diff --git a/crates/clazel-x509/README.md b/crates/clazel-x509/README.md index 81cbcc8..dd09e9e 100644 --- a/crates/clazel-x509/README.md +++ b/crates/clazel-x509/README.md @@ -4,8 +4,9 @@ X.509 certificate decoding, RFC 9525 name matching and the root certificate table for the Clazel browser. Part of [Clazel](../../README.md), a web browser whose parsers of untrusted input carry machine-checked proofs. The tier and its status are in `Cargo.toml` and the -[status table](../../README.md#verification-status); this README covers only -the root table, which is plain data and not part of any proof. +[status table](../../README.md#verification-status); this README covers +the root table, which is plain data and not part of any proof, and the +x509-limbo harness. ## The root table (`roots`) @@ -73,3 +74,25 @@ and the `include_str!` and `ROOT_COUNT` in `tests/trust_store.rs` at it, run `cargo xtask tables`, and commit the result. Review the diff of the table: a root added to or removed from NSS's trust is a change to what the browser trusts. + +## x509-limbo harness (`tests/conformance_limbo.rs`) + +The x509-limbo corpus (C2SP, Apache-2.0; 9,802 testcases, 30,379 distinct +certificates) is vendored byte for byte in `tests/data/x509-limbo/` and reduced +by `cargo xtask testdata` to a testcase index and a binary file of DER +certificates under `tests/generated/` (`cargo xtask check` fails if either is +stale). + +What the harness covers: every distinct certificate goes through every decoder +(envelope, signature algorithm, TBS, SPKI, extensions, SAN, BasicConstraints, +KeyUsage, ExtendedKeyUsage, NameConstraints) without panicking, with the +accepted counts pinned; every `SERVER` testcase that expects `SUCCESS` for a DNS +or IP name has a leaf that `check_leaf_certificate` accepts (RFC 9525 match, +validity, EKU, key usage), and none of its certificates is rejected by a decoder. + +What it does not cover: limbo's chain-validation verdicts. There is no path +validation yet, so every other testcase is listed by id, with a reason, in +`tests/limbo/not_yet_supported.rs`; the test fails if an id appears or vanishes, +or if a listed case starts passing. Two server-leaf cases (`rfc5280::ca-as-leaf`, +`pathlen::validation-ignores-pathlen-in-leaf`) are listed because the leaf +policy rejects a CA certificate as an end entity, where limbo follows RFC 5280. diff --git a/crates/clazel-x509/tests/conformance_limbo.rs b/crates/clazel-x509/tests/conformance_limbo.rs new file mode 100644 index 0000000..4253a99 --- /dev/null +++ b/crates/clazel-x509/tests/conformance_limbo.rs @@ -0,0 +1,365 @@ +//! x509-limbo conformance (docs/phases/phase-3.md item 3.5b), as far as +//! clazel-x509 goes today. +//! +//! clazel-x509 has no path validation yet, so limbo's chain verdicts are not +//! run. What this file does with the corpus (C2SP/x509-limbo, Apache-2.0, +//! vendored in full under `tests/data/x509-limbo/` and reduced by +//! `cargo xtask testdata` to `tests/generated/x509_limbo.rs`, the testcase +//! index, and `x509_limbo_certs.bin`, every distinct certificate as DER): +//! +//! 1. Runs the decoders on every distinct certificate of the corpus +//! (leaves, intermediates and trust anchors): envelope, TBS, SPKI, +//! extensions, and the SAN, BasicConstraints, KeyUsage, ExtendedKeyUsage +//! and NameConstraints extension decoders, plus signature-algorithm +//! classification. None may panic, and the number of certificates each +//! stage accepts is pinned in `DECODE_COUNTS`, so a decoder change that +//! moves it is noticed. +//! 2. Pins the one outcome limbo's expectations decide for a decoder: a +//! `SERVER` testcase that expects `SUCCESS` for a DNS or IP peer name has +//! a leaf that `check_leaf_certificate` (envelope, TBS, extensions, the +//! RFC 9525 SAN match, validity at the testcase's time, EKU, key usage +//! and BasicConstraints leaf role) accepts for that name at that time. +//! 3. Accounts for every other testcase in `NOT_YET_SUPPORTED` +//! (`tests/limbo/not_yet_supported.rs`), by id, with a reason. The test +//! fails if a corpus id is neither pinned nor listed, if a listed id is not +//! in the corpus, if a listed testcase now passes its pin, or if a pinned +//! testcase fails and is not listed. The list shrinks as path validation +//! lands; limbo's `FAILURE` verdicts cannot be pinned before then, since +//! most rest on chain building, trust, policy or CRLs, not on one decoder. + +use std::net::IpAddr; + +use clazel_x509::{ + certificate::exec::parse_certificate, + constraints::exec::{parse_basic_constraints, parse_extended_key_usage, parse_key_usage}, + extensions::exec::{parse_extensions, parse_subject_alt_name}, + leaf::exec::{LeafPolicy, check_leaf_certificate}, + matcher::ReferenceIdentity, + name_constraints::exec::parse_name_constraints, + signature_algorithm::exec::classify, + spki::exec::parse_subject_public_key_info, + tbs::exec::parse_tbs_certificate, + time::exec::CertificateTime, +}; + +/// One testcase of the index. +struct Case { + id: &'static str, + kind: &'static str, + expected: &'static str, + peer: (&'static str, &'static str), + peer_names: &'static [(&'static str, &'static str)], + time: &'static str, + features: &'static [&'static str], + importance: &'static str, + trusted: &'static [usize], + intermediates: &'static [usize], + leaf: usize, +} + +// `TESTCASE_COUNT`, `CERT_SPANS` and `CASES`, generated from the vendored file. +include!("generated/x509_limbo.rs"); + +// `NOT_YET_SUPPORTED`: (testcase id, reason), checked in by hand. +include!("limbo/not_yet_supported.rs"); + +static CERTS: &[u8] = include_bytes!("generated/x509_limbo_certs.bin"); + +fn cert(index: usize) -> Option<&'static [u8]> { + let &(offset, length) = CERT_SPANS.get(index)?; + let start = usize::try_from(offset).ok()?; + let end = start.checked_add(usize::try_from(length).ok()?)?; + CERTS.get(start..end) +} + +/// `YYYY-MM-DDTHH:MM:SS+00:00` (all of limbo's times are UTC). +fn parse_time(text: &str) -> Option { + let body = text.strip_suffix("+00:00")?; + let (date, clock) = body.split_once('T')?; + let mut d = date.split('-'); + let mut c = clock.split(':'); + let time = CertificateTime { + year: d.next()?.parse().ok()?, + month: d.next()?.parse().ok()?, + day: d.next()?.parse().ok()?, + hour: c.next()?.parse().ok()?, + minute: c.next()?.parse().ok()?, + // Fractional seconds (`...:00.005`) are truncated, as RFC 5280 time + // has whole-second precision. + second: c.next()?.split('.').next()?.parse().ok()?, + }; + (d.next().is_none() && c.next().is_none()).then_some(time) +} + +const SAN: &[u64] = &[2, 5, 29, 17]; +const KEY_USAGE: &[u64] = &[2, 5, 29, 15]; +const BASIC_CONSTRAINTS: &[u64] = &[2, 5, 29, 19]; +const NAME_CONSTRAINTS: &[u64] = &[2, 5, 29, 30]; +const EXTENDED_KEY_USAGE: &[u64] = &[2, 5, 29, 37]; + +/// For each decoder stage of `STAGES`, how many corpus certificates it applied +/// to and how many it accepted, as of this commit's decoders. +const DECODE_COUNTS: &[(usize, usize)] = &[ + (30379, 30379), + (30379, 30379), + (30379, 30375), + (30375, 30374), + (30374, 30373), + (9098, 8545), + (30158, 30158), + (30369, 30368), + (9818, 9817), + (9458, 9453), +]; + +/// Decoder stages, in the order of `DECODE_COUNTS`. Each counts how many +/// certificates the stage was applicable to and how many it accepted. +const STAGES: &[&str] = &[ + "envelope", + "signature algorithm classified", + "tbs", + "spki", + "extensions", + "subjectAltName", + "basicConstraints", + "keyUsage", + "extKeyUsage", + "nameConstraints", +]; + +/// Run every decoder on one certificate. Entry `i` is `None` when stage `i` +/// did not apply (an earlier stage failed or the extension is absent), and +/// otherwise whether it accepted. +fn decode(der: &[u8]) -> Vec> { + let mut out: Vec> = vec![None; STAGES.len()]; + let mut set = |stage: usize, ok: bool| { + if let Some(slot) = out.get_mut(stage) { + *slot = Some(ok); + } + }; + let Some(envelope) = parse_certificate(der) else { + set(0, false); + return out; + }; + set(0, true); + set(1, classify(&envelope.signature_algorithm).is_some()); + let Some(tbs) = parse_tbs_certificate(envelope.tbs_certificate_der) else { + set(2, false); + return out; + }; + set(2, true); + set( + 3, + parse_subject_public_key_info(tbs.subject_public_key_info_der).is_some(), + ); + let Some(sequence) = tbs.extensions_sequence_der else { + return out; + }; + let Some(extensions) = parse_extensions(sequence) else { + set(4, false); + return out; + }; + set(4, true); + for e in &extensions { + let oid = e.oid.as_slice(); + if oid == SAN { + set(5, parse_subject_alt_name(e.value).is_some()); + } else if oid == BASIC_CONSTRAINTS { + set(6, parse_basic_constraints(e.value).is_some()); + } else if oid == KEY_USAGE { + set(7, parse_key_usage(e.value).is_some()); + } else if oid == EXTENDED_KEY_USAGE { + set(8, parse_extended_key_usage(e.value).is_some()); + } else if oid == NAME_CONSTRAINTS { + set(9, parse_name_constraints(e.value).is_some()); + } + } + out +} + +/// What the pin says about a testcase. +enum Pin { + /// Limbo's expectations decide nothing for the decoders. + None, + /// The leaf must be accepted for this peer at this time. + Accept, +} + +fn pin_of(case: &Case) -> Pin { + let named = matches!(case.peer.0, "DNS" | "IP"); + if case.kind == "SERVER" && case.expected == "SUCCESS" && named { + Pin::Accept + } else { + Pin::None + } +} + +/// Whether `check_leaf_certificate` accepts the testcase's leaf for its peer +/// name at its validation time. `None` when the testcase gives no usable +/// name, or a time that does not parse. +fn leaf_accepted(case: &Case) -> Option { + let der = cert(case.leaf)?; + // Limbo leaves the time out of some testcases (`time` is empty); the leaf + // is then checked at its own notBefore, which its validity includes. + let now = if case.time.is_empty() { + let envelope = parse_certificate(der)?; + parse_tbs_certificate(envelope.tbs_certificate_der)?.not_before + } else { + parse_time(case.time)? + }; + let policy = LeafPolicy { + allow_any_extended_key_usage: false, + }; + let accepted = |reference: ReferenceIdentity<'_>| { + check_leaf_certificate(der, reference, &now, policy) + .is_some_and(|r| r.identity_matched && r.valid_at_captured_time) + }; + Some(match case.peer { + ("DNS", name) => accepted(ReferenceIdentity::Dns(name.as_bytes())), + ("IP", text) => match text.parse::().ok()? { + IpAddr::V4(a) => accepted(ReferenceIdentity::Ip(&a.octets())), + IpAddr::V6(a) => accepted(ReferenceIdentity::Ip(&a.octets())), + }, + _ => return None, + }) +} + +#[test] +#[cfg_attr(miri, ignore)] +fn limbo_corpus_decodes_without_panic_and_pins_what_it_decides() { + let mut problems: Vec = Vec::new(); + + // The index and the certificate file agree with each other. + if CASES.len() != TESTCASE_COUNT { + problems.push(format!( + "{} cases, but the converter counted {TESTCASE_COUNT}", + CASES.len() + )); + } + for (i, _) in CERT_SPANS.iter().enumerate() { + if cert(i).is_none() { + problems.push(format!("certificate {i} lies outside the certificate file")); + } + } + let used = |idx: usize| idx < CERT_SPANS.len(); + for c in CASES { + let all = std::iter::once(&c.leaf) + .chain(c.trusted) + .chain(c.intermediates); + if !all.copied().all(used) { + problems.push(format!("{}: certificate index out of range", c.id)); + } + } + + // 1. Every certificate through every decoder. + let mut counts = vec![(0usize, 0usize); STAGES.len()]; + for i in 0..CERT_SPANS.len() { + let Some(der) = cert(i) else { continue }; + for (slot, outcome) in counts.iter_mut().zip(decode(der)) { + if let Some(ok) = outcome { + slot.0 = slot.0.saturating_add(1); + slot.1 = slot.1.saturating_add(usize::from(ok)); + } + } + } + for (stage, (applicable, accepted)) in STAGES.iter().zip(&counts) { + println!("limbo decode: {stage}: accepted {accepted} of {applicable}"); + } + if counts.as_slice() != DECODE_COUNTS { + problems.push(format!( + "decode counts changed: now {counts:?}, pinned {DECODE_COUNTS:?}" + )); + } + + for c in CASES.iter().filter(|c| c.expected == "SUCCESS") { + let all = std::iter::once(&c.leaf) + .chain(c.trusted) + .chain(c.intermediates); + for &i in all { + if cert(i).is_some_and(|der| decode(der).contains(&Some(false))) { + problems.push(format!( + "{}: expects SUCCESS, but certificate {i} is rejected by a decoder", + c.id + )); + } + } + } + // 2 and 3. Pins and the not-yet-supported list. + let mut listed: std::collections::BTreeMap<&str, &str> = std::collections::BTreeMap::new(); + for (id, reason) in NOT_YET_SUPPORTED { + if listed.insert(id, reason).is_some() { + problems.push(format!("{id}: listed twice")); + } + } + let mut seen = std::collections::BTreeSet::new(); + let (mut pinned_pass, mut listed_count, mut case_fail) = (0usize, 0usize, 0usize); + for c in CASES { + if !seen.insert(c.id) { + problems.push(format!("{}: duplicate id in the corpus", c.id)); + } + let is_listed = listed.contains_key(c.id); + listed_count = listed_count.saturating_add(usize::from(is_listed)); + match pin_of(c) { + Pin::None if !is_listed => { + case_fail = case_fail.saturating_add(1); + problems.push(format!( + "{}: new testcase: neither pinned nor in NOT_YET_SUPPORTED", + c.id + )); + } + Pin::None => {} + Pin::Accept => match leaf_accepted(c) { + Some(true) if is_listed => { + // Counted below as listed; the stale entry fails the run. + problems.push(format!( + "{}: listed as not yet supported, but its pin now passes: remove it from the list", + c.id + )); + } + Some(true) => pinned_pass = pinned_pass.saturating_add(1), + Some(false) | None if is_listed => {} + Some(false) | None => { + case_fail = case_fail.saturating_add(1); + problems.push(format!( + "{}: limbo expects SUCCESS for {:?} at {}, but the leaf is rejected", + c.id, c.peer, c.time + )); + } + }, + } + } + for id in listed.keys() { + if !seen.contains(id) { + problems.push(format!("{id}: listed, but no longer in the corpus")); + } + } + println!( + "limbo: {} testcases, {pinned_pass} pinned and passing, {listed_count} not yet supported", + CASES.len() + ); + // One unit per testcase: a pin that passes, a listed testcase (an + // expected failure, with its reason in NOT_YET_SUPPORTED), or a + // testcase that is neither (xtask/src/conformance.rs). + println!( + "clazel-conformance: suite=\"x509-limbo leaf checks\" pass={pinned_pass} xfail={listed_count} fail={case_fail} total={}", + CASES.len() + ); + let reasons: std::collections::BTreeSet<&&str> = listed.values().collect(); + for r in reasons { + let n = listed.values().filter(|v| *v == r).count(); + println!("limbo not yet supported: {n}: {r}"); + } + // The index's other fields have the shapes the converter promises. + for c in CASES { + let names_ok = c + .peer_names + .iter() + .all(|(k, _)| matches!(*k, "DNS" | "IP" | "RFC822")); + let known = matches!(c.importance, "undetermined" | "low" | "high" | "critical"); + if !names_ok || !known || c.features.iter().any(|f| f.is_empty()) { + problems.push(format!("{}: unexpected index fields", c.id)); + } + } + problems.truncate(40); + assert!(problems.is_empty(), "limbo: {}", problems.join("\n")); +} diff --git a/crates/clazel-x509/tests/data/x509-limbo/LICENSE.md b/crates/clazel-x509/tests/data/x509-limbo/LICENSE.md new file mode 100644 index 0000000..62589ed --- /dev/null +++ b/crates/clazel-x509/tests/data/x509-limbo/LICENSE.md @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + https://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/crates/clazel-x509/tests/data/x509-limbo/SOURCE.md b/crates/clazel-x509/tests/data/x509-limbo/SOURCE.md new file mode 100644 index 0000000..70cfd51 --- /dev/null +++ b/crates/clazel-x509/tests/data/x509-limbo/SOURCE.md @@ -0,0 +1,46 @@ +# x509-limbo: path-validation testcases for X.509 implementations + +Upstream: https://github.com/C2SP/x509-limbo +Commit: 1080e565f26e544bbe9cf99953be8a57c08e7e20 +License: Apache-2.0 (`LICENSE.md`, copied from `LICENSE` at the root of the repository) + +Commit date: not recorded by this download; it is the head of upstream's +default branch when vendored on 2026-10-26. + +The upstream README says "Apache-2.0 / MIT", but the repository ships only the +Apache-2.0 text (`LICENSE`); `LICENSE-APACHE` and `LICENSE-MIT` do not exist at +this commit. We vendor the one licence text that exists. + +Files, copied byte for byte from that commit (fetched from +`https://github.com/C2SP/x509-limbo/raw//`): + +| Here | SHA-256 | Size | +|------|---------|------| +| `limbo.json` | `611e337b9fb477b927bae65434650692cb9d2070ff5b05f975d0403510acd4de` | 41,791,455 bytes | +| `LICENSE.md` | `aac73b3148f6d1d7111dbca32099f68d26c644c6813ae1e4f05f6579aa2663fe` | 11,360 bytes | + +`limbo.json` is the whole published corpus: 9,802 testcases (9,572 `bettertls`, +109 `rfc5280`, 56 `webpki`, and a few dozen `crl`, `pathlen`, `pathological`, +`online`, `rfc9881`, `cve` and `invalid` cases) and 30,379 distinct +certificates. It was vendored in full, byte for byte, on Alex's decision to +raise the 20 MB cap for this file. + +`xtask/src/testdata/x509_limbo.rs` reduces it to two derived files, which are +ours and reproducible (`cargo xtask check` fails if either is stale), so no +Rust source holds 41.8 MB of literals: + +- `tests/generated/x509_limbo.rs`: an index of the testcases (id, validation + kind, expected result and peer name, validation time, features, + importance, and the certificates of each as indices); +- `tests/generated/x509_limbo_certs.bin`: the distinct certificates as DER, + concatenated; the index gives each one's offset and length. + +Both are read by `tests/conformance_limbo.rs`, which does not run limbo's +validation verdicts: clazel-x509 has no path validation yet. See the crate +README for what it does cover. + +To update, download `limbo.json` and `LICENSE` from a newer commit into an +empty directory, copy them here, change the commit, size and hashes above, run +`cargo xtask testdata`, and update `NOT_YET_SUPPORTED` in +`tests/conformance_limbo.rs` (the test names every id that appeared or +vanished). diff --git a/crates/clazel-x509/tests/data/x509-limbo/limbo.json b/crates/clazel-x509/tests/data/x509-limbo/limbo.json new file mode 100644 index 0000000..f6a87ae --- /dev/null +++ b/crates/clazel-x509/tests/data/x509-limbo/limbo.json @@ -0,0 +1,285104 @@ +{ + "version": 1, + "testcases": [ + { + "id": "crl::structure::crl-invalid-signature", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "undetermined", + "description": "Tests an invalid CRL that revokes the leaf but has a signature that does not\ncorrespond to the root.\n\nThe CRL claims to be issued by the root CA (matching issuer name and AKI),\nbut is actually signed by a random ephemeral key.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIULh9bcllDv+SlLONvneoCC6D7GRkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQHUwBRRSrakGkG1ntw7XnrR/onGXAUG3oAqZtk\nY7Q/xOEPObnSR//420ChzNX/hSWwmG6fJMR9NIQ2YYi7TvKAo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUU20JZL6xVO4Arte4EevH9aCSxQgwCgYIKoZIzj0EAwIDSAAwRQIh\nAIuKluMAXgapUd7C+gz2Fc8d3CQ7a30YadpPk5WX+LGfAiAHp/am0L4rfVKBnvno\nl1fYp7IBP18iSoIOY4CP/mrJJQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUdUwWzQv9YEX5H0UYirQZDlSYdkEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABK4xWuJEtxgI+z76KC6KWyup7DXV+9rCcPgI35IXnGR0\n0AbhZVCydrPVG5uAB9J50Bf4KqL0bmR/Ja/xBG54sR6jfDB6MB0GA1UdDgQWBBSz\nzyeVgryl/Hluru9XFWQCAOVm4jAfBgNVHSMEGDAWgBRTbQlkvrFU7gCu17gR68f1\noJLFCDALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhALBu2dOkvGg3OlMiLinY\ne1/R5ZN4om/4rgjWXd7zb5EjAiBQfMFG6Y/8Ah6U+UfATwUNDtXWTZuXJSDt03tq\nZD9LsA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIEglqJYYVcpzWYzcm8kkMQkNcph7yyaSEhnTAwNqo75koAoGCCqGSM49\nAwEHoUQDQgAErjFa4kS3GAj7PvooLopbK6nsNdX72sJw+AjfkhecZHTQBuFlULJ2\ns9Ubm4AH0nnQF/gqovRuZH8lr/EEbnixHg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIIBADCBpgIBATAKBggqhkjOPQQDAjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJv\nb3QXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAwMDAxWjAnMCUCFCEupHNVCLqF\nQXihtmehY43jJAYoFw0yMzEyMzEwMDAwMDBaoDAwLjAfBgNVHSMEGDAWgBRTbQlk\nvrFU7gCu17gR68f1oJLFCDALBgNVHRQEBAICBTkwCgYIKoZIzj0EAwIDSQAwRgIh\nALjGOubpDsYffiWjU50U3acSSGB5BCRbZOayc/8KJAYDAiEA6pn1jdwJKdCuro/u\ndvwTecn1Od5SHIRlz/2up074/Gg=\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::structure::crl-wrong-signing-key", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "undetermined", + "description": "Tests that an invalid CRL signed by the wrong key is rejected.\n\nTwo root CAs are trusted. The CRL's issuer name matches root_ca_1 but the\nCRL is signed with root_ca_2's key. Validators MUST reject the CRL because\nthe signature does not verify against root_ca_1's public key.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBgzCCASmgAwIBAgIUBL2/RfqQwYDfBNnANyvuWPJDOj4wCgYIKoZIzj0EAwIw\nFDESMBAGA1UEAwwJUm9vdCBDQSAxMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAz\nMDAwMDAxWjAUMRIwEAYDVQQDDAlSb290IENBIDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS2ZuhlUqGREsieOyTzohhu5musqchXVe2b+5d2ChraTlFIav+2/7fW\npy7UY4KwPhPk/V1Vi9dltGNnBwsDUCgSo1cwVTAPBgNVHRMBAf8EBTADAQH/MAsG\nA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAdBgNVHQ4EFgQUCbcz\ndFUU/n7+C4/tN9Nm+dJVtQAwCgYIKoZIzj0EAwIDSAAwRQIgMhTwHwSfsMOGEU1s\naZ9egJK1hE3n6Qpttien35v792kCIQC43UGgEtV3nLpdPqu2xePEG1qSu8nNabp2\nW/A/FnbS0w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBgjCCASmgAwIBAgIUB/3ffKd7jmNV4cLhC6DeO/aRrqEwCgYIKoZIzj0EAwIw\nFDESMBAGA1UEAwwJUm9vdCBDQSAyMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAz\nMDAwMDAxWjAUMRIwEAYDVQQDDAlSb290IENBIDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQfvm5krJpNwpQ9CMjR6ercvP8I63DNugsSabWXI+GCxE082QZVbqBX\nE7qzAwYOy5FMLpp2okIrgX6Ob3VyFOn7o1cwVTAPBgNVHRMBAf8EBTADAQH/MAsG\nA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAdBgNVHQ4EFgQUd1xI\n3u/CXAbROk/1IKp/dfZ91CkwCgYIKoZIzj0EAwIDRwAwRAIgRc1L0ePpFOTlUDUI\nBI8xBJNPzMgSvPktV44JrU+sk3wCIARj+AJAviQFFURlkk1TP0BqCSo0lKknu6GT\nUj0VGRHl\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBqjCCAVCgAwIBAgIURfghw/jh6/8I2eA1bbsv8IkkTHwwCgYIKoZIzj0EAwIw\nFDESMBAGA1UEAwwJUm9vdCBDQSAxMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAz\nMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqG\nSM49AwEHA0IABJrjMkjnLxd9/i7Q9JtHJhBHxvNVxRRRk4bL5lOIP19qNe4VeyZR\nkcdCtJQxV3+z8TOizy6l4+GW4mriwFWCXR2jfDB6MB0GA1UdDgQWBBTC1kXXuNe+\npP8dNWJdqMYGCgqSrjAfBgNVHSMEGDAWgBQJtzN0VRT+fv4Lj+0302b50lW1ADAL\nBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhh\nbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgEAPLzHJi2tPr0UJp6yxGQ9p8I5FV\ngl+4tRVNaiHKP5kCIQDHDjHP3wbMvcot3B2H1iifZDJDYKSWIQnFilfd0YUXAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIOX59v6cgxQi5qGKH8ejP/W5g2bd3WO0eIM3WPKg61proAoGCCqGSM49\nAwEHoUQDQgAEmuMySOcvF33+LtD0m0cmEEfG81XFFFGThsvmU4g/X2o17hV7JlGR\nx0K0lDFXf7PxM6LPLqXj4ZbiauLAVYJdHQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIH5MIGgAgEBMAoGCCqGSM49BAMCMBQxEjAQBgNVBAMMCVJvb3QgQ0EgMRcNNzAw\nMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMCcwJQIUBuGcaGgc5OVIOqx/G4Sh\nL6r0vPoXDTIzMTIzMTAwMDAwMFqgMDAuMB8GA1UdIwQYMBaAFHdcSN7vwlwG0TpP\n9SCqf3X2fdQpMAsGA1UdFAQEAgIFOTAKBggqhkjOPQQDAgNIADBFAiAwaA9p6o68\n0sd9w4SO3lV0LSELXK/cxdDaZhU2ljwL4AIhALL+fqaqIh6otNr0uIal9Jpr5O8A\nHy4QntN4JDzsoHXs\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::structure::crl-empty", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "undetermined", + "description": "Tests that an valid but empty CRL (with no revocation entries) is accepted.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUR4PLmBaj+r6vpE6qMSasJ4HX+7kwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASurIqFThBrrfQkT5NZ3NyGjGrIp9F2sjCECvG6\nutdenxYhdeKsEEX8dryqGPvoRNefwqXWVe+yzGcePZRinFnLo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUHzjF/rZ/3Mqur1u5baVBgeYIDFUwCgYIKoZIzj0EAwIDSAAwRQIh\nAPEVtdNVSpDS3gZPp5bfl7M5gQ8gV++l0fo8qMoFG8YnAiAzFOFxlM6Y9rUcS5M/\nwhFY31az2TOVQhBpmwWwk0hruA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUXgQgY6C9SZBmquq+HF0F6sOEqZMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABJdkW3pqxMbOzwtFIXdCy8+4SMjua7zZF2InubOmmWLY\n31mEL55zDvT/eCDYWmIFgZsXthFwvPOnWCIjy/HGJKajfDB6MB0GA1UdDgQWBBSE\nVqrFoLjOTqJbFmTq1cwpwOnXUjAfBgNVHSMEGDAWgBQfOMX+tn/cyq6vW7ltpUGB\n5ggMVTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAK6pHse5y1j1hpMvm62V\nlhM8tvpYsXfAJIWuj5J85E4cAiAkNfEFkDGwBy0lErDTXM44ZWD/5kUEFgCp+a9U\nmOyfTg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDqhotjLCA46+WJTNsYFANySNg0hbRo20a2/QcQapFnooAoGCCqGSM49\nAwEHoUQDQgAEl2RbemrExs7PC0Uhd0LLz7hIyO5rvNkXYie5s6aZYtjfWYQvnnMO\n9P94INhaYgWBmxe2EXC886dYIiPL8cYkpg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIHVMH0CAQEwCgYIKoZIzj0EAwIwGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290\nFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVqgMDAuMB8GA1UdIwQYMBaA\nFB84xf62f9zKrq9buW2lQYHmCAxVMAsGA1UdFAQEAgIFOTAKBggqhkjOPQQDAgNI\nADBFAiBYD2gOcn9STlDsvJ+zSRcbv0i1nbv0DSGpOQK3fzUEhQIhAObQsmVZZmM6\nQ2Or9pVYBoEtw8tMR4cehogEtkpEUoux\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::structure::crl-very-large", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "undetermined", + "description": "Tests that a valid CRL with 10,000 revoked entries is accepted.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUfMmfMv2ddZUKtM+WllXJ99YbNZQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQ51A/FDiFzhRwVBGbdYRylvSuZxVzNR8MAtt+J\nQfOyLXkJBKmyfZX73/Ltz1+SDS08xtJDZZ2Cb7mZVlcbefZro1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUM6mo4WSWhXCN3feNDRp6wr1OQ4cwCgYIKoZIzj0EAwIDSQAwRgIh\nAPNL9tIGdRe13kR35lEGdC25U8p9uO6Pu7hiFur5XfiwAiEA6U4WAs2d7phzqCtJ\nnDbrIPNNbkd4VZXZ7AkTn0biAYY=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUfF0Znzav0ZYa1KRyZ7r9MJcAxeswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABCSN0F7eoKWlMtkDwO4pfmxYjt3txD+q3D7iVKedRouR\nTKJRWIKq4e7vUyYv82hE48vBzYlcnX2/lE/fc1m58bajfDB6MB0GA1UdDgQWBBSs\ngW+Et+wMg4plcz+zJSjf+Zb8TzAfBgNVHSMEGDAWgBQzqajhZJaFcI3d940NGnrC\nvU5DhzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgUtRScP0Bt9g9eJtIT1Bl\nXXnFSFfgrhBXaoDsKbWhgUQCIQD+x+Gqay5nReKvUSfywg5c567PhSH95J3EHt+5\nUPWlxg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILQQxM30IOVGtLd0+aPexHb+d66iJaY2WfB6b8FJA378oAoGCCqGSM49\nAwEHoUQDQgAEJI3QXt6gpaUy2QPA7il+bFiO3e3EP6rcPuJUp51Gi5FMolFYgqrh\n7u9TJi/zaETjy8HNiVydfb+UT99zWbnxtg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----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\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::structure::crl-duplicate-revoked-serial", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "undetermined", + "description": "Tests that a CRL with a duplicate revoked serial number is rejected.\n\nFor more context, see .", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUTV3v97dBlcjKDjL79TfeDwfwIk8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQ4QCIYdcs8UJWHH0OKpv2s1eU5BZrIYqvnoPWY\nwcLnPnyRkH5sCqdItINwsLJxDeQKe7/KIGqDO2nsYsCVE6vGo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUhKpC0cqpMJ+ugBgjQD9rz6SW9uUwCgYIKoZIzj0EAwIDSAAwRQIg\nG4xC84XZBNXMB3ZS0wta8ZjFNvq0YySfz09LIEkxc9sCIQCcEAgVifGDX9/14Bnx\n1n4ky2SHoql1HDUdKUUuFaYeFQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUPkcTgX54oGKQVA8i1t2AOIEcBnEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABCn8xNF2KtqBUcnjki63aQdh0GGpK4OIxb4b3pvy6W7+\n6WdOHMbNC1xYfr9ZwAEl6kVcA9aobnvHUQCKewHCNAujfDB6MB0GA1UdDgQWBBRC\n6ghbq2NbDtLl4dPz+YTEFrUjqTAfBgNVHSMEGDAWgBSEqkLRyqkwn66AGCNAP2vP\npJb25TALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAO1c8cM3Elkl6DYLN/6D\neLVx+WmBJ4Rvyk4H0rKNFvBpAiBGC3F7WMzrB2Mw1vdBCaNmyDvdi3Fq6ZbBjI+7\nflx4wg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIONV+Spp2qG3ERzG+lrW4acFNRI2nO/tcU3yNJ3w4vqGoAoGCCqGSM49\nAwEHoUQDQgAEKfzE0XYq2oFRyeOSLrdpB2HQYakrg4jFvhvem/Lpbv7pZ04cxs0L\nXFh+v1nAASXqRVwD1qhue8dRAIp7AcI0Cw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIIBJjCBzQIBATAKBggqhkjOPQQDAjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJv\nb3QXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAwMDAxWjBOMCUCFDHDwagbLKUU\nV8RozEz3c7g4ZkUxFw0yMzEyMzEwMDAwMDBaMCUCFDHDwagbLKUUV8RozEz3c7g4\nZkUxFw0yMzEyMzEwMDAwMDBaoDAwLjAfBgNVHSMEGDAWgBSEqkLRyqkwn66AGCNA\nP2vPpJb25TALBgNVHRQEBAICBTkwCgYIKoZIzj0EAwIDSAAwRQIhAIibutGtBLc6\nXYYglaFFSsq7uxWAXy57Hp+kMpS6S7BvAiAC6ml3PvCQSFMfFcLY3VtsFnJxSOxK\nPHhd8fEoQDggUg==\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::structure::crl-unknown-critical-extension", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "undetermined", + "description": "Tests that a CRL with an unknown critical extension is rejected.\n\nPer RFC 5280 5.2, CRLs that contain unknown critical extensions MUST NOT be\nused to determine the revocation status of certificates.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUSSg9+9fZpd2IBudukyQusIEn1rcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQ8XpxPd7JGK56YDkpS3cvJpG6Y2+dOCBFwz9jl\niov5kKTzIGZFJt/CNLLX8Tr1ppRgwGSna1oPYNqCw0ApEogVo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUzppi11ZJwh6cJTmr07Qy+pztwEQwCgYIKoZIzj0EAwIDSQAwRgIh\nAOPfYzc/1Rb6z5aGkKWkbcoYArafZjqMabJc/zBfTHupAiEAoZN3+H4VcSFyQkIy\nbmTz+jx1af6C2ZAKgnMJBTK2THQ=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUDKalQbDov55pMQhq6oOYTcFNFt0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABG7PBZLC93egecFMlAf0tXkvT1mbUfbxiaLgu5t1mc6M\nDH0Y2veR64KhGdg2NdKlQSjuUbg0cncWcff72Tti59WjfDB6MB0GA1UdDgQWBBQY\nSgdpsdVtl6MxCqywdX+CXQ4cPDAfBgNVHSMEGDAWgBTOmmLXVknCHpwlOavTtDL6\nnO3ARDALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgKcqN9bTBu0rqzNejQBUf\nhmXPUThgCGz9Z0de97dKH/cCIB3Fu6DL5Zl2xwllwsgtqkh9qeieY7iR5AkNJOb1\n4Fin\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIJqijCH2IrTkaT7AJtLTsBEVZg89l3jBC8V/EoqtXVKyoAoGCCqGSM49\nAwEHoUQDQgAEbs8FksL3d6B5wUyUB/S1eS9PWZtR9vGJouC7m3WZzowMfRja95Hr\ngqEZ2DY10qVBKO5RuDRydxZx9/vZO2Ln1Q==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIIBEjCBugIBATAKBggqhkjOPQQDAjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJv\nb3QXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAwMDAxWjAnMCUCFB7ytKcuNbim\nBkc5VhT1HWNhaYqwFw0yMzEyMzEwMDAwMDBaoEQwQjAfBgNVHSMEGDAWgBTOmmLX\nVknCHpwlOavTtDL6nO3ARDALBgNVHRQEBAICBTkwEgYLKwYBBAGDszqFGgEBAf8E\nADAKBggqhkjOPQQDAgNHADBEAiBaakqfYamxIAbCCB9xs+rjiHiAqmZT6xSu6q6p\n6vPclgIgMR69UX2Z/MbmuCQthOusj3r97lhssYGi7ocyTouvX88=\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::structure::crl-unknown-noncritical-extension", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "undetermined", + "description": "Tests that a CRL with an unknown non-critical extension is accepted.\n\nPer RFC 5280 5.2, unknown non-critical extensions MUST be ignored. The CRL\nshould be accepted by the validator and the chain should build.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUYG+Rymb38vBkR31pv4iMDZ0V3SQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASzbMB9c76GzALYjobPU4Mpip/i/KIC3Kkbihut\ny0Pxai2aEetdCGdxeGa7EBkXLip0xop/65SXzyLsuMKEgmW/o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUcrDBsGvjD2z7b5tbWqlm/hvY2tAwCgYIKoZIzj0EAwIDSAAwRQIg\nS3RCQY98GEULanvhembSFxEvdD4oIuGg3luxVoHAbF8CIQCNTW6M+MTRzheqmigl\nl4gtUM7UepDjdgzIynIgfL/n0w==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUAegp96Ijt9B3NN1AbVGurpJJF5kwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABJ7jA5B78dwTVx12In80uloRR19jfRiRSKRfptIZPdsw\nrFsNcqBN0HvdiiHPvwx/bpknV+OF0B/9HkBt8ERCPZejfDB6MB0GA1UdDgQWBBQn\nb9Syc7biYWrYiiyC8UolRtRi6TAfBgNVHSMEGDAWgBRysMGwa+MPbPtvm1taqWb+\nG9ja0DALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgJItkVo+ayMeLMzVEXvU7\nVRSDyNdDupuwMWNsDaKyBNACIQDVqZ/+RDKJhJySbpkng3mDYOl4Oy0hzNAUtReN\nrfGg9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIHntbveus/dGXxeyulVkNIlCjQcwLLbR1yZWGGLSR4kKoAoGCCqGSM49\nAwEHoUQDQgAEnuMDkHvx3BNXHXYifzS6WhFHX2N9GJFIpF+m0hk92zCsWw1yoE3Q\ne92KIc+/DH9umSdX44XQH/0eQG3wREI9lw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIIBETCBtwIBATAKBggqhkjOPQQDAjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJv\nb3QXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAwMDAxWjAnMCUCFBKOicooRONF\nHXQZq/nx2MOPEEIAFw0yMzEyMzEwMDAwMDBaoEEwPzAfBgNVHSMEGDAWgBRysMGw\na+MPbPtvm1taqWb+G9ja0DALBgNVHRQEBAICBTkwDwYLKwYBBAGDszqFGgEEADAK\nBggqhkjOPQQDAgNJADBGAiEAhprCu7r0AHeo6SJmiSF0kA8M6h2rFqnlvBcoly69\nzncCIQDIzbcUTMD8Urxb5Cupo+A1BOEOhYdBX/hMHrSOiRz5/A==\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::structure::entry-unknown-critical-extension", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "undetermined", + "description": "Tests that a CRL entry with an unknown critical extension is rejected.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUVka+yASuykofn0DUtBrpmEuNBSEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQgi8DxPVtvlil3hYkebqNRL2k2xN401v1ob91n\nuVuSOjBxlewwImqYgnc9Hzz7MHnvjWcFS1J88l2aHN8lxIrko1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUGT/N0Vc7DrfrHlw7NmylpCS4WeowCgYIKoZIzj0EAwIDSAAwRQIh\nAMtjcDpSaDBAqsGiifgvyogd1uZHU7ZSYF+NV0aFOwmSAiABMu9BCWTxQDNWP7+z\nyl1e0tRcI74CLVV8+saVWdNdTQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVagAwIBAgIUT5OmblUlUwKl2+q3tAoPSUJCjsQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABBTjhCsHFaprr/OgOeGuvljbAcJcqNVZltLEF96gCs6E\n+nY7fhvC8Wfrjq/H9GBJEbDJfMLCSKeKe0AzOOf3cFGjfDB6MB0GA1UdDgQWBBRI\nbdagDUzSm5kHm5kp/PLPS7yLSzAfBgNVHSMEGDAWgBQZP83RVzsOt+seXDs2bKWk\nJLhZ6jALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhALhozbrCeYS1AAZ0URrf\nXjnvMbEDAtmFhDQTyGdqMZaiAiEA1j7bvLO3wbQX+hZDrKkz6p/ThZD9T0qE9g0P\nFPr6GcE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIFGk7t+HGgaVwZB527OYgYaeXZmWrD4FSPXmKDh8DvkmoAoGCCqGSM49\nAwEHoUQDQgAEFOOEKwcVqmuv86A54a6+WNsBwlyo1VmW0sQX3qAKzoT6djt+G8Lx\nZ+uOr8f0YEkRsMl8wsJIp4p7QDM45/dwUQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIIBFDCBvAIBATAKBggqhkjOPQQDAjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJv\nb3QXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAwMDAxWjA9MDsCFE+Tpm5VJVMC\npdvqt7QKD0lCQo7EFw0yMzEyMzEwMDAwMDBaMBQwEgYLKwYBBAGDszqFGgEBAf8E\nAKAwMC4wHwYDVR0jBBgwFoAUGT/N0Vc7DrfrHlw7NmylpCS4WeowCwYDVR0UBAQC\nAgU5MAoGCCqGSM49BAMCA0cAMEQCICRlRheutEu0x2yc9wdFoVDUizwQxThyr9ru\nkcgXVj9zAiA7vI/sdwV5K6LUJjgHxFB8FjEMte3/9KNLT3MY8hnfrQ==\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::structure::entry-unknown-noncritical-extension", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "undetermined", + "description": "Tests that a CRL entry with an unknown non-critical extension is accepted\nand revokes the certificate.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUbgtU1OTclE67oTa3B3DyBwCJ9q4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATnpIssOVbo4clvQr+FAP0peduxidDGJ98S5e3q\nQlCN/oWizC77tGiuVyfctHJTc+RyzC5kj2Fdf4hosX090RXvo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUEvdN4w/gsJ7UBZVP2XaeKMECU7kwCgYIKoZIzj0EAwIDSAAwRQIh\nAOl7b8blMGncKUKokpI5HB5+gbOiY7qtk58jFBdfoXuEAiBMO0KK4+7/sMufF/hQ\n06GfzD0txIyEcYTPF482382N1Q==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUOGVb8wNZuIx6NhTlwIO2uI3VuIgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABD++eO9K2pT4LG3npv1s20vB5LkjGrd/DEQfBnvF931k\n86VnrmaQ4FpfPtmoWr3hhoKWGok0AyF+xELoXDpnHEWjfDB6MB0GA1UdDgQWBBSC\nIOEUEpfIzcZAX2sCge2rk8O8AjAfBgNVHSMEGDAWgBQS903jD+CwntQFlU/Zdp4o\nwQJTuTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgXVSphLeM0DO1aQsVGb1y\nRpyOvRZ3qxrnub2o5OrH7aUCIQDdsSGI1o2eix8Q6+Dm3frG2W21fzwrd/HOhdWR\n/8shVw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIFv9+yNE5HFYwbDVQmMgW6D9m4QLKQjugVi6KgoSYu6PoAoGCCqGSM49\nAwEHoUQDQgAEP75470ralPgsbeem/WzbS8HkuSMat38MRB8Ge8X3fWTzpWeuZpDg\nWl8+2ahaveGGgpYaiTQDIX7EQuhcOmccRQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIIBEzCBuQIBATAKBggqhkjOPQQDAjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJv\nb3QXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAwMDAxWjA6MDgCFDhlW/MDWbiM\nejYU5cCDtriN1biIFw0yMzEyMzEwMDAwMDBaMBEwDwYLKwYBBAGDszqFGgEEAKAw\nMC4wHwYDVR0jBBgwFoAUEvdN4w/gsJ7UBZVP2XaeKMECU7kwCwYDVR0UBAQCAgU5\nMAoGCCqGSM49BAMCA0kAMEYCIQCNeulihoYsUQm9N3gWWBvM1wO4TI0TnMzew+2s\nbQnf4AIhAJLDSyx1/vMGM2jtBdGlPYq7UvREOKJrfSPtdpWdgdyC\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::revoked-certificate-with-crl", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "high", + "description": "Tests a Certificate Revocation List (CRL) that revokes a certificate.\n\nProduces a simple test case where a certificate has been revoked by the CA\nthrough a CRL. The CA certificate and CRL are provided, and the leaf certificate\nis expected to be rejected due to its revoked status.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUOm7z7tb8WidmoD35b+DwND3prGkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR8fIR/Z0eBphAIZK9QlZme4PthKlOEh8ivfhj9\nKyvLouWKhpWGK+EHiEaXXJXz8nUcAz4RI4F7HFT2b7kRxR9Wo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUEZONWISDq1ARmLxsPOySEEQthNswCgYIKoZIzj0EAwIDSAAwRQIg\nOE2eafjhlBHhc7lkqFx+hANUVWM5btQN9j9HUsVJopMCIQDBpP2O+P9HhUHavyui\naR8a1QJWsZPDqjOHjveix9XCGQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBwTCCAWigAwIBAgIUMCzWqTelXTHDG1ZJN0HejDbK2vswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAeMRwwGgYDVQQDDBNyZXZva2VkLmV4YW1wbGUuY29tMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEI0N9YCOB9t6mHO8C2doyOQyAAW0MPRiB\nG8lefsFGaTaolNKgwYk0X0TPrGGkJxiWTB3a4qQieqNNDlH45LcCxqOBhTCBgjAd\nBgNVHQ4EFgQUyigPlEYwJh+9rSUFHyRx+pWt/ggwHwYDVR0jBBgwFoAUEZONWISD\nq1ARmLxsPOySEEQthNswCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMB\nMB4GA1UdEQQXMBWCE3Jldm9rZWQuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAw\nRAIgXHX7QZ/kZQm4sgAGunwZamUafa0i5UHq29rw8iNTKC4CIGdP8ByciygePx10\nCeLkSM/LUvqllKHGU2CFE+NMklE7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIL/rTX7KBZZh7HzAzuY1dQFp1j2b+bqttqOtcCSnntiCoAoGCCqGSM49\nAwEHoUQDQgAEI0N9YCOB9t6mHO8C2doyOQyAAW0MPRiBG8lefsFGaTaolNKgwYk0\nX0TPrGGkJxiWTB3a4qQieqNNDlH45LcCxg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "revoked.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIH/MIGmAgEBMAoGCCqGSM49BAMCMBoxGDAWBgNVBAMMD3g1MDktbGltYm8tcm9v\ndBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMCcwJQIUMCzWqTelXTHD\nG1ZJN0HejDbK2vsXDTIzMTIzMTAwMDAwMFqgMDAuMB8GA1UdIwQYMBaAFBGTjViE\ng6tQEZi8bDzskhBELYTbMAsGA1UdFAQEAgIFOTAKBggqhkjOPQQDAgNIADBFAiEA\nv+dChy/+IxvzPlR4xHwuI4TlCqVx/V17DGonlLRt3vUCIHkVQu7t4ytruWQBI97f\nR1L9afNnJt9nw9LZffFRGAbO\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::crlnumber-missing", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "high", + "description": "Tests handling of a CRL that's missing the `CRLNumber` extension.\n\nPer RFC 5280 5.2.3 this extension MUST be included in a CRL.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUYjRPcV/EY/xP+BM8x6q693mKm+AwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASSUmMhR5TZEmUflnGnGfZyGQUvKa1hFYHMeADc\n0bc4dZAJOglTex0/5wcsglo7mSIhDhIPxd8cXwaEDF5H2qlIo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUBTyRdWQK8xIw8YdpJIP3ux1OTlswCgYIKoZIzj0EAwIDRwAwRAIg\nT1t/HuR06Lqu8Xr+oNFDVocFPnW1QUZwrQ1t6rrGbOoCIA89pfScG15PAdJui8ts\n/zN6Q/QafD8jY4fj0HI25Q3m\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB1TCCAXygAwIBAgIUEhBxtfIhdcxrV24rPBhi/2cITGgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAoMSYwJAYDVQQDDB1taXNzaW5nLWNybG51bWJlci5leGFt\ncGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIj2M1XREURb+cFGxOUX\nxxTWgCCCJH2PU+4c9ag/67ndDt8lTJQ9tvUkQXT+DZXWsayI00r1LlQ0eb3jJzU8\n9h2jgY8wgYwwHQYDVR0OBBYEFNuwL6ulzJXbMWK3QLFDKcKlmyTGMB8GA1UdIwQY\nMBaAFAU8kXVkCvMSMPGHaSSD97sdTk5bMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAK\nBggrBgEFBQcDATAoBgNVHREEITAfgh1taXNzaW5nLWNybG51bWJlci5leGFtcGxl\nLmNvbTAKBggqhkjOPQQDAgNHADBEAiBruIcgo6zDwdoqlB4w1ObXFK3wtg7larT7\n4E0bCLzyxQIgMpOqcfG2+Zqhml+Iic6/nSp8vKe9tIvup3mLHHGPwWw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIN8DPdlPHBBNz/4VZBB5EIuc0g3GcCykopTK9ZeRiClwoAoGCCqGSM49\nAwEHoUQDQgAEiPYzVdERRFv5wUbE5RfHFNaAIIIkfY9T7hz1qD/rud0O3yVMlD22\n9SRBdP4NldaxrIjTSvUuVDR5veMnNTz2HQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "1970-01-01T00:00:03+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "missing-crlnumber.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIHzMIGZAgEBMAoGCCqGSM49BAMCMBoxGDAWBgNVBAMMD3g1MDktbGltYm8tcm9v\ndBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMCcwJQIUb8Aq3Bl3wyWB\nLWFUP59MsP0YU4gXDTcwMDEwMTAwMDAwMlqgIzAhMB8GA1UdIwQYMBaAFAU8kXVk\nCvMSMPGHaSSD97sdTk5bMAoGCCqGSM49BAMCA0kAMEYCIQDMCTBo/auL63SCy047\nO/Nnw2kCS3lFDZsle90TxIZhggIhAKEsWkjV94GcsAzK0QXfTBeYjDQ4/Rj1GfX1\nbkgf8AvO\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::certificate-not-on-crl", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "high", + "description": "Tests a certificate that is not present on any of the CRLs (expected pass).", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUCzeCxuEj/qxTFtqXkoOO+z1y13AwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQrofyGiTcAJn0Jwrizszx7mzKcsTVQ9m/5pxkZ\nxwGW9c4mLEpNgO73ZaNoM6i6CawKsdeXmBgNRPf+GfdfnAPRo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUtPKoKEYLlCCyV2WTW8bttCHg5lMwCgYIKoZIzj0EAwIDSAAwRQIg\nV05pr8/y+Haw9dKOx14H9ntrQFWlycFu655oQvG1wYMCIQCCFePQ5LGD1aPoX9cN\nUpyBfWhSEZH7PHvVgVp9xSAcTQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUSLHsO+BbAEYRPWN1z/T9N3ebVxgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABCAmbAo5MwgCw8gzeCUC0I0Mdm9BCn61vlAnb2U+YQ9S\nQdTtN9o+7fzrfHfohG4NLjMgXbciD03acH0jHwTBlJyjfDB6MB0GA1UdDgQWBBTE\nUTZOdakR7ZXpfbKKTrn6vqEq8DAfBgNVHSMEGDAWgBS08qgoRguUILJXZZNbxu20\nIeDmUzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAMeoMZX8w7EU4tIfe/ek\n3W2qOGuTMI3EsIRb3NCo36VNAiB6O1ib6r7mQwUX1zD5c3FBIj9osJZS5ha6PYFZ\nRwUc9w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIK/sRDO+KQN0oNoIAXaxgYBtp6G3EAFYmPRSm158/RvZoAoGCCqGSM49\nAwEHoUQDQgAEICZsCjkzCALDyDN4JQLQjQx2b0EKfrW+UCdvZT5hD1JB1O032j7t\n/Ot8d+iEbg0uMyBdtyIPTdpwfSMfBMGUnA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIIBJTCBzQIBATAKBggqhkjOPQQDAjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJv\nb3QXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAwMDAxWjBOMCUCFDjaccXfg+JR\ns8tXVQJIRE7RYafVFw0yMzEyMzEwMDAwMDBaMCUCFE06KYiFjFhSU6GE6XmItTmq\nh9KrFw0yMzEyMzAwMDAwMDBaoDAwLjAfBgNVHSMEGDAWgBS08qgoRguUILJXZZNb\nxu20IeDmUzALBgNVHRQEBAICBTkwCgYIKoZIzj0EAwIDRwAwRAIgeNazRbPajixj\nIdRjUPjqVbdra0ARH/makB4dERiaHcACIB0YUdqBDGG9PSWHIYMGk8mPfBzR7TYQ\nKAvFAMYnEinP\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::certificate-serial-on-crl-different-issuer", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "high", + "description": "Tests a certificate whose serial number is found on a CRL, but that CRL\nhas a different issuer than the certificate (expected pass).\n\nProduces a test case where a certificate's serial number appears on a CRL,\nbut the CRL is issued by a different CA than the one that issued the\ncertificate. The certificate should be accepted since the CRL from a\ndifferent issuer should not affect this certificate's validity.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBgjCCASmgAwIBAgIUHvwdq/+O6/InGYxGx/+qqmCVKcYwCgYIKoZIzj0EAwIw\nFDESMBAGA1UEAwwJUm9vdCBDQSAxMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAz\nMDAwMDAxWjAUMRIwEAYDVQQDDAlSb290IENBIDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9gllUTv182FQAKUQcyDvqt2r71eucz+nmhJAq6EfV1YaAMpQLAiKQ\nhUZaii1CWl0a3gQaIaetzfYQpDU91iK7o1cwVTAPBgNVHRMBAf8EBTADAQH/MAsG\nA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAdBgNVHQ4EFgQUMjg1\n/4m0m1jpS7uBgYZxr/KkR3swCgYIKoZIzj0EAwIDRwAwRAIgBkkFCBX/CGsDDhdx\nsWcJs7xhgqq89dy1KsNBAgut8EACIGBshHAhVy2PAzHptf3OhH1M6m3K98hagopj\n1ORg1s3H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBgzCCASmgAwIBAgIUNC+riQptnoewcAF6Qfw6mdpcd6owCgYIKoZIzj0EAwIw\nFDESMBAGA1UEAwwJUm9vdCBDQSAyMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAz\nMDAwMDAxWjAUMRIwEAYDVQQDDAlSb290IENBIDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASOUcG5VrC6ziZV2J3UCWGAs7dt9t1BAr8ncJzOznX8Qq++4dUc1BLS\n2Y1Ts/ko4vvJTLAr9YDVxVBPVlK7yrpEo1cwVTAPBgNVHRMBAf8EBTADAQH/MAsG\nA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAdBgNVHQ4EFgQUzwkQ\nbjwHWaM5fegJsUe5B+YEp2cwCgYIKoZIzj0EAwIDSAAwRQIgEIUYs5ZhI17CsxDY\nO43wVuWNi+4ZVBPzh5gN33aF3QwCIQD+ikyiJoGbOWTKXsAoHXx/ntxoYy/1w5Yb\nXtZqySltIQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBqjCCAVCgAwIBAgIUA3cB2vrc1BZoeAsM2kddPrGMaowwCgYIKoZIzj0EAwIw\nFDESMBAGA1UEAwwJUm9vdCBDQSAxMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAz\nMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqG\nSM49AwEHA0IABIQi/MfrEjokOo75dkAxhcUUyU37M0ef7XF930uXHvReYzNjnWkR\nXWr7s70tEJl8riblFlyj3+iRsOEOwqHj2QyjfDB6MB0GA1UdDgQWBBQPkaHORttD\n9yJhsN4P8XHpIC1wvzAfBgNVHSMEGDAWgBQyODX/ibSbWOlLu4GBhnGv8qRHezAL\nBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhh\nbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgERCiuz703n5OWkpcH7fu0p0ZluN9\nwUEVPyQlXFlwf+sCIQDrm7Mc8I13AeyOSVDSTWr3P7jj9Mg91BfPRCuB7xPbKQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILxp2Z1bxBmx/dnUvUBztIMGYfkncQlOcIE6m+cZOtiQoAoGCCqGSM49\nAwEHoUQDQgAEhCL8x+sSOiQ6jvl2QDGFxRTJTfszR5/tcX3fS5ce9F5jM2OdaRFd\navuzvS0QmXyuJuUWXKPf6JGw4Q7CoePZDA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIHOMHcCAQEwCgYIKoZIzj0EAwIwFDESMBAGA1UEAwwJUm9vdCBDQSAxFw03MDAx\nMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVqgMDAuMB8GA1UdIwQYMBaAFDI4Nf+J\ntJtY6Uu7gYGGca/ypEd7MAsGA1UdFAQEAgIFOTAKBggqhkjOPQQDAgNHADBEAiB5\nAxcZSlkhlIKHF3zj7vX/G8+wV5GV9J2X+BbKedHG+gIgCMzB3ZCT9pSi0T+Q0NT3\nASeuGaQc7nJqr2Xf01I9Ewk=\n-----END X509 CRL-----\n", + "-----BEGIN X509 CRL-----\nMIH5MIGgAgEBMAoGCCqGSM49BAMCMBQxEjAQBgNVBAMMCVJvb3QgQ0EgMhcNNzAw\nMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMCcwJQIUA3cB2vrc1BZoeAsM2kdd\nPrGMaowXDTIzMTIzMTAwMDAwMFqgMDAuMB8GA1UdIwQYMBaAFM8JEG48B1mjOX3o\nCbFHuQfmBKdnMAsGA1UdFAQEAgIFOTAKBggqhkjOPQQDAgNIADBFAiEAgk6bOqMn\nGiaD5ZSiS3TUNttjAiW4YL3EkcDw0PVbQ4UCIBbeeMdypNCSLlD0wwl7F8CsN9zR\nBCp2LlS4Qxy6QMTF\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::crlnumber-critical", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "high", + "description": "Tests handling of a CRL that has a critical `CRLNumber` extension.\n\nPer RFC 5280 5.2.3, the `CRLNumber` extension is mandatory but MUST\nbe marked as non-critical.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUMjDR1XYJo5gtipTQuhpwVjYXJ6AwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATpqrNphLNybOPCyWLb3SmoPS5F7aOT5rwN15qn\nlWbFiRFa7J33PrYRVQ53ZfZ9awXZ7PyN8Ivi80Ief9DtDMmRo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUqDNDWRpAUndRZHmE3nj93gGhGFAwCgYIKoZIzj0EAwIDRwAwRAIg\ndmpq0Hgx+U3K42BcU88DZHily6Ap979ioH5wngjRatACIGxZlWGMejR1JGjasxIm\nLLCxsXme8TNR5QtP1eogPpWR\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB1zCCAX6gAwIBAgIUFb358whOADv+j/mufFy7ij9D0qwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjApMScwJQYDVQQDDB5jcmxudW1iZXItY3JpdGljYWwuZXhh\nbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQxdZP5OQVue9GsT/2+\nxL5H6kcwc/eW9VYSPU9C9flGQ1xWiQksgllCx9HKfTNBhsw9JG6fOclSahatJ8ig\nvpi4o4GQMIGNMB0GA1UdDgQWBBQdCgz/VnA0tQ7l4kLq20pEbGXzqTAfBgNVHSME\nGDAWgBSoM0NZGkBSd1FkeYTeeP3eAaEYUDALBgNVHQ8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwKQYDVR0RBCIwIIIeY3JsbnVtYmVyLWNyaXRpY2FsLmV4YW1w\nbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCID5IF9yoCwp2BR13MKdngrpBwENR1wS3\nVfT2+hFPBLj2AiA3Ifp2iwvoNxs0G1PJ4OYvwPwhgJakMXBziNIUvi5lcg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICLAiW9h0G7w7t3NJe2fPCkCealeRfyTXLRvijo5EkQdoAoGCCqGSM49\nAwEHoUQDQgAEMXWT+TkFbnvRrE/9vsS+R+pHMHP3lvVWEj1PQvX5RkNcVokJLIJZ\nQsfRyn0zQYbMPSRunznJUmoWrSfIoL6YuA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "1970-01-01T00:00:03+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "crlnumber-critical.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIIBATCBqQIBATAKBggqhkjOPQQDAjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJv\nb3QXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAwMDAxWjAnMCUCFFKhlJzXQvm1\nGW0gjwCZNwukScvsFw03MDAxMDEwMDAwMDJaoDMwMTAfBgNVHSMEGDAWgBSoM0NZ\nGkBSd1FkeYTeeP3eAaEYUDAOBgNVHRQBAf8EBAICMDkwCgYIKoZIzj0EAwIDRwAw\nRAIgZ6VgDGHVKu3I+eHNNIjnsLYgEfAow+kZkttK78cY5MMCIBL9GZavyUVOOeYQ\nmqPfkqPTx9J30f9zCsLlRQjsjqcK\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::issuer-missing-crlsign", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "high", + "description": "Tests CRL validation when the CA issuer has a keyUsage extension with only\n`keyCertSign` set (no `cRLSign`).\n\nPer RFC 5280 Section 4.2.1.3, if the keyUsage extension is present in a CA\ncertificate, the `cRLSign` bit MUST be set if the CA will be issuing CRLs.\nA CRL signed by a CA without the `cRLSign` bit should be rejected.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUaDi+ySmRWrrftcV11dQzYN8eRggwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATxVFbz+YE2FL5BckMDa+0pmEbGDDMptn3TCxRX\nkm5gFid25gmuEMRrSeaQk7m1JyZ0yEIPF7ehwPDx8EtvH/lQo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUh3ZDVU9aA8lpREWPAQCHOPXWr2MwCgYIKoZIzj0EAwIDSQAwRgIh\nAMnvcVprvKNTRDyNlDhiMK0a0Ucv+/faP/IC3wvKyp1IAiEAqzVwwH4bGNBoN2gr\nh5aw8zIUP+Xi0ZyM7UKjodU2lWg=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB3zCCAYagAwIBAgIUcmTlYIHPKUbJ8E97Ffa3lqhcpakwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAtMSswKQYDVQQDDCJpc3N1ZXItbWlzc2luZy1jcmxzaWdu\nLmV4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYT3C6JbhIr9l\nCKapPJsp6PyCLIHyBPBC3ZfhCM8gIq8JX9y4BsdJjggQ5V7VOm9hEV1Q3oiYBMke\nw/2Ds5cRa6OBlDCBkTAdBgNVHQ4EFgQU0D1nhXGKBBrFG1IDbbYuo7YEB2YwHwYD\nVR0jBBgwFoAUh3ZDVU9aA8lpREWPAQCHOPXWr2MwCwYDVR0PBAQDAgeAMBMGA1Ud\nJQQMMAoGCCsGAQUFBwMBMC0GA1UdEQQmMCSCImlzc3Vlci1taXNzaW5nLWNybHNp\nZ24uZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgO/ckTkC8V7isNlCXL1EZ\nSNl8VNJEhaAOK4mD/AxXHWMCIAzjr8Lu7rgDXCkD1VzRDoEqZykiJF0L2wcb3gCd\nRxsV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIFnfGyNqYzYvPW/Ve+5cdEA4R/PxUjjiRBMspJSsGbwpoAoGCCqGSM49\nAwEHoUQDQgAEYT3C6JbhIr9lCKapPJsp6PyCLIHyBPBC3ZfhCM8gIq8JX9y4BsdJ\njggQ5V7VOm9hEV1Q3oiYBMkew/2Ds5cRaw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "issuer-missing-crlsign.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIH/MIGmAgEBMAoGCCqGSM49BAMCMBoxGDAWBgNVBAMMD3g1MDktbGltYm8tcm9v\ndBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMCcwJQIUPqZnx1qb7Wi1\nr54MbdA71LiT514XDTIzMTIzMTAwMDAwMFqgMDAuMB8GA1UdIwQYMBaAFId2Q1VP\nWgPJaURFjwEAhzj11q9jMAsGA1UdFAQEAgIFOTAKBggqhkjOPQQDAgNIADBFAiBr\nhnoi0J6yhk/VB3loYwSpUiVNty0yB6liMWx4D8hfyQIhAP7nEog3zMd5Qn0mxYE8\np2D/wrmy3U8mU0qyHZbghSiG\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::issuer-no-keyusage-extension", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "high", + "description": "Tests CRL validation when the CA issuer has no keyUsage extension.\n\nPer RFC 5280 Section 6.3.3(f), the CRL validation algorithm states:\n\"If a key usage extension is present in the CRL issuer's certificate,\nverify that the cRLSign bit is set.\" This conditional check means that\nwhen keyUsage is absent, there is no cRLSign verification to perform.\n\nNote: RFC 5280 Section 4.2.1.3 states that \"Conforming CAs MUST include\nthis extension in certificates that contain public keys that are used to\nvalidate digital signatures on other public key certificates or CRLs.\"\nHowever, this is a certificate issuance requirement, not a validation\nrequirement. The validation algorithm in Section 6.3.3(f) explicitly uses\nconditional language (\"If... is present\").", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBgjCCASigAwIBAgIUaxtbbTOq+AM8u59BLizWj66VgqkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAT2c3dNCbfLQ4k7hsNLW3HbMhFbABLTbuh0YDD4\n633UmQo1HJGQu8z5eLPQUIaxu9mCoKg/mHhXz+dFoK7KsC+Xo0owSDAPBgNVHRMB\nAf8EBTADAQH/MBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB0GA1UdDgQWBBRML49h\nrDEjdot+AfBpNPefjmdlqjAKBggqhkjOPQQDAgNIADBFAiEAkfKFbCCQw2Q4CQwP\n+go5mNo2IcBkavYWbRSylLS6Mo4CIC0/Qg7zKZ9g1os7jHEBoCs70XfHe6RwbPyA\na20D0Ncj\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB2DCCAX6gAwIBAgIUEBSrcrCDAfyvXTPRxBDQeWQULEMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjApMScwJQYDVQQDDB5pc3N1ZXItbm8ta2V5dXNhZ2UuZXhh\nbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQR3eTo6LJ4IgtEwin/\nGPfOeAZiNfXg9aWednms2zI0IZldG5xistNjjS2Mf/NZq23/V2+ZTNamNAZSIfFp\nDbg5o4GQMIGNMB0GA1UdDgQWBBR9NAcfYfnJvPuIqjLen4yhL2i4tTAfBgNVHSME\nGDAWgBRML49hrDEjdot+AfBpNPefjmdlqjALBgNVHQ8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwKQYDVR0RBCIwIIIeaXNzdWVyLW5vLWtleXVzYWdlLmV4YW1w\nbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCaiLK8JIEj8S5CqnYZ4zzglbbfbqlS\n+E9arnkg83rYqQIgSVGQQnVTRtU7WFvy4Xqg5CXXd8ZBkyBbb+PIMPavQvQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIMP+RwmUPe4gxqRlj4mqxvQU2fcxBwcB1/DZKXohdvBOoAoGCCqGSM49\nAwEHoUQDQgAEEd3k6OiyeCILRMIp/xj3zngGYjX14PWlnnZ5rNsyNCGZXRucYrLT\nY40tjH/zWatt/1dvmUzWpjQGUiHxaQ24OQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "issuer-no-keyusage.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIH+MIGmAgEBMAoGCCqGSM49BAMCMBoxGDAWBgNVBAMMD3g1MDktbGltYm8tcm9v\ndBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMCcwJQIUDG8/Gx/iSxQe\n85qJK9Xy8+ur1Y4XDTIzMTIzMTAwMDAwMFqgMDAuMB8GA1UdIwQYMBaAFEwvj2Gs\nMSN2i34B8Gk095+OZ2WqMAsGA1UdFAQEAgIFOTAKBggqhkjOPQQDAgNHADBEAiAW\nzeieGTesm1nKABjCOYmz2Lr1lnXKGssOp3SEmXDyCwIgQUFuL/5WyO9oZank9sHZ\nfIm9/HDLa27ZJtRCW9mTWf8=\n-----END X509 CRL-----\n" + ] + }, + { + "id": "crl::issuer-valid-crlsign-and-keycertsign", + "conflicts_with": [], + "features": [ + "has-crl" + ], + "importance": "high", + "description": "Tests CRL validation when the CA issuer has a keyUsage extension with both\n`keyCertSign` and `cRLSign` bits set.\n\nThis is the standard configuration for a CA that issues both certificates\nand CRLs. The CRL should be accepted.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUPue6Ujya97zBUoawS7bUd2FjWoMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASt2I5mZbpU91bc9y6cVU3sidfXe88L+z2BNG1k\nmHAXurgGjjqFdOj9SatRNA3RlF5QYompAOcRbhDQBQRt7eLVo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUay9kdQ9FdaCQjC3QCT4fUTvWVJ4wCgYIKoZIzj0EAwIDSQAwRgIh\nANRL10G3ITV1CRhTQGc9jLj7Jwt7IAEcquj4spKEIFrdAiEAj86coXdnqF3Y7zE0\n0zM4etcqliLkl/AR2J1iwb1+msE=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB2zCCAYKgAwIBAgIUEABZFMLV/PxCjCD5QbYfD9YbtyowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjArMSkwJwYDVQQDDCBpc3N1ZXItdmFsaWQtY3Jsc2lnbi5l\neGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABP/TbF+6Ghd8dmuX\nKRHSPTUca17zbyyuNxJgH6wfBhyP/6qaK3Eyuutcd8K3F+cEr4PM0Oo9XsZM0ex8\nJGjYkTOjgZIwgY8wHQYDVR0OBBYEFJaqmtT9hj1Zyi1kJ0ZdSbj8d4goMB8GA1Ud\nIwQYMBaAFGsvZHUPRXWgkIwt0Ak+H1E71lSeMAsGA1UdDwQEAwIHgDATBgNVHSUE\nDDAKBggrBgEFBQcDATArBgNVHREEJDAigiBpc3N1ZXItdmFsaWQtY3Jsc2lnbi5l\neGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBMTog+SvNfd58Vvq5oC5BUbrja\n2FnL1+I6F4uqcawXNQIge5MNVKD0y2x6I7/NLJ/JCwckp8B5yw+Vkge8bP3RB7Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEINzAvC1hu+4BA7aBNuDikXHouzNbR7bAD/Mr8RUNOXvFoAoGCCqGSM49\nAwEHoUQDQgAE/9NsX7oaF3x2a5cpEdI9NRxrXvNvLK43EmAfrB8GHI//qporcTK6\n61x3wrcX5wSvg8zQ6j1exkzR7HwkaNiRMw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "issuer-valid-crlsign.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [ + "-----BEGIN X509 CRL-----\nMIH/MIGmAgEBMAoGCCqGSM49BAMCMBoxGDAWBgNVBAMMD3g1MDktbGltYm8tcm9v\ndBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMCcwJQIUcC2WqTJVRjze\nK37paXyiut4VACgXDTIzMTIzMTAwMDAwMFqgMDAuMB8GA1UdIwQYMBaAFGsvZHUP\nRXWgkIwt0Ak+H1E71lSeMAsGA1UdFAQEAgIFOTAKBggqhkjOPQQDAgNIADBFAiBk\nCfPahxiwb8g1lexLji10xr3scW/gh0I0m54wxuqdrQIhAPAUHy8mpFjHLdeqDFWJ\nMxgwlM0ShuF60O05jXOl2mab\n-----END X509 CRL-----\n" + ] + }, + { + "id": "cve::cve-2024-0567", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Tests CVE-2024-0567.\n\nProduces the following **valid** trust graph:\n\n```\nleaf -> A1 -> (A <-> B <-> C) -> Root A\n```\n\nIn other words: `leaf` is signed by intermediate `A1`, which in turn is signed\nby `A`, which is mutually cross-signed by CAs `B` and `C`. This naively results\nin a cycle, which can be resolved because `A` is also present as a self-signed\nroot in the trusted set.\n\n`B` and `C` also have subordinate CAs (`B1` and `C1`), but these do not factor\ninto the constructed chain.\n\nAffects GnuTLS prior to 3.8.3.\n\n* Announcement: \n* Patch: \n\nThis testcase is an independent recreation of the testcase in the patch, for CABF\nconformance.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBhjCCASygAwIBAgIURhLAb6+BC7Uj6tmtIhwjWMtTXCYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjARMQ8wDQYDVQQDDAZSb290IEEwWTATBgcqhkjOPQIBBggq\nhkjOPQMBBwNCAAR3MhAmL85Lt+tr6XkAaliGewkxDXm2yIAPr/4gYGT/FQt6/P5K\n1r8HkSIvJpjRkigX0yBx4bJ7Qv2TGFnlGvwxo1cwVTAPBgNVHRMBAf8EBTADAQH/\nMAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAdBgNVHQ4EFgQU\n9frD0GXqHgdDhvDFmp50QXnCwcowCgYIKoZIzj0EAwIDSAAwRQIgL+ph2SLcIVuc\nVYnznPTExYi6Y/6SfM/t+57eL/8tciECIQCcc8Zjv0a50z4gPDwvWf8a9PJxjQjp\n3kK9BLChjnsBPg==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUSIzZJ+irMqEI2upQiCpXMOnnAlEwCgYIKoZIzj0EAwIw\nETEPMA0GA1UEAwwGUm9vdCBBMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAw\nMDAxWjAaMRgwFgYDVQQDDA9JbnRlcm1lZGlhdGUgQTEwWTATBgcqhkjOPQIBBggq\nhkjOPQMBBwNCAATfmD0z2nLASZAsOVtt0TqDf3+2TupJ2BsczhOW5rBnrjSmmPrP\nW9XmCrEm/595FdyY3t/q0a4/V64ItdBz7sI7o2AwXjAPBgNVHRMBAf8EBTADAQH/\nMAsGA1UdDwQEAwICBDAfBgNVHSMEGDAWgBT1+sPQZeoeB0OG8MWannRBecLByjAd\nBgNVHQ4EFgQUut8QMSMYq+c7RWiKQEmT2imb7Z4wCgYIKoZIzj0EAwIDSQAwRgIh\nAMu/MsaF230TY/IZz/XQwcxRiDFAdz3jvQU7xV0PN/CwAiEAmEHIAj+qWyQTnsHd\nY8XV/TNaDM6yTTvbcWbvJsB01Yc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBhjCCASygAwIBAgIUcERS7ykBpaAf7LvoRZP/CRAhcyEwCgYIKoZIzj0EAwIw\nETEPMA0GA1UEAwwGUm9vdCBCMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAw\nMDAxWjARMQ8wDQYDVQQDDAZSb290IEEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR3MhAmL85Lt+tr6XkAaliGewkxDXm2yIAPr/4gYGT/FQt6/P5K1r8HkSIvJpjR\nkigX0yBx4bJ7Qv2TGFnlGvwxo2AwXjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAfBgNVHSMEGDAWgBSMx6VgES7p5JyTB4DmoXTOSxRpYDAdBgNVHQ4EFgQU\n9frD0GXqHgdDhvDFmp50QXnCwcowCgYIKoZIzj0EAwIDSAAwRQIgO8umJh6ajdqi\nnxbjYb3xOeee5Gdfp7KokUsGRlYuSfICIQD0V/75dQ6d7S0dELrRYP1fovh7RWFC\nIr2ts9aPNzNrag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBhjCCASygAwIBAgIUEwc+VqHy6Y8MkdurkhNuf+23TZMwCgYIKoZIzj0EAwIw\nETEPMA0GA1UEAwwGUm9vdCBDMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAw\nMDAxWjARMQ8wDQYDVQQDDAZSb290IEEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR3MhAmL85Lt+tr6XkAaliGewkxDXm2yIAPr/4gYGT/FQt6/P5K1r8HkSIvJpjR\nkigX0yBx4bJ7Qv2TGFnlGvwxo2AwXjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAfBgNVHSMEGDAWgBRYywhfdDzbHEQcJItYpwHIn+mjKzAdBgNVHQ4EFgQU\n9frD0GXqHgdDhvDFmp50QXnCwcowCgYIKoZIzj0EAwIDSAAwRQIgRfhHQq4tV+EH\n3xShu2Pp8Qns/hh6SbMzIb9iQwiAqHcCIQCfQisgxHJMjDttN4oQxdnvibDbOd36\nqObGkSzW1+yfJQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUc8036iJRpb/Rjn24I6DYPPbI/M4wCgYIKoZIzj0EAwIw\nETEPMA0GA1UEAwwGUm9vdCBCMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAw\nMDAxWjAaMRgwFgYDVQQDDA9JbnRlcm1lZGlhdGUgQjEwWTATBgcqhkjOPQIBBggq\nhkjOPQMBBwNCAAT3O/kNWvyDm4B1IuTsS5YU5+UEj9FqIEicdmHi+9YvXePWk/Xo\nVksB5un+5NbWJETWze8qZPj3/jJsHhJnAT1oo2AwXjAPBgNVHRMBAf8EBTADAQH/\nMAsGA1UdDwQEAwICBDAfBgNVHSMEGDAWgBSMx6VgES7p5JyTB4DmoXTOSxRpYDAd\nBgNVHQ4EFgQUv/Mbb40XSXwMyw03xPv/6vTEusMwCgYIKoZIzj0EAwIDSAAwRQIg\nLWs+jSAOXhxxzR7rna2FsbkO5f+xyNxAatEZGN3UdXoCIQDaJYelER7LE2e9UKYF\ncn6uR1fJnzS+u4uiVMav1HDG8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBhzCCASygAwIBAgIUUQjxxT8yqKfIIWYg/u4Y5ATWHiMwCgYIKoZIzj0EAwIw\nETEPMA0GA1UEAwwGUm9vdCBBMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAw\nMDAxWjARMQ8wDQYDVQQDDAZSb290IEIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT7S1d+AvMfrsUybQJoWQazIka0TvJo0+KiFMOt96WUdTfs/7wGjAXBqd956afC\ndZqyx1CJ+DZpuVmWX9H6DhTBo2AwXjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAfBgNVHSMEGDAWgBT1+sPQZeoeB0OG8MWannRBecLByjAdBgNVHQ4EFgQU\njMelYBEu6eSckweA5qF0zksUaWAwCgYIKoZIzj0EAwIDSQAwRgIhAMhQi+2npwh0\ncyYUBzmi17V3JDWrKMXHcVyKkaXwuCNQAiEAuZ+JMuqXJodvBx/Va1/qpezouN7C\nXFWpdSQioNW3cEA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBhTCCASygAwIBAgIUPR2pmutnXEYjjHbrGVOpxnQi6qMwCgYIKoZIzj0EAwIw\nETEPMA0GA1UEAwwGUm9vdCBDMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAw\nMDAxWjARMQ8wDQYDVQQDDAZSb290IEIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT7S1d+AvMfrsUybQJoWQazIka0TvJo0+KiFMOt96WUdTfs/7wGjAXBqd956afC\ndZqyx1CJ+DZpuVmWX9H6DhTBo2AwXjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAfBgNVHSMEGDAWgBRYywhfdDzbHEQcJItYpwHIn+mjKzAdBgNVHQ4EFgQU\njMelYBEu6eSckweA5qF0zksUaWAwCgYIKoZIzj0EAwIDRwAwRAIgY0qHR4wVhael\nOX41BLgKInoC7xoSGhddINqcBA0YrrMCIDkcRHv8fOZmDe3HQTbj3ElsX2mQRpwe\nU06MGYQCZW44\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUDb33mIBdY1nScgrEMj/9Zoqt/9QwCgYIKoZIzj0EAwIw\nETEPMA0GA1UEAwwGUm9vdCBDMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAw\nMDAxWjAaMRgwFgYDVQQDDA9JbnRlcm1lZGlhdGUgQzEwWTATBgcqhkjOPQIBBggq\nhkjOPQMBBwNCAAQJ4SovKCckShNSVtcy29I/fkOnmvC9o8TQNCLdJjgdgxwR7lrB\nPC9xJa4UpwurkcNA3872Y3nAfRP2sRuC4iSHo2AwXjAPBgNVHRMBAf8EBTADAQH/\nMAsGA1UdDwQEAwICBDAfBgNVHSMEGDAWgBRYywhfdDzbHEQcJItYpwHIn+mjKzAd\nBgNVHQ4EFgQUDVyv51fWvkVsEHENrJwDylSuRy0wCgYIKoZIzj0EAwIDSAAwRQIg\nXt2h+bHQnZHx5XrUkiyfSrr/4lPpvkugEDBf2Nk/FMwCIQDyiiW1nX+qqKXy8PW7\nfI205m+rHFRtc/RAAdHSDxFoZg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBhzCCASygAwIBAgIUUWua5uMtDMUfCsaAR+STrqJ3hQkwCgYIKoZIzj0EAwIw\nETEPMA0GA1UEAwwGUm9vdCBBMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAw\nMDAxWjARMQ8wDQYDVQQDDAZSb290IEMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQgp726NZmNPcqRZWObKrkV9AlW3WGTQgnmCkn9pJGvIBP35vAXVC+hqYfmG1mu\n5q2DPrWtfJnzBF8IDmajfA2jo2AwXjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAfBgNVHSMEGDAWgBT1+sPQZeoeB0OG8MWannRBecLByjAdBgNVHQ4EFgQU\nWMsIX3Q82xxEHCSLWKcByJ/poyswCgYIKoZIzj0EAwIDSQAwRgIhAMtZH953QoFf\nLOt9girWkt05fJmZh/wke1LuYfR4KXesAiEAyKceu0U8i06LvIXxah8Y2W8KoJyS\ndAFR2VgZ810l7Ks=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBhzCCASygAwIBAgIUF2VCEslMEkSR0IVbL9CFeL9oT+YwCgYIKoZIzj0EAwIw\nETEPMA0GA1UEAwwGUm9vdCBCMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAw\nMDAxWjARMQ8wDQYDVQQDDAZSb290IEMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQgp726NZmNPcqRZWObKrkV9AlW3WGTQgnmCkn9pJGvIBP35vAXVC+hqYfmG1mu\n5q2DPrWtfJnzBF8IDmajfA2jo2AwXjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAfBgNVHSMEGDAWgBSMx6VgES7p5JyTB4DmoXTOSxRpYDAdBgNVHQ4EFgQU\nWMsIX3Q82xxEHCSLWKcByJ/poyswCgYIKoZIzj0EAwIDSQAwRgIhAOERgZtzrbCU\nPflQ+SI7I5L7sT5/cPdktmlVjRmGJeu4AiEAlgk9nG3AvCH9y6C7cFHiG14ONdYB\nlrx8cof0S8Twp2w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrDCCAVOgAwIBAgIUXG03NtwTLTl+dl3fOEizECKXCFEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPSW50ZXJtZWRpYXRlIEExMCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAAMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9T+ZfjRp\n6ooql6qL7IbBnJRB6KeXTMJV1JE07MYuL9mz597OTQ4ddwMH5mRMMTvtFKWNIEw7\nSN0DlKAK6zydL6OBjjCBizAdBgNVHQ4EFgQUPN67mxNHp/fJRM88ZfD+ohpPuEww\nHwYDVR0jBBgwFoAUut8QMSMYq+c7RWiKQEmT2imb7Z4wCwYDVR0PBAQDAgeAMBMG\nA1UdJQQMMAoGCCsGAQUFBwMBMCcGA1UdEQEB/wQdMBuCGWN2ZS0yMDI0LTA1Njcu\nZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgdirlRwbcy3GeGedodDi6tA4i\noagsO2zL7V1IlofAr7ICIEjyYNRVRVHwm50S4X0dL6aAXQhiO5rMCiQyXaTElnWk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDfNbX3+evS0QtWZ+/kht6faEzyfjwNZ+3Z/wijGUgAtoAoGCCqGSM49\nAwEHoUQDQgAE9T+ZfjRp6ooql6qL7IbBnJRB6KeXTMJV1JE07MYuL9mz597OTQ4d\ndwMH5mRMMTvtFKWNIEw7SN0DlKAK6zydLw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "cve-2024-0567.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "cve::cve-2025-61727", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Tests CVE-2025-61727.\n\nProduces the following chain:\n\n```\nroot -> ICA (NC: forbid: bar.example.com) -> EE (SAN: *.example.com)\n```\n\nThis chain exercises an ambiguity between RFC 5280 and RFC 9525:\nRFC 5280 says that name constraints apply to subjects and SANs,\nwhile RFC 9525 defines wildcard semantics and matching of peer names\nagainst wildcards. Together, neither spec defines how name constraints\napply to peer names when a subject matches a peer name but doesn't\ndirectly match a name constraint.\n\nIn practice, validators should behave defensively and reject chains\nwhere a subject name *might* match a peer name that would violate the\nname constraint, even if the subject name itself doesn't match the name\nconstraint. For example, `*.example.com` does not match the\n`bar.example.com` constraint, but *would* accept `bar.example.com` as a peer\nname.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUbVNhSxBIFRnqm8ABbGUseZheMuswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQJNbfvoRVVQqHnErCJ2+5C7HnT2qEEvD7wrdAI\nCaIN5Z03MqmTwrtR+X2dFd0f33CNpSQRTS5Kyrbhk9pKLYh9o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUwMvUspJPVzUAN5glMr/uQgvJ8qQwCgYIKoZIzj0EAwIDRwAwRAIg\naIYfGoLwTxn7k1avlwQiQDaV6oH8XKHMfnPcxU02mjYCIF0aUUA1OcpFADKN15ka\nEq1IxUJjAaXSG2aqXCxWCIBi\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgIUddbAwAMPu80+TNm4gOJ4qRQHkOwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA2MjQxMzk0MzEzMDU4MzEzNzA5NjY3\nNTYzMTMxODYyMTY2MTQ2Mjg1NTM1MzYyMzUxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABCQhu0h20SNhRVNszmBuCyGDr5CL29INwVaUerUr0+8CHNW56CGyWjuadbec\nY8LAefEvPI6c6Dxp9A45nVeIalyjgZUwgZIwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAUwMvUspJPVzUAN5glMr/uQgvJ8qQwHQYDVR0O\nBBYEFL4UpZFBCrimwxhHXcbIX2x3O+f4MDIGA1UdHgEB/wQoMCagDzANggtleGFt\ncGxlLmNvbaETMBGCD2Jhci5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAH\ngBNEn8C+mPgaX1mXWgk5sbZ4X/7AhcnGlrcInuB5QQIhAIt+rJqat7RRW2JWUoRV\n8E/Lto3YI/kqzQBWrVMsknhp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICATCCAaigAwIBAgIUfb1YKRhR9RTZeCQ3lxzIj04nG6kwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjI0MTM5NDMxMzA1ODMxMzcwOTY2NzU2MzEzMTg2MjE2NjE0\nNjI4NTUzNTM2MjM1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMUqknRRlci5jCQF8ZoNKqdPhhC62KN0kHBQVK7rnCi4OLUPDC919i5BXdp2yju3R\nFMvTbI2JUpo8Mn3DxW83CaN+MHwwHQYDVR0OBBYEFPiWF10XUpbVcfNOXam+m+pa\nfnSVMB8GA1UdIwQYMBaAFL4UpZFBCrimwxhHXcbIX2x3O+f4MAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAYBgNVHREEETAPgg0qLmV4YW1wbGUuY29t\nMAoGCCqGSM49BAMCA0cAMEQCIDb1V1WQ4h6jzaeBW353zp6dG5pozHZ3l4TfBLFf\ntfKzAiBho3POUWaooQVEw5wc8gvxngdhlUl6ltgDAC5YsyV6dQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILhfhs0+hcfDzL+DEVSRSl8JxM3RrPd3TJkryrVbLwCdoAoGCCqGSM49\nAwEHoUQDQgAEMUqknRRlci5jCQF8ZoNKqdPhhC62KN0kHBQVK7rnCi4OLUPDC919\ni5BXdp2yju3RFMvTbI2JUpo8Mn3DxW83CQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "bar.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "cve::cve-2025-61727-nc-permits-variant", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Like CVE-2025-61727, but with a single permitted subtree of `foo.example.com`:\n\n```\nroot -> ICA (NC: permit: foo.example.com) -> EE (SAN: *.example.com)\n```\n\nIn practice, like above, validators should behave defensively and reject chains where a subject\nname *might* match a peer name that would violate the name constraint.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUOS/44epyjZOGjS0FHkv6Cqf5jUkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAS/KMKLUvDsGFFXYGw01BUNjzqRnXcWSulmNc4T\nzna/NfmgvLL/lfTxE9BQ+q3kAmC8oiUf0RsFnACFsSihfYiPo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU+0wYfMK6AWhBg2XHXIrh7AyUQ9swCgYIKoZIzj0EAwIDSQAwRgIh\nAO5Ei8khxvMh9XOJ/haugxjY1WQKaNHT72Cw28lhPmq0AiEAmip10K7yD45u8oVg\n5k/h25tN2WPU7Aqd1zZErdRBv1w=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbOgAwIBAgIULIRU8d9OMFDWt6IVPGxqAQALSiIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAzMjY0ODIyODk2ODMzNjc1NzAyODQ3\nNDI5NzMzMjg3Mjc4NjA2MjgwMzAwNjU5OTMxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABNCujIDZ2ankWQVDgm0Dqf68LxBnyLHsJLg3nEV9HcWbZFk8827IcDyfVjMK\nW0AV9jeZhqMmBhUoIleKUVPlQEmjgYQwgYEwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAU+0wYfMK6AWhBg2XHXIrh7AyUQ9swHQYDVR0O\nBBYEFE+23y2ZOWu6cqxWURPVsLL7+MtZMCEGA1UdHgEB/wQXMBWgEzARgg9mb28u\nZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAOvVaThjXcfMm1TTElBDDcUC\n2WYBjfyYAQAwO7lgh73mAiEA+oBcqC6Q4CQcdg2Refl5fASNBVlIh4K3TT/fqHV6\n0H4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICAjCCAaegAwIBAgITAZFABULJRP3jfEL8K9y5wwugczAKBggqhkjOPQQDAjBq\nMTkwNwYDVQQLDDAzMjY0ODIyODk2ODMzNjc1NzAyODQ3NDI5NzMzMjg3Mjc4NjA2\nMjgwMzAwNjU5OTMxLTArBgNVBAMMJHg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tTm9uZTAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFjEU\nMBIGA1UEAwwLZXhhbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATQ\nRZVaFTcBwH1Vtq13W4DxJkPdRqpTB3xban+EiSfp1P4vlu0A0uKLu8Sie46BIdH/\nwzNYNq0gbv76Y89TNywyo34wfDAdBgNVHQ4EFgQUfHyM1Ll4/aaEEMlPKehTy/VQ\nWBQwHwYDVR0jBBgwFoAUT7bfLZk5a7pyrFZRE9Wwsvv4y1kwCwYDVR0PBAQDAgeA\nMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBgGA1UdEQQRMA+CDSouZXhhbXBsZS5jb20w\nCgYIKoZIzj0EAwIDSQAwRgIhAIxfs51qkB9Ty+pmg+RZtVLIT+k5S9sv7HAi7fP4\nN64NAiEAuw5uwy2cqlhJ77oi+j5B178TO/iG27+3J5qOIgfqjIY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIFH15BFlyCBjbRtIBT2M0ciM8yAPa045zBg/BnTE4oqMoAoGCCqGSM49\nAwEHoUQDQgAE0EWVWhU3AcB9Vbatd1uA8SZD3UaqUwd8W2p/hIkn6dT+L5btANLi\ni7vEonuOgSHR/8MzWDatIG7++mPPUzcsMg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "invalid::invalid-issuer-key", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "invalid-issuer-key", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUbT1Yr1d5hOkdAK/suuO5inp/qCswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQaOohphMaz8FgzLNuHUzUsW2Io2oqWQb2AFIAj\neG/btyXxSM33K05Wu/RL4byCyzwywuqF+dme/3F7WH61HlWuo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQURCtImZ80QeJu1Tn2dHwNecViHiwwCgYIKoZIzj0EAwIDSAAwRQIg\nVmX29zLTFmgXuUu+NuzATAMCKFl+an0H1cV0Vv0HGUsCIQCqLKS/VpvXk1fX+/P6\n/YDMvm3/jTTZiXTj0dyMGPHM2g==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBtzCCAV2gAwIBAgIUO+ChpSfJ76NoRB3evFDVZIiCb9AwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBoMTcwNQYDVQQLDC4zNjA1MzMwOTEyOTc0MzMzNzIxMTgz\nNTQ3MDMxMTE4NjQ3MjQ0NDQ0MTMzODM3MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWlu\ndGVybWVkaWF0ZS1wYXRobGVuLU5vbmUwEjANBgkqhkiG9w0BAQEFAAMBAKN4MHYw\nDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBs\nZS5jb20wHwYDVR0jBBgwFoAUyRkCKXwzqoBJrFmdmzalLNA30BowHQYDVR0OBBYE\nFABIfr15XtDvPA6eQlgIe6lJB9XSMAoGCCqGSM49BAMCA0gAMEUCIH2oCaMNx6kF\nlefbyctUTy0WOCj0mibWTWW9Sgi3zQCUAiEAihdYLSxHjI9lSAbJKYNkhTS3Ig0j\nlhLRZhyERl0hl2g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBvzCCAaegAwIBAgIUDs2uz0JnNOCGAUzr5JZiOjNkLBAwDQYJKoZIhvcNAQEL\nBQAwaDE3MDUGA1UECwwuMzYwNTMzMDkxMjk3NDMzMzcyMTE4MzU0NzAzMTExODY0\nNzI0NDQ0NDEzMzgzNzEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRlcm1lZGlhdGUt\ncGF0aGxlbi1Ob25lMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAwMDAxWjAW\nMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBJfrecdyYJIzPxq92/iGG8c41zY/oDm1tjT8B30f10P9RJuo79zjwTHLYIzcOjji\neO8xnZo6ZTZUgh0dhbc8YPejfDB6MB0GA1UdDgQWBBSciSpscgQOez7ossuGcI/n\nl5j0kTAfBgNVHSMEGDAWgBQASH69eV7Q7zwOnkJYCHupSQfV0jALBgNVHQ8EBAMC\nB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20w\nDQYJKoZIhvcNAQELBQADAwAwAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIMMfIDXY2jIKRONol1mrGOa0umM66nCRpDqMVzrBfFApoAoGCCqGSM49\nAwEHoUQDQgAEl+t5x3JgkjM/Gr3b+IYbxzjXNj+gObW2NPwHfR/XQ/1Em6jv3OPB\nMctgjNw6OOJ47zGdmjplNlSCHR2Ftzxg9w==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathlen::ee-with-intermediate-pathlen-0", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> intermediate (pathlen:0) -> EE\n```\n\nThis is a \"trivial\" verification: the intermediate has a `pathlen:0`\nconstraint, but the leaf is an end entity and is therefore allowed.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUP6h0niFRRhhEPPtBNq9yXvkMC4YwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR1E8CHeGb8PSaSeK6qbVcjrwS0JNkuCuAKEI4G\nUV7ZvFr8QNOFMS8AjSJ6MipjAXpBeM9h6uHalXG7baR+ylrOo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUjCFTVCU7LLjG7fv/TflrN3y+NGkwCgYIKoZIzj0EAwIDSAAwRQIh\nAJHoluHQcy+kpTE/J+E6LIShN9pRYNtBRVVzIiAGQlczAiA/AkeaUgmVPZLI2YEr\nKqJqn2i3iJzBRvFHkBRiQA/jvQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUcBKYIpZ9Q0QMFRDOSxNjdwdivRIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDAzNjM0MjMxMDI1ODkzMjM2MTQwMDkw\nNjQ3MDQwOTM2MTI3NTAzMDEyNDQ5NTE0MzAxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBCvOEfFpvf/VUuntzNJq9aLAnHUUvLzP3XerSlyebOM2ckQfpL6LD05rX+8nz1M0\nZ8CxoTmpRO84ldmDjyEZS26jezB5MBIGA1UdEwEB/wQIMAYBAf8CAQAwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFIwhU1Ql\nOyy4xu37/035azd8vjRpMB0GA1UdDgQWBBTDtp5F//hn0wMpV81MTPXKZwlXoTAK\nBggqhkjOPQQDAgNIADBFAiEA/6fOEfnp4SS1G746HCOl4EA/Z18KZDIK1l2oepsi\nfG4CIGcf23FYrSY0wQEpP2fL7c38k3o93hiDzPjtC+w3lYfL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaOgAwIBAgIUDQ9dV7TJVHEcZf28lc/jVSFI/8kwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwMzYzNDIzMTAyNTg5MzIzNjE0MDA5MDY0NzA0MDkzNjEyNzUw\nMzAxMjQ0OTUxNDMwMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELTCL\npoxJPvqfhtvY4iJq2tfX+l+zglz60fLo9G4+uu/Y/mHKR1ddstrHpn+0DngwLeow\nANCAsgynoC6XKWIJK6N8MHowHQYDVR0OBBYEFL0xUgqURXrGSUoDLnn92KHtcXn4\nMB8GA1UdIwQYMBaAFMO2nkX/+GfTAylXzUxM9cpnCVehMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEArr+g3vylbsNGiuJcny8mw6FjlU2QoXvRAjoolv1FxsoC\nIEe1xnQiDx5ZycFenPTJcKqtq/Wzu4wjkrx0G3j9sLXL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIAjIB5uzr+yRRMaWStrCQWxy6k3w2Cypq92r+50ccIP1oAoGCCqGSM49\nAwEHoUQDQgAELTCLpoxJPvqfhtvY4iJq2tfX+l+zglz60fLo9G4+uu/Y/mHKR1dd\nstrHpn+0DngwLeowANCAsgynoC6XKWIJKw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathlen::ee-with-intermediate-pathlen-1", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> intermediate (pathlen:1) -> EE\n```\n\nThis is a \"trivial\" verification: the intermediate has a `pathlen:1`\nconstraint, but the leaf is an end entity and is therefore allowed.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUF21JZynvJPts2avVQ9JxginRndkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATSHI0DWCqdrmMV/HfQp3khAywztgZYVH8NxcNY\nRgnoMYfiRLoXeK0TS7+Pz7PDbxPWrnW21M8xMOBozeiVSyddo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUPrC3mJnq0sf3JaWNQV8I4ZC1QB0wCgYIKoZIzj0EAwIDRwAwRAIg\nXQHWY7s00QL6flbqkgeWnracoE1Csg3v1naIipQN22oCIAc1RXmoGfM82FLe4T92\neW76RXH0O06DEc3cLn1sidcM\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICATCCAaagAwIBAgIURF0t9WabVZyTOLKX7H6jCAE/vxQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDAxMzM3NDM5NjMyNTcyODUwMTUxOTc1\nMzAwNjkzMDgzNTMxNDQxOTQ3NDY5MTYzMTMxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBIuSF7if1E6lhD5sHDV70Nokj1lweJxPLLCLSMwXfkFiU7Z4wD2Vf1MvIOZujrWH\nmn2qDNGQu730D+59xBn9g1SjezB5MBIGA1UdEwEB/wQIMAYBAf8CAQEwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFD6wt5iZ\n6tLH9yWljUFfCOGQtUAdMB0GA1UdDgQWBBQpeBylisfngEuv68gNFiSQOPTljTAK\nBggqhkjOPQQDAgNJADBGAiEAq3Tcx3pnyFDr7s6yXmFL1xx5nL+b6VuDvX1KtHYZ\nlsUCIQD5KiAw6O71ZuA6paqEJnWG/H634+LAVu8vWMRt4rWYAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaOgAwIBAgIUa5WKGDYbzN+j4F/DWcgTVDTaUrcwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwMTMzNzQzOTYzMjU3Mjg1MDE1MTk3NTMwMDY5MzA4MzUzMTQ0\nMTk0NzQ2OTE2MzEzMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTEwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElYp3\nQPw4tI7tGZR9JXSXX07WB7ImndLpUl37KBEjIOeGEkecCp5YMi0IdbYvVBpRr5eY\nyiha7IRu3pyOi3aKkqN8MHowHQYDVR0OBBYEFPo/rI0xKVg0HytCw6csqPy1qHFf\nMB8GA1UdIwQYMBaAFCl4HKWKx+eAS6/ryA0WJJA49OWNMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAh4JGfRJJP9aJ0dHce/Y1NRJfEqRR1d6WJMQ14igMSu4C\nIQC0oKd7zug97gjj6sDDDM41hyghVrWhLjHIdTfKrl7Cmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIMhKXG6cNx/OoCqDeHf6H1wo2+SOs+7j1IelK11Xr5HoAoGCCqGSM49\nAwEHoUQDQgAElYp3QPw4tI7tGZR9JXSXX07WB7ImndLpUl37KBEjIOeGEkecCp5Y\nMi0IdbYvVBpRr5eYyiha7IRu3pyOi3aKkg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathlen::ee-with-intermediate-pathlen-2", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> intermediate (pathlen:2) -> EE\n```\n\nThis is a \"trivial\" verification: the intermediate has a `pathlen:2`\nconstraint, but the leaf is an end entity and is therefore allowed.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUUayBDLj4eQ/Q/w16+X1oilFjWsAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATTL0b4yugWLb27CNcq5w5p0ewAYXtIDFykgKh4\ni0ihINXC3UaYXVbnTcl//6pQl6vstzQkE4qmRJ0oSyMD/1m9o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUjHfCr8LgNfFXiFHDfy3FxLZl4DQwCgYIKoZIzj0EAwIDRwAwRAIg\nDp2LRzOvnbf0zG/PzrFQ7BJz5ASr7cPKG5aKulR3OusCIFMTCPFFhyvJedfFs3sg\nWYyxYA9FmLbctOY0XJvlqTft\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUA7DkXze51lp3VzHwH1pFlMaSCxYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDA0NjYyNzUyMjI0MjUwMTk5NjUwMzYz\nMTQ2MzI5MDY0MTE2ODEyMjY1Mzc3ODYwNDgxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBIKOwdpdEtJe5ylAj3o+INUmFv4efehGT1wtEuDO+Z1isaboW3HBifhzCunB7q25\nz0y+xTz6YCN/aZli3Yp/ylGjezB5MBIGA1UdEwEB/wQIMAYBAf8CAQIwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFIx3wq/C\n4DXxV4hRw38txcS2ZeA0MB0GA1UdDgQWBBTLzWE8pOEybPpiGpyH+yeT5QJyuzAK\nBggqhkjOPQQDAgNIADBFAiB13yra/LbLQhYA3J6Ls3UGT0XDuCG1IC8kuYU44GDG\nugIhAKoF0wHiRMhtvs0iTApr0dfGDHv9N9VdDZFe8RqyILyF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaOgAwIBAgIUU1BNNk0Cw8TPisZZMUvpsctHSm4wCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwNDY2Mjc1MjIyNDI1MDE5OTY1MDM2MzE0NjMyOTA2NDExNjgx\nMjI2NTM3Nzg2MDQ4MSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTIwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsltl\nNZwZ1GASOhXEKpXSDGT8ZpIjG7+h3Sn/Phku5DuLFxnVe8488EzPgr99PtMkJFWG\niTRM/o3e+l5yuxABLaN8MHowHQYDVR0OBBYEFKA3CXiteFfePh+GKw4CAeV0cFhE\nMB8GA1UdIwQYMBaAFMvNYTyk4TJs+mIanIf7J5PlAnK7MAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiB01AdXUDJpcKMSBuqt37iG0EkC3FbbhMJCJ0U9Z9mSbgIh\nAPRnBZ1YK0MBCrnHtp8kZnmcF46CvvMC6yZ7Av3nmFqo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEII24cjpWKLJ+sAP6M4+vrtTbnXujTth+3ELzcBP+KeSLoAoGCCqGSM49\nAwEHoUQDQgAEsltlNZwZ1GASOhXEKpXSDGT8ZpIjG7+h3Sn/Phku5DuLFxnVe848\n8EzPgr99PtMkJFWGiTRM/o3e+l5yuxABLQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathlen::validation-ignores-pathlen-in-leaf", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> intermediate (pathlen:0) -> intermediate (pathlen:0)\n```\n\nThis is, unintuitively, a valid chain construction: RFC 5280 4.2.1.9\nnotes that the leaf certificate in a validation path is definitionally\nnot an intermediate, meaning that it is not included in the maximum\nnumber of intermediate certificates that may follow a path length\nconstrained CA certificate:\n\n> Note: The last certificate in the certification path is not an intermediate\n> certificate, and is not included in this limit. Usually, the last certificate\n> is an end entity certificate, but it can be a CA certificate.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUKi07ImqRPPHd7283tj2P03oA8rMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASdcQxTrQE+aXhGM/Mi7/9tlK1sdELJ5H5/cq4c\n2kZV9FSNn3zTYe23+nRd6oMTHIBMXPqe3Bz9yLbfUKupeTyPo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU/Dh2XXQxQ7xWbZi+DvAIKQMlACQwCgYIKoZIzj0EAwIDRwAwRAIg\nOe4Rf9Q/bTJb+niRADASGcu0L6fs6hkXykB9kGt7E7YCID9a8J+1Ai0N5jQ4tfDF\nA9CmXN6iF0DfwDy18HGL9VOf\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICATCCAaagAwIBAgIUaLpH4w7EIzHi47NpUif/jpSJJbowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDAyNDA3ODYyOTcyNDQ2NTc4NzM5MzA1\nNTg3MjE5NzgyNTA0MTc4OTYzODM2NDAyNDMxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBHJ4063vKgiclE+qXmF96i19lmSeLB68rJMehJqul2FqFczNJxxbA7bAb18JfH4s\n3yD5JGcuWJS2I63N70OKJ9ajezB5MBIGA1UdEwEB/wQIMAYBAf8CAQAwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFPw4dl10\nMUO8Vm2Yvg7wCCkDJQAkMB0GA1UdDgQWBBRrBj/iuLa0IaKvpIAGomYTE/ji0TAK\nBggqhkjOPQQDAgNJADBGAiEAikmP1SU+pSMfAgZ77mXexLxvLRQbGRFhSF4JHxG4\nPZ0CIQD79a5rapiK3Ba0Mb+qx/wafwuLgHMkqNGPES+kkF2YMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgIUUXJBjADLo6YN+fU6HL5B2tSgHzMwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwMjQwNzg2Mjk3MjQ0NjU3ODczOTMwNTU4NzIxOTc4MjUwNDE3\nODk2MzgzNjQwMjQzMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMGcxOTA3\nBgNVBAsMMDU5Nzg4OTI0MTAwODYzMjA0ODQxNzExMjM0ODQ0Mjk3MDg0NDE1MTEz\nMDE3MDgxMDEqMCgGA1UEAwwheDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0aGxl\nbi0wMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE36qQ8y9G/VTjbteAr5CoeHJD\nz91E55Mq37fzRnPjwmjwsw+KQsiQQPDGgDgG9x9sugmCGZeSorIi5U1KChlspqN7\nMHkwEgYDVR0TAQH/BAgwBgEB/wIBADALBgNVHQ8EBAMCAgQwFgYDVR0RBA8wDYIL\nZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUawY/4ri2tCGir6SABqJmExP44tEwHQYD\nVR0OBBYEFP7ugwSbByh+TmLsPg5rpq42+3e+MAoGCCqGSM49BAMCA0kAMEYCIQCw\n9bFVjsHxDyHAQQUvUr98fXMFLb2BLeT8IoF3cZjd9gIhAL1U1P1lIgLnsZ4g6jma\ng9TotyIfqdo2fx8OCjViQUqe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIMCIeuFvvtK13fwGWnpgbcN87CfTpazJw2iZ8omoKELQoAoGCCqGSM49\nAwEHoUQDQgAE36qQ8y9G/VTjbteAr5CoeHJDz91E55Mq37fzRnPjwmjwsw+KQsiQ\nQPDGgDgG9x9sugmCGZeSorIi5U1KChlspg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathlen::intermediate-violates-pathlen-0", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate (pathlen:0) -> intermediate (pathlen:0) -> EE\n```\n\nThis violates the first intermediate's `pathlen:0` constraint,\nwhich requires that any subsequent certificate be an end-entity and not\na CA itself.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUVo2fAJl9pZ9avxQC+lqF2DAOp1swCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARkV7XzMR0HdVX7n6JmWKH4FzJsDivVxXrxHF9s\nolyqrjVR8qfyqiOYBGIm8Eth93+ZugK/2KuEhGkpiRIxSz8fo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUcUj6dGyX7JQv6YIdcW9TpM4A2BIwCgYIKoZIzj0EAwIDRwAwRAIg\nPww4NpPofmTK8ZKDwmIC/r/EAVAYvSar4qyLg3b7MewCICgfxpkjMniGXnP9T7z9\nA03gJZai6FhYDbNrrQt06w8A\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICATCCAaagAwIBAgIUVbpGI2ufLvc5/eb6pG9GKuzt0ywwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDA0OTQxMzE0NjI0MjEzMzA0NDY1MTE1\nNzk3OTc0ODYzMTk1NDM4MzQxNTY5MDIyMzUxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBEtmSFs5wHNUgy9kcLXwgPW2cr7kAfQdV3utgHrYxUAbwlrmGfcHLbzVZNMW4hSf\nlNqMblGnNefkTLdHf5FlU9+jezB5MBIGA1UdEwEB/wQIMAYBAf8CAQAwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFHFI+nRs\nl+yUL+mCHXFvU6TOANgSMB0GA1UdDgQWBBRcOVGzFrG07YeXgcahyJy15kSDlDAK\nBggqhkjOPQQDAgNJADBGAiEAz04Gd94QllW4CdU8aGpiBAaYXj6HSX2SDMRt7FqJ\nfVACIQCfTf2lkRiQCYXxuc8EGGSbCzHr8pbn5G81wsxLtmRorQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgIUFh73GrxSDxlevTfrVf5fLpAwlWgwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwNDk0MTMxNDYyNDIxMzMwNDQ2NTExNTc5Nzk3NDg2MzE5NTQz\nODM0MTU2OTAyMjM1MSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMGcxOTA3\nBgNVBAsMMDQ4OTQxODI2NDAzOTkwNTA0NDI0MTg5Mjg5NzY1NjM5Njk4NTM5Mjg1\nMzUzNzU4MDEqMCgGA1UEAwwheDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0aGxl\nbi0wMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEivIUT0yEqY6m3gm+UZYzHldx\nLvb3BHqtFt2tUNutdlGKPB/c2wAP6RMy6hEVq0kHc7A4WgFF7iMduGEincC9ZKN7\nMHkwEgYDVR0TAQH/BAgwBgEB/wIBADALBgNVHQ8EBAMCAgQwFgYDVR0RBA8wDYIL\nZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUXDlRsxaxtO2Hl4HGocicteZEg5QwHQYD\nVR0OBBYEFKR+eDXP4yS1KMHW3S9ttvSqYtSLMAoGCCqGSM49BAMCA0kAMEYCIQD4\nHiPDlESw8TBlmm4fWei3y9aRLBckCiXAz5BNofj6OAIhAO8gPD7CngY/Pwg1oOfv\nfqEsBQ2OZ/12SUJASBZ596JY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/DCCAaOgAwIBAgIUW78RcY5q+B7OVU/nR110eJQcAnswCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwNDg5NDE4MjY0MDM5OTA1MDQ0MjQxODkyODk3NjU2Mzk2OTg1\nMzkyODUzNTM3NTgwMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGu3d\nixyC6yTWNnVY9urfxXRGtK12ZldVLcoY/34hVxd8HV2Zb+AcQ2zYhe7QZIs6KsxH\npBGi8B2ls5Mkn7QjTKN8MHowHQYDVR0OBBYEFGW53/1Q8Rv02whee42XX8O3WD6T\nMB8GA1UdIwQYMBaAFKR+eDXP4yS1KMHW3S9ttvSqYtSLMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBJbK7lqcn4SQ4ZhC5aIOzpIi+sjo8i/s9rqMFwwZA5kgIg\nEfvJyXmDV2tTqfjDz85t66wtb92Zl/NHf9OwhvKQW3I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIL+khhPpdWP+u28vQMvLfl4+YQDJxH2y5QMNMPHbfXc2oAoGCCqGSM49\nAwEHoUQDQgAEGu3dixyC6yTWNnVY9urfxXRGtK12ZldVLcoY/34hVxd8HV2Zb+Ac\nQ2zYhe7QZIs6KsxHpBGi8B2ls5Mkn7QjTA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathlen::intermediate-pathlen-may-increase", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> intermediate (pathlen:1) -> intermediate (pathlen:2) -> EE\n```\n\nThis is a less straightforward case as the second intermediate's `pathlen:2`\nconstraint seems to contradict the first intermediate's `pathlen:1`\nconstraint.\n\nRFC 5280 permits this as part of supporting multiple validation paths.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUYSM6h84zq4p2rrdndTVk+acWQKUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQmtWvOpTApjl1Dt+CEYvCW2us5ECq5xi+Gm2xh\nhCFYZKgimYvTj4SdpfcFUbYgDbj6EVkG5HDkcsqecs5b9LH3o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUiAwye/ypzmSwj4J8F4b5Jgu4hKEwCgYIKoZIzj0EAwIDRwAwRAIg\nBwG1riy8FE6tVMSvkofXN2b2y/rYIMdOu200Q910SIYCIA73SIUUBlJiAsJlBfjn\nwPuOLjwYNDS0FOegEp0kXBX0\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUebSnmgxDMxU7RbjvAunu9sZ1jmcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDA1NTQ1NTc3Mjk1NzY2NTM4MzU2MTUz\nMDM4MjU4MTIxMDg3ODQzOTQ2MDA1OTU2MjExKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBCIgjPBMTSKeJwiUd7ZMn4GT7gLyI1Wilz1uKJ4VHFV/qgt/L7N2wDzddUwrili8\nVsoG1AvFnU9hsTs+fS6kQTSjezB5MBIGA1UdEwEB/wQIMAYBAf8CAQEwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFIgMMnv8\nqc5ksI+CfBeG+SYLuIShMB0GA1UdDgQWBBSz0ZnstmHSuTGxHNWnwtABD51xNzAK\nBggqhkjOPQQDAgNIADBFAiBTbeO2UHZIqVWoAE/oqIGopvJXaG9HjWQ3CAYb2bcW\nSwIhANWkAIncim5I/+XdlziY2s0sRVwrHuZGkp2FEEJoXndj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgIUPp0iOO+kiX86mfhBkOstpxrPcVgwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwNTU0NTU3NzI5NTc2NjUzODM1NjE1MzAzODI1ODEyMTA4Nzg0\nMzk0NjAwNTk1NjIxMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTEwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMGcxOTA3\nBgNVBAsMMDY5NDgxNjYxNzU3Njk1NDg2MDMwNzM2NjEyNTc5OTY2NjE2ODk3OTI5\nNDM1OTE0MzEqMCgGA1UEAwwheDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0aGxl\nbi0yMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwkg5yo9h4wQBcm0H+TbCF91f\nUzAk6ecVlrxpab5Hoh8oJoAh9H/JgrOSkSYbVmoA+y2X4qwj2GZGM9X/F1X+W6N7\nMHkwEgYDVR0TAQH/BAgwBgEB/wIBAjALBgNVHQ8EBAMCAgQwFgYDVR0RBA8wDYIL\nZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUs9GZ7LZh0rkxsRzVp8LQAQ+dcTcwHQYD\nVR0OBBYEFJ0lH21uo0hWqyb19mEwZ+wp99FPMAoGCCqGSM49BAMCA0cAMEQCIDxz\nQp8YYkzp/zhnxFrNT1ZjG3jDWCBOG01qip7dyyM4AiB9C82y8tV/f9+/pvgMwtQK\n2TcdIwkpAJLA1awWwXpWew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/DCCAaOgAwIBAgIUPp11GCJGEI8eTqfwvov8SdWA9K8wCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwNjk0ODE2NjE3NTc2OTU0ODYwMzA3MzY2MTI1Nzk5NjY2MTY4\nOTc5Mjk0MzU5MTQzMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTIwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXAlN\nTtAqSEDqoNFp5ImCdb4CscOLRbQEcREULq5Zgz9bMNuiLAy/q7Qw1uZDBBixEhdu\n67dBEIy6refAsgC/A6N8MHowHQYDVR0OBBYEFBMqQJjDf7q2t9yp3LDVtEfPrR82\nMB8GA1UdIwQYMBaAFJ0lH21uo0hWqyb19mEwZ+wp99FPMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBEOnc/QhSgWgIjZKdme6g4iHYFEG/feGJ195pWZKHfBQIg\nc4MfcMhhrtiWuLSqq2tIdeh7PID77xowAKxp/FxAGXs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIEm4HkCA0GoMirrsPxjo/e6wHrH2HwWrLlow5TFVhMYWoAoGCCqGSM49\nAwEHoUQDQgAEXAlNTtAqSEDqoNFp5ImCdb4CscOLRbQEcREULq5Zgz9bMNuiLAy/\nq7Qw1uZDBBixEhdu67dBEIy6refAsgC/Aw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathlen::intermediate-pathlen-too-long", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate (pathlen:1) -> intermediate (pathlen:0) -> intermediate (pathlen:0) -> EE\n```\n\nThis violates the second intermediate's `pathlen:0` constraint, which\nforbids any subsequent issuing certificates (which the third intermediate\nis).", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUOhjt4m7l6QH3zsUteM+zOX1xgNUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR2DzGhIeGSeMeLgbE26M66G+MSuIorTe6+g/57\nvmlQikv2rXJCySEZPeLiBelMhUgNWQpSY9naI4R05rqPNysxo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUgoPMakJGzFVU2qhESPN4JPNBIDYwCgYIKoZIzj0EAwIDRwAwRAIg\nIRzNUnchh1rQoPozsG+1XuWihujyyuIUt5mR1oAqP8ACIFPAZCkjZj85SibHckAW\nN+fUmGO6mv0d8nJ9zJ8AohFX\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaagAwIBAgIUDIdEeasIPgKEolINbAh8wGxES7QwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDAzMzE2Nzc0MDUyNTU1MzcwMjAxNDU3\nNzA5OTY5MjcyMTQwMTc2MTcwODE3NjIwMDUxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBF1rekmZG1hnoaD26ddbzzK5vTbqGBTza6Kwh3e3qTrG4KUQEqGOaqxFL8Oo2ohA\nFho3BOKJtK6OLTc8y+xvxsCjezB5MBIGA1UdEwEB/wQIMAYBAf8CAQEwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFIKDzGpC\nRsxVVNqoREjzeCTzQSA2MB0GA1UdDgQWBBQ8ImS+8YffmyV0kzYeNnhTztQT2DAK\nBggqhkjOPQQDAgNHADBEAiAczz4Swf26U6TblkAyYdSVbGNXkshDybeI1k8nt42p\nnQIgI7B77j/O6BDRslOLUJKAU7AhRXnWZzOIPXFJi0vvn8c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfKgAwIBAgIUJJxGsadUa/Iw+aqIIDo4DFdoYqIwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwMzMxNjc3NDA1MjU1NTM3MDIwMTQ1NzcwOTk2OTI3MjE0MDE3\nNjE3MDgxNzYyMDA1MSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTEwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMGYxODA2\nBgNVBAsMLzcxNTI0NDU0ODg4NjM4MjQ4OTA4MjE5OTk3MDc0MzkwMTc0Mzk4ODA1\nMTk5Nzk2MSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1wYXRobGVu\nLTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATmdL4lU2w3gtywwTTlPv/FT0LR\nVKMd9Sz64VGWb8kIkrT9s+HwTE8bdRqBnVhbce/oO2PGXmdGFd03zmJi7E6Ao3sw\neTASBgNVHRMBAf8ECDAGAQH/AgEAMAsGA1UdDwQEAwICBDAWBgNVHREEDzANggtl\neGFtcGxlLmNvbTAfBgNVHSMEGDAWgBQ8ImS+8YffmyV0kzYeNnhTztQT2DAdBgNV\nHQ4EFgQUs8LN09Alc5xV17ROFtkiTuxPsSswCgYIKoZIzj0EAwIDSAAwRQIgBcPe\nJUHqgvEL4icNSrDGZdqiR3OM+x3Q37DhxIun54oCIQCC6QBVMKQW6zWUksZm9HR6\n9BgyawRuZZAW+OPcmog3yg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfKgAwIBAgIUNhigCcXU/SehuNJ/cCfc/dsR0b4wCgYIKoZIzj0EAwIw\nZjE4MDYGA1UECwwvNzE1MjQ0NTQ4ODg2MzgyNDg5MDgyMTk5OTcwNzQzOTAxNzQz\nOTg4MDUxOTk3OTYxKjAoBgNVBAMMIXg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tMDAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowZzE5MDcG\nA1UECwwwMjA5MDA4NzQyMzEzMDQyNTg1OTQ0MjQzOTUyMTMxODU4NjU1NTA2MzYz\nNjA1NjY2MSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1wYXRobGVu\nLTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASEqb/cNDrfZmkqXD3yYkvxiuyU\nMewGxtd4IFtdod/O1HHK2JN8oSi/T1qopv5Z3Y9g0vkd4fa1DcgEfsplCx1Io3sw\neTASBgNVHRMBAf8ECDAGAQH/AgEAMAsGA1UdDwQEAwICBDAWBgNVHREEDzANggtl\neGFtcGxlLmNvbTAfBgNVHSMEGDAWgBSzws3T0CVznFXXtE4W2SJO7E+xKzAdBgNV\nHQ4EFgQUc8el/WSPtUxzmbUeigiC8rUmLUowCgYIKoZIzj0EAwIDRwAwRAIgCDjb\nabMjVHACzLjJuErBgJdV481DKKpzL/8SLj3qyDgCICbfaNH0TJ/CTzVDxZSyZ5J3\njkJMOrxtdrTtsK0Unsq1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaOgAwIBAgIUeOn5Sb0m4AxiFapV5jiZOPkAJoAwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwMjA5MDA4NzQyMzEzMDQyNTg1OTQ0MjQzOTUyMTMxODU4NjU1\nNTA2MzYzNjA1NjY2MSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn/9q\ns2haBZZ8nGm2J/LKEzHoa7zrbIpzGzL9IC9vANFn2h8saHh+oejBPhD/8e1GoVBE\ne0Un62UDOM+fWVfj96N8MHowHQYDVR0OBBYEFA1imDMrGt97VW7eBITK70rXTr//\nMB8GA1UdIwQYMBaAFHPHpf1kj7VMc5m1HooIgvK1Ji1KMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAjb8WzC1wdaf5Zky72WUqnTRVBsdtBxiHMh9sXYVStrMC\nIQCn/3Lo7ULmqaCncjOPAKRPHe5sXROzvlhpgA13VXqI9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIGHmYWeTTCv48mwN+8+GASN15Ymbu4aZo7y6x7CFRcfCoAoGCCqGSM49\nAwEHoUQDQgAEn/9qs2haBZZ8nGm2J/LKEzHoa7zrbIpzGzL9IC9vANFn2h8saHh+\noejBPhD/8e1GoVBEe0Un62UDOM+fWVfj9w==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathlen::self-issued-certs-pathlen", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> ICA' (pathlen:1) -> ICA' (pathlen:1) -> ICA'' (pathlen:0) -> EE\n```\n\nThe second ICA' intermediate is a self-issued certificate. Self-issued certificates\nare certificates with identical issuers and subjects. While this chain trivially\nseems to violate the assigned path length constraints, the RFC 5280 4.2.1.9\nstates that self issued certificates should not be counted.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUEJU52jhGTi5GjdNF8JnDxFm8fVMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATZenDKbKpSFLSa0jwrClv+QbXL9Pfbsavua33J\nB/o7npUTA4sSdQaMEgpAUc6ig6isD0J9SoK1zI/vRxhEQn1Co1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUCFEY86d2dH3xF4i0yNare0XoVFQwCgYIKoZIzj0EAwIDSAAwRQIg\nU2iChVDxdbr22ei0bn7GPEUIX6J/t2TdztwNnLgRP6oCIQCpZppuGJukDZCBK8qm\n61osEE8NXDu+Q+S47t4YiNaB0Q==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaWgAwIBAgIUSzPTHYOcEembtgw1KbdtZdHe5LcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBmMTgwNgYDVQQLDC85NDY3MTcwMzAyNDQxODQwODU3Mjc5\nNTcxMDg4NTk0MTQzMzk4MTU1ODYxOTQ3NTEqMCgGA1UEAwwheDUwOS1saW1iby1p\nbnRlcm1lZGlhdGUtcGF0aGxlbi0xMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJKEyc1ipYQFDVaSZ8QpYmMWcmdbDLeR3ljOFT3fJicTAT3Te/rywR6wm1xfxPrxf\ncl0ib10CDLfmaFz26GSKFqN7MHkwEgYDVR0TAQH/BAgwBgEB/wIBATALBgNVHQ8E\nBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUCFEY86d2\ndH3xF4i0yNare0XoVFQwHQYDVR0OBBYEFPNoFuzQ8TVBdTLMHK3rVHAhsqrGMAoG\nCCqGSM49BAMCA0gAMEUCICeBJZdkphoRwiESnr0ypD3FAPaUtHdnGCfbcma99XCI\nAiEAhGOHnc8ZZ79br80SbaV1jIizP0pny4THdYdN4iTMOOE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgIUKy8toYop3BWSTg4RByn6N34u4MkwCgYIKoZIzj0EAwIw\nZjE4MDYGA1UECwwvOTQ2NzE3MDMwMjQ0MTg0MDg1NzI3OTU3MTA4ODU5NDE0MzM5\nODE1NTg2MTk0NzUxKjAoBgNVBAMMIXg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tMTAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowZjE4MDYG\nA1UECwwvOTQ2NzE3MDMwMjQ0MTg0MDg1NzI3OTU3MTA4ODU5NDE0MzM5ODE1NTg2\nMTk0NzUxKjAoBgNVBAMMIXg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBhdGhsZW4t\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJLZUca3oX0m2qsz+2TXNZ+gQZte\nTVvVrzW0YeQpBVp7OSOnc+0tb8oxerhJhm8g8kVDCJ6WvPGry7hTwkcds3SjezB5\nMBIGA1UdEwEB/wQIMAYBAf8CAQEwCwYDVR0PBAQDAgIEMBYGA1UdEQQPMA2CC2V4\nYW1wbGUuY29tMB8GA1UdIwQYMBaAFPNoFuzQ8TVBdTLMHK3rVHAhsqrGMB0GA1Ud\nDgQWBBQCKNYY+jrfAtQQZOidY7MB9c2XuzAKBggqhkjOPQQDAgNIADBFAiEApTg4\nI8jknwD660vaqE4X2V7116beyHlzk+nLQlF6lrwCIAwXEaq5X3mogvrZ5xWYNnVV\nQXg9AjtfXra/cXpsOHHt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfKgAwIBAgIUegOG82f+YXVxe4yNYrYjiEWgNHswCgYIKoZIzj0EAwIw\nZjE4MDYGA1UECwwvOTQ2NzE3MDMwMjQ0MTg0MDg1NzI3OTU3MTA4ODU5NDE0MzM5\nODE1NTg2MTk0NzUxKjAoBgNVBAMMIXg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tMTAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowZzE5MDcG\nA1UECwwwMjQ2NTM4NzEzMTkxNzM0ODUzNzQwNTcwNzg5ODE4NTQ0NDc4NzQ3MDgx\nMjM2NjgxMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1wYXRobGVu\nLTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAR2HVemBs/4T6PRTLPjI67Q/GKh\nxQbIh+R8Z+ZmRpdKop2kyrk7RWkHCjitqnFAc16st0Ij7KLEUjxH92FLjdaXo3sw\neTASBgNVHRMBAf8ECDAGAQH/AgEAMAsGA1UdDwQEAwICBDAWBgNVHREEDzANggtl\neGFtcGxlLmNvbTAfBgNVHSMEGDAWgBQCKNYY+jrfAtQQZOidY7MB9c2XuzAdBgNV\nHQ4EFgQUK5DAhct8vkbFQputfaQfEokuqzIwCgYIKoZIzj0EAwIDSAAwRQIhAKLM\nRD9/pRFzZYDddX4F8e6wmSis+vUAlyXDly3odO4VAiB+cMmpmCDBOiqZAs53GZnY\nHUvM/5KGV70tRWghPAskJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaOgAwIBAgIUR5oMPb+ZnYYeKTeX69Ve5u4WIu4wCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwMjQ2NTM4NzEzMTkxNzM0ODUzNzQwNTcwNzg5ODE4NTQ0NDc4\nNzQ3MDgxMjM2NjgxMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKO7S\ntuCo5SDu+ApuFdh/t89AF2fh/SPYvqbIJee73iy0hy+iaxJ+kHhI/cUH2ZpVH4Od\nmDFwGyTjooQUz/IiBaN8MHowHQYDVR0OBBYEFCayz7kM4Amy9V5qHyddzSTMy/yQ\nMB8GA1UdIwQYMBaAFCuQwIXLfL5GxUKbrX2kHxKJLqsyMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBroI30WzCOKXV37s9lZajijw4wiYvwTtbsqDKb4vgthQIh\nAN4iSEmwJz9/GP6PRAbrldezjDdYqTXP4FJUkYLNg3U8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIILklhJLxvsfSZ7SVuUkFHYwBxtsysLfJgXiTu1HzvMoAoGCCqGSM49\nAwEHoUQDQgAEKO7StuCo5SDu+ApuFdh/t89AF2fh/SPYvqbIJee73iy0hy+iaxJ+\nkHhI/cUH2ZpVH4OdmDFwGyTjooQUz/IiBQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathlen::max-chain-depth-0", + "conflicts_with": [], + "features": [ + "max-chain-depth" + ], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> leaf\n```\n\nWhen validating with a maximum chain depth of 0, there may not be any\nintermediates.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUZ4UO1IV5LZJ0CJWLtg7jdTv31QQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAT4kIHfUBhhrdZG/EvwDNibwq8uuMGbZmSBO7O3\ni0kZMft99yHNaeJz7kDUCIfFC8sIqG93MS2YOJff7Pizh34Qo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU6b53lSOzVYgnlq1+isH2qMJ7NmIwCgYIKoZIzj0EAwIDSQAwRgIh\nAINIEzZoAhfA3q0T8WBGMs4IDcWeUCkms7BNTPV2p/mYAiEAlv5i7JuB2gGh0ZcR\ntX+Pey1KjlB7W4znbxPTOCRMNfo=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUak7oIZMENNE3FX2VLxggOgU6RaYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABLIxmIIAwzwE4URcpJ7087H8q3Zk6J6cPCvd0zYmacHE\nlMy+8i/WhfBwC83Bjh+e66qo8zo01kvx/+KLgj2aiJSjfDB6MB0GA1UdDgQWBBTn\nE0claZ4sjnq5BD48baybsuU4KjAfBgNVHSMEGDAWgBTpvneVI7NViCeWrX6Kwfao\nwns2YjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAPRPBn31PYNUXzSfJu0c\nFxiNnKcpBewjXpSX0bt4atL6AiBiBi4aq829P0eCeHr4HNN5KssUf1jBe649TZWU\nsBXiGw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIP2Z++goC19+bQ2W7WDx61VJnDitl+jYc/2/6Z4GvL5moAoGCCqGSM49\nAwEHoUQDQgAEsjGYggDDPAThRFyknvTzsfyrdmTonpw8K93TNiZpwcSUzL7yL9aF\n8HALzcGOH57rqqjzOjTWS/H/4ouCPZqIlA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": 0, + "crls": [] + }, + { + "id": "pathlen::max-chain-depth-0-exhausted", + "conflicts_with": [], + "features": [ + "max-chain-depth" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA' -> leaf\n```\n\nWhen validating with a maximum chain depth of 0, there may not be any\nintermediates.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUJ33YBFxa5XZUG/2d2HI1s8i2ThYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAS/tK60P5k3Zlu9UN0HXQu3PtHyeYoZsJ2HJSbN\nqBbISYJnatYodrMChve64svQsEauC3l3pRNEEhCU1qFuD53Bo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU0u5D19cHoTTp3yp7h2J3tsajVecwCgYIKoZIzj0EAwIDSAAwRQIh\nAIOw5bT7PXKgf3D7gtTfFmRBXpXGyn0sVKLHrj4rMrGQAiA4xCTJzl3IySVs61D+\nKCtfH4KeaVTPQrHiG57SbSZpLw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUGBQfUV1ak9Imkuf9beaqz1EXGvgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAyMjU0NTcwNTA5NDk1OTc3MzM2MTEw\nNDc0ODc4MzYwMDgzMzEyNzkyNTkyOTExNTgxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABNEOGR8dVajrIP10IsoHiKEchIrJmiQmecCUaooKyKbnuDL5pfCRktlZZhE5\n6NiRFkG5cQ9urOImhpPtLa6FrJajeDB2MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFNLuQ9fX\nB6E06d8qe4did7bGo1XnMB0GA1UdDgQWBBRwQzKjOz3hcRVwJsssakZPutXm+TAK\nBggqhkjOPQQDAgNIADBFAiEAnTcnOpjyvkmLd+9l5oMSHBKk+dppwuPQRTw9S4VP\nJ3ACICgOxqGZDdrJtHxE8iwmASFoyZXbYthPcMA1hFoW/Uaq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUb0/TfuifojTUhedpF+Ym08vzQ5QwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMjI1NDU3MDUwOTQ5NTk3NzMzNjExMDQ3NDg3ODM2MDA4MzMx\nMjc5MjU5MjkxMTU4MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n75eciyzmE/cMWXnQPtM3zHzzZHblylkwgyH4dqWOLI5DcjGD/K2GLKi/HJVTQduv\nY7tYmmm+8BwcxBtNUHrN3KN8MHowHQYDVR0OBBYEFPPwcYLK61eCvaDRQMe3/17R\nzaNRMB8GA1UdIwQYMBaAFHBDMqM7PeFxFXAmyyxqRk+61eb5MAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNIADBFAiEA9PM4lChKZVXBhqJQpooGTbgMkxkds71l2ilGmoUQ\nUWgCIBA5Beg2r9FHpsa249vU7FqXC6LlHHGJI+DOwrW2HqOx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDuuGJyS0yy3sYDl3DNtWQZPi0X+CcdnzCC1HkesraeqoAoGCCqGSM49\nAwEHoUQDQgAE75eciyzmE/cMWXnQPtM3zHzzZHblylkwgyH4dqWOLI5DcjGD/K2G\nLKi/HJVTQduvY7tYmmm+8BwcxBtNUHrN3A==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": 0, + "crls": [] + }, + { + "id": "pathlen::max-chain-depth-1", + "conflicts_with": [], + "features": [ + "max-chain-depth" + ], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> ICA' -> leaf\n```\n\nWhen validating with a maximum chain depth of 1, there may only be one\nlogical intermediate.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUGnDlca1hi8kb9BwUFSIolHTroP0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQOXlQLI5MqK6fpltVH7Pbi7vtONjdE0bwDCbe1\n4ci0R39Ew7cKaWBqX4CxQDx8t4M7qM8dvO/gbXDcBA7K9Cglo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUJLJOSD+NA1ThWW4plJFCCP3TmkcwCgYIKoZIzj0EAwIDSAAwRQIg\nSGIVRK5YGR6t6UIBtVOQisVtIKap/duJ6PQqUj7xYuUCIQDB/VWpRTBoN/qiO4SY\noNb8TwM1Ix6K+9hWW+Dpqn6E5w==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUB0NIp/m75+rZ73SJIhCbki2A9owwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAxNTA5NTE0MzA4OTk1MDQwMjM4Mzg5\nNTcyOTI1MDcxMjkyMDc0MjUxNDk0MTE1ODExLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABH028+kO7MWtkVznncYK0x93pjZ3k37pCcHuDE72AV59Sov+dQu/nLUdjCGm\nlM/IbzqG8mpTK+fu5xr73pcUbNSjeDB2MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFCSyTkg/\njQNU4VluKZSRQgj905pHMB0GA1UdDgQWBBRb88NWDxhfu+LB4ANU3Ndla7dDKDAK\nBggqhkjOPQQDAgNIADBFAiEAujpYFWYu07MrphVaUxpc6+/vttWYVUa+LxVXlG05\nuJUCIHu1rTK0EWEo0yZ0+oYfZS8UlBNZqgFlNe0zVtota8cR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaagAwIBAgIUE0ex6AGzQ+Mti4sDp9WlGInymSMwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMTUwOTUxNDMwODk5NTA0MDIzODM4OTU3MjkyNTA3MTI5MjA3\nNDI1MTQ5NDExNTgxMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nC6spW2D3AIUX2EB3hNHFVL7jgeIi5lVXbDI5BTsjiLd/b8XhukHOgjTFw7qj8PXi\nKKqSEEH3XOdwpw05z/az06N8MHowHQYDVR0OBBYEFC/j7Ur626/USwj/XzhMf5r9\n3hQeMB8GA1UdIwQYMBaAFFvzw1YPGF+74sHgA1Tc12Vrt0MoMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNHADBEAiBwnmSb4Exuzp7T8WAhOscjqZ7vCTmoLVyvHIuF0KKe\nngIgLfcFtRBfFePm5ifv/9ZSPnqP90/NmZlJjdclBXBPca0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIKy4qPzuMgU/Jmxmq4rb/FRKBct2RocQd0Z4Mb1j5K1aoAoGCCqGSM49\nAwEHoUQDQgAEC6spW2D3AIUX2EB3hNHFVL7jgeIi5lVXbDI5BTsjiLd/b8XhukHO\ngjTFw7qj8PXiKKqSEEH3XOdwpw05z/az0w==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": 1, + "crls": [] + }, + { + "id": "pathlen::max-chain-depth-1-exhausted", + "conflicts_with": [], + "features": [ + "max-chain-depth" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA' -> ICA'' -> leaf\n```\n\nWhen validating with a maximum chain depth of 1, there may only be one\nlogical intermediate.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUYdzwkzbYyvegCZ33wG4Y93+BopEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQMo+y04Si9cxbG29hvKT/yylEmFMUO6TS/Opj6\nsIcbq9pjBSVjnaGxPGYl0073B/w7k5AYDUkWSGGRPbuQrz9Wo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUBnWZxWkBFgkH5DhMSnFoqv5XrYowCgYIKoZIzj0EAwIDSAAwRQIh\nALr9AtnN0IUOHvJA+0u19IgwwOUJY06caPJLVe/MKiE+AiBKMpMqcIDIqmVsxM1O\nhJH0o769PDo6dOUxRmTP3NcAhQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICATCCAaagAwIBAgIUQyWpnIh/XwBWHn9/9AzGLHHZDqwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA1NTg2OTkyMjU3NTY2MjQ2OTUzMzgz\nNTY0MTk0NjkxNjEyMzEzMjIxMTY2MjkxMzcxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABH1X0B7Kd+WJy0EFxi/zO+x4bzebtNgKCHZxET87XDnPhesNW7wtl0F8/IKq\nkGljT1IkiZeGYePzGUet+hANDFqjeDB2MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFAZ1mcVp\nARYJB+Q4TEpxaKr+V62KMB0GA1UdDgQWBBQT50jYAn4EQ56ZBPl6wpJUStYdoTAK\nBggqhkjOPQQDAgNJADBGAiEAg6KOvEqbGnzJ2xLmYLDErYDp+ENAmaFwvTXafvaV\n53ACIQDI/BLz7o3Wk880GIFvCDml80jl2l8x6pGg1zPBKGHiRQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgIUMuFAfYUXSLP5HkxSAY9cVzDNaw8wCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNTU4Njk5MjI1NzU2NjI0Njk1MzM4MzU2NDE5NDY5MTYxMjMx\nMzIyMTE2NjI5MTM3MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMGox\nOTA3BgNVBAsMMDM4MzM0MjI4NDQ1OTM1MDk0NDMxMTI4ODQ1MDU2NjUyODM2NjY1\nMzY0MjE4MjMxNjEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0\naGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl8iZu+D5rMotA6sq\nMlXSK8fkXuL7nujIf6qbQe19IwncNIPYbOgcmwGL+TGg8H2CkWp8jgkHVeL8R7vy\nt9LFtKN4MHYwDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8EBAMCAgQwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUE+dI2AJ+BEOemQT5esKSVErWHaEw\nHQYDVR0OBBYEFJO2ywEc6dn/xNG7S9FB4Mvxh508MAoGCCqGSM49BAMCA0cAMEQC\nIGOb6bJ5aKPRxW+KOInn2B3pcoyR3+e2bhmqIiPgd6cKAiAhJymzZyAl4Z6ijD2Q\nzZLYcdNMYm18+kYHHjU2dGzFFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUFS7Zh1AXELWpeSk8nqeSLBPS0I0wCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMzgzMzQyMjg0NDU5MzUwOTQ0MzExMjg4NDUwNTY2NTI4MzY2\nNjUzNjQyMTgyMzE2MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxYq2H886GTYrZuU9LJz3fd1gdPJHbI6+KG8jrdTOAz0fAGSrj4bmLdcCc+Wn5CWz\n8yNcIWBvyKgpMUFFK2DVD6N8MHowHQYDVR0OBBYEFCcDxvLpF0dyggZ2+o3Rx583\nxGQfMB8GA1UdIwQYMBaAFJO2ywEc6dn/xNG7S9FB4Mvxh508MAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNIADBFAiEAjbzX7Ns13KS6A+u2gSg3mfXjDVXx4UUC04zqIcrF\nmPQCIAo8z8QcDxnCtXgdp9z91ZlbCwvPDHQy3lWBuEDAZm7u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDclSVol4u58lNbj0GZnGK15Y/E/gRx0DlK5r0+QDVaCoAoGCCqGSM49\nAwEHoUQDQgAExYq2H886GTYrZuU9LJz3fd1gdPJHbI6+KG8jrdTOAz0fAGSrj4bm\nLdcCc+Wn5CWz8yNcIWBvyKgpMUFFK2DVDw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": 1, + "crls": [] + }, + { + "id": "pathlen::max-chain-depth-1-self-issued", + "conflicts_with": [], + "features": [ + "max-chain-depth" + ], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> ICA' -> ICA' -> leaf\n```\n\nWhen validating with a maximum chain depth of 1, there may only be one\nlogical intermediate.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUQp1yP5X6T19Hg5VxamqECMj49jAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASb2VBGuhFrRQN34wrENjnLYi6vYs5ww9WI8Znj\ncmplvgmu4YIUWqAKyjzlTqFtg/PSTAru28yTwf2cRipA7j5Ho1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUMB4dfX+qSRfcQRTqE4GldpqpjvAwCgYIKoZIzj0EAwIDSAAwRQIg\ncg4UCDnX3K8Ex1L3AkQXO0h/bpuLUWVVNfmQGD7FwLwCIQD3QYBo6eY9sJVJBq/c\nPKPVzdqPysIqN3HE1VtQq6ZFGA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICATCCAaagAwIBAgIUMlki9pgf3kRPCUHmqibxtNnoefowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAzODAzMDQ1NjAzMDgyODI3MDg1NjU2\nMDIzMjcwMzE5MzI2MzU2NjY0NDc5MjI3MzYxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABFhZWbqTFmaUkZh7ypmedYrqGr3xfNNTdeO3FS2SdFUcVDnmFKOfdRFJddAR\ncfigJMIHtdqz381usJAYVQ41OZ2jeDB2MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFDAeHX1/\nqkkX3EEU6hOBpXaaqY7wMB0GA1UdDgQWBBQ2D63uLfglLhZhimldFuq8wtOAtzAK\nBggqhkjOPQQDAgNJADBGAiEAt5IjZc41H0I9z3yVFR+1WvTNIHvLzxXNEUuRF1nd\n6QkCIQCPthtu660iVX+Gup8Zvhy1SXEheuFPF4EG9sVw2S7rZg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgIUHLda/7KzOuwK++TocD6e7tsIGxowCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMzgwMzA0NTYwMzA4MjgyNzA4NTY1NjAyMzI3MDMxOTMyNjM1\nNjY2NDQ3OTIyNzM2MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMGox\nOTA3BgNVBAsMMDM4MDMwNDU2MDMwODI4MjcwODU2NTYwMjMyNzAzMTkzMjYzNTY2\nNjQ0NzkyMjczNjEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0\naGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGBC7849ZXL/LGf8a\nu/DiCCzaou7r2GexsSBpu5GYljiXyd8D1YLE7KLdwtFiZmEbIpzHiwCFGWpCkGPH\nQ5ndqKN4MHYwDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8EBAMCAgQwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUNg+t7i34JS4WYYppXRbqvMLTgLcw\nHQYDVR0OBBYEFMvg4GJM/AutCYKo8kzgIhW0MdjZMAoGCCqGSM49BAMCA0gAMEUC\nIGXNM30RwsJFCxeQJGzMEZm/zld4Z11/lHgrc3kdTykeAiEAoyinFU8nZbejerjI\np0RQqMn6P6Hcf9mzFEteQ/lH48M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICATCCAaagAwIBAgIURlFqigQo/af5QNLq+rxwoTJNVa8wCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMzgwMzA0NTYwMzA4MjgyNzA4NTY1NjAyMzI3MDMxOTMyNjM1\nNjY2NDQ3OTIyNzM2MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nh08Iwtv1RRCxPosd1FnBCgzsA2LQYy9MKI7Qm86wYMlW9z4Ii1Hwn1oeXDxAzwBc\nQT2BxaGI2y9VhM5E3NpX+aN8MHowHQYDVR0OBBYEFE8I/WXX4vSf3Tdc0x/4NTyS\nAc9hMB8GA1UdIwQYMBaAFMvg4GJM/AutCYKo8kzgIhW0MdjZMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNJADBGAiEAh6jRShsgnrDDls2zX01k+j+fJwhfEO9xAaR1cZK7\n67wCIQC8Eu3jU+XtBxzx2Kzk+r3gl3DS0a9DWHbRrsH6elDJ9g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIAZeXBBq6y25QNFJ5dKbQnRn9mRVw3sYa39mYt4TIq+NoAoGCCqGSM49\nAwEHoUQDQgAEh08Iwtv1RRCxPosd1FnBCgzsA2LQYy9MKI7Qm86wYMlW9z4Ii1Hw\nn1oeXDxAzwBcQT2BxaGI2y9VhM5E3NpX+Q==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": 1, + "crls": [] + }, + { + "id": "pathological::multiple-chains-expired-intermediate", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following chain:\n\n```\nroot 2 -> intermediate (expired) -> root -> EE\n```\n\nBoth roots are trusted. A chain should be built successfully, disregarding\nthe expired intermediate certificate and the second root. This scenario is\nknown as the \"chain of pain\"; for further reference, see\n.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUDxHKuQVcWDzGeXLyP5fXU1E41WAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASmPvknuc9VK/m86FTUHRxjfy9A9VmTy5HTktab\n1z2cceopjckTOOEsQOh7B9yZJ3HseGRtIT3ltUt8QLkact3bo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU/S/koyKnp9BHWa9MicCcZw+UBSswCgYIKoZIzj0EAwIDRwAwRAIg\nR8VLnsO+P01BO4uBmmfROuh0y+vluLDvzHvACl1PL0ACIC1gmRD5FDAm+8Wya3pi\n0Nsm0G9NgGYKuYQFnqP5gChv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBkzCCATmgAwIBAgIUVg2WSnTDXWsRxQZgmE/m49GRvqAwCgYIKoZIzj0EAwIw\nHDEaMBgGA1UEAwwReDUwOS1saW1iby1yb290LTIwIBcNNzAwMTAxMDAwMDAxWhgP\nMjk2OTA1MDMwMDAwMDFaMBwxGjAYBgNVBAMMEXg1MDktbGltYm8tcm9vdC0yMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbLmnaiciRuj+hgYsyPqArKYNTnSvsTRY\no7T5lGHtTQ8ddMwdEsvrpCiL0A8GLxOYn3Dlpt4DqiOZ5378afhqTKNXMFUwDwYD\nVR0TAQH/BAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5j\nb20wHQYDVR0OBBYEFFGbiUdxUUQFGhd3d/L/aG/n/IQ/MAoGCCqGSM49BAMCA0gA\nMEUCIEgLu+9EG2U39j9fLO8NDyg7Nq9sazQ0PFd/UX9dYphQAiEAgwWPc2AvyfJm\nwFNs2Y96n2NI/6lNLWfFBXL4oI7DlI8=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBszCCAVmgAwIBAgIUJ1O9eg1pKI/ESxRRbBHxoC3m/GUwCgYIKoZIzj0EAwIw\nHDEaMBgGA1UEAwwReDUwOS1saW1iby1yb290LTIwHhcNNzAwMTAxMDAwMDAxWhcN\nODgxMTI1MDAwMDAwWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASmPvknuc9VK/m86FTUHRxjfy9A9VmTy5HTktab\n1z2cceopjckTOOEsQOh7B9yZJ3HseGRtIT3ltUt8QLkact3bo3sweTASBgNVHRMB\nAf8ECDAGAQH/AgEBMAsGA1UdDwQEAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNv\nbTAfBgNVHSMEGDAWgBRRm4lHcVFEBRoXd3fy/2hv5/yEPzAdBgNVHQ4EFgQU/S/k\noyKnp9BHWa9MicCcZw+UBSswCgYIKoZIzj0EAwIDSAAwRQIgP6h9BmV5pWYT4G8c\n2FZMFwZZdPgh2O7e3+5pwyKj7EoCIQDIntOhkNjPcQJbjhLLQzn3UH4h8yk4C0H+\nzoLQiUx8FA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVagAwIBAgIUM7TomAjfhifrPSYXNqXR3HYO89EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABBvwuhsHq8SUUTqedCgOzmsAP/zEBilZXWee/gTUW2VB\ndw2uGvCU1+4AdKLo1c6X0GaISDp+Oc0otAVQoYA/VHejfDB6MB0GA1UdDgQWBBRW\ng4fY71lwS/ePLy1HKp7deG1cljAfBgNVHSMEGDAWgBT9L+SjIqen0EdZr0yJwJxn\nD5QFKzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhALoGgIcOq/d01JAJ4Q5u\n/YLp09Vb5DmJyOe1xyabMulzAiEAwPmm03EEu2YuvIqRbuWzXI8dYx7GNsII30JQ\nIvgka5Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILrdk925DHjH1FPO5C19bb7Fs0lwjP2Q46rExo3fK//qoAoGCCqGSM49\nAwEHoUQDQgAEG/C6GwerxJRROp50KA7OawA//MQGKVldZ57+BNRbZUF3Da4a8JTX\n7gB0oujVzpfQZohIOn45zSi0BVChgD9Udw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathological::intermediate-cycle-distinct-cas", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -/-> (ICA' <-> ICA'') -> EE\n```\n\n`ICA'` and `ICA''` are separate logical CAs that sign for each other.\nNeither chains up to the root.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUdDCQvZXyxtzjYXjDL2kNLu4UOPAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQkGy0NTDc6X/aztikzafX8rTuBzc1M8jfRjbF1\nYmYyAC35zWO0oom2Hp8hO1BSWOQZBfLvnOO0P8SIyIeOj6YLo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUc5w1gSE7zEKCnh9ol09vpKBl9SIwCgYIKoZIzj0EAwIDSQAwRgIh\nAPRvcOZicE0jE7hsSkKV2hA4BM9O6kPkojJhGot9d+z4AiEAkXBWuZUs0aoOGuq+\nf9KIZe+vsQ9llZAEBHo7sJWsfnY=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBuDCCAV6gAwIBAgIUeMwFCba67gpa804l1iAa7lZROYUwCgYIKoZIzj0EAwIw\nKjEoMCYGA1UEAwwfaW50ZXJtZWRpYXRlLWN5Y2xlLWRpc3RpbmN0LWNhMjAgFw03\nMDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowKjEoMCYGA1UEAwwfaW50ZXJt\nZWRpYXRlLWN5Y2xlLWRpc3RpbmN0LWNhMTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABLoghW8LEn6UU8hoRmN9a28Oo6TLV0VH0k3rnD9dep1s+osHborREab0XUwy\nkd47QZKkE4R6EjiYTSwkNaB2s1ajYDBeMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMB8GA1UdIwQYMBaAFGb8DfiphWEAjEnmo685H3LOGxmfMB0GA1UdDgQW\nBBTox+7cPEttbQ4U0mwE4n7LFeO22jAKBggqhkjOPQQDAgNIADBFAiEAupFKM+xn\nnbiYy7zxpuQ9nAQbR8jHciOPW0zyRNxthMsCIA1Wb1LW4g+N3L4wzUbdxYSq87M3\nyEie7IGrGdd8Vmys\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBuDCCAV6gAwIBAgIUfC/yG+K+21HEUcbheDxZ3ztJ1PEwCgYIKoZIzj0EAwIw\nKjEoMCYGA1UEAwwfaW50ZXJtZWRpYXRlLWN5Y2xlLWRpc3RpbmN0LWNhMTAgFw03\nMDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowKjEoMCYGA1UEAwwfaW50ZXJt\nZWRpYXRlLWN5Y2xlLWRpc3RpbmN0LWNhMjBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABCKeJ0Q6eb1FBDi18AN1kbWZGcx+3eyOtVbYNIFOWNXL+PE2oOLewCJw4aoo\nVERO6G+6oL9AcfE3EkrL3ndv8DqjYDBeMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMB8GA1UdIwQYMBaAFOjH7tw8S21tDhTSbATifssV47baMB0GA1UdDgQW\nBBRm/A34qYVhAIxJ5qOvOR9yzhsZnzAKBggqhkjOPQQDAgNIADBFAiAOAo1z8wgR\nwCiW1MVDwQ+RTc9uw/X/hXKLGfNIJd9ywQIhAPqyp3hS+C7xBWA7gPkEvmpfStPi\nm4AucVY+V2hyvi1y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBvzCCAWagAwIBAgIUNrGYKxZWmozkUGG6WL+1GSssJSEwCgYIKoZIzj0EAwIw\nKjEoMCYGA1UEAwwfaW50ZXJtZWRpYXRlLWN5Y2xlLWRpc3RpbmN0LWNhMTAgFw03\nMDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFjEUMBIGA1UEAwwLZXhhbXBs\nZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATLr9CDSgGHWBHifSxqhWjN\nsljs3ZhYL/2JoM9aUkHdJuQ/jZL2F5BwGjWgg4JsIGkPFnK0fVsQGL5wKaMgtGEV\no3wwejAdBgNVHQ4EFgQUH4BRg//zzevhVw7/SIlpaPxZY9kwHwYDVR0jBBgwFoAU\n6Mfu3DxLbW0OFNJsBOJ+yxXjttowCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsG\nAQUFBwMBMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIEIgpByyJQLebDF8nbKpwVkQk+VJ26DUa4q01EGOEh4iAiBrixRzEq7T4akkFC78\no9ghuinUUCH3qT9Gmf2vVNm5+Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEINFkaUsnKawTLGE5h1V6ocuU/h8Y0O/5UfTMf8FfRtjkoAoGCCqGSM49\nAwEHoUQDQgAEy6/Qg0oBh1gR4n0saoVozbJY7N2YWC/9iaDPWlJB3SbkP42S9heQ\ncBo1oIOCbCBpDxZytH1bEBi+cCmjILRhFQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathological::intermediate-cycle-distinct-cas-max-depth", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -/-> (ICA' <-> ICA'') -> EE\n```\n\n`ICA'` and `ICA''` are separate logical CAs that sign for each other.\nNeither chains up to the root.\n\nThis testcase is identical to `intermediate-cycle-distinct-cas`, except\nthat it specifies a large explicit max depth.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUDqTf8Niu8BXOzpwy5zHIdFD4Ug0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARM9699abwtoRDHvrPDJQIZzF0oZ3XYj7JcLuDH\nvFDV9Ju6JbKBQz4kdamSmCYhm6cqYBYLpAjsNbHtJmW9HxCIo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUvSdmOB3qDEr8NaZJO2uY+h4DstUwCgYIKoZIzj0EAwIDSQAwRgIh\nANOq7TVXa0PdcJ27ORAshQ2mDo2tMuUD2ho/AOgf1mg8AiEA45OntCWsGob3rnYu\n62SoYJ840dXrnEzwhTgGXxn5AWw=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBuTCCAV6gAwIBAgIUVtofXKwk/+nTLUcouT/Y5jb8sbkwCgYIKoZIzj0EAwIw\nKjEoMCYGA1UEAwwfaW50ZXJtZWRpYXRlLWN5Y2xlLWRpc3RpbmN0LWNhMjAgFw03\nMDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowKjEoMCYGA1UEAwwfaW50ZXJt\nZWRpYXRlLWN5Y2xlLWRpc3RpbmN0LWNhMTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABHmdeZX2rSkM79euoAgxPX+KijotQHd7NxXhe05oU2KqGT8RH86pTsdS2Zb3\n7jWHuIrfzZfszW/16FFFuD5o2vajYDBeMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMB8GA1UdIwQYMBaAFK2javNMf/qZ6KK0m13HEKsTrxq6MB0GA1UdDgQW\nBBSBQ55w7G/Gw7yiMKPtlFY26l1g7zAKBggqhkjOPQQDAgNJADBGAiEA5vDGinJB\nN6da9Vb3xF6j2mALHGI1DgD8G6d5D97HtDECIQDhHiWyGV85WzJG+OjvRYOk+/vO\neybqzNx7K/SeL7oQiQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBuDCCAV6gAwIBAgIUHbB+r8L+lDQvfUFdEQJp7GgtDqwwCgYIKoZIzj0EAwIw\nKjEoMCYGA1UEAwwfaW50ZXJtZWRpYXRlLWN5Y2xlLWRpc3RpbmN0LWNhMTAgFw03\nMDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowKjEoMCYGA1UEAwwfaW50ZXJt\nZWRpYXRlLWN5Y2xlLWRpc3RpbmN0LWNhMjBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABAEHbtzuIcg4o5YYjKOz5Zkv1daq9Q/ewtFvfACw0bk+gvMrHWdIP40VRVBl\n2IsQJjRLyOIRji1+ycIjKcsrG72jYDBeMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMB8GA1UdIwQYMBaAFIFDnnDsb8bDvKIwo+2UVjbqXWDvMB0GA1UdDgQW\nBBSto2rzTH/6meiitJtdxxCrE68aujAKBggqhkjOPQQDAgNIADBFAiEA2fggJBHp\nHAUJVqn1OgRLzkE9s2X9KqXxEVe+eiVW7qsCIH7jhHMKF1pY1Olbapf9OEqyZa8c\nvn9cMMb/RNazITnr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBvzCCAWagAwIBAgIUMvI2XHkfZ4UAQ3SiKs1p5+YoOrswCgYIKoZIzj0EAwIw\nKjEoMCYGA1UEAwwfaW50ZXJtZWRpYXRlLWN5Y2xlLWRpc3RpbmN0LWNhMTAgFw03\nMDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFjEUMBIGA1UEAwwLZXhhbXBs\nZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAR1pB6n9ZW184uwcLpCfBDE\nFS5deKeSziA+wFbamFm+ZvcDP0iVFY2DHxQgBdVLXGQETHubAWBQKHr3lvxypckw\no3wwejAdBgNVHQ4EFgQUOeSpDufsSX3jnyBAcbxgarRbuC8wHwYDVR0jBBgwFoAU\ngUOecOxvxsO8ojCj7ZRWNupdYO8wCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsG\nAQUFBwMBMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIDYsaaNyUmIbYI+2mqjsAlw34sae4c2ys3bvB7vEysXOAiApIkrJVsVWD9Qz9vmA\nsb+67Wka7JcMGe2mzD2d5o5JgQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIK2760zFqoFJkw5ezc03M31fdVErcmLMvolaroWspIrvoAoGCCqGSM49\nAwEHoUQDQgAEdaQep/WVtfOLsHC6QnwQxBUuXXinks4gPsBW2phZvmb3Az9IlRWN\ngx8UIAXVS1xkBEx7mwFgUCh695b8cqXJMA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": 255, + "crls": [] + }, + { + "id": "pathological::intermediate-cycle-same-logical-ca", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -/-> (ICA <-> ICA) -> EE\n```\n\nThe two ICA certificates are from the same logical CA (same subject),\nbut have different keys and sign for each other, forming a cycle.\nNeither chains up to the root.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUVg+iN0E+134UhBJx6N/vFwWR2dAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATQscilKTrnL+Jm/Lrf4fNvxinUPCDfK3QJpKgZ\nKFx0JTt0Y1x/Wviuy9+RUtWqcGMKUdNrtMy02WkDa8Qdkelxo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUPYzNZVnIG4zpKpqX7uB+1JjDROswCgYIKoZIzj0EAwIDSAAwRQIg\nD2uF1ppLf0mt7LMH+1e5FwF1oR9aZ//0wkpi9H5FcgACIQDNzCFaJ6eMsP6nP4Kk\nlIrALQsQhhnWbEYWfqFZiOpUFw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBsjCCAVegAwIBAgIUHvCaNk9kqZCqYdBibS0UdhuOThIwCgYIKoZIzj0EAwIw\nLTErMCkGA1UEAwwiaW50ZXJtZWRpYXRlLWN5Y2xlLXNhbWUtbG9naWNhbC1jYTAg\nFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowLTErMCkGA1UEAwwiaW50\nZXJtZWRpYXRlLWN5Y2xlLXNhbWUtbG9naWNhbC1jYTBZMBMGByqGSM49AgEGCCqG\nSM49AwEHA0IABKSrwxCEwGqC6he3wJK0EBS14QxROLzGyWez8QEa7Ns6naCyHsAJ\nKxOGzflO8bf35PvaweM2IdkgfRIX7/yBE5ujUzBRMA8GA1UdEwEB/wQFMAMBAf8w\nHwYDVR0jBBgwFoAUdHqxoa/kUrtfPQJEmBJfWEsHaVkwHQYDVR0OBBYEFMj5o3eB\niUdnwvr/IIy3iwG/D5KgMAoGCCqGSM49BAMCA0kAMEYCIQCfWWWZOwABrzUE4Tz5\nOCClAGuhHGwOkPW7zz9RBcmqzgIhAIPx2f6yOiU5O3KB48PfjmZsMVSLdrP9TO4T\npXCh8k0L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBsjCCAVegAwIBAgIUUf427hnyNbx+FX7P6+F3hAgO8pEwCgYIKoZIzj0EAwIw\nLTErMCkGA1UEAwwiaW50ZXJtZWRpYXRlLWN5Y2xlLXNhbWUtbG9naWNhbC1jYTAg\nFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowLTErMCkGA1UEAwwiaW50\nZXJtZWRpYXRlLWN5Y2xlLXNhbWUtbG9naWNhbC1jYTBZMBMGByqGSM49AgEGCCqG\nSM49AwEHA0IABDo1Y0u0Hs8Y8bkY/obMgzuT3v/94+T3DGlcPSfZdmKJhIfNQlJr\nTUIirUeNi4HhQ+yQ0Bg3m/PiWPUm+YZcbJqjUzBRMA8GA1UdEwEB/wQFMAMBAf8w\nHwYDVR0jBBgwFoAUyPmjd4GJR2fC+v8gjLeLAb8PkqAwHQYDVR0OBBYEFHR6saGv\n5FK7Xz0CRJgSX1hLB2lZMAoGCCqGSM49BAMCA0kAMEYCIQDnM/oUlS2XQzZ4/mBe\n8Xpxz+B4Fk6fxajX7oXW64oKQgIhAJMtOx+jXsRixtmJRhjcqnqtS85yfjQw6TVl\nWbN9ZgEf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBwzCCAWmgAwIBAgIUFSGTtt6SL6PZTK5yFbHOFYTP9VEwCgYIKoZIzj0EAwIw\nLTErMCkGA1UEAwwiaW50ZXJtZWRpYXRlLWN5Y2xlLXNhbWUtbG9naWNhbC1jYTAg\nFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFjEUMBIGA1UEAwwLZXhh\nbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQaaz8qWV88nXQmBSoX\nV9zDsP8i8yTAAHhWemfxBmLwmg7PFkZQlTJs8IK1LgtCiua23Snj5Kfu0ZCHi+Zq\n8X7lo3wwejAdBgNVHQ4EFgQUIsBoAhXRl6fWkkOtvyngATxsq5AwHwYDVR0jBBgw\nFoAUyPmjd4GJR2fC+v8gjLeLAb8PkqAwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gA\nMEUCIQC3Xl8QHvreCI0+45DJaQRO+g/k9YFcsO6jnIBOV9aiHgIgFcrNcSzlXLwj\nyBCTlJv9AVRq6xyuG9jJdwUSC+wuPqc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIFyPtV1KyfL/1cc5Lnyghi3G8tomGBSz8cYeJqKsw1a6oAoGCCqGSM49\nAwEHoUQDQgAEGms/KllfPJ10JgUqF1fcw7D/IvMkwAB4Vnpn8QZi8JoOzxZGUJUy\nbPCCtS4LQormtt0p4+Sn7tGQh4vmavF+5Q==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathological::nc-dos-1", + "conflicts_with": [], + "features": [ + "denial-of-service" + ], + "importance": "undetermined", + "description": "Produces the following pathological chain:\n\n```\nroot [many constraints] -> EE [many names]\n```\n\nThe root CA contains 2048 permits and excludes name constraints, which\nare checked against the EE's 2048 SANs and 2048 subjects. This is typically rejected by\nimplementations due to quadratic blowup, but is technically valid.\n\nThis testcase is extended from OpenSSL's `(many-names1.pem, many-constraints.pem)`\ntestcase, via .", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----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\nsLIpISom1RDcpJ0V/9anUdDjM9AZX3JTvSvoz6kK2JU=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\n9nECIQCd2Dbeu/oamNasYVBy82JtZBuk7mewPxb0Lcw7SXTkqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIHMrNo3HStYOiQ5c1Tc9Qk4hSvJao+ZUtsuaYdWskpi5oAoGCCqGSM49\nAwEHoUQDQgAESKH1CwKjvX7SQDkv1EbMNB3tftS/iWu6KugxDDujNJj0dRD7OEzF\nyL2o2Lw5OdPl4C3dsqehaxqVcVkAzQInzw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "t0.test" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathological::nc-dos-2", + "conflicts_with": [], + "features": [ + "denial-of-service" + ], + "importance": "undetermined", + "description": "Produces the following pathological chain:\n\n```\nroot [many constraints] -> EE [many names]\n```\n\nThe root CA contains over 2048 permits and excludes name constraints, which\nare checked against the EE's 2048 SANs. This is typically rejected by\nimplementations due to quadratic blowup, but is technically valid.\n\nThis testcase is extended from OpenSSL's `(many-names2.pem, many-constraints.pem)`\ntestcase, via .", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----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\nl5t0wY1EZ5guAZ+HQUoOpG9L0l/YI6h9nEPa2rLc\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\nqHytGWIWDYQZCnHNHQY/f3tWZBZjqA0ILg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIF1ibul3tiZ5exzlCT2nTCYb7yWJQacb3YM+2pxG7AkeoAoGCCqGSM49\nAwEHoUQDQgAEgqkcPLqhqR5MhVi8wbX3XUHMwc8qKeQkAhiG0b9Dbg27rBqkYoBc\nVDkYRXCuDMY4W3sMNwcf/EaB7AMZ1SkYFw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "t0.test" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathological::nc-dos-3", + "conflicts_with": [], + "features": [ + "denial-of-service" + ], + "importance": "undetermined", + "description": "Produces the following pathological chain:\n\n```\nroot [many constraints] -> EE [many names]\n```\n\nThe root CA contains over 2048 permits and excludes name constraints, which\nare checked against the EE's 2048 subjects (**not** SANS). This is typically\nrejected by implementations due to quadratic blowup, but is technically valid.\n\nThis testcase is a reproduction of OpenSSL's `(many-names3.pem, many-constraints.pem)`\ntestcase, via .", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----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\nrG1m9hG8VmgyOkI/3E8KI3oLYSxJgphxHIStpTa7Dw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\nqtwogPkp0UwIbMUch/7rR8o1NEE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIFkBN5n56UTvAkT4E5oiVsxg42+TqhB4y41wpN9DzpdoAoGCCqGSM49\nAwEHoUQDQgAESsPl6Pd0TnydgeenOWGhXbG6AclIFvbhCKi3ZTjG+Z9ENlZ7WzIM\nRYJBudnqJod2Z+vKX8Rzj3NFmZ4F05YUSA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "t0.test" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathological::pathological-chain-distinct-subject-distinct-key", + "conflicts_with": [], + "features": [ + "denial-of-service" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nICA #0 (self-signed) <- ICA #1 <- ... <- ICA #99 <- EE\n```\n\nA chain of 100 intermediate CAs, each with a distinct subject and a distinct\nkey, none of which chain up to a trusted root. No valid chain can be built.\n\nThis is the \"easy\" pathological case from Go's `TestPathologicalChains`:\neach intermediate has a unique subject and key, so a path builder should be\nable to prune candidate parents quickly.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUOHPbIbsJxiBwYA87KteVApeISVowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQm+pg4ju88fjRJti8wcLnKTyOwleffeIZd0kGp\niBNBhh0bJud5jj7hY2s6UYpvrTA0tXX9dCRAe0GXdwg+6mNUo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU7K9gVX5+da94TOrI4CvZd1JHD2MwCgYIKoZIzj0EAwIDSAAwRQIg\nRv7fOSHY8AaErEMJ1UniOsqeVaJT6PNIv+WtoUybKfECIQD55NC2UUqLmgUpE+8F\nem8eqsLGhMwkHTPMqDHM61bTjA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUeQLBb5TyrEaZABzvEO/rW/wwWWwwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICMwMCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzAw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATaoQIsIVP28NKEFV19i7+DM08tTSrE\n15pK6+b+L7gwtAFspk7YjdXKDiP2kj0AjeSai+MO7FJsySprwvmDJdWtoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAKBggqhkjOPQQDAgNIADBFAiAc\niscJ+IHcEvQ9+iAg/ZK/ofVl8Zp3Td3hA3YgiEV++wIhANdSrfD5fSg4shv5KBh8\nqtw19uoZfq4KGtzt+c9bsN6w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQSgAwIBAgIUMDrgGfHvLmGj1zuxi1GfMkcnVNswCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICMwMCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzEw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATzpLbLMjcuiN2PnzZ7fCmRoffq+aqx\nkWY3WwFegFTKTgc+ocbdWKCdGt8Oks/DojZoy5eQKoNAJaG5GVvOLzBRoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNJADBGAiEA\no0IjrLnswV6IRFmo6YiVoEEIWdgAFQHq/n+HNynrgxECIQCisG3pW4T9x8h3Xvac\n2iMuAVbQ6R9YefcSIXc8F1PZMg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIURYHtipQcwO3gOKpqaXi5djEpVvEwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICMxMCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzIw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASHXTE0YjNsIKuvwiH/hX8dbFqPgasa\niX9X0yE/kHh2dKKM5D2nD/NAtVSDmUCOu2vbmuaBjs8Tv8HI5xv+4Jv2oyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNIADBFAiBL\nZnKaPacVKzuh0xG+jd2Fz4fz6dsGTquIvoSpJFF5OwIhAN8NZb7+QqfrNSrOdFzd\nTSidoC85R/GsXisUh7VyCxc9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUUYA4jUNxFerFfGBseisdo3IdmlwwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICMyMCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzMw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATLvQ6MLbLINndLyTAC8wWHtXVoZKQ2\nohEQ7+rPj3pammdh6rGAvRZjkI7R360zJHEI4zYAyNyQ8bp/jVfbOkjGoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNIADBFAiBW\np6LzoAyRFEPRYLxBcJNFNJ/lrpsaq8EyhAb9TksZqAIhAKpDco1cn2TZalc2/a5y\nAGpjjZI9EGA2AfJHvLMIracZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUIqOl2nFXLS14EhEBcz79MoXFXD8wCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICMzMCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzQw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAShJSo+zG1R2Ewa9C/jWjWrWihAGUJr\n/v/HCjMu28TAsqQaqW0WyjdXU0lhUDRUyKrWRazLZlpV6fT8YyEBXaARoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNIADBFAiEA\nxlK/uXMt/Jjd9pC8Pk3fRZbWhWU5GDUm6bg0bu4yA0ICICX7IR7IIXs1ybmK5FI3\nAbmkPxzGa/CzdYMgWCEtWdxW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUKUOSg5/kLMd/gvpiw6HnrMDG2v4wCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM0MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzUw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAShhdSf24OzNu9pDPz0YOUN7sFCR2OO\npa2knUoVnZTPdOYK6OLcW6CVJ7Pmiqd4TvwjsY60qSJPouCkoS6Btu+voyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNIADBFAiEA\n1kTINeH55rR7ocTB89W9r6N8S9pE1EOuYc2QoL7S4xUCIAH8Hc4NhHY8NU3be1eg\nKEBYI3WBl20ZJYcQ7kdu7CpJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUC6lr6fAA2zZ5+ZYDDpTCk5v/b6UwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM1MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzYw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATbOlrwQ/ELzxDgrIwbCG49trvlx1J0\nJe709cc2MsuRR3cRrUxiGmSwNaQdox+eIGidRg1L+BBHFZPCk1gA+8uWoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNIADBFAiEA\nsbS/dZlzUyEQPShSy+2oBLM0zmkIkayFNGzD5KK/thkCIALAMKW6LNooyaMiw1z5\n9NkaCIWlrfq9pIE1GmTptU4s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQSgAwIBAgIUR3raePpSSjeAUT7u8blmuQEZQpUwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM2MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzcw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS6w2Uw98SMipzBsgfivsmW3BGd+H5e\noIQxe4T5jzxLbRUXYEB/jMXWTQeC/5cvY0yDJLFQkmwhfjtfoUdhxMS4oyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNJADBGAiEA\nhdchL//w5OWJ1bSSkUBDOQKbRg8MV4EpODJ4336lIGYCIQChFd+upo0vxIuTOPZo\nJ7PtrxMSmAThhZK2OYVCrrsbSw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXTCCAQSgAwIBAgIULMdkikTxL/Qw1oT2vUi5jQ5WsK4wCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM3MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzgw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATVFtqSLW10c2XGRhfurX9sf2gxPoxn\noCKHrzZZDAnZOfBi3c7FBVx0RigBZas1IVxPS1G4XQvs1O94HaCxBFSNoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNHADBEAiAz\nWMXQ93GXmBgqjDk6QUfS5nwthqv/aZZUzP+HW0PCowIgZquVb+cq2O6tp32NSlc4\ne7IUOcAKknbCvn7X0oyUiwQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUIQFFAvHQ1BD8E7Jg+AqHu4/4SGUwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM4MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzkw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASbzVui/rRuC7QRTBTrXcF3Qe8zAwJx\nftVSaQX02GrtzaANghrKlVsCEPk0ScLYIrCN9b+/qfgG5mDkUGki/RyEoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNIADBFAiEA\nkpYOxECC4VTnko9lmMhhUZGm2zK9s1siM1zoekSxaH8CIE+jY/YZUSSwSN2bSTyO\nFOU3Snoz7fKmBVNAtHsnkvnA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQWgAwIBAgIULps39FFMj9vu3+fs8KipozpFdH8wCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM5MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAeMRwwGgYDVQQDDBNQYXRob2xvZ2ljYWwgQ0EgIzEw\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWwO+pJmzToL9Wo37tpScI8amKZ6o\nyX81gNIKGHVEZnGQ3NACXWpcRCU2f4QKWnMzSBsyCNYkztgDLDhzwkTCm6MgMB4w\nDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8EBAMCAgQwCgYIKoZIzj0EAwIDSAAwRQIg\nPBr/hxhYh3prQJMq2bPYJY27i/fulx4NKLQgIBWjqtQCIQD7ZJtezdpvlN69cjTi\nDYOrOWnVjnGhYw0pt7bSzIri9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUePUINWJxChuGOIkfpiSULeQHwfQwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxMDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCPni1irfeJicfcZ3OJ8VG7TqC92\ncyxAfgzI/8fiFuAsRRkK/zhd7ZX56CrSI9RsseUUWKB0oU4WcpBYYJ6cCVGjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIDp/9xryLZXD9N3I4vGV7KvV1Gw5DOZKAC6iPLFmFC2bAiEA2JacrltxLXJOk8+4\nm+LynnwmfGhWA4MRrZXmew20rAM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUCG9SvqIchvDKmi97kr3JSjFyhwIwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxMTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCttweexvpDP6KlZhouU/1Bj++vm\nd1UMjy8xKQewxY0FUNTkxlxiYsMouzA7hpT8ONo6O17e7sMTFjhHUG4n6kKjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIA9B8dwFp8gzBej8N/nflSrqLrT1oo/1+mAjYppEJ0OrAiBHqzXnHiKgc6H/2A/K\nb5JM1rWaof6H52RBZshQGyfPyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUdSHM5oKKEZ809oJTgKA9owehdtkwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxMjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBlZWYm4sQJLsYqtMpeqkZNN0mJX\niYhSQBJp73PVdZlK/6cNjg5liOdIAuSYZo/IPwdfBATqTxe61KiEIikMiDijIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCFdxzU5kfC3wcLNMWEblOti4fSRKqtcorh32almHe4lAIhALnNZQNERgjM4rxw\nemsDLbtzqhz+/R9RwGyRYaH9oZL6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUJ/S9qiKhrOQuLincO/CDV24yUtowCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxMzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGOgK/eGyaO9l8nC4NYPoc/KFLvT\nJwYmfX3BrZeng+aV4vHn7kEsROXlMZC6nRMI+EIqfxAUB52JtZycteUP6HajIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCsf1LolROetWSxihXsGzqjYDpJKVoEAXgeoA2+fB9AVgIgR/A5Ycu9+qlegmr/\n2pjpCUgdWFUWZ8oi+Xjh42bc5lQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUNCtwdwbbYNQOwxaGKh742Au85uQwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxNDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFUgFHzhByLqyojY6PTxNWxmAJAe\nd2UPYp8cXDtdIWLz6YTMR/CIQUyTTlBCWyOkelP9dAXU4WzKE6XJpR0Fr7+jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIDTjBL8XXSYyj/3WPB94NORpDNJUAVDMbCyW9jPF3b/9AiEAxJ2tOxnE5/QLpJQu\nBLyEDARgWVmMgw/Gvo+VAdepf1I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUOHUcRVHXZHOQkQIna9lKgADZ7i8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxNTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIIF5f/L2+yCbTXuvktd1hPrIO62\nGmBZV8K8NvyAyCKt7uXQRAOHxn8t2/pX1wWqUUD8bgBePfCu6K+Q4WcYW52jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCbLYXz+Ms8b4qjc5CM7A8y3PyL63sOSiGyRnIgf9tM8wIhAL9pkS2YxPYreO07\nKLs9kciwG1KJf3ACKpOc7abFJWfN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUVhax3dQAXwU0wGBamHCV2JU3khwwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxNjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLix8/UJQ+Y0zln1sJYPPXDdai0V\nVTsQCLQPvgWSPpbnXoqUXbf5P5YUS826R6e8KVfqp/OMfWEwZ99kPdzeGiajIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQC5vhJvYVfxi1t3JwhaDt/YoU6lrev6iTn0RJA8EmopHAIhAL2VIv2sJIzwMcU/\nWvYgmDVsnmjF+KivSNqKkuojctKH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUFdsOHhrQbI9l/LYGpUiZD63NeeQwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxNzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBo78/jqvE5yoZGLHfHhQNmPGtbB\nqlRtEobmv6cvU9QrV2jGyLudHPYrFdSqNnS8A9y+9FbNGPACYD4i/ASCQVmjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIGcsruSRHOLiK5vadm9P4zctoBirRxpHSmUENcwQMmi9AiB3l1PbIlYCUwJd8DCV\nPxSBDyj5XWEMnTsZUpMlfIEN3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUV7UO6nT8AccVFTjCcNCquzBnC3MwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLVygbGjuGCaYcYJbIwHadk7hPtm\nG3P8iiH+ozbPQDpSLT07OUw/m9/k2cCTAtZZ8WiCjZV3s4rUANQGzsGYlxGjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDUx3V6GS5Ux2ApZAOGCDYLUCzPFhrClzz8jze7AayFgQIhANbilt8AOhTFJD+x\n0zo5VuPw3/DifwewZNzIwQSAWQBC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUdFc3vuQQolN0zFbyoKbdaQqBndEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxOTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFvOZjZhlAdfaBxTsMzI5MPpEbyl\ngE+XZIisCiyGHPVhnVPWUHMQedh5CwYRL4rIGYxKiLKoCJXbqrfxqBsvs1KjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQC1PIfdck8gOn0YEjXU8f7LoC5Qg6ogpG8K/tDRh5vA2AIhAKLJJqD209jRWPnU\n54siSAe/MS1D9sqyuvL3nWjT0TkM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIURk97DffURhft7eJfD0r0UoK238QwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyMDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEtUhJDuSvE6gdS1NMklhX04Z2Cl\nEXTrA8P/OQs6j/LV6H9PfW3JviYoLdV2nWSWg5YvWo7xu4M5Xpie5moxVHCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCOdpnxtyPZ8O1Wk/MFNqd8zCtM26He6SRRVsRL2G4nmAIhAOpcupsTADfgjl4b\ne+xxQ1r+sZsmZeS1OEI+wB0brWhC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUMLaGOrqqUnfbEuAaMnLyKkUlykYwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyMTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBLwOTf2oVS5CmFBmHr/mCYrWVxw\nHQF36jc2/tpVwLPtxjycYcPTVUUdBwle5K4cFitn2IyYsMo+BY8W82O37T2jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCR/dfZSb9sf4LQ25mCmYyE4thaE35WdoYVeU/4y8sp+wIhAMr2xsvSWFI4okxo\n+0yXmLzreHsEYGGtM9Fo6c+bQNr9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUTxawWcZUM16XcTBKvTirPEHJgakwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyMjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMmyIErIZA3ixCSdA2ld/mepQoTS\n8BVyUCkk5Uf9azxACHf03fYVxogrxZnqxGFlTC0wKIE7ynM9cf77zGRGeaCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDCD8S6QBksT5RCnxvrYRYm2ynNHeT5rXxjWABlxABQiAIhAJcUoyvvD/E5uF9i\nrDSUPoifHpzJtmIN6Wr1cOiV+P45\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUcAInK9/jbyZXOXv9fhNglCwtE/gwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyMzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOJyF8G4A15drmNrtOX5NmTceKE/\nrrAvbJc6P0bj5Iw0lOVKuyQSYc/o5hVtD10hmOT9Zzu26EPUmcZh5FJYIZ2jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDZo6F20aOh1KEVDnuTO5W0c7QJwqQ9vT8UyYAf6C3fDQIgBSwkcUCzJHK7ExrW\nSJdSdWaEH9cj6TlL32T493SLAn8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUHGB1BUcrvSrXRjOTyQ7qqrGqcSIwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyNDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMwaPxsgjkM1sIvwjgbzDqYmSrwc\ntOnifZBi0QhDho8HsbXrfmRithld76RMNaqd95f37YAwkV+pBOANOui68z2jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQD9194FA1mUxeUK6e+plQ03FqXNFnOIXVQFZs02/qAAhAIgaZKLJkIIkqmHVzxJ\nU7Kbo8G7PudEy/fBHUEsMUqhV+Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUTdk80JTAt553nPmJT72hA09S8fQwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyNTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFPKEShah+erUUuVCt1F0DjAZzVV\nGaENBnClji7KgNmbtNkUEEdUSck7btItkmlrDfkxh9yzUujO+Dg1RB/gHJCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCO0yecUzP/jVwTEqek7f1DG716JAlsdGJddRN/0FUOTwIhANAtRo2EB8RA67uL\nt0UWma+4kHM6xNfMgKVhgjnEFArX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUNHFC783mXgChA6Vq/B5orWAYGZ0wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyNjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABC7BgMxnESkhLKyW6cuw/qBtU3/I\nE2eUiFfjTp8HFXuP69MrYtZT6rpyraXt2I7g6ZliulvO06Jn1AfZkXoR4KqjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIEStYlmwabtq22e4Tvl9k0OpCDso6FXhBxdBw4tOAEoCAiEAz+WawPIh696J41Wu\nrJN0KAVD73mz5ByC/5ti+W5KUJc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUE+MbUFbCxBQF/yH/NWKol6gLo+YwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyNzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKd3b8HdAKQQCdJUkUA0Fp9mI1s8\nkGsIv33wyXoVtdBbYAfPreW1BNY/w/4YW/vS1p9HgfuiOX1wwkM4VyWVTFyjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIDDPI7D38GOXdpzxVMYZzfJBqnq8eOlgdaqBK3LgcQepAiEA0g7dhzKyr+eLKBjL\nnbbar/4wwJy2j0LEOuJchPaB2Wc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUZ8M3RWMITHYGpGdmvOYxlZdf7fAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOZ87Hhk6JQAPY6LSpbWAsowbx9A\nTlFCC88kfNfFQ8F0RnSGBS843c6u0ysiYmk7zzfW5jsXZkxXKxukh90YPlijIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCzXFIrds4VZf0dB8h6Pl39kYLj7OSA3ZqRNKSaq75n5QIgFYivBmjrPtck7sTO\nofKdGCM4KMniTnUZx8cY+8fvZw4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUNzyHu9tsOM9jjAhdntmjv9wBdzowCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyOTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDdAOc9Xq8qGwf4COa0vExxjJOet\nA1RMsPxwez9Pn9Q0YcYMK4g4xBTxIW1t5Cgoy+28gGg/jj5iMAhen2sKsICjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIDxXArFAEXqG/VGHf5tPqylrMTJtVaPsGlbpYn39pYwCAiEAvFQiJe/CS8hJKZMp\n2mgH/JMpEOn1UjHriY9NkOuwBxw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUSlxqQYj63BHYYY3mGT6nyOcrmrMwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzMDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBelfZ2jT419KGu8N/UzGUpn5QX0\njHw4UJe690G5FNxV9n7eo+9xukVhVzNdN4hmfGZpgEjARD+er/5lL+4jnvqjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQD8bToQnYSPiGwCYiZgH2zi3Vvpxz2p4dW5wNGi1LdaswIhAJQFEWQAam1+obTv\nJka011q/lPqdkXEKk1LkVJj7Ch5+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUFSxOChuSaRklDKiH2Z4YqPbUF9swCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzMTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFTvR8DbIHJt6gQqHusCKjygYZAv\n5kWGjekt+CQOiyp4tqPQBZn/hh5gN/wyAYQe7X/AvTYDesx4x2I8g6FpEWGjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCYTWpfDNu5OLiyrUXGuIj6ABb99zEM8F13TMH+AqK7nAIhAOlCdD1PKLffGfsU\n+SA0S9lFi+5WAOFHs+Se0SQDOQSF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUPZG44skM/UYZmqdbk4PTJoMrDTAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzMjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCOuxfavH9uYW1nbQqhnS3UTGNwG\nhFL+d+7DcMmEnxVbQI34Bq/UMsW6y6Vye1UT4Ex+HfTigT0Uo3HrLGmV+lSjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nID/ACy7zfIqefGyrO374kxfKAKBwSPsY1+YXOqBt4AdbAiBxANo4dcIuxIldjt6C\nW1z9k+vBoxfwOw6ffL2LLYQdbQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUDXwGPPfD+jmWl4S34Vjb0aoJZ9UwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzMzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOXKkwwmKOy9Ar57tUukTrSTkcwY\n/whSiTdKZp0wINX4150ANDBxcRjEkH4koOfffxhyY06Aas4Uzq6iYQCIiX6jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCvdDElWeiDo2oHQHderhAkvYDevAgOlbX5Opee4kpnRgIgGKQgHh7s8hRRA5sB\n5fx8AEINBCtu8jx02cC2zQwl8Gg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUG4FLQhY/tUW/DycNo4A5r4jzXwIwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzNDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEd85b4AkIVZOIIEGYEwIaEoqPRT\nczFIal7eHaJsvucd8NnR0Zua7IiEpvoZLsWgfwI6OLCJWm4i4UxYLUJuPTCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDQaLnrYfDOMhzkI9d10+DYpiVVyQoRZvQqsxGJc+ne4AIgN+c7vV9O6KF6W8bx\nJyiL7psO2mIBKfD0MakyK4xWeDw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUI6TT3mVKFUBhS6Y9DjFbTJ2f+ZEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzNTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJL1VwqojT91SeSP+xWm9AEyI/D7\nlEt9bTb5Os5bctIYFdM9XEDILwSIJ/TS7ciSuYJrjzAYxYqBSLSK7vrUbM+jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIFDtPxxyeBBTr+gjFIr0/5GTKiU1XI5njdywFm4q53aYAiEAnbMXIYOwX8UGwjiE\nilBDzAnQkLWanDXAVo1eOUt8uGI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUCtm7ec9ASgtNb6weDb8GhVyZwZIwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzNjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHcw5y+ZPtzPvyIR4CNbRK7nvznD\nsaQsV2Dtz/1y4gLjq0umFe9ELXrCQTuxOAliDdc/jEmVG5waHS1eIjQJcgyjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQD95no1vTe2cqEhY8TIJZrY/QH9twYbQ05gVN7XxjlUfQIgaerdsoxJxGYcouPd\nV5sLxo8gVhAUTsMU754vq0ZO7/U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIURRK4qBdLZxH+b1xVBk/POk9cNKMwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzNzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBcjY83W0s8A+95TiLkzCfLiGfCd\n6ftpyU+eAY0EEINuNh3XN93CO9zD+UlQFLj00l5UpalcATfDNBemURmnFTGjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIHNXCnTelh7xWM7n8a1eTz6H0/Gq0icPosCQAYEpXj1AAiEAv367Yo+JNkA0saLY\nyCQl79A0tHzg6tSIx7q/PWMlW7Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUITliPz9MxDeO6gupUcAWl42tYM8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCDRKQXKJ9YqFzPnaCizM0yfN/RI\n2MFisOfQ+L+4an07ZEmNB7B9bI4FSXiD/9aeko9ey3p+NIilxXWUnBbO0N+jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIFtqey9hARJ1VEiqWzeLnuXSm8+Fe1ud8EDjFY0tHhi/AiBYhbjbuKNAAvCXSWAs\nffKwG6eQxykk/lcYXGkbPEZNfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUKE6JIyCnon/vkCUJpIuYhZB39B0wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzOTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM4UlTictuyZqEiRqdIzijncXLPk\nmfepcS2w9Jnzv+De2Z3o/rLvfIlm68nmoWB67f7Ml2B+hkfgRaXx/E4ZaJajIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCCMaA6RqgFLjemKUScxxva+BFIhgieA2kAfqmbY30+RQIhALrzjxz7UyIMDcNl\nLg4dRDWyZb4QPQLGl95WFBR+/+to\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUBNL/7EF2yo7pHyTni+c0psChfRkwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGnSLFV+bbRGYUUvz/l1agPOn3Rc\nybm05GPIICvpZcqxVHRIYQSCizdcP7y7mvm2e7LwbexIA1vD7SdHNh6kp6CjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIEFtw1JD27NuWnnGIBGfV/w4bogGHEiYHyf6hcs5XtFUAiEA774LP4RJfxqJFGLj\nv1P8T1IF/yrruCTUmGs8o3j3Fik=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUaUnsP/SKWtmJgdbpRRbphWRQYvYwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHPcv6cfSvhaF9gTyUwEFa7tFP6y\nVohJRS28XlZFabc2Vwj1JR+I3nEjP5R9QT9uMIecPlxHeCnK6i07LufwqPqjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCa3/UUEQ1FsNJKViD3tS8ogcQ9rIPrf1hFtmSojCjlRQIhAMXWCjzKKNstqHFK\nGDjRLoTXEQXltpQ2TTP/OR1u93N+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUZsfvzTkrcu9Ny9IqRmOxBRGsWe8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOSogmH/PsADuaS6W3m6HgJMihEF\nCPDDEzGdVbINZwLIIUrNhPaMEXzpA36B2eWcJe/sLX7YXUdTOUO7lARqFSSjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQC9asVpKj2plx2evPmodchksknTECFNtIEGXEsFxV4vVAIhALSYUeAocF77710x\nCjAft9XYbA5TcgkuE4/7GdLAL+us\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUOSx3i1uF9G4OvxSlQ9D9J8+7J2QwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFNPSuhSnw9OnmDwFtF9V03m1iqs\nvdpzUe2bp4aZ3gmFKvGodCuDJsCuqNQTaBq3aJZ0qG3+bHovHpe9w4h4BOijIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQC8jHGVEMUTqrocmm+T+/hZDe2v2iY3lnl6HF8lPV3/mQIgbRA0IVwjLDIpVFnc\nKj2wbe0Bhhn9m509b1+oLUIlMdA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUSxi6eX4IxTSFPcA74IFj2gKsnUkwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGKkivFzcnj7RacBVh6XVQ1ZaTIM\nWajsf3CKjZrXkQElkSAm/RYt863a+LxvUlZjJwq1qY5ilsAq6cu0lxo0/bujIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDMx95fedq6Fp1sUTrg7RQv4jIdjilzw4vRcEVGDlqrZwIgaR8iJZvKFGQ7sgJP\n1uUG1yldrtzCCm+V/q+U6ZiOiaM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUHEs4dBvkJam4Lf3vbR9ACuTPk3IwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDlqGHP6Oxveo40gNp/vmYLnszle\nVo3BYuh3oJ49GF6yVS68kvrCezA4EX2wZKL5qz3He4VYKMsvBNzdpmQHUmOjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIHKfA/+lnvt0ec8aLaj70vwUwhrnmz11tQIdDqcedzSdAiEA2vYLuP5OYCPR1sgJ\n5x+nSxjLBUjyc0KtU8tHdABozoQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUdPoBJNbBDKW9Gja+kgBu6vpPUWgwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHnmnWSoeMod9m6lXe4YsXVe81pg\n9RopBjUCVFXuVauMNEIf9T0+Bu476z2QusMHJHBVtjSj4H090CEiWYZjcHajIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIAyeCBEJn6YAWbuf0on95JTE/8GC5xhNLsjrqNmG8SwFAiBa/ilkSFRAQeG3gXkL\nu+gytEoWz9EELpVzGSXw9ctH5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUdsGDl0q7Og959r8NVbX22NYDbQswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHLni3XGZsNefkamAcaRrkCEcen3\nBS3A37W4oVqCFgpgR1oV7jWYLRCr3k511asGYTnAn3bSgEz7N30942aGNRyjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDa8AnhgA4uQU5YXadC5mRxMqaMH/ul/JvuVFDD7ROUdQIhAL43skTxEr1KWGKE\nrOlM7tFL2QMkrn65XCTJEHpWK8Og\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUasso+KBbmMfydDYsP/xsurxe3SswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE7qVYQOC5zgBxYyhGkBJUGyJiM1\nhGNnE8mUIjdWcUZmNeDWKSikr6c/2BB5svIxzcPJKRH/au6wcrAM6pKulO+jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nICAzaHK6Id7EjAdJ0aY6WZ8VCsrKoDVS0pIlyZmVOAGWAiEAs1I+oYG5y86si54H\nRVdQZU5uQUIU2G1angecn8R0wnQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUfdF3N7JX/clj3fKxfy5OZBVxz2EwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMU493KH8BXL1FRKbJuM4BDSJJH0\nY/eFD3inxkSDX2eIK9jhsVJLLCfl3jGG101f074H+KFARzDjj8J5C5TL7aajIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIEHOvy/MBflZz8juM8XWbVCFOUnAmdebCg0Ptv0VylWyAiANE/BEVMVwn6UwGGVZ\nqwDh07d4+e8ip98ziB3Nw+alpw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUPxum9YiEhTDUZOqxdST/nl+M0O4wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMZ4DAJERbBZ6VKg+vNgG/g0in7s\n6DJDnZbu0ya7UQo/pDpWiasDV0fMkxKqoqfd9PsnQXdpgAe3mdEqmqTEgE6jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDf0DD4hSmulAaQTmoBuxerJ41xvhsR4WJd7YRNAAjDkAIgNdJ+y8bhhynKo9CU\nSFDjdXSDxkxhA3JYaC++6qL0/5c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUJSAXoKKalG5uT8FOy2DUg+EKyo8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDcdckFIbpvMR+PvW4w1Sw9lo+nj\niV1/EiAj7RBWBsudhdyVHHKPt9snzuw15bNshmo1Nz0u5fzWHYOz6oP4teOjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIF1vA3lAAmf4ugS46IKvtXr6cZZWtmzKFIq7/xVcZ0AhAiEAl8Fh/Q6o65E5k/ao\n8RuMnDHVKEuE0Np3wRjkzR67OJk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUGMQN0GlMsCUQcf9ucJJpXZ7DI94wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABA3pG2WYdA2gKzzRJHnmtaZKlaeR\nG8g0rYhECJewM0N+jgdhA/LIoai3W4XOdjN2dm0sSAg/Yv58YL6CXSEiH4SjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nICgxYcXOx4w4qZvLPqHXMDC0BEClm1jPUggIWG2IqAAFAiEAoU8srWftzHYFv+iQ\n5C1JN2XTkXGje/iSaOhaJ/wC/Tk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUSXYGZNBC4RwD/7rnlcSVUS8Tom4wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCh7+L4/nMlZ3O2yk7rCAozDtD1K\nb4ENyETkK2G1dwszhiVN6zgDbysS1qf6R9gU1x88PWWj5rWTalp21PFsaGGjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nICZk3OyzQ3jzUrRFveOLCrUYi8FE1TlNqlyhwDzqEzf1AiASbVCIzlwo2TCtVPvk\nVI6RoDS/53NLopMzVby5a6plcA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUOcljaxY7XatDFMvWLnaR+qD7pyIwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCDA5RrtLMKAuvmaDY4/pkzA1I7u\npJjh0C/PlEsW9iJCWZwX/KzLIhIHC9oLAzEcLSvTshG91KAfEqZE6GIOtn+jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIAKNZRSiFnKDtbditF4+QgETBrCTrIVsUdK+OtqhEOprAiB0QRvBKMIumHqwgGmi\nxOSVqz3W5L79VPRZWS2f7G6EkA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUYeLIkUI+FDNdFAe1IO7cSIwd/l4wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHtai/wU72ENSFV18uA14Pmd99xQ\nmiypEa2xtf0IMBK6bk1jsuoWjML3M0+f3QT5SoCjd4xjzNSpZ72/FWevoRmjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQD8zk8f9aTwtObKgEhwnNDpaTZdsGQtI7gE6X9e1mRR1QIhAL48sGiWpTOcstgk\nERk187cnUujEJZbfDeCyx3a5aWE/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUXZr+aPV4pHF5iQ8xUtgf5d0tuVgwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGSITj7xcGoX+c5phe9c1wq2mO/s\nb4SQgXj9PT9vYAZY2vzuM0UkaGyUXlnl1rmORGzcSgJc4rE9MzLFvIlH7aajIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDBUHj9X7Q2JWEQT1C31pZHz6qZIx9gTintmKU4OXDAcAIgHRwZNuCSVwlg0qNP\nxl1oqc09q6BlFl3ccAKaQYsG0/U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUFjK9lq8gNYE7bX2hf0wPyO8ohowwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKWAb3DI6lyi1SK6NHNHkk16hQZO\nk5NCZwnKR6Ycc55ukB9zXYHLzXdRCAUA2q+hwX0FZU9QcfZovHqr3uRdw9OjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIEpyAy4TGehJdlgftcH/4GWPiHTg1mhTNC1tXhlneSkSAiBd638ZWnOomAJRsfCb\nDlS6It3q13i09GF3trQLsVGGZw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUQ4CZthIP/hWbwOuOBgEIbbC0fR4wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHuQHbx+Izcv0xA40Afl/9yNQSSi\nBhfl9V2xO8s4Rpe+iO2uJTYslWocnyHsglFfsejFxIWei+AuO1MYrug9XqSjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQD5dvbTeJCDa7xFT/U1IMe0ORL/+pcDay+di7sh5VmVaAIhAMIdBANZ4dl2fuA6\n1CpFdZAKMqRS0F5V2wf/059OkQap\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUXQ845TkP1bnBvEWmvGiHe5RPky8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOHGUk3Uy0x5b0XuPtp8d3Fx2vmH\nqjp3iVw+sPXFFzCNhR1AmuEAeuBQpurK74ppQzDy6cnFCfAeacjYMKA1YoGjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIArtqsJrtKfzGsjZUGXkmypHTpJAqy1uhbM3lbU3V5IiAiABEt8NTb9oR4P+qssg\nnVpQAM2ZBaWfv2fAGKyLNTQy9w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUcLXOlCmF8X2vlddPtv5LWaUbYAEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNhCMZo9kcHkIskWsW3O4RIsNf5c\nl1NgrHRdwaOKpAoIZ/unh5D0TMn5qA/PTCPjVrf3YQFQ7BUH5iB1hALM6NKjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCAhpwncaMEtPJRP97rDMnBu71FazakYX9Jkm9jzmjb4QIhAJUOtKkRQucNZxbL\nf0CuhN6OmOt6zth1oKR0F/pGpd4O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUAnXzeqNurNlCIp7U/P1ba2cIYaMwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHtN3Uyp8+o8PasIjTwwSRbDRL64\nwrO+21o2V2LegNFZOTmyIQSFyDuFTYUDjSnOwcub1BArrJ3EKxICXfjcJWmjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIFtMY2HR1XRkiRWT8MvNJf8XyV01M7hwnKhgBpJODwnUAiEAxhbqT1vd6JWFCXhX\nTtPn6k2Blm0fG7OGeHmIP/8rdn8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUUhrtSQSsKq5X7NQRWn/nHELn7iQwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO4u4qP/tS+WIsmCEDROTgE4xz6J\nIPdbQoZe7URkaFHmY2Ru6Hco/yIf5v4VbO5cmu5Y2jaC0pKRGV4rfT0+RFmjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDOZUMDsw4PrZ7GyE+G2JxjZuSWXDd+vB9QJTpHbquijwIhAPA2WXu48IY6qNiW\nLlIfiUFXLA9LN4fZbGn7p5qOlHSG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUZXI6Cf7dav0dmJUo333PCASC4SAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK1/34q+e27n8WCFD75FBiU1KjKI\n2xWicXW+t8EL+B5Fzpk85wc0wCVBHERa+vi0eBT0yUDcXNvhfK0sy2xO9pujIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIFENrY2Hwq9NbkadpHFqEWUBRhE2KQDZGuooPaEVHPN3AiBuQIVut90fAvvM8ZJu\nna5Sz7ZUzlArYl9L+yItAHYmyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUBbsPtxOr9AdXRTex7DhXl59kTy8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBKjdOhg2nUKKodJ2VEcZQ/eQqOD\nUayQC9Pmq8tpdcKcagYXgc7Txhhpo+pUCzUSbqaxkdYzao5vXTiii45AuXCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIC2glnIA/DB8HAPZUzhjt2rooBh+rwXmqieY8+zFUI3JAiEA/rPKVhz8mDj7DzL3\nrU2qDf/FPGoeI80LE4KarOis+Ms=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUMj0+PQRzrCDQhrLBnvsX6Y7Rk2MwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBXAFd9p2IWHEfY664EMM1n/wYKq\n7A6kc+dJqrs7/m3xiQUd7m76o649+h6mLlG7DWITOKsT2VszoqQZdtPsjWKjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCF6Q9xOQkgUpGOmENmzxmnq6nT06gkelk+ElWDQ2LZEgIhAKLkCByYAPd0N7jZ\nBkDA3ocich+JvJZn8nG3YhEQSCBS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUH8AuCI9zMIyGraOfURPyEVPEhPwwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLebptLS72B/OTaZmBvx3yopBdad\n6D55K0VQOSL6DIVPxgqu8/PQHl1OVoBM5cvE2kk1zMMKNyEAjpKExu7zI1GjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCWNLgItmZDyVpDaWuXjidlVbuqUegTFsTsjpqn2JQNjgIgeyRQPID35p83e0qa\nzpGSFAiBKqfutgZ71Lw7eSdskNY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUM2PNtGjfqmRcnfwXqiRYFTqkfHAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBSJI+QI8iQs7RsBRHfmC8Ai5IQb\nunBHuiwBnNOIjdvoQEIBb0lWhrk4rN1hIyyVFbwBXt6sWkKoHoSygLpPJGijIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQC0TCK1BzjQCgpso4t8GYVz1OyrEBczskXnbxgSDo9AJQIgfDO9nfZNbcpwE1rj\nYVkeSrzRA7Q7f4ts0+AXZc7bXEA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUJqkTnQf2PpfKPtHd7SEkOW5ePZAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMYGuCD4kVtM/VLKZSycN6REI5Gg\n7vMxoiVPorHc+l6JyRj8dMMxbUY5ZEV4TxQg8rymXdwH+VuGWcqyK5/gdm+jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCX1NfOFG3tlC9wsxN5YSIcMU0Qoi8cT6gVp8H6Gp7UvQIhANUmRG0w/UEe1fpa\nQexv6SINurqlVBDcvE7dlOwDBtg2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUNOld9msCKGZWisuLDchhXAbnwNAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPrOM7z0v07+6Kc5Xq32DKAxiDSn\nbHCzyAy1pnGub5NUjzYrFjT5cr1+Kp09hN9U5c9VlyWJ844u7hm+okjhLZijIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCpla8DdbtOxoVPs2VIPTvw5uZ++LgquXWsMR6Aifch7gIgHj0N4PcEfMXMtYa8\nY8v4g1sIEVOUA4aWJW7ptLCN//4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUNejDzsSqp1y/WDLrMQ0vD2hQn38wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNsw7VnxdG7o4myFDZSFc/yyubMW\n4yE0p6FYScoVOVl5cjtXiiuzcuf/7A+LkwksUS/n0jQw83FJ0cYdwBAM/sKjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDTZIKTwOj5aYqVO47wd94U2yyVnsXhcT5cgML7OgunvQIhANfrh0mPGoDz5fF4\nCaC7ggDH7yNMKoKyjYiO9XagEPKW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUetwd1XDvXHIa/Y8S6tMZbFutW4EwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIJVGJbX3zk7N95V26pQ4c5tuQgK\nOqGTzZF7XVr3oYu1yOZNjrY1uu5JgdyZnJbtida+Rr3wpy9ugyMci8Yvw+6jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCuxty7AIuB7Wz6nezsoS1uvBSheopLSqexH/J6Md0tkQIhAPvKIHKLen54WXMT\n7qXRFVrBKIvbTYWqLCCx1jyIKZzt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUcm3O0O+OtqHcVPKelpjMnD0yJ24wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDaRKxjGj4WYi/y55sh2LIqcDbp0\nb8H0fDVBdF9SNQ343/VWqYItP4O37YoHGgIdHSoeXoSGmOY0G+5IEjVyzj6jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCBd/slUIy/iP5rKA7NrZphjbYRYSKOnKI59N6e/KGg4gIgdO/hXCxFI+r96dpQ\n4fQQtqKsLjaPOZbn+wU/uonxYIQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUXXjx24pljqhFRFqlqEkUMKbMwmcwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABL0JXJ/pOdgTJrX93E5en5rl6YVx\nwGiyDIOYYAFfdrgApA0TtEHX44cdjSh0oFqHBAVJq/WmB4IESQCgpJpKyRajIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIBEGW6XYmUIfWUoEQbmeZt2U7lw9UUrHPXXml0OeVNDJAiEA9qEQwyu4uzHx4AmG\nv8QM37uJVm78N7LHepy5Bwyvu6Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUIJzdvE0BdZlzMtVeDQyS1cs29jAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFeh2P3bGZKMr66RzGdmHKD04cBR\n7jIIeStTz5sQJnaRl3Tj/Jn0UPSKHu9KKxDekpk1ERWR3l5+426qRimp4ZOjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCswm3LwlUP+XsA1QAUK9l2viGeG+97UKFwYblfW0ySpwIhAPZqd/MPF0va7kr3\n3wnwyStMd6pI3KbMqCtn437cu29/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUXsQiYeP0rK5JtyTJZ6ftpMBH/hIwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABB9Nt/V0XHzEd4LQKVPVuQlr+8kU\nin/cneYqCPhs2LOZNb8ZmXH5dStXiexnlMS8nS6Ee9DnTAisjKRFudhcuv+jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQC0p5u0fgOokE//YZFX0Pjy2mrBb1NnjxbKXGn3Fl69mgIhAIF/OBqBX8rOC8Z9\nHn6JdY8Evf6bCOzm+icLLVA3Yg/D\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUWrbvyPEQHeaurE249h4aMvOglf4wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGbMoMdH8DDCHfE7BhaalCyiJ/0Q\n4W6xKLlQYcFiP7+u77OuzPOMdAj07VAZWkhlo/7YAnw9TT2bSX73ncr3wIOjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDSGCM2CNgpHcdLBTShKrxdkNTZEuYRjoyYwEiyAhPqEgIgdBxPevtARtj7CbOT\nuhFn5lk7a4fndph7pxevLNDh+P4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUW2S8jxC4FVXogfcfBtuLhMstfFAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABACkauIsISQv3s40PaD/I0piLcoZ\nq+7abTebkse8VCwcZaUgb9nbzXZ9FJOX1iU67yFXQ2bsHsjU88csV4SLaU6jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCwFH5oNdkE5B49KqGaNFT4kmJ1UomiM0DfI0aL2T22/gIhANbXOfPn3EJnmJDr\noVrP6a3SNPjtcAcQYQJNVjTMe8jp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIULIZaxv9cME+v3iK2jBYYKg2E5IowCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFUt/qZWjdYtKNm4Cet4xUnlzlY3\nX4u+KVr8Rl4riorHC7ikjdYkTkoMP6Xedbgvi/heR9maqr7BVLOlGgqdkEKjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIGhVSvLVlu9jWu/twKAho12EjA05NhFUm+MSlpxAYc9+AiASMG3k5tAufCakIelU\npee3uUL5nA9Agoe1kagaPPOY/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUalZT5TAcj+KZiSwZdbLqQHUtix4wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLIaqpOdjKb4UyL7llMQhG685jcb\nGwsjzv5xF8t+LwK+JzxhCm7seIucI8mnewPPiUnNWFmjRp2jBwM9jbpHhOmjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIGuvaHhIsgOPMsww64EJ8gThN7MRUYzQiMaWSo2feZZLAiApG/yjQjoi7hLc1+TM\n+qo3JCBY9bG2zEOClfKrL+LkUQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUPI5pmQJ9SYjSEnV9RRiCFxzod6gwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFR14JIF+S6cZsfxUcA4es3tCort\nsxP1J9amiu3NMCKyxcU8hZM3kybbxEZGGiq4FzkJsGhFWg8zveGheGR1TKSjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQC2wHk52DFqHxDBegxjoJgQyHX5D3Nv274M2eUtVt6qvQIhAKQcBd4vd4S9KKm1\nPZ6GSsH9HRn26NPaoKhCe2dz8/AA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUE5uogfX4uGajaCsCbxDjX0IzvlIwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLV1yuAV6tf1+Ym+4GYC/05bumb/\nGYwYoBSPX13lsy9a5z6L0VKlcmiNEDtxnlpGnNotLkCXx+h+6IKr6LluXN2jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIBUO18C39efJcKtcDxBTnPkoV/ciYEQV0fFQMbEFeGmbAiEAsBr9UkhSqbD8g8qF\njFyqlRlOuMrCYLfdFiRmi5LiXg8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUGM87USwqH+ogARHh+u744id9gH0wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG1L83ExRQD2w0lsk1GgTDFWRGdy\nKru5pQmiZq/EACXcPSSr+H3QN3GdMspLFRU38ETwzPopQwT/t2Ol8QaG08GjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCADcbTMPxMF3vSdjt1Di/0WpWZVPERQQZUq+1fMX96qAIgXYPSQd16139ltAu9\nlGazdA0SXnQFD1nS/TPJp0dX0oQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUfhf2fyTPA/eLW6zSE9SA9QkCw04wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOl6JQ5j6LrG3WAmw+tReSNQVpkb\nbZboqlebYOYQfcKsEvo02t/yFqimwCmR9LVsIsmBZSW5WpMYXzjr3fMIKCijIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCPF9mN2OgIftieNskmG989llj8ddYlxinCJElheStpmAIhANAXs8a3FBX1kIIx\nP4B3WpRnOVBn4m7BA2nkXERG3A2G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUCwnF/xjZNScwv23xvEbuOE9dhZkwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJ3OoTV4oPYFCWkFIX3nIZm/VTUf\neSHbxUrsTnBun7di4dMfZ0Hc06XagYxWeBkzGcXfYMBxiE2FimhkacfTESyjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIG4zaN/P+61Wo3o5NaAbloBqJATnlO27GVQzZeUPEplRAiEAhcMPgO0opYT4ItSm\n2RBLvdQK2Vp0jASNbiP4qJ2Qnnw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUIIXjTsG5DN+0l99Jt4us38P2TGcwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIYHCn6HD4AblwiliN2WJjik4Km6\n53Jp0zOrk8hrbDbHKaqpgqB/dzV1fA0Ld2xbpf5daWVYtteJihyYrtumkAajIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDuhoBg/QDEx57TdrlWH6UqoKqqfULKq1Rnqfa1VLB8/AIhAJ9ixrvgjrMjXofJ\nhAnXeqjugOXwru2tYUA9OLqHVxsV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUeTeGscaHu5nBUE2Cf2KfX+b4pzUwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGzefbckQxWsDPlAxj4XYeymq1nR\nOcvn7DxF/DMQXjDwmrWWfvapvgob9jrM13jgko1wEAdJUpNdoZeIvTHQD3ijIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCnTaB5G9F0JU4X+XRgmKT+UWfg2r1qx3DF2njB0p0IHwIgGw00Obx7sgZ4nUkK\nxm5hsEymluGZY+0XiJLkU34vdoc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUd6PNxOzOn4oUfftrxExF2zv4PDIwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEgwJJoRNL1YvOiz4eb4l8FG3NA3\niDCcSwMMhhLcW3lXNjfQRO3EETofaTrsGvG7hr7BSimjCTJvF98BVBYj9UKjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQD0BBTRrzF/nOeSZCPKEfKxQee/dD1UDvGq6XUCYYcBqQIgCkdkpSj+pjUbtQlu\nCLIO+87i0RDEJUSrsl6O3UKNz94=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUZh5HBxm2AtErKCEyicQYp0fEbKswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLhvqtC/G3FohG5vZq0eijlNCuqx\nB22b28dFjgMcQ2KzLBhCR6fNtzFFAgUFASiapj8NbEOsdfGP0V/M2HL7SSGjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDC3A+nGYYJl+Gl5XRhTbz0cKOa9JVHKTEmUdsOGucv4AIgPulQX8oSBgQOAI2g\nOMpPd52BOCZJRrer48pe224Z410=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUJKgWhtdb0Qxcd9hedVlcesVL4OcwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMIa9ZwOVE9P7bXiePZVa0tMHXv6\nQszoKC2SeTABuaVUSsXqQWrZU3N+MlE59HhiyVPVprhoSaBpZ+nUJhnhi3WjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDuvvv66gwysXzX+1dm8O8s4VZ5LONOC6yszgeMzZF9xAIhAOOzx2/kdTq0D+07\nlerhdSRpUKOT2mC+Q/7HtntA2sM2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUTiupcWG5yB8SiErtv/j9kPNmTtcwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM5TKYoaxQfZKNWN7UuPiYlFSo6/\nN1G/AySlK5U1IMxy8f6ovSONZj03F7tJuMl7r0ht8hOFBe+FjtjJM8H1HPWjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDfC2AP+y5KYkkRRPLQPYH9P2WmBJ1qoCpLMaL+qajCcAIhAOdrr2p9SitpGbEB\nvtjcM/V1L1+Il8ksLRZyBVVupPO2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUShnepp7GvYXfEVxbUYriNrDp3UowCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJ7R5qBBB/UbBvBmN8xwSwgrna/U\nHjSsgWmWnii/g5CCc+mzO5SqqUlyhvyB1w1k70taUWop2fxti2hjk3kArVKjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDpxKt0frJRKAXwg8FVxhXWXe58We5Sa8IgznG50JIWmQIhAJLmV227c8uX6xLM\nvFQURyuEm9eik/uv2uY02iD0+3wy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUClHU4w2fO+ElYowrgjLrZ0gtw9UwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDIoRw64QPaX3NQS1hJS9KPEDam2\nXKld7HrMNnxkUzFYDuGcCWS65nG1lGYAuOu/6a9QXajaMnGXPFuB8D1g4eKjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDFVWOBUBFv4SUtzCW5S/ng+3O33nLPhMdbPJkDLNSoCAIgfIOa3NcmOZB42N5P\nCfILWOuGYFRZ+vbL85MwjCYWQSA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUBoacV6XaMG4ldZJXvLB1QcLJlZYwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKblCfnMCC7A2Vm/HiU4PoAldK2r\nAdRVH6KYbDs0MuPE4ikWtuLGU2rAgxTN82ZvecXvHnHCmaSYkAA7VpLGLGmjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIF3nh2amHZqzlOMj4hffgwboZE2y+99jnYAPXRwxw9NTAiEAu9Mkc0Z1xRIpLjEe\nmukRCpxfX/sIZPD5I8ihb7yrTqg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUDbRvQ/ERxLA7w1QUeZ7Ep4Yg+VAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGOXJGqqYqCdSdC+n9FnfvYPGDWf\nRZQ43AiOYOLS3kVYaACUJfQbrKGbYjIVPshFVxR0QcLyLbO3pSvJYsrMAp+jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCn4ZEwEwZ+7Wg72bqA5n8GVoZNZWxTgTycA0IeIpB8WgIhAOvEBSpn07fgbmx2\nMPvW20Qp7CcWVgvZUKsG703ITk2L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIULA4UdXhWZ37fOIDCs5ifU+nnIhowCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLHEeES+kz8IDdaAht0hXO+XZk4G\nRN3BeBVtPFeoSpElpvNX59znuBwaSDHaLDl9B3Nse6wDD7zXe33t1EA833SjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQD4+mhsALHqRO4tBL04XSs/D9oOvsPTyly1KVK5Lq8WhgIgPUv6NR7F+pe3U2et\nV/m/AyKxibjUIqvlCTasK44IWQQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUP7ki+oaU/QxV2Nr7wriZJXls1RgwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM5pqf9OA8OciHtRcRY3TMfu5RBR\nOnjZsbPrbK3/R9DLx0o7VEE2WLEP1d/rsI95qtHlER92T8YXH//MIgRdil2jIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIDZcJRtuMbzNFxI/GypnrlTKjGu0HMqw82H4pYqmL5qYAiAVa2gdr1cd86/LASoU\no5NL8uRVCCK0wETnTnqzmqHMhQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUFh4uHlKjqHf/jaOZGkUESMF1+YgwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMjgrPswz4snEfHczgtrGgk7z8Wp\ncUQA5b3DzB+v4k9skWHJAOJb80rPjUTbr2jApKoBjPmKiusB9MWm5LGaf0WjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCZfWcI9V3DuZFNI40mW6x7NJpEmx0v2i8c8kow3XNjwgIhAJKUZp9gSJacR9vv\nGAX5SSS/U8br24Kw4qjyIX0eOHcK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUbKce+XqTSFgIPnpuZitO3VsxuJgwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMRvPRhubGkhBsbvVyvq1onFyFTl\n+5whEkT4aDfgrPM+HujrRRootYKNa3zvA6KfBesJ6BuhsuLKlMkB/TvxeQejIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIFSgiqEiBkT/Lpd1x7gsU65Ni/zT9WDpVf58qeHxb54zAiEA8AgqnUoJWngOovyB\nZgkPvu58378JNpV08uUaAAFAmTM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtTCCAVqgAwIBAgIUNeXdmvhjsaVBNPRhfMElahDJ33wwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowFjEUMBIGA1UEAwwLZXhhbXBsZS5jb20wWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARC1OXkOXvmie6hhfEYqKPANprNm/NqVPJBknIX\nlUqMYUDQYapy23yWoVgsMUUNjLRxLgqoqwuuWXHEhUOcbsUzo3wwejAdBgNVHQ4E\nFgQUKOittg0VtL9Dy1uOTGcgKQ4nFa4wHwYDVR0jBBgwFoAUyhvVEL3kuWSe0t7I\nv0JZPEZ90QAwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBYGA1Ud\nEQQPMA2CC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC/L+mLai6tZMEY\ngqMOYkOEDg77tOjSyUJ120bQNQhvdwIhAKds7tuQ/m8rw/nIeFgEYXEhcm/+dXhk\nkLgXwYuLw+e2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICmfjZGBqbFz7rrZh/0WkWzgIrzD+S0uaHRtx449uniioAoGCCqGSM49\nAwEHoUQDQgAEQtTl5Dl75onuoYXxGKijwDaazZvzalTyQZJyF5VKjGFA0GGqctt8\nlqFYLDFFDYy0cS4KqKsLrllxxIVDnG7FMw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathological::pathological-chain-same-subject-distinct-key", + "conflicts_with": [], + "features": [ + "denial-of-service" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nICA (self-signed) <- ICA <- ... <- ICA <- EE\n```\n\nA chain of 100 intermediate CAs that all share a single subject but each\nhave a distinct key, none of which chain up to a trusted root. No valid\nchain can be built.\n\nBecause every intermediate shares a subject, a path builder may consider all\n100 of them as candidate parents for each intermediate, exercising the\nquadratic blowup described in Go's `TestPathologicalChains`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUQ8McnidDm3dccW1bAvOENp9R6ewwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARP5LREhi8vlRZS2nv+SyXCpyIAyyrXA4EMbPDW\ns+ABxw6JU/F6+2W4QOQOrw7B0brWVT/RNaVcr2uEjicqhOifo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUQv/qtV/fwWks2h9rkIIonq3U2UwwCgYIKoZIzj0EAwIDSAAwRQIh\nALtbU+ECZMC8r9+aT3DRCgx/n9YLEfGlykc5u7Yw7tXEAiAA3o4/842BgplJi0n4\na3e0Zc95Fk3AfWdIXYTGVwEv7w==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRngVczlGYvgOY49JAJdrk3nCdqUzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABIPNkcXxPVve9x+QOOi4vNYClrI2sH0CAzTOxiOo\nYbAklgIuuSH0dE6RDUxW+jYnf7+bsSdDw4PjP7euUglMOASjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgEGMAoGCCqGSM49BAMCA0cAMEQCIFxpaHKzGJNF\nEj5QQFO7KDkLDWfGk/hFrAFlyoPnRpClAiBBQfSpHwk85ngm1u7wK7g+kYwKVgtu\nt7Fq/4LCl+OySA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhREYzCgWmvI1fIq5kysy+rRtnOtJjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABHK6NhftGvNxWxonARAvsK/6k7xGcQgNV/y9P+f6\nQ9Kj5oOjcdrw0thwQFmjiyKU3acEN5qryDi/TAJzchvgzxyjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCtN3hoGxBI\nALBgVw8KAdA/CU1MVfZ9VzKRiLcXSSADdQIgP5GtK9Rp0LsezKXed7bwI0qyhVpG\niVEkOZ4cFQVkedc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQ1hzjS3C44zFTLS6/2MUOAZbajMTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABMB0kA2+74rHKPCfSiBVFl4pVaiQsOV/sZu4CJQF\n9Cq7TMK71AhN2Z+VRQ9SdPXz7HYoZttxNxNu3j5eDZ29sbajIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCFxjuS8U3h\ncMv1GO6Tzg/t2zeFV2KtkFc7RI9PL/rSHAIhANai1/r2hlQAuxma/+gwP2Dys+JZ\np5Q4P239IqWiSM3H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQqAxpAIvq3sO12W09Ne9uoBz/W+jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABKIy13b77lMDaZqtq44AuVjWX16VAnFwnKzzGRIZ\no4oWKsUetjKv5HTao+Sf71A1RRraHIQ1y1X9cxC3ilt80nmjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQC/boreDrlH\nUmhGcAOjpvrcDTpLNcMp8Vjpc5QS2XfFRwIhAO//90WQmwkhOiln1sXE8TpoXGmD\nOcQpOi6c9BUBBfrN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRZeOevkdyXhEKDvK2ybYO9YXse0TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABAiIAmoPlD695aUAguuxRCPzG1BseBcpWiTMsGvL\ni+iyWaSugwEECHOxbZWfW9ArB5IAYwB3RV/YoTw8OJz+WFejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDOIR2lGc1u\nyW7WrC0twHlPjQ40gcWZBsdDQPx0f9BHSQIgG+fcFFf4WCW6zv72717jDCxLalB+\nvfiOKF5BpG68ZCs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRTNWcS5Fh4BuE0PD+GW9JJz9ONCjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABCNQSwGWN/J4uagDLZGwivqKY+cI0xzL1dIO2nuY\nLPARDFfvsHf/RN8/vbBx7yiVvadezpcyQPIKacyvKR+LTB2jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCICsqmrP1xO1c\nRRMLMFVtK117D52jaAcdJZnwEoBlGoI6AiEAzN6VsNAPYY8bppBIR7zhKhd8IbEU\nQ6sm83VYm9lDd6U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQ3t+OplHNg6z1NIsqwDXCkLl9FxDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABHJgXIw4gf7vWMOzHz8nNA1KJ998l2EJ7pqmYtcz\ni2iSIWtp2ZVsDF6CTg+CoOBxRC9SG/6Cll+HDQBRLRus4lajIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDHztfiV+46\nZHRDO2vJxqy5Hdfp8FepsiubLf3pyAP7RwIhAMYwE4hp/X4iC7pqaPftv06kbnKS\nmqt5dCl4ie2Emlu8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQCMnGCxsmw/eOhP8MGlNcUfUFuODAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABBSt20BbrjDEmTMddOm+j6PorMFrBBRjWNquXYKZ\nf6aJOecWxtkorg/3T10byUgAXcGCLP8xiBxGPNx5blVxdaSjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIH9GyWx2T/BK\nOVunmVvsOaI0JxQpSPI9M/QzH5qLS+iYAiEA8yeD7vPy19g/PCGnxAma6cMeeRzL\nFise/oEXKXGXhLc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRr0s2FLmVpvDhxkA6GJ5H8QpgXTjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABLDCygAUonZ/D67p5JKZe6rQf7VSgTZxd2ijw2XS\nZLjo7445B35bEdbnHoyxk5zjddtXmYAmd21V4h40kgb38myjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDmhmISxvhE\nMbByDWW7scyhcvcA9pjwbBDGYN3mR0kKQwIgWvmJfzmUN7oxoMhU843xUQDmyIFP\nf1t1h9oJxBySNSA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQLM+ItwCN4uBtGKwcedGyzJwsP1DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABP3Qcs9CiNrB3U6dSn7eXlK3k1ylmS1YGzr/DiS4\neh2JCvGjrLNNhfBzz85CHWhzy5bsQMPSORhrDA0QHoXoEM+jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCITtAJrgqJ\nsUYxzPlf1XyAuykXFaI5+AVLdHNOCoLQWwIgDC8Y3vwgLSqd6pbg4I54fLMTf/Fx\n99L4UQ8kD9rj8Ac=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRC/mjwxhurVtZoXCGpSYZsozzWSzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABIjKhXAMv7iwx7aJybywYolObTKviIqo1e7VBJ06\nnfdVpHzuokrg6hE/urdwBsurzCuHTqCtxfMUSalaK0aU/8OjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIBj6RaE654kj\n3mjjxZz+HNlBPPsQNV/umaz2kv4RU34RAiEAw6K+YIute3i0KV7pHpt26rn/Ucn2\nK+mn2BT4r4YLOLA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQc0on3BTiY/zIwsgyiUE0+70iQIDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABDlDPZ2xZClrGh5SrAs5cgZXYvqZUo1opEn6Mnmi\nPtkUl9amvxwqH4uYrNxQjiB9shHHcQmfVERsDHxIkqv7kcqjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDtFvpfuPEw\nTI59kXTZjKGCgJBOIr2CHf7hkoAx16TexgIhAK+RWT/f+nEaePSa9iGtMouG81PZ\nfLGsXCEdsfRAr7D3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQnhhcIRbrj/jE+EjKwRW3simGZ9TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABJbU9sxKqInQlFPCIdkC5QGkw+AQv+2W3A5ulIQR\n3tthMImWcedof4kBIRfi85P7baKHZm8Z5PhQwkuBzMoGb12jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIGDsUsxKKwdC\nPgLOTGgOzG7Pk1OWQJRSDw1mDrN4q1cTAiAGWvwQ6mpARK+51m1oEMyuhnPavpL9\nsHlxEfCTI20gHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQ8ehtxPiNlbEbxgtlZ7OFsJqG74jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABPrLx+QVoRstT+kuG4jRGBhg+ZjxnZj6yTBsHrP0\nzY+SxBFN9QWOjH6mJjn8bxn3+ZNbQHLHtLIc6Gq4xDoBj6KjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQD1VxYsky09\n61YTtj1xi120ycK3m3TxK7aAtQ0EP9R+6QIgG/tiGIwtKG0SCCM5uOg3T6PAXsoT\nuz7XfhNISAMnhwU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRWJrnlzMt0Fy5VcfvulF6as4lIYzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABLgzcqz7qEEu0phbsnC7bDBjIrv/f+z0OPeyYL7r\nnDet14A3H7jJsoqwiAOYEyCoOYylHOar61vvw9PDo1LXmmGjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIDytyucKpBY6\nOir9fYW5U5WhrEhTGv0khaxkANvrwCg0AiEAx5S5MEGAS+wUq9DLg/I+5457e3MD\nTgAxt4YjYe/raUo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQJPi6X3yM4I3QP3T9U02vNiZghwzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABB7jTsJvuha8rkVFaL8Kt4wcYLBvHHo9u71SrALu\nIl9YhQfdUSzALdhN57x0HohBsm3ckO+VK/mNdjdKW5WyK9+jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCzZ/SSVBt0\nAxXFzgyAHiRFf0e7bEld3oe1BXeA0HwZvQIgWH0cXVyUwqjehGkwDDnm1f1gEQT8\nc9qWP/O/ATTt3dc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQp18z4GgxruiYV4B0zPCOf8SmF0TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABKRL0yhiDaiQitFNvUjj/WOtWQFDamLRQKhrJpWf\nToWIdxe024zNrw03XJaQBtGATUTdl6rPHkIx9A4LoCK6S0GjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCID/kCaS3p9mp\nkA4DS+8SsuWvofNhiY34UcfnUTBEfPnaAiB22NbqdCDp6s6G8ktf5LIcDq+QcUjq\nbDfFpHoJpvJbWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQQvHYDZYw+s6KcXcy+bV/ZRn/wQDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABHXhvm9A4vZf0aoLwyjUlgA+AXreYG++8/g9fRW7\nsnNrRvvnK5cNU/i2hQoBQOY7q9KbIQHQxaT6RRml3NXt1cajIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIQCGOHvI8OyU\nAugmuVzJU0nRrs2WrcNS7Q8mjDAqoB3ovwIfdrFH4Ectt5W+yA17TgaRYUlG/mGF\nGWryH8qjGgF+dg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRPTEQTU1bEQT0bnIHOsSifiNOZEjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABCHBwRiuXXQMdPpW9G2eio5UXkyI+ZnDTUk+Gvvu\n+38693/hbUmRVAl9EcZ8rdwSkkjF3h1nVIVUwfuTX5lYRM6jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDg6m//Dzsi\nGqdF5VITQrZHGAyB9OIpTjWx30kQxIVnkAIhALQaIqTVI+0lNz6Wqf3cpdG98eEf\nwXmDxoYdPN0YeVIO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQhRMPmw/94c9ZSMfjT1D6hwUKnijAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABGjgfyyI+M3K9AejTvp1CQH164DJEyyeUIHOReog\nh9H0b3giWMDqBG8JmD7IPJVNrUmpN3i5eDECB9pMTK2rz3KjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCZ1+kfttLt\nF0zENMophVPzxXV4zChn2bmgdHOtY97bkgIgYmGeYbfdIgFgoW7t1AHr2SxlawG1\nHGiMY1wex1qZrLE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRhSgmZN/eQT/AnhTA63YIrRQHxAzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABBX4ePaBAjydYyLdABIDzCvOsh1JVJu1A0qWKjHU\n66lbSMtDV/XTCDq7wcg1pZizCptL/j+U1AmlnjYhBVkoAb6jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCWDIqybvLu\ny28Nn8qlFUr1db4l2WLHZYA84x3JtipINwIhANeT2V6Z5wla/y4/6W50FxecDnu1\nABJHieawBwPT4n1S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQcE+XG3fuPAT5zBuYgLdlrv47sszAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABGwC4tFBhk4tAp41dXG5GxXCldVMMmw0d68M2j2E\n5uvU3il9ndAzXIMrG+wr4OSiEUSNcCtbTyf8GLtzSMCCnwWjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCCkmBxoOTh\nCE5MbD7wh05PBmwnazGqvxtOs5RqW52FmwIhAPXsCzMuxGiqf0xZ7eBIzPsJ+Ng9\nnquRRHXecrCgZPg7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQ6CdIGgIlB0Z9mSnspSFihNDhB4DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABO5+lt+fRvX2sGdhjlVyN60+2RTpqC6EIj/0QF/9\n5+DSUdFcqRflSQS3fQ0tNLdfN4sPOCiCTlvxoRQDm+SDBsqjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIG+Gk5tIEbg0\n2GBlJ0PcwHuDpvaEyuKI9ye5XsTsLzLwAiEAl0i7PRwFEMq6dJ5ziRVjh/i0xxfH\nGicQgLv9SOtWVrc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQtfOhw82wyVyM3X6sa0j7Yox7e9DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABH/TDjP5xIQGhNY0O8D0H0V28EdHKcObFznpH2YS\nIX1PUdWUFt96i3UrbPW23AelxqZc59oSX+a9FVcmHiqCXrejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIDQqOHskxZUK\nTolojo1wdamf/gxEfJVvouFZRja9ZaOqAiEA7Tc7rJIRclNe6B6i9CnXVKVsOIcf\nE5rOyVDjBwPrskQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQHACWXljeda49BY1t0qyFohnovojAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABH/qZt5KFMt9cs3VqH6pSR1PpbLSW+0H1QBcjejd\necMqJi/CAYfW9awlG6Mqp/jQgR+kvCMa8lOPuN+vRyZvYfajIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIAhll8tP68Ek\nYaOQrD5UH3jhuOs/shCImWyqo7Any64LAiEA6hesk+23ZexuWTZDPzYcDNGfvyHp\ngsAdJs06SW01IZU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRLeFkSilbRSbixa9plLSs2vt8tyjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABOmBaIWDD/y24SLXSdaLRM+Aaonv5dwmHFbQolcD\njbURz7XImirDkOFm7pV/MKh3E0lHuIRbjVVi6IzneR5wcTyjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDfhphZdV3C\nQy8/iKb4HaMjsVNO0c89puKSn+sQ1WMM9AIgcPGA9fgr2MacOpJCKYlfLxV3z3qd\nCViRIXpsLECu6Oc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQij2U192YzVUetV6Qcbi24OlrozjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABCcLyOJHClGrAqRa0aIeP2w4Uz/If9RVq+ngIgvA\nYM7/3jCjr40DkOVgRUrwzwV+hGy6APeNcCMlLm0JYzlRFKijIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDk2aDM+Qsh\naC43zdYuuOPM0AZt+VG8qW/mFa9zvQ2beQIhALOAFSRYz7upJCqh07kd+q9P2Xso\n8Q+sOXJZ2PFxz7dM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/aADAgECAhNQ0wDixbPk1hT8O6mJeap4Pv+UMAoGCCqGSM49BAMCMBox\nGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTAgFw03MDAxMDEwMDAwMDFaGA8yOTY5\nMDUwMzAwMDAwMVowGjEYMBYGA1UEAwwPUGF0aG9sb2dpY2FsIENBMFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAE7CoOTdsHbFV+vhFsSXaKbZoe7z1EZT4O0P9vOBRg\nnFW+QdnK0GSeTUIA0yMViXAD4Rd03DvTMnJ/XFvsUDzIYKMgMB4wDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAgQwCgYIKoZIzj0EAwIDSAAwRQIgFNznMj8GUIjo\noANJ+CwhMeiTh19AETRfglt+ykoCVggCIQCgZpCxRDXkAAgHDO1fy6lCbCm1ASPz\nnYr3TmFVpaWsZA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQCov9EqzCOWFNCQhTtEPUEPamP5TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABENdoffrtqgzF3rpY0WHw/sKnhdY4RS+PnNHAkk0\nyd2r9tdANbFFuI+i7WIbAqhPhfn2rY0GwHdvNTcu4oZj5RijIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCN7T4NP6KS\nMLjCcXH2uxojb0CCTvvao0Z8oEw6UIIgHQIgC77SlprbrhTSL510dRjEUUTRZe+j\nayaXRysMDv1HewQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRhuXOxmUR6au6Y5qJQ3tEZjR4pSjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABPYsaWTu0Pmtg6gEN3labA4wol/Wb8IJDZ7PQheC\ndQ0oyhuZ1p1kdrhXIx0b7wqlZKpeURQRmWXBkotxA1XScv6jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDmsU2sH0ou\nuV5eLMnnu/7OsOgWfFTMqW7Agx+Y6MEwqQIhANDsf9Q181IYBhXUkmMKuRPavBbO\nGsiM4p1P4NBzpxHT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRPDRvrxCwQIRwkt80U3vuhfq0I3zAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABB3To9mNnKaIDh2ulXFepXLonoSCP1p6Fz7l+aFU\njTaP8pSq4S3pw13ZWPhYARd7EW/+oe6/mzy2VBGHaT44qa6jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDdo/BGizkM\nn+pgvVmKklz1Xn47U2FqVcEoY61AOAykkgIgCt8joLPjleWHy7jKzqSCNp3zImm4\nltwSOlsoanyk+6I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRGJRGZeumrOtQ5Raklo2BTV0rVGTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABEf9vGUNrhtSYFcXUO+KCPDKitdqc+bGPDXtndpa\nSaseEFTqGrr7g7l8dehjr8nKi+VQujU1x8/WqfkHfz5dTBujIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIH+qrjpfeuKH\n/9jGw6WuYUwIWUE/2nnoyjfo49mVSZoRAiA3S7xyz0bPABUqiF5qNBLVtOJzrwCS\nsTwCwTzDGNMm9A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQ+5lttTw8Ax5suQu5P4Vo+icVFBTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABBPkNi2/UabcO7qpziubDYUYNpWaDYOGrFTxqFD3\nyGszhmY79iill2sHg1382SLQhanjiP5ogtyLCf4rdZVu3d6jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIF/lNf72Qg6t\nyzWoCrlAT40PP6CPONQun4rzLh/AXtBvAiEA7iUPLvjpl5b8n8CE43jJR9yioiCe\nxIGO3zgDURCEY08=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRcFMGKQoP9XHjqgurNVArsiUlMWjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABB7pSeeoeRLrQRndxNPWzMkbDoeKCwErKhVbcYQs\nuzLEt3m6XnF3G373ETTjiKdlEwMnKIKYmTQ4P+vpg0oj2WOjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDKShHl1sQU\nhOsqaDLZBZbV4aEl4kt01hhZwa/qOy53ywIgLE7piYWCjpE4tf9ljFLvuDMjJM+g\nE0Pr/AtS+CZseVE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQHyijPFKtzQxzRQMgO10e+8fshnTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABEPnBIqDXBfR3K2fQ4OOU9/FlrwfYff0PZ3Q44s/\nRXx7GT75/iE0+dnE+agsaspSkTJ7nrAKaLjKrYkgP+s7kwqjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQC7jI+AN+oH\nWFFMu2aorUDM7gc+Ci0UTYT7VJ0h62J37wIhANeRQi4qgeD1Fjqfh2UGq/Iz8G4f\nt/pXc3WujktwegOx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQPzFeZVQyuPy3GtBRbdUwLfZeoeDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABHGijnVPWvjjoRysNYl71j7lWS/LCv/jmEI5k2Yp\n5OFryPOgNlLhAMT4MtU9ZEIBuDT0rrjRGrstnPP9hfXu+P6jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDiBgY2ciK9\n3IiqbgZxHcushD/FDu3UF6vh5OWeFojA+AIhANAqnWe+sy0wT3Y+sL9orObFwdZI\nxCTMBjE4ZEp6WRCc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhR2RC1lhnomnQakGs2VEEbe++owjjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABNbIgHq4F53b3R+Vkq1Bba6L0KmKkjXTM8obr1sS\nF8qk/9LcurqUj+3z15iIGB/IQdf7TSJfrOCEWHe0WuQ2F+KjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQClHFqRBzQQ\nWuD24JgVpZ1jlWwQCbG7IPHG1KDmHQh/4AIgIpKX+iXvFrm885YlHc8rV2GKrK+e\nuMz4pzsbsjJnyTc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQ+jnNLF5sLNslGR+gjom9btjH0hDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABIOXUPWp3lX7B96zIwc7omay1+KspAN7M6MC44fC\nO1+kzogQIUId+Sdv8uYJYjkiLR+yLR9ZjCJS1ubPFkMjkrWjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIFRF+LGAHGt5\nTruR+9vl2bdfje/C3yCKWFArYnb7T12mAiEAmCutAOAeja+zuZHIU5L+b4oncNPe\nKPsz9oOt3lUTP2Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRvZG2rm4mSp0fNCE4b5dW4U9SjpDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABFUTR4lKONe4UtQsWseMD5UWUjSM02JvnLfACDta\n2Kg6uoN0Xouyj9qF/bUHEXNfibtF1K5iTU1LyxKsfLpIBx+jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCZ62UEt1ij\nIP5gqlDzVWmVIRwcd2Ff3AgRCiUHzj1qNQIgN12mfAQ7ZH6+MpXLZg3PWrZLDv0f\nKtAVVPt/PCv/e0k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRe3WKgqAz1HmVf7MpccLqgXziSNDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABBW6Pg1dwAlpLXCd40jEAd/3WI2MrZ7uunzZUIz2\n8dU+TEt4Xd69Bs59Kttj7XiA1H6EFAC8cGxQJqn3V5+aqN6jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIHpcG6tC/Wfq\n5jeVzo/XH7pdcMoRaut0sqcN7+vmbnkQAiEA9KJbPqqE708qTq0oW/eNQLsqNHUx\n2RfJ2PRXAN0lEzo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRhbpSkgMZs0Z/VsMx6Cul5H7zjjTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG4EZC5DmaI16rloHEO7wBuq3sVt0T1QSrydLlG1\nyfG9nTK8MT8eF4szD1PvsNAb2c2v03wYuuL8JZrsjKhfURijIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCICEsCWBCVBbe\n+jWjD4LIpEc6JIpCzuCPK7l1cLGhbytcAiAk7KsCOzo93+SX/sp1BiypdX0rLeCW\nv/X/ITeV6PJz7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhR4j5Uw6PNbh4sqif+YeCyWd5U1BjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABOz0yKEyXtL/j1KTCVhHtr5E3mRanqhGRbjKvNui\nA9guZtfyCxiuOCaRoAWDZAtIVPKX2vrlcMqUlhS5RCS0uCWjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCA71VnWl1I\nNJn59Kvoy6Ss3SMNiPEg9QC0jqyDaaleQgIgbcz2ztEQjBTj6yR8M6wOhwDahZPV\nEnna3KRQYoJEWU4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRmUm8X37GjVwFYwxcmqoPkb+4/UTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABFZLvs/9APZ76o1WdO6hcqLQChyo7St9jvt3ZV2f\ntKgS5/BX/xSPmgXz+kFEccQbejGQA7XsWIXD7too247uxaujIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCgJhwfE7ku\nSKfBnGQd8a80RDil0nw+eGdZ3lixaU+Q/AIhAMk0S3vlHqi2LrgAS8pWVK2AqH3o\nUGZxGKtiYzRKUViO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQ8lCtk4GP5q3N2gPFdBnV4g14Y8jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABOKg7tEE7bqHl+Y+xDQ+LdPEien16MZGqyJ7PPBr\nJpOC5G4/NAn6PKxzi4RWx+UUlmAzzv1ZSlpVLVWB7Kz7zO+jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCVfeJ2Bxc/\nLa6MU9SZQhuxvc+TSMF7Di2adSZvp4zsgQIgRWC4fIYNHv2nEyk7sgaQprn3pkgj\nv3r1e0wpVE8IMSQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQ2+h9RatrbHxeX1AiLSKOfny+ANjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABJwDUXUcOfbswmNEuU84wkhUSSd5HOUSq6T8xkNr\nv/7Hg0ce1IuYzwGl7CPGiacfk7IpAjfmUwVS3IUFWe3Mw9mjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCICR30coJtmYY\nQfWosDZMLL9IDBBd3dV/A4Bg/YL1seebAiEA7G3GkBWpSeSkysjuKZAohL7ZUT/P\nEt1KU8PcTqNY5QU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRJpFfGwt+OR4d0A+HlJ69eXn5qXjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABFT0knuxwxekokNRyfQwmbZwAiOSTfwMFHRoIBRi\nyUTWxWbpgyivw6p9i8tOEFIRRyFyQ0mYiXWxvI0V1UdCiQmjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDiJ3kJK7fb\nVMfX9fk89oAKcqYi+7uKOY6Ofza05q6AowIhAK30bzebZgPXQnow/BdKpC1fITmo\nuO5wyFhO+Ycpm3A0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRZLrcXsh4U5TgNQl78dRzRWUGaxDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABGecqRz2nvA0SUHeZz2IPwnLkRyTkFoxKuMCpnaO\n6op2o3yWZLt5x3sV7vyVzxyfphr00OvARaXNS4ZOtrCjxk+jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIA8CkDUswJFi\nhET7DI7jd+UxlD5ueg5z5zwi+iIbQcUrAiAy5m4ULRa2ut+jBDHHwqNvmliRc0lM\nw7MdJ5b0Jxiraw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRJEVkeiSBNgNmVUnDtVebXxda6BDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABL20hG/uKKNNMTW+9NN60grYUWwdYMdUTIlzeHou\nXLVLav+V+BGhr/nFJlce1vBvqxWDEAILCK0q/GJxP4anocGjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCICkU2gTyhTZm\nKXW0bTFYPgOZyj7Hoo6+Bx3NKypzjscpAiEA+LpRDjhEgQj4+n7Da4sqRrfWEzq+\nSkSGat6r6dzjgpQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQh1KxIkr7GlQa7kJFnsSZNxpR/6TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABCrQ3nehnuGEGrsG6qTQ/cX8UOicX3q1+WW6r1oE\ny1ErOCcWmvmPOpfRsNjRJQVIbZ0F1EQbOTOVCgjHTQct7rijIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQC7TSg3DBCq\nNf5xv0rwwVrclNV3VNAAgBRfuDuvop9JyAIhAKPxUQEWT+3ZZ0JKwr4r5N5SGesr\ngDxcWHgyHNsrApX6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQkCKanwjXcxBOMS1+NBHvr6XgbjzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABGOsBECYgbXEjuAR58WSpv2ialh35/ttPbEZNJ4F\nsLeLUtEucaXSlVb6e7paR3B6M5EK8e1FQp4csF6oMKcw1lOjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIGPffgguv6Mm\nsKqw291C5xGFYLMg2tE7Jbfn3lB7fP1YAiEA4EU5Un4w3Zvqqnlk+B3xtS1YkeLx\nAloJ3QocpUV9lMo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRxSkBW9f6E9CZJ5AhMNrg4T92qvjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABINxWZ2kzDNZAV07Mto8B+TwtcUabhfQeKN83/cr\nrhum9tJNs9hx8qeMyqzFGZ+O46bOTFNL6ti343L4KGtHsm2jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIEbziTjNdtwl\nxTgfSaiuXSlznGKColRqpMqqqOPQ3A0tAiBUihVXnilbfF82qvX0xu3uyGRvJ2Hj\nZsMhg/VFsjkaGA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQceLPD9dqTsyCl7Z+PPCne4S8dlzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABEZnRQG1kChC9m7xCexOj1oW6z8Hypg3BcuBjdOp\nKzEHPcJjvlJYI9AjWK+ctNna4X/Iqnp9NB+JuCrAPDil5PejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIHLh209YM0Vx\nYkM+a54apHzTOs0zbv3Mb+HnXJqW/jsNAiEAr77FFQdgIf72TdR7CnxqcljMMHbS\nReFSvD9H06a4S98=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRPvL3AhC01OIze2rlUyIFnnwcgTjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABLo4JSPhKcMWAZ4+7oKNfwuSuPUv4SypzvFco4RS\nZzX/qx8sC4sKpFvC+yMORnvOlDv7B246/Zh0mW60hmXGasKjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCICmn6XpovkTY\n/GWYCHG1qUpaDFV+8DQ8Kb8AcCwPF/ClAiBo3iFiSB0UjUbwyiEHUVCtF+6cdO7y\nq0xmPSX5aaw9Iw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRBko+25uMqSQIhcrKGhsX0rO7N8DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABMZKp3pnwqagN5CRDOo7PkEYpJBDMoc49T6wAMOw\nE1ob9XpWTr95Ep67uOvKKCWMdYWTX+pj4LyRoWxsj/+In5KjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIFImP19DTnL3\nW+4KA19VtX+Ysp50MTWBmiXy4vLcZ5doAiEA//pSmgB/Ejr3xQuEF24Jer70WJd4\n4hRLtW6gVZCBM9o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQKUQV1mTmhBjuDebM1VZnxaSQo5DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABEXOAlgFCjHM0xadjJbddWP9XTwpFCO8Cw+VS6ZZ\nx+MvhXOPpz7ugv3/xb3deYLDIQrF3le2rHZlr6RMP6bRxlCjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIARvcOMVlieO\nHYkAkKUxR6fUbfJdY8cwwu+KwWta3sLgAiB+LekMIZJqaI1DYGVLxsn2E7CGK8In\n8NiNKNfgdQ6AiQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQyAAtILGGKniGc2PVgSifcvFpCBTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABGC9XtY4iXMCRWQqzsrR1XAP0qMFKmlTSyttLYua\nGy0Qyje+6ih0CcTMrnY9I5+vWvG0n/sxetz3eun8AgZAi0OjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDDQXIKxu6W\n2G6y0R65tAx4zhIakKZKbdsZfu8VtRqpPwIhAPkJigNMS3618qR71TObKDiNwnOI\nIO24X43BmtE7sHvZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQWHr1yBv+jvugR5ygT9EJT78DlxzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABDR4RRcRqbxVJXhSSuoLAdAkhKx2qZBTnMJuYgPs\nFeRdjzy15m7nPW3a5jExRf/UR/3GHapec1hTFA532K776hqjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIHptxSjyQrsN\noOx1xcjX1pXtDj3a+7OtGOElfbH+DrndAiAfBS/9FpUO0E0d9NN3jb/42IWwOzps\nX2xHkEV3PDaLeg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQeZ8LEWB7pi/iw+momjTFTmWYi+jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABCiUa2+yar+uc6bplAEqOoOFUz3L8hcQr3od2c/P\nmSsvqIRn2b2s+mROGuc9Ni2n6gOrM5HRxfu7hVCAvy8E5ESjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIE/okvU/Oe1K\nwBBJkIfeto68jtPeWM84Ut14mITL22lsAiAsamUNM401cD7c/3/QG2+mRZVVP2OE\nT3+O1OkFuZyJvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQ4+ffdDm82xMLiL6uPsExyMOKsUDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABNV1XUC4Lq3688UmLd4wzMbJsk/7jxdCry9FQOh/\nezrn1h5xbj3DKWIAKR/oj3Z0EftbmBBEYT2lqAWEIPAXXzSjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDpcHb9eRbw\nkFUK5Vdy+sXNS1NKi9YVrIQQktPicv26OQIgMb/SWO7e27/W8hgvkyxGcviMkdcc\nr8PYP1CGGv+kcWM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQtO8BqRWdk7EFNJ8pOutRskflKADAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABAsaezdfpcyGNF+/k08Bfo5o8MCL3QLUTLJNlMdW\nvHHr/wmdNKZBfU4KzJI6cwJeSJOwn8wXE+/jVe3UreKuSyijIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIGvjwwqSuwht\nE5F41174HxKmFy2CZK9V9WS4yeMEFyjCAiEA8gx4Twi91gJJsYz5olhTvtF7dUKB\nHDccFOPMm+PHYTM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQH4LTxbnhScYwlOeD9RBWGjmXwkDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABMUz3avY3MrkOQnH6ylgdvCUAEY/LUDFI4/IW2ip\nLQruJb8BmpPyCgH5HOJS8w8cvaIkdNFh5meTYaVFX3yskfWjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCNNmi3r7dK\nHWGX0778n63y72sbr8Ca/IWbQmq6tcjH6wIgRkjAbadi1mCYlTDI3NjNbG6SAlJR\nyPqBkvKyuG+QEMs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQEk7qHiMyVICF5xZNhzlwttS1M7TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABNxr40jtEj4UKjPGkD5cKART9W9Z2HhAzpSbZ9ua\nbqDTQ6l5V1IAFVkF3+FTI8t6SZR67wOIHEX/kGD7OhGdUDqjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIBeTkNy6ZfKI\nC6REWQbNZWtGshJ7n0ECb7QWSoiszW3eAiEAuW/dxCiMAjzJs2O2JPfVJv3wjP9K\ngtUc5xm8pJpwZx8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRIOfclEF5xlrreb4aeKJ8+J0qREDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABPL/77QSllSYzzqxo29MrhCFQ9GNxOjxLXOFF97Z\n0P+pWtoIP8t385kdF8NWpkBedw2MsJvU+DF18KgnN8vpAkGjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCv10D7KB3H\nlrXXdoztxinjtveOtex1Oebx4x+YehyFJAIgVscBQVOlw1GueaRqX2il9Q/H+ZV3\nYS8ISWekkAKFgq4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQd6UcAEHHy4UiDzfs6StBMhnhQuzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABIliKBMkBrbkMVbJeZV2jqF8q3cfTDFw7aSMDGSN\nufH10vu7yL5fWJevzhySMdQ+DyZKP7/KSQgeK7cDqBdVO+yjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIDLQr77edecV\nwxUNQVoeMIjta76mElHswWFRMg9Z3loEAiA3ntQPkSURz4BtPXIpJNaalicU8pca\nue4puxsp2xerSw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQonhiEADqY/JVIXelAcaH4cHLiOTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABP0Ri62jnBc8C52pq6AgvDFQYwr5/H4haktRjIqU\niX2NkOnKvO8uk5O7RUMX7HKGdjnlu7kK4wmASodhbr1LfA+jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDPTMJdWZrd\nxSCUmWfn/17JxsFcLyHwaRuRzLJdip6EwwIgaJqBHPwuj7DoCfsF/KRuUuV3Bisz\nSo1VjMrZj03LM4k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQhWXNHgKIHVitP14Wn9UYSmD+81TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABLHyAh76uJC/K2Ro1UoLFbV+BSZ1E41uWWENqYje\ncugUJGQtbjrigFPM6DN77/x36V3An0rSPD6E6Ht0xkNKe/yjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCGNIKA+ykU\npTF+A/mMQkI/mltoguWukHEcr+XArH3o3AIgLbzHVZpNctt6BGC7T2LXsyqdZMre\nRsEaG2VwuxmS7BY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQTLAJbOCnzoe/4HIN7P1Fepmu7LDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABAJqkukFA6/aqSo4KtD9mo79L2xdDht5d4BRNmXk\n4K+G4aLcNq/fUgD2stk8GDMG2iJkqsR77CFtJ5ryx8wAcD6jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIA3zHYvEtwsc\nyLGu7jtWErmNRoWVn+pF8FnU/AjYoINvAiEAm0EhsrNCjhC2ZAJUKf4CmKPmJEso\n+DKCFWvOaFLI7wo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRRHqCkjnReqM89M1hnNTE2ZVJSKzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABJGqW6cOIJD8YQXjWMzFSNP9Pxz5lUhElSdKKaN7\nzUafswA7jjbtzMTerSNqSgmt4a2sqRjAfqSBrQiv6wv4mTWjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIGQY8JbvDzff\nWqHJR2tgp7f/iSQF0S9KFkFYdyUXIJIuAiEA7fCdQMr1KpKR9+rAQcWDiOANyEim\nlDtJkLmhBVns6U8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhReb6KL1wyrY4sF8F+IVR6u53P/CjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABDzUWLgChp/If7OowoV4M9jnBTto2ah8vrJONOW1\ngJLrei/IAEamOCxYjwITWMNoc6QCw6YFymf/prMz2l56JTmjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQD4NgA4lBAk\nPnoAYIEFXgkt7dY77wKssdUSjbTXDGJvPgIhAMkg40gNFMFcvxREO1xq5pw7If9R\nyC6mGWhiynuflG5Y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRNQW53tQDcU+lEJmCMuSjjQo08ODAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABJdM4XpLM8PL79VHFRzoEuqkvNYa2XoD/oA6JI5H\ntCgZXLQ6CJ3Fw9Wx+ZlUsHpANhHkxMT/aBZc9P8JeJGhovujIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCAkobloCbs\na169ph5VEQEDbXfenEddl/g4JOmpyP8npAIhAJsmdd0UIuBot4FJ3auZCEfJWaKC\n/iR3qZozS/siMh+5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQRcebApnC5v4X4/brQiWcU6bov8TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABD28SHr59L/VrJnanftmy4IGxc4pW8QI4vNUvTDE\ndgpuHOfNqqGwNAI3xhAZh6jftBrlNwxkFhnO3Mjp36SWYpqjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCV4/nvCWcx\nMFxCNrjnDjP77lXcpnxU8yLAGtbDlKx3bQIgG8om0SbSx49xsT0pTrhwlvwoPF/0\nFtqbNr09FsRuLKg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQxvOFdxC+QT4eT8Dqqq+4wR49ipzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABH+TKpZLsMmSLVDKmumYtDAJGj49pgqCIl60rcJV\nOctiwoQJ8Eo71H4kahd6LEkKqSFd4+kE6SFeBH/YRvlu9ISjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDo/Q/1RSPS\nE71zFOmyjZZtzh//UoJIqhfU4C/QsI0o1AIhAI91b33bd7DXe6USrkO72azw5itK\nUJonh8qR/CisQjvQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQuErYS/lXckXR2D+FH/5nfljpocDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABMDEGgqSKc/HSCR87IjYSTWz7TtA3XIoZcS5M++q\nQFOnJzal5HVcGtFLHaW9sDuCUQGI69EvlpNZyaKDtNSlsa6jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCSVKWcQP5f\n3czrky2tV2G4uAdUcEShzmuwr2hfgY0ilAIgGhJRVJJuSmbrPoNeHAhl8MJGrCgF\ndCIOnifXCKaJVow=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRvaYnkezgcBrR7NkFmRvMnnbnFHjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABKRbCEJKN6VoJDfKa3zKWsgr5J/fSNUwYLSTcm3d\nfFdH1cDrwwWyHkU31aDBPFoAxAmXaMOe5UXkaVdgPuQ9YQqjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIBP5aoAdreEy\nKihnQfvuGGpjVAzd0s9a7hEBJ9lAm4iTAiEAzkjRyxO+B0Rgp8xsjJ/xj9OZ9Rpv\nkPIx7I1CGQTKvq0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRUiyDW571danBrutvp/4UY/xHicDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABEyh2zXkK9FV5gBFLI6KcyhGgXHf8Y5vIZMbtvXA\nieoOZpPfovMgprB0wSaW495BnjiNIptfnpp6q+pj7onKK0GjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIHx18RkLCkW/\n9O2IKin9LhsttyR5LRqIrVXJxi6wwcjbAiEA4YklGZJ6cgZYA4CJbzPgy4qkU23d\noi/XfWPINFlZCOQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQWWQ/T2FLs896OqaEzz9zsmKFqyzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABF2GRIspQR+tSYpzrHqiYYOim7tT3gp1bXOxxz1R\nxq5fD0yWNmCeabSEeNnZ8OGpg1MbRwJ+BNQS4ZE5p8CTBTyjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDA8an8mkkU\nT027t7D8IBGQy80A3Jvtdu/5TABJRB9pPAIgMwB7HTVrmoKm6doPljbulx+uAdyH\nYIQJN3wgg/luw8U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQWgrV/mAgmbfQtTY7UXJccjrYtuzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABAORY0h8zWMp/IIOwrRZFGWk26EMA22cHqPH5kP0\nYCbRdx33+m8+vJmUsjji+d/x1KaoNwAw5hKzmAOvmsjFajijIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIFmJKtnY+CDi\n1oiqwfHJLPgGryWZjLLZe+5z1Y+IIUjuAiAnYEOQH35faIC3xJ6VH3q3p+9OU0dQ\nwSgq04pvGiq2QQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQaK/6+r+kSAiyLxsVMJuhQdFoIrTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABH1BzMvjletSRNn15G6f3x6cDRRtxMoRwD2JSiYe\nmyC/CHfkEcBkQbk3a1WWoDPVwUh31oGvVVigvaL3G23lPwKjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCID2UwU2yFIS5\nEgntL1pI8Hf/Hs0qp5WPfUYcIMCGfCwpAiEAtvokZXWAmlnET3eA+Jt6HuJC4cnG\nOKC0fQb6ODE4vbo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQGOd9TmuEgu+oQgpFAZBXar63erTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABHdxBgnsnD7qqBuOPotpDo8Z/dr4pD0VBorgubGs\nucu9jKvovnO/DuzRXRsg2f/e0vt7u257VilzGXedHaYtqYOjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCih+shx93H\n/jJmGg1EdcJ0Eo8MakGs0wPr1oSPPH1GLQIgJNIuVcEsZJcN3qIdeDVbkaZI21u+\n6zM6fFsgB30fOK8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQcaswc5xdzWC6AsjZcGrmV6qJgGjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABMZFNOzU6KMOGXsCrh1q36ny94o4YSZDP6deL92a\nNzdHL5t3P4cm5MLanf7FTBGZa1OGHjDTvqQAKeO4IgRu/aCjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDUu+c6o1DE\n2zxa1Kn+L5Ib16W3HT3ZCxquM/o4+UdPNwIhAPI2ZEVz7zhxD7qlcQ2PY1xeTsU9\nLTGxxvzPf/TBq9PT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQFUqM4QcfHRNImjj7pwVDgRtuWXTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABFm8815oRHMCM1lkiyrJQSQYk2cGwfxEJW5ByTxT\nfTUJyU/MujRXrECdUAJ3fH7ve8Vduw1QpeXoHzfmNu8PwNmjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIEAFEDjxj95f\nQWvMvziFwC2Cr5EDhs6tYsX4a6ZbsogJAiA/5HUTxAuU5jzLwVjXbmTypCxwxExc\nCwlSBv5hmJeOAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhR3wkCUV/Rnppb9ZI3ll5jMnVcc7jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABDIlE1kHXDS6wP2TvN5B2FA0VYWvqadh87RVNx73\nOqyvRq1LXu9GeFoawHmA8k0i8weGlUkpoMY6mo5TTgmobtGjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIE5HV95+gIgn\n3v20U7ROUgQnT+Fy92VHlEQfOoSKYe1rAiBj6CifsA6gMqkoXyPyi+wFpFVpscfE\naCRw6PzsjpjhjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQSxXPZv3sid8gA96yGOCngV+stAzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABAxw1K/9G7+dedezYIhtz+Tc0Dli1ZztF2q+L/Hw\nGoc9kMBtL9+HBs+x24/FTB3gHMwrkx22NgEd04/zLPJlbDmjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCICa/Q80uri1b\nx5eRis937ZlOLw8B1VOe7b7nu0Ez3eldAiBLPv62j/YBfx8NU1XKcoxq6TfFnA+5\nvPKw8y3Hx0dFuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhROQcEAgpWYxx/bHZkywXrh2l5cpDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABN7oaChZ67jhQMlf0EShwo6Rs/WQ6lK9KTE6NVmE\nF5F+XDXMONyAe2kpIrW9xtU9VakN3EinuWzeCrJ327QaX2OjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDlUQEvjXqR\nUEd8/BxS2dD5wSIBf9gcI9vNJKDA0cGgDwIgZieuiCu0GViyPYsMajwFJYO1afdl\neetMiYwUns5zzpg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRexIxkDO5FYXOi+0JNHj8HWH8REjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABI1cjdB42JyA48h/R2dzQaGq1Pcsj3VudlYZJGhq\neWWy8L/T9aQji59KR9arXBgcj/Oo56xgmWF5VGXq2Js31POjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIGkBtRib7HvG\nZlj5Aet/NspxaVFQrkSPOITQHfjhuV5QAiEA/7OiGltLXDDyizRxvwFc4bXW0jnK\nGKaONnZGaGk9JKE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRwnHF16afbuS1gaQPt1AcW4FlAhTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABMtnh2ZRt3wmD9iNOf9C9yK7cdsTiAGDao2cFb6q\nxYg9tWf7rrPEvn1cTdxEs2KgmGDeqdgQ86EfTcl0KMGmoBmjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQC4UpkoqWg0\neqggYwMUzSiw5Vv+B1IkuAhwei9ub1i5xwIgFzCOKdYS6T+VD4LkyQQ1s3OhMTOD\nMxQJR2+oyKKJ7gE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRwXGasCxbGdLaGotoy66UKvnAlYTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABFxP2jviLWpr0V19rC/NNmAs2I5LtAgyy7iOY3ET\nup7pFHHrGPnkU305j/y+FpWqd/MXTPiDaEI9DGo7/ebGvBujIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDxkAwHag3f\nO/d2A34EGYlOc+NGXBWBnJsTx2Jobwi4DQIgAO49IhG3cgBvvB046xcAmlYqXnHA\njQO76jkpxmIGMc0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRK+8uajy5ZMu3A5GIGtMLV7K8LazAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABOn/+zGDH5WJ2DGcdgGyODVEm8HYb9RfKPljH4OC\nXXex8Rqq6qYmQShjb39/6RNRFGLHZbwyZUPLJTaUNqYVVtujIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIDGbKkEDCWD4\nCMLCUtm/Qu41hQx8+rnkYRInCqJhGs1SAiEAmXvu7Xe6D4dCrKuam/WIbiuVX/uo\nQfXOGgQpNJ6O/nU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRUK89THaWTmiOphDw2Ges8KqMG7TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABMhK3rMfLCRyhWrSoWFxNc1zQ+BmYaG/Mw4EzeIT\nrm1zYH32QVS9MmTGpVDdVrotTFrRG+BncvoYe41YX7vmfWWjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIAp1zQov0G7E\nWjyhwbFmekcRUfEoifcFzfN6sxeMi95OAiB0VdwnPnAaBm/+Ng1wPPxgX8MthIL5\nWENEtUAwuWJoxA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQ8ihh07EAIS9NWc7BUpDNb5zuMhjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABJbrSU8AFch3imMHQHfQaxBFyK/UbUeJx0dVcirR\nSNmtS2/noz7aJbM6RqjMGt119bAG1ptC26vMnEPu59PjH1ajIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCCtJZbXwN+\nRiNjy9tVhyQ2qfmQrhrNhaGiVHPONa5FBgIhAP6Ebj1HkYJx5GgNji5vsUPG+70k\nxzmN4DeORW9MhE0h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQNfmZ8hJRygPQyfDZ34CqXXqXElDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABGopiBaa09W1NhMX21AIbjisJWCVlMtkr5W0JSR8\nENR5CprQ66fQ3AAa5/rUJSPJKHxBZVGkoi2WKIj4uLB6RHWjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDIdb4SPuZA\nMRg91HVDN17Yq5I8oabTVkawN2c4av7giAIgHmNypcGN+Ge2JoRED+HQjkI+g7pr\njR4qy/UGpmRBO6w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQEAsfcvdXmT90tds6F7MZt2hoTQzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABL6w2aCQ0QPJqiBQfob6KGB6nyKdMJB6le6n275z\nmD5LwUFPoOs2DC31jGeHdAROnFr3O6HIeRkuHhRJyoUoRR2jIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQD+jYlgmI1K\nTwgBOSB2b/Ndzq6bweP5dxuYw8hwcoHLPQIgSIe+Dy1yvXX+MohXPDNyWpwydYvQ\nH8vrA1pt/gl4fno=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQ2DEbVLmApS/M3vWhCTtWWN+/WvjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABMXs53V4QK7dtHrugW1brnyiqRRo8LRzYuYRlE+L\nn77CqY67HK1F1ejImdN+jghwq9qDfBzY2JxqVUGs/FD1VkGjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIC70K38MqPAN\nshR/xGKEnJ8ECO3u1NTCodSToTd1sH8cAiABZP38GjeuRQh0NTfpiuy448BOABa4\npwvxpMuq6XXg0Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRaLg0ua+QAklcq9vZqGIYrAp5M3jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABGTd+G19lP0FWpgT4Utk+We+l3ZjD6cX7XWae5cl\nUoGJKJITxulM2ELpDgSOG3wUnx9MG7dszoydnh/tjkQlSaKjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDySyZ8Tew7\nYO9KM9A/ZiFxvSaXvMTUpXAKtqSvPKPwuAIhAP4DQZuez6I6Qvmfr6uWVRXLyQPG\nXIYz/2OoSvbVvF3+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQifwy1d53hFq2cQLhesQM0wrzT1DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABENTD1uHEW/6HBZohikvLtYcxWrsoxkUtc2nbB/b\ngKQqmUNHSeoH9x+t3MpZYiSamVp8hKZVx6dlICEGs2ej8NijIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIAvokeAFOizI\n58CrJDFFXOHJtFzr24aFYPmXuYmYKzSAAiAOLFwka/jwrjS+aE/sKjJDoe9Y/GQ6\niexoI4eJMdnHtg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRAruMH8yb/kMC1WuhjTmTDyJxvPjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABEW8vaHSoDs7l5YphyM/TT2mJWbkA7cgBnBZTcBo\nSR5jgcBknnHbI+cGu89Q1oFMOZaL/92+mEUrtkV6CtajfmOjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQD9FIZLv17s\nrW1aZ18v9lb2GtZsYc/AICX0sdCmeO+2nwIgFh6GVJ9bqrLMtHrg4Y0LKXfznVfc\n9W8qlEA2pYbL924=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQ6JH6dNkEHVNZug9QTjKMtAKTUkTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABBgDdosfiJAmLR+qdDV4FlJINYxOHwPDPHvmjvke\nEkcTshBSuVPcS75UcF4J/kpOjMLwcLnNLCFcB/zzGgaZSRqjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCnEy7rZMTQ\nbDZsXE9MatDkA49ysk+xgZ7C869e95DdZAIhAOveKVkmnWr6+jaXl8WAiHPs7MKO\na+iv5iWGwsqoaFgv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhR5mSdTORroX9esEw1OFO9nP13+yzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABIB9BcCzkkQzqeEOOnzQ07Vqbe8p6j7JA+G0H4Qt\nkF1NbuS7J0BQHOgYsXoTlYCmO2BE9yCmhlSKU+6ZKWwBBryjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIHsn5CdaOPIK\nM0UDJjK6t+foB1ZRFJ+s5zQCurQp1FPBAiBMsqENtT9nNqGDU8GnICWu+5+Z+C1X\n27rdRY1zRSC/SA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQVLtWFcRoUowHfZmej1Vr+lblcdjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABNReIVz5ITmjSZLYgy/Fb+MwsMMujp+rTcFh2AE1\nlliIO00pelo6+/un0QIoDGRmm8wtwfNaKbvLJY8ZYjzpa0OjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIExR2VincVu6\n67k2IuL7Vo4QqLbhGFT0mGPOdatHilPNAiEA2YzRrphJuQHQ51c5T/jhWmuWH3jU\noW7NOufoG0zssDo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRzVm2+O9xe2V88YtI5sTQFzK3DwjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABBLCsyMkmEGBqfJncFl89AXWImBCroEUcVNaNIp3\nhZMp2fsVBt0k5m/8g3lnXBflCq3ebftYkI2eVRmlIXeVnaCjIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQD8Fut9BGYg\nOmjJNnQ/BOGHwywWlGt+YGVmYvNywGLOvgIhAMSeZEJOeHNSk5+EiktdFumGQ0ns\npuRgyBHFcpqdSJWA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUX41yT2ZLq7aNgUf9/OGU+rZyvZUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPUGF0aG9sb2dpY2FsIENBMCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABHEeyLGO5b2BD/lYvNaYsbSb41hy+BJtdVc0eAU/hSUQ\ne5WBuGYLOxi3ugX3mYAgLAfBf8FuiHj1MCharj/aNoejfDB6MB0GA1UdDgQWBBQI\n6uikv8VnxTqPcBAfU8xxOleL7DAfBgNVHSMEGDAWgBTT1d9Fg5TNmtYwHN1iohQH\ndlmClTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgKxJx62QDxuYeQ0xNS/9U\nSCJLKp/Z1mRxDFZMtpmhnWACIFcgnuUHdh4E7ERzT6+bpM9IDms8JUovNsasOd4P\nLF5c\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIOhq9PhA/40zv8L7eLKDSYpK3w9a+gnokUdBVN37M8WFoAoGCCqGSM49\nAwEHoUQDQgAEcR7IsY7lvYEP+Vi81pixtJvjWHL4Em11VzR4BT+FJRB7lYG4Zgs7\nGLe6BfeZgCAsB8F/wW6IePUwKFquP9o2hw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathological::pathological-chain-distinct-subject-same-key", + "conflicts_with": [], + "features": [ + "denial-of-service" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nICA #0 (self-signed) <- ICA #1 <- ... <- ICA #99 <- EE\n```\n\nA chain of 100 intermediate CAs that each have a distinct subject but all\nshare a single key, none of which chain up to a trusted root. No valid chain\ncan be built.\n\nBecause every intermediate shares a key, each intermediate's signature\nverifies against every other intermediate's public key, exercising the\npathological behavior described in Go's `TestPathologicalChains`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIURtICO4DgXFt6HQopJDlLFfmwtsgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR4VB22nA7wAtziQZESIF+4DfJf+VmC0I2a0CAR\nGCZa1yfSX8eZ+yfDc9H/NkiWoAnAcRIZVKCH0Wly4kS1f7YNo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUShsukYvOeF0n5FwAXm30YBc1WXAwCgYIKoZIzj0EAwIDSAAwRQIg\nLDAgu4c4GKxodB117VPHFPJEjD9FFNscck7bJRUsL50CIQDnFW8nXmbDlMONxjgd\n0eEt+P9IwZGtmGEqwruwxfAeZQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUNekHbwDclT9UPEreOk0LpeapuTYwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICMwMCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzAw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUsc2WFBnxp2k+1Af+m+WPPY83xki0\n5M+toAUwwiZZws9AYo9PU6rS2w/R5K60vCUOHQraPAvGovJGWfQYviGQoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAKBggqhkjOPQQDAgNIADBFAiAh\nO49G4+1N4DvdXuAoTsNfzMAdyuOzUsfhc7/ea75PkAIhAKEZIGoVgrg+oHLqiFZD\nvla9hMDqhN1nMn6k3siT3RHh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQSgAwIBAgIUXvVu/xLDaBC/v7u8eu6xgmGXFeYwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICMwMCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzEw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUsc2WFBnxp2k+1Af+m+WPPY83xki0\n5M+toAUwwiZZws9AYo9PU6rS2w/R5K60vCUOHQraPAvGovJGWfQYviGQoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNJADBGAiEA\n1SdolKwKzAWzHY1IYstyZ8NJnkWOL8HPcFG7BF4maUACIQCGZ0hE+H108Elw7VVH\n2NuBi7MBH6F91BxhwzE2r1l8PQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUGc9qLX+KSVhCks3ZrJIeJpkeWvwwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICMxMCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzIw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUsc2WFBnxp2k+1Af+m+WPPY83xki0\n5M+toAUwwiZZws9AYo9PU6rS2w/R5K60vCUOHQraPAvGovJGWfQYviGQoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNIADBFAiEA\n0dCxTjKtY8sbPvEQrdvhVSlUU/Tn1pU8/rM4UGh+nNUCIAebobvEKDhzkXgYp+qh\n007mYyC7cWkU0EX4ET66c4z6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUfOb7L+fQXY6qShIhd9ydFTHGzeowCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICMyMCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzMw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUsc2WFBnxp2k+1Af+m+WPPY83xki0\n5M+toAUwwiZZws9AYo9PU6rS2w/R5K60vCUOHQraPAvGovJGWfQYviGQoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNIADBFAiAh\n8Csj2j0JJqe2YCuyE83kblxxFzTYXwlLYL4BDjBe7wIhAPqinbSaGCvUGqQ7GBq/\nA23x9UPmYiTohjjlL+J7N2Uj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUXJzv1XrRRifcrHC98YHDuFYMNTAwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICMzMCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzQw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUsc2WFBnxp2k+1Af+m+WPPY83xki0\n5M+toAUwwiZZws9AYo9PU6rS2w/R5K60vCUOHQraPAvGovJGWfQYviGQoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNIADBFAiBA\npILSHw1WmRSrc1T3tYRG0f/jSnTBR1CC3tkUThc1SgIhANw4QSJHfiVTy7ylFVLN\nXnZcKMOsm3rqfOg7Ba8x5HYH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXTCCAQSgAwIBAgIUQoD7gFICfxU5Hw55IBJkGL2PVbAwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM0MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzUw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUsc2WFBnxp2k+1Af+m+WPPY83xki0\n5M+toAUwwiZZws9AYo9PU6rS2w/R5K60vCUOHQraPAvGovJGWfQYviGQoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNHADBEAiAf\nG69ZS7IDja9GxsV9+5a5kJpcKY6SyNpObKkCD9TIsAIgT4JCet7+bWz8zvDb+uS/\nF7+ec1QfAQiw6dh85EZsQeg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQSgAwIBAgIUTjy6UqzQx2v/T2sNoYuULaJpyuQwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM1MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzYw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUsc2WFBnxp2k+1Af+m+WPPY83xki0\n5M+toAUwwiZZws9AYo9PU6rS2w/R5K60vCUOHQraPAvGovJGWfQYviGQoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNJADBGAiEA\nntpiryNjhxHG7f5eD9sm8OgeiQM6zJV//cfuLZ4/k6YCIQCyTeY1bqkotVkxDwx1\nz1VpE6QOza2omYu3ujmYonqCOw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQSgAwIBAgIUZ3BiUFnF/5siZec+VVEE0mTLX1AwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM2MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzcw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUsc2WFBnxp2k+1Af+m+WPPY83xki0\n5M+toAUwwiZZws9AYo9PU6rS2w/R5K60vCUOHQraPAvGovJGWfQYviGQoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNIADBFAiEA\nrV7sev2HfbLbp9CUL/U2rwvdIruk2fXT+jPYuqzRI0gCIA4wClj6kF8wWZuSn6Wg\nOqvFQ8rj/SMc2DtnRSCo3uxM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXTCCAQSgAwIBAgIUJAzgXlDGVhP0vEZBCznvqlNzxL0wCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM3MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzgw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUsc2WFBnxp2k+1Af+m+WPPY83xki0\n5M+toAUwwiZZws9AYo9PU6rS2w/R5K60vCUOHQraPAvGovJGWfQYviGQoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNHADBEAiA5\noxx1A2pF9wl6zha17ivfVoITa21j4QdwMO0Ni9pxZwIgfEzWYo/kuO/5ihJt0sUC\nXr4ng5W7kQ1sPFlFd2y8voo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXTCCAQSgAwIBAgIUNpKlgP/ALh2uJ6uO9nwY8P4YwzYwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM4MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAdMRswGQYDVQQDDBJQYXRob2xvZ2ljYWwgQ0EgIzkw\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUsc2WFBnxp2k+1Af+m+WPPY83xki0\n5M+toAUwwiZZws9AYo9PU6rS2w/R5K60vCUOHQraPAvGovJGWfQYviGQoyAwHjAP\nBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAKBggqhkjOPQQDAgNHADBEAiA7\ncrJi5fZd9b0XUl7/papBNsQcCEMGDW8LPh77xmeNZQIgfGgMwRntzSAFIfdAFmO9\nF4aqqnm9V07kxpZErVJvY1M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXjCCAQWgAwIBAgIUB80Qap+KbNjZOr7dqu5TDi4aNnYwCgYIKoZIzj0EAwIw\nHTEbMBkGA1UEAwwSUGF0aG9sb2dpY2FsIENBICM5MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAeMRwwGgYDVQQDDBNQYXRob2xvZ2ljYWwgQ0EgIzEw\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVLHNlhQZ8adpPtQH/pvljz2PN8ZI\ntOTPraAFMMImWcLPQGKPT1Oq0tsP0eSutLwlDh0K2jwLxqLyRln0GL4hkKMgMB4w\nDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8EBAMCAgQwCgYIKoZIzj0EAwIDRwAwRAIg\nObozdrhKSsOevybf44tG6dwfrUMrP/vrk1A+u1oS3S4CIELp+YJXa33utIHiY32s\nwdI0ufxfQ10subxeL4P+kkRM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUG4eGotBCW9+8grq78SfDy1vNl8owCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxMDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDjNGalEQM66OPCwvawaUvs+wD9/IPb93hzG9cpGDsrTAIgd3xMcuFvLoHejhAL\n9Obw8niDh5aHXyOVmxWZNH4titM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUUjllEy+RBM/HtbJnu6QF56w/Yl4wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxMTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIA6vXNBlKPSd9ZnzePnBdDkIQepOd5Y2DuNLGkurPbL5AiEA1JfP0Axx/w9ianZy\nQuE+QN4i72wpIkFhx5XEa83+zSo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUPEWzWgRFsdQAo81rwlTntDuhA9MwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxMjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIF2r9a54F7j9MYmRWoZL4lzdZTfnt++mAUrqjpnZ9RKNAiAcWPIiRZAdIet3XEFf\nRkI4Use8/4SQYmpe7clwC+gLSw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUUVaDUam+Tp4o4flOZ113VtYha1wwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxMzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDnTpiVKpVgZK7sNygnsUhu5dRGy9CypffY+6aAsR/77AIhANa77j5aZKZ72vD2\nEEU6THzsolJueTWKva5ldwXOR5wD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUUH+ItMNrJwbX0alvy6OEZ+75noowCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxNDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQC3JZtM/z4SuevwDQx+Qe4MgVaZCdyx/rxCxVY1jmbzKwIgLeMFUMrC+BOlgok4\ntWVKtUqSfiSpMMkEINlf6OI5e40=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUZldDBysM98MVXjXUk3mktfw7pfMwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxNTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIA8s3ggebHDCcvRqjTjyOTLg3v6cwkZoF/7S6PlrFA2AAiAx4G9sNCQItOmanV/f\nPdywprhXwuYCt32e0+aHGajI1w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUGl4/coXMZVoiFXDMk7zhTwJSs2gwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxNjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDUVkGPcJPWLjmynU/vi9VRUF1DmG3RrownxNxKynn5kwIgVls9PkIdiiDNimqp\nmP8oKR1strUE6A8/FIU4fmhzr+k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUHQE6tXPsMKTl3HaG7bKDssdk+58wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxNzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCRi//Oz/o9XogvR8lcSKbNZgOVakckAoJfC0VOgsDcuwIhAJ9B4g3Kj4Zv1y/S\nelwBVy/b6YlZuo6yRVzoM0boshJi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUDfyliM5ImJxNigrFThgQUAfzIpgwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMx\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIHfHLFO+hCg7/KAinsWaYKcuWDab2xvduiYH3yO/I/1HAiEA+7cs4GjzsjTM/WrJ\n5qLHwO3VHkU/7GBxWN6CtGyM47w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUAQzYmvYY8K9tNRT4UClDIpTPUqEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMxOTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIGo3zHmaSGN7HAhiXc62f5JHTrZA9Z1lhzPcQHyh85WYAiEAxzxVP/R24Y3HcuSh\nHNLt0nswYJ3S7xkWpiiaZxDwLNg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUfAGjL6WzLKrQyeuOfI92/lZ6X0swCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyMDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIGqOkLuFZ7w66rniOfx8ZN4NKJQCXnsXEIoNm6hrMjCtAiB6gvUO7Kjznr2Z+0H1\nmeKSK2D67uqWopQKUHVpyLUP+w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUGZrhos+cxK6Qvbic6ln7XaePHm8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyMTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCS5hD32OhdVO0kEa2BVug9Sej0eITNO69MCHleXhPO9AIgILALCLsDQOZddtuy\ns0A6pOMsFsjE3DoA5Tc26AnPmq4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUX11V+D3q0/+niDM0LojyCg2oeOMwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyMjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCTouEeAgmKq9mNvfBL+3vIlabw5rn6WtPon9LbTewwPQIgdA6zgzfj33MfI1dn\ngrozTrine5O70vKGT9Jbbyk0e1c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIURVmX01InJJ1u8SUYXhF2CoXIRbMwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyMzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIFrx3hw7OeIT9QSulwtVRZLzqZKJFe0TfAWS5SaM6TWfAiAcowKyWmpaju/PHw68\n+qok7FnUUM7HVISUpxK2qEBVTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUUPtZTvBUuvUM1zk4tl/+kdvG05YwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyNDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQC5S5CxxQ63IDPv4XWwdAK0XSWVchavs6rt96TSlqucMAIhAPPHwSYfMggCFYMY\nR/FlWOQrhkWeVzSbNONQsvezJ0FK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUFG/V1bRbvt6L/Iy+qZRnVedlCwYwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyNTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIExdCjWG4wncjGLlUgku8L2r+Ys0dF2PhUoxa/VbKFpLAiAQ+R1GKS2ee64Vd9AA\nE/Zc4CvXZTkpk1wEmkyNft+A3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUS0eg/Ja7w0zy1TsLMuoQ4Jjz0rswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyNjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIGAoGMdsHd9TdLG9pppFN++Ij+hZbOvDrPJCjGN4KE+jAiEAh1QRjNJjEojcEIx7\nDT14o6KV27ypgsbEmH4WkNW/yEA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUPh5Scvs4M+soxwvWYDF6dihozbswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyNzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDC4YbTw0bRcU/oLFzX3pDJSqmywl5OVeN9TsKtlfzwvQIgYcE4dY24dOZesLI0\na0xBWWzJCsPS080ON3oOPLygtw0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUKpR4GPiITJDGuwFWb/VkVMlitC8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMy\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIH58MDWWr2GuYG+EKrAE/yalwBZPqot2ab6u0SFTRrpBAiA4aJdJHj7SdHO0DFMl\n62rj8atXma/16HDY5SDGDxNetA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUf7JfqCzdWS/oG/0RLUG5SXEzRWAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMyOTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIAdgGZ0mEcHTjXOS0vyyAm5A9EGte5YSlgcy140uMwugAiEA+X0eNaqPoxOmmQc1\nYQB6HYho5e8G2dGV8rmnNB1g8OE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUeXFtEY6UDr8H2IydxkmtrAPPoHEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzMDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIAGQaIIUqvHOTb6lFU24R/3F1BC+2oYUKj+UI0RLb9YJAiBvrmmSDDNuVYwiuxe4\nNxymXfYUvNBaEgedDrXuhjNpWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUZVe3vUT0OTfzIeBf2yoo6DJUuyEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzMTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCBnzL+3SBUAGtPzAtt3jRfD1NdSpVV9LLVR8yjUlzXdwIhAP4bDBbkz7Y7UXzX\ngO7VeI/iTiFOOasOHXXQWnvTCaJp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUDwPapgGEAneIeD+kUoXDfZz/PdcwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzMjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCF0HYDm3WnyyRL/L4G+uX1k0LvxtI0f394eQlOPQx/nQIgIF/Qu9PbFcSLXiTO\nQDijRfp6oayadQ9bl30929Fz8Aw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIULTPxP9mYd7v/2bYeMuCv7WO+52QwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzMzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCjblmdWpin5UVrz7K4+ZaMDCBYWDa/6IC14GqmpjNf9AIgVyooRIWFFJ93TB0L\nVowAO54eEnTzudt1JUPA6wGXaTs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUL6Tk9wTcjzdorq16XhlYsZGWDSYwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzNDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIHwvP7+TWnHI6U4VTJFiJxRNpNLC+fD7ZByWJ+UEGWuKAiBY4RfUlSGQ2prfzs+w\nSVf/d7S9fmbxAEPPUlH/GUmH9A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUVI47IoZ+7yl/UEF6Vmsg19gFN+8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzNTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQD+PwmM7MV1z8fmjQKb3zG3p5dRa0smepbZLhjAgGAs4AIhANI5mLpbFz6rV17T\ngGNFHZHu0mCjXRG4f0DWPJng6du1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUWVQ1+gzGgnGUDU6Ys1uv2ipQi30wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzNjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDUGBuqc7/bqvNCNWVDmQl8nskRIQ02xVhmhkINCutWtQIhAJspyAa+p0E9WCfd\n9HlDLBfMBZywf05fOCzQ1IIqsOqH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUIdBaxrIxe4nL/lq3w6uXHyg/lj8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzNzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIFEVR0fL363YdS7yGMIO7ESwiYGE6kABwShsH6Dak2tHAiBav4wVwFIucIw+f4Ke\nIV+U/NCGsfqSbu24wuey/pqkKw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUENEtbYaODwxjrjKoV5eWrGkqGa0wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMz\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIEKWWJ1iDQSLT0A90O5Pgs+Q8XIxdwAdAwjZjYqKWCPBAiBTEmaEAXJ9q9ojw5hc\nJCiF+p0E5DS64DfvyN3DEhjnqQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUdAjs/8ij8IzYzaFFzh22vp/lg9YwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICMzOTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCo0UMp7/oWJuxb624k4VVun155MU3XR9qU9v6AaM/+sAIgYq7vFYEQG+GaFL9j\ncVogj4gBYtW+atATQqTKQu72dWg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUFxvRwfP/rYNlQ9rq0fwWwiuDmd8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCOuzTgd03znW2GpLq+tdFZ8xdtxJcTzE/O37LmbZ+rYwIhAO8XvIRWNGhhl/K/\noOG5fj3ttI0h8ry6P0JGQa28Ox05\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUcUSZNVSicD85rZglsoQ/c1JXDVAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCingGJ6Tu1KLhM4zjScHj1A56vGRALdxIsDgDw2dhD+QIhAKwN/XFhCwd1ljSU\nVBm/f4v+B5MTj2QyeC8BOwpIDS7e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUPNmHQn30xsStD4d/Y7zUH4sS7GkwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIEuNkS3UWcULkW3FW7pEDsMcQGDij6Q8OkgqSgJgSwySAiEAsU2pnlDJQYkva/xJ\nAvfDBln4fmYVAx2z/BYgBRFcszY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUJl6OZHBkhcqFtfTtX2sUdUXhdSMwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIAla0JSR8mp0AyLWDUd27mpx+qfXEIkncG6KqEJgjOFcAiEA2GUV7+GNAk+othti\nrANd0kUn90p2dOuO3INq0aObyEU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUU2AtXTqStaKqa7ZL/rs1aX6KZGEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCUHch8eokMGrhjvsEwDdr6lCClg4wrpuA96GCjd8w1CQIhAI2RHRt8HQp2koWi\nbKfIXTaCyg5Lehmm3eZ6xuh0x/dX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUQXlsDA8ULL1H/kips9cePPu6kzUwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDF0w5BDZg0ZsUn+QMg0qZ/rdY3jaGfmE5nX6A2pxiB9gIhANw85EtCQKKXJw7q\nwMO+tZhdUBxPMBew/VCfBM5nUOvP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUZJBTVC+GhphgMta9Xib9Z6J8DvswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIBjcQcaPyTvDGhemz+NjAl2xR0fpHPfDaduAtLbUgZo9AiB9Lb3AtHPuPusVNqD0\n6pV40cY/br36cTS15Alt9zQ3TQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUBCYthkqi3jUGlvKLwPy69ooLQhAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDLVF25gguROvFcMDOGbwrZi9G+RwQdE4oKeE5TvLN7uwIhAOjPgkOxns06gnze\n5IoXIEDj/k+pHTpFW/K3jSAh4b6G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUD+DQwmScPW8bSFtzYWMg0+U4/4owCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCFoom7AVGTNVniJuC5j1B7bXSV/Ng70EqRhvyngiXjKQIhAOhlCLjMkdRjSiZ0\n/RUvSz9F4PveFiUgqyO5cQnX1LUU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUIuGxzQrI1M+VtRS6fRJpK9ocQrQwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM0OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCr77SGyS62+r7wQJc9MomHqcMiFueSK53xixlU0OswLwIhALly5Sh7yERO3tN3\nPUy3AYE4OenNCu7bCs7EjM6pMUNL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUeY+9EyaRCuGm7ip/iKjkCdXXKb4wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIEXENIyHECUJxPFgxUTb9OVF9GyHNP5ikVvdbXytA4rvAiBgLsSvlDpFBMJ80Rmw\nTobaUgHU7t0wA6WPckokAIHjNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUDcO0wL4qGfCyOS/uoFAoX8Xl19QwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIDZL15l0vSQmpdXdglY1nex5OB1NrByRACYUfbniX7jrAiAeNE8+5ukNrZsdKUM6\nbw+UBx43+38lxhRuPwxud6w+6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUaAnjDGIpwiSZ6F4xmWR/giX98U8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQC99iKzgY+aNji/RkiFKn9M7aclfd3UBCiXMiFOkFhG9QIhAJmLTHsz72KOJrt4\n8wsmdY2ul5HM+TP0gq3EmXw0nPAg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUHfClmOtGiReeNZs8LMdG89ICPyYwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDCxoQ2qVfmXXu5wNcqtb0aNFblFjSEeowoNVnmBnPwRAIgHmVigcjnatb/fvjr\nTruXuUP0Ao0F0G9kb+o8a043oDE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUD5Imb65gxZIqlq8S1bCAeSpafdcwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIDHnkLRd/kyNppeXqbs3vUU0tbEX7Z+3OACL2+gVSPh2AiBA8FZl3HGQv8ePGbpv\niMQLM+qc1xrmFZ6CkbdLnVVOtw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUaj3IHdRKk/PHu51RG3S0GAj5AzcwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCfJO5DDTYIvySK/aVUhie87kojzfGRiMNnBaTTEddgIAIhAMi0nCC0hssFc3kG\nRN0dD8d8if3tx8d4Jdw9EjisHe7r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUPLr9wWPPGXbOyVrfcSyIiV9sEocwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIDRt4UzNa9kCjoqO7r2nQum1hS9eoNzs2uf2qNvMh2rwAiB/YklESPSWVbyfpyan\n3AqEU2uRbecohh94MjpEwvS48w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUe++wbOZ7KjZj3YGtji8Cp/WgLPkwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIBY29Xcqffs/509a2abvh3+t3hH0dzFHuNQiWzxkAOXXAiEA8gO8A3r+bptt4dnP\nworyR065l2aRhujuLnb3D1FVkD4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUbw3yiVMNnGQIVMeT50AJuTjFpn8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQD3BZ5vGViHYTZ+ntNXCFTQI1MTX4c7j5AzQur8UcjI+AIhAPySAy45dqEk7Vv+\nkft31npLywAsnyRk0KgceW+gI83c\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUEB/DQXTkaMzQ3nC26Lz8uvnONGEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM1OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCtCTUC57tfPrcD+CFWciCd3i16/ptHKIhpOBZ1cHXovwIgAvTo4JWgJbkqAcVg\n4ii4UCnUDVmc5Zrx2+jOtkMDtSw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIURh1w/04qPb4UfF+Z8/M80yESZUUwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDkTODa9O07DRWycgAHmAVd1ApJuVV7blKmeeNU+0GntgIgEJAqAx3gSo9A3qz1\nduc9/ZX//c3h2AWhnUktaCp5dw4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUJ2l9/km1l+dydJkGJB3h7jd7VCYwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCCWIB6lzgMbhYxCNUlDc/KVgOAcWW+aZU97PVHcAFtlQIhAPDD2lOA28H1KdVe\npp9GiGnRneHxSBnKRPM4Q6GowbK4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUK4uPksX4GPaKLUoJExlG1sF16hswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nICJS051MhqYUX5MkZoaC1Vwuv+NQGeKiddVkh2f4TbN4AiB80/SsDush3rFOE6EF\nq64OUkhCAj+ywvDgkkjbY6GMdA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUJpfdiMVwd72gEvGosui4hb+KBSkwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQC0QY+lwoHzECEbFoyEglei0nOyJr86ikJBCQbX11+I3gIgIiyOg8ksXo5s5zNh\nvVZaz1k3SC+KkMcUvzNrI8XtEkE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUUDvSp+WnKvu5oPMezScwms3fDSYwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDA/NKLxEC/RCEL56AVWV12FiUYn4tkRp/aLw5tn5wVeAIhAOEaSQ1QoeLPOmeQ\nrufGE6NLMZbGY7fIU16ojLpyfD/M\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUKxb6ddNC+W/2o/jC8fgw4CaRaIMwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIGX7ptRgDMpeen0/d+p/afwa4h39M5QJQHkWCkTy21GGAiAbCmAeqB5uVWlomh3a\nHkJsWfFN0h54HZwtq4wqw2opxA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUQZwScfeDyyEf0NBK1huGsYWDfw8wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIDiYNl71pMBdeNxjbdjkDQS4ritB/r681U1FROc9mQ0HAiEA6Ip8CXJ6ZzcBlS8Z\nDp9lbNEmqJN7Ed6Tn4otsXzdpE8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIURbAviYEXgOp2YzcciDlZs4mM5FswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCtSZKoPzk+Jwy/6Z/itD0pJoUm6xEMttDT/XjvVmTpJQIgK9Nej9EkGaHkVQUI\nj0jt+KphycUtMeddhkhlEgeFhNc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUH1ApjRKoj5fSOJe7jqHdjCNezwUwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDtOudItFl0C5dQFja0HeYfbQuNmTMG5nZZK2PDAMuUlQIhAMBGRsCgclJcSHJq\nkoXnw54ZDOa+W7MF9IDlT1vbctO2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUaANcYyURCQGjINN73U7nSSnEq7EwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM2OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIGUY6qO2X9cg3m00YdyN9f/ViCoAtNMA83ABTnWofcngAiBV6cVUT8OjQ4bCKd38\ncFWWd4kuiH/BzMfxc8vq2EtGAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUf7O4eWNNdPqGOOkRHcy1jISuGxYwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIFUBgE6xIY+GxO5F7X/jsjlSDAQ81NK12V0x/oxbToBsAiBuJCLBj2dIsjv2Y+eb\nf7NJ6m6Hh6cG2P0Z60aHGhUu+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUEjwmWEZ6hhA6Lh0l9ExGCEdXJWEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCmVpVlCwBLiQ027IRinilxQv/EZx3AAilwJyLd6mf3swIhAOovfw6WALzURe/p\nXryltJCU0AV21+gS50CpF9y1ZD6y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUI5ruypbzc37xkmYy2UYVAyC6w8cwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIDgaiVIW9GVSfuQTyBlOTsmfXSEBkXhQgtF7lbIK6ONVAiBJ2vpdb3wvLLbbuPRE\nsBcZFqL4B9vSQAXQ3HVHRZ2Agg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUUPCQtcIdeNrTKMkVNE8O8vMEclgwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIGVj09K2oBqs8GzvOE13cePIFTV5cEwyzestABhYeI/0AiBwWMLatmKcSHLBFgpA\nfuT6deBJusCPFc0kKwPQOrhxaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUZnGbCy1rUTn+9nICgaYOrphThWswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIEfZIqDZJx5M3JZeOgn/7Aa+o+25XED1Xb1K6Zxnpz5XAiEAv+uuXZNGvDjbyrJA\na99rdjy+KYBFYQmBWmZROQyfJEo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUSdMUIxztJmXFqUQDLFFoKeVcYIYwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDUumvWQ1JGnaLaWdnIOn/KLsHAHM9AHMVpj4pWpU09wQIgFme04BvASWqmvnlA\nQZaIRLpCsuenbay171BmUKpn96c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUT35SpHTUeMw1E6UqGagF8wbeTnswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCJifaScQF2vn2eHQXEeMSrlKpZqkGgPN1efbVePH0PvQIgfvhviu0GnromUF4J\nE0ZbtPflaEnLONyprkcrkazoS7I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUCW2eEmgL3im+usi83f1ASQ3H+b0wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQC7Tqfkke0TqycJzwkkik/HOwog10fC/wq7lhQug9XCOwIgNER3F3E1PkLlzigN\n5OmLFlRmAchoxe1I22ygMAkX24M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUGbjoNqhgCD29GbCz7kGJGf+/rV4wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nICHtjcNSClg5ZbnFM3tmFx2SXtvNA/pzElbAxt/wkmU/AiEA0qhiJdN2/ztBDADi\nlc54hNTFgQV9FPLUqvP5SZSLrko=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUBmM7SQPbgHS24EjrgGHWb5CPONcwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM3OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIDvy8Vd0yaFd02e5jp8gw8We9CrGIRtO4vqpzNe7+tepAiEAno9LoVYGGunqm1XS\nAyRyWJPiRSegOJrW9MtaE04Re8c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUWopqizdkN/yBYGzKeF6txK6uorowCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCwMZ4qPwPtpLD6i2ad6yKHhkjEgpjn5FlLkI7gOrYaBQIgQmBKoxqDT4daWll+\n/Te0oy0YKMsy1OeUW26thvO3Y3A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUM1Vos4Hqb/bcPJpmlaCHBtoK/M0wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQCYQ3a+QUM9hb9S85KvIt8Dw8xREAoRRTkYjS5803E7VQIgc2i69MZwoV9f5tjE\n+3agC5R2PxVKgrPXKTWJN3yM2DA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUCZWN0oujDwPP5t/JwrUTNbINVVEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIFYKQx/GchWg9SZsl1g3Z0uxJBJN5Al7ROcOLvclv5FWAiEA06OLd8xVT9/qIgoj\nzr2xkJm6nwVUvFPkODOxST6B41g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUFARU+QquqBh9ZOUHnncgn9o17kcwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCV8Wlc06cNdxEwnwqluXh7rCPISWfKo8DU0FZ/JmEDrwIhAK3B/zJuN4NUhX0W\n/KhzVrSePrzQkv21OtBfqQ1JBFbq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUOA6mRP55maKiFAWNTydtYLcnQAwwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQDbgWjlG1FCsIhHAHH4SN3bxu3jj3YPYGvn950jsXo0ewIhAMXnyp56fh7NgNQm\nWpWvat34NmRt9PGwoB2aPaB3x7F8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUcJ6WrRl/6bfWYed4MAyMIKiD72IwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDLlyb0ekY2zjTDfPAyU82TdeMZHErKRtlLxsLhufefeQIgG2zZrQ3XU6dL2rxw\ngKsT3aUYntYvwy0Q9tMuaVu4tMU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUCLlCezYI7Pmr5YdNV1FjgJpsN1IwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIBXMrKCBZSLlFKX3GsVMWhIBVJzKc5Po/ZePRwuFvhcvAiBmVVrsKoc2lXS1Z0AL\nP5xqpQm+ZhBGoxwHgdgxGPKAHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUSiwQ3n4h9yz0CgqM32Y3GQXedSUwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIBUylLhtHiTCuECg5LU9W3K1PuJMtynBgNxTrSdbJmcmAiAl7nXcJJf7MJpzP6QZ\nCU7sf0EMJNPH0ugCKUe7Hid9ig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUDm+IesyH86zuuPqxmJrJgAUaA7swCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQD2Qx/pY9dnVAhNJF3ZpDSU0+35/fYuIYS8lWpY0RVTTgIgbfKqXDkOciSurKff\nIARcBfn39v5pRPdD9CJLIGVIW64=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUedCIqfQuhxjJOCHHH59mdaGGo1QwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM4OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nICLou477ERk5PRw3QHln7MksKBf6ZYJZ2asXi0+Oj9GDAiAoCG3jUGsT1z9uTTsg\ntgK42GVUBeb3ImDya1g4mSYRHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUOfN/k+zJEKh/e4ASvTsYNfBci0EwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5MDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIFvcCwgMC4JAtyuWfCM2egNBHleMx9BOA7k2J9ZrXipSAiBjjsux7+pQpTIGrXKX\nvANkzZbA28yRA8yn7Hm4GIZSCQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUCyBJdYD7nccyyBoc/dZHnI/TTiswCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5MTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIBHfpoL4nZ0NyDEdR4puTwWMPsuNlbVCK6DZzU4vBSiwAiBdT2cGpzoXcCJkdJ1i\nG+bIjlW6wP3lJJ/ZqsTQUNnBaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUAm6jW4/6xkbzCNO/s53eZ6E2R3YwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5MjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIQDoOe8YFGVRVNOP6o7PO9heCiOZx5UTKDJsENRUXQmdngIgKjGUc248st0bkv1v\n3AKvAkHW+GaqvnWFqTo5LIcl/fo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYDCCAQagAwIBAgIUYNmOt2p3Icopu/yBmE7fWgdR4KUwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5MzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUC\nIGAjRq9gBYkPavCf7nbsJSsrLpe93HLDushRXdguHxX6AiEAimzasJClkgHc8FEl\n6jhyu8wSSCXO6QBmLfJHCIItV7U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUdBViyOhY1qLxSjDA2LSyobya5jIwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5NDAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nICu1l5Z3wsSYtrJaiT+iG7zOycpUgMD5PGopx1YYUDUUAiBMScpDkfSVZruYMSs9\nKzVv0cJ/0hvoxV5Ps6IhMZRu/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUTeiPyLk77pUG9mKokPXoI8BGXuAwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5NTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIBpVi4WP++6qhxzuaj1NwhbiLxtS/kQaPE+PuJ7ciV3wAiBGud2aYcJu+9jhyGaW\nyPdTlQAQwsPZOQJz/SYm5iNV0w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUTQaPyQT/iFGPwql2wtVZzzIn+8swCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5NjAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIDaddYvFk52OSXwBrVTSHLKhoDZRT33mqX7i4qkHr5E+AiBipsX/GIOOhj9UxEzF\n5XplZdJnfYeahDWEKGkG3ClHig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBXzCCAQagAwIBAgIUbDzFScGfCFt4TfQs98KquICQGcwwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5NzAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQC\nIBJcCWyxirkEJ2oyPgEwYQ2N4Inko8CP8l25vuJMwFMuAiA1YXYGRrldmMc8TtZj\niwzlj70hInoak4dYjnzmn7gxPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBYTCCAQagAwIBAgIUVMyo/QymzaHtqgpnMGel668gpmEwCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5ODAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5\nOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSxzZYUGfGnaT7UB/6b5Y89jzfG\nSLTkz62gBTDCJlnCz0Bij09TqtLbD9HkrrS8JQ4dCto8C8ai8kZZ9Bi+IZCjIDAe\nMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYC\nIQCosYkMQWCatsdBlcRPVc3i41hQ+h7BQmNRYlGB2bUMWwIhAORB79P5visVRwTP\nbJxdTMZZN5oNXVrlPLE9lYVCOdmT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtDCCAVqgAwIBAgIULlneOqR4T4DxX+8WzjKq8qGmto0wCgYIKoZIzj0EAwIw\nHjEcMBoGA1UEAwwTUGF0aG9sb2dpY2FsIENBICM5OTAgFw03MDAxMDEwMDAwMDFa\nGA8yOTY5MDUwMzAwMDAwMVowFjEUMBIGA1UEAwwLZXhhbXBsZS5jb20wWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATuNxx4YegiXq9NJSachcrnQYSQTiJoq182PUt8\nDuNHorwp6/YOQMhKCbAT20i2DpYvR08KUGdG8EGwzUylip0Xo3wwejAdBgNVHQ4E\nFgQU/Dcko+udIv6+aiG0r27oE9SvG50wHwYDVR0jBBgwFoAURIKIgWxZumtndSUu\nNDUTL2xrracwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBYGA1Ud\nEQQPMA2CC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDm/1eYVr+kQ/x0b\noQHHTFgLX1JyawEBVWMoldF8Tdm0AiEAkyfxJr11Cd25J5s272utQOLHZhw8FKaK\njDeBQpKbb/w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIJQRDNDR4byqnLjy1/StyoNKaJJxWQQLWzhqUPmo/s/ooAoGCCqGSM49\nAwEHoUQDQgAE7jcceGHoIl6vTSUmnIXK50GEkE4iaKtfNj1LfA7jR6K8Kev2DkDI\nSgmwE9tItg6WL0dPClBnRvBBsM1MpYqdFw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "pathological::pathological-chain-same-subject-same-key", + "conflicts_with": [], + "features": [ + "denial-of-service" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nICA (self-signed) <- ICA <- ... <- ICA <- EE\n```\n\nA chain of 100 intermediate CAs that all share both a single subject and a\nsingle key, none of which chain up to a trusted root. No valid chain can be\nbuilt.\n\nThis is the worst case from Go's `TestPathologicalChains`: every\nintermediate shares both subject and key, so every intermediate appears to\nhave signed every other, producing the largest possible set of candidate\nparents for each step of path building.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUXTC7M/3zyiOHnOMYSHT39f5lOTkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARQJ0jnxEaDfYdWe+dccGz4zqxyWRMGeB19StXA\nx5lsg8D+SrzrLy6xJ5MDa5iukfxZin1L7H1CNbgm9XAf/Lt+o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU0q9ARNcAV1Up/jQKMIPGUGEbD3wwCgYIKoZIzj0EAwIDRwAwRAIg\nc6ZvkuJdcyCn4vgwlOEeVfVzdOlsj8ZuK/KDTpcV+6ICIFNbFXrh+mCc2xRoTc5T\n1vLM8VfQ6bqWRmjqYzfMhU9H\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQsAgI00dj4X+CjYVKpinbnweP9JTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgEGMAoGCCqGSM49BAMCA0cAMEQCIBZ7ms7MCkhn\njVBjVslIPY/Q/KYcO3eRzLW9yWf0dqBeAiBEv0C9eKvxZbXYSRscG0AnubAe23Ow\nqnS80KNoEG+c3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRB+Id3KMhnKzkObtbMgtyLTBJ0GDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIE40ZlJ9pv0F\ncXRZqlWOvndgWa5WxIXwHdVH1IVcPHACAiEAnR35ecQxNunwfg4q+zjKtJbZ1rG1\njJloYUsyEUEqxnI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRJYqu6pvtqAErOYk5sM4u+ZR3r6DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIFUwH2hHsQL2\n6utD3LLUItXq9lk9wESbzsFLrAi6ZhOgAiBH/knrQ/dfRnla0c4nUTj30EVlxazp\n3qoVMJXe/hzAvg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQw1J+KXNJkgaIz+cmebNwu2E5VTzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIBpTi2jsG+zA\nBTF01kH2ePp/uaynson5y5iOl7vhfmAlAiAp2WOfvAWeiM2eEvQPfTrj9z6RkWaO\nGQToRjtGP0lhSA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRgiIp/58qtBUHRMyzINKsVdRqmzjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIAqF4FwYeHUG\n1IHmxnIvSw7rCauaswp/mR/lIJvge9dCAiA0ZPNmoe8WcbRvI10lpyjzP88hsMCu\nxHrGwp3iX/OjsQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQXbxYYYE8AgOkgsviYaD1BWwNIkDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIHOfvds3vbvD\nyjPWXEX1USL+NOAU4tGWAC5jqpvsN9ozAiAhmwJbTd1naVz4gmp7JPFv6/o6dKzF\nuedMyZV8/p3pIg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRCRZTU+IalRj22DubF4U6Xj8e+KjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCICwC1LlX3vcw\nivJftGaoVewyw3t1oypHEmH2xtaGZ/G/AiEA7CljFqb3IUrR5d9FVzvhEtOaXQUD\naqdjOl8QDr2MQQw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRm9QapAXTdv5SUQk+rpUp67TU52DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIG9CbNm73VN0\n2KCb1bgeNm6JoMJsFXpUbqqZILTM81ZYAiBK/jyl/bd2beTfWmt9wLJPc1Bmho3B\nqo3bgD0p/SVM3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhR2HXjUcKqSYlDs5YyN7MKiWMsLhDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDvyRX/AyO1\nC1fW8eggNAuNYmaNIcZ85Gl9ri0D+zilgAIgVMjTvO/MYj7AyzKAqlK9t5PGQeYg\ngPWl/2jcBMQooYk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/aADAgECAhNCD+SpyXe/rYsySYq18zUzw9JiMAoGCCqGSM49BAMCMBox\nGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTAgFw03MDAxMDEwMDAwMDFaGA8yOTY5\nMDUwMzAwMDAwMVowGjEYMBYGA1UEAwwPUGF0aG9sb2dpY2FsIENBMFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAEbtQ6pDSCW870QTVU2zZJC1DpEAiT3oQZOTfqu1w8\nMRjYRL38tm3CsvwWbh8j82Qr1nioVn9Obi7+rFvbwwaql6MgMB4wDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAgQwCgYIKoZIzj0EAwIDSAAwRQIhAPxQglHcVQ38\nUhR8pVP8mqD0SSqNoUkElyi75ZwEWtghAiAC55NOHTRkWp8Ljyi8tSSX+hKRIOJP\nvyw/p/1JJuB7zg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQiqG1dGHK9XyD6RWGOWS/Wn1cLOzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCICZ2SmWE4v6o\nZyhxl5dj2EEmIINcA+HiE3fw9LJZQ9ZCAiEA2jm0woIhoNcNzCKUvF4NwrYGmQBx\npKG8eBriiqweN1o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRcW0Ns2Xna+3RtiK6N1W5D7fMPDTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIBC893bmgw/c\nesC5JY2oenO0GIdQjBO9VYXqa6rvebYXAiEA5hU8kv5g9+ehzurPIqcyBFh2+Arf\nwk6258kbViZwv6Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRg2xXIU65Y3EMqZiHD9BlnfoHZTDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQC0HxNIWJH4\nggxmxmgnQ+AoQqh9gHOgYGGZ8Rvi//NKtwIgF/OJPk4FJf+xi8aWnknpJOaUMUxq\nXTqdXvvl650i8ZY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQednNe1DLZtfYNKbV1IOD8qj9CZDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCICH0lr87/Prj\ntcp/w+SDFHYk6Yg0fnLOdy8JGhtbzjakAiAMQJ9ifVl2eQ76ORbsVKGmzV8OiDbd\nw+VoFH+64nlRjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQ7fIiXuk4c0cKjEKHc0XsqG/skmDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDlgL7of3Pr\n00pE50iXZgC9W9Usm1aLGSnB7IRqrJR8LQIhAJSokUHrTRxmVGOWWBSrfs8pKG/y\nMtkf5ORj5AqzXeXH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQczqhtZj6psrknwaDMvzWK2RmenDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIFpNP35Hd5v7\nhALhO1eWhEXchAuNUGJQGVMPNWtkVnYEAiEAlzdCLUmGOFvyOoLvXTv4Bz1ptEO4\nmH6FPCbNpc5ntPg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQYZQ/BQHx1vPGvSKLU1MV0+KmzUTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIBDjd9j7m4PU\nu6xanJopDe3/DeOYfc6gzqNAGi4qAo3zAiAu/i80oFO5RpWBpF+L8xatCBcjYQ6A\n8qa/XrIdSPEhig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRYvgUopTxTNJWJbDLvCQUBSTjn4zAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIDnTBYXd0lEj\nf6cm6xDEkFnG+QSlf4JVukpsv/fm+r5EAiEAqqC5JTfLROmzZYmPDznz9Ymx0kVD\nEg547j+LzSTBqAI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQ/0c44hVIZsOq1urLRMQnEghpmdDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIA3nUqvRLYOn\nm45FZhQGfEl83yMlakqf/p7zQzBL1fU7AiBrTeYO+53wzuFaJMgTsI/pScYKk5fi\n7h2K6K7BbXn4Yg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQt0IKbC738HHYaTdNmK7YAg6qUBzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCbncI//lDw\nZHFIdfV40O6zTSxkhzv13CXPdod55+/zEAIgFWlpbQr2zfFm+eMpY/XrphQTdDoY\n567+AmEM341GnPE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQRxbrfaksbl5m21fc2R4nklPi+aDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCRHHYszdon\nk6KJ6K113j+n79UAx9uV636q4/6TIPKBSAIhAK36AP7V5bWTF9sq705Mr4FtLegI\nXwG1x+Fg4y1c7m1m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRrHNJ14Q8dV7aV6UUjcFXZhOSXTjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDN/DSqCKCs\nKiftkBmlZRhPcW4g2CnE3Y7MgQfHRw7DnAIgCY+IXRz4e7LVkMpJPkVkLAiX+IO6\nCOdC1ijwbfjTJTA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQpOQew/T6kcv6s9a3/1jqWJxHZcTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDzTGakEagr\nnG1PyqhtEQdSlzM5VTonAHZOi5Cm5/SocwIgb6NAS5gSd5prOsjNm4fZeXrKHkjB\n9OzrtJu5o+9h8Os=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQldG99mkxoRpuLnuZrYMgPFonokDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDSSoGu9Awc\nrnXf5Ro9LejM13Ah5vr8DFtbvM20ugYXOAIgc+f4qsfPPCujts1HG3tnWh8wQ+Q7\n2N8YU2VVcLHvSj4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRtg1F7bhdMK4N4WtKaykrB4CU6TTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDcF8wBOiRn\nWHjENCTkDTsvzG34oTuheaFYsUjXP3xkKgIhANgKaj2Xsjf41ku9vyfO4UGUKycP\nm5BNj3Jp2a6XqmDe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRXEmkEe2u3SvPcKOMlhkjOtxBUEjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCLybHzr9Sk\na9pxmQRjHYnj6tOfpv2e5IzX6q+AO6ZdTQIgRloUXtF0WYnL905JnQ2h7SZBjWf/\ndimjLzWR0PWN5Uk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRsZuiu2RxER3k/8ntaLlu5scarAzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIEOTDUcc7bGq\nVhdHcmA1rx9TeZy62wr2N/UeUZBVuhq4AiBXw4OuBZ2//fs8TiWrH3BAm+MPIefU\nTrWrONWf5lJscQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQOjH2cvg4118YejleQGKn9S6v77DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIACzjJV/pDjz\niZuDzK7AYyPb7axRTS2+jSiwylQb2mqZAiAUi8tH70tfH6OPSudS9M6xh3PBpkOo\n5W5gKihxX37ZsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRJ1pA827uXHgLPLQ9CbiNEr07aojAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIFJWoMJgjmVv\nQHVnQ4ZC01O6W315Hieq3bkMBWPUgKATAiEAkWXCU1s20W99db+SvGZ9uNPvtWnm\n6Ah8dBOGvwzD8SI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQFlJfbL3FDAUoiRc9hfbyHBuOrcDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIANuwxomEfww\no9B5be4/9h+/GGt0BtHhDQ8psjXKK8z5AiEAppYixe6LO3pRAuyoUQiYe++73vWH\n7uBYly2wEKtj9Yg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRsFbtLM/WtrGeVk3QSRTTeCUm1+jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCwhdIGJQoS\nKRIfGtFcXeQuNxFKThIwx3DNXM6h6bM2EQIgGzGH9GRV8Y6Z4iMQAllUWVUX4dv2\nN12U7EPIsggmWY8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhR+Dop1IAzVBmUX02uajIP3ZkJYgjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIFysxelxKpL7\nhr1m0YmLyxjgv6k2mQAVk4pXGXcreAPrAiA6KLKi7vtU5HdqLG5RxnKzoH3iW38t\nZ8IKOr9V9W1o6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRdTfBtzvq2WDmaVicu77SgBrVOGzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIBhYnfmdf52N\njAKIJ0Fk+GtxX8mjyGQPrH0xh/wPJwULAiAS9gViMKtNln+hXHYYLCeZ1mxPGgH1\nuWBaWMjrxcWMYA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRvHnZdwETmZZ0EkWFVf9AmYRjpTjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIGj/ZiHPx0Ri\n5BufRXF6yyvn5Nb4mHrAnWTJ1XuNhoE6AiEAvJcY2EQ2yqutlbO9PwULbVw6zJiR\nqDYvl8vw9ViAuyU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRTpljhRHIdrCN6uYMe+x9FcBuV1DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIBZ0lYoc5H0M\nYojw53Gqkabmq0moRSO/QZmWu0S0W+YAAiEAmzYNQxexJN4g8VzI79W4inONtsNk\nV9hTH/vK3AVltTc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQwkMVJTxrgG/9zAn3CK4jlQcuuMjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCsC5hM5ZGv\ncHQnls4E/HbqEP45kX6nsRVH8NDBpjPyIQIgSW2yLdl+wBlon1wg3hXAFnrY557P\nE9ulu2kKQ3nxwbw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQr9JUHuCLvJOW9+ZhAWOOEWhjbpTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIEHZQ8WXgICm\nJyCYTDSlARYQVCktVDFI/FE5/EcQdMm+AiEAlZ8jiiBCE2iZpUdbNnYv1z5CnwZ+\npP1fQYtk1La0a5M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRh1oik5GyzjZXc2DHvOpTbBH7FVTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIDZI1rAyBtfh\n82/R6rbwtCEg0NhlU3oUMfeetwijrFMGAiEAhQJvHH08JFNxtFT5fiZu+5DxfXjH\ngdPYbIUUmtkzHzk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhR8fHOOl0tEDOHnStfhTNE0ir+wTzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQC/x4xqTFMQ\nhWf+eTDCFkZT6gnpclUx8/4A2uX+4eLnmgIgAZ2HvZZXplrZ4vYzU9Am5gCghm6E\nrcdXFCEPfMOhZgU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRziUEa16w1wE5os4kMcs9+NELqwzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDY5Wdosj9V\nzsFIriiCoBhv9krhbdCpBdb1oOEm68oRlAIhAPPrV6yJlRnY+TSP4NYvVZXkAUcl\ndrSep3yry0rMGRsC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRDbTm3eSXIKj82y01L0e9u7I9KojAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCRyp0g2YAL\nUGfTr9lx7AjKJ8hm9lMsanuwc4Mio/eLrgIhANsl0EVHhg7Mn6c9KNIhMuSkvQfZ\nuuT8OFPlfdZ8kkoF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQl0YMrfJefos8SQ0ojnkvDv+6SHzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDB0UmtD+H8\nxWzrACTYK/yI+SA3in97HubkVh2KT+W+5wIgKkZx+vMhFWw/I+buQo7Sm3usgAJ5\nmejefYpbv6T8Tlo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRqelKL7BFp4gYKSaNwqeumhemt5TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQD9Hq369ZoB\nJNcvGxmQOe4/i7K/LyzBcYFGjC7c20KpRgIhAIkCrZ8Q5Iuc6u3cr5D77w3ig8zM\nM1jaavgvoHe4T9FL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRObdMmOb/J1C/CNqyPYeVImkkZ3DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIAx4WJ0lJFh/\nfw/QNc7xsyRuSVRFU6mBwdQZwt9kWL7SAiAHFqaMU/BTDtSYaOOWheU7K00mSHym\nVQCzu5SEIjEG5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRM+ZBh0E6/AdAmdD1NohATvKER3jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIAlCBI91Iq/c\ndCwS/AVjd6bzXdkv4pcAc6ZV+ZbsOuQ2AiEA6k+tzAOfIhAFpPN0eTmpn3jXiKQw\nRL5aMUHt2YR3Ze0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRwr81hN42Y2XRA2cfpOQYCUBWf1jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCZ2fqVk137\nJ+jJaGlUPnuZ9EkTdhZAM4IFJMAERVe0dgIhAK8tzYKy36fEr7d/gKLBm+iBxcz7\n4CK42HRlADGtAY4e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRpc/RRFiINxRBsKW+NKFbtSDDwMDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDb/ANwvJYu\nGP1Q17Y+fA7bCo1g1BOa2kQPtDbkXCXBhAIgUImW6WogI8qUi5QKVFqj5Ww09XnP\nMFYF/t8dr6pmOP0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQMzmXGk0eyq2Kxg7ueU7Wh9iV30jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCICtVBB6lGZsV\nwKr4+wWzq5js5NtujBU1hQ0gnErng2HZAiEA68teXbEAWt6L3tQ21zpyu6rMzAg/\nvbTg/oZg/5rTxTQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRxudgUpE7uXeq5WtVvMFYfaDg31jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDYS9cewgkj\n9k8UE7Kt+NfD/IebtIhTqV/ZZXvH73cwvAIgE3GUNcBlJTlutHCpq8/ORY41uGLY\nGWA4n1xEVisx/Sw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQHyBJ9kAuK5UJsdWyvY5YNsSARlTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIBmvoyIP8Jub\n3B87ZiJPqJVhTHtsJGjjjVixGcrmlrEQAiA/H5e4zc6NR0yx4hQ1hzq5OKpY8j3P\n7Kw2zwKjQ6S82w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQ4cK7vwtSHtfk5JGOo2y+kvwfXizAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIGeAVCuEszxg\nfQUaysYnkQh6JVnUXjoaLzMurBOmzaEAAiEA8A4pWuvNamRbnVRTosQmhQQupusT\nLdEwW8zemoYHO34=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRmcRQBcGsjJbnLjOmMuEhpWxWSPjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIHZIjGrO3y43\nDP5KLXau0uzjO3ybp8B4JN1r8D7jH7YrAiAYAcPYr1DAakdShxWJzQMxGXmdaztd\n5/l7/vzr5sD/gg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRyBxTdzqkJD1hZ+m6J2GZijMNgPzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDg2zpfFIcm\nAnuM3mjUaCOJo2tpzClelIw8s/YmZbOcBwIgXbH0qaT/Shdq3x6bZ92HKr+V43UY\nJpETHodywy0WOrg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhR52uC3hn7k7zlIit5kMG7uTZAX8jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDOAGOaSybm\nU1+nDT2ZE6HRLV78TMURMK9gq9bZQZw12AIgLbzS8vxglGDUz5kca3GPGQNC2B2T\nNTgw6UZxQBPL1EM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhR6Veyzt/3IGx7EQJSlmGLTefNMODAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCICm77q7OPRjs\nSbK4wRI+iOLXzwSo4DLdKGV9tOVP5JdDAiEAinThIZ2HOlhrtHcmf6NduSFc15os\nkNJumi0kkvjvmcE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQA28x3pN6GKkOE/19bMYumS2Q30TAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIFY1brFElPTd\nSnPeqj296oiNjEyNDVzEYgMy3r7UBgYwAiBa8mSFVL1W5svfkGWQ7MbJolmmYePw\nmLq0kulfRD46LQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQ+duI5yOm2BDGAXG0d8MoPe4NKETAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIBVI2WlSQwPW\n23mkQT/2O2N2h93ezXM7m1+dsoeJsOyuAiBIL/SY4uvcNpKJMB96Dt3W627QyRjG\nqdwToI/b+Tox+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRloAt77dZiSVVK7x9wA5bapTvTpjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIElKaXVTUsKM\nvIW7YtJHxERhO84VcH8QqyIXc3YWkglGAiEAtrbx5dJYVRrATeeeaGKTebJ6t9TX\nV+KRMIrAOqCoL1E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQj6pDIAsxSS7Lg+dDbkzVvbURDLTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQC+r2vFyKfj\nsIYSdWykdkqsXtgfeHHs+c0d4Y06WppntQIgLmXjbV0VhbfUEIRaJYGLVS3LPfP3\n37G6AGVXrBcrXSc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQJdjzDKhkVX22z+5/jiIZLx8OBhDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDm4srqjIYw\n3x+mT08EyN0fuYOeBdzz2pbdMPXZH7nVhQIgOKwPAAReR0Tr/Hi0NbDIakcio7Th\nogbzc+NrzYKhl/U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRledHjFmRk4nzsGEGZdX6aBOWAwjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCjuSZyoOoc\nuhKwM+rM9EfXd5LHANAUiEsDvnxBa24NUAIgWUiXK8oJHSWO3t5+YApwmH/JAphW\nBlK0rM6D/u1T8FE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRCKwc2ZonDfL+v1bmJr6Uoy1hwwDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCMjrSGDs1s\nxxhs7mFWxZBsemc5UNtbrLcVtPYF2J6EJgIhAMmiyM+lKJK/8jcIywwZk8GBsHls\nVLedlsVjJ/3cUen3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRT9TU5Gmx0AdSCB5V9/0WBC1RX9zAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQC8dEdBBYvQ\nb/PNy70SuHiFJusqrw/EEgccH8LWjbW6xwIgBaeHO+bm2VL2V4Ry9w96GStxip/1\noHRGuITStA9BB78=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQgjcqMkLbw6oXrvMGLVXvDaCbQ6jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDpaahuCY8d\nMDH9XZcHh22eLVKPKUXajX+SpX6T4t7/8AIhALQBH1nDa7t4e+XvihGfr6hrnb8x\ncEeJ/Ff86kG9xTHb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQKv+TJqn474KicLjh9afkxoX4URjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDeRkUQcRXC\nSSznt2uaHuuIwuKX5JHt6dZLX6ZNWHzcUQIhAJU5YsYtRczsmJI7/x8QHfwdHLqt\nHyDd00gudWVtH4Wg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQcyxtXo1cKdQbOjwip4mJmkuov7jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIHqGHmeYiC6z\nSpYxrfzuA9+iG51IL33Y2owRCwdZX0G7AiEAxoSJJaexwAyStoTiTIbJgCBvxsSq\nH2s267w3XBjWP50=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQ4LGknz5OEKicHOK7ppFR/WBCCFjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQClXSNM/Nhq\nP10CLcO3r141ePVwwo7peaTcQNhN5Cv9ogIgGh7lrLK3U42REI4wCmUTO/IbbW0z\nS5sP3rfhVw2Ehz4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQ4kEZYoE//KcsEgFTrPgIH2GIF/jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCLN5jPUCLy\ngndBQi+DGJfsNYRJc9afWE1Qj26fHUD8jQIgbmFUb6IDJyErWMC9Z5H6MM4Sqi4y\nG8PS4TUEtQ2tLXg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRvHKcL3PGyhzqXOg7idAx9H4QFfTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDF+tRm2yYY\n9ZcMl8wJmBRkmOvX9xtkM/6u7dtxNl7t+AIgP2z0tGN8Yzh0FJCSn6y1ZC+dGI4O\nWU63popITd7ngjM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRQ+d2P58k6Z09D9kqO8jqc1mJ7vTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIEY2cQctef9p\nqxrGPWl13j21zi7XXPBrNLnwLTFcQilrAiA8M7nLv/pSh4WHVtgFln5kHTYOLA3A\n7Pa5yMUbRaa3zg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhR8IiGERNF7Dc48VzlwMNTDyZkRlTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIHD4sHIhOeeU\neiHO5qD29bE0Cm79MVqe6j4AxeMZyMzGAiEA5i5sjbVcPRsB6ca+sdpb2W91LAKv\nXj2fWbAnQaye5SY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQaTYZ+k5BNU4mzBCUo8LM3T3v7rTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDOmdqsl2rG\n/uURvQiRyPIZdWELKdC0rESfHWkDUH7PDAIgZI9UuAxIztUVEvGgA+bjRgzyScrr\nLwMe+vOm4FMdVzU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQ+gaqOJdPu+NKgCGNV/pYqYGhgXjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCYCSsqUz/T\no9Y+BsByukkNtvhxZJvngWimLeAUN9SFVgIhAL8FzGtDIfVXzfTYXk94yUo7clpG\n0Y5CFHtzopPD5Vd2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhR9FZRC+ek3J4TZWiEoXlIc5BPrqDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDw+5enscfZ\n6EqP4GqfbcVDIA6TgSp5XRAViZCUMoDKtwIgae7t4mSbgN9SCYYMpp4NqR+r/bN3\neJpGAaJ0CHvy270=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQOpJ4mKNMitlmHC5bnt5B3YHiIbDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCWmg4l6a0P\nDNySjGp8TIg6X7v1/T/y55HucxnNsYFapQIgLydL/hwR3de4N80T2Bs5YOJQfr6F\nACJ8rc2LqVxWc8g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVTCB/qADAgECAhRZmqIrvieduCB06PFdzLf20X27azAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0YAMEMCHwGDHrFXlplg\nmIjJAWe5+GqpW7K1WjX9v+VyOzVtmt8CIDK5jpDyorebGW0KFBBQo8qQD2oOZlec\nXbqVQ2esrzuK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQU9AxEsEFX50w8yFzpBmNus1KHSjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQC/JHnwaFxZ\nsDdXb8xU5KRTOjGB+4PQBdZs3wuISBtE5AIhALcKYEDIn/EAt3ikOKOOxGNQ9HY+\nniE49WqiNMIecE/K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRLwpsmkuxFkC4RU3vgSNUIEl2R7jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDAHvjri6c/\newkBXXxMQeKr9GWzCB+UyjkI6BzZEMIUCwIgFadAMlaYGzQq5qfnsx3v31n+q3zT\nheuSqHDB+1DAeeI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRZWcLMNn9EP6SQLsf8VfJ0OXvIuzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIBPlmN8OSSpg\nJ+2sr88fvoyx72Q+3muVSAQdlzIIGwe1AiEA7rh1YOC6TTj/hLw9w62AXVT4rEUy\nHzNPE8VOsAtbic4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhR2rO3ewFeChIREjgPhreIAWCPZ7jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIF14SDNqQoX1\nYkzHdjZZY/TEx3TsM4S/fNNhJG5G7n3mAiBuyytpCKbLRhrFHUwtova22I/Ju4I6\nEB1GzZKPYjEx0w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQJeBTOT0AKxPQPFix2EiAkEyzTLjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIFxAUZkrzflI\nFh9CJv29JKlDZUu7IUGkezcx4TUN8niPAiEAm+T1PUKb6+OOY49UAf41FEkFOma+\nY97yzF2Zra/vrJE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQiBGQ//FvF28MhdvGV/BhoVghYkjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCRxDbpJxmK\nkxbt8n0pd+x5sYNztjBtjwj9gDSM7vItygIhALwBbZjwFDXgcGB5LRf+amdAX+Nx\njuqy0BhZ/HUMymjJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRXX1wwzE+W5DHbvRtUn1RABa5hdjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIBjO2NlcLukL\nU4//8IoL8A3rRSTMrQC2WrYthYNnOpS1AiEA07LN6Evg9cD/cWS+xwXVzw89ZIiC\nlaN5+yrbrKtVvok=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRtHwz1TRRxKa+aCCVp09n36noWQjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCxQBRps5LB\n/CrKRWYI1rsHDUXWH5HENPFUkIzIfL3E0QIga0zpHGNaKcUxyD5bT76tQwyEHP5c\nSGD0uBLVJoTXRh4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQK2YxdfIhqhOaseR96MohVXWZ0gzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIDSwKSLmEn7c\nlMfnSoekpNtfx9ijQT4GhhU3NqKH/tVNAiAls2Q/v+3LX1S44mtLZPfmprBLZxhE\n6LmdK9L0BOX89g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhQuqE+IkddF+Ok2+xHpwkT56xc7ajAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDolZAyiTcJ\nMaU7szDy4RzvjUkLJGE93PCCU7Ti/XrxxQIhAMq+2xPUs/WCLETvk4iSub6FST0t\nnkuXimguufa/p3DC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRFhdjffiZG5gX+XNpY0SWHv00FpjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIBSh032YF92L\nVNfR3mJqzFdiaOBBlYcYStTFqeB7+nTAAiAH0HnZYgsWLgAIAyJ9pdd3NOQu2/JN\nFB/0HrSvVzI5cg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhR6OsulY37d5MoSvLmGb3wXhhMDATAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQCtwDsAs3zi\ntdPf66QqCQ2wrln0UOVYv2dhhTI6WM4WPAIhAIIp+8IgJaaipBvzCuqhkP/Qk3yE\nsp5jx7XjJZSUjePZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRnViERvC8MPNwwvEHEjYU4dR/OMDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQD51YTaedZw\ngc7jCMyGEpPx0b+4VSR4q25g4gkjNPZDUAIhAKQUBQE2qSjbuut9V1yvimGkeco/\nUy4cokSWbLktdmdr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRKFFnAnwEA7h7tBwPt+CrC57xb1jAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDVqBGQlTV3\ngpGjRV1Hp+5Z/H52KYnSLJwRjsp/rapa+QIgREnZaCM8amLQT0DZjA7eVujDTSBt\nA6JgUtZNCI3hvoQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRD46YG4Y+Rno7ghzvY96LlULBUszAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIEz7E/E3n53U\nuqcRgt6gv+TuxRdsa3EEfb/9zjI2s42rAiEAyCCEzETi336Yc11JHh/7LXmPB4FK\n9IIeXyrAceRtC6U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRuJExLmc9RL7lPRgVS7R3zYEl3XDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCICe+24EHQvOW\nEoyF77IiXZPym07TwUP+4fXJpXA9SULfAiB7s2fvAbX3VxaSxFPg4SgnIE4+i5Gx\nskDUBEvWaMIeNw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhQs6O98gZA7d/7n0ASl8JUBjMQJqzAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQD73zzLEf5Q\nq/eLhfraUIUJV2AJaavEKNEKZRsok1WFkQIgRCgHt6SmmJTQZJt+PDKFCT/UCDJb\nfAbICtWcjYSNj3g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRlacOfm8uYqfZw3XTVNFTcDeeV7DAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIBy+Zmr3KI8b\nmp8+117owlhafYe3mCy+SjDAnQlUobO0AiBqkM0r9MibbVu2eETQ2woKgD0ljXJx\nMszNuaHk1Niy2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRXo4H2T8nQ5RVsxYKkFrpS8DgT8zAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIEtbDbOmbB/x\n+0DN0zuNZOO8QyMaWvXbowHwxCHK7PWlAiAyo8mUxtrV9NgCwoYMnEWih/54h+Vo\nRJDuxEPj/09wkQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBWDCB/qADAgECAhRrgSA5FoAAPazBSpYJIM8x2xY0uTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0kAMEYCIQDiQtmOOj6I\nCZDIPwbiXpt50+QXuQtam1GYLytb4A4pzgIhAM6ZPUGZcL0L6DlbOmFyW286/SGA\nBAelGYLwiPS1ByZk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRTO/3ltc/+Vt9+xT5CdJyK/JyFqjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQDC4GJiWxWC\n1h72NA96lDNSOq7qwu5ovg4cmWvkCk3L6gIgLL4chG68/ow7DGjZVDM3vj4hNjBu\n3MoVOlbmw4Ykw98=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVzCB/qADAgECAhRQe27vk5LsGsiqzcaVahiZ/RBniTAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0gAMEUCIQCqqPT/50tU\nc/dUaEU+9vNb/KNQlWMCbhDblrbET9OaLQIgSCR64b6KDJu4d9++b2bRSYrriMg4\nHiYTP/zoMedb4eU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhRrGHtoEcqX0cLmfh3G1a/dqOx2hjAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIHIRuV/t6pGV\nWWzUvIbOPVbGtUxNOxBhq9UtvngUqxi2AiBUQn2SVQ2CSH+/2fctE2z6TxbvsOuE\n0xyZP/N58fTMfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBVjCB/qADAgECAhQGr0o7anD2nPzi0PSZdCYqjdqCqDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA9QYXRob2xvZ2ljYWwgQ0EwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBoxGDAWBgNVBAMMD1BhdGhvbG9naWNhbCBDQTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABG7UOqQ0glvO9EE1VNs2SQtQ6RAIk96EGTk36rtc\nPDEY2ES9/LZtwrL8Fm4fI/NkK9Z4qFZ/Tm4u/qxb28MGqpejIDAeMA8GA1UdEwEB\n/wQFMAMBAf8wCwYDVR0PBAQDAgIEMAoGCCqGSM49BAMCA0cAMEQCIATuXYdNLVM3\n2xLguUTZP9l7rGvHZQRMgt70RlS/KsdTAiBJiieBjlxjL45yqar2t3VwI1vi+Ud7\niAQUcLd6EphEZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUQNiUlk4qrVmOjlE2SAOiaI2cT2EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPUGF0aG9sb2dpY2FsIENBMCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABBXCmZzxQX6Q8O8XqcJ8JPLtJB+7/MunpO0zjBxodef3\nNFisagIzrJ7fWOhJFqV8B6+kVSVCzXzvbMcxXujeKp2jfDB6MB0GA1UdDgQWBBS4\nZ0rVWMwL9ryPpk7pHWIKbR3FDDAfBgNVHSMEGDAWgBQt/AmrV2UaFlLB+aXVWcZF\nYWEV+jALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAKQhDIBDiF4hUIQqQb3N\n7pc+jrkALX+zEFwYBaib/T69AiBGZjFLCgkBpXM8R9uXD8k9tE9xm76aYeSKV7U7\nZ8o8TQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIPVO6kQyzFvLGuR2ycHxs8kMHZVGtzNONEPqzGbJOxXsoAoGCCqGSM49\nAwEHoUQDQgAEFcKZnPFBfpDw7xepwnwk8u0kH7v8y6ek7TOMHGh15/c0WKxqAjOs\nnt9Y6EkWpXwHr6RVJULNfO9sxzFe6N4qnQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::aki::critical-aki", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert has an AKI extension marked as critical, which is disallowed\nunder RFC 5280 4.2.1.1:\n\n> Conforming CAs MUST mark this extension as non-critical.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBszCCAVmgAwIBAgIUG3SeSesxtcht4pOApHcOjjeYgeQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAS70I0eWiNqsrSHoHtilvow87C6B8EpDppTlLV1\nCkqUIVycrNFyzEVJeA3BIFFj342nuJlBKeWfvX0bfb1Lv+Ijo3sweTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAi\nBgNVHSMBAf8EGDAWgBQzr/DbFz6TqODPy+b7lpq1AyAjWjAdBgNVHQ4EFgQUM6/w\n2xc+k6jgz8vm+5aatQMgI1owCgYIKoZIzj0EAwIDSAAwRQIgZMDiY9yyvwAjZfex\n+9tNqjQzuS5fezaDTpDFfiuDi5cCIQCRNVtG64t9wagDYzoo8QLVcC7nlU6L24+a\n4xbf3gG4pQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUb378rLk1bI73+O6xBhXD5s8bEvAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABFTZqc+okBxOYiEmimmbe7nCrVzriEyqfHJJneJdcP5U\n5frfnAkNrJ+/yTdWijcnXzxVT2sRe1JQ9HWMRvhjQq6jfDB6MB0GA1UdDgQWBBQb\ndUiNfEuzs08oaxRy+X4ho2eOZjAfBgNVHSMEGDAWgBQzr/DbFz6TqODPy+b7lpq1\nAyAjWjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgBdvnenyiKpOTUfJoHkwR\n7ibsbRPxPt8CV2fBm/QzU5ACIQDVXSehaBQu4wTDs/bAdVC8iPlZ+GvE5nLDQ/KV\nZ1h5xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIAwo/1EmT9nvmXlNiDO1+6PSEDPn4/aQivtHAjtbdzlpoAoGCCqGSM49\nAwEHoUQDQgAEVNmpz6iQHE5iISaKaZt7ucKtXOuITKp8ckmd4l1w/lTl+t+cCQ2s\nn7/JN1aKNydfPFVPaxF7UlD0dYxG+GNCrg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::aki::leaf-missing-aki", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE cert is signed by the root but missing the AKI extension, which is\nforbidden under RFC 5280 4.2.1.1.\n\n> The keyIdentifier field of the authorityKeyIdentifier extension MUST\n> be included in all certificates generated by conforming CAs to\n> facilitate certification path construction.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUTcY1k47WJ0Moe1TdibIds2nvmO0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQ94ysQca/urdQZ+kvShOaMjwfYKuiKuJKfj3cX\nlwp6DYerZbXgFUtf+xkh484CqzUL7mqAxGCS43cZRK2ffxsPo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU7126ujPqaUzemtgVo/L0YwittYgwCgYIKoZIzj0EAwIDSAAwRQIh\nAJXd0BUXUA7GyP42KRxn3Aq3cuQLKH0rl3yJJorWJsk9AiAWoSSO9Je6fQEe1HGu\nIr0n0CkN3nGA7lsWhiRGuf3u2Q==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUaJY/dELGpIi8tctnsKHhPfKw0TgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABOOqmdJLzZ8iEOmQ2W63Xg075+gOzPpBYAqr4d5lyG/p\nL17FYHR68+aNQkZGxr7XQm9AyHlG3z+GMFXZRD6M3nejWzBZMB0GA1UdDgQWBBSY\nws0WN1Np3gPGc0owm6bNvOFUGDALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYB\nBQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIh\nAMhLRAolkuAEtpsZeMos+3sS/Wt17fZSwowAdQxcVoMuAiBXQrKUZ9cD/o/t1oUK\nJvvS6Xzq2heiu0z47hsthk0fXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIG4sb2OQUKaCyv8ORLHtM/oevf3GZ7/ytn7gvq8zMzy1oAoGCCqGSM49\nAwEHoUQDQgAE46qZ0kvNnyIQ6ZDZbrdeDTvn6A7M+kFgCqvh3mXIb+kvXsVgdHrz\n5o1CRkbGvtdCb0DIeUbfP4YwVdlEPozedw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::aki::intermediate-missing-aki", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate -> EE\n```\n\nThe intermediate is signed by the root but missing the AKI extension, which\nis forbidden under RFC 5280 4.2.1.1.\n\n> The keyIdentifier field of the authorityKeyIdentifier extension MUST\n> be included in all certificates generated by conforming CAs to\n> facilitate certification path construction.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUVGTtKKbmzzUsy1ZjVG4xlK9YKjQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARiAnUiJKE2fYu9HVe6h2o0OeRn9j76xS8PRTTU\nyv0lgV2JzF/YSJMb4KNODvqnvfmU3/Vsix6Bg8Ybg6TBpz58o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUifskk0zOx0Jf2Dc87/mavsGcUBgwCgYIKoZIzj0EAwIDSAAwRQIg\nMmqUuS4njqoGwSah0k47ZUNWrgKmh41/JMb03ymmTZQCIQDvkFwYUoUIh+ChE0uC\ngeCfTLKOLpfOz4LMcCNNvdsA+g==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB3zCCAYWgAwIBAgIUVcxvHFYi0vW2ru7wIijpliBHgLcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDA0ODE4MDU5NTg3MTM5NjYzNjQ2MTUy\nMzQyMjA2OTkxOTMyMzI2ODIzMzg3NTcxNzIxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBKzND+9SFEpm6gQA56jfCEfBaxcoPeoEPqkb6WZcvxnlXggUlArGtgyRDcUmad/y\nReMOf0BT5VVvjmHVuJHDMrKjWjBYMBIGA1UdEwEB/wQIMAYBAf8CAQAwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB0GA1UdDgQWBBRcCotmeFNL\nBfjrzmly+gs+rsNxvjAKBggqhkjOPQQDAgNIADBFAiEA4bo2xksiLJxvvAYYSNSm\nL39wLiGpJx4+tqv26iadbYACID0gl4+Sb6Du6iUtgRrvtJmL8++l71vtZqvewqUt\nrUm9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaOgAwIBAgIUBPhMSctVB7Dwh2d4SQwhXRBZqggwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwNDgxODA1OTU4NzEzOTY2MzY0NjE1MjM0MjIwNjk5MTkzMjMy\nNjgyMzM4NzU3MTcyMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjNA7\nLLCilQOM0HZXKfjdDTyze1+2d1xK1VpIAiVcZoICiABZYVDOjlqjNuEYDFVrHULT\nWHAahS5+XfhfhOhAiqN8MHowHQYDVR0OBBYEFNVxHDtHj+IINxie0LOEzafFFORT\nMB8GA1UdIwQYMBaAFFwKi2Z4U0sF+OvOaXL6Cz6uw3G+MAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBWatyNmUz88iUNW8icTfIArI3CmnWDm/lYxw/47sZWQAIh\nANyTZMewrwmJuPEeLmZnRANbSpMhL0yxyOKuKrv9uXtF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEINmaOO/jL7ExYlIxZT9w7agPqHEciERBRRblVJnOsWBUoAoGCCqGSM49\nAwEHoUQDQgAEjNA7LLCilQOM0HZXKfjdDTyze1+2d1xK1VpIAiVcZoICiABZYVDO\njlqjNuEYDFVrHULTWHAahS5+XfhfhOhAig==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::aki::self-signed-root-missing-aki", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert is missing the AKI extension, which is ordinarily forbidden\nunder RFC 5280 4.2.1.1 **unless** the certificate is self-signed,\nwhich this root is:\n\n> The keyIdentifier field of the authorityKeyIdentifier extension MUST\n> be included in all certificates generated by conforming CAs to\n> facilitate certification path construction. There is one exception;\n> where a CA distributes its public key in the form of a \"self-signed\"\n> certificate, the authority key identifier MAY be omitted.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUHa9kLKJURYonaDVC+IQf/KijSIEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQbke40UCA9eNf+qzfqn7JwdKAOZP4dtgG85U/x\nNb52+qCY9+sTSaDXdYPIuRDiWfDsLj9e0Kb9p2A6PngMKpPpo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU70s+hoVjPWaciMV+tUyZlJmmKtswCgYIKoZIzj0EAwIDSAAwRQIh\nAIVwfqhVLAINPgZpPOLJ0XUy/qPhg2ArVoTh+Sae3YY2AiAsef6iKHR9TaTssL8L\nBP5ZeXHnmeqXsdjQGI/vlm5S6Q==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVagAwIBAgIUKd8Hvr3r+buufeLy/92rr4svrfswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABFafYhzz7fXgCT9+294vLJBMWxrNOtfqtPYW34bnt4es\np1QNlfJmWT2hd4w301iMZRaIk7ylZgsZPOP2muMhtcijfDB6MB0GA1UdDgQWBBSK\nn9cntVsw0Q3qhZb9/8iROs/jMzAfBgNVHSMEGDAWgBTvSz6GhWM9ZpyIxX61TJmU\nmaYq2zALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAP7ndT8r6yR2wHrjXInG\nwg2KLZe/kPgYdANmxBKRG7xkAiEApl/QRV25cTXwgmhtoP86EQ9dERMD8hpivBLV\nIi78huE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIG/BUDFkFDNOGhaAztcBLH14XzSBpVjbGYnxk+mgfK4noAoGCCqGSM49\nAwEHoUQDQgAEVp9iHPPt9eAJP37b3i8skExbGs061+q09hbfhue3h6ynVA2V8mZZ\nPaF3jDfTWIxlFoiTvKVmCxk84/aa4yG1yA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::aki::cross-signed-root-missing-aki", + "conflicts_with": [], + "features": [ + "pedantic-rfc5280" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root is cross signed by another root but missing the AKI extension,\nwhich is ambiguous but potentially disallowed under RFC 5280 4.2.1.1.\n\n> The keyIdentifier field of the authorityKeyIdentifier extension MUST\n> be included in all certificates generated by conforming CAs to\n> facilitate certification path construction.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIB3zCCAYWgAwIBAgIUYe6HkGmwnwbpkDkovVadZABRj/kwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDA3MjUzNjIzMjU5MjYyMTA1MDM3MDky\nNDE5NDU2NzI3MDU1NTUzNzE2MzA1MDIxNDIxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBOyrjO36XBjQVJ98Ox9kDd7SrYw085UGxpYEGiwZH1kf2/KHFtASFvSwrFGu8Yhm\nDrrkuxugEVQuUwNOWzJjLmijWjBYMBIGA1UdEwEB/wQIMAYBAf8CAQAwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB0GA1UdDgQWBBTHRZLygGjZ\nIpRDtqrHKfpUGMaeDzAKBggqhkjOPQQDAgNIADBFAiEA1ARAQIrgUzwGGH7GxqjS\nkOENENcKajb1LIsm3KdrDWcCIH0RmPRjp3+G758UFLvVIqWdm3BpM4RusUb8y1C4\ntwxe\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaOgAwIBAgIUKXeVvcwAIwxrZfmT4YBfdzOiLZkwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwNzI1MzYyMzI1OTI2MjEwNTAzNzA5MjQxOTQ1NjcyNzA1NTU1\nMzcxNjMwNTAyMTQyMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkC1e\nJDD/CsCpmWLV1iyayH+E1YDpi2EBRS4vyis1NjbvnbClV3wD3n2ppGrYfiVaplxr\nU7MtpJoQssvIIfOWI6N8MHowHQYDVR0OBBYEFBtbKn/IHrqgTWNZo9LvsKWec4RH\nMB8GA1UdIwQYMBaAFMdFkvKAaNkilEO2qscp+lQYxp4PMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBILXVCt5vmCQ9Mpq9fvazzlMAa8KK1y9a7sMVZd31kNgIh\nAII07t6IKR1ZtDC5jeAsDJMmJSSCGTdXwhIrlziRBx1y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIEeeJNB/A4UYR2zmtLiyeObkyU+LSaOwUoenGuy8tZoWoAoGCCqGSM49\nAwEHoUQDQgAEkC1eJDD/CsCpmWLV1iyayH+E1YDpi2EBRS4vyis1NjbvnbClV3wD\n3n2ppGrYfiVaplxrU7MtpJoQssvIIfOWIw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::eku::ee-wrong-eku", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe chain is correctly constructed, but the EE cert contains\nan Extended Key Usage extension that contains just `id-kp-clientAuth`\nwhile the validator expects `id-kp-serverAuth`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUNv1ievT5XcYGW3BFZha9KKHNMQ0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATBQ5I3ITxr7VwII93XwdOEzQx9GTkG/x4chVt0\nJMhWjHvyJbPtdrFMmE6+CQ8zratfNSPXyspREomdo8gqjy2lo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU9F3FpSWFeRDHBVS6x6uVfB57tSAwCgYIKoZIzj0EAwIDSQAwRgIh\nALDE5JK9ceWoZwgFfNmCn60JF7zPDJJ+kIIIcUQoIYBcAiEAmrg5a+I0pNkHN8st\nBBVZw8Gd0HqWufNzFnJ19wrJP44=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUYCfmlAYuZFhh5DYhD9msSMGvG7EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABIEJ7TJ+3b9TN7Od4o8pc30Qq1G/r0lifZEdFXNP71lH\nCgvmNkuCGF4WLPTZcmfe1iO/DxGcR8Ji6RasSKiRa/ajfDB6MB0GA1UdDgQWBBRa\nE05HjyuiDK9dRqli1wHv75ATkjAfBgNVHSMEGDAWgBT0XcWlJYV5EMcFVLrHq5V8\nHnu1IDALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwIwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgR3WQ+pditRxHstLzCptb\n8K2u/hTiUwO4Xz3fOqn3NPACIQC8Fz5gx87bN/VZMQ7S+S0CkrqBZApN5xb4fK2f\nX2V2jQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICu5FK1sfPDBkm5AN87IxJGsqI1bVwOhh0m9uHisME7ioAoGCCqGSM49\nAwEHoUQDQgAEgQntMn7dv1M3s53ijylzfRCrUb+vSWJ9kR0Vc0/vWUcKC+Y2S4IY\nXhYs9NlyZ97WI78PEZxHwmLpFqxIqJFr9g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "serverAuth" + ], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::eku::ee-without-eku", + "conflicts_with": [ + "webpki::eku::ee-without-eku" + ], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> EE\n```\n\nThe EE is missing an extKeyUsage extension, which is permitted under\nRFC 5280 4.2.1.12.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUQj4GxdwbkqN0TJsqZu1IsjJGG9EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARyf8ZrEAToAJUJ4XPmrg3Q65Pcs5FGBWom467B\nmBYO1BC7YzGwOn11zX56sGcwObn8kYIVf4GIMsGeDLyccMhZo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUYuYzzSRaOAkLS+4MMnrNagZ50NAwCgYIKoZIzj0EAwIDSAAwRQIg\nAaorKWrR1NqDp37taaY2TEAXZFjInI7UZeU1Q6+jUUgCIQDKlsn5JypEtkjUT514\nn5WyNto9xST7QZHk/Pg7uW1X7g==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBmzCCAUGgAwIBAgIUZTib/Zkx5C6YN90FQMp4guq2dWkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABMuaFdYQnXoTPR8ZjgjCIYZB9npdbJgs7VmQsQW2Zvkg\nIiORfUvRZyurOYrTigPfwRFMTtnU+AyF2XmZVYYTbbOjZzBlMB0GA1UdDgQWBBRp\nlvnIgZ7CWixPpFUGdP8f1HFAwzAfBgNVHSMEGDAWgBRi5jPNJFo4CQtL7gwyes1q\nBnnQ0DALBgNVHQ8EBAMCB4AwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYIKoZI\nzj0EAwIDSAAwRQIhAJ959VMaONp50LM83sRiPS3fhcHWtimBECmE7/bmEn2DAiAV\n39+2LlJjz5my3Hj7uOZ+SSWEzf/MmRLnsN7tKV6imw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICz9ljWM2U1lQMJE4+nfHQVnMYTImASjT0HhE4+hgWxDoAoGCCqGSM49\nAwEHoUQDQgAEy5oV1hCdehM9HxmOCMIhhkH2el1smCztWZCxBbZm+SAiI5F9S9Fn\nK6s5itOKA9/BEUxO2dT4DIXZeZlVhhNtsw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::eku::ee-eku-empty", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE contains an extKeyUsage extension, but with no listed usages,\nwhich is forbidden per RFC 5280 4.2.1.12:\n\n> This extension indicates one or more purposes for which the certified\n> public key may be used", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUJBqevcj/fJLNz1lS5Ugko7MISOgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAS21WW4pwQZMpUCXpaSB9YSk9TMTpgh9XuUVsni\nv5HmhMFkmPkWtzLo9SpUA9+jsatWDL/EhnK8/0pfNamfxsZJo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUri41RBY3YAdv+4kFcVRy+SP3wOowCgYIKoZIzj0EAwIDSQAwRgIh\nAIWOoadk8mDS4ESGULxiljluq/NhOQinSliSfNIWZIfGAiEA9OPxLYetod6zFtWV\nxryyVmokLp9s+dwAGgnt04kAclo=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBpjCCAUygAwIBAgIUfAhcPJauTzjetbzwFf+Lt8udVBwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABI/MfzbydASmVt8GQr2if5IoUEh+Ay6c3tSUBe/73clQ\n6hgBT2d9t6uWoav8jiHLwJzZQQbVFKzNpjQIamgmMAWjcjBwMB0GA1UdDgQWBBRX\nqf8fWozpmf1NA0jh3wAppsG32TAfBgNVHSMEGDAWgBSuLjVEFjdgB2/7iQVxVHL5\nI/fA6jALBgNVHQ8EBAMCB4AwCQYDVR0lBAIwADAWBgNVHREEDzANggtleGFtcGxl\nLmNvbTAKBggqhkjOPQQDAgNIADBFAiAJgRgMo/ADQvG9vnqVfWL8GmqFzXVQVf33\nc9U17DnQIAIhANMBJZmN118FOWp8fgnpCGqoNfaEFYxbcHJ4R7tYEEmU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIG6B/sLxGsPKTcA/PpMpqJ0RvfnVhgP4Nk2d57PlP3tfoAoGCCqGSM49\nAwEHoUQDQgAEj8x/NvJ0BKZW3wZCvaJ/kihQSH4DLpze1JQF7/vdyVDqGAFPZ323\nq5ahq/yOIcvAnNlBBtUUrM2mNAhqaCYwBQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-dns-mismatch", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted dNSName\n\"example.com\", whereas the leaf certificate has a SubjectAlternativeName with a\ndNSName of \"not-example.com\".", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBrjCCAVSgAwIBAgIUH1AtefknHdpCNhkCn3QyA/YfHVUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAART6qncYqwv414Nt7YC+uVq6618SGBbWTg4fUY6\nJhYZkv+Zmqu4trfyFjflB7sa4n8gAlJ0FfO6CTuxFc0Cl33Go3YwdDAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU7pq5FobxysaLZQcyGpi/YdEJp8swHQYDVR0eAQH/BBMwEaAPMA2C\nC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDck9xTyA4Xhgn6pA10GHWV\nQNdP5oD93YbWQ9yZwprr1wIgMfwJalp+FEPKbgJ14Uoua4VWhaFOfrceA/jeqwUm\nOcs=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtjCCAVugAwIBAgIUUh31ClXBB4qJlh+dXVP9nYI/j2wwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABP7F0QKwGFkZkY3tYpRZeQjxfdkuywZvBU99pegrVFy1\nC3r83v2S4nYhcowI9FCN0eT2NcBAD1QFzsVISEGWxy+jgYAwfjAdBgNVHQ4EFgQU\n2caKc2qwP0MeE53kE3jjd0LRsdAwHwYDVR0jBBgwFoAU7pq5FobxysaLZQcyGpi/\nYdEJp8swCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBoGA1UdEQQT\nMBGCD25vdC1leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA0Y+XPmzegpMl\nFYQvZa4aHSw191WG6Jq0yg/bFXTFQjkCIQDl2cJxnjT7Yrrqklc6tqYz4JAlRxNd\noHSTpPM5pmxoFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIAiSxgu0NktX7Jp+SdKjyFBzuTQgfFSql1f1DNKpyxjgoAoGCCqGSM49\nAwEHoUQDQgAE/sXRArAYWRmRje1ilFl5CPF92S7LBm8FT32l6CtUXLULevze/ZLi\ndiFyjAj0UI3R5PY1wEAPVAXOxUhIQZbHLw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::excluded-dns-match", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> leaf\n```\n\nThe ICA contains a NameConstraints extension with an excluded dNSName of\n\"example.com\", matching the leaf's SubjectAlternativeName.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUK4UGWWk517GeIhab5I1BtRdLpGYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASVUihWe/I0mFNNJNr7kOaN5zxcer2rRLlHRL6M\nNbiD3ysaIwwpodVpHIQvr/Ryzs3DgCkoKONXpKxvGrmAKx22o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUgo1U2bGtyZT7+gLxK6Ofnzgksa0wCgYIKoZIzj0EAwIDSQAwRgIh\nAJLJVC6+cqbZwMR2Xyvs4ga4AytXPAqfktyXrxSt9ctFAiEAnUC2x1bhJqBv7nYh\nZA6TUiivNCu1tYGxfhoOpl9hO5E=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICIDCCAcegAwIBAgIURutc3LF2AAqVPtjepsZJiIjuSoMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAyNDg0NTMxNTUzNTU1NDUxOTQyMTM1\nOTQ2MDkwMjAzODM2MTg5NjQwMDg5NjkzMTgxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABFN9aXBHLB5ZoszZ63ynWg4W8Vu9j4uqaLqD+uduDJzhrjYGmZGawbyGPwlj\nPkvnxZ68r4P2quTOPD7wvgjGg86jgZgwgZUwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUgo1U\n2bGtyZT7+gLxK6Ofnzgksa0wHQYDVR0OBBYEFExju5cOPYOaegDPd/ZQEyVyHtpa\nMB0GA1UdHgEB/wQTMBGhDzANggtleGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBE\nAiBrIcrBlPTbp7jRQa5GfDx9907hXq/vtV642Y9IXRipOQIgfh0TCLfrxc3lw5Cq\nwtBfCkgEtkOPvzd4LlV879JPSyc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUMI6oniKnJU2G6ct0bJONkGaa77MwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMjQ4NDUzMTU1MzU1NTQ1MTk0MjEzNTk0NjA5MDIwMzgzNjE4\nOTY0MDA4OTY5MzE4MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvHPLHILPGsRsq94pkZtKweECbGhHKT+IuQiXGYJoteTk8WPQ2uPiZ0EFkKRQ0vKD\nIT0v7WbXTPmzhMCGYh3yP6N8MHowHQYDVR0OBBYEFHe2PrtPUBQEeyvAONIFMPGq\nn0t3MB8GA1UdIwQYMBaAFExju5cOPYOaegDPd/ZQEyVyHtpaMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNIADBFAiAqjaMV1JFUOjg0yt9vJ76JBSOuUmymyR8XAfSqeMpt\nHwIhALyWRIWvnIagLu7+Ruo4dsOHRm04M9ziaFFo2eR8XQqI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICIaXxp4oO6d0HkjTJP2Iko9NxPPEOAjwzlgUW00/ACCoAoGCCqGSM49\nAwEHoUQDQgAEvHPLHILPGsRsq94pkZtKweECbGhHKT+IuQiXGYJoteTk8WPQ2uPi\nZ0EFkKRQ0vKDIT0v7WbXTPmzhMCGYh3yPw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-dns-match", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted dNSName of\n\"example.com\", matching the leaf's SubjectAlternativeName.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBrjCCAVSgAwIBAgIUXtE6QvgA0Q/NgRJMVzVZRfsCjHMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQQmwLxft2WaQJDp+RShzL+zn/chh9pnRYejB6O\nZkqdVvGa2XO+A6qLf3BqIKsZ75nlUlA36PWSoYxj76YiPIHbo3YwdDAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUIrTY7dI1pWAtZYvCKX0QZChDEvgwHQYDVR0eAQH/BBMwEaAPMA2C\nC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCNgMpOozreAsSmJx+T1y2h\njR7tgRiH5nXmMKNMhnKqwQIgAOLXxcqLJ7G+0tXWnZCALKg1BoO4dust1cPdhIMK\n7z0=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUWvPODaGJuTRNvFpNY+hc5nu6sw4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABKNnLkisiVjYxUyd/RbjyrFkDrr623M/SPSJwOPwMOvz\nYKl5NuZpTX/jbvlmCdaMu/h3KR80TM/Lr9VoH6PlvamjfDB6MB0GA1UdDgQWBBRN\nu4g7Gby/5sMjoJOulq+xyvj2hTAfBgNVHSMEGDAWgBQitNjt0jWlYC1li8IpfRBk\nKEMS+DALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgJDhglmlE/zE9lqwx5Ibz\nEK0fI4MQBYR28yKiQWWHavMCIFRsrSEAlkO8hrT9+CgMhV4kvs4/E5uq39iE4b1P\ngEus\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIMWie0Ero29EPa47qT6wxXeoDeQZqikOnocf12+JOTq5oAoGCCqGSM49\nAwEHoUQDQgAEo2cuSKyJWNjFTJ39FuPKsWQOuvrbcz9I9InA4/Aw6/NgqXk25mlN\nf+Nu+WYJ1oy7+HcpHzRMz8uv1Wgfo+W9qQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-dns-match-noncritical", + "conflicts_with": [ + "webpki::nc::permitted-dns-match-noncritical" + ], + "features": [ + "rfc5280-incompatible-with-webpki" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted dNSName of\n\"example.com\", matching the leaf's SubjectAlternativeName. However,\nthe NameConstraints extension is not marked as critical, which is required by\nthe RFC 5280 profile.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBrDCCAVGgAwIBAgIUJpN7aw3Iz4NIRZZhEUwtVu/KRrMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASYAQR9EjDMVofeFEJg080MSCxHizdFIeYM06WF\nCevikzmjPMi3pTBCMLXXzQm8TvFSnUeNVVwPDJODdNBxhEzUo3MwcTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUr9OlcmN4Ziv+XF+BDmOcCv0xu+0wGgYDVR0eBBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDplvnXJEL7EP/Dr/xgpAy1F97d\nWHOuTRiE+YeCvwn18gIhAN2Q58Lu7tYDUbjh0xBhFSF5nI+fzdCg9rW6bPl+IzLl\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUReE6w05iaQJgcy5IMjZ5yfjLVNEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABBLtXaldeR+bnS7/NOE4N2bd6ykNMBf2jLAVHfA01dtz\nEzpcOswA8XmGQ/cwp0PjxgoaLjkcsPQC5iBKAHvadESjfDB6MB0GA1UdDgQWBBRa\ncLTU+p829ELpXDM+mXtNFZvX+DAfBgNVHSMEGDAWgBSv06VyY3hmK/5cX4EOY5wK\n/TG77TALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAMLoINvZ4/2ixqhSSa+o\n72Tp9Rf/w1aagdbW1aHgXI/FAiASqa3bF/A88GZlVFpsB21VClOZn6LkenZ5IHjT\n4JimpQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIHBwBN5D++Rs/ejocL0miVpQt7cjnqK3bETF7jXSs3bMoAoGCCqGSM49\nAwEHoUQDQgAEEu1dqV15H5udLv804Tg3Zt3rKQ0wF/aMsBUd8DTV23MTOlw6zADx\neYZD9zCnQ+PGChouORyw9ALmIEoAe9p0RA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-dns-match-more", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted dNSName of\n\"example.com\". The leaf's \"foo.bar.example.com\" satisfies this constraint\nper the RFC 5280 profile:\n\n> DNS name restrictions are expressed as host.example.com. Any DNS\n> name that can be constructed by simply adding zero or more labels to\n> the left-hand side of the name satisfies the name constraint. For\n> example, www.host.example.com would satisfy the constraint but\n> host1.example.com would not.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBrjCCAVSgAwIBAgIUAPrd7GQCPmeaAPdYg64+ld73wHcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR8VqxVrtYwIxQETWwEwFYmL7ExKPwx4mIVN3t+\nDzeJi6JuEPsMewgjNGNKZ7mpIlm2SpJKVmB1zfyI5hLeONcNo3YwdDAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUo7D4ES2kd0zKHHgeTwtoijDonA8wHQYDVR0eAQH/BBMwEaAPMA2C\nC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIF/9FqEvE9JH4sYBr/F+fb/f\noz8RKPryjgbBsZJ+dHLhAiEAnRQLE92KiQ80kopW8EjQS38UDiyMcvJcdFmdaio9\ncp0=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBujCCAWCgAwIBAgIUKNFTAUYW+w2baIVC9P9/crKJhz8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABJUrQsIvN2u8nKQXqbGUl3FI1Xujfkv7zZvipek7cjwh\nNKpeyBYJdCN6qTj4/3hb2wW764tGI/bNHJGwBzuetXSjgYUwgYIwHQYDVR0OBBYE\nFDTkks7cJ9IaZ4GQV6Z2AgTr7EBnMB8GA1UdIwQYMBaAFKOw+BEtpHdMyhx4Hk8L\naIow6JwPMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAeBgNVHREE\nFzAVghNmb28uYmFyLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCt9aWH\n8GsVMqtgVuzV5hOmh/h8F3MI4N6CweFIj/80CwIgbLf2Qj52YJ4MscFsSIIuFnwF\ndFE+LNXkXCFRMkanaJo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIJ3Wj/sJdrGbWbW2Z/5fM/AUnIrmXRM1gnF6CLgQ4jZ+oAoGCCqGSM49\nAwEHoUQDQgAElStCwi83a7ycpBepsZSXcUjVe6N+S/vNm+Kl6TtyPCE0ql7IFgl0\nI3qpOPj/eFvbBbvri0Yj9s0ckbAHO561dA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.bar.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::excluded-dns-match-second", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with an excluded dNSName of\n\"not-allowed.example.com\". This should match the leaf's second\nSubjectAlternativeName entry.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBvTCCAWKgAwIBAgIUIU2LZqt0wz/FTldIIur8kKo7FKAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARdnPUln3UGDRb2BsgmXsrhun52tCvL30R83GnB\nMTD76Zja+OetJYnEPDqR7BU+rASaPgroBR2HyOMpGF9LRKESo4GDMIGAMA8GA1Ud\nEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29t\nMB0GA1UdDgQWBBTtaRz8wZ0VCKoFhzBh+J97XEGPizApBgNVHR4BAf8EHzAdoRsw\nGYIXbm90LWFsbG93ZWQuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAKxP\nULtivZaIs97QeE0qlTdLnoJeESzpSqd3/AfAkOvGAiEAo0+u7LlSQkRLOZyoUH2Z\nwAS15PjTz1jhrNJkj7bV4UE=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIByzCCAXGgAwIBAgIUTQmSfLPZiR0FKz4I8QhUpc4DT9wwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABDa1/qzA87DsnGU6mAoga/TBa92rNsm6VWgjB3/TX85x\nzcJhchKAOxl/jRBVxi+2Il9EylDb2xGyXqejhC7wNCmjgZYwgZMwHQYDVR0OBBYE\nFH8IRePhifpGMTdJbgKIoq41lLZBMB8GA1UdIwQYMBaAFO1pHPzBnRUIqgWHMGH4\nn3tcQY+LMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAvBgNVHREE\nKDAmggtleGFtcGxlLmNvbYIXbm90LWFsbG93ZWQuZXhhbXBsZS5jb20wCgYIKoZI\nzj0EAwIDSAAwRQIgN3hF6X5Xt11x9F0u9Cow8mumHxwYjas7RerZ7GOZdQMCIQDR\nyh+VgM5MrLtUEdbWTtuQlH5Sjx1qUhAC1urbJeFtzw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIFmVLtXvyxzkUu0kOWqxcbmjph+OkYc7xKS7Y4pNUayLoAoGCCqGSM49\nAwEHoUQDQgAENrX+rMDzsOycZTqYCiBr9MFr3as2ybpVaCMHf9NfznHNwmFyEoA7\nGX+NEFXGL7YiX0TKUNvbEbJep6OELvA0KQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-ip-mismatch", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted iPAddress of\n`192.0.2.0/24`, which does not match the iPAddress in the SubjectAlternativeName\nof the leaf.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBrDCCAVGgAwIBAgIUBTTJGdWVhUd7idiCIzp+xdw6opowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARE8OVV4uYQVnFZh4BCM7t+N9zDw+Ngic9I74hU\nfMGH1+bZO6PPfabk7+Jc2M/xOUpQAH5mkL81vglkm0wVhVajo3MwcTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUQXSsaAG8NEF647/6mlZhNueSW6MwGgYDVR0eAQH/BBAwDqAMMAqH\nCMAAAgD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDt7vDm3iobH84aDR4NSK9MYtvg\nRERkLT/5zlwhJGL9uwIhAMu7oVdzmTReOlMfUZNFC4Yt2uDuAtdao92k3YRg4reg\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBqjCCAU+gAwIBAgIUEwaR+E7wXedI+NSxYgL/UFIQbV4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABIS/rTg1kEx0UnLm1LnYmnDQ2JkR66tZF8oKS5lvd7Oi\n3WUCmQRHCL63wsb0nZCJEY0bYQn6+Lu8wG/w/EUFqKOjdTBzMB0GA1UdDgQWBBRf\nFCmRMIAiscYCgfZfLK5Zy9EmkjAfBgNVHSMEGDAWgBRBdKxoAbw0QXrjv/qaVmE2\n55JbozALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDwYDVR0RBAgw\nBocEwAADATAKBggqhkjOPQQDAgNJADBGAiEAzpsvVxpjbRdwApKms8joHosxoZIx\n4BXrQ83ozLKyPjYCIQD56oTJwf6Y3yKNR6AXz+6uYMJED2/IykOhnlWP7mbh8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIENJ+NoprePC+4ege4q6pgxa4APhrRzP+SGKr3kuA7PRoAoGCCqGSM49\nAwEHoUQDQgAEhL+tODWQTHRScubUudiacNDYmRHrq1kXygpLmW93s6LdZQKZBEcI\nvrfCxvSdkIkRjRthCfr4u7zAb/D8RQWoow==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "192.0.3.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::excluded-ipv4-match", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with an excluded iPAddress of\n`192.0.2.0/24`, matching the iPAddress in the SubjectAlternativeName of the leaf.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBqzCCAVGgAwIBAgIUGb9Mvv3tZXpxUrP358AzlSCAnlYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARoxNKFOEIbooivIPUaxsNEfZvdxcHFHOxA0zAl\n7eCLAVjhe/FaQahb11NZXh79mU34bctsOVm9p2TJvKaAVoUNo3MwcTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUnMUPVs/IM3tEUJmHvmyfUVjtv7EwGgYDVR0eAQH/BBAwDqEMMAqH\nCMAAAgD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDMcKBKr6dtATjFSAnpn6wTHoig\n98NSOwlhOVyZXkrRCwIgIxndhJBynOlKCo36QEiv+Qsf7hvBu0mNq/XlWZISC64=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBqTCCAU+gAwIBAgIUO5IaqHixdze4G73QlDxWSARUyu4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABH8pFqAQDrUTKzR+Z+yiw+lQvbed3oWNOC0RV6GvD3o2\nH4oB3GvRV/8PcYIRB5bTTz75ei8eFTuYag7FSPAeUiOjdTBzMB0GA1UdDgQWBBS4\nxYZO2ePCUSkhDNWUoX68TVBHWjAfBgNVHSMEGDAWgBScxQ9Wz8gze0RQmYe+bJ9R\nWO2/sTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDwYDVR0RBAgw\nBocEwAACATAKBggqhkjOPQQDAgNIADBFAiEA8xXo7c4TGUW0sHT6FOxWOUwJnsyG\ntbD3l+U+/YWNzoECIHWZISltjb1pbo419z60+IwjFqFDwtyIEHYo/e8CrtDg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIHnNubaFe61FA2dOEe4sU17fVbU7U2am3lbVY/fNlLWEoAoGCCqGSM49\nAwEHoUQDQgAEfykWoBAOtRMrNH5n7KLD6VC9t53ehY04LRFXoa8PejYfigHca9FX\n/w9xghEHltNPPvl6Lx4VO5hqDsVI8B5SIw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "192.0.2.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::excluded-ipv6-match", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with an excluded iPAddress of\n`::1/128`, matching the iPAddress in the SubjectAlternativeName of the leaf.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBxjCCAWugAwIBAgIUNShMj3exdV47pwOOn6wVKAEBX0QwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR3guLQTkM3P2zq5UloDw9vN7jP8XnltYM7t64N\nxtyCtGH90SgN2xL6SiLrWBjVxh16vJhYVa89tN4bLhTUeCxZo4GMMIGJMA8GA1Ud\nEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29t\nMB0GA1UdDgQWBBQMEhsy8T1D8JoSpnT/pNdsUG7NPjAyBgNVHR4BAf8EKDAmoSQw\nIocgAAAAAAAAAAAAAAAAAAAAAf////////////////////8wCgYIKoZIzj0EAwID\nSQAwRgIhAJoY2iioZKG7wayXt3CPlmVj5th+p/ZTEK0sKPDbucaIAiEA6E8yhooc\nd+FsDloEoeJGBvfERHvnKNV6zJRko2uR4uA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtjCCAVygAwIBAgIUMjxVmLC6YZ4WM/NdteV0xBMenFQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABAMmpSqd7pbZLJAJzalamytCa11zikDOpO1M5W+CLBN8\nGgokUJ9QDNS4IYPlQR8ywoK2Xnr+8zoA8hlfXKHDvCOjgYEwfzAdBgNVHQ4EFgQU\n6LmK8yBtRgdqaJF63XeptFp2XZgwHwYDVR0jBBgwFoAUDBIbMvE9Q/CaEqZ0/6TX\nbFBuzT4wCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBsGA1UdEQQU\nMBKHEAAAAAAAAAAAAAAAAAAAAAEwCgYIKoZIzj0EAwIDSAAwRQIgVJDw8J2VH1I0\nMdNGQ9IeON5gVB7lXGO+gbVJSZkaLNcCIQC4M8dxou2841s7A4hwk0jn4Vl9gLHX\nOKxdpVBIqaeyhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDWsUD1aHFmrcYHTARB9EiGSMr2YN569ys8d233sXl1NoAoGCCqGSM49\nAwEHoUQDQgAEAyalKp3ultkskAnNqVqbK0JrXXOKQM6k7Uzlb4IsE3waCiRQn1AM\n1Lghg+VBHzLCgrZeev7zOgDyGV9cocO8Iw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "::1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-ipv4-match", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted iPAddress of\n`192.0.2.0/24`, which matches the iPAddress in the SubjectAlternativeName\nof the leaf.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBqjCCAVGgAwIBAgIUZhWNrk1buorg+CWO+U2SLrqR3XgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQLTa9xQQrEXTgpM2ZhA4/R5Ee4P6Nvyxw2bMno\n6RuOnk6JLQzUbFHxIR/gDfe4LPjnJyMxzH/1M7Ix2WF1/2P8o3MwcTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUZZc8fpml5dDNj/l8RoLOWcq/9oEwGgYDVR0eAQH/BBAwDqAMMAqH\nCMAAAgD///8AMAoGCCqGSM49BAMCA0cAMEQCIBrM+WEgDAzaHPP/7BMEjMkduqfG\nZ9fDfYU+Z5xsMbvFAiACGYertzhdKT3ZQ1jQDgD8wN4/C6VAiLiiovp1HrWyWA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBqDCCAU+gAwIBAgIUBdwXgRRxEQqqB1OrAKjKb/pGhPwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABIlwcTMUZ/s8l5dgORuqHxgq3964ARnIyJqayNIEDPCi\nTANwpnj2H0PeVDdf6s8kSmHpXEbrMD7xYM6epH/+DPKjdTBzMB0GA1UdDgQWBBTE\nMHhzvkM+q5xnL0CqfxL7SW4G4zAfBgNVHSMEGDAWgBRllzx+maXl0M2P+XxGgs5Z\nyr/2gTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDwYDVR0RBAgw\nBocEwAACATAKBggqhkjOPQQDAgNHADBEAiA0Zg9VNo98vdh2uyA49uxJcBZK0/kx\n3jq75APb1Upv/gIgUGh/k8d58Iylqo5+DpsMitPc0MvhavvNQy5RsdxnjsE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIJhi/hTawQfTsygZuhtkmsVBQoXZSFnyzwDFWs1BC5OKoAoGCCqGSM49\nAwEHoUQDQgAEiXBxMxRn+zyXl2A5G6ofGCrf3rgBGcjImprI0gQM8KJMA3CmePYf\nQ95UN1/qzyRKYelcRuswPvFgzp6kf/4M8g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "192.0.2.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-ipv6-match", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted iPAddress of\n`::1/128`, which matches the iPAddress in the SubjectAlternativeName\nof the leaf.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBxjCCAWugAwIBAgIURtkMUVIr5afS3XZFnt3Sir5sZCEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARQKPOhpba9EJQ77yBHxn2sTqmcFVYV91f5JaTc\nQhkWmPDuagp+Z6pAwP+F4EL8FbFwQmBKt+ZrI0GR8UE9Gzvyo4GMMIGJMA8GA1Ud\nEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29t\nMB0GA1UdDgQWBBRPpf7/9HkRw7eJ8x2+b7Io/2z56DAyBgNVHR4BAf8EKDAmoCQw\nIocgAAAAAAAAAAAAAAAAAAAAAf////////////////////8wCgYIKoZIzj0EAwID\nSQAwRgIhALRGvrJsoi216UEu9xbF6YL1BM9anm96vtAo/u6O8OTdAiEAvks5IYP7\n++T8aGU1ctLZFNfHBLMrK8p2IjKqaZKfzKE=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtjCCAVygAwIBAgIUNsMVzLYb5Db/nJh5Mesed+ACUhswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABDCf/f6ph1bCy4xhXD+/CUYEXWmwF3khtJnZVsOdJgI3\nPC/nAJQgcg9YqS4TpJAJ5E2hJZFC6qr2ECojLSPdwO2jgYEwfzAdBgNVHQ4EFgQU\ne1IYCntB9pLOJ/TsmmZExLNZ7VUwHwYDVR0jBBgwFoAUT6X+//R5EcO3ifMdvm+y\nKP9s+egwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBsGA1UdEQQU\nMBKHEAAAAAAAAAAAAAAAAAAAAAEwCgYIKoZIzj0EAwIDSAAwRQIgVKUoZR4ssbst\nogbZyM1RxGj3rS1zCxxktqqLG2YkoZkCIQC+9wT7ccQNE+edW4O8LjObMKVZKLEw\nnxgBjb9y/oenTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILonmPczTxttWQrRUXtnGNbVjSjParis8ZLbrtQVCfz7oAoGCCqGSM49\nAwEHoUQDQgAEMJ/9/qmHVsLLjGFcP78JRgRdabAXeSG0mdlWw50mAjc8L+cAlCBy\nD1ipLhOkkAnkTaElkULqqvYQKiMtI93A7Q==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "::1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-dn-mismatch", + "conflicts_with": [], + "features": [ + "name-constraint-dn" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted DirectoryName\nof `CN=foo`. This should not match the child's DirectoryName of `CN=not-foo`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBszCCAVmgAwIBAgIUN53iWijAR50OlKGnhOj7XuntcWAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASz9+DEMsS5v59Jlkso1eA0UcvGhDj38E4r9LnY\nVWSb+5f/pF01VMd1HnJ+a2zd1EW7YzdJgU4IWpqlTM1JwxK2o3sweTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUOSm06gYkxnsmT3Ud65KjwcW+8OIwIgYDVR0eAQH/BBgwFqAUMBKk\nEDAOMQwwCgYDVQQDDANmb28wCgYIKoZIzj0EAwIDSAAwRQIhAIceUATFxocUmOds\nZNgIBoM642XgPT2MinrRmSHa7mQUAiAD7lBodDZ8aRl1YLYHwKXE7cQgst1OQkLX\nhfLctuK+2w==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBuDCCAV2gAwIBAgIUA2ZwK5E8Zs++BZgNzUH8TAx98HAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjASMRAwDgYDVQQDDAdub3QtZm9vMFkwEwYHKoZIzj0CAQYI\nKoZIzj0DAQcDQgAEZKrQxHOB5KcIBWuoko1GBgV6CnI2CNTIkoBo0BYt1CjSADho\nLTh10IO0CSQnCgTMvZwlanUUj3erizxbd8u3PqOBhjCBgzAdBgNVHQ4EFgQUTqm3\nNZZpfFLTteTZHesKSREwJu4wHwYDVR0jBBgwFoAUOSm06gYkxnsmT3Ud65KjwcW+\n8OIwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMB8GA1UdEQQYMBak\nFDASMRAwDgYDVQQDDAdub3QtZm9vMAoGCCqGSM49BAMCA0kAMEYCIQCo/YSUrhJS\nnPO4QhmGShkOQbPSBKC/aj4T3RcYt6QV1wIhAI1/10/xbxOPt/BiPoqD6dYNl3bs\navyySUQSL+41aFv2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIbSWSkqwoPoFV58nzzoGnUkWMSNND5PvEqrBqirniGNoAoGCCqGSM49\nAwEHoUQDQgAEZKrQxHOB5KcIBWuoko1GBgV6CnI2CNTIkoBo0BYt1CjSADhoLTh1\n0IO0CSQnCgTMvZwlanUUj3erizxbd8u3Pg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::excluded-dn-match", + "conflicts_with": [], + "features": [ + "name-constraint-dn" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with an excluded DirectoryName\nof `CN=foo`, matching the leaf's SubjectAlternativeName.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBsjCCAVmgAwIBAgIUHynIJnziL7p6sn4vJWGxe6C/UY4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARJz/x8Vslsus77PQKSZV6h9J/fj4bMpar+mQp/\nFJBSuMoxuNPGj+hkxWNtG1Rch6uwq+HKoeMkQqvRXFItklSHo3sweTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUneRvxdVjJp/gMMuPNdXYnK7w+IwwIgYDVR0eAQH/BBgwFqEUMBKk\nEDAOMQwwCgYDVQQDDANmb28wCgYIKoZIzj0EAwIDRwAwRAIgZh4IHEW0bKYfOVJV\nQ8kvhAm6jgroZLxwSJQqTuYDjgUCID8Q5kEZ1LuOQb2Fi25LK3g5abQjzoq4R4/L\n4iUbXLVk\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrTCCAVSgAwIBAgIUXQbwzIV7erIkxqfsQq0eEW6KYQcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAOMQwwCgYDVQQDDANmb28wWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR4FJfXsxfhvLwgnMI10fYPpWVex2++MS2exfgQhVuvBznTJnamByEj\nOXtd4VRk64mWwbnGfvHkpjWQoLfQzSw7o4GBMH8wHQYDVR0OBBYEFIPMMtDort47\nZ3Fzy7ZnIUMVRMQjMB8GA1UdIwQYMBaAFJ3kb8XVYyaf4DDLjzXV2Jyu8PiMMAsG\nA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAbBgNVHREEFDASpBAwDjEM\nMAoGA1UEAwwDZm9vMAoGCCqGSM49BAMCA0cAMEQCIEHpR/YzdMSTj9GkFZs+3qzk\nmzA4tVChEatiRto16viEAiByBsJY/2iYmlR6jQL8LQMdWtmHEcy6ymxyylZhOsZb\niA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIN94JYhFa+3Z3uvI6ZjyNA10fWozw0uAZl801g45wdtioAoGCCqGSM49\nAwEHoUQDQgAEeBSX17MX4by8IJzCNdH2D6VlXsdvvjEtnsX4EIVbrwc50yZ2pgch\nIzl7XeFUZOuJlsG5xn7x5KY1kKC30M0sOw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-dn-match", + "conflicts_with": [], + "features": [ + "name-constraint-dn" + ], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted DirectoryName\nof `CN=foo`, matching the leaf's SubjectAlternativeName.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBmzCCAUGgAwIBAgIUXKak4o3cu0f3GlxQ+/NJ+1zUaMEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARSZRK7sI7wkF/yijCXmgzG2I4pyRYtDEWNkiWs\nMiCiVtWLppd3SMqsBKYV1y/RE+9OEICOybRnqisHnq9JB03Zo2MwYTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQU7M5XYac+TcpuOEJgpUWO\ndcbLXpkwIgYDVR0eAQH/BBgwFqAUMBKkEDAOMQwwCgYDVQQDDANmb28wCgYIKoZI\nzj0EAwIDSAAwRQIhAIgoH9RTYllpwFrUUoiUkLHz1uS23hISX2xaDbIecrWhAiA3\ndmuhExdNKvKX4B14qptAzYJSZqclvBGjtGR6qyeH7g==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrjCCAVSgAwIBAgIUPFzUcJhd3EzAfGTBWaB/vxnz240wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAOMQwwCgYDVQQDDANmb28wWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATV1UJP7eA5ZpvWaHPFjTuU871a+LuHb3vgB6hie4O5IJkSPLsNp5vq\npyEHFuTtJyW0t34yVbxG951+2R1tvuzho4GBMH8wHQYDVR0OBBYEFNrzHsNpRXqQ\nAisjJeb2Ut58lHwEMB8GA1UdIwQYMBaAFOzOV2GnPk3KbjhCYKVFjnXGy16ZMAsG\nA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAbBgNVHREEFDASpBAwDjEM\nMAoGA1UEAwwDZm9vMAoGCCqGSM49BAMCA0gAMEUCIQDXMqLkMtadkbTycjG5hZF0\nUBrGi13ObalE8iND+7E9eQIgQjI4q4Vc17XcweoZfsuLyet06AWblW2Muwd5WHvh\nQqA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIErPD4Ubn52q5jr7CtDrpI44+q9K7al3fIsKOxwe6k8LoAoGCCqGSM49\nAwEHoUQDQgAE1dVCT+3gOWab1mhzxY07lPO9Wvi7h2974AeoYnuDuSCZEjy7Daeb\n6qchBxbk7ScltLd+MlW8Rvedftkdbb7s4Q==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": null, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-dn-match-subject-san-mismatch", + "conflicts_with": [], + "features": [ + "name-constraint-dn" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted DirectoryName\nof \"CN=foo\", matching the leaf's SubjectAlternativeName but not its subject.\nThe leaf must be rejected per RFC 5280 4.2.1.10 due to this mismatch:\n\n> Restrictions of the form directoryName MUST be applied to the subject\n> field in the certificate (when the certificate includes a non-empty\n> subject field) and to any names of type directoryName in the\n> subjectAltName extension.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBsjCCAVmgAwIBAgIUTFcrzDUZEWTwCir8rFammxFJIQcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASS6oQkHacFtbkrtH0vhe9U0yUagkx+36RD6kai\nANDjVBDXCFxUVGjtBxLOmtjnkU4J/LZnarV0qGEe89Bsy0T0o3sweTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUR01o+cYDwpBcs4cN/Ta/xYYocOcwIgYDVR0eAQH/BBgwFqAUMBKk\nEDAOMQwwCgYDVQQDDANmb28wCgYIKoZIzj0EAwIDRwAwRAIgau/ud68dT24VbEgN\nHHC1P5adIhWDFpsYI7sUdw4nJ8ECIA9BPhWDoc9yjIMK0d4ULdqAGc6S/u15rI6f\nnhQI+mtq\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsjCCAVigAwIBAgIUA+S/yVHrrMlPNYvhwjtKOCu2CYIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjASMRAwDgYDVQQDDAdub3QtZm9vMFkwEwYHKoZIzj0CAQYI\nKoZIzj0DAQcDQgAEfKqypK6OuhDJCWu40LQ4QK+sQXkhAHSAX+WcHDtOHb/ajy5V\ni7dEMZR1GeCtMdgshouFYvaoj+xD0ze3v5FSFKOBgTB/MB0GA1UdDgQWBBQ0EuQx\n+wGJqNz5JMuKpepwYeCXbDAfBgNVHSMEGDAWgBRHTWj5xgPCkFyzhw39Nr/Fhihw\n5zALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwGwYDVR0RBBQwEqQQ\nMA4xDDAKBgNVBAMMA2ZvbzAKBggqhkjOPQQDAgNIADBFAiBYUnh235S8s9dZpKL/\nwdnMvohutRd0w1SfSiua2T45QgIhAKklMUJKFEpMdPYLsSf7ZjjJCZfJhzTg/eEB\neS/ZcrV7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIELPMTu+g+QN0O9FfHJJr2hnRhbHmEOM6OeC78nvk0xyoAoGCCqGSM49\nAwEHoUQDQgAEfKqypK6OuhDJCWu40LQ4QK+sQXkhAHSAX+WcHDtOHb/ajy5Vi7dE\nMZR1GeCtMdgshouFYvaoj+xD0ze3v5FSFA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::excluded-dn-match-sub-mismatch", + "conflicts_with": [], + "features": [ + "name-constraint-dn" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with an excluded DirectoryName\nof \"CN=foo\", matching the leaf's subject but not its SubjectAlternativeName.\nThe leaf must be rejected per RFC 5280 4.2.1.10 due to this match:\n\n> Restrictions of the form directoryName MUST be applied to the subject\n> field in the certificate (when the certificate includes a non-empty\n> subject field) and to any names of type directoryName in the\n> subjectAltName extension.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBszCCAVmgAwIBAgIUA7GMIbkmjlCX/RDm3FRKiA9xw00wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQSozRXTklbLai1ebFZJNSeYVNKEgj7kI05rVVq\nTYWfGn0BjoOnwwDBP3VG5Be0c890PLxh+LxUqegm0AXMNTfao3sweTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUWe0y4VmjqhGhfQ6IUoJSVkeLHMQwIgYDVR0eAQH/BBgwFqEUMBKk\nEDAOMQwwCgYDVQQDDANmb28wCgYIKoZIzj0EAwIDSAAwRQIhAK9GPJ1Uo+7DqEE3\niK0lD9obOsOOxmMOzBqAg6WOsAFiAiA3tkCsoFoo/+pzdfFXhVsfUn2EkVQwGJyt\noUNKJqRPaA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsjCCAVmgAwIBAgIUVF8oukmyGlPM40XyPjsPQOGNKqgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAOMQwwCgYDVQQDDANmb28wWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATWFRnUuJ0h1l719gXIJAxPVDBtFEFJiSyL0PcwsSj3PRoQ7oHUDwhV\nWkT1N+pmEV2oLY2ElSL8ucY0dmFaPu6Zo4GGMIGDMB0GA1UdDgQWBBS5tDlfVAOc\nZi9hOO5NG8CG88RK/TAfBgNVHSMEGDAWgBRZ7TLhWaOqEaF9DohSglJWR4scxDAL\nBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwHwYDVR0RBBgwFqQUMBIx\nEDAOBgNVBAMMB25vdC1mb28wCgYIKoZIzj0EAwIDRwAwRAIgPZ1jLhx//WIUu7HO\nYaEw605e6KPABfuzzQjn1wUzd8wCID1qPT42FPPANk57A1Ej2L+tLhDxQGHbZ0Hn\nEHMuYbTO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIPpkJp/MPlydljBTDSRAZIJR7wc9vdHnOqVn4OQSisODoAoGCCqGSM49\nAwEHoUQDQgAE1hUZ1LidIdZe9fYFyCQMT1QwbRRBSYksi9D3MLEo9z0aEO6B1A8I\nVVpE9TfqZhFdqC2NhJUi/LnGNHZhWj7umQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-self-issued", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> intermediate -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted dNSName of\n\"example.com\", whereas the intermediate certificate has a\nSubjectAlternativeName with a dNSName of \"not-example.com\".\n\nNormally, this would mean that the chain would be rejected, however the\nintermediate is self-issued so name constraints don't apply to it.\n\n> Name constraints are not applied to self-issued certificates (unless\n> the certificate is the final certificate in the path). (This could\n> prevent CAs that use name constraints from employing self-issued\n> certificates to implement key rollover.)", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVigAwIBAgIUPlvxe6tl9dVtoaynCg5mMB/rRsAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPbm90LWV4YW1wbGUuY29tMCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA9ub3QtZXhhbXBsZS5jb20wWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASP9jQutL5RoJLmxnhuXbSx7UZ2HoG3dA0m0K5K\nvfraCFJJT7s/qvIKudQeu7MvlEez7/AWRZeb4Pqxcl1txVCNo3oweDAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAaBgNVHREEEzARgg9ub3QtZXhhbXBsZS5j\nb20wHQYDVR0OBBYEFKOHgLOHk2yHLkw8LbUns193+x0uMB0GA1UdHgEB/wQTMBGg\nDzANggtleGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAD2vMdSBoEPW4/+2iU\nmNPkni/fzkfemOe675FOpGS+DwIgOvcAFXgDN8ao1Oa87HX360rYmWPp1ey6Nk5D\nSjH6PPw=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBtTCCAVqgAwIBAgIUa+yiwddQia10ybK+uZJsuAxKA84wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPbm90LWV4YW1wbGUuY29tMCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA9ub3QtZXhhbXBsZS5jb20wWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATW80jUA07bjuc2HoR+3+HHZXB5gy+/tN6Bg9X3\ntvlNMoWxpQfEYAeFLsJDfjctCjifpU+EHGtYzHFclbvRc6x9o3wwejAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwICBDAaBgNVHREEEzARgg9ub3QtZXhhbXBsZS5j\nb20wHwYDVR0jBBgwFoAUo4eAs4eTbIcuTDwttSezX3f7HS4wHQYDVR0OBBYEFCvj\nwE8vYt4zyNkljAmXzQYXW6wuMAoGCCqGSM49BAMCA0kAMEYCIQCh8kri8mLEQALz\nOZBg/biV+ZLWykeeYwThWRiZUMHB2gIhALiNDWD2G04zYCZ1VuSaCI2QjQWajNqR\nyfS2G2pt+/be\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUaHUHsQ/H6nL6ATMGvDi86iYASD4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPbm90LWV4YW1wbGUuY29tMCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABJykJLCCS623UlZzQVEotnrYGPuF73NeCQbVSQ1+g/mo\nlpjIXrYAZcJVg50LPFJdo25S3kSdXQOsyvlekWuvMGqjfDB6MB0GA1UdDgQWBBRm\n9II3J489p3OrrQ/LItwzTm5XojAfBgNVHSMEGDAWgBQr48BPL2LeM8jZJYwJl80G\nF1usLjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgS3Rg0FHWwVciJv46N+gz\nQonyG86ciO7VsnQvFgYyYZ8CIQD4NWXkntUPE1H7E7Uewp/di283yqLovGAlPMw7\nHMljQw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIChT8Wx5E1Dibvc6VBVa3XLmf7ju96t3JRkC9zTPIs9/oAoGCCqGSM49\nAwEHoUQDQgAEnKQksIJLrbdSVnNBUSi2etgY+4Xvc14JBtVJDX6D+aiWmMhetgBl\nwlWDnQs8Ul2jblLeRJ1dA6zK+V6Ra68wag==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::excluded-self-issued-leaf", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted dNSName of\n\"example.com\", whereas the leaf certificate has a SubjectAlternativeName\nwith a dNSName of \"not-example.com\".\n\nIn this case, the chain would still be rejected as name constraints do apply\nto self-issued certificates if they are in the leaf position.\n\n> Name constraints are not applied to self-issued certificates (unless\n> the certificate is the final certificate in the path). (This could\n> prevent CAs that use name constraints from employing self-issued\n> certificates to implement key rollover.)", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBrjCCAVSgAwIBAgIUHH7I6xK7jgR1BqLcr2rOK29q20gwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAS/NeTvAhpqZBrVDfMsPMa6FPMj7wlW88z4JfIc\nUwfd1T0riz3cbBgrCKsybJ+2nWuRDBWX8F5YSmCLimaW2VwPo3YwdDAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUFlEsQKbMmRjE2aJ7OqkiqpL8YNswHQYDVR0eAQH/BBMwEaAPMA2C\nC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIC8GtIhSEFBdarGSufz9B7hn\n1UR0rMj881kh/INsusbiAiEA8sKOAWu0R/ub/WrpIs+b1dxgfJCfO14oLUiOBGEM\nKMU=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBtTCCAVqgAwIBAgIUVQM9VIrwxTocY7i5XMjhg1xgM1kwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA9ub3QtZXhhbXBsZS5jb20wWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASbcSLAbIpaq94R99FCelJ8Ff1t4bg2m7DGTQn3\n30cCzNo8rBu2yjIasaHHCtuyd4lOiOWeCEjAXhzsVEPztYdIo3wwejAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwICBDAaBgNVHREEEzARgg9ub3QtZXhhbXBsZS5j\nb20wHwYDVR0jBBgwFoAUFlEsQKbMmRjE2aJ7OqkiqpL8YNswHQYDVR0OBBYEFA3Y\nFhAA0LvDRepcgRf5msHlEW9UMAoGCCqGSM49BAMCA0kAMEYCIQD8DHBDd/CKnAEF\nE2sxVlQFco6bvUulL/rf0z3wxJIQ2QIhAOfpzNBtpJqjNnug4zuAKEOCSGPmVc/2\nlwLSDNRN+fft\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBuTCCAV+gAwIBAgIUTXVtRAzjmOlO/Z9Fg53pDtin//gwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPbm90LWV4YW1wbGUuY29tMCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA9ub3QtZXhhbXBsZS5jb20wWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATFHVQf/ymo+xwGU2HXXbIQELnbIbBjRwS42XFd\nwXQFl9Uk4YRU0nFEXVP+q3G4dbmYQvaaYkBk23aUsEFIhzIpo4GAMH4wHQYDVR0O\nBBYEFJuSHAK9uD3Ol7ZWIjAwV6KWccrkMB8GA1UdIwQYMBaAFA3YFhAA0LvDRepc\ngRf5msHlEW9UMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAaBgNV\nHREEEzARgg9ub3QtZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgUK+wlhs1\nx5zv69ayDF7eJlgkv8QdjA/0B3pF4d8v6nkCIQDCvZdFM3CgIsUPUMJNM1s1AptL\nwOWdkwK6z6dxBzlzeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIPH7uHDUBUrzqxH0jCSbli9+hIWGAjE3DZ5NE0kGg5zsoAoGCCqGSM49\nAwEHoUQDQgAExR1UH/8pqPscBlNh112yEBC52yGwY0cEuNlxXcF0BZfVJOGEVNJx\nRF1T/qtxuHW5mEL2mmJAZNt2lLBBSIcyKQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "not-example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::excluded-match-permitted-and-excluded", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted and excluded\ndNSName of \"example.com\", both of which match the leaf's\nSubjectAlternativeName.\n\nThe excluded constraint takes precedence over the the permitted so this\nchain should be marked as invalid.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBwDCCAWegAwIBAgIUaMxPaWWc543WQnlnO7uAEVo9RTcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQF+r0fxiVV+BuGWv1lh8tIUnn5/+uhYybXgBdf\nNWbY0giQpTcOEPtZX2WNnYG7OcT3zXhls9neQ/+rAtxMeymuo4GIMIGFMA8GA1Ud\nEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29t\nMB0GA1UdDgQWBBTTHitiFkVg2oAdoa9XUj5RJvKjnTAuBgNVHR4BAf8EJDAioA8w\nDYILZXhhbXBsZS5jb22hDzANggtleGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBE\nAiBcmN1sKH4OTYv2Du75m9pAd3yCNszjy+zBnC1mTmOA4gIgBj0i1H8hJmIJJUBc\nol1hI50iu8eqlwwKJtRbPwcJkxw=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUFY2eHMq7SEcBbGmHMgRx71ULIWcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABIsUMJyoxm24R5YFvMZ67C6faR5+oCGW8ksB8/aYSta7\nE2zWoOCtrTNQM/WwuShOLUgE9HBOP0qoHp+Wb9uIq86jfDB6MB0GA1UdDgQWBBTL\nsIh1CJ732YzchkJsnEdsGuMCdjAfBgNVHSMEGDAWgBTTHitiFkVg2oAdoa9XUj5R\nJvKjnTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAPb58SmArQzQ0vgYsvyc\nOFe0SNm7PFKd3dHH691SiCooAiB1VlwkUwRowvgvEdOS1hvMjVIIK21md3rZoOZX\nprUqbQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIPcXl3241dGGX5Z5Z1/C4rnWYSgSuNajYWPrV96X79WLoAoGCCqGSM49\nAwEHoUQDQgAEixQwnKjGbbhHlgW8xnrsLp9pHn6gIZbySwHz9phK1rsTbNag4K2t\nM1Az9bC5KE4tSAT0cE4/Sqgen5Zv24irzg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-empty-sequence-excluded-nonempty", + "conflicts_with": [], + "features": [ + "pedantic-rfc5280" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> leaf\n```\n\nThe ICA contains a NameConstraints extension whose permittedSubtrees is\npresent but empty, alongside an excluded dNSName of \"bad.example\". The\nleaf's SubjectAlternativeName is \"example.com\", which does not match the\nexcluded subtree.\n\nAn empty permittedSubtrees violates RFC 5280 4.2.1.10, and permits nothing:\n\n> GeneralSubtrees ::= SEQUENCE SIZE (1..MAX) OF GeneralSubtree", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUeYJXLuyaMzdC6c+RR2g7dIIut2IwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR8WsTYf7YwzF6/VCgMPYjOr12YURfMeSfv8Fix\nHjsxYaYrTipMyx1gFU35VYj2ojisCLVI03xoN4CgnQ/advPLo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU0L73fsQPvrTAi0bqUm8snTWTrqowCgYIKoZIzj0EAwIDSAAwRQIg\nTL5jpSbdBF0S2qIFRjot3FE8UjW8hqqi0isrA6gQwYcCIQCDJSJd9JQBShc17t8N\nulnaK+Mzx315bEnM+0EDKs2sAw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgIUWoVSw9c6WJM/rNMQ38ZhVlO02dYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA2OTM2OTQ1NzQ4ODE4NTY5NjQ0NDc4\nMzk1MzI3MzcyNzUyMDI2MDc0MDc2MDk2OTgxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABEX6xJOVz0ZgaH5cspIRgOq6uDxNH58bF3IyBPie3K00a/X63i6U7aiPHrw4\nifc0rzKGEtyRKjzutfeOBNlNDmSjgZowgZcwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAU0L73\nfsQPvrTAi0bqUm8snTWTrqowHQYDVR0OBBYEFBstuD2iEQElDhOJT0/ZynK64Axg\nMB8GA1UdHgEB/wQVMBOgAKEPMA2CC2JhZC5leGFtcGxlMAoGCCqGSM49BAMCA0kA\nMEYCIQCZEugaB+5Ri5vEM+1nNpdMd4Zgus3QSWV1e0k6YyvRQwIhANDEsc/nzLJr\nStSAsrIukNIZWORDg/xmv0H78Srl4xDw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUR7QkBcp0w1vriUYL2f4NcUmGKlcwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjkzNjk0NTc0ODgxODU2OTY0NDQ3ODM5NTMyNzM3Mjc1MjAy\nNjA3NDA3NjA5Njk4MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2TIvQOFlvTTKkgE6tW0LL7Axo7mY/rfx4zsPei0aiDPWV4GR5ZVrLeSarbXE6CXu\nkQkUEF7zIdwyK7c1XgF29KN8MHowHQYDVR0OBBYEFGPNJhtp45bGRNPhrc1JaE/F\nvk99MB8GA1UdIwQYMBaAFBstuD2iEQElDhOJT0/ZynK64AxgMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNIADBFAiEAp0mfQO8WrJ87KKLKNOtfrqwC3yAAxGLwUDsnUXk2\nd/oCIAMxAwwQkhOI8s+iwLSzpSySEAelr8cjWK4O3qXZ/XrX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIF0niQ5Ki29mAAGpBAfmbSJa7Kz2pruv8C9dxBOdBeZroAoGCCqGSM49\nAwEHoUQDQgAE2TIvQOFlvTTKkgE6tW0LL7Axo7mY/rfx4zsPei0aiDPWV4GR5ZVr\nLeSarbXE6CXukQkUEF7zIdwyK7c1XgF29A==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-nonempty-excluded-nonempty", + "conflicts_with": [], + "features": [ + "pedantic-rfc5280" + ], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> ICA -> leaf\n```\n\nThe ICA contains a NameConstraints extension with a permitted dNSName of\n\"example.com\" and an excluded dNSName of \"bad.example\". The leaf's\nSubjectAlternativeName matches the permitted subtree and does not match\nthe excluded one.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUUsj5Jg/neltPdBGrpNhHmlWnhxMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR/UoxNBTXtSKFxtvFuT/VcKNjFOmQXDPJMoYMW\nJzOxthqrx+w7jl8T4iNO+b+GhHMS8D7mSpxPvlozYCWLy0gao1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU6wuHvAII5SuUDLtaFBTX4gN4ktgwCgYIKoZIzj0EAwIDRwAwRAIg\nTV6nxvKYD79TtGdxphocd7batpVwrshVrLa+zn/hRDYCIHBlDAUIANCcPK1NO2Fs\nCiABJXDUYWhbAJITrzXy8D5X\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgIUWoKIS/T8wg7mU5QOEYNtX4C6xjgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA0NzI2MTkwOTYxNTgzMjgyMzkxMTE5\nMjA5MTQ3ODgyMzI3MDg3NTU0MTQyODgxNDcxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABPbhIhnGND0I0fGW5qMTvjtETtoG/pFQObni2EAbEe5un5sdgSkR5W0fD6lo\ndxgzDL3yY4PiBMw9a5+7sG/WpfujgakwgaYwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAU6wuH\nvAII5SuUDLtaFBTX4gN4ktgwHQYDVR0OBBYEFBsdoqglVYqCoVRY2p3jkQPgJxFm\nMC4GA1UdHgEB/wQkMCKgDzANggtleGFtcGxlLmNvbaEPMA2CC2JhZC5leGFtcGxl\nMAoGCCqGSM49BAMCA0kAMEYCIQDGOfQJrRDC2G6uqXOKc+/MvQthfsV6iSk1hnYw\nk6G1mwIhAMvbxkR9kZIx3ySOAtc2pxx0UxjiM3Diu+Ng2rfEb1Xw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUB8T1BcDzkBels1ZeKmc1+gZCZrEwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNDcyNjE5MDk2MTU4MzI4MjM5MTExOTIwOTE0Nzg4MjMyNzA4\nNzU1NDE0Mjg4MTQ3MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngqhO3w3RbPJvpZGsgQQvQX5yHMtP0U9+ivyFZ7wyLmFehdmoebBK9o5vhfxuKuzG\nNVK5QOfpJtLaZcvh/gJmd6N8MHowHQYDVR0OBBYEFC7qXO5WHCGL/Wht+Em+LdSa\nYYIjMB8GA1UdIwQYMBaAFBsdoqglVYqCoVRY2p3jkQPgJxFmMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNIADBFAiBJ39kKli78KxeSMI+UDGD/udM7g8aGS4e5th8BSwyC\nOwIhANwbOqyzq+ZCqySOE8MbRoW7QBJZldbq5cvciEJJ0NDs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIM3cPzSYVU+WtLtvT/i84C/hYbCndY3ayIqeBq9y6xO9oAoGCCqGSM49\nAwEHoUQDQgAEgqhO3w3RbPJvpZGsgQQvQX5yHMtP0U9+ivyFZ7wyLmFehdmoebBK\n9o5vhfxuKuzGNVK5QOfpJtLaZcvh/gJmdw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-nonempty-excluded-empty-sequence", + "conflicts_with": [], + "features": [ + "pedantic-rfc5280" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> leaf\n```\n\nThe ICA contains a NameConstraints extension with a permitted dNSName of\n\"example.com\" alongside an excludedSubtrees that is present but empty. The\nleaf's SubjectAlternativeName matches the permitted subtree.\n\nAn excludedSubtrees that is present but empty violates RFC 5280 4.2.1.10.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUAbz6kuq+BwZ8UBNIpBAGPi2+2KQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQlWlQxEzvTgUmtvGp+GSFGwgRmd5mXgVXkLpv5\nghml8QyEaRFl1piPCgDok9ZBdOnwYUoufhxkCtlVEviGqMigo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUhWZwDg5vGPzMcuyBky794FX9s+IwCgYIKoZIzj0EAwIDSAAwRQIg\nQckHLHvqT2W0lLdQ/QHgcnPVt0PLZORx93WSo2VZneYCIQCUYHWr43vLwz1PZkOP\nnXY4szawkmpVzi2lKUtO6j3G7A==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICITCCAcegAwIBAgIUAi7BVgI8bYVLICnSY5TQBNDyreIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBoMTcwNQYDVQQLDC45OTIzMzU4OTMyODgyMTM3MTAxMDIw\nMjU5MDQ1MTgxNDkyODg0NjkxNDA5MDYwMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWlu\ndGVybWVkaWF0ZS1wYXRobGVuLU5vbmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQS2V+VnXNMBPNkPRVXT/R4rc+OzPuWrNDlb0vIQ52q0eO3Ty/fMuCuISmk4GGX\nnadZwRtocDiTEL8SbdWgYILso4GaMIGXMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFIVmcA4O\nbxj8zHLsgZMu/eBV/bPiMB0GA1UdDgQWBBTv66uBuXAvjjmFWUtrJNQjAe+RezAf\nBgNVHR4BAf8EFTAToA8wDYILZXhhbXBsZS5jb22hADAKBggqhkjOPQQDAgNIADBF\nAiB/TSqtyj6O7bRp+9pAXKRnMMBqDnQsFzk1nn1Wiqt64AIhAJS0pKKNtPAh6TYE\nga5NKijq9kHAxzhdN+xSIPxf1lrB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgIUR69ADA3MIL/XrU0HZB4pk2sKABUwCgYIKoZIzj0EAwIw\naDE3MDUGA1UECwwuOTkyMzM1ODkzMjg4MjEzNzEwMTAyMDI1OTA0NTE4MTQ5Mjg4\nNDY5MTQwOTA2MDEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0\naGxlbi1Ob25lMCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAzMDAwMDAxWjAWMRQw\nEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJLR\nWmR1TuZRHwt216Uprkzw/G4p4mrThzADblKwogJScuugIqm5dD5bXjMMk9jRE0L2\nwSJslaTSUAaQxeqGvFijfDB6MB0GA1UdDgQWBBRYe1nQoEQ604GwT3Nr5Qr0p2Pb\nqDAfBgNVHSMEGDAWgBTv66uBuXAvjjmFWUtrJNQjAe+RezALBgNVHQ8EBAMCB4Aw\nEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAIfrkLFuningF9H27VyfAKhtHToCk0M9gWBjktTD3TBH\nAiB+4f7yQPFOOTvKn59zkE/e1maXelK+BD4eFwpxRCAzGQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEINtfVn/5Y3HUtWX7TEL+cgD/AWqy5QnFP76HCWz2prfVoAoGCCqGSM49\nAwEHoUQDQgAEktFaZHVO5lEfC3bXpSmuTPD8biniatOHMANuUrCiAlJy66Aiqbl0\nPlteMwyT2NETQvbBImyVpNJQBpDF6oa8WA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::permitted-different-constraint-type", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted iPAddress of\n`192.0.2.0/24`, while the leaf's SubjectAlternativeName is a dNSName.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBqjCCAVGgAwIBAgIUVVERm3581MfOSh5ePrCfzj3IedAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATdJpvblWfJ5V30UU5kKxZ69y+aHN652dwh4wto\naUJnCAw1WH2D1EbbtSXiT+ygsd7lnCWIl9aduo+CZ11smOPio3MwcTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUoHPh3gCVx6P0OqkhcSZR360g6d4wGgYDVR0eAQH/BBAwDqAMMAqH\nCMAAAgD///8AMAoGCCqGSM49BAMCA0cAMEQCIBu+xBH8aMDDOa3gfiEWY4dwSLtE\nmT0+YCAkQtF3X5QrAiBwYu0h7kutP+YFZ5dck1VA82JQIwL0p+/SvEoeoD97bg==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUYw3Uh1EIPtkvh376GXKK0kxWQZMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABF4IxqkIt+DuReqiIyCqnLK86AHSyFt0LBOngQ26jxU5\n/ienvC5dwygoNc2ruhrw9Ejrxs8FrIm1A0yVQM25MuSjfDB6MB0GA1UdDgQWBBR1\nnAY4RAofcnG5YizbfW4T0toWIzAfBgNVHSMEGDAWgBSgc+HeAJXHo/Q6qSFxJlHf\nrSDp3jALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgdqlrtycBWo1cpMRNpzzh\n+V1FQyUYTR2BBJU3UaogqwkCIFdVuV0ujZwenXyobCANnPkmE9HJA9NF+r1Cq4Yl\nVcnw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICL1zkX/7fVZ6NrViddbH9kX2ooo9AA1zInc/+YjF/zfoAoGCCqGSM49\nAwEHoUQDQgAEXgjGqQi34O5F6qIjIKqcsrzoAdLIW3QsE6eBDbqPFTn+J6e8Ll3D\nKCg1zau6GvD0SOvGzwWsibUDTJVAzbky5A==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::excluded-different-constraint-type", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with an excluded iPAddress of\n`192.0.2.0/24`, while the leaf's SubjectAlternativeName is a dNSName.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBqzCCAVGgAwIBAgIUCZoIUGZRuNEEAAzSVqCkCw4PzEUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASVg/YWagdPki2dZ1fgPxADo6K+NtZ6cykjz3LH\n4tOnZHXZWuxgiYdgUgHxLr+y2SlmIN1uMqvbGHHMEruKjjn4o3MwcTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU7APNQHvnBaTjn4ofNAqAfjhQhdUwGgYDVR0eAQH/BBAwDqEMMAqH\nCMAAAgD///8AMAoGCCqGSM49BAMCA0gAMEUCIFxYVahjtBnjbHozbpdVV71bmDKy\nNoaIFjvHSPzKezH4AiEAxmFWVKAcR524VKTdZZAoX7GzDc+50bvGqZV6ZGY8rvw=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUcagNUuC8NRC6YR8nlWzJ0UqN0WwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABN54itWtAlrjk5aaVKVc3245ZAvjKM/i0EbgXs453KFz\nza+ooT3naaOXjHiNYVpSzr6ujIS8agl1Qs4jct5SzLCjfDB6MB0GA1UdDgQWBBSu\nYQOV2hih8lpP6rsPbklHRsW4cTAfBgNVHSMEGDAWgBTsA81Ae+cFpOOfih80CoB+\nOFCF1TALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgNabUC2nvWCtS8YRxJcc4\nL0ecs/CeORGY+gUOFChRbs4CIQDVZDaCOj1+ph8oF52pxAkT13LNEg/3MxgS6yQL\n/dowvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEINMZUORbYp4GoTs5gn09rrIcE0G24bMUnZU53GtAK90CoAoGCCqGSM49\nAwEHoUQDQgAE3niK1a0CWuOTlppUpVzfbjlkC+Moz+LQRuBezjncoXPNr6ihPedp\no5eMeI1hWlLOvq6MhLxqCXVCziNy3lLMsA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::invalid-dnsname-wildcard", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a Name Constraints extension with a malformed dNSName\n(uses a wildcard pattern, which is not permitted under RFC 5280).", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIULIjxJ/+Ebh2LnboiVbBgpEORozMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARs6sDBowiN4ZgivWariIT9JZ1o3eZbXAaimyBf\naMcChj2/0Kd6QErGBaHP5nVme3wrEhO+ssgcokF4scyM21hYo3gwdjAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUpvb/vvGTHEfaoS/5t5P0w1yHabAwHwYDVR0eAQH/BBUwE6ARMA+C\nDSouZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgEuvX9QAL5ZUOmT1cF6JG\nPpOFgTupUggXEfg3XZZkmicCIAgt9kQi4cxoMMB4fC5IgSjFoysGleo8/dtjgmit\nGhYo\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtTCCAVugAwIBAgIUTdJqahzExLCeZrvRgin4fIROiAIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABCh3/NZKvsxxgM83ha73Y8XA+Fx+ViR7JNCdtd3GF7fi\n6BrqVu3vWW6WbItWHvK+7gPdc1EO6AU+XsNUlYfkWK6jgYAwfjAdBgNVHQ4EFgQU\nqc9s45xLr0IuU7yYNYt8xnLpsjIwHwYDVR0jBBgwFoAUpvb/vvGTHEfaoS/5t5P0\nw1yHabAwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBoGA1UdEQQT\nMBGCD2Zvby5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAVmvnGTOoIDtB7\nIgGlXwJBK/XWy4fin1B3FOoK5f+MFwIhAJfcCXrHM6/A/NI63HyQZWABvyWMQC/Q\n+IAcj18TUa4z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIP5wqmEAXGhIUlXDYtYmqUYRY0tSL1bNH9/9v7rBRSyWoAoGCCqGSM49\nAwEHoUQDQgAEKHf81kq+zHGAzzeFrvdjxcD4XH5WJHsk0J213cYXt+LoGupW7e9Z\nbpZsi1Ye8r7uA91zUQ7oBT5ew1SVh+RYrg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::invalid-dnsname-leading-period", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a Name Constraint extension with a malformed DNS name\n(uses a leading period, which is not permitted under RFC 5280 4.2.1.10).\n\nThis is widely (incorrectly) accepted by implementations due to OpenSSL\naccepting it and due to misreadings of RFC 5280, which allows a leading\nperiod in *URI* constraints but not DNS constraints.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVWgAwIBAgIUJ8Ub4fRP2nQfbZ81XkbZIUUVJJcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARQ16AQE2IGnvmLxxHDltW3eSQKv4Ctd5JYgFwN\njdRGid2YicLcT18bYMvwDWEbJMY9Iy0KyjJ/m/YQQlOGcg2jo3cwdTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUpdOUN9r0Y9zEdasoL68cFyszoAgwHgYDVR0eAQH/BBQwEqAQMA6C\nDC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAxjELnsTTrtW3pf0yaqaE\nddKdqo4etdCb3YMMzalkkNgCIQDlqPsyzkKNx/rHQAn+kSMGAotLGJBQp5spK0Ws\nq3z14g==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtjCCAVugAwIBAgIUUJ+YDgP3KHtPxsBFJChY3V1N1OcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABOJLkproQhPvdp2afdPXo8f5ReDC5UGrcuxI/CFZXQU2\nY4OeGg807tu9xOMdbxoPVyaLZukdUghJiIsyfuirIB+jgYAwfjAdBgNVHQ4EFgQU\nts/Kae9SVPrFfbw5PQ95nErP9hYwHwYDVR0jBBgwFoAUpdOUN9r0Y9zEdasoL68c\nFyszoAgwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBoGA1UdEQQT\nMBGCD2Zvby5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA1UC7x49HKg0m\nr0vE0ruTILY2RlCtdAMg9gGINRtmTQACIQCY2sDVNtcc1B1K30GkobPSfTqC02Wi\nOTF6T8qsfSWgkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIMWuFz6A18KIiuiioWShpYlAUTYoYPkIAtR+2IaJsEpXoAoGCCqGSM49\nAwEHoUQDQgAE4kuSmuhCE+92nZp909ejx/lF4MLlQaty7Ej8IVldBTZjg54aDzTu\n273E4x1vGg9XJotm6R1SCEmIizJ+6KsgHw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::invalid-ipv4-address", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a malformed IPv4\niPAddress (not in CIDR form).", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBpjCCAU2gAwIBAgIUUhNDKPscOZwStoLEFc8V4QmTq5MwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASRkENt+1/9CW9Vn3vJcA04k2iOiwnvplYY7TtL\naxGoaXuWPFpq9yh33SGhTdDCu/K6bvqtMVE2f+XDsACtsJLPo28wbTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUB6Nrjtm4xMHLONUBFAQbwC+0pPAwFgYDVR0eAQH/BAwwCqAIMAaH\nBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgA6Ss7xFTVsPW1DFD/gDDEaJvJVBwYEOZ\nQAUfJhqdhZ4CIFrxYdQ6daqr71BY7wUWSDggelfoM1DsJXENgiSbTHEt\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBqTCCAU+gAwIBAgIUTDFg7DtpDKQBczV92K0D1LbMCjEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABMmL80i8SNAxK6dWWutv3ktPJd0nh2ydgrMBQdk4mZXe\nzjIdiJgqjdYZOuRSPviX5F+Q8QKcoOCfkiWnGL8YVuyjdTBzMB0GA1UdDgQWBBTd\nHtKVHHDoQ/prhkr/i2HPeZSiUDAfBgNVHSMEGDAWgBQHo2uO2bjEwcs41QEUBBvA\nL7Sk8DALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBmBKHhZ9JIClw7EmSKa/x5zd96EHoY\n1o1jjy/NR/IFMQIhAJdugqx1/kQV2GAa6ZcMQks9BQ+1rINPbe0LEW7abIut\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIHmo5Wj7ikmS8DPmNsoJm03IcpWHgF2MogoYSXFTm1n0oAoGCCqGSM49\nAwEHoUQDQgAEyYvzSLxI0DErp1Za62/eS08l3SeHbJ2CswFB2TiZld7OMh2ImCqN\n1hk65FI++JfkX5DxApyg4J+SJacYvxhW7A==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::invalid-ipv6-address", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a malformed IPv6\niPAddress (not in CIDR form).", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBszCCAVmgAwIBAgIUITzAFL0XiY1+v0Yo2XBFhEkjaIgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASas43geaQyrxBLFFIohagu9J40Jw+N93Jm9MCn\nKeNRw8IOMki60+JkCM4DiILfnpVkR9wULEuCOS425VZMPhx8o3sweTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUGHuqOsBCiRyFsnZkAUf/pvhw80IwIgYDVR0eAQH/BBgwFqAUMBKH\nEAAAAAAAAAAAAAAAAAAAAAEwCgYIKoZIzj0EAwIDSAAwRQIgHaXemC2Yv0JYk/ts\nn4Qsw4JoxOGp/K2dRq+BaZgLJNQCIQDsdBgUUcjctUsZdiDJu/d+8skxhzrMAK0Y\nN8bw1hY3YA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtzCCAVygAwIBAgIUQkorh887NR3EanIV0/b65xuyjSIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABItGSnJn76EpG3Ch5tmy/dtf2OghYpJl3kFYYG3eAMSE\nb0BlLcZYSeeWnA8GEBgHi6Lm/efu8SeFH6CdjKWm72OjgYEwfzAdBgNVHQ4EFgQU\nV3jmpUvfCZor0XKMcugog1ZdQFcwHwYDVR0jBBgwFoAUGHuqOsBCiRyFsnZkAUf/\npvhw80IwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBsGA1UdEQQU\nMBKHEAAAAAAAAAAAAAAAAAAAAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKs9GhNJyhbq\nkiThObgyGhL4LSY69i7+Ny3kmZpivnjKAiEA1Hp90AvY5FfgDpUHUHYr+CajQR3H\n7Mtee4qB7XEeSDg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIEDWn8IArL2lnc/kKF7eZsJUJFkGPYwQoTE0wa9PA6XzoAoGCCqGSM49\nAwEHoUQDQgAEi0ZKcmfvoSkbcKHm2bL921/Y6CFikmXeQVhgbd4AxIRvQGUtxlhJ\n55acDwYQGAeLoub95+7xJ4UfoJ2MpabvYw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "::1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::invalid-email-address", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a `NameConstraints` extension with a malformed\nRFC822 name constraint (`invalid@invalid@example.com`, which is not\na valid email address).", + "validation_kind": "CLIENT", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBwDCCAWagAwIBAgIUI55g4MDtFC471gOc/hYVseDAQD4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQRcTaY18pRKEHya8h98eomBhJ/HxZ/daIw6DuM\nwbuiHqgI36uO5Hmj70vZia0qv1DDd5LHPbo28mOnh+Wa9C2Vo4GHMIGEMA8GA1Ud\nEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29t\nMB0GA1UdDgQWBBSPGRABAVq6uYvYLeEkHtMWUjBr/TAtBgNVHR4BAf8EIzAhoB8w\nHYEbaW52YWxpZEBpbnZhbGlkQGV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIC1Ty+5PSvwtwXs0Sz0x3ey/7gDPsOclr1sdzuapX9cXAiEA/eGkmiawTe3bJz+t\n1T4doy/V/bCJ7So/N4s52a1SfIw=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBujCCAWCgAwIBAgIUDD+UUMEWNsxw2jKAyQRgV2SW5sUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABGy+EolufUE2KdP2DH6A+/4pbOu5SySAcCUSZZpIHO3H\nKnPW/494Gnml27TnksMd2PtIxYSEJP2TCXa4MtVwmW2jgYUwgYIwHQYDVR0OBBYE\nFBtJKSsqJ6qgLIJNxhua/e/LrFB/MB8GA1UdIwQYMBaAFI8ZEAEBWrq5i9gt4SQe\n0xZSMGv9MAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAjAeBgNVHREE\nFzAVgRNleGFtcGxlQGV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCuMjdU\n4PbWbeTpOfxSagOPYQpRPOJiewlHpE6a17wAvQIgK7RpAv5sTtfi08ZqFtYduXkF\niwWuiX7JhgVb/jFij8E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIKPiq1ZqNiBFe21/thGQS9T1LuR1R5eCgzi++08bQA1noAoGCCqGSM49\nAwEHoUQDQgAEbL4SiW59QTYp0/YMfoD7/ils67lLJIBwJRJlmkgc7ccqc9b/j3ga\neaXbtOeSwx3Y+0jFhIQk/ZMJdrgy1XCZbQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "clientAuth" + ], + "expected_result": "FAILURE", + "expected_peer_name": null, + "expected_peer_names": [ + { + "kind": "RFC822", + "value": "example@example.com" + } + ], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::not-allowed-in-ee-noncritical", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE contains a non-critical NameConstraints extension, which is not\npermitted under the RFC 5280 profile:\n\n> The name constraints extension, which MUST be used only in a CA certificate", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUdiG3BiET/ryuT38i3D3DuH+pd8AwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARWwnWJ/Zcv5A+G/jSdLmF3A3cfbk3hbC/Cxm4I\nS0EbWEsaaxNWX+9OSYR1kWg9AuojiNiqhTpTjaH+g6AG4dgVo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUZsMq/9h7Z9D4wVDlJBiZ+LAb0GUwCgYIKoZIzj0EAwIDSQAwRgIh\nAOJIUSCtar2Uy1SimFIzkQ7Iy1cQDDpPU+ckvr7smq2VAiEAugr9Kt0GHvJXbPT7\n4sNqk7WjWaocgltNw7ieHdSMeTo=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBzjCCAXSgAwIBAgIUbvmN3/E0QbNC9UAGK5+lWLJk56cwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABHK4roKUzD8M3MTXBwUUc/MKI2FM7oK3yhH5CfF4UsVI\ntPt87lhK7SBlRMgHgv6MNm4MTI/9iDcOsi15mOM30WyjgZkwgZYwHQYDVR0OBBYE\nFKX2ykkzPVpMJLm2afOyjcVldjZHMB8GA1UdIwQYMBaAFGbDKv/Ye2fQ+MFQ5SQY\nmfiwG9BlMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREE\nDzANggtleGFtcGxlLmNvbTAaBgNVHR4EEzARoA8wDYILZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhANYoWgn9yV9g1Re+OffXUJrvJMvlHvfnyZ0tedS4APDK\nAiBNEah7Sjmq1avQVyzRi25yXNtMjpwTDkxGxJwsa35gpw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIBUHvnf/r0B6dT1qQRqKJyVX4zzwrQYqizFKQj5/3kvloAoGCCqGSM49\nAwEHoUQDQgAEcriugpTMPwzcxNcHBRRz8wojYUzugrfKEfkJ8XhSxUi0+3zuWErt\nIGVEyAeC/ow2bgxMj/2INw6yLXmY4zfRbA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::not-allowed-in-ee-critical", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE contains a critical NameConstraints extension, which is not\npermitted under the RFC 5280 profile:\n\n> The name constraints extension, which MUST be used only in a CA certificate", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIURsOn3jilMkTitrXu+bDCwiUHs9UwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASgHFphoC+B0gRRbfbYFY33okNqJsFs3rnZtmTi\niN/XQHvMbvcVAq9rwF3JtNB0e6NhYxrWZpodEfGeEuUUrjvCo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUjtNizY2jIkhD+cm4BdrIoLwEA4wwCgYIKoZIzj0EAwIDSAAwRQIg\nZ6K2gurtes5Qf6rGwk8AT76FA8t0nUOoT3Acty6jUoYCIQCV0yzKU7EwCRMj4LEh\nJBB/qeONJjaUyegPZUH3XY3zuA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB0jCCAXegAwIBAgIUW4GlslNq486QXDONIJbNXUjeP58wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABH+mFsxLmEvE18l8x3VjmTTsVFWZyRLSli1t2jD/fjrU\neZsDhFj17fhz3f7MfieaaSXE/FeorLMiQC2O3SFQzXSjgZwwgZkwHQYDVR0OBBYE\nFDWepJFAnnO83lrBBZZ5yNETqc5zMB8GA1UdIwQYMBaAFI7TYs2NoyJIQ/nJuAXa\nyKC8BAOMMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREE\nDzANggtleGFtcGxlLmNvbTAdBgNVHR4BAf8EEzARoA8wDYILZXhhbXBsZS5jb20w\nCgYIKoZIzj0EAwIDSQAwRgIhAMIyWNlR/IuwaFeJACevvxJ+jgtZym2YEcBJpLBp\nOfjzAiEAjKPuez/ZVxM4zha2O3r7fVr6JQGAuYCeHEs1vCGsyEY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILIQ3DOrwU33FP7oUjJXgf5v4g3ZRZlqHuGvFq+qMlC0oAoGCCqGSM49\nAwEHoUQDQgAEf6YWzEuYS8TXyXzHdWOZNOxUVZnJEtKWLW3aMP9+OtR5mwOEWPXt\n+HPd/sx+J5ppJcT8V6issyJALY7dIVDNdA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::intermediate-with-san-rejected-by-intermediate-nc", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA1 -> ICA2 -> EE\n | | |\n | | |\n NC SAN1 SAN2\n```\n\nICA1 contains a NameConstraints extension that forbids\nSAN1 (forbidden.example.com) and permits SAN2 (permitted.example.com),\nwhich should be rejected under RFC 5280:\n\n> The name constraints extension, which MUST be used only in a CA\n> certificate, indicates a name space within which all subject names in\n> subsequent certificates in a certification path MUST be located.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUFvlXi7bnhs9HcZtillEXvoCH+K8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARPblHmqtYVvJOjpeYFONX+hrM2jj3gIijdHOP2\nlam30eMPwzH2qFiUm/r568zthfLQHMjKJHRqgT82GBLOwn9Lo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU54suqU8kOpU0UOKpBJp32U5F//MwCgYIKoZIzj0EAwIDSAAwRQIg\nHHoiS1MEZ6fEsPOpEp3GiGqKJGKRL+h/GbecS2HPg2sCIQDVuLXij9c2KXIJ6Rae\nBZn6oJlOZKFWNtW8xKViLx8RDA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeygAwIBAgIUOKGUHNhqfKi5Klw4GrhaDYh5d/AwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAxMzExNTgzMDg4MjM4MDUzMDk5MTk2\nNzk3Nzg3NzczNTk0Njk0NzI5MTYxNzUwMjMxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABOtLAFjzXy+ucITSLYEsJ7LLL7Wu0p1c4K1MtWkP6BWRxrlNXzPGZ2J7GWxl\nfm1BmWpZprN/Oo/A4OfRDzAA5dSjgb0wgbowDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAU54su\nqU8kOpU0UOKpBJp32U5F//MwHQYDVR0OBBYEFMfYE2UC+asn/2f+hb58c5cOCAR7\nMEIGA1UdHgEB/wQ4MDagGTAXghVwZXJtaXR0ZWQuZXhhbXBsZS5jb22hGTAXghVm\nb3JiaWRkZW4uZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRgAwQwIgaCqyKsdyzm09\ntdFvy5kZA2gSpDDpqYrHdm/PVI1tRLQCHyxCRIg75FyCRY9Juonjeb4rBRNPpvQv\n0R12fvv6r+E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgIUIoeTkSvjI+Hj9sfsgrdYMPf05VUwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMTMxMTU4MzA4ODIzODA1MzA5OTE5Njc5Nzc4Nzc3MzU5NDY5\nNDcyOTE2MTc1MDIzMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMGox\nOTA3BgNVBAsMMDMyMzMwNjgwNTU3Njk4ODc3NjkyODU5ODU5Nzc4MzYxODY1NDYx\nMTA4Njg2NjQxNjEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0\naGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEplpxHzc79XEEcXm6\nmrkc7IkVSw9lNXD1+Wkq1og+fFQN+k9e73SNl5wJqiare3xC5PrxIJfQ4WJ9ekRj\n1v2M7qOBgzCBgDAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAgBgNVHREE\nGTAXghVmb3JiaWRkZW4uZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUx9gTZQL5qyf/\nZ/6Fvnxzlw4IBHswHQYDVR0OBBYEFPnoB96PT/QhQY1rz9x/ZT9MA9ZQMAoGCCqG\nSM49BAMCA0gAMEUCIAJpq3ts+LyhASQtjXAM7qtacGRb1ARFUYST0FdpTfRmAiEA\n/IJZoD9AgsV8igqfTO6Zb6asP8yqvfJISCKnwxv4t7Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgIUFxHfrRpRKAOqgEZ0CD+Jso33i8UwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMzIzMzA2ODA1NTc2OTg4Nzc2OTI4NTk4NTk3NzgzNjE4NjU0\nNjExMDg2ODY2NDE2MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4X4D5BI7sIAT+REvMCYMuVLRmXOf+M30r/bUIlo4xQ0kPIqAoOb270NtvSSytFOH\nobPj2+aze3OCWY0EjLVSZ6OBhzCBhDAdBgNVHQ4EFgQU+w6yfW9KIbfbiOe5jjpa\nNSZMVsMwHwYDVR0jBBgwFoAU+egH3o9P9CFBjWvP3H9lP0wD1lAwCwYDVR0PBAQD\nAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMCAGA1UdEQQZMBeCFXBlcm1pdHRlZC5l\neGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiA7omRu0qGi063ILhpw7xLUUcSv\n6XfdxdW4IFoTO8OM4QIhAJ8jrwLnpC8Fz8pFWobV0aWyOKB1lbYifk4XBNiVCcZ0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIM3knXDD9iyCdUueQmhihG7U6tO229vYboKVZ6MDm1mdoAoGCCqGSM49\nAwEHoUQDQgAE4X4D5BI7sIAT+REvMCYMuVLRmXOf+M30r/bUIlo4xQ0kPIqAoOb2\n70NtvSSytFOHobPj2+aze3OCWY0EjLVSZw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "permitted.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::intermediate-with-san-rejected-by-root-nc", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA1 -> ICA2 -> EE\n | | |\n | | |\n NC SAN1 SAN2\n```\n\nThe root contains a NameConstraints extension that forbids\nSAN1 (forbidden.example.com) and permits SAN2 (permitted.example.com),\nwhich should be rejected under RFC 5280:\n\n> The name constraints extension, which MUST be used only in a CA\n> certificate, indicates a name space within which all subject names in\n> subsequent certificates in a certification path MUST be located.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIB1DCCAXugAwIBAgIUGLPpKUMqOLJQwly+zM5oo9LmVZwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQI9+wryTxGCu6TKyx3udfy70FPTm9xkrHmTgcp\nzlZo3tvT0uskrqBcdIcDcqJicX/j49JZcMB51cMTEquz6ejUo4GcMIGZMA8GA1Ud\nEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29t\nMB0GA1UdDgQWBBQ7lUBZWAepzX1R/a8sEUPtWZjDizBCBgNVHR4BAf8EODA2oBkw\nF4IVcGVybWl0dGVkLmV4YW1wbGUuY29toRkwF4IVZm9yYmlkZGVuLmV4YW1wbGUu\nY29tMAoGCCqGSM49BAMCA0cAMEQCIHIzEDec8ArZSlRjfEFmdzWl/RUy60pb9xm+\nCOY6CbFDAiBtkOq3qc6mfPZz8F8eiXGlJPK9KXlV7xaG/3MC6g7cUw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICATCCAaagAwIBAgIUJniM4U0jTNBSBrFwt+rYQOKQGtEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAxNDEwMjc5MjMwOTM3ODU3NzYxNDgw\nNjgzNDA2NTQ1MTYyNjA4NDg0MTAxODcxNjQxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABFHfeajOgyTtTpkOWk1E9Idv7vD0jTA0tGhyhzOukEl54nqyZKXoOK1jokEo\nfs1xErhL+aKaU7fmOJ5RbIGAMKqjeDB2MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFDuVQFlY\nB6nNfVH9rywRQ+1ZmMOLMB0GA1UdDgQWBBRkfDVy35dJgQvEVxtOr92URPkTtzAK\nBggqhkjOPQQDAgNJADBGAiEAvdudFVm/4ibG6cRrdEYdWUbel8/UjHQq9lg+6uLl\nWzcCIQCO/ZOwNBUroaqNtlgT6jXw1n7vqF1dwfvcaehk27FgbQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgIUOPmq5jU1ChbvDsk0YfBhEDk0IRcwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMTQxMDI3OTIzMDkzNzg1Nzc2MTQ4MDY4MzQwNjU0NTE2MjYw\nODQ4NDEwMTg3MTY0MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMGox\nOTA3BgNVBAsMMDIxOTYzMDAxMTEwMTIyNjQyNDM3Njk4OTM0NDEyNzIwNzY3MTUx\nMjYyNDUzNjI3MzEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0\naGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn4RMLpVdItPJw17/\nbxeGSHLv2/iW77FaW3DyYvvrRaiH1qf+De7m4tB01SOsfJrQ9B3Q0BBbEPlg3rUV\n7Ou0g6OBgzCBgDAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAgBgNVHREE\nGTAXghVmb3JiaWRkZW4uZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUZHw1ct+XSYEL\nxFcbTq/dlET5E7cwHQYDVR0OBBYEFEouTR36cBwu5Sduo5v09WgyjZFxMAoGCCqG\nSM49BAMCA0gAMEUCIQDEImDgPWOr4Aeww01JOORxTPtPc4Pwy/bMY6gTBY+/0AIg\nR2V1bBUH98mLSGzuwJ2rRhCvRb1t/mZVLUZaEI6HiyM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgIUI3HqscASIeqKb4iuc9a1JPDS+zMwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMjE5NjMwMDExMTAxMjI2NDI0Mzc2OTg5MzQ0MTI3MjA3Njcx\nNTEyNjI0NTM2MjczMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbBuSop3KhFZyC0UEGwd8V4xIYmTivmksM0vUgey/SZ9BVyKbdV1lXtvR8fSDtuIT\n4qSXB+J1PxlUpngf3EM4yKOBhzCBhDAdBgNVHQ4EFgQUftpHl6iDlndkwEVmNWKK\nnz0SOacwHwYDVR0jBBgwFoAUSi5NHfpwHC7lJ26jm/T1aDKNkXEwCwYDVR0PBAQD\nAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMCAGA1UdEQQZMBeCFXBlcm1pdHRlZC5l\neGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBqvqxGNS6hi0zdxT0kWE5ICmYw\n9+S70Pe6DIL7sOA71QIhAI9nnGSRvJR848VbOeHa7mdpjsR84D1Jp4W1rI/NzOXl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIKd4MsAL9XU4iDyNcQkzFgo8EB8KvG8LHh9hxy4D3BfwoAoGCCqGSM49\nAwEHoUQDQgAEbBuSop3KhFZyC0UEGwd8V4xIYmTivmksM0vUgey/SZ9BVyKbdV1l\nXtvR8fSDtuIT4qSXB+J1PxlUpngf3EM4yA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "permitted.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::restrictive-permits-in-intermediates-narrows", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA1 -> ICA2 -> EE\n | | |\n permits: permits: SAN: foo.example.com\n foo.example.com bar.example.com\n bar.example.com\n```\n\nICA1 contains a NameConstraints extension permitting `foo.example.com`\nand `bar.example.com`, while ICA2 contains a NameConstraints extension\npermitting only `bar.example.com`. The EE then contains a SAN for\n`foo.example.com`, which should be rejected under RFC 5280:\n\n> a name space within which all subject names in\n> subsequent certificates in a certification path MUST be located.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUV8VQtDRBGrazuc0Hi8XpGzulgcowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARsppukLiuIqSFgnHalQpE/u7gFKDSWcWECgUPV\n5qe5vy2rjUcRWXHkOm5FBgRqaJTUdLUNOEaAadGDYyjR3nVjo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUtAtprBFC24GEiTfCyzZ1290mdkcwCgYIKoZIzj0EAwIDRwAwRAIg\nA/FxhNWZLiCQDSBtP4neehgdezeHWTZVor+nueCdknUCIBb83whfCz0GpP3R8xRy\n2NhIIbIcSg8/flw7qf6OYZFq\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgIUOu0rQSYpLccYojqVJm32OeZrcz8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA1MDEwODI0NzQxNjg5NDMwNTQ4NTAy\nMzkzMDUxNzI4OTU4NzE5OTU3ODI0NjM5NDYxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABFLT5wbvD0GYM3xma+Aw8S57Y7TDpWi+9fITZIIbXB5oNEJ8STrzUS/a4suI\nM4EBzIl5iYr70D5BMaKMXoNs0sejga8wgawwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUtAtp\nrBFC24GEiTfCyzZ1290mdkcwHQYDVR0OBBYEFIZyk84+o+UHrLEmSKRKX/bPc67z\nMDQGA1UdHgEB/wQqMCigJjARgg9mb28uZXhhbXBsZS5jb20wEYIPYmFyLmV4YW1w\nbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD/gPXyg+qyqiwiPJERvKl2nNUGtpgH\n/YiSRmfRxxByDAIhAOTS9rtkcJtHHFGAGy2aVtvTi/9U9qzptfskndRDNHMf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICdjCCAhugAwIBAgIUCfOHzzyYlsJPb50a/zE3HdGT508wCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNTAxMDgyNDc0MTY4OTQzMDU0ODUwMjM5MzA1MTcyODk1ODcx\nOTk1NzgyNDYzOTQ2MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMGox\nOTA3BgNVBAsMMDMzNjQxMDUwOTMxNzIwNzg0MjEzNTE1OTIzODcyMzg5NTE2Nzc0\nMTEwOTk1NzQzOTEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0\naGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE62aDGsBeVhxZrq1B\nkOCMTXgDeGUyS6MUMf2qVIpDFuT4x6MHD6t0efRi4DUYGxEl1MmyRrsjTh5trarz\nuI2ZHaOBnDCBmTAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAWBgNVHREE\nDzANggtleGFtcGxlLmNvbTAfBgNVHSMEGDAWgBSGcpPOPqPlB6yxJkikSl/2z3Ou\n8zAdBgNVHQ4EFgQUO2a4Nl5IxKae2YdVRH8fb0y3ynUwIQYDVR0eAQH/BBcwFaAT\nMBGCD2Jhci5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAyRSISNy10Jep\nLYuGzupU08feDvUkV5h7TRTx1MCaJu8CIQD8ZfBRdsSjuciH1tBn2h+U/ppaf2xD\nCMnQIbqLzGBc4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICBTCCAaugAwIBAgIUU9sEQ8Heqo0j/VcowMGyU7SFowkwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMzM2NDEwNTA5MzE3MjA3ODQyMTM1MTU5MjM4NzIzODk1MTY3\nNzQxMTA5OTU3NDM5MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntdwxdq4iv3ckX2uRLdvn8sbYcWoKIfi8qgKPGmBaT+hilEdRG4oy3GD3KZTMha0+\n8XzNQU7LFe/TUGEZyb50YqOBgDB+MB0GA1UdDgQWBBRBdSGDy/bWefAA1+TbJplZ\nrq4n6jAfBgNVHSMEGDAWgBQ7Zrg2XkjEpp7Zh1VEfx9vTLfKdTALBgNVHQ8EBAMC\nB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwGgYDVR0RBBMwEYIPZm9vLmV4YW1wbGUu\nY29tMAoGCCqGSM49BAMCA0gAMEUCIDuAtY6Q9/zoWHmXu5wSmHE9Zb0ho4uHmIOH\n/gsUTp6KAiEAoG7SpPxMTZsOzZlbd02jdP8KDTtyVgCdDEYzAsxWwJs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIH/1M0WVgGbeOohcFvMTaFot9iB4TCa0pbliNAKoLm7/oAoGCCqGSM49\nAwEHoUQDQgAEtdwxdq4iv3ckX2uRLdvn8sbYcWoKIfi8qgKPGmBaT+hilEdRG4oy\n3GD3KZTMha0+8XzNQU7LFe/TUGEZyb50Yg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::restrictive-permits-in-intermediates-widens", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA1 -> ICA2 -> EE\n | | |\n permits: permits: SAN: foo.example.com\n bar.example.com foo.example.com\n bar.example.com\n```\n\nICA1 contains a NameConstraints extension permitting only `bar.example.com`,\nwhile ICA2 contains a NameConstraints extension permitting `foo.example.com`\nand `bar.example.com`. The EE then contains a SAN for `foo.example.com`,\nwhich should be rejected under RFC 5280:\n\n> a name space within which all subject names in\n> subsequent certificates in a certification path MUST be located.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUUrOjlGrWi7dswK1Zl6+fBIWmjdowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQl+KsipnkLEGIK3VaOLY+ZkPWGZKJkddCzot/3\ndm/Rga0c/6uO3y380XkVKPH2qWeHWBaZlti4EVGaxu/TglCLo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUJp4Oj+hSebYueapjisXPj+lGcnswCgYIKoZIzj0EAwIDRwAwRAIg\nfmA8msUzPJWkveV110M3RY1WYcyLCNEY9FPAdNny7Q0CIFCg6GPp0XFPktxWBy5G\n1CSyDCUrBx9qzjGVTwIwBv7C\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgIUdbkoUGCb80o7pumePcOln9F1oDUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA0NzIxNDMzMjY0MDQ1MDExNTY2MTY4\nMjIxODA1OTgzMzQyMjE5NTQzOTAwNjg2OTgxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABAgcQYeF38OC94IuFhcUCQRe8/ibgk5yjQgl70xHuU9ZJEj+GZjbF06JXXbD\nM6LFGmmMZq6Sw8+jaW4o9A4LxiCjgZwwgZkwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUJp4O\nj+hSebYueapjisXPj+lGcnswHQYDVR0OBBYEFFo2HEysPnpCkl5s+rnyBJOxkxpA\nMCEGA1UdHgEB/wQXMBWgEzARgg9iYXIuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwID\nRwAwRAIgPh24s8gY74D4hM2z+r2S9CMHMP4caCF1d44fcYv6cggCIEDBgBZvO9zG\nBCv11V0SPKLHvcdhabhJkPqm3yxUutqn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICiDCCAi6gAwIBAgIUeCIVzCyZTYNr28Hx9cN6r3Q8bnkwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNDcyMTQzMzI2NDA0NTAxMTU2NjE2ODIyMTgwNTk4MzM0MjIx\nOTU0MzkwMDY4Njk4MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMGox\nOTA3BgNVBAsMMDY3MjA4MTA2OTg5MDU1OTY0MTgxNjcwODgxOTU5NzM1NjExNTEw\nOTc0MzAwOTg0NTEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0\naGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2xfJTyMyAE32YPMn\nQBE3C/fsmHvgnoM/wr5HqKeuo8wWeNTbYOGG7UXwrdZsD6p+thQWmmz9hTCQgx8m\nCDxveKOBrzCBrDAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwICBDAWBgNVHREE\nDzANggtleGFtcGxlLmNvbTAfBgNVHSMEGDAWgBRaNhxMrD56QpJebPq58gSTsZMa\nQDAdBgNVHQ4EFgQUvoQiFdKlm0+ep93wxhgZCZrqdhswNAYDVR0eAQH/BCowKKAm\nMBGCD2Zvby5leGFtcGxlLmNvbTARgg9iYXIuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgE0sVAf9Kttuqgca7EWIMXSUd7fbFEh24/K7CnfSCzr8CIQD33cCH\nZK08PAKztL8nfcrOQBNMJP11qoH4zJxHa7lpDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICBTCCAaugAwIBAgIUEHhVHUoQocn7EaLQEZv5m0Yw1n0wCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjcyMDgxMDY5ODkwNTU5NjQxODE2NzA4ODE5NTk3MzU2MTE1\nMTA5NzQzMDA5ODQ1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8AhWuFRs4dIXUkXupeU0RaEXbcbwvtx3ilaGoQPqNG/e8vSJkjuPoDC9OS9DlmSX\naeuL/rcRuzggP08pgRVxs6OBgDB+MB0GA1UdDgQWBBR8rC6qbFOkYaBw6eMFWqoS\nBWP3fzAfBgNVHSMEGDAWgBS+hCIV0qWbT56n3fDGGBkJmup2GzALBgNVHQ8EBAMC\nB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwGgYDVR0RBBMwEYIPZm9vLmV4YW1wbGUu\nY29tMAoGCCqGSM49BAMCA0gAMEUCIQD8JG+6j96j0UACOTiylvGsVnnjTHTRM/1U\nTQVaMXhHiwIgL+9el0mBgL+zxGnouk2w7cLpOooMrM8HgijYM1A6H9A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIHr0oyZbkWHbeY1IAFNPZdEKa0aNDMfGJNpaOCLZPbm7oAoGCCqGSM49\nAwEHoUQDQgAE8AhWuFRs4dIXUkXupeU0RaEXbcbwvtx3ilaGoQPqNG/e8vSJkjuP\noDC9OS9DlmSXaeuL/rcRuzggP08pgRVxsw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-invalid-dns-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA (NC: example.com) -> EE (SAN: .example.com)\n```\n\nThe ICA contains a NC that allows `example.com` and all subdomains,\nbut the EE's SAN contains a malformed DNS name (`.example.com`). This should\nfail per RFC 5280, since all names MUST be located within the\npermitted namespace.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUS2mAuy+A29q8cNqSfeAqlI0CObgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATzFEmjh0IRZjrsQkSPt8C6T2v58hb0HdVAGC5x\norJ9XGBKmD1XIw3KLg5i0sOxzkS2Y1y4RN5atOqmDvK/oLn+o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUl0KIdKkqA+M7EY/xrtvw1L/z/rIwCgYIKoZIzj0EAwIDSQAwRgIh\nAN58F/cF36QNScsj16LY06YltZWgLfC0Lqcu0H2g9vb/AiEAuv9VcXddpwSGi91c\nnhzlAFRuuxSmQFlFn/LpQXNPTrU=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICIDCCAcegAwIBAgIUUDmlGZxzp75LjsA0v+QYjWJhtqMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA0MzA1MjcxMDAxMjYxNzgzNDgyNTE5\nNTYyMjIyNjg0NDE3MTYxOTc0MDAxMzIwMjQxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABPzvts+Wazu3k2VsJo6o8SWwEzaZu+/YWmyHhR2FunWdIKeMi1NIAiyrhBdS\nk6d5QCXgmzChjyYRJuCyE0QGz4ejgZgwgZUwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUl0KI\ndKkqA+M7EY/xrtvw1L/z/rIwHQYDVR0OBBYEFBzhvDKI6PsXjrGXtZ18ZL8wHrd/\nMB0GA1UdHgEB/wQTMBGgDzANggtleGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBE\nAiA/6Sx680sUL0w3H0PlXzgo7R8sDNCknsoyly3JomHzPgIgNjdqUUA8JB5afgzl\nzWRHt64Pca6pxmOy8RWLnVUygaQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgIUUWGPdJuOBGrcxenInJWUUTf7grcwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNDMwNTI3MTAwMTI2MTc4MzQ4MjUxOTU2MjIyMjY4NDQxNzE2\nMTk3NDAwMTMyMDI0MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKvm+pYq2NSr+wQYySUcXIk0uOAwuZXBVOyjX1C2W1+IuH1MpAYildD9ldPt27gou\nXfk919PDWA5LsL5nJpedR6OBjzCBjDAdBgNVHQ4EFgQUe89v06rGtvu1FK7XSCn0\nRvf+yTgwHwYDVR0jBBgwFoAUHOG8Mojo+xeOsZe1nXxkvzAet38wCwYDVR0PBAQD\nAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMCgGA1UdEQQhMB+CDC5leGFtcGxlLmNv\nbYIPZm9vLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDv5BH9mnH+oNFMW\n+o+3l/cP4r7OklSDoe/773v2W/GoAiEAtO5fvgWfpFfYdr/iGu73HXiboFzNoGC0\nHY41MSZ65yA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIKd8q8UsaBElI8QTJjB439Wi7tE1wRzR2A11xZhVv3IJoAoGCCqGSM49\nAwEHoUQDQgAEKvm+pYq2NSr+wQYySUcXIk0uOAwuZXBVOyjX1C2W1+IuH1MpAYil\ndD9ldPt27gouXfk919PDWA5LsL5nJpedRw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-invalid-ip-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA (NC: 192.0.2.0/24) -> EE (SAN: 192.0.2.0/24)\n```\n\nThe ICA contains a NC that permits 192.0.2.0/24, but the EE's SAN\nis malformed (containing a CIDR range instead of an IP address). This should\nfail per RFC 5280, since all names MUST be located within the\npermitted namespace.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUCLibU6SNEXbTpGWXhwMEW6gHya4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARfHl0HdWYK52INfZoXOi31Y25ZjUM+VuDm/EyE\nQn2DzdYY6Y2WGRAvabdTmHWnh2L/CNRq4sQ0KVGQ8pD9cSW+o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUiXIfzpYsKHoZZevYsqHKeLGb9j4wCgYIKoZIzj0EAwIDRwAwRAIg\nWFSgHcM8ci1k/yY9Iux6GacAWpBZzq0VfBspayps2ZECID2zdxjUa5s0+Mq7jrlF\nqzKATnkUjKCWZRiEPYGkKiq5\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgIUVVosQnBiJ/uQyRy4XobPO/5EucMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBpMTgwNgYDVQQLDC80OTc4ODc5NDE0OTYwMjA4NzUwOTE5\nNjU1MDYyMzQyNTAxMTM1MjI0MjQ3MzM5MDEtMCsGA1UEAwwkeDUwOS1saW1iby1p\nbnRlcm1lZGlhdGUtcGF0aGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED70yFq+SiLO5y5bCEZHz/VohvS/OSjRqF3KPUTI6QA84Dyrt7RSo5SKpPek7\nep/ue9cXpf4GRjqB4ZKnWYBtUaOBlTCBkjAPBgNVHRMBAf8EBTADAQH/MAsGA1Ud\nDwQEAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNvbTAfBgNVHSMEGDAWgBSJch/O\nliwoehll69iyocp4sZv2PjAdBgNVHQ4EFgQUvX8wPOQ7mhIRNdhdc1eGb3D7HWIw\nGgYDVR0eAQH/BBAwDqAMMAqHCMAAAgD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDL\ndFPofCg7QG2tpdwS8bxQ3rZFrOpfTv4fAaoOnbODPAIhAKwggzb3gkzcAbGgge3v\nYEgSHfeSK5slScxzkn8tA5RW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICAjCCAaigAwIBAgIUHe9mWoSRXF+1lbfAXt6bNI/bOAUwCgYIKoZIzj0EAwIw\naTE4MDYGA1UECwwvNDk3ODg3OTQxNDk2MDIwODc1MDkxOTY1NTA2MjM0MjUwMTEz\nNTIyNDI0NzMzOTAxLTArBgNVBAMMJHg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tTm9uZTAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFjEU\nMBIGA1UEAwwLZXhhbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARF\nfRwqaZ3xWrOb+WphuxM+2Px1QZzDzYpi/OINCKnx4Y+1LwSJLmF05BiN6ashqT8z\nJ2isPG05Pd6Dh6fTzQeho38wfTAdBgNVHQ4EFgQUGHaYVJHHwtQRw074mSCHlFQS\nYR8wHwYDVR0jBBgwFoAUvX8wPOQ7mhIRNdhdc1eGb3D7HWIwCwYDVR0PBAQDAgeA\nMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBkGA1UdEQQSMBCHCMAAAgD///8AhwTAAAIB\nMAoGCCqGSM49BAMCA0gAMEUCIQC7q3wn1Ywew6oz3rpSr14tzNaygeDZjbuYskVJ\nbOqbAgIgS6hoR9WWIOvAo34HHD9foqb5WfR/ZoGvnvxsGw7wf0E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILM4xDwq0cgroAcMzSsD7TBh97b07oAFlnEJsWCXgdgdoAoGCCqGSM49\nAwEHoUQDQgAERX0cKmmd8Vqzm/lqYbsTPtj8dUGcw82KYvziDQip8eGPtS8EiS5h\ndOQYjemrIak/MydorDxtOT3eg4en080HoQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "192.0.2.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-invalid-email-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA (NC: example.com) -> EE (SAN: invalid@address@example.com)\n```\n\nThe ICA contains a NC that permits any email inbox on `example.com`,\nbut the EE's SAN is malformed (containing a malformed email address).\nThis should fail per RFC 5280, since all names MUST be located within the\npermitted namespace.", + "validation_kind": "CLIENT", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUFAqq+maP+PEyapS2+CsSyQqen1QwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATkujxl8Uu4R5AVUKAVD5H4LI8aCttNLZpunGvh\nw9sUiVuwUFkc0uY5sb5vCY+uvBk1B5aUdnHQLy6rNvmbObjmo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUn/VDZOJfwqmvGn3ZMZzV/ozngwMwCgYIKoZIzj0EAwIDRwAwRAIg\nJbU6x6HvuMJj+DEEEzMJlP1Fzr1JMUOSBGwwt5IEi98CIEjP/a0d/we3Y9jjhb7N\nlLiwNywpFuF82JkgLbnJpRMG\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICIjCCAcegAwIBAgIUSId6SQZsGdda3RyMb4+6zkEDC9EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAxMTQ0MTc3MTcxNjM5OTEwMjkzNjA2\nMjc4OTY0OTc2Njc3NjA3NTc4NDgwNTU2MzYxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABBCocMcSzsSakt4mX1R07pZcQpTGTeUL+lL4+dmDJsw5/Vkpl1iPQhYecFBw\nr9F21jCoy5TLnvpOOZzLj1O5WbqjgZgwgZUwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUn/VD\nZOJfwqmvGn3ZMZzV/ozngwMwHQYDVR0OBBYEFDDqFBDw3FMgm4cdia1irLCCALPM\nMB0GA1UdHgEB/wQTMBGgDzANgQtleGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBG\nAiEApCjyiTqHoL5ajSCmjuliik/mS3garhEc3l63Fx+UbskCIQCEnopwbeJgIYjq\nZVx/XpmQgENqCWIeXAfMn947G2kz3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgIUflQN4mU8JqV9+A9/hQkhB/Rv/G8wCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMTE0NDE3NzE3MTYzOTkxMDI5MzYwNjI3ODk2NDk3NjY3NzYw\nNzU3ODQ4MDU1NjM2MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrwHtL/R31F/ePGSvn8sUBpOFfN2tChSU2bGQQYDGB0M3wuWWtFWSCoN3BJqUVJuW\nKpsFruaysqtAcweEZtsIfaOBtTCBsjAdBgNVHQ4EFgQUfgwP+3g5Wc7a3x6+iFc/\nm4bPbEcwHwYDVR0jBBgwFoAUMOoUEPDcUyCbhx2JrWKssIIAs8wwCwYDVR0PBAQD\nAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMCME4GA1UdEQRHMEWBEGdvb2RAZXhhbXBs\nZS5jb22BFGFsc29nb29kQGV4YW1wbGUuY29tgRtpbnZhbGlkQGFkZHJlc3NAZXhh\nbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgadbmg1NoNmZxbrpIRn5gjzYfN8Yr\nIOyQ3UzPP4gMJwgCIQCZ/WCJX6PDFkZohikeh/qAWTi5iVohUEmrAzyPdb1aTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIGcoflzPi3DuDuIf70oN2AhzITjISpyIsMkQg0pQyMV0oAoGCCqGSM49\nAwEHoUQDQgAErwHtL/R31F/ePGSvn8sUBpOFfN2tChSU2bGQQYDGB0M3wuWWtFWS\nCoN3BJqUVJuWKpsFruaysqtAcweEZtsIfQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "clientAuth" + ], + "expected_result": "FAILURE", + "expected_peer_name": null, + "expected_peer_names": [ + { + "kind": "RFC822", + "value": "good@example.com" + }, + { + "kind": "RFC822", + "value": "alsogood@example.com" + } + ], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-forbids-alternate-chain-ica", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nEE (SAN:X) +-> ICA_B' (SAN:Y) -> No root to chain to\n |-> ICA_B'' (no SAN) -> ICA_A (NC forbids SAN:Y) -> Root\n```\n\n`ICA_B'` and `ICA_B''` are certificates for the same logical intermediate,\nbut issued by different logical root CAs.\n\nThis graph allows validation through `EE -> ICA_B'' -> Root`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBeDCCAR2gAwIBAgIUa/w8hJABS/T0qmKaZjQoulexLRQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARQ0zTYEfRwB/0glXa87IT1IKfWxTj4njuJ9FZv\nqeaVK+LHpM1SOtqi8Uj6Iq8G5JeXMgJACQ9tlibYIQf610lKoz8wPTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQUy333xEbS6g3jykE9Qpba\n3USA+V4wCgYIKoZIzj0EAwIDSQAwRgIhAOiuvI2sFTmBmgDUbiS9Yg1R1ej7J9Tx\nIig8KPcwbUOZAiEAhk7zIuME8RN50P3AEVQvJw/lsG57aMoz+QgLJm2oppo=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgIUTTbTjy73j6GwAPUB/c2eVAgT1QgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA2MTY0ODcwNzIxMTQwMjQ0NDk1ODEy\nODgwNDM4MzU4ODc3MDI4NDYyMzAwNDgwMjAxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABGqqJZHgReUsuCpk16Y9i4wdwp1KRoQUKjNs7w2PVnSgTN6giwNSdnC4x+cn\nlqSDme2WXtNIUClInf1di5lFB+ejgaUwgaIwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAUy333xEbS6g3jykE9Qpba3USA+V4wHQYDVR0O\nBBYEFCpCSHH0y9NwJKWvJd8695J5AFysMEIGA1UdHgEB/wQ4MDagGTAXghVwZXJt\naXR0ZWQuZXhhbXBsZS5jb22hGTAXghVmb3JiaWRkZW4uZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgeckgsa1fmlYbTrb8hzqVdXS2O9DNAxKNQ+sUqXhrvGAC\nIQCrARVHfCuHcio23MUOxH0lIeAc6SriV7xEvG751Uw7QA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBvDCCAWKgAwIBAgIUEbZ4JmEIFiSeZna3Tpk6DQlRdGEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA9hbi1pbnRlcm1lZGlhdGUwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARxasUIgsYHoAtTnmWr/etKWFYbW2MORIQPMVui\n8bHrOVQdvMm6t1TWlVidVETohRo5vAivmXyNo4ZGqkq97Xuso4GDMIGAMA8GA1Ud\nEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMCAGA1UdEQQZMBeCFWZvcmJpZGRlbi5l\neGFtcGxlLmNvbTAfBgNVHSMEGDAWgBRXLit6XRcrj9vJmL8yw3TQJKzAGDAdBgNV\nHQ4EFgQUfFHHpE8bKnPLnPpbeC+NlXMEo4AwCgYIKoZIzj0EAwIDSAAwRQIgBm6w\n2O2XnuActwRK8V2Z4AO9VOtsDQI5+wFWgGPkQ2oCIQDAVRh0HAqaE4XhsVa2VUm3\nwvd1fDMj/lLe1/79sBNumQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB6TCCAY6gAwIBAgIUCZRATk/Aa9LSlDSQNOaaHnoqZIkwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjE2NDg3MDcyMTE0MDI0NDQ5NTgxMjg4MDQzODM1ODg3NzAy\nODQ2MjMwMDQ4MDIwMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBox\nGDAWBgNVBAMMD2FuLWludGVybWVkaWF0ZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABHFqxQiCxgegC1OeZav960pYVhtbYw5EhA8xW6Lxses5VB28ybq3VNaVWJ1U\nROiFGjm8CK+ZfI2jhkaqSr3te6yjYDBeMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMB8GA1UdIwQYMBaAFCpCSHH0y9NwJKWvJd8695J5AFysMB0GA1UdDgQW\nBBR8UcekTxsqc8uc+lt4L42VcwSjgDAKBggqhkjOPQQDAgNJADBGAiEAiVtb9xci\nPPLIYDUlT/scp2/N8cMTeDmquYjuROI0j6ECIQDx017RPNYl5cikEOt4YAUtMHFF\n4MwPnDUldvuSW6gxrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBxjCCAWygAwIBAgIUSLgf9btaTwBMsypiAQD9tOznbjMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPYW4taW50ZXJtZWRpYXRlMCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAgMR4wHAYDVQQDDBVwZXJtaXR0ZWQuZXhhbXBsZS5jb20w\nWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASEfh7V29taNk/AteBAQSjZQkxcICfK\nAf5bqEveirj3694U2JELwLkNCHiJR1IMVHcssEh6Vpqzz5oeBKU0BI1Bo4GHMIGE\nMB0GA1UdDgQWBBT9g5ue7xPH+sseRfgTccww/mFB0jAfBgNVHSMEGDAWgBR8Ucek\nTxsqc8uc+lt4L42VcwSjgDALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUH\nAwEwIAYDVR0RBBkwF4IVcGVybWl0dGVkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCTTyUu0G9mHoCZIG/KuR+PiszI97SJybxl72L8k32zrgIgLZOw9olK\nfpyEQfIxH9JjL21rbMGI/4IOXArh4FS9I9s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIEWVwiYjjLkKhu6pL6VKjjeC+NXQk4oKIkJj3EpB40WqoAoGCCqGSM49\nAwEHoUQDQgAEhH4e1dvbWjZPwLXgQEEo2UJMXCAnygH+W6hL3oq49+veFNiRC8C5\nDQh4iUdSDFR3LLBIelaas8+aHgSlNASNQQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "permitted.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-forbids-same-chain-ica", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nEE (SAN:X) +-> ICA_B' (SAN:Y) -> ICA_A (forbid: SAN:Y) -> RCA_A\n |-> ICA_B'' (SAN:Z) -> RCA_B (no NC)\n```\n\n`ICA_B'` and `ICA_B''` are certificates for the same logical intermediate,\nbut chained to different logical root CAs. Both root CAs are trusted,\nbut `ICA_B'` is issued through `ICA_A`, which forbids `ICA_B'`'s SAN.\n\nThis graph allows validation through `EE -> ICA_B'' -> RCA_B`", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBdzCCAR2gAwIBAgIUXV5rWQNm3w7jMrBI+Mn4/PbWWoYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARTKrd/0Pnb/RVZjBHsAReyE4xEWLreKOEnB5k+\nERJvn15l6cgYsrj68Jr/+CRgXxc8qs/2skmIoV4u0z5W5ZLEoz8wPTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQUkmA3GdLDblNV+TyZMhaw\n3y38RLQwCgYIKoZIzj0EAwIDSAAwRQIhAO105JZB0kh3O8lS03ZiZ9rLat9HthDF\nY91bJvtUrf7qAiBkBzU2raNZV0YX/OtHhyW57lvRSkJCfeI/fE+y9YqbPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBeDCCAR2gAwIBAgIUYCj62g7OdJjJ4APMvNbRFMznLYswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARAApXMs64LbeQsR/Pm7u1trafk2FXxRdG/C3DO\ntgtBw3YpZ48N0JR8Uub1M0BpwKcNeHMejaJUI3aDzxbpqLKhoz8wPTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQUc8/loBCuun+m4TzS1dlc\nGeD2438wCgYIKoZIzj0EAwIDSQAwRgIhAJEJvvFj0FFEApkdFPLg7g132Wkhvbui\nFq6P6QV41V8OAiEAltImUNW5jUyMyRko4q0H8hDQMMUsK9ssliw7I4hA+cY=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgIUat5u6+MmRPbTqXv9oCa33TSfYkEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA1MzMwNDE3NjMwMzk1MjYxMzEwNjI2\nNzY3NDA3MTI0NzQ1MjE0NzIyMjQwOTA3NTgxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABO6MEeXzrn6EC0RntZhNa6E9zHqzyvqzxswsVxu0Z/O1ksM9qmhPKFEECVes\n4JogUuR4XFOIRpnkANjo/myc+JajgYowgYcwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAUkmA3GdLDblNV+TyZMhaw3y38RLQwHQYDVR0O\nBBYEFOiJmx00oQuBDAbyqqfu8bY9311DMCcGA1UdHgEB/wQdMBuhGTAXghVmb3Ji\naWRkZW4uZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhANSq9NF4QoTgWjQn\nwCOJBwmVLUtAm9CHdZ4LznYhe2CkAiBDhImMqk/MEWSpVc4+/f2DEXf8NiHt95s/\nIr1zI39mLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgIUHqYlsR18l55S+zZh2jb4ER5IRgwwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNTMzMDQxNzYzMDM5NTI2MTMxMDYyNjc2NzQwNzEyNDc0NTIx\nNDcyMjI0MDkwNzU4MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBox\nGDAWBgNVBAMMD2FuLWludGVybWVkaWF0ZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABExCLGxID3jMxVMbsdQz0SWxpmUXBSSLSCOnDxQQTZdPZH1YNq8cFKu51/53\nZEOXIVhMt41TA0AeLpTaYPvxuqOjgYMwgYAwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwIAYDVR0RBBkwF4IVZm9yYmlkZGVuLmV4YW1wbGUuY29tMB8GA1Ud\nIwQYMBaAFOiJmx00oQuBDAbyqqfu8bY9311DMB0GA1UdDgQWBBQBlC1EYPkjMXAZ\nVu/Bc/j3f29s0DAKBggqhkjOPQQDAgNJADBGAiEA9icN8/t4Rf0UMTjxZh3uhqh8\n02SfhrXj76YjedkdvzECIQCDJCAvZvW07b98fpLUGHJG+KiA7RjBm8idIi+VY62b\ntw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBwzCCAWqgAwIBAgIUe8ANEy64L7pVGFWEhne/fBM/iBgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA9hbi1pbnRlcm1lZGlhdGUwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARMQixsSA94zMVTG7HUM9ElsaZlFwUki0gjpw8U\nEE2XT2R9WDavHBSrudf+d2RDlyFYTLeNUwNAHi6U2mD78bqjo4GLMIGIMA8GA1Ud\nEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgIEMCgGA1UdEQQhMB+CHXVuY29uc3RyYWlu\nZWQtaWNhLmV4YW1wbGUuY29tMB8GA1UdIwQYMBaAFHPP5aAQrrp/puE80tXZXBng\n9uN/MB0GA1UdDgQWBBQBlC1EYPkjMXAZVu/Bc/j3f29s0DAKBggqhkjOPQQDAgNH\nADBEAiB56aDdqtv5M9t42cXYswtuPEwxVxvGl9ddzcShsu/V/wIgYjslBSnWiiJ/\nZgxlJ2qzo43jEk65ljfUkDcfs/HHLO4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBzjCCAXSgAwIBAgIUHGNDX+eUbJMR1oAqNGqTennbpXAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPYW4taW50ZXJtZWRpYXRlMCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAkMSIwIAYDVQQDDBl1bmNvbnN0cmFpbmVkLmV4YW1wbGUu\nY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4e7SLwWbjpgjoMBAZvKkysUv\nXCeTme/is8v74us8OvkgTxbuvQ3wz2KbMAtF8OBHNXXjS/wfnwuTvXhC7uZojqOB\nizCBiDAdBgNVHQ4EFgQUBEE2YbhRnRe2MQqKKYnTbRo+/gswHwYDVR0jBBgwFoAU\nAZQtRGD5IzFwGVbvwXP4939vbNAwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsG\nAQUFBwMBMCQGA1UdEQQdMBuCGXVuY29uc3RyYWluZWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgNSfcbGg+SUdDRvgxq1GiPqawfLh1imp3bFaH7BgVbIEC\nIQCLyJDpcRKRHfXKyVXr4aroihdw55S0Ir+ZEopOBTNPFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIeVlXiGfHf/wl0gYLDb9e7dmHKM6K/eyqDu/PpSLOyToAoGCCqGSM49\nAwEHoUQDQgAE4e7SLwWbjpgjoMBAZvKkysUvXCeTme/is8v74us8OvkgTxbuvQ3w\nz2KbMAtF8OBHNXXjS/wfnwuTvXhC7uZojg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "unconstrained.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-email-exact", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nroot -> ICA (permit: foo@example.com) -> EE (SAN: foo@example.com)\n```\n\nPer RFC 5280 4.2.1.10 an email name constraint may specify a particular mailbox,\nlike in this graph.", + "validation_kind": "CLIENT", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIURQgTmTcoJFj7DHdbtFZopjpL+JgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQOV3qbi8d8/lTdTNdOlQS1odTth1lvp18ueyco\nOh5xCgNTWrGP7wsakTTyTz9EH0lcF3TN7XloaSox2lr29iQxo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU9LRP3lXxUeEECXVfQZ54RfAyze8wCgYIKoZIzj0EAwIDRwAwRAIg\nDJD+WIJas520UXPPxKTFxXxPHqHH3Iv3Rts4lujn2BMCIEeeupS4fvi4e8JaUNzd\nSkAr0mdkbOkvttLPsZrTTH5J\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbOgAwIBAgIUehU9MrrGHpxwje0939I/C1ZAEUYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAzOTQxMDA0NzY0MTgzODM5ODMzNjQ1\nMjIwMTYxMjMxNDc3NTcwNDk2NDY2NzYxMjAxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABGM+V4oGbzEOTVd9SThkDK+fcCMs//AW/+ha56pkJKEW93knWemEI4VIe6Vp\nXIzq2ppmn2nDaBt3rDbhahQKP2KjgYQwgYEwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAU9LRP3lXxUeEECXVfQZ54RfAyze8wHQYDVR0O\nBBYEFIASwwN7/Gt1fLoPM5Fp4A2Q5VyNMCEGA1UdHgEB/wQXMBWgEzARgQ9mb29A\nZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAOogTK8CeN4EWLiwcNKIRHoF\nuVcnJL4EDV8LxzgMYOtQAiEA0E/5R3wXNpCTGhU32Q84hB5UF10vqSonI8nKyCYr\nUYw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICBTCCAaugAwIBAgIUWX7QUtOvORMRZQ0D2P43+8e8TLkwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMzk0MTAwNDc2NDE4MzgzOTgzMzY0NTIyMDE2MTIzMTQ3NzU3\nMDQ5NjQ2Njc2MTIwMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nS74Ov3w6eSDEDHihg3SDvdL4AJ1ckw0Jte3bzW8FqCnlodfMkL2yMnX1TIto7UV/\nrrYQ7BIKsDFKv0ln86c+KaOBgDB+MB0GA1UdDgQWBBTzprnJv4vM7gQROjKxbuwE\n+JyKIDAfBgNVHSMEGDAWgBSAEsMDe/xrdXy6DzORaeANkOVcjTALBgNVHQ8EBAMC\nB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwIwGgYDVR0RBBMwEYEPZm9vQGV4YW1wbGUu\nY29tMAoGCCqGSM49BAMCA0gAMEUCIQCNvcYxPPetGganUNzGatoxVGdf+CiVaCwU\nyr5ERxEmxAIgPLQlqHRLhs0det2zjYVdQCNK9jlf0w4/e2cGNI+Eojc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICzCn4DcaDbi/hcVaTGqwk8zbsZqHEtqL7tbJJf+/gkKoAoGCCqGSM49\nAwEHoUQDQgAES74Ov3w6eSDEDHihg3SDvdL4AJ1ckw0Jte3bzW8FqCnlodfMkL2y\nMnX1TIto7UV/rrYQ7BIKsDFKv0ln86c+KQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "clientAuth" + ], + "expected_result": "SUCCESS", + "expected_peer_name": null, + "expected_peer_names": [ + { + "kind": "RFC822", + "value": "foo@example.com" + } + ], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-email-domain", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nroot -> ICA (permit: example.com) -> EE (SAN: foo@example.com)\n```\n\nPer RFC 5280 4.2.1.10 an email name constraint may specify a host name to\nconstrain all inboxes on that host.", + "validation_kind": "CLIENT", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUFlevkdfcOCIG0H4I3GatMNIQMC0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAS3XhC7A1kTao5g6G+APK2yyklbeNURurjvd7+P\nVBQKepMxAN/Mwqf+fDWLp6a37Hq0F6zQ+lPrwzKYOK9ufAqwo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUWc81pPIlN4pL1wDQ5LwHyeQ0mWMwCgYIKoZIzj0EAwIDSAAwRQIg\nWtOzxgKVN+tfhes+x65XezOV3aXErfnt2FLW+GlR1ZQCIQCueyaMx7Lm629ZRbzN\nFaG+JymKnQ9KWK3E3X0W6Eprkg==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICBjCCAa2gAwIBAgIUHGGHHktZrkj9CecW6Fh6pCf6CoowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAxMjc1NTMyNTYwNjgzMDUzNTgyMzkx\nMjIwMDA3MTUxNzM3MjU2NjEwNTg1NzY0MjkxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABJ0LILyCKjv/B+hT7aXOtpU7VVH9q32W1MGTXxgu/SYRpk4QPbv68Qrz6itE\ndFlbBTPyIOEvRKdG4z/fEbyQYwWjfzB9MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMB8GA1UdIwQYMBaAFFnPNaTyJTeKS9cA0OS8B8nkNJljMB0GA1UdDgQW\nBBSEP2n2B0wnj4V+ix9WK/DHcOLFYDAdBgNVHR4BAf8EEzARoA8wDYELZXhhbXBs\nZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgKzTSg+qmfQ3H5f7as8JbX+kbAhNievow\nUNsgFOtBNTgCIDk+385CdxqAfdimD53qfo+lpjis5Cso/Et76x5m/W1g\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICBDCCAaugAwIBAgIUbrogFeBovkwRmUQIL9LnkA0AoTAwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMTI3NTUzMjU2MDY4MzA1MzU4MjM5MTIyMDAwNzE1MTczNzI1\nNjYxMDU4NTc2NDI5MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n20LxtmKuMLiXZA8umZxrkvARgnyQzFBLfDUu8qG4NVWgE8mKBfW1atoY9XVViCTG\nHJFMVzKhbveLX7HPb/lBm6OBgDB+MB0GA1UdDgQWBBRuqVbGJ20p+R0CvcXHyTpK\nQPjBRzAfBgNVHSMEGDAWgBSEP2n2B0wnj4V+ix9WK/DHcOLFYDALBgNVHQ8EBAMC\nB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwIwGgYDVR0RBBMwEYEPZm9vQGV4YW1wbGUu\nY29tMAoGCCqGSM49BAMCA0cAMEQCIB4JN7o8s2dJgQdEfe2M6ltnq28MQszLKluj\nZQ7bgWvoAiBkQH8WiYra/HFHqzgfGjOetU5jGcUVRlNxpGfQrnQoNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILoDLGLae9MImakzDqiieCsS/8NPL+BmRZlHZIHhiWUKoAoGCCqGSM49\nAwEHoUQDQgAE20LxtmKuMLiXZA8umZxrkvARgnyQzFBLfDUu8qG4NVWgE8mKBfW1\natoY9XVViCTGHJFMVzKhbveLX7HPb/lBmw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "clientAuth" + ], + "expected_result": "SUCCESS", + "expected_peer_name": null, + "expected_peer_names": [ + { + "kind": "RFC822", + "value": "foo@example.com" + } + ], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-email-domain-rejects-subdomain", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** graph:\n\n```\nroot -> ICA (permit email: example.com) -> EE\n```\n\nPer RFC 5280 4.2.1.10, a bare email name constraint applies only to\nmailboxes at that exact host, and a leading period is required to cover\nsubdomains. The EE contains an rfc822Name of \"foo@sub.example.com\",\nalongside a dNSName used for server identification.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUDVKYPeEVZxBWKR6fp51GCV6DeK4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARWV4IUnmoEzKDuQ4jbu2RZAOh0i8zd7dssN47o\nYH22LOT7OB5bCgNCz3T09+/h3ak/PWnJR2/J+XMn5bD0VwZbo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU7zHowKjJiRSq3f3cbABi2IXERHUwCgYIKoZIzj0EAwIDSAAwRQIh\nAMgQKMtUuF6RiVBnphX4iJ7fE0snrtOPNGiStevHd/+MAiBCMCzaGtGq6TLtHXBy\ncj1g9lxVJRs0QeBE/V/J/yfXlQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICBTCCAaygAwIBAgIURf04VxHeeHhtg3fzH6GlBc0x6WYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBpMTgwNgYDVQQLDC83NjA1ODgwMzI1MDg2Mjg2MjMxNTUx\nMzg1Nzk2MTQ4OTcwNDM4NDg3NjIxNDQ0NjEtMCsGA1UEAwwkeDUwOS1saW1iby1p\nbnRlcm1lZGlhdGUtcGF0aGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETifiw/7CeuT1+AkyoA00fimqRRB1TQKgZKcj9g0GmVtB97iX4tYLbjFQ156C\nsB+6OivFVD0ao6t8oHaA8GbZEqN/MH0wDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8E\nBAMCAgQwHwYDVR0jBBgwFoAU7zHowKjJiRSq3f3cbABi2IXERHUwHQYDVR0OBBYE\nFFGltVEAdJTXiHg3Yps9XmgWlSG0MB0GA1UdHgEB/wQTMBGgDzANgQtleGFtcGxl\nLmNvbTAKBggqhkjOPQQDAgNHADBEAiBcDo6/dtPpDc2SIKFmaog3GnygxgGdvhDb\nTIIFu6WHPAIgI+F6encrv8PEsYqqQ2tsDKGDZv74qggxv4z48/2/LEM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFzCCAbygAwIBAgIUYYYFS77m13jReMm4qddw3k8XToMwCgYIKoZIzj0EAwIw\naTE4MDYGA1UECwwvNzYwNTg4MDMyNTA4NjI4NjIzMTU1MTM4NTc5NjE0ODk3MDQz\nODQ4NzYyMTQ0NDYxLTArBgNVBAMMJHg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tTm9uZTAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFjEU\nMBIGA1UEAwwLZXhhbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARQ\nVjEj1RNkmOWtgAEpHnced6YieK597X+1+cty1ZM6+a3j/Bm5TodvjleYT3kX+zGR\nS2hfXGJhhmiPiDsHlzwro4GSMIGPMB0GA1UdDgQWBBT34gvZSAD1hMJ9zK8xbSi8\nZPHpyDAfBgNVHSMEGDAWgBRRpbVRAHSU14h4N2KbPV5oFpUhtDALBgNVHQ8EBAMC\nB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwKwYDVR0RBCQwIoILZXhhbXBsZS5jb22B\nE2Zvb0BzdWIuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAPE/UKwE9i5y\nUyw29pvEdjnCccZjZEtD+Mfegz5UXMX1AiEA/lefU/eyphTz/Vb7NtNtLBxmXCpW\npAFON8dhbLh2rJ0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIEQTb1fvxL81FGEtgW4lanN9d1jUCd/G+bPpePjkBLg4oAoGCCqGSM49\nAwEHoUQDQgAEUFYxI9UTZJjlrYABKR53HnemIniufe1/tfnLctWTOvmt4/wZuU6H\nb45XmE95F/sxkUtoX1xiYYZoj4g7B5c8Kw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-email-subdomains-rejects-apex", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** graph:\n\n```\nroot -> ICA (permit: .example.com) -> EE (SAN: foo@example.com)\n```\n\nPer RFC 5280 4.2.1.10, an email name constraint with a leading period\npermits mailboxes on subdomains but not on the named host itself. The EE\ncontains an rfc822Name of \"foo@example.com\", alongside a dNSName used for\nserver identification.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUaDkUpsij03B7gyjnGP5hVeZrsxYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQG9JAkYs8PBQDNldR923i3K8Oo+5AjhGPTJhTf\nTg/u5nqtw3bGRALLpihaYsqpKIMu1NQoPzZW0g++QC6SBODso1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUaonfQpYJ/BmIJOZmrbD4hpunRB4wCgYIKoZIzj0EAwIDRwAwRAIg\nItP5y3PzOlIpKzFbwkcUpbLhIDYHZijvimJN9PeCnRwCIEeJTazt+V/c1zFUFNeY\n74Ey+STsfMlxdRIBa3KaxDaY\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgIUf7HZxAEGIRCiZpBYdQ4Wdn56YDAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA1OTUwMDc5ODE2NDEyODMzMzIxNjUx\nNjI1MDg4NjMwMzYxMDM1ODI4MTUwNzMwNDYxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABIUzMmewrfu/+3boogwL7x2wfC5gkwXXDRVipMkoNzZcGWsvQIpxsQtMcA+b\n2AzNI4i3U1+KgYFPIyIFbvmEtpOjgYAwfjAPBgNVHRMBAf8EBTADAQH/MAsGA1Ud\nDwQEAwICBDAfBgNVHSMEGDAWgBRqid9Clgn8GYgk5matsPiGm6dEHjAdBgNVHQ4E\nFgQUbxEaAIIXwNjtzHygBoT4DuhWhewwHgYDVR0eAQH/BBQwEqAQMA6BDC5leGFt\ncGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAu8TXmagjdY8NLazq67drkLEjfXY1L\nUK0DIzVlrt8tvwIgD0fDV8aPI/X59BkgIIOsmk3GSjJXmcZyIUsRg2fmBIQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgIUSXKr4DohQveagBkPQo/Eqw5ezcMwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNTk1MDA3OTgxNjQxMjgzMzMyMTY1MTYyNTA4ODYzMDM2MTAz\nNTgyODE1MDczMDQ2MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nicq3wLFpw46sHmUIQ4DGMoLGDnJtra79LPLLQ6gzkCRs5H6nEu/sDF044Xeo9qxE\nlcJgiYBUAwDh4i3nby128KOBjjCBizAdBgNVHQ4EFgQU3vqnVIxCbukfYfnQVn/j\nVYKcI9EwHwYDVR0jBBgwFoAUbxEaAIIXwNjtzHygBoT4DuhWhewwCwYDVR0PBAQD\nAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMCcGA1UdEQQgMB6CC2V4YW1wbGUuY29t\ngQ9mb29AZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAP+osHZZuTag7Q3d\nZQ8acHtUKhuBF2C7CgDrPUs6XusBAiEAmD8OlnCRhvWK2Prk2rQwgMZ7/DFNxLfS\nZe5SaGWRhbM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICMUlia+307IA3fAqUQmqoBFQ0eTY3FQQ3TPWagQ7o1HoAoGCCqGSM49\nAwEHoUQDQgAEicq3wLFpw46sHmUIQ4DGMoLGDnJtra79LPLLQ6gzkCRs5H6nEu/s\nDF044Xeo9qxElcJgiYBUAwDh4i3nby128A==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-email-literal-asterisk-exact-match", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nroot -> ICA (permit: *@example.com) -> EE (SAN: *@example.com)\n```\n\nPer RFC 5280 4.2.1.10, an asterisk in an email name constraint is a literal\ncharacter, not a wildcard. The constraint `*@example.com` should permit the\nexact mailbox `*@example.com`.", + "validation_kind": "CLIENT", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUUy559dDtxK47ShdI4MeHwhLnhTcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARD1kzND6Wx+O2XOXSNSvUsuiQpDG4h4ipnDP2l\nzT45sZnxCV2/tsnQrwx8W0+VlfwOvuNwEdaA9tKd5DX7f3wBo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU1c3y7CI1dTB6xI00zlkPHgFNnW0wCgYIKoZIzj0EAwIDSAAwRQIh\nAIUQoJbPjOSqwsIU1rsrk2B51yGHERMIikTeJ2e+Tm69AiBu7TIRCt9nq0bNIMYH\nKEJtITdoVPRNBFdRoH2uMA8GGw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgIUNkDeuawy+AXtGJfkxdMo5GjmE5cwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA0NzQ4ODI2OTI0OTEwMDI3MTQ0MzA2\nOTY0MDk4ODY2NDY4NTMwMjUwMDI5MTUxMjcxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABDu38myLEqpb5w8B4kidG9sj9P4mXFJw118RRUX5NFk5tUNWeyPhRkQkmySU\nNX9TWCDD3vh+z603uwFwg+ULhMijgYEwfzAPBgNVHRMBAf8EBTADAQH/MAsGA1Ud\nDwQEAwICBDAfBgNVHSMEGDAWgBTVzfLsIjV1MHrEjTTOWQ8eAU2dbTAdBgNVHQ4E\nFgQUeTEbu6U+QN4+HCBndIXkP04Th/cwHwYDVR0eAQH/BBUwE6ARMA+BDSpAZXhh\nbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgUDV1z/ZjoIQXmseNXgQMAWIQOc7V\n8cStm3/Pysu9MjoCIA/vyFGypeaHVzqAW9OfqMISCKu55pyqXmkd74CBABD+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICAjCCAaigAwIBAgIUX2QvrLLoQmq6ByX5mPXHle1sLXowCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNDc0ODgyNjkyNDkxMDAyNzE0NDMwNjk2NDA5ODg2NjQ2ODUz\nMDI1MDAyOTE1MTI3MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nn+kdgcYt7bs/uLN3e8SK+8+9/S6AyB6RmJ+KKPbXKbDW1exce9yqm38bgcDzOaLq\nfbAWcIxREhkd/Ya/oNBF16N+MHwwHQYDVR0OBBYEFLOLtTUQVmXzA501FCohV76C\nxMesMB8GA1UdIwQYMBaAFHkxG7ulPkDePhwgZ3SF5D9OE4f3MAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDAjAYBgNVHREEETAPgQ0qQGV4YW1wbGUuY29t\nMAoGCCqGSM49BAMCA0gAMEUCIBGVSsTQQ3Re6hv97cn/MGSCbi25uhg9M5qUUeDS\nAgFlAiEAmQ4w7AGX1scaHHGdwlTyCqfyKVeyAJzQpKfdXr7908Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIORKWchrM7g2Xuf9fp7UuUQgg+FLKk+MfmJ0EmkEfPdZoAoGCCqGSM49\nAwEHoUQDQgAEn+kdgcYt7bs/uLN3e8SK+8+9/S6AyB6RmJ+KKPbXKbDW1exce9yq\nm38bgcDzOaLqfbAWcIxREhkd/Ya/oNBF1w==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "clientAuth" + ], + "expected_result": "SUCCESS", + "expected_peer_name": null, + "expected_peer_names": [ + { + "kind": "RFC822", + "value": "*@example.com" + } + ], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-email-literal-asterisk-rejects-user", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** graph:\n\n```\nroot -> ICA (permit: *@example.com) -> EE (SAN: user@example.com)\n```\n\nPer RFC 5280 4.2.1.10, an asterisk in an email name constraint is a literal\ncharacter, not a wildcard. The constraint `*@example.com` should NOT match\n`user@example.com` because the asterisk must match literally, not as a\npattern.", + "validation_kind": "CLIENT", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIULXNsbZAMD0iwUVIkN3XrtnVdN6owCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQC0KJwE8EyFnvQL//FuAsrpa6BcCCg6hG/IOeL\nz4u/BksN+kvKu7xQfnhSLRC5jeklEToWIgcSqiI+oTMg4gZ1o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUPQWqKph8RwXcx58//iB307LVwJgwCgYIKoZIzj0EAwIDSQAwRgIh\nAItMWuO/IH5CV02t151Qn7XlGuHww0l+ZHInGTt8OnoVAiEAmJw/P6xXdiTxlw6A\nWhGvIgea7BisRblBmCnNC0sd0bs=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgIUfZP84g8M8ksQi1Ysip036ug+h2QwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAyNTk0Nzg2MTU3OTQwMzM4NzM2OTEx\nNjgxNjcwNDUwOTc2NzY3Mjg5OTIzNDgwNzQxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABOIUnALpGw/uQBBkw6+u6K8oSVpTS5UKvreomz0l5UDeL17ulwoB1uT10hev\n3gQsM/2AjJ4X9YkmdkrS2wiI2h+jgYEwfzAPBgNVHRMBAf8EBTADAQH/MAsGA1Ud\nDwQEAwICBDAfBgNVHSMEGDAWgBQ9BaoqmHxHBdzHnz/+IHfTstXAmDAdBgNVHQ4E\nFgQUriXGqTPhK07oImPAvAhk6rhI47wwHwYDVR0eAQH/BBUwE6ARMA+BDSpAZXhh\nbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAOu/ZxUPNfX4jhDi3kvym0uYx2O/\nl0BQPHoCEb6+EBzsAiEAuiuTjVpbgFRJmTwr2rfHrUpNIX+UwjAhURP4MPUynaU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICBzCCAaygAwIBAgIUHEBiGIasmIMQQWsQQ5rzkMWMFz0wCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMjU5NDc4NjE1Nzk0MDMzODczNjkxMTY4MTY3MDQ1MDk3Njc2\nNzI4OTkyMzQ4MDc0MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3z4/A8PSSFf9k7dc4AcMGuQ+qZ+lizervsOzxlREWChElrcjSFpAnrp04HXQf5US\nD4Lg5HNkDcpT5uEPhijfC6OBgTB/MB0GA1UdDgQWBBRNmA1f1RZ4jPkKD8XhSmTE\nhJwmNTAfBgNVHSMEGDAWgBSuJcapM+ErTugiY8C8CGTquEjjvDALBgNVHQ8EBAMC\nB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwIwGwYDVR0RBBQwEoEQdXNlckBleGFtcGxl\nLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAlyB3xsxq+f7zpJSI4YA7peLX7l1L2gAO\nVsiYjwC1zGQCIQDaiWKTHYPNNha8Gjq6niCNounxvYHlxkS1FP9bEwnbZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEII22t382lpwM2kGGVDpFZdq3dYLtNJoxokLNfcMh278poAoGCCqGSM49\nAwEHoUQDQgAE3z4/A8PSSFf9k7dc4AcMGuQ+qZ+lizervsOzxlREWChElrcjSFpA\nnrp04HXQf5USD4Lg5HNkDcpT5uEPhijfCw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "clientAuth" + ], + "expected_result": "FAILURE", + "expected_peer_name": null, + "expected_peer_names": [ + { + "kind": "RFC822", + "value": "user@example.com" + } + ], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-email-literal-asterisk-rejects-subdomain", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** graph:\n\n```\nroot -> ICA (permit: *@example.com) -> EE (SAN: *@subdomain.example.com)\n```\n\nPer RFC 5280 4.2.1.10, the constraint `*@example.com` should NOT match\n`*@subdomain.example.com` because they are different domains, and the\nasterisk is a literal character in both cases.", + "validation_kind": "CLIENT", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUe87WZ4FTSqjV4P1r0YYxhOjVARkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARUdWg+W/Tz8rxhQt1wzfJ50rImyUEA7lCegUS5\nSO5aPW349yB12R6diArpKlBENmaC16XPmjDmn3fTFMVAtJFEo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUGB8njO9pkbxe9n6LT3TmXX5Mb8IwCgYIKoZIzj0EAwIDSQAwRgIh\nAJp3UzSJbxUeXjEe7Vy8EqM8TZLnEOx3NA9S6+pWiudYAiEA8wXoXhtNql2v95Sn\nNvG7sL0aXSAD6vA1Z3jhjdR8dDg=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgIUY9aOH0dJPVfXbKXXOzW43drp3C4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA3MDY4MTg0OTU1NzI0MDU2NDU3Njc2\nMjM5ODMzMTYzMzQyNzQ1NDQyMjU1NTA2MTcxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABC4wRcQEzpQ5Q6uNZ316bexgHtly0xBZ2oiBkLfhPghI54LV20hhc6ww1Uxn\ns5TT3RoAYAHdfFcY4DvU4R6zGtOjgYEwfzAPBgNVHRMBAf8EBTADAQH/MAsGA1Ud\nDwQEAwICBDAfBgNVHSMEGDAWgBQYHyeM72mRvF72fotPdOZdfkxvwjAdBgNVHQ4E\nFgQUXK4p5L26U1+Vl1qDBu2glNz+mmEwHwYDVR0eAQH/BBUwE6ARMA+BDSpAZXhh\nbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAOYkj42kyESpoX3nUQUAjTMEqRo6\n9vms8jlo1s/5WmHpAiEAuPk2r1BAG/kgLtf+y/hiV7l2eSjWDi1CuV9QkNsbGrQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgIUBnoNKd9H4CbBxPtYrYSOF9JJ2FAwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNzA2ODE4NDk1NTcyNDA1NjQ1NzY3NjIzOTgzMzE2MzM0Mjc0\nNTQ0MjI1NTUwNjE3MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9A0OjbNjZZpMBRws/WR6IHuDo+UiPDRKasFMqU9GSnE0rS2TuyWQn26gIF9mEAYp\ndzIVQzeubWFhuz8WA/CY7qOBiTCBhjAdBgNVHQ4EFgQUCNgAiEhumN6PW9ELHQL7\n8hvQBP4wHwYDVR0jBBgwFoAUXK4p5L26U1+Vl1qDBu2glNz+mmEwCwYDVR0PBAQD\nAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMCMCIGA1UdEQQbMBmBFypAc3ViZG9tYWlu\nLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC3cSqSdK76lNZoLz5Je9JT\nVUftjFg00hqsP3RYG8joJwIgbqAdl1+NZju20j2yMPlklS9RWVI1FpcIXc8ANKoZ\nOhA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIN/se8X8HOLyWoQLio/lGeQ61dC8zBdBmxw/OMr2GHTIoAoGCCqGSM49\nAwEHoUQDQgAE9A0OjbNjZZpMBRws/WR6IHuDo+UiPDRKasFMqU9GSnE0rS2TuyWQ\nn26gIF9mEAYpdzIVQzeubWFhuz8WA/CY7g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "clientAuth" + ], + "expected_result": "FAILURE", + "expected_peer_name": null, + "expected_peer_names": [ + { + "kind": "RFC822", + "value": "*@subdomain.example.com" + } + ], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-email-literal-double-asterisk", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nroot -> ICA (permit: **@example.com) -> EE (SAN: **@example.com)\n```\n\nPer RFC 5280 4.2.1.10, any characters in an email name constraint are treated\nliterally. The constraint `**@example.com` should permit only the exact\nmailbox `**@example.com`.", + "validation_kind": "CLIENT", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUScI/in4FH1GYizy+GB4l7i5I4eMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATo6WveQppHTD8nyXFEhry6Gp1H3KsmxKz94o+U\nbjuZT8KWcJpZXm5XMLvacMyb1YJBtZVqhFbN57MreOXhQB4Yo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUx3MWPIzWPeOmhLbRhb6peiFj50wwCgYIKoZIzj0EAwIDSAAwRQIg\nQaOLAjgWhNTd0BDq0so7is7QOHUzDIyg8MxOQ/Ul+5wCIQCSmMrGHMwxMCCm61+O\nlqEZu8/FK+UdaJpiK9e/mLi4aA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgIUaC8gN4Z3almyZ5VSe/RkzLmK4Y8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA0MjEwODgyMDYwMzkxNDQ4ODYzMTYx\nMDUxMjc2ODcxMDY3NzQ5MTI1NjgxODk0MTExLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABP0Su4QuJv76rCgxRC2aZXHsNB4z9/eRbU8cBUU19fpy9e9wMjNJJJzrTazF\noRbJZY2rQfxaLC5naFvoxzP0eEijgYMwgYAwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAUx3MWPIzWPeOmhLbRhb6peiFj50wwHQYDVR0O\nBBYEFMnQRznPkVetsU+3JyWmYmX1IHoEMCAGA1UdHgEB/wQWMBSgEjAQgQ4qKkBl\neGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA1C2XuFd79KU+HfnyoVvAbhmF\nsEgR7ho9c1QcSdgti3QCIFUoRgx4TyJfjXxG1I4VPNhl8Wmbcni6UwTru6oZSn52\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICAzCCAamgAwIBAgIUHPbXp1fb8Pl/cpTOGvrmzi7ilSswCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNDIxMDg4MjA2MDM5MTQ0ODg2MzE2MTA1MTI3Njg3MTA2Nzc0\nOTEyNTY4MTg5NDExMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nu+yffHjc4b3x+FqXfH6nQF3MfdXETpTVLzBt1EdJpdNVZ4fZPbDcSrn4otbrQ4B4\n1vMVYAbUoPiQx7K4GGeTz6N/MH0wHQYDVR0OBBYEFPZSv0QSEmPX6GkXZomtx+nv\nnvLtMB8GA1UdIwQYMBaAFMnQRznPkVetsU+3JyWmYmX1IHoEMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDAjAZBgNVHREEEjAQgQ4qKkBleGFtcGxlLmNv\nbTAKBggqhkjOPQQDAgNIADBFAiEAhEqo90dMd8IUcRFZlTXb9+vPLIga7/QIjjRN\n1EVy5GACIExnibgwPbuUWKmyb0fK2JwIoU/UGxqXTBEbJWYEqjOh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIGK9MpJIl8GXGl53NGNEidRexuRpMDneTmi7C/PyOdvMoAoGCCqGSM49\nAwEHoUQDQgAEu+yffHjc4b3x+FqXfH6nQF3MfdXETpTVLzBt1EdJpdNVZ4fZPbDc\nSrn4otbrQ4B41vMVYAbUoPiQx7K4GGeTzw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "clientAuth" + ], + "expected_result": "SUCCESS", + "expected_peer_name": null, + "expected_peer_names": [ + { + "kind": "RFC822", + "value": "**@example.com" + } + ], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-email-literal-double-asterisk-rejects-single", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** graph:\n\n```\nroot -> ICA (permit: **@example.com) -> EE (SAN: *@example.com)\n```\n\nPer RFC 5280 4.2.1.10, the constraint `**@example.com` should NOT match\n`*@example.com` because the asterisks are literal characters, not wildcards.", + "validation_kind": "CLIENT", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUbEoz2RqLrmNMP08tRaVXdRYMrBQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAS0qHqyJ1pgEo4gOjB8NgQkHbQ5zBFcEBOA6Mwk\nUvG1xA5db4t7GcM74ncwUGhX9nvApxhhAF3SVNn/w1D0twe/o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU2psN6O7gDH9qFTmEwYfqN5BRqikwCgYIKoZIzj0EAwIDSAAwRQIg\nB92zb0XJwyazgEkXElxJzY1LSFZpVKDCu8uzOqhYEH8CIQDDuapsTzwoM/6N9b9D\nkQVoCSkSQR35pkI5+fIfVBQung==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgIUaX012CtLuR4CHb3pt6B5eHwlX/wwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA2MTgyMjU3NzQ5OTY4MDcyNzA1MDYw\nNzk0MDYzMzkzNDIzMjEwNjgwNDM3MDk0NjAxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABPrjzt4FQupzIgROJIRhLWlEsz7tjOmWFVVmUUkuTHZPBCLUFfZ+K2CyR+in\nuZqgFeqwmkg/k5QPjt/rseeGUKKjgYMwgYAwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAU2psN6O7gDH9qFTmEwYfqN5BRqikwHQYDVR0O\nBBYEFIlMrmFPjTeaL1axl7vJkXVDE0bpMCAGA1UdHgEB/wQWMBSgEjAQgQ4qKkBl\neGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA4Y+en/T9vrjsGs1LoHEm1ne3\nuActQMOt6Knmq6G2mjoCIQDM8krqXgj8VxbDDGnMyKiJMOuPdcIg6Y345m584gz+\nhg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICAzCCAaigAwIBAgIUPKVe/M0a0xrxC+KVL3a4mNkiVvEwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjE4MjI1Nzc0OTk2ODA3MjcwNTA2MDc5NDA2MzM5MzQyMzIx\nMDY4MDQzNzA5NDYwMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntvRM/lIs/tbxF4l4YyBNjFQn7g4TUQgv4w3oDZnaBnUsdHXBWvNK7YBNRZF6aMTP\nYEs09pfVopfCVBxuJewyIaN+MHwwHQYDVR0OBBYEFP+E/El/xrLqYElyFO2OtWSJ\noV6EMB8GA1UdIwQYMBaAFIlMrmFPjTeaL1axl7vJkXVDE0bpMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDAjAYBgNVHREEETAPgQ0qQGV4YW1wbGUuY29t\nMAoGCCqGSM49BAMCA0kAMEYCIQCmR8NeFvpbzr55PXb0S9Fz+UyJgpvxiTf7tP9N\nOVWHCQIhAJfVFzWZukJgGOgBVCtytQWV6twDm4aXixj+r18DA73U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIMCE64+oytgyvfK5vprDjyw4Rtd6xypzytOsphIkX6j6oAoGCCqGSM49\nAwEHoUQDQgAEtvRM/lIs/tbxF4l4YyBNjFQn7g4TUQgv4w3oDZnaBnUsdHXBWvNK\n7YBNRZF6aMTPYEs09pfVopfCVBxuJewyIQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "clientAuth" + ], + "expected_result": "FAILURE", + "expected_peer_name": null, + "expected_peer_names": [ + { + "kind": "RFC822", + "value": "*@example.com" + } + ], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-email-literal-mid-asterisk", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nroot -> ICA (permit: user*@example.com) -> EE (SAN: user*@example.com)\n```\n\nPer RFC 5280 4.2.1.10, all characters in an email name constraint are treated\nliterally, including asterisks at any position. The constraint\n`user*@example.com` should permit only the exact mailbox `user*@example.com`.", + "validation_kind": "CLIENT", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUcboWC6FzMqv9l/3KbhMUKn5A96MwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATYg/i1nHtlnQ/y0T6wAj3+ZaikGohqtW5lsaY6\nuUXhGg5NLLS/+80iN/ASXjZSwenblqPl8/FpidyctmrOGhLyo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU2nQ42DVH/pWUanWKTrs9WubVVVUwCgYIKoZIzj0EAwIDSAAwRQIh\nAK6qTeBWioS0mZc+yK82XUl2Tcp+5QRj2aoGRm94Ww4EAiAv3tbWqk9ot8rh2qNo\nWnGqTwYprVA3H6LdoRZ+srUARw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgIUKJOOhYYjz1ZzyPHDydYkByOk0ocwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA2NDkyNjU4MTYxMzgwMjA5NDYyMDU1\nMDI2MTI2MjY3NjcyODk4Mzg0OTQzNDkyMTkxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABIMfkgLNEoKXQnLW2XxjqRccbP7ptHX2IBjqO50+FmxASD8mykaxYYiHMy3/\nmqkCWn8wm3Y3NhAkeelvsRVMNrOjgYYwgYMwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAU2nQ42DVH/pWUanWKTrs9WubVVVUwHQYDVR0O\nBBYEFMqECWH8XwmAMX2TFCzvPSYp+YVhMCMGA1UdHgEB/wQZMBegFTATgRF1c2Vy\nKkBleGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAgEb4ihYFM7tWZiCb6Kox\nyo39LJpMifGNB4DCzPfNHBsCIH2Wo+flR+H4b10jG5NpFnSsotv8cG/pwe9FDJdI\nKpyu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa6gAwIBAgIUCu2umf3qyTdmmyua4H5oyWr7mAQwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjQ5MjY1ODE2MTM4MDIwOTQ2MjA1NTAyNjEyNjI2NzY3Mjg5\nODM4NDk0MzQ5MjE5MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1FPCgteJm8vvDRVQNqd+AvMlGjv3PCHMLkFzlmg2kedL2LgSYGMSnqTQT+FEEW1c\nji3+1Hf5/irRpGIq9c7dEqOBgzCBgDAdBgNVHQ4EFgQUv8Z87wR92cAlEUiqFlYz\nekzom0kwHwYDVR0jBBgwFoAUyoQJYfxfCYAxfZMULO89Jin5hWEwCwYDVR0PBAQD\nAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMCMBwGA1UdEQQVMBOBEXVzZXIqQGV4YW1w\nbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDfYSuWlZo+ClHZDrmqw4lvfuchJJLo\nS2VF+q4PcAxz9wIhAMTwNrpl8z7PvtWZ6a8KZijNVM1TLF6aZ6f9ZJnLNic6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIEc3KcubN5tZi533xxbjuKHJkRD54tMHupVhn/8H/LscoAoGCCqGSM49\nAwEHoUQDQgAE1FPCgteJm8vvDRVQNqd+AvMlGjv3PCHMLkFzlmg2kedL2LgSYGMS\nnqTQT+FEEW1cji3+1Hf5/irRpGIq9c7dEg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "clientAuth" + ], + "expected_result": "SUCCESS", + "expected_peer_name": null, + "expected_peer_names": [ + { + "kind": "RFC822", + "value": "user*@example.com" + } + ], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-uri-host-rejects-subdomain", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** graph:\n\n```\nroot -> ICA (permit URI: example.com) -> EE\n```\n\nPer RFC 5280 4.2.1.10, a URI name constraint without a leading period\nspecifies one exact host, not a domain. The EE contains one URI on that\nhost and another on \"sub.example.com\", alongside a dNSName used for\nserver identification. The subdomain URI is not permitted.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUGeAa1cMYE7dlo/ifdhsAFLxUvIcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASNLjAGGw+jiK8wF/kYB30x8APLrp8lufGnQ3mF\nGVnOkAEkeANrMnyz3gz55B2pltBIgN6BkCxCfFUey5srAHM7o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUGZTMUd97ar9uTGawXralom0AyzQwCgYIKoZIzj0EAwIDRwAwRAIg\nSc7U0VDGXH4U8DApa0rJ0K+pUpZQsqcV5A0uydv7EAICIFcP6ZgMdg4VFwVvprs1\nmxslgoVVmySOamrRu0Cr4VkO\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa2gAwIBAgIUGzF2L+uv34BO9yMH8p0NcpnNGtkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAxNDc3MjI0NzM4NTM5Njk3MDE4MTQ0\nOTM5ODMzMTg2MjM2MzA2MTI3NjE5ODQxMzUxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABIZS3GlWNpQe5R0FmHR6TwxRqPefoHqwSzRiW9WPPxZbK6JZyobv42j3wuu2\nk40SwWZKw3RboCd7A1laUZwfapujfzB9MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMB8GA1UdIwQYMBaAFBmUzFHfe2q/bkxmsF62paJtAMs0MB0GA1UdDgQW\nBBSAkrvXMqGT2KyLTC4C+TOX1LMAXDAdBgNVHR4BAf8EEzARoA8wDYYLZXhhbXBs\nZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAOie6LXbR9hr/6VkI6Z75PvgGsVhd7UR\nDc1pjLsumeFQAiEAzskPqZg541PSJIxjKQbODGT/XG5eS21pHGVN/2a4mwE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQzCCAeqgAwIBAgIUOLPdBhKYVt0C1xdMWyqS0WrOH6gwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMTQ3NzIyNDczODUzOTY5NzAxODE0NDkzOTgzMzE4NjIzNjMw\nNjEyNzYxOTg0MTM1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlJBcfcj2Mx5m52oiiouuiQq1uYNeqsSCE9CKEOQaPn99X1s0FyyjrrnF+Z3xKw4I\njtOiI7IyYw3iMQMK+gVx9KOBvzCBvDAdBgNVHQ4EFgQUMnhFJ4BKbR35SQvGK8Q6\ng49tRiswHwYDVR0jBBgwFoAUgJK71zKhk9isi0wuAvkzl9SzAFwwCwYDVR0PBAQD\nAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMFgGA1UdEQRRME+CC2V4YW1wbGUuY29t\nhhtodHRwczovL2V4YW1wbGUuY29tL2FsbG93ZWSGI2h0dHBzOi8vc3ViLmV4YW1w\nbGUuY29tL25vdC1hbGxvd2VkMAoGCCqGSM49BAMCA0cAMEQCIG82tEKsPNC5lYv8\n48x5Edyk+fQE3ualpctKtZMHMPhuAiAMdZSKKszS2PwUgZAwAahOTmwI45cgtmoK\nAPtXaPUpFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIBC4CquUWUWuAIQePnE4XWeue3g3wdDFc37/gxYKMn+5oAoGCCqGSM49\nAwEHoUQDQgAElJBcfcj2Mx5m52oiiouuiQq1uYNeqsSCE9CKEOQaPn99X1s0Fyyj\nrrnF+Z3xKw4IjtOiI7IyYw3iMQMK+gVx9A==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-permits-uri-subdomains-rejects-apex", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** graph:\n\n```\nroot -> ICA (permit URI: .example.com) -> EE (SAN: https://example.com)\n```\n\nPer RFC 5280 4.2.1.10, a URI name constraint with a leading period permits\nhosts with one or more additional labels but not the named host itself. The\nEE contains a URI on \"example.com\", alongside a dNSName used for server\nidentification.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUdGB9QbQEbaPVqRJ5zILriChBDMkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQk26nAxSWEthDNaKckhRRku4t1r2rQ2FLl8yND\nh+oK/z18jOccqrvVzZTO6SrX/00yp06Lr/VreZZUWR7XA9J4o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU7zTlmOeC2uGEotdgNUYWnm+FN4IwCgYIKoZIzj0EAwIDSQAwRgIh\nAJ35bY9uuIjqIbhxpct/9twrofoGD+dDRVoBCGvZfvf4AiEAjZgiBavyW62jorTk\nbQrNWAD78XInixnlPzvOU4SWFg4=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgIUfI8jmKCgBs4SuYTQtySB0Bwou1MwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA2NjQzOTQ3MTIzNDgwMDM2NzY3MTYx\nNDQwNTg5ODA3NDA2MTI5MDk4MDgyOTEwMTcxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABNAq1YasODTHRrP6FTvoS1blSwHq7vOtwItGmrS5nJcJFb48z1XRbsZr6kCU\naV0wKRtiiopVXRgjSpMVR1JGynGjgYAwfjAPBgNVHRMBAf8EBTADAQH/MAsGA1Ud\nDwQEAwICBDAfBgNVHSMEGDAWgBTvNOWY54La4YSi12A1Rhaeb4U3gjAdBgNVHQ4E\nFgQUo4j87936Dz6QuMIw021q45GVyqcwHgYDVR0eAQH/BBQwEqAQMA6GDC5leGFt\ncGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAsUBRddcbIUk59fgVqaMf+7t5qxJ9f\nlpwquEdc0Z2T+QIgTIRnt4bjP97O3pfQ+y0m8UWb3Fn2j+Iedk0FF6lrxiY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgIUEJvg1g8S4CRfby7QVYmsl3bXYAYwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjY0Mzk0NzEyMzQ4MDAzNjc2NzE2MTQ0MDU4OTgwNzQwNjEy\nOTA5ODA4MjkxMDE3MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTjS5Bak2ZlUcKHnXyg5Kj4Q5BYIJerV6QO/ssHQnno7NUzrDusm3tI4TM/C8MIjv\nzEZ21lz8nF6NOrTjS2K5iqOBnjCBmzAdBgNVHQ4EFgQUFbWLkKb72dMTmHTo28lb\nnzzs+rYwHwYDVR0jBBgwFoAUo4j87936Dz6QuMIw021q45GVyqcwCwYDVR0PBAQD\nAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMDcGA1UdEQQwMC6CC2V4YW1wbGUuY29t\nhh9odHRwczovL2V4YW1wbGUuY29tL25vdC1hbGxvd2VkMAoGCCqGSM49BAMCA0gA\nMEUCIQClve9XtFAYl5Lt1dz+cvonI2NjpB6nmcdP1s7NCyRc+gIgC8sLACXi+cWl\nKQe+Ydybtywew++22KLbaV5uPYcumzA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIBSAyGw6Z5evx6Twv3t5YNBU6ZibowLmYvKwM0MHtjF4oAoGCCqGSM49\nAwEHoUQDQgAETjS5Bak2ZlUcKHnXyg5Kj4Q5BYIJerV6QO/ssHQnno7NUzrDusm3\ntI4TM/C8MIjvzEZ21lz8nF6NOrTjS2K5ig==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-forbids-othername", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** graph:\n\n```\nroot -> ICA (forbid: ON) -> EE (SAN: ON)\n```\n\nRFC 5280 does not specify the handling other OtherName constraints,\nbut does specify that implementations must either process (and\ntherefore recognize) all constraints or outright reject the certificate.\n\n> If a name constraints extension that is marked as critical\n> imposes constraints on a particular name form, and an instance of\n> that name form appears in the subject field or subjectAltName\n> extension of a subsequent certificate, then the application MUST\n> either process the constraint or reject the certificate.\n\nThis testcase contains an ICA with a private OtherName (meaning the\nimplementation will not recognize it), and therefore must reject the chain.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUdnrKI4TnxuwmFSIx5flK9KceRCIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATUvpk9eA8LtlsyzazsAFMWRBdavP7Pbx46lOmE\npucpwtGTMiGX4r2EWVfYZ+WOUCcSVIozRPtGLb2Au6kWXzcbo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUWVXKwv9DGzxM34U+APBbfuXWl2gwCgYIKoZIzj0EAwIDRwAwRAIg\nd13Uq03oDigycLy3YlJueYNsWuKRglVSOC5f3w3DAUkCIHxijWyORFzsSTd1rwOM\nhr/BgnN07qP7hLH06hfvTsXv\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHzCCAcagAwIBAgIUBZtJQbTpszH9TrelWddH/pDaBFEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA2NzYzOTkyMTA2Mzk3MzY0MDgzMzAx\nMTE0NzA1NTQyMDE1MjIxNDk2NDQ5NzcxODYxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABBqG4vx+W+rMZDchuf0gv2iAqIMD5JdNbDO0oS2catm+HsLquK+Pgkr0gL3g\nkn9OBrGQv9uBHDoKxhb38xyWupOjgZcwgZQwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAUWVXKwv9DGzxM34U+APBbfuXWl2gwHQYDVR0O\nBBYEFERqE73b9uLE5c6gFhiuHR8Jl2gjMDQGA1UdHgEB/wQqMCigDzANggtleGFt\ncGxlLmNvbaEVMBOgEQYLKwYBBAGDszqFGgOgAgUAMAoGCCqGSM49BAMCA0cAMEQC\nIARTCdPN/UvHopT1SkHc+9W4ypRcyAWLSnSJ4vdw2q5wAiAbMVZa9BgdCGDrFeyW\nY8yzFSMY6Nb6nApaxy7khoMgtA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgIUTN24b9WY/mdc9dd+IiA+6GzBLbwwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjc2Mzk5MjEwNjM5NzM2NDA4MzMwMTExNDcwNTU0MjAxNTIy\nMTQ5NjQ0OTc3MTg2MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ni0cgnBrzgHx47DkybDypqUmC3t7TBfE20ubS5Xt2JRGqYoSfU/RBSJt0qi2HzcNR\ndNj2WomtzUbFQVTMyxEpPqOBkDCBjTAdBgNVHQ4EFgQU6kueU3BpRnxYayvbEeft\nszqmjW4wHwYDVR0jBBgwFoAURGoTvdv24sTlzqAWGK4dHwmXaCMwCwYDVR0PBAQD\nAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMCkGA1UdEQQiMCCCC2V4YW1wbGUuY29t\noBEGCysGAQQBg7M6hRoDoAIFADAKBggqhkjOPQQDAgNIADBFAiEAlPGXO+dUdQZP\nxZUKhrEFMtgdTAekRtKCnueqbRa4rCkCIGJ+wIUj+TOjjc2He0vqQjAG9aewaJba\nb6zDvH47BMVO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIGEC0r7pMLBmxzSI/CQdH8faipgw27INWqoVz3siIJXKoAoGCCqGSM49\nAwEHoUQDQgAEi0cgnBrzgHx47DkybDypqUmC3t7TBfE20ubS5Xt2JRGqYoSfU/RB\nSJt0qi2HzcNRdNj2WomtzUbFQVTMyxEpPg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-forbids-othername-noop", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nroot -> ICA (forbid: ON) -> EE (SAN: no ON)\n```\n\nRFC 5280 does not specify the handling other OtherName constraints,\nbut does specify that implementations are only required to evaluate constraints\nfor names that actually appear on the validation path.\n\nIn this case, ICA contains an OtherName Name Constraint but no actual SANs\non the path contain any OtherName subjects, making the chain valid.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUFRtmhNrQLoS8tCHztHp9BgTqXjEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATe2Q9af/wUSSN9OcaGkOVVmVIQZvoTrF23r3IZ\nQrpWmQlz8ttsFVj1ofT0UnuGsecUr86hsZxeZUh6gZcX03FZo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUpCtANdrC0CLlIvD/cxQ6LepXH5YwCgYIKoZIzj0EAwIDSAAwRQIh\nAMNe3E4WbMhLMbK27fzW6Dsgek62yaxSRKJMducWfjUrAiBZ+Z6XxNTXDl0HYZPa\n8UMYjEbPp3YIbkomvR8XXZyTRA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHzCCAcagAwIBAgIUEFaMAja7hX0YPuiDq/lQhzz68R8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAxMjA0OTk4NTY5Njg5NTEwNzQyNzc3\nOTk2OTE3NTc0MTM5Nzc5NjA5MTc2NTUwODkxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABDj8BbjYUOKlFtT9H9NMWgshiC4OMXnWCe7cX02qKOzWmfUJwyJaHXJnTuDT\nvZ3J6crePugFuhU++0vAvAYWhhajgZcwgZQwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAUpCtANdrC0CLlIvD/cxQ6LepXH5YwHQYDVR0O\nBBYEFBDDIPytMPo1I+EM5luz1kfI7uxMMDQGA1UdHgEB/wQqMCigDzANggtleGFt\ncGxlLmNvbaEVMBOgEQYLKwYBBAGDszqFGgOgAgUAMAoGCCqGSM49BAMCA0cAMEQC\nIDx9szYhkuTQKoaZTa+zgmLB83dY5KN/2QLt9g8XwKOwAiAjjmii4TLtRPYmQhkK\nl0QezTXguXI7JfVGSzU5k/Ttpg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUTzcvjRislHNcOCE7zmmJ9QgcjSIwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMTIwNDk5ODU2OTY4OTUxMDc0Mjc3Nzk5NjkxNzU3NDEzOTc3\nOTYwOTE3NjU1MDg5MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noKU8IPvMsMcnOKadxZDtDg84r6gBVT+JEH8BUVFPUmCymd6lmur94aqase+jFYba\n1VxlJt26EaouAOFG08Fl/qN8MHowHQYDVR0OBBYEFAMmWunJEg16WHGH4KivJlk4\nfn/DMB8GA1UdIwQYMBaAFBDDIPytMPo1I+EM5luz1kfI7uxMMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNIADBFAiAfF6Sj0eH+zQyrNCdLj7Z8B7AfcWjG8fbY44hC815f\nCQIhALWYpfTYS6AJcX7kacJ+Maw6clANbRQsU2HgBk66bA3w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIP/fmnRRUSXq8PQQB7P/eEc0+j/j8yJFgSKkKfb+vaspoAoGCCqGSM49\nAwEHoUQDQgAEoKU8IPvMsMcnOKadxZDtDg84r6gBVT+JEH8BUVFPUmCymd6lmur9\n4aqase+jFYba1VxlJt26EaouAOFG08Fl/g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::nc::nc-forbids-dnsname-wildcard-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following chain:\n\n```\nroot -> ICA (forbid: bar.example.com) -> EE (SAN: *.example.com)\n```\n\nThis chain should forbid `bar.example.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUEfB2/Yg1bFB53Ip2t1uTVB4Oq4MwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARaa4WMAs0Dw84+wbqxonqhkjybRsJ4KnjZDmAM\nef5LVo/B175BVD/gpCQWrbCNlv0AyNpDNEno24uBKG4+k9L4o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUH9v3KwdP83qNXAfV1Fc3YiiG1aQwCgYIKoZIzj0EAwIDRwAwRAIg\nAnNCN31xYBGCWWu7sskL7mcGBcxfkEz4mfVXFeDbN9ICIAilyspMnkCVIXOM90Cu\nutdXcvwCA0xQZQ6wd81R25Gk\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHzCCAcSgAwIBAgIUMQIpPEyjGK+SPfkJZMHo1GUPTvAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAxMDI0MTUzODc0NzM4ODM3OTYyMDg5\nMjI5ODAwMDc5MDE2NDk3ODEzOTQ0MTg1NjMxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABB6Vd4IBxfQo+1UaoAe13H/z0zS67vxqXnqQPGbTUvjTAkJQc3rPeB9SLg93\nB93oqkilnWnTsrBTuf6oTKXIxSKjgZUwgZIwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwHwYDVR0jBBgwFoAUH9v3KwdP83qNXAfV1Fc3YiiG1aQwHQYDVR0O\nBBYEFDzn6M+pg+5AfT1HZgmlquLey/+1MDIGA1UdHgEB/wQoMCagDzANggtleGFt\ncGxlLmNvbaETMBGCD2Jhci5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\nrwJ5MKmNhj/U77IznzDSFR3cgn3v2lrL0SSV9OKwrbECIQCicFoNciBOd7weeThL\nlCQw9c9zyNqTen8g5YWbEXppKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICAzCCAaigAwIBAgIUPd3SNelbhomVh9YxTIOCaEgQ+0QwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMTAyNDE1Mzg3NDczODgzNzk2MjA4OTIyOTgwMDA3OTAxNjQ5\nNzgxMzk0NDE4NTYzMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbe4wwx8TlPkGVP52dLHlQPRlHunlDzuKnm0tMpJFe9wMNrXfcs2ID68nU3czdnTV\nhVpEAdL8LRfX5TR8Ou1VVaN+MHwwHQYDVR0OBBYEFDaqO7nek4YiT1nb6mLO1M4A\nsURiMB8GA1UdIwQYMBaAFDzn6M+pg+5AfT1HZgmlquLey/+1MAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAYBgNVHREEETAPgg0qLmV4YW1wbGUuY29t\nMAoGCCqGSM49BAMCA0kAMEYCIQD8uuGnXFLHl/krp3SW5G73JJgsii9mBYNAStwR\n2UyqNgIhANil8perhQ6XCsUQTKHWjJpRsxY6tP68xGBQixMncz2B\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIyHjnPPBBKk/aWEd0GoCdqb498Cfrpyoyv5R2qbjye1oAoGCCqGSM49\nAwEHoUQDQgAEbe4wwx8TlPkGVP52dLHlQPRlHunlDzuKnm0tMpJFe9wMNrXfcs2I\nD68nU3czdnTVhVpEAdL8LRfX5TR8Ou1VVQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "bar.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::pc::ica-noncritical-pc", + "conflicts_with": [], + "features": [ + "has-policy-constraints" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> EE\n```\n\nThe ICA has a `PolicyConstraints` extension marked as non-critical,\nwhich is disallowed under RFC 5280 4.2.1.11:\n\n> Conforming CAs MUST mark this extension as critical.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUNbm3TW3fJ0bldEsj+e0W4M+E18QwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARcDIq9dc8Jvrc8GpMy1+NH6IFp1u7P/0hhHcgD\nSnjNJGPIO4xi/QuXagJ3uSyHLypgdZpqTd6I5PWmnrYIe2cio1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUxvxsEYgcqQB0GbQ5iu2YaE/SxTowCgYIKoZIzj0EAwIDSAAwRQIg\nQsjBVzxRbpeRvmSoK7RgGlVpWD0mAAbJcQxbPyy1g28CIQCvH2dHdi3gTVQoozbE\n2nIphUYhmzfSxOdU4+WahjWUyw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICETCCAbagAwIBAgIUXrtCp1R0ni9NaJzkFnUMls8WWlgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAzMDY3MTgxMTY2MTE1MDM5NTU0NzM5\nMDY0MjQ4NjM4MDg3Mzg0MjMxMjIyMjA5OTYxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABPX9zKXjDzXp40QeuCqIQmNNXL8SQ5Y+K1NUoYuQ8DQCX9UghGKYeRCJ78lD\nLSuRPbzNlIQPjrI9RqNc3eHRCYKjgYcwgYQwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUxvxs\nEYgcqQB0GbQ5iu2YaE/SxTowHQYDVR0OBBYEFAhLdcYdN3cVtcLA1EAF6tRO/6kE\nMAwGA1UdJAQFMAOAAQMwCgYIKoZIzj0EAwIDSQAwRgIhAPBbQaDNlPAMVtO3eXXF\nB0+RvMVWFGnVzKXrz4bZglSZAiEA/s5ppV1QcDQnMVWVsvGxRB9GTig2NsJ73VuN\n49KKjGw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaagAwIBAgIUMYNqcZFk60NZaOch+RMSM1PJmjgwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMzA2NzE4MTE2NjExNTAzOTU1NDczOTA2NDI0ODYzODA4NzM4\nNDIzMTIyMjIwOTk2MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ng1S3SiUY8G1j7MyJaroFWK6Zo/+NwgP6oVckBgY/yrBlNH5kSyFn2udbwKYqnd7F\nJm+UgXtyN/r0WlSJzA6q9qN8MHowHQYDVR0OBBYEFFRkH3rH9jmdfsa+0BZXBJdN\nz0zgMB8GA1UdIwQYMBaAFAhLdcYdN3cVtcLA1EAF6tRO/6kEMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNHADBEAiBf4Z+n4WzsUgt4ffbyb3NvbHEOqhf1NtcgSU7meGJj\nVwIgFSZ+me+X+1ZGo7CwKc2eWLn5AmJRxUBNMbDl2eJBIO4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIBCnygQRVtoHdRBGaKJVQt4b9HpnL8QtiG1fAHJaX2OioAoGCCqGSM49\nAwEHoUQDQgAEg1S3SiUY8G1j7MyJaroFWK6Zo/+NwgP6oVckBgY/yrBlNH5kSyFn\n2udbwKYqnd7FJm+UgXtyN/r0WlSJzA6q9g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::san::malformed", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE cert has a SubjectAlternativeName with a value in ASCII bytes, rather\nthan in the expected DER encoding.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUfEYnt7rddzg7NCTMEmw1azxUdWIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARvPMO9ooj6lHATM+fwCnCpgJpLoY+pdttTuWAB\ntqKzFORSmPcrJkg2Uxft1N1x8unAJkvT5yVrcIJXzLY4kGq9o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUDk8fkgDL996t0zzXvKuK8jf2ZzcwCgYIKoZIzj0EAwIDRwAwRAIg\neWfzkJrzbzsTi3bvHS8v4B7AUuYZBSZFd2QOwWDVls0CIBibG7eW6r81epCBZcAx\nGhGuDICscVYyCLwMNr6WYjFI\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrTCCAVKgAwIBAgIUAhH83jgIfEhYrsaf0o6xK9PuoyowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABP3OybLzP7XO47UJYiEJ8nVu7CTzsUe+GsDi2nITB55G\ng3j5pRR0q265KgF5RHdpQwyzWsl8zIaIgemY/xjRaLGjeDB2MB0GA1UdDgQWBBQV\nMtMVoQv5OKTpfZxELir1nHZiEjAfBgNVHSMEGDAWgBQOTx+SAMv33q3TPNe8q4ry\nN/ZnNzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwEgYDVR0RBAtl\neGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAxhjmldVCEXXj5FKxLCVdfYYu\nJsV0wWf1avAT1I+2bo8CIQCe5V9exxsFZMDKCt5K8tISLg1XEr8UsCaq5Vi3q9EZ\n2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIQ3QBUQMoX3g5Z1Zsyy5jAPZ8Nh2gVHg5xU+T8fH/oeoAoGCCqGSM49\nAwEHoUQDQgAE/c7JsvM/tc7jtQliIQnydW7sJPOxR74awOLachMHnkaDePmlFHSr\nbrkqAXlEd2lDDLNayXzMhoiB6Zj/GNFosQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::san::noncritical-with-empty-subject", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces an **invalid** chain due to an invalid EE cert.\n\nThe EE cert contains a non-critical Subject Alternative Name extension,\nwhich is disallowed when the cert's Subject is empty under\nRFC 5280:\n\n> If the subject field contains an empty sequence, then the issuing CA MUST\n> include a subjectAltName extension that is marked as critical.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUGrQJ3ZLApMn0cGc1FX5McKRCQjQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATnzcrkw48CZcpcnzkYioDMp9y2Pgk8biUWNa7E\nfxSd828KVOVSMVioZTxBGOftJz26MHEYbV8AwldagXHQIbLIo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU55N1b9viJPQmckGI5LuHUHeRwqowCgYIKoZIzj0EAwIDSAAwRQIg\nb08e6r/BWVQbERjIGJEGx2RHpSUGwAPJlwfX56SrPaACIQDtIUxj3dg7uS2P4fj7\nmZW9gm1f/uWheLY7wSJ2CsY6vQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBmTCCAUCgAwIBAgIUfYA2yM69cEuIXL9zR8TskcCsaXMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAAMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDkTSzJbg\ng3ncxpj93zp7NdzHohOWDJcl8QLuU/PhpuZVQp6i2mTc26vmsb9WAp2aNUuG4YoS\n0gv6mVCVDeUl0qN8MHowHQYDVR0OBBYEFOCLBrIuZk7OnSMxh4kc/KwpsZofMB8G\nA1UdIwQYMBaAFOeTdW/b4iT0JnJBiOS7h1B3kcKqMAsGA1UdDwQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiATrxpzQk3HBd3DLrpsZ7P8s9HaD0RFr5tUesMk/MfPfQIgX18b\nfkG5LlPJ8pl990IQSfnnZoum3e6B9TegDxqmiuY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIGaSBAazXjbpUaIHINOzlu4xKpwNeobBS4oV6GMelkguoAoGCCqGSM49\nAwEHoUQDQgAEDkTSzJbgg3ncxpj93zp7NdzHohOWDJcl8QLuU/PhpuZVQp6i2mTc\n26vmsb9WAp2aNUuG4YoS0gv6mVCVDeUl0g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::san::underscore-dns", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces an **invalid** chain due to an invalid EE cert.\n\nThe EE cert contains a Subject Alternative Name extension that\ncontains an underscore, which is disallowed under RFC 5280 4.2.1.6:\n\n> When the subjectAltName extension contains a domain name system\n> label, the domain name MUST be stored in the dNSName (an IA5String).\n> The name MUST be in the \"preferred name syntax\", as specified by\n> Section 3.5 of RFC 1034 and as modified by Section 2.1 of\n> RFC 1123.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIURVnS4aI6oND+SaVByVtpSXo9U+IwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQNpa+DhGrUhKXDiswW8NxXoVplZ3uiAi5NCZEC\nZJ4u6Y3gPiINRGw/8NstSU3cp5KnixzngSKRlWLnOK6K4NIxo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUpJGyq67TYaMPcuyLPRh3pmdlwa4wCgYIKoZIzj0EAwIDSQAwRgIh\nAO2IW9XDLB2jehLiG0gMTtOR1pnV65zrvu0PYTwVwOv3AiEAz2+d6k753RVi94fb\nK9sQY8yugbh04smbmH16+TOXc9w=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBujCCAWCgAwIBAgIUB3ydhsfLVZ/0jRM8uJtZz3p1E8MwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABADQYGQjtAgSDUGfgC+D/PfE1yBNpRO4g0BO/eMZftQR\nRImtWyTx8LV+AGhOn3E6NQCryy4APz84bbCNyVb69rqjgYUwgYIwHQYDVR0OBBYE\nFEAk2uu31megjgI6pY+7gYHH3/AXMB8GA1UdIwQYMBaAFKSRsquu02GjD3Lsiz0Y\nd6ZnZcGuMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAeBgNVHREE\nFzAVghNmb29fYmFyLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIE1NVj3l\nZHHVYthoTr2D/OiJr/1/3N9Coxt4nLolPr7nAiEA+bcG9chuZSjLaBmVkb0sT6Lj\ndr8GRqMWheJcgap5YDI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEINSZ2INLDVCQmYb690JLUM7huaOOulJR5RHiKsYYC9LzoAoGCCqGSM49\nAwEHoUQDQgAEANBgZCO0CBINQZ+AL4P898TXIE2lE7iDQE794xl+1BFEia1bJPHw\ntX4AaE6fcTo1AKvLLgA/PzhtsI3JVvr2ug==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "foo_bar.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::san::ip-in-dns", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces an **invalid** chain due to an invalid EE cert.\n\nThe EE certain contains a Subject Alternative Name extension that\ncontains an IP address as a DNSName rather than as an IPAddress,\nwhich is disallowed under RFC 5280 4.2.1.6.\n\nSee: for a public\nexample of this kind of misissuance.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUM8KzgSXMn4kjJHWce+Tx5qG49kowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASM2nRpK5+2EtUkrWyG7FfxDhX2/fc9wHrYJa5A\n+DK+nqZQTW/yoZPjUvoO8Q7WKnHSX9TWvp3pFpjFW10EK+SIo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUu89z9jG/FkKRnwESMAI2aaUGOPAwCgYIKoZIzj0EAwIDSAAwRQIg\nHidcnjqRj1zuCOIWr0E6a3wgiALnpnTJhBDJHpU3IzkCIQCp0MjhQuSLGzi6nhUF\nLMnefvpkrPBzHkuaIEaNrfUbRw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBqzCCAVKgAwIBAgIUe4ZLbhFviwoic5GfN5CdsVt9QSMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABPExv5iXdVuE5Ft3k0ST2oA1VRWJbv860XrZjzlMVAfi\n7Btio/KvYQaRThSoA5Gn9YUmQltYfPIDxZgs8Fs1Te2jeDB2MB0GA1UdDgQWBBQm\nPOx30IzPECN9c8XhoLVWHLPgUjAfBgNVHSMEGDAWgBS7z3P2Mb8WQpGfARIwAjZp\npQY48DALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwEgYDVR0RBAsw\nCYIHOC44LjguODAKBggqhkjOPQQDAgNHADBEAiBHT3zQEAd3GCG3JP+X5uUO7z5V\n5rp1WpaFDkHTWEP2pwIgVPCkJfum9HuMPxCEPii67vflsf5Si4l8Q2lcYWESSbI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIFkq+nprAPn6zCBhUuBzAvb1YHogyr2mEPL7ZvK2JBY+oAoGCCqGSM49\nAwEHoUQDQgAE8TG/mJd1W4TkW3eTRJPagDVVFYlu/zrRetmPOUxUB+LsG2Kj8q9h\nBpFOFKgDkaf1hSZCW1h88gPFmCzwWzVN7Q==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "8.8.8.8" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::serial::too-long", + "conflicts_with": [], + "features": [ + "pedantic-serial-number" + ], + "importance": "undetermined", + "description": "Produces an **invalid** chain due to an invalid EE cert.\n\nThe EE cert contains a serial number longer than 20 octets, which is\ndisallowed under RFC 5280.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUMml5idSQuZQpXrZIvSTb4KFsgLUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQNia9JhqL6LuRH7/RMMuGIPLXVPLCbRSs5KvS1\nUV22uCTjoLnxiAPl0kVsu+ooKKVrzZgmKN/Yc7KGnlvDVYC8o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUStZDg0dMfViwrEasdFD+Uf/lpHowCgYIKoZIzj0EAwIDRwAwRAIg\nebyokBOa15sHpR0Nkwo0BZfO+7wVPu5vQB5xAa07KsUCIBpGhdCbPa8S5uZBj+tT\nxGvD4pD4+uU4oFyihpgKILPt\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsjCCAVigAwIBAgIWXYpP2Iz0IczVLBVP3j3F7A2naN2f6jAKBggqhkjOPQQD\nAjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwIBcNNzAwMTAxMDAwMDAxWhgP\nMjk2OTA1MDMwMDAwMDFaMBYxFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAE45BDf1rGLA9YRYjxJr8FHUAtaO3dGtPYv0rZsNkG\nXoq3/rgzEa8M3Fl6aL/FrDGGq5noDTQiQyEItlPgEkRB+6N8MHowHQYDVR0OBBYE\nFFI9wYpGAtUs8yz/DY/igIogF3sRMB8GA1UdIwQYMBaAFErWQ4NHTH1YsKxGrHRQ\n/lH/5aR6MAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREE\nDzANggtleGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBAmMio741gOAJ0R80X\nBT3HmHwL5odRUuw54QPrkTPW+gIhAJkiaXGORhycHpGfhTexTcpZOodDbep0WpYi\nuGC+8A6T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIDyfO81xMGynuhFGF2mGmOXdR46Ri/gq8lOuPvyMagkoAoGCCqGSM49\nAwEHoUQDQgAE45BDf1rGLA9YRYjxJr8FHUAtaO3dGtPYv0rZsNkGXoq3/rgzEa8M\n3Fl6aL/FrDGGq5noDTQiQyEItlPgEkRB+w==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::serial::zero", + "conflicts_with": [], + "features": [ + "pedantic-serial-number" + ], + "importance": "undetermined", + "description": "Produces an **invalid** chain due to an invalid EE cert.\n\nThe EE cert contains a serial number of zero, which is disallowed\nunder RFC 5280.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUTfY+GsGOivz6YtNs5j9TysHa7nAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATLFY2YixEiNWY+7kJcOetiE72zCMP9p+Df2L1V\n7ij/G8jyDl4svAi5I+7CFzXupdY+kC8OMdx/ErxjqQUSuWxWo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUwYG7Ho8qq5qCjHuxjykiUHrATX0wCgYIKoZIzj0EAwIDSAAwRQIh\nAOxgRm4NbwwEkYBbgw4o4gCt0Nb+nfEnxZga4low08cAAiAB9IVbd7C7OEWf4/fl\n8F7HH/gm6Scy/Y7iaB0MuVUPRQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBnjCCAUOgAwIBAgIBADAKBggqhkjOPQQDAjAaMRgwFgYDVQQDDA94NTA5LWxp\nbWJvLXJvb3QwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEI6g1\nOAdKJTo3yxpewlmYJG8mDKVczeGs/lKjcip9Tj8W1XZSIXd5NAXhG79PTF0+Zsb2\nT3vi+CqMOvsof1VD1qN8MHowHQYDVR0OBBYEFCLGDMjECKWFjnH7ZM76aEDCD+/9\nMB8GA1UdIwQYMBaAFMGBux6PKquagox7sY8pIlB6wE19MAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAlhGgJx+mL+vrmVTaK7gxm70QkEV5hVksTBSfwFXrXKIC\nIQCpu/ByRco0pSeftuccMWZzIbYOZvdSiMGfb/IEYARgnQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIW86J05Dtnrgek3ZMBkN8sdA6aXwj/neu2kX5hpnGUcoAoGCCqGSM49\nAwEHoUQDQgAEI6g1OAdKJTo3yxpewlmYJG8mDKVczeGs/lKjcip9Tj8W1XZSIXd5\nNAXhG79PTF0+Zsb2T3vi+CqMOvsof1VD1g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::serial::negative", + "conflicts_with": [], + "features": [ + "pedantic-serial-number" + ], + "importance": "undetermined", + "description": "Produces an **invalid** chain due to an invalid EE cert. Verifies against a\nsaved copy of a certificate with a negative serial number from the\n`cryptography.io` test suite since the API won't allow us to create\ncertificates with negative serial numbers.\n\nThe EE cert contains a negative serial number, which is disallowed\nunder RFC 5280.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIELDCCAxSgAwIBAgIF+86ZbBMwDQYJKoZIhvcNAQELBQAwUjELMAkGA1UEBhMC\nVVMxFjAUBgNVBAoTDU1vdGhlciBOYXR1cmUxEzARBgNVBAsTCkV2ZXJ5dGhpbmcx\nFjAUBgNVBAMTDU1vdGhlciBOYXR1cmUwHhcNMTYwNzA2MTgzNDA2WhcNMTYwOTE4\nMTgzNDA2WjCBmTELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkZMMRQwEgYDVQQHEwtU\nYWxsYWhhc3NlZTEcMBoGA1UECRMTMzIxMCBIb2xseSBNaWxsIFJ1bjEOMAwGA1UE\nERMFMzAwNjIxGDAWBgNVBAoTD0V4dHJlbWUgRGlzY29yZDEOMAwGA1UECxMFQ2hh\nb3MxDzANBgNVBAMTBmdvdi51czCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\nggEBAMu6VH/JvcG/foNel5R3NHz/OeI9fqHyoPB6d/wQ1k/aVGNotSzVaDCJPY3J\nxmr1KCnNjzGmViuaLXyZWZEMum2R8D0+LX1PHBQl2vbrXSOMDu97c323QOdTUwMY\nC2LmaFP3fa5SV5Q+8+4f/B97wXExOjp1z5z7VafYj2MoY72GitoSfJ/LrkKEksey\nfTflVxKEvZqW3wUN6F2Kj4Jo1N45Ym+lIrz/VQKDOSpc/p0dJ1PghDZZ2d2b3iuj\n5rCMTw9533WS3wueYfn70jJY9DKoFj9Ly6AG0AB2o7cqTv8j+3slVfAR3ufwgyx2\nckUDBWCZaZdnhRxaj/G9MMYGEV0CAwEAAaOBwDCBvTAPBgNVHRMBAf8EBTADAQH/\nMA4GA1UdIwQHMAWAAwECAzANBgNVHQ4EBgQEBAMCATAbBgNVHREEFDASgggqLmdv\ndi51c4IGZ292LnVzMAsGA1UdDwQEAwIBhjAgBgNVHSUBAf8EFjAUBggrBgEFBQcD\nAQYIKwYBBQUHAwIwPwYDVR0fAQH/BDUwMzAxoC+gLYYraHR0cDovL2NybC5zdGFy\nZmllbGR0ZWNoLmNvbS9zZmlnMnMxLTE3LmNybDANBgkqhkiG9w0BAQsFAAOCAQEA\nbfqYztTkJPRPAJ1WItmU3RZIGRx1VkCABouAor6tVH6wGVCwWgaG8li6AujHMfYv\ny6QUPhhIyNjTe21ne72BY1XXd9haGdMwXtUCNfeGBXKsR9EN0kDyOAXGZWj3Fqpu\nS9WjluPAjQWHFoRwlQBSxCVuRgIrjXhJndvW9ySAaI51epRAr5kwylvTD7qy363C\nxDANx5XVFEktclI25DSrxmiJyawVGFjnwaYBFTe2ZINoZvs68EEl1b18+VGF21e9\nBAQGlcsIfbDAAEQFJ+5A+o8zy9M7CVsNVgw3TRJbjVTZSEg5PAEX+3C5V6wzrQi1\nnqzaNa/5DxGWILelZclgvA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIELDCCAxSgAwIBAgIF+86ZbBMwDQYJKoZIhvcNAQELBQAwUjELMAkGA1UEBhMC\nVVMxFjAUBgNVBAoTDU1vdGhlciBOYXR1cmUxEzARBgNVBAsTCkV2ZXJ5dGhpbmcx\nFjAUBgNVBAMTDU1vdGhlciBOYXR1cmUwHhcNMTYwNzA2MTgzNDA2WhcNMTYwOTE4\nMTgzNDA2WjCBmTELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkZMMRQwEgYDVQQHEwtU\nYWxsYWhhc3NlZTEcMBoGA1UECRMTMzIxMCBIb2xseSBNaWxsIFJ1bjEOMAwGA1UE\nERMFMzAwNjIxGDAWBgNVBAoTD0V4dHJlbWUgRGlzY29yZDEOMAwGA1UECxMFQ2hh\nb3MxDzANBgNVBAMTBmdvdi51czCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\nggEBAMu6VH/JvcG/foNel5R3NHz/OeI9fqHyoPB6d/wQ1k/aVGNotSzVaDCJPY3J\nxmr1KCnNjzGmViuaLXyZWZEMum2R8D0+LX1PHBQl2vbrXSOMDu97c323QOdTUwMY\nC2LmaFP3fa5SV5Q+8+4f/B97wXExOjp1z5z7VafYj2MoY72GitoSfJ/LrkKEksey\nfTflVxKEvZqW3wUN6F2Kj4Jo1N45Ym+lIrz/VQKDOSpc/p0dJ1PghDZZ2d2b3iuj\n5rCMTw9533WS3wueYfn70jJY9DKoFj9Ly6AG0AB2o7cqTv8j+3slVfAR3ufwgyx2\nckUDBWCZaZdnhRxaj/G9MMYGEV0CAwEAAaOBwDCBvTAPBgNVHRMBAf8EBTADAQH/\nMA4GA1UdIwQHMAWAAwECAzANBgNVHQ4EBgQEBAMCATAbBgNVHREEFDASgggqLmdv\ndi51c4IGZ292LnVzMAsGA1UdDwQEAwIBhjAgBgNVHSUBAf8EFjAUBggrBgEFBQcD\nAQYIKwYBBQUHAwIwPwYDVR0fAQH/BDUwMzAxoC+gLYYraHR0cDovL2NybC5zdGFy\nZmllbGR0ZWNoLmNvbS9zZmlnMnMxLTE3LmNybDANBgkqhkiG9w0BAQsFAAOCAQEA\nbfqYztTkJPRPAJ1WItmU3RZIGRx1VkCABouAor6tVH6wGVCwWgaG8li6AujHMfYv\ny6QUPhhIyNjTe21ne72BY1XXd9haGdMwXtUCNfeGBXKsR9EN0kDyOAXGZWj3Fqpu\nS9WjluPAjQWHFoRwlQBSxCVuRgIrjXhJndvW9ySAaI51epRAr5kwylvTD7qy363C\nxDANx5XVFEktclI25DSrxmiJyawVGFjnwaYBFTe2ZINoZvs68EEl1b18+VGF21e9\nBAQGlcsIfbDAAEQFJ+5A+o8zy9M7CVsNVgw3TRJbjVTZSEg5PAEX+3C5V6wzrQi1\nnqzaNa/5DxGWILelZclgvA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2016-09-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "gov.us" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::ski::critical-ski", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert has an SKI extension marked as critical, which is disallowed\nunder RFC 5280 4.2.1.2.\n\n> Conforming CAs MUST mark this extension as non-critical.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkjCCATigAwIBAgIUQN5UwhYdeF82P/VyLtvqCvT6p1cwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASL/LWLub6DoZK+eHPDNGBK6/TWlxzFf14zBIOb\nmLhO0TFk6emF9PDyTXWqInvG++VVYK66tfI4+Wu8Y/LaTsOio1owWDAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAg\nBgNVHQ4BAf8EFgQU4K5uIh32H7KFP8f796GA53l1hHEwCgYIKoZIzj0EAwIDSAAw\nRQIhALP4ef33J2nMCO2+0cfacB7JQKdzsvUbcF4JXj3pY91UAiApEkOMiypVZuJB\noC58gtE8LU58iCmUvqMSteOuh1+kVg==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUdU/itpoZkHxZucSSrC6fEipb6i4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABHdJ58ru2Z/YOvISKtTFdIFko/e8YlvfHH0BdC/a/ppJ\nmWRBhDcaIefruCNw12MrwAZuPyNrNkaKz5a2ZNhzDs2jfDB6MB0GA1UdDgQWBBQ5\ncjbrpEDwgFuq1OqFjTRo9hcpbDAfBgNVHSMEGDAWgBRn9xU/aHh4ofAnw5968Msz\navROAjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgGigXVeDnWMZ+sHbdsADX\naZpLGVbzgcvDuWK5bBr5KcgCIBAKYh4asuKqwDFVLnuf8RFc8ilP5VNy+EN9N/Hs\ncZyC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDX/QnsAVMJ6WJZX9mkRPC1SfYlBBiVcE7TafA3SfGbhoAoGCCqGSM49\nAwEHoUQDQgAEd0nnyu7Zn9g68hIq1MV0gWSj97xiW98cfQF0L9r+mkmZZEGENxoh\n5+u4I3DXYyvABm4/I2s2RorPlrZk2HMOzQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::ski::root-missing-ski", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert is missing the SKI extension, which is disallowed under\nRFC 5280 4.2.1.2.\n\n> To facilitate certification path construction, this extension MUST\n> appear in all conforming CA certificates, that is, all certificates\n> including the basic constraints extension (Section 4.2.1.9) where the\n> value of cA is TRUE.\n\nNote: for roots, the SKI should be the same value as the AKI, therefore,\nthis extension isn't strictly necessary, although required by the RFC.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBbzCCARagAwIBAgIUL1uzyeOP32hB1Ajp6TTBSlU0BLMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATzyv1oDDVnxEDzipaU8QnL38IidC5tqiy4PE/R\nWY0eVjNNhQn1xi6PHDajViALGK49WIovP58wa0m5WR0HfzyTozgwNjAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNHADBEAiA1PTIG7CGiuDccwFw2+CbRUZTMXyDflHOYO4WMr+Pb\nsQIgNUo6VSaoFLKFeX6/WADtI9FSGZhiQ+x0pw+ZKB7sjQw=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUNYPArp0rKuqJ1VFeVISpIOIv53QwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABLPBC/9DxEFAYPVkPHebf2QxBULnOAaGVbUROPbCGmUi\n7wmTICyuMGTSkPRNEkjPElZw0On5W75x5Q8z8dMSVLqjfDB6MB0GA1UdDgQWBBR7\nCvwyuEreg0qO4GS2Bv00ajohnjAfBgNVHSMEGDAWgBRmnroODJQI7NgCeHqOMWn2\ngobw6TALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgfB25W6qLtow40Rm+NAEB\nECKz6rc/kPdDsUSx9VTp3osCIBG99TKMVdewEbuaY0HmLc8gPEC54K0dG/Z+SofR\noX/k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIOxkFGzWlL/ZSpvMs8U9hS4OAYuNTo44a3vMez72dJINoAoGCCqGSM49\nAwEHoUQDQgAEs8EL/0PEQUBg9WQ8d5t/ZDEFQuc4BoZVtRE49sIaZSLvCZMgLK4w\nZNKQ9E0SSM8SVnDQ6flbvnHlDzPx0xJUug==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::ski::intermediate-missing-ski", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> EE\n```\n\nThe intermediate cert is missing the SKI extension, which is disallowed under\nRFC 5280 4.2.1.2.\n\n> To facilitate certification path construction, this extension MUST\n> appear in all conforming CA certificates, that is, all certificates\n> including the basic constraints extension (Section 4.2.1.9) where the\n> value of cA is TRUE.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUbCavgYYUQQmcpQECl5ibgPcORiUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATP65xXrF1GNVxB9K4Jq6kbJaDebEtRal/ke85U\n7bFeTrLRPhNOTXEX7XX6+Ce3iFCUijv/ltL+mFaUKr5T89pko1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUqmaJl2hsNEwoQhaN75/I3cIbA78wCgYIKoZIzj0EAwIDSAAwRQIh\nAIQRYp8Tn/JcukJngj7/60p2tsfk3Zoo3dkw0I0WTQaBAiBKOv5GZc05n/dIAnO/\nYSSpzoclIVCOddqzbw3sInh4hg==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB4TCCAYegAwIBAgIUTLLu7ctZ0bBbxP5mVWwtUdPg7JcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA2MTc0MzM3MjAyOTEyMDM5Mzk2MzEy\nODkxMDQ2MjU0NjcwNTY5MTIyNzI4Njg5MDExLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABIgWZX79e8MgoUNfRsPu0xJTk+MdC2D0K+yQjnYeDT9qXnkm3y+qtO0whvVw\nYSRnEEVQG2evQfiFuX5nggVw2IOjWTBXMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFKpmiZdo\nbDRMKEIWje+fyN3CGwO/MAoGCCqGSM49BAMCA0gAMEUCICq7LmPyUEUvfJuTP+/r\n6xD+/wMQaqUW6YhKN/k1ZuDHAiEAwlAF2W+MO5ikO/kVljUdpa01r6w81rul+zgQ\n0gxi6mc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICATCCAaagAwIBAgIUcBMZnFahgfWErtLmPRph8wGPbzMwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjE3NDMzNzIwMjkxMjAzOTM5NjMxMjg5MTA0NjI1NDY3MDU2\nOTEyMjcyODY4OTAxMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGu8et1Qu3rh6Q18CMFdrMqoFI+DZ7oCeev+DnPtpPBKMjaA6ywrpy8sCU5WSUwJc\nb/uzgWHmHMCjIhaPesELMKN8MHowHQYDVR0OBBYEFCB6X6ZCVM4MHJ/IIsHFz38J\n+a5CMB8GA1UdIwQYMBaAFMWj2pBi7MbeSqeZkDtCDyfZhSJnMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNJADBGAiEAnvgETOcahl83TbXcBOicbw2wrUPSTJSZz4ezYJr9\nfPQCIQCfyALr5/vvJQsAMmH9hhI/JQ4B68v6AucTJO2GaflAsw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIFk/7h5YcD9t6LF+F9tLIPgBhMLIY43PqyRWtaa+5Y32oAoGCCqGSM49\nAwEHoUQDQgAEGu8et1Qu3rh6Q18CMFdrMqoFI+DZ7oCeev+DnPtpPBKMjaA6ywrp\ny8sCU5WSUwJcb/uzgWHmHMCjIhaPesELMA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::expired-root", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate -> EE\n```\n\nAll three certificates are well-formed, but the root\n(and only the root) is expired at the validation time.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATOgAwIBAgIUDy3CcuqSlaNvjpkwyH00F3/NrlowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTE2MDEwMTAwMDAwMFoXDTIw\nMDEwMTAwMDAwMFowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAEcy49SxUN7+cNP7XKC5G1kG/IWXi4Hm47AsIigjkX\n99/NEMGlCsx+PoOeWtO6d+y79dX/yUh5X6DGPbxMcTzg4KNXMFUwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFOOw8TNn2taaHEL/RQgFiX1UrMcnMAoGCCqGSM49BAMCA0kAMEYCIQCC\n/Z0Ib18IlsD7WtVnGTy66J8p1na3/pxlXJH5gTEb0wIhAI+fUs41eCh9korWE+m0\n9D+tuQd6wPdGuITZ7KSVFl1Y\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/DCCAaOgAwIBAgIUMemQI8RPTipJrInetKwE3M4q+6owCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTE2MDEwMTAwMDAwMFoXDTI2\nMDEwMTAwMDAwMFowaTE4MDYGA1UECwwvODY2NTUzMzM5ODM3NTI1MjI3NjI0NjM2\nMDUzNDYyMDEwNTg0ODY3Nzg3MDM0NTAxLTArBgNVBAMMJHg1MDktbGltYm8taW50\nZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBA4lto4RBbPWcVaghm1aVIORSyTYGFQ2tI651WIhS+xJI59s6pu2D3LZXuTQrwYy\nJskaEeLSSKTXM8gl8zZvXAKjeDB2MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQD\nAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFOOw8TNn2taa\nHEL/RQgFiX1UrMcnMB0GA1UdDgQWBBTQqHqamLdZ3Sgc7t1+thNHiSRDiTAKBggq\nhkjOPQQDAgNHADBEAiACcjKsI/96RswAthVCyWFfxaywqKq2kGecDCpMpQO0bAIg\nSxu25qxLmzUEXy+6I9JfgMEArOL8iVo/oHjmz0wKXGU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+zCCAaKgAwIBAgITekeIodkPjvBB4nP1V/qSISbLdzAKBggqhkjOPQQDAjBp\nMTgwNgYDVQQLDC84NjY1NTMzMzk4Mzc1MjUyMjc2MjQ2MzYwNTM0NjIwMTA1ODQ4\nNjc3ODcwMzQ1MDEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0\naGxlbi1Ob25lMB4XDTE4MDEwMTAwMDAwMFoXDTIzMDEwMTAwMDAwMFowFjEUMBIG\nA1UEAwwLZXhhbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATz80WJ\nVov1UnwRTlbXXtT0r83pZUUt0PuEkXdq9xqqwD4qnX2G9SciQNRj0LOj645aHoKi\nWApGWeJOzLTLXe1uo3wwejAdBgNVHQ4EFgQU+GAnxTBfhuGYBVQSpjsG1+tAKk8w\nHwYDVR0jBBgwFoAU0Kh6mpi3Wd0oHO7dfrYTR4kkQ4kwCwYDVR0PBAQDAgeAMBMG\nA1UdJQQMMAoGCCsGAQUFBwMBMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIBZiI7kx/3rILA8LVy+hG1fbxAjQQq5nz8X5D7rAuQJCAiAa\nIhMTow6nhieOolcCtBI6GQ9UabPIGNOOjct/NYIQ5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICC12sQgUC+GI+J0hqlwck5Khwlin4FtVhGFKlFghQYJoAoGCCqGSM49\nAwEHoUQDQgAE8/NFiVaL9VJ8EU5W117U9K/N6WVFLdD7hJF3avcaqsA+Kp19hvUn\nIkDUY9Czo+uOWh6ColgKRlniTsy0y13tbg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2022-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::expired-intermediate", + "conflicts_with": [], + "features": [], + "importance": "critical", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate -> EE\n```\n\nAll three certificates are well-formed, but the intermediate\n(and only the intermediate) is expired at the validation time.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATOgAwIBAgIUBT00m0Gss5k1vyvGkQS130TZ0LswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTE2MDEwMTAwMDAwMFoXDTI2\nMDEwMTAwMDAwMFowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAE5daB9sYS+364qH2c18MvOeAHZD8cvp73kf6Aou6N\nOzs4VSn7P6BdsvpYdp2wOCEsSQmRT+o1ULVXeUlNRLFlO6NXMFUwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFMhdPiNVFOv9q/GlLGzzLWwTgelvMAoGCCqGSM49BAMCA0kAMEYCIQCT\nXmUpigqbOg22sGiYvQkDEAb0Ffwbm4uhLB714Glv1wIhAM4vzJij/H5U2iNW9QpV\nrB7HtC7GBmnajeWJQGvLJDNS\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/DCCAaOgAwIBAgIUVcfQ4tLmqfngBpiYlTRyfZgI6vgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTE2MDEwMTAwMDAwMFoXDTIw\nMDEwMTAwMDAwMFowaTE4MDYGA1UECwwvMjk5MDk4ODE5ODExNjE0MjczODY2MzYx\nMTY5Njg1MDU0Mjg4NjkwMzc4MDU3NTUxLTArBgNVBAMMJHg1MDktbGltYm8taW50\nZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBGp3OrbCDFfJiYfUe+Sw/P1NErJsyU93TA22bgqGynGn4IAwjhddrklVhBstxnBP\n0RPaFnZ/riE4OuZH/j2DooOjeDB2MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQD\nAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFMhdPiNVFOv9\nq/GlLGzzLWwTgelvMB0GA1UdDgQWBBRWfv2OHKLWt4GaP90oEh/knqnazDAKBggq\nhkjOPQQDAgNHADBEAiA5co4K8Lh5gLZWnshxo9t+Oeqh1QMHkf4w3Eo1eTcqqAIg\nS9dbmV6aHlgKVm6o7FrstG+CJ1jmW3KTcOcJcOzRgNg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaOgAwIBAgIUXyyoypWDYB0UwVlBgaMP6m4mIyQwCgYIKoZIzj0EAwIw\naTE4MDYGA1UECwwvMjk5MDk4ODE5ODExNjE0MjczODY2MzYxMTY5Njg1MDU0Mjg4\nNjkwMzc4MDU3NTUxLTArBgNVBAMMJHg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tTm9uZTAeFw0xODAxMDEwMDAwMDBaFw0yMzAxMDEwMDAwMDBaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzIHu\nlYNjWhz+SVJuiFqejqB1wwwBESeKzTU0EwpaAT9b6EqzItYy8lK4kUTVIz9VojPm\nHyHnkpRJDxq/BVvg6qN8MHowHQYDVR0OBBYEFO5cenLBATYHUPLtBj2+iUaTemMZ\nMB8GA1UdIwQYMBaAFFZ+/Y4cota3gZo/3SgSH+SeqdrMMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAxt1/1PZ3X19SUNfQO56qZFjLX49SoHkqr1qeBkJbifEC\nIQDO5+xKfE69drl0Oliw8I4DwtZ+wF4NL561u+azzpDUyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDelFfhcEsBE66TnIjOoi5WgNzJPa6R8iOBrQ0K7CpczoAoGCCqGSM49\nAwEHoUQDQgAEzIHulYNjWhz+SVJuiFqejqB1wwwBESeKzTU0EwpaAT9b6EqzItYy\n8lK4kUTVIz9VojPmHyHnkpRJDxq/BVvg6g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2022-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::expired-leaf", + "conflicts_with": [], + "features": [], + "importance": "critical", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate -> EE\n```\n\nAll three certificates are well-formed, but the leaf\n(and only the leaf) is expired at the validation time.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjDCCATKgAwIBAgITaLPjlWahnRXzjC13OrbDdQmduDAKBggqhkjOPQQDAjAa\nMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwHhcNMTYwMTAxMDAwMDAwWhcNMjYw\nMTAxMDAwMDAwWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcqhkjO\nPQIBBggqhkjOPQMBBwNCAAQfiPqq5PSMCWPjkWEZFJvys7fDqS3eKgeSUx9u8zaa\nF4sMayBT7UiXdPqe0PI4hklr9NsKP4ArQORyXRwXlMwTo1cwVTAPBgNVHRMBAf8E\nBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAdBgNV\nHQ4EFgQU7wuCb3Y1/KeTGVaMhGREkXvzDEcwCgYIKoZIzj0EAwIDSAAwRQIhAOfE\ny+S/N8vC+H2P1256ssb0MLVd+PIaerzv0LrPSVAvAiAOm5uLY5eVPYD19bIZg/Ct\npK0VZNdC9+ptkg+U4AIi3A==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB+zCCAaKgAwIBAgIUVs3pEukJU4qLuEyxGk5R/JWqNckwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTE2MDEwMTAwMDAwMFoXDTI2\nMDEwMTAwMDAwMFowaDE3MDUGA1UECwwuMjMzNDk0ODA0MjUxNDEyNDUwODk4NTAw\nMjg1NDAzNTk1Njg0NTQzMTU5NDQyNDEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRl\ncm1lZGlhdGUtcGF0aGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBciRqEO7kwgCUBuUHXO5AYFo4rdh42WLl7vnf7SgPXernhSluIGEEkZTJPI4bVrd\ndDE4x06zhd1CPeqU967pU6N4MHYwDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8EBAMC\nAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAU7wuCb3Y1/KeT\nGVaMhGREkXvzDEcwHQYDVR0OBBYEFGR4oHmw+U8ZJ0+wwUHgOB768f2IMAoGCCqG\nSM49BAMCA0cAMEQCIF6QGWwrU9HLTcvYe4LY1lL6pmi1oSkvnkygKH780SEhAiAQ\n2Sw8odvkfmq2Whfnn2XoCdPIQkUig21dBCklgeIKsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/DCCAaKgAwIBAgIUdwEWNWkHMbd9kS9C41Phjgy19TEwCgYIKoZIzj0EAwIw\naDE3MDUGA1UECwwuMjMzNDk0ODA0MjUxNDEyNDUwODk4NTAwMjg1NDAzNTk1Njg0\nNTQzMTU5NDQyNDEtMCsGA1UEAwwkeDUwOS1saW1iby1pbnRlcm1lZGlhdGUtcGF0\naGxlbi1Ob25lMB4XDTE4MDEwMTAwMDAwMFoXDTIxMDEwMTAwMDAwMFowFjEUMBIG\nA1UEAwwLZXhhbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQ7VLXj\nKaMGmBdKcV9Nv7wTgcyveFlhaeLJDFBLuXV5qvsZ7t8sGeMNfDOWKuaBUgYk3Grb\nD3wRmjRGTyBI367/o3wwejAdBgNVHQ4EFgQUARSb3wG2XP8duvYpAJyqxPuTV9Mw\nHwYDVR0jBBgwFoAUZHigebD5TxknT7DBQeA4Hvrx/YgwCwYDVR0PBAQDAgeAMBMG\nA1UdJQQMMAoGCCsGAQUFBwMBMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCMYjnFvSKFqpPxZ+oURTAew3nWnpCcKXINfyDkXYvO+gIg\nURhkPNGrB1JusqCJl2o3JNW9cTEQlGGN/w+5otLNx1U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIB3SVk8Q2pVyQQ/BiP7OjpkHfzT//6J8vKu0//Bm0laXoAoGCCqGSM49\nAwEHoUQDQgAEO1S14ymjBpgXSnFfTb+8E4HMr3hZYWniyQxQS7l1ear7Ge7fLBnj\nDXwzlirmgVIGJNxq2w98EZo0Rk8gSN+u/w==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2022-01-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::notbefore-exact", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following valid chain:\n\n```\nroot -> ICA -> EE\n```\n\nEE becomes valid at `2024-03-01T00:00:00Z`, and the chain is validated at\nexactly `2024-03-01T00:00:00Z`.\n\nRFC 5280 4.1.2.5 says that `notBefore` is inclusive, so this chain should\nvalidate:\n\n> The validity period for a certificate is the period of time from\n> notBefore through notAfter, inclusive.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjDCCATOgAwIBAgIUIDgS1V11RTga6kS+hKOQ/XYT6aEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMFoXDTI0\nMDQwMTAwMDAwMFowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAEig+Euu2XLPqp19P79Im8mCj5VLxs/V3CKwY/EN9I\nDN1171d3Nf7ssiicECMmf6nFfyH0+Z9y64NBH6tF1CZYDKNXMFUwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFNdjGHdBES8YVUmlizJ6kBQZG4F9MAoGCCqGSM49BAMCA0cAMEQCIDVk\nZz5u06Y2EU+0ZzO3gNZTMY4UK5Jzdm94VwaelSWFAiBdujaikE1Hwtf3P26Fw13E\nnAfV4coxSvx1KX/xDU2aAA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgIUNah97eKduyA9uvvLe1try9W14rAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMFoXDTI0\nMDQwMTAwMDAwMFowajE5MDcGA1UECwwwMTgzOTM4MTg3MDIyOTk4NjExNzg3NTM0\nMjg4NTUwOTQ1MDQyOTM4MTcyMDA4ODY1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWlu\ndGVybWVkaWF0ZS1wYXRobGVuLU5vbmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQFWFu1RPAZQScTaIPk2m6+NcPXtx4GsKZe/KjBmwqBqCZZfoMfGWKCfY4h5TPt\n+4nysD1FFf67wHi4L3+DYDpjo3gwdjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNvbTAfBgNVHSMEGDAWgBTXYxh3QREv\nGFVJpYsyepAUGRuBfTAdBgNVHQ4EFgQUT871p/j/q1gEkaQ7PMFSPXz7oRAwCgYI\nKoZIzj0EAwIDSAAwRQIhAIF1f3qOZE012ps63bHxCP9S6SM2zBCJs/qqcUL57QQQ\nAiAIQTE8b5nOHfSywXsh/UzW33zzy0rqQbh9ZBqVY4REWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaSgAwIBAgIUB13Tq7l0UBcx47ET7wEZQFKoEMcwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMTgzOTM4MTg3MDIyOTk4NjExNzg3NTM0Mjg4NTUwOTQ1MDQy\nOTM4MTcyMDA4ODY1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwHhcNMjQwMzAxMDAwMDAwWhcNMjQwNDAxMDAwMDAwWjAWMRQw\nEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHXI\nRA7dBEnHzE8ZZXXOVeHbAz2eyRhy+Bv0z5aFA0fDvoPics2ehmVG+Ub3Ak55g+Om\n/G1xCji6fJ6SZ/7h4wajfDB6MB0GA1UdDgQWBBSgTKhsWpzeGYzJFJkRImgPcIo3\nCDAfBgNVHSMEGDAWgBRPzvWn+P+rWASRpDs8wVI9fPuhEDALBgNVHQ8EBAMCB4Aw\nEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgSmCG3nwwMUf9gaICPW+21qUiX9OUVmkMmYLDUq49QNEC\nIAWAiOHRKK0cA1jBXoBfRw6H7c9xxS0MLBNr9ZduKoFO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDj4HsCU0QV7kil1p7hbmrkAY9YNDa53u98usw/yp6iyoAoGCCqGSM49\nAwEHoUQDQgAEdchEDt0EScfMTxlldc5V4dsDPZ7JGHL4G/TPloUDR8O+g+JyzZ6G\nZUb5RvcCTnmD46b8bXEKOLp8npJn/uHjBg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-03-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::notbefore-fractional", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> EE\n```\n\nEE becomes valid at `2024-03-01T00:00:01Z`, and the chain is validated at\nexactly `2024-03-01T00:00:00.999Z`.\n\nThis is the counterpart to `rfc5280::validity::notafter-fractional`:\ndespite rounding to the `notBefore` date, implementations should\n`floor` the validation time instead and subsequently reject this chain.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjTCCATOgAwIBAgIUDtgZ8576VauDJibzgoN/HYpxfikwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMVoXDTI0\nMDQwMTAwMDAwMFowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAELlYC8qUppcsKf4sDDUzf2IR5hCd/pBpmJI7Y+WHU\nzyhCjqKe6WGnQkuW+jTzgFIyNHCKnAXiAbK62Bea1OYD6aNXMFUwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFOl+sgDcuUQbCJXTBVtwI9lVxRcYMAoGCCqGSM49BAMCA0gAMEUCIQCv\nV9Al5ACEtg15WZfxRsAW2BXIs7vQstBKtAYB7TOsaQIgTNTgmbkNQBjsg1iQZpXr\niHWA8wb0aWYCUYGeLDK/vYI=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/DCCAaOgAwIBAgIUSmwMFVutmgcUf7c1Uxc1pQKgyeQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMVoXDTI0\nMDQwMTAwMDAwMFowaTE4MDYGA1UECwwvODQ3NDUwOTI0NjE0OTc2NTg4NzQxMTk2\nOTEyMDAzMzQwNjU2NTkxODYwODU0MTcxLTArBgNVBAMMJHg1MDktbGltYm8taW50\nZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBFBbvlBsgq/vlEfCD8qN66i4HXBEFOZWreQ5FT1jvdqcK6oP0xZck+NEnO9uUMHj\n8beyDy1j0Ay4XV8uXlW1JvqjeDB2MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQD\nAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFOl+sgDcuUQb\nCJXTBVtwI9lVxRcYMB0GA1UdDgQWBBSos0BKfyIi5UdZbfshT1DbB8w5AjAKBggq\nhkjOPQQDAgNHADBEAiBkewEYFAS+Ija15Se6tUQ/+1eq7z+5swdFQc7oLQoJ2AIg\nNrO5lkS8XJCKTGWNiaaPYNAwEKWqz0Z+6e+47sCjP+Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/DCCAaOgAwIBAgIUaT/WrqJMyJmcXOXCV/MrPkO8R70wCgYIKoZIzj0EAwIw\naTE4MDYGA1UECwwvODQ3NDUwOTI0NjE0OTc2NTg4NzQxMTk2OTEyMDAzMzQwNjU2\nNTkxODYwODU0MTcxLTArBgNVBAMMJHg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tTm9uZTAeFw0yNDAzMDEwMDAwMDFaFw0yNDA0MDEwMDAwMDBaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsNyp\n+JG8PbO1lg6Y5I5FXnJmxU5HVtj6qBt3DHGL9d/MwNEJNS5nSc3IyiB0n6V7e2Fb\n0TlGhTjQOQABNnZf+KN8MHowHQYDVR0OBBYEFNcpthr1GqoWB9GbTZITcd+PxG72\nMB8GA1UdIwQYMBaAFKizQEp/IiLlR1lt+yFPUNsHzDkCMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBR/5DDNASjPLhxwUxISZL7B1gIuBM1JvJO9GSdH7kYVAIg\nK01Lr3u9B9DYQLHwB0UUYj1MfS5Y/Z1k+clr/6+ul/A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIM3GVLNTnGV33NEnErhHTDfGwxzAReG94I299oAEN6U9oAoGCCqGSM49\nAwEHoUQDQgAEsNyp+JG8PbO1lg6Y5I5FXnJmxU5HVtj6qBt3DHGL9d/MwNEJNS5n\nSc3IyiB0n6V7e2Fb0TlGhTjQOQABNnZf+A==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-03-01T00:00:00.999+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::notafter-exact", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following valid chain:\n\n```\nroot -> ICA -> EE\n```\n\nEE expires at `2024-04-01T00:00:00Z`, and the chain is validated at\nexactly `2024-04-01T00:00:00Z`.\n\nRFC 5280 4.1.2.5 says that `notAfter` is inclusive, so this chain should\nvalidate:\n\n> The validity period for a certificate is the period of time from\n> notBefore through notAfter, inclusive.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjDCCATOgAwIBAgIUed6M3pMez3msUqRn+kBjg4ENjFMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMFoXDTI0\nMDQwMTAwMDAwMFowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAEEgEtaDftHvO5B8WWE7gha690yUP+wf2NR1c3Plyf\nwG01D/DydMwXY0d1iL/koNDZHbw5QUFM5+tkImF2x+Q/kqNXMFUwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFMGXwuKxloWsnMEpCmLtIupRlivtMAoGCCqGSM49BAMCA0cAMEQCIEbg\nB5vV7V0YjiTygSG5HVTf+bx6qb5zrZsEwD6cShI4AiBSuzdvrhGZ0Fk2W8VLj2RY\nYCfz+qsjNi2SdahJ8vz8dQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgIUYdU/0sXVCg3c//PlCoSzll2ZoBMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMFoXDTI0\nMDQwMTAwMDAwMFowajE5MDcGA1UECwwwNjk1NzUwOTIwMTYyMDMwNzc2MDM3MzY2\nMzgzMTQ1Mjg1MDQ5MjkxMDc1NTg3MTU1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWlu\ndGVybWVkaWF0ZS1wYXRobGVuLU5vbmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR74D5ArctDrMeYLYfPxMNkoQgtLDg6k0/ITtIFUnV+XILuZoM7B+e23Ag7Eko/\nnQUr7II2BvSy66NRf5sLCIg8o3gwdjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNvbTAfBgNVHSMEGDAWgBTBl8LisZaF\nrJzBKQpi7SLqUZYr7TAdBgNVHQ4EFgQUW5lUpVG5DFYUv1USaoVjAz6dJVgwCgYI\nKoZIzj0EAwIDSAAwRQIhAOrS5fRMRCXEl6wFiF96/t6nMige7d5+30MHWnd6R6Dg\nAiByiKirYiix34wvM9v4btKDGe4m7hkjmjlSKT9zidTRuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgIUP++dswBOK2UJce/cGYxqe7ELXBwwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjk1NzUwOTIwMTYyMDMwNzc2MDM3MzY2MzgzMTQ1Mjg1MDQ5\nMjkxMDc1NTg3MTU1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwHhcNMjQwMzAxMDAwMDAwWhcNMjQwNDAxMDAwMDAwWjAWMRQw\nEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKqd\nhGydPtl5otQ7h0r7kF4AsERlei3iASInIRMRBsplCNjmjAvlSM8PZWI+NtEWBUNR\nY937UcHV6lTdL0O2aNKjfDB6MB0GA1UdDgQWBBTNGTweXUB3V4GU93490sI2x9vf\nujAfBgNVHSMEGDAWgBRbmVSlUbkMVhS/VRJqhWMDPp0lWDALBgNVHQ8EBAMCB4Aw\nEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgYOmGOL0PsaGrvA/rtYwXKmoMhRLpe2YXr1b8aeIaKUkC\nIQCy+RGHcUZ5v5zZuHj/uKQSAZEbUK/voU8jTmaswiudjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIBcDeTFVFm1m06RdjlIJX3HEUEzEOz7iDP36IHqgxEjNoAoGCCqGSM49\nAwEHoUQDQgAEqp2EbJ0+2Xmi1DuHSvuQXgCwRGV6LeIBIichExEGymUI2OaMC+VI\nzw9lYj420RYFQ1Fj3ftRwdXqVN0vQ7Zo0g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-04-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::notafter-fractional", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **ambiguous** chain:\n\n```\nroot -> ICA -> EE\n```\n\nEE expires at `2024-04-01T00:00:00Z`, and the chain is validated at\n`2024-04-01T00:00:00.005Z`, i.e. 5 milliseconds after the `notAfter`\ndate.\n\nRFC 5280 only allows second granularities in the validity interval, with\ntwo conflicting interpretations of how to handle the validity check:\n\n1. Comparisons are performed at the granularity of the encoded\n representation, i.e. `floor(time)`. Under this interpretation,\n the chain is valid, since the entire millisecond interval `[0, .999...]`\n is truncated to `0`.\n2. Comparisons are instantaneous. Under this interpretation the chain\n is **invalid**, since 5 milliseconds after the `notAfter` is factually\n after the `notAfter`.\n\nThere is no clear \"winning\" interpretation here, although\nCAs in the Web PKI have filed and handled compliance reports based on\ninterpretation (1).\n\nSee also:\n\n* \n* ", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjDCCATOgAwIBAgIUIKPSm7n6Fu84HDfh7FQUTJxgduUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMFoXDTI0\nMDQwMTAwMDAwMFowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAELs4obBb11WU+iQEBvhiEIZcGOa+QOc8gBCB+G4JE\nOriDXUcMWdr/jUjn6o4hGWEsLXwUG5NDZFT5I0TtxJqq/aNXMFUwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFJcMRwt8b5rzVuRP+nlDx8PlUiy3MAoGCCqGSM49BAMCA0cAMEQCIH9Y\noOzSB9hzi22DtlpwgdMa5BSirb40hCtq7xwE3PT/AiAVWBB3Xm8+2Vc+Iz7sqhI2\nV4L0GkMt/lDDuNhjazVPWQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaSgAwIBAgIUX371RbDPeT1jVN924GEIZ3yKSi8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMFoXDTI0\nMDQwMTAwMDAwMFowajE5MDcGA1UECwwwMTg2MzQxMDcyNzA0NzQxNjE3MzQ1NTM5\nMDkzMDIwODQ3NDUyMzg3MTcxOTIzNjg1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWlu\ndGVybWVkaWF0ZS1wYXRobGVuLU5vbmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASzaOkPX2Vs5HjjqfMnTmhR4sZXVpgHmalywv40ZEJWTA+gRKut/Fyhgj33om36\n10+/pdd6CQNDeGbu6vp7AD2ro3gwdjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNvbTAfBgNVHSMEGDAWgBSXDEcLfG+a\n81bkT/p5Q8fD5VIstzAdBgNVHQ4EFgQUFblJEeTZDsD9lrSKGgcKWfnxlzkwCgYI\nKoZIzj0EAwIDRwAwRAIgOrK6eFXFfJLmwMAx2LvGMI1Tnx7bySGvPi0sGxHUl0MC\nIFpIjSOloodFJ6fVIqsV9LTO8mXxcf0KpS+dyOOTcyBb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgIUfqLoXeCi/vn7DpbzycCY7L6ohv0wCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMTg2MzQxMDcyNzA0NzQxNjE3MzQ1NTM5MDkzMDIwODQ3NDUy\nMzg3MTcxOTIzNjg1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwHhcNMjQwMzAxMDAwMDAwWhcNMjQwNDAxMDAwMDAwWjAWMRQw\nEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG5h\ng6p9pznP2pZNrkSD4PXWQh/F4v3lmEd1yIr1bD7JqD8PZnB6MgDcs+PP1MJ28npk\nseza0AOibwsckQRyMrijfDB6MB0GA1UdDgQWBBRthgn1zhG8i/Pjhfr6ao8F2KLY\nfTAfBgNVHSMEGDAWgBQVuUkR5NkOwP2WtIoaBwpZ+fGXOTALBgNVHQ8EBAMCB4Aw\nEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAPbs+qVYSHHzRrOH8yRa4d4UsSUl09f7RiSRVU1/lcrK\nAiA68IREXjolgT/nZ+zXjqS2aSVxQZ0ubluLOq4ip0/X3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIArQmR6Vf/mFVPo4GNoYtabXPfIWAfOrXnjn2OTeLBsyoAoGCCqGSM49\nAwEHoUQDQgAEbmGDqn2nOc/alk2uRIPg9dZCH8Xi/eWYR3XIivVsPsmoPw9mcHoy\nANyz48/UwnbyemSx7NrQA6JvCxyRBHIyuA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-04-01T00:00:00.005+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::expired-1-second", + "conflicts_with": [], + "features": [], + "importance": "critical", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> EE\n```\n\nThe EE certificate expires at `2024-04-01T00:00:00Z`, and the chain is\nvalidated at `2024-04-01T00:00:01Z`, i.e. exactly 1 second after expiration.\n\nPer RFC 5280 4.1.2.5, the validity period is inclusive of both `notBefore`\nand `notAfter`. However, any time strictly after `notAfter` should result\nin validation failure. This test ensures implementations strictly reject\ncertificates that have expired, even by a single second.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjTCCATOgAwIBAgIUP8SpBTrA2/f6YLrGIGROEWvD+/EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMFoXDTI0\nMDQwMTAwMDAwMFowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAERCrkok9AQBOH+DLDYgIjjsjNaeS1NpgtKxSdL9UZ\ntzolyau4KXbiiNdknGCa5+63XG92IpHuSq1MOgaBpdIXuKNXMFUwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFDHVkxVWKcZ8WMRBNiqGqcSck8dKMAoGCCqGSM49BAMCA0gAMEUCIQDZ\ngsVzsWARkExvo7wtkO/1OSR+Pka/PKMsZIKy4rFZYwIgVoqv/IdZeT/E7bYt15Hj\nwFvxe1Ov6Imzvw8EUIYDuJ8=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaSgAwIBAgIUbLVDmkpCKtkR9Kdn3xXIMbPYNYEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMFoXDTI0\nMDQwMTAwMDAwMFowajE5MDcGA1UECwwwMzY0MDUyMDg4Mzc2NjQ0ODAwNDk1NzE2\nMDAxNDU5Nzg4MjAxNTIxMzA1NjE1MzQ1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWlu\ndGVybWVkaWF0ZS1wYXRobGVuLU5vbmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQRn2EMne+9YhzwcMiTS30SSMXmpjrYoLNXG56YpN9ni92jxDDzmhB7Zasz5BAP\n0or0kxr0Fhuh7wLfS4AXBgiJo3gwdjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNvbTAfBgNVHSMEGDAWgBQx1ZMVVinG\nfFjEQTYqhqnEnJPHSjAdBgNVHQ4EFgQU3OHcLWWO5nZLmlqVOrxNhVFwwHkwCgYI\nKoZIzj0EAwIDSQAwRgIhAMlQcUbbc3Nkps/KkHXvckd8DqSNXEDAz9/Q4f42Aheo\nAiEA9LK0ZKyR0rOR+Km+86YJEoevSj6v+G36i07Sx0LIeDA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaSgAwIBAgIUE96GtbEsS703sUZM5EdqtcDmUJcwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMzY0MDUyMDg4Mzc2NjQ0ODAwNDk1NzE2MDAxNDU5Nzg4MjAx\nNTIxMzA1NjE1MzQ1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwHhcNMjQwMzAxMDAwMDAwWhcNMjQwNDAxMDAwMDAwWjAWMRQw\nEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEVG\nEtGoRXFG8Qm6Yd1bu7jUJ9piSMdWcWYxqFLdmRLyVXdfITKEEYWSZl/VYcLwqYmZ\nihr9te/qpp6ZZ0cExJSjfDB6MB0GA1UdDgQWBBTiOj/Svilz/xzqsjlyzv4+Enle\nYTAfBgNVHSMEGDAWgBTc4dwtZY7mdkuaWpU6vE2FUXDAeTALBgNVHQ8EBAMCB4Aw\nEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgLm+7fMp6vVW58r2xScHvgk4jrV1//CtU2hogZxIWefIC\nIFgaXEAfQsxiXrca+LOrAGFwYAaL3FwcDJh9PjUbAKyp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIN/mddccvLPz1wNBeoE5oXri8AGwJ2KpbyjtEjJMvoaaoAoGCCqGSM49\nAwEHoUQDQgAERUYS0ahFcUbxCbph3Vu7uNQn2mJIx1ZxZjGoUt2ZEvJVd18hMoQR\nhZJmX9VhwvCpiZmKGv217+qmnplnRwTElA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-04-01T00:00:01+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::expired-5-seconds", + "conflicts_with": [], + "features": [], + "importance": "critical", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> EE\n```\n\nThe EE certificate expires at `2024-04-01T00:00:00Z`, and the chain is\nvalidated at `2024-04-01T00:00:05Z`, i.e. 5 seconds after expiration.\n\nThis test ensures implementations strictly reject certificates that have\nexpired by a small number of seconds.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjDCCATOgAwIBAgIUdmlRCr97mdWlNVmeiwr9YWy2lZMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMFoXDTI0\nMDQwMTAwMDAwMFowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAEaato/UwxDfvrePHJW5PBlARVqFBefou/9dFCHzCB\nvhCAFeZyQRhBH+bYkCbfS4QqQlaE42a7Fj2whgfw4/EUG6NXMFUwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFPrTn8D8DL0Y6U+Cmb7Ml1zP2UvCMAoGCCqGSM49BAMCA0cAMEQCIByj\nYhKgt0fqwBG4fAiVOMNhKb3gxhHKEYWNH2oFruoGAiA5our1hV2ED8Pr+QyJU9ee\nhfdPaGDAEPY/cOFStRjiFA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgIUQA4CwNVJhHGiSc+NRPpJjdQNh+owCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMFoXDTI0\nMDQwMTAwMDAwMFowajE5MDcGA1UECwwwNjc2MDA5NTQ4OTU1NTY3MjQwOTIyNjUx\nNDUxODM5MzkzODgyMzU2NzQ1NDA5OTM5MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWlu\ndGVybWVkaWF0ZS1wYXRobGVuLU5vbmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATEO4/1cW8xuGzLUHlZMywkCF6RZaskipD1SEz/YXrEZmgIcO3+FQdjojJpmc3v\neyARuY7pTV9kHdu7mzETMtARo3gwdjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNvbTAfBgNVHSMEGDAWgBT605/A/Ay9\nGOlPgpm+zJdcz9lLwjAdBgNVHQ4EFgQUD8ts+uK5jsmNOta3Lp+zidd2yuYwCgYI\nKoZIzj0EAwIDSAAwRQIhAKiih+327gn7+Z7dAdz73qzMfgVCCbauQaXXwjLYe1cX\nAiBgks2LZDVHKBzFrv6ag6kOoufwgvONpPt4/Hp2emc4/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgIUPKtOZm+UOc9J0bsqTMjxuuhrOfAwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjc2MDA5NTQ4OTU1NTY3MjQwOTIyNjUxNDUxODM5MzkzODgy\nMzU2NzQ1NDA5OTM5MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwHhcNMjQwMzAxMDAwMDAwWhcNMjQwNDAxMDAwMDAwWjAWMRQw\nEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDHp\nSWvVnHv2xVqDXIb8+zirp5dOkE2DhFxzdguNUowobzv4fV3ziZAqbXX5mfXgZGZa\nA1cXQN44iRjLi1eFNtejfDB6MB0GA1UdDgQWBBRw+BI4vOGYreXhmMJX/pbg0sAN\nBzAfBgNVHSMEGDAWgBQPy2z64rmOyY061rcun7OJ13bK5jALBgNVHQ8EBAMCB4Aw\nEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAL+jnOZxdZCWLD+n0NjJadEYK8eRd9Nyh0PIMx6+PdMV\nAiBAGmb8Vy48MkL0IE1a4P3L1PlexyNvcj5afrN2Uv6S5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIGKChdORJCIJHJuk4vn1xgK6dYcvAPL1q9BJG47Sbc0joAoGCCqGSM49\nAwEHoUQDQgAEMelJa9Wce/bFWoNchvz7OKunl06QTYOEXHN2C41SjChvO/h9XfOJ\nkCptdfmZ9eBkZloDVxdA3jiJGMuLV4U21w==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-04-01T00:00:05+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::not-yet-valid-1-second", + "conflicts_with": [], + "features": [], + "importance": "critical", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> EE\n```\n\nThe EE certificate becomes valid at `2024-03-01T00:00:01Z`, and the chain\nis validated at `2024-03-01T00:00:00Z`, i.e. 1 second before the certificate\nbecomes valid.\n\nPer RFC 5280 4.1.2.5, the validity period is inclusive of `notBefore`.\nHowever, any time strictly before `notBefore` should result in validation\nfailure. This test ensures implementations strictly reject certificates\nthat are not yet valid, even by a single second.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjTCCATOgAwIBAgIUeSdjGFQQQ9N9D98zE7/YPvyIhs0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMVoXDTI0\nMDQwMTAwMDAwMFowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAEowFAYCgqRB9Dn8RXoMpdQGVhHYiYAl3WzXrZFZWc\nkEwcc3KIJxKcQ5DvTe/iIBqSPsRrb1XJIGJrwcbrAmPJJqNXMFUwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFAXK38hmP8XvPfraviUGyy2CJkKxMAoGCCqGSM49BAMCA0gAMEUCIQD3\n7f6mRTYeubIK63kIZ4UtYoRcSnMUoOEWWHEwTB+ygAIgT1A+208nGsV/wLwFtMAy\n2PvLeTG4gZfwClWSY73gWvE=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgIUK03iHmG3xxMZElkCysqKAvce9KQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwMVoXDTI0\nMDQwMTAwMDAwMFowajE5MDcGA1UECwwwNjkxNjY2MjQ0NzI3MjUwOTMxMTc0NjMx\nNDgwOTk1Nzk1MjUzNDAyOTkzNzIzMDg1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWlu\ndGVybWVkaWF0ZS1wYXRobGVuLU5vbmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATCRuNdlRQabJUk8AjnHr/tKKrVHP5N8gheduKc/e/iBTbEBf+fY4ej8QZVqrds\nhguL8N++A46ujaTHtp7tp79Lo3gwdjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNvbTAfBgNVHSMEGDAWgBQFyt/IZj/F\n7z362r4lBsstgiZCsTAdBgNVHQ4EFgQUCuuATVJDpTy64KK1Sm8pf/nP15swCgYI\nKoZIzj0EAwIDSAAwRQIhALFyjZiu64os4xDnwXiQbA82jwejEvxEXnNG/3Jgk39Z\nAiBNB/Uc8t2f3CR2rFOaPEhG5gY6jWi9pS27nq0eixoq+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgIULGBg3alPAFrbYqwiDNk5lCqYzKswCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNjkxNjY2MjQ0NzI3MjUwOTMxMTc0NjMxNDgwOTk1Nzk1MjUz\nNDAyOTkzNzIzMDg1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwHhcNMjQwMzAxMDAwMDAxWhcNMjQwNDAxMDAwMDAwWjAWMRQw\nEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEEq\nlaqqenZwrsT2IAwVKfK5UtxYkSmUBGaF643XI0EM5elalox0+9UNmxHGT0vtg9Rm\n1hQPQVPRLC6L3maeq6OjfDB6MB0GA1UdDgQWBBQVms+VyNAYcKpsXJbKza9j3wDB\nZDAfBgNVHSMEGDAWgBQK64BNUkOlPLrgorVKbyl/+c/XmzALBgNVHQ8EBAMCB4Aw\nEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgWhvpbvz9atbVcq6qz+v7ghGwlLDJCOWApLd2cU4xrZMC\nIQCCX3zxDY3KMjyq34xbP0SnwMQ9iOYoY8j3CXp+FVhQOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIADgLr3z+x2nzu4ewUjAzereJ+BIZyZtP5duW4joaT7OoAoGCCqGSM49\nAwEHoUQDQgAEQSqVqqp6dnCuxPYgDBUp8rlS3FiRKZQEZoXrjdcjQQzl6VqWjHT7\n1Q2bEcZPS+2D1GbWFA9BU9EsLoveZp6row==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-03-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::validity::not-yet-valid-5-seconds", + "conflicts_with": [], + "features": [], + "importance": "critical", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> EE\n```\n\nThe EE certificate becomes valid at `2024-03-01T00:00:05Z`, and the chain\nis validated at `2024-03-01T00:00:00Z`, i.e. 5 seconds before the certificate\nbecomes valid.\n\nThis test ensures implementations strictly reject certificates that are\nnot yet valid by a small number of seconds.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATOgAwIBAgIUP4LeTjLIypARoDQfk1EjzVYRtA0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwNVoXDTI0\nMDQwMTAwMDAwMFowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAEThCkO36v5CXjFV/T0LesC3wVLGoQrWxP7MDXYmVR\n1kpcoruST7PAhr3iZYT3BQ9/wIPPi7MaJjM9Tj4idMC+kaNXMFUwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFKJ+iyX6jW3dH5zdO6OV8/kCqWwNMAoGCCqGSM49BAMCA0kAMEYCIQDj\nnqek92M34nXiJX/4lKFFEWkbH1HaUzXcIbUvkVBLMAIhAMBTzufBYrQEXPcGl6dl\nmUb6d3IJDBYmMYVDE/jai4NT\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaSgAwIBAgIUKpfyo4fDXaPIqY8rCq6VJxyMfPQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MB4XDTI0MDMwMTAwMDAwNVoXDTI0\nMDQwMTAwMDAwMFowajE5MDcGA1UECwwwMzYyNTg0ODgwOTc0NzE2MzA5MjY1MDQ2\nNDI2NjMxNjM1MzkzODkyNDIzMTUyNjUzMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWlu\ndGVybWVkaWF0ZS1wYXRobGVuLU5vbmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATeLVjuMDR1QvQyBLxyB4cu477XTjr97ZF5W2e3jg2b8mJQEdPz3MfsozGZCO9l\nbk/lbcwKqJCP4AJrtVvoPTOHo3gwdjAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQE\nAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNvbTAfBgNVHSMEGDAWgBSifosl+o1t\n3R+c3TujlfP5AqlsDTAdBgNVHQ4EFgQULBEUDgfga3CRllG0Lsm31kaV5ZkwCgYI\nKoZIzj0EAwIDRwAwRAIgSLDH0rQ7sYC+xXhmjBf8/MxoKaoy3CWbMX0avpU7C94C\nICvYWja6qPYypsWaIgP4fNatjXqQnhvKCmQcrvQnvWUJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgIUdNdvuadEoqMTXbBMSh1Z6fTp1G8wCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMzYyNTg0ODgwOTc0NzE2MzA5MjY1MDQ2NDI2NjMxNjM1Mzkz\nODkyNDIzMTUyNjUzMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwHhcNMjQwMzAxMDAwMDA1WhcNMjQwNDAxMDAwMDAwWjAWMRQw\nEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABACt\noaGhPnXwNDTfy8HNe/sorckwthm0V4ue9F90Hj1PxEK14D/OYv/MG0jwun9MylJ6\ncZlS7cFJvFBg6SpA4PKjfDB6MB0GA1UdDgQWBBQAXF0rmaPqNXW71aAUpa1TUfMS\nSTAfBgNVHSMEGDAWgBQsERQOB+BrcJGWUbQuybfWRpXlmTALBgNVHQ8EBAMCB4Aw\nEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAMm1l4hTx+2Z5sYZrY84oRxFL+7AFx4ZM1rFBvjOrFUT\nAiBxyde8K954v8ys2X85rRIBli6I/QdGWJa+PzFbOWUybQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIF1Ee5cPddr/+yumb5tji+7PJ0rxBIKHJ35Q35kLo2EoAoGCCqGSM49\nAwEHoUQDQgAEAK2hoaE+dfA0NN/Lwc17+yityTC2GbRXi570X3QePU/EQrXgP85i\n/8wbSPC6f0zKUnpxmVLtwUm8UGDpKkDg8g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": "2024-03-01T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::ee-empty-issuer", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThis chain is invalid solely because of the EE cert's construction:\nit has an empty issuer name, which isn't allowed under the RFC 5280 profile.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUW4bZwpiOJeCYOXbn5ZwtGetU31YwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQURgE5xcvTCIyW/Qc0hGsfhA3pUNlGV3hL4saP\nylMVjONf0b4xBKdlcqu1QS43rQ+lvkkEZiRNkBWqlTGecZCoo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUf97Gg2k7ABk7kBq82nSJyEU1UBUwCgYIKoZIzj0EAwIDSAAwRQIg\nTynYRJPmSfUlVFtVIQBn3e8th78wDciOweEaI686arUCIQC6004DYrt4OKpuFv4x\nif/UVI8+hXCSCpoSA2aZKpr6bQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBlzCCAT2gAwIBAgIUaetJ9hunT7U2jpe6twmjTiDfmoYwCgYIKoZIzj0EAwIw\nADAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFzEVMBMGA1UEAwwM\nZW1wdHktaXNzdWVyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfQOzstUvJ1ZH\nuvEdNIGPfGzTJX8Fi/SnDrs3ev1Dr01SOK8bWdbkaaaKk8RBzvJoB2DDC43WWeG9\n+ma7WWHn9qN8MHowHQYDVR0OBBYEFIX515ETwUsV2LTZGUrrjPLbgBxOMB8GA1Ud\nIwQYMBaAFH/exoNpOwAZO5AavNp0ichFNVAVMAsGA1UdDwQEAwIHgDATBgNVHSUE\nDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggqhkjOPQQD\nAgNIADBFAiEA3q5kPjaAOU0XIVVInitZKAIibtzJ+YfuRwLivgAvNycCIEoouud5\nzoGf6SuVA1n5XCYnx5Fd3oh6YFwNoU8NjQUc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIMiNFprjILUEeXAe7wWuKTcey5ka7WHhp/LEKPH5WJHeoAoGCCqGSM49\nAwEHoUQDQgAEfQOzstUvJ1ZHuvEdNIGPfGzTJX8Fi/SnDrs3ev1Dr01SOK8bWdbk\naaaKk8RBzvJoB2DDC43WWeG9+ma7WWHn9g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::ca-empty-subject", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces an **invalid** chain due to an invalid CA cert.\n\nThe CA cert contains an empty Subject `SEQUENCE`, which is disallowed\nunder RFC 5280:\n\n> If the subject is a CA [...], then the subject field MUST be populated\n> with a non-empty distinguished name", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBdDCCARugAwIBAgIUAU+CsptakfNv9lpJPBoBXCMksuUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAAMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr8utJDhb\n2jDVkAYMB76ldB0ceYNuFZjcMZ2JL8WtUWAVGqDsaSJBhqqL43LFsBz4rg1R5Okt\nn2CYpx4k8LlrS6NXMFUwDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYD\nVR0RBA8wDYILZXhhbXBsZS5jb20wHQYDVR0OBBYEFF51JDSLCMVu3RdBhws3U94l\nJwTqMAoGCCqGSM49BAMCA0cAMEQCIEgoL+eOwzFwrbVplD6TT1JQ41/K9/mnxhT+\nYrCZX+xpAiBLYo04yYHYptB7iwEnjfW6ZZpZJHMbxDftozmenXNqow==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBlTCCATygAwIBAgIUfjhgr4y/Ig7PJHuWrLTIfmOOnvIwCgYIKoZIzj0EAwIw\nADAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFjEUMBIGA1UEAwwL\nZXhhbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATFoyRqs+OfTLC3\nIA1p2Shs+U3GBmtvarBbIoZarrNssL50bOETtcXEMAKxqzgqUKv18B99+76bCCEy\ndrhyzNhlo3wwejAdBgNVHQ4EFgQUAt0XpK4T1wjhpvN1z6Q4tzITXDEwHwYDVR0j\nBBgwFoAUXnUkNIsIxW7dF0GHCzdT3iUnBOowCwYDVR0PBAQDAgeAMBMGA1UdJQQM\nMAoGCCsGAQUFBwMBMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIBicwKzHDiOQ0MKTrAJEkIGuwxw+bzSEExTMirveLQhmAiBXcfDZ49mZ\nxUMl+e9gdKfzhniEK/2Z55tx7KXqA287gQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIA1S4rcG6iZWTonnxoDR9sUWlOxvZawCYt0/PVkA1gZtoAoGCCqGSM49\nAwEHoUQDQgAExaMkarPjn0ywtyANadkobPlNxgZrb2qwWyKGWq6zbLC+dGzhE7XF\nxDACsas4KlCr9fAfffu+mwghMna4cszYZQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::unknown-critical-extension-ee", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE cert has an extension, 1.3.6.1.4.1.55738.666.1, that no implementation\nshould recognize. As this unrecognized extension is marked as critical, a\nchain should not be built with this EE.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUDAr1o3p0zEu+ZYGNpOFZcBSMB1QwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQNmQDs0gWJmja0Muhg9AdRHqJo94MKBvPIT2lr\nS/ltOsNF+YRUeIdg+oyTFtNRO4h9eRzhxjVT/1bjbJHWlyaZo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUPC7nHWg+hjYtiIgw6Y/TG5as/igwCgYIKoZIzj0EAwIDSQAwRgIh\nAKSoyBmdW2Ne/+c7SspdJaEVCoatQEI9ivEA9Eu+iTnYAiEA4PrGnBFd7MwnQpPh\n5JDwN2YoPeq+SC7moyBXZs96rxw=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBxjCCAWygAwIBAgIUBkaib+GrWxrlzOz9RbFF2kbjjxAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABFBrjZ3HnSH1JGd70RSm5O+PA7hvYodCx2bY5h7pCdMt\nkNBuBgPcjFkvBXrllSuwK7WvFSz88cN4w6z6B1Qwf6ejgZEwgY4wHQYDVR0OBBYE\nFEgeIqSAyH/YSLGDLmgnOFBZiwBcMB8GA1UdIwQYMBaAFDwu5x1oPoY2LYiIMOmP\n0xuWrP4oMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREE\nDzANggtleGFtcGxlLmNvbTASBgsrBgEEAYOzOoUaAQEB/wQAMAoGCCqGSM49BAMC\nA0gAMEUCIQCgS11M/ATTRb/KDAmtYP8Ev1soCb1Qyh52KyONvfGN+AIgK7/kwm80\n7z9UVQZjOYLzZ9XIuKsqCEo3Utb635S4zxE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICvAXgUJ3jCUOnWxFxT0knGEDElqPR++p5V03Z6ZLvGvoAoGCCqGSM49\nAwEHoUQDQgAEUGuNncedIfUkZ3vRFKbk748DuG9ih0LHZtjmHukJ0y2Q0G4GA9yM\nWS8FeuWVK7Arta8VLPzxw3jDrPoHVDB/pw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::unknown-critical-extension-root", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root has an extension, 1.3.6.1.4.1.55738.666.1, that no implementation\nshould recognize. As this unrecognized extension is marked as critical, a\nchain should not be built with this root.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBpDCCAUmgAwIBAgIUQjP5Bb4SlyauRnYbp3Ekn/u3Tm4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAS29pQoqkL6qBON4/pkXwiX4MglqHz4i+j0yqKM\nwgNxoOCrfGJ/s3ZMq48mvUDMpUyOmWCrAdDXB55HHy/WmCqUo2swaTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUvYyDdbuNe1i+hnTHAPB9M/gHdqIwEgYLKwYBBAGDszqFGgEBAf8E\nADAKBggqhkjOPQQDAgNJADBGAiEA34Pc4b8IoWUCqqYumYYgYb4priprI6BMZK7Q\nlBYJG6oCIQCPlK9QWwQNvFLKvh187+o7d65uYDIHYOfHpICIWLIVuQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUYgAnQkgsNbwrv2T0+lV8PLGDBZgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABD+iBv+uVIhrvxRgK5/9JCb7Sdr693ABQ/jc/eeebBVQ\nbe+8+tPrh7jxbWpnJ15TbYOi+T1c6gS5NNEiauz1WqOjfDB6MB0GA1UdDgQWBBST\ny1qXOvJATfsNrw9jtxdAPSaN3zAfBgNVHSMEGDAWgBS9jIN1u417WL6GdMcA8H0z\n+Ad2ojALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAMsNDyiEBOPfyDmUI6J8\niAO4G40HaMvOA73BX7XUbrhsAiBoyZPKrk0xhT4wWlu9fvmRtC9cgkHHI9dFCtI9\n6QguIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIKdwT8CwqlSsF4Xp+iVNxNe/Gk+N1S+2lDMYDyM0sJ9XoAoGCCqGSM49\nAwEHoUQDQgAEP6IG/65UiGu/FGArn/0kJvtJ2vr3cAFD+Nz9555sFVBt77z60+uH\nuPFtamcnXlNtg6L5PVzqBLk00SJq7PVaow==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::unknown-critical-extension-unrelated-root", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nrootA (used) -> EE\n\nrootB (unused)\n```\n\nThe trusted set contains two roots: rootA is used in the chain, while rootB is not.\nrootB has an extension, 1.3.6.1.4.1.55738.666.1, that no implementation\nshould recognize. However, because the extension is in an unused root, it should not cause\nthe chain to fail, as the validator should ignore rootB entirely and not eagerly\nevaluate its extensions.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUb3WlY4G4pdVIc0mt+PMCsBAlAjUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARwkgZ5s4uvPwJFAJq1+BH5nTCON8mCkLjuabyC\nXMOPJnY82Irff0qxxcNkfelFGMj9pk3abSYobRoxpXWVANvno1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU1zbRKGtc4HfTT8385cpsevvOZAowCgYIKoZIzj0EAwIDSAAwRQIh\nAIjwqHv6x1Pi+70OgBuTMAySdbrJ/KqeEmEn4oNLWS94AiAdIUl+0JBU5wggeKTq\nXq1MCsNcVnu91oN+3c/QhwF6Nw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBojCCAUegAwIBAgIUJ0+qO/qqz/P06OMVceak0WbzwzgwCgYIKoZIzj0EAwIw\nGTEXMBUGA1UEAwwOdW5yZWxhdGVkLXJvb3QwIBcNNzAwMTAxMDAwMDAxWhgPMjk2\nOTA1MDMwMDAwMDFaMBkxFzAVBgNVBAMMDnVucmVsYXRlZC1yb290MFkwEwYHKoZI\nzj0CAQYIKoZIzj0DAQcDQgAESKLHiHHD9eR4koOWptA8PJXQsY2hVE4Z63kXyTgJ\nK4JWFHP0A1ulcC7QtOAQRpMQZETDWS82FSGWm2Y0Jg9Q6aNrMGkwDwYDVR0TAQH/\nBAUwAwEB/zALBgNVHQ8EBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYD\nVR0OBBYEFMOt7zF5rOxpFqEPszkLuKyrtB3tMBIGCysGAQQBg7M6hRoBAQH/BAAw\nCgYIKoZIzj0EAwIDSQAwRgIhAPEpy9A61RRGQtfbPxUxBJwND1fOicXZ55oh5+sU\n+aijAiEAs8RxZ8JGyGoYnrWgSvEpriVvF+lWOiSmXyy30j9A1qU=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUea9nPVoONy+iPDH1gOKfK5j/M2YwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABD71B5X01d9lSEKvHeMwRNiNnvzwqpTJfj/qHw0cVtqE\nepZKaqmJOO6P0pmIGimCg7W1J+/vFN9VLYBNRFnhElGjfDB6MB0GA1UdDgQWBBTO\nxtT1jM5wa0XQwW0ePU7ymZUYyjAfBgNVHSMEGDAWgBTXNtEoa1zgd9NPzfzlymx6\n+85kCjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgCI7Fbqc2hbsiBLQLSu5v\nSGB1g+766lHsWeTaHny2t7gCIBnfC+WLU3K1EJhB+DAZXHS52cExHAEIY7J3nOPU\nhMaT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIINnNg7Q+QH3Q5jy/PCdwryX0eO2vLH7U7o2YLCFnqcUoAoGCCqGSM49\nAwEHoUQDQgAEPvUHlfTV32VIQq8d4zBE2I2e/PCqlMl+P+ofDRxW2oR6lkpqqYk4\n7o/SmYgaKYKDtbUn7+8U31UtgE1EWeESUQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::unknown-critical-extension-unrelated-intermediate", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nroot -> intermediateA (used) -> EE\nroot -> intermediateB (unused)\n```\n\nThe untrusted intermediate set contains two intermediates: intermediateA is used in the chain,\nwhile intermediateB is not. intermediateB has an extension, 1.3.6.1.4.1.55738.666.1,\nthat no implementation should recognize. However, because the extension is in an unused\nintermediate, it should not cause the chain to fail, as the validator should ignore\nintermediateB entirely and not eagerly evaluate its extensions.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUI+tHgEh3Y5xoWfckwyhdkAGQqGswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQww89QdPIlD82GmP7k6wEvKMkhqd9WcdEwjjni\n/Hd19HV/SqzmdQMO4s3TqbbngH/WvZD1rsH3FAOwIH8bWZvIo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUpy5DZPq3fUCdTdedCyahPtQV4pEwCgYIKoZIzj0EAwIDSAAwRQIg\nZpFQdqoYnWH/T7OCDd5YhatemFAsqQnh9Wy4/28OnKMCIQC1bCfi8SdM3/T+A0os\nuPwSuVK3oo4o+9Bz7bSE/H/e5g==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaagAwIBAgIUTMYT3IMTUzYmBfbZW+SuKobh0UswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDAyMDUwNjE1ODA3MjUyNTc1MjAwMTcx\nNzUwNjY3MjUzMjYyMjUyMTYzMTMwMTAyODMxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBPokg2P+8p5llWCdzhiz9JO895P1vgLgagRK2FxlF/d/JpFa5GutD8r5Wx0QU+C7\nxSOPbSpxbKMnGaZd7iS5gBSjezB5MBIGA1UdEwEB/wQIMAYBAf8CAQAwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFKcuQ2T6\nt31AnU3XnQsmoT7UFeKRMB0GA1UdDgQWBBTMVheeDHBmvZavi6MOIgXoYBdvbTAK\nBggqhkjOPQQDAgNHADBEAiBkvPWgkpKZMa7A5ENW1HCkHUUZW5QKnQlPEHesMqWU\nCQIgVIVQC9hppr4xCxbg95CZ2KqvwhhELMzglpl2Fxh6IuI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgIUPuoxWQAojgM5DzBduVkO8K6nrvswCgYIKoZIzj0EAwIw\nITEfMB0GA1UEAwwWdW5yZWxhdGVkLWludGVybWVkaWF0ZTAgFw03MDAxMDEwMDAw\nMDFaGA8yOTY5MDUwMzAwMDAwMVowajE5MDcGA1UECwwwMjA1MDYxNTgwNzI1MjU3\nNTIwMDE3MTc1MDY2NzI1MzI2MjI1MjE2MzEzMDEwMjgzMS0wKwYDVQQDDCR4NTA5\nLWxpbWJvLWludGVybWVkaWF0ZS1wYXRobGVuLU5vbmUwWTATBgcqhkjOPQIBBggq\nhkjOPQMBBwNCAAQ1ToGmKsl9EhNcl3ETYYD5s5/WvCHmhCZqXHfJ2DIovslEj/YB\n8+P8ozw9NbHqlNWNsM1TPG16ejpuwrHJkXEio4GNMIGKMA8GA1UdEwEB/wQFMAMB\nAf8wCwYDVR0PBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQY\nMBaAFKcuQ2T6t31AnU3XnQsmoT7UFeKRMB0GA1UdDgQWBBTTCTMfOXSiKaS8uBTP\njiT7Fozx6jASBgsrBgEEAYOzOoUaAQEB/wQAMAoGCCqGSM49BAMCA0cAMEQCIHvQ\nae6SzcDiSyZk6iW8Tn0tQ90Q1K5mdu2oGNBVRqkeAiA7TI+G5zFh68NTqfiX4bTO\nzNXibIn6lg5Q+PVxnQGu1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaOgAwIBAgIUbej4z+UhGFjvG5ez1Lof2rW7TWswCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwMjA1MDYxNTgwNzI1MjU3NTIwMDE3MTc1MDY2NzI1MzI2MjI1\nMjE2MzEzMDEwMjgzMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEMMm\nRpnwnxWa38v52BH8MMESpbrK/DmvA1lNdb+801XoBwQ51gWwP4iC3HtzHLNZADiB\nyl0cAxiQy89HEyWDuqN8MHowHQYDVR0OBBYEFDtu+VLBiVNhBjZr8jushG60GoUm\nMB8GA1UdIwQYMBaAFMxWF54McGa9lq+Low4iBehgF29tMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBTTHA+YaJOX0N9iu3Q6fc/7FycLlcOgDqfT2pMCQWQSAIh\nAPN7xESW/r8Micv54wjUs978JIAkbkt73CiRt2gMSL1Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIGcB77DDyaG2xcJEnGaoMRbya7EZe7g7yEyFDJP1uOOfoAoGCCqGSM49\nAwEHoUQDQgAEEMMmRpnwnxWa38v52BH8MMESpbrK/DmvA1lNdb+801XoBwQ51gWw\nP4iC3HtzHLNZADiByl0cAxiQy89HEyWDug==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::unknown-critical-extension-intermediate", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate (pathlen:0) -> EE\n```\n\nThe intermediate has an extension, 1.3.6.1.4.1.55738.666.1, that no implementation\nshould recognize. As this unrecognized extension is marked as critical, a\nchain should not be built with this intermediate.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUEvqtFs/JN4rvawTiiyr3T3cibgwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAS7UiVInAVr3VgSn37AQrawkKkeKIGYO703C6DH\nCAsXXbwJ5QDL6hdHuDuvNcb8xcTDZjRR9gD/MWpL9w9qEWawo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUE+oLQuNK8nBMaWS+OYDX8VGrAmcwCgYIKoZIzj0EAwIDRwAwRAIg\nR4dqUy1paoJGal6wPQxkE+s+EO80W9xuWAmqn6o/E7sCIHahuJUoOT4azhh1/GZH\n89296qrGYSB+vKvp5LU9ofdO\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICFzCCAbygAwIBAgIUeZvNIkxSiC2vGyT3+Er4fkl+yokwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDAxMDgzNTIwOTgzNjIzMzUwMDczNDEw\nNTA1OTA4MzA2MTQwNjY0MTg0MTU3MjYwOTIxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBBzZCmB0/1bQD5k9sct1CG/n3ZAC8GhEDgsBiqCqIgm6hdu66MOknSswQlWPglqo\nKZMMfLB7UblzwoGfn7JL1xOjgZAwgY0wEgYDVR0TAQH/BAgwBgEB/wIBADALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUE+oL\nQuNK8nBMaWS+OYDX8VGrAmcwHQYDVR0OBBYEFJXa+goWyiVdQ8+27OXmaoRCWNWo\nMBIGCysGAQQBg7M6hRoBAQH/BAAwCgYIKoZIzj0EAwIDSQAwRgIhAN5VqnCuT+0c\nUcP/P9711CdBroG3G7VL4c14J1OJy7XHAiEA39lJKK3wr2yc0OOhPs0WfhJaIqX7\nUMbChFFOK3gn7Vo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaOgAwIBAgIUJQge5lm4CpuXcYSwf1SMU3M08JcwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwMTA4MzUyMDk4MzYyMzM1MDA3MzQxMDUwNTkwODMwNjE0MDY2\nNDE4NDE1NzI2MDkyMSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUdni\nuvaaBiDqpiVi14Uor/7R5DCLAf1WhX6rW/YkW03HHZnTarq8+nIV+pKLrdppQHrX\nDe2A8mddDCaZ4i8IqaN8MHowHQYDVR0OBBYEFFAy/rPDm2qjd2KY21DrFRu5agmg\nMB8GA1UdIwQYMBaAFJXa+goWyiVdQ8+27OXmaoRCWNWoMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAlY1ryPpumjRXd1S+aHuwtlw9Qcws6lhkbQHaFYwy9ocC\nIQDbAf89lQ0dGs7zyB/XZAQE/OfO8FfzdoQvHlAyg8LzDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIE7G4hhTOAk1O2D2u9i3g5cgauTUXUHDthgENdotmX+DoAoGCCqGSM49\nAwEHoUQDQgAEUdniuvaaBiDqpiVi14Uor/7R5DCLAf1WhX6rW/YkW03HHZnTarq8\n+nIV+pKLrdppQHrXDe2A8mddDCaZ4i8IqQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::chain-untrusted-root", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following chain:\n\n```\nroot (untrusted) -> intermediate -> EE\n```\n\nThe root is not in the trusted set, thus no chain should be built.\nVerification can't be achieved without trusted certificates so we add an\nunrelated root CA to create a more realistic scenario.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBojCCAUmgAwIBAgIUaUiPsFzJgnZ/J9E+040P9/LcSOgwCgYIKoZIzj0EAwIw\nJDEiMCAGA1UEAwwZeDUwOS1saW1iby11bnJlbGF0ZWQtcm9vdDAgFw03MDAxMDEw\nMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowJDEiMCAGA1UEAwwZeDUwOS1saW1iby11\nbnJlbGF0ZWQtcm9vdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJ+b0MmNu/i0\n44pEcEPrQW2kQcbEt4/L/XKnoNMv8RfteRXYl7SIFFRh+3cq8uL4Rjm2U7yuufjb\neuf7uiZTFLejVzBVMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1Ud\nEQQPMA2CC2V4YW1wbGUuY29tMB0GA1UdDgQWBBRyYoQak3pKTPdpUkDLyUo5qUx7\nCDAKBggqhkjOPQQDAgNHADBEAiBmQEpP0bPn9lKTouhV9Yq3FQmOW5Hj+aBj2+Ol\nl1og7wIgTUfb+6BiFlZAr4aY0hmmg+wseYDcpQwvSztrJkveQ1k=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUdiAAABqM3Ldd6osyhI2R/g7RdKowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARzKkqIBozccdHMzY6lo3OH6CRjm42Mt9pFNHS8\ndQMGDhRiVlwIsGPT/Nc+vG0XFZiMML4v+OAQ8zE3A/t+U1olo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUhyO7vdAQrTt95kS08w6l6fBVfa0wCgYIKoZIzj0EAwIDSAAwRQIg\nOaO3lUNnR/ZfLUQ4Yamm8jZIx/pgXcc3xAc9Ks+rdecCIQCfnhbDMkIWjGoaZEXy\n8X+Bq/JiT7nkQV9Hmc35WHPQyQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaagAwIBAgIUcGiHt6OMl7EMdWUmuGJYhupYz/4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBnMTkwNwYDVQQLDDA2NzQzNzQ1MzQ4Mzg4NTczNjk5MDg1\nNzUwMDQ1MDIyNTE0NDEwOTc1ODA1NzM4NjYxKjAoBgNVBAMMIXg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IA\nBF3xRAYOAJamNO3UWGy7SB8doHm0fkyCJLrXUI4sIN/ju5NVsVRLfXU3VWI7PhMs\nnrz79nkRS/0kC4d25IhVIC6jezB5MBIGA1UdEwEB/wQIMAYBAf8CAQAwCwYDVR0P\nBAQDAgIEMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB8GA1UdIwQYMBaAFIcju73Q\nEK07feZEtPMOpenwVX2tMB0GA1UdDgQWBBSE7bJbIBAacScP+u37B2JYN2wVUjAK\nBggqhkjOPQQDAgNHADBEAiBl/2cmF7vLDmvX7jBB7vICaHRNIuCenurR7lt3djRm\nAgIgUYcWyqWHnU8HBMAm3rCl1hdkuiR1xxjAd2iKn5l9bsM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaOgAwIBAgIURfTHFUkFEpGR5qfTaobk3X8SaVkwCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwNjc0Mzc0NTM0ODM4ODU3MzY5OTA4NTc1MDA0NTAyMjUxNDQx\nMDk3NTgwNTczODY2MSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQjTq\nB5KCm3o/WFA6TfQhGS82iDqkCxUPUiS2GEwvNA8QFSKveZCfM/lZtjIkTb0jdsGI\ntdpqfD3QcGG9+EznBqN8MHowHQYDVR0OBBYEFG9MhYLA+5FjJlKZKnBF0PLRQZB2\nMB8GA1UdIwQYMBaAFITtslsgEBpxJw/67fsHYlg3bBVSMAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA+Dn++cEuZT7BFSKdMTqO7+IK6wp1cxBcb7uow6qW5MwC\nIQDtCQxelmMu1fENC9FMymjrAC0nnKZcYsFmbODokNStZA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDIXh1Kxz0ijggJe4dorhO7SY+nTi88c/HleUuUJC2ExoAoGCCqGSM49\nAwEHoUQDQgAEQjTqB5KCm3o/WFA6TfQhGS82iDqkCxUPUiS2GEwvNA8QFSKveZCf\nM/lZtjIkTb0jdsGItdpqfD3QcGG9+EznBg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::intermediate-ca-without-ca-bit", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate -> EE\n```\n\nThe intermediate CA does not have the cA bit set in BasicConstraints, thus\nno valid chain to the leaf exists per RFC 5280 4.2.1.9:\n\n> If the basic constraints extension is not present in a version 3\n> certificate, or the extension is present but the cA boolean\n> is not asserted, then the certified public key MUST NOT be used to\n> verify certificate signatures.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUBFgfQBRdi7Op5haNc5ShlUUuUP4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATG0IKSYLo+OkiKShd/yaoOy1HB5qO/jWet5coX\nzp2oKc3Iu9KUWGP8OUt1XHk+vDKNxvdbaMQ1pxATtIALE7Vmo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUjXVgr6hmKBUfU4cQtA9NjwQ3s1cwCgYIKoZIzj0EAwIDSAAwRQIh\nAKJxfoWK2m9G7zBZvAij8zUuJf2m1vWPjFJX1aMoz303AiBSXKhRW/nu/URwGzoM\neuQzjHKBdvrpdJ8xEqFVafJ/kQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/DCCAaKgAwIBAgIUeFYnLw01ANJksJ4gd3lGFzvfIwUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBpMTgwNgYDVQQLDC8yNDgwMTE1MDk0Njc3MTY5NzQ1Mzk5\nNDYwNTg3ODc3OTk0NTU0MDE3MTc0NzU4MjEtMCsGA1UEAwwkeDUwOS1saW1iby1p\nbnRlcm1lZGlhdGUtcGF0aGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAPPXdJTeILA7CdzXzp4gPEJpCIjjlua39Ka2yFHgmUfFhDxkzHoXI2ODcagN\nMVkrA7afaZIE5byqrg8LZDnXraN1MHMwDAYDVR0TAQH/BAIwADALBgNVHQ8EBAMC\nAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUjXVgr6hmKBUf\nU4cQtA9NjwQ3s1cwHQYDVR0OBBYEFH5g3iAvdCDZgnD/ySTocRhDQqmFMAoGCCqG\nSM49BAMCA0gAMEUCIQDP3vdo60gP/63KibMstATnPdk9rp1zVGDmTxJytNlYqQIg\nc1jZfX6rYFqTBfvY+Gug+7KjAamt5Kj8v29TdEdsLb8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaWgAwIBAgIUYCPOskGuJfFb/bVXSfEfyxwQuLIwCgYIKoZIzj0EAwIw\naTE4MDYGA1UECwwvMjQ4MDExNTA5NDY3NzE2OTc0NTM5OTQ2MDU4Nzg3Nzk5NDU1\nNDAxNzE3NDc1ODIxLTArBgNVBAMMJHg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tTm9uZTAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFjEU\nMBIGA1UEAwwLZXhhbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAR8\nndxArHZDlflzNlMHKhmXDCQMKlkK/8QnxZDVLAkIxlM0f+ryy5qc1oGSm/zqRM+P\njOWGv8SijqFxOYcgjwZlo3wwejAdBgNVHQ4EFgQUQc9CtwqFxqQPxTvsTvf/0Goo\nWFQwHwYDVR0jBBgwFoAUfmDeIC90INmCcP/JJOhxGENCqYUwCwYDVR0PBAQDAgeA\nMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMAoG\nCCqGSM49BAMCA0gAMEUCIQCw+hIqm95HycRdSbLcIRuLCnyaammv7/ggHFIidjyX\n0AIgPQhZ29GEjHxHJlerDRf3qpkAdok09Sw7z2YtSvzCJ4c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIBhLvIg8sZXm8LinmtRdCBrMMnZm5RnxfOvBSPVDoWjVoAoGCCqGSM49\nAwEHoUQDQgAEfJ3cQKx2Q5X5czZTByoZlwwkDCpZCv/EJ8WQ1SwJCMZTNH/q8sua\nnNaBkpv86kTPj4zlhr/Eoo6hcTmHII8GZQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::intermediate-ca-missing-basic-constraints", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> EE\n```\n\nThe intermediate CA is missing the BasicConstraints extension, which is disallowed\nunder RFC 5280 4.2.1.9:\n\n> Conforming CAs MUST include this extension in all CA certificates\n> that contain public keys used to validate digital signatures on\n> certificates and MUST mark the extension as critical in such\n> certificates.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUJrLdlztTc99J8PIQbdQhCXpbNocwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAT64/RjqnHnkQguPuV+fDjcZKgb7bJuRDY6omrr\nQtu6rm0f/wzcSRVgziGR1NrLBlMFaRECCGI7aZFbuy4aXt+uo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU4bx+nsO40rD9VEPK6lTX7h9HF/YwCgYIKoZIzj0EAwIDRwAwRAIg\nRyOG88VtVvMmzTcXWyi+ZA+6l6u4SyCK0Yi3FPemSAECIG7bXPKBApUdeNnyB0GW\niwm3eAPtiZ9kbrPLp7YNk2aA\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaagAwIBAgIUWkf7Xe9sj6wrFvK/OpnEJWNRw6AwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwMjIwOTMwNDg1MjEzMzMwNDM5NDc0NzA2NDkwOTA3MTY1NTgz\nNDYxNzU4NzQ0MTk5MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOJAu6joK2RjRfO2s8jTIRzdTH7W7jwpwQLwGi1tZpfvGz00jVGPZ7K+7sr5Zbbnp\nQc6OLZ/gA6oUzK3Ip4ncl6N8MHowHQYDVR0OBBYEFPang7zdJHGv1XjgzP5cYjNP\n3Je4MB8GA1UdIwQYMBaAFH8hC80XzWvYJy8utji4DBFE50szMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNHADBEAiB4T02JcTZY8ttVoowPp3/GZ6VA+mVVkTtELthP7/dN\n0AIgW+e9Y3Vu9+CT2X1BqmJc0fWgYwVdHo5AWmqY/KK4P/I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIKkjES7RAm37Du5ELlawaKQi6ALxAZ/1MR9Zm+lKtYedoAoGCCqGSM49\nAwEHoUQDQgAEOJAu6joK2RjRfO2s8jTIRzdTH7W7jwpwQLwGi1tZpfvGz00jVGPZ\n7K+7sr5ZbbnpQc6OLZ/gA6oUzK3Ip4nclw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::root-missing-basic-constraints", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root CA is missing the BasicConstraints extension, which is disallowed\nunder RFC 5280 4.2.1.9:\n\n> Conforming CAs MUST include this extension in all CA certificates\n> that contain public keys used to validate digital signatures on\n> certificates and MUST mark the extension as critical in such\n> certificates.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBfTCCASSgAwIBAgIUaLLKrDV0u9IXoGUdM0tLCIKfMNEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASSinCTQE2Hk/xAnjjq8V7eIu91awqqIPn0SwUd\nnXs0jsoICbfOUpXr5yLJvbmwvEnmDsoyJDmogDiOHahJheX6o0YwRDALBgNVHQ8E\nBAMCAQYwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYDVR0OBBYEFC1LiIHK9Kk/\n8KngXtSREygIacMrMAoGCCqGSM49BAMCA0cAMEQCIG0lGcRm36zfWQyK5Nv67K/U\nNXO8BkG2Y5RSKMGbkvhDAiADJNFHXsO7F+uf9bELb6UZAJdo1Wh4deIArHyx87Bb\nCw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUcVjrdNK/rtSlq8QNRNMmU10rOKQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABGeythfqD/WtY5hZzSMr/BBMrOmsjduJc2J0f4s/3pxH\n3B3o1nZJBX4Gy3nGZjd40CG3Ih+TVQmnQDTWZmT6M7yjfDB6MB0GA1UdDgQWBBTV\nX+lXzqoF749IymK7pyBHteOUuDAfBgNVHSMEGDAWgBQtS4iByvSpP/Cp4F7UkRMo\nCGnDKzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAKpKNiXMZ73hX8Dtk664\nh3uSROUSrId9IHz94Qd2HwVkAiBHt98J2wh5Kw8SLQBjy+N250qImQJjTNevgV9f\n3GR3Ig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIAY5VL++FkG4+SE/4sFwf/KWXr+EWEHCZ4cqajk8dZ5GoAoGCCqGSM49\nAwEHoUQDQgAEZ7K2F+oP9a1jmFnNIyv8EEys6ayN24lzYnR/iz/enEfcHejWdkkF\nfgbLecZmN3jQIbciH5NVCadANNZmZPozvA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::root-non-critical-basic-constraints", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root CA has a non-critical BasicConstraints extension, which is disallowed\nunder RFC 5280 4.2.1.9:\n\n> Conforming CAs MUST include this extension in all CA certificates\n> that contain public keys used to validate digital signatures on\n> certificates and MUST mark the extension as critical in such\n> certificates.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjDCCATKgAwIBAgIUbtU6EB2s9uhNjN/dwmzfiEYP0eEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQhwM0bf0zOVTJxNZjWGFAcFp3aGwj7XvIgNenn\n1J0+AJHMxHDv38q1BDZ72KNHDtzKrzOOx9Av+CDw+tWF31xBo1QwUjAMBgNVHRME\nBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAdBgNV\nHQ4EFgQUU09nSUoo4gHEze4fXNcARud08nMwCgYIKoZIzj0EAwIDSAAwRQIhAIMA\nNm/4aGAsWMXJJBqNtQr4p7uEITu9rlW0laqeUGuvAiAbLh0lkHtB7b2R6PEjGJKu\nMArv14tKD7NQFhjTGZbLVA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVagAwIBAgIUC77tT+SxFmG6K00PrMQsbyvLtlIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABNR5ASY8CRQHP6fCdMhQX49Bclkz4YG/KkMR4VTocjPE\nh7lLo82wEnOGR6G8ep/Q/NR1/VKCOeLZM0GltJ8MRGejfDB6MB0GA1UdDgQWBBQb\nde5AXbxd8TpT1LdSMTtUoXa3hTAfBgNVHSMEGDAWgBRTT2dJSijiAcTN7h9c1wBG\n53TyczALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAK0BYKwPPcm3kewJkZVo\nZaGYhBSeKxC8ewLlQefZjth5AiEA3A3PhTk4MAN/YJFRwQ0V6PIHTrWBNyrKbD7y\nEX1ip8Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIJJv1dlE3Dwjglg6xI8f2JvRvjnZb+9/wVbwD1CjIu4foAoGCCqGSM49\nAwEHoUQDQgAE1HkBJjwJFAc/p8J0yFBfj0FyWTPhgb8qQxHhVOhyM8SHuUujzbAS\nc4ZHobx6n9D81HX9UoI54tkzQaW0nwxEZw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::root-inconsistent-ca-extensions", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root CA has `BasicConstraints.cA=TRUE` and `KeyUsage.keyCertSign=FALSE`.\nAccording to RFC 5280, these two fields are related in the\nfollowing ways:\n\n> If the keyCertSign bit is asserted, then the cA bit in the basic\n> constraints extension MUST also be asserted. (Section 4.2.1.3)\n\nand\n\n> If the cA boolean is not asserted, then the keyCertSign bit in the\n> key usage extension MUST NOT be asserted. (Section 4.2.1.9)\n\nAlthough the profile does not directly state that keyCertSign must be asserted\nwhen cA is asserted, this configuration is inconsistent and clients should\nreject it.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATSgAwIBAgIUYfiK3lzCiEg/lRNDz7OCBGFWlHUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARDw/syEnVPHzjrFaC4fvXbRipnNB9WzPBqdjI0\n/RdNAjT2UmXsioR/BHVNYF9z3CJvwqUgypPjgGjuCSiU7h/go1YwVDAPBgNVHRMB\nAf8EBTADAQH/MAoGA1UdDwQDAwEAMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB0G\nA1UdDgQWBBR1vxR3JCVdZWv8RWsKd5MDzYD5JjAKBggqhkjOPQQDAgNIADBFAiBX\nc1R0PESDRMv24GGBriUHA3CmZs0d7SGTEiZrGPKEuwIhAM/HbUfUIH5UPJkwjgVl\nYt9Y8ohCLg3UA0ocHqEA2pC0\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVagAwIBAgIUGamSkGrOXAADqnBAtI06GwmQDcEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABPqPeKRzBYSPWw5wyJ+NcLYJq/SCFL7Cw5Yc07Zxvv2Y\ngG/jstGP8GBDnPuciIZxhxH1rgnG3vMTXjXTjKKobFCjfDB6MB0GA1UdDgQWBBQr\nOof0oz0nyPcS2uxRWZu3Q483BTAfBgNVHSMEGDAWgBR1vxR3JCVdZWv8RWsKd5MD\nzYD5JjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAIjNA8HmFpwOH2O+/DOn\n1LxoPTWha98lY8vAEnHLb/r3AiEAmA83g/yVtDef8D2ZoOU+Uz2XQQSkh4nv6P4u\nL0zhEI4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIPGFDQn1a7P9FRzCZahBNDbp3+S7fLGkaWW+UuHoBYCJoAoGCCqGSM49\nAwEHoUQDQgAE+o94pHMFhI9bDnDIn41wtgmr9IIUvsLDlhzTtnG+/ZiAb+Oy0Y/w\nYEOc+5yIhnGHEfWuCcbe8xNeNdOMoqhsUA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::ica-ku-keycertsign", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA -> EE\n```\n\nThe intermediate CA includes BasicConstraints with pathLenConstraint=0 and\nKeyUsage.keyCertSign=FALSE, which is disallowed under RFC 5280 4.2.1.9:\n\n> CAs MUST NOT include the pathLenConstraint field unless the cA\n> boolean is asserted and the key usage extension asserts the\n> keyCertSign bit.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUe5mbkdYBgowcA+8s20S/lRWvxxowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQuj72MggT4E4VX87cJW4X+NACNzNb1Jz0Y7Ohm\njzhqm8NoJW7/rDotpR7LVEtrUDWUPxGDO+DMMwloq8IH8x/ko1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUiueEiaihgSq8WAnBpdJgh3qVp8MwCgYIKoZIzj0EAwIDSAAwRQIg\nLf2w3lXFJqFwjFTKSG50qWeexT58+D8s5JLgS8NbsfsCIQDhnD2JKdhjEacExTmm\nmX7KXkHkd4CVO9h+DUSnKBJNjg==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaOgAwIBAgIUDeKOTGNplFzQrg8UCzF+XcV8Mi8wCgYIKoZIzj0EAwIw\nZzE5MDcGA1UECwwwNzA1NjMxNDMwODU2NDMyNzA0NDA0MzMxMTg1NjI3MzE2MDA5\nMTU0ODkyNTE1MDk4MSowKAYDVQQDDCF4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLTAwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYxFDAS\nBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOnw+\n4hQDfQFPis86BVt29z9d6bek4XxoqWXKYL99brn5v3KVL0opCUawKEcjoCeDSc2Q\n9CAUZWmidhbZfJFhyKN8MHowHQYDVR0OBBYEFJSqqfHytyHyx4Umw1zbxFrS/KOo\nMB8GA1UdIwQYMBaAFNMey2KUteHkdZluM0nJjtEDB1E4MAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAn0PhMjVIpU9PDItmLkmZQ0rXX0PT6YViPwa3GdGQb/cC\nIGEaAl+J5Uld6WSzeC+oC3QcVqjF4Tw2UYFUCwoUxfbV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIMlzxsOrkzhh5zJIMkgjfy/PHXEq8OvD1JduQTeINRTJoAoGCCqGSM49\nAwEHoUQDQgAEOnw+4hQDfQFPis86BVt29z9d6bek4XxoqWXKYL99brn5v3KVL0op\nCUawKEcjoCeDSc2Q9CAUZWmidhbZfJFhyA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::leaf-ku-keycertsign", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe leaf has a BasicConstraints extension with cA=FALSE and a KeyUsage\nextension with keyCertSign=TRUE. This is disallowed under\nRFC 5280 4.2.1.9:\n\n> The cA boolean indicates whether the certified public key may be used\n> to verify certificate signatures. If the cA boolean is not asserted,\n> then the keyCertSign bit in the key usage extension MUST NOT be\n> asserted.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUMgxvyoQ4/rOwRjQ0NA6b2JVHqGUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARzfXly90zk0Od7CeehsAOx1wGPohLKAa4kPw6l\n4nK7QGXg4pF+SHdiymeRcjDzIIuLTtn1Rv55yJ6aF/IEKRpao1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUOtaf5btlAz59g7gNSWXKWM9G/24wCgYIKoZIzj0EAwIDSQAwRgIh\nAKm/rh7lQ3RNdIboN5eK/iMyDzsJKw9fV92rGQ7S/hO0AiEAoYxKT5MAIWvEfuZJ\nEuh5jovUOLvT6CrLVAhSQ1aPusI=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBvzCCAWagAwIBAgIUcpDG5q/NDtM/Rm5OY+iPJZxwiOYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABGlcu0cQHdMww1apIJSccLaaHfdHiVLiUSGvBJwp0KHf\n4Px0/NWerEWkSuFngG5ISTKwzWgHo+QucoZD7x7mNeajgYswgYgwHQYDVR0OBBYE\nFA/79PBr+qxDiEg86IMfTNx0lqnOMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU\nOtaf5btlAz59g7gNSWXKWM9G/24wCwYDVR0PBAQDAgKEMBMGA1UdJQQMMAoGCCsG\nAQUFBwMBMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIBUY/z4zU2oH5Ipu5Th0nsolcqvBRc4H3736l+3tDwT2AiBoMc7Xpr0/Kg2O6M+I\nmZci90DIwf6y5sUS9KwcOnaHIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIOpCOBA24qCdzjqCMIaiJP2tKpRCwpo7VQaPiVJDKgb3oAoGCCqGSM49\nAwEHoUQDQgAEaVy7RxAd0zDDVqkglJxwtpod90eJUuJRIa8EnCnQod/g/HT81Z6s\nRaRK4WeAbkhJMrDNaAej5C5yhkPvHuY15g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::ee-aia", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a **valid** chain with an EE cert.\n\nThis EE cert contains an Authority Information Access extension with a CA Issuer Access\nDescription.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUFOCNx78Stls71sIyfPlLkG59pdEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAShiZxdxkXZtxtpet2EDfNK1V0CDohbynqj2dho\nDsA3OyOxsdk4ZtRUR2ZWgRsRMjiwMiVhjDsRM2Vd3buuzXCYo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUa85AD3RZwMbo2bgRAxPjA6cAo3IwCgYIKoZIzj0EAwIDSAAwRQIh\nALocVashF9jKSstl6A9+68QdtxFCPrzUKw62f6AAbl9VAiATAwB52hCbrcXwU0Qs\ngwYaFH3G+Lr3/zkB1k1WqeVtjA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB2zCCAYGgAwIBAgIURTrX7e2Mnqgc8QbM3roiScXEnQQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABEbhunGsvB8gORIZoRznobPaDC2nm4pDtCgIgJhHMJhJ\nR9sQFZQ6sRDOEbTlOvHJ5S+6Vp2+Nd6m0ldm8OchpJejgaYwgaMwHQYDVR0OBBYE\nFErS1aXNNBJfkVnLIWPmSgseXRNTMB8GA1UdIwQYMBaAFGvOQA90WcDG6Nm4EQMT\n4wOnAKNyMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREE\nDzANggtleGFtcGxlLmNvbTAnBggrBgEFBQcBAQQbMBkwFwYIKwYBBQUHMAKCC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBj+rEA1QIGk2o5U210SAk0088mr\n52mfdF8afazpV51FAiEA9emSpzY4xwBKLYcR4KgegOcB3z8qq80W2BJuurV3aBo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIKnNpOm4W0hGUezmI6JMQ1ZjBc3CnKv+t8hhoANOOtSroAoGCCqGSM49\nAwEHoUQDQgAERuG6cay8HyA5EhmhHOehs9oMLaebikO0KAiAmEcwmElH2xAVlDqx\nEM4RtOU68cnlL7pWnb413qbSV2bw5yGklw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::ee-critical-aia-invalid", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a **invalid** chain with an EE cert.\n\nThis EE cert contains an Authority Information Access extension with a CA Issuer Access\nDescription. The AIA extension is marked as critical, which is disallowed\nunder RFC 5280:\n\n> Conforming CAs MUST mark this extension as non-critical.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUZG1RWCkrR8uZNW7zJT4IdFAwBZgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATOJeuoI4gbe1lOWsOcaKjkuBi8sHRm3URszEjo\nPCU4F6ET80lajZ1LyxNCRy7L8dnYC89WBU/v4JDD0IVGwYvCo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU3FlF6ZW97UTm6DnyKA549HAWBWMwCgYIKoZIzj0EAwIDSQAwRgIh\nAIbj5OvgbQlnM5wIHrtdiUlnXp6aoG/nvWFecQs8ZTkQAiEAqjFZJ6SUENANzJQz\nqVJmtL/4OBNIW9k//1j64YD9QjU=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB3jCCAYSgAwIBAgIUKg19C/5lhRod2o6h/yi6ZXR/necwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABI9Ib08ciXhl9EILVg0z/zp/+7AUIOTK3O8eMKG3tqYq\nv1rJ+nO2Lmh9ubepWfSfSrNeOhU5rMtqkMGg+l3yk8ejgakwgaYwHQYDVR0OBBYE\nFLhlRd6jjyLJ50ZTMbBIjkmRSkz5MB8GA1UdIwQYMBaAFNxZRemVve1E5ug58igO\nePRwFgVjMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREE\nDzANggtleGFtcGxlLmNvbTAqBggrBgEFBQcBAQEB/wQbMBkwFwYIKwYBBQUHMAKC\nC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCmaQ3FVhaQ6E/HLo+NIVuy\n/G76zbDNkUE8II5S2oUfDwIgFOA+9LXvTXCkhh20wdUlXgIS2Wm2/AD2OwibsUq6\nuR8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIFPLkbvFVKDuM/POOYdzZmPt9WrOUnRZDVr6wTs9750+oAoGCCqGSM49\nAwEHoUQDQgAEj0hvTxyJeGX0QgtWDTP/On/7sBQg5Mrc7x4wobe2piq/Wsn6c7Yu\naH25t6lZ9J9Ks146FTmsy2qQwaD6XfKTxw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::duplicate-extensions", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThis chain is invalid solely because of the EE cert's construction:\nit contains multiple X.509v3 extensions with the same OID, which\nis prohibited under RFC 5280 4.2.\n\n> A certificate MUST NOT include more than one instance of a particular\n> extension.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIURWpDI5vbNvsDnLGBdgGbA+/uvH4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQUJAJhR4ppDfC8HAGqB9mlTGeGpkQbJhG6doym\nyvHUe/SnjVVXRkCxmRoiU17UPVgI7jXqJqpyGv1SrJPO7o8ko1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUzbUAYjrzRRl+596l3mQa+lcJGU4wCgYIKoZIzj0EAwIDSQAwRgIh\nAPGI2pQpKVvk7INk0NBDeE5ekD8+awybYpDIOd+S+HNJAiEAhiJRAK7d93TGn3yc\n9sBZ8Wuco8IdvwOSU5f9Ykc5l5Q=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIByTCCAXCgAwIBAgIUI9SoixepibgbEyLSmODoO/3/1mUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABCKGhrt2DcVSylsqGj1SIJMvYCdXmZF7kkysSeb/4P6V\nFhNUlr1609bspso0AkhfiaOBrFfQ26LCuh5RnWtL3cujgZUwgZIwHQYDVR0OBBYE\nFEmFPCwDxiwxrMzkuBlnXg06IGipMB8GA1UdIwQYMBaAFM21AGI680UZfufepd5k\nGvpXCRlOMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREE\nDzANggtleGFtcGxlLmNvbTAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAbnSIrNTH4Kw6uwRnCzm8qXBhSYjk90wFS9yNHOLt1UwIgKMMI\nXeiia7137L0qlQOG7o7fbo89tiSkFY0hrwLm3eY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILdxv4M8k2AGtFN1eEHGSYKXLDf3jSnJs55jb8q7T+OuoAoGCCqGSM49\nAwEHoUQDQgAEIoaGu3YNxVLKWyoaPVIgky9gJ1eZkXuSTKxJ5v/g/pUWE1SWvXrT\n1uymyjQCSF+Jo4GsV9DbosK6HlGda0vdyw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::no-keyusage", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> EE\n```\n\nThe EE lacks a Key Usage extension, which is not required for\nend-entity certificates under the RFC 5280 profile.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUcGenEwdIb7iTVQ5Hqp6BPCU/rMwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATu8d+URreGsWbKbqqHnsG83ME0upXp1DQfl3EM\nwG7Pg1uEyL5iIuzgBXFUELPLqJkpOxb46MTuLeEWDLiOOwqNo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUytSWjYFCPJQCEh/ZZufXEKmOSgMwCgYIKoZIzj0EAwIDSQAwRgIh\nAMGZnGMRh0m0SS20QBuHiBxpVqWy+izOzUuNFzCBu6qZAiEAgqhljmhxjRPlT3JP\nNux/NXICk8V8R84TzwOj4e5UyLk=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBojCCAUmgAwIBAgIUF2EgXTqY2RIq5e5V7ebtiufsIFAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABPkL/Q2luJifjkdYjb/qVUv0bZhSzUjyFf78J3Le2ait\nynOFBXhZR2GYeoi059QsbQZ9GkQzA2CehSWBQBmKR7+jbzBtMB0GA1UdDgQWBBTz\ngMQEvWLTDNd8I2AVgLQ5C1iR+DAfBgNVHSMEGDAWgBTK1JaNgUI8lAISH9lm59cQ\nqY5KAzATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNv\nbTAKBggqhkjOPQQDAgNHADBEAiAaKDDVC8QkTLPSp6JhfxixX2gPWKiS7zEZ10oD\nx19FdQIgQbtsRT/VmBHxB7hZojTvGUgbaYROqTtxMR0uTptmPWg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIEYZKNZbLH9F9/5brOEHAKlOLEvwD8xcLc46g0/Tiqs4oAoGCCqGSM49\nAwEHoUQDQgAE+Qv9DaW4mJ+OR1iNv+pVS/RtmFLNSPIV/vwnct7ZqK3Kc4UFeFlH\nYZh6iLTn1CxtBn0aRDMDYJ6FJYFAGYpHvw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::no-basicconstraints", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> EE\n```\n\nThe EE lacks a Basic Constraints extension, which is not required for\nend-entity certificates under the RFC 5280 profile.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUI0A81a4Viw3JZRY+VNG3TTveBi4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAS4fCkM2n1NnkJQXLIchQY0a1VUgAp6BXxccq1M\nkNsVFvBOs3pKbHoWL260P2HXho+M0QdgdSlljt6NeDD1LMZIo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUoATMQMnVbVAh2ZqOBrvatMm1ZEAwCgYIKoZIzj0EAwIDSAAwRQIh\nAIDjd+8VmRlrnMxGUD2wnLyZGscq0OLes8BnjK8dJaDZAiAgsIBt4PRpZOZqpiZX\neKSmbRQRLCv6m6D05jF390VMow==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUAopohLr98Oryn5XM0DV6tliPYpgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABD0sQBpPZb426tExXjU6By3xb9gT62EF3DoAIy/JsP2h\nF/8vOK9GgUlUjsnWn9pfvtt5KGU2TMipDc7N2tl7HdqjfDB6MB0GA1UdDgQWBBSA\ntfHPBJD/EDOEfBZKx+YwcOnsWTAfBgNVHSMEGDAWgBSgBMxAydVtUCHZmo4Gu9q0\nybVkQDALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgE7LYGZ2pbouHQojKwNC+\nm6N0EsFXscS8thgHixPoFt4CIGDFq5mMWktresEvE6q/CNhtLQQGD9F5b8dUDXbu\nDelh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIEUmrXzqdNOOhgZmXTkXCyEKUciLlNzXnApl8lOaxoIooAoGCCqGSM49\nAwEHoUQDQgAEPSxAGk9lvjbq0TFeNToHLfFv2BPrYQXcOgAjL8mw/aEX/y84r0aB\nSVSOydaf2l++23koZTZMyKkNzs3a2Xsd2g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::mismatching-signature-algorithm", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Verifies against a saved copy of `cryptography.io`'s chain with\nthe root certificate modified to have mismatched `signatureAlgorithm`\nfields, which is prohibited under RFC 5280 4.2.\n\n> A certificate MUST NOT include more than one instance of a particular\n> extension.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw\nTzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh\ncmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4\nWhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu\nZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY\nMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc\nh77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+\n0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U\nA5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW\nT8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH\nB5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC\nB5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv\nKBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn\nOlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn\njh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw\nqHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI\nrU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq\nhkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL\nubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ\n3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK\nNFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5\nORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur\nTkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC\njNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc\noyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq\n4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA\nmRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d\nemyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIFFjCCAv6gAwIBAgIRAJErCErPDBinU/bWLiWnX1owDQYJKoZIhvcNAQELBQAw\nTzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh\ncmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMjAwOTA0MDAwMDAw\nWhcNMjUwOTE1MTYwMDAwWjAyMQswCQYDVQQGEwJVUzEWMBQGA1UEChMNTGV0J3Mg\nRW5jcnlwdDELMAkGA1UEAxMCUjMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\nAoIBAQC7AhUozPaglNMPEuyNVZLD+ILxmaZ6QoinXSaqtSu5xUyxr45r+XXIo9cP\nR5QUVTVXjJ6oojkZ9YI8QqlObvU7wy7bjcCwXPNZOOftz2nwWgsbvsCUJCWH+jdx\nsxPnHKzhm+/b5DtFUkWWqcFTzjTIUu61ru2P3mBw4qVUq7ZtDpelQDRrK9O8Zutm\nNHz6a4uPVymZ+DAXXbpyb/uBxa3Shlg9F8fnCbvxK/eG3MHacV3URuPMrSXBiLxg\nZ3Vms/EY96Jc5lP/Ooi2R6X/ExjqmAl3P51T+c8B5fWmcBcUr2Ok/5mzk53cU6cG\n/kiFHaFpriV1uxPMUgP17VGhi9sVAgMBAAGjggEIMIIBBDAOBgNVHQ8BAf8EBAMC\nAYYwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1UdEwEB/wQIMAYB\nAf8CAQAwHQYDVR0OBBYEFBQusxe3WFbLrlAJQOYfr52LFMLGMB8GA1UdIwQYMBaA\nFHm0WeZ7tuXkAXOACIjIGlj26ZtuMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEFBQcw\nAoYWaHR0cDovL3gxLmkubGVuY3Iub3JnLzAnBgNVHR8EIDAeMBygGqAYhhZodHRw\nOi8veDEuYy5sZW5jci5vcmcvMCIGA1UdIAQbMBkwCAYGZ4EMAQIBMA0GCysGAQQB\ngt8TAQEBMA0GCSqGSIb3DQEBCwUAA4ICAQCFyk5HPqP3hUSFvNVneLKYY611TR6W\nPTNlclQtgaDqw+34IL9fzLdwALduO/ZelN7kIJ+m74uyA+eitRY8kc607TkC53wl\nikfmZW4/RvTZ8M6UK+5UzhK8jCdLuMGYL6KvzXGRSgi3yLgjewQtCPkIVz6D2QQz\nCkcheAmCJ8MqyJu5zlzyZMjAvnnAT45tRAxekrsu94sQ4egdRCnbWSDtY7kh+BIm\nlJNXoB1lBMEKIq4QDUOXoRgffuDghje1WrG9ML+Hbisq/yFOGwXD9RiX8F6sw6W4\navAuvDszue5L3sz85K+EC4Y/wFVDNvZo4TYXao6Z0f+lQKc0t8DQYzk1OXVu8rp2\nyJMC6alLbBfODALZvYH7n7do1AZls4I9d1P4jnkDrQoxB3UqQ9hVl3LEKQ73xF1O\nyK5GhDDX8oVfGKF5u+decIsH4YaTw7mP3GFxJSqv3+0lUFJoi5Lc5da149p90Ids\nhCExroL1+7mryIkXPeFM5TgO9r0rvZaBFOvV2z0gp35Z0+L4WPlbuEjN/lxPFin+\nHlUjr8gRsI3qfJOQFy/9rKIJR0Y/8Omwt/8oTWgy1mdeHmmjk7j1nYsvC9JSQ6Zv\nMldlTTKB3zhThV1+XWYp6rjd5JW1zbVWEkLNxE7GJThEUG3szgBVGP7pSWTUTsqX\nnLRbwHOoq7hHwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIFJDCCBAygAwIBAgISBCjrgR1TEHICklNpQDzj1PqPMA0GCSqGSIb3DQEBCwUA\nMDIxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQswCQYDVQQD\nEwJSMzAeFw0yMzA1MjkxODQ0MDBaFw0yMzA4MjcxODQzNTlaMBoxGDAWBgNVBAMT\nD2NyeXB0b2dyYXBoeS5pbzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\nAObo0GReSiFFL4eMlFHutcV+LpLDorPpzzFxxJsXhrm19GyWYHdr4ml7GIAEjqI7\nQZp0aYw1lmtHwgNnaRySU+aWj6LMWI/rIP5rXZYIZLyXSfLbHP0xlfYEvcrcprOm\nAu0YuQgy3TBO0qz6FKx5PtfbDc7p/LYD5tnG5NkbQ4o+7Ko361w787WSb8OV5NFd\nnPqSeIjwxqSy62G6oOHL4wRFDTCOdNjHeYJnPC0L3P9qkGeC6zjqt2h8Q+GE9zNQ\nenqaEOeBIZo46mti6Tvzzc7dqILw1ATqIXJdjwABzuT8Ob34/LsPorLQoRP1+YHF\n++D2JyyvYKM/aFpQI+HHfGUCAwEAAaOCAkowggJGMA4GA1UdDwEB/wQEAwIFoDAd\nBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAdBgNV\nHQ4EFgQUOtGXHs6fLoMQEwjlwSu88r4qLf0wHwYDVR0jBBgwFoAUFC6zF7dYVsuu\nUAlA5h+vnYsUwsYwVQYIKwYBBQUHAQEESTBHMCEGCCsGAQUFBzABhhVodHRwOi8v\ncjMuby5sZW5jci5vcmcwIgYIKwYBBQUHMAKGFmh0dHA6Ly9yMy5pLmxlbmNyLm9y\nZy8wGgYDVR0RBBMwEYIPY3J5cHRvZ3JhcGh5LmlvMEwGA1UdIARFMEMwCAYGZ4EM\nAQIBMDcGCysGAQQBgt8TAQEBMCgwJgYIKwYBBQUHAgEWGmh0dHA6Ly9jcHMubGV0\nc2VuY3J5cHQub3JnMIIBBAYKKwYBBAHWeQIEAgSB9QSB8gDwAHcAtz77JN+cTbp1\n8jnFulj0bF38Qs96nzXEnh0JgSXttJkAAAGIaQn30wAABAMASDBGAiEAglrQJj8G\na7/1upmZ2Is6AqPT9pQpSty0sH4PgnqyQxICIQDEpKnk6Rt6KzvEpIIIEtXgrYx+\ncrerlx4SQVQbnwfz0gB1AHoyjFTYty22IOo44FIe6YQWcDIThU070ivBOlejUutS\nAAABiGkJ9+sAAAQDAEYwRAIgaLwFE4CfhV09wq5IR5zmo/90y5OQJ2MnW5gpRZZh\ns4YCICEAGxUN/f95xFmxOCfqXv3SEozwkrMHA33abVjCQiaGMA0GCSqGSIb3DQEB\nDQUAA4IBAQBSTN5U/3yp6cGMBXlS5WcrB/XOY6TtxPmeSvLM3vqNbpRGu1JOFFtn\n31eweHOTj66GWowSy9+uAhp1V9Uf0hoJMa/b+CkCelyJN4QZCcMfhKrPAD4prbHa\nGYFaLo5SQqkK1hYHo9LH+qhaOBx9hF5aLrGbEFWXQE9/W7KSeCzz6LBLw9xVrB2v\nNTLlXXt5tUiczOIzge5KGaSQr5wgc1viddcRsYuZjtgWlqJ5E5QcZxD8xLTfBe5W\n9vl/k1CB4CZ1IG8Sa9+n91Kxm3HTLL6TcrEOutChwMfZfrLH/piWoRQxezCpn82N\nRaeeHd1Bv3oH3SeVJUHLxgzUv/dh6GSi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2023-07-10T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "cryptography.io" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::ca-as-leaf", + "conflicts_with": [ + "webpki::ca-as-leaf" + ], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> ICA\n```\n\nThe ICA is in leaf position, despite being a CA certificate. This\nis permitted under RFC 5280, which makes no stipulations about CA/EE\nstate in the leaf position.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUXDYg/5iMMXrsSYOqzfkUFX72CcAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQPjznYVkAhdBV2gzos67R5Cf+p+c4PJPzr5ldx\nAzWDWYm6ueyNmTUSdWW8+7nDL8AFiWZHjFc4zgjS233kwDPto1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUCRtvR7OUiXkeM6QA6QOH1+mZ0f0wCgYIKoZIzj0EAwIDSQAwRgIh\nAOYluFVpY0H+48voAj0AGFgdyWvEvuvCCXHbp0oWVcpwAiEAweDGkdrqUJyRN+ye\nN68ediJ4oT/PfKe/B1jSlbZycYo=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICAjCCAamgAwIBAgIUO4N2G/mt9+6XxvlNgDzNZTJCJ00wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA1MjY0MzQyNjU3MjQ0Mzc4NTE1NDI4\nMjg4NzA1NzQzODYwNjkwNjUxMTU3NjUxODQxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABDIn+JAKC/I5dlQeL1rDbKJmwt6x5EN5nH00dQwafr+vTZrM2Ahzurb9FCOA\nU5e7c/rQ7rRMdIjg+4y9qm4/3nKjezB5MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMBkGA1UdEQQSMBCCDmNhLmV4YW1wbGUuY29tMB8GA1UdIwQYMBaAFAkb\nb0ezlIl5HjOkAOkDh9fpmdH9MB0GA1UdDgQWBBQFwWbi7YWg2OlouvoZoyPnsQTB\nCDAKBggqhkjOPQQDAgNHADBEAiBqmO3uahP5e72lJ1WikuaT1Fuxy9GryFh6SiMu\nj0wQkgIgefYWrQs3eUMDAIiHnV1ncbaoDLAbPdzP9ToDh9uoGaY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIHqeMT2b4pQK5rmCoFnfjpfsxEVnqcl6qGF8rF4YwqZToAoGCCqGSM49\nAwEHoUQDQgAEMif4kAoL8jl2VB4vWsNsombC3rHkQ3mcfTR1DBp+v69NmszYCHO6\ntv0UI4BTl7tz+tDutEx0iOD7jL2qbj/ecg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "ca.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::ca-as-leaf-wrong-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA\n```\n\nThe ICA is in leaf position, despite being a CA certificate. This\nis permitted under RFC 5280, which makes no stipulations about CA/EE\nstate in the leaf position. However, the ICA *also* has a different\nSAN than expected, resulting in a failure.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUGQ+RTuXmpwMbvAreUzI3zzrvU8wwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATeHz0a51GY0MME/XN0zrTI4AxyYrOgtf/8NHY/\n2zU2q2zUNikeM5FII/1OUuN4LeJOITwEE/oafH9WL5/zegQ6o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUZWjZeNfY3e2qKP4mQDoYiqasot8wCgYIKoZIzj0EAwIDSAAwRQIg\nIp6G7jwRiaNlE6moZGMoSaaXNxesw2DqxWHqjS4PVNkCIQCj3bQroXxZrdROxDit\n+TqKxwQpj5K7YzBzLU9zKvMFVA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICAzCCAamgAwIBAgIUHu/BV1PQkNV2mbkzbq/ZK0gpuyIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAxNDMwNzE5Mzg1Nzc2NDk0OTkyNDI3\nOTYwMTA1OTMwNzQ5MjQ1MjM4NjY3NzI0MjgxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABOCTiOly6MlEJ/bJKh2Ar7ImuNS1MLEOM/j8edaita2mrA0zlBzgQhpGHSeS\nc/pNEdLnRtN46z5+s9ynzuzYQTSjezB5MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMBkGA1UdEQQSMBCCDmNhLmV4YW1wbGUuY29tMB8GA1UdIwQYMBaAFGVo\n2XjX2N3tqij+JkA6GIqmrKLfMB0GA1UdDgQWBBTPP3blBSBFUlpKAw7YVzE+T/tR\n0jAKBggqhkjOPQQDAgNIADBFAiEAxQh+wXVdQbbMBgX4xJvvr22GJjRdU5kM97We\nXtlVvp0CIEEoX3KIvWiBqg1UuXV/AZEAhXvE8Sc+xowC8t5UBjv+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIHLV/qwx/9fVZuJZPPTYYXbljF8hiWKiY6ZxL26+ClTkoAoGCCqGSM49\nAwEHoUQDQgAE4JOI6XLoyUQn9skqHYCvsia41LUwsQ4z+Px51qK1raasDTOUHOBC\nGkYdJ5Jz+k0R0udG03jrPn6z3KfO7NhBNA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "some-other-ca.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc5280::root-and-intermediate-swapped", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following valid chain:\n\n```\nroot -> ICA -> EE\n```\n\nThe configuration puts the ICA in the trusted set, meaning that validation\nshould ignore (and not fail on) the root in the untrusted intermediate set.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaWgAwIBAgIUcp3S51e2FrCemOeQG3+ZaqiJOp0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBpMTgwNgYDVQQLDC84NzQ1MTcyMDcwNzIwMjk4MTc1ODcz\nMzExNjAzOTAwNDQ1NTI2NzA0Njg2MDYwMzEtMCsGA1UEAwwkeDUwOS1saW1iby1p\nbnRlcm1lZGlhdGUtcGF0aGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIkhGJfHrVUkAXZ13r5ecTyuzTpWbvNUvCo4dIWkKbbPCfS6d98qQGJ1Bq6r7\nxZT82msnWoWS1YqktKOb/j9D8qN4MHYwDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8E\nBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUFkXjHUj0\n89fLx8OAQmTqISHCE+IwHQYDVR0OBBYEFGwHJw22yyhx54GNHUwGEyx7VTVXMAoG\nCCqGSM49BAMCA0cAMEQCIHJ/NihlvNP35t4ucv8YevGLN98HE3EgZ5zoXlNjq1KA\nAiBVDoKyWDUNl+piCS/GH2NbDuBhFCggHeKfixg/xzVFgw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUD1F4hScLJu44Vfwg/k0Fij9xJzswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARerxbjaJ2YHrteEQYkZ0S2JRsjVUUydELv+5Et\n99iX2hu5+idVZUUImVw5IeZ+WamWZhAX5Qf2UfdvI3E8GxUFo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUFkXjHUj089fLx8OAQmTqISHCE+IwCgYIKoZIzj0EAwIDSAAwRQIg\nFn3i8PSz8tcPtwL7PhJ91igjgER+gD6085PJI3DInM8CIQCP2URQdmOQqROScb9K\nUyXVwsjCTvnBWJ8ZiaJqZ27brA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaWgAwIBAgIURidG+YuS479oIy6eyKJKHYLRtEQwCgYIKoZIzj0EAwIw\naTE4MDYGA1UECwwvODc0NTE3MjA3MDcyMDI5ODE3NTg3MzMxMTYwMzkwMDQ0NTUy\nNjcwNDY4NjA2MDMxLTArBgNVBAMMJHg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tTm9uZTAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFjEU\nMBIGA1UEAwwLZXhhbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATM\n71hSCMsK9+qf52lg8BUoqtL/yOSzUluB+/eC515AkdwgHQiYAPZqLCe17CCiAtZS\nk334pQ9tSBkj8Aj1VnJTo3wwejAdBgNVHQ4EFgQUr+0Ib9PjBbr8ydediwU+bfO4\nZIAwHwYDVR0jBBgwFoAUbAcnDbbLKHHngY0dTAYTLHtVNVcwCwYDVR0PBAQDAgeA\nMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMAoG\nCCqGSM49BAMCA0gAMEUCIQCJdm+j6nqorDMIsNYip2yzdnRoNs/5lsbBih0D/11a\nqgIgVi/czaYltV8MHRjDntm0x5fRDtPfyVM6oB1QaEfYEmE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIJNeZxdIIlzD0bWTQ9TnzGlxdYVfKKCcaO2rIN9v0wZ7oAoGCCqGSM49\nAwEHoUQDQgAEzO9YUgjLCvfqn+dpYPAVKKrS/8jks1Jbgfv3gudeQJHcIB0ImAD2\naiwntewgogLWUpN9+KUPbUgZI/AI9VZyUw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc9881::ml-dsa-44", + "conflicts_with": [], + "features": [ + "has-mldsa" + ], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> EE\n```\n\nBoth certificates convey ML-DSA-44 keys, and the root signs for the EE with\nits ML-DSA-44 key, as described in RFC 9881 3 and RFC 9881 4.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----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\nAAAAAAAAAAAAAAAOHy48\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN PRIVATE KEY-----\nMDQCAQAwCwYJYIZIAWUDBAMRBCKAILwG6Rf92yhXUY1P2RC0OwazLIroJU/dTU77\nXT3vpKq5\n-----END PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc9881::ml-dsa-65", + "conflicts_with": [], + "features": [ + "has-mldsa" + ], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> EE\n```\n\nBoth certificates convey ML-DSA-65 keys, and the root signs for the EE with\nits ML-DSA-65 key, as described in RFC 9881 3 and RFC 9881 4.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----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\nAAAFDBIZHSE=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\nkKCsucsBFKUJbXyMBzBddsX9AAAAAAAAAAAAAAAAAAAAAAAKERkcICY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN PRIVATE KEY-----\nMDQCAQAwCwYJYIZIAWUDBAMSBCKAIHyvy9+KiQXPXUS6x+zuK+Y8rm/ah1XA2QI8\n5NOR08/l\n-----END PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc9881::ml-dsa-87", + "conflicts_with": [], + "features": [ + "has-mldsa" + ], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> EE\n```\n\nBoth certificates convey ML-DSA-87 keys, and the root signs for the EE with\nits ML-DSA-87 key, as described in RFC 9881 3 and RFC 9881 4.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\nHlVWbo6U0dQAAAAAAAAAAAAAAAAAAAAKERchJCwyPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN PRIVATE KEY-----\nMDQCAQAwCwYJYIZIAWUDBAMTBCKAIDGCSFJ3UkyY8aW+BamJoTjbjlu4djJwtcjr\nd9fcix/b\n-----END PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc9881::ml-dsa-44-bad-signature", + "conflicts_with": [], + "features": [ + "has-mldsa" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE certificate names the root as its issuer, but is signed with an\nML-DSA-44 key that isn't the root's. Implementations that don't actually\nverify ML-DSA signatures will accept this chain.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----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\nAAAAAAAAAAAAABMiMEQ=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN PRIVATE KEY-----\nMDQCAQAwCwYJYIZIAWUDBAMRBCKAIF8Afg1Wnnh23DyTTOYnIayw9p6mRzbyiYem\nm9+KfaRV\n-----END PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc9881::ml-dsa-44-key-encipherment", + "conflicts_with": [], + "features": [ + "has-mldsa", + "pedantic-rfc5280" + ], + "importance": "low", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE conveys an ML-DSA-44 key, but asserts `keyEncipherment` in its\n`keyUsage` extension. ML-DSA keys can't encrypt data, so this is forbidden\nunder RFC 9881 5:\n\n> ML-DSA subject public keys cannot be used to establish keys or encrypt\n> data, so the keyUsage extension MUST NOT have any of the following bits\n> set: keyEncipherment, dataEncipherment, keyAgreement, encipherOnly,\n> decipherOnly\n\nMost implementations don't check the asserted key usages against the\nsubject key's type, and will accept this chain.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----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\nAAAAAAAAAAAAAAAOHi9B\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN PRIVATE KEY-----\nMDQCAQAwCwYJYIZIAWUDBAMRBCKAIEr++a6XOKipMlBjGGuK84BZGZRxKLiSq40F\nS5n/bJeu\n-----END PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "rfc9881::ml-dsa-44-key-agreement", + "conflicts_with": [], + "features": [ + "has-mldsa", + "pedantic-rfc5280" + ], + "importance": "low", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE conveys an ML-DSA-44 key, but asserts `keyAgreement` in its\n`keyUsage` extension. ML-DSA keys can't establish keys, so this is\nforbidden under RFC 9881 5:\n\n> ML-DSA subject public keys cannot be used to establish keys or encrypt\n> data, so the keyUsage extension MUST NOT have any of the following bits\n> set: keyEncipherment, dataEncipherment, keyAgreement, encipherOnly,\n> decipherOnly\n\nMost implementations don't check the asserted key usages against the\nsubject key's type, and will accept this chain.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIPmzCCBhGgAwIBAgIUFcSW1vtDkKIFjDiug439JXRdRK8wCwYJYIZIAWUDBAMR\nMBoxGDAWBgNVBAMMD3g1MDktbGltYm8tcm9vdDAgFw03MDAxMDEwMDAwMDFaGA8y\nOTY5MDUwMzAwMDAwMVowGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MIIFMjAL\nBglghkgBZQMEAxEDggUhAHR7XEHrrbGRqE+2RVWOXh8dBwXyAG2pmBOulMMqbkgn\n7pXakQp89YtODCSd5U6qBhfFurIT1keUVqDcyuTKFFDAIse8FHCF5EElSHCAESKi\nk8j9w/aAgO/1+ZAAMxVbowj0Z+zsUASKk88NFqEKJgzXd/81qE3CAF2sgia9fxyD\nITw5naoibYN9hQ+H9JaE0xpOIygGjhHKhssra0h6KHNWpjL5YAlfpQRQx45P2Z8D\n+CHSHGtY6bPartQ08x2Ct4oGVw42SrnzLYKZOKzUKDl+6xJen5KjGb1IQIOGUfHT\nq/W/FACWx5spcbAEM/Zx00i+64AYTH6/xFFBm3EEw6dWfePw4tJHt7WbzOSbTfpK\n3kV9JvQ9S/Jf3AiPggG0wicA0uM+X9F4TsBR5ASl8ZFVnNkFg5JOYAJkopJO1z1T\nBVMtMcvnphthbqqvRutF502Bwe2pweVqBiSckoLVr73MJcMy16Xj4L0H94kxLEUm\nv4jqMtTL3/N9Wysgp0zbY6yGrv3uIeDP3ouHDA+BS/FEkf5+eXHuG4q+q2UpQkYV\n/llxN6+vNbHqOFbDaGVGWa8ErpLaR/eei8EGTpRI7PyxOfAqMCoZtVpAELPXVWDm\n/bpZa6RNTDcfgLkkfkvhDaCaHw/67prX1FSeG7U0bm4SLTBHJH2gmrd6mq96we0D\nDWKijIV80QDojVSnLbk0TBmTRqfcDnZfc0xFJzUwnK+fzO8znJha6lS10qVyF9Vh\n+G7fSO+laygRtepEQDNqP3/AP0SpEchrbqa6YRcJ2CW2HT3qkFCgazlgoIJJahyZ\nukaCwLUMJOyMzSVW8hPpz/eIpKLgPWUXrWa7a78Xq8jA+HZEJAWPpklqv3iik5CY\ne9IiGJI6rQnpmH3uCj8aXsy5hlTaBjOdwSlAmT2i2XZ36CYzd+wubRbNpy7zgC6B\nt01a4kAp/LXFwKmM8xr/oL7qbxRlEaZCODXSg/59enQx5EVV42FVyYm83fg9NlsY\ngmYFW8BhQlPwhW340QSXs0iuOzIP+8+IlJoaR4Y60tUNEENbrhAA8gHAKzGASVxa\nO73MIZaTWxiIw1GcGPSOQldqXeO0fTLWQYLCbZ3RRa30RjWVLl0EOucCa89pY6jL\nkUYuyh1EF4+N+PeCYFLtRMBpoBIFfpikpIewmiQCH2A4+/cAMuWViU4gHo1sNI7R\ni0eI/vHdAbRdb/5jTt675NMmNq4a5Y8MUTRQjuBAY6daDpkSQKsO6dAtZWBAhWAV\norf+9a74tDihbmYUSzHXmyNQlP/ZCkk0+M3OYMISxhDZxacE7DDt7peGEplCGBQm\nMVN7RFBQP++Othq1R26yaeiKdQVMpwlUW1KhAZaBRoi3h6Pnr+xKHxibBIfrqIPz\nFHjCV2fLuFuXOnJfMAo46zaKQLYLusXi4W47/sjYqnkbNityu12H34eX1e8wItWh\nN4Iu5wkF8EmcpNghRC5rgMaeVGb/P9aRbR3U3/7H+WNxFKun64aC7MCng4aiWS1Y\nSeljhXtsTHnntXSFaEX0w7rkJr2fvJX3pvET+VT5ALglE0qCMqQb7zpfk8632pFe\n6hgtH3Q58EvueRZx9LkjBjySiFn8kTleO8Zqj20eMMaZAQYFkn2DPimNmjvOjk2m\nsFx6INjZkShKoKiNOXpT4LRP8McyWxD2abDQOPz8IGIHq0MKJ+dl7pP5PMQVyOjq\nXRkKmRlzWp0fepGdilhyPFNLFPRft74da1fgqsCvIHCjVzBVMA8GA1UdEwEB/wQF\nMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB0GA1Ud\nDgQWBBQ0QNGCqmy82ovrfybgRtNeDrUw5DALBglghkgBZQMEAxEDggl1AHj1Dil0\n9fb7pyKmwYKhvARlaLfFJ1i10XTpKvCQHh31tPDeJxo1JRqZBJe1JfDQG45KWqlD\nheKGgj8q/NmbjgtHzkkshfeCbPY0r2d7iLKURhLVQHf3mKMXJ6hLm1i5i7A05BHp\nk4NwibnHUclGu7m2cBHrJqP9ViOl/m3WB1CcsnQ+eqoUlhwh1p9zU/ueYXfpZlkB\n0qWF3hr9ri+qPPufnG8ipruxS81uZIVSvHbU1AqnIdUWwkmcIT8ZPQq4puxmCgz8\nybeFdnU3bAbNHT+MxG2CVgGyQyyZEVbUoeoDwncBFn5+LKPIOPqvdzi1w0VgbkkJ\nU6w1WHWdYzIQfVY26CDErelSEAXlntxO8FzAhV4aExa+L5h3634uZxZR+vm2r7/v\n73oM/fRhwmKKWRgDoL/udglyGZkkNJhZIHRsmoo17u7xkRJQcmT1oKL+iICtpaRL\nj4CYX5MKb39JPR0Ugn6fuOEVYN41pFUcmf+R/0xbTBFfWMWFKsOkqO2nUCncECXT\nRUUth012H6q7dEtu4n+MAvTeVtswXUVZD2rVzia6Z2U2T4ny0AYB4fhMX6QLwhsX\nk4JQMDnvt6w8j5Gl76xJpsu/X1tohiZGp2dMqb34vGffRGY0r+CJMzFmB+e0QUgH\n9nBsSEVJhWYgIQnaKJ5IWub+QZX91vBZJGN7IW3ePQsejeYS4S3Vb4wXg8+5SxEc\nwrKcduaq3IO8wccVMT5To5aCG8bhMWI7Fv/WWjI7La0g0IQ0I2wAtvKfpFYAFNEy\n0g96q69+xE8HUZTD+al3KeurZ3IFajQVnCyCeeqN5ffnbwP2D2e/08WhqE98l1hM\ndoR4L7f9gwROyF1P1ibLpD/3gcxVtUmjzGxNWNHx759rIC5k7gUCjsivvqVlkkJL\nw7drJa0GREFxTI44sTShRKlUTIp+NYVHL0T0B9TDhHfM4Igivxoimbg1JwYgy5Z1\ndHCR1LqU7lyQixIgwpWXdnmyDMRElgvP9XfMzPiP9uHJJtQezWhmdZGsVnl7aYye\nCx4EnGyV6k13m0iUwpPPfAX81TVhW4yHzU5oBYZ8ypvTPfiGPOVKpg0106wLQgt8\nvNtzbJTA/IZIldPpnUFVyCXRWl6oTgm7yvYb6U51RR9KoaTgf5y0ASBzUuX2GeYe\nAezIt6XeKZGtUszwJyq7caJ1cpYKiwL0FpSJ78eF1DItpCawPcHubxycN+dPx5q/\njMx6VYG4TlJWKf6b0MeYZorgENSgp+T3nxwYNxZ7QkK/014ZWUEJmhmCKUWCmRl/\nKVa4BGWTuvJ2wNPX6Jn4XvrppRmCMd44squw83RUfj9C2KlNGfcfFC3sx0xWiLX2\nWlY39tTUjs3klWi6kq3VRL1Zy+ahdsC2P+MT03KAF+wrM6X6b8hYhSWL2OXt1MAu\nMoQx2Yqsq9aSqr32UjhLMgd4EMc97SzyDrmOiyGayJsCHqE6S1cVc/TlurFkk7ov\n4Ki/tIitqkOOmECIfVef6SJV44kLLhX/6jtbhFUDcOEMTRfwMClyn30ePnd8zTuV\nQeRb8Gw+jzUQLFynPRmw6WqdZAeBYwnHFMk8HA2qHJbmC04gykVvlq6OOKqCrAuO\njRqTjIINSAdbGSL+OE+YSzAo1aXPtJF+7r3Jrs14qlKE4fRtT60A4Gzw4hqUwLqH\n/e6ML7RP5dVhqPKGU96B1SoVwbq61HTBzk+c9PjMchnLOb5uhyGE/H4A1H5gDbaC\n57V6o5rs2Ffe/BoUCHaA7peXlTTvziKEa9Py66VSp0pMpMVUGUtcLAO9GCaXldlp\nbZmNWow4g1NT0GixJ0PG/vwbJbURLcwVVuG9oMfQMyPPdwutsAuq8TJdnOQek66P\nKeGNYYUh+oQxBp8SarNmSUmo13BDZ3oD/oa+f4eUHbj8hXE1fDhmQea6z0sJrYoF\nF1yAwuhlCUKoMbFQLN7xlIEWFGMguSsJQQVCNLrdk36UacTbBmohpw4hI03XQy9i\n3rDqVUZFdl7pdcvQFhE6s+3RWqTh3j66K8oo4cESjEhcVDBOlegVbJzH7ruL3aY0\nJJOJWb2fw0m082aZnnk9VtDDEi7ub0qOlZ6CoUnO5d7KkdJIYhKBjzsy+lqzgL0u\nYnHZMXfTO0r3lMeedUPLTGIjTF3p9dNTjumBeuOfIoKu8WD7k9V1Ig8ypdHDpHGM\n9WlnWoUMk6pGMmKI2D2XlfoWzeTeVAB2C8Z/Xl2IbEFxDWXcv+J9EP8XxnLGYFEs\nZLJf5ouN/CUIWMUZOtQrBD2jW1cPSmXSiRvpHLniTs0bPvDMGpt/MMh/wSgaAe/q\ngGm1ARJrmFxH7BCJj2H9mBPaWQQ3GTMDY+98Evom/cRouo2Wg9MM/zK22Zc1wzRF\ng5RJsB1zYNSJHEZlSeFPgboWNJ7QopagF5qyzlxtEtYzwEW0qQXWxfAh5s2htD+m\nt37PF6EoMn4ZlyJeCE7C/jKZHPWPNGRp7PsjqTW2hztxDvUyivaSAtI3ntBZSnfH\n6MOdSu34hxQoqWQ9+Zd1hkbbLR6pF8HX0X9K8OtuoNLixzVVgoHxaBDN0UpE2BRg\nCUujtr82gx2EKLVUdRJIx/3PVVo/imEekYnWOCTftKyyUX7x7nxCBPxtMzv6yNyY\nDpfrueQhLs+JSGxAECCPzwbtHJ+pjwb8cIRGCjTZ2NK9cCSnngtlWodCUyCJGZI5\n0n/bR3///dEwUIJ2IlI/toR/PqO9zy1AjQjhAtpK3373XtlcsHTX38b+kFS7MC1n\nBmuNmINXX0aR9IS0F2uKgMmS4QiGK97ePfaMdiZX/djYIJ17dN2/mNq+k2brEiX7\nJCzWyQR8YCuCmfHcO5vc2hZoMWHKaJi9+qbUVZDESC7cIaOIQ/rqNtmw0czb5T1k\nPPqmhdt68zb0rnxh/7Yh5YFQqi3lvxn9sqVEI0x5hD4SmuaXvSR/5Z313k/0m2td\nnhwwTupDiPi35azL8pXEbtyfyT/7JX6qYSo7756Y+V3Ryw9hv7TjgFQRBVHCtorF\nHRRU0ILkYYVdY0YuDiuXEmm0NeZnHfyCut0J1Enzkm1PVSmNhfuMY/OKXmQ4MIYK\n2XdxOipyaLwQ9VwR7BL7AXLs0CbhgiNNedxPOFxed4GLr+MMERs0SFNpdXuLj5Of\ntsbU+v4bJClUi5KztLW4z9Xf+BgjLDxPc3mWsr/Bx8jLAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAIGig2\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN PRIVATE KEY-----\nMDQCAQAwCwYJYIZIAWUDBAMRBCKAICIDfye+//XCIydfYCSJTj9H72QqDbZBLj1V\n5rD8xrPU\n-----END PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::aki::root-with-aki-missing-keyidentifier", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert incudes the authorityKeyIdentifier extension but without\nthe keyIdentifier field, which is required under CABF:\n\n> 7.1.2.1.3 Root CA Authority Key Identifier\n> Field Description\n> ...\n> keyIdentifier MUST be present. MUST be identical to the subjectKeyIdentifier field.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBmTCCAUCgAwIBAgIUKN/1A2YdrMPehxaOz7ScG0duX9EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQ4j0GNX8B3AS5exOLmAPLasz2HZ8cqQ0+HlifD\njcy9czIumwxVXyTfVSPUmN/VHreuwmFnTCLOKrBUyr202I5po2IwYDAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAJ\nBgNVHSMEAjAAMB0GA1UdDgQWBBSZzDtP6865tD6keNrY8ClY7wxSWDAKBggqhkjO\nPQQDAgNHADBEAiBmpsofT0HVdEYVsjivFWV2QdOLa7VRaGxCNuQ2h67UwgIgD3AN\nBqKpZa5wSuaoNqDbc/OoYSy2JHzQJxwH6cFbN/U=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVagAwIBAgIUC7r4tgcUHf2Q6gZ/ufFih3u2ykkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABMXuaQlA+RpcGOt4eiwoxg6oK4xWN82P2C3xqPhK4qFA\nGP580Wq4/ukWkd1FYEwA325KloH+ExHu29dnIB2VGJ6jfDB6MB0GA1UdDgQWBBQs\nnDeLqLpz4LkhSTRYCyxGuClwTTAfBgNVHSMEGDAWgBSZzDtP6865tD6keNrY8ClY\n7wxSWDALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAOrR2UAhnJOSM2Em9RQJ\n5hwx9mv7XDspZl9QP0uBDam9AiEAmo7OARmh79KIrkmu99Ysq5x0xAx3djWSK4hY\naAuv4fo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIICR29sCESll2nFIjWmieph5mu1nWq0q8dQXayqdJTXGoAoGCCqGSM49\nAwEHoUQDQgAExe5pCUD5GlwY63h6LCjGDqgrjFY3zY/YLfGo+ErioUAY/nzRarj+\n6RaR3UVgTADfbkqWgf4TEe7b12cgHZUYng==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::aki::root-with-aki-authoritycertissuer", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert includes the authorityKeyIdentifier extension with the\nauthorityCertIssuer field, which is forbidden under CABF:\n\n> 7.1.2.1.3 Root CA Authority Key Identifier\n> Field Description\n> ...\n> authorityCertIssuer MUST NOT be present", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIByDCCAW2gAwIBAgIUD07fLQs/26fw5G9SLLnINfyohQ8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASRZGTuU6ak1kFn89nqEpboVg2yUIFT7AHNe18m\nPcpzvVoig8+Dxjk+kBVqyHJLLvSsvdGhWqvluA2glwPqrOX3o4GOMIGLMA8GA1Ud\nEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29t\nMDQGA1UdIwQtMCuAFKrdR4OtgjlEHFWcdXiFAwkCSbHkoROkETAPMQ0wCwYDVQQD\nDARteUNOMB0GA1UdDgQWBBSq3UeDrYI5RBxVnHV4hQMJAkmx5DAKBggqhkjOPQQD\nAgNJADBGAiEA08e29J10Sxptpfdb1OGf9CdutxE2BmgKkr1Yn0GbewwCIQDyOb94\nSdNgRgMoVkimysAq8+BW4u5I5yO/aiXyZC+PeQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVagAwIBAgIUVKpRCZk4Ue7/D/JBguqkE54h8MYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABMp6rfcDyiuPSfLfpgNdOtnAUm5HM9IC6OZKoGIqNsdU\nLslF7pvBW4T9lSRDG756JL/4WxxZQLqFTEaS8JyAMfajfDB6MB0GA1UdDgQWBBSf\namLnZIA/bbCRBHdPwLLQyh60sTAfBgNVHSMEGDAWgBSq3UeDrYI5RBxVnHV4hQMJ\nAkmx5DALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAOTRHnjfSVkqvg67VXP3\n6ZvCFm/oQhNcwvDa56tFI77IAiEAh3i2+D6/pfvErn6IQwLaO5gvE7bTltrXNvFC\nxvhowrA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILHQTqYstpe9OSz6KbQ6zgQezPOCeGYGGI6dGjUwjTkXoAoGCCqGSM49\nAwEHoUQDQgAEynqt9wPKK49J8t+mA1062cBSbkcz0gLo5kqgYio2x1QuyUXum8Fb\nhP2VJEMbvnokv/hbHFlAuoVMRpLwnIAx9g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::aki::root-with-aki-authoritycertserialnumber", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert includes the authorityKeyIdentifier extension with the\nauthorityCertSerialNumber field, which is forbidden under the\n[CA/B BR profile]:\n\n> 7.1.2.1.3 Root CA Authority Key Identifier\n> Field Description\n> ...\n> authorityCertSerialNumber MUST NOT be present", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBtDCCAVqgAwIBAgIUXUcw+l1urulZTH5HQAKMkwsOtWUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARhnqRXawZPG9twzGpzBjUpiVN3gOd6W+vzZUPr\npk+g8FrHE2pvsNj5ufv+NTtsCirbtdZFJWtS4/cIfJDXPVSko3wwejAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAj\nBgNVHSMEHDAagBQJZe1tazLKgEbYgkGijbgEOATsV4ICBNIwHQYDVR0OBBYEFAll\n7W1rMsqARtiCQaKNuAQ4BOxXMAoGCCqGSM49BAMCA0gAMEUCIH/PXqX3fBFxPZtR\nzd6gsk13gGA9X9sseLZ3ewH718IQAiEAiqtT8CW38cGkFMfPDexYCJtbtJRf6HY9\njOnluSG+MQ0=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUAOe+h14K5MDZKqRK/EF+Tq2EGScwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABJnETo9e7qJOsurFHrPiTenmiQWh6BXr+SZlsVg9hCUg\nPX30r9CpUqH8/Rym8Ynu8RFAfIbvZip4RVTuom4ilYOjfDB6MB0GA1UdDgQWBBSg\nTNTLp7JhVBGaCIeHjuy8K6WPXjAfBgNVHSMEGDAWgBQJZe1tazLKgEbYgkGijbgE\nOATsVzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAP/tNRun9kXZL8yhD1qF\nLVbJGJ0eAa2HR7GH9lcfDtLIAiB3xt3Q83jwM02fsmPQcjkUpoFuKfd5QNFDamHw\nHFBIyw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIrfGvPhgaItlUQ2FoapdEoV0uGFDLLCruOrvEJCNsGsoAoGCCqGSM49\nAwEHoUQDQgAEmcROj17uok6y6sUes+JN6eaJBaHoFev5JmWxWD2EJSA9ffSv0KlS\nofz9HKbxie7xEUB8hu9mKnhFVO6ibiKVgw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::aki::root-with-aki-all-fields", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert includes the authorityKeyIdentifier extension with the\nauthorityCertIssuer and authorityCertSerialNumber fields, which is\nforbidden under CABF:\n\n> 7.1.2.1.3 Root CA Authority Key Identifier\n> Field Description\n> ...\n> authorityCertIssuer MUST NOT be present\n> authorityCertSerialNumber MUST NOT be present", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIByzCCAXGgAwIBAgIUccFrANcN3Lv0ymRXxBU8gMHgSPUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQ/DPwUhJBq82g52S1bu7BLVcveZtxRhTpEKvoX\naBTrro8luOegVlcoCCmI058FDlgzriILDycMNDCAyuPyGYC7o4GSMIGPMA8GA1Ud\nEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29t\nMDgGA1UdIwQxMC+AFEp0Z5pjRQtkI5FCJ/LUWAnCbryaoROkETAPMQ0wCwYDVQQD\nDARteUNOggIE0jAdBgNVHQ4EFgQUSnRnmmNFC2QjkUIn8tRYCcJuvJowCgYIKoZI\nzj0EAwIDSAAwRQIgZ2JI9R+FYZwkgzGdk0AXznoB4arsbKHGJdlOjJU+S0UCIQDp\niGoal53C+W29FDmO+GDhxzGNJpFOtgrNGj20WwUkUg==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUXEoTjyzh71ce10dOqviMI2iAcXUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABB5Z5JiI6TZKRW14VnhSXqQNbfXb7D+MkwV3qcoWUDtv\ncV+vZk8921KBUKaKD73MaEtuy+Q8vyp0NCLfkMOfGpqjfDB6MB0GA1UdDgQWBBS9\nBLljCmmjtxILfDSnJx/klatluzAfBgNVHSMEGDAWgBRKdGeaY0ULZCORQify1FgJ\nwm68mjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgZvDm4u3cMmH4a77nK1Xc\nuz3Rg69cwSqKGlhvVlif6UYCIAKNAV1tcWg07n+jQTxwJwrwDdlxtL7soWoi+C6T\nt4Go\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIH1euf8m4cv9Jcbw9sLRiuOhyHa6wBiQk4GdOfqLejYBoAoGCCqGSM49\nAwEHoUQDQgAEHlnkmIjpNkpFbXhWeFJepA1t9dvsP4yTBXepyhZQO29xX69mTz3b\nUoFQpooPvcxoS27L5Dy/KnQ0It+Qw58amg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::aki::root-with-aki-ski-mismatch", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert is self-signed contains an authorityKeyIdentifier, but\nthe keyIdentifier field doesn't match the subjectKeyIdentifier field\nas required under CABF.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUVs6O5gpziPtktuaIPVF8lI1ry7EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR/BfLCyNycCra3tLHaFIuyxuiPSQwOGyAkOeAw\noT/Ymm+wDDPVIf5Rh/jRBLytCjZTAMnbiLELhNYZzTQZmNwXo3gwdjAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAf\nBgNVHSMEGDAWgBTwvyrAZP5Jg/HvGK6cjB2FnQ3l/DAdBgNVHQ4EFgQUl7QhU2dh\n8fwDEJYZpIAnRKRWh+AwCgYIKoZIzj0EAwIDSAAwRQIgLHmUOAnAOwV7KqAeBmkT\ncJTfR9Q8mu9IVmGHX/uqDHcCIQDnCJKSFpOSVbhmbr3WidGNU0qsB0ZvhqYfJKjk\nYTG+Sw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUVGnBRjbYiOKGRBis3dQrZ74thoMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABMGca3UeqY4LYqSioRj0liqZ832Ax4+m+lUIEWMw5zvK\ngcv2h9vqMeIhhIwdZjg493XwDjR8OfiYzsDWHq7m6tejfDB6MB0GA1UdDgQWBBSc\nD/kNGeO4ThCi2839Xa6hz3y3/DAfBgNVHSMEGDAWgBSXtCFTZ2Hx/AMQlhmkgCdE\npFaH4DALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgfZqSRncsS8B0z3exaMHO\nkj8JdXoeo8j4Fg37KjK1axcCIGd+AJLoU/lzY7uE7VorQijinQqpSsXoCdQtk79N\nnLC1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIKnJgAq9v4gHwYJP0FPPgiyKvUEMg3DzRO1XW+LLa4qkoAoGCCqGSM49\nAwEHoUQDQgAEwZxrdR6pjgtipKKhGPSWKpnzfYDHj6b6VQgRYzDnO8qBy/aH2+ox\n4iGEjB1mODj3dfAONHw5+JjOwNYerubq1w==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cn::ipv4-hex-mismatch", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a certificate where the CN contains an IPv4 address in hexadecimal\nformat, which violates CABF BR 7.1.4.3.\n\nCABF BR 7.1.4.3 requires: \"If the value is an IPv4 address, then the value\nMUST be encoded as an IPv4Address as specified in RFC 3986, Section 3.2.2.\"\n\nRFC 3986 Section 3.2.2 defines the IPv4address grammar using only decimal\noctets separated by periods (dotted-decimal notation). Hexadecimal format\nis not permitted by this grammar.\n\n> IPv4address = dec-octet \".\" dec-octet \".\" dec-octet \".\" dec-octet\n\nCN: 0xC0A80101 (invalid - hexadecimal format, represents 192.168.1.1)\nSAN: 192.168.1.1 (valid RFC 3986 dotted-decimal format)\n\nThe certificate MUST be rejected because the CN is not a valid IPv4 address\nper the required encoding format.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUTkSvPONDTetK67pgoeH7YB9lg+MwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARDCdn4uCLVodDmO6C84uANDcsxIp+VuSOMgttF\nz+CtzxnZEseJWSoFIVEOo32cJTAANfL8eTLfdf4eLaBl9K0do1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUQnbqNnH0PACBXzfg8peRaUcyZkcwCgYIKoZIzj0EAwIDSAAwRQIg\nMRA3wtC0uT3G1LyGDQU1W6aai80H186GwDtgpJ35JhICIQCubV7ZdnN4MX7lwBJZ\nGybJ8DkMtYpQLGVyCpxyZoHCnA==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBqDCCAU6gAwIBAgIUMP2ZUc5eXb1enUY23FuY1FWgi5MwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAVMRMwEQYDVQQDDAoweEMwQTgwMTAxMFkwEwYHKoZIzj0C\nAQYIKoZIzj0DAQcDQgAEvPQ4c/gXm6OGCM/aauM2YwXfSXyR3TSBnK6vLS02J7Vb\ny9qMT57ta7wohXvWTUqDMSiRGvKtzlXgEV4zS9+L3qN1MHMwHQYDVR0OBBYEFIBi\nJ0HJ7TY+qXadmU+oeuDf9pLKMB8GA1UdIwQYMBaAFEJ26jZx9DwAgV834PKXkWlH\nMmZHMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAPBgNVHREECDAG\nhwTAqAEBMAoGCCqGSM49BAMCA0gAMEUCIFs1nBzWjqIpYwCh3RjsDrPfM00CEnZ4\nO1oz6iObqlBrAiEA0MIsiNPleakbcXOSo+AsCvmQ4lJipApgOJcZhgixdSw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIOLWxcG+S4CRJw8G++75NDixQPoXJzV6yJj+LYHc9uqOoAoGCCqGSM49\nAwEHoUQDQgAEvPQ4c/gXm6OGCM/aauM2YwXfSXyR3TSBnK6vLS02J7Vby9qMT57t\na7wohXvWTUqDMSiRGvKtzlXgEV4zS9+L3g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "192.168.1.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cn::ipv4-leading-zeros-mismatch", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a certificate where the CN contains an IPv4 address with leading\nzeros, which violates CABF BR 7.1.4.3.\n\nCABF BR 7.1.4.3 requires: \"If the value is an IPv4 address, then the value\nMUST be encoded as an IPv4Address as specified in RFC 3986, Section 3.2.2.\"\n\nRFC 3986 Section 3.2.2 defines the dec-octet grammar as:\n\n> dec-octet = DIGIT / %x31-39 DIGIT / \"1\" 2DIGIT / \"2\" %x30-34 DIGIT\n> / \"25\" %x30-35\n\nThis grammar does not permit leading zeros (e.g., \"001\" is not valid because\na three-digit octet must start with \"1\" or \"2\").\n\nCN: 192.168.001.001 (invalid - contains leading zeros)\nSAN: 192.168.1.1 (valid RFC 3986 format)\n\nThe certificate MUST be rejected because the CN is not a valid IPv4 address\nper the required encoding format.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUfge4+8E2nhFMKaYVd8K161scLZQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARpVD0Ucvk+AokR2mY8C3J/YffgiEHvEWH1S8E/\nM9d8Ajjvxbi95aHXb6g3riyhOKuPA9Smud7ODo7mOpJSosiLo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUv64WUO3AIw4duOra6b6kgHMhdu8wCgYIKoZIzj0EAwIDRwAwRAIg\nKFKOkmVAa6+9MM5y7eeqInuqRuez8HHkw9PW3B0Zgk0CIEoBoY10f6a3AvMM10M6\n2snFOwYDHSDQD3j5ERN519k2\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrjCCAVOgAwIBAgIUGq6Iq05qNdTA+cZge7ha7gIklfwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA8xOTIuMTY4LjAwMS4wMDEwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATPdB44Grt+HJlJHTZAOzeVA3k575+gIK6N6/mN\nGo3txWJRZA5YH4nMXfvtueKfxNtzbbyVDEAA8RhUA/L9Ox76o3UwczAdBgNVHQ4E\nFgQUR0tv77e15e/n3xzOffywCxUCF+8wHwYDVR0jBBgwFoAUv64WUO3AIw4duOra\n6b6kgHMhdu8wCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMA8GA1Ud\nEQQIMAaHBMCoAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIjExFuUaWPYDhQe4IuL7V2j\nTwaxWCYDrBkh91mlh2bjAiEA9Q+iGtdpCXwmcNIKIsGwMhccRZnIYm8qyyY5hyDG\nfZo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIKR2N9Bh2G9xA74x758fTvmf1JwNmBXw5iNDdqIVOrvUoAoGCCqGSM49\nAwEHoUQDQgAEz3QeOBq7fhyZSR02QDs3lQN5Oe+foCCujev5jRqN7cViUWQOWB+J\nzF377bnin8Tbc228lQxAAPEYVAPy/Tse+g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "192.168.1.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cn::ipv6-uppercase-mismatch", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a certificate where the CN contains an IPv6 address with uppercase\nhexadecimal characters, which violates CABF BR 7.1.4.3.\n\nCABF BR 7.1.4.3 requires: \"If the value is an IPv6 address, then the value\nMUST be encoded in the text representation specified in RFC 5952, Section 4.\"\n\nRFC 5952 Section 4 states:\n\n> The characters \"a\", \"b\", \"c\", \"d\", \"e\", and \"f\" in an IPv6 address MUST\n> be represented in lowercase.\n\nCN: 2001:DB8::8A2E:370:7334 (invalid - contains uppercase hex characters)\nSAN: 2001:db8::8a2e:370:7334 (valid RFC 5952 format with lowercase)\n\nThe certificate MUST be rejected because the CN is not a valid IPv6 address\nper the required RFC 5952 text representation.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUV2F3q4RsJgrVebuOAWXCZ4JALecwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASEkjfD44pXwmw9CC6CFPKqMcO6I6fiTaDHSCtn\nqQwkqO1x+QdECi6/fPQm5IWkZin93zTe1b9GGwtB2D71Eraco1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUiTb3cHv08w1j8zG0pFAMb73PJVUwCgYIKoZIzj0EAwIDSQAwRgIh\nAIoOR06d4KExlJ/a7/k4Q2yjk4p1YlOrEoQtPCr0dW+lAiEAo4pClTUGzPxXJTj0\nApZziuplxYBzmC4rHPw4ZMuNH04=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBwjCCAWigAwIBAgIUPsIiOyF9jLZL4WurQPBo2+6vK3AwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAiMSAwHgYDVQQDDBcyMDAxOkRCODo6OEEyRTozNzA6NzMz\nNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDaDq0Wy6dbhkOs2QX6XrtFjdFxZ\nqHt0hcpk2v2YmY1yNVo7rQeQJKMCvD/u9EpSYBAy+3XXUuuTNjnKAT/wtryjgYEw\nfzAdBgNVHQ4EFgQU/aQFaQavMDJaOyIX0uAM+0sh4UIwHwYDVR0jBBgwFoAUiTb3\ncHv08w1j8zG0pFAMb73PJVUwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUF\nBwMBMBsGA1UdEQQUMBKHECABDbgAAAAAAACKLgNwczQwCgYIKoZIzj0EAwIDSAAw\nRQIhAJY36s6AgodYHE84AnBtie3F6KbQJpugac2K0KEYIQMmAiBRD9rrPEdpJ9Zh\nQxOSuCvJObta/mnqD0YmTeQTyOJBzQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIOW5mTr/DpZlE+RMhrX0y/JwF1ED2S54njEGT9OQlVw+oAoGCCqGSM49\nAwEHoUQDQgAENoOrRbLp1uGQ6zZBfpeu0WN0XFmoe3SFymTa/ZiZjXI1WjutB5Ak\nowK8P+70SlJgEDL7dddS65M2OcoBP/C2vA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "2001:db8::8a2e:370:7334" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cn::ipv6-uncompressed-mismatch", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a certificate where the CN contains an uncompressed IPv6 address\nwith leading zeros and no \"::\" compression, which violates CABF BR 7.1.4.3.\n\nCABF BR 7.1.4.3 requires: \"If the value is an IPv6 address, then the value\nMUST be encoded in the text representation specified in RFC 5952, Section 4.\"\n\nRFC 5952 Section 4 states:\n\n> Leading zeros MUST be suppressed. For example, 2001:0db8::0001 is not\n> acceptable and must be represented as 2001:db8::1.\n\n> The use of \"::\" MUST be used to its maximum capability.\n\nCN: 2001:0db8:0000:0000:0000:0000:0000:0001 (invalid - has leading zeros\n and doesn't use \"::\" compression)\nSAN: 2001:db8::1 (valid RFC 5952 format)\n\nThe certificate MUST be rejected because the CN is not a valid IPv6 address\nper the required RFC 5952 text representation.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUZ0nhYku7bN1/kPq5l80eXKPQ4PcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAStz1BejslGdb0plBWNpoabzAYM97A4krjcyXUR\nozP0ACBg3G/08BCeCUM2Vh+hH+RBcQofOmiNiYein1M7HPFVo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUHg75+fyZ9QLV5uTX2MeeDOL4QjQwCgYIKoZIzj0EAwIDSAAwRQIg\nHMduzvmhqratNQ+hOHSTHqc7s0lymTMdzTpeukfzEdcCIQDC04YkEs8vfkrEoNeJ\nwsebSYes811ZTNFV6PLPITMhQw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB0zCCAXigAwIBAgIUA+lBB2aK6NB+sj5ejs2z9QbmmiwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAyMTAwLgYDVQQDDCcyMDAxOjBkYjg6MDAwMDowMDAwOjAw\nMDA6MDAwMDowMDAwOjAwMDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASOYSCK\nfmEFvA5exaoWto6fgQalAg4l7hsZo/eCC9xvAtpGb744Syf/q5Llqf2IvMwQI6qc\nDp2Xs1+udVISazYJo4GBMH8wHQYDVR0OBBYEFC9RH4eOwz1Iwey4VoVKr8X7UWga\nMB8GA1UdIwQYMBaAFB4O+fn8mfUC1ebk19jHngzi+EI0MAsGA1UdDwQEAwIHgDAT\nBgNVHSUEDDAKBggrBgEFBQcDATAbBgNVHREEFDAShxAgAQ24AAAAAAAAAAAAAAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCxCLenMUb8c9IeG9udq8TBycGjbHaEirbU52WK\n9GWACgIhAMRYxjcNJYVuNnRBsYzr9xN/iOjETN/v39nVIFYQV1qv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIMvaN4wOOb5YMHm758rc6hfGnZfyMko+lIIEmFy5Jt7roAoGCCqGSM49\nAwEHoUQDQgAEjmEgin5hBbwOXsWqFraOn4EGpQIOJe4bGaP3ggvcbwLaRm++OEsn\n/6uS5an9iLzMECOqnA6dl7NfrnVSEms2CQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "2001:db8::1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cn::ipv6-non-rfc5952-mismatch", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a certificate where the CN contains an IPv6 address that doesn't\nuse \"::\" compression for the longest zero sequence, violating CABF BR 7.1.4.3.\n\nCABF BR 7.1.4.3 requires: \"If the value is an IPv6 address, then the value\nMUST be encoded in the text representation specified in RFC 5952, Section 4.\"\n\nRFC 5952 Section 4 states:\n\n> The use of \"::\" MUST be used to its maximum capability. For example,\n> 2001:db8:0:0:0:0:2:1 must be shortened to 2001:db8::2:1.\n\n> When there is an alternative choice in the placement of a \"::\", the first\n> sequence of zero bits MUST be shortened.\n\nCN: 2001:db8:0:0:1:0:0:1 (invalid - doesn't use \"::\" for the first longest\n zero sequence at positions 3-4)\nSAN: 2001:db8::1:0:0:1 (valid RFC 5952 format with \"::\" at first zero run)\n\nThe certificate MUST be rejected because the CN is not a valid IPv6 address\nper the required RFC 5952 text representation.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUJ6H7BTSdqDCqpY5KDLz4bOp9GggwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQIeOgVGWbtrHX3YM0LXCSfdwClbmWWUaThgpx/\nyz+UHpowM2Q25/arhYI6Rz0VqVOO2Iu4fON+MLBsbCLRRnXxo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUkdYBBYcSpGUqHcadftlIFJOTy0UwCgYIKoZIzj0EAwIDSAAwRQIh\nAKfMzbpPrmhxHH8MbvND6sEJwHORhLLL1L6LVMf+xNdUAiA5i1VCjid1g56pQk4B\nw1/o6MSjM6idk6nBX58z/Kshyw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBwDCCAWWgAwIBAgIUC11ZuCCC9UHRB2E0nbMlQY9I77owCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAfMR0wGwYDVQQDDBQyMDAxOmRiODowOjA6MTowOjA6MTBZ\nMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFg3bVeZjziYGjMaEu3Ph7n5Ct4ILIHC\n8JZUapABFftIsGrLEE3QzFWR22zTAa0y2wRuseINMp3SQO9B4ZCesXyjgYEwfzAd\nBgNVHQ4EFgQUWPPxm1Cn6AmUFa1wB8jfyO2YFsgwHwYDVR0jBBgwFoAUkdYBBYcS\npGUqHcadftlIFJOTy0UwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMB\nMBsGA1UdEQQUMBKHECABDbgAAAAAAAEAAAAAAAEwCgYIKoZIzj0EAwIDSQAwRgIh\nAKR2ePYUMGg+cIEOAe1nkbxj6AwieuQm4VFqmHBj9iNbAiEAjrU6jo2jr2fUVrTK\nTIiNqi6gtsaLILSUNSXovOAWii0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIBmluVM+aCHtEPov+TlD0aPwMuecyAMaVcC8cJzKpcnZoAoGCCqGSM49\nAwEHoUQDQgAEWDdtV5mPOJgaMxoS7c+HufkK3ggsgcLwllRqkAEV+0iwassQTdDM\nVZHbbNMBrTLbBG6x4g0yndJA70HhkJ6xfA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "2001:db8::1:0:0:1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cn::punycode-not-in-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a certificate where the CN contains a punycode domain that is not\npresent in the SAN, violating CABF BR 7.1.4.3.\n\nCABF BR 7.1.4.3 requires: \"If present, this attribute MUST contain exactly\none entry that is one of the values contained in the Certificate's\nsubjectAltName extension.\"\n\nCN: xn--nxasmq6b.com (punycode for \"בדיקה.com\")\nSAN: xn--n3h.com (punycode for \"⌘.com\" - a different domain)\n\nThe certificate MUST be rejected because the CN value does not match any\nof the SAN entries.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUfI6C4HvrYZW5qOrbiWOeLWn1vbswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQwsWkY1cwoBmL9fnR37BUzyo5O+iTVrWy2VwOR\nYrd5VzoETRqbOHp4uAWvulptaneH3457D9FpdMbUqXvmep6To1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUTAInaOOoXMiiKnFPfvk29R+ApH0wCgYIKoZIzj0EAwIDSQAwRgIh\nAMbTnAyW8CkWSZ84tqCTu6bQZa/UiMzpco55vP2BBzHEAiEA3Ibmk4HS/mgxURqW\nwRFoKyC5dy3iTvNyMg1lldELKTg=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtjCCAVugAwIBAgIUQXIZrt4w6tOSD4eKgQa5ELfM3IQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAbMRkwFwYDVQQDDBB4bi0tbnhhc21xNmIuY29tMFkwEwYH\nKoZIzj0CAQYIKoZIzj0DAQcDQgAE+2uy1b74yDDpZ03D27Q2Z/2rnSky2YNzgRL1\nm8o2MU3RxHRcbHBbAxk0OZrPFo8PQfC7p5cQE+xmlZvkJoc4waN8MHowHQYDVR0O\nBBYEFOCWTngYvvvTrT3N4m9HrmP9jnJuMB8GA1UdIwQYMBaAFEwCJ2jjqFzIoipx\nT375NvUfgKR9MAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNV\nHREEDzANggt4bi0tbjNoLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAhACba8d0XhTZ\n2ylS+d9IaSUBmXiJnbyBvQOdrTzuhTsCIQD71O0G7LuotqzAn/Fp1nYxvDIblva5\n0hG41++gyiSb3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIM/EYkN0BP+XnK+qNoV9caWNeqlcMtT0ZU/vxcf2WnzZoAoGCCqGSM49\nAwEHoUQDQgAE+2uy1b74yDDpZ03D27Q2Z/2rnSky2YNzgRL1m8o2MU3RxHRcbHBb\nAxk0OZrPFo8PQfC7p5cQE+xmlZvkJoc4wQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "xn--n3h.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cn::utf8-vs-punycode-mismatch", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a certificate where the CN contains a UTF-8 internationalized\ndomain name while the SAN contains the punycode equivalent, violating\nCABF BR 7.1.4.3.\n\nCABF BR 7.1.4.3 requires: \"If the value is a Fully-Qualified Domain Name\nor Wildcard Domain Name, then the value MUST be encoded as a\ncharacter-for-character copy of the dNSName entry value from the\nsubjectAltName extension.\"\n\nThe CN value \"test-測試.com\" (UTF-8) is not a character-for-character\ncopy of the SAN value \"xn--test--wg5h0h.com\" (punycode), even though\nthey represent the same domain semantically.\n\nCN: test-測試.com (UTF-8 representation)\nSAN: xn--test--wg5h0h.com (punycode/A-label representation)\n\nThe certificate MUST be rejected because the CN is not a\ncharacter-for-character copy of the SAN dNSName entry.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUBnWDyUOLBUIVjTEMDA2MzbAofA8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQgmjukGNds3o1kGrK6XzptFCTlrg0ynn/KmgLm\nrwxNQn/KBSgBeGcpuMSc3W9ZPUDb9KtydOb0DaeCh8/pe/njo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU7ot0ZRJGVOa3tZ4TH4BMJNSpBQ0wCgYIKoZIzj0EAwIDRwAwRAIg\nGEdHTEVYy9TE5hdFbBeIwLw2W2iiei4eqc10SrnhRlcCIA+Ci81aT3F0XmUDZeT2\nKeYEhMUKDrSnIIRDz0K2r/xN\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBwDCCAWWgAwIBAgIUf/b6Q8LiQTsDFTRYd6taQcLyNXgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA90ZXN0Lea4rOippi5jb20wWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARjquzYypvMujzSXEgz1kSqrQJrOMqdl5oXJP2T\ne+ox9ItDR5yFAji425NQfXhybi5UpXPVXRhKmL4AKYfQERMAo4GGMIGDMB0GA1Ud\nDgQWBBQ2pqeM0FTxXcTHOs9CF+BT9XcImDAfBgNVHSMEGDAWgBTui3RlEkZU5re1\nnhMfgEwk1KkFDTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwHwYD\nVR0RBBgwFoIUeG4tLXRlc3QtLXdnNWgwaC5jb20wCgYIKoZIzj0EAwIDSQAwRgIh\nALfdXLTF294pmdUeueGhnhkEeq8W48+SOBayPfe3MJ+AAiEAqArbtrtr43y8MTI2\n0Z4qf18RAkfBk2kgwR5TOGvQhUE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIJV94fpiZnCu7mEZR8+VQM3J7h2CL7RcDVuclbmaI1rCoAoGCCqGSM49\nAwEHoUQDQgAEY6rs2MqbzLo80lxIM9ZEqq0CazjKnZeaFyT9k3vqMfSLQ0echQI4\nuNuTUH14cm4uVKVz1V0YSpi+ACmH0BETAA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "xn--test--wg5h0h.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cn::not-in-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a certificate where the CN contains a domain name that is not\npresent in any SAN entry, violating CABF BR 7.1.4.3.\n\nCABF BR 7.1.4.3 requires: \"If present, this attribute MUST contain exactly\none entry that is one of the values contained in the Certificate's\nsubjectAltName extension.\"\n\nCN: notinsan.example.com\nSAN: valid.example.com, another.example.com\n\nThe certificate MUST be rejected because the CN value \"notinsan.example.com\"\ndoes not match any of the SAN dNSName entries.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUOE7DIeDlTkESv7VExFC52ABxAO8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR6ffVxdyMAzDt3eLKrvQjGn7df1NoQZUk8EQi6\nlsj5r79WeigfDmKQWVCY6CI2hMqUbqEnAGZG0yojodV9Xkg6o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU0B/Cqeqbf3NSIXrw8qh5OcQxEQMwCgYIKoZIzj0EAwIDSQAwRgIh\nAJJmRrdtFtGOFsvHs0VEqUFlYdjZB+SxFw0e9HtQ7TLeAiEA91aGbxuHPiQDtN2W\nv7nKgOh7IreCsxgHDLihOgBc/Hs=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB1TCCAXygAwIBAgIUPPYNk584UZ2+YIUY5gUxeHLDuK0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAfMR0wGwYDVQQDDBRub3RpbnNhbi5leGFtcGxlLmNvbTBZ\nMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK6Sns1Z9kanoaMNpkJWJk0KgSy7pxFZ\n76qlM5EnmA6eUeHO1zafskEGqqshjt0v2Ah/SG1VMtRI1PplQc+uJrSjgZgwgZUw\nHQYDVR0OBBYEFCrUmQ8GBfFC1KeAkC1kNCyDTU8OMB8GA1UdIwQYMBaAFNAfwqnq\nm39zUiF68PKoeTnEMREDMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcD\nATAxBgNVHREEKjAoghF2YWxpZC5leGFtcGxlLmNvbYITYW5vdGhlci5leGFtcGxl\nLmNvbTAKBggqhkjOPQQDAgNHADBEAiBVUJraLiV0E6Yos57tWt9LEqzOvpugx065\neSjbj/N2CgIgU0/hh+ncB19XTeyPxhlJQ5DNx6fIa8m0583+O9m2OIA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIPvY8NwgfgahjOCVvxwbcCZP3i9G0WeW3p2FqoF7D/9yoAoGCCqGSM49\nAwEHoUQDQgAErpKezVn2Rqehow2mQlYmTQqBLLunEVnvqqUzkSeYDp5R4c7XNp+y\nQQaqqyGO3S/YCH9IbVUy1EjU+mVBz64mtA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "valid.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cn::case-mismatch", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a certificate where the CN differs from the SAN entry only in\nletter case, violating CABF BR 7.1.4.3.\n\nCABF BR 7.1.4.3 requires: \"If the value is a Fully-Qualified Domain Name\nor Wildcard Domain Name, then the value MUST be encoded as a\ncharacter-for-character copy of the dNSName entry value from the\nsubjectAltName extension.\"\n\nThe requirement for a \"character-for-character copy\" means that the CN\nmust be byte-identical to the SAN entry. \"Example.COM\" differs from\n\"example.com\" in the bytes representing 'E', 'C', 'O', and 'M'.\n\nCN: Example.COM (mixed case)\nSAN: example.com (lowercase)\n\nThe certificate MUST be rejected because the CN is not a\ncharacter-for-character copy of the SAN dNSName entry.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUNmImNLO9tb3naejs7wYXHvkw/pwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAReAOqDl1lDve5m+VNsOH8L5Xs0l8cj1NBzO+/+\nhHHdLZCAKDQEFcZq/oTJm+Wx65yhyiY1xnG0fd+vQbA+9Ml5o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU0WLH/ObXjs0FEi449MDPs/rRskMwCgYIKoZIzj0EAwIDRwAwRAIg\nQqYozDbIQKQOYzQO8NC5sSGZXTuNkI2D9hEHfbR0Rd8CIEa9wWgKlrCvlaO/7M+Z\nbxcHoLBLmniqIuXTJJj2ELtY\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVagAwIBAgIULHym0vosJe7vZa+XD8ZozXooFHgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtFeGFtcGxlLkNPTTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABALdmOVl7fQX1BGaC3L4T9c+DtR2eCXUoeC8NyPWT1L1\nxdf0f2RpPU/P3c6DLjfihQFKmsmuRbkdvR3Bq72am86jfDB6MB0GA1UdDgQWBBTo\nYdc2kLtmhgGd314DF6MgZ6VX3jAfBgNVHSMEGDAWgBTRYsf85teOzQUSLjj0wM+z\n+tGyQzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAJWRda9jHr4Q9hfSKg+r\nVqOMQfnmE5bNYRRQCNu2i005AiEAokeqp3SF+QAb2+bgvE3/rLp2OQ57GBY60rH1\ndSMZXQc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIH/RYlkOQfeeerAYoPSt/DWKKGlRKLn28QNYIRFRpjVBoAoGCCqGSM49\nAwEHoUQDQgAEAt2Y5WXt9BfUEZoLcvhP1z4O1HZ4JdSh4Lw3I9ZPUvXF1/R/ZGk9\nT8/dzoMuN+KFAUqaya5FuR29HcGrvZqbzg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::eku::ee-anyeku", + "conflicts_with": [], + "features": [ + "pedantic-webpki-eku" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThis chain is correctly constructed, but the EE cert contains an\nExtended Key Usage extension that contains `anyExtendedKeyUsage`,\nwhich is explicitly forbidden under CABF 7.1.2.7.10.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUcDrgUmwKezfNxJPypo+yJuOL46EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASxGgZ8JCugyyQv7LR+jOhPr50zKKIyWs2Ln1yv\nJkjrDdYSJYgAB/gpk7sNgBmQI0vLRzmKhPbEy+aL8d3QNfPPo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUTzdLrH+ar9IKz/fo82BilWdCWxkwCgYIKoZIzj0EAwIDSQAwRgIh\nAJ4phL8heupJRNwrFvft+wQp9msleme5k2PdB/DpU62kAiEApeLTy2AxhJmSTfbx\nqLlUWkrwA5L/W9LLmhfoUsKcSy0=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBuDCCAV6gAwIBAgIUfcDYMDjfll5Wh+q+D9sDuWJVFeswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABALSINAkqrgRKmnM8YT1LU/W63sEbxkknteffOP8MdKq\nM6WUpdl5lxXoX0R++l6ASGBSiq6uOROcnPvdNQvtMk2jgYMwgYAwHQYDVR0OBBYE\nFNlvui+6++SurwwC3nDzvNt7r4ZsMB8GA1UdIwQYMBaAFE83S6x/mq/SCs/36PNg\nYpVnQlsZMAsGA1UdDwQEAwIHgDAZBgNVHSUEEjAQBggrBgEFBQcDAQYEVR0lADAW\nBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiA9ui9sbfWY\nYvRxB318qGcdIZXvL6Q5sIGQ3qI660IgRwIhALxlAwOCOjhjhM67M5QDLkj6BmS/\n3bhSLZTWYvn6WVvA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEINLkuob07oCq7643iyaYEkTpAx3YWuPxS0zXr88jZEPNoAoGCCqGSM49\nAwEHoUQDQgAEAtIg0CSquBEqaczxhPUtT9brewRvGSSe15984/wx0qozpZSl2XmX\nFehfRH76XoBIYFKKrq45E5yc+901C+0yTQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "serverAuth" + ], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::eku::ee-critical-eku", + "conflicts_with": [], + "features": [ + "pedantic-webpki-eku" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThis chain is correctly constructed, but the EE has an extKeyUsage extension\nmarked as critical, which is forbidden per CABF 7.1.2.7.6.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUe3zwCFtqd8AyZX8JMxmG0+0gPjwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARPsDc329bbMO0bcSKbnKV9JrfScwZKW04Y/kIL\nu7xsUeUbDpmCISISXD1mKdkcZuWU2qUrRhUZL6FDEq0U7urbo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUnXlgFX3LNr+R42tF6seso92eLdAwCgYIKoZIzj0EAwIDRwAwRAIg\nLa1gHk8RxZM+nJYbCYbbKED4kEIwjGZYTGoZAYo3T5cCIGR/UKU+DuLOL5LmqMdh\nIsbenza9nG2lGUWqI+B8vowL\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsjCCAVmgAwIBAgIUOWtDYJHf4kZKwImXyNy0dVAt5J8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABNWsX+z3HBiaO0TvPA4q4jryE/GTc52f0M9en7sdsQ7K\nsFoJnnLX+RpzKZMIXwv1T7D1Fbn3tfv9iYoYEo2hB9ijfzB9MB0GA1UdDgQWBBSI\nkfZOylbl89PnWZjkCiQ25DdauTAfBgNVHSMEGDAWgBSdeWAVfcs2v5Hja0Xqx6yj\n3Z4t0DALBgNVHQ8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwEwFgYDVR0R\nBA8wDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgOHOZOR3aGsUqf18n\nYn0u8pX9dmYMb1nB1qXeZZ0X9SkCICGDUYQCZUDttdf2mVNwnmKRLIJ7xP9Ccpsi\nDlUi/Z8t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIOr3iwPTIMDUBX6FA//n2YidSl4r5ipSDy4GQIc5/j7ioAoGCCqGSM49\nAwEHoUQDQgAE1axf7PccGJo7RO88DiriOvIT8ZNznZ/Qz16fux2xDsqwWgmectf5\nGnMpkwhfC/VPsPUVufe1+/2JihgSjaEH2A==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "serverAuth" + ], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::eku::ee-without-eku", + "conflicts_with": [ + "rfc5280::eku::ee-without-eku" + ], + "features": [ + "pedantic-webpki-eku" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThis chain is correctly constructed, but the EE does not have\nthe extKeyUsage extension, which is required per CABF 7.1.2.7.6.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUWqDD6aKtUJl1xxg1NH4gALgxJNswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQfKCJAOxm3K10KOjxphdrzV/OeJwLmjDGMO0VK\nCpfzaFvqXwUc2tIwUkVJPbEnwLEW2Jpv0fOJQlLC/gmz7uhUo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUtO8wwPn3uvJWVtVUvL7gpptAtEgwCgYIKoZIzj0EAwIDRwAwRAIg\nOdNquCL86kaLmvTTt251jJQjztF0r5sdo39bxS1nsW0CIBWlzoNZnl7JdtEHy7AN\ngkr6qTxMXPVz64zBenKTeWmd\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBmjCCAUGgAwIBAgIUHWGWPlqYbBfHvw2hfzPZD12A/UQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABOlynKzOyT2mYNoVAklpXjwF8Ts8imBU0Fqp6/tt6w2i\nAp5ApudXMaQvli1hL6G+KNNY1jfkVr53JB1tAdDikkKjZzBlMB0GA1UdDgQWBBQn\nWwXeyoco+aX00ZAsisDWXrWcYDAfBgNVHSMEGDAWgBS07zDA+fe68lZW1VS8vuCm\nm0C0SDALBgNVHQ8EBAMCB4AwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYIKoZI\nzj0EAwIDRwAwRAIgZf20jA4qDKOsk6NmakYiasyYSxMZzUa8IfWsa7pqEUECICB9\nG2gJyZvYt5XE0EbfVyTSvZ+VZJYBwcRJn5xkO0iK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIEGJfbeRJWYy+AD4ndNqMS6N1MezQHLPx0zULNJALbjMoAoGCCqGSM49\nAwEHoUQDQgAE6XKcrM7JPaZg2hUCSWlePAXxOzyKYFTQWqnr+23rDaICnkCm51cx\npC+WLWEvob4o01jWN+RWvnckHW0B0OKSQg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::eku::root-has-eku", + "conflicts_with": [], + "features": [ + "pedantic-webpki-eku" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert includes the extKeyUsage extension, which is forbidden\nunder CABF:\n\n> 7.1.2.1.2 Root CA Extensions\n> Extension Presence Critical\n> ...\n> extKeyUsage MUST NOT N", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBozCCAUqgAwIBAgIUbLQ6Kbz/rbzlhD0L+e1Z/L27vOswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARJStTy7d+TKqaCYQfwP2cywzkc/WX+XlTZRuIB\n2MrLAUiqmS3EiZX74jgN7VTxLhu+NUFtDze/tBGyXcbJdcvQo2wwajAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUP3jIDCjy1htXG/8o/DTz5cgAjnIwEwYDVR0lBAwwCgYIKwYBBQUH\nAwEwCgYIKoZIzj0EAwIDRwAwRAIgbPbea59rpXtWKKdsSsZbVKWgWZVPsZJWDtGB\nfsYkvTUCIHP+Sk9AUtGseg8d9iGAbDC06GBARdl7m7P/ZTyT32hS\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUNTpvaUSIS7AhQwbmJ1rMm6tO6Y4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABLkNxPm/9bszxLaxeqMe0G46R6my55AQ45xhOW1jQCAP\nHKHunL6TxCA0n8ZTYwMtkSkZFb3/PNLur6CTN2yMXlSjfDB6MB0GA1UdDgQWBBRy\nPRr7E+gASL7nFKdRKA3oXwu8HTAfBgNVHSMEGDAWgBQ/eMgMKPLWG1cb/yj8NPPl\nyACOcjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgWlkpBvVHDV1IaP2Nvo/i\nBdTCVj3TOK72kvmqN0fOgecCIFeYH8MbJbJFavtB241qnxYoH535eDzRcUJqnys+\nD5uG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILNja3R8GupTxFrYnMeRKI4PabcE0EB31bDmg8GRkFB4oAoGCCqGSM49\nAwEHoUQDQgAEuQ3E+b/1uzPEtrF6ox7QbjpHqbLnkBDjnGE5bWNAIA8coe6cvpPE\nIDSfxlNjAy2RKRkVvf880u6voJM3bIxeVA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [ + "serverAuth" + ], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::nc::permitted-dns-match-noncritical", + "conflicts_with": [ + "rfc5280::nc::permitted-dns-match-noncritical" + ], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** chain:\n\n```\nroot -> leaf\n```\n\nThe root contains a NameConstraints extension with a permitted dNSName of\n\"example.com\", matching the leaf's SubjectAlternativeName.\nThe NameConstraints extension is marked as non-critical, which would\nbe a violation of RFC 5280, but CABF explicitly permits this as an\nexception to RFC 5280:\n\n> As an explicit exception from RFC 5280, this extension SHOULD be marked\n> critical, but MAY be marked non-critical if compatibility with certain\n> legacy applications that do not support Name Constraints is necessary.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBqjCCAVGgAwIBAgIUQb8a1WL17gBfOXv1DcfxPXyui24wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAT9eJNOFx1s2t/M3xQ3zi1uJAk3scYGRnq9BTkd\n9lKwfOZ6RdVhDcxnQ9gU6T+NL6mVYNgFyXlv6NP9ZMV8hHkso3MwcTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUhU3TToL22bgU6ochvCeKbjO4CDYwGgYDVR0eBBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAEySlI8VIGabeSawKYVENLCNKZT\nfSGixg27BZE4Ob5HAiBub4xaRoKAs9G9KV1TjmHcdR8ublZYWLW3FluyONw6jg==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrzCCAVagAwIBAgIUX+IXKlsHUjRx4aKQCiMFVdIYnnYwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABCsBpAKGC0vrMqSK3uBBYz3Lfei7Ieuov0ExmYK6C6ao\nAFKnxa0Y9UzV3SEBI6iIthidq8ov3L+mpRxpJva45JmjfDB6MB0GA1UdDgQWBBRc\nyJc9yZvEOZy0gXwmTgwtVXqLwTAfBgNVHSMEGDAWgBSFTdNOgvbZuBTqhyG8J4pu\nM7gINjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgaq0NKNp+13kYw8Pfmbqh\nk0n/eHECLEmxVMk4yQ56XTICIEpDakcYZHam8EKE7MRKcbLTGixIYB5OjEwKIQVr\nUX0o\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIOGivbjr8CvpZc/7qyqBXcYtmL6EfFvSDg9k+Ia7mWTHoAoGCCqGSM49\nAwEHoUQDQgAEKwGkAoYLS+sypIre4EFjPct96Lsh66i/QTGZgroLpqgAUqfFrRj1\nTNXdIQEjqIi2GJ2ryi/cv6alHGkm9rjkmQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::nc::intermediate-permitted-excluded-subtrees-both-null", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate -> leaf\n```\n\nThe intermediate contains a NameConstraints extension with `ASN.1 NULL` for\nboth permittedSubtrees and excludedSubtrees, which is forbidden under\nCABF 7.1.2.5.2.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUW7lasq1dkNtrWN3D5v9BO54Cu5EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAT5Gbbz+vXwjiQ3ZzWmyoQaVfNwZlUGoyYlA6wR\nZ9/Npe8whQiu8mLoXqKg/NBHUQWdUnqNc4V9et5uqWiCGjjgo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUGT6r7eBDXFkX1qq8AVZx/nmh6tEwCgYIKoZIzj0EAwIDSAAwRQIg\nB7Ow+Mj9TOHNNYCk67VL9cykSEJm68ro5OemOZ9jtwICIQCboUixa3Ucp8StXTFN\nvD6a2YPCOVFkFZaWGQ8T7cQ3sw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICEDCCAbagAwIBAgIUNFa6BqoE3OniM4oAeitWwsVO0hcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA1MjM2NTE2OTg5MTMxMzQ5OTcyNjU0\nNTE5MjM2MTc2OTczNzkwNTE2NjIxMzAwNjUxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABAnbHlv2BxrEmMNq39F2AMze3tdphQkitpCbcaIX+1i5WxtsNGkyLKrt0EyF\ngFB0zrK1FhM28CDx8rY3I8AHuoCjgYcwgYQwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUGT6r\n7eBDXFkX1qq8AVZx/nmh6tEwHQYDVR0OBBYEFMeTvlyAyiGvycaXiGhQRywuMwd2\nMAwGA1UdHgEB/wQCMAAwCgYIKoZIzj0EAwIDSAAwRQIgJgDPBBlv1J4vUo6ZbPPp\nWibdrxX4WPIxN3AAlo0AIeoCIQCTZWBmoZg8yF7jhFhKgofmZ4RIIi+6D/TuogFX\nvUb81Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICADCCAaagAwIBAgIUQrf14I7BTogFpm09KQjAWXp6xZkwCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNTIzNjUxNjk4OTEzMTM0OTk3MjY1NDUxOTIzNjE3Njk3Mzc5\nMDUxNjYyMTMwMDY1MS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWHNx89Xcje3hlAtFVQ4PBUEmDCnWnoWw2r41toVfOZtC5NJev5RM/EblNtf1zaOD\nco82P5qOIP/VRAACYVfMdaN8MHowHQYDVR0OBBYEFNYyrQOVrrbeMYlBKXmseuCd\n2u2qMB8GA1UdIwQYMBaAFMeTvlyAyiGvycaXiGhQRywuMwd2MAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNIADBFAiBXW4rSSTzNdINNDdN1oZp7YVlIsq5lui46OVwp2wAw\nFwIhAKn21+2vVRWy9uUgWCDxMrZ2ifeS3kEO08kt9lB6uAsC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILZHoJAC9UM36peEj0RFc7qY0tRooC+1CrxsM1ZmPDQmoAoGCCqGSM49\nAwEHoUQDQgAEWHNx89Xcje3hlAtFVQ4PBUEmDCnWnoWw2r41toVfOZtC5NJev5RM\n/EblNtf1zaODco82P5qOIP/VRAACYVfMdQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::nc::intermediate-permitted-excluded-subtrees-both-empty-sequences", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> intermediate -> leaf\n```\n\nThe intermediate contains a NameConstraints extension with empty sequences for\nboth permittedSubtrees and excludedSubtrees, which is forbidden under\nCABF 7.1.2.5.2.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUUw2nEtbf2Xos4V0Is5P/N/a1m1IwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR/wX7dWrZpdqrGNmHRRzb4gE2Eod/DYa2iGsQW\nZIBJA0wlonLmDEK5lkzt0Z+Qvn6Rxjw3pDnwZY/6x1r9oMdSo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUcyUqXAe2TpeErWu5BSQpkOMuGngwCgYIKoZIzj0EAwIDSQAwRgIh\nALi7CgMadiH1s+PdHpieXyc/mKddHISduEn0PB5iBUXRAiEAh87q8YHtwT8e44d9\nxlglStdy0f/N8ADmOXo98YhCAg8=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgIUBTbHosj0V7D4Uq9SZbfsOhkRaX0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDA0NzQxNTA2OTc4Mjg0MDk4NzE0MTAz\nMDgxMDUzMjQxOTQxNjYwNzc0Mjc5MTU2MDIxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABB/afXX/sUrlT/rtO2RSpwQtd4znVzlW6JeWFdx8a/33F3yh/U1KHoTsgLTP\nIkuQCE4oJEDOkhrQ7KUtjAor9AKjgYswgYgwDwYDVR0TAQH/BAUwAwEB/zALBgNV\nHQ8EBAMCAgQwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHwYDVR0jBBgwFoAUcyUq\nXAe2TpeErWu5BSQpkOMuGngwHQYDVR0OBBYEFKiXpqgOqAw3DY3DTOXk5RtDzrdS\nMBAGA1UdHgEB/wQGMASgAKEAMAoGCCqGSM49BAMCA0kAMEYCIQCvw4V70z8i8in9\nbjT/HlwTRF8y+uzvf+nftjll51W/XgIhAK8f+NtNPFl/rJY5l3E+gORhRC5J1ife\nUHEAuPZJNbHf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB/zCCAaagAwIBAgIUCsSyU+hab75VEWrEiz2CB0HUEfowCgYIKoZIzj0EAwIw\najE5MDcGA1UECwwwNDc0MTUwNjk3ODI4NDA5ODcxNDEwMzA4MTA1MzI0MTk0MTY2\nMDc3NDI3OTE1NjAyMS0wKwYDVQQDDCR4NTA5LWxpbWJvLWludGVybWVkaWF0ZS1w\nYXRobGVuLU5vbmUwIBcNNzAwMTAxMDAwMDAxWhgPMjk2OTA1MDMwMDAwMDFaMBYx\nFDASBgNVBAMMC2V4YW1wbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nk13k/E8qNZXgNLhLswtJaKk0f7aBGehTgjv8lAyIL/7e9T527RViGYVEMbxEmteE\npIaOl8NJUvI/cd4IafOQ16N8MHowHQYDVR0OBBYEFKamzC6DRfkCYOmqlcwVClmc\nvOCZMB8GA1UdIwQYMBaAFKiXpqgOqAw3DY3DTOXk5RtDzrdSMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNHADBEAiBgFe16//VjL9qDhgk5Bux2HhysdWxCZrUpdxWm62h0\nbwIgcBr2csPG6sFRJ59yVqLU31upylWVhRCOJ2OsJ5jXm84=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIJgngL4s7uEpiLSnz6oajEStLDADDRmTY3M2QbCxaaPaoAoGCCqGSM49\nAwEHoUQDQgAEk13k/E8qNZXgNLhLswtJaKk0f7aBGehTgjv8lAyIL/7e9T527RVi\nGYVEMbxEmteEpIaOl8NJUvI/cd4IafOQ1w==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::nc::nc-permits-dns-san-pattern", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **valid** graph:\n\n```\nroot -> ICA (permit: foo.com) -> EE (SAN: *.foo.com)\n```\n\nCABF does not specify how Name Constraints and SAN patterns compose\n(the latter is not specified at all), but their compatibility is a logical\nconclusion of the following rules:\n\n1. A DNS Name Constraint matches `name` as well as zero or more sublabels\n2. A DNS SAN pattern of `*.name` matches exactly one sublabel\n3. Therefore, any DNS NC of `name` will always match all `*.name` SANs", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUC9sa5JKQHejGemO0HTLZfKF00pgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR69TUzMVdxn/vjjW03fMW4zIW/XotAanw/+Ly2\nAPdiZDbn7Wso+5MI61LH5ucq2yJ5JxeosvG2luxeqHVkl20ro1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUZ1wDCZHeFepLHGXl+PIBqd9BzOUwCgYIKoZIzj0EAwIDSQAwRgIh\nANiCAv7PeTNIzbA5ukmqg0cXATUaW2yU3aKW4Wzyc6T9AiEAv/FxPk52jew9Nz8P\nbiFL+UU70UhE0OXzQqLArff9xCo=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICBTCCAaygAwIBAgIUFF1qusp6hEXUEUJnb52LAJyALmIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBpMTgwNgYDVQQLDC82NzY4NTEwNDM3NjE2OTkwOTczOTQw\nODMyMDM4OTkzNzIwNDc0MjQ5OTY1MjI0ODEtMCsGA1UEAwwkeDUwOS1saW1iby1p\nbnRlcm1lZGlhdGUtcGF0aGxlbi1Ob25lMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYbidO0GD7NBLh00HcAWEg2rwobzF6PDbYXyglDhU2SLtnYa6CNB9h1MOtARt\nunPF5QXZM1RGiG7gbVNRH80a76N/MH0wDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8E\nBAMCAgQwHwYDVR0jBBgwFoAUZ1wDCZHeFepLHGXl+PIBqd9BzOUwHQYDVR0OBBYE\nFFUkdGCfVE3qXYCjhDTKLhYjTh4EMB0GA1UdHgEB/wQTMBGgDzANggtleGFtcGxl\nLmNvbTAKBggqhkjOPQQDAgNHADBEAh8rQKS+LnSnW7DC6v/TH/+ABmztWCejLlbj\n3yajiHNQAiEAnJDEuaKu0CwOulAw/oTnS9IJnOJOWy/djrseytLwrnI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICATCCAaegAwIBAgIUIAIFtr4hamyZ2GGpk6Axsa2IoZ8wCgYIKoZIzj0EAwIw\naTE4MDYGA1UECwwvNjc2ODUxMDQzNzYxNjk5MDk3Mzk0MDgzMjAzODk5MzcyMDQ3\nNDI0OTk2NTIyNDgxLTArBgNVBAMMJHg1MDktbGltYm8taW50ZXJtZWRpYXRlLXBh\ndGhsZW4tTm9uZTAgFw03MDAxMDEwMDAwMDFaGA8yOTY5MDUwMzAwMDAwMVowFjEU\nMBIGA1UEAwwLZXhhbXBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATH\nKFrinSh0Ixnrl0p/dV3HMOBBxfVb7rffk+JIjOMBuhYTAhGKrW2FAM4RwZWCTDee\noxNxc1ulcDWlKZ+360E9o34wfDAdBgNVHQ4EFgQUjzlHaJE+9bqAUaiGMOYFkl0P\nvCUwHwYDVR0jBBgwFoAUVSR0YJ9UTepdgKOENMouFiNOHgQwCwYDVR0PBAQDAgeA\nMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBgGA1UdEQQRMA+CDSouZXhhbXBsZS5jb20w\nCgYIKoZIzj0EAwIDSAAwRQIhAIQfzNE4MbLYNgpYGlej6vA8wAmi9s2qTft1cnUS\nxETqAiBbISIyPNNUTexXoZZyVHCD3oJGIehDoRWmaevv9GXTlA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIMj+mmpdqp8+KcUrV2/nSOBLsoqpByyWLEH5qrEHHW+roAoGCCqGSM49\nAwEHoUQDQgAExyha4p0odCMZ65dKf3VdxzDgQcX1W+6335PiSIzjAboWEwIRiq1t\nhQDOEcGVgkw3nqMTcXNbpXA1pSmft+tBPQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::exact-dns-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with a valid EE cert for `example.com`.\n\nThis EE cert contains a Subject Alternative Name with the dNSName \"example.com\".\nThis should verify successfully against the domain \"example.com\", per\nRFC 6125 6.4.1.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUKr5Zqze8Z76mPBQzwCexrTLeW0owCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATkA0pjDTCDiik/h3xgCop16h9tk+TKzI4mpEbV\n7s/hJrMDjS/1C+MbmbE5C9bZvnDr3icu2EYsjRirUQUNErwno1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUi/SgO3JkdPNs1YgY+M/PLoNdrjkwCgYIKoZIzj0EAwIDRwAwRAIg\nYRGdKvFTn/z1rOnrakxWgLSNJjmqzQTSfdpwUIVQtwUCIHSfxFpAjIPUOfVA2aEk\nmzFTCURKm76EqkfXgaSealUz\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUaO99dlYbnl7HjK3csE+oyTUl6f8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABOjIM3wjaXIvyr5AY4owfK/4z9PRYszrJF1llHXewMv+\nQEwG4ofheQMZngEU1sO6S5XNw37v0oE48YzMv+PSc5ajfDB6MB0GA1UdDgQWBBSg\n/FgZeu4YzKjfHzH8wY+yPycfOzAfBgNVHSMEGDAWgBSL9KA7cmR082zViBj4z88u\ng12uOTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAMaO2wlraDFVYnMpeTcb\nAJIzZyb1W+utZkhdfjzfr3pDAiBVcWHJ9AdSGd0xtiDCEY1qb64Or/78VTlHpuTV\n/14sBw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIGYxU3MlabBlHEaQDxuWHbe52L/QjrhHUa21x8+O/Jt2oAoGCCqGSM49\nAwEHoUQDQgAE6MgzfCNpci/KvkBjijB8r/jP09FizOskXWWUdd7Ay/5ATAbih+F5\nAxmeARTWw7pLlc3Dfu/SgTjxjMy/49Jzlg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::exact-localhost-ip-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with a valid EE cert, for IP 127.0.0.1, i.e. localhost.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUDV7+1c7kiCri+FfEL+xfSp8RoAcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATBfdTHJVO022YzCpZyYrfmRsljtMSdatrSWHRf\ni2PUBg6tTpAD+X2SLHLTNDjfPPY3Zl9TLuMvhL4gBD6Y6x8No1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU14G1JmU6uE5VsabwxCFLkFKHTuIwCgYIKoZIzj0EAwIDSQAwRgIh\nAKeMjh/IKIkldJGinJhtuM+a05H6sCD+8Ga8/fcYNr/hAiEAyA9YmdOILFJStnvI\nxK9CfJo3l3iMzmhxhh1uz8dqb/s=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBqTCCAU+gAwIBAgIUKtMQyAro9E8xA9VW0L4w+rAxoZkwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABHuGrj8oB2fONPexdZrbcDCV4xAC7cl/rSj6iHLLy7Dg\n3krO49wSBzMVuiNrjQEQQRx96HlvTaXSNJo8rwNknVejdTBzMB0GA1UdDgQWBBRN\nQT5le9XlFIndAefP4Pv4q9aoLDAfBgNVHSMEGDAWgBTXgbUmZTq4TlWxpvDEIUuQ\nUodO4jALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA8ZIdnMzAN1Cn0L07MqW+DNP375O5\nZUwijVKzgaAihZECIHOgvxvOhuLpuVu2vSfiWUIYJFkgWfVNlUIiqhPs5fXp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIE61Btn74C/e7Ii6G6EWqTIQhqnBdmafSA/yQzaHn54MoAoGCCqGSM49\nAwEHoUQDQgAEe4auPygHZ84097F1mttwMJXjEALtyX+tKPqIcsvLsODeSs7j3BIH\nMxW6I2uNARBBHH3oeW9NpdI0mjyvA2SdVw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::mismatch-domain-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName `example.com`.\nThis should **fail to verify** against the domain `example2.com`, per RFC 6125 6.4.1.\n\n> Each label MUST match in order for the names to be considered to match,\n> except as supplemented by the rule about checking of wildcard labels.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUV0tmuJySIztZNi+we2INjulnSZQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARKF3K6Rz8384sPDnfxsUWhY4oTaHMaKZT/8gZM\nQgd4MIYRW6HesJODFoUTltBIDwW8Uw0K/VXGjwIQl7QiE4zUo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU+eyp7/0jDf7D7yEWVEAXiBWZPlowCgYIKoZIzj0EAwIDSAAwRQIg\nUM9HtKq+3l2mNlyHHjGUDcpkrYN+XikfVGsB1Mrwo2oCIQDGQiIoBZdNXqH59ctq\nbHNkPF9SL82gFojjJtgHNSk+pg==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUboQbDKxyIfvp5iyjyKfaCiKEUf8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABKtPUbP3b7Jw8tmovEhqS5NXCf52AqC5gpriNj0tqCtL\n2FVxGwMxO/lm1BG2LuVMwSJTY6Fh3cljMDZUNg32tmujfDB6MB0GA1UdDgQWBBS8\nvtnnhN92nHpkonRk7fB7z328gzAfBgNVHSMEGDAWgBT57Knv/SMN/sPvIRZUQBeI\nFZk+WjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAL+qS5gSwY7EomyDe5e7\njEaakUNcpljI/m3pM9bwzYLpAiB6oh8EwcmnN8mUmWSRTTbn/AOFFk0DWHYLQW/W\nuImNgA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIOu3NDCIu+2L2DTha/QdDEdVFpcmgqcnXZETuGWiyf3ToAoGCCqGSM49\nAwEHoUQDQgAEq09Rs/dvsnDy2ai8SGpLk1cJ/nYCoLmCmuI2PS2oK0vYVXEbAzE7\n+WbUEbYu5UzBIlNjoWHdyWMwNlQ2Dfa2aw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example2.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::mismatch-subdomain-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName `abc.example.com`.\nThis should **fail to verify** against the domain `def.example.com`, per RFC 6125 6.4.1.\n\n> Each label MUST match in order for the names to be considered to match,\n> except as supplemented by the rule about checking of wildcard labels.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUf7AcykmSQ8Ptfni7GHXjtMsp8vQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAT9bwLetEUqFxuMCUOcoUuzplIfE1/L33JCzHvT\nw20ew+UUbJKgGFoCW0X6uSqin8t0EN349jwHCUguV1pqZFPKo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUBsIkNp2FYSvuRl2TfeR+B2PDQwcwCgYIKoZIzj0EAwIDSQAwRgIh\nAO6YfTLL8MttC2CI1CVATcK1G+r1yG3eLk2MVvyEX3Z/AiEAo6B7jd7BEEAPGbTa\nz55KYsW5vOS1mfuaWWZ/YxBbBRg=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtTCCAVugAwIBAgIUXcrdd27Exk+jM5aGPxMaHQWlSV4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABCsSBkGIg/WNxwDcNKAfcnl9r+EvLfVUz5cF1voW33Ab\nMsXH/Kbt/K0ZanF3Awa2I8A07O0Che4+RXLRFPE26NejgYAwfjAdBgNVHQ4EFgQU\nAT/znVvLmpCntBJwQJ7c67+GF+IwHwYDVR0jBBgwFoAUBsIkNp2FYSvuRl2TfeR+\nB2PDQwcwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBoGA1UdEQQT\nMBGCD2FiYy5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAixZVMKpUFBVX\nljmxQqHYa0T+txG3elWf3vCWuCDuddACIC87J17d0bRhvZwKtBYUTEAurZYqkuOJ\nQotlQp5lPPJ6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIBFXodvo2B6nAkHLjt4TFg6KYIRRP5QpteeO4wAkHoF2oAoGCCqGSM49\nAwEHoUQDQgAEKxIGQYiD9Y3HANw0oB9yeX2v4S8t9VTPlwXW+hbfcBsyxcf8pu38\nrRlqcXcDBrYjwDTs7QKF7j5FctEU8Tbo1w==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "def.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::mismatch-subdomain-apex-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName `example.com`.\nThis should **fail to verify** against the domain `abc.example.com`, per RFC 6125 6.4.1.\n\n> Each label MUST match in order for the names to be considered to match,\n> except as supplemented by the rule about checking of wildcard labels.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIULheB+PuUrUS2UZt2XNlBy/J49E4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARc2medtHm4GmLRp2ENijo+7hZ2NB/y3ocV5OTH\nZEuB7hohgp8oMTJowTN/7ploltZqTH9WcfgCpnd+6O1rDCBno1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUFfbPRb5b/XDemwUxxJurgIwEhOIwCgYIKoZIzj0EAwIDSAAwRQIh\nAKqOmP0q3bIHOWI5wB087kr6rWc0hQX0N5mm1oB6tp1kAiBAxSC3y9NyOc9SUTaA\nvrKhshwk3tFVieStQ0LoMos7fQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsDCCAVagAwIBAgIUQhD0WoTb67djuUyvXiNhJR02HyswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABP0jAPriNbMT677pkJAykrOobm1eXpuNNzJsR9wfDPIk\nNfEQqzRBdsqc/bWl4TBpms8sSWWxWKQUn1W5p0bXg/ijfDB6MB0GA1UdDgQWBBT7\n9Jlk9Vh16rBmP+5rI6L7e88UyjAfBgNVHSMEGDAWgBQV9s9Fvlv9cN6bBTHEm6uA\njASE4jALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhANkpgVd8LqSI8Zq4Lrog\n9sgmswqKjneGjeO3yAR3eAOxAiAQJ4zrfv/WBGGEIP32BDrvw78oBSAT4It0Tn91\n1I3GdQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIyATaVH3sHL3CLwx6PnfvLsc3B2j5yNi6h+7oyLeiPOoAoGCCqGSM49\nAwEHoUQDQgAE/SMA+uI1sxPrvumQkDKSs6hubV5em403MmxH3B8M8iQ18RCrNEF2\nypz9taXhMGmazyxJZbFYpBSfVbmnRteD+A==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "abc.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::mismatch-apex-subdomain-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName `abc.example.com`.\nThis should **fail to verify** against the domain `example.com`, per RFC 6125 6.4.1.\n\n> Each label MUST match in order for the names to be considered to match,\n> except as supplemented by the rule about checking of wildcard labels.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUdlXO+9rHr0oe81DbD7UPXnVsRsUwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARiwl1WUiRtsbtAipP9E3PlJGQphnpNbaaHJCOT\nPTgUezbz5eVNEe5UiJvE8uDNk6/3L2gjmorv/LJHf/3MtoaPo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUZmvpH5rQzy9OEBxUNK6Nnv4gYO4wCgYIKoZIzj0EAwIDSQAwRgIh\nAKEEt0cIszNcl314QPNDtpCkA8m3g0NSgH1GP9JsViEWAiEA3iyGrIQRKVrcNywk\n3LU/XpqPk/xZMzq18gb/HaIDy3M=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtTCCAVugAwIBAgIUHNdEOJPNXk6WVtqHsuY78YOYG4QwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABCybQjp61Kg9bBAOQlG/zI6okcUG4CMtL93XhaTKnLR+\nf/QJrWIZb85qgyPM918SMdhd0AfOp0aJizG1jqkB3JGjgYAwfjAdBgNVHQ4EFgQU\nxPMG6ysoMy1zis7dwoc5K+Giij0wHwYDVR0jBBgwFoAUZmvpH5rQzy9OEBxUNK6N\nnv4gYO4wCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBoGA1UdEQQT\nMBGCD2FiYy5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA/vzFb8nebasA\nSEhKJCgAlGF+OH1f6ht89gIYoHC4Nu4CIFaCSoOBin/33nIyGIqfl2e/pnfKN01S\n9IkpkfVF0RpQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIHEhWLVw+eJD51yS2PnDmFc6SVqQUUl4NHJqEPNCmh1ToAoGCCqGSM49\nAwEHoUQDQgAELJtCOnrUqD1sEA5CUb/MjqiRxQbgIy0v3deFpMqctH5/9AmtYhlv\nzmqDI8z3XxIx2F3QB86nRomLMbWOqQHckQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::public-suffix-wildcard-san", + "conflicts_with": [], + "features": [ + "pedantic-public-suffix-wildcard" + ], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative name with the dNSName `*.com`.\nConformant CAs should not issue such a certificate, according to CABF:\n\n> If the FQDN portion of any Wildcard Domain Name is “registry‐controlled”\n> or is a “public suffix”, CAs MUST refuse issuance unless the Applicant\n> proves its rightful control of the entire Domain Namespace.\n\nWhile the Baseline Requirements do not specify how clients should behave\nwhen given such a certificate, it is generally safe to assume that wildcard\ncertificates spanning a gTLD are malicious, and clients should reject them.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUNowbCRGh3u02F3ttzhLs9DppcDgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATEKEQXhGih15gCrlvuBRpavVkpYerKerLqDe7z\nRP2F5NwFGfw/GgXD79MO/FOG0daNX51OL07EgbFYTiXyIV9Do1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUU2oAHUjO5NBamsIzptg+xnfjWzEwCgYIKoZIzj0EAwIDSQAwRgIh\nANPnPxbAi5MN0PjMikid1s6jsin2HIgEYDjJ4LOmE1KMAiEAilMdBraPpHa29B0n\nQMni1nCf/r48IBp+Q6TJ5/lHQnU=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBqzCCAVCgAwIBAgIUFgiT8DxAq3b+3pF11iBHp1iVx8MwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABGuPdjQ9uEIqm6HwoYYzoXq+tlt4n8MgejFixWMyBzJT\n230OHEvNmMHFTSEU7GNlXfrO63dg90qO9LoHiELyIDKjdjB0MB0GA1UdDgQWBBRI\n0tDcU0Z/9w4D/VMGi5rIBARkgTAfBgNVHSMEGDAWgBRTagAdSM7k0FqawjOm2D7G\nd+NbMTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwEAYDVR0RBAkw\nB4IFKi5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAMOBzuwU3bCGMIbYqFq6ugaqQM57\nTJKRGBEt8HHEG1MeAiEAvVMRzAgkdE2LnhFJAkb+OLcMKOKq/bg8D/SA7CYXkVw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEINTaKFzJKmBNC0N2yT4dSyFrbyzOeHg2pXTdKdDPkyXEoAoGCCqGSM49\nAwEHoUQDQgAEa492ND24QiqbofChhjOher62W3ifwyB6MWLFYzIHMlPbfQ4cS82Y\nwcVNIRTsY2Vd+s7rd2D3So70ugeIQvIgMg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::public-suffix-multi-label-wildcard-san", + "conflicts_with": [], + "features": [ + "pedantic-public-suffix-wildcard" + ], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName `*.co.uk`.\nLike the `*.com` case, conformant CAs should not issue such a certificate,\nper CABF, and clients should reject it.\n\nUnlike the `*.com` case, the wildcard here is followed by two labels.\nImplementations that approximate the \"public suffix\" rule with a simple\n\"wildcard must be followed by at least two labels\" heuristic will\nincorrectly accept this certificate; rejecting it requires a real PSL\nlookup (or an equivalent enumeration of multi-label public suffixes).", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUf0tErYabq4ovlujJPs2JdV6dw34wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQsouX96auFowvnhxCREyrs9s6pTvOiEVEJwilt\nUyHx3Rgwuc5l/9ho1gS9jwiWw9+Eq0DPzsnfzAes+9Rcn0/vo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU7VAM1TJLQYuPnsu69BcPUpjd0EUwCgYIKoZIzj0EAwIDSAAwRQIg\nZZQOh+Pfpeiif24Dn9/G5nlWuvUIU1iSe+Eu44oSzWUCIQCBOw/m15z+LbmQwpyF\nysvEqs22+fCztYwkbO5CQXgWSw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBrDCCAVKgAwIBAgIUer+si1BTHUdZ/hXTBneeMQR+oMgwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABOieO1nwoSm6mhNa8sbgd4P1CQBqqfVTnsdjtEQDLd9H\nWEPEAlXxMyt6A4VcKC5sw4p3jDWrd9jH5YV5WZ6DxY6jeDB2MB0GA1UdDgQWBBS3\n0urxFVYFh3wtmVWRgL/iCvznezAfBgNVHSMEGDAWgBTtUAzVMktBi4+ey7r0Fw9S\nmN3QRTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwEgYDVR0RBAsw\nCYIHKi5jby51azAKBggqhkjOPQQDAgNIADBFAiEAr2ye0+q8G8ls3h6lrWopmoXM\niDhwMRcc9HY1RUZzrr4CIE+D193LHPzxuvjJbP7pSGdSuLGZWdtPf3HgVKL4RpK6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIAZQ4asMpkKaPRmHnC3huAF1k5HDBXarQA+EyM4yOJHcoAoGCCqGSM49\nAwEHoUQDQgAE6J47WfChKbqaE1ryxuB3g/UJAGqp9VOex2O0RAMt30dYQ8QCVfEz\nK3oDhVwoLmzDineMNat32MflhXlZnoPFjg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.co.uk" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::public-suffix-private-namespace-wildcard-san", + "conflicts_with": [], + "features": [ + "pedantic-public-suffix-wildcard" + ], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName\n`*.s3.amazonaws.com`. The `s3.amazonaws.com` suffix is listed in the\nPublic Suffix List's PRIVATE DOMAINS section, so per CABF a conformant\nCA should not issue this certificate and clients should reject it.\n\nThe wildcard here is followed by three labels, so neither a \"≥2 labels\"\nnor a \"≥3 labels\" heuristic suffices to reject it. Doing so correctly\nrequires consulting the PSL (including its private-domains section).", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUNjxg/T3f/D2AALvEbhRfIaROECIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR9Q70nikoEzaCKsQftuDKuv7mDxM2gQOBS1YCj\ntajmPfLe2Y2wzZtwk6QILzpx2c27HuTMbLOD0NaU9brFV1u4o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUjX6xN0ttkKDw/P3/HVV7BJ2HkmcwCgYIKoZIzj0EAwIDRwAwRAIg\nArD6bs1xzp4hLgA+7lv6TYUEIeqNZcR8zY4hasjuxWICIH/0gkJuka8YhumTQwox\nfHqbjyCHLVn0nrsW7ingRXyW\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBujCCAV+gAwIBAgIUUnCKZT7N1rlzYZfyWG8ofH5rdQwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABEAtyY9tZmL2IJZ17HRlBBMktsGNoMdhlG05C5ZRVh7m\n4UiTEO5peE/xdtbyrQfv/tYSHuJya7ceiL8HV3XAM8WjgYQwgYEwHQYDVR0OBBYE\nFPEpF2VviVLuNLUSQLHyoxEjY48hMB8GA1UdIwQYMBaAFI1+sTdLbZCg8Pz9/x1V\newSdh5JnMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAdBgNVHREE\nFjAUghIqLnMzLmFtYXpvbmF3cy5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAMYiCbs3\n8lwCiJ6ybTGaNOPFsY0gT35GlXonMv4CYXNWAiEAn0UHnp9VBhRcpfyWId+8evwu\nHn2RNgMco9LmX/ZOOPM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIG1iAaWXo0I+cEMQqY2WJBFaOm3KWR7HwZ3OlTGYWeXjoAoGCCqGSM49\nAwEHoUQDQgAEQC3Jj21mYvYglnXsdGUEEyS2wY2gx2GUbTkLllFWHubhSJMQ7ml4\nT/F21vKtB+/+1hIe4nJrtx6IvwdXdcAzxQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.s3.amazonaws.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::leftmost-wildcard-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName `*.example.com`.\nThis should verify successfully against the domain `foo.example.com`, per RFC 6125 6.4.3.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUM95Rk6hn2YnoGmVKTAZkiz7AJEQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR+hEqt+f3ZM9vNxbvNWF6VNYT8bJXInM1ICytQ\nIeNdulggHca4QJfBFPwqeR6/PaKSmB2eWE7WSGYrv9ekWA3Yo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUnO09QLZyiF5E5lVhAQuERwXZNJ8wCgYIKoZIzj0EAwIDSAAwRQIg\nPJGBpIDIkma+7BM2QsglBailyFGKlVbm9wKhKXiFnT4CIQD8wFfZC9vSV/VqUPYY\nAjeApRjbZ7j94lbrv8EbE9V0pQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVigAwIBAgIUSe6nOXuC8bsmTQ6nfmlvaLNLnZMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABPviQDiLJO77wU9QLeX3p0r2/ayPZwZE4P1GrgjS0FRL\nyDNdbuC9ZeS3tB8zUK7Fu6ElSSJmdhp+pOEJ1xQNsCijfjB8MB0GA1UdDgQWBBS+\nBQ8+Dnzhy9pa41YaDa2VTSOwkjAfBgNVHSMEGDAWgBSc7T1AtnKIXkTmVWEBC4RH\nBdk0nzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwGAYDVR0RBBEw\nD4INKi5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBjFUAHVvpAQnXogxl5\njR45/2XDlWdf3WUWs/PK3u9KLgIgLr8rOaRqOSbpZ5/rX5UBOxcW3CbB1mFRhVq9\nm7NqGQ4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIA16V5xjMGVo10LtIw5Ut+SGEvhaZnDzYrsAWH9nsl7moAoGCCqGSM49\nAwEHoUQDQgAE++JAOIsk7vvBT1At5fenSvb9rI9nBkTg/UauCNLQVEvIM11u4L1l\n5Le0HzNQrsW7oSVJImZ2Gn6k4QnXFA2wKA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::wildcard-embedded-leftmost-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName `ba*.example.com`.\nThis should **fail to verify** against the domain `baz.example.com`, per CABF.\n\n> Wildcard Domain Name: A string starting with “*.” (U+002A ASTERISK, U+002E FULL STOP)\n> immediately followed by a Fully-Qualified Domain Name.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUKkMmwkciigfDBAlWCgr+DZlE/sQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASQZ1QL6tgkGQsg+NNzjW86Ph5LC3zKseeLsfLi\nd85JLCJ/KRg6VFC2i6eLMcOBSpgEKGIZTZ9RUkm8bbSn379Yo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUz6FgNlNCZt6QbE55oHlRlR59oUYwCgYIKoZIzj0EAwIDSAAwRQIh\nAKd1D1vZIhCX830t7UjnfWGdSF3MTFVvneUi28LlD6rEAiBNJlH1BuEyXX9qy8wJ\nIG4CxEMgumH6fmj3zeq1Ca6Bxw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtjCCAVugAwIBAgIUeEH0ik4dpqINTU9NOO36+B3rMh8wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABGkXVskJ6+S+2cNUyADqcNYDk8a1YL3TpmCwJOOvD6+e\nZuogByn+ss9hxI1z/GbkV7nK6hY0vHgJFDv45cytQUajgYAwfjAdBgNVHQ4EFgQU\n5/1fKoJSQwQ2uDRSODTL+1ZckyowHwYDVR0jBBgwFoAUz6FgNlNCZt6QbE55oHlR\nlR59oUYwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBoGA1UdEQQT\nMBGCD2JhKi5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAp6phPa7w2i1z\njwLx2yZBzwvEJMogepa6xkg7YuXa27ACIQDftAT/DdeUsgOfl8IEfjBnHl1eY1yU\n0d07qPjtcTQjxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIIyASYCTI44Whr6C6HaiTngv5pyHfcjBpdsJUCmXSzgqoAoGCCqGSM49\nAwEHoUQDQgAEaRdWyQnr5L7Zw1TIAOpw1gOTxrVgvdOmYLAk468Pr55m6iAHKf6y\nz2HEjXP8ZuRXucrqFjS8eAkUO/jlzK1BRg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "baz.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::wildcard-not-in-leftmost-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName `foo.*.example.com`.\nThis should **fail to verify** against the domain `foo.bar.example.com`, per RFC 6125 6.4.3.\n\n> The client SHOULD NOT attempt to match a presented identifier in\n> which the wildcard character comprises a label other than the\n> left-most label (e.g., do not match bar.*.example.net).", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUcUNPxNNoJtU70z1wjUoH+Wh5cLAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAT+yrzMcZ676gNCcYLFPjYPTXdiRaz2pnpN/hY6\nTZSD49anUDDMDmi+mDOEjyng45waY0FnG3O0fWYtpPwxS+1po1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUSesoj1LWrnsJcnSqQ6vrGHeZpxUwCgYIKoZIzj0EAwIDSAAwRQIg\nO/zUOITTQErPYgwrJchFZf7SJYlUsKGBxx/Rh62sHQUCIQCjxN0bZDVRvYijtVfF\nudlYUVShJBLH0fi14yvPIa99Kw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBuDCCAV6gAwIBAgIUDr1rJZ+f0r47xH5Ty+9squnub8owCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABDNQmIJRZzzNjU+M4bmBceWm3cm4ZJE63xxcgnoKGkfS\n9O4g6jut8rc966dd7wONBbO3L6xiPdoRUDwfR6hFyi6jgYMwgYAwHQYDVR0OBBYE\nFIIFYU2UJCwE+Q3f25g3gngvCWb8MB8GA1UdIwQYMBaAFEnrKI9S1q57CXJ0qkOr\n6xh3macVMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAcBgNVHREE\nFTATghFmb28uKi5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAvE829P5+\nHdUP37c3Co7305fcrvdt5araEbTmJAnyzuwCICX4/3kPD8Od0HBKGQyZ08w378zZ\nW3eWE6PbmdzZbmhA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIG5ZkzmXTpluIP4fST9y+cXs/J+QqQKm+X6L8iSP6dqPoAoGCCqGSM49\nAwEHoUQDQgAEM1CYglFnPM2NT4zhuYFx5abdybhkkTrfHFyCegoaR9L07iDqO63y\ntz3rp13vA40Fs7cvrGI92hFQPB9HqEXKLg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.bar.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::wildcard-match-across-labels-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName `*.example.com`.\nThis should **fail to verify** against the domain `foo.bar.example.com`, per RFC 6125 6.4.3.\n\n> If the wildcard character is the only character of the left-most\n> label in the presented identifier, the client SHOULD NOT compare\n> against anything but the left-most label of the reference\n> identifier (e.g., *.example.com would match foo.example.com but\n> not bar.foo.example.com or example.com).", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUGFqwCaslES1w867nl0tBIHLBDYEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAT+e2P5RjEvSgYsfZZzl7SAIDy6Ng8QzI3q2+s1\nAgOXpSaiGBK+FKFowFYxThtRpkTKRcFHrat+ndX9aWzavNS6o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUvqfPOd8QmPdutYwMDBGURE7zO6wwCgYIKoZIzj0EAwIDRwAwRAIg\nLiHJSjgL/YAv7woEaNmFHJLKxxlJr3nCEsqKQCX1sdQCIA7H4grbL0T2MHpLfWYc\nEO5pDiDZW3iieC0lkUALep++\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsjCCAVigAwIBAgIUJMTeyZEdTM6KEu4LPyNbsHi0Wy4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABIAIlwp8iffoSLyCftu8/X3VsTE8FsbsO1YUaBYbjWOH\nWhJsfSBDwy96xDmjyEsMvl+2udGXedzOecGYj7IZT4GjfjB8MB0GA1UdDgQWBBSt\ndNE815BkQbb4VHabF0rbL86BzDAfBgNVHSMEGDAWgBS+p8853xCY9261jAwMEZRE\nTvM7rDALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwGAYDVR0RBBEw\nD4INKi5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA2Kn7ae6yIu7mpSR2\nRofKBpYmvF7fpj4Qr6OJozivQG4CIA5/6vd3wmRjPvjc+OTk6fQm6eGd+doenBBu\nTHJBNYNi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDAiJ6tAoGCAeIq0c75RhFVHZnHx/z0reWL8yi06y3gMoAoGCCqGSM49\nAwEHoUQDQgAEgAiXCnyJ9+hIvIJ+27z9fdWxMTwWxuw7VhRoFhuNY4daEmx9IEPD\nL3rEOaPISwy+X7a50Zd53M55wZiPshlPgQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "foo.bar.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::wildcard-embedded-ulabel-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName\n`xn--*-1b3c148a.example.com`. This should **fail to verify** against the domain\n`xn--bliss-1b3c148a.example.com`, per RFC 6125 6.4.3:\n\n> ... the client SHOULD NOT attempt to match a presented identifier\n> where the wildcard character is embedded within an A-label or\n> U-label [IDNA-DEFS] of an internationalized domain name [IDNA-PROTO].", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUN72FLhlPEzeXHeuZYGbVwPmte/AwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARV7TjIUT2cI1+BcL3nBqqeHHpI5BNgBCZXsl/J\nY3ApDEbceVQK3J+I+SCyU9PBEwSRVr/m5XUCMSKAtU9rZqE/o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUgH1XFnfehh6mFk8XKiEUxIYzZY8wCgYIKoZIzj0EAwIDSAAwRQIg\nabV1qTz7RoeinVjRszL3PlwmdTaZRC7syUQuBYVtOcwCIQCeg8x6kmQW9TCvy711\n6qRfuhHw6lvtF8R1t0IGO5rIlQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBwDCCAWegAwIBAgIUa0ZpnLRJCf3mw+IOFZJbQJS9gDowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABOfvMkzQxVaCJvlxnmi2UJqHkeUiMe+l2AXbEWC2Nut3\nusbJGKBBHQEcdbdIUqB11ASVLmzPAetg3sQWZWL1lTWjgYwwgYkwHQYDVR0OBBYE\nFND5+6Z4g5gQf4A975RumOhBLdubMB8GA1UdIwQYMBaAFIB9VxZ33oYephZPFyoh\nFMSGM2WPMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAlBgNVHREE\nHjAcghp4bi0tKi0xYjNjMTQ4YS5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBE\nAiAKjiKGGYRTAtKPm2R4TpbNFChEIPT5/Qy6TK1Utv0l4gIgGzybMuo4P2m6V2eK\nMMT0/6B0EFUNhVfCW7aMe+Njv+Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIBCzDz0PPFLTeuyro9vT35kOIgDeBs8LuISDfZmvdHc7oAoGCCqGSM49\nAwEHoUQDQgAE5+8yTNDFVoIm+XGeaLZQmoeR5SIx76XYBdsRYLY263e6xskYoEEd\nARx1t0hSoHXUBJUubM8B62DexBZlYvWVNQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "xn--bliss-1b3c148a.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::unicode-emoji-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains a Subject Alternative Name with the dNSName `😜.example.com`,\nThis should **fail to verify** against the domain `xn--628h.example.com`,\nper RFC 5280 7.2:\n\n> IA5String is limited to the set of ASCII characters. To accommodate\n> internationalized domain names in the current structure, conforming\n> implementations MUST convert internationalized domain names to the\n> ASCII Compatible Encoding (ACE) format as specified in Section 4 of\n> RFC 3490 before storage in the dNSName field.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUPYBaju5QsrZ4MuM09pogW7oa3RAwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATQM9oT53HqCpu4JqnJqscCLplcbgbun0FaFmkq\nVeJtxnDIYV8x+wXoBvhuiuwmSOApt8Xc3Rv3gu/lB+JiAGp8o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUvjNeUAhJ40CNtnCBoY0lDFdKosUwCgYIKoZIzj0EAwIDSAAwRQIh\nAMcSG4z5mU8h4TmG+DKWL+cvtoA4P75bfDEhWUqQZPzAAiBw4ONy0/ETGzd3ssEt\nrlwllx1Kb+mlEtPgXw7zggRQiw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtTCCAVygAwIBAgIUKs0pxN+yBLW0++LRqFuqc1rFfNEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABOxkd4+E1tiFQP96HZsruj7nTCy7CX0KPu1AYiunQZid\nOv1OmzCm1F3v5v3kZvQZGFB+uxOGQrGxYGthMVuO30WjgYEwfzAdBgNVHQ4EFgQU\nEbb8JOwO7cXESPkkMhBywrPCaswwHwYDVR0jBBgwFoAUvjNeUAhJ40CNtnCBoY0l\nDFdKosUwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBsGA1UdEQQU\nMBKCEPCfmJwuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIgBqZ0I1oiejUS\nCxirAT3orEMurNPV1YkmOgDfQuuH+MsCIBQ6sfjD4n7hF4gi4qjciEUxTjR/3Ygi\nCazgOZnC1iYk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIC05G1n+iPSGwFBJXN7LD7byFu56J3TFF/zsjFQd/4SWoAoGCCqGSM49\nAwEHoUQDQgAE7GR3j4TW2IVA/3odmyu6PudMLLsJfQo+7UBiK6dBmJ06/U6bMKbU\nXe/m/eRm9BkYUH67E4ZCsbFga2ExW47fRQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "xn--628h.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::no-san", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe chain is correctly constructed, but the EE cert does not have a\nSubject Alternative Name, which is required. This is invalid even when\nthe Subject contains a valid domain name in its Common Name component.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUTyG60IY2CABKIwKsFcSNlebRdrcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARu6qoMzUf8HMhbMwH2GnEYGDxuNL43KjZ9Qna2\n7azDsDTknQlq6/gwZADVFBN+iE7mUyAEAHXS6eRjpbmOSp+lo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUFg4Mz1Sh3Z/9KUDrtg+ERHqkYxgwCgYIKoZIzj0EAwIDRwAwRAIg\nfkdd9NHDwI9GDyJ9t7QAjsSMsGQ7yEvz7zzGEOzrIxICIBG7Kd4w0PNmWfChq+du\n3cvVfraJtx69F3KhRqlBsTEX\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBmDCCAT6gAwIBAgIUMeVrdx/2FiizL4cvMFTySGhwZb4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABFDR7edIM2yI/v/UXE6RH17OGAXq21jPbtNzs83ralwJ\nHwl5DiPFgFDhCgIk3OyNfi/nffcrmJrxh7os3QlHev2jZDBiMB0GA1UdDgQWBBRo\nK38SlCsN4bzYY59pew2w7FpDGDAfBgNVHSMEGDAWgBQWDgzPVKHdn/0pQOu2D4RE\neqRjGDALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwCgYIKoZIzj0E\nAwIDSAAwRQIgK+JALs11WjvZ05sLjZ+OXZulLP8l8p3DK0vqDQZTxpICIQCol5W1\nG54MaZl3DmGKLlhm0wB/UQ2YLsOXP5AhIEAeew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDiDWT+oTYnUt9OmMtjNnMR/O1+fwuhESa75zP1AuPH8oAoGCCqGSM49\nAwEHoUQDQgAEUNHt50gzbIj+/9RcTpEfXs4YBerbWM9u03OzzetqXAkfCXkOI8WA\nUOEKAiTc7I1+L+d99yuYmvGHuizdCUd6/Q==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::san-critical-with-nonempty-subject", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE cert includes a critical subjectAlternativeName extension, which\nis forbidden under CABF when the subject is non-empty:\n\n> If the subject field of the certificate is an empty SEQUENCE, this\n> extension MUST be marked critical, as specified in RFC 5280,\n> Section 4.2.1.6. Otherwise, this extension MUST NOT be marked\n> critical.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUdUHKIoO1vfC3+U8Q5QIf7h3ZPQQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARIRlvMGkIInnljDH5A7fGW8NBnz2BJvGhGvF6w\n68rRKlwdz0it3pDPEMK4Vxwu9Yf12kXcv5apyyZQ46x3/x4go1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUFMW0O0oMA34SYjvhQOsNu7ieVbAwCgYIKoZIzj0EAwIDRwAwRAIg\nNjcrM8ppOhvMPdcsvpiuKvu04kE3I0T8G0U/cId8FO8CIGaXdptfuNHW7guPM+//\n+vIhy71sG/lPHs+0b9MAbqK5\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBtjCCAVygAwIBAgIUHboTlTtC4Y0enHoOmigwP+w8La4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAZMRcwFQYDVQQDDA5zb21ldGhpbmctZWxzZTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABD5QUCRFRlTCyrvZ8xQYl6jOElpKiC4DB+GeXouX\ngRIYUyBdZsRiMBqyFgZnS6kTLk7Ci60aDkK7i0sCyc8IA0CjfzB9MB0GA1UdDgQW\nBBTot8maFEufm+VWjALY3ovHHIRz/DAfBgNVHSMEGDAWgBQUxbQ7SgwDfhJiO+FA\n6w27uJ5VsDALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwGQYDVR0R\nAQH/BA8wDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhANhtkZadtug7\nLJzyMybGgDxSXeNKZoTRynwsx0yMdviHAiBOxOusPfFixhOVj82Cwl2HNAVz9D0B\nd2MMK7WKrd//uQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIDyXuj4LO81S7ihKicb4CMSMNFgd8Kwzq3O4jmVcs8ADoAoGCCqGSM49\nAwEHoUQDQgAEPlBQJEVGVMLKu9nzFBiXqM4SWkqILgMH4Z5ei5eBEhhTIF1mxGIw\nGrIWBmdLqRMuTsKLrRoOQruLSwLJzwgDQA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::san-wildcard-only", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE cert contains a SAN of just `DNS:*`, which should be rejected.\n\nThe reason for this is subtle: CABF 3.2.2.6 notes that certs with\nwildcards on public suffixes should not be issued, and `.` (i.e. the DNS\nroot) is effectively a public suffix. This is true even though the DNS\nroot is not itself on the PSL.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUPQV2egfDSNED5uySaznK+ONwBtcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASSavtMPlgY9DRqLfuH6D+e2/y/BdiMaKdqAfEU\nQFmLTYwIoP7QHI4ftXRh89SGzRSEbjvpEIBXQrjLJhBEDIUGo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUfiznIt1HqeGdZnjZZgQu4P7TzsswCgYIKoZIzj0EAwIDSAAwRQIh\nAIa4+rO74xTytYrHMSHBbIQbrfjCILLl9yd1dyenngDTAiBf6/+E6fVrCscTVPxb\niL45jYTZoZRsKVU4HAugcEeBAQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBpjCCAUygAwIBAgIUApHmI0OrwM8Mj9noWHqpRfD1O4EwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABO2snxUknu0CW4kDW6nxMWo826vF0D3BZ/FkVZMVeADI\nhsb0yEKNfHYdgugmG+skFO6Niaxq4PmQLFj0Fi51THqjcjBwMB0GA1UdDgQWBBQS\nZEmhkt6JUUTVRzEtwUVXQ3FwhDAfBgNVHSMEGDAWgBR+LOci3Uep4Z1meNlmBC7g\n/tPOyzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0RBAUw\nA4IBKjAKBggqhkjOPQQDAgNIADBFAiAzvgjLcIKL66hKPoIXz6T6D6rIJSYG7nvN\nsKCoD3+yqAIhAM/1zPebJaNHXFH17PH3XzS407YiSsxoTBs27SlA1+5F\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIPb1jC5lNmbjfQmh9cPMxuG0qgsxGHS9QcRVrnfJV/VXoAoGCCqGSM49\nAwEHoUQDQgAE7ayfFSSe7QJbiQNbqfExajzbq8XQPcFn8WRVkxV4AMiGxvTIQo18\ndh2C6CYb6yQU7o2JrGrg+ZAsWPQWLnVMeg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::san::san-wildcard-only-tld", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE cert contains a SAN of just `DNS:*`, which should be rejected.\n\nThe reason for this is subtle: CABF 3.2.2.6 notes that certs with\nwildcards on public suffixes should not be issued, and `.` (i.e. the DNS\nroot) is effectively a public suffix. This is true even though the DNS\nroot is not itself on the PSL.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUaz60ed0157mqphxoERfI9t2GDI4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARGH9S9cKrq3gSkUDqctUKPSCSEebNfv0ayNPf7\nuyChEGw1hd41MJuH2+TKdi/Ou/9d3csEdb38BJMVgppL1vHoo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUcWabwHChZQ5QJdNb7nnFowWrzTgwCgYIKoZIzj0EAwIDSQAwRgIh\nAMdE9GMXN+pCegEWcenqdAiN/1seY0dkidKu8e8jedgCAiEA5JJgWmAnGTCyqyBS\n/v5K6K7tsuRes8V7OM70G+jlYsg=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBpjCCAUygAwIBAgIUDZxSkm6vdWn3PtBFx2QMAZ5bWi0wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABPH26RbH8sSJVbyKeCzi2thd7N4lhjC40S+Xq5BHmIvY\n6t4ux+JxAgDmAU0oTh9jiILssd9zPGUq2IWYFWs1XzWjcjBwMB0GA1UdDgQWBBTe\n1VeWLA9R4tw0ksalYnynxVk6+jAfBgNVHSMEGDAWgBRxZpvAcKFlDlAl01vuecWj\nBavNODALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0RBAUw\nA4IBKjAKBggqhkjOPQQDAgNIADBFAiEAhaCngQEgWtJIPyIeAfA8T41OJjThqRXl\n4YsL0ANCgIwCIGKm0wxunbvQCMwcxysxDjWRGLZHhYCd0I+k1BceyvHC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIHWwUK1AUlLN3Qo/TNBrdgWrvdJWi2n/eoX02R9dzUmEoAoGCCqGSM49\nAwEHoUQDQgAE8fbpFsfyxIlVvIp4LOLa2F3s3iWGMLjRL5erkEeYi9jq3i7H4nEC\nAOYBTShOH2OIguyx33M8ZSrYhZgVazVfNQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::explicit-curve", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nBoth root and EE convey EC keys using the \"explicit\" curve encoding,\nwhich is forbidden under CABF 7.1.3.1.2:\n\n> The CA SHALL indicate an ECDSA key using the id‐ecPublicKey\n> (OID: 1.2.840.10045.2.1) algorithm identifier. The parameters MUST use\n> the namedCurve encoding.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIChDCCAiqgAwIBAgIUOlFUnEuz7jLK9sT/idTpv8HSbaMwCgYIKoZIzj0EAwIw\nJjEkMCIGA1UEAwwbeDUwOS1saW1iby1leHBsaWNpdC1lYy1yb290MB4XDTI0MDMx\nMjE5NDk1N1oXDTI1MDMxMjE5NDk1N1owJjEkMCIGA1UEAwwbeDUwOS1saW1iby1l\neHBsaWNpdC1lYy1yb290MIIBSzCCAQMGByqGSM49AgEwgfcCAQEwLAYHKoZIzj0B\nAQIhAP////8AAAABAAAAAAAAAAAAAAAA////////////////MFsEIP////8AAAAB\nAAAAAAAAAAAAAAAA///////////////8BCBaxjXYqjqT57PrvVV2mIa8ZR0GsMxT\nsPY7zjw+J9JgSwMVAMSdNgiG5wSTamZ44ROdJreBn36QBEEEaxfR8uEsQkf4vObl\nY6RA8ncDfYEt6zOg9KE5RdiYwpZP40Li/hp/m47n60p8D54WK84zV2sxXs7LtkBo\nN79R9QIhAP////8AAAAA//////////+85vqtpxeehPO5ysL8YyVRAgEBA0IABC2E\n3wiuGhZ3RF5Kw/3AUaRHO5ybITRqrl8xWZJF8k1H9Vq+8PI7CIG/MYMJppYNH/sl\nnK3s1RrkpffH5cJAqB6jQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD\nAQH/MB0GA1UdDgQWBBTtkZG9GKH0NpdP3t0IlXXzOxaYxTAKBggqhkjOPQQDAgNI\nADBFAiEAxJTXk+uFOQbaxfYfltBHopKTKRp5LxLW12G7oy4yaGACIFcbeD6T2Ykl\nD1CL8R3j6ebCnE+pBeQ2XqUkVySjpviD\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICyzCCAnGgAwIBAgIUJqkzKauUZilx3XKm1fhjkquuQLgwCgYIKoZIzj0EAwIw\nJjEkMCIGA1UEAwwbeDUwOS1saW1iby1leHBsaWNpdC1lYy1yb290MB4XDTI0MDMx\nMjE5NDk1N1oXDTI1MDMxMjE5NDk1N1owFjEUMBIGA1UEAwwLZXhhbXBsZS5jb20w\nggFLMIIBAwYHKoZIzj0CATCB9wIBATAsBgcqhkjOPQEBAiEA/////wAAAAEAAAAA\nAAAAAAAAAAD///////////////8wWwQg/////wAAAAEAAAAAAAAAAAAAAAD/////\n//////////wEIFrGNdiqOpPns+u9VXaYhrxlHQawzFOw9jvOPD4n0mBLAxUAxJ02\nCIbnBJNqZnjhE50mt4GffpAEQQRrF9Hy4SxCR/i85uVjpEDydwN9gS3rM6D0oTlF\n2JjClk/jQuL+Gn+bjufrSnwPnhYrzjNXazFezsu2QGg3v1H1AiEA/////wAAAAD/\n/////////7zm+q2nF56E87nKwvxjJVECAQEDQgAEfMmSp9aLYgFQMT8Hz9zOjqNT\nB58DBs9wrVoNstn4Msduype5/8OGxHeUIS6tTgkh0Eh48R4ucFGUW/yAxadlNKOB\nmDCBlTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUF\nBwMCMAwGA1UdEwEB/wQCMAAwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wHQYDVR0O\nBBYEFDNdrS5piqv/yUCBn4iSt+RkQcwgMB8GA1UdIwQYMBaAFO2Rkb0YofQ2l0/e\n3QiVdfM7FpjFMAoGCCqGSM49BAMCA0gAMEUCIGKslZ6HQB2dsitu8urUMni9Voc2\nL6oj5Kd6FJzEtuW9AiEAgCcY/hESTmlD0KrScVC47uLmRl4rZKQY7EWXZ11TaZs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2024-03-13T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cryptographydotio-chain", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Verifies against a saved copy of `cryptography.io`'s chain. This should\ntrivially succeed.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw\nTzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh\ncmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4\nWhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu\nZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY\nMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc\nh77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+\n0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U\nA5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW\nT8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH\nB5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC\nB5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv\nKBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn\nOlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn\njh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw\nqHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI\nrU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq\nhkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL\nubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ\n3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK\nNFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5\nORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur\nTkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC\njNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc\noyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq\n4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA\nmRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d\nemyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIFFjCCAv6gAwIBAgIRAJErCErPDBinU/bWLiWnX1owDQYJKoZIhvcNAQELBQAw\nTzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh\ncmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMjAwOTA0MDAwMDAw\nWhcNMjUwOTE1MTYwMDAwWjAyMQswCQYDVQQGEwJVUzEWMBQGA1UEChMNTGV0J3Mg\nRW5jcnlwdDELMAkGA1UEAxMCUjMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\nAoIBAQC7AhUozPaglNMPEuyNVZLD+ILxmaZ6QoinXSaqtSu5xUyxr45r+XXIo9cP\nR5QUVTVXjJ6oojkZ9YI8QqlObvU7wy7bjcCwXPNZOOftz2nwWgsbvsCUJCWH+jdx\nsxPnHKzhm+/b5DtFUkWWqcFTzjTIUu61ru2P3mBw4qVUq7ZtDpelQDRrK9O8Zutm\nNHz6a4uPVymZ+DAXXbpyb/uBxa3Shlg9F8fnCbvxK/eG3MHacV3URuPMrSXBiLxg\nZ3Vms/EY96Jc5lP/Ooi2R6X/ExjqmAl3P51T+c8B5fWmcBcUr2Ok/5mzk53cU6cG\n/kiFHaFpriV1uxPMUgP17VGhi9sVAgMBAAGjggEIMIIBBDAOBgNVHQ8BAf8EBAMC\nAYYwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1UdEwEB/wQIMAYB\nAf8CAQAwHQYDVR0OBBYEFBQusxe3WFbLrlAJQOYfr52LFMLGMB8GA1UdIwQYMBaA\nFHm0WeZ7tuXkAXOACIjIGlj26ZtuMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEFBQcw\nAoYWaHR0cDovL3gxLmkubGVuY3Iub3JnLzAnBgNVHR8EIDAeMBygGqAYhhZodHRw\nOi8veDEuYy5sZW5jci5vcmcvMCIGA1UdIAQbMBkwCAYGZ4EMAQIBMA0GCysGAQQB\ngt8TAQEBMA0GCSqGSIb3DQEBCwUAA4ICAQCFyk5HPqP3hUSFvNVneLKYY611TR6W\nPTNlclQtgaDqw+34IL9fzLdwALduO/ZelN7kIJ+m74uyA+eitRY8kc607TkC53wl\nikfmZW4/RvTZ8M6UK+5UzhK8jCdLuMGYL6KvzXGRSgi3yLgjewQtCPkIVz6D2QQz\nCkcheAmCJ8MqyJu5zlzyZMjAvnnAT45tRAxekrsu94sQ4egdRCnbWSDtY7kh+BIm\nlJNXoB1lBMEKIq4QDUOXoRgffuDghje1WrG9ML+Hbisq/yFOGwXD9RiX8F6sw6W4\navAuvDszue5L3sz85K+EC4Y/wFVDNvZo4TYXao6Z0f+lQKc0t8DQYzk1OXVu8rp2\nyJMC6alLbBfODALZvYH7n7do1AZls4I9d1P4jnkDrQoxB3UqQ9hVl3LEKQ73xF1O\nyK5GhDDX8oVfGKF5u+decIsH4YaTw7mP3GFxJSqv3+0lUFJoi5Lc5da149p90Ids\nhCExroL1+7mryIkXPeFM5TgO9r0rvZaBFOvV2z0gp35Z0+L4WPlbuEjN/lxPFin+\nHlUjr8gRsI3qfJOQFy/9rKIJR0Y/8Omwt/8oTWgy1mdeHmmjk7j1nYsvC9JSQ6Zv\nMldlTTKB3zhThV1+XWYp6rjd5JW1zbVWEkLNxE7GJThEUG3szgBVGP7pSWTUTsqX\nnLRbwHOoq7hHwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIFJDCCBAygAwIBAgISBCjrgR1TEHICklNpQDzj1PqPMA0GCSqGSIb3DQEBCwUA\nMDIxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQswCQYDVQQD\nEwJSMzAeFw0yMzA1MjkxODQ0MDBaFw0yMzA4MjcxODQzNTlaMBoxGDAWBgNVBAMT\nD2NyeXB0b2dyYXBoeS5pbzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\nAObo0GReSiFFL4eMlFHutcV+LpLDorPpzzFxxJsXhrm19GyWYHdr4ml7GIAEjqI7\nQZp0aYw1lmtHwgNnaRySU+aWj6LMWI/rIP5rXZYIZLyXSfLbHP0xlfYEvcrcprOm\nAu0YuQgy3TBO0qz6FKx5PtfbDc7p/LYD5tnG5NkbQ4o+7Ko361w787WSb8OV5NFd\nnPqSeIjwxqSy62G6oOHL4wRFDTCOdNjHeYJnPC0L3P9qkGeC6zjqt2h8Q+GE9zNQ\nenqaEOeBIZo46mti6Tvzzc7dqILw1ATqIXJdjwABzuT8Ob34/LsPorLQoRP1+YHF\n++D2JyyvYKM/aFpQI+HHfGUCAwEAAaOCAkowggJGMA4GA1UdDwEB/wQEAwIFoDAd\nBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAdBgNV\nHQ4EFgQUOtGXHs6fLoMQEwjlwSu88r4qLf0wHwYDVR0jBBgwFoAUFC6zF7dYVsuu\nUAlA5h+vnYsUwsYwVQYIKwYBBQUHAQEESTBHMCEGCCsGAQUFBzABhhVodHRwOi8v\ncjMuby5sZW5jci5vcmcwIgYIKwYBBQUHMAKGFmh0dHA6Ly9yMy5pLmxlbmNyLm9y\nZy8wGgYDVR0RBBMwEYIPY3J5cHRvZ3JhcGh5LmlvMEwGA1UdIARFMEMwCAYGZ4EM\nAQIBMDcGCysGAQQBgt8TAQEBMCgwJgYIKwYBBQUHAgEWGmh0dHA6Ly9jcHMubGV0\nc2VuY3J5cHQub3JnMIIBBAYKKwYBBAHWeQIEAgSB9QSB8gDwAHcAtz77JN+cTbp1\n8jnFulj0bF38Qs96nzXEnh0JgSXttJkAAAGIaQn30wAABAMASDBGAiEAglrQJj8G\na7/1upmZ2Is6AqPT9pQpSty0sH4PgnqyQxICIQDEpKnk6Rt6KzvEpIIIEtXgrYx+\ncrerlx4SQVQbnwfz0gB1AHoyjFTYty22IOo44FIe6YQWcDIThU070ivBOlejUutS\nAAABiGkJ9+sAAAQDAEYwRAIgaLwFE4CfhV09wq5IR5zmo/90y5OQJ2MnW5gpRZZh\ns4YCICEAGxUN/f95xFmxOCfqXv3SEozwkrMHA33abVjCQiaGMA0GCSqGSIb3DQEB\nCwUAA4IBAQBSTN5U/3yp6cGMBXlS5WcrB/XOY6TtxPmeSvLM3vqNbpRGu1JOFFtn\n31eweHOTj66GWowSy9+uAhp1V9Uf0hoJMa/b+CkCelyJN4QZCcMfhKrPAD4prbHa\nGYFaLo5SQqkK1hYHo9LH+qhaOBx9hF5aLrGbEFWXQE9/W7KSeCzz6LBLw9xVrB2v\nNTLlXXt5tUiczOIzge5KGaSQr5wgc1viddcRsYuZjtgWlqJ5E5QcZxD8xLTfBe5W\n9vl/k1CB4CZ1IG8Sa9+n91Kxm3HTLL6TcrEOutChwMfZfrLH/piWoRQxezCpn82N\nRaeeHd1Bv3oH3SeVJUHLxgzUv/dh6GSi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2023-07-10T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [ + "digitalSignature" + ], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "cryptography.io" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::cryptographydotio-chain-missing-intermediate", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Verifies against a saved copy of `cryptography.io`'s chain, but without its\nintermediates. This should trivially fail.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw\nTzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh\ncmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4\nWhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu\nZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY\nMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc\nh77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+\n0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U\nA5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW\nT8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH\nB5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC\nB5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv\nKBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn\nOlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn\njh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw\nqHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI\nrU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq\nhkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL\nubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ\n3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK\nNFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5\nORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur\nTkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC\njNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc\noyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq\n4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA\nmRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d\nemyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIFJDCCBAygAwIBAgISBCjrgR1TEHICklNpQDzj1PqPMA0GCSqGSIb3DQEBCwUA\nMDIxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQswCQYDVQQD\nEwJSMzAeFw0yMzA1MjkxODQ0MDBaFw0yMzA4MjcxODQzNTlaMBoxGDAWBgNVBAMT\nD2NyeXB0b2dyYXBoeS5pbzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\nAObo0GReSiFFL4eMlFHutcV+LpLDorPpzzFxxJsXhrm19GyWYHdr4ml7GIAEjqI7\nQZp0aYw1lmtHwgNnaRySU+aWj6LMWI/rIP5rXZYIZLyXSfLbHP0xlfYEvcrcprOm\nAu0YuQgy3TBO0qz6FKx5PtfbDc7p/LYD5tnG5NkbQ4o+7Ko361w787WSb8OV5NFd\nnPqSeIjwxqSy62G6oOHL4wRFDTCOdNjHeYJnPC0L3P9qkGeC6zjqt2h8Q+GE9zNQ\nenqaEOeBIZo46mti6Tvzzc7dqILw1ATqIXJdjwABzuT8Ob34/LsPorLQoRP1+YHF\n++D2JyyvYKM/aFpQI+HHfGUCAwEAAaOCAkowggJGMA4GA1UdDwEB/wQEAwIFoDAd\nBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAdBgNV\nHQ4EFgQUOtGXHs6fLoMQEwjlwSu88r4qLf0wHwYDVR0jBBgwFoAUFC6zF7dYVsuu\nUAlA5h+vnYsUwsYwVQYIKwYBBQUHAQEESTBHMCEGCCsGAQUFBzABhhVodHRwOi8v\ncjMuby5sZW5jci5vcmcwIgYIKwYBBQUHMAKGFmh0dHA6Ly9yMy5pLmxlbmNyLm9y\nZy8wGgYDVR0RBBMwEYIPY3J5cHRvZ3JhcGh5LmlvMEwGA1UdIARFMEMwCAYGZ4EM\nAQIBMDcGCysGAQQBgt8TAQEBMCgwJgYIKwYBBQUHAgEWGmh0dHA6Ly9jcHMubGV0\nc2VuY3J5cHQub3JnMIIBBAYKKwYBBAHWeQIEAgSB9QSB8gDwAHcAtz77JN+cTbp1\n8jnFulj0bF38Qs96nzXEnh0JgSXttJkAAAGIaQn30wAABAMASDBGAiEAglrQJj8G\na7/1upmZ2Is6AqPT9pQpSty0sH4PgnqyQxICIQDEpKnk6Rt6KzvEpIIIEtXgrYx+\ncrerlx4SQVQbnwfz0gB1AHoyjFTYty22IOo44FIe6YQWcDIThU070ivBOlejUutS\nAAABiGkJ9+sAAAQDAEYwRAIgaLwFE4CfhV09wq5IR5zmo/90y5OQJ2MnW5gpRZZh\ns4YCICEAGxUN/f95xFmxOCfqXv3SEozwkrMHA33abVjCQiaGMA0GCSqGSIb3DQEB\nCwUAA4IBAQBSTN5U/3yp6cGMBXlS5WcrB/XOY6TtxPmeSvLM3vqNbpRGu1JOFFtn\n31eweHOTj66GWowSy9+uAhp1V9Uf0hoJMa/b+CkCelyJN4QZCcMfhKrPAD4prbHa\nGYFaLo5SQqkK1hYHo9LH+qhaOBx9hF5aLrGbEFWXQE9/W7KSeCzz6LBLw9xVrB2v\nNTLlXXt5tUiczOIzge5KGaSQr5wgc1viddcRsYuZjtgWlqJ5E5QcZxD8xLTfBe5W\n9vl/k1CB4CZ1IG8Sa9+n91Kxm3HTLL6TcrEOutChwMfZfrLH/piWoRQxezCpn82N\nRaeeHd1Bv3oH3SeVJUHLxgzUv/dh6GSi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2023-07-10T00:00:00+00:00", + "signature_algorithms": [], + "key_usage": [ + "digitalSignature" + ], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "cryptography.io" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::malformed-aia", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces a chain with an EE cert.\n\nThis EE cert contains an Authority Information Access extension with malformed\ncontents. This is **invalid** per CABF.\n\n> The AuthorityInfoAccessSyntax MUST contain one or more AccessDescriptions.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUZ134ISECbYNXCD+1U0DPB9eJ0CIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATAlaPd1EDVQm46p9YW0MRUSukRr2P+6bDrLXB8\nO6fZOHJjivaquN2+I4tIRbsK9g7ueUXv4a4qa7iGdrUVll/Ko1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUr5+kuPl/cb3D3O25FfNdJLqp1kQwCgYIKoZIzj0EAwIDRwAwRAIg\naNIyHo0DpvcNv7GOBbHci4g8f4zvxpHZORWy6jUYC+QCIHmm/auQnQuZUgTeG7VC\nXMcIWAUESj6OzRvAksdRLoyX\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIByjCCAW+gAwIBAgIUVHKAx/bAEeBxfflyUAI1j4qoA1IwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABEDKsWpb7tYeEPKtaeXBr8ch/6DTMUnHraHV5rwT4nZT\nC8RTwiJ+UgiikRlIKqD4k2d+y2iNMo7igprw9CyS0UOjgZQwgZEwHQYDVR0OBBYE\nFABsZbw9VWLAXbl+yon4EET0tobrMB8GA1UdIwQYMBaAFK+fpLj5f3G9w9ztuRXz\nXSS6qdZEMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREE\nDzANggtleGFtcGxlLmNvbTAVBggrBgEFBQcBAQQJbWFsZm9ybWVkMAoGCCqGSM49\nBAMCA0kAMEYCIQCpkQFZ2+XPKaDHrbnvFCMqUqn05nZ2N9VQ5ETlp99KRQIhAOVU\n/UKDKBJwyJz8tiAN6vV3i7DfvWoSJOIxR5cMXIMF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEICrcL4Ew8zmtBJvYgEozDO+xmkL8T1RLM2uQ6bdGOTYDoAoGCCqGSM49\nAwEHoUQDQgAEQMqxalvu1h4Q8q1p5cGvxyH/oNMxScetodXmvBPidlMLxFPCIn5S\nCKKRGUgqoPiTZ37LaI0yjuKCmvD0LJLRQw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::forbidden-p192-root", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert conveys a P-192 key and signs for the EE with it,\nwhich is not permitted under the CABF's key or signature types.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBcDCCASWgAwIBAgIUMhxxlkSscV6BD0rWoqp5o4158rowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwSTATBgcq\nhkjOPQIBBggqhkjOPQMBAQMyAAR7NMAqtBxBLJjEWAcFWS70gVjC7PaTY1zGxvzA\n07vCY73g5baQs3ATrjgto11OVG2jVzBVMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgEGMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB0GA1UdDgQWBBTLnJNqpgXE\nWFIoBQI0Nuf2rI2oeTAKBggqhkjOPQQDAgM5ADA2AhkAgiEEBQa8zE49oJvcdNBY\nQdTxo90K4RCyAhkAtQBwcZoW+gCniZ1nu4w9IOQhNUcxpMcS\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBoDCCAVagAwIBAgIUfQFvGjtWufkOb/ocSfB9c3Y+nLcwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABDpN3BsEiU+ouqXi8MNsss0ACjgJMCd+GoHvI7JslKcv\nMy0qLbvuruXt6BMCipPiuvX38Cu1rhzVcuFL2rrjSMujfDB6MB0GA1UdDgQWBBTe\noXfElXzkPSoEnBYy5LAggt3gGzAfBgNVHSMEGDAWgBTLnJNqpgXEWFIoBQI0Nuf2\nrI2oeTALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0RBA8w\nDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDOAAwNQIYEEMIzyZeqdPiea26aOm+\net7kb/Ev4HTDAhkAnORZngEpWOdazwEmetKWE18owBEBvNs+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIKrEtgQ35myl4UCyNPUKG/8jX5uetgFa0h5eFVUIqYYKoAoGCCqGSM49\nAwEHoUQDQgAEOk3cGwSJT6i6peLww2yyzQAKOAkwJ34age8jsmyUpy8zLSotu+6u\n5e3oEwKKk+K69ffwK7WuHNVy4UvauuNIyw==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::forbidden-p192-leaf", + "conflicts_with": [], + "features": [ + "pedantic-webpki-subscriber-key" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE cert conveys a P-192 key, which is not one of the permitted\npublic keys under CABF.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUbbic6jjhGKwukDqJ4Kc0xYKhRoEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARmh0H73Dq3B0CdI2KemzXhpf+l8CnAt9ayMUR9\nEl80DhYB6uO2KAw8JiIY/ri64Zwq4FPjRR5KSXphFJ6a2zSKo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUDLi4Ml7TTbdpAARjOLyYNiAPpUUwCgYIKoZIzj0EAwIDSQAwRgIh\nALcfwizYa3CpKe5EXmv4s4/khYfzgbia2/h3hbiTdy2HAiEArj/DqkBdkIufSXh7\n2XAhrMJ77robFmo7leqoS4jJBZs=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBoDCCAUagAwIBAgIUZuGpVsg6Sbt5sQkEAWG3kRT8+NMwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBJMBMGByqGSM49\nAgEGCCqGSM49AwEBAzIABNDKKdD4k0IyuCBHJH3eJg2OvLNXiaDx1j6QKGD4Tiim\nxn7wz4uhapfrN7ubH0B1gaN8MHowHQYDVR0OBBYEFM1dfPUcSM1HwK73+rxPQdZ+\nVlGJMB8GA1UdIwQYMBaAFAy4uDJe0023aQAEYzi8mDYgD6VFMAsGA1UdDwQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAK\nBggqhkjOPQQDAgNIADBFAiAGFJkkHA2BoKp65300FMzu6HTcJCswwk0CEQbE4WtY\nDAIhAOqQxu/B55DBNz9K+H11xGsP9tK+9UASWukvCo2K6FQR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMF8CAQEEGKRn6oO1Hv8ykOuY4wg0qi/vl46hndzaFaAKBggqhkjOPQMBAaE0AzIA\nBNDKKdD4k0IyuCBHJH3eJg2OvLNXiaDx1j6QKGD4Tiimxn7wz4uhapfrN7ubH0B1\ngQ==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::forbidden-dsa-root", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert conveys a DSA-30272 key and signs for the EE with it,\nwhich is not permitted under the CABF's key or signature types.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----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\nh6g9+E8=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBsTCCAVegAwIBAgIUd8z3y5bxRFY+oIOQXTbT4/NRIxYwCwYJYIZIAWUDBAMC\nMBoxGDAWBgNVBAMMD3g1MDktbGltYm8tcm9vdDAgFw03MDAxMDEwMDAwMDFaGA8y\nOTY5MDUwMzAwMDAwMVowFjEUMBIGA1UEAwwLZXhhbXBsZS5jb20wWTATBgcqhkjO\nPQIBBggqhkjOPQMBBwNCAASDaMzbN9Gja6Qenqpj0KegNbqxYHmQAr/t5nxXNG9j\nUm4CtVpDk3zFu5GMgOz21VFqw8YaHmBoLuMj162qScgeo3wwejAdBgNVHQ4EFgQU\nxvG9Iusd3D24HJpgBW6n0/CFiqcwHwYDVR0jBBgwFoAUiGNiwuwK1LUrtEHBoNeJ\nU1oSZ5owCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBYGA1UdEQQP\nMA2CC2V4YW1wbGUuY29tMAsGCWCGSAFlAwQDAgNHADBEAiAiJRVTWNDl7b/qkBEZ\nTqIHxGEUVohpzL2mpLav9A1BtQIgMqnhnFwrFM4DA41aw80x4ov5ac+0poZtRkhD\n81Lv2fk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIC00geJ8tEB5tdWSlTdghdvpVCydXNnfrQSv/NJkSKrGoAoGCCqGSM49\nAwEHoUQDQgAEg2jM2zfRo2ukHp6qY9CnoDW6sWB5kAK/7eZ8VzRvY1JuArVaQ5N8\nxbuRjIDs9tVRasPGGh5gaC7jI9etqknIHg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::forbidden-dsa-leaf", + "conflicts_with": [], + "features": [ + "pedantic-webpki-subscriber-key" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE cert conveys a DSA key, which is not one of the permitted\npublic keys under CABF.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUIBJsHpFLobNiYK9vsd+iHw2CrBwwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASVoz8XhHPw7xNRLYQUkf3KZhO5ysh1ygz6G1jv\nJWT2IqviYVTsmfryTyBWmamWu/9RNPBsS+mzB4OnIQvJOJcco1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUlZyuxZ+k7rqC0JEa7UY/lefGegAwCgYIKoZIzj0EAwIDSAAwRQIg\nODLeWlNIukKsoSM6AQgZp2poOq9PGF7BzAWgCn1l154CIQCcDaqtAl3f802Q3miw\nCw8ii/OKFO258ofn4+LR/kPeFw==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\nPPzkAiEAvY5EUHrU5X3ONGoPVLLDD0OolotF++LQ0M/yBoaBoFs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN DSA PRIVATE KEY-----\nMIIE1wIBAAKCAYEAv00PnIz9TTcZQLiiDhiKFPnAvpOc4Uk2RVnBT76DHevl48hi\nVw1SkoSGdHp7l8mIsuJYb+R5eZ2c2J2h1WdCLBhL9EgX6pCX2lt4eZdudZNRNKiF\nJuTPc1KNT6naMSTo/vaqfpty1XDwx8d/2TZnBZQAUJ3HkXoAhgq5P4p4O9bAVMoa\nbdJAnWHyj7RBM+yS3sPbZu4iw0xs4Jk0J4P1l4ocRD5tLGJs+Ux950R8ILrly3hS\n2wIVsX1O42fk6Km6z4MEcAkRH6OJg2VRB91s7yXxpJRNIGQiBovtexGTQGurQEar\nBzdpsUkAp2DHxkCJOKvi9yi99TwqXEETEZnoXDmla4cGuKIiYJfH1kkD6vmUjMSE\n+XQ85p2u1Hdym8dc6ziaLGmIw/Rj55ZxbvQBJvL4H6gMG6DLmodNDGUmU+kzsFmu\npZn5neR+fYIg4r8SXvL7yc+mPqpxd0o4Xp6wdW35kOA1I9D8AOACcWSbHeiobUS/\n93FvOfSslKgSREMzAiEAxM7DPi5ABd2BwdZm+tOfNOjwLNeTh/AwDpXg38uKWzEC\nggGBAIk1FlNOEr+rBArCgSo11m6MF/SoJShW/hb0tgVF2FXOZVJHKqpQiIiZsXFE\nt/Je4QRX+R2ClrKQypQZRQlMnJ05vYIuVDzlfwbnea+/fdhvNxEqSp7ouPFloSbq\n8FsOKVGZGlbT7s1LKRoJRV/buDhpVlPIouSe+gx1/PXiSolXm7ZArgZU4nlrtNmq\nWWFzaY/OVbyZ5jXYbLRJgCRYcuFG+rgrXpVJ031Bj2JV0QKFkYRuhIkU9zElFjJj\nFEeOZcZtnqD+ZcpSvY6M880vw+9XWhiJimECzDJ3cdRtOhL/E7mZXSd4kSN2L0JU\nT9tNM23gRnpxEeA/8wze+Z5KtAUvuIODeHq6SaqiyBzNSyWIhwA6JL3ud1oma6G2\nC9UUZc4NvuX25z+1KzYbpaGi1JElE1QSi+AzT7Tw9I1dKoA4d9Y2nX/WXNzj8wm6\nd+eYi6lMukAFPDUMXc01D7kMq6jXA3uT2lrkjsO3GqBOkP0BWT1dr+z3a5YXk8T2\n8xd4MwKCAYEAqOyudvmqXvRX6WRzwUoU8dRPvf7CunPkqUHcxc00ulu+mBLmM2aa\nT3H5lPDlL+5Mjh92/tB3pmYwp7fQleUGdDP8m1TUOUu56Qmb06GUZU4kFe6eT8Yb\nlEyAoPHh8gLUuVmicJMZd9lvwlc9y0z4UQmZPuZzEj01z6Z6ZY11v160jWXCGhUn\n4Hky2iBvRu6eRw4KG7HIglxEgjP0b+GmsMr75MNa5Ip544+AsTmq1BiyMw1nNIFo\nsn8Z1HktEw1emuRp69EEL1if/x2+fB9Q/0BpxNosdd8zPBIgUbu6ROm081uuZ3So\nPdeCO3d2Ax8W2iuDR7/MXYe/WpynYyY9Ov5QGDQQdKNfcmIxzT5VpRTbl5rmzX93\nFI3MQF3T3F55L8+AgYouEaiWSXY3O0Qx83IES1MkuBxy8InUlp2vhqgt5fnQ1cjG\nsGzMFYYIxhK1kGd0b+wQIvuHuA8WLUDIZBesnGQMK6M8AKj8Y1HD1eVnYin3b6uH\nNetD4BC0w1YaAiAqrAs8Pqa0zmLXbsTXtjFPhj3CdUEN+EHxOs3rnqwrUA==\n-----END DSA PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::forbidden-weak-rsa-key-in-root", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert is signed with and conveys an RSA-1024 key, which is\nbelow the security margin (2048) required under CABF 6.1.5.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICFjCCAX+gAwIBAgIUexzFNr/kG1cOy4LBTKF97RRnQMcwDQYJKoZIhvcNAQEL\nBQAwGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwgZ8w\nDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALd1id7V1rLrINdlxYrSLHYggEahi76P\nQoWno20V3MgvjxNzowbenegKapFeE1iQRCA/oM91Y59blJ1SVNl1fZ/Pxq6XREAf\nJfNL1FkktocTyzWYjJwzXfx0hCAS0876989BaO6mfuZNdghzXrHTNEPIm+ph23Qd\nLe04gQ9KxDDtAgMBAAGjVzBVMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEG\nMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMB0GA1UdDgQWBBSPg3EGoSWkFPhMtQ5m\nqIrVJtFJcjANBgkqhkiG9w0BAQsFAAOBgQCZllIcdryBliChUyGmSSPUa6cNOMy6\nxHc2HpqT5Pj7DwecfPmhXvHhYlL46qJniW8VvqoCvV4nN7rnK/EIHmtNdk2MycC9\ncV5AI+KrEfoK2P3JXUOTSYtqagv4LTjjmQLlYZmb7eKi5oMVIVh5hpp7i0yadWh/\nFpPjaJB0RWXDpQ==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB8DCCAVmgAwIBAgIUL6+ZEcPFusbKm8ieHsHfJpzg6CIwDQYJKoZIhvcNAQEL\nBQAwGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABGGRFvsFg4X0LO3ePuvK0VQ0PTOFKBTa4gOnSSZ8\nrYTdr7Shd/mVyno2SddAxCGZUSgTkfbVgEv9yrQ9GIF2+LSjfDB6MB0GA1UdDgQW\nBBSGpbCYgKBSulaVDcDZ8lmerLAQXTAfBgNVHSMEGDAWgBSPg3EGoSWkFPhMtQ5m\nqIrVJtFJcjALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0R\nBA8wDYILZXhhbXBsZS5jb20wDQYJKoZIhvcNAQELBQADgYEAoe8GLoi53CpWXgdY\nhxOEhcuFxPTPCtI+zLNTqgsojj2xi6l9+hV0htqj4vVylxrgGrjemCo8Ydw4u6e9\namFKjFRWidjwDQdehrQsxsi6MXsqh0TlpaxRlsLHndsTgzKuLSFZkn8mc2hs0Tol\nz+bbbSJwuN9IsYrBKTqBKh2crco=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEINjXyRTddoYYaPTH7362IS65wsYaOnvPLfbfQ6A5jB6CoAoGCCqGSM49\nAwEHoUQDQgAEYZEW+wWDhfQs7d4+68rRVDQ9M4UoFNriA6dJJnythN2vtKF3+ZXK\nejZJ10DEIZlRKBOR9tWAS/3KtD0YgXb4tA==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::forbidden-weak-rsa-in-leaf", + "conflicts_with": [], + "features": [ + "pedantic-webpki-subscriber-key" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE cert conveys an RSA 1024 key, which is below the security margin\n(2048) required under CABF 6.1.5.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUGazgIe6NVXQpKZSz3FPUjoZW3qEwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAASwtLRyDJtNGFd06XuwBWhxDNcbCwwvyRdj9PSt\ng2T5jB1Ll2Y7+8qSbYY5GfYE4YSQg1RrSTjatjobvYb2yUE5o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUXSymo6ovKAcJtcWvxODMbK6znFgwCgYIKoZIzj0EAwIDSQAwRgIh\nANIBYcug8OOrIeq+5wd6+l8LGUwH6w4KRmmWCNYHkkMqAiEAjNjeudnpw2OZqcYZ\nHsc/aJYSt1sNfPwZOtX0o4pAGpo=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9jCCAZ2gAwIBAgIUD/Gw5pVLurTnqLPG/K0P3H/qF+4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTCBnzANBgkqhkiG\n9w0BAQEFAAOBjQAwgYkCgYEAyvpttdgzCbkwr3acy6tQCqltyPe4mHNqhSmYPEBb\n4rQrqeFKyVfj/PJUwaqrttbDW+VEOBoKgyaks+8lLdqGjvxSpXdzG9is2L55fZhf\nF5tC/+bPrH3TnX3BWAx7iF6Ig8c0GPURVLc7XKO/e1At7fqmTpbucZvyy5LRJhAB\n15MCAwEAAaN8MHowHQYDVR0OBBYEFIldJxA9gzJdQv6sqUdnXfG8JPGyMB8GA1Ud\nIwQYMBaAFF0spqOqLygHCbXFr8TgzGyus5xYMAsGA1UdDwQEAwIHgDATBgNVHSUE\nDDAKBggrBgEFBQcDATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggqhkjOPQQD\nAgNHADBEAiBFcf1Hix2JA37xL9r8xAq4bU2YTJJ0bKqxONi9HZaR/AIgWlmQNP4F\nNuhXL6j4hS1E3X5BXnZnZ6L5dlTRUFJtmDs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN RSA PRIVATE KEY-----\nMIICXgIBAAKBgQDK+m212DMJuTCvdpzLq1AKqW3I97iYc2qFKZg8QFvitCup4UrJ\nV+P88lTBqqu21sNb5UQ4GgqDJqSz7yUt2oaO/FKld3Mb2KzYvnl9mF8Xm0L/5s+s\nfdOdfcFYDHuIXoiDxzQY9RFUtztco797UC3t+qZOlu5xm/LLktEmEAHXkwIDAQAB\nAoGAMHk76Bh4n9LVGKIn8c+4rsMlj7/xGp89ig2T6JeqGerTHp/J/2l47fhlW1bJ\n6UFCqFiJQSie6BE7dikfZOLyDRh6sxLQbXO6Y2paSfb2/ktbBAUIKJt/zA6dFhgR\nWXRbpQ9gNLbya3Xo5CGqqEmT12wknWlXCtKye4sJnHpFXrECQQD0a8dA12QDEveb\nj6jX8qFJU4PElKbDKAN0COHeh67prlgdMVzP1yrNjTb4XOK3rtg2WGp5nOZ569Sm\n3h+CHn3pAkEA1JgNT/xdsIoLMaOr7/UJfiBegsPvPoQGisohuhcW+qYqXx/+6Usz\naSSV/6zS643Wvo/60Ye26G4S4h3KSAwQGwJBAOAUi2kLzvnugqjQbPgFzg3+jdhE\nfBqA7aGMnx63gAlmuAuTfMZjOi+WnmXWKlhB6KDyMDNsP/RY2+1byMEvGTkCQQCI\nefRR3NjodDYrb775FH07ktwZZl836tmoT4rHQ/tkfTfGSWwDqFsgrHP+5pugzDWH\nsDZ8PHuXStKkhitNhTDxAkEAm++z7+IyRsm0ldlS8DZVFAToH2GTLFgDdO+NHEXm\neGTUO/uKAwn7JJspCkxNsVgB0eOTT4OD/995AuUcjlDDoA==\n-----END RSA PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::forbidden-rsa-not-divisible-by-8-in-root", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe root cert is signed with and conveys an RSA-2052 key, which is\nabove the security margin (2048) but not divisible by 8, as is required\nunder CABF 6.1.5.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIDHDCCAgOgAwIBAgIUZ7dREMziryu1TreLWHt5KaQf1C8wDQYJKoZIhvcNAQEL\nBQAwGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwggEi\nMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQoYOSNcoIrm2vz5dm9NnH7FT3fk\nSHxmguMtPDLYxVf7Jj+FKi6yMJ0yUUb/N/r1pV+krtSNJwq3zdqlUYeo1sndYlte\nIFY6BCq3lew1Zd/MuWDV8a7hFHga8HxgcIxSEwULM6XUYVXSg0TO6auqfSPm02iD\nYIlJ09KXKhShqB69RYwj9+F/f186t/C5384DKez8YESUL6Kkz8JExphtVKY+hFdq\n3uI6atPR7d5zUcwFTu6Kn0ZuDoscrMuYIKEisDQbZq/BB8fELVWNBQqjfsh8BK/f\nFIoL2jpI0LWWpzbfUpB/4wMsbWZNgQHYs6AWfW6DJhkOjFIWuk0ApeJAkxhlAgMB\nAAGjVzBVMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMBYGA1UdEQQPMA2C\nC2V4YW1wbGUuY29tMB0GA1UdDgQWBBTqf9525OnjPWd6V/vSLZKIceBaVzANBgkq\nhkiG9w0BAQsFAAOCAQIABuj7FJheS0slWmER5P6IkHU/sBgDpAvNaMbta6LWqkJg\n0fbTVnZHf8GfiRvip1+wVuY4LScESKmE7XIl0inIXU7MwG3Eckeuyypy8pRhcFtx\n9zJ1MxIHEiVeFmSKxJnhqiKU1jlmXRCwc/VC9ftudeTqOBffiDOQn+CF3O1KlKdg\nHr5O2V/SSiFa/dFzVbvBWQIMHT900UqmVuVEgEmu6VxZ1JdGV++YUwqRyOFRtQrP\nXJ/wA1bmk+JFwIcatqn0oUaGe63UmWs529LExZJTkx09WgdBVx6+37gQCUk5kxKa\npT37U79ZWsnGAsXV8P41TFlscsyIy2DG2b70dRzvBvQ=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICcjCCAVmgAwIBAgIUUrejiVXH5eA4S6hgcV8qfFZnl08wDQYJKoZIhvcNAQEL\nBQAwGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoY\nDzI5NjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqG\nSM49AgEGCCqGSM49AwEHA0IABF7vS88G5StPfRMVVnYG2SP/55Mxyq2smUN65S4k\nGlqKbcGxxTeFmeDkZqOTX2vZ9IyH4hTgrFvboTXP/7BR5O6jfDB6MB0GA1UdDgQW\nBBQzzxMFa9sWMWXg+A+CIoJidup/ADAfBgNVHSMEGDAWgBTqf9525OnjPWd6V/vS\nLZKIceBaVzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwFgYDVR0R\nBA8wDYILZXhhbXBsZS5jb20wDQYJKoZIhvcNAQELBQADggECAAMAYx6hSnLmWHCP\nOeYl3SDN7zkafpOGTsZ4MsE5U5tcpafnvOJvgIwx0U50OCtjmDsznb79k5T773YJ\ngKIkNvJxeNSr0ekMARCNnC1Q/TRJcCowIi6ji4W3uqko0Dsq9ra5eJKBblrQ8TGS\nlzvzwcc60j2vfMd3sMX2cCoEn+WzcNVvRG9gT83tlyzDAQaQTGLxOmACC6g6lVFy\nBBiz58rzxjs2CZgFP+T+bl9Mdkh9Er/Juv7gH34bW7Xh1k7jsAlHfhEcXEO2fJbo\niTbjF8yNfaRRoZmsrxiijmg/vf9JXFlNhH3rIKV1VEH2sEwDvgHHP4Elv8etaU2b\n+dp5QE96\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIK4obfmZFRufBIgu1bxSha/7wVxZp/eHIMlooLVYaWj0oAoGCCqGSM49\nAwEHoUQDQgAEXu9LzwblK099ExVWdgbZI//nkzHKrayZQ3rlLiQaWoptwbHFN4WZ\n4ORmo5Nfa9n0jIfiFOCsW9uhNc//sFHk7g==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::forbidden-rsa-key-not-divisible-by-8-in-leaf", + "conflicts_with": [], + "features": [ + "pedantic-webpki-subscriber-key" + ], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE cert conveys an RSA-2052 key, which is above the security margin\n(2048) but not divisible by 8, as is required under CABF 6.1.5.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBkDCCATWgAwIBAgIUAnwrEhgBVyDW2xko5YBL6NpEJ6cwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAATgbUbo7vLYjp/0iXnsCQNJDX6d00lqY3iRGK8Z\nsU+181T8SFEUS/Q8SMNgkRP5CyzGPpDV2dsfuim90IXos4n7o1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUgL0rZnLdiLVfYwIWFfZIaW1ulqgwCgYIKoZIzj0EAwIDSQAwRgIh\nAO6spPfvd0hxXl1Qa7L8IGGoK7TLZHrILoN+51XhZbyzAiEA8tB2WDvGF8YtM70+\n/XKmx2QjbrU9soEBw/J/4dgsZSg=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICezCCAiGgAwIBAgIUe1hPhT9JWH/cDAf5+xCukHZENVowCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTCCASIwDQYJKoZI\nhvcNAQEBBQADggEPADCCAQoCggEBCrn/4zNhxP5ZlIbF4VUX+k+gASTW4zpdYn2c\nyEgKscl0mJZ09Q+nHDc80t+q6hIqka/rsNX75ToS7RxiNml8Xuu4eQY2bs5Sfe7p\nL8awB93ctINc6DsLVP6/C5+Ph1aG+EqmQhFWTOtDvnMIbBLttbZ0lFM7ObjgE12R\nr/sI/OeENAISKbRpSi8moOgADTZFC5pmLAfLV/McpN/QibRWbHEdk+YgFUaibf+l\nKKRjwcMNoDVOS7wtYYW4TqpHab/0XmbENoockm0/i9SF1+5k8SnNEuHGWmWu2bn5\nit70MNcGDLDrZ+xFRFGL6h0hZPsmUbE3yXaKIpT4PDSvLN2NOfECAwEAAaN8MHow\nHQYDVR0OBBYEFEKFPEz1TnozzE5p17gAMEfmwEozMB8GA1UdIwQYMBaAFIC9K2Zy\n3Yi1X2MCFhX2SGltbpaoMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcD\nATAWBgNVHREEDzANggtleGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAHKQjr\nouHrZ8UFbuvnH8Nu+He35mo2MXQ4E5ZHn5016AIhALFN1dKjpMWAwzlx1G1Mv4dn\nwD1X4y6Ea/z3H4uxVF38\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN RSA PRIVATE KEY-----\nMIIEpQIBAAKCAQEKuf/jM2HE/lmUhsXhVRf6T6ABJNbjOl1ifZzISAqxyXSYlnT1\nD6ccNzzS36rqEiqRr+uw1fvlOhLtHGI2aXxe67h5BjZuzlJ97ukvxrAH3dy0g1zo\nOwtU/r8Ln4+HVob4SqZCEVZM60O+cwhsEu21tnSUUzs5uOATXZGv+wj854Q0AhIp\ntGlKLyag6AANNkULmmYsB8tX8xyk39CJtFZscR2T5iAVRqJt/6UopGPBww2gNU5L\nvC1hhbhOqkdpv/ReZsQ2ihySbT+L1IXX7mTxKc0S4cZaZa7ZufmK3vQw1wYMsOtn\n7EVEUYvqHSFk+yZRsTfJdooilPg8NK8s3Y058QIDAQABAoIBAQDB5GcTBDbILOQX\nZhaEjyZeA/LAuqmdv+VJ8E2WBKdMDb8OdKCvI8ISxmkvYN6ZPMc/sDkyytADOz3h\n0K994EnFhCeLgEFvsRRyT6XPdjN//2sBkYhWTvUH7c5wzE4mlm4muzmUBs90lzp1\n3eTfq0g242FrxRVM0AmeBED0TUyqPc0t7cXwSdmPnlW5D4bQXa86BgV9uG+pvb8d\nV+uAgku13J153YzTQENo8hwX0rs0JYiTBpn1cM80xXFZqmJHH50qUopgIlV4tV/K\n+nK3fVdU3cJmcxc16YHS0551L6xHpsdeFkZAw7SOR+Oe5zltutMCjerBwJIa09Vo\nx8kCLjDJAoGBA45wLcWSDComU2oY0IQDWYGLrYLZ4USmdiFO3MNDHOSlsrOWWgGB\ni9QwW2b5/8afyrw6qpDwQMi3Hu7TJdI6KE/SjPiVr9L4uxdZwgMhdx61a0mRGSQZ\ncGeQnaBWitdoBA9BO4LJCnXo3cbMX1v8Re/7Qane3mWEXpPKuMhwKL+FAoGBAwQh\nERIPu23KX3Z2YYaa0Ff65wwNlT8Tl2Q4vYNsndgAghCbuog7hs+8j4rYgrz9qEE/\nbAyrhMcwiZnd1v55tyEkkNL7KZTwMnDdOUupfg4UZOzK063nE501+buFOSqO8+HI\ncUewzLLqN+vlFVS0nwGRnohHaLJkuEr4PQypZ759AoGBAyK0uUZ2jA8ll2n10vJx\n2ZqkQikaXMkgUwru8ymdpH3bsgEw0M5/H3/H2u6iAOdov2DSAMylZxkQi09aDwCZ\nki0+oFgT8d96ucnOs4X7HYGPxrYoHhh77WUCVleltehRpzKj+wpGothupgq+6ly5\nwhfiWXSiMUckPBbmJ6FhcivZAoGAUuUp7AJ8YOElNpanCch9LbTmMUkUCN2Vl1Dw\nJ7f1ikcjr5zIfe/GHW9lCccM4jVpZvfkJcgUTT5Mx5QljNSMcKZ4Ve5ZHIBdKfjW\nOeVMfz55R2LPLxBr7qjo0tUOuh721/qpDsVQdLTopA7IJ3vsxkJX/tGLz/s4PfRA\nuadGWBECgYEChyokfYdxvHR11JnkWjBaD5hBQzqWcwGCRl+4GtetyD0n6yKFGpDQ\nFFDRhVsDK45RxTETFk23hi6FwzlA0YPeW38KFCno+7JQSbX+ROYLWTx+/USvsJcW\nF8D57b7MjwjjUhpZeRxVp4wAdumCid2VB1OtoS2ICsddu0vXFQ37QG4=\n-----END RSA PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::v1-cert", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThis chain is correctly constructed, but the EE cert is marked with\nversion 2 (ordinal 1) rather than version 3 (ordinal 2). This is invalid,\nper CABF 7.1.1:\n\n> Certificates MUST be of type X.509 v3.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUNYSaf0YCh3wPJEiFRV9MEYEuLEIwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAR4t7VqHNG16hlrTlHS+KWnQdsmos1GM7vNJ3Nj\nZfJy9FZsFeB+t+30u4B6No29aNhhVXVc/ovXTOGBJ0grxeiRo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUvlGWMV5jcfqj/Sh7AYo9LnXIklkwCgYIKoZIzj0EAwIDRwAwRAIg\nDmHjeEGHpYvOBn6tbhCSmOIBZ/otXcTTzs6UF3Q3zCgCIEQea951WkENF1kgjTkp\n4o7Nw2dQ/ouwZW7bqj762cYr\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBLDCB0wIUSusfjpRy1zJz0DxOtbvyqLxhM4MwCgYIKoZIzj0EAwIwGjEYMBYG\nA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5NjkwNTAz\nMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49AgEGCCqG\nSM49AwEHA0IABKxhWVFNcKcFfrVyXSfA7Wnd8FqUreddrbMiWl0oRuqXuynzG6Us\ngZOuNlJdJ6hLv68X7GoIStjcoyvn2Y0z3nYwCgYIKoZIzj0EAwIDSAAwRQIhAJ8C\nbaVMj3JxnQyIEIV7pdXxZFxfks+E8fAG2ILpRZ0XAiAGHa7MMar0Q8awAXKKEAM7\nM9f8m2ZV2MCiUtAsyl5gmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEILQCRTjvhrvJC+cwQ6EjllOYtHTb2CrT+EMExYR0X4cdoAoGCCqGSM49\nAwEHoUQDQgAErGFZUU1wpwV+tXJdJ8Dtad3wWpSt512tsyJaXShG6pe7KfMbpSyB\nk642Ul0nqEu/rxfsaghK2NyjK+fZjTPedg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::ee-basicconstraints-ca", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> EE\n```\n\nThe EE certificate has `keyUsage.keyCertSign=FALSE` but\n`basicConstraints.cA=TRUE`, which is explicitly forbidden under\nCABF 7.1.2.7.8:\n\n> cA MUST be FALSE", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjjCCATWgAwIBAgIUOTV3ktdzKQARfvMuvLNrNRCodZQwCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAARXcWOlOBdRq5zP9R6+UrriwZpUvDIopNKfRQCC\nC7Ct1d8+pw4dIuZBgZtj2C2cWRlhFUeXxehjCbVOd+zu0wNpo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQUa1X47u6WCrWbvLKZJGZZAK7S+IMwCgYIKoZIzj0EAwIDRwAwRAIg\nVjyGFTNUrQuEsruB4OUNeL36OS+hAloQJ6Kp54wm7ogCIGyi1E1jmCiDwaMTvD8a\nkGEX2vIZXgzvYglRfWRm6Byc\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIBwzCCAWmgAwIBAgIUSZrH9PbJsc97jYd/HpApqPKbeqswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABKAGf8LwrmkOzPAd1+yn07K1V69GjllEMxrQ5J2Lpnam\nyKMLRX6R2XFtPOcGrXOFUOwbKBcB69j5MrJdJd25r46jgY4wgYswHQYDVR0OBBYE\nFFX6QU4TcIJZzrYMEAWPWEfMqkWcMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgw\nFoAUa1X47u6WCrWbvLKZJGZZAK7S+IMwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMBYGA1UdEQQPMA2CC2V4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gA\nMEUCIQDrCgqfHGhOjkiutMzEQ8trDq/M1IZ1JJoKbhrTs2q6hAIgJ96IaEwrhk5s\nLEjwp06KZHO0wEEvUs5i0Ar6ePLsVWk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIBoFP0MtKDlpzEr54CsBtSu1veMDgXYNRzU09FFi6Q1yoAoGCCqGSM49\nAwEHoUQDQgAEoAZ/wvCuaQ7M8B3X7KfTsrVXr0aOWUQzGtDknYumdqbIowtFfpHZ\ncW085watc4VQ7BsoFwHr2Pkysl0l3bmvjg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "webpki::ca-as-leaf", + "conflicts_with": [ + "rfc5280::ca-as-leaf" + ], + "features": [], + "importance": "undetermined", + "description": "Produces the following **invalid** chain:\n\n```\nroot -> ICA\n```\n\nThe ICA is in leaf position, despite being a CA certificate,\nwhich is explicitly forbidden under CABF 7.1.2.7.11 (`keyUsage.keyCertSign` must NOT be\npermitted) and 7.1.2.7.8 (`basicConstraints.cA` MUST be false).", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIBjzCCATWgAwIBAgIUNi0DrY2bl2X4fGxlJT2F11IVhBswCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq\nhkjOPQIBBggqhkjOPQMBBwNCAAQC3IEQo3/OVmX8bQaW17fTLG/NPWKvwWta3/Wc\nFrqVXgDFeqeTmqKcLduDAAJtwmJYqp3erwFly+W4g4tQFaAAo1cwVTAPBgNVHRMB\nAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd\nBgNVHQ4EFgQU+guD/A9Iy9ed6EEjEmwtmZdFR7wwCgYIKoZIzj0EAwIDSAAwRQIg\nANMTeNooZLXwxmKLOMnqxeBhRTpnLh/YRg7XzU3RF90CIQDWgZAhOCbDMbHBSPdK\nI8K7h59EeWUmQnoe21eIH2uGSg==\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICBDCCAamgAwIBAgIUDPPJOQWYSe7mZo++qXn4n3ZUog4wCgYIKoZIzj0EAwIw\nGjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5\nNjkwNTAzMDAwMDAxWjBqMTkwNwYDVQQLDDAzMDkyODkzNTU1NTIzNTc1MDkwOTQ1\nOTYyOTg1ODIzNjczOTQ5NzQzNTE1OTA0MjcxLTArBgNVBAMMJHg1MDktbGltYm8t\naW50ZXJtZWRpYXRlLXBhdGhsZW4tTm9uZTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABMhgDkQddtN4VfEdJZcP9his0FFw06hYh1hXKfFXtDJH9DaEmrpAn8WXhAgi\nFJxEv6jdesYXEjsqVR3czwAf7JqjezB5MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0P\nBAQDAgIEMBkGA1UdEQQSMBCCDmNhLmV4YW1wbGUuY29tMB8GA1UdIwQYMBaAFPoL\ng/wPSMvXnehBIxJsLZmXRUe8MB0GA1UdDgQWBBQGTawDnG6xxfVtuX+21uDyW79z\nSDAKBggqhkjOPQQDAgNJADBGAiEAsOtEca+7KQHsDjivzl2VQWugjrFOXHZzAwro\nLMGtgEQCIQC8v5aKoDD9YaRG6J1lVNbaLrrKKD/x8DbReYyRgqx2eg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": "-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIGOsvKqn37eduP+15E1PDKedy4nju24sw1Dhd95CfVLyoAoGCCqGSM49\nAwEHoUQDQgAEyGAORB1203hV8R0llw/2GKzQUXDTqFiHWFcp8Ve0Mkf0NoSaukCf\nxZeECCIUnES/qN16xhcSOypVHdzPAB/smg==\n-----END EC PRIVATE KEY-----\n", + "validation_time": null, + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "ca.example.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc0", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `0` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfOyIhEWp2AXePNkU2M2gt3lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzOTM3NGE0LWJhOTYtNDU0Mi05MzAxLWUzMmE2YmZhMTljYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ0YzhlMWItNDdk\nNC00NDE3LWE3MTUtYmZkYTJkMWVlMTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIbr54xrefS29bypdN+ZtgPydR6V0UfcMEnGTd75fJ94n8PjgY4K/gOrow/zO\nC4M6CgWPz09blV4Pmvuxvu8/SKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLdFZ5NSI0vkF2xPwF4rGvOk09lVMB8GA1UdIwQY\nMBaAFF8D6xWyxU08iG5w70yRH+uCNGNAMAoGCCqGSM49BAMCA0gAMEUCIQD0Rtcf\nAlRKL+cull/jUuZU1PsUVi2grXYl51lzI8fCxwIgPk2HFAbzCiBGtmd/HwtEjQvC\n1xxf0ibdAvYtWkswXnY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd3jVUfWXpDXH3S1cwJv1V+nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzkzNzRhNC1iYTk2LTQ1NDItOTMwMS1lMzJhNmJmYTE5Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwX+WnVHrxp8oTncnDHB4po3GyqXEUJliYgQev7/pgyZFa\nRj5DeSkRT3hdEO6B7ePhC6GDv5FfEJWJWYrx5lGWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXwPrFbLFTTyIbnDvTJEf64I0\nY0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMjtpMV6jY/u/2yoLBqJyx2AA/Ky1zOnRLhTHFhsN/oAAiEA4ptybdU4\nejSSb45ydPO54vBdNJWrlbrPqoq+vORG8XQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVZyEtEQ4IhKNE9dePBfucCxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ0YzhlMWItNDdkNC00NDE3LWE3MTUtYmZkYTJkMWVlMTJhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJkNGE1NTI4\nLTg3NmItNGUyOS04ZmY4LTQyMzQ0NDVmZjRiZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO3DwDy6Ujcs+BfreHztbMvQl0a60z6u6mdNtj0JMbhvTQ8b4vWfP8ZM\nEu84gugpWxW30fP9CdmVlGOQIQSQyiGjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLdFZ5NS\nI0vkF2xPwF4rGvOk09lVMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCICxfSjklI1FFM9JjL4m+0UUbPyIZL53NKMVixEyyiRBsAiEA\njCeKU7eMEbyXqcMVQ4rzEdAainDotnNezKx0i6CMVdA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAaGqxF+FZSVC08RGgOl6iKAXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlYjAxY2Y2LWJjNTYtNGFmMy1iM2E1LTZiZDBhYmFkYjk4YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZjMjc3YzYtZTBl\nMS00OWYzLWFiMzMtNjQzMGM5OGNlNmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfmCVyiNknFtT1GRUHquvmEANOMlCiwWA8ONX/BG/yj1HgV411q2DbTsLBH51\nE+bwbXjffnw4XSYEoocgNkOkCqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQUJ2rUy2CLk33xrqUW7Zw1rkueYTAfBgNVHSME\nGDAWgBRYzPL4BDTK9YksUMF5Ery8BXJGITAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDYSV+7Xr6ZWhdWuVqhPD+K2wN4OCc3\nnPIwWdFk94SlsAIgLYn/uezSQmEvhs7+tIlLtqWVTss61rruCVYB5xM264I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfQTks0//sUG9UEiN0duZdFoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWIwMWNmNi1iYzU2LTRhZjMtYjNhNS02YmQwYWJhZGI5OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkurYxPVa7tqWcZDBGm+fSVTJvj2fowcbOvd1AKXjsQF3O\n4hPH5Ng0qYr7VKFZk6NQCNiMDQ630vatwe5njeR2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWMzy+AQ0yvWJLFDBeRK8vAVy\nRiEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJzTwM0A9N1FWxDGehDsb51ybd8ngA0jJiCihxtZNNBoCIQC7Zf1JhbA5\nVjBkF90dKdzJ/D4QkNCfS7Oqsi8wYUwACw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAbc8VFDcfOZNkWUuz8rLOQkRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZjMjc3YzYtZTBlMS00OWYzLWFiMzMtNjQzMGM5OGNlNmQ2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUxZjA5YjEw\nLTU0ZjMtNGRmMC1hZDQ4LWE1ODJiYTFjOWNjYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFNO+ipSDHM8y6Ppp12aaPYcnsO4Ewg/+jBzDvfluP8s5LouXuOCxC+W\ngA2A/PGLuchW7HUpmzJe7rY+B2C3B7+jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBQnatTL\nYIuTffGupRbtnDWuS55hMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDntsaBVhOpwJOKKoL8nEgiXlJ3CqLJSYB9sy9PxM3PnAIh\nALJhJvwih1hQ3bOK6OjvsnByxQuA24QXEQwfIENXG5wo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWO/horwMOrThIJYL1dPPA/ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwMmZiMDRmLTJkNTQtNDc1Zi05MjhhLTExNzQ5ZWM4Zjg2NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM5NTcwOWQtMDNi\nYS00OTAzLTk3NDMtNTcxOGQ3YjQ0NjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuJdkDCW/21FgmxfnsfJmSeN0cYceP12EgvvsIRDuVpGlyhieg3ooRfqSlOuH\nRK4FmaLh825bdZhW6ZLy2ZN1/aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJrWXdWtQM8PSSz31QjUpX9aOYXNMB8GA1UdIwQY\nMBaAFOmzbJLBZUie3RmX8pfqZg9UszH+MAoGCCqGSM49BAMCA0cAMEQCIA1DG5dF\n5uvhuz8IuJvSX5pwWftX+T1zRPmESJnEiwhvAiB96EwnPsgJgUcL0QXu3oDfiR1r\n6zFpo8M4emNH09q7Tg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXbZT8ieETlLmTxJIrUA/20bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDJmYjA0Zi0yZDU0LTQ3NWYtOTI4YS0xMTc0OWVjOGY4NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSnBAm4DkwHOQsgXyPQNChpX16utIEjPYmisxBaR81IuHk\nh/FacWB9+jyGb+HH3zhu8XX+gbtLCgeEPYpakkI2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6bNsksFlSJ7dGZfyl+pmD1Sz\nMf4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI0S+nMYgxapUqHr7PnLcC+8yj21pRR7ipJNR+Fu8EjCAiEAkTpGIufG\nB1CS6o9TyStDSivYLwnEMbnsh/S7bN/yznk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbvrfj+MeE0zXnDuc8XEmHkKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM5NTcwOWQtMDNiYS00OTAzLTk3NDMtNTcxOGQ3YjQ0NjcyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk1NGQxMjMtNjVjNy00OWM2LWI3OTgtN2VkNGYwZTMz\nMjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGNb0FGrTSa5cRuMB6A/LAP02\nYCalODMk4Pl9l+nXCW3yzPkF7B9RW4ySja0EnWya8bfieb9JX6NJHfYeY3jMOqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmtZd1a1Azw9JLPfVCNSlf1o5hc0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgIpn/fUeUdG/zd4QC\nn+hEyPeWppZ6WMb+8FCEvjyi77wCIQCn6/mZ6YX27cxWmpRo5zdd6UGIGH6BY7HS\nFB7H1qikyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZ10bCzBlhD/C6xuRIDX2OUDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzMWZiNDUyLThkYjMtNGExMy04MjZkLWM0MDI2ZmU1YjRjYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY5OTFmY2UtOWZi\nYy00ZjNhLWIzOTMtMWMyZmY2NzQzN2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFppQaYHlgO+GWMvlxzi2zsnLpNsTqUG9pDFz5SIJHZiKEWufgWXgtEayMnkk\n9v8XC7bWlfFV28yR9+CmPAu3G6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDxnSJVGWqD3LUOmE5kndxVdEc2rMB8GA1UdIwQY\nMBaAFFLLfCOJ37PyAuZGyFloqe1kXtLoMAoGCCqGSM49BAMCA0gAMEUCICMD/p/J\ntcQcArMLAKY5Bj5AG4lQJ6CYkr7yPN+zNYipAiEAvUxQb17zYVL+ae8MGDNe/sJ3\nVI3+GfiNhbgLmJT7M9E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAROkoyIb/drCpmav186MKodRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzFmYjQ1Mi04ZGIzLTRhMTMtODI2ZC1jNDAyNmZlNWI0Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/V8flUu0muxbJROYSX6akrP8yp9SiMLUIVyVLrMB2wJ9X\n5/OQWEu5z9QZRJK5kSuqfowaq2cHttXkjwlrrWzbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUst8I4nfs/IC5kbIWWip7WRe\n0ugwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEQE1JQcZwMlG/76xMaSpOvX0R0tsaNw2ZRDOahjKaWACICaNa4Pcre1L\n1rsyTAOIDEpJ3kBFeCPY7uMj6rP6F4AL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAV/fUfLfd+JoOFVqTrl0EaMFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY5OTFmY2UtOWZiYy00ZjNhLWIzOTMtMWMyZmY2NzQzN2VkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDk0NjBiNGQtZGQ4OC00ZTdiLWFhNzctZGQxM2Y3MTJi\nZjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEspk9g5dLf0mDyyFT4f8zcagk\nnAWLeOv2MWfwdCLOJRAxc6LO2nys8zHsotDt2eF8bQN7DGUfhbN2Zp+WSXEE6KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPGdIlUZaoPctQ6YTmSd3FV0RzaswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC1Wk3n3CMFFmW4\n6uWa5RE+HAXYIpQb6fnKdSj6NrGQMwIgdX6J9RDvxpNdhetSMchIozaOlefSn5lY\ni+Ge9TRPPhg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUc8TITmXRGWj7ZeND6fd9PMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhNTE1MjczLWMzMWQtNGExNi1hODQ0LWM3N2Y5ODQ1NTFlZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWU1MmZjZGMtZGFl\nOS00MzA3LWEzYzYtZjU1YjA0ZmJkMDU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES7w946qBJx8YloE5P7JnKggWqZjSobEzhyGiY/ONqdQgjJo8InHVaGkG8/3s\nESBvoRylHdekEVMnLhIA3trYv6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFE2A027GSOaOUF/Qg+Lj68tccBYhMB8GA1UdIwQY\nMBaAFL7SGwIM/yOzd0BU3+ggcnaJgoi9MAoGCCqGSM49BAMCA0gAMEUCIED9oaG3\nUWQQQBWrtZlhr3tqY2stXjuwPhk7j4OxMDw0AiEAiLS1WJD7FlrfY2RGdKRtF8VP\nvHk+OEIGOEKEWOqYNwg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcuZynf2S/MSX/2btC09YYwUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTUxNTI3My1jMzFkLTRhMTYtYTg0NC1jNzdmOTg0NTUxZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9zq3MWHL44tSuLgVLJS/RcjGfjZ5ho4LyUDiJUVRTaNMo\nh1evdQNejKLBqnwcL04DbTkPt756soM+0VQW5cwQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvtIbAgz/I7N3QFTf6CBydomC\niL0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVGa5rsA1xPg9PTENIt4zqNvK+82jER2jReX0Y+cAG/ACIDonJZX5jqFj\nJNM73YzCyerpN1Syar9Fek8K5ePhx0TE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbs3yGIGkXqz0WPfyBa7xjVCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWU1MmZjZGMtZGFlOS00MzA3LWEzYzYtZjU1YjA0ZmJkMDU4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmMyZTQ4ZGEtMTMzYi00OTI5LWI0NzMtM2Y4NTNmMGI2\nN2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm6C3h1NqZ6U/83beJoOcXg+A\nZj1Fc7mF/lUk32ULucrMuSPd0gkyLUUWcvb1WtYK2l7puKxJcJq7jTzEOeDa2KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTYDTbsZI5o5QX9CD4uPry1xwFiEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA6EC+W+YGcWJubBSzKRIoezhYjQ2T\nSySTxPFLDN76brgCIDaj5UzqUbAsIiDbXkWxX3EEUIwzx29zaJn/09U4XINg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVfIKAH1RiU8rwC84q3jqsXuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNTVjYzMwLTg3MzMtNDNkYy05ZmRlLTBhNTY1ZTFlZjZiNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YyN2E5ZjctOTFi\nZS00MDBkLThkMWYtZTBmNGQ1NzBlZjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELgEFd/nihibzU7mOWMQkxg7W3gwyDriSwHjw+jRUv+H1dD+vhvzPubysZ1lT\n5I0X4J6T2o3o+tQRtTP5n/9bW6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGB8BDfvoil0pWgJeFdvmm93FC3OMB8GA1UdIwQY\nMBaAFGeoiIbgsxroekgFuuL8kLnJUbB0MAoGCCqGSM49BAMCA0cAMEQCIAoFFsT3\ncP1r0/FDZlfPMTFMtLqfDJEm2a8nUdm1lrPsAiBL2SU+FnnDBV2TA3wLQdxgfKLX\nPBcxWO9lAjGn5tkJuA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcuMK7iIkXL507zXcFRIHV2ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzU1Y2MzMC04NzMzLTQzZGMtOWZkZS0wYTU2NWUxZWY2YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaeGe7SMrkw3C66nSXOJHT2csH2wzCE4LgZgAtytWSVzUJ\nDSuOOnqOv79mrSBVuIymUhYwsc3EQFtfrYOrniMho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ6iIhuCzGuh6SAW64vyQuclR\nsHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN7ONRWHtKhrPDlXI6+SN0D978o905DNcfN1WMEKfZamAiBSd9aUxSsU\nTlv1M1zc59IFq/UZ0Dxl6xL0v3Ns/Bs1Mw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAabnGwTetIiNF4Xrso+isoS7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YyN2E5ZjctOTFiZS00MDBkLThkMWYtZTBmNGQ1NzBlZjUyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTJmMzIwNDgtZDVjMS00ZDRhLWE3MmItOGYwM2ZlYzhh\nNmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECqC1xmiQkMgedZFb1vQ8PCaU\nDzAM0eWlx7l/YXooUsST3mJ4q/HVw9HyFFHiIyqquSUb2YUQnt5ua3umZzgQW6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYHwEN++iKXSlaAl4V2+ab3cULc4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAJyrsUuZIrQZZQT8UgQdSdaMMJ3h4F\nJYJsTc6rLquS8QIhAOu4dWOMEqDLE+6/rB/+MxR39lExfuSB2wCNCVbukFcc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAWYhyRopbAxOYfrJQeXA3zS/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwNWNkZDY2LTIxM2QtNDUxMi05ODQ0LTA5OWUwOGEyNDVlOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmUxYWZlZWUtMTE2\nMy00ZjJiLTlmMjctOTViZWU4YTAwYTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf3L/uLaVHH3Rdwm8qp3z8Qp4s012gt+J06Br5EkDDxzO6abb9vFdOgrpTvO1\nsRF4r2vzxm/2GNmT/ijROixIeaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTDK+FLwaV6QyjorqcapA9eZaVw+jAfBgNVHSME\nGDAWgBRnqZZC5v5Ykw8lZ/+y/Tm2gJAXhjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDWiNAo05iidK/+rmaL6/hylN6eZqxxN\n34EhoV1e3c5WAiBG0KO4xzyP7edA7dncWPb3yM8NYTskDv82pxIpUxzi3Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASGXpH9UwU8MRBT+1QVAEVmuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDVjZGQ2Ni0yMTNkLTQ1MTItOTg0NC0wOTllMDhhMjQ1ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8S8dUD88R2nIOdTqb77EeBwF1STvTIfdQ2l+wVJYkt81V\nh8HKSR3SMwYMOLrRrY/VslOlW9qJPAedp4dwgPeqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ6mWQub+WJMPJWf/sv05toCQ\nF4YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdch5APHSqSlxL28a317tHbFvdStHuJ1mmeMDc9SDoRkCIQCHin41Xg4E\nZoVjzJx5V6GuI01gsUiZ7FGnyV/fa313nA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAaPrLfZ1OSQiNE9cdSkxFhZhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmUxYWZlZWUtMTE2My00ZjJiLTlmMjctOTViZWU4YTAwYTg4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTA3OTM3OTQtZTZmNS00YTFhLWIyZDEtMDA2YTg0YjNj\nNmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjxvm4wAZW0pq0b/vIoihBBZb\ng76ibymaYpjO466T4VMUA9aqIHcp8qBmwxvq0I4HRpDJ2D2csqV/b3mhADVBAKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTDK+FLwaV6QyjorqcapA9eZaVw+jA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22GImh0dHA6Ly9mb28uYmFyLCBETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgH8feBPLTOkh/eY3ok60vKVSx0w5f\nYZABJe9kKpctJd8CIQDEJsYQb/kjhWqvfL4rQl0yxZb3QfM8eqnYQEa0Cupm5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXQhVSy3UoljDCvNG3KVK25jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhNmExZjNhLTE4OTgtNGE0Zi1hNTA1LTlkOTAzMGFiYzdjMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFiOGY3MDItYjkw\nYS00M2Q3LTgxOTctYzNjZDI4MGQyNGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJZAr6cyNEdpdP3X19SMXag4vGIC8k/l+03K+kO0j5exIyztiJkrBL0dL2WYw\nk7xVCMmxFvkkItWyKKbS0gV7h6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOAzojKpi676sI+gIwcdd5NRuOIaMB8GA1UdIwQY\nMBaAFI0eFDHiH1NaUOKS3ELaynDwjoZJMAoGCCqGSM49BAMCA0gAMEUCIQDeywre\nSHy8pkkZHGd+LjtcWv8SXj8eMFYTSqVosgKcSwIgL45BdW9ZJeKdr+x3j66uVlDf\nlgvjKLz4c6Hz1J+U8DI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf4dGujPz8APdkA+KBY7LBGoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTZhMWYzYS0xODk4LTRhNGYtYTUwNS05ZDkwMzBhYmM3YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1ilipFFTEGDbMTRGGi0MK85Ur6hH3gGd1wE9zfjazp/p0\nurRbiLyifYhCvW7/MlxAO76KqnsjC3YOn2re+wJ8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjR4UMeIfU1pQ4pLcQtrKcPCO\nhkkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOVuP/Dgm5/rxBR8LrkOBJwiT5UIGOObtkPa3UIms87LAiB/Cn27ydMT\nstlRU/jMjJVOoMlanJpXjMS3/VaRtJqFTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAZrevjoxoebsAEvv32yjrOTCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFiOGY3MDItYjkwYS00M2Q3LTgxOTctYzNjZDI4MGQyNGJlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzc0NWU5MDMtMWYxMy00ZjMwLWE2MWQtNzMwYjNjYTRj\nYjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGSok/0zhMSNfYuoTZ2xMOyam\nlXcg0YImJRap8IH8wonIXirKkrkEWdYRa1cDjOEtHzgKNLYMCLyU8nSCigOQcKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4DOiMqmLrvqwj6AjBx13k1G44howCgYIKoZIzj0E\nAwIDRwAwRAIgY2vR6TKriNINk0qf7wDu2HqJES8iR/Mp/jcHHB/IeO0CIDu3NyXE\nQRcyccOA3FsSCaGc4Rzi5xSw3HjgN+bi4GND\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQ6w7+VNyHpTH8bNMxhwYXIsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2MmM5ZDhjLTc0YWEtNGJkMy1hNzM0LTNhZTVjNDUxN2JkMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU3ZmNiOTktNTNh\nYS00NTdjLWI1NzktYjdjMjdhMzJmNGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8bTVtFjLEdG0uomZixsjldWshyhPHR+PhDuogENYGBz6GF0UJ0EMJT4z9e8j\nLysKVcW/TOGmIgOlwKES4rjveKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNBLbnpgEBOmJnfS4DzrclqFegH7MB8GA1UdIwQY\nMBaAFBtBGSI9vWBqvAwURGce6oQKqoorMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAFv35w4i0IzDmVZufLhIoxmT0mz0VkzjrI\n1qq6bHtt8QIhAKaEx0E8qGqYziVwJlUcWONaaFSUVCkcYfBiIMPuUfGf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcFHKMtdRj+s6xF3IQOKQuTxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjJjOWQ4Yy03NGFhLTRiZDMtYTczNC0zYWU1YzQ1MTdiZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbFsciY765HgEupjzJ3q14LvX31UtEym1DPSCh696w+75s\n+KRB02/LwBetsXHZcQo8pOrNAus7FUgjtdmtp3Zco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG0EZIj29YGq8DBREZx7qhAqq\niiswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKWEzQOjzlyFidSpnvHx2NhU+zbA04H/IvJpNLX/WPIiAiEAl8igex1y\nNuKTDKktucC7zGO9HtzPIjYpb/T+Cdem1cY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAUsmDg8iE3SDsx0nzJT/1onaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU3ZmNiOTktNTNhYS00NTdjLWI1NzktYjdjMjdhMzJmNGI3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjhkNWRiOTEtMmUxNC00ZWM2LTgyNDEtOTY5OWJlYmIz\nMDQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXq1lrUX7mEhkvEoLwPyyLhT1\ngYUu72QgK9lOwpEuc3zB1I2iCkUVHSeOgXdaQFF6Vm4k1Fso6JougCqkuZjqmqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0EtuemAQE6Ymd9LgPOtyWoV6AfswCgYIKoZIzj0E\nAwIDSAAwRQIgDE8aFFiy2cuIy7z2lHmLToFnWvsyM0YLmXmoDi6zyMECIQCQkhwb\nCTlfXrHoo3xuzvu1iAPvXtnk8kyYLn/QNZcEoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVBQXOAvm5rAvfASwg0pxG5nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjM2U4OTAyLTVlNWItNDBjNi1hYWQyLTRiNzZhYTBkODcyNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg5MTJkMmYtNGM0\nZi00MjgwLTlkYWEtZTVhOGIxZmNkNThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGB7TDMZr6YUuJthBgFTUMl6S/wNQbePIYpoTzMRc9CAhEdCU4QSrs3LtYr8L\nCRVuJ8zzDyA1eO/zESK45GLW96N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHg3epD84B1CUaDeFXDeZz3lFAIQMB8GA1UdIwQY\nMBaAFGBOvgjnMGo2UK78QOaGvBw62I60MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiANa24b11mHrQp2CfBVYQOCf1/O/tcsIhfu\n53qz1Ob5EwIhALL7Wf52B3/+ULHOQvIXINBNC0oti2mg/pkNDlT94+bE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbh/rGhwi5N2SYR+p7aqtFpGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzNlODkwMi01ZTViLTQwYzYtYWFkMi00Yjc2YWEwZDg3MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATymZNBOCoHa2Jem9JoBH1zCeKUDy1c9KD1fbJcW45HGNVp\nen0sSAqTA/7TFjSx8kMTZB2f3SzgjrB/0ZE7MCLKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYE6+COcwajZQrvxA5oa8HDrY\njrQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJRyeMPYNLwhvuFQ/dF1GS4UD3XJEJ27L1DAq3kE2fUsCIB3EvK/72nNM\nrzKgmVXuOoLk2uZSC2EFEmCnruscfBWa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAVBU+DFPysGJKEQvbrFtJCVTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg5MTJkMmYtNGM0Zi00MjgwLTlkYWEtZTVhOGIxZmNkNThhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWQzMTc5NWQtZjkzYS00Nzg5LThjZGMtZThmMDFmNTMz\nNTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9jLlIpKHT5jODiXV4YXOmAyG\nn0DUYMKuej4IETMj17nQF2bJpGKgX8FEedA3keBgNUmlZzHSCeIiexG4Np65QqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeDd6kPzgHUJRoN4VcN5nPeUUAhAwCgYIKoZIzj0E\nAwIDSQAwRgIhAOGR+Zo2hq9nD540tC7V/xRoqWxSF6+0vurBB2eN6nwGAiEAqPgf\nbfWpPl/B+DfS+Wuc4Cs8g1qwTgRrc8R7S9X5Dto=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc10", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `10` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATS0L0x9By8fEL/KLq2wH0fzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMzE3MzU0LTQ0YzUtNDhjMC1hNGE4LWEyMjFjM2MwY2QxMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM3N2Y1ZDctODEx\nMC00NjAxLTlmZDYtZjNiMDZjNjMzZWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPRr1OynPJT2RSPpigSxtL+OAu6+20VrkGiLdo0bKUHIwyyPGPaSPQDzVf+4z\nV11CIz+TbBDCecegaYmVELqr/KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTXt6aciBWpvySk+46vDSciJhV11zAfBgNVHSME\nGDAWgBRfA77JKHpG3LzyTES58WsYoTVnkzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDvc1vUTekL9UY1Ua3ahtzKunN1JTCW\ndOSluBieSA/jTgIgAN3IhU345fVxpQjege7txwRhk/mm0WZphbebTmlAEGU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeaXZIL9DH1iCozJcQkmK5oGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzMxNzM1NC00NGM1LTQ4YzAtYTRhOC1hMjIxYzNjMGNkMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlGU33QgPICpiWrre/qyaYBVcQIVJkmMKddu4YfGRJLVqS\n0QEFPHzFkIOGPtm2JS24gPHFfEydL/cFWdvyj3ADo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXwO+ySh6Rty88kxEufFrGKE1\nZ5MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALkJ1yeQc+DuyDjolzoxrPyQhnsc+jWZrQjHKOQ7AYKwAiBihhnBgcMq\nCa+nx66+ik9Rqi1wvhVtPiQm4UsivfVQuQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATje8E6psmckEM6IezMsvHU6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM3N2Y1ZDctODExMC00NjAxLTlmZDYtZjNiMDZjNjMzZWViMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGIzN2RhYTMtNzM1Ni00NGIyLWJjYTYtOTFmYTY4MTQw\nZGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2dbK07foOM3icbJqe0zJI0jw\n6elZL1Th7grlGlW+XoQjx1SeqiVdTNhaMLVzIGNiDb9NR8jMKEetKnbgrG+Vj6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU17emnIgVqb8kpPuOrw0nIiYVddcwCgYIKoZIzj0E\nAwIDSAAwRQIhAMAwRfKH0ZtvTUQJXdc1qUDjvyDMDi1MDhSiVvlOEq8aAiBVU0Dv\nn42j38yNL88tGyeH9nFtRx72eYrCXCudpGR9xw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc11", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `11` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAVruwofE+O/1JrxyuMj4+5FsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZmZmMDcxLWZmYWYtNGVkOS04MGYwLWE1ZWY1NzVmOTVkOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI3ZjQ3YjEtYTM2\nZS00NWVjLTkwMzktNzE3NTBlOTFjZDQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESW9alLZ1W0JdU6Cn9MLTzaqfC8tr7337tBQe6BCukbvuPLAn+YqE6VU+qIo7\n4boDLxvTQz16ok6uZ74cp+pY8KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULr2Gq+I8p+hCYDFzjVyxhtmJ8MowHwYDVR0j\nBBgwFoAUgu53kZDkyKjeZiMe86lLD7N3z+owJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAhUgfnlygUi60\nj+VHKHXzIZssdeoArU3mR5BPcHYRmQ4CIQDqT7rrUTBoyXOKSUSxy8y6sMSDfhBf\nyx84ZRRaaJ653w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcGZY9kyjCSyZJdHNjXDufd/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWZmZjA3MS1mZmFmLTRlZDktODBmMC1hNWVmNTc1Zjk1ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzoNIEvJU4jGGFf8hSrLyHg4pH7ksH2iB60uMwrYoSBmew\nsgGc2DXnhQZFcjonkR5B+pB0h4aPVvqh4Ne/uQ1jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgu53kZDkyKjeZiMe86lLD7N3\nz+owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOYtBYVsjd9J95q8dfkeqPwG3pZCn3FSu2C90PHmbBzYAiEAo+TUU6pK\nOjDzW1Yvt4HMw6WtIkt1CswXiak6Sby+HKQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZ1maPFDxsrcF6rGyl6qu0pOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI3ZjQ3YjEtYTM2ZS00NWVjLTkwMzktNzE3NTBlOTFjZDQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmNhNDZiYWMtODUzNi00MTI2LThlMzYtNDA0MGI4NGM1\nZGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH/vfEozhLZpuVBz2Ax4O/qUL\nVgjmYMEWGQ932EsqDdtbb7Y2Ja+Mv1cPiTIcpIR+mSmIHUemh2EpNlgIKvgjy6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULr2Gq+I8p+hCYDFzjVyxhtmJ8MowCgYIKoZIzj0E\nAwIDSAAwRQIhAM8Io4J9sht8712jcP3c20c7MZmht6GDGaTLdAQ7zQN3AiAH1c23\n7peBHKtjvLDZV1yhGE2s9Rjr/pZg4inz/GEzWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc12", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `12` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATL8C/pV67odxfR4uc11c+I9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZDQ3N2VmLTQzODgtNDA1OC1hMDFiLWFmNTkyYTUyNWNlMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc2Yzk2NWEtMmZh\nMi00YzJhLThkYmYtMDJlY2ViYWZkNzA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDh2n4eOXa0oz8TFqrP4dpKFXFU7V1/qVo89mMdTka9re9jMxnQyw+PWhgWfv\nwhacGr/Km44hDwTpaF6NpWZN36OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkA5g7n02KM7zkh8YEI2aQLxST1UwHwYDVR0j\nBBgwFoAUKUYACfVtwnXKVHr21Td6cP/Ju1owJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAx1wiQnng+Rum\nQ6Mbnw4Rlf7WwmDD2CNmA97sW7OQRfsCIH6VE+De2aHSqH8+TO0RGT8ZGMKJWTmz\n5qbOpkWUjXC3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXv4lG3Gf/ZVRa+pa8GuhSzTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmQ0NzdlZi00Mzg4LTQwNTgtYTAxYi1hZjU5MmE1MjVjZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqwWSP5NcKgglLNDvaARDJWJnmLImlY3qsEBa9A1yWQtJm\nDPwY8IPgikA3gQZTA+wJZSq5x7RRWgC3ChJRDpHTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKUYACfVtwnXKVHr21Td6cP/J\nu1owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKa8Jd7NT/ISj6KGvHyZZiQZK368dCVLxe2Q/WBHrz+TAiBcLsAG+WwQ\nZsLsybCZS6fh0XzRkvw5aBoiyjpIC5iXug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAepkaLnPnzaYxF11ep7TZgewMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc2Yzk2NWEtMmZhMi00YzJhLThkYmYtMDJlY2ViYWZkNzA3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjgyZjU2ZjEtYTE0Yi00ZDRkLWExNzEtNmQwYzU4MTAx\nNWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnnzGUSfcSDh1wsOfRMourwSt\nx2Vco9lJIKOf71y+/HJT44s0RoP+RXe2gEg1ffdFTZu0waFmsRcTa0QNpd8oJqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkA5g7n02KM7zkh8YEI2aQLxST1UwCgYIKoZIzj0E\nAwIDSAAwRQIgFImF0+7OWNcGsyX/W6JPcUvuwHY0CFX2zrI/gafn5LgCIQCfyV/b\n8O1MDZwHdPpy+DGSz2l1tuFNW6HZTpxs1VTtHg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc13", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `13` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAb2gj/r0SwVEKZEjrBAscIowMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxNjcxYjRjLTAxMDMtNGU1OC04YWFlLWE0NjViMTIzM2Q3OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQwMmExZGQtMzEx\nMC00MDFjLTgwZjAtYjQ5NjAzZDRjMTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3YWtFuCR2W3u86sZCKCKQaEmnk5G1OkedgB3DIgUZGpPiWp7FdgUlJf5SFRL\norkLY9p0RWKkcoG60ERfSi0ne6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEk2C/b9m8HJOj35ABDuVu0nFSBswHwYDVR0j\nBBgwFoAU9YDsQWd4D4vgldjrexxrLImJU9IwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAvyDSffczvPcursusIPQo\nowIx4fUCN9Vnv4Hp0+gP6fQCIGegjcQ4OvUGK6NzwjRqqquV7ir6DtpEK3Y70bDu\neBXl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQKKtUovv+e/KYz3oxvChQejMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTY3MWI0Yy0wMTAzLTRlNTgtOGFhZS1hNDY1YjEyMzNkNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQJ4cA7VuzQ6+tvvtird6cyIybnJ0JvnuNcGDBMf9So2H5\nnx+XPZxID1tG4MMs8BHsUCphRbVpfebkqi6p2CzTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9YDsQWd4D4vgldjrexxrLImJ\nU9IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOW1mQ8SKw5rsW+EfIFZDMp3Cz2eSBCUnuuz0kVcoRziAiBl/RrhTElk\npyJuk5SgUnrG3u3qD+biG7g3MLVQLqHx2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAdfNGSCv2NpXozKXADwIQRB5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQwMmExZGQtMzExMC00MDFjLTgwZjAtYjQ5NjAzZDRjMTMwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWMxNzhkNGYtOTAxNy00NjdiLWJkNzEtZWFiMmYwNzdl\nMWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZxlCPZSoKfxzAw119zqqoqNm\nSAgYlAy0eDPDqS/hdkLJVyu4hpxjPNftc6f/wLByveyqwmr5quOEeA0YL8Uov6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEk2C/b9m8HJOj35ABDuVu0nFSBswCgYIKoZIzj0E\nAwIDSQAwRgIhAJHEnnYX2X+IDeATag0wSP23fTwo+vSPRydszSmkXNfuAiEA/D1r\nBoi6LXZ6iguUjOArrIsdmdDM0Qs/wV2zph5Y+Vw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc14", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `14` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAS5FK6VjLDqqTXp0ebpEHUUgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1Njg0N2M2LTc1OTUtNDU1YS1iZWI1LWQxOGI0ZmRjYmQ5MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQ2NzFiODMtNTgw\nMC00ZDU0LThjMzYtNTU5NTA1NzdkZDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl4IrUPxQT6o8YhekDVBsf8dltV7DUfRr1/Lo7Rb61rEoLbzMWLJHtyaVCJQD\nCBHCyRbF7usW2rs9j9NbAu9euaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSrnXg/6pNOykYoY3pPo0J1dv+/kwHwYDVR0j\nBBgwFoAUTz6SYPyfSMqI0SGzsmske2yzEo8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBGQ7t5\nSlxP4t0UDLf7R9pih6YaiPon/VytIDI6yZQ3XQIhAJfgwAV+4Dgx+gC2nAWns+FQ\n7RTIzByi6y11N5Qqo/c0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfmgXDtw4cpaQCUwPogKJm/3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTY4NDdjNi03NTk1LTQ1NWEtYmViNS1kMThiNGZkY2JkOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATURgmGPHc5mwVXrElrd0Gi4QM9ciETaY1UTJhiabBUabYS\ngT1GRgdPrfAcKEfaGjNUtCBXUi75mH0q9VfS6dK5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTz6SYPyfSMqI0SGzsmske2yz\nEo8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQNwFT472Haj9dYnJeeQ1OvbMLWGJPGPlEljBkjpx9Q0CIEHbcw2hibNi\nbnRyPEeZKzXvkF/HdXL0iRH/eZkXYR8M\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAaEqcNmTEzralNrz8/RijP4UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQ2NzFiODMtNTgwMC00ZDU0LThjMzYtNTU5NTA1NzdkZDM0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2UyM2IyODItZWMyNS00M2JiLTllMjctZjEwOWFhNWM1\nNDEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEv/Z3+lfQmQG6yGlv72pd8uyR\nYzUO+zcIJ//yrIdq2BtG1ovVHX3PRdfFPrDzkoAVQyqlz2IzIYxvBc4Psf937KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSrnXg/6pNOykYoY3pPo0J1dv+/kwCgYIKoZIzj0E\nAwIDRwAwRAIgEECS6pJf2pN1XF7hDEgbN8NVUePnvkQXehv4sC+KDVgCICMQ6jc3\npBayLSY1481xHbf66IP7YKwgQWS78D1NxwgF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc15", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `15` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISATdlm1mmQMLYZ6ql9ArZPEFPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiMGRhYTFmLWM4YjgtNDlmNi04MmJlLTNiNzI2NjhhYmIxZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdjNWMxMDctODIw\nMS00NGIyLThiNjQtZDRmMzE4YjEyOTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7adfTerNt5UbOM0MGqm5+0MnY6LKifmfj8SkIR5sQO2N2Moz5WDHvMcwFso0\n9e0E6I8jPHmKrtULF8blo1uPBKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8VjNK8yJm8sQJJv4O/pDvIHvdHcwHwYDVR0j\nBBgwFoAUtks7Q/C+2C08qLydSwngjQZCAlAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBr2tgV\nkdhK/ZxDR2SYZf0yVeoWP873qP/x2ojRUF8/NAIgWluRsjg9XNS16HK214LrUu4j\nZwlOSJMQMoRCL2FnEvA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAczE2pTvKiqMRXNp2EDy6p6UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjBkYWExZi1jOGI4LTQ5ZjYtODJiZS0zYjcyNjY4YWJiMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOeThghRmhZ7YIPnkE7pXqykd9SuP3A9KBlzsXxmFL2SUq\npCDpkX5ghyLo/h8uIz5+hrEkrIiGu4hg8gbA3SQvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtks7Q/C+2C08qLydSwngjQZC\nAlAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ4BaVo72FM+hN6zNwrgk3uNAcrKVidsQqiR3KQtqYYoCIAY4UMNU8lWP\nyKfSPCRttouVOsafAu8cEUW30kpLMZRt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAU7CyrRAQUsBdo9IOc4M8PU/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdjNWMxMDctODIwMS00NGIyLThiNjQtZDRmMzE4YjEyOTUxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODQ2ZDRlYjUtMGU1ZS00NGJlLTk5ZTMtY2UzMTYxOWZh\nZDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEDVn8exdinxwoqvziw1KiKrL\n6aTUIp1tsQ53frebrS7CZBHJuslYvCbMsMBQcq04jGt5lv5WIFlJ9sO+8oWOjKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8VjNK8yJm8sQJJv4O/pDvIHvdHcwCgYIKoZIzj0E\nAwIDSAAwRQIhALpWY29uGzOGf8ez7e9UwoUssYATrOb9dBmcxM8kWMA1AiBPwHr2\nwnC3a1fhfeyjXTDpTrxBs8+TEuY/C//Y5Vv8ZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc16", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `16` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAefCIj+Ty0c4ro9rKp+jJQp4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwZTdhZWQwLTI0NzUtNDk5ZS05MmE0LWQxNTQ4ZGI5ODVkNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFhMGJlNzItOWI4\nNC00MDlhLWFhYTctOGQ4YjdiZWM3OTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPyy3hAAWZ6e7I57EP2KBXvWz+v84bPCfL0F0w1qGBhMHYL4cBPgRzCxOLigG\niY5cM22FN51YZeSPYbE2c5zUW6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLasgAh/Fz055zbuc/Q2HKIojtW5MB8GA1UdIwQY\nMBaAFBD2IX60SKx3DJystAMDi0EorTNHMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA1KWXfpVNAaO2wfsyENAInVAB2tBtNFwV\nKPpCe2f4VqECIQDJ0dVwOwFhm2guPpFxKvTYGG0eIdyQo1ItAxixmBHU4Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfsh5NoHAhY7wI8vx+RwrJQLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMGU3YWVkMC0yNDc1LTQ5OWUtOTJhNC1kMTU0OGRiOTg1ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoz4SMj+Ni8BJ+fadWh3ZpvqlHtC+nFWlXEslzzJGzDuoh\na1mUXS5rLUrns4MJy/biJYa5Wa25lYpl40xtLpB9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEPYhfrRIrHcMnKy0AwOLQSit\nM0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS2SUclut+eXUwbef8qzO8hTQ+i8jiAiZghEzqe8Tx7cCIQC7DiWn+ybq\nIHTnbLgRfTc9vg2yHqtMjBufSB1ZSBAl5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAQ1jxP4UlaYHi2o3vQcDGfhMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFhMGJlNzItOWI4NC00MDlhLWFhYTctOGQ4YjdiZWM3OTEzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWYzZGZiMzctNTc3OC00ZGNlLWEwZjgtNWEyOTBiMzVi\nZTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/m3SRte6On3P/8aY6qBwVzNr\ng64cCSfqYQoHkA7jrm60Zf21XI2n5ZmFfP4BpALgKh51fFZqD4XicWnUN+jd1KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtqyACH8XPTnnNu5z9DYcoiiO1bkwCgYIKoZIzj0E\nAwIDRwAwRAIgEOUuPnQPbxW1ze7wyyPmKvWD52liEid6iCmQu8NsEu4CICOfxRhI\nr4LQSJY7kqDZtg8yzxAOfY0BEO9NkvCqrB8W\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc17", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `17` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAawYX0HwVJEO8pX1W6ANazk/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMzRjMmNjLTZiYzMtNDczOC04NGI5LTFhZGI0MGFjYjJkMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI5ZjFmMmItY2Q4\nZC00MDFlLTlmNTgtYjhhZTFlMmUzM2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeKg6dgjcYyw6+nqhjaE7EWEkcZ7g6UCZmsYPuEueM5v9XT3mG3C3vkg4Bb0p\nL8uzza48TBpAPBfSALuXFh6E9aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC7wILb1vxQu+HKDayYrHSq0JTYEwHwYDVR0j\nBBgwFoAU2CeGbzOtVgYc8/PLFAT5xVVWd/swKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPoIe5mH4Lti\nqQ/spgpgMBeOs1e4tXNC3HKXvSovLERbAiAr/QcH8zTjXLIeffuq7U5FMO8r2cad\nyJLReCyvtkqdrg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATPabTq+jbBsbU8Hc/YoX/BPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzM0YzJjYy02YmMzLTQ3MzgtODRiOS0xYWRiNDBhY2IyZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARz5dRFfPeM5U7t7P7CGlzs/YSVuhG2gJByoPTe/JnqStbn\nKCyR4l6XtGXHkVcuWJedZ8kA79S7GDPkaveUo1C2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2CeGbzOtVgYc8/PLFAT5xVVW\nd/swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPrYJ7zhAuVn+uF7WtICJ1yztjGMX9V9SKv+OYZREGzkAiEA173upCrr\nNuGqO12tXR8idXQKLc0gbOfjJUY/aXoi8o4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISARw5EU9vOx9qVl3SHBNhknNzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI5ZjFmMmItY2Q4ZC00MDFlLTlmNTgtYjhhZTFlMmUzM2UxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjk0N2UyMzEtZjIyYy00OGUzLTg0YjktNmYwNDMzODc2\nMjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElsbn1Wp7kWmdw3n9vq5kzlYg\nDIWUVzZXsKs4gqCJcaCIjZJoDJRTEE+cDrTXkPJblcRvPbQ46TIbOhX562G3PqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC7wILb1vxQu+HKDayYrHSq0JTYEwCgYIKoZIzj0E\nAwIDRwAwRAIgUjzdt+7vBReIcyT6qNOtvoQX0T4/OLYX5u2Zj9EdSBcCIDDlI2qU\na2Kp58HgQaOTyfcGOV9C3s3kwWW4aJu8wHMg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc18", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `18` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAZAY3c6Mx1TqwsWbh3bOTN3HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkMGIyM2I4LTljNzctNGEzNC1hN2VjLTc2MTM4NTRkNDgwNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFjMjg5NDktZjFj\nNC00N2Q2LWEzMjEtYjYwOGQyZThkMjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu76m07gIRdMUKZRKSaIW7aMNYWyybcHdrpg+QRWZVdJjeS/V4d2GUDhGCkg6\n/G7eW8oRRv5+/E19//4+Uh0ouqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHX8GP/o5BI9LaqFe328hfzMqA58wHwYDVR0j\nBBgwFoAU6jo2/rQYyyVAh34+o0czgzJc8tkwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKN/Ih1EVk1L\nIbeUa7OA/26DGOJUVueZRZvtVA1Su+22AiApd/awPbpzebjSMUAAL2QXgIrUnrHu\nOYmRdhyYKMzt+g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaf/0ZwdTEeonjjA0F4ffQfDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDBiMjNiOC05Yzc3LTRhMzQtYTdlYy03NjEzODU0ZDQ4MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbjgTi2+LHFpwmb5kuzqUbsqgs7B8zsvWrdc0xl+And4t4\nAy/4grbtH3ND9ulND5BK9ukaORruJYIN/qSesCtio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6jo2/rQYyyVAh34+o0czgzJc\n8tkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgac9xxJM9XhFID04BKDx6xuQPngENDky2rowyjQSk0hcCIDNUhL+ofb6Q\nbvA3WfcLecblPGEvqzKSE5S2HUpfXhn2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAe5zEzZCjfOIKoc8GiZm6ZNZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFjMjg5NDktZjFjNC00N2Q2LWEzMjEtYjYwOGQyZThkMjk1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTFjZmE0MTUtZWRmNC00NTAwLWE0NzYtYjJlNWQwYmM5\nMTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9nvJ7OJg+mf7fC/yvdxX7oOQ\nw95GV7eo5FhDhD9o/5UUp7x2jOAM61KMKX+6ZXaZ3IPCF/iyVI8nR9deoXiPL6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHX8GP/o5BI9LaqFe328hfzMqA58wCgYIKoZIzj0E\nAwIDSAAwRQIgGZnZJJD4RWaHqoTEBFrd2uJ0oPfkbiiESbcSInNFk68CIQC2ur9U\ntO2vJoW5bLO0SGqp3vEKmcxtoEc/QdDnsfGMtQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc19", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `19` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARtOmecGZknOU1OSwZYfxL0tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3YjRlYTdhLTIzNTYtNDI1Ny1iNjZlLWE1NjVkMmIxNjBiNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ3MTVhOGUtNmJj\nNS00YWYyLWI1YzQtYzJhNzZhMDJkMDlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFHE4uA0rY8wLoGlhgHmPOdKcbhZ+S3iw4b2JUWuX85SlWkAEwJHqRCySz7ZZ\nMRXyZ0+tPHk9XzNHmBwY8I/8w6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPJTmGTo2vvFrnTTcLcGHkvmXh4MwHwYDVR0j\nBBgwFoAUpF23cO/crvY/LiTiSbvjzU4tR8owKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAlHWGrX3Awx\n/HZnQaW37+nO5of4MLRXkxeI6V72vqMkAiEA91Wf2tQiMqIIQ9zeuLpUmcE0eb3N\nONVtJB2aFWnhTCs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWXpu7RYzau4J9Y7SIdWrTcIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2I0ZWE3YS0yMzU2LTQyNTctYjY2ZS1hNTY1ZDJiMTYwYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcgSOdNYGrB0bUJMwtEz17EJRRqV7VZl3psdYohUUYoa8j\nts6hSmwFbRDytREfFK9CY3NrRcOpNr0Bwysrfs0Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpF23cO/crvY/LiTiSbvjzU4t\nR8owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSmPzCTT1xqpCF++qYKtf6UD80ovikrNxiWd0PmbMU18CIQC34HjLz9Xc\n4mK6bqw7iF0I3EfKpSKaWt0sOBylKmUgig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISARaeubo4kgDtLhyk8gA6c9sDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ3MTVhOGUtNmJjNS00YWYyLWI1YzQtYzJhNzZhMDJkMDlmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWU1ZWE1N2QtNDhkYy00NTcxLTlmMTItYjM0YmQyNzAz\nMjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr7/2uYMzFPYjvFufARCKlEkQ\n5dwTAgCgFEWsqDKNeXevVueOTqn46trpSEV0D99Cj4ldq3loFe8pEobHw0uVraNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPJTmGTo2vvFrnTTcLcGHkvmXh4MwCgYIKoZIzj0E\nAwIDSQAwRgIhAIDIDxCdXCluUzZRAWYwgs4x+yNq+f/RIkIEZRQPTRlwAiEAnW9k\n+HH8g31VBsypOH3t0Fq7hs8zTzfYdqt24TS7Wz0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc20", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `20` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdjUmt9AJ0galW5Zbzux9rDgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5MzNlMDI0LTRhNjktNDM1ZC1iOGQyLTYxMzNmOWI4NDBiMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYyMGU2OGUtNzlj\nMC00NTk2LWI0YWItYmVhMGZjZmIzZDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVP0M1h6TllTVezxO7TT0F/7/tkgz0sF+zZB7HvMDZkmV5Fm3rrZEh1psdFFj\nim7Fic22QzCAbIFWeX+3fbhCIKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8w9xL3vg7OiyIdAxRfbvVlU3E/AwHwYDVR0j\nBBgwFoAU0lAayQAxGcZQ1YqvfzQxZBfqhIcwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEx7kSM6yg2ijZUVSr/iqEPirAXGCMlNTcQw4cI0nCQAAiEAtsiQaXUAMODT\np4nwob0ICE+WbtcDzotyFPPwH4/kMj0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfZpo5hQ8/mb2UqtJcLkn6UHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTMzZTAyNC00YTY5LTQzNWQtYjhkMi02MTMzZjliODQwYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQ6C1c9E/nl3oqF48wN5aiCmIT66MCpOppXjRoF5K6BCgG\nEMpibhwFOF+IelaYJ3xPG9uoRiIMaNoQoT9lQDOCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0lAayQAxGcZQ1YqvfzQxZBfq\nhIcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYndDMb0oh/JABp4CPkzNUexk7eJOaBm3ksfnAzmTpUwCIQC4Bg/hbLq/\nYImYnkzsgOZhPTM+EXrSUMKG07yoIaaLzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAXZN0Gy6TZE5UCsbAC3QeA17MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYyMGU2OGUtNzljMC00NTk2LWI0YWItYmVhMGZjZmIzZDAwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTM4OTU2MDctNmQ4My00NTc0LWJiZmMtMzUxNmNlY2Ez\nZDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcV+q1MEhrrdUw+3ovIvhayAp\nxt87ozj9hBnlEVL7W6+MzWZ/CRJPP2+FwBwY1I/R/e711c3SmOqi2ZjkqGeeWKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8w9xL3vg7OiyIdAxRfbvVlU3E/AwCgYIKoZIzj0E\nAwIDSAAwRQIgWfb0SBy1k3vAJtezzVExYkKxogc/tFrkc4jwJAZsQJACIQD23sJw\nKNLixjCpKpMutm+zlyW/VXFXg3RrOFcquo/txg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc21", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `21` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVV+Qj1cSi4xoV3qlAr2+sWbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzNDdjOTk1LWJiOGItNDAxYS1iN2I0LWZkYmVmNzhkNTkwZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q1MmFmZGEtOTA0\nZi00NzdjLTlkNjQtZmNkZjk1YWI3MjY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOdw/gtbFazhC3X+1Ne4M5DEO+AFcDHvHefyT/KuwQF1z96AOEX/MXmZi/NJb\nFBW/IcLYc65SMngeck0P6z9kwaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsaF+V95pc+2pn/r/C4/Tmwkt24EwHwYDVR0j\nBBgwFoAUpjMEFZWLzx+HLu4DijxoIahTbtgwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCfdJeF/9bQa5u24/yvNWIxjUA5r6z18+YBdu9TcBL/ZAIgeM9iqQmbhu2W\nFFVdigYbTwQrqEVjsVbuADrsMLO570o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAakhZ6pgNDV7ibie/mbmORezMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzQ3Yzk5NS1iYjhiLTQwMWEtYjdiNC1mZGJlZjc4ZDU5MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPEsuNaRnNHP13UUjiOXlkYyzNzG9jSdeYho85bBNhj/aD\nDmHk18Ty50jW2F/bimPQl8c0Jd0cFQUHSIuxZmDEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpjMEFZWLzx+HLu4DijxoIahT\nbtgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJPudLHRsebgr1xeIc2M0MAidzaAkEQnn4N77xXmb/cxAiEAupVwcn5G\nA+wjneksMD1KHMAQ/E7B+BnFFAJl5T5sbzk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAST69PuB77RpU80bv9GszTDlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q1MmFmZGEtOTA0Zi00NzdjLTlkNjQtZmNkZjk1YWI3MjY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWRiYzkzMjgtMWEzYS00NzBjLTkyYmUtZWZhNDZhMDll\nODNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExfgVL9pE2UX2ggqeQZ2SF87R\ncJX2huFY5WHWzXl60PghEOysFlKbA0cmFov7AjWNhICn0J0n0bfyBj2paLEgOKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsaF+V95pc+2pn/r/C4/Tmwkt24EwCgYIKoZIzj0E\nAwIDSQAwRgIhANeVVnUtsayXglNXnIcOe2jX4vlYUFKOufggxasOcy54AiEA/LBJ\n0/pjXFcCwAo90bJ/V6AxMlU5zLIqCbA1Mtu8PyY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc22", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `22` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISATEFubjWKZmYt/Ti+GRIVauPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NzIyOTVhLWIxNzUtNGIzNS04ZWVjLTA2YWJkOTkzMTY1YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY2NjUzZWEtYTU5\nOS00YjIyLThlZjktMmQ2MGM4ZGIxN2QxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVmEjFkZPqY5R3XwRVprd0XXdrofHl1tsaU/BcVyOjluph7/zAKe0b7vBzkQe\n17v6o0Lcde13U5ybNZ4Jsw0acaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoMdThK9url7ZiOY+gawcOU1MDmswHwYDVR0j\nBBgwFoAUDM8BByQj3vhL32H8PJD7zWM2OaQwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGRx\nbT5o5Qqfo6AnCp5XqC8OqiJKZxGchfUhofJpymuaAiEAlQ9nwITqC/sjDFJkfap5\nSRAlck5uAsnMVThG/S086+0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUiK0YluHu07Y7tQfaqmWviKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDcyMjk1YS1iMTc1LTRiMzUtOGVlYy0wNmFiZDk5MzE2NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRve7iAlnzeiUIls0dYC9qo9SX48CrFK6foRLOBsjpD8Ws\nRjoq1QVPJk9odRhXnuUQ164kYzFTfMa+W3Jr3GKto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDM8BByQj3vhL32H8PJD7zWM2\nOaQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL/adZcxgb28sZT2bxjtsaQjrQJ4aOKza28TkClaTo59AiBVaxlKmU28\nX/XesMfdOKhOVnnvmR8I/xRvqbO4XRomMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAc5yOE/Tpkn5oky8/ni0QkRqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY2NjUzZWEtYTU5OS00YjIyLThlZjktMmQ2MGM4ZGIxN2QxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjFjMDhhZTktN2ViNi00NjEzLWI0N2ItMmMyODA5ZWE4\nN2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4dGG7d/iGhT13XqCLNXyHh53\nw54oPNnwvBQouDhuIf15Wr6XpU/ZwZB1M4u9KcfM5lyup2emtVre5vqiMDF8FKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoMdThK9url7ZiOY+gawcOU1MDmswCgYIKoZIzj0E\nAwIDSAAwRQIhAMmTGVriXXLsZidRfQQ0wGTie+yInte/wa0YV6fh/RrgAiAEFBck\ns1crgSphYDesRgI3gHA77m12sXnkdFTwJwmWyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc23", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `23` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAQxtWiRobJDybrVx5EEd99awMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNjI0OTFhLWYyNzktNDA4ZS05YmNkLWUwOTRmMWRlMTFkYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWEwZDkyMjktYTA2\nZS00ZGJkLThlNDAtMmE3ODQxYTU1YmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUuk/5m/WeJISNKQeNvaE0FMBFfZvfiZmXFSaC1MOS308glQunKgKohuDmSk2\nfMtg3zpo9XWockkDFmc6w9axkKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUukZtU0SnLi+R/NxuYij8HNObvp4wHwYDVR0j\nBBgwFoAUY6OFIZTjXNscVU7hWB8TUbW9lTMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIE+g9vNi3JxhCAyK1aL1vJ0RxbRh8sFGYyPta0Ci4xqyAiBjO8wk\nzwiNvEmRgs2SgIEJqB4mpz2Amo9QKFUZcNzbFQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVxdkJnrq7m9ZEvOAVbxzR2ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjYyNDkxYS1mMjc5LTQwOGUtOWJjZC1lMDk0ZjFkZTExZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcOE27TfeNtfYU0hvUiXMuH34h/gEpu9GQftU0CV24dj6S\nbNHUM46re4hc0RkWGTJj3IuDwbCV8XkU+JtN/Csho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY6OFIZTjXNscVU7hWB8TUbW9\nlTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAODca3KZTYVX1jP4qofwQyYnCq2Wcs5oqa2ySgtoh8OcAiEAvOE+u7jw\nI7i9S+ZpU1BmwE20DaQKXSGARMZFrYTpR7o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAekN0g5m7LypLn3D3JBNAl13MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWEwZDkyMjktYTA2ZS00ZGJkLThlNDAtMmE3ODQxYTU1YmEyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDE3ZjA0NDctM2UxNS00MDk0LTkyNTMtNDdkNzdiNmQ2\nZWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX+AUC3vyqZs8O1jDPCiNlGUu\nkQzh6gh98MKumHJ+l7rUS25f6GvxdgaT6Obp12AaM0ADVIP6+18jALJnp2pNEaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUukZtU0SnLi+R/NxuYij8HNObvp4wCgYIKoZIzj0E\nAwIDSAAwRQIhANR/fkQBUttSbSx15QFfcjpPytxWqAAikcS2a3jX+AV3AiBCLMK5\nr7V7Ns+89RSzVRir+rlw4mKMoMNowUY3Q7Vngw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc24", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `24` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWaW9heGFvVppLIr1tvT1v0gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkY2UzZTM1LTY4NDEtNDJlMS1hYWI5LTUxYzE3Y2E4MmI0MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzdlYTVjMmUtYWY3\nMy00NmFiLTlmY2YtMDVlOTQwMzhmZDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd3LMjVYb6csVH6xV6NFLS9QPGiNWPTC5FCpk7E6Ji2Ac/QFpbDBVNpqfIMSJ\nv32y3GIEHULdp7xXF9AqGu2p26OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAwIoaKZH3n0r3kVYsNGMVIlfHEEwHwYDVR0j\nBBgwFoAU0+Mli/u6ZPmGfkCf0ITBCQEGcg0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDM5VbxexQwXb40/tbAvYXe9ZEMgKQJrqUHMdFLh9DXFAIgJte+\njqqCUK1yfq0+uXYT+2Um2H/aOjAAng0f90eW+ok=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZMLXXKmS6CvD6epRJrTZLQ/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGNlM2UzNS02ODQxLTQyZTEtYWFiOS01MWMxN2NhODJiNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhJGGrgn+nnnkiktqMWEEFxjsAHeEjiW2yXK72T2mTTJGL\nj4P/yOfeKb3joF+817DLxvs1K7JuwMGIQvGWNAYQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0+Mli/u6ZPmGfkCf0ITBCQEG\ncg0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH4pcCfw5w53/7aN7VnC/0iSRd/2Rt3asN90V0peEo34CIQCLRLlB7RPY\nH39CKdFFWz8KsmP0XB47przek1o5zeE5oA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAY/4qvYetV1rvMR0XIElMEwUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzdlYTVjMmUtYWY3My00NmFiLTlmY2YtMDVlOTQwMzhmZDNhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTExYzMyOGEtZThlNS00OTMxLTg1ZGEtZTZiNDY0YWU4\nYTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwnv42gY9JzjjdAmEs86IneYf\nPfMnYAiCUU5Y+d9lRf2Wip3oc7kayPGTqcaW6n3P107b6Rf03BLwTi/Lp0dvLqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAwIoaKZH3n0r3kVYsNGMVIlfHEEwCgYIKoZIzj0E\nAwIDSAAwRQIhALm3sxP52hgOzoO0leT5G3iQhdv3Svx1asOzGwbA6/SpAiBV754i\nUJBt20PI5ssLmfY4tQJGypxfFajl4THkcy5qdg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc25", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `25` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAey9uQ4lXm7uk8vS7cXP2ErWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZDllOWIzLTRjMjktNGJiMi1iYjNiLThkYmMyYzY2MWI5MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMyYWY3NWUtZThj\nZi00ODlmLWEwOTYtNGFlYWEwNzc4NGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbPhgkvN4PShZswdjsAGCS72bCWOaLj0+Nwd3nbFqpbz1I1d4+AT4xJh9+sQA\n1vGvXR8r/qaEiMKW5geWG7x3vaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKxViURMcmTFrBtWogkex7BknkwSMB8GA1UdIwQY\nMBaAFEYJuUq8sf3tdmtYucs92jF+24oSMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA2QVHbqKqrUe2nFNy7Gje0GVdJNCkl3yv\nUTAGvZiyffACIQDVRnYftS1/+SIdOnr2zToJu+w4E5a6MkTRvUkMHgxtgg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZr+i5NQ3zRuFHoI9UhmsOszMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmQ5ZTliMy00YzI5LTRiYjItYmIzYi04ZGJjMmM2NjFiOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiFi3bRHC/HDTD53qZmB13TCv9kabnFFs8qM2QbFED6/SO\npFn53TevBvECtkLbAszsbWmxMlTTY++E7t/nxbHWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURgm5Sryx/e12a1i5yz3aMX7b\nihIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIi7lw02yedRmN26txtEm+db4Ke2WkYUUJFtxYEWQ9HICICFFVX2HNPGT\nYWtdOG1EKbPqkZe8+Lt31J9NbHkX4Iug\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfIiWvZzEp1iI+9LCzOSM2K8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMyYWY3NWUtZThjZi00ODlmLWEwOTYtNGFlYWEwNzc4NGI0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGViZTA2ZmEtZGQwZi00NzYwLWI5ZWQtZWYyZGVhM2U2\nMjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjKVSQK398QzZJjzCzTMCrvtk\nUz800NRg3yBxKEXSYQrHyBuZ9R67u8r/PSDxJF2O2QM1RdcStmPupPbvVTjX3aNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrFWJRExyZMWsG1aiCR7HsGSeTBIwCgYIKoZIzj0E\nAwIDSAAwRQIgEDbsnwK4s/f+zQj/2jt8QxgWw2g50PdOQurnmD9yuuECIQC7FxLc\nQ52lOZjHnS+J7TJ4t+/A8JbzxxG0/5UQAGusOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc26", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `26` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAa8PktjDwDZhhQuPFXpza6pZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxYTBhYjQ4LTc0OTctNGQ3OC1iNzkwLTdlYmRkNmJiMDc2NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc0ZDQxYWQtMDU2\nMy00NDY5LTg1YTUtNDBhYzc4ZDY2MDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELf0qsG4K/07YK1xrRtaKg5P7yZKWPSVLL91m/iZSYgFLPmeC1U8BXQpNgAdW\n0uMjj0AnC/m7PGfRTZXdu3Fh6KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiY6TG07x6xwBlJ+ep8W3udlR6o0wHwYDVR0j\nBBgwFoAUNqwXAxR2Fu47XBZmnlO2TwKVeRUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgK9Z+h6ipu/MN\nESlvwvy5SQIu8n0SiRHuWzRyclQnMUkCIQDqkbFu2ikYBTgewYJUTmLTpRyQX5m6\n7s4bIv3fpcunbQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd3TS9Ioc4YLgDlxLsKglYluMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWEwYWI0OC03NDk3LTRkNzgtYjc5MC03ZWJkZDZiYjA3NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+MsXi6z/dOjNmOdsJ47RqNigxjljaOi5Yu4q8tdiIW6eX\nic3yYIAUqx22MVE2dNnWI+soQ83Zt96ADpbIPz+5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNqwXAxR2Fu47XBZmnlO2TwKV\neRUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMlXzQmoa+SImWEPnjqvjthIZVT+a4mvU81UZx5mTU3YAiAhWzUlcno9\n4V1zyVZb5sGUSL53xaEcL30GoHeGQ32eww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAXC2CNsLTDTwMa4iUyDIwDRAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc0ZDQxYWQtMDU2My00NDY5LTg1YTUtNDBhYzc4ZDY2MDAyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTJlNDRmNTQtZjEzMS00NTJlLTllZmYtMGU1YmJmZGQ5\nYThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECRtCcqS4bDg6vI6V0K/eto1U\nwerCcISf0k553AHWwh2p4XU8W/EZKOEXsgn9KETi2XJDVNz5T3VzocFM+CyEwKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiY6TG07x6xwBlJ+ep8W3udlR6o0wCgYIKoZIzj0E\nAwIDSAAwRQIgaReHsBZqaLD5/WgQOLAuQ6mo7AymGaHJYOPoV+c9cSkCIQDCrNQB\nNd28fDecFsLR1AdRjM3PAzBFPQBQPfne/L0ljw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc27", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `27` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISATvn0lEtEquq2DAPE9hlOtWXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1M2I1NTEwLWE3OWUtNDEzYS1iNzU2LTdmYjlhZDQ0ZDUyYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQwNGI0NmMtNmM5\nOS00MDhhLTg1MTYtZjZkZDFjMmZkZDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhTbpILRgvYPBp7zBcn0RpqBwz0Qj/6FKJLWfylTXZM50mHsrdeC0C8aoKpp1\nZIs22icWv19cK95u7dUXk3gP8qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbX60y9eXUMicRXXNTuWit2vEtWowHwYDVR0j\nBBgwFoAU5duRuB6yYbdki7dqXrwrZpLFnBIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgWt/WgmMJWBB4\nol/OVGbIe71NQBL8Rk6GouDH3J2gxtYCIAlhf6TtLbgUjrqbXDZL8fAU4R7tVA4M\ntr1uOLaTwLK8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeWvgk55nY5grWYw2lqxsOWyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTNiNTUxMC1hNzllLTQxM2EtYjc1Ni03ZmI5YWQ0NGQ1MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuqRNlaEY3ygTFcS4PpQBZtT8A2m5J00YxB1g+K5gseRVQ\nBh5Fin8SmL2xKzrpVnW6y4A58SktDMKTmVBHcZHPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5duRuB6yYbdki7dqXrwrZpLF\nnBIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLOMDa6J0yeQI9H794mUV7Ac/0tPt95BCEbmAgcBZweUCIQCR59U8vmMs\ngo5W5jxmfOpHYJbKMJKAobRMF6TyVqxyfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISASecjyXQS+koIvvQox04o+oLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQwNGI0NmMtNmM5OS00MDhhLTg1MTYtZjZkZDFjMmZkZDkxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmVhMWQzZTYtZDNhYS00OWVmLTk0NTAtYzNkMzg4ODRh\nNWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOP2R1vjzmgz4pV+ckpUAeGdn\n2V0t93gDeT5sLyy5XpZwj8DE8vKbm0sAOXVyRh0RclAIdSvWdgktPGpeJCjKvqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbX60y9eXUMicRXXNTuWit2vEtWowCgYIKoZIzj0E\nAwIDSAAwRQIgcKUNfXbpz1rwL2HLoR2rS5kcHAB1/D0ArbaohEnqkqcCIQCo/uXQ\ndJjjo1SNBnqm1flu/tm16M9hh3CcMYsaC3Ussg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc28", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `28` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbawsmfdbWVmqlXOg814G7vZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MTYwNTczLWMyOTMtNDAxZS04MjgxLTVjYTIwOGU0OTMzNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjAwNDI1M2ItYTJm\nYS00ODljLWE2MGQtZTFmY2NiNTkwNDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELk1wrxKySeUYPuUnOl3UvauJhyJRRauco1Sryo4xSE5416fGNoM5i1BbfmXY\n7EUmPdlVQFpScb4ekgp0gr6ZDqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP7JnTHZg7slTWxRqANz9z0Yebj8wHwYDVR0j\nBBgwFoAUCctM4J8YK+KxIj9ysh25nB0y3fUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC87jLh0RbC\nDLmWuMoZ+/TfTDhS3LYSBZkeRF18Fs+sugIgSrFQ40DyCAADlCfbdI+23locJ8r1\n+/C4PxbOVs2/rQY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVv/E4STg7Bn0LogzNZ3QIjpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjE2MDU3My1jMjkzLTQwMWUtODI4MS01Y2EyMDhlNDkzMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjWjg0D6wozClRXypQzatXL3HXGQjADSKUSGweazCqlXbi\nwx4m82iJUtRclCC7TeJNCrdPMl/T3A0hbFD92XMno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCctM4J8YK+KxIj9ysh25nB0y\n3fUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS6ir7DfbFIolfJRZN5OTIdH6vN/QCf1xVPU0SeL+Ii8CIQDSUltwomQQ\nTxBnVmql3LFnChjazrnkiS2T9mutRlwMjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAZzpGDHA3Axmp83Qi1V4hk1GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjAwNDI1M2ItYTJmYS00ODljLWE2MGQtZTFmY2NiNTkwNDU2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmQ1ODNjN2MtMzA4Ny00YzBkLTk2MmUtN2E1NWEyOWU2\nNGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEN7iPzoUw9l3ighrcAnhTvnU\nRLsOMn8jzwiGyaOqa8GvSlGnp/EmyTTVMz2j4dO1bzyR/p0kGxvV6fl0BgCw7KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUP7JnTHZg7slTWxRqANz9z0Yebj8wCgYIKoZIzj0E\nAwIDSQAwRgIhANzsgmA4gL9Sj9iRXKM8LEZgtNl0592GIMnhOgpzxvDuAiEAnkyC\n7PMABmT8FIPAubBMdYInoHN57fnWDti0m01GHt0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc29", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `29` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYZChHN9xhxdArHL4PFqaeETMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0NmRhYjg5LTg2NjEtNDQ0Mi04ZWRiLWRhYzIxYmYwMmFlMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I5MDMwNDAtZTNm\nYi00NjgxLTkyNTUtZjYwNjgxMmJjOTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0pm9vsibFMKicfIO+twv2K000I1NswFPiAptZVnGDrwLrCS/cdNJSTQupB5t\nsIXr37nPknfzWkVez55wMKoFYqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnMd4q/3qlVkzfvLIoL712UAwH9EwHwYDVR0j\nBBgwFoAUFd7F0T5vWysKfj6QukAKlwR00/IwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHnAue3kKSqZn9o0cyNWM+rzKG6Z2Rdzwm8lmwbCTn8yAiEA0MD8r+dvvPA6\neksev+idjqclMHpaIX2sjCcBUBLl6gc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYDABLQnuyTJx3LipPyTJknoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDZkYWI4OS04NjYxLTQ0NDItOGVkYi1kYWMyMWJmMDJhZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9vrZD45BlVJY2bny1mlUYB9GRS0nvTK6mQ1Y3ZCeCp2n+\n6h/6a3sn2+PWC99eUliNXn7/Ro9tYzgcHxmLS03Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFd7F0T5vWysKfj6QukAKlwR0\n0/IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL9CK0dw0VJAXMXCw61rvhFglh3Se+Ov/iG5l0zT9tazAiAxtaWW/ywM\ni4K0Z3jXY6hh9HRLRitm5bZCv10cRIFi1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAQ3XcBnA7BvCC3Ws6NKAtbMpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I5MDMwNDAtZTNmYi00NjgxLTkyNTUtZjYwNjgxMmJjOTQxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWUzMzYyYTAtZWFhYi00MzY1LWIzYzMtOTcxZGFjMTc0\nOTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3m8pRnpXOq6fb1blknXb9sRd\nG/i2wbSSpX/YJ+laOObq5QtqdgiJXPCY2W0KptXlJKiS1IrBeTV2l35+1TPTiaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnMd4q/3qlVkzfvLIoL712UAwH9EwCgYIKoZIzj0E\nAwIDSAAwRQIgX49OfIOw/7m//ImhObfRACJJ5Dmh6D3jbEbM7TnXcTQCIQDVm+07\nc0AjqXC+R+aoU02OmborlyOa4fx/JPi74pGCNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc30", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `30` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdFjamLYKGj6AIhsIdnd9NCwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0NGIxMDEyLTNiMTYtNGQxNC05MWNhLTY5ZWQ4ZDk5OTRhMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRkODgzZGEtNjk1\nMS00NDVhLWFmYzAtZmE1M2Y1YWU0MDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdOL9gCOipRQSIiImNKrxwIDXXbhnnmTA99PpLrF+vHRyKGEtwgUACxNI8qhW\nB/EXnlnzwNCR3JQwGdkK7+Fz1KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2ojPBuh44u0oXck20n9CtvD2P1AwHwYDVR0j\nBBgwFoAUDfm2ANAPn9JDsAKimLiga1yIrEUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDpollx21e2M88WRy1EMRcoFKsTSBh3KgDa7yeGuflt6AiEA0CxZeIIJTvvv\nBGpiKgqBofFxm34t+MuWGE+xGJ7vmxU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQjksmkvO2i8NsDDPFo776caMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDRiMTAxMi0zYjE2LTRkMTQtOTFjYS02OWVkOGQ5OTk0YTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6Gb5CV2QKl8Gc4cfk1j1H04xz5UMAxJDNqwwsi4KhR3Sq\nmg1NxlKyu4l/AXcn79M9xV2BNcbHuXx72h0pvqCHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDfm2ANAPn9JDsAKimLiga1yI\nrEUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJLo9RBM0Hxt5o3nbn3L68rujrISEXRoIOybdbeLtJ1eAiEA3VQTB73v\nqzjAeVQmfAlxc7wIfAw7gtmlAUNg0ErNJ+A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfZ1sTJ0BqVZz5AVFGWSHnF+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRkODgzZGEtNjk1MS00NDVhLWFmYzAtZmE1M2Y1YWU0MDcyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGMwZjk0OWQtYTFiMi00NmM5LWJkYWQtZjg5NDQ2ZmVj\nZDZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2LgE2yK3XV/GWjw/wxfyMjBW\nT2tza8YAY6dUB7Q+mQE7bEeYIvd0FYvvpN+VNrDHa+r1K+5CfjFnFjcEfl1r2KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2ojPBuh44u0oXck20n9CtvD2P1AwCgYIKoZIzj0E\nAwIDSAAwRQIgFx8e0w96Pby3CAmVjLjdV7KWpq9yMmVreWd4uKz/odoCIQC6rhCp\nJ8PU9Ky6etGTftMsTcezKRXhtnqsd0IiZTXy/A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc31", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `31` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAb/wJdWy+gzoIzs8gAxI7kaBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNmE0NTg2LWY5NmYtNGI2Ni1hZmE5LWNjNTcyMTk4NmMxNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNkYTNmYWEtYzJj\nYi00YThhLThiMzctMmNlMDRjZDAyMTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELQMStFFKQ1KX6z0S12X2pYhSwrAiyMqyjJTGlof6zW6GHZGJlIdjWchtAktU\njk/HoEe7QVWlSbOdd2XlvJrwnaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhHXaUA1KN9D21R1xUQxIpBPcKuUwHwYDVR0j\nBBgwFoAUSXSjLcHKzw0xpQWTDpn66NIliP8wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHBp\n5gx03Xv3Y2/tuS9flFddy4kL7IcDZRmevCXCDKcpAiA578KvMNIIcLWgA0gx+zo1\nehuDOHQEuFB2Pq4oEeBiqQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXUZvTCPx4FS5SkJqv3nY4Q2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTZhNDU4Ni1mOTZmLTRiNjYtYWZhOS1jYzU3MjE5ODZjMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0mozJKNcD96jIIzEvMdNz42MwnM+l46587kYVrYtDjnf0\ntxpCxHH2lziKiy+8ihHZayRNp5InQ4oCFnduV/Lzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSXSjLcHKzw0xpQWTDpn66NIl\niP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDFuosQp92n8JftWnC389RgDuVvXGYDv1yQsuxikYBSECIFosaRFxdg1+\nBOT4qLKHsg/z6pqX0R8DW7X3SAdp2lGF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAaKeV/nqNUxfgB3KtSWAdSWRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNkYTNmYWEtYzJjYi00YThhLThiMzctMmNlMDRjZDAyMTEwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWYyMDczZDEtYmM4ZC00MjZhLTllODYtNGNjNjgwNWY0\nMjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyqg2MJJkDZAnyTxUiOAuRpKP\nzQZy+xj/lawsO8hHTCEHWUQxPNI5vsLeq+si8XITrcqkPcCjbX2xWBhe4beNP6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhHXaUA1KN9D21R1xUQxIpBPcKuUwCgYIKoZIzj0E\nAwIDRwAwRAIgcE0rII9OUUNh53Syg4/MNm06YRDIz+FxwVUiLs94vooCIDrfsxNO\nlE5SoQNzjCjQ/l92K7R5+TL0cjwQ4HkRmzkQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc32", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `32` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWSCKKNtL1SloSFrhOtWSc65MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3Y2VlYjEzLTkxNDAtNDA2ZC04MDMyLTdjYzdjZjNjNTQzNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzEzNTY3ZjEtZWUy\nZC00YmUwLTgwOTYtOGFkNzNhYTk5YTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm9NxN0vrKdHb8mOg+lR7wI/HL3jPf0Uy2vbDkG0JLGVB+QHXXrzOm2ZSOYwB\nZfTGIejuLG2WBHVjKYs4EDUmvqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQuXhKg19yG9Glat9HvpOTZOuQF0wHwYDVR0j\nBBgwFoAUEdVwvRtbu6/9Fm3tIASq1TtAt1wwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCeKs9ZFc9BhS3Ixa0XVZGio8CL+QSE+EeXb2jfwv3urAIgdz5W\nV0x0SaM5I+U5r/xTa/IGeIHC5ORQF8ACEn6orqA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXOofGHCY8e6slN79rFN31HcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2NlZWIxMy05MTQwLTQwNmQtODAzMi03Y2M3Y2YzYzU0MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQGeQrAw4iq3b+oM2fJ4Fz+G/q2eluL2TtkCsUCekAZXqj\njTFD0ckpnt/I/hst9n/xSjF0UjDW5NIQd4NBS7gNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEdVwvRtbu6/9Fm3tIASq1TtA\nt1wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE+A3yWxF6cMWuYpJxSwnvYfi3qLvBKbilCii1A5cHJUCIQDmhrpm7Efc\nPb7deyFXYeKJaQLWY6m0Nqt9CqVKjJa3mg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATIrB+07hf6byXcA4BRfrcItMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzEzNTY3ZjEtZWUyZC00YmUwLTgwOTYtOGFkNzNhYTk5YTQwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTUzNmVhNWMtNzIzYy00YTRhLTg3MDctM2Q5NTM4NmM3\nMTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcwzlIGQCE0O6rqGbXmdlYG1n\npVZfvPtQiNAnjQY65UFTyoAOGEkIagqnENIkn1ES5Qu7n+UOtnMiNz/hdDaIy6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQuXhKg19yG9Glat9HvpOTZOuQF0wCgYIKoZIzj0E\nAwIDSAAwRQIgB4f8cRblnSPhw8OnGV6ao1r2bSHfpkn9tvot76yPWl8CIQC2eh0W\n34ojzZ+tBhyeWjsYfEEw735zjo0bXNt7l00K7w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc33", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `33` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAYXFr4f52CbvsqK5ktian8vqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MDhjYzk5LTRjNTYtNDNkMC04ZTlhLTQ1Zjc0MGU0ZGFhMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTcxNzMzMmItZmE3\nNy00OGE4LThlODUtZGNjMzE1NmRjYzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqdde60M3+oCMBbDWJLH0LZFsDE+dq6hGrvjKQNEj5M5BNEkfHvnLhHhP54Q1\nVhXujiQ0xhnEQfU+zIfaGVU+L6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH+XvbvTtWDfJVKulTrSnSrNuJaIwHwYDVR0j\nBBgwFoAUE1yF/xlvJuiwpy4JXD0T9ZDCFqMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCaqiAetE+A3jh2aTIQiJtg6GgK7jVl+dQbKSLiZxCx5gIhAL6f\nnGdDlemLtCBlyDI985TpJawlh1XcISIUPNyHfGcj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVWmaKhSIdkbBayM4ie61CuuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTA4Y2M5OS00YzU2LTQzZDAtOGU5YS00NWY3NDBlNGRhYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ55NPnPlMt050w5fUcPa11zZkEd71Ie0gHxZOaAHyKjpq7\nVrGoc8e8KYI5+NNHRzXdCXr8ZpFzAdDRuIM/A22wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE1yF/xlvJuiwpy4JXD0T9ZDC\nFqMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJHI4zrlLTJYb3F89fmGVEGGebon+zJBCoXIORkr6221AiBq/2Z5CIOg\nH4VeUrjnHrkBsAWyqlEEEserrtlDaGQJzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAT1xltz4aTBhG7qgrF65tV8DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTcxNzMzMmItZmE3Ny00OGE4LThlODUtZGNjMzE1NmRjYzQ4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTE1OGYxZGYtZWFjOS00OWRiLTlkMDItNGIxN2RhYmQ1\nYjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEupz2LmPPRwpjML/vFcSYyxG3\nmgiX27Emv4ayantpXLw48P1gpjZbM/O6krDrVIEVrM7Lm0s/uPZM3bMkrthmRaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH+XvbvTtWDfJVKulTrSnSrNuJaIwCgYIKoZIzj0E\nAwIDRwAwRAIgD1Qg2QtOYLg2fkwShL6cLM8jjlisk+hySU2LOASDP4kCIF3/KTkq\nsggfO7WcQrA97g3BaMEbl9n9hGjPSzocBUHa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc34", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `34` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAdeg+vrDPTS9Ij9cavtxPgxPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NDNiZGYzLTNiYjctNDdmMi04ZWM3LTRmNjQ4NGExMDM4OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdmNTk3MWItZmQ5\nOS00Y2U3LWFlNDktNGZhNjk4MjY5NjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2demOoyWqZlt78hhJi1XxTIHdRrwq6xh45enl8lxX5/888NB8nvGVfmj7DF4\nKio6hqy0tJlaxssYFnn67amHZqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTywYZA2loNBRu/sJ2X5AAKFukh1DAfBgNVHSME\nGDAWgBQaYUXBN15urx46SIXkYUGkJZRFijAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCjHr72WG3eRvdEZxuh5NH/RGncU4Ar\nLiyM4JMUovWcYAIhANpwqjj0DU/+M1ZFOFYYkfaJSYcENr5VhGIRZ1lSxAGK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdqEEs7c/dtjDwfHRCfOw0iCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjQzYmRmMy0zYmI3LTQ3ZjItOGVjNy00ZjY0ODRhMTAzODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSe1RsRoUX8Oc/wkhD3wn+QrDDefPEZQrCPAC8SV6KIQ1n\nKPOkQwL5OfUaj7TuiHJ/GehJkUmoqqUVeKyir1uso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGmFFwTdebq8eOkiF5GFBpCWU\nRYowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPi/Jf3UXkDS/BDQhkHvKIqQfVoabpyb9jg8wwoMsnZ/AiANkCEcQ4t+\nflJXNkE3ddhBeG4tX0GSNzLVjU/cg4FDAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAexcDj/itm6o4J0wwZeD9b/AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdmNTk3MWItZmQ5OS00Y2U3LWFlNDktNGZhNjk4MjY5NjU0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTZmNTk3MGEtM2VkNS00MTJjLTg3NjItOWRjN2M2Y2Fm\nYzY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAf3+MfGsgGEOOFjRwGUSxgOb\nGpIjnIX7RPujoSdqrZwGY5CrSOg4kD+3jqNsY59DPF+WN3YV7zs0nDjc9lrGQKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8sGGQNpaDQUbv7Cdl+QAChbpIdQwCgYIKoZIzj0E\nAwIDRwAwRAIgSARGihFjp8Z1DHBJM3BEvQvqAYF1LZQHraNKooUF8ugCIDLKi6TF\nopR2fjMvgRV41QmEdPgiRzjsTGJU78YPbXEz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc35", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `35` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISARp7ccrBD2Txt3Sqp8U/IPMkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5Y2EyMDM4LTI1NjgtNDYzNi1hMGU5LWQ4MWFjOTcxY2FmMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjUxYTdmMTUtNDAz\nYi00NzU0LThmODktNDQ4NDQ2YzhjY2NjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE98Ne92lzXgn7yzJJYgWZ+pX3Q1ww1iiSrU/nk22dbUDY92V64Ott5loE6/Dg\nnZPcY7PnHBVpz8w96d7SPYqmHaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiOfI8Zr1NWxF1GhU7oZacq6WmEMwHwYDVR0j\nBBgwFoAU5sp2GHy/Whf3zP9fqOtWXF2wItcwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDK05YvP+Nm\nGr+1hxcA17piqLHhKac9wyt724Eih3r3aQIhAOtJLF75FxyoHvdGeUMzmWZrq+s+\nHdcTzGwOq6PoFxqH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAditVM+nZl3krsrQNaqnSFUzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWNhMjAzOC0yNTY4LTQ2MzYtYTBlOS1kODFhYzk3MWNhZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhS4HZesPlBfLUIyUyr2ShjqLHXlYGRM0usxiKU23+yYbc\nljpoZd0EPtKyfq617TzO7s7R6J0RsO62hS2nf801o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5sp2GHy/Whf3zP9fqOtWXF2w\nItcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ2ZyxPlsuPbBFyydq5Xfiahp/6qy+Vhw6FCmb/IkwY2AiAnDjnCrwDP\nU1PYEqniaD5lottdeo2jw8+UvkGFFbavaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAaOsiQknvDWsgb+Y/UoyLErjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjUxYTdmMTUtNDAzYi00NzU0LThmODktNDQ4NDQ2YzhjY2NjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGY5MWFkMTQtNzhmOS00ZGI1LTk1ZjMtOWY4NzFkZTJh\nNmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGPUboklrsljp126vVTISegTJ\n+/FzZ+RVEJLus4ViUesqI/sw8JERE1sftaBtlE6Tuq3xEh3JMZaCbq5hOLKnsaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiOfI8Zr1NWxF1GhU7oZacq6WmEMwCgYIKoZIzj0E\nAwIDSQAwRgIhAJVb9b+lEazL4rzU4aOxaOHl9IWgG/3IE+/J6So6u0KZAiEAzxnO\neuiOHiEcmbOhERJDM1ZOTKdUudVXY7ePhXSHrI4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc36", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `36` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAWcJt59kh15YULdl4LeNsbJrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyN2NhOWFkLTAyYzUtNGZmZC05ODg5LWYzY2ZmNjBiZjUwOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZhY2M3MTItOTQ1\nNy00OGQyLTgxZmMtM2ZlMTZhMDQwMjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz06BQiNPrzDp5IOQTJlKQ7zMb26sCweuxt7fXuwEq+9+ZDjAnesz+/zKVSoJ\ncZ+jCQbiYeLIGMbNtFVmMYkdxaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9py4Fgu9Y+r43//iSoJncxZKNMUwHwYDVR0j\nBBgwFoAUKCiMfB7NJ98Hr+hD4+/izj/QzoswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDQKqBV/va/\nz1mkoGXE6nocaZBVLDQnuykNpHpBpnDmbQIhAPC19VM9zJS4g5vNnN7T8o8JK4mN\nFLDLEsR9PPKylJvM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbzIexgg5aC34dRUMhRYQxuDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjdjYTlhZC0wMmM1LTRmZmQtOTg4OS1mM2NmZjYwYmY1MDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyxoZCvLenmpvU+ZCCyE5CeXBoMAOVZpY+L0LVcptvnXL4\nhactox/i+oG/uu2fO3vtV8AlcqBXgnrHBLCfKzrzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKCiMfB7NJ98Hr+hD4+/izj/Q\nzoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ6bo3lUGBgvbSZV37NMAen8cyZUOqesSKLyj/CO+/6wCIQDpnDINcmTK\n/EaqT+2TTMpZMElzuLGzszDbiJaAd81AUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAU6xP7Fd+N2VwCYHNT2M+VX6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZhY2M3MTItOTQ1Ny00OGQyLTgxZmMtM2ZlMTZhMDQwMjcwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2RlZjgyN2EtZjQ2OS00YjIzLTlhZjAtMjVmYmJmN2Q1\nZTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcA6PRwT06jINtpavkhJKP4UX\nIUxYVi0FuhjMaffgA9ma6U4q9CHIpOLBnQsYcqWPla4D5kNYJKU/VkcWuYCrLaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9py4Fgu9Y+r43//iSoJncxZKNMUwCgYIKoZIzj0E\nAwIDSAAwRQIgCJ5RRpopAt1fHzDi9P6rM/Kbm3kDwOcSnfoKKHHVTVUCIQCl1oAB\nYhxoGvZrlGsoq77kL8eY0tGsoqbhVTPs1oNRDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc37", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `37` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAVm1iemYwGE6xzX2CXWTiTncMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmNTJjODQxLWI0N2YtNGE1Yi04OWNhLTEzNzk5NWUwMmQ3ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM1MmU2ODktMzIw\nOS00MGRkLWE5YzEtYzYxMzkyZjA4ZTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3DkyqgtIuvK22gBCZULnmp0rF2CWHbjiyVJYLiZhCbd4QOcolXPP8yQ/AMiU\nh5a1ys4qjw7Ai5CRvVWPVuiaDqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcFZqFSft+P212LFUeQC8rItGbbcwHwYDVR0j\nBBgwFoAUxgkHy9z9897/xKkVTJPNRzXvHrYwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAyh53mg1x\n4sCeAElgc+rt+Qo4h9048/Lov/bI2CRwwKwCIQDxKq8y/hXpBpw1v89zYz3DmdhS\nvuBjxNProUlnYiUyqQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT53IPAND2/4mhovHGDO8FbaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjUyYzg0MS1iNDdmLTRhNWItODljYS0xMzc5OTVlMDJkN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3JEhPwn3SdKCuwE6GfEoC30UdJxewH+oM1G4ZM3pcYVTM\nSobp0fdiX2qCg3mxc6SCkvAwwtnSr/2ESonN/GHto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxgkHy9z9897/xKkVTJPNRzXv\nHrYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPZ/4x+pJphPPgpFAb6L6CoIm0min76Rdx4Bu9cTs5twCIEbzhIGjtkzx\nwGcWAB1DqY8+ilmEmANjg7MtE3nTeTWw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAS3zUkxZZiCVK5jlGdM4RRdfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM1MmU2ODktMzIwOS00MGRkLWE5YzEtYzYxMzkyZjA4ZTEyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmY4Y2ZjZDktZjEyMy00MTQwLWFhNDMtYzUzYmMwMTk5\nMWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3P6UOT3K1DEJ+MYi9VbuHWJp\nbdeFmLp+4souQFuphOJCYrbWYTFnym7ofMhxmK8MvrFHvZSqscCU9FcCkbn/OKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcFZqFSft+P212LFUeQC8rItGbbcwCgYIKoZIzj0E\nAwIDRwAwRAIgLJHosaNapnwWJjQrnbasbwRexHdwHxQscEPhEfq/ywYCIHwnENWJ\nV4vg42Bd+GbIogXozIklN5OvJ/xv5AEBjcOz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc38", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `38` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAe8qLKiTJKvRBkLv1sdDRqhEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhZDQ5ZmUzLThiYmEtNDVjMS05N2UzLWU2NzA5YTJmNWQ5MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUxYzk2YWQtMjM0\nOC00MGFhLTk5NWQtNjQyY2ViYWMzZWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWX1QSD1TdUWpNZaIiM1aiz6KXKudX5uDib977D1IkxxOxHeQ6/Cym9t/oxHd\nkkBEOe9riRMSmYwJL+Eihn7IHqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0MsTwrn7DX4HtDhUBpV4hQ/9MIYwHwYDVR0j\nBBgwFoAU2fY1tH/TIPGeg0fe9rtF0TOmTp4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAkv62ofzllsMXmGQa1iuvs+0m6LB/uManjU8/tczI/AQCIQCHJD3gwhwD\nQaAmDJClDb/RwS7pPcbasHmz9hRGJPNMag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXr4l+LbgDPVavVinNF5ZIUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWQ0OWZlMy04YmJhLTQ1YzEtOTdlMy1lNjcwOWEyZjVkOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMZKfT7HuOmuO+FvNxqwa6YjuhCOISiB5tlhO+AeD2IZdH\nhhuH7n7+myHSfEv9HQ7tGyeBc/qtE0KLq7359eXgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2fY1tH/TIPGeg0fe9rtF0TOm\nTp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKCxgkbtCqQrQRJGiSbzPoN3iWytbvbLej1ZKpoZQT4GAiBrZaAaWyqs\nko+lALj9DaMi+HnnenBn6Kt5zKaOPivczw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAdMJQe0zKQNlJD/UqHssHksuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUxYzk2YWQtMjM0OC00MGFhLTk5NWQtNjQyY2ViYWMzZWJkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTY1ZTE0YzktODhhMC00N2ZhLWJiYzAtN2Q2MmZiMTZi\nODIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBTQWUAnYXJwuUL3QtroBbtD6\nBn+DHGK4ZmxlRJ36AQ6gTt6lV1H7kLBTeFLkqoUN3ZX7oSUNLBEC6ZkKLR65/qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0MsTwrn7DX4HtDhUBpV4hQ/9MIYwCgYIKoZIzj0E\nAwIDRwAwRAIgNzU4GjpEBv3tHWlK7ZKm6sz+gFV1FqEQ8Wzdv+O0HhICIEuYO+9n\nNy5lMfE1vyineHsLt4YsEW1aLBhe/8Rgp1Ek\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc39", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `39` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAcGDxXB7WWuBBz0f3FlX+x1SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlMTA4NzE3LThlZTEtNGZlZC05MGQ1LTU3ZmZhMGFiMWNhNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI5ZDk4MDAtYTdi\nOC00ZDU3LTljM2UtZDI2MDlhZGE3ZTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2SCWWvXiEDRbmNi34wExVBhG7Tmx10rdVa5ha+fBKC98/dxonVuqBlX9kIeH\nRx7kJey0g2hdZ+Wa4TWmVO66laOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0zbsxpDxG3XVk36X64/SJvHZvSMwHwYDVR0j\nBBgwFoAUtRF5TnN9oL7V72dMGY+H1c3ZyMkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBaRIxIT63FYDwdaFBQt6zDSsKdLBJ7uUTuiXT50W6D9QIhAKBMTWQ93cZL\nLq5q8qPbZPahqrT4nb3M/81ROWyM09LZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAROVV6uGircnxMQi2n+QBtCDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTEwODcxNy04ZWUxLTRmZWQtOTBkNS01N2ZmYTBhYjFjYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfuEwzw4WGEIZ7U3yaP5YuaK9npxpFKMbrlcrIkCSgdq8S\nurmmDgunpHUIELKTSHNcGsdy/3nEeDsWTDaQ1N20o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtRF5TnN9oL7V72dMGY+H1c3Z\nyMkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGvmovW2Yx7uO8emgf5H/qWffOO4N0YfhjCeDS4h8hzACIBV9CQrw3lIB\nnkyXwOKd4MStG6FurEVhIkU3EXO2ioSb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAVIH+Wk897617rbkcPNBiMBUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI5ZDk4MDAtYTdiOC00ZDU3LTljM2UtZDI2MDlhZGE3ZTMwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTA4YmRlMDgtMDk0MS00OTZhLWI4YjAtZDllZjllMDcy\nZGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5CFKo176De7UjvFcCsGGfr0S\niFa/EtSBV1LgCJ0B0Vt4n6ortm/yeW4uIRyN0J5Bs37Wod/jAkpZwXsnRylqLqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0zbsxpDxG3XVk36X64/SJvHZvSMwCgYIKoZIzj0E\nAwIDSQAwRgIhAJP2xRv87+Hzxu/f4RAjERApJh2DXyQYOuxdVjsvc+PgAiEAyfU2\nZiRpvBzphYoPGcnN63H8Rit77uv/VdlXcs9KOx0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc40", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `40` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAewk78o9yaoZL/Y7iI4deOisMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwMjNhM2NiLWEyMGUtNDdhNC1hOGU1LTUxNDlhNjk4MGQyNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU3MGZmYmYtY2Q0\nNi00OWEzLWJhZDctZGFlMGVhOGVmMjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEekcHjMPo86v0pKtDrMvxjTnxmuWfbWWflsAsUK8xhMycT+D0q42OQAQwT4Y6\nGonlMxqSCqwYXF9tCzB5SmVRgKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd3jwXshcyvoOaeobjNaI7jpuS7gwHwYDVR0j\nBBgwFoAUsVyS89AE29o6kVu+ZMxBuG6ED6UwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAI\n80hUWsJnW/aCGaw8CVdxj7jpAqxzEO2bt/5ivq9wFgIhAKz+J9zaQztEK/wegxzm\nUN23yc/V7T78F8KCKg33b8aX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfRJVUvh5Gos7XtR649RHJzzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDIzYTNjYi1hMjBlLTQ3YTQtYThlNS01MTQ5YTY5ODBkMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQl2N8sq727dHZ7L9mK9ZMk7LuSP2qrfMV7sfh5MpYhZxCB\nPJMbbPfSzSy51GCz+kLdus57f+w3jr2ayBZ7ukNFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsVyS89AE29o6kVu+ZMxBuG6E\nD6UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBrLKqe0hgl6sp+LgP0fCWGtp+UUlyPateY1RYirYDjoCIAwQQ/amyKAG\nk0oKFjtnjivQGI+OjxraCzbodUU9D8w8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISARnSFv/ziLtqgL4jBz/lpzysMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU3MGZmYmYtY2Q0Ni00OWEzLWJhZDctZGFlMGVhOGVmMjk1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWYzNWY0ODMtNDA3MS00YjAyLWE1YWYtOTdmYWU0NjQ2\nM2RlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsoj9J4b36Owm5ljoxUsTYWx5\n30XIjRTyzI9zNx/XJwDzMGHvvFEUcJ4djyUNmRmBtlK0r29sj903FQ45cKRuLKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUd3jwXshcyvoOaeobjNaI7jpuS7gwCgYIKoZIzj0E\nAwIDRwAwRAIgKwIxr8ImV0hTm7r2rA/1hBaDCgbasHBI1P/cxvcU0vECIECZiXm+\npRRPdwbsL6QWoEEdRli7CEjPC0faGmlr7eEE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc41", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `41` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAaxaJLU1YfMOPV/IU73HAN78MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0MTkwMWNmLTViN2EtNDQ4Yy04NzU4LTI3NTU5MWIwMmFiNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNiYWNiZDItOWUw\nMy00ZTM5LTlkNmYtNTU2ZmU1YTVkZWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJHgq0BLyP4q/iVFb/kTA01B9Aa11HUSEzk0athDJoLh4Mr51fpx6AYjHfNAx\nH+R8mw3GNUNqHI+UH/ZKg9xywKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ6GSfAcGGYG3ZoShCrPPjaDVS6UwHwYDVR0j\nBBgwFoAUtSOn74Ymz7yiC8IU5ZPM4yehKHYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAl5Ty6t9+8Xjm29IrxJGjFy5TwOT/xi4UTw3c9cxXadUCIQDm\nAGiBr31anHViY+XmkRrW7OP4XGTz0n6cnRRSdAogTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT5mNNWYlRhXoMnUH2oJj9BzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDE5MDFjZi01YjdhLTQ0OGMtODc1OC0yNzU1OTFiMDJhYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLpIVR8zMOXnE4pmzlS0vDFHZmn8I5fg70uZ9t5uXr/K7v\nKKdo1c6MzlxrPN0jdSsnPIL4vh5lPkv8YZP7IVT3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtSOn74Ymz7yiC8IU5ZPM4yeh\nKHYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMi7mMNDvqBXPGGLu5KP2nBzIXYHULTc6kGo1zmvsrCpAiEAnfsN57fm\n043zNFu3FETch0jQgiDO9d+RGYqRW63T+YY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAe356w2pEVYWpLPG/m1j8BV8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNiYWNiZDItOWUwMy00ZTM5LTlkNmYtNTU2ZmU1YTVkZWViMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzgyYzkyZTAtODU5Yi00MWMzLTgzOTYtZTAyYjBjMTBl\nNzIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETnwz8KWD64y5xMNSb6YhI/OT\nICdtYeVbKgHqyWeHAKLlqvUs5uuEoxuS2jeahKtBscfgdYYhSsMnlr8GMGzIKKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ6GSfAcGGYG3ZoShCrPPjaDVS6UwCgYIKoZIzj0E\nAwIDSAAwRQIhAOBJ1Qbu72MCXh7JhtOK5WdzKDdszjEi27Maw0Du9YzwAiB+H9LG\nxTWbMpeH8nSuxL2bMw/9c3VBf+nrWTTavMSbBQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc42", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `42` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAU3jlUNrYYAg1o+jEaPAJrYBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2OTc2ZWIxLTY2ZTktNDEwNC1iMjRjLWJlOTNlZDQ0YzU3OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZkZjg4MTMtZjNj\nYS00M2MzLThiY2MtNmZkOTA0YWI1MWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpICEeECCYVHiR/ul82thgEXdvzC6b4LYGpnZN/D7UJmHvaZys6a2k/KWgkNm\naWbluNfI6/9CIj0Yg2mKLOYnsaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUADerbo5OR53Ba5J96lt1187f6+UwHwYDVR0j\nBBgwFoAU+zLyUqHWwHcv+CFauRjaqNgRdSIwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBP3rbA4J0tUBjNJwRr0G4riJb2z4lsxUjRzUunDceiDwIgWyax\nVPOvhRLtUqAiKjIoEHsV3FxTBHKR0Q+i5DLxDfM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd73sB8XB7Qi/nP51BHymip1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjk3NmViMS02NmU5LTQxMDQtYjI0Yy1iZTkzZWQ0NGM1NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHiF0xur3jiDXjSxXZSSkdL6ZT/MMa7VPUyW/JnXdceWIc\n6mTHdtaH5aJaQw9y0wU+x/wDDz3gjr6D9Kt0kXTko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+zLyUqHWwHcv+CFauRjaqNgR\ndSIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL2oZFxRaMgmoSDJ93t8GuauK4iKJ3IM9mvfgbf25JAwAiEA216KASNN\n6S/x23h5T8cjgrY4JO3KU8mMxZ0mf6ntxz0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAWYbaJ3jJOx7xyJAJzR/XEtpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZkZjg4MTMtZjNjYS00M2MzLThiY2MtNmZkOTA0YWI1MWM0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzk3OGY1OTctZGEwOC00NWM4LThhMzItMTFlNjhkYTQz\nNWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/1UGnUXLe/zGYnRFm0O1Xc06\nyw6cJmk1wAQrIP50ubhDC1Vt5kQnoc+F03EZXg+kLi26mbFhlIaYjjjUczcvwqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUADerbo5OR53Ba5J96lt1187f6+UwCgYIKoZIzj0E\nAwIDSAAwRQIgCp5orNCB3c6EYuxsFgUypkDaE2w5BJZv1FBBLxxj6c4CIQCn/pNG\nUp5eiOVOvjHTZ/7GDprXXsWi/vqP9GreegEnnw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc43", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `43` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARuGWD4mhjD1WsYFjDcyKEzCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjMGI4NjRiLTdhMDEtNDljOC1iNGU4LTYzZDFjZjAzZDJjMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM5NzhjZjktMDcw\nMS00YTdhLTllMTktNjUyOTE3ZmRjYTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEijt5PbyDcmLAW4kYHYrpjhw+MnYeAgD3SPAT7BFmQxl88cqjZUlyikG+/QXs\nBXVy9rhZQttd70jvo0QKV9CT96OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhVszCjS+EktZq9au6xf4i7IsTlswHwYDVR0j\nBBgwFoAU3aQTcgZsbV5Y6RaOIM6DIXQRNk8wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBSPRFjoHh5A88z\n8sngBFkj1i91X6qEhf3Td+zsF5IxLAIhAOEReGBrnZAxP/9XKGfK95btSpwyh799\nR9TvSuD4LwTi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbVcE3rDykP1UWgtFfdB0ha4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzBiODY0Yi03YTAxLTQ5YzgtYjRlOC02M2QxY2YwM2QyYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATG7lBGlnhkOICab/TU3m+mbHYOWiEVVcP1MoqHWgnRtRfk\nJrFRZia8mgdywDui5T1lBPKOeYzdtncHYlXL/2hEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3aQTcgZsbV5Y6RaOIM6DIXQR\nNk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOBF07uxV/xaNUcLMv0N/SITO67ch/jlYoiEVtVpQOSTAiEA41m2tbvd\nNrQYsyfNpFjPSKwNiymqWuXOQfp/RAx4/nY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAUc7XXYe7BG0ryQCLE6Un5U/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM5NzhjZjktMDcwMS00YTdhLTllMTktNjUyOTE3ZmRjYTYzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODM2NzkzODgtMWU0Mi00MzNhLWJkNjItZTAzMDNiOTVl\nMDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8xtsVRa35pobPtBUXe93Rfcw\nudpufq2v0YVgpL01Ewy/j+cbTAu45Oy/JTiVz5XNSrsNxjLXnVsnIZ/cfzxwZqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhVszCjS+EktZq9au6xf4i7IsTlswCgYIKoZIzj0E\nAwIDRwAwRAIgGreNTNjLYNYt/b2MSB96ktGyXD+0r4Cf0e6ULMDPGV4CIDhOXWfU\nMieInSAewGNxRIsbMnvbB7GzODmY8u5wbuIj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc44", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `44` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWUKKjUFnFZPf2yXMjdSUFl/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExZjM5Yjk5LTNiMzctNDE1Yy1hNzEyLThlMjE0NTFkNDQ5NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIyZGJmOTAtNWE3\nNS00YWNjLTkxNGYtODdlNTYyOTI5NTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnBUNhUDz6GLYslySTTc8zp3nLmXWr/XX0G5mRCcVBQyohIf83a5/JqvGb4b/\n2+hqOtXuMGJeCbcC5V+oRG09/qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGIJ850vxWAYlJCumhbCACDcxcygwHwYDVR0j\nBBgwFoAUTRS78qKCH61KVFjrDilS7dN2/0EwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFZptH2XLechNtXp1XTq2cMQjT1dfEcXh3MScLb7b3vNAiEA5utk8mEfsQwP\nGNtdKI/lTnPsYbBtQ6qWEM4gnB6Pevk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWM1RcROrYC3Nj8vZWfL3iMGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWYzOWI5OS0zYjM3LTQxNWMtYTcxMi04ZTIxNDUxZDQ0OTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQG5lRyiUFJGFZEZma5Gp2ZKt+swjnUT6H64hwv50own5I/\nlVpbsYFhtcf6ojVNh4JaVO6CIbshcnfSkJyV8tPJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTRS78qKCH61KVFjrDilS7dN2\n/0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPQjC8cnLvPazNK4Wopva7fIff/Qwm8h+inYfxhBjy3VAiBpPWd6q2FW\n3kJX+VUj83wWToarEItuINQJRSJ+TVcSYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAfe7OYT95sbrmMR4S1rRO1oWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIyZGJmOTAtNWE3NS00YWNjLTkxNGYtODdlNTYyOTI5NTNmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjhkM2EyM2YtZTc3ZC00ZTFkLWI5MzMtMzZkMzdiMzA5\nNDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnXNLYicoX/cXRRbGPJey4GKu\nNyfVazV3bH/TowVxTxRKUdCIxjE8I6VJ6wfTtbSlKe0EBFm/D6RNtME8ubOCpKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGIJ850vxWAYlJCumhbCACDcxcygwCgYIKoZIzj0E\nAwIDRwAwRAIgCJkc5kildIjFlUEvn5BUZ1qAvFJQlOZE0jNOfKTn6g8CIG66RUmQ\nNiUOTIX4u2/NDXBDZb0F9soNLMDfEPpxI3ZK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc45", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `45` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVdWKMDr2/bgM4BadvlMJxOJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzY2JkNzJkLTI3ODMtNGJhYy04Zjg1LTgyYzJiNDBjM2Y1NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE3NzJkZTctZTA3\nYi00MjVlLTk0ZjYtMDE0OGRmM2M1NTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzHsld+W6K3bXp5n4M9Tk4UNSKMNeYvYpFfxaMjllkZcydGQZlKgSxA3RcSmq\nhgh2FsBDyew3hnHjnUc5Sgp8DaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Uht8JNsFTn3YMugAX/GtnjcSGQwHwYDVR0j\nBBgwFoAUmFlsFPZqxACIDgDPwZVW6CAFIZgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFdDuxeg494lZoV+VWkPxpRc0RwsZGQeGEwW/Ysr5DjKAiEAxy2hInB2xxou\nUXLo35LTGfhP8CSPws0ck95s+NhgD5E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ3RMG84XDIqiwZDNjkqAFPQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2NiZDcyZC0yNzgzLTRiYWMtOGY4NS04MmMyYjQwYzNmNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXK8V/Tz+1YvTm8R1wSiPM2aNh2ypqaF7B3bOaqftgSPad\niH3/ZFBXU4xFl1NHFP6WgYEVbrG83g81WSSvZxlno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmFlsFPZqxACIDgDPwZVW6CAF\nIZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfq1nko188ekQehSZfpQZfyypElbECxR6G48CPbTCiEkCIGZaTeWsjMyI\no+E8FjSK1fC3HZjQBgEo9U/F23TD7ZaR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAfo37w2DcTWGEQ5PBN/PAFB2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE3NzJkZTctZTA3Yi00MjVlLTk0ZjYtMDE0OGRmM2M1NTlhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmNlMDJiNWQtZTU1NC00Yjg0LWFiNmUtMzY2Zjc4NTU1\nNzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPfRywrHMNpXj02Ej3xRIhpgH\nWGizpIu0UTL79IzHmn7QO/EFOIQOohpP4KB/V4afR5p0k7u8pYjmrEEAk1YLf6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0Uht8JNsFTn3YMugAX/GtnjcSGQwCgYIKoZIzj0E\nAwIDSQAwRgIhAMfkxUxkhNyo3Zwe2p4aX3W9X+uLsX4Erv4s1dWnhTD8AiEAy5ex\n7d6gMib2n+ZM5QP5At/4pvdgMauOUP848B7vUEk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc46", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `46` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAd6KHLobvggQ02draZwZDPdyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmNWM3NDgwLWU2YzUtNDAwMS1iNTlhLTBkZWQyOGQ3YWU4YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU5Y2JkYWQtNTQ1\nYS00OThjLWE3ZjMtZTg5ZGRiN2YyODc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ3eEung6ZWKlsPTM1hUS83qDLaX2XejognrNNcKt+63LVOJJMiqncEfKFBcO\nF/angop912HMRZ5x3Wou+yUZr6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+960HVQIEkYaVP32a4Jr8Ze+f20wHwYDVR0j\nBBgwFoAUgWKnbYliTpc94GqKIfRh/2VBZVAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA160rJGIMfHbOoklouF+VDiS8cvU9jXI6DPUBCeMnUF8CIQDT4E/71PHa\nUpqereN4FrbhracrCxN5G7YoIHVPs6OAnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdahqkuoxqpZHKh/qybVmDgpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjVjNzQ4MC1lNmM1LTQwMDEtYjU5YS0wZGVkMjhkN2FlOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvdcttfQ2g5G+ZJqb//XulOYxC44sbh0WR0LjHdAIGBJ8j\nI0ght+qgL+/saFq/4iMExJhrfIVAu/yZB7HY/Thxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgWKnbYliTpc94GqKIfRh/2VB\nZVAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJFBEcqDf4GYK+ppRBeVx+ARCnrxcAeMTg5+ODtKxdrSAiEA7SEqblHo\nkZbaqJUOszRA/CCfOISs9fTuF7Wxcq3kgbc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAU7KZgL1zniOIv2KuTCeAm+lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU5Y2JkYWQtNTQ1YS00OThjLWE3ZjMtZTg5ZGRiN2YyODc4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzRjOWQyNzgtNTg2ZS00NzY1LTliNjAtMGE5Yzc5ZmYy\nODNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtQx6ne1NQ7DBBNT3d8oQqxm8\nF/FKX6PLhKvLDdgb+5mwzSg8wge3svii3Kvx6ms6T+M5JZeP2S4vKjzzQ62j3qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+960HVQIEkYaVP32a4Jr8Ze+f20wCgYIKoZIzj0E\nAwIDSAAwRQIgKvZ9cJO0l8jamXzeYmbcA74dgANZsGzbtsdQBuSsHboCIQDagg3S\nG9uL++kdl+HsrnbwA5AIsP5jfgLODJvUCYCj5Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc47", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `47` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAaQlixSYjWsmFTObezGyWbKBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNzljYmI3LTQ0MTgtNGUxYS04NjhiLTIwYjQ4ZjI3MzkyMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjYyOTA4ZTgtMGU5\nYy00NTg2LTk0Y2MtOGVhOWFmNTAzYWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6z7XmfPKG0SwjVUVgc3pSLjS3sEbBIGly9DZAWXmqkM362Xy5dwWwfluMlMO\nJBG+l8jXM9AaLlW003NJTC7jBaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY91ci1gEtsrpYDouMYgSrGtJXM4wHwYDVR0j\nBBgwFoAUpuTb3VbNZNsvAh+Sr2ccwY24ggswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBP9QCJ+zYByTlqUMwBNdZX7+t8epzafEx6UT9NQ1nz\nCAIgag0eeStcUFoR7GuBTEo0tOf2lp/aQ5OQOlFIt4lX7kU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUuX5gq+0yQT+BI475/3g+3XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzc5Y2JiNy00NDE4LTRlMWEtODY4Yi0yMGI0OGYyNzM5MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnrpnyqe/Ea+KTjcEZijeiBJvNBFASySs7HqJ2GegL4Uyv\n4m+ksO7tOSzu7/ZwhTl3x2OKebyhBwziU3lZbzH2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpuTb3VbNZNsvAh+Sr2ccwY24\nggswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO2fVtMVBGcjuGLzTI4h222+t8iBTtg4CqnbNXjJLvTtAiAmi7pG5UFO\ncPCqlbbyvMXCS89g6oaVKWYAwVnHQjgYwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAewTH/JPkuMAh94hw4LWpxvtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjYyOTA4ZTgtMGU5Yy00NTg2LTk0Y2MtOGVhOWFmNTAzYWM3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzczNzRiMmMtZGMwNS00Y2E1LThmODQtZTdiM2U5MDBh\nNWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+GHW4AGyet7bJ4nfD/nbJIYu\n274rhaL7etLb8aF7KUGnX7ENMO33/fB5gsSqp6QXJ6dpUz7QpVwiJDLzEIjmnKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY91ci1gEtsrpYDouMYgSrGtJXM4wCgYIKoZIzj0E\nAwIDSAAwRQIgAt7aojUCUlVEAi2tFScRm9fK96bsBubf/OLhOgFs8AACIQDwifgF\nUBd1Lb82nILSk0b//IL/ZdrHv+SdXXYycRJz8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc48", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `48` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISARnjjU25/oEiYqA5sgo6K2A2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjNDc3YWY3LTYwYzItNDNhOS05OTJhLTlhMDQ5ZTBkMGFiZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYxOWVkNmEtYmY1\nOC00MDE3LWEwYjEtZTU1MDM4YWFkYWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpuZ1aZxG4wIgDT+l7qRlDMD7gE6H5ciVcUM8iEqPbOnpBxR6jA/gaspiDrbK\nXD3cqMibOXCxbgHyhFIp+oBzgKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrTUQmX7ABOM37ihJAFMkGkL5SlowHwYDVR0j\nBBgwFoAUkuKhKLd4jK+VhexLwcujv4NHg/4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAuw11fWS9Iz6AOqwEGa5hqGB5y4et5bVOCoEEEiFI\nASkCIQCwYjtp+Qe0bb0aAfZbiXCOqHcm26g0tJIT3sYg+jAjeA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARwvPK/ybL7ZXnOPuPb6rUgOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzQ3N2FmNy02MGMyLTQzYTktOTkyYS05YTA0OWUwZDBhYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATu7N3IEaQBPOhaTEP7OdRt9LAp1qwbp2Rbc66L9cW48cVi\nvD47+vFpC8lKoH1OTnHPnCcARp652UyIuEX8jMrzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkuKhKLd4jK+VhexLwcujv4NH\ng/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH1CHEq6OMmiEfICmG35OTKgMj/wQuTMAiwiAz+VH0MgCIQCgaWPKN+ED\nvHMJfdCIRLTYJjl/v/bvJEgbMkzUo52qfA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAZozCD7+jb2c1Dl8KLOcaJrsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYxOWVkNmEtYmY1OC00MDE3LWEwYjEtZTU1MDM4YWFkYWU3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDcwNzA0MjctYzQ2OC00YjYyLTkwM2EtNTg3NGZlMDc5\nNzViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJCXHQKV+U4M1Xd06qLijxOkA\nqaipt+FjayOakLmaJC6W3Td6+1jXzsX4wUotvgwh8D7Rtw+cciTfTj8BWig83KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrTUQmX7ABOM37ihJAFMkGkL5SlowCgYIKoZIzj0E\nAwIDRwAwRAIgHGPpwvY8A0hs8XIWQnYbMfBpaxkK6PzDf3D/7P6/4YkCIFIQxVQT\ncPxvV9zLJNSRm2hzq8X6igksOCdPDbboTrwD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc49", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `49` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAXapmHb2cNlqjheUJgofFFifMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiOTM3YmExLWE1YjYtNDhjZi05MjFhLTIzZTgwYTUzNjBjNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA5ZTExOGItNmVl\nYS00NWFiLTg1NWItYTI3OTRkMjdjOTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwzwa1zx4HTr403QxB3GS1NMoBh5CO6OtwYQ+XRe+tp8aaJUJNO9R4y/Eg1ay\nzrkP8d5SmQ4oGdhycSxfuGDrqaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULUqMF8W6fboc9j/hf6HH45de1XcwHwYDVR0j\nBBgwFoAUOq0g2qgGsfFg1Gkur1ZjXv/pku0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA0WZ5VVyzTxZuYDFwH8pMt/qpPwlsP2yUO9b0NUY6j4YCIQDx\nj5CNGkNOoLVw03h6/jNL//hbYxGWLL0UOUoAiGsXNg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT4L5sd7Sm+lCVQ+Cery/iptMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjkzN2JhMS1hNWI2LTQ4Y2YtOTIxYS0yM2U4MGE1MzYwYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrdTwC5uAyjENLfqHusAU6SiHVCHkbHQr6aBPrfckblVxg\nHQzbMWjgcKGE/uMiQjeZLYdW4HpMMAxLR/rLoNSHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOq0g2qgGsfFg1Gkur1ZjXv/p\nku0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANy7ewihZsGS9QhFBU+Yuzup+JJ3cZX0Heresybr4MgdAiAej15BRVS8\nmgHU3F+VvNL5uWwE4RQ343jxbxOPywNjwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAULGvZPbE8AZBieosxOqQM16MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA5ZTExOGItNmVlYS00NWFiLTg1NWItYTI3OTRkMjdjOTE3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzc0ZGM1NDQtNGI5Yy00OWE2LTlhNDctOTUzOTVhNjU2\nZjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeumV2tKgAf88tB7PCTHouW93\nU1JoqQ8ct6VIVmqEqF2l4/eFfibt2MIH7l5Jg1709+qtF4ffUSmSMxpBWMPKEKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULUqMF8W6fboc9j/hf6HH45de1XcwCgYIKoZIzj0E\nAwIDSQAwRgIhAJu/3ZtHawKWDMlbIwsg3s0bAPJmJZISgi/82QtKufadAiEA8Je3\nBtZUMIHdXPhajyiSMlDg00BObfozaUYnmyBCD10=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc50", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `50` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAdlxG0S5fyKjoUTVTNPPDbepMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzYzE5ZTY0LWEwNGYtNGJlOC1iMThjLTk2NjY4YWVlYjVhMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFjZGQ3YjktYWNj\nZS00NzE1LThkNzEtYjBmZjgyZGE2ZTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaer475oGTg+6SR1QLIfzYlnr0kXQ/GKebEks6s7cTk5e7N1OoqvK5PTtLRWA\noD5VdDvvc0AyL4shZa21uSVaS6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW3Qn8dU+y8mJtEQZ0d4t0VvoRrswHwYDVR0j\nBBgwFoAU/jLpDylsZOnuIEq6mGZEvO8bK/wwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAnejxj3IR+H1ZLUaBZHeHhVwBzaBV8PY8\nQFPKg4lfHNUCIQCTkECfspkMjnzYIJkXNqaHZIrvIrFeynjM4k6XvazkPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXq19Yq1K1Rur4dnPrkNbe2IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2MxOWU2NC1hMDRmLTRiZTgtYjE4Yy05NjY2OGFlZWI1YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvUTk2byjkmaRUgQEVer8S20KA61/66+g8NMhSv4CiLTCW\nE6i4xs5Q4n+kJK4MHOBvMUEk6TDDCTRuzfHpRoo1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/jLpDylsZOnuIEq6mGZEvO8b\nK/wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIjETLSEpuj2fo6BbVrgTWCjWyy73IjPVtpdpgYNT3YNAiA8X4x1FE7x\n7NXfs3TY0iy//FBJS341AIeOG0TRS0Xilg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISASrfiQET5FWfiDwlAYxhXhfKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFjZGQ3YjktYWNjZS00NzE1LThkNzEtYjBmZjgyZGE2ZTgwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTg2OWJkYzQtMTBlMS00ZGI3LTgxMTMtYmQwYzkzMzhl\nODQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpEP3//oPh81ktk8SPfsOOB0B\n81UmIbayo4sakBPtAGopWkgoBjKv4oIjrnoND+qnFGa1jwe4JqfmzT7bzob+iaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUW3Qn8dU+y8mJtEQZ0d4t0VvoRrswCgYIKoZIzj0E\nAwIDSQAwRgIhAPEWhy4FT4eW4RmW79KYcHrL96n6s+RAboYY5iKhFhPiAiEA3DYB\nDoefc1dgnpPs6YUZX/tfjaOraDoz8RPk5RNQPYk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc51", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `51` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARhjdk91xi77tTJ7m/Ns4uPhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlMTExNmVkLTdkOTctNDgzNy05ZTQwLTc5M2VjMGEwNzhhZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY0YzQxZDMtNTNj\nOC00NTYyLWI4MjktOTE2YWQ0MmIwMDhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExMmHMrP8/c4EUC+4Iscz07fVP2wceBcfiUpQgd7Yudt27i08nBQbQipExK7e\n2MlI75ygwwHMDHvM7R0qthykzaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHQhnFsf5Olk9QaZjkzey95HbWxIwHwYDVR0j\nBBgwFoAUX/zIoQzLLwNXBbU3oPh+9JBmiUswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAwnJ+QOibV9329U0JRwywZ3bt59C1bqfb\nK+weJ4wu2SYCIBuqAcDCzoHCBogPez/vW44aQi8W+BptT7t3nR4RsnMa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe8kbWv21VPxkWKi158U7V6MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTExMTZlZC03ZDk3LTQ4MzctOWU0MC03OTNlYzBhMDc4YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSdrOasAnlbJJT6P77DRTew2HCCT8SYibggpdoQiYp4SPv\nxzbsRaFYzKByYbeznn4kn2kCOgP7W3JR7Dl9wsC1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX/zIoQzLLwNXBbU3oPh+9JBm\niUswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTfw58Bb6WNa7SCg2UKlg2TEg6P71nf+X3YRLMXP9FrwCIHGgpXQbwoa6\ntLjBRwB9K7/Q2yiFVe8NeZks1XBLItjd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAaB8LEVWlZQW68DDPWYU4HWNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY0YzQxZDMtNTNjOC00NTYyLWI4MjktOTE2YWQ0MmIwMDhkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTA4OTU4N2UtNTkzZi00MDBlLTk2OWYtMWU2ODkzZmZk\nMWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdrbxuW+RRR+GcLiKMVYGb6Fm\nBZreqYtP9FPRbNx/kxcPmRgqzBgAUpxO7YYE4+WiPBpCFC96rHCv9+ZrG4YApqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHQhnFsf5Olk9QaZjkzey95HbWxIwCgYIKoZIzj0E\nAwIDRwAwRAIgWjqzUD+LjeIOwIQizKpx7Y3dqqnUlvUR0qNCVb3AxNQCIGmsp6E9\nPP1+ZuT1K09rAaj20H/xdq4Gwf5AtxOUB/il\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc52", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `52` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAYi+3yF11HWlR/eZUY0uutnXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNzQ3Njg3LTdlZmUtNGM1ZC1hNTc3LTNiMWNkN2VkNzk3ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRmMmQzZmMtMTll\nYi00YzAxLWJhZjQtOTVjMGJmYjA4YWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwlxmlidHkd8rGR9AxRikhmzyK+Y4LaWISyp7AjYUk2Fx0GcQSxP/nAQnWT8V\nt0esYRjohRnLmao2y6phYKaxgKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzRCkGHC+8HU/02slXNCa2FDArlMwHwYDVR0j\nBBgwFoAUCbWEl84nS9vQ1s8ghYv/UZ/KEXEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBnQt5q+AcE2VI/\nUNxVZ13LUuj3Gq7OwkxINsljmVnpYQIhAJ2OSjZ/cGqISKZ7RGd313kMJr3kieEl\n6GIuJYM8AJPe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATKeb+XGRisloRXuEEWuHejXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzc0NzY4Ny03ZWZlLTRjNWQtYTU3Ny0zYjFjZDdlZDc5N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaQ+tcYqgd2+p0AH1DsU9L4ECcj1a8UZtYMMw/+eCDDKSi\nitQ5Ygv+3R1vl4y6FDvVWvq7Otm5dOz1mQp0EU2go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCbWEl84nS9vQ1s8ghYv/UZ/K\nEXEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPOQJ6hVGUyBHsrsMGYw1mUJ95fBm7dzt73klTDBNXsXAiAoNcXJAQfh\niFnvlaVloA+M2Xbf3SXCcjSRnyM8icRXDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAYaYUMf7lHrL2IkfNhVzR7N4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRmMmQzZmMtMTllYi00YzAxLWJhZjQtOTVjMGJmYjA4YWQyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGM0NDE4YjgtMmYwZC00NWNjLThhZGEtN2I3ZGQzNDE3\nYzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEatt/7WjBSasJ/xPTndPCbD7\n6KN+s1Ml5bKspgl2a/wZpPV8GE4kSn6kuWDK05XExiPw+DD1nf5z9n3yTh7JfKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzRCkGHC+8HU/02slXNCa2FDArlMwCgYIKoZIzj0E\nAwIDSQAwRgIhAOiBf0c8Uylh3Fv40v6keLZV5DginN27QSX1wlNzDpm9AiEA6b8H\nGpyrUzHTk2tiPvYZXMijBpW81YTUuR2WSpnKWHM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc53", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `53` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATUD6VmfSSabxWpcFKbZt+nDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkNTExZjRmLWYxNzktNGY3ZS1iZGZjLWE1ZDA5M2I2N2ZjZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTZkNGRjMzAtNjJm\nOC00ZjdhLWJlZjQtYzk2MjFhNDFhYWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE83CsvAd0HJd7OHKsNXR0SruAQ+K+rvdhIZP9tYBPoU5tRAVg8HD7tM4inLyG\nW5rrsUSPaiebdmpcjG8Cnt+igqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAwXmvbL3VM6L+9Y/ElHLBWckjGYwHwYDVR0j\nBBgwFoAUo13K7ueiG2dGq3QZ/hSYnrHMrywwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCID+EDUYQU3isQQE4mcuQzaVHNmTVJPYdLgSuebbcGHU3AiBEiKDYVQE8POw0\nwxyP52Mw3h0eeq2NGGifvnEW7NV+/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAet/ZD5bWvrEQkAoQOyAo6zRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDUxMWY0Zi1mMTc5LTRmN2UtYmRmYy1hNWQwOTNiNjdmY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYRu7kIHeazReJahTcTFFtDa85fh5Yey2qYyKn21cAM+nU\nnN+AbkQBdouy+CXhWNDzev2bBeV8QJINiIT3QWHgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo13K7ueiG2dGq3QZ/hSYnrHM\nrywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP/OSZpoWzERgDfYGnNWP9r1bKPUWl97ErO34cnOhY5sAiAkc9EfnXIi\nnE6lg9/ZpnlkdTy/cLtV+Zasceoo4IWK2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAUCUCpL/AJ9ZSnz/WUjbCAXrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTZkNGRjMzAtNjJmOC00ZjdhLWJlZjQtYzk2MjFhNDFhYWFhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk4M2VjMWQtNmE2Yi00YWQyLTkwZWYtM2NhZTY5ODg3\nYTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWnrp+CZf3IInuz16jEZjzRkq\nSEXdbuqT9rnkUjIVmsGD4em/8ludPgle6DKXFliYyjNry//WdbzKFOhlq40fn6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAwXmvbL3VM6L+9Y/ElHLBWckjGYwCgYIKoZIzj0E\nAwIDRwAwRAIgLPp2A6dlAtu2bqVtA710cOwUJ7ds50FvFS/J57UnGtMCICXR9Z2Z\np81y2uhOdlQP5RPA8jtfFc+H9IB4E294HPC8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc54", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `54` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYCEPWWmxVUq8zsJIETmKa3xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3ODFmYzNlLThjNGItNDU0OS05ZWVjLTBiM2QwMDcwYjg0ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgyYTRjNDQtNjA0\nZS00OTY0LWE0OTMtNTljYjZmNTM4MTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI63yBUL95tug9Z4FxUKF9wyoSTCcUOBwxL/fSDsoOsOQiBbWpWj0NnTIVYnJ\nwu5RFxFT94TJqjMZ02Ibq4JUyqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1V5ZqInDqScJKNsv9k1fQTDrW+EwHwYDVR0j\nBBgwFoAU2HP6APuoq3u0yOEh60a95Ez0MlIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC9OVnaA5VLQrNXrWk7cbbeQvLtBcckCWMHp8zvzRn3ywIgY3K5SiYNU4fG\n/3Bbi4Aj4xB3mLZsx/H7KDEYAQxELkA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaWHKyHEL//5WWcy74BVzSC5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzgxZmMzZS04YzRiLTQ1NDktOWVlYy0wYjNkMDA3MGI4NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzxm3G86CktVuBAta7P6G8fYRiliQDM3ie2CKnDg63ZueS\nSFd+YTPF8qu+lco+5dEk0J7Na9ql4exRRoZYuSvMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2HP6APuoq3u0yOEh60a95Ez0\nMlIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHxOppsfcOxvaPMe1dILWghSwXPM1Ufp0ndUmqlTknQUCIQDQzD37WXuY\nP56VTZn8MT8f0/iOF3n03wb1L9a1QZ16rQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAe30yCiSxUY9RPBJVrZHrBoKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgyYTRjNDQtNjA0ZS00OTY0LWE0OTMtNTljYjZmNTM4MTExMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmU1MmYwNDMtNGMxNC00MzgxLWI3NTctNDQxMzMzYTk0\nOTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy32PVVHSecmwL6+yn5wGGiH1\nU3hS4zQWvqZEQtQrWunlLBIeiT5825KXuyDdY+HnaghDr3D3vCpu4Xf29n3wZaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1V5ZqInDqScJKNsv9k1fQTDrW+EwCgYIKoZIzj0E\nAwIDRwAwRAIgRnhl/YbNpmQzxWm/ClsqT40m5qoOWfbml28t+/rCxlICIEA9wf0d\ncUqwZ6v138lSmbc52AR2SsLHyZ9Auc+x0TWD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc55", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `55` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAdBUUqn5SfP0ufmqSEOuNlpKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4Mjc0YTI4LTUzY2QtNDY4Yy1hMGZiLTljMDRmNDk3YmFhOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDEzMDI3NjgtOWY0\nMy00ODk1LTliYjMtNTNiZWI0NWM5MzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEouD/5VTNpnG+xS1zyNMmkGgc/uBaTWdGc2jivWLqPdj8xlDpXrlvYn7d3euF\nJXabGFjqfT8MGbjvDaAicClWmKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjfFqaRRr2vowZRAv544cD1eAWfEwHwYDVR0j\nBBgwFoAU8DaEEbgglZXZ0WriYNNOddbZVk8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAq10bCl8XRfGFogPXWHPc4Tz5RJDJM9sddk+MGZ6ECnQIgTh4XysQya2q9\n/bXaq/ezk42Nn2XJwwPokEIDQv0CSbI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARGAsaYORbin1OVmr9xAvV9BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODI3NGEyOC01M2NkLTQ2OGMtYTBmYi05YzA0ZjQ5N2JhYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi+Jfyp3Hpjh9i6PD6JDEIFTn/BBl7mNHrsIFw7W6/R81i\nKSa/wDilJt49c4VywtzMxN4hqWeODfndky59dMrfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8DaEEbgglZXZ0WriYNNOddbZ\nVk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIizmvigPMkBXUlRJvoMvE0wFlispZbCfbKvkyN2td/+AiEAlypOfDr1\nbGesJYTqtHbEwLoVMB8KMgzX9yb4B0aM158=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAXxJ18c1sO4Bzb7Vx7ho+6b/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDEzMDI3NjgtOWY0My00ODk1LTliYjMtNTNiZWI0NWM5MzY5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTEwMWUxMTQtNzZmNS00ZTcyLTkzMWYtMDU2YmU3M2Ew\nNjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOGPw5jlmDIMPnCmRLZ1rAU8t\nyznRlErwf/iRINbHV2OC0gsdLzOK2D/D0drjcLrzrLTz4WOGFvTmSMh8Zt5cd6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjfFqaRRr2vowZRAv544cD1eAWfEwCgYIKoZIzj0E\nAwIDRwAwRAIgZ35+eH95ghfPQG0H6/YFheQ/Ks2htQfbQUlBKLrnhMECIBfHfQir\nua1biBOcBICJCvHWdDSJMlTBRfpGfA0FmCT1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc56", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `56` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISASYO4HrgnEGSzl1l+Zu9XQ8UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwNTBiNzgxLThkZDMtNGFhNy1iMjU0LWYwMTljZjEzZmY1ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFkOTc4ZWEtYjdl\nMS00NDU1LWEyM2ItM2ZhZDMzMzQyY2U0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjQnKr5X/Pw3Y3AGRELZfKzI3AyjVyz3sn6InWo3aSD03IMSztlDmYJMuq2RS\nVghdn8u/AxLTPjTHLLLQdzl2IqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWsOtItJGror7VLNMmBToXuq7aVQwHwYDVR0j\nBBgwFoAUt7KTkoPR7l8g8kowMntqQ0hjHD8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAI3ROC4/O+vnVKvJ3ajs5+YwZGYPTZvgcb8ieDoW2/\nCQIgYUGwq/Gz8mDcCWwyT0sIxvpEdmhJEIlnBVGuT2AuJOg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ3QoKrNVpeCLfD1CwWVvX4mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDUwYjc4MS04ZGQzLTRhYTctYjI1NC1mMDE5Y2YxM2ZmNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMGmG30c29gEWlBg/OzFh1/drFuV3zoGLk6tAu34n1st0W\n+2HZ22gbKiS0ZY5gbPK0EOVuTQ2bD70/58YdcuGWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt7KTkoPR7l8g8kowMntqQ0hj\nHD8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIA4y5KupIIaTNKfjAQicp0ttQdh3UiqP23p2itk4Ig8AiEAqz37p/zr\nVOX5s7rxjNIaDtmTB/+7eLIHXnkl9qpYu+0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATX+OosB6tRFZjBTGlIfmeYUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFkOTc4ZWEtYjdlMS00NDU1LWEyM2ItM2ZhZDMzMzQyY2U0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQyNTEwNWEtZGE4OS00YmQxLWEyYmItOWE0MTkxMGIx\nNTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcxHNEQaogpYw+N2JhvIGQHe5\npZTOP1CUsgJG44BH7YrMW6Zu0AGiyCEPht/c3adx6GGoQklsq5yKxaio9NY1/qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWsOtItJGror7VLNMmBToXuq7aVQwCgYIKoZIzj0E\nAwIDSAAwRQIgOHvYNIxWeqxp9PytVs0p1kRNgw+8x+eJqohrehHoePwCIQD94mGn\nnhgaOe2QKzk9b6KUT02HsQ6gD/oX5vddQUN8xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc57", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `57` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAXDqm9+H9XeGz3Q5VMfB8yfQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4MjBhNjNiLWUwZWItNDM3Ny04OWNlLTgwYjAzOTU0MGI5NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIyYjdjYzctNTRj\nYS00M2E0LTkyMTUtYzllYzc3M2UzMmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkHf9lvgJDjSusoOMdOxmQU10fFs+G0YT1VuecSTA7YTjgwP8ir5/Ej6HPRok\nmZZ2Y9jlq0WYMoYK4fa/bnrVJqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNW4ttffVCbctVGe/wwc1jcks7hUwHwYDVR0j\nBBgwFoAU3F3us0LK7c0JuLxch1BN6HWV1KowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAQr0LuR286cJK7Zwy9RJOW/JUPANrg7kvjwLY1Bmlf\ndAIgWNQPwmy6MZP7dnKAN5d0zBAXuYuA+Ug46NhtZmDM3ms=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAef3PC/lvarA5rfPMPstjis/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODIwYTYzYi1lMGViLTQzNzctODljZS04MGIwMzk1NDBiOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpYQj2oATorFm2qx/pce0iJH5WFf6+B+sEi1JVmZ+FqLG3\nIKIyNFwep9ZDfE+w0WMJPIeOvrCV1go2ZmX62fomo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3F3us0LK7c0JuLxch1BN6HWV\n1KowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV8YMhSqZkbhSpFe/FQgtIIZd0v92+8mtPfwaJmI4/ZICIQDyAl70Dd+Z\nQp0EiVZsvS3pjwu8k8pFcvOGiS70wJPlPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAYJdV9wWW+e3ToVBQH2NUYU0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIyYjdjYzctNTRjYS00M2E0LTkyMTUtYzllYzc3M2UzMmRmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWViN2JmMjAtZWE1NC00OWI2LWE3MzUtM2Y0YzRkZjhh\nNzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8dzbm/VmvS5cAACKhaysFN0c\n1LawAt/Iu1uchdfHiWRkMmbkhEntXfG29aFV7XQHl3xh8LiYW3ijcfsxKlK+m6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNW4ttffVCbctVGe/wwc1jcks7hUwCgYIKoZIzj0E\nAwIDSAAwRQIhAJ7b0hQcFaDYoPIrMalqMCl3PxJDJzdxPKvLtsx3VEj6AiAH6IrU\nJl3isnHspHXlB8kxif9FHz3QyrMCB7Ooiqm0Xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc58", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `58` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQKiJI2gDf1eOVROEcz5LY8AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MDEwMGY4LTA3MDQtNGVlMy04ZjZkLTc5NzlkMjAyYjhlNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJhMzZlYmEtOGQ5\nMS00MzMxLThhMjctOTZhNzNlNWUyOWYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHEHdH0GXr2GmBtFuCRarKVd86qXRk5qD9d65UqIhT0LJX51r29zpYZHnKRap\nuLzqpZmom2dxh+o5A217Z2pXKKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZO9jwD4Av5Xie0bugy3wu/YuVxkwHwYDVR0j\nBBgwFoAUwdpP2QXAj0sSzBZyOn0OaHLsHTMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEApz5wtZOSbhS+QhIASZug0AcsaxwNOk2BUgPEBC2O5iMCICQ4\neQxz9CmrS2XAkZUuvvTJHd3GDhixfQeqDlSJNi3E\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaE94Eprgql5cgYyd1csS5fjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDAxMDBmOC0wNzA0LTRlZTMtOGY2ZC03OTc5ZDIwMmI4ZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiVcv4XkbupUXx3z64iXwpPpwa2mQh0aQum0vpUQhvwist\nlaHpklP+40CpFWcbVM+lLcq9o7ywaZaNG1w+aIMIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwdpP2QXAj0sSzBZyOn0OaHLs\nHTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC9yL1+l/YQNqyC+KqbUvQ2hOwajOxaYLqtms3zU3XvUCIE/ca335EBQl\nTm/TJrQrICoWY2j26nbgobFIbjKhB7rn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAe8wO+dyvHWomPSYzUSi1wHhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJhMzZlYmEtOGQ5MS00MzMxLThhMjctOTZhNzNlNWUyOWYzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmJhZGI4ZWEtOGEyZC00ZmM4LTlhMzctMmIxYzIzMjMw\nNGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErh4i/yKjroFoj5vaRhzzfjsg\neLBZr+fZlV7C9ESj7YsGbedYk1rLO0rUUCB0HTYoB8lnkvTgKMZxERZG3qs0wKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZO9jwD4Av5Xie0bugy3wu/YuVxkwCgYIKoZIzj0E\nAwIDRwAwRAIgKh+GVVp2hH9gPML6f7aml/ydOPlW5M4Qcx4CwmFyW4ICIBdwu3t7\n63ZCHFLOEAdFJVNMj9NbMz7TUr0E31+ZkJNQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc59", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `59` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISASKDhAi8PQBvggdaCLE6j6VCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1ZDk3YTU0LTY0ODEtNGM3NC1hYTM2LTdlMWY2MzUzNGFlYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM1NDYxZWItZGM4\nOC00ZTE2LWI2NDMtMmEyYjc4MjEyODA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8ZM5YrDwacUqiaKkLjmeUJyFcT1QZGN11vOc8ygKX/Jiqpq+ewbvDsy9QMhK\nNGpatY7lBLo83TqtbT6AEfIex6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE3tetgNu+2j+4RALIRGxrJjxZpAwHwYDVR0j\nBBgwFoAUMTu9t4fd7Xx1AhGXVuCFZt3LE04wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBgKJMOFwzy2s92ZuyZze3G4VcmwkBJ0tg+\n1agPFcP1GwIgSTXMY+incgXtnhfrRcSIix933/Y5nenYBwADRRDax/I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYW7tSiPPzjrn77t06RESF5VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWQ5N2E1NC02NDgxLTRjNzQtYWEzNi03ZTFmNjM1MzRhZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrTA45p5OgaC1PPHFRHns54ZjwhGx8g9ss86MR672EFgI6\nispisrTrf7vEr9iabDaE5StKLuQnlX9pC1m1fSAoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMTu9t4fd7Xx1AhGXVuCFZt3L\nE04wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOVjgJvYIX0ThMw/pMoOe8rshLjHgLxQJM0zQRK+nzu3AiEApY+9aGTj\n7QrARRWOSqB3Mzi8oEBQ+CaM4T2lbUb40P4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAbwgME7F1ggm0v9WulHtwdn8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM1NDYxZWItZGM4OC00ZTE2LWI2NDMtMmEyYjc4MjEyODA0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmFlYWI4ZTMtOTBiNi00YWIzLWE1YTYtYjk0ODczZGY5\nYWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaQrs5hHR2v6Fopqr93SSsBS7\nYZGHeWfsw1nYo7IkuOb6wEh6XGiswJiPWmlj/IcdsXTVDdq7kUDzxrjJJITcNaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE3tetgNu+2j+4RALIRGxrJjxZpAwCgYIKoZIzj0E\nAwIDSAAwRQIgJTTn39r7izfyFt7gyA/Zos2THipqdSFmniMnjXEMbNcCIQDX5KqP\nnda1Bxotp9gR0XatyqVWQlvWrufOsW//3r3EiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc60", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `60` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISATCwSpWiZx/tN257JIn1EispMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwODM5ZDU0LWFiMGMtNDhlZC1iMWJjLTYyMDQ4YTMyNjAwZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA0YmE5ODItNWIz\nMS00ZTJlLTk0YTgtNzQ5ZGI1OGY3YWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZQNq1BrBJpU1bX/mnHLSBT+rJ5Myd82R2YhwyMyZ2jMsnE/GUebu0RLfIJNH\n8myvttKxnh/jVeaU3rov2C+f3KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPCiDrwjeyPDTStbGtgnv391WTIMwHwYDVR0j\nBBgwFoAU2x01N+8BIo7s/TnK3scy28qUDVYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAtp8cY6QfgjfV+O+fwg9+15ZW0z0w97PV\nle8pK3ENyokCIQCMaFoaf0OblSs2+WhJ4D6F7LgqqInDAmcvukS8OaZ8EQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXnfPuvv1mmEuD5eNnfXw5jkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDgzOWQ1NC1hYjBjLTQ4ZWQtYjFiYy02MjA0OGEzMjYwMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASU7Mh2pga/qXxBng1KX2UoS6TgPPbsCBK7WJDgMLVlVisn\nE5rkaoXEGDOVcShw1+UYvL0ibdNJ+u/AX/VN4EZqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2x01N+8BIo7s/TnK3scy28qU\nDVYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJN5eEMnsXzP0sgbv2EfyIVgPmJm3MnXrTakgbRh6pM0AiBpMa/++Ho2\n+MJ9Sc7f/Rn8FWR0pKAsLHG1b2EFAHoVtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAUa8kxLgZe2eofyDHMWCoPqsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA0YmE5ODItNWIzMS00ZTJlLTk0YTgtNzQ5ZGI1OGY3YWQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjM2NWFkN2MtNzhlMy00ZmNjLTk5YjAtODY2MGJhYWJk\nYzYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+SFAHfwgNxfb6pUy/cZsVG04\nx8zYsXcetzYW2bcyoZlRUxvWxb46TeJ4roD8IHwzKo/XIvWCtX7Wekl9660T4aNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPCiDrwjeyPDTStbGtgnv391WTIMwCgYIKoZIzj0E\nAwIDSQAwRgIhANNcuhZFHi1dBP7QrklFM3PQLECUTgzQ0pxgieZVrUySAiEA7rkn\nYaCNxtAD+HEtQNINYWGPqtWevuzHyXuqiGsv0qc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc61", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `61` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAcdxd+JdRHXTbKeImcHyIDgEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjOWYzZWY3LTBlYWUtNDY1YS05Y2UyLTI2Y2IxMWFhZmM3NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJjNjc2OTktNWJl\nYy00MjQ2LThkMTItOTMwMmFhMzZkNjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/qJLRs1CbpaRGucPpvUJFoGdhd7f/SoTS1st6BdzNGRpFPJC+o5lvbedCi4W\nRufkPvvUxgPPyt+uqnjReSdvcqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyWZnzPP3d2ZSmMQSGUknR0tjdjswHwYDVR0j\nBBgwFoAUSvr7WrilWoGtqZf7aU2GWdx7oW8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDVq2jM1tdvRkzPZYCPuHJjOpwC\nkQdH6GQt6IAfFXqmQQIhAKJMrmVwjBrN/Obcnd4i47x0EDktluvSPkejaVDqC1Rg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARoSvyzSGFbayXtT502lrt9HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzlmM2VmNy0wZWFlLTQ2NWEtOWNlMi0yNmNiMTFhYWZjNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAST1BB+NNvga3DJ3NY9bPpTJtE5vhoUX71eDYMZxGpGfdCq\naiteVs77yr7qCrcssggdIsHAWpMM2nAj1oH0y0L8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSvr7WrilWoGtqZf7aU2GWdx7\noW8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANRalD+tQbIwr7g7Yj7rm4jEtqEAO9A2ve6oZmSLpC7YAiBX9Y8ftzxT\ndu7TdlCalJF596GG3fSWg+tjxDXZOO9RPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATvIPpKneJfboZOkAlMemud/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJjNjc2OTktNWJlYy00MjQ2LThkMTItOTMwMmFhMzZkNjU5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTc5MTc1MmUtNzEzZC00NjcwLTgyOWUtYzY0ZjFmNGVh\nZGNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiMjbWwb000QwyTdl0wkQlXT0\nhCprW0hblnI8Ix2SDhxjoSdS+r8EKz69tZSUlaVODdELZVejw3nvqJ/dXhI4AaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyWZnzPP3d2ZSmMQSGUknR0tjdjswCgYIKoZIzj0E\nAwIDSAAwRQIga+qaFkhPOodZmRDDMZ8eaY00EM48f+Cxabxp4MXR46kCIQDWNfDT\n5a0ENY2FYfOiKj+MmFt/BAq9AV9BM6BRlz9Scg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc62", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `62` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAce3aMYnbbG272PSz5CNdJZFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1YTczNTc1LWY2NDUtNDVmZS1hOTIxLTI1ODkxNjI5MDQ3NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI3NzdmM2UtMTYz\nOC00MDNiLTk1MDAtOTdjY2QyZDkyZWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnmxy6HfijnUN4yH1l/HM4wonS4Rugu9H3Dc+PPzSNM43b3A/Zq2BZg86e8lt\nvoIULv4GAfbvCGKoHJYtEYGSu6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUabrhIrfz2sGNXgFADgT1jgTMwBswHwYDVR0j\nBBgwFoAU+YLgmss04CxTTQjowVlMTMjYVwowKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgdJlFYrtx\nwU0j6zzOzIr/CCM7DfiIlsZF6MaYHgpChSICIAamXCHF6ZvEYQg8ur61xbaRMbjs\nNnqER8fYO6szXh47\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdgi7ic7lge33dW2xn+CykE1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWE3MzU3NS1mNjQ1LTQ1ZmUtYTkyMS0yNTg5MTYyOTA0NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPqgn62MIXuM26HV5a5mOkcMA+RFpJjJRsibYGJNn+08aV\nv3bxLJvfkq8hhsaDICs0iSugzsF24NzsTwDb21Fio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+YLgmss04CxTTQjowVlMTMjY\nVwowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJLWpzgz2CJlpCCUWXbyp1XUu75VsssDpKMSdbrrghtoAiEAqbvdBMTK\nHbF5VetYhHaunF40JrxZgn2pSkx6JLBXXOs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAeC1dMTlvpCEUj4MkloJ+hE7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI3NzdmM2UtMTYzOC00MDNiLTk1MDAtOTdjY2QyZDkyZWJlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmM1ZTNjNTQtZDg4Mi00YmM1LTg1MmYtMTZhMzYzZjA2\nMzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnzJ2snXkNeY1eMp9uALlBY+Z\nV1GUfMsExurKRPXVuzbwKsM1LaoP8CnLbNFj2R0F75Mxe7M5N3rAnRaKQGVGv6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUabrhIrfz2sGNXgFADgT1jgTMwBswCgYIKoZIzj0E\nAwIDSQAwRgIhAPZ5ZpmUtYbOl4oLqtBNMrmaGXfsSPcFYTtLPCtZGNOsAiEA0ufo\nTZrTvb9evEbHquh26IuGOtQohNVnHO055TRV8p0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc63", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `63` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAcFdBjI+zhuqUe/SjHa+i1/EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlZDNhMzlkLWUxOTEtNGUyNi1iNGEwLTYxZjFlNGNhMTI2ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWEzNzcyOWUtYTMw\nZS00NzZlLTkzYmEtODdiYzRiZGZjNjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXOQVwlEOAC7r196mRqY8l59XtxHiwPxduhIHzsSCSJDNIbIEEMw/Tr8KdDcZ\nOFp+OxYfjGH6kDWtv5GHQPBlVKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqJ1P+6FGSxuPNT9CVTKCVaoTSw4wHwYDVR0j\nBBgwFoAUvSNSaQ1fMHl2ipEagZvWmubkNUMwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPJNtVIs\nxsmYlU17Dx8UUAJ36SRhaSmNMo81Shl7Gkw+AiAtPb1GYNS8lKIqrhP+vlwx3fSK\nQKpI30dknlioK6Zq6w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeVeoe+sYfaXCVPp6yX4LiWjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZWQzYTM5ZC1lMTkxLTRlMjYtYjRhMC02MWYxZTRjYTEyNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLrd4+dlE/rwkOT4qeocqW8RfHVEd75moP+3j5HF9q1xB6\nDtLrf7zNeVGbS8MlbEjEyTQYd8ImdVqZOwmbHtyjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvSNSaQ1fMHl2ipEagZvWmubk\nNUMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWweMZCIiAz2pOvd45EGRR4/j8EcGNnrOZb3U5DYCHKQCIGK+TPxoxS8b\n3IyTujROrCll8OGtYyVFnlqBwh4O6pnt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAVQxR8rAk+9TVV9MFi+tEgG5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWEzNzcyOWUtYTMwZS00NzZlLTkzYmEtODdiYzRiZGZjNjlmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWJkYTZkZmMtNjMwNS00NjM1LTk3OTktYThiZWZjZDFl\nMzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJiYV5D62/V2/HeLTUh7YZryK\nSkBBnqBZJOVxLp0qeVk1hmwzHTwYOEp8G4KVSpGIXXEZLk246I5kwqyQGCGueaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqJ1P+6FGSxuPNT9CVTKCVaoTSw4wCgYIKoZIzj0E\nAwIDSAAwRQIhAM38rHWWr0uVJLW+atnxSyOBa8QyTRql1YTER/wWs1QBAiAkc10p\nW9+j8bWDkRAHkWE4GUqpuF7U2Y9hbOdvc/eA/A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc64", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `64` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISARTUgpZmA8EZzLJAeWEnIOsyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMTI1Njg3LTBmODgtNGE4ZS1hOTRmLWUzY2NjNjg5MmQ4MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZhM2NmODItOTVj\nOS00ZDFlLTk5NjEtZWMxOWU0NWE0NzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOn7sf1obTI4kepk2n75BxShzi08gtzjfYpEdNQHmMC68+h8niXiC35Z97jfS\nLrIuybkRKURO8oEFcYIx3fk0cqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhd6f1PmnxzhNSBdni5Hc3cGzSwIwHwYDVR0j\nBBgwFoAUFZKUfzjHsPlJ/L4wELlX+nXXjoUwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDYUu0n\nyFQhcFr6L3tUz7VLE5zeyasSJp/Xd66yEEG7lQIhAM0WsXGIwZX7WSH1XjeSQL60\njwapwgurXcNKjL3jM1L+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUXpGAoOAv3NEMrMiQ9PIqWaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjEyNTY4Ny0wZjg4LTRhOGUtYTk0Zi1lM2NjYzY4OTJkODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/ZSThlaZ/qhK2a8BVKqaPT5RgeajM71QPdmIknMvfEAOB\nN0s72mXmt6sM4OKycjz1kqxsHI0Y2/J8BhL0ij4zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFZKUfzjHsPlJ/L4wELlX+nXX\njoUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIAtgtUr7I/g1GcrmB7Vnr+STL7nBFd3Y1mKkZiVrz8eAiEA9rZT8ZtF\ncz1nS+RDQGko7W+BR2QSbaqqVqcwDYGbXuQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAbmz6KsWW0p1RYMZ76ZcYcpJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZhM2NmODItOTVjOS00ZDFlLTk5NjEtZWMxOWU0NWE0NzJiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGJhMDJhNGQtNjA0Yi00MmFhLTg1M2YtNzk2NGFhYTk0\nMGZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfVuuoHnKkax8JQVyuwG0UeQ2\n9gUUScHgVFPPz96s6EI6B0JpP70Sy9jl7Ff69WtiNZcsM3r5gu2VcTTuy69lZKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhd6f1PmnxzhNSBdni5Hc3cGzSwIwCgYIKoZIzj0E\nAwIDSAAwRQIgRse4w6Iw2mJJzm+B2qhbrUPFcYHqyxhQGVHqJwiljqICIQD8JRrr\n9WriI9eIosWh+MzYuOTkozNpu4w3eMthhOCF5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc65", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `65` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAYdXL+YEhiCjSO1pKkOS7MaFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmYjVmNmEyLTg0ZTEtNGQ4NS1hMWQ0LTNiYzhkYjM3ZWI4NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc4M2I5ZmItNTJk\nNC00NmFlLWJkMGQtNTgwZmMxZjllYmJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER8XaxmQimrM0iB2an45MjFANgTXvp5a1JgnNCmRLgEHqsUgUTEJRsLeRcjrg\nrjjHnYyKoyrj5RACY5G9NBgdVqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW4tx+n216F/qTi51V/pO2ejBIacwHwYDVR0j\nBBgwFoAUXiXg7qZwL6gLwtRk49JCyysmwtMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDw7WIWTqve7UZFSIclyYWKJixeENRBBZvNyQKmnizuZAIgR1HGGtMi\n6skZx9KyudqGRZU7ZflirI9vZTsH05ezFkY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYWqzFupQwdOAKPrrdeElz0nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmI1ZjZhMi04NGUxLTRkODUtYTFkNC0zYmM4ZGIzN2ViODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFktGd9Zg3bmyrefjq+ydYVtsWfHid6wfq9bOWSt7WvjUn\nSwv66pUr3y5WX9hmvlK8ttZXYkTQSGTV0i8dEz1uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXiXg7qZwL6gLwtRk49JCyysm\nwtMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOQAArXxui8AopTwZrNAfWYse0bmfntaDQe+30Hem3gGAiEAmcHe0ZAB\njYWdQDmtMEMcAP+fzexDWiaAz46SO3+JAlA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAaLZc6ZH5fBiRN2FBNFozoHoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc4M2I5ZmItNTJkNC00NmFlLWJkMGQtNTgwZmMxZjllYmJmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTJhMjQ0NmUtOTE5NC00OTU3LWEwNWMtZDllYTdiNjlj\nYWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEffpNe1oabh+e4cfv5mkoCB/b\nKeMeVg0thet252iptJLTs/ZZzMyL5vZMEb59mjdqem0GCx+bLGH332VHE4olTKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUW4tx+n216F/qTi51V/pO2ejBIacwCgYIKoZIzj0E\nAwIDRwAwRAIgBHZa8Am0NBZGR87uCRtfh4eL/QMs6mVq2RzwPCUiXm4CIAkeBrl8\nBhw7BJeNIJ5nuomReGyM013Vcxr0nnYksrab\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc66", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `66` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeDVukSiSwFtCA49hNoo0hBCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxNmVlOTRiLWZjMjItNGIzYy1hNTZhLTZmOTcxMWNlZjNhMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFiN2EyZDktOWNm\nNC00ZWNkLWEyMWItYTBhZjVlMmViYjgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+DR+Has8zfWXifp+yR329IsFqVHjw0H+Jl4b2dwkMEIHkd23q0zpBV5nLijw\nAMAUkHd2S6dZgeHHhkNBX+gZuqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUic1Robxv0nEcc079cDdym0jbsNkwHwYDVR0j\nBBgwFoAUxBDW4D0kRkwPrCNJi5AFlNWWuq0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDMBq0cXlWESqfEphbQhNnNwbjNk9R7/6M8EXxPf92AwQIgbYM3GCEO\n8qXTsTkbAaQ0hBPrincQdnQ9P1gfj9PEM74=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUZroGeAXHEQQzvsecVzVMXUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTZlZTk0Yi1mYzIyLTRiM2MtYTU2YS02Zjk3MTFjZWYzYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAST04QD1X8AhI78eOw3ppPGgy5/BzEvtSUwZjy64EKm5wh1\n7mWjIjzZG/IjLH7DFIpI/fs8EeW9hCzFzLOTl+C3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxBDW4D0kRkwPrCNJi5AFlNWW\nuq0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANafj/wIuT/cDmpfCOAnPSp3D3uc6G6m29KIAjOYiJGMAiBBFTn5pBjq\nIkJtZJM1fcbmEo2/GXHBiZf04Zsr++iqeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAVlM1lqQw2b7Fst0NgEUxlMZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFiN2EyZDktOWNmNC00ZWNkLWEyMWItYTBhZjVlMmViYjgyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzFkNmRiZTAtYjIwNi00ZGMxLThhNjUtYTE3ZjE2NDkx\nNDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhv6sInTepDEs4WP/Bo7Fu3FR\nkbYDd0nWkVUAEho+6D79j/S5WtGWwHcUTH9mGdjezBs+n88gZG1FY2MB8xMlsqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUic1Robxv0nEcc079cDdym0jbsNkwCgYIKoZIzj0E\nAwIDSAAwRQIhALEEsF0pAQYabR/w2g8Rt7hen7PW6zPgGVexhf6ISWsoAiBdDJpn\nfNq9itZuqEqILrthGOFURRFvGWFF5LQM4w9B4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc67", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `67` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAUPSCB2s8J1Bgopmh76zowYBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4NzNlZjFmLTBhODktNDc3MC04OGFhLTQyNDBkNzFmOGE0NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNiMDNlMjgtYTVk\nMi00Nzg2LTg2YzAtMzIyOWM2YmMwYWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExhSgCAomOIvA423ynKOauqfw/iBayT05FrueDEho3qRslnhqxy+DMKDrLcUH\n+IQUR/qLwsoWf/SleOqQWOCiGKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnGdYsKoO/nQBTf+8HbA5rSVATFgwHwYDVR0j\nBBgwFoAUL1QUHOoXt7KX3DKug0T8VsMbu+EwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIAJvm8MkW3xVDbFi1nJz77BzB12AweZU67DZ2O4egHadAiALNCW85komhpuOBpWl\nvma1fP6jWliAj3HZi/bflXD4ZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATU35qt+9z8BuSKNPCaRb5eaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODczZWYxZi0wYTg5LTQ3NzAtODhhYS00MjQwZDcxZjhhNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASh48RenFsIJEq2vE7yToXRFBtzrZZeA2YE3OL28kejezXI\n/ajg4POnk6GGvl7Oo2k1g2/CMcerd1HfVHd3Hvl6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL1QUHOoXt7KX3DKug0T8VsMb\nu+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANLn71nya7sa4YVlb61z8fTldM0WomFIG1wGq3HxGsOyAiEAswk4bA1g\nM6o/Bc9lnfUeUz8gokdhg6Clwgx3mgDltcQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAQddmqKd13upSJwi0Pcg4+xfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNiMDNlMjgtYTVkMi00Nzg2LTg2YzAtMzIyOWM2YmMwYWZjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2QyYzU3YTUtYjk3MS00ZDI0LWIwZWYtYmU2OWUyMjkw\nNzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEScLiUTiGxIZlQ8hs1kJtJEU5\nl+1E6Kyp0PaUnzMipeUhcCuvY1WXjg4l14BxDlq+Y9Z2YCasCtLwUXijD8aRK6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnGdYsKoO/nQBTf+8HbA5rSVATFgwCgYIKoZIzj0E\nAwIDSQAwRgIhAOie8h9BVzs2xjnOaUvzJ++1s/sBZxaQLhBJS0wuaUyxAiEA3wMS\nCzjZK+HI0lMimT4rx3LCwBYSf1P0PE64/o8UDLg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc68", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `68` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAY1wy9TYoXZzeOag0vhmE/7eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzYTEyODZhLWUyYjYtNGQ5OC04OTg2LTI1NTFiNDlkYjQzNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTllZDFhZjgtMDIy\nNy00NDdiLThkYmItYzQ1NTY4MGUxYWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzy79zvJLIhM74r0xvQr4Boobc/DjTJfw5hj0YgZGLsst+EUx48hjkx2wDH0p\n360tL65ipKxx+x1tHHr2ynz/UqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ530VLKVosCYg4gff4rMlq7f/FAwHwYDVR0j\nBBgwFoAUR3a2Qbg8I4/8AKap2bCt+9fG2cAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIA3b0MJl1c9x+o6kEwWmU9bb4bZvhsIibjUP/nPenJLRAiAN\n3HIuZ/3KP/a/r4Z28zVKA1BX4CS75VCn3o8elRdd8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWOYzbNp3aGNIJ5tPHVvQKYrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2ExMjg2YS1lMmI2LTRkOTgtODk4Ni0yNTUxYjQ5ZGI0MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoaV321IhKy89Y2IE7yW1p9BwTx8O9rUWKFMRu0S8/2Q5B\nE7Ovj2pb/UY/oOTr9DblhFqMQjADUWrsbZ6wPTq3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR3a2Qbg8I4/8AKap2bCt+9fG\n2cAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJjW68TZPkQlf0JHwxnmzT0niv36IR9S4z3Uxp+/mh2aAiAtmoAFfXDl\nvuYH5h9BInu2zoVN1SI13+lbztmt2Ogvig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAQ1C5ZF9tjYGJ7Pk9HpY5ZwHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTllZDFhZjgtMDIyNy00NDdiLThkYmItYzQ1NTY4MGUxYWFhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTFkZTZhOTItNjMyMi00NmMxLTkyMWUtZDQwZWI3ZDI1\nMjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM+iRESSdcgrWDoA0iAJ0m7ua\nr4L+1Qk/ogIwr6Tqlo+T1szJi2MbeuboJPgBvCWTKhs3xBiKyIrkZlxcQ2T5kaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZ530VLKVosCYg4gff4rMlq7f/FAwCgYIKoZIzj0E\nAwIDSAAwRQIgM4U5mufZbT0dzWi1wjFZltTZRnWAvRCFG8CBnS6viyUCIQCruLkL\nz4md/EadLSRx4CGVUPnt+NA+FdcTmeqLcEOsMA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc69", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `69` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAaqEfzQ7Jqow39HZd6rG23BWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkOWZkM2Y4LTM0ZDgtNDUxYi05MDJiLTIxZDU1ODNiYTkzYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFiMTdmZWQtYThj\nYS00Y2QyLWIzYzktNmNlZTY4ZjJkNDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcBx92clqH/XuAe7Gz5MbmigYhraF6DpKO0OSAEJ65Z16kZfvQyUb1AXbvrap\n2mYc20EA6XLxFSHcZrbW1TiShaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUewQECjpchJJeirmsvhlOCzosfocwHwYDVR0j\nBBgwFoAUUSLYpiYHx1fveN5yJWUPs4zRWhkwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIETw1FSpo1N/dePbt7inocW/4ySrDqWNZDieZi2QvkCbAiEA\n5N7Kvammt6gD++XRgBMORZ5Lb1k/hrUJtAbFXjVszng=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAargs8YT8YCQmp318VW1QXB2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDlmZDNmOC0zNGQ4LTQ1MWItOTAyYi0yMWQ1NTgzYmE5M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8jh6qPo8GgJGP0QhLNQzhBhPiCKvp97ELawc+phcxkNYN\nv63Jn4z3c2xTcxTo2sxonD44BVDz6mTgfAm9atu+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUSLYpiYHx1fveN5yJWUPs4zR\nWhkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAInzFmkMEPrsBXOhoIhDN7nK4vxhF9W5OqtSsdXAuYXkAiAlUizw3UIc\nmwAJL1RU693dxE1OCKhe9vgwMRaq0ADEKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAR7LIrqLcTo5VhS6gJpjBAXPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFiMTdmZWQtYThjYS00Y2QyLWIzYzktNmNlZTY4ZjJkNDAwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmI2OWI2ZTMtMGI0Yy00ZmJjLTkzNzAtYzQwNTEyZDc0\nMmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9tDoNVGekR5vnFCOWppfe/I7\nHdwYtvndgBqHCbaOEZ0Q6qik0pcefnRmmj7nZ/TZhxSd6B4VBrt62ckwHPemg6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUewQECjpchJJeirmsvhlOCzosfocwCgYIKoZIzj0E\nAwIDSAAwRQIgEwgYBmxYcXyLuMmQWtH/NTilV2CZ6f2m6CStEWrhzLsCIQDRuB8R\njtINzly7BcAgeZjMxz/pJnyecdXnLRRsSB4hWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc70", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `70` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISARLs8daB423U7WiC4DMttAleMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2YTMxZjE5LTgyZWYtNGM5Ny04NzU1LTgxMDllZDRjNzUxZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzdiMmE1MjYtMDA5\nNS00Yzk4LTgzOTItN2QwMThmMTRiNTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEjab9vMNcLvLpyH3o45DjUEDJFuKlPtipPAjSqtayFU/WtlrKxHco3dQgm1L\nqbAOnBg5QsKvFhueYHsgYfyZc6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIiaJrAGOFK7idU8iP2grsI4CorEwHwYDVR0j\nBBgwFoAUtVc0gh65Ed+Pz0FuXrXbbIISZRAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICHjTizBG64y\neKTmaFa7l2IF+tw2XE3nhtf039NpQTyGAiAZ1wyUoY+6tyBByv85z54INVPb3UrK\n0M++AWeLClA4mQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASb9+ydfo8YvYErmWFKgmwEBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmEzMWYxOS04MmVmLTRjOTctODc1NS04MTA5ZWQ0Yzc1MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2G1tqHNkd9SrU0PzkXCcpmQnbc9vaD/CTpJ2xmktQS5bf\nquG926iET5sU3Qx/18l2eIxOgbO8qYQfF22+eSpXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtVc0gh65Ed+Pz0FuXrXbbIIS\nZRAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAJrMMtFNTbvM3bPJWiaUjg/rGS3kHdgRYx1yHTDy5O9SAh9EpnAlpnNh\nT+bRhU0JGf8hqXHRo7e28JCzm22wqbBB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISASrVzmDLVeYacEAPoL+BRBMXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzdiMmE1MjYtMDA5NS00Yzk4LTgzOTItN2QwMThmMTRiNTU1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjk2Nzc1MGYtYWI2Ni00MGZjLWE3MjQtMTk1YWZlODFk\nYWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE50B6I0spHkD5KTKtDZt5q3uH\nQxI4ssW/ToAkZYOYI7NNCPJHP/4HJuO65JAOSDN1VXOfU8FS9Oiwxt5u0eCNEqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIiaJrAGOFK7idU8iP2grsI4CorEwCgYIKoZIzj0E\nAwIDSQAwRgIhAK0v2yLkXcXd/Q8pb55LRdFDuVxqa+XWiEFch/2pBchpAiEAvwqJ\nkXgYQGlmAUjXSjVr5xwDNZKBWcUU1MJOKGGwkAo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc71", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `71` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATe2IHWz4y6OB/bvUleP58CBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxYTUwZDdkLTQ5YmItNDliNy04MjEwLWU0MmJkYjBjOWI0ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYyMTg2MDAtZTkx\nZi00NWIzLWJmMTktMGI1YmEwMmZmM2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE18B9c78hoComAiDTk3TpTVUBavD0asw0HIi50gZ8anAU1Fw114CzjNdOERLs\n2IGQnwLOGBicNGLw/FW3jEpDdqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX18EkTdD5tAtgHydEvJIynfB98owHwYDVR0j\nBBgwFoAUgKobqWe0ul/xQxo5Esf2TNsWg2IwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgTvahC3DCvyWsb2orHNwUkKB/OZq+CWk9p9X7aoMl5scCIQDa94H5q0jl\nvQxXZkMEsR5u8gm0iGci5pxBx6+JcMvBIQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYkXi0iUgD4oI6ArGYrM5EOoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWE1MGQ3ZC00OWJiLTQ5YjctODIxMC1lNDJiZGIwYzliNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhbaMAhnKCFGHLd88760pTw2caCVmF6YgrqeB4XW9anIbw\nNwot3a3cnmEqLJWb3+x/JAaqrDkhRWtISgh/v8Vao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgKobqWe0ul/xQxo5Esf2TNsW\ng2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM8bApCFcJabKEi8L696s3E8spBekHGt4qFgVmckERWhAiAlFpbTnp2y\nj2y5586HxvB1okNLQC0OzqCfHRi5IWQsgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAZU8M0g8AT0c3uG5CgMJtYkcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYyMTg2MDAtZTkxZi00NWIzLWJmMTktMGI1YmEwMmZmM2MyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzViM2Y3NWUtZWI2MC00YWUzLTk4NzAtOGExMGZlODg5\nODI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw1PCB1oKPz8PUr2X/1L+2g2V\n2hS4gok10iBCsJ8kQkhb1uPWxG8bltObv40IGbRjtfB6MX3VqIARAWlNjrGOIKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUX18EkTdD5tAtgHydEvJIynfB98owCgYIKoZIzj0E\nAwIDRwAwRAIgRZPzFo4POmGldBSUJEo2oLAgHs7bKDTE18tJIWQ0+NgCIFWDgbla\nktsYCtPp2QjWJN2zQq1OOvx8dbr/Ufr9as/7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc72", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `72` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAT1yNlSyINoCzXFmxVLAp3okMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3NzJhZmU4LTVmZGEtNGUwYi1iNjBlLWI0MTRlNmI0OTBmMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU1NjEyMzktMmZk\nMS00ODI3LThlNmUtZTQ4MDM5NGQ5OTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhdI3xqdQkFBPK3Arph4P1WtXeE8fBAHBimtrfIBw7uMiuoHzlPOW25tFTtI6\n56OkITw66ogBOx7cIQBgQL9jH6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU57a/c3FvJLEq3NmzfO95JfcQ89swHwYDVR0j\nBBgwFoAUNrnnpzbt0uVPdvD7B8dtxQVYnQMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAMYAKi9EszJAOKE4rCO9qtftnW6gGUClxTVhLrTya3AzAiEAhboWIE5z\nqnrf+Z3ZLdfuGYcTNtHRU9fRmGf63sRBgyQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQbhw2o+OnJrRtFI39ultn9IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzcyYWZlOC01ZmRhLTRlMGItYjYwZS1iNDE0ZTZiNDkwZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9Gsa40wk2r8rMEYGHzEf4uy7FKX6jo8g4AzAROhXIh9nl\noeC3EPXTVqmY8AKeJplJy6J3u2XXRJiOEXe4AlSLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNrnnpzbt0uVPdvD7B8dtxQVY\nnQMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZsgXuMXjm4mRqnl5n3zweXVNrBzxITEZghjeTPVJBPMCIAgfK2IEDRe8\n9j0cNhdAUbfS2QbIx/lzJvPcSDw8oAur\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAcqpSrA8b3KuE8iaHvbBYNg8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU1NjEyMzktMmZkMS00ODI3LThlNmUtZTQ4MDM5NGQ5OTNhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGIyMGY2ZGItOThkNS00ODk1LTk4ODctOGI0MGU4ZWE2\nMGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUeNUNQtXCy4d/tHi/fxGqmdj\nbIOL1VKbCpWg2mGcxxjFgYBUv5TQlwJFjClfCzJ+uTWr7/kHtP38nS+igXHJLqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU57a/c3FvJLEq3NmzfO95JfcQ89swCgYIKoZIzj0E\nAwIDSAAwRQIgDSztV8nsv9rpQ2FtjfDaxl4lahzdT9QW1Ge6GEHAr9ECIQCCi/BX\nWBuurOhwuOnj3IcgpCi8JwKRXW6CV6ybFnc0Vw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc73", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `73` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAT7dbzripnRuET6SWRBje3OFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4NjA1NjI0LWQ4ODktNDdhNy04NDFjLWE4YTQ2M2I5OWVmZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc2ZDA2ZGYtNmRm\nMi00YWMwLTg3MzMtYzAxYWFhYTcyMGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL1KkCFfPmRNqtLcwys8IkAr6qHWotchKhs9GkJBBqeeUgpfH1SGxXhla3jN+\nBsuFqzEEs602UoRhvfFHnzbIA6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPI3uiKRziLwhOwxLAVLPwbpoHk8wHwYDVR0j\nBBgwFoAUMvT54I+1UsQpKgRKDbKtaAC4Uw0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICiJB7jFr3VmMNnXDBcsvvQ9VOuFlD4bmZMSRURhfgDOAiEAoZWEH2Af\nI9MF7wK3xxAyTcIqst+9u0d3AxC+J7ARHIA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQrE1b+gQ2uvVGCxr3d5p6EaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODYwNTYyNC1kODg5LTQ3YTctODQxYy1hOGE0NjNiOTllZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8+yQcSwKhZTVYUK4BFfeDzXv+M6rsSrdzVgzSTf3gCio3\nVx/lzZpSivrFmQCTPina4gpcOPoAAuI5OfPIAfMNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMvT54I+1UsQpKgRKDbKtaAC4\nUw0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRApMyo2G64pY6nyQTFyM5A3ZD8As2FGRnuBiuEJJnQsCIEA5UbShnvAJ\nrXbv1pTKFKbjE/PKh3LDk58ghH+0lYEu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAVujTI0zFnwBD4a9RcbfE4XDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc2ZDA2ZGYtNmRmMi00YWMwLTg3MzMtYzAxYWFhYTcyMGVjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmU2NjAxZGQtZTBmYy00ZjY0LWJhMWQtYzUzZDE3NGVh\nYzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6WATLJZiJawHntS2AHoWRWhU\nn+32maaJg8Z2T1D5vyvs/KNAz2ohHaSuh+IZHmJyweVOwa3BUuK6QlXxtvyjp6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPI3uiKRziLwhOwxLAVLPwbpoHk8wCgYIKoZIzj0E\nAwIDSQAwRgIhAJL5kLo3IEXXkaA4nfWhBDgZBFpw1RfVoyYM3fjjEO90AiEAjOCM\nTa/h3WB9id3yrn83wIEYD0oDLNOJbfM89Kb/N+Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc74", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `74` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAZd2gjVzXIQslIiQ1yH1lO7EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0YjFlNWEyLWY4ZTktNGIzMS1hODA5LWE3YTEyMjY0ZDA0NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFjMTQ5NDAtYTM2\nZC00MTExLTg4YjctZjAyZDgwYzlmZDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPQFVlCK21xfy948q7TDJEOsLUsbYtA3tcfipFuX5F7dd83OOy+JePEjriCdJ\nQZZCFYF7+HymaJiRjbjrVriNxqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUolATkDglT6ElTq26HJcxxqf2OQowHwYDVR0j\nBBgwFoAU926nVHOeKrO1h2D7kt4ZWdcIjGAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCEt+SPornkAvObtTrxK96h/ebwvQlLqGS+cVGv\nKATKUQIhALIIox2on7kbEAddJkARBN1wVZiUqgIVp9bqNynMjsj+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYkrml60ZxluDZWH/NZEjuKaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGIxZTVhMi1mOGU5LTRiMzEtYTgwOS1hN2ExMjI2NGQwNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQf6ArulJZXVylF7lQG+vBLAutEZYiSILAxybtYHMuEyXiS\n//h5fBLghHlZLadMYNibWT8B151XQnnthbqT8Vlco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU926nVHOeKrO1h2D7kt4ZWdcI\njGAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAXwFQRwc4ZUKFhntXDXQfPaKMk96LgnJolUHAevyywECIQDJwgsoViKT\nNs24vjyF0JCTcFzO5BMfV9edBZ9PyJ4/ng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAdJwDrfp88o75lcnae3pKNDPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFjMTQ5NDAtYTM2ZC00MTExLTg4YjctZjAyZDgwYzlmZDZhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmJmNDJlY2UtYWU1OS00YWI2LWFjNjctNDlmNzI3ZWY1\nNDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIJhZ5Vnv2TQIoP9clYoa0ZHV\nJ17ockxh0gF+ORWd/4QPIxRJuEovZXx17Y//IwPxGB6QraNkxUrupyaBiGty/KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUolATkDglT6ElTq26HJcxxqf2OQowCgYIKoZIzj0E\nAwIDRwAwRAIgdsOBJWg+KrFBBKsrEcbLqkBuXkAi+GYdiHwGI0eWlXQCIAdvthEz\nfDBI6VNpHrL2w0kvhFgB9G6qKqoc7WqZf4zg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc75", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `75` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISASdAZt7pVJ3psV5JLxI0Kju0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhYTZlNzg5LTBjMWMtNDBjZS1iZTNlLWE0NTZhNjQwNTExNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTcwNTlkZTAtNTA3\nOS00ZDFiLWIyMmMtM2YzYTI0NTc5M2Q5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBC89lEvxaiH6NNtRJJ/2eUNJSaoYDpqe6WdI8v+vrEdwGIrgNTZ2GmfmlY2B\n+7uvvWu/+UdR+0QPNhRTRZjQxKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfNXvb1Ny0GHB2cmeL3pzQkR4AjgwHwYDVR0j\nBBgwFoAUaJ6Xm+96B4H7YeNxoRr8fwqaKZ4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDCcXCHZRze4nIagDm9uoXJRazzrQJE6XyUdpNZ\nGWtkMgIgOlWsFYPXLs7yzkzxO3FbBTzCowy5IA3X3xKHWqQnl+Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcgk6A/IQja8oeow1i0vxnplMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWE2ZTc4OS0wYzFjLTQwY2UtYmUzZS1hNDU2YTY0MDUxMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx+7QvPUsGZZYe6Oh8mW0xyLjikhWK9yq+u7l2mvEErFiu\nKGpPkEUGffncG8X2XyN0ZLhUOZnrDIT/GCUNE0LMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaJ6Xm+96B4H7YeNxoRr8fwqa\nKZ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJdNridi665+2Pzvaj/Vw6BQ3gnSfVmq0JKdlRsmVFGbAiB1nRXMJ1Yi\nSAG38eFfkfhywjs5VB6ckFGw22KD2EQq9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISARssKERH6zCBSIu4bERiTueEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTcwNTlkZTAtNTA3OS00ZDFiLWIyMmMtM2YzYTI0NTc5M2Q5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmZkM2ZkMjktYzcwZi00ZDhlLWJkNWItZjY4ZTMxZTVk\nYmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETjijTKEOBw/BwEev+fkhi8Dy\noHRinW0BL0E/pGrcejAOO/0PsFIrhm5Ap1et6ibwmhJov2eah9AW8W2EPZdfo6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfNXvb1Ny0GHB2cmeL3pzQkR4AjgwCgYIKoZIzj0E\nAwIDSAAwRQIgWVDMAe6BLVhhrZ8dFD52TOLLfHxH69LKiIvkaA43hXMCIQDAY1gI\nD0E8rffsnpp0rzZHEXh60VB9My6C5wgPYoKfgA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc76", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `76` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAXa4N9EtcHuJh+BWmxp/TkeGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0OTQzYjNiLWYxODItNDg2NS05ODliLTNlNmNjZWY0OTgzOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVhMWYyYWItYmEw\nYi00Mzg5LTljNGYtMzE5ZmQ1M2M1MjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp+0KoPwRwPj6UFeWRIoG7vJ5VgJmZ/7vSoZuontH0NIDuxMACsUqye5N7RQk\nFaoP/bTZz3rC1Nijwv5f2JiHOaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6UjP9XgSsCChPiGP06ZQc/5u89MwHwYDVR0j\nBBgwFoAUKGVuXlnhp0FQUtx0kVFeeOpm5y8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCSuZXnUG4K5B30RAbAwIGl1UzD8mB4wCJE0GFgiS00KwIh\nAI3ddt/E4RJeAUaFpoSRG28LbQPzDOtOPPAQaWHoq2+4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS1dJVe3bNrPFWWr0SVrTByqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDk0M2IzYi1mMTgyLTQ4NjUtOTg5Yi0zZTZjY2VmNDk4MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTxCP569LAuavuIJzl4WjVP70KEOCaUb2GH9DDTrcTLZyH\nly4XShnWZPybNypO7ayu37gcMUmJ18cGlQyzMcT+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKGVuXlnhp0FQUtx0kVFeeOpm\n5y8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAL2ZSn/jM2NeS3LigBrf1jvs12jzDFOvaS3Y6L/H9ixYAh8ikojPId9A\nvrrs7sRRMbdNb3baJpH2yX5rtCwzRF1+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAVJi2MLIdbi4nPC67yswwhArMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVhMWYyYWItYmEwYi00Mzg5LTljNGYtMzE5ZmQ1M2M1MjU5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDA4N2Q5OTMtYjM5Ny00MmJhLTgxZjgtZjIwYmJkZWY2\nOWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWLvExgclt//4cxE7lTESrLZq\nGTpdTYZykIkULCVpljfR77/YQ7Zs+HaybzH9o+Jyh80QeK6pmmytsqo6RsmKqqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6UjP9XgSsCChPiGP06ZQc/5u89MwCgYIKoZIzj0E\nAwIDSQAwRgIhAJ65m+fwSQdf6z0RNJ7h2PJ7gm57hF3qIpS+NHvFbZEVAiEAuS/b\ncsVV6fe6HoXdfLlGDv1EMY53zTEeEsYjRyWBhk8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc77", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `77` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfAGzn7v/fLA1rrnHwCTQUUbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzNGY5NmE0LTFhMGUtNDMyNS04N2U3LTMxNzBhMTkxZjQ5OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFmOTEzMzUtMDJj\nYS00MzY2LTkyNDQtYTk3ZDA0ZGFkMzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErtX4+HAGtQUtmtM/sAxF1HfoOrNUBftL+lpet+wK5F0c/5BVRojE3b08GI94\n//3qo3YUqy8u/zoSdcNEJ9X1BaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2inY9RQz56C7f338ZkMvb1QKW4wwHwYDVR0j\nBBgwFoAUmajSuRVkqYGZqYbYC19SBFvs5Q8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGwHDIXBk7sxUbGDWOmedgc/csJkadI3\n96h+3FilQy5yAiEA7m40PooPUJET8MEJVn14egDITWvYpxOvV2k5wOF6EAY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQzJr/uXhH/RwEN96Por2V0yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzRmOTZhNC0xYTBlLTQzMjUtODdlNy0zMTcwYTE5MWY0OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHS3R6BYv6AhNmkLn03fB2TXM1EGLH3oD0vHpBWM0HcLnj\nnVIav6MVKMNVMDrSHq2NPpYq0n8Rq4CExAUtwb2ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmajSuRVkqYGZqYbYC19SBFvs\n5Q8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMPUcWyd6nuMb5AtdWfCZPpBDJ3e+iX9PkfJl8QHfXR6AiEAroNFPVan\nWB2qEKc5P4VCD/GKPODMCMRkD3Z6wtoB/34=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAek0Wjq6KF3WxKy5plUTFHJ6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFmOTEzMzUtMDJjYS00MzY2LTkyNDQtYTk3ZDA0ZGFkMzkwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDQzN2UwZWQtYzA5MC00NWYwLWE4ZmYtZWMwNzZlMGQ2\nMDE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOI9zw+6tBld1iGYg8nmmlB3C\nVkSNRPpeJLdr/JV+vam0nGo304T9rHs7QeEmP0FJgz/MnLvrwV2lD6azXITY+6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2inY9RQz56C7f338ZkMvb1QKW4wwCgYIKoZIzj0E\nAwIDSQAwRgIhAKeSCoPTmK0APHoRXO6f3P1+J7s+EoGqtD9SwPGud5rQAiEAmNkK\nCnkDUSnVlcUvcnA7IoCKRBnnvRrcGWR5FjKrTnk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc78", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `78` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISATC97G0PpKGdJvoIQ2XEmYRuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZDAzYWM1LWMzNDYtNDEzMS04MWI2LTMxN2IwYTYyZWQ5NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I0ODhmNjgtNTMw\nYi00MjQ1LTljOTMtMmE1YjZkODc4ODVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkPy90n38RF1i7yHakhASFENMXTClSm0PYc7M99jGOiRcFtjmPpGqNUoFoeup\nU3WCrQAkRh6BA5SF8sdA8947ZKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1C9L2pRj28y7rxwAuZGKjE/OZaUwHwYDVR0j\nBBgwFoAU5JKfDhXH04x4xIGS2UftmTQi0cswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAx5tre6VOdO0x9kqCXSKRMZr89/n+AD\nqOWsTwjaF0MAAiAiLqGM0RUJIa+fS7pWFMmilYdzxt/Eq1zaAQ8sKjWTGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARUeCrjXKstOaDNssaSGhcECMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGQwM2FjNS1jMzQ2LTQxMzEtODFiNi0zMTdiMGE2MmVkOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFf5X/lW4F1afDT0MD3HQAqRAiLUU4AiQ0ha6i3ixD1yw8\nT5ECm3bh9yvu9VeiFqAsCVJ5o6sVEPO2yd1nKL6Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5JKfDhXH04x4xIGS2UftmTQi\n0cswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJp5DOquMaVXWEC/nYD9HelvH6PZf4RTGMGow18CAbpTAiAm4qKB8K2h\nJONWANrQGcq0FEEfQe0DdYnfFV4YUgto3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISASG/9wFja1NeqQDPuwedHsf+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I0ODhmNjgtNTMwYi00MjQ1LTljOTMtMmE1YjZkODc4ODVlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDU2ZGRmMzAtZmFjNi00ZDI0LTg1OTAtNGMwYTJjZDg0\nZmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwSnRSDwuzLiLKpLkc5YAu006\nRzH6SJx7pxPjFIqteo9FXVq84H1kqudIKafAeVqJAfavJrssKWaUBASQu3ntQaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1C9L2pRj28y7rxwAuZGKjE/OZaUwCgYIKoZIzj0E\nAwIDSQAwRgIhAIGwHUQL15AgGMKb+aWyon31IVAVXGpquNLbx7GWzal3AiEAy7Rc\ngJaJX284We04WeKb+db8qArW67Jfnw5Aas5TkLw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc79", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `79` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAeIQ/ncdw1LNtKzx1O3TH9RbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZTY2NzNkLWMyMDUtNDY3Ny1iNDJkLWM3OTI2MzAzYWU2MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y2M2ViZTgtYjFk\nZi00OTViLTliYTQtMjM2YjRiNDBiY2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbfeifWtmeQbHc0FWEMoDIRQ5Q09kwqg3r5pliW2To82GIPECEw9CiscRYs5q\nSa7IRPUBg6s4AHzOduu0nb4w+6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMU+dLdqaaBNPzH33XsQRwZbB000wHwYDVR0j\nBBgwFoAU3kTTt3F6CLEVwzsC2IjjIu9zrygwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHeH0TuOPB5t\n1VpikjJ3rQVLAklN73jlI3ijrwTgpG4+AiEAtJEkOUDvolmXxkycNRmZ799u9HW+\nJNLI46P2Le5ANnk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARq5LnrHto4HpbG1+jF1ODt3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWU2NjczZC1jMjA1LTQ2NzctYjQyZC1jNzkyNjMwM2FlNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaaswL9jMDn/Yeamz1p0UjCfsld93V8DrPYAtwrRAlxBxo\ncRcQ2aLJUmUvDKt7eBVwAWwtvdfuncqFQimpT/ZUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3kTTt3F6CLEVwzsC2IjjIu9z\nrygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPOowem3a/4fEaEoAfunePB3mGs4L8YFX6Oiml/fmSvMCIQCoiA6qFvp/\no3I7kwRvtGaNsk7y40RiakCIA/LwP45AnQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAWUmW9RGxzsPYJ5JoL8p7/j+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y2M2ViZTgtYjFkZi00OTViLTliYTQtMjM2YjRiNDBiY2NkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmRmZjJlMWYtMjM1OC00ZWQxLThiZWItZGFjNDYwNzc5\nOGQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOsVDqZfBAdEfs46Q86XO+NXR\n1NoNxTF4wy7CF8uW+c52agrHhkYuO6um5lF3IFuWEaUNY7lO59dBjRVq1YW4ZaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMU+dLdqaaBNPzH33XsQRwZbB000wCgYIKoZIzj0E\nAwIDRwAwRAIgG0h2vHKmqMi2MT/xg10nTx9TryTY+aMaycjaN9Q60AgCIGqlj3et\nXUJ7/1b+v9cL6HkXImY5G3znrJFxoznvpMoz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc80", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `80` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISASraUPMWx03AiZG7ba5oJDbJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4MWRlODdkLWI4YmUtNDljNy1iY2M0LWU1MGQ3YmFmMzIyMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFlMjNjMTUtNGIx\nYS00ZTJlLWFlMmEtOGJmNTU1YjUwNDEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4uS/Owhu9Bgmcnow0D76N3LPeVGQ24+uOgGBCMsO3+1zUEon/UIb2KSFj0uz\nGTtKoWQZEZuADUydkGpIV3ef2KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7yeE1CVF9mWAxhHvTNWYiSqFDNAwHwYDVR0j\nBBgwFoAUOXd9TmaDUcuh8LcEgARg5fKqJ/owNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJG0ZwcQs+nC+vFfGeOGqqvs8cDHb+EY6E1ZXRl9PRpQAiEA+L/IUtla\nd7Q55XEbqfMQaRYPTW2MHRFTdQ7bogF/2ac=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATVwB5lTQUOVZ0pKYVIeONAlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODFkZTg3ZC1iOGJlLTQ5YzctYmNjNC1lNTBkN2JhZjMyMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdpgYIi9TkJgbj8YgrG+slDPSfRtOf0oHL01yvl5+VVbzy\nWH/S8xFkOvLi420jyUEKWwaZ3+dTpOKdTxcjDjT2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOXd9TmaDUcuh8LcEgARg5fKq\nJ/owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWvYuDh0x/OX5GKysPVel+k9q36SQLuUtoctsMP23TWoCIGJO/bQ/AsT7\nF5Jx/UWyMRKXzYjVvNCC8cYnBr45X7xj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAWx+CkRd3NE6T4LVcXxyHs+nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFlMjNjMTUtNGIxYS00ZTJlLWFlMmEtOGJmNTU1YjUwNDEzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjdjOTQ2NWItZDgxMy00NTY4LWFmNzAtZGRhZjNlZDc5\nMjJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELE9KKQaQYBHpwKgrHYJomIpD\ng5WWwFItlicrT9cRtVti6evIT2WSqskh/LFKpigh8J74e1GVq59ffUUJbbYhTKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7yeE1CVF9mWAxhHvTNWYiSqFDNAwCgYIKoZIzj0E\nAwIDSAAwRQIgLPSoSSfqRGiSnDpePdd+T1LAKL2coE0lOpABBF4/OAwCIQCg+p3M\nJ4rKOmOCnmUd5C1sFyV5JOIALA/0i+4WYhFlUg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc81", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `81` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAVlLNdPR5i5i5UPkj6ZJQbiHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0OThjMTA2LTFhODgtNDdlZS1hZTM5LWZiNDU5ZmM0MGY4ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDllZThhOWEtYTMy\nOC00YTRmLWJiMTQtMmQ2NjcxOWU2MTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHCsIz9KDniuAQAKLNMZX9Tsi37ZXQWgP2h/xDjNlfvkS9u1dSTN2K1Ce6NUI\n8KRKAnswBNcyMOXrTHY2Ie/VLqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo7Pc0jpzY9Pii6NbM0dZCtkREt8wHwYDVR0j\nBBgwFoAUbgh52ALKz/KYJjQdpPrxt53/z+UwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIyANiICtPSu50BB0uorICE1vR9JRjgwT9IkP2bDiRmwAiEAy/7IdTAx\nErO5ZHt2ccRj1HhIU/+YXDIWcgP7sSIMMZo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAej1jC9poxP8isJm2mg9DSECMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDk4YzEwNi0xYTg4LTQ3ZWUtYWUzOS1mYjQ1OWZjNDBmOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxMycMXsaIfY87s5CPi7YDSEDCiILLtboE8swoB0LvO+5r\naVTB0xzyM+PdhRtGZXpUga4Lw5G8Gh4+nAVC+Py3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbgh52ALKz/KYJjQdpPrxt53/\nz+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQFCvLw2n6JiK5FpENFjfc1gygntB+xrHV0TXdxSnH5ICIQCqkULUhw4t\nR+e7pA9eEliZxa/84ol+ZBak+JtYehmF5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAV77vhvRTbh+bUv1aJyVIPuyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDllZThhOWEtYTMyOC00YTRmLWJiMTQtMmQ2NjcxOWU2MTI0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmQ0NTdmYTgtZDhkZS00MDIzLTg5YzktYmE2ZDRkMWM4\nMzZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/I+xmY7Ef05VDglvA3M6nVqF\n6QlR6xHYvDi3I5WM56kF+1sGVssX8WHQjxaO0SNkdnvCMe/AUSj6uFHYSHVdTqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUo7Pc0jpzY9Pii6NbM0dZCtkREt8wCgYIKoZIzj0E\nAwIDRwAwRAIgatHncWSpZ2/SJ2gnpq88zeHTlbzMt/wCuFXfSnmgnJwCIFe0EJNa\n+WmqOur9IX5ubQo308XR4REcnOYl3BVzn0e7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc82", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `82` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAXlgKNioV2JkXXXu8MMI6t1NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MTllMDQzLWJjYjctNDY4YS04ZWIzLTE4ZDM1ZDE5ZjJmNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDlhNTFkNTQtNmY3\nMC00NWMzLTg1MjMtNzc5OTI4YzFiOTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBK3Dsk9+7neBEyEyH+BLUgJMg2YKuu3heYnHil+ZUtZ6bcBDN/L4ssUbBQuO\n7eqFk1vPp4az3eFjcGeUOdym9qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiOYhFp6MWaQfmefwDdYrInGrO7cwHwYDVR0j\nBBgwFoAUixqiUGEPa6T9APR1CQsPjfDoJxgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCRAV32z7J/NSarL84Dc09PFavvPHJ1FvZpwKPN4chm/QIhAMLkoRzC\nwyjKGdScSA1jqWv/LMFYp7YBeZpeAanJCt43\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUJmK4KddM2/UyvT0Q177OQdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODE5ZTA0My1iY2I3LTQ2OGEtOGViMy0xOGQzNWQxOWYyZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSPIS3yzX4Yw8ha7XKY93P1qinUvts276w+peAnbJoXU0+\n4T8zc/Y6JobxXMw3ElknMCOxbgOvuSg6mrTT2DC/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUixqiUGEPa6T9APR1CQsPjfDo\nJxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANvHllGbRTch61/HykFiFt5vsvFuDxPcInqWeLSzl4DLAiBGuzeVIZyr\nI75yUgDMMjcnq0EHwGym0r5oTibl8263MA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAXU9zdxeVwUPE4Xdci5ai2s2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDlhNTFkNTQtNmY3MC00NWMzLTg1MjMtNzc5OTI4YzFiOTc1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzZkMTQ1NGMtYWMzMy00ZjBiLWJlOTQtNWE1NmNlNGVi\nODhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEU73EdLesNXxUzADXTt7uI53G\naiHUAATwF+35IYimXlJ+lYpDQbJdbPx6Nx3ys7cj1T+KSg72dRDsG/FuZAFmBqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiOYhFp6MWaQfmefwDdYrInGrO7cwCgYIKoZIzj0E\nAwIDSAAwRQIgMzhRgt7t+2hIQ0MJlr3FwDcn+ew1FP8rsfzpO55lZU4CIQC8QCRC\nGmp9MdQSRif3uOksZfJUfNb7UCSjY1TaghdrRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc83", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `83` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISATqKLlCIQ9Uvgl3hqlccSK7kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmMGY4MzFkLWMwYjUtNDJmOC1hYzMyLTYyZjQyYTQ3Zjc2ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk2NTJlN2MtNWNh\nMy00MDkyLWFhODEtYTQ1ZDAzZjViZmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDF1rzLjhqGrBpxgJiSgW78IOLM7x8KPTg73+wjX7v0cxzUugghXRwfrh75CV\nPqYt5RFKSnW/36yuzBXqbEPh26OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBpE/DFb/oaQqoFEHf2rwxnaionwwHwYDVR0j\nBBgwFoAUBRxrrP6VUY7V78Nbov+mlTZu7OYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIAWkbmfuPOJq/DL38d5VSmqqTTwxmx0jwKwNsmYM\nde4qAiAtHuzA+TJurOhanaGyAuV5+SKZ9kkVVAp7DAkXm+JbXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa1Hk8gBgc4Eey0D0Ddmr1AgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjBmODMxZC1jMGI1LTQyZjgtYWMzMi02MmY0MmE0N2Y3NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3+3n5l8RbRHXzj+3YpL4zaEJ7psjeje3BssId8Za5mX9h\n/5yYBDyN2SH3SAKnEFOYgFjl8TnyAY+lfs9qTeVeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBRxrrP6VUY7V78Nbov+mlTZu\n7OYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIK8oxVSEWyxUVD1Lsz2Gk5roFSNGr9z4AQN5sRpZfH+AiEA/rpXgIJi\nixqw7AB64uokdBudpoaWkdKfM2D0pRzD6lg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAdj/trYdGMwSr36AW61nh27kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk2NTJlN2MtNWNhMy00MDkyLWFhODEtYTQ1ZDAzZjViZmMzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGUyOTBkY2EtZWY3Yi00MGMxLTkyZWYtODBmN2QxOTQw\nMzcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4tie1nqfwPPBHEo5k0P2zWqh\nGlbAt/lvXW0/svVclRUMeAGw6JeWWGHuI4l1FTX3v70t/6wfhXJa6kwfTHrunqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBpE/DFb/oaQqoFEHf2rwxnaionwwCgYIKoZIzj0E\nAwIDSAAwRQIhAPbjtZgx+UYnu5ZuMZeHL5NdyAAGByJtpn9Vfiz8bI8OAiA4L7cT\nDCwqk3qYf3oPJLS4ej2xlfo910Gq4s0qchDbTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc84", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `84` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAYTjrV0gbK1tbALjo4sIFatiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlNjcyYzQyLTNjMGEtNDUwNC04NDYzLTc4MTE4OGZkNTY4YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjkyNTliMDMtNDYx\nZS00ZTlmLWIyOTMtZmQ2YjNiMmFkZjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5aQPA2jimSXLz+7JQGPEb2mig11xvuzaQv9FZME7FKuiahMEzu2UPIbM1q6I\nQNrTwuUWZcf25J8Z5y8UmHAVn6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh1cJwYqMCXI4muEw70bunrGqx4IwHwYDVR0j\nBBgwFoAUHTvWl8LMWUlBqyUyI4+Axcc/jjwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCPgiPZuzgscQ8s644oEnAZVXL4rlv1MkdJ16LU\nOXN4BQIhAP0VAoV4bAumKhktCW2En7M2HUDF89kC5RsBM6/BrXJ3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXZPvEocBC3+TBY4NOWLALX3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTY3MmM0Mi0zYzBhLTQ1MDQtODQ2My03ODExODhmZDU2OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATa9hBQSOw/oWC5mHX/OXaE/Lg/TWXwI5pdSU/r1msrIH/u\ntzUagsMsjBgANmIQg/cCt8+fIbAqPzVOt1YHJSndo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHTvWl8LMWUlBqyUyI4+Axcc/\njjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANluRIbZ+GoddeksLM/F3Qng7H61dEU+gWpE+/6utHTHAiAyn4NZNb4Y\nfPurnsSqJgo5lVFiwO40sDwXrODzINcf9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAawSqkXEAzHzyjC7948rH7OrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjkyNTliMDMtNDYxZS00ZTlmLWIyOTMtZmQ2YjNiMmFkZjU0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDcyOTE4ZDktNTdiOC00YjhjLTk2ZDEtOWRlZTlkYzFl\nMDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELzUQdNZSJ/CGpF6CBskPkkL4\nvS6I164yKEf9NPJTQjEj/HFz17f/b/8QkcQALnAx+fyIYF+j78Vfr0F+rrEByKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh1cJwYqMCXI4muEw70bunrGqx4IwCgYIKoZIzj0E\nAwIDRwAwRAIgVqj6s4kuh7R5QQS84fMCPmIPvBWlvzMCKzCPulP0AcACIBpf9cXq\nj+a3hJhVf7LyTG6sAEuEgfQJ60YRP1yw6xw0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc85", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `85` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAd202aK4+fCVVtW6Cxi7R3F9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1NDc4MDk0LTNmYjctNGM2My04YzNjLTkyNGRmMTgxOWVjODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQ0MDEyZDQtMzBm\nNi00ODFiLWI0NGYtZjk0MjY3MTE0OGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1cj3uFpPjnmtDln+AFctxaPK69ZOalN7rNeZvrgI6qc1Jd+7jBbVJrBISxQT\nV/H5TmF8AhaZOL/U/vfuUnLa36OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoPGtuqYhauzTDRek16G/GnbZ8HAwHwYDVR0j\nBBgwFoAUOGsQQnHipYRMve5gm2+6aIa7DzIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIHlriimxZYRQiekbp1EnXzabvRNrMFebW6b8smWMUl+bAiEA\n2HR2rLWUERXK5LxDY5O14rTRdwf0NiR9LpjIbWJAeiI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXIzCLmGaXyCHAH2NEuFUhunMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTQ3ODA5NC0zZmI3LTRjNjMtOGMzYy05MjRkZjE4MTllYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW6vjaYvTzIxQeTEEuFYu1ec+TPzw9QZC75bhVaMS6b67F\natxjDHp0zMxg3mksd0Ta27LkH/klG4eoBpRlRp8Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOGsQQnHipYRMve5gm2+6aIa7\nDzIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMIt98taKpm0bKfz3bi4T5wL1/MYUeMLbaKLxgm78CFpAiAvnE7z+Xd1\nUgitaagp5gX67eUQww3Q4vpX7Rr4oNyFjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISARW++a9lIfoAntAxNXtemQfLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQ0MDEyZDQtMzBmNi00ODFiLWI0NGYtZjk0MjY3MTE0OGJmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFjY2FhNWItM2EwMi00ODdjLWI5Y2EtMjk4MmVlZDJm\nZWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENXxOhs0UNP/0UwtEFByzU8J4\nTdbA3nkIh6IWJjTwfC7sKEop9N1PhsufIBYzUCCANWFhP1naUuoIZ6tGnvU8cqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoPGtuqYhauzTDRek16G/GnbZ8HAwCgYIKoZIzj0E\nAwIDSAAwRQIgQV2v6f5VvtCcXJry1Z0iWE6dPsP2SGjtwEV70KCFCOgCIQCSrHU0\n2eyhLxLgoriVpIBKg/bhHaW4i/kcyeWSyMp3nQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc86", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `86` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAZo9YlvaXb8kBSUwqEmTWIwfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhMjdhZjlkLTU5MjctNGE2NS1iM2RiLWZjNTUwZTY2ZGJjYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDAwMzkwYzUtOTBm\nYi00NjhhLWE0NzUtZTE4MjlhZTYzZTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl3FSpO/8RaQ/dG6MV36RHwUk3Mm/8myO99sPOsyKcaLCtWsb67npoq3NVuZM\nK0EGquPozSITtrOamt9VuVjZPqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8hivFAjjafWHFLr6Q0gNGh8uAt0wHwYDVR0j\nBBgwFoAUz0UGUQPT5xoaXSWDNnFU2Qq19HkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCLhr591BvGX2b1HznvASFuNDoPmMMr\nJ/D1vqDzBQ23HgIhAJrf+/BNouWpSGBCB3AYKiWx1a6G3oFdm4XMfi/pwoau\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdNZqDXzyXRW3A2ir/GnHyHEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTI3YWY5ZC01OTI3LTRhNjUtYjNkYi1mYzU1MGU2NmRiY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1SQI3Gh6Qq2gzaM5o9RaqPWzRixJaYbIAz3ahu6CMeZnn\nIoEz4fRt6k3/9qaKOpb/nntVq2Q+X+IqeLJOuEe4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz0UGUQPT5xoaXSWDNnFU2Qq1\n9HkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJouiazsWXdhKfd+7zZn/aBDc37PuzwJ+WPwXqfWCNheAiBeRlMnKRTR\nOUb8bRksjjepRu4K0008HcWZUIJhVu20Ow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAVCcZA5sbugAtkr/eQk9cmIYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDAwMzkwYzUtOTBmYi00NjhhLWE0NzUtZTE4MjlhZTYzZTU3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDYwNGM5NjUtZTBjNS00NjFhLWIyZjYtMmU2YzBkOGU3\nYTI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8Y2LoIDYMs49uBjfgjvu98YY\n4mz8QExAsfGLtQ6TAlDwo5Nz2t8rdHN8r2SlGVm/JecUP9OeMLYEavFWU4ocGqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8hivFAjjafWHFLr6Q0gNGh8uAt0wCgYIKoZIzj0E\nAwIDSAAwRQIgVvNGKWQk3UFUwZCDRkGYTjbQD2BB91YASiwlzZ/VobgCIQD/UKIn\nHjOK8V2YgbcSkqbT/zGHceluGm2T0AiWXr8Irw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc87", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `87` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQmu15ifwkI73T7OynVM2MaLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NjRkM2NhLWY2ZmMtNDJjNC04YjljLTM4YzUwMmIzOWNhYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY1ZGU3MTMtYzBk\nOS00NzRkLTgyZWMtYzQ5YjdmM2NkNDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnmz0USUiEQL9BxwYiv8YAn4Wlryqhtyt6U4NBr1+HnmqiLaOYWDuyiTXEXhv\nScVLE9KOi1Iu0s5DN7lZlqhjnqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuHhC9+AC9/9AIw/YpR1ulWCUaYcwHwYDVR0j\nBBgwFoAUMvEsrvAe4Ph/nlwjwPuHLSc5PmgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHINQA+u7n52p7pc2OEGYdWpL4hchNoX\n8/ydIkQdl0fKAiEAgLL9G7MHawQVcO5marGR29/BP9fqJyAnjy1ikyDv6ZM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAViqLoSzsubDBUQLzgBUfajuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTY0ZDNjYS1mNmZjLTQyYzQtOGI5Yy0zOGM1MDJiMzljYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPqKuSiVLSTT5T9PfkWpA+qDppn+kc5vkZcKl1vKhO/IjM\nevayieZRV52Pnj/potr95cDI1actkLXPtfi4m94mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMvEsrvAe4Ph/nlwjwPuHLSc5\nPmgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQiXZe2DDVyiZBHLPF9bfosIt53kC6UjpK3onW6l8izsCIFIdbQIh0che\nlLjxxpDTO5cTF8kxY6B3wrupjUxSYh3k\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAUUZWRmmI50UawidGWRArgNnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY1ZGU3MTMtYzBkOS00NzRkLTgyZWMtYzQ5YjdmM2NkNDNhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzVjOWU2OTktMzkxMi00MWZlLThlYTEtMjIwYjlhMzkz\nMTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa5dihm+1TbKMsmfoQKuvzoGi\nu+2YkoiIsEb0rO9PxysatWzRfl8AgU9CS+UewxIprJJBQWQmHDAYMP5E83g8PKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuHhC9+AC9/9AIw/YpR1ulWCUaYcwCgYIKoZIzj0E\nAwIDSAAwRQIhAIOtxbRE8MSd5TJZs11oAhdTO5V/HITbRnYiVq/mkoOYAiABhoQd\n2Cd201RXlmkXj6z0p70k4GNQYrJXfGSPcdvQUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc88", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `88` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaCW2RjtYq0ZqsivfVh/6Ws7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjYjRkNWFlLWUzN2QtNDc4ZC05MzllLTdmNTNjNTk2ZThlMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM4YzEyMTktYTZk\nNC00ZjYxLWE5ODctNWM2ZmFjNGE3OGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG82hT1z943RcTLL9OBWErmymuwdEA4qQh0MqEuIdEx+/I52sSWGJlhs+iqiG\nvF4xCAKmdXEC7Hpn3oZDJnI9S6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKTIizbH3y1LnldsQi+dRh5bS9n6MB8GA1UdIwQY\nMBaAFHLWpvyzyCRMIXcX0Qljjd2eQq7OMAoGCCqGSM49BAMCA0gAMEUCIByRkrfy\nlqa5B9AewqwCgxAlHrdHa6wPMGd3xJ5JPRDmAiEA8cVZG4+0hix6mNXpATcd/SEy\nk+NPIo1iqkSn3j3a+e0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARgUHAd4x1v2tacFE5tkgxNSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2I0ZDVhZS1lMzdkLTQ3OGQtOTM5ZS03ZjUzYzU5NmU4ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASg+QC6ue69zp324tZUm3bN6PURdTGWA/QNRez7GYn9Ul10\nNxkVMUp0tLu0kOrwm61XqiIjyy6CGQ00L2edVo1Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUctam/LPIJEwhdxfRCWON3Z5C\nrs4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfMeD6/HSlyRsezqegv9wBmkjFaxjajXeHIZYLfWCxiYCIQC7ALOIIi2p\nOkizEqj1U3zwciAkVyiEmyV0Ucbu/zrg5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeEeeG8A1S4CEpALFmDPBqZ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM4YzEyMTktYTZkNC00ZjYxLWE5ODctNWM2ZmFjNGE3OGEwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjVhY2VhZGYtMmYzYS00M2EwLTk0MjEtZTllOGJlMGUy\nZTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETkZMLZ0lAg6xr/QmcnIkMF2O\n0Q2MRNEqA4ZmvB+AIB6u4f3D3S7ZiZqQ8NFeliCyFlqLcTcHHKkcQGQy2Rr5K6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpMiLNsffLUueV2xCL51GHltL2fowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiB/O8+2ImhyalwPC7j3zI14KlUbg+Ub\np0PTcxhpyhz3uwIhANo0AdlM34SEW80y1jWCguBPep8cdC4SJDrrmeqgFHOH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc89", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `89` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAT4i4xdvmQ/M4bYkwjrKZVv4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzNmM4MDIxLTM0YTktNDE4Ny04ODE5LWI1ZjFiNDZiNjM4NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U5MTBmNDktNzll\nMi00NTAyLWE0ZjYtZDFmMWY3NTRjZDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6wM502q/mDU9GZqxAvI6M1w4KzpnCyY1WpgD9N8g3WU60/MogrIkfq3tY/nY\nCcNpiHl6mfQdC6Qm6sCTMDRI0qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDwNNqoTn9ct/+DubOSp0Vr+qP9lMB8GA1UdIwQY\nMBaAFDXIECNpWzFh40pK6Jos+HmhpR6cMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAA7DXclW4FAHJ9Ne9huE/aUMA3q4YyFr2+\nYtCNhgfrDAIgHlXrr0gy8mWSg2ZVivmUjqI1KkcccdgL54WrN1gsWfA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASnw1RP5TdBWfsD40G2VF7m7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzZjODAyMS0zNGE5LTQxODctODgxOS1iNWYxYjQ2YjYzODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzgRPyo1TiRSSqAyIsoOA+JQgKa0kCJ+BG50kVg4atzbQl\nxiKYHduRe9l9r2xOsTFbyY21dOy6+SEFFVjuD/mPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNcgQI2lbMWHjSkromiz4eaGl\nHpwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJOLZdWxNOC+kYjme/AO7I+RIDvzDAbAzPllR6aDBlSgCIH6zTsmJTg9i\n1i9sfK32MgKBIBwGhuSw4wrM5YNEiWER\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQYWbdA1SycQMn466y2qQ8PeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U5MTBmNDktNzllMi00NTAyLWE0ZjYtZDFmMWY3NTRjZDBkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2YzZjBhYjUtNTRiNC00ZjZlLThlZTgtMWY4ZGNkYjFj\nNzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmGU0ec2uzIyZ7qkuxI5qZy69\njzToRwrjnJmoGS67myhuLvCIdqBiLEidM/T0uzgpGKMPuxY37qtOKYH3K4Zk3qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPA02qhOf1y3/4O5s5KnRWv6o/2UwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAptqNGYY09muD9kbiMEpTaVAAZxv6\noA1QZtlnLumGPgUCIFFuK7NQ80ylgkOlWiiDbRP/oKN01CLoJIV3qNU/8eaQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc90", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `90` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAc7UACQEQiF6zO97jS7CANKqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlYzlkN2UwLTQyZjMtNDZjYi1iZTEyLWFmOWVmOTE0YzgyNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg0YzFjZDQtZjNj\nYy00NzBiLWJjZmItYjY0OGEwOTViMDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg8TG4KP/861JijAZHmmMtJk8Ifh9wValD/1yDIL6VPOMwa1afVQsC9c/1+Vk\n8tOi2PmBp8QQWZnKNzzYxPjn/KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPKOVw/zsF2FQ80F5Ey0Mdb8T1hUMB8GA1UdIwQY\nMBaAFPcQaeZE6P8mcIhgY680IsRH2b5jMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBBnGDuIU2CSr/1WwVrgjWVYXyIhFa15Uyi\nLfmHVRCdkwIgK4iYmErXUDbCl86WquupdybyPN+dyxrx781ya/QWEN0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcxnBp7epiid3r+hhXTcAQoKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZWM5ZDdlMC00MmYzLTQ2Y2ItYmUxMi1hZjllZjkxNGM4MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx/GTX6vnMplN5zb5Jlt49pMT5Jxaa+C5p3JD0FdSLWeZH\nk+NFFcB/NK7pSnOo3G91D8Do7jvNUjcBS/Fj7AXNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9xBp5kTo/yZwiGBjrzQixEfZ\nvmMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgabTNyDCL1eMIzIdvnNWQBMd9sdbIx+4ZeJ83JN9DZ+cCIGEqSrfW5Wz0\nlqma0jrY2ZtMusuJm2yy+jSDoTqKgyq4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUSPXRs83SMMLxXvcMPo4T4OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg0YzFjZDQtZjNjYy00NzBiLWJjZmItYjY0OGEwOTViMDk0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmY3NjUxOWUtNTEwZi00ZWUwLWIwMjgtZGY4YTY3ZjRh\nY2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp2TEHtg2RvEC6WIMAkBipOg0\nrZbir2VOoGHhplwHpzllZwV81SJheLPhctnThW4QVoDeAmGwUGnr4aZX1/XUDaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8o5XD/OwXYVDzQXkTLQx1vxPWFQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiATEH0IWh+vWuyk6woeCIHDux4hm/qs\nuqHiHDlbhO37GQIhAJ2mcp+XpEqRFWNpzxSRvewz0M6UHLs230Eqr0pRO++0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc91", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `91` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAQAJqtNLPjo1feN/adaBzF9+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0OGU3OWJlLTVmNWMtNDI5Yy1iY2IzLTc3MDJmNGY0ZTY5NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDNmZjg4YjctY2M4\nMS00NzMyLTkxYmYtYmMwYjNlNTI3NWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEep6nOGj6qwMze4DrzSBTVvm3jDIypbT1d39VyLx2FDHer/uf2qDzakILqwCO\n5jkinfLcB2r3HEIvVoBwP5EPrqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRJFm2EvE3rWIcnW/5eEOtQL77q7TAfBgNVHSME\nGDAWgBTDT8N2Tf9XSa5kfamau2OnChyrkTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAqCIijEh3rCAra1kSvsGhLCZOZpYw/j\nre4mKLBAk6tXAiABAyoertOp8JjuByWaIjKghZdaFKl0bNBsN5+YxL7t4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATAVhzi0EDhtwf1+VRh4IEfVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDhlNzliZS01ZjVjLTQyOWMtYmNiMy03NzAyZjRmNGU2OTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk9qFivUH950MfwbbNGCy6d1xWK89WDpmUnm5fwU3G17RT\nZzdjHdWXHdSp8/sD/f82rtZ7SwBFlGW6O+rG7Ofro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw0/Ddk3/V0muZH2pmrtjpwoc\nq5EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQbuGPfw8E2/gHoZyEJCz08cmeu0xs3A0OBIBB6qFjRACIBEzWdTo7DK/\n086LU6Vxj94beYZqQMCV61MGWaK3ZGNE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeL1W7lumFoiOgquCXWJvo7qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDNmZjg4YjctY2M4MS00NzMyLTkxYmYtYmMwYjNlNTI3NWI5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGI1MzdjMDMtYWU3Yi00MTY4LWEzNzEtNjM0YmQ0NDcz\nYWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbvxS4I+l7gAiP5yfeCHa3X8N\nE0b5lHjfHwgNu7pXklY5F94EvDbqQ4y7SEUvmQYrQNzGWVKu1nMxbRBnzTFzcqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSRZthLxN61iHJ1v+XhDrUC++6u0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiB6KxpOvdOZICOST0a/4j4QByiSuTqf\nHuoN4CqnaNLYrgIhAOl2B06wiS+ZG/Pu/uNiWq/VyAVoqhocqo/kf8diTm5Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc92", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `92` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAYms847IJ0a1TtZIeuoEC/aWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4NWY4MjI3LWQ1NzYtNGZlOS1iNWU0LTE1MzY0MzU2ZGI3ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWVjODNlNzItMWE2\nMy00ODA3LTg1ZTQtZGJiZTdjYmViZGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiWT5hgkr/xYE3vF17wFUD/iak++qxWIOGmHGj+C1EqE3m8zEZQkAal/NysCY\n/+z+AyGlMY9X+0kDScRnfppj+KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV5iZzl2RRcgZ2tDxoViTSZ8irFMwHwYDVR0j\nBBgwFoAUAIXKtwWKo9tzXt/1MgBSiEQRP8QwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAzTqaiDg4/v1U\nqTC3UccNNx8MjrbM/vGpMP6owUK3vw0CIQDbReg/laVu0MroWVEj/sDpSodihhmy\nSyx6fH/uJXNeYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYBWvjJwt7J+BE7GF42zpAxCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODVmODIyNy1kNTc2LTRmZTktYjVlNC0xNTM2NDM1NmRiN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuz3cl1geJaaP1RcQ4KPbKAMRoEU7VDv6afJBtO1d/eCnu\n1fqn3Io7BEU+SkE4ETix4pVZaN7/xKGef+wLsK75o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAIXKtwWKo9tzXt/1MgBSiEQR\nP8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbMy26o+/QJa4bkFkMhdhIlVzAqMQNjEZXb9NMqy4g4sCIQCK7CvwhfOH\nYy++eb3Z/a/lBtpObbtLxbC9fB6DuPUdVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdCOnnJCLlcMm7CreMW9aJO/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWVjODNlNzItMWE2My00ODA3LTg1ZTQtZGJiZTdjYmViZGE1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmIwYTMyYjQtNTVhNy00ZDU2LWE0NjYtMDAzYTA5NDU1\nYzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErp2Y0DA6C3NpCdoAaQ9ERZKH\nYsjeZ/pgW0rdrpIJI5eK5mKHCMfjSBLSiQM9vFqbxKn/6V12UU74fT1m1R+7h6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV5iZzl2RRcgZ2tDxoViTSZ8irFMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAPUZFZcS9gIfDv13y0GbDAEEsaKXxR\n7eN3fnKL6NuShwIgWBu9HfjpgXVDot/B/IIcbLJ8mpsP87JwpEJMigzq5eM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc93", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `93` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAUpcgSPcml9NRytxrXOw7al/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjYzViNmNmLTIyMjgtNGE5ZC1hMGU0LWVjZWMwMWI2NTcwZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgwN2ZhNzUtMWIz\nZS00ZTY5LTlmNDQtM2E1ZWJiZTk0MjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELo5KS/7mcG08sakjfNowIBcJItJFq7BD0AYqd/NMCmlKjvnGD9AKNDNzA5fp\n0rIcq0+q8O6oFx295xWp0Ceq1KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmDcoH3vuLe0sfFiisaguxtVxikswHwYDVR0j\nBBgwFoAUi2NZUidVzdvojxnpEqEX5ia1qjwwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB3SyTemTMCfyWp\nvKOtE+jFY81j2DUl6It9ph1drwxj8QIhAK2CDvUtQlQ9SxsfFG/M3p8Bxz8oWI8i\njm0KQv7P0s2J\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUMUWZnGFdsX380cmmAwHWT2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2M1YjZjZi0yMjI4LTRhOWQtYTBlNC1lY2VjMDFiNjU3MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgLAN2tEFh9EJ2jmebhL8eOoxcetSQHYaMKzgN3BiE07dG\n4yd0ZI7QD0MAIV+KS59qjrZu2D9JmbQySc6EdIuyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi2NZUidVzdvojxnpEqEX5ia1\nqjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ8VpeQtJX9RDm4w9V0MXCTYJ9T8G8AWwSuUm32NhECcCIQCMbeBRSMaL\nUyCIWrvRmyx4KLE2gtF5eU7Yyq0Bf1xpjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAd4toz2rt3kR+YQDgy1oNcIPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgwN2ZhNzUtMWIzZS00ZTY5LTlmNDQtM2E1ZWJiZTk0MjY0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2FmNmJjNzQtMDI4Ni00YTBlLTkyZGYtY2YwYzU5Y2Ni\nZGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMdjWystI04Ve/mKhVIJo61Ws\nXQCl69END7VdnCNXJWT2FnHYFdR9G2eXczwmIEbIR2pQM8785AHykmWqjBKYs6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmDcoH3vuLe0sfFiisaguxtVxikswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAvEoPgnQz1U8o8myuGnFqDV4raJVx\nsYEzj4ZJqxBLA4wCIQDXMplA5JDwBURRqrJnmWPTNluUn35j6bt9pFpCsRnsMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc94", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `94` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISASN66tVfLUgRIaa0Y6S44WD+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MGZlMTE5LTE0YmItNDliZS1iOWMzLWIwNjc3YTkxNWYyMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdiZThjNDktMTk2\nNy00NWY1LWExZTMtZjQ0YzU2MDg5Yzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKmEH198lco6jvKmyQ36bJW92a0mj0/jEfzd4HWBF5qdfZTVSVpgxsFRVa7HL\nJ58xaUFgaIXNU5eTz2RC7p7zvaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMPWRgRwj5YmsXduQK1nPNR3l2CQwHwYDVR0j\nBBgwFoAUsb24mSlYNRUVJl38VFF97gBAI5owIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiB3Tq0Wdr5sCf8vAt7Vrr3S\njWpnmC22ZMnQYuln0wEhwgIhAN6TZDMA0aBXoALZyNRuc57szp1dzqQ7GR8LVAQh\n7Z1u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARgZT57lowXWcxgKs1YDDQyMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzBmZTExOS0xNGJiLTQ5YmUtYjljMy1iMDY3N2E5MTVmMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9m+GCOc5FFOW7r5i21JhCe5zI1QNfYsJHCooXd9xpIntm\nN7xTTvKbxdm76XDyUL+dhm43sTB7iiL4jtclpEKjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsb24mSlYNRUVJl38VFF97gBA\nI5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM5J9rN0KJa16/6qAMmJgETB43CR+mE9otiOLYXGwQX0CICNF7lHmNMGF\nwkGbZgJxDC42r8+fW8khjpOdFdANpC2E\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAY1piJiKubxJ5iMWKVxmMtLdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdiZThjNDktMTk2Ny00NWY1LWExZTMtZjQ0YzU2MDg5Yzc2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjY5YTIwZWUtYTViOS00MTFiLWEyMTgtMDgwNDdlMjVi\nYTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOPbp9wqao/Oq6mQxDnhiDz9k\n3ASqGYjdG2xHYZQV6VyyY+ALVeWJkwLAeB1e84ReKqZpf9avA8nglZEvJa8AIKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMPWRgRwj5YmsXduQK1nPNR3l2CQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEApN0EEy0yH45tdnS6F6+lXm8x/I7l\nCbQbXUROL5vRmxQCIQDaio8cQk/VdqeYkUBRW63W5u2tX3lrmsCrJoX3sO+WIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc95", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `95` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISARetPRrK4v8t4EaZhH62dHFNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NjE4NmRiLTkzM2MtNDczNi05NjYyLTA0OGQzYmQwNjk4NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU2ZDFhODEtOWVm\nMC00MGU5LWJlM2UtMThmODJiZTMyMDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmQJ6eD05/8tEVKs64GvnpzO96tQXzYTTXGt/X2ISRNdtow9jm0d45UlEuZLs\nyYbc/XCj8ZpK//tOTSxhCufQSqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXdGfAGOrF7NMeyMt4Mg3vmE+q6gwHwYDVR0j\nBBgwFoAUzHJaccIlI0hBnwc7/29FXd9dwD8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBTOfAg\nl4uLS2FnoziFK20TK2g2VJXltuPWjeP5TonAagIgO21EkYnMUKMmN0rmAnVoMOe2\nEhjG4LcmpSccgxgrS2A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAehyfLHEN03fP1dNt1V088/0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTYxODZkYi05MzNjLTQ3MzYtOTY2Mi0wNDhkM2JkMDY5ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATchsXmaT76a4UuWb7IMx57CW3aqWv/i1xqWCrzO8wzMsFp\n9xL4tP9NM9ghuFu7W9dTps2AzTCo63fhb7/Iy+e2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzHJaccIlI0hBnwc7/29FXd9d\nwD8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOACSyZ34Fn2eQbApBoKqojoYQjWF6A1y5C5e+7o2N3fAiAVGv5on8YQ\nWQ/CbzbYFn/1wSQm09yRZYDTQfNzWKuk8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAe5e0s2Hj0jak6LKW0g50a7uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU2ZDFhODEtOWVmMC00MGU5LWJlM2UtMThmODJiZTMyMDcwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWJjYTRhZmQtYmZiYi00MTI0LWFkMmQtOWRmMmUyOWJl\nZWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1QSoGZreEW03rjzWGmbZNwiS\n63e9bDqwkuPr493iZAUTpUpnfYFTFV4PNrir5J4IsHLjCF/ndYE9IiDzvWyBJaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXdGfAGOrF7NMeyMt4Mg3vmE+q6gwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAmUVmJwZ6LPCDUILIlFqOs+/G1ks7\nG1VN4Nk0InU30S4CIEmgx2EANCIr92wVVGvx3HaZVcig94EhPE2xqa1kkn46\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc96", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `96` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAYXUHj+AJ9XbPTsOySxPuJ6+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjMzQxZTYzLTI4NzMtNDg5Mi1hZTNiLTQ2MzI1N2UzZWNhYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY0N2ZhOGEtNGIy\nNi00OTg5LTlmODYtM2E2YWMyNmNmNzEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExma7Rbz1xkMXBKhERYSn/R+DIKH01+jzgFHPbnfargnb5uf7toJ8MsUYQP0r\nmhezPd2tda1+W03OqZvTsG0+VKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWT3NS6FufjHfQIs5F0hn/FxqJAQwHwYDVR0j\nBBgwFoAUQx2tTbKgCpVdCOL8MvCnRPajAnEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAsRb5\nJTObmf+WVl268RWrlwFhamkeuVzW6gOMWBVCypgCIENom/c6ZNmuSkLsZCdeM2wj\nV5wYRxRc1tvtxw3iWfjo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARGdwFylY4e8BUXttFt84WOtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzM0MWU2My0yODczLTQ4OTItYWUzYi00NjMyNTdlM2VjYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHFxt4Ss5ihqdgyFeR4xz/4a3JM3fqKzuXolciDU39Y1gT\njfIivJQ60ltqoYeSLveUMDnC7f7Dde9E4H/1BVzHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQx2tTbKgCpVdCOL8MvCnRPaj\nAnEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSenHnDwpqz9L2oJv2VBe0mYasGnoi6D9QfB9DrAT8e0CIQCDkpzrUEa/\nlLuHemWceIL05O0bVmYRfurC2BQEKGUw9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATi5oedckXr4hzRDD7imo/QsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY0N2ZhOGEtNGIyNi00OTg5LTlmODYtM2E2YWMyNmNmNzEwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmNiNDkyNGMtODExZi00OGM5LTg3NWQtZjUzMjQyNmM3\nYmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV594XAY9Gv+1W9yE5kL0CWBk\npJ1N1w/O6uz6252unJl2qlduZ6H8w5EXiZUyXayF1LnXBUgq7FTO7dzVmXU9l6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWT3NS6FufjHfQIs5F0hn/FxqJAQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB8WVXcGZAaenTOgX7kqLW5lKiKZJtL\n/bp58l4LzVveIAIgIiTxEXzlrwBzRgYudVg6xOs57j6zz1REXB/M0nM0xo0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc97", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `97` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAWrbNCIuI8NdflTxmN3oMQylMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViYzAxZTU4LTcxMjQtNGZjYS04NTg0LWQxOTQzYjdjYmQ4NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNiYzk3YzMtNzRm\nMy00ZjFmLWI1YjItOWM2MDFmZjQ0NDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGHU8oI2+aHCLsd6c3pE7Z67irEoMNiG4Xqp296/ZUS0AHcTWhWZovemvD7YQ\naErJMkmoj3hAz26nxSHmW6WuBqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLCWD4p1LpNM+E6rjt0mcvG0if/pMB8GA1UdIwQY\nMBaAFM1NZ/UZCDzAv6nWkNpPO00wmxX7MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAwS1D7/UdBQJy6k6iFxA1IXtzaQkL4Qso\n5wHVVZsmyi4CIQCSOs4fh5nBzobdz7dkHy2TBv5q04LAO9mEbrULt3y3wA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWcFhEr/VkDMe79Xl7wJj7NeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmMwMWU1OC03MTI0LTRmY2EtODU4NC1kMTk0M2I3Y2JkODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJY6r3FiE/H4MYOwYNAb6txHYjzcV9QbWxJHrcVDwH8nrp\noDlcE8Zr/tjZ00A4vABkWuXEBNueFX7lrn1elWV1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzU1n9RkIPMC/qdaQ2k87TTCb\nFfswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZLjH+fgQmda11o8tsbJ68Z7R2juq6CNdH71Edw43xYICIQCBgqQ0ps4H\nZKjE48FTKMGXgadKaTjGh8YfSxD0AyZRpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfn/gvsUiEyIjkyQ4namRwONMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNiYzk3YzMtNzRmMy00ZjFmLWI1YjItOWM2MDFmZjQ0NDVlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzAzODEyOTgtNDI1NS00MjdkLWI2NjgtYjg0NjAxY2Ex\nYjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGGgtHt8BICP0JuudvhJSXein\nwTo6gDqCR31BTcvjOOuni00Kr4gFeBAGQbmtamJyafjpk34ZL9OmsxGSBH/TYaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsJYPinUuk0z4TquO3SZy8bSJ/+kwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAuwi9VVkba4CCf1PhL7GpA1SdX2fC\nr2DGL5mJrG+9yakCIQCroFK6OR+YlmdVAJQ5vgFadUxPFZzPQ5XdA9ctybeDgA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc98", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `98` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAWJycScxWEcAhziasDOMKyAjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4NzM4ZDI1LWE0ZmEtNDdhNi04MmVmLTNjZmUzNmZlZTNmODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVhNzBjYzctNGFk\nYS00ZTM0LTg1ZWMtYTE0YjhmYzBjMTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYsOnudG1Y6IYu/aF6ihO+eSfzsvy9VUtcCg/6gDrJF/Xr0yK9n0r4bqO2upb\nf5tR+/HzqisytQnumvaUbi1AzaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDs2jgt66rwMwOdCDRx8vtDRaEAIwHwYDVR0j\nBBgwFoAUbQ731LEHjt4qyVYaOs+OXLJhC1swKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAO7Pz3shc4DH\nJzeMV8U8FkFfy8b3QuaupMez4C6NR84AAiEA6wratOEwpbOkGiL29G/QbDeO/Uqy\nhDg8TAnApkF3mkw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU251YPqLm+eb24FBw1tAteqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODczOGQyNS1hNGZhLTQ3YTYtODJlZi0zY2ZlMzZmZWUzZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/IrLdlEgQ8RyRG0nVvotsqDd7SiNmhH6S2Te3IUzYZu9r\nJ06kMz8mx/xzZAfHmdpcagS/dx7aWt17PiRJWfNmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbQ731LEHjt4qyVYaOs+OXLJh\nC1swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJtjvUM4JBlRIOteedbX8dTPnoRtZLxTrHXNapaYPqjoAiAG3G7/V6lJ\nS3rzo0uz5+hWJexHVt50e8JkkDXH+h20/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAeb0GFj7y9TZXjUidp9yfw3AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVhNzBjYzctNGFkYS00ZTM0LTg1ZWMtYTE0YjhmYzBjMTI1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWI1ODI5MWUtMTgwZC00NjIxLThjMTEtZjA2ZDVmYjli\nYzYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/lmFjhZHpUv4aGuBxHyARgdG\n+IPENgmWj2HPytRrVt0sk3sPgoj5AdggPGPkovaZ1jSz7pwM6Op5+1yIVAueKKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDs2jgt66rwMwOdCDRx8vtDRaEAIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBLHC7QCn/86NT1+2AUWonvj7r5mbwu\nlmUOGIy8KP6/KQIgGJ0k/C+A7i9mMgmVzyXNE7q3ASJ+aMP3Zcr8u7qRgAI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc99", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `99` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAYxrfeM4Cmf4UkL6R3q+y4RwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1MzJlZThmLTA3ZjEtNDE2NS04MDJkLTlkODVmYjM0ODRhNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ0YjEzYWQtMTc3\nNC00MmU0LWE3MzItNzQzNGExMTYzM2U2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw+MxoGT1oSBsxGEAK79stxrAP+Q1HJN4vpsnfSycdQF0onaCAJ8msgrGkxwT\n7zusNWuBSylnduPucj5dn6ZTwKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM/9pxt3TA4b/Oi1mwseJ+MowPo0wHwYDVR0j\nBBgwFoAUJ2Rp9JHO/G2BShDMMH7DviTLguswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAP3+yIR3fQlH\nACqdTboOmi8n2U80yvxB7Xpbwp6LA6RNAiEAjf+uecPRSd5ZKBo1IkxohxzXhpqc\nKBPlMrl2xaTlTWE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASGw4p2VUsDkdVDxDLdvRIYnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTMyZWU4Zi0wN2YxLTQxNjUtODAyZC05ZDg1ZmIzNDg0YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQE2pgJqTRzaaJ57Uz4t5mkITE91VjRZ/+1LTdNVyWCemhN\nDhsWzOmGRLSv28ghw2zDDOyP9LatdT5syIe74VT0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ2Rp9JHO/G2BShDMMH7DviTL\nguswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYOYcCWfl9tYLTvBZ2W+Nn0qsgNtIstBFfVqwsY9qROECICvc33fmIkAd\njMpIyJ+4QrjZ4SGznRYIlyThNw5lyaap\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfTutZbvqgEKh04ZhsvcW1aUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ0YjEzYWQtMTc3NC00MmU0LWE3MzItNzQzNGExMTYzM2U2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGZjNjcxZmItYzAyNy00ODcwLThiN2QtODBhOWQ3OTll\nNWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvCIsqV6OdtnEo3sawP+nIw1A\nyxoJrMPLT92nWc9bVcUkF7kGC5+S9qqjseI8RQRolTCHFjxJ25q1AaRaG+kAwqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUM/9pxt3TA4b/Oi1mwseJ+MowPo0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAqFNgaHSXXMOnH6R7UoGe/lDBbRON\nVPVpAGE3PkNsHQcCIQCRZss6vhm6FHizQA7Sj8PX08yHRF8Jk1SzZ3B0lTqI1A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc100", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `100` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbb8tbIrcwSo4oMmKc8x4LKbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMzZjMTZiLTk2NjEtNDhjNS1iMzY3LTRmODkzM2QyYzhiNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRiNTFmOTQtZDg0\nNy00MGIwLWJmNzAtZmZkNWY1NTJlOGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfVKewZ+6LYy/qIo44iJdz6PHb5pH60h9doQt2/B5vYoPjKDiB4pXQFRxsWiU\neEbRAH3F0sZaewWllZVq6sOWm6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5YtKHRb3/af5oVWzUzCQO4LxlSYwHwYDVR0j\nBBgwFoAUkfp55MGjotkhZiZ4T3bEFpMWk+MwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD4guS+KhfY\ncDP25zKBigwdExAlMPAbbPPEwUvvuWAL0AIgUB1OL7hZ9YolbI2rmFdn/a0WTFcc\nM8HTl+H1Kr2NVcQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARkZE/zO+rtDauHYAwbuOiDOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjM2YzE2Yi05NjYxLTQ4YzUtYjM2Ny00Zjg5MzNkMmM4YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwugVY/g4A2sdCsqo+xMySXV6NSTO8PveDxK67+j99dqbm\nsfhxHjXJcvIUMmYqrsxTohcD9CszhLFq+a0wYlAvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkfp55MGjotkhZiZ4T3bEFpMW\nk+MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKPUR2iZPN/6NJn4PGfNhyJqzlGwu3fJjfgwVB0nfn3+AiEArf1SYadJ\nOl703h/Uc+bPHFdmeFZfUtgajJjZ7DCx0HA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeW3N6dfCpZDiY4giqD2IzWZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRiNTFmOTQtZDg0Ny00MGIwLWJmNzAtZmZkNWY1NTJlOGZlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTYyZmU0MjQtNzVjMS00ZTI1LWE1ZjktNDE2YTk1NzU3\nZTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqfpnbbGRWoCK/QZyGufGVlyb\nbXoK7S/0QfKI7LfgTE/1kYhc9sS9tp+TIprUGAAUR2bXgbA350sfYPjQaZ6a+aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5YtKHRb3/af5oVWzUzCQO4LxlSYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAiH8+rbjmPH5XKXCIaICNuAs2B80rI\nWskKKAFmv4pebAIhAJ5F8Xt0urNk7q75ld6h+flHvG3YhsFQz4EbbEO35c3X\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc101", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `101` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAXUNCfWNRdWB6d8RyhPBBOo3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViMjQ1ZWQ4LTExMDgtNDY4Yy05MWQ2LTRlODk3OWI2NjJiZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUwNjdlYzQtN2Jm\nNi00ODcyLWExNDYtYmYyOTgxNWU3Zjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED/Qen/m6cwB0NVfflqI0SyEVX068hGN1dhowlnpXp9s5FvuC4nKg92Aqqd4C\nJoTSM5YS0TAqbEkNIPSgezcv/KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZpAXXieVY4xd7jZHM/Z6qReZ1zQwHwYDVR0j\nBBgwFoAU4UqE7Xncrjl7GELO2Z3QrR75qYwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGiiKsqxfqN1mMZntoDDBOd2QdQ6+e0MMuUHT+9QSKSxAiBLsEK1fSKeT1wt\nozBC3wcx+BigRalrZrI3EhS1KfyEWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb28OkUbseS9CUftQwgg+PLTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjI0NWVkOC0xMTA4LTQ2OGMtOTFkNi00ZTg5NzliNjYyYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdTMWkrKLGOtE+MDHghSzcu+b9NmwSBdtPjgC6hVCrz8TV\n7as218D1nFrM0CO4DpUpzUMetoeME55KsYMLPeWzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4UqE7Xncrjl7GELO2Z3QrR75\nqYwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPjUIMTsbozuwNfOCdr0cNcA9SnVpbvrDzprBIuHL4+5AiEA1nWEN4kA\nLZBJP2Gb/6O7qa1Nd+ABKj0RZ8ADHlJq6G4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXepb5kSW/KVIqyotUJi1IlVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUwNjdlYzQtN2JmNi00ODcyLWExNDYtYmYyOTgxNWU3Zjg1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2QzMTU0ZDYtYzNlOS00OWY0LThmMDctNTVjYTIzNWRm\nN2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE68yewv4HtOtqPD88bZasW+MS\n2bx9aLYZQi2txzLiVtTxzIB2RpH3oHljfpcfJaa37LYfDQEyHFA04fKx0Y2n+6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZpAXXieVY4xd7jZHM/Z6qReZ1zQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAPtTxHFeojv40ni1PKVp7Ddql8pukQ\nLmKjv7OxWpfiDAIhAPReHJ3GqiHbOORjTvNEjzEHvS241pMVZaWKU206yPKK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc102", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `102` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAQAb/+41CzAfNOvMDs9GZek/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiM2MwMTZiLWI4OTAtNDA4YS04NGM0LTgyZTA2NzBiOWI2NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNhNTNmMDctMTEy\nZS00OTExLWE2ZTEtMDg3MmY0ODc2MTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaOWTP8BLY4fRWikRPEMMvzhTne+l9X6Pbb9W3Wo9b8lIoTSI3oH0cqJrtZ+I\nTw6MBFhaQwoVe11GllBzArqRa6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYYHIItMEY/oBXDhndEb1hrH/33owHwYDVR0j\nBBgwFoAUl+94rvNi1gbev70yqFr5e1SC+/UwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCc899sheJGDYiGW/8oWOwwe7QGrNRKsiEXoiSndtGogAIhAN4j/eO1uw7B\nHKk5zLgVm6ogYhcIvyBvPnCmq1IVbNvL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS5jXPpwqipIFP3ASt+yR2g6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjNjMDE2Yi1iODkwLTQwOGEtODRjNC04MmUwNjcwYjliNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGTy2BWbXz5pu/L/5CqDUtvKsL3SLe3MRxIOSEL7jdRWMV\nVRXwUw3OkuikLfSnWWXIUJgig1MnfFucYVSxxb8Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+94rvNi1gbev70yqFr5e1SC\n+/UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANKE8d+/ejzdYgEm3kJwCrygVHHKVe6biEdYUk98Am8JAiEAz0z8bA6i\ncIfOosdr3ENbq22WpU/XiW0TPxBWV7EnSCA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdwUtnSK1mwA9Jq9qnVRRvfGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNhNTNmMDctMTEyZS00OTExLWE2ZTEtMDg3MmY0ODc2MTViMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTA1NjZlODItNjlkNi00OWFiLWIzY2MtOThhNDdjYzEw\nYjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPivHWXR9rtCt7UWbCokNAI+j\nGAhiU78oJuURCFHGNvoifACf5yB/I2kAV5FaTR4lUNf016Gx5SIWXTGkCi427KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYYHIItMEY/oBXDhndEb1hrH/33owDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAnJYVROr5n/buNX/Jf0r3alpvwGKc\n9bmjPkqMqkvncrACIHAcwrRckrLZ6W9uXdZZcJcC07JKuVNfZ4pJJJReKsPn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc103", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `103` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAWRHeiOJv40JFz5bbMHqWD+jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjY2U0ZTZmLTc1OTUtNDg1NC1hM2I5LTI2NzExNTk3NTA0MjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTgxZDU3M2ItYjU3\nMS00ZTg3LTk1ZmYtNGE3YTY5M2I4YzllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4IKjpoMxM1jEHa7RZibpYgxhtuJzBL10xzVFRt74pV2emFPs+ZB9SxLNYCf2\nEefXkR+P7AYVrJjoiEe0eay0F6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxnOk3lp7fi9NkDkfFfUw6reUnYwHwYDVR0j\nBBgwFoAUC4k5IYcy7GUlY/qJDsMJF0uyjIowLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD3\nuLuaVk1kgkHiDV77rmk+afEqeowYtbIovV2856Xb6wIgM/NAyfPo5kMFGyeABUdH\nNyRtMaipwQFEMlBJYvgVjqk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAThxWjT4FXMYmpRacI7E1HbJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2NlNGU2Zi03NTk1LTQ4NTQtYTNiOS0yNjcxMTU5NzUwNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCoKr7ldl3XBy+AS3MxpIuSopvz4khHT31FbY9oy48NDKy\nM8ImsF6K+optnaeOzk8loFAZnmt6kCBE89dw7ykXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC4k5IYcy7GUlY/qJDsMJF0uy\njIowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd92yI0PXHVtxlQqVNQqzHlEBtrROf35wjU//VzMd4LICIEkGuTG0dJwG\nUJEUeeOzQ9gWuBvWOyr9Y1AM5EWFPtBx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWcfrfM4r6++nEHmmWGOfQLvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTgxZDU3M2ItYjU3MS00ZTg3LTk1ZmYtNGE3YTY5M2I4YzllMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2EyYmI4OTMtZjQ5Yi00NmNlLWI4M2YtYTNkZTJkZTZh\nYmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm4DhoAyaJAuNw7Qq+UBYpkUx\nvWjMesqnm8wKOLGc1ponvQuSm3KODhVG+GKoD6Nr6lHh+xEmo1wMq4jwSt38L6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhxnOk3lp7fi9NkDkfFfUw6reUnYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA2eRz0MKdWuWj24aLE9i8fztONU2K\nZL3T9V3+yLyPGR8CIQCX+TjjOwd8EtkeEkEYTkgGCHGsvPpUhqB6Hv4r3a7Pqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc104", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `104` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUoZKXRpQKBbe3j6WUhmmwweMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzMzRkNWJkLTRlNDktNDU0Zi1iNDRjLWYyYTVjNzViZGQ4ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNhN2IxMzYtN2Jj\nYy00ODdhLWEyNzctYmE3MGFlZDM5ZjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFo6jGXfbm6kYXK3ZrAxb0FW61NWqtIikmGRbiufNbrVaYqc2ATK3qx2l4J32\nKOPGs2cFZ1qoGDgn8Z7XUe+8IKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU19uObx+16Q+Dj0zyNKPntkP/iakwHwYDVR0j\nBBgwFoAUkSfUL0BYu92cCvfALuXopbsGArswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDy3r0HBTAuF9rzh5DuPPoSJ0ZfpFHYY6piNOPssizsSwIhANvq\nOTZfJEuRy0oQbKHW8QafWR1Yc3PJkZe4zdlTTzI/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeJYwvf3SJt7MdiZPDn05WJ7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzM0ZDViZC00ZTQ5LTQ1NGYtYjQ0Yy1mMmE1Yzc1YmRkODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATR0YZY177U+KiE+avZxJA8bkR89IjcaQMwfYu9qPmKW0E0\n+35ncJCe/n4yWygp4GTQhxi1k7Hwloo22EfZIH+Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkSfUL0BYu92cCvfALuXopbsG\nArswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOVAqW15o/UGorN3Xs8/BExA4W2uDsfA0F8TQtNE7xmvAiAtiYxt2zYh\nXil1wL/c8+674gN7122xvfOhoZ9Q+G6Avg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASboZ3U8cZ65wzy46M6kpSCtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNhN2IxMzYtN2JjYy00ODdhLWEyNzctYmE3MGFlZDM5ZjQyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODc4MjdkN2YtZGRmOC00NzI4LWEzNGUtM2IzMzQ5OTc2\nN2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIDLuuUllaBdqQAcMyTX+Nn64\nRxWI+54lV68aDKI7qD7i3viRLvJTdRYcgBhpe2SzA+dbguchDW+FveMQppDa4KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU19uObx+16Q+Dj0zyNKPntkP/iakwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB5aZjj22RSy4rsDrYYtiCTvSGei5MW\nr/5uzUhQWFb63QIgf2Y9ZLYzQ6UTExpkomMpGG/1GOlexxr48zLt5m0FwE0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc105", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `105` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZwgIVKjxIAgijkw0kvDydLBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzZDA3YjEzLWIzMzEtNDVkNy1hNmMzLWY0M2Y3MTdlZDcwMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM3ZDBjOGYtYTg1\nMy00Y2IyLThlMDQtNmFlZmMyOThmOTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdPiD8GZUReQED/GMsL3yn1ml+GHLrNr21HBaBJa1me/FlQFYsbp0j0PNCcQO\nayBUfiu/xKMQvFt1aBaMLbkpTKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1z0VY11wGh8697DXN0vZnuy1ZnwwHwYDVR0j\nBBgwFoAUY/wNhG/urzUWzKKzNgtBb/ulut4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCtcGlmq9LJMsLK2p1pH3NErgNR5lw2OhW70W3hOqVg2AIgAhml\njJo3XIVz/A4w7bawFOXetNqfoBC2TevlW02BXG0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASl5piedJV65/tqhy5UlaEXTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2QwN2IxMy1iMzMxLTQ1ZDctYTZjMy1mNDNmNzE3ZWQ3MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASG+S7ZMONpsKxLyOleTTdJTcfOle9L75qZzrY6BrdLxkGP\nKlGNLMQ8HF1nJ+VJn25L206WdTVEgCHPvOEYUWzao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY/wNhG/urzUWzKKzNgtBb/ul\nut4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbldI06xeY3Y8i4l942K2rqgqEUATMWrjtzbfzEpzKFcCIQD9WEQX+odp\n6yaDS+gh3wzLx659+jSwaMeventz2T+PTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAX20cXwzJE0GqTwvc7LllpCPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM3ZDBjOGYtYTg1My00Y2IyLThlMDQtNmFlZmMyOThmOTQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzUwYjAxNTItN2FkYi00NjIzLWFhMzktMjk0OGJlYjYw\nYzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZJtafgDiBMukZcfdWgVfTLqh\njaIPbx6bJzd1nxpt1QF5F0buAHFD2TTFse8pnqqwxdx01/4ZhH8SaVkAoBiFTaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1z0VY11wGh8697DXN0vZnuy1ZnwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB0cQiwv/AnjxtNwzF/6yPdgQlWTdLF\nUWbx0k4FWivWOQIgQHYpyAxa88sAOVdEI00W/r+gfSyDKKkaqzvlRCeBI/k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc106", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `106` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAemW4/pjnM+/F9eF0DQgdv25MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkZDJmYmU1LWY5OWMtNDU1MS05MTJhLTBkMGY4ODQzN2QzODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVkM2QwOWYtMDY5\nYi00NGVlLWJlNTktZDc0ZTkzMDYzOWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgAVIuWDCKPgWfW3mdMqz3/C+Nj7P6X/holR7csdbX8lGV8q/8BZ1KKQNJ1VC\nYqThHjIG1fFIIfUhfNZQt0NSdqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFY6Cctq4mtzt4vSXeFk40ayIR6TMB8GA1UdIwQY\nMBaAFC/jfQy7rYmCEPn2dnNdRuYGwi8IMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAmN8ScbW12H14g4PeA/ohJ811g6xBDIil\nm3D3alEH53cCIQCaLFHKNWJrT9ZqVBSpLGo5VeCwRxWGAe5KWX7jR8MKnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfS8aSqp+a0ilnvSnhGG0lVTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGQyZmJlNS1mOTljLTQ1NTEtOTEyYS0wZDBmODg0MzdkMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVqcD3K7cnGTmMXXTkYvAvWPcYntjl7pTbQXwejAAWm0jq\n10sN9D8u7rwEVnCsUXhzgwX8XPBZrV9bXxtJ/n2no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL+N9DLutiYIQ+fZ2c11G5gbC\nLwgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKpHA9UY9ekQnOnvPGYbtRS0e6G1oTyySHWhrr55z6bGAiAPx6e1VVHb\nA2PFwpP+zvkEvxmnKHni5i0DhwUKHkGPNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdcLHNscY2fRRN0TxkaPApBUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVkM2QwOWYtMDY5Yi00NGVlLWJlNTktZDc0ZTkzMDYzOWFjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDA1Mzc1OGQtZTYzMC00NjdkLWI4MmQtOGMxMmM3OGY4\nMDMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0n5CO3cNXMCW+3gPgQ1iqt4E\nJoOUBGC/l/ALf+kdvCVaGTWAGlhO0yCHBpBuYPppahz3mDMCVTTqxUaK41aPC6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVjoJy2ria3O3i9Jd4WTjRrIhHpMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBDCUgfTq6df6sQAuqBTVQlu3QzNOxD\n+1US6GtA+S7+8QIhAIqlzW8Q+EsR3bIlWG/iTcD6sx+gBblKqxapoFPwMJde\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc107", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `107` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAYIRy8jK8qbD6PKCjEzfc/3AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MzcxYWY2LTA1Y2MtNDJkYi1hMTg5LWFkNGFhNGQyYjgyODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODkzOGQzZTUtMWM4\nZS00ZjUwLTg3YmMtZjY3ZmNhYzNkNzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWk86WYeYzjtItZwZrqU5A/YceNgYTVc1WpD4JMMe97TP1rVFVT5rvGlne7+Y\niLtxi7kybuzfCfVhoKYfcvxzz6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiU7CTsiSk7RbEjPe7TcA039pvTowHwYDVR0j\nBBgwFoAUPaQ5KBecbgEKyEw/bA2EkHEgAOUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgWDTq8Jp2Xf4X\nQvd1UKx79HtlygbMRcdWG4Njfn1hVGYCIBzxQCIpThn1Z7jUD8c5CoXyZKutfE6W\nb+4klCiHztz5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQOXco+hGO9B67BFYVvYnliCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODM3MWFmNi0wNWNjLTQyZGItYTE4OS1hZDRhYTRkMmI4MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1UgtHrD4tvKMMmcF8TZRacn8kXlK8w86iOzvUi9ZXSvUF\nPn7giDy5PHnfmrqgCc15g4g90F3MSamIqWedCbsto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPaQ5KBecbgEKyEw/bA2EkHEg\nAOUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfvETTbUWH6zf6e2XryzgzUp/uRppXMJJ+yKq6zEMGAoCIQDbhAJ8d62j\nikZ+aava9T+bkVyjU1gGVqoQMK7ZjreXFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdGNSH1BU32Ejepr9f0C3x20MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODkzOGQzZTUtMWM4ZS00ZjUwLTg3YmMtZjY3ZmNhYzNkNzJjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFmZTBmNWQtZDg1NC00ZjM4LTg2NDAtMGVjNThjMDNi\nN2IxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEq/gzbWyPCqesIEhMTwNvVEXv\nDL58YPka5xi5XYVKZF0jpG7g+aI80fODrAhXLnDLCmry9s1oyg6FBSJHBG0Ox6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiU7CTsiSk7RbEjPe7TcA039pvTowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBGEY35Feuwt6PpvcllOSE4yggQmYPp\nQvjNtj1D4qQHngIhAMFZMVLkcW+52ZTgt9Nwqg5qD99dbegLHfOYMl5bkJtW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc108", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `108` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWAJTPEfKjYyXq22VaNRJ4ujMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZjYyZjY4LTBmYzEtNDNmNS05NjBhLWIzMzg0ZTM2OTMxZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzExOTYxMTQtZTRm\nZS00N2QzLWEyMTEtMDFhYmQ4YjQ3YTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPyU6gEHpqQ4ZxNKMdx4Vvz8plBCXHsLnJu87lzZ1a296O7nHcQexL5nfsodI\nmUdzGsjY7ZdHztaOOqta3/Cyk6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNydUos8/UsjCYI98O17bFqI85mowHwYDVR0j\nBBgwFoAUgodunBjsDDslpmBgkDeLP78/zfkwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMKyZ/l8kBje\n5KukiVLW6ssRsuc6MDeUWZ6P54Bc9rVKAiB6pPyeh+FLkzTreZ7sGtYL/h8Z0zNf\n+r89TGnjnDErtg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASRHk8g8KcS35HYWQJqJ4V0wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2Y2MmY2OC0wZmMxLTQzZjUtOTYwYS1iMzM4NGUzNjkzMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdT1x5WlZWcUPc7pHglybr2/9+oUcmnwK0Pt2TqHIQsdAd\nqI9lK0LcFTfKpPefyNCsRuWCRuoSkqi6cx7NZ+1Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgodunBjsDDslpmBgkDeLP78/\nzfkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIW4X51E7N0VhxW41pcycuzvhqzeWcEO7K0vtnJkYRNFAiEAsbxuX/pY\nZPYNZ9hZN5jjeKuLsYTQ9vrShDmxbRgX5tI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARS8FJLGCcJJmKiY0l/ahyPtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzExOTYxMTQtZTRmZS00N2QzLWEyMTEtMDFhYmQ4YjQ3YTdjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmYzN2I3ZDAtODJiZS00OGMwLTk1ZmMtMmZiMWU3ZWQz\nN2NjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIQjI3pRQcHTNGUA7e37p5Nlz\nuYy1zTV3lcJ7Qz7h+MtvoM7CFgl7wy8eYJYj2cT0fILv3doTncKlc5t+I6A53aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNydUos8/UsjCYI98O17bFqI85mowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA6lzKJ7qAlAAHyjVk1/5ojLYe8nQo\nFy5Wk/IJaMoOwkACIQCZtEfRwL0QXdcXjWoM/YImn3olZuA9c/AvNW2AfKBCJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc109", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `109` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISARUyT4UJ2r6SbqUCyJkWkX6NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzZjMxMmU3LTFlNjItNDhjYi05NWNiLWI1ZmJkOWYxMzM4MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDg0NDg5NTMtNGEx\nOS00MTA1LTg4NmUtY2Q0YWYyMzYzZmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj+EVF4roopuAVoikE0De5DdIKMxHekPiZUEN4rSYkhj9DrKoR+emUcBwdvsa\nVreGW68kiWyO4GuGQnvQBlxhLqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg7vq0OqqXkuu9c6uhqLn6/X5jLowHwYDVR0j\nBBgwFoAUWidUwO0C5UIBkmsG7PxZKTYUEQowKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICz7nTyCAj0a\nZoGxPip+VppGygD1MjpvUy49f6eyIdcRAiBUCdsqC1VRhZWJRqaKmPTS3bBeh7hU\nKJ19D3DoVf7FCw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcun4a0nLBlJfq6WV3VU6PF3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2YzMTJlNy0xZTYyLTQ4Y2ItOTVjYi1iNWZiZDlmMTMzODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNRnJhvABoZRHAzOHr/uupeLW6FRphWnIwPllTMbqyG6Rk\n/kvyVRRMEP2SLcs21iA7jtqfajmWkWBdeD78bm2do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWidUwO0C5UIBkmsG7PxZKTYU\nEQowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXeKvmWDnHsnHExtTNd9zRukwytMaAg5pqSyEMtZ15b4CIHzY2WRWWbpF\n9ZzjtIdccxkUjuJVCQPmTtxsUWXKcjmR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARCS7SsaH3J2z+WK9K5dzuLYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDg0NDg5NTMtNGExOS00MTA1LTg4NmUtY2Q0YWYyMzYzZmRlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmUzNjhiZWYtOWQ0NS00ZTdlLTkxMGMtN2Q3ZmVjNzE2\nMWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj17FDksrqDQOOPpnGijij1Uc\nn4wJjmbpbXAXNvjUdDHtV3lADCK0wxIpsmY4orC+zHFtBn+OtQIl/q2i+eFweaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUg7vq0OqqXkuu9c6uhqLn6/X5jLowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA8xICDw6Qp2drrrePkPkHnz1hYoeL\n3BmvMQ/zKqEkxSMCIGI0A28YLXbcGoWwNTQgYGa3Ps0EC7NwqqFTAOQG5Dp1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc110", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `110` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbUGztGruJFvzH0Ub37WWhAkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5ZTdjY2NhLTc4MTEtNGM3Mi05NzJmLWYwY2U5MGQzYjE0NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjgzNzcwZmMtNDQ5\nYS00ODU1LWE2NWItYzRkMjViOTA0NWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB9/NGXmIEBTjVyEalFVe9MkojbSPjZ96WEyIvwo8fWNEA1GfEdnlDa3tQekF\nXP3sF2IiMBYLuJKj4Tt8fwiqfqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU42pXaT9HXv6wchkL6y+vLIXGdL8wHwYDVR0j\nBBgwFoAUhMOh0xGBKZSvIs3x3weUvwGxj7cwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDu7EGKTImYol1oKvvXcTlGVHa+GuCmtNWNDClctF2rYAiArnVUcIdypvp4Q\nXfj9dWpc0C8RHGRERXNwd6MwY+c+jA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ9oDKzv669aW6xmutG5ywkLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOWU3Y2NjYS03ODExLTRjNzItOTcyZi1mMGNlOTBkM2IxNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASF9emRDicrgTbQN2mIPUXgP796QOMqPHKETHjM0ka60N6t\nHFNwxAoF5BYHVqcE1TQwAIwLdDAz14rsHk+4PBveo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhMOh0xGBKZSvIs3x3weUvwGx\nj7cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdWa6q17FSKBwdeN0hgr0y3US//2fBg5hgD9t36nfEnMCIQDArq03EpAY\nVcNmxj7XwJK+3J4Iz4xZwNPFlTbn1jOWaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdsgq2dkQBwUxCs8Er3TkBlUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjgzNzcwZmMtNDQ5YS00ODU1LWE2NWItYzRkMjViOTA0NWRjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmRjZWJlY2MtMjlmZi00MmUwLWJlZTgtMjc4MDQzZWVi\nMzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOmrSvUa0ytlWMSk+Wf++rPTO\nO167O2IDey+P26oCmPI6FKuDKpx8E9Hx8oMG88W5SenIB3Fz7AgoYTv0zrc8VqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU42pXaT9HXv6wchkL6y+vLIXGdL8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAkfd1IgSoYnoqqhPPr0N1twgdZpxA\nfUcH+mR6Iri3dHACIQCTLg0/tj/kbuKbJUUSWg/RxWCK72yfPIVS5hmhZAb2pw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc111", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `111` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcvkejrNRzkW5zVgQ0PZP+HcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMTcyZmJhLWViYzYtNDA3Ni1iNWRjLWEzYjkwMjczYTYyZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdjN2FiZjItNjg3\nZS00NGZjLWI1YmQtMzhhOWRmOTY5ZGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsvXZVXfU02YUszelzhwrmfxNtfU9us6aidVefsJK3XFnKa68BqAvZnLGROmL\nfc/nbryIwTWWOalNAzW7UaAO76OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCoHmE/s1BWIG74AFWxITRXtdvaowHwYDVR0j\nBBgwFoAUVtDV8Zkk08XKErD2e/ZgJVianrMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDypuUKuCGQdtrLcLDCObjqUvzmFNt+7w6y3cMCl6Mz3gIhANr9pLISQZ6J\nwQx3UzvlEpys2oaIIVC76WDUcgB0bMSy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZVR58z2Eg4agHy/WhX6KrI0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDE3MmZiYS1lYmM2LTQwNzYtYjVkYy1hM2I5MDI3M2E2MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATezWCPVN8c+KYys3gPR11+XkNjG5GgY6QTwM89gEJ50E+h\ng4n6NOp6aFaeaq9sHQcXq0aq+1LAcj5Y3tXfI3BIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVtDV8Zkk08XKErD2e/ZgJVia\nnrMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWfRe5GMPrNaHaXHALzgJXLI8QIBDt7ebhzp9GNUFXHwCIQDJL01qAeHx\nmla15c5/pbUc/iBmyLkXNZNkLC7V24bvbQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAb6jiEDEX6+t/FJhKLksrHCOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdjN2FiZjItNjg3ZS00NGZjLWI1YmQtMzhhOWRmOTY5ZGQ2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmIzYWQ0ZGMtNDNhYy00MjEwLWFlMmMtYWRmZTdhMjc1\nOTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhpSVGaj76rO4DSeyRXOHZMvp\nBmkiJefpSLOy+6WNCnDb+/sIFsVpn+b2WWdPemoGbR7WKr1+hcKNVPt3NcIQmqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCoHmE/s1BWIG74AFWxITRXtdvaowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA2qbN5Qg6StO/t6vITFwhv1yYyg6p\nmDYDyb6qAp4WsJACIH8MHYsG/pjH5oP4WihI/s0o4rqHFI+7ToPJ5X5vZa4T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc112", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `112` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISARSUOh3DS8N6s7LNTbjDfZhgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMzhlOWNiLTBkYjgtNDllYy1iMDc2LTIxZGY2MDQ1NjkzNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM1ZWE0OTgtMWJm\nYS00ZTFmLWJhMTctNzM4ZDhjMmNhZjU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnk2gPRuyhnFy31kCjzrjWVhYv+WpO572/WteG6CAMItyt9vM0NMiRqYHZP55\nudPGbYyNZBqZ0TyQsNQIk8TDhKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkgRU+z/C4be87ztPjy2TmeZngQ0wHwYDVR0j\nBBgwFoAUxr0wjIzo4ZFC5MXnNPRLVxh8L4swLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCu\nvuF43c4uT0BImApYdwdTGywDDuxqJf2xqnQoEXRkIQIgWSXpjNE6H3siT2sQaktz\niOJ/DpUHE0l8Uh8vstypqv0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAct64ywJr1wR07b7yYQ3mAuMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjM4ZTljYi0wZGI4LTQ5ZWMtYjA3Ni0yMWRmNjA0NTY5MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvGOoPd9HBCJM5hYqcXarqfEHP6Nm7EZlYUPltmhtP3RwY\nbQf1MFqpqcQlD34vnUlGy5iio+xPkG0zGE187Yz/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxr0wjIzo4ZFC5MXnNPRLVxh8\nL4swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXS7vSXHco2gA3XnMCcrnh08oRu6ofONPu1bdfPTicPECIQDHvWs/gRMq\n26fNnUsw2LoFi8e7lpRY3hFKCu3px+xSvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdbiy0UOpbD/NDAeIDXor0acMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM1ZWE0OTgtMWJmYS00ZTFmLWJhMTctNzM4ZDhjMmNhZjU2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjM0OGQ2ZWMtOGY1Mi00ZWU3LTljOTktM2NjYjhiNWI5\nZDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWA2/vGz30bqnilhFPmIFgbfC\njChTL0rG5YZlU9Z4PTFKuAFOBxaG5yw+weNbiwlaPIzAlPj4uQ2zUnvzx0EB3KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkgRU+z/C4be87ztPjy2TmeZngQ0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiALd0UBNtSlZKYMTeQOVsoWGr7CFYyV\nmxdrcP4UCQclFAIhAKOY0BlJS7bRytZgJMhnMV/4EjCxDnz+Feu8AE4Mob6z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc113", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `113` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQiQ2T9wQJy93+E+ZQxWezKyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzZWIyNmU3LWMwNTEtNDQzNy04ZWMwLTViM2E4OGYwNzQ5MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAxNzQzNDAtZjc2\nYS00YTQxLTk1YjEtOGE3NWI4ZmMwZjcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL4XlN/q/hTW+O0V7iDRgk65zSzMdXG/hPGFt3vys8eJbPiqVFcl8xG8l983E\nooc41yMcX9H3O9QNSdIfLSh4PKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqftVBUsZ21A+KrkpM4swWSA68G0wHwYDVR0j\nBBgwFoAUst+rR8bqfx7C8F0RTsT0iL9kb8owOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBAuO6ZI73mI2rGjhHKvab9wh0BZiS6To5R6FChfrVxCAiEAsScp\nbSzalfzeDvl2+hPYAm4Vcv2HhORH6Tq4nH7WKRA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfB7mMYkT+bcVzBOor7RfXM0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2ViMjZlNy1jMDUxLTQ0MzctOGVjMC01YjNhODhmMDc0OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDux4cjAx7k6jfJE4cCrjsz6WLt/OJZ+IDHnr1If7DViv/\nlm8Z/Rci5gVL1jr++62D/Uv+/1prEz22eZv61+U+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUst+rR8bqfx7C8F0RTsT0iL9k\nb8owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKf2HZ8KBdEptS05TaC2B60wE5TefQGXiKkiuSVSHBTWAiEAudaSR8OQ\nnOAVkcadtgVj9ntqMmDQS6vJbMajElgIYrY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfsqZ2unFhTFzC1lHesj0bWGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAxNzQzNDAtZjc2YS00YTQxLTk1YjEtOGE3NWI4ZmMwZjcxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWI4OTQ5NjYtNmVjNS00MjYzLThlNTgtN2E0MjNmZGZi\nZTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1chfCbsdkiYnIjnkHvl8S+7v\ncETgo8YnlJij/5T16DvY83ay/efaIhfOEtUP2zs4Sqq4tkQQG0KdIeqQI1qx16Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqftVBUsZ21A+KrkpM4swWSA68G0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAtI5ZApL8y8rW36W4b5cYPjMMwshZ\nAu82OsS1bYiHP5oCIQCmRITvZFGg88PUyLPrGQIFia67rIsdO8pJjSBV4PU4bA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc114", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `114` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAQFr6uoKle8SOgx7Er9iWBavMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNTEwNzIzLTQ0YTAtNGI1MS1hMjQ3LWViZmMxZTI4Zjc1ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJjNWNhMTEtNzQ3\nOS00OTdjLWIxNzktMGQyMDRkYmVmMjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg7L4/khg1knRGB1XDNB9HEsZ3GQnZhy56oR/AT3qPu4i/44XjnkF6XU+frBI\nSq3To7yS1rsPtq++gctGyrvBoqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx0hYDRjozNjNgwjbzVONXkIctYMwHwYDVR0j\nBBgwFoAUQ1WhqhNH56L/L1K863L/gUltep0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIA+gbiBXOrScjIlIWnBVL2gsTT4tPIfv7iPMwLxki0kCAiBBJ257\n0y9wpEG9eU9VbVxLlGmkdelLXUZVgjOwdR67QQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcGTEsAOIdgab9ljdskEzFYqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDUxMDcyMy00NGEwLTRiNTEtYTI0Ny1lYmZjMWUyOGY3NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBxtajZT8hGzD/rGbqdMmmnclVcvF87167eAU5/33bDUuq\np5Rgb/LTy9SB5/CGglcE0kdcovuM7qQI5p2+aXKyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ1WhqhNH56L/L1K863L/gUlt\nep0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSFAz49kTW3q97Z/77zxqx4I3Xw+XfD4cvQjxtMRfODgCIEstFa+vziYG\nO0klDh0KW0eLKCnFmlLtcU56kJFoWcPW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXRjzHEfyGS1Sj9Gmol9nWRjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJjNWNhMTEtNzQ3OS00OTdjLWIxNzktMGQyMDRkYmVmMjlkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTMwNmMzOTMtYzZhNi00MDk3LWFlODgtNGM2NTVlZDAw\nOWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN5lKH4QD8rCIi1hoAxwG02sG\nPd2+wRqUW9OdHKneliFgqX7eSdNdzBAUkbNLgYKLz/myqKmxoumpRcwL6FWEKqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUx0hYDRjozNjNgwjbzVONXkIctYMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB19G90uukSDHtTeq9O6VWsowcvtE9Z\nT47ADLULP/SU+gIgI5vVfJkPodLpQZ0ODqpJIW7GkzyxjieFDvGBSyNUSZ8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc115", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `115` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYNEfltO6i6PRIKHXjxdMk4xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NWJlYjdmLTM4NTQtNDA1OS1hNTkwLTA3NTg5MGJlNDFmYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2VjZjRhODQtYzVi\nNi00ZTg0LTg1OGUtMjE2MDRmNmE3N2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0YErjmsA0LYODR3XEYNjlV+j4aLk7Jun773tDZEvT1KIbP4e2U4/MK24Iwxv\nPK0CL7OlRPCc6QLd2tI/GKTChqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSQu90e4RUfR70g7GJ/HIMGGCSoCTAfBgNVHSME\nGDAWgBSCuHtcZL6JyBZZkR5Yto0UmLfwtjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIE2+KjwZKhSwD7u/FdMOeQLJIIAGybKs\nkXxA4HJROD98AiAhZHt5aXfMFUy3uDQCFUX5QXa9mf72Ht77/WTrQMaj7Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbOHT+Oy+wm+6GAD8aGJ9ziDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODViZWI3Zi0zODU0LTQwNTktYTU5MC0wNzU4OTBiZTQxZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6WdCT8njNgu0NuPrmoWEyWGukatGfPl009sg2ENQ921CO\nLsP7nzWpizdkh1zS07i+xuZCFWu5Axp4Y6HQT3ovo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgrh7XGS+icgWWZEeWLaNFJi3\n8LYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPNE37c+rLvpbJKXvsCAlHtMloFZbU1QuEwrqxfs3u3yAiEA/reZgmoF\n3WLHxRrAKGEGJbtIT2TSUO627ud0Ph6//dA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAasMCLqYy4GBHGlzwLbFZ2b7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2VjZjRhODQtYzViNi00ZTg0LTg1OGUtMjE2MDRmNmE3N2MxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzUyMDQ4M2QtOGZhYS00NjEyLWFlZWYtNTQyN2EwMjQz\nOGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjmzZ4uyl5QVXzRhkMEaLVMlb\nNAUikIi6kYMGrm7oVeA6fkqmcDlKb/TgDFSO565X0keH95NfwLLf8JzmHG/OpKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkLvdHuEVH0e9IOxifxyDBhgkqAkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAR7ryI5cLYBK1YAJG2nLMRPXEJnOVJ\nn5cR5ABjG1v2RwIhAKrvmSwgghZkQL5/ig9oDD9Kn5Rs6UzoAAPnDDw2D2lN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc116", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `116` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAaqbwQgff2hazIJmWrGvj28sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5NjNkNWJjLWRlY2UtNGQ3YS1hZTNiLTIyY2UyNmIyZTNlMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc4NmY5NWMtOTVm\nZS00NzFhLWI1Y2UtMGU4MzMyNjEzNTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMBbsLwfDMVkk0a+WA0K9ksSluV6Di7KFBhoxTZOhOvV8u96SDfg00A2247T7\nxZTxAy/Q5EdordnK6cjmUr11NaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPo8nAjWI1s2jGizbNfiU/S9OPqwwHwYDVR0j\nBBgwFoAU7ZOIdZG1pFKiFFkc5/kWe+xeh+8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCH3tjj3I2n\nopLaa1eRTGESYFcoCeoKFSfsbMqvQr2YlgIhAPjPAyuO72qa1bFhBvDqhvKsmvPR\nIgczVvXNgcYIXiz2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeSUXdr+vtqwndxRYgymgxQlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTYzZDViYy1kZWNlLTRkN2EtYWUzYi0yMmNlMjZiMmUzZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATs+66KEiUg+u9kl0SJGsfmiyJrpYh/AxAZxyJWX8fX0yIq\nFIAjHzLLh2eUqR3M9kp7gKaXm5p22Jt4Pn6fnQPQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ZOIdZG1pFKiFFkc5/kWe+xe\nh+8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPZFwchBA7zAsn80kX4kZJcAN0JD6dvQ7wAF89WaWRJ1AiEAiKaIag1S\n5qu+XH4vjQ+q8HtxH2HThfWWAZFEYPoq6G4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaS1yQksgdu7ZKkpPTTdSBYCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc4NmY5NWMtOTVmZS00NzFhLWI1Y2UtMGU4MzMyNjEzNTljMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjIxZWVjODktZTEyZi00NDE4LTg3NWEtMjAyMTk0MDI1\nMjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEdL5Mx7nycZYsbw9fQCAKYiT\nUJj0muPxch+Y5z2/C/pEKqATLhuIxiMK7F7GHeA+6DT8nTizBkInoTz10+vZ0KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPo8nAjWI1s2jGizbNfiU/S9OPqwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAarOUKzFJ2dvn8oBSn/Wgvfr6Bsxu4\nWZkYi2S7rfjuBQIhAO91ulzC3Y1KYzO2B+rPKt4Bvpd//r2sePGPBq9lry41\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc117", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `117` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATv2NQ9OY6bPjo9wIpDHkRMmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViMzBkNWNlLWM3MmQtNGNmZC05MDA3LTY1NDlmOTQ3YzdkNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTMzZTZkNGQtOTNl\nZS00ZjYxLWIwOGMtNzNlN2M4YjQxNTA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7N07w6oV92DhQWRZKyxNVxOevQFPlYL10rWes8TRGxlkr4Fu5wPxtS0awHs9\n56HT6KTnbUZBVzjUEmrLBqDdwaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7KO78t0VI/dbj/mj3XjC4Re27xYwHwYDVR0j\nBBgwFoAUqcCgiwYhzpOgSjKmrT4brX9s30QwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIE0B1XRQS2vb\nGWTum3qrOBekzZLjYq2U18sZCqsUJWCZAiEAumUtpLD16wDQ7pdm7YxaRpioigqF\nxOWwtP4s1qMHg5Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARlwufWr0DIBmMPNwh45mCscMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjMwZDVjZS1jNzJkLTRjZmQtOTAwNy02NTQ5Zjk0N2M3ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxpz+H3RWrVUwb4oael0s+3D3P64IGgRkYc+Rr2557bRUo\n9tCWBV6GoyKM6v9FxVyAreyWlyM90fgq++4tbGuTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqcCgiwYhzpOgSjKmrT4brX9s\n30QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZIfzYOOOOmyFDPAWSdeF0y1tst2NR4S9Zz58MC6FvCkCIBxUyRpj5rRn\naYTxqy8NhjrFtFgozcFOQ/koVBvLCqw4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbMHcMn5KfZlNy4vPoVXshsIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTMzZTZkNGQtOTNlZS00ZjYxLWIwOGMtNzNlN2M4YjQxNTA4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWJmMzgxMzctMzE5OS00NmJhLTk3ZGQtYjUyZjRkZWQ4\nNTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElV4fJt12jHT8MnkAfpJX+x07\nLU8DCdhumHUNS3MNbx38WbzspQqm4lWMKOpPEkwzBDVkZjbPps0BDd8n4AMUs6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7KO78t0VI/dbj/mj3XjC4Re27xYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAop80nfXyjEKj/8QEzdrn1yaQQYEO\nOJqr69pZVHawmk0CIQDpVmLCcYyDcRKVJU8NDy0DbDvmUbygAsVILsxMzDWxww==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc118", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `118` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAR6tiwmea2+Dckiwcz1x8wzmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMzMyMTA1LTUwYzktNDdiMi1iYzcxLWYzZmRlOTQ4MGQ2NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGMwMDFlMzgtMTE0\nYS00ZTI0LWEwNjEtOTUxMWJhNDY2MWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbjKFzNLgjrVPbbPYO53DrZIcNoVjdW99bMb8NlGGIlp97Yuz7QAl3dCU44WV\nKvI1pa9x12VAG8+ZlvnwbNyH9aOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBMI5izVLICg0aBOmlfvN7GmF95QwHwYDVR0j\nBBgwFoAUph/hQ+/xw342vr6gS9qjOamUcuMwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBwWhzuCv6W\nff/Wxiw3cRywphZT89X5lKw3C+yWIhGFMgIgEaqgUyR3Bl2EbVVsOoIZXsdeTtzJ\n4wJnBrU4cbvwCQ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWR9Bx4iWnl3Uox+XhC11COMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzMzMjEwNS01MGM5LTQ3YjItYmM3MS1mM2ZkZTk0ODBkNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQArtT9LC4QZF1LSb4gLBgjxKVxeaiIADJWC2g0TRtxEdjU\nmU9yeQjbBGnbcbHivK/d6ORLqKG3RSPz6kqLUJZBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUph/hQ+/xw342vr6gS9qjOamU\ncuMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM7KUc2QF3g73yQrMsO0ovrrAeecQv6RgyRrS+iQP07qAiEA2OmCJJNY\nFJqLaPD5rspshAOaTBzPP8E2w28sWveLmOw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAd81tISxayhII9KCvrko/4AtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGMwMDFlMzgtMTE0YS00ZTI0LWEwNjEtOTUxMWJhNDY2MWFhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGU2ZDVjZjUtOTkwZS00Y2M1LTk1ZTEtZjExODc4ZGJm\nNGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETJLw4CA12atl9eb3OEHv8l4F\nf/pbszu9fem1KfGHCFanLfF1SsDYWtWvAt0yfbnPWpGhaKch+XmHbxFkpT639qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBMI5izVLICg0aBOmlfvN7GmF95QwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAlQ3kR9JLUBFeIPhp8/nqyANTBCQP\nftYunCzCXvIafckCIQCXH1bLGt1fg8+ykzSEE6TpThm7Iu+fpDb2vwPvpgchvg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc119", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `119` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVLdZBXCCWSsQaXhDFvHUkcfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhYjI0YjMxLWQ5ZDYtNGIzOS1hY2VhLTc3MzY5ZGM0M2I4NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ5NzIzMzUtMDIx\nZC00YThhLThmMDYtZDZkNWI2YmIxZjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOR2RWz46GlJWPkmeREOcqK+d+xe6k1WTYo+fuf6v87lNmo9fRlQH2b9dB/JQ\nVFbgky79Dn9nO6dTBnLOIlwbG6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIb1DnMDxHRckx7l4tsqoNSbsP7owHwYDVR0j\nBBgwFoAUdZPxjbfjGzr+Iw7OdD2rIbqYiTwwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiAySgSveoPfQ9Qq6G/KbJSofbdffMDQs2LYIvqIw+tcvgIhAO6wRpq6F+8S\njyHMaxkZsQOUqYLDkXewFP3aqdKgVUIS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS36lpcrq67B0f6aSSjrik73MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWIyNGIzMS1kOWQ2LTRiMzktYWNlYS03NzM2OWRjNDNiODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNwv5bjsvtU9ZLZgtpcAm7dasJGVzlBnJNWrEwI0XhNsZz\nmVMOSYzREOQfecHL9NYY+MKuc3bDsiUogCQopUcmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdZPxjbfjGzr+Iw7OdD2rIbqY\niTwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJQ1Y7z7IFwkqjdm5bod1778zwHdrPlxbKj77j+yA8aoCIQCnfWDa/j+5\nXYOZbUZbNxNBUs/WXghLqMt+s6hbT7DzBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAakl7nYJz2lKsRLLwmDyI5cpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ5NzIzMzUtMDIxZC00YThhLThmMDYtZDZkNWI2YmIxZjg1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjMwMGRiYmMtYzZhZi00YzYxLWEyZDAtYzRmYTkyZTk0\nNjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIgB1I+VW3ykmR7uNLCafBd7h\nKIV1sF159F5lykSOLSO5/+L748GWJinltoilG7XAmSyjb+Xnfl4vKbrKy5NT16Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIb1DnMDxHRckx7l4tsqoNSbsP7owDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAVfeLbfhZw04PvOIEkq4GkQ0blpV3h\nyXcYH9t876v5awIgPGuQT7/6+v0EQGMW9GIXVIcMLy/hoYasP2eKiw+BAfc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc120", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `120` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAWE2+sO220sgYCiiMoYSpELQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1M2M3MWJlLWE5MzAtNDgyNy04MGFhLTg1NWQwY2JiNjM3ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzcxNzcwNTgtNWI3\nZS00Njc1LTg4MDctZjIwNWQ2ODQ5MTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0L0RC8/Z8ykmX5uIXdAYIgl+46bfBOQ5XH2MUFY0HCioMEHd2vbfc5IgoLHk\nCW5O//X0o4IBwQSRlmazaQsanKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNU4Pw89CNzyjYVZcBtaThWfrmmkwHwYDVR0j\nBBgwFoAUwoOLnKF/4PCPnLTILYmt8jRF5QMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiBatiTLGNBs9XPB6F3qWs4JLENxFQCP4c/xKBj9aJr4uQIgQxI4E7Z8Kq0R\nwh9GTdw+fZ9s/cs4Wxt3tjcCFujLUJ8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcO6LCibslN+BxTQtVRYEVU2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTNjNzFiZS1hOTMwLTQ4MjctODBhYS04NTVkMGNiYjYzNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbqpZErt6cuC3WUdXsM7ViYx4qn0zAA7EGLZq2rk2KrDxK\nSMdoRgRsQgljU4g0ZNIliOArD9tYv/PWVR7YQ9WRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwoOLnKF/4PCPnLTILYmt8jRF\n5QMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTn7F509Qm9IK0qjNLeR4gNEibcwO/EtUqiZqnc/RJzkCIAuz06CQOu8s\nEA66GTZa2mec/3cobALKXfIP+BLfJDea\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWNOvgp5ogiDfWIgK2xVnA5zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzcxNzcwNTgtNWI3ZS00Njc1LTg4MDctZjIwNWQ2ODQ5MTRkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTIzMjNjNzktOWUxMy00OGNmLWFlMjItNjEzNjFhYmE0\nOWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFZOl8VY/qOO5IACdKeXUbDbp\nLQKfNneP10VHezlPdmHFtFgpvC+omS0NCj4AMMwf/fVd1oiJzhZYSbF5DY0dqKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNU4Pw89CNzyjYVZcBtaThWfrmmkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBBiVzKSSRUlrzON6Dg5xmcQjW58TH7\nSuZKAfYMDgzsPQIhANJJR9FqajEbknvXonCYo6rk1+F4JcSNQWcb4ZVGEbug\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc121", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `121` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAcLQZXciswnp80OgzZhOL+D4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkYTQ2MmM5LTEwMGUtNDYwZi1iOTIyLTM1MmQyN2U4OGI1MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY3NTM5MjUtMjFh\nMi00M2IyLTg3MGQtYWNhZGQ1NWU4YzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkREIAn6s+x+ZjqUlXwxRYJFO4qGAiHQ7Vx4kUS9MgsFcxmVFnuMGxQWB4Hu3\nX/AfP7mF4PZqYXt4bkC+CZLAU6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP2cAeIiG/aGJtsBQb+cbAUoqtpYwHwYDVR0j\nBBgwFoAUsj/KqEgFbC0ArJy1VmYY4pKFg5AwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAn\nY8V9iCDFb+WA2/VTI+kcGRLSQkn8/11Qmi2Vi+SfKwIhAM16F1Laj18uWbLJjHZA\nZ2HSGZiNzINuImCsSzg7oTGf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXVrAVc2Lb41bAL5urm5UMyGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZGE0NjJjOS0xMDBlLTQ2MGYtYjkyMi0zNTJkMjdlODhiNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6nyfdPYttoq2Jrcmpe9suLx3/WYvkpC0PMkgGYFzoqWUz\n6OZmg67q2fWCj3mA6yOcWQjyvF1med4MFS9xMCGao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsj/KqEgFbC0ArJy1VmYY4pKF\ng5AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIn8eguj7GDicIVQiPkJa/v9qTA9epWf64JMlmDu4ryoCIQDNI0GqJ+cY\nqx5b5+VK5qmsmVj4oQrLLFLQ5m0SxDAdSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcaiiM620xCpjaXt+ulq3A40MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY3NTM5MjUtMjFhMi00M2IyLTg3MGQtYWNhZGQ1NWU4YzM0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzk5MDk3NjMtNTZkMy00NjMwLWIxN2QtZDY4NjRjMWJi\nODA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs+HkTgnJDUs/J1BPnUGaoq5S\nCcbrraSJJum3316ikyUJZdlIP3gWUnauIUTu0Oc60/Xu1rFNHu4A0QWOmT6Sm6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUP2cAeIiG/aGJtsBQb+cbAUoqtpYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBzJCOcRhvqqGEpX3f9aBw0+bXQQXb8\ngBrGykXX9bI64wIhAMTSBpMudP344oNaGwpTvONNbPznWKkpDT3gHoEaLXCQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc122", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `122` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARy7t0TJtDZ5lJlkKOoco7XkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzMDJiYjc5LTRhMTMtNDUyMy1iYTFhLWU3NTM1NDA2ZmMyODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI1N2FkMmYtZTg2\nYy00ZWJmLWIwMjgtYmEzNDE3YjdmMDEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnM8+hdb5QAyG95zMvtwyuKbVtu26NthtL5IHCl2QnORZgRrGkSRIvwAvfocX\n0oPeV2BruUozdH8Rq+iqxZTYWaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV41IRofTuJuBjj8RLeAWhWvjT+YwHwYDVR0j\nBBgwFoAUDUmqw9R5hUQk7LUZqDme+Z69Lf8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAnFMxXsea1DStrDL15L7vbX05GIckC4bkzRtMr20LN/ECIBXg\n/m5NaAFDgoIjcEboO2uYu6jJ3UxMxrXEkHqFIPay\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc9Ro6Cj1Vx4P6G1EDH/pqWlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzAyYmI3OS00YTEzLTQ1MjMtYmExYS1lNzUzNTQwNmZjMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfgOl4rKgPFLvaYCMX628n7SJRJrNq6THDPSGdFMWmk6BP\niTvLJ958WX7+3SILcyOqI1C9PLicex/YvJptM/xbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDUmqw9R5hUQk7LUZqDme+Z69\nLf8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALKXf/LZau4Q1O7BxxRXwWpQ2TIUpAATkbisOUWbV6xLAiACPZ9Q4N7f\nKqZ/67XxlPa901SkY7UfEQR3lGW3LQ73LQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAa04rJDdi+qPHvDusLUkGj0+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI1N2FkMmYtZTg2Yy00ZWJmLWIwMjgtYmEzNDE3YjdmMDEwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODU1Njg3MTUtYzRhYS00NGZmLWE4ZTMtMDJiMDQ1ZTBh\nNDdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl4CkbXw6P5jFh/Bh0e5xQspC\nkIsOG9mc0n2o6qoKIfpTKMuFoIjp/Ba9BXiTvdHMzcREq8Yv2rjC/mdtdumvhqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV41IRofTuJuBjj8RLeAWhWvjT+YwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAbGj3kCH0zbrSSCiPSi/nCqpAfBQ54\nzg97AA5tyrVYswIgCGGTP1rgjP74coXtu087K0el4RiZKBbDvYeGnEmN2u0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc123", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `123` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASl4FuV3YriXDnViy0fyRbU9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0NmZlNTY0LThiZjktNGVjNi04MDA2LTkxYjEyMTIxZTIzZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U3YzVjNGQtYjhj\nNS00ZDU2LWE2MmQtMzQwZmQ5NGVmNzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6QFKK9IGemojh5IUVu9UNSxgmGt/0Vuj3tskF3q1PHg3SxMNSPbj5rQ8Tr3Z\noBsPiTxtGbXJwy3ypaNUwqGplqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyxJ7zu+NJVvOrQ3Jq2Zf9HzP0m0wHwYDVR0j\nBBgwFoAUwCVzXUAJAchaN477k2Djztt9bT4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA2V8vuUtMAL561hQowRYWJ3AjLEwmha+K76zfBLlf3C4CIHll\nVopd8kLm1Jn2Bt9aKICkyicVa7EmGZdZ5jhQ0GFZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY8HLP2hVWiqMLLsjJK3Qd8AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDZmZTU2NC04YmY5LTRlYzYtODAwNi05MWIxMjEyMWUyM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASM83nqMg9/1vXw77/B/GkBCGym7KkAvqda2V0HyUMQ5ee5\n1nfRvHQbRDhmR9yr0HMo4g7Yh9XrlHAIxkFZM619o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwCVzXUAJAchaN477k2Djztt9\nbT4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG2oYcekBmdZXCTiyy5Fkupd5VuxCJ8GwYSjptDhr/eoCIQCxSYR43CGE\nYMt1Tf0YDgyHvXbTDNqZdUZ07JiXwtXA3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa4B7Z7Yxd7tBRBvqjMGqCI7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U3YzVjNGQtYjhjNS00ZDU2LWE2MmQtMzQwZmQ5NGVmNzNjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk1YzdmYzgtOWU5MC00YmY2LWJlZjItNTE4YWNkNWI5\nZmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdbZjZonklq2Rff9AtEZBk6jh\nGcvnQuQAPWrLfZ9b8eUAf2B3gN1LnwKRNHibtooL8kfD6tSy5u3Yvf3ypluyzKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyxJ7zu+NJVvOrQ3Jq2Zf9HzP0m0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAzzTyvmtgQZ+DbMpdZTzvmiaQwpwD\nhXaHcjnolNeLFNECIAV5nk5uLGZtSaNbjiKd1MlJI3OO66Z80Yh1JJjnVIDJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc124", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `124` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQs5gxEftW8LlaFykkZRRI4gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwYjkxMTA4LWRmMzEtNGRiNy1hN2FlLTE3MzMwYjY3ZGMzMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQxZmFhNDgtNTJj\nZi00YTlhLWE3ZjctN2Y0MDIyMjliZmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0OaCeWoHg54P74wu3aTQIsS1w/7LxZg4p4wSdcX7ngnX/IZRJTIH04KCoW1D\nze/57I+72P0DpkA0w30k86TFqKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbNsTFcDL/UgGyTT5WGAX3rUigDEwHwYDVR0j\nBBgwFoAUbLcetWKGmaEBK8uhjA6on//Cu84wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAukuWCXOhEdNA\nV4z/IIwXcFZBAfpwNuKBM7UntAgxdLMCIHO81C133GIeonh7yTBWr9rtPi8REoKO\nrqPZNIciiBT9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXpYUWcS9ANMbXKPWcjRFtmfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMGI5MTEwOC1kZjMxLTRkYjctYTdhZS0xNzMzMGI2N2RjMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8lLaJXeT97/2DGhf8HFotqF+WejQzpxyyPdkynyfcIfSz\np7hsHMXReVnAnTB9meEDZKfbo+NAh11EgNs+hinko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbLcetWKGmaEBK8uhjA6on//C\nu84wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB7OdMXrA+Fo+XgrL4W4Mq62yd1DZyQp2zN8fI7RFe34CIQDID3IvuDGK\n24MSDVUMnjEKTq4G/haU/XZT6VUx7B5A/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATi18MrTdh0bM19JU5HDD3YRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQxZmFhNDgtNTJjZi00YTlhLWE3ZjctN2Y0MDIyMjliZmRhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmE3MjdkY2EtYzU0Mi00MmVmLWE1NmUtZjMwYzc0YTYy\nNDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkUpoTzgdl7fz+d2fcjgYY5Im\nlexCwpI5X0fqkrWM/ZEIj3MouYNAqQgEz+tCY1z73dPQAxnSdl9gOv7jKRRxBqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbNsTFcDL/UgGyTT5WGAX3rUigDEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB4qw5ZTKGcxwhPGiixFgLVi32/YYmI\nvzmq0vCAK/VGjAIgcw0X5/HT7bPIhUDoNJdbosGwzV93OfjefuY0Jhq20rI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc125", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `125` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZsDR5nqwGqZNGPeJQXOr+HDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NWE4ODZiLTEzMGItNGUzYy1hZmM4LTJkMWIwYWEyMzMyMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNlM2RiZmUtMjVj\nZC00N2RmLWJkMzItOTg4OTdiZmNhY2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuFaIeo5kYgFobjWkq45EQZTLEh0+q5Sn6tNvg88CTej/RAv+b4F9IPz58oeS\nfW65Bqi+nzlEpOFsLoLMLk5ucaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv4dK/SxYcHX9NujIQbm2TswIzNEwHwYDVR0j\nBBgwFoAU+Z8Fr8CuhQqMp8dNRElf6XI7PGwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAGA5CKoeCl2D5rBl4EEQ17iRk7JpSCM/GkurrDEVQxaAiB7UFvV27xT3C7C\n2ssR4yENfpuIY+2yZG+wdzr9H58QiQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV2zut5ZwfI32Ui6BFtLeCJYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDVhODg2Yi0xMzBiLTRlM2MtYWZjOC0yZDFiMGFhMjMzMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATG9jCxN8zz/qvv+zI3mnFwBpnLOoFw68re1Bm9ItDch2ZS\nNjd24T1ozTa0A1vmrBIIDe2bxfHlU4Mg0kSjlxZko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Z8Fr8CuhQqMp8dNRElf6XI7\nPGwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS3HqH66alF77JmpDUb8jd+ldQ7EcgBrOHSeNM4NunzMCIQDYfcobOGE3\nr2I4l+Y+WzztQ3mnd0DhB19mA0HnSnd50w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAex4r+TOglrkBz0wiP7b9YS0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNlM2RiZmUtMjVjZC00N2RmLWJkMzItOTg4OTdiZmNhY2QyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTY1NmE1ZmEtNWQ3Mi00NTY3LWE3NzYtNjhiYTM5NzA0\nYWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGL1aS4knV1g2pnPLvLm9Nadk\n0OK0b9/D3IVQlkYtsrss5RMn4JZtAKPX6fcTx20LvCPhFYGis5Gz4LyYj9+JbKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUv4dK/SxYcHX9NujIQbm2TswIzNEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiALpPrbLT0ycBMn8ispVRH2vV/reT7Y\nmJ7nOHmV1eRaNgIgCdJU4vAWswtHfYYjtDaAVOo0ZSpK74JVdvaanGSjJqU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc126", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `126` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWQf690eoAjhwxqLMxqRW2PaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MWYxMDhlLWNiYjQtNGQwMC1iNzNiLTViM2I0MDY4ZTY0YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDllMDk3YjQtNjVk\nMi00OTUxLWI3ZWMtMzQ2Y2JkNDkyMDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExzIzEQj+g6n6PcV7HH7LWQzX5fZ1gbNDi/20avOruo2AZmiHmZWN1LOemfCs\nLDWcrfGtgOpAu4Y1oBRRHIxEMKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUru0pdzNslBuCPAJFW6JMsYgEpaUwHwYDVR0j\nBBgwFoAUZa8Hj4pf2KlYH/mNf6YXisrQr9AwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICuJjTqJy9ZslummRqKrBriuu2vNY7PGU5AYN0h1gdkxAiAthM8sqrV0T3SW\nj5/eb4Afb9+kiAqVQEPR3DIXOCTqyQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbcjLsuWzN38KrCsX/2OhVtHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTFmMTA4ZS1jYmI0LTRkMDAtYjczYi01YjNiNDA2OGU2NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUWpQ0p0Bp7nLFcGm7XWDm29U5ye8qL4z59Vv9Sz4tfTLd\nAtnO4YVArPMFywLnk8LAOndrJ0MAFDuuts52YJMKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZa8Hj4pf2KlYH/mNf6YXisrQ\nr9AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUWfJmfgjVouTlwTHcOzfjJCAQVlAKIUavawFlhbV+nwCIQCy82EY1N9t\nwfGaRUKJ/XsRnTqlDF2gbimgWpYVj4VF4A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQ4XIlXrKsXgOFAyqpQ8B6AtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDllMDk3YjQtNjVkMi00OTUxLWI3ZWMtMzQ2Y2JkNDkyMDNmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjJjYjVjY2QtOTFiNC00MThhLWIzZGEtNzA3NjIzM2Ex\nM2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgkRLuCgSzGnsbcaUFyZ/mbg+\nB4TuIqYu+hv8fl57lHo2re2tF8DpTWpMheBRGyj7uGwIXi68iZUcPKtlUH59AaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUru0pdzNslBuCPAJFW6JMsYgEpaUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiB7c8+Puh1CHzeGgn2A2Nggo/l/xXB1\nf0BhBDSLs2heSAIhAKNFh5wXD6gyyqUWmVLstbqp7x1r1FpJvxTi9YkwbDnA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc127", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `127` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYX+G1IdXJNqOP8BVNYJ9JUMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2NDdmZjAzLTEzYjgtNDQ3Zi1iY2Q3LWFhMzU0Njg0YmUzYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDMyYWFhNTMtYTQ1\nMy00MDAxLWE0MmItNzYwOWNhMTI3NTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENC5yZPUWmZrR+0iqHlpYdLNJqtXGHjMOUP1ueLpOnd6bE2/N+aLDRgE+3fnx\nN9WIUaRZic4UsrEkwNe1I7yua6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ3UVyDs08WlMn9ChKNAi7r1mcAQwHwYDVR0j\nBBgwFoAUM450/+6KmtdAl9XZfAZkU322xkQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAmLI9D8ALRFHqeCXUU7/JgZYv4+iRUNUJgVlDBrvZZksCIEacrUcAD0JT\nV+9SOFGU7tKZ9kLIGgBC42D+338ZxErb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWewbZI+2dKPBWt2cYZ5sB23MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjQ3ZmYwMy0xM2I4LTQ0N2YtYmNkNy1hYTM1NDY4NGJlM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcxv+ByxTelDI62BfCWY37gf774NMix+fKYmU7zYaAV3zV\nSpTKfh9FYjHFNvuFrp8eaw8FzS7p+DXVZElBYN8No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM450/+6KmtdAl9XZfAZkU322\nxkQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc/+K24OTz7UlZplT4+Z44vz9Ztn5Qb06AOpEcdtU+ZECIHs+iujHZvkr\nUEEzsuh3fR9V5BdJxJkW5QcZifqgz7RD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAd3Tb0QrFnk+/pYGtrY2qyRnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDMyYWFhNTMtYTQ1My00MDAxLWE0MmItNzYwOWNhMTI3NTJlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQ5Y2E1MTItYjc1Yy00MDg4LTg4YTYtNmRkNGJiOTI0\nZjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOTNgh9y20R+6vcqRu3ehMBrX\nNTu4MNVncqqjtu/mCTAXPQppWAdl14735hjiixyQOxQelvsejSN42icSgEuzE6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ3UVyDs08WlMn9ChKNAi7r1mcAQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAx8yQUICEurVo7WqP9rbu3stnDMfR\nJzSCapFRamLFl0wCIQD5zM/d0iQUFarymrkM31EHOOpEid+ioPkvsNtFofjuRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc128", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `128` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYPC4Wf9mcUR36TzabJFgtGAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmNzllODIzLWIzNzEtNDkyNi05MzQzLTkxMzQ4MzZiZGZmYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDcyNWNkYzEtOGFm\nMy00ZjZiLTk3OTItNjhiMWFlOGNlNjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9aEo2gvRKLr3rZeWNIRoMsM3+HNhZhaT8GpGW7ui3Jn7y4B7lWg3kv6o8wgJ\nlu7dPjxjw8dIgh1hiB/fLM2SZKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIcgBO5l33+LhUDunzpXXMhtUD/0wHwYDVR0j\nBBgwFoAUIcQOye+PCh0l3Q9HGJgkbkoYbtkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA+kLtf2RmQFGjob410roxzDOci90WeoVZPFqhzydh\nFqkCIEmy5qH6OZTbdEhpspNX25DC4dA0jeeIQT7XAWR4z8Mf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeTnQEBYYf2MoBM5uWRwwAQ2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjc5ZTgyMy1iMzcxLTQ5MjYtOTM0My05MTM0ODM2YmRmZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATm3t13EjLv2UqT5Svw/kbohnBoqIqaHRi/6MF43LLpgMjw\nYYu+38KOFZKgAhWytIG9NH0mUBWpXWuvOfjRvrFSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIcQOye+PCh0l3Q9HGJgkbkoY\nbtkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANwEyezAV55IPWGDmpq4TzLwNat4bq8YHFXEZNM/j9KUAiBkbrNC+wjy\nRb0ol3NmFIJT805I52haQfQnMpDFlvCwPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQQJx+KmUYRYeEtPLOoQFtHhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDcyNWNkYzEtOGFmMy00ZjZiLTk3OTItNjhiMWFlOGNlNjY2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODA1NDc5OGEtZmFiZC00ZjA2LTk4Y2QtYTI2OGJhZjg1\nYWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9SChQqic6vIGkc20QobUl68Z\nMjH7lbY4mD/6MrqJU4o/qlOq/uAT+03ios4K+b44D0alXF7ZTZskV6sg7Z5fWKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIcgBO5l33+LhUDunzpXXMhtUD/0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiACwSgZUMB9nKmjtIGRBzuomGE4syR8\nbmG19f5rMbf/0AIgaBhUD3toD61Xu3p66ErrvvCdQtS7mjNe246XZ1coaNY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc129", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `129` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAenwbkM7bAs3/+HoErMZ3UD1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNDVmNDUyLWIxYjMtNDUzOC04M2YxLWFiNDhiODg4MzYzOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRmODU0OTctMDFi\nZi00OWEwLTgwYzEtOTY3ZjQ1NzBhMmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3s6FxLOgslsgIkfThms9/uto8SulrE/SkHbySdaEENGmpxKzRdFYJflWU5b7\nRY23UYIOZ+NR8hjP8HNowoPPB6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdan6qzLr8oQ8jHEOFDOv9EynD9kwHwYDVR0j\nBBgwFoAUih3GP6+aDezolV1z7nl9h/jaRCowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiA/Uvg2/Xi4NJKdkK1eFHW5V1M1ESEg0NH6KTstqVTw\nGwIgE1q1K3NJi0eMjLg/GaSMvQOpOhoItQk0kMjmeuOccCA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfJzBQATXKKeyxaP3gSs2kE5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjQ1ZjQ1Mi1iMWIzLTQ1MzgtODNmMS1hYjQ4Yjg4ODM2MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgFv2wW1bHqG8KycbcEazSZN2j67i2aKdcHBasd6/nxUT3\ndG7kUMTmiEupTmNnKOeyRLoqym80OfiAiEVEAbfTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUih3GP6+aDezolV1z7nl9h/ja\nRCowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOQ5KVe8ZdJJ/TzVuy+VqOO+MJBVHBoQLOMpACK5+t1QAiBJjAUXxEX/\nQBHTQVMfC0ovgi8kPZ4ZhCy7KesO/FNHfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbSapFdpvXIlJhf2lU0AIWsdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRmODU0OTctMDFiZi00OWEwLTgwYzEtOTY3ZjQ1NzBhMmZlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2FlOWY3NzYtM2ZhMC00ZDU4LThmNGEtZTFiMGM3Nzkw\nOTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECrjlsEtUp+XyZ1Wkw6RzKWlM\n6tQTPdQNXy2qk3cz8eZ1WmUIk6fa1oeVGhoOc4c3wppqmC2eBs8QvOnPdL+YuKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdan6qzLr8oQ8jHEOFDOv9EynD9kwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAqE0qh2Pd6VAYbUKbH6JNf9mIc6p6Z\n63Y3j5IKkqpDVgIhANIQ0nb/raxljJpyZsk1Tm4/Q0gxm4zorJqG2NYjWkHQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc130", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `130` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAd+N0XK1oTooa+X3ii8I4n3EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlNTU5MzVlLTM4NmEtNDI1Ni04OTUyLTI0ZWNmMDY2MGI5MjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTczMTNmYzYtNGU0\nZi00NGU3LWE1NjUtNDc5ZDFkOTE5ZDIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7qLSqA90p7petjO8pqmPLsdkklXVFMtuOo3ScF06afSG9FdrCWEI/r5Ds0jT\nFsjbkyv55OhsWSQd4ewy6cBUhKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6QH//QCTyGEco/lplJh2elFd0bowHwYDVR0j\nBBgwFoAUvRHia9zCc0/WmD0RXa+C+8uH3twwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAjC6pJ0MWkudhheMm0GMLW3LtfUSH6GKsqSgVTncK28oCIQC4\nfeDerrAA1kKFsWR3QxZJ6xWXzbLx32X7bgTHoB/OgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS19dEQLLVVnj3g26aNqgq7LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTU1OTM1ZS0zODZhLTQyNTYtODk1Mi0yNGVjZjA2NjBiOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfyQFrM7dOSYWYtyxs0n4dTw5K2ekRZc6CdnzKxY1fUHRg\nu6XQFdpzagx4ekaaAkePHLPczQ4K0927j2IYYH5oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvRHia9zCc0/WmD0RXa+C+8uH\n3twwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI3LISW/p/zoqjKgVtpgJhM1irjzJ1UtxaDTyy8Zc2m0AiEA0TLxLhAe\nxJxYpCiOS7WGix6771FW/Wf1ldIGcU/ei94=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAe6DP5ik+LSvBsoi6ygD7pA0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTczMTNmYzYtNGU0Zi00NGU3LWE1NjUtNDc5ZDFkOTE5ZDIxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDRkNzJlZjEtNWMzZS00ODg4LWIxODAtYzc1N2M0MTcw\nZTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmA94eg1sU90uy0V3yatAZe+N\nO8wGEJMPiaN5DqhsgI95BALzf1SiRYqi30PVf4wvXwU/n38hNmBFCCb0odY+VqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6QH//QCTyGEco/lplJh2elFd0bowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA5M7nGwsI5NdMFBfM01FbYUkeG7k7\n4AGO39MWZob4/L4CIQCNrNG+C3Cmai69M38sFBy0KcHHwKWW6JHN2+1Q5iEvxg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc131", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `131` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAQOZbRcHrlJcaeSe92lhSt6sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyMTY2Yzk0LWI3YzktNGI1ZC04OTZlLTIzNzhjZDljYTg2ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMxZDViOGYtMGQ5\nNy00OTJlLTliOTgtOGU3YjdjZDExZGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh/tmTOC1JT6ZNYPcwkLxsynGxT6aqEzxpC1xY3cHaTDtGU0asKzajqUM70gJ\nA0ucBsnucgNz5yo6L2rDEMpeXaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWzVyar8oSWgiaIGGiu/grPK66xUwHwYDVR0j\nBBgwFoAUJnc5YHrd1k/d5JlhwcDrztpohekwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAgIyWDUIiWSPh5DoYk8eJQnVApg3VJKdD\nTgyojsjorhYCIQCasDzGgH8zv8gdCcCWT2TtT5vBIAWqthZbABwKnamPGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVO0I7xlEzfG6VR8lNw/mLV6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjE2NmM5NC1iN2M5LTRiNWQtODk2ZS0yMzc4Y2Q5Y2E4NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGMCjGuuWV5HIHk7Y5TnOi274n4/c+H3AvzTPM44kHx1zx\n8Xdm6+7gsVH21qT85ha7iRw8VPZVET0EMBmKz2Wgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJnc5YHrd1k/d5JlhwcDrztpo\nhekwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMvxtBD7WPuGj61HdZt6w13oqUMW8ft0IXrUg9llYDldAiBzBMWc372b\ncl2+PK3H6ucvJ01x50wIzzGKxHljpFRJAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfW7yPV8oWxcQDuACHwW4nxcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMxZDViOGYtMGQ5Ny00OTJlLTliOTgtOGU3YjdjZDExZGU3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWM4ZTljZTQtZjllMS00ZTkxLWE1NTctNDc5MmViZmQw\nYTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETg9k/MVKaYsINvGB3+o0g41B\np7kd8BJdk4BwEIGqch5xKzSqRwbypiccPUZBldmNDMD93yYguK8CunTA56rNf6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWzVyar8oSWgiaIGGiu/grPK66xUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBgng8uB8CgryRm0iXzQKf1s5V2Vcq3\nBtoPwVF/tjWb4AIhAJKhuv2M4+gel8cEf42HyVzzEaUT2jpao0Rr+CgaBRQY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc132", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `132` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAa3HcyjJqbvZ1cJLx416l/9EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlODE4NTE2LWIwM2UtNDBmYy1iYTVmLTU0ZjQ0NDI0YmI0OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJkNTU3NDAtNGY5\nZi00NDNkLThlZjUtYTMxMzYyYTVmNGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkWMVcz7bNmtHDWucjXp40BWlIipOA1JSuHUVX9GAedRbddcivvzWxlRVw1YG\np0+elRsV+lRHNHs0o/3FF47UQaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUawzf1dL5EQLMP7EIKFVh391nBeAwHwYDVR0j\nBBgwFoAUbeIRtnlLsi3PCaUQv8NFugBe95EwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA5iwJMfuVjDF9EVg7iRzAzgLuE01wep6j\n4nIaEt/QWPcCIQDov7GqG6/ia1r1jR7D3zNEzrb2H8kWh3xXrEe540l7Pw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdNchm7WmTzMJGILRww9YgPQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTgxODUxNi1iMDNlLTQwZmMtYmE1Zi01NGY0NDQyNGJiNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxVwfmBPBfsK38foALitWAYDxe4j5hUBCJ61FPe+T0KX7S\noItZoAi7nyaAIDfFGAjRmCDsdxPE/K+Ccvo57pkCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbeIRtnlLsi3PCaUQv8NFugBe\n95EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZJK8pY8yIuzUXEZaiilKv4A7uV59YBWE2TlYIsV+qTsCIE1ihKo7gKCg\npghlu7LPxQpVA3+LjvN5WcGtWun8+sPI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcJfsTDFIws4OxhgtzlOy7uXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJkNTU3NDAtNGY5Zi00NDNkLThlZjUtYTMxMzYyYTVmNGFhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzI0MmRkZmEtZGI5Zi00OWM4LWJlYmEtN2RjZTY3NjMz\nYWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0W8Ykmbbz0TH+3H9/V/XOWUq\niliK3B36XUvfrskwZ/VTzEfOjvfJ2nEq/0FUP5qQVGhoFuKjZftcO4IHRLivu6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUawzf1dL5EQLMP7EIKFVh391nBeAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBgJhVZg38VDFhffmcquoM3eBfA0ii0\nZA1VVILxnD1T8AIhAJeoAyL0oFa0kBfnoWWeWwXfwuythpr+nGPRjn18j8NN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc133", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `133` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAXz2/7YqU1m9GWWtx+bnpulLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmMWQ3OTM4LWQzOTktNGE2MS04MDg4LTVkYThhMjM1Zjg5ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAwOWM0ZDItZWU0\nNS00MWVmLWJmY2UtZDM2M2MxMzgxNWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI82QS+voCmqrBW6/w63+xgfDVuN9z3Qj65pu6Jil2R+vn4Efp1W/WvYN4qoI\nWjMu8WoDmhJvXtfq2530AbXAVaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU41CEU3O+QGbFBtUVTbdQWJRmZwcwHwYDVR0j\nBBgwFoAUKks08LuvxokkfL0wq+IZyO26OfkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAxIru6RNJKT8zq\n4sEgLjE8XPTT5IhOqpqlhVA/10EyLQIhAJHO2D4G0RnLMfxBAPne8OrDnmAHNC0c\nCVkwGx5Q5a4l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ6Li7fKaKJfu8LrmgxbXQNuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjFkNzkzOC1kMzk5LTRhNjEtODA4OC01ZGE4YTIzNWY4OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASo++sQ67lKVLjT8mL5Kn7PeK3hf5zcfavSLRv3m92EU1Sa\nlm8n5Mm50yyQyo92F1dHyHM9nzdF0AXnp3Y6xTjlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKks08LuvxokkfL0wq+IZyO26\nOfkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM8Qt42+PoTdP499tnCTxiEfx0zbI/nQhRCpyA5UOlkgAiBKg8sdlncG\nrL2FbFOSFkWyal6B1oJr2BXFm/qaKMzkLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYfgUVFH2Bq0RTdZ8ohNR+XfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAwOWM0ZDItZWU0NS00MWVmLWJmY2UtZDM2M2MxMzgxNWJhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzhhY2M5MWEtNDkwYy00ZGEyLThlNDYtZmEyMzE1NDBk\nNDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2UvhhkqS3oVtPUmy9DguB8jq\n5LXom0/LZzNuPmoVPOGfUPrgU6eCL32BLH+8WKcdNu3pdnMBuTFcuK4ZRvZ0v6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU41CEU3O+QGbFBtUVTbdQWJRmZwcwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAcLaRGGs3j1hOhHNjz+YR8ZrwqsmOG\nyz9QOlbclY4g5gIgMRSnrp5WaExBQjGNDjivnjdebu/q6+50RfcN17Tfne0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc134", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `134` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdaOOo0ejqaIcg9I1q0baV8UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExODZlNGNhLWQ3Y2ItNGRlYi1hZmRhLWEyY2U2OTFkYWFkMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE3ZGFkNjEtNmFk\nNi00YjQyLWE0MjQtZGYxNDI4MzRiZmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFjnf57JBhOHDbJuJN2yQCtDHs3afxhrj8Iy5hlsVxdRB1vd6NeW4FSDxZH8C\nsaqP19R0rcLZu4sTcEM31t8zw6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURNT34L4HWHbOKmF5QD5vu+zqU94wHwYDVR0j\nBBgwFoAUxdSM3Lihg0mH6zP1tTMG6WvSqagwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBtzEiRZgoqyRykikRMKygG/MOu5fVINVjZSGSaxiBKOAiBZpzphmiTRbhbn\nU+arX39hWfm6dd3kJR+r5+Q8B8UaAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASf4bwX3TMmVywSCP/QvQaA/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTg2ZTRjYS1kN2NiLTRkZWItYWZkYS1hMmNlNjkxZGFhZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrLOC7HDcBv9fqhENWSQZBczCN2ACuRHqZ7czaIlPLcbYN\nhq/xCu56i4zCaVsBq22loIAbjIQV1dHAIO74e4Uto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxdSM3Lihg0mH6zP1tTMG6WvS\nqagwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgERMqXIxgT2qtsSN6Ed0BioVtnretqGw+9mN1ks/NxIUCIQDgVCKkJRpw\nGy4bUSF6Qj/HPu/uNVaIECeplVooDsKDdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVPeLBCE0FyEZW0M+3s+TcLjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE3ZGFkNjEtNmFkNi00YjQyLWE0MjQtZGYxNDI4MzRiZmRhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmJlZDQ3MmEtZjMwMC00Y2Q4LTljNGYtMWJmNjBkNWQx\nY2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEovNw5UrFkvVvmqy8HF+d/5ew\nN3sc2to38/kbMPOtcoCMxsgV3ZBPLOSdEGZAzJlkLilfHsNXWDK43j3UmIL+wqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURNT34L4HWHbOKmF5QD5vu+zqU94wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAxGW6+a2DfkRjLbDsKQedBnXqlnIe8\noeUwpExRwpAYKQIgUf8NpKDToPi8GlG+fmT9v4OCEDFFpJHKLdjF4KG0mXE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc135", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `135` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZdsJoZGkl0tOHH0Qs9gFEQUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlY2RmNzUyLTU0YjktNDcxOS05ODNkLTExNjcwNmQ2OGUwZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTRhNTFmZjItM2Ni\nMy00NDk3LTgxNWYtMzY2OTU1NGI1YjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESFfs6KwmmkPSFm1bWTLHPFuaL/qKB6kLw86z6gfkCTYmMNVVwbqqWAiCspB2\nt129M8HrMj1xh68fdoHtmB5WbaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE115J6k8OWwXy+eSQXHoJqw4j6YwHwYDVR0j\nBBgwFoAUqC9oRnXmqeYXsv6auWADLQBBJe0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC4+EvTG1JzFaeC1G/iPuMoP0+zvMV1vwEMoceWaoh+DQIhAKGxPryD4gyG\nDFWFG5rnfRM6FZJTw/XE6c+895Q5yrv0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR5Edyh/eTn4UuV3Q5q35pygMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZWNkZjc1Mi01NGI5LTQ3MTktOTgzZC0xMTY3MDZkNjhlMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQe/iv7QY3LH14pusJuoYR7ZfWtIVrtrXcQUmR3KBHa3kck\ncTM+FBBVYEsD374ka/5uyb734kYUoRLcb/75L/8To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqC9oRnXmqeYXsv6auWADLQBB\nJe0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQZqxSE87kfBRQ9YiMCRgyeKUxuepUvJOQjd+aPWaHxoCIFlme42lzwcJ\n91qgJFqJp4OV0GMsfxR7SBrun3OVWBXu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQ/l0zBkJIAhhHNHxv444v3fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTRhNTFmZjItM2NiMy00NDk3LTgxNWYtMzY2OTU1NGI1YjFlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTVmZjQ4OGYtZTRiNy00OGYzLTk2YWUtMDlhYTNkNjM3\nYTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExOZFtTjn69ARjAhdvl48UaAR\n7ARjXYzMNqqNI9VaYpxvytWwl+mKjxDcrm+oubK8Pz4McVN2eK11bjk9MFtneaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE115J6k8OWwXy+eSQXHoJqw4j6YwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA8Hn7t+MoGZvY4mb8Q4RG83BHGRr3\nYz0AOqeQg7fOjhICIQD6JzdBlN4IiUpl7U50tPaB4rnSpgIin65jtxEMXFG+AQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc136", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `136` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfXPJEvFmGSIIC3TNcbpfWOtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwOWQ4ZjJiLWJmZmEtNDk3My05OGVmLTdmMmFhMGZhNzAyMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg0N2RjMDYtNDQ3\nNy00YWI2LWFlMGYtNjg5ZDYyOTI4ZjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEui2dMJIVXhoIiZYTS8QKc7PhM9dUHxHZPIaZGWGDyUCnGx887XLeBE5ATAcc\no78Fn8ttPYqJptcaOqtoBlSwC6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgerWuF7BnYahJnxZUNsXa+smmjgwHwYDVR0j\nBBgwFoAUkSanVKQJKCehtHSgf26e8jpuBvEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAn8DBoTafBTXJUzn2uNZyMAlG5qwgSppuHB6ywBSoh7wCIG3a5EtgeM9V\nBIAbXpgTM3uQCnNaIVkbZRnmfatx9m/K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX+yDc+n87oOaUHK/noI4DviMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDlkOGYyYi1iZmZhLTQ5NzMtOThlZi03ZjJhYTBmYTcwMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCPjzJu0GZFQpgK/yN+AYJFbiM4AjhThI13Qy9GdNRJzmG\n1jCrNzH+PQFR9a5v69OAFlqLu94gZScPRkOIf+Z2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkSanVKQJKCehtHSgf26e8jpu\nBvEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMGi1Vudf4xXCnUHNPvtMSMDdLroNYpzUANVnpOlsLXEAiAmVv0TXT3F\nKOZlToVnv3l9UoGaYS3D9OqJYdj9YLL7Og==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZJ3ILWQpErlgeO4PfWV7GqBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg0N2RjMDYtNDQ3Ny00YWI2LWFlMGYtNjg5ZDYyOTI4ZjRiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGUzYzM4NzItNmM2Yi00MTEyLWFhNWMtNmQyNTcyZDIy\nZmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcq5ZmitiggzJwqOW+fhxNVQV\nlxzzBqS9TQyFpiK4V+tk/tsaaOyZZ3Slp9lbkKA8mfkovaSYH/ZedZiem6MuaqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgerWuF7BnYahJnxZUNsXa+smmjgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiApwTFsSz/S48lxbwC59xwTswBLiRtu\ntHVmBHVPGJBkEQIhALK9mINjJ1A0MAVe8iaJJzZCyFb9T4PeIHAMS57T0XQJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc137", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `137` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAbu6BTlaqua7IPfmzkxW96t9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1YTZmOTQ2LWExYTQtNGU2NC05YjgwLWQ3OWFkMGM5YjI2OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTliZTNiOWQtOWM0\nYi00NjE4LThkNDEtMjcxZjAzY2UzYzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFkq+46Ff/VBalZvWUYcQuPv/5kvnIHIvEwzlL5odmDKhboQroA8Yt9f2O82b\n56w98P3oj4ESbyS+XkF+2icrbKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT0BnPvtLyWdKzsANe9A6jUP037AwHwYDVR0j\nBBgwFoAUqf+OxvvZjK9rvlgzvhUfn1cdTlswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA3WmNAz2X8SfyCkQ9IWxQEGoo9KAwE9b6fmuN8Fhn\nhEgCID5jeNTVyGSqIaTcHjbSE0mYX4dDFblnaVATuSR9irvh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbsTvrNM5JwPAvEFJlKvBr88MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWE2Zjk0Ni1hMWE0LTRlNjQtOWI4MC1kNzlhZDBjOWIyNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGRSINbRXrHmc5mWDOB2Y90w2Lb7OePqQbYTbWnHeu/1wZ\nHpS2vij/y89MbWRUJ7rzeKz46MG0R/zOS1qnVzQ8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqf+OxvvZjK9rvlgzvhUfn1cd\nTlswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLU19gYQdTWc1XZSLvzvCGEdYlP0DJU6zkNeCwQCM92MCICz6wpicIwnb\n30jciwap2enJXYB0ah234nDRf5ZZ6Bnb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASxOvjiU4Dfw247nXsPpsUFmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTliZTNiOWQtOWM0Yi00NjE4LThkNDEtMjcxZjAzY2UzYzhmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWUxOWZlMGQtNDM1NS00ZTkwLWI1NTktYmQyZjVmODhk\nYjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBfJ8JLRJBJfdf/tcfRdudeu4\n/nGPKqcV5yGCMfN2YeJueiMKU1raBdyHtm1TLOPz/VPl7b1qgVxRhbLaT68skKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT0BnPvtLyWdKzsANe9A6jUP037AwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAk/TVV2gpwrLlUduiPwjincwxarYX\nkzljjqCfCD0+n3gCIEojybRnyzdw0cXQw7FRA9svLxAQpunFIHZAqbgPOUVX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc138", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `138` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZgpVoN7MkFHNTzqtNkJoDXaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwMGUzNjE0LTNiOGQtNDU4MC05MWRiLWJhYjVkNzFmODY3NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcxNGVkN2EtMGZm\nMi00NjA5LWE4N2QtMDk5ZTUzZTUzM2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZU/n87x2pkpwwJD1AZjVG15atnSo4QAUec2N4zpn1Lk3ACUxa5OZ8dlQeMd1\nT/PuDQrLupOHEAfWQUYk7QgLfqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyFKnUOdxGl2kiDuI53IhTxMuwQwwHwYDVR0j\nBBgwFoAUcx0j01fvzmI04V4LO7ZWs9kM1pMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBaPWjlhxoZCJAwEYFaRymNhh+OLpbBwqmjTvOHs0R3\nUQIhALJWNaCWYXoFkS8OxFx6U3/RaTGKagFMwS12mEY0Jihi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZj9OedkJqt4iXYsnhUeuQyZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDBlMzYxNC0zYjhkLTQ1ODAtOTFkYi1iYWI1ZDcxZjg2NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAclgMPRl6LU1HKe8UhyHqclzy5fATA8VjrG7oJ4YKuOtk\nrOAbOnbhBgUfTLaz9Tl/aGbx+A+ilehctRH+OoYWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcx0j01fvzmI04V4LO7ZWs9kM\n1pMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYxJPev4u6/5no9IPWlNoKQiBluGMJseFiNzXd1yt2qECIBaIJeyA9jI7\nbsfhmm0GV88waolHZkFpX7ISJMw9Sdgf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdwssu2DINdca85FYMQqzEmOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcxNGVkN2EtMGZmMi00NjA5LWE4N2QtMDk5ZTUzZTUzM2YyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWMwYTVjYjYtOTM3NS00MTE4LWE1NWItY2MxOTNiMGUy\nMjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEe075OHcyOmgxGt6XcfDtFWFb\ng2lDbxJIEPHnrwnlFAeTunBeE0F5AccEcGKXS7GxhVdLDCG/aQVUCrGmHlK8F6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyFKnUOdxGl2kiDuI53IhTxMuwQwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA4gjiDGyTt9RH2Fr8i44Af0fwk2lF\nkM8wPPsy2/1e2OsCIH//LpXlp8Eei+m2HtiuBATtjhFBEUcQUpxHIS56a3W0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc139", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `139` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAeP9maekRLAsAnlADx7CFX1aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlMDhmMjhlLTllY2EtNDlhOS04MDI1LTgwYjk3NjgyNTZhOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJkMTQ3MDAtNDc5\nZS00OTgxLTg1M2MtOWE5ZjdjZWM5YzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgF9PqNyoQYiq3tqg5gOVE9jeDsCjTSk+kACpN7EMPT+bCRH39xhvWdp6OWvw\n95pRfVU9uP0qdUUU2pY8d8cpqaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP9nHxHK8tAXe3A5jPjfDXU/qEhowHwYDVR0j\nBBgwFoAUPkiNpxjsdJYd/a03k/Ac8xw8ZoswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA0JpKywmGQ6HDApK/7YrB4Ct5hQM98BXUi/jLeT+DiLAIhAP0X\n9LubJwlSkCS72U0sBWepYmMtIwL+PxpucBmEV2rw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAenNv2XEzCeyXd0tKFUePEd4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTA4ZjI4ZS05ZWNhLTQ5YTktODAyNS04MGI5NzY4MjU2YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVpX9a7ocN6llc5g8KxmMffFLokyKJ0UOnRZCyjRyRbDZ/\nBcAjsY9GkGsD0OYwOwFYEhFknDLVIth05hR8IR+Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPkiNpxjsdJYd/a03k/Ac8xw8\nZoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbyGFbAcZTDjDeQHTiemjGJ10BgbONCqzWV9V9NZpKS4CIHxMlJYVXRje\niq6SLVm1QjNX2uyxGxOHeV93yAdXfSE+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARNgnkoeJSu6JOKFS5yaDnlBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJkMTQ3MDAtNDc5ZS00OTgxLTg1M2MtOWE5ZjdjZWM5YzhmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDU3NGU0NjktMDM0Yi00NWM4LWEyNzQtMDgxODQ4MzNi\nODZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEezZ3HfmtA/320msumYTGJbnY\nhxbbCQilgvHAaASfWB/9hD8KPPpfXWP1t/FaRoJimrttmngQ0+BiypbHu1p3oqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUP9nHxHK8tAXe3A5jPjfDXU/qEhowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAGGtox99J4AdUasbQxIk+JXQWW14wf\n9SH5G6MGpU3YdAIhAP88hUucGtPEfKGF/2KDkTiueJudenY2H19HM62xmqxy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc140", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `140` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAWl9ZOcfkGdGLLkRSSfvTlM+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4ZDRmMDM5LTcxMzEtNGNmNC04NTBjLWY1MDJlZjMxMGZkMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU1NDNmZjItNjZj\nOS00MjdiLTg2NzItMzc1ZGQ0ODdiYmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKIDWWHzqIfkc8YLyhmAq0mn7al/iPt9jsvKmlBixH9JxM0X5Mkcy0fWPYONQ\n05yuHD6gychtMhLUsYy28vkBqqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrxS7tcjUIdmuKRwWs3+gD3/JqYMwHwYDVR0j\nBBgwFoAUYSb1iKL/RqwM9Xh5bH1SxcvQKBkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAlmCIj92+Ls6LxT+WgogS5q85jiO6Hmcc\nZJPmJaieraYCIHjkc7pP4LnAcSNuaKlFvwg8G5nPbpCfyHiVVOUDyDc7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcWnh8yQJaZ/pcbh9t++RSprMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGQ0ZjAzOS03MTMxLTRjZjQtODUwYy1mNTAyZWYzMTBmZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScf5sYqoCU4SagqamBzADg3cLZPb709uDyAj2zwkbj33n2\n74EQQHOfshbhJn19jQ725XD6sfbMXDuBmW8iuONro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYSb1iKL/RqwM9Xh5bH1SxcvQ\nKBkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJJzxfzoRQBWdYUa9wg74qOCcjJSVXrIB+m0EktZ40QbAiATetvxZvjy\nvSahXv9RCdOlfJwIiOcSWjLYVd/ugoGlyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcQD3X29MK3c0qye2SbV0gaEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU1NDNmZjItNjZjOS00MjdiLTg2NzItMzc1ZGQ0ODdiYmZhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmRlYWI2YjktZDNiZC00ZGI3LTg1MTAtZDdlYTkyNWU2\nMjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3u698kBjHE4OLGiYKX6pIz9T\nsZ1VMXoSB1U2hhmHOEpCbE1CD3pyAJhsE8Oxo6HD0RFnk6K/Y7jqN0+S4BjPGaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrxS7tcjUIdmuKRwWs3+gD3/JqYMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAZKCXib2fPgOellT3tvsMvEppnzptX\npRvOifM2uie2gQIgco1Ape9teb838nNnKx5w6Hh3XbPxXpBVXJsp1T4Ebqw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc141", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `141` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAYjAVaHoSNOnl3i0jeea0CTwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxYWQ2MWNjLWVkMDgtNGUzOS1iODBlLWY3Y2I1ODVlOWVkYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdmZDMxYmUtYTRh\nYS00NDVkLTkyNzMtNTA5ZTNiNGZjYzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP5ksNz86YKdmxex7116cDRzHO8PYSKP1k7UoztGHKFORXpUIxhLPo1Jh4mfE\niAObrZ+73TxoHo/i1fPyJAdLSqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2yLH6rsI17LPTRtqtzKtig1LU8gwHwYDVR0j\nBBgwFoAUhN0grVqCtVkRRJS1Xk9yDHh75RkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAu0Ll57aT4dWsKkeLzyH5Su+TcEdKWi+v\ng3CtvjyRUFoCIEsPIxtolJWn/NYoVSOWgAIDlVPvahDjsX9/sqqDpgxM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVySY91+8xlF7l8NJpCiDsrpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWFkNjFjYy1lZDA4LTRlMzktYjgwZS1mN2NiNTg1ZTllZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrwIweCQ5+KiKwrJh1rA0GVQy11z2+Wwci2P8nVNzONkK1\nzZ1vIa+4se1MCMQ6KKNT+F+1w29zXhY/CLpE7bmbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhN0grVqCtVkRRJS1Xk9yDHh7\n5RkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVuGAYEUsmDGi3IPl5RAfsEfouR0+d3R+IXGDecHkgAcCIQDCtcqeaLmO\nyrE1Wt6Uq+HrRX8qzyep90EnxT83OOtUmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAU3Fc/tTBRt5VmgyoZP3IhWAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdmZDMxYmUtYTRhYS00NDVkLTkyNzMtNTA5ZTNiNGZjYzY0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODZmN2M5YTQtYTk3Yi00MjZmLWFmZDAtOWMxNmI1ZGNh\nNjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESZ3fYcFcbLjfSbsbwpyQuIcr\ngdpdhZsNzHk4+yDm9wTP/a8VByaJkfe26yKlOF9mrA03mxzpDJm/xI0EQYIAtKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2yLH6rsI17LPTRtqtzKtig1LU8gwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA9G6uoqnUqBMFoxqlFeJHZnJ6Bn+o\ntwtlniWKQBh/VzYCIQD/xwFEVP8nkb+QZJcRqbpIjY75NCw51UVqJgd5zhE6kg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc142", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `142` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAUR7AFqxKEKLQL7Cy2aw+JFtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3NGUyZDYxLWYxM2UtNGYyMi05MzQ1LTg3YmE4OTI2MTMwMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q0YTUyMzMtNjlj\nZS00OWE4LWEwOTYtOTUyZjQxZWEwYTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELBqmnPd+PtjB0+yBwngrEMV81wOgPFmQqE6r7wIhkNSVqJWmfcQgW6pybhDt\n2eU3G9RXPcWwQlTqj+SZpxDpEaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU31yFQKMiP9S0MqcCZxcZ01f3PacwHwYDVR0j\nBBgwFoAUeTPeFtqXS7EihKZkzSFv/dtCJ74wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIE6AS5wzfQuTeUqxuNCc5jS4urOw\nPcAengY2uM1iS0+9AiARfhd98Is8NTX0VPsvYhTGOvpsomOqNC60IlsGdNGH6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbzfOXi8Cttz3xsnjIzhuic6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzRlMmQ2MS1mMTNlLTRmMjItOTM0NS04N2JhODkyNjEzMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScVrHgL1DrL+0yZ7jU9hK0bA/I1lt1Vvdc8x1Y+rElkrDt\n7ObXiY+uUUb+/K9FkPj2DNFLYyc3SMteIYlhBW1fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeTPeFtqXS7EihKZkzSFv/dtC\nJ74wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOZb/C1Nh3QDkxEsyM3OCbySnG1Czd8O7Am9fzrywXBOAiBEUHD+pwpd\nUPtx43HPmrtIxC+VLFnOit9jajDiJZqHNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARjcWeuEYbJ5Jw4bFByJzSDHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q0YTUyMzMtNjljZS00OWE4LWEwOTYtOTUyZjQxZWEwYTRlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODZjNTAyZjEtNzEzNC00NmMxLWJiOTEtMmM0ODJmNWM3\nZWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB7oNAi9r014mY2f9cIxCjyGH\nOo0KdoTkTM6rzySbGhjitsJR1mookgTOGtcooUDFsg0RJ1GcrGAZh1pf2onCxKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU31yFQKMiP9S0MqcCZxcZ01f3PacwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA2qhlhzpuZnqZsgYTZ3beqF09rqRG\nnFUb++6IFG7flB4CICEwGkWg8MsfwMxAWO5GEi9ulm0zDQX+93/xoq9w85By\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc143", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `143` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAYf+ioxpVs9Q38LLlL37HAU4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1YWZhNjQwLTk4MDAtNGEyNy1hNjRhLTk0MTM0NWJmZjdkNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGUxZWYzM2QtZDhl\nMC00MTRlLWE5MWQtYTczYTMxOTI5NWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8HlE3UvjlSXTfJgpupi6V1YgUbHfwPEma0cJno7aZH5XKRSexejXqmXSkbMB\ni5T3WOkxj9ufKfaZIKQX74iNOaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoCsvm0fgHv7pjEw7wgfi+Dv0PYQwHwYDVR0j\nBBgwFoAUaYpz+IbAKm5AIs29tMV1G7mc2SEwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALN7jZGd\nxAUK0637NYOL7u1ddD8EKa5xA6WhBxgpsIILAiB2kgs3usF5ih0YX7vRSM/2R3H9\n+BN1sGpmIVUIBTwHJA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAffM6Zc4bubkEohKfDfDMqM6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWFmYTY0MC05ODAwLTRhMjctYTY0YS05NDEzNDViZmY3ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHedxqmLkjr87dPNXC3urxzVnqgLe12Eq3zApbzo7jR2ND\nBLBO/40bCfOjcFLPGzoG95R13o7S0gS0qqpCujVDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaYpz+IbAKm5AIs29tMV1G7mc\n2SEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAmhrj2f/Ax5lnQPOAmpfuifQhp9sg0Aq90QWJuChyYoCIQDCACH+ZEUX\n+m6D8YD9gt458ya8rVZbr+SQVJ8GPDXQXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAb87aySrMf1GO9F3GcpO4TQCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGUxZWYzM2QtZDhlMC00MTRlLWE5MWQtYTczYTMxOTI5NWUwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGM2MGRkMDItYzlkZi00YTAzLWJmZTctYTE0ZWVlNWU0\nOTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk6jrxUT7F90nG/gjbtLQjZiK\nK8CNlTAPc0Um5yfYQ6kV1FD0ZWb6WPvtf6lJrZWjzUOOSbaBhGNFsJ+2mup4maNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoCsvm0fgHv7pjEw7wgfi+Dv0PYQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA0G8IjrHdL+dHsQhabEQ8IC6ZLbL/3\n7Cdjp+rlpvP0owIgHAnWeo8oH8BOXsT4yMOtcTOcXK07oNgf51AKsj12+VI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc144", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `144` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISASnUVPUaHFz3dYfr0v7xUTQCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmM2Q5MDI5LWY4ZjMtNDg5ZS05ZmNlLTBhMzg1YzM3YWZiMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdjNTdkOGQtNTEz\nMy00NTdiLTkxOWItYmMwZjk1M2EzNDI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETkj4rx7RM8Q4c7CvPXhI/23bD9YyM9OCOEOqSAtfK1OMc0fbnEtIUlzTDmF+\nGJLvg/Ef8PChKTnixlr1AFUX+6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYWL0ytfnaVYQJMj3CwCO0B+RQrowHwYDVR0j\nBBgwFoAU4NvsR3B4oTYkl/1QRWAMkqBcDhkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgLTxn+L5M\nB2WyT6PBg4j5UFZs0bnhluKAISl9GJbCgrkCIQD4Hf3HlEViif8yu9PHvKLgthlW\nL/gV7P2magF8HPHsDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAflbHCzVYFy0vMlIGVlp3JkzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjNkOTAyOS1mOGYzLTQ4OWUtOWZjZS0wYTM4NWMzN2FmYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2481brwosq1HrzxX0/jeOfGa+yBVp5En2jo0Bmy1TI7OI\nwBpN+F5d6yezrUfv3zlUligWPasZoIo8OI5S1sTLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4NvsR3B4oTYkl/1QRWAMkqBc\nDhkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPj/zSJVHMBjDPbV+JNAAgQG8EW0WqaMXR4uZn3ZpzoDAiEA92+P/TCb\nbCAWrn9CgDgp+polgW8mk0pk1Yk9spHNKRk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZ/DTtZVbSI+sX/xd28nYRZMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdjNTdkOGQtNTEzMy00NTdiLTkxOWItYmMwZjk1M2EzNDI5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWJjZGJkMzQtMDY1NS00ZWU2LWI3NTUtYmE2NTU4MTNj\nOTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX44tBLpAKdjTZooYlommuxl5\nRujGYUc/GV3veAu/eJ04pt4g8bG+c/OCu0QqYYi+geQd47GwCibtbDHT/J3mpKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYWL0ytfnaVYQJMj3CwCO0B+RQrowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA4iKAyff1pi74S7O4VH4KU3CT10fl\nAd8CLHGtAxk4TVkCIE2gOfXvjuNSe2V3t3hwsgraIn2hDC3SbW1p/VaCni9F\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc145", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `145` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAZ5Vb5sLARb2m2woU4ncOp5nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZTU1MzA5LTlkYTgtNGM2MS04YmJhLTFjM2NlMzI4YzlmZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY1Y2NmNGMtYzA0\nZS00YzJlLTk4YzEtNmU1MmUyMjE5Mjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnt+ZGOJem3ULKiuZVaG4IAr5pWsQG9aM0ENZn1iMAz5b7+pe9iS9pU6iE6t+\nTuP6/U9YPCiHi3/US/BYOIzdl6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmsDEFVSCxsYxrciC/98kaWmsp7AwHwYDVR0j\nBBgwFoAU/3l8VLY46LGpEoXf/H2sYJdHbhQwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAbKXvpU\nPXIgMZO47C4pmd9Jt8IE/wAFbyiAGF4v9aYHAiBRO7mxmZ02gsIJyiyWjT1Ksw6p\nm87e2mWK4Bm0gszl3Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUI0M9Lp6sM6yAi2X0RCnZTIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWU1NTMwOS05ZGE4LTRjNjEtOGJiYS0xYzNjZTMyOGM5ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASF7mjKmEjCMGCVipXaFwE3Kf6RrMs4cvYxv2G2UBa8TyKU\ntACb1VaFT3alGEzvKvVteccG3hGiTKcx1we/BEcBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/3l8VLY46LGpEoXf/H2sYJdH\nbhQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL0g2ctwDWNPKVkzfqEqqTIshvA2iSBJvHmGNo0jANDGAiAtl1sMeDwz\nAVlKqClLPx4jmg9SA2dZ5dK/qMR8INqrWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcy5m6+q+NWQQaVVaIvBRhs1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY1Y2NmNGMtYzA0ZS00YzJlLTk4YzEtNmU1MmUyMjE5Mjg1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjA4Mzk0ZDItZDU2Ny00MjdlLWExYzAtZWM2ODc4ZGU0\nOGY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErD/bGle89UDW72kCO3WhtSGl\n/l9vdAvY6RdkAhkoPghwv+o/XlV31z878RpOjdQArC8C334JddFcfpdurrPFL6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmsDEFVSCxsYxrciC/98kaWmsp7AwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA6y6b+i4WRFH7wgIQf034hWfZJpSE\neAK5kGQZ4MK5w0YCIQD1eD2TXRUrK09ctgIzjEi28acx7qMCPCSgy69ULl0knA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc146", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `146` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAXOeqJrZiFCFVLNzlYcTppsqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxMjE0ZDBiLTA0NzgtNDVkZC05Y2U5LThmN2ZkYzU3YWQyZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I0MzMwNTYtZjIx\nNS00OWNiLTg2MzctMzk1M2U2NTQ0YjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjBDv9f0//iYYK4e3OEB9Fzi34Sasv/hkXfdk57GKXDRb1rnaldlSaGNxbqt0\nZ4uQCGp0aUwZwhrvZgf9oBtydqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbsrY3ItLd2NidjeVC9KB5TeqtRswHwYDVR0j\nBBgwFoAU9yx17GNrV9znEaqu03qJh98iHQ0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIBFUTf/FO5Oeh4UTSHa9Tj94Hq92fpBA9/Vtxgt7mjE3AiAIfCjkunq1\nW1OIBP3PwtTJl//s3FsiscdkjlqXS1iSIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASMxOAafst4id6BjKkuPtAkAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTIxNGQwYi0wNDc4LTQ1ZGQtOWNlOS04ZjdmZGM1N2FkMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJzLq0RG+J460K0DrZ+04RU0EJRJtMCr7vG8ulagyadH8C\nDCrQOWcRlljTCMYKCPEgqMp4FoMO+QmixofE0S4+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9yx17GNrV9znEaqu03qJh98i\nHQ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP6wML6IkJG6HQE80jiulW6vqSTl92ptnI6Pdp+S0pFxAiEArZwjriKv\njx0F2SsT2v+K86CvUK4qELnPUd4n7VCUPLM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZ/hcTI4UJUeE4M8kcMFq88cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I0MzMwNTYtZjIxNS00OWNiLTg2MzctMzk1M2U2NTQ0YjVhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDViNGM0ZjktMWU1ZC00NjU4LTk2OGQtODcxYjcwYmI5\nM2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqHwaGSsPs15rIM9vrHRqj/+W\nJNEo+ISTM+g5v5fLP/SCMeqo3xFdvtqEe4XRV1pUZRAKeGXRX1Xm5scHx52kqKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbsrY3ItLd2NidjeVC9KB5TeqtRswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAvUVqgT8NQDD2UAG0s1mY941vORFz\npJjPNbf/8nBLdjkCIENQu04LvNQ35UNg8mMcjmGmLJUmCQRYDQWw51+ahuFS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc147", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `147` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdmxcBbBVTFX2bfVLIKoyP8tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzY2U1MTY2LTU1YjUtNDMyOC04N2Q3LTZjZWUzNDZkMTU5MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJhMDE5NjUtOTVl\nNy00MGU4LTgyYjYtMmVmOWRiNjRmYzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPj/u2d79ZuKT4KVVHLaG/yHIAi2YjcCU2f916raJtUGr4BMq+SKv33/lcMUD\naHbzkYuBX595gJ+QPIWyzeWKgqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWFrVROwlFMg4zh4ZKvyh3rFpiFgwHwYDVR0j\nBBgwFoAUFCtIHppvnY/+cF40swE5k1MroA8wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCqkuAOseFQBNtop2FIxZnmSZrMJxa2Kld6OyZ0kuykawIgY9mqbczq\ngS9gHe2Zlt4dfPv0tfYOJ2vtr/5mhAlcHlI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe9WPJF+95CWTaeYJcD+8MHaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2NlNTE2Ni01NWI1LTQzMjgtODdkNy02Y2VlMzQ2ZDE1OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQz41MwcKrm/y3z/9Zl+LcqQD0EQTi+gvgKGc1M4XWgq/hn\nCENe/z2+ltDHXElXgzT1HOcsM8KoVSQVl8Gp6kouo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFCtIHppvnY/+cF40swE5k1Mr\noA8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP8jOQMoI8gtiTgmcA6UbFUM3prAi8b/8mCI16+s+z0ACIBvhTtchs/yE\nKz7q3hLxg7twfQFOm17qEPiYlDVqLomL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeSul2odEr5YBMzvmgAqeQqtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJhMDE5NjUtOTVlNy00MGU4LTgyYjYtMmVmOWRiNjRmYzJkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWUxMjE1ZDItZGM2ZC00OWE4LTk0MzctMGZlYTVhNTZj\nNTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa19EXfLcFW2z9NlRo0EFamX2\nClGr+AXzluwnOe2VQUNK67mZ752WynBYNMGpLZ4xd4xWtbfmpEBQOPfN5dlEGKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWFrVROwlFMg4zh4ZKvyh3rFpiFgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAqBa6Nh/WvgFthCpoCDy/4TVTkJzv\np4ypFFr8WzTjBrACID3u5uBE4L/BxExlZ2t9wllL7Zqol3M8dK1HfOFMu9gM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc148", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `148` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAfyE06bGng5wdhAzihP8x0U6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlYzI4ZTQ1LTdjNjAtNGUxMy04YWY4LTk0YzcwYjczMTBmNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI1ZDdkMzUtZmQ0\nNS00MjRiLWEyNjAtNDhkNWYwN2M2OTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEadH+2KFsdLWc12thnWGdh/gexb/qLG24vFyx+RK7VAD6N5Zeks5lB2Y0gImY\n1P1oNqfGQQbiKYEEo5DsobKxl6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXgkFtHW5lysDPNgYnv5cVC5P8DIwHwYDVR0j\nBBgwFoAUZmdXRe21lvRG2N6229gMaYsH4cwwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQC+NCt30Pc2qm+WRWuu3+idLvOtp38AfCXIGlUZNdu5MgIgGkESt69LKaSB+x8f\nMvFcnu/H4kbQsT9g6aTBtV7QrPk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZL7Pqjc4GW/sPq3eqDwlrMxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWMyOGU0NS03YzYwLTRlMTMtOGFmOC05NGM3MGI3MzEwZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJ6udbYIhdi44Hu94+XyacO3Ni85NDHe6JrhBHb6j9tq1Q\nMaGtCdeXedcvntZitkeyy+YtacZljU20FumCfP+Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZmdXRe21lvRG2N6229gMaYsH\n4cwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIepHOW472Nk2MYd4ZDTVi9WigVxavZ916VFuAXZ7P+xAiB3SXAkC2mV\nFzGxcMC+n0C1f7gRxHBJubQmJMgML2nJ+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAR+5xddvigvxle+FVxEJrlvYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI1ZDdkMzUtZmQ0NS00MjRiLWEyNjAtNDhkNWYwN2M2OTcwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmE5ZGU3YzEtNzllNy00OWFhLTg3MDgtYjk0MDZmODVm\nM2NjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtW/JJGkKA5WS5QYXZJV9iHZM\nEv8/gPdFnlCP0ujYZyx7UBbbmAd1htB92QjyZOtPy6DethjIjV625RMvKFMNYaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXgkFtHW5lysDPNgYnv5cVC5P8DIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA2t8oIZJtEdNigSHIOTjM8GogHhEdy\n12SG1llGTH1urwIhAN01z5K7x7/U6h84w+v/i0IJdFUI95C6jg3M1D0eE+uh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc149", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `149` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAbg9iaZZaCTvBaRckpqMFBsXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3N2VmOGIwLTdjZDYtNDExZC1iODFkLTkzNmJiNDc0MDRlNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBkMjYzNjEtM2Rj\nMC00NGMzLWI3MzQtNjg5OGFmZjg0Yjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE36JRSYBYLrV+zNXThuMrJDA1w7ImPEMchbqGQDrQjbsqKIUAxIenasMJPkac\n1ZfmpJY+XCCzO+TyVSAfsl4YEKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1wUCWLf9ivAOTqWHF+1NzF32/r8wHwYDVR0j\nBBgwFoAUHt05/GtpX7LAD4lr7zqavDgrqmIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIHHPE8EQfyocwGkx0Ff0tfOg4DxtrJoMArWEiYxrdYXUAiAs\nGBgXWv3FCCDkDumTiphtThf8iHWyyGzBPy1sU7oalw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfvHniAIBXhXOoLCIenxJ50OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzdlZjhiMC03Y2Q2LTQxMWQtYjgxZC05MzZiYjQ3NDA0ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPNgMAXl861HJMuC2Jh+eZa4L9yOI5P/bQY9uEshDrHjhP\nClGNDfJnJ9E9GZbqMigNkqQtQ2i1EC1EBGtxbuRQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHt05/GtpX7LAD4lr7zqavDgr\nqmIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWZgLg9t/Y50zBumSEvJ2C55c7oFWM8t1Z+ahKg2MQ6sCIQCo9TwV27Fx\ngsjfqhIzjm7MkaUPi9O1R2VT4+VeajW6dA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdKhNlFGeINnQ31QFjzLqf0nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBkMjYzNjEtM2RjMC00NGMzLWI3MzQtNjg5OGFmZjg0Yjc2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjU3ZjIxYTMtMjgxMi00ZTQ4LWE4YzQtZGNhNzI2MDU0\nZDZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdVQg2TD6bONHSI33iMZfKvLn\nc5wCL0IjjN/8cOBzJUoWvxTf+3KQcxSScF50Zi/OcyU42+Fy06w8FHg5lwAaCaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1wUCWLf9ivAOTqWHF+1NzF32/r8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAgexPpc0pl5zRnHIokgf29YvAZPwX\nobYRS+fEJFqJnF8CIQCiYPbj4RsaytmP6olYq4iEUmReRkcagWWlKvgkBfnbAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc150", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `150` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUckkQOitobjj2MDnJ89ACJnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NDZiNzk0LWI5ZGMtNDMwZC1hNDI1LTljZjE1MjFiYjFlYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM5YjM2N2UtNmMx\nYy00ZmYyLTk4NTUtNzQ3YzRmZGQ2YmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgPzPRvXyEZchnB+GSILA5BKeaCNtOfo3TGbiPI3AjGgah/u29IVdAG9ulTD4\n34sq8pcT6HLQhctT0GG3sEMqTKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUicmsDBE1Frj1sYpaws/FRjC5D4YwHwYDVR0j\nBBgwFoAURJJ/8zXas7pkRYQyExjaT7/tGEMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIBYx6DWrrHL5XhPAYFGXP3tLOXUcEXX63BBAYV6GbVqJAiEA\nsJG1OBORfrXWIqMaUr1sBytm0BIAMuXz4WLhDWDf+ZI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbu2NjRG18ltayfHARhKfqZ/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODQ2Yjc5NC1iOWRjLTQzMGQtYTQyNS05Y2YxNTIxYmIxZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMkgGknduujUuGBsG4VmIWhCB0Ka8TMIvQlRpJXauP0FiJ\n75VM7T66+mvbNvf8/kZUN15+lE/nHnpMyHdHQQ1Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURJJ/8zXas7pkRYQyExjaT7/t\nGEMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaxvodG32aAXfHIhjZutrIndIIoVyWT05WbBnLD74UpACIF2dk57Ek55p\nokU/srDQ+OEPnuPTBKzUCa8yxmEKsnMl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAX4ZEH79Art2Vbb9LYevp0wNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM5YjM2N2UtNmMxYy00ZmYyLTk4NTUtNzQ3YzRmZGQ2YmUyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjM0MmQ1MzEtMDg1ZS00NWUyLWIxY2UtZWM2OTU2NjY4\nMjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl7Kb0OfWWsMVCD3sGp1lqywU\n75u2f7AzYeITL3kdeM9L82o+usqB6kjYY1O12dxpXJcVGrhpwnzEhHQdIN0+IaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUicmsDBE1Frj1sYpaws/FRjC5D4YwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA8rHCR5wbjRV6vu43drEPRspBgXKk\nZDz24uvXKjo43i0CICKH3tohi7S5bZSPrRfgTgNRCSK3Wg/5C7qa/uGIbtsr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc151", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `151` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAXIpe0sHWc+4z8XkvcD64/OVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiMDBiOTIyLWNjMWEtNGZkYy04ZTUxLTBiOGQyNzljZGMyZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFlY2Y2ZjAtZWUx\nYy00NjM4LWExM2YtYTc3OTNmNDIzYjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp8JnRCT89R9RZccUV+gLdDMe9WwzZDbiNzZ1eJvWYBNUXsKrYSIpTADQgonI\nUDffRJzsNTeHlZGJRHGw2NHsOaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Ya4J1yp3nJ9df2IVmBqpbwrHWswHwYDVR0j\nBBgwFoAUh9JIRehzAgj/hChcQ7NehwdAi0kwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBNUc1RfxBV0\ncegSSoK2siV2BocUGlWW6FaH4A6dvwWgAiBhyoXDknO/r6m3qVPw9h2DfhE/8CIx\ntXFF0fb+4H/FhA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQZvMq7I6maxyzM4V+jLH05zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjAwYjkyMi1jYzFhLTRmZGMtOGU1MS0wYjhkMjc5Y2RjMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATj5va3FHGXeHg5Oq41QhHlgwsAdHLm6+xSjSFWjdgsC68V\nkC3MQzfRLnj1lC5TUEKE/UivZVkVKFgiMX4pMdh1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh9JIRehzAgj/hChcQ7NehwdA\ni0kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALWZBP4k2jg6dc8EdrLqr4tzaB6/CoWupgeoGlYqEoQrAiEA/Ei6NxDU\nXfjmzhCNnjlKmCQT9RpJaa0Wof5gFNz5oF0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeax7MdXh3vqaukM0KNeg67lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFlY2Y2ZjAtZWUxYy00NjM4LWExM2YtYTc3OTNmNDIzYjRhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmIxNzRhNTgtMjEzOC00NmFjLThjZjYtZjNlYTgwMjli\nMzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm3mqK/VIp8aMARtcSrNZBJeU\nM306tqtrN11+Qyq1ek5z3dmubznU5J6t5xdh9y42PJqKX0qtbTODq8+yCGVxdaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/Ya4J1yp3nJ9df2IVmBqpbwrHWswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAhnj56ldS+T99pbBxKZL27WH+WQjhs\nDsNt9jAE8LoQ2wIhAPlSjF0YcaMCB2kxSxmPbtURHCKTkjzCp2Ja+XbrDHtz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc152", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `152` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQgQo1/xdhQsi4mBdtka5cUhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4MjA1ODc0LTlkN2YtNDY3YS1hMjZlLTA5MmZmMzBhNzQyZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTVhMWZiYWUtYTA0\nNS00YmJhLWJkZjUtNjM2OWE0OTIzMDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsf1w8HFjR+GC9BWbb62qDKBDAY+z1l/0AdxB/+wN8zYRfNnSpqIEeL0sH2qn\nDaCjeXrtrdJw0+TKxHWqLt3RfqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxAf+CXwqGs0qgIuystRwwvA1KeIwHwYDVR0j\nBBgwFoAUe3U0T+i1vlMkPpTKoGDUPcOVXKowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgOrPPFD6G4gUDZAjuD1gQ1SO9qrsMSBLrbWY/71aa3AwCIQDIKy/YbFAu\nFRH0Gk7fUEbSRstPY33W12uWbSlAxagUmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYRoWOgraaoBzkLOfE81//SLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODIwNTg3NC05ZDdmLTQ2N2EtYTI2ZS0wOTJmZjMwYTc0MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASglAu5dIBqxL4mVxNwvnloRl1yR9mixZzwQpiCJex+Qcfh\nPCXODssbHIk3OWVX3pAVqKG7ccy3F0B50RZNSxgDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe3U0T+i1vlMkPpTKoGDUPcOV\nXKowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaykFjQwbZ7gJZidx/xU3cYexrc/mUtm8UB13Q5MyL9oCIQDrNNihiZrT\nVzznjbDzSVCFlc00CCDFedzwrHbnxLf/Xw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAb8LrerwRlu4UXtlVRK6AgF6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTVhMWZiYWUtYTA0NS00YmJhLWJkZjUtNjM2OWE0OTIzMDAxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjRmMGJmZjgtMTc0OC00NTljLTg5YTctZWJhY2ExZDQw\nMDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPXn5y3YGrMHL3IRKYrjfdjrk\nmhBW7qgsD/DNJT53+RZ3xzxp3vGb0TrVP7IkeMWGwM5TghaMvaWU6U2eTnfSCKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxAf+CXwqGs0qgIuystRwwvA1KeIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBqdvhw24hbhBTOQHvo1qMBEY10pCV6\n6WG78+kq84RvBAIhAP1RLb0LiYQ/KGdS05xs9SuvB2ayLw2UcpDxrq3wfkeN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc153", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `153` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAZ5HKPNBMp7cB4xuFaB4OgApMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1YzNkZTRjLWE1YzEtNDRhYS05ZWUzLTBmMGYzYTVkYzRhMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQ4YjA0Y2ItOGY3\nZS00NGRjLWJhODktOWI3NDVmOTU3ZmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjqnuIMJxsmpCzNKCpEax/xi1s1hB9idxJ2cSDhsvZtmaioFq3qOI7Vz5J3uv\nZhZpa9s9Zi6nMyp5+ZXZtcoY7qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUNuloKNaQPH2vlJbWO8xDRjI3XQwHwYDVR0j\nBBgwFoAUFm1R/r1SycdA6X7BurjPA3YtTVowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgF+8g4YGmAdqEjcfjjjgLf8+vQ2+uOcFrlkK5V1s1edkCIGHowtnsFIqi\nX1Uj0DNcbnqz/C0SXSfp+fe+WQSHb8Ha\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf+vbifvM4Zlj0pQkgiTPZLXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWMzZGU0Yy1hNWMxLTQ0YWEtOWVlMy0wZjBmM2E1ZGM0YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNQZ54Eww/Hw6RP6gATHahLZ+0jhMFVWThz1ehbgagugEd\nhATmKwhr+JEGaxLjkPbwrG2ovavTCl9homtBrWYTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFm1R/r1SycdA6X7BurjPA3Yt\nTVowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALXYZzYzAmF0SVL/M7M3RKFJ2a/KzJ6apaH2UdMQVXwsAiBcuNj5B1ER\n6xfuneWKmtXkQ5Ln4vliEpfBC1B3IROQTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVEuNObttePXH1R4QHdOhAooMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQ4YjA0Y2ItOGY3ZS00NGRjLWJhODktOWI3NDVmOTU3ZmNjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDIzZjE0YzgtOThjMS00YTdkLTg1NzItMDk0ZmY0YWQw\nODVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8PsPEhmxlgO0OWeEUi7MAeCA\nnK00XSaB1phfCV9o7QfUErgwAJ1+pDgvfzQkimA70C/kTBoad+8qRuY25GU4CaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUNuloKNaQPH2vlJbWO8xDRjI3XQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBEzHZ0kYhxZLz5E3KszN0u2t9bm4p3\naW2HEc4ypNKEnAIgAv1ShXBmJX2nuhGYI2bpTwIYG3SAsXj4DJ8TBBAh4RA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc154", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `154` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAW9wBSfTpMU6wldvFDnxHn7XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlZWUyY2ZiLTc5NzktNDVmMC1hNGVlLWNkNTA3ZmRkNmZmMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgxYmEzNDMtNzlh\nMS00N2YzLWEwOGEtOTIzOTJiNmFjN2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/FLsZqMzcJgsBcECmo4Zv4KlYre8NwS8UndeAAYUbZmBBRykrzXxMeCOFQs5\nc/V2w3COc7/UJ3SnaC+zYoRsd6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbaGtTjod2fGlxzNuldEXCD6b4aswHwYDVR0j\nBBgwFoAU0DbiZGDElYQI7XmusCrKUpd0sIwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCyZuT6lTZupWayRwebHMGUuZudnad4mLkhkf+Di24ZrQIgHGpKdDla\n0gdive/elKPxZFq8S8wGPjXJrlBpQZE4nXI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWBkAXx1rMGATBq9PocT/dK4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWVlMmNmYi03OTc5LTQ1ZjAtYTRlZS1jZDUwN2ZkZDZmZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq1WwC4s0xr38L7LveEMi3zqk1wCa/j5X4ioBZ61AO3hJu\naIeIC5o6XSUFPr9dCbQncEJHXjGwvkZqcKCUhowdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0DbiZGDElYQI7XmusCrKUpd0\nsIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAvApfAXKA5w9gZWbBHqEHnQMzjKOUmz/BBxNKdFoRTsCIDNtycGr6KsC\nnowk5dXfMGZdLWDx1heSkumVIMC62HDD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdkn1zu/0nvGdC0M9pgcYCmRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgxYmEzNDMtNzlhMS00N2YzLWEwOGEtOTIzOTJiNmFjN2E4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjA0ZDI1NjgtM2Y5ZS00MTBlLTgwZWYtMDE0NDU1Y2Fk\nYTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPtsTUyExTehtf3eIr+aTS8T3\nTywu8BU2xrMCGi0YOPjxvC8CulfRLje725t4h5wj8gkKF7SmYyilLxDMR7WfvqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbaGtTjod2fGlxzNuldEXCD6b4aswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEArbHxJTCGK/BXjGyKvukattFIDAjR\nuLqEhcQXbBfrdVACIQDLpCYuuwFsZIr8bUJbT3puYeM9B9kB2Febw7A5d7qAbg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc155", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `155` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAbXe0uueoSnUWv2Id6hH/cqqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViYWZlZDc2LWU4NWYtNDA3OS04NjQ1LTAxZWY4Y2Q5NmMwMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ2YzgzM2MtNjJm\nZi00MmUxLWI0NTUtZjBjNTExNjAyMzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh0G6cRh2Mj2lrFhnvGXxIbwOPn+JHsxyIgPMcgozDJL9KBfUO6GDfe1JUIP6\nIDkTSzT7E68O5Sqn24cyM/Cd86OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdgZGZHPPRaH0xl4zcDk3NCHL/PswHwYDVR0j\nBBgwFoAUpKmCX/+TCI6WUeJwdbIT7plld2MwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIA1t3EC+Yy9kIRGDN+Ei/93SFSYtlaIg9OPjWu63\nq6LSAiEAgY1vaFUVmV/8GK8l1RQlYSfuBKV/xyexR6rAAHo/H0Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVhNyunI9inWY5+66Wlh3TMNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmFmZWQ3Ni1lODVmLTQwNzktODY0NS0wMWVmOGNkOTZjMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTDn6sEsoo86KFoUcRQmSP98nl7WjvheBw3tpQFF75VJlv\ns8P8/JJxRZQMYrVqvcnqzsploB5+fRIpnC08xtSXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpKmCX/+TCI6WUeJwdbIT7pll\nd2MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALCEIkTclh5UuNzuDSe1GN39VQ2jnntO6S3m4V294VegAiEAsRGmb2D+\nYbHP1E/mo0J89Af6iOMlHSY1SlnhNgAyets=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVgbsyMeHkbLQyyUwHsqdO6TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ2YzgzM2MtNjJmZi00MmUxLWI0NTUtZjBjNTExNjAyMzgzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGU4MjE4YjItNmNkOS00NjY5LWE3MDEtZWE2MWE0N2Qx\nNzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9MSrDASQ+eRSP4NoyVYdJcy/\nQN2Jj/ab7RW4J6M5PtBkDORmbTkI54Yn0PWUbmb+m5e3ml+YckopDetqK/zIDqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdgZGZHPPRaH0xl4zcDk3NCHL/PswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAP2UFXsJA9E1c5RGVv0hU++0aXoid1\n98tE/0Sy0EIrLQIgdREEwHvmhSuUiXBy6293E2A6JtCabrxLgI8CBq38WqA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc156", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `156` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAf4S0bHmBDyl20zkavhdsHG+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmODAzYzA5LTdmMWItNDgwYy1hZWJkLTBkOGZmYWI3OTA5OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhjZDY2MGQtOTQw\nYy00M2EwLTllZmMtNjhjNTY5NGE2NGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdmphsRzZFMMAhVStp/lZVTTOduAzwlY5ekphJV9CnPkl3k7S3ZtENzb8xzkg\nIgAA2v8BDlfqDuwh0BTl+xhXfaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm5hgh82fq6a2Pv14tHWUWkOAbqUwHwYDVR0j\nBBgwFoAUXTtoUXcNhrOSiEswJWc6CkXOmb4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDqQdaiNc6e2TtSsEedtf3EdNlvLw4eXQX2NmuB\n4g5jRAIhANKJj8xRbJ7e1CQN+tIt10M3yu/Zi5IsIv+Mdpz3Rz9V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARxmAex1j8a11U58QHdxJBNSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjgwM2MwOS03ZjFiLTQ4MGMtYWViZC0wZDhmZmFiNzkwOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARt0fJ8tfxCn7Js1MuJhrA/I5wVNHNOGQo2stlao/aPmSJU\nwWmH7PUnGOKvBz0aTkwMcSadFazQU+Tx4TdN13NPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXTtoUXcNhrOSiEswJWc6CkXO\nmb4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ3UTfgvu04ABsqRDb0d0lb8sYbrgcWTj0ku8b7wmFCUCIQDjSREMbSgU\nOf4HOszWvOcOTGttS2ddygGw8qJQsz8W9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAV6yUkNbzoi+mMhKL9ZlDBSUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhjZDY2MGQtOTQwYy00M2EwLTllZmMtNjhjNTY5NGE2NGM1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTNmNTA1OWYtZTA5YS00OThmLTg5NjQtZDA2YTgxYmY2\nMTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGkJCNJ9OtRDgYTxStv1mQFCb\n3ec7N7wkFY4hiewtToZ6dFEWSGFCJEMwB/gEeEM0nZEE+ba5uOrnekXh9YvkpaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm5hgh82fq6a2Pv14tHWUWkOAbqUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAj6pPOSUcBrjSYM1kXIv1xUDzIIAo\n1kP74fFOrPwGY90CIBF+csyccFKu9jhI0kQI2s8w1ThnLFpcR31rhlGkJmjI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc157", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `157` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISARaLOsKTkg3VNyUr21wBuYKiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0NjdiNDE2LTcxM2ItNDU3NS05M2IwLWNhNzUwNjIxNWIyMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM3N2M5M2QtMmM5\nNy00Zjg5LWFmMmItMTU3Yzc2YmYwOWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKD9WzdKMpXVPzFkkaagnNRqGyJW7bElKNzYIWYpygA4U1hLA56wZ5fLGmFOS\nLnO68l4wvg5BSDLo+rtq/fZrTaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUers24tXIOcHqDd+q7d5xuU4cUZkwHwYDVR0j\nBBgwFoAUXjLkX9hAsjQCybgvzgRwzmNkRH8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDGk0DgAalKMPOkZFn0nK2fwNXijduXqnnpGsWl5uea2wIh\nANKVGoPl07180t6g2tNlkgwUZvUn3WES+sdWIa4Z6FNJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQWz2MNNN8W3h6USLwoQ+QKHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDY3YjQxNi03MTNiLTQ1NzUtOTNiMC1jYTc1MDYyMTViMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6+ibKpi+ezamFowBC1TFunDp0J+9tSfuKjK4HT+/YYIXe\nqYm6gV1zBxnmUKNLB2+q/Yc3Hvo3ptj15Cp4lqcAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXjLkX9hAsjQCybgvzgRwzmNk\nRH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWG1Fa0J9i3aqkDuOzcMw5JTmy06KrhEsnGvQKa5ql3ACIGzbw1qj0/aP\nc2lhSH4hmOZzaAmyw/DMbt8czSG84VF/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQFY2Eo9rZqkvR2wbXtVWzwVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM3N2M5M2QtMmM5Ny00Zjg5LWFmMmItMTU3Yzc2YmYwOWVlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjEwNmZiYjAtNDRiNi00MTkxLTg4YWQtZGRiNTlkNTBh\nYjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl7iccW14SB3bFxllugGln/3A\nJUa/HTuCOwNif4Gpj2J3ElQij7gLA0UskW1M3WMhuACJoJCsMDwqdphQtkKud6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUers24tXIOcHqDd+q7d5xuU4cUZkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAinCsjmamj6WytcSy9Mezs8Hl4s58\ncuqzq7tRQqcjCIICIQDspXkFWi3iLPx791lSD+wBv2m4Ire9J2zQhd2pFK2UwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc158", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `158` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAemGLJv1/CKc20DG5NCtosF5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4YWVkZDhkLWI4YzctNDk1My04ZWQwLTdmOGJjYzQ3MmVkYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODhmZjBmNzUtNDYz\nYS00NWZmLTk2M2EtYzMyZmZlNDRkZjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGihyQJkG/LHrdyPRToGheRZ+DRqmpTJsIJJ5o4XKwYmNAU49NVHCul/nTSgK\nnmd6IIAR9uKt8X3s3KiAddiTvqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjViHJpWPajqFs9JDAUpAcZpKbMUwHwYDVR0j\nBBgwFoAUyineNdb40d73GEqMq7uhFLfx5n4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCICcF1Ch6HIiK4RdcxlSzzkdc2BbIxzv9\ntzhIo8jUuy3XAiEAohuUOuF+PWb1U9tyZh6jP6E6wI38l4RY6Z2TzZACUWI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWdi2GNBRDwHiilxhpos58+yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGFlZGQ4ZC1iOGM3LTQ5NTMtOGVkMC03ZjhiY2M0NzJlZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASisHZfqVoUxnL67QXUxecmFYh8HdIbVn9I00QesD3tgP8I\n+GUd5mkaxjHCeMYThxsLJGSyPCVoMRGX9fvGJu1yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyineNdb40d73GEqMq7uhFLfx\n5n4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIYEAWeiPQz1o+kor/NXC+i+YmeQXgJTeLtOYH4aXgagCIGENqajvEpq4\n5gJMUvyB5/O2skYnMaUH/iNTN6BqvZkv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAelvzVBlKNmtXeXk4XA5tjFCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODhmZjBmNzUtNDYzYS00NWZmLTk2M2EtYzMyZmZlNDRkZjE4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJjZmQ5ZmMtNmU3NS00YTMwLWJhN2QtM2NkZmM2NThm\nNGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErnmQc5J/ijjrvAp5ZkCmlgkd\nyVgy5vAP3YfxIl9BJO3/xrHO1d3vfNCz0STvjFnP2S3clMG8pVkrG+G3KTJVTaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjViHJpWPajqFs9JDAUpAcZpKbMUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAqVxP2YAXtMwtDucpW0k9Cjvtl2F7\naX/ytSoZuY633FMCIQD858vD9TAAWtcli5DJHbd/Nyfks27lxjgdUPCUPTVd1A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc159", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `159` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISASyozACUIbdPopXCOMlI6WuaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0YmViMGViLTNlMTctNDY1NS1iZDNhLWU5YTFjODU4ZDE1MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUwMTJkNGItZmE2\nNS00NTAxLTk1YzgtNTI0MzM4ZTY3MzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED9ZDNT43QIwqCq+Oqh+LsQAn56aeK5WoheL+J+uvfvJAjmIHqPXlfsdrnhL0\nCZjbo/dYbwd6BwMX4H9mgwM+5qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhGz5gMI2wQJKf0E0yZhImBZnOjIwHwYDVR0j\nBBgwFoAUy7PeOx+a8c8imXtJvDRnXwdonCMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCJUB/bGfoLy/ZcDNezz/jHmka+xoDp\nL9C9h8q0EDYWnwIhAM7llEN2q8oVz0x/+Kw9CBeqHm+16siJ1jGEBt2176Hn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbY3Wgb+Vfm5covTo58ZqBi8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGJlYjBlYi0zZTE3LTQ2NTUtYmQzYS1lOWExYzg1OGQxNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKLEa2rpgocN8TaRCoKxw//CpOtoRmcdN2S8ncQg/spLit\n5RYERbGWzHAHk4hzExI3gEYfoPQoD4nB7fyjWd+Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy7PeOx+a8c8imXtJvDRnXwdo\nnCMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC2aHttYpt1KeosVVxUdEWYBIGG03+g9Ytj7st6KrposCIQCogb+9t1o5\njSqycGk3FI+mJe4p0Yv906v+f+6e/3ZU3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAR/EA8NJzDGp9LvZc0klWsZJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUwMTJkNGItZmE2NS00NTAxLTk1YzgtNTI0MzM4ZTY3MzIxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTJmYWUxODMtMmEyMy00ZjU4LWI3YzUtMTE5ZTMyYWE0\nYTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhNqPWkrb1PAt2YjXOPACadso\nPjv88z8nqCvd7NVyQs9gbDRXbtfBAvuEWwjsiAq0xCwEuT2iDgx9zEZJvMBb46Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhGz5gMI2wQJKf0E0yZhImBZnOjIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA+7YkAJVUE0UE72EVtAp5igdkSZT2\nR3bufowFSIuJHiQCIQDh9BVy1XjclHGc/iVPR0DE9aBpnDn43o0OykI3yRXkWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc160", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `160` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAeg717io9r2kZ/5gfKz4xzcqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjYmY5YjBjLTJjYmQtNDY5Yy04NWI1LTkyZWY0ZDg0YzMwYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFkNWNhYjEtMjZm\nMy00NWVkLWE4MDQtYWNlMjRmOTkxNjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVbGVHdscN/WhDAWUfmg3Pi646pXjSOPB/F0LhwJCnPyJAvRr/ZpLsmDe0XXH\nw8gyPp3F8gGHLD3xdu6sfZ+ig6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKdaurINfwtEsyEFbYnV4RAy0rPwwHwYDVR0j\nBBgwFoAU33nYQpPff20spBKctmNBUydE8AswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCw4oVzhYFU\nEQeGid4OD+3as/7WpSdRiV41w+bRNY3pSAIhAIlzlQ4DJSdqevkh5jEV6pEwKkFO\nvwgnihyRdo0mmwec\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY9OvJJKCoGkcKAmpEV2PuGiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2JmOWIwYy0yY2JkLTQ2OWMtODViNS05MmVmNGQ4NGMzMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/IHTO93m3gKES5TUJI4lMVmvtexMF/a1IafdldVkq7k86\npLVG9zBpAr9FSdQ/N3OeAezkpUKFke6eEAD/IXvTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU33nYQpPff20spBKctmNBUydE\n8AswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAORIo5XWdMwx+kBIu+wJ4xqlXLhVyHvXlxtgIFAoE7v8AiEAgGhq8jDt\nq2VwKGDOvwgJ8vm4DfCU/uGjdclZFwEkBpM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQw6yn1aagJypIjyfFHyLMqbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFkNWNhYjEtMjZmMy00NWVkLWE4MDQtYWNlMjRmOTkxNjE0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTg2ODk0Y2ItODllYS00OTZiLTg3ZWEtMGI3NzgyODQ5\nNzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwdToOxgxibw6o8vvpqirXBsE\n2VrJuMJL2/oI8Ef1cYzKLUk1ZVAS2JG0cCv8kZHun/EKqDX2F49HHGk+3y0p5qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKdaurINfwtEsyEFbYnV4RAy0rPwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAmE4xsmhSJvJJxTPNRrAOqByuo3Vl\nqpXIku4N5ldBYGACIEsNC/vrIz+jc8SJ9mILTqdsLhpBMlS9pSZ5oZFJCUuT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc161", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `161` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISATHn5gHBQ1c7jBCaSIqkUUsPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkOTljMDJiLTQ1ZWEtNDJlNC1hNTQ4LWQ1ZmJmNWQwM2Q1ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRlZTY3ZjctYjlj\nNi00YjhmLTlmYTQtYjI3YzJlYTdhOWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN3BeEdzyXCZEawWb8lm4SHDyCYdYqROCpMPj/k4U18sb6W68vjp6WqCXfLzF\nlj6FrI/HTYt8Jl8xN47ncbwi2KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsMi/o5LeoP4X2IxsUSEtjA1sPrwwHwYDVR0j\nBBgwFoAUvsiebrTCfM6uJ99yQe/vTIehxa4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAKLrmf7rT2MFkFFTFVZq8XOW79dyDvqDV7qqziec6CXFAiEA6rGgR1/8\nia+Vxo3yhupWH8Vj578kT+07Nc0EQwjbu7w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARhYm+izDWSTmTfhs3Knl8w2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDk5YzAyYi00NWVhLTQyZTQtYTU0OC1kNWZiZjVkMDNkNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEskwTcRVa7ck/Zd8BSWEtyYeeExDm0y7/KQtjk8bQOFai\ngUOCJOw2x7CUNH28BSwuBnq8cycWuJv8fBn5Xspno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvsiebrTCfM6uJ99yQe/vTIeh\nxa4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdeqRhGuT6pmr50MLkscN0k7WfodcQTwDHvexCgLLGP4CIQCkl2UD2b6W\n/vh09AWrNE82RDnVDWk6oZbyOFBTME7JJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAS9EH4VvCMxAghbwnGnCrdIyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRlZTY3ZjctYjljNi00YjhmLTlmYTQtYjI3YzJlYTdhOWVlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmMxNTQwYjItYWZjYS00YmQzLTk1MTItNDU4YzgxOTli\nMWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWPViLR1qgcsHcp2Tmp50QhPW\npj73sOhrlR8HUi4YmaH4XMAvqdj0hNDNKFsq/UK4GiYMLGQ7yWKKjghTmU5y/aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsMi/o5LeoP4X2IxsUSEtjA1sPrwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBC7812PzF4STv5w2isblH2rP2wxhyr\nEvpUWTAHtHIl3AIhANo4dog7bbqxWeJ90v40oaZXXa7p2hha950hS3/+HwdH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc162", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `162` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXXXrPyrpQmIJUvaFiRjmRNHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ZWVjMDI4LTFiMDAtNDU0ZS05YmNmLWQ0MmFlZTQ4MTg3MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVlMzgwZjctMjY3\nMC00YzY0LWIwNzEtNGM2YTQ3ZmViYjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr1dXejwdEe+kZIV89hyM3X857l8ECHOFqC8Vvor3VIO3Ucyg1i7JyG0/pY4i\nlwF9c77pdAfXv7r13ypwwvBgi6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8HA/OH0zuyY/dvbFv1HBl2jD+WIwHwYDVR0j\nBBgwFoAUk3VDBeuV0Y08dr/fKKABmDURq+cwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANAntjcyyLQdhvUiqMk1bLZEk+ia1U8M9Xqsz7ppbY5pAiBDUJxFGWrp\nRTY0iyEdsjMntncWhwjQ8KkVLy/kFpZswg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYa9cWUNxRcUB3ZE3e9yCLfbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGVlYzAyOC0xYjAwLTQ1NGUtOWJjZi1kNDJhZWU0ODE4NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARa4Jf9epZhocH3uONvtTtPSnK0h9vc+pLsWe9sMV7Gd1un\n4b5GvsYK+5/yuUMC5Ib5wcHMhtR4P1mQB3RlS3tFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk3VDBeuV0Y08dr/fKKABmDUR\nq+cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTBxXUxsSfnwEcVwP4NBaJc8/mBBEhPR6CJYv6pWPtSACIQDspQtQPt6F\nXpebEkhb/gCozXTemlrhpuEVPPJohx7PqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASRkPyFz1rXU0v+dy4k1GTyaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVlMzgwZjctMjY3MC00YzY0LWIwNzEtNGM2YTQ3ZmViYjkwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmZiNTFlN2MtNzE3Zi00YTQxLWI3ZGYtM2QxZjMzZTdh\nOTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFVb52o8sXyeZ7tDTX/TrC7Oj\n23+MgMs5HJCXK0OGOQ835N8vVn22dAN+dffYEt9qOcGJy1L4N5wQlxK8+zmeQKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8HA/OH0zuyY/dvbFv1HBl2jD+WIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA5QfCCcwmp4hln1ZFs2wWcTaa5i5ye\ner89ll3DvGXKpAIgLb8qRLBSblebDaMbL9tiYSINAI2jiicT+bkb8bED3RE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc163", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `163` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAUiioCwmVxQ7E//k1qXYL4wrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5MDgyNGZmLTg4YjktNDkyOC04NzU3LTViMjJhOTQ5NzRmZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDYxMzEyZTMtZThl\nMC00MGU4LWI0NzEtMTFiNzY1ZDQ2MjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsu2/bSJpO5quunoK3GcybBOV8a9Ryu+WHZtI/eAy1S+NAfVWEnwlDmSbK2jd\nUzB9ONb2tR/dgDtrtzLiy0p1OqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZwKIP2KGGzDqc+ll8aJPm3lMppgwHwYDVR0j\nBBgwFoAUvLD30/MGaIzbpXHUzligBb7lIs4wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCEDlvOTncRjLvasre89vVI0UXJwQca+asfma2bSivdtAIhALszEkSH\nJXiHpoCYmUwUed/D7He70t35cIbBDrIchKtW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc534znN1XRQj9iiSnyeHrmNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTA4MjRmZi04OGI5LTQ5MjgtODc1Ny01YjIyYTk0OTc0ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTWRgOcGubT8/AaCjmIBvkA2GsdUAkBFSK0OgCxq6tkNqe\nVpGHlO9/7KgN9DkJ30RT84+J8TcdiDL2eKX8aq45o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvLD30/MGaIzbpXHUzligBb7l\nIs4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKk76ZN8g6xo4mpGlQPme3gcKluWMdpfLyWpMDtAvuY6AiAnYk1qaMKp\nNzpcXOZ966XZmB3hMEt6vt9GFd6jyPXNsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATkk1w2dys0ms9wbZeSFqObyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDYxMzEyZTMtZThlMC00MGU4LWI0NzEtMTFiNzY1ZDQ2MjJhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjY3ZjA0NDMtMTc0NS00YzhiLWEzYTEtODZjNTI4Yjgy\nM2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtuZGf3wRTDoFZzDXkXs3D4OQ\nRqsLaUXzKF+RqRsWovVpPYapAZqk7wuP8kUsm/f2wjTH4fYVoY7yiUOOBnc0K6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZwKIP2KGGzDqc+ll8aJPm3lMppgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA5p6sX+6nLnaPv2JAajJ4Tstc+bq/\nCzV34VnMIaYL7NcCIEpYgHkjYXQElWLUAayK0JIsOkI273Smg46STZijwnaP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc164", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `164` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISASeH7gsENslPsAwQ78jU9m2rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4YzVlNGViLTRhODMtNGZjNS05ZTc5LWUyZjEyODUxMmRmNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzczNzJmOGMtOTM0\nYy00MzU1LWIyOWItYjU2YTA1NTJmMWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl7X5+dBEN+O2USCITzAJqEHM3kCTwoYB3+wdL5t4yI6AdubE6UpzVs0VvBoY\nYgtjIsBjOwXqKIbdNKcqFY984aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSHUsNEGM2YkPLCUlJhBk7g19868wHwYDVR0j\nBBgwFoAU+IxoPIhqVPEiqmxrHZ8dq4TWb08wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIGPvsUK6vuJXJPs/RO6ram2McNqODGH3WiCoaf8o\n9l/BAiA5Z4OQSJLU2zAg2e3GsWsaqBhC2P79NO1DubOnvH62+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaCOdfOpLZEBkYL4N68Hq3pFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGM1ZTRlYi00YTgzLTRmYzUtOWU3OS1lMmYxMjg1MTJkZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdDbfEmqYxJ/JENbO8e1ncYIg+vbNrG1hfFaRJadtUQHpX\nBIXvtsHzEZjpQkMiJvzxAMvROCefEXjGalXw9uteo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+IxoPIhqVPEiqmxrHZ8dq4TW\nb08wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIjcDziGrMCSOsivkpH6y4Gr8jiWbYoSDV435/CV9DYpAiEAy5khN9xX\nzzz+ieMd48LUe6ZqjNB6rQxypYlamVPgxyk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASCetygFzY5O4ijKUYrMY2STMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzczNzJmOGMtOTM0Yy00MzU1LWIyOWItYjU2YTA1NTJmMWZjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTA4OThjNTEtZjcxYS00ZmM4LTk5YjYtNmVjOGY5ZTEw\nYTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmESicGRdnB+jEOA4QlhSAF9U\njRBy2M+EzJcfqW6YKnPfxS9oWTfgelsueYbLvl8Ei9xi//BB7M5Vuvnsn6mpSKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSHUsNEGM2YkPLCUlJhBk7g19868wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB0XYpCq2A34zq38iMpekDtLFqK/fWQ\nr1zVJIpFcOLhvgIgDqfNApCkW2fg4eXRjn8qkgeE8rr1aJZWjW03AHHAAPM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc165", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `165` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAT9uzMADXSo4ukO9b+pfmwiHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxNzMzNTE4LTVhNjEtNDUxOS04YjlkLWVkZGQxNjBhMzc1ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDViMmI4YTAtMjFk\nYi00M2ZiLWIxNjYtYmE5NWViYTg0NzViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Z+y3vudi3ZZfHJG6DXBhCwSXPhbAi7eje0dwU35CRRZi17MM1v08ICsTHkj\nUQjTWjLWdIqjGgGUFwt834spj6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd/Jt7plZ+9wNnKNOMubQxOhqtMUwHwYDVR0j\nBBgwFoAUvMNjRsn4ZOo19dFeUvAAIncru5IwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCbVpe/c6UiHvXBtFAfrq1DFd915O4c/4SHySKq\nnG/8OgIhALRwoSJH0ba2SJHE/6awh5/ZnrwNwWZXvqI7oSQQvh2K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbmjKxeNbfD2T0wnJjVPadMPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTczMzUxOC01YTYxLTQ1MTktOGI5ZC1lZGRkMTYwYTM3NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv5RHujAdqI+9C0i9/39+7YuakKkif8THzYHiEYPjipG1I\nBrpFOiKIj6flxVVrBd3Vxdg5c0vIz7JIzdcYIordo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvMNjRsn4ZOo19dFeUvAAIncr\nu5IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI3VSsPuL467LtSyb1snJB82NMcdlhXMumpD0iRTH5PiAiEAg2Vw7SJI\nDetP0oGrmx5KhD4xyWTsUbkIho7WgW9Wj4w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISASqYEKd6ddnw20BUw9dccoxmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDViMmI4YTAtMjFkYi00M2ZiLWIxNjYtYmE5NWViYTg0NzViMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODQ4NGE3ZWUtZGUyOC00ZjY1LThmNjgtMmFkNGE1YmMw\nYTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE253tsdV+c2Em0rqfryq6libb\noP/S0gsLYIbCQDdb75Zxbt29NcEdDPqr0MNj8g63ygWWQZsU/5f3PhsQbgAuAKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUd/Jt7plZ+9wNnKNOMubQxOhqtMUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA4OtGHIEaf39/eYU9sdXWF7kvbQMT\nMIwPMhkkHA22cf8CIQD14lq7as0OjQ6E1LRM33Ty7quxommSA3DL/O9h5iBO4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc166", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `166` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAaFDkOxxFl6bx4zpCCn/VRbxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwNDI3ZjAxLTVkMTItNDczYi1iOTJiLTc2YzljMDA0NThkZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThkYjllYzAtMTM4\nNS00MmU0LWE3MWItYjgxOGFlZWY5NGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnuZzHbnV+dt5qlS7xkQnQVVEVKNC9gkobF/Nv6684QPisjQvzibZdIyB7bY6\nOUURPGg+zwcsU4nUfiFxL/7jeaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURN9DHhW1qMm9+plAgpxrrGeeEk0wHwYDVR0j\nBBgwFoAUKmewuBvFy28pYSQJ6GhFH41AzE8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIFsCboGNVVmW8FKPlnHuY/2HnyA0oT/qujABMxmZ6/zEAiBH\nySLtFwEhuQE1sj5e3A8NbLNsxtyW63bBerh/vRbJQw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfooVEd5T1MbFduYqv3Znqz8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDQyN2YwMS01ZDEyLTQ3M2ItYjkyYi03NmM5YzAwNDU4ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARa4zqkvdu27EOaajkEKb+EQT4etOrMbm0OnyuS9DkktzB3\nu94YLGP0jd4n0R5ABeuTh8cA8ZpRC1CJ13/6kZGgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKmewuBvFy28pYSQJ6GhFH41A\nzE8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO9a6WD5pMIf97uzQsLwCDdCoB8hsKrDTOcrBlDD07ZwAiAhHsvWhilu\nC1b46IQ4YRXgkP6XPCLV3lie+s4OoaRuyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAe2FeIzS2PAQg1hfk8lYwyrfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThkYjllYzAtMTM4NS00MmU0LWE3MWItYjgxOGFlZWY5NGIyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWRiZGZhNjAtYmIyYS00NjQyLThiYjktYTdlNmRiMzhj\nNzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFv+FVBfupomw5tIPqBW9y+1g\nb9bCJlgIyeamrkSI2hMr8anCdPWNJ6prCpHZpFb/yl51EnaMsjlC1IKqBxYtMKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURN9DHhW1qMm9+plAgpxrrGeeEk0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAjLTgT+NEBjgBYVvsnV68Bzx0Aiyj4\n1d8jFlObe8M1eAIhAO+kMQovfEMAbfoTrZzerqDrE0xRNz2fPPO05hF8Gs2l\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc167", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `167` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQTWA3KSLcrKKXjbEfBT9JjFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNmU0YTMxLWU4YmMtNDU3NS1hM2Y5LWIxODBlZTMyMDk4MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU4NjJlZjgtOTFk\nZC00NTllLTkwNjgtNjJhNzYzN2U4YWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzkVAzEmicl6jKMUFcvp7lmDjJ3zXET4E9K7BbAWvVFoP9vNpSDHO1jdXxvij\n/YoK4nc/krBY1aKsPbwK4o16VqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgCK5Hv1ssq032E+QO6Y4pSE+Ir0wHwYDVR0j\nBBgwFoAUpFy2hIfC7mv6ZnSLg5Us2AuW9MMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDxZ6X94Iu2bBFnusy5JdnM6X4bDR6H\nSIm8hCfXqHGLtAIgJ7fTJbds0OTsK4E0aTUb77i36qO0V0OXl9Qok5eOnCg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdRhY+PUvhkMqNrEpLNQlhGGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzZlNGEzMS1lOGJjLTQ1NzUtYTNmOS1iMTgwZWUzMjA5ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3n+x47iskYyODNE/vpdpIk4aoc0aXCHID/0Pb4uB7oyaU\nPHRoO2bmM2hfhAV1KKbMlq2dbPXy1nRXQ7PAHnlwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpFy2hIfC7mv6ZnSLg5Us2AuW\n9MMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNelyzMYEGSnQQ6hkmbvwNtHbvb+2LQFpm/Yxca9xUA8CIQCz/t89nB70\nXWOlrsYUXKrRr490Js6c0JrdRhtSbu99jA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdl4koq2R2CGsGTluhnGcN61MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU4NjJlZjgtOTFkZC00NTllLTkwNjgtNjJhNzYzN2U4YWQ2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWQ0ZDk1YTEtZjdkZC00NjkxLWJjNzktNzNhY2I4YTFk\nMThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3h7yRNGpV+EJCC2SswIDdDrZ\nABrquW7bM5yvDLVyeyJ+uI2c85UAPl/snhbHEmBPZXUDK2k6SXJuih7NrtAHcqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgCK5Hv1ssq032E+QO6Y4pSE+Ir0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBy3WDIzjiKVtV4YMHfG+RuTAMe2oZw\nfVjSzi3HXHiL8gIgZQi11QNBzC/F1RmqFT+7FNuKL/D8Ihl0wLQjlUDZy6g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc168", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `168` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAXZB834Q+YvKJPcCF4vVU/wQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiNTI5MmMzLTJhNjQtNGM2MC1hZGYxLTllZTdiZWQwYjg5NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2IwZjBlMjktMzk2\nYS00MWNiLThhMGEtMzYxZGY0YmViYzcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEageamUcQOnbvS+rgK3aYmjw2EiyozEqUKxsLw8My8PomNSuh2Qm5bEw8bX7X\nFXYWh4g6GUKzI3/ap8SUFNaEhaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqRiO0a13gmO++vcLj0X0QLi0IoEwHwYDVR0j\nBBgwFoAUUA19SWqCqop7PuIXIkIewy9HzdAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQClsebXnZp3TjolgFMJ0Ctl2dt6Jn1N\nrIEFdY38ks1JtQIhAKTZnaGuS6f0z4o5YIxM2z2cgPQG6a71ap1Q8yq7hQ9S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAStS5KMx2r5xlQyH9DpO6W2MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjUyOTJjMy0yYTY0LTRjNjAtYWRmMS05ZWU3YmVkMGI4OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+ZdSoPF8iEBqT6/8ELD32RHpY8zDVHP59b/X2Bmb8wn9D\nt4+PYupPF1HX4WqWKOLWuW/IyP0Tud3lSs9418pvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUA19SWqCqop7PuIXIkIewy9H\nzdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANIreXq46Vx3TlUNgwKVuW/q7NVxlO16AhjObAqH4jFSAiBWhQluvHkA\nuYpNGyBySsJbmGbiuA5piZZgmA0E7r4png==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVtTlBvg2t0X1rm2NGcwLfUGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2IwZjBlMjktMzk2YS00MWNiLThhMGEtMzYxZGY0YmViYzcwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjU4NDM1YjUtOGVjZi00ZTgwLWIwNDUtMTlkNjhiZTY0\nNmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1YWp+hNWKQpHSO2ozde2ELTT\nNu6tUSUah3Dz1E1W70UkK5uN9bPuQoeGwh3KXfyrToxbGirFqMrg/T1Ho+OLoqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqRiO0a13gmO++vcLj0X0QLi0IoEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA/zNJG7ME9WDQB5ph9tDEIh9m6QPB\nCjELKZAJvl1Q9OoCIQDsmEb6SU0mgk+trA0RJ7QLmWiiJO3Y0+GcxnGLCZoZ9g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc169", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `169` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWzZNjpLXXEw5fXmGiO8ycEaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NjQxZjYxLTNlN2EtNDJkMC04MDNjLTEwOWIwMDk1ODNiYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI2MjcyN2UtNjUw\nYy00NzNlLTk0ZGMtMzY3YjIwZDkyNWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz2/ZvbRKVEwWXgxUqZVGTwTH94jRbJj7/0P99JzY6fV9BdZEe9oJVW8l9yQy\nJW2F5KeAZpc5sI/wkzefEJSqrKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGySFx/6QVU4AqffsuztPEtLzTPgMB8GA1UdIwQY\nMBaAFAQPa64AKtHQdS2u9Vn0R6VrM6IoMAoGCCqGSM49BAMCA0gAMEUCIBWumLqN\nNBbuQTSyCHfYhuCCBcZVNolwu9zzHC1qnsQOAiEAuoRPHlbRy+IK3v3Ntqpzdv4y\nzeES6QcOTxcE3F79AKY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT0Iq4YQmG9EZBLQK4owim5nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDY0MWY2MS0zZTdhLTQyZDAtODAzYy0xMDliMDA5NTgzYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUpkiBAbXw87hV6Wy+IKR1GvdOFIhjhemcJA3A21lbgA4y\n6G9Q4mIOt8Uhktcd9L7UqpxOrvdIClN3JBTNlIRGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBA9rrgAq0dB1La71WfRHpWsz\noigwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD3plutXXts8DR8fitTjI3UGVTZMukmaeVY5ZkYZ5vzkCIQCQYlck984o\ne990NIo4+zoET4mgaabz4pn4ChJxaHG3Fg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAeOw2gOz87BUKY222qEpF/UoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI2MjcyN2UtNjUwYy00NzNlLTk0ZGMtMzY3YjIwZDkyNWVlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTAwNzgxMzUtZmQ1OC00MjlkLThlNWItOTVkZThkNTQ4\nMzk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoaA0+i9WnFKqSUz4wYJgLSGE\nWdfngE3qSwsNqxZib34hzd63ta7MMX3OAlHfTedrQXRl4M1tf3+8MiJQ5rSs06Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbJIXH/pBVTgCp9+y7O08S0vNM+AwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiADLcTeyb1RXFMJHsczLtn2vSK9ionP\nLeAOAFa2hAmMCwIgYuL98IpxNv+C9OJKgT0Qn5Z92oR/FfDtcmfbL85pyJ0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc170", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `170` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISASda8Rx+jWXhbyo2DTgb+YQJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkMDZjNzI3LTllMjktNGE5Ny1iMThhLTI0ZTY0ZWUyMjczOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc3OTg2ZjAtOGQz\nYy00MTkwLTg1ODItYTYxYzI2YmNhMDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjptJL1pVIwz+PDnrnUWdLamyoSOBNc9cfySK6VV+tJJqlpY9Btw3Fs83rBiS\nFI93ek57zPEzuHzccBeATEaqCaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJQybtAhUzJ+drTsoH4w2mVitW+zMB8GA1UdIwQY\nMBaAFAS1xfLkawPl+xL/z1xfNj2+1HSUMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAwrZwJoII9YfHQjnH5FUoYerUm//eZXSe\nZXJY4f/iRp0CIQD9AKIhZ2esp2NdxQKyf0FKpfAFy1ZfbwalEep+IWrcuw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWnO2jCfB+9d1aiCsZwlfc23MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDA2YzcyNy05ZTI5LTRhOTctYjE4YS0yNGU2NGVlMjI3MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdCxfanOBGOeXgy3z+tAINgKbJ4eFXV1v1BnICe93GpOla\nAG2pXjHzwvYMduESWaB8kPkPi8kAFH8voY61cw+jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBLXF8uRrA+X7Ev/PXF82Pb7U\ndJQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH+7KN2JBU1t8uSEpETVFML5XqoKdrs1M5cVrFVkcD7sCIQDpgMLY1xo5\nHzqyg/ZQZJjlIiTpaLSNpBFdqC8tvrhH+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWC1L7EpKQzKusX7T557daDmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc3OTg2ZjAtOGQzYy00MTkwLTg1ODItYTYxYzI2YmNhMDUzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDA1M2ZjOWUtYTcxYi00NjI5LTkxZTQtNDRiNDE0NGM4\nNDdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpAK6MqWP5qxAr83o/i6ahdKk\n+OfcTnzsSsHn5NN092qMzuSIHRowUuoUFg93SIt8iQP7HR8JeBIL6uUmF6r1QKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlDJu0CFTMn52tOygfjDaZWK1b7MwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBvqw5JILYpbM6GEZpkQMs8pgY9borw\nynJD7IN8gHF3ywIhANg+5LEeAmSXM9+jRELiou2c0CZ/+VkjggXGSPV48qcN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc171", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `171` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAfjciiLPLhRwmwuTv0RNsZbAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwN2M2NDY2LThjMTMtNDI3NC1iMWE0LTg1ZDIyNTdmOTU1ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU2MjkxYTItYWVj\nZC00ZDU1LWIwM2ItNjRlMmY1OGQ2NzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtLRaLy8C0KyZB+naLNFOngJC5dOIGD6jO/omaWq3i1oAP2KRoRpeA0mdyZlT\naLu45n+vg+iidjD+yKL7m2qRtKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAgBJIX/IoCp5HN/ENwHnABSnlloMB8GA1UdIwQY\nMBaAFF7s6ObC7CIbn/15W4KzHezS9XbLMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA1rr+wpMN8TcXZN+PNtxeXCovBnQpkV2C\nx2goqS4pc+ICIQD05aYogDO+lRi4ZXN38FP7riwSSslXiaLCzjr1lP1+QQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc+L+hQrGO6tP6rroVWhuc/vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDdjNjQ2Ni04YzEzLTQyNzQtYjFhNC04NWQyMjU3Zjk1NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfrfBSxpyc7AjxsbxDIG4GkoWZjwj002/Ba5p7Y/zihJPi\n8hqXZa1iJU3mmsKsovMcRtMTCyYsetXD7draU3sMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXuzo5sLsIhuf/XlbgrMd7NL1\ndsswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOu0+xbONzr75foHfO3IUErU5rXFuQEiSlostaTpNzR6AiEA8yTxp9Ec\nE5NVquxJw6NLeS2mGx4WEML1CT5Yz/DHvoo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdutc57UQoVlhMkWpOfhuSrMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU2MjkxYTItYWVjZC00ZDU1LWIwM2ItNjRlMmY1OGQ2NzNjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTBkYWQ5YzgtMGE4ZS00MWQ2LWJlYzUtNTU1MWM1Njg0\nMTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETGXsbjAVSqL6WBAAj+JAPLCO\nRrAlEiOGCHUDX/lwYq+TrRULBIUf1zMoWS8N+Vfc+SOnqDa5gDcAVQECpk1DSaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCAEkhf8igKnkc38Q3AecAFKeWWgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAsahZC9DoJS4w12uTOJ8PYUZjQgOX\nJXjDNkZNPObjqQsCIFRbSFDZYsUpE/9DmKTDcMb7q4FQ1JWM2zusSZpsAIT0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc172", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `172` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISATNPC591KC7Mc/Tr8go4kJKVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyNzE0MmQwLWI2OTItNDlkYy1hNWM3LTUxNDk4M2FhMTNlNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY0ZjBjMzgtNGFl\nYy00ZTYzLWJiZDUtNzc3OWI0M2JmNGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuPU/ZKNns4SQoskoCOUTYAkobslCKMgfBEd9XgUg/EIzB2vgbsW/XA4yDlI+\noEi4Rz7p/3R5hkbmDbnFbNd3C6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS7O8PPuDxyf64UgL8HbwwI2+AGJDAfBgNVHSME\nGDAWgBR18tbGTaAZfTa5jcgm8g1WFOchrzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIF5jKYdkT4/JAtfBIVGQf6SgwRZjZVwG\nNOeGwtCLsOkbAiAKJ4OTwo6Uew6Zwa9Q7NS2HWx8w5oWOwecF5Nbmz9yrg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARiKz3+A11OTa8BHuwTb2/YvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjcxNDJkMC1iNjkyLTQ5ZGMtYTVjNy01MTQ5ODNhYTEzZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJIP4GZ+R3DBrtxbwyB9jMvIb6hWUYfNHr3lwbtNkSjIBT\n0TIyE2GzKWIW4RUfc1Wor2+wO/2dd473o+wAt/fPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdfLWxk2gGX02uY3IJvINVhTn\nIa8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLTZjUHxOt5+iBb28mCK1iS2HYtC8H9RazcUNbAJkNYgCIQDHdiHB5IPW\nKUj3lkYjszSgHbSOtWZP4NhKJKS1l5kGQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYxeKJlQm1QTUSUiS5edTBvXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY0ZjBjMzgtNGFlYy00ZTYzLWJiZDUtNzc3OWI0M2JmNGZjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzgwZjU1MTEtY2E2NC00YzMxLWI2MGEtZTNiY2U0MGIx\nNzViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqEuQ95F7MDwEPIVzBld/ysC0\n2IMWdPCkSPrlLHNooWDLWEiVu+JROsPRdPZymoH6lFDavB9aek3ub+LZ7dggpKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuzvDz7g8cn+uFIC/B28MCNvgBiQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBM0WD5rhNcg/lqcG+o0Xy69jKmguRc\nDcLamP5OySvukwIhAKdAHHbe381yVPgqlPtTlMVrobYIc+vZgVB1DNMMuajK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc173", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `173` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAd3v2w0IzsDrHuUoX95zpQAgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjMWYyZDU2LWE2NGUtNDJjOC1iY2U1LTliOGNhODhjODIyYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDJkNGM2ZGEtYTQ3\nMS00ZjQyLThlZjktNzlkZWEyNzhiZmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8WOFfLkVuXWTSNhU++FwUF99NGE7IBiFEbkGiHPNwmM0tfOcPz38v3ktcvOq\nZV7+g2v+QB8IuyQXPnBU4jmxo6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU98wzHvlKWdwQ485XpxE8BRehnBIwHwYDVR0j\nBBgwFoAUPgAwzZ6rMVKRlRw3Qp4srmb4HJQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA8MYz83hNEoGb\nSpmXsTMIdYefHuM1JmmNVqOyaOA3o3ACIQCGFfRLNDoswQdnyBOl/1ObbKSKWQOF\nJ0v5X4iyHA3ibg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASFG4Adn7pmgzlBTHm7FpMUTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzFmMmQ1Ni1hNjRlLTQyYzgtYmNlNS05YjhjYTg4YzgyMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+o9/+7pivykk9B5h7Qb3sBJ9gYbKx/nM3gnd9eak6fJ0a\nKvuRornJipCX7ZNwwyvzOHnNMJ+DXDrmmoB9OyAEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPgAwzZ6rMVKRlRw3Qp4srmb4\nHJQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJjBsMGijoUhMEqSsw1tlG0EyQs2e5qeEvwUVhtxqg81AiEApmrbMUja\nRiFduHptBR1Odr7RuwU0Z5o14y9ZC/GXzMM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATLELwfqkNyqCsCpi4jp3xsQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDJkNGM2ZGEtYTQ3MS00ZjQyLThlZjktNzlkZWEyNzhiZmJlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ZlYzUzNGYtMDBlYS00YzgxLTljOWItYTBlYjA3ODVh\nNGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEp5hzYLeWnWXY38NAsO0ITO/\nqW6Kwv3qO0QI7J72JpKzQzx0i+zDaUqvAkwN4OPsFQxxotgqbOIR1/in/Lyc0KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU98wzHvlKWdwQ485XpxE8BRehnBIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBuFVaGgMI6pnuPiClN3kWOw6T1wB/7\nbSSa8L4NYCvyhwIgU1DVtixgx+tVBk4h/p4tpQKWd3ppHEb4vHX3GNZauM8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc174", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `174` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASxBnC9bYQsTBrF9b5PIrWVXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhOTVlZDUyLTBmZjAtNDFkNC05NTUyLWY0Zjc0Yzk2MmJlOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJlNWE1MDEtZWNk\nNi00NTk5LThkYzQtNDliMWRhZTExZGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEILWv+opfbz0jvED0B1bZWSBlSJLtIsEC9wv0+YWrNUoA07GOQq2HY4+Q8eA0\nz14B5v/lvKoMeXbh0x2auM3q7aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn9ICNXpAKkFl5JXt0PpjIluUSygwHwYDVR0j\nBBgwFoAUQcd9KXEZgQDMUZ6iSAaY+SJDzc8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAo/Nn2MfUcOla\n0PFYCu4pLxCYVX4f9foV12Ht4Jk/t/UCIHovqumIxwjEk4AnP/41cfetSudZZAlN\nyOMLQBuTRQpQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARCJFuIxKJUlbKlEm2SkrmjaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTk1ZWQ1Mi0wZmYwLTQxZDQtOTU1Mi1mNGY3NGM5NjJiZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/JnzFtdTu4yXFFf6fegjOj+sRv+VWVAPj+sb3dZD3wjwp\nXt7fvUGWrSvlMXg5FYvxX9qF9PfXrLOWbJjxVHY8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQcd9KXEZgQDMUZ6iSAaY+SJD\nzc8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKXYDl0b8UiM7NZg02QE/ed14Q4FgQouW8MvXhF5DafKAiB/JlILU16b\nrY9MvEccCBnD75FMsvVoUaNfC5oYilSaOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAajXtcB5MzlrKmGcSrPjC1s3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJlNWE1MDEtZWNkNi00NTk5LThkYzQtNDliMWRhZTExZGNjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzY3M2Q3MWYtZDE1Zi00NTVhLTk3NDAtZjBlMDQwNjUx\nOWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6w5e/OQ/xSd2AhmRCe+WqtF1\nkamv5mDqQdYVeUN1AEJ65kTqeMOaByOnx1BGgR57sIHzFEk5fh6CpTotgiiEaqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn9ICNXpAKkFl5JXt0PpjIluUSygwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAyeFg4KtapdWOefK6urDlSuXTaG4+\nAsqNuQ0vZT9HVJQCIQCP4lXwa/uOXWvqS7MKHeFt5ThmXIk65vzwI3tSzoGABQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc175", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `175` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAdgLJOS9lmLtshIztUfiNVq7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlODg5YTEyLTY0ZWMtNGQ4MC04ODcxLTYxNjQ1N2UyMmY1ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGEwMGYzMWQtMGRh\nZi00YmEzLTgyYTAtYzUwNTY5ZmI0YjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpcIIc0NB/9Sxf19a5QUHPwv6M4qudZrEnitwajATTi7TBqOqzhVS8owufG0m\nE4zFEpPEJR9UfgrWDBSZYUUCrKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULDSAGpmFewnOgI75O+RflHQpMy4wHwYDVR0j\nBBgwFoAUgw9Wdm3jpbM4jwxR/Kd8uqIthwMwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA1b8k/i+3+xxK7bfTPTN3\nHPPS2EEUlcxipTmA34N8p3sCIQDvNc79qSG4nZ3Xx9NMBYAsu79FP3eMFOOAOlMo\nEao/ww==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY873p6Tyb1UUEYEYz7QywQIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTg4OWExMi02NGVjLTRkODAtODg3MS02MTY0NTdlMjJmNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJ7C73wZH9oskddQoskmJMIedYxiVMs+YulHhEGt6Vb4uv\n5cmH9tGuaoFKuXv012hWtcbjAaBDX63rgGMnai/1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgw9Wdm3jpbM4jwxR/Kd8uqIt\nhwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO3Fz9kZzgegOoLSdPutTbxIFxqBZCbCxVgsYCno9q9MCIQCmp8GGULrA\nW/ENg8+jCO6qcztJNp0woBhN1o+pfEQpAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVihVkuKNQYkVGp7Klv4mQKmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGEwMGYzMWQtMGRhZi00YmEzLTgyYTAtYzUwNTY5ZmI0YjRjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTE5ZTgxNGYtNDlmNy00MWEwLWI0ZTctMjM4MmNjMmJh\nMDU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvNX8DXC8rkAWG/l6iZyMNI5M\neetNf4R7Hj8mMqVKBnvkzGVHEI9oYPj0ZPb4MVJy74+Lx9iq/Vo7r3n07+8XY6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULDSAGpmFewnOgI75O+RflHQpMy4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAfPlKig0kOgigvOl2/J+W1P/6KHZQo\n4gYIdj9gRbWhcwIgFwbe+NUQrv0qth0mEF2oRI7MvRbCgva1mxBO4f90teQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc176", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `176` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISARQ09yyk0FEGELCeSrJ4j2kMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZGVjMzE4LWE0NWItNDFmMy1iYzdmLTI3OTc4NzZmNzFhYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ0MmI4M2YtMmYz\nNy00MzA3LWJiNmItODdhYTE3NTAzNDA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGw2sIP9BLVdV5jruzbSBDOt2UFm8j92WsVSyS3Aw91eMO4kte7RYgGxE7p9k\nbbUEYmMRXDRDMt4+Nmh6f2q7FaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh5FI6tMb0JsKNOlxKDcyn0bnGu8wHwYDVR0j\nBBgwFoAUdl/eMPuDTfWi2dibZ4UMb/WVgggwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA+f4i\ngO2ItZq+MZe6oM6ZtFRxmM0l7hdFRVXzPaVCa6gCIFaxsGPloR3TEOwtbmmZCsmS\no2srWxtOR9tEZH8n5gxE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdKejxd7oZBPkbLwqvhgBtcjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWRlYzMxOC1hNDViLTQxZjMtYmM3Zi0yNzk3ODc2ZjcxYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQC01LLx01CvzI8R60Bk2NNisIP4fTwm6/8e0Tkv1aMA1UU\nxtlNgo4JkuFgX7EgEUSS0GrKVVonZQr5HZWYqBSqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdl/eMPuDTfWi2dibZ4UMb/WV\ngggwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOir1nXTrZ7vGj8EW8r7Z7HcaDfOOoNFfc7SygKpVuLNAiEA23QKnY3F\nXDpdH7LkmpwI6MIsuLCfvSlBfX1nv640I+M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAf21gWcjNExySImowqf6d1ukMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ0MmI4M2YtMmYzNy00MzA3LWJiNmItODdhYTE3NTAzNDA2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGFjZDkyMDgtNWZhMC00Zjc3LThjN2UtZjQ5ZjE2YmQ0\nNGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbrlgR0fNuwuQnuEVYF4adf6k\n1eB3IUr7VKhhJo9s8nhDPIYwcJVweRqFJNNw/aZCgimg85O+4T7ePyEpUeeWQKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh5FI6tMb0JsKNOlxKDcyn0bnGu8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAiT/IoJJncXA+Ka7mUQTo9UKISLBu\nMzQLNVUHJVigh3ECIQDGOtatGDr+Kmd1Zl0/bJNVAJNH9ntRljzUCuNYCMWWGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc177", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `177` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAWeNMH7Xg8viDWpt9rKXMiT3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNmE0NTdhLTBmMzQtNDllMS04ZTEyLWE0ZDRmYzA4OTY5ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTkzNTI3NjgtMzI0\nNC00NjVmLWEzZjAtZDUxZDkwMjdkMmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw0gZ9HGRqzrw8hPAWZ9/vWXY+fPCsxJVhuHlu81RITUClGXaBhwSQmxyAa52\n9DWuJmaNLwKMga5mkwZsDxB1QKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtmpNw4hEcJtj1R2mmFG44hDFLggwHwYDVR0j\nBBgwFoAUNw0A7Srf6Gsf9ctNp5O+8SQzLYwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBK61Ae\nT+j8XCgETROXi5l7ipmmUfJu4zPH7+UpSqBcmwIgLh2oYF0JQEs6ARfTDYj2xht8\nBQZkO+2wqp2VJVLT/f8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdGNutBXgZL6kGQY2qW/CbTHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTZhNDU3YS0wZjM0LTQ5ZTEtOGUxMi1hNGQ0ZmMwODk2OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi1NAgVsiS6CL/9nh0AcJ+ObeNjjqIYqEI6GGmfe8IEgNs\n/6/SbAUq7X9d2Y03Y9lS9zcZAlQBEZXsh1AccGN1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNw0A7Srf6Gsf9ctNp5O+8SQz\nLYwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJMgEWp6tQtv+2JDbFpDJ+dMUyLaVC0aTqu0llU9+xNeAiB/WlYCObJm\nGYf+hk1psDAYsJNONpOivuUcSib7z/utlQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZCZw1M72BinlJqyDFtJEHi6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTkzNTI3NjgtMzI0NC00NjVmLWEzZjAtZDUxZDkwMjdkMmY5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTg4ZjI0YmMtMmZjMy00ZDNhLThkYzItM2IwZjA3MTYw\nMWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjcIm8Uqwqzq4dnDCbq19ZpeF\no4FEv7Cz23d+weDA5Ld+8KlZmu7Q1FvwUT6lhNHp4imQDcAg5r2wlAF+Z6/4SKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtmpNw4hEcJtj1R2mmFG44hDFLggwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAmKDyqynr+23gDLYq7cOi1bhAzKTD\nyPR1NY1cwr10KmwCIQCcf1+IuxDquiDxt2PQwV4C5w2zR9VJ5zA8CfQEw2eHOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc178", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `178` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZRu5FeE3887lhLDngB1aKxjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNjI2MDA1LTZmOGYtNDJmOS1iZjRkLTEyNmU0MzRhMzhiZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM1YjU3ODMtYjk3\nMy00MTFmLTliYmItNDE2NmViMzgyNTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEluayZ5jHALfOLD/flCGmDUtTtr1Wn+H4xo6FRc/SPBs9525Srscnrp3G+aUE\nQfO1JFV+sEMtMHqk8yHp/uKerKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCDzldOqTxQU1+XQB2eNSgYy7rFhMB8GA1UdIwQY\nMBaAFEu41fi+IbCgzLC91MjRdYwkL5ThMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiArC5vAxiaGjAW0VrLYu5BoJNM0bOguHpeq\nEqaXgZ+87gIgaebaPU3pJJ7R4eRYq93W4wQdObyNlFgsTsMZAuOvxWQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAferoNVSqUK7OISEbi319YSLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTYyNjAwNS02ZjhmLTQyZjktYmY0ZC0xMjZlNDM0YTM4YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQJdMdYB6bv+VKBmqTsQAj8OC/7eVDzJQkUQcsp7c7hFPa\nffi54zraWYiQ+kZiKbGojE/GH0S6vGBkAK+VKDkLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS7jV+L4hsKDMsL3UyNF1jCQv\nlOEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgb8LyNRlMg61L0gRh6TYiF27kjAauDkppwLxzkB7COGMCIQCSlVq8smgC\nDy7LJkQ7lm6w4cM8dA/rnqQIdZxCVsI3Vg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdRHys8/4b45AHm2TNGr0xqtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM1YjU3ODMtYjk3My00MTFmLTliYmItNDE2NmViMzgyNTM4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQ3YTIxYWItOGY5OS00YmFiLTg3NmUtZWM5N2UwZGQ4\nNDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETGKtipbxQIohSx8DD8QDsiTq\nv/7ufkeeXp0JPTkIbZULU52wPZJV4jfmOOXpu2hJxiFxbunH6YS0+z7Q5WKlT6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIPOV06pPFBTX5dAHZ41KBjLusWEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAqAzCAXQTH2WkTOKUO80Gq8rcvQp2\nP2s5g4YxZta7ahQCIQCZHCiAAcTxIkvqX2Q+HnxkZRTLnIxz/QDiXaCefHCVXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc179", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `179` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAaOjI+z3w7Fq5y438/L9HbbLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExNTEzNjI3LTQ1NWMtNDUwNi04YmRhLWY4ZDkwNDIzYzUzZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhhYTFkNzktZjYw\nNi00MTNmLTg4YjAtNjI1YmQ4ODhhZWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvXdZ4YqRrvOOu8QjkRwmV8NA9hKyqoiA1nVuqaC9mGMMTw6MWUraqRpI4Ozx\nTxuQJCP+9nt5AvirBI4WoT+HBqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQtpg8UittRc3Sxc0U68F1BR5kugwHwYDVR0j\nBBgwFoAUvdzf9tEC9bnFS0hoRyzKNo2tpUEwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgAjvwe7TAyn60\nM0mZKV+GeTj8FNTrP6lUKP83iZIUuNkCIB/3SwrPzntqlgUf2p2d6uMLMM88HKje\nCNE48vYVUE83\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbJ8kVIWGLPi++Jby2JGKbgcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTUxMzYyNy00NTVjLTQ1MDYtOGJkYS1mOGQ5MDQyM2M1M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiRjda9BDilAzQhxjNOi7Jk0UGgtfJhUtvvH/uUKvAmsgM\nLWxzYteDlzdieSTF0/ozAeHfXU/J8dBACsrXNZOPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvdzf9tEC9bnFS0hoRyzKNo2t\npUEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO2t5ku7Cwihj67sGtUICclhSlARjgNLPqdIl9iWffeeAiEAytdvDC4W\nN/Rr2Cq4oJ3Etgv0hxaTTZnKiHUW4ndsPqA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAej20VmW2Nu3Jwr7Ow3gvUm5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhhYTFkNzktZjYwNi00MTNmLTg4YjAtNjI1YmQ4ODhhZWEzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTI2MWM0NjUtYzNlNy00NjJjLWIzMDUtM2RhNzE1NDdj\nMWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp3+vo2gINyoxtuHDCE6BiF6h\nV/IRKwoW/nih/o3sfYq6FKyFaM2PPZnQnoOAJ/fr9gfccSxQDiolY4WHTcp6cqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQtpg8UittRc3Sxc0U68F1BR5kugwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAsqynaOwQ+UJCrcsEfO6KuBTw2q/j\n2oqmWtYYKX9it/kCIQCu96ztwP6m0eBTNxeT/2Se3DbAxZ9IVSiX1QCDszALKA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc180", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `180` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAUUynQorDs7QiaiFGPO158mTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ODI5MGQ4LWE1NTYtNGFlNS1iMTVmLThjNzBjNWNiY2I2NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZjNjhhOTMtZDNh\nZC00NTMzLThiYzItZmYzZDEyNDgwODllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEue4x+p6SH4XK66bFxeZIy4uSl8uyfpGgpfj0TSm5McZDHsZeKX4bW/yUYXvD\n7WVr/tIZA90hkTT6YyjxrMgWBaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaR7MJnuPUHRlkuVYGQdyR2ojjqowHwYDVR0j\nBBgwFoAUvdGR6LaKlYSvHk4ffiA8bSrhEXcwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKSZyFI8v94ZD\n/wQBR8zHy+6kpb3Iy3mfOTmHvbLA9IsCIQD4a16wQ7NMFfaUmfnKUKBFeQEAozds\nJy9gcNHfCyI+rg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZdYaA6r+6V/CH0+Tk6cQ6bNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzgyOTBkOC1hNTU2LTRhZTUtYjE1Zi04YzcwYzVjYmNiNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgqZI+3NVZNulOkbrzYlcrmFwOG/FfEr/G1+1IlYHWUnRv\nvechOdex3HMlc3mASu34DoX0VrlxKz4Opq10MP2No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvdGR6LaKlYSvHk4ffiA8bSrh\nEXcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI8p5GlJdpND+S0nMjzAk2b9eNjz/bkfhuMOv1brr2UyAiAutfhLWM74\nYarLqN3qUaxrrQvnY3pKZGro50ChEJOyOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWqwo3yaU8X+gaNWvTvJt8bBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZjNjhhOTMtZDNhZC00NTMzLThiYzItZmYzZDEyNDgwODllMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjJjOTQyODYtMjgxMi00YjE5LWFlNTItMjA5MjQ3NWU0\nNWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvEHrvvagZL3dzWqnGHS56aeG\nClGRdyd5a5HUA0+4nm9BqzfUNbc0KguzkhaTB8LOCT64vjCFDyLPiDdB0RGRGKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaR7MJnuPUHRlkuVYGQdyR2ojjqowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA0khr5+zizJTvv01V7wULXJrovuhF\n90wCI5t6CoR3fLkCIG38Ti3i+XIch2gG5o6OlukUFp+OcT+wHYALPMIRJc3U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc181", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `181` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdm6Arg7Zl97y/dYGwRwyLMrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzY2I4ZmNhLWQ5M2YtNDY2Ny04YjAwLWFmNmQ2MjE3NTJlYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE2NmZmNTItZWFh\nZS00YjA1LTlhNmQtNzdmZDQ5NGIzNTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENpr5oXtLH5JOboiorCaBa5kE7PcVZTsks6UkCM8MiAAfoD6WLQyTd7liMKm8\nL/D6SpDaU8dwf9yDwGNkTCtA7qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGzxQa+mQTcvUxAXRgBF7odysvLswHwYDVR0j\nBBgwFoAUXhdYKtnH3spFTB7P50gJSIe1wP8wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICrfDJcU87Yf\nMFyKrXxubHxW4BZz9q5WODj5snTQ7yYtAiEAr4M10q1Tasj2HbNu189SeNz6RRFx\n2gNLeOk+eWO3zNY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeZnoVo1uZKHGme9S8ReuRdFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2NiOGZjYS1kOTNmLTQ2NjctOGIwMC1hZjZkNjIxNzUyZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSGMiQMV4wdfZwK+cAqBU1Bj7QixggJ5J2vOyD6r7NRtkd\nDqydvhr7MXAppd5OyU4KIdfy5EGupxxWS5OXC1xao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXhdYKtnH3spFTB7P50gJSIe1\nwP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ69TeepdL4XZIi91YEe2dcKuJkBxGmbuHsFX83R3GckCIQC/dyzNrPIe\nc7b/kOvC5jykfrDNjvd+jg1vEcDBdWkBaQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATF2kJIYsYYBvPUZhxafgCekMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE2NmZmNTItZWFhZS00YjA1LTlhNmQtNzdmZDQ5NGIzNTVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTkzMTVkNzUtZDA2OC00ZmI1LWJiNDAtM2QzMTg2ZThj\nMGVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBy96ntgGs1ho3VW07yB3hjRb\nPXzUV3NEFgozYnXc9WoAwThBsGSA2ztItdIa2OenONmJTZNK0/3dvrVXAodYvKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGzxQa+mQTcvUxAXRgBF7odysvLswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBmH7LF+jaTBWdBCOCKnVYP65Yq/jYg\nocFY9FhLck16KgIhAMrqOjsAl9QkMJWZyujjT5pM9+kylMdUs3MDRn458tI1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc182", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `182` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAWK7pu9lHSWKvEdUFg+vDL4qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ODNmODFmLTlkYWEtNDJkMi1iYTdiLTAwYjk3OGIzMjNlZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRjYzc5MTgtMDIz\nYy00OWNjLThmMTktMjYzMzE4YTZkYzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqAsin9aGt6T4bMZKZJRrOtPRU4bCcxc+mox/Q8jGdyWKxiXimClaJIySPqeO\n58KGw/PSYMp7+7EECmf5rom0KaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkfmEVd8/Ng3vMxLoRzH3X4UlPo4wHwYDVR0j\nBBgwFoAUtDyKVqAPibltkYVNnWjlqQ/D08kwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDMajw3492Oc0BuH39Ezdm7jqU5KcizdDJgQciTzYr5igIhAMYyjSJj/Mxd\nN7La+unwtLWrGxQCuRXhD7pyz1zC+EOX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVaYCaO8ipXEtRKME1ml4eM5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDgzZjgxZi05ZGFhLTQyZDItYmE3Yi0wMGI5NzhiMzIzZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASh/kwDOAp+eL9DLjWRSRXSBUnbuDD6DJf48IBvJN2TmP6D\nH81ezGXSgdO6q8e4aTbr517+FOWXUaxWiKjyd8NJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtDyKVqAPibltkYVNnWjlqQ/D\n08kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOMdQ1hPSzFUj2O4ZyeeGRpTpI1lPI22t7rSo7S3/pdRAiEAhSDApelO\nUkuCc6VBCA9dAn1DRhQhYRZuhWhPU8ifAKo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeEf4Rdc3AhyXi5TwGS5wpuvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRjYzc5MTgtMDIzYy00OWNjLThmMTktMjYzMzE4YTZkYzE2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWU2M2ZiNWItYjcyOS00NTI4LWIyZDItMzZkNjA4ODFj\nZjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn3ofAZS8rsQ8edsjs5V65NEG\nvNhV1D+YCxAAadMMKCJef70sC4JOPPZIZb8klMe5wsgO8HUpBx7aim2YqkggfaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkfmEVd8/Ng3vMxLoRzH3X4UlPo4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA7EYyqBaWGnqMLC25U+u3POXeegIy\nVSsJm09UNo+4MZoCIQDgnxGYCpgMDPaqrq92kLUH0ADzCJuu4c0Nhp7cO9c5ww==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc183", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `183` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVqwyCloiQpqyZ24pERIUoFIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmODExODgyLTNhM2EtNDdmYy1hOTJkLTJhZDFiY2Q5NzYxNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI2OTRmM2QtYjgx\nYS00NWQ1LWFkOTUtMWQ5ZDg0Y2VkNTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFotIu3nCjS8+CgWfdjAV+WqpQpUE/ePBneS90Sf8xClSW9+lrUw/4m7ZnL4S\nTFiOL99DtYu6LK+lfLxAnMJo2aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ4/Rz5RBBPiP3tAOHec/iu2G2NIwHwYDVR0j\nBBgwFoAUq/UaNCeNzhsr1HNsIdu04PW8lyswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCJCmXWZSeyGHfq5dN3d9Z229bAjwCSPQJshsXNNi4WwgIhAMMvO39AlfB7\nGs3Nj/i1jzNVZWqKQ3Q5zRjdT8RnzgdM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbhMVmRmwZZ0b8Whyp/0uskGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjgxMTg4Mi0zYTNhLTQ3ZmMtYTkyZC0yYWQxYmNkOTc2MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIFdkrwy9Adcb/uZNN+gs6+QVgxnO1kQOeZCyKgo+qp8IT\n7rigsplColA+Ae4tTZCpnDsthHgQ9qx30YXhVus6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq/UaNCeNzhsr1HNsIdu04PW8\nlyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOdIqf8zfXzKNCtjT/+wDmH4hi0CQt5McaJQbJis3G8+AiEAiiRkv/YO\nyuZ6OH6dmcPqRvq/2zKiOF5aXYrzvqsseww=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXTR47KN/PDx/kBTTtcoed5tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI2OTRmM2QtYjgxYS00NWQ1LWFkOTUtMWQ5ZDg0Y2VkNTcyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODkzODM3ZjAtYWRjMy00ZDM5LWI3MmUtOGUwYWEzZDMw\nMWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgrN+dIwU+EcMOCcA0lpE4Dd1\nFZoG4MSsPGezbR2YtAtYptZG7vhb8lxsvROnYCltB4DTXeM7XgfpW0fnIR+tDKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ4/Rz5RBBPiP3tAOHec/iu2G2NIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAxdt2in5nSBz8jsNBMwtPZut/PU+GQ\n5JQQmKwNc6Ik5gIhAPSO3avVXkpWme0ZBVmWjV3jO55qNsRy0WTxoFTDEti/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc184", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `184` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAdK/qRvYzmJBE06jGFaL+b2BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlZTg0YmMzLTE0ODQtNDM5Ny1iZTk0LTNmOTNlMzU5ZDVkNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU4YmE1NzUtMDQ4\nYi00MWVhLWI2MTktYTk1ZWE0OTY4NjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsG4qTKZ72O4SygbUOFpeWEVKN29b92vmH1F8fcq+gwFbBuF2PnVpR+wVMjd6\ng4fyFc3g1PUteS5DqZEd1MO666OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnz9fF3fbbRb4HOWiQxD8pC37d30wHwYDVR0j\nBBgwFoAUJ0u1zSmpEnF/Q7nWH2xUbXcm2uowLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDv\nFGfAnPN3bdaaAALwbB5v93OZQ+jlxmx925D4dWuM2gIgMd/6BqPPAGVxNGMwab/Y\nxw4gkAl8FUV4dKJhbnAUea4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZBKNA0JgfVUGe5AsDEUBFUCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWU4NGJjMy0xNDg0LTQzOTctYmU5NC0zZjkzZTM1OWQ1ZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGes/Hpxel7qKhGI4RHRU9UDnqHxv91ans5EGblCtnYuwH\n/wluP3Pbt+249xDGr2KG9Oi1BCE9WRYiihZShYEBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ0u1zSmpEnF/Q7nWH2xUbXcm\n2uowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN7epfJHi8wbXM2q8hMPGYK4JjrrY5U0MXJWua0/nV/MAiBPj/Wjfq4k\nZnh71WiKq+IWinIjD52pbfb8Z/VOPnKAkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAT+3hdox562a44+Fmods+2GsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU4YmE1NzUtMDQ4Yi00MWVhLWI2MTktYTk1ZWE0OTY4NjczMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjgxMTMzZDctZjIzYS00ZGFkLTkwMjUtYjhkOGUxNzVm\nZmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqJB5KCRKXb9aIn05HHfIZyGK\nApCURsN4+a8c38pbZopTy4TR+mfzqdT1iTVfPLoeFNIj3uqgF9HMRQvviHJdT6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnz9fF3fbbRb4HOWiQxD8pC37d30wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAipFhNobJ2lqKmxIcmLJvzzwLzkm2\nHrt7VpBG7xb/epICICq3fIOcg5M/jKchQU0w744jdSieoNhpokiABdNEaMSW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc185", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `185` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUtQP0eQGYxw72FhM8vDG/0SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmN2YyNzgzLWFmZWYtNDM3MS1iNjA5LTUyMDA5YjE4Zjc5ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZkMzYyZTAtMmJi\nMi00OThiLTk5MWEtOWU3NTI0NWFhOWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEit0mWrljYO2L8hVkKVIc3BlwCsQIp3W2//m0TV3UEIn+YtgpHyi65f/OLJSQ\nKP7JeMu3/IoYcjQYaJPUVSRze6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqam/b1U8W37T1Wg1iK+Od+7W/+owHwYDVR0j\nBBgwFoAUo0tVgGz6LgEoJOPxEU2pkFtnSEwwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCygF6MoDNTFdUKOZ0SVtB/Iza2+WCHeSqvPd7kkPWh0gIhAJnz\n6TSnHyg7WgzG2yZgmuVfPHUZnCESnOvNAOJ6EZvj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYnlt3svPakPCRFQjUiy7I4aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjdmMjc4My1hZmVmLTQzNzEtYjYwOS01MjAwOWIxOGY3OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQM8HOiRrx1sC5zBzDDUrpoFnk8V2bH2S9fKsQtv+WmtLo9\np/TO5dr98F1AdPUMx9WPqGn5GPqc77IFAUgwPOu9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo0tVgGz6LgEoJOPxEU2pkFtn\nSEwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM7+AxkKV0eaYu8bA0kT9gHpw8zSnpnb5rB/lHRcep3WAiEArEbLJG2S\nY3wuPVnerYYULemHXBgz/xeRGqmiOGptU1k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXPYUPRLNOEERv6YaezZtUC0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZkMzYyZTAtMmJiMi00OThiLTk5MWEtOWU3NTI0NWFhOWY0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTUwZGIxODQtOGNjOC00MTg1LWI4YmUtOGY1NzY0MGUx\nODEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEViyxd/DQOtsTNtKR3OzO7eDP\nTvIhZdNGPteFQAo4tEfAfLHKouNnG0hHxKBZiV/kLYfMgdzP14Q4qYi2zZRm4KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqam/b1U8W37T1Wg1iK+Od+7W/+owDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA2S1cIwi/06YZivnqyrXHW27fTbl2\nzd+9nUQuXoU97ikCIHEq8s4XSIs/noo1bZ0cm7jLrRC85aDF4H7vur4UG47+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc186", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `186` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAV46Pnk8R28Kpa7HDG3njXocMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3MWJlMTI3LTAzNmUtNDBjZC05ZjMzLTdiYmU4OGIwMjBkOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQzMDQzZGEtNGYx\nOS00ZTUxLTk5MWUtODRlZGRjYjA3YTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvGZT744etDjECirIlB1nC6v2WmK2DOnCZWNrWuAjjaJ/NauowCum32ZEfT3L\nN1dx0CRkY6SlsnJDsd87SPQQZ6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDI+x1/Hn36+Vvb9F5RidDCi1e0gwHwYDVR0j\nBBgwFoAUZzRpr2yqv1zErioxlRb/6Y9cp18wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCw+EPKytGQdjDLfLe0W+M6wMvcXMSTwXWlNpqlnJPapgIgb8F1\n54ge0ZzLzShzdHz3zpjnl5WnE/5NLcye3fo9iv4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAde/vK1bqGNDfvYUCs0czu8CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzFiZTEyNy0wMzZlLTQwY2QtOWYzMy03YmJlODhiMDIwZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6VR72uU5F8moXuSXJtZaH27iQRwlCW/dmBxYRBOd0Ilmy\nM9gUV7lIfpvPKfrvZfCrUKdXZ7Ujqp+5Rc33cjqYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZzRpr2yqv1zErioxlRb/6Y9c\np18wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOpYKZ1sr2JNtzPfPslRQJceQnyH9aNtUX5uuLsdsVxMAiEA/LssAi1i\n1zoO24/+NP5WahyrPBgf1ajLMydIeqt9do8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAX5ABdGbOPqaw+cls1wQIEAHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQzMDQzZGEtNGYxOS00ZTUxLTk5MWUtODRlZGRjYjA3YTc3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzBiZjhlYzktZjMxZC00MjE0LTg5MmUtYWYwOGI4NGU0\nMTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1HDLamGLGsKFzysVMNsrlGV3\nxuAyIhKHBLa+vwseHOlKLSlKXs26qBoE5bEBSJLn+KczrUhG6H9SNETMS5OPnKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDI+x1/Hn36+Vvb9F5RidDCi1e0gwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBQ3Oc0V/xxFrKDQRJvwME23LvkHZlG\nid5U7ntgqFZ/sgIgF8tNW6aWm4AgETRxjvpn717/nXGtxa1J7G+WTrDTH8s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc187", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `187` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAYBN2MqpvNFFdUtVg6V11AJKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzYWFmNGQwLWYwOTMtNDMxNS04ZDdkLWJiN2QyOWU5NDY2MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTZiZDYzMGUtODVi\nZC00MmFkLTgyYzYtM2RiZDA2ZjI2N2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6EQALRamId9dmgxju3+JV8dDJpeeGML2+V3ua77NgiIMVnN8Ve9t4Lx9BIHT\nbph4RnEe48kRTAlLNOSBmbULeqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEQ/jV7KwUXJJnYEqwYoAxYGMmv5MB8GA1UdIwQY\nMBaAFO4E7//l7jSviFqR184CXBTPFOuUMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAZpWhT76iHW/1eL5CBQwYtFdWn/7FVJ412\naaqKciNeogIgY+c10KBZ61nXumiiK83LsSKkQJKMN4+CLS9aCdQ4//4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZKK2hW1h2d49qDZl+aLQItjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2FhZjRkMC1mMDkzLTQzMTUtOGQ3ZC1iYjdkMjllOTQ2NjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeSAbVYLqEPHfHpuZNricQsqqTwLiYXweMBSwngeTVkqUe\nfq/2OfSgdEky24FR4oz0NCxE8OsRE2KAYn4vm/Loo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7gTv/+XuNK+IWpHXzgJcFM8U\n65QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMr3vFaMfuUj94wWiq7DPT9unEa6WEfM+QTvl+0wB8iUCIQCkMowaHhBg\nAPQWBkGe/dj1BHAjOCDpV2E3WQysh35rZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARo2dL03B7l815luw4WJQ1K8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTZiZDYzMGUtODViZC00MmFkLTgyYzYtM2RiZDA2ZjI2N2Q1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmUwMWIzMDQtNTkwMS00M2ZhLWE1MTMtNDExOTkzODgx\nZGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELJzT2wVTlPTKgbNKN6NiWxDa\nTh7xUlgbDCiqsSU+S8UoI+UsYRjLHHHLFBAF4Tk5mdsc2Il8F5skZawvaJ4GTqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURD+NXsrBRckmdgSrBigDFgYya/kwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAjSl98QUeYMInTM4PkC/sxZ9l4aJ0\nEt/YKJ1ed8QHPukCIFoVdl3pVcpo77MVG+FcfLRSLuN6LyMU2ME8CNpdjVa3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc188", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `188` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAS21awnwTFC9Ymbx1Gul7yQIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMmU0OWM0LWZjNjctNGJkNS1hOTU1LTI4Njg1OWM0M2M0ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTllMDBhYTUtYjE5\nNy00MzI1LWJiMDEtYmQzMDgwYzk1NWQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER+vHmXgnYjiBsaHx6tOU7tNunP891YFFDHc9aGQmmRx7Bmb+c6wGp1xlkuxz\nmx1nhxn+FU+Mztml5ltSb9xThKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7BhSIaKw6m090ZXe8Btl+DJcujYwHwYDVR0j\nBBgwFoAUvx4+XA3v4TDdjBnCvhDYCnxgUAUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgIvmS5LR0EAlo\nBc4/U3yCXEfxOQ9bsIrJTgFntT1Z1UYCIQDV/EHrBfC3dGZOuFEix9GzNLZExZBW\nrlZEoyfTL3Xxsg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe9skS+dln3DKrN9AxwyfRcQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTJlNDljNC1mYzY3LTRiZDUtYTk1NS0yODY4NTljNDNjNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+/0wYjUtIcdUrEaorHS9jY0nf+7DuO35QTYYNZ1UJd3fL\nhqAFmNRZ00365YyOvPuMUZWJewTPfJlk3W6Mpqoqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvx4+XA3v4TDdjBnCvhDYCnxg\nUAUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDzty3CTtnvlJqnnLm4PNWe/SX7AHmjMU4CX2YJJt45QCIFDBd8PdXeNb\nnJTGOni2+Kw0sot/yWXpcz04LBNClJp/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZHqwOKnMK0Tsb5YWGOgMLWRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTllMDBhYTUtYjE5Ny00MzI1LWJiMDEtYmQzMDgwYzk1NWQ0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTQ0YzNlZmItMTVjNi00MTJmLWJmZGMtNTdmZDM1Njkx\nMDRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo/KUMJMqy10U8UPEzsiS+djA\nvJWi3oXP2q7FwwfIFFnb9yMsisoT70K7xlqF9bBslaHnHmY9TkZ998++uJh/UKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7BhSIaKw6m090ZXe8Btl+DJcujYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA6HzlTrXnW+FiboDrWp6Ztmfh2w5U\nPTKZzHiFi3VRQjICIQC4cjKBDg9PhVspjNf61NW1Nu+6cO7zuBkBX+RMskVd2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc189", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `189` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAXSTyHU0k9t6Y9+T9RtGRLz/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmZGYzZGI4LTcwNTItNDIxNS1hYWY0LTMzNTk2YWVlODhiNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRmZmI2ZjktNmU2\nZS00MzZlLWI4MjAtZTBlMTFiODYwMGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+Fj3HPlR9yhTIvvgAxDb1thdwtIzAv3poU3H5cqIGVzuXu4fyliBi4azOWyR\nt7cCnOzDr6pvz4B0ixGawe+UHKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzpacio3yQFBBDVH7I4msem7RB28wHwYDVR0j\nBBgwFoAU+N7xHqS4Fp1l0ZfwL6H/B+MFFbIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJQJmdTMjsmk\npvAoIy3ntdnBi2uRptnjhdrA8NwOvz8DAiEAsgG3HJgUs7WDuY8NSpZJGIyzlx4h\nujLIBPqD3Rt3Eo4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAahuHxIX7KiFmT0I0i8Zyzk6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmRmM2RiOC03MDUyLTQyMTUtYWFmNC0zMzU5NmFlZTg4YjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARB+EY7zOspOVGBYuiE1o1sOQ6/7r9IPGEahDP6oHATfvSs\ngDmNJgYtmZJcqJZvfldyfs3rksL/Zig90reHZepKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+N7xHqS4Fp1l0ZfwL6H/B+MF\nFbIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKmNta2I1Pcgv1SoN39Nu4H3mGVvHhLHlBxGGw9q3wADAiEAmko1PYnB\nM3LukH1QKRiRwG62OlNclSvXRI3SYfqAaRU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAakqSEEptthUd6cZAxeLdoB3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRmZmI2ZjktNmU2ZS00MzZlLWI4MjAtZTBlMTFiODYwMGI2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmFlMTkyOWUtZWJhZi00YjAzLTg0MzAtMTMyNDUxMjk1\nOTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9pQWf+VofzLr2EzapH9R1HxK\nlLUBWU1UcIOXker4EztR8Y+hvcdNw046rVxva6w7y5c9te7HTju786kmC19pVaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzpacio3yQFBBDVH7I4msem7RB28wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiB9PTLe06yDhF5CR7inxgHJpL0eoA3k\nUyoIM/IyI4gEaAIhAOd5/ZbKUs1FdYtNYxDqTZrL0c3ItdwoVZaPSdFrAzw8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc190", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `190` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISARRqKfy3U0+2EHZfYjlhHQpwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjZTc0NjhkLWY0NDktNDQ5ZC05ZGUxLWIwOGFmM2Y3NmYxZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2M1ZGIzZWUtMjQ2\nZS00NjIwLTliMWUtN2JkOTVkZjAyZGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoDVHRrH7aMyWukxMMDD27zHjrR1EyqplgydV0+5E4thuuSgMgxz8qqydMB31\nqCZoohoAYoXEMViPHlNzYebCAKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW/9U3lodtSAV0OHKVEBXMptBkVgwHwYDVR0j\nBBgwFoAUNiMb2tN8ok8cM46gU4YZjHxBOoAwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCxVfuTrjYB\nV3bLxH3WmPkr06WaXdlcS7J9HuD2rStkBgIhANH3TaIy3a/E955sUY9gsxTEE0oo\n18CCZhWbrpFTiO59\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUYSDFg6PS6mNiShBxIBAt0mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2U3NDY4ZC1mNDQ5LTQ0OWQtOWRlMS1iMDhhZjNmNzZmMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpP5bgfLTc+OU9SIrRpMxgmAHwo1avbgdmym06eKRAAkm8\ndndEHPxn5rktCEXZfRTL6iTXz57RW4y7bgUREgwSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNiMb2tN8ok8cM46gU4YZjHxB\nOoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPD+JC9g7zUqy68OHRNJHdeQ8bABrYPuxQ+h/Lx5PIX3AiEAsVqZevk2\nYu/bE13oaK0vc/dwWqu/8mHQ5vvgcs8sSpE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAU0jSoyipVpNkNPjqbRy72U9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2M1ZGIzZWUtMjQ2ZS00NjIwLTliMWUtN2JkOTVkZjAyZGZlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk4YTU4OGEtZTQ1Yy00OTUyLTk0MWUtOGZkZjU5NzQ5\nZGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0C9twQEwx2PzD92uAllUwTlY\nyD5N0/UR95IyO2sjs2vAdcfsOs2jnFjFnIIG3pPhBc5fajMmkAlCVJ4QQKMVCqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUW/9U3lodtSAV0OHKVEBXMptBkVgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAlq4yl1HuzPFetxIOfYxrPUA1//3bR\ni3q45PDzG2OE8gIgJ+bdjZSlG11TYMC9HT9UTpIJKf0HVXN7Zuk2sAAfPYM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc191", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `191` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWDkieQPmp0KavWi5OxT95LEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0ZmU4MTJmLTRkOWYtNGM4ZC1hNTk2LTYxOTkwZGM1NGQ5NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjExNTE3MTgtMTc2\nMS00MTEwLTgzOWQtZGQyNTczNTQ4MzZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExXeRP55ddTF60joQEjliZLED/o3VqrI4rgWgMhkHLVogy2agTn2/A/chVO39\nAXLXtd+DV79wK2Jg/2hzclMok6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl6s1F5myPKaUX9hl8F+E+QhtTkgwHwYDVR0j\nBBgwFoAUZUwcLH9aYD6VCzjNLNZrGwD/aUMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGdVsed819sUYPoRFUtQBEOF0mql+Ge0q4Pu+ACz28lyAiAXRK1REVVhL6Ud\nbvFMi6lD9jmPjsmX1/EwHMqEbBgrUQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT1PuGn9fewgNHtQZGjPz7Y3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGZlODEyZi00ZDlmLTRjOGQtYTU5Ni02MTk5MGRjNTRkOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQntZlvKWEQwG5mHlSyFxzwLNMc3F8cL/Gr8dU1lytcqV0\nHfgwaZkCVTOH3rqNCpU98IQ9yp0ViOzWe+ViCSaxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZUwcLH9aYD6VCzjNLNZrGwD/\naUMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJBEVxHtZVxQ8KRxMXmf1RUUCr8bPzH8hs35E6y/Aq6kAiEA9u5MwG6h\nTv90Q0iG9xbRbFsC8gKVFTSZzYVmnkvWETQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAa9gwKRsQ3pDCn5it7zjI8Q/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjExNTE3MTgtMTc2MS00MTEwLTgzOWQtZGQyNTczNTQ4MzZhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTI5ZDQ5YjYtM2MxZS00ZjA1LTk1MWYtZTUzZWJkMWM3\nY2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7V9gGQUnO5xmQu1dNQQlwdyd\nF/amECaRKvRuPy8EcbPizEY0kxJuGtIUC67eBMFIhy9BsaoMc5CeayQnal3+jaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUl6s1F5myPKaUX9hl8F+E+QhtTkgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAqvviSOZMBaAdT2GkvoP5C747Es7Yh\n00pP8n4Eac8bgAIgVcAqpgDK/ozKJSZI/Z7xONbmz5wDw9QB2+nwa86Zk+Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc192", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `192` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfjszdX31K4UBhJw1DrvyCHGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViOWMyZjVmLThkNzctNGRjZC05MmZlLTg0ZjEzN2VhMDNjMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzllODQ2OTMtYzBj\nNy00YmY1LTgyMWYtNDg0NTE0YjdkMmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZQEyVDdfNulTy8gpF2/Y5xloOGjyVimJYq9QxMo3VYRgUe+1t8T5I5oBFvF8\n8Qc8DWX5ZGY/fAF5L2lblQB/jqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsuvPsQmJQH8Ki43oOQUYWg1wUPcwHwYDVR0j\nBBgwFoAUMqbA2PFLXULu+eRveoVniUJcLoEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCahLwuSiA/2uGDa1+79fkIeRQq0ZItE8a7w3ZwTrFH8wIgQAksuJE+8QzZ\ngsQLuDRrueC0Ry27fpD8JC2z2xDX2dk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS3lLTDtjoAliPsCGOieL0iRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjljMmY1Zi04ZDc3LTRkY2QtOTJmZS04NGYxMzdlYTAzYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmCWue7dKNJciQu0XgWVIG/PnZgR7asQudTQWS5+aEabA3\n1uqr+pTW46B3J58+GGAn+RWU5CDJuQQH03d0phFGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMqbA2PFLXULu+eRveoVniUJc\nLoEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANR3cRrnMwXZjc3BpBxgWUkS/5SsiE38M4UKW4vz6SYuAiBxG/oly5xr\nJ6YMN6tmvD2t+w30n5RRzm/e2I+5DI3pZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAS26Yvoyev+lBsLCfBK91SxWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzllODQ2OTMtYzBjNy00YmY1LTgyMWYtNDg0NTE0YjdkMmZmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWM1NDUzZWMtODRmOS00Nzk5LTk1MGMtODc1MWJhMmU2\nNWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0b2TV2nZBSvBBc0nX9fcsBlb\na5bo5rOpbU6SUA/rIbSH7OCnvmkFUcIv592cF85Q/9zeBWckgp9kBkVWaJIwdaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsuvPsQmJQH8Ki43oOQUYWg1wUPcwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA7+U3QWUyMrpSisV86WuUjGhWxWK4\ndgXpqYT2b7zj4ycCIQDnDG0PNDDgrFO8GVPMdROh98TqmSACAvGrWzOMg2X4gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc193", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `193` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAdXl12JAOeQ5BDt868uQPtt0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1YTY1NWZkLWMyMWItNDkyYS1hNTUwLWEzYzg3MGJjZGU0YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI2ZjgzM2YtMzcx\nNC00NTBjLWJkMGUtMGJmZTYxZWIyNWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELi42mVWVznK8AiQQaQ/kgfWjkxyYrgKiHl9s9HPLRfdvTz1ibM2DBWvJAGr3\n40YvNIHRjlvmDbtTY2+S3assQKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyZu4ictcKGOUfEvsXsSNcQ4dF74wHwYDVR0j\nBBgwFoAUiXDCp1yC4MjQvVCTsBykKmgwl1kwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFJG\njjXfwlGoOoVh0OqAIjIoeCPbGUOqWLJDcGn0Pb7BAiAukgQF10CNmcpWEXyS9Vix\nTF5mitsNho85LMrJ/a3fcQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATlHmpW1rJ3uejl3dgFC3F60MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWE2NTVmZC1jMjFiLTQ5MmEtYTU1MC1hM2M4NzBiY2RlNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKVSZ7EEbtJmW5FmcTN2dWAzkHzKAqAZ9a38/0Hf9oktEi\n8+eDwXxZUz3Q7ZIWqDj1wo7Ejy0SgC6fApidO248o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiXDCp1yC4MjQvVCTsBykKmgw\nl1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJPG0oAcTjLsMybxVyTdAeldeWxHdn0M5tEpFzRySlMJAiEA0S0AxRXT\n7dXaxjXFbSrjtN+EebJH0TUNjtxPTAzfcm0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdDZ3DO9cp2vysbS8ecRyExWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI2ZjgzM2YtMzcxNC00NTBjLWJkMGUtMGJmZTYxZWIyNWZhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDg0ODQ2ZTItMjRhOS00OTFkLWI1OWQtNjE1OTk0Y2E3\nNGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA1wyaggdAo3xm1deTsS7dSGV\nAAzBJu+OTHGkpP1QrjArBA2KD83MkZRg+0+rOXtcMnbGwswj8Dpv4huxSBZvx6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyZu4ictcKGOUfEvsXsSNcQ4dF74wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiB7e5cnLVnq0/ihE+LLj8G5J6BJ+rPm\ng4MHRRT94W88KAIgHzVGI76xFYUUImJUkNFBiJWza8hrGIkcbMbLI2f+NJQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc194", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `194` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAX9S0SEdTweJ91vuuhnRvx0FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwZDk4ZDk3LTYzYmQtNDQ5Ni05NzEyLTIwNDRiNDMyYjhlYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmIwZWU2NmMtNTc3\nMC00N2IxLThjYTgtMTczNzRjZWNmNjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMZZmOqAEHWDFeDTNcXznZxGz2j0GTQvPKkPFIGcI3L2cYDCGFYZWqfNs9Hyp\n4r0VBp2rg3H5KUinlcHhuqYQ7KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxq/5SiZ+KmxiyBS4zooEqbNyqlgwHwYDVR0j\nBBgwFoAU23UaGmqLfeT1CQQ18NtfAYKF/q8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC20fjVC0L1YTnjnVFaD8YcToPJevZTr4hIVc7bit4XQwIhAM/q\nJiOAgR6VLXnNjN3k0AC1GiUPAxxgDYwMig7JnDus\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdsre5eaVTnew+2cP4MwYh2XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGQ5OGQ5Ny02M2JkLTQ0OTYtOTcxMi0yMDQ0YjQzMmI4ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV31Of9yA5larzZbFhjXH7MnTZocp8udvyX0wAUtjdOuc+\n51YZrhPepPoCYP3KBLniva3qHfo3TUhOPoc46l7qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU23UaGmqLfeT1CQQ18NtfAYKF\n/q8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNSpkiWkQUNchnSX2ab/ZUWzGZ5dN0mAYzTfJrKexWZ8CIQCCR6pWNQze\nphBifscKHLmGB63rZJt8UXFVyrwrQTWSpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfE5oWIxAXW9vxersJiBT+4wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmIwZWU2NmMtNTc3MC00N2IxLThjYTgtMTczNzRjZWNmNjIyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGViNzU2NzQtZmQ5OC00ZjE5LWJmOWMtNjEwODFiZjk2\nOTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9/gmObG72ffwmmVXJTqfYtRM\nfXxI3ZvrNaScW2qgshwbLHCWGR9R78L06R8Gu1D4HcnwmvgmAtDrmwW+yWOLl6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxq/5SiZ+KmxiyBS4zooEqbNyqlgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAgEZ4hJS6wYoQXsFPryB2UQ0NZIKh\nbyQ2a6jKQzx209sCIQDQx2fN9wLLq9u1vw6OtYGG+ubdCt/7WfTPX8nQ9TOV+Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc195", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `195` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAevYD8ZjmVw9QhXYsXKs3ALQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MjBhZTY0LWY2N2MtNDQzMi05ODQ1LTU1MzcyMjAyYzZkOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE0ZDM0OGQtOTEy\nNy00YjVhLWJlMzktZDJjMjE2ZTIwOTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbH9EW8XLDicAZKdZv+Agfl9JGBOkbLbqiB0hHAW8JRoBw5DtYKW+zdNOphBN\nv3Zsrr9+p8QBagqm4c+Q6rPoFqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKQ9p2a5fCch4EdOh0PosBZFXweowHwYDVR0j\nBBgwFoAUkL0djbnE2VkZSV6zT6KoPRPw+tswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDRxkN3mSIVdraMBRS4KQIL2lghs3ozkUtpqkowd+I/PgIhAPGH\nhzIfYyJEvaUGaUFAGnaXEXIWsKuIOE4ungnj3u72\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdRgv6i03iuFRNM7fIFZXov7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTIwYWU2NC1mNjdjLTQ0MzItOTg0NS01NTM3MjIwMmM2ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2Xo5xMRNe9Vxnfx0wGoyyflKsWhb8ta75iwLE9Ii46Zcg\n91TDhEG87N3AIfoZ00cg2lFubJj/6brZJ9bf9m1ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkL0djbnE2VkZSV6zT6KoPRPw\n+tswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbfkrtxZogs/lQjDuF5+9J3xz3/pacySFHHyjxI2CioICIQDafzkB1rDw\nm9l5x7sOiG1LamrvVhzkHs9e4y1L7iV9/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVuXRvn7y1DLPRDPTRjj12VSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE0ZDM0OGQtOTEyNy00YjVhLWJlMzktZDJjMjE2ZTIwOTEwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWRlNTY2YTMtY2Q1OS00Zjg4LTg2NjAtMTQxYWFjOTU0\nZmNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERL6BiyPjLd9h/px5RUPDa5e7\nAmT3tifH5AnyqJfm39xNJyXi0Ice+ZmvCS6Lr1v10xlg84vK3MV1HfowTmHhgKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKQ9p2a5fCch4EdOh0PosBZFXweowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAk/9Gel5tnFQrLmfP1sgGcl8KJkne\n/9/QHPbySUDJR1ACIQDEJebozVLKAOtZM2aCwYng2K6srpcHsrPmmKWe6oGYDg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc196", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `196` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAUbx0uoUFqm9O5Z10OSdGrSyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0ZWVmN2Q3LWViYzgtNDE0Zi05ZDQ4LTYyNDM5OTBkZmQwYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmEyNDRhZDQtODk4\nNC00MWYyLWJlZTEtZTgwNjY3ZGMyYzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfybSzMjf1P2/m8Eq5WCiXWLqTKl0dvVm+sKbKD10VzH9/dmiyBGXLfEACtOB\nTiPVWaFx5ooIWAzV8rqX3nfNIaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRdY+8GMXQnohBIjX909TPYgRhfvjAfBgNVHSME\nGDAWgBQNm1E2hSQvXMb06/CWVC3BMdXsDzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCFpo0qfxwFHbYeCqyOosEx3UkhHdeo\nsTivz6XjhpqR9gIhALg/JMPahRzIHH4/kklrMEFeJvg8CzKnL90WEdqxmzxK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYSFBkeu2TQuuKuhOD0bonC6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGVlZjdkNy1lYmM4LTQxNGYtOWQ0OC02MjQzOTkwZGZkMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZ9sFk3SXnZ3jRAquc8ZAonvq8l5gKe/T+w4hHUaJM4BXs\nD+x2gZ5+yQwHG4jj50wskidxKhLi04rPJvQF3fNBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDZtRNoUkL1zG9OvwllQtwTHV\n7A8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKX8pwGfYGG12cQxxGVzGX6UKUusEgu0q6GqXADGG0aXAiEAwT6LiZQ4\nycsl25LjrL0cClOb+2Be6Dpn5gczYWJxnj8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUjUFsPbfFoSqEebMzVDg6ytMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmEyNDRhZDQtODk4NC00MWYyLWJlZTEtZTgwNjY3ZGMyYzRmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmMyODEwNGYtYWUwYy00NmVhLThlMWYtOWY5NGQxZDFj\nMWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaycBJ9iCtBG6zg1f2KxbcsRO\nENpd8v3LM76fSTI6JqvWz3Y33JSArl0634VnBK/MZDLGLkSybkeqa0lxnhD4wKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXWPvBjF0J6IQSI1/dPUz2IEYX74wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAmlumexYlQs6Fi2BVaTTkUI8NnPA4\nDvGYDuhuso2REAwCIQCb//0Qp+18LA5b9EmFBEQf5t9N4nvvuN7TXR1bChY0Aw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc197", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `197` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVrJCAYmjcJTjQk8qMt3ifPXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0NzM1MGYwLTlmNDYtNDllZS05YTM4LWU4OTZlMWYzMTE5ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQwNWQzZjYtNGIw\nYy00ZGQ5LTkyODctOWIzMDljY2Y4NTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe/F050e/zqPN54h3e+xRolouo7D9Ki8lOea3gimXjF0TY0ZDILWgKW7h4vO4\n5slNWK6/9ds8bUGc2Jvb5G0QyKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ8zzSKvd43r67Wpjm4k9qSsrFtkwHwYDVR0j\nBBgwFoAUY9KjMwPl7X2cu4PLoOFb2+kif8AwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIB6bIDTbgvJt\niMtFF3fvm9LV0kEZz+PtZTz27wASEBA5AiEAtXmsQbmDZ1dK0LfTSYlgQdmLDfiT\nLoKBTaowZVSAZ0Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf0RuoCspckUXVkFURNCSZkLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDczNTBmMC05ZjQ2LTQ5ZWUtOWEzOC1lODk2ZTFmMzExOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqnsOwo7f/2MwIp7yRBUoWoNE4ijAnMoJdmTELXxLtnUCu\nCwFCHFV+BB8uAQMJwRK+3FwSSdJWi3z4E1HAcPaZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY9KjMwPl7X2cu4PLoOFb2+ki\nf8AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY9ysM4Z0pbTM/BDkLOQQcsa0+5e8HVopAjoet5aT3vgCIQC92p+VleV5\nuLBeKjjbGCMLalbI5S22B8sEZwylfWyK8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAe/kBr/1z9PToCllWgFTWdSUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQwNWQzZjYtNGIwYy00ZGQ5LTkyODctOWIzMDljY2Y4NTZkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDcyYmY4MWUtYWNiNS00YmU4LWEzNWYtZGU2NGQxNTM4\nMDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkdP/lwFayxHM0GdJV/Cexa2A\nTKjARHT7jpCTf+MBktLN8AUAOvOOPIUiWGbdH2hRjVHKSlM2Obf8AvBjaKqV/qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZ8zzSKvd43r67Wpjm4k9qSsrFtkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAxFsvNlRh1xr+X+GvuA7JiFCYZsQU\nSNvZgwJd0bdW5EcCIQDyKd3tH7Fxjx/a6j2oE4jDDzW2UZGRGqccIFrO5Q52/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc198", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `198` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAZ3OSNXXM3RlMwbcwwNKDb7hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0ZjM1ODc2LTY3NjEtNGEwMS1iZWY3LTIyOWZlNmJlY2M5NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODY1ZTJkYWQtMzlh\nOS00YjI2LWIzMzYtZjE2ODE0YmY5MDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE7/rpjDfbhJx8vr2mV3HqzjISYWX45uEZnGOxRwatDf8fchLf8VFCr2e6VKi\nV4EkEauFNIdD/CB9/OAow9XRyKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbkqvu5S6A8avmWKBU9x+KwZcB7swHwYDVR0j\nBBgwFoAUrkweaQs+LL/730QWmNBdaGrCx6QwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDyv3VNavr3\njNfGQ8wQRwNO3OL09t+TsFLhga+vA3FLfAIhAMbN8b7BLw4gezVKg2j+l/25aYVs\nSF+XX/a+glQvGLXp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd0jVtNiBPkngygiuP4ThCQIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGYzNTg3Ni02NzYxLTRhMDEtYmVmNy0yMjlmZTZiZWNjOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASr75XdsZ+EdzMy9w2i7L76DBbyssyAlkFiRAwTZrqbYMfW\nyVtN9vAhpEMzH0pP1eJCOnVIppuWOQSuG0Nn1lcbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrkweaQs+LL/730QWmNBdaGrC\nx6QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALaBLhshMqIqEZa9rKSZjAAlOTsc41nRJJt+gpzNo2qaAiBumItURPT1\nECWmb+zBSk1e1Nh8N3MWzkUTvfIWD3BNBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAY/sAYLm0qlnur0bKnZuNvMEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODY1ZTJkYWQtMzlhOS00YjI2LWIzMzYtZjE2ODE0YmY5MDc3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTgzMDNiZGUtMTVkNi00YjkyLWE5OGYtODJjYmQ1Y2Ex\nNjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOmzycR6hGC4Q6jKOqIkmiv9b\nkSnUPbl+NvtETuHkE5UxuJABeOJwY8UsgkorjX9/6fXi6UJeg/35Tsl95yEWSKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbkqvu5S6A8avmWKBU9x+KwZcB7swDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAKBWOB+fVUA2ENZDE0vScH81m1L9VU\nIw2jGGeIwVvPwwIgH0A4Nb2BemV9PgdzKHyfLEA1hbGdv0OEMtea7rwX9Xs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc199", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `199` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAT7Xxh9q1JJt/9J6XMm6QzCtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2NDE3YjMwLTA0YTctNDY5Yy04MThkLThlYjA3ZTQ0OThjNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNiMmQ1NDQtMmY3\nMS00NDY4LWJjYTAtNzUyYjc3YTNmYjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENiXiyk3FREGTXn2o3Y2aVsIarYnACXjHPQctVAUi2/sHfUQZFNdg/ayX5Kua\ntAhZ+TZ2fwFDz6Sg3Es+q1sCpKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK9XVbKGdezRXnFMzmvuLz0/1nDowHwYDVR0j\nBBgwFoAUaSKOmbpeBmeoYzebAYULOGFfgaowKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBpd8HxvLHu\nTSRBFBP/yaMXw3bI8bcYvJnvfQ6i/go4QQIhAIsF8jS1cDsmdiOe7X4U3U45v9F2\nvKbJoakjXqifstU9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARqxfb6T885umqORMd9qiUnQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjQxN2IzMC0wNGE3LTQ2OWMtODE4ZC04ZWIwN2U0NDk4YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvcYhe3DN5c/vYD4AYr4hvFwG0qGc/2FtMmMozijHC4YFu\nZrcBosFLB/6La8KioRMeSEgiyiY5nHpVrAd+84W+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaSKOmbpeBmeoYzebAYULOGFf\ngaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDYUujeXpUTOczWj2yCc9Bf4cLqeVrZODD5iDvAFDyNQCIGIL7TqLtJE0\nOaOOKwZ/vKDbf0paMLjs2l8ErHEnLiPn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcUlS/6mwqh82UbcG6oLYoKKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNiMmQ1NDQtMmY3MS00NDY4LWJjYTAtNzUyYjc3YTNmYjMyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQ0NjNlNmQtZTZkYS00MTNhLWFlODUtNmI2NmVjNWI3\nYTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKuQXwU6dsV2mkzuLKBNUEB4h\n/o6UCmV4zaxcyzYEpVBGr+Jk/BrhG79Jc8P/4tnrciqB20tORL18pKNqu6eREKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUK9XVbKGdezRXnFMzmvuLz0/1nDowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBWw3pT+9vJG/htBDJGK9XOB+Wkmfpu\nx6K+ByUiNEoD+QIgD87mNnlaIJPWnZeu1lNvW3HEm5kZhgkqW+kTBFdGbks=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc200", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `200` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAakAe3LMXe56o+tX5MSSvrPnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmZjhjNjAwLTZlMGQtNGY3Mi1iMGQ2LWI1YjBlMDk1OTRmNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDljNDI1OTMtNjMw\nNS00MjI3LWE0YzItYjI2NTVkY2EzYjQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuTvDqkg1nX887rTMSsEitG4DnuvsZYL/cUwzEjSeX/AFryx5df0LOZ1a4wca\nIPJQMV+kaeOuTcvd8hMZduncvKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQXPbH0TaGr27462mA9cvhTIZixQwHwYDVR0j\nBBgwFoAUNCjmuSU8kTDYBbszu8MO0eqiNK0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA62efTAkPm2tmanWcFGxrkkNOVq27whUksCbIL/I5t50CIDMWUyAsMC79\nG5SZ5VvkIQi8pxOHzZcfTRDsjXrHEkK+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfTB8v7BbUjoUUr2NnnNSnfTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZmY4YzYwMC02ZTBkLTRmNzItYjBkNi1iNWIwZTA5NTk0ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZCnFfTVb3h1CTv0SSF6M1ogZdPAEdJa19iEbdiigS38CX\nzujg6fdt7nQhS/jyS8Uzz4FipdMUC3Mv8efUUcyJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNCjmuSU8kTDYBbszu8MO0eqi\nNK0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQBvo6YK2MnbNiEuUNPfAXBJM2psw94ouRdIMJ/GRqgMCICysL0e5O+Fl\nViG2mQVvfZHwNZIYdw1PtQ9ZjZm8/DZu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXaBxBZFkYagVZ88jgTs+j+MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDljNDI1OTMtNjMwNS00MjI3LWE0YzItYjI2NTVkY2EzYjQwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmM4YzY2NGQtNDRiMC00ZDI5LWJmYTktMWQ5OWM1YmYw\nZDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsXWb37U6lCMphXPYO66yKfCk\nT1YTVSK6VbcToG7hzSB0xYJqnJzCniws+a1uyWXeeWthGKbbnC/YWlIuwNYO3qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQXPbH0TaGr27462mA9cvhTIZixQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBDeRSSZovl1wsSYC7TPzga8DBJq6n9\nUvl+B9gk0ohb5QIgDN/3u1sh+YgTnihOyQ52kni3/0gMILiq5290hfVucI4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc201", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `201` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAVKRvNuqJabVC6j3YNBerHhxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYzAzODdlLTA3NDUtNDg3ZS05NTMzLWM4ZjkyOGU4YTNmZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJlZjg2ZTUtMDM5\nOC00NzZhLThlMzUtNDQ4Y2M5MmZiZWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEFMZ9sh70CaIvXUTarXvAuhhlcwZU3/LTiIoX1gOJ8vxzKZEIJA/EPJA1PbK\nmSWgLqYj0spkWXsjzmpIgb8WzqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr3yFx89O8tOJUF+l6TP7UlgiOgYwHwYDVR0j\nBBgwFoAUfmclQp9tqj09I/7aMqZ7AAotv7owNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiB+2w3HXp1S6Gd9UD117fn8gqMaAKSAvnw28egKPrit0wIgRoOAuvOclt/l\n6zIDRsFmojw5UJTc0BUbfO34cNjERrg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc32B5lbQhMPr/6Be8QEyRtrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWMwMzg3ZS0wNzQ1LTQ4N2UtOTUzMy1jOGY5MjhlOGEzZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBntqKUZeKfmeSbRgegK9kH0nXgQvryJ8t6h8+rjSlOo91\nlFQd9a4bazKgPJePJARf1EzdN9L0kLaP8fUDRa5Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfmclQp9tqj09I/7aMqZ7AAot\nv7owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNwmvZvtYJsVWvJsg3vCt5slSqgRq0+u9Vp+kheDnEb0CICQbSb0H5ceM\nbVA0ihb/4UxgJZNqzk43fwkMH9L8tMBt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYQXrdXo3J2N0eRaDaMezz3PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJlZjg2ZTUtMDM5OC00NzZhLThlMzUtNDQ4Y2M5MmZiZWM1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmNlMDM1YjctNzQyOS00NmY3LTljZDctMDk3YTI2ZmU0\nOWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1nb0s7WZgoHBdKwfn0TseKl9\nqE+MqXkyqmVRhIXiTqGUxnuEku59lRC1Yck16FLtrjgtSPekmxB9e2gM/hUtwaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUr3yFx89O8tOJUF+l6TP7UlgiOgYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA2XRnxYKxn4jHEfi319VQFNEdMHZC\nQfO9WiRnPK9y2F4CIQDpB/rJsFHwDg75FpJ1CaVoVdOMhFTdbX1hnSRjJq3KMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc202", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `202` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAYctZS4cyLygB1psllvpxI/bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkMjIzMjQ5LTE4ZDgtNDE3OS05MjIzLTNkMTkzMjA4ZDFjYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdiNDk3YjAtMjY1\nOS00NzNkLTgyNGUtMmM2MjBjZTgzZTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMLll1ge8gxM2hWYXawF9XUXeZmIFaYys7jq9msyhnOJxTihnZuF6LMXn0dp/\nSon+x8ZiWNWQTStQEaqI5Fzp26OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoibCb1bJ98nKYpgDZVTqgd31xoIwHwYDVR0j\nBBgwFoAUvvxzSZNJoq0S7OWiLoJxios2vfMwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\nuLP8Tx5Lhp7qA5Dv8Iu5iIttJbJqsIDXW1N0N64XtcMCIDF4iezzkF4fefiFd+Ol\nzx0/ZZ9D+ubLF9KZSTdEtRdp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdoWeHu9qVa573LoYY58FNMHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDIyMzI0OS0xOGQ4LTQxNzktOTIyMy0zZDE5MzIwOGQxY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkknIBdpgOM2e47wVk+A1Ccmv2l2dJtcFahv5fdfKJegzZ\nGgBJcrkZs9vLNekJN2un3yZz2w+jNPdkzqO0XlTvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvvxzSZNJoq0S7OWiLoJxios2\nvfMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ9hD+MISNDVpeau9iUZdkhVuJcALwHVMeBtYS9keK3DAiBiG6fngzuI\nc2pQu728o5rnks9NVINuoSTn38LHJqzFxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbS8X3/T0z61VADvhYjWmSkGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdiNDk3YjAtMjY1OS00NzNkLTgyNGUtMmM2MjBjZTgzZTMzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzg0ZTAxNTEtNmQ1Mi00ZjhiLWIwMWMtZTkzNjI4OTk1\nM2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELXDr7EdTEvDLwsNhnl5Piv+S\nQi+pU/IwUhH5cy/RlTSSuSCcbEVjk14LMtGtR1AnQXWJ8e5zhKLVUxzcoZtzsqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoibCb1bJ98nKYpgDZVTqgd31xoIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAmvtFQVzJcCoNG254na57tmEcPG9JY\nDYCAs40qkn2qAAIgbtiQ90YTa6p+GzSdtGSFKaFI43jA+duZKLfTgZOM/M0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc203", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `203` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAT/QOE9Nrq9hxYxE2FsdT0sEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiNWEzNTg5LWQxNzgtNDYyYi1hNmRiLTIxYjUyODRiZTdhZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGMwZGEzNjAtZGM0\nZi00ZDUwLTliYTYtOGMyOTBiYTQzMDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE6Xs53zWYfC909HxRTTeOfbEfP18lfsPvw6yIUfaFSn0KBOZ43/IAO+/JCzr\nt6Bx0qRNMq21z1Jr8lq8mIVRXKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl50bPsepBMRTFxaCgtQNQZmLPLYwHwYDVR0j\nBBgwFoAUVGV7+tPE0h799jpt3p9+SG1s5vMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAI6NEWBWo9LwmnbhEgFcRAuvAXuz/8h6tkFn2MR0fVeAIgBbmu\nrvG7Pjd/NlF1bUCK/48GP9i5vU5/iIevN6Kk4vo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbEvTw0BO4Rl+od8TxSE/zuwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjVhMzU4OS1kMTc4LTQ2MmItYTZkYi0yMWI1Mjg0YmU3YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFISxXwcoj4maOm48Kwmgvb8VopT7yQRYtbv1fCRkq07V+\nrvjRMKjbRnlGQuZhOLr88RjyH1pcOm/b+WbHfrE7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVGV7+tPE0h799jpt3p9+SG1s\n5vMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO5g5hpuVYduRLxThlD898kWZWOOBdYApHmvmCpJ1EsxAiACLczfUGpy\nyALWWv4yOBPwg7rgroBiv0Y07eb4bwjU8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYSyL/0Jsbn9TWoalQTxMaR3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGMwZGEzNjAtZGM0Zi00ZDUwLTliYTYtOGMyOTBiYTQzMDZkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzUxYzJkODctZWQxMy00MTdiLTllM2UtMmY3ZjE2ZTAz\nMTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEouOKozQQovxf934hGt/3XlKN\n03L6IrZ7EKm6FBGgbwDj86HJGM2vQkh3kO4+KUPaRlW/Ph5Jy5RrPDrZFw5+SKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUl50bPsepBMRTFxaCgtQNQZmLPLYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAIwtvM6UDH5sMPjNFkdSEhEiaSvqOV\nSGvRWj5kCz03cQIgVLF36/5+zvmzO75xpuH2Fw++c/dexig2j5q3sZYCjnM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc204", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `204` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVcs/khMzvNqPfGZ6htYYkTZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZTA0MTBlLWU5MmYtNGMyZS05YjdhLWRjYmEyYmJlZGZjNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM3ZTY3YjEtNzZh\nMC00YWY2LThmYzUtNzlkNWI3M2MxOTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnEIrBoPV/Z+c3tlvHpVcVMr0Al7Qn7TFCT06uT4ikqSadkDVtEwbAMH3bdHT\nXJgIdVbdVEV+qfXaVHiIdtzDi6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxAvnsz/Q00wp9bRp+PVP57+z0yIwHwYDVR0j\nBBgwFoAUErtejS5bpHxQuK8pU/C1JpO3pd0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiA7fgZVlHfCesAosaZdQ80csUE3zkZT/YUIfU8VfRDRYAIhAM9A\nTfOJpmsBNvPbyhpDmOXfw1yIhhRFv5CvnAQDeOe4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZxpDJGhcn6hOhAfAy5iMoKyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGUwNDEwZS1lOTJmLTRjMmUtOWI3YS1kY2JhMmJiZWRmYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASquxTMe7a3H6mKO0J5IDeXThB/GDe4/o6uoEIW3u/80sQr\nCQwtYN+WVMDxhq0UdSSYpiMBoh5XPgIIO12zv9j+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUErtejS5bpHxQuK8pU/C1JpO3\npd0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJn17F9Mcyz15Mo1sMCy1axERadIC/SJB8RO33HTIWOiAiBeyT5/lE94\nTaszSOziScrkqqfDjoHhCuDrxf+EsV+SXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVfTSM4E29UBSI+zJaw1F/ggMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM3ZTY3YjEtNzZhMC00YWY2LThmYzUtNzlkNWI3M2MxOTZhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTgwZmM2MTgtNGYwZC00ZjZmLTk2MDItZmFmNGM5ZDcz\nMDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzIyyoYOp1DilZNTurECtYlE2\nK3k0qe5npyiKqmqQhMQ6sixzZUFV5yl36wcg82irK19BhuqQLHRY7mMUd70VKKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxAvnsz/Q00wp9bRp+PVP57+z0yIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAedq0r15CJsuXpUZGx/i89U/pb2A0C\nilZ8Y9bG4bwPnQIgc3iUurN1OFIWCysgM7Uiku70PsXk9+328dcICst1UlE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc205", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `205` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARMCZ94NU+barB7m4n2xECQGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhY2E3YTlhLTAzMTgtNGJmZC04MWY4LWZjNDljMjUwMjhkYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdjZTViNTEtM2E0\nMi00Mjk3LTliNWEtYjdmYmZlMWQ1MzA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7T+lAYcRzT8S0mD50pKqQglYZXtTsjvDni2gJgcH9CbwP2AvhFap67baPJ6e\nL1+4GvOh1FTaWoempNXkgEMCw6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYqBUgcTwqMYBZ6N4NiKdQs25HikwHwYDVR0j\nBBgwFoAU+gjCaki/pKXFkh9qhMmRGLUC32YwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiA+ixp2voHsOW6X\nG+5eDfJpZdnkM0aNxpqRDYaQSfI3qAIhAM3Ox6yqUTVqMeuwwuBzV+Ze+TY5Ouc3\nXrJHWpP1XERO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZHrpYXaKttRqptUMeWauiGwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWNhN2E5YS0wMzE4LTRiZmQtODFmOC1mYzQ5YzI1MDI4ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNm6xX3sCRRNjBWOOxSXy8zJUZnwPWIsiIeVgklz2gvh51\nwGz4X0vwEPgJ1DyMcxvru3pJGuy6RZZZbRzWgghgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+gjCaki/pKXFkh9qhMmRGLUC\n32YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFWNVRczDIof//f9zd0gxLvivdbaCuvCplCTAeHJsRFwCIDxCDpxelKHJ\nKXsA7S+03bQq97Rwlt6YEII4nDqluApZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATb7fSqllXDEk97+EMDuaMobMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdjZTViNTEtM2E0Mi00Mjk3LTliNWEtYjdmYmZlMWQ1MzA3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjI1MjI3MTYtNjQzZS00Y2UyLWEzNzgtZTlmZjJiZWU1\nOWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm9XghwGhFjFttb1gtksosouD\nslwWJYFRKbzW67JkqmRMHSlAubvcj2xGeLFqYFjcXGJGnvUs/YoMbs9aW/kSmaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYqBUgcTwqMYBZ6N4NiKdQs25HikwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA3qDYx7pRU3nNvYoSYrpafmC99alB\n+ishImr1kT4V9CUCIH+X9PI/zm0EpSSG8gUP/3mE/Brb7zEAQC58fQowRsLH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc206", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `206` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZpVrLpN+c6G1Ci5D+7Lo+tKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0Y2Q3YjM5LWY1MzYtNDU0NS04Y2Q0LWEwZmY3YmU5N2FiODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIwM2FmNTQtMjAy\nMS00OWQwLTllNmQtNWU1NTBjODZkODEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUm+GWvC5g+FMMIVH8xaE/TcVotb9kmSUeY+V+Gxm683O4XJwJ01Bnqu8f9NO\nFxpPPS2a/D8K9utsfYjPl/JKy6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+iD8ZZ1s1Gw8a0Bi6R/JoGsjpUwHwYDVR0j\nBBgwFoAUHwtTb9wajNc2vEvBN40e/Z84k3AwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEtQvNhnkrY3VrwBgFj632/4WpQ+8QXvswiCOgAJTxtSAiBtBA43/w/OCdx7\nr+NKP7eaLC9DF7Hls4R8c4BuWLDSeg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASQJn2GqOshiBZlObkr5a7ZuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGNkN2IzOS1mNTM2LTQ1NDUtOGNkNC1hMGZmN2JlOTdhYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwZVaUHLuVRzOXbvq1szLGowkY+3ohtJo2ESUSfDBJnF0i\nYwwF1Hft7Q9c2+0lA7WrwDrI5EtZwHz4xwdfRrs/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHwtTb9wajNc2vEvBN40e/Z84\nk3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAObnju/J4JXUPaudyahq4PnehiqAzD1JOVSCwb4lOOAVAiEA1wp4OiYw\nxzj/zONib9d6B17tO35r6lGwq+kmanFifc8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASFLZ1baqC4jbAEBOMURGI0fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIwM2FmNTQtMjAyMS00OWQwLTllNmQtNWU1NTBjODZkODEzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzk3ZGE1ZTktOGMxZS00NDBmLWExNDktNTRmODI5ZDU3\nZjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZGGPK/Ayp7av2OcmJTKozK8c\npN2btQIsRhIfaDxf4Lioe006c7pjLYHhO6EvyRQslut1Y8lC60XMmSCEoiDUeKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm+iD8ZZ1s1Gw8a0Bi6R/JoGsjpUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAgSJHZR54ZGdbrC+5VPj3w6BhOKYt3\njCspcK+gnG3mSwIhANI3JbP8pZcak0sDcMuoNPodPwAHbpenua64ceahP1Ga\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc207", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `207` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAV4lstrf0SA0aBeprXfPkhMHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyZDgxNjFkLTQ4NmUtNGFiMy1iZTFkLTAxM2NmNWQ2YjI2NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWRhYTc3NTktYmFm\nNy00MzQ4LWI1NWMtNWE2Zjc2ZGU4MThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7pHvO0kkNyFQt/Dh1UObjdD63sbi8CyPmQVJ6mGzoqY0/l3p/j7nVMUB4SNZ\ndwOFYOFGLiT6oX1LWAoCGkQQIaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKGuUOBufqWWu/AP+gTNZ3+OnU/owHwYDVR0j\nBBgwFoAUDt+pjf/1gozaaEC2Ia8826UpvyYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCNGJpDP0hZVqs2ijpx7BKmbxUB71GW9KcIkZjh38FgkAIgV1iRUr6OnkDL\n1OeORLKtu+rCZKaRtffAb8mtEr087P4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAblL8WZ+ME04SIfZK5xFM+rpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmQ4MTYxZC00ODZlLTRhYjMtYmUxZC0wMTNjZjVkNmIyNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHNUwtAmfTjXMwYyu6Nk8ioEYLqtkTaGIEpFZcRpJKzKUS\nIwsO5aIxviskSXizpVMXQIB16ued0z8xdOZDjJTao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDt+pjf/1gozaaEC2Ia8826Up\nvyYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKhCtGGFL96XQCKqK6AZCYRNBz2vzQkKFezJ7eGsTbYvAiAr6KTKiJSF\nFags0EW9DR3wz5Lt2a5b0voC3nBMjEgvvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbJ5qjHRU2AsMyo6b2Fs+M65MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWRhYTc3NTktYmFmNy00MzQ4LWI1NWMtNWE2Zjc2ZGU4MThkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDliMjI1ODktZWE0Ny00ZTc3LTlmNmYtZDUwNTBjYTI5\nZmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQMrZ4zCQI4MOgwNXz4gkEzsT\n6XPv3CaTs1YX1cYGEUKc6/cozjgcIi8aQKrj2hIJFOLumaqfOgmEeIgVbwO4AKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKGuUOBufqWWu/AP+gTNZ3+OnU/owDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBtiIDmJ0P10yf5mEoTvWqorlThjkh1\nwWeGdgLXJovqkAIgI+PGV+0ePKNIirqndOCOuF2PI3qBhDqLTh8GH2J4Aro=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc208", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `208` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAaoEzY3q00kbkCLTCNg0o6LlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlZGQ3N2FiLTdjZWUtNDJjYy1hOWQzLTc1YWFiZmU2NzI1NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOThkMDA0MGQtZTBj\nYy00ZGJkLTliM2YtZGE2YjQ2YWUzMjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7tkJGmaz4zaWmbl6kBIO3Tw+9MI7/C7H5QkHHak1qTpQWT0Sew9BsjSRLGKw\n7vijexw8R7Uaij8TRftb8/Oto6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXcerDg7BPynbQa9Gx1KAko2Jty8wHwYDVR0j\nBBgwFoAUU/9++hvqIIQ1vL+3Efw4E/heJzAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBwaCYjtS7XI9Tdt7sO3tcRnlSsnz+XApqpmAZfw63F0gIhANq4XWHbll5E\nHgDkSL7j1a7QpLsvNjAPFDppUnlW1klb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATrEUPUZXr0moJEheNmZytETMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZWRkNzdhYi03Y2VlLTQyY2MtYTlkMy03NWFhYmZlNjcyNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjpS5Bu984pfvlDqv+Ut3gjMGcxIjdX70YJMBDKtDzco8V\n5qnQYjTmMzZXC/T12N7evJr+oK3GaTYS2VTAodVGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU/9++hvqIIQ1vL+3Efw4E/he\nJzAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALmpCD+a0Rd5ztVk3CasRH3TIHADMbxft2Uem3OdCmsEAiBVMb6RxSb3\nLGarqzeFfyMqhRGpr+En3gz5zjwG6/Tsjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUQMJesuxZpjdD+uwoCCr6EkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOThkMDA0MGQtZTBjYy00ZGJkLTliM2YtZGE2YjQ2YWUzMjg4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2EyY2IwYWItNTY5MC00YThkLWE2MGYtMTMwZjQ0MWFk\nODU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy1HscIAIX7VORVyzLs9H+NiP\nBN+T8qygd7xMueQJGrJhGqqETATWxDNthhIXQUffgbcP+txUIHnu7v44RvIfoKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXcerDg7BPynbQa9Gx1KAko2Jty8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA/Vugk+K9eC0ysxdKvmu+phR6c504\njzSxjU41rFdks6gCIQDf9pPCKnzFhHoW/NZjtMeNvvQ5fSDvt345wd25BxH7fQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc209", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `209` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAYbQi+QcUarrkd1gRy4oOVfnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0M2U2YmFjLTE5Y2UtNDUyYy05ZGJmLWFkY2M0MjljM2QxYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM3OTlhMGMtMDQ1\nMy00YTZiLWE4ODUtOThiMDg1NTUxMzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX/IXswZlqnBiA3KGpXRQDXRjAOHFfeaAENTDxn66hZdNi8qwBo5Tlj0Z1/i5\nEEU7yjI4DmLggmeLD3W7MC/ZLaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOQuxhN6HFKv04o+KVckhFEdV/zgwHwYDVR0j\nBBgwFoAUSBb+dnb9it6aShQLo9b9rr67aPgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBtOWf0G3Rlzy8kp0Yq6Avfjax9HxwMb36rq8Ny2Q6M\nnAIgLlhWwWUrKVRV9kxPeUDWGLOYuoedQtN3dvwHYEkXswE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASRhu6Oy9VuVJa0R37pJLg8GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDNlNmJhYy0xOWNlLTQ1MmMtOWRiZi1hZGNjNDI5YzNkMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnZIeD7CAx/BAW4iNP354+7ZaxJtMj9tYh3L+Cf+AKwOSy\nYWNsdyR1QxNfBHUaucIQr1972xuz3YY+Py4Fe7kPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSBb+dnb9it6aShQLo9b9rr67\naPgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEPq5/EofzNtkN5uIgTt/8qJwG7DiYF7kyiQN9cbV5WcCIQDzIzd5EBdI\n18xfjOjXiI/WHercjNfKoWdyWUx3Ovo9ew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeCvaxyWc+s0u3Cjw8xKQGvZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM3OTlhMGMtMDQ1My00YTZiLWE4ODUtOThiMDg1NTUxMzZjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTczZWM4MTYtZDU0My00ZTc3LTg2MTEtNDRiNGNkNWNk\nZDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsTpSkjni6hZagCPg42/QedK5\njk3Pv5+UX1hx+MLYvUlfRLMLWdNT6H9ukzhdUWHvwFwsaak2X02bHl60qMfZyKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOQuxhN6HFKv04o+KVckhFEdV/zgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiByGn0EGV3zBL2Qlb9KR0mOiKfUVQWy\nNORK1j9CHD5zNgIhAL9Po39pXFJotGxwvswow8rYxi5uxdGZkrvu4cqpc2WA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc210", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `210` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASViOqNqLltPiXHEImxIvuy+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzMWQ0ZTIxLTY3YmEtNDA1ZC04ODIxLTg3YzgyYWI1MDIxZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk1NWYyOTAtYWE2\nOS00YzllLTgwZjAtNDljNzYzYzM3YmQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFJP9LBz/4F7MDEvdDhT/KAYDd1x7SWqltt29o2X42gSd993mtD8NyiaZiaWw\nNx20E6BpUufh0ySBxVg1xxqph6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXQjd730tWh+PnW2XnBp1pPoN18IwHwYDVR0j\nBBgwFoAU863SYHx4d9yY7dRo4L6yGrW4UWIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAC3cb1Vd+oBUwqudJKiGaBKkw5SuzoyiqQPEyWSqoe\n1wIhAIDiTAF6Ei/acHgxsq+gvlrh0K6CdVdLyAhulpdVGFDx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATLrsnnUmYLkw/bEtXW03/iSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzFkNGUyMS02N2JhLTQwNWQtODgyMS04N2M4MmFiNTAyMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHpfKpBcuMAiSAfwJCb7l3BgBA4G0K1tU1CtOiBuXVfGeR\ntJKSotnD3ui8iLalLgNwvR/r8W/yegJkQbVqOt0Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU863SYHx4d9yY7dRo4L6yGrW4\nUWIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVFSaxtkJSaFbvoV84p5hYX0zKcj+QEpWhgBqNrYMQlQCIFJ4rPkQa04M\nzIFy+KyR4F55YVu9+Via0pj0KgIgfUoN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQffirIjo6fwjbLQbcLjCLcrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk1NWYyOTAtYWE2OS00YzllLTgwZjAtNDljNzYzYzM3YmQyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjYzMzkyODgtYjZiMi00NzA0LWFiNjQtNmU1ZTY5YzQw\nNmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAtUcED0ZKiTflxNajmQ4Spb3\nRz0fWY+md1M0wzT67ZP1Jq+dYdV2jZvIM6Av/nL1lw1ljtrDXeUhvA1MT6QxwqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXQjd730tWh+PnW2XnBp1pPoN18IwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAzrECFqYHIp1mmvpDkCUSmusZ6YDm\n3cEZKifUom8SPJECIQDeVetKgLaQpoiGkum8obGvt3KVL/hAcaZ5kQkgzC8wHw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc211", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `211` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAaAVPB7ADz00lVhldRFO2+EIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhODk2NWZjLTczODAtNDYxMi1hMjJjLTE1YmRhMGRlMmU5ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVlYWI0YTUtYzli\nNC00NzkwLWE3NTMtNDhhYjkxNjNhOTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPwWqYzmMxJmjXC9LfSGG1SflFKW/F3F1TjgmPtlc9k+LFy1yuBCWyZoh8dqO\ntnTHoLCLga3qg/GyaA4l0xqgzKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxV0/OMD/zZViuCj+VTsIaOkuaL4wHwYDVR0j\nBBgwFoAUtg/TDmNx0lF3yfJ7bpBUHomPaDUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAtw5DFyrI+/Uvv3zhZ3K6lr1MkjrNjYPFy6uwHTGUoLECIQCc\nogS1rnvio8JPD/bh8oCS24HLLHVI0OTwZI1ohgw8dA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfVw2DU8N6adJRXrpNUk5CbyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTg5NjVmYy03MzgwLTQ2MTItYTIyYy0xNWJkYTBkZTJlOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATc092v9z71GNXLgii3A8otUVZlBpwPjsczEo73eRqlAlht\nl42MJgOrytXYN21H1CRsjeKf/Xtfy/RcG738+bJ3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtg/TDmNx0lF3yfJ7bpBUHomP\naDUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVVPHr4Ammc6Mx2KeyVFyJRSPkMTZE3Wa7rqhvluUPgcCIEg/2O39hhzC\nAmhw2YfeECfSN28jVQxUASoMQ+pFRM20\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWNKMMKwAwBY9IKQBljGK71zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVlYWI0YTUtYzliNC00NzkwLWE3NTMtNDhhYjkxNjNhOTE4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTJlMzYyM2YtZTU0ZS00MjQ3LWI3NjUtNTJhZDY1YmVm\nOGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyM9mGWnKtcK4mLB80Wpcn53t\nn9Z1Yt9aAPJX4acRQdYb/SKgtGrT+/NAQi8COY0I9kc7o36ktS6xQnrxd+bq56Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxV0/OMD/zZViuCj+VTsIaOkuaL4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEArAW9aJHl53rFHeNIJ+pa6X9f+FA1\nm+NNcE2TjS2hfBsCIQDQBtY8tVMFNUWWTMBktqbrxsni23+y77CfPQi8iVNssA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc212", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `212` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASlji9sGAxGoZYRjvaR83O1gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ZmY0ZDc1LTQ1NDAtNDFjMy1hODI2LWRlOGU2MDRlZWY2ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ1ZTIzZDktYzc4\nNi00MTM5LWFmOWEtMGYxYTEzOTMwZjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4ExZhGPHskrpdyEqoeWf7qpXNUbuw8iXnlssI61SegDxrsZonYow+h0bnBLm\nlL9VnJ7lvBFlWw2Ozkytsq5iNKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMntDokYOVh6ffMJUg6aOlu6FYG8wHwYDVR0j\nBBgwFoAUV0cap8hH4+gr9nye00G9wmEjaNIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAloKueiwmRMXesli/z723zU6xd33Ocj/t\nuiI1emQWhwMCIHX9W5aAGXmdDcN6NdcY2O/mZDkrwxfXlKXSyKszglx9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVhv9Gd0XqAVN/0E+NbuzFaQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2ZmNGQ3NS00NTQwLTQxYzMtYTgyNi1kZThlNjA0ZWVmNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmDSwGMdRxBoDTkLRqxYxbgumYqUDEmj1ACCXMwtComFl8\nT8qt/wWTGlQzJ6kjZK+3Agvm0FbO9x5oM0uNRAxeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV0cap8hH4+gr9nye00G9wmEj\naNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANfY6GmePbZ1z4tKUpL2al+T8301/Md+FqCoFQRXPCXIAiBObWzLoitC\nNIY1ZIw8zstNEK1iNkP3kT4mcQVIzm/owg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAanlcYAeWCBHh494aukG7BZiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ1ZTIzZDktYzc4Ni00MTM5LWFmOWEtMGYxYTEzOTMwZjU3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDA1MGE4NDctNmE4NC00ZjAxLWFkYjAtOTNjM2FkMGMy\nYWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn7+u81cxkl0jbBDPhPM6BnHU\nkqGtmHWCHg6eXRtfhskCY1hJ3glscJz0zgUplHA50f4dyqT6Z3xnZqxVvClJKqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMntDokYOVh6ffMJUg6aOlu6FYG8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAcRmNQrQBOwubsbCQQ0GJ/KL0u4pGF\nqmwNnwhh129f6AIgMxYM8WJguBv6GGGiIejpiWVdwbQvZrjX82xD14vN/6A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc213", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `213` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAYrwg44A88uAd86mlhGeO5qbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlNGIxNDg0LTM4NGItNDkzYi1hMGJkLWI1MTdmNmRlZjAzMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU1ZWRhN2ItNjY4\nOC00N2JhLTllZTQtNTJkYTNlNzg2YjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZERNnn8k/ldoBzsiKVUG5MHt4smU6bmA3XddWcQloXvagqE1bETixL4r1Nrc\nq833dqhe9u7XdXhP/9OZBiYO7aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3g2jjpke1scHgXzbVfCBDHbyTbswHwYDVR0j\nBBgwFoAUWMCu1rVOrBXbANsa/m4kOHvgGFAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBuYsuxy5vrnOWyZr/+aF5IH9AerbOPp0Oh\nig+SKXwSowIhAPdMwRlD0+Fnsd7chF9KIlnA100SxmkCvFCCxsaokwk/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW/UnBUvsi2+jlrY7lHvLSZjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTRiMTQ4NC0zODRiLTQ5M2ItYTBiZC1iNTE3ZjZkZWYwMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHcqdmVxTDV9NK+xiuSuGGp6p7zYCvZ2GcePGPFgHjqF91\nEpDD5K+vZkp29om0akXZBt/oRaKuMamox9cgNUUgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWMCu1rVOrBXbANsa/m4kOHvg\nGFAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTbZ8rls84wvsAUMy0V/fysiI3VHLAO0cvGuEkG2v9u0CICS0oy1Jqox8\nPCmlvD/Ku+d/4ak4ao5Mf8hDApuOp6UF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYTfrNRWrzGnZIg6VHHgYkhvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU1ZWRhN2ItNjY4OC00N2JhLTllZTQtNTJkYTNlNzg2YjE0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTYxZWM4NTMtNjNhNS00MjRlLTg0NDUtMzY5NTEzMTA2\nN2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7itz3WvHqfspjkGHU39MKyDh\n+tZQnDPiHglmFCJ7hRmmDoHPPV4PdwIT5R4O4o4GO7aPihqqD1OfvDPuDithE6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3g2jjpke1scHgXzbVfCBDHbyTbswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA1pio9ipBXvk22z+iF0okXyFw3mm6\nC1ZZBQFIFfFkKkYCIFGcvhQi8mBprDBMnu/rIrmapQrmNiMPiI0EQIh0cOG1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc214", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `214` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAe4OclYtbIeILHu7peOTUMYPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiYWIwOTg2LWM4OWUtNGJlOC05OTk4LWE0OTBkNTNkZjdjYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRmYTA5ZjYtYWQy\nMy00NjEyLWJhNzEtOWZkZTZhZDBlNWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBBrvnHYEmC9er3FA3IIs3NDgcPbv+96n/gYorCJGAwTJ/fNiaNAQF/Rm0nnZ\nGsh4b1SPFq2bNUGdJrLNAI3Lw6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUraVtquXfPj9FnaNlKurZxpmUnO4wHwYDVR0j\nBBgwFoAUpfjJY1IQmIxh3aiZ0XoWOs38iNcwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiASDsxnrAw9kqj7\nMf/EjuC5TgVsTuWz60go1rPsh7ti4wIga3WMdbVFL5VNNvfFI+1wPXNKiL+0dEEj\nEqLRxgEnvqU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXOp2SddQdg3idXwgaUxYzqTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmFiMDk4Ni1jODllLTRiZTgtOTk5OC1hNDkwZDUzZGY3Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJaG2Pw8wlefPUihlS5h17bH3izcmoxnLndohSzjJvhJCG\neJ67sCCE/kWRgcE+WM/ak9cUJ0GhRNZKmPO7Np6Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpfjJY1IQmIxh3aiZ0XoWOs38\niNcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP6gGMYD1bes6I0rR0akwzjgUE4DBpB9kH0O+BWe+wJgAiB/FKIQDrdS\nKC2XqWhxqnYqtIJ+eZl3x93GcaW/Hp3m/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARUP2bvEk0fIrerzVpnGtUCDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRmYTA5ZjYtYWQyMy00NjEyLWJhNzEtOWZkZTZhZDBlNWQxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTIwZmMyNTctN2JmOS00NTI1LWI0MjYtYjU4OGEwMjQw\nZjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVXXBh6H2DUo5tHRe2NdhhPZv\nSBst7yBMIDb0MU9JAVKq7JfXGtzbqbPZDbDX3ATxXcptMCCpg3r6nxWIuI8OrKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUraVtquXfPj9FnaNlKurZxpmUnO4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAlz2yFOfUA1DzoplEaiUFiweV6a3w\nHr7aMJF0WEWzesoCICGLMCMSRnAcmBu3xj2mhpFYb9Ep2G0dyavvB726YOyE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc215", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `215` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaIllh62MYKvBjAnHNxXKh6KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMDkxMGE3LTQzZjItNGMyMC1hNzJjLWNiMzc5NmQ4ZmRlMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTAzNDExODYtY2Ex\nYy00YjE4LWI3M2YtZTFjY2YxMTFkOGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMDzewA8DMNO7UH6jCE7s0FxkkJQAGegOL7BquRjce4gSR6JJ5Cpx1IdNQ5oZ\nOiKLsw1NCp9+DpswDENapeWFr6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIJ1rL65yFLjkF5QKbQn1SUagPwMwHwYDVR0j\nBBgwFoAUJoHbawCpmH3sEaeVVHLnJR3M2EIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIB0uu3whaKAFriTgp5Cpfdgg4j+vgvmO6iT/s1xqxQA+AiEAryOU+Pvvmj3l\nkFvgj8NAUMOhsy9HN9Y3bNjy7RaQtHg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUeqINd5cgP/PvjChtgAnl72MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTA5MTBhNy00M2YyLTRjMjAtYTcyYy1jYjM3OTZkOGZkZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlZTdMTz5/r7FscA5VcRsMhnMb71EAsLSre7bK18wVPqKm\ntjrUoF3JLwAxj4Ziw784RvZU1W173aQUBIPVEO/So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJoHbawCpmH3sEaeVVHLnJR3M\n2EIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOxtva+rWYFSrAw07R4E1bp5WYRg7/XTQLqDOul9+QXzAiEA43JCjDf5\nqbGfuaabrR1mtJdABT0FU/VfH5TBmOH62gI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAerMm9A6Mbg1B5ftjSbulMm9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTAzNDExODYtY2ExYy00YjE4LWI3M2YtZTFjY2YxMTFkOGYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWYwMTBlYzMtYzE0Yi00YWJhLWE3MjEtMTVkNzRlZmMw\nNjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqvSzaJQmOmKihnH2c0aJbReP\nyr/DG5kwIjkbcwqzYXql70de/bSKvQGufE2smf1NWenimugagcHPnkI4rm28maNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIJ1rL65yFLjkF5QKbQn1SUagPwMwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA06oF0zdmjCjmJQ9xooEW1BwMeuoT\nGS0zpQhRwWVbRIwCIQC4wmoL61nrSFG3R8JZ/xDjRjl2/MkCb6aJSXla4Rf2Hw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc216", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `216` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAQO9DlUbnVDRuoyD8cm1kQvEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjMGYwMDZkLWNmYmItNDM1Mi04NWE1LWYwNDA1MjRiZTVjNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMyYjcwOTAtYjFm\nOS00M2VkLTlkMTAtOTkxMTA5MTVlNzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEluaiyYG//GqvuBvpIRmptUkWa4hFRSyxPsFvfv7AFEnGcVwQ8iaLGqJIkJDh\nYogdFL8+CodYLkD45t9NBjjQOaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURfShxzBIPrj6Cw+cd//pJbfT9/QwHwYDVR0j\nBBgwFoAUIdIlE1CMi/yQ2n5nM+XXl7zClccwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCTLnH65SWbS2IBxYdx8V1UiNgxE6w8+9biS8UxwskHkQIhAN9MqfXEmYwR\noILmNVddb3nlwBbL2M47OWjD8zZOPYdb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASgaE/8ePt5zltY91ZjFt3uqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzBmMDA2ZC1jZmJiLTQzNTItODVhNS1mMDQwNTI0YmU1YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuv+4ipFrMW8/rNEqLkBq5joCZlGHlEwuuvme+Tvz2s9Xm\nAjko6pwr9Re2ZveePtpz6/jW65FT4ynVbw6I6rw/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIdIlE1CMi/yQ2n5nM+XXl7zC\nlccwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNzBnPa60eRRUWYa8f0bm7CjQfKY3g9dgIZ5dE3+AGtsCICOkXqpYbEvc\n/llbxTVr0RHGWjyEi6qZmM+JX7GCfumG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAd8otyEOUVAVzCOYGmplztlLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMyYjcwOTAtYjFmOS00M2VkLTlkMTAtOTkxMTA5MTVlNzM2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2M0ODVhNjAtZDgxNi00MGYyLTgzMTktMjRjNjc2YTRh\nYTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2LmiIMWEZpZI7X/EuEBs0jOe\nQK/YP7TA9ASXXweXy1L812KMyi/eA71sQD9S/dV067LE90FEp4sUFewoSqVME6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURfShxzBIPrj6Cw+cd//pJbfT9/QwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAyS9zUFy8e7bgpEst6CnWeY5VI4Cw\nf2sAU7pCP2wOPRECIQDIfq9LqzVaIWdzwTVdrJPreeXLK0ntxfpGRpVepBbcZw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc217", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `217` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISARsT7FMPvUPXE4IUHCKNSWI4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiNTIxNWNkLTM2NjItNDZjOS05MGQ2LWRkZjQzNWQ1MGRiMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWMxYWQ5ODQtMzk3\nYS00ZTgyLTlhMmMtMjJhNTQzNDQwZTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkQXKN0R4I7mRLgKr/4OlbB+CCSW3ZtjI7cjFpZkV/RVoFt4iUioch3n/qBP3\nUZUDN8m2gDaOeSwgxx9x+kjZg6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGKCkQ04VsiE4gDpRwbgqKhKxvAgwHwYDVR0j\nBBgwFoAUNMKbtVeIctogXLEdN/iUKArRmEYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAqUydgxGItB3XDbB8PKxW5mzRYq7OPUh8QmbqWHVkNwMCIQDlYQ/E3moz\nlrYTb5zIkqeYQfZp5DuBQNi0FN9CajsmIg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQsGbBsximbfFVgJcOHkS2TdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjUyMTVjZC0zNjYyLTQ2YzktOTBkNi1kZGY0MzVkNTBkYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARp4d1q/JM3Ehr52ZQvcKakWJ5Ifoh9R2TIlea1hqhfevKB\nLd/u+zM/TyWjPgg31Tbr7D88QOHlSIbM6SfdXdqno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNMKbtVeIctogXLEdN/iUKArR\nmEYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMyFHvZFvUdkVYb6ZtLnUwuGFu8syTPwlT9LpM/U2ZIdAiAjXulXNRnL\nu2+qFzSTQuXtKaG8yfC/JKDqjyZYa51TNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATDxvVdMiffSqSNfDmLGTXUbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWMxYWQ5ODQtMzk3YS00ZTgyLTlhMmMtMjJhNTQzNDQwZTcyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2JhNWQxMjItNjNhNi00NjFlLTg1NTctZjZlOWVhYWQy\nNDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4skHYR1ne7zS/O9tqPU4D19h\nmXIwf3ycbJa7azdAbiqvyEjoqnzgLbAnpIaZ3tHyl49RpC9E6HcvrYtT6xqMRaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGKCkQ04VsiE4gDpRwbgqKhKxvAgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiARNTNi5cwBYbHiks06K6XHEZQfGUb9\nSxEE/Z1ZMhgLhQIhANnjgwoGS2zdZJmwULXWJuuuY4URQULrvbmKrX1AQ0xM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc218", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `218` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcwqhPpmqYuavvbjlkVqRWVOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwZGY1ZWIyLTY5NjAtNGJjNC05OWE2LTljNjM4ZmIyNjE5NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE1MGZkYjctYzRi\nNy00NzE1LWI4MTAtZjVmYWNlNmI0YzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdOgID82l70kolu6vQDNPPXgYpz1PVR9nfOWErMZcpo9kfIes6IXaS32LSRGn\n91N1mD4Bk7HFddGz1qH67t0WkKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKPjTDkgoonQGktQXm/q1T6es3+0wHwYDVR0j\nBBgwFoAUlH3ToTPl90K53hQf69vMZsPJu+0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBc60gh3Jl20YdC/8wldf0t9n7+zV6BzoZohEBXjc3I\noQIhAPsr7vQUgvno7pV5aYcFxdsHgwvPOOhUaiotYMPh+wzt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUloxz40mpw0IVDPwb8/hzZGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGRmNWViMi02OTYwLTRiYzQtOTlhNi05YzYzOGZiMjYxOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKZQ75UpOnBRYeZaIUssrQ9OHuZOasOsNP9t14N/DLPy/a\n8zESK/zGcp//SRyWcXNROxzQ/EzujhcDetZ+ovjao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlH3ToTPl90K53hQf69vMZsPJ\nu+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKCClAO2DPGV39y/t6+4ZoSLMKB9YVm3yAhlUsQvdoNoAiB0XldIwDS4\nsaa43bJwOyRncoOcdviO4OTmqQKaBnx60g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAY1e2b+MERS7ajtHGczmfoSNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE1MGZkYjctYzRiNy00NzE1LWI4MTAtZjVmYWNlNmI0YzU5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmZiZWQxYWEtNWRjNC00ZmJlLWI2NWMtODhjYmNlNTUy\nODY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEweF+M6hOVo4i/RQqojd3tAGu\nazy8SElRpFRufsX/cObF418NoHAiDueO3mGZcabbGKv9o+xcoVOPdTArFrW+v6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKPjTDkgoonQGktQXm/q1T6es3+0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBaXWn5ZCsudpjMqvCI1Bdc5wPEaa7/\nSIIFJe73/lPfjQIgBJt82UT0Y59BiYHDe23c5moTvF77Bidx99qMBoq3mV4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc219", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `219` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAdO0tXOS9acNNmIDyVa1EC/gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3ZTEyNWZjLWJhMjYtNGI1YS1iMmZkLTRjYmJjM2RhZGQyMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFiZTAwNDEtOGJk\nOC00M2Q0LWE3ZDgtOWM1YzFlY2U0MWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWmmfQJjTaw6CDDbYimIhr+M1PGH8VSzjVCk9zsidlmWhyy7iDuFXjIAW9RLY\naA5BndaVB2L8ZXEeytvqreiZ+aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUQThFXjZ1uEiTkiqgSwTrIyMF1UwHwYDVR0j\nBBgwFoAU8Ba2uSok1WJIfPm2YU6qPYzT58MwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEApg9om7FFCointdmWIpKVD3UrwkNyASWW2x3dXdqI\nj1gCIQDAEztmIXVifSTzvkYax7vTL+wD0gorWGuUI8S8v6G9Lw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVpBYtJok7HO3AtDePmU7IcvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2UxMjVmYy1iYTI2LTRiNWEtYjJmZC00Y2JiYzNkYWRkMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCBQPMm2Ft1nYk0780IE80PPdPyg0IZQE8Lwi1/P5xXr2g\ntnGoA5pao6Sr6ov10vFT7uhlaecQ3VZzdT7cefZOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Ba2uSok1WJIfPm2YU6qPYzT\n58MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAr4bFovcORzymv2fJ2HhCnWmhSNnp3Mwvnzhbx5DhA0CIFSEi1aU3xlt\nxFOupZ5TfZVDCuVYxOkoPGMuSH4m0Kc+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAc9cfCa4s8E8kuDdU/AktrWGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFiZTAwNDEtOGJkOC00M2Q0LWE3ZDgtOWM1YzFlY2U0MWU1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjg2NTczOTEtZWFlYS00Nzk2LTg3NDgtMGRkOTRmNDNl\nMjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElvv1DdnAyiyvUvtbJnL9WkSv\nA+Ri6K3Kz+5gG73djkiojjgthT7nLYSKo9G8Xcnuj59DJJNoaf64yWPha/iDlqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUQThFXjZ1uEiTkiqgSwTrIyMF1UwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA3w+OLIBqw1FBAofr2+psUFedmKAP\nGEr3BzskkMIfwpACIEmujda9uK3SbhAUXDYlYMOiN6AmHlxelZf5acSdyt1S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc220", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `220` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAV/OlMDpVTOzLIW96Bo5D5H3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1ZDcyYjk5LWZiYjMtNDU5Ni05MDQ4LWIxM2Q2MmVhMzQyZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk0MTBkNGQtNmNl\nMS00MzEyLWIwMTUtN2JhMmI2ZGMxZTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh39bFdPVUrjWBSvW6bzxbGohmXGq1jTGNj1Bm7ct47qa5CBKYg3JKxGP2V00\nQ1BfCTR23Pgo5K19m0eSy1V6w6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgiGXKINYpyTbacKJhes0J6xhFRYwHwYDVR0j\nBBgwFoAUvRWjqB+etm8fIl8FwnNDeI/CqzUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAqyHK8quOvhHPAu6tRH7Hv6SSu7gh1q2s67P/ySIT/FgCIBQa\nc/ftR2HRNoNXbNXI5R3iMY5pt/vt9Z53/Sg/oAUN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeZFqW4Ke2PKzLLJYTwa5sDWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNWQ3MmI5OS1mYmIzLTQ1OTYtOTA0OC1iMTNkNjJlYTM0MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyeY/54gpd4OieGSoLSDxqAhK4ezaKeztGNms3GzvbxAdT\nVXX1GP9tSBTZZeQN5Dkn8FdDKp8GjmdDx6ku2hbao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvRWjqB+etm8fIl8FwnNDeI/C\nqzUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC37Ys+G+VwWSlVgbSGjVjJ6FGTlSISlGPL5vEXmksJYCIQCvyf9ZWk9c\nABNUDNIm7T/AIfwKfqC6g29bMxEcp4XeIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbtueUUdI3+SikJ2oi8H/dXQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk0MTBkNGQtNmNlMS00MzEyLWIwMTUtN2JhMmI2ZGMxZTJlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGJmNTQ2MGYtOGIyZi00YzQ4LThjN2QtNTBkN2RkMTcx\nMWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgQfqBeJ/Di7iZXcEsI9SXPM9\np/zAZ66dm8Q5NmLK7K26R2f8DkfpnRMa1GodGA9CBFyWdhZvo93vRgFpW9sQ36Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgiGXKINYpyTbacKJhes0J6xhFRYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAx0NFyxn7YVTP6XORkWAYDdAbKseU\nzzq2w3GkjS0qkzACIHbGQeb6yeLN6SghPwfiT6RDgGRvnPECZiHc3zvq/a9k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc221", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `221` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISASr1CYVzc4P1NOqg4YfGCcIZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ZmE2YjQ2LTMwNmItNGE2My1hYzYwLWY3ZDFhYjI1MDllZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE0ODI1OWYtZjE4\nYS00NDYwLThiYjUtOGM1Zjg3OTUzZjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE39SA6aqbZJP6dVhZhAT1aPLURCUfhyifY3Ooadj2UBrBi4vhGBXRh631O84B\ngJXjyToVzsnvO6fWPXo2Sub8YaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa76vlWk/RZFowU0DoTbU3GsilacwHwYDVR0j\nBBgwFoAUO+Tc2m/eP3wqK+NWUv8NB+VVcqcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiADXNV94EI52Sx23bHbHbxZ2R5NJCpuLaSk\nZImoPFEa3QIgN14hRdkSFEleWERnWaFqBHWWUy1LdYHHDXtIb+XiU64=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ9FADRxJmZKiYAm3Akb5/cEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWZhNmI0Ni0zMDZiLTRhNjMtYWM2MC1mN2QxYWIyNTA5ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQa2SEhvOLITz7CYJMx2QECpimsNms7Gx5FUsTsF7H9/Ier\nLDU+BJoLUvWgCyIcf6kqI32RcxKzzlZ1wzfD/KT9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO+Tc2m/eP3wqK+NWUv8NB+VV\ncqcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOrZsxtMXHGOqApx+Su35UloafM7Fi6pn2MzuBIRfbVeAiBVTJak9vQH\nTLuw19JwGx9bmCcip+Q6sL+iuUpNQuvdFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAauRu3yCJM9k+T9OdFAxFwWbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE0ODI1OWYtZjE4YS00NDYwLThiYjUtOGM1Zjg3OTUzZjk2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODkxZjg5Y2UtZTgxZC00NTk1LTg1YWMtMjZmNDIwYzkw\nMzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6dp47YL3nzC6MTG/UrlL1c7m\ndmP+4UAG4ILO9ZXlhIgoSDdwGODIdzayHmVv1izYbEO0ZOF1Q276QG1UgA7m+qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUa76vlWk/RZFowU0DoTbU3GsilacwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA39LQKbJ2hFJtUTd4WQZ4T6aE42YQ\nKNCcjctENgqYEMQCIQC4BAjAvec57ecVsnAz+XCrvlAaiO/6jXwOWArrBzvypA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc222", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `222` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAdMqdZYvSqz+B/VefHCIbGdvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3OThiMjNlLTU3NDMtNDFlNy05Y2JjLTgwZTRjZTI3ZGY1MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ3MmMxNjUtMDdk\nYi00ZjgwLTllOWYtYTBhNGZkNWQzN2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh23RiaHV384TDfq1uOoli3ExzSm2xTIZjGrn7yIaA5o7a3jvpNnJTFi6sFO8\nW/ykxev2zsfceUUDC5WAuWLXN6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6QWgbjCNpduJaTinDU3YbeInLREwHwYDVR0j\nBBgwFoAUjOq1SbE3DOp3XRdAISZtF6+9hs0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBpHJjAS6RMRreWN9fQRBqUtPVnotEkgkmk\nAxU28vP57QIgLVGRAovi0VrMd+8SNQKcU7fVezWRgyK3qULJ475T0Jw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcOatSBU/YEK9loc8ZngaGp4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzk4YjIzZS01NzQzLTQxZTctOWNiYy04MGU0Y2UyN2RmNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARr/GLBgrrJbmyiB7R3S74M5sfOjVcLIIyKUP+qiCbFLk/K\nK6x7WiwJfCDAtKdzli5wg0kxBoyv9TQcus3VQJ3mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjOq1SbE3DOp3XRdAISZtF6+9\nhs0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANI7hdhXwryNIk2VIB+55rlWKOJUUmCniEBEoMY0guUeAiBQ08XvwpMm\nOgeQmOke/GH+MKDn1zFnT090kIVX4EMU7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbgJ4QHzWigTR3Yr+bYG5ZTTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ3MmMxNjUtMDdkYi00ZjgwLTllOWYtYTBhNGZkNWQzN2Y5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDI2YTEwODYtYTJhYS00MWUwLTk3OTQtMzQxMzFlYmQ4\nYjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4xLxiU5LAOWS47q/Ollb/Tsi\nsa+ei0ws/zxH1PHryn5cBLkSq+EWZkF79bkGH6b0f3G2j/qlxRfmSMi330K1+qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6QWgbjCNpduJaTinDU3YbeInLREwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAYWWZ+1qZHFexxlBbttbSdQVWHfimQ\nx5qJz5NJEsNZXwIhAORG2z/PQXbDKeecTEFB397NMhQvDh2kWlBnE9vcKIWP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc223", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `223` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQLoSgBSIw8MylpEFHTc3u94MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3MTBlNzM3LWUxYjktNGU0ZS1hMzQ3LWFkZWZmNjNlZjk1MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU1NWQxYWQtMmZh\nOS00ZTcyLTk4YjEtZGRkZDZiMTkxNmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK9USRGF9gfdnHAdrwjrXYbjDtuPs6U+Qh5cHd4WMs9Nll3NjPauKks5BfA86\nuZQxYuIzCd1aMqs3ZG6yYf0NLKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+WKeeXXp9NXCNCQS+eQNNj3+XfswHwYDVR0j\nBBgwFoAUD/oWmqxDaSsltldaWA5GhiRFBEIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCcNe3vm97e5dW/eEiVz3vGUByA\nOIVWWoqyv1gC1vdUvQIgbvn5MtzzekOoOLtkdr4JHViYkudzMa6IMgYpv6o36V0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWAZijaN9lqvSyYlASjT7GyRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzEwZTczNy1lMWI5LTRlNGUtYTM0Ny1hZGVmZjYzZWY5NTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaccfiQ5hidbpzSgARejy+VCBuwJ9HJADGX8LNHo0aRxYR\nmLNiY6XxgWV5lA5kdMRSLOOTCAeQTVfymojwov6Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD/oWmqxDaSsltldaWA5GhiRF\nBEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ7JOakAHLjDrodwSSuSYusQwJAywWeWfrNr6LvGOMq0CIQCg9ZLn7Pf4\ngjUW5I7wqf3uu8w5HkeinLiI6Gq8EOV72w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAS9Qbvgn5Y+gks9MreDRzaPTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU1NWQxYWQtMmZhOS00ZTcyLTk4YjEtZGRkZDZiMTkxNmViMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjQ4MjZmMTYtMWYxMy00NTM0LWE4N2YtN2U5ODZkMGQ1\nOTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4pzuuskZqZP1fSc6n7ckk0Vc\nZKFkKENWBf9If/nTUl46EDLXedunpPe6pb9pKO14l1SnqKGl2AZGkN66Jn4ohKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+WKeeXXp9NXCNCQS+eQNNj3+XfswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA2Oic4kBtpDJphV0NWAqnDfHoO822a\nb4qi/hTU38ymPAIgAkfX/DjmyM+KUUTOhBQ8l0dqzbLyGTCdwQI0fQ2GuoI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc224", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `224` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAXgkoexdY9F6KYRaxImjjukmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMWEyN2JmLTkzNTctNDM2Mi1hZmIyLTc1NWYzYTkxNjQzNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQyZjE1Y2YtYzli\nZi00NjUxLThlN2QtNWM5Yzc0MzJhNjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYxoF0JEzk1H+eNEAU//LCyQT2J9fshPHCAcB1b4HJxmLPIE0X1BKm/YSX4c6\ns+KGTrdGCjzaHCr6z3asH1khvKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrN+VzvLBGpGx/bnCKwVluVuME8AwHwYDVR0j\nBBgwFoAUX/NVE+YH3+gDURAugTYyVaqRmukwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgRp/QTPlJ\nnWpyjkHd1j/Iw0G1PK49QfJOTFzQaOz8hGoCICxzIOQTLbb62mIsYRqY/8TUpXuW\n1dyLxbExJnfwLxC+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVG/WROR5PLHdvl3IZ9Jlk/WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzFhMjdiZi05MzU3LTQzNjItYWZiMi03NTVmM2E5MTY0MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREPXD5kFg5s/GX+UzYF1FQWDLAtstkJ8X4k5RF6vRQ5UXy\nCL25QjmnJd3h/1HSKHuMmxlwq5et9piKMiUg84jDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX/NVE+YH3+gDURAugTYyVaqR\nmukwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge5dXt/jvQMhei2COHwyw+ZNe7FrMFu2wGWP3iBiOUbMCIELh65eTvtPf\nB+8pDwxILEKL6hWLvKSnM8lzFSul0aam\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVW5wxMpaaHAUZASUEF4XMRgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQyZjE1Y2YtYzliZi00NjUxLThlN2QtNWM5Yzc0MzJhNjI3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTdkOTE2NzgtZGEyNy00NDljLThjNmEtM2Y5Yjk5MGVi\nMjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFb4QAO5lOi6E1INKHgbLJLBb\nfOo4cttWW9f6NA0401t/mGqbbG+u1QUQ7pUvkpIwVic1VsMBwSJw3k4IGQiFdaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrN+VzvLBGpGx/bnCKwVluVuME8AwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBCEn5ZHURhZjVqAY9hg2m9/MIap0KQ\nbMcVmgYrNxObDwIhAIJV9OxdkwU/6EI2zMOaUs5/BmzTmaZldP1kNJYn/QDW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc225", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `225` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISARD2xcwYB4dzGSc+9lug4CHKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkOTNiNWM4LWNjYWYtNGQyOC05NGZmLTcxNWUyZDk4YWMyZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjNjNDA0ZTQtMzY3\nYi00ZTcyLWJmMWUtOTViZjYwMmUxNzUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEek/aPgCKoifS7d26/6JRFOFKeJTCyNLKyXSLRKw46vSvf5NTeWUm4ZtezLly\nNfCUWS45w6Of4MX9R25R5UyAgKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs6/UjImf9rJ+kOicmAHHXnKhdDYwHwYDVR0j\nBBgwFoAUzB/My0gsU+E0uJFXWhdw5yA+DGAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJIdzKf1\nWaNlkAhGtVIHQpzO8lnYwSFvrQIQJVLvX5F1AiBMn4fbmDoHdKShSmZvgwwXLW9B\nHmgULaGdnFHETcQSYA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbDp2GDT6VjvL2db0NydbWyiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDkzYjVjOC1jY2FmLTRkMjgtOTRmZi03MTVlMmQ5OGFjMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7wjRYTGaWh2aC98LXoMYyVyYJy674Y/hfTEgTOjUfNoaM\neeKislMfVBnCZI/9aCUoRGOyo01lYnSyu6oQO4cjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzB/My0gsU+E0uJFXWhdw5yA+\nDGAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALxAsLYYKKV+en+S/Jk8ZACGbkW/5RK2aVTg3h6WpGnPAiBMJZaxRj9k\nJw7p1FBLpSC+Q387HqGyqpbhkn4HoJS7Tg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeR7nue5VayGSjpTeQsxjJN5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjNjNDA0ZTQtMzY3Yi00ZTcyLWJmMWUtOTViZjYwMmUxNzUyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQ2ZjA0ZjItMjhlNC00NTA0LTgwMDYtYzMxYTZhNzY1\nMDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhm5MkvGQSpyQ3zRSScq0kMoJ\nG0caPW2OoYZTcG84rsCo9iCoM3J9uf2QeR/nm+ReYBIChjAk8DXJcU39v3ZBYKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUs6/UjImf9rJ+kOicmAHHXnKhdDYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA60i+3hvJCfrFnXtjY2OOTFN6o7nG\nXeGB/8h4gBWpYqYCIQDSKn8lhPzDEfTinJ6Vo3jrnBAi7C7P5ITfVbg/KxdiRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc226", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `226` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAd+Sh+bS52ErUJ72+BF2uIFrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkZWI2ZjhmLWU1NjQtNGYzMy1hMTU1LTYzNTRhNGRiMTlkZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjljYjllYWEtOGIx\nYS00OTNlLThkNWYtMjc0MmMyZjJhZDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXr9NII7p2KCUN8sczbuvQOKe4ZAC2x0Y14PhQ55gsbL4ZBSKoB3WDbbd5CUw\nNGmHQNHkbsa77XM/2RzEvMX04qOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa0JHsCfZpNXXODdqT7StuwDJxc8wHwYDVR0j\nBBgwFoAUzVwNcrkQRnLM2pxWf7zgtbg3xR4wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDwyVIQ\nVZtnpuVjPxP6rn2h98ycvi/qsFjEWTKMS4lJjAIhAJHr/VqSufbqpnZtt5gkWxNN\nyb0S4RsLbnDgNKbj5KkU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWljE0gVg3eQs2S7It4SunUyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGViNmY4Zi1lNTY0LTRmMzMtYTE1NS02MzU0YTRkYjE5ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsaUcGu7YVygVwFSPfhm5E3fSLRcqgLNH3qo9HAB03MpXJ\nZm+UAWFitS1zLt7RcsWLvUO1mCCptzQD3W1HkLmLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzVwNcrkQRnLM2pxWf7zgtbg3\nxR4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKIiED+XcDgLlSVGaNkWiUMqoJXE2k1aoyffOD/bm0U5AiEA/yTdGgam\nixnkE0dT3fiyknwSlwDiIBpqnEPOx0B+6Q8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYjeV7MtOzuMl3v61UsVGIjQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjljYjllYWEtOGIxYS00OTNlLThkNWYtMjc0MmMyZjJhZDc5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjMxZTIzYmUtYTkyMi00MTE3LWJjMTctZmU1M2Q1MzE0\nZmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5piGLCkQex2yVtvHzLFPgmiy\nrJ10zzM/Ri3n1VWNleC6uzM0tdhR3UcYWtqOALrexZmy2l1lRd/M6mntg79St6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUa0JHsCfZpNXXODdqT7StuwDJxc8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAyBk9LVFRfNFztf/UK+80Rih2fcJe\ntnwaDPrNPGMNPugCIEHxqyROIyI9vZL19nttUSTC2IuMnf26Qb2yManY1WX1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc227", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `227` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAVa32vCIhfsIHDelGQ91jn6SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1MDM3YzVhLTUwMmMtNDViYi1iZTFkLTQ3MmM1M2M4MzkzZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTAxODc5NmUtODEz\nNC00ZDBlLThkMTgtNjE0MWQxZDg1ZmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdAwUOnD+u0EU5s6V+nY8OR7SuT+U8cq1U0azAW/qKn61rcYXsmivEFrusu0t\n2ViR0rvAsVAOePuvIU1kUH9+16OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMRceIAr5hLOq37P7T5F5tKWMQ3cwHwYDVR0j\nBBgwFoAUBJbzf7e29DH2H8mwFBmLhtAopekwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIDdBzAjRVXeSvXeCh2bPo47GW6Miw3dW9wrUEGZIGNbsAiAh/ohRT5Kx\nr5UW3sMiRSaxBkMwSsPXcUi/ovBuqjw/9A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdNUq0YQWsfhd+8nTXCm64GtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTAzN2M1YS01MDJjLTQ1YmItYmUxZC00NzJjNTNjODM5M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvgku7OCsnM0LrDVylktEvuhokxTTvXGOjdTwH9pEV2B+W\nrjBDRGjiFN1YSi8JT9O1mFuuAmoqSlup5L1fI/8co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBJbzf7e29DH2H8mwFBmLhtAo\npekwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWZZkdSLSE9vCrGr0X6E5GLqOQPuvCdc52DjQOGY5jVwCIQDRewIZIVd5\neeyyr+2wbTmB2fOk/qnHdXc5tnFghZKSTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYjmNJW28CobxwEPDqS8uTwgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTAxODc5NmUtODEzNC00ZDBlLThkMTgtNjE0MWQxZDg1ZmRiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmVhZGUwMzUtMmU2ZS00MTE1LTk0YWUtZWFhZDI2MTg4\nYzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk3/3FcUaqMv/g+L0iDVL3zdB\nYa6FctlToy2/fs4Owvbl8pJFU34nU+eF+k7Yf4eOXilSyGmdCMRyB8sX3bGIVqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMRceIAr5hLOq37P7T5F5tKWMQ3cwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAvw6IiMwgQKTdhHiU7xaUNAolaeAi\nJNF1fsKOeXYla4ICIEDzikY+U8y0RwMKHovWav6j+KHjR0SsmgDolQr90eCK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc228", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `228` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAYRv+Nc/gKZyor6IkGfG+MmbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjOTNlNjZlLWRiNWItNDhjYi05ODkwLTFkMTYxNzE0ZTYxMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM3YjFiMzUtNDNh\nZi00N2M1LWI3NzAtNDAwZjdjZGMwMmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE09/sTTn6Eq+dMaUFQyBNH6IovWMBso3Qqycci+PDwRd3xWL+SiUcfyPFdo4c\ndC3YcnDTWZzkhBzfH+MSxPXj6aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfAk6w1RUda/cVsKBVUN4zBxBybkwHwYDVR0j\nBBgwFoAUR7EMrg0szbyMQ/ADnqcEjdc53GMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIGlXJBsklOQbj26yEYm4y9PyvI2tlWxsuF1nnzbGQJYSAiBapoGH41Hd\ncZa+jRy5P361+1LSmelTJVy/To61GJXYlg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASk6Oo6Zj6WC4TgUHle/TbYlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzkzZTY2ZS1kYjViLTQ4Y2ItOTg5MC0xZDE2MTcxNGU2MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUgxmbg2X6jW8mvHkhaMexU9Z4pXyAnr6BL4zio0BQQn69\n4b4osMuJxtgXTsxK5rXTPVvs5C9j7tD9N/j8uGOdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR7EMrg0szbyMQ/ADnqcEjdc5\n3GMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcfqRymnbm+pHNFaWFxQB4xMVPXRbKKhZNjYgtYFTwhcCIQC12XuVAuQP\nu8c74CLY3sVNtJnqAV22jR7VKolhaBkCOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATjBRlgfLNDv0XvfNvxjIsilMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM3YjFiMzUtNDNhZi00N2M1LWI3NzAtNDAwZjdjZGMwMmJlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTFlYjE5ZDctZThjNC00NTM4LWE0ZmUtNjA3NTZlMjJm\nZTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL7nQleIGWowQB+EWzyiwHdWu\ncYsDQjJsSEYEgF872CDxonKZq6S9+crOqlNv9IKKGcBLWa+A6/bRW3qI7qAFLaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfAk6w1RUda/cVsKBVUN4zBxBybkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAtjwMFz0jaQakHBECbB1gktTEJexi\ndHXk940hwLINIFECIGbsy0Xu8/aeVU1i4WQTiS1uHalo987bn/8SfSPpnI1d\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc229", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `229` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAQAKwZ0N1l/Js2YY7v3Ik6C3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMzQ5MTI0LTJjMDgtNGY2YS05ZTdjLTg3YTRkMTE0NGJmNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE1YjM3M2YtYWFk\nNy00MGYxLWI1ZTQtZmVmYzMwMzIxNTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE62+XweXyifumHJVIumsYknWVFSy9OXdDmx9oi5AF2aTwIRdqF4p+zS40tw/A\nEqII1lkrkRsymXauEYnDNFv9CKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUquBklGxveLAY0xgxH90w0Dv44JEwHwYDVR0j\nBBgwFoAUmKKUoa37q7bws7WlLJxeFZk76VQwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIG21UtrGq4cAg6LRBPwhyKJi+WFI1ljGy0/U6my4QRgXAiBkWMZnJqabBvIGp17g\nZBq9jJ9zDVWw5E2flTxvCyM1ow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASbfZZ2JCLVBEPhwMmTM0nd1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTM0OTEyNC0yYzA4LTRmNmEtOWU3Yy04N2E0ZDExNDRiZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZSQp/8whvEme6xjDjbPve7Mk042NX5KUBy9K1W2lVvjXH\n2+3iVXO7AdF7DifiZLu4i7P0Dj3sw7pXok1HsB0lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmKKUoa37q7bws7WlLJxeFZk7\n6VQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZusIeh/FZRoQZM4n6szWSq6wVzQime7gXUpli49p4kYCIQCA6r853cj5\nKUHlptBPlw/WdJUPNQpvtuFX9rYLgUHA/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQKChfVOLU93IeN2kC0ty9DgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE1YjM3M2YtYWFkNy00MGYxLWI1ZTQtZmVmYzMwMzIxNTM1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTUwNmYzOTYtNWMwMC00MGZlLThiNTgtY2I5N2M1NjZl\nMWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAbNRuYJIx8PuEPKV5UIBm6Lg\nOwxZbb6tCVSI/R4ViEb8RLSQEs/XxcNlSNTG+6W1msNwJj+8lb/tEyKjv7notKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUquBklGxveLAY0xgxH90w0Dv44JEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBfHcZxp+g7/wZgYHrEWDgaYCleIVPN\nljAuaU7K4K9mIgIhAKR5e/4gI3NHINp5BAbP9XKZkxq5vzr1S4bp0CZLX1nT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc230", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `230` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAcqWICPmolaqf0Iq7Vae4oN0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNmQ1OWY5LWY0NWQtNGEzZS1iOGQ2LWEwMzczMzEyYjUwMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I4NzE3NWItYjlh\nNi00OWY2LWI1OTAtYWQ1NjEzMTc0ZmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkxxE2c0bnEW8uac5IdmUIJo/tUApP9vJ3XOXeMiG9a2tiIz9XTLwGrJCLSz6\nCOmAlkYahj+R1BA74U+K45RrHqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo1Grywn+tsaOGYN77oyBkzJsy0gwHwYDVR0j\nBBgwFoAUFaB+Lf1dvWqCZIPRswqdk1jvm+UwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIElvVFx82L/TrOC8lgLxLem9L3gpJJ+IVMVQFoiDxYyIAiAZ\nTqqp5FDuSatdoybV3P0eE3RrVF3Nlk2RAo2/HH53Wg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWd6SBAuf4XOUuV/1zyBw/+oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDZkNTlmOS1mNDVkLTRhM2UtYjhkNi1hMDM3MzMxMmI1MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSSTin5VQBQWBVSKHKWvFws+/K7zGWiuX5fw71V2qF8eXZ\nDLCPORUs7gJ0LS3iqqmYgmfZAJeHVVL5XB085x+Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFaB+Lf1dvWqCZIPRswqdk1jv\nm+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPlMMB4gKt9jnE2D6UMouU+o6PL77SMhHXgXFgJky1GbAiEAhwZ2D14t\nkj8k7BZQuN0emQaxaEEcl1Ea8NF3HS5QLH0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARadqOla1z8rarG2vNxWBQmWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I4NzE3NWItYjlhNi00OWY2LWI1OTAtYWQ1NjEzMTc0ZmNkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQxYWVmZTktY2Y1MC00YmVkLTliNTYtNzUyYmZhYWY3\nZWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUAVGXIQjYdQSnkuaIWRGDyam\ncpSTwDVMiTbN7QEmG1Og2zJ+45X3J4sDqy33fKzTFEm2zwkRCQttAjgbc1H51qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUo1Grywn+tsaOGYN77oyBkzJsy0gwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBcnk2C567YEmBsiJwt1ejqYJBiUyHj\nQtQLzEHpsKfPRgIgd6ni7da8BtfsqC1tiOqStsDSQ1maCXKYqLYY8OKUfx8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc231", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `231` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAU0Hl6kNlB5DYfQmaCwHQUXOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5NWQ1MjJmLTNmNzMtNGE1Mi1iN2U3LWYwNDhiMDY1YTMzYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E3MmM3YmUtNDFj\nZS00ZjM5LWIzNmItYzZlNzU3NTE5NDU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECEX2mmQwfEU1tmjbOGxwGTN+3XkvcgVsv4dyuYpszo+2csNNhfzgSSzlVGtL\nvVC9QEwp+ex/5uO92ENFff5k5aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv7q4zXoP4AlWtFhzy6+mDGzG26wwHwYDVR0j\nBBgwFoAUmo+h+p9Pixz7Ct+AWXMG12ecgFkwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIG2SIUt+iw+/ehtQ7zhgs69cwPuEE6ZtdtECzMn2ovmEAiEA\nzZZSGXqV1CnV1XFzksLtv00WeSF4+ycjSVWKAZtc7xw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATpOHP488FZO7rUU16yY1vy4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTVkNTIyZi0zZjczLTRhNTItYjdlNy1mMDQ4YjA2NWEzM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPECGORB8HHskBpKHjoakIjrL9KX6ADiYjD82akSoAMChM\n5RbDg9gTi3mJRefAGSvylYI8R1eX8UczCNvAKzOYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmo+h+p9Pixz7Ct+AWXMG12ec\ngFkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI6hMnE8jkvqCQS12cf47+CtjmhfbAuuHhcph/8qODfwCIBEppPXsqR3+\nR1FxQnouj4yVL+9weHOoYMlNOKk0EqjF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWt0djdTxvY+Rz/8u8t8p+5HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E3MmM3YmUtNDFjZS00ZjM5LWIzNmItYzZlNzU3NTE5NDU4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjBhYTdlY2EtMTBjYy00YmFhLWFlMjEtMjVlNjllZDdl\nZjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWNPYbNaHmCI+Er3GKVIc1kuG\nxb0uJsPZ8v5KUx2vO05XnO4qKBaGxVGSx0J/PYwqXq/D7GNScWK6tK1DGvhrnKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUv7q4zXoP4AlWtFhzy6+mDGzG26wwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAEV+DedpGhL2u0wgS8/e1otqkbCMiv\ngE6j8T2xrCjPlwIgJHYwJ7zrShQNXfdDq78LxwXsI3JdC1JfuG0OA5CaiEQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc232", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `232` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQ1wBwGYg/hmI6q5jJBh8lMcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxZWNhMTM4LTFiZTktNDc4Ni05MDdhLTc5ZDZhZGJhNzVlZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM4MjAzYzQtNzk4\nMy00YzdjLTg1NDgtNTVjMTg4NDZkZWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhX865K+iC5qHpPlBmrPMwjNHWd8O4xPwUVOUnZRfJ3WDy9ipnE1tARH4b8Mx\n0sY1cbbf7WIZL8QMToyiREmUeaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ5vLH6NP2g/xx8IKdRjnqKIWU8MwHwYDVR0j\nBBgwFoAUVwqB0PzD1UrH7LgvUrWTGzaJprUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCF+qQdCndQ\nxp59TAfpSKEO6fj8yT3vwP713l/cCKZV6AIgCc2uokukog3MblOfZA143CCibvw+\nvJab4w4dIzJce0s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYHnGDIxm+I7qQVF++HueKKEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWVjYTEzOC0xYmU5LTQ3ODYtOTA3YS03OWQ2YWRiYTc1ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdMKKkHZp0xDWt07sUJzm1eWBZved66S1OmqKH55WqEBqF\nZ/6QhiNco1j1l8TgZDv/lHvFmnkwg0Q2u0p7Sg0jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVwqB0PzD1UrH7LgvUrWTGzaJ\nprUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGYZht8t1Au+GW8bTW7QRrTJiuuwLFmYGptKzVGKhKicCIQDk9xB5EUVC\nrKm6VI3U3oPc9iI/qNy535uH5rDR0E11Rw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUpFBpcD2SXPirLjdI2SSTXbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM4MjAzYzQtNzk4My00YzdjLTg1NDgtNTVjMTg4NDZkZWY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTY3ZWQyMjQtYjMwYi00ZTFjLTlhYzYtMGU1MTkwYWE3\nNjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMhr4pDsyuQajS1hOwux73St9\n+XSYIAXzvnJw0XV/S9qV6Mlyu4i5CLJtjr5hXZ5nG1m1GUerEiVzB3rKy8l0RKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ5vLH6NP2g/xx8IKdRjnqKIWU8MwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA3wHBbAfbElvryHYraVI4d+R6NAfA\nA5w2ZYvxsZXi+JMCIDP7TdwLlH18/gHnbz5GHNNr0h+gKtC2IwSvu1zCmTrL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc233", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `233` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAV1CrIww1qUdhP+gNq93tCNaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwZDU3NzgxLWNjZWMtNGZmNi1hOWVmLWQ0MmI5YTM5NTM4MjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzYwMmNkYjktNTA2\nNy00MjNlLWIzYjctYWE1ZWNmMzFhMjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUGdos4XUgvIjAeFdVRWMRNFt/+76pz+AWRJ+cTc2R6AOxFZhpwTfBArEfqEF\nBm4NsWwXIkgSUl1A88fJlIo+fKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwsD9myhQX6x0g2IGNdCGpSK4lVQwHwYDVR0j\nBBgwFoAU/UAnv2a/ur5ijwt+F6uOYIx4RUQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAKUi7TopqBqWKQqXk3oQytzbys3qGNplP4/9dHIqisftAiEAymBjNS/p\nX/BsFJpZuKnWhXQf1H3skJgIeARcd3/kROM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUrZ7DZpCCZo/k06yYiBdojZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGQ1Nzc4MS1jY2VjLTRmZjYtYTllZi1kNDJiOWEzOTUzODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRnpBfpEvDmIO8Do96m4a4dsj/oqFFBBF8Z2TWIOQMzlr3\n42ppKOHLcg4tLIB4ROf+HWJYLtQJ2YfrzXxkWBqdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/UAnv2a/ur5ijwt+F6uOYIx4\nRUQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP56HU3Ey6cOLNhqaLDTGsnLgBz3cj28s3hm1e3UHJXuAiBx6i9sCOW/\nyLdGjROwtLxU5eCFpVIlAVP+/eDypHbBTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfmlvv2R1dNuy4/887ajMc8CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzYwMmNkYjktNTA2Ny00MjNlLWIzYjctYWE1ZWNmMzFhMjljMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjI0ZjM1NGYtNGEyNi00NzYyLTlhN2YtNDgzMDYxM2Zi\nOGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3puGU1QuNQkRmMYSI0L5Jxd+\n9NQBqf6/89Z/Bj+hKdeSL6L1qOfYVL6OJQhHv5Rc00cDmKSdZDnoDN0i3wQlvKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwsD9myhQX6x0g2IGNdCGpSK4lVQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBOUhuSB7c87UzHADMW4t8uT78pvh/N\nbav3Nn/GEH8yCwIhAJGny9GzyUBJFcsLDHTAuEfIDbFHgTotNtfji06a5kiX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc234", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `234` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISASrzsISPXOOaKq8TlMKsc3t9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhMjNjMDA1LWEwOWEtNDQ3OS1hNGIxLWZkOGQ2ZjkxMTE1OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ5ZjhmZmQtYzU0\nMS00NmE4LTg3N2EtYmQzNWY4MmE1Y2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWyCmeP/081Ktl2KERIqBKqfrzLpovsKmDW7G6Y7Sm6GQa3NOAMTopL0e8kj6\nSZUktMCiWzQwn/Ms4g0nECiw16OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3S2Rzki5vf6ZT71JEDhbKZo69NswHwYDVR0j\nBBgwFoAUjnazjQXCf+nIsK//tTpLvqTiPeUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMroYf8RoYfmjCJFkYvbiZz7vwalitFQH8hMbA3DTnf4AiADVoqIFZhV\nC2wUfRDiijZSSLzUxTjrdInFwK0KnR5/eg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW7RxJpSFT+XdCKpIJJybWGZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTIzYzAwNS1hMDlhLTQ0NzktYTRiMS1mZDhkNmY5MTExNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASerdtHWzAY9ywPNSe0vSRKNrWQfVcTDQQJXr/aIMjfz7kz\nFCvQUKHM21dN+xNnoPpTEstHe8IZlQDUyw5RxRiFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjnazjQXCf+nIsK//tTpLvqTi\nPeUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN8uCplxIvDcIq5MiU9iXaSjqlVgDSBxptWUOh8v/y/0AiEAk+Ql5J3o\nd2cTepQYn38KYUNDqYIqroTN7j5CZ5+H7aQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa0le55xm445Wx/Ti0lHGLTsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ5ZjhmZmQtYzU0MS00NmE4LTg3N2EtYmQzNWY4MmE1Y2NlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWI3MWVmZmUtNDJhOC00MGIyLWE2YjgtZTk2Y2U3YjBj\nMmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoPsUsCZkVvqkD1jCx84a8xsv\n7h9AXPH641B9u0fcyr3xElIwrXnyAl8blTHjgfkA/9SyFj6gDOAovGb5xSapJKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3S2Rzki5vf6ZT71JEDhbKZo69NswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAKRkKsmrkNRU+nQgDVbobJRiCROza0\nII4T8LjBu1PbAQIhANMsk5BQvmdNTyjgOJimIGyfPVN+CIBxao2c/hYI0liH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc235", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `235` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAeJP13DazlrkIs70IcJcO05kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiNTI2ZmNmLWFkNWUtNGI5Yi1iYTkwLTMwODRkZjQ2NThiMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI3MjExYjQtNGE4\nNS00MGVhLTlhNTAtOTk2NDlhNTdkZTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExGtzwdVdHCLFFu3NXhQOqfpXbGsEtWCRhpVC6v2olV3UFZkLgyMWWxvkVjf+\naer1/eggoYCKkjtG7adkiaToB6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdsCr9bMI837oVXW1h6Df1IShMj8wHwYDVR0j\nBBgwFoAU600kqAUzkRHqPxVlQCz6BUXDkeQwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIAju6d2bgOt6gGX+Nezbf6swPo/vL3mxYjjyB93ef8rvAiBSq+Nx2hS6\nOJi8Ji0mtOFZ2/4NGZESZbU4TGwHjZqjNg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASoBJ68o9vkBkW6UMRIDAW6eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjUyNmZjZi1hZDVlLTRiOWItYmE5MC0zMDg0ZGY0NjU4YjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYfnJFIn/8gRhTmQV1qVY5Gez27RlH/39SklY8EoAsT0v3\n7EekLoPRjK4VCDy/smANH4McoJB8Ze7bWivh1DKdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU600kqAUzkRHqPxVlQCz6BUXD\nkeQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDg2sIvCU0dhGwuZKviX+YztRtQLdDXneZzD0pj39dEYCID4cA6EuNHPx\niXRFjQ33bHCcqIvxlSsu5QMaS/Qdp6pI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVq8y4/aUuTgqVEAWDSsbteSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI3MjExYjQtNGE4NS00MGVhLTlhNTAtOTk2NDlhNTdkZTQ0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDNiNjk3MGItYWQyYy00MDBhLTliYWUtODljNTk2NDk0\nZDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECcCF+xNRXywZvZhxlBkggIQU\nBWVe9vBWYvu9ti1Js9evaBwGPw2uE7eCrIaYN4pCEBtg+o8wNDNtosVQ6LCjcqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdsCr9bMI837oVXW1h6Df1IShMj8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBPLMiqPcUil6XsolKJtGoLoLcwCGzN\nHPUFHQxVo2P7SQIgR6puV47FonrxBH2QDZhpaPvDwOJzQcI3AmcFunj6klk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc236", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `236` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAUxssSFqjW1/U8mogINZnCMRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwMjYwOTQ0LWVlZmYtNDU4Ni1iZjliLTg1NmQzYWQ4OTM1ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIxNDA2YjYtMmM1\nZi00YmViLTk5MjYtNzBlNDgyM2I5ZGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6D5etgxhgIiNe3UGkpqYPjmYlYeedkMW8vR21WgqlpyDKKef0AN2/IybpE6O\nWf4M47rKBtlKyDqZeVyREFtWxaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNYqBPGY32Up4Cv0FdZ0YnJYiQkowHwYDVR0j\nBBgwFoAUnAIakmy60jfUEDpB++UpdMH/+pcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCfY5LmEiIiA9M11gKuEM9cMKsr8TtozzzFxFzu\n9z8d0wIhANYndjAe5N3kCTbI4nS/wAJ+LQbGJemmYlj+BHf1oZE+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdX0Va6tz/zy5WOuA15ltCQJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDI2MDk0NC1lZWZmLTQ1ODYtYmY5Yi04NTZkM2FkODkzNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTLiS2Ag8grxliHomjieGWK2SWewrOoLJZtwL7sRNsx0tF\nO7DophNWfvV2PyQb+V/YkahwV6hNsshOSiEfoszao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnAIakmy60jfUEDpB++UpdMH/\n+pcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBwvZCI8At5LWpukllxoojt172fgggCdUwKEWmEf+ZqECIQDDlUCKSSId\n6d+/RL8UXHp3fQbnzkSUcMXcQ0LM0mwsmg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAV/xy/+jpPlYjaTQ+QDDNG97MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIxNDA2YjYtMmM1Zi00YmViLTk5MjYtNzBlNDgyM2I5ZGY0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjRlNzA4ZWQtOWQ1Yy00M2EwLTlhNWMtYzQwMGUwYzQ2\nMTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGj+oSkcJMCs6GaWvUVSRYIO8\nN1hG24g5VOl6D84u8gup0egJFj/mnKO94sAHpfOM4a67hFFs8uFZmj1H71159qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNYqBPGY32Up4Cv0FdZ0YnJYiQkowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA2iM0ImGvk+D33pVfZeATH8nagUzm\nHgwKeVpsrfPzYDwCIQDf6VDS7zUbNO3WNIiNnqKBMWih4x7zboU8YvS0xctRtA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc237", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `237` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISASS6OFy6Ygeva/waQSXWXDcwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1MTM4NjQxLWNjOTEtNDc4Yy04Y2RlLTFhNGMyOWNiNTg1ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE2YzQ3YmEtMGY1\nZC00ODlhLWExOWUtZTExNzdhYWYwZTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPztb5Y6jCU1WuMA/Ld8+FDokMO4xby17WaZ2IBfMNYDNa260POtKsN16SkEy\nRiKskYhBgzC13RX4K7t13BCb3qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Ebib9nkVQ5DtjJDmAxWanLc34YwHwYDVR0j\nBBgwFoAUfvqZOHEvQtFEPnSvkH3V7sJMm7gwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIC+5JQJNNIEkULAHrteVnAzahc1CkrLiQY+FqYei\nsfYgAiB9fe/N1WdDEyELSSViOTgghJwg/G6ftoTRM9UXFo24pA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW/t4xpfdNENrFapsPXy25LVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTEzODY0MS1jYzkxLTQ3OGMtOGNkZS0xYTRjMjljYjU4NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8kwqQnT4FrzYMcMTBtfktxqJ1laztz05e8u8ONh8v4p4s\nuMVhFSajhA4TYYdhQeGUG707Td9xyKofMbEUPSv+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfvqZOHEvQtFEPnSvkH3V7sJM\nm7gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBubymDa2PYJiKR6CfIV1RtZkZDcuCvMgnINQSbF23IsCIGVYByQTaep4\nnaahR/MaO1iZhlglzuuLuyMrPNBst/gC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXuXCFjOArOSg1VsOipi7nB6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE2YzQ3YmEtMGY1ZC00ODlhLWExOWUtZTExNzdhYWYwZTZmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjljNmFhYjUtNjQ1NS00ZDIyLWJlNjEtZWYwYTFmYzIy\nNjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8A56bWTqEE3ElbXHFm9zpoWc\n4IYnCCAXi5BgsJRAgyzO8YtBQVXqiRNHnGnobsPfvTnMF5d7h50EJo+uvVmegaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1Ebib9nkVQ5DtjJDmAxWanLc34YwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA5bmgCswkLhVopV7AfaN6aLuRNfzql\nhS/ss++0eqZwWwIgW8/QmvJ047piyjO92NSZfyHNPauLlxGUXAv+gqEHpak=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc238", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `238` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISARAfmBG7fdM42LUh5ERDg0z/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyNDcwYmJhLWE3OTItNGU1Yy1hMmI0LTkyOGMxZmZiNzc3YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFiMjE0MjctYTEz\nMS00NDk1LTkwMjAtZDAwYzNjZDMyMTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEu171onVlSOwXXGmnkV/xksr9THqiqKeYdYiHLMJsgvbXuXrEzmlwHQaklPW\nljKMbD5rFrcWYvM9PKqh1p7YwaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUteg+yLS9GIGBx2vZpMAUtb4LX0MwHwYDVR0j\nBBgwFoAUj8MV0d4fLuW0ExGYYkxLWabdUG4wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDdQxaVfMFvLC38SEkG+KYQ2s5sU9GUGlbPuKHkgBp9ngIh\nAL3Y84qsTDJ07dX8c3NlmdsoAs0QUMkwJBxQq9axPMs4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeHgVBSNsApSC1RnaSP7TsSKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjQ3MGJiYS1hNzkyLTRlNWMtYTJiNC05MjhjMWZmYjc3N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNUtE6h7YmHdl871fYVTspFk8u3bz4+Lh4wzDh9mn/lsg5\nmDSkJKQ49v6Uyj90xpLo0Olmfvq25RKS/lHOeXMDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj8MV0d4fLuW0ExGYYkxLWabd\nUG4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXP3nbRxe1uE/wqTCMMvjlmzLoQM4ghAl5oJvMbeztUUCIQCQmg3fXHZi\nyZJ9wml241A2cwF5yEWl/pVoQ4/slPhb7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAapxaHOj4GfS1rEwufg5W2YWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFiMjE0MjctYTEzMS00NDk1LTkwMjAtZDAwYzNjZDMyMTljMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTlmOTBhNjgtY2ZiMS00NDFlLThmZTktNTQyNWY1ZjAw\nZDk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHkPqAouWuw2gP5aNVC4Lbwe7\nfD/xlGEsn114e7ITWUaydezS+gwJ2458/u152fhUVOYqXktgaCPntAeOhyTYnaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUteg+yLS9GIGBx2vZpMAUtb4LX0MwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAIL1Dq3BC7fsyFXCgemV4xHU1DvGrk\nds52wE8t6h4W5wIhAJyVyzMYIKZU1SJDM7xXA2t5VNyqAKbVTZjV3/F1A/b8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc239", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `239` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAcOgil6JnugFjUU960KXPPMlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMzlkZGIyLWM1OGMtNGYwYi1hM2E3LTIzMjNhZmI2ODdmNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODMwNjExNDUtOTM0\nMS00MmFkLWI0OTItMDk0ZGE4Yzc3ZWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0FHnFQhNMgliRVkh9rkikXumAUeBNhU1GOBqYDu44r5IgvSjukmnmt9EyEVZ\nbOZVFJOIYhXg67nDnMMQd8NgH6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6aXTiYVYwKcLmdgHHeSQIwLPmo0wHwYDVR0j\nBBgwFoAUsWLsx38upb12uW41qLqWYvNpPc0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCRIXMhVwlVfN1nkeaMf2e77cIyBRg1\nI1rvCBATVKZlgwIgV0eQZ0jmF6GffsmWmg6ZRUEuxc3LD76hvyMUDMvN0+k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWk8xZ9B/g86LOcaRgXl9YSyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzM5ZGRiMi1jNThjLTRmMGItYTNhNy0yMzIzYWZiNjg3ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnisraBAZGi24TlfxsrfBcqP2zwsDjSbquc68haAx+7Hfi\neSut2XAiqELSvbnPDAnkWofxO2XhssU6rXZOiQs+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsWLsx38upb12uW41qLqWYvNp\nPc0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALbQXbiTqNvJvEzydR9RDlDRy3HWSxdTS6GiAE8SociYAiEA2+mnCycd\na8U495qhTnM017OAZuTqXCO8PwRUpOLpbPg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYALAhmJM+jFZ60MD2DqgJ2nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODMwNjExNDUtOTM0MS00MmFkLWI0OTItMDk0ZGE4Yzc3ZWUzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjkxOGJjODItYzdjNi00YzQ5LWE1MmQtZTY2MDA1OWVj\nOWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB9KrGrGO3xb+nsPRlc5KCmwl\nv/Emqk51ShLjwRL9a8y9d9yysWf/qdlbmU/DeSlM4pdYbU2e+Ocy80o2m4qzDKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6aXTiYVYwKcLmdgHHeSQIwLPmo0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAIwAVs76GcPVDaibvJAiEIbhPIxF1O\nNCytSS6ZrefhAgIgH+KM/5eTFcBk5ylOctZDyAZ8BymM5ZFEKUk2+aKieMc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc240", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `240` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbtJFiJ0qqD1zst9DEK+h89/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1Njk3N2NiLTI5YmMtNGVkZS05N2RkLTJmNzk3Y2I3MDdkMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ2MTgyZjYtNmU5\nZC00NmM3LTgwODUtYmE4ZjkzMmE0ZmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETWiJuTei/zl820A0bPLz1FYZk75ihUuEpcuVYzkBHcMvzx9869RvyyuWHczt\nsgUJtEAXRewFJ3BrMwCYEE5Jt6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmvVDzDTfJIn8USmlA98jcs7oQPowHwYDVR0j\nBBgwFoAUAdjKSBxmVFPd18WTqe67iNZLTMEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGmUjg0B+q66V/CxPIlOdPDyroqn35RH\n3eUb+4m5BUo3AiEAnuqwYYFx3CGhMNxFoH3aAPc0eQHAqGGrzbLDkwc50ac=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAehy31UIAFcrHu+VsP8LruNuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTY5NzdjYi0yOWJjLTRlZGUtOTdkZC0yZjc5N2NiNzA3ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwv4+h21ikbJjVn5qT4yay55m7zwR06InzhSQxPVXIEFtu\nq9/6JCVs690fiktguJOR1VHd7PsjlgE6VAiDvXqEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAdjKSBxmVFPd18WTqe67iNZL\nTMEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV2N0CxTcT7mkPpms+7ukxJkQKMDX/Yx62Y8OmszP+RICIQD83TO0J9Ao\nvfHDC7UjjSF9aLpb6cmQQM0vwTDL+CXa0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAc+R8oymfug3ra3rMmnu+d6bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ2MTgyZjYtNmU5ZC00NmM3LTgwODUtYmE4ZjkzMmE0ZmUxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDdkM2MxMDQtYjFjOC00NWJmLWI4MTctNTFlZThiZGNl\nNTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWJ3DaAu3VWyzWxRpZBg1L1SC\nvmJa3wgnpRChxLkvQMNJs1moNs2HYM2vKkdwzsbW6b1pK/WaYn5y0ZeQhr53U6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmvVDzDTfJIn8USmlA98jcs7oQPowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAWDUQu18vDikNxll6ZZsI3SLg8Ezz5\nuu5uBgtd7t8BAQIgZ59jLMD1/CQOsyfamHmPeHdtBykV29JJo/OgyJnOiU4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc241", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `241` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfmNaH5W2ZPEDUsgMSXf8MpYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3ZmU0NDRiLTI3ZWEtNDNkZS04MWI0LTAxOTQ1MzczYzE0MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJjY2FkZGUtMjE3\nZi00MDExLWJhNzctNWVhNmVhMDUzZTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvYW0hkaUfkWiZCkoTIrBqVXIyP8CZko+mDSWiENp8Mgl4jQizESKRckzEy2s\neVqTS0yvw7ZIA7hD1XqhDxUJwKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2zOgxRq/D5gDKVZMWyHOc2eQfSEwHwYDVR0j\nBBgwFoAUcjkEKfQRKJcpSbbZlOrjTXHpRLUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIBK1mOW1Mjwu\n71dUxq0/YsQmlN4YKotqs+8wr/9m/2CMAiB7S9ThRys5C5tH/XEVYbYskwcQxS89\ncMGwbbWFWiRdqA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcK62nmGiBmpRZJvd1+Y53EYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2ZlNDQ0Yi0yN2VhLTQzZGUtODFiNC0wMTk0NTM3M2MxNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmtaWkMQsn2xKZKQjNwRIc0Po+jgstazzJUSeQ05GGJzVp\nzcGtMTwx8kDzYJvwyG7LQ0LZ63xA88BeMQn65Jdto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcjkEKfQRKJcpSbbZlOrjTXHp\nRLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIj2PAvLDKKR/AMuJsYbIYQtzNP8xsVr1aIn1s6hmuqgCIQCkHq1MS48u\n2lvFOlAPP7DWGmq8zLEn88sTuISoH3ZraA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASTGhfkpXYxkgXdevZAJwlmnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJjY2FkZGUtMjE3Zi00MDExLWJhNzctNWVhNmVhMDUzZTk1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjBiMTJiZTEtM2EyNi00MzYyLWIwNzEtNGU0NmU4MWVm\nZDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+l//4Bv8m1hWzPgeuhT7Ffl8\nNjz7+axPqjB3Bi0kxnf0hiv2r1AdFea5h2k2JCjPfqs/AJxbEQAw+RMlquzZ/KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2zOgxRq/D5gDKVZMWyHOc2eQfSEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAg9g9sWiB88z0sqMVpK+aNPV1Jz7H\n0VYpGPHuuNJ2dfgCIETwVC+M8crL2cuUAT97gvPaSEIzrt2r+rudK5Apfa/N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc242", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `242` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAV1kRnlHdJqF+/tv+1+C7fzEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmYTBlMWUyLTFmZjAtNDhlOC05NWQxLTJmZWVhYTA1YmY2NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZiNTc3NDctODE2\nZS00N2UyLWE3OTEtYTQxODVhYjQwZjA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGNgkyiMs7US8Heepe7YdZQpEL3YlrjdLi0flNgb4xt55NdGG2NXuSQYc9rXS\naFk5xBxTzUOzWCwfN45JClsx1aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeEGshR0EA05jjd7f+jAtwc+b1NUwHwYDVR0j\nBBgwFoAUNtT3OoSw2OXMBqaBKX/po2och3IwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAMQuAeYac/lF5jN//yP43Qn/VpkZeVgQoRXAEFryqj+gAiEAi2v2lTJw\niS3xbTqpFoLG6nAe1JKDI/SVrjDHhVKmMB8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAejoMXQLh0q7v1j433i6MqduMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmEwZTFlMi0xZmYwLTQ4ZTgtOTVkMS0yZmVlYWEwNWJmNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARH8tsiyIpZm9bpJ28yUyS1Qz6ZiDEnmZiFag0taVOWA1vb\n/8LlGOJJOVHqL0QuWWhPylCI5RiNX+QrynnyUMQfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNtT3OoSw2OXMBqaBKX/po2oc\nh3IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKoXmscXZJlV0WWlxkrL34JKJD6z3jchtyS95k99b2OqAiEAn90Uqbud\nXK5T317wRsF8ug3nwbbJkbp9m1Fo9ug5l7k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWY5tx56uDkA8aAKbzF52PFAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZiNTc3NDctODE2ZS00N2UyLWE3OTEtYTQxODVhYjQwZjA1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTUyODdmODctMmVkNy00YjdhLWJmNjYtNTQ0ODNkMzMx\nZmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9ZpBfAroPpadxMvdox9OVMIp\n5XFj5tPrzLnheIzWudd99nIPHITwB4fAMoQmCzvPSvxsWCisFGYnvG/wzqcieaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeEGshR0EA05jjd7f+jAtwc+b1NUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBKcqBaLv7ODxxtYeukCuPQzeDDac4Q\n1U4PBdLVHVWxnAIhAKXLZvyJy5ok6HZIoCe2hi/gvI1o6+aBYgg9L63Rgpy+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc243", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `243` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAZYjNXHQ0oBR2WgIVFvMyIvFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhMjQ1MWEyLTZlYWUtNGZmNS05ODdhLWYyYWYzOGUyNTVmOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRjN2FhODktOTFl\nNS00OWU2LWE3NWUtMTlkZWRjMjg1MjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQfzxHayMXQm/YOyoEpwhx5sFy+WipauLs3yO993hTDMR9/+iZFbUe/btP1Tx\nnqP6DhuMxDIvztNdVbzRUURxpKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIr6QfXxFBocz3Oo6jBFtgs9olUkwHwYDVR0j\nBBgwFoAUUqZcsqpUM1RGwlaxPhtGuM6iGUAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgJs5Q45VDOKNDY0ptzHi7yiovqXzFohYp5DtwJQlypVYCIFLsbm5ECBA3\nnJqGZBzaGnhWKZuFnoqBvRxh4h4wVhIt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQOUzjoCHGAM6B9XArYpvFUYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTI0NTFhMi02ZWFlLTRmZjUtOTg3YS1mMmFmMzhlMjU1ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQ/fFXVghwf02KD86wyRGETaS6WiDpQaBkv1oQKE3GuTIy\nxJdzxHmwSmm4Y/9D1g/4X2T7wkeC2NSl1/H9IRzho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUqZcsqpUM1RGwlaxPhtGuM6i\nGUAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVIWP6QR8zVbY7bFJGW2ShrlxyFxvUzzxsn8qwP6Ljn0CIFITuU9uAQ4e\ncbxBROX6ZIkb+DNfeGeTLe5hN2pGN+gV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQ6ZIxoEOD+zI97oMyUM84NDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRjN2FhODktOTFlNS00OWU2LWE3NWUtMTlkZWRjMjg1MjI4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmY3MTZkZTUtZDZkYS00OTYwLThlNjItOWNmZWI4Njhj\nYzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIlte82CWTaCtOrLOmCOaOLHG\nYH7htHETTEtudrJOywgZVmrS68IKHqSWA+4LRaSW2fcXz6p5LY5uG0p261ZO2aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIr6QfXxFBocz3Oo6jBFtgs9olUkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA9kzDOAJfsg5lsPGlGZNL/WRhPci+\nCjnwzXAFlsxgGTwCIQD9cQh2wGyC5KYyfQuYUVXDJxC/oIvCFZ5LNuYNL0ho8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc244", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `244` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUe+KrZYo4kLGwDh+7KVcteOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMWFmZGJlLTc4ZWItNDBlNC1iNTNlLTIxY2ZjOWQ5OWZkNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFiNGIxNzMtM2Yz\nNC00YzMzLTlmNzgtNmY5NzZhMmJkMmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB2bZKCAOIG3mvSmXgI9FqJXn2HS6SwnPscQRhhVganJZOkW3+sxX312Dcwwb\nE0kmTLKNuY2a+eG4YZkSO5uQEKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkV+i2wYYMhgiucfmvFfUvS7Be/YwHwYDVR0j\nBBgwFoAUGEKX5YHrN4d19vuORpNSmLI8DPkwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCMxzU/Hqrb/25GIK7JR1IFp4OfBVr209YUApPM3ZnORgIgb6FTBnd9\nD4bCr4IjfVkV5pG98EAnHZS4WWda19jhZL8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW3xqNboRZD9VNcWg13GLbtZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTFhZmRiZS03OGViLTQwZTQtYjUzZS0yMWNmYzlkOTlmZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkZZmVimhACFiQtArlWhbACGLhG6lVtAK+mmofMjX//IHl\nvGlmIKbc1YoliRIsOnTEOPOnSq8ty2w9WxM3wxo/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGEKX5YHrN4d19vuORpNSmLI8\nDPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN48BWDbD9KFioLlcpYiID5AvE087GgAJ0rqKuipKVIICIE1lVGzSSBKY\nHR90UlW4IRFlCnTilTP/HfGFSeUcbDDB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVwDsf1tJUSXyZ61AQQbiknuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFiNGIxNzMtM2YzNC00YzMzLTlmNzgtNmY5NzZhMmJkMmVhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDdjZjYzMzktMGNhZS00MWU0LWEwMGEtMjBkYWQ1N2Ri\nNjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA/x53MfPyXsz2kqvNh8vKmhc\ndeQT2IMKKrlQ9AzvuP5JcXa02+SaZWttKB7YdRNCkfeTRDAo8eNsRkaNABFDO6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkV+i2wYYMhgiucfmvFfUvS7Be/YwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA2LbX43TimCa7WR3j4DFl6LKqnlVy\neSQExaltF4lzLYgCID53GCAIAZj3Ru81J0DahV69JhVTQv98rybvr17qh4pi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc245", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `245` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAXm1wWYD+IaZOqGUGgD2jyaeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1MWIxOGYyLTFkODgtNDY2My1iZTdmLTg3ZDk4ZTFiNTk3OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdmMDY0ZTQtMmJi\nMi00MWEzLTlmMDMtNDc2ZWRiMGMyZDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWTRkf3f/q2KdguH79hzpeGV4+QlOg1XfVS0bSGxptA+hR/kNfnbbrjXt3MyO\nPOioi6mLV8IrOtu6ompUoOaWMqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFISxM9nL4UvOdy51CUddq/f6KOwwHwYDVR0j\nBBgwFoAUO66chnRG1jpuU5SoAjSu5EAZWFcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDCWNKoN+rTqKA7JN408riM0UaQ/l6/70pTdI7B\nYlsdowIgBkYdmSIMlWPS9wrMxHjOUpE9OkLcZON1WJiHn8HnOtg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc3E4322n+5s2XNx87zU1ObGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTFiMThmMi0xZDg4LTQ2NjMtYmU3Zi04N2Q5OGUxYjU5NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMkI2djEc0lKBEO2Wy26KIuvv0GEuo97Zd4G7EirPv18Jk\nTnUALAzKlcsVuPtaM5a3cS8wCbnCS246UjH4tHTNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO66chnRG1jpuU5SoAjSu5EAZ\nWFcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKGFmSqWKInWvUL9iPiNRbkqdtlvm4NRqoR/w7JWPmM6AiA/GSGzyYyS\n5N6fzZB7FHoamXuH2uanPkIDNzeOSdX1Lw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWqNdCHV5CzAWq2ZuEYHtp4zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdmMDY0ZTQtMmJiMi00MWEzLTlmMDMtNDc2ZWRiMGMyZDA5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTExZGJiNzQtOWQzZS00NzAzLWIyMzItNGY2ZWJkNmUy\nNDI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2AD9t7+hJ3PPtcb5Zyzw+sbM\nj8LwcHjRIfoyzByT10nLAcSoLEQjsD9cncuQoQCISRXho6VaDLl2twSaVg3yoKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFISxM9nL4UvOdy51CUddq/f6KOwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA2F9ivXdpjA33EvVJKRteoqt4rL0e\n2AgsICVuyOn4RmECIQDGKK9cWzkNPqGK+7wCKcCtlgny+1WIKBEGYPOUR8uiaQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc246", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `246` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAd2ZhEOAcsOg1/gz9blphSAUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3MTVkNWZhLWI0YmUtNDU4MC1iZTdjLTYwOWI3ODI3YjUyYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZhNTg0MWUtNWEw\nMy00MGFmLWE1MDgtYTAyYjkyNzU4N2RmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr/X0R4GYxTPi7lm8slwvxA7DG+ItGB/PMElGnytMwEiiZMTjFUrrWPAbU47l\nZVtB2jCfYemSPU+t0MIa2WvkcaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK9vr4RREWC0N6/VfFUeu7AfN8l8wHwYDVR0j\nBBgwFoAUXfAB9ZMnQJWJSagVA64JQJoVqrwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCyIvXU5oQNGXE4J+q+vLaSFr2lsgUT4w7RztJN\nLQPIHwIgAdw0EIh7V2PETmfJAgxOJhqQhFYxXkDAV8wDziT0K1c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW1eDt1yv2NN3hcgLTRmo2fhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzE1ZDVmYS1iNGJlLTQ1ODAtYmU3Yy02MDliNzgyN2I1MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhCEEH6kL0mL6IJ+QQJIYme/AdeztedML0Hl087EMPjuMq\nFCiNOZ/dsH3NnKL4VIkHQ3f977R31pTvf6rBw865o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXfAB9ZMnQJWJSagVA64JQJoV\nqrwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALo+sgKHIwsBhDrd44AQEcWDFRMeMkbW9fuCLh9tV+CrAiBehm7zaU9P\nwGrYoIhQKxnci9B/0H6ZEpbUfhrT0Ilesg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXF7+rbSvxI2a8a46V6xuGEsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZhNTg0MWUtNWEwMy00MGFmLWE1MDgtYTAyYjkyNzU4N2RmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmI4ZTNjMjUtYzVjYi00MzNmLThhOGUtOTkxMGE3YWI2\nMmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJTK+Bc26vb/R0ZHDcKuc0yMl\n0ynQl36AwOxroHoD4IjVRfeImeD/KuJN/634LFbxhdrqwE5iYW/jm20liAJ1YqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUK9vr4RREWC0N6/VfFUeu7AfN8l8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAm2lJCKV9ws6k/dJiyK+cRBuXxz8s\nFUPjIplIJEbv54ICIG47zCWDviiqjvLz+G/inBcNjCHaPWqsnRkjVjHu/SeR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc247", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `247` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAWh3mTobg/Bkm2AWWuRC+70hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiNTJkYzIxLWEyOTYtNDc4Zi05ZTU5LTEzOTk2MTZkOTYzYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjkwMjQ5ZTEtNWJm\nYi00OTRlLTlhMDgtMDY1Mzg1MDYyOTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqSKLbL3yhGxn3ZFqS8DdQDM7IWML/oDFfyfHBJXoXN0+IcGabptJ5u9cgR3y\n3Hj2Yasq89lbkGkJ3Jy0JC5RlKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm0yM8sLZQohmlyo56IgsYBqytDAwHwYDVR0j\nBBgwFoAU5ADJ9gp+6PLgAW6oSnwD4gUw5KEwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIEH3j4kJD52uA/+6uDVyCAJ+b9ryBy5Znv9g6UxSVbdAAiAG\nbaxjoNC/cA8H/8CeIgUy1zWYM7Oeru90v5NFA58RNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQBXEAhufLudzEw37lCs7ggFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjUyZGMyMS1hMjk2LTQ3OGYtOWU1OS0xMzk5NjE2ZDk2M2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGI8KkvnHUHS6fgwV/SHzNv+Wtp01QAgieOAs9c9O46sx8\nnxXhbsbQKIniaYM8zHBnRVQ0y5QL5w9nQX+b6V+uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5ADJ9gp+6PLgAW6oSnwD4gUw\n5KEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHyhE/3zTeYO0Rc5tX712QCl15MTmqgn4iaveY9kKxRICIQDD5d7HgQv4\n+UZ8HPgvt726NPtzGlqAXEeLMfBDBh2YTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUb9l0hT3jyNhvypcKHm8TL6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjkwMjQ5ZTEtNWJmYi00OTRlLTlhMDgtMDY1Mzg1MDYyOTY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODc5MDg1YTktZjI1Ny00NGYyLTkwMTktZTg1OTY4Zjk4\nOWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE24f+7SIjK4Jeo4JqblH1X/PH\n31/X+1Kt+KCCrRtJlubYzIL2by3wpzPIecbClMFagINrHecZHvmqnK5tr7cC86Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm0yM8sLZQohmlyo56IgsYBqytDAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA0O11UAiuuAs6ux7tc9L8ptO8zJDa9\nmwoZUfRb1ocpwwIhAPDhh/906d8GVBFID99+CpaZOHj7Y9IJ5YmZKqZqO0bN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc248", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `248` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISARFBqYNqUmSZPkL447XTIg87MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkNzM2NTZhLWY2NjItNDY3OC05OTkyLWJkMjc3ZTc3OTBiZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODEwODFhNjYtZDM4\nYy00OTE5LTllMjEtOGMxZWQxYTI2ODJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9g12wbyPLoGd5nmsgszTwREZdxvxymNLxtQx0KjKeQonBE1bXuoQlqPKe0r4\nXCTzJViQAGhJQYrZ53YuoIXJQ6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrwi8gGUAVlwveNgzyRxt37IXVpAwHwYDVR0j\nBBgwFoAUu+2CtBxNvl7tYtZCpB4WGkoHhBswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCJRBzicTEVvuOfQWF2b+OXSLH3drSR\nnNTIWh2xzdOa8gIgQgLVj1rcJHDAMvXCClS3tQBABYX9c58hv2ddviKGZ6w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZy8hTg6JgyAuM0wZnaxQP0qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDczNjU2YS1mNjYyLTQ2NzgtOTk5Mi1iZDI3N2U3NzkwYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQM2kkojlNHwvgDbxiYOci81GTBLyoKAxyivtSS5a2F83vt\nSf9dhKiDSp+aSypepyZR74HWPPX0UgWbYHj62XN2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+2CtBxNvl7tYtZCpB4WGkoH\nhBswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGY+tCkR5ryk6LuM7TmRDnT2g0N5RFlop9gq3tM4zkFoCIHUDWRGJq4FL\n3oLpwUpFq60Ccv/0wSoDP/2gjrMNFWX+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfJ+cUEcVoxA7GlvcnAjfRlZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODEwODFhNjYtZDM4Yy00OTE5LTllMjEtOGMxZWQxYTI2ODJlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzhkMzY5ODYtNGVkNC00N2Q2LThlNjUtNDNjYjBjOTE3\nMThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwi9EgmArQ6Ru7AgUrQ4mLlnM\nlagitAgcw4Zo3M8rqVCtGBRU2d9AqJ/4SjBKpv0J+vkaqP6LQ+fjaCMhcmODYqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrwi8gGUAVlwveNgzyRxt37IXVpAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAUvYIzLDnN69RR6/7YqcT6BOlr8Utk\n/fspozfD3oTRHQIgMUeMjuMj0FayxK7o5Tn/EG4q1gktQO3FaIZaXraJIrY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc249", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `249` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAT+MKUpPGcHQIYOtvVL5aIRgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwNGYyMGI3LTU5NTItNGM0ZS05MTI5LWM5NDhhYTJlOWYzYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZmY2I1Y2QtNTdk\nMS00ZjE2LTg3ZmYtMmJkN2I4MTE0NWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpsR4nFi9+ZdRQNwLFK0RavfR2GWHRU8kw7U4J/t28JJodXIrqCijLNqAXrb3\n81QnGwKThuFlwOizMbAFNz344qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIyve0DTFcqeLlwFXNAo2co1qLDYwHwYDVR0j\nBBgwFoAUhcYsSEwxkdVDZLAVH7m5HD6u/3owSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCXBopU94V+mvOyeastsM/XAi3nUdk9\nnbVl6u2i+x8EZwIhAMpO5gysjqFEBgL6h/bFqkw/uINfavRs8lDnWp1agV2c\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZdxG4tMXyshH6F4XqvsGWKeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDRmMjBiNy01OTUyLTRjNGUtOTEyOS1jOTQ4YWEyZTlmM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcrZFSVrjl5pUPbrze38Z+5QKoDpLyR9sSD6DzWFi+Azm7\noV4Qlvr80fSYBn8I97lxOdjqjT/nuQqu1u+bc7Zoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhcYsSEwxkdVDZLAVH7m5HD6u\n/3owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWCnM9ffoE7WINuwoksiM34hlVomMdcA/WFqEUKxw7b0CIQDw7O64LU4M\ntLBRiMhPtYKQudfkVebtJhHVYLcu26Tu9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXWSBgwmlQSZVo6tWTS2j9nwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZmY2I1Y2QtNTdkMS00ZjE2LTg3ZmYtMmJkN2I4MTE0NWEyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGFhZDFlZTgtOWQ1Ni00MWE1LWJkYmYtMzljNDJiYTdh\nYTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0s8pRGB1NOiZC5tlyhDBADfk\nxKdrlrWIJbpl41KJxHfIFMIUlOD1kfHjpYbgwh9OQ2np0TaShMrjU2lY97isv6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIyve0DTFcqeLlwFXNAo2co1qLDYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAiRDYRjoSUiIvTGn2NITDE80OT/TY2\noyIKLzvs5ST9tgIgJp7jg8YgbDcALj/SIyGkxSS0bI3gGgm4KJor/GO21U8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc250", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `250` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZX+hgoTMzHc9cqeJaJ1LWEqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiY2VhZTVmLTk3MDQtNDFjMi05ZmJkLTNmODIzOTM5MzJmNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2VlYjFlOWQtZjhm\nMS00ZjEyLTk0ZTYtZmU5N2VkM2M3MWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfsMww/3FgxnjUOKQMz/R0TOgmsB1yMlDN25Hk36IFlGM89tTrSbDzASzxSwk\nsy0jwmjW8IxoOC/qwa1OUxCk36NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFF92G91yfuQe6asZrgIQy0ZWy5qVMB8GA1UdIwQY\nMBaAFHBcMbthOL1pMuDZaqRNv4TZjoRcMAoGCCqGSM49BAMCA0gAMEUCIQCiN44R\nDs8yjvsbYb2bwD1LOQtTr6ku36/pI8ElokgUyAIgD2TkSbn/RwHXWHzuKHaqr6vx\nezwM8p4vgQ3obRMcYIo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATxn5FBQt8KhqjwkVxJC+WCrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmNlYWU1Zi05NzA0LTQxYzItOWZiZC0zZjgyMzkzOTMyZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ90LynpFWlbdQUv+TLflke06N8qce8xPmaBHbSYEBKE84z\n/sHZMxsclSFidNQRcpowAXZSvIBaaNQJIkbOdsQRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcFwxu2E4vWky4NlqpE2/hNmO\nhFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaDkVJ+hEkHKeWHK6bApyMrzogrdsatJ6XVAulGDI+DECIQCm2IwgBC7c\nCqTrr27SBxWYHkS4w+XTvrOceDN3dv99UQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAVi5Ai7USJ3ZWMGnIOWrqbZsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2VlYjFlOWQtZjhmMS00ZjEyLTk0ZTYtZmU5N2VkM2M3MWM2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTIxZmRlNTMtODU0OS00YmE3LTllNjUtNTE4YWQzNGRm\nZmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7XsKgPd0B8zB9EazjsEfZBTL\nz+EQ/ps25xsI4dThvQFWoULRQ3n9sLDoA3HlRk0Ki896T68KiXpSkEjeFzPUBqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUX3Yb3XJ+5B7pqxmuAhDLRlbLmpUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgWd7OzI2LS1W9z4EQ\nuMenpoGzOPYbZgXD5IaiOpsh8/YCIE6CLfiKu+TVSEy6Owrd9CMe2k8VRyBy8xnL\np9YybA++\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc251", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `251` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAeiwgoSpKFBivghnPrlTLEOCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZDI2MjYwLWMyMDQtNDUwNC1hMWZiLTVkNjk3ODRmY2UxNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU3NjkzYTYtOTA0\nYy00Yzc4LTkyYTQtNzFjYmRlZDE1ZTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo4n+n3EtQvXDv3Z1cZWGq4QIc/bWle6BTC0d1HXtRMdiQpYJpB1DAIuwYwqX\ndhzLxBs8AAat8GYr1CghafqL1KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGwssso7ToYYl1kzmckJs9IZrrxJMB8GA1UdIwQY\nMBaAFOt6FezroBGGghB8RGJOwfwQD4szMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAxiIYqrAgJpEaOfL6EZXhDqkuT6JQwOTRN\ny33o7C57zAIhAIvO7TjQQUx54ZEGOK0y24vI6KXIM7aEzpg30UdZ8Rvc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZPxrwZVu1e2MHQotmmQd5WVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGQyNjI2MC1jMjA0LTQ1MDQtYTFmYi01ZDY5Nzg0ZmNlMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeQQA+5VqEEQuwXuVoWG4b663acD4m6ioioZscJDUfh1BF\n3pNkiRWOfIgYY6s7bM0eoBUpYT+bE7LRFfusp6Flo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU63oV7OugEYaCEHxEYk7B/BAP\nizMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANqK58BEdyAwK0eVUDrSr0YMsrh4i/u4iykpx7qPC4EXAiEAyG5b8SFO\nFqyEWyqd2zAtCFp+moC1bKD1dKAkYMU8bNI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAdk/f5fYmC69qSWkVcVj3gNJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU3NjkzYTYtOTA0Yy00Yzc4LTkyYTQtNzFjYmRlZDE1ZTZhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjMyYTI3MjgtMGE3MS00MWNjLTk5MzYtNzg2MDQ0OWI5\nNDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEndSrDuDemT2fv8mEdqu3X3hh\nYaIconhxJMoAgGzNxaMrFedAZgUO2M33HHcHdEiMGp0RconyZUU4zZAGMDW2/KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbCyyyjtOhhiXWTOZyQmz0hmuvEkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgTvuFr2eVIjQhHnly\nZhPcqBk2QmQsQqY4e1UTde3SJboCIQD2sBAkGEgUYAsTp60AYjYskSi/S4CGxZDK\n0k+efchh8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc252", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `252` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAan47DIhH0rL4UMc3OFqwJg5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwZTU0Mjg4LTAzYjAtNGUzMi1hMGFjLWE2ZDcxNTdkZWNkYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTlhYWRkZWEtMGQw\nNy00ODhmLWFkODktMGM3MjZjYmRlYTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYenPANIJqHg+8B/pqeEbX6Q0zXvhy3HWJwqSWgNyZelFWpueu8ER8Z73gD7F\nvRtW7WvN/xyKgDF71n0RhR+q1qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDngMCWjiXCeyk/Pig+KJKxm3PAOMB8GA1UdIwQY\nMBaAFDLpj5SDt7tLCI16sFB1wrf4C2kRMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiB9Onf375TadDo4VDjGfkhDSzangXthsow7\nq6n8e6BFEgIhAMRWRvG6bSg9W3X/wI/C1DQDIgzgVgQWokfMv4AoBHxs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAafATvpITNVexpRa5GMZWmPeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMGU1NDI4OC0wM2IwLTRlMzItYTBhYy1hNmQ3MTU3ZGVjZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQagJGuIlIvXYlfTsPfhb7Bo37VVMugaFgBqOX84GeaEU1n\nLLlZ9a2oQRE5oME6jtZaDoy3XURAc8xc/mxppbdYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMumPlIO3u0sIjXqwUHXCt/gL\naREwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK7eg629VnX69hUpgh+ypDiWVlenylm/2bg0p9+nyHmECIQC43uMopZUA\nn+0XPms7z/NI1Ezc+6ZjDznyq6YhrO8jlQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAXjBZa7oGBbp9JNqt4u6P3MOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTlhYWRkZWEtMGQwNy00ODhmLWFkODktMGM3MjZjYmRlYTU5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWRjMDA4YzAtNTUzMC00OTliLTljMWEtZjI0ZGU3OWU1\nM2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMhf8kfmYzO/UdiPYnac4WRWQ\nkwVeKHf/XA+PanlbjGLU0snzuJwYvkCBQSZdZFbOpEkIvtgva6QM8ltvDUkqiKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOeAwJaOJcJ7KT8+KD4okrGbc8A4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANx43XFetLdlPak6\npPH45guRGuAYtLYI45J7VfoOSztKAiBWyDMzmQREmo1Z1MkFU1QYf3SRcjkA7we4\ntJawE7Z4kw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc253", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `253` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAfp+AtSsyp0xnS1DvYlCK5tQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3NjE0Y2FkLTg5MDktNGMyNC05ZDM1LTZlZGNhYTZmOThmNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRiNDAyOTYtZTYz\nZS00NDQxLTk3MjgtNzFiOTAwZjE5YWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDFG+Y4VWUa8AudH3sxF48bda7b6RDW7MbATJl1ZIZhTiwRFtBPoNbwG+iCl7\nQIlsyqNFW9MayjdlKlW/fgSpK6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ+D0S3A5mzs+fY9/KUm4KWHphfrDAfBgNVHSME\nGDAWgBSrk4eCHaaVzPDGITeDALXzylFeOjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGsxbFsC5Ugdd+unXLTjPnQrVwGT9ny0\nFQmAzAubUGMIAiBlUbfBop+TIvtCbqDSgjUoPsZud5DVZf1vhThO0BSlfA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAct0ieBcA/ZHqF2RRUyhzM0kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzYxNGNhZC04OTA5LTRjMjQtOWQzNS02ZWRjYWE2Zjk4ZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEOx6cb19Y6BeK5p7frRDcmgbubIGbccjlA4yV6dgtiPj6\n2wGGKYtFHjUMmTV6fRPl5XePTZ9FPVKui+ujNpzDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq5OHgh2mlczwxiE3gwC188pR\nXjowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP6/pON4T2TlqEN36b7TNia4fdNzr8+U2Ikn2iR2EOvYAiEA/MnZ/Fy9\n5lAGs408oN22onMPABHYlcibyVx2RhPMr0c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAY3GXgyZq0fJkR6/HjsNgaxAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRiNDAyOTYtZTYzZS00NDQxLTk3MjgtNzFiOTAwZjE5YWM3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzA1ZTJkN2UtZWQyYi00MGEzLWJlODgtYzE5MTk2ZmU5\nNWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6TNgU+j6RyPxy2ohAg0AB7sJ\n3UBUZJmwqTSKKYj9H5Y77dDDSHZAQyC788t526zR+obbo6iUqi+bpVJoXNEOiaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPg9EtwOZs7Pn2PfylJuClh6YX6wwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgMe62hrGdnDEtdRS6\nAnYGE6JkbmcoeCIzuCpMlF44woECIQD0qG6hHYSGp+agvu8QcxCN2T5WnQ9iKOGh\nuICwGWKMbQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc254", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `254` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISARfQTcJbJl7FMwkahIPE+xhKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMDM2NmFhLWFmNmUtNDlhNi1iOTg0LWIwZDRkNzY0ZDY0NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRlM2Y2MmYtNzgx\nOS00NGI3LThiOTMtNzY0MzRlZjk4NTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOdFqMud9qDtrKd6HDg1s/TbDkAsK58dSMRc1geOEkvhM7cz8/V3wZYkmGxl3\nm+e48OiFmkqHHIq3JdXtR8e8saOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkzYE3vKtpBRMEtpknqj0a7kQxY0wHwYDVR0j\nBBgwFoAUT1VDeJLeUcSzhnKJU5iQwg5sRPowJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBCIoo8nVnq2yWE\n8/bachURJTIs6FFQY/bZPb9NCDqKJAIgOOLQs4cthWfI6HlbJVTGao63BxyrujNp\nF+O+POnZDQU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWfroYPMADPqsLs2NDrlPq0bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjAzNjZhYS1hZjZlLTQ5YTYtYjk4NC1iMGQ0ZDc2NGQ2NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARf3l0dNQmr0G4aXNZE+DXxdFwhoK2mDNkmuCiybcfpKUc8\nGcRonYjvpZOnn81kugP7DLOfROPXy/LbB7ec7ex7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT1VDeJLeUcSzhnKJU5iQwg5s\nRPowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHNNceqvNRAkpRNFWjdlpVz8Oi5cSB0+qkaEmHJuAaq4CIFTDTzoB1wXP\nl9YcBQQdSjun604vmYaAHkHZkTB3hKwR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAaZluWHMCuSlmLfUHsXaJltoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRlM2Y2MmYtNzgxOS00NGI3LThiOTMtNzY0MzRlZjk4NTE4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk4NDUxZjYtZTdkOS00MWQ2LWFjMjAtYzI2MGMyMWU1\nN2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwrSnam8c8DL7uXMIWqlObrPg\nl2PJdaOI9++OV/tRso97v1LvkExA9yVn/szYjQRB81cfeJkVjA9gVXgkQsI7RqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkzYE3vKtpBRMEtpknqj0a7kQxY0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOnXJtOeuKq92iu9\nrapWJMQ7GrPjK+33+kR5GSBwm0oiAiEAnaO0EXWqj+s67VZOMjsUyCUSsK/GmX5m\n3pyqhQFLGhY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc255", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `255` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfUpr8WFhBXcVBJYUeH5qx1ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4OGExOTkwLWVjMDYtNGQ3Ni1hZGJjLWRkNTcwOTVkODE3NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJiYjdiNmEtZmZk\nZS00Mzg4LTkwZmQtMDI1MTExOGNkZjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnAI4N47sKFuRMqGZEU0MeJ+8Dd2J0u7EJxJXme7FHmfvPpSb/UD7e5Wnicm+\n2V7Kl9zO6iBSBpmjkG6Gg/XPFqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURURUP/f77NthKh3pjsKpG/OCbpswHwYDVR0j\nBBgwFoAUGRFq3K1RMzB+B+vjVIO1cJcZGu0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBlkEBE35Gxaq43\njKn4pADMbxPLYCPczvHEVPh0jB4uOQIhAN2R+sz/fjM/9g81QIixWYS0RPg4lCa/\nVtqXHAJW0cmH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY2dnHVqX4af8r6HDYT+EQkcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODhhMTk5MC1lYzA2LTRkNzYtYWRiYy1kZDU3MDk1ZDgxNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARt0Gkf873XYrdtlzCPwqwtsrZ2R145gb7kLFCC0dwvO54M\nCBeYxEa9wnmFKyv94L6P2lr/DbDy/8Yxt/2KkD8uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGRFq3K1RMzB+B+vjVIO1cJcZ\nGu0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIZ9fksyncpySCwjhMVZVVjXC7uCbJBLDqnhpa1R8Nu0AiEA9aCQ5KdO\n0nyrAhwEE7JaRqDcB4/s4qJUX2+spRVxzyE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAQw8JkW+v0/Y6vSpD5eoH+haMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJiYjdiNmEtZmZkZS00Mzg4LTkwZmQtMDI1MTExOGNkZjQ3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTNhODk5ZjMtMTI5Yi00OGI3LTk1NDItY2ZjY2Q4ZGQ3\nYzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9wZZpc9Wywt/Wbl6SjBs3UD2\nTrVGGFZ0au9l2ZZzTfkLU3Ummb2usR4apcGzliSR235kx+3sKvBHzDzYhRSqFaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURURUP/f77NthKh3pjsKpG/OCbpswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOIaXWmOo3eNQ8Wt\nWhPlaDInIQQP8c5yzNKgNRAqqmMyAiEA+59O9tZFuvpkIMqcO28QTiubC9UNF+/Q\nsW07l3yFFYg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc256", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `256` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAYyyUHm89clxGgcQ7w1FyhrcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyNGJlODFiLWIzOTAtNDdmMy1iYTRlLTUyNmFhNWM1YWZjNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVhNTA4Y2EtNDU1\nMS00ZmNiLWE0YWUtZTIzY2EzZDQxYzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEObe37BjYB2iuZCfAip+9kBefLP6qEgjmG5Ivz8df15wwKrzlbnhfd3B+jLcJ\nJ7UFcBge2tNHPz+eKotr/FEjRKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmerfeTCZueUWwHRygIffkWzOjnowHwYDVR0j\nBBgwFoAU5YIbrysHAfQDQWTNO/FinOdC2c0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBDIGY2ZwQtMmqBl4rX1i4i\nr47UaOnIAD1jGk/1hyFA/wIgY/q2dX4YE7FWa57TbVHcBRw9Cp/CjMSkkzJLidqe\n7FI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYRJ+5/E9hSNmNN6JrdCurGUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjRiZTgxYi1iMzkwLTQ3ZjMtYmE0ZS01MjZhYTVjNWFmYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATB3sNOPv5nq0FUKB0hnygXvFt59VmobEiDAipWIV8+LQb/\nFPk1KnXAajpqPcvOqZWkn/PoxdPHFtLwe0lNyWNko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5YIbrysHAfQDQWTNO/FinOdC\n2c0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO7iRZMl4rBvj5w1NCdcYp9GsBcgFrvT0V6OXp3utE5HAiEA2mNrZeuP\nraj35JRP+xiDwAuyU0SLBTg1RT7jDLiECjI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZyOCFrOCDMNK3ze3syCdRcUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVhNTA4Y2EtNDU1MS00ZmNiLWE0YWUtZTIzY2EzZDQxYzI2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWQ5NjMzOWYtNTlmYS00NjU0LTk0MGQtMjI5NDE3N2Y4\nZDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+RYzIhtnm/GdirnwVlJlFdF6\nQJv8H3hP170GlAIDrSVc/3Pkth4bxyfILpzmoo6JmTFa7Nq1aplCf2blEZroI6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmerfeTCZueUWwHRygIffkWzOjnowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPN+Q+2XZ8Ipe2Yp\ntexSt0mpk8m2k555K3rqz/khpPfAAiEAtJb3UKtmNsLk4iyGNX4Jw63pra6UUWFK\nrRKyvDUF5Ws=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc257", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `257` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISASPTxysnQlOmS7iBtgLfp9BIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwYmUxMmM5LTBmNTktNDkwZC04NjZlLTk2MDNlNThhMTY1ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTViYzk4ZGMtMTY0\nMC00ZTUxLTg4MDAtZGUwMjRlMzY3OGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH1/QQJIz4Mu5GeEMP0P6HC9Z/jHuDCaFpjQMwwJQC7OfBDLCM4KVwKt1t7DY\nZGfZuLGZUdBGyiY+dghDVSReuqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUag0dbs+FmSgYGzbB/fL94TcLbeswHwYDVR0j\nBBgwFoAUituKQimJYUT42ePFEXBlBtKNVzowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA7pTV\nf2o4YJlTYm7ANT8JGZ4pi8LZbS7GrG9pwLKOZfkCIQCjF8GXrcttBOoOoWuFuP0/\ndOALeVdTm9PgpYyMq5NGKw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT/8DFEtJNHhfT0MojLaUsiTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGJlMTJjOS0wZjU5LTQ5MGQtODY2ZS05NjAzZTU4YTE2NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASw0r4eil822leYwAUPTqWPeEcfUopeqIH64OGsILdYbQV6\nmwOJA/wasJf0Kr2xkvWGCQLpgHtDI8ji3+UrCxGto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUituKQimJYUT42ePFEXBlBtKN\nVzowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI65DnvOmAUCpLxg8miO3qNJhazuHjak5AuXVQnKARrBAiAuSBBVUtjJ\n1ZgALKy3i6xvJ3aGooR8g7+NBEB3zwG2cw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAeCJhBDFWhq0AGsVmVeaGnQEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTViYzk4ZGMtMTY0MC00ZTUxLTg4MDAtZGUwMjRlMzY3OGYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODQ1YjRiYTEtZjZhYi00MGVkLTgxODUtNzc2ZmExYTZl\nNDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExnpC978oRshrNBh9UJaA6zLL\n6FydgmMMZXwOfKhbcXZYBtfuxrrQmesePlJEDTVT+3HEOQQd/ylrPxzEbHxsX6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUag0dbs+FmSgYGzbB/fL94TcLbeswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgE6snbK0qTzEfVxrF\nOne+SuYTW0ELeEjLt0FlwXCnOHkCID12HQ2hsxBR3KfQBbqzf8wv7E0Zm87ZN3BX\ngbhLQLjq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc258", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `258` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAVQpfGGjs0fegq+Dry+u75ubMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5ZWUzZGUwLTUxZjktNDdkOS05MjA1LWFkYzY2ZjE1YTA3YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAwMDUyZjctMTcy\nNi00YThkLTljY2QtNDY2ZmYwMWM1ZjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2Wak9dwh/ae2tDM3oHpPMRCcOm0RRgYcUf1MDsgks31qjhrNZXX6zaHUVfoN\nUXEz2tY4CP0G6mw6MQG9ZCfuDKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz7PTFlL0CIbnk7vaBFee9/WFex8wHwYDVR0j\nBBgwFoAU714PTZ8GiJYL6OAJ36xbjbDD3ZswLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAe0EWA\nLpYXs/uspkZfwm4olYcN8D+YqNKM9bRvw5lOVAIhALQZglS/nvKXcBXkJMAEzrjz\n/rnSCsGJIMAETVMANYMl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc9vSfAQVWyGcgUs9Yrc6fF4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWVlM2RlMC01MWY5LTQ3ZDktOTIwNS1hZGM2NmYxNWEwN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZ63FwIUOF/nwpnZwoH8iVdDEGweqLUGGcH24NJwktr+v+\nussLt3kARJ3KZ2gLu6zHjHh+TMIl66e5caOWXiHwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU714PTZ8GiJYL6OAJ36xbjbDD\n3ZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWgri5xnIHyDSfqvlsSkQFQmMPINfn5LADPRMZqlDyisCIC03i9N9tray\nmVa3u56HJB13181G9j4GBjw4xL10VsoJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAb8Yc+6ZXRhDerwtUNey1TdfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAwMDUyZjctMTcyNi00YThkLTljY2QtNDY2ZmYwMWM1ZjIxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTJmMmY4MzgtMjhlYi00NDk0LWE1MTctYTI5YmU4MjAw\nYWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpw/OhjmM/YsBWHN4DGoBt0Ep\nycDLE/cRVNA0xoRP61Ek6TfVFTo8q2LS8UEwylwmp2BlWryRmCn29SGa+n6f7qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUz7PTFlL0CIbnk7vaBFee9/WFex8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOeZXfzKoBEToIvc\nDgA3G0TtEDFw5DNiqUWIVPzuoEM3AiEAzikUzTX5n6FU93YJAb2Gb2owrT65Lx3F\n9TFiBxQ8OnA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc259", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `259` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAc/w+GX+DlUUeSneyde4vqs0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjYTA5MjA4LTExNDctNDgxOS1hYmM4LTAxMmNhMGQzYzNjNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNhNzFkNmYtODdk\nMy00OGU1LWIzNzMtZjc2YjA0ZWFlZDE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES/433QS8I9YmMffC7Mv+5wkqfTL5G0pvx0FCmRPBLRrfMvRrmdgqSwTk/jh5\nD4LBGG/ON3q1v0yHBxnffLBKJqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFF6ihPVePUqfD5kexzOGuXVS9GXNMB8GA1UdIwQY\nMBaAFMKcfjcnT20mIFVZGnBPQyn5s8CMMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiABvsd5AWYtsER3lpbIoO34cqqVC0s1RhZJ\n1UTyx/74SQIhALsI8IDsGtQiTH4sq9NBnBMuL88BTspcMFyQpiIRukC/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcRp7BaLEGrSGpSx0SpYPH5MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2EwOTIwOC0xMTQ3LTQ4MTktYWJjOC0wMTJjYTBkM2MzYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4WJWa1rJpZKKljs13RTsBXLDFuy4cX6Ezpi50jfofPyPR\nDzXI5bihvtrIwet4pcLHSflSLqe+KH8mE7JmkV/zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwpx+NydPbSYgVVkacE9DKfmz\nwIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDJcilZ2AVZFhjT/el0BfKigUfDW2/52rywezJwXzIfcCIQD5wuZWK09W\nmXoPSavXEG8Zjqi173lrxrpdDQ7yzUAmsw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAe98/lCU1TPRivBcBWgYzCwcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNhNzFkNmYtODdkMy00OGU1LWIzNzMtZjc2YjA0ZWFlZDE0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk2NzkyYjQtODU0YS00NGVmLTljYWEtMTI1MjcyZjk2\nZTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUVwfGOHsvrlehv6msRHJsCu4\nmRLPLgrHL+7lZd5aOnVU/brcYCzEcK0tUYK4HImVbRHQezppt2fZevR/CZ6UJKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXqKE9V49Sp8PmR7HM4a5dVL0Zc0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKXtbOnKgctCK15T\n6t+Z4C7VDDi4yqz+v+XdQmDLc35XAiEA7JtyEE6MMBedfNSymUpq/dpSLsjqykF1\nAuW8nL8GPAY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc260", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `260` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAdcqUqt+Yp/QE6vekWv/sbNXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiMWI3M2E2LWU4MGQtNDhiMC05ZWEwLTM4Y2Q5NjVlYjY4MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmMzYzg3YmItNTRh\nOS00YzA3LWIyYTYtOGIwYjgxZTBkZDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP+TPAMYye6kmpKZSTKKUNH44KvHdgjqFsh/kVHNjwp+vVNjugQ98HzQ/63Fe\nBynd4IygLjiTxd1Y0YAEtnbffaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULDwuWyzFiviiiiKTHMF24MC0FvkwHwYDVR0j\nBBgwFoAUdJ8tQ4BdoicyOh4rV8vVWdfItuswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMNnhTgqKeCl\n7Ti+IxlOfLCqdaDjBObb7erpI9EtzMcTAiBxYFOukiAh0V+52w6KAfUJLrasUrbD\n3gbKVs0zFOiPwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ7S+lnKUh2JYNsHcgI8lBOuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjFiNzNhNi1lODBkLTQ4YjAtOWVhMC0zOGNkOTY1ZWI2ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvoz5MIfqjGqeD9vfXu3BG0tKQRa35wwB8aOpRPfpKwOQg\nogpmK5vKh2R31tVfQUmUbB5JfbXfWLgekhmg9qP8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdJ8tQ4BdoicyOh4rV8vVWdfI\ntuswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPcnF71anUPRZmV4WKXyNltJtPh1sHm0TgTgLzgLWKhNAiEAlMDT9jpB\nHiW71iiNBQAPKlwk/16DosIkBuj3V/cXkds=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAXFBCYu/3j20PRkWvr5CcSd1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmMzYzg3YmItNTRhOS00YzA3LWIyYTYtOGIwYjgxZTBkZDQ2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzExZjRiMDctMTAzZS00MmFlLTg5ZGItMjBiNWQ4MjA2\nMTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8ORznseTlL7lXPwtNDQC9sFS\nxJEao6QXz4kT9q5IzqFq1jFG7VzNtYDF55r11QZ/DlWCRWY/Do7C+pAD0Rb2naNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULDwuWyzFiviiiiKTHMF24MC0FvkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPrndM28imewkuM9\nccdCkFT0A9mSCb4mfEfsnX7g5vxhAiAQoSyYcWTeexpuWUn+fe3itktPbPK5T74h\nhQtdTYZ2jw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc261", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `261` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWMC+oDQOeIlmxLUGgGZ2BuhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0M2JjMGJlLTNhN2UtNDkzNS04YjZkLWIzODZkODBkN2Q0MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2VmOTljOWYtOGRi\nMi00ZWU1LTk0ZDItZTFhYzU4MTU2MzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErdGWcF6QkCIW2C2NQgDjd2jMgfaWNgNlashv8rcGUhQr3XhUMqWDrZdEeHP2\nfyuQYZ8OvZ+9O1KZYXBhb1FmuKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Xdvbok2Y3b29GpuBG2UdbCGQd4wHwYDVR0j\nBBgwFoAUg+Gt4eUKM7Yq6uBYPgc+KTD7SxowKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANqwffbU6/+S\nJQI3A1A7/4Pf1KyosTj1s2adLWTof0S+AiAMx5HcSV0S63k1OpLXumeiYPY1XgR6\ntR3Nm3YMW97zHw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVAj8T1bLZYFC/5fzfS9bl//MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDNiYzBiZS0zYTdlLTQ5MzUtOGI2ZC1iMzg2ZDgwZDdkNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlxYVub0F4HGQOAJyEHvY4mhyV9Xb4gePG73bjodaSpwLQ\nKDJVv2qcKoHw+kbimFVf3YIW5W67a4BmGkUL5N63o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg+Gt4eUKM7Yq6uBYPgc+KTD7\nSxowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRoaz6nAvGg2u05HcIWLB/wRivA2LvnEfnzTWM65kPlYCIQD4v7k++dEa\ndWCT4FbGIhAOjG5rK/sv36BmDTrjbgqcuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAcN39yBq4XIf47XnFGD9Gn0/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2VmOTljOWYtOGRiMi00ZWU1LTk0ZDItZTFhYzU4MTU2MzVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDY3Yzg5MTMtZjljZS00NDkwLTg1NjctODFiZWU0ZTBl\nZmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEylsV+CKWo1Vyl7Au2EVE/4GV\n1p1HcEqRIGuRdzjKzJbFtqKCMjJuZQYkjzEWk9Xd50oQSVy8cTMzPe0g4HBno6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2Xdvbok2Y3b29GpuBG2UdbCGQd4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgJwpUrltstpA1GDVh\n9ZugXc3nEM0NCogra5cqMyPO4UwCIQDboiwXQPjr3084wMUfNgmt0Wn4EA7dt87u\nKD4uKIxBwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc262", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `262` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAfbprxgbpW2j/C6mk8ICwtcgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZTc4ODQ5LWNmMWUtNDdmOS1hMWZhLWVlYmJhZTcwZTZkYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDcwOTgwNTctM2M3\nYS00MDZmLTk1ODQtNjZkN2JhM2Q0MmJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc5X5PH1S5gBS4pz7pKzxZOrObB6Nahlm4iUVdDJWj6Qm/dytXO51aW7h4mUz\nnk2aWLic4wE6AqsDUtSleg0SRKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBVqM11NhpxT/5HbmQHYM9mW8EawwHwYDVR0j\nBBgwFoAUHuo8sCkYpwTUzpRxbsZ0Ef003yowKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDFySO8GHMc\nS284GZKIoJ+y6E+1oifzcsMNVzrOg7cpQAIhALNl/ZSQ5JftSm+bSsyT+PzgDjYl\n2iq9YPknt2i+j6ps\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXVEBuUqo9shU1mJ2EgrFQmdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWU3ODg0OS1jZjFlLTQ3ZjktYTFmYS1lZWJiYWU3MGU2ZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVfzfR7Oj+gkIQKpSAIRLumHxzsanP9WjGRUCHiJ1wJjD8\nDDWXb1qyWm/llWvVSp2ZXLymxur4qLKLLcD1nXSKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHuo8sCkYpwTUzpRxbsZ0Ef00\n3yowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANB4gG27M0sTdCCPMfyQ9zp/qupyZmtcS9Q7to47vQPPAiEAmtcq4v0w\nFolgYEMIZroIAGwQ6874ymj4H39ifhnDO8Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAR1DOqN52F++XignK5UO3W8nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDcwOTgwNTctM2M3YS00MDZmLTk1ODQtNjZkN2JhM2Q0MmJiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQ5YjkwMzMtZjQ5ZC00YjdkLWI1MDYtOGY3MDVmN2Uw\nNWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeBNJrK8yMbqa6j75hVvN7pZR\njsy/nqlhuZDgs9DbUpBi3TGbiw4Cb//TuLVZs2x0jkcnPHQgokfusNvjXHzEA6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBVqM11NhpxT/5HbmQHYM9mW8EawwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgVhWz//qSx/NPb6CH\n0ZVdbd5tRFF6t8g5UtMpGau3cTUCIER9HiR7Sys1K0TfqbNHjZzvIyhU4KQJg3yj\nWFwlN9oM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc263", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `263` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATeUIx/6sPxuvGBhrXnevZDYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNWU0YTlhLTIwMzYtNDAyYi05OTc2LWUzMzVlODdkZjhjZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAxMDBkNjUtYTU0\nYS00YmU5LWIxODMtOTQyOTg1MDk5YzRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXQ+pnWPb/hFT4fL2snYfgXKa7qlQr27miHPFR323m0HB+kplrL5ZcISXKSS3\nNiR76E5aTQmnPiWF7AaSuHLGEKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfYujYVRQpBmaf+sIPm+uBm8qFoowHwYDVR0j\nBBgwFoAUS9TOd5s1CkUtCErRMknFAezm9c8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHWQlKIuXxtvWrm/4qGCuXwmuffRpKEQcUn2s9xzqeajAiAi0GStcn6U+kPM\nDogtYFRVSawTrjNOVAnnv4WosFNZ8g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATbc8oIDLXS1KU2U3CvQ1YoTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTVlNGE5YS0yMDM2LTQwMmItOTk3Ni1lMzM1ZTg3ZGY4Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrVIzKcE+qywjX+xyHVcqkH8MHhaZTACcv7CXscqrbjpw0\n6BMAqyhe76nFQV4yldlLF152cj5rRCTH/w6KdfeZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS9TOd5s1CkUtCErRMknFAezm\n9c8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMJujX4DHgkcYLptiauVpLyT4z9Cyo+dC1Qyh/63su81AiEAuNzeXuh5\n33+/oP5MxWHty5n1UUUqC8iJj85WkNKtjZY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAfKc1A9pWoOAX20fkRh7ylG5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAxMDBkNjUtYTU0YS00YmU5LWIxODMtOTQyOTg1MDk5YzRjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDI4NzA3NzAtNDlkYS00NWUwLWFjMDgtNDFkNzdiOTIz\nMTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEf7oD+4LayMBhi5t9VFnOVmeS\nqFhmhQaqk7H/vOd5MMKg8bfDTXkdoXzylUbKI2jOovOul7eoIjyMobn7jsXCd6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfYujYVRQpBmaf+sIPm+uBm8qFoowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAP9TxBTjS/2YOtWv\nya1ME692YfkLuCeDOvZYVpVevby/AiEAug1uhA8iiPhBoMrFlxvikhEFYGv6Cc9u\nVGT2/+yYFWU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc264", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `264` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATFQociMLBXVlcY+odGpOQILMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjNzkyOTBmLTVhZDktNDRhNy04OWMxLTJhNDlmMzIwMDk3ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA1YTE3MjQtOGFj\nZi00M2Y5LThmYWUtNmJjYzY5NzUyODU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVdDRSjd45Vh+kK/BNQDb/gU3H662gF7oISQE3SaqWdv6hQLL8cjp+z7x3u4R\nyYuPRaxIHX+DEFR32YD2JbORN6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/XtN26obQJSLQ4i80bnqOdPS94kwHwYDVR0j\nBBgwFoAUdX4B4C0fFK7BKsfHcQwdr5PgTM0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCFVS/9KTk2MzoIrDxpFKqV5XD/gWATJ1UM8sqFZfy6DgIhAO6r41YGn7hi\nrtjPxPfpYwQvALGlD9hNuyCMGj+k76oR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUq2hDn+rRGtFw+LK5BfMzOWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzc5MjkwZi01YWQ5LTQ0YTctODljMS0yYTQ5ZjMyMDA5NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+Z+MK5nAp6SvyHT85qrukREt3vSeMqnAoc21ajSDs3EQV\nAtc7tOqTu/X9EThcnFoIrnaPj136ZVJ0p2g35sYOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdX4B4C0fFK7BKsfHcQwdr5Pg\nTM0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALyoGoxpFpciNz+xeg1ZCP/byWu2GGCUml2k4vWav2IXAiAc+/FozqtY\ndRO3CDlFxlH0IoUG+Q3tYUCBQXKY3W52AQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQ3N4A2ZRGOY54Jj/+ENiesaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA1YTE3MjQtOGFjZi00M2Y5LThmYWUtNmJjYzY5NzUyODU5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjNlMWY1ZjItZTFhZi00YTMyLTljODMtYzhjMTgyYzE4\nNDFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkvITTcl/dDfYWv7jZBXDAGJz\nvLewVP3WznKQHccV9dYrViEnb7gPilwS+cfbGeFqIt/BzuLCBm++4Xp7XZOjbqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/XtN26obQJSLQ4i80bnqOdPS94kwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMlnpu4i5sBTWRqn\n9dkRJyzpfQ/YikcCOAL/ToXTnbdqAiBJ1w3p40XfPZ8eNUkLTJL6xKgCLiKs74he\ncbEpcwhurw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc265", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `265` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAaxtiV4bCkMDiqyogXWjM0xsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNDFmMjBmLWZjM2MtNDZhNC1hMDExLWYyNDBjNWMxYzg5NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZkNTE1NmQtZjA3\nMy00NTAwLWEwNDAtMDVjMzlkMWExMmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJQDePjtCeLd2sNvYHgjC8t8X7esqD/LhsQbTKKaWkpSZveTegE5yzNnFunKe\nvYa7ZBgO9poaPJvF551qzEwP9KOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY62vHd7FmEVR5mCuoJ7g0wzOArkwHwYDVR0j\nBBgwFoAUgVSAoJqeg2A3ZbvDwEOtwes8MNIwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAkW\neK8CcMady2dYGXGmEOKlwRhkTLUGO+iASgKc3Fl0AiEA862o19X4bdp/VRQXiYP4\nSxJWZ9O+Rz07sY4hWRPhF8A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbb+WuC/WP2wNMFj/IDCv3yHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjQxZjIwZi1mYzNjLTQ2YTQtYTAxMS1mMjQwYzVjMWM4OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQytTA/3MqdTRBFE4P4hwQWdOqsnRV2zqVzMojYAM+C4D8A\nZNGopd9fNlTZQGgpwbRa8T69bdYTlUrmKAI2eum/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgVSAoJqeg2A3ZbvDwEOtwes8\nMNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALJu5WfLbi4bkaBetetoROnMHE85yTXosPov3lRLK4A2AiEA9pa2q8Uz\nUaFyMU1iYEKRQLtjoTikq1yMMA7EDrDh0Ro=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISATz2hvv+wm7H1/cJ7AdZYA0ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZkNTE1NmQtZjA3My00NTAwLWEwNDAtMDVjMzlkMWExMmNjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjk4Mjk5YTYtNWVlNy00MGY0LWEyYjktNTZmMWE2NTUw\nYmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw72k/24SILAz32HnfmvDRPRc\n4tWs3cYMEB5dg/H0ooFDHKkD56cLQCqk+4wO1dJkLybvRR4i6Dw1PqeLnjCgTqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY62vHd7FmEVR5mCuoJ7g0wzOArkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgDQZbCfxnzo79BXm+\ndiOS85r6BKbFSBu262Ba5A8sfDUCIQCcK0o28GCsG3xYUJFxr2RTWBC+k7X62o3V\nW0IulX3KUQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc266", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `266` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAalvCCm0cGUy/gmLlvqzNzdaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5NTI3OTMwLWZlZGYtNDk1Zi04YjNlLTNiOWM5YmMzZDVjYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ0NDlmNTgtM2Y2\nMS00MjZiLWFmNzgtOGE3ZjA1MGNmYjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoOJ1fdw525/fZQdTljk68vLvDHftmsXDou37f1u22QZm8KbJumyO7DoCGfDl\nvL1AbEuQqbRm/a26ptLCWyN2kaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyCW0FR1rLVVR7E4BHdvu/oP9vREwHwYDVR0j\nBBgwFoAUvowKfxFSf6lwgU6KDGujlqjG2Y4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIGoyu1kc8Ru621h81lmZ0tXHZ2Syz4oSkRGHdA4wxGBTAiEA3YvU\nrKvkG6/uTkDfPBOgBtajoWAwHLFnfLrG2pUdAcc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfuLvCgqhEmuqvYn0Y1juvDdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTUyNzkzMC1mZWRmLTQ5NWYtOGIzZS0zYjljOWJjM2Q1Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgKfjpHLJ/WI+HqqXyGw8JxYVtxPZpUkYwiCFOaMvHIMYa\nDbVGcPDRhNxt4aCfFR2i4ER7+PBnY6wSAFTFXS7Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvowKfxFSf6lwgU6KDGujlqjG\n2Y4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPsbioW+ICZ1LPLyOG+hmiezxfJ8yEF7HazFqY0pTkMACIGMSCxyIxQCk\nny2nCVqr5RRli0OTKGlEwGVNdM4SIQY7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAcDQStULqiDuzG9GW0hzIod+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ0NDlmNTgtM2Y2MS00MjZiLWFmNzgtOGE3ZjA1MGNmYjdhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTY1NTM2YTEtOTE4Yi00MWNlLTkyMWQtNDQyNThlNTQz\nMDJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEie6dEjZtT/atkJzJpbmkTgOD\no7/l9vVnosPPmotW8EAy7fc1QMC0siWkuMYtAqJqtOOnX0dgylJHFJLyw90HdqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyCW0FR1rLVVR7E4BHdvu/oP9vREwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgVLbciD8zNLUvmBzq\nKhAw2safuIJZZzpjlC2fFDyK88kCIAh6UcFrO2Ba6Fkr3tu+LwAESzsa50Lyej9C\nmoy/pEiS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc267", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `267` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAajpEkos4sSw99WXPXIPDZ++MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4YmFlNDNhLTllOTMtNDI5ZC1hNmFjLWQ2NzIxNThhNzE3YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE4NTU5YjItNTlk\nMC00ZjIzLWE5MDQtMTQ2MWQ0MDJkMDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsj35F87n+IODoISwcMxkkUEJ8NLqIG+Vc8XebK4/A9zlZYNNPM+95YVl+y89\nxdOvnL0OdA8Lv2e8T6t+WlrUI6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULpZM/PRnYiHuZgKjh5n0N2IfVhowHwYDVR0j\nBBgwFoAUgy2lztMOAvkgkF1EbakH8ffBjAIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCiBg8iLjAd9NljwZSx9Y3xbgt6Y3wWwRPpk2MaPe0R5AIgHRBH\n5tYKQd4ytPibwZSMAxSOwNuMGkPLC9yMMqkAZyQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAW/8eSHmlXiAgZTNHS/pvKIUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGJhZTQzYS05ZTkzLTQyOWQtYTZhYy1kNjcyMTU4YTcxN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBIGl+BY6QYB/GpmxDWlMrO86wIpb+Axb24imK6pmoJIGL\n9RnwnZKpQB8skXs3UqdhmcC2Xmihm4xrwBzl67/Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgy2lztMOAvkgkF1EbakH8ffB\njAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIgYsAFCYIUSmdlb5L/o/0ZR+Hb9yBhk1SU45dm/bkLjycCH1iOull8up4h\nuvYL0TonZrP9InaucEYOXaDxl5Fu0cA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAb3s/DHb+HHYCzqFpO5ZazUgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE4NTU5YjItNTlkMC00ZjIzLWE5MDQtMTQ2MWQ0MDJkMDVhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTI4YjY0OTEtYWMyMy00ZDM4LTkzYmMtNmRhYTExZDJi\nYzExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8FoEaMtuFCOGRMdWplLf8aHF\nxdaaXKff3Zc/L+aAhGwAvUvTmYpyrC7Efyz/61p7hAGK4YPS6wtzbXGYgfk5JKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULpZM/PRnYiHuZgKjh5n0N2IfVhowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOHcQdABLbgL82Bm\nGLLtdfAtIQThU+pxSQ1te9MsQQcGAiEAvUxI3AhpLg36CupE8qGBP26/z6OzMSqr\niPfOshgoeqk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc268", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `268` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATyuOJ/1Ic/9kckhmqzQdCYAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4Yjk4NDRmLTNlNzMtNGNmZi05MDhmLTY4ZDBlNDAzMDU0YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc3YTlmMmItN2Nh\nMy00NGNjLThmOTEtM2MzMDFmMDQ2MjgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjWJH7iIIgEhqszklbMmEFYLcHwSbZ/mZq0tBHTWvHqg+vCpCD5pRsw329/3S\nZWtvmSC7HqI6ZsH7y6QCfMCsKqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFh2i+Sh8jx4R1cTM8p/DoYn6cpGMB8GA1UdIwQY\nMBaAFAr2YDvrstxApPfE0eVOxfi+ZGHPMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAqq6ntVFwswRZHbHmo5CF1dRzG9vNezCUR\neXIU6LjJ9AIhAJgsE11UeKjxm7DsZ8C5gAH3nZn9C1+fGgs9g1dKMAlj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVe08TP8MXOh/nRx3F+ecdiLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOGI5ODQ0Zi0zZTczLTRjZmYtOTA4Zi02OGQwZTQwMzA1NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASU1xxaxeOc8asgkt3J3hIjvJ7RNwNbIZzx2yyGCoyJDvHC\n6x7PeyGv9BKG0UJWleKjmzsCY1CQ0FYOJ0jfXYHwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCvZgO+uy3ECk98TR5U7F+L5k\nYc8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKmnX+gagOkDnF/S5mYU3cvdrDYioCcikH/yfhTpq45YCIBVa9HI+DkkJ\nyUqXlXXnNWljVGyT73bD8Xbz9/zJfQFo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAcd3Ab4n+/FB6MQhbT/c9sBqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc3YTlmMmItN2NhMy00NGNjLThmOTEtM2MzMDFmMDQ2MjgyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTllY2FmYjItYjNiYS00MDRiLTg3YWItMWRkYjdjNjc2\nYzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE3JO9L4h71MjlosCMmraCrH2\nD7WnARi8CWBSQbG894k/HD17sgjWp5hZOAmvyhQfPNM97WHoqoDr/tvVqxDSvKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWHaL5KHyPHhHVxMzyn8OhifpykYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAK/B2dOc435UGyR7\nNR7vzQ+VQUreOJfeXZ9OzfW7VKugAiEA3Xfn5J7s1zeQ/1SsxIz/QGorXJgpZglx\nItD6Ec521HA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc269", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `269` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAWEzpLSBl/Kmeky2Un0hIuAlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1OGYwNzlmLTIzODEtNDE5Yi1hYWJhLTk4NTVkODg4NzJmZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMThiZGQzMjgtYzUz\nMi00ZmMyLTk1ZGEtZTM2YjUzOWVmM2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOjXV0NH4tJcaTz+dAQIqoPI/TmkLp8yI7pIZlMUF/1tGUxuHhF3iSmxKOlq3\nCQ/GuJYTtNnQ00hjYpQ6TExZOqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSOlv2v8T7P9fwpBGH5V69mFLImMwHwYDVR0j\nBBgwFoAUshz3OaaMH4840mTCq1hrFQvCSxEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgC/xqx99gWpgK\n7aFl+Ka9lxIAxxatLITW4IMRCEtsFZkCIBOkMkfZCo0nWqV8kE9/TYNLEph+7wMN\nvYzTfWXOLqdG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfhch9m4yv570l0Uubxa/W1AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNThmMDc5Zi0yMzgxLTQxOWItYWFiYS05ODU1ZDg4ODcyZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuIK+LnNqZJEOlbOSLmbOmv1YimG4KpFu+P4/IicVCeXIl\nnm59FBlPRO7K8PO5J1CWKi2lW3VPE8pUz1xd0eCVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUshz3OaaMH4840mTCq1hrFQvC\nSxEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdPFRJVrHO2AYqNU8wazYZioX+4Q20O9YF2xnZOf946gCIQCFO/RIcFSL\n5uf6DD1bzLllxzvUwSiO8Ly0SPIGjZzkGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAR8DviJ9prngy5vKccMWDbkHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMThiZGQzMjgtYzUzMi00ZmMyLTk1ZGEtZTM2YjUzOWVmM2Y5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjE5NjYyZjItNTliMS00NWY4LTlkYWMtNmY1NjI4YWQw\nYjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsiUKvS/B3+9YF24ybElYrECT\nCUFCuoxRn691r1x4mAoVlY3feBwXx+gOcFtLU2nKRUyO9KYBaRtH7EnTKf5YWqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSOlv2v8T7P9fwpBGH5V69mFLImMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgc8JH1jV6b4RPLs9g\nlzkbBif51AKVpr9vWhULs5qKp+oCIGfie+v2uvqkfx4iXrD0EO4YI16ZWRwW5fCs\nM3TNKex5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc270", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `270` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISASNNNYN4DcS1g8Zt1jlTyd8+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwZmVmZWU3LWVhY2YtNDk3YS05ZWMzLTJkOGI5NTVkNTJkZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M1YWVjZDYtNmVj\nYy00MzVmLTg1NGMtMjg4OWZhYzEzYzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV8kZ5BcuIVmzc0jjk87Vzq5LK6oVgC39r6aE1xS2+0+oYdW2OQ8SwX79+RQF\nVXfV608OsdFi/BekVTbOvnfiu6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF9FFjiw5v3UYzgWo7XeT0PPIXXIwHwYDVR0j\nBBgwFoAUw8kgjWcgvqTJ/Nkqdk1VtIRtVz0wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJGrS5qMODs+\nqvfujDpKCs1j94ghmg6HOJmAXg36/4fgAiEAqfiJUetY5t8mKifr4p7DbcZUQwhw\n4dEPkdj55X0OM18=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQRTEEcfJHqLGBnZ+9ZOjjyUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMGZlZmVlNy1lYWNmLTQ5N2EtOWVjMy0yZDhiOTU1ZDUyZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQS+9du/VwLK+TsEMki5QtNlxdouMCHXIZ18XUSBDMquP+a\naEjBuUrx1BM3hRY9EgdLhWyr4tjDgQImeP91lK9no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw8kgjWcgvqTJ/Nkqdk1VtIRt\nVz0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJbTeprL7XTkmk9ekbKVrGXxr6PrjtE5o8vuh0FezQ9JAiEArZ2PZzUa\nF0OY213jUQSuNFKxl9PKOwyyr9Pd4Iw/D00=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAcBrmaZUyFzF4v0xdDGpFIGQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M1YWVjZDYtNmVjYy00MzVmLTg1NGMtMjg4OWZhYzEzYzI0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODhiNjYxMDAtNGYzNS00NWNkLTkyNDgtMzViODQ4OWVm\nMThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFoExxtloIEs0TSTHYoc/8BwF\n+NGhetu9ZtLo5hZu+BIHJqHS56XMCsYC0OMIwI82YQflef68zaXbDG8b9eI85KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUF9FFjiw5v3UYzgWo7XeT0PPIXXIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgOVIP7Trh+jK5WQoY\n7SKlSJ7rQKIU1b9IDp8X24s0k3ECIQD7me6spC3rmgA4GpIpSpbh9drJ1JsMFLhK\nvl8JI4rqLQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc271", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `271` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAbZciILJxEY1bI5iwRfO/xNWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZGY0ZDI3LThhYjctNGNiMS1hNzRiLTQ0MTZjYjE1NGU2NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ0ZDg1MzYtNGEz\nNS00YzBiLTgyMmYtODIxOTE4ZWUyZjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5sXG+fcGC9B1bfEHZ2tNOaUK/QYkdS/s+bHyfcN0m7zt54bMPiWNkxd7e79e\nbhMEjZJPG9mJKU25mOn46XuXxaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUucnzkAZEJtne7xGu20zuTOn4neQwHwYDVR0j\nBBgwFoAU8ozbi/5PZrX8i+c16Fp+OsEBXpMwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICiaW4lBPojm\nOqYpqIrR/Um097SNN3gEN7T+RpN0Z/GeAiBzqGfavkbPqzT83T+gi+S13HLKYSea\nnMZ7V6AFWGwJPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX1nMLJnQIG88eFtjJb70nHBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2RmNGQyNy04YWI3LTRjYjEtYTc0Yi00NDE2Y2IxNTRlNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5ZrsvEoN+YqWaoLaejcLydbPWhSEtctF7OHc7Zqk6ADCi\nmlD996NbUIHoIYEFUM2VCkFORBsxKtiv5a+PSFyIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8ozbi/5PZrX8i+c16Fp+OsEB\nXpMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP5D/7wCl2srtXLpv3L1Ri/5ghfiolIu/t/vGQmyJVsUCIGsN5OqKxips\nVA8mSpIDc5LJNj9Gs2ok4rkzYKPHLhca\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAVJC94hQOvkE4jXUWs6KPE1vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ0ZDg1MzYtNGEzNS00YzBiLTgyMmYtODIxOTE4ZWUyZjhhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODViY2MyZmItY2ZmYi00NDBlLTlkMDAtMGFkNDU2YmQ0\nYzZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMi/mhlFkgzE4JetzBkz4wC7D\nGp4uGNED6Pmd3cFNB8NApUHT0RbBg6BFG/NyjrGegc6QZJglwhB5iUZugikZP6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUucnzkAZEJtne7xGu20zuTOn4neQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJZjlvdoNagaQlFz\nhAcv89kBcOjpfb6kqrc39CBhb1eHAiEAxoh+vhQMFFfHTBkKap5xm2O0Rh9c11KL\nEAW75DRWxyo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc272", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `272` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcVBdo7JB149f4ZC4Y6KF5RDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxYWIwMTEwLTJkOWYtNDFkZS05MGJlLTI2NTdhNTcyODBlZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjljYTM1Y2MtY2Iz\nYy00YzlhLWE3ZmUtMDdlMDdkMTg5YmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHdcMjcV1m0oTQsrdol531ZjohMbgufpI39iMpidp/JZNv7nQlygkboeQDrPN\ndDXF8qMfDyhTJOdmI9DCeKwabqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNB542+bxIwHM+JZociyxXPuFt/AwHwYDVR0j\nBBgwFoAUQiy9yJCTP1leBx2sYC8gZMz+tmEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFVKca+CfNOMog7thI04zbobYlqyeqjBpd/A1q3s1HhzAiEAliwOXii7oXoL\nhMnVgK2184LNliMO5ZOlb5piB+Tm9tI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdWajzK25IlyTEA4pbRnQxx0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWFiMDExMC0yZDlmLTQxZGUtOTBiZS0yNjU3YTU3MjgwZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLgHQLIjjUoTjLQ+2+kE0dznYRvN2WMNwxv+qyOJQQ7UpO\nDmfFo8EM1kiaUIcxonh3qhLcpjdgPJuZlrpn9IJ5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQiy9yJCTP1leBx2sYC8gZMz+\ntmEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgawDALsL2NpIryV2mBzfde2/HCQM4BbSqvWMh7bGKxOACIDIvMZSYD7b3\nxeKlVePAWxY+BOfCsoX7u9ZlZeeRagPx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAXLJIANZ1QCt7XCC4EuGkvW6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjljYTM1Y2MtY2IzYy00YzlhLWE3ZmUtMDdlMDdkMTg5YmRhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmZhODYzODgtMzhiMC00OTAwLWJmODYtNjVjMjM2NzI3\nNGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEINY+T7d3c3PmkaQwKQ17eoPk\nfakNI929ZP5um/0TNWDPR3gUtwzYVNTQ58qOJOB4g0FNQCoR640SJVYW/CiuP6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNB542+bxIwHM+JZociyxXPuFt/AwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMt9qeqkMhZJMyZP\nEMuF02CC7dyTfHWilt4SDYXnoI3yAiEAiNShBv3YazjJALg10L9BQFbJi8jb5TjZ\n7VjrsYFtGW4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc273", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `273` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATO/mJMchBtsmUnMtM9G3VoWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiZjk3NTQ1LTEzZjAtNDM2My1hZDQ2LTFjNzc2N2YwZDliZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFiY2YzNmMtOGY3\nYi00MWRhLTljODItNmFmZjAxY2Q0MzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECYB/3KE9pHj+lwAJsbnNBB/kTFpBJp/oLVDho4hRrhLpT3AtQtoQK5ZN/DBe\niBEteAuEoPX60iU52W6SXxZIp6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvi+KtFvbIdsnX576xehx6aaHG50wHwYDVR0j\nBBgwFoAUDtboZi3+67bGJgkV2ykW5ScNhF4wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAL7SFDLXp7iavzJpxD3YM1xGv2L+jB+cL3s6V4/o2TKAiEAgqib6h2j94wg\nzP+ozYqt88r9J9NejSsRQ4zHXBY8sV8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYTFBOXYW4xvbzeOrtFGG8PzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmY5NzU0NS0xM2YwLTQzNjMtYWQ0Ni0xYzc3NjdmMGQ5YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSxwp3Hte67X6d0Js4Ku4fIsg6H1yH+ay4b0/uPQjzJFx/\n4244Lql7u3SkoGgEBz5q8oNMthkLE3TtufjmwaWdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDtboZi3+67bGJgkV2ykW5ScN\nhF4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZgTJZhHK20uFGVQlILntBuQaGESLyQeQmOJcRgOsHXsCIQCLElKDa0+q\nLkLInnWz6uQLkfdGQ0ZA0Hd0dHMK2tYoOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAcRuFEUbZdnae3QO6BL7pNYpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFiY2YzNmMtOGY3Yi00MWRhLTljODItNmFmZjAxY2Q0MzJmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTJiM2MwYmItNDU0Mi00MmRhLWJhNzUtZTQyNjZiZThj\nNDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDkvY8oLX5KKKoRQY3VWgCOLu\nepM/WiBkTDnn/C/x1gmHoRARVjJRNw+i2KsAP+iazTyGdbtpsN7G569pAZfp0aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvi+KtFvbIdsnX576xehx6aaHG50wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgI6BWY810fRLDjX2W\nU3ojyynE3NAVxvuoF69t3wMkPpcCIErenGtDPzxF7l4tcuyLVGSLw7bJtmlCq42O\nQupV1YSe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc274", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `274` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAZ/7icqgWInNF16V3etApAa7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlZTY2NmY2LTEzYmQtNDZhYS1iYzNmLTA2YmQ1Y2RhNmUxODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM4Y2ExYmEtOTg0\nNS00OGQ4LWEwODUtNDk2YTM5MzRiNGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECO22CXTkKZa1NbIWMulzR/PDkFEKAfbS27lyyUZ4DHHP1/57ygZHN+0LT6FZ\n8ma5Ntnl3VWQOWLNS2OektqMsKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCBgsiUWMzXDME0ZhyZWbk671UZkwHwYDVR0j\nBBgwFoAUWqx1At/3U2avVvvrRmVIxgWUS2owLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDx\n9iDwcbHGYyIOIS8bKxL5O8oBG4/xBLh8XH5KBIklWgIhAPhE3QuS5LPit/koq8qH\n+FhQmXvfdCC3hEbaTKLK441B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVm6eV9LFEHG2dNOU4a8/QSGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWU2NjZmNi0xM2JkLTQ2YWEtYmMzZi0wNmJkNWNkYTZlMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzNJrGZYO0NQjjAEz+od++WZFFCUfQ2BydWkxoPjDXkNct\nQC39IY7SYBumDKOT/1q1XsC4kYomZh/6riJjX5Jho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWqx1At/3U2avVvvrRmVIxgWU\nS2owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOVMIuwMmGNPBDf2nylYhyjWARSmbtSUtbu0wJdXq6bACIQCrJNbMs76X\nQWMHPleMNuI6Gc42WPoKrKa8pnxpKV+qOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAcOqoKGGi3aNA3/pcrMUUvQzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM4Y2ExYmEtOTg0NS00OGQ4LWEwODUtNDk2YTM5MzRiNGJiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODVjMWI2MmItMTNmZi00NDMwLThiZmMtOGQ0MThlN2M3\nN2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMvULUMdchdNcAO1QuvJBYMJg\nEY5XylgjCXChKZht3B6I18UGFQ3WDE7qj0MFf6b23W7FB7JUrMzIzhNpKMHdBKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCBgsiUWMzXDME0ZhyZWbk671UZkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgUZa3/dkTH3Hrytx1\n9VScR+Wf2r/I6aok5p8gs/AyfAwCIQC0IzwWt2nJYGzc/f1zMYvD+T8kK4aQHYDD\nwvun51YOxA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc275", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `275` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYjLFmroMikMtWjAnqkpE0yJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjNGEzOGQ0LWZlZTYtNDY4NS05MGExLWFlODBiMjc1ZjIyZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODhiOGFmNTEtOWEy\nYS00YWM2LWJmZTYtOTEwMGZjNWE1NGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAFsqsJnKoJcqz7eBilt9VxSLgN0Yvg/RjEpeCy9uETPQ0LOL93BkWaTV8Kab\nt/bblJPssoh1LTUKGKK2sJEZOKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz8YZLC2rni3NjppmnQFlb3ppK2IwHwYDVR0j\nBBgwFoAUDrc8J58HtR5SPm/76Mvcr2Oj42AwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCFVNUskHrJRvlzjHct5RNAMqzEFJawWuQbtTOnwszQLwIgVrVi\nPKVCo+E71pwFF3/ORgqYXzsyHvYVVEHgyrlVGdY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdzMfPjfqHfR3TtKoNjka0y3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzRhMzhkNC1mZWU2LTQ2ODUtOTBhMS1hZTgwYjI3NWYyMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv53kTyIs5XVtJBKF487scXRhBePCG7XTtnsbuU7JHojSb\nzsVJunlJyGzBBhOjS9CQ1MAcnUGIjOwR9zbgBKRio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDrc8J58HtR5SPm/76Mvcr2Oj\n42AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALYAqfdvuZIuJ8WGcOb6RWVOV3yuhz0sc3dEi0xvNPm9AiEA/iywoGHT\n3VYAz2cx4JJbFHkuiXf7rhWfu7AW8HgXM40=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAdy4AeBkhgLLj/alekQvvcpcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODhiOGFmNTEtOWEyYS00YWM2LWJmZTYtOTEwMGZjNWE1NGFiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGMzYzVjODgtMWE1Ny00ZmQ3LWJlZDAtNTNlNWFlNTQz\nNzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0yYjXVrhrR7UNpXwAP+qJve+\n0HifbSHZcYzZ6ThErJ5W7QRtrEv7swUFi4JckpsX0X9pLVQr4bcCUBY50QJKyKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUz8YZLC2rni3NjppmnQFlb3ppK2IwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMZfZqPLXRA2j22Q\n2beda5iHN1wN4fwl8yRkgKOg8+ZqAiEAvQBUGdmQCioB3t2GOiR66gqsKqxZOJEm\nsTUUlDK4hIc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc276", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `276` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQboE0ohIg7H2nJqqEITO97+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4OGExMzRmLWM0MjktNGUwOC1iZjUzLTY4NDdiYTAwY2IxODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q4OTU2NzgtOGFm\nMy00ZTBjLTgzMzgtMjRlYzBjMjNkNTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBL8BEiHS80SFsYKmg7JmZe8xu7uFD3Wtu0VkFHWJ7Mtop8jOR5rxBlOYxyHd\nc8VkYeBeBH2xoDdjt5Gar2bFAaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrz2sJttx5HfemfRuAlkz7gNbx+gwHwYDVR0j\nBBgwFoAUYhNw5CeHcpvb8EsAZgIXsLOfvwMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDp0QLxV8NieqUQeXVnEK65S7//RgIshrKIgCztWFCVRgIgd3Qe\nXScm9CPfz0dIlDlVbutslW4b0SemNTT0/pLcLoE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY7kw2msb5w8VpkwmeGakmJPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODhhMTM0Zi1jNDI5LTRlMDgtYmY1My02ODQ3YmEwMGNiMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATS1e+NLWgkl0Gn6AErPeL6Mc0hh1RCKjAzENZBZ0WBc6pD\n5Sl1CAgFlsy6R+JE7gix0PsM2enIHg1CB1Ivv4CBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYhNw5CeHcpvb8EsAZgIXsLOf\nvwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM/lImy+McuoQbcNRmR3tmZ+ISEFwIJ1/JiQSbBTzOcZAiEAqkAYMuv2\nuUDzmGnuSTTIc7M2i5h+bG5n8Pa5SU8FXkY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAXzydMF89iaSccYo29FM/VX0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q4OTU2NzgtOGFmMy00ZTBjLTgzMzgtMjRlYzBjMjNkNTlhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDBjYThmMDEtYWJhNS00YjczLThiMzUtNjRjNGE3NDdi\nYzA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdpjz3sXc+yEJLkwEZazwboj1\nAV9V7/6AVCvilwYsB/GZs1L0/Jg7uIL5vfU6Xjy/xS8ly1n46WakwKUHwfiVEKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrz2sJttx5HfemfRuAlkz7gNbx+gwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALeokoyZpGea75RV\nCiP1Z00PCHvNWwdyuADxQKGEKKyiAiBh8la3XAduNElJe3ES7flaRQxFLGBMDCHr\nP4Qp2Uvsyw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc277", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `277` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAUle2Gv0jb+Y927Rj+Z/fvs2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3N2VjMjQ0LTk4NWItNGJlMy04ZjFmLTRkNTE3N2YyZWRhYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UxNzRmZjItNTlm\nMi00NWEyLWE3MzUtNjkzMTFhNzdiOWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf0P/jrGrjbfmO0ZBZHO+EyZyECiGa9rvqUKnf+Ldg7P6JhKpTttULZCcSuWA\nYYsKbx5d24czjNoIRro8oWLHgqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQof5Ele2PXPhnok2f1FTUzpXLPZDAfBgNVHSME\nGDAWgBRET+iTPBoZxgL5FrqVtQuhLMI2FDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDetjio+6zpunNhiNCGeqXdy1gzVF7kb\nXCJp+LqRRh0oAiA37jXKp5+ZlHelxOdqQJ1jH71IouSS6aFtpeDvfSLoZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASBPNn6HsaPYID0HFJluGWQVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzdlYzI0NC05ODViLTRiZTMtOGYxZi00ZDUxNzdmMmVkYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjzSVQNOgpF5WEt72mYAM787jVA873tKel4pJR/soEds5P\n9AD6ZJhMukcWIcYb4EbG+B1AZeMNPD+nQFXFL0wRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURE/okzwaGcYC+Ra6lbULoSzC\nNhQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfIwdh/l2zTQwha1OFsmb4VHJLBJYL4QFBmpuEw/ceGwCIHy6OSiGdClv\n5N8pTJpUFjQDlf7SGHrSdgBCLsRl27Kb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAT7nnj+gZ5Cfd6CA69geL587MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UxNzRmZjItNTlmMi00NWEyLWE3MzUtNjkzMTFhNzdiOWZhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmE5NzIyNDAtN2EzYy00YjBhLWE3OTQtOWUyYTM4MDhi\nNDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETw7SGvxvKYB38JvI1ZUI0LnG\nBTu0BcWo8sEdnTdwJmGj+QANZkWH+gGFnq9Z3fA+MLMZCuZPpIiBubC676meeaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKH+RJXtj1z4Z6JNn9RU1M6Vyz2QwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgQFWhWAoeYHfJ2mn5\nuozc/Glz6OyDdwh+i6LcQ+Hxl5kCIQD81LOf/47EGMKpxEt89NMDYE/f111rfPMJ\n8/hRmFziSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc278", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `278` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcmmTDpE+iYZh6PVN4r8d6bzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiMWEyMDYxLTM4MzctNDMyOC1iMDlhLWNjNWRlZmZkYzIzYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThiZjFiZGEtODM0\nMy00YzVkLWFjYjAtYTY1ZjkwZDNlYjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENmKMy6DrvjMZp2wUEQ3DGzySZJccqZWgECyhy1yo2mQrrc0Ki4mtu9JtbPBQ\nsSSEoa7btQhwpDM4SzzZg/8T66OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOzf6boxL8Kz0y13Cy9tvSRx7oL8wHwYDVR0j\nBBgwFoAU3xxnZz12651x3XNiwDlrJoU14w0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDtFXHQS3ox\nL18PwwEiLIOjAm3cL8RJMm613kbP46HELAIhAPLwUkKolDxUmu4hO+XCRXLGccX8\nMMfFApXdXHS2OrEs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYL/S2maiSxldKXqaa48+Ip0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjFhMjA2MS0zODM3LTQzMjgtYjA5YS1jYzVkZWZmZGMyM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASORen1oBLWt+qWFu47WIwdly1JwobROm+MBlrvK4W6c0T2\nOoIIjTWL0S1BW4iGXv7H93ANo6AD0s1g3ehphv/8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3xxnZz12651x3XNiwDlrJoU1\n4w0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTxv5kAOnYs2P8q1RbTyjo2+Fn8Lboq9Kaq1dgtFCMhUCIGCcL4xFuDvK\nohKR6mWnNiMHUumnpP8//eQiUd5fHQpO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISARzHbuoziE+++sDxePtUUDDzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThiZjFiZGEtODM0My00YzVkLWFjYjAtYTY1ZjkwZDNlYjk2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2M4ZTBkZWUtNDRkNi00NTRlLWI5MzktNWY1NjY1MWU1\nZmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQRqvrylcWPW16mXGcEO7bU/W\nc007rs4JNzXjcBPFpe6CTTE4JQm+CLdsmy+wAXBiAWlL6n8tm4qG+3TCZdzjMKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOzf6boxL8Kz0y13Cy9tvSRx7oL8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIgjFBZCSCbUbGWU\nXT1gdEAQu7vDZvpZr1KDkvjwvHREAiEAuOSDxJWM/JU9jN0kKcGUP6tFVzyvqA2+\nI/pcA5tEA90=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc279", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `279` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAW2WaS+81aGV0/cVISaWcBhfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2ZGY4Y2U2LTU3MWQtNDUyMS05NzJjLTc0ZDk1ZDUwYWI3ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGRkYTllZDktZTli\nNi00NGMxLTllYmQtMTY5Y2Q4YzI0NjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4iLhGZa86CC00nRyMK/XvEdHwgy4fuPmYat8dJ9QaW6leSCq3P16f9a1mJpF\nakMk2F9Ey59TSD3wCvQ5tmsQQqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/7eppgtq0i/PSgpefflRFmjgQ8gwHwYDVR0j\nBBgwFoAUkS/NwyQpgNO2EsHQLZzuBWjcDd4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCdTPBuW8PA\njfqmUcSqQ2Huusz/pj0LzAcIDyg1+o79fgIgeJ0uxmcNpYNJGuw4Rxzg1wfVmWVA\nCLhoYJ2zh/TDGPU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAREC0gY6h6so6rxswZv3c3WQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmRmOGNlNi01NzFkLTQ1MjEtOTcyYy03NGQ5NWQ1MGFiN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkmAcDKuvZa/cYgjUYgE66fewzu+LCowl9OTg7SyC6KlaJ\nG4miS+z6nAkB9NgMNO7aLRM7zquukXBLMv3fyjhwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkS/NwyQpgNO2EsHQLZzuBWjc\nDd4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKaCz39TKV3evcu71wXC7OS7G39Sm2Yi/yr6zQnARA8DAiAkhFGJgY+b\nuVH6A9g9nWot3q/PUtw972p9/3MwC7er9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAU+hqJVyIEL2kO+HQQcg7KDNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGRkYTllZDktZTliNi00NGMxLTllYmQtMTY5Y2Q4YzI0NjA3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGE3Yjk1MzgtNzU0YS00MzdjLWJlNDMtZWZlODg4NTA4\nNDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDNsiV5+Xsq4AVye4GHxGYKuR\n/8cOeVLQOuWDEoTBgzng6aIAih1RHx/F99elkdL1ge4JG5Z5CnwnicfHVn5jeaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/7eppgtq0i/PSgpefflRFmjgQ8gwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMPCz59Lu4Ubrl+6\n4GXigfDFdGyovFe1n74wNGy54qdQAiAo3nVZp0Ca5vwCQd0X79K6UtbShpU/nqWy\nJKhV9urQIw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc280", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `280` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAX5miF1b46QMFjRt+JAzNSrPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjMzFhYmRjLTQyZTktNDFiOC04ZmQ5LTg3NTg3N2Q4YTM0MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjU1N2FlMDItZmUw\nYS00OWY3LWE4MmMtZmQzNmQ4YTRkNmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOQjX8sCti3bOb92hBC28dzUcwR1yA3oVkZm7IOmdyHqeaKsmtDAWSp6BG5nK\nrMMSHZnPZzCR7di9xqo7yM/6M6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3/dUD+iCZKfuuV1eEQ+ilPfystowHwYDVR0j\nBBgwFoAUE+UpTWKdVtIeEjXtG6L9gD3/ukswKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAxbtGM9Qr\naTg9xUnnENNmehq05u5ByjB2Zf4IzM4KhrYCIG5OUSXU+x4i8cbMh+cW7+3XtESy\nDBBMSvW9qo3ltIlC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAauJj7AOguFu52thcz6xtZigMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzMxYWJkYy00MmU5LTQxYjgtOGZkOS04NzU4NzdkOGEzNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmI89Yyct60aVeX7LvSRhaT/+JR6j4sw+wmCqAOMCzskbh\n87jBd3NuFM8vpwufb6l6IIe3XoLQAlqh3U19Z/l1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE+UpTWKdVtIeEjXtG6L9gD3/\nukswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIF3C//mNhCS6q7imBGDDhjhE9i5vXd88UXfushj4W0EAiBgpzQmQNTt\nig0zskDsbBQuL5g/FjySR29bFIUCCIjYUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASWkJaaB6fdIdSn1rKH9OtdrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjU1N2FlMDItZmUwYS00OWY3LWE4MmMtZmQzNmQ4YTRkNmNlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTRhZWQ0YzktYWMyYi00ZTNiLThjN2QtNzc2ODQ5Mzk2\nYTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEStAn1Pr/K8X2GpeaZJAD0fQh\n7VRXbF14rP7xfgiTWkSPXjIKxc6mfOiKXx26+udF4Vg1ROLagHidLWOX3dQreaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3/dUD+iCZKfuuV1eEQ+ilPfystowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgM2hcGTof7xSqT8kV\nmbFg8LChHdU8pvgnN/JsBssWeFACIQC5awst+3o8GCmWsBfGhDMlkOFzc8g8AcVg\nIE4VFD2lvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc281", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `281` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAftrvBld6KQK7u+pJ4KzqEcXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2NTRhOGU1LWRiZTItNDg4Yy04ZGRmLTZkODZiNWQ1MWY4MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY4Y2Q5ZWItMTgy\nOC00ZGFhLThhOGYtZTE5NzhjNmFjZTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2Tn75d2gaOhL1Zs4sXLCRkoX8iz/sY+XKyG/CkDNAGYnIO8bO1EVoM30SiFC\n2uiFDNiybSTApU0c/lCqHv9tMaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8gbTcYSb8sk3GdOw9532gbfzT88wHwYDVR0j\nBBgwFoAUiJYMPd9IGenmqEUyynYqKZ8PPVgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiAFHzhmLx4iLsWjvw+pzuesV3JdlA5flqzkvk6XgzCdHQIhALu7lo4ICC75\nL8HV9hCjpfQy1GMQ0vceWdNiKhVb+2VV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWcktWnMfjNxAkgC29Wwj9ytMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjU0YThlNS1kYmUyLTQ4OGMtOGRkZi02ZDg2YjVkNTFmODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARw/fUOiRE43kJdH0u5M81khljdhLgNf7CQJ0f1alCfVsdi\n8SuopyL1GAD7OtrPZj4vpSUIxZ+Q2AmlHnbYG7zJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiJYMPd9IGenmqEUyynYqKZ8P\nPVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYfRyQ4/snjLhIkv8SRS+7NsMpahHjZ7hFNQruf3rN4YCIQDM21KWHlaA\nuxPCp9rU7P/Ca5y3tEUlw1aik6iDfKMWXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAdjKXFSELB0LFCKa15lj1jKRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY4Y2Q5ZWItMTgyOC00ZGFhLThhOGYtZTE5NzhjNmFjZTViMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzNhZjhjNGUtNGU0Zi00MTA5LWIxZTMtN2FlNWNlM2Zl\nMzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9zoGTjRIUDkI+kiNFC6Djea0\n1SpRogAyU/jmU26XvLECgou67lTElb9Lvz76hOMhuBk1q9Qa5v0esw1LmvtPtqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8gbTcYSb8sk3GdOw9532gbfzT88wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgDqbeqGIWPPRKVLzo\nBcBKmwO32E0EPePvZKpGi3GWrlsCIQD7jSfKJgBVRFg8fKQN8yLtj+d273da28n5\nmntRfyF8VA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc282", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `282` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAUpGNTl/clT4txQJhW/zO6UEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkMmYyOTdkLWMwZTYtNDgzYy1hYTkzLTViMjhlZDFkZWNiNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMyMGE1NzYtYjNm\nMi00NGNkLWJiOWQtZDAwMjNmM2VhYWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ0BzwSJCoGJflI7wXqYQ92Jp8NC0yAPJPDADGz2/+6/N8jXvPNb1AB7MV+EJ\nXqmX9S/NjYJv/0GbYPCdHKVumqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpXhThLMHNSGk+HaJ4dGal7jVvuEwHwYDVR0j\nBBgwFoAUw1GqWVVVgtSeiNZU2sYVYczfalMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBHXTnbhDQXDZpVK1pWS55mvNsN0krIkajrHvCLi4OwTAIhAJAfRBw+lXm4\n4JmlfDomBR3H1K1W8y5+N4zxo7UsR28O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASrJ4EiRY0sUUnEK36neLmCRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDJmMjk3ZC1jMGU2LTQ4M2MtYWE5My01YjI4ZWQxZGVjYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPPiJp9ELHglrgsuct40617FZzZ9jdaffU3VNI5zslfFNf\no0WY4IUjRzbqYwz3y9b6jQOQfcZRU0ZNaoJsIVTNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw1GqWVVVgtSeiNZU2sYVYczf\nalMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPPr02InrKhfbWF9rS26W35nkcEZUSXsTBVdazKo+vaoAiEA1Ifz2HXb\njuVNeP51gclZVwrkWGKQE/BSarz7dOkaS9U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAWqnTg8CNALZR8PwyRIT5eg7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMyMGE1NzYtYjNmMi00NGNkLWJiOWQtZDAwMjNmM2VhYWRiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjY2MzQ1N2QtNmJiYi00ZmRmLWE2MjQtYWM3MzY3YjFj\nZTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERFIOKJETz7s4PCsKGop+zUP5\nAlQbvOU1RkWfRibiKTojm7V8obLdK4zZ7sYEYnxYb2iBzxl7wDImSZQ+bgf886Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpXhThLMHNSGk+HaJ4dGal7jVvuEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPZw3459CfUKcNCZ\nfjXItErWm/TN9m48KryrNzTbboNNAiA8jmg/yu5GACoKKY4VSjaizDtJolibjmxL\naqB+AD86ZA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc283", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `283` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAe0XVyzJjWvw56HKcqKpbt39MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxZTUzY2I4LTg0OWEtNDRhZS1iNTJhLWRiNzdhYjZjNTc3MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRkY2Y4NDgtYmQ2\nMi00ZDYxLTg2YmItZjA4ODAxZDU1MzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUt2Pq+upYF18VxYLYgXqA1PkgfCmW5B/Ybp29RhDeiNsvJal+ymv2cO+lEDB\nhmDAUi5P5k+PtN24rw4D4LXq66OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+NKOxXfs2a11Ejk7wLVi80P4NNAwHwYDVR0j\nBBgwFoAUS+wg+Hin+j5W0N83LpNBZ8ksHrIwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\ntYY+VmJPHR+ucx2Et/OFmeyCafbV2HEq2ubqZPONLOACIQD/kJNqn4z++tMKMoia\nYbeyUDofrLgLJuVd+ek8Kv113g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaE2CUze4lgQe1cnct3mK+peMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWU1M2NiOC04NDlhLTQ0YWUtYjUyYS1kYjc3YWI2YzU3NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlKnb2W5R/VUnCBxg5hIkvY8s3LYAqAfNGDOZcIeGZYmES\nSOD0TGWgN47S4TzlX5GSfuODkl1kpASHgZlxFa+Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS+wg+Hin+j5W0N83LpNBZ8ks\nHrIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKWnIBOao2eXQaMql6OfGYSz4xjzfNpH58y+ihHFAunOAiEA2jrvEED6\njqG1Jb5KcTF5Xh6fgm4pANepoKVOR+4oa6w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASrz17Ykm8UuWYIaVcsc7BfSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRkY2Y4NDgtYmQ2Mi00ZDYxLTg2YmItZjA4ODAxZDU1MzU0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjA5OGU3YzUtNDU3Ny00YmY0LWEzNDgtZTFkNzRiNmZm\nNWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsalUS1OOK1kWd21RqGm5YKya\nRTykGlqJAPdzpuIARr7nNJ95wIHiNsYNdeZXhKsLhjEz9dHf+oZyzb+fte4jX6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+NKOxXfs2a11Ejk7wLVi80P4NNAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgJPz06Sjic7syUFht\nLSDKCpXEL8IDacdgmbfc2AzeX34CIQCC/goqhsJ802qxC9xNuYWlRzm8qgxzXUzL\ndDfIpfuDlg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc284", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `284` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAW2F9jEDOcADG4UMNPeO58QTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3MTc0Nzc1LTU5YWEtNDA5ZS1hOGRkLTU5YTFmOTI0OGE3ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2YwY2Q5NzAtYTA5\nMy00ZWI4LTkzMTItOWQxZmFmZmNkYjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbO5YvNN4PR8wLnUrk0TEW37x5Szhr5FtBJi8RL3NhkqID6xtJy4+YyFmj0/M\nEmI2g6mqPtMKvc1+7dp4eQyczqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS2xlKI3Ou9rPiajjF2KKIw+vOMIwHwYDVR0j\nBBgwFoAU85Y7rMLsXD9IBjFWdaq8RH6tr+YwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAmEuItMy9/dguSIqHM3OqiYd0mYFVC5o0hfvv+SVO3xoCIGaj\nn3i4FuXPF5we4iznY2GUAiiAC5yRCZc1Az/SoXPs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYtjstsfsmBpXVAlIJEcjzcDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzE3NDc3NS01OWFhLTQwOWUtYThkZC01OWExZjkyNDhhN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzdvqMexvkfTaI0N0yr3oCLKHBUXZxrvnQLrWiJ40W/+FB\nmStqnGMlZyAQTJAfO3/cfX8ye/ctVSKUiKB9eGsEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU85Y7rMLsXD9IBjFWdaq8RH6t\nr+YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI3DzwybQU1wDbtOgw2UVpiX0c9wAfXwK8T/JL9igVswAiEA2JffJIot\nczL0TxUHbaxYv9W+ovsdOZFXbIQ8cxnid1o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAa2mJa3rzcvxP2N8mmLIQbW8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2YwY2Q5NzAtYTA5My00ZWI4LTkzMTItOWQxZmFmZmNkYjI2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjIzYTczMjktZjJjZS00MWMwLThjYmMtZjg2Y2RjOWM4\nYzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUAO3y6hNPHTqN4m5gHBeU7In\nd4yWhyb8N8fa1K/iimZYFrVq7h+OSvhErqRYWzzFazqZsHrN1ILrOLm3LDi1oKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUS2xlKI3Ou9rPiajjF2KKIw+vOMIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgMlQ0nZRmg1jFXt7t\nXUYlf1nxP3KPxuHrdBCaDBlKecMCIQDbz4WY6FAYb0PfC9bHpGCitcWo16WMtHeN\n9JdV+VJ7+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc285", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `285` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAbGj5tzkqpOFzG756G56pPpeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3NzZmNmQ1LWQwMWMtNDljZi1hNjI0LTg1OTI5MDU2MjYwYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg1ZThiMmUtZjgw\nZi00ZmEwLThlZTgtMWYxYjA5YWI1MGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQn/zK62KrLFhBijsNbS/cFPkbK5EpQ2Tjw4SMJ2wqkjSXPCO2vZWWHbBlwae\nrgKyvC/IGSUZbqXRn2/5H1Qme6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7BjfSMEZeVoPmjVJrYzC25kmxGQwHwYDVR0j\nBBgwFoAU7gxhKCBZ1AIpDbeBjmK/ZUK/vDYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA/qw0wyNIrdjZ2k5HHfrPcD4Se8dWycgxYjEq7nar9R8CIQCm\nnFe1x9rUb6qZV33u3wchsUtI65UuSS6/RL1Fv36pEg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU+VmzGOxeyR9n31prrpxUMUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzc2ZjZkNS1kMDFjLTQ5Y2YtYTYyNC04NTkyOTA1NjI2MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ09LEaQh7uLmUjM4+ZvQ63RY1UdJHPf8ilZ+Fcwt4lF68p\nI6ZQhI3SENTXOC3UOjWqgCp+AvOfozQJUgmxTUNao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7gxhKCBZ1AIpDbeBjmK/ZUK/\nvDYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANguSIP1eKjYG4nD//gXV+UjkLBclR+UsH/JCvE4cbqFAiEAjeRVU7CJ\nbAoDcvsQvYNuNbYMphW89P0jXTkqrEOqJpI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAdjNBUe+UWu+sd/RIQ/D6LKxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg1ZThiMmUtZjgwZi00ZmEwLThlZTgtMWYxYjA5YWI1MGIwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQwYjUyZWQtY2MwOC00NWQyLWFhNGEtNDU5MmFmOTI2\nMmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUaG5mRpBzxd9SmWi8JBP/DzA\nEVEUhi4GXRBVVX5BNm0EhpZIo5CczXpJdWrSOXgHpy/qcrkbpuCGBDIJBOY+hqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7BjfSMEZeVoPmjVJrYzC25kmxGQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgUrPG4XW569xiqn4u\nk+3dUj7Q1TS+Wn8JDhiDtWGWfgECIE9LdLo54ss7XYrLYWWScClZAqr3HFut8B7I\n0HKLhY5H\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc286", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `286` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAcvmVV5VXTj9EbWNYLuTHLiTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyOTgxOWNiLTk2YWEtNDg4MS05NjcyLTNkYWJmODQ3ZDEzYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDZhNzQxM2YtMDBj\nNC00YTllLTljY2QtMjJkMzA2YTQyMDk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6t4U1pXgEjMZIrl09wLU3+xeNGMUsFLbIDuDje+YaHjf1ZRMg694KbFWy/w+\no6XHAtf6WwT2go52FdgQzSnxwKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoggSmolYUu6i8rUdILmL7HrahqAwHwYDVR0j\nBBgwFoAU2TIr/2EY/G7vENtri7pV1I31jgkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA4dfhQUMvm/LW\nVhwSCKh4Gdz5IgAr38RkHNJpaXVEl/0CIQCiN0d7R+yOfHvr32EZOB+Z6c7SWN+v\npKaSeQSh81LpZw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVXxAp8jZ3dSOZGTzUtX7FmDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjk4MTljYi05NmFhLTQ4ODEtOTY3Mi0zZGFiZjg0N2QxM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbT3eDd8wKe4vps6Qd6R8+a4oI/GS8Zewbx7V58k0I5NNP\nno9yUAZ5V0BVRZesnBdjJHCYtMdoGHIZcpW0HxFFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2TIr/2EY/G7vENtri7pV1I31\njgkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFyNGZBjoSpD6vRGLXnOUjFah0vO+MWGpHi0cqbPbJOYCIHZXLuJ3EXM0\nbAEVXA70w1FTxm5uPf2zKe+8mYToY82A\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAbaK93iKwdIDKVQuO43LVsv9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDZhNzQxM2YtMDBjNC00YTllLTljY2QtMjJkMzA2YTQyMDk2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmI2Mjc2N2EtMTY3Yi00Y2Q4LTg5MTktZjY4YTcwYTdl\nNDE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEycGu+TCPf8vTSWKOoPRqRX7F\nIC3hhgGX6BRUUgWqaf5RQWOKF92SNcHgQWwbHDBB9HlZwxqO37V+L6r82jhAQqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoggSmolYUu6i8rUdILmL7HrahqAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgCghTcayNPWtaK94w\nEF+Avp7c/gyuUcd0hl+4asQ4+6wCIH0m/pH9HD/lwoagGllYGz1cGvPYFWm/n65k\nwmDQvw2t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc287", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `287` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXQo4uZGmlVTNtzMR1FXOzjEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkYzU4MTlmLTNiMWEtNDVkMi1iOThhLTU4ZWVmOWRhZjNmYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU0ZDBiNWMtNzdj\nMC00MjA0LWJjZDgtOWY4ZWU1OGU1ZDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU+ydSqEOf2M11ZQvbX37fflH3uCcyfV4Mjh3PRo1AGvODh6smMpVAxNB1z5P\n1PUuSrFMIGy6k0mATuS6Irb8W6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcJL9xFi6YA/nyuRH4kIKTHb283IwHwYDVR0j\nBBgwFoAUgIWPe8j+9yJeON1oFCjcmgfMMx0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDWqUNdqWjjH6q3WjhdWO1gIASYZA7gspWrRFyhjJKvVwIhAOO9r2S0kXNO\nm8uPOVBd2dkNz5bd0ztnul4K4JyuZY7n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX6Rte+fGJFPGT5z8TNdEzzWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGM1ODE5Zi0zYjFhLTQ1ZDItYjk4YS01OGVlZjlkYWYzZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5lLUFMI/PsSFTHjkP3yst2oHayK/kSeNjiw8hjxStqco2\nY3bATd8owiUnh+atZcjC4hvE/VkvjH4I1497RNhoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgIWPe8j+9yJeON1oFCjcmgfM\nMx0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBnq2u20YY7v/iY0CGSWZ0jJc/eCHjmqpCI/QLDxYUhICIEh8KvWxTzhw\nynXNM9Hk0ayLkNRTh4wCGpEgXzbxhDeo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAbjESbxzRPT7BAgkBSr+EFGIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU0ZDBiNWMtNzdjMC00MjA0LWJjZDgtOWY4ZWU1OGU1ZDRiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2QxMzZkMjQtNDhmNS00M2Y1LTlkNWItZGZjZTk1OGRl\nMGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoNIbOlyQPAaEASbZ2PgOXkaG\n+LglOFwzz08OkX6d7r2VOCmX1ylpv/aPQ9HbcV7TVIUrDiGC9dueECAIIzvbtKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcJL9xFi6YA/nyuRH4kIKTHb283IwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAN4dGnd6bghZFni3\ncsRZXUylBpjL/IpA61NIiA7HlnkVAiEA3vuS1FRWSycIannCMZ0x6UsdYZqi3ULl\nQ5+XQoAlaPM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc288", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `288` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAa/K1hICHQfaPa6koH5YvLfSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNjQ1MTY0LWUyYWQtNGZjNS05Y2U4LWJhZWVlM2U4ZmZiZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc5ZTJlZGMtNjI4\nNS00MTg5LTgzODgtM2E5OTQwNDU5YzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExj/Ztpk1k/HgFtfakTFaly8jjA55aehAVeo6RjA/0DLnlGWjDz47QsvzEUNl\nm0MefJp0eMxYTqdoEc4zS8EOVaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTptEd5SZw5QbnslY5As7hQUdDawwHwYDVR0j\nBBgwFoAUG2iyfC5K956jOUub1IWW5b50nk8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDE6ysAAr5AqDCL2QlsNGwZNgAGeAqidgWgLqyurQpbSAIhAO76kmqQa4H7\nq60uyXfApda/TYDS6TUbqwHHEN9Pdz/P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeVx5C3PqSfHw3sHM6gzRFdEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTY0NTE2NC1lMmFkLTRmYzUtOWNlOC1iYWVlZTNlOGZmYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4oHs3Qu/49SjheQrMwS+pfHYj121Nbc0+quimn3Mqgiv6\nuluKYKv53Rr+1tkBdT8pzw/LWrqDmcIG6XsjDU4ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG2iyfC5K956jOUub1IWW5b50\nnk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDr/f5q/58/Cjj6IfDTH1/cHGgFzMIaIBzr6eTmuczyQCIGGAADCvil0t\nl3AS+4EbY6OVQ7QoR6zHVs6jOrzwaaBf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAeVp9/ki0de+fsZXDCj6b0wRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc5ZTJlZGMtNjI4NS00MTg5LTgzODgtM2E5OTQwNDU5YzAxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDcyZGZhMWMtZDc3OS00YzI1LWEzZmUtZmJkYzZmODhi\nMjVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnm5vKTutmJ0jHjcby0pKjQBh\nxBb6g7opXW3o9w2GqJ8LZaR+jtmDzUvxfGcdkGfJ95oeSe7koEaRFeK3ahETSqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTptEd5SZw5QbnslY5As7hQUdDawwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgJVoRPxIV8bXLIlhq\naUO1Ju7uc77GXwcC43CqcclS9tUCIQCP1zdSJLdwBcIoZnUSy0/1F1bLVIZgDDtA\nyA3AF/EmHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc289", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `289` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAWjeEDxh4Lu7At2n2AWIo+74MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMWQ0ZjAxLTgxMWYtNDJmOS1hODEwLWUzODlhYTBiZjU2MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMzYTZkMDYtMDg5\nMi00ZDIyLTk1MmEtNDgwZDc3OGQxOWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgAsiIHDs7VCaanSA9fHdya17PHQddzivRqWwYx9bS+zrj32yWmmYr1BZuwG4\nkZIVeunF/DSvBu8NIftnvghBkaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOZFhTAHpv/VkNpJdFcRspIuCcTgwHwYDVR0j\nBBgwFoAUn9LTVbUAMor8oDsomhPY+A3wKygwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBul9GIV5qfTCPMRKUDOHtYhBcV/vFICN8JI+q3mbrgYAIgWcCk0kjZFqMD\nzJ4WfVyPYOoL3hO4AGxchtu2D+vLIEo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWuQyR7yIr7+5tL2G8BMYUzwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzFkNGYwMS04MTFmLTQyZjktYTgxMC1lMzg5YWEwYmY1NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRp+u/OSXyvtjlpjgq2wLDnDU+SyRSDUVy93epVQ3I8Ce3\nooTq/K6+AcMsc47dm4KOgMZBDZUy8ptPjSeFXCGDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn9LTVbUAMor8oDsomhPY+A3w\nKygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIVtWcD6JCYNNyxQ0OMzXgM3gWm+tQIEvbP0qVLTqgnQAiEAz/PsuaHk\nfpY9tbLTzfpGlKDGLbNzB8cSvBSDn0FohN4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAQq/XKTO+GoPMFKuM1jZhJdHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMzYTZkMDYtMDg5Mi00ZDIyLTk1MmEtNDgwZDc3OGQxOWVlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTNlNWM3ZTItNzYwNC00M2RjLWJjYmYtYjQ2NjU4NDQy\nMjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMV7q+OnS+oU+UMt4xg+oXc7w\nd1MoupQB5YEvmuVo27JR3nhhVRfz61zuSu2OHghIDHkJUakIRbBY7Xhgv3w8B6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOZFhTAHpv/VkNpJdFcRspIuCcTgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgL+XpSlvvqNYPApYq\nzlc3HcfgTl/7IeuvgwGQJMPlM2cCIG49TR3G7Yg+iESuC5s9j/MslCLi3ycCvs0x\nRPhCQ9uj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc290", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `290` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAThO7LTHP/VtZKrVrfFUUYpsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NDMzMTRhLWY2MTQtNDJmMi1iNDIzLTBmYWI5Y2EzNzEzNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJjMDkzMDktYmY3\nZC00NzFmLThjYzYtOTE5M2I5YzFmMzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER9W2EQ7yQtp5SLYM2YzGIeclxEwH4Mma3EhFiAE5Kr0vGlFEyybZXiimhSkO\nKfM9vTqIVomWFhLFfK52ZEWR9aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXia5n4eD8QzF15FQx62NHn/oI+wwHwYDVR0j\nBBgwFoAUMj5GMLDxe8kW7borOhkf6SV7r+EwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEApAubefNfR3eYtEI76WUgRQa5XvMkn3ibblT9kYrm\nVH0CIDIEqPAkCyEqAoZ89RYuHpIAOFldzSMLUC5TnJ1hMekJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVskfV2fZv3cZGbzn4v2HB0AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDQzMzE0YS1mNjE0LTQyZjItYjQyMy0wZmFiOWNhMzcxMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScDmgdVjYe4YZw6rwIaYNM454HIO/K/ryyPdMwzOT6k24J\nyoSeNnUj+rwtY6MNFeLGaxPy8okDBz9TxVDaMIMYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMj5GMLDxe8kW7borOhkf6SV7\nr+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgItD3gu7MS2LMtj1rPdXukpiGygle76HjOYQosIoMCw4CIQDZVOL/4GeJ\niOFG1YtblDLGp9vZ9/4/2fblAqDgMVPIEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZJ+Yj+yszORDSQS1hNIsvoaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJjMDkzMDktYmY3ZC00NzFmLThjYzYtOTE5M2I5YzFmMzY2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzYyMTM0ODgtZjE4Yi00YTg4LWI2N2EtYzI3NGI1Mzhm\nODczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOfgyp3dqySaOQF38OWrB6mbe\n2Vg8T7RzOBKBZfngUccy4hLmd+QUWaBywrEyqX8S+6fVIFvgOvN1Yt7+J7hoY6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXia5n4eD8QzF15FQx62NHn/oI+wwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgE4n8enflK3Bc18cz\n0a3JMQ/0UawYqAvJ5yYfx+3KVBECIQDe9zyTtkJg6AgWXAqvXzfFzaaH7Ewhv0Q9\nu8GlYIGgqQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc291", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `291` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQLthbCAwvaZC2Hm07UubFnpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMTY5OTQ0LTA2Y2UtNDkyOS1iNTk4LTNmNDFmMWI0MTYyYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkzY2FmNTMtODUy\nOC00ZjMzLWIwNTUtOGFlMjEyYzkwNjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx2b2U5fe2SHWDoK2lvdxYvX23M/iG+AgfGjGlv2ZfAxneiURrLHBadnpzPTg\nbqis3y2rPd1zFIx0REf5zAL+yKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJVu2DRotkXa9PMncp7mo3BUcWx0wHwYDVR0j\nBBgwFoAUOFbm8GckSpmp8T386nvxnMbaiNUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAkhdroGqiTPiEybqrYexyHBnAy6vhN61TkITveAGJ\n4LgCIH74vG+OpBQ4hqfrB8MvuTLggEuCz9hLNlXLUfA4dozY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX7iIO7y3k5C5xW8FV+i65EXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjE2OTk0NC0wNmNlLTQ5MjktYjU5OC0zZjQxZjFiNDE2MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6p2SRjIiH3ZlZTZmyAGRzFirZMt2O7GeaODF+DV4PSMGc\nbHW2SI65eqUfwTPhxnilL6JljmuoW9BjlxYbdR5Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOFbm8GckSpmp8T386nvxnMba\niNUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALRC+8wV+jx4pEg3twWq4CG4yqLn92YVGwx5OAHA1dnEAiAjUymDPi1q\nWvwyHN7LHgmqwdnk42sKnTMe+SXzQiRsIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAXbZfnEpBExejRv4AfoefkQYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkzY2FmNTMtODUyOC00ZjMzLWIwNTUtOGFlMjEyYzkwNjUxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2ZkZDU2YWItOGRjMy00YTM3LTk1MTEtYzM1ODIwZjI3\nYjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjrZSvsvZdylpXKwJWM+669rK\ndUbFZTL6JHJAGlXq3W5hkPkaL8QVuXxn3knMx8QTm2CxpNKNtK+ij79QLvK9T6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJVu2DRotkXa9PMncp7mo3BUcWx0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgcMheZktjnh+3JXCn\nxS8HdR3LZnPWrEmckxaQ1VDcstUCIQCPWBhF6jMB3YC+WhJVHKNl6ujEpwLWdbzy\nKiKNo2MI9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc292", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `292` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAc2HwW4qs7YlB6pKo/+Vcz9tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzYzMzNWY0LWE2MDEtNDVlZi1iMjc2LTQwNTEyYTcxYzczZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRmNGJjMGItY2Jm\nYi00MzNmLWEwMTctNTE0MjNlY2NmNDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5zilelRjUj/anX3gnm+Nw9ZmbRGX3rPzDakAK0zKnsIPldK9zvLh0h97HdCC\nlebes4CCrdeoS434dSPYotLhuqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX/B6BEC3ea6mDgT4A3A2BdVG1RMwHwYDVR0j\nBBgwFoAUAtmfiycKvzbsJzHJgJ4jkOUtLPowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAuDvtfOJCj0xpAO5tkjDBy0FIAzET1TD33/frYgy/0tAIhAN25\nnwyNo9yKKJoYT5TXIFk7iLyHFi6SJ/fs9ZtMgK52\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ4o/d/1jJByGES6ImPxkCfNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nM2MzMzVmNC1hNjAxLTQ1ZWYtYjI3Ni00MDUxMmE3MWM3M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3lMrkz7gLAnXBzhFrjSgPFSAEGSEUaYbS0zqmh6yuNFQ9\nz2a72WUph7JTc3AnFZTg863ieeJxnvlWJjhSuUrUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAtmfiycKvzbsJzHJgJ4jkOUt\nLPowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHr40hL8SBgjbu3dYFg/r4w/u8IDazisZn3kW3lC7zi8CIAZsHtEAgQb9\nQLXLZU3xHRW+9Qj2DPsBfFs8N4Lg2m33\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAQ+w9PQamhpt5hBzkUzOyFWDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRmNGJjMGItY2JmYi00MzNmLWEwMTctNTE0MjNlY2NmNDE1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGQxOGUyNzktZTJkMC00YWUzLTk3MjMtNTZlYWUwZDll\nZDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEySfCkv1QEoUXQUMFVpzX1LpQ\nKSglK4L7m/Y3ii6yEgijMpNTE9NhYw3IK8A2eF3AM9v4Caq5E0kZDehBM3izEaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUX/B6BEC3ea6mDgT4A3A2BdVG1RMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALhTZLVY61/wPiFt\nQplweHmqxgqofDR8dA4BN6hfKOP2AiEA5dWWwS7KQun/AO9UxHZdH7pweZMMRa+X\nf1N5XUxSREs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc293", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `293` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdDPGP8XCiZk+bXQgaWIJ4O7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlZmJkZDI5LWU5OGYtNDVkYS04MGZkLTA3MmFmMTdjZTdkYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk4MjQ1MWYtZjE0\nMy00MGVjLWJkODEtZThjMmUwOGQ2ZDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE97KowN53PXoFq/bvaggXCC4tFI/Q1Wgo8/5ecrQcdhH0LmDnBQQZ6Ms0s7OJ\nah9VlEtAfqYbKbh5QC9E37l7IKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH7m4nNOjhJC01+lpUwHebil2lu0wHwYDVR0j\nBBgwFoAURE94QD2MTvj7uNB0GsR1zlWWJvMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA0VUFm/ymtyzxZdpQbsNsbpdj7l3J8hmk\nwdr9ufmljWoCICbYbkX8d767FdId1Og5HIaoSbCdKxf2U5OPhnuGGG6C\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXvFQJMRro3L7JS2nE3GdOR7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWZiZGQyOS1lOThmLTQ1ZGEtODBmZC0wNzJhZjE3Y2U3ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2Q/OEklBJBgjVADKiIrnFgTHf5Qg47dK9LLdRmgETX2Cr\ndeih2O3LSxYK10/mr2GI0UpjZ0W3TMs6QFvUapXSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURE94QD2MTvj7uNB0GsR1zlWW\nJvMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYy3dVXJxEvuUq1QT4vYnjWOMoRslHWikZ/Op1cEeAbkCIDfXJ/WVcyid\ng3E17jIVJ6HiNYe/AV0UP/azhfe3+oAy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAdsXcTv+ufS5Anyf//1mIuIsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk4MjQ1MWYtZjE0My00MGVjLWJkODEtZThjMmUwOGQ2ZDVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDAzOWQ2OTctZjNjZC00NzVkLTlkZDktZjllNzY3ZmY1\nZTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECQUn2H4qLjabFPMbjEmG/qO0\nzQkdnFAFCrK1OSwq121VSLu+2UaSoqFrI33WFtwydOrrTtKAv9fw8c8jdXcC2aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH7m4nNOjhJC01+lpUwHebil2lu0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgZXY7PpeJnPiHChW6\nWWQr3s6lrawjk1IcoNkQ9mJWvzgCIQDfcof66krpx8Q1b8Ezzrmzgb+U7uu8OMgn\nGWWzfRmdPw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc294", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `294` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbFthFf9UAOzeWs+IVlXJliTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNDM5MTBlLTM1MDAtNGQwYy1iZjgyLTdlMDcxM2E5NjcyMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVjODYzMDgtZGFk\nYy00MjQyLTkxZTMtMDE1NWJjMzNkYjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA3NuS/ePHUSDY5nfULOOaUsYO+/daEQbrYKm91nBNnRc7bmNQKxKiQaUAnL6\nNW7Ds2Zqspn9qEhPG958XTf9y6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeqVUXC3R7qOduIPWoAHhymiWWVAwHwYDVR0j\nBBgwFoAUhhxDL5dynPt+gLPfOPY2K+rxHUMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAMbPgYfAEHMjQCVjpqz+JRC1Xauhwu2BbC\nCfdw3fsWlwIhAMI6WMnXYzWK1QH+XIC3S90/1iCdDBP3xaZc6G6xcDK7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf/iG4NOeQeOKhYJ5vRlzvK/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzQzOTEwZS0zNTAwLTRkMGMtYmY4Mi03ZTA3MTNhOTY3MjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCLggOnBKtUPs5nA0ZveItRSm2SeVjbe62v6SJZzjk47fZ\nNaVIKZO1xzTr7ayrgYhEJkNwuUGjaVf08eXSkNvbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhhxDL5dynPt+gLPfOPY2K+rx\nHUMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPzi0VvAOFg/MXjPCWGqvhaancgTNqWpbF6uRcIVJEb+AiADgikgCoOZ\nGBQSytQeFVTGjQNkDtCXKn7DWW75ogBa2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAX+dq47/no8Li0xzeq9MY1LYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVjODYzMDgtZGFkYy00MjQyLTkxZTMtMDE1NWJjMzNkYjQ3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2QzMDA2ODMtOWQyNy00N2JiLTgzZWQtYTU5NDc3M2Q0\nNDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoieMTmDV89RnUNcjQj/ZqWKQ\nZofR7Q+4+YRiDUjd6JY/4nsYwu4FRA7VZjtaqqv7Z9eehOEVUvWKBYstIymNA6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeqVUXC3R7qOduIPWoAHhymiWWVAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKXrltHzCVT53iX2\n9RVMnW7DjdMe4wy0yBotWjSOL3RCAiAeSLXgOveljwzk/Ncfxxbp+4Mk4aFswS/w\nWsEcmj+w7w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc295", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `295` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAVxh7vbZGSzlexlh96uTAVT4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiNGUyYjI5LTc0NjQtNDkyOS1iYzg1LWJhNTBjZWFiM2MxYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI5ZGRhYzEtOWZj\nOS00ODc0LThlNTMtNmEwMmQ1ODdhYThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmmFnPEuC1ZmPWx7wGqjVmMglU311nZokDpDr4bYN+091QvF8ei2qQkRaZ7Mq\nKMg0jeuPO5r5/x+UGtsb4M6muKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeCoIQEt7vjiu7hwXyTTv5+ilG5owHwYDVR0j\nBBgwFoAUEiBDLjQipUdPrk/IVcL3h+wXFMswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBklPnJii8PhzY4\n64RREGLnET1kJzaUYpzhlLxAvrwIRAIhAIA/mYasQmnupfJZkJil5XtgVgjIBTGA\nnI951g5nXlqD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeRNAHZCXRRxb7mjDSuCoolNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjRlMmIyOS03NDY0LTQ5MjktYmM4NS1iYTUwY2VhYjNjMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNUL5SxaKt9vlJsolhHMMha2d0NGaCB3pkfP2y3BFa6h0u\nzksO2kyIX6q6l34yd5uPJExpMhRAs43M+KDCXnMpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEiBDLjQipUdPrk/IVcL3h+wX\nFMswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM5+J5G9G8CuwilVZfayD+bA8FOOuGq8XDhp6pmh0A72AiA9eL9OS8nB\nkfenzpwt4UGfzLxtLcpf/8mBuW+3cJ4AtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAf++EJSR4KZcuBB0GKtl16YOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI5ZGRhYzEtOWZjOS00ODc0LThlNTMtNmEwMmQ1ODdhYThhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmZmNzYxMDctYzNjOS00YTVlLWEwY2EtYzE2ODI1ZTFm\nNDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEACB3SuHiscWnzlt6m2Yudtuf\nlFJ2WFNrr91XUyI9sbWS6EVxSIp28z5ssFGYJ26glfB/LgoesWljjZxLoRv7t6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeCoIQEt7vjiu7hwXyTTv5+ilG5owGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgURLIqJA+4bZn2e9h\n38qq9hEgCjcsYLkdisLCAHtrl/cCIQCopZh7GrJxWozhhQlfNTDn8pFwz5vuFF1s\ng9FXgV99mw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc296", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `296` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdUkTyPHBLozNoFogtvEgUpcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjNDgyMmY5LWFhODAtNDM4Yy05MzJhLTM1OWI5YzE5N2I0MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjJiMmNmMmYtYzI3\nMi00YWNjLTlkYTEtZDc1YzEzNWNiMTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjCcXlpYwjP5grsJqcndQYNbZY7f6hH4fdCx0dWeFu+OavjmMgqnv+rG1DR21\nARSwxDil1oBsMuvlWEz6GReH16OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMOgRX+Bg0JFwj+Kk/nJURSQ1fAkwHwYDVR0j\nBBgwFoAUyXNGsIbbYoaQ+iChBTvBEZa32SkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC5U9mCXRfqF8JPPAmVSxhzPH2C5VMNv7354i3RbS/wrwIhAKVU6OL+63GK\n+eBqUCAqvlBaN+GrH3LOuEcbJL2OExgZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXBXHyuqm+qOPT5smGOa73FPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzQ4MjJmOS1hYTgwLTQzOGMtOTMyYS0zNTliOWMxOTdiNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDtyPKdeCCShsWfoZn2j5KxtWR26SbogqyjGZjKzFRwWXQ\ng+t3Ae2deR9+NHmUnySgYpXL1tola9Q4V8Pd6reQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyXNGsIbbYoaQ+iChBTvBEZa3\n2SkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbz+eAWG6FnJNVZgjDqkJwhGZkdt29s+dtA7zPRp6548CIQDri+v3OZB8\nU2CzJFaLV/kJsStBX/SPVwGPGJMDViPr9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZTB2bPXudV/pr6+vP4OlnV0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjJiMmNmMmYtYzI3Mi00YWNjLTlkYTEtZDc1YzEzNWNiMTIyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWVkNTM4M2YtMjk0My00ZTJmLWFhOTctMzYxYWRkZTRm\nOTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvsdok4UZN5I6eaHh36pfVChW\nBn8Qg2fVAc0q8sn26L4EVc/xiYr5hZjvwe18wuu1WhRc1ukst4ghUvlRgYBEYqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMOgRX+Bg0JFwj+Kk/nJURSQ1fAkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgezqprNSGqXYwUF4s\nNrFghfGTvOknTFrBHzWW9zHpfQECIQCVXTxz03fjVR+V/EQzVI1jD7MwCUWq+C7C\nf92Fbch5Xw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc297", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `297` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATF8xP8qnrndOVAtDxumaL1NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2MDJkYWQ0LTI5NWQtNGEwOC1iNmI2LWFiMWQ1NzMyYTZmMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAyNTI1MTctNDhl\nZC00ZjFhLWFiMjEtMjAxZjQ3ZDZkMDY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBT+rrHjeYcJDlIh8SpmDkVKbf1ltnBinYXF3sl/+4UaCAnyauNf0d4FjO5jw\nVis0mC+x0Me6S6A7udq0ixWPcaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7AMkz63bfAUTFa8uZt7pnUdDIwcwHwYDVR0j\nBBgwFoAUH4IVF2UmgBHIgpPG7pXivJSpeQcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHgdCj+q64JOer7iOR4pNBZviImiqpA6INxs8n6ETiStAiEAhcFK2UMTRg9c\n4PMTnwrpgthFdJnnrIl4ikT2qIf6afw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXEzw1UIeRuaIHkWKZHdXqG8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjAyZGFkNC0yOTVkLTRhMDgtYjZiNi1hYjFkNTczMmE2ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNJ4jJSCyDjmheEOaZskbL7vfK1Tu4NFLamAQXijy7tlLd\nkT8JmjUWYhQlHvizYS/OXnJAmc9hNTfTYT/k8dYoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH4IVF2UmgBHIgpPG7pXivJSp\neQcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANdFFwm+ABYsRebx5IrUhXEcQ+3dxcXeBMx5CrtECcLDAiEAjxoEEvRm\njsSwN0ucKP1Y1/w6F2GMpM7qE1ShGR3NLvo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAbzL8836/yEEp1EXixijcCheMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAyNTI1MTctNDhlZC00ZjFhLWFiMjEtMjAxZjQ3ZDZkMDY1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTZhMDVlYTYtODU2ZC00YjY4LTg1NTQtZDJhN2UyYzU1\nZmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZmp5kMUIgRQjc+bi3Ik3YcLz\nNtndOWkCLbiW15thn1TQMlkUC0CK03lHoRIu0n5h2CO/AAd1wuCfTpx0vKr7paNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7AMkz63bfAUTFa8uZt7pnUdDIwcwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAK/xJkopytP7ld7u\nVGcuvIdOA3W0eB89sECBZW4FsoaVAiEAj4zIQkdAhQzmifwnWsDJ+jvG9JEfvQU1\nx+DNuHjafc0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc298", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `298` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZ9m5sovGEpyQV1v4+RTC7hXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ZDFjMzBlLTA4MTktNDVjZS1hZTg0LWNmNmQzZDAyOWZhMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDU1ZDZlNTMtYmVm\nOS00OWVkLTkxNjYtZjJiMDQ1NDk2MzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOXJ+2CBdMnavM6op7QPlbAfIdjNHDnUxXeB4N2/0EV1N0DEOSzrxdaiOrzUM\n6H6XfTRgvp3BkaVPGFTV9dnQbqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOlLl9UP3hyWfoTjwON4Bu6r5imEwHwYDVR0j\nBBgwFoAU+sIgVhK00CUaIiTuKbsYmbFHEQkwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA0ugf+uodHxQYKy6sbX3MQNTvoBcKWjukVEw2ugqf0I8CIDlLa8eDLYNW\nO/Bcg3xYjoTeN6S5uiURrLtYACO+/e7F\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXZ1CiBGPCPWxUwDUM2ZzqwZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWQxYzMwZS0wODE5LTQ1Y2UtYWU4NC1jZjZkM2QwMjlmYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5hvaB34XJOm8L5Sg6LZawxUgfBeiochgVtOopjx8V+ft/\naOJ0bOeGauIvzx5/xHH0vOuZdh35sWJ40TCPGPU3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+sIgVhK00CUaIiTuKbsYmbFH\nEQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaotPaxDZIZuGbfeXjcpF4rb2fa4wYQsDAYDhTxDaHswCIQD4cQ1XcUDY\nCJd+7qU95zpBc0ma0bQ1gSKxJynCgUA0aw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAYUGg4lrSAzlS/4WtNSn7hnQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDU1ZDZlNTMtYmVmOS00OWVkLTkxNjYtZjJiMDQ1NDk2MzJjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGQ3NTFjMDQtZmU5NS00M2UyLThkMGYtZjE3NTI4YWQ4\nMWYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWQOH1AZwVmA2a3aPJ7cusgJ5\nZRXgjGXgLEZdwr08o/KRYplMNr/h080PIb1RuB4ZyPNcbvi5vyH7AdCaxJnzMKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOlLl9UP3hyWfoTjwON4Bu6r5imEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANyNvM+qc1pjR5iV\nQbhfX9Db1WHGyF62rzuLCQEHhiH2AiBdT6eZTwwxJNeJoTyhzR+YwJBlf0HZSzJq\nZ7c+dMjJDQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc299", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `299` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcX0GPeG/iN0QtlJMijOoozJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYjc5ZmFjLTE5YTEtNDM4Ni05MjEzLWQ5OTM5N2RhYTE3ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI4ZmIzZDAtMzEw\nZS00NGNmLWE5N2QtMGM5MWU4YThjMDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2N7W/XnBU/mVq+zuulb0uDvVqQ05U4FuOhIFx28PhyhrcjAqg5qGsVlySGG1\n/zbkp/8WJBll8AzrrKOJ8S9HzaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPWlvKAYbwOo6MeZyE2vszunWFbgwHwYDVR0j\nBBgwFoAU8er2l8WFspUdebvxqW7+PnHGapMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBEqHiMB6HAJkPz133YB6Z1dD3vyT/QZD9dkLXe88E3\nLAIhAMriuWVia20ScZbdEvQ+Q4/3OXULdxFlkM9IwsGvuO0w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc8oWwsxEfo5ix8vio1v4UtEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmI3OWZhYy0xOWExLTQzODYtOTIxMy1kOTkzOTdkYWExN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQo4E2SSNuCS1ruVt/UgIYf86vPK3viUxGFZs1VdzzOrsdP\neOfWyRBBmMUNo+D5dpUmQoMB6kFz3vmgOBKxOorlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8er2l8WFspUdebvxqW7+PnHG\napMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeZgxiTzsLvx3HirDsID8lJO4PBp5KDDznYB9NnbZ1KQCIEB9dkTIg2Rr\n6VF5ejosnWSTczimA0BoyJUCVXX9MPeo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZJ3PgUvmsTLB4ZiQy3pFbbUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI4ZmIzZDAtMzEwZS00NGNmLWE5N2QtMGM5MWU4YThjMDA5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGM0MzMzZjAtYmQwNy00ZDcyLWE0ZTUtZTkxMWY3NDIy\nOTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4Pi/wJhPBQQinaNBVjAEkuJ3\ntAmrgeQ/nxupbx0fkZFRbJ9tqWW1BE1JLFGCylDDPPeE0OOXiI3tIg2xDZdUGqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPWlvKAYbwOo6MeZyE2vszunWFbgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJ1+e6eTswmttAmC\ni6qYVATBykfQPMn9YdjluGygaPvSAiEAk+Lgq53GrYVNlODd9PL9WWjtr1p9TtqN\nRQcktxVxl8Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc300", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `300` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAf2FxzoZ0956rJJc7yfsSMCyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYTQ0MmRkLWQxZGYtNGZlNi1iNWRhLTg5MDdjOGIxMzBhZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBhNTMzZmQtY2Jm\nMi00ODY1LTg1YmYtNTM5NWY3MWEwMDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELMCiAtqcw+PA6Q+KcCWbjRewTG9BNKucTFOK22pxNb3sarUcQURmvZdiH/4+\noLpzBIVQ0tqG3Sfiy+UBxljMoKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdla2qD18E/dvYjE7zG85HGa2etAwHwYDVR0j\nBBgwFoAUSkeS56Gy1Za3Qybc/+W3lV/lmxUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBLvOCv76bZP58xYPHZJW6uhfaMMr9JensAAIp9Po1D\nUAIhAIMEAatwM6B4Z8qglwDs3FT2xGNFjnAcbAs+cOVKjert\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaPkf7nRbgiWVIU0WnAck9boMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2E0NDJkZC1kMWRmLTRmZTYtYjVkYS04OTA3YzhiMTMwYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASat4U+HRHlwVKUF3TPUHqkK7PWaajJNWtgwFUZwjVyOieu\nAHg8DxMDEMVmypQTaqXDF3pVigqwdsWUajRwBprco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSkeS56Gy1Za3Qybc/+W3lV/l\nmxUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK2lEwd5mEbrDUw46Zt/Jn9je2ez57fHy4IO5/lDxaweAiEAuLp04UNT\n8nsFkuuDu9HJGjqIJ+uK5LnOpMyUmplpoc0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISASDU5GH4edS5XfGixHUcirK8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBhNTMzZmQtY2JmMi00ODY1LTg1YmYtNTM5NWY3MWEwMDVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2NiYWRmMmYtZmI1ZS00OGY3LTgwYTItYTlmY2Y0Y2Rm\nOGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM21Lzc71FxNKkGPpRay7asud\nPxczcsj8AqSOzYrrlPhAE9R1G8Czb37e8Uv4xksAhRjvAiyN9x3js+EQEmeOHKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdla2qD18E/dvYjE7zG85HGa2etAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgQt8FcjFJxkS4/hgA\nwzZLDpweh+hBUDNbflwBwV0v69ICIAOs0q5ast01r/PEciNsoovYSxsCcXMURGmp\nt+OGNb89\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc301", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `301` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWWjv6tdF/+1UHdjKD6KXWWsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3ZDcwYjM2LWMzMDktNGRhYy1iYTQ5LWU5NTE3YTBiOWZiZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRlZmQ2NzktNjIz\nOS00MTE2LTgzOGQtMWI1MzIzOGE3MmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1FUuh5UV0zs8Z2WAnkavxzkhID4TXBqGBflJ0VgVXbPytXXpuuF+maWcbH9M\nZUWSn897E1mrGGP/AOhP8Mg0UaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSdI/U0hej8j5EypQaCTlq16eJ0IwHwYDVR0j\nBBgwFoAUDLSAXqhDh8JWN40Lq1EqhpoYZHgwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBIrktWtP73AVluUqp+xxSwN4LChGV5NwOic0osWLcrqwIhAJFJ\n25PbOUG5x7DaK6ZUYKVs8qb8RPzrVIi+6Am/htCR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY/7MWdf2k3e7/oRzWFE5H4NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2Q3MGIzNi1jMzA5LTRkYWMtYmE0OS1lOTUxN2EwYjlmYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASy2PcRcXTbAcz1dgQb2xb6UlnopVUa1Yjw1LmZ2wn1n9xp\nYtiY7E+/6+tGTjcVqMh6Dr7zyajXj4t+7p/BUlxRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDLSAXqhDh8JWN40Lq1EqhpoY\nZHgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKFJyM8tUXjUkse3Z0XRpQWwiK3gMOqcd376QWSJRXh3AiEAqkC8x+HN\nRD74LBafE0vPT/Mz5kxqwZ4P00ODzrvMeQg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAUCjP2VyXDnAxIFC+ZytYcY1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRlZmQ2NzktNjIzOS00MTE2LTgzOGQtMWI1MzIzOGE3MmM5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzBjNTQwY2ItNDU0Ny00YjEzLWJhZjAtMGI1YzRlZmM5\nN2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC/KSAVm+rUSi6ELCF4vEJnuH\ng+BjulV/2kAGG/Cklx75rxQTO4KTTj/z1euSvno0fFoRoyBnJ7yapHcPPG1JUaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSdI/U0hej8j5EypQaCTlq16eJ0IwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOTduZOVwMH3BOpQ\npLVZkbvWV+T0G/KY3ZuLfHv5iafQAiEAk4rtRyJkfpNYIkbBTxYstL3PweY+/GGL\nVRQuXmYjbno=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc302", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `302` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAeRcFSapcixiY6NbDkxCMt83MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlMjMyN2E0LWE0ZTctNGI1Ni05MTFjLWQyMzYyOGYwYTA3OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODliNDQzNzMtYmEw\nYi00NmY5LTkzMDQtMWZkOWE4NzlkODQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaH5U8n7q0vpZmIOSo8zbyjO9ICh0nlmehPXFlI/srgro41TD9atvtDTyTCMD\nD1dv+8smgdIqMqF8AW0alY10wqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp2r32aFzKbUYNB+LMV1URgvDXCowHwYDVR0j\nBBgwFoAUHR8m1qmJ2LAmoZ1bLHezaP/MME8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAkV7FzFqhahT7Du0hehgmYCX79BrANIfL\nwlX8nBTSWO8CIE/qIFf83K0LoSR4+mamqK8s0345vRLaeEyNlpkXMsBD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb5LxOzI4QlK5FVTCK4q44eYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTIzMjdhNC1hNGU3LTRiNTYtOTExYy1kMjM2MjhmMGEwNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+zi3icAJPGL3QX8XuMe22xuWhQCqG0clMNNwQxQk67JC7\nhKwb7ugs8k5YMsE0bETRo6QCElu0VqoqRvvI2WYLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHR8m1qmJ2LAmoZ1bLHezaP/M\nME8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMeYmDrgoLyjHfsQKq3pXG5cHyi4Zs4aZ0xnTSOZg8a8AiEA+whKj6bz\nzJ8rWxk8piEqk4ytWDHPidIP/+tsEOnQaX0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAffm4ySbjejSvBsL63xyenPVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODliNDQzNzMtYmEwYi00NmY5LTkzMDQtMWZkOWE4NzlkODQxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWRkZDI1ZmItZjQ3MC00YTllLWI3NGYtMzU0OTljOGQw\nODRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELkjrhdrVCgXb+lRQo/2zumYr\nDqqXoHS1VVr9+/BMgm19JlNbWhf374BhKtN+yedREOGypE3J9vr+AR9X7VJsQqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUp2r32aFzKbUYNB+LMV1URgvDXCowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgEZXrwGu0lM/yzec7\nLhai6mNXK54fXgO712wUC9w60gACIQDq4CJhyyiF/N34SIMjjLwJqKABrKkDLISz\nBU0eSN58+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc303", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `303` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAUsQmiKc+bk3nEUMMwhUtM20MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NGRmNTIwLWVkYjQtNGNlOS05NjE1LWMyMDJmZjg0YTIxNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI5NjdmODAtOTJl\nNC00NGRiLWEwZmYtYjQ0ODNhNjQ0YjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhLKlFNmTP1DYqbCMSZOVe3KFtIFnKv96oa80RPPYxZoejvd5cMKwArSB4hmm\ngoXzmD4SSM9PgUsvivawm1ZSZqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPRuaEWQHcaauphFoq9vY6bfHWUUwHwYDVR0j\nBBgwFoAUB+fBCCB99rynnvQtwgL6UKEzXkwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBO7E8V54VCz/NCRScCfZ7nONDOJ2yjvGih\nb5SPNY3xAgIhAM5JR+grx4xA9XIjfUlbmbdtSCw2twdB5Krw1PEeX015\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdaeXpjKMrdYpHnwWbneqoyPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTRkZjUyMC1lZGI0LTRjZTktOTYxNS1jMjAyZmY4NGEyMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqDIFnjnqSuWuJLomqCTDNyzOwAN9eb0VNf72ww6sdKS2Q\n3boaII10M4Ycl/vsr64zTcl1sGhAnNyAA0Tb3ElHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB+fBCCB99rynnvQtwgL6UKEz\nXkwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM6YV/ntFDPQLpZ4rq/zhcp3vbxLaldR4z9WO0PSMrm/AiBhdvZir7UL\nGccvIqOm4QULNUfRfVZSwGRHmPELnzCyhw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAcmvim6aEyRnkb5uf+jkDQB5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI5NjdmODAtOTJlNC00NGRiLWEwZmYtYjQ0ODNhNjQ0YjRiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmQ5OTcxZWItZWQ3YS00NjEwLThlZjktODE3ZjA3ZTQ0\nMWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9n7r3pLUvHXvWWoh+3LLe1UN\nC/Nl9Qhu3Q4HYKNG0WOMX4qa0MrdnhkZ48LuCEyTnAHKyalFRH02pcSokFlzbaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPRuaEWQHcaauphFoq9vY6bfHWUUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMNyQ5mFlM6cq74L\n4f/tKfdSTs6xxBr3ytPdwNRTXe8yAiEA1DeWZC1Ut9yvvyFDHBtmkRjvQOz8WcKC\nDDvod6qmXGo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc304", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `304` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAe24ID1oyiDCOzRgIPFLCvHSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlNWNlMjI5LTU2MzgtNDk0OC1iNzBjLWNkODY0ZjJmZmQ4MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYzNjUxM2MtMDNi\nNS00NzAyLThmMWItNmM1YWE2ODZlNGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8S64E7p7iLt1xQnjV6qeow3QSHxLrv4CHLcXtpvsznuFtotjfWVeWuIgjNyj\n2GXHLDnHPahWl/8UvaRLEH4yoKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCwj78WR/EV9i7ycid3+ZtOykyZkwHwYDVR0j\nBBgwFoAUPvaPCaZWwIZG+2a23/KgZsTl7iEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBvBNgEH5pqC9FPR4VD61mAFjjcf\nUFpHp1ud6bFdBqp1AiEAvgINcSufa3ngFnemj7yBYW87AXh2AdshsiTiqjPfrDo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQd7stR/C3jb03CW22QOsnsUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTVjZTIyOS01NjM4LTQ5NDgtYjcwYy1jZDg2NGYyZmZkODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYOEYxsSZqUDo0mtTU0TL+pnDhMTVBrt8Yi1m6fuaCCIXu\nH8qv3k3TMxC/VWVe4eDgwy/Qc9FkC+CkBVHewBnGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPvaPCaZWwIZG+2a23/KgZsTl\n7iEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRnVCQjBXSgF+hOvnnRjeT5JnaGqF2mhXkq6bAF62SjICIQCgdNQLPdPb\nVGQ4QAhkngdU9TktGGe1B4Dj1PbJXABzqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAQa002yFHj49mwgpkSmlAbkuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYzNjUxM2MtMDNiNS00NzAyLThmMWItNmM1YWE2ODZlNGQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjIwNjM2OTItNzNlYy00M2UwLWJkMjMtYWY4YzU1NmM2\nOTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6QRkcWfLf0XD9etxuwgTThL/\nG+pX1c/7ha2bLa1co4BZ0FoghcerVNrNKHAVQpp7xr4oGPpLVjKP+TdzPApXKaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCwj78WR/EV9i7ycid3+ZtOykyZkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgMvJ5yFBzbVGrTmKA\n9Rieumc3kQbBX1UGs48YE1MsCUMCIBRpn/RzuROxXzdNHpgnzVorAduToRuaCm7G\nVFKf0owC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc305", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `305` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAaLAjFNgNqRwa2tJ7bGaCxW2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhMTY5ZTcwLTNlZmItNDZlYy1hYTYwLTAxNjg3ODQ2NzBmNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODMyYjJlOWMtMmZl\nYS00M2UyLWIwMmQtODE1MWRkY2RkZGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL7p3DW00PBMg0xPPYVkmy881vgNUi5cMeiuhdX/1Rj/+O02WMoRpOZooXmOw\nWDSX14EoDEG1tVHhPVhmzmQdg6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTjYvDr35VUQEnUmh+XV42tUop0MwHwYDVR0j\nBBgwFoAUhMrZhxqq+lcyu49v7nr7fE7SwAQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIge0fP/W8J\nT+4tFQzkSQfDI8vpV9glQHbCCa6KSXxE92cCIQCW7E7lb1c25p2PxtuG74EuHiIf\nZoMnHUO69Svvz6TxoA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZWHLYNTPn0jWU6wyeA7xjxbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTE2OWU3MC0zZWZiLTQ2ZWMtYWE2MC0wMTY4Nzg0NjcwZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQT6JZz64nCd9yRrqirdv/ZAVfor43D02VcEOttP5AA//mT\niAR8jIztJGJwB3rhjqYCjTl4MJl7z30RNzcccNVPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhMrZhxqq+lcyu49v7nr7fE7S\nwAQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPUQSLksEv9gL2KViBvIVe8WWmJ3x2wwvurAWCPUABpRAiEAkOjv0eNk\njgVFcSqb1J+hybOxTnRvZLEg7rwKeOrXKP4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAbae3iy8KmtHbd/+fMOIoLT0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODMyYjJlOWMtMmZlYS00M2UyLWIwMmQtODE1MWRkY2RkZGRkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjMxNzRhN2UtN2I1NS00OGU5LWE0OGQtMWE0Yjk3YWE5\nNGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6736YQWbAMVWxayjFJ2Nq2BX\nexJSXBW/o8eT5RmkI30cLOXHouomlrJb3ZhyjqHKhVN6OtPH3y0j9nRrckr+q6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTjYvDr35VUQEnUmh+XV42tUop0MwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPvMbjoXmnd2dcPe\nuoEecjIr3VUVHjzPEWKj63Fnc9x1AiEAkh6Y306auteExqer+LFV6N0FpmP6EKCC\ng0xxQgO9IDQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc306", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `306` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISATI5o6xzVGQ1vlichhUV0PSRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwNDIzODE5LTQ0YWUtNDRlZS05NDMyLTAyNmEyY2RkZWU0ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY1OTI4NmItZjYw\nMC00OWEwLTliNGYtZjYzOTMyN2Y3ZTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp1T12zqGCdy0KlNypmGzd9XtaDpkRgv9TttZzF6BarNGHbEGqTXWxYL30rQ1\nhgEvz71G2SjV0fol/8L4aq6fKKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOCR4YRUxGc3z4C4hBhJ8nCUcnpIwHwYDVR0j\nBBgwFoAUZX4cP6LmTTLyZjq4kBOSqFtsJN0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAM7NLNWA\neZXU7PhEcmh5D1fS6FLMlXhD6o0NIR8QAd01AiBKPw9+CYtbrZ9XnwD542iNGyJ4\npesUfIlh8QEO6Ao89w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY8S39vpzy7FcDO75T8tpIguMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDQyMzgxOS00NGFlLTQ0ZWUtOTQzMi0wMjZhMmNkZGVlNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoKxdhL/9lSX21XChEIRLb9OKsi8FdVkhsE7mdCG/kDAH7\ndoP0DyVx4/VineUSqpeTAZNB9c3r+xmJ60TLcKLBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZX4cP6LmTTLyZjq4kBOSqFts\nJN0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPlC+bpn9woT6IdMUpYWHdAEhGz5THZHDUBuC1frE7hUCIFzkroSvphxu\nIwbXJERbCPMyml4cZqIZR1zW3Ug0m6oP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbr11npanTmnazF88D+KI/rHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY1OTI4NmItZjYwMC00OWEwLTliNGYtZjYzOTMyN2Y3ZTllMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDI5YTJmMjctZDRjNS00ZWI2LWI4YTktNzJjMmQ3MTA4\nMDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3P1zPHY63a6bMrYutVqAdFTP\nk8ztJdsrnBXRhM62P0pAgfm9pnBUkvYf4uNRxDwCdhtGJd+Ebu1a1z3zB14dyKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOCR4YRUxGc3z4C4hBhJ8nCUcnpIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMdY1NyRZujpGken\nuUmXNmPnhLNLME+y/JFcRRBKFpB7AiAwGWfL7yZlRrVs068jAZ1ceFV5HR/noRlI\n5VcFCuX95w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc307", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `307` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAbhMKEkAJIfV9ez5+zz+oL2AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxYmFmN2Q3LTVhYzMtNDEzYy05YmVmLWE4YmRjMDdlYmEwZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc1NDM0YWYtNjlk\nZi00NTcxLThiOWYtZGE5N2FhNDRlZjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW4zIm5cQDDI9Cu96a/wralr28Q7lw/lqDfZIMCItcWRNnTiUZNaK6ybc8GDw\nQoFlwGbEvWOEYWVWEgR4wdZLG6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIfTPmAGdHyr7JYj0OiB97FVbFDYwHwYDVR0j\nBBgwFoAUlvUx3KoxMR4iE1VqiETJWbJqIrowLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCD1PE7\nClwkK2VZ/aaA3hD0ghkqwqk1oLry3ktyoJz0xQIhAMCO4BJ5EYvbpAMi7RbuaF+c\nQsWPuFMvWUx6HUtQLM2t\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASt78GjGJrmQBdd0y6aJwR26MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWJhZjdkNy01YWMzLTQxM2MtOWJlZi1hOGJkYzA3ZWJhMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCk6X4l0ttlnLSDp1ydOzbxVnca2H0XWSqfUdpr4yb0lKS\nwFhROA05qCnetOMx8w4xrb7UHp7Wdj6KP1EmiAB3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlvUx3KoxMR4iE1VqiETJWbJq\nIrowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJXO1G1P9yTXOYLukiSSEqD6Q2e7J8ziujeHrlMiR/TfAiB5vrvX5VFe\nqTyLid3xh66SQc0JSNGYxANbwLeRzatmAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAceRAuISZajtm35nv6ewE+h2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc1NDM0YWYtNjlkZi00NTcxLThiOWYtZGE5N2FhNDRlZjMyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQxODYzMzktYTM1My00MzhhLTg5NTctNThjOTQwOWJj\nMmJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl80aZbs2XYUiuNoIcJsQKNmg\nqXeQwg2qMmgGaTCa1vcXsGI4uJCcYYJKuW9gpqL+2McXvZbALIqNX4g87VgusqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIfTPmAGdHyr7JYj0OiB97FVbFDYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKslpn+iSu0iBJ8R\ndKkcMFBnTIJklevbLZ4tyvG82vswAiB1LOS2R1r8790hu/tfN8TstSicEeUyLK5o\nhxgb6j6kDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc308", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `308` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAWekzwhFkYW08lFGMKzSH5GpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkNDAzMDYyLTJjOWUtNDViZi04M2EwLTBiYWRiZjJhOGM5MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg1NWI2ZGEtODI1\nNi00MTk1LTlkMmQtMDNkMGM5MjNmYzhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqwwAIny+rX0QyECPteqSfPT77XwOX3WlGSjJGa62mNKcw5ll3rH36xLtsj+B\nqrHuj1vWXXXeg0FwzZY9BV0hWqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbZ405bDruSSdEs1RFC5GYd5VLogwHwYDVR0j\nBBgwFoAUgIspcJA6rOQZ0UxbXinmyo1+k/kwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIBdVjrBRL9O4Io4WaUFAetH2v1sWiTUVHp2arwTCnD2jAiBuFd/TT1wB\noHnk6eNQOQiugfPLe0U3zrVRlKq9GhtHLA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdxkfMfNdmWNtpUhgFv1sKsfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDQwMzA2Mi0yYzllLTQ1YmYtODNhMC0wYmFkYmYyYThjOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWPt4K/1RMST1ULphkeWZ96y/HO5HFTUtl+aXiMimRB5Sb\njCX8po4wd8Aglm3ENDdVZqERWXtGr1uoY5hfzOFdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgIspcJA6rOQZ0UxbXinmyo1+\nk/kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJtxeSzGlbTFYv90CpsE0J2MgcSlcnWpaAyJH+efUE5eAiB/ug4A/1H9\nOaowVulmV1drebwagg2y+ZGicg2Q11fzFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAWvJj9nWmLEeBkVUHVn4UY+nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg1NWI2ZGEtODI1Ni00MTk1LTlkMmQtMDNkMGM5MjNmYzhhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGNlYWY2YzgtZGRiZC00MmM1LWI0MmEtNDlmMjVhM2Fi\nYjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZUc/rcrxeV7YoHEoi+4kz9RY\nA/R5A0ExCMcLoEGhpkGejVM2W2NSuC0pfYzLk4foODNb9PPuWI5WsLGWi/Qph6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbZ405bDruSSdEs1RFC5GYd5VLogwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgF7QDhhjkLSdZo/cb\nVgVWJCC2XD70xxHHruPvcNgJErICIGexn0DWpEtPd29Z7R6/giCDiuQ8uxTiwJfn\nDxljByRY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc309", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `309` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISASgLY4b5zF1PcG/HfH20k7X0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMjgyNjI0LTljNTQtNGNkZC1iOTQ5LTQ0MzFjMmQ0ZTNkMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE1NTQzMzktY2Q3\nZC00NDIxLTkwZmItYWU3YzljOGY4NTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+romxTto2FPZV668S9XEOOo7WTFpFBik1kFSY/9NDlVx3BMrkM1iovJuPhE7\nn+0Fmw3elqjemX1AFAeqKRlDVqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULV5i3+unPq+JbYcVdVel/tIKOfYwHwYDVR0j\nBBgwFoAU18z03ldEDfdEguuznvBpzFIcgiIwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIHqVE338itxZ4wHOsn2ghlwYxE1A/Abd0fhL55QOPtJKAiBzEeL8kDyR\n5AWs/JsOQtHtExpFXvg1rtNahDKcmCqDGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd2onL4GCFlDAl0+YKUDepQvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTI4MjYyNC05YzU0LTRjZGQtYjk0OS00NDMxYzJkNGUzZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATknLegS60ftyzLfx5J6zGqZi6NsIljzUB+fbDIzept6WdZ\nQRJd36w6M6ouk7ECrbGDOv58umE7qdXHgw6Oy59fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU18z03ldEDfdEguuznvBpzFIc\ngiIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLgOi2XwkzFh3XKAB6DXTmDUCPZ04x97IvqrTLk0jGnoCIQCjfPTbbCJB\njAFWTdk8alQgUSJvAX27Lu33j8v7qUwM7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAR5X5oP2Fx7xrvQe6c7xqh4fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE1NTQzMzktY2Q3ZC00NDIxLTkwZmItYWU3YzljOGY4NTEwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjNhNjgzZjgtMDgwOC00ZjUyLWI0MDQtYWYxZTJlN2Vi\nMDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZb00Q7SPuBRbgynH5Lf17ixh\nfMGsFpWHeFmr9GUSvdV/X6wuhNjW7ktY7P+OQiYAy8KnLDvnsXb3cPvrCZ724aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULV5i3+unPq+JbYcVdVel/tIKOfYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAP1M4dJEOgfitQVH\n7TSJ5MqfMLZ86NiDFmNshK/LnnNvAiAcRL5lF+iGrHfNxOEjo9+FHey263RzjNI/\nFs6HDT5lAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc310", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `310` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAWVPNrs1DPUq7TWle0XZEoiUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NWUyMDM0LTU3NTgtNGQyNC04NGYxLTcwOTEwY2NkNmM4ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJiYTk3OTctMzFj\nNi00NGIwLWFmYmYtMTBkN2MwMmM4NWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEim4ro4LY7ZVrQTjRLsOy4jPVT41BG9CESoLyG4C76ONC/EhTkojeQuA6MqtP\nz5czEmgXfhoCbrgoZkpABsvW4qOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjjBFJ744m5BdNjWnyzR/eVxRqWwwHwYDVR0j\nBBgwFoAU80RYTntwi41vd9wRqG35yfhI1towMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIDaVpXG9YdSrOW4ChI2F6S8CieLsM9WeOgqzZKMswiQXAiEA0qwotdGP1fV+I5HP\nA7svNWZfoc41WlAb4DYpp5wKWg8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVVx7iyfR/68JuIn8YLY5BguMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTVlMjAzNC01NzU4LTRkMjQtODRmMS03MDkxMGNjZDZjODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0ylpOGQwleL3i0vzV82eqNJdRgwt9muQ8KplInSzuhH+6\nmK075AfnURl50IRshZ+E4GJPD566pbNeCE/7LSZBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU80RYTntwi41vd9wRqG35yfhI\n1towHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE8JviKNH+Eu0bjKUTVo3FDEHykg+LttB3gkbujsHmdECIQDDpiGOI4WR\njQmYseA4jNM/YUjc8/bNBf52VXabEsb9mQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAacxw/KQn2aa2T0jKlZlGKQ/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJiYTk3OTctMzFjNi00NGIwLWFmYmYtMTBkN2MwMmM4NWI1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjJjMjA0ZGEtMTY4Zi00NTgwLWE4YjEtOTNkZDZjNzhi\nMGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6BIY/TUyFcpCLhRxz39gjosn\nXgltQrKlJpJheiRSn65ATo8J6QLhH1QqNX8RNNWDh7AFZ7C55fiJHUmpNFk9BKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjjBFJ744m5BdNjWnyzR/eVxRqWwwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKnHojYWwpEpMxIR\nLZD3+113VeVNcMXLeBZSo2yNavMhAiEAsvkojEnnpEVzQpTw2xCFcKaff5DHpWMP\nEbxkjrvk6Bc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc311", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `311` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAZp52Nk0CedwJeebhr7SNZ6OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5Y2Y2MDQzLWQyOGYtNDVkYy05MTVhLTZkMGExYzI0NmI3ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWNjNWFhYzctZTI2\nMC00NThjLTkwZTAtODQ5ODVhYTQyYmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3AhTDw4/xTAz2A5WQXEko9YIWiBGcjJxCovV6tkHzALpTdaKuTd/JwlVlpWv\n5J7YgjMPnKb2lRJZVB5KxIVpn6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ9uljOm9iapkUvlr6RJcd9VBDskwHwYDVR0j\nBBgwFoAUV+zm/T9gfBul9OHOssocjPdjj5QwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCMPgKpztoHwBMbCMkEV+kYvUbviCMjXmOSEmg/iiPhVQIh\nAI/EDEWcJVJUPAZoXyVICe3cyBz7ZIAtGUIXFKX/Q92H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATO0okC/LVfxd3PAkNWgMPLoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWNmNjA0My1kMjhmLTQ1ZGMtOTE1YS02ZDBhMWMyNDZiN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGXNVNldkAc4FPLGPYiT9Cmej3onvNXTLNbs7l38NKEFu/\nUI6i5VH16eiyKpp8noExFutLfqj0y8LiGWyq5W0Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV+zm/T9gfBul9OHOssocjPdj\nj5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK8/ZV2qws44QQ2L8pGXc7e5jmvXc5rsTPc7UyEQQcesAiEAzdMabiJ9\nIEkgc1o8zyv9MiG+rZcxRrDhovB9fqdRtIs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAVJh/WsQOOATiE0U/wAopVkfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWNjNWFhYzctZTI2MC00NThjLTkwZTAtODQ5ODVhYTQyYmY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTViY2FkYmEtNDZhNS00NTgzLWFkNDktZWMyNmZhNjQ3\nOTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyLE+50bs7/H998Oa5qKXMWCB\nKYE1UZtEuAmB1g6PAon0T/KdK7RXzX08sfTykjzkNDm1uwZLJJAweAYY0P8u96Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZ9uljOm9iapkUvlr6RJcd9VBDskwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgNV/GQH+9Fy2Q13Fm\nepln8jamShPp1E3xvCFI6jdOWIUCIA8UWHKkkgHv15oDHrK2M6SWszQsPq4P5ZXQ\nOHieZh5Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc312", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `312` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAQCoTWpAJ9QAjcNrSJytv+qfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3Mzk0YmQ3LTU3YmQtNDg1Yi04MzIxLTVjMTllYjQ4Y2Q5OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGZkMjNkYmYtOWVh\nNC00ZjllLThmZTUtOGIyYjQ3OTE1Zjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE35Cu25zTWzTcVKA1ACo/gxskngei8M739PIKGN7rqjNVo+jaZIOftGDpbK/W\nO2rMVjvVsU3DD+cZVbPhz8EExaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrQ6Yb2l41+eOF8UoHkVTHO8mLaEwHwYDVR0j\nBBgwFoAUU1dkTtnYp5FE81t4irJCN5tgwxIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDye6v45/4y8pZMBbfSLZ+ymC/w+HWv3okY0dD9sFCn8AIh\nAIMLQOlodDU5z0mYuAp7IJYFUNhLnKYSokl//XxSaHmr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZRJmqyerrSWs3B/Vr9tqtUQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzM5NGJkNy01N2JkLTQ4NWItODMyMS01YzE5ZWI0OGNkOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEzx4vL67ZRXeYLc623HDsT3q3nNhsYsTkt9PQ0EUESkP1\npJ3FUt4LiwgsYxdnxPddDK/cXvTEOhEQGMdTuCGfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU1dkTtnYp5FE81t4irJCN5tg\nwxIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKfhs8w6+aEYXt2OltOgz35B6nV4ShymhFrKT5QawX6KAiAYyQe4njly\nsJFMnnlqO5ZuW3I/WO7fCnVkBAZD7rAg9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAbebnzxx/GI6MJ/hMXvtUq/pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGZkMjNkYmYtOWVhNC00ZjllLThmZTUtOGIyYjQ3OTE1Zjg5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGMzN2MxNzctNjdjZS00YmJlLTllY2YtNmQyNmMxY2Nj\nY2I5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUg0Y/OLvsMvPa+GxHgVTgS8Z\nnSA+6BYsdGQlLTW3kk8Sv8vs8URyDA6rpF2Eh7tunCehEs+7udWQrixkVxOPH6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrQ6Yb2l41+eOF8UoHkVTHO8mLaEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAP4aP+iK8KSNS8gd\nnZci29aSNgPEI5TaJNG1JXFFLmtMAiEAyObpTUDpwCZxtpEawGME2GLxjkRBOnKG\nfph4MZ/MQ+g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc313", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `313` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXacUEdiZcl2m1QgHtVaVufOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxMDk2Y2E4LTkwNDYtNGQ0MS04ZGU4LWJkOTY5YWUzMjQ4MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYxYTMwMzctY2M3\nYS00ZTUzLWI1ODAtMWZiZjRiZDRkNmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaAu6vey9ByPva8IBdEEfZkKv5RFcV636FPgSR+pb3DYksII//dog0xSRlHES\nSz2oh4swyrUUBjEWZmHCYt+016OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsyc8YTLKt16Tst/7+1/Z2r0eOzYwHwYDVR0j\nBBgwFoAUijj8UcjAJSfOPFIGYWYRjpbExhgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDnjDWOu1Yq\nnhBlZcnEnVfsu2iqGhpbDd6IbfpyP6Iu4wIgaimYLPw+F12hwfMecUTSBd7QGV8E\nHsIJl0tRy4ibtMc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZNGswFHsM/nsEz+hxMQpQ2VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTA5NmNhOC05MDQ2LTRkNDEtOGRlOC1iZDk2OWFlMzI0ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRAHpuyx8lEVH8uOmp6g1n2G/QKmol6Bvi+wu1c2NBAQyY\nmxno8xHkizzvSc0KN3YWuPzkK0UFRC4WWHDZtJW5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUijj8UcjAJSfOPFIGYWYRjpbE\nxhgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJm+syRHHy50iaKarPT5a4M5xScKYnv8kamD7h0XXImMCIFZgFEeyP/zI\nVmQNeEPYVt9nnZD6gbm4QTIXuc7cdqMO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAfIXHbD1q1mZdBY19tLRq8/VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYxYTMwMzctY2M3YS00ZTUzLWI1ODAtMWZiZjRiZDRkNmY2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzczOWJjMjEtNTQwNC00MTI4LWI3ZTgtYmYxZjM5OTll\nM2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0HYCgdh82GixLihHiEQpB2ws\nAWx1UJs/4MWmOdoOFeOGMmiajGYhdw90siPXhEyTcQ71tzuBv8nypAZxoNuP6qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsyc8YTLKt16Tst/7+1/Z2r0eOzYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMO3E/Bqv4ARhByz\nv3Vr8lqxePS0Hiubzh+pH5bFmkLQAiAZPHKEd06UPbeGvdQo4V4yuXGJYFmOOrbW\nh4lMjxjp8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc314", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `314` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAUCn88z9kpAfCwxKycfEsP+OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzNDU5N2I2LTJlODAtNDNjOS04M2E5LTc2MjA5NTczM2ZmNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlmNDdiZTEtNjcw\nNS00NzliLThhZTctYTE5NDE3MjRjOTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Ntfxrylo+YJA0LtWyRZ09jESOHB/pn8ZhX05gAJSLcanOomBh7iPkT7E8NI\nFElaKgUI90F9TEMExPwMRfVr9KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU7XQYiN16INkTA/OMdVzGyOP9K8wHwYDVR0j\nBBgwFoAU6jlNtuAv0+z6uLgL4TTuT+pdEY4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAICOBfFrFI84uOuPg/Nq9hc+bJ95107oQiX0Pu3w1muiAiEA7q4a7j3l\nslmlUX8P+y1SzO+mIvCQgFLE/BSldlwxol0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASRQeMHqcY7pmvsqgRYVrkQsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzQ1OTdiNi0yZTgwLTQzYzktODNhOS03NjIwOTU3MzNmZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnQrTLEMNmS34bah8Nm6nzY6z6KneFMAblCzcnFVT1woHn\nEkJFW8eAivrRR5wF3YXLYXyMqG1XX5/NF/Wv1Djoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6jlNtuAv0+z6uLgL4TTuT+pd\nEY4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMdlRg56WPs5xtH6HmNoRo1yM9DVINtFNhswRVyaqT0kCIQDYcxzwlDq4\n0UOFgnFKJ+BcF/31Ch3mH5hbWrEhB3eQiw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAS5ccEX8A0bkFOssItqhTZlcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlmNDdiZTEtNjcwNS00NzliLThhZTctYTE5NDE3MjRjOTNhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ5MWVkZWItYzc0Mi00MjBhLTg2ZjYtMTZkYTM4MGM4\nMmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEf3rxYIMupQ5CVHoQqAjAi+Vy\nwHVx1BhRMSJ2rfIIYYyNgp2QIYmLrqlubEnWFQDXaQWuo3QNMNLWgEoLnSR4maNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU7XQYiN16INkTA/OMdVzGyOP9K8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMRTGdfKd8nsM5RE\nPxwZYAlIkyATWM8EhJLT9GsTmgj7AiEA97Ax60JvirhovuDuwKwU4aQ5nD940YeT\nYTn0Ffs1tF4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc315", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `315` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAac8kCP3e7T3zoRH84FT8qbFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYWY1MWYyLTIyMTktNDhhZC05YWU2LTE4YTljMDdhZmM5ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjExOWYxNjYtZGVj\nNy00ZDlkLWE3ZjUtNGVjYTJmZGE2ZGNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5YtTTbdKAK2DmIbHc8t/3ubxFZxGxze5ObhCgnB1v6jN+nOh64pKLI7aqYuJ\nEKkPbeotRa+kdBlCGdPSvs4gT6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD13mqMltqk5V5FnMDHvHluxWSPkwHwYDVR0j\nBBgwFoAU/OLyeCapWv4hxvJd6DXqTORR/qYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgTbQe/yZqn3jWCIYYGr9kuyC0vGxYx78LeRHtZNw/XWcCIGprLlyowtSU\nnK9xA6ETJGeOqBs9GALtwAvPddZiWCD9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWCRhIIuTfeuF2twG8X/aYt9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmFmNTFmMi0yMjE5LTQ4YWQtOWFlNi0xOGE5YzA3YWZjOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREJDf+quHb/IG06Sxs8eV7QE3RI7rF65SgCPKFw5YExLJy\nh7Ci4/mXyp0DgcQa0IIgvNABWZVAJSvoX5s203vBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/OLyeCapWv4hxvJd6DXqTORR\n/qYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO4njEfVM44AK6erZfywNB2LreweUXCNI1anu997kFigCIQDqOUrj1mqr\nWD+lYmYtLoiMuczMyW8gl+sgkdfjKuzC5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAWpbE62lO3pF9tNlqsaG/zNVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjExOWYxNjYtZGVjNy00ZDlkLWE3ZjUtNGVjYTJmZGE2ZGNlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmU1NDA0MWYtMTliZC00MzUwLWFhNjItNzIxMDJhZGUy\nZWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqB+e1iR06HeksBMCMEDZIiRh\nX5M/vYFE3I9Qs4ilKFO0TRlZLFRK1CeEa+KNRQxLPxVCqMpR1r+M/8IXTe20O6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUD13mqMltqk5V5FnMDHvHluxWSPkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgM0uaSfBDA9t1FCF1\n+sk9N3THV+AwxyoraA1GjS7tPDUCIGulUnGbNIBLWux36HBOjSaKONlFuZdk4lAS\nDyF4WUjQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc316", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `316` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAWOqV/XmfhttS+K20t9h5JlzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhZTkxNGNlLTZiZmItNDJhMC04NmFhLThlNThiYWZmYzUxNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJmN2Q5NzktNWEw\nNi00YmM4LWExYmMtMjJlMThjZDdhZjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjZ3ouH6XCSutgi/AbHwEUezq26lF3jhRR26umZKJN/Cl36IwWkww4ADKk5+v\nPjO1qcgJwGV5yYOF6r17QOvMXKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6YLpGCgDLCr7XdbUNot0CC1u3kgwHwYDVR0j\nBBgwFoAUXP38Z9l2fcBMoRM6fOFMMzR/c5IwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCL61SS8cMNpicRWiIXQ613A5aT1NF7LWFnmHdAcAIXbgIhAIsvXanP\nxLVxHuht1SEQrraxU8+yzkA+Rxf6d/+xXDHw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATMlkJed+jcDYgEFxyVTvibXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWU5MTRjZS02YmZiLTQyYTAtODZhYS04ZTU4YmFmZmM1MTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROap6zqWXoeENYm8WkHKmgOH6A6tOgKvK7DbS9Kzb8GWI2\nwFrEG7Gz/Hmu7hErufjv8De7oBZzO3Non7XKp4fho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXP38Z9l2fcBMoRM6fOFMMzR/\nc5IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLwe21US9ae4ozblKmklnGgZGJjdL0XRV8WMObssUOYUCICeNkvrgFBS2\nUUf4+J5gqPjFe4vv0Z1DRlvkQgYD2ugU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISARXJVZw7Qx6I1JbiX5gMYUjtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJmN2Q5NzktNWEwNi00YmM4LWExYmMtMjJlMThjZDdhZjhjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmFhNmJkZDUtNDY4MS00NmU2LTg4Y2MtZWFhMmNkZWQx\nYTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVvbvl4Bunc2S4Ms7R2RLpgfh\nJyIoUcAPcimtzLLVyShOyKXXvb4rqyPknmzphl9B6mLmbtviHmYplmfD2t0G46Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6YLpGCgDLCr7XdbUNot0CC1u3kgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgMXVJDWxUT6DembpV\nsxvAUivKcsrgjsHWrDZfM/0MG0oCIDTRibOTH8iScBt6haA3QQO3vlmK+VFEhr1Z\nz4sjYU6Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc317", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `317` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQDeb5RPr3k1nku8RA4nT4a9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiZGE4YjEwLTQwMjctNDljMy1hOTllLTlmNDRlMGE3NzVhNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc0ZTA0NzEtNzRj\nYi00MWU3LThmYTktYTAyZWQ2NjllNDRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5gteIbh7BNafKStH2P97x/m1evwZAuvIBD9uLr5ljClaBQgNLI/7HC58T0Or\neyT7sTN4NqVt4nlugGdBU/AYRKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtwU/9mwyddrR8oSwsthA4ps5N3swHwYDVR0j\nBBgwFoAUjH9f655FMRROj/thBh+sFNcPdTQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCICvfwroPV2++PTZ9SIqxojguCbWui8dIHjZ1Y8EM\nsuZQAiEAwlirtgQbIGWVZ2wkW2dGR20HCsK1qcxkauuIo1Tqeww=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdcasUNfJ9iXwqWXibqcAQKnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmRhOGIxMC00MDI3LTQ5YzMtYTk5ZS05ZjQ0ZTBhNzc1YTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQz7g1Xbvea2r79OCEwLnrSmHNybovsUu7+vXH8c6hasiK6\njuY+kkrPCK4xM3NApsKC2YfH/SajjEZVTb1lzH/1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjH9f655FMRROj/thBh+sFNcP\ndTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH4FtNNjAdyXmco54UElZnaO2k70Oq4j0+a1ybPnxHSgCIQCTzs2wK/ah\nEsLhs2dkhHJROZ/txejszqK0PtyL1WNUbg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAemJDselc49rGuCWf57mRgWjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc0ZTA0NzEtNzRjYi00MWU3LThmYTktYTAyZWQ2NjllNDRjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZjZTk1NzQtMTM3Ni00Y2E2LWJiZmItY2IzZjZmNmY5\nNmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHGoLkaomBz7+IqeSxCMhkie7\nSv+jXdwfXVx2H2TfljrJlgb6CaUg3A9m3auGzpYW0HgDAB5palG2rt2gxG1fyKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtwU/9mwyddrR8oSwsthA4ps5N3swGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMyErk025rbhCnXW\nsfTJ5ImSYMVZNFkzMvdeLte/5P7TAiADS/XGEp+baju1b9ZakBt1kuPcjXZC0DQU\nbpT1oNK3vg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc318", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `318` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAesCZSC+/qRIiGr8cWEdGaDOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZTkyYjliLTAwMzEtNDJhOS1iNzU2LWE3YjVjMmZhNGJhZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYzOTg1ZGQtNzA3\nNi00NTUxLWEyMWQtMzBhMWZlZmQ1OGU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsmmLce9CdiGVyw1qAdmEREj/R2fXs+TNOHbte8DurIbZwt7YAFrbiIjjpfLr\nMKf97rip9BNE8L2idZDe2AVabaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs8IILjYwk4JkLfLPAciNgj88dbowHwYDVR0j\nBBgwFoAUQS1r6Tyxl7EbLcQXflSEvj2w8ogwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD6H1kLBbfsdEJhqBxk0EFz5QoAqNQ8/GVnnEKE\nWzxXVgIgHv2kYS0r5kH0/7F8O9BrWY7tbXlx6xJhfE77OfHmZB8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbP/7qE6wlZElaT1Z2ZXNpOxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGU5MmI5Yi0wMDMxLTQyYTktYjc1Ni1hN2I1YzJmYTRiYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOSA6c+ON2TDHb4s4YlWlJzsXvqrJZq7QrXtMci1mmuMZW\nFsrootKG3pGzOm4dFtckW6axzR1xoHFxFNQKEu3jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQS1r6Tyxl7EbLcQXflSEvj2w\n8ogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANXDsY++rYrsaQqtiBXGBtoR38cLbTuisrLPkcuWqh2JAiBFqKURyek1\ni0Vrnf/Tj1mQDb6/R7Vc5gOtf9mzO5Lr7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASitxr3T8uevoQlEz3vkeTB2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYzOTg1ZGQtNzA3Ni00NTUxLWEyMWQtMzBhMWZlZmQ1OGU2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjZjMGFmNzItNmY1Zi00ZTg1LWEzYWEtZDBhZjJmNThl\nYzNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+AtqhZ6PvQpqw3QlR7Jd93ap\nZ++00K1okR3fo0o/8ch6N5WtEO78QvGEX9c059bnexasDyiMU4B3ySTY2bpafaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUs8IILjYwk4JkLfLPAciNgj88dbowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgY7LvBPzG5iV96kfH\n5h+l+i70uW+qUwJ4/wwzIy6MxokCIQCBigVrGX8KkQqVmRBE06D97RIWkPKepQu5\n2nDH3o4csw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc319", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `319` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAdBzn2mD452a7h7KOYl9/oMaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0ZTQ1ZTAzLTQ0NDgtNGU0NC04MDgwLTRiZjA3ODk0MjMxNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRiNDE5Y2UtYzc5\nNC00ZDk4LWE4YzItYmM1N2MwNjAxYTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUIM7NAXHhcZWAnEj6Yqha8ky8xQ9BoSi8LVZV49gBB4fiFLVq2Z9chK+P1nH\nEIbFL2LIN89fDGS0fG5zARaLXqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYnjoDNd11opSDYqcctFkZWuw2pAwHwYDVR0j\nBBgwFoAUvEXh/dyYC9kJmEsAKUTucbi/8qswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIB2UoUM++aQJQYl4fOJTtjWYfrInMgNEumpBRA4RVdyYAiBp\nhe9WLDZJuGJDGFACSr5gI+f1ItrXy8vuHup9dkY0Og==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZbtLw90WxuUYXmTRb9JqKeHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGU0NWUwMy00NDQ4LTRlNDQtODA4MC00YmYwNzg5NDIzMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPsi5lqGomJWp+KMDGXhxKYgjaeob+laegpAgr1YXgjOX+\naEZzHcG35b2BgITdXa2pSC8jex3lo4GJeLZfB3Ryo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvEXh/dyYC9kJmEsAKUTucbi/\n8qswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEimWc/JGqowFOsYn8LbeeYp0G0woLsy7aB6O+lVtmacCIQCXV71Q8dUI\ncJtLCHpC13I/mQkdgbgq1spfett+HAdWqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAU/MFArX2LItLOw5cwce4yAkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRiNDE5Y2UtYzc5NC00ZDk4LWE4YzItYmM1N2MwNjAxYTQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzM4YjBjYTAtZWFkYi00ZGRkLTk2OGUtNmIwMDkyZGU2\nMWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG9GvcZx9dGICC/jZMpYNW0Cw\n6pKNiMxGOeVs8okCPj9RN0w95g6J1lR2UZnsYZysOnVljIX3GT1SZoCtadXKJKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYnjoDNd11opSDYqcctFkZWuw2pAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOkRY9APfC4fBCja\nE79aUa6PMFdG/nkoTN9w5YVcaEJ4AiAUmqg78dBlpEhRupIaZvKvDn59DQ0dsy30\nq5bZ3EZaVw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc320", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `320` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAcqPDF6nDhg9jx4QrC5u05CuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNjNiMTFkLWNkM2MtNDJmMy04ZTc2LTI3ODIzNDExYzQwNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJiYTgwNDctOGEw\nMC00YTdmLWFhZGUtMzRlMjljNTM5YzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE12QvQZD4Pwr09iTU/xJ4b1jTxVD3YovYDU9WMn3rlW/zlRH/urGCb9sJnJn\nhS0PtGVZm6BK52zVXk2xKRxAcKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB/OeUGWOmHjb3uNLDE/t+8Ahy50wHwYDVR0j\nBBgwFoAUnWkCJAbv4D8A0GMAudH8AflGXFEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCiGtlgmPynOFZJHDE2wumvZtogJBco\ndSuJrKp588Q95AIhAOZqlG70PftlPIlYPtLjBS2z5VOSA5nKhkK3ovjsr3Qo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfpptr48oaZfog7dhOJUg2d9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzYzYjExZC1jZDNjLTQyZjMtOGU3Ni0yNzgyMzQxMWM0MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6yh9kegrenaQ6L+B5ZgLaP5kbqj6BZb90m3pR5jEdmZxN\n/uBHuT7L8mf/yckYxOOApbaR1TG/xRk7a1249bApo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnWkCJAbv4D8A0GMAudH8AflG\nXFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM+ZtaWCqWBBif4qtkpyR1uGglDUmlfD+4zH1fhaIQxmAiBevJVOtgLE\nxEVPOe6gdFmhoMwJDYY7fym6wyFHGuNEAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAY9+e+ydCRFVD06JyAyYSEMHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJiYTgwNDctOGEwMC00YTdmLWFhZGUtMzRlMjljNTM5YzVjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmQ3NWM4Y2QtNDZlNS00ZDQyLWEzNjctYzRlYTc2OTA0\nNGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOOkufeUbpKY1iHisjzxRxDja\nfEHuJ3REUwwnoXpirIKO9/upRwkAIAI/43I/iDmEltcKThoXezE8MN2b7LOeWKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUB/OeUGWOmHjb3uNLDE/t+8Ahy50wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIYNbsbIzK+6b6ps\nlT29yyD3/pjktjcBRLC3tIBDo9TxAiA9XO3/fAGV56KbVHOpw4go5ehefHEBK1Kb\n7Eaz+jAq2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc321", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `321` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAdbpBrJPerVJrLKpVXq5wgxhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2NWVkZmRkLTFmYTEtNDIxNC05MmMxLWFmNGI0MTFkYTk4ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg1OTJkZGMtMmE2\nOS00MzFiLThiNmYtNmY0OTJlZTEyMmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE81xJSi3Hi0RrdVLWBGIxELrFvdvQ0xs5dBP3xA/KwgXnN+1R536RfciJX5e1\nyU/re4ppaITyjBFMvAq64m4Gn6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNc2wc7wxPkszvldlzopax9g4QzMwHwYDVR0j\nBBgwFoAUNWPa3PmRzpmrN+/dEZqEFMOohzgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIHzfI/sLQfV9fRUDN8oKpEu8s2DHuUH6\nsIWUrzx4StrKAiABrjzoWLkV1XAJgaYdvcRVo80mzikPNo/8op8XlkemCw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX0Tz274tdFet5h0gFN9oCCVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjVlZGZkZC0xZmExLTQyMTQtOTJjMS1hZjRiNDExZGE5OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT41hVuiKVt0TLSR4W5q+QdmNY7yk6uONQilQ6zWTAMfFQw\n7nSCFi1i3E1SE+Tb4EMz8i0s0+6oZbXhuUTujfo6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNWPa3PmRzpmrN+/dEZqEFMOo\nhzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMMh3js7UbdAMORSGo8o6COOdVY2EOfAW4VluL85bbPkCIATZEESTH/hU\nhQ/ZyM80d/waqWDnFb+896cVEHabHf3T\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAfLuMWgNTbF40M4itBNPKApnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg1OTJkZGMtMmE2OS00MzFiLThiNmYtNmY0OTJlZTEyMmE0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTYwOTIzMGUtNmRkOC00ZWU2LWI1YTktMDE3NGY1OTlk\nNWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZjtSzURwy5Jgln6N2sSdGBn8\nnEhhFcU/h3Ok8cpXwK/ayyXotSI47gKAtoFfxlTwsHmYJDA/nwaKDSWnjpO06KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNc2wc7wxPkszvldlzopax9g4QzMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKDbPj5TuD2GOYFM\n763YUqLeqtlKPVWOcEIs3zsJCNIDAiEA7aozpNp00d97m0ny+rr/ZofVKByWExvO\nneNJmT1zz1Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc322", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `322` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdh+N4Urdz8HPkTW1hHa4WYEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmNTdhMmJlLTg0MTEtNDYwZC1iNDc5LTkwNGQ3ZmY3ZDgwYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjUxNDJlNGItODk3\nYy00MDIzLWI2ZGQtM2NhMDdkZWQyY2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh3PL2V7KkPGrx2YP195blrDCgZomwhgQo+aqiPq+Q1WFFPvCWr/AD2i0JL/K\ngC9qJqVvIVQ2zAUvW4WKi3syOqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxcmZqTDRcfyc5oFIVl8URDzSel8wHwYDVR0j\nBBgwFoAUk/4T/BP4DffxR3QDI3LqeYK5LZswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBb5TBTT9Yf/\n1us9B5eHoE1jk54uA4YHX91KtpwK+ng7AiEA8fO9TTULSBF4iRkPKGTuht6KcRVK\n+cmqpUqOTEVMXe4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQRRuufc/ZE1KZC0syCNpbUrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjU3YTJiZS04NDExLTQ2MGQtYjQ3OS05MDRkN2ZmN2Q4MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHUKE8UYByPaqEHzeflie61NQEgcuWZw91tqwBcNiwZnCz\nRbtTt70cgerc5XFvm3l5jpN0qs7Ah/izK65vRfpgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk/4T/BP4DffxR3QDI3LqeYK5\nLZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG1yspiMtU4crIoGDsIbopmFmDCTPi31JaOB9wEw5RdACIHlGUxr8cg0W\nEgGKBYoXA0yk4nc9dyOVeopHwtj1eERE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAdfb1Kcm6lUHPcojzkfl71qLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjUxNDJlNGItODk3Yy00MDIzLWI2ZGQtM2NhMDdkZWQyY2M1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTUwNWNiMDEtYTI3MS00ZTk5LWE1YmQtYjQ4NWM0NGQx\nYWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg9t5mW6WnzC3CSadcRGDdaPg\n1arhLCKxzr0nUSK8oqrlVKaqOmXY3b9DcTbXtBNR1cl0fhKdjbo+QfapNO6WCaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxcmZqTDRcfyc5oFIVl8URDzSel8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJEI7WjYhmxWWxJr\nJsXLE1bq0ZffbVUhje6mqCw4T1CQAiEApK/19HYRnMKAEhShfNvEa7IZYcFO7B7t\nRGYkRwirXM8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc323", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `323` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAa5kAIrSCHIIm0nvhebHYdUUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmNzJhZGQxLThkODMtNDhiMi04YjkxLWY1Y2UxOGRkN2Q1NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY5YTlhNjEtODVl\nMy00MTE0LWJhMGItOTZiMWUxMDkxYzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqErld746844Bh/HCbqx2vp801h8QjSQESz8wsvWzv4q8gT0khR3TqDPNnM7u\nkYQSfichzKt0VN2AJiVrse+VHKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEvTTZqWsGgi0RSja/kEfVTUP+/YwHwYDVR0j\nBBgwFoAUmrYUUlEGcPtnepiHWypU97l9yAEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgSjInmAb4twQ+DeCe2ry9kFJdFMYRB9pCJM2PGjCcPcwCIA6BVWwD43rZ\n1gFCyU0PlcdYN4d+d3uzsEdjQmnB9vZH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVDOdg9lmHqOF338YgG2E7blMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjcyYWRkMS04ZDgzLTQ4YjItOGI5MS1mNWNlMThkZDdkNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGnJ7jNmxC2BGI9It2hbIlYqVTEXrgpqtMQw8pcVqA6iHQ\n60lnbT0uf5ZOze2wKMYWVjfdpWN1aCFAXUutFTtko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmrYUUlEGcPtnepiHWypU97l9\nyAEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBBvS0LJ7WUAiX7Q3S46A9QPoIpF62pDeJpIrUPlu0tECIQDGLppHm4+G\npZaeXIswjx6uYu2sUyWOVSATnC/1GoBRgw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAWjP3NT7iu3xL+FbPrN+2LZJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY5YTlhNjEtODVlMy00MTE0LWJhMGItOTZiMWUxMDkxYzBlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjI4ZDBmNGQtOTU4Zi00YzE5LTkxN2MtZmZlYjYxMmM4\nN2UyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMPW+kfybAZfMzYW1TrljAayz\nTlgThtIumSGShkLFQ3xN9zaT/UG8SgZoWAaJuFQESDH+luyoMOXtQ7XssHy/SaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEvTTZqWsGgi0RSja/kEfVTUP+/YwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgLbAPcIbPjPbOTQ/c\nvFYjO9qr5Tkiq4KvRzvdrDLV1CkCIQCdVb0FpNGFWV1T2pH4w4oiMYAjUr22zUrl\nPwdJkbUoog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc324", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `324` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATtY3faIgnqlKLFj8rfGsC9gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxYTA5NDY1LWIwMDQtNDYwMS1hNzliLTcxZTIxZGQyMWUzMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTMxZTRmN2ItMjlm\nNC00YjFmLWJmMDQtYzM2MGJiMjcyOTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl9orahLQQILyLtDEiD9RCDyK+oC4VFB35zYd01Wc+7w13oGrw2eQp2jgoS53\n5eJfuU4NT/3WRsYHGDuK+RVyq6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT7v9GOrYspNNo4ARoFBv2TosxlAwHwYDVR0j\nBBgwFoAUwe7CC6Dyh4NlDKISsUi6aK5TATMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgMC88Daqk7NF0umzDau97bzLMTOtcYkirRkxhfmGeJ1YCIQCtJzAJZX67\nLbFVBUUIujCxwH1qLUFAV/Ks/YmzbtooOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQum2/wQm0C/psPpyT3XKVWnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWEwOTQ2NS1iMDA0LTQ2MDEtYTc5Yi03MWUyMWRkMjFlMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiWO1UiQ62ZhpPYbptYfFX2t06xrWI2fbcLdeU1HOZBWHj\nzK9cHACKCsJhlKPt/Zgxy2Tl6leLjcmyuWvBo1FSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwe7CC6Dyh4NlDKISsUi6aK5T\nATMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIH2jWQ19T/UecredOaYH8edSPLTTxCMmAIOE/XAYJ+ACIQDv+b6m+ZB+\nMNr8P//uPj1sJR5dLptHfk6JT/SPfJ+Khg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAUD2b8TQwR3cJpzi1N35tdRxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTMxZTRmN2ItMjlmNC00YjFmLWJmMDQtYzM2MGJiMjcyOTlkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGZmOGQxOTYtNzBkOC00ZjgxLTk1YmQtZjIyZDEyYzI5\nMGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdOgFOPkpZBeTgFI+p2+OOQ5q\nUiirzVrm/XYa/sxTOBb97m/nWcr5bxIlNA3/9Mh8ZG14DUujc6zKsHT26CopCKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT7v9GOrYspNNo4ARoFBv2TosxlAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAI6nfAHIiMWpaxJE\nLFAOnN+jhRMHDk0w32myJo67pAmyAiEAiNWwb2EwWWLiAvApeczGnXLzmkCpcqXV\nHhMtieXWQQo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc325", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `325` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAfLNBD98EGd/gQRonzpOm05sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxYjg3NWFlLThkYmMtNDEwYy1iNjBhLWMxOTYyMTE2NDI5MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q3ODE2M2UtOGQw\nNS00MTliLWI0ODctYTM3Njg5MGFkMDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX8AhFJf/ykfvfYcWVluBBjKsmnKbYYKlXgrCYH1kO7QNrv2bigZl9dU8ord9\nZamwbgGPoyn/LKRKivD+n/9DGqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3hyO1nMQdfB57nnk4dg3T/6jqa0wHwYDVR0j\nBBgwFoAUJTnKgVyPbd6MwFQ4ka8jWy1chb0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIEjfbKfrnNF00OMzmPSfaWsSIhNwi/9sdoD76gVpczWZAiEAhpKjRC6J\n82wAkktyXjyXIBXHLSo4baPm+LTrxkw98Dw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARHgGjRQcUW5dthLFn74AybPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWI4NzVhZS04ZGJjLTQxMGMtYjYwYS1jMTk2MjExNjQyOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQI3sMDWFCZmubnd6etrTr3LunUhTmQr7Fwdmqi6Syxyn8I\nwy2+Pk9runOU+DR4xGjoHmNveqNepXQD8mP21SoXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJTnKgVyPbd6MwFQ4ka8jWy1c\nhb0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc1ZkZg7lQLD4dkmsBL9qj1Ujk7mTjC+3jfarRrNJoysCIQC6BmmOg9E5\njKYMe08kAgpk/NQlDQ/bNmIG50t0O6HBRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAUqBrFli5l+exGb07lg+y2leMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q3ODE2M2UtOGQwNS00MTliLWI0ODctYTM3Njg5MGFkMDc3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjE0ZTgyNDctODZlZi00ZTEyLWJhNGUtYmZiNzY0M2Jh\nMjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBoZ1szsdrO/3STvSVGJRWyU0\nYjBQEV7FKTiopP9nrwSdGLsxfCJ+N+jeASBB+uVDUVnRIN0Uc1xZ1M9XwwGorqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3hyO1nMQdfB57nnk4dg3T/6jqa0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgcKv9Ca7J42Sd27IN\nuBOsXqhjnqn2rqmGZG/eqA2uvKACIGiTR1qqAKEgDDkk3287AA0DK5plS5ylF4S8\nzP3RGPYQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc326", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `326` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAS8zl6+cNNz3w7S2d6NH6LI0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MWQ3NzY0LTBkZDAtNGZlOC05OTE5LTNhYmFhYTg1ODIwYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZkYzE1MjktNTFm\nMC00ZDc2LWIzMDUtMjdlNGNjYWYyY2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXJ5CUEnKQcHyofZqEWX2/yzzgZ+yH5HzW+QlZSCw5OGI5dQVl8bvzebqx/3+\nhaLGKZ1iVjR41GY+okzqXeXsg6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9dxs8xuQq/NWxyY5EowZtmO0mp0wHwYDVR0j\nBBgwFoAUws0W5xUzvxFsaSRfeMgW3ikzu50wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD8o0ebPysPMXRi5a2aeDa2S/WY8koYaTileshD\nVL5aSwIgTQpqa2BXb8U7bowzGjn+u1zEJaLbVhgztWziSl/uzo8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbWhkbhbKt5oRnR5aCxZjKzXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTFkNzc2NC0wZGQwLTRmZTgtOTkxOS0zYWJhYWE4NTgyMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmIJIB7W4ntuZJQgqYaHZx4acbZHwHtNt5R9deYLgWEjr1\nhZ3NhlQkNOMiJWZ5kzp+aaFq95KWDYhAocYAYyfeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUws0W5xUzvxFsaSRfeMgW3ikz\nu50wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgO6rSbJKy/rushRAE2oXAtbcyxvb5HeBEWSWQj9O3xvYCIDQIqAr1eFKJ\nwDEbU9N0ZTDDKlj3d+MZ50Vwy+jY79Kr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQ9iFdbMyAGKzw0VIGj87eARMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZkYzE1MjktNTFmMC00ZDc2LWIzMDUtMjdlNGNjYWYyY2Y3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzYwMWM2ZjEtYjkyZC00OTIzLWEwYjUtZDEyMjZkZjBi\nODg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBs+PhDjvwiZV2NieTTuOlWZN\nxDBqgJKiUx4LWr69q6YZ8D0WCZAoI+YNU66z5Jd8QUjUZ5w58KuRcDJsb5JrXKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9dxs8xuQq/NWxyY5EowZtmO0mp0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgB0FXCaVMIi7SVLUp\nea9UAAZTZ7d+aEU55lOOT5AdsuoCIQCiWuYdrHZyVm7NVoYthKbq9AUDv7RYvbBX\nTPNjOJFvgQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc327", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `327` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZhbNvK6bRwe5/1b3oIOvPfIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyYzE4MmQ4LTQ1ZmQtNDcwNi1hNTkwLWI0NjVjZGMxODhkNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjMwNWI2MmItNTIw\nMy00Yjg5LThjMzMtZjdjZTliMTE1ODdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE17NYTapPbp7CpfXz/u6nI4lQejE6aOFl0q7oLWqCpez79nnbed79upSgefUX\nKB3kCYbNq2lr7FgZojwP5k4RKKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoXjr4P3ygzEsrfBmYcLdBsL42DswHwYDVR0j\nBBgwFoAUu/nXzuh+QlI1zUh4xzNJeog00GswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIAs/GTqjTcJf1getbLmByyqo4Nn0Qog1EUgq4+do\nnIg5AiEAp+JBU/gnHwVWBIV0ihOQaR/kBemjR3Ddd3jmhN2sDhM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe0bQ4ezm+pQpcpXuTnUeJKpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmMxODJkOC00NWZkLTQ3MDYtYTU5MC1iNDY1Y2RjMTg4ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5OdJfXpT4U8uivqQy1OFuXkKZesbW3epO/A0dLAYcHB0c\n1HPRACGJAOMuB5QAXZ3iE5ySlpi7DMIxBnvX631oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu/nXzuh+QlI1zUh4xzNJeog0\n0GswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMgd58LYGiPVYnwhYt03fcX/d3vIuTGHT7aLWlAzadwIAiAf31m9Kp0l\n6+PSB70HRfBcEJUlPxpV8VOL1chkUPf2Cg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAUWhQAVy2XMHdWMLfInH6E2EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjMwNWI2MmItNTIwMy00Yjg5LThjMzMtZjdjZTliMTE1ODdkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDIyNTc3Y2MtMGE3NC00NThmLTlhMTAtNjIxNmYxNTVj\nOTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9Bv+CLXOQ3bmRwQgPvkkwAnB\neBHLBZx/6rmK9Pmmc6peHqEzKVCCuiwD1uOAaps/BJ2YxKBZ6AsmY5iY8I5RpKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoXjr4P3ygzEsrfBmYcLdBsL42DswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgAnMz5oSAJwxkDaEu\nqAiExZpwDZTrxsRnFt9TptRHnnsCIQDb0ladvj0QPukSEeCajgDnTjCDMCnpUNxU\nbBx0iel2DQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc328", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `328` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAV2AOKxkuWopnvsquM+i87laMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzZThlMmIzLTI1ODMtNGQwYy04MWFjLTc2OTAwOTkyNGE0ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU1NjM0OGItNDA3\nMS00NDc2LTkwYTgtY2RmZWUwZmU1MzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyVoQ6Kh5WdGP+CrDFmzAJ1fywSa4gbt6HvvHGld1fWgFEIieGMiuWV9xBh5p\nTe8P+on/lJzUDg0Kiwos1G0JdaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU25agnOUaVP+xDbxkdqWXmoxw3kYwHwYDVR0j\nBBgwFoAUUwHFrc6l9BxFtdu5MGnetMU3lB8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIH1CrrM2grkafzB4IUWAn9kFLqfqe1NcNRu21zWAcpunAiB1\nKaPZe6yABCrQWi7qyOGE+LWODS+5/Xk310p102Fpug==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe664wIF0zVQRvG1wQn4Dc5iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2U4ZTJiMy0yNTgzLTRkMGMtODFhYy03NjkwMDk5MjRhNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ07GuPxsRiDPpaZ4+kQEIR+f4MgnrrHaoQkAALJyDuVR6G\nKxLWiQtik4zeAHfLUL249Dn71JftnJQVYBe5YtVpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUwHFrc6l9BxFtdu5MGnetMU3\nlB8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP9lWm+SnIyYLttJEUEsC4eDH9NiVOxmIvM7rkSHtrpvAiAByuhyAjA5\nuRdJz1/3wd0JltI6REE3mYXvgq1akdiG1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASw16f9ce8vqNsddFC5C1/zJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU1NjM0OGItNDA3MS00NDc2LTkwYTgtY2RmZWUwZmU1MzBmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWZlYWJmMzktMmNmNS00NzU4LWFmMWItZGU4YWUwNTY4\nYmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPgd0akHIyMedt4uvGkawaHpO\nq1Az+NIfx3YLgraS9luodPnAYTznAXEv5MsMnK4Z5tzNcY5JM/J/KSZldpJc+KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU25agnOUaVP+xDbxkdqWXmoxw3kYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJf4tmfuZuJK2lSv\nWzna5jAWxP8hJGttYsgDJoO0iWZxAiAb7+lNpOz+tXZKEJNL2cVR5vs9KkZ+2Bnn\ncxbylC83uQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc329", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `329` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAULOS7GlZWPIZbcGlGzZSteqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiM2IxYmQ5LTg3ZTMtNGEyMS1iNTI2LTc3NjdhNzVkZWM1MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGMxYzBlZDUtNmQy\nYi00YWM4LWE2MzUtMzY1NTUzOTVhMzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3LS7UxH8j2ZNMlEpqj2zDu8dqoDjzktfz7C+bCh2mepORWHraCNelcQbsL3c\nv/BJGKuuxJLskz8D92NoBCkgHKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHZ9cuytms5NtxSkvmAf7f9owFSgwHwYDVR0j\nBBgwFoAUz5eL2M0p01O6+JoYZyawv6tV0bgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIFshYq9lKBABgQPEaSujhGgQzMH6EnfL\nmxexUY2knnpoAiBXEzKF5bQbGo7PAsEXqR9uucFdyfLLzCnZC1+fBluoXQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcdiKKtKHo3/C1+UecbG/KTCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjNiMWJkOS04N2UzLTRhMjEtYjUyNi03NzY3YTc1ZGVjNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkHmUT7anFHWISHeHzIG3HgBX/hWA7PgbXXJ1Q1pXL8tqN\nkdBUPRskW4dtGeeaf1l8KXUpF0YIfsjaDsQTo5BEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz5eL2M0p01O6+JoYZyawv6tV\n0bgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJZ11XZ60+3CgYhez224mo5LiAJWKmqmsmQb5J/NJfthAiBuUKkHMuIy\nPol4tmKOgOxFeqXYwXqEszq7vwXj868OTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAfDkY6D+/7HGX5/v8IE30FmfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGMxYzBlZDUtNmQyYi00YWM4LWE2MzUtMzY1NTUzOTVhMzZjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2UwZmZjMDctYjI3Ny00Zjk1LTk0NWQtYWU5ZDkzNGNj\nMWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEe27RCRDoAC3OeWjkHCGTrF0\ntIxjBc9h1vKWNFLdRUqqoDTL7/GjCEuY/4PdZlcPUK6Zsk8dnxK+4u3Ov/OElqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHZ9cuytms5NtxSkvmAf7f9owFSgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAN4KZIwKeIeCcoNc\nutAw3CKWZNMhA1vymglfzVleM0ayAiAnQ3DXE1VKkGNhVUVebwaqxD8SJZE1GDzn\nu+Sju2Xzpw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc330", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `330` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAftBwSUeIWmM/HomIjKKR94TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlZDgxYjcwLWExNDQtNGE3Zi1iNGMzLWU0YTY4NTkyNDA4NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2QyMDEwODMtNzMx\nOC00MDE2LWJjNTAtMmQ0YmJjODIwNzgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGJK1H6mt2r9wg+QpRHreD3Iopbr8Sii1FO+3BOU1ddZIdJBf/JR84VUHFW0t\n6sxkbLFxSgQe9XB+GPwr10DgE6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqGJM35DN6rsf+FxkKyV/AttK/YEwHwYDVR0j\nBBgwFoAUDiUYH+7EeKX8ux0GGbwf6fpF4jQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIAaKu+raWYhI80APkxvJjXLJEWgLGzTn\nUDfp0hdbvnHbAiEAhReQdYgIle0gGGwBk+rjpvmZKsAAnDyQ3aL8Pr9uW4U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcn6OLoJ+ZGZ8Kyi52BnUUETMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZWQ4MWI3MC1hMTQ0LTRhN2YtYjRjMy1lNGE2ODU5MjQwODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9qwVqUazJ3rO1GAb9z2O8LjHbDoNvlguwLu3LRiRQvTm/\nZ3vMhupRoqbn5NJZ7wnFfkBj1i3i7FMmq73j6Yx6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDiUYH+7EeKX8ux0GGbwf6fpF\n4jQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRYQDnFuMC0rO22cCLvqdpSn7QsfSB4ofZ0DMZaYasvwCIQCZZ+Z1OiR9\nukrYttXoKOvyi8hWrt2lfhHYh3RF5fcukg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAY0zqFaqrqdbBp8SWplSGQLqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2QyMDEwODMtNzMxOC00MDE2LWJjNTAtMmQ0YmJjODIwNzgyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmZlZTcyMjEtMDc1ZS00ZTVhLTk0YzMtN2RiYjNiODFk\nNjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEus0EkKQZa0kosAB5K4zEe2fw\nj8hfQOTNA0ENSueg9vNmQW7hD9F+Ibf5o8BMat56Zs3sMNEzyFLGXCytgPdyRqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqGJM35DN6rsf+FxkKyV/AttK/YEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAO6rbbrFMRF4XHdI\n3nd6UfZm6RdLeLKxVL2cR3kbxypBAiEA3N4PLmJseGFv7lq1J7AzEx2e5wL9q6Xe\nV7A+e8xwMH0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc331", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `331` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAX6iOZ8b0oS8QLgsrLh9R8YZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlN2VhNzdlLTlhOTMtNDgyZS1iMzk4LTFjYTFkYWNjZDRkODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZlNDg5NmEtNzQ3\nNS00YzZmLTkzOWEtOWM4ZTA0YjAxNjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2yETJf3sZDabX3g1YG68OBrI2kXOAwv6CNUOxuER+ucvO1dEqiAN08kiRw0i\n5ePuTzADYoKLmIhCwdW/QDS57KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNy6QHnL2DahL73tnC7KbG2YFg33MB8GA1UdIwQY\nMBaAFIkVjQjNwIDoWZFNY8K43TkBbTbKMAoGCCqGSM49BAMCA0gAMEUCIQDgSWUw\nFP3aWFJuTVylgoatWKcFNuw0soQbxvtqa6r99wIgZrufgstORphGYcil7OLlNkHo\nw0ZHF2gmKVOvuPusWpg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAablFUb6zkhiwhpAWJ6g5H0hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTdlYTc3ZS05YTkzLTQ4MmUtYjM5OC0xY2ExZGFjY2Q0ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROdzXqFPfdSYcc3GuKVePySXVKVDIg89/M5NiKEXTQPlGq\nNFnzmUjwFE2YoUw7/P31iDeOsvmB5J8cffAv2Gvso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiRWNCM3AgOhZkU1jwrjdOQFt\nNsowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS8KTdVC/6Pa8F/oC2RBd/CcnZtULcVHSjCvs/lMAuOMCIQCUOtzvomMO\nfJA4Ykj6s1Nh7CqIvMYzFqKBMj4LKqQ/ZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAS8JXtWh96OFLg8jNMGzetAvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZlNDg5NmEtNzQ3NS00YzZmLTkzOWEtOWM4ZTA0YjAxNjUxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWI1NTExNjUtODU4Mi00NjhiLWE2NzAtZDAxMmE3YTI5\nOGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWyXDVzvSTrTNyRY8E+EfdmNF\nLhJbhMxLwcJbYBnNfmTgNsvGIwyEvSYdW8Js+2YqW6lakxFfjsVoJnQkmr7606N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3LpAecvYNqEvve2cLspsbZgWDfcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOZFgSt6\nALGqiZ/lCuRLqdYB8wXgH2P57ZxLO5xpHxAKAiABlmYVPvNB3ml3SkZeZ+s9F3Sj\nquxLZcTDmvSDyCRYqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc332", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `332` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAaZBmhuHPRz6vUBYIMWisuSsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzNTM2NWI2LTk5MWEtNGMyMi04NzkyLWMwNzBmODliYzNmZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA1ZjA4ODctZjM1\nNy00NTc5LTk2NjctNTRmZWMxM2E3MzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu4vG2lVhWq0fK77itb3gvk1FSTpKBtWldIgil5tGOMmixL+voYU2/o84L7zR\ndjK3DkJU+c8Eashf4NAiGP/5lqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMuIfW2oNO9QeCzQNn8Ty0E/Bj+EMB8GA1UdIwQY\nMBaAFHqNs8NPxaXuQ9hC/5EE4plr0Xz4MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBjvc/jnjxipaEmAD+5oyGvPEciejxLzJf4\nvdesEgNvXwIgZQ7JsHYvYrrq7PLyh4w4FrEaK03MRXnjdZVYFMoBKAs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYpnigjbN9gRXPM5Ji8RLOFzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzUzNjViNi05OTFhLTRjMjItODc5Mi1jMDcwZjg5YmMzZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWDWMhYtBsC1pNOjyeh03XMtfA/K/fnTIOgjhXB3Pdymwm\nIHZaD8VnHZ6xUtd4D5JvR3/SbQvv1Wz6A/mKj59Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeo2zw0/Fpe5D2EL/kQTimWvR\nfPgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANkBmL+4ij4c6smW6b3Ntzymidt+GP+mvYPqgUAhnN/oAiEAnIMeO7er\naTC6EwkaAvWpVOfYDaxTWeUKJmKLchnHhZ8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZ19rPXav4QEbbjRtjQuJA4BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA1ZjA4ODctZjM1Ny00NTc5LTk2NjctNTRmZWMxM2E3MzE1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGVkNjI3ZmItNThjMC00MTExLWFhMTctZTdjZGUyNmY1\nYzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUw1WP7bR3xcKRWHi53/2mtnl\nADbIAbw8TgPE4WkxAxCKbKI3d4F8U3+j0gQ55pY/AMqC7Qlfaeig4ijR2NhY2aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy4h9bag071B4LNA2fxPLQT8GP4QwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgSagSZFDi\nP3PQnE1a1NucAsuhYUbCdxsSsjOiS1n4cB8CIQCypdHQrdPL4f5RPnlRBIAOzrKl\nw0FOAe2xVu9XBCjKog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc333", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `333` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVHVqaJbZkoX5Zi7rcXFQcHHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YzhmZWRlLTA1ZTEtNGEwNi05NmJlLTY1YzBiMjg1NTdiODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTliZWYzN2UtOTRh\nMS00OTQxLTkwZTItZWI4MDM0ZmUxZjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj+1LfNWx3bob5rYdh0m/8SJ+1HzrqzYIwqBtqpMRjP72jwaG03DQHkySOFUi\nzJGAPmrV4kzp7auW4MG2FH8SCKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFH02KvEmdrXRKtVdKdeAxv/hZuuJMB8GA1UdIwQY\nMBaAFE9U0LdQmc+2XWMikDJPPBseGLz6MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAqP9jyM3RylNWFzJ0FfSTFH6LstRZFA1J5\njAIHHXyXpwIgKalNv9ENx6MFMUHyu8/BDUs01ojbrVvt1IItpQK4UQY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf5cgyR0CB50XVnBylYqC2q2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2M4ZmVkZS0wNWUxLTRhMDYtOTZiZS02NWMwYjI4NTU3YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASN02NHYdRCVY2zcXGieifq7VovS99TBYDt5iOanjBFswo3\nCkkzgUmGh3yytvLs2ngu9z2v4CfBTWRwQf0ts3ydo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT1TQt1CZz7ZdYyKQMk88Gx4Y\nvPowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOpqLwGXuVZswzV9k5j1ExL6GptAAql1rI/eKXYem81hAiAMPDvpUE/z\nsSXqH49bZiVtP1ksgRPa94d9fsvyS9yG7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUT+5Klsj2T4t427Sm44JsslMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTliZWYzN2UtOTRhMS00OTQxLTkwZTItZWI4MDM0ZmUxZjUwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDdmYzhhYmQtNDliZC00NDBkLWE0MTItYmVjNDllNDky\nMDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/ob77do9JhgGIAmcdwvIA/Zu\n/X0QN5UA2IbVtlzWib3HUWURHtQ5l19UOx+hkh0FZzxNl92irmk1jhbAZGRhlaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfTYq8SZ2tdEq1V0p14DG/+Fm64kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPd/MGYY\nd442rqhMgb4wcSoQYi60MzXfOZjD9fOX3u9HAiAheYbPQbFAYd8d3Ah0p/7r7CAD\ngFXSeMJ0+jybZSLglA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc334", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `334` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAWs8vW8B2yZlMsLTKeYOEhRqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyNzQ2OTc2LThmMTEtNDgzNC1iMTkxLTkxODQwNDY3YzM5ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ0N2FmYzYtMGNl\nZC00YjJhLWIzMGQtMjhiODI2MjFiM2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe8rrdUi5kt3+avzeOXdcvBc9QVQbsf5d4AMJv+3f30vwYHldiLjusNZ32774\nzidq2xoVzCK0KYAlEhFpAX+AL6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSb9Qhkb7oxLPS0k3Ypnmx37lEE0jAfBgNVHSME\nGDAWgBTpLJLSwzoYC53GAwqb4p/zWSA5ZDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBHwHFuGfJzu8G2j8vI7FBXoYVF1rVXe\nBDfLSPB9KmPfAiAsMcCkY/AAA7xYAmSsnmbiTuxBZuzyHOp9Wgjoy7lOkQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfFh+J2ShtjL5UiCQwCF7W4xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjc0Njk3Ni04ZjExLTQ4MzQtYjE5MS05MTg0MDQ2N2MzOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzRpRtzEJ/nsiKxzmBfWwbhJy+Jat8hIZxc4jaiUtn3o5r\nDmZRy0ieG6M+aEOrk6ra46SFSwTEOLtRCYLp0Yo4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6SyS0sM6GAudxgMKm+Kf81kg\nOWQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ268oMvEtMHeClpDOkx8gG2ivgBioSby98pzX/MgOi0AiBaxD3nc/eP\nKwjuiwCoOZLmIDqbTCJe7bvU+aRTlCB0jQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISARZRdY+1E8JtU5b5wQG8R5L9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ0N2FmYzYtMGNlZC00YjJhLWIzMGQtMjhiODI2MjFiM2ZhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzBhODdlNGYtN2ZhZi00MzY3LTgyNGItODUyYWM4M2Jh\nZWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjXAifruX/6vpZi29Gmfo+bgi\nAnvlWqe1C6uFhhbfMcyH9c0p4zRQWiEOlKAHA3XvlDd2wQpcAVoXoFM/uRuNt6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm/UIZG+6MSz0tJN2KZ5sd+5RBNIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgNXtx6B5M\n3rihynWGMDEkXYNqbKVJJaiKjr0DUYlr9oMCIGWkM2jtRHuQ6EGKmnLr/zNRKZSs\nNL77kPqCpi5xwYsq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc335", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `335` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAS7EUi2hXXHJWOU5iwj15yf1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NDczOWJkLTk4YjYtNDcxNC1iOTU4LTczNzI4ZDAzYTZiOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODlhNDU2YzMtMmNj\nZC00MDU2LTk3NGYtNDdhZjA0M2Q0ZDhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8dnSqmFpZH5yPp57ZuFkGb5xd08FHz9ebpDDagoupu4tQtn64MqV6cs0lMw3\nWd5qqgg1zWhYq1b1dPUUyi4icqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf+xrVF8xCEu/S5CUV9l9IvO1ThQwHwYDVR0j\nBBgwFoAUW1yUsGLIDkXU1UWD97OZ3+1J43MwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAK27yjYCzhnIyD\nOtqttHa6Nrdjx2AcYtd1i3NYbcJgygIgHxowqRssI1GI/zBmzq9EfrkfRauY0qM1\ndbzAd6tCbqw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbPcl5943aO8lwNkvsUprr+8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTQ3MzliZC05OGI2LTQ3MTQtYjk1OC03MzcyOGQwM2E2YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHZ++ucnhkPQqnVQkEnLe97cbhLf2HFKSsZyGgVyhYw9h2\nxjfHdYB77DDrGXiesjkS7FLHc1lgwo1n1LLSL/tdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW1yUsGLIDkXU1UWD97OZ3+1J\n43MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcZ6NvtMBYTaZE6CJddJJddoT7qttiMWbi2xrtYC1kA0CIGf3ZndaJNNI\nSblpC01vEFeNR8E2cbwksz6cb4ubcFM+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZRygBq78a1mHJfHN+vGKiEFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODlhNDU2YzMtMmNjZC00MDU2LTk3NGYtNDdhZjA0M2Q0ZDhmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjcwNWQ0Y2QtOTdhOS00N2Q2LTg4NTItYjg5OTkyZDRj\nNzI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwJjkr0IKWjlG3Hh2NSDFbIuw\naTo+73rJzVInjkaDMizJK5d3RqCF6vKPJFoXuOVdHuVRXqBSh2hcOtN4GMKycKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUf+xrVF8xCEu/S5CUV9l9IvO1ThQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgH59d/jZA\nT91CJNdxFUJwPacNegt04sVdNXkwGivoo00CIBWrMoD70h8eMWyVq56ISCikiLYh\nnLvYXqNFy4fU+G+E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc336", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `336` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAUz9J/Ss+zgb+jud04nwUsXpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjMDJiNGUwLWYwNjEtNDhmYi1iZGQzLTJkODljMWEwMTc0YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjczNGE0ZTctNzdl\nMi00ODEzLTg0NjAtODg3Yjk4NjEzNzFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/DAydHdRtpSewy20ePZQmbWopSlLKgCrlRaM9Sk0iTZTXj/5dg7NPQPOzAbz\nLJW68mkhjN0FqyY9uZtQ5oAiRqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrQqRZrXEohts4Dhui2qNtRowiAcwHwYDVR0j\nBBgwFoAUXKUrRXiduBeU3ySKilXIpG2hXPowJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAuGASPuQYDv0+\nPeSV2Z3MrkkjqWSOCGHuDVsorPLCYbwCIQC+GOgI0ymP8pNt7njFs0xxmkH97gD6\nM68PvthDPMbRQQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZe7sxLCq4aKzN0SELmbWiMhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzAyYjRlMC1mMDYxLTQ4ZmItYmRkMy0yZDg5YzFhMDE3NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThMfq1efXniC/D73Sc3tw1yJMfhbQ9O2VWDDgzPwoTTS30\nde63MnsB1YV546PdC/PlPW1lvyU87DoSde+9GZ4Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXKUrRXiduBeU3ySKilXIpG2h\nXPowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALpHRIvN5ymqCSuncfVWItxtItpXA5eOuFlGKe2iMvrfAiBZaFDWDSz5\n/6TeSZ+g9R7VESmuM0dkNVPht5dNK/8m+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUJaS4ziJUOkxjtEVue6ipxDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjczNGE0ZTctNzdlMi00ODEzLTg0NjAtODg3Yjk4NjEzNzFlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODZkNjkwYjgtZWZkNS00ZGNkLTk1NDAtZmViZWNiMzkz\nMjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy/EsndNYqRrS4Us08+F/Sw4v\nEdVDNRnK3wgNgrYCSCHX5J8Q3ZsKrUeBf+nDgvYQ1QTsAtlTC1Y5FSX517JtpaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrQqRZrXEohts4Dhui2qNtRowiAcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMOzYXvx\nAxt1ntTguVb9c6nF+pzPpvJVcOt2I5uDnlyIAiBle4DlNYF3gI1Tmbhnl3qk4vUx\nWlDxyUP3W1HoZkTXLQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc337", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `337` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAQexxTdo2pMDMD/5CNHidmqFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ODBhYTU0LTI2OWQtNDAwZi1hYjA2LTdlOWMyY2E5MDE4ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM1Nzg0ODYtMzVh\nOS00NWJmLWE3NjctM2FlNjVlOWRmN2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBwyYJurCZNPDtKRtlC/RayIrhNdGSY70i3ZQtd0HPxn41jrLy2GYbFdraFVV\n+KPKjqpELcdggJ+PpCa9an8XKaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJBpBrwS3XUUMI8T74XWGmv9im+owHwYDVR0j\nBBgwFoAUbtrh7e91gE+ExXfe/zansQkvF0AwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA+csYjNfHA1ch2UZbc0aR\nVPzBlrzAA5lC8Fokep+J4iECIDOewa88pNkaXrN+HHUCFrlkrjTeLxcen60w2bXM\nQRnM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWkTtfgajDLWABuZj5p8n+hrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDgwYWE1NC0yNjlkLTQwMGYtYWIwNi03ZTljMmNhOTAxODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT17c6YhcnKCM2c6GiN+OgsYxnjKKHW1pYSJUSgCMyh+lVA\ngNbrqK1P7947CffzjGb6sgvndVz9OcRTZlDmCAB9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbtrh7e91gE+ExXfe/zansQkv\nF0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW6c4T/mBDQgzMUcIuJY+LBXkLREWA7KNiTZw0x1avygCIQCY1W69EJid\nM3nSWKrVxnD+HAKDqvJ9+LA50FFI3q+4Sg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcgkZuCw6Wc4vn+gTSmS2x2/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM1Nzg0ODYtMzVhOS00NWJmLWE3NjctM2FlNjVlOWRmN2FkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjhiYmQ0OTUtMGZiNi00NzAyLTk0MDAtOTczMzU3OGE4\nNzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9W5KXZcxbAAVIsEG7TvcbvXH\nG522hu2yvV5lT7FC9xDV/8QolyqiXS3XT/3jRagoivBF/hCuA/U1Kw8y9dUtF6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJBpBrwS3XUUMI8T74XWGmv9im+owHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhANgzSwiB\nsXfkt4qLm46Mz32vVmoHCLjOoNlI+38+9g3PAiEA5D1AWvvKsdT2iB0B5Mzt61Dp\nmZ1ZSir34/OmyD9oQVg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc338", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `338` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAS/QoSK2iRgo+yjkWKyR+ARtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5MmI2YzA3LTlkNGItNGUyYS1hMDEyLWIzNzIxNDMwNDdhNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM2NTU4YzUtNTQx\nMC00ZDlmLTgyYmYtMGQ5ZjljZjQwYjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe+ipzS35LykPhcd7NgW+smwp2ookQatUBXFKBebNGI3PRB0xdLS4wY4Bhz4r\nVgTs20d6DTZzgRDNT6itOfOTZaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNSpZm5/DUD3LZ0tzeS17vkMQLQ0wHwYDVR0j\nBBgwFoAUx7yl2Pqojxf5xflJ9lflt4LuTmowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBXLGvv\nsHwJdd78mEobnwIW+8ntwdXkwmePET84S/wmdwIgWdcY9P/bZCfWEjQQjvvKf3bZ\nNPVBkwyz7Tr61aFHyqg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfUGO+2J3cjYvV5AZsIAx1kmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTJiNmMwNy05ZDRiLTRlMmEtYTAxMi1iMzcyMTQzMDQ3YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyhf0WiyjoiAD7Ghu4rvSsFo3+fTr5GHWOWuDRhBpBRfku\nnd17pjXMYAhHgmnQmhfLNAVm3jekg/Ph0f6Bgqyho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx7yl2Pqojxf5xflJ9lflt4Lu\nTmowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIGvIpSOeFR9H+qHIX1+5+HJRFYSmMEyDNbwaxMa4XJ0CIQC0xckeii2O\nrb2mzFTJ4qrOoK8Fzj+g66s3X67QkAnY6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXcLfmuUFQvDxTZ3ojLT0MKGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM2NTU4YzUtNTQxMC00ZDlmLTgyYmYtMGQ5ZjljZjQwYjcwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjA1YmNiYjYtYTE0OS00OGJjLWIzMDQtYTU2YThmZjQx\nZTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzCiujsqDAFvNqJyIaDZAy97D\nw1VqTBsM2KUTjFKBiQSivz1G4FN30vrN7N5wStIgP88qMLM/mTzY+0KTeFy/laN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNSpZm5/DUD3LZ0tzeS17vkMQLQ0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgHxRF1uVm\n7ziorzS8bjhmIyh5G/zbrVW+8Xch97cpM1ACIQD8bWroac9BRrI3l+iQPTn9kUQD\nhcIEeilZEJTuj6ZajA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc339", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `339` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAcaPBTkVW3zjdhODu8v8V9SiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyYTI0ODdlLTVjNmYtNDBkZi1iMjM2LTdkNTk5NDQ1OWVmYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhmMDZiZTQtY2Yy\nYy00MzMwLWEwZTQtZDIzZDNkYWU0NGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESt0da//OMPILFWujYk4imD8fSh0o+pCplAoRdKtJR4Tbw90xgx+tGu5IBDAO\nTK9Wk5rI6H4V9qhsH1/uKNQCDqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy2ZjgmowUG1BGAZn5WwBWofnesswHwYDVR0j\nBBgwFoAUr3aTIBruR0VZyWojQi3LeYT3EmAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBHe95I\nzu6b/mnj0pwyquCPjktjBI/6HZX5MxQOuy1AMgIgY5DWbKo6IHNIw6t3CMacYXKS\nhgVPrbsuu8OXjw1mhdk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZk1wkEO27LldYQPVwurIesXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmEyNDg3ZS01YzZmLTQwZGYtYjIzNi03ZDU5OTQ0NTllZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWOnscii71so9YvWzpkBG1xY2AD6yYycwkcc6OtZ31Hdvs\nND45+e/pnXmhEgLC/DWTAeq5O9PKIfFjNbuX929Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr3aTIBruR0VZyWojQi3LeYT3\nEmAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM5AYvK1ok7ZGaM/oM+tqwRVspd2h9kLC/LlV9UhfVuzAiEAosAOllBI\nJN0BMVhKC8IrZoaQ3xtLlK0JRF+FAHhJvNw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARFA6tmm+pzvo1wcxwGPPtXwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhmMDZiZTQtY2YyYy00MzMwLWEwZTQtZDIzZDNkYWU0NGRjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2QzZThjZTYtMTdkYi00OTg3LTgzMTAtOTMzMzQ1MTQy\nMDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZr/WmFyI90xU23M4BVSXJGzN\nGnh+e827WPCaPvawXctZwdZNRLm17la/yXmF2CJede9nBb4lo8xbp5AMm8odo6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy2ZjgmowUG1BGAZn5WwBWofnesswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhANImTDz7\nICoePLmpfgfP2YtOX3gWVy2e+jYpjvLMzBAMAiBnNW9W1NfnYnAzRYzAlbW0yIgQ\nXhXC6BoxJUGV+0GKrA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc340", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `340` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAWI5A3GyGjZwNPBI/bvGrKEXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjYTA4MWRkLTUzOTItNDBiMC05MTc2LTYyYzMwNzFmYzZlNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M1NGMzNTEtNmIy\nMy00ZjdiLWEyOGEtMjY2OTE4MDU2NmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC/iqyxrpf0ufebvGqyhulnRzqf6vM1FvU/niAddrfSCynduKPEZN2bZoqn50\n23xYkdoW6ag+H/Y2hU30uk5A7KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC9ATqfu6M7dWzMw+KjCPTBbO3esMB8GA1UdIwQY\nMBaAFC/pgPEyALPmW0C12/YxEZ1XPiZ0MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAHCe4eMEo+HLg+qUuH4huAZNYHzV1JmLYa\n+JXdGixC4gIgGvegrc4TzTqUbf+6ZUI8Hd9JGx5hDrowSVSVmxMRXss=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXgTk/purksK6toAEYpt8iUoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2EwODFkZC01MzkyLTQwYjAtOTE3Ni02MmMzMDcxZmM2ZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPkdxkFqpYDH/X3+58bH0aOCY+2jECmd1pNCe/rkr/yJZK\nApr+kGIKfw7HdPgulnD/qObYdZSPC1qaB3tS7bOwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL+mA8TIAs+ZbQLXb9jERnVc+\nJnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJiyhXEGmSm4l5UnnAOJUXF/1uTVgTknmTvA6TkWezq7AiAm5Anyxt0x\nIyyLU/MLHXvX46PQUK7xRPOOCPd08B3tJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASc+MhvOQfI+5/oJPdy5RykqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M1NGMzNTEtNmIyMy00ZjdiLWEyOGEtMjY2OTE4MDU2NmM0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzU0NWY3NjEtYTUzMi00MjRiLThmOGEtZWI0ZTcyNDg5\nYTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELdSiNA3w2IG54C2OvvtU85gY\nsZQ2q70lF1mjcPJUEvkeSZrjywG9U7FYO5uUI0MQ/El8bS06jYieEzQA8yIrFaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUL0BOp+7ozt1bMzD4qMI9MFs7d6wwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgD9uXGBVw\nAC2V1hhG96VWxU+dfEB7COdatjjg7sjEXHwCIQCnBMWwq65cBkzlJXwXkB8vlupu\n0ie6SzBr1TsNHYLqNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc341", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `341` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATf3Sur/4H532nX7u/V5RdZLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiMTNiZTM2LThjMTYtNDAyOC04ZGVmLWUyYmVlZjVhMWQ2YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQyMzU4MzUtYzBk\nZC00ZjVkLTkxZTgtMTBlZDMyNDhhZWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiYOTRtxTEWTS5Dd7JgmCUlV8+pU8rPykGeOkCAuPTWpiIM8sWMkllUsnis87\nNhiJJHBtW/H1gaW1cPWZxomSpKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBjFASaBHL9AM9pQCmkiHydBanIwHwYDVR0j\nBBgwFoAUE4U38ox1RWmm/q79OnOp0PET0ZAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAK8sBoKwQi1p\ni2M/viJ/MZnxVLbidBZz0KzOoWxQ9KVrAiA8qXVpEtTLZMHxG1kkR85pXIhzFlQ9\nXz9ctnIVj6GFPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWur7MjAh1sLzJ5oI1jKnwbRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjEzYmUzNi04YzE2LTQwMjgtOGRlZi1lMmJlZWY1YTFkNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKk25nlUOMXenawR3FWczU6JxrTjKW1M6F7L0+xe1pzUtj\nzN5hPxGNfhSRqT1dn0tQGQ3RhFQhn1iqUqb+cj6Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE4U38ox1RWmm/q79OnOp0PET\n0ZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCwZGeWcy9ShJsRnz+8hSg0YoTNvPBucF7v06VOkKycYCIHHbeBPRaEfr\nSAofSLIBRkT919QrotwI1INCFw8+1x1U\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAafmjevbriOsrnadfvH2Q/a+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQyMzU4MzUtYzBkZC00ZjVkLTkxZTgtMTBlZDMyNDhhZWNmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk1MjcyM2EtZWNlNC00ZjVmLTg5YmItOWM4ZmNlMzc3\nZTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEF8XbWNHPnySd52qEXnfiS7Xj\n8D0wDdOO+PdMuiHINgrfzcl9wVIgeXYQtgbpWZyZmam5IAVr+Uv5CFHbaqTVDaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeBjFASaBHL9AM9pQCmkiHydBanIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOZLOvdE\neBwF5bEDlsqzXfMdYeO+i10pf9ffD+Q+zfbDAiEAyzQbuWjwhhCgNMgMSViuiiQI\n09hDXoSXrpw0oukqC2s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc342", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `342` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAS3OQ9pMtcpn6Lkwam+vgzuyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhZGY4MDVkLTM5YWQtNGZiYi05MzJjLWU0MzBmMDcwNzcxODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmVlMjdjYTktYjEy\nNy00MGMzLTgwMDMtMmIyYmI2NTc0NTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2swW1vg4iC8e8WyqlfwQLcXX6ccJGFUz953NlWSTwheDKVS07IVfs/61iSJ4\nqQxzI1IByD950kfisZXOBNNgbKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcZVkr5Z4crLm8LNK1/ZpsHvL+5cwHwYDVR0j\nBBgwFoAUv4otthIMYU7U1cavou+2JSPjZDgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgQZ7KcOEKaApB\nAQhnCigivu5B6hw0dImKZV1GN8F6WNMCIAfDO9Uvo+dbrOd0/5pbHAtNVp9IuFVx\npQoOAMbWYTcF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeVzYK0IT9HrBLFV1idz4grsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWRmODA1ZC0zOWFkLTRmYmItOTMyYy1lNDMwZjA3MDc3MTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3l34Tc1rwV9nttz8kT2GAVyjjDs2LL/33kjsJqlC56gb4\n9tEf5LTkG4936Wt+NB+t73+0Uh3NeVzQOejNskPlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv4otthIMYU7U1cavou+2JSPj\nZDgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMNULb0m4sFqpdAUKKhIZwGsxc78DCUasna9FeEw7fV4CIFdvFLTuts8f\n8Jrhn7rd24ZSZWdW4/HtdI/M7Z2eHKvq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAd5olhqg/Hx816hiXcrWZULpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmVlMjdjYTktYjEyNy00MGMzLTgwMDMtMmIyYmI2NTc0NTE0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmE4MThkN2QtZDQzMC00NjIyLTk2YWYtMGVlMTRjYzA5\nYzgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErHEfpl75j2WGZp5F5phJ4ihR\nf36PEAJ4tzlKVGOzowp+EkQVriYaAeKvnTDhrffFIPzzsCHI3V4rjXuqevqO1qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcZVkr5Z4crLm8LNK1/ZpsHvL+5cwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAO4rzbA5\nsS/omQO2PYBjh0MyI8sJYBWsfKVtSw+5PZGcAiAFjoavaFA8as7jIGMOWm7FK1Gu\npfovfZSSObIOpdMTXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc343", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `343` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUiast+Ql3VCOq67vMOOhJ63MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkZTNiOWE5LTk5NjQtNDZmOS05N2JhLWZlOTRmMGFhOGFmNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTYwOGRiNTQtMTU4\nYS00OTlmLWExY2ItN2RjMTgzN2M3NTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0mK9A3h4nXJDrlFZcSLDOIhbH2Lecl9AAXlvPfKg7iDuJGnajzobwc5/Apd+\n2txV3B2aIrCIP+JPuOjmxve3vqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVCFv5mO1mi8iPpJ5OqSYidKQXA0wHwYDVR0j\nBBgwFoAUr9jNnh9CiWM4tKhv47ULex+qGfswKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBHB7GQVY2Ty\nGZc6csQMlLAFLjYCZCjGZC1efEXwTiQ1AiEArIN862DjHwSebxB/omORIG3s1xZw\n+Mu1g4WGXwLqdYc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX8VZOTcSzbubF8hgFStD+LqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZGUzYjlhOS05OTY0LTQ2ZjktOTdiYS1mZTk0ZjBhYThhZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/2t82KyixmwYyeWbf417hgocaqTEWWFwj2Yqaq77uhcH0\nV7fHFjiMzkpqWjOYUtsBKGFJPZj2tyYtKItK7azFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr9jNnh9CiWM4tKhv47ULex+q\nGfswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFEG4YfoEGE/dWD+3IQ+z0+kKN//wfBF6u/xn1rYnDVMCIAbi9v6zeb5b\nYsDpal7UUSfpeRs3yq6jMaBgFUQPnS7Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAblXXvOvrQJqjdtLGau2DOEJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTYwOGRiNTQtMTU4YS00OTlmLWExY2ItN2RjMTgzN2M3NTY0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzY4YjMyMWYtM2M2OC00ZjViLWFiNTQtMWM0MjRiM2U2\nYWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsBp33s9qLmyKUbF9eaYClWJV\nNsYyOqy20WkwR6boBl7cxyEMacFnWVa4L5WmcgwmRgsCel5wt1VI5K431sfqx6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVCFv5mO1mi8iPpJ5OqSYidKQXA0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAM12zFZt\nBBCmKWO8CeU/3AqBpbC+aQICHbp2pzaklUxkAiA5N29WPQozl/4w5vP7V058dogJ\nh9dhF0EvyDtshuUVnw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc344", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `344` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATfEgsUhwHC/mtZdx42H+vl5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3ODMxN2ZlLTIwZWQtNDczMy05Mjc3LTE5M2MxOTZiZDdkZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhkYWYyODctMTg3\nZS00MGYyLWIwMGItNWE2NDU0YTk2MDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEizQCpx9fVRaA0n0+RmNENZvHmOxF2BtPgMUBwepEtomuK4nBz6NW10Cdsiuk\npXa+Nl717q6Epc+qxOJ2zQ3LDqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbsP+LIpXauB29Yf28eqwH0wYPrEwHwYDVR0j\nBBgwFoAUZQuVV/ocUzVpe/8gstwftjApvtEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEXPS99cqSQfDxWsr68j0psflBUr+r+fl9Z7FVLHkT+nAiA+09ykoVa3eE5q\ndkJkVQVi4Grs59+Ox8WnDwo2St6aLg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAavvQNE9ltqeunUOgTTcBLBfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzgzMTdmZS0yMGVkLTQ3MzMtOTI3Ny0xOTNjMTk2YmQ3ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARB8VVQsT3E8xE4CEWm4JbM5Lk86Iowng+zx2C8qGQphA2f\nUEwRZxXehtyu5W34u6vBOKJCUtdHz7hdBeyimTEEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZQuVV/ocUzVpe/8gstwftjAp\nvtEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM5c5Xbge0QCMZ3j56qrWY8GGQNX1v5fOmouUokrzRr0AiAkr7Ejkpqn\nXGdplB+zGe61ZUAEF3HbT2trrPEzNEfL9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXkgzNvOmawgIqNwHDvyzTa3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhkYWYyODctMTg3ZS00MGYyLWIwMGItNWE2NDU0YTk2MDBhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmU2N2JkMGUtOTFjYy00MWJhLWJiZDctMGNkNTFkZDIz\nMDRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6vuzH2mIH1B2C4mOfHXwjBvX\n6gyJUt1qxOatJRT/do1WoSswC0g+Msz+F+6vZbb3Pll1cGUA8ezRJmAR8X3XG6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbsP+LIpXauB29Yf28eqwH0wYPrEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIst7QK8\n4fGxibRRQ35iC4qxsSEGFaralBexsqdT1tRbAiAldHghn0ORV7wdRNaLfLpUDMJK\n36VLooGU+zZpxPiV0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc345", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `345` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVl9Jx5erAR7Nm7S+E6fyeHiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjMzUyYzgwLWI4MjEtNGYxMC04YjhmLTg5YzU3OTE1YzI1ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNlZGZiMDYtOWYz\nNi00MWE2LTllOTQtZTA3Yjk4Y2NjNGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIUAzFtGxNyKIKMpyotqhpzfXqveee8BIwsvf3E0xJGUqD6Uo7qmdRLI5SDyp\n/9XRlXI4MOmuYVfl/5F2znlbcKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmf+lBZ2oogq4xAudlczxH3/7WNIwHwYDVR0j\nBBgwFoAUBBvFDZrUOnigKksmYHw5bJMAYYIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC9K7ago3GuIiYtkhqX9xYGGAj30+uhXjFjDp5K/N4eIQIgQjWj9AxvB90e\nVm6F9zAty41Y36113mSzFmcWDL+CjvQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARMf5FqtvtAHh5m3MmY6sWySMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzM1MmM4MC1iODIxLTRmMTAtOGI4Zi04OWM1NzkxNWMyNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROO6Obi6xrfEjSJObC0tHTSzyKsMs01wwjbeK4rRIkAY4H\n6rr5S/FdBk9zMCe1OUqwPYl7tikiSxjB/Sq+NkS1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBBvFDZrUOnigKksmYHw5bJMA\nYYIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJFPAFUvfpF4WxGuYSDhfnvftFYTZQcHJx5PDkuSGg6QCIAHDMM1n4N6Z\nkFSOxcww837EzOqgrqSm4FFGlAvoBrHb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAb3IIdbVPwX3f9sHr1AApeXAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNlZGZiMDYtOWYzNi00MWE2LTllOTQtZTA3Yjk4Y2NjNGM1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWY5N2JjMmMtNWIyNC00YTc3LWFjMTMtMjBlNDZhM2I4\nMGMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyNy7czKvoep3xuSkocYFtHRi\nwQ+dY2afgVcTgHK1KD3uG0JZGUdjd6+4tPG87j+2XtitjRSFXJ7dhIbkwOtDX6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmf+lBZ2oogq4xAudlczxH3/7WNIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgBftx2ooi\na7w4zWcySXrnEwr5OfDq3nq9aXBTYMlGUSMCIQCEFudc10IGDwAbXu0VMuNnw3rZ\nhnPNm8We/9+Ilr3a7g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc346", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `346` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAbGH0Ch2sF2UT3k/nZgcpFbXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlZWQwMDA3LWE0Y2QtNDA4NC1hMDE5LWMyYWYzNWIxZjQxZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjlmYzc2ZWYtZDQ3\nZS00MTBiLWFiNzEtMDMxM2M3YTIxMTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9rotmadzHY1RalwuYMr8suv3Km6U+EQy7SqBKE7Pkrjyr36jQqDbZfuXw1cW\n7WI/+OPTMzwNOyqAXux2DJcIv6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0mPTes3XvmeptlrM+Y4JgB61LfYwHwYDVR0j\nBBgwFoAU0dIgoyHsyqeihlvNx1NEYcLK+HwwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDg+\nYKmpTDP3YBBA7MenjOt78yixUZqD891etwcbw+1gAiEA+AL7uxW3LOeFw3j4UTtr\niX6uSx0qIr6sZhsE/Apr5jk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZiHTPZ0Y4bn5dWu+7jOboodMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZWVkMDAwNy1hNGNkLTQwODQtYTAxOS1jMmFmMzViMWY0MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzy6Nmrsqq3qYGLNjciLT6CAOwKCamaCXYa1OLkuLcb4KN\nARO2gUh92x7gJ4UdbZeGZS46M/21iiHDLNTE8zU4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0dIgoyHsyqeihlvNx1NEYcLK\n+HwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJzjPo3WJia8WGxAiorDWRJVITRKwVNFdPpIwTTCBFJUAiEAh1B4bjNs\ndBvI1DIY0jnGQCGS7RmTyMlwIDApDOz7YPc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAabFmw+5QrlrMExg1uTxNVlwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjlmYzc2ZWYtZDQ3ZS00MTBiLWFiNzEtMDMxM2M3YTIxMTYyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjBjNzczNDAtZWRjNC00YzVjLWE3ZTUtZTcwNGZhYjVl\nY2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwh8r2lUd69D2x10ILe5TnU5U\n7Sw7D3PohQ6QzZGnKFzIYmz+3k7NHfiDv4EuamZ+pS5RKqVT4Hs1OlmTB7PmkKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0mPTes3XvmeptlrM+Y4JgB61LfYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgRlzXoLQk\nCBgdwoK0GlJM+ee5X+5ZzvPVxs1KdwwsDigCIFCzcvEMO1OdaCIv6nHkOpbrXel6\nyEOKRs7r3pQqZKFv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc347", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `347` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATBrmFDFRe2h8wKLytDquxGRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNDY1NmU1LTNlNWMtNGY2ZS04YjQ2LTI2MWUwYmE5Mjg3ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjYwYWJiZTItZDQw\nMy00MjFkLWIxYWUtMGM5MDM5ZDZmNDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeI1blok6V5HWHlOZmqZ22AZik/C5lhMC4V6wQZ0s2aPRQbhjChYoi1V3JBiY\n0D7dl4c/4Sp5WGlC9oWysUjq4aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7DSx4GZ+iLNyeMhKsOhISuSBRlowHwYDVR0j\nBBgwFoAUPFv5IM9FjBqez6ibsjAE4DuLlckwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQD7DQw1GHbVNe0TSY5UIe4Q6sKXyslMkZD1z9w7aENW7AIgYSpx\nYoqRBPZ5hWjx/AqQISkD6uZ/QRn+i/TGR/TwRH4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe8XCOI5kc/c9zJi8+d38EFLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDQ2NTZlNS0zZTVjLTRmNmUtOGI0Ni0yNjFlMGJhOTI4N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvPi5iRdw/MPn8upCkAghuzlBZz72cfm4ZGda0wiCll+d9\nmHPVhz/6TDG3x1cLuUgf4KV70kV0elZ90K4+3rtMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPFv5IM9FjBqez6ibsjAE4DuL\nlckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJwdtLgP6T5lw7ASdGZwDW5PnenhcNLEEcezzSFOrI4tAiEAnsDDIxAq\nCb+Zhqm/GqB1AszCaPIv6a7Hv4IkvnLOoHg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAezcSX5TyvcCEEDeDlMVO2hYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjYwYWJiZTItZDQwMy00MjFkLWIxYWUtMGM5MDM5ZDZmNDhjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQ0NmRlZmEtN2YwNC00ZGIxLTgwMWMtNjQzZWIzMWEw\nMDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESqrbyKr5U4hrNyZUOzAvMxmw\nrYc9f409l9Bs4Pk7PcIFrvKhmIL9aNrshJmUWeJQxxTAIpChfu8vbEnSs0fLJqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7DSx4GZ+iLNyeMhKsOhISuSBRlowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhANZDoJYi\n4fDFvGZpCfQQerXBHBZJLWdwLu6SgakmA4NnAiAmyWdAC+kCTxGgZZU/RWz1OQmu\nWXwcMQylgHI2XfZZ5Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc348", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `348` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAZaN2CVJwCQTwzcaLSvF2TnNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyNGFlNjc4LTkzNWYtNDExZi04MGQ2LWFiNDZjNjU3YTc2YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNiOTE4OGUtNzUw\nMS00ZDU0LWIyOTktMDc1OWI3NTAyM2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENzJAapRlyyU/eA+52v41rCAn2cbQz6K/kyhi7oGcsVfdPrUv/MQQjKzd596h\n71tExkItqIsgvwVYUC7Inxi/+qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4KOI9NgUmGTdw1lgSyqzH4IPFk0wHwYDVR0j\nBBgwFoAUsl2rzr8cdd0txw4BGXZw05AyMREwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQD84NOX0W4NZOScDW2+sKcymtM4LA/bSVeBep3b+1vovAIhAJup\nGD2zZygB0ra3AgS4qnobVZBuuz2HfG+d4jNFNgEi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASZeNYfCz7dnY1jguuGS90jSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjRhZTY3OC05MzVmLTQxMWYtODBkNi1hYjQ2YzY1N2E3NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQknSCO5Xbf4Y7LYbGROK4jae85mY1PnJoW+FnxyL+wOVLM\nRkWZvSp9MMFCKxd/KGtrjcds1sh851Nzv+U2+RKlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsl2rzr8cdd0txw4BGXZw05Ay\nMREwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPyIy5wV+upEEECtOoyXxy+lQokIG8DEuZyIjKTAIlzcAiEA62gzL9ts\nJ0j+iI12v71jJ1MM7yMjGLpZBH0ecQ3DO/E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARz5idBHS3RLhYWNyvK7dMn2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNiOTE4OGUtNzUwMS00ZDU0LWIyOTktMDc1OWI3NTAyM2QyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDRhMDllNWUtM2MzMS00MjYyLWEwMzctMTU2ZjhjZGU3\nZjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/QaMHF3k+qB4FFnO/qTCN1v4\nT/em6nfu3gHk5FhPMfDkVEGjeNQJmwoP6KWbpuv7OFSevIN9myxtziI84VsfraN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4KOI9NgUmGTdw1lgSyqzH4IPFk0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMpVW+/+\n7kcsvFL9vaAHNmn1AF8BMDXrvZ9m9TVd6rDMAiAMRwGYi/zH+YFRmnmBfYzddj9G\nv8R+tsI1roE0n7Ykmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc349", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `349` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAcYx0F56tOZ2I1DpsfcFao+1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZWE1YTNhLWI3YzktNDE1ZC05MTZkLTY3MmRiNjhjYmY2MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RjNzI3MmMtMTJm\nNS00MzRiLWJjZWYtNTc3MTMyNzY4YTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL4uuzZzwNg2a1q4VD33Z5VmJs4++/Hj+eTKZCttU/rCq3iiDKlow/d0KAekh\ngz5mqBkKulQ/VIOfgyMrH8xm/aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFET35V1P4ytqyUWIWEgMy7xBZZlSMB8GA1UdIwQY\nMBaAFI29PeyC744MOJedYRLWr/kIHRDHMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA3sN+aPN5+DAcXVzegpQU6zsnEv6PAkjO\nfOfzo3d/2LwCIQD3xuSu04hMXqV+Y882q7zU5l9LNQXwgzn5TAt+92tsSA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZahnFjgUL756c2w1+J1Lq1MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2VhNWEzYS1iN2M5LTQxNWQtOTE2ZC02NzJkYjY4Y2JmNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2LGx0/u2Jrov1s7R3QyhjvsN+FSFzQi2va2Y6KjC4QNO0\njj1rIi25nfZKqov+SITZDVKUfSCZDccN5iAUIERqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjb097ILvjgw4l51hEtav+Qgd\nEMcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfeG7iPhOSF4fDyXIB52lDPUej/I6wNfIrGlWNLM10i0CIQCLgIn3DnYM\nUwi1KWsbnvqoPEcf85svbQq382g7exjXJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISARTfhLU0ITAsJSlU+JR+QcCJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RjNzI3MmMtMTJmNS00MzRiLWJjZWYtNTc3MTMyNzY4YTc3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmY1MjAzNzYtMWNmMi00ZDA4LWJkYjgtYTYyOTVlOTFm\nODY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5OY23zS0xk+hGEAmOD+XhttN\n5Fz7IXI0tDNAJw4qrWrNnr+Bb4tDPKPInMbBnIg6mQra/NCq8Hje2OcGrB4RnqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURPflXU/jK2rJRYhYSAzLvEFlmVIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgHvnE4zjL\nHExIUwtTtGIt3YoljF6a+Hr8yHDdQ0wxyEwCID3Akt97NDyWmjKExEvMx9n0Ul41\naF68JJhEfe7uDcsk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc350", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `350` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAcI6CtzIVsiqUYkKtoRsYAfmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmYjU1ODg2LTA1YTMtNDY0OS1hNGI1LWQ3NTIzMTI5ZGRlNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGMxNDUwNGEtNjYy\nYi00NjNmLWIyMDktZDcyZGU3NThkYzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcA9dewztGGuf4vWh2Ev4bs/snuiL6xiZF/j0okZObcHeAmGxNLo8io2Ysz6Q\nDBlUZOjGzq4h4Gn0JX25J5PVWKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiV+YOym0iSuwO/K7ki3+k08P7Q8wHwYDVR0j\nBBgwFoAUYzvp8oCpUuu2c/A8LBGgMl2oSiUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgB7MTucNv8CIX\nZKxkko+Y9DMSgQ2Mf41fWeZ6hD42ZiECIG2qyYNQXZFkiG5VgBHKjPok3aOg2E8L\n3kvvbD7w5mL5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXUh2G8sImibj+jUENFpa2YRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmI1NTg4Ni0wNWEzLTQ2NDktYTRiNS1kNzUyMzEyOWRkZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGv8hzmrmWNpQpg3vfIdPtJPAhlZQ3guM2TzeFxP6h0R4U\nmapKRbDq3C4dXmUlYv46QVy6cYcne+HON65uHuUQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYzvp8oCpUuu2c/A8LBGgMl2o\nSiUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXyBZ67AvLTs7/Met1MOrxQozSiedJ7x16FLRYgugbNsCIQCKPz3a6wu3\nsufi40H3HBgVep/LBAc0m37aIqEHcovXwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISARGn52toXMZD517xqh3698ueMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGMxNDUwNGEtNjYyYi00NjNmLWIyMDktZDcyZGU3NThkYzhlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmZhMzQ5YjktNDFjMi00OWRjLTg1MGEtYjdiZmNlMjY2\nMmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMsPWDMXsonllQYiscAyV202d\nqROlf8tKoow7oH/tWCOeXULEfv1QpKFn1G8w+MUHlT4Rq+OoKnyhnUwp9u0oqKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiV+YOym0iSuwO/K7ki3+k08P7Q8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgIphGIeqQ\nuo1KlxfB+bV7PJP47bw1dbx9K9rOyX8sGCQCIH49xz3qynIUiLKWz5ALKamvIkUz\nN0sy5SemrxLo+4PI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc351", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `351` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVK8RDGz87gaFnxOkyDgwHR2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3Nzg3OTgyLWMxY2YtNDhjNC05NWYyLTU4MmUwNjY3NTUyNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZiNzk4ZTktNGZi\nZi00ZWViLTlhMjItMjRmNjEzOTdjMzRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMFmWhECxWxh+ZAgj1ydg2BeOkSVU+qPmhvYIn3Y81psFoBGyUJo9pKZ5QoFM\nYHLrNGvhTz5x5c6Ez9zQAVgEI6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUldJXmUOXG7NBE48A/sn7MJ9MFFIwHwYDVR0j\nBBgwFoAUDgjuT6rswzW5FPtAc/dsHubk5UgwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgHcUhL4feQYUj\nUp2urEVxnt8Vbgz3KHjeAn8UKyX4bYgCIQDPOxf33DVbVZzy6d3yRB1o/cCZ7F+h\nBu481BEs479lqQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW+rbV5acDBNX2n32Q3Gk14aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzc4Nzk4Mi1jMWNmLTQ4YzQtOTVmMi01ODJlMDY2NzU1MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBJXuTiitR27qlzRmx9NeAR/WUWssWf/kR/WMOfLb3L+vY\nak/OSajcRc7soEc2nE7sLhLtOUf4j7kMG6RdvVCMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDgjuT6rswzW5FPtAc/dsHubk\n5UgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU8Xs50TdxlfYus3lBGPTSwDC+OajNTM7vBuUQBa12ccCIQD/MphIwbDv\n9WNl4/gB3h0DZ3ERDqYWpDuXLQS/AvePvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATdcN1DW3+Njo/UlD3uLIvTKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZiNzk4ZTktNGZiZi00ZWViLTlhMjItMjRmNjEzOTdjMzRhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjc4YTIwMjgtMjNlYy00YmY2LWFkNzgtMjNmYmM5NmFh\nNzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExTDNyCW9aQC8rbSfrD8dp2z2\nqQVDklvZrwWQO8eknf5qrgrlNR1YTpi1cCv4sg0yMQkhc9n+O4n4X4xrDhTlPKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUldJXmUOXG7NBE48A/sn7MJ9MFFIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgHyY92tPN\nAnMQ479hrPpSWzqaVdUVfT7Vt6tmEgU3Ao0CIQCvSuiOJZxvxl6og4PKccpfgBGa\nQr1dRxGam5WvYMP1EQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc352", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `352` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATmjNaIndyOxbCXUIPMf59Y9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5YTRmYzg0LWU0OTctNGQxZS04NDJmLTY3YWExOTM5ZjM3ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFmYTk1YjItYWE5\nZi00MzhlLTgwY2EtMGY2NjE5OWQxOGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESLHt8dWsgjvjoMRzHOA5KzV/cGurYH4oQotfCol0zqe1UFNewEGTXkUvgFlc\nopfE9DTgrV/YfRVnYhUJA6vxz6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxodiZyfMB+kSBatT4C+t6pKp7OwwHwYDVR0j\nBBgwFoAUNjfiVpwAgCccH3OJepI1yX5CTsYwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDaw9XKzXYX\nd2p+f7kbLxGHIxYADxpP/FZxOPya1vIqTAIhALNzVH21lUGKxyP0Ruw/fWMQGTGt\n4tlqX6axnFaqoSvb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbkI+VH05Zput/1lIz/YnHVSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWE0ZmM4NC1lNDk3LTRkMWUtODQyZi02N2FhMTkzOWYzN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1NcuvQpeDfoKCjAsMgVSMLrO/3MjjhzgwrfmTMidMg3DO\noL8GdBr/Mz5IA29EM7JiNhrvM9Uz8T3fu50HkDWjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNjfiVpwAgCccH3OJepI1yX5C\nTsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ8Dn1OakGW1X1fYewic37cmzGvnzZwwtw/hlh9ydL1kCIGI7JE31QQfF\nwgmQ4rTgBO0q44mM+0JMsx4RuU+IXyIb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAenxoa8B+lbbUxh3vecfrQx2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFmYTk1YjItYWE5Zi00MzhlLTgwY2EtMGY2NjE5OWQxOGNkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDEzODFlY2UtNmZmNy00NTBmLTk0MTQtOTFhYzc3NWNl\nMTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPP45wY/JeeLUawosIWGt+Hdi\nrT58+oMtFtjHaNPpkCSgsbTxxdMUyEgy+RXdfJ0VHMh3W4inFMuk8bLUa6j+IqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxodiZyfMB+kSBatT4C+t6pKp7OwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIq4j1Yt\nrEpnhv6srrf0goscvdX56RPvs6K0gHcxv/HOAiEAxrrAmUPGwYR5PEjzDDAnrhcB\nD38VB6zLi/fTBqT6cbI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc353", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `353` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQ9SJVdmkn7bSe7M8WyzJ/U9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2OTMxNzk0LTcyZjgtNGMyYS04OWY3LTFlNjBkZjgyZjUyYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjNhOWE2YzctOGQy\nNC00MzAyLWFlMmUtZjZjOGJiYTZlYTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjuWTZSybBpYeanR/nLDDwAW/mIw4UPqNLfbPFZv8+ORL4qDOCOYth+LIWRjZ\ncd1hQ2MRgyYDkgl1o9j+cMnsD6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUimHYsrw/HXRDzzK2UKodDc59E5IwHwYDVR0j\nBBgwFoAUcVXBhUqKGZzS4WUbXxBX1Ogr7YMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEWvUHXDEBqnXsSAUylcSsQKGPMbBaPS2g/0kqgxwXuLAiBxcuH+8cPjzF+h\n+snjA86RvJYjvOuJrgDNVGqXM6lzYA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYXR4nOkhc9qxYy/M2O4ucLtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjkzMTc5NC03MmY4LTRjMmEtODlmNy0xZTYwZGY4MmY1MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmc/jwUaQVUARyf0WiG7ETYJNbX9JTGredmdkxMJG87kiw\neqnJTGKZ6GFJ4QTA9UZozCGYOW+gIsTUAjo51MzWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcVXBhUqKGZzS4WUbXxBX1Ogr\n7YMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEHDVADP6+joPcsLnx2VyVxgEIrrj0CTWU3Gk47+GnIkCIGhCyoIi1gSt\nqKUoB1F3q7yqeejR0gwDet2RGmEiF3ZX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVzZ589WfxrBVQ+gnIV2ltKeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjNhOWE2YzctOGQyNC00MzAyLWFlMmUtZjZjOGJiYTZlYTdkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWM3Nzk0Y2YtZDRlZC00YmE1LTlmMGUtNmIwOWUwNjcy\nYTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzFX1c2pJ7BBCjIZu2LXthq+W\nBU6NSxSK3rAq5vFsFqw+A/Cfg2UkidW/OnKCBhQXVgLuYZ2uIVUaYQ1uCgAJDKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUimHYsrw/HXRDzzK2UKodDc59E5IwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgY5JIobFz\nCbNSEyLITU7LZWuLlQmJiRfkUlj7VXz+xKwCIDKrr6YLP2hpdCgklC9z/J3PNuP+\nNvEUu47BVPrBCQFq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc354", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `354` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAViMs4AJFTyj8JbRBv51t0/jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1MjBmYWM1LTZiMzItNGNhMi04ZDVmLWQ4NjZmNjllODhjYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNkNDBiYWYtMTI1\nMi00ZDZiLWEyYTctMDg3Njg1NjkwNzFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn3ChkGzGqEkczyHbcaZTZxVuz+fl4Xy6RROL4AjSgB7Yt7MOBidJyJgrZzXf\n6OfqZIRvne3Eyy/MzND/Kv9sMKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ0plCbfT1C19sWlgM39u3NubfcEwHwYDVR0j\nBBgwFoAU+QHLuKyW7b2rKEULQKELYGj88+cwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDttI/CfyPSYA6jsdN/18K8vvWoDBHBdTy57fqOHtVunAIhAMCeKgHOTnm0\nvgdVZl8qqPOz560ezMCbVrrpKvDd4C4d\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYwO0eq3U02oLhi4buSkqnsPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTIwZmFjNS02YjMyLTRjYTItOGQ1Zi1kODY2ZjY5ZTg4Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQH0o9rDKBapz9yc/C6J6QT7Mnkv7FzSbeaKreEvv7run6V\nYcde9ZdBREKUCe65dhkFROXqulELrgInF2AXt+X7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+QHLuKyW7b2rKEULQKELYGj8\n8+cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALbbpNVGNIQIQUsRQB4LDp43fLZyhR0cHSEEB0ca1mQOAiBn33mzzMDn\nCUlVcJewkMVS+EVfMltbxjl2c6c0Igvqew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZsEVcYVtJedq3KRiypnzIUkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNkNDBiYWYtMTI1Mi00ZDZiLWEyYTctMDg3Njg1NjkwNzFiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDNiNDE0YTEtZGI0Yy00OTI4LTkzZmUtNmJiYzZiMWI4\nNmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmgo8yVKjo5NjMFV5ontJFkHW\nxjuC2er+d12xxBB8Uq3717tC6zPu9JsGjZJgZ+YUbvCQmamJQP5qeOzEBbzdiqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ0plCbfT1C19sWlgM39u3NubfcEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJEmjApg\nqS/ryIBpXwDUxo+PJhyrGK/vue8g0P74tDSqAiEAwoZpNfARYLJPNWEkeiSwt9mR\nVzC4kPH5wkRbSCAw07Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc355", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `355` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAYNFDO4YgER3TuJfnmbKpoTaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhYTg1YWQ2LWI2YTQtNGJlYS05MWRjLTQ2ODQ0ZDgyZWJiMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmMxNTE1ZjAtNzU5\nMS00Mzk1LTg4YzgtYjVhOGQyNjAyZGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE83xMPlKe0Yn6O17VwIy/4Ww+ZIiYnzZ1XVPCbDq4iEtbBE1ugd9TlvwtrAku\n2PBBEZXjBVvULsdp8JCgjknm2qOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFjcDurQ1yWwoSmF7+aHb4IdAJIMwHwYDVR0j\nBBgwFoAU4FFWMZZMiVoV6A4BYhjU0+K+qCIwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC1\nkdGdvttIoOSvwBWxVy3TF/Cfum2uNGYSGlklkyKsMAIgfVSlOJ6vU1U18yB5l7x4\n/DPAuAGmKtTrbmTMpyQptYw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcbEUBhw19F7tkvYp0Nj+l5PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWE4NWFkNi1iNmE0LTRiZWEtOTFkYy00Njg0NGQ4MmViYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv3Zk9WUaePNASPwf9J0G4gTxUahoAIQHS4qWATqs2VXv6\nuIg/J4nDjx48cj+TnlTsPvIdlJxOj6qpntNQatF+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4FFWMZZMiVoV6A4BYhjU0+K+\nqCIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEnJQApdWF9EBGtOw0mdP73Bjxfs0/j4q3kFJPnNdD+ECIQCK11xf7fZt\niHcAehKVKnexzwOoYcsF+8OVmAVPlCQ6EQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYMekyDE8gwjROAykqW1pY9CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmMxNTE1ZjAtNzU5MS00Mzk1LTg4YzgtYjVhOGQyNjAyZGU3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ZhNThkN2QtMDI1Yi00MDRjLTk5NmEtOTM2ZmZiNmMx\nNzhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/sSwTfWRqmViI0/5e795pY47\nV1l/fFPoHZZtb336f925T/fgS6cCcQltrWGfdh9SdULd7b+XVUoOkvRfLukTYaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFjcDurQ1yWwoSmF7+aHb4IdAJIMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIga2pCIgZp\ncjl3wrPxpjKi/b7Ii4QjltVgMgMuaAEXkfkCIQDxcls0CKz/CKoT50oO5/Dd2sL7\nhVRnZeQxxjR3osSKaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc356", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `356` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUNp/2CNgX+ovRPm40loFI4tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwZWVjZDBmLWQyMmMtNDc1OS1iOWI3LTc1ODQ1MGY1NTBmZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRkZThhNDgtMDBh\nMi00M2NjLTlmOWMtOGRjYzJhZWMxMjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcAiJ5tTtnOT3kbNmN833pDWT8Z19rLoAqXoBgj2BE1nDu/w+0O+0cF96/04M\nFT58LxISaX/zSMNAwH8Dqg7VzaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxgn6l4/XNJXOjw+B2j4L5BcDStAwHwYDVR0j\nBBgwFoAUBZBeuXak+MUPGmHLWPROgMdXsGEwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCJtnU69UxsyKBYxBAM1PghIz5a3Tbs6575/AfcXiykgQIhAK4w\nPWn6Y0TcfC285xJ6kZVTJaILI1KkJoTQxHYMgIin\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWnUqixokJFfJ1Nb736VobqeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGVlY2QwZi1kMjJjLTQ3NTktYjliNy03NTg0NTBmNTUwZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMN3YL25iT7JOGohKVnNFB1UZpRReWY+73c3tHE6cSiUkS\nCY+PNaZZRB/AfPDP0+cLhQURX/+OEnesYlUodZCoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBZBeuXak+MUPGmHLWPROgMdX\nsGEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJsBC/k2vO5SAN3BlVa+uwwO7WRPoLaMfsQYdNDuyAgVAiBd0rONT6Hb\nK56IJCHVUspvGpbSAUDbQ3jDdIjbI/jJJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAbtvvYNm/tD29lNjkxosJdBRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRkZThhNDgtMDBhMi00M2NjLTlmOWMtOGRjYzJhZWMxMjQ2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGZiMzg5MWQtMWQ4ZC00ZDE4LTlhMmMtMzY2MDM3MDc0\nNzg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQGo8osXY50/jZ9PMjw+wQn79\nj5E9K6z5ieNhtzTtx6DA+hR8cEbHfpSYootcHCNLzrBVt/VvMwwp6d+vi70uFqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxgn6l4/XNJXOjw+B2j4L5BcDStAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJ5zwYtQ\njCn+7C2vWMaDGmvLDyHo9hXbvci3WhgtGpfBAiEA619ANV7an9RpvZyvsNI0Stxv\nbRiXzr42QqriwgNYJ9Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc357", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `357` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAd3hn99ndudjRKTpF61u8eM+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkMzJjM2UxLTc2ODItNDljNC05MDhhLWQ3YWRiNWVmMjgzZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUxZDczYmItYWVm\nYy00ODJhLTlhNTUtNTUwNjNlN2QyMzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGw0oiXa6H3Sg6zkDGP21XWvzTO5WsRxymPtyZphnIzWZ9k08JTiZmdP+5Ods\nzi/qv0LCzTIQhX7PpOX1JGrfRqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBOBU+ICw5teHyMI/LmIFeKrbVFAwHwYDVR0j\nBBgwFoAUJKuRK4KGuq0R+Bznz5lCF4oYZ1swOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDWbLH11Obeh7iOctGo3Nzpy/tRrF0ofEbpyHt+sYwUuAIhANzp\n5dKk09xqEYcuXN9s2O4NY+yY/jUSqkxWg0Kp/OVG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ1nWptxwx+raoX81xZTGOD5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDMyYzNlMS03NjgyLTQ5YzQtOTA4YS1kN2FkYjVlZjI4M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNS/oR7hQ8GdaKH9aU5xMcYaA+QknjkZiz1H5VNIpVWgiJ\niNOrABMSBT6dJ+eT3Lndu8nGJ4KIy+MhLN0WivsEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJKuRK4KGuq0R+Bznz5lCF4oY\nZ1swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNZyrInEcETWyDZXcJPhx4Aa8BQTAJUBebsjUDo5qLmYCIQCoV1K71ksS\nRfnYH9XmiakHjt7GOuzbvzuQiRJG+rdGrA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZT3812yP1zbBeDinHgzpsE+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUxZDczYmItYWVmYy00ODJhLTlhNTUtNTUwNjNlN2QyMzczMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY5YmU4MDctZTg2ZS00MjU3LThlMWMtYTVhMjYzODhm\nNzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExAjwuuIgcW2kpPuLZWGJqVhs\nhEPPqu/m2Xv96bI1RpmfAr1KZsnHSQvQBXwJ9NbNgal0Y1UVdFPW5NiIE/GIrqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBOBU+ICw5teHyMI/LmIFeKrbVFAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgayDyFhsU\nmD/zMB/qHjVUu/2sINPBa0Y7ItnVbjVW3uECIAKkgJaeBBx6T7SBiAGojfE69rdJ\n7AG4XaV5d7unj8nN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc358", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `358` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAeTAF8zWeXR8aQma78E7GAO0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4NGJmNjliLTdlZTItNGJlYy1iMjY5LWM0ZThiNzhiOWMzNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg5ZDczZmYtM2Zi\nOS00NjgwLWI5OGEtNjU3MDUyNjI3NmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOg2zHaeRQIt7pkuBfphTDgGzIpldjreqzFBLoHhSpKPEwzzPVpKa97hjctZO\nMxWGwrnd7IjPQFxQ6bIL9NrIvKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQYJVi9M/l/vEr8AJ6DdUKoTyttRDAfBgNVHSME\nGDAWgBRAekW23duAIWcbhgDMKQLHYMx85DAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC0o8LnJJxsOjiyJUZge2pU9NGP74Y0\nPGDjLECezRbc8gIhAKMdnBi3II8YO7qCK7q3JF7zbIFmqCT0jw1i5MYFGwA4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcKJft5PtfTRHQIndS5BAnNzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODRiZjY5Yi03ZWUyLTRiZWMtYjI2OS1jNGU4Yjc4YjljMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/rhpqHYle95SSlwM4otbcqs6CgzWC2tRnfhyfiLaYGU5x\nHsjEe0pb/1AtPIyhqjC8PdYKPomlp2NYh3qvQA58o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQHpFtt3bgCFnG4YAzCkCx2DM\nfOQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLQDpZmwdugybL4c96+YV1q0SYkS1Wf1f2l6Xf16V6bACIBNWSLMQKGTC\nIsc5N96m7ZYcI2shcgc7RAL3eBkypSxH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVACq1Tf1BUSF+t67BTUodJ8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg5ZDczZmYtM2ZiOS00NjgwLWI5OGEtNjU3MDUyNjI3NmRhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDk3ZDFlZTktOTk1YS00NDFhLWEyMzktMTYzNTJkZjcx\nMDI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw7XwhqGsYhKrhF2dK+y/DP/6\n7uCPrl3LkDy7/1ZLO8SeIiUnsy7npYpn5G8OqN+dTc9CzWz4PDT0vC1q7KqBBKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGCVYvTP5f7xK/ACeg3VCqE8rbUQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgQGqSBDhB\nMtrFXZ+MMImKPnw6vUMFcWQnHmBiKOqPUvcCIFkgPbycp4Pfjv5M6WwtFaTdrjO0\nUz+ZvH6/wgZyi//X\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc359", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `359` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAaM8QkWJQtKlV7WNXGsYT896MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NjY0N2M3LWU4ZjktNDdmZC1hOWQ1LTg3MTRhZGI1NTk0ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc2MzQ4YjctMGRm\nYy00NWRmLWJhZjctYzY5NzkyYTkwNGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjftPv++Nl5DrtbwNHsOtFb9g9Gv87GoJzF5+p2alm+0hyG9T+gFQaPzWH847\npRLS+T0E+WvDdOl1X4aDXX2DuqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXdavR0jsSsZ7HKcT/VATFL0iXTUwHwYDVR0j\nBBgwFoAUQiBD4EvragGLLZch3fG7kl7fS9gwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHROCk91zYeP\nkiojoN57B3S2Fh6ZHlplqYH/Ub/H1kv3AiEA/vr9xPfPyTfBhzh3YeXfaxH+oIKk\nYsrVJxbGwsrvKS8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASUQWxIbptAeABCghgs9xarTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTY2NDdjNy1lOGY5LTQ3ZmQtYTlkNS04NzE0YWRiNTU5NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdMil3DhEuwEKUJIUBZFW0+1Ae6UT+18DjjmdDzWnDS8HZ\nMgQ+JcC6QbZlnP0Z320aSGbwVqzRVtqgPhIaPJolo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQiBD4EvragGLLZch3fG7kl7f\nS9gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAq0F8pWH4gaHW1P508MTfJyiZNfQrRKaQMmijrLxlRYCIQCByaQjVeTW\nRxiz8usBQceDxMFvxDG0QExL9f1qT6yjVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAeb01+LFZE4K8B9cp0M/Hb+RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc2MzQ4YjctMGRmYy00NWRmLWJhZjctYzY5NzkyYTkwNGIwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTk1MjViYTYtNzFmYi00NjJkLWIwMDYtMTk0MTNlNDhj\nZGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKK2M4FIoAipZkavPnry7j33\nsAp//jlW+3v2W7vb257KpyOjtNOLXib+legTHzzM08Fm9G6xF3rbgsK10etu9KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXdavR0jsSsZ7HKcT/VATFL0iXTUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJGRSHM/\nlL5RFdEMP4FHJuhWECV3IQSXb2+2L8D3yCj1AiEAhqJWoCFFhfVILvafvHQzV/EJ\nB0/swxvJhoi6CK8PTh0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc360", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `360` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWJnq2fWR0ikSoIQdFlDOmC7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNGZhYmEyLTJmZGEtNDhlZC1hYTI4LWM1MTMxNzRmZTg5YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdhZTY5MGUtMjI0\nZC00YjU2LWJjOTEtYmQ4ZGYxMWZiMGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETtl4WaKwXFrc+4zY/TXXIzyOLLKoAOem4xrHRbsV/k0jpfIZRLGC3RvtZm8X\nsmtsKE/s3t/5qfRa2FHcGljs8aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrIP6NSbRu98njhlsSq3OSiQ++b8wHwYDVR0j\nBBgwFoAU5E37x/bj0mEPjvD6CXYWTuomblMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIAJHdBWNcxEm\nUy1dZKrqMYqujHLkbdbsmrVX3Ykag6P4AiEAvkAAKjn4tRCiApQGrtPdCWu0u+wQ\nFpSS2A/HFyAE74c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU1w+CD5RNhIv+R8aoV7acmNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTRmYWJhMi0yZmRhLTQ4ZWQtYWEyOC1jNTEzMTc0ZmU4OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNCYhXXryczvDIKNgYfLZVe1JTjbY3dwsWSXhDzWbIEdto\nHF7NA+rc/+dz9evr4t4m+S2dhKlY/UQ6Zo1fsEKyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5E37x/bj0mEPjvD6CXYWTuom\nblMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMtsItgTVzkxcDszkYzZcj8PO1EfjPUU0dzjGwK8jqmyAiEAp4xDUlWt\nXxhMatpuxCwW/dcDpVGBD+Ff4u8U4HCWmVQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAed3Ips0lnt37RY/u4HH7Tq4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdhZTY5MGUtMjI0ZC00YjU2LWJjOTEtYmQ4ZGYxMWZiMGU1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGE2ODMwZDItYTNjNS00ODI3LWI0N2MtMGY1MjIyNDc2\nMzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/mJjPev17jX/zIxI2nItJJ2w\nNKX69j3LrAA1nzDn2jIG94Wg7frvYlxhgmIUfiOG3KetWuTnjNrkWKGn4C+7kqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrIP6NSbRu98njhlsSq3OSiQ++b8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKeB1uhX\nIbWfOzNcQQg6btg5JH9FjoM/TM1jTKa2mk4dAiEA/uVw5C7oLj6+x+0G6KnN1Ubt\n+jSeahyI/NcEBbaCXaQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc361", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `361` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAQUCsnKpcNmde8fsjXnPuYCMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0OGEwOTYzLTdkOWYtNDMyOC04ZjM0LTBmMjkwMjQzNWIzMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ1NGM1YjAtYjY2\nOC00MzBjLWEwZTgtZThiMzEwMTQwODJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEFWIroZzCt8AhTgX7JL5PNlqP33/2bQIGsoVnFvtp+u3/ttss9dk1rDjjrVq\nKSbaaw+nQKOrm6PoRgqOYx/ImKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULmcZHqoYgkY5iy+FqB3BkE8XqXkwHwYDVR0j\nBBgwFoAUfb1UaJlNOJvv19LKlShAXGyelKswKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBe8m6nASLl\nQGdroGF5N6eCs6lrTgZIZ/VTpjRGaj3qYwIhANYRZyh+MgAv/ugoG5cqjbfJNN8j\n+beiTMHLsYOl/onI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWQ/Jq4dpVmAB0aKsqRQ4qcbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDhhMDk2My03ZDlmLTQzMjgtOGYzNC0wZjI5MDI0MzViMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLFFRwp+6pIAJFxdLmle6GVjJc1kUO4meiI6bZrdvuc9ac\nW3Guv+OxBn8awDwMOvkV/IvotwUrZbBaRO9xpcejo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfb1UaJlNOJvv19LKlShAXGye\nlKswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgficjdCG2WzKVmKN6MmpBr/s/v9Ynrzr57oJA0GOjrJACIQCq+eerqPp+\nQ3NBiiP8gvGrzF4WGeGZyz5pCgN6kPJYRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWg+R1c0Y1/roUpBlyfedAC3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ1NGM1YjAtYjY2OC00MzBjLWEwZTgtZThiMzEwMTQwODJiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTc5ZWZhMGUtZGQ0Mi00NmQ1LTliZTctY2EyOTQ3ODMy\nYTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1gXjPxdW+yAC5T4HiNg9QzHU\nQINGYYdiLbFgwyIx3YIM3kPBmBoMZbNU5MzR5fyCPnxOZApqJjOdj5EKR2Gjo6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULmcZHqoYgkY5iy+FqB3BkE8XqXkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgSfkrUqm4\n1gJ2gODmi1zjpmdSWXOMX/hBCtJEdSVYDCYCIQDkm2XVNnlz0MgYsk7NyavsZp3O\n6CCiQ4ZWZtqMB/IN7Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc362", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `362` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZ9bfC+kt87wLgLKzEzpjoseMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NDhkODQwLTYwNjUtNDM3My1iZDQ3LWUxZDg3MmUwMWY1NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RmM2Y5MjMtNzEz\nYy00M2NkLThiZTMtYTQzNDExYzc1YjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqyWr1JAAmfAFAAV+JfAuhBWANzrdBHQDa800YDcLKEY8hsiCs9tX5zQGUj/T\nFSepi5dJ4uD9R5reCJ9MZZobLKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpbnUo7OpsMRRlQhMcXNPCHRY/N8wHwYDVR0j\nBBgwFoAUO9N3I1aQs0V/UwcRYy2EPzS43LIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA/aMunEvmXAqf0WqRANJT22ajWADKK9/eWsFAUJ9hE8ACIHH7/R4257Jk\nga5oXq0cq9hYQl9/n87I4AFuT4rwqQ9/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcAUK9jOOGc/uObkWH9c0Q/1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjQ4ZDg0MC02MDY1LTQzNzMtYmQ0Ny1lMWQ4NzJlMDFmNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeSZWdkzIb29W8HJQMyjBG08p+qMJKzwOx3rZK3HsQE5kh\nc94yfxh7PbqyRZ5fj0i77WZrZIbn2j+2xXK7BJImo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO9N3I1aQs0V/UwcRYy2EPzS4\n3LIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ55kpI302M0E+khNaMw204Hh+PR2gV2XfBSrzHX1ORcCIQDQy7JDXFjD\nSLXsORjEQS5orv2L27RHP1pUK4vSeX9WWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAaXbipqN/VxSNiIdGhgyYHuhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RmM2Y5MjMtNzEzYy00M2NkLThiZTMtYTQzNDExYzc1YjI5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmVlMzE3MGUtZTIwOS00MTJhLTk3NTEtZTg5YWQzYjI0\nOTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2Y5vQzdOrlxVQSN/M/oL38CJ\nJbFkjK94Klk8MAnOoYEDuPgs1B5nnn4ea5KXLn6Ptc/WvE2tiOZxioQxKC7JbqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpbnUo7OpsMRRlQhMcXNPCHRY/N8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgTUDSgreE\nHbFbspmbblN5BrPaN4qGQjDsiv9V5YBGKR4CID7/tLdq11XOw87bjIdHEN6WG3Lv\n0pKAa5ILIM9rvjdY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc363", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `363` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAeMbE3gaQ8jhmijv4tUAr+6nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkNTBjYWQ0LTBjYTQtNDgxZC1iOWY1LWYzNmVkNWQ3MzYyYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZmZDg0MzAtZGNl\nZC00ODdjLWFmMDktZDY2YmFjYjRkMmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK4+F0zob0YiwofR3D+rzdfmFEKKLBigsZH+y9ngzR0H4Sl3Ot67JtnG2Rrl9\n4jjfpsnr5+Nck3HsyQsL9v94kKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZXYbxnZG2U9b+yBc/NVvt0bDKF8wHwYDVR0j\nBBgwFoAUlkDashqOK90PMIqVGZHCk7cGAJ8wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAsI7FfsvOPjsR6X1FwSVbbUPZkcyU7L5N9O5xamTmKyAIgItnj3Q9TMyBu\n8PXJWNWWbO0K8pnOX04hN/nmYg/R19M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc9B03sFsSQXTN0CHYfLmM8EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDUwY2FkNC0wY2E0LTQ4MWQtYjlmNS1mMzZlZDVkNzM2MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXa35PyMYZDu6sqVKuTZkAwHVcrFCKNJMZoIPJeFv5vsJN\n2zSS329qN8mDo3G+XyFzeV8RnxInR25H88KkgEO1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlkDashqOK90PMIqVGZHCk7cG\nAJ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANMezd7ESr9lPtpR7Z7l+yVyz0Di4R/y01H3/yYBl4VRAiBOodfIOD1Q\nsWOTSkeF6CdAFkTJuD4V9F4KIwBQIk61/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASB5fSwwgDmhGIqQ3rWeSIk2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZmZDg0MzAtZGNlZC00ODdjLWFmMDktZDY2YmFjYjRkMmE1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzJjMWQ0ZTktOTY3My00M2ZlLWJiMTYtYmQ5OGQwYmI4\nODFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiEgKzJyGPVKcHANdsEuydn9O\nQH0i72TNnOYPYZyR5IPlq3b3j/SBXSEXI/4qN2vvYhUx1L+vcwH95L+dCWaZQ6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZXYbxnZG2U9b+yBc/NVvt0bDKF8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgbeh53Xiu\nDEUkksn2pXtpQ54EUpnbjpFNtLLgtxB3M68CIQC7Eevdvb6aiGGLLq7tu88XpKAS\nw5KwXWf5CMgoYESYkg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc364", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `364` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISARO0woEvyJ0rAMVBvPMLb3QxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyNjU4NDYxLThmNjMtNGE0Zi1iZGQyLTljZTFlNmQ0YjEzNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFjNWQzYzQtZWY3\nOS00Y2VhLTg4YTctYzY3N2RjZTUyZmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESR0qItGlfm4s/go1GHqCuPMYXze6Sag2Dy9nlXPxO15W0lQn6WneWnuN0Wr2\neCwgBdDi816EDQO+8nHDPN60q6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA8HzLvi5pwLFEgCNf410dhB+jcUwHwYDVR0j\nBBgwFoAUmIzJmrjVDU49OgTFgM7NWn8r2MYwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\nsHdcpnx6Ab0pgoLc6X2ZaFnoIvLz0jU8PUio4BV3AtwCIAWMu59KdWp7mqpd3Pl7\nTDTQ8jXKoxf3tAubd4bMBHUO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUBGj8tRepd2mppRnp5O1CDTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjY1ODQ2MS04ZjYzLTRhNGYtYmRkMi05Y2UxZTZkNGIxMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUTLWxvQ/te37n3nxu+M4OSA5YOP3ZtfIB2V6WoJC4/QQt\n9tVF2c5Wm90KKWqQUB5L5z0kv+5X7L3731x9H5qbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmIzJmrjVDU49OgTFgM7NWn8r\n2MYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLxRV9wlFok6/0fO3l8MVr5VLFj3cJ/7ORIZwBtlgu6MCIQCFTpXtTtnS\nTmutHhe7CoFIZZGlpK29pYdoKl2MgXk1zw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARfV0qmA9o0RIeqCMmL3I2+gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFjNWQzYzQtZWY3OS00Y2VhLTg4YTctYzY3N2RjZTUyZmJkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmE3OTRmMDAtOTYxNy00Nzc0LTg1MGUtMjdiZjQyYWJh\nMjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbSX6/te1fimv7wsorddDHx1b\nYKMrNdwLTkB/dEPMKNXceNEJeVf3O7mj1Q8zrcYfLrbgF7i0VKln9YK6ed27iKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA8HzLvi5pwLFEgCNf410dhB+jcUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPxTsSh/\nn0cYMeCHYkUgF3NMZd+eFnmUVQaw5+JGhdf+AiBTEesQLND1uXc//OIcZgJgHs1R\nR0e4Ip7Cg+XISmMz1A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc365", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `365` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAXVqVxr6to66Qks5lt79MkU9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxODcyNTlmLTRkMTMtNDlkOC05OTI2LWIxMTJjMzA2NDBhNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk0NjU3MjQtOTg0\nNi00YTI1LThmY2UtZmU2MTU3MzFjZjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnKt2VRAVZLVdfKlZ708EmiqhZkgauYtGmeQyfjeLfyKAvDirJ5VbWG7zn8TI\nkURCjjSJWn6OClypZ173LdOCWqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMjTWJYH62zAgjE32bQ+Ro6MSw4YwHwYDVR0j\nBBgwFoAUcndoRGrkZp9cfghpmtXGJ600m1EwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiA4mDrmp8wQIRP9ETzXAlel0ysNNxLeO5QeTs72Uh916QIhAMMk\nmPQg+ugYz9fUlTozrUzlTm7CECQKza9/oNRWp/DU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWa+Ibc7zMAKHfUam80xU24FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTg3MjU5Zi00ZDEzLTQ5ZDgtOTkyNi1iMTEyYzMwNjQwYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8NllWAv3AoTOcEUtwceL8O03W3pYcEOBT4bfJ0VzFvGQV\nsQWXxg5OoeELk06XrmlLC5YlhflDx+n4AEUFuu6Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcndoRGrkZp9cfghpmtXGJ600\nm1EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO/HeQa/g75RBMGDCjTKB4iORAY5ajwFLJB13BVUD1hkAiEAkbEyMa3I\n5JidU63lIoNtCHy+aKwaUnXmw+Wn3ToWdOU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAT/1/4fQvlECV0NH7v7lNzNZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk0NjU3MjQtOTg0Ni00YTI1LThmY2UtZmU2MTU3MzFjZjQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2ViYjYxYTAtZWFkNC00OTIxLWExMWEtZWJkNzRjYjAz\nYTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqaj8ajmTpYVwLjySyEcJa0dj\nRVXR64iMXscXvfXa/YPw67uzWJrBfAebbCa9SjE+gOzO9R/TR3xH0B8Ykk8GMaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMjTWJYH62zAgjE32bQ+Ro6MSw4YwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKFgCCSq\nPL8FqMwojzXNbreW1HlMfOpFvivFCIY0hZIuAiBBOgMCjRKh84Tfx0j9FeDwn+0Y\nPWJ4ZRDR29P/gcN2Kw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc366", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `366` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISATVu9H6jPbverJxA1ox4w+SkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjMDFkMTc3LTY2YzUtNGNjMC1hZmE4LTQ0NWY1YWExMjEzZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NiYzQ3N2EtMDAy\nMy00NjFlLTgyYzItNTZiMGQyMmIzMjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE4heAcwgUb81Sj4rd//Nha+PGlBChCwcweq+PpdDIdglLfqDxkKtIz5jzU5O\nS7M1RXzwbrO+KefF8YWOTCXSRqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/7vfcKa4KLNRj7sAyk8pXJA7/iwwHwYDVR0j\nBBgwFoAUZHKd8zldMAEs2D49NoWTFYqOgoQwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiAK4JiupGF+m3gUVw4/FOl4WirIMLm1Jli6sfzZrBdmpgIhAPP3\nOxAmfIcHVf8Q8RKgM56klTHLupmQRKEuUEAVG49l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc5OXS5Nh1FGZvBDQI8BB0i4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzAxZDE3Ny02NmM1LTRjYzAtYWZhOC00NDVmNWFhMTIxM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYESOpKMFVY9BN+7e7qK2uVLeFNdcAUScsj1IyLcIyWY+s\nYOq31iaDuaYUzVjwJSeL1LkWXl1QaFaAWLjeHVdMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZHKd8zldMAEs2D49NoWTFYqO\ngoQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgALeZw3Bh2gzfSNKhacT56f+Ngkhov/DXpc3x5GXF/QUCIBZ2WDpEH9Yc\n8orgg3hDsiG89zByaFMZ3iiFBHqQO2j1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZy/4xwyCsBEYuKsKKpUj+kNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NiYzQ3N2EtMDAyMy00NjFlLTgyYzItNTZiMGQyMmIzMjg0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjVmMGM2NjEtMWUzNy00ZmNlLWEwYzEtODJiNmI5ZjVi\nZjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV7jWwYcZlW3kNMxHTfTV4oEH\nmp54SB8ovC1BLBHsEyq0SIOmkOvJRWscBxe5mKo+gXa5VM9Bq12++UdVTeswPaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/7vfcKa4KLNRj7sAyk8pXJA7/iwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAO67YwXo\nDppk2NYndlrcFjwIR8tgqEBfWb51JzLB8CoRAiEA8kOLKPcDvtvllCBvqGZ749lC\ncXo66ELIwW0oOWHu7fE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc367", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `367` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZzS2aipSQmZ6wPomxK6iHH+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4MGFhOGQxLTkzM2MtNDJhOC05MmRjLWEyMmY4MDljOGNiMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJkNmU3ZWYtZGVk\nZC00MzYxLThiN2MtNDFlZjVmZDFkNmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGor5MiOgompUa/Iz5qWDnt5etk/QeKEFJIO2QZwTSSO88YR2do9XLM8pfRQE\nNOzKX6O2guyZRG13AfkNRaqapqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV5KI3iq+vvfTjPKFF3FSBLg6qbAwHwYDVR0j\nBBgwFoAU+WrQ8T20sBnxUh7YqWDUJGXSOPswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAs0Al89jx9R1e\naM4LAw68q7u4bJaJBcT87oTTMNAwt8ECIBx0dv2G7xzJRix1awLrYFhi7FdePO+2\nGwltnoekqkno\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd1RluZ950LsN5GfmxGp+K1dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODBhYThkMS05MzNjLTQyYTgtOTJkYy1hMjJmODA5YzhjYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnzPQQy/rqbOHJfZ/ldQXvgFQeU3Ero9iT5Kawn3a2yBWv\n8Io1UuGywcfbpWxdaaIpGLGCM+t6h4gEvpQLly+jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+WrQ8T20sBnxUh7YqWDUJGXS\nOPswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgevKdxjZl/xZRSD5jk884Rqg/tuQY/mtJZsVg11L8SYECIF3py2quVbk8\nLrhDhdYY2h8TIq5i3gC6Zvbus4pU4NR5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAWGt7YL2hTjj1e5B+WgoFo+MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJkNmU3ZWYtZGVkZC00MzYxLThiN2MtNDFlZjVmZDFkNmYzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmY3NTA3ZmYtYjc1Yy00MTFkLTkwMTItZTc2MjMyM2Yw\nYTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZvCeWQM6ixIV4pP5VScuixKn\nFTxqdT75aTNkCdGqky3bHE8qTsjD9UTz8T9kIftNXUTpA4BhmssKCurrdjbuFKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV5KI3iq+vvfTjPKFF3FSBLg6qbAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAO3g6SPo\nRdyc0RTMO+SXaSo2Bwwnl+mUghR7YjakGx81AiEAhfGMwtNReWFui52Ch2M480rr\n9EVE8AETH6pejq2XOWM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc368", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `368` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATPPNttkmoBYhkf5ghO+SidzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjY2YzYTVlLTk2ZTUtNGRhOS1hMzIyLTZhODBhMzgwNmRkMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTRjODUxNjAtMjg1\nYS00NTZjLTlmZTMtMjFhYWFiZWFjYjc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgczA8MqzpSyoQNq5V83tSM0Zq9BlqMz5qvEMBGsUGiVmQ0xr/GNmdaKTWBYh\naeuCnWFMXvxQEEZRbjQTz7EM+6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOM/rAZyhdiZbOlt9+8Arlmd9VnIwHwYDVR0j\nBBgwFoAUghHHme8CpUYYX9dbGXffNOYZhoQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAYMoyri0RXrExjAVbLtF0JjGwbSBQp8v+K6D3QdqYZCAiEA2Z4dWXXFVxqI\nF6eZAkK48RO0HlvPJPDXY0ek3rFo5z0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWgm8UoxairG8T2k4+veao27MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2NmM2E1ZS05NmU1LTRkYTktYTMyMi02YTgwYTM4MDZkZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhVKZwzNSuG5IhryuoLfkGb059/haLgXE0kDH3/y9csI7K\nUtRaOAhQtpNvxbPL57XyViAeG5OeW4M+wGy35TDIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUghHHme8CpUYYX9dbGXffNOYZ\nhoQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGeKAXjWh3czL1sac1jqZr6zzhAYjoLvdLXArKEfqJKsCIHawNTkgF2Ox\nVxod40PyIN+LKdDEU6+DVDhAZFx0yEQp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXei6PSsxDk5BKljIaddIso1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTRjODUxNjAtMjg1YS00NTZjLTlmZTMtMjFhYWFiZWFjYjc1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmIwNDY0YzEtN2Q4Mi00MmViLTg2MzctZjMyZGRmYWY0\nZjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7YxEd4jB6QdvMgN4k4k0GeZC\n89mdWW6DEo7aQ2zSuN0IL7yUHTY3kU1iRjrYhtHxyavMeRZKRe0q14lBLl92haN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOM/rAZyhdiZbOlt9+8Arlmd9VnIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgQDxvQhoD\nTP5pnsYLPBTNP1nTMmGuPHSqcxPiRXpJhloCIA+cbmlIsY3eFCXpfU1pLXkbdnw1\nNgzX9c59OuMjpQDw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc369", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `369` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAY0k7avUNKqDoIkLAK7CqJ5eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiODhmMDM0LTcyNjItNGRmMS1iMGRmLTY0MGQxZDE1ZTU2MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRhODI3OGUtNjJj\nYy00NGE2LWFhZjQtN2ZlMjMwZjZjMDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGV4Y2YZ/HljlokPWkaZW/Kcuq9Ovhwa1ZWdLEZ8nbVhbSvii20cvD4O5G+DM\nLVazqY+472nwDC2ATSEbfFedqKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoYeDrBTH5mf/HlYQEqwSv6bQ2uEwHwYDVR0j\nBBgwFoAUFcdMrwLMZqzNzVVEexoHthwrxuswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHYqqvSpTApDVenWTr59TG7/eZIzLMK1up/IlJKJ4uJIAiEA/nzWlWxC5A3P\ngVPkKC1w+cNUdlXoGmkMynANJlgcFgc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVG37MK4YNCbwXdWImQTj8GuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjg4ZjAzNC03MjYyLTRkZjEtYjBkZi02NDBkMWQxNWU1NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASff9z2irZQilD7fajq77ONyvqKlJBdGAqLmIuU4lX2G9Wm\n7TmQgP5tyOhBT4peRvOTnCYc+jK8J+pr+XZYou22o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFcdMrwLMZqzNzVVEexoHthwr\nxuswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPEK12CaphET+JEyOr1GjLixs9QX+MIJM7/d0zBE72huAiAlsTONn8IW\nBvGWSvpv48vQf8Za7drme4vtezb+B4Uekw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATmkyf7lL4ZjA1cYGcZGXcjwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRhODI3OGUtNjJjYy00NGE2LWFhZjQtN2ZlMjMwZjZjMDU1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2YwMjM4NjEtNGUyMS00MjJhLWIwZTctNjQyODJiYjFh\nMWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg8c8kRmVRVJbAFmV7zDbmX4M\nGhYLT+zFTz2sYIuwh7DC0cmXHJjZbsaIc0Gi43nrX44p4c05jYeLgfKl1PPo4KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoYeDrBTH5mf/HlYQEqwSv6bQ2uEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgKCXkLA39\nXUAd/8pXhlf/oQB2ak2tNxSU/4v0m6XCtB8CIQCA1vt2FILzAhs/3xPXV3ydyEoy\nB/cg2+36PEoCKOTjGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc370", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `370` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQraPFRRfBivaqZgSgljO/M8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlZTk4OTUwLThkMWQtNDUxOC1iNDEwLWI3Yzg4NDMwZDg1NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWNhMzU3NjktYTQw\nZC00MjA5LTlkZjgtMzUzMjRlM2E2NTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJZvNXMz2aPBFgOBn2p6hdxKaKIaMCk0XcYPDv+rp8ILRIdAE3FOD6JvlpJJN\nyLvVx6RNHTF9s4y4SWbQciRFoaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU71viQvlm2EXYueLQK/6/yQfitiUwHwYDVR0j\nBBgwFoAUGz5HVnZEEQ+D7fr/ocSHAEOpSEQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAtkZffuZ7lxJHBYsm3xc+AhJ8quvcjDqohhwKfnYSCwoCID54fxEWhs+y\nfyF6hnGer9dFcMnJX5O/DtvKrwjUq+K5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYk0hEuMra8oegU2eMmf2y/xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZWU5ODk1MC04ZDFkLTQ1MTgtYjQxMC1iN2M4ODQzMGQ4NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHBkcNgm0tmrs5DUG6OczNCiITEdeGF1mxu9z6R85YSrsl\nYEXb1UvFNV6LzdgQVugmKeynrvkqJrNAUIjKwgnZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGz5HVnZEEQ+D7fr/ocSHAEOp\nSEQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNhUVrl3VjGr4Zn2hqcSRj/OFLEGeChndJAygFznBDZ4CIDYCpnR7yjB9\nqoM7tYQzlW8XztMSGof2QK8CB9amwdiW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATAoTGoiV2gFPq6rRbsOZdDjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWNhMzU3NjktYTQwZC00MjA5LTlkZjgtMzUzMjRlM2E2NTQxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmJjODIwNWMtODZhMi00ZTk2LWFmNjctZDNlNGM0ZGJk\nMTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdbY2uJ8w26tu1BJ4g8R9nak4\nNr1I+aJQ6iIRzgOnVRGrAG+MMENlpnHVQkR6ds0uux2VBUYOHCVN0xZRxrGovaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU71viQvlm2EXYueLQK/6/yQfitiUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgIxwBMCqI\nIN9J+JDFGJmc13RwekywjaPovdYsU03jWwwCIQC+bySBg+fLZvYzH85yr5tVvtA8\nkKxG+qeCoS/n//Ggig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc371", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `371` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAZH0kfRNLG+Grh2FQs6Rb02IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkOTBhMDEzLTQ2MDEtNGVmMy05MTcxLTY1ZTBjODc5M2ZlYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgzMDgyNWMtODc4\nYi00MzhmLWJhNjktYTBlOWI0ZmVkN2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa0vs8QDQAizUq0rP/c01o3Cy9HGfr8/zKc0BuWah2XkOKaveRU82zvKGTxLW\nrF56P4Lh/qtJXcmriVKMwVPofKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpo5Jw8VdXGTrxFvO2Llpg3/DCzIwHwYDVR0j\nBBgwFoAUBNl5WMccAsn+khwtgFN+I4WY/4QwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA0YZ4eNJiYyMxDp0luMP2ZkRvIK7SOuoj7K2EOee8\nDt0CIQCVeDRqsL2gNgr+s+2/ZD+sQuEzf5XAZDzf2vmDqmYaKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUg5E9wNsXwnP499Uy+wjQCpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDkwYTAxMy00NjAxLTRlZjMtOTE3MS02NWUwYzg3OTNmZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtNgCr/bLf0CWap/9h0Ts23h0wzIgNpHvqJzRI/hzWiz0R\n07RZHyMNZzfmumPjEuMpFvrbj4AxsUrvnU1t6mUMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBNl5WMccAsn+khwtgFN+I4WY\n/4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWQ2vLEtJEE9NaNqo9HGyE0dhxxfXIsAySRDzHxa4nP0CIQDHENz4j4bL\nDUsmCOfXMXrMVHJdrsOzG3Zu+9H4U/A9PQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAd9GlV6vxKB2QTRhJRTZGZpjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgzMDgyNWMtODc4Yi00MzhmLWJhNjktYTBlOWI0ZmVkN2Y4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZmYWEyMzItNGZiZC00Njg5LTg1YmQtZTFmZmVlNjYy\nZjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOUVuXL/Y4XC8eHl0k5oXmQ54\nHn5wsueCQyGE2Lc87wNKCpbsSmdqGZOJmKDHX6YXO3rk4sNgY4NUlHh2UAspdaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpo5Jw8VdXGTrxFvO2Llpg3/DCzIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgM+hLODNn\nRiYkmW6Pc/1E6f9Cdr9EMKOlXBuwfd0u5G8CIDcGAXl3I7oDwf96mPBVMjGKDk9o\nviqdRpOmsPplrcLs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc372", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `372` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAakkZwylGAC0QhSVKy6aWacdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlMzI5NGZkLTIyMWQtNDFmZC1iMDIzLTg3Y2RlMTZmN2NmNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRiODYwZGYtZTMz\nMi00YTc2LWE4N2ItMzY0OWYwY2UxMDI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEulXmLIagL7PHwotPQXa+f774BB//XXe4vaDCbN25k+TWqPj1fC2z2JpimFH/\njHB4h4ZRhYnDBAEbdMrdZ4ENNqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmbB2T4eeQY8/XYjl0w6/lAjPTVUwHwYDVR0j\nBBgwFoAUmcJ+/RavCPXZGtYfvsEFTeNgKjUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAzzJoIz9U4V6KpFzxzkGzBkjKgVt6GWBQNeSm8KuP\ndygCIFuhe6e/Xqr9TBnV1IlopLuYGbiSEGHsNtPzs8Ybdqw8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXQiwl93pOLaIRGFgOG2CIy5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTMyOTRmZC0yMjFkLTQxZmQtYjAyMy04N2NkZTE2ZjdjZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0M7kKOqBRIvbqP8cw89ThYFk80drzcF69G9Ml6ruZyLZ9\nO7L/7Xtvb+1pa8DJO+RqVpUT6iPrcUFeJ9qua3nzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmcJ+/RavCPXZGtYfvsEFTeNg\nKjUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM8kgXduQKFAPPmBBEDc9RVthBbXm9ox2aDh33mAkUK1AiEAsC/Kdrdi\nNj5UChnaEv7U95bibT9Aa7pBDrhEN8i8CFc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXDPC+3DIMA34WaujH+osUe4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRiODYwZGYtZTMzMi00YTc2LWE4N2ItMzY0OWYwY2UxMDI3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTg2NWE1MzYtNTU1Yi00NmJkLThhNDMtOWQ1MjIwNTYy\nOWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjWyV5AMXOIMz/ghTIMi6n3qj\nKjYG7IgeL+ECmkcR7Y7yQ+tMxgU221rT4ZSy6cXxKy0SHXpMsp7/tAyKwKUozKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmbB2T4eeQY8/XYjl0w6/lAjPTVUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgZjVyQxpL\nb0ujmJNMVbJpBtXICuPiUacpTIsnz0aFtPQCICxw7IUSp0jEKKceV613cGajTAGE\ndupQKJOuZ6FAzcI0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc373", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `373` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAU685JQ6JSbqDZ7cN2JdUxLNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYTk0NzIwLThhMjgtNDI5Ny1iMjVmLTNkMTVkN2RhOTVjZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY1ZjMwZmQtOThk\nMS00ZDQ1LWE3MDYtZDYyOWEzMWJjYzEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmU9rvimv92VnS5dibKxf2faA0Z9JvDtORBSvtTGo2ZquLnOm+ZhunkDLxb4+\nJAx1P7R2Sp0ovl+P5AfR4QF0QaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeSzCnmxIk1AUuLOsWXqW+ufz0AEwHwYDVR0j\nBBgwFoAUv5E8HH6Jyn9Bf1B0cyPNmlGodbAwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBUDsb3ZS3rUHfDCm68izajOODWkxBTsihsgXChvH3StQIhAJrY\n1xMjjtIidk3lDhbmUlf49j1rl+xRbVbYRL52PL6R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWbVIGby012oETMvRiiJq/YzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWE5NDcyMC04YTI4LTQyOTctYjI1Zi0zZDE1ZDdkYTk1Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwHdWa45iy08Ujen8cp/pinAP7SfWhCLemeAaDLzdTnfuV\nCTz3C6Wf1nUQ/Je/uWWJ9ulklb0/yScgskPk2Fuko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv5E8HH6Jyn9Bf1B0cyPNmlGo\ndbAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJaawkK154jO87Cp25pe2M4QmbUvWUl7pW5kINUdSZ/sCIAjN91rSGIEq\n+epvsd3TLbXC/C4mPq0ovQEq+/GAy7hC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASJ6H/2qcepWTcA9Fd1d0SKXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY1ZjMwZmQtOThkMS00ZDQ1LWE3MDYtZDYyOWEzMWJjYzEwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGMzOGFjYmEtZmM0NS00MjZhLTgzMzQtYTg5OWM2NDNh\nZmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY1PEvDvTRcDlMiSGKQIEspHk\n2DBUOvkBlfD9/jJuUbnxM415Uo/gLN+pOgHpYuJq01A5ZWSO9JWDHS/d9mICA6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeSzCnmxIk1AUuLOsWXqW+ufz0AEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgJPUv7pM/\npQaEtXXrPQ6z87Wga+jYDHopgytvOf16UCYCIBEjJOOtiID/3R7a8oUMB6n+riNT\n35YA/Y0Kph2EZvus\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc374", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `374` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAYBSx4oEAZ7qmowKGy39z802MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1OWFhYmI1LWExMGUtNDg5Yi1iNzYxLTczOTFjYWYzOGNhYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdlN2VkOGUtZTVi\nNC00OTRiLWJmNWItM2IyMDVhYzQxYWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9kDU/gsygB6rexwKlWexVjsCsBM+P0+wvJt6mj/+3OQssgas7ktmTMtzW5XR\niMeJL+COCOVUMT9A8Qlk4FZu9aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS1EI/7HT8EVWNaHGHXk8IJc0fK0wHwYDVR0j\nBBgwFoAUaJBnZx3fr1FD+yIwV21DEwaDwbgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBeE+YpZWH1ZtpsUHRF76nBaz1O69j7EUX/\nRjQ8XxxcewIgFyOmbt6hDPOOHZEO6IoNcwCV42a4CuUCLStMo5LRje4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdb/qK9l1DRq+c5S1P9Vo3UIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTlhYWJiNS1hMTBlLTQ4OWItYjc2MS03MzkxY2FmMzhjYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3RGtlv05CFK/1eqtULKTVzm0c0ybyeEWhipruZmsGPZa7\nGiYLEQ944CHbuZMdSHOpa03O3+9ObH0BD2joz4VRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaJBnZx3fr1FD+yIwV21DEwaD\nwbgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY7cFp8siWF9JfD5DeZxWgRiO/DPHkvAOlnyeLF74OzICIDJTzjdE82es\neAYDGxbZQASupHgG7qWenNiJ3F2V2a0c\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAc9NT5mryNMKcrLgf4J1LB99MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdlN2VkOGUtZTViNC00OTRiLWJmNWItM2IyMDVhYzQxYWY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTk4YWEzMGEtNzdkNy00YjQyLWE0NDAtOTMyMWFiNGM2\nYzA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEU6GNmvpF1Fof5krzyybVFdot\n+V4obxsuTtUlkqX2c2VL38NqtYadbUCS/P+3EDi4k0QldER7Aa9jgE0LKg6T7qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUS1EI/7HT8EVWNaHGHXk8IJc0fK0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAO4YMQGT\nLSRTYG1Z4Lh6xnDx4Xf//OjUj+uFQIuQANH6AiEA4pDnebj7QoXdgNzrIYcPdwP9\ntqZArjUZclxlvVJu0MY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc375", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `375` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbRspSIBzdlve8NznQaRIPujMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MDQ0YTdkLTg3ZWYtNDMyMS04ZTdmLTA2MmE5ZTA4NjY2ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhiMGU3NzEtZDcz\nZi00ZDljLWI0OTctMmU3MmFkYmZkNzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkWyMH/FOxfrtQNvBqduzZMgWYwdI0trPtUt/rV7wyfBQe+GQO3vW2OIAiZDP\n4/Dc/hkyjpIyN26o7eliQn6cC6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI70ETkxSI+yX/D5haiVWNwgNu74wHwYDVR0j\nBBgwFoAU/YNxBZ+GzV0yfURjMFrxY3eUWNMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA5yRaNQ92Bn/UyBy02W2WWnSNovm6sAuZ\ne97myIGhQlgCIAdhddDNZD+S23XqS5K2TTWguujLvLrbwspaIiYxIKQC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcChSBSuADNnBImdPpPmGas3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODA0NGE3ZC04N2VmLTQzMjEtOGU3Zi0wNjJhOWUwODY2NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARC4Z0Z93F6DrjZH8ZJYDbbkKyRkw4rmoI8rQK9OmGxFmDX\nOO/NZDATpTzutCUs5jsh9E8v08okg3+Hx2toXc2Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/YNxBZ+GzV0yfURjMFrxY3eU\nWNMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIdxzbmAnm56qb+frlBe6bpnFbNEtS8J0vw3lvCycwKcCIQC+yRko23Ur\nXUIzUEmtKgkn4xb/G0YsoiTj4Hiq6afoGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAR60WVYTmpheAkCTSuGvZTI7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhiMGU3NzEtZDczZi00ZDljLWI0OTctMmU3MmFkYmZkNzJmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQyNDE5ZDItODM3OS00ZDFmLTliZDUtYjkxZjExNTVl\nODRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEASVKvO1xzJSWpInmaImlvdPb\nAUp4gcaXdtwZRyuxCnlo7CrzSD/ki3tfPQp7MpX3UHwpyiT1yV3l5MIGufiZ/KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUI70ETkxSI+yX/D5haiVWNwgNu74wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgRcdpYPqr\n6OmWjjnuPYtuqvNub3DGTUR8XkZ5Qlrs7asCIBo2FFNkZUMPUMnySXtCxedly47t\nbEdqeXzgdPhCzFYw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc376", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `376` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAeOiUsYrd7EKFe4wnm+Jle0HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxN2VmMzdlLTk4YTctNGI5ZS05YjQwLTllYWFkOGIzMGM3NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI3MmU4NzUtYmY4\nYy00Yzk3LTk1ZTgtNjQxYjNmM2I0M2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3YygNqAYESjKFM5qaNeZi3cmoUAUEfla/be4yAy54evGUntj6cH0WKGEhRJ9\n0nIbtAZvkailp6FX1c2T7Ow8rKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvfrntUi7QSj5QnM4+DA2K4+XVWgwHwYDVR0j\nBBgwFoAUR8xr1JAAEdYbkbM+eSGkZ+GIEeEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiANbuv4cBlfvcJh\nmmY4kUUN85KWqk2bU1FY4Spsj+QPkQIgNxIG3ZTZqGK1jxRmADIZ6JLVwksF5rP8\nu+J3QaB1ldQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYgedrPbiAUdB7ahqHS+tIaIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTdlZjM3ZS05OGE3LTRiOWUtOWI0MC05ZWFhZDhiMzBjNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+w4ENgYI8XYSNK1oSzPOl3zed5Tm6P5vaGpsJaVyrzQwt\nM1iv+jmmEzZSXjpp6aOKS5fmxPDVMB/XqGpB89Qbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR8xr1JAAEdYbkbM+eSGkZ+GI\nEeEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWlOSzkEEqJEl5WD8PBfXQwMlzX0B7dEjD+y+17vEJaECIAWu6L92LFcH\n3jTvlgjazECOGVZcy6AXii/otaFFY2WM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAalaRSMPoWXXEF1G2zfz6L4uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI3MmU4NzUtYmY4Yy00Yzk3LTk1ZTgtNjQxYjNmM2I0M2MxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzkyYzczNTItMTIxZi00MjU2LWI5OWMtYzQ2YjlhMmI2\nZmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaN+6Pp6qvJaYrgD+LgOJNLpk\nSNUiVLm/r0UNV+vdfY9M6gBaoVKcBt0eqzd5NeLJWC6I79QzeHlOxZtOiVp0dqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvfrntUi7QSj5QnM4+DA2K4+XVWgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgM0kbuxAv\n2j/OP838H/5201DLqekToZscyd+Nlrm/J04CIBniElNb8BLYp5Ct6pqpVR/uwlMX\nbeA7VQGttbAMbnM2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc377", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `377` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbJ0hiIF6sFfeS8Rrx5CpsjoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNzc0N2RhLTMxNmUtNDk1MS05NTlkLTQxMzFhYjEwMmNjNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQxMmNjODktNmNj\nOC00MGNkLWFjOWItMzQ1YWVkYzQ0Njc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES7+xZvnKC68INQRIAovO0nxibQguP95o/lis84d92cAfxHpy5h/tq6Ur4kz0\nNIUq5xT1mTOpmVtlJISqDua5yaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJJNtaeEZjyfc+o2aOlFNl3CrfscwHwYDVR0j\nBBgwFoAUyFUielXu9n9lhiHOYfUvR763Uk0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDTXslKX8+fWU9SL8RldCEuUOnVnpO5HLIfHdXnYIgYvAIhAOGQ7yDNpxso\nyIi8Vgs9RW+WW6yAddXsoVV7sJRKG/Iv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAezhJiaeMT9Mvh/RXWdXNIy7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTc3NDdkYS0zMTZlLTQ5NTEtOTU5ZC00MTMxYWIxMDJjYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbIB9YE4yFX/mVMJWgPURmTuER6AYe0gNODSQDVwLzEBZI\nLt8+OsLH+k/pxKCZfuUwGlqb28N9d8Yu7u70tmM3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyFUielXu9n9lhiHOYfUvR763\nUk0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaCwf3lXgrtkq7QEhVV0wqnzJ6I7TrLNIIzh5CIePL4YCIFtrB97ctJSb\nJsRMmzlzqu2Wr0uELduCebk/rtX6z5sT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZWkg1B2ukZ13abMz85yJka5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQxMmNjODktNmNjOC00MGNkLWFjOWItMzQ1YWVkYzQ0Njc4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZiYjcxZDUtY2MxOC00NDQ1LWEwNDYtOGVkNDhlNWY3\nMzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBqQmxVERTrL92LeDUCpcGhye\nKtlnl+YhOg8qxjU7QOvjI9Y4ydlesHBtSj0BYP18zcfgBv0vnUmDOQV7Ki9F/6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJJNtaeEZjyfc+o2aOlFNl3CrfscwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMG56+7K\nsRcdgiiTRQn+Yr5cpeVrGSi3/q0nvzOJ3UDlAiAnq8RHL0zZkuCDxJaCyhmdBx7d\nnVKqAPhDcePAxerFhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc378", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `378` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQjn+R/KH8U0SWk7N+c9NQTTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjMWI1MTM1LWM3ZTEtNGIxOC04ZDQ2LWY4NjRhNmRiZTFmZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY1YmFhYjMtYjA4\nNC00YjI4LTg3NGQtYjJiYmIxOGMwMmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI0Ur3Yqkv8DQm4wgsvlwGOJ4ATPlBUjFKBAp7XcJeyjct+u52hL4CNe9wvqU\nWhwBKrdRrL3HIZzzlMLFFTFowKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDdgUUuVQxw0ZrAlMah991nLSMQ4wHwYDVR0j\nBBgwFoAU9OGNDzzFn8ZDWbHEQrmZCYcv29kwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCrlHQfel/irDhsNNG2zo3puOn/wmtP4BLIgn+9o3TwpAIgRVQWlMkVyayO\n1WKCENWo0ygybzkPNpPDgruFSTN2TrA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcOKWdo+tBU/x451MmnoMzLrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzFiNTEzNS1jN2UxLTRiMTgtOGQ0Ni1mODY0YTZkYmUxZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVfYMTrPlnhUspp/1L97rinSLanMRkFxjRv9Ef+UeXWjD0\nNGPxJi2lBT3W/JqbkLOwODHZ0JqPw4tSQGm2ydeDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9OGNDzzFn8ZDWbHEQrmZCYcv\n29kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALZttIlDx4wE3JEMUaxZEFCSbO2/CAoS6J87BYfN0OD5AiBqX25vUNGO\nktnOhJK8Lj351C5quvSKRI9WxUPlxDG5rQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdm3QHgzQE7wJ+85KMil/0IVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY1YmFhYjMtYjA4NC00YjI4LTg3NGQtYjJiYmIxOGMwMmQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDIzZjQ3N2EtMWRkNC00YjU4LWIxNGYtODFlNWUwYmRk\nNDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpWlFbDE70SAeiaCH/XQ68e6v\nBvPDV6YsxZ9BIINFFaourlZLeN+ESoNMhhIbCqfD29PnmsX86El6nxkMc7Ph6qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDdgUUuVQxw0ZrAlMah991nLSMQ4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJodDZzV\nmxYggixCSJPEWuZ9G1/OYmvuD4lH8GDaT3fuAiBR5MLjpSbnEnEszRmGtTZjLXK0\nA6MhKZng2iE6oqfJsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc379", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `379` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdEZfooIBbNEqHibcSKJRDGiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MmIzY2I2LWEyNWQtNDhmNS05OGZmLTM3ZDY5YzgzNjEwNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY3Y2YxN2UtN2Uy\nMC00MjcwLWFmMGEtYTUwYjBhYWRjZmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd7BgTQljpZ0EAHqGvQ2iZ4JNYxjQRFPR1279X/Yitfb2GUYWqUw8eD7ZKosN\nG3/ISI6CJImjsnTak94PpvxLq6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHl520wx/EAx8VfcLd7/33H10yxQwHwYDVR0j\nBBgwFoAUShgFMuNRmIBFaJnwCLBpylHoG5cwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAvwDyEhPbex1E33ZKor7Qag2e98f48P+Gnpx+FsNrGjoCIFgfZxncznAu\nTuCJiQ6oF80NWftCOkX/IdDbYzmVTri/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ/VLXbUC1AzsT45bvRgPGTwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDJiM2NiNi1hMjVkLTQ4ZjUtOThmZi0zN2Q2OWM4MzYxMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6Iu+MKmOyq5eVGXmaPZo2vEs1pYfcxNxJkZmw7+7+rUO4\nSpOrLetP7C4dAuBlmVkfRYI/j/SE1+fm46ZQiUDto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUShgFMuNRmIBFaJnwCLBpylHo\nG5cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO6IZyHP38nXyhNYtwB/pIo/tmygScIRgNNeXdV4MjaQAiBRml3sCFA4\n5j6YPaykgv1Xrvjhe+DjosRSjD1rDOeXgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAd26aY+oEeMjphNCYGWlizhbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY3Y2YxN2UtN2UyMC00MjcwLWFmMGEtYTUwYjBhYWRjZmQ4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWUwZDZlZjctM2UzMy00M2JmLWI1NzUtOGMwZjcxZTJj\nMTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeD+egISgoifPDYhmui6Icz2H\n+H8MwQMx+NV7XU+0drqB0FsX/a3UBN2bAZU5L6AgAlDxbvuFfuMd0a9SDYEsKqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHl520wx/EAx8VfcLd7/33H10yxQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKCNoKgJ\n5LUrjxgPeDzNcIqbwdUIwgESea5XHRR0q3/YAiEAySTK4mxBVHHwsuJZYJZYS8tz\n/s4TJKq08j43UbYjVOw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc380", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `380` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISARDuErvnw+gw98z+QIvot/HrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ODU3NTZkLTYxMmMtNGZkNy04ZTE3LWU3YjYwMTE5ZjA0YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg1MWZmYzEtOWNi\nOC00MTY2LWE3MTgtNGNjOWQ1ZjVhMTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErj95eQYToM6LB818ayLfMqSUGypj9rVRROiz8t89wAKyVNZRIlvHkwWyIp3y\nFoQg1BSYBLZptUdeZjcqdTwkQaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJSFLiNWlMTZPEE2vIvxmb+l9JEowHwYDVR0j\nBBgwFoAU1t2QiublxtpoR7BfsEyakhaIKcMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA3fc5Rzd2rL8pGDNIYT9Jx9mVjjlbWsjCdZ39gBQ2\nFlECID/HfPVjQaYVQpolaKXFOjBVkMltn7H2eRoNdUPdAHkx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAegnONKI2fQt34ZpP/EuZN3JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzg1NzU2ZC02MTJjLTRmZDctOGUxNy1lN2I2MDExOWYwNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThEo6gjBRq/rxhgBa1bieVf6jBaKioq33kMRx2KWcqIxkL\njnqLG9E5kkT7/Sl0JLMBdsk2REjHebYfw6mmP8E9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1t2QiublxtpoR7BfsEyakhaI\nKcMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM7EU5RVhotllFZY8lxYRNAXiuewUNW2KwJLmZl1s6gVAiB9l++w+rmk\nWSKpF8S9Xb62kK0hFS3jSYaDGgXUqw7p5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXKMJlSG+n2rzlrrkqR7ctbEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg1MWZmYzEtOWNiOC00MTY2LWE3MTgtNGNjOWQ1ZjVhMTczMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2RkYTc4OWItMTgyNi00YWMzLWIyYTgtNTJlYjFkOGNk\nOGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL9MLFIqfQNSa5Nwm9K62Ipzr\n78LQZXQ4FK8hH3Ft23PmTrwl3A4gqyp/oxdH4FoO8gRBkIfKryfdcF48jPxSOqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJSFLiNWlMTZPEE2vIvxmb+l9JEowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgc8B4fw4T\nxQCh5Zp2nJ6GYm0Cpf3uebHIr+FbY6lLLEwCIAbK/Jq4Z4AjWvEErovOXi1mK7hl\ncc+qN9yuKwsIs+iR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc381", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `381` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAeiBW/1klpHlrInGKj9e85LgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNmMxZjdjLWZkNTAtNDA0Yy04NjE4LTlmOTQ2OWZiODdkODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjkyZmI0ZmItMGQ5\nYi00MmRlLWE1OWEtMjUzZjZiZGIyNGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEax2HqBoGnbp8F/s0q04QHzFexxrkW9wDe1d/d32HumZRIUIsmpo/OwT/Kk83\naA3YYj76A7WpBUUsgADgQ9SDO6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEA4cnroZ9FGbJ79Md3u/73aU/s0wHwYDVR0j\nBBgwFoAUelS5AGQ/Usc8CLn1IeOzuMhGDNMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiB3LdKjZOdYqqCJ5E1SoVafCMBrLxc44nM4OBbiI5DG\nTAIgPrnxjAg9LsO5wYJVPlkaLnoZazeCEO/Kps8K/jE/q7w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU6lKqNtl2GTr5o/kaEqjJxVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDZjMWY3Yy1mZDUwLTQwNGMtODYxOC05Zjk0NjlmYjg3ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIQmbCuyf6DV0x8jJC/0bDXi2D/mUa0nx6eHrP2lpmugOU\nM2+NwGaNf20moU/FRCzZLHn4zMrs6py5A2LnYcHBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUelS5AGQ/Usc8CLn1IeOzuMhG\nDNMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANm03Pvp10MNrJRO4wO98q27HspHOzab6bQ5tPpTsmadAiEA0nfGacOm\np/MVn6F5xOcNMPjrO4Spf2h5VflvMlLMNdc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAWljTxSghSh4LPkw1Yr68u80MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjkyZmI0ZmItMGQ5Yi00MmRlLWE1OWEtMjUzZjZiZGIyNGQyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWUxZmMwYjgtZmUxZS00Mjc1LTkxOTctMTljMzA5Mjg2\nY2JiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEICZ1HDcmHFPUX9M0UJhEJEgh\nXhEMRnp2a99RCfR6RdMy9BTmNZ/TSutDx/Dl3vyL2hkbltYPfahSC2PHS1P8JKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEA4cnroZ9FGbJ79Md3u/73aU/s0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgQ39R2dS+\ncMGJc1H2Mq/1HEln1+Hyk/A7k67tce0uVzwCIDrQOB25CDsUuLlEFGUu/MHmBCTF\nliJtGO9yqDZtzMHF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc382", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `382` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAUBemkZwmVcVyOCVcNDx+rh9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5N2Q3NjE5LTM2ODgtNDU5MC1hODFhLTQ1ZDc1YWQyN2E3NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVjMGZkZmUtYjEy\nZi00YWM4LTk2ZjktYTE0MTBlNzI3OWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvl3uVApCFDMmHgXIORLCsR5vLzuO92HmYBEJUpBlSaUPV2Xf93H9W37XWVS1\nfl1w+jzBLR5FlcbFMTuOHsnWq6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFJBGdSiCq8eDLobqht8gSKq+RuowHwYDVR0j\nBBgwFoAU89DuAGs7kBJrt9fWDvRFDaMf+94wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA7qF0wH1wNWYO2W70BL/lRGDJ0CqRyPKjjelGa0rGPnwCIB6X\nb9M30Y20BU05ekIcBr/6G+YRMhSAips7z1ECcpbJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf/jB0g+LwN6KZT92cWnC9J/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTdkNzYxOS0zNjg4LTQ1OTAtYTgxYS00NWQ3NWFkMjdhNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1K4RDs0X6IQDX/LxvFzkE54SaGBksVcRIFIrQ1N9nCtON\nbHV8U3XCKKh76inSGHwwKjNKjy8XOkXPyNW1foK8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU89DuAGs7kBJrt9fWDvRFDaMf\n+94wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgevaZa+byOEcN/XMzlEfOBt45q6zKydZ5G2oD6Vm8SCcCIQDUSbDKhWT8\nFKLnY0eK39gVAa9yeYHor4ufIS+drb0CIA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARoT2SdRxc9xQgEDkiNLN4cTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVjMGZkZmUtYjEyZi00YWM4LTk2ZjktYTE0MTBlNzI3OWU5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTY5ZGUwMjEtZTk2Ni00MDllLTg1OTItNTMxNzdjMDYz\nNjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1S2ls51O8f+lCRLzf6GFrAzK\nQ4s+HokObG0xsO3nEBgTrDRAfF13m/PVvinIesO9CzVE6w1qLOLmzMGpNKsnwqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFJBGdSiCq8eDLobqht8gSKq+RuowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgJaFmclHc\nrA6fVUbQmZ97tlqufVCzu97Lr1qZ9XzYQbICIQDa3uVc9DyunhjMsHDDgyI3fRqu\nBDZv9qv1IY26stFWNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc383", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `383` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAYli80NS7Ldp06WgDZh0O4qRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YWZmZTE1LTkwODEtNDRlNi1iMWRiLTJjZGEwZGQyMWFiYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ5ZWQ5YjEtNGJk\nYS00MzBjLThhZTgtMGJjZmYyYTczODg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIoak50bHCG8jKfvVQIXDScYiUbTC4PPj+YuNYuvHaip5BFk6KEqIA3A/yYuM\n0yA3WGMmPGMklmx7KLArE1WwtaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ySotVstkVDk2JyIWxnhtS0/XmAwHwYDVR0j\nBBgwFoAUA0okgU1yGeV9g6vQElNSDtO2GUYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAazA5Si9/1nElhkqHL8xznxU0UwCOsIg6t\nRGEOLqJZfAIgW5glBdzCTgb7moP8HQSs5pVVcpPXNLG9HnOjAROVpN8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASahwvKmIObaA2TaP69XxcwFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWFmZmUxNS05MDgxLTQ0ZTYtYjFkYi0yY2RhMGRkMjFhYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJXV2I4FfWgthIjEJX7iPka02c+cg7j2Zidc5EZj/ZLaCC\nRCCjqnCs+DNEG7zsHdKl6RIsC5DHOrYqTshs5JS1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA0okgU1yGeV9g6vQElNSDtO2\nGUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO+qp98UZF6nI4yCEtbkXSpmQtbiJLOugWNsLB4dsfECAiBkvaYW9K9G\nzNIIo4o7zgGfGaYQeqL30SvEvhoptQqkzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAapXZFyZ+s3kZOCGmv3aaguBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ5ZWQ5YjEtNGJkYS00MzBjLThhZTgtMGJjZmYyYTczODg1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmZhNzk2YTQtMTE0ZC00ZTFhLWFmNGQtMzIyMmI2ZjY0\nM2Y2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElHOPvEhfLHvfVZNwA/cWHecg\n1eXJzVev+vaXbPlXDL6+bXGXosT8A77Ge6P5X+p5Dv7r1XYDOBvQyIGrzHggoaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4ySotVstkVDk2JyIWxnhtS0/XmAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOcIkeam\nhfLRMdUpVX7MVRz85xku2gkBlulFim9232e0AiEAisp+Q3kdexFH96nrsn5RKkij\nHY1Jb5mw0nzISrQcGAA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc384", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `384` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZIqP8PIc+xAmwC0fp6GfNbiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNDUxMjZiLWE4ZjEtNDk5Ny1iMWE3LTlhNzQwNjRiZjk0ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg5Y2EwZjgtYzE2\nYS00YzRmLTgwYjMtOGM1MWNlNWY1YzZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWzxLIm9PQ7PBBdKvmXoC3+in1g8pMfNQZ20OZs91fVWarv8AaY/JAUB5ouDh\nZdePsaP3yFOx0LR0OW+jdHp6nqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh0hZgCS2O7O9iXjQB5Y2hAIygnEwHwYDVR0j\nBBgwFoAU93i+gJhbM8eUdfBI6tI2MkhW25wwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA+Y///rGVmRJ4tP+cgNiyf8t0shsSGBSp\n5O/i7UOwoxACIDRjuQhtShsSFT1jli4/xz0g+GtkXUAG/J0TncluBZfj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXca15ViqTiQqel9MwebROGsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTQ1MTI2Yi1hOGYxLTQ5OTctYjFhNy05YTc0MDY0YmY5NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuJ4vmEpbEPq9i5lEwL2JgXBhVZzxzDtwu5Upclm7JNlcn\nTRRihwgqawDKCmYON2YZS8UIL7VlmzCTn7d2TogMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU93i+gJhbM8eUdfBI6tI2MkhW\n25wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgenbwjPXVx/oCrgKx++/vQnXNGRmWax2nCX7Jo4wfqncCIQD+D9P9dKIO\n2l2Q8z5lW3160ZNFwRcIMf2AQXD9kdKTxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISATLOt5SmKWYjKnEzBj4eUU84MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg5Y2EwZjgtYzE2YS00YzRmLTgwYjMtOGM1MWNlNWY1YzZhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDg3Zjk4OTEtYTczNS00MGIwLWJkOGYtNjc2NWM4ZDZh\nNTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEguOPU0Q6HaSRkB1DchB5hkZZ\n8kK7mtKpXjCBt2wnw0b6jHrF073hHP8w6xdDLKIcBrNYhyo58oEFSUDPrDCY9qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh0hZgCS2O7O9iXjQB5Y2hAIygnEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKVnOM++\nd9Oxna4sc1h2HQKC/OEg04AFM8cEo0vgLoDaAiEAnF214ATskuoSmBxa6Ib7l/l3\nYKICuULIomIUet+o0Jk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc385", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `385` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAbpmIVDX4y+x722AthJ3oPKyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlMjA1MGNkLTBmZTItNDc0Mi05M2U3LWExNDRhZDc2N2Y0ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM3MTMyN2YtMjNk\nOS00YjRlLWEyYzgtYTcwZTVjNmU3MTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+xu0JHsm7nuasLUnIrjvCG7Osy765xhkzY+wL8aQHs92HdScCRaPKAbDtSpK\ny96oswThPrLTREfvijDqGO6NpaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFC5jxOe+bh83mzxAXFE8iW+0QMUwHwYDVR0j\nBBgwFoAUh++Qib4zf0/Den8fbAnbAwHwW3swHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCxW4eF1CsMp9zY+LVcUhkXwRC4\n+bZik6tEL3z7xJvRMgIgceyqVv4XZTL7Xkr5yZdgvhTKn9YD8PsybmB2WiJRyx0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAenusWohGr+pkYHxBNuR5hf7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTIwNTBjZC0wZmUyLTQ3NDItOTNlNy1hMTQ0YWQ3NjdmNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyqPoN+iBhdD1TtSJwir5/NQqzCfxVZIsu9c+6ru4qYF71\nWo1Zj/lvaMSih5GhXN7ReEmlB8TEQYi16kCdP0nLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh++Qib4zf0/Den8fbAnbAwHw\nW3swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKmmKQXHQBJc1CU0uP6ug5sIxDnd5jDFsUDIUG1u2xNsCIQCh/RR3edcP\nQ+LM0URRCu492gxXMeaOQOri9l3FRtARug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQcN61+wHCYFIy4zaNB1Vhb7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM3MTMyN2YtMjNkOS00YjRlLWEyYzgtYTcwZTVjNmU3MTAyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmVkOTFhNDktNjgxYi00ZWRjLTg4ZTUtNDg1YmQyOWU1\nODY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE26eJY1z9hdUHJz43ZqBJakK2\nUpGtQSWN6Zmb/svnmik/U+nFO/K7Yuhz2vEaJuMfHZyIbxMhT0aeGKDRDsXH/aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFC5jxOe+bh83mzxAXFE8iW+0QMUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOGoJzmX\nHcQ4NyqZqfbdn3dDajlrhNNyyuGWZsAv33WGAiBd/4KL/8LSz7iwM3Sw6XnqLeXT\nf5nH+M4vmQriOXQdQg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc386", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `386` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAVEoDoDPvRaR8+wWRKCou4ogMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0OWYyMjg4LTM5MzUtNDc3YS05MDRjLWU4OWEyNDMyNmQ0MjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjliYWVkOGYtM2U1\nMy00ZjVhLTg0NGMtNWY2ZGQ5Yzk2YWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUhpTPYwpLtwzGDkvmpaSZMj9VoK1w1fd11JqEHJATaIPQKHoZqiY0fovA+fA\nkkY6tRKhxv1vgk/X4mokjTbwB6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI8htdALYBdUsLCQSZ+VozCKAk+gwHwYDVR0j\nBBgwFoAUPvYo8FFD5Nn8EcsB1RQ4K1ete2AwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAOwje/wP\nTtAiWd4AnXOfEGF2H2u1r+TLb0Ih91TrIj0+AiEA6wSxGt/v4AJQYgl7MzQAQAS6\nv9R9zOKnHiXilH1T0qE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYWXZp7Mg1ZjVmktvpHy0nZuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNDlmMjI4OC0zOTM1LTQ3N2EtOTA0Yy1lODlhMjQzMjZkNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMuOw6N8JEhhTWblBHwi45RMBnthtkZocj62gzZIjM0qMF\nKt29dwXK4gE4kdgXEFB7/JZBcl7GVF8SfNaJlM0Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPvYo8FFD5Nn8EcsB1RQ4K1et\ne2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgepmzwcw4+cVmn4kE+E5VIaBP7pYQDViKrMvJwCWsMgUCIQDNnju0MhwU\nJy1+IZU/VnlaCeYDuUlSl25ttOGjlIlr6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbOM+OJihlzogHBuzYhACsZqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjliYWVkOGYtM2U1My00ZjVhLTg0NGMtNWY2ZGQ5Yzk2YWRkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTY3ODFiNDMtYTMzYS00NDk0LWFlODMtOTAxMDY4NDJk\nOWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjQd3BFtpbe8YqR+tT37hueHL\n7pWfcMpaeo+VeCmNBMVpktAZ5QIOdJdMlrpIlArKWnDu+TKjnlhYJwCmPf5xtKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUI8htdALYBdUsLCQSZ+VozCKAk+gwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJnPesbe\n7tGt69aH/+W6qghcnsuSgUSAKU3j0+8lWWlqAiA8ct9Ry1rRKCKZhDEMs+gW4XGl\nTzBOpXoGWh/jEPRv5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc387", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `387` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAVJoEJlB/Avn1pgL7JsOTZR7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZWE2YzQ5LWI2MWItNGRhMS04ZWI1LWJjOGFlNTQxMzk0MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWMwOWI0ODMtNmMw\nMC00M2IxLTkwODktMjk3YmZlZTQ2NDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgh9pMg0FaEx6Mxzr0EbeDbCN+SqwWxHcia3t2Su4NdVDGc4Ce7Zn1kA+uSNX\nL4++pgiaczkEw++r1pbraAHJwKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUmIht16FD3Bn5CmJjNV6l6e/At0wHwYDVR0j\nBBgwFoAUvRw6HORyKt8EcEvI/AikeMDCCnUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANPYHaNf\n6ymnoANXnfgtX88e58cqjcJxY/bTPtOqjZ3dAiB3F7C4UMss6zhsHlD+PIW6un3H\nbJhdtHsh/ms7hdNdTQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcUZaieQaiCoMQMBuPRec0LBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmVhNmM0OS1iNjFiLTRkYTEtOGViNS1iYzhhZTU0MTM5NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiE+4kd9Q8Vf3Ut38FuTVR1OfAD3cG5i8TbBqO9r0Z1Hi5\n7pfYyccY68pB5g1jyyG9aCDzidn8U0cwBU+zKjp2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvRw6HORyKt8EcEvI/AikeMDC\nCnUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOqpGd00QrYw8FdY2B2f68kixlKDdHZevTOHVD0aN8QmAiEApV9NvQIu\nUoSwKnwEpM4BX68IkAnFhVIPgYxPo3rA/zg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAasoNBCUII7gbtoCLkV6yCjRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWMwOWI0ODMtNmMwMC00M2IxLTkwODktMjk3YmZlZTQ2NDk0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2Y1YjNlNjItOWYxYS00N2RjLWJlZmYtOTlhNThlZjY0\nYmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELITsC/UxBAIdAeubemHdY00M\ndH0l5oDky28/uqAKMarxGaId32vXjW4jZCxsqCPhyJ59bqrcH+JEQa9fJwEBg6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUmIht16FD3Bn5CmJjNV6l6e/At0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgdSUr7xvd\nwoHtVMJZGu7G3+iAR9b+sDfV6mYmU29tnvsCIQCD/cXHwdiWw0EkdVXUPqIVjYNt\n5Nk+ll8ofiLBvCqkwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc388", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `388` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAajAx9OgZxBtYMNkeUfSKIUCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjNGY2NDhjLTMxNzctNDhhNS05NjM4LWExNzc0YmZjMDIwNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdjMjBjMjktYTk1\nMi00ZTY3LThkNmQtYjI4ZThhMDlkMTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEighALBp1gqqeljsULR9g4HVwf1XTkeelLpYjudwnsswg8gt5mS014V9LiJO2\nEzDWFws1higBp7b09QXT0WfeTKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ/ceFkxpGfGHycJ7cVld0M2aRK0wHwYDVR0j\nBBgwFoAUCiB8fwk+nrwLgG5lxy4Bnk6+S8gwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD4g8W1\nko7+cjU4jHoTnbTKM3PbAQ/4s9iA7TmXiOKwEwIhAO8Xb0LB1YqNOM1kVRp6c6TS\n7125YFr+SkCt0gc43stB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb3Q7p7chxxvxqGjz2pKSl0DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzRmNjQ4Yy0zMTc3LTQ4YTUtOTYzOC1hMTc3NGJmYzAyMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvViGQy2DMZiRU2cLb7xsqx0xV6lF0pTTOMmLVwmVbuBUF\nKyo+VI50zN31+U0wYYdBTfI3F4fLvENu39l4a76Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCiB8fwk+nrwLgG5lxy4Bnk6+\nS8gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFKdekMMBu2xHxiZf/AbSzxZz1tkMF6ypjVxj1B51Fm0CIBx7YV8/Wym2\nc9KRuIq3DnhZGo1Oq+MYSFaBKqPvljwb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAS5a9hFK2REn9zlwMI5erqlhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdjMjBjMjktYTk1Mi00ZTY3LThkNmQtYjI4ZThhMDlkMTBmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjk4ZjE4ODgtNDc3MS00ZjUxLTljMTctOGNlN2YxODVj\nNTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMEIElJnLd/Qtex3aQrInSFlw\n9oi+jbKRDjuDE2TlOPNh8BRCOXtYDovR1LxETs+N23AmSCeuTvM3cqlgshWtuqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZ/ceFkxpGfGHycJ7cVld0M2aRK0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhALuGivL8\nzFJxz7peDGNZojK7rzITHJqAQZG0jtzcAJQFAiEA55anBqSR7gdSCFX+141grseJ\nR9Cq4wtXnnb2cXgPwGE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc389", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `389` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdd3eIZSYaxuGP4YHGzE3fxDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNGVjMWM5LTBkYzAtNGVlMC05YjY2LTUyNmEwZTg1ZDM4ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRjNWZiMGItM2Uy\nYS00MjI0LWE5ZDktOTRhNzdiNmRlYTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENBHgH+O2B4UNzeGvQj9P0KTlxPVWBLCBe5Dzi4QuwKST1oJu/bE93ixsEXUg\nuBRddndXds6nBGocSmn1mNO43aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUepDzKyI9gc3gSjaxj/7sG9BuVx4wHwYDVR0j\nBBgwFoAUZK7renFaibzsh0XXnuZhoOCJPOAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIDpUmW/VivFknkdkKLNLSL78jeEGFj6E6EnSe3zEJ29DAiEA+cbBFfhF\nvXih4S38GzqeVDVg+QE36R9XeVFES/kQOps=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZoQ73XY1kTWYtE+DSTs8RgyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzRlYzFjOS0wZGMwLTRlZTAtOWI2Ni01MjZhMGU4NWQzODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZz28h6XVKePpTWF2nUgFtyaz5K4FQDU7/2R5Ds5KVsz3G\nRYGOf3nAINcyK6aRNUFwu10L1bKKUXxgyjBWLsjGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZK7renFaibzsh0XXnuZhoOCJ\nPOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG2txQs4uiIxH5G62tYVjyFfd3jayTsAXZoNwuV3RSRwCIQDDkmQhSaoi\nq7iyWvirLGRVJQ3GAcLLhPo4OaiqTHttVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAR0WfPZsoiKKSsbMvvPdXrgOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRjNWZiMGItM2UyYS00MjI0LWE5ZDktOTRhNzdiNmRlYTVlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQxNGFlZjMtZDIzMi00NzI0LWI3ZmQtNWUwYzgwMjQx\nN2U3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY7WhMNbTE+w+Ld9U3yir3I3H\nbiP6v8bWzedGfL3guMEXfqHEIWXyhrlj7eihb2LCwSBF0riLDVBw0+nr+2UnTKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUepDzKyI9gc3gSjaxj/7sG9BuVx4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAN0VIKCa\ndJK795MIKjS1K43KHFDPYbmMnd3w+04jqwchAiEA/CxIE98rNW/cqeY0ht6MHaaV\nCtDfhurYz+TXLbiDR1g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc390", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `390` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAVWA6KaJM3FglE0aqeYy5Gu+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxZTYzNGNkLWY0MGItNGM4Ni04ZjZjLWZiNGM4MDRkZTAyNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFlNjFhYmItZjdi\nNy00Y2VjLTk2YTktYWZjZGEwZWE0MjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQjqWPyXigYZ2VdMf+sqM4In1VbSyN0uSPXDxx0Zp5ib8m6UiBs7beTADpuoI\ntOdFDa0RB0hQxXMrgPo6DrUxFaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU5cKgzS65nXezS6HIA0kYNHk0A4wHwYDVR0j\nBBgwFoAUMpGweYS4NDOoDa/YUmsOySNhNewwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDmhDopndwE3Sb3ZHAvajokNjXENnzzc8Q60kiZoeTYMQIgWHzZmbzr\nyWPL1wfz4PcqrlnjtCRmSJjTU6budX4iDQg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaSyr/GE/uvbogfocIjBdWvzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWU2MzRjZC1mNDBiLTRjODYtOGY2Yy1mYjRjODA0ZGUwMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1BVy5fISlSAyxGHywruZusG8Wp1ZHDPJXkbUlUa4+1zmD\ndkNG15QztEs5znpjD7vQOX2wOBC8T+0Dx4gPNhsPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMpGweYS4NDOoDa/YUmsOySNh\nNewwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKAmWbj6u1WRA38YECMVVJwBTX4hWMHsYj80pj2cMNUoCIQCrRZQiAOY+\n4nPnSJrdZ3Djks2TLemeP0WaaHYWH4s5NQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWobvuMY0W3er7xY4XlofjfgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFlNjFhYmItZjdiNy00Y2VjLTk2YTktYWZjZGEwZWE0MjA5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWE5MTgwNjAtZTk0My00Y2I4LWFhNTAtNzhiOGZhMjI3\nNDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXwc9wo3mxR+0O9mRIrWj3AXm\ndcDbOTweXMHEy+ZUtZj+nHMg2BNQuC7rN3BOBoXAyBV8Q4+P2Gl67gz+EU2TT6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU5cKgzS65nXezS6HIA0kYNHk0A4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMwEhXJV\n4yedhL5y11W+z5VfiVc8SD2HqnhEyAPKZY/yAiBTMJUeB9Mx9vWFoJFLucozg6if\nnL/xqbF4WwnNu5xqKg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc391", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `391` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAUE4IIhpzrvx7pjlURjpC+ExMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ZmI0YWMwLTQ4ZmEtNDlhNi1iMmU5LWJmYzQ3MWYzNTZiZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNmY2IxZjctODFi\nOC00ZDA2LThhNGEtMGI4MGNkMmIxYjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7VztzZ9rnZwTHQsyixkjUIDo+BAiQe5J285ZIUaDwJBwdRr1sf1nqg06EFoY\n26VlLd4pb9PxanJ1hWceF3MHJKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr+gcDRYxWsKfWneUuuOjQYI/378wHwYDVR0j\nBBgwFoAU3V6JdlvMcAFmzkXAm18Xc86LohIwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIGvbG3hy8ejrcMCicQ0IElLougSYAr6HwOm/yPvvilgYAiAeYcu82o+uKMhQUIYi\nkrKVNCpB1t7fKotQCyXxTkhYzw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVhltHHFGzwptaKcrkI7pIu6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2ZiNGFjMC00OGZhLTQ5YTYtYjJlOS1iZmM0NzFmMzU2YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATU3NNMsmT4qkfHcqYkxY+1a5J71GIhByfKJhUWLEs82MpA\nAzMTbiPWFtiMdHeXJM7pBG/fxnR1X4TdQ/iWVpz3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3V6JdlvMcAFmzkXAm18Xc86L\nohIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSm6+uQnFz1h2xYegpa5U6Nd+dkopdjkgHDntgpONSKsCICFCy6+rxnWf\nO2dux13CDtqzI05bd3MAblXSIbp/bNn2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAWu/xSN9ISv4t9H8ETVwu8chMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNmY2IxZjctODFiOC00ZDA2LThhNGEtMGI4MGNkMmIxYjViMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzAxNmI1MzgtZTZjZC00Mjg4LTgxYjYtZTA3MWM5NzU0\nZDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8K4eVUuTddxUuSGaMNv3P3zb\nyPr0P2zjz+vTwDzqFPmPoPKYrJvytrb3MJN6Z3A03iGgqeORWUci3lh1r5oH9aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUr+gcDRYxWsKfWneUuuOjQYI/378wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIq6PGi5\n6ERwmCuaS9twLTHu2SlblJGKSshpXN9krZ2PAiEAgtlcyiIyndviRo3d83AXa+qh\nTlexJ7fOAgj4jqXfVmw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc392", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `392` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISATLBh9MF7CJwJU//KlXkVL9pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZDEwOTg4LWM3ZTktNGJkOC05NmJjLWQ5MTRkZjhjNDFlYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg0ZDA0OGMtNDc3\nZi00MTJjLWEyNjMtYjI0ODhlZDhjNTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvlV7t3WGj0SSOMhG8nIKOA7mYtg8s8s6sef4h+8QDCcKzrfUpjMRIxSNySqB\nOE75xDFZ8XTfXwr3ggA7LzSHXKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF+LM/VyvkN0GyHO+Hucbh3uUVycwHwYDVR0j\nBBgwFoAUcdxnyyUyqmwjvI8dc7niypMZmyQwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCWJEnai/ifUSS3taA1HCpd2uDzjRLcllR7r5h3Uiy+dAIh\nAOQO/VvY0tntM29WCZM1bZOP7hPMoj2PdNPBO2zmqCkv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVdRy1YWq6hMwqnV0cTTc+ZAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWQxMDk4OC1jN2U5LTRiZDgtOTZiYy1kOTE0ZGY4YzQxZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0pF5i+Dd8q8ZdGBGdGJwzP3vsrr3dcr3UvkLv7+EI4HNd\nEAEYoR4n56AJ4qqd0Lpgdb8ZGGephyIa0uwJXm8+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcdxnyyUyqmwjvI8dc7niypMZ\nmyQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgImDd6YUoyZpdOXOW/1b/Djf6cYdfx0dVLks88W9tDbgCIQC0KyFpjg8k\n6I/Hr7suDza96pvLC5oL90Y4Cv1iH9Awaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAYmNjZKfV5S8lfyTutkoj349MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg0ZDA0OGMtNDc3Zi00MTJjLWEyNjMtYjI0ODhlZDhjNTJmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTRlMjg5NmMtZTZjMi00ZDFiLTgwZjgtYmUzNjQ3NDRj\nMmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExMLQF0jzxDpzWYfhqvDX3SpX\n65SctQptkP6MnzaHhAqsJdDMddqSvyjDKSIyAUM22xyS06CjQa812iJZlYkJrqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUF+LM/VyvkN0GyHO+Hucbh3uUVycwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgNTzu72ck\npRSNyAUJZvbQI3PsNfbWbRBAz98GQNkrbTgCIBkNLc2RFQw1vMfdiEnHjl9dZamz\nTd4ww4PMi0KejPi1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc393", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `393` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAY+KPBRomW2eqAlI04lleFgRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNWI3NTY4LTg2M2YtNDU5NS1hOTIzLTQyOTg4ZTE0YzhlMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU2YjFkMDMtMDM1\nZS00ODc2LWI5MjgtNzk3YmNiN2JlNWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBj6gTaIC5bNeXsxhVcATRPMSZPc1ol0FEy1bf5+jP2jT+TRfdYktWa8B6Z9B\nUEymKEi/JHtEHqPJaffafKMewaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4V/U1ScoBi+Ze+8lgqDuuXr92vwwHwYDVR0j\nBBgwFoAUxqZ2vE97Plal7yIRzwqkDfJg5rAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIF94ihdnzRcNqE1vN+7bmvll6qLHIa2mbazZbnXecAyGAiEA\n6b66eBEF6UVAi/7stP60ZqKdvQpOWGOcWBa2plpQZf0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUPT1ac5lAaeR8Bn05e1Wi6GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjViNzU2OC04NjNmLTQ1OTUtYTkyMy00Mjk4OGUxNGM4ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZnRHat4exxrwjseSe9NQhpGo4zZL28IQQtBmB/XTU5LmN\n/EpK8PbsnAeM6j+gopH0gtmfNwDxwt0g8g5O6w+Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxqZ2vE97Plal7yIRzwqkDfJg\n5rAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbjNTE67RW+7qRP3Ilp1wyUQkNO7b2QOZEm8BP4uHvEQCIHJQDESi2kPA\nHD9TDvZ5TxqJ8X6tOobZiFpro7+lkLvb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAW2UPv1BDt8nqRHv5kFbrf4JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU2YjFkMDMtMDM1ZS00ODc2LWI5MjgtNzk3YmNiN2JlNWUyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGJmMDVhMzgtMmY1Ny00MDdlLTliZTMtYzYzNmY1ZGY1\nZjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE69wV7S2o4V5EmVSvbMA4Ctph\nMSFSJpg4ZTM2znrEQjapkAdFwGwXZN/z0jqwadLu0PHEJ12A4AMIRIHYAZalKaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4V/U1ScoBi+Ze+8lgqDuuXr92vwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJkOhsOF\ncwdNPKj51gUlpFGRnzxNqzTIE1gBtC5ZKMPAAiEA3V4Nar4BHh4wdzA+CwJ1jT0M\n9mSquwsiM9Ubo5qs6M8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc394", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `394` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATFbzDhleFLVxhkh40x1lTe1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiYWY1ODUzLTRkZWItNDRmNC1hNTljLWY1MGIwOTM0NDRmZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDIwNmJlOWYtMjI4\nMi00ODFiLTgwODItNjIwNGYxMTQxNDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEok8jkw9jjCbKX6jIPk5ymxaKN92VzhhY1CqqapP+aHe/ngeNzCDLzMBnIyxj\nJmqlEIXfdNJAqU3BIUWq8Jc/Q6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURHFms+Zs/GDP3Z2HiJmmf292oEEwHwYDVR0j\nBBgwFoAUBaR/Ps6R91gnLBGKCWzSuzYyYTQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIC9LR2lsgGoR\n6a1uNF8JhyQuUwdWqrk/RnN2VxTlaOOFAiEAyzkHysreoy358uUq/7n+jo1TmqFn\n4Co1b3dpad0p+jM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARTT+2sXR2cTBkuHyLSY/IpCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmFmNTg1My00ZGViLTQ0ZjQtYTU5Yy1mNTBiMDkzNDQ0ZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFvHBThp9OY3GzW/xU7RgCZpOIEtPdhbXvOdL3J+9E5EJw\nV5oCvWDvzaNbUt8hmDTKandOax0284/VSQ05JoC+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBaR/Ps6R91gnLBGKCWzSuzYy\nYTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANygDW7jeBKTtEYI7PimtONuAp909BO0Ju7d2BYhdCZSAiEAvdec3++9\nhElXXRztGicEyR2AmPk/y2EI7IgBn7V8a6U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUWKcgzbdupchXUztzLF2WCYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDIwNmJlOWYtMjI4Mi00ODFiLTgwODItNjIwNGYxMTQxNDVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTE5MzdmZDUtOWIxYy00OWU2LWEzOWItYWQ0YjMyY2U5\nMDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtv7VsStnftgUf7XHYIMNaagl\nk2zHLLpABJYta+2JVwVyj5rdSqqRpu6etf1zw/dqgArz3ytWnaeBMTFoJWn1uKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURHFms+Zs/GDP3Z2HiJmmf292oEEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgFnYeOZX7\nsznBM7tI8qYHNKEaGkyQeNNwgYMY+ofGhQcCIQCXH+414pRc9LviXJ7kFSkESGFE\nrQwrbvy7vrN3Z30A+Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc395", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `395` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAY+ubpuOfIHDCHN2i0JFyw6rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmNDdjNDVlLWJjMzctNGRhYi04NzcwLTljNTA1ZTcxNjE2ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODhiYjQzNzktY2Qx\nNS00OTRlLTlmYzMtNDNmYmM1OTAyYTIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdgUlnA7dAYuzzu6D2oSBevvke8av7A2jcHGNY1J/vp++wU+ng4+3IaMBx5Rb\nvxCEgKpMZvP3/PTnNnjclRDZlKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdKKfsz3ZUftgcZSE7XfBXNb/pUYwHwYDVR0j\nBBgwFoAUardwKyetBFardcutcro9pVu3fH4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgJWwBK9Bq1y79ybdgJB7frjIfjbJ8E9VLbnqD+ViwWuECIQC8ThzK0sca\ns05/yCzPac+lfWgxdciG8ha0PQ3QRBuGXQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQQ5EGzltSIQhULLkooMqliAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjQ3YzQ1ZS1iYzM3LTRkYWItODc3MC05YzUwNWU3MTYxNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrUB9I++UPnWqIEbFp/oOSi0PRA5nnM5AtFbuSeN2ZG05i\n1fwd2LIEjOklYTd5DR2E+CuXtufrrC4Fzpje5dZOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUardwKyetBFardcutcro9pVu3\nfH4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKHe9BotVVwfSnV0zX25g++/c58I1lKuENQOxHBl20IVAiEAuvIS90aK\no0Kn6BWpRMfd8ZifH2IlhPeU2wHFtyBrXXQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAaQgphEyKMLhAd5Mk6/OYJvCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODhiYjQzNzktY2QxNS00OTRlLTlmYzMtNDNmYmM1OTAyYTIwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODhmZWE5ZjgtMzZiOS00ZTIzLTk4NjktNzNlMjYyZWEw\nZjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuAeYdbK5aLDlZLAKmfftXYmM\nwb6EzwRpoiQmxrTOJ8oB0uwq29HSQ1sd4JpsWOML/+JJWqYzj3DP/MD+gExXf6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdKKfsz3ZUftgcZSE7XfBXNb/pUYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhALW2vCxI\nXUocSDD3pO8+cjPw0nHNVshwKwg/DKYk+eudAiEA3IBrTYt0khCtz8u43p/Fg3iw\niMVAHYmT5Wp3P32nr+k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc396", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `396` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARttfKFARflqU0DLVvCwh1TyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NjFiNjZmLWVlODktNGYzYi1hZmY2LWJiMjIwMzJiZDU1YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2QwZTFlZWEtYjJl\nMC00NWYzLTk1NGItOGRjZTczMzM3OGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpaybdJLWaiRWaV0rnFKKXPeYlXpdrCLX4wNsPUEth7RUNszD2M8lApCwCQCZ\nTq9rpIotDOu1UEXmhInG77lGkaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv4qqIBMKej6T90SNZzTK8GEq/SYwHwYDVR0j\nBBgwFoAUsoQfJE/poFmeVquQE+KaFFM9D/gwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgJ4h+uM6rM25bUGO2qk78porJ9UJaR58Y0cMSPqXbLhkCIQDOhTcdWfKC\nU/J02EHf6tpvFikfE2fYViB6+pbS0ze2Hw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATW3yydBmsxrjPA5SyJpyYXHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTYxYjY2Zi1lZTg5LTRmM2ItYWZmNi1iYjIyMDMyYmQ1NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4c4qnGDvU6Fyl/zACjFjfUwyIxypKMOaTPcS1zHc2hTzK\nIwGH3Gjy+kUJUEaYAh0Zf+0AnbYOPs1aw4gZFN9eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsoQfJE/poFmeVquQE+KaFFM9\nD/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJSMCBOGwdA6XU+Xh1Hu56MziRe7kbZjwM9I7wJ8EwkbAiEAr3vN1e4+\nI8GTSaNruVa962i7wNcFJr2f8Mt8O8AhvDk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAS0AQsKi69CCEoX3SFmTW9XBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2QwZTFlZWEtYjJlMC00NWYzLTk1NGItOGRjZTczMzM3OGU5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmQwODdhMDItZmU3MC00ZjRiLTllYzgtMGRlMmY4YTMz\nYmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAsBKnJNxEMUQLZrQs2WT+Vp5\niefKkQRhwf7iO4PoNnVwIZWyDGfQ2/7UYyFa14g3bijebe8q8ZWbFhZgFOvaS6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUv4qqIBMKej6T90SNZzTK8GEq/SYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAMY9Ylzn\nmYI2eTpMI4FRDin1ZduG+OoGu2bK8cioaBAVAiEAxmAQNZNNhjWeyLHr0CYrOquA\nYoZCjd7/dGGOLTa/EY8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc397", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `397` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAczvCNAQCjhjFW9cWCUN3sA1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiNmJlZmI3LTQxYWUtNDBkNy1iOWRjLTAwM2I5MzU2YWMxNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY1YzRjODctYzA3\nOS00NTU4LTgyNWUtZjFjNzQxYzAyYjU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo7JWpvCFVIE9bZDaqTtztGlCGqYoAe0kkNVQKPIECZt81mMFCqaWjVCUllaw\n89fHm66IQgZj5h6pz2PPshdVKqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvHCTnzrGNpU6Pqhs4fm8P80TapcwHwYDVR0j\nBBgwFoAUq7NKtXFM3mcECqMbFXI6hgczUucwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIGSY/pzC3IzdEkNR+ojn5i/rDAosP6p8c9Ba6SvsPHVfAiEA44mmyP72\nMVkwFxAxlNhKvAVj9HWJa9ANLPHazbo2kZo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfrIMVurRrkLDCKkBae42olgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjZiZWZiNy00MWFlLTQwZDctYjlkYy0wMDNiOTM1NmFjMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDuZEjXkFtddROSsE47AGKLiy/dCnaFR64o4Pev/kicIJ5\ngVXuqC98xRo8a/FhrRfGkhUOHu+jOO0Pf2g+DBhjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq7NKtXFM3mcECqMbFXI6hgcz\nUucwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXGO3kwzUARYqhyBEEf5vIz4aF0s4Uu+jh9X6sISuUpUCIQD4uDBLuPEB\n0OFFRGtTeqOFUOaoI+caWIVs97+qrTY2Fg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAa6xI7MTOYGkZtZswd85LWUCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY1YzRjODctYzA3OS00NTU4LTgyNWUtZjFjNzQxYzAyYjU2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTVjMGIwNGItZjg3Mi00ZjcwLWE2ZTEtYjk0MGY2MjYz\nODljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIsLtJbIa3UYGaytRIqxGg53q\niCH4S3ByPQlzRmRUbtn0owWRKlFGiu6sjE2Z6c6V916sfpEjsdlm2Ue12Ca7KqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvHCTnzrGNpU6Pqhs4fm8P80TapcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOGtchQb\nDNy+qf2QlKwn8s+45SRZq5X+ZJabUojrstE+AiEAxJY2Bljj/BEOA5YSqEZOczc4\nYQiu4ceJCogUM8tQN+w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc398", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `398` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAZLkyMCCnFN+ifQjzdgxyS1bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViMWRjZjI4LTU4YTItNDRkMy1hNTg4LWNmN2NlODVkYTk4YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU1MDI5MDYtMGI2\nNi00ZWJiLWJmMjQtMTk2MTFhNGIyMGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5nsxXeDjy8iZBrAKOAjRkG9ajKmGpBZa91zPjdMIP/RcFwTQRVmrxJ1l8Kk0\n3bts0c3uAYBlN4L7PQ+rCSx8Q6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZFfQqqAMg5Z1qY11s/6Xpr7RYW8wHwYDVR0j\nBBgwFoAUHm7kjPWEodMIol+vf1CCCgyDjpAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDyTkzJKCajx7qvsEilCl/NEht0YrfWrEjFBOV5\nhVSJdQIhAI61Qh1YXKgAqQFfcQBouv0lXKZd4/dNPReViH1b9ZVL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ1I4tAlkY5yr+VBWne/PbAtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjFkY2YyOC01OGEyLTQ0ZDMtYTU4OC1jZjdjZTg1ZGE5OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfxDBrZ95wHrfeg1Ooj7hXgoRfLL/wIUSWyF5i9dsPL3G4\nw49iE8ZVILfoa5gg4823e3mxFG/HTg6a3GfcxWElo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHm7kjPWEodMIol+vf1CCCgyD\njpAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNsjNzW3/jaeNePJe7YdMvEBRNgnGzu7rzRHv4xzRjKcCIEQAfeFhJFWd\n6csuLEmDyIwWUebnSv3/PJaqU8SeLryZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISASqZdoEl7aDwqBDtgU/WDkGnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU1MDI5MDYtMGI2Ni00ZWJiLWJmMjQtMTk2MTFhNGIyMGNkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTgxNTE5MzItNWM2YS00MDcxLTlkNTAtNzU2NzRjODA0\nMmM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJuZlVGhNq1IjijwTN8EGzCcs\niGEEsZPKE+aJH+DhjCBJRXDYgZRjmcRJalFN80jVb/nlI2Vyu9s5jVgyzUOXv6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZFfQqqAMg5Z1qY11s/6Xpr7RYW8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAK01tYus\nXS0dIs1tPwIDxXRftHpvrkW10xnyYCNsqyumAiEAuntMUUkUrq/HBTkIT26OVSjU\nj92AG4bVvsLuBO7/3bw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc399", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `399` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAc2ufCNujefxFq0+konoawxuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiMmJjZDE5LTNiZDktNDk2MC04YzFkLTYyZTMzZThkNTE0ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDliNWQ3NGEtY2Nm\nZC00NzQ1LTg2MDgtMjY2ZDkyMDdmNTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKgbH30H2UPY8NE7uL3F7wwuAqNP8Oi4k3MYi9GMDfUgN1uz1LkmANfZFcVFG\nVCee3GHEHAlZafuGMRbMyz5lMKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaxnj7d+w+kj/sGmWs26QVMCcovowHwYDVR0j\nBBgwFoAUuzfzRKULojCxgantHRp6itTLlzQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIEvTTLPDtdzhAlNNAedKfMxXP6egPTfDkeQA9580\nvLL0AiEAtvSgYQhqRFv3WZrdBVEDVpry1cXET7xQzOS//PoyKYI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASHic0wgIc9InzaFbQ4WZjazMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjJiY2QxOS0zYmQ5LTQ5NjAtOGMxZC02MmUzM2U4ZDUxNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFbddftl47LyeR8C5dg06QjZH++D5J8Vg85DECauMGKuGM\nW/huyt30yRwLczqCtB9Hz/8ViZZbzLTtd6eeJWADo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuzfzRKULojCxgantHRp6itTL\nlzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK3NKO1/LMFMVdVrwPj4AEOLgs1rz/zg8pQ8HndYVolHAiAn0wFyXs+Y\nN8/O51wjAP6nZx2qjrEo5jNXpajDvw7jUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYcddxCuFfz2w5sW4UpbVHACMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDliNWQ3NGEtY2NmZC00NzQ1LTg2MDgtMjY2ZDkyMDdmNTM1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGI0ZWM3MTAtYTFlOC00MWZlLTkzZGUtMmE3NzcwY2M4\nMDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7pBptB6ZyT9hB/h/RhWlN2cG\n/4nq2aIzUsMlV2eKBKv0jcUxo9xaYcMzh41rUUqEf1PjXhET/N1WtlDkv5mrXqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaxnj7d+w+kj/sGmWs26QVMCcovowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgWOOZOuik\nt4YzRNy4vURFkmsI4Q47OnA2wyOu5CqbobMCIQDxR1aQb9FN1dRIKAQjcWiInItI\nqKG3PDpz87p3sQuKCQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc400", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `400` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAS5JoAZDjygamu5eX+LLOZawMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyYTYyOThmLWRmOWUtNGJlZC05M2Q5LTBjN2E0MTEzNzk0MjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU5NmVmNDYtOGQ5\nOS00OGEzLTkwZjktMTNhZjk3NmU2MjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsFJQjVOIv/LqdyU7HTjqDhpMWO3z9ptoQIuUAa7J2sa4Rxuu7zIJHoRJWMr7\noOnzTv3y2XAIlGlhKaNYOtPq7qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcuzc114xzGFaGT42SdHyvNPgRikwHwYDVR0j\nBBgwFoAU5TqQqWGMeKZerni7WwFO/T9A+BowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQD+v+/MedDjvLAGF+5SeWofoGA3lG/0WYtoVx9YdpIcpQIh\nAPBZuOYLd/mNSAeFoqVyWiclERSjKvjUY+KGGtK0JSFY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAToou9JBvL7CE63ez84h+SEeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmE2Mjk4Zi1kZjllLTRiZWQtOTNkOS0wYzdhNDExMzc5NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ55sd7nzvy0y+do+JY/ZfZ8lMLDGCUhD9OK9f5eA1Etr3a\nzJ+3yvepV/kWYOE62bAff2dVk7ZsWZJ3mTwIs8o9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5TqQqWGMeKZerni7WwFO/T9A\n+BowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSlkHaiP/DVmKPKAkhuWMxR/2Kea/R0uPoZl4g08mJI4CIAPM073iHQXX\ngpn3UC98NtXXTHYiDeUEuGVlTWRvlh1p\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYopr7sVEqLGrObYOmyBLgdzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU5NmVmNDYtOGQ5OS00OGEzLTkwZjktMTNhZjk3NmU2MjNkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTEyZWY5MmYtNDUzMi00NzllLTg1YTYtNzc0NzQ2M2Q0\nNmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOAnzZLJhOe7TNapmEWl5vJ/R\nJJGDP6nMsE8Lwt2b9Laj7XGqJ9dECUexIkMiV6/P+TNe+5XY9F5WJMJp0M+3pqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcuzc114xzGFaGT42SdHyvNPgRikwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgMXJd/PvE\n8JzP7GwmKJJ+LAc1b9rOCe7SYgb1oOnbn04CIQCjAzm9p3DVIBWira047SA0jdrO\nLbGqPlTX7YUahaacWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc401", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `401` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAW37rZhSs25TaeQ+c8tAdr05MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxNWMxOTliLTdlMzItNGQxMS05ZDc2LWE1NGMwZGJhMGQyODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM1ZDMwYmEtZTdh\nMi00YTI4LTg2MTItNTg3MTczMDRhYWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ5dcxYFfrSEPofpEV8vVV0gd9X2sF3g4u+9Ovul7AVEISsu+Vxa7W1ZnTQ4L\nMXX2AL8LOBBCrAalHMigHilMa6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhlwhIZAgc+6sSmbjQtfQ4qbPDAAwHwYDVR0j\nBBgwFoAUsBChtELRM5peJDZskbUV1J8/beswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDrmG32JL9OAg966/EWZYjYVolg3Fuv\nl+fTKFFnkNW2XgIgVaMGsJoVsTFo9dMNfec031nkqteNH/0SiOG/PBScfs8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdCr4baML59HltAsJbakNsJDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTVjMTk5Yi03ZTMyLTRkMTEtOWQ3Ni1hNTRjMGRiYTBkMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvEv4C4q/fwteGdGQ14tNdbtYMuy2rFygudeg739wFuuZO\n1LysA8DbzUpqR4r/i8jCamnLxKeTRL27ZWP/de7+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsBChtELRM5peJDZskbUV1J8/\nbeswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIEBvwVwUqRupsaZcBJPBLckUVWB/lMVEASgnzKnzWzUAiAHCXYDd5yZ\nqKSr3wIspw44kG+GemTGgQGICWdgL99pMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdtMYvvVJRGGRG3FsXusjpZKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM1ZDMwYmEtZTdhMi00YTI4LTg2MTItNTg3MTczMDRhYWM4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDRlMDUwNzgtMTI1MC00NjQwLWJjNWUtNDhhOGEyZjE4\nMTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZX8h23TRmQCkF6iAqhXB+HZP\nENwXuGCpsnxb7l01ovqzqi6Osr5Vw1EaKMuj68a1inxZ0Lu8wlIpJAhVLsh0FKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhlwhIZAgc+6sSmbjQtfQ4qbPDAAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhALQfOIxY\naY9V5c6orNhHQlt1cElBw1Qc1bNxz/F9NSzrAiBuxDjWzN+Ba/Cj6q60yp+p4OsV\ns+CBnrIeEyTDAMMh1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc402", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `402` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAalB+hq+LDeR+2VUC/MHJI4HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlNTkwYzhhLTcyMjMtNGZjMC1iNDRiLWExMWUwNGNjZWJjNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZhYzRlN2YtOTg3\nOS00OWQ0LTk5ZGMtZmE4NjljNGEzY2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh9xLyfeqZM2DUULeKqiABpW/sj09X9FWNCF4Ebf4tJMevzRwQlkL1zc2wk3h\ne+uXJCuPDXu+mBjYh8GtQa9xyaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa/Bh1bvCBq3WRgM8v5SBoGB0VqMwHwYDVR0j\nBBgwFoAUVeDloyFMim+Op8TJndeZyuAxWgIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIFx0OfijSyBbA4WA95xNCNjb9R2cTSK2\nqWQx+SnwjDraAiEA8NHv453mwdVzhFZfIFYnixJ349lYDRjpT0GVINssZVU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR+o10Zo5SYiBwikPc+Hc8eAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTU5MGM4YS03MjIzLTRmYzAtYjQ0Yi1hMTFlMDRjY2ViYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdOr7mBVNFM9Ys7OZqmAdYgCGQODyNcL1xGjjZnbADrVWs\nMQwAZpBIXMTdpzl1ilc4Tx8ep7+QcEtGV54YZ64ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVeDloyFMim+Op8TJndeZyuAx\nWgIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOU49f2ksejEQXI2doN0SERekvLqg8Ptq+7QbZnIUdrICIBFdYM4YswPl\nL/6Yi6guw42Q7ZGaZOQVC6L/5CNPAA9G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAan8IxJhGPc/us33S9wzjVO9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZhYzRlN2YtOTg3OS00OWQ0LTk5ZGMtZmE4NjljNGEzY2U4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjMwNmY1MjUtYzk2MS00NTg4LWE3YmUtOTA0NjI2MWFm\nMDU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuFE9UVjgzC1p/lfF9rcz3TNp\n/8bOwxCxL1Jmx+8wqGd06r5R2w2tVNhChHrW/LLnDAKyjwE4uaKH6G7meLoQzKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUa/Bh1bvCBq3WRgM8v5SBoGB0VqMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgbt/I2Wxg\n8mCxEXWmJepPq4KW3qkchDO/VgrdR2fQkrcCIGNaYHsFyMakFNmDJXcisRM9xrYd\nM25P4SZMIibM/iv8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc403", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `403` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAeWCVlj2ReHl+pQ2sgOtdGIfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YTU4YjE1LTE1N2ItNDk2YS04YTA3LTdiNzQ5Y2YyZTViZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAyZjlhNGQtMzlm\nYy00NjA3LTlkMDktYzk3YjRkYjNlNDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETZ6EM7wJ+vBUV1rg8GlBJ5huQuAWRGh84GqE78hjqKIdFPVtSiMe+oZ84+tQ\nzNrUj7XFXpsBW9sFPDDugWf+tKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOhPyna4ZLzQpA/HUgxfa1mT7WXswHwYDVR0j\nBBgwFoAUyuL7zJh81HtTU3MLOwSH8jfsfAswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDQdujCAV04\nkqxEDGUgr3MYmlAzJ0ADBKdwFhL8bd9ANQIgfY7hU+su4Bwxv7c6CHSEykJAE77K\nWL4sqbvWhUBrwYw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATSZIZxjPLBENpgEZSY/8wm3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWE1OGIxNS0xNTdiLTQ5NmEtOGEwNy03Yjc0OWNmMmU1YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2xlNT/tBVsCk7fWy+h9R0O0g9+3OwEoYPdJeRMfz5v25T\nyoXSraeQnQAIx9uxLJOhpZ2bd7zsbi8xgWNrJ/fHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyuL7zJh81HtTU3MLOwSH8jfs\nfAswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0hAHKL21owJ7p7w6wT7HoktCR80U4ul/1CrTho6jQqAiAxPZBN8psE\nLHorrAt1wcLkWgI3WjaV9CDFNChn6jhb4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAa2JS8u0zZjJuEME+CPEMdfvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAyZjlhNGQtMzlmYy00NjA3LTlkMDktYzk3YjRkYjNlNDYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmY3ZTE3YmMtNTU3MS00YTQ3LWJiZjQtYzcwYjNiZjU0\nMzZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETQm2CSYvtecsjuGTG1dzr2e1\nCuigHApe8hZWoAXQzm6nSUoZybtkOizkISDN0ebfGlBcO+LJg9UoUR8ypuypzaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOhPyna4ZLzQpA/HUgxfa1mT7WXswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgYG58542L\npUbq2HzPA0ndojjT6vyiz4jUqjL81IqREuYCIQCMFS4F2+HRMLClVczp1luKMn/S\nMJ/sx+328F5opvjpMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc404", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `404` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAf/AC0ERHNfXsGWGcuMam50OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNzU1Y2UyLTI5ZDktNDE3ZC05NzEzLTU3YzQ1ZjI4MDU5NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDkyMzU1MmItZGE2\nYy00YTY3LWE2MDUtNDExOWE5N2I5OTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYD1IfUgqIcU4XiAJnvb9S/miOFlpxdmSupbYK9LCAHeFtkEKCig2wI2KxFoq\nL8jjGXK5GfR7MrPWsvjF19DAB6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU77Ueu1rEv6kVG7tAcTPNVqQM+rowHwYDVR0j\nBBgwFoAUutu7djuLe/Z5ENP9DDRzUAyD24IwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgMuD9hq4DrFIkXayW9HxlDZBaO6wFqh0wkKR13JpdpiQCIQCvGmrVO1Rm\nUFTA7L19MrS8np0P2mb3UgmCkMryveEbyg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV26++Df8AQNM+uTsYfRGAheMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTc1NWNlMi0yOWQ5LTQxN2QtOTcxMy01N2M0NWYyODA1OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARthg5+NXLlfKnRuDBHXVYvZUoSNYAXBTW1rdTlcPvfuiUJ\n1foBl2W0xKvhEK0qw0Hgd5SRUazv/9cfm7ji1bOBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUutu7djuLe/Z5ENP9DDRzUAyD\n24IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTqTxBSa3b145wX2K3RFfJ6G9hENw5BP3PAahpuJR+KECIQDGOuLzWVkn\nY6LXhg9TzQ8tFqldpPz4YDFj0UxYFMpolg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYZLijF+5LQOq3jcSQsyhmXzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDkyMzU1MmItZGE2Yy00YTY3LWE2MDUtNDExOWE5N2I5OTRiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTBmNGY3OTYtNjhmZS00N2Q2LTkyNzYtMmNiZjhiMTBk\nNzk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIlFPAXctwWXLPdCc35R10g8C\nHljeIzRHG5TijMlbM0lI/+y2gqbn/DdJ5Axgn3WGuRvJPhWOSCK5ZDJiQmtybqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU77Ueu1rEv6kVG7tAcTPNVqQM+rowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAL7AMQJ+\n3KU5egm7Ym7aQS/Zk+Sy80VFIONwspnJtszKAiEAm7uf6GaqN0rr2DKkmJuAYOgN\nJ4SQCluR0bN7wNqCKpQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc405", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `405` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATVSJZwOBKG7Srxcu4/eMAiOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5YWRkNmYzLWMxNzctNDQ2NC1iNTc4LWVhOWY5ZDVlNzQwMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRmODhlM2YtNDEx\nNC00ODhjLWEyMjUtZmEzNWE3ZGJlMjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2SPQIS2EagcuFEG3cUR2H08b4goRMZgGAPb7MeeuYMhvh2zC7XfVufPXpcin\nR3x8HC5IziEae1oUSv17ij3OA6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgtwO65yXq4FPwECZ+ncScFRVnMQwHwYDVR0j\nBBgwFoAU94mmc7JlpWDyU2NbVkod1alV1W4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMRSAkrCSMZxKWxWyw2oJ3iMW+7C4krqjTuSD9acNtxLAiBLkFsUJ8dB\nWfjeHu2jW3S+YvOmhnBsq0XkVXShmVYHgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdEoaOVZZeZEBpdKb1si33MlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWFkZDZmMy1jMTc3LTQ0NjQtYjU3OC1lYTlmOWQ1ZTc0MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSZDM05Oo2ocSUwEDmuvispYa99Y5N/fmyFfcFyWXpZYEz\n/0qzNlYPoUduhPQEEJaPEwM47kYvl2x5UWiGlwUro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU94mmc7JlpWDyU2NbVkod1alV\n1W4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgex5S/DROZwbxJkTKCkvxmkHy1TvKeYkF8jbzTJdotbICIQCKt+Ob2GmQ\nWtaP0QSjUOvS5iS4zYgXuWur6BreNRTu3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYIBHc2irzYKbhBuZUWn3qVPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRmODhlM2YtNDExNC00ODhjLWEyMjUtZmEzNWE3ZGJlMjM1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWJlYzE1YWMtNThjZC00NzdkLThmMzEtMDBlZWVmODc5\nZWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIY/nXpTyE1ybKaSPPzidHmEp\nO9jaVXY+/LgyPFSeKkdl1ophoSQ4fb7MxNK6qvS3Enj65jhYQhB9xS/vl+INiqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgtwO65yXq4FPwECZ+ncScFRVnMQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgerMh20D2\nSX+PQ9a41rioBEkv9JYup+oU+aYEm/8NaK4CIQC7clr6HYQEsNitN6symmhQvARm\nH7XXXYPsZ9F/DZh3/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc406", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `406` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAV8yWrFnS1u5ix+KDmQUIosvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2YTUxMTdhLWRiYjItNGNlZS04YTY2LWMyZDY3NDQ2NGJhODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBhYWFhMDMtZjQ3\nNS00NTM0LTk4MGUtOWEzMmE0MDE3NGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBD72y0S8gJN18DscV+WQuoR10/Ix81b5uDNBXctRNXRsvzVhCCGa07Sw3965\nIa+ZOoO1Ku3A839v8ifNrICs86OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZkQhf3prlz8lRjrngGtsqQTgRLAwHwYDVR0j\nBBgwFoAUlrgESWcvlC8HMcNqx8HEkVxMz+IwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCD1RXekePrRr1yyko8pegjGbJApIoKsOjA2LC0iQnPUAIhAMzmhD/w\n7+RRVGxU4AQlVh3w/SxKgPp0cIPXjQRb557K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZQk3cQgLa8EcWKoL/v0V4tYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmE1MTE3YS1kYmIyLTRjZWUtOGE2Ni1jMmQ2NzQ0NjRiYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYV0m1BRMaWWFv2WTb2D2M9zpzTa2e/NVJGfdLujDgJd9T\n/i0JzoH2DwzjxSEefzIEb7MljXJIFUVSp3y+IKito2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlrgESWcvlC8HMcNqx8HEkVxM\nz+IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIfeSUSGqD24K4JlWtGsnTK7J1WUn/JyFk8Qi9TLwCyiQIhAOqTfVdn05OS\nKVsYZbF6xMPxHukYZz1QBmxHyWU6peEg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISARZo51MLgOA6QYx0DIljUDhNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBhYWFhMDMtZjQ3NS00NTM0LTk4MGUtOWEzMmE0MDE3NGIwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDIzYzUwZjQtZWFlYy00MGZhLTk4YzAtZWFjZTRjYWI0\nYjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjfx9O9btM3NcR//pd0ftxZ3m\nKfNyErTBNGsLADjCQ3OaugblOWq/kwcRzuSEMUoHGdoppHePXdtx0ccQIJiDHqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZkQhf3prlz8lRjrngGtsqQTgRLAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAPuigLHz\nE7Hki3+88CxBtxSlMwoR9Y3neyTdx4XL+2XAAiEA2vlYxeCsRB7hs+eNnu9MzXR2\nz+tnSAYqdV2JMbvi3d0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc407", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `407` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAbfLpy0nt2nAGGZC95fbf2zYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjODc2ZTkwLTkyZTgtNDUxNi1iZDM1LTk1YWQ4ZDIwYTc0OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVhNTA1MDAtYjM1\nYS00MWJkLWEzZGUtMGMzMzM3ODFhMDhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIFh+DgGSBKsa9enj4vsQbl4j1djHjEQcKSgaP0/1SRbsMsfHZZinjb6DbMZE\n0eR3iqaykx5qVgT2Qhhynb7GxqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU31waF8E7B0dgXHOPmGZ4m9wQxgUwHwYDVR0j\nBBgwFoAUuBaN9LkO0WQuQex5+qkEefK++TkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDsvFJ85bXN+WDsA6i4wLP7tiwBA/KKX8Cwt5Y4\nenW3lwIgVTW2mWCqAn28sBB+gWOjYTqx6OdN29lYIGVZaZlQ9I0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaA//PEmjIwZOous2jGlXhHMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzg3NmU5MC05MmU4LTQ1MTYtYmQzNS05NWFkOGQyMGE3NDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHlCA3Fsx/vkBActE+7T8nj3b2AXFXTlJgXhziOHt14SMA\n9+bFuDOxtoGn0gRVgCiJ5FSQKifBdFMfdztcPBLGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuBaN9LkO0WQuQex5+qkEefK+\n+TkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPHCDTNy7oc17x9CpMdbXBTDiajzCYqnBfG0omtET+V3AiBI1pMzumOI\nMd4eUyXA+CinLCC6OLIEc8m92UL0UvRJ4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZs4aAAnw4JDr2PMtHleVRTLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVhNTA1MDAtYjM1YS00MWJkLWEzZGUtMGMzMzM3ODFhMDhkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmUwODgwMWUtMjA3Zi00YTg3LTk5ZmUtODg3ZWM1MGRl\nZTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsKcRBLAGu6OAfAWnHlFfGBP3\nLw8ioclSQxk+UNB9ocyVhxHIZgHUNsw0GMeKHWC6MUOo58OmeiLKf//iM5+Hj6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU31waF8E7B0dgXHOPmGZ4m9wQxgUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAP8hM7Zn\n7NfKu3Sh6HIrLhdYPqN/Iagx8k77G8huchzDAiEA9H2Dd8lfT/eJDv9G5qAtqNp1\nZuhIqI7TA9DhYfe2byI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc408", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `408` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAbgrj7dDyuBVjXVhRFOx/ps1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0ZjNkYzFkLTM2Y2EtNDEzZS04MDM3LWU5OThhYjNiZTk5NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmVmZmQ4ZWMtMzZi\nZi00OTg2LWE3NDAtZWQ1MTIzMzJlNjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoje0hlJMPDZZG+j2V0YAl3X5gJbRH5P8Yz7nwckinCiISfgizkWjZpVU3eAA\nBxzqxml9TtvwwppWFIjw9JTkuaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDBFnZRoM5TsG6kORFjUQZ2sZtncwHwYDVR0j\nBBgwFoAUeGTEbWtjPViU3GXOVPnkosC9eNIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEtoAj/iomII8oQZUHCms5bduucSL0uUNQUSPmjl\nUkUbAiBJKQcowVxiO86BqBGltAYaqFFoHSdPArTKGocIH9/4AQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVjIhkuOiigFcnyRdB+GFa+OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGYzZGMxZC0zNmNhLTQxM2UtODAzNy1lOTk4YWIzYmU5OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSCJEbFsjIR1EJEGJLJjwJc5KzhfXmE0qPhqnFKssK/SHh\nxrYyJax1/YhZZFVLOHZQibdP6IXgXcYCrUZF8WdFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeGTEbWtjPViU3GXOVPnkosC9\neNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP1T69wwRgA/JIcqTiUU6rimH91z0k7u4X8pVAlAnyRRAiBHOQhEJECt\ntJ0A1WSJGR3U0+tzjS7WBUtCEe05LSvkhg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXNwD11nYda+n5qy7AMZXvHuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmVmZmQ4ZWMtMzZiZi00OTg2LWE3NDAtZWQ1MTIzMzJlNjg4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzIxYTgyNjAtNTAzMi00MzQ4LTkxZWMtZjgyZTZkMDM1\nMmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEz2EwDjQYDw6BQ8kwm80aLFq2\ngDST/6/SXgJKY7dQLUygL1SuFs8cYSzZDGN9IELMhIOeDFyiNapyABnXP7qWE6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDBFnZRoM5TsG6kORFjUQZ2sZtncwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgTFKxfQte\nocEeRw9dEePea9Utl+zDsIM1lk/gDEUpAq8CIHg6EtRsERu8O/zyYk7UaP03wG7/\nsggRzQXM8YgpI234\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc409", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `409` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVHD2Ri+cpQr4tiae3Wq1XL0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiMmFlNTBkLTgwMWItNGIxNi05N2M3LTdkNjE5NWU3NDc4YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA1YTc1ZDctZDI5\nNC00OTQ2LWI2MjktZTBhMWUzYjVlNjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhJnEcddtwOltVuy7WscMegsumQk8m7cKAcfjpMNr/jAuz/Iad2HfQN6XjK03\n2QnlSzwhWAEvhZEbhR6kx5LbIKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCbYSKppMW7j/IeCDmTXhda5sPW0wHwYDVR0j\nBBgwFoAUb9eSO01urdxzO4zuQSxc0m4+FnMwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIFj9jhov+ybM5yzmwd+c42H9bDRvKKe46kY2kyRYSizfAiEA\nkzU40yjTSIvdHvqCUKPU8cG4cadS3WEokqETI9jZy9Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASBartUBqVUwG7R3V+qBnkWqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjJhZTUwZC04MDFiLTRiMTYtOTdjNy03ZDYxOTVlNzQ3OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwTHtyNzLkmiON7tZfKQMtidqT/iaiv6346/b4UsZMCYYX\n+uPEnmWYshTkFJ8kqSZ8uS82POCb2KgnRGJYxtAAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb9eSO01urdxzO4zuQSxc0m4+\nFnMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO7//7FgwJkStOdLopY30xhDyvywmLkxU4KB6r4Rn59UAiBcV8a5zeAS\naDfpalWPp117UFYOFyhdglv72sqk0wfP9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQ0j3dUQxw4QUGx4o012/tj6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA1YTc1ZDctZDI5NC00OTQ2LWI2MjktZTBhMWUzYjVlNjAwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWNlNmY0MDEtZGRlNy00MmU5LThhYjYtMGE0NTE0ZWIx\nOTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPVOtoRCp8dUrgjmqoBjhK8uX\nRmMjhuca/sA9pjeHc+qtmkeOB6N4/OtUIZa0dyrr6yNwIIY3zcyczMNX9IHlCKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCbYSKppMW7j/IeCDmTXhda5sPW0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgCJ/3AbVJ\n9Mbt27+c42vam18/59Wl8hwxuDTMXDaTJgACIH4kbf+nQB2LCAhlPfwLRBerfgjD\nHjUH+T2I9CL2VKKy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc410", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `410` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZMZ0tn3LbNSYDHDf05sEWhAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MmI4YzA0LTc4ZTItNDkxNy1hNzU1LTM1ZjU0MjAxNzViODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJmYTA2NjEtY2Vk\nZC00OTY1LWFiNGItMDM5ZDkwNjZkMThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErL/wLSLZHPAlWmjd3BtwmoD5kQK6UVt2m0suhyvHIXtqIfOYZPPkKdovxhsa\nFKhlQAnweZbqXDwx4fSfJedijaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULdP9IwZrPAJCD6yp/jCvojjB3uYwHwYDVR0j\nBBgwFoAUo8yTApr0UNWFbU+gJq7Z4pE08pAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDx0k+FmvsGqDtVkJqe7kpDkQGWMiW1\nvbxOQnthVVe1BgIgLuB+lCjKp+CC5CIuzm7xJj/Z6AxxuxEepocBl6TVG7A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXqysaz3UCRfd31+pAd+zASMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzJiOGMwNC03OGUyLTQ5MTctYTc1NS0zNWY1NDIwMTc1YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJKykvMAbBtQS9YFjIbO7wnk63SytknuA7JmkvVvEu0jV1\nsLHSJIO8bUKr+Yuu4roDRp7ARnSygpB2keDPbJQXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo8yTApr0UNWFbU+gJq7Z4pE0\n8pAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALMIcT5Qcsik0U2Lqptnpw49wYRwUCeGdrZPn3dED9JoAiAESI69bFgi\nPftkIZ2rs/5wYRgdwBRMTcXofk1opr2eKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAcDMJfcZsY2ch4s0yhcvtpBnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJmYTA2NjEtY2VkZC00OTY1LWFiNGItMDM5ZDkwNjZkMThlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJjMDc5ZTYtMTdmMC00MGRlLWIzM2UtZTY3ZjQ4N2Yz\nMDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPvEuNxQXaO5oqixRzXa8XzIN\nBgFUREGvVHIS7r21fMykYCpmUok8l9EKcckzhJLqMcYHu2aL3+IjvVxteMun5aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULdP9IwZrPAJCD6yp/jCvojjB3uYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgT9YlOEUm\nRNEKvcMrAw6SBkuv2cFKVvCt654F7utGcbwCIQDi88Eo95S3G6OtkSSl5EDqzKku\ntnAWQZW+J45NKmja9A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc411", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `411` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAeYacH6Ecafs/3g9Vz8ypzRCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkNTQyODUwLWIxNzctNDIwMy1hYWMwLTkyOTM0OWExYzBjZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTYwZjY0NDktYzQ3\nZS00ZDJmLTgxMTMtYWNjNmZiY2ViNzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6gcsG5lK5FEHwfL5X1GuKpZHyPIFa9O/DdHNMo9QU01qat5P1NJ6PsFiSaTK\nZ7W0tbUHXTA8t06Gd0WJjhYAd6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZVhXF/I91I81aYUBErtXd4r4PJswHwYDVR0j\nBBgwFoAUADksAzleO6/ChKH7GFOEREKKu2kwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDgTjt5dCJ2Sfi+xkzuZWyX8QIoe5ag\nvW5Uk455aM2BXAIhANgqX/AjN8Y+ZSZu+AUsrek3DwmqVcasStDx+EIbXTrs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbpDt156/IP3Zk7zMml9MqtmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDU0Mjg1MC1iMTc3LTQyMDMtYWFjMC05MjkzNDlhMWMwY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgBEm2kesfMS6kmJdKCnPr26jUJkA8TFwlssRZHFrZsWJg\ne9UgAZ6ze0RuEJ9jOzvaWmkbKItwybxGqS03/CmQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUADksAzleO6/ChKH7GFOEREKK\nu2kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANNhXG4oSufueun4pSTsIH6zgcsnoKf1wlqsmU82Y4R9AiEAvUrMLa8P\n17t+gfPXdDGeYKPBSR8Qm/DWfPc/esPk4ts=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAUowuhBHNzhaSJN1ucmgkSzeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTYwZjY0NDktYzQ3ZS00ZDJmLTgxMTMtYWNjNmZiY2ViNzY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGNmMzA1NjctZWQxMC00NTg3LWIwNjAtOGZlNDdmMGFk\nN2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX1YprTtPE1tHEXFydJkLF2yE\nELPdPg3EZUogVcmJEXFY/6JpaHdWlPjDWOevWRpZJPFbjRSU1sSAyidJIKO+PqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZVhXF/I91I81aYUBErtXd4r4PJswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAITL8GA0\ncHbbp9OAEVQFg+9BFO4/GOYZcEBvKhv1PdY7AiEAmi/vZSepV3noAJ0VyKZX5hzL\nmv+dwTaaTcgOk3iFGsg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc412", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `412` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVeG+4UbmbP+lisLYYexWNKPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5YWNkNTQxLTA0MzAtNDMyYS05NDVjLWYwMjM4NmNmNWUzYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FmZWYwYjYtYWEy\nZS00NmNlLTg2ZmYtYTc5ZTdhNTU2YTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Z8vhb6vbjENqTu+PerUMsT2BczCnSVKsM18wfZT74XHI2dFAtDJcP1LwtWU\nwSGHv6DNXNPq/QnYl1idimHZXKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJT/jcduceYmCdpAz0tEBaqU5rzQMB8GA1UdIwQY\nMBaAFPiMshrv9G120uSO6RD4JFebxHxpMAoGCCqGSM49BAMCA0kAMEYCIQDkDSJ/\nH84xxdcTsdynUznavwK7aUartPkYkYZ2UyL20QIhANZjLLSWaut3qWYtaHBqVPht\nt5mANBQpGhZ5b75Ei49N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWSVU8Qnp0HQ2uBOq6GwVp5EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOWFjZDU0MS0wNDMwLTQzMmEtOTQ1Yy1mMDIzODZjZjVlM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqQew/6ADs5ps224iZrU1MF7fBB53/mDDwVegM945LzYF3\ni5kuyXeqGkncNG9LqKMgunXjK5u64/ol/XTisYQko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+IyyGu/0bXbS5I7pEPgkV5vE\nfGkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfEuC8h4RH0Tnaf1hHFg3JiEH0BtFhAdurW0dfUUJi5oCIC+ZcFshDt4z\nsFAm+4q3tZvFja3ZWYO/dqS4zUkBzvqL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcgPfLyP6Swzl4fj78xTvSJ8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FmZWYwYjYtYWEyZS00NmNlLTg2ZmYtYTc5ZTdhNTU2YTNiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDM4NjYyNjUtYTc3OS00YWUwLWFhYWUtZjkzZTAzOGFk\nOGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5WHKK/XwiTEEEUlbspL5HGpC\nF/PXBOvLyDCvLgwS73nR/GOhPsKOqAsmV+dfbKOoGLtN3ZR6mE3EYSmXGk43NaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlP+Nx25x5iYJ2kDPS0QFqpTmvNAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKesdhU6\nar4dZk3O/pEpxlXF3ZgYs+haS0AS/jlKq3VhAiEAsGat20TDa3LSAMe7P3EmSVtj\nK4usTTCWZkPRomKznR4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc413", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `413` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISARfd8nHqc4YMZ4g72bQsNmeGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2YTBhNmU2LTYwYWItNDNmYy04ZTQ1LTA4MmY4MGE2NWEwZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNjZDI4MGUtMjU3\nMS00YWQ5LTgyNzEtODM3NGZkODRlODUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUNTM238Uov4vs8Q0a/gIg3buUiac62PCBo7stFJWWo9Xm1UgOyWCtc0rUFd4\nGoDZp27e8C5odko4ASicClDlRaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCEE7HgCoStGqEPdagZK76S8CothMB8GA1UdIwQY\nMBaAFIccBPOAZWjempcBo/X4WL8zHTuoMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAGhX3y3Kp6qjqQuImChYhHZ+D5MSxgsG+/\nh8zHJDbUygIgHM3zd47lB3koxb66ojha0FQv7Nv0MNJIjXsgJGfXMsE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZHY+ziDm6KOtCi4C3mj1etJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmEwYTZlNi02MGFiLTQzZmMtOGU0NS0wODJmODBhNjVhMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7y/1pon7JHJhPJN60NKgdJKaO14qVNA6ZNVsuH4rzDsxz\nmF/UfCYn1jbswi5M8fIAIreCFlt5GWcZpo299lH+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxwE84BlaN6alwGj9fhYvzMd\nO6gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANSUbeD9Fg1R04gM3T8HTHXKmaERmEu2nQjL5hfxIskGAiBNAlvbht4C\nPKZgEp2SLF3vp6QhG9DQ9hUTcJHGXf5o7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAb7zMGvQAc7UBJGpHuBmKxtEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNjZDI4MGUtMjU3MS00YWQ5LTgyNzEtODM3NGZkODRlODUyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQ2OTk0ODgtYTY5Yy00Mjk3LTlmOTEtZTlkYmQ5NzJi\nZTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkbm8RlB9bNkoaQuXwGAN+7P9\n9X73tQr446uhKdr4hJsuUBp/CFQ4iucJNuLBSCUBnB/G822ABIy/IRD7iS1Q36N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIQTseAKhK0aoQ91qBkrvpLwKi2EwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgTPTsJLB7\nMmNkdGh92I6DwEd8EiBfE7tEuvHFD0SW480CIAYEmXtYUous5a2nNO/bAx0ND7q5\n6yzVBalP+hBoZbCW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc414", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `414` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAR8SOCJ7yYctTdq5gfnUYC7OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllZWYyMTMyLTE5MjYtNDNjYS1hM2VjLTdjZmMxNzZkODg3NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM5YjVjZTYtNjll\nYi00YTk3LTlmNzUtYjA4N2M4YTcyY2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEgVsmKHeTaXecW5vJZLxnswT2lGLgVTBhV3k+W5Ht0lCeOfhjqJAUMrdiFBT\ndlCt82nXMzRsM+5jEOJ+rpy0paN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAVk9PV/E9yB0Zi0UFkUT8w2wBzCMB8GA1UdIwQY\nMBaAFBHo63C0WSCrsyZ7CCmOSWfXksPrMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBEik4bYfc83w5mvEudkpPULEWeVKpissa8\nqeZrEEQ1UAIhAIVjg5+lXd7SyPjsC9JayglU6Rz5lVT039eZlZAuYdE8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbdyHWCiEixc2yndL5OilZtcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWVmMjEzMi0xOTI2LTQzY2EtYTNlYy03Y2ZjMTc2ZDg4NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARASRgAfduO6MEpmEXWJDBHcx91wv1pMXxqqbdYb7Mil1QL\ntUPjduEZrf7TIuqRE1uFeQbi3dVSw6AKoSux/ImTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEejrcLRZIKuzJnsIKY5JZ9eS\nw+swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIz3UAAtgQCTGW/x+dc5PVRIupJYplFpKIpkqXa7GJXlAiEAov1s51Gl\nn5kV/EG4Bc1fAtZMzscJa3D4wpSbYn6N334=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAciHvzlkHvgb5GoNyBVI8wYuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM5YjVjZTYtNjllYi00YTk3LTlmNzUtYjA4N2M4YTcyY2E1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzBmZDEyYTYtMTA5YS00OGM4LWE5NGYtNmU4ZmQxZDFh\nZmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwYt/8CYpGGai+Nfn65f++9c7\nRrbKunpSvTU6hevt0X694c+ZYOXH1C1ktAgKNoiJspEderq9/ysR0oyGhv7qnaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBWT09X8T3IHRmLRQWRRPzDbAHMIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgIwleS8Dl\nvLdfiUYmwNyByrjd/zu2AUtE18STZeBnf4oCIQDovug8fAIihoV1RqP81T7Ajmee\n1ivLVJyUG0+s2Zcb0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc415", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `415` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYvUeZmpwSQRLXAFskRaiTdNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ODhjZWRjLTNlNmEtNDg0OS04YWIxLTYxNzI0MTBjYjMyNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM0ODVjNjgtMDk3\nMy00NzNhLTg5NjgtY2M3MTRlOWRiODI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtwEASkt3wjiTKgEiZdVvRE5AAM0RWBI9PAt3vxqtIB3FDndz0HDROmJ50pqP\nYypa1oce2EVl+jMO+eleMFRfpaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTSct2FbIMYK7xKL2u9KJMTDD9hVzAfBgNVHSME\nGDAWgBT5DOLn6QHTUuu06TYXNQViX3v6TTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHZbAXa7TKWq4v6qU03Vaxtmz7OUlE+F\nFUqbib2/G0ePAiAk1g6b4QOSm1OB6gYYro1vc5RIkq/p2fyKo/izN0ZTrg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYuxjApkUf09h4Y/8AQJ3UjJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTg4Y2VkYy0zZTZhLTQ4NDktOGFiMS02MTcyNDEwY2IzMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOwaRMiogelRPeKklutnem+blxKzAAs4V9iFfTc+STPnNg\nP4XGW09edb7boujZwtwOVh2SWib3l5GsWRnN0hxyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Qzi5+kB01LrtOk2FzUFYl97\n+k0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSC9bSgoU4kZyMPtTHpVFKL5SVZvllLJjuiFsIYkVGLUCIQD8mPb8rdvr\nxBGk3JAunRKPReVVFpnGmFcFeGvuQ4nN3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcN9H6jjYJoW9Hw3rtD7jcj2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM0ODVjNjgtMDk3My00NzNhLTg5NjgtY2M3MTRlOWRiODI2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDFkN2NiOWQtZDVmYS00NjM1LTgzMmQtNTUwZDUyMTQ3\nNTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpKu5wv0N/WymPsbuAn/59I4I\nlkdhXfLR/SXFA5xJ9g98XcgezL1w67l76ARfMP+i8ZKiGTctTFru+l+oxTJAaaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0nLdhWyDGCu8Si9rvSiTEww/YVcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMhx0fQR\njYuiTOYkVu36NlIEuH0PSxJ7HNwAJUDa/0XqAiEArtzaujp2Pdav3cZ09zxbaXD1\ngzazPJSvrzPJf9JBI3g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc416", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `416` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISASpHC2/XiS2x99Ths4GJbWiHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZTVjMTEzLWU2YmYtNDI3MS1iMGM0LTc2MmViMjFkMjAwODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQxMDZlODItYjE0\nNi00YTY0LWEyMWUtNWZiMjA5MmMxYTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0IZSJAZ9VoytueDHK7u8OaJHAAdr/yFkijp0W9vyd4amShhQT/n/JJyzMBX2\n4aQbfa2oQqIgAAAwd/09zMD5AKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSa+4yiMAr55AK56bqti4jeqo0qQwHwYDVR0j\nBBgwFoAU6kf1kXwtGf+j6hTKVTN1UeQ3F84wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBlfcjQ1lngmX/g\nHghRLeLDb00suHrdTvPqdHPmQb3aUgIgG5zaMWJgWELdEQQ8MqDPkV+QH4YI6IiL\nvEie10QiWeM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAd6f7c83038lvwZ0h0ggaoEWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWU1YzExMy1lNmJmLTQyNzEtYjBjNC03NjJlYjIxZDIwMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZrtxw8Ikrk+YB5t/LfoPm9Wa4MEu5xLRlH+z+GcnViEYw\nQkJKXx353g7d8DQss7RSc9WfHslgprOEVmfOaZNBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6kf1kXwtGf+j6hTKVTN1UeQ3\nF84wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIfDVC/i/owWI7SUTpgF/XZg4WTU3LHlG6f1Dt9x1vXVAIgQ6+LkP21qnFX\nnD6kSS1ynMLL0CV4uT5pfqKt8Sthe1I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISATVu2/rCfutr49fe9lFE2QyoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQxMDZlODItYjE0Ni00YTY0LWEyMWUtNWZiMjA5MmMxYTY3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjcwMWY1ODgtZTMwNS00ZjU2LWE4ODctMjI1MjczOTYy\nZGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPS7LPHamt/qiTTWV8yxtvPzJ\nP2gXXEGceIFovpe4zjQ/gM45OniQY8M3CriExcysPx25xXCjDkJEL8xFBcPMzaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSa+4yiMAr55AK56bqti4jeqo0qQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgWI6L1NZE\nJePpOcnI1pHSmLL/7owOFrJjz/dW7syZkUcCIDe5lEHgObdnxfxQzQxBn4t+G8wD\nHmPo5eYZurCj18SX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc417", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `417` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAS5ww5wp0pwJoc7CwXts734oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViYjVlZjRlLWY3MzEtNGIzYi04OGNhLWY1ODZhMTVlZjIxODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBmNjRkOTgtYjc2\nNi00MTY4LWEzNDEtMTgxZDFmZTM2NzQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDrs4OzKk7pqkRXJxZOYrD50pdeNVOMU8u8q9WpkyoMJ6JL4kNXezDQczZBsk\nrN8/H9bmQqAzeVqioIuyYN6jlqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTLMzn11jr0uUt67mI4MZYXEa9QwwHwYDVR0j\nBBgwFoAUPUVPYfap0L3AShQSKdY5CAGKK8EwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiApbTXDDOfczXAe\nQjM0s0gOo8HqXtKqvmHycNTvSZF6cQIhAKp2Ree0C7rpeW0dUVfR6cGBgftDmtiV\ngw1/asusgKRG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeQITxEHZ/afT+RmuBmxQ5PKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmI1ZWY0ZS1mNzMxLTRiM2ItODhjYS1mNTg2YTE1ZWYyMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpxaXIAB6cEqKxA1pf/1yLEukRpjAsKq4Hv+WNIcEtGZCH\nfG5iAAo2VKwTrx3ngHEkSwxwUWzf3uhKNRiG8/O0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPUVPYfap0L3AShQSKdY5CAGK\nK8EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIY5Cum1/wQegRurJNIizDijpr+q9a/rGF006TbPAVmRAiA3y5mKrmEG\ncRux3oaqYRg7wxAn8jo905jYDcqB+6gnVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAcXNcUMZacw8ksNMErdI34LWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBmNjRkOTgtYjc2Ni00MTY4LWEzNDEtMTgxZDFmZTM2NzQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWNkMjQwMzQtM2MwMy00N2E5LTk4MDItN2RlZDBkMDk5\nMjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKhbYNn4k3x9dYXSPVfoPH9Pg\nlStnwfxeHEWKfVpRofCFxPOCHAKRjYefat1JdjHVgtISvV6pJHDWKDYCxtOoMqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTLMzn11jr0uUt67mI4MZYXEa9QwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgSABAOTOZ\n+o4iCxIzEPjyDDvxwF8U3DJGsG6Q3hfUfMYCIQC+0zBb9Gr0FePtpWjbUY3i0ceK\nOQ44y/g8AAoLeTerWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc418", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `418` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAaC9IxdFUreisygCLVpCXpy8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyN2NmYjEwLTdkNzgtNDg2OS05MWRhLThiODhjMzJkY2M4MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU3YjdlMGMtNzUz\nMy00M2RjLTliOTAtY2NkOGMzZTYxZjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvuWkd5f7Nx89q1eImQTIb4H70jsLlxP6cIfAWMbVxamFJ5VLNm5qR5Zn1k6w\nbwgTc9augHzHva+ugoaiVXfa4aOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpFZTQu8v370evhELHIJCFUjU/IwwHwYDVR0j\nBBgwFoAUdchnzskZPGksl7L/mTAUHb00VWgwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAn4QhiC/DdkPPxuW2EomX\nZ08iI6tiHMAIToLkP1Q9BtsCIH7m4ChHorC1vwlRB+DIDbHg47M064Rdnd94fjNz\ngURT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZzczGBXC2Vtp5AOASEbFfSWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjdjZmIxMC03ZDc4LTQ4NjktOTFkYS04Yjg4YzMyZGNjODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfc5z0YNh2sm82CyqhG6EVUE/6kaBuS0GXqIMIGFXo6Vai\nZQ3Nzav0XucORzGrF5kyaTfIeLSjYDqNrW/E6yypo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdchnzskZPGksl7L/mTAUHb00\nVWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKDcsASYa8Lm8e1TPP/ZFf5nEJZQ6LLcyaAE8LwI5bF4AiAGNVr4qdqt\nVOXZQR6300+9r2pkzXCN5KAN5PanPn7H5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAd8aZ7iYhus2lHlC3C6+h+tRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU3YjdlMGMtNzUzMy00M2RjLTliOTAtY2NkOGMzZTYxZjA0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzc5MmUxNzktNDM1My00MGI0LTgyNjktMmU1NTY0OGU5\nNzNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsMh99XLxWWyhrHZIHAX7mJc6\nK8TFDWjqM1LeAVpodij74hURABmpJE7xi9UYN4e5n+wkb8R3oMQGKhvzj7fYt6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpFZTQu8v370evhELHIJCFUjU/IwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPY6QKbg\nGpaDEMcUuMB3KfK0QG5CaSbQRViljfX0ysbMAiBhEoG+VGInHbL+BQ+rHeQ9V57X\nT2dBSooCsEXvTA05Lw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc419", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `419` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAZ5Y6WkuItafN/9obEPbLvQOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiZTBhMjI3LTE2Y2YtNGYxMC1iNDA4LTQ4ZDlmOTRlODIyODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDgzOTU2MjgtNzI1\nZS00NzRjLWFiOGYtMTljNTA1MWE3OTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA1kc/c8H69/m3on09e2atI1hQtuvmAYwCy38zzZPAylA7gvxwvwb+XrTAPsk\nWoxs8XtX1dTtndmWcVB9Xs2IRaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiog6N+sokC6E//upS/pc/I3IIE0wHwYDVR0j\nBBgwFoAUFaf/oGYh0YfJzEXl0qRtMCCZv8EwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBgrBJ5\nmFia8VWLtJ1klNaco7ypkDGCfsvntnvtg/7nLwIhAPeWnS6wIB0gLc23HlQZAnOd\nZYkA/Lx8qwsOBdEde8YA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASYDM/lmO/pM1Qu9Yx48s1CwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmUwYTIyNy0xNmNmLTRmMTAtYjQwOC00OGQ5Zjk0ZTgyMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsEjbFZ21JcdZ3OibbaGr9EHMzZjdLziREo0BjEUVC5kwd\n50DykOhm4j77cd0pM/YqSi/bM+d5U4ZVdcm71ZIVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFaf/oGYh0YfJzEXl0qRtMCCZ\nv8EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJa/IY7rb2R18rVGG2FptfPpV7CZGq/SDf4gD/bEvFsQAiAgxRmiaqSq\nEIsUs4WrcNrqXuaZnehJRsMY1TrEfGpAPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdqYvAX20Yq2lA7iB3N/z5TRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDgzOTU2MjgtNzI1ZS00NzRjLWFiOGYtMTljNTA1MWE3OTNjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmM3NmQ2ZmMtNWQ4OS00YjkwLWEzY2ItOGEzZDg1ZDM1\nNGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExGN2YsGnsgMAg8SEOvlwqSf6\nbIhgV+wcAXlJc1CoyPsYLBvkAnz+FKDdfQL5Wy3ybjBQRPaV2G/+/oHSG6N7RaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiog6N+sokC6E//upS/pc/I3IIE0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgHR7EBGMI\nt9F0x/OlN0rr9fq+7yKyGuPL3k/Ng+qW9DMCIQDD/38xcXXrH1hj1rOlI7o7psHO\nwgqSN/4Ab/qUqMRr5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc420", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `420` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAc+McoO+ViIGy43ZAMoKgf3xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4ZmVmZTg0LTFlZGMtNGIxMS04N2Y2LWQ2Y2YxNTY4Yzk0MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRkYzcxNGQtOGQ4\nMi00OGQ0LTljODQtMjNmMzk0ODBkYjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETbO4UwBEZjbJvnD0gVKcDHBg55jyj4e5asDr7yE2F/UoJ2fKoM+4Ans2q8S/\ntAT8sM1g6A050sRLm0vmz6goQaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0zj2pFL7vaO6cqpeuuJTHTeCrB4wHwYDVR0j\nBBgwFoAU5EAqH5dtnr6z7aatfngQo8BIJTQwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA846e\nSUzfcQ4RMa9jv/RaUsgqaZzYMOy1Dgs3CyA1zCACIBA5LnNz60v8xVdhPKNVWOuF\naks2COhsu7R7m2/b2Ngu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV//NUphqWsPJfpNXxcXNEfjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGZlZmU4NC0xZWRjLTRiMTEtODdmNi1kNmNmMTU2OGM5NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqmy3eYxVa7ggVMoZL87Mi+4cU5FaHxoX2ewh3Ln/Fu/VW\ngrAZVlpByRSp6PUJWQl2Gp7Msv6SXukvxpeabPdBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5EAqH5dtnr6z7aatfngQo8BI\nJTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAISGQ2rKzpiRVvlfqRRSRIVryLifx6oHxcx1J4tJZYFyAiEA5DVpMV1E\nWV4yMs1OlktBZRacBX0SxxLLqD56Qd4UQt0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbubtFhuQGvpMx+A6QEQ9bmAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRkYzcxNGQtOGQ4Mi00OGQ0LTljODQtMjNmMzk0ODBkYjk2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Y1YjFmZDktODBkNi00NWYwLWE2NzUtMWFiNjE1ODA5\nZDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEilJ5RnWP5WueRstW4phJn2z0\n3tvdTPvBPBoMHS9XGauWPFvVW/nJCjsb8b0hXTxAr7fJzKjQg5L1wQZ2HumrTaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0zj2pFL7vaO6cqpeuuJTHTeCrB4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhALr0pWca\nwnpam6BbP0rfA47RVodohu8VdExD5yxLWxKUAiBqR6RryM6neepXzQMwpASWd7Zo\nB7rEh50oV9IT2gA+Mw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc421", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `421` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAUaFarg7cdlZ1exIBXHmnkbiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YzkzMjQyLTc3OTQtNDQwZC05NDUwLWQ0OGZhMGY3ZDI2MjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ4MTBiNjgtNWYy\nNi00M2EwLWE0NmItYmUyMzMzZDE0NjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8a2imR13VtwrDIg+rjsfWTgu67TsuMaSW1Gy6EOv+2gFD6JghkJgVHIMaxNd\ncYZ+BFGICxUc6XftZREimNTw3KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFM8pWYJ63e6fTQEMJ469Jvn4VtyIMB8GA1UdIwQY\nMBaAFDaExMDnnifVhRI1V+CKqK2fwmXfMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBCEW8juaN9fokRn1B/CKNNifA/CHer5jCc\nDBCd1HbStQIgTExVnBc0yWcdseKexS+dkLUUnuOAx4wzSkMCpSbV1YY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXXeSFsJGc1gcDVeT+MfuePDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWM5MzI0Mi03Nzk0LTQ0MGQtOTQ1MC1kNDhmYTBmN2QyNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATh/QNdMrerJms8rSvprIcBnGq677Mx6iLzaG4C0h0mZRZK\n75r7jObvSWue7RkQY2jJZPbWyjGcHDSaSIH57Llyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNoTEwOeeJ9WFEjVX4IqorZ/C\nZd8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPK4pXm3bVf2POO8Jk7YXTPuZ05ZM50I4tVAmDOT4cPcCIGxKkxer9RRE\nSfF2OXAYPJBueMv4ri0frBIvYxHeJiL0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAfLATLc/qyoY59jCVeOz/Gm8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ4MTBiNjgtNWYyNi00M2EwLWE0NmItYmUyMzMzZDE0NjRhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Y1YzUzYmQtZTY2ZS00YjE5LTk1MzMtZDU2MGRiOGYz\nZmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+GjQxCCtVB1+oIDj5+fTSzS8\n13WZVvx6MjodDM16k10HaBO0851tiBCw4erYbJYc0lsSSS8/K31Qj9E+362qe6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzylZgnrd7p9NAQwnjr0m+fhW3IgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgfZzJNmSh\nN1sU9mQoiLc3ycoKgoevb7c6AC5JiF3Nmu8CIAMRXmjtVTGES1hfSi6IsM954VGl\nTtYbCf9eUcdqO6zd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc422", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `422` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAYsa79L40enqxMFEDQdhSw68MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhM2ZhNGM4LWViY2ItNGU2ZS1hNGQxLWQwYmJmYWM0ZDgxOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRlZmM3N2QtYzBm\nNS00ZDY4LWIxNzctMTc5Y2ViMmE0OGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtN2BPUztWy9VApK8W04CrD6qXbf25Bg2f5XGvglQP1jTPMKuZOXiQftbnkx7\nKsp/be0uo0cY+XnjU2YYaMlZf6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIkKapPpmM/cUhriSpXKfXhjLD/EwHwYDVR0j\nBBgwFoAUedfuaAPJomHzjHI319RssKa5AfIwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgO7mHg1gHaw90\nUkAsqJiSSbmeyWcPIbebUlFTjVifID8CIBPLk5PZNGDQFBBu9HhBmVrMJPr2pdMc\nkTZ8GhRtTyCi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVyoRxqPgZYNWMg4F/yEr+bZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTNmYTRjOC1lYmNiLTRlNmUtYTRkMS1kMGJiZmFjNGQ4MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRYUlq8ymRgxP9pwmROssvtEXstZ3Uw8me0uS2eyu5f0b+\nB9L57J2E+aQH/h5IMh5VgrHvGgDoHRgizdNguAQLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUedfuaAPJomHzjHI319RssKa5\nAfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeT5SBgkl4ZgeXCJSqmIQS4lYNwozjqBXWAJVkcYD06wCICb7OgqVmrg9\ngrYbvPQQVnXtULk5J6m42phnl2t+peNk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfGiHFhbXieWu/lOOgnDr/btMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRlZmM3N2QtYzBmNS00ZDY4LWIxNzctMTc5Y2ViMmE0OGE0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjUxYTYyMjctNWRkYi00NjExLThlMGUtYmM5ODYwYmYz\nY2U0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpkBdpnQh0KvCsddYeRMkFAei\n2MM2Byox9RzLtJ0mepduLlB3mzutvyZpfQQt2eRgqtHUqXG6EW7lvJG/VzX72aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIkKapPpmM/cUhriSpXKfXhjLD/EwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgXhuFvUK6\na+iExox2d2CpKY+Bn4KC2YRH+f2xDkqG/mYCIQDNtnfA2geyA3FCPRa0m1/6Yjrh\nlL1rgfSd+arKXUMDPg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc423", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `423` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAa1S9rvtRI2zZs5Q6RBWoYvDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2ODQwOTU3LTM1MmMtNGE4Mi1iYmNlLTVmYjUxODFhMTg0MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM0YmE4ODItYWQ0\nOS00MmE2LTg1ODQtMjY0OWI3YmQyMTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIMFKS0FSS0OETuD6JS1A9E4Xs+1YNCDMuG7yCcqVa09vOGoL1gh2DZ2WGplt\nAuZYGxNJ9AIQWh0rbm9dBu9fpaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZUMFpbGOI8chP/Yzp5T3rBmKeqYwHwYDVR0j\nBBgwFoAUZdwWlhRrdfDNbdAvUDdi7pVjnXQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKOnRl6dq88v\nu2h9H8UZ7yyApddyuqnRsd4ZehqLiSNXAiAkWiSvEbH3hekche290mpx2bmbncI3\nRNGnXm/26JwZ9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXbrtPdJyqBjZtyPBOnsdcT2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjg0MDk1Ny0zNTJjLTRhODItYmJjZS01ZmI1MTgxYTE4NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASChcMLfqNlCZtiu2L9CO55u413PcSdxrVlOuwO7WC2d6+S\nPHke4GMHXWaFBE70lt3faxGrfUvT9MmS/zgAVQFjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZdwWlhRrdfDNbdAvUDdi7pVj\nnXQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCxBlON/2DhImHbs/24YzrfL+AtbRitToRn0OLBz+G50CIQDQdkrsxLQP\nLuBie0L1ki7u5A6PaZ21xJRr6oxVdCYWYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAS6cxHqMs2+y5C4f9wJIu4DJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM0YmE4ODItYWQ0OS00MmE2LTg1ODQtMjY0OWI3YmQyMTQ2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjA5ZTU1MWYtZDkxNi00M2UyLWI0ZDMtN2ZkODIzMTIw\nNDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvK24Rx0rxh28+p+i1QWqugeA\nA+eT2VwXayQOtpuR02UZ8oDCEF3rWhVWKkHgcxMYs8ejmFTwctO7aT9Bj9+TA6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZUMFpbGOI8chP/Yzp5T3rBmKeqYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgMdFBj4lU\nMyAmHV7HCXSJuGuu00+F3VWy2IqxXU5Q2zgCIE+sqXEVysUUNhUcRF8noxuD2QeH\nUUqp7yyNiD+tkEdp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc424", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `424` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAQKNvzpxdJvt1rea2ipzk88uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3YWI3ZjU2LTZhYWQtNDU4NS04OWU5LTUyNmNmNDJlMTljODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY3ODJjYzQtNzFk\nNy00NGZlLTgwZGQtNDUxYjBkYmEwNWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpr7OEaNbBVxesfnQkBWuaqXLF/EDDIa8Jvo/7+3gK0JH67fAaVdlhfL/Ifk/\nnYvd7ISctUx8t/0TqUxvYDFsYqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Uo9dpeLjaRJjk7H/me7nEkIqGUwHwYDVR0j\nBBgwFoAUbXIyA8San0yqLzS2Pg7Z//TUi10wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICYI3W1gOEqw\nnWWaGKZy4asiN2qcX/xQQdcOhuMBryDwAiBp40jQbMDFMfyA7W3N0HjVYGETpahF\nazC0lT9W6IFRzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZatYG3SQw9I2kHyl7oUH+dGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2FiN2Y1Ni02YWFkLTQ1ODUtODllOS01MjZjZjQyZTE5YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/TGeRZ2FYOJ1ywPUWennsY0goajxkJDzP+NFWe250hDhy\nsNmpQklSk5GwRQg192Rn+rA0rgm1iS1W2Cscbcb6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbXIyA8San0yqLzS2Pg7Z//TU\ni10wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeOAOymCMvNuLBqzbWI/dVwIcytC13FOhzDd6PPErQcUCIQDn6PG5zuOk\nHwNHFIiXPPLt3aycoatnh7LtdA2UZglkww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUm/GZna3BAfboARnO2qCQikMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY3ODJjYzQtNzFkNy00NGZlLTgwZGQtNDUxYjBkYmEwNWUwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDE1MGI4MTYtZDM4Zi00YzI5LWE4YTAtZTZhODU1Yjlk\nNmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQflmczTemPj1/lJavvds2599\nRZogpDMDMC01gBDmdfUcV1ixkfeqpbI25tgo49OgvOFm9m4vTLTxdno+rv7S1KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8Uo9dpeLjaRJjk7H/me7nEkIqGUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhANCIX7Zj\njQ4cgU7GUJ7Fq3olyl6ppLS+kAWq0xPDTjPkAiB3SeG18GTMl3tD9hXHEwZeEExY\nDeUArITr1GiB794sNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc425", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `425` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdHiRgTX9TFvWyhjoKm0COGTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2ZjQ1ZDhmLWNjMzktNDFkMS1hNGU3LWZjMTQ1NDM3NTU2YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjViYmJkYjEtYzc5\nNy00Y2YwLWIzYmEtM2NiMTRjMjgwZjNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGncilZa/pGl/Q+u25wHD/6dq7zEoH8ZMbY4yNZf2pEgmeS2nZEJsdsDdMOgO\nx/H3DAt0i3uWCrUfJp+tOChlWqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCxKyB0jNmKyPX+DESDW1YpS+lvMwHwYDVR0j\nBBgwFoAUgRCn4TG6hcviq5A8mNd4q9yehvEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICYtLziSTjuDhrEXdh3xNlwDrgV7hR6y2Cqbijl5ZSC9AiBYe7RajD3G3bdc\nfw1Ml+1pdwYzJUpXNqVqi8RxtplfAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAauM+adbhcQ01zf7q6O9CXlbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmY0NWQ4Zi1jYzM5LTQxZDEtYTRlNy1mYzE0NTQzNzU1NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxlS+3H5sQRM+rCU8ncimS5IXoduwnuDsaeVliQ7YDAwIl\nf0WF3TONrKjolO+vj0kmQ91fOwE9EDQ0GW/RfG58o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgRCn4TG6hcviq5A8mNd4q9ye\nhvEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJT9gV70ZeRZMGkvPf4flK0oi+wljOTQ9iYNwsSh674WAiBJWwZAyOxZ\nQjIR9cjodhgP06U9fsHoq6v93amQjwDwDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYUHb6Y4ZFPeTDntfTJyEB4GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjViYmJkYjEtYzc5Ny00Y2YwLWIzYmEtM2NiMTRjMjgwZjNmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmI4MWIyZmEtYWEyNC00NzYzLTlkMzktNzEzYmYwMjA5\nMWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM+Cy8YcOnNHfOCx+QY9BTFFZ\n3RbSMXBuFmEZmoJfc5nVpVj6jeZWdYUtfMQY8tc+gZIT99LOm9iYzWxyXI0azKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCxKyB0jNmKyPX+DESDW1YpS+lvMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAIgV5TPw\nTHbdwESxV40+1xTmgPYYrv5GYRpbYh0H+438AiAooaO7n8fXkg4sej4f0Est1HlO\nJnxbwoamFXVbedxIIw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc426", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `426` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbL4HQKDd6fmpF9ABiywQJDqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzMjFmN2RhLWYyMDItNDBjZC04YjI2LWZkMjQyMWUyMDA3MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYxYjk5YzEtZjNl\nNC00NmI4LTk2OTAtODdjMGFmN2Y1MmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIRCCK1g1O7r+3uIQk8DcS0OewORzPYA6KiJjw3HgAEhfVMulp9QkpU4Rp4ut\nfD5/hqQbFH4/ArsfiGl3sHkiNqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwdDcWyuZzvSrlX5udzoWIPK4p8UwHwYDVR0j\nBBgwFoAUk3tZMliu9u6mnoJ4dP3TTl7lHRAwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBTKyyyScHd6fxLBAX+Z0XZ5Rerrvu2KWLRVww7VFMx7AiEAk1LO4/rGD5BL\n3ECr9G1zbBA5EL3hh3/rBHCwXiU5ZSE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbx7R+m23sE75yfQSs/ZEc8IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzIxZjdkYS1mMjAyLTQwY2QtOGIyNi1mZDI0MjFlMjAwNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARv8txhPZOXQsiTP6upCsSsD8q/tlCU06xp9c1Xgrn0VeSQ\nwY4fZjFAqLPjBR1ap0+1D33xtH5Bd6ytYiiClLLVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk3tZMliu9u6mnoJ4dP3TTl7l\nHRAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJhkDabBWoDj1iwLCFGxIZx1+ME6LOZZHcJXZD7ks0jtAiAkUUkrVzhu\nXGwZcs/2833IgpZf/BCT0u0PA8rRhPdX1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZAcvdWqMENXxE/hO8vqStdGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYxYjk5YzEtZjNlNC00NmI4LTk2OTAtODdjMGFmN2Y1MmIzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTRkMGFmZmEtOGZkMS00NzE5LWEzOWEtYjJkZWNkZGEz\nZDRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjoEesWuHubzW+I0xZawTvE9u\nw0y2Vq70UcGO4Wlz4IpJViHUuwgSSy0Tn3pe2CE+EUW3j+PJGwrk3YeIBETmDqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwdDcWyuZzvSrlX5udzoWIPK4p8UwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgajiEY6QW\nyFaDiaGhJDJv9CiisltV4ncoxlVeQ7NJNIACIGF2hFmTrgL43+w4yzeuki0I6qbW\nc9zHEQeVJzbJmdUu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc427", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `427` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAeszQNCV9mZTeWeq0x7Vylw4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2Njk2YmIxLTZlNmItNDA3My1hMzVlLTQ4YTM4YmM1ZDIxMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE1YTVmMWMtNmRk\nNC00MTIxLTljOTEtODczODFjNjk3OWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKH4n2LSqML2qZnLSrZ4yqvLua2lGPlhxjQPmfkqgzAqCI8FfXP2L3iQ/Lnko\ndCHEO8Sg4JRPoydceqPBM7fyM6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkZBJIaTIKDM2WvvTVbrqLT4mVv4wHwYDVR0j\nBBgwFoAUZSJwP7G9kF+x4btK9rc13nF1DQ4wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFzv\nlNdrI2JToWqcuVEAlIRmG+6mAf0KF804Cmy95fHoAiAozY6GMoMU2lp+s603f3FI\n1cD+Et+ysTFsPnULnaR6TA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUAThAEbm1zODcOPRSCBJQpCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjY5NmJiMS02ZTZiLTQwNzMtYTM1ZS00OGEzOGJjNWQyMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbsVoZggqOjZlyQED9LTZmpEYludmYAOcqbOV+ZvvfM5K8\nThmB9elNyLmHI/7f8RMhhfFNebtLQziaMn4R76Olo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZSJwP7G9kF+x4btK9rc13nF1\nDQ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQqfSgzQ3sSt/L41384fP6wpn+MnR9Q8AuDw7Yla2vF4CID6mQWWTGlTm\nFMbJQrMDYaWWHcSUQO/ficmqXC9SKj9H\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfZ6wgWxujKJPP53zuGaOdb6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE1YTVmMWMtNmRkNC00MTIxLTljOTEtODczODFjNjk3OWZlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmVjMmNlMTgtMGIxYi00NGRjLTljZmItYzA3MjYxNGQy\nMjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG+fTJHsdghNb5LjgOCV+IKXm\n1cVlVZZr64e59t4S4JHUjwj15CI3EF//00+YGBvtkd1Uqo/PI02TF2E2kdbcp6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkZBJIaTIKDM2WvvTVbrqLT4mVv4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPzNpgGu\nDc//ahKSf54ZGhUABmHG8X9Iqbmp9e0B9UDKAiA9VvD5FZVYFPi5bmcFgIkRr8PQ\nPo5LOfn9gTTnL7zqrg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc428", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `428` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUGKPAvbzPY6k4LEVoSPYO/eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiMTc4YWJiLWI5YjgtNGU3Zi1iNzg0LWIyYzNjOGI3NzkyNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNjMjc3N2MtMDdj\nOS00YzJhLWFjNmMtYzA1NDg2M2JmYjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqzBwVk+FACAE6houUr2qKiJod57mxAg6YlcsfxejWa6nu3CsiJXqxcaoGIqk\nnrGwNPIW/Nr8RC1zskg4K0IPjqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+1zqcvp1gweLeciNS4Q13Sh507swHwYDVR0j\nBBgwFoAUv95wmSTKkmsiv0+YI1FPYtPqnhQwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQD6S3+iBZSoNYQxN3pfNxbb91TaiUtXjngkjUllVvHnPAIhALcu\n13eHrOtlv05nrDoxaomT+mHOMvYaEzWbOIOlA6Ti\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXowysn8E040hkfA1ORUPh+wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjE3OGFiYi1iOWI4LTRlN2YtYjc4NC1iMmMzYzhiNzc5MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQemYguKKE3gDG6o4MBm1o7zWecL6lGL6anzxXno2R35Vqr\nWMHYHrpP6r2u+wA50AyY1IjuYtCRDuhLfBETdrOBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv95wmSTKkmsiv0+YI1FPYtPq\nnhQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKk1VmwurUtUBtrAL6OQmA8ZyhLWrl5m6np3tejetrocAiBupMUEo7l1\nbENENLgXY/aMsaqQnq2a2CfO23yr9QpBng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASRdNRRB6a7oWJ/+AuUKup0MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNjMjc3N2MtMDdjOS00YzJhLWFjNmMtYzA1NDg2M2JmYjI1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjIxYjQ3NmUtMWQxMi00MTI0LWE5NDctZGQ0NGI2ZWQ4\nYmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJmijOF4cbiPOFenyIaWOqPIr\n6W89M9LY1YqLt9+bYsW/snakxfCUPR/1FLt3/0yDsJ5DWXemeuj3BO7sMOd5cqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+1zqcvp1gweLeciNS4Q13Sh507swHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPaz59J6\ns6oRK2kj9s6wrH6/+Ba/jgdAuCGpP5GFR0jMAiAbmCRHiMQH9kEJRBM2Ew261XG8\n896yAvyYa+nH68kKUg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc429", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `429` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAWTHd3LjHhpkGa/AKHLDxpDIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZmQwZTc4LTMzYzgtNDNlMC04YWJhLTE4YWU0MTAyNDlkNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIwMDA3ZWEtZWIy\nYS00NDFhLTk3YmMtYmI2ODlmNTFmY2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEadMqMO/eAan9PaMpka8Rqqw5xPq+Xu0wVkUH1jYn5qViZAtPnDVKDJ3kKUui\nBspG5Uc4AYuOZO53Jc3rWVHBgaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeu0tUyi7wa3dR+v0eqcc/OX5lNowHwYDVR0j\nBBgwFoAUX2plDcEt5CjuSwL1pEhyWV4kvPgwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIBQsv/5cA6YtBN0qFZC5ArQnP2VoUNF4gDsqcis5NAeFAiAFTME7\n3kADkEGbYouXtkkDCHUIaL4JJr9lPSnvq+htrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXWpXV4ZxnatpY/AEV5s9ZZTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWZkMGU3OC0zM2M4LTQzZTAtOGFiYS0xOGFlNDEwMjQ5ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrR2CAp7CEnstYiqmUsA57hkLMvEiAFFAg5NblR1ZXA/Zq\n9gYPcgncBePze4teoOJZMMzCQoAGISgqwSBr779mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX2plDcEt5CjuSwL1pEhyWV4k\nvPgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI1M4TOrr59soLKLsUTxdwk3AAkgucIqdYfRHZNNIsC6AiEAj7/YT8OE\nPUQB84+Y9COKa3b44DccEwQZv9OLEdyWq3E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAW21Djq9nWzxzfKOgis3k0KXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIwMDA3ZWEtZWIyYS00NDFhLTk3YmMtYmI2ODlmNTFmY2Q1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTQxN2ZjODAtYWY0MS00ZGQ2LWFhZjAtNWRhZmMyODJh\nNjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiQ3RuGBCJ19rUpMPj9dBzaD1\njg+Sn2X37grDFupamTFNC96K7nhowkE6xpunGVvqjuhzNJr+h/sK5gvEG+cMOqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeu0tUyi7wa3dR+v0eqcc/OX5lNowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgDV2jiT34\nPANjCCOE2FFCfknHcSZMWWYM2Zb07Vqkqd0CIQDO6A2UkBIxia4XAf//82LCvyfG\n0Bi1dGZtCjc53FOvZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc430", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `430` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQ/JE3hPb+vgGaVAKuYc9tSYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlZmM1Yzk1LWRiMjQtNDVkZi05MjgxLTQ1MTllMzAxZWJkMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjcxYzYyZDktYmYz\nNy00ZjRmLWIwOTgtZDZlNWVmNjc5MjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExLZoHwpU6faV+1PGfmyzuCfOsCa0TJuoBz1NXdc7E5RnD2YlsOils+pCOZHT\nQsrX/yI6OrP/a4jvXfvf3Jt7V6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFruG8dibsOZi6odLz55gwGJNF95MB8GA1UdIwQY\nMBaAFGqBoRN2vB1bZzg2xns/7mkrCbx+MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAOcYc0pmogJ6W6zOTtFK0LOUjOMjzaTnkv\nJYQZYXM1HwIhALkpxAANeknUL1MeHNAnclnRP+a8++feexN+vJxO9waP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaTMpHX0s7+LZlqtLkB8Jo1qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWZjNWM5NS1kYjI0LTQ1ZGYtOTI4MS00NTE5ZTMwMWViZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARL+znJncrkqE3nLE7PYRqzQduwGiYIg6duCk9REj3CKBLj\nXHX90k11cUGKHZAZw1PUoob4MwYmox0rDFQ644QGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaoGhE3a8HVtnODbGez/uaSsJ\nvH4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQw8NmcG/bcQaJwJ8c+3Zx3XKlwezgXIgeYYR0dnAcVECIQDNYceF7WM6\n9Pe5YUhoZkjyOhywtHPfgrNrH9/6dU2XJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAUKS9TQTHAMXtMalgoMSK3LTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjcxYzYyZDktYmYzNy00ZjRmLWIwOTgtZDZlNWVmNjc5MjMzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzE1NzA5NmYtYjg3Zi00MGZmLWE0NDUtZjVmMmI4ZTgw\nYWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELPXHE9O0LHwAOehMozHRijA5\nzHakAoIyjSe3HmQgyL+k3a3+vxhIxbqUQM51o59XYqozSI7rzntLm1IEKxIlQaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWu4bx2Juw5mLqh0vPnmDAYk0X3kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgDbK5aM4Y\nz8TicMEDkXKSVXcXS5Gq1z4XzCeiC74+u9ICIAz3W8Gja3UIureItc2VwKY4yBBA\nUdy0hehEEeMwqKRF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc431", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `431` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAZahx8Xv34cjvzKr6nfb9/qvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0OTQ3NDNhLTA3ZmYtNDYyMC1hZWZjLTMzYTBjNzI3NWVhNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM1ODA1NjUtNTU5\nOS00OTM3LTg1MTAtODZiODA1ZDM0OGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5ScY8IpNXpuCrfWdO2wu4j467rGA+HFDV9ocVK47/g5pSlD+ZfJJR18ukKED\nmpwHWT26Mt8iEwNwogeaK35+6aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Nl1qkEGiCG8eSCMEy2y3R+TmBwwHwYDVR0j\nBBgwFoAUhTeSMgaYeWJVBpoxfK4ah6NMa6MwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgf5I66kHDdYvK\n5zalxvCXLdr5MZfjoU8qdIfk1RiqFWUCIHgmwegXI2WVvIU1MIw2ZVajpnwY5CSx\nfH6yEcD/U+yt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbxiwIs5BGCLcw7W94uuGscvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDk0NzQzYS0wN2ZmLTQ2MjAtYWVmYy0zM2EwYzcyNzVlYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/qe/IUFJYou+jIFHuy0CjgAuwD5yiqOsYRjGBF6lVEfsX\nh8fEPS+WAfiWQkgLVazu8b7Srnw60sJeJNe2uUWpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhTeSMgaYeWJVBpoxfK4ah6NM\na6MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgISdWLZ6HHCFQPnUr+CXNsG7oVUbFk4KBO335iK3251wCIFPeYX4dJMSI\nLJHFQ9de4WZhRBJb8xVMPnRz+w6oY1VS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQW9NcztZR0HTG3z/FCTJxfzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM1ODA1NjUtNTU5OS00OTM3LTg1MTAtODZiODA1ZDM0OGM5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2JkZGViZTAtNTQwZS00MTUxLWFjMTgtYTIxMDc4ZDdj\nZjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqnR+e2bmf9jXWNNk8wHBKfJN\nswln0m4hfiYq8pS/XMxShbJ1VW+08lEIwrhQTW+aGZ/T6n0ivtiX+XJdXS1L3aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9Nl1qkEGiCG8eSCMEy2y3R+TmBwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJ55Qjj2\njmci4inbRcPx8kM5PJ/IdFG91xLL9GxlP6OUAiEAy4mfO0LjS6VXgO8oEinW4N3A\nJR2YVimWmXGjJAkvjng=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc432", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `432` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWDTouX0BvnyhohuMjEsdaxDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4NmU3NTYyLTM3ZDMtNDA5Ni1hODQ1LTYwYmI5NjIxZjAxMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQyN2JhMjUtMTk1\nNy00MDAwLTkwMDUtNzcxYTllZTcxMmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Dk/yxat9lJFwEq/WQ99tPkDcYR2OgXjN4+rRztBlOpZcO/3M9y/blFwMkLZ\nus8iTeiPVDC90yL4gNAY/JMusqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFtQxNiOWTiv3xWHYrTvuR1LFcNMwHwYDVR0j\nBBgwFoAUWPbUK4a+5m7d1eLue1Ec98y2w7kwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANthz6KAyGQM\nm/2YigMdesysWEIG3IIz9B2JgJfpMK6xAiBgFAegL/2Gs8UG/vWU9GalPcy2gDfe\nbPiIcdBRePaDaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcFXm86uSCAClyQ0NxM4ooiuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODZlNzU2Mi0zN2QzLTQwOTYtYTg0NS02MGJiOTYyMWYwMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7zIOulljY3qlDi//Jy486DqSohgNmHqEpxohFEd1IbguE\nhB/Ijv91842gF2q0Txlla1aMh4HbBp2Lbcdl9ebho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWPbUK4a+5m7d1eLue1Ec98y2\nw7kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK2IFSFPtJw57zFDzjfubK69LmwR/mMs4fPTpc6t/H/DAiEAqv+Sownq\neBD+gUNLDJAiIAq0yCbgVjE1zPy5MkNFK04=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASJZh/zlmAa/VF08nS7XSSy3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQyN2JhMjUtMTk1Ny00MDAwLTkwMDUtNzcxYTllZTcxMmQ2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGFkZWVmMDctYTgzZS00MDJkLThjMmItYTA4NDlkODE2\nNjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpDoQccDIZVe2EBnA6XRLaEY2\nioF3BNyXuWXGluxHQUmmEF7BJk7qpd66iKCwhM0ylzAiVzD1Yrz5EB9MgW3uJ6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFtQxNiOWTiv3xWHYrTvuR1LFcNMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgYAaw+sj/\nnmg1FpZLMFy0Hx5d7+d/R3QEM7y+uPKr3jYCIHeaCS0SR1nHLKChiRYnYGPLSz4Y\nPYsUQUH01jqDTfzm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc433", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `433` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAaDiJhY/W9hZfDx2KFQsRW+AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3OWU5OTU5LTRiY2EtNGU3NC1hZmRlLWI4OWU3N2UzYTgyYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk4MTk2ZDEtY2Fj\nYy00NWIzLWI2YjYtNjM2OWVlYTEzYzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELjtX33GlvZ5zMFp1To12Ju8cVYNB++Ny4r+2CBhSoRA3tt6YphGGMLnjB2oa\ngu6Vhove52BzTutz09vS/09rxqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaK+AMurWLfOaQuHcH2d1PaaOkM4wHwYDVR0j\nBBgwFoAU7U98i8VzaSLMJWzkZWuRy/SFnj8wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA5Xnt+In1rA\nc96Sz3RWItVzIh5DakkGrjL7JkGovShYAiEAs3aDz8dD3TDEvTDkycF+0RnWq+p0\n4zQP8Vdpc0WRU/g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVbPo9lbIHD58HaJIr+SxchkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzllOTk1OS00YmNhLTRlNzQtYWZkZS1iODllNzdlM2E4MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKzon6o9Duua9KVxCmuHHX8SUvDOVx7YQQkvSZ/b2Akxl2\ni4em+vs12hYkrI7542PqOEZzsxtH+4x1x/84eRE3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7U98i8VzaSLMJWzkZWuRy/SF\nnj8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFNdzk/OYOt1QSKf/PjKgZ+1YHYbWCo1xhgrgefv2R88CIALv2eHKKlLn\nrnsuK+k/1m+okjNk4E7Zh3pxZWylCvH5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAR0GOsskSM6Lcb4LtQm+GCRCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk4MTk2ZDEtY2FjYy00NWIzLWI2YjYtNjM2OWVlYTEzYzkwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmMwMzc5YWYtYjhiZS00MmQ1LWFjOGMtMDYwYjhmYmI3\nNzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs01WRNuak11KASvxpBQMWOME\nNvfhdfAI2jMQdjn9cLsyzfm8YCT1y5zw+mVznwL4JKxAZbMm3RNzeTCFwzfe2KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaK+AMurWLfOaQuHcH2d1PaaOkM4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKqFV1ku\nDx6aJq8kInLA2URgmTWHXCwXTwuBCjGLAxUmAiEA8Hsh/nbjfr8GuY0v52XL4KU1\narHvudSzTN/rYO30nd8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc434", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `434` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQOtkILsmKspbOSZ6W804bDvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkZmU5ZDNiLWJhYzAtNDU2OC05NzE2LThhZDBhNTI3M2VhYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY3NGQ0MzUtY2I5\nYi00NTM4LWE5ZTUtODEzZmNiMDc3MjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHAiuDVuoAjhq1ctYG0RCyLNCgkXQn28ZUz3lGFsEtfwCAHFKc5prYOCY6G7d\nGZ3D/0Dtk6b4xii2t1pc3I1qs6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTErzaojlbU1KL/yQR8wkrai6CC0wHwYDVR0j\nBBgwFoAUNwAUh+ba0A/xXLndxNbHqtbb4HUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGU4/PBM4gdTI7o/Gxz/U1B1jVKPPtZucktVk0C2h3BzAiB2SwIz2bKBhfno\njC8K70/9ejWXuM8GuIF14/iQF7IGJg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ175rI42lSnBc/tNgkvJBAmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZGZlOWQzYi1iYWMwLTQ1NjgtOTcxNi04YWQwYTUyNzNlYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfBXXl8balpjT9DSG0kUE9kgHYwvo1wz+aNzwiZKMJMMUZ\nIoZUEa0tw9Pg4FO6CA+paGfYHcBvhhaXxMs3AIIqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNwAUh+ba0A/xXLndxNbHqtbb\n4HUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW3Rq/as7VMZz2cz3KYi7gBU3w3s/TtBBFvrV9nTTTuUCIEYkNZex9nvM\n7N/AyRfhIYIJ5RlLGT/iXQD14B27GKwI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAf104k1tm2e0hjm1nrleYyIsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY3NGQ0MzUtY2I5Yi00NTM4LWE5ZTUtODEzZmNiMDc3MjE0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjRhOWNhZmItMGExNy00YjgxLWE0OTItNjk0MDk2M2Ew\nNGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwoiayuQe7X7P/8Xx8KHKBE7n\nBlaHSyCdCnrNHObEcg7gXh2PIu76tBdSxgg7ZRFaHG1nFHH6A7SzvyVi8tZJZKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTErzaojlbU1KL/yQR8wkrai6CC0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgarzKOOHF\ng0w98xZsiXv2//2Mmd/c5VT8P0VFA2FOYJMCIQCcl5c2YijP08/I+U0LUY3bRF0/\nLjPXHEVv9ou9GNOPJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc435", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `435` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQPnqattwz/3JKTk4cCW6X+jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMDFkZjJkLWFjMjAtNGRhZC04NTE4LWI0Y2NlOWEzZDYzZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBjNDdhNTAtZGY0\nYy00MmQyLTljYzUtYjA3ODJjZTVmN2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoa52Gmn5/LuVHg4VIDgQrSyovWg7yheA4D37CJ4Cnp32GG/zys1/dgpKo5zV\n9VuWfg7Y5uYSCUTNj18dnluIXKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtJCuqwQLUkQEsCS3XwCNrneTJh0wHwYDVR0j\nBBgwFoAUi5m7uSJ3ykruVzs2YyJzUBy5WgEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICIkpYfICFqKsl07YIfTwmjlUkh7DPh3W63mavvm/v8AAiEAhHyDx5g6uTgJ\nQLjj8PhlsaUfqi9TfiyFHFxFpKS1THs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ9M3Sh9Y2ARxxg9Zcp4XwWyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzAxZGYyZC1hYzIwLTRkYWQtODUxOC1iNGNjZTlhM2Q2M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+2D6eQOGbI4IDYqMzmikNWJEfvrnWfxsf25W2LjJQ2HNm\nJ2wSukpGQwmhHQtClUlnCmYKHazkYqiwImSQMSONo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi5m7uSJ3ykruVzs2YyJzUBy5\nWgEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPZVApwBNf3U4o9VSN3zlKtWwoa+QMrsSvegTfuqAUVcAiEAx8+zLdkB\ncvu98rm7ToyY2Rl0J7g6urw7Q3m5yl7KgJU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAUY3qdCOHnkBvJVqdoU1N60oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBjNDdhNTAtZGY0Yy00MmQyLTljYzUtYjA3ODJjZTVmN2EyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjk1NmExMTQtYzQzOC00YzVhLTg3NmMtYWI3NTI2ZTYx\nMDQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESj7jzGwlGqh/GPDDJonml5Jx\nRrI5MJGm0st7ssSlDUUG7cQF6m0yjaNySSxHeLNBk4g4QGYCnI/x7O5/f1F5jaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtJCuqwQLUkQEsCS3XwCNrneTJh0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJuB2W/F\nX9cCtowyGTkQpBT7YvrVrAw5weaTbVKln9hFAiEA0xFBqZPA+16kkOqS2uo4OzDK\nfYy1EPQaWOvFvLH+JoU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc436", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `436` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAatecEPkT7A/LtKjv3Oop+tSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MDBjNmM0LWFhZTktNDdmNi1iMmRiLTQ3NTJjYzQwYjBjZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RmNDM5OTYtNTY1\nNy00M2U2LWI2ODktMTk5NjZkZjBhZTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA897LgXk8Kx0Y4NdHlXl58oCEEoxB6NG8k0Hq1OLopIh5UNu2nm9sg0EU/A/\n1XL8maBKdMOur19B26y6K/OVTqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfuCrbE6v5+68xsKTH7pHv59S0mcwHwYDVR0j\nBBgwFoAUIBNd6jm6jXF9pLgAd9aSDzr7ToUwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDFS\n2iHV+d351ITW+gtgE5NlhHx5ipnfShUf5++0KEfbAiEAiA3AJ0p7W+wZBSFZ0Nnk\nJngFwIQeyH7kH5Y/8VF7gXk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUyt6EXk4RRvf/ObbDhiAHwpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDAwYzZjNC1hYWU5LTQ3ZjYtYjJkYi00NzUyY2M0MGIwY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4MUIVM+rVA6/JQCvR/NGP71/eAkolPt8UjRgR7onW+KO0\n4iHUjXNGJWl53z+kJr9MEMecKAjU0KH+iAb3dZ2vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIBNd6jm6jXF9pLgAd9aSDzr7\nToUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOag5AbmWmBNJbLpaX3MiXhJCY86n3XDiKm01JSfucbtAiEA5cQZdTzE\n/K3XbSuVsQci9dCUMrFRP1RVThFg8yhlo0s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQijmHKHUGfch8ngpE3qOj64MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RmNDM5OTYtNTY1Ny00M2U2LWI2ODktMTk5NjZkZjBhZTQzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmYzNWU0OGEtODM2NC00NjNjLWE2MDMtMzMxNTZlZmIz\nNmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKXLEM08qFy7e/pZCzprBTp6e\nScESq5qGAZ5FOOQ3fw29+RmwY3vMybvrRlM8EAYb4nwwb1lr1KPPNr88IJ4wb6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfuCrbE6v5+68xsKTH7pHv59S0mcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJ07xBC8\nLDcWxdjCTMMHVNpVNIoezOTt/1N2CD0Zs6WfAiBnIVBlzdexshvJMJJQbNmzugaV\nsfR4Wm0gpisGkJkQdw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc437", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `437` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZCafiAVWnbO1GjWJaW7GUqzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiNDkyYzI1LTU1NDQtNGU3Zi05MmI5LWE5NDMxM2ZlZjI5ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk1ZTEyZDItYTZi\nYy00YTM0LWI5M2YtNWQxYWI0N2Q3MDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE79b3+fVvft2gdZLzM2W6K7P/3uN6I28D/CkDX3NCqGTtv3s0vO/8vi8O4rdp\n+zJPuiXu78vsbOdcRNjU8BRpMqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAm8ovjAKMKPG1VnELV/8l9n5WVkwHwYDVR0j\nBBgwFoAUSe74ODLHkXgsZTHmJAZGOAu9yS4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIE1nQJaByNHB9YxLCD3OxWKsjXvJTDLlsHcOjqtL97t3AiEAji7n\nQapUDzJyF3Lke4q0oFPCXh3wo8X+sQlSWsj7lzg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAakHDPdq53jLlaszRxVWUrrIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjQ5MmMyNS01NTQ0LTRlN2YtOTJiOS1hOTQzMTNmZWYyOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkgHEu5LAoywkuUiJL0lpMAGKvDOBw5gPZZeYq9CgekyNZ\ndsFlo8XPrN52PbHpsKKHuPpBe79RwHtyrwGkZ717o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSe74ODLHkXgsZTHmJAZGOAu9\nyS4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO9/fGYJa+Ks1U1vfT8GAOxKidOtCZnvnx+bzFe5ssFSAiARLiRJsamC\nLaswkXSWHFERyIEMn3SamV/IjFSCqigmJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAdp7QxEigAJR2/g5P8PSvVWRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk1ZTEyZDItYTZiYy00YTM0LWI5M2YtNWQxYWI0N2Q3MDZmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFiZmI4MDQtYjgwZS00ZDEwLWE0ODYtOGJlMGQ0MWVj\nNmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESK1vPdJHn0z6YGUf9fDsmkaR\n9coKtEPfwaskdiBvBxdKwSCvv4A5NzhOOD7G1w2JnqDa/9/dH1ffXN9eef+EFqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAm8ovjAKMKPG1VnELV/8l9n5WVkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgBUR/o/E5\nnmiFYmgSLlxGzkzuVFQzupVp4PMlqWI5icACIAwItZZZmHg6FpAtU5Uzp/zpc2au\nsjL+JUNvwawneC2X\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc438", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `438` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQxDfwkJtyPjl8C6Tf1u/M5TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4M2NmMTVlLWM2YTctNDQyMC1iZDQ1LTAzODE4ZjcxYWE0ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg5OTA1ZTYtNDVh\nNy00YzEyLWJlZWItNjUxZDI0OTFlMTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJT27GWpW6/4lSz/Seh8bhXzN22rSKe5IVFlGqy3T/P9Dbo9adtPUeCauH+Vh\nP7Rh7I6smhokhxjAIcdXHeLJiaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMnsKIp+FcdtH0Fn/v2D1Eo3rR04wHwYDVR0j\nBBgwFoAURSTqatgywTCrBQnsAKvw9jfzq1QwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQChoV33juhWQVl8pCpvEVvun1D7OOrFELD0bkGjdOdOsQIgI4EQ\nZNbM3nePHcwfMm5tX5JCZOVHkXm7G5zlWf41sVk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaZTOh+YlKaYiRlV3GjTL8hqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODNjZjE1ZS1jNmE3LTQ0MjAtYmQ0NS0wMzgxOGY3MWFhNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSBM34ykp+YCCQnUgFu2TxopkubYrUiRfu/bmlYUTIiOUB\ni7XmnYIUKDHerHEzKCeHCj4ZIPa5EcqWGi9Be1Djo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURSTqatgywTCrBQnsAKvw9jfz\nq1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMwwyyWuUQUvibz4mVVleYj/2qClf/lc5r0F7vS7B/avAiEA+8gd51R4\no1coDG5ZjlExc2+dHqyclBunHOBGiqy2c/8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAc9e2IGXFcO4E7mEbuft9DcrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg5OTA1ZTYtNDVhNy00YzEyLWJlZWItNjUxZDI0OTFlMTNhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzkyNjg1MmQtZGE5Ny00M2Q1LWJhN2EtOWQ5Yzg3NmYz\nYjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvO4nhHfaJB7tAHFcZ774aWTe\n/kXbFaJCv+wSkxBhs8uM/peCwbhFg+8wmaQ6uRg/RsNELY447ZEUQRYwPS6OUaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMnsKIp+FcdtH0Fn/v2D1Eo3rR04wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhALYE91Ka\nnKS9xe79Sz3o5JorMRKy6J69U09eaHpS9lB6AiEAyPHLVc/EcFzdJ+l58xGk2Wd8\ncGASPT0pGZEDdJkfxEo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc439", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `439` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAbscurgjTaL6y4bxKi/SIq/HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NTkxYjUwLTY2ODItNDZkNS1hNGE0LTI1NGYxNTgxMDgzMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTliNGNjM2MtMDgz\nOS00MTYzLWE2ODMtNjViMDNmYTc0MDU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEajSDWzmazjJMjjKS0J8h5eYTkMYVNvt9nE6C0UA2GcUJph9FXJUFMCPIve4g\nk8Sk1I6cMm1i5AKcvAtNNFt/o6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTUzVpPfRri2cKSNijwKLyy7xbQ7DAfBgNVHSME\nGDAWgBROxZMPBJSflvZKBb/ExgHNv7rKnjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHKia4RNfXi8S/idaIRty/7pJz7OZm5p\nq5UMyidKHyq9AiA4ibxy35d9qhkk+tI3UW3Po1lp2ArShkpaM2wmbjjh7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUf9wbPrugcMvrh5iWUENMsSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzU5MWI1MC02NjgyLTQ2ZDUtYTRhNC0yNTRmMTU4MTA4MzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQD8pk8VX74zPEtSxyfyZNGV+yWMyCJBzdQ0BF4O4tDKJBv\niAYB8x4bH5pFcRbYL52XIaDGfftUXuZqq2TqS8+uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTsWTDwSUn5b2SgW/xMYBzb+6\nyp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPd3bHQOFSHh2XdG6QTeP/yJGKbcpoEYiGC3ywYtjdfPAiEAuIRJed+r\nC2G6U4bXoy3OijIC9YFHU0ZKgGeDJwDpNtI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAbOeYlgf+CU7F3AiP/jt8wDEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTliNGNjM2MtMDgzOS00MTYzLWE2ODMtNjViMDNmYTc0MDU4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTk0ZWFmYmEtZjdmOC00NjEwLTgwYjctYTk0NjFmNTMz\nMTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwePNYgqm+u9Q1Ugv2oCl4l2L\nMhsJ6BJixwfXPvNqz0qnQSqCYfWz+l+P/t53lsULZv06oPffvMJQfr2J5ZsMb6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1M1aT30a4tnCkjYo8Ci8su8W0OwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAK9DXepe\nBV65EfhqB6wwd6C7Y1MUy/ceH7C4/GtV1szjAiEAzxZl1O9Vw/bkfZN/l0yNWp8V\nbUJqIklboeRD4dRj30g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc440", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `440` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYyDhj+10HwogvsHwTWLW6FJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYTJlOWEzLTc2ZjctNDRjNC05Yjc2LTc3YWFjOWM1MWYzYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJlYTM1YjQtMjc3\nZi00MmMxLTliNzAtNzdlMmU4NTExYTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK8Q4aJ+7hGedOcGXzGFG/qyT3JgWDSUToaQhsWaK/XabHaoo9rmyQeV0FFi7\nqLsehoFquUsIFRyf6ZpsXeVZ3aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWHRHdZqDP8ahFoxkRm4XHVgl3HcwHwYDVR0j\nBBgwFoAUevEhSYWhNieLvRqNPuiFkr8I7QQwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGhcX/G4pUpn\neWuoXlggL4buJLlh1LbZmd8H73moiMWfAiAfxCWwgnFSjdpTXv9l3dlE30Zj+l83\nbhHp1UEvOcIuJQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaLcPGyWKT9I3nOd47T6JMBzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2EyZTlhMy03NmY3LTQ0YzQtOWI3Ni03N2FhYzljNTFmM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQWDwmIwMBB4+HjeiX1bgLinPy1De2Z7C+jN1H+g5iPtig\nkyQnIjaGmV4zSNlpJ/ZaHT2q6YlpNDXy7gLD1O0xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUevEhSYWhNieLvRqNPuiFkr8I\n7QQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOlbbCBrDjQEWxAiVMdiZBiMDWpYBkcTecy1nskK0Py9AiEAwOrlvsXm\nGnllHARNSnUge1qnChOoCK/Xc8qatOoQVjY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYzbo4pORyfEOT2x22Dsjo9GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJlYTM1YjQtMjc3Zi00MmMxLTliNzAtNzdlMmU4NTExYTRmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjk1OWIyYzctOTIxNy00NzJhLWExMTAtYWI5ZmJjN2Nm\nYTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk1M9gDDnbCQGQC4Jki08BrKj\nrNG0kUBXKBvHkrAfxtIn+1KS8CgsSUgXmJ7tmI43Tjvq+hRanZMKORWC57B6LaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWHRHdZqDP8ahFoxkRm4XHVgl3HcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJ7QnpYo\nAvcLzW+aozFXDywVoeoQDZceIIXsKqpLm3gAAiB/G90dlkcT00pVowXr52cGqUHf\nBomLoW3fGez76SbVSA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc441", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `441` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAXncNdJzFDg1O3OLHg5UQeB+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0YzJlN2I1LTY5NTItNDg1Ni1iM2I0LTIyMjhkMThkYmQyNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc4MjIwMjUtYTMw\nYi00ZGIwLThjYTMtMjVhMmI1YWY0NTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMr0+ZIw0fTJaEPDu2Lw2mDaq0r55glbf2LqNArbyfeKx5ITFwxk80550PWd/\nxV6F3k+Oa0iss26nFrSiSUQ1zKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSKA4IFzJnjM27XjnIE7nFN7E9WUwHwYDVR0j\nBBgwFoAUMi75luVhILgmmCwHfWrAzq3k128wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDYV+VO0fup\nbum/htj3ItPRUvZcI+IzBBDskedO7h5yOAIhAMabKQmfCW6dXef21I1P9rcMisHY\nYE0GlVwxF4AQoOh4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASNdNQeGp3suHfnf3PHlvldcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGMyZTdiNS02OTUyLTQ4NTYtYjNiNC0yMjI4ZDE4ZGJkMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvd8D5lMw9Bw5KJQmjMxIzfBMVr33uKQR4kDu75SnKiP6Y\n0jBeyvpx5lbO0bJfozt0jQLEAUM3yMzJCuEvedeGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMi75luVhILgmmCwHfWrAzq3k\n128wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaBvM++KdYCi0ACnkbCDH87KGrQr9FhMA8oHknJ0BRlsCIQC0Vxfbfiqc\nzOLc9nNAbHbCn14qMuXNhDqBiV/2fkrlIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATZhAsGn/knhMfNfzj6iT+MEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc4MjIwMjUtYTMwYi00ZGIwLThjYTMtMjVhMmI1YWY0NTVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjY4NTU4OWUtODQ1NC00N2E0LTk1MzgtMTRkYjhlYzkw\nZGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEai0FvfGTBTrYxDnzsHyxrLbU\n2EReud26Qp2TA01BBcYkPVXcOxV9/F9oOZECPZl6G8eEePwv2qaMhx8skQOA3aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSKA4IFzJnjM27XjnIE7nFN7E9WUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAOKIyAE9\nWxZ6r7d7ssPG1TTS0KmPZSjCL3Cc44OrvuL5AiBryPj9FRrCVHNBlzqOvGF5KbnW\nBjE1WpO0jd9lpw5MqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc442", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `442` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAXlKPCPfQXOBjjnqJ9X/FAc/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwODJjZDIwLWE1NzctNDVjMi1iMjE4LTcxZTUwYTQxOGIyZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVkZmFhNjctMGMy\nNy00ZmY2LThkMmYtMDE4ODFiMDUyY2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0E4iJtKxN6UNsnYMALVN0+OkGyZbT8dq7Ki2iGPjnAFCICgwfopg/K0MLxxu\nRySbpORJWVBXaePOSgukOS1il6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjLrUpNzWnerIzbzNnzRbGgNJbiYwHwYDVR0j\nBBgwFoAUBKkfcI5n7fj5M3drpEQQyfmGxYYwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAjZsL9W2GA\nTor9aeelMA4T9xqQnzwon4d+HjUqXRAHSAIhAPF/YQvHXLe25b+gFAj0VzV+j34S\nzdwAxNP4RmDxuurj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY16Z8w82ADZLlRMZe95qMAAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDgyY2QyMC1hNTc3LTQ1YzItYjIxOC03MWU1MGE0MThiMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeXQSKOSNBbvr6PjfSplFnOQUp12lK7Hv9DOtzUwkhxM7k\nM4VuvoRXlSHMMaL0RUbGru8V3908qLK6PA4249guo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBKkfcI5n7fj5M3drpEQQyfmG\nxYYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIRDGBJk0GIugIE5oFZtnTeuNfG/XMy1AacI90hcGjZpAiBsF3D0fo+r\ns2pnyorXNGfgIPHxSVva5rIvH232XjV6gQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAX2QUukXfEyAv9LQG2Vnqw21MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVkZmFhNjctMGMyNy00ZmY2LThkMmYtMDE4ODFiMDUyY2U1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzZhMDBjOWMtNzE2MS00NGNmLTk5NGEtMjU1ZmZiZmMz\nZjZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZ5WBPe+g04xWtHvSa4CWxBxf\n0mm1D9VDpfPYmZk79SOM3WmmmZp08AAWetJnoNOsrMlxD6knsbgXZxNshZh/yqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjLrUpNzWnerIzbzNnzRbGgNJbiYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIga2Jkgs96\nS/EYWy6Qztv8GeFuZqXWxNUdZ/EEqvijpmsCIQCCavSdPrOWMgRIDME5LA9/XGoT\nqpUji2L82B/YdS47bw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc443", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `443` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISASqRXz1Jwx4SfAI5VBi7pnfpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzNmI5NTIwLWYwMzktNGFhYi04NWMzLTZkMDU4NzllYjNjYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ2ZTk2MWUtZWZm\nNy00MGM4LWEzZGItNjAyYTFhM2I0ZGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYNmfPYjF4mYsYOLX4GBzYJwJlioPCQUDN43bcCsjkpLIwHthm5pPtFNbzokM\nsYMi31p7M/5HyVbWwqcO9O6r96OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTZHAQwcYqOY4xw54FGKLhQ3JR1IwHwYDVR0j\nBBgwFoAUm5IBtK9jYdmBmccNgO1UnOAoqvAwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAsBdk91uQn6VinlhENsIWS68Bbf34snN4gmvDPN8cwT8CIQDecIHFPuSA\n8tciVo033a0HK0VYDi6M6iEnysib1JhbFQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcurWemcaSnZpvI8I5hzyTNeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzZiOTUyMC1mMDM5LTRhYWItODVjMy02ZDA1ODc5ZWIzY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzph/5rqWkNH8NhAEqrcvs3X4hEsUnSVpJa3ClbAsfrS/V\nck6ffeEugwOT2d95BVjTWVVC8+9/ILQ7HDAASvV0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm5IBtK9jYdmBmccNgO1UnOAo\nqvAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFAQYdaZ0o3fC275/QDHQm48LmSXERIfnO2+tSd/NlW8CIQChhGjsDacq\nRTXx7Ut/SFuEW8TbV6M+JKvYtQi7dFxvqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAYG3xiH4MkwkBUkN/poUpzt9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ2ZTk2MWUtZWZmNy00MGM4LWEzZGItNjAyYTFhM2I0ZGNiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmM4MzZkZmMtYTI4Zi00MzE4LWJlYWYtZTM0ZDNjNzI3\nZjU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDzqeMbE5N8BJliNm1aFMBMoG\nMOtLkS2ynRPGjG+kxYP0VAwbO2BDb+kQMRbJCbSMgcMA3oTrUD5YBss1lPZ+TqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTZHAQwcYqOY4xw54FGKLhQ3JR1IwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgEZv5Ny5z\nfwPhTsq+6b+QwuRifdQcs9JW2U/xm9pYYLACIGpi7cWPjtTi0fOX9DLG2o1OzBJB\nZmP2d53hTGrt1qoN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc444", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `444` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdc6Mdxpby/FqgBqUtgM0wy1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MWM4MDBiLTA0ZjMtNDgwMS04NjZjLWFlZjMxMDZhZmZlYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VkYzg5MmUtMGJh\nNC00MWI0LTg4NWYtMTQzNTg4NTc2OTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZAst7zfBUELKHe/3CGH+0UYGIYP2Ldyr1IPAArfJK3hGTJQtW1Bhh+UQZmv+\n0wofIFZ+Grp8fOyUahL6osF09aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Ii+1yOPMsae0vEumrmwqLczYLwwHwYDVR0j\nBBgwFoAUy7g2uSxbC2IPs+snC62WgDH2UB4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAnFKwRJIuchnItf91eRVG2rLv5p/O4f7Kvl2qmg7QnjAIhAL+RKFo5W8WJ\nLizfhr93BzbJ3HEwFqCUMIawlRmy0rxO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc4pQ6DSKJmGhVd02W5i06XHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjFjODAwYi0wNGYzLTQ4MDEtODY2Yy1hZWYzMTA2YWZmZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjp/euYE3kJJaf6azohrs86Ap4yaI/p7WzS7CThhDwTlUX\nUiwGRoAT6kqCsMD3KmUzsQLSMOu0ChxHTHirKw3oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy7g2uSxbC2IPs+snC62WgDH2\nUB4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN3BVGfq/r7UBHwf8h1fNs1y1bOOyK1xhN/qBgvDh/DYAiAhykT7VNDG\nNjAcrydFGC5VmIpGscG8z4v0wevt0FrD/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAfdlE7fSarxMNyedZHjlMdqpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VkYzg5MmUtMGJhNC00MWI0LTg4NWYtMTQzNTg4NTc2OTRiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmM5ODM5MTAtZDMxOC00NDE4LWJjYzEtMzIxMmM2M2U2\nZWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvRus54xhTvt7e3+kEsBLkXg4\nu1h/GqVUcMh/JurC6CQJHi/iTsl3kjOddaOX4UkHdceofmMmq/8b3/+zJy/d1qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5Ii+1yOPMsae0vEumrmwqLczYLwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIui5lAl\nTgbKZJkPXml+ViWssSVk8A6qlN62mt/za3Z7AiEAkF4jcIWgid9jTwQLBGa9xg/Z\nf8H9fMeVYter1XxgPcQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc445", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `445` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISASd0rLCJ4V4CfVxcvOEWp/uJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5ODVhMWNjLTllMmYtNGM0Ni1iMmU1LTYxNmI2ZjU2MzJjYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTFkYWRjOTgtOTg2\nMy00MWE2LTk2MzUtZmIwZWI3YjlkZTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0TEqYewDSU3EVxFa3PUawMdWZ//iuwE0ooqXnPTDyfkyWQwEBR8kV4+q6lZ0\nAl4eY9a88GjwlDOBdyZhMN8riKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUJN7XPkpCxbP4zZhMUOcAr7ZnQYwHwYDVR0j\nBBgwFoAU4RscjGt988hiKMSdn7yaqch/QGkwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBo\nyVw32QbiqiRz7OtHEn6BoI5C0W2RNks6WE01gMuknQIgTnZjAnKizkDPPndUx8DK\ndbnxO9ZYN5JD3z0Os9Zzl8c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcNpqR9mRzP/ZRHpiQXxKqADMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTg1YTFjYy05ZTJmLTRjNDYtYjJlNS02MTZiNmY1NjMyY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPkrZwpRLJDQz1qYMK/CZFAmoTs/KPt/9Hqf1LvBzXd5KW\nUBwQVEZPNprH7gCsvoES+RANXKytrcJaTXwAFbnqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4RscjGt988hiKMSdn7yaqch/\nQGkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQkYzJX6JfhoNDH9LeTeTsYJBLlJcEqm2HhcRF8t8RxICIQConimwfRZO\nFJUkQBtsXrTPVFXcQO5FOuXg483Wmkktgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAS5eg+Bx4wPEcxV+Jv7RNpSNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTFkYWRjOTgtOTg2My00MWE2LTk2MzUtZmIwZWI3YjlkZTYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2NjYmM0OTgtN2RkZC00ODU1LTgxNzgtMjkxNjlmZDc4\nMGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESedY/jfRczXBhUgxSfk6dswg\nJQNb+tH+3zWV5QLtWETNxMRrXMOQmCWTReKGmxVexKnayCRttTfr4hJacOdK6aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUJN7XPkpCxbP4zZhMUOcAr7ZnQYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgPXO9EGL4\nEy/shjATOjSAJUKvU60Ez+isJ9nI93sWMOcCIQC3zXTm3+RME6E71NiU1FeBpjbe\ncAxG/q7FrlRU1Dg46A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc446", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `446` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVDrh0Kr/o7QpI3buplI6RGVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzN2U5MmExLWE0ZDYtNGRmZS1iN2U5LTMzZTZhOTBiOGE0MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FkNzM2Y2ItMjMw\nMC00M2JlLTk1MjUtNmExMWQ5ODdmOGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjNLyWQT5B44453CgEz9GHTo8DOKrYNiVA5zn/lpcUYZYpj+ffHK3bvJ8R2ZY\n82O8d1Dez+dkL5os27j1v78UFaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwjL1OW6l6s7ooFq4mLxmIB/48KMwHwYDVR0j\nBBgwFoAUWUu308VxE3TQFQPYCviKCmqZzO0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiB7X5wOI2+aix9S6LBEo8xsG9bdMeIglU3irsfoZPhKPQIhAKv/\nJxrYzxL6D9WAbS2GmJWjsDSoTLyWD1wd1eJZGhxw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcQqWXusumgruFUE4Sxf9wUxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzdlOTJhMS1hNGQ2LTRkZmUtYjdlOS0zM2U2YTkwYjhhNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlTBEbmQuW/agOHTZIfi2SdZ+RYdhGS+j8xICuPv5bEDhz\nnQjX+67rIrUEbOwUwcVLoe78h+MnJlmaf5Fi02/vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWUu308VxE3TQFQPYCviKCmqZ\nzO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBNKGH7K4BLV/ZhhHdLFjLexSKTaT/vYxOk8aDmkIZt4CIFeuhzgVFRMG\nP8DiWB6COmJfvX62e1kIcFZwVT0JJp+Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAc2UcRcYXHDC8Eh3DNUvhAHqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FkNzM2Y2ItMjMwMC00M2JlLTk1MjUtNmExMWQ5ODdmOGE0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDNlZDc2OTgtYTY3MC00N2UxLTkwY2UtYzk4MzdiNGI5\nM2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4IL2xruLfxDMPoMFGuKWfEnc\nxZHEYiZ6Eu4CWbOLPIRbd4rN3hF+8KsKrFXWj9U84+LqHCjTXPuvwQthwpkE3KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwjL1OW6l6s7ooFq4mLxmIB/48KMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhALfAfcMn\nmhEqv9g8bvLn6WM2Gr3rgUK9NkaLRL9yfJIVAiALoGjAe5dOrPnrPWqV8VbbaFOg\ndh1tKZf+xTvt4l//Ug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc447", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `447` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISATpjRYgEmBjxy3j1GX1WU1nVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5NThiNmE4LWQxMzAtNDBjMi04YThjLWU0N2MxZTgyMzg1NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTE3NTk4NGEtZDli\nMC00OWIwLTg3NTEtY2JlMGJjNjJkYTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX3dx4dc+M6nzvAurYPIuIGE9+svV48irdg0c4FyG5Law0StLV4Lc/27XiKkt\nhYntyuNekJntuBfEwbz+zGGcuaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkuERb7WxZASxzg3s6ry0hY66V5UwHwYDVR0j\nBBgwFoAUTI1IWfe00PdVoWEnZpCjSHPD+FswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBfBI21dZKcp4wcU2lJepRpBfcwcm07aIzwhFla1GnxQQIhAIgw\n1vk4UPagcBkfV66Us2KFMobRxAJdFywDLwfVKfvk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV0LGxczRqCR2eRuJSUap5sRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTU4YjZhOC1kMTMwLTQwYzItOGE4Yy1lNDdjMWU4MjM4NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMRU2miTzcCMP+VDEKe78H+iCB3K1qwZGML4ozSt92uu7/\nJ7pYdjqgSAmdWInyuV5iiaMhgKQaarvjTlUYIqrVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTI1IWfe00PdVoWEnZpCjSHPD\n+FswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC+p6icNFoO0E/seN1/a6M0Kk3zXzcgAOpu9FuLByHrECIQDSYm3Il/H4\neBh+zs6oTyN1m42NuYbvfJ2shxiBSuMmUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAdFS9RlzF/qof1MN9FcFQySvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTE3NTk4NGEtZDliMC00OWIwLTg3NTEtY2JlMGJjNjJkYTczMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmZiMmJmOTktZjFjYS00OTE1LWEwYmUtYzFjMTA2OWNj\nNzc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKWDx72IBe1wlqicifQfqbq1s\nwTjYp5pzm/L2LkSjeaj9rrPESnc8mz6fWuQJkQhHOIUHgc5H8JtSeJsyUyyWFqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkuERb7WxZASxzg3s6ry0hY66V5UwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJAajisj\nJ2OHZnNMh70sAIiD6LWZp6ESX8zP/pFX6QoAAiEA4YDK7xSvgw2nlUqUcJ9dJ9+D\nQCifQzuNVXbM9OFKgJI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc448", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `448` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAaRD3LpcUkkSX7hHgXm9gjfcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3Y2U2MTZjLTUxNzgtNDg4Yy05M2JhLWQ5M2QxYzk3MDBhMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA2YWUwNzktZGEz\nMy00MzU5LTg4ODYtOWViYWNkZTY3NGU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7HTIBfhvWx3wBZjv42NsM5ut1Qb4PfF5H5M26kRLEe9Dmd/M0+49zgXEfkH9\nlsZDIyQ3mXWlXVpQyMzexA9tq6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVNmVDlM6YVFo3BMQfc0WAQgBZqcwHwYDVR0j\nBBgwFoAUkum0vj2AlT0ODOkCEVyPLtPqpXswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBOp6K8WMLqE8kR\ngZHxxE2CW7q7sIvL63xA/RwGGUn3lAIgf2rtyJuUkMJYRGqZByv6SJJXNzpbJPlN\n2gQPcyvJ8tI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWQlAwVgLF2nve12+msgPl/3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2NlNjE2Yy01MTc4LTQ4OGMtOTNiYS1kOTNkMWM5NzAwYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzp6lXA9l6QD+jtSWI3wEH4akO/OYlv3bMF6Ja29oeZ7Up\nIJp5Dcqd//bpr8PW+cKy7gCWlMPdYy4RIJjNrCbpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkum0vj2AlT0ODOkCEVyPLtPq\npXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVMryrJYkebbqAysKPBOJp+FTWUPweiM4FoX03F05JmACIQDBs+0sndYE\niWKw96e4NHS0VmcxsFbaszq17hc3+VwD2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQMl0875RXXYRVH6xYm/nT7PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA2YWUwNzktZGEzMy00MzU5LTg4ODYtOWViYWNkZTY3NGU2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWNhYjc1NDUtNDJmYy00NDkyLWJiZTAtYjBkNGE2ZTE0\nZTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOLywYNPb5HhKY8FPWlkbo9DY\nNQCMTqVWhxZxNGoZ/ayx5shCdIDZqvoa1xyDs0wh7ZwHoF0NiU4S/PqOtqdnLKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVNmVDlM6YVFo3BMQfc0WAQgBZqcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAL/vO7e+\nhAzTERnQiJ00DDaDOEx1m+jVSDgldlxZPmGtAiEAkNcxzFDoAGRM22OtNeNdB8Qv\nWMTqCOyQ1jRqZbjOm5k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc449", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `449` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATvtIiWPjcOks1bPq3iPvbHfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllYWU2ZDBhLWExZWUtNGZmOC04NjMyLTgxNWRlMzQxM2NjNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmIyY2I0MzUtM2Fm\nNi00MjQzLWIwNzUtYzFmY2RlMGVjNmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM9HPfh1cKkhKUDhv/a5FuGESiE0PSGINPD1wol+5oN18co2/+E/eDeIw+QdD\nmCno39dUswlFuSX0r8mXPxNGhaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+1enKdW7h9wffv12IZrKlpPzMXIwHwYDVR0j\nBBgwFoAUizmTiYy01rplzPAsffw6S/NaoPkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCsPfQVuMRRMNErOf0bzDM9V/7SCZ5AOSIlFbU/VQiAfAIgY3lHclJumS8C\nh9Vme9FTu2Yy3TYYzSeizUN/RMvDC+E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXMN6OCHEQ9bqCxCkluxRJddMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWFlNmQwYS1hMWVlLTRmZjgtODYzMi04MTVkZTM0MTNjYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6qqB9DBDf2KIyhdHe7fPQCwUgaCE+XaRr48uSv42wwOAQ\nbFucBCzJ8fWx+N/T5c6mjs/dpcrtXVBcrtrS+XsZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUizmTiYy01rplzPAsffw6S/Na\noPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANhB8BpiM2r4E8rB5XHl3YgniRqQfLRTsuo7V7XkNLo1AiEA5z+4Sz21\nduo8xmNI2kBdc75Xepd5yZ/dyC6x4hcaRUg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAddvJMBAjwwJraEVmlDfug8/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmIyY2I0MzUtM2FmNi00MjQzLWIwNzUtYzFmY2RlMGVjNmQ0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzU4YmQwMTgtMWM4Zi00MDFjLWExNjktNmI5MGU3ZWFh\nNThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjOPInnTnWYYerDLt/AD8eNSJ\nwFSBqNPUs5X3MOWLgBa4fkpomgVJrzF8NQOGp45dYZx2QA6LiGLLvpG0/FLXw6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+1enKdW7h9wffv12IZrKlpPzMXIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgL5tD/s/L\n3iiMq88TshUPGWnhALvGovQbFgRO3/eIkSsCIElKXoz5rK8kWzuOvpehfSy57daZ\nNYm9Lo3o8qI3BCQL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc450", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `450` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYKYBiZGVPG9rFkrekf+NnBYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmNTZhNjRlLWFiMjEtNGI3Mi04ZmU5LTBlMWIwZGY4NDIwNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE0MzZmYTQtYzhl\nNi00MTUzLTg0OTctZTM4ZGNmMWE0MTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj7tDeAISeFKFkTQ+tu+D7NNt/O01RtJpVxPJ6XEvyuTlasOGjkpbz5OPEgpl\nwyr1BxV6ARHi7jZsuAI1VyyXwaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyuJHb4ASdDcEL8mVXcRLE7ixFTswHwYDVR0j\nBBgwFoAUEMTCScAPRdpnbF6e95KwKkitE8owNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFdJwTIU8vcQH3hHSYD8jWYuPiWNX74wAI5aGGpKqKhZAiEAzBqI9FoSbeWy\nUqYDLH5eXgloQdyXRGBkOnuUuVYZ2Zk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdcO4ENh0w9FlbISSeM/cr/zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjU2YTY0ZS1hYjIxLTRiNzItOGZlOS0wZTFiMGRmODQyMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASi6r/nyB0UYPKlPQeh2WkfYQItGZutYoMSnhDqMI/4zLe2\n6fZp7+ECpzXmufzsi84rSxfhWTnFoXgeVt6s1tq8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEMTCScAPRdpnbF6e95KwKkit\nE8owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPJG6Elk5enOUSdlsrGuU8cHLWrW2v0viAhkNNV+nDHmAiEA62evOTXH\niEaV2kx1pkEabNaPzzfu3srWgn2zFjiRXUc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAY6Ov7wiUjcuPooa1N3J6rn8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE0MzZmYTQtYzhlNi00MTUzLTg0OTctZTM4ZGNmMWE0MTExMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWE0MWMzMTMtODUzNi00ZmFmLTkyNDAtNmJkNjZhMjcw\nMjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6TOU3UnXZLBauLkrWJ4GnyBt\nUzN7WdtzkserCv824lXpVp0FEYf6q6wMbUATrzYJWVbryHRIJDYWobdaT5lI2KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyuJHb4ASdDcEL8mVXcRLE7ixFTswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgKIx86wEM\nCQZtualqoNrKUdNGOfmBZYUJ0hSetOdsvnUCIH1+CjR79H572YEnnpsRE+AnoAU6\nzofzC7jcDAkNavY9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc451", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `451` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZYKThwhDectnZmCx3XgoLi6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3YjRlNTQyLTg3YjgtNDE5OS1hMzA5LTdkMzcyYjQwMTA4MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJmMWM3MzAtOTVi\nOS00YmY3LWFmM2EtZDQzNTg5OWJiM2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES4puig9XJVGE73Pb1/9+MHGc729v63H2MIqeiQFD0ktaf7K6B1RMoQ6KgwlR\nqEXeVWV0NUB7sRiv3Z8z+LaBC6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlyRim2Mum8V5XGgjcmsruXc1zMMwHwYDVR0j\nBBgwFoAUmGTE/3Me8KhJzNVnm1NDJJH6fTYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAb/YZuoe2FURxTxn9YC3yOFwhTKHLc0oKIW0vuJcrROgIhAONIbvd1FnoV\nDfIQNXRxQpCiR5L+Hrh3RbQd/Y2LBbEq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARRAFgZU5pAUcqFbECmZ2vh8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2I0ZTU0Mi04N2I4LTQxOTktYTMwOS03ZDM3MmI0MDEwODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8zs6PAyP0V5Kh3rf5waLYPRXzZMMTvlSbNcMSX0rZH7Iw\n96xVe13X96OscsRrYm9VK0aDKtzw18ytvlXRMr22o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmGTE/3Me8KhJzNVnm1NDJJH6\nfTYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANTugR4STbEa6perWSNcC8gHmBW3EYWsBxrbPR3OZBRkAiApNlsTTQfk\nxpkL36fvZxCVKJTAcXOmtC6lqLg7DDUn3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYYsdyoSTuboYr7cw0oUIzfKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJmMWM3MzAtOTViOS00YmY3LWFmM2EtZDQzNTg5OWJiM2NlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjdkNjI0Y2YtZjJhZC00Y2ViLWExNDQtYmQwOTRkY2Iw\nY2M2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEASirUUWbuirF1eK9z3MMOdrQ\njt9G3cqtfH5lVwN/nvU2b+AkXHjPT3mNKDd+BsL6mfzgQ7wN24t2oNSx0TE1hqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlyRim2Mum8V5XGgjcmsruXc1zMMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMdGFhvU\nsVxVy9CFqj4pB017BEffz7kWlvAbkcL6/d87AiEAoXPIhSIEATftsBgMBxmxGUZo\nla9QopbxY4oRr8UPzwg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc452", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `452` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAYjh62yofd5bc/7djOniuLokMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5MDk2MjNlLTI5ZjQtNGE0Zi1iOWFkLTAzNzcyZmZlZmE1YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc4MTc1Y2EtOTVm\nOC00ZTE2LThkZDctZTZhNTE5NTE1ZWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC2905rMGlAavQOV8/6VHNcs8ny7Lxwn9TMsFfjVRhups7yZqB8NheWeJ2plQ\nUVHceXqgEVT7siZtwxv3MBcFSqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaDj9JqUZAHBSLCOCRJzitnTP0mowHwYDVR0j\nBBgwFoAUvhlPYsguvbocAl4SYT/kpiHgSXgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAqw5Vrm2Wr++OwlOLtUd67YGpMnrw5uEjeq9F7VRWf\nlAIgc2mZT0RUmreq3HfHcHzb+lAZK1l5Wb0itIoOlivdn0w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUFRjRvgjSQ+L97oKZUIWuJ5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTA5NjIzZS0yOWY0LTRhNGYtYjlhZC0wMzc3MmZmZWZhNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJgFpMUaH10ZlGsEOgikkDf+tf9jXRMVcJR/59DLqzQXUC\nEodGOilbkCafHhNj8VVkw1T06eElhnKKV+x7KKpIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvhlPYsguvbocAl4SYT/kpiHg\nSXgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKujpyT36IJNAS2owWFkZH2csqzADxqxvgJKnK4amQppAiBu8Gr3gtPH\nrRbRRxoM8Kfh/CpPybxQrl8gy/13YXzPCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAaThZBlHwXgSjRwfrND0VFU3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc4MTc1Y2EtOTVmOC00ZTE2LThkZDctZTZhNTE5NTE1ZWJkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTMwZThlNTktMDFjMS00MDA2LWI0MjEtOTczNTI5Yzdl\nNGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP8uv9l1zCWnZEOGMbTKV98ES\ncuuban6Loi9xbSpjOOmrYXZHDjc7E0s9XxR/J6CusRHvlLa+fNT2mLIUnQ6XTqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaDj9JqUZAHBSLCOCRJzitnTP0mowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhANi6Tvqe\njAlWD9tkinCiiiFEwawndEHkcq8ap1tes4irAiBPRnvvF/uXw2H+D2WfdWu17QNi\no3OK7e+RBcr99q5QuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc453", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `453` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAc8TcU0u+777dkDH5LyfSPaVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlOTY0ZjZmLTA3OTMtNDg2MC04NmUxLWIzNjMwNjk5NDJjNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRhMWUyNjAtNTYy\nOS00OWQ1LTg1MDUtNjEwNmE3YjgyNWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl6olcEKSad5zPo26H+zKEmeLIJk0qYYXsc+IOiqVlT7JnYju15Wi41BEt31j\nscc5X+9jieEfIRiF5lo6RHuy36OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlX9Mg8I+y3aJpjSqnhGUYPGFYqEwHwYDVR0j\nBBgwFoAU5L8QrWwaILDfvX+R48wlJNjJzGMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAO0RcI5z3cym+w3wm7IBNH7CFwjhG+cPuMliOZmhJe\n2wIhANUvivojI0HYs/bQSuZDhJBTamqpMO5hpjnoQRLFO6mF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATfu+Nk1QWCqLsC2CrVEj/15MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTk2NGY2Zi0wNzkzLTQ4NjAtODZlMS1iMzYzMDY5OTQyYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4EuTYD+FZDjGOpIJEZhdfBuyxsO2nw7sEkeC97tQTJ+21\nAi2uCjnpSvid/XleezXugYlJKtY6X7Ln3AxdDvfwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5L8QrWwaILDfvX+R48wlJNjJ\nzGMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALFC9t3CsYOcO6pmSLvrNo3JRH14k1LsOT1nHWFlS5L0AiEAsEZ97kMA\nDHt6sNuWMpwuVj1Z1jOZsab+RgKGsOBHGhE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZoL/bvXuzrXaZuj7x4jgHS+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRhMWUyNjAtNTYyOS00OWQ1LTg1MDUtNjEwNmE3YjgyNWM3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODMyZmU2N2ItZTQzMy00OThmLWEzZjQtMTM0NTFmMWJm\nOTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX60x61j67YgeKyj40nEBLObB\nUGzlbg67q3+WRaWo6rZnznMl1S5B+cZt7TRPSsgcnB1k+5Xa6R/L9hJudGms9aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlX9Mg8I+y3aJpjSqnhGUYPGFYqEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgETN/R0Lb\n7zevM1qF7k+HjA8KAV/1RSySuI32oRgkPcECICPChySQGnpjoF8Lo/zQvYM025tC\n4OTFSQ7gFscUaf9q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc454", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `454` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAbDOIJst2HOkKgI08HuTPxZoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlNWIwMTI3LTBhOGUtNDkwNC1iMDA5LTc1Zjc5MWMwMDFkZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgwNjdiMmEtZWVj\nZS00Nzg3LTk4NGQtYzc0NGU0OWU3YzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETNmZqD592+R9TtHK1OFSOUZIsuJwfEhfFwsrnvn0sCRJ66fT+77PPlth0Id2\nWRkIUDq583fKc3OJGFkziAVhaKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK7Wz7RfdWqbP+/MFIXuutXo0wGswHwYDVR0j\nBBgwFoAU2xO6lRM6m5bYFuX6Z1JiDQeLBnkwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAw6GuE8JGdzrrkdyMgAR8yQZNuvpTzJTt40C4qSmOqtwIhAKcZ\na/UG1I13d7xFyhTfqMRc/mJkg7SVZvQG1kPRByo8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaLkoxYx7Uiw6IvbSmZhKsK4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTViMDEyNy0wYThlLTQ5MDQtYjAwOS03NWY3OTFjMDAxZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXwLCVCtZALmmFgS6apISeg4zDB/OjbBYU0w/AVuvJ6NnU\ne3rc7EPbffoE2WnS2nFLCWtPtNqYOn2zLBV+VzOio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2xO6lRM6m5bYFuX6Z1JiDQeL\nBnkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKvGXc/jT9qqFWrpWUjWbgtw2l926Qe8MgL7ZFK0PA5EAiAE1DZfLB9T\njoLWRZbdsDiFx1E2orAnyVk1U1b45UkQPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVkkQMeUueBvjgIsCR4PIxdTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgwNjdiMmEtZWVjZS00Nzg3LTk4NGQtYzc0NGU0OWU3YzliMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY4MzYyZTQtZGZiYi00MGE5LThjMmMtNTI4Y2Q2ZmRk\nNTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgHsXOcmBWNJR1vGQV49bnS7S\nTyCMlN5Ux6i/2fQlKFEeyn2a36rzWN7EnokSATPr9BH/AHCCWdk13ZpzTR/BG6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUK7Wz7RfdWqbP+/MFIXuutXo0wGswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMLDL3Ec\nItbA26W1/oSx6KMR/lPpFUReQO1xKYAz3PaDAiBOhYKC2nhziuKIss9scta64jZ6\nBcKp/t9iko0ZRByDeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc455", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `455` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXO/2X6wIYp9muDtTTXIx9zjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2NWMwMzg5LWRlMGQtNGQxMC1hNWY2LWU4NGZkMzc1Y2RlMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUyMTFmY2QtYzZl\nNi00YmVkLThmNTYtYzJhMDNlZmU3ZDJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnUX+os3ovDX2q/Dk1VwDQzG3a9dSEfxcyVi2m69LO0z4pgbmu9DpFq3TABW6\nM7BEGSU/O0tWw0xSFp5ZPstlTKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1+IHwuXXKQr+9o/lRwZA+QZ8NT0wHwYDVR0j\nBBgwFoAUmfHgvjfF/UL5P/pOGKCGfls7VBEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAlyXR07qdEEg8/y8nc7WNogeJUgqhdcqR\ne9MzxD5P9QkCIH+lmevHRQaanLPBry8AIC+IudtgwUwNgNYKFFSYtMvi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQMbOuUGXCXdwLr2c+xnfoe+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjVjMDM4OS1kZTBkLTRkMTAtYTVmNi1lODRmZDM3NWNkZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASL+NmUzfSfm5e0IUmVzGru93T6u3GJFj2Jppxn4CagAb5Y\nY+ib2nVe7glxN8A5qfmKi6djM8BWelp0QH2a+j8Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmfHgvjfF/UL5P/pOGKCGfls7\nVBEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfj9D8FboKj1fM7h1CvuNDcAiUOhmg6YbU/YHy3UyJhECIDJHmVVRLsPj\n9ixn2ht8t1HAoPy78vO5mPUu18vu0m3M\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXM+PMLmjjM3icfpebXn08BaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUyMTFmY2QtYzZlNi00YmVkLThmNTYtYzJhMDNlZmU3ZDJlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjYyYTkyOWItNzk0Zi00ZWIyLThmN2EtYTA5Mjk4ZTM1\nZjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdV+V/Bx12HxXdtjV56Af3hWT\n2RuuCwY4BkVrInoio+tEgfMrAJhTmzrgNvlT6ELO6Ge97MLuZLwn0uoC9fFT36N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1+IHwuXXKQr+9o/lRwZA+QZ8NT0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhANdyrwJ6\n9O/ijbuOScaE2dgnDejpO23azn+9Ony9TxF/AiAbXvygDkr0A9quRAOhdE+fLFE6\nAJyAywIbuFGRJGEI7g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc456", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `456` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAYdBvpHt3ijbDzT/VlRtFKCHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3YTVhOWJkLWQ2Y2MtNDMyOC1iODZjLTkyOTMwMzczZTZkZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNhYzI3OGEtYjVm\nZS00Y2JjLWIxYzMtMWY4ZGM4NWMxNzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBAcEmAKFNHQs1uCxjZeF5F4l5+pnnlfEo2C536Cd4Yfdtxr6OUg5ygdRyJUA\nH+gOVkzW1H77UWJZQLnkJpR6sKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUagm0FN5XbWFDK6l31eTGC2LtcB4wHwYDVR0j\nBBgwFoAUuXf0tjEMNaL+pMhehZO1fHL+zYcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB78ZIfjetB+XMA0BawIel2u4IaieEYDbJG\niQWyvsaLVwIgBkmPGjsnl2hXYrE72UjbswHDdKZCSYKLxXTQDUVNsIs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXaFO+33mYbD8+D7MR+vUqXxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2E1YTliZC1kNmNjLTQzMjgtYjg2Yy05MjkzMDM3M2U2ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjgBS7lZ5Iwv+WGhLW8xoKs9ECzOylXShxOHYZHPxNE9Lo\nfFtcYPjQHuNyz/aCK/mRs8slxtjlKxi8s5p2H5Eqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuXf0tjEMNaL+pMhehZO1fHL+\nzYcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLVWiAB20Z63OXh6s6z1CAKuzXR2D88bFlHbIDCPEcjUCIFeP5+il3jnM\nJdpNoWq6Z4386nI0Cj7v9wXSaLeiC8a1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAeFWXxQglVA1Lsph4bUi4YbbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNhYzI3OGEtYjVmZS00Y2JjLWIxYzMtMWY4ZGM4NWMxNzM5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGE4NzBmMDEtYTY2Ni00ZjVlLWI5NDEtZWVhMjQyMWVm\nMmU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEF2xvhGGg+VwWZQABkKlZsUHN\nc2579Zg/twJmkosxdnpt1tVUVdqUXUfJ1Z9/8ec87cNNIV3jcLup2CJTFCtsuaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUagm0FN5XbWFDK6l31eTGC2LtcB4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgc9upvRjH\nfSNn/Wrnuo6Pu0QpwXS8D+Tv8Wh+q3vY1I8CIQDIAmpcpebkaxtNyhsEtbY6Zl1h\nhrOjarJ33Nhyalm+7Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc457", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `457` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAVSFlvV3iPL039ReVtuELvD1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1YmNhZDA2LWFhZGUtNDc4YS1hZjc3LTNhZTA1NWM5NmZmZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJhMGIwMTYtNWE5\nNy00ZmExLTg1NDYtZGNmMmEzYzdmZjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN7ylfWLC6u7vOcZB2B1ztTjln+oWD3Ahih1B9lO9ZxefDvgPSgjBdf3cr1Z2\nyR3ZABXQVUrEJTL+k37LIqpLSKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS7nT/CBCS/6lMLIbC0vdbbIfnxcwHwYDVR0j\nBBgwFoAU3LtdOKFwvIrDexO9aw9QG0FtmuswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA/Lbe/MncmfcG\nBNmZTO7kFcwIHrW7VNibNlebX9E3s08CIQChNfhGFjRRnFROWOwGtwLvzEMj7Gb2\nVcgf7NS9VI1obA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYgs3QCJtd9I3xB0kpXieHKLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWJjYWQwNi1hYWRlLTQ3OGEtYWY3Ny0zYWUwNTVjOTZmZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7qNZzdlnPNmsed0I2YhJZnwsRF1Qyp9dt0g9emk+AWfU0\nL+AHNymJl85ZQCWxV5QXHMfTEAoIYTKiWOsG+yino2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3LtdOKFwvIrDexO9aw9QG0Ft\nmuswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAItg+Sbx2GA/Uu+Ho/iZF5n9REI/PfJtst9uaDRKi2ulAiEAq17EK76Z\nSOSm/mheeyrAR3lDjBsgCCO4nEH8VSdtRE8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYStQ382j6eh90lyG1F3SSxnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJhMGIwMTYtNWE5Ny00ZmExLTg1NDYtZGNmMmEzYzdmZjc2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGM5ZGIxY2MtZTA0NS00OGExLWIwYmQtNjI4YzQ3ZTg5\nYzAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPR+9OmPg9RywluDV87+xYfb/\n0zLo7Ad2L1RkZgYMYIfp8XSMsgmYOOxyWac8Jq4p8ZiimfVODNJ6x9NQrfoD5aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUS7nT/CBCS/6lMLIbC0vdbbIfnxcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAP5BC6R5\nGrQw7x0VAvJ7OEIfw3bvBEiLXEJfw+SE8Dd4AiEA04XP8CIP8+W13DKmvRQoW0iY\nSi/fqU6GxtkhrF2uPak=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc458", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `458` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAduw0G/SUKjG48jQ23r16zfzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2YjM0NmQzLWQ0ODAtNDVhYy05N2ExLWRiMmMxZDVmNGZmODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlhMzFkYWMtNTUz\nMC00MTdhLTk1Y2ItNWJkZWYxZDE0OTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuyvDdYZUBvWwBPP/FWWGTEd/5tV65zf/gA/2311nQR1yogq3nKOo8tpM7w0c\n+i9Kt96zkkdPwRYYw5oKeo25KaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1SfbbyCzs+vmtVsCjL6fYFcGen4wHwYDVR0j\nBBgwFoAULm6qBbp0yMW++mqfj/68+WtGAzowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQClatr6cSFzJahUr6U8S7WOKVrGzQY1tEDNDO8A1BxObQIgKygvaKKRyAaI\n5gQvBqqGbnS41vhHv0gvl3taSMbzISE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQeaRwOr3+M9s7vi3GkUMqPjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNmIzNDZkMy1kNDgwLTQ1YWMtOTdhMS1kYjJjMWQ1ZjRmZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTk5YX1JrCOnIqmPMlMgILXNCdvdLAL6xV/4fTPNWqgeHA\nT4RG97HMZsD6VKP5Ql70MRT1oL9p18TL9B5ic9Q4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULm6qBbp0yMW++mqfj/68+WtG\nAzowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMlUvgVh5KkinqI6u/NuyOeacfpmMR0lknmcykFHiUF8AiEAsjPkef5G\nIYOng8rjLcbEGoJ8Yc5x485aZk/P6Q7ku6Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAe1MtJ16wvzyZu1FcXagW0kbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlhMzFkYWMtNTUzMC00MTdhLTk1Y2ItNWJkZWYxZDE0OTJmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTkwYjg2ZjAtZjk2Yy00MGUxLWIzNTgtM2FjNWI1MmFh\nMDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErtxoSrXxam07lDWors6WcbP7\nZ3B9X6gGlqn/Zw1TUm04b0ldkAxriJFEhBFpg/mb3B5aeOVrXC7WlxT7zOmymqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1SfbbyCzs+vmtVsCjL6fYFcGen4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMwl4El6\nDpbzflSgyqWsxzIZF0d99GCXJhEZ/qNOTbjxAiEAlNec9iDF67Vuw3W81ktY9cDR\nVrKdBErhDPcFUsIdU9A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc459", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `459` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbf6vLlG5GjmbUP/s6pDIxz9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYzBmYjgwLTFkM2QtNDk4Zi05NjIyLWQ2MDg0M2FlYzU5YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE2NDE5YzctMjlm\nYi00ZjJjLWEwYWYtOWNiMGVkYTJjMDE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUmN4G9MQzyXPATA17q0AsXt31KqhJkFkUfzbjK2HU+Qa/7qduOTGKlvqffLb\nFqVprE1D83a0cXOD3nlEIgPAK6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf9clLAHdEWRAZM9iCrLrk3dO/mIwHwYDVR0j\nBBgwFoAUcXPnRnxP4nl/Y9/LIXXw8MrCTdcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCLxai2ymS0yO3fSxD8poQWWsBZjEnuZal0wDm6Nny+cQIhAKqZtKUqFEVz\ngLzJ6XHk+2QeLNekoRHU/GCjCfWrDxQ2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVub0Ho4exfO+TdxQU0AieyEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmMwZmI4MC0xZDNkLTQ5OGYtOTYyMi1kNjA4NDNhZWM1OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOA47dSF52OXj7nGdVueQScHZG9tH/syGVfEDvTjPNPpHx\npDM5zMFx+yOUtNWR/CHb32wmkLtlk/6Eyn9m1I5yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcXPnRnxP4nl/Y9/LIXXw8MrC\nTdcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN+OwiUtjjzOVHTVouaVpeA72ACnKf+MMoAS49hy+LHACIAORrVo2NW2e\nfMbZ1+ijGxRW4ZqM3S3TQPw683osOPke\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZmWQpz331xUl9Fr+9KOfA+qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE2NDE5YzctMjlmYi00ZjJjLWEwYWYtOWNiMGVkYTJjMDE0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzQ0NjU2ODctYjI2OC00NGY5LTk5NmYtNzg1NDJiZmY4\nMmRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm7Q3gambi0kMEyYk9llkwNkK\nabBpptcknNl8ObxP2guVilueDr3zSNaIPbrWpLMRrVKJeyz5zStLJK1oIgD78qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUf9clLAHdEWRAZM9iCrLrk3dO/mIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgQISoEHX8\nJnfwdUUa3DL759Bl+vsYcvqCtKEOcyELBTsCIDh45lJMq5iix7Sc5i21P556ojGy\nHHcdaOQFbCkUOG1Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc460", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `460` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAfHbuoruEgRcBcmx0+jJaH8UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMWRlZjM4LTAxNDYtNDEyNi05NmM3LWI2MzNkMTUxMzMzMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA4NWFlM2UtZGNj\nMS00ZWFiLWJiOGEtZDBiNDNlYmZhN2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsolLEArQ2k6cZbDdUz4YirJMt+TdE1OIttK3XY8PDZP9hCSrovCF1kUj7/XW\nDbptrJ57E0MnHPBUm5kK/M66wKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5xii+n309wnQjElaBttdYOUSFowwHwYDVR0j\nBBgwFoAU6R/nUMI/gRb+oy95pg9xjoBsvgAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA1dXLvux7vRtCO2tjU+gZG9zvuB8s2JaitHTDgzH0mAECIQDosYS6W0wp\nDh/iH5W0BWgy5oGlNjKxaT6QX19DGL7L5w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd6ILJPe8kog8ZqsmBwoW2tHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjFkZWYzOC0wMTQ2LTQxMjYtOTZjNy1iNjMzZDE1MTMzMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATReGCTQ5HKMkyr171gd9tvgguqVvV/isSIs2c6G+LOb1mF\nod8CUXvv6MzWgJ+tbaamGrRcAjrIgVJmXOUOZa1vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6R/nUMI/gRb+oy95pg9xjoBs\nvgAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNfiBEhlzEp0yHz7zDQ50Iicotw/i3DDcBYcicyaTIC0CIC/xPeang4xt\nXCMwfaKctqVbZNUzhRR3mUXveXYnrKu7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZo+o2JlayNsnf/+MvV97X7IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA4NWFlM2UtZGNjMS00ZWFiLWJiOGEtZDBiNDNlYmZhN2NlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzgyYzg5ZjYtYjkyYy00ZjBkLTliNDMtZjllN2MwMzJk\nMTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjJjqChnuAj4d7ddvGmT5DFcr\nnhY7V/b54/FICxeMuO6xN9DD5XbTsqZ781MX8eG2y914sA5qIg6TjMqfeNQVIqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5xii+n309wnQjElaBttdYOUSFowwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAM0elaQx\npz+0etqWW17SwUn3Ps59U+qKeXmbiIgblsS8AiEAhP0mlFqnbceWvb49lYFAhCkk\nkfgqpD1b5ZSk1kFOzi8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc461", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `461` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAT/wzdmT4+JUgOXhrduJKERQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NjU2OWI3LWVhNjUtNGRhYi1hMTI1LTk0Yzk5MjVjNDI1ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q4NTI3MDAtMzJi\nOC00MTdiLWI1MmMtNTg5OGUwOGYxMzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvRhIsuDsXALd0USex+tyrANiiNYqk6bKGy6Uijq741O9cj9raEXDveJDhM9h\naJJ5aXFMekiZWBF4Jiu34ynURqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmN+d6qREP++iBUfpnFpRgnvYm+kwHwYDVR0j\nBBgwFoAU617smle6byC4dkdV1AD5m3HRsY0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA+X0d/92/eyYm/6D9toDBTGNSFHsWgiMDco7C0hDx\nIXYCICYjfW1hEJykV47jiiNRQu+tXYmN8OlztaWtj7L4LIg4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUPZySiOtchHunuMPK346ykTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTY1NjliNy1lYTY1LTRkYWItYTEyNS05NGM5OTI1YzQyNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrrZ2jlm4gsSUbJN691s6Bk5D3fWeOUwKjcegrH21Jp+ex\ntpYHM01UeOAWdCIddFEyW7SUa0R+bXs/PeTTETH4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU617smle6byC4dkdV1AD5m3HR\nsY0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfjct2blNT4l06XxmHHVuXof5Gu0fcI0FtcjowxTYjK4CIQDHdHQYhdrE\nGymuJQGXRYJ7iWNynQS8/h3j/HPt/qWnww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVux1iP3i/BBBOvC68ke6uSDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q4NTI3MDAtMzJiOC00MTdiLWI1MmMtNTg5OGUwOGYxMzAxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDIxMDliZjMtYWFjYS00NjE3LWEzNWYtMjVkYmEwZDQx\nYjIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr4j0S1X3TQD/xc34x3dnr95M\nCw/S7Sh7jIo9+lRTYNyYI1PmXffxd24EYSbq/C04Kl0tKb7INA5aju1hDo3CPaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmN+d6qREP++iBUfpnFpRgnvYm+kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgQEQDDDdR\ne5AN2sBjJ2ouOxvn21rLni+VempcJjmB7aUCIBEIXnzbZgYHyH/xy1cfvV/Qu+og\nXPIHlbXds3KTGqzJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc462", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `462` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAeM8b/Ep/tUycmCzyWngJbkiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5YWJkYTY2LTc4ZDktNDFmYS05NTIwLWJmODNkYmQ3ZGVkMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI0N2JmNDgtMDkz\nOS00ODZjLWFkZmMtMDUxYmY1N2FlYjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE06a20rH0B+V9g3xGfHAKA7iOvrZtlgi3OVgwvxZXbxfAEyLh0xwYtZymHsi8\nDxzVItvctvYyDkVZXwLwvMU/J6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUybwJgaUkqicWuy4ddt1j03jeFCkwHwYDVR0j\nBBgwFoAUQKFa7OycYL+E5sH51MTanoPg6I0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBrc21X15tm1yzF534gM4nGnsu3HzL1Pkq6uKrX4jyA\n7QIhAK4IvwPRiIk+f9hqn2AXT/hyvRCezpj9T/2XdI506zEg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa3wZc9aKwIIykunhVICK4VCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWFiZGE2Ni03OGQ5LTQxZmEtOTUyMC1iZjgzZGJkN2RlZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSVtVohTL8pBlHsxWIpmytzBuU9y6MxTm57RSYmYfW79IC\njCmsUlMvlKrghw1Lh220bx2yzmAu6xM4L7mE/nB7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQKFa7OycYL+E5sH51MTanoPg\n6I0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXrltxqrREYcPG/YrIRFddeYkhRFTLj/ITKqKDTv9IX8CIQDFFoi0aJh/\n1jY+RmY17ZeGpwHN6LkN+mlHwj/eTJTlPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAcwe8WV0o14T0hvnB711iazDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI0N2JmNDgtMDkzOS00ODZjLWFkZmMtMDUxYmY1N2FlYjA4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ZkNGNiOGMtNDhlYy00OTM0LWE5ODUtMzQyZDNlM2Yy\nYmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqXhtgVJRFMksImj938tbgtkj\nXc1cB79Xo1V942h2joVqEk+4c6JI1OUx37ltimlxmBWu6m9ueHXDtiF5H6uKJ6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUybwJgaUkqicWuy4ddt1j03jeFCkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgbVArI6ih\naAz1AQL3EgCRHv8zeTKIqpW3itegWS4KkEICIE7OHFlb+rmHX/9l/NZZ3bytvyHg\nxW1i5FacM2L1WHHi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc463", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `463` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAToNicyFrH9TF+SnBSMOV6D1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxYmMyYzYzLTk1NjgtNDUzNi04MmFjLTg4ZTVlZjBmZmQ3YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE3YzU0NmUtNDE5\nYi00Y2NkLTk3MzMtM2U2YTAyNTc3MzExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjolwGiDM0nSgQGMNx6jw0D4Kqd+tpqfzc2xAPrzPOqMbmiVHBD0WwKMJXk0X\nEvLnZGhIMtGLnJNfCJmDOfeLWqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Ed9fiRUIM9eNWnzXXB0vWkewCYwHwYDVR0j\nBBgwFoAUEph4Kqr29LucfElPUWZI94paO1gwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAoGPQ6HBX0D7WR5cpuhz4Q4ffgSlnRzTy9jsfXaaEfMQCIQDw\npRrknuvN2uJbpLEHhfGnetgaM95eO6GTkWIdXJ9CRA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR8UHSrpIPTrkzO1mHmYO/ZtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWJjMmM2My05NTY4LTQ1MzYtODJhYy04OGU1ZWYwZmZkN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJyh8QaQEWtNpfn0lEYqQxQsvrJ+sKQ1izbzG/isu8vz3M\nxkQIDME7+9SRFnYKT+DcCFssaR0mTJUZuYOMqbdpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEph4Kqr29LucfElPUWZI94pa\nO1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALBqyqKYSXcCyrabZEi72RD5zFB3wjzZlDWwb6pi9uMVAiAdiIgeO1Ps\nG+j+RPgSuw4wyU/aOd6QU/JGiEvFix4mFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQcBJV2n3LTLVUsQeBfMyMOfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE3YzU0NmUtNDE5Yi00Y2NkLTk3MzMtM2U2YTAyNTc3MzExMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjg2Y2E1ODUtZjcyYi00Y2JiLTgxN2MtYjMxNmE4Yjk1\nY2UwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiqFKI7Otrs9u7WPqIDjWCn0E\nEMxe2XfMwR/Ewnj04jJpfZ9JLu55rEt+6ir/jndUunApsWTSOQHie9NOz46CGaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+Ed9fiRUIM9eNWnzXXB0vWkewCYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgNRfRFzy7\nGdR1JAx7YfzEnMdV+zfy7nShibv1yp1FGuwCIDr7bHJumsf8PAMSgN7qXofQn8rj\nLZeKiNTzm/KUpaLi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc464", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `464` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAcslxgfM5DABOYCgdVU+30auMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2ZDE0MTY2LTY0ZGQtNDQxMC1hN2FmLTBmYjE3OGU1NzI1YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI4YWM3MzQtMTMz\nMS00ZjBhLWI4MDctMTJmNDc5ZDVhMTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd6SbFhMlUPkzIRfhj1a47/O4YFtyCIVRZRPgCrtB+kxXd48Zf9yyuZ7+6wPh\nH4Tf+kwGs+TY+9kCAzcsRO25H6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2XCWrXIr9OFuIGkbYRJNgpdOy8wwHwYDVR0j\nBBgwFoAUDfspJTk7CycmHWgFegOA+xMrfVkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA77L08T+xYfxmySHW6UnkDYbONL2YXYrD\n3Q223ee7oCUCIAJfm/xAkquvGki3nyNozbJOfs2K5CVpWcXEHV2iWvz1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYKwufCG5QqLWHMoYlTg4C5JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNmQxNDE2Ni02NGRkLTQ0MTAtYTdhZi0wZmIxNzhlNTcyNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARs2kKhvZROrswL87vGuOR/CVHDqg1qKR5ii5YBxG09H9nO\nnp/kn52h/rfpFdRsF1cnY4BCXpnP51zNJJdTVqUao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDfspJTk7CycmHWgFegOA+xMr\nfVkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPA1yKKWcjRTDJ+JAVdhn+GqHy24CNHBVT3zmUGCQW8XAiBaWFg3i6jw\nVBHLHsAmWwhxWalRBhefEWbljN+tPZpZVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAS+XUSrgAS0mwKEE+LYCGBw0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI4YWM3MzQtMTMzMS00ZjBhLWI4MDctMTJmNDc5ZDVhMTU1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzA4ZGJiZjUtYzgxNS00ZjNmLWE1N2UtMzAxOWZlYmYy\nMjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpYaPgQbIxfZOnyr6npeSW8wO\nCNvqGcwCQFakVPcH0Lflf26NhLQAbd046NYTECVp2FUMpU1t/2vJIRkckj0DiKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2XCWrXIr9OFuIGkbYRJNgpdOy8wwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgNeea60x0\nzV65n3PZb4qfWvZcbJcLmIEFuBbArIKSGgICIG8Ci08cZiJF48+cO5PAQIAvy6gK\nTMz7poWyDxE3zSjV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc465", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `465` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAW7ulnpEIwvXgmrAflcVi9hbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0OGJmMDhhLWZlZmQtNDg3Zi1hNWRhLTA3NDE5ZTA2ZjNjOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRmY2M3ZjctMGI3\nYS00MDcxLTg0MGMtMGQ4ZmZkYTgwMTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK4UX5ON5U0Z4ypKIPaMV2qfu6py4PwX8eJKbZ1L3UZvsUKGuKxMDi1voKu7u\nfxeJ08lf6EWhD63GrpV/BdE/+6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYMXDJhXN5Y5uigVHFHOGmHh29k4wHwYDVR0j\nBBgwFoAUmj4Onklo0RanhApxC4UuGhwOz7wwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBPwNmJES0au5CkHhvZh+CUW53z1bku1Nzw\nZ54pKJsRPwIgbnKkjRLmeFgDGZvBnuAJzGGXucXCaPX8xD0TXbWT37s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ59rpNzDnXRqCrjbw6NTJWiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDhiZjA4YS1mZWZkLTQ4N2YtYTVkYS0wNzQxOWUwNmYzYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASanZ7Kjgu0mgoBMUePGPwDGyBWYVPNtHsPt2CMmD/5HXmG\nwI0t3Eii8FiW9oU1g6pJengKgL9pJNiaxb6AlszLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmj4Onklo0RanhApxC4UuGhwO\nz7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUS2hBMpZB1OJQDsgPsGZcuQzYSXOv6Jp8mrcYslr9eQCIQDy62N2m/1l\nIo6XyHZ3lZA/owqXz2kgm5kQavvqCiAXng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcUvQ2zmGrjNPB/xxZKFp5EaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRmY2M3ZjctMGI3YS00MDcxLTg0MGMtMGQ4ZmZkYTgwMTdhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTkyYzkyY2QtMDdmMS00NGFhLTkzMDAtZWJlZDZhZjcy\nZWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAsqREFy0tG0c09tnL3JbVORC\npQWoppn8d0Jaqo43Ehee1c+UvNJPf4u97DfrNPAXX1Z8diXpgfOYjd2ckg7gUqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYMXDJhXN5Y5uigVHFHOGmHh29k4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPJMQ6C5\nJfOZwkkXzwqaytXUuxaK7a83k8JdwQtApd5WAiEAlTfB/kCqOTtkDJKB5Vv0YH4F\nGQtwQKAhr1JsTZvamx8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc466", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `466` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdyAdWCgYtx/Oubcd7nR7ejEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNDg5OGY2LTk3MjQtNDI1ZC1iNGVlLWZhZGE3NmE2NWY0YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQyN2ZhOGItMGEx\nYi00Y2U3LWIwNWItYjk2ZGJkYzQyMTBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEllxB0eWgFQuDRMDGs/bcme8QmJjaNGLKUcxBjjiWxYXOCfswn97hy674bzG9\nr3rZs7P3hWDgYjpAe6QGbfJXb6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2etIWotY27j4FP1adIwwEvSKXjkwHwYDVR0j\nBBgwFoAUCg3XETbD/nrLEoG1jCf67690YAUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDOkh0Cd7TVUPUYbi5gVUJiyIq+l\ngCaygsoWfQFvErAWAiEAoYaMOI3KNWPLMIDNapgdqnX9Y4r0ZdSzJkElESRP0rM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXgrJl41QYLQa8d/Ap1DVlKYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTQ4OThmNi05NzI0LTQyNWQtYjRlZS1mYWRhNzZhNjVmNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeZ/uPsRWLLX1M9NScnyJHfDRnq58YENHM84sfYWB6C3+Q\nUlGyTyzQRxAyGpP3m6UyRwb9FyodkT2+VanIURd6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCg3XETbD/nrLEoG1jCf67690\nYAUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWoebXXg+tpWcZ68vjlsZSfQnT3gNcWi0Mp+Mq/zVqLECIQDGb309xr5i\nllfM5Po8gyW5Bi9qlTyu1reZDAAp75zWtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXy5FkmZeSCatkuaq41fjvtwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQyN2ZhOGItMGExYi00Y2U3LWIwNWItYjk2ZGJkYzQyMTBkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODIxMjkxYjMtMmU1NS00NWY3LWI3MjktYjM3YmI2MmMx\nZmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2w2EEvTo0/LPRZT7ujq5QnRr\nKWj+84a8D3WGKlC+hju+mI3ozZplua0QboHXm59XpqIc6n6qpjEMYVIO3+X1+KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2etIWotY27j4FP1adIwwEvSKXjkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJSTePaV\nsr/CvfjMXsAHFlP47zdBT/vkd2FJxOaCUe72AiAHPyUDL3LQEUXaNktAWs5bSrrS\n13w0O9GIYO3ZfUF6XQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc467", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `467` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAayux1ygfmSP7HU/VH00/D0QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NDM2ZTkzLTUwZDYtNDM4OS04MjA2LTQ0NTQxZTk0MzJkNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZjZTg4ODgtMGQ1\nZC00ZGU3LTk4ZTEtOWU1NjAwYWM2ZWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGCUAZkrSolbxavuY9Jd5xStN2xxOxKjLCAE99+unCOM0lGO6D5O9K29y5eTi\ncK3cJ6oxGyoCZAV8amGH1hQ23aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+3CJZeMHqfePM1KxBqDzb6pbanEwHwYDVR0j\nBBgwFoAUXOVSjuhJo8jHuzIlDOblNUzw+KQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgMGdn5AmT\n+Q7L/tEwkS/VeV3Vh/zuCNXFqQyJBbbq1xcCIQDuMvXt9VY5KFAf6duPNvyS04ag\nw5tnHx2OGjfFkXdn5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATuiyb2xtNzy33GOn8I154gAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODQzNmU5My01MGQ2LTQzODktODIwNi00NDU0MWU5NDMyZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsWZ7duisIYtq/sxuerZgMUBJ+ko4ksilTQIqTtle3zky2\neqyKNzfY5cTiutitx7u6171r/KHUwDRv429v7udho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXOVSjuhJo8jHuzIlDOblNUzw\n+KQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN9hbnUKhxZ9SlhOXiZBzyaBX/Tj5jmOFNut2cPc/jKSAiBabLqbHYeP\nJrhqnp2NWB+jnfk8/YLrIgzkVEZ6NaqOwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXb4ZWOI/sfu03aUWO14DtrBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZjZTg4ODgtMGQ1ZC00ZGU3LTk4ZTEtOWU1NjAwYWM2ZWZmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmZjMmI2ZjMtZjVjYS00YzY3LTg0MWItMzIzNDBkYmQ1\nMGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGwJZLYVhsIFDp1d6v7xEBeyT\nwZ901wvI5p3Fp2bTKmj1tKn/asFOP80wkROHxrgfNf/jCZF6te/y9nKRRNj6ZKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+3CJZeMHqfePM1KxBqDzb6pbanEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgTfbZsbBn\ncHaRZgtIyyaDl+2hI0hZ5p13vw/du0LHbksCIGaU0R4qGTKFghUKXfcKwlR5mdo0\nujdreo9xMeQ1Ju5s\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc468", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `468` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAdSAO58lMd98SHhME+FuiTyrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlNDE2ZGMzLThkZjItNDhhZi1hMGE4LTdhN2JkNjc3YzhiNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDZjZjMxNzktOGEx\nNS00Y2I4LWI5MGQtZWRkYWVmNjA4MmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1d4QOY89RKBWeSyuPD1sjxW5/9R91KDAONVbj6kPxzJB6PP/WA8wGpz3YYGE\ntViW/IrYsxAEeqaUR3/oejuckaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5rIpeNSJpo5+Orpbneno/lcIZoAwHwYDVR0j\nBBgwFoAU3gpkdglzgkTm6f9N6aEK1YYxpV8wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIkQe8Ei\n5QRRSJ5jQmV5VJE+ptxfHgoyvQmW1qroO1/xAiEA+iHSTR6QUjyHeR54CrmbhUnu\nhFB/5M/gTOjV5ELyc/A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcO2Pk3iveYg+2wYEbQx6eq4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTQxNmRjMy04ZGYyLTQ4YWYtYTBhOC03YTdiZDY3N2M4YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwE3Fj4Epe2RKA9VjDBQ1RsORVat0ewGvExgM2yQU5TGVZ\neX+7p6qetO+bN/2jdGf7yt1yC4+sBSi9i0J6vFNno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3gpkdglzgkTm6f9N6aEK1YYx\npV8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTfazDAejoGriyTW+zWlSJm3ipjVJZdc2g32qHUA8pBYCIALTK/l2ohC4\nMESWCtop00rZGoWIUMi0D9aLwSzA1Lw7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcs4KSdRHE6F+V0Ul//tKzEfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDZjZjMxNzktOGExNS00Y2I4LWI5MGQtZWRkYWVmNjA4MmY3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzZhNGI3YTktYjFhZS00ODEyLTg0N2MtMTA4ZGI2YTdi\nYjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0wFy8qdCkl/PMH6G3Dzw+Zdv\nIhGdcXDsygF3GQvirN8eL6efRd0n/H9NRVEBE6+eERxS2/X+/IH2V3Xt2MLkQqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5rIpeNSJpo5+Orpbneno/lcIZoAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhALfy3xH4\nczixhmMYNlME9xNmCTnaNBX3ugZZcaXXe2UsAiEAlxd83rYnzu1rpT51omn8YNr3\n0R0VNEKCcFuQ6tN689I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc469", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `469` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAa0d1iPbtA2EOJIBi6jsQLxgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1YmNkMDM5LTBlYmQtNDQ1Ny1hMTE4LWMzZTFhMjAxOTMyNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA4MmZiMzctYWQw\nYS00ZDkwLThiZTQtOGNhY2M3NWU5NTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2Hum28Dk94Ejxu7ywa4TP0eh3M7j7oC+xZ9+d9OA4zbq98VBil91VQP4iDC7\nqV70h7PWt0HzvRY6oh42fU7zTKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGyLknDw0+HGIPcRT+NvpMJL3WpgwHwYDVR0j\nBBgwFoAUp3qO3grwdfzHeL36lHhqyHeZ1wcwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDJtAuA7\nF6zHnKpvlueOV2FS+PAiB3uB+NgjexqiMqr3AiA5TrsuTjt8bicjQOa2vBF7Zo/H\nf/jH4cdCr5yvNMfZfg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZAg0y9m/haEp7THCQZk49RkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWJjZDAzOS0wZWJkLTQ0NTctYTExOC1jM2UxYTIwMTkzMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXyW63YLaiUxypCvU2ohskZup9TcVBmfwKwek/987hB9XU\nD2WLa5Y6eitDL1SmuBuhjsBnfgqRX8sl/7yPUWjgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp3qO3grwdfzHeL36lHhqyHeZ\n1wcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALBslyY8w7XyEwaF9PFzZaOgNqhGN/YXjQHJLxMeZQ4WAiBf9kFnyQTt\njNJmk9qft6xK7AxWfcGlUTpe7Zz4EIpt3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAR3/sXoOBKkvdCGVaadlKQJsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA4MmZiMzctYWQwYS00ZDkwLThiZTQtOGNhY2M3NWU5NTI2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDNjYmRhYmQtYWRhNi00NWNmLTk5NmQtNWI4Njk3YzIx\nNzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2yfv3JDtoDjQxIr2jdox+yCG\nsWs9Z5wvbh0tOURO3InhMdroV62ByqPLTGN6+K1VJyshBMXSSf6m+an4xWzOO6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGyLknDw0+HGIPcRT+NvpMJL3WpgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhALNnf1Pe\niZAfzKDbu/BB3+dRyKRvccCGxCeGPPXF70shAiAu1PJyzPYsE6OhUdSt+TkYAlTd\nrWGb/2PMhtt3KJqZyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc470", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `470` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAT1O96jLcIUf5Gm82LHqGw40MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1NWEyZmFhLTA4NDEtNGQxMS04Y2RkLTZkMDAxNzQ3NGI0NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU1ZmJhNWItOGUy\nNS00OWFlLWFhZmMtYWZjOTkyMjZjYTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoApeKq+82OIlg64YNKLfaz15+P2k/36QI7CdAWs3WDN2v4DsEYKApHPUndVm\npKqS5sWsrvWfKDjEuPi2P9Pbg6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOzY7X+X195p2JWP90zn7lai6qP8wHwYDVR0j\nBBgwFoAUtC7mN3xDhmmP5sxdWRAybI7Wl0AwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCHulWScmUk/i7Suydv2plbltson1tZIwkaPuJ9FGSntwIhAKxoGiOx\nLrYzZd140FmKNSTlVa0LX5aOVJvYCv/cdH1T\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcGT6l+ovuChkon4G+Zp7azxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTVhMmZhYS0wODQxLTRkMTEtOGNkZC02ZDAwMTc0NzRiNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFtfPnKVGZ3VoAHEho6xEyH7X3ZkB2SXyo/fgy0eKqNvLd\nP0ZO5eD0Kszrg4sfjz1h0lt1gCT6duKL5XjXo25Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtC7mN3xDhmmP5sxdWRAybI7W\nl0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVyA2NLWpu6v+qSuhDsB3eGc/qa8yXo1E1x+hdDjw1K0CIAvlmOGYSWyk\nC2EZVAGH+pkI+2Y+WOQt8HTT+hXlA2U9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISARwzxQg71IaFD8t/QlYefDyDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU1ZmJhNWItOGUyNS00OWFlLWFhZmMtYWZjOTkyMjZjYTZkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDZiYzU2ZGEtMTk1OC00M2VlLTlmMjYtZDM0M2UyNjEz\nYjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENVAg04Vb6Lqc0otqXJFeVDLX\nFL/pZaFib3Nr5jpILIE1XWx3NckJFX075UWVCvZUS4nxMz7b2J9gw8X9VRbA36N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOzY7X+X195p2JWP90zn7lai6qP8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgG2mrUs3+\nMy4v7SOFtK3U+CPvxrV9jiWDeh1Qe+bPLp8CIET+JyeqyWispK+9eJDgba4J4lVx\n9Q2WyEtFCU+ahxrJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc471", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `471` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQHc9+azu1RJnpJTduK3+E5nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MGMxNGRlLWFkZDctNGNiNi04NTZiLWNiMjk2ZDRlNjRkOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmVmMjE2NGUtNzg2\nYi00MjYzLWEzYTctMzVkNGEyZmJiNTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdYLeQ62IQ/Q7xVNd1j+sLSjKPVv0UXDuHuJX+DYIImPSJ6pIc7YfuXZ5uBFz\nvw4J4QkG26gNmaXOx5bjRGlh1qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7lNKbMmNb25qIryS9KGdGObyuDcwHwYDVR0j\nBBgwFoAUyRO2fwQRDBAL+rkPynEX8F9/q6EwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCICoV8q0NaY1NE14kQHRnlw5VLMANggp81jCIjSK8no0LAiEAxb3KT42K\nu52JD15N0g3Fd5eZKcazPGhuTbfOYc8v9U4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT4PGRj52FAFw3vfuVNVDR37MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTBjMTRkZS1hZGQ3LTRjYjYtODU2Yi1jYjI5NmQ0ZTY0ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuj6Etyx+VKCn9tSb59nLMgGzfzk2G/2jKcERNgiO9ZluD\nJrmKmNZm/pJHFyDvK8NvHiy6l/1pawkUJbVok6DJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyRO2fwQRDBAL+rkPynEX8F9/\nq6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMggpXlVkx+BOdnU/nb7MkhMhH7D+MwWO7gV5yy25wMEAiEAp7e0GZeA\n4gNNlV63gkbAUGaJJPQDstn7atB4OtH3XF8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAUrtwxZ5UrMKGAE/AyOe/v3JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmVmMjE2NGUtNzg2Yi00MjYzLWEzYTctMzVkNGEyZmJiNTI1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGU5MGZkNWQtOTcyNi00ODNiLTgzZjktYWM0NGI3NmQ5\nZDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExKQtuhfl3yGErW09ooiUp6sO\nUz5s9t9i9FEYHzBcTHIMXvSzqm7hcTbbF4a+Fwt6fxSdFY6Wm66uznO0KEesO6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7lNKbMmNb25qIryS9KGdGObyuDcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgDK2qDWLX\nW65dSzUuEabvDx/sm+Nr3tXhg9PFsmFeiEkCIDdU2kWZsv9wtqDeenEGltXw0F2B\nMt7CPZOYnp2nccLA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc472", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `472` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAZ+f/hujP9y9NYvx5o8XynfkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhYzU0OTdmLTk1ODktNDM0Ny1iNWNhLTg0YzU1M2JiNzIwMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZhYTU3NTUtNmE0\nYi00N2NmLTk2ZTMtMDlhNjI1NThmOGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8kBti2RuqfvTTjbvbOT/9VYd9Qww05J3HmK7N4WrIX2lLn55OKN7mxJSOrw0\ne8Pn0WuZM8sV4Fi6vC74N0/S86OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuTTMqUNjakqIWXXIYHWW1HH+8oAwHwYDVR0j\nBBgwFoAUj+juOkcqn6CayGvT0NWCS+xoEtcwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQCN2W34MfI92qbKqG8mvguWlwq0IAPKkeN3EdUXjiZ45QIgez5QYebEBAGj4j3n\nBfmxxXUKPSOZOv1JqU7ZvYLV3jI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV9WejK74W3YameLmcOiIQ6ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWM1NDk3Zi05NTg5LTQzNDctYjVjYS04NGM1NTNiYjcyMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxPcaQ5gtccNiNFqJLxC5zmXF8jWZxBQvMvSok7tyIC876\nFj5PP+ChtNtUtMnTu89q2WIhSOoB0DdGx/eUbBNUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj+juOkcqn6CayGvT0NWCS+xo\nEtcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWDspUxXVn5dLiKyb5IUGWhQL1/CSy3t9WmPEtyXmkcoCIQD8RQH6d59B\nk0oHyJPmU1GKysjR+f1ZIQa9Z++grnUeJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASTNrg67rPzzE8kOkO7UIPgvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZhYTU3NTUtNmE0Yi00N2NmLTk2ZTMtMDlhNjI1NThmOGRkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmRiZDM1ZGYtMmUzZS00MTQ5LTk3ZmYtMDQ0MTY4Mjlj\nZDBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0tmhLUp1/o5LA4WDqPOs0IPx\nUbsjjuaTdQ+I4HunHDO/SQO6leWlEr6H6yTJdWgTII9cKBlRGonLSD9YoXMzMqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuTTMqUNjakqIWXXIYHWW1HH+8oAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgZRAnrMpG\nHj5yXqLZ5V7IN5foiOfXMhHvdtK3nWCYXxMCIE9Jj6m8akTx7qqj7Q75T6QM2fan\ncKLicMBTdgV6aDZX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc473", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `473` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISARSdwJSnRz31kvUYpUtZt7T9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMjYzNzY2LTYzMzAtNDYwYi1hOWUwLTI5OTU3ZWEwZTQyODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg2NTNhY2MtN2Jj\nZC00OTczLWE0MWItNjdhYjZjMWI4MmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcMjDztdZdpLxdUeZ7kIF7/PbZlp5wDfpEXvZPizBb++ylXudKzEpeUZrmfH0\nVS7U93FpM/gkKxbjTqgCcVigN6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFhNpeXyW6a4SVC5P1gUXMNdmQZ0wHwYDVR0j\nBBgwFoAUpXF+wHSlpA88tBEFfluC06e1yKIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIBga6asVq0NwAVADSVI1aSpxUthlTonZ77URNPX/MXMKAiAx\ndOEzWBs7BiC4Raf1GUcmDI1yoTqmnXrn7fJTpJWwPg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASdZ2d/+/ESSjTXlVPFK+IIoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDI2Mzc2Ni02MzMwLTQ2MGItYTllMC0yOTk1N2VhMGU0MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXTGeIXh3G2bqzwivLZsBxrV2PQ1PXK04coZuLxnrXhlub\naI6LouSzXiiUafV3xxBru7pqAfys3X8f7fvRApe4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpXF+wHSlpA88tBEFfluC06e1\nyKIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHlsS8OwhKYMv5N3MeLvGLMgeNeEF2j+AZUfC+p4f8C0CIQDmijE3l+gB\nBWP/Njcuktxv4aDjiZ/M9KOmMdnE0bSo6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAeGUIwkeIwzcJzIghTjklncgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg2NTNhY2MtN2JjZC00OTczLWE0MWItNjdhYjZjMWI4MmFiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGU1ODhkMjAtOTcyOC00MWNmLWEyN2MtYWJjNWI2NzU2\nODIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn8nZUi11H2Lr1vyrj3j3FsC4\noTjHOufg1gduoLckehgc52OKMErxrjujvInKcNAcNy3jO61KBXNv6o8zvNfBiaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFhNpeXyW6a4SVC5P1gUXMNdmQZ0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhANCBEv1Y\nXGSTJ3sGH8qoKHGr4VpBDHz6ypfyRkwZpQALAiBLO4a7dPZf37jZ9hltDldduST0\nvgggsoZvHHNxoW5+Fw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc474", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `474` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISATBie5nIxp2O5lIFhu3vza3MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxMTE5NTA5LWE2ODktNGFjNS1hMTJkLTU1N2Y5ZGJhNGZlNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYyMTgwNzItYmUz\nZi00MjhjLWFhNzYtODIxNzMyZDk3MWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAXy2HFEUsiik1s9uWxl2YqefZDrHbtALgCqVsXPGou/4SCDrO070PnDyPUyV\nJHfMprFx0kXzIhCcOY/03mLE7KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8xUNaMRfYIpQNRhRlKHEDWqlglowHwYDVR0j\nBBgwFoAUQoe49b4VZ5Tv3NBT0lfhA9m4lOUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCALpbXgThxDSIttxEIapgTPWgr6jlOxXhWIVd3PKcXkgIh\nAPw1XWhRg5a+TMnocRyEKCJzIl0xmKHrJGU5SxluJ3Sb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeHMYavKGqMcb8dJ2OmXXU9JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTExOTUwOS1hNjg5LTRhYzUtYTEyZC01NTdmOWRiYTRmZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfAcN9x0TWGsD2Y17JTINgMT2AC6rU73jGsyc+VSDfB8oX\nMfnjYRNeYNkvS8I+E7aluGBnIuX8bjrpFf3YXqDwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQoe49b4VZ5Tv3NBT0lfhA9m4\nlOUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO93/bXV+DD24u/ui2IS79M+zCwFdBzydcDvlas5EYqPAiBE0z52X9LI\nCmt5mtAp2YTFBwx22dD+OLoMP9EtXt+g7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAf4vlFyXKGsFvPlYyh/Eauu9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYyMTgwNzItYmUzZi00MjhjLWFhNzYtODIxNzMyZDk3MWVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGFjZjY5ODItZTc4MC00MDhhLWFjZjYtNmVlYzE3NWE3\nNWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+7TjeZZ4HxNEFJG2qfjjFyy9\ndsADEslxTnggj/n/D3lzcH9L96Zutxrire1oMEl/I/MZRS+H/AAZkz4v5dvs56N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8xUNaMRfYIpQNRhRlKHEDWqlglowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMrkDaho\n1KURKcNjPYrE0F5o+g/xajfGYNFodDALsDyRAiBOyy/XHxwgzB3JDbmJMvKmDIEY\n2oRpTh+JS/WTfw4ELQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc475", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `475` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAS6/igTivqDNVGZFOvWvnqyTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0YzA1N2MyLTA0MzUtNGIxMi1iYjRmLWExZTc3MzQzMjhjODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDAwYzFmMmQtMjc4\nOS00NzJkLTgxZjQtZGVkZmI5OTZjYzViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2AXTEKkKOvTydZ+YU5vh6BhChl/86rP+uO8FJkflJMmyGru2wjCFmIGRZ59B\ne4sU9cJm0sl8fPboE+WXDzW9lqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPfEAonanClmU1ZwDR0sl7QPFZ+gwHwYDVR0j\nBBgwFoAUiyuyyKHF1NdZn4+s85mY+TtZNIUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEkvAuKkYG41\nYU09Wi03kJwxFSCjA6IEp2vAOkp5I6+PAiEA7YR8DY/eVMmTDpKithi1d3Od+EeM\n3MaPBm+8GWq3s4A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc5Qb3QjjKyu8SncCq4i0+5DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGMwNTdjMi0wNDM1LTRiMTItYmI0Zi1hMWU3NzM0MzI4YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwz/H8agbRpAd/YvHhO3cRgDNgyaj7ZXIndYOBSmF6uJiG\nk2JkgKkVPv5kJjE4vO2mPO+HZYAoKez/DCCk1xtdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiyuyyKHF1NdZn4+s85mY+TtZ\nNIUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJESggU8NGDMRKAUdb5PVYXwvfu9+J0Dn48RXaUBLnMoAiBfEK2k94ci\na/fHcb3KfYa8MBpCJqbTDgx4e5Jg/ZaZ2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUgGgKFfCvchBlpM70Y1UVYTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDAwYzFmMmQtMjc4OS00NzJkLTgxZjQtZGVkZmI5OTZjYzViMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzdmMzNiZjItNDgxNi00Y2ZhLWI4YjEtZDJiMmMyN2Vh\nMmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/uQeHfbPh/z/2jHjTdmMj7+6\nS6D7AiK/JE4DW3ZIhHXUYrFQpNWu6xAdbMj1YK2UTOREeBIEZWcLg+5pPYYBsKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPfEAonanClmU1ZwDR0sl7QPFZ+gwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhANXKgW72\nQyhs86iaJ/ZFS41shLZc2DfKYTHSJdydSjUvAiBP+FGuQjhvlGFhC0mQe30aeGl7\nK+O7fd+O/1Z9KgvEXg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc476", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `476` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAaJihW82sQEzzpER67zWcesJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNDgyYzJhLTk3MDItNGU4Mi05ZGJlLWYzZWI0YTlmNjJkZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjMxNjRlOWUtYjZi\nMC00MTBmLThmZDUtZmZiM2VlZTg5NDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFdD0OoAevEVn5pKD/mKGN4GBDgxV9dhNv0L9Po5JCVWBtZ3JQP9fFMtiN4nT\npV6COw8Os7xcwL6xWhRPbhZkxaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Um5P2TdybglNr7/hSMm9maykocwHwYDVR0j\nBBgwFoAUioDkipVjRCLU9ZNdq29rZJRyhtswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAL0gEzxxP2apXdlrloROttz9pYO5Vsdd6wJV4CAyBGZEAiEA4yY1qYxG\nlAXefNeZjR9YJEaGgBmQiWQ4L+y0DqEjKvI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbsqeFisn6TEr9jA17kIHHJmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzQ4MmMyYS05NzAyLTRlODItOWRiZS1mM2ViNGE5ZjYyZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTWcXg/eJDK/I8K6lBEQRDE1LUhocNUDQSxqINtAWYIBbc\n9HNlExmrj+cPGphQ6BhErl0LwGSeicHYfn/s552Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUioDkipVjRCLU9ZNdq29rZJRy\nhtswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMmXRRiq5qa2Y+7QbvprTkfdVV1DuP68RQiisGh2OZuUCIFdDYMdHaGAu\nlS2r95eiWuwaQV9QmgGUheFwxRXT9C/S\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAU60snwQRAOXgRvtsSj1X9v2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjMxNjRlOWUtYjZiMC00MTBmLThmZDUtZmZiM2VlZTg5NDkxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTlkNzQ5ZmEtNWQwMS00OTQ3LWFjNmItNTdiZGY0OTFi\nNDk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOW3MdEBsK/dPJPK8GimcAqiS\nrt5ro8o4MC/iIzqR5Sds6GKj1RZoNdETF9QNMS9tveflms5za8kO+zfprpBlJaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1Um5P2TdybglNr7/hSMm9maykocwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgE6gpc0RC\n94IWjh53d4Xu46YqEX/VcYWG1ubBSIvmn4wCIQDtDwn10PMadkEslKSAdT1jFFe5\nsOMSO0W4OehZGt2vbQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc477", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `477` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXfjEODCai6nDf0KvaZEKxhRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3MzhhMjI3LTBjZjUtNGRjZC1hNTVkLTVkNjFiMDg5Nzc5MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQ4N2FlMDItMTA1\nOC00ZGVjLWI3OGQtMTkxNzMxZjYxMjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYXasJTdMNIwFD3/jexO9dj1ttP7tYNHu0ot45FxujCd/dVQ64tmAT2hVela/\nTvKbQ1z/PI8WsboLgLPRIFeHSqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/qVZJEfA/n5Xj/nG3wyExIj206EwHwYDVR0j\nBBgwFoAUlBtDZTrbGrpPwcJRsaxSzyhG40kwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKIaAMGgiOa5G2Pwvgb9uNw90CXenhBOb818SSE3UdQYAiB9S36GYp0M\nCnqbTkKRUf2cFTdgL6FieF1qU1Zn4ow2XQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARlrpTPyrqOe8k+apb0pmp8IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzM4YTIyNy0wY2Y1LTRkY2QtYTU1ZC01ZDYxYjA4OTc3OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPMRdRkcmw7/C/sbD4TKFJt5J6x7QcIexw1x2yU9NPMCzB\n32e71c36Dt8PaJefg6k2quGRkfjyLRaZkjSsQPeAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlBtDZTrbGrpPwcJRsaxSzyhG\n40kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOHCho4dHQmXmLZ34hr0sTEp/qABI9NudM9/lci0Z31kAiBd3Y9ETthk\n7g2RwXxRfsXfEQht5u+cnrOfq96r+bLRaQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAYfbB+Uda5Je31WXWveWImIcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQ4N2FlMDItMTA1OC00ZGVjLWI3OGQtMTkxNzMxZjYxMjg2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWMwMjRmOTEtY2RjNS00OWIzLThiMDEtNTFiMjhjMTdl\nYzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiSRsTlx4HrNdIiIWWM3kjcR/\nzQrtsh0h+BNfDwWUqiDTB5UG0Y3mXEamRfjgO6JtjP+uwihy/Tiod5y97uIi0KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/qVZJEfA/n5Xj/nG3wyExIj206EwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgTpQC2LuJ\ncGoh0d2Fq3pOdZvHUmLm2S0CQbLI4q96UnQCICNNiyn5MbD6VXxlBAMrAPVBuj2A\nd96r10jYork+REOO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc478", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `478` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAfwqjeTtxGxaBPkFcMHQfmLMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmYjI4ZmI2LTVlZTAtNDJhZS04OWViLWJjMjFlMjkzOWVhZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYxNTc0OWQtYjNi\nMi00YjVhLThhOWMtMDg2OWU5N2UxNDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZX/s7j8o0mU0/Clqi28MED2PfXPqexVFg4MiYUeqaFfKzuVVVd6Oy4zHUvrj\nyzV1d4Y+AqAZrNCjqWeudHvmiaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8mthz8qIRjzRmhU0j02eSEQj+7IwHwYDVR0j\nBBgwFoAUMeW2OI/ZFJhBFECPzbbA9AkEUHwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDivQ2/jfwn76Q2PEkTb+A5YzYuJ2K/lAt5WxYX7tVHawIgCGMZCXlX\nGysfaOdHnR4hSGK+TUU2JGCTR4Mmt/moznQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZHU9f8M1TK9pfkce164GlydMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmIyOGZiNi01ZWUwLTQyYWUtODllYi1iYzIxZTI5MzllYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQP7EgeFIEshJvhcYHKiY6JZGi/+bo+97kCqfq2BTG126AI\nETpeyyNf/vWIUU4Ss1daB92BWu8ducViWG/TdnL1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMeW2OI/ZFJhBFECPzbbA9AkE\nUHwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ6mxLWWcds/MRlZ6QxaM6dHwmuATszRz6drMKJxpXnaAiBkAIPQq8Tx\n9wrIfaSDT+Lmu8yKcB3sU5GU+KSpg1faFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQVYrqRrqAEjuqXpAofE7DN+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYxNTc0OWQtYjNiMi00YjVhLThhOWMtMDg2OWU5N2UxNDI4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGU1OGNhMzctMTgxNS00MjExLWE0OWYtY2U4YmY1M2Nl\nOGQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZamIIxExNcBtGj6tctuvx4du\niGA0VoZBbDdlaGrPLp4wIcbThAI4rPmeG3T98vdSmsPuGHjXXBN7lYSc5zX9q6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8mthz8qIRjzRmhU0j02eSEQj+7IwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAOsWVHyA\nLLXbgqAwoVbWj3t8Ckxh8tPitqyK2ZS58J6HAiB3q0B4++Po9im7RoIG3H9WzsOH\nlA+i/CCEJGHvlDz3pQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc479", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `479` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAapUOVRDXI5jdMRDadhlDAPiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNTI0ZDUyLWRlNzAtNGFlMi1iMGNiLTFmY2NkZTRlNTdjMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmIxYjE0MDktZjNi\nMC00OTNhLWFhNjgtZmU5ZWQ0MTYxYTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIRikbOel3KRoboqs7O1wdj/XTfthJGHDMu2quzCW+bSZ3d3G9eMUojWS6kaw\nBBpvE4PJewzAA/qC2G9JG+wKxKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDoRXuyzNZqlr3SHfJU+sITpmR8AwHwYDVR0j\nBBgwFoAUvHkWB00coUuydFBfXgzuPmSPbiUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEcca7LjY+gDxnmx0hI7nPuKd+2j3a3DmzFGWoGe\n4xGjAiBUXdpTH8P92QXPVqAT4O+GHn5C1/TZpTN6rFfwI+vPTQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX5UXn61sXzF+ZI/wrfA9CHPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjUyNGQ1Mi1kZTcwLTRhZTItYjBjYi0xZmNjZGU0ZTU3YzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuM2iMLpmBqTOa3EuvF1VjqicABL1MSrs2ah32eRIKKXN2\n8+OtLncEvli9GLJzu0pOBDsi5FL8YvY1RYMykX8Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvHkWB00coUuydFBfXgzuPmSP\nbiUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALE5jwkzJi325/nDCgwWm5Trr5iWpFnSmjQlBHvEpEJQAiEAjClNgoss\nS1Reyv12Zyvke5MaVuET3i9L9I7GUbNGjrM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQHCoiE4/+yX3jaQncHqw/WzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmIxYjE0MDktZjNiMC00OTNhLWFhNjgtZmU5ZWQ0MTYxYTAxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWJlMDE0YjQtYTY5NS00ZmZiLTkwNmUtYTUwMzc2YzY3\nMjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyc8kcLgQCQc+HGzXJx7NSvOR\n1DIQbBSCLlzKkDGaMyRuFS7tjM74//gGXm92ffma4gS7DS5lJX+RShcy8AFpAqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDoRXuyzNZqlr3SHfJU+sITpmR8AwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJzEi1XO\nxo3g6ScN1jyEzDGZH8B+y2K6uCzvQgiy2xRbAiEAv/nNQwfQlmwqW6lc6tm5o8Ur\n8ouGcvFSP20ayJWbmEc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc480", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `480` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISARk9+Xi5Cpql4ZHmNX7aG0C0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjMGRiOWMzLTRiNjktNGI5Zi04Y2ZjLWQxZjQ3ODkyMjk1ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJmYTc3MDAtM2Ji\nOS00ZmFmLWI0MWEtYjk1NDNmMzgzZTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8I8n1BU98VtsHKW0u1zFche8ekqQ/Xb8srhAAXqW8UpTSD7FWnYVPll1Yu0f\nSJf6p/eeHo2SyZFGZnukMfmzOKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Uzz55/vSh0vtnp0RtNNnl0vjyMwHwYDVR0j\nBBgwFoAUyD+dGCDyzO9ShjIyZbcEFPy9nNAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICLIuv1CJCrHk4L7g2L1IIxjjJDWgTWI9yA3oruS\nWsFVAiBkd9INabFsBfu5ScNyRqPF0Zk4YA5AbzokTYoYXuprjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVXgYCLgMX9oF8dtKeKZcGRDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzBkYjljMy00YjY5LTRiOWYtOGNmYy1kMWY0Nzg5MjI5NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASECywyyV/UoPJeMFzJTs0vpXsymQH+B6vcHO1YJB4lgDcK\no95QenoiLeoSDtpPGRoPLPdW+pXAWWflUQOj8Vezo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyD+dGCDyzO9ShjIyZbcEFPy9\nnNAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEuYM4r2fDSMf/5qiXV9DhtCYS5yWHn0f29Qr85P4bF8CIAuEGdhmrbMJ\n9dG3GcmsR4kNbTZa84X3HgE67JBNTotv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAWXd71MKhw1+Sy1zh4xNLuxIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJmYTc3MDAtM2JiOS00ZmFmLWI0MWEtYjk1NDNmMzgzZTU5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTI0YTkyNDMtYTQ2OS00NDk5LWI4OGMtMWVkZjljYjFl\nZTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERSh67qQNrFL7g3H9SVfxSvuS\nj8K8M7s7jPpNV1Cfv/zSAEfMxUdOQ6AKcYLjstE/fRDAu4QWjSqwWug0icUcQqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9Uzz55/vSh0vtnp0RtNNnl0vjyMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgGpKo4RQw\nOzk4H4AgfsU0/MRFcNlS/E7BF5qT3MT8fu8CIG/wv45FmXS3Dy3Hqj1fjWAzqzvH\nPfwpHAFHcxBRfOfR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc481", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `481` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVFx6xhCuIabv85thjGwOi+VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MmEwNDcwLTZmNjUtNDlkZi05ZjRmLWYwNTc5NTM4ZDQ1ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFmOTA1NjgtZDdh\nNC00OWFmLWI4NzAtNmE5OWUzOTRlZDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4iuqgErfUPmY4XaaqahTcnByR8nY1qYs96XynzjwrsOzpH4DlEXSbLaQBgHT\nCGlva57hhCUXAgaf20ZAoUEZ/aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPiaVGt0fH8KZlF31Rlb6KLexgiUwHwYDVR0j\nBBgwFoAUGr81W4vh78HWTdadedXIOihkHZUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCTkZNUg4YaQ8EZqLYZO25WcSP9rqlOqKx+bViGfEPl9QIg\nLvSL2SnZna3H9+LMluKJpGzXxYFUd+mFaFtpx41cUPI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASZIlOLvGfs53q3T/o4b8lbhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODJhMDQ3MC02ZjY1LTQ5ZGYtOWY0Zi1mMDU3OTUzOGQ0NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxywAVjz/vGyiXw4D7o0yTcYeBs6tQmuYOvoe8gSKpnCpv\ntr0Wxo2diEFR8TJIJhhbVvnyzAb0votT+yBuWMaUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGr81W4vh78HWTdadedXIOihk\nHZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALkuUcMv+wJXbifoVAqG6bmiouYTRLSGH92jjzx+alCTAiEArx6sfiQv\n6tGS8FLfDPQWUa6eGUHqHAJrC7+3y9WN4sg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARB7PkYj2KhNXuy7yYtr6VOHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFmOTA1NjgtZDdhNC00OWFmLWI4NzAtNmE5OWUzOTRlZDkyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDRjNDI0OWItNzg3My00ODUzLThhZjctNDcxNGNiYzE1\nZWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUUOj+tEsJ9ejlMiuY8rWMQkp\nkbODH3dmUtj4a4jQlcdfEShTEqYaZe2vud4AvgRHrGe0fmjlgIO+BylLvwCtNaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPiaVGt0fH8KZlF31Rlb6KLexgiUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAP0Y8OrI\nT40uodUCDI/SM2OFi8//eevNnNgdgWnBYDtqAiANKJ9oLedLxB3SczmvmXL6teMD\nMgBKHedpn1Km9GgwtA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc482", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `482` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASLoqF59B8zQl2faAVmtBW2qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliYzM3NDBmLTliN2YtNDM0Mi04ZmE1LTFlNGI3NTdiYzU1OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRkMDIxMWYtZDgy\nNy00M2Q3LWE2ZDUtMDNjYzU2OWUzNDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4VGmCS2J3sxyS5+dxgv7G70yexRKudjLYmQ+oy/4BKImjiwvgRTj8M6Lnw9E\nJ9+FZhtDH4mcsPAVDGEmsJLJ1KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEVQnePEqH/CQEEfXEVWcpNaz7GMwHwYDVR0j\nBBgwFoAU36mVJlX55PBDD83AgdSMWs8J8nkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD56Gj8GsK4kNv+lYNY/sibHpEm0e7Y\nAMDnNxg4dnbMUgIgIaPcbK50zV5tOxBo9rxp0BJnCwUXT95cBsJ5g9LiF8Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT3BQ0lR1xrQDpXhJSF8u5XKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmMzNzQwZi05YjdmLTQzNDItOGZhNS0xZTRiNzU3YmM1NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWtjA7580znHL68TCDRN9DLF77PJi2m1mGlVc3rqCNFZhl\nN8pifKGUsWajZ3ElVG3CRmwRWogzmvmYqU7ubr20o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU36mVJlX55PBDD83AgdSMWs8J\n8nkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0UFFmyqlA/quML9hwNpEfN8M0e7pciqfQMls9o8nYJAiBWryZgkArQ\nhz0oaHHFMxB4QGXLgFqe14U4xFL7Myni/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYyos8BjgwLuTr5lsvH0CFJYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRkMDIxMWYtZDgyNy00M2Q3LWE2ZDUtMDNjYzU2OWUzNDYzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDJkNzNhY2UtNDVkZC00ZjczLWI1ZTctMDc3MjY5M2E5\nYTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvpnOf5jwmE/wqJ7UMI5SSPz6\nCkOyVHrvA8udNLjW0mByu5WzVjckzueOh9/okBA2yEAo2HHNoMoXvmL1mMH1SKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEVQnePEqH/CQEEfXEVWcpNaz7GMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIhZIQEC\nmUwpV773Ywx5VyG70ZmcfNsIIqdVzsyxYFrjAiEAubOCV6ZMWJntT6/DxAZ+AcJN\nBlJX5EChQFgE9MQvg3k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc483", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `483` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISASrTmxCe+BQ4tvCZyBY8UtULMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxNDVlZWE5LTMzNGUtNGFjYi1hNGRiLTU3NTZmMjYwY2E3NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk5M2M3OTEtMzlh\nYS00MTI1LThiMDEtMjY4OTFiMmZiNmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVyP6wcKcFFCaJUbTMe4kcSssRKZsSbx8zxckpH7zXmrik69gMywY7ZYPVV+3\noS10FCP3jRCKlQ2cZouAsU5WlKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7YbJWSKmrgDxR7DYfzXIW4vUvSQwHwYDVR0j\nBBgwFoAUz8zcOmhTS+Wuip2+dHCrDp5Rt7swSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIBh59DQmr1c/0pm+0p598EWSZvMibao1\n8qNK15bn8h17AiAVvR/1Tx1tJEUsnsF2Yy1M3aEfNS/jP5DbHca+SlkwKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVEolNavHKWugqpaLjObudcSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTQ1ZWVhOS0zMzRlLTRhY2ItYTRkYi01NzU2ZjI2MGNhNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcgj6bwVFG5JeHEUsNmReOiORxDliOQl+NtWTMxvo3imyq\njaEgLqYJOfK4Socn5MmxaQF2ojrhTkJMHdbqxlWgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz8zcOmhTS+Wuip2+dHCrDp5R\nt7swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALNHg5BR5XegoxeBpj3Foy/pcOcphdLv+V6CxYSu9IrGAiBSEUwT8OCx\nU4uJWCCHq+HP768WrBkY8tu7lsbdAw+yJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAf+o1SjausGRg9oUFe/sEFF8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk5M2M3OTEtMzlhYS00MTI1LThiMDEtMjY4OTFiMmZiNmVhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODY5ODM4OTItNTg1MC00MjQ5LWFmODktN2M2Y2NlOGM2\nNzc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqnRaN/g8QYQwpZ+wYPc8cZcX\nDQ4oCvK2scMpso7C2ZL4Yrf7EnrAQJcYxmuzR/0+Hhuv4mZU3wwcKuGNcMiPuaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7YbJWSKmrgDxR7DYfzXIW4vUvSQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgEEBc8Zhz\nUFb1q2lnKXSl3haPzwMWhDtOx6AeVHYMAM8CIQD4CtB5UgHDRbOb7cJgGjDQXvnJ\nfjEz4TkyzkhoGIhHXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc484", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `484` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISATs5tJ44RuVm6mCnpHGtdP1RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MDA4ODFlLWVlMzQtNGQ1OS05NjY1LWVjMTZlZjliMDUyNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNiNGMzMzUtOWUx\nNC00NDJiLWI3YjctNTNkZmVjYjkxYmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuTcgkmITEKn5RHhadDJ0mRVieA1GXtmc9sVGEKU+TEfGWyjEDFAmtO6dJlAb\nrwO4ZUX5XXvyeYVUhCV9VSs7rqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2xXO9jS9z0sJ+4IXs3w4LWSiCRgwHwYDVR0j\nBBgwFoAUhl1Otri1NkLeDx+F6NALxWFdyc0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIHXBkZLlUTuB\nSOjZ8di3zDYjS66H1+P/4/ZvqL29P/wcAiBhnZCNuG0qbp1Afjeu7mXhXVAclAsf\nOwb/WXfQxFUN9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZdmj4oAYvpgRapqxUir93M8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDAwODgxZS1lZTM0LTRkNTktOTY2NS1lYzE2ZWY5YjA1MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMS0/YLn2LD2/YLqu0/9VwgV0VCH72G5RCUlE6KenPBJUI\n0gu7O/wZEJRFXtHl3z03UmTB0SXObjQlzlTxL8W3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhl1Otri1NkLeDx+F6NALxWFd\nyc0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPv3g9S82uimxjwZpFZQCd86CfTfG1rGYucf1IXzyKH/AiEAiUzWOluW\nNVpv5BKkvw4oT6gzwvDRJ/aNYYwFrkBCwFk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZnmsb6Ond114vA/bAAtSyxBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNiNGMzMzUtOWUxNC00NDJiLWI3YjctNTNkZmVjYjkxYmRiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjk4NzM4M2MtY2Q2MS00YjRkLThlNzAtMmEyOTQ3YzEw\nOTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyE23i2E3S1e7ia3/U98zz+Jd\n8zZX0oCfczbz1YsnnB+WHg48dzia53InRIbgFZM5RzFtRv9OxUng6iF2lrUh8aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2xXO9jS9z0sJ+4IXs3w4LWSiCRgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgSi0p4csE\niQrhNCGpsTLMo6JRKs2hR3QPRvP+uQZYp3gCIBIMXybFb6+tWphWnIFVbR0hAxPb\n0YKEkdB5vBmrSfh2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc485", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `485` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISARzcvleNeRFdZr34y63wX0kzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNjQwODI3LTRmNTAtNGQxYy05NmJhLWM2NDIyZDA2ZTNiZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkyZDVlMjMtZTZi\nYS00MjAxLTkzYjEtOWFjYmFjZjU0MzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0LGnXPna5OO5iS817YRZPn+wqM4511JLkC9hmIaRK4L4uW7cXZscI1GPsKYm\nlr06IJVoo0SDuMXJjhrp8Sa+LqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu514u+9qbgbK+tav5Gu7yOJ8Sb8wHwYDVR0j\nBBgwFoAUEMyW6Kvo23MYZXNLrR4jeq9wr0YwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAOCzo3FFXkiC0x6PAALJ1L1k15DK7mhNiNvXjM4ngJ6rAiEAo8vGWSCI\nP65eEMLSTw8puorJYLvbjvZk2OzmzMXMaPo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe3lXd4a+ebxyuGI8UNmXkMfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDY0MDgyNy00ZjUwLTRkMWMtOTZiYS1jNjQyMmQwNmUzYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS15liwe/bw5wlRBjXgKHMGEj74pBv3sJY/YnJuyI11zyPY\nVL8mgvkUIAHXEyfD/lJdozpGglk57B2KGJjY/1Rko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEMyW6Kvo23MYZXNLrR4jeq9w\nr0YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANxuew1zqG3ih4ZDp+ZCzqD2lS1HdNRZJJL2YU0NHe8eAiBSFagmnyYK\nvBWp9ctltj78DOQXU0bVxS3ue7nR2BHDPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAS8S406cfOpwgTMQfaLZtLpsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkyZDVlMjMtZTZiYS00MjAxLTkzYjEtOWFjYmFjZjU0MzYyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWM0YmI0YjYtZTU5MS00ZjdhLWJiOTctZmIyMzZhYTYx\nNTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoJPf+bi/o05tTfm5c/zYgAzT\nb6CaN5M7IHmg8JxoJInmt3Hs4xdrazsQqf0E5Pn4RKZ8z0vnnaOGfdYKIZgcAKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUu514u+9qbgbK+tav5Gu7yOJ8Sb8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhALANyajo\n09VHRZ8s7u6DIJ8KdnqKnJ9ojjW4o2VPP2ycAiAL53jbjLbWa3R65LZvT2VTSLmd\nA8KvzlU5AgoQ/HHxBQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc486", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `486` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAcYacgYMWysvVq7l7/T5RqaMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmMWMyY2IxLWFmOWUtNDI4ZS1hZTkwLWI1YWU0ZTFiNzBjZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMThhODFmMGMtNWQ0\nMC00ZjNlLTgzZjItYzA3MzI3NzU0NDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECHe1GYkQ+cJXqKMCbhLmAaPbKPD8MY1/uNvm/sAkCgzHCmzoKGpuodNQTPr2\nIVr3Mq9WcG2inWBqdp26j0MlEaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNAT+Xc1cM4opBsoWOrf0+1VFB/cwHwYDVR0j\nBBgwFoAU428NWcaJIm9djyZbUjMvCsybpnMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAPJ9ydsFpsDk57PT2ieqRitIoCt19K6+mWPKWp6G7h+5AiAxyCyjnaie\nD9Tz9KDZ9TQRxbyG3wXkEUXPrJX+vhoXaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYEBEQOCnotsUM+807V216c9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjFjMmNiMS1hZjllLTQyOGUtYWU5MC1iNWFlNGUxYjcwY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVtaR63u13Q0GFPCmAoP2H85O5N36DGweQSZ3QibRg6Sid\nqPXoxBmyw2qsUeTzzgXWioQze/RQqbJV9e8rm6rNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU428NWcaJIm9djyZbUjMvCsyb\npnMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANgC05pK/KREDCIcv1a6jk5EeWfGAEKORUcvHN4TtpTEAiEA2E8C32UV\n+jtryJUuBKDlCxz77+mOnxkm7Naz3qBidBk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAe0futsZlddVTcYezRBeM9MOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMThhODFmMGMtNWQ0MC00ZjNlLTgzZjItYzA3MzI3NzU0NDY0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmRkY2Y2NmUtNmUyZi00YjFhLWI4YmYtZjY0YTY0YzYy\nYzhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELsUNUT93yCeUFOkI/4SlYucq\n/SMUCHM15sVRZ4A4lTptf4zlLJqnFnP1L121mz/8WT6/rMDVYD9X3UBUxzgROqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNAT+Xc1cM4opBsoWOrf0+1VFB/cwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMsz2ch7\nYSElc2tfQNr2L31DJvoaF5kldHesrNtqMk8GAiBYahR86B6Hew9rh7XKSIdJx23K\n72Xv0k43JD0VB8Q6Vw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc487", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `487` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAd2dQ9Y2HP9TuCWFu1AeYTPeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzYjMxMTNmLTU3MjItNGQ1ZC04MjVkLTI2MzJkMDE0MGZiZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTliOWI3NTYtMjc3\nMi00MTg0LWExOTUtNWRlMDgyMDkwZDg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHoPNULIZV72eVBrdS0agjsG7Z9PrRC8FSS9xR1hXGgFFkYhu+6p5zUPPXzIC\nIvcFPbOS2G7YZu6Iz/2dbHXK3qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXmVLVYuvGhr01D0csHDqkYyMjuYwHwYDVR0j\nBBgwFoAUDfUJcbXe3cF6TJ7UoqRK4TRa0gMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDauXZ9IxWB9o9/K2pz4ZsqdoWYRtHwWWua571XQwqikgIhALUl9ek7\n+8ZBzjGRuosX6+lXO4LiplBnBGk2uTSd11Ww\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX2a9ryefuHsbbfPIJ+OKqeUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2IzMTEzZi01NzIyLTRkNWQtODI1ZC0yNjMyZDAxNDBmYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATorzQNrq2eo3k1KWoMMexFGk15BvZrsilndVWshJEK9Vhg\nmooi07OChZ/AXOUxBr/SW96I3kRpElEp4/7oGj0Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDfUJcbXe3cF6TJ7UoqRK4TRa\n0gMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIlZR+9V1sP66EID9B+QMhC5wXsP3KdyebV6NkzqWf4UCIQCxQnAKIes/\nwJPDTPa2t1M3Qi1Ddx2BGsa/BcoLevwECQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAa0qhJ2cqZhe96rfChvJky6PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTliOWI3NTYtMjc3Mi00MTg0LWExOTUtNWRlMDgyMDkwZDg1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzdjYjkwMDctZDVlYS00NmI3LTk2YjEtMmVjOGJmMTRh\nYTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEURRe9iXAi+JTeWIOjLr/5i5A\nFB8BTqz9GtqnmgHUut9dRH70cvWXWgbJsDvA9o3Ev3zS91bhiJbjth/4UU/TYKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXmVLVYuvGhr01D0csHDqkYyMjuYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOPLEAp+\ny9mgphMZCSPFu4GoAEF/PfEgdUm2E89WP2JoAiEAgYWTjOJ/19WC8xZhK0QrOMa4\n7JsPrP4gj5ujVcksOa4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc488", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `488` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAfAovEc3923iOOcbfmsARjnPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZjg1ODI0LTMwYzUtNGNiZS1iZDljLTFhZTAwOGVmYzM4YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE1OTJkYTEtNDEw\nYS00N2ZmLThkYjMtYWZhYzJmZjMxMzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmct9FDg9V/f50ggzHbNQTb4zzMPfA+mLLdnLtDaZ10WqTMxIi8Pji2Xyqvdu\niMR+27r3HILOhlrT1U+gFrhxX6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURQFvElZQygQMvVQJ+Yjg5jDvHcUwHwYDVR0j\nBBgwFoAUbrz5ziHZxN5rdbGBCwpKwCZvft0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDqn1p8b/t7rMlWimXJVHlq1c82UkfXs4sV/9v8\n6zMGswIhAI1rdfn3VIKBLMR3LVerOD3FED74vcP8UDAmmrFiC285\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbQOnGxbZ4zvcbQyoJzoZIeXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWY4NTgyNC0zMGM1LTRjYmUtYmQ5Yy0xYWUwMDhlZmMzOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDyUyNPseYZvfa6H8QDNbgQlHwuUikIHRBhusPg0ivdK1W\nym9edCaMUqkQhEZfxHjqMtYYumdODd+VwvTxQWVuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbrz5ziHZxN5rdbGBCwpKwCZv\nft0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAipu0wya92NToaUuijR1IWw4n7Abv15UU1axUKEZ0AYCIH1btB53D2z5\nJVH+O2BqQJ960pkhTjrtI9VQsK4f2++W\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVPClf8Z09YsPkwLE3EwNshGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE1OTJkYTEtNDEwYS00N2ZmLThkYjMtYWZhYzJmZjMxMzljMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQxMjAyZDMtYzQxNS00MTMyLWIzNDctYjgzNmYwZmMx\nN2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEc24uxNhQbv9hkGDaRwu5R2G\ng+qwzDVYyHQAWAbQNiVAQUWokLjdoVFrg4Ozr5Qn0IdJmssKoh40YRiR+uyzz6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURQFvElZQygQMvVQJ+Yjg5jDvHcUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgY0AmFm5/\nmo9qLC+hmE89vK646oj0rUQkjnAJ2pMROBYCIDxfEVrzNtD0epQ1+ocisUC36bWn\nVn8XU+nX3SmOISeX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc489", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `489` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAbZIoUfAyjrULl5SthoQ3o/VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwYWRhMTVmLTE1Y2QtNDUwNC1iMGI3LThmMzg5MWZiMjg5OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU1MmE1ZmQtNTVk\nYi00ZGE2LThkOTQtYzdmNTMwODMwN2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1n4tbBnEgkPI+mN4/jbpemXFDmTq3YACWOzTyefKQJuPEpnx/2YRQflJ6ZeC\nJPtlQCvohsqwKc2vng5tqZJ2H6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmOaZCex/r2ddPUZ0h42lL17ju/MwHwYDVR0j\nBBgwFoAUQimxJiM1XcINLwOI2freUcCG6cIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCWQVxd3UeVLU88GercrRwHckQ1ePPsUS05098l\nTY38XgIhAM2K7+2PiOdUP218s+LieVbORG7LxuFT/HRd57cYV6EH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbjQUOJjo9lhrr/jGQ/Zcw0tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGFkYTE1Zi0xNWNkLTQ1MDQtYjBiNy04ZjM4OTFmYjI4OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRMULmeKvqhRz3iDUif7gEBhLhSttDiKqx5Q4PdkLfOvL2\n4AjQ9pqEJpelMMaeHH1dN16cAe6GzJzwfRVIamUYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQimxJiM1XcINLwOI2freUcCG\n6cIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKj7NLyPrCKOjXE/GmJ7yyitjQaKijDUJiC4BTO3WWS1AiEA6pUHvE6Q\noy/w/c6bbarXAyhhsKKydTiqmD/8+i6Xeqs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISATzDhTYuzNHeYJZVQnx+Nyj8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU1MmE1ZmQtNTVkYi00ZGE2LThkOTQtYzdmNTMwODMwN2Y5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWFmZmYzMTYtZmI5YS00OGY4LWEzYTAtYzdhMmNlMWZi\nOThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFiq9e2MJJiPgG9dHIBSwSrzO\nJER6tg4O9PPrL6Q/37u7CkC0H3uIfa5qLMt+kr//Wie/Bd27qKVqOYFnUlswHaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmOaZCex/r2ddPUZ0h42lL17ju/MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIcSb/0U\nhwWyijh55d4la0hlaQTshoMK5XZHfy8lFnR2AiEAs+1DZsO0yP4u47LIo2HtH1oh\n94Idmsi+2CbEHZ4nn6s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc490", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `490` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAcqBrZ3jOIGD7n59MFFqGF3RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmZDUzNzkyLTIyMzUtNDhkZC05NzlhLTFjZTRjZjg2ODA2MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGY5ZDJhYjgtNWNj\nNS00MTViLThlMDMtNzgyZWY4YWVlMDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8Az8SNw00nxsmrsjYiFiTB2nd/sAkohaBRz2Z6TtRdAU3iCuEu6X5IefzW0V\n7byIiyZaJAwQEngn0GqcjN4htaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF+jqi0+Zhut9PTABHH2BPAehDxEwHwYDVR0j\nBBgwFoAUAoCLZ4C0nE7ADiXcgOn6sLXWU2UwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIFPcDXXN6PxTTzNbmnEvDGEvLXOlR9voAUbqYDuzGE7zAiAa\n8MEIjX5fluLbGU9GHojTDeGKNAA6X17Sjzftsle0SA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcPdibTPjdHXD4yrUwykZnDEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZmQ1Mzc5Mi0yMjM1LTQ4ZGQtOTc5YS0xY2U0Y2Y4NjgwNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/SNOY8WkJbhAV23vdf0CaLTjK1O6ccaEdq936ym/7n1Mk\nwqlDspSLe/3UVoXFOUdOM8UGBHJVmR307rDAYWo5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAoCLZ4C0nE7ADiXcgOn6sLXW\nU2UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMXCa5XSNQhy/82sRHoYbSMfPsExrzCuhH3TiliMx96sAiEA8f8zE/iG\nO/lmxveNNE4CwlN79kkEFt4kR5o4a8TQlag=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARE/qqjqW7++31AewKnAWXmKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGY5ZDJhYjgtNWNjNS00MTViLThlMDMtNzgyZWY4YWVlMDkzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzVmNTM5ZDYtNDgzNy00NWEzLTkwNGItNzhkOTliZGY1\nMGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvmyyIneCADkPtiwaGnbD07BR\nC+D/nQ+oL2Xfm1WFE8t4xTwbqJ5Z7dLr2F7wHYHVgUs280Ci6YfSiBE3LLZcE6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUF+jqi0+Zhut9PTABHH2BPAehDxEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJhNp5KO\nJHJGvTYL9rrl70cV4bHDJ385QHVKeClAPzUuAiBQ3lthyouqWuUTcDyCaw7Yv9BN\nZYgPNr99oT3MHRRa0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc491", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `491` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAea/1FLJnQJg8100+7/yt7CSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2M2RlYzUyLWM4MjgtNDg4Mi04ZTk4LWY1MGIyMjNlYTUyNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFkZDI1ZWItNzZm\nNi00NDdkLWI5MzMtNmRkZGIzNDE5MDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExFNKrMNMzEO2zmYioZD5Ae3GRlG5TcRGSKHAl9uIb8GKJeHomggXtSt4gm7g\ncAGsfUkh3nghoYYl6BlS3me7O6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ3emEQrTleEXhXO1phD1aK1pG6MwHwYDVR0j\nBBgwFoAUpuI6oSau2vzdseO2GUMstv7lYR0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDcqWAy5FkWoGzPbrDOjhuBIWr7MR3I\nUksJBWr7f58EKwIhAO3ubHHaaC3dKWd0ZwF6kq4di3YnCtLqMJForg44pCcJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX6XV4wVgCSj/uKJ31KTjPD2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjNkZWM1Mi1jODI4LTQ4ODItOGU5OC1mNTBiMjIzZWE1MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBwCmBFci9Taz1y8ms6qrqJZI77xuvYJPjtpK485geVHjv\nh+lu9OPPeeOdAFq6oGg8tSzQDZceqpOYX1hH9XiRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpuI6oSau2vzdseO2GUMstv7l\nYR0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAVRu8QiENcs279k1C5kHmcW4B85zmKKs/t+WFjsi8SoCIH60zWnGIUR0\nCP2gCP7URytVGAJtRSjWkrfkiSV1+bJk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYYt/2p5j7j+z94yyPRnRyEzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFkZDI1ZWItNzZmNi00NDdkLWI5MzMtNmRkZGIzNDE5MDM0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDg4MmEzNTMtOGMzYi00ZmUxLWFjNGUtMGIzMmNhZDVh\nNWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKcbwnoHC1a+8ZkcIrirg/BaD\nzxKZjpEgM5EMcZN0Qn53511gUzDpQdjwAzgjRJbvShjrPa5L1s2IPEqCuiiGWKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ3emEQrTleEXhXO1phD1aK1pG6MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgQz8DmVVv\n+UMj3ggvyfUJXRqOL2lX/IGC4ve3IW+ZkfoCIQCe7k41chiQqU6/5kpvHw5xyXqK\niE/XVA5vqCCHlv8mZg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc492", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `492` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISASgPeOOnKAa91iAm+JlOJuWvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxNjhlZGJkLWI3NDgtNDU0YS1hOGRjLTNkN2U3NTg1MTFmNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJmZDE5ODctN2U1\nNy00NjFkLWJiNTMtMjhmZTg0YWRlY2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUoWax/Rh7gQQ/5hlzWI8MAV10NrjJDfDZfM1U0TBppvE5l70Y+6jdfFM97FR\ntO567WsII2kByIro/L6A4kppDKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUawmLm2RouejUqzjzTV3t8V9SJ5cwHwYDVR0j\nBBgwFoAUJcOl5y6mchi9fmgDvLZLvKEOtrowSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDlfoK1da3CZm+AhLo/lh+0dx8KDLGr\nPfJW3JGIBGRN9QIhALP1toZRMZc8hd/4qIUYAasJSePv4AijSHw7WdkGYmhv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAViCDMfRIEZ8yDWD50FAjkl7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTY4ZWRiZC1iNzQ4LTQ1NGEtYThkYy0zZDdlNzU4NTExZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV/fb87RBCaS5EEVijex8z634j6udoB2Ew1BkW4h/BdW5G\nD5j5zFhi1KM14QRmIRqZX4ijUPRTsxVlmQK7Ve6Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJcOl5y6mchi9fmgDvLZLvKEO\ntrowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKRYsq6CIL4VUjRVZCTgVOQQRZ5DhyEK3El6VdLswL82AiBBYrLgtq05\n0qZQsIDGT08TswdIl7f9NJ1o4lhIw2B9Aw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAURVWn65i/T4rGsHQtuqWCjiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJmZDE5ODctN2U1Ny00NjFkLWJiNTMtMjhmZTg0YWRlY2YxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTk0MmM2NzMtZTYxYy00ZWM2LWI5NGUtNDI5NDNmNTc1\nMzA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+gLBY6vMOnfgGhPay4tZqkkr\nR4F/kMKnJ9BHcfttBQzsrA/4ls++T7/JcvcF758qFPUCalqtf50PYQy3Zh2Hl6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUawmLm2RouejUqzjzTV3t8V9SJ5cwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJYXDncu\nIsAXK/MuRQFZnbYdDbRbNMU3sxaJ0RR76lHdAiEAnSMqeefxbBr4Is6PXOwv4Dnc\n31TJe4YhMfueVUyBJhU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc493", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `493` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdvPDtO0dsFSMblrbxrSKcXSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmYzRjYzA2LWM4ZGItNGNiNy05MDdlLTc4MWUyMmUyYzk0OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY0OTllNmMtNjgw\nYS00ZmQyLTkwZDktMTAwNzg2ZmY2ZmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz1XNkaSWjCCz0pBz6M2XjnO0HcfMXBV94uMAC2RKo3gpXDlMfSM3Vc/kdMub\nBcEFhlq7GNNCfKG1EU4vgJBklaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPXCh1IQqaZ5PaZrhCtJmLKg/seCMB8GA1UdIwQY\nMBaAFHzuDw69dQU0t/yjNOcE1DSvV3VKMAoGCCqGSM49BAMCA0gAMEUCICIA2hUl\nCLlPSR4UMeQ+FNCrIA+PeoZPBBwDzggeua2bAiEA80eSbcZwXy9eOV/zwDwjgObS\npDqcpM3h8r7GI5PSFiI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeaWjKrtlboxaS1R42SNcipQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZmM0Y2MwNi1jOGRiLTRjYjctOTA3ZS03ODFlMjJlMmM5NDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9GxTYPBQfSl5IWPU0vMehVpnJkY+pYIHSSPCHw4FXaC1J\nkbFdYnsE8nmGKptyLRh5PRhiKXB0MueEhKJdkJdqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfO4PDr11BTS3/KM05wTUNK9X\ndUowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPP/wjAVfinzjb/mXjWkUnD389BOd54nKDs1jKB0zuiqAiBYKU8D3t4L\n33AhQbvtV4QONmj4h7ET5elgSR93ciZn3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAWfEaOj5MAW+d9vWG3f8BxHiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY0OTllNmMtNjgwYS00ZmQyLTkwZDktMTAwNzg2ZmY2ZmQ4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWEyMjkyNjQtYWEyMS00YWUzLWE1NTUtZTc1Nzc5NWVh\nNTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE47H4hdCMd8F9gTYXUcUW6uef\nclg7BoCexc51KVwfmtruT80xH9N57lg9t8AB3VchfyZX+vgW2AiJAGhSNbdETaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9cKHUhCppnk9pmuEK0mYsqD+x4IwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG/nUvWDGVZh9/km\nDSlGWHpOVuI8h+wBNH6ApOegS1bdAiEA6tvcBzV3VwCdwBNdPWvAuyDESsX6cpOX\nVkzePq04IT8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc494", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `494` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQtHJpuJPdY55oOH7vXuvVgZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiNWMxMzg2LWNlMGItNDFjNi1hNzRhLTQ3MTEyNzJlZTA2ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZiYzAwNDgtNjZj\nZS00NjYyLWE5MTEtZDNmYzhiM2U1NGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU5zxv0PPe2v14ofGxxOwpOhVdt+43PlENHMOLNfy2Mm1SIs35wYjtSPvWBde\ngszfz09Tw83OPtoy6Psy4DQ4CaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGbHbdJgNL6h4q+k7XH0XzE60z1uMB8GA1UdIwQY\nMBaAFAv/nhVxAATh6BNF6d3P0hGOk0DKMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAsBoh6Q9hiREl1FEZOheHew1QHrYD9eUX\nmm7NzJw1h0gCIBd7+ippofn4ZFmy7lUu2xHO2hgTV0oo3fFt+n3fTJ4/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW4QdD5tYB+KubpcM+LUEMhyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjVjMTM4Ni1jZTBiLTQxYzYtYTc0YS00NzExMjcyZWUwNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQff2mkEXhUPVitZ/+Upr64AYygrJ7xPrYKKOPvq+LHxk/i\n8gq1cZYsA3lYJ5mds5HZBwbVUwjpEPyN/RQqlFb2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC/+eFXEABOHoE0Xp3c/SEY6T\nQMowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJese0qab3+6EtSxIA27pOjJNoP+K7DUS6l+fDryVf5ICIE2jVGws1UIG\nR8eyT1DeNzvxT+VWnpSYEcJytVrDtd33\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAV8zOC8gxWQMIFIDfJ42eVwRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZiYzAwNDgtNjZjZS00NjYyLWE5MTEtZDNmYzhiM2U1NGRlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGVhZDc1MjktNGYzMS00YmQwLTlhOWItMDBhMDIzMDI2\nZTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaU1LLfoJ4lcg6MiyWR3YbuB1\nZ5dMpBZRdvT+rT5G8TI7G89KcNSdQrvK4kUa6QaWVjKC+wMVr+ztu198L/a7J6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZsdt0mA0vqHir6TtcfRfMTrTPW4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDX6/xpXHi3zPcD\nkVfO0WmaJw96QAjnUHWZcolc/iwl6AIgf3KvX6RvAliC6QZX/m51biH66p/3x97U\nHfn3rzle2Lw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc495", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `495` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbRcKu6QihAwlkZqXCcidCeFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiYzVjMGVhLThhM2UtNDI1MS04MWZmLTU4MmRjYzE2YjA4ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg0ODA4NjItZjdk\nZS00M2Y5LTkwYjEtZjk5ZmQ1ODZiY2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKy4OsvYWrq0RR5JpVOQpuKutggLS26LkkNnHR/Y/PydgF6JJOsAHdI8vj1GF\nSnuGqhoLNwxk6qc3p2oYd/10saN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKVnLQidc0Kfs79P43pMeosBsWz+MB8GA1UdIwQY\nMBaAFAjnWbzrf/w3pR2P0+o6GecrMmByMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA8LbXZrVrIE5kZ6tQbv2OHRN5A4XapYJa\n68Y2TgiH0M0CIA/1Tp9/SnCTS12dIh3ewZH8Tj+Kqd3fztSTbxiUQ/Ga\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaj1QHbmscgXr6QmjIf1nL01MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmM1YzBlYS04YTNlLTQyNTEtODFmZi01ODJkY2MxNmIwOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYvnf7mhxTbv+tRB7Wp2Oo7AL7YoIEHZIZAdKSfNGjGCDn\nhAAoPAhHgtWz8HTyj4pARm+u7aXb+q6DTzfbcM6wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCOdZvOt//DelHY/T6joZ5ysy\nYHIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJjyjB4PuYMrBFK7UU7iQOjKtkuuPwQNj54RO8wSuXEcAiEAwetetGSo\nvsybW4eDgfpkqVwHiiKvbdnRR+cfOchTTSU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQgCGjjMnhEQGnAKX7COwvWJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg0ODA4NjItZjdkZS00M2Y5LTkwYjEtZjk5ZmQ1ODZiY2NiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTExN2JjYjMtZDIwOS00YmU3LWEzNTctNWU3YjhkMDVi\nMTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5U/je9WobntonAf04El4cvj3\nneKi3LcmLogjhgES5Bne0CQ97Q5O/g+XF/sTfC3OTxgB6rp9lzUfI0wvNeqF66Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpWctCJ1zQp+zv0/jekx6iwGxbP4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDKa3a7lErpN3A9\nSgbAKXNvhRgnUiVgHB8qyfHLwGTxrQIgTeauOpPWvs0sEkbEI6OvtMqIGz5IyiSZ\nnAOodmuTSqc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc496", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `496` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdX8vXVp0JhIqfMc3djSTIZXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMjBjNGJlLTFkZjktNDBjNi04NTg3LTdiMGYyMTYyNjgxYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzEzOTZkYjQtODRk\nMy00MDgyLTg2MGUtODIwMzE3NTRiMzQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf/h7+8EUQi2v4GmPC8YsbLbLrxlwTrWPOX2uMRWtrnkeSmMS4ruH+Qm/CWoB\nT7dc6CcoOCLaFPFSmMFX9AovyqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTZz9JtFng1z2moVOm3Mdv3yyjXbzAfBgNVHSME\nGDAWgBQGb4eqkrOwAbnIq87rFBzhgJHEEjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDK33RR3lNQYDhUbFA+rYESbmgdeSb/\nwba+WgXpqbvhOAIgLcoqxs6plCdw0bfWpTIYNB90P4w+SJhy6TohnYiT1eQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdRkL+uKxJbT8DkGtdE5CyjAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDIwYzRiZS0xZGY5LTQwYzYtODU4Ny03YjBmMjE2MjY4MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAHezSbBaAq0AVygx9QoVy9OZzQ8ZmpjJ8TynD+3oskP7q\nkNGFty4+K4zgQGoDLAvCI+3BL/mbz4E3qIGGIz2/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBm+HqpKzsAG5yKvO6xQc4YCR\nxBIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIs0lUwJ8pMmeL3T3f9oB1ain9Uxe+DuwUSRT7t45PtHAiAy1d/U/Ucs\nOKsct2jhlLQLokjBccqS74jr1fcCY6TazQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAQaqFpirVLQdtZiAVi5eWEYWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzEzOTZkYjQtODRkMy00MDgyLTg2MGUtODIwMzE3NTRiMzQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2JmYjFmYzctNTg5MS00ZWJhLWFlNjAtNTY4ZjZjYzA3\nMzllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpU1azhjCBqkJLYv8Sj5yk3Tv\nR956cf6Kpr/BFepPlRDlyp4gxZjh5eq4Y8C7RJdGjivXu06tNXwG4Bni5aKuKKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2c/SbRZ4Nc9pqFTptzHb98so128wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFYHOf00qaFElLa3\nuxqau+TB6Ho3L6FEvkg2uTstmSmjAiBMiuWVq3j2LuEbhHADvbk9K2Novgk5TlD/\nR9bhzaY41g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc497", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `497` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAd67sE9irlnLfztMGknP5SjkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ZTlkNWU4LWM5MDgtNDlkZC04MDQ3LWE5ODZiMGI1ZmM3NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ3MTRkMzItYTA0\nNC00NTMxLTg2MWItNGQ1ZmE0NTUxY2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM7e+9dqA/YutnZf0Blxg3nhrucmHmUmFmZiTrYQpUbBXP7Iy3dD8NKerjHLx\n+BXkDX6BFs5HT4DKfw1wr+2VaqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF24HYEZNeJw25dXwREdm0wqe+58wHwYDVR0j\nBBgwFoAUIBmMUZVx/nS9OmlvqKBJoK1pn6swJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAHxftyFsb9CSDX\nrLo7xMl33P3t6l1NSy90IddfZj+YngIhAIJCU+8g2VcIHLRqy0dGcHYqq85j6fyk\nPU+E83+sUlEp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX+Wp6FCKkmPlUaL8wcHNfVyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGU5ZDVlOC1jOTA4LTQ5ZGQtODA0Ny1hOTg2YjBiNWZjNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeaRX41AGo8ffI8R42XFXbGEtqYm7elOa+RpYB2axZN4Bu\n4A+tTr98B8sE8GIcmG/uT683vco6Olgg/UHyTpAKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIBmMUZVx/nS9OmlvqKBJoK1p\nn6swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWkFf/dBH1HSaqHG8G2LYs7o7fh+tIbQeE83h6t9kNGkCIQCGu1QrVnu9\nYxGZVQGePVZ4n3sqBpjS7RlbkISqEtxMuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAWWc1irYVRHjkUfLDlVNpWzJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ3MTRkMzItYTA0NC00NTMxLTg2MWItNGQ1ZmE0NTUxY2Y3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGE1YTY4NTUtMWVhMC00NmY1LTg4M2MtMTVlN2ExZjNj\nOThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElqLKMpCactyShhJJpi82NzoJ\nQKBzONqzqK+5qhUmnhxZLJaNIUfkWaO3acfbChwVf5Xws8usrk56R9APlWcz+aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUF24HYEZNeJw25dXwREdm0wqe+58wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD+qpPNV46DlSkC\n6OMkaCQxzdkGd79gpQ6PxVS+Vz+CuAIhAJOVqHCZk3iglm1kS6SFLXb+J5TVpfG9\nkLe6TzRbZ1wY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc498", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `498` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISARS3oQBsKqvepJhiCMFpVJLuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiMDE1NTc1LWFkM2UtNDIyZC04YzI0LTcwMTEzMDRiY2FmOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmEyNTY3ODctNWRl\nOS00NzFiLWIzYTQtODQ0Y2I2MWM1ZDI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0KF54AJgQeHrimGjgwm0JVvW83fo19DordBxl8XD8emy1qG2bGh86D52jkdW\nWOi6tYeAID1kcPnQjP1L5u/ZjKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNtd9pANQ75MDP6/VvfN/pkRichYwHwYDVR0j\nBBgwFoAU2v8WVoXf5cnnxyXepyNjG+8EKzgwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAvXQcF1Y9llhS\nIze/gFB9esDZp2WBL3CQAMUE+7IONEACIQDh59H/lTgDQLlb6U+KshWRZ99l3lb6\nNjMDakuruK47Gg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAalzM6lt7qAiUo5QL7F+Z2MpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjAxNTU3NS1hZDNlLTQyMmQtOGMyNC03MDExMzA0YmNhZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5btOP1FzBy8KTmKvKzLXCAzm545vjRofvwdotGrv1jUsQ\n2tOGOypwxZu6YSsXi5M4UU4asjgblLTBcfMBYcZdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2v8WVoXf5cnnxyXepyNjG+8E\nKzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHYgs7KTrnc1Mcj1jo3XqQ8B0iSCAuQGRrADUnYpZ77UCIQDEUypZ8o6g\nZOzAJh2FMIHQM7xeC+vQGSy2JTuxtAU9hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAWje7eqVs4bJBfNyAKmOQyFQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmEyNTY3ODctNWRlOS00NzFiLWIzYTQtODQ0Y2I2MWM1ZDI5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWM4YTA5ODYtYzdjZi00NmViLThhZGQtZjMwODNkMTg2\nMWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENvDZcskW2RvAyxq7GxvIt2sH\nftQk0k0cP8HbYQsQ18Ld/uqU0W6yCnX51l279SpWIXCvBHi5yfn/bzINHi+BM6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNtd9pANQ75MDP6/VvfN/pkRichYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDsgKD+gakPIrx9\nYCpXqfOIRsljBjbpsz8W/oKAWuUwzgIhAO6MZx0Hu2lFTllqxcGuG3JDcoMWDqyj\nw2R8HlnsJ7W4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc499", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `499` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAUVtHfur2OutKuIl9jabCn7UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0MzNkODQ3LTAzYjItNDY3OC1iNGFhLThjNDc3N2VmYjRmMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc0ZTM3MTItZWZj\nYy00ZTMzLWExOTQtMmJlMzQxZDYyNWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECkTl3Dclp3HCLjUqxVl39WsJAkFG4bgCJwPzEA8+UOxcGDacUYMZcjxy0kcO\nNYRqYR+R1sjQaPUg9FuOz/tlvKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmzn9FZb3qDlu+Kw+5s77+pGUg0gwHwYDVR0j\nBBgwFoAUDcb7OfZBYGay+KO9AeQ0wfbTk+wwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAp+EoDMWpBLQPP7xrTpv/\nLZkMur+QmB0EsbUwo/tQUUcCIQDUuJUjnDYYcMiN2KCKwbf2vlDw72y8aDTr7htW\nPLHVtQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcys2i9F7n4MKUk7YGs0SSlSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNDMzZDg0Ny0wM2IyLTQ2NzgtYjRhYS04YzQ3NzdlZmI0ZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATE0HkBIjisQn+zJkFjJ0Bmtil92dZSur71hyN4cTPl/Lo9\nYfXVFyBC9ajgbsx2/usAfAHp1gBuKA7rULKv279oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDcb7OfZBYGay+KO9AeQ0wfbT\nk+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRKXnmpnuhpkvWN/8gGOqvjMxJiECXVmOpPsEsE5MUOoCIQDIrz9ehZas\npgJ73bkVVsN4wFMmCQxPoaAhCFIx+5JSpg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAaVWhGTVLoxtDAeXpKhlLGwyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc0ZTM3MTItZWZjYy00ZTMzLWExOTQtMmJlMzQxZDYyNWM5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjZhNDAxN2QtZGQ3Ny00MTVkLTg5YTktOTg5OWI2NjAz\nZmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5xbBJZxgQJPBrxN2MmWC41/f\nN1pTKX/4P6l7zeMRQwcFNX8fwXZzYxENHOBkBOT8j3DT00vC3IrhCK13xa216aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmzn9FZb3qDlu+Kw+5s77+pGUg0gwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCl//Up/Hkh/1gX\nqMpr5aBa0pTmI5SDAHoLva9aD9otZQIgHXSZpFWH6IyTrCVW1L3DjyfyrSFtx2ib\ns7KOzylgcFw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc500", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `500` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAU24lsNJ3swh4G3JLpKPwroDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxODIzMjgwLWYyMTgtNGM3OS04NjYzLTY3MzVlMjM5M2JkOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM5Y2FmMDktMjM0\nNi00ZTg2LWIyM2MtYWIyOWEwZDFhMjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0f1dySOc3tI0xMyx/R06ty1HlUvpiYQLKYEOG+iRCuahsOcEBDO3lqOf1Ccs\n8FNmVygJoS8PZWzUU7NAL4Bz1KOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUai5P5HRA+Kb75qWC04xYZJGoiWowHwYDVR0j\nBBgwFoAUqrBgQYPM9kytLAivzlSKOzr9pzEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiB2F1I3\nFE/8ueV0ANeYdsxIF0prHhySijPCkUfW9I/pcgIhAI4iitoj+0WQ5e+vGxSXE5OW\nxPW0zAU27C0Vo+x/g/Xj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASdGc/Cn31wqrR4fZYMhci2RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTgyMzI4MC1mMjE4LTRjNzktODY2My02NzM1ZTIzOTNiZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIVuwMkgnyk8GzgF7XjA564HS+QvVnI2oTpTyCGi5U113z\nsp5Zxn7yszPrkK7nFgIlbpYlTDC5JSlBqM2EoMmmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqrBgQYPM9kytLAivzlSKOzr9\npzEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNmIW5xOwurKGCh4bOYsZVVj6grX9apBkoFbyjWhnqU4CIQDysGD4dYQG\nqAfPzioDAjBfvBuGbB1eLoJdqGeg/9s3tQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAdP+Ulz2mijkPAL+natB2zsHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM5Y2FmMDktMjM0Ni00ZTg2LWIyM2MtYWIyOWEwZDFhMjRhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2I1ZjI1MmItNTk4MC00ODNiLThmYjYtOTYwNTEyYWQ3\nMTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm0aYPtxX3QrQPVoEHkLGgKTN\nh7qIyMdOkz7pGouC95xYf/iGlwgjQTPueBykP0nasdXe96v8+B7p/4tcxt3VyqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUai5P5HRA+Kb75qWC04xYZJGoiWowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFeZTAysAbpa69R7\nJgkgcjC9uolWJqJRGRUUR6MneItLAiA640WBXi9whPeuJYo/PozK1/+Pz/C64y/h\nKFEi2KqpSA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc501", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `501` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISATT//5tzruDGTDwN3AGqhhpnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmYzM5N2I3LWU0MTktNDY4Yi1iZGI0LTAwZTU5YmNjMjY4YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBjNTZlMTMtMDM3\nNy00M2JlLWFmNzYtMTg0ZDJkNzk2NTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDNMcRYWKUr50Qcv9fP7EQ/xw/AaaYm7IDXPD7YeguKWEtDmMbhwgkqa4XcMI\n0vlEP0nzNvS5p8GsjSVV2by/taOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+OvINZwVyYZwJG6/IbQ5wUNB3AgwHwYDVR0j\nBBgwFoAUtJEBR4AWS/m0Z3X5uBRENldma1MwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAx0Na\n4ox00zs08Te2gkDkAUZGMbOZCe1w49fFqDWD9dYCIFBbzdvvbw/Uztsiv4PFiSJ7\nLzNyHmKLy2sTpH0al7WZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQBDy6NtcpflcEXK86SazZGiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmMzOTdiNy1lNDE5LTQ2OGItYmRiNC0wMGU1OWJjYzI2OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASN01rEgpPyr+Yj5R93Ycs6HayrAR2WNgp95ncsNodC/sjL\ndoP8727ClXZe0HpL4T/5tZsiWoG+A6HKr6E26HKFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtJEBR4AWS/m0Z3X5uBRENldm\na1MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJOFNsGsTmC/wdvM0swP6OCmmO2KB1CUvw1pXAkF3w8SAiAyoPh3QPs0\npW4V+mNVd18Vkpub+BL7F17xLFbPDRmlPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYUlanOMHA3KyqguYErxa5XYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBjNTZlMTMtMDM3Ny00M2JlLWFmNzYtMTg0ZDJkNzk2NTQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGNkOGFlZDktNTdlNS00ZGE4LWFkYjEtMjA0NDY2YzY3\nYTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBe0nTFIlFhxpAqtd+z+q15dX\nIvNsxlo/HeykDj0v4B/FihtLJqBsKtZe2hrWtUzkWxYwQwnMRB/KNcAKhJH366Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+OvINZwVyYZwJG6/IbQ5wUNB3AgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDjvZNg6Ufro2i7c\n5hM/PSYyzvIy0Ok4nkS0QidpquzCAiAB9UkkEscNwcjWbu+rew/vUx1dMqzL+KnP\nqgJYLZZXZw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc502", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `502` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAXcpl4MqdN3vr5AYH3QKXOYTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyMGE1Zjk4LWJmODMtNDM3OS1iODdlLWQxYTVlZjVlMDQxYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVlZGE2ZWQtMmI0\nOS00NGU1LWJmMGUtYWEzYTVhMDQzNjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgupHkKDclWlZIevOvt6WwZaIwWqUL5+XwVK+wYZuSfLtfaD7egioa/NFoZDm\ngET0Gul1chll9DE4DVmm+YQfG6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIGFeTstGQ9oW92JraEpeTZQFqHuMB8GA1UdIwQY\nMBaAFJH3I1/g8kldl7ThSdvOv7lSpmnmMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA0tugSOVwtW3+PfjmQGnjbg7Mtwcue9wB\n2cZQFhfwWrYCIQDuhNbR57Jrf0E/saufmm3oGI7TyJNFTZPSVxt8Sxcmvg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd6P/sPkyoQp4/EJMkMNciCrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjBhNWY5OC1iZjgzLTQzNzktYjg3ZS1kMWE1ZWY1ZTA0MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpzTEmIpKRjusZEnf3GtDZ+DJQCCNpGl5TVkujmUZIakwF\nNjyQkNUaAUFUYdzgcaE+8VUdQXpvjNKJ8pykux1Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkfcjX+DySV2XtOFJ286/uVKm\naeYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ4Eu6oK6FIA7UuM5VQ7mcN2QY0KJq+RR8/nxpwTGTUECIF4Ild/NpmnE\n2nXO5kZ1B8PRoo8Qjeb0qGHVaGw6zPDS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASGU5pLgmMe63ueXK3vvVpaAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVlZGE2ZWQtMmI0OS00NGU1LWJmMGUtYWEzYTVhMDQzNjQ5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzM3YWE1NDItNDFhNi00ZTc2LThiZTctNmJlNzJhYWM2\nZGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEF4tfPF6PkeXTrNFb1Jj7qa1E\nUXbO/QQwy0hq4/YE/OUVFJlUA9NbdKhex6WUh7hafxaMd6aEsD5JVnqYaH0gF6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgYV5Oy0ZD2hb3YmtoSl5NlAWoe4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC3hXETZxzOckRD\nXP7E9klUVh5mIyA8R9wDSHhLlHUS4gIgOYDkYiEimyeKcTk9Dj6sMW/ycu+3d9vh\ntUTk5E6Fz6Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc503", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `503` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAaqnn2GdY4heKS0ORTroWN1NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwMTI5ZmI1LTgyMjgtNDI1Mi04ZGQ5LTY5NmNmZDUzYTYyODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRhM2E0ZDAtZDdk\nMi00Njk4LWIzMWYtYTcxY2IzYzYxNDFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ/KLARhqiGCy+Pr/iELQ886VWJi3r9azaMxkffYArXFsz7EC215TouZSXIiz\nuYJyTH6lV+ccG0YOr5Bb38MJ/KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtMRnbbOj4PGMT/QcTaJNtpKjjsgwHwYDVR0j\nBBgwFoAUgEQx7jw1Qfhhsfx0buxMSxREaDIwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgNPH/ziRH7CVV\nEjKseEZe5LvTWSysFjzGnWX/R5V22PoCIFSzt2bTHx+KDghmt0S83QVhpvgTVUe+\n7DBv5hbk7ACA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARAe9NBFOZTL26k1PEub1GW3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDEyOWZiNS04MjI4LTQyNTItOGRkOS02OTZjZmQ1M2E2MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvNNHGjzO2DaoOjOR6H5z/7smVvSBCpcSGGQv4STJSr00D\nsuAkgzanOW/cO0WdWD9r3UlOdNGEnWWVUnubViyMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgEQx7jw1Qfhhsfx0buxMSxRE\naDIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTwGU389ZDBJyR28xdWsTJ5VtTH7/FP0snE8wEueBsWECIF8MY9iluylj\n7H6uC/JwpcMUA/ksynCWEUe+/VqwkC+e\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYw7vH3KbaArNjuADhrdv6MGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRhM2E0ZDAtZDdkMi00Njk4LWIzMWYtYTcxY2IzYzYxNDFmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzdiYTI1M2EtMGM2Zi00Y2VmLWJlZjgtODM1YTE2NDFk\nYTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJqBIEFnke8xWaIINZkYPBWA8\ncj8zCm13qI94CjICkUf/4KmI8YGg5CcM2dxsKE21t20aZsvkl/KiDjxTY0IysKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtMRnbbOj4PGMT/QcTaJNtpKjjsgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDWCJuO6Mo2ODz0l\nCGoE9JSsTewMESQVwMYnz2Iu5rSQAiEA0N8WnFVMUMmZ5O8WG4NMZ8yoVZgdoX41\nHQx6Ewp8jXE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc504", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `504` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARnBeD7Vjs80BQyWFMk0MTtAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NmVmNGQ2LWRiNTUtNGZmNS04ZDgwLTQ2ZjcyMTViMGZkNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTVhNmQ5YmMtNmY4\nMi00NGNiLWE2M2EtODViMmQzM2Q1NDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnXHjy6Nv3oQLYcb7aBC0y1ge8nSO7Op7QswmPYAkSMmvfXmJ615ZXlGAz6pa\n9HaEOBars8BKNHQ3fX4WADMTHaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwT099+7J1gbhp2SdgPKafucflJUwHwYDVR0j\nBBgwFoAUdW01TKNG6sMD6FNftGb+VtCh0y0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgQJEir8CXZ3gC\nJmydBnvG/t177n/PgtixZmCBe4nOA5QCIQCiiPRITDUrlizq8CkfAoenkzCdiUCP\nAYf0pxNiGFOPtQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ7F+5dMju/d0IGIATtNyUIdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTZlZjRkNi1kYjU1LTRmZjUtOGQ4MC00NmY3MjE1YjBmZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2jbyM/KjrwWw3dH0gh5ufj0Vl0pApiW9bd7C58N1DA83N\nkKoLvLaR134vAdT/fiAqS1UMjds4+yGdANvXAGMSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdW01TKNG6sMD6FNftGb+VtCh\n0y0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJChNC83Q3DCMmo7pe+gTSf1IEmvcnLEwICgaVF61zH3AiBwly/9CsGZ\ndRGMzdjZVXKubEXJjJwJlshzLiW5SPIR6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYtS/O5AsLxhn2HgYWtDPWS6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTVhNmQ5YmMtNmY4Mi00NGNiLWE2M2EtODViMmQzM2Q1NDE1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmNjMTc0ZjYtOTE2ZS00NjlkLTlmYTEtZjRiZjBlNmEz\nNzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ3gek7g8hdi1dZ7teZpWvz2x\nJ66f4bNY6IXEtCXhPV3F7UlQCX8Vt1PrBQV8eYIeL7orGddKDuiRKLqAvY5MIaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwT099+7J1gbhp2SdgPKafucflJUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCID2JSRFMfSGkeLL/\nYsxe9jXSc9qMRKE/5ONaxlHOez5lAiEA8j+7aWFoKon6x0M408+xBmC/sghVgE1n\nsp9xqwwKiqk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc505", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `505` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWx3mIDe4L9/w4AEOh7rgc6CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3NDM5OTI2LTI3ZjUtNDg4ZC04NzQxLTRlZTBlMTIwNWI1OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUwZTYyNjQtNzFj\nNi00MGUwLWI3MWItYjhkOTcwY2IyOTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo87X+hy2LNQdi5hNClE922QoULCUJYT0963TIoHqIKOyWaW4o0aGeB+FYUF8\n0+PrQZ5OtiTrU/FPZjexPV6BO6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiZizGCMz4sJTCO01217XonQnDhYwHwYDVR0j\nBBgwFoAU4emkkxEuZgMkb9Jvhsq3+Biw/GkwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA2QSrEtFox7\nEVNsfZKlWuP8iXWxA9KksmBo4QJAdEWdAiEAz2/IrzWTHczpU+/G0SABIkBJSVXb\nZpUGogabYglK9EE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVtnTQ+kwzt6xAAQTVxRDFt2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzQzOTkyNi0yN2Y1LTQ4OGQtODc0MS00ZWUwZTEyMDViNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoES92gBAFz35uE/awZgCHF+WaFaQv4VUjEDBbdE38cNhq\nh7ts7cJSvS/IyonPqP//PC9BqsHSxsQ6UXidP3h0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4emkkxEuZgMkb9Jvhsq3+Biw\n/GkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaNpUDAAltei+yCkoaRIYI6wg6SeR48oPtrow/bvOEDkCIQDkm61ZsKqS\nG7L8G4UtWpL/eYocLcYifEuzZKB06exBmw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfXWcsSZITS6VCY4gbW5jT2IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUwZTYyNjQtNzFjNi00MGUwLWI3MWItYjhkOTcwY2IyOTMzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGJiNjdkYjgtZDZkYy00NjBlLThhZTMtODUxZGU4YjEy\nOWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvZKazNh5elyJMqZdUC6rYx7v\nvy5IrVNsjT84NI+7ITa/LzZj+i6ecp6+1uRluvPegf3hKBNSjCF14GbC+VgxyqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiZizGCMz4sJTCO01217XonQnDhYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDKybA0IqissT2G+\nbYEs0oU06HYzjSapBONcIAcrjCBWAiEA1dDd/+8MzGVMFtEQzPgZJUERGxgIDBuH\nldlkReYPoc8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc506", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `506` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWiBGn1xAliOpjhWeOb3qQpmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxOTVhMjkwLWQ2N2QtNDE5Yy04NTE0LTRhNDczNjQ4NDY2YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNiNmEyZTktYTA2\nMy00ODQxLTliYTEtYTEwZTg3OGQ2NTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL0aqQEdMqqKl8duJj35piXQPaS2VSvmbEkHdI/5f/AU1312IN67D3XAiWkfX\nUjGWVtx6NqpGvaVS74jVspPmUqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+CHDePQHh/I/HwfDuUVS+WLqT2UwHwYDVR0j\nBBgwFoAULRZEHtenUO3nK4dpwgLEEUvIaE8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIExFere/wf7EZQSS8T2NR6cMMWl4rcadKca9lNfclV4LAiEA9weoHupyBn2W\ndHhpZm32MJfhyjmimsSOOM8YuGR6QCw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdaWBELvCKRPRDLAN8VD0tamMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTk1YTI5MC1kNjdkLTQxOWMtODUxNC00YTQ3MzY0ODQ2NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmhvVTDB70bSdWf+TJYIax/sFxE/4Vbityg9rU54MV9yTw\naaB54SPUSIEkMY7AE2PL7jBzH6qgv+im1K2DgKlyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULRZEHtenUO3nK4dpwgLEEUvI\naE8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbbP5JT1KCVkcH8IMImq62RkyBnT683HWg8+S+5bVEUYCIQCAiOeTK6wD\nRJrVzHzv1ELNp92aqbW/p3rfVkVvzaU8Cg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISARvr0HMPfYHXbcmaczVwZspEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNiNmEyZTktYTA2My00ODQxLTliYTEtYTEwZTg3OGQ2NTgzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2NmZmM4N2EtZDI2ZC00M2E0LTkxNWMtMjFhMTUwNDQy\nZWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2CuJ3BFRVhiuM4hOAIJG1el8\nSGTBvaaR8UKgIfEcFNHBTuXTGP7ahd+BjXtLPsdJCj0ApMPhux+47XzsspriR6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+CHDePQHh/I/HwfDuUVS+WLqT2UwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDnPQ2c/BFZKc+z\nfJTRY0URsFouRZzr7cYXLF2bccAe7wIgbVC4vx4iJ20jdJslio0x/cfnmRt+h41T\nYu2Hc5l4mlc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc507", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `507` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAY5ISwz7m7k/fUZs44nEJqFVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZmY2MTFiLTlkOWQtNGU2MS05M2E3LTk4NWFmNTRjNWFmMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYyOTI5ZDAtODgx\nNC00OWY4LTlkYWUtNDExMGNjMzZhOWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjuDFpkENYvfqxbLEcoF+hWANF4jusQQgRSSsYAcrddkLGwJmD4CKrCp2pMdM\n7UNBMN/pgPBDTZCz5J/ctMv6JqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoVofjOWHhhimawDgZr/D13Nt76MwHwYDVR0j\nBBgwFoAUHyUMLhpikzxM57Y3V+vTRVQ1sPswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAxmU7jeoXzqwZpg7+asZXfAGiPmWAV4w0WZLznkUSjbAiEA+d4V2yX0PI4i\nL3uP1hoMqDMy6moGkCMyaut6d6WWoMc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZGPpNcRbDskiOhPNBbczeR0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmZmNjExYi05ZDlkLTRlNjEtOTNhNy05ODVhZjU0YzVhZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiyscM96/2QJ/tlyBIu1+XbEPOzEpd4HXfwuKyJhPbIrZE\nFEpn7j3ZHDODGRGpUBT/iNFiVP3Q+pPeX7RJkTcBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHyUMLhpikzxM57Y3V+vTRVQ1\nsPswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOvZPqZA5C57Q4fbd3Ij2nD1H//aus1bMBV349yub9+wCIQC8PWx5gL3e\nrzazgMGOCWw39R6ZGxPKHTMYrFSa5Jaajg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISASaF+Zpotmo5AF2MStBshLqnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYyOTI5ZDAtODgxNC00OWY4LTlkYWUtNDExMGNjMzZhOWFlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2UxNzMwNTMtZTEwMC00OTQ0LTlmYjYtNGQwNTQyMzg1\nZDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhlhB+9Dl3dTWj+5z/vtDKmOU\nkUON+GywFiFFrUZtCo6zlz3/r9ek2ElE7oDFl7fBlCgBiCd3zyHJFbbtHVG6nqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoVofjOWHhhimawDgZr/D13Nt76MwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDu3C4peGHjBtvW\nz91o/fXXjQIOO/SwrcnlkuNp1WqOCgIhAN1ObJ+KDiQsxedVLYEM2jVacxpqHqua\nUCM0M7VGkytg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc508", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `508` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAYz+AGq1m4NWHNQr9tehO4ZDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NzVlZWUwLWQwMDItNDM3MS05ZDc3LTU2MzIwNjA0ZmQ0MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQxOWZmNzMtYmVm\nMC00OGY0LTg3YjEtMWQ5YTUxYmUzMWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+Ie7baWAzFZ+hkf83wE0TX+qqpJPicp6Xsz6J92QN8k6CRyW/8tsWpufvxoc\nh/YIyAGvHNAWYfFesCkQJlT0baOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrLXO/no4BocJKU7OAoz+h5f9CYowHwYDVR0j\nBBgwFoAULTXEduqVqejMwIbEyHHhIj6qQ90wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCC\nx4shuGv3GRfvHg69TtcWnUTRQ7qVgTYeAzbOoeOaIAIhAId8r+XcIKukeZn9yiqI\nOSYN4ifqpQ5/cpev3AkUAReR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY+F8Kp2brhr0/9uqg8hKS7rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDc1ZWVlMC1kMDAyLTQzNzEtOWQ3Ny01NjMyMDYwNGZkNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8ukHY+UFjYSXr0pIlyW/IiZj8zmB+1Sd33cyYKwrayusF\njZnTr1ZxFTTNNBp+p0hfSsqVzUJRgceLRlRpxS5so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULTXEduqVqejMwIbEyHHhIj6q\nQ90wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMrke9zOdsd4O5Miu0OKgrPXH4XeSFpixvf9imaK8HLZAiB9QMyyv39+\n9IkwC00x4aVZrM8+OC4QKf8YzrlzEP4LAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAWklhIExhfWdvFwowsB+akeSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQxOWZmNzMtYmVmMC00OGY0LTg3YjEtMWQ5YTUxYmUzMWYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjJiNzVlNDMtY2UyZi00MGRkLWIwZDktYTk4YWJjMjlm\nN2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgUhNc7CficM5fkht9rkOkAZj\nfmzZRSkm1zkA6k5GjqmLShEsT1Jp0G/JagkoHh4RUX18N9j5UdvgzjZjzx8abqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrLXO/no4BocJKU7OAoz+h5f9CYowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDAnpSe4JOrixko\n6fRdV3hXxT+YZtIptJWrvm+W9mGDSAIhAP29VRp1SADw2H6oJU0maY+nK9FUzW3W\nC7SzjBPRcLye\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc509", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `509` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAVjTZiHrqJmfTpxqD6cY8TciMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzZjM4YTNhLWY5ZTctNDQ4Zi1hMWQ5LTg4NDdiNjUzMzBjMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM5MDBjZjItNDE5\nNi00YjBiLWIwMGMtOTM5ZWE2OWYzODk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPJg0gQVxTCNU5GdJewpxmq+CSmNADxJQ2XzM2VlfJQAeJxS063wov3plLl0x\noFHGB6/6Ej4SkZRf0EAqqdJN3aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUumoBNGLuebmZW+w0JPCF/ZxlNWMwHwYDVR0j\nBBgwFoAU7YhAZypSDhNDDRhtaueATO76v5owOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCDjiU1Z/VfiNYfIJlp2nNwBPtTQYu/lMjXZ304RFsqTwIhAL+6\nd9JJDtYdddBYhzFNVjvkatGCs1B9Q7Ag/JhTHf1m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVBPPjUoxAg9RlPxkKiYvVwEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nM2YzOGEzYS1mOWU3LTQ0OGYtYTFkOS04ODQ3YjY1MzMwYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATe9sZot3S6JyhjonDc9OMpUzYpV5rRg3QbOnHCHzpxYAd3\nlKdRqkuxo/gwwIe9UUqy/aVOW/NGL/T0trlMGpbjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7YhAZypSDhNDDRhtaueATO76\nv5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH6yhQpn1V0z6yOZhsuLck16DpjBvCF7yQbqPMrYMc5QCIQCXig8S/glO\nkeiV1UBW8Uhr8RelQOOe2XFaCxdRXOQuBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVp+LQvrTUeE6k8Mqey44y3xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM5MDBjZjItNDE5Ni00YjBiLWIwMGMtOTM5ZWE2OWYzODk2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDYxN2NhZjAtOWM0Ni00ZTMzLThjYzItZGZlMTQwMDcw\nNzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmCrTimrhmjW0ofMH28yLb1x8\nQqPZQ4zdZw0LQoHpSh1RIXN3w0eENHvfNsfAmj6XCQHARhZ7k1BlUz0KJI5Op6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUumoBNGLuebmZW+w0JPCF/ZxlNWMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC7cgetAyVg/GfO\nn8ZYj/rl9I8GT6xVQL9MiM4c1+lZVQIgKk+S3tNAXzdaGws9sH+7kUThk0EDqeLB\nk436Rf5vpl8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc510", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `510` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAQkfySeBH+eWq0psyPOBbXFzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkOTNmMGQxLTRkOWItNGQ5Ny1iYzJmLWRlZGEwZDRiNzljMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmViZjQ5YTItZDEw\nMS00ODM4LTkyN2UtOTIyZTNmZTQyYTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzAsaGx3vtKW/dL36EysCFluiKBDDJUsXMfxAVSeIa0XrvL6z8K+3oeNRVhOr\nrWlm1WdO5tGe/lH+j/gxOvV8VKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNdCCC/vO0J2dqWF47XYDSxg0C84wHwYDVR0j\nBBgwFoAU2QYdFGGlyCqfaIHbxRHC1uR/ZqUwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQD1lcR74xQxB+QinIqkNbPqx2BNdrF20mRg6HhArtX5IgIhANCu\n+/ciBfFMZHt593Rhzgv3+mXaDrUJ2MbDLEYs6Y10\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW1yfHGy3mSJiyHNZRBFo57vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDkzZjBkMS00ZDliLTRkOTctYmMyZi1kZWRhMGQ0Yjc5YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARE5MsEDTgRfsSgSBDy3yglY8LDK00MOlYwm5R1pyQat58I\nq+mXMfojQHWFA2AYRobdK4D5RygaP+NXkVtgJ1+eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2QYdFGGlyCqfaIHbxRHC1uR/\nZqUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPbQcHdLKq1n0Xmb5Q1sMq1CSskbkrAPqPfwDxAstMG3AiEA83LjVX+c\nULxOSHbF93jAuo+MD1pYAk3pD3Lo4LbM5ik=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXUNl5iA5vDBloxAKyWwTt8pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmViZjQ5YTItZDEwMS00ODM4LTkyN2UtOTIyZTNmZTQyYTU5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDUyNjA4MzctOTI4YS00MjVkLWEwYjMtNTExMjZkOTZh\nMmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETiibwYfu3pX62IGZ/sgfxRKj\nLy0oHR26ZUymEFutLA4gbpPHV/zGGkb+Y+ceOQ68h6XdLstaNQJ/04qtrCJwHaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNdCCC/vO0J2dqWF47XYDSxg0C84wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCO7fJxq8vOqG+M\nN9q2/OxAH0KQQIf6C4P8rF+tOvVIjgIgBsQ2CIgfyobWkY1QLvuAtsXIkvoFY6sv\nt3IWg1SkQiI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc511", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `511` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdc4yuFZLt2EVaYvqV5js7wMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0N2QyODMwLWNlODEtNGNhMy04NWNkLWMwNTRiNGFhZmNiMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVjY2RkZjctNGQz\nZS00MGUzLTk0NTctZTM3OWFmMGQ1MDc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOb7tAOrnmNk7MU18FSUxCkS2rKAVNSjau0MHzwU1QwhMe6rtcHKhV++oZgdk\nquEI8CqMzereG9usoFslT/1zUKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDZ96wTQCSHixCx08+nSJtsZQCPPMB8GA1UdIwQY\nMBaAFK8y7HWgrt5mHOcBRkMmOQOhVTsZMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBRGe3D4/nNzXuY/liiVZwoZ69AxWFjKP7E\njK/RTWeZEQIhAJiQt8xo/qHxZZI+cUOo4ohH5g+j7QsQQy2VisUdJ9vB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXRDd/VOuu07mZ5sEkio6zeiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDdkMjgzMC1jZTgxLTRjYTMtODVjZC1jMDU0YjRhYWZjYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzHe4oNidJpJVxxz9TvWyf3eSPhFtBdrfARAxcHT2n8GiO\nEGvu3MDVzZVbGlocglVFO2aaDToplpAkaT3wUwhXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrzLsdaCu3mYc5wFGQyY5A6FV\nOxkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI5QG+X0DTI7H/ROBYpYbJ6XFfhDxuDcyod22r4BkKQ/AiAUbNfJYjHA\npgKTaLpLJMjLpfCiN0LV1ehXLDZB6gjakg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAahIWA7XykwRvBpb0ofNlQ8sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVjY2RkZjctNGQzZS00MGUzLTk0NTctZTM3OWFmMGQ1MDc1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjNiOWIyNTUtMDJlNy00OTMyLWI5NzItYjFkMmU2Zjhm\nYzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVLm1TNHPclXu43iRjbSfQZTg\nmuhCuK0sSFDcI5Ftvs+zJvUrNcuCv/b0Far+RU95/jUOu2irnFUn/4CqgoLnRaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNn3rBNAJIeLELHTz6dIm2xlAI88wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHi6ZwqDuOc8StFd\ndU6sW6haif3feljDBFPfiJCljhtaAiA547nmEBlH7M+eCeD8IRy+U5qzwlIxuCgd\nYAe6aNuauA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc512", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `512` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAWTw2XSa6jb26sfzQ2AcFVkQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExMWRiYmY2LWVhYTItNGJhYy04YjkwLTMzMzVkOTYwY2ZmZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUxMmI4ZDctZmRh\nMi00OTI0LTk3MzUtNDI3YmM1NTVjODJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF5YMFLZD/RJ5Xg+CCiHhott01zdNISmIksY09n76QcTFj2NOUcDV+fFEm5lm\nB0RGKD/KylWxYLhvay0wtEe9c6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIv78kLLpEYTVEO73puPHz1fmQ48wHwYDVR0j\nBBgwFoAU6mulHFObjTe0T9j7Pumht2L8hM4wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJUMBC5j7g3h\neWR4Co+A0AtHekoi+ExopT7n6ZlkPl9OAiEApbt5Xg/xc22vNbt8Dm0riS+fxIRV\nmYruDD6XXZpoXhs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXjF1yIbY5gVJFABOH3aVaypMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTFkYmJmNi1lYWEyLTRiYWMtOGI5MC0zMzM1ZDk2MGNmZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARA08uMjojuJj6Ajm1mXc/gnaovlVJmaiDvqGwWY4MK8bU6\na1aWs2APa4px1krDNAOwcIaRIMV1XDqyQsgYaLR/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6mulHFObjTe0T9j7Pumht2L8\nhM4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJtQFNqUGFQytqY82pJFxweSiyf5+q7Bner1bM99YQ+aAiAIuEQVXo5U\n+N/UKb4rwQw447sfehF+DFdYf8uDNwDHyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAe9RjUEhMDSlFS4ZwjoDzbW/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUxMmI4ZDctZmRhMi00OTI0LTk3MzUtNDI3YmM1NTVjODJhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzgwNThmMTMtNDVhNC00NmZhLWE0N2ItMTYwYTE3YTMw\nZmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyv6j3w80SHrYFHAxuctT2IO3\n0abF663A0FlS9muWFYfuScPmmz8yMFSLQKVUBAq8TYmMHTuHQVLqq/K3a+RWjKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIv78kLLpEYTVEO73puPHz1fmQ48wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDR+FZCh5qU38o9\n8xR2IK+PkGuaCUsAGeTk2qoRGaDiPQIhAKmO098nFHu/WtSvSm1oo6TtT+mVt7BS\nxOB+X4BogLFg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc513", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `513` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAVdL22Tl04du8G2KavurUCxMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2ZTNiMDU5LTNiZTQtNDlmYi05N2NkLTUyNmFmMWM1NmQ3ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzcxNGY0ZTQtZjY4\nMy00Y2E4LTk4OGItYTUwYjY0NDcwNTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0K2ZxkOVE1yaBazXVaThrh7HiQiavtUWyt2W69VU7L7sIgSV3IU/uzLR3f/+\nhlr9kBXXJgPOBAJxRQcqlMWQH6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNAcfmQSnwcrBEn8OZYNJBj0A7NEwHwYDVR0j\nBBgwFoAUxwHufvTI6aDQopoLnnlUumXbj+swKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMDH1kmbzp6H\nHeujV8iPR3EvRnW5KmkuH4XzEJ9qToroAiEA6NLZm9a/mMAPjTXQnN7KJ9QzhuCN\npQlUQUF7uRZEn2M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU69hXhewWCbWnHBl6/VFSYUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmUzYjA1OS0zYmU0LTQ5ZmItOTdjZC01MjZhZjFjNTZkN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9zvQBbPjf6SBbijdno82tZgrXGYVPug3v6f+j2cOOLb56\nyVcG72CEGesSDD0XLIJAOw6KsLexrzDN/g/esOLyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxwHufvTI6aDQopoLnnlUumXb\nj+swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgd7pXVDMe/hHmsmAsgZ+IzQJFJxkBoUUKG3ki8YVSWsACIQCCskQIf5Yk\n2/RDgez5andNSTYziq39Tj19W1AOdvGsMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAY0AijTVFEhBFBJEMrCE2kCDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzcxNGY0ZTQtZjY4My00Y2E4LTk4OGItYTUwYjY0NDcwNTY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmVhZGViMWQtOTg4Zi00ZmFjLTg4MTQtYzE4ZmRlNDVj\nNjBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiKvRq1tRdcRAnmB3M6xuEMLy\nRkH120l8pVJcF6526ZZs4z8Z8g8VkoBfWolbovNkRsdgLcwqc34Ta3wdWhiK9KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNAcfmQSnwcrBEn8OZYNJBj0A7NEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAktzPoL8OQYN9A6\niKzv4SE03G671Qj67XVgVhTHSrF6AiEA8HdOWZlZL6n1P98eeSlgz9yR2GHUe5k0\nAQOQ9WL5Vsc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc514", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `514` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAb9LCfXwcRshr/Om5nVC2zcPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiMzhiNjViLTNmZTAtNDQyZi1hYTg0LTZjNTdhMTllYzk2NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMzZmRkNWUtYmY5\nNS00MTA1LWE1MDAtYjNjODY5N2U1MWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+X47QyrS1QEdhEV7iHiztDbefkYEc8uU5fxUkHSH5g7bK+N/qzueuowklrU6\nxMS2tz7DsFdLDhHzVQ+glQHxcKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0AUOD+GDiaXrKFrAGFoYv9X20GcwHwYDVR0j\nBBgwFoAUVXuWZPs9gD6I2EDr9KBfenrAr24wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFeSoMp+1npC\nEtSr4bqbfx6cLa21KQREKD/NQjWYd38EAiBVAB9OFPlSJORG3glgZqqh3USnhZgw\nelYof3IIcCYfPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfQN47gQdawXSxJSi9FdNsx3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjM4YjY1Yi0zZmUwLTQ0MmYtYWE4NC02YzU3YTE5ZWM5NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBVA8kn3k/QvnwgqUnXnyhND8+U6jTvJ3QCz59EdJlOhnV\ni3QCrUdpXTU4LGJAEvehaBpYXRcCA2K+0dYrztilo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVXuWZPs9gD6I2EDr9KBfenrA\nr24wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBHRfDiyl0X81hhblT30/lKyJ+ccJrieA85phv2+DS/ACIE8ESayosrJp\nzAqzyxDfLU+9oJOE5DaeG//JA9FGa/yH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATk5d1A7zOPi4CkqjliyfbcXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMzZmRkNWUtYmY5NS00MTA1LWE1MDAtYjNjODY5N2U1MWEzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTEyMjAxMWYtZjNkMi00M2E0LTlhOTUtMTdiN2U5MmU1\nMGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcEFs8kOM4dM2jsjP2DWkjYCw\nGYG8Qys6B0hskmTcXXGOR5mxoNPEhsSiDrvbQo6gA9PzK3HD5Vmn9pWzFJwhPKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0AUOD+GDiaXrKFrAGFoYv9X20GcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDW0K81vbAg6Dlx\nyZ59zAmBUP3uaGAyiOacMMpQJVYVMQIgZqutQabGNRUnvLnBM3WgrcpH3xqgCAn3\nxCyrBvxVEQA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc515", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `515` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASxoqmudusXpnHA4ZNzfQuiSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhOGJkYWNkLWYzNDYtNDRlZS04MDdlLWQ2ZjllZmM4NDc4YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIwZWZkZjgtN2My\nYy00NThkLWIyNjgtN2E0MzI4YWFmMmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmRYzeyCj4BXdGehxpDHWMWcbzxDAbY0Uc5PrG1NbZ6K3F8+Cz4n1IBUpxWHF\nqF05dAxt19S41EeDAftKLrjND6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0WDhbHRNEZJbIrfAdg21sDP978EwHwYDVR0j\nBBgwFoAUfbFKAyABf9WYYL4Rzvt2oXmBKLkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICcSUjS2u6Gh4qlJJzj20ZkbXlT1qKjjamF9dRsvt46+AiAKhXk/8X3315s+\nD+HTeSg94wpTjHssoNUsasqtOyWXyw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaj9+S60hgFBdEVRx295YjX+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYThiZGFjZC1mMzQ2LTQ0ZWUtODA3ZS1kNmY5ZWZjODQ3OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEwmmenMEjx8Uo1oJNwKCPJuQK7JjIdfiS2Hbvgd2KY6i5\nb4g+3tGbsXKLNwjnAmDYjNQP8y0bU9SckMUS3Bfxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfbFKAyABf9WYYL4Rzvt2oXmB\nKLkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANxUz1DAGxKU0NOM8wKuvqTIJ4/dDk/VodJva8dTGMlRAiAxeU+fJjYZ\nbZN4XYo+XzbDFOS6Uyie1URVx39x7+Kv9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAVnjc76exl0nSs80dEhjlX9lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIwZWZkZjgtN2MyYy00NThkLWIyNjgtN2E0MzI4YWFmMmVhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2JkMDM0YmUtYjAwMy00NGNmLWE5MzQtZDkwMTIxMmI2\nZjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAED8/dL6lkXWIAS/mfCGFnZG8D\nFBR13qAu3ffs46kuWB+vMUiTz4QQq4RSfxYq7SbN/ORXi8uzCPJ1nqBoHNDsJKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0WDhbHRNEZJbIrfAdg21sDP978EwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDrHvMb9TzuFJN0\nyMx2PIAHodfsEKREA6f7go+Tx01GbgIhAP8cqaq1Bq7wSVQ7IssDgI5gAYsijIPb\nh5V+RbRMNl6Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc516", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `516` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAU38gsSlVY3vTV36ftJgmzJbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4ZDcwZjliLWMwMDUtNGFjZC05NzE5LTNiZGFjMWE1ZmQxZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRlN2MxNWUtMGFm\nMC00NjNjLWFiNDItY2UyODlkYjU5YzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5GbUyV7oQJNak0uBI7WU1H3oZfA9rUgbgDZT8DZYCvwx/tv1LNg+kBIBmyQu\nOm0ImIIc8oeOZtj3E0rQfBAIUaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh/mOWT+j+qLi+Xxng/18SG1iyv0wHwYDVR0j\nBBgwFoAUR3f60H/DlFcJjndGYQ/HJ4pyNYQwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHOnn5B01Y7+ntqfrCY2TFZaPq3Rx2swSSwoEk3UcnfAAiBDNeQC4XubUY/H\nrinHRi/dZiUPYAHDl4kRUcUq3fotPg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYyscSIxoNbiRBHQsbZMR/YxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGQ3MGY5Yi1jMDA1LTRhY2QtOTcxOS0zYmRhYzFhNWZkMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqT1oBfDSm+YbKpdTzz8JY1juohNXNV0MoDqMv0cLhBmmF\nkEoX+fMvLMC9WZwxsz6Wk4DvFFdqVs1l1oUKHDrTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR3f60H/DlFcJjndGYQ/HJ4py\nNYQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP12Caqzy2pPaweVWbS46nlk+VqA7mzUWjP2mDWZqZTsAiEAxOPG/GzM\nPVmBX3IS9/GmPRMKlzVpFwtmz4f0voPtyPI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAW4TuU0A+WQFGezTkGbQNi92MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRlN2MxNWUtMGFmMC00NjNjLWFiNDItY2UyODlkYjU5YzkxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODY4MmFkMWItYzc1Mi00MjI0LWJmNTMtMTIxYWVlYzY0\nMTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoFSjWMxoYhZQQ9CxbHhu2PVr\nBtCloghrwrAks0af8q2+qn9RePnE+dsSbomDTzgxtP2jwwbXXO0fUNQHt0Bm6KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh/mOWT+j+qLi+Xxng/18SG1iyv0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCwPw5FPu+Zj9nf\nNMh5vXeWrFIdiJ8m/kME7ls/sc25pgIgDUZJJQYUpCIDrzhU81+Jd7TBdUhhfNGo\nDrqzkReqqe0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc517", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `517` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAaAS1Bb3J8xkvDpYPceVK74qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyNGQxZGMwLTcxZDItNGQxNi1iNzMyLWQ3NThiNTdkMmVkNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJiY2U5ZWUtMTdm\nMi00MjI3LWE5NTYtYzNjMzkyZDRhYmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHffM1Qvo0bs8ySnTmzwfzshxaINqxfgXiksfasFfPpMvOWv1l3BdKtsR0oEM\nZhLbIkK5AonOU+QqP8352TylO6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXHThjrb27RgOvYoqDPvjqqAyVp0wHwYDVR0j\nBBgwFoAU7Q1bgPc18xB2pE1qw5TrFyz9iCowLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDSE\nCPu4AYM2S8GMLEvszodvw9av+NVzv35sia1WGTn4AiA0ya+8RlbPi29PKa6xRICg\n3xWSk7IvlMpgw/G8H4jIFg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV8L/viSYUAQ892AksT4qzm2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjRkMWRjMC03MWQyLTRkMTYtYjczMi1kNzU4YjU3ZDJlZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT06GkUfkaypb/PVm9LPAclYvrw8y6qTVetcBjqAynagGC/\nTRsy8PbBQTZBGw/HMnnOktDhwzETa8uqEaqnKMzjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Q1bgPc18xB2pE1qw5TrFyz9\niCowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGijHvCWPXFq/J8e/RxmPoWNp7O8wuOBM23OYNOiWeVMCIQCu72B+FPWD\nt71I8E7BmRExpIwfXkw0Y3Es6UVmbpIi0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQgmrCrYldLoVo8FCPZX98qeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJiY2U5ZWUtMTdmMi00MjI3LWE5NTYtYzNjMzkyZDRhYmFjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDIwOGFhNWQtNzMxNi00MzI2LThiMjEtYzQ3YTQyMTAy\nOTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESaIGuE6EyYA4CO04rLZWySGB\n+eeoZ/2+v7Gko1zQZh+akB59GGuLlJbwoeiGz1ZsxNLur5jPX2Xm54abb4+5waNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXHThjrb27RgOvYoqDPvjqqAyVp0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICOdRVp+JR415bqK\nCDh9VdiSlwQm6efGnoooA80L3x+VAiEAl86KnS52yW7fYUmz7AYD/R6mXlbzbTwL\nUAiSQ/P33pI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc518", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `518` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQ+qfgFioiPFCzyvYHSpaHySMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YzY5ZTNiLTkzN2MtNGFkNi05OTExLTEyNTZiM2I2OTE2ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M5NmQ5NjAtN2Jh\nMy00YTlmLWE3Y2ItOTU4ZGE5NThjZjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3oWjbvCcxNhJuUsklSG5070TmPlsCK/Rqh9ed9npF2A/qlfl3pspSAcJHJWp\ngtlUcqoMup4er+ZYJ4W5xRica6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUibDbvQcgvXJHgWjZxSEwF9Tmgq8wHwYDVR0j\nBBgwFoAUQCnlWgpj4NG7iuJkXHBr89dBiaswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFtGIr1Hu8oMns6zRLyN6k9NbIJCQ3Px1W48xA7/LDEoAiEAwqFL\nKqp1l8pwjvN9PxihXOJQvSmaPMWid27irnBtzO4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQWwm6XwH0FqNJxOmP4H3CTgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2M2OWUzYi05MzdjLTRhZDYtOTkxMS0xMjU2YjNiNjkxNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsz8wsNuFIm2r8lvFidbCNVWfhjI496IMMjzTtabXdzj57\nJuXOXuvJzPOuXzu5dX0++eaaB81xA07Q5PYJuMHmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQCnlWgpj4NG7iuJkXHBr89dB\niaswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANNAENRXCZHzg/MFFUg6yZaVBaI0lMPb3jQWVt0BckwwAiA2jmpzy8FZ\nSgukTBJSLaVihu7cGPzEik3NS0ggUkn2OA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAaHGUkY3rBf+Fdzc8yZUDCYJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M5NmQ5NjAtN2JhMy00YTlmLWE3Y2ItOTU4ZGE5NThjZjAyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTZiNDAxNjEtMGVhMy00ZmQ1LWJiMzQtZWEyNTI1MDZm\nNjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE11Mpfa+5LR2nG+KgxHUz/uW9\niHTASwD7O82hD0zvVjcaOiutitvnQ0UOnPtnayk/mMfpjnzVNkub8nfWxrXumaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUibDbvQcgvXJHgWjZxSEwF9Tmgq8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDFcko12u5CILii\niN++SYRhijKK2wd1Nu793MftG67HIwIhAOiq+G3WOSzMqs45fCAxiOLIBZh59beI\nWdy954PVkReO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc519", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `519` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAcEa49sTlgl/ydBtNCCaB1kPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYTlhNTE0LWQ4YTctNGY5ZS1iNGQ4LTZlODcxNGZmNmYyMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE3ZDA2OWItZGVi\nNi00ODE5LTg1NTItYjJmOWU5ZDczNWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMiJOxX1PtSRWtPFScXUCYBl3v8xm0PvPga6cganip23qqh2a0DWEdcYltcOd\n/P8LnvLQjxy4O1H7cKKozWXp46OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUct4HZSMwu2lS6+2zIwafE9URo08wHwYDVR0j\nBBgwFoAUZ2jEGyEUGAiCPYSm0eXEMJtijRAwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDOM7pF7uWLvydT8R42WDMeINgkQDSQxLog8zAPJEyitwIhAIZ6\nmAjPuAp2KuD0U1nrOyRv/yNmoEDzNWn0SbJ2s6+z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfeabXHQo6lfUyg7sGFO0+9kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWE5YTUxNC1kOGE3LTRmOWUtYjRkOC02ZTg3MTRmZjZmMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDkGPS0Q+6d2Lw1MDo6oZGtItgbita5N0Ej1JDwXh46kE0\negTgOJ6mAex7YQ+XfmvvhE373GAn2nTAsuLZgwgMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ2jEGyEUGAiCPYSm0eXEMJti\njRAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAInZnHlJe6Ui70RalpKYMiizKq8YNYjzONp+HZWkt5biAiEA2K/ZjG8u\n1zA3R2Aap6kNOzOhjqdXW7mIjNUmJrh0eK8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQGv59fOinhw1RoRXr+Lo5QlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE3ZDA2OWItZGViNi00ODE5LTg1NTItYjJmOWU5ZDczNWY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWY0OTcyYWEtOTM5Ni00ZGE1LTkyYjgtYzNjMzMzYzli\nNTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7FGIULKk66P0xQ+nBcrKv8XF\n6+a1cqWcIzkzqq3UQgBBcGQ3uU4cgf6HMTEGx2N4/4cvBbXTYbwXlYdH3swtWqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUct4HZSMwu2lS6+2zIwafE9URo08wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCbtt2qzljIejrn\ndShMNJJwQoTdBzkMkdgvfVdctCVETwIgEs+jWl00rv7DUqNfSN0YjeA3IBTQcKRy\nO0gn00b6g1Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc520", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `520` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISARXpKlouEZFI1vvLycx+R6DdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjNDViODgzLTFjYjItNDkwOC04ODAwLWUyNjBkYzMwMThhZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWI0ZTM1YWYtOWMy\nMy00NjM4LWIwOTctOGM0MjY4MmFjMzcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExNl7G3Z8gCyySc5WlcY0SwOFGBQX1ReSy2aog5TDe7IFnlZm9IN9xdDpIc5r\n019ASizd1mSiB0qwey0XxAQivaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRiT6t3CknwhgW7L324+9TVTRZ1pjAfBgNVHSME\nGDAWgBTTSCMKb/39YwuEJ+Ry+dYkd8I82DAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGr7TEdqdOSt0unoTdB3LWDG83k6I/4P\nzuxQrzD1lW4MAiEAoLHlMrZpVvhJClHQyoN6iLMZ/JfVI0YDekQWg5UM66w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdcPRyrA0woNeERZnQSC4dt8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzQ1Yjg4My0xY2IyLTQ5MDgtODgwMC1lMjYwZGMzMDE4YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYeVo9IwkyA6zpN8v4BW8Zbkc22AUZ0Mf4zWISvFvwCPIB\nJwmmQTvFd4Rv1eH2ceQ9zC+AXEik4MnFXiSA9m8oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU00gjCm/9/WMLhCfkcvnWJHfC\nPNgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANLCSsssVFKGjBGDkKCOkv0NxyNtIU3B3ozkmeMbuX2vAiEAmmHHYTHO\nlQtwWpjsN0V91zbMxzC0ActfEy5tP9MXM3c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAbQhOLVCYuASnpD5Fj1JHTFYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWI0ZTM1YWYtOWMyMy00NjM4LWIwOTctOGM0MjY4MmFjMzcyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDY0NjljOWEtODc3ZS00ODFiLTkwNWItYzM4NzFmMWY1\nMDgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0JmHEkTBvYHx+pNRuNQbO2VG\nDqRnuid2Z1TuPRl5Cpkbnjn4irJaFopqrhtv/utNNMm3h/EOzHK5vBwen+0UGqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYk+rdwpJ8IYFuy99uPvU1U0WdaYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCchKIhZ7tLpKEM\n1Bpo5KjioNgnDupmILn/WTWMCOn5NgIhAPm3JPXB/bAzsV3GGitlt5+3zenyI+8a\nb9DA9W0xOgFC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc521", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `521` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYj6Zw4q0dIsTgzMhxaN475WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkYWE5ZDk4LTMyNmQtNDI4OC05M2Y1LTNlNGM1MWI1NzFjMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI3MWEwOGYtMWRm\nOS00ZGQwLTkxNTYtMDBiZTk1ZDIxY2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUb0ZWmcPr2d5wyCJ5MQxzUYbUVLqIAgfyvxDOw8BeIw2ZkAyiypEgs1YHDTZ\nniqgYu/L5MRGMBLcvAdxHDKww6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1LgmyznWgulfCXwKRL9Ux0EsjMYwHwYDVR0j\nBBgwFoAU0OLQR9LZ7uadHeV+3tNFHrE9NWQwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIG6CYucY63Hw\nP0fQOXq/qpZSuHlCdepGbruwG/Efa5VOAiEAm8Tl/1I26bD/TuKc/Wc2dNs00Fwo\njMeKW7RdJwE07z8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfo8wcujOY/JmCgj5ZNO6eueMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGFhOWQ5OC0zMjZkLTQyODgtOTNmNS0zZTRjNTFiNTcxYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1+IovPKnvsHmFGFEqn+5f5W23XL/ypl4CZlf0VsjBTLO4\nehC04eRWNvhL5KwBdBHDTBlXtnIzpBT0oj6/Du0Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0OLQR9LZ7uadHeV+3tNFHrE9\nNWQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ7d9689/AlDJd5o1wy2AqnXHZzBCbn+d1BHRpvoKxZACIQCcByr1XyeK\nP726FjK/OfDc+Uj1t29PZbB3OW72Mw7KOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISARpjHi5GyyWN1ibTU0jbBnqbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI3MWEwOGYtMWRmOS00ZGQwLTkxNTYtMDBiZTk1ZDIxY2Q1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjYyODQyOGMtMmJhYS00ZjQ4LWE5MWMtOTg5NWM0NGVi\nNmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtmKtJq3Hd7jgVyBXYfuufCGu\nYUmJAvUD0yM/CVIfQ0PFySxiiVPIDhx5ZMmSZArcuo7lzZi506HPNNhyE139Q6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1LgmyznWgulfCXwKRL9Ux0EsjMYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAsCWt0vBeGjYCSs\nZpSfS9zCPPdhUBdR/xTq/w5eAi7BAiEAuie+DvU9DmSfHfbM5AsNXte8iAUhZ1He\n1qWu1LzQ09g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc522", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `522` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAT9ixzdGn0ekAAFGV5qyTZrFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjODE0MjIxLWM4ZGEtNGFiOC1hMjhmLTY4YmM4ODg5MzIxYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE5MTkwZTQtMDVl\nYS00MDRmLThlMTctM2I0M2E0N2M1NjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEclh6M07E3U4XFIyBD6iCukYGzpQP7zcg2eTTqvrfj6qFyWvOu/MoZqCiqhTf\nhgcDyEmvR7t0JHCf626tzCFjqKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGPSffiXOt7puYQ/h/ps5Dqf5mD8wHwYDVR0j\nBBgwFoAU/uzRF+cYfZlxlKatuSxvvOzViF4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCH2y7TTzjc\nOUCw7M2iQZvbDHUdW6RMxdEmkL43tLwyOQIgJCXmMY45+jg/Vhk808N15egmCDhd\nqFUpvqJhV54itNI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATw2MdLhlukrhZFH1jj23eihMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzgxNDIyMS1jOGRhLTRhYjgtYTI4Zi02OGJjODg4OTMyMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATD0y3xZkdJc7SIpxKHuUF1yTdGEcYRQdGjRfdpFYIMrcXU\ntrbKEHWXWNT+VJym8AgKhrHZVoNG8p5zveLt0EEYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/uzRF+cYfZlxlKatuSxvvOzV\niF4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANKILLdLE7dqP3pJFJX/53esctKjL1HbyjyPbDzXv0g6AiARHMlHc5oe\nnFhQ5CqqqSNj2Pz30ETz+lCBik5uX8TFdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAY3KbIGkFmDbaCalsa0Ro9ORMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE5MTkwZTQtMDVlYS00MDRmLThlMTctM2I0M2E0N2M1NjlmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjU1YTRlOTYtNjAyNC00OGFhLWFlMTEtYTMyZGJiYjk1\nNWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEruWDF0SVR/Me9iq5x6o11N0u\nwizlvcCRYnHjfrZltZDPDJKGG4bPK0Wm6ryGRJZRl1nYwvJHQgWV4KXSCEIlTaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGPSffiXOt7puYQ/h/ps5Dqf5mD8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCrqY8GQdvLpJAG\noowSWWll5HRx8b/eLlt4jAsH3UDMiwIhAL8upf6Zy8bNPBEbtMRFdiaRw6N2ihGV\neLrAVoEZY7NL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc523", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `523` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAbRZnDrAhxte3o7nl/0rQ6yMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMzMxOTdhLWNlOWQtNGIyOS05N2MwLWIwMDZjMmM5NDlmNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY2MWNhMGItMDVk\nYS00NTM2LTg2ZWYtNGFkMmIxYWNjMGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5MV9lq04uKInYuHuaj5QpJc7cDSCOZ9j45R87NRcLRrPY8DUB+mQdiV2m8Ob\nalFavlpuGGAV4n08sH5TVTmi+qOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFFCrOoszT6kWQNAUMbNpacOpyuIwHwYDVR0j\nBBgwFoAUeAzU/mKho+v1zA+fZMq9Bi0VQXAwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBAWJ1IYAXg\ncGrt98K5z4pcqUfn5zJ55sGMO2HFXyokuQIhAKDPRBf7CLKMWwYBwX+y93eYH2ah\n/3JoetqfiNtWqJsO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZzjCLMYajV99Pwrrw+sBqE2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTMzMTk3YS1jZTlkLTRiMjktOTdjMC1iMDA2YzJjOTQ5ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARs96q+hEXCBvuHKPg7KQl8WcdWpgKNwP+CMDI+55rEGsPN\nZH8ExDGwNeiQDH8Pk7ee26EyN9I4QyOh6di6yYd0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeAzU/mKho+v1zA+fZMq9Bi0V\nQXAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ1aVmCPo6uD51DR0mfOYzK19vaxy+wLR/rOWu0jk+dDAiEApwmPNxZM\nHW1jcJwC2/KJkFWGhcvHr0ctyJjPaNieX28=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYzPcYZk+3yroSWmxXFnFbsHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY2MWNhMGItMDVkYS00NTM2LTg2ZWYtNGFkMmIxYWNjMGRjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjI3MDgxY2MtNzQwZi00NzFlLWE4N2EtZTdhOTI4MzI1\nMmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELncgAmhcAHqtem7Q7DoKXRZO\nkxlo5Lzk0B0bu95qPJjRty+wsNDvat3JGUKsJR2U9N6haUtRThqdF2Qu2f67cKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFFCrOoszT6kWQNAUMbNpacOpyuIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG+naDgtFeJ61wNB\nR8Z+Zs0MjYGnVdFcr9vb8TeZVUHVAiEAmPppwxiJ00lJUYO3r8GQYx5Lmiyo7pqe\nWjt0uV1p9so=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc524", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `524` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZdWQQSsE/fGLIaDoYrIHnKhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhZmY4ZWQ1LThiYTctNGQwZS1hZjBjLTNmMjIzMjg5ZTIzMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRmZTdmNzMtYjBk\nYy00ODQ5LTk3OGEtMGVlOTE2NDhmZDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUUaopX/mO0ZMVR/6wcYdNbdTVBHij7KsCIFBC6WYHsreTG4+LI3qUwlSDSgi\nlLW9hmDoGBV9mrl6JlY7I7nvjKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk7cbizPoWJOT30lkIOInVHfuHRAwHwYDVR0j\nBBgwFoAUzrqP3nfguxKd4EoJJ/Uso6o3LQ0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA8mFkarckoQqGcJfrIPJuepPJvltD5+4L4yfvA959pRsCIF6F1e2d7DyZ\nthO0HnPXyTRrgN2kgIDiX7XW19Ats3Wv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdEre3Wrno2EgcPZ6275L6NBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWZmOGVkNS04YmE3LTRkMGUtYWYwYy0zZjIyMzI4OWUyMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHqaO2zdBedo6lPr8WJ0ICsdYk8fS05NWb4XDTgNnKZZD7\nxc1D6HZvB90darUIyWciHsd/vGHla00ApiJofaZvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzrqP3nfguxKd4EoJJ/Uso6o3\nLQ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT+qseCHT9MKp0QM9uhCq0PlnR2cG06ypP5ELXOFx8b8CIC9xlMH8LqBk\nquPgMZzLVSVn5QCb2eqYdspItPo+jCYZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAQVYxQ/C2nmuJx58e+KBsv8mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRmZTdmNzMtYjBkYy00ODQ5LTk3OGEtMGVlOTE2NDhmZDdjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Y4Mzg0NmQtYmZjZS00NzdmLWFlNGMtY2MxYjQ2ZDY3\nZjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiSxSAoANUuygOkDyDitD88iy\nJqxN3NkaUlv8H/2XmjX6gnFlqPvzrN3geMq8JOjH0vzapnJ7ommUjMVBORImrKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUk7cbizPoWJOT30lkIOInVHfuHRAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFePF9bmFIslQe97\nY0SAjZZayh3oszMsUp9lXNiZrBoXAiBoADGEiZ4jctD/vEYgdMb45l/YvIb1fxBy\nghJhSY0QMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc525", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `525` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAbsJy6IhFhxIw0RU35tkljGlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmYTY0ZGY2LTJlMjItNGQzOS1iMzQ1LTZkZmE0OGNjNzFhZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRjZGNjNDQtODVl\nYS00ZTM4LWEyZWQtODE2NWViNDdkMzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0zI8P3FtS7oqf4YizxkK9P6m/kiMDRp+nF0SYrGnn8mS8xGgSJxNxXiykpQ7\nwSg79o2CSfpLxn8roDztvq6/caOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTT2naqTRidshb3uus4U3Y3ioiScwHwYDVR0j\nBBgwFoAUISHdpRGAEuj+wx340BjR6SNHguYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAvk4CT114jBPP8eP7wiilJaIZuH+G4QNbVu+jLHRtJXQIgWBp0OhTwspQY\n/ul+njy/pucxn9D4J/n6RSHGk3DiGlE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW1ivEXHRsGzDhvCcG+UySHJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZmE2NGRmNi0yZTIyLTRkMzktYjM0NS02ZGZhNDhjYzcxYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUfv/dGaShg6I0aRJOLYxL3ghbGhpUroMTzRavR/UEYzk1\nCIZCG/Fyy+AvtudBUAK38zClzOkaHwQAFliRd+w8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUISHdpRGAEuj+wx340BjR6SNH\nguYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUSZm9TL4kj025b52I+I10CVvvfgxdS41v07HEVubGIgCICxredRlU8tf\nRthn9PVnT/41KG9nMMzNbC7xb5ErDVMB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASp1AT5QR1DPb7ITUYjlrIfUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRjZGNjNDQtODVlYS00ZTM4LWEyZWQtODE2NWViNDdkMzkwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFjZWRiODgtNmNmOS00NGVhLWJkZGUtYjNlM2E2ZjZh\nZjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsDy51xehLviibHd+DBk4OZWL\nj9rndJD9H08t4ppirV6tLhAnGYNPk+S6+LlZvgc9jLq/YD9lxUBSznPKSM8bv6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTT2naqTRidshb3uus4U3Y3ioiScwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBNOnMuiImxvD2rD\nVr910E08vriniJZnKzY2dWW0zqxcAiEA4sZCB6WQl34xXVZgiQ8B5T6EIMw+OCsf\n10Ym92rUrgs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc526", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `526` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAZY2XuAgve5Yx0tRpOAyIBBsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxYzRiYzRkLWJjZjYtNGMwYy04MTVjLTEzOGFmYzBhZGRkYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFlMTZkN2ItOWEz\nYi00MTZjLWJhMzEtNTc3ZmRmOGYyNjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEucedWAq+hEDdkrNDrY9+egtI7sEk0iuB7k0I8w5kXIxdS7ymOMHKbpKvzK9o\nhAAU0wj0NUtjncubyx3hDV+xs6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiqxwjWvPGKSazgYQU2HZ1kYhow0wHwYDVR0j\nBBgwFoAUNwWG6NFf80065XNLuUvjlRGCzX8wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\nm0eOhfDvx4apZbVCofPtJBWS2tGn4jNNCxzqnZc+qQgCIHjAeUnzSUbHVp8lnvPJ\n0hatPXsVXurDSw0qVWMxq3oj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaYV+W42YlszVSHTtK9zxm+2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWM0YmM0ZC1iY2Y2LTRjMGMtODE1Yy0xMzhhZmMwYWRkZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEje+u/2y5LwkosYm0+kBfnvesrtqyNWDisdj04OubOnfM\nSGy9X4Ck9X05L2HOFz31LSTyfDHX46lSSlr58XAVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNwWG6NFf80065XNLuUvjlRGC\nzX8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBt8OfW4hOgGv0cBUr+5E+QsfNoR0pBKUL+Qflm7cn8cCIDV7OuC7B9VP\noZmxfJZoDp7A63YEHGzF95Luuc22DHQP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfSA1mmF64zQZCha6kQt/3KSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFlMTZkN2ItOWEzYi00MTZjLWJhMzEtNTc3ZmRmOGYyNjg5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGVjMTdiZDktMDM3Zi00ZmMzLTliZTYtZjU4NmI4NWM3\nNzNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7CgetQp1NaqM/BoybjzopmtN\nye+ZmBUiSIxNXXDoy5iF7RLEeU4ms+EczUsKfGgwORjllE72upxhWiHW2qteG6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiqxwjWvPGKSazgYQU2HZ1kYhow0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDK2KPb6r56Di12W\nQAVyvRzkrXs4i1Llkbj9Ay6oWeVbAiEA0ekC7aPVV6JkYdBEes9UDMqSWzUNTGfh\nRKo0NZFXq4A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc527", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `527` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYM1Kp465B1mbLZk0/aIOBlaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MjM0YTEzLTQ0ZTgtNDFkMi04NTcyLWQyNGI1MWZlZTdjYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY2NGZjMjAtY2I2\nOC00ZjVkLWI1MWMtYTcyZjNkYzg0NGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhQ+YkL/QHoxZFZfYDKAksOn307W2MRZOX8jNdnfmRTYLbGChytry8iWCNJu3\nrFn9+m26eeKAcRAMb2yXD8+DyKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/9bkGFDyxgmg+2PDH1vQEz6v3FcwHwYDVR0j\nBBgwFoAUb+8kCaK9EGhiLqR078LwLWUK4D8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAsoY56s5JDd5iR7TewM0A58IItAbLTWKtuSEUWgzdB70CIFr1\nEJsINms/iD2wAk0W7Njn8RUBiO6iY0i38Ggxb69I\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATOv352NoJhTOmKVPMk3JAsfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTIzNGExMy00NGU4LTQxZDItODU3Mi1kMjRiNTFmZWU3Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8BJG27k2OPLImL+NRi9/aKOywudWHQPTe915eMx0DKHJS\n+4IGiIqVmvIdLgXSBZeUwKlU0lreU5wp3GT50gxYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb+8kCaK9EGhiLqR078LwLWUK\n4D8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGBr/RtDiKRWGNsKeqMfVLHEv6+G0J3S62oJLR980od4CIQCdhRzcdyzW\nombKJbD8AojO94zSfVIEOy1yvUwuU7DoCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAR65otfQey4ul5/0C90DOVM9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY2NGZjMjAtY2I2OC00ZjVkLWI1MWMtYTcyZjNkYzg0NGVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjRlNDAyNmYtYmE3Ni00ZWIxLWE1ZDUtY2Y1MjNhYzJm\nN2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmFvTAqUaWUbrgQtc/AMY2+xF\nUP5QuF3PH6JFZ/kUGONdCF/Wd5J4Do0e5H7kglCNYbtxIIm88lhZNFc5H4hmQ6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/9bkGFDyxgmg+2PDH1vQEz6v3FcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCID7uxEj9lWGbqFCq\nfug55/KnnRduo9eCNuNzdkY7s7PHAiEAxV4JfOBeaJ4vXyXpb+wnoxIBGiIX7KVI\nloYlcs9/IKU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc528", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `528` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISARxWsyz9UZzTCXPu9YJ2vGWDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwN2YyNjlmLTFiMjItNGMyOS1hNDdmLWRjMjMyZTViOGJiZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM5YjdiOTctOTJi\nYy00ZmFlLTg5MTItYTQ4MGU0MTEwNWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf2e+V7UCktVCMxIDo7P/ojD/M9S4k0Q1XMhsvetbeGSuHt5G5gKpLvM8XryK\nTkFrsajNYaGdRndesl8Bnt67i6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE9cZfDtF9y/P/bWeAS90BEXlzfswHwYDVR0j\nBBgwFoAUNcA+dHSJ+/W1ECTMMf8V72pf94gwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiAhKuIlUGtCHeXpgY5zhS49k3+WihUbR6+TNT68LD/FgQIgeXIL\neDNBc8frc7s4cGv2LvRhR/ol1vwaVEm/9U7dgtg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWDZJKhpV6uedcqjlnMgZIICMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMDdmMjY5Zi0xYjIyLTRjMjktYTQ3Zi1kYzIzMmU1YjhiYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUmKg80xYEn0sNv0oZJzlMQnGrXK6l1PAAL5NXzFZmpk76\nlEPrIP7oSO1ZBTXLVpNcp0BPMgl50G0+iAedWBaeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNcA+dHSJ+/W1ECTMMf8V72pf\n94gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDef9RhfiBDdOyg4b5SNT7ERBZGVNFXunMtgyS1QVub8CIQC0p3tPUV1H\n7pWufmwRu/vgP2TGkCbDjXBhv2pjvr96ow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAeBU6g2cxr80iRHmVGgDNknpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM5YjdiOTctOTJiYy00ZmFlLTg5MTItYTQ4MGU0MTEwNWRhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDc5ZDRmNzAtNzIwZi00N2M3LTk1MWEtMzc1YTdkM2I3\nMDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErGDAilDoXBH45PYkrgTpSycZ\nIGxMDMttn5YkpAly0eBZMetG6KiM+8W0jwpzyENIAhnp/tLISagWlZ7noI3CqqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE9cZfDtF9y/P/bWeAS90BEXlzfswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDaheXod5aVz6II\n4Ho+Of0iHPAW0CXz9OjSi4EUvZ31UgIgFLR1oY6T7/T81PR+K/uOMXxu8C23FQCB\n088yFenKGww=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc529", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `529` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAfWcmo74noVT4bgP7xCtwqx0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwZjkwMzBkLTIyODAtNDVmZC04ZmI3LWQxOGRhYTRkMDgwMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY1YzkyZDYtZWM4\nYS00NDQ5LWFkY2EtYmZiMmRkYjEyODdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4kFJfVVWIopxDEWrWY/CJjQx3f2WCAUeVbySvIsCq/PtLZRo5ErXlIeg9YEl\nDVKLssIFEw+s2gKNNzKEJ9sOK6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8wen0xriWJCj8tdhAU+hBEe4UqgwHwYDVR0j\nBBgwFoAUfyQvri1j9uLnBWJZJoIHdUrOMr0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBFdO1uE8GSRUVo\nmp5K+kstuqiMoG4HAMHYA3qm07FnFwIgUamtf4jlKawpSA6GCksUBweckqYm6CDd\nXjaMsWwqbN8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVKOB/j8kYfL0k/GvW7E9ixoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMGY5MDMwZC0yMjgwLTQ1ZmQtOGZiNy1kMThkYWE0ZDA4MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvincrF+0OW3O6BhryF3aDMWtzGryevTui9P2bOC1DlUnv\nKUH/+4WPkj+bOxPhWSke67CaUEKh4iZOGVaYaJ/Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfyQvri1j9uLnBWJZJoIHdUrO\nMr0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXFp3jXt4cwBIlcP40k7N3Jr5zuMBw12BmxWJZoFqGQcCIA5j0sFE2cnj\n/dC9URjNqCksRlMe+MvnkzwNqndyp2xC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISASYUe1NBAZsPfw9rV7mQBrtQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY1YzkyZDYtZWM4YS00NDQ5LWFkY2EtYmZiMmRkYjEyODdiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmYwZTk4YjgtOTk0Yi00NTZjLWI5YmMtYTljYWNhMjBh\nNTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1ExuupAYtbSMQWIiVOukkkTQ\nshUu3QeSIGjyZ2rPoM4hCgyOSvLEtu8ooUt8J4TrTXVPLGqmCl5lV4hTA1a/h6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8wen0xriWJCj8tdhAU+hBEe4UqgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDcpfZhZZ3Nubg1\n+YXFHp3hgs9gkA0X3oLxXkIOoq26wwIhAJsYis6qq20BdG+59WPjVApKmu4+CEOE\nKEvn+9rPc9Uv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc530", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `530` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATWViefZwsn/mPN69+voyL/UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmNGE4MDM3LWIxNDUtNGQzMC05NWJmLTAwNjY5ZjZjYWFlMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYxNTE2MmUtNjQ1\nMC00ZjAyLTg2ZDQtMDRlOTZjYjY0MGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYJ579bK+82tQDoNfeb4XW0ePDEec5UcWaBpO6P0HymnO+8BOHCMGazFFA2kr\nWb5W5CNzkSlReYQeXCMFrm0HeKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUltmdJlRMMPBGpSFolVnD731rH1gwHwYDVR0j\nBBgwFoAUIACwHcHAnS/H/shu5oX3n7MTZkswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAWeUK6lXoXfhkCzvBy9cGCtJm4mKDj8ZSAm7GICkH3jAiEAuNT3wH14XT8h\nibVddgsJKdLJwQRf/dRg9+T6OpJFJ/g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQk4M8IDqy+KJ2KkBMxifCczMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjRhODAzNy1iMTQ1LTRkMzAtOTViZi0wMDY2OWY2Y2FhZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMgKjzi8dx0xE9dHT9S+V4bUBvps0AS/ESblvG2e7iJVHB\nLjLp2YuM9Qb6zWwUkO2OIhhDZejwiGlH+eaEYVpvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIACwHcHAnS/H/shu5oX3n7MT\nZkswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNTR73V8wwNBC/VQsjJnY6uTtH70Dvuz+nO2GsdG1ECsCIHTIx7MyPhEF\nRQQlirFqwUmIVvrE1lqjZdv0IgSBJ5LF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAcAEn1IdxmZctM529SBjPqYPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYxNTE2MmUtNjQ1MC00ZjAyLTg2ZDQtMDRlOTZjYjY0MGUxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmE1ZjZkNWEtZWZjNS00MGMyLWI0MzAtN2M1NGIzNWFl\nNWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcMY6S8MMZanWIUHglPKw5mtm\nVUZAaugR6dfNw+0Jf5NxFeACdqBPzDMGOqYq75/simZ/e2U5bHdtNP5mbIOLnqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUltmdJlRMMPBGpSFolVnD731rH1gwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCUhzZOH4W7UsYX\ngVHQhyBQFgBOc4fB0642tgnE9h7T6wIhAInKMWY6Y+8/htlEUfQFsVE1GLZEjnod\nhNmG8BsRo4XV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc531", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `531` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdwL8vIo1FqsNwERyPUgd1laMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MjBiZTkzLTFkZWYtNDgxNy05MDI2LTQ4YzM0NGIwNjU1NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGZhYWM5NWUtMzcz\nMC00MDkxLWJkZDUtNDZmMGJkZmYxMWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDmQkyv5zEuvbQrbqcFhXG6Smns4+neC50bqxSHrdBiGqIXs56sdbSEZTy6+D\nkiadlIe1lTrZJ8GymDenmkpAXaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKSM0hQpsf0vTOt2k9uVfrYd4eqcwHwYDVR0j\nBBgwFoAUPgFdSEtJcAZWPRuAU8j2kdbBXVQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIERjoI6FXLGJ1Wt1BgrQwS634mvdCpphdn866+4HTSK5AiEAsZIa/19Y/jC/\nG8uZVphTfPJ+XjBjZjUmlKe/ME4wsEU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATB+AewH1SlDQ4lbpMPAexyNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjIwYmU5My0xZGVmLTQ4MTctOTAyNi00OGMzNDRiMDY1NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFyINlL7GAFJGx6ujlo6hMQHOOziTGH3ftR0UzIaU7S9ON\n6HZ0QGmOHdXbcSRm+gKtlZz8SFUUE1H7pxBgBsWQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPgFdSEtJcAZWPRuAU8j2kdbB\nXVQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgccgIhTUWwz14yHLoX8pyIvDAh+TITq4+6XY6uHQfDUsCIEwXY9qoT92h\nlqQwd4ogNH/bVDn4Ja6GvjnkYfhG+tqd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYZ1imopvdCE0yrHsvX+exZyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGZhYWM5NWUtMzczMC00MDkxLWJkZDUtNDZmMGJkZmYxMWRlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmRiZjA1NTktM2VlNS00Y2Q3LThkOTctOWZkMzMzNWMz\nMDMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXuICHhudGiDrhBIcwFVuwlH3\nZCNQumFTAoe9YutiKGFNBG07skkkliyVQCfWq+a2p+pa53gxSxMOnOQ/SKFKnKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKSM0hQpsf0vTOt2k9uVfrYd4eqcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAamUVvbvTEg4bsJ\nMDkoonmC1VCXuTs8qUJrj0i8+ReQAiEAgiNX1K6PR3dWup79HdTniJbrC7CNrEp0\ntzrNMNV/R+I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc532", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `532` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAWOAnbEi7nG2H98KdhS0s+4uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkNDk4OWNjLWFkOTAtNDhlMC05NjUzLWVmZGU5Zjc0NTI5OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY4ODYwMzYtOGJh\nYS00M2IxLWJiM2UtODk0Njk5ZGZmNGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESO01f8nYCF1JAkX1OvINzJjrxZUqYujKiBZBfr94fzHRxF5zvWP76TirQKYA\nHFK3ZrO+J+9QFTP1522k9t3ekqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURPeUg20j2upM92ih5/evOLdzyoIwHwYDVR0j\nBBgwFoAUcgMglW6lYF98BET8cUkRqbD7vn0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAxr5vgv/nsrU2odn9stxV115YuO2fhi4IHk/ADMiCIk8CIQDh0MDowJcI\nVvb8/98JIZDBi7Wktl3qKpD4Jb7B0SU9mA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWI07xb8DDrLO/+CEWAie4fKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDQ5ODljYy1hZDkwLTQ4ZTAtOTY1My1lZmRlOWY3NDUyOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdfqKP3DYfWsBadR7othNft240snRSjWhqaceR2mSRkZhx\n6yOIgnLmumiOOlVaTSRgxqlrdC5EsyhAKI2rj+zOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcgMglW6lYF98BET8cUkRqbD7\nvn0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO8S2i9AjNXC0MmVsljiGvraXYDZDnSWvTFfE1Rnfp+vAiEAy0sPs8f+\n2DgJchLJDCzBwKg6okXWDIXCUiPc6kJ0Qio=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASOXtVJdC+QlKAhIaQpU9eESMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY4ODYwMzYtOGJhYS00M2IxLWJiM2UtODk0Njk5ZGZmNGU1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTY0ZDJkNWItMjUyYy00NTlmLWI3MmQtYmVhYjNlYjdj\nODIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr4vB2XXJvJYj0VH3h2Ttw320\ns+djt4MWQvAubxhXf6V5oRVK/dD1EGM0u2BUZunEwJ1/QzQzbSgh7fYS1A6OtqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURPeUg20j2upM92ih5/evOLdzyoIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGtkRGrLYfksVkMh\nKlGtUUl0C92/M98turC+HtVftVFKAiEAoI/G+HLhqCzm7ZGaTEIqa3L5TbjRPv1s\ni9qWnmBhKFw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc533", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `533` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUQQOiQxK3SyUu8y08CZJLeEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxNTc0OTExLWQxODQtNDc3Ni1iYWEzLWZkMWNmMTYwMDE1NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM1NGU3MDYtZmNk\nZC00MDIwLTk2ZWEtYTQ5ZTljYTQxMDgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEiSehgLslEWvZ/5Pmhy1eu//RpM59eNmy15y2dsQnVYiucV0ZFcrMb95Cfei\n8EaueB+2g/lMt2vGui/4/stQPKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsytJnW2JIGfginh0VTsOplgPYAMwHwYDVR0j\nBBgwFoAUI9bWTfQgeALIhQyJjt2F0zEMnTswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAm+oY1C9QAPOKm557NlRX2ehZ8aAIoyTbNp7jFa2P\njggCIFP/kO4iH1LT3Ga0M+JaQe6P32PIPeYkNZKDuhhEfLvy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASq3qhwHldIFAs6BKYYKy3iaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTU3NDkxMS1kMTg0LTQ3NzYtYmFhMy1mZDFjZjE2MDAxNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWZFViuHLVv7dTIJK2UoTwmdfh1+oiShAnEKt42fCufTke\nq8RMOAsqgXCEaGvIwWPIqk1Nq+Faj2RgZB4yBuOuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI9bWTfQgeALIhQyJjt2F0zEM\nnTswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdMGtcHF9zWV99TPipHkLm8y/8ruadG5TwXNs26lKppICIQCALqGEq9za\nNdiTvBDIRoB71E7AdbWjT7CZyl5IbRq2Hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAco6G4BuWiXrMLrOVnkOxSMSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM1NGU3MDYtZmNkZC00MDIwLTk2ZWEtYTQ5ZTljYTQxMDgzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGEwMGQ3ODAtMzg5OS00ODY3LThmOGMtZmZmNWExNzZm\nODY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEic0V6sAE9cQicYRbMJtsp7fW\nMG2eRQLfT2k0pRbpWiGAenNWVrfSva4fWPm0wk/O5DWD1PoHiabOCJIaZf9uRqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsytJnW2JIGfginh0VTsOplgPYAMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIG7CFMIK/tZGZloC\nAZcvauUA/nBrNS7O/bQTkBGLxGJsAiBrm8y+/acYn4jrnKD/oUZLj4G+mOY0ODN8\n6Bk0MqYRQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc534", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `534` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAdyEgvk6lzX9m2EHM++r4i6DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1ZTNiNzZmLTdlMGQtNDU2Yi1hZTU4LWU4NTlkMTcyZDQzOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQyMWQ3YTAtY2Yy\nMC00NjJiLWI3MWMtY2FmZjAyYzJhY2M3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdn+Mfo1rwEEmrNIX4nqwHimU2dGTJ0vshe/bkFXLzyD5x3mmI++z+0z5woy3\nwrn/yGe0Yy+rMLkrAMyIJWeDzaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg4Ndbl+dGaH7JvUeFhxYh+L2IQEwHwYDVR0j\nBBgwFoAUZCYQY1SDdp8EWsMypCsUWIYVJ9AwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiA9xlF3TQdS/DsRjBX2QD8ol6GsqKgnlUjZ3m8je/mf\nXQIhAK8g1TGgLs1L6UPbY7EaLuh5gw9X/OayOhNb4ROk683a\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfNNl8pA5hg4wfhqzhBwpR5OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWUzYjc2Zi03ZTBkLTQ1NmItYWU1OC1lODU5ZDE3MmQ0MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwGLZam+Q6TqScA1vPtn/RrE3EGu+MdMUSFTCKEYFGQEqh\nCv6mADHmdG6RmdUuX6I5v9dH+VrEAcAO9S4+Pw98o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZCYQY1SDdp8EWsMypCsUWIYV\nJ9AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI8mECUML5ULBxgHrVDS3daEXj5X7Za5BM8LccgvpOucCIBedh/omJy6x\nbvq7tQCL6LwQxQVZ5LbifdvVwHDpWe8q\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAfJIbacjA7YA5PiOXPdUS7+CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQyMWQ3YTAtY2YyMC00NjJiLWI3MWMtY2FmZjAyYzJhY2M3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmYzMDMzMzgtYjViMS00NTg3LWIzNzktMmQ2MTE4YmI3\nZDgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEixQKXYytamfZ2YLqvh/5cpHS\ne3udzkm4/prpJjmv523dHrDTvPPgqMLx4uyjdbBFQ+P3GX6NBxHMkpwPQAGPOqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUg4Ndbl+dGaH7JvUeFhxYh+L2IQEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIC6SxQfLQ0hxjoLo\n/HZzkRrnx4SuFSonORKt/wbDch0HAiBnh8qkmE3M2G1dIEbwLwfKn3Zor1KhB+kd\niAD8SdWeSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc535", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `535` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAWPi8sBcyPxnXJbdKgWdxU3eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2OWExMWU0LTdmYTktNGJiNC1hYjA3LWE2OTNiZjQ3YTAxYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmMwOTQxNDktNDc0\nZC00OGY4LTg2MzItZGE2MzQxYTRkNTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIzsO2v2/ZUNtB0sAnW6IOQOcUjmtGR4SABsQisYiZ3Q41KKVkR/mz9CzPfy6\nxXaFXEl5TMmQzLYewjyFTRL7iKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU23/HWKYSLo3I+x3+gjnqgWFanhQwHwYDVR0j\nBBgwFoAUCFFfb7eduKatIj+H1ARuMuYcKqowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBOBg9TjXR0cwMBuklGl5P/uRM/O0aMCzGsNevzo0diVAIgJwdv\n1WcQTlCcY0qyLYAr3cAs96dAFDAxDXRrodlDPAg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ1cT/TTxixX4mUPNOZEpna4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjlhMTFlNC03ZmE5LTRiYjQtYWIwNy1hNjkzYmY0N2EwMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQlSKR4BPaExlRQF6/xdBNc+O7ljRvQU2keiH6L/dP/R+T\nx0B3JkjkiJWpbHlGGi9I2ciN469DUVqzb3VHy4e8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCFFfb7eduKatIj+H1ARuMuYc\nKqowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKHxveMGjwJvI7CHjUvYqPwD5ILnb80+Ab6izWX0mLxlAiBb3eyQYfx4\nKr6vzz3UUe0kD76g3QiswI99m1LrlwEPJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZq9j3xt23wSIsH0qp5zXSH3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmMwOTQxNDktNDc0ZC00OGY4LTg2MzItZGE2MzQxYTRkNTM3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTI1NjMxMjQtMDJmOC00NzVkLWE2NzEtODQ3ZTU5N2Q3\nMmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE99mCdZc+c7DUtQY+A0mFqYvr\nHCdqMaM3cb1f0T2tDxboKAKmubD6/psYnTlF8kIl/OY3FvwQ8sH1dqIgLevsgqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU23/HWKYSLo3I+x3+gjnqgWFanhQwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAoDcVXvP5LR2dlY\nkKzXVYQ1Fk+BNYDnfevQTC3Bpv9sAiEA7SUBy0AWskv4ljZA2DIwVfRyiGt8YBWn\nBXUYUDFK6v4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc536", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `536` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAWhYs44l3evuBj76SX7q7Bl+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNDA3ZGVkLTU2ZjUtNDJhMi05NDFhLTA5N2I0MDc3NGYzYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdkYzYyZWUtNjA0\nNi00M2EzLTk3NDctMTE3NmUxYTYzNjY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWHOYvpJbtaoOHx1MlVHuRMpYNjlP+bp1+vLGNz4QbZvI4jhp7f2imaaks46F\n+tYCBVSmp35xDthcOGT6MtDQVaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9qotLwPohlHuhuu6bmDBK/9GL44wHwYDVR0j\nBBgwFoAUVL32x+3p1Yj7cHJOGEL66kTwiO8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiB6zIVRKIlm1U0Wt8aVX4bEh107ZcUkkPwu\nkFGY/vWgcwIhANAOyiFJccHo9qHn7U4O26eng1nYQmciEO12jVUr75JF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYJlNBje2ksCwB5NWF11651DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDQwN2RlZC01NmY1LTQyYTItOTQxYS0wOTdiNDA3NzRmM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpMkWKBCCYsyUJazB4u7L9yqbn5TuMIE7Z9ne0B6OHKDJB\nwCk2+gsqBNhGJuUFQQhmXkeir4ggQyib/ml2ISYRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVL32x+3p1Yj7cHJOGEL66kTw\niO8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNtAHG+9iiJ98BtOZXNFJ0S+w42yDSoIcFTcf5d0KcKgCIGLN1HS4xEUI\n9kG6FCHTLu/wdTpwmTR/uBZ0znfok+il\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAcbT1kaccCnN+JbtU6sgIF6NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdkYzYyZWUtNjA0Ni00M2EzLTk3NDctMTE3NmUxYTYzNjY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjY1Nzk3MmQtNjQyOC00MmUwLTk0ZDEtMTE3ZjgxNDMx\nZGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENSA8VCATUNydxsoY46H+p5nK\nFLd2uy70ufzrElI3N60UZ9niZH/rhJW2NiXkUocUEaTKDvPuJ3t7zNtD15JSCaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9qotLwPohlHuhuu6bmDBK/9GL44wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCZ9NODtNnSpiUt\nRHkeIqFyv/KXA16XHasrzU0En9xH2QIgYlkpne9QBq1YnPSyH5rUXeqsHh1GeTTw\nO5Jtv3LKRq0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc537", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `537` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAex2sB1+whNQCVSidDdACV/kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4NTRjMmNhLTE1NWUtNGI2Yy05YjgzLTNmZmRmZjNjMzg2YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlhNThhY2YtY2Jk\nOS00MWM3LWIwNDEtMDM2ZmY5MTEyYjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV8vGf3iQhOqyVl1dpw89DGEJPNo049+MeXpv4ZRl3ydtOItjYL7UrVjiIs6C\ns4lJrUzi4gWVaH8o700JHW4NlqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxkM3TdBIc/c/7TE5FEhFvQk/uYowHwYDVR0j\nBBgwFoAUT5FLc5T+gJ1kWV8PSvRyLy0dP+YwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiB/39MmRmoudvf/zukH2NqSwj2CtIxw9W26\nWDxjVcidBgIhAL2bnTkyXDt0+MRC3uRv5iZ/FslD7INwGyxOVZ/pofnD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYVDmLuIn+Qu2ziHBtWJ9D+9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODU0YzJjYS0xNTVlLTRiNmMtOWI4My0zZmZkZmYzYzM4NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBG65oJjWdbg0u3zu8UrC3EcohNqC67SU04rS0082fNJf3\nlyMh6HvamQefgi/+NSUM/aNAysEEkf3R1BGzkzyZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT5FLc5T+gJ1kWV8PSvRyLy0d\nP+YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU6P+yBDRbJtfrFmFkkSEH4ExTH8FLg3vbenajEdqkeUCIQD1hNG4qTTn\nQkFeaI0kAhyJ/7hktAfuNYuh2nrHND2btQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAU1ukMxShUbvPLEMlN95fH58MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlhNThhY2YtY2JkOS00MWM3LWIwNDEtMDM2ZmY5MTEyYjU0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2Y5ZDcwYTgtYmFmNy00YjE2LTk2MDYtNzUwYzRmMDdi\nYTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQL3gVY7lAqphxmcu8iSjp6Et\nJke7UegdHe0hxzcfTmSWJKiV/ZRXppc8YQnW/3GcoAz1JMJDyMCOnWrQeniCMKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxkM3TdBIc/c/7TE5FEhFvQk/uYowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCPZiz1HtG9Ty5f\nsNz38u60i7enE/xtAQD9vlJd2BMLKAIgLTB1PcbBE+8OzCSNjtCmcUlKqRwIFCqD\nS43TRaFJlo8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc538", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `538` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAUhRoejs7YJ7t4v+bBqKFjo0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZTY4Yjc5LWUxODctNDBiYS1iNDIyLWQwNjU1NWY2NTQ0NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgyODE1MTktZWE0\nNi00Mzc0LTkzNDctYWJjODBmNzVkNjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElDCG3nXSl54R0iViGJQT5CR31pfzG/6CPoEXTjLP8uNCVh8/gTelmDtqxZYA\nAzcw6LUElso1lBCB5b5dEWuGX6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyvGBPtoDvi9RlDpTRr43c04HwcwwHwYDVR0j\nBBgwFoAUyhJ+OuPOjZ2rQpwXwe/q6BsOInMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAr30TO+UeV7wi\nCCIqq4zQfjRpFjYntXeFYlkE3ybWswoCIQDxstIgMsktwaf1Vj7pznKxy0v8fhrf\nGtGwCNgS9gCSSA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVabRGitC5gsk5T804S74ukxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWU2OGI3OS1lMTg3LTQwYmEtYjQyMi1kMDY1NTVmNjU0NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsY4IrfE3T4C1MrkwfHOx3qJPo7ygCg84zaK3ViUHBmelq\nA6CAScl6B+3GKHGp/0walAKB/WbkkBpogL3ZNyEho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyhJ+OuPOjZ2rQpwXwe/q6BsO\nInMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIJvbZVEWOuHJrvIhhNp59eszX5yUKSccEtIIsk8K5efAiEA51CUEMaj\nxulr3UbSVxDw9+lSueOSJ4vfHMSSxw2NMtU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAYfLOZotEWk8z/Qb7Yn2uXJvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgyODE1MTktZWE0Ni00Mzc0LTkzNDctYWJjODBmNzVkNjRhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjU4MjU3ZWYtYjNiOC00MDM3LWE0NWQtYWFkZTU2MjNj\nYjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER+Czl/nuFQJFlTbHKihPkBFr\nJYBcOf+VZkzCrsInu0Hbcy1iHR6zI1+FngNRfKQ1bOGIfWYOspgZ/XOt9HQxbKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyvGBPtoDvi9RlDpTRr43c04HwcwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCAa8NmI2PgFaaE\nzozDi9ZV/87zEZbU7YPkwDW51XCLYQIhAMLkq5o1U4gg57icg4PxgQWSX9ohtWxt\n4xi711A9sN48\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc539", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `539` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASMathyoXsDhvKqTaJz53f41MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0NjU4YjZjLWUyYmUtNDNjMC1hMTE3LTk5ZmI1OWUyZWMyZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk1YmY4YTgtOGZl\nYi00M2Q0LWI1OTItYzQzMDgzY2Q3NTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqwMq3eV/EjgtBJ3cbqVSUhMMYM5H2fmYXcRkjtTGFMSPTi4mbjFWgdcAldij\nmm89ck5Gh77tXlfL7aOlWRj0+KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULNfI8+NC6kdFy1N52pA98FYUDXYwHwYDVR0j\nBBgwFoAU5/U1t7q+74/kXf1IxbXmVAcQp9EwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDC21vtAKXaAH6WR5CMQ7jTtaCk+04k55wOk1Cu6OwAqwIhALD3DdLuKZBS\nLujfzkQnDvpQ6Eaon3eiy1l45cEOqLAd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb3y1m0eebuD7/FZXBpDMYaUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDY1OGI2Yy1lMmJlLTQzYzAtYTExNy05OWZiNTllMmVjMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7eKlduBewbkBDs0YkPixSMWuhbhhqzhH98zuAhyY6P/Sk\nhw7n/EoD9DrIyOgBeXpJxYCcGhIGBkeDjyVlqJTYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/U1t7q+74/kXf1IxbXmVAcQ\np9EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSVQJJDjkWFYjkF9w0+zSfURE7FfciF5Ucgd1L7QstusCIG0h0kGpJrtx\nIPGNRosIHqFKNK81uXCWpVjnP2BYMLF9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAT5JU8iImtriDUgRv+LB1BOWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk1YmY4YTgtOGZlYi00M2Q0LWI1OTItYzQzMDgzY2Q3NTlhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWRhMzZkMmItMzg2Yi00N2VlLTk4ZTEtY2RjNWUwZTI4\nN2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKkowcDW6x6Boq/gcrHXwbtuy\n9qIbsRK2tkGHdU3U8QXSVvt8n07XDe0hl2Ngl54p+bnf+bnBljJl2ZBdw7IhOaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULNfI8+NC6kdFy1N52pA98FYUDXYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIC+vxm+XhUQ/YAXa\n+Bth1+r2mPlKSC24lyWs2ro1rLH+AiBz5hixWhG1Wg6yqK3VpgvyJvumwG+osras\nhDIwjDmu7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc540", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `540` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbsfP+nJmTTIr50t7WfC+d9aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3NjkxYjE1LTk4NTEtNDc2MC04MDlhLWFmMTJmOTI5YjI5NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJlNmRhZDgtNmNj\nZS00MWE4LWJmZWItNWU4ZTI3MjZhYjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhRr2qdXTsnHLYRT1Bp+RKx6W4IE4an/uihQi/Ypd1n8wijsrHVkQvaxCPHmT\nVYhkMkmWEtwpq2tQoB801UzM+aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU45uoi4Ia7bNzSNNIRq4I7UMCtbYwHwYDVR0j\nBBgwFoAUED/qcidao8KvWBtY7O8rPhXvX1kwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAIhwwgYpejaZ03ubYyOOGpHrhB3BCzGIjZaA/PsM1FPAiEA0LUtZaPABjAg\nmqN8XBfSFc5+Q1L/29DyW4AJ2X28ReE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARk4Hqr6PZUme0x3OYr7s54rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzY5MWIxNS05ODUxLTQ3NjAtODA5YS1hZjEyZjkyOWIyOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLu1/fHpkyYmhoB9WvlL+CEQI5fOZG0qTyBZDAMwyv85kl\nyJmbT1oR4mbDhcR/1AFR0S6ameo72mmxNCzuJ6aGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUED/qcidao8KvWBtY7O8rPhXv\nX1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALpGTJDJwotSAiOK5J46vbwbr8qDmGY2TpEO6eg5tPU/AiEArSAiMUrX\nytPQGSJBmACGVOpq4yXW9jDxV9jNgzJieds=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAXuF2RxhZ136avgEeUftmToBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJlNmRhZDgtNmNjZS00MWE4LWJmZWItNWU4ZTI3MjZhYjYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2E1MWZlYjgtMjA1My00ZWFhLTgzNmUtYjExMzM5OTAz\nNDllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDgLu0/nJziDoTbTKcIRBUq4K\ngW3KWQjXZ6NHrGTkJ6XP2fnT7D7a0VxOYDuTzM9uh3szOI+HrrTQkgXfFrzhsKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU45uoi4Ia7bNzSNNIRq4I7UMCtbYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGZ/rutG1DxYObnN\nRzf9WJeYoPMVDpnh2CLxHBiH5f0qAiAuaAJAwNGOurXALwxGtj6KboZawLK6eiib\nMeJZ0ELE9A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc541", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `541` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAeGIlwLzkcrKuRlR6dsVlg+KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZmVmODlkLTQ1YWEtNGU3My05NmM3LTAxYzA3YzYyYjFjZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UyMDMyMzgtYjhk\nMC00ODZiLTliOWItMTNkOWQwMWM2ZDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESnttD3B+RPrldd6LKFYzL22SHOZukwOCZnlstbhCNkRzNzv967W6d5PkZ+x4\nSl0mnBTGmSRKqiztdX1umoCs66OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY/XRHBEqgLCFYhRz9ZYDKIuZNeYwHwYDVR0j\nBBgwFoAUOVfKHhero98tqBO+ZRt3BKg13kgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBwj5hjP3n4p7v65KuJgyPX8zTiaujU5TwIFJXwMXq2+wIgaqJT2yXoS8nR\nXWGB9cpWn6+3zTm6J3DLJcoFi8pzUIQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf/givEUT6CRXlbGfncVKFGJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWZlZjg5ZC00NWFhLTRlNzMtOTZjNy0wMWMwN2M2MmIxY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6AZxXj2xOa58V001iUD3n+I6++yTDgRfrrti1f8P/olkM\n9HuXmyGPgdw6mmOcEX3fVQC8jug0sR5flU2XLS15o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOVfKHhero98tqBO+ZRt3BKg1\n3kgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE9/MOi5q0LNMQaWWD/Jg50f3F3kD52g9zLYnFPR2fRECIQDuLiIrb2TZ\nfCLuaTbznW0ccv0B0UmPhkQuYAqiS9xN6g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISASiO3+Gx2jdVUn4GOx0oY1stMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UyMDMyMzgtYjhkMC00ODZiLTliOWItMTNkOWQwMWM2ZDI0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJhY2FlMTItMGQ4OS00YTgyLWFjY2QtNjYyMTAxNGEw\nZjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwbXyb5t2NER0jRPoKL3rHkpX\nVzzDxy0sBKzHOQLIkJbgShAJjsLfIkAug3uhiy00IpM0hIShV9Foh9SJ28sRwKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY/XRHBEqgLCFYhRz9ZYDKIuZNeYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD7lWqtkkV2Jxxj\n73DHIJU39iqb81a0qkw87cfNPsHZXwIhAKtBTOWVNv+5BLZG+ZrtJuhoto7o9QJ2\nZ0eYCcQ5pj9j\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc542", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `542` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAWFJy/Fg7N+8Sdv3UqKpmhQaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzMmM5NzlhLTNhNzEtNDM3My1hODQ5LTNlMjA4YzljN2U4NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNjZTQwZjItYWQy\nZC00MjIzLTgwYTktYzQ5OGExZGExZWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuACRiZbrnEVay7RP6xL0rmV2sEClNZNWz2IsDPqUHqtuXnR5tGgXNFfJ6Agt\nDHvh7B20DsJpe2IhZusLKp+niKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1E+Hrn7SEpN7DSNNkw/USe6dbi8wHwYDVR0j\nBBgwFoAUimCU/kVTS7/c1tryIqN7wYyhF4AwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA12mPzRJrsXxRjR6ocSlZZfw56HW9HWeTsfTsNaKA\ncHQCIQCe0uj/uPE34AO+HIZ2yIaHocLImYBeL3crzG2aHZTVdQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbDZ4UzsOK36/nR3xXMYZW3dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzJjOTc5YS0zYTcxLTQzNzMtYTg0OS0zZTIwOGM5YzdlODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNVTJoGw3wVAXV8FVZ8voXSUrAIt8krw/OzdBCPiKmn5Dx\n8lsi3PdaiEZyvB9i+IBnzkx1W9nKWLenQSMxi2FGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUimCU/kVTS7/c1tryIqN7wYyh\nF4AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJiDF5WsiqxPbu7T0O0YMF9G2KTT7m+TdxyPNQsn7n3bAiEApXyeQvxB\nJWWqIUxX1fB9q9cap9BoCFwqxqqm25aX5vI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISATgz/6M4AsQxEb2HX8YdAj9cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNjZTQwZjItYWQyZC00MjIzLTgwYTktYzQ5OGExZGExZWYxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTYxZjY1ZWItZWRiMS00MjFhLWI1OWMtMmUwYTJiZTE2\nZGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbETVhgVLXKRpjfNMyjZayBX4\n5aCkADICgDQD0/XzRCO4wrE93XQPuhEN5/sw0fzRYZDozrUDRoUax+/qRIJ4H6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1E+Hrn7SEpN7DSNNkw/USe6dbi8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICORFsku2pC5AKhA\n7Jvm45Jj9eXFrrShtpd16Da+jTeJAiAboclBhpIH3RSw+xvJNGHwj42jOt+6+Zje\nxFM9Q/huEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc543", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `543` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISATjTkCOqeTKGrWX+1i0fuUr4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViYjUzODEwLTE4YTktNGQ2OC1iN2ZjLTg4NDcyZDViMDU0MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTg2MTY0NmEtODlk\nOC00OWUzLTg0YzktZGYxOTMwMDg5OGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJvF9Z6Y8gmAMOy5k4ffo42ZSgc1mImtJq7+qJdqKPh6O4h3VaVl70SSrpppw\ngTgDJbRFVJp7R1hVjiTjDtIa7aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU69qNVHmWQCyC3PGL7QXUmxwRkNswHwYDVR0j\nBBgwFoAUbt72GCky3NYZy2XrGNPlqoKQP+UwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEArp/9fEedgskKyI2pQ2vykk2KfxgUYH/qMLvAN+Qx\npnACIQD2Jpvw5IwhWnrhch17uzRn2KGHR60cS5137ke5ORV8aQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXvpbAzJdqJB2DeNxoUqyJNMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmI1MzgxMC0xOGE5LTRkNjgtYjdmYy04ODQ3MmQ1YjA1NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUNKX5lmi21cZtKgdC+XqRS+AyhCydLVifO+bbWom0SSUM\nWafIRz5EMsfHutjTZGzwC1Gujt9ETekReF5sfSgGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbt72GCky3NYZy2XrGNPlqoKQ\nP+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANN6GBRPaD4y+Z2Lmghv85lnr5TwQcZnWRbJZEvFaoATAiB/L4tRWU/Q\nVOzWNfgxYIx5zwqzX3xJi6DrgEMDQf1iaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISARqO7DYHfdagiqEErermYK6JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTg2MTY0NmEtODlkOC00OWUzLTg0YzktZGYxOTMwMDg5OGVkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDdiZDkyMjEtYTBlNC00MjE0LTlmOTQtMTBmOTU0YjA0\nZTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM2qepgCCOex/bDEFUh6B8ch+\nPgiQ0/Ml4tE+0RXfNsHhcR6SY/QaWB/u6Cbd8jhw5Q2OrN6f+2NRxH/YCpnWZKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU69qNVHmWQCyC3PGL7QXUmxwRkNswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCa7+zN6lSeT7XZ\n2yBAfXV/KdHwc47eiedt7r4hkHv82AIgQ+KNVR0oPnOmIt06LJrDC3Napf12q3Bg\n13LhQhXirkk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc544", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `544` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAUTCzTe4yHm3j52KwMqud+kMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyMjhkZTU0LTNmZjMtNDQwZi1hMjc3LWNjNDdmYzFhMDljOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM2OTZmMTctMTJk\nYy00ZjlkLTliNWItNzcyYmZkMWQ4MDU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvuBncR+y8MuhzkaQKajE8f3m/W/ju1zk/sMHmGnRKCf6CIt7KXDCfusTcnqq\noRRZ/vJTlOidLyRsuQ/rg9HI4qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTCobQlyp6WcC7DWPFKu31N8scf4wHwYDVR0j\nBBgwFoAUbyxVcbeZXL3X79U5gySTErNKPC8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA7IiPOvPmGbOCFyu2bTlgevGyoOYLQoYj5WUw8DnCmAMCIQCw\ntAcYWKLqoGQ8XkOGX/IowFpDfq5wFidvLiCWgCn/8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc8ycO4++9yAv9opea3LDzamMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjI4ZGU1NC0zZmYzLTQ0MGYtYTI3Ny1jYzQ3ZmMxYTA5YzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9MqIaWJ0H3H1cGdPTe8ZAlHJnngSGKkqqRK1gpm+U2Wie\n7gGzaUz8So9oUBCyPJw6mEIBlag8xOXo9kJsdAoko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbyxVcbeZXL3X79U5gySTErNK\nPC8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIeWOQ080IwiMEXV3Xh72rkz14SbS7ciSiU3YDMRh6OZAiBfJIEpFD9h\nSL0jTI4VSLG9n+7CVScKfl0ZMsLl6+ikYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfSic1Z1ZgA/8FufqV4o5RPRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM2OTZmMTctMTJkYy00ZjlkLTliNWItNzcyYmZkMWQ4MDU4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQyYTYwNzctN2MzMi00NTE3LTk5YjgtNGRmY2ZmZWVj\nMjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyO3DUsqaGebdaNB86vXyxx8M\nw2ceemlhtSy9DTNCM9GV9w9e+Q0xa01cTKk3+6oQtF0Y7BqnpF418xYsew8sFaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTCobQlyp6WcC7DWPFKu31N8scf4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEszrVtELzKM9esi\nmB+slajhICdsoEycvSiqPJEHvU1nAiEAiHfks/zY1jJ1Ivg5yc2WxRp6wTMJVChE\nI8sUgdJwo3s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc545", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `545` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVgtTGnwBsfCcTv+RtdzTCh9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YTU3ZGE4LTY0NjgtNDZiYy1iNzFlLWM1YWRhYjU0MGYwNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM0MjM5MTItY2Ex\nOS00OWZhLTk1YzYtMjYyZTJjMWNiZTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtzg1C+d1GvjUBNPxcEOAKXzhaN8FW8lIdIh7NUnSN+6FeN4J02NB6WHS0Ia6\nwRo/EExol6xrBJ4WghBUJK2zrKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUefdUntfObaVeciQoW2Tcl9RulqYwHwYDVR0j\nBBgwFoAUXzno7vYBlmW2fp7j1zVysr6LLpIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAdsbyJuATOJiL7ABijBZWp8xT78DU/UyIk\nR07mzqkOSwIhAO8dVwPpCZvN9/URVKmerwCZ27VF/5LOwTShUWrwiZr1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVALBPVsehCQkgBQe5BnYMUoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2E1N2RhOC02NDY4LTQ2YmMtYjcxZS1jNWFkYWI1NDBmMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGzcSoZD0oqBcv/BAvgOPwaTJhU+JDggspR/M5L6JbIU6A\neL7tLgk/oNfh4Q60n0RLBZ4ph3aSrjv9SOzXo5rso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXzno7vYBlmW2fp7j1zVysr6L\nLpIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWYWDVmWlSl04L9Bj1HzXEgmtJrqerAbnMTr7wGn+fYgCIG6/yYomsIMD\ntHXiGwqvdJj2+TRjYeOaFSo4LnaBDlsE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAcoThw006PpVbYZDDBANkpwNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM0MjM5MTItY2ExOS00OWZhLTk1YzYtMjYyZTJjMWNiZTBjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Q2M2UyOWItOTQzYy00MWY2LWFiNjAtMzY1YjJhNDk2\nYWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEho3bxBhhTFmWVdxylLMwU517\n6ayF8/xDlx4GPPyRYT98L1fZhAGG2xEGMDUOyVcme5R/6iZL6lTdTZrw8zzEI6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUefdUntfObaVeciQoW2Tcl9RulqYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAUCdLEmDONHENiu\ntRoeoaiqRBDollmAiLwkuDiHrxAQAiBHrhqEEyFQ/PrIN8QOBVJTPReMOrdy8wje\nAKyw78uLlA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc546", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `546` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAfU/KIagCbOU3LySc6fq7y5DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwYWY5M2RkLTk2Y2QtNDU2OC05MmE1LTZmMWNlMjFmYmI1NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQyZjhjMDYtZTBj\nOC00NzlkLThhNWItOTI2MGExMzlkYTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmT22AhJW1bHThBP040GMlXO/8zyY1oT91u3fag8Zl0S74WIafQkLcvklRQ0P\ncly+glS0p8bYUKB7JVLlllFQzKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU74IJP8AKWEXRtrMgMetVFGHp1xQwHwYDVR0j\nBBgwFoAUehSoqHs5tgkllNwQz8vfDzCImggwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAkCvWk6r5JVPdeRLUghPMbvHmiS28cdi6\nguVcrQViPKACIDYF/5Fu0ujuHgB2TUID5Eb+PClreZBw+xKjtLxgUd/h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcD8XPTVLatcLfEl3aQ/bE7sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGFmOTNkZC05NmNkLTQ1NjgtOTJhNS02ZjFjZTIxZmJiNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFRwGz8OOIdG0B1BI1uuUf0zsW50Aia6UCIZcehm7yLkE8\npc6WCIGYtkiaXdfBwXEqhG+IlStxba1ycrripT3Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUehSoqHs5tgkllNwQz8vfDzCI\nmggwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTKhBpjNuBhOh+XjUbKSwmi8GjhTG5vc9tEqrTJ2ddekCIQDcewWHTdzU\nyfuhCPCR1EZqSPPIGDpQVxIgXgxY1vP2og==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbT+rpXfVlK1w2r6VwRWJNHrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQyZjhjMDYtZTBjOC00NzlkLThhNWItOTI2MGExMzlkYTlmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjdlN2RiOTUtZDg2ZC00OGM1LTg1NTctZDEwMTkzM2Y5\nMjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETSWNkDifRlgPUhaKZfRN13Cr\ncn9XSbGcEGWI4M6o7osfwpRoMCQFsW07todTILX+44+lQ/YP9uKXRA03490uCKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU74IJP8AKWEXRtrMgMetVFGHp1xQwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFsV1SXpPIP0c39b\no+DvuN+FdB7zdMUnvhu7GoxQJXUdAiEAsqwwwVo5Nn8pOqS/ENNNJEEVYbNVBjsx\nFPTMsE7szE8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc547", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `547` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAbeRb6uJJX8t2OYEDsWr5P3YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwYzg4ODRkLWViNzItNDk3OS1iOWFlLWFhODE5MGZkOGY2ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWEzYmJjNDktYjdl\nYS00Y2U5LWFkZDQtMzc2NDFjOWFiNmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2yXZAinhEX0njUloo3N5AANelgMJtHcMlWqYxtCLBKY+/BVchLldSVRoo/61\ngjtSdRIsdr3FCDfvD9oQ9eDYh6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ2wA4bKUggLqpiW57cNX3fmZGZUwHwYDVR0j\nBBgwFoAURBGDfKJjK6dXWW0mb6moCeKbkXwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDf27zFA/2MZApxS+V0eBM01Jl/\n+thE+cQUBWGrG2boyAIgVHP+/iUn60BmHIzHIplHBufe9zh85oWXEumO1zMhdsI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ/Auuh0XfcZPNUW2EoF4mW0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGM4ODg0ZC1lYjcyLTQ5NzktYjlhZS1hYTgxOTBmZDhmNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7n6M2er2E2aypksve1Fcil3UAU70nQssLBQWhom83HXLy\nLfC+D9Oor9ROkPZo1kGM070gKFgD9ySgivVHR17bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURBGDfKJjK6dXWW0mb6moCeKb\nkXwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKI3rox+sKKxaDAmLIFl0h7/vb9xt69QSG9X0xmVaspDAiBmwimBIiSm\nZArppfwv7A1P1AZ5dlFvgCN5KVr+ubEpvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXSMBHP37KW1BKOXMQWbDOeQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWEzYmJjNDktYjdlYS00Y2U5LWFkZDQtMzc2NDFjOWFiNmU0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzUwNTA0YWYtMWZjMC00YWZmLWI1ZTgtZGFhMzhiNGQ2\nMTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEq5D+dWvYOPkjRtZLjsRBgrGf\nFgZULZBTVB3Y54zOmMZBF2sysavzVULryLMpFaBObrTWyFf25Vktqp2YAP8SDaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ2wA4bKUggLqpiW57cNX3fmZGZUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIArUF5FLTgmHoT/N\nNdeJaHpjpAJMRvWJpxVrN1VTT+YJAiEAmrtDjzH6MopKSOpxXr4MjOD2Vja912ba\nzlsXjV1rOWQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc548", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `548` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAd2BchanoHWNyx21Pc4Uf1vIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZTBhMWI1LTIxNGEtNDA0Ny04YTk5LWExNGRlYjliM2NkODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA3NjkzZmItNmJk\nYS00MWY2LThkM2MtNzA5MTg1Y2M0ODcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn0Qizzt5ZmElSRLKjUZPCPLOZrICqfO0yMVpystySGvfj1Irk99LX+C1gaTZ\nTboq04Z43Da6yNKMoagwxrfA/aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA+7LNalD1EJdRTIyjRy3s4tYg+MwHwYDVR0j\nBBgwFoAUBkvQIA10feS7o2GQ9bbNiVkGogwwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAOfFv2hf\nHAGfdZw9G1hG999THylkLqxWG2W6FGuLF+49AiEAkh2ICWTONak1K6VpDKTcvs/F\n27tn3KbWjQtbb4YAlHE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXr3bLzO/UlBbe1A2ZxyA4e9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGUwYTFiNS0yMTRhLTQwNDctOGE5OS1hMTRkZWI5YjNjZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUU7JGoT0+yyT4CBXKQztr/Yjc/bcG9sDkvmbZaanSqjhR\nwrKbcTlYNWIwP2qIhcuedqgk9mfxpCcHv7jHHV/Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBkvQIA10feS7o2GQ9bbNiVkG\nogwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOYkQL6E8j39zqOl8f91P43yovffb5Vi6lKabjrECh1DAiEA/y/V57Qy\n8vB9tF4yCCIyPtl0+hvha+tfsoVkyWn1Q+w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAa6332Yl9AqKCG2r92ggNEmDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA3NjkzZmItNmJkYS00MWY2LThkM2MtNzA5MTg1Y2M0ODcxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTFjNGJkMmItYTA5ZC00ZWI1LWJlMmItNWIyMjBkN2Yx\nNzA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdIRRiKze9QRG9nnR4isxvfSC\nNlj0u4/nLB7MR0SBThIBbmWsZi56aTTTjeIUoJ+yPrUzP0ACQQbGuHt0/DpiFqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA+7LNalD1EJdRTIyjRy3s4tYg+MwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDhjnP1C964nxNj\n2CzoMhlv20weuguO51wn2HXCLaMKhQIhAMxb4nl+lXTtXV0cW1Hf3upA11iyUcjh\nDqKp4am4JHSC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc549", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `549` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAbXm/t3meLwE9INPanCDJPnyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjMDFmODFhLWViNTgtNGI5OC05NWY4LTQyNDdjYzk5MWRjZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRiZDkwMTgtYjdk\nZi00MDQ2LWEzNTQtN2Y4N2FiZTE1ZGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+8sjyt+qid3mVbSyw5ld/X8roF6ANENlK3+HFbUUwXAVoM0oSCjmfLBAl3P6\nOMwXI3IZOjWpPWuFgK/kMUa7QaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+bTU0G/YB2AZzA2iqlslb+ysqAYwHwYDVR0j\nBBgwFoAUlurCZZGjh69DsI6jBb5M1Tu4C/EwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAL8m8hYT\nQJxBJVYUr1pQEKbNju6gcjM7Aw7WFtOd4zuVAiEAwETphjiahr4t4tT/xa0m+sNf\n+gquEG42QcbqeGnknqM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAafPSlP94Xgj+ARLXYDRYv6vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzAxZjgxYS1lYjU4LTRiOTgtOTVmOC00MjQ3Y2M5OTFkY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARl8UiMDBqzD//Y920Ib3OSPQtM2C2s0+NCUCyoB4C1hkMJ\nzEbPtO7IYc0il4J7jSkYNlVHXkEYgTOTIhMLo5TLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlurCZZGjh69DsI6jBb5M1Tu4\nC/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUWV3gT0ZCGK/oWUaLFm50Peht2xlE8M5gYIB48ziv0ACIGlNTO7XCFs8\ntt4OW4lOlf/A9jkk5XYW84HFNW5P0qh2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATIBkuQfMjIVpNRxYtB12ieMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRiZDkwMTgtYjdkZi00MDQ2LWEzNTQtN2Y4N2FiZTE1ZGYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2EzZWJiYTktYWE2NS00ZDY5LWFmN2EtMTc0ZWE4NDZm\nYTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEezJLCnYS06qKGzEUeWRleJbP\nsY13pGpZ8ov4/Bgoo1ccUOAqjCYo2HVLybhkZc921cNfiwhL13G77oeph7P0R6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+bTU0G/YB2AZzA2iqlslb+ysqAYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDxDSimX+Be2PPHb\nXiEq6r6368vtuitScqHmLqX06NF5AiEA349UwkNuVZv5tzoJVmgwg1TFMYjWo5UF\nBAmaiTX7a2s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc550", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `550` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAYREjI6f+k3XJR/xm1/rjuwLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0MjU5ZmU1LWUyZDAtNGMyNC1hOWJjLWJhYTFlODg2MjVkMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI2YzQyNGMtNTA1\nMi00MGNhLThkNGYtM2MyNzc0ZTIzOTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOde6IYCB+3m4nSeViZtcl0Uro3KQH7gg70su2GLkdAyL9mL/420sxoLidYwn\n22p/uzJA23p6rEbxoohQwim2hqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnAmrLzPz+DaaIq/PWHp260RT28EwHwYDVR0j\nBBgwFoAUG/bWxjZhC5gpINVg9SBL17ZIRCowLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGbONjVY\nb/e+mIHgA9pBr8KJmV2GNjsb75/ObG1mSmWuAiA1VQHvRAFlbRgCWc4tChLNIdlP\nXP/lrwsnZskY9fDAwA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT0cHIZiyPzQDOrSDLYY+teqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDI1OWZlNS1lMmQwLTRjMjQtYTliYy1iYWExZTg4NjI1ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARB5aVSnDg3LDn2sWPGRGX6H4eLWYiqeWAkr1zvCzqTOtPS\nPrUTyrR8hkg5UUCZRf2it9aNXttZXIJIHHc1Px99o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG/bWxjZhC5gpINVg9SBL17ZI\nRCowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK+aGX0tZz+RzIKO5Ucauv78MTGMXy1T9VP9iNpo0/HQCIBg3v3bBPHnb\nICMBCKVMPYMWnMy31YI8p4KxhFwK7t0o\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXj0h+LVkg7JsZn+sEgO/JgoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI2YzQyNGMtNTA1Mi00MGNhLThkNGYtM2MyNzc0ZTIzOTQ2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWY3ZjdhMDMtYWU5Yi00ZTEwLTk4ZTUtNzA0ZjNmNTlj\nYWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH7o1cO4gGsR3dmdBSDb1dS56\n0uxfzZDBI7d54ldZcgfwZoOvCH3qPExBksSLmFUWp5eStUY5tx3Q+V3jfGYnXqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnAmrLzPz+DaaIq/PWHp260RT28EwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHPZ+UuxQdWTxDk9\n+D4rQdR/aTD1xvW0U+R1BbUUx9OUAiEAs3BdpS9FylQrebIqBzFj+Rm4lZylyffk\nFd/lThovirE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc551", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `551` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAc4fLsqXS3B7eanjzmobVEUGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2OTlhYTU0LTUzZDktNDY0YS04NmFjLTg4ZDdhZjc5NDI2NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI2MDZjYTItMDMx\nZS00YjJmLTk0YzAtZGFiZGExZjA5NmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFHYoKwjjA6SS7ubmNgYU9XT/Ba2xug0tPzHN6A2qjrO1UKRBdSFvPAjH8FF/\nVK61qISQYxpKwna0nQThosFXYKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJWYxzZZPmjRg5xcdDX4hA1QdHGEwHwYDVR0j\nBBgwFoAUzhlFWTkdOaWEiW4CxhLk5NBlMkkwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIA4B+Cu+VdRQrfXG+UftlGbQRs/2ZV1cgeyXRRwdItWrAiEA6XvTUClx\nEx36WB6SCXGeRtRuuzGDvYAOmR3AwTGiMUY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXqRV3x+2delRmr/4X5CCDsFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjk5YWE1NC01M2Q5LTQ2NGEtODZhYy04OGQ3YWY3OTQyNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATw9KGBvfO1ixDILdLP0IrKaG2pRe88wzfc9tVoITxysG+0\nSW+dBggYGqwA/8K1DrjWieTaL35F87LQa57kP2Npo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzhlFWTkdOaWEiW4CxhLk5NBl\nMkkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANykm9tEErdMsESx13TeoIeI4M7U1lOeplDykhUWh9a/AiBjg3MHPOUo\nDsVH9NbpLzRCzJKs2gJsc4mGQRL+SMpqGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbqgAwIBAgISAcTV8T9JcME+GGZgiI/tVjW/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI2MDZjYTItMDMxZS00YjJmLTk0YzAtZGFiZGExZjA5NmQ1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWIzNTE0ZjMtYmI1Mi00NTVkLTg1YWYtOTY2NzA1ZTJh\nZGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+p9cerpQfM09kcij7r+cqHgy\nFkk0rDXeTeeaXhzbz3iXA03QtCO9zw9b4M9cql9PtDcN6IB9Dfp1CzWCWYvOc6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJWYxzZZPmjRg5xcdDX4hA1QdHGEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0YAMEMCHxxKLqa0qsVpPDMF\nza3Gio0O1re5JPA9id4zHLtSZFcCIBNQzHN3WgSmpP4Ve/t5KTlpSoinkedzfEFT\nP911p7sg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc552", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `552` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAYXni0EDmIi+KbVsKIJOFmDJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3Yjk1ZjU0LWQyMmYtNDUzOS1iYzdkLTQ4N2NjN2Q2OGIxYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQ1N2FkM2QtZTQ0\nNy00MzBiLWJlNDYtMmI5MjRmZjFmNjEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsup5fjotxAW1UbCjDAjaeZxrK8hcCobzu/K/qY697DNClKUJelHyeTX6KSm9\n4FBAPHGLrB9tQtTG6lbh6EzoQ6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUieweMOEgNtA/3l/nfqSEvy+DOQ0wHwYDVR0j\nBBgwFoAUHCU/rzt/5n5GrFO3VfUGHMlVqUQwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDUxJFSWm57MOqD1C9PDoowfRIoAJgyaMxifLYHaG/poQIgZ9rU5mz9\nNtohv8PIgKZ+DGa+eGKnlJ4tDWJxhd8lYqQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVpfmUlpIOdUDy0J0NGDaO93MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2I5NWY1NC1kMjJmLTQ1MzktYmM3ZC00ODdjYzdkNjhiMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGJ0UXpccon8EXDApUPb3eW8Oh3ZzLfHnYpkPrsDdhJ2Cj\nF3Cl6EgsQrLS+hW++T76WCU0ihQ5LM3hBZGcsv9eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHCU/rzt/5n5GrFO3VfUGHMlV\nqUQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSwuBbPMYicZUJ3KOo70jXGBnJRvx5tlYjLp/Uj4cckQCICU33WH1fM3j\n/LEQmwyxFmcXSP8AX7V0FBysACuwlTui\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAVxHHagnwSHmImkXnHGj+iLtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQ1N2FkM2QtZTQ0Ny00MzBiLWJlNDYtMmI5MjRmZjFmNjEyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQwYzVjNzAtMDhkNS00ODJhLTg4YWItYTM2MTg1M2Zk\nYzEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1lR2PobAJPsGyAdeDmfUcIQO\nN5Jk83Zd4ROqpAQ9VwNjmjehKmb8WvoKno+r6lH69t7PfNs9lSxRHKTn+VRgLKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUieweMOEgNtA/3l/nfqSEvy+DOQ0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD1prMHmIwk98BQ\nsl1wO6zR3Q2K8Z84JfQbdgKARevpiwIhAOnE0kQ1xRIblnW8lSvoLjh3HZiiuo9a\ntDSx2gFZW1VC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc553", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `553` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAR46HPfyiSSyevizXck9LFdSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxNGQ5OWMzLWEyMzYtNGY1Yy1hYmM4LTBlYWE2NjlkMmVkYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg1OTY1YjEtYjAz\nMC00MzE2LWI5YjktNWE5MjZlMmQ4Nzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3nwGiTbAwb5LZJPJO3kQHHq4L7gYrQO0FLVI+K7bNj+EUIX8prCvxSKCyRhb\n1rJeiag1wobTFSdZL82W4s02x6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Rh+e3hmrXFQQoCLETUmrgKNKWswHwYDVR0j\nBBgwFoAUuFTbMSXj+UjlWKAXqk/mfTFhXmIwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQCFPKUOFHOSAnEqn+hVjiMCyoNO76vafVYMm12dzZ2NcQIhAK8Rng3fzFukuTYN\nfp+1YUgnLwPXBMJWD668x837cYdM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQsR0Qff0fswuUR4aXcrZHCKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTRkOTljMy1hMjM2LTRmNWMtYWJjOC0wZWFhNjY5ZDJlZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5Kb6l6bG3xivyD2h7RJ1+ziS2zgTSrCt4N2eg9XdKI7WJ\nAnvsf6zR2eBEbUP0urLh8x3SVojhycHjp8VZcuQOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuFTbMSXj+UjlWKAXqk/mfTFh\nXmIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP/HceIHECCogvNi4bP2UAsnIYgHszcyq8Mp+dstVtKRAiArLyey/kQ0\n3sKXbU4nOT+E8Jj05ALOb9xxjC+8WMgiSQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVSJ+aSg2LUa5umcFWtBzq0FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg1OTY1YjEtYjAzMC00MzE2LWI5YjktNWE5MjZlMmQ4Nzc4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmRlM2ZmYTItNTczYi00ZWNlLWE2MDQtZmRiMDZjMWJl\nM2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAET9zr2k8yRIsnu4uCbJg5CpGs\n7jk2SuHszSpkW4cKLBzQxDkqGio4EGvBD8Myi8akx2ID6UaFZ3TgbMJZX3sZr6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+Rh+e3hmrXFQQoCLETUmrgKNKWswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGLJQ5CRwlsi8H3O\nReFZFx1Y9bnosKk7Tn+I/ontcGsJAiEAxd+1eJA8bVWSVgvSO6yijOC128uvLomO\n9Uteu0IpMtI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc554", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `554` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZUUF4NjFJkLeQwj65i0utWBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1NzY4ODE5LWNlNGUtNDNhOS04MTdiLTcyMjNiYWI4YjUwMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjkwNjAwM2EtYzZm\nMC00MjI2LWI4NTYtMjMyMzg2YzEyMDFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH3sWSgG8wCd9Uqyzi03W4bwxg6LszPY7eL9SrL+DFy6dC1jmlWCKdwXqFzQp\nO+fy1ZjD9SQeZ2J8KDnVMZl7tKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuS29pxcwC1VVRBQ3KmMSJCZK0hYwHwYDVR0j\nBBgwFoAU+u652VeN9/xX1w4ldBLa6YwqRN0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIEu1vkRJ07c4FxYdx/l63CDpCh5p9Gxjb50pz1GWVPTCAiEA\nhRvdCH6HtI+4eINtY3HMp4prCepjyueDMnjrSjR7Kps=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb11jQIwihtJlkBHyLhOlWsVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTc2ODgxOS1jZTRlLTQzYTktODE3Yi03MjIzYmFiOGI1MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRkLaMy7S0SPMYQRKZznnaWt11Zm977Jc1/mshEloSIlb1\nLybxJ3u4OALNcI7zRmFx+hp/JZ/wFPZLeZoE6mMDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+u652VeN9/xX1w4ldBLa6Ywq\nRN0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPEQAm/K5jb1cDUXJmcIHZ5ATcmRXp+Osdc7GSZqOJ9hAiAZAs0WUkBW\nZZKrGq66/QLrwtkugMcUCPr2YEUNhiMxQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQng+inSBVC9JYC5KnIPlxwhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjkwNjAwM2EtYzZmMC00MjI2LWI4NTYtMjMyMzg2YzEyMDFjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzlkMTYxNDctZTI2ZC00MDA2LWIyMDAtZTQ1OTUxMDMy\nNzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElGgaGM5vVP/mKArxY4Fq9YXk\nVSknCDo6pGTmUD89RC24RtMS68DtLtzm0V+Z7jp7tjS5oiPGBw6rMofsFylAX6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuS29pxcwC1VVRBQ3KmMSJCZK0hYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEtrBLSsb3O+FlwM\nBlgO9txxqShyUyaFDhEK73XwpRSxAiEA7aOrHGj6g642v+VJgAO/sLxaQY5S7wIg\nTynJxTFNeNo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc555", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `555` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAbdh7iK4OpthIh0qMENNEiQ4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhZGE0ZjU3LTNjYzgtNDJjNy05YmE5LTAxMGMzMzJlNzhlZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzEwMjAyOGUtYjAx\nMC00ZjY4LWFkZmYtZjMwNzk5NjI2ZjBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7HeLZ/c1EMR2OokC+HgBqCtLuX9eav7L2y8MCJxPFKN4lgYROrN56UvaWjgn\nc8ra8RY8bTMoI0eC83G7BHYOL6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULE0f7dDWOr2VExR+zIKbZQdniIcwHwYDVR0j\nBBgwFoAUrN3Xx87DEz1esGDTDYl+EJ487fMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIAuPKfSoKD+reliYGB7yCz1aFrBy4Z4vE9snhY0ykiZPAiBF\nvkWt+djXNjw/WstzuxXsFqlPAH5EHF8X3PGnqd5epw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfO24IeShZRhyuQboeEF48K5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWRhNGY1Ny0zY2M4LTQyYzctOWJhOS0wMTBjMzMyZTc4ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoTEWGZJ+7nXgHxlYXKItlgm64KH/2HG0yILZae+oMHzpV\nuVJ+uHtgmI9fSdHGJ0YGLvlhuQ8ajjO4itFeXstLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrN3Xx87DEz1esGDTDYl+EJ48\n7fMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXEoGVYAcoywm121IZHljg6NKAmQBKKF+B7cMVMdjSWoCIQC3MFlKreeC\nomZjw6pU6iHjaRuqJzT9r9MiO9U3cFog5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAdnjgmKCzQQjcnBL53QLDzb8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzEwMjAyOGUtYjAxMC00ZjY4LWFkZmYtZjMwNzk5NjI2ZjBjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmYwZWM2MzktODEwNS00ZWNkLWEwZDQtNTQwZTU3MThk\nMWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6wCEyvT9bgx/q2JIpkzgYDQu\nc+r/o3WIgRqYIvHJ8eiAUeqGyFQPUE+dQGz10qT8u0ftM5V5PA5RRQXrmF9qQqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULE0f7dDWOr2VExR+zIKbZQdniIcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCSkrWgxq6W0i7O\nwb3vHRLdqHh4KcFqYAW9davE1rlQCgIhAJHJqz1fEbcc/owFKiyQLJ1vDTtEhZuM\nqCuUnDWrIlUc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc556", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `556` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcIgZ2gYjbwkAQ/Bu7qcoX9MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmYWU0YWJkLTM2ZTAtNGE0NC1iNWQ2LTI3NjU5OTMwYTBlNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUwNDYwMTgtODli\nMS00MGEyLTk1MzQtZmUzYWQ0YjAzODliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaO7mLiOLBmEfnrtG6pChUgtYECfOoixqu1ewpFIskI+uZavhbylfbqECI477\nePUGqRcZ6byiLzcY6GOvuFivfqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ZzLYOJnvcJIBcjuMSCHkARqzxgwHwYDVR0j\nBBgwFoAUBhqgYHGHikMXIrlb1cIHW2rL/G0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC18RM4hrpi\nKd0iGRJYEZ+POmiM65yvtLS2H0FtvfCbRAIhAOa15eDZTiEYEf4pWWLp00knKETi\njcIzWdwn6CowojXe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcjC5cXxUWgphqJNrQob7b+XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZmFlNGFiZC0zNmUwLTRhNDQtYjVkNi0yNzY1OTkzMGEwZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFD3t6S70qp6/u0ypqcodU6WkkSeFFBrRJyOJ0yNmV/Q+Z\n3Mvt5lLPxaU2sjxUIo8iJ9yicP08Rh6M1vFJ7+xYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBhqgYHGHikMXIrlb1cIHW2rL\n/G0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYpfwtvARM6V2XiJzGCOA5G3Luk4NcCjwvtT90jfd0vMCIQCH27PV+j8D\nIhejgKujeiiBcmaQ+YJlyEax63Un5tUf2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbmVfSJ3RfDWXE+JIs8h8131MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUwNDYwMTgtODliMS00MGEyLTk1MzQtZmUzYWQ0YjAzODliMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjVhYmFhN2ItODIwZC00NmEyLWE5YmYtZmEyYjNkMWQ2\nYWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo1ExkUx8CFhvq+8Vh2aWU52p\nwwdVL9jnLd5JxqljdD6tc4tV5BuHueEL2nTqF2LZyQGFmxIcAfGi30b/7ishwaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3ZzLYOJnvcJIBcjuMSCHkARqzxgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCUnV4n9/kTFt/W\nhSR75kS5eLc40JDN5ywN4y2weiI0+wIgcr4REp+Dwq5z0IbJBhzrnnDgGQNL3YQi\ntH2rn6xuaHU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc557", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `557` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAeMnwNyfaWWiDcsBDtzWdLHIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5NTA2NDYwLTQyODAtNDA5OS05OTZiLTQyNDdhODk4ZDZlYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY5MTkxNGYtMmNj\nNS00MGEzLWE5NzQtZGE4NTRhODkwNGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+o8agPpcgLZL6nE3cOKWE8N1eRaahoiGj8vRjq6agWxU3FRz3lgnxDTBYDwL\nbdlhYjSYJa1t99pvZ7nPBdXnoKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdbHU/knPhatIuSwZ10kdwvfnJwkwHwYDVR0j\nBBgwFoAUkeDhmF9HxMLOPGPAIHbBJUrpj50wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPAqaW/nr8rSpuePF+bEOOoIWI3SdNjroiqsGYfqFpMBAiEAh1fdG+0j\nF8fM/HxdjxwutqTNXufc7C3RrVzHnNYfnX0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARPCnTENJVaVLCdktJmAgSs0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTUwNjQ2MC00MjgwLTQwOTktOTk2Yi00MjQ3YTg5OGQ2ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASorCfdnmnZnn6sRFjgX4beeJmy6QRmlEB1Mu+L/p4WG711\nb2Llcd3naycqjm80F9f8RPRXPvrPwYReDQ2vH+Xko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkeDhmF9HxMLOPGPAIHbBJUrp\nj50wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEInN2SQlML+v8/VoockrfCjEK3GNcwwdrdm+rp2zIZcCIEw9lVPo+FnZ\nndgouAG6ovfKv1gxROfV/f+eN/cXAHxR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATueqYzdLM26DXBqywJwZz6MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY5MTkxNGYtMmNjNS00MGEzLWE5NzQtZGE4NTRhODkwNGJkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDJhMWMzOGQtZThiNS00MDY5LWIwZGMtYzUwYWQwMjNl\nZTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9wG1Eyui69i2vcm6gmO/b89A\nL+3aQtkrddb5dmi4cOD1qb4XXuDtc5xH3YWWcb2kVvjwqFIyqCtYHQnwq013gaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdbHU/knPhatIuSwZ10kdwvfnJwkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFJwn89t6wpERj1Y\nT5ZgIZoeYr8vJTScqhKZ4XkkjR4/AiEAtsADwdtah4VYV4J0Id9i590Lc/WgDKpN\nFuD6iXLIai8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc558", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `558` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAUUqy0PlektC3tdsg7BUf4n3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhNGRjN2M4LWUxN2QtNDIyZi1iYzRiLTJkZjljNmQ3MTNmMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM1NmI0YTktMjdl\nMC00ZjM3LTlhZDAtZTZiMjIzMzMwODc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPNADHjDKH4a/ipirH8D1+ONKCCb0Jx0g+lHrSFGK7pYkwSOkKx7uG+uVB8oj\nxUa5CQStTW0v8oACfCA/t/40S6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXj/8CQACkcSpFNuUQzwPYra++ZEwHwYDVR0j\nBBgwFoAUnVhMzg3XLpXiXQu3DOEZhELdCpEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAPCINAdkZqXO5BSYQX5iKYo424s5DlIBVD3L81IfoSwdAiB/4vfdxV0b\nt4vcJZf8nYwQrVWG0UhUWWOSnLDtEKkoCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYN4n5rmwqcoyurcxNG2KWXtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTRkYzdjOC1lMTdkLTQyMmYtYmM0Yi0yZGY5YzZkNzEzZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBQuenhf7zm8YOBDa20rxei6pshWOlhJTCSf0t1hKOHIgB\nOWgUNqL2/FWIQW5WiuzXvUlrhP7v4p2Yu6b299vro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnVhMzg3XLpXiXQu3DOEZhELd\nCpEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIGVz9sShasJnIN09N6OA/E85PyyWTEqFEXkIT5AFTyEAiEAnATt7SsZ\nvRX2j+EcjvyOXw1BufmEeInMOHbI2MMS+3c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAWG2U6+9mNh6Lsbuq2LiXBKpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM1NmI0YTktMjdlMC00ZjM3LTlhZDAtZTZiMjIzMzMwODc0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGQ1MWE0MzItMzM4Yi00Zjg1LTgxMmEtN2EzNGJiNDU2\nM2ZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnlag80MDm/EwAPoGGXAzExTp\nvpMl2h5v3WbsDLEGduK7jlrxdMzhPsc3cMIEKNHoN8BnsOw/feXKQY2Fr274y6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXj/8CQACkcSpFNuUQzwPYra++ZEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCPoEbNTTGKj0YA\nUcGL+tMLd+zqiuhVqaQf0NIFgarxPAIgbRpBKphQlrT0EcRhVP50fsQp2Nzj8ka9\nnHURVN5Bkxw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc559", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `559` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARyjv6yPGy+u4pbz/lLQI1PqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YmNlMjEwLTljODQtNDQ4My05MTU4LTU5ZGQ4ODM5NThiNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzcxMTdhYTktMjIx\nZi00ZTljLWIyZDUtMDFkODJjYmVlZTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj51rhuZAn6fE7yg2qwBj66+Mf+8SPIPBVW7paM0RK3HAo+zCKEMzoSwJEAKk\nmjXUeCIz/RFGhSvlG/itYIHGP6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI29+Mh9BJRj+kZb7g5gKO4uwLVAwHwYDVR0j\nBBgwFoAUZzf1qkmJs/1ohrusjRG+79LHi/YwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIHquqA6CBfgG6mUDsDnthIvbZxCBacFhywzDJlx+6MNXAiEA63kbgmPp\norDeevmLDS0ONTEEfRsHMkmqMRn8KUXRpdc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZQCKUJ9VNmWp6HRaV3lRTa3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2JjZTIxMC05Yzg0LTQ0ODMtOTE1OC01OWRkODgzOTU4YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWdKq0bBMCcgu3zkhOPVGl37tHNn/FaETLRCK/XA3WXBwP\nPvaLYnxbjHxUqB6gwgZo6uQbj9i3AuYGIocXS0GZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZzf1qkmJs/1ohrusjRG+79LH\ni/YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMiowIo35I9a9EayQsinrHw66Ra5VObuPqTR4maHPsVEAiAMfxnE7OHX\nO1LwuNZpZs/9QJ/98ARV6rc2J2c8Mpve+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAXmfwt5Jsfh+Oqw7BQWg+Y+jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzcxMTdhYTktMjIxZi00ZTljLWIyZDUtMDFkODJjYmVlZTI5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDVjNDVjMzktNzk3MS00YjYwLWFhMDAtNGZjNjA3NTYy\nNWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtQMBjsSt64LU5RmriBvHBLCV\nymq2CebX/0+6XvuRcJYAo58FVmDKjt/qYrYrqbvaIyvdsDo5QbukCWBfq2UabKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUI29+Mh9BJRj+kZb7g5gKO4uwLVAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDsbLCpc/DRd1mV\nxtewY1kq1WpUoQX34hRnWGQS5fWDdAIhAP1qhNJBI/EJ69si6he1zzMki+00pNwt\nt6MjTibZeTnv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc560", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `560` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAUKuMVsSV+0fO2wuMQM//GChMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMzU1YjFhLWU4OWItNDc0MC1hYzczLTVlYWQ3OGY0YmI3ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRlNjZmZjItZDUz\nMi00MzhlLWJmZDYtYjQyZGQxNDI5N2QxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6RFbZCFdXEp1V/1s0E7pFvMwQSXtbggYbC80il66XB41dz4H0QFaKdveobfk\nv71PcpMgwrqoK8u8yXtefdKd06OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ2zmZ8x41pKmi3IbhQvaE2sS6j0wHwYDVR0j\nBBgwFoAUkcxpIfRLNOf30PKASJ8Awkxd/70wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBdwkAiSy7ZuAwBcfUr5v8jDDl2ybo4VnjvlEfME\nhfX2AiAEhFswVEcGfxVeYPgy2iZmsVhmyWFz0+1kwCvy9kxYUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfSdS5FBa4yD8DUufZzRE/9xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDM1NWIxYS1lODliLTQ3NDAtYWM3My01ZWFkNzhmNGJiN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+sfh6Wf+2PGdxOS/5eDNKV+wzf6yAfHzvmBvb6g9SFh5H\nT243wPOawtReD4qQbymVOMUglcgtz0M0wWCCy6z8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkcxpIfRLNOf30PKASJ8Awkxd\n/70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPFm0+6aWr4a6HAB9hz0ZKPJjEDR1R++JTcir545manbAiEAlQbTRWPl\nFAnSW4WKBqk4v3MU1vvGxgHCSVDRYK54E0k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAWhvagD4wfDlMph9sgnzVBhiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRlNjZmZjItZDUzMi00MzhlLWJmZDYtYjQyZGQxNDI5N2QxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2E2ODNmZGQtNjVmMy00Mjk5LWJiNTYtYzlhODIwNzkx\nZDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8WCB0p43Q7coShI2xfOUcR6n\nIDROosOaXhHvf5m2lFww5aapjvvG10XBDNz9g+AhrVyRd9QV1igK1slrs8Rux6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ2zmZ8x41pKmi3IbhQvaE2sS6j0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEYUCcq+4D60Tw8l\nUevlJy/yWV5Q5bI72cyjj+qaTPfGAiEAlSIYeBjsrf1giry6McHRM8J/Xwwuc/LE\nNSwC6mRtokw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc561", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `561` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUGG52HnvHaohGyNctkJeloMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhN2UwZDFiLTk5MDAtNGY1Zi1hYThhLWZlOGZlNDMyMjBkZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJkY2YwZjgtZWE1\nNy00MjRiLTllNGEtZjA1NmJlNDZhZDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmeV2vV7WeQNYiGCJu5v57t6E72P6K7tTlMoarXQPTN/uDNdZPaxojlciE7zI\n8Vd7rIeDqF2f+qa1xf3fYcqeG6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkgtEhVF3ZLXj7/5ezccs4DGpUzAwHwYDVR0j\nBBgwFoAUJe5dLI5oTS5BODir4gGrXDC7f6cwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGSPvSs8AyjyRqFMMtVxwHl3iDQVzqRMQnmh0miA\nuA1OAiEAvhSjnDREV8hscrnIif+igUuXCrk8vRaaDSOCku0yP34=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQLGQF89+QkG2voYE8tLe6nWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTdlMGQxYi05OTAwLTRmNWYtYWE4YS1mZThmZTQzMjIwZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPnZqzriEXjoPgjWy7895khLMsB+yv66z1lzdOkXDAydbH\nh+MwdssoXN3k6JIw2Rr38VJhc/+gIFGn46Lu2nSOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJe5dLI5oTS5BODir4gGrXDC7\nf6cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANwGXQWlIbdHkR2LeS3dgCYaTxRK+3NgP/8GA49l5E5VAiEAodzs/mJr\nssPwS2KMbLOJZWVStuKhpEwK0PIm9dBibuI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISATJKHS6aSkQDPcaQKL7elhEqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJkY2YwZjgtZWE1Ny00MjRiLTllNGEtZjA1NmJlNDZhZDVhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFkZjE1NWItMmI1YS00ZjVkLWI1OWEtZTVlYjU3MjZi\nZjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9YQpCWOr5x/QJDTQKdBkeBsm\nvJbLMOAs4XBhLPS+36UziyxhXrTyQZ6lrIMcnigzHW5xgYULLswSPVO7543DNaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkgtEhVF3ZLXj7/5ezccs4DGpUzAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDqYf4YKLpjzSNYd\nfU1K8jxwneMA/CIeBLR1yNYkjyfOAiBKEMMT17nGyZq7SSLONCpUwqoJ+dvnMmf4\n2rYTms+qAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc562", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `562` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAchRuWOqmF1PQSwkJf+VcA9JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5YjczNjFlLTQ3NjEtNDRiMC1hYTAxLWE1NWU2ZTU1OGQxZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDljNzQxODAtMTZk\nNS00YzdiLWE2Y2EtZWMzZWM3NjYyODUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENK52PfNWtJoSb1Ig9zc7hG0tf1USmPMPK5jA7Ui+7+fCLvZYOHJG1PSGyvhR\n8B167Tb52tXAcoEgNEcX7zsthKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUexXruEX4SA7epE+UZNsMGWsrlRQwHwYDVR0j\nBBgwFoAUD5rIPyd+2ptiuR8Hg9UFbIVirxYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQD70Bshfn0AKJwEfsa6rSeTfCDbDaKgbErJxHG+JdcnhgIg\nS1VIY7gytotkvcsUIrzf95yjbZuAoaK+lLZ32DExEUY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd7RyaXtmgrKBgSdEwNIrfnCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWI3MzYxZS00NzYxLTQ0YjAtYWEwMS1hNTVlNmU1NThkMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATc/0bWoJwRMa95cNy3w7YrVReeB7N13OOqKH6BfXrascf2\njbFYAOF0qNltv1fgHM5I5PaBmQjMdNZEjrpxV6Mio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD5rIPyd+2ptiuR8Hg9UFbIVi\nrxYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOqzYy5EL2ZOqMlxEml/j+UdSEeGgRd4nIrrPwXOQSm0CIQCCAr2scrZA\n58wG8wg3L1h90OuNu6yAb5mfT/T7QPbpAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYuPfK4lRKUkKyJ4VfCynPHHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDljNzQxODAtMTZkNS00YzdiLWE2Y2EtZWMzZWM3NjYyODUwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTU0YzQ1ZDUtOTgzZS00MDY3LTk1YzItYThlOGM4YTAz\nYjcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoC+VzfteTNDxbxayVHcmTdA5\n+R/WqL4WqHyy8Tx7EDmXL8a/3Ja03N2XLoP43DmrpQWPVuuJm3HdPkVkV7qdo6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUexXruEX4SA7epE+UZNsMGWsrlRQwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIF02IiktitrYml0T\nW98RCnlMtnbPvKlRSgbHjI/YcMp8AiBSyGogxLSclVbBRRH2A2jowiupbT3uoHnD\nRtrxrEt+Ww==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc563", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `563` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAeX3v34DEBj3N7UjiSgCQb6DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYzMzYWNjLWNjY2YtNDkxNi1hNWNkLWMyYWM5NTYwOTBhYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzk3MjE5MTUtMGIz\nYi00NTBjLTkxZmEtYzg1ZjhjYmNmZDMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfnTUxAivWb+2g2TOQYEZ5uWUxioVGuF/MCIcWI1RG5CHYAGuSTh4hv502SQO\n84op2ZgKRaDaePm7m/34MWcCw6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU4HUWoH8OVUyrcw9wTU6JXAgsJkwHwYDVR0j\nBBgwFoAUqJ9dF1Lqn2Ldz3nSI4P4BslHFykwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDGP1+hIww1IhCJtdPusP6DQpPjWxhYO\ne9KfSaUJG09VAiEApO5zNpoOYcrRvxsrYsmntquxjUUBoxtpl/9v0b2F2zE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdBuoHCqZvUbO4YmuczILgFAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmMzM2FjYy1jY2NmLTQ5MTYtYTVjZC1jMmFjOTU2MDkwYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSIl2xVo1OZgmrLnnni0hfczLhLLUsu2mQyM3Y/JL8LPCM\niZmEFgMb5MjSvxt4FAobctvbWa7IHopyOHsRbnBqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqJ9dF1Lqn2Ldz3nSI4P4BslH\nFykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOXd2nOhNevQ3HqHZmwGCs0dvlQnDbZimy4BoKI9gI9ACIQCL8/Fhw8/o\nzvHOWt5X9cS4LJuE1nlQW2T5Vb69GetdfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQjGzFROXigvcpFzbNw6mgB4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzk3MjE5MTUtMGIzYi00NTBjLTkxZmEtYzg1ZjhjYmNmZDMyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzMyZTU5NzktMjI5My00MmYzLTg3ZjgtNmU0MzZlMmU0\nOGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1Q16u4BVnOsTu6u/NPRqFw+T\nExIJ29OmsjtWdpGikGV4xkIktKDpQK/Q70l6Spcddqkenqx+KkKq9SEIQAUQZ6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU4HUWoH8OVUyrcw9wTU6JXAgsJkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDDNDTMbWg/HWIK\nN0qT0TgELgE00+KfuU+4vz85aZsdLQIgPhZTtl1WVu5hxXITAp0PlUcetEu/LDTT\nx42W47a0GKU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc564", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `564` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAdE1zy/GlqJCi3VRgKqKrZpsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkYjI0ODY5LWI2YzEtNDIzNC04MmI2LTI2NzJkMjNkYjY3ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJiMzRhZGUtOGYy\nYi00MGNjLTkxNWEtMzQ3YzM3YmE3ODhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPkD7JajmlRCTrZ7zEJN0Ms4fMjL2G5qidPWo+xglSEhdthmi1kmNydIy5Sva\no8OigI4ltJFTh5Lo6bsViOiqN6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfXE4EOBkWFfhimuIDXXymEOyaJcwHwYDVR0j\nBBgwFoAUQ/3QWD88nAJdnRjNUnaQsXcaHSEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDx0vN5JM5ufMuAvvU5hxKNMIzQ8UjT4\nOdyJ3oucxQ86AiEAl2zQsoXRPthS6x5s9KEWoJt60Tezy3JnfXLsZUBEcfw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASkM5ji17z8t9BHck5xVvo8YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGIyNDg2OS1iNmMxLTQyMzQtODJiNi0yNjcyZDIzZGI2N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZaBfE/F5432IThYatdO1iNHVKcNKQKIdTqVUF5acToLaO\nixnV4kCkfy7/0Zp7NMWUH6qmbihJW+XH2eUZnq1Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ/3QWD88nAJdnRjNUnaQsXca\nHSEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOUCh/WXW1r/wneDXeIMXlJfY+WZrkq8cn1K997GE116AiEA1TYFpkCX\nrwFsbysuSMxhxzKzCdGiIpm1x4j+xVddL+E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAUZRJEWjgCTqR0NIoldLLn09MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJiMzRhZGUtOGYyYi00MGNjLTkxNWEtMzQ3YzM3YmE3ODhiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzYzMjNmYzEtM2IxNy00ZDM5LWE5ZTItYmFkNDdjNGQz\nODFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9Av9aw4Wjp7GfvxW7Uot5Ioj\nklP4js1Vc/mOeOyGS45F3ZftQo7+6Et8w3bIFbHM3C10SgEOdVbYdyLCSGTkeaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfXE4EOBkWFfhimuIDXXymEOyaJcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDn4cU9fjbUpkeO\nB97DqjHND+EZXgD+jnXNasDrWw6Q7wIgEIv0OolLFTLQ8YthQO3bZX2skPM02Md/\nKppZaDJCX9s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc565", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `565` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARVEDlizpwoQb/DkBPAEYm4KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyOTJiODc1LWY2ODctNDcwMi05NWZjLWU2OGQ3MTI5NTBiYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRlNzFkMjUtZGVh\nYS00ODkyLTk2MzMtYTlmNzlmZWZmZGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr01ERpijV9nVBbYiojtL1Qqq/cPDXzsBrsJ1YQt1KBsnz+/H0udllLKU0JxH\nIOYeOrhNZBf4Fhw1Mev7y5+wwqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyVZtpwQr5jxBoDotL8k9tay+jYQwHwYDVR0j\nBBgwFoAUawJAM398i7rDqTzr3X4Y67nHpM0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCar327uI4/\nJhvbWwYdirRl8J1aCGFU7ev1YSWff+RyVAIgGCEAdYIYRSJfVaJUfU10d7ek+bWm\nIT3daLtPLZxfSgo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWE3cII1InXmjj+F1Y5wNOLGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjkyYjg3NS1mNjg3LTQ3MDItOTVmYy1lNjhkNzEyOTUwYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUqn/I009Lz9aq0DDv6CjK9NccLrZSnz4aI8DVbKa1zFSG\nMzWJPGpVvYBgKOwanbPHXELJNml/e1OH7MNJd2yho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUawJAM398i7rDqTzr3X4Y67nH\npM0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL4sL+iEGP7z7ZF5/4r0/Rd4TpGWXDG4HLduKAUrnOU0CIHpV0Uo7GpJ5\nW2zc54fuCx/aoiDMHPZxI2HT4gpL5jgR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAd8dcV9WB+jpzKvRWgSIiV6zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRlNzFkMjUtZGVhYS00ODkyLTk2MzMtYTlmNzlmZWZmZGE2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZlMTE2Y2EtNzFjYi00MzIwLWI1MTgtZWQ4ZjU2NGYw\nZWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEt/rj8QjfMGGjGKg5w1eHWphp\n9iye951NyshnOWQOzr/IuCVIhyW9VYIzTjB0OPTI8b5xsOmxbmeuEAV/0opfb6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyVZtpwQr5jxBoDotL8k9tay+jYQwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIH+43rU1hLTgToxS\n20u3DGvFtu2qGQRUAi3vbCmvTH5aAiB0IUeuk3Onq7Vu0+nBgQh95nDfIVWkselA\nzNaMlDSXgg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc566", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `566` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAWHz9ZkPDDwMcTkx9l3vNOZCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzODYyNDcwLTc0MWMtNGIxNy04MWIyLTgzODQ3OGQyNjIzOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQzYmZmZmMtYzVl\nOC00MDE2LWE0YmItYmUwNDA0MzljYzEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0BhLEEJ6YLsC9qyVEz6rT2zquncXY0ymU9f8fKNv2pEDDaa1EItIq11fEzaA\nmyPFOZCj2S5VJ/aTiV0TuyxX+6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVuERHGoT48OIw7oD4zt/OIo5AWUwHwYDVR0j\nBBgwFoAU93EB7qSvSWiAgiqm3NOmqb31ercwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAOowjr7hCx2b7TqSQxpPXz4rZX4Kwj28QEPt+BmmDX2WAiEAzNKDu9wI\niDq2pw/11j/hHKr2GwkD7+gPSUCtc4ATA6w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdjuLokwmtlhgd+yY4a5gkb7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzg2MjQ3MC03NDFjLTRiMTctODFiMi04Mzg0NzhkMjYyMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4RNd3t9xa46DAcWeeHL0W83jRrR6HYN4amIWqLCWLzLCC\nG3os/6t41kFKRyfqxrfascWBHlJHhlNhYk7Tnm/ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU93EB7qSvSWiAgiqm3NOmqb31\nercwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAISgrwTRHhTn/De4jop7rkIdENDpoADuoLc6TNGiRjYwAiEAnHr2To+x\nsFYm6VgjVCdBZDrH1AJypP/E45zvfwFCujc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAcG0ED7mt40niVTewsAka+3fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQzYmZmZmMtYzVlOC00MDE2LWE0YmItYmUwNDA0MzljYzEwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjdiNDkyYzMtNjBhZi00OTFmLWI0ZDMtMGJkMTAyM2Vh\nNGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8hHdiF/mv1IzGLUiAS2hnEjz\n8BDj0ZGdAqo2V2MGRsOzHRjecMMiGi0ZXviX73xRkysum+ZAWCcPQOtrKbXn+KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVuERHGoT48OIw7oD4zt/OIo5AWUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDRb+dyn8osD1Ae\nQxYDxvEekRMdI8R/aOzufFktdhZzywIgeD08jG27XG165+ra+BQI8iiCRmltlZff\nBlRw1Gzv/oE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc567", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `567` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAbD98F7uaVtTYk5wGE9ZDxf1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliYjk0YWU5LTM3ZjctNDFjYS1hYjRmLTNhYWYxYjJlN2YwZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTYwMjI3ZDUtNmQx\nMC00Yjg0LWJhMTUtZTkyNjgyODVmZmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE0WbG4VvfXu/uD8AhlVgFzYh4zhGpGXE7wrOmMFc/DVqa5Ouw4Zg6IYxPGhV\na9EykP50qhDzXp8/ikg9AMWw7KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQzppiKs5wYaLt9lbHTw5ltjVZmowHwYDVR0j\nBBgwFoAUDIgI6jfJQPZsKxy3fF0iQq7/a+MwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgOM0IQXvobyztxewsEaTaHteKxz/UhmMjFsAYrkpc9vsCIQDC/nEg3Bjz\n/I/nqxjghrK5EzAgOizvJBmiglqGhj7OvQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU1WsR9JjMnw/WsJTFRrCmraMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmI5NGFlOS0zN2Y3LTQxY2EtYWI0Zi0zYWFmMWIyZTdmMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLp/VJYZlJ2KGS0PQ6ApK3TbLcWCkktn+msQK6J3S7Qzi6\nCLZiXQVwGd74P1D7jq8TaZ57aLh/1RVn1Fzm447ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDIgI6jfJQPZsKxy3fF0iQq7/\na+MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV+hFKe5q8ZYuh2GWt5xbDfImdbsU5rHv0RHET/ZHiCACIGe1gfipiQPZ\nfYZ6YIykhVb9vRX9x4D4PHWEC8VIh/Do\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYwJ0I2aygQn6HzfMQV+8tvwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTYwMjI3ZDUtNmQxMC00Yjg0LWJhMTUtZTkyNjgyODVmZmJjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmZkNDZkMDktNTI0OC00NzUyLWI2ZGItYjgwYWIzNGI3\nYjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECCvxR7/4oBuecJ3zWz7kjlSW\nm5KZq2MpsxYQR3YxtdaSVif0UcpdtHAY3udxjR2ma247Xk82GnH8rEsYdMi69KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQzppiKs5wYaLt9lbHTw5ltjVZmowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFeXSZM+q6xcoNJf\ncqL9cOcBJs29i1Z/BPH49blOrdNUAiBjYCXbuNrXsoI/fIv4hIxqbWYdczr9UMl/\nZYtfujz+kQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc568", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `568` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAVeeCD49G8+2f8x7Vzu7a+chMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhOTFhZjhiLWQwYzktNDc3OC1hZjYwLTRhZGJkNGNmODk2MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhhM2Y0MTctMzVl\nNi00NGQ5LTk4ZGUtODhlMzNhMDExN2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWDvYpkrCwB0Nqqa6lt2d0IG6hZUdv4IA8u7gLZDOtDgJUNNGnLkk8i4YqCKP\n9TMYFJCQZ1HByc21TkESol79U6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9mGN9u6q+Ll0v147ScfujfZKK2swHwYDVR0j\nBBgwFoAUQPbuYeG2H/BgnBegSlgLSsgQAJwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQC8MlJU23iVfBY/MkmpWvOa3dO5+VMF4cd24nQ1VIt49QIhAKL9xYzD\nzil8SOf+Nj0+zt1uQIpKEra8yYx9AuHJrSJU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbkznKbANIPFS0x97EFU4h6sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTkxYWY4Yi1kMGM5LTQ3NzgtYWY2MC00YWRiZDRjZjg5NjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMoLdD76Yw1rCBMOy+v6stIPyBYDGEXEdFJg8VLL3670Ax\nbdNG/xjVo3Q601q32hNjYao+eishCojsQVcOCoT/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQPbuYeG2H/BgnBegSlgLSsgQ\nAJwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcKcj3IMXIHZn9NrB7W/MkwghXMmoeAkTIYv56jPzAhMCIQCFmqsRsTe1\nWwIjwcpNFv/q35hCpJFJUF4n3MCXDAtfsg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAeLuTciFaQpv07mD1KQLdlFkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhhM2Y0MTctMzVlNi00NGQ5LTk4ZGUtODhlMzNhMDExN2M1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTVmYTI0MDItNmM3Zi00YjcyLTgwN2YtMTRlOWI3MjFm\nNzA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKaoWnuw3nod+2Ft9YdiAI9vI\nRL4ojxb+iV+O3/PHOvTegjTO46K0JHEhGYtZA3JS4XiiWzgnzDdWAn9gk97GUKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9mGN9u6q+Ll0v147ScfujfZKK2swGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGdj5Gp8XPR7viBj\nvVuZRA0JTYnN2uV/FJLYbPlG+r+yAiBD1agXtWwAz0IxqL9FW68T4AuW4G+Au5x6\nykXPvVgEfg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc569", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `569` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZPz5ubMFnDZjrCdsRFv0KzqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkZTFkZTY2LTUxMjQtNDE2NS1iN2I5LTk5NmFmNmZmYmUyODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ4N2I4YTMtNmY1\nMC00ZDAzLWEwZWQtMjNkZWZmYWQwYzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd2su6bAAbCybJWEehVi9v85QYed5sRPCLxDk7PfYcgZeXa2iaaMbzg3YhStj\nUqBRBROb58UCiuv8OKjtr5OgYqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD1c7xhaiclu4jE7/AzDVMKczS24wHwYDVR0j\nBBgwFoAU//qPYqMlbFbOCVhLieV6S+HRtfQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCFWyo3mmqudft611HZI9/eiTKOKJIj6CZ+Ja9K\nd1bYKwIgBLZ5L5L+5KGMERZs4ffF3JLJ7GlAllLNfX/I3R8lNsc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARXecr9o07TWTtKeMUnPRbq2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGUxZGU2Ni01MTI0LTQxNjUtYjdiOS05OTZhZjZmZmJlMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0Qh+xvDsV7MZwIlwlvhB08eOTTuNU3i/IuCTMPY2BBiKo\n0427JMmSnjhUFSGKSynsLlIXzjEhl+/JvSgF+bFXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU//qPYqMlbFbOCVhLieV6S+HR\ntfQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ7eHlh7XUYbJt+gBjul745XMXQnK0l8uv73xqr2sN5MCIGiUCxdB3FmL\nQUULqwCFYD0+OxqsKwD0saLBxkKKf8ac\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbTD0eY6mBxOV8VkPZggH+FHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ4N2I4YTMtNmY1MC00ZDAzLWEwZWQtMjNkZWZmYWQwYzgzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjk5MDlkMzAtZDNiMi00MzM4LWE4NzEtMDg4OWFhMjZl\nZGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA/zs/54ni+U2reBHHEJ+ZDEG\nQv0iV9TIN3CAh1AxJTI2RiJcl69L9F72jPsdJa8ZIQFUncLY0ZRy+SUvj4foZKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUD1c7xhaiclu4jE7/AzDVMKczS24wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICfgrDCbw0k0QSKD\nCb7xL0dqi1bw5adKUTzeeGA74QIeAiEAgdBldCUcmRlJZijXzXPvwjAI6Ef9dp7O\nkHHwpOVCLyY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc570", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `570` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAWKU0EeKrzvupW6ZCMAlU/fnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4OGFmYTAyLTdlYTctNGIxNC1hZDZhLTE1YTMzZDIyMTgyYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBhNjgzNjEtNTQ5\nNS00NTZkLWE1NDctYWUxNGY5NDYwN2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4tYfB9dWy+r3akqU+ykrAD/+nvRMPpRyB96B1GKTTUC7Vbh2zwp/MN90JSm4\ngj0+zO76d9e5BB0YNGymO0acDKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq3NTYXojCU9mOJwKR6H2imdOYsUwHwYDVR0j\nBBgwFoAUIxDC3HHcvZf8PyUcjm8CYs2cDEIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIB42hqAnpXbFK4i5JuGlV0D7aT/hanGFs+vwbSeK\nSD3fAiEA6mpNAS8hrajZEfucAT45fuCMh1TL7vlYs/quZGQMPzw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT3s5tV7AzHFO4GbA65PtEuNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODhhZmEwMi03ZWE3LTRiMTQtYWQ2YS0xNWEzM2QyMjE4MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiSQIDzD/XuOvoN5yS5seRhQe4VJgatykbbE+NZIxcumLy\nf4hwfQZAMdcZEd4S+ZPJK/GxtJV8vFjcBtbkmNdko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIxDC3HHcvZf8PyUcjm8CYs2c\nDEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIRNv9+UKzrEnMYN5rVJ4CQ5l1+9SfUY53GMtWB7srf4CIHMhLnRTQ+iY\nzwtCL/YGAdmT6WXQPBkuszbwimyWv+4t\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXSMv/EdX7iwQ7amqTSmcYEgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBhNjgzNjEtNTQ5NS00NTZkLWE1NDctYWUxNGY5NDYwN2Y3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ4Njg0NWEtZmJkNy00NWQ2LWE4MTQtZGIzYjZlNGY1\nMjM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQZre7C0/B+gOTG8h23V+SQye\njevSNeJFi/1L+7bK9xr8sBMH8YCN9prpvfRyY9LA932HczRE35spTsOkQIqMCKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUq3NTYXojCU9mOJwKR6H2imdOYsUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCWCDQ+SmQgMUdr\nCa6rSA4SNdpNh2nxQ02ORuxl0jw4eQIgV6KFEthz0fmVyq63ctFNM2PhcFnUuYwf\nBsr3vbATlM8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc571", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `571` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAWdx6y7XrcNn4EkTNivdapcpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNzQ1YzZlLTc2YTItNGFmOC04ODQxLTViZTc1NjFmZWJjYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQyYjU0NWEtZWE4\nYS00NDYzLTk1OTAtOGI2NmQ3OTM0MGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvCt5PZ7695G/jEprtWiQcC77uaMZkWOy/K/Ko9/kryhztgLcZ+FgtCdvZxSk\nC0R4DI7pMcPptSQOVvU/QpqJd6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU05co8mdmJ0Vx4+I4/XiLifTIj+gwHwYDVR0j\nBBgwFoAUu57TIz5tF8wwixF4DAYMji4gCJYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCRt4eC77NJogHJu3xT5yOzWuA/NfXSR5w4w/NOAsmjJgIg\nIB9uZTaisSXo+kUSA/Wi9LKVqCVANbhODhIwL2pWAig=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAan9LBKxHTXpDCyIQBQFIyq7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTc0NWM2ZS03NmEyLTRhZjgtODg0MS01YmU3NTYxZmViY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToiXW54KC2psb7zNUVNWU/7fmSdltO2SzcO1IN6TEsrWQ7\nhwkMPsmTI/lf1dBXarvUBzewwgJW8nS/kLdUD7U2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu57TIz5tF8wwixF4DAYMji4g\nCJYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIgHhra0HS6O8FmDsqbM8qzCVYZtOOULedBwY2QNejFuAiEAz/376Ntu\nJQQyf3f7epIv3zafjReMIJWDsUt+SSKXr9k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAY2u2D1rwMWx9n1hBMBKAdQlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQyYjU0NWEtZWE4YS00NDYzLTk1OTAtOGI2NmQ3OTM0MGQ0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTUxNDdiNDEtNzY0Yi00MmRjLTk0MmItNTg0ODRlZjBk\nOWQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtzVk5Rr89I2iUs1sSJfTEnIk\noTlVIzLIil8DdYiLIzqgc6TZTajij8HSbDXh0rcP4tWD4MtxvGxz6d5lA9qsYqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU05co8mdmJ0Vx4+I4/XiLifTIj+gwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCHyQttU+3uxh1EbOs\nq6YiRGoYPh7BSplWvAap5cs5zgcCIQCQf+0SfZ78cdanba6DbQfaNDXkvAEF6dxq\nZHUq2fBQOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc572", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `572` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAcnipeks9MD5mLnBWPVcPpU+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkZmY5ZTcyLWQ5NGMtNDcyOC05MzUwLTUxY2Y4NWIzYjljNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY5Mzc2YjctYzY5\nMS00YjM3LTgwMzctNzNhZTlmYzNjZTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHf+q4SNQjwOHd75BRUwMLw5nX1tNlyRcZSPndauwmBvbE0zyekGZXuy/92Wi\nBvVjTnkV1aDqtU72V73eBbY3NqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU690nehngelFoKWUG1CUXZuEj61wwHwYDVR0j\nBBgwFoAUkaliXBwpLyP7V5BWI1UgidUJh08wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIA9SFTjMFjV+KmxH7B2aHaK719OLT4vN\nslcJsa5DskNOAiAfM3hh0HKYi0feaNmwCA0UsWCBUhWQp1DARjWl9dOyzA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW5+znlHwW272FAXE5LKwiJvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGZmOWU3Mi1kOTRjLTQ3MjgtOTM1MC01MWNmODViM2I5YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSgELC5uMc0oFbatmM3pMRIbPLvEKe/cOzwn7UWuz+MR9Z\nsiMCekdLdWwl9/IIoTsFYyO+bb6wiF9eRAoEtkfUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkaliXBwpLyP7V5BWI1UgidUJ\nh08wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHKfZkpWRJZHBGY/LP4kfIwK6cVCwASrrLi8Ugj6icz4CIA3S/UPBE2jr\naKDfnU6IS6ImzY0UMlcLW1j7xIq/UB8/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZf2+Pb7R8y1aJyE89CugDaJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY5Mzc2YjctYzY5MS00YjM3LTgwMzctNzNhZTlmYzNjZTczMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjgxZDBkMjktYmYyOS00OThiLWFiMjAtMjg3ZmVjNmVj\nMjY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN45iHVAM9tb0iSiBjMWtiNkt\nZMHk8sYJmkDdYfwyIbYX0hC5UOzztN29iQ89sXMfEcOTyKVY+5A9vkgMGujZmaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU690nehngelFoKWUG1CUXZuEj61wwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBBW6hZMemIbuhht\nTA7vf13MnWtZjD43CadzL44qMRhlAiB2OQGsYNhSPyJCQq0hxvBlyCS53eAmNZOq\nJiSvU3ISQA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc573", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `573` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAe0ZJufCnkw85xUrQTOzA9smMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2MTkwMDg5LTBmOGYtNDBhMS04MjQzLTc5OTgwMjZlYWZjYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNiNWZkNjMtYmE4\nZS00YWJkLTkyMmMtY2VhYmI1Mjg4MDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHrWC+sYqN0JdJDYMQ1JjQ98LZGKLiYVbGahWVAKS9lfzsylt5vAlI88Oi9qc\nsWb1lmta5xxatrQe57YEQmpEr6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5X50wAQjG/eTTOgtiGhm6L8U81cwHwYDVR0j\nBBgwFoAUXVN4SCyc99Qczp8Cdx5n49h0SD8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGDpeuTmOId+TVo36MwO9So6R4PxPOeu\nnj2JvgGvs95kAiEA9Jn8rBr2TfT2HyOIH1+m0PlMvxqoDoK4gtbXUDq/B5A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQkq3BK1GI+Hv/ZWOH2BHngNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjE5MDA4OS0wZjhmLTQwYTEtODI0My03OTk4MDI2ZWFmY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFFTen2ZQlbYT2nz0Epm78GWHquWgyDW3k4+PCxeBt8iu6\nZgnpGJpbTPpJuHRwl9prScu2piVX+U/rL+5PbubSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXVN4SCyc99Qczp8Cdx5n49h0\nSD8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPUHFh2DvtJ9VSc/xNusbI96gb/8TLx8R8yArFxkW1jgAiAJx58FHt1/\n/Y//muLHnnurw6sfy7o26NqfYJyWRxh/0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAd9tozcjQnvKjS8pp0ZwTFlPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNiNWZkNjMtYmE4ZS00YWJkLTkyMmMtY2VhYmI1Mjg4MDdlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2FkMTExODItNGE1NS00Yzk5LWFlODgtNTdiZTJjYWU4\nYjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9LOM2hcGbJiUm+aab7xwDxuh\nvNbeYSuR01qx2mJoJOUMqncCcPTuCIcE+ITzO8tt1kjzYEc1slptNIibFFJdYKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5X50wAQjG/eTTOgtiGhm6L8U81cwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHRGkYBcT4b7G9yB\n43faG8QdsoJ8H0NZ5Ge1ckBG5tBIAiBelZz8kYyNqk6fCDrLs82/IKPUXkfx81zg\nUPTdm+fIdw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc574", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `574` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAa64D9VmRqMYAAb2hmuHD+gQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhYjgwMjRhLTMxY2EtNGJjNi04MGFhLTcyY2JmYTNhZDA2MjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk5NGRiNjUtMzA0\nYi00ZTZlLTlmM2MtOTFmNTQzM2Q2NTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuYz77CHDhMupcuYVKAgW/ikSNIbrogv13Qzj4Zhbq364iL1CSyBS2X9eu/6O\nEXhXyACZqfwpKN50ewJBSMn5+qNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPIe7Z7wO/iDZ5d+86n8IBhVUUsPMB8GA1UdIwQY\nMBaAFIDssCCaDNaoN5lzzVjqlGAmIUX2MAoGCCqGSM49BAMCA0gAMEUCIQCf1kdA\nY+9pSMUWy6vKtqDx9DdaaT3LuPUghOuMRilJdAIgBZaXBQZMp4bf2w/1+TBWGiFU\nHjFl4x42ADQVs9bOso4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQadE+PPGukyAaCIpvqvc8hdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWI4MDI0YS0zMWNhLTRiYzYtODBhYS03MmNiZmEzYWQwNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfy2qQ/UNiBhx4FAHUr0OfBul+RFF4YZ+eUzmZ5xrEbs11\nyec3plWr6YdtAdFL0J+SeqzrZkVEYrfatJcnruB7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgOywIJoM1qg3mXPNWOqUYCYh\nRfYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOfh6VpSy+jvgX3WzgDQc9isztMSLvTf/DNUWREomtokAiEA0/yCv6TJ\nKSr68uZfhlgyak0LhKm1cGGdXmYABZoHaN8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWTPA9y4K5s09MMUGyAcsJRdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk5NGRiNjUtMzA0Yi00ZTZlLTlmM2MtOTFmNTQzM2Q2NTBhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTA3YTkzZjctYTliOS00MmNhLWJiMDYtZjk4YzU1NmEy\nYzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnKB9aktyTE9e2gBD4INIwZMM\nO9lCgLv4/O7dLbUIbphNlKyeHjYmBgceQofJW1sif/noJOB+H4EO0fLFkgp4YKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8h7tnvA7+INnl37zqfwgGFVRSw8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCYxo8v\ndarSQFGLZt2sdkFWtaPedmi5sLvTUs7MYqtjuwIgD5LMKyaioJlxDYpl9BTDs/rz\nXAQmwxY10XdKDeGe/Kg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc575", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `575` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZvlDa0Ak1FAUAbmOEuPqUX0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjNThkNDM3LWUwMWItNDVkNC1hMDYxLTY4YjM2MWRiYzY4NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUxOTAyYmYtNjJm\nMC00YjMxLTg4NTUtZWEzNjJjYmQ1YmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPld9Uj7fhd1Leq1/E6g3jsMl7PdvH4ae/iRKAKW7sMqamGldUwtVDhlYVNHu\nabphVu08zPKkMZm3x0jlZf83AqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPd3Vbqzhk8CezLJF7szAEf1noW/MB8GA1UdIwQY\nMBaAFO0KfeZYJziFCc6itgUeIG1sYVOTMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAY33Xiq2d+xe26fHXZ2xnJxSPaK3p2i97m\nCChXpsY7pAIga2+sgQgqojQi6w3RtpAeHKFoijg/YcPFefVJuJs1UJI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcv1PkfmIbWHEkPV1VBjSmjWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzU4ZDQzNy1lMDFiLTQ1ZDQtYTA2MS02OGIzNjFkYmM2ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATL99vouPomQ5mCG51zMoW9wuLTZZHIlALe5SsLMl0nRTUV\nDLP1hG0ignNE5DtOLuhtMaFEzHTtSxUZ883PChUxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Qp95lgnOIUJzqK2BR4gbWxh\nU5MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN6Hs0dXQv37Tf/yJ4+DaAV9GLwum8DPoWWlF0WW3x5OAiA2NEHO1YdJ\nJmt7Du4Qe7/SmCH65xiNOSTO18Ew2HVjOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAc5tLkF0T6M4XDobHt6QxM5iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUxOTAyYmYtNjJmMC00YjMxLTg4NTUtZWEzNjJjYmQ1YmMxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzIzZmNhNGMtZDJkOS00ZTNlLWE3NzAtMTkzN2I3MzA3\nMGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4/RTLNy2OvJc2MmEAdcDuAXe\nbrIk62GM1ozClJ5OYF4nQeSDEpRRU/m/KlEfoXg3OV3/oFE3QrH3tNMxDKUCh6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU93dVurOGTwJ7MskXuzMAR/Wehb8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCICKHprey\nTqfNzKGLdobyUAGZt0YRw+i7xl+XkMV4LOr0AiEAskBlpRueFD6miDWyI/xbChIm\nbMUukANuBkFDI4XBI/s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc576", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `576` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISASBPDzTVpdJ3y+b/pz/c9b4wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMDMzOWI4LTUyM2ItNDdiZC04NDIxLWU0NjM5NTk0NmJmNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdlN2M5NTItNWUw\nNi00YjY1LTg1MTctMzMwZmMyYmEyMjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXPDzdG83J/pPlN7DZUNOhWCuQL2Xs4EhUagYDVqpTS7vMgJGOhe1b0b2A6DK\n1mMHKdpody+J3xI2QVu+dO9uXaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJLDAb3QJmuoAS7XFtvj1veKinoRMB8GA1UdIwQY\nMBaAFN8wpNhgYNSppOa5RCRcOmJPJ1jSMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiACRkAAQsQ/VP+0+welpeZnQIvOMFaJnCSR\nU1DtQsegpAIgAt5Q59OdOff1tApRY90HRCDy7goax2cZq+wVVe1dBgQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATqiGNErzeLUbJ731anmkybTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTAzMzliOC01MjNiLTQ3YmQtODQyMS1lNDYzOTU5NDZiZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7f61dUukRtXM/iGamhlnGxkZsjkU8M6aAcP9fhTTSmPam\nQuXJpYCGmLv4hLs91lSVxuLNrzuuNRUlkVxn16KLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3zCk2GBg1Kmk5rlEJFw6Yk8n\nWNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMybeRYP975IgKf+2agJXoEZ49a7VmbRSnSrvtsDvH3pAiEAyspRV8fb\nJLXbCOXHYi8e/zUtPt8m8UFZhZCDtWEImm4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQrCEnYaZZtADIMftxNJoteDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdlN2M5NTItNWUwNi00YjY1LTg1MTctMzMwZmMyYmEyMjQxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTFlYjk2NmUtODlmMC00ZjRmLWE3NWYtODI1NTk3MGEz\nMGExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1MII9FtdzgCBtBxfMMePHyNO\nfsU/kzECI6l0XMlMWu62pQtsYeVeSQw75C36eM+pLFS5vfmumUVA185ZmbuV4qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUksMBvdAma6gBLtcW2+PW94qKehEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBaU/qb0\nFmWlZnNpH2nQTAAXpKgYpRjF2MTS6etwEeDLAiAPCH/ZcVrudfmVunvWYnnGpCoc\n6y3rkv3mLVTW4giKig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc577", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `577` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAWxCFEpqWLWplwAn95FlDFTBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNTI4M2RiLTMyNDktNGExYi1hNmM3LTVkNDRjNDdkMjQwZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzk1MTRlMjYtZTFh\nYy00ZWY2LWE5OWItMDdlZjdjNzIxZjcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzCIpBua7+oyuMW4JVg7egxJ5Z2MMAWNVtrXRGX/g1FEmWSkykRMhlct5LnUW\nOWY/iLNbk2I1TXWcIdpmm4hcEKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSlsdnwceZF3GWezTr1RBTuMvFWwzAfBgNVHSME\nGDAWgBRTNH7eG+aJGgTA8Ou4KRs28+u4CzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDo9r82h7URdlpM6JRh9bsKkjvlujKu\n63TKY9gzpMiBrQIhAMB4T/laZ/JfV7oPw0DrrK37aqdNuKoCUPjZd7P4Li1P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATI8gftW0zLmrJ1fBcuvPhagMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTUyODNkYi0zMjQ5LTRhMWItYTZjNy01ZDQ0YzQ3ZDI0MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQD7Gxyty9/b06kvwQqJcXGF4YQmZaZyT1bKCNDL4OeB4JE\nKFGUlZH++dBw5aLf9fjHH7QhmUVRWXd0Xe/e6o9no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUzR+3hvmiRoEwPDruCkbNvPr\nuAswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIa6aOlpjFa0TYLbbdGfBBON25tAXmycskcnVfP5Y1MeAiEArg+UVns5\nvbLZm6xbF3/CGMYsBhBK/x5BCSyAHM8I2kg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAeZNC3ItKfI1kb5Ls6a79S5uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzk1MTRlMjYtZTFhYy00ZWY2LWE5OWItMDdlZjdjNzIxZjcxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWJlNGMxMDgtYmIyYS00OWFhLThmYzEtZjBmZjBkYWMw\nN2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgW4EGqZBuIepfMw3uaVIZ/bb\nzVJ+mIjRZMmuUtcsnU/NwX+DIIvwcRTT7Y63x/4MbvP4SYGrL8rgb3R1Fo8HKqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpbHZ8HHmRdxlns069UQU7jLxVsMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIHwL0onJ\nXRAWvPQw1FoLm4dqPLirl/TfL3Fzfi82jgzoAiAaVO3Ik6JW9e+kH4zSDQponFCT\n3ybjfUCjqso2zyr1eQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc578", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `578` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAQLtRIhL1taZoZe8vlfmvrCyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhYzEzOTM5LTM2MjgtNDJlNC05YTc1LWRmYjUzMTQ1NjRiYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTllZjFkODEtMGIx\nNy00MTlhLTk5ZTItYjRlZDYzZjI3NTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETvgp2n9M+sTXdDKQ0jQ1k4+IS0QIo8GELTAxZ2yd1w1B1Aff0aqkETI74jWF\nOll4DfRCsfH80te9eIKcS64rYqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfki/15ebQQw6cp3W3u0oMz2Ytl4wHwYDVR0j\nBBgwFoAU0/w4xajYi/2O/SaV5RCFNT/mI2UwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAs7UH6oxRPOvN\nhXO+GBcX3IoWvE8duz1fbcqnF2Z0mz4CIQD16ZzJZAjSDwRwfUXjcyPnB5tIZSET\n0qY5PNhtG4YnGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeiN2YOGN1ztfijjBbf1x+0fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWMxMzkzOS0zNjI4LTQyZTQtOWE3NS1kZmI1MzE0NTY0YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/8UrAc3ZEf5CJGOe8vzJtzy9I5U+4N21+mEyNWUEPd19p\nDGn6RAc4Z+FGKbc8DPYFGLZSy+ID/vKFptqfiNG/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0/w4xajYi/2O/SaV5RCFNT/m\nI2UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALjwkCA20qeKyMiTOgTlPIQ84GFKB0ESe6UhTIit324DAiAJA+yt4fuz\nSWMi3v1xTRd6NzkTHjusf9cAVaPoAQ/LHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAZz0ud5xSN/lYSSI4xgq+h1gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTllZjFkODEtMGIxNy00MTlhLTk5ZTItYjRlZDYzZjI3NTk3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWFhOTNkMmEtYjI3Yi00NTE0LWE0ODgtYTkzYzlkMDA3\nMmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkCPlH4ecBqPM5l8cH539K6GK\nC8Y0ArTC2o36EdlyAF4G76TPFTDhW7NtZqce/kELzLWZZVpkNaaWZcqsAM3sHaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfki/15ebQQw6cp3W3u0oMz2Ytl4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDx1OXTU\n9s1TR0rxqi7hwmm5bj2H7+KIU+RqHsySMwjyAiBVVvPdD9R9s5NbpQS900MaLrnD\nBd6tncRqHU8YvAbQLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc579", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `579` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAe6kEFNfXyh7KnmdmREEodaeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjNmM4OTAxLWUyZGEtNGE4YS1iNDFmLTU4MGZiZDVkMjJkZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk4MDk2MmUtODkw\nNi00NmI0LThkNmMtODVjODk5ZTI2NGJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET9B2IQ9323qVsbGliK9AMXQlfmsWys37xgk/Bb6QrsHyduPrAFlA7i5P51S6\nLpjQwM6gBRIcwrLWbZUhGofLG6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvdAZ5tDmOdlkSzc+F9cBb1zYaI0wHwYDVR0j\nBBgwFoAUNGLjuYQ6rF55jFS0xgXTghxyqfIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAiNNQZBEoyw1m\ngtwT1DLds3bw7CltD/+tXYEfNHuIcMsCIEVMHnw/RpCUB4bYRArdWpfgeMd9Kg09\n2FHvMnBpS4pH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaqtaQUTOKLiXnMOsErtnRc6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzZjODkwMS1lMmRhLTRhOGEtYjQxZi01ODBmYmQ1ZDIyZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATd2xOR87co6lUQNeubQhHON/Ud4N9TsBvzR2RwP5zGTjkQ\nvkI7GLYWa2/Gf7MkwPYhSIMDnUtWzrTzUgPfvAoso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNGLjuYQ6rF55jFS0xgXTghxy\nqfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd4jEUQNTCQWRIAJ4Mz3p5v/ncibCzpNdthLgww7n1x8CIB7kaDZAgou5\noi8fToT3W6Fhfqkw/8vzwbMBifec0E2v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWnGJXUyAo7D+Vo20t1DKHZXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk4MDk2MmUtODkwNi00NmI0LThkNmMtODVjODk5ZTI2NGJhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzQ0YjcyZGYtNTM3ZC00NzZiLWJkMTgtOTAyZTFiZTAw\nMTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEz/BISNxG/SlkpLz59NMMW9+r\nv7i81OlICBGUdJCjlcWAUP1dnsMzJw9cLobh/597PcNuCxHnwF2vErcf6ZsEmaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvdAZ5tDmOdlkSzc+F9cBb1zYaI0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDh3NIc\nn0qD3BqlTn4LPs9bQI2hBRj+E6boGAeY7h0LCwIgUzzdorLdck0vNxFiseCraRkZ\nj27rtKFBOgJUv200kds=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc580", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `580` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAYuTqUPUlDxxYU1zBfa/aZnuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyNDZkNTJjLWJjYWUtNGE4Yy04M2VhLWZlMmJmMTBmNTU1YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQ3ZmYzOWUtYmMz\nZi00ODAyLTgzMWEtZTM4MjZlNmZjYmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx4HRZfqb9Qmnq2f+NHp/1jqlV0fTLmGphoMP/BnXfCJk+NpPYscIuiev8Bud\n5emAmw5zTG1IBK+9PxJaKTowjKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZN5oLRX45vYLlzuqRyn8L65ckJMwHwYDVR0j\nBBgwFoAUe1JEEWcSqhN48lqM/m/55LgLzPAwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAoqSsjklSEayNY8R413QR\nYoZBiUJEE6tZrneGgOsQdVACIH/uzoixrtTyEhKPIXZEHf7YY1rKR3Q9EgXAerec\n971Y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXHSTuO9f2OIssqkQ4dpm8XkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjQ2ZDUyYy1iY2FlLTRhOGMtODNlYS1mZTJiZjEwZjU1NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjoFKEV4qjtknDSiTRFokePtQQb09pJj6vjVzJMDmpsg30\nwq67ov0jgGmn3Gcazx6gutp+nj+tM3In+TILexCWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe1JEEWcSqhN48lqM/m/55LgL\nzPAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALjRi4lcCyhCrnM8I3QqfnY91Ldb0pYPFXhDI1R/O+6kAiEA6LzSXmOC\ncsA5Eqf/hgLHJUTyFE9KJD5Ai56sY2gSTHE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWcLjrJ3oOevnFXSTMna1/TKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQ3ZmYzOWUtYmMzZi00ODAyLTgzMWEtZTM4MjZlNmZjYmI3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODUwM2YyOGUtYjVjMC00ZWYwLTg0YWItOTVlYTc4YzY2\nOTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEO/XbsJkZItbbq/XhvzW47pLv\nTURR7yEcWPz4Bf0y0Rg2xvXBGm+wxzdyT6IiqxH36ZjIR922tpFTfodz7oAEsaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZN5oLRX45vYLlzuqRyn8L65ckJMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDk6+sD\nHjDS9aJU4EuCIJ/8A9w6rGQF1zT3pEUKjjprJgIgd3jaC5OJ9sOYXc4NtO5fjlu3\nqAQlU7RpxrBc6fBktns=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc581", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `581` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAUftQj8NdMMV/n5zi0vbLx6sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlMjNjNzA1LTc4NTUtNDM1OC1iZmVhLWY5YTUzZDRlMWJlODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkwODlkNTUtOTY2\nNy00NzVhLWJhYTctMmMzNDBlYWY2YzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP0x3LXx0tUBsto8+24qgq8OgK5gWznsDd6hEhedyWfFHPwXixwMMjpGphZyN\nvjlhT3AN1Az0u/w4EM8otkG8WqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5P1S9F+9ckjdvnn/maT9X36thkQwHwYDVR0j\nBBgwFoAUN8SQPjSdXXKKcxGBj4UV6sw4lAkwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAwlTr\nntASsfsj/MqgljzAZL/pQSF0JfsKsS9c4Kgr7iwCIBsfDCyDAGAQqGie4qO+AEil\nf8bAZ6Jp5Ij6YWjaco/n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASc7OdfOuDqiSKqc8YO9WeJ6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTIzYzcwNS03ODU1LTQzNTgtYmZlYS1mOWE1M2Q0ZTFiZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoflDUKmv+gFObr93p10msV9nTWS0GNCO0rrTx1fZM76nr\nZVbGGJAd1EzAECw46sPc6QzuBKeKk5Tobp+EbAhdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN8SQPjSdXXKKcxGBj4UV6sw4\nlAkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKnMqhJNyfkbn5W6oYW/fLROngUsyO3zVw/RlOtkUM3AAiBFGMmsRr6g\nadW9aofWd+a2ie+nYCPloTzjvkscp37t/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAYMaR5dMcBKZqdweE2JgjVVRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkwODlkNTUtOTY2Ny00NzVhLWJhYTctMmMzNDBlYWY2YzEyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2NiNTgzOWMtMTgxNi00NDdjLThjMWEtODUxYjI0YjM0\nOGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2mopOPA7QcsqM/OXOoK/7r13\nboEUJuwU6XGRA9GF3kt58wcURsy+agwIXi15//G9Ct3ADOSW0z64OyHIpk2BDqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5P1S9F+9ckjdvnn/maT9X36thkQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCrij1W\nvASRblZucYwoS3c1K2KcUxyl8V1Uz/xPD+HVHQIhAM5lerBL5ZZsvBbM2CKtdCeG\nHuDAfPhYMDlLNHphlKXp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc582", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `582` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAfMb7JOB/Z53GJXB1pVmCue2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyYzIzMjA4LTNkY2UtNDk0Ny1iY2VhLTI1ODlmMmI1YTU3YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY3OWFhMGYtZWRh\nYS00YjFiLWJkYzgtMWI4ODA0M2NkYjBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGAmoXdBij31K6mdlOG+6IXpV4mEDZ3nrwjQqztrmK5wYo7r3cAfL/DTAMuvf\n5nekhHdHVsl9yest1pJmbtJWKqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUor+9rxYYyxQkKDck4Fbyp48LsKYwHwYDVR0j\nBBgwFoAUa/6GIRRM01Par8GqBnLsLuZLK1gwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA2SAI2\nqsz1+Z1f3dW1q6r/PZ8kJ4piLTxFFRHdZVZv7gIgNRJC0N/MUuRBUyyVLcqVDOxj\n3wiGz3PZK+ckhRox/aE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdg6aU684hRcc+MJz3gv8E2XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmMyMzIwOC0zZGNlLTQ5NDctYmNlYS0yNTg5ZjJiNWE1N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3qevOjBfvygiC2vuRUn+8WRpym4k1qlVXpeVj/ZbQs/bD\nCy+OOrL7paJFPX4t8jAf4rGAYEpQckj8Gb4ovQwCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa/6GIRRM01Par8GqBnLsLuZL\nK1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGk55vrSEAIXqO/y/mCWIsPFGLbOg848gxM/5CVteHPECIQC2wA54wAQl\nS6jSuKgbQPRUkRx5lUEPKMTcXsxKaJMctw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWl45Vv7LBrWjHFh1lTpmw0EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY3OWFhMGYtZWRhYS00YjFiLWJkYzgtMWI4ODA0M2NkYjBmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWViYjI5ZjAtOTFhNy00NGU5LWIzNTMtMDAyZDZiYzRj\nMWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESKrA0RqEXDVPW+vNJO3T6tji\nhB6FeMAJCsPyR5l1G3uqRgBxwV2teTkvtluf7Hj6QcaTPJkMpxjKPO3RoD7UUKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUor+9rxYYyxQkKDck4Fbyp48LsKYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDl93db\nvU7lpIPaVzhx2h7np4XqsO4PeTsYGoL9abS6AAIgS7pX1LpNFqgTPssCyVEeNSAs\n5rggo0ZeJoPpIjWILo8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc583", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `583` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbq+rVUmtigISAuMf8ZlHOStMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1MjZjN2U2LTIzMTctNGEyZC04YmMzLWI5ZjA5MzdhMmJjMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjczY2FiY2UtY2Vm\nNS00YjI1LTg3N2QtOGYzNTAwOGZhOGEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF/2cIyvr30RSmZOtXE4GjQ5zwwtziHG0OCn2ugnPajNOvv6Sp38E1A7PBuMj\nMpblYcztxj/6mEW018ppo1Jn3qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJObOnPzLeK+TMHb24ogE2eBec3cMB8GA1UdIwQY\nMBaAFII3L8LWyKZTMhEx/p6FjwyzEtHLMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAgzTrkYj9PtEoXJyJWoYTzcEbLu19+pyx7\nQ5PZFpinWAIhAI7/a9axz933gyCTqx8v5FgBQuGbZZuTK0hgogcHgNB/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASuo6Yj00HqbOq0mESHPTCZOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTI2YzdlNi0yMzE3LTRhMmQtOGJjMy1iOWYwOTM3YTJiYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZ3JjvOBVUEnvf/lGH7fmCfptGgpV6GHlYpAy8hritVJJB\nbUe/ahOJD2s8MA9ZYV1nuTSBbtTngfjMkmF4HZkSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgjcvwtbIplMyETH+noWPDLMS\n0cswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUCpbvk/My0lDh6x9YmepspsuLSbS9d1LacaDrRaYZOICIEOy+VeQmte8\nMWU30B314IzAUSqKAmFoQDQ9sqe4r30D\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAazN+82t9hJHxKR0im2S605CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjczY2FiY2UtY2VmNS00YjI1LTg3N2QtOGYzNTAwOGZhOGEyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTA1NDg4NGQtYzg5ZC00NDE2LTgzNTgtZGYwNDljNjc3\nOTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsmLau5K829HbCSso+XmSNzQO\ndmllcm5OySHY1bJBz2z6/zKJCFKvs2vAs5QjfXPBOzwX5E0AxEnSgdrZh/4oq6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUk5s6c/Mt4r5MwdvbiiATZ4F5zdwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIB4nBt22\nUobbhBnT/sQFoY0M4Ols+gj5cYEyqB/AORBPAiEA6jWdGyadSd6cXF8TUadWhYFN\nWYe2k5ieS5RIBvrHkl8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc584", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `584` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAXQoAmX5tgmzc4S+rzjXTN8KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MzI3MGQzLTk5YTQtNGYxYi04MGE0LTA2YmQwZjU3N2FjMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE1NTExYzgtODdk\nYi00YWE5LWJmMmItMGI3NzVmMmVkYzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeiT0IdI4ph0VJ9h7eK28UrQ/FwnU/+UpVueL0SnOqOTXXei3S5d9BMFxZHb+\nOKRf3lNfPtSovCQPQkqmfI0JbaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVuRGHrcfw8dvbSyucZvzDImqpHgwHwYDVR0j\nBBgwFoAUit5aprqn7BTh/hIsv+VvjRoekrowKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJsdK8m1knr7\nxac6f/qzN6kG+zmkx08kvyKCUDUnmxZBAiA0kgYWQsyn4hOjXYKNXsOPvRRJLf9V\ni/P4uUTJRpcMpg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUP1wkRieq3TRAe7+8EO0T1CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzMyNzBkMy05OWE0LTRmMWItODBhNC0wNmJkMGY1NzdhYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR02oj4OasRJUkX48affK20iYel3oO1jtycObOCwUcDAqB5\nCX2UgBm59nMJj1SlSx7yh424R7fBCQuFQ8wjVpQeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUit5aprqn7BTh/hIsv+VvjRoe\nkrowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOFXo4KRNnchEXXwE98GlL+Tf6gEoLjWmB/VVs/HyISJAiEA67Ujh2dn\nkFJZE9VofjDCpMgndxXq2qY8gH1oZrzgBvQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQfBOI6O4mhowU4a52XlvdJ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE1NTExYzgtODdkYi00YWE5LWJmMmItMGI3NzVmMmVkYzU0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjdiMGVmNTMtNmUzOS00MzY5LWIyYjAtYTk4MzAzNjk1\nM2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdQ93Z7/GmWc5PIJs9fIL1Of4\nS0dYzAxGsnLfizrSSoLJjmXMB3ohh7dO/IHgxWi/cbZ0Gdom1F1jOh/IEvOG9KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVuRGHrcfw8dvbSyucZvzDImqpHgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDxN7gU\ntqbSgYiP2s+wVnYCWJv049vIzDY0H2uCtYDkngIhAOEVcEJ9ez51XIYVjw8FB14U\nhlGV4GC8n5rmMOShWhcF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc585", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `585` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASERjE0OTuGDAuRsfbPckl94MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxNWZkYTFiLTNjYmItNGI5ZC1hYTdlLTBjZjgyMGVhNmNkNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNlZTk3NGItNTZj\nOC00ZGEwLTg4MWItZWU3Y2RiZjU4OGExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEugaj+SbkMVmuqUIcAMOt6GXtSVMWIkOdfNACJ0e40kPLdlyqbgEi7zpj8/zp\nC7FFKV0FoFRh9lLXzc+2renJvKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq42JeA9/AzfxJAQPK3Jn0djQsa8wHwYDVR0j\nBBgwFoAUPsh/intNUSHXh3bcVRMQBQ6DjqMwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgYVAUlc6Jk0g4\n8tgeBqDkM/pf5izwenJOYHyClfY+TUwCIQCV9Sxx65SFb5cVh9JaisicQZaXNYyx\nbworBx4QhIxe9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ/MhQ6yXuWGWj3D4xmFjuemMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTVmZGExYi0zY2JiLTRiOWQtYWE3ZS0wY2Y4MjBlYTZjZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2ocoRwFho34PUNfkkofMcXeh+vi4CEKKGklS2wXAEUPJf\n5gir8Q/AMpsIXS2LJafGvEsMb0JQCR24zqlBBGgto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPsh/intNUSHXh3bcVRMQBQ6D\njqMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM8R/nXq7hUE7hg0uWjFxShtW8sERxo7ALbHGQH+Tfd+AiEAwLe0l6li\nxrV6s3XLKeaFZAy2cqf/JDg0EOdayzKsiyM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWGjhp039bhxXEo9F1YctYPLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNlZTk3NGItNTZjOC00ZGEwLTg4MWItZWU3Y2RiZjU4OGExMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjdmOTk3NWQtYTBhNC00ZTc5LWFiNGItN2M5NmZmMDA0\nZjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEh/4/Ak2VOWXPZEDknY9AIM7B\n90b8+s0i5iEsA7g4xyB84oUo8VcQr5Tns4MCBHpK8+OupYx72U/COsXGBqeVmKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUq42JeA9/AzfxJAQPK3Jn0djQsa8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBUL/VCR\nz4Dq4jSkjdnGAnwx4urX/CXbFO0KJo2Gj65xAiATeeRdjEJ9MEQCcLnp5n/WS4MW\nPCOu4WmqB1J62SYbcw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc586", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `586` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAVMwjo6kXS5CnLOXp2LW7w2sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMmFiMDU2LTJjZDctNDFhYS1hMmIwLTlmMzI3YmYwNmVkODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc1ZmY3MmYtMDJi\nOS00MzViLTg3MWEtNGE1Mzc1YjMwOTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmjp6CE0daie9Q7y/ENYMT7I/BqwQsi6b0BSrLbdeC2eX4v7uaiAhYGHHyjmR\n4yTHyl+BbETJ313kyqTrwbggDaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYKYiwfeK9Caf9GBfGBgZpiPOimYwHwYDVR0j\nBBgwFoAUS85xaoWot9l8/vl8omSHZwGY3ZswKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDdq+UX/2GW\n9IZbpoR7VStG2+4rLdtAOLUtc/pcWFdH+QIhAKgYmZtBCoS8Wa117KVB4HMp+BbA\nO2tGvv6A3qauIfgD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS0uS5vnVWdytVFqnTEeY5Z1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTJhYjA1Ni0yY2Q3LTQxYWEtYTJiMC05ZjMyN2JmMDZlZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQLz3fJVlmGWl9KnF9lvMWl36+L2WDqZ7PRX9SKKNYktFw\nRTzvxOLuNkr0q65EYh9erdYLKIjk34yIjswLaBRYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS85xaoWot9l8/vl8omSHZwGY\n3ZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSZr7OrAwqz6a3lH7sYFZtchz0rN7LwjNp9V+8KrCtMUCIE9Pv+sGC0dg\nUknW3HVYPIwGswrewuoLqPZ5HmmuD/er\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAROPKvAasvhVV8AwWGDdnuXKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc1ZmY3MmYtMDJiOS00MzViLTg3MWEtNGE1Mzc1YjMwOTUyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQzMDRmYzItNWQyOS00ZDkwLWEwODktODU4NTNhN2Jh\nM2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECe/60kUxfrNyXJvXt4ljr19O\nGo7R+IDVvp0bEpYtZ18HiALtheXCegBQddVXT9s7y/zpAK4aUMxdVUHtTJhI7qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYKYiwfeK9Caf9GBfGBgZpiPOimYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHYEC7fg\ncpedkE6KwZM8HFMzLSAjjaHTzwhDl21S3cotAiEAxhnWzyeMWEuUWvdabZ0pfxL7\nAgLCoCFKGorLjgd2blI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc587", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `587` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARl6G/Ut6TPlJeA9RHebnTRVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzYjcwZDFjLThiNjctNDA5Ni1iMDI5LWQ2ODFjMWM0MmU5OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZjNTAxMTktMmQ0\nZS00OWYxLWFjYzMtMjY5NTU3Y2E3NTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJB2V4hiAef+jQ+LxynC8Y5ppJkjYxcx1B6lYDtWthQXMiJHNg8NMBK/RG18H\nqEHQe/kMvdtG/LAZurSbuXiC46OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUESoHxVrnXwrHnGfIzUPLynGxZ+wwHwYDVR0j\nBBgwFoAUlXi1kQryT/AeBImm5LjV3LHzux0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD6akHjmC7KZ5D+6FGPIdXVvZHeAiKNSf42RS16aphH0gIgR8BN5AZx1aV2\npVdBBAnen5se479dQsmPddmwy5lrt8g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATzwNNTXMEoVrfGDZn2f8IS2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2I3MGQxYy04YjY3LTQwOTYtYjAyOS1kNjgxYzFjNDJlOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPMwx2MJ+m2JUwysbCO1aZcoBJ4rxftr0VovAwg/9B8Z/3\nCZST6cHaUpmvsV/sjlAu+is2tB1OH/DT72EAE5+3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlXi1kQryT/AeBImm5LjV3LHz\nux0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeZxlrduvo44CH3AvWBTs8LvOMGcRTjdg8Gvpvs0+ZMkCIQDofLJ27edY\n79zeIMdccrKvHEziVso1BuszCTh6MmWFeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASpM0TA7JBL5KUghYISxrbnUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZjNTAxMTktMmQ0ZS00OWYxLWFjYzMtMjY5NTU3Y2E3NTM3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTA5ZDcyZjUtMzgwMC00YzU5LWIxYjgtZGQ5MzY3NTI1\nNmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5fvqiieK6ZXOl/EOEOraGud8\nCCazh8cXzRx2jqfrlgPiXbSGdtt8zWo0H4P3aWI+nFcNTybt1XvIwzMAlc0y6KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUESoHxVrnXwrHnGfIzUPLynGxZ+wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDLRaHV\nA8pQ/A+LTDz38Ps7OLh/c0H1T+8P/e+pCY6okQIgGeUVjHA62p5iQkQ7BZcL0B79\nw0h+0UT5sp+2bX0nlIQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc588", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `588` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaG3LNZVXuJr14Vn73pzprPcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1NzEzYjk2LWZmOWEtNGJjMS05YjM4LTFlYTM3N2JiNDNmMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M1ZjI3MGEtM2Vl\nOS00OTg3LWFlMzMtYjI2ZmU4ZDdkYjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELK0X8jSOizo3W2DPv5qQ5pZnLFpnd/L3P+CkQDxCk6fB46pfD5myst/rHzHN\nSnrW3QTQqGCBX0S0NyAnBtZNl6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFX6jqo0GRSH4UmMVy2Iau89ImqEwHwYDVR0j\nBBgwFoAUhtdJ5UPYgIvzJ8NVbbni2d1Hcy8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIH/cHiVGInoMjcdMX/rJrT7KabTwu5C5t9TBrGBkZAMzAiEA4NQcjCZx8ThW\ne2oBM8U8Ti/aK4QcxsQELqUg4tQ0JUI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdcWD1x1hu3y5KJ3yfqDjYzAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTcxM2I5Ni1mZjlhLTRiYzEtOWIzOC0xZWEzNzdiYjQzZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0fbFbl34IC6MXqfr6Rej1m5LJ4a6vHMAm/xNSf3gsiiZ/\nx6FhtwTgUJtXuXzRSpkx90+Mt3GB0497dWKR5vwQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhtdJ5UPYgIvzJ8NVbbni2d1H\ncy8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIFL+cV3tLl92lVm5BRYAsskdpKskDYKdsJl0eIGPAcICIQDNYEdZ24uV\noNE0b+av7Vo4eziJdRo0J8G3Zu5+sS5MUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQWNZNnY7EZNv/pLEb9MzadbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M1ZjI3MGEtM2VlOS00OTg3LWFlMzMtYjI2ZmU4ZDdkYjYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGFkOTgzYjQtODlkNy00ODY5LWIwYTMtMGZmYjMxZDA3\nOGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwkH5IfmGqOpGu7VOX66OXp3v\nY5DKF0Nk0kwab2F7ITjC5Pr9I2LtVGnPjCACFz0Gz4TJNtSYkNxZZDLAApwTfqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFX6jqo0GRSH4UmMVy2Iau89ImqEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICrUkud+\nuu0I2fdlr5PVo7nU8xUnEr6mY/0FOkYipNpLAiBX7dg5AMPrsSxoJVzvbp3Z+1rW\nBXnx7xw5D/Ls/hVB3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc589", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `589` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAWV83GbUk8QEMi39K0/WT1rUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlYjc1ZGY4LThkNzAtNDczZi1iZGE2LTRkODMxMWU0MjFhNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYyYzYwZWMtMjVm\nYy00YmJjLTkyMDItMzc3YTA2NWY1ZDMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEukGVwNBFbytrei7du970q+EvzUiUMzYI3D9Qw7Bq3A9mDr0URs3FDgC+90Rz\nUw9pPM6h4ua8z7attLTfsdNWo6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY+q/XA1vDyZeWVO2nHsrkaG79xEwHwYDVR0j\nBBgwFoAU113endtbAEutnIUaXAKbHjX1Pa0wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDa\n4FjhrWnK1alF3hxgB2jwWQWeePPv6YbqQVXOcVq82gIgLQHxWcvwuG78jFZtcY+h\nqp01yF3M7spry0n6x7T3wuM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbA04dYoaqQwMGEq4PV/4xeHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWI3NWRmOC04ZDcwLTQ3M2YtYmRhNi00ZDgzMTFlNDIxYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASa6r1Orf64gg13V59MQLI4qsJLdseaokL+V7REWndSMFQJ\nw9RcuS1Tyf3QStF32CN6+f9M/YT+TQnDqOZfwtBDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU113endtbAEutnIUaXAKbHjX1\nPa0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbnSMAfMHQvfRMslT+L1Bz4qaMvNvmVC3laO6tNShBmsCIQDCNWLlBv4m\n9sGyF3TrOY5SnqVmIZhsXxyQKpgYXEzQnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdXvavB/HJ/QLlxJO3x76+I4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYyYzYwZWMtMjVmYy00YmJjLTkyMDItMzc3YTA2NWY1ZDMxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjIyNDcyMzktNTc0Zi00OGNhLTlkNWEtZmY4ZDNmMWUz\nNTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2O0GALAgwd+VhYaeCBHh82Mg\nRCIcEJJIkd+t/+PYyCe5nv1Xwk+wocU8vZdgJepDp5RxbU2N54CalGEbijEe/aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY+q/XA1vDyZeWVO2nHsrkaG79xEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFLclYfb\nQZr9w/MxuXyCnJYvf90goJbscb9mrOaFvUsKAiEA+yTXvtYAcFTcffwOmydmlPoa\n3tay3FSDIOTMUFtcFiI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc590", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `590` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISATIHBdw1NN8hex5p1yBgJHmsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMDE1ZWRmLTAyYTEtNDYxYS04Nzg5LWI4M2YwMDYwNmY1ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ5Mzk3ZmMtMmU0\nNi00Y2E0LTllZmYtZTcxOWU1MmE4MzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfi1HeElEXohyTtC+XsGmzHMdOoQbXlZfaDl6YUKzKL4vD4xTWUFDyEvGL+Tx\nbsSD3sxYrJ5+1aKBQOMWTU+PhKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfPR8hniP809ABDXyJW/ZbNnvD/kwHwYDVR0j\nBBgwFoAUW/Z5CtBNBoFzxcKNDhW3jrXApgkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIE1kBq+LLMBOPyn6awtqa0IiQV7ZaIEU5Jy155uMWOmUAiAsl1bi\nDae9kMjG9Yd+FTVW9IPqTugvi5SdZX+k1s4SGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUi7eQcHIliGKUGMrGaBbSCqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjAxNWVkZi0wMmExLTQ2MWEtODc4OS1iODNmMDA2MDZmNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlCMg/mSfaP2v4ujanHh5EPFm0LF5wTVKbex/3IZ/hHgxy\ni0dzkyzDenT2dJtPgtT9NiWk7NE4jrXDC/8kMg8+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW/Z5CtBNBoFzxcKNDhW3jrXA\npgkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMX5KYc2MQ2s1vdZLo1TZL6Yc0PfURfxWJV+w3Vtm3aECIQC6iSJTP5AT\n5f2RMKLnr3DH3PZk9aNiLrRtNV/VoGoHEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYCW5k96vJM96/z96ftFnZ5TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ5Mzk3ZmMtMmU0Ni00Y2E0LTllZmYtZTcxOWU1MmE4MzY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTJhMzZlMzktMzA0NS00Mjc2LWFiODctZDY1NWU5OGNk\nYzAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE58W8Qc2d9eSr+g08UYnMJ23P\nDZ6eqs0QTI0OAZktXcRxz7WcQz0rroNl0J7RXMtq6Yi3nFz5yCrARbw7K5yEFKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfPR8hniP809ABDXyJW/ZbNnvD/kwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIF5sLOnF\nV1IfrPDMnJPMeErvQBXYfGlTaYz3GOOCLk+OAiEAuqjwzV0zihzr1TJrqS6KSjik\nkDBmdX4VMG+WQR8npXw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc591", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `591` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAZtyGxEEp7bCQdCeEzVwDIAxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MDVkYTU2LTIzMTQtNGIyYS1iNTIzLTA1NjRjNDE0OGY0ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQwOGU2N2YtYTIw\nNi00ZDc5LTg4YTMtNWUzM2Y5Njg1YTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFVePLa3RoRp+RpoIOKlunokya5qk/5zvkYbb8WbI7GqaHd3rMaVXFDXWT/5d\nHAT8TciS98qpJNP4f16jg+LhDqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQXh4AVAOC/XVtczQyk10YF8ktI8wHwYDVR0j\nBBgwFoAUArpwZeG+JWhLpKqJUDvQM0sO72YwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCBN3AzrhLFlb9yeJrstT4qaSFcjB8zIRmmhu/Nwj0AmgIhALwC\nHqSQCGaBfjKvTHDG9Djmrak4dSwiBM9zJKXwjk+H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZj4Y3egKJsL1YcTuF49ru4YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTA1ZGE1Ni0yMzE0LTRiMmEtYjUyMy0wNTY0YzQxNDhmNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXvDnHDBTHDyRw/IZiczGx1NEhgXi0YBthmnqCSP3/cXDR\neGmA7efZLCx0NTnzEAyKIMipNPTdTZNh8tX7nZ2go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUArpwZeG+JWhLpKqJUDvQM0sO\n72YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ9Kjmo2xF1OQx0xeEK2lBHUuQY1TNPkEaXm/ixAoedoCIQD33Bl/8TmM\njghwHhZRDp2dpdYuvZiiuGblKuxLkLAYsw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQmGDF+BtkrdYxefwTxIjmegMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQwOGU2N2YtYTIwNi00ZDc5LTg4YTMtNWUzM2Y5Njg1YTVkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjYyYjQ5OGQtODAzZC00M2Q2LWI3M2EtZDVmZGVjMDM2\nNGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETZPh0J/BPyeOP15vVB5C/I9P\n5khdGv42puIKpMTqwTkaJOuCczuQiwDS6TEaLLZ+viMHVwzqTrRSXVK9pVACrqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQXh4AVAOC/XVtczQyk10YF8ktI8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDCaU0X\nalVDAcDuK9bD3OiOX5bP9mCogHWa+Yqgqx4ozwIgDQ97pFx3S0iS4+GvGzI3xPmi\ni4cZwi5f83EYiIxsgGY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc592", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `592` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISASN7A0auIwU70lI0OWI+K1SYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxMGFhMmI2LWNkODAtNGI2Zi04YzAzLWM0YjRhMWY5YjJiMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2JlYzdiZDMtNGM1\nOS00N2ZkLTlkMjMtNWJmMWUxZWI5Njk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5adR0QxRFs4c7+7wSk6TBUPZE7M9/b4vrtU8hXNf8s0G/5oLFXgojbK4Ajm8\nd3mvU2ruCi5l/LhGx+kXYWdSTKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBr1vyJm89DIyiX83DNwAaFbO8QnMB8GA1UdIwQY\nMBaAFHGRNx7UwoDAuGHW+LSmPszW1pmdMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAwvMglr7FtfCLo4DglVxZBgufVFI0Oe11\ngdvDm/P/G9wCIQC3mTiQJg/4NyUSAJgNz/XuuOSkCj2vHgiFbMvLF7TFlQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATlP+mKXX2njclu0J6H0JW/8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTBhYTJiNi1jZDgwLTRiNmYtOGMwMy1jNGI0YTFmOWIyYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfagEDhVAPPZ5Q5U90syk9Su8eEV9p6yV0PD2eTZm1UBpf\npdUeoFXCSbE2fXR3zMS0gtQzMkhrI80A4We5vTQDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcZE3HtTCgMC4Ydb4tKY+zNbW\nmZ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGlnWcIOZeEIq5estg1czoVn+XMjbGRF1Wf1Vs3APnZECIHpjyNisnHms\nXM4m/doRcxbf1npILZ5Fv5He+hs+XkNl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAaAwZ0h3jCInKj0t0CRTYRizMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2JlYzdiZDMtNGM1OS00N2ZkLTlkMjMtNWJmMWUxZWI5Njk5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjgwZTNlY2EtMmRmMC00MTNjLWEyOWQtZDA3ODU5NTFj\nNjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2RufzBCjhw43jnnyZcuZmDR5\ng87vLp8zy8K9lGlub6gzlSprP/pYKz0zQczbZMUubN3V7TFayWRN+qaUIMYx26N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGvW/Imbz0MjKJfzcM3ABoVs7xCcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIG5mxS3m\nhPNFiYeF5o0ZvlipAsGW2O41qrPjH+hGfTw3AiBfOAQDzHqpEg5Bbium7DLNDHSp\nDORAPlBaarTT1bT8hw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc593", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `593` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWm5VkSW6zxX3qvvIHwah81uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4N2U5NzQxLTgyNjItNDg1MS1iNmZhLTU3NWY3N2IyNDNjNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk2MjNiNjYtOGUw\nYy00ZGQ2LWJjZDYtY2QyYjE0YWYyMGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkZPRakywtno8gilTBx4tLZet/btX/kkwPJXfAnZ+cVxt1eK5d30yvFLnEY7f\nioUm2VQY9QWRgBlcgKod8Qnz9qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUor2CO8Kduj5sdpTtSOcimsfXs1wwHwYDVR0j\nBBgwFoAUTOjDar4HUAAITbYOeYPMUPKdHQAwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgMTB98vqjytOm\n6gQzDvjodNI1ylmn7oVsmqE6wSDWCY8CIQDMp0Xpw0/g7qn3lerRaPAWxHQy4g2E\nF2qKiQoi6TaJ/A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeiBTN0oT3uPfAWKiXXMaSAXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODdlOTc0MS04MjYyLTQ4NTEtYjZmYS01NzVmNzdiMjQzYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsX57P5mKPcNlX8/GnLiXpMm29Ahfyj8oNqj/ND/Hga9jB\nsq9+v54ltL9XRUciuOrDsD6EJldYLAG9mLw7lVXMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTOjDar4HUAAITbYOeYPMUPKd\nHQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKKaf6v4sU4zTxzbuufPhwr6UFjln8cpIIq9L27b+elsAiEAnkpn0nAU\nboIBC6RK2LMe3SbbBW6wz7mie+p9JELvYkc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQ1lFdGjQKi123C5pBVVPCCrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk2MjNiNjYtOGUwYy00ZGQ2LWJjZDYtY2QyYjE0YWYyMGZhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDcxNjNiMzYtMGQyYy00OTQyLTk3MmItMGI0NTZkNmY1\nMzU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmZwwQJ3aO2d066Umv702xQEa\nA82eK3xOr71RxmaANxK+yy1cG4r6FirZm1uh3CP4aQPDvs6U3javRx96BPwa7aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUor2CO8Kduj5sdpTtSOcimsfXs1wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBFOXqI3\nn7alRqjFFeGZaBkK/CfUMqqTO22a848Aj34SAiBSlSoh6ljqPb9Nm9MgA/qfsoEl\nMS62fnqxgDrysNRUpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc594", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `594` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISASBh4sg9k7Et0j4A6OF5jLLkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyODVmNzM3LTcwZDEtNGIzMy1iNjJiLThkOTU2ZDE3YjA2YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGMxOTFmNjEtYTk1\nYS00N2JhLTlmNGYtZWE4ZGYyNjhjNGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHqz8OlocSCo0tIES0BDKdxvY3DUxFYaNsvKD39djz+TxOJERy75jPxUWegyL\nnI35YGpmHzh7VfHWlJB4p0WEsKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzlDS1bwm2sX8uE26Xp2vjO8psCAwHwYDVR0j\nBBgwFoAUL7+NAN5bck9iSk8E4uVO5cyDWBwwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMiUwfU5bCgx\ntDSlCdCJTjrSxaRVHCq0lbdKgI0aiirRAiEA/A4ny8O6QVJtgNRHwsdtsZnAVU0v\n1jupM33q3/BAhVI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdlySip2wwZNLJIf24ZCSuwSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjg1ZjczNy03MGQxLTRiMzMtYjYyYi04ZDk1NmQxN2IwNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFIz8tCWKbtRrM1pN2kLXWDvQMMATBl0muhFhFj/ik43bj\nkweN/wW2Ocf21Vbs3aYP+dHXN+8TcFuwSJWsOVOZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL7+NAN5bck9iSk8E4uVO5cyD\nWBwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKZ2PRud27CW8olcHByakSTrtwQNJ2kmidcR8h1uvlcAAiBLjfC2BKdG\nI2hqrTLkZ3QigfHGK2ilPt6vHszdaUy8+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAezJiZ9Kyk4tEDCp9uyHyUL/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGMxOTFmNjEtYTk1YS00N2JhLTlmNGYtZWE4ZGYyNjhjNGE4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTE0N2RiM2QtZDE1Yi00MDA5LWJhZjgtOWVkY2Q2ZTEx\nYmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcibjBfwmVA17cV493MsOH761\nIxVvs1VlSvfGG0211C64jB0qnNIq/mucZXU3rL1nWPrKp2SHpshtZ2AekerjNqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzlDS1bwm2sX8uE26Xp2vjO8psCAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICXoI7hn\neFMVhwINNsNvIrWI9o+AoUcq2KHoL1Qar3Z5AiBtZ9a8cLuO4Ohd7RF35HYJvnx3\nzENhZW3eZExBLRuq5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc595", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `595` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAZ/tbjrI/67+qQ8Dwd8/FcnMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwZGI1YjRiLTcwMDMtNDNjMy1hY2ZlLTk2NTVmODFhNzczYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVhNGIyMWMtMTg4\nZC00YTFhLWI5YjMtZmY2NDVjMTU5YTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXel4GYUxPSZyg4xunBpn8hNb6J7ZuK6unBCb1ZyO/pIjfCFpNfyUuSVL8DAF\nllRyM1XXgWmxyXS8onnT+68IsKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEilEJ0oZneEpJRton1T8mkJuS9wwHwYDVR0j\nBBgwFoAUEYeGomVdrDRZB6647W3LvdTrrYYwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDeMUfwbIJp\novSmuaQb2MHZdN1n+jKHOBn5xidgyRDLgQIhAMsSSDNO+ir6fLMpsfX+FGXTjhXk\ne4/xKuEWUOlGbio1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATWEtjGAERRr3H7oyiBQzlqJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGRiNWI0Yi03MDAzLTQzYzMtYWNmZS05NjU1ZjgxYTc3M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWQH+RBu/hePEP7pPJdf1EDsZIDgSYLGVqgWKH9hBuvhMn\nFVLh+Q1SYgdkCkeanj5I09hkdyPrWBKt4OUOKM/2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEYeGomVdrDRZB6647W3LvdTr\nrYYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMQma3cPFxnFDPcn0uYY2RMCyu9OMHSuk6wK+yrQQ/YgCIC59XGDwXSSV\n0DrWSNrvq4hbhkbKSXE3UdxUQw3nhyRN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQ46h6t70HRkmj9wVhLqDPYSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVhNGIyMWMtMTg4ZC00YTFhLWI5YjMtZmY2NDVjMTU5YTQ2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTkzODE3OWYtZTc5My00Yzg5LWJmYjktMzc5OTNjM2Ri\nNDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEF6xqt2aL7k6g2txFbGFJkJ3w\nmKdvwCorOhyrHalwIQU98AUPb+gc8zOVipWS3JnuEjww9RM27EoyDq6wZm4nOaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEilEJ0oZneEpJRton1T8mkJuS9wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDufX6l\nZ/U9rePW4W6RtQleE6a85iMECWMJlVidGSCzwQIhAPrDJbKYnoBW5/QKDI+DRjM0\nVGuDIrO0gib9yb4Mqq7V\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc596", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `596` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAUUqWxrHrooV7wn81Y4YNn28MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5OGFlODA4LTNhN2UtNGQ3Mi1iOWU1LTQ4ZmE2NDQ1OTY3NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQyYzRhYTMtZGMw\nNS00MGU0LWE3ZTItZmEyNWNjOGQ1NmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcMiG/fuABmkjVhFZStQnwDmjDLjKVPRghjX270CEbAlJwMXByoBoueOjGTH3\ndKsPv2yjPVB+AzrbZgQkLxuUfaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBWkhPsg8hGrChIC6kFRz76bjHwUwHwYDVR0j\nBBgwFoAUBM+BpuSWWd5kWIKHtNSSRwhdGOkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFMoYBkjqB1EEhKoX7I2Z4/B3Qu4/OCPemIJeCb00mv5AiAa8ixr2qCI/Zyo\nIBnbinzGojhXG58peib+XojtFcv6Ig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQEtSlipfvJOxUmiJvBueLWtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOThhZTgwOC0zYTdlLTRkNzItYjllNS00OGZhNjQ0NTk2NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFAUtF038dGFafVvq9ALWqYpvnAHalt3GwqiygN5PzzxSj\nonUBFCls7rOHh5g22x0UY//9w+KQLU5JTIMfXrM6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBM+BpuSWWd5kWIKHtNSSRwhd\nGOkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOQ656ykXEn5f0F8NltWp7BuhQ8FmPLUPQLTWu12ZHm9AiAakhUn5niR\nx6JeBOhtWbH5L79ann/qwdg7Hf5z/QBHfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfJN2DoeMsNTHOtxYDgA3tjXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQyYzRhYTMtZGMwNS00MGU0LWE3ZTItZmEyNWNjOGQ1NmM2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2M4MWZhMWMtOTA0My00ZjQyLThkYmQtYjE0ODg4YjY1\nOTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEem88Np7yHvsJcZal3JYaHh8k\n09KDss30yN2mrmvtsaPjxIXskigCDZTO53LyAlnpx9nwdSHJSZFuOHEqJU5ANKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBWkhPsg8hGrChIC6kFRz76bjHwUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCID6sz79k\npWQb5rqXasMKPuNS5zMPvIpxYGZyT4jxtmwLAiEA5LUenGBXHxdxCxiyJnr3lrf6\nodwPNkv0NQw0plu6yg0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc597", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `597` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATOfGcWcQ8k4oy0KX77FdiFWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMzk1MGUwLTVjNGUtNDhmYy1hNGIyLWI5MDI5NmM5ZWM0YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE3MzJjNWMtNGNl\nYS00YTQ5LWE2MzAtM2JhY2ZhMjBjNzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg9dxLzEcMtAusSVABhAc90I+V35f8UvtnxT1Q1M4zwYa8x/0FLJdccoj1NYh\nEl3zi57NYsafcvl5tapfMj0R/KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFQz0k7jM2km3EIW/glAtScGlQM4wHwYDVR0j\nBBgwFoAUmovR7oFswIrJi3TciJCAkPScYEYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD0Fv8568ScArnupy8MKIXV7KeyCIbmDtADupZ/cuY7ZQIhAIu+W+csu7U0\nquYJxLXqTS3qZk9l8ER6d0Wt/rPexfKX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATSXLBE0Bd5na0JhjunOaZvHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzM5NTBlMC01YzRlLTQ4ZmMtYTRiMi1iOTAyOTZjOWVjNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNVbjZnjD8lsPafOV/+kTXqgjgw1nN9fPc+uCTattFB9kX\n+NKyDAfYjv65/7yGtBuBi8rbusmmnFVqoAD7wJPNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmovR7oFswIrJi3TciJCAkPSc\nYEYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZX33cRyt8JjfNMxh1khPAxjmO8B27GkqmscY7LoIHY8CIQCS1h2Wear5\nOx4oCoTxIdiObH62kCiV4k1YZR5Y6uNJWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcKZucIuHpI1wu9hjZpx9edDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE3MzJjNWMtNGNlYS00YTQ5LWE2MzAtM2JhY2ZhMjBjNzhmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFiYWRhNjAtZmU2Yi00OGNlLTllNzAtMTZkM2U3MDk2\nY2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+5YTd52zFphuRVEqIW4UQ7oz\njEbw+qtct1trYowy+wZLT1WjuUgi3v3uWnQNzLy6rT9XGvVseozI071dOWMIzKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFQz0k7jM2km3EIW/glAtScGlQM4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD/aohY\nnpiWwiMw72Fk90ukznxKI0Re8r3kZAIjxEUwAgIgD+Y9QSwdC8TcAxunxtx3qYEZ\npgDdwpnbI5DVfF1JA3c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc598", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `598` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAfaWbOPKxLTHVge7j1CWGz1SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1MzA2MTAzLTMxMDctNDRjNC04NzljLTZkZTEyNDRiZDE2YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmMyZGVhM2QtNTMy\nOS00YWRlLTg1NmMtNGRmYjIyN2ZjNWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE31N0IOIF2KooRVJSANfr7TzbfcszViImWnj/GXM0gfIUy3ZGg7fUFeDpKU5O\nsCCd+Q8hdpMUaUgUqTWITCRFYqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURhYFWI5ULuKZI4MtDPoG/dZx9GcwHwYDVR0j\nBBgwFoAUra2hpCh0spuqeZ9W+OUhJ59KpawwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFHh\n97ixxPAjs6MQOnXb82aP1+DgnVh4Xzcd2+NJzmWyAiEAxBuZ8POeD0x8C8iVM+8/\n4xeQfCsC2It5QpsFnKLX+h4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARA4bTQVNr6r+zr/mzOZmTQvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTMwNjEwMy0zMTA3LTQ0YzQtODc5Yy02ZGUxMjQ0YmQxNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9s53QDmivOTkDkAcdwsfcqVI8jWlJeJEoTavPaF2YudWm\nNApazyPUBnnsjsU2bipDGgGIduZ7hR2S4jXoc9qNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUra2hpCh0spuqeZ9W+OUhJ59K\npawwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSjSoxiQ3jVR2PpHgNOu9pikql7koS/kUWW2z32eWZh0CIQDDuCtnWvVh\nmY3m0T6Eys3LZ8DILxXJkPHcN3U2pj2abA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWRZJsuQbbNfWPO8xYiHoVMrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmMyZGVhM2QtNTMyOS00YWRlLTg1NmMtNGRmYjIyN2ZjNWRlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTc5NTUyZmQtZjc3Yi00ZjZkLWEyMmItNWY3OTkzMTg5\nMWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzojIJEIgIELme95P4yAiR2xJ\n5FxtZ44C/E3ktt4tlnsr2dgUMQLYZ4mK3ZU6vr5Puz3ZJQmq6e8AhYdiT+Q0TaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURhYFWI5ULuKZI4MtDPoG/dZx9GcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDasPpN\ntSS+8gyWME4mzkuzrMrwvow/0+8eufO5oVTCawIgP7okt+4DvZ6BbJXOD9g3NrST\nJkg4mDECjOxiCdJH1Os=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc599", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `599` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAYRGlXLrsDOYVxLwQbf3rZ7lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyYzIxNDAxLTVjOWYtNDRjMS1iZGYzLWJjZTU0NDJjMTAwMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNkY2Y0MTYtMjVi\nNy00NDUzLTkxODItYzJhMGM4NmIyMzg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBZRudhs+obuH9X6D7sBusWt0QraUcyXbv3+h1seB6A22dsGf/OYXbxLN/stl\nMsAnjhXsd6fZjFqTAKit34PQvaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs65Zo6nd3bEvc81pxe8bxCPskh0wHwYDVR0j\nBBgwFoAU7wAoiTyTAuvj7HXNzE7jr3vfCSYwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICHWmYYCI2fa6KOReC9bHVVHHuBsgjZUUNNzUqqjK2kcAiAomkhX\nENtezICXRXcxVKS1ElFHmd8Hrk7NLpldVw1m4w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYnqZw1zRtzUQ3OuxgHRyOhWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmMyMTQwMS01YzlmLTQ0YzEtYmRmMy1iY2U1NDQyYzEwMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATja1Ol9wZjwqIRO+phJwrfP7yXGtGv19iVcyYD1yrPYSjc\nQN4hr62I39vBZvkaEDPdZZ4q06WxQMsRS5BLHD9lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7wAoiTyTAuvj7HXNzE7jr3vf\nCSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANZKFQ108pRm6zQ2vcSAc8cZpQ7u4cISmvaFW+XW0FpMAiEA8eS5LuBq\nK39PFBCRhQHnGbERdgI875TddNj2nJWqolk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAUJDnWZo2FUhT/UoMcpXp0CCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNkY2Y0MTYtMjViNy00NDUzLTkxODItYzJhMGM4NmIyMzg5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODM1MzgxMGItNGE2Mi00ZTVlLWJlN2EtMzI4NmMxZTNj\nNTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdMbZ+ehZud0/QtjfX4J2h50h\nCfK+sX47TCzoXEaZOd4PSS/qpXKBHLAOsTMEPQIcEpJr71MEzOmMpQFBHfkyPKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUs65Zo6nd3bEvc81pxe8bxCPskh0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFrU3IGQ\n3NLqtizBMqfdIfOsNjaKUt5SnKhO5p3KMTYwAiAC0SOCxy7gVz+uzuMFg2pZihWP\njt6wpFVTNbDLB8kEvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc600", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `600` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISATJNoaBz3c4WursfjlFbtHy4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhZTA2MTgwLTU1MGItNGM4Ny04NTEyLWFhY2EwMWNkYzAxNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVlMmYxMDYtZWI4\nYi00YWY3LWFjNTgtM2E2ODUwYmQxMzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfYbkX+XfKdarPNYrqrVFjLfZgUtQ5bdjYBuQ3HKUTIarQB4A6ZjDC5z6u4C+\nPMG6+cj6jNSLN8bH8A4ecz4vHqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ZD0nMwhXHCxMsLdN5vSmEXulBowHwYDVR0j\nBBgwFoAUwjvzqwLy7Fx7ePcWpw3p5It2joswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCbfJXvQptSce4xPo5j9RQ8707Juq5oRuV7Vdu9LrQkbAIhAMn9\nXXYRdy+7Weoy5qWWSPfYyJvqU5QI7O16QqwTBABG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQuKs7utWa5NUlMsXShy/dRJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWUwNjE4MC01NTBiLTRjODctODUxMi1hYWNhMDFjZGMwMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeEf4MdO/tQr8s2jH99pDUnSyxT7LrlC4VBLx3n9Bn0Nrt\n7IAOBF16yRWt9MG6volPBmLh89Wujl6wm7r2l7imo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwjvzqwLy7Fx7ePcWpw3p5It2\njoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKKgMdrBYaHNX98OUD3XpX2gDdYE9xAbixJLEV0aVBAqAiEAlP0BUEXh\nReKUlo98eNtJ5gKIhf03qzk58oK2z9wdZNQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAcxQkgZsi/OoOL9I3w3rCSewMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVlMmYxMDYtZWI4Yi00YWY3LWFjNTgtM2E2ODUwYmQxMzdlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTljNjg2MjEtNTY0MS00ZDM0LWJmNjEtMzQ3YTA1NWFh\nMDUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESWY6HDa6UyUgFY8NjT51lDpA\nNXs4OL/gEHtUagNgIcywF8Ewy5KKhw08XOdMxltww8KkMq+PrRTrFR1/7e7QHqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4ZD0nMwhXHCxMsLdN5vSmEXulBowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBc/BMyM\nA2QylQsFgFphPTmSaSFZ0T7+KcBl2pYNknrtAiBmQ/+yUiUj+vDg4narpEREvQx3\nHA3HtSovs/jxGqsr8A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc601", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `601` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAe0Gxm4JCK3dGUsfXLFqaqzzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4ZWQ2Y2Q1LTVhNTQtNDgxZC05YTZjLTJmOGY1OWEzNmVmNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAzYzc0NWMtNzQ0\nMS00MDQzLWJiYmYtMjgxODNjNzY1YTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhZ2SMIGjE/P5RzaVIfWHG74iljz6Fi9PQ1Mb2geE333YgAac9Mgt38s6h+qE\ngIvW/1CMkfy4n+YU1yng8aUlraOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTT7Wexv92ce5KtXqgSgqRDtqd6vTAfBgNVHSME\nGDAWgBSXvPNl8ufSkwCFC/F2FzXNk6GQRzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGYWmfmEvWPWkxKyhFL2mnHiB5oIfNxu\nAuQG79EaydD7AiEA73cLz1izMSlblU8+NRNsOG+jUzFyRth4tdoeYmB877E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAanJJMrXsegj3NOI3I8HVKWbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOGVkNmNkNS01YTU0LTQ4MWQtOWE2Yy0yZjhmNTlhMzZlZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRcDSqICjZ6f/hy6N2V2hd1s5YmmzQ0oF94XXvxwnG4mTG\nJ/50fW7T95c4POV/BsMZ1CSph0Ap63KcB+qs68Kzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl7zzZfLn0pMAhQvxdhc1zZOh\nkEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRo22PqFZrTzXWTWJAthkwIl2yTYo/PK/Vr65cK+uMS8CIDhEXpVmMd1b\nn4KrsTr2CkMv/NxpPS8z1DL4igsB/G59\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAX1s8U3gJ/NnRVaT7qg1IHpnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAzYzc0NWMtNzQ0MS00MDQzLWJiYmYtMjgxODNjNzY1YTg4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGI3NTNlMDQtZTVmZC00NDVmLWE0ZDUtMWY0ZjIyYjg2\nOTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESTORvQFNQEE9I+qxZisadDaU\npJVWp/nrDxZk0z5KHuVySBfGVj1ojcq0wN6yFbA8VjaHXeOx8NtYBF5DHAwoyqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0+1nsb/dnHuSrV6oEoKkQ7aner0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIA+kSjWc\nLlpbU1xvTp5sa2jypjmbaUNi9/WEGoI3o9Y4AiEAutKanHcdBnCWQET6a7h+WZwc\nUFXckurGbPg65PkMcSM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc602", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `602` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUsjo7a0KTSc/n94cOseVZhdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhNmNiYzI0LTgwMzgtNGNiNS1hNTU4LTJjYzVhYmNjMTk2YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBkNjAyMDctMzYx\nNy00N2NmLWJlZjktZTAzMzlmYjdmZTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdx4/5Sho4kO9Rt72SXnGjMyTBPVpxKhA1XtJ6ZLjD7P69SQuDzRankHMKJUk\nxG3ZaHtKgbyRsvI/FiFf6VYmW6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8eOV5XH1VFyWTxrbBjYD46CDcEIwHwYDVR0j\nBBgwFoAURbenZkDxMdM5xuksUS7T+AUswL0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDzIbD4WpnNE\n8cv28PA2q5SiLmAc34GJ6ZQMYqJssddcAiEAtkEc+oXz4RcDbYyLfo1NMj6jJBEx\nDl689B2mknnXiG4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQDRB3qB+/Ju5cfOVDhE4t8uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTZjYmMyNC04MDM4LTRjYjUtYTU1OC0yY2M1YWJjYzE5NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg9Z3yX9apiuUnd/iNpamacb8NV5pRztFsSApbFpQDBY0d\nRlw72grf0S8Xc+XZ7alpzYKUdihx5P0Iqae/cHfSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURbenZkDxMdM5xuksUS7T+AUs\nwL0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALUwFpHnHqaHBFm/Gr1Ow0Gsi1Ka//3SVgmAWSo0dwj9AiEAgSyxyq4+\nxyQBZDXkh+tCXu0t9Rm9F/yuZlE5UZzmuV0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbsjhJX+v5+h/q7OCD9mcXawMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBkNjAyMDctMzYxNy00N2NmLWJlZjktZTAzMzlmYjdmZTY0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzEyMmQ0MWItYmRjMy00MTQ3LTgzMzktZmQyZjZhZDBh\nNTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYGPY+bd187Frmi24w6EBdjTe\n+uTKc/dCvbR4eOtbBXn4Al5pR3moTqCHLnHVW4TvhTw2o1ASYzevNFShe8siuKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8eOV5XH1VFyWTxrbBjYD46CDcEIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFO6ypJe\nktHfYbK+As7VpMyvJztQpbLCf1fRpbeTq0gDAiEA4TMe63qlBRare9mEB3BZxY5u\nVO8wU09OPQLh25TkuNI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc603", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `603` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAVbA9cXctzcBRdRDI1Faveo5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNjViNzA0LWZlYmItNDgzZi05YjRmLTZmNGY5ZDJiNDVlZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI0MzgwNTQtN2Jj\nOC00MDdiLTk3YzMtN2Y2OWJjMGVkMDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEhj4amQqy16Lv3qXFpLeLuPtVQLeB6yIKRpBNLoLfKBZkGc/TIDvk1z7+ygf\n9bp8Zl5wsAvBBdg8jAGX1V06MKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd0KFN2GCZY+NdLsdrNIUPo3RBYcwHwYDVR0j\nBBgwFoAU7PnOctmldKfAs/0Sh7fe0aSbPTIwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIEZS3IwTjRnJ\ntmEN5hhUp0Ywn0sVITETWFhxsdcDQyH9AiByYgkj2au+SC9+oaz3xt6HKpWS4fUH\n8ZGfbsN7vnh/4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATOek2r8y0XvAdwH376MVZ80MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzY1YjcwNC1mZWJiLTQ4M2YtOWI0Zi02ZjRmOWQyYjQ1ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwd0Qoz2aG1xOTgQfhuXvCtWJog/YNA7p2qcHpqALR1f4v\nW9yYB5za7goA6e6PXXDbCUKRjPmAUrY2gc/acdKyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7PnOctmldKfAs/0Sh7fe0aSb\nPTIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO5mn3hSI+uhTfoTo6B1ntPk9WTPxVfExEY4TevoK/kkCIQDPIn122Yiw\n2OWfBPZsG90XY/HNjLsVfbSyT46x1mZ69w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAd3/V/aIufbLFP9AqZRD/RlpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI0MzgwNTQtN2JjOC00MDdiLTk3YzMtN2Y2OWJjMGVkMDkzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjQwZjk3MzQtNGM1YS00OGRjLTllMTAtYmUwMDUzMGVh\nN2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeT6oCPufjqMd90trh3qrDP2z\nAG5dAipgtAqL0igESFu8+yFw3Sk5ThnS8ghhi/A4J8L2NLJhsiVTiblMio8W6qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUd0KFN2GCZY+NdLsdrNIUPo3RBYcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCKSrLN\nF/v9VZij5Cscv25ED7AwTbnBo7osBjuSnwdipgIhANX2I/31IKnQbcy0b7YQqP5X\nfPp+RT5mMbOxfKXw8bYZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc604", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `604` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAbtowzoFRWazvQnoK5xYpbmsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMjRhY2NhLTlmMGEtNDliNy1iYzVlLTNhY2ExMGI5YWNjZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYzYzk0NTktNWY4\nZS00NGM0LWI4N2EtMmE4ZTFlMDNhZTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErttVZFbjEYgfwUFUcqrWuvRYJE0Kz76mksRHPOFLvZXEolIPVLU9TFMbmXVe\nOmt98pZaIjYE7YSuQKdxpS2zH6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzS8l9f1QoM1WVePoT2QZBX8twUswHwYDVR0j\nBBgwFoAUB7xQYUI/xPytoeUK9Ke327gYDUYwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA4nXDzB+D\nCUlLDtEPlNThRWhC8ji7upF6l7+6ZxD028QCIBnDqDZB5vl17Wrz4pJbAylS+ItI\n8qhTTV3Epu6TX6zM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUDh05Zv8yENqAGUuvJmBtaJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjI0YWNjYS05ZjBhLTQ5YjctYmM1ZS0zYWNhMTBiOWFjY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyZoSTqcR0/ITyB1bRPYNeG/z9U5QCrOur2K6na5HRrk8I\nLo5bGPUj7pcD2X54uE+WMoAoiQN8Nqh/ahNmJ3kXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB7xQYUI/xPytoeUK9Ke327gY\nDUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKY49aBtqiK9zC4Uet1Ret8yw/+P598gZmHodg9ebhuICICpOCEKVj2sL\ncDen+Nen7Er5uK84ZuqL8e8JDYQJ60dr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASTJR3i/RdfBWERQx9uSAnonMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYzYzk0NTktNWY4ZS00NGM0LWI4N2EtMmE4ZTFlMDNhZTEyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTFjZjIyMDAtZTQ0YS00NmJhLWIyN2EtYzM4Y2ZkOTc4\nN2FhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWPmxkDy/r47m42Z1oJgiM8Nj\n60nt7GxeT+JHOkQR5Y3qqo0NiS33OH6iJc3tADKkD9wMx49NMpk21tvSWBDzfaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzS8l9f1QoM1WVePoT2QZBX8twUswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDCAsy4X\n5SaChgdd/pILRkhoTHBvjFq3ty6znpZ3VmYkAiEApvh0CQiJYO0Y6f1Utej37aIA\npNBNYiEui8yD7GsMuoI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc605", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `605` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbP+E0JXJTZe7G0Lffjo2xUxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1N2YxNmIxLTg5ZGUtNDg1My05ZWMwLTUzZGQ3OTFjNjY0ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzExODNiYzItOTlm\nYS00MWZjLTllNzQtMjMxZGIzOGY3MTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvOcJiqgK/TzaPE2QesDfs7SndtgYxXAj8qMF474rLQ5BXhxRJ2acORzhKnrS\nRD4ItItvyxmTtnkgU56D/QqZC6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnWY1I3YONYWv55Q5GnKJiaGVlj4wHwYDVR0j\nBBgwFoAUdBfNlRbmJsV9WTml6GtSKxOClCAwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA9e3Go1mv00nTTQW6GSmpM7VK8M5r/Rwn/4nfT2YLK1QCIB3cdFZutHKE\nLX0rPXOeNZWEqPvAUGgRNuMsj3vAWtq2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASDh99zFb8GIqOEvHygoIOzSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTdmMTZiMS04OWRlLTQ4NTMtOWVjMC01M2RkNzkxYzY2NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDIXpDnJi29+PIX1xOiwbPZXyRR5TXkD1zV0EjXqWL4GAf\nEvV8nnqYfvYDe2IXggCq6V/ZxOSyOdo6SpRlkOwHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdBfNlRbmJsV9WTml6GtSKxOC\nlCAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJuxM1qIGP+GLK8dIL6+QokB0DCM3Q7y997XkiUTbD2BAiEAsPl1MNQU\nMypsQdGG5BstOgo7VhhmHrZDJy73CYOxn8I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISATtt4/11ddJny+iVylI12KwWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzExODNiYzItOTlmYS00MWZjLTllNzQtMjMxZGIzOGY3MTM5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGQ3YTYxYjItOTNkYS00OWQ4LTlkZTMtYzdjZDM3NTdm\nOTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP+L4GgUbv2IXZ+6zC+RUId6U\nHULJCY4q4o9BQzH18/mAfE/VLbMEktHOBY6RkBcO+b5LmGv5RPER0rbL9XbaFaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnWY1I3YONYWv55Q5GnKJiaGVlj4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCzTmvd\nwn/bpaeTHTpD0OWq2wPzgcudmIptQJcdmkY9DgIhAJkm5DQi5jQqx2P1AchLQigq\nttavOwtKpzivoKDpYeHc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc606", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `606` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAZVC9xRORMRCfYm/Xy41td1pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkOWI5Mjk5LTdiZDMtNGQ1NS1iN2Y3LWNiMWM5MWRmZDc1ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZkYTQ2MGQtZjFh\nMC00Y2NmLTlmYzctZWY0NTFiM2U5NGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5VR7Z1PLhsmxw8OC1EvbqRZXe6z8u3+OvROaiEKi8/FtYG57/NiDOo75tkL3\n6U5hRyuqFc6kBMZBEvsY8ElbN6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP0Ml4QzscXJ1zA6hwmQZnNj2NxQwHwYDVR0j\nBBgwFoAUyYxBn4DBaDQVbTIbIOa6qzglpuIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA4UfyOwICW760Vft1sKbo9chlBzwWoJbFTdATLf/Hj8MCIQCLnr8S9oKI\n9k6c9WC6ntM1+SUy5pgsGNGZA7qAZ5D27w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZafNi4J3ihx5Jt8SwC2fOs0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDliOTI5OS03YmQzLTRkNTUtYjdmNy1jYjFjOTFkZmQ3NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdpixaBAnEkgSAdkS5veYiQllS4+E+pNf3GwezmSSOPpOm\n7yf/mLJb/DoqVbMQkBw0hJmO0lA9Oe38ZWatCFFoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyYxBn4DBaDQVbTIbIOa6qzgl\npuIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWmEM2X+EQ845pjyHYSMkPSX7qmtlCcHSNYySKH3xU84CIQC/EL3lX8sm\nkfoQotXhJwCZzljuTE6i/6Cngbt7E3u+iw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAdM3xGIVyWAbqjXsYwdrJ8QyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZkYTQ2MGQtZjFhMC00Y2NmLTlmYzctZWY0NTFiM2U5NGM4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzgxM2FhOWQtMWJkNC00MWY0LWI5YzYtZDBlYzRmZDFm\nNWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAAeNxpmqx1FWyR8DMBgMLXmR\nFrkd9CDv7N0CZhS69qZcqdD3PKsWA/cocb3wIlmOx0Yc0P5nj0MVcf4E0LQW9KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUP0Ml4QzscXJ1zA6hwmQZnNj2NxQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDo6tgT\nwvKYzNmva9oHETYUbwSg8y8EYNbRXAlR0bo5FAIhAOeqMekwMsUKu/wIyWf2odmQ\n445eXsJJjezhoF16p1/U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc607", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `607` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAdglwg1T9iBmU1lLgh0zTBj9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYmY2YTEwLWRjODItNDgzNy1hNmU1LWVkMGExZWVlYzc0NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVjNDI0ZDktYTQ0\nNi00NTAyLTk5ODItM2YyZjBhMmY4OWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvLKvDduBtMigBU/ILRLXmLXLXR3MJydmfaNmJC3UsCjcTFECrEKLlz1tmM0K\n0kL9jYAN7v2DrBtyzsuZ5ujW36OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+VOR52SE7mYbXZRqDS40QM24LG0wHwYDVR0j\nBBgwFoAUUCeZSgrsdZXDLX2Apl7wSCZkkmgwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAH\n2klMgD2IgYN/PpWgABYS0DHwhtPLZN+aOJigtUeFXwIgH4WOlh1n3OJ0HAykDglq\n1mbpn/Tw/8nyUNDHmNjC0cs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASDHxZYDIxt46HNvMOD48NeNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmJmNmExMC1kYzgyLTQ4MzctYTZlNS1lZDBhMWVlZWM3NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHa9WL5foPN+gU4xTLNfG7o8izShkLMLq7pjJMYYlfMpj6\nCS2T7id3IsPfpjZqoZpP5XWFvMhBcMeETsD0mfKNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUCeZSgrsdZXDLX2Apl7wSCZk\nkmgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALC6fDEMxVEPfYO5NIg8iVtgbNykc1XYjg6Xyq+yYjs5AiEAw8PM8Pco\ngjfAxOmXwaW7+wNfwzgVuyHfv/SHJTjBivM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAY6PFovJZblMxlrcsr+uk7KSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVjNDI0ZDktYTQ0Ni00NTAyLTk5ODItM2YyZjBhMmY4OWNmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmYwM2NiM2YtNTljMi00MWEzLWIxNmYtMGRlY2M0NjAx\nMTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER2jB3nZCH22Y+yEokbkJgu9y\n+vuFruPAjnJ9HprQaHUB5fCXlKv8yv+aV9Rr00fLie9WWD6t1yINxbYNgkuWHqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+VOR52SE7mYbXZRqDS40QM24LG0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDp7hWn\n5xKi1lNgvLaQ6zj6pr9/fHrzHuUWFCHTwd/hgQIgDweeSpKKM399MGoxiwkNzIEe\n1cLnMtmyAvCcfEeOqr4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc608", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `608` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAU54E6RMx6YDxCQVxz3HAlAPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2ODdlYTM4LWM3NDAtNGUzMC04ZjQzLWNiZmM3MGIwN2RmZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI4YjRlM2YtN2E0\nMi00MDBjLTgwZDctOGU5YWUwNWVjNDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMMKrWD5PBHheNIwFGeWMKzo6N/SGqS+n3i7ucIDxAIFT81/1NFtbd4UU0k/2\nt0jvFjVKiFanrzSdP06aD9hxpaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjFYAuRoqp+6Ro2bOXe1HAunivwAwHwYDVR0j\nBBgwFoAU95SUbX3v+PmDRYv9g0Jfhsy580QwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiAhp2k5FzS8lzqxvurpprMC0MnD5PBuVt34HdzXKXlR2AIhALaA\ntG5cqMEGa0oqF3VUv+4zMAYDahkum4uqYWsc4quD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd5Sk5dvZD9C/Ziq9BIX+nz2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjg3ZWEzOC1jNzQwLTRlMzAtOGY0My1jYmZjNzBiMDdkZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATebyqloXPiwneYOtm+/Sw1pwINwwOP7CLUYiS+j/eplc01\nomjTZguv1y2MeJoKq71Cc0SZjaM7qbewlLd/YN8Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU95SUbX3v+PmDRYv9g0Jfhsy5\n80QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMsEJcJV19yy+ABsOkN3JYT2Zbg2mRmhQ6XJCwR+c4I5AiB5z1jv1lPt\ne5VqzIJ1u4iNbxqMLTKeAR5ewAwGCe1U1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAci19NMxzbJiW45guE1m1feuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI4YjRlM2YtN2E0Mi00MDBjLTgwZDctOGU5YWUwNWVjNDkwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmY1NTgxNDUtY2YyMC00MjlhLWI0MTAtNzAyMWViYjIz\nZjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECG/6micz9WkpOqdi0vxJZ6n7\npWq/SvTbNB5RQPfDuKac4ARd0rBo+P5e/CGXWdxxdHs5Cn55kw7jMmyw+rHgNKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjFYAuRoqp+6Ro2bOXe1HAunivwAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDsH7vuv\n+MrSfV4qgWmGAkm3E7BhkG1Okp4GwrNyJajKAiEA9l7RqrNu3Mvf3OZv3gGVrgc6\nIj5QNH5CxjFIt979eHQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc609", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `609` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZt8uaxTA4sWuufaN4w2tyXIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhYWUzNDRiLThiMzQtNDlhOS05ZWM2LWZkNWE1OTg4Njg5NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmExY2FjNGQtMjZh\nNi00MGM0LTlkZDctZmZkYWEwNGY1ZDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErBYVlfXE6SKJzNhBktZSHWZCAi2QzAQ6q21DO/SFdX7L0S8qtwMB3nS+K21F\nfOBU98Lq/NMcx9v9wZb1Afy7AKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsfQmjRGXUgAd7FehqJ2oJZkxWvYwHwYDVR0j\nBBgwFoAUwWetevbs1O1A7EtyQqv1SGgqzz8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA81kK8+EhdyvIXHftjQQtcJRnT6C/eF0e+sGmXNIW07cCIFsz\nTYCYEgKfztRYmKytPkKK47NZF1iX4M7M8ZeXGfyW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV4VgBYHbCLtciC3tdKvR9yBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWFlMzQ0Yi04YjM0LTQ5YTktOWVjNi1mZDVhNTk4ODY4OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+QYJGx31cF35ub4VAQN07NxxxkPQ39RDZrkkvM4z8PgRA\n6mYPyrg0kGxjwncO7wbHZjR1cERBfP7d9GW+CaKyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwWetevbs1O1A7EtyQqv1SGgq\nzz8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALEr/5Rzk7S0juPTKT7bYqlLB+u4nbwDFVvbKMySL8SuAiEA78+8Kc27\nKwt/e6PIA8b45HUOrP+uqwcym2BbYktiCRQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISASGL6o2LHzftvWbzzNkSN8y5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmExY2FjNGQtMjZhNi00MGM0LTlkZDctZmZkYWEwNGY1ZDgyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTJlZmQzYmYtZTVlMi00YWJkLTg2MjUtODM5NDY3NGRj\nOWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/uAIvgWBDahf9+mOnlFUPLQh\n04l9Rdp5JY4/RLrOTSLF5wvnMO7p8Z3c3ij0umjRk/2daOFGJvGvVbVp/L+xS6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsfQmjRGXUgAd7FehqJ2oJZkxWvYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFKp6u/g\nTcSJKRx8I1a/63zqAjB7zSOpziTnZ5pFLlQhAiB7g0wjzZepUFs5cCz7WuwhFGlF\nrOHomNxqScZtiDT40w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc610", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `610` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAazja4JdUaGfMJl7YpFgfoMwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNzFiNWY4LTc5YzctNGRjMS1iMGNkLTkxYzk2NWFkOThjMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QwZjkxZTUtNzA3\nZC00YTA5LTkwZjUtODY3MTUxZjYzNjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6zbSzlaHy+ROs7tzD3VLLhRJaKJnFXf2hL+neR0kejrYSMpsgrguR9EjpDkC\no18D2BH/yy45ITpBrq0w1lUTAqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUXn8kDEj3KIcZWcuE1HUW/sliWwwHwYDVR0j\nBBgwFoAUSKMv8ttuqIJRzj6NpVucn0ch79kwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAoah38Yuml0Vl\nX74LyB5ZI/T60mrCDoa06LFVqHB5KCgCIB5HXl4lgn1CnGkiq/zhsqsQgSfSLP0b\nm9CtPbwijNfB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY5G2ElDqSZgD5l6YvoG+8+ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDcxYjVmOC03OWM3LTRkYzEtYjBjZC05MWM5NjVhZDk4YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTZ6qGxolxSuTg1HEhVBjPB6nCrFVDEPEayKWeTJVQJs23\nIfmBKx7DfKd0n9u6/hrHctODiFsBKAMl0Vg4JpPao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSKMv8ttuqIJRzj6NpVucn0ch\n79kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcG/5kDYehHq96aN3eoyeefGC4B0X2uoxlI+g3nM5YdECIQDGepKA8sav\n21ApyYEw3YVNPRNsL85DfD1P3hyhYSMj+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXrCKKpwemS0mYac1dKMvXksMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QwZjkxZTUtNzA3ZC00YTA5LTkwZjUtODY3MTUxZjYzNjk5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWVlMTIxNGEtMjM0Ni00MWY4LTliNmItNWIwMDExNTc0\nNTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERs9hLrJuGfK8Ta/94R4aR7FZ\nIUpyeRnIOu8WzWmc69JTjK8iiNR9QsdTQmIWwykMv1mrlvEUAGe72otw+cLSIqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUXn8kDEj3KIcZWcuE1HUW/sliWwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGBFV0td\n8q3dZa4nIDMKdODrbZoXsvbk2IGu0c1xvX/MAiEAh+kYvOHTD4TPNb2J5nOYsBUG\nyC+D5LpX9H3Y8N1BfEE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc611", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `611` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdu3QS+kG1DfhL7bLGQJYmFzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2ZmU3ZTIwLTE1NDYtNDgxYy04ZDM3LTk0NDI4NzQwNTA3YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY3NWRjYzEtYWJj\nNC00YWI0LTkwN2ItNzNiMzkzYTcwMWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEavVi6XB5S+5kxcGIni0N/yQLs+tcbmvzdwOfbf644/x2XTsVY+C7C8oY71g/\nD/cf/V2krekLj5SH5gbn/UXkv6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdwhTmDF7ariMio6n5UzLWiT21XIwHwYDVR0j\nBBgwFoAUS2GRwvUk2QPoMKI86fp2pyu49rwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC8TJzekKeln4fMtsHjzvwH8EPjZEshuE6b6m7sLskCHgIgCRDrNSzYXQnG\njzl+A8pxo6xB+FB9xzBlNoKLuHxuPgM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd/e9KttHbOEMT2jIFKY6aaVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNmZlN2UyMC0xNTQ2LTQ4MWMtOGQzNy05NDQyODc0MDUwN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARd9+wGLRCB7WBGT2/98VxQr5682eAaGFbg3JSx4yP3+aJM\nNrNBD76YEv87a6MRn24GsyMMjanY5PL8+QyvdiDeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS2GRwvUk2QPoMKI86fp2pyu4\n9rwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK9TFoTfI57BRer7QDRHnznGJmU1sb58FGXjs+5+NZahAiEA8SLZ/T0e\niMIuiB+ZWaV4BzCGaxyNhPeSpFa6Hpx7oJ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAdf/IZW/ozNNexwYWLB6lH2OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY3NWRjYzEtYWJjNC00YWI0LTkwN2ItNzNiMzkzYTcwMWYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTZhZmU5NTAtNTk4YS00M2RkLTliNWMtOGM2MjQyNTM3\nMmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMy/BoXk7+3VSp+I2Os+vFoIF\nr7ehWYPrlDk9bAYHdAQOMCX2dAt1I9Vk1mG6SF8wY4UTXPOsRi2Veu5+rPisw6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdwhTmDF7ariMio6n5UzLWiT21XIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIA+hxFzV\ny58PzxwoEJdOzhGH+V62tRZl5KIWPD0trHT6AiBeKcErVcwgDP39UlQSy9yu6mzW\nbYVtH8PCJl7UBK/95Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc612", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `612` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQdOKVvWy+JUxG3ERnuJTGxPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5ZWZkMTI5LTA4OTktNGIyZS1hM2EyLTU0MzU0MDVkZjQ3NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNiZTk3NDUtMDNh\nOC00MWEyLTkyODUtMDZmZjY5ZTgwYzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN+ZLmiEs8HWuZyRGoi55W8LZRW4Xi5Xr9l6nOhTAMtq5QDsxhv9vsVgiTf9M\niWpBX9mWIEGnB1AREB/5etxRmqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtlEScXzguCzaSb84BPx/+QJIgVQwHwYDVR0j\nBBgwFoAUd2CtAFmbafTBpnPagZZ/7iVNP/QwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICz7Ju895QMuPXSRhQIQoGQgAp38/CcTt4+XwTvbX7RbAiA4gKgcxRAJWDIG\nWVmhpwTUwhvKT1hALru6gilPezccGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbFlV6CzzD62wXwrHszFelG0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWVmZDEyOS0wODk5LTRiMmUtYTNhMi01NDM1NDA1ZGY0NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpjsmQTwqDhxCd7Ztg2c3p5wE/V7anhz2fKc1V9Sbgb+fw\npWzLk+swk2Q3lmSvmElrDTYo4cqXHxEY2u7Ni1eUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd2CtAFmbafTBpnPagZZ/7iVN\nP/QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaNgFOLsmOPLfMD/hIVQ7n5qCpkq5qM3yWvw9P0553EcCICot5Tm1l2Bp\nHJs6KR9TtQBb+oRdmK+R1UbEL8uD1hyi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbBoVEtaizv/sAlTfh+UPTodMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNiZTk3NDUtMDNhOC00MWEyLTkyODUtMDZmZjY5ZTgwYzczMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDkwM2VjNzktMDA5MS00MTQwLTkyNzAtZDE1YjQ4MDhm\nZmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETZBPU5aySa1uxHXLZY/LQBf5\nsetl4LGHAOPgIJ6DK/iF6KixCEptPLkTehHUE5zmCYu1r/g2Yc8D5paAYs31l6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtlEScXzguCzaSb84BPx/+QJIgVQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIETr+vpr\nz1maix+nowkYwpj0rD8v0ixdgwMWjtLO8w8NAiEAsxLXRqcUeODusJNHalWhIgqL\nFkrI6YgMVxokhvtIo0k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc613", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `613` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAXOP0jlC4gKwZXc+VFul0CUrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0YjUzNmNmLWI5MzUtNDc4ZS04ZWM1LTNkNWMxNDQwNjQwODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFlZWY5MWQtZmQ1\nMi00OGYyLWJmZGItNWI0ODNmY2ExMDIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEALJXSSaLJrkZxD8cM3WybKX5oolMWEQyofsWQkcg7tiLek+BzvMd/oPOfmQb\nH98wKyAUdFeGVmgRyBRFyG2Y+6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5XUa9EdKLyod9n+Yd16mGT+PkR4wHwYDVR0j\nBBgwFoAU68jnQYvGqVzJ2QsAYjwGIW6qx+UwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA/9RwDPq/fp0tKKmiIYKqzsDbMzkg5xrF9XmclM8eVSMCIA2/mGVe3ZcJ\nBVyelMPtSJ8lt/dtjfCWTeUmEkY/DHTj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAStXYP80x/7m/iVtCqucFZLiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGI1MzZjZi1iOTM1LTQ3OGUtOGVjNS0zZDVjMTQ0MDY0MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtIJfJaTlVgrlPEZRbxqPkHUS24keRI7RKWC9iIz0IQJaG\nd79APk2C2/3+bTwBQWXP01pPaTrmEUmdSyq3B+qZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU68jnQYvGqVzJ2QsAYjwGIW6q\nx+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWO77WwmKxx+nN3QahPnGYQ0nX7VG5NOXpawuhgABoIgCIQD+lWK/n9CE\n6v+PpK6pG8hdpIqHTa3u1K0H/toV7zGmuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAf4bIaP5/Uv5Fc95hCxSyXtFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFlZWY5MWQtZmQ1Mi00OGYyLWJmZGItNWI0ODNmY2ExMDIyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTFiZTcwZGMtNTY2NC00NDhhLTlmZTUtODQ4MzYxOTcz\nMzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwYyXzfNbflU+MxSvq/XrwBxG\n0qiwgCIYXUmXCl3NzExDgrQoAHAsgs02pcfbNwOHIj1+nQeC5IJl+Oxx16QshKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5XUa9EdKLyod9n+Yd16mGT+PkR4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCn1A3X\nLAF/oMWLmRa7X2RepAadkPB/UL9p75dNgsyfOwIhAK7gHwKtfAKfL7HivfpYGtdp\nY6izAP8DKHyPr8LS5nDc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc614", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `614` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAS/oDW4Rkr7+OiYVjQflbbcnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3YjlkOGZiLTUxMzQtNDA4Ni04MjI5LWQ5ODNlMDU1ZTExYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk5M2E3YWItYTQ4\nOS00YzM3LTkxOTgtODQ4M2ZkMjliYTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8mg3jOPtompp3A8r/qd22dELqC9u21A5Itw0x+ZXTHOeZyumfJPwOIjeovLm\nIEmIk4mcYmLgegOlV/st979rk6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiiZcCayoLT0zWc50lc+2BcspYRgwHwYDVR0j\nBBgwFoAULsl1CdJsYQYtFTloGwCbg73wQqEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBZPtx4a1rkfkPTRC6LKJebjfE9s5guF363ynEcWNSL\noAIgFskY1ecpcsjHMTG3Zf3/vyAQofe6jvUHPF0rAUNdgII=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASQCz+T866OaRf4nmRZOm6xyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2I5ZDhmYi01MTM0LTQwODYtODIyOS1kOTgzZTA1NWUxMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbWJmr+otBPpkTGMpphjcNbmlE2aPsI2kBBehCWqHnLLdh\njg35SpiM5x2DNVqnC8lUqljS/zyZRcxVu+rMI9K+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULsl1CdJsYQYtFTloGwCbg73w\nQqEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgds5B+ww9OQtLsZVB1t/CjQnoNViKnWiZ+M55y1dt5w0CIQClE1J22FRq\nnwgshAQAjnSh1GS32gy1sud5YUrquQCjVw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAckJlTn7af/PS3idrUpbSZ/FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk5M2E3YWItYTQ4OS00YzM3LTkxOTgtODQ4M2ZkMjliYTJiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2NmOTdmOTEtNzgxYy00NDliLWIwNGMtMGJjNmY5MTQ4\nM2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+HweMfdeQseH+Gu8kNryzNDM\nDnVCGv21GAcMgEJKlCixqXShPIv+96VYe1l2WcH0R1fdc69ASuc0GRptKjwNc6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiiZcCayoLT0zWc50lc+2BcspYRgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDIRK4nC\n0jxV9mcaVrj5nQZt3UtOZh+ZXhMmzwQexfr7AiAbxXbQU1/L+1A16Cb4cTKWHw6l\n/D1LvztDz7COnpaeDg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc615", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `615` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAWOyNPKPeaJr55CdlWmOGhOeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2NDNlNWJiLWFmMDEtNGI5OS05MTZlLWU4ZGU4NWZlMTA1ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDllOWM2MzUtNGI5\nNi00NTVmLTgzNTItZWFhMjNhZjJiYTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEecMVTY8MC1m42k3eXNEIwezc+gEZ8w32kUTS3lOJTUCO2eNs2IdjLVFMtesP\nbsx4ABdVbQyaH8S6cITjPAJQyaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCYWnTdKjvDZ/dv+9T14VAlwnnv4wHwYDVR0j\nBBgwFoAUnfXQ2Cv6zS3R9QmVrxqv6t4aNa4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEApHB1tCkcj26r7irLYebu9cSCjMNCqpz/w7hiIN8l\nBYECIQCke91LyoW+AFJRWAZJM3S8a8Ne0fveKVR2J/hSXDNXrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbHMaOplXcBGe8zjcpYyTfNjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjQzZTViYi1hZjAxLTRiOTktOTE2ZS1lOGRlODVmZTEwNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASefHXOydMBpoBhJtqKuiFSrJaBE1aQECVHg+UP7wK1IDZT\nlLiZYbPHlLJwMIlPNYYKeJJaiYYTfny4IyyRbBj3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnfXQ2Cv6zS3R9QmVrxqv6t4a\nNa4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW7/IoFeg1gJITP+N0rI8oyu1DGA+mnSK1n+8uUMaquECIAOJH9mV9xj3\nA8/fInKogyIUHV2gEZc2K6kw4sS+Sf1O\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAe+pbPVfj3zkyX+R6PtoAJ1jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDllOWM2MzUtNGI5Ni00NTVmLTgzNTItZWFhMjNhZjJiYTg1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGM0MmZhMTYtZDI2ZS00N2E5LTlkNjgtMjg4OWE5Y2Ix\nMzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEisSIlCHZE+9NhaHgVaIPvZTP\nykzw+gjaTbHDyPJcuIlE+5MFeUI/SbEOk+kq+nfVn2dJ1BruPYrCKnik3qTX3KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCYWnTdKjvDZ/dv+9T14VAlwnnv4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFi3J+xK\nzlUT6eLjBltuffbRIBhDc/d8lx8x1P2gZAVjAiEAjlifPuf6kwJLs6obdLLk+UU5\npAXwrHIZvtaIbUSkpg8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc616", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `616` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAdHVgnsYcNTr9wLBbUrxKrSGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzYjFhMTg3LTNiMTktNGUxNC04YzJlLTgzNjAxODA0ZjUwZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTgyZTUxM2YtZWQ5\nMy00NGE4LTlkZmYtYzg4NTRjZjA0YTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI82KCjGcLVZI5sodwNR1Vg/sRqrEwSA5TNy5n5qF5TTu1va5brqLcWJxvnc4\nlpd+RQojauSy6Niu21RbbsAbrKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhOY1IyIBXAPQNHMvoAY/WtFk94cwHwYDVR0j\nBBgwFoAUHmQN9/5lJA66YyQN4/Z2ElCGEs8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBYRJveAWJRjlUqu2plbCeG+Iuh/mGz5A185O074U7uNQIgAacd\n38uUijcBfz/5FbPxGBepvdVfn95YUaKlucfetuI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb3R5DOuzZ/uYzMpBc8nh6FzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nM2IxYTE4Ny0zYjE5LTRlMTQtOGMyZS04MzYwMTgwNGY1MGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASn0Gs0YCAKQkans9xRzRlkk8LhYtNJZcXZrCn2qwJKEYPd\nPwzYxdjwgwauWcKdHvoE8jSIty8vNCONESanWsIVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHmQN9/5lJA66YyQN4/Z2ElCG\nEs8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJfAZh6YHw45LFyRMhLm/YLd+LI/LlqaIFqWPRwvYT56AiEAnUePMTey\nfwupco4W9+R1RtvjTXLROciSW7i7K2ea+fY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUUlED42Oe6W3rt1CkeOQfegMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTgyZTUxM2YtZWQ5My00NGE4LTlkZmYtYzg4NTRjZjA0YTM1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmE4ZWE4OTItYmUwYS00ZmI1LWIxNGQtYjg3MzU2YzE2\nMzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV5jZSiFaeKRSQLl8UW2vX3qc\nErhUMc5l3FEA83W/WXf3wZK7B9E0RmpVaoPLRwF7YN6y5amV4AUVcAqdveV/qqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhOY1IyIBXAPQNHMvoAY/WtFk94cwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCi99Uu\ni+wGAoelEfUKZK/sVZ1uPP5+DAnm8EuYz/mz8wIhAICxrBnpnAdNs5PRA7x+Tc/f\nVbcMBh9OXPlx86GrlaP0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc617", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `617` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAZm37jA/oYWoW4rL5qJXAPXvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzZWQ3ZmIyLTU2OTgtNGZkNi1iZDUwLWU0MWVhZjMwNTRjNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdmYWUzZDEtMWE3\nMi00NjgwLTkyNzAtMzAxYjQyZjExMzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExOGfxzjUZQDnPeuYoBHVnMaUuv7Pp+kF1A5NSZcbchyODl2LOrVcZ0flzeOO\ncksfyG+tDJ++iIryVGxeS1IALqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQsOHSyHQJhzti+Aleg0a6ar6hmkwHwYDVR0j\nBBgwFoAUBrwlDFxkkQ3biGGzEiQONFxK5rswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBP90gW53s3JIxHP/S65Zs6NqEikbSJl91q\nSQCCdzc13wIgJTjeOFpZ957BlgOzrjJhYH1yxsp03mW8kscsgLMqq5Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWIhiwYAMq4j+6aXo59PewllMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2VkN2ZiMi01Njk4LTRmZDYtYmQ1MC1lNDFlYWYzMDU0YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8dSc14caGiyPw1YW7yvtF5Y1+9fY+ngMk1wrmHbCOOa+K\n41zPqeEYb7/zRyfYddsb+kh/1pGZw228so15ceyzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBrwlDFxkkQ3biGGzEiQONFxK\n5rswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRmBODTOeCDFHKHH8e1I291gIGOyg6BARgvz3xy24OhECIQDT+0WvkaIn\np3DBfgir4wffd5tu3k7qLaYJAR+KR8KtqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQ/tDsxxXbhpaCVSoRyRCPuCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdmYWUzZDEtMWE3Mi00NjgwLTkyNzAtMzAxYjQyZjExMzc2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjk2M2VhY2EtZWYzNy00ZDc0LWFkMmUtMmM4YzcxMjQw\nMmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuI689yvDwPdOWS5zMpn7Tsgw\nArVJfgRHdWH0nOYGqWAF6yseTrJ4w5Ov8hLcc1APgEmTo775ibuUKnNj751x56N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQsOHSyHQJhzti+Aleg0a6ar6hmkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFCCMRlc\nTTfcCsEhCxr2/b2S8hg7v+vWYvKeyQNX97N8AiBJPEpkSuw1Zidboj9sqHIDosU/\nyQYYIR9Gt2/7/Lp6zw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc618", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `618` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATKJYlMUam9eggkJNaBc/aYZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MTIxYTA2LTg5YWUtNGVkYy04M2NlLTNjNjdlNjFlMWM5NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVmYWE4NTctODU4\nNS00YTEzLTgzZDUtZDVjMmI3MzEyNGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIocx+LhG5gzURXA+4UCxzI6BG0QLFRrLwZslBZtsAv102HY0NeVqlR12NPP6\nxdoiXZvHhZeykleUOAxfTGvIi6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9rSjG+Xz62GJxSI/bCZx+UVNTZswHwYDVR0j\nBBgwFoAU9ixM1R8wcFMBFuGdzeysrd4fQ4UwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBuiKlHWAMiR/bz2c5SiPFP8uI7xUNjpn9N\nkSLNO48MvQIgUaNkiZiHMA57G1yhLsiHEAz6uoQx5TmyUCQSjwhe0sE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXuJOzwUawY8fwdTOv+Du+9NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzEyMWEwNi04OWFlLTRlZGMtODNjZS0zYzY3ZTYxZTFjOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASC1LBwt7fgt8EG3NkFkz9fAl9bz7cZ7CfwCSync/We12Oh\nuRQVHVqG8fg+UskGmwRCGnN8vFvvU+493mXZj8F1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ixM1R8wcFMBFuGdzeysrd4f\nQ4UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJknk+7GfMpg5DGGU2GnvflsYrmFcdu161z0s4bSzSvFAiAtna2a238G\nxWbdWDXuS4v4pK1pIkIPPdNW6OhHeLtrpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAWM6dqTBOzMnOWD12yQuA7GQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVmYWE4NTctODU4NS00YTEzLTgzZDUtZDVjMmI3MzEyNGEwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjRmNjgwY2EtYjZhYy00YzZiLWI2NWYtOWM5MGM3Njdk\nZWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjz57CIZYsqRdQyFL78FxdFSy\nMJyafi01ZXM3Bc2h8wKlF/zXAfO9dsfNgg2ySqK4gNKmN4L5tP2BP0c4uOYF5KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9rSjG+Xz62GJxSI/bCZx+UVNTZswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD1z5F+\noxM6E+iIZEYo7s9ACVhJe2dFigjVDcGPIsNx8QIhAImeujJVelHgmXGTZwEXsvay\nE3Xtir5eniC7332liWIl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc619", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `619` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISATPeNAVeCqr0lMT3Jfo87xecMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MTk2Y2RmLTUwYzEtNDYyMS1hOTllLTgxMDRiYzA0N2U2ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk5NDUwOTctNmQ2\nMC00MTM1LThhZWEtMzRmODY2ZGM5Yzk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEphBqgr54cx7T9ifQ8bhywLe9a9UDSmSfKeA0N9NfQH2Sg8eyL+9K9NfzcxDx\n2c5+MZVrmrYCWs/99lsEwP/fYKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBhGVlJ9heondhqRkfrsTvgx//YwHwYDVR0j\nBBgwFoAU4Dx9PA/kB7x0fIPTqGUZD+ix8pAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAHKiCvIcYXpmzM\nyKRMK+W1M9x5gzFxwCnIvYP+WiJD/gIgRg+mTJqf8Z0DZrQAE1Z+Z2GQs/AjvexP\nhGNTZ1vOKLw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATYQ6pVxoc7vHSZKfFPrbbtlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODE5NmNkZi01MGMxLTQ2MjEtYTk5ZS04MTA0YmMwNDdlNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4LB7Cew/kxIv4q1CJ5vmk3smfdjqaHcqtmc7n+7xPGmEF\nTJI6V29UN0lxq2CCCCZhBuaEzOsOVlClyB2xmhYFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Dx9PA/kB7x0fIPTqGUZD+ix\n8pAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJH7aeMmqsZ2p7QCm2vDTQbfWGGkwbQT2mifSsOdLpNeAiAbjTnU11hJ\nv7wm/STT/21c9k/bbsqfoJOGyp/ZPYAJrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdJebtR4azSpsfVmP0/EYoKZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk5NDUwOTctNmQ2MC00MTM1LThhZWEtMzRmODY2ZGM5Yzk0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjc0YmY4ZGQtYThjOS00MjhiLTg5ZDctNGM2YmQ1MDI0\nY2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE42EUj33bG67xI5Rv9Sgr9PcZ\nVwRtsfBm2LvMmazG04+yn7J01O/OA7uNp1E34YW2gbMwuu6ag/oBEyAx3+8QgKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeBhGVlJ9heondhqRkfrsTvgx//YwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQChD9dP\nvafJDZ4vWtbZcg9uBbnPUdaIKHY6Tp/Bj8REXgIgK2ZtrhNXWtCLxO+Dmrvwga7l\nvwdpY+fZmUNyJDTMnPo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc620", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `620` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAb9M/gjp5nxmmYQrOVoXYfu9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkMjlkZGQ1LTQxMjItNGRkNS05MDJlLTNjYmM0NDk0ZWRmNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU5OTY3MTktMjky\nMC00NDMxLTg4YTgtM2M2MzViODBlZTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE55gI3tYOmcr0JzLyFWqittqB072OtRiYkjZRNYTIfKlQwJ9EZaT3IvGSIDCs\nZwAE9gmdK/veXywPtFuK7mOtZaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU/z2/ASzidNkpWQTP7E0d65/f2IwHwYDVR0j\nBBgwFoAUkwqrn3+LWlxlNbKvEZHl+D794V8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDf/doLtdIq58Dq/++kMx1UfRK5l4gJrM2OXo6BOR5QTAiEA6VvNmL611RNJ\ndHFBz22eVjQSTk/tX3lqcmivmN6j/aw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfEI0Cv2lnrrv/i0ruScxnm6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDI5ZGRkNS00MTIyLTRkZDUtOTAyZS0zY2JjNDQ5NGVkZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6EwpvmM7UpSjYvuItCaxC819uWc8ALuOATkFp+g+1Q33S\nSv+GNs2YsEK2ve04PwJ2fpx45g83QQogjRylJtblo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkwqrn3+LWlxlNbKvEZHl+D79\n4V8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANl0asEY/LA2ecWn4UGHny7bVL2mLLU/foZgojuz0jNIAiAKM33o6K1K\nAg61gIYIjmp76rKso7cg6fzPPAWbDtbE3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVM9kAhHnJSxytFqAOJZ3xlIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU5OTY3MTktMjkyMC00NDMxLTg4YTgtM2M2MzViODBlZTI5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTM5ZjgxMzEtODEyMy00ZmUwLWE4MGYtYWIxNjRkYTIw\nODRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVhnDqhIFOBng0HaBcA7qhDuI\n3GxB9h7tO/y61E+mh1BF21Ob4DU0jQeWeTgsKkvD7+qpHmVyPJAroKPgJNQCqqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU/z2/ASzidNkpWQTP7E0d65/f2IwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCID+myV1H\nWLGKZ8dQbrgiVyYxVARFD02dpNUZEun8VozcAiBMwwpcgMUQ1znOIwfYOEWYC79U\nkEUHxtLcu8hsB0o51A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc621", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `621` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWKg7/9KSY597a7CvEJEVBUVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4NzcyYmRkLTk4ZjEtNDZhYi05MjA2LTU5NWFmMzUwNWUwNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmMzNWZkNTEtMDQ5\nMS00ZGM3LWJlYWUtYWY3ODJhMmZmOTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO2aAIu3gBvLwwkxYoJGD+DNzjVVZydxtDADlIUb+/LohRvhCegugOzm0apKn\n/v2Kd5p/6kYDGRguabithc5L9qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXRcumPTGBZLroiq6a9h5OLRycMYwHwYDVR0j\nBBgwFoAUJwxMLw9UEzpeXHDKoDKamWSD6lgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDw3Q9oKLvR+tHJOF/36rnMmhVP/35nxCqKuswGJ1dKrAiBMPApuGzMNv12y\naVRSOCX/j6AgaMsFbV4blStgQ4gRTg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARbTq+9l4JASLM0fORm4b/XtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODc3MmJkZC05OGYxLTQ2YWItOTIwNi01OTVhZjM1MDVlMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJJ6D875570oeF0xM58sNOry15VVVjIsIzkYbTfOPR+Ngb\nTO6Fc51LPP3eFbz/dalIygXrgwauOuDgKnX13dh7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJwxMLw9UEzpeXHDKoDKamWSD\n6lgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKqBbMVQWROBKtRajh9a1XojdQT4zz9w2Mi6Vl6WyGi8AiEAxwAwaY1l\nvtmKGzrHjw37LCDFX4sLmw6o5rxw7vAgkrc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcqerhO34+ApcXi/WEeFPLkGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmMzNWZkNTEtMDQ5MS00ZGM3LWJlYWUtYWY3ODJhMmZmOTY4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmY2ZDM2YTItNGNjYS00YTE3LWJkMzctOGEyZDAzYmM3\nNTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELtsrwJur2ZMZ4ZnwCuimYk5e\nLel76H9kyg8LdQM9JZgVKehvReQ7ZqplHhsuOeENm8XK7CXrgqk0YOjWTck8q6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXRcumPTGBZLroiq6a9h5OLRycMYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGFyvdi9\nepvytSAoEM/SkeoprEgd/QeHcFpwplErrxsfAiEA1Qty8ECeT/Dy0IcUpI0C8rSG\nPAB5pGuUSptet6WG9xk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc622", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `622` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAXht+nl2snIiMFSrfcrsHZL1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ODc1OGFjLWJhZjItNDhjZi1hZDgxLWNmNTExYmFiN2IxMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA0OWRjZWUtZTQ1\nNC00ZmEyLTkxYjktMmIwZmU1ODhkYTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN7s5MF7x867AMFVuMCuLOYkEou1mdgCHtEEIrJKMvgtP4TWJa/WB+MSMFBAC\nV1/eZx2ygCnbhISUaEqgwDugw6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIcPyVTn8BY4FYtbitA9TISgSpEQwHwYDVR0j\nBBgwFoAUUUCmaVyFVQiuG/TiqZT088qTjVAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAqRVvfFCWNE32raU/KmvlaB0GFKFjCvkoTmTn75HVNsUCIQCGTNc6iaJN\nWpMxjRM5QHd37rlISF2FbY4KNNOsmfEtDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUkZHkwp0GHXeAEVeEYeE+43MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzg3NThhYy1iYWYyLTQ4Y2YtYWQ4MS1jZjUxMWJhYjdiMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfMtx4q7jKVluAwfFIrE/RLHZX3GQTtPozUOiQNy0Mab14\nvvo4dSqGPIrZwIfXPLxHJhbadR1MLLPLU2sm73f8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUUCmaVyFVQiuG/TiqZT088qT\njVAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYSGMTghEbuA386VGEAVsbJww/jBXo2JdvI41jsbcOBcCIQCJj98ZsgwA\n4cXtngkvxN2nLyhSkELZHr0Xp9eSoH5XtA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZ9b0JUS2ZecVWS4I1QyV23jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA0OWRjZWUtZTQ1NC00ZmEyLTkxYjktMmIwZmU1ODhkYTAwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzhmZjkxOWMtYzgyOC00OGQ3LTg4YjYtM2I2MTMwY2Uz\nNDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEddY4xrnY7kbi1AvIa8DGHF+M\ntlOIfYntU8wB4B5Tj6ySUFDxaqGL12hPqAGcE3gCmzzmFye/VCoWdQ1S8IsDnKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIcPyVTn8BY4FYtbitA9TISgSpEQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBiVhOye\nYcKwocX8TobrLJ3sMvGJs+Xhme6Ojxb5bslvAiEApDtHSMZ/FyAI/o+qdlHmDzpz\n1Z2qVtdL/XaNS0cfScI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc623", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `623` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQF6PPK2hi+5l1iSVFw7w6KsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmM2Y5OTJlLWY5YzctNDk4NS04YjJkLWQ1M2FhMTZlZjVlMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODY0Njk5MzktMGQx\nMy00MzJjLWE2NzctYTM0NjRkNzg2MmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7V5TPOmug9TA6YQ2SWMqBFH7lhZ2k1i0eKDBxMnxhWrICTshT/Xa9a3mkAJZ\nfXgtRNM9UFX1k3+0naGxb7srV6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUip3M6/pop1ZQrTkpddcV90LoRuMwHwYDVR0j\nBBgwFoAUmgscTigiE6lFcsAHkDd54TGYaPwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAm7eUazemgiZQisun9qq7nBgNUq2/mGRqoRp0aKJhr\nSQIhAI8DvS0p7MCGioUAEln6lXavabCNb3BtevM00J7BDSRP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeLe5zezxuhwGMGS4uEkH/7JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjNmOTkyZS1mOWM3LTQ5ODUtOGIyZC1kNTNhYTE2ZWY1ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMeyFJ9B/oqsQPePNdHNQbCw1aUICaIYpCUE1GujD2cYbx\nNYFYX3MJ2/aBWm9EShqhRT0x3FDhfUj6Kz3PXQlGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmgscTigiE6lFcsAHkDd54TGY\naPwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKGIMdvr0C1Efo9X3psEgqopsixxwiVI2qPcKHnmI7ljAiAap0Yu5pUK\nag0o80bJK3wdMhfcwjwZEbYeXiKHZkVbuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcPo3T3psSblCYFaSA2kcwc7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODY0Njk5MzktMGQxMy00MzJjLWE2NzctYTM0NjRkNzg2MmFiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTg2Nzc3YTAtNDg3MC00NThhLTg3ZjYtYjUyZjQwN2I0\nMjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgjOagDlJJGO4XJ9dxXp7FpUO\n9CCB/jq27G5AvkTRziFdNgm7rqv81p0MDF2IXBvR2nUIS7MJXuqTHC5Y+GHrpqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUip3M6/pop1ZQrTkpddcV90LoRuMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCvGf6j\nUg9LkiFAuUiFogFnDub8J0V6F/dJwTubkDcEWAIgBajA89Ni0U2czkXZKN6N0X7o\nJh/KAlGtP/q8eiAsn58=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc624", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `624` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcFXSMhKfge4g0VvAnBePX/BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4YTI0MGM1LTI5MDAtNGQwOS1iMmZmLTZlNDE4NmVmY2RkZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U0MTAwNTctMDEz\nOS00MjQ0LTlkNzMtNGUzYjhmNTY5NjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES6Q83eXpkaCoDt5MxXkrDwlBOdON+vP95zteUzXEY6H/GBSKjPvy3nCcjDkz\nfkwVSS4hIuaJY8wfGmEH/DRs/qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIlDeBawSZdwOeOHBoQ7/tzrmEcUwHwYDVR0j\nBBgwFoAUP1pOyMUG//D116PkATn2+RxaspwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiA0ZpXUVpl1tnXTgArCy5axsMxUb13qDUEdMurckQKn\nLgIhAJoD9sBZG0YpDEDPaN/4F0L5BPPx3eU3+CH+z53VVA0o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT0vXIGMGBGtGK/r8hRCkF7FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGEyNDBjNS0yOTAwLTRkMDktYjJmZi02ZTQxODZlZmNkZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJf6BS7xLYN0sSXRUf1PLukk6TAh2XCoHEfbY7AYgAoPNV\nMEJq9p9g5pgXDq+3MTOrJbr5uOEbSqIJFIjWnFooo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP1pOyMUG//D116PkATn2+Rxa\nspwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSWfRXGYVnrqAt4qwHQOSTJ7KPRM/BuEyuH4Pq9TmZSMCIEoEczQuiaRi\nqIyxrYvjvGYeHTdwr7woTHzfUe0b8bn2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAW1GZ0qHfldM5FLBTtMolKAyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U0MTAwNTctMDEzOS00MjQ0LTlkNzMtNGUzYjhmNTY5NjYzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmYwZjhkOGItYjA2Ni00NzFlLThmMzMtODQ1MDY5YTE0\nYTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeixXbk3HKaoOUiwENYeAb3hB\nz+uSkrDgotLqby4b3TGMRyQcXNMPoz3rEReRRTZWpuwOwuNF2JrbZJ8GOjnInKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIlDeBawSZdwOeOHBoQ7/tzrmEcUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDiJMM5\nTeaypvbnM3lUCanfJ22zBx7YIGVCKcnwnFCpsgIhAJu4LAqpqL2w2kSy2tMYEndc\nOVt9XxERfNEfdY6UBBez\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc625", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `625` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASAPmlJe37FSvJ06xtNejg46MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjODE0YTYzLWRkZDgtNGI4OS04N2FjLTY1NDljODNiNDg5ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM2OTY4MGEtNmRi\nZC00NDY2LTliMDUtYTk0ZWRhMGJiMjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ0lqlznb6+AUWHtAuqYE1w4vmM3MlYgYbOpKXzWKmONOq/WAxM83LVWK1i1B\nvlL4olK0VlcnHmDXvPZXwCCNHaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUObKxdbzfQ1I52+c/Dxv7uO2G3eMwHwYDVR0j\nBBgwFoAU3Uv8Gwez4DAC1gFqJlC+zARUBdEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAIGWR/IYzhB2o0yEMD6PBZUliIMYzYx9Q2BBPdhJAe6QIhAN+j\nh8xZ4+oum4LFUOPH6XWyvYjH753jMmR8sujh4s8m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe2hzVZLxFJlg1+6CFF8mI03MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzgxNGE2My1kZGQ4LTRiODktODdhYy02NTQ5YzgzYjQ4OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARF+s41+c8hF3fq8RH4FxHLQLDe7hNC2bVh/3DR8ibSw71H\nQNkXckV5iD7F0amUINnwYJqACCVG3NSUVfNaMNdMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Uv8Gwez4DAC1gFqJlC+zARU\nBdEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPyPDv87iMxO8KO8OBN8w0tj4+YuIKMwHr+/xo4qtTMMCIDDWibeK4IXa\noMZ33eCmy3n7vD5MgYZX2v55e2xITPry\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAclmxO7fDTXYrRN5zMmQK4odMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM2OTY4MGEtNmRiZC00NDY2LTliMDUtYTk0ZWRhMGJiMjc4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWI1NjRmMDQtYjVmZC00N2UwLWE1MzctNjM2ZmM5YTUx\nZmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2iQpIlvCNptdHgKOMY20s1ip\nR+6B0GLREUGeST6QK8eAEueu9OSSIZNt80zeu5AnlFQY6xJtqs9VOjsXydFFMqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUObKxdbzfQ1I52+c/Dxv7uO2G3eMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD68pkw\neJfjPifuSqQGEXY9cxCRKIyih++kDaX3DK17qAIgEmb+/pklPwhOz6p0CNHbI0Fr\nFX5AdCjrj80W1HXKYP8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc626", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `626` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAYsEeeKHTqeRsEFdL2Ab1TCBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiNjlmZTIwLTk2MDUtNDJmMy1iNjVlLWJhYTEzYWIxNGEzMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRjZTZmYTUtNzI2\nYi00ZjgzLTlmODAtZDhjZjAzOTJiZTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7cykz1gUIUw/NsZuaBIIu7iq+kJe5oPCBJcYPryLz7BROmgGxBWDVudifTaH\noYQYkkrd1B2wbZFZSTR/1JCw8KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWOtoYQxFZhbp+n/zNnZ1QHUiI78wHwYDVR0j\nBBgwFoAUjzIa/qwRG+0hMi+R+biVpSBxAmIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAuWeU8ZwTJGceKT0tpJvluV+gO7fYy+u2\nqylIsniOLgECIBuc/4j4G+fwwrZ7Ny9SmkwvxSY8gcFuIJR26RlHruME\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVdqfeWocrjhkG4mSNL+WZUGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjY5ZmUyMC05NjA1LTQyZjMtYjY1ZS1iYWExM2FiMTRhMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+2LFhZdpohPOZbPCECx45ZlXr+P3AZfUjxHkrxHA64MnT\ngcodEw8CFzbapWqU61hGmtj3Wm/KpfG4wfzFF4jSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjzIa/qwRG+0hMi+R+biVpSBx\nAmIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIuM3WJ5DdP76iieNl/Y05sRte50XYf7N6aptWfloW/ECIQD5/uh3WTi/\nmNpW6JFCNpAg9MgWehPPn8LdBx2kEbvZyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYaZumdLkcgS4AuSFArnRBEpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRjZTZmYTUtNzI2Yi00ZjgzLTlmODAtZDhjZjAzOTJiZTE4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWI1YWU2YjgtNTMxYy00NjE1LTgzMjMtMDY5M2Q0NGRi\nNWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6O+i495vRW5kEWLOMsun+AkI\nW0hIZASU+vnEVX7FpEQYhkxbQqAdu6qpjPFo/ZMbAKX6S+UChDnIUTZhhoG496N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWOtoYQxFZhbp+n/zNnZ1QHUiI78wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFiPJQeV\n6zDULqOp2xzKvUxKfhp6cykQ41IqnqYjE0aFAiEAuiKjqLT3piWvBLa3PP3SE3EL\n20ZRc44UJ1k5qPUpN/8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc627", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `627` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAU2TE2PmluvrB3gxcIZ4IutcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5NWRkNWUzLWQ4NjctNDAxMS05MmU1LTBmMDliNmQ0YTNmMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY4ZTlhMjktMmMx\nNi00YmJiLWJhMDAtMjc5NTMwNTg2NTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp2T+ABqtIhjNtEZvKQ4Y1U3JYgbKJ/vl/s0kxkYYGUwqnqxnU/8q6ubwy3I8\nZGY2mx+5rhD9Y879BpNw8dZp/qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfUr6ohmTNng5zBYVkGEgi+gdmO4wHwYDVR0j\nBBgwFoAUWQDxf0u7Y2JRSlpDZnwD1USUbn8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBHXH+/BIesP8zEJ+x7HrVPpjN74jnTWwhP\nf4v7W3l1lAIhAP162oW08TNUB0fYLKt+g5l0crbFlpsmQq5CYlqMK2GD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc1iMLUXrZ6n2H4J1reSHiDaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTVkZDVlMy1kODY3LTQwMTEtOTJlNS0wZjA5YjZkNGEzZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJka1eusaqrFOXMGagrbwGlB5+bF0Ax9ukmCQnc6atmvB7\nqbeatbYikdELW4q8KUG8qd8B9XFTih+7Rxkm+bVko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWQDxf0u7Y2JRSlpDZnwD1USU\nbn8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTVx5rYRQ2Sdsel09u78J5yi0OqpSEMYChQZ3TMFsFewCIFukzk5iuyQd\nNZSe5oR7hcrCxlKVM8gRVfef6U6hhcqX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUaWBO22RKoyLFzgeXkgMbNvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY4ZTlhMjktMmMxNi00YmJiLWJhMDAtMjc5NTMwNTg2NTljMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzI5MjZiZjItNzc1MC00MzBjLWEzZjktOTk0MjZmN2Nk\nMzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6PjVt1wvHnWfA9FipptAiBYb\nVNWL04JwMCokA0UMy8QZpMNRJ5T8N2rDhWroB6bcA+N6JKL6m+oXdB6/vV2HoqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfUr6ohmTNng5zBYVkGEgi+gdmO4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIEtorG9H\n8K3ZXHmVmOiDNK5NjPBFT+GOElrlsY4ZdWLPAiEAyS4havb6Zl+eRQt2hXudGWn1\ns3SsABhZWkz89Nuzl3U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc628", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `628` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVdmexGW68OSxcI75zAOyJRSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNzI0NTVjLTBiMGEtNDU2My04NTczLTZhNTg2YTNjMTEyMjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQxYTc1MTQtMDU2\nNy00YmRjLWE2NmYtZTNlNjMwNTIyZDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFR6jZQQtj2KNovbN1myZJl8+S5YWHe2oUF99HWXom5sM7RUcF6ecw6pwlw0i\n6QUI95FL5WCkA8gVXVvJ0xUT46OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjCPjAEi/mscEjgjH+exBZD9bnpwwHwYDVR0j\nBBgwFoAUGbU9mAWYmxOIg7Ld9HlpjWzRjbgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHJuQPLR4dAT8c9AZ+ph5c8zoUmC\nw3IOi3NWpgrdxYrCAiEAj6t/DMXD/GCbSlCgv0kxRDghQjRzkJ6TLFPGYD9x2zw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYnsznRDEcShv61SZIcdzSHIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTcyNDU1Yy0wYjBhLTQ1NjMtODU3My02YTU4NmEzYzExMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStmgKPd/AEUOAV0Uyvg1Znj9792k3XB2oDZeeLrVIxukPd\nAuqyjC1SrbiwaGvaiNwPwWt+nJZPsFA1MsGpzmx4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGbU9mAWYmxOIg7Ld9HlpjWzR\njbgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIihvEYXrHXHLp94QxVoYzN/JhqP83wLvOa7YVo/oOezAiEA8vI8EMzS\nza3vMO5YqUEytvptZp1If/7uOHKiJV+bwAY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAaPWEwsvx2cK4+MRr2HfIsr2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQxYTc1MTQtMDU2Ny00YmRjLWE2NmYtZTNlNjMwNTIyZDhjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmQzOWU2NzQtZDRlNC00Njk4LTgwMzAtMTY0MDhkYWYx\nNmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGwOHnVuN/UZzQC5PUYv0TwSF\nKUUUrih+xRfWWWn5B04Krgakc0hpHORhMQqclnXg527PR3RMXy5gXlQc3Rp39aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjCPjAEi/mscEjgjH+exBZD9bnpwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD1eKdM\nNzrszMYtqNM35GZ4XGBxOL/uCbdTpyfEa8pBwgIhAMoYs5ROoapoITVj/x/+dX+f\npyy11LM3zh2GNeguPJqj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc629", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `629` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAdWTnq8REnoJQDJ487OVsS+CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzMDZmMWU3LWZmODMtNDNhMy05NjljLTQ2ODUyZjhkOWVjYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE5MmE1MjgtNjM4\nZC00NTQ1LWFjNjEtNDQwNGI5ZDRmY2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1l+rYX7Le4HJXj2mEeGGW0wxQe2wMA5cHqp7kEo580N0HBVzm92JNIOAiCru\nn8OR01W4z3lhxsqr76tFZLXfxqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU69fgFo57VtsX2BSFO+0gcbNzXHgwHwYDVR0j\nBBgwFoAUC6kkCWk9KCervQoNsJNoNM/DI08wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJ1D7V7K\nexx/pEPyUObIGkluOBRKUSxpL5woPms2LFkuAiEA1r3CQQTrN9bTFfh0lNl202BU\n1a9dbaoQJCMUnexRJww=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUFoX3AEEUO492ENBBwE4FyXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzA2ZjFlNy1mZjgzLTQzYTMtOTY5Yy00Njg1MmY4ZDllY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATA9WZ4NiwXNZtC8pysp6Qtkap9iV7rCMnDGkCpqOParuy1\n4XYByKtrGvsfQPafB/l7v4AfiV/cAx3UutHyRBSJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC6kkCWk9KCervQoNsJNoNM/D\nI08wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJc9dJSByuGCf1qL9r2XW7HJ69W10/fJr8pv+H4iT0ofAiEA1HBgQ54f\niyYItmhLwnMYk4uGUjo9koqXW5bz/QqeXac=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAd5Egp1U3QNXQSzcfpSSZhKaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE5MmE1MjgtNjM4ZC00NTQ1LWFjNjEtNDQwNGI5ZDRmY2RhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGI3M2FlMzktZjVhNy00Mzc0LTk1YzItZjI3MmI3N2Qy\nNjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi322I8+wAgZP0dfwKiPMZ8LP\nVN8ISQBjHodo1SLsRKC7QHntJmIRVc3CWkrcwi4k1Ffd0A/VGEBtoYcp40JVz6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU69fgFo57VtsX2BSFO+0gcbNzXHgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDuuwTS\ny2yGOCjxL4OuFOWhNxVU8axSnjumq4R7nicecwIhAJvrqBar7ljaCVLiDRjv1kSW\nTxhcYnxxHxa4ZVqQfWU5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc630", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `630` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISASL5Lya8TkPATmPLBJDMsGRqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmMTRhNDBhLWFjMWMtNGJhOC04YzYwLWQyNTJjMDA2ZDA2MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUyODMzZmYtYjlm\nNC00OWU3LTk2YmItYTc1YWU5NTMwZjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE28L8IJLg/I53hUrsmVs4KceukmgVo6QkHHsPugMJU+tzqoOP8ipWp1mF8Gcx\nl1HlLRM72/P8bXigLGoW+ezhkqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURdh5Fr198XexRrEKj24awygtakYwHwYDVR0j\nBBgwFoAULadInkGG5IiCBvkgBffjtDg0XSEwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgbRfy8WwI\nWiFN8JCLSerEa6Zna4nAbN1MdVPCjMQB3TECIQDmwe7lt3FRJzsY9uNVmldv8FyH\n/tHkD4a/Kw6ole42rQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfNK7T+XfwAqM0FpKMJquziHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjE0YTQwYS1hYzFjLTRiYTgtOGM2MC1kMjUyYzAwNmQwNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcKUYWcNy3Z+qD8YECQl8nEelUnkEejvqdI7GpjHUdrXZB\nt8+oYw6jVNGqQOgpSEhrMvnANLpxRlF8hu0rZ7ego2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULadInkGG5IiCBvkgBffjtDg0\nXSEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPd1YS8EE/+yRjx2K5L1MBd9jJ/euF2UMy2JEN5mZ372AiBui8x9C32K\necjaHVKeCIzVAfQLbTUawcC9TT/d00tm5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaAec3/7s1EwzZk4/ogotINlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUyODMzZmYtYjlmNC00OWU3LTk2YmItYTc1YWU5NTMwZjFhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmFiYWU0YzMtMWUyOS00MTM3LWJkNDktZWVkYzhkZmQ1\nNDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECWZFVkIfR3PCAs9rgeNWsvaL\nWSCM+3+R3Rgb79pejl1UMG433YATLJYlo8Pb9M94agH3tWZ1j2po8ula/ARGLKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURdh5Fr198XexRrEKj24awygtakYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC8F3Qf\n21nRHA6Br/FCliDbP8xeHaOvupoJatFzR2kWaAIgBChm2W4dWDBhumMkO916SAYK\nyYwFdRceuNqlTwlspkk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc631", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `631` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAdwne9Imz311O6qVFHwtCaiDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliZTMyODE1LTk5ZGQtNGRlNi1iM2YxLWY1MDFlYjBiNzA2NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc3NWU5NTktMmRj\nZS00ZWNhLWIwMTMtNmJhZjA0ZjgyZmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFxrZmfXf+rWaryl8ix6K016V1jGVvE8MaTfrxYft9PAB0c8xrHetWGLBlaGj\nQuAmoLOuzbKE63PjzdSnAdH9AKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq21OGeZoPWfg8h6MHeW5+xcFxiEwHwYDVR0j\nBBgwFoAUf0Od2z3PPMq7/ynt2gVDGM2A0UQwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC1rVjT\nT4wc7LT7adVmPu26GK0ICkGMJxVcOURLDbAQiAIhAK7zDtic0GpMQo9jbwPPqa33\nVHUJ0JKSBKeiSltl4goc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATtuuF/0Y4hVefnES1HqHrRSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmUzMjgxNS05OWRkLTRkZTYtYjNmMS1mNTAxZWIwYjcwNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6ZgU18Vsc9UJ+Fec5vj+jalmHqz3eNNmZDpGwAl+mQEav\nDAnSNsZRtbXwpcYD9xK4825Z+3AoihjtB0Vd5hgro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf0Od2z3PPMq7/ynt2gVDGM2A\n0UQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJeTYuE7oS41BfefYNeBi/lA/P+8TolIVB91iko0xWo7AiEAubUa4LZ5\nDNUAgtvSOIK49YjRDDI+bBEK7XxB7z5KLQs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISARB1ajCj6UnPmUi37+AC6I8JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc3NWU5NTktMmRjZS00ZWNhLWIwMTMtNmJhZjA0ZjgyZmVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWVhOTE1ZTAtZTM3My00ZWU3LWEwOGItYmQ1YWE3OTgx\nMTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3gNGOoYItXddD1Eq0v+FYf4Q\n4JDwpYjiSwDSJOSTy6RYQskCSr93+ir3cxMJbTJdlDmWrqLflPoGcTLhu4dD/aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUq21OGeZoPWfg8h6MHeW5+xcFxiEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIB1AtqH6\nHG46SXXG6cfrS77VXWAqm65K+q0VG1pFMOSdAiAdCUowiQUR10ttGXESRfGjxgiy\n5zzoRluoB+STjr4ZlA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc632", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `632` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISATLmQKqj+hxNj3i+H17yQ08sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2YTkwNTU4LTg4YjQtNDgxNS04Yzk3LThmYTFlZmNlNmJhNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA1YzRkZmUtYTU0\nMi00OWRiLWFhY2EtYTYyNmY5NGZmNjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm379X0faNcXmankWrYzFsWbdkHoutjWf8uNugTqmvGjDVI7dvAuqb0KkHvpm\nKOQCihPclj6NZzQAjwMMZMS+/KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQVGe3naO/XcY6wxG+tdJaREqZQYwHwYDVR0j\nBBgwFoAUcEJv7XoxFTYs8PHBVPEidbknaP4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDxKv8KP2j/ezEqyf2NbifZ0oW2my7bQ8NiARs7Oxmq2QIgKCpY0ryg\n14pAkfZ7nPrf1XEIZdOzQtlxHMz/TgbuEBg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZnsibzXw1EKzHq5aARi3xtIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNmE5MDU1OC04OGI0LTQ4MTUtOGM5Ny04ZmExZWZjZTZiYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsnD2FwIIGE/kOK7EZq8pEPMKRKMjs5EeaspypPiBCC0o6\nmGLNCXtTVc+P8+QbIqZOAiz/04UwVTkCFiKJHu0No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcEJv7XoxFTYs8PHBVPEidbkn\naP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKMiuI0SAERJDcE8i942hngYln7eQFVVYzD+svc69XNdAiEAuUv0lsx4\nunZwJobE1xcKkxvfUINr8KH84ztyemWwIzM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWlwQ4bGBFDfYZy+hFo15lFQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA1YzRkZmUtYTU0Mi00OWRiLWFhY2EtYTYyNmY5NGZmNjI0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGEyYzE4ZjMtNDM4YS00YWVlLWFmNDItNGRkZWY4YTVl\nNGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXrDg05yORoUVzXBwpUun8xhY\nV5JRUGvjal/UEY+U7K6ESuigFjHZa/De895SbqqgMK6Y8cdNTRbKsEIsbucWNaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQVGe3naO/XcY6wxG+tdJaREqZQYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHcXgxrE\n89rMvYscjPtlLgW5VRj5YsXYXC0SHPWCJBEwAiEAoQQhcQ55vJ3hb01GMcI6H8D8\nJYXRH2P99jFKis6J8Vo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc633", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `633` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAXTQCIZ3whxneUYWGN+nEUGoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMWVmNDkxLTkxNDYtNGNmYy05NDY5LTBjMjQzMjBhYWQ4ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ3OWVlYTEtZTE0\nYi00ZjkwLTllY2MtZWE3NjlkYzFlMGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMzk3CX5Jqah5WLRu5cnZ3eW3oqCnSAC8NJLNE6AF1kjdFGAXCCzpvSqQAESL\n9y5EZETZ5Mr8k5r8HqFZ4nTQVaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+82aV262V3cpqj60lXpM4RnppwowHwYDVR0j\nBBgwFoAU5BRP8uPY3MOgdgGYSduuyAWLProwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIHoUooiBH4bHLMC9eCg7vG/SU6tRA6HFbeAGfZbf2/ukAiEAlEW50D4H\np1QwGPHPVdb0rEqIwuXSgPfuXT38XJ99U+I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZFLr1VQOYIIC5cBpV5kdDHjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTFlZjQ5MS05MTQ2LTRjZmMtOTQ2OS0wYzI0MzIwYWFkOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARH+L7kNLWsFeBM8CJS7NarF+OoWcM9Ukx7g3LwXgKprl+q\nQprywHsMRXxCk6J+4M8fhKLAQLoeO5Iv80GB9Ir+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5BRP8uPY3MOgdgGYSduuyAWL\nProwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZXnXUAWI7MkRhymynMQHG4hdEv61/dElbLEg7ZMJ2iECIQCq3Xk5ziCb\nmWoD3kXPYVi/+6O8wWmB3/0IijWsKK0tEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVbRfpnOMGdyHyuhy6UzB1fFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ3OWVlYTEtZTE0Yi00ZjkwLTllY2MtZWE3NjlkYzFlMGI3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzFlN2RlZDAtZGRmYy00ZTcxLWIwYzQtYWFmZGZhZjUy\nYjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy0sfAAx3PEoD9OCyd0cdr8Gh\nt+SPvHCyd0YyMZvk+n1KEqvqrUG6B89EgaLJiMRtRdnuRTCJf0U+PQoKyo8YdqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+82aV262V3cpqj60lXpM4RnppwowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCVHWWJ\nXXSF2DaI6AUHhRA16i4JGcfeu3CB9t0F8jOFcgIhAKWuku3275GY6F1TuyPrjzCu\nl6l8c6x5f645y4ZLQYo8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc634", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `634` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAaKlqTRR8YOqKh+0Tg5tGyGaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5OTNhM2I0LTljMGYtNDhhNS1hODhhLTY5Mzc2ZWZhYTllZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI5ZGUyYjMtOGU2\nNC00MTJiLWI3MTQtNjg1YzE5ZmQzYjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElDJBS0giCVuVGcxXa7cfx8MWyZB82StuGBxuSi3O/VxJfhbiCOIb4J9abYVf\nnxo0SMNxI6uzxmPIM+iarZuDOaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2QlMJvWgmDcboA6XPYaDc3V6ew8wHwYDVR0j\nBBgwFoAU3GFRXFIEYOQCLMy31Dye9JOVZdEwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQCFslkEQO22nXJRV6P2e3nJ3Qh9+boAAAgBYLHDqSfO8wIgVg0txHPKQ33IfyZf\ngDMeeSrjXmhYfmIBhRLWYge49k0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYypTJ2JsBPM1KCJkNA1MSEtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTkzYTNiNC05YzBmLTQ4YTUtYTg4YS02OTM3NmVmYWE5ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNnNfWIrYPBvFYmz+M6Nx8buYxuYH1TxpkPRgfu5DDi7je\neV0fXH+/nB70shvYwdPpm5KpuGzG1cPnCLCNMxtYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3GFRXFIEYOQCLMy31Dye9JOV\nZdEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCHuOpyqGodWdLYMgu/ULW5f89P0VCjr1AJWo1TqQ2IcCIQDnabKA+rCB\nEjH5D4RKC3UXEfKaOHA7kyXxMITJvhYtzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAa+sGawIcmRW+P5+CeTG9TBGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI5ZGUyYjMtOGU2NC00MTJiLWI3MTQtNjg1YzE5ZmQzYjRlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmNlMmU0NWYtMDY2Yi00NTg3LTg5NjMtMjdlOTNjZTQz\nZGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp8KyyVAHqEhWrYh/c4MUNuQq\nmxqLH+KbOFbOD0gfnkzqURaraGLekbuU+QPHuCpNLk9G4C7OiXg0u686TuniQ6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2QlMJvWgmDcboA6XPYaDc3V6ew8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCxKzpf\naD7lTjEyi9K2pStl+3oOLA4Tq5rkVtKf8TKCDwIhAJZ1Ei2Y7idYFphSS9LH8iE9\nMB46CNI1bf11KZd9mKXH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc635", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `635` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAc6R/DnA7d34Kx417H0TZ7x/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxOTQ2N2Q2LTRlMDYtNDlkZS1hOTAxLTQzZjI2ODBhNzJlZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRiMzQ5ZTYtNWM5\nYi00MjA2LWI3NGEtMTIyZTVjNmUwMjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3MmmmzrfHymdUkPujXKQwT+Ubvdv+kjprouBVE1GG7o6W86JxPoth4LHwqT1\n1wARipSF6d7hYWQxkTFY61KIcKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMlz0qG2zuLKtgoRvs/G64ykXIPMwHwYDVR0j\nBBgwFoAUSa6qMBFno+sCRVs/4ZHoOZWaxL8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDvSKs0D1YiC8rxP6cydYy9kNojcoK2q5y1v6it2m/DmwIg\nKsJndL8TvkKYbmLUzqd6tVHnSdlkWSbqcA71kGCnZjA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATohXk2ZqvMqhyiLLjvwp1GeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTk0NjdkNi00ZTA2LTQ5ZGUtYTkwMS00M2YyNjgwYTcyZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqIyINEbz2JZa0RWKeSCWY4BxBIuJ6kQ7NWjRHWu8sbMrH\nU1N8MYehNz9VGK3VdrJ//usoCq3PwPHhde3SErmYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSa6qMBFno+sCRVs/4ZHoOZWa\nxL8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ3aH1cwNTxveYJodQuasqFnwJCAivlgY8D4IPmWuTPxAiANixzxoCYm\nDvIrp298TNtmBTxEjHBBOUCj6I7d7VcDaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASGvV8h8m9yR+1hu1kjdWnwgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRiMzQ5ZTYtNWM5Yi00MjA2LWI3NGEtMTIyZTVjNmUwMjY0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjI3MzE3MWQtZTI2Mi00MmY0LWE1MWItZGI3MGU4M2Jm\nMDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8tfzOWaxKzFAA8y1wSmdX7Zd\nNly9XJJD/x2qV6ny3PVOSTetjSsJN8nGL1bTsqt3lkXHfr0BQ3eK+lsf3EtoIKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMlz0qG2zuLKtgoRvs/G64ykXIPMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIA6CC6aP\nB6LDdmmqM/cxgYx2CAmOYU8clbi4bq9UE0znAiEAxbr2ly5xINtyelodBHJPv3ES\nAAvFWEuNidM5GjBSugY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc636", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `636` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAZ4JbEA0lmYUVQRfBzJaLA5PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwODlkMzBkLTUyYjgtNDdmYS1hYmVjLTNmNDA5YjU4YmIwMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY4ZWEyMjktYTM0\nMy00ZDMxLThiN2EtYzk4NGYwZTA5NzcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEotWf9+85yBX0uWg3aQ8aD9ti9OLUIzQDAFxS0Jxxb6DnkpTiPEgDIgPoms95\n3Rqi6PLs3dYfv8T+JcjEa9HBfKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYGdoc+binAGGkSrUtLxyI9nIS54wHwYDVR0j\nBBgwFoAU0wq9GLu0iArs4Lk56MufdvJzQ8QwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIFa8t2Y65TCyztSYQpb200AP+zqV5+3PHXxvaulCwnI6AiAx\n3pBbR0K8pH4N9Bm79ciJEoLjndY72x6vv299E/bWFw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASFEiwiYyHtsHrInVMNSGBfTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDg5ZDMwZC01MmI4LTQ3ZmEtYWJlYy0zZjQwOWI1OGJiMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdQIQ6jiGweWdIx5dL4Y/LXGshyFKnvwxyFN5M/rO9XGjg\nITw+JBcsJ3yQyHki74twWiv+dulhJ8lfsTxyr3Bao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0wq9GLu0iArs4Lk56MufdvJz\nQ8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANBxU0S3WyitkW44hLPAbG4q2kMkWCR1WpuclrR1pWlKAiEAmpQGu7bG\naD1fBFeVz6iV7gYLnUP7Wr6SGQEAbrDnEnU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQlGVzgu/NTmubA/srGaJpgVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY4ZWEyMjktYTM0My00ZDMxLThiN2EtYzk4NGYwZTA5NzcwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjU3ZDRmNTAtODk2Ni00ZWI0LTk3YjktMTQyZTRmYjkz\nZTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYRaYl0R/iC+qOvGNHlqyL+d3\n9Zw35HqzhkdPsRQKP7fZMumGkP5jl/GxNh8uzmrSM+VFJIh9/XaeR3iS2o32KaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYGdoc+binAGGkSrUtLxyI9nIS54wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBUnevgQ\noKKv3qmN5vk8/nZe/eHb2tugiJBUQKh4onsMAiEAvfvjG69KDsAQj7HpQSugZcmd\nYTQ6LZyjGbbk084NgSI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc637", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `637` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAURK+w6U0rXCGAlSkyCegEn7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5NWQ1NDMzLTE0ZDMtNGVmMS05ZWMwLTY2MDliMDU3OGVhODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWI0YzNkZGQtYjJm\nZS00ZTkwLWE5NzctZmIxNjUzNjkyYzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6rObDynPRdZ3v5Lr9dJI1W6kmfNfin/508B54zYew4BStVdsNYekHMpkTsZ9\nj/6emOkBtyY3SCz5ZvcSiJlUvKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8QijlrjIWRVgbVmeVU7/4zlfeKowHwYDVR0j\nBBgwFoAU95qaXJTOcPrtEXqugxFcgIY02wgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCBrLop09No\nKGMtKpeDX8b74kkv5ByV1OtR1gTzUJpDxAIgP4QcoYdPVYmjgA2VHga1Qo0JDPmd\nVUr+hh9euw67asY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfC8L5NHLzXAo9NKu7YG1x8zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTVkNTQzMy0xNGQzLTRlZjEtOWVjMC02NjA5YjA1NzhlYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeMiJ33ceZPm3XidsU0T4BwpltXoXCVGKYH3Cq7LWMv5Ak\nwqEc3rtl9/74BuJ1iMPnpjRY98XUCe4gO3XNns81o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU95qaXJTOcPrtEXqugxFcgIY0\n2wgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM3dy+TfS+IMpiukBHkd9eKQRbb5nLIVCd28zW+WwhBjAiEA43rylxBQ\nGht3NYN/PcV+3zzHN0+tlCtlfzu4CGN1BQU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAa9nwWA41J4SYTAGY6lDnyr0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWI0YzNkZGQtYjJmZS00ZTkwLWE5NzctZmIxNjUzNjkyYzE4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2JlMTdiMTctMzY1OS00ZjE3LThkNTItYjI5MjlkMjMx\nNjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsrMH9+dF6QY+OOMBX7tnJeJ9\npx/36749vyRgmy4Y3+gWKujO+xMZsp7CeRMx+022cLWlG+8kZw+CXqdoSvZsGqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8QijlrjIWRVgbVmeVU7/4zlfeKowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDgfvLW\nBPxHaiDvCbP3XPPTBwyjSTqR37TjbYKDF7n5IAIgRnKISn3MbytcI2vsdH6awjGa\njaAAJ0UvkDMPttwsLSA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc638", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `638` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISARcEkNI3HHEs9+NjXAKS5X9nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0YjkxOTQ4LTM4NTgtNGZkNi1iNzQyLTZmYzFiNWYzYTU2ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRmMmNhMDMtYzNm\nNC00MmFhLWFhMTktOGM1ODdjYWMyNTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERTBnuc+vf5WVQZR81M0RzsCj36ZQdWQWRWj5+p0ZPhD+IPOqo6mrCuuUVwjP\nGM9zkeRFnMt/aX7Tkiszj4h+bKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8HDpBIQVikC7M0qKdJLtI4WZNoUwHwYDVR0j\nBBgwFoAUfdb1OgAN/KCb9MVXR/y+dJL6QbUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgSomqaJEr2etuc76H5lccYZiC8vNXmI9dWjFLfYdisJECIFwQlSHtia0y\nQ1ELl7QHCkElTIFLXD+w+sgF6UeK0oU1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYbuzMXBrDSDRwX4p4GLnJH8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGI5MTk0OC0zODU4LTRmZDYtYjc0Mi02ZmMxYjVmM2E1NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQywOdIKHkHrkPfAaEYSCYQoXfV5MyyQ19y4q6DX3sj/V51\neUkXu7mvHIgW5Oa4pwFLrDGvnRwmoYYWAeas6E82o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfdb1OgAN/KCb9MVXR/y+dJL6\nQbUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFiKVVitSW+MrBWn48EXTIySdN4VX5be3/xkS2aFNFuUCIFVFliZHL9VQ\nn6S18Xmi7jwuOIG+xxkmQzCnA5zxZZJy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQvneV9QX1Zlh3LurKde/dOOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRmMmNhMDMtYzNmNC00MmFhLWFhMTktOGM1ODdjYWMyNTlkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzZhOTYwNjUtNmNjNy00NDljLTg1YmItZTI2ZjQ3YjJi\nZTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExTWCuA19LQ9ojgIo3pXcCbn+\n/lagjkrOt92zJqbyPfLIxUoMUSvMIA6YXsLqlmlGICtkGiYRhUpH+yPiItbOTaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8HDpBIQVikC7M0qKdJLtI4WZNoUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIC1K5lft\nu9IPhb8vQbay71sOcT9CX1ZMYrf5HCGzx683AiEA3Fg+nPhR2j1TbtSHzgj21HFg\nFppcEXG6dIVe48vmYJo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc639", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `639` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAUcvT952fEQ8+KSY+OJSOTJLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1OGZiMWFkLTI0M2UtNGFhNC05YTE1LThiOTRiYTY1Y2UyOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFmYzVjYTMtYzJm\nNy00YzRmLThjMGMtYWI3NDEzZGEzN2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW4uLpYVkSPb4AB1dh98o6Ubi17fZQ3Vvp5xXc+c9BNMPLGRFAcpF/Tih4/Ae\nx6Xj0r7wRp4Z4M+C4OQ9nuil8qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEBI+KeRBUJsNwcmCeefRIanRif8wHwYDVR0j\nBBgwFoAUfEmWKoGQ8bJp6WIV4Cc0IhXHI2cwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPxqzm3CF4cgj0vKFUnC2Bp9ucTXRReUu8nol3be3aI6AiEAjzi+/Dih\nuLyZ8df6o8lJve70OT5VfKqFUoueQEi22TI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUM2xJXyI3f5iu1cYRUZ6QQrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNThmYjFhZC0yNDNlLTRhYTQtOWExNS04Yjk0YmE2NWNlMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGPiaQhgpI+D+vT0VJVJqpuo3AwYQnhyJ0Qtcul5XHRrvX\nPLSWQxJKxKMW17euNVpzvkuPb9LSSXm3aQIAJEn2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEmWKoGQ8bJp6WIV4Cc0IhXH\nI2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMUslbzN/TKM8MnrqnxpvOyR0Gyd0sFT9yI4plekMGlECICTTKYUoKesd\nA34eL+znxFm1qCx3I9rNhXlpnHE/766c\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAX4vcNfuNldhx7LXVYStiLk9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFmYzVjYTMtYzJmNy00YzRmLThjMGMtYWI3NDEzZGEzN2EyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjk2NWY1NWMtYWMyZS00MTRkLTkwZjUtNDc0N2JlNDcx\nOWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExIJ6V5RBuWn5/+w8xCxNkAZu\nIIatyfz05S1+8W5iR7js/yO6xTXMYmgI2oO7pwP6xAbGxwuvsBaefC1LzV6zl6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEBI+KeRBUJsNwcmCeefRIanRif8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIHdaexK3\nr6RJPTzReliSdAHZXqkf1TW4FbeQKj8HbY+5AiAkOxjmmtdVRYueFAus5xre1NZ8\nSk+4h9dNVj9VM/sdQg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc640", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `640` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAVDS01XvMAQ7DZ3cUCRf7/ZzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZWI1Njc4LTc3NDQtNDJjNS05NWYzLWMwNzU0Mjk0NzAyNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA1ODA1ZmMtNzY3\nNC00YzE1LTkxZGQtOTYzM2Y3ODQ5MDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKvOXF+lUhKd7ARH60RPfwqTu1g725gcRIdSNAWsp3Du7zAJeYJ0moM37Xsyk\ngXX+XOBBL3fTyEL29yFSc+/wd6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSElDQtqYJcEr16RvQeSvlarbvnUwHwYDVR0j\nBBgwFoAUV3NWz6w0T4aInsujI3nz96rpZEswOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDLvS8MpoBu9wakK+D/Kuf6korjdCI0e6G09aDYl5/9lQIhANQRZUPT\nShCnGjEuu/Y+L0V5Top2Jx3nC4HVBhFX+YZF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdFdMVD/QUu4gIm5uCiT8BuyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWViNTY3OC03NzQ0LTQyYzUtOTVmMy1jMDc1NDI5NDcwMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2BQUlweo4QOyIvE9QS8fZvjg9FZLJJ0h8F/4XAK+Ia4bn\nVYSI+hgH7h0IuR2R/G/2uRqpzDKrx5IrmXhJg/ICo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV3NWz6w0T4aInsujI3nz96rp\nZEswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL/VW1jauzYv7Vgs34eUrLYPFwz9YX8qIhBnU6p/vkESAiEAzqx+7124\n1HuDyOLJxYiggDT/uUtjD8WlSJ8lJ49BiTc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATT6f56hCLuT8J2udvtr8Fc+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA1ODA1ZmMtNzY3NC00YzE1LTkxZGQtOTYzM2Y3ODQ5MDUzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTE3MjU2MmMtNzc2Ni00ZjkxLWJjZDgtODcwZjA0NTcz\nM2ViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmjne4kdfiKhhpTNVLEOXj9gG\njGVZVABfwsAdNWL1ogXrE8bGPLcqfdH6Tiibhl6wmvHZ5xw/VvOuLnFdBQ3ECKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSElDQtqYJcEr16RvQeSvlarbvnUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDyOBgd\n0mABEIE1O3FGojLuNtGmunX2aK+MZkjkxM7vVAIgTynzU7tl03tgjK5dh+nGOUig\nBAg3xEfm1TX5c4FSFeQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc641", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `641` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAZSi58eIdZ632LBW+4Q6+CdzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMzg3N2QyLTdhODQtNDA4NS1iN2ZkLTliZTM3YWYzNmIxMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUzOWM5Y2MtMTY2\nNy00YjNhLWFhMGQtNTAzNDRjZjY2YzA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZKsrkSd2lR6LxznW5ShzBgbRECaP+3DrxqD++pIWfqqDthUoaVR1VYru5B29\nQYM1TXXYyu3Sbd4Ys7opdIHgj6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZD/hf796cF2HbY+/LiXq2uDXbU8wHwYDVR0j\nBBgwFoAUlBdSiKUl1QaSyad5dmk3Kj6PGCswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDm5aw6sGP2Lfm63Y7VS/rh/bbxmUlSE3P8m5F2\n/IHYggIhAIBkHR3NyK8dfBawDwQPwdLZo5OVT4TgCetLnVQKl0tf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfi6XTPiqNnpgOwYmhC2KerUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjM4NzdkMi03YTg0LTQwODUtYjdmZC05YmUzN2FmMzZiMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2rYeLDvpMk4Yp7j+tsvgBWHD4m7m3schp3TnpoLWmoYli\ns0QIfs2Hx0ANtCC1O4Uh/mE5SmFH7rTX5lhmr/t6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlBdSiKUl1QaSyad5dmk3Kj6P\nGCswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMI9ov+6Z90PcMDIkf6z/PZlfnMFG5u8q7uEQv+TS0NOAiEA+eSgjUYm\nI+CU6V97ww79J9SSVZqQ3Esbi0tFwC6PgSg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAeKhjY99TwVBDAIb6jWQRHuXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUzOWM5Y2MtMTY2Ny00YjNhLWFhMGQtNTAzNDRjZjY2YzA1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTE0ZGY3NjUtNjk1ZS00MTdmLTkzNTgtNmMwYTAyMzll\nYzEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfQwycFwILTnet2nZYERHLHXg\nkzdk+ksQsLSsaFpkE8ULWfIfySDtHnaPUoqhbqq6pyZ4GtpBEYdiZGAyxKdUI6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZD/hf796cF2HbY+/LiXq2uDXbU8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAV5rX8j\neVSkkD8VaGJrWvTzI1DQCjvNuZnjzcIkh2hKAiB36+zS1PwDlgcGCn3sRQ+d+JBl\n44Ivc2rBwRGVYJD0yA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc642", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `642` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISARit1omNjGEkjSuWTGk2YeFgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMDQ2ZmRlLTBkZGItNGJmMi05ODUxLWIyNzlmYzYxNDM4YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI1MDg2ZTQtODEw\nZS00OGI5LTk2MWEtOGU4YmRmODAwN2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIMTSh31vdDty+tSpVdPbBVyiS8zqRJSmhSbH/tb2Elh+zyxvuZNM4hOZEDS6\nSPII/gRlAeINx6mQw/ac/srxFaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi5WWBdMrXGBFzwBQzaQZLPsMQSMwHwYDVR0j\nBBgwFoAUU/pFQltkws63Bg6EAEVxt0h8YQwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCICFp3SBLUaAKqzpLjn20fRIFg5NsbucBc47nodqg\n/jNKAiEAjFLo+AnCM+M/4PdGQ5E/p/lUu0+dKYJUTFpt9H6iJ04=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAauFWVCUOSlVTZtFr6fnQs8XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjA0NmZkZS0wZGRiLTRiZjItOTg1MS1iMjc5ZmM2MTQzOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZz79Y/gkAV7/94UmU5Jt2Iv2hbca73DLWEh1xnxXR/lJt\nqwCUfZhr5zWWT3z16zJ+uuMJKVDizNQsCw0WmTSpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU/pFQltkws63Bg6EAEVxt0h8\nYQwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgX2+hg1hKPeG2wUC1qsNdRw0/zYFDJth8TCraIvWO41oCIEGvCuwX2/KO\nupUvhNTgtn+1qHfmUZKn6mssmiq2CiSw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdBOxs6pywkUOUxaDeLrmY8MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI1MDg2ZTQtODEwZS00OGI5LTk2MWEtOGU4YmRmODAwN2E1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTc3ZDgwZDktOTIzYy00OWZjLTljZGItOTcxM2JjYjg3\nMmYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqvCp+Oq3aNCosmJqvMpQn5MC\nxzQpOKAAXd7/J4loJpO1PXCZHFUA+yEPZTbsyJlSF1xLXIiYL1K7LPnL+EoSCaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUi5WWBdMrXGBFzwBQzaQZLPsMQSMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBQ4kgsj\niv0Y+tPLnw+wB/9TMhjB4lCgCbbnoqVt1sqpAiEAgohriMN9dxUFPMZbAfqJ44AZ\nySSIueRHp6AvRojHumY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc643", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `643` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVdFTFpkG2s88M2FVYjn570+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MmE5NjNmLWMyMWMtNGVlZS05YmZjLWJjMTAzOGQ2ZmMyNjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTcwYzZkNTMtODJl\nNC00NjVjLTk1NGQtMDI0ZDg3NzhkYjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAI7HfV1wtJqzT2/sXfDnuT3oOUygc4IY1bpwL8ZZsrdvRADDYZaNK7qoa/2g\nzDAXSw0WX6dMbr5KH4WaQICtNKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFxOkPmWlx0H3vv/fAe2bcFPQpREwHwYDVR0j\nBBgwFoAUb+dfyKxCZGx8VH8WnRQurcThNvcwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIFE94fSiaTemDWTk/0R8tezH9GJNZPS6DRX9ixuG/bR+AiEA\n7gLcMCTTA8eHjkN/mXf8p3eg3J4fMcKD+XeA3agfoKU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc6YUafXCuthSlJN6Ucw7DoQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODJhOTYzZi1jMjFjLTRlZWUtOWJmYy1iYzEwMzhkNmZjMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5DORa0VBGRuW1eLpZyFYKTHCdG8sFkZzSIOXhM8EUY9r7\nNNrYpHw6OYJrgTOGafe4hI6Jm7QhARvRDgpfGg6mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb+dfyKxCZGx8VH8WnRQurcTh\nNvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIJAfyKzbR1MMLIN93byMf2ZAcKNIM0+Tzg5Xb+G2BuHAiEAkP76F+JP\nilHiiOnx244Na11xKZuZzwTNsgerjIQGOWw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfjdbFJseJl+pqz4Dl/+FkGKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTcwYzZkNTMtODJlNC00NjVjLTk1NGQtMDI0ZDg3NzhkYjVhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2E2YjE3NWItYzE1Ni00ODYwLTk2NDktNDFhOGQ2MTg5\nY2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw0hAZNBnHOp4RaPAafrZ9n+r\nSPuHgB6JkUTbpHV2YAxD+MDX9ZKork+bjr9DXo3gg3eYBAcQaqNJqIBDTdZc2KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFxOkPmWlx0H3vv/fAe2bcFPQpREwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICKIjeIF\n5HJapaaBTDxxx4rnbNKKvmBnwfP/7Il3H/9AAiB4iThvbnHhUQV0h7BHad6xa23Y\no05BaeNhT3UzlUdwHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc644", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `644` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZhFlI5Y6+pYKr34cbtMH0PzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjNmRhZGZiLWUxOWEtNGU0MC05ZDY0LTQxZGM1YjI2MzA3ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjllMWMwYzMtMjYw\nNy00MmMyLTk1ZTItNDRhMTVhYmNhNWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3CgIzYgIuPLi494lECNK48zWmlYthiMcpUb/CT8u9Q3m5PDwSuv1A33R3pNL\ni1zuaNrsq7J5AKm3lkfmIAtNVqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4zp8WvixVysfcNjkYEmuk/IQKCIwHwYDVR0j\nBBgwFoAUzoVJOCAb01UWGPImxzwqXkK8cNQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICfN8NwXrx8MjNkWcP424Hf7cpPnj+sK\ni5Dk40WjRjhfAiAktLt/NoO9kUTuGuAdkPRYojXS11y/jXzqWiBJxX22aQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASujY4TYdla7oUaXOtniKoNGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzZkYWRmYi1lMTlhLTRlNDAtOWQ2NC00MWRjNWIyNjMwN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASblx6L5VMQc7HhUwmra2uayAUvp41Iu5b7Rk94Xd/Sueh3\n0cyKbyi9rxzyCLz99Uggo5c0tmYOQvjaNTchUd+Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzoVJOCAb01UWGPImxzwqXkK8\ncNQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJXfNvcH+leEY67ShvzkS3Vy9pJHIKWM0/ml2jye8YjpAiA0aQHhAFXu\nLjUtlIwpfTYsF3+RhBzxB0szhO5KD2i89w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQRyOZn0CQXP07x7NsNEQXgiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjllMWMwYzMtMjYwNy00MmMyLTk1ZTItNDRhMTVhYmNhNWJiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNiMTRlY2YtNjNlNy00YTkxLTg5NGMtYTBmZjFiNjA0\nNTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETIytQLx+CZMtbXDmkXi2AYYo\nPD3+plZpinQ2hGRBRTuvG14xiA5D6f0pLC6zk4d2zRY9EMMxSB3joSzW2NP+/aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4zp8WvixVysfcNjkYEmuk/IQKCIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGNSHVAF\nCLhzlbQMEMmpIAAqBmzfuEcg4p9W0ni6jMdaAiAakCwXx8GOi9eA32tB8FPkoLsv\nWnC6tGX5r9DRvVXb7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc645", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `645` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfdrtW5z1Ztv/dB2jzKZyMR6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhYTZkZTE5LTBhZDEtNDhhMy1iYTAxLWI5YjY2ZWE4OGYyNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDczNTY3MTUtODk2\nZi00OTM1LTliYTUtYWU3NTA4ZTUyMmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv3JLCjfkcObDQ1Q5hqYPl7BIC54wAgqTvbEtOiHYqwJNNJrkTgHrIQnyLDrB\nfYVccVMP5g4n1VT+7vE7cHze3qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPhyGHOFvni7HDA2y8vaj6c4uHqMwHwYDVR0j\nBBgwFoAUi7+ZfKLIFKEVQChQUusSVX0hLmAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGOJdFVwf7Q3DR6qyluSj6Opx9KCGniH\nq0kq0E8kQP9XAiEAkMCOuxS2QvQuIn8df7el1X/MgGnxoVXKuXMebrOFHXk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR92Xwfyagsz74jvLORtV64rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWE2ZGUxOS0wYWQxLTQ4YTMtYmEwMS1iOWI2NmVhODhmMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+sFYC71K4nH70BVtbqrw/z2VAOURAvxTGZziKIGmwcHJ4\nPRKgsdKdHt77uFQuBXFGKCCn/qyeJdhkod21zq2Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi7+ZfKLIFKEVQChQUusSVX0h\nLmAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPRpTeYXhGqf48WPvqMxdqkHkbH6HTWwU4wLDGPpwNdGAiEA2lEld5dS\n4AbFDrFnWkuN6GywPWBsQ6ZSsXJKKt7ryP0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUHBqcOgFzygBnPHGPxzwmM6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDczNTY3MTUtODk2Zi00OTM1LTliYTUtYWU3NTA4ZTUyMmY0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTczNWY1ZGQtYWQ2OC00NzY4LThmZTQtOWVlNzgzYzBh\nNjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuhVPSUZzKfgeHvApyhqmO0ih\nSXxs+DgRE9soNpZLQ+fLeB3xYbVQb50yoNrHxZEP2EBffxyUnvi/+q4CmvYIE6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPhyGHOFvni7HDA2y8vaj6c4uHqMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBNXh9eM\nuwvD9iiJlXnG3hXyqO5gHDpOp3zAGr0GZRXBAiEA39Ml8KG/Xypy5dbsda/Zv2LF\nJgaWKWy07It7mvXb+sc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc646", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `646` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASgShGIMMFFxan1ALpmdWmdFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiNDMwYjExLTYyMmItNGQyZi05OWEyLThiNWZkMjg4YzBmMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JlY2JjZmEtNDFh\nNS00Nzk3LTlmNjgtMmVhYmI0ZmI2ZWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKIpLJWFXbUDbKyFIq7b6j3oEmLtWDo1JO364F3QPFdMrB8/ErjC8SCFeUw4d\nM+dzIA46XYIUhbVN3ltIlZ0WzKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCV19AwLgnOeMEBYRKucvOWqKK+0wHwYDVR0j\nBBgwFoAUZrAjwsGzQiD72HBp9ORfreRxWHEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD9bMZR/AFo\n++rcSQBhqjD+FXdFrI85vn6/0gHsyGFLIQIhAJLV4m95o02y+exs8Fu7+IzRfg8o\n1nKYnHjhlXTHaEWt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARfpkR74aCrrBZJBQed6g4FfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjQzMGIxMS02MjJiLTRkMmYtOTlhMi04YjVmZDI4OGMwZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmbVxPAXpN9O1yl3gBoXZiiTwkwZw2BTZoAapDHHYC9K/o\n6s3P1LuG2Qc8QKzBkpTzBFfUSGX6vTrTkzcKkLFxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZrAjwsGzQiD72HBp9ORfreRx\nWHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALq+se0dRnsTUry5OT62c6jE0msDFo5YIw+iqjfDemMQAiEA3rdZPXLV\n2AcV0XRuZQ+sW74kzlO6XL4eKztulIbHjYM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdAKdaPYN1XnVTIH4FmVdwP7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JlY2JjZmEtNDFhNS00Nzk3LTlmNjgtMmVhYmI0ZmI2ZWY3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmU1YzlhYmUtNjVhNi00YWJhLWIxNTQtODE4NjYwMTFm\nZTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHKTEeC1M4ZFc/Q8W9Q/QmHJC\n9m7k+lVGUaSCmjcMuWZIEm6h/gf6JoKnEt/wLZQI6TXkIgjq5zfLGt/6v6PULaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCV19AwLgnOeMEBYRKucvOWqKK+0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGhSRnLW\nk6W9LHaE/gAjpViiY6NQlDrAUSpKq2WxfR67AiEAwIbj2z0s15XmT3VYZVblZwWU\n98/3USq2J0hE/wRm8+k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc647", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `647` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAciVYibcGn2G8CjhwrbMdQj/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwZmQ5YzNlLTY2MzItNDU4Ny04MDkyLWZiMWZmYWM3OTg5ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQwYWY0ZjItODA5\nOC00M2FhLWI4ZDgtMGM0YTAyODg5Y2MzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJo9DoZduD8fqHlAzGUyAtG1G+ilgUaVzb/2wbVvrL42aUorGLIyaN1f7r9xf\nkp17Vvz3deWyIaF/x8iCF3AFUKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdZhHsX52HVLuB0keNWJO0JHOUC8wHwYDVR0j\nBBgwFoAULTHFzfAOcMPOlB1rk3y/0MfS9I4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgCaH8R2kCw67o98YgpnKaOAHcVDx+yn5y8COaOvWgQ9sCIQD1q9isHExZ\nmrtx4z6ymwA7r19HALKlnGOaNG5bOTT5Mg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVYkkrFSnCNbY0hikKFKBdSEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGZkOWMzZS02NjMyLTQ1ODctODA5Mi1mYjFmZmFjNzk4OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOmBQ45G/wJVTtlIjtcmQ+MyYwM6XgJHUbtHBeK3DshxdF\nasT56DldDI5phdM/LFcqU3oD85XqrYuey0NZmi9uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULTHFzfAOcMPOlB1rk3y/0MfS\n9I4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL1zD3fIHC18WfQURB08h/FQjJizRdSPnDbAuv3TVXjWAiBXH0qKuEqu\nybEJL9UDyF4057ch8+6PGpW1Dq/qIyitCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAfX6o3CZI8kcUIcvnEZnsKQhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQwYWY0ZjItODA5OC00M2FhLWI4ZDgtMGM0YTAyODg5Y2MzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzNkMmVhNzItMjhjYS00MGJiLTgwNDEtNjc5NzFiMjUx\nM2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwLlwh1epOtXFkmJY8ouXG23k\nu3XPbVzn8V1BtBH2xBIOEJFt7TnJHSFdfSzaNBiRN/poT+UT2BjQzEu8isEoEaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdZhHsX52HVLuB0keNWJO0JHOUC8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD6Oyqy\nkc/fLDCjllCjHJfo7DZ6Sse4C2L0L81EKSH1BQIhAJ7jU67fM0wSlRJarIaOZumd\nojvOjcI5n7eOlzwz38ul\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc648", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `648` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfySySo9lWSZ2TtKf21hl0JsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwMmQ1YzE4LWI4M2QtNDg4OS04OGUxLWE0MDAzYmU1MDhiZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk1OWJjNGItYTcz\nMS00ZTA2LWE1OGUtMDY1NDkyZTExNTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENouDB92UPZjj2xp2yb65wiBnPhop13D4zN+1qikC1eT0QINI7yFbj7JEJ6no\nq27Xr9lefUz+1nC+O6v7Vqt98qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUELk8H2/VkvbEKgfBPhANnRQPANcwHwYDVR0j\nBBgwFoAUKNfueDJySKS4QKhZrAeElLFqzsgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgCHudycHxwtgBC8EYtbNwTT1ZUwI8CItJxsrhgENkwo4CIQDxWZFzYzoI\nUvz/r4lXaUcK2gnupHi5Z3xvxEmu+HL92w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaC7taen5UvWLg6VHUoVDY6xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDJkNWMxOC1iODNkLTQ4ODktODhlMS1hNDAwM2JlNTA4YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcUM9NrIzt3YgXinJi7knNWgNyQaamsLrw2h3o6FLZL6Fq\nXDrs6RP2ta3v/Oon7yXHtsDx332i6vF+gsgpoyXZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKNfueDJySKS4QKhZrAeElLFq\nzsgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOtvmeblSyvebKqNz9BjTh9xjyAsnjxUrWXYrxsIR8aCAiAzr940rtKH\nVCXgSNQqhU51vlpp2iBvKXm8jDM7FtM3SQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAai1NbvCQSj+5UIFzgFERj3WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk1OWJjNGItYTczMS00ZTA2LWE1OGUtMDY1NDkyZTExNTNjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTI5YTUzMDMtYThmMS00NDlhLTg0ZmItZWMzNGU3OTY5\nZmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQ/uv51eH8YYH8qsMxClCCO6f\nW9vPvwzidblMpAhudSa95kQEePUewsJUt54OTGaCvMzveF3XAzsG0SKVZCIa1KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUELk8H2/VkvbEKgfBPhANnRQPANcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCK/wqU\nxNUp+4c1JOoqkzLqxUJGb+2UnAe2IwCEcLgsbwIhANeoMrhAIexIthufUat0LHoG\nNBMhuzyTajt6INQ7G5Xd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc649", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `649` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAZjG34vBNyxmkXSr63GCJGBhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxMTdhNTRkLTg2OTItNDE0My1iY2RlLTNhZDVhNTc3MWZmZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTljZThmYjgtMTA2\nYS00YjA4LWFlMjktZDk5MzY3YzliY2EzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5oDsNLLmI+v28c5kRIAFCe97ATp/VcUkVUSb2KV96eWLpflikJyWacg/1zz8\nFM34RP/tZqTCmzIC6gUFGvR/taOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbwYlOEzWBdBAMvMj9XGx6WjHVrowHwYDVR0j\nBBgwFoAUArS22Hhs2pE/1099EwNQS3Lw7FEwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIFgOcrHOLSTLTTc+W+HqgMVhxwMb+P+5lYQqMLWql9IeAiEA5pmsax9Y\neYl+RMDp7NzxdAD7l4rRsMS2kftu8+dnMf8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS4z6QWlGdagnz+zDUvStbogMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTE3YTU0ZC04NjkyLTQxNDMtYmNkZS0zYWQ1YTU3NzFmZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0ITDYxsJESVB0DLplU+SUsU5XTrIYLtcXBEvPg2eo75qP\n3dUsQ6lC0Nn5v76GLdalWFCUErSalOOwD3K7Fr5bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUArS22Hhs2pE/1099EwNQS3Lw\n7FEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN4RLEyMQWsWDB2DwsiubcVwOf5dJ+ya9k+KGC7oOjkcAiBUEhX6qKuS\n9aYWd3tzAyrdsIf8xpkUYa24NPL4BK9tFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAeDsUrYnvmV+uRkj7jbphpSJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTljZThmYjgtMTA2YS00YjA4LWFlMjktZDk5MzY3YzliY2EzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2IxZTdhMjQtZTQzOS00MDcyLTk2MTEtMDM0Mjc1YzFj\nY2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPKoQpXldsETWCIJKNLPE38hL\n5TEbqFT3fqyjM7TY9UvHPzILQgh180wgbF+4/wynlm7LhN5NGW6Y2uSJFtjvXaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbwYlOEzWBdBAMvMj9XGx6WjHVrowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIAJiITa8\nskr9WpI0bg6UdG7cbwi0Y6DVv3YxSBhLbq/vAiEA7Cm3oIQcT7opS2Ht3HirPlIv\nfOFvN5fXYSDGbepxddk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc650", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `650` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAdQwCjV7Y6kSbX/8ifnhY2SKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxM2FjOGQ2LWQ1MmYtNGJjOC05Yjc4LWE2Y2UxMDg0MDIzMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE5MGRhNTktNmQ5\nZC00OTgwLThkZDctY2I3MzJjYTk3ZDFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX6/OSWZIyljcObV6XqYC7YcculoBxxBFaxfqG2CBlBzDlAtQK+ugJ5m78NJg\nRWRcqmi2T9jsrwfIUuiqYnZ/S6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlkbLL7Sq9sHLp6/WZwkKSxLwKKswHwYDVR0j\nBBgwFoAUOqExWuzolFYnDFNP8AjyWjlOkrAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCkckZNsDzTJwNdmhJhI7ULyrhvuNUFokBZ3Cwe\nI3qYzAIgN1OOXZGG2qE+U9sxnKEUQiPXBm9pemEVPzLf0CP2tOY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWAYPuDd5C/6mGEp90BZZr+4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTNhYzhkNi1kNTJmLTRiYzgtOWI3OC1hNmNlMTA4NDAyMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASINwcuRRRtZCPIZLOr6jzJqpJ1McjfXG5fb4qM3bS/2C60\nKAEsjjneIlpjZ91ySRwXdUw/BziKthEZGtGFfCS/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOqExWuzolFYnDFNP8AjyWjlO\nkrAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHA9N95JlDKshmOQJ6m9bE/BtqB0MPhr5bwAUtdBBj0kCIEAzhBrLdyvQ\nojjm5q/mEGJJAeyt1dDmMcPpKCli2Dkh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQDgAHeGpcHEksRBJ25EOfpOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE5MGRhNTktNmQ5ZC00OTgwLThkZDctY2I3MzJjYTk3ZDFiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTdiZGZkYTMtM2ZiZi00MjJiLTkyMmQtYzFlMDhmMWNi\nMDJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXsh7/HYTql1xASIUY1zoSOzj\n09InNhG4J1sDKbz+tdww4PplLbun6i+MSe4z8Bixd2kcqu4On9iKN7zlbkb5vKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlkbLL7Sq9sHLp6/WZwkKSxLwKKswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDdXQKt\nvl2aZGI7g4KN8+MmN73Kay/04Vy2BHIoUFln0AIgL3S7nvxp3RBkSgZGC23atQCx\nzHYuQEKjnoT5fgIpPt4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc651", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `651` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISARPH7X7sQ7fxs/vdVitcqqZGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MWY4NWZhLWMzMTMtNGY2MS05YjUzLTZmZGQ1YjBiZTk0NTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmMxZWQ5MjQtMWFi\nYS00ZTA1LTg3MjMtMjVmOWM4NTBiMGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsbWjBlLINRlSqKhFEigLdjmwHZbnCS5lgiDEYvlI6qRp1gKjoCzPHsRGxhhy\ncfUrKbh/8gzWymWgfKnMDIJo1KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtPMnxaNso5/xDNRbhioen8Q6vDQwHwYDVR0j\nBBgwFoAUMCRhr/pFMui5ELDswu4G3CPp1r4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIF2yWJjwRSOW8ayW58cCULRyWpCjfG2ZVMwbfSAT\n9SwRAiEA1ngdD5TqAzKVzRElsInhVotSs49YpuSz115+miN6VmI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWBAbY7TT07/Nik5kkEeRkaPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDFmODVmYS1jMzEzLTRmNjEtOWI1My02ZmRkNWIwYmU5NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARY9Kktebce3O6p67TC4JhdX8Vv/aPSLWDqNb95KyODzFXe\nilcMpnic5TMWCI2HQMYzl5a5TsgS/dMw3fhsbR9Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMCRhr/pFMui5ELDswu4G3CPp\n1r4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgR5KNmrbnYDKucCqFcuoV+ttNOU3ZHtq6TuGIFCSY3LICIQDTHl/cirs3\nipGIzrRURWOGgrdfF+m8qcOTmZ27GY6wIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWXq8fLdo2OtvGowB4eijFu4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmMxZWQ5MjQtMWFiYS00ZTA1LTg3MjMtMjVmOWM4NTBiMGJjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWU0YjlmOTYtZWMxOS00OTM2LWIzN2YtZWVkMjhlMDhk\nNTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENyKYohcv+JSbZW6qCJagOQsX\nj5fAICjC8Tgg0XKvvuLqQetHUUZhUueTk5m4MPROImPI2vaeh6aiVmlLii6TiqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtPMnxaNso5/xDNRbhioen8Q6vDQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDUqsdf\nLzbeCk0x47RNb4rVsLcGf3hNn5Gxss9qCSiMuQIgULUcB4Eti7UMMrZ3qP7zIl9K\nrC9fJ2tTStcM4eMCSPQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc652", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `652` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZB5sUs8anVUun0fF0Y0EzKMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1OWI1YzBlLTE0NzYtNDYyOC05N2Q3LTQ0ODk1OTA4OTE2ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNkOGM5MTAtNTg4\nOS00ZDFiLTgzMjMtYmVmODZkZTJlYjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbakBwfWdUgoPoHiVq/glBHZpyGP9oSeixYeJ+UhC8TjCBwgGxYFRAyqvcisB\n+BUTJWnABJZ9acKqoCENmwKtT6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1oXw7dMMNwDXslOq+cIjdpBMz/cwHwYDVR0j\nBBgwFoAUIWBoSYJ8KNfoPIFimnrWwRoLVZUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIFiC8Z5JLvGC8bInZL+OPiD/CNzCLcN+c8pK6zT0dKQTAiEA\nmeEPR9zcrEcJRgPxcEASUbfy+Wh65fp+Yp2UJ6L5vz8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcFNEZQRLBE72yW7VCJUV6wpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTliNWMwZS0xNDc2LTQ2MjgtOTdkNy00NDg5NTkwODkxNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATma4crZTz76tj4Mbs02D5zug5Y7fy+N8LhRYQBKSs5d1Kq\nM6EbcXquQFany+i2ys+c24DwgROwYGXq+pEVdGK6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIWBoSYJ8KNfoPIFimnrWwRoL\nVZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPQ5ft7IN69scwb6cR6h1hqf+fSxF23hADzvnBxh2JTdAiAlWVRSXo1t\nDiG0B6aikoocccaWas3FE+PUkc+iKvUXjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAeM+3qBgi7simJvgewB+ZPyoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNkOGM5MTAtNTg4OS00ZDFiLTgzMjMtYmVmODZkZTJlYjkwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODkwMjcyNjQtMWI3Yy00YWVhLTk0MzEtZDhmNTI1NDg2\nZDEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnsVlqJKa4sqvva7e+LmYpAOH\nAvZGxPaId55BiNcZegO+swTH81eblL8uiA+A6rhK+az7QCxG3LaoqJaodZsXDqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1oXw7dMMNwDXslOq+cIjdpBMz/cwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBcKU3Lj\njuphe9ZyD38arTXYGbPpt3Euz52o1Vp6b4O/AiBKLMolUUs53CXInQRay0kLna6O\nBvtTO1xwdF1j8o0gyg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc653", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `653` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAdPexu7RI0fEu/SXMRf/+C7pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNTc3NmIzLWI1YzAtNDMxMC05ZGI0LTc0MjU1ZmE5NjE5ZjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY3YmVmNjUtNmFk\nYS00NDZmLThlOTYtNjAyOTFjMGNmM2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY7aQqNibLObGRjKD4lzt4AALP9xDV9Gbs0g6SPnSYcWotClxppg2aeFO2si5\n7HgyOzZ1FvPjjsxPR9z69n3KmqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURHKXTX4ffqJ1rn2vNAkb+Okh5fYwHwYDVR0j\nBBgwFoAU1oExuInakWdiqvzz1sPL5zCk9FcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDKqV1zfSrRe1lQs+Rfviqg7Kl90H5O\n5qBKU7oEGObYaQIhAJXUD/W3JytkyEUc9iGT62ZXiE7mWhYg+bvhRMq4/hfR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWvleuEIpvjLr4Nx1YRMpnHHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTU3NzZiMy1iNWMwLTQzMTAtOWRiNC03NDI1NWZhOTYxOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7l0dMzskhg0eYFFcSpjI8IcYOOB29Nlgxt6QrMCBpe5qD\nzIyQMmLcSOjkKTGElbkWbPLR7CeZs35oh5+CS22Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1oExuInakWdiqvzz1sPL5zCk\n9FcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAME+18hGoHjEdbDvZSfmVDjroSg19FsRCvT4crjeukauAiB5nORsn4L2\nwHinNRaKRYRaudyQpBbR7afFN1l6lVrWEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAcTYMBD6P6Vi6lewGEbdQNj6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY3YmVmNjUtNmFkYS00NDZmLThlOTYtNjAyOTFjMGNmM2EwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTgyYWM0ODItN2EwYy00MmUyLTg1NGItNDI2MWExYjgx\nOTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo3x4BzHry/K4oAQL/nGQyjGU\n/C02MMYeKnlIOkCrX7QIdWvIJGkXnVch4wPTlchXP2IFw3Bdc4Xq+666N8zVA6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURHKXTX4ffqJ1rn2vNAkb+Okh5fYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIC4yMiOc\neL135KUJ1FphxxTczGYsN2Be0u33XteeiIpVAiAP7aKgmzEExm3OgXEAhRCqByyZ\nNYcbM4/WsWj9uaxZPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc654", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `654` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAU7fDC6CE8WGuP+PYF7n2yDhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZjU5ZTNhLTUxNzEtNGFjYy04ZDY0LTE5ZGVmMTcyYzRjNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U0YWViYjAtNzY1\nMS00ZDg5LThmNzUtN2NhNGY0YjAyN2I5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElm2vx8RYqpFYm/SzGM1gweuH1WVJShekJHGSypcRNvam8xi+zEdQ7K+lCBbX\nevqbTDq3EQGgf3tQP4GeGaq0g6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO27+bTehnhKvevwRN8SBVZgprZQwHwYDVR0j\nBBgwFoAUsnHxtUXpw1pxNUcImyUzmOobfm8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCICdPd65tJUJ+7LbwrF3GDToUWtfKxfXo\nKRgIOl3gLSYCAiAMucqYPImtXpW6Wv6JyDbepsGivTZKLorlMSK1wmsRhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa/S5R0/mQLqk+VEGH8EAxM+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmY1OWUzYS01MTcxLTRhY2MtOGQ2NC0xOWRlZjE3MmM0YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5wtv1BFKT7QjcKHRa6M2re+6GBdcM/jq6UzYUnS3l9n/h\nZuKKVVq3afLT+bIHbFFmjv2rGeO1W4ZrRqiADEWxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsnHxtUXpw1pxNUcImyUzmOob\nfm8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALKHS5I59j0hUm6k/LoV4np1PlwIXm3mJ06r8+0i2f67AiEAurVHQRr6\nrxjrGsjDe/GXSSyquUybYo83n9Zk8qsqMZQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdEOcRBUSVG1xLzPyTa9lY1MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U0YWViYjAtNzY1MS00ZDg5LThmNzUtN2NhNGY0YjAyN2I5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjRjZTE4MjgtODgxZi00NTBiLWE2MjYtZDI2ODkxN2M4\nNjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdhzSiSdQNYY1JTt4UYzV1nm5\nHx7AQ9HB48Bi2nxdJxWcA8eZNYPY/HgXLwN++atJdImlpWKayt9fNcY1Mf2XcqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO27+bTehnhKvevwRN8SBVZgprZQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGSM+NDR\n4nQtszrZR2ZrJOKAFAdPYkXi2L15vasHFNTdAiEAu/KSxtG0JGDu1Np46tkpD7UE\nxmWwJ7sKiPHXplHwkVQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc655", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `655` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfq2tBoFrBorjAgpqD0JIkmJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1YWVlZWMyLTk0OWQtNDQ0YS05MWRhLTg4YWIzMDMwYzk0YjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk3MzMyZjMtMDIx\nOC00ZTExLTkyN2QtZmUyYzE5ZjQzYTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkFJlMeK2xwT4ERKAMipQ97zVLPftyorpnCEfVpXnsHAeGj8j2JKL6eg0Cq0X\nhV9cQ7n+cfW+ropEHGyyVYsGd6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOG0uFEU0TvSOlxRZQ57KDzgzgCuMB8GA1UdIwQY\nMBaAFOf4pTNugBfJMvazrp6q4XeQCNTlMAoGCCqGSM49BAMCA0cAMEQCIFYUaeVA\ndgSUz4TFkK5fAeJu9bMLdzLAC2Vi0zyhS4rPAiAG7ZsTblYgc7C4gJhGILgXXRbm\n3DSo7mFeq8rCpPh2Pg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZdrK3fhRo4OWbRa57F7JrGCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWFlZWVjMi05NDlkLTQ0NGEtOTFkYS04OGFiMzAzMGM5NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARa06EOIJZ9jzukNX9J0fEAX4w9oeXfuzxw6VPgDpbx9YP7\nlFB3uHKC3qvqJKFW5OyT62kPi59UB4cMYK9kEuBmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/ilM26AF8ky9rOunqrhd5AI\n1OUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKwUF4RdOTXpljeptZ9zcVhOHDIoph8CkfmEdB+bQSVWAiBSC8MtMZN1\np2BoZpl1tGkGeS6aUX0Jym5fD1IDQx8qEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAU/AEVSUzPt/kCp3rMRDR0umMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk3MzMyZjMtMDIxOC00ZTExLTkyN2QtZmUyYzE5ZjQzYTJiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzc5M2UwYzktOTIwYi00MWU0LWJhMjUtOTBlMmU3NTI4\nZDVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhX3CP8V/bUMHFyjRdPgOWKwu\nXvGX8Qzt1+TGvpgD6D+lWl7edXD70fgglo5r9hyMEAFbHRt3saUl/U9nxKvhuqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4bS4URTRO9I6XFFlDnsoPODOAK4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIDzYEEV2\nqzIc2C5p7rIl2WbNZoSiO1b/o5TQa9M1gRFAAiB7SCQrrnrsmLzI2on69URc4yl6\nKhV1vglwvTjY5PdWKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc656", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `656` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZqSw6Ph7ig2VUHuTCrG4U3oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyNjNkODg5LTY4ZTktNDNjZC1hNzdjLTcwMGVlMzJkOWM2MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJkY2I3MGUtYmUw\nNy00NjcwLWE0MDgtNDc4ZTYyODE5YTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbNp/EZ7NKHmqDv/6TdgTsxy+m+1zyEf4iMZ8SxhQdXb0H1cC44/126U3lHVF\nl5A3zrKZOeHL9Ea0WEYMxGDYMKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOO/pxHs7iISTRt2pnstoHj5+imgMB8GA1UdIwQY\nMBaAFNnEtJXIlTdZ0sswrc6sWxZko3jGMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAkBxmtH+JbiGftRHo6JVGeGkEspUMgv/H\nLq9JJq9Si8sCIQC4GhpwQqzK21RNl+1BwEOPdGZuMjS9B4eNu8URHK6ljA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVpexnO9ulHps8a8FujKJed1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjYzZDg4OS02OGU5LTQzY2QtYTc3Yy03MDBlZTMyZDljNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAxa36PqB9yJ/badmxLLYxeLRScHf+Yun+wQO/vYNmjfTT\nqITDAKOMPeR5dW37OFSByelsUyAd5R0HC1yOXzQ+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2cS0lciVN1nSyzCtzqxbFmSj\neMYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTFh2jCkd3e09xlGysxD9tp+mby69sr2jSn1WSxW1z+8CIQC3UssFBn8A\nIV8WSLirTLQ2+eXI0sirX8kDXC/qdvJkXQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAakDqA97len0zlzpC9RpwAWBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJkY2I3MGUtYmUwNy00NjcwLWE0MDgtNDc4ZTYyODE5YTk3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmJkM2U2MDEtYzg1Ni00MmExLTgyZWYtMWI0N2QyZmRh\nYmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEknEgK6O0SNqnKJ+VMK/GDGpy\nLGN6QaufHhlnyfmLW50Cgn/cqDkVkYXndwuxBsLEWdJ7arRSFJsw7aO3NBcHHKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU47+nEezuIhJNG3amey2gePn6KaAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCMsALK\nWXAIe5t/iOzb3MIE0/PIGlSUcNNImPDzWi6kVgIhAKB6//eHWjbBQpCrc6+DeJC+\nPcYHvn11IyQbMXvCJ8aN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc657", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `657` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUpYKQe0lQBCMtUlTE7ZvCU+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkMDUyNDVjLTBjOWEtNGQyNi1hMTU1LTI1N2Y5MGUxYzVmZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc4ZTcxODEtMjc5\nNC00YzJkLThlNjMtNjFkZGZhY2ViNjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2i/eCVzKBXAAMrSOcsgQPfzRur9SEr9GKyDYydQEyiZYGUpPuTLW2NH5BEP5\nG7YUVHloj4ytL9aDBPjTQzvTs6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPxgnhPfHi3Fy5Na5MdUvh1hL2t8MB8GA1UdIwQY\nMBaAFBjPNDG/w49IQ/hFB6QPQ50YimOBMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAq5NWbNGNuJsPwXS83wuDZCL3YgT94uhz\n8GXYSoAxIdkCIF7NxNUlqCHL1pq6p47J1jMisLtF15ev1BG5mzAyoOoe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbJlEasPm/1/bNbVKfB3FLxZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDA1MjQ1Yy0wYzlhLTRkMjYtYTE1NS0yNTdmOTBlMWM1ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+mCG+3EfLHAQenojI7h81g5kUMWbJd2tVzW0rqJlo3k7g\nP8sArHDOuixMtGWJPqIL0lPKoY6zVUh0YH3tltOqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGM80Mb/Dj0hD+EUHpA9DnRiK\nY4EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXAmpLMh+jlVHsnPWq/ymtBt0+IfR8i3r9OG6CQ2fgeECIFNhfNWesUbI\nAy0b1Bo7cK6tkPSKEeEbOAy9CsOYlZPP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAY3FjawDfJO4dM3550t+CJ+NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc4ZTcxODEtMjc5NC00YzJkLThlNjMtNjFkZGZhY2ViNjk2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWE0ZWVjMmQtNWQ5Yi00ZjcyLTg2MjctZjI5Y2M1Yjhl\nYjU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuBOMiaTxVOBptaftDW41ixxR\nvjAs6GedVGKJ1h4tDHDx6yWaNnFD6+q5OyAkoxYSdlSiX6iVP7fMjSoLi77BJaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/GCeE98eLcXLk1rkx1S+HWEva3wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIEar65Km\nJN0WG1BN65peCRhBFIhichBUDcrr63LjtpEKAiEAz4Cu312FYY55vVxIRx60XpSv\nleuxrichVuIUZo/IhZs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc658", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `658` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAbmiPetWslxW/wQOqER9IeR0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllMzk4ZDZkLWM3YTMtNGJhZS05ZjU5LTIxMWYzMWM2YmM0YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZmZDA2NjItNmZh\nYy00YjFhLWExM2QtMzAxNjU2Yjk5ZGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7CPz8Ou3mZX7C395UlRi8cg8ylkGcKW4huCTH345p+qQX8wbAE3HNeVBbuRH\n3i+y1CjGcCAgpOlvuiONuwzf0qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSqtIDgpOsauai1F34IRSUmFYRH5jAfBgNVHSME\nGDAWgBRRlRfvRmdouo5yq1OXFymXt/DU/zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDZeQUgB0/aOIlCxF6mWrq/Y9X2loO2m\nRBPnDUenN4+rAiA/LeLfVK/EcfrfRA/zzl12a8FY7bzODVztQO1EneNVaA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVR+kZl3fpa/6/AmqysuMb0BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTM5OGQ2ZC1jN2EzLTRiYWUtOWY1OS0yMTFmMzFjNmJjNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe+kHNNfmfkA3MOI2WVPXws9swIxsX5jpV95We5EWSqCDK\n88XQJjUKOQWto83JzW+RNTbZKK0a4ZsTa8CGNqmpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUZUX70ZnaLqOcqtTlxcpl7fw\n1P8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMOVA6rnBdMigahDM+38jycJNKF0MNGgBa47W4CDZE8GAiEA4PZ6epfh\n7mXfSBWbqax+UJT/CmuX/tu2X9WelS4itrg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQQZ2PFriLwU71FtzCnGguogMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZmZDA2NjItNmZhYy00YjFhLWExM2QtMzAxNjU2Yjk5ZGVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDAzM2I0ZTEtMTg0NC00MzcxLTlkNjQtOTkxOTE4MGNl\nNjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2DlMc6TXH2zzgvi+aCAuKnzu\nJASzV9Kiqgs9zkNTpfMhWUkVjPrzUUsJFbBTuzq/AiOV9l57TXV5jNqtmpjEYKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqrSA4KTrGrmotRd+CEUlJhWER+YwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDz2kAo\nxT7maj/+rxdYz2BLQShUevzLhB+sI8liCDpyMAIgLlymgBnf5ONc8o5ucAsynPv0\nyJZAPsdMFLolubtNc8A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc659", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `659` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAYGnV1Q2IcOzP6j8AITFkokXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MzBhNzhkLTUwM2MtNDUyOC1hY2U0LTE4NTg2ZmM5Mjc0OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRjYjVmOWQtMGRk\nMy00MzJjLWJmZTItYzM5YmUyMTA4MzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESYGodzaKYyrnHJheZe5QfAC1So8QQjvi2stLSdXEzC7R5DygA1+L3f5IPnUi\nOIDcX0YgdOAQ70q2HyqouyMAa6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXqMNz5t7zbQ5i9n9KzUls4IQHq8wHwYDVR0j\nBBgwFoAUJRVtNq3A8QCwN22iTcbvPUX7SqswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBneOtEy0LJaESK\nRljFG7MZZMc1ofqiEakr0/3ALEys6gIgWAAbYdS2KQeWQIP/tc+Hnru3HGFDx8dC\nohdi/ROdl94=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaZLBc1Mj8YHyjgRjyMsOPhnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzMwYTc4ZC01MDNjLTQ1MjgtYWNlNC0xODU4NmZjOTI3NDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWFe0kURuAf6Z1qoXfvThMn/iNQVhxBsZwY08CB/gSEOl4\nn8fZ/PDp/q78ptfT5sRYGs2q/SUakELiMmEL4whvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJRVtNq3A8QCwN22iTcbvPUX7\nSqswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJpW2rzyZJ9Tiym28th0ud/0PlB2DXB7oS81WxlIZ7N0CIQCQJldYnPCJ\nO2WMOt81yfqTUMMgBwaqALTCj4/p3oUjFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaKLqvKsomy30/5Pw3tz+0DKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRjYjVmOWQtMGRkMy00MzJjLWJmZTItYzM5YmUyMTA4MzJlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTZkNjU5NjItZTkzNC00ZDU3LWJkNTAtZGE4ZjgyNDhh\nNjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErlQ3T4AWrM6vscrjTFUm+e5I\n8SKLSeYnkuWtRHWXgTCbcGgKXv21l5WMeI0FH9b8U+pZVqBRyxKtcgoSVtnqdKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXqMNz5t7zbQ5i9n9KzUls4IQHq8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDPYR9JL\nqL5uZARM5pqFIoHgpQsYRKxsE5zqreSe2SjeAiEAumNIvGKOhWejDvdcaDgZg4uL\nTA7D+OsfqofnfnzBOdM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc660", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `660` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISARHDygA+fDyasd3Qiym7CoDOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiNzgwMTE3LTQzYzQtNDM1MC1hYzA4LWY4NGZmZTUxOGY3ZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ4ZjQzNjQtYmI0\nNy00ZGM4LWIzNmQtOTNiNWZiMDBiYTIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ/HJywNeE2h8m+clIzgAOHUPX++k51e6n9UZh9DYkyp4f4KPzMy9vLdQ8FGb\ncuE/bfwPfTd+o1/s6UXnSn+GgKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlSAHCSApPNa+rwTTJ1H7FMH2s/AwHwYDVR0j\nBBgwFoAUuo7FYUPJkh0U4Km79SqML4uEv/EwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiApXS7NmRJvyogK\n0RwrpWipccAAY2dOYDZkX7v8t1N34QIgSp/nsOXsBoknIy+mDVy4zym997vQqbXG\nggYAD7fxKWE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXmBMcG9qzFWk07LnLJpPGZ1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjc4MDExNy00M2M0LTQzNTAtYWMwOC1mODRmZmU1MThmN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsn2FXNF8usTllvo2QHwPsJG04M9OCN9/FhttjL/Fq7D5q\nqoRzF0xC8+Zi9sEnfNNIcic0F13zvsCLNzwcNOvyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuo7FYUPJkh0U4Km79SqML4uE\nv/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM2O6jGJYtf+Pso9Lw/nEBf2aY5S9/2Q/OZ87NZrKcavAiAarQDNftw4\nRvGTj8x9nvw8sugovyt6LIWYSCpzBN5jWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAU6j0EjceuAFLSqZ4PiVhXwjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ4ZjQzNjQtYmI0Ny00ZGM4LWIzNmQtOTNiNWZiMDBiYTIxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTY1ODQ5ZGItYjVmNy00MWIyLTlmNzYtYzMyNjBmZTZh\nYjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2p1t63L8VcTKWt6o2tI18h4H\nYmG0fQW+tUYgc7imRYnGo+mhBUbgbP9TKeglS16RoPPzPbZx5mhdaMi4nEDxNqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlSAHCSApPNa+rwTTJ1H7FMH2s/AwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGzlZJrA\ndVFTy2CZcXvupSOft7j4LmKnhnidwdoQlQ+kAiEApFbwd6Ft1Nsqmvkhxe78oA6K\n1oyU18+hz1ntTQQFXaE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc661", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `661` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAWcdrXQQoK6x9qeCC6ERUNyCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ZTg2YzU5LWMxYWMtNDU1MC1iZTQ1LTM3MTNiYjhiOTYzOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNhNjEyNDMtNTA1\nZi00MDVlLWFlMWUtMWZjNGZjZTE5MGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9pdeCeIymK0Oow2OV8CIFtiLlRYeTSBZTKk/jERaASAAk52R20Rk64wSSm+I\nJwIO8lIAVXLxPgmZy9PbvQLrE6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTCicefInSHdWXoJ5SxLXxHxlZtswHwYDVR0j\nBBgwFoAUvUrYN2Jw/4s3pSDqyXFhR2QGyI8wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiByxdf1hNVt/8YpKbDLexHT\n6kIs0tIKp3BUIYHW29IxBAIhALBdA3ZVJQcpvaIDiU9SvGpSiadFufBKIKKXz5Be\n3+GK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATUW1yHxdpuaOztbGomNgrerMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2U4NmM1OS1jMWFjLTQ1NTAtYmU0NS0zNzEzYmI4Yjk2MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUxDTs2vuxeLfeMhQYzTlS1Rc0NVLnC5QhhrutBFFWaMnv\nElwruwFXP/yaOooedZIQYOnx34R+/dcq4dzvZYtzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvUrYN2Jw/4s3pSDqyXFhR2QG\nyI8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF79AijIu3PPT2qrY/r+kpNiDpD5haT4WYP7jecoxZfQCIAIW0DHplsXx\nMN7ldySvrWlKE7KRoB1X4pwRaQGfLzKF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaKuYmEKB+l/DHulq9O70kbrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNhNjEyNDMtNTA1Zi00MDVlLWFlMWUtMWZjNGZjZTE5MGYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjA2OWFjNjktNTZkYS00YTFiLTkxNzYtYzNhYTQ0MWU2\nNWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB4nQ9PW88L01jhr+FAZGPeQj\nYJ85P4kTdJhCkpZAZ4spo8WmhhB36WaDpY2cJwc8ma8hb8DVbDFagIcTJztOrqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTCicefInSHdWXoJ5SxLXxHxlZtswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCu7vzo\n05EKvTTIB6z85G5RFtMfnnmBLbe45QL1UmE4agIgZJl7wOgXcjOHGC/z95LunMFa\nz4/Fwq/3AS7Oai9UFMc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc662", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `662` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAZKSrKc+FcxOTFIRKuyJuXW8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0ZGE4MzU3LTlhNzItNDM3My1hNWM5LTU1MmY3NzhlNGZiOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGY4YjhmMjctMDhj\nZC00ZTU4LTgzNTAtYTMzMmNmYTNkNmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQFm00uqfty7RnUUXf4iDHux9F/IprSPdnq94ouoiZUJwU1zugOJIR5BDETD8\nBAH2KrzYDSSdY2v/7mdzVe/DX6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSBN1H0d5u9SJUTwUKHgzLC+eS/YwHwYDVR0j\nBBgwFoAU+LIl+nnD3cdpMmhH5pLVzKoezd0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBPNoHq\njrfXLGdfBro9ti6RB2ZoX03f4y5cK0t0rzFJ5gIgO3zyVPNHLkny9GcCU6jWqvqz\nO3R4qyUKu5RHmXrGBvk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAexpIQx1G98AeCF+G6pBWCWxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGRhODM1Ny05YTcyLTQzNzMtYTVjOS01NTJmNzc4ZTRmYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFb09ZGhL3jeWT1PRTw8W7mUy9VpIS/vkN3Nq/45oJ3fCP\nvoY9AFD3S4dO3NcxNUxagnM7plupvsXYgB/vRA0So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+LIl+nnD3cdpMmhH5pLVzKoe\nzd0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKdm8DnGsYyzGegb34vLzJE/UommBD+Xd1iYSfH+XJdWAiEAiiFZ20z+\nEXFRuzHNCIKgAKtnv836Czr+YqrL2IWQJ84=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAebP8g1UbAfkcD7hcIsqgXzcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGY4YjhmMjctMDhjZC00ZTU4LTgzNTAtYTMzMmNmYTNkNmUxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGU3YzI4MDAtZTBlYS00MDM2LWIyOGEtZjUwODE4NGY0\nZGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETuvJ6/RMN2jITYG9O9YZOD0x\nWeWtaY2SeGaWRhXiuYebZ/Tu4+yJxKuxYJR0cl0W7fG26HoSThleFTEfGtOiW6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSBN1H0d5u9SJUTwUKHgzLC+eS/YwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAnmHcwJ\nCMJEO9KROgTbMKZ/GVm+HkOP+CaZIMuf4a32AiAO30RcfLytNNqu8U1SY9yOYO/X\nMjNSLWKSYB4V0D5UpA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc663", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `663` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAfvRM+tKIswPe+FCy+eVpHF4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ZThiM2I0LWVjMGUtNDVlMC04MTNlLTliNGFhZmNjMjY1MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgyMmQ1M2YtZGZm\nZi00NDExLTlmZmEtOWVlODRmN2Y0NWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE42G46rH/LW3YuInw/tNdUMiZ/ti2ntu5Aaz0wJ480ij+IxerXSjC53SzEEcL\na1so/JMNxqYfc9w78jsGqYOHf6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzVlaD1IgQy0ifEp+tux0FpWKwkUwHwYDVR0j\nBBgwFoAUpxacDAo0LxqcobJdVTweZy5MYkIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB4GiwZ\nKRgNjSzlDDND2Ma8642RRbpSRSHiVSQc3ycYVgIhAN9U9IWTgsQuV8pd6qsw/8Pr\nSsU7yXtuhDVP2Ngrd+rW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYy77YIsrx4WEcFmHaAt2hwoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWU4YjNiNC1lYzBlLTQ1ZTAtODEzZS05YjRhYWZjYzI2NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBfI2+7QqO2k4aiyz9Q2DoQwL6hzp6YH1fNNsP8uWy97pL\n+8seBxR/6kmB+znjidO/rY97sOfOa54Admi830aro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpxacDAo0LxqcobJdVTweZy5M\nYkIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMa1YoKEZa44JZzA1XVjyOL9ttq6kAyrb+xA7DcOKbBpAiEA1cTbyTN2\ndfa1k2rCqkLdGjr1vqGyT7gDd93qKrzRkRo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWX1icK0Inch0kBslWU1OM3jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgyMmQ1M2YtZGZmZi00NDExLTlmZmEtOWVlODRmN2Y0NWM4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGRjOGQ1ODAtNGZkOS00NmE0LTllZDAtMTdlZjYzODE5\nNjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIyZVcDnnkGGgLIB9fuWxPu6k\nIvFDHr8WbeBV2cdSHxzmkK2mvA/uAzC8CRDZB+ksjC6omRw4nHyB8Wnv1NB2bqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzVlaD1IgQy0ifEp+tux0FpWKwkUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHLiuchy\n5vjsXWq1lzvivak5z6F/scxwKRYAA7HZ/rG6AiEAyi6FkwWGR80bLgZ3MWvxJfka\nI3t1eKdtwnfg9xSHg/E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc664", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `664` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAUoLcfT0OAuDwPocQgaomU/NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ZmYyMDg5LTdmNTQtNDdkYi1hMWQ4LTNhMGY4MmYyYzA0MTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY3NGI5ODYtOTFi\nZS00M2Y5LWIwYTYtZmQ0NjE4ZjczNmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWvSmWOjliyY9ynBdXqTUcQMSKoOqkFeAzgndm7OKw67EYaZGi8bkDNtPZyk+\n/DAYVY5ib/6120uK1D6fGfRkNKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFP5F/xS0Bqi8/zg/og60OMG6yxObMB8GA1UdIwQY\nMBaAFKrzxCUYwdBhm5xErJ1t1k/HIrVxMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAuHoQjG2S1tEBe56S5jQCGdE5RqBH3s+b+\naOf82eG2zgIgcBh/Cde7KD5TPIqUjdK8pz4W0WzFpMa51gGnFiob8eI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARt6KnCwD4suqohz9agYrm3uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2ZmMjA4OS03ZjU0LTQ3ZGItYTFkOC0zYTBmODJmMmMwNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASj+ff6s6fKPk30D5ZqbxeLrgR32RYF2MO8iKING7fm0mAz\noG26+WKUMtR4qglPQhr/1IJDPVpOqfa+xC+ooC3Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqvPEJRjB0GGbnESsnW3WT8ci\ntXEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJiVLZ4uCuz50+7/EPtQDw+vPOxuNKA6U1jgvxjAqbdIAiEA/TrbSHVJ\ndz69R0zGhFr5ViGFfTkYRh6Yypgu9Hl9R+M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASmfDlDfLWQgQAbkheH6IhJyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY3NGI5ODYtOTFiZS00M2Y5LWIwYTYtZmQ0NjE4ZjczNmI0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTZiN2QwMmYtOGFhZS00ZTdhLWI4YTEtNjNjYWE4YjJl\nYzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZbiD+XV1mdrCr2sBRQlkobX/\n4Ns5VIwrUry3hL7EiP7Yoz52a8So+LRYQUJX4KW7ZOQaANI/0eny2hUgWB6W6KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/kX/FLQGqLz/OD+iDrQ4wbrLE5swIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDz49Sg\nasZKwQJxHQsuNVHst7EZBL3/V4P0tKunEVDacgIgJrkCSBuicHyig/Xavb6lKpzV\noZ2VT8042ZRbJDg43r4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc665", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `665` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAVaw9hKxP3IESPnvr2TTvWNYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxMGQ1YjMzLTMyM2ItNDRkMS1iOWVkLTMxOTMxNzk4NzU2ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTgzYTQyYzktMmYw\nYi00YTY3LTk1M2ItMWExNzJjNTYzYTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMaODFY7VO6Y9B76575xHU3xuQKKrfdnBUKc0p82amO9FEJ5ssA8s6DZg05hV\nDePSlIRgFmfrSW6WEsQnX0OAgaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTAYV8S1l7PCcTEqUhaDSwQszPRswHwYDVR0j\nBBgwFoAUGpWcOGZARG/2sLc93q3ZO6i81wQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgKWrSdwR22Ltz\nN+OWYBDptSMfdUoiwAw2TkFRa9T/J4wCIHdHbGo4cBOBzzHL4/5o8tJ8KPUqDvUy\neHLI02b4X63q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYsMWSRPyjCkdCkW8ojFzIdBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTBkNWIzMy0zMjNiLTQ0ZDEtYjllZC0zMTkzMTc5ODc1NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXv6KpUM4XFeIitdwj2kQ6T+F+oZfpmGw6YorlSRUuWRmm\n7j4X5jM8z+Uoe3kuuh+WNe9wx9d+FihVV7Jhfapfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGpWcOGZARG/2sLc93q3ZO6i8\n1wQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIJBECP2RWTxIBDNr5mUn6U68auq3nQfCV3N1kvCgzLQCIAsHhewDSBlR\nJRUCxbWEuuL/VLgNRUhFonMYHZagsw2G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAe8o/VpdbMpvkzJAFE7bU6W0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTgzYTQyYzktMmYwYi00YTY3LTk1M2ItMWExNzJjNTYzYTBiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjFhMjJhNWItYzNhMC00MGYwLTlhNzctY2QwMDJjMWJk\nYjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcHoBsw8Uq9hjMP/SQ4EuIgAy\nSQKlXMeNIEn0V2XPM4kV+/QCcwJZVsp8yxVX9AMpJXo/r42uhW3+A1iTFJqUz6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTAYV8S1l7PCcTEqUhaDSwQszPRswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIADOb3Ww\nuD6Zzp2xQtMjMk7BfVI2AciCJB6JoWyM5xHTAiAv+oHupdYY0ifj9jMZzDOm9wk0\nGTbr3zzYTdscn76gIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc666", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `666` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAQ3tZVWepr91VoNCOJiDfJNxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1MWRiYWY4LThlNWMtNDJjNy05ZWU5LTA1NzJmZWYzNjA1MjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM4MTlmNmMtNGIw\nZS00YjhkLTgxOTEtMTliOTE2MzhlY2ZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGt5FtuelIjvRlkDX4b1rSQ3u3QLy4/FH9uQKXXoi/xE6w5dYvU6ew4vV5HeX\nV2XJE4RUZstk5B78YEKAJdDrf6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGkt3Rir3Ja9NmifxsUHAbIH9K84wHwYDVR0j\nBBgwFoAUBPHuTKDY3O+K+X2q4HdpnYf9B6IwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgL9SqWkwNkINx\nlasr7jM4a9VXTbHGGg7MZ52fD22yjgkCICoGozDAd9REvIku4MCAf2fEB0O6Xc4E\nGJAn5IWwoIF2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZiMteuZK1WjC4GZlrl+Fy8QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTFkYmFmOC04ZTVjLTQyYzctOWVlOS0wNTcyZmVmMzYwNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmFx1GPyjckU92gQkXBjUl+/HHYcSAJUTK8ml8gkD9L36c\nUbyquRWtpBygqctKjfDPpMmehftqvn6fjzyKUgkdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBPHuTKDY3O+K+X2q4HdpnYf9\nB6IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK/rXr3w2AT1oR5Pu3dTXtye3bZjLVrklzVknzGIbxukCIA+wN34X6hPV\nRDFvpRHoi+rPBpZlEg7mRd4qSo1SSLZK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcOPTAibSL/HbqlNprJ6cTZoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM4MTlmNmMtNGIwZS00YjhkLTgxOTEtMTliOTE2MzhlY2ZlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY0MmE0OTEtMGMwYi00YzI0LTk3NmYtZmNiNWNmMTQ5\nNGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1asYAarm80KJGtOq+yAELPCg\nltAG6wK0+DXnXA6chAszZE884eJBRIWYCCzdLOlXzR5buh4g+T/V6VXyuW2sa6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGkt3Rir3Ja9NmifxsUHAbIH9K84wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDoCUIF\nSecmDWrQZRLOEo2zOfVkMze9KdKrWss9Lpx89gIgDAN6lLTHekeGvnxcp5ID5TuI\nV2APCscULEArTj3k2L8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc667", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `667` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQjQQu7bSka0+vVZcEQID9ClMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5Yzg4ZmQ0LWQyNjAtNDU0OS04NTEzLWNiMjJlYTkxMDkwOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODc1ZDVmNjAtNjcz\nMC00MWViLThiOTQtYzUyMTI4NGNjZGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIUdhuoSO37TDeD2VnhyJn4zXsAM0Q3/IehG/d/EmA436EN561uYJmME3AWCO\ntnDLK2EXpGYzTpNTF/NqYis+IqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHZ+O/UmsnAj7JHaJQOTzMLeqz7IwHwYDVR0j\nBBgwFoAUvf+8BmDvSBdRNO9JPGOF46AopSowKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDwA1Dkmxrx\nu995nGBw6o0rAgrUYPhYmRWpkyuvQQlfLgIgCYiJgub+U7bAyDcuNtF5LQySLHdu\nW8lMWrMNoPk123M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATy1CS3ksjTucj7uTcnZgpuvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWM4OGZkNC1kMjYwLTQ1NDktODUxMy1jYjIyZWE5MTA5MDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDOrF4QwwkiAm2KtfitdOqVVJCOyTy2HDy6jJBIn4wq2op\nfnQbdttK6hAwNZ/3YnNRudDf8Mc90G1m/xD4xmpDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvf+8BmDvSBdRNO9JPGOF46Ao\npSowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALYjbODCArvrp2a+3XlquFZL8Fv1CnsGjvgrWSN7uMzFAiBsoUDHEswR\nkNOnFqbRKsT1hOdJ5HDKmdSzaAmxO7tMlA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUhsgX6M2WDXK6q6ci6LFYzNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODc1ZDVmNjAtNjczMC00MWViLThiOTQtYzUyMTI4NGNjZGFjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzJiY2JjYmItNjgwZC00YmRlLWJlN2UtODBjZWQ4NTQw\nYmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVE1zHacUoKxomFuvcoXD+b5v\nH7qsai5FgWbYRJ/0n2HsB+UV5KvfdPUiuYTUavpF4lNGm7bfTjXKhZNLxBmNQKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHZ+O/UmsnAj7JHaJQOTzMLeqz7IwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCl8l+C\nyK5sfqlo7cuE19TUFND/zFWfouSYjmx725BSVwIhAMX1qpSw7LThMrwkDdji+k05\n217jAHhVmQMTDBdVhs9E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc668", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `668` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeReikYKfRjpI+gDhPgMj1PUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMGQ1OGFiLTA2YTItNGIyOC04Mjg2LTQyZTllN2ViOWEzMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmExYTAwZTctOTk2\nZi00MmMxLTlkZjQtZjI4ODMwMzZhZmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG8cHhO9LYrStS3EbOuewijrw7qi5AYNNH9N1dmLM8Y3bcE+J60Trk6vYA48v\nse3WMSdbtS6+saqmYdWcthGJ8KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn783L0h94S+QW60Q7ea88WSQ8cgwHwYDVR0j\nBBgwFoAUa1yqAmlTEVh1HIYVP5mbImniz9wwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHLF7Gf6Xs/Gx4MD5CZth9OxI1zVpF+aOrylOKtOx3KcAiEA8gep5cyx4BMi\nBfr2HevtYlmwYx2m+VhJvTeyeewPTO4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbc6ApB3rJMyj3IopN9+Awe0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTBkNThhYi0wNmEyLTRiMjgtODI4Ni00MmU5ZTdlYjlhMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWdJ678WoBq4/O3r0KF2gIgkOvcXrj+2NkZ66rmEoHR4gh\nrb0MfZCYrweqXs0z7g7oEfqOXIVWr+ONIrmVzwCRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa1yqAmlTEVh1HIYVP5mbImni\nz9wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPm4OY2QWFuAQmUrDFv0WTZ/F4CsyBf0I2Gn9KkqWf3YAiBiZDimLe0s\n4KWIAwUW+hEF4yh+oUB30Sohf9XjD8XvZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAazEnUihTK1XJ4SCmzi2eLHjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmExYTAwZTctOTk2Zi00MmMxLTlkZjQtZjI4ODMwMzZhZmRlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmJjYmU3MTItMzU5MC00ODI0LTk0NjQtZTlhYTI4Njg1\nYTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaqrvJVTfRGl1Q/PoGNx37IqC\nj6KTsDf+RCeaDkQZmI+GKHvPdivY5UTDxJiB1GGUllvNsiSrrQSXfkAinCTCe6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn783L0h94S+QW60Q7ea88WSQ8cgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDrFWgzU\n3I+UBdlYOEtVNo5UXrKuWiFBPZKhysx1cX7SAiEA5D0INXQBxm5m9YsRZRjjAfGd\ndbgY5xMC89k+YWjyzqc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc669", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `669` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASaC6TOGQkYiCdH4BsdyjMXIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiZmY2ZjY0LWUzOTUtNGZkOS1iMGI3LTE1NTQzYTIwZTFmYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdmODk3NmItNzgw\nYS00M2M0LThiNWUtYjExZjBhYjZlMzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE77jtcf0CsXoIKY+N5HTSHEv8wEaPEChu7XwFqJ7mV6KKujCHz14H2oaUROZz\n8ZOd4hzf3IKleP7jRKTY1StG5KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU55yeoEp+Fw3oGpFhyelLjh3fa2cwHwYDVR0j\nBBgwFoAUmcgN+/A6oDsHBkB2SYAWeWV4tpwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDEdOBlRSiQlpOjYHCXAoQPaw/tkOF5jGOVnSBYnpCR0wIgSWF86NCM7S2+\n1E8CteBw8YaE+3Q2JKs2+yLQF9D86Q0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARUd0KkjR/ffkoSOvUEztjJmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmZmNmY2NC1lMzk1LTRmZDktYjBiNy0xNTU0M2EyMGUxZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARW7CMdyv4ngZgLAnpKaRVVVKUgAEoCdk12FqVo4mOF8+ef\nNdGxfkd2WgNF6ZG1vA5Sk0ZWTQfSJ/YwADBZm+Rao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmcgN+/A6oDsHBkB2SYAWeWV4\ntpwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ8Stx5uci1xthW8JELgNKQEWsixGPEBJf7e9HFh0zD9AiA/FxG2HBh9\najhl2ZuQ/HmFL5TehHfr0VrrJ0jscifBdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAeOKvcHu8CCXSDvzKexRCubmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdmODk3NmItNzgwYS00M2M0LThiNWUtYjExZjBhYjZlMzMwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDUzYWY5ZjctMDZhNS00NzgxLTk2YWItZjEwMzZlYjI5\nY2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOUbP8kGz5o4vbGyKtlUq1skx\nOR7vD3Gc3/zYZAEopppveCBZh7BH9WbBd6Yxsme3DuPfTjGG7EWMdXcKfTfOhaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU55yeoEp+Fw3oGpFhyelLjh3fa2cwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDzQ+vH\nYAMeVjrodwRTb5Q81zZg103uXTipKaH08dYF/gIhAMdFQE7pYLZUWONYMnEp/vbo\nqFYrYljZ0MBOZbeFwxVy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc670", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `670` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAQZ20HWJr3iq9Yd+l5WaTLFHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwY2Q4ZWNhLTc4MmEtNGU1My1iOTc2LWJhMDZiMDVmYWIyZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI1MGY3ZmMtN2Jj\nNS00M2MxLTgwOTAtNTg2MWEzODE2MTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwKdesOR/c4/qzVZphPAY7qo+9lzyVP6XqdXwxieJ+MRMPsSJ7TL5HaYemmbv\nkiiYiCnqzEQy0NiIXh8c/c25QKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8KiAdU/5hV39GgYw5aQMoEEPjuYwHwYDVR0j\nBBgwFoAU6Q6C7tScwII2HU8kes/58K09VqYwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDdh\nUZ7GT6VFTWuctJ7gWS7t39+TSE+Ap5oWQrfqDoknAiEA/S+P/+rzrSynCcqDX26j\n84NNbCmqL6nNlIMwYe5F9g8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARKem2gDGryxK5ft9RnZcLBBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMGNkOGVjYS03ODJhLTRlNTMtYjk3Ni1iYTA2YjA1ZmFiMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUqIEl7xffAKdlll5KtDW6anmbUqjvaJEtlweVm/bGmLeA\n85HN0zP/ov5nag9BtZO3a2lB/TaP+wHbb4NG6bzio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Q6C7tScwII2HU8kes/58K09\nVqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTUVvrkHc/KdTjL+WpjoKRzk9VM8sB+z2y6DxV/kuCt4CIQDJ3OoaSfHn\npQZSf+z1wtKR2XrHUZXkyuWXDDfibSbqkg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdIv6nZ+TN0aDS0O8LbEkeAJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI1MGY3ZmMtN2JjNS00M2MxLTgwOTAtNTg2MWEzODE2MTI1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTE1YTcxZDktNDZkNy00ZDg2LWE5OTYtMjdlMWEwOGI2\nOThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoI5h1ndqCahHMbrM3y9E0r4f\nDpaHfGt1OFnWrDWPmNyUF9X/z/euX1iF8vcdibWa1aj8q/OuD2g0kWhWNbPV9KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8KiAdU/5hV39GgYw5aQMoEEPjuYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDy88D9\nIzTUim55OZkvpiqcpD9H1zAh0nu6sNNpCA9akwIgdPz+PjUwMsAYYzmGgeupAjCL\nLA5SpxvHm1szfAKi54s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc671", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `671` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAczXHhu2iFQ/n4x6Vleddd0+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1OTNmNTBlLTU0NDYtNDQzMy04N2IxLTAzYjE0YWE0NGEwNDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlkMWQyMzAtODBi\nNC00N2IzLWJmZWQtMmRjNGZiZjBiNDFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0+pIrc03b+jA1Go3govhYh0qWm02dnxwB1yddqbVML5LbSIazbhQeL4N6Lg2\nAs89mxyoag8tS/nkscGc+evVK6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWC95DaFVcvYjPyuzDjS8/qMG8L0wHwYDVR0j\nBBgwFoAUW4nG7bG7IawfzbXXLtEEVCMyuLYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFy2Vq1JcHAZPqchctsCsk7b9TEy6MB5HSsV93RI02itAiEA9rzz\nk8sRFCW6ZF1CiGNFHaU5nV1stkskqc+oFrvea+c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaNy2jQFLy3orXb7mIoGXcYHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTkzZjUwZS01NDQ2LTQ0MzMtODdiMS0wM2IxNGFhNDRhMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxYJwLhqvwPTt+61IRUVp8OuIaMlNXs9zuRuHPrYNphkXG\nkLHPubocu1OrGVVul3femDoId7NSt9Wsedsyz7i5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW4nG7bG7IawfzbXXLtEEVCMy\nuLYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJUwKP43V3fz2gm+noaUCBSnZjCi8zv+shyJGVucIEYOAiBUpbRLgRRu\n/4zG2ga1DJMkO9z7e37Aapc38SBP4oBCIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVILvxeSWwADiOvckiyPzML1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlkMWQyMzAtODBiNC00N2IzLWJmZWQtMmRjNGZiZjBiNDFiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDI1ZDAxODctOWJlMS00MzhhLTk2NTMtY2MyMjgxNTc5\nZjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1+d/GiTERoZsp59yR5WJjAQu\n+dEFje0rh56f4bp5KEXEzUZForexPXaq/pbKM24ErwoR1xCPIHSGm8vN29unEKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWC95DaFVcvYjPyuzDjS8/qMG8L0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCmU6UA\nVoPq14H1sscZQj7GeUtUDDvJCT9m8Yly1D2CpQIgSC8MAr0+AJBRcueCBh0YO7/v\n0SDFnI4cu98JL2zxDx0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc672", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `672` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAdcik3TA3yMV9AEpsq+Ij0gqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0MTVmYmJiLTIyOTMtNDU1My1hNjhmLWM4ZmExMjBiZDY0YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYzNWVlMDMtNTY0\nMi00MDM5LWI2ZGMtYjdiMTg4NzU1OWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaTCpM+3702ke/9vd2SLHNQeItVKUJ38S0DQj4yYZeQAvtQhVaFGFBzzDB89Q\n9fNtLDdKJhe/xaFaXhfgf/tZ9qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmAnu4Hv07j3cXdTMGKPIujFgdPwwHwYDVR0j\nBBgwFoAUonM4WIaSEtzwsfXqsdFnsQxMR3YwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIE6Z4kjvVJ0h1aRFkjssadcIanXMf7K/IqCB05X6JYOIAiAU/McZ\nuvke+ph7Ly44bA6l22IB6Fei88LOQWM5gFxyLg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYMqMbOY3hiSVwLoFbnRWNp2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDE1ZmJiYi0yMjkzLTQ1NTMtYTY4Zi1jOGZhMTIwYmQ2NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFxbbxAwmMYQ+5PYQtR4OqPGPAdKCEtHNZo8juVItKSQ6t\nmiWkDXWe0IlS2HTyIlSUUBWJuTIvz3XjvVxTYXS3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUonM4WIaSEtzwsfXqsdFnsQxM\nR3YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfJzm+JO8zREL2p9WlZo83om5rKtMFR5RGirQtPr7VQ4CIQDnxAhdnkAr\nGn+UnsTI/4EqC9JENIe8nQOcrfxLYRDPKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQt1MqHyzaRAtvhhXmdAL4MAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYzNWVlMDMtNTY0Mi00MDM5LWI2ZGMtYjdiMTg4NzU1OWM0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTg1MjQwMWEtNjRmYy00ZTA4LTgwZGEtZWMwOTM0MDhk\nN2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9faORlBfOr5gMa17ciyZ76yV\n4wcBEPGFP9//WG+neWy727fFo+K6QZNfqYHrnmTBes6//6VvXvYZRkNyKOOoJaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmAnu4Hv07j3cXdTMGKPIujFgdPwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDIl3ww\nZYECluThq8ycBRLcuem0nUbf7CMvzzKF3azthAIhAKPzMak9/NFckpSd3o4WAcme\n0TZnjENyt7XMUIO4NMRh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc673", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `673` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcEA/L3R8hcZ8jE5EJWFWQDAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5NWI2ODk1LThhZTUtNDY3MC05NDAxLWRhMTc4NzdmMzFhNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTE2NzYxMDItY2Qz\nNy00ZDNjLWI1NWYtYWFiYmMzMmYyZGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl5Qb+wZAkUawjiQ06WTRvTXV5/q/T6pL82THaZ/cEmf9H6JPi4orQvR72qBK\nTKrIjRMIjuZMx2QWCotv3OqZ9qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOCOsI6ESZ13iPIhhKiiGqOuwCp6MB8GA1UdIwQY\nMBaAFNA5EJA9QNynl7ANE/X5syzIhwWvMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA0EtZ6Q2KOSHzBQYIt6OjMlzIH+jWLa0c\nonLE3XdFzd0CICN1LpSD/NlQmOdOnSUOqK5F97mZCAtW39V0BgNege8E\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdcnhmvOhelDLEuoDT5QaCVUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTViNjg5NS04YWU1LTQ2NzAtOTQwMS1kYTE3ODc3ZjMxYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQvJFZXQ2Dkkm/PDTTg97bOrV8iCOlC71CPufV5mq5U2g6\nlxjNrhV70qveC5Kcm34GaNummvm6auQhOqizZ2tNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0DkQkD1A3KeXsA0T9fmzLMiH\nBa8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB/icmIoQZrMh57zYmNHX8U2KqDa9q6PVktgKtso7eVwCIFaju7KLXqex\n3VKitpNJm4WW31zS2FRmRVhDpQKelBr2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbcfEQAIb9zzA772Zb1DyTrHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTE2NzYxMDItY2QzNy00ZDNjLWI1NWYtYWFiYmMzMmYyZGU5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWYyYzU5NmYtNWJlYS00OTViLThhZmYtM2Q5MzViMWM3\nNTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMCNrSjWhe6IjWX0FEPc+blwZ\nWZ7MbtyPHHdejVbUdo+6bZnZiHk/0rZrkoBoBs+B3hwmRhqyolBeUrf5swRT+KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4I6wjoRJnXeI8iGEqKIao67AKnowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDJjLTk\nhnVbqgjh8XDZCH9rvt2Fxx7Gqywamozt5+dNcwIgU2/jjqtAPlQiijkxGJXfQCn+\nrTo03qacKj2CIvpGySU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc674", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `674` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAUK4UdemKfU+u12zXCFdYzfoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NzNiYmI0LWUyNmUtNDM5OC04ZTllLWQxYjUzOTBmMWIzMTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQzN2E0OTEtODYy\nYS00YzU2LTg0ZDMtOGJhZDAxMWYzOTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExiGJFdB25uKvqNLniNAMLWgADE1Ur0HqoRKugYJbo58yZsVQHiLxS9RCpk0/\nQ+vNpqTWBX8ps7sh5wy4w5SUxKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb3nqOlNDefAU4m/h7FY3jSx/0U0wHwYDVR0j\nBBgwFoAUwNlOxUCU8Qb5nLhqb58yWm3TReQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMbsMtPxd03v\njQtQj1j98O5TJk1rbUneRU3frzcLqF3lAiBAhspd9ryvc9fbRME2bOSU2+uP6h09\n1s+ha4EVJAeQwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWWv2gKI2Ocpr/JITqEU9lm9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODczYmJiNC1lMjZlLTQzOTgtOGU5ZS1kMWI1MzkwZjFiMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQldUkR+mw9/9ItsaxgI1Lh064d2ADzU6/iMTHLkgSZJxzs\nnoReCsvsyVZP5D1JcBckvtxFtb72jtabqrBxGRHYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwNlOxUCU8Qb5nLhqb58yWm3T\nReQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDI+8UelchdeEiLsEQEpYI9XOFfdTjaswdAk81X2SkR8CIQDa56I7Eqz6\nO9uoegx/o+JeDKz07Y6i5TTTVxGqMptuvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAddmf/yJhfKDX3WROZ7qrV6SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQzN2E0OTEtODYyYS00YzU2LTg0ZDMtOGJhZDAxMWYzOTdiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTZkYjhiYzMtZjJjMS00ZDQ4LWI1NjYtZjBhMWQ4YTMy\nMWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK9h/T5sen57Ktnu/WTX0DOnN\nSb6iY3xRTm/Lk/RlHJ6f6gEeNvfPdKcb3z+jIZdmg5zbE1MKEJncYEaFRo66W6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUb3nqOlNDefAU4m/h7FY3jSx/0U0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCYLEk3\nThg2oN5NxVJ/mETPWECpB/366dGKe4sS42LBeQIgMweOjend3gEHuLt5NQmBPiTB\nxuDoMa7kDBLpCYlY61Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc675", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `675` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVev++RsFDQVEt68OTf7OjtZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlNWQ2NGZmLWM3NDItNDFmYy04NzNmLTYzOTY5NzM2Yzk2YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjkzZTRjMzAtNzA2\nYS00ZDIzLWE1ZTktMGVmMzZjNTU4YTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvmO+EHzd2TIKnl63DAaAsmaFWgKDrLCr6mWEuEE/32eI3Pi4jzhIQESfSzuc\nrQ9ORU2LG6ko5Wklz3QYU23J16OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUBH1esVqq51cj51ghi39+Ybl5KEwHwYDVR0j\nBBgwFoAUbwBdsU34a/KQTfPSPK4U+MdJvFUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALuGMbyMPF6m\n/BHwlHrKCkj3OLD025PO6BZyoKKW+Y2HAiB87UDNA+dX6/pBdsyvZ3ID69YM28DR\nQD1X1OoXV0XJ+g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUzeoiAD3cfRLn8C8vqCU1lhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTVkNjRmZi1jNzQyLTQxZmMtODczZi02Mzk2OTczNmM5NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASk/XekbnRHgvUO+wUGY8AZCcb8EBB3DEKvgCvCHgsCucNx\n1NUYqU+wI3olbEawyrs8m/ylItSBLJ1IqmFPQ/nwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbwBdsU34a/KQTfPSPK4U+MdJ\nvFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALV+fVIGvd1LurKCav0RihFfaLrKBMmAJOr7dpdIUYjqAiBovyBzMXZK\nPvSQIdGgPUtL3cOjQpI8HgDF6m0Tytbn8w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAS6b3YRbjNdNbfeGWAd37JE5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjkzZTRjMzAtNzA2YS00ZDIzLWE1ZTktMGVmMzZjNTU4YTY1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMThmMWFiMWYtMjQ2Zi00ZWJhLTg5MmMtN2Q5NWFiMDI0\nM2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtvmuFrDrjI2ImNohDVcAkRc7\n7DDefUG1FoNHp7ZeLbYxJxSMt/slRX87j/y5NC1TCjrHtKDfleFHnr57wYIVM6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUBH1esVqq51cj51ghi39+Ybl5KEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGH5OBur\nBCeBtck8RcgK4OQcq9Gmpsg4TQxhRNWfxpZfAiBfgezayURukWjs+sU1bhV1LGZq\nFK0u7sKxGZ6dM0/8vg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc676", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `676` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAbu86WUagyEOS48xEkIQiVndMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2NTAwY2ZmLTI0MTYtNDEwNC1hMDhkLTk1ZmYwNGIwNTMxYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZkNDYyZGYtZWRi\nNC00ODc1LTk5NjMtOWY0MjYwNWNlYmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE25s4gFrI1+i8lDsF3dSL25DFHkaxwZUtptwyGaLJ5dyV3BkaM+7eOSRxiEy4\nTvCTQZsh1Mbz4CXpqn5cSATzBaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWcASAiOv787fgV1ir+jnsdiyC30wHwYDVR0j\nBBgwFoAUd4g9BdAug6cbyIYqnROhMPttrRQwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAJFFATuaaQf\nV18udXpm83voehEgdsRAkVrdXHYVvMcpAiAK0/27Nw5RTsQF3ny/uFJ0fU+8sA1O\nLcZzM6i1BS5uCg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV/fBKSQiDLBAqqrTjX6Bjn3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjUwMGNmZi0yNDE2LTQxMDQtYTA4ZC05NWZmMDRiMDUzMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCEkK6lKjCFtlzGchbJxdim9f0f+nxcYXRmtndU5KsMO1d\nTCVJkYxNgnNBbXT7xMS7hxPEhlyF6Dnz4eMYpRZ5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd4g9BdAug6cbyIYqnROhMPtt\nrRQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMYsXqmj6aUdgH+3V9skCYuDuSzeBCFPTNYqwSdtleqYCIFnVdPbnMlCW\nCMfMy/1UZEAo7TztkVeAzelOLJMFlIre\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfL/PDiit6uMRFVpmSfWt4u8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZkNDYyZGYtZWRiNC00ODc1LTk5NjMtOWY0MjYwNWNlYmEwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjAxMjkwZWQtMGU4ZS00ZGUyLWE5NWItMTZlYzM1NzA0\nOTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE27E+Oj5cehyW4xny3mnuf15A\nhN2n5FV4xKNjcdmTVFsSoOKL4OFEkAx2cnAOZzj8D4s21GOQH4MhWLL7ZJcoe6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWcASAiOv787fgV1ir+jnsdiyC30wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIEuUHpAx\nnoDVTLeSdo2IW52GmuR4yrkasYgIMFbmIYuSAiEAgqV/L+i+mFHEqpfM4VuBmU5W\nLLE6rqmCdZrPKnrnvxQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc677", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `677` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbE/u4SuG/eck26+wPN0GV/hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1MDdkNzIyLTdhOGUtNGY0ZS05YjY1LTJiNDc1NmY5ODdlYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA0M2ZjYmYtNTA1\nMy00Nzg1LThiMWUtMGUxNmRhZjQ4NjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6J/PDaG1tIzl4xaUZAzxw9mVlRSnxpjDOdKpdQ35AuGgBcR0UY6xh3e1RYms\nvj1wxB+RdJ8yDrK0nIwi4p/p3aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjkArThd9NfaTM2Q9nv5+bLuSFAswHwYDVR0j\nBBgwFoAULGgOJa6dInNa1caDQInXGvkx52QwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD/cMSUmNTvcAuzCkzMSLIaJeXBStaz/8OxDAQ3tbhmRQIgJrwpbyy598E/\nRplKFZilUPHQeVdH2vIXQ0t8ut17R4o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb5yLgYzhyqPlmYNGsvT7cNAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTA3ZDcyMi03YThlLTRmNGUtOWI2NS0yYjQ3NTZmOTg3ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVz/Tdx7jLMQeYfWvMrfnv86e45aIj/uRdlcSwPi7tlAf7\nhmkoiW5rsO16J1iYoGmMCHUSFzRrPKbqpCZ6NNWio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULGgOJa6dInNa1caDQInXGvkx\n52QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMRUz0x/l+vYNOordWn3xHHv19Xg58g2NT5CDG/3IQQqAiEA3mw898uT\ncCCuzeaKK1lHPDsxqjeKglol3SZ6JX1JCoQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAeMZY7bXjY4ggjBe0SCy7Ox8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA0M2ZjYmYtNTA1My00Nzg1LThiMWUtMGUxNmRhZjQ4NjAwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGZkM2JlMTgtNmYwMi00YmMwLWE4NzAtMTJhY2I1NDc0\nYjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqxqNMfBEqMxohJ0n6mjywTlw\n0AgIzRQxuwA08CF12oQpa4HWxt1den3dpPvF56q/zVpu2uZlAJVQofwrpcgQ7aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjkArThd9NfaTM2Q9nv5+bLuSFAswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCICmxXl3J\n30rTngL6DnSXJf/uFhjVZ02AHmEWXZfqe1DuAiEA5f8YPRhBioT8p5asKK6JYKyP\nD6VO9kbQTHtQivpkx60=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc678", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `678` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAW6IhQJKjRksMsVc7cZjsxf4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4ZWU5ODU0LTM1ZGQtNDAyYS1hMDc4LTQ0MTc0NGJmM2ExYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNmYzQ5MTItMWFm\nOC00MTM4LWI5ZjEtMzBkZjUwZTAxM2RlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHxnx50G7HnKzcZmDC6kUScafWu+Nj8RNuM7gBoyFAkI/bzxE1TDE2VanP/OX\n66u/0QxUUF+OUY8RHoYqtA+im6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz3pdZhciFBdYn8ewsJgGT8t5/7YwHwYDVR0j\nBBgwFoAUd5YsNcoiQoWsyVa+Wf0cXzmm+g8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCZXBihiXgccKThnAsMw8p05RUefmOXiRIM0FHX5VBrKAIgPkQLL7BhGFx1\nPirIBHHtRzdxIK8Q6gK4dLnEsHfcKEU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaHTcAW6Q07v8uSQAaPO1lJkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGVlOTg1NC0zNWRkLTQwMmEtYTA3OC00NDE3NDRiZjNhMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjKWmlztacllgmUKRlq0Fz20hQd/CX+65VhkreRkHCwjW2\nLoOuZjVxn0kQxh3K+BT4x2T18qzhV3AVQ5nj5WGjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd5YsNcoiQoWsyVa+Wf0cXzmm\n+g8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK6SUc435BSwTO6jkpHmJCmByRAv145BUcWDx3Gq31fSAiEAuF/5KENT\np6oKXpIA7zZXQb+M+9tQltyrR00TNrJsuMk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISATKP+FKs7yVlRMhvvWmJivseMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNmYzQ5MTItMWFmOC00MTM4LWI5ZjEtMzBkZjUwZTAxM2RlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDc0YTE5MmYtMjJjZS00MmUwLTg1OWItNTY4MGM4OTNl\nZDQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmlLDw/nZhneubDFr9RaD/5u/\n0xcIY1E0VelLm1K0d7WRTlk/G/ds5CwQ2ezYFY0HNSSQTwxFHMdeq3cW5D8nRaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUz3pdZhciFBdYn8ewsJgGT8t5/7YwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHAXFfC4\ndRHPKAwgAmlBZ3dk5u51d/ERSxCeztMr1/+XAiBQEaWjz6q+jZH/eDKKD/Phd15k\n9sBBf6ULxz8iu0J6RQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc679", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `679` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAXpYWvloBXSNkScgbpxpz5I7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkYWM4OWI5LWM0MTMtNDJhMC1hOGE5LTI1M2U0ODUzYzJjZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI5MjdjMDktZWNk\nMS00YTk4LWFlZjUtNDJiMTZjMjU2YTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGnQ9Xh4rGI6RIxwUmpHJdYTOp3N/LfzCKurfGJMwkTmiosaGzWJRIgDNvG3X\nth4ThSs7WZ+AjLeaDx4mS8yq3aOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURo/rLEcLc1u93kFjyvLihSviPxgwHwYDVR0j\nBBgwFoAURjU6+fqwn5dXUx0DYPjcYSi1h+QwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEnr\nYMHZWw3i5aYg3gqXHggWeiGTdmLsrTLh/d8YBMniAiBY41pYBuz9MQxKWi5zHLKv\nSGPVuQquWPmaVF3zPVCv+w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUnJ7Pf7bpQsyfQQpkVRtH88MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGFjODliOS1jNDEzLTQyYTAtYThhOS0yNTNlNDg1M2MyY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATf2J/vZoE5M4+FMOzC8r7Z5HGXo7t2+y4269oqivl7pXo1\n7LJ1P9y87pI1o1c41w9g6vdDofn+8Jv0mgugpR7Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURjU6+fqwn5dXUx0DYPjcYSi1\nh+QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgf1U5QlXuQW2EoOZ+8tGr63g0pFcN29GVZoSIKC6HUL0CIQDhA0HcF3kC\nGGMO7DBaSZbj5rlXGectyn7XwT+0Gv463A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAbMgQ4nj5XGgi9G20nPJrWL+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI5MjdjMDktZWNkMS00YTk4LWFlZjUtNDJiMTZjMjU2YTc3MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjAxMWU0ZmMtMzQ0MS00N2RlLTlmNDUtN2U2ZWQ5Yjll\nMmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfBIHTHgIKQoT7EOkpJadorLq\n6n0nJeYoEWoku0IOKkDB2xF2ZvypC8Xic1BoLLQvavQPoIdQ3NkcxF40RJe6WaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURo/rLEcLc1u93kFjyvLihSviPxgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAnJEBIv\nTeOxjH+MDDgNbhJzb11CqqGi/29fcvUuSG5YAiBbqL+LArqUM1g8oVueVeEe4OBo\n1CUNcKHapYUyz6/51A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc680", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `680` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAaP7faFvhxf9rWNThJwFuzNwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMzdkNjdlLWQxNGUtNDY5Zi04ODEwLWQ3N2E1MDExNmUwZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU5ZjZiNjMtZTcx\nNi00ZjlmLThlNzUtZTQzMmVjOTA4NzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIUFoGVULXlfmV9FXvAoqHp9mGuls0QSEbdxYj/mKL/T0TJZDs3o4N9YNg4j2\n12RExwqwc44fS4b8xv0FR8wT86OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhket03uRGjyXFzjSTtxkgw+cowYwHwYDVR0j\nBBgwFoAU8Oj97B2URYmcAxS1ViQqeX8CpAwwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIF8vid8tGBewwKph4gaotoBzm8IJfMVQ+iUjS8H3qQayAiEA6YeO\nnsvXG82XdEg2Tah7XnumsCJSCENZYjnNBT2spG4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX7q/8y355k16oBPAWg1iWzsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjM3ZDY3ZS1kMTRlLTQ2OWYtODgxMC1kNzdhNTAxMTZlMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+BmICwIZDuFSd7VNWT5Zzw3DIhs6fR81eHNOl95AzTea5\nZlWrGNLX6TlL5EcYnGsbnCxoSTthEqLNrkoITy0to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Oj97B2URYmcAxS1ViQqeX8C\npAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfjqJQf1dlDim+rvHKNLbLcRApxzkPfEVE6eYz/UKxIcCICOjCHi1ErVn\nIl5KdO4RouADg7YuIhx9aCT8uk32x/Xh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXbZCKtSEGRnK8guFdHzdpICMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU5ZjZiNjMtZTcxNi00ZjlmLThlNzUtZTQzMmVjOTA4NzJmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTg4Mjk1ZGYtYWZiZS00MGQ2LWE4YzEtZDQwOTUyNWFm\nNWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbXaylSwt6ACBLkRR6EP769Gf\n9LYPFi6+KsG9a67Lv/pRjsd5GADkWHhCiFl0eYfj4WQTBxZJls7tYnaoTXg9zaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhket03uRGjyXFzjSTtxkgw+cowYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIDDPJNQs\nfvwl0cjxvUDPaUm150ZFiS7ScOKYbZYpwB9eAiBhm6C/na97CnJkfcHUD1qDQLh/\ngYX6uiE3FlB6/YHT0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc681", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `681` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISARt9o/izhCWXlhqt8b9+9jlfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2ZmUzNTg0LTE1MWItNGI0OC1iODdkLTUyNGM1MDRhNDQyNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJmOGUwOGItYTdl\nYy00NjczLWFmMjQtYWEzNmEwNGY2MWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZU9yymElP9qpV1PxRig6pIXzI850VW+RRI16bwkUHDaQNM2VklYJdHm5h0U4\nTqQftptLFcI39eH32qm/gC29MaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2O/Xn/UnA6aj4OD1Nopt4uCtR0wwHwYDVR0j\nBBgwFoAUL9dmzAhBSuVRuLV0LFts4t3UoQowOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCiP4vjg56pApfnvpND0P225EbDtQ8r27AbgxxDmrtI1AIhANt6\nNlcDQ8YeMJ/D/wT1cv3+gemolHP+mlv5JIdtFzsv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfTD8tDH4QafoRlEinR6ueJpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmZlMzU4NC0xNTFiLTRiNDgtYjg3ZC01MjRjNTA0YTQ0MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqqObyvVRkbRRpdgHjohe7gOB8INLvLsROmYx6VGQvJHEH\nL2Yf/QoYuGpaSYEw5SqGzUF3nbBCNjnIi2j4o22So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL9dmzAhBSuVRuLV0LFts4t3U\noQowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWBlmia8lft3T59w9eCB6Ngt2GFDnTicXiI7WQfyfbGkCIQDtH8CY7o7P\nBuCQaGfhhEWh51wCCDVhbl636ZSfvfCRGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASiONgAg+HHI5oCilLLSOylKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJmOGUwOGItYTdlYy00NjczLWFmMjQtYWEzNmEwNGY2MWE4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDk1NjFkODUtYWYyOS00Y2EzLWIxNTAtNDk1YjM1NDQx\nZTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjq3NoOW9RuLXd5trgu7Jnzky\nm89b0sOjS0SnTdIPtnKSoF9H/wStS6SQNY6muyde+mwufTf1BRJcnPXYT0RgFqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2O/Xn/UnA6aj4OD1Nopt4uCtR0wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBaYKA6T\np/AWz9fOQ1jKRRbXHe5nvAguZGxg5olQkEExAiEA/M4QOvW8dJ9pTOi7rTDTIzgH\nqC8vkKtPr8NDXmF7C58=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc682", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `682` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbgbLbJDRP4Ra3bqiGFjBVchMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlOWIxMmMyLTZlZTAtNGY4Ni05ZmNkLTU0OWYyODcyODQ2OTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAxNzRjYjMtYjli\nNi00OGNkLTgyZmQtYjNiN2FhNWY5NDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGX0URa2sBNzEyNmJwBbkUUqkzic6Pm1XExyuJzicKkhCdA94UTNNBOnpdFCq\nCc1kFrPBZ+P+zl/YDS1U5B+Cr6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQTsFMwQVI5dKxQpK8hLyOU6u5NzjAfBgNVHSME\nGDAWgBSC6e68mpOMAeUJ50d1qu7onpDjVjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDMChZNoYJUNdmTmZwY4x1ubUCobnLc\nUY9OrZivtrcf+gIhAO1UD6s0yKYqkTsQrIFQ+jDKPVOGV5TWZl0xR6qVRbPc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb6TMz3szLql8WirlqH7uBoBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTliMTJjMi02ZWUwLTRmODYtOWZjZC01NDlmMjg3Mjg0NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEf4BywUX8XSnzOmC0j1GHqY+x/gaMisXG8oHObY68kLWy\nrnAwKu8V2f2mBkCPoxYUUzlUasht5AUrnfqqkzwRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgunuvJqTjAHlCedHdaru6J6Q\n41YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYwXpHdeU9f1K4VDAxKqDEZVZcFmfSWfDxtHqyUXh5tkCIBiIq8RVZu5S\nokyWsEsA6LDSc1j9BLOCZiGAd5l5qoZn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfBo2CqProu6DYyuycCuvZp/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAxNzRjYjMtYjliNi00OGNkLTgyZmQtYjNiN2FhNWY5NDNhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmYyZGI4YjUtOTVkZS00M2EzLWE1NmEtMDNiZmI5YTc5\nOWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgPx5zZ1m+Z56TJMFj3i5o7rB\nW1iXsxsnvC4OZ2amSkP9uaTdwNiaw27Ce4W1nIx9vPhxi1mxj+2FnqVXDEc/DqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE7BTMEFSOXSsUKSvIS8jlOruTc4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIChd5MUy\nZ/idQ8mUV985M05nJPOvVSrGVjA015jC3pWqAiAN/7dAu6gYhHDrJ94vOw6ddUGN\nY5jhwneG6g0sEv4fwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc683", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `683` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYkvuAIIAPaqxJzaLYAjKVkCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2NWI3ZWNmLTA3YzUtNGUzZC05YTE5LWE2M2VjMDA4N2U4NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI3MDIwYzItNjA1\nNS00N2ZiLTk3YzQtNjQwNmEwY2Y3ZDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELe6eQlEwF3ndDY8x19BaiHDp3U/JYW7PE4uh6HN0OCVoH9t6c4Z4TQKH1iuw\nbmzz1Pg5a2rJRzTFkY32pHrVc6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7OZ2t/IXyblsWeUmvY+YthnX630wHwYDVR0j\nBBgwFoAU1HVMyOwufKjimxXZHrT4cTBVztgwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCdqL8ZpakP\nyCj3I4Y58Ib1cJP9URXdK5gAwvPX5aiRMwIgKznnQQx0MT2YkXxl9o+9MgZ7YXTU\nDuWqUB9e+YqPc0E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAauEtackHsHvBpFM/o90aKV7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjViN2VjZi0wN2M1LTRlM2QtOWExOS1hNjNlYzAwODdlODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0rEvj5x/CeIcBSjAzxjwyIeX1j6IL17OBs67ZIunrMx/Z\nD5zOI1iiXzK9YXHDJUDQPBETlyxKJAX9JVNuNZoMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1HVMyOwufKjimxXZHrT4cTBV\nztgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ35z9IVkTPYaNtNat3ILfltYBFLZguHO/zjfvspYFN8CIQC9qxMvyLEQ\nmEFDrms1JQv1Bhr5tMlG9ZX8vszpMQ+OHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASmjT8lMg0kXOUC5/M7sABBNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI3MDIwYzItNjA1NS00N2ZiLTk3YzQtNjQwNmEwY2Y3ZDgyMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjZjZmQ3MzItOTdkYy00NGI3LTg3MjktNzlhMTdmYTEw\nNDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4pgiWcFXtRvTSX6V4gZRGexq\nRf8ffp0HsdP0wDIS7gXp6DkrwiUN8I/Fyhhd2FocJ9Gg2KzQWf0ti4XmOwCTuaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7OZ2t/IXyblsWeUmvY+YthnX630wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDUz+Id\nNX0cLjnh37AmdO5Zc3D8ofxK2n61caEEVFdVsAIhAN1RtoS3XAuMd/eiderCMivy\nyEePt82Oc19eAStJ/mxy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc684", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `684` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISARaEEyYWV+CM2YaKaOQ5EFVXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4OTAxZWMwLWMwNWYtNDg0ZS1hMmRkLTZlNDYxYWVmMDc1MzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmYwMTAxZDItYjIw\nNC00YTdlLWJjZDctYmZlNWZlZGRmMzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiOPubYGqryuPFk4BnXfbtucuMdwkYVPG4jrQFy3RNvyWtL7LbLBjVSV8hnAO\nUBkEuCn3HukXYem0208jPlbWAaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1coBpUEwos50kd024+u2yRNV1eYwHwYDVR0j\nBBgwFoAUMLUnFhC6I0WTFNpq9iASAh/wgBQwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCEwL9wQP/s\nNMRAi2LRNcifVx2ejgE3LwjrXCtzz6apkwIhAIHaqI6wx0QThvVNLSB1yWVCFGNb\nWzLptZWScJlyy5CX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdqntEDDXyqmi+FBKnpgEeQ/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODkwMWVjMC1jMDVmLTQ4NGUtYTJkZC02ZTQ2MWFlZjA3NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCyOZm/9QFLOcgZp5JamZqgp8vhQDJkkuJDCaWV+2Tsww9\nO7z+LUlECzEwDZd8AWPk5w9AYUlEaOQGcayb2rPVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMLUnFhC6I0WTFNpq9iASAh/w\ngBQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSuqdW8AbQtdilsyxdWPJudvRLWW8CEGFx1JN5be7G38CIQCJ670UZvoS\nlmOq4mFV5NAu6JxA2JNbO8vwKFJcpPS+PA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAYI+LWTDCsjL7z5Tvqa3xdLCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmYwMTAxZDItYjIwNC00YTdlLWJjZDctYmZlNWZlZGRmMzAxMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNhY2Q0NjYtZDcxZi00NjdmLThkMDUtM2I0MjhkYjA2\nMGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENbJ8IZ6xtgHwCCGet/XwHPk6\n228O8SXmmAlVgdaym/aG4XvPTtIAFO/N8OGoTG9cmiGcDexrSjVpd4G8Y9vnMqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1coBpUEwos50kd024+u2yRNV1eYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCFnsWY\n6E1b/0B8oIsCswCA0JnWK3xLVmOyS8AK7hBvGAIhAJuh+n3lJNUqJd+2JhVlVdcL\nx0LPd5gwzBWuacHzWC15\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc685", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `685` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAbneHtsGrztkK8DKjQah2Sz3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMzZiMTE0LWMxMTMtNDVlOS1hYmFhLTVhYjA4MzBmNDJjNzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzUzMTMyNWEtYjU5\nOC00ZmU5LWFhZjUtYWFhMjAyNGFiZjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVLuJfywjilMeN/cxpGaQ4nEvoMpfcnC3Pk9awmkn2vMU+26/kFBEJNtJbhYF\nTsxEWvfUAOIZQA1X4J465y5PEqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrkAPMX6gJKnyBmLKcJE2q7XhlZYwHwYDVR0j\nBBgwFoAUps4ui7HB0Gf6e9FsDNsz2zAMqnowKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAwjSdCvYzX\neOFT2wsdJn+5UB3+GRg+23JeZGEh4fokRAIgapqyLe9x6HLFEUEQ5az8W9jxmM91\na9MLv/zwewav0dw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWwllzNUfcKGc1t4sNNtz6CNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjM2YjExNC1jMTEzLTQ1ZTktYWJhYS01YWIwODMwZjQyYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReBf4ikVUWRUyL8BPr/Ju6epXL4+0Tws2M4uENttHDllYw\nwtl5L0lFko2iSqz8aZw6eHiqt/hLQbA4ogiXnl7Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUps4ui7HB0Gf6e9FsDNsz2zAM\nqnowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPsZdLQzj8e5Q9X83qXaM3XZpvszQ9wSXtgjxZ7KxYD8AiEAqmWgURSs\njeFINC0/mSqCRO02Id7G/nXncwqcsqpsbr4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZNGIAezpa3V8PTZ+iPrB8bjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzUzMTMyNWEtYjU5OC00ZmU5LWFhZjUtYWFhMjAyNGFiZjBiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWZmNDViYzAtODVlYy00NGJmLWE1ZjAtYzU1ODA2MjM3\nNjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjTS2dKXb+mrvB8tTYH4E0mOE\nP2VqykTvEZvTLRxH3XFEo5RyD6aY6hCGyZZ3P0yidX/hwV2/afaQ1/fffEYDzqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrkAPMX6gJKnyBmLKcJE2q7XhlZYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIF8IKvq5\nh1suVX704zqxhI9jqztr3KIOb/faV7ABR0M8AiEA79iOUPjk3PKlrPVhgjB98T4H\n6oUolUaLOiGPTgqgslg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc686", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `686` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAXwHkFbMRJa7o1S1AtMFJPWpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4YzNmMTdhLTY2ZDEtNGRlZi05MGRhLWYzZWExYTRlODI5NDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNhNDQyZTktMWVi\nZi00MzUxLThkMDEtODFhMjk2YTIzZDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbMUvvikmwj2x81VqMKPNw76RfUKHxHFbEtiUMsn749ia5D5qY/DnIDkliPMW\nKk9yTzMQFeCvWE4QP9K6A9QzoKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHshvJSyv7N8/5SHvLj9gZ1h0Bp8wHwYDVR0j\nBBgwFoAUFUPl3sYXNXO5rqOMKNsqGQ8a0f0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiBuqnouP4QAyyN3knblrRgg6h2I90digRorEC9Z65OTNgIgPKcnAwBj85BI\nLC/sHZyQpgLtU2taYkLOVJENw7W0DIQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaUcrO1mrpzwWhyTrs935xgNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGMzZjE3YS02NmQxLTRkZWYtOTBkYS1mM2VhMWE0ZTgyOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFiRAPSHsN8NF7n6N8rDXuydHA06Q1xvmOuBL//pJmTua+\nV1tQuao6Dqi85u7xxbOvkVbF6BOk+zPBNlw6One9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFUPl3sYXNXO5rqOMKNsqGQ8a\n0f0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIP1oS+fii08uwmi0BeG6QGoc5niwMon9MJfZysebnIcAiAeCj/vlctq\nXu/frWF+bB/F0YuRpxduUoUSxB00drxEzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAV9Kk9jX2wg6lkfvbyZEA/ikMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNhNDQyZTktMWViZi00MzUxLThkMDEtODFhMjk2YTIzZDc5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjU2NzA3OGMtYjEzZS00ZjVhLTg3ODAtZDU0Zjk4MDgy\nZjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELGsC2n50tct0WEF+102eTHdI\nmkVn/pwvgietEiuOeDosam3MYPEut1nknhb9kBT84Rys6qepc6PlzGRlb3HVeqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHshvJSyv7N8/5SHvLj9gZ1h0Bp8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCflmrw\nNEB86/Uwzbd5QKJV5jEjByyJ5qjY5AhbmtemNwIhALJgk3lz7hdpccU3Xu4/IZ0y\nfCNsWO9JEf3Q6c0sOJtN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc687", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `687` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISARfr5W+XcU6McnXfq8AWP3FiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkOWQ0YThjLWQxOGUtNGY4OC1iY2ExLTk4YTQ4MWJlNjhjZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE2N2E0YTQtOTNj\nYy00MDU1LTlkODUtNzcwYjc0ZDZkODRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELTW1i5pP33m9Uox4t4Eebn5YzCERiUWykaFJV0zYXfdUONctR2doizOJ4A69\nhhu0kysKNVDVgy2p9VTzVaDimaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7fE9VPSNX36wHjR1oKQkuI8iR54wHwYDVR0j\nBBgwFoAUuglefL+tS9pe6v5OmecdLIoNUNwwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAPgAOb2GXQDQoLlgdiv6vPniSoOKxnABZ2wqYFXO3EhAIgGrlDcYPY2TYm\ndX//38DZsGnJ3APlyxKPzE90UBXKIxw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa62lGgEsQwP+7tbb5X1cpA+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDlkNGE4Yy1kMThlLTRmODgtYmNhMS05OGE0ODFiZTY4Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASt0OevF9615UgQcybK8CIXPp/7VhokwO3XBBsQhphOhYM2\nrsrx00V173iIdACOAAwCEJeE3aSRpsAsKhT8p2wjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuglefL+tS9pe6v5OmecdLIoN\nUNwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMfAP/Qt6andJYq+Dsr1Yb8r3M7LCuLDFIDM/KoE6GPNAiEAhmHDid+O\ng4j1l8SIe6recVmC/SOs3Tfv4LJGAt6Dnm8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISATGaL7PeBo+RR5v/8dbWgYxuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE2N2E0YTQtOTNjYy00MDU1LTlkODUtNzcwYjc0ZDZkODRmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNlNzRhN2EtMDViNi00NWY1LTg2YjgtNjJjNTM5MmQ3\nODNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5vJuQYsq9+EPe3smD/tilhZ7\nmeQcBqM5PqvktR20a1d2BDreFRMDock9wO2KvTn2MdnxqMmzda/37FieTGHBUKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7fE9VPSNX36wHjR1oKQkuI8iR54wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCfMaTb\nVJLkv4CUFQ6ycUVr96r/i95E9PrbT2YU6nG1+AIhAMkd62J814MuQW4UQ9BZxbP9\nViUQc4vj35wImZ5PCrfD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc688", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `688` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAezFt0XWEpd0Z+Znx3/OW7KiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZmEyNzJjLTMzOTMtNGE0YS04MjMzLTU1NzQ2NDUyZjNkYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM0ZjQ0YjItODIz\nYy00NWIyLTkxNjktNzUyZTUzY2M4MTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeDl5v/VR6UioyOcH71Mfdxl5wOaQj36JUr93N/xsydWkUZW+If5LSaGxIU4T\n8E4UQrqs3BSppby4UsflK/2E1KOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhyHgfsomRY1Qb38JjOi6DlMiD6wwHwYDVR0j\nBBgwFoAUOD9nhEtzg4m6q8BXXxsiUX0qzMswMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\nySui0Rj9xVUiHVzk0+xrf9mpbcvnJkxGTX5FvT+41SMCIEoFo7rg256cAfKvXkjW\nEZxtTMUeG6MCiJj3qTFF6JHO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATWtmKkiJ5psN4cnL4WNvz/lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWZhMjcyYy0zMzkzLTRhNGEtODIzMy01NTc0NjQ1MmYzZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvfNmIdKs9hXsu00lwOjxbL6/e1pusiggOMwRJkola7zdp\nXi5xgpWneV6DBXlp2AkdrIn1FgGsdUV5n70BfH6Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOD9nhEtzg4m6q8BXXxsiUX0q\nzMswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFBNaGWglPgVgz7t//P0G0OcVtcIDnCbbV6H5HRiQtm8CIQDH+uNqeiM4\n13J7MMILLrurvA0TyTXgzyzuq0wpPWFITw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAV61ix/yufUWuzaMOjHmn1RsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM0ZjQ0YjItODIzYy00NWIyLTkxNjktNzUyZTUzY2M4MTBjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDllNDc2NGEtNDMxYy00ZDRmLTlkOTctNDkyZmVlZDlm\nZDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBrMcPJSt2cCnx57fdyI3czcW\nG7V8Cmu4qWhFSQq8nnQ+L5i3rrtRzgmIJ/QS2BrbL9mjeeE82zf7GN/CqohBTqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhyHgfsomRY1Qb38JjOi6DlMiD6wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCeDJM9\n5XOzSIWdMfAQP8ib8dRYiVb/v5rTe+2FkaxMlgIgWOvHcqSB+9+qUcDmKheNYLWA\nsDOsUbC2Cl2FwCSaxFc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc689", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `689` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAeKoCoVCor34EQiaJA9604lQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1ZDhhNjdjLTMzOTctNGIwZC1hYTQxLWQ3OGNkMTY4NzI2NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU4ZTk4ZDEtYjYx\nYS00NjEyLTkyZjQtYjMyMGYzNTQ0ODg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9YfJoF8z6vzbjXxmaVAVvwS737/Se+SUgUmZqzoLD0k09J93YEuf+1s6PYFT\nxjRnXFrwgFxbCJ2IT2toY+2xc6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0qiWWZAvVyDuzwCgnJuX/9JcRGYwHwYDVR0j\nBBgwFoAU1HEINvRkImwgCKvHp7w8k4YadAcwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiAySRvPwlmjvLlnghdTZ/z3DF0SNWip63KNbp7nqCMQjgIhAIzp\nyMxmUggWWd1UcdM/b/g4bTYq0rM/R+NS7XuqLc7L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAac/MDC0FHD/8W/xWKhb7emxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNWQ4YTY3Yy0zMzk3LTRiMGQtYWE0MS1kNzhjZDE2ODcyNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7rx0m0e05/sGwRqXLGa8EhIeLZOwMC05AJd9DMP9fcgiI\nK3gtGS7LdGnCQauiShVpIYWE8sr6MJDbdUDMSwfno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1HEINvRkImwgCKvHp7w8k4Ya\ndAcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANubxapVfjsSnrzhhT+JXEQObXeXd8cBB33CTWwKKDOzAiEAwCnFDMCh\nFigkvu+TDs74Dm5N7q9yplDBNuh3hWft8hA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVdnDZMz2KRqDjv4i3WBFF7TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU4ZTk4ZDEtYjYxYS00NjEyLTkyZjQtYjMyMGYzNTQ0ODg4MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTU1ODA3ODUtNjZmMy00NzU0LTlhNzYtMGY4NjVkMmI4\nYjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETEdspPsjtstAQ3ClS6opvIxM\nVxd2xB6YNuKsyTUlkQjD8ctPEbwZK/EQl3sBdkQhT/Upx5cwaXtHatvreqFd0qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0qiWWZAvVyDuzwCgnJuX/9JcRGYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICQgl3zJ\nyAhlTKQrzysAdC4U2WkdZt4XbqJ3O6IA6LSHAiBed1/akaeBOQz9WYOjCWM6k39D\ndlJWJPGC+gZ4OPO9sQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc690", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `690` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAS05fUwfiDRF4t/lX2JAciR2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MTUzMTQxLTEwN2MtNGY1Ni05MTFkLTQ3NzMxMWQwNzg4NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYzODY1NDEtZTEz\nMS00MjFlLTgxOGEtNzk3YjA3OTBkYzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQf7pyvog2cvl33E1itQ81FuTIgiFm5gAhfsF+kujNS4Po5p9Zp+NKBiRiNxu\nUh6lVr6l1WYDU8UQDccbbgO74KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP4t6/vKXlFg8oJhi5yT5QgaeZUkwHwYDVR0j\nBBgwFoAU2l4ytbVa+d5srMqxTB9E0rtm+TAwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiAWZCXNE5MRtdTHSQgtwBtf6Ow4gIglOCbpK93Bse0cugIgNEIP\nvmaTaZXkWFVOQ7eGbexiaoMJpDe4EER9YdSjkec=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd8DPylw14kCfFhWQnaFUL40MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDE1MzE0MS0xMDdjLTRmNTYtOTExZC00NzczMTFkMDc4ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYyDpd0Pi6WjBNK052uciGnz2z5bF76Rhihxxk2mmvFTu6\nrNvor8h9BHIvNcJP2LGAFXCZLgkDpgb0uZhGHbbuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2l4ytbVa+d5srMqxTB9E0rtm\n+TAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIlFE47ba2G/sO6yIpSWut5mdDxwkC4qHhAOkfUCp/KXAiEAyY7mpD9B\ncS9vPOPQ8U1nOaN37Q4cdRThYsGHMWtSyNg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAb192LeE0tpzNoZAB6z+8JirMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYzODY1NDEtZTEzMS00MjFlLTgxOGEtNzk3YjA3OTBkYzQzMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGRiYjkyY2UtZmY4MC00ZjhhLTg4YjAtMDNlYmMyMWVl\nMmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElYU6qoBXAgcuqKHaujfWzJeX\nCqI5bDoMrUrgvBo4pr+gjkpDvRnDsePnAd6qZfOyRp5Os6bgJSoxEdiFLFT9JqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUP4t6/vKXlFg8oJhi5yT5QgaeZUkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICSEpfrg\nbr3jvJUgvK94VGccvxaO2fJJV061AULGBFnDAiBo53qcjecZRHJGChjkOsxoRN6J\nNvhajoB+Xs3rjyMUsw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc691", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `691` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAVsFjyymIDQHPhlXIFNi3Z6XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0NTZmODhjLWNmZjQtNDI0Yi04ZmI5LWI2ZTM0ZGNjNjQ5YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGI4MDM2MmItZGU2\nMC00NDk1LWIwOWItYTk5Nzc4MTZkN2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHA9R3X7z9LhcBDuEhXGlHsRoLbyyMzrxdhE3/sqrQthUKIVodx72ngfKn1li\ne8yQwtKVBlMyvrdyPpvXF+WBraOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWFJPkZdE4vSzwhOsCUdf4g+cQ0gwHwYDVR0j\nBBgwFoAUVX8goXDa/vY7RHLSXkNnkjf8ZwswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiB3lZjlGwt0DtjM\n6UpBz8nID51CtHL55FvKwKrUIHgsMQIhAMpglb2HKBpRXqxoaSteTL3EZ98HQ2ru\nJonJK5Ebwt/1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQJE6A7vaIpONxxz62rLpmY9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDU2Zjg4Yy1jZmY0LTQyNGItOGZiOS1iNmUzNGRjYzY0OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBkZSji+EWV8F/BMYZDzMn6PueQKkHhO/+3YRrlCeN/Naz\nv63NKeyw3C3Bfl4iqA+JmagTc1mUJoBXN2ovM/kMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVX8goXDa/vY7RHLSXkNnkjf8\nZwswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMpmpSoHiabrUuW8Mdg62fp2AFxuKjlakUWbTRh4n/U0CIDeXXRo89Sci\n3CM9dAHoB5UkkMUTLiR7RZcgoDH4qTaE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQjlOQ3HSajngZN/972wnwQgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGI4MDM2MmItZGU2MC00NDk1LWIwOWItYTk5Nzc4MTZkN2I0MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQ3ZTQ2ODgtZGIwYS00YzVmLWI1YjktZjMzZTg0ZTFj\nODVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELtDmbwwgg4/KwCR5RrliFKfd\nHYJnmXQp0ogf1Pvl5Q2m1jz1YTbLJpGhYVI23tcTSRnFlxQpHfgTMAFAozfGwKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWFJPkZdE4vSzwhOsCUdf4g+cQ0gwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCKYi39\nAo/HsKExgW2U7jBUuJlRRPYNDS05tHLXnlZrmwIgJoYLcUU74MOsOKQeLsaCYETq\n4Ur0epFyCiAtxnQv8gU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc692", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `692` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAV+B+4k6ty+q2u7kv+yNpyYWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwZTJkMWY4LWVhMGUtNGIyOC05NWYyLTc3MzlkMmY1YzBkYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE5MmZiYWItMDY1\nOC00YmU2LWEzODktNzM3ZDZmMzU1ZjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM0Z+owcPTBbqDuElVTnISh6RLwR6kowvvFyi5D3koTfaBFgW1iclDfEwfhfP\nuo0DjogtgZOxabAGOJfKu/Qfu6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX5s8Xkx3pU4uASiLylzhzzTsw0MwHwYDVR0j\nBBgwFoAUssTpPPxyRG9cYlgjU9VKPqqy/ekwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDtvCsjsHNnwWAGf6bfWUAcxZrpvJbHB8tYU3yYzHmnuwIgXP/VrTOJHepI\n9jLKU+nRIcC0NvSgRYeG0NXWUrLxAaE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdhjgkUK5FkNCN+EEXwagBtuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGUyZDFmOC1lYTBlLTRiMjgtOTVmMi03NzM5ZDJmNWMwZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSG8jxwjqDjfXJx6viYGZ3uN0kVzp8Qj7aN5UN+xDwfpEU\nNPZmjZtdabnfQABQ0b5r+qQtGv0rdGBlRc3v5c0Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUssTpPPxyRG9cYlgjU9VKPqqy\n/ekwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM5UoYeQc4FWo48UAK291psBFQB+quKlabozuXcRPAk3AiEA027jPxwt\ne/+fKUsirfUssZAKCCx+U5zgLLHbSaxRrLA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAWk8JIkdiy4JBp4Wr8tEKBECMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE5MmZiYWItMDY1OC00YmU2LWEzODktNzM3ZDZmMzU1ZjM1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGM2MjAwZDktOTIwZS00NGRkLWI4MjQtOTE5M2JlNzFi\nZGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfOreNyNbPZkOYpY/Q1eO+NLM\no6yzgTUoqXnuICe3jYp/6X1PQFdgU5/4xh74pGQIKCcm9OyaF4Tu15qWIwn/OKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUX5s8Xkx3pU4uASiLylzhzzTsw0MwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCgU23J\nC23+6Vrq56/RAW7c+iHTz2nMb/QbIZu3t9309wIhALbWkSeHFeSFfteP6JXbd0+1\ne6i+PDONs7N4cFWEsJ+D\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc693", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `693` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAd6xGNzm+N25wY/T1ecxzJUNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzYTZhOGVlLWJjMjktNDBhMi04NjdlLTAzYjYwMWUwNTk2YTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FhNDc1NTctNWMz\nMy00MjA0LWIyYTYtMjkxYmVlNGFjMjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoAG7ht5fBVLmPAe/DE9gauJjH+HM/ntyYex3cjfnJffLQZA70Elx2k+Affgu\nPZ1XiJroDyd/eZOzEnFtEqIh/6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiSi0h0cj6hbz/VToyq+qclFAbv4wHwYDVR0j\nBBgwFoAU3QKNJwcBCzHJWXHsjcJX/mRQXx8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD8iBjPjX1XXE5URFa8v25fvJuoY8YukNRsAjG6ez9/NQIhAIACFPOlnkni\nKstg2nKATQZknh6EnokjAcGpU0XxO7pV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf/3Kr32pMNtua7ZeXbaMBx0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2E2YThlZS1iYzI5LTQwYTItODY3ZS0wM2I2MDFlMDU5NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmxiXU0fn7gsnvy9cum31ngWupvI0K8gRbWrZHlGmm9wSj\nqTiPOFoq9PR/NWmlUUlsOm5TdQu4mU5w9tL3WKldo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3QKNJwcBCzHJWXHsjcJX/mRQ\nXx8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeyaaHp0h/ZTjvimR8UWDv438yHFryYo5z95M7R0rCVoCIQDbTiixr1+4\n8wLD/1h4tfrfRu9DJ3OXI1BpAZXoyMUC9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQ+h1E5ZCCwb3TTx9yAdtKd6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FhNDc1NTctNWMzMy00MjA0LWIyYTYtMjkxYmVlNGFjMjY5MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTNlNWFhMzQtMDFiYy00MzcxLWFkOTgtNDY1NDQzZDdl\nYjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtAv7wqtQfiHum6mMLV8RArv8\npHAsKdZcZD7M+JxezUdN1VySQDb1oo4YOd5665SvSEoBGfVQLrbNmDNlD8G6X6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiSi0h0cj6hbz/VToyq+qclFAbv4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCd42SM\nwe2jG++momgNs+xVbS6R1Yzpd3kd9AIGuy0CyQIgFqGYIhtKjvv4zQKh0RjpvIXW\noKhl/kO/E+M69thGSjQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc694", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `694` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAVjwS5fYJ3YUFpLF83YdXfDaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5ZjI1OTIzLTZjZGQtNDE1MS1iZDhkLTk1MDQ1OTBlZTk3NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYzY2QzOWEtN2Nm\nNC00MGFmLTk5NzYtNWY4N2QxZWJjOTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhWfUnCLsB/1gq0UJPSfFCLhovZE0OGdzzLoIpJcDUj3UPUmc5AFtt4DzHFCI\ny0SmT1QHTS+F/ZGNXADV8HJ9hqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS6J9Yacgkb2JboAXJbfE2Fid8KEwHwYDVR0j\nBBgwFoAU4JfoDsoPoWBaFcd+OZ+dgLCBzj8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAoSBXRGdCd7qpwercONyF04ga8t2lRwAF2qRaZVCCPswIgFqjDzEBmWL3k\nSvWWPjQ/H8iIGj0u/Z7oMe+HFXXLteA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcEH+J0atnFptrLsPVf4+L1dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOWYyNTkyMy02Y2RkLTQxNTEtYmQ4ZC05NTA0NTkwZWU5NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQW4JHqKKG7gn8znJNg/aHd6vMwb3Wf8edTzIZXmvLfzzjg\nVOhnJIXnJRbvhKR9W6QZvbRuu486sqsWY6XfmITno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4JfoDsoPoWBaFcd+OZ+dgLCB\nzj8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgULKN8FwzQH/rxnvgOwqSL5QtAO/v4Mo/CmJsr1In7NACIBumAO10de51\nA1jTOxTO7+wJcNdmm6bM6lUHvVm/bZQq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASTw/s51TCco6NhNhF6ADIt5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYzY2QzOWEtN2NmNC00MGFmLTk5NzYtNWY4N2QxZWJjOTdhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODJmNTAxNTItNmJhNS00NTYxLWI0N2QtNWY3YzIwNjE0\nNGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErYSqFadf6929bnZYgpYVU9VO\nrRKbenGmDUodeWn+qmFKyKruoEnDBoOZZd/x9q055agdn5LJFz5byAhC8x1zqKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUS6J9Yacgkb2JboAXJbfE2Fid8KEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDN9mJFs\nGXKmgGXd2fESGql82IMUk3zDKj/OYHAzCJhhAiEA8ixOL/ojFfD/k/i3S7n+PB86\nGpGTAWKVndGzbxyF/t4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc695", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `695` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWa+aWAROq/19DhEfIsIy5sRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0Zjc0MjJiLTBmN2MtNDg5Ny05NTc1LTA1Yjc3ZmUxMWE3NjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEyNTJlNzUtYTA2\nNC00NzJkLWEyMTgtOGFjZWQzZjAwNGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErJK5N3bxZ0VjrFerQCkrocl+7lfWWBouDb/8NZbQkGXcVSRSk+aVOVhd6qBG\nfbecxDceP50lUdlQB5tSTVGBiKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrft5oaSdHbZh8yk4/4q6XISOxZowHwYDVR0j\nBBgwFoAUdcOzvJeu/ka3NUbncShPek06nSMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBVTc8IvJKsq8wy9TDhFldoU1ZS6kOoi6e3MnWvOny8\nwAIhALf/coqU9gPiRT/LwXUig+nnnbzn95kdYnz2STo4YUmu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdQ5eeJAmJreOX5lVuFs6JKUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGY3NDIyYi0wZjdjLTQ4OTctOTU3NS0wNWI3N2ZlMTFhNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLFKyvwhTnEI6qZR3mJIcI4pdsSDlsqXDL0/GKh2Sv/gDg\n/F+MFLug4kmVtyRrpeqleHbUryUYVTJZ2+u0gFbTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdcOzvJeu/ka3NUbncShPek06\nnSMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWLZ9U4Ui9npNosZP33TK2S2P6iNOwVUrmKiA154MDGwCIGx5T6V6toFq\nmVbbX7uQhxSPGyX0umTJ0tCNZsquJd1r\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAap8+RqGQq814Cym/avbgs4xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEyNTJlNzUtYTA2NC00NzJkLWEyMTgtOGFjZWQzZjAwNGRiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzA2ZjUxOTYtZGI1My00YjYxLWJiYjgtZTU4OTJlZjhl\nZGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbs+ht8F4ai/sGKLwncniuEuy\nK6xw3VdNQhwFIOSbQW6oFfqbPk/u3mkCN0g1hfqKZ9+ec9sIeESeAbVIE3+3lKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrft5oaSdHbZh8yk4/4q6XISOxZowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBZ7grfv\n1x7mopNaefZttyOaELpiwdekMfGc9NfOQbFyAiEA8ZhIrWUa8kv+ZyTzJNaxs48s\nJ/x+ieGcaVZGDsMBzus=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc696", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `696` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAZM6pW5X6UCjuBfInqM0zV7WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3ZTI3ZjllLTE4MzItNDI0ZC1iZDQ2LWI2MDBmZWVlMzA3MDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmYxMjY3YjEtODI3\nMi00OWM4LThhNGMtYTUxNmQzNDhkYTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETcdXbFhJC39MNvhgUmrNZDRCxGM6q0j1wT/vAVexsiu7D9+NHIXfS7eDbj4u\nvLHaCz9mLR/RZdU6RsKtOVU5GKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2rFABSKyg7BQEe+AeWBPY2SUtSQwHwYDVR0j\nBBgwFoAU4ieXOOg2KzzLBluQzhzCXjnBRHowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAqdiYnGIvB0HcYOg+t59o9b/iSmuNDfKOhgF/ITLr\nDjQCIQC56rs9PU+gPSXHDChOcteEKFT2G9bCAJdv+MoIouXj/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVabR4WexWhsYBZaDE+2gQFaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2UyN2Y5ZS0xODMyLTQyNGQtYmQ0Ni1iNjAwZmVlZTMwNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGvxGGhXEP6J6bhhZuurBZq78GcsH3zt2B6KORc2112+nx\nPFD+3TwIUJ2o6FXdNVZDhb9FItaJH79yvO+1Qv+mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ieXOOg2KzzLBluQzhzCXjnB\nRHowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCzD5aGasnKBbVk34MH0K2VkUU5o1QJYVyACgxzK0nK4CIQDmdfVMy0A+\n1/q4K86xBRwtf2VuyTrDZiNlgWKaUkm1OA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQHV8p4tJ5TF3mi/Z8gjGHYoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmYxMjY3YjEtODI3Mi00OWM4LThhNGMtYTUxNmQzNDhkYTAwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDcyNTczZDYtZjQzZi00Y2ZhLTlhZGUtNDVhODc0NjY2\nNDM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoK6MZmL5dEoEF2m3SMxuNlWT\nDgh2nTEUEHXi/KqNVUCOc3VcA10qc8stHNVbdqsJNKYDfdz+Wlla/gdEiFrRD6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2rFABSKyg7BQEe+AeWBPY2SUtSQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCKlLWn\naB6xQRqrSSeXF0AjmWvxRTo9yKAfmG+8ikXUygIgJBZyoPgjua5woXOWkzQfbyeW\n3IrkxsbH6NCr/dBNAFM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc697", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `697` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAeLmOwBX9XNk+yNCNLsx19EqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkMDg2ODE0LWQzNzQtNDRhYy1hNGE3LTNmN2EzNDk0ZWZjNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI1M2QwOTctZjBm\nNi00ZTYzLWExNTktY2U2NDUwNGQ3ZWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETsziq6239qlIR/mRcB6FNmXW0j7y4Ra+mLGWsiaupwspLykx62yKEciPwFiM\n3HA68a0xjFR5yzo+dgu5kK8XcqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1/ixlVYmoeu3vfeYOIJ2Q7myLgAwHwYDVR0j\nBBgwFoAU8wagRaffoztKWiJG+2BK/eS9/t8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBsMrzPGppoNPDYERP3VFe1L3oFFLywsUFAp+gaB2e+/gIhAMB0\nLFjzMGLPY8zIl42r19JnXc5/asjSgQ6AXjHoLMHM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeXTzPmy2E451XOymYWjeHv5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDA4NjgxNC1kMzc0LTQ0YWMtYTRhNy0zZjdhMzQ5NGVmYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtWJx3OrV3bJOiel5pg6kdYS6F2H902FzlAdbEQZtGLjQ+\nz68PCf0ceNrZ/Qwrb87fYtpCdRUcUyRQKYYUNWjdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8wagRaffoztKWiJG+2BK/eS9\n/t8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJn4cQmf6EsNLo0U/ggoYTAaKh1yNpeKeBgTj+vHvP+BAiEA93hIS5bn\n8uNADLzlkx7fsOIntysSbvlSxzs8V14OCdk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQ3j/WHFN0OgguRLwqtIj/yfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI1M2QwOTctZjBmNi00ZTYzLWExNTktY2U2NDUwNGQ3ZWRkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWUzYTljMDMtNWY5Yy00NzBlLWI4NGEtNDc5OWI3N2Fh\nOTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUVvJwcSdHopCm3hyfH5tNL9r\nQRkG5/KmfVTCdA9bEDa//xhxab41aELIURhD9APoXDbtQEAvSwYVeb0DaUiQzaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1/ixlVYmoeu3vfeYOIJ2Q7myLgAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDhbP1y\ni8Qiti3WHVPEAcnZfQF6Mz7mmXuc2Svb8PFBLwIgIHKzssgyVLIqsjnL00+PofWl\n/sjfZQIsOMBNtrQiia8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc698", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `698` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARnA5ZA+zOcXfdzywuTaBaaOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyYTRkOWUxLTNjZGMtNGRhOC04YmMzLTcwNjcyMzQwYTYzMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZkMjRhMWUtYjUx\nYy00ZGEyLWI3Y2MtMzUwOWYxMWUxMzRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMp+vqNBefnno70rLqn6xi5msi1jr7xXaop7dtyYCgzObgsmGwye4oMmzmqPe\nHnvJFRUxEGlgIsWrsXS4TV/ioqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1/cjALz9PyocPjMqyIWIauG3TZ8wHwYDVR0j\nBBgwFoAU7YBKnmZfsnlkjiPYCZLawwiJYRwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiALI8qdyalWcDnnkdqdXAZbzCRUMtGY3tPM\nkVbps8ieSAIhAISaMDj8JSfZKxZpcJkmvvlJhdusrf1e0GJpSfeesJYA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWyawDBt8E/oIU2I7X+Z602aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmE0ZDllMS0zY2RjLTRkYTgtOGJjMy03MDY3MjM0MGE2MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyGWLufkzeelkaWIrFufSdhFfm5t4lS9U6FphGoYV6RihG\nDZtWuu2BnLxDsCLsfXQ7NDugRj53h9gx8ROh9EMPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7YBKnmZfsnlkjiPYCZLawwiJ\nYRwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ70MrylcXnigx9SuFKJHF/jpZG97cc0SznFh0N0nxlcCIHZ0SCWwkLfw\ns2LcwpRrqJhb4apFfJUeI491DnXMMcpL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaIoT9s+lrQBsoJP3aXaK14TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZkMjRhMWUtYjUxYy00ZGEyLWI3Y2MtMzUwOWYxMWUxMzRlMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzMxZDc4OTgtMmIyNC00YzhmLTk0NzEtMGRjMWM5MjUx\nNGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb/NMQQZjA0LOfiZtsqH+H9ED\nAja1B2yG/YgHNL/aGBD6jpCMGoHp7rQVn5ZPAvEh/u7h1ld/wenbzXv8eDv5f6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1/cjALz9PyocPjMqyIWIauG3TZ8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHtpIyMy\n691DmvOZGA6du8Ka6pnPPZ3Aox+EPb2P6x1qAiEAhryeu/ticQBT3yPPoAS5qAHH\nQ27sZx0hVcQibydw/6c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc699", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `699` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAfSwPI/Ktp1CmSPtT5Wv/X0MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5N2FiMWU1LTZlOTQtNGM5NS04NDU3LTk1MTc0N2RiNWRkOTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI3ZDIyNzctYjAy\nZi00NWNjLWJkY2UtODBhMGUyMTc4YWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2CbDp9zDV36LxNYhijUdbEKDE89LfNkATbuicM7tS4qjYvOC1YcOyC/JjWAs\nwB8QtcTfZeFXnXr2iEa1HjqfXqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULiQBLczeTsJz3+jMhNyCUAu5umwwHwYDVR0j\nBBgwFoAUdN0ZamvXv1npPgL/QhLDE9PHGvcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEApI6Uk61FXlV/2gp6O3LOnx6cowzVJLz8\nZ7rlDYVt3p4CIQC1ptnyPQef4E/MDCZsKihOICoXCnEY43I2uaA87JSOdw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARw+cTeCA47SH6q41u/QldJAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTdhYjFlNS02ZTk0LTRjOTUtODQ1Ny05NTE3NDdkYjVkZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/n20xhH/gnGC/LjgctD4t9BzLzs+Bl4IWwe6/RL8KKUZ7\n+MlAR0f2yanqgW6naWOBWkrO3POd8iQGEi70wMsDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdN0ZamvXv1npPgL/QhLDE9PH\nGvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJf1jaVKrF40nPY9h1vtfZwIbjG+5JL4fTHv7/2tuX2JAiEA8r6Q+i8N\ngnmIlogIEn27lZNXx3Ok64fAl5B/yAQelB8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXzm4qzTMWHXmcKAgNlR+qi5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI3ZDIyNzctYjAyZi00NWNjLWJkY2UtODBhMGUyMTc4YWQ2MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmZiZjA5MjItOWY2Yi00NTNkLWFiMjMtMDdiZmRmYTkx\nNDIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBp77WlcmzknIpN0CW0bnlfTM\nIddaNYDpQDi6g9e5/gqbWmgHZdksYRZT6DjX0tN8zOftLDg/GjYEjoa93y0j7aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULiQBLczeTsJz3+jMhNyCUAu5umwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIEkebhF0\nrBoIEiFDO3Vi4rV/M9v7KWCWIDrQB4HUjIC+AiEA7KLP2+Lnw1Hr39QslN9HZ6cS\nBmGe526u/e7HHrly3+w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc700", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `700` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbYYen1m6CFQ4KnLianoUd5VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlM2I5ZDE5LTI2NzktNDcyYS1hZDE4LTdkNzk5MjczZGNkMzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY0NDg1N2YtMjI2\nZS00MjBlLWJmMTAtMTljN2FmNmMwOWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Kuaaf5rjMiiIlAHTzLk4lfwOYLJpgGRYuqiSkVGzD0XXb4D9HhehH5eZW+6\nJ7uepGQvPmY8GebxxBYHh82lRaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7vOfOj0ajwIHkzC5JeGFGivA8vQwHwYDVR0j\nBBgwFoAUdLqnXfTy2Wyr2LXLRcrQmSSIuLUwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAg+TZ/P21JMwy\nyud0Hwu0ur3XCaRVNAwsXwVi8v1bIjgCIAYI90d/mZfUakZ3CdschQAy9hbGk/e9\nfUbfclU5ZHzY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS33jg5HVZKpVgi9yeJWGNONMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTNiOWQxOS0yNjc5LTQ3MmEtYWQxOC03ZDc5OTI3M2RjZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXX3J3SLqmHo6bhl8UdaneJqIYeGRsHnHU3lYWyJnlb8Q4\nSaFe9RgYMGRfibKLwiEgQFKXQd9J1NUdXjKQGDJDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdLqnXfTy2Wyr2LXLRcrQmSSI\nuLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMZ4c+50UXSAEu/AYiFXIXZNihZzK15esuXGOQ9f8U40CIQDofmA+dauy\n68zsIMqVk4+ljrlPY0nH/3XeQ8zMWo3ZVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXekddRBtEDgJGKbcbJr6rI8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY0NDg1N2YtMjI2ZS00MjBlLWJmMTAtMTljN2FmNmMwOWFhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGI0ZjM0YTctM2ExNS00MDc1LTkwZmMtNDBiYjdhNmRk\nODU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELgwCCxlQKQ9h3WPcTNeNHLgv\n/W+sHi4f3O66/ahH9YxsP0t0I9Kd0IT77oFMPJYinv9xbJkJnlOwPLqfojqoWqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7vOfOj0ajwIHkzC5JeGFGivA8vQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCl6IRW\ngwsi7K5A3wkPWjQvFkyP68Ca+y1CN1CP3Vsq8wIgRwHQyldgRw6kxD7AdJw1bKTU\nuCFSCA4x3oo40OjJXrQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc701", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `701` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAd3I40/ovkJ0jaDchBfhadNFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YTRjMDkyLWFlN2ItNGRlMC05ODI1LWNkMzUzZTliOGRmYjAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzE0MmNmOWItMThi\nYy00ZTM3LWFlMzItZDQ5MWZkODg5ZTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE51IlMzoVAGPtYpOHbGoBjP5TyNO0CH/R+dPBufl29OoEl3RtXuYmhUzSjzjc\ntQm52PWTtcLN1xTUbBO0N6hFL6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGWmO98gFfpW6MMRZ4hZa131LdHgwHwYDVR0j\nBBgwFoAUOd2ljSc0fWlv0Tk7AcKqEYd9cr4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGERACpO1gP32N9l1KHDUOaZ3h0gQn2e5cdDDahyZs1SAiByNMKJ2uClg/Qw\n3AIf1aVpCuHPeImsO/BvfQ+qr7tK8g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZpktXJlxxYtpaRunNe655MxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2E0YzA5Mi1hZTdiLTRkZTAtOTgyNS1jZDM1M2U5YjhkZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYC0MX+UHEn+vsSvsW/Rbj6ULhY/mK4F/jsxPMHUV+Dz78\nB5fyV/dbqM+yi5CVtt9ACRS8VxNaoEjGgmgM0hlao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOd2ljSc0fWlv0Tk7AcKqEYd9\ncr4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAInuFQ5ux8zfwMXw4pKuZGz2xLF8jdKDsXxQmPxYM77cAiBSlDDn+tN9\n+UJoAedQpngl/Z7+nWUlU/UiRwVwpwcW1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAT28SLrEXxYO6/Q9kkXj4edfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzE0MmNmOWItMThiYy00ZTM3LWFlMzItZDQ5MWZkODg5ZTRmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmU0MDAyZDUtYWVhOS00NDYzLTk3ZDQtODFjNjQ0MGFh\nZjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyuqOag32xLTMJZ3DVohRamGT\nJpG/oBPg6j92AMQ9ZJdSsuQpZrcWaf9cX9Ej7GXZ3Npx37DMzfS7IHEi3Nh5xqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGWmO98gFfpW6MMRZ4hZa131LdHgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDwJk65\n13EnrV4RIsyBMpZJbIQtxPh+gKfrDXqu1XTeRQIgTTsdH96Dq9Fjk09+JjS46EQL\nio42u/ODAeUS0kg53BM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc702", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `702` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAS2APIC3AfaEIBFOmp358wE1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3ZjA5NWM0LWJmZTgtNDliNy1hZjZjLWU0ZmQ4MWI3NThlMDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhmM2Q4NGYtYmY0\nOC00MTNkLTk5YWYtNmViNzU3NzNiMzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ6bzxZlCSdL9l3rCHEVWwpeOvUXdspZ11nyN+gVhKXwHzWztN0WelakRp0IJ\nhjF+45GITvFsMlaVPvR2o8MjFqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6FEPTZ02UZbXbda44JzZ6LmfCIQwHwYDVR0j\nBBgwFoAUjB57k3JAbDBAjh+1aLy5C+bsKJEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBhNN9KgnZiZ2FIkeJTcBDZTgDHp9ehrNQAayW9xA7OZAiEA2v/JHkzuVYUn\nhy2L/dPvjoFHUZL9bqknlO+UmmgtSoA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd7eFtIitst+dWYrxfH1NJdjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2YwOTVjNC1iZmU4LTQ5YjctYWY2Yy1lNGZkODFiNzU4ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2ISGYbSdNHs9h9z4W8jO04G2o/qtuUanoDgURIgsUh5FB\nDHimWQGQyDCtU2CYGz9iEueCYvj5Zt6uDp5avMjuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjB57k3JAbDBAjh+1aLy5C+bs\nKJEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPCsbDUdEdPq5uQdWrYSULKMesncsOFGHKXttPVsfSI0AiAW9xntjklu\nbl/5C3EOX67f+Zftra2dbrdOAWBgnT0smA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQ43g0FkUd+YyvE6mOicVr69MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhmM2Q4NGYtYmY0OC00MTNkLTk5YWYtNmViNzU3NzNiMzJjMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGRkZjUyNDEtZmRjYy00NjVhLWFhM2MtYWY0NjU3ZjFl\nNTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEArExKEzN8fLxF3HNHPQ/tN+/\n1ESKMH7yvw6PSq2ppr4HFjeFfweMy/LUrQ3X9+BofEQ4yGSua+Ca8GJdI/ERuKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6FEPTZ02UZbXbda44JzZ6LmfCIQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAM9ObY2\nuJar3jZzeor5vpm10fgm3x1dSkmc6Yfx3X9jAiEAqTxkKK8Y2ccKnT1b6i2y5znH\nbGQxE6rB5rmL860Xc60=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc703", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `703` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAbzj5Li0EQqYauIBMs8C23eoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5ZGI1MjcyLTY0ZGEtNDViZC1iOWViLTBlMDAxY2IwMzQ0ODAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzMzOTEyYzYtOTY5\nOS00YmIzLTk2ODUtMGJhOTBlMzU4NGJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2M0ahYCIIbb2d7YhAD5sKpAzZ0MTaSa+ULd0/a50FmUJg3gltyFmn8l4kBpP\ncebTgnggZ61pgRE6i/cQstqlxKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlVj9nWZ2vLjEgbK2IB+cO5RlCxgwHwYDVR0j\nBBgwFoAUJMhf3VeoJkBVKykzbCdgUCTS4WAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA15hF73tR4tBnn+URVLuoL+loObO3sjTuNJPLVSZEJE4CIQCd3W0V3cQZ\nWLD4tG5kLQJFPV5bwvcYXyqQ/EAQfu+grw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASUakJT9G4z+FcNqIZtgB9KEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWRiNTI3Mi02NGRhLTQ1YmQtYjllYi0wZTAwMWNiMDM0NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARD0wu3zRVTu5Yguy+T/iSfuzvd36rjkl5DCBhtm7wtNWFx\nKRW/6QWcwSJ6V/0jl2D9L+zKnA3mNKQ8mKvsQlWLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJMhf3VeoJkBVKykzbCdgUCTS\n4WAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAInkotRlkkj8AB18ioG8hArGufE+Q4t/PaRhu2xZEVHPAiEAjFczHe1G\naXVUH51mOPZPKlQlRNGwlRxltB8ToWE0OsI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQRJji8LeQaHbknuU0J8C40jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzMzOTEyYzYtOTY5OS00YmIzLTk2ODUtMGJhOTBlMzU4NGJhMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTMzNzZlMjQtODAxZC00MzI3LTg4MGYtYWQ4YjE3YzU5\nMzVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG9yZRHvXy23GuwIA4Ix6P0cJ\nbrlQkN2pT2XVIahQvOrWV3jlDqIMRM7W7Je+TpZZQGFJq/IKUOSMdw0U17rbnKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlVj9nWZ2vLjEgbK2IB+cO5RlCxgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIFP6HrVV\njPhOn0FKs8bFlqAV/QfM4decW32jb24A5Ji2AiBEvmoDhLi2bC3QBXp2NNSgPMhJ\nB6On9sIgjdTYc4CPxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc704", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `704` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISARXOedsTZ1u1wYnaUOxhdqHIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiMzlkODczLTU5NjMtNGZiMy04Mzg5LWNmOWM5NmY3NTk2YzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdmM2IyYzctNzFl\nZC00MWRkLWIxNjQtOWU5YTkzMTc4NjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEv55m5ZVHo+ydL4T5VdqqG3ibzhYWlvP1lK5ds4ZSbooFglpID1YENCYqE2w\nJPudb1krjVMVCuJ/1GrB/IEHSqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFJoDrKnTkmHaK6gQuBsGXpC5iV0wHwYDVR0j\nBBgwFoAULbXIeTKFbBQzXww/FULBjsax3MQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAN/E3LV2R/HDFP4Rm6eFmeulGTfJHksrg2Ke9ZMuFd\nvwIgYkuHnWVx058rqScqrhZ7YTYDRe7HMDeRMv0Cxw/2mGc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcPkVjdAmHuW2LVFWyD316K0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjM5ZDg3My01OTYzLTRmYjMtODM4OS1jZjljOTZmNzU5NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmvcDK9tRxbKCLFCP5GA/MoVoltDKSk4hMqTk2dV5xvq6E\nRFfP2SIebk4fXNpVjpViswAvpLsT+X8WC5g+Hqimo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULbXIeTKFbBQzXww/FULBjsax\n3MQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgappZ/UUM9JP3u/YhYpI42p46l1BecuKBqTrJXaaOeWQCIDhO3/TX523v\nXSnas0ElpGKaAOfHW6uJ7DMnsHJe3i2n\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAePVKhyPpNUvTy4O8P7BcYLRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdmM2IyYzctNzFlZC00MWRkLWIxNjQtOWU5YTkzMTc4NjFmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWE1OThiYjYtZDdkZS00NTM3LWI5ZTItNWUxODZhNGE0\nOTk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEROe0FNWpt/XoR6ogizAmD/s7\nRKAHnHIF0z7NKqlwUxzh1GNBn6rBNT1GygpypzIuIsfEdoVKfi4XOhWtFkqEMKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFJoDrKnTkmHaK6gQuBsGXpC5iV0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCSIjov\ncILLwrCR8AwbWEmHJJYvzz6elQrBdyTbJXvtGgIhANBY/c/WIvcfjvC1PVDnIiip\n8SaxSIzIxdi74DJOHm8M\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc705", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `705` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAVcsSHYuV0x1lW8FJRep0jCnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZTFhY2M2LTkyNTAtNGYxMi05NTE0LTI1YjkxYTUyMmFjNTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzcwYmY4NzEtN2U2\nNC00NjBmLTliYzktODNjN2JhMGY4OTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfXLeA3/ORYRrGDN0BX/hVSvFm4Oy+yV6HBEWOToQ0KyUi2pvHlad/532IL5i\nY5PQymCEk7XVdHsk8cCLZlpOgaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6mmCJAkpbF8P7yLxdf1AiOzNLTswHwYDVR0j\nBBgwFoAURp9XT+S42o848JiDofZj0GflsTswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAqGThXWVvuCVBvxltRE58Mo7ghENS1ThLfzvq9jMw\nswQCIQDwN/Xs69/L7lKc6VZYMYlOT9JI9xg7cWfKj8DaR9lnsw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZaw/Uvj8yuf/C+xEanaZtOdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmUxYWNjNi05MjUwLTRmMTItOTUxNC0yNWI5MWE1MjJhYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR67ap1kjjpcAIrymEygCWRMVaYHya5xBRSfbSFETJzkGIj\nh3gsZ1Qd17oCvv1/NS4M5UfUnh90uzJfTlbsKOX7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURp9XT+S42o848JiDofZj0Gfl\nsTswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBf/LVYbpSbUDJA9omj1oa0tjlS7OQzTPXiEeukQoQPMCIGeOE/xg6gqt\nAl/OZ95XVymQMiguHliHzx1EW7pdBsy3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAR1v7VQYTXfloXoili8Z+SIiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzcwYmY4NzEtN2U2NC00NjBmLTliYzktODNjN2JhMGY4OTk1MB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTliMWUzOGItODZmYS00ZDRjLWE4NmEtYTZkNjRiN2Jh\nN2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwb/2ANRwfHRwP++8jPl/97+F\nPlqSdTy3DUYs9jqI1PX8bXmsfjktZ6ZBKWbW0/Rxut+eFc56AggtF8X0QpNN56N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6mmCJAkpbF8P7yLxdf1AiOzNLTswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCoUTJ9\nTfYbLCJqatvjSNMY7HrOYfDEshpz5zaGxaW4BQIgNDhYdqWm/D1rED31IzRYVRv8\nc6hongVkzKj9IRLqAhQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc706", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `706` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAcaBy8xn4Vrw3Nam8tX2wI7+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1MTU2MThlLTRhY2MtNGRkNS1hYTdhLTJmYTcxMTkzZjc3ZTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ1NjdjOGEtZjdm\nNS00ZDkzLWE5YWItMDRhMWVjOWY1ZWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5K9slJLopSAd5IeBdmTl6YQRfRrROTIC2jYPH5/SDFQqzfaJJJvga0fdVx8Y\nBucxNAcwvySuDr0C1iUU07sTkaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaI8/qWplaPTAosm7WgtgvfKswaIwHwYDVR0j\nBBgwFoAULjfUzraKwv+nbMNablKcGHS49ZQwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiB57kWQvnHQ3uABBd/65cvxa8Emx26tlLnfBpFgJYmhDwIhAJCF\nPvZT0FqHOluDSGb1NmT4vl7bX2xYK9CVa0XCINCr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV665dxTZN7/PmzRSO2hOzRUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTE1NjE4ZS00YWNjLTRkZDUtYWE3YS0yZmE3MTE5M2Y3N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/e8WNlkhBTKNF0mk7JZ5KJYYux+IJvgfgozHkCehIk7oG\nMJgXkBUGsxN1ikG7nAJDSG2+U/td7P+yUzeCGWX3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULjfUzraKwv+nbMNablKcGHS4\n9ZQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK9RJQ7rA20lRkkf0n+16JgW5e8uDtP8vB6SG9RfCplYAiBiljtdssAL\n9XZTh7M3YiCcAyMyq8e2hXgrwUJvo3XFTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAcQ8Kl6I+Z01eB2/F7AmEd6TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ1NjdjOGEtZjdmNS00ZDkzLWE5YWItMDRhMWVjOWY1ZWVmMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmY5MjVhNTItNWFlNC00MThkLTgxNjAtMjFiNTUyYWM3\nZWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEns0giZlrB+tMG3JjHf9CfFRO\nYlq7atVRuAl7nuLXMcHXcMIMD78tqZkwvgEIADy9A7AONrrB8h+ZtoJQsGdnOaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaI8/qWplaPTAosm7WgtgvfKswaIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCRKPEM\n20waVDeRLMWCfWieSmn7468A6m4iw3W+v9GQmQIhAJB9V3SoFPNMoEjeA+gUXxU5\nlhIsYDNIY38Td9QcttQ+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc707", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `707` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAf5ojyhSuApqlNxeDS1VMnH3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhNTRlMDNhLTBhMzUtNDNlMC1hNmRjLTc3MWExZjY3MmVhZDAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFhNmY5MzktOWU5\nYi00ZDNiLTk2MGEtM2RmY2FlZmUxYzYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3jNeTSYR36Kv+sH2K6VEX2lx1Aw+uoe9WPnxpt8zUgGwX5+1UR+Y7oTQVSG3\nTkhWeMuF1tOtUsf8V80N/kwLU6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhoKzJ5ogKMDuU1krDMVPkOnNKicwHwYDVR0j\nBBgwFoAUJtAJ5AOSlnMOeWuGAWsMiRPfP2MwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBR96xQO94NiksmZMOiO3rJIarjLTi8ni6q\n+1E0/4UrjgIgW9skJjrqAZQHcJV/kA9ks6h7VkG+J7saaRnj9vkcUnU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeTZ3gNFX4OzEBh96TwvisjVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTU0ZTAzYS0wYTM1LTQzZTAtYTZkYy03NzFhMWY2NzJlYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7tKGuIi+aScyTvtq/oGAiVRSg1FqlIK++wdiRmbioKE7e\nLKq2xbFkKS0fxLfBbh5Dy8miM1gHNgcg+88dy8axo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJtAJ5AOSlnMOeWuGAWsMiRPf\nP2MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOCisHew5eGumMrei1lkrfAF/xUsEa4aUBMB+g5OlAsBAiEAuMBafQrD\nls5BHJ2de5fs/jUJpHM9QBsUbhPOYlUb5UU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASMvBPEcHNuwM0HJQVHU7IIJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFhNmY5MzktOWU5Yi00ZDNiLTk2MGEtM2RmY2FlZmUxYzYwMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODVlNTI5ODgtNDIzZS00NjAyLTkwZWQtZWY2ODYyOGEy\nODdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGhDB7tHEdBF+aEy3Hs0bbb4c\n1DjKvhmBDy6rqQQNvSlm9Mrve9XI70UP+6AwmDG7UOlUF9hrtiNWNOkvyl4lYqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhoKzJ5ogKMDuU1krDMVPkOnNKicwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDwPsSu\ntW4HQ9qIVXC6ILfZ9YwlWvJl1YyzTTCg56TOuwIhALYFhNRMxjYFmhO7ReaCimva\n0zkYMPSgqahtUdRf9Wu1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc708", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `708` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXdE8fhYYjZrxQf28QYKku83MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzYWNjN2IxLTQ1OWQtNGIxMS05NTYxLTMyMjBlNTE0Nzg1NzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM3ZjEzZjgtY2Uw\nZC00NmFkLWI1NTItYWUyZjkzM2E3ZDZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm4IOP9acm93ocj9MG3W13hPPMpr/ZXXzXRwpDZjM7eX1kXPpdqiFwxkfK7CH\njK6KtRZ59utS7XV6OgoC/4y3Y6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZLkANcWLEZ5iaYWf+2UbnaapUl0wHwYDVR0j\nBBgwFoAUq9knsC8BFt1QTBOBZoIUMkHfr/swSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAx6iyzNvpK1uDZEoqM6f0kbEhf/LITOZk\nlaCDedhenlACIFjbzZyLChHCzbTA6IE+IRD1TxTNrTuZQ7cme/vzIMZ3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaUPoYVViKuoxr3FCLg7zUVIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2FjYzdiMS00NTlkLTRiMTEtOTU2MS0zMjIwZTUxNDc4NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGQsnL3UgSwKLbj4zV0qIGJnKCceGPhPDgZsmnaFQzZPMg\nG0g/sG2T2secj1MpzJhLTFQsCUX+o/STzTkEHIbNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq9knsC8BFt1QTBOBZoIUMkHf\nr/swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEWYlXNniMWFJJ4s2JzzZJFdM6aSs5H/vMfCvbNi8N4MCIEJmOkPmSRCK\nMKaVtrjMOaCUQNzuiW+I3Un+rReijEcV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAYkujcyNauq86aFg0ldaKQNaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM3ZjEzZjgtY2UwZC00NmFkLWI1NTItYWUyZjkzM2E3ZDZiMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNlZGY0OTYtZTljNy00NWRlLWI0ZjItZDFhOTJkOTBm\nMmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr5jaWL0fkdbPnDmbkGy96Zvs\nxOPbHaR8dX6l69aBzQhPSIMGwUxcCYUUGg8mT2MrfOZmCgTHHzeCOdcq0yFuhKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZLkANcWLEZ5iaYWf+2UbnaapUl0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCwLqWe\ntDp2C42BoNeTZ4w11+2IfRbvZMg9kYEdE43K4QIhAIwGo33wPaIGzm9HFzEyewdV\nDormdQNhBZYjQlDXj/+G\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc709", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `709` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAX7z77v5n0By4ZxcGbqOXuYJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZGMyNGNkLTZhODEtNDdjNy05M2UzLTg5ZDQzNmQxMTdmYTAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTgzMTY5YzYtZjY3\nMi00MWUxLTg4OTQtNjZmZDNhMTM1MTBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgjAmyXUmKITCWRyE/ckUR8IVNywxU5AYHZIcKa7zcjLgKfyopicMn+a6fwpn\nHQBBDWNDpfiS8ULA/YuV8CYPeKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD6DPkj1thTzSYy+AOu7Kw7KvYMswHwYDVR0j\nBBgwFoAUVeI/TC6Ygy2OfToe0XxIhbAg0JAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDcwbXlzPlhAh2ZsC6qBx/uKium\n2/RmRW15TgACSBXA6wIhALGgkgannef7EGd03CTzwef1tbH3zGkDblNucBKMmEFj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATSez+wh4rZS6u3yRV8EHIYxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmRjMjRjZC02YTgxLTQ3YzctOTNlMy04OWQ0MzZkMTE3ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDafFxAx+FolCaGXhC1EYAu4Dx/A2FiUB3dg5CnPUswuoI\nIZPfSjfSGo3gkz9ts5Xfo6RY1pSUgFgF1VtrXIb3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVeI/TC6Ygy2OfToe0XxIhbAg\n0JAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIXZmeb8+omGwcnoOoRJ6U29baPnS8grxTP9L733E+IACIHlo/kfxNAN5\nNGY/MBUMWyJzi70HgXhqZXZcMyKeNFmu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAehy0hE4iHrqdfABXjSNriYJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTgzMTY5YzYtZjY3Mi00MWUxLTg4OTQtNjZmZDNhMTM1MTBkMB4XDTI2\nMDExOTE3MjU0OVoXDTI3MDEyMTE3MjU0OVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmMyYzVkZGQtMGU2Yy00NDBlLWEyZjYtMzY2NTI4ZGUz\nZDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkSmqYACWEXVhmE2o4NQ8KUdy\nVsCHli/B84Mu11iXigyYxncPqV8qUX/TXMf2ZtmjjC8uKip2Y6ZDymCKWzMR/aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUD6DPkj1thTzSYy+AOu7Kw7KvYMswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDdkC53\nKYutXn1q8EaczyHEBBzaMY+2t5gLD9lwyUw5AwIgYMBJ+y/xptfyf27sRyAd4Vim\nrBFoFae7RXcEQhUSd74=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:50+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc710", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `710` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAScL/dgTjqiQ0c1dnjd9ynDfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZGU0NGU4LTU2NzktNDU4Yi1iMDM3LWNmOTcwZjYxNDMxYzAeFw0y\nNjAxMTkxNzI1NDlaFw0yNzAxMjExNzI1NDlaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ1MTE3YTYtNDgy\nMy00YTk3LTgwYWEtMDRlZmM4MDkxZTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt1Z2X8roSx8PVfRDdg+l2XGfAFkni6BkjXyniVphPyF7IHdEjdODeWa996eI\nFbilUPySutAz89PK+x9jh6265aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy/bNKLos2O1b02DLvYe+BZxRvyYwHwYDVR0j\nBBgwFoAUvtXpd0o0IkgnvC9YytLvmz5l6QswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgeHHucw0B\n3iNhIo/aWhmeInyQdjJOkVE8Hx7DvoeNmY0CIQDOtmLzLW4Ra72LeUdDJolmbOAN\nZRx0WPMBLFtDrJfLUg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUGl+Mor5QN8+iyg1g3ZusN3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWRlNDRlOC01Njc5LTQ1OGItYjAzNy1jZjk3MGY2MTQzMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASp91I5rNYO2BWPv9FQaHJSIyoK57Xu6kMyvW+WEpomwQS6\nsTFyxm61Q0ZHxwnacXJjbLJdVui9Py31XX3SV0FWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvtXpd0o0IkgnvC9YytLvmz5l\n6QswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKz1RT3y7cKYtdHYXCW3k6tBpjpPicmS7FzC7UNP5BgfAiBAwZj3DBoG\nYpLRplZWAKK/DsukIQYcUTfygI1oQI4rYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISASwcOmi+15IS7bw61eoxQaLxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ1MTE3YTYtNDgyMy00YTk3LTgwYWEtMDRlZmM4MDkxZTExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWMyODI4M2ItMTdhZi00YjdjLTg1ODgtMWRhNzg4ZDdj\nOWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ2yljrFLtXnniTrpWapuaLDo\nFLyCnqusloiHEw/jLmox53jYblAzOlyngcPncdKrDdK5BbbGXelDBEDu2lrQTaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy/bNKLos2O1b02DLvYe+BZxRvyYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIA89uRV8\ndlMWW6eMSLFjG7BjOf+9EgR3Cj5wgnWN5NmfAiBOK9w7I01aTxxKzQ36iBnYh3us\nAuTzkzWfY7GAaIs47w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc711", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `711` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAcOBBPXNyDENSPx9pxD0WJplMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3M2RmNzE4LWFlZWQtNDZjNC04OWE2LTVmMTQwZmQ5ZDg4MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzU2NjZhNTctNDhi\nYi00Yzg3LWJjOWMtMzc3ODI0ODBjZDVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQQDyLQQabc4QoZUWCRs6dwo3vC2stSoqjVDy6JSuiIgUSzMUDgREgHrjN1v0\nhhA5B0qqX2hFAIlysZXpIaCTB6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURQoARJI4AKdOs/DSUoECNri9D+8wHwYDVR0j\nBBgwFoAUCvkQ6/JRB+PqoE+RDEyfNWGT5VwwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgNZTCbYdU\nDRUTXmgkhkDO9qduWt/9PJ0Beu6rXIqD/VECIFI/8FPUj2BJwJJb3yQwhQEVmrXw\nbENWbD5Lh7roO62J\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb7ZR7NPgup3ifegE8sOS2vQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzNkZjcxOC1hZWVkLTQ2YzQtODlhNi01ZjE0MGZkOWQ4ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGr8Us9JubaA/z+L04SCDJrEFYBZ0QSJ/dQs5/h0xISgj5\nDYEdKo7nfNLnNjbId2TkZIpngmf+bNqPBs7bt+2Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCvkQ6/JRB+PqoE+RDEyfNWGT\n5VwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALWQhLgMt9UVE0iKfdsdFZe9OhjlZHjoVb9wej3VTeqWAiEA8twXgZH7\n4CQkjmVAnmgS33pbghndfius67XcjKZFNek=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfhAgeq4KjBP0BdlAErhp72rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzU2NjZhNTctNDhiYi00Yzg3LWJjOWMtMzc3ODI0ODBjZDVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjE4NDY1ZTYtMWNlYy00OGVkLThiZDEtYzMzZTNiMmFh\nMTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqKyXts7UVTZjQe31wgJ6J0Kn\nxN2mbib0L9Lu5IvG3VWArG8vZ+GzDVsMvQ1a+ObFvnA1bUS2G4ZX0hDZtwho2KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURQoARJI4AKdOs/DSUoECNri9D+8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICdRRNpP\nWvE4+bda7GNw0KYJweKQn2Ix3xjwd05ObsRPAiAM+Il78Oz2+s1c1/6WjEGggAhG\nSb9IFfXSfFcVocO5qA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc712", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `712` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAZ1MznrVWR2d6IGqK0SpqvqJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNWYwYmZkLTAwN2UtNDIxZC1hMWYzLWE0Njk5OGEyMmQ1YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk2MzM1NGYtM2Q4\nOS00ZWE0LWJiZjYtMDU4ZDkxODlmOGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhTIBLiLcsLdskcSDuatZD1RAVbbjQHBNoewfHttbxKlQtF8pwzE1G52fF7Zh\nuWGZkURdJqvEe1d3jpLErVoukKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxA3hJQvfsQHWvI9ImXB/zhYPIzUwHwYDVR0j\nBBgwFoAUm5kFunZspwwydNONfz1t27NJckwwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBogWwa+\nN8mhbdqXswpObAamJrWH8apSCWCBpBPrhEE8AiEArLijwUj3tsoJp8iTS39dqkUE\n5t0dSHeV7TrpSpU3ej0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfvsUz7OqJlr+m3tYJaC5zgZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzVmMGJmZC0wMDdlLTQyMWQtYTFmMy1hNDY5OThhMjJkNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwsSZDVHBtiyRjXF+SAjflAHNlIJBw/xL5qknoezNIa+Ly\n+dWlxAtpvkvSLWVd8MoJ7dvb/Vnpe/+PexxNdNGYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm5kFunZspwwydNONfz1t27NJ\nckwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF5Des1nbzkxjiUMrhqik8e9mYSXoi5x7KEfaqlmAP2sCIQDHlP5gs6qE\nLivKYVkiaAiUyVFVocnaG1NJ8E5W5Hfp+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASynn4rFXPRUp4EwA0zqhrBSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk2MzM1NGYtM2Q4OS00ZWE0LWJiZjYtMDU4ZDkxODlmOGIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTVkNTNhYjYtNjdhMC00NjU3LTkyMDYtNDExNzQ4Njhj\nNDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOAJGGaOm0sWE+hJipn1CPO+H\nFnD/jv2L6AWqza8fpGw95qAwbScE3nXpHLhOYwhDROwt0lPDRq+vYCgherFDIaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxA3hJQvfsQHWvI9ImXB/zhYPIzUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDTdBYK\nYPd5DscX3Gfa8toc7I7UA5BMk/PbbbtM0rgUKAIgSzlETXb47uj+K5/JYBxTbhX7\n0bSIT6Yp22AnS1ZvpO0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc713", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `713` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAWpEV82JPSOFGce08vFvGFEfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MjRhNTM2LWQyNDctNDQ3ZC05MDU0LTEyNjcwZTA2MmZmNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU1M2M5YjUtNmQx\nNS00N2NhLWEwM2QtZDIxOTJlYzIwNWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExyZz5Lfk5yWg12paYd3vKkpuutIHOka7/Kp2x2aC4eXcVZ2hjFoNvcUqwRPB\nvZ0/IRrFbSBaupJdjn36OQmQTqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdbgVhjo+qnPCAnaflXzZ08I1hrowHwYDVR0j\nBBgwFoAUfUH1e9jjK1/IJu+eZKwDGZidmoYwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIGlbFjRuHgFQl6S+ZDWpCYpJw1zT9JrCKXSmx5kK4QckAiEApSfuXWpt\nrvN31y2nKIuezABXneZ3mtBNbVUm3dLdS14=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQe8GrOoeJUWxOWJ6nZl/nrLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDI0YTUzNi1kMjQ3LTQ0N2QtOTA1NC0xMjY3MGUwNjJmZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUy54Z01hutHhYAFjFa0zjYPVChXCMXQryOe8zMylyV9Pz\nL+ZLEnCBhje/GYwanudsgAhbul7RJOdDw7pNn+o7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfUH1e9jjK1/IJu+eZKwDGZid\nmoYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ41w316R7ZVawBAh4AKgCMVGBOa+2jJcbpehFYzRHCYCIQCZw+R5p9Nn\ne9iyWqE2dhE5DJugQibCQIrdMrfPPK5FwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWQOG2+amCJ5pYzCZzwl9MQ4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU1M2M5YjUtNmQxNS00N2NhLWEwM2QtZDIxOTJlYzIwNWYyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWZiYWJiYmItYzJhZC00MDM1LWJkMDktMGM5ZDFlNmRl\nM2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzvwz13DEp9W3h1e05esWDmBH\naE/ohYhZlBJ8UTb2aPRI7csraA9Kkv4/KqDXfwc3xZRj4xq65q3bUzLaJun9u6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdbgVhjo+qnPCAnaflXzZ08I1hrowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIEMpJtxw\nUgYRteKUpBDCy4hx3crvpBbyMulDELiba45lAiEA9Gr0q4sYwLRbI2hKykzUFUMU\n34gIPP02EwDIRaBvZvI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc714", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `714` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAVNZns/CvT/iwg1JWZlk8LT0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0MDJlNDdiLTEyMmYtNDE2ZS05ZDk3LTIwNzYxMGViZmQwYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZhOGQxZjctYTgy\nMS00ZWMzLTgzZWItMTQ3N2UxN2QyMjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE1YxwfUaCY0YNjEpnFfMRGzL03ZyEg7gk+nA21Mw6R7bMayAJLYO4CN+JG3P\noy1TT+PcHFtxNdPIszMNMEKGwKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGtyZ5jiIDPpPHdYSsMDlIBueWF4wHwYDVR0j\nBBgwFoAUKc/mLVw3t5GDY6N755sgJ1gIg20wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCID0BSrzxkO/g6C0ylr6ZdKQZe9/mwSje2EItGlPTugSOAiEA+B9219sl\nBHby9GGD4h0cdcwUY5lMdHm3OQ5+Tmyqhbk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYMkPpDtxxvFGEN9QiG8v/ooMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDAyZTQ3Yi0xMjJmLTQxNmUtOWQ5Ny0yMDc2MTBlYmZkMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7wE0feyCjCEBPfWYdKxTbMj8C/4VZ7HNMVZyHdodbA2ty\na7Y6CzhL+pii0zVxjQBkkn7CNPXVCNefkJnRUPMJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKc/mLVw3t5GDY6N755sgJ1gI\ng20wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLRZdmGlq9IzEq04+GLEFeimhj8EPRswNTJjKrglNMRgCIAek1V30Ppnj\npFaWK1IAgMplw8SXPNoKDXvej5lZrSa+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAUZcsx5EL/aiMpoNC8SVmRqZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZhOGQxZjctYTgyMS00ZWMzLTgzZWItMTQ3N2UxN2QyMjdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2U1MTgyOTItYzRhNy00YjUxLWI2ZjctNTQ2MjU5YjMw\nMjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2/Dqb3FzUmYBpa5SmppXjufW\nDSuwZbH5RD3egvr+vYabL8EC0OJy1lBjsnZfDnchb4zB+tSgSBHHnkrmMaCFYqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGtyZ5jiIDPpPHdYSsMDlIBueWF4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCID/PmuZX\nwshIKns5fMNLYjIfG+pq1b1mSCvkSdtpHudDAiAa9UZqP67j+zi2kD0f+yen3Tvn\nOxIgBNXxaxfehgUUvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc715", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `715` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAWkfC66KsSXTGhZpsEvDqoQuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyOGNkMTYwLTcwOGEtNDI5Yi04N2UwLTc4NjI1ODQxNjQ3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NhYTBmZDktODZl\nNC00NWU3LTg5NGQtYzAyZWYzNmVjOWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvtHa3TAGfDxyJCmimnMPO8BWR/ikPesb0wvvc2Z5WPFzxRPG9PzFQIMjaR8f\nBLF6cvpvfIaZbOaSsNtygockVKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz6g4Iai9z64+nufpTyL0jD48aGAwHwYDVR0j\nBBgwFoAUVsLiH5I898E5MsLAFYM2GeDSQ/QwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIHxZXW23UkBxkM3lUq6Bf+gX8RZmqG2sFir9C4XKKMULAiBGOV5i4jpwQJV01Hes\nRJHRejMULwSg+d4d+kZ+8dZCvQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZvmxTII/0mg42G9mz4dh8mZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjhjZDE2MC03MDhhLTQyOWItODdlMC03ODYyNTg0MTY0N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgRP/gYkzM5i3Pnu0uQX7c9Agn1qttuYNpxa22eOJonXMm\nqsAInJPyRncNVCqrhYhxx28aAY0oDpsWuWzXewx8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVsLiH5I898E5MsLAFYM2GeDS\nQ/QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFuBnQQLO7kJue6jswXBY0gObuwEJ3nvO7Kud0Id83fQCICmyOkHk9kyj\nmJ91CiHeZg2/NaDj92P/1PEXYLFNKG+e\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAeNBSbijcTTfG25KOUNnGyM6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NhYTBmZDktODZlNC00NWU3LTg5NGQtYzAyZWYzNmVjOWM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTllYWQ3MGYtZWFkMS00NjE0LWJkMjctZjAxYmZjNDAy\nZTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM8HpA3m+WI62gTIGW8hT1vDZ\n5cKupbQYkzjhgz+5U7Zg0j5BPtC59DU6hRL+fm4RpL+u/X3NWfHiy8EI1qUmjqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUz6g4Iai9z64+nufpTyL0jD48aGAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAcIZanY\ntev5AMtbRoq2vZMyRZcQe2lsQWKzU6Wc2UbDAiAAsvfqstmYnAQqgbeZWtMmGKyz\n/fe5grJmmXOrUtYKCA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc716", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `716` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAWzpDaQhzHL+AXk7ndIJK+AWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4MzdhMDA0LThhMDYtNDkwMC05NjVhLWQ5OGRkZThjYWFhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdmNGY3ZjItNTdh\nZS00ZDNlLTkxMjAtYTY4MTkzYWI5MzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG/mj6MzYRv4Wmo9SDBAW9RDRc36xsl/j35vZ52PwdligpaQtPeTk0gNYPHxI\ngY9vs6LRv8ZSP6h3KUYzLglbmaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULbTwQm79Uk7yVuTkVQClHSxUcXEwHwYDVR0j\nBBgwFoAUWrALlLuASfnIkZ5oRV1XjMFUwIUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCHyDyVpmC8gue6QPU3HDPzMPxt4UhTEpdYOl9wN4HTpYCIQDy\niD1XtFLYnoPMae1Lxza48053fHLsYVqcUlt2vEPsZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbWNmruuo0tqP4BlRzcyFdnAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODM3YTAwNC04YTA2LTQ5MDAtOTY1YS1kOThkZGU4Y2FhYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXoQ8hWsMwtaMFqhu6d98AVRwubEdNrYvUMfkZHIgcsBjK\nw9Qo20eFMYlNgA7+7my3QyBmPb/2OxXb+MC1gwm5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWrALlLuASfnIkZ5oRV1XjMFU\nwIUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTs1cN0VgJYCUCrGybC7oKpXStyodOrq4ecJiCRcRJ3ICIQCAkHQ6pIu1\nbd5hqL5J94SH14opiL8VgLVlbkrr7Erwxg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATZUAWX54PzCdqu8wTaBVqt1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdmNGY3ZjItNTdhZS00ZDNlLTkxMjAtYTY4MTkzYWI5MzY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjhmYTIyYjEtYWZlOS00Mzc4LWJkYmYtOWQ3NTgzY2Nj\nZWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYwuzJyFuq5JwLKWQ6KiXNchx\n4rahT7dd7NWhZ1nofQ9CjeV4U/yQZCvb83hgX9ISr3UEsJg5pBesJCVMnCdyAqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULbTwQm79Uk7yVuTkVQClHSxUcXEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCJfkFF\nKuWI/I8tZpOy+6Pxkf2qOSB2vqy2uUJ5AlMoswIgcxEOz5XR30HnO8dlzlkNH5jk\nUMVKFU0/IEqkqqYdqm0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc717", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `717` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAY11tslRAHDNvrDIWBX50LXlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwZDEzYzdjLTdkNTItNGVkZC05MDFlLTk4MDMwMGUyMmY1MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZmNDk5ZWEtMWE5\nYS00NzMyLThjODMtMDQzMTEzMWM1NGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET/Gjyjp+cmehD+w/KDw3JxZHHG449Nhc71A1GJRC5hKfNdaXB1EFHrf81kV4\nWC1c3ScCMx1neUAeJzjkzhaL0qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeK5GUlR5GQZNv6eNEHFlthmOfiQwHwYDVR0j\nBBgwFoAU/7SecfhKWg9VbP38h5s7YtM34y8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCICGiFfa1MI46d3Qyy4YcUEW1Wuavm6VlDopga2Hm8yMFAiB0\nZU4Lw/z0hzPdM+Z2g1UhkHXWPiQ7GjoNYo9JxFiRLg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASkFLgxR37HSYN//OyLa4YqqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGQxM2M3Yy03ZDUyLTRlZGQtOTAxZS05ODAzMDBlMjJmNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQZcoWC7B7tV+EdWpfptAhQcqp5GUQJ4VnQKPFPppoYyCl\nxyhJTNzOsUHMK2xTnkuSplPCtBnc4bjWgp29kSgyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/7SecfhKWg9VbP38h5s7YtM3\n4y8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANFvrGWQ8fYCuEGdulHuAe2mlimCEkrr50cJuLgP+u7AAiB8XzBaPzJA\n9/v1T8l9OoJLSm88OjqrR+PIddYRWwOdVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAbJyEPVklN0w7h5tETEi5bfHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZmNDk5ZWEtMWE5YS00NzMyLThjODMtMDQzMTEzMWM1NGY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjYwNDQ2OWUtNWExZC00ZTM5LWIzMWItYzRmZjBiODkw\nOTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECeAe2JipdSA8aU5XGAopmwgm\nuHdT9rYd3eswWUruZt4V3KL9ztPwkFTSUqmqw8eDPp/nLt7m0DNk3CW6f8J/UqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeK5GUlR5GQZNv6eNEHFlthmOfiQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQC01WlM\naMHjZh7o0bq5RHs0DaxgD0wdH1r6+022sBaIfAIhAJplb4FUYW9rvwXDE7WV/QTZ\nEi1CkUfGh+c8rzXfZB6r\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc718", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `718` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASRduyPw8aS5JB6x1X6d6miGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyOGExMGM2LTRkMmUtNGIxZi1hNWQ1LTUyZmY1MzhjYjBmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JhNDM1N2EtYTJm\nNy00OWFiLWEyN2UtNDM0NzA4ZWE0YWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa311ttA/E3pqRAlVozREFB4TGJQKsBGv5P+YUSL3pRHXOWFwlRAIZIjQqa9m\nB37y68uFMnnIZjxB07urYspORqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ryBqOvQCnFWvzmLSSh7DvY+xfowHwYDVR0j\nBBgwFoAUWaAlKCk0HELA5xezTww9StVpgaEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDB91Y4mL1E\n0yy59dNtERlBe2/4vykyyIMHZXRWPLSpMgIgFWQYjYiOkn+fFdvUD5kAuF55I2dT\nq8zCRBP/acgj/cI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbSUU9RygjPojZQiYZodh4jnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjhhMTBjNi00ZDJlLTRiMWYtYTVkNS01MmZmNTM4Y2IwZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkNZi1kZAHgkXU+8i6BnZouc28tIrmY4wY1bGdWpzCZyot\nK264Fqv20paEaWUc0vHgaBtdAzCgW3RDxhAgDQh8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWaAlKCk0HELA5xezTww9StVp\ngaEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKGd0ApGJxbn+bIkxl+hoO45NzHkTQrI5lLOEwMtvyVrAiEAhrr5iADa\nYxiGo+MeUgxTpKoZRcRMIz3La4L9IORumzs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISASsy+254OAHKRMoh14/e63B9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JhNDM1N2EtYTJmNy00OWFiLWEyN2UtNDM0NzA4ZWE0YWRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjhkY2RkOWEtZTQxNi00Yjk1LTk1YmItYmVhOTdjNGE2\nYWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE13qFdChHAoAknNgV4hWpLwB/\nhAyuCXgHAIV8h90nfbBR5xTVdeIVSjibNOkCkE+cYbyifA1Y+vinLXDWg5NG96N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4ryBqOvQCnFWvzmLSSh7DvY+xfowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHAVcnjJ\ncA8fsHKtTzRWH/ki2nJUuFtVkZoEPe2M+iMDAiA7LO86jInibNVc5fM1pwtEVOp0\n/rGfDW2be/4JPZRO9g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc719", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `719` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAfJj98XizmNFULAFwbtYgM5FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxZWQ3NTZkLTgyZTgtNDNiYy05ZWE1LTdiYzdjODI1MDFmNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYyY2YyNGEtYWJi\nMS00YzM0LThlM2UtNjA4NzEwMThmNjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtZ5Curf+lgX9OCaANqLE8z3zUhExWVYi9pttLjLORbybrESS7jWgpZ3baLkG\n83E7W4nvv0cFJRND/tCzxsq1IaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxBfc39ObPArCeYHX3nWaWJZ8G9MwHwYDVR0j\nBBgwFoAUn58q/xirEwrMzcByq5XEep/1vSowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgSrQlztSBKjXt6FW565Q/oWfOqrQGh7u57SznctaTQOkCIFR+CV/wsO3g\nt83yPRh9jooGGpveqwAtUE28ZF/i8Ela\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUb5N53MyxEoqYewzsYH2b2JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWVkNzU2ZC04MmU4LTQzYmMtOWVhNS03YmM3YzgyNTAxZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRV745ulwe+sL7EyB+RNWaGxXw9OdyQ6FsyPjrujfkMtZi\n/xUvddKqcB4XF14b8HISXbGjEAoD5E6ohlEX/ki/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn58q/xirEwrMzcByq5XEep/1\nvSowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfcgz6Z7S6IUzk6H+xYy4rKvPPDVF95uHMWitxPss/1ECIBAi1ffyhzh8\nqviV7OcfUbTJBg8jP+sITZ4JfJiXsjam\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAc0TEkgc4JMX8qVOXxKGRvV/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYyY2YyNGEtYWJiMS00YzM0LThlM2UtNjA4NzEwMThmNjE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZThkNzVlNzItNjM5My00YmY2LTgwZjMtM2U4ZDI4ZWVl\nNmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENtmlan0kSij7RmLL5Lfq8aSO\nv5b0VEgnb8VFbBk/ZE4xyp8ObZI859yaBKJd0xyg5r5Kh9uDNz2nQuP/J+I7d6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxBfc39ObPArCeYHX3nWaWJZ8G9MwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDmYm47\nvZq2RERqwyceJ6CDRm7+npM6eJmipBIj7FK3CgIgWoyFqhPTNDZ1CJBT/bN4bEmG\nN983Gghwss8OSnfDC2o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc720", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `720` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAcU/K6bRmmOnj4BoiS+Tn664MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjMGQ0ZGU0LTA4MzEtNGU1ZC04NjIxLTNkODVjN2MzMzc0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JmMTA3OTctZTU1\nZS00ZjlhLTgwZTAtYjkyZDZkMjJhYWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4ZWWBLNNJ1WEwOvBa8wlXAesJuSEalOevXa1V+eeacsQc/xO+LPMwpfrHB4L\nBELveE2o97MB+T8fwP/Mhl0wU6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0PzHt3jzzI8jTrewnjR1bbiylb0wHwYDVR0j\nBBgwFoAU7rWDaeOGZYDzfTfyNbYymMiOnl4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgSD56Ht8I7lLsUUOZe4MQB5agxR9NW+5BSq0Wwb7nYRsCIQD7u5jrCUTk\nTTqvxRJn+fvnfW8keqRa0+iAFFy4Xco17Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfd4Cegsa1jGs6Wf9JUnNAmNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzBkNGRlNC0wODMxLTRlNWQtODYyMS0zZDg1YzdjMzM3NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ13j3KP/ewP6Iie7Z49EDu3rgM8eABu5k9L+hyP2B8eJHL\nuGMWfUXYrgFAGAonW7SohqrS+G0a8wtVFsoOIuR2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7rWDaeOGZYDzfTfyNbYymMiO\nnl4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMG6yTWtxBgE1KOuyDjzrFdVpsPjklCtGvVaNB23aVduAiEA1qhT76z+\nXo9orRHv07ZIeAvx1OXfzsfqEuL1fULCKQw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAe1xQKKr0fR+E1/k7J64x9y3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JmMTA3OTctZTU1ZS00ZjlhLTgwZTAtYjkyZDZkMjJhYWM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZjOGU5ZDgtZTdhNi00NzY4LWI5N2UtZjEzNjk0MDMy\nM2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEELr5kNLvx+xgJeKZJ+ObKLq7\nYv2kHIAjDwb7GGKaxglEULIFgYQymlRInfv8WmBG5cykJlS2Izfo29UzkS7Ra6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0PzHt3jzzI8jTrewnjR1bbiylb0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIC9msU5i\nykLK9b2Td9NesuSmXycKTZzAage7Cxst208qAiASIwq5zvRlaV5pirtrKWHf1GWV\nrFsYSjq4qSj4f7pgEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc721", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `721` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAaS2MprnMagF0kMLdv2tRo+ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjYTZiM2E0LTM2ZWUtNDhlMy1iNDk0LTkyMmM4ZTU4YjJhOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTVmNTA2NDQtMzUx\nNS00M2E1LWJjZDMtMmIyOTUxZGMxZjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+m/jpwVTIcytVI87X0bHnqoL48A7C7v6YNS3HNv1ALvgw9u6OGanXguOuRkJ\nQqYGw3cTtBMAGXTd3rmbJnNSw6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeVPRodbOi6BbCDkmPtJy3bVK7IEwHwYDVR0j\nBBgwFoAU0hxY2fYYwPKLZS4GfjU2Go1Q7RswOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCICpBLHcBc90D7dxn8odEmYrIfudulsfGUiJQ2PJUtPvsAiBvRrwsWC/O\nBUssb0v0I+FtTaUttI80HEI4pKHJwLGTMg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa6JbwEBkt4b1RPNG5ih6eEZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2E2YjNhNC0zNmVlLTQ4ZTMtYjQ5NC05MjJjOGU1OGIyYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASj9zxsR9PyxMZhFy+tBjTHnkXE5RYdxUC8N+n/m/6VV+pR\n04NupYiqPC0HM8oQcnvBdv6PjzL2n6NOvwYEmAsdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0hxY2fYYwPKLZS4GfjU2Go1Q\n7RswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN8w7HDchq4AbDRrPtlee+NeZRBdGeZHrJjFDm88UxV8AiEAhvEV0oz9\nk6gxy5U88Qml3rgA2Mr4FXckqHZhUN4LVUs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAewJSJsPp5+e5Y21ZscYeUncMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTVmNTA2NDQtMzUxNS00M2E1LWJjZDMtMmIyOTUxZGMxZjNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDgzOWJmODgtNmI0Zi00NWUzLWE4OTktMzI2M2NjMjhm\nYWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC5DDInsys4zxfBvXxJhug2GT\njiqtCxOcbvOIGAB3dl4xOnG5WZklGfH4AVAOjz8GNjQuW8ZDuDYTF0kouR4bPaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeVPRodbOi6BbCDkmPtJy3bVK7IEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBgNq9oo\noFrMnzAfs+hZ83nUOWXinMY7pW6ntmVpb358AiEAy0EwreuYff9g2QplAr4xRF8e\n//n2ydotuG2GNuMLMGw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc722", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `722` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAUjMbRsZ7agAFkLw8y0dA6T6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwY2I1OTU3LWM1NTEtNGY4NS1hNTdhLTlmMzdiOTM5MmM2YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDMwMDg1NjItMDVm\nMy00NDBhLWEzZGYtYmZmYmNiNWNmNWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUMTr4wUe0lIZ6JEmX4qOpfLxhqDmrfaYttHllY2JxjTss6ekhCAMqoGfpagg\n/SHg4qtOnopiMASD2ANdF6GYnqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXK+HqHJ2cHStbtA3zwc6Fzxc0NYwHwYDVR0j\nBBgwFoAUlQ9Bfnb0zYmT4ibkSMJXnJ8RlbwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEJhP9XtZwN7NBKYOdgrc0ta7zmUYGENgwfIWspa\nCNiQAiBf9HGrFP/5cHSTUHCrGMX9cSCBoIQjCxNaO7gKpHpOfA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS8wFnQJkhqAM9N1u5OuAZH+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGNiNTk1Ny1jNTUxLTRmODUtYTU3YS05ZjM3YjkzOTJjNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3g5oEtabKY5ZsgSBhSgMG3U2Cxcqn9iVxP/Wr9Wo/Oh41\ntxUv+DaKNzUnmaSh96EgC46LtBZ1Y45X/1g5TNwoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlQ9Bfnb0zYmT4ibkSMJXnJ8R\nlbwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPQQSkAKx4G/zuQB104NmtxuWCSvdyvLaAmu0krKZyDDAiA+/v3p0fJE\n4wGjAKtFGxQpqdh+pkAbuiDUNZaWngZEyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAWOrU3bs2mLARDKackAT5IfFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDMwMDg1NjItMDVmMy00NDBhLWEzZGYtYmZmYmNiNWNmNWY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmNhNzNkMmYtMWM4Zi00N2U3LTkxYWYtZGE1NmVmNjI2\nNTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP/jIFD+EPMssTALLGOtwsXu5\nFdmk61CvdcJmgOFzRjtZ+cyi5Z1vfLEgCea1VEosN29/ySBGOBPR7ZmI1usuJ6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXK+HqHJ2cHStbtA3zwc6Fzxc0NYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCFI8LN\nrkaCtB2HPcQYszzoUCStk7+VuNGvZUTji30LnAIhAOpqrarFgugx8lBeZlemtIps\nnUHRDqTnPLGJCnZRKZFM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc723", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `723` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQruFWasNdE07LkmSgAmSWhjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMTJlYWMwLWQwODctNDczZC04ZWIyLWVkODg2NGNjOTI3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI1ODZkNTAtYmU3\nMi00ZDRjLWIwNmUtOGY2Zjc5NTUzOTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETT8dnv+OHZhKI1QcC2Z35tk8aQ3BqQ1fH4PCVHAYTH7qXBNUO3GUoak8qwVT\nBR/eIx5/yglRp7s098hhYeDO/aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF4QFfQWbZclR5B1zDS/IdMc4uoUwHwYDVR0j\nBBgwFoAU/JRj8jqgRvRuL6fbgf+6BI02s1gwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHPrNBuFWhbiQtgofW996DUGmfJVJOS9n9Sem40G\nYI20AiEA1/b3vmrHXj+rdxF7BboFqhcDc1vlfAV0pFfvxhR5wIQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbRhuVF8bAgSnCd0rQ1M5wz0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTEyZWFjMC1kMDg3LTQ3M2QtOGViMi1lZDg4NjRjYzkyNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2v2J9nPj9/O5/5ImE3B9huPVVjzlrmGleaOh43EJvU9YA\n9jB92t4jFEYLLF28Yk3icTLjvLU6vjXx4O/MLf9Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/JRj8jqgRvRuL6fbgf+6BI02\ns1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALqoEkTCATxDtbZWXGyFxk1Og3/pc22YwcCsmfaZRvmKAiBxIOq6/OAl\nf7FB7hoFikiXYBZCjyYnpp51SRQbRWYjvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAf8STze0DNkW5xEDh/OOsNLOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI1ODZkNTAtYmU3Mi00ZDRjLWIwNmUtOGY2Zjc5NTUzOTllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFkMzAwZWMtMzllNy00N2UzLWI4ZmMtYzc3MWZjNjIz\nYmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4N8QPvOtv2Pl2h853k6BpQuP\nId9W04zajGM8ud24lThNKygxSnDS7HDVi+3qP9p2lzQqmoQZdRRoY79tH3y5aaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUF4QFfQWbZclR5B1zDS/IdMc4uoUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCy4LZl\n/Za38cf4My7TDYyM40VMB3BRM61Dj9CjHISGEwIgV/5jMruS3lSzF5wiCOvprDdr\nj99CkN8bEeyVY07fKWU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc724", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `724` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUb8poYcRbcztTH2fZFhAro0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiOGU0MDA3LTViMDktNGI2Ni1iM2JmLWJhNmM5NTFlMWI5NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODc2NTM5NjMtNzAw\nMC00ZTU3LTkzMDEtMzc3NWU2MWZiOGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfkzLn+PagpGM4kH/xTYAv01YfiNrBzAe7QlKjp2YK8/YhVJ2XD3L7dHVPT2t\nLCXqW5a3x+kRx101k+0t48dVqaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsxBDWUbhRiHN5TyZb3n07xNBfmAwHwYDVR0j\nBBgwFoAUnuyhIoTI1FarFLn2G9qyQZz+rm4wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIB3H1ZZDIDnYf7a9HoreUGrSlVjFnJJulUHO9vAQ09FAAiEA\n0BN4smXy0kfhuxMQff8Ebiwfju9fymt2Fp8VWXu95Fk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd0PE0rWJLyTyphogJJZYmWBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjhlNDAwNy01YjA5LTRiNjYtYjNiZi1iYTZjOTUxZTFiOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRfVFeCjSzj3tjTpWD0GE/pFKjf31bE4bxiJk3o5qLv1Hl\njMDt255GAxWULIwWzhfU2H5EBaH0YsB4KvvgQWkQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnuyhIoTI1FarFLn2G9qyQZz+\nrm4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIfFgehomXUcFXgKiUxLxcLJ6RVSz/QJx4Pt/04w31zRAiEAvB92w9DS\nd3x+dLorBmEh6/rnKS+8yuAzvrN2DMrPOVI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAYLnjNZjdu+xzAzEkW7pkuNdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODc2NTM5NjMtNzAwMC00ZTU3LTkzMDEtMzc3NWU2MWZiOGNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzI4NGJmNmYtMTA3Mi00MjNlLWJlY2QtNzBhZDFlMzVk\nMTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuLmhEBQGnZI3lmrTKrPYz2qY\n1LEVV/kygyhP7OU3vovlq8n/bcAM0ZB6lNkd/p1pjbGiUWWHl9AB0OGc/peceKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsxBDWUbhRiHN5TyZb3n07xNBfmAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDInoak\nnURx2pkNNyuLJXwLhg65B30Fykg0EtObeHvb4AIhAMxo280mHZyN5CaSnmvQjzCH\nm5sAD4w9v27iuzJhecW/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc725", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `725` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAeqSVrsCpR7J5WRcAy+DiaubMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMDdlNWQxLWEyMjctNDNmZS04MjhmLTZiODI1NTAxYjBkNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRiZTVhNmYtZDkw\nNS00ODQyLWJhODktNWMyZWE2YTNhZGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfMYRb1NMAx55pKR+K7zOB032Fxyz2vT6yMRKaR+u8gujr6ef65OJYCAwMZV7\nEC+r040aXl2qGuEph7UiOpeewaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC6+pScJTZXU4qJca4SIy4jLhV88wHwYDVR0j\nBBgwFoAU3+6OLkh+S1Iy4O2SJJfmg8V31iQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDNQgLacfNg5Bvo1P99xN1/1ExBVDXa\n8BAbXyM+2qk5QwIhANKcM/0YLV+odupZor/xr9tVyy5Ww9+qZPqC1Xrc2NmX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQM4r6Ev+ZL0bDMHTdS3OgkoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjA3ZTVkMS1hMjI3LTQzZmUtODI4Zi02YjgyNTUwMWIwZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/qt9Q+VbNNL2bP+pC6/XHhgwcC07UvhsOyvgL8fNa2Pof\nJYQElDiO9yHJ0HSgLI8Wgi/GhQrLRDVHe17L1+fBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3+6OLkh+S1Iy4O2SJJfmg8V3\n1iQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOIcNF7pzlrLvOtoBVs61H/wQzUgriyHqp3Fa5JuXvb/AiEA637hu+MI\nyY2Pw2XHorS7iIbVOS97zeLQd0i7c5GvdIE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAeQ7wOxLJCBUf5RBhfVmbT6gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRiZTVhNmYtZDkwNS00ODQyLWJhODktNWMyZWE2YTNhZGRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTc0N2E3ZDgtMTc4OS00MDU0LThhMzQtNDAyMTM2MWJm\nNjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnTCfjFVvLa+N8eikSOi4DCm6\n7CjysDqCzPLnbJntyHVczwVQMdt3REMleyl4IOjhokiqy/GukQytsHJ2Gjb5EaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC6+pScJTZXU4qJca4SIy4jLhV88wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDyxG30D\n8koZzmjabqV9H+5HWmZxWGuoASUUOwwEjLj1AiEArRBYZbd4cwa29CqrINjp4+i+\njmRMo9odAc8uNpU4mt0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc726", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `726` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISATf9EaoGCfdCRsh4HuhXISVGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1YzhkMTVlLTVkYTMtNDQ0ZS04MjBlLTNiMzM2ZDNhY2Y2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA2MmExM2YtNTZl\nNi00NmNiLThmNTgtMTU2ZmFjNmE4ODgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM/Q6Q5SD8+JhydQGFEsgPGJ4S7ec00WovFJa0pkIzzmTXUeJ+Vy2nw8GoFzj\nGunQxcHz4aLS3NJV+pUzDRiaqqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPF+m9o1ehSw7ZQmLPw3afyRtoB4wHwYDVR0j\nBBgwFoAUHxmYcLR0EhNarVF29YkqxJbjKkgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIBhj0M++3BDObx00cp8kRH84ostpdizB\nM9SAxBxMi2A+AiAF4vJ1714gvB01HSUQ0plJQGrnTxndgaU251sRDoxAJQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUNPDLRErWNjUbvf/RiLxUvkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWM4ZDE1ZS01ZGEzLTQ0NGUtODIwZS0zYjMzNmQzYWNmNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSYSx7HIZCOWmSsZWWZe41594gMYXrvDKbfM6TA2LDXA/Y\n1QvpmOHfDEQciOZfgh8Nvd+npm7U1shgV6F3ijTvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHxmYcLR0EhNarVF29YkqxJbj\nKkgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOAubctsevp6fhZrBl2yBK+aE/coq0N7CJUD2L/MX1iwCIH7D1cw/grIo\noYEidaWgV4WhxCy0UDZdouBbiG7Z9bn6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAeRkzJxAQ3VGDJJ9BiingpkOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA2MmExM2YtNTZlNi00NmNiLThmNTgtMTU2ZmFjNmE4ODgzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2ZlYjBjYjctMTMxNi00MGIyLWE5ZGYtMmFmZjRlODYx\nYTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkVb4pfrTuZVzA064JqH4tisA\nzZEo69d0tjECPIk1asalppytzuGLEQL8Dke0StEoEgT3LcS144qZOkLlFMErKqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPF+m9o1ehSw7ZQmLPw3afyRtoB4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIC1/EvGV\ncitRb34RGUgs5Zw2yuRmcMIQPmmbAN90NK0FAiEA6poDAD5l6o/QxENCV6MeiVwY\nAW09ss8eamE+hU4R3OY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc727", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `727` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAck9Sy7yzuibvDUutLWGpPcYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3M2UxOGU1LWQ4ZDMtNDMzNS04OGNjLWIzMjFkNjVkZGEyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZlNjI5ZWUtNGQw\nMC00MDYwLWFjZmQtNGQxNjUzODgwYmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Byv2yKQsRjLEUb7tjEZGR8Rdxifs5s9+6OHK1jpbp4/PYkhOtQ7JV4j6Vp2\n04af1qEzzXnjwLT0iBhKCtawEaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDKMpiC+vSlZlma6v7k3b6+9RC0YwHwYDVR0j\nBBgwFoAU2LTRrL0JdCTdfYuppmgVwB81igQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHo24CsbRvya\nPaNU9NaeGhYQ2XKBE44V+gyjo1di2+4SAiEAgwrh4O4HmAi6qonwuuWOqg8uMeVc\n4ZI4Ae85F36S5Sw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY1qVwf05jShvB5oIJj0ggY1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzNlMThlNS1kOGQzLTQzMzUtODhjYy1iMzIxZDY1ZGRhMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEPZ44/KWHWiER+2nh1Fn4SSTDwdVLOV1zhaVI/luj0ooL\n4RDmD9j5GCBuYT6eGJsLADdyPK9db0dyrAHCi9Ufo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2LTRrL0JdCTdfYuppmgVwB81\nigQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKcbgPXw9h4FDuhn2gKgJlibdMe9lW65pNIFtEwkU9lfAiEAmSbDp9da\nCiP0r2pYNLFWZH6Xa6GoOyDIR2StprBiK1w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAbZ/7vP1qUo/wGPEVPffNuZUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZlNjI5ZWUtNGQwMC00MDYwLWFjZmQtNGQxNjUzODgwYmQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjc3OGJiYzMtOTAyMS00ZDNhLWE1NmEtZGQ2MjJjZDIx\nYjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElM9w8kmfoJVKlDwrUoAJDsfp\nKDoPMGrBJryJgZ6iG/W5MUWLwHAWPyji9cmk8F3HJGR/UCqAhm/MdICsF+GCgqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDKMpiC+vSlZlma6v7k3b6+9RC0YwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCR+upF\nTgM+R8mURZUw0t0Ew8nJtryG8v3rxS9ZZP6ifwIhAIBlBMnwEGCaR+2HBcJl04jC\nhHLFmfn1l1yJJOS0vDLT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc728", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `728` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAbLaiPmU51mlc3y5/x5x5OlHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxZWYyNGNiLWZkODUtNGExYy1iYWYyLTY2NDVkYzUwYWFkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNjYWNlMGMtNGUw\nYi00NzI3LTgyYTgtNTk1NTI2M2QxZDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU7g1sguClP40cqUMaiQzVICRV2FDsATEO80mXYtdFtYOia4p4Dnil/pGcWHF\nvxOkb3fNPU5iFravRVSqtaZJqqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUclXEvAOtnPSBlyycnUEIn4Gs6xgwHwYDVR0j\nBBgwFoAUERddQt0JUwZBjc/Y7xt1Dohc/gEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgaOXLGUzOMDxBYgfYFvbSVdf672TaenJdJY6DPoEe2jkCIQCBbZXtAGKg\nXdNXPKXcAnxEKcFqzoxF8u85+BgtXF2X9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAePiLHFrfr16m8DPjx7jXCURMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMWVmMjRjYi1mZDg1LTRhMWMtYmFmMi02NjQ1ZGM1MGFhZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0YCsI9er44T3BcMI7eDo81TR26hVAhnR8y+TZVsLFkRGq\nXo88OhzjHkN5OEq3JNRwxQFegN+p32OXNc1FUXSKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUERddQt0JUwZBjc/Y7xt1Dohc\n/gEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHmO7KONdEpmlTBZvbzV/5B+A/mxpDnDxM6jfVzcTfUECIQDqGPxa+/IB\nlqdaTZeSRHAxILq6daYtrY5xgEcnr53dag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAao/NfijOFQF7PR/Whvhlmi2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNjYWNlMGMtNGUwYi00NzI3LTgyYTgtNTk1NTI2M2QxZDk4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzlkNmYwNDAtMTUwYi00OGQwLWJlYmItMmI3ZjAyOTcw\nMDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtp7LL8yb9TLy1zi0UUhtLH0j\nSXQIO98qUMK5YFKllhOwrmxao20vUvNqg7w2yyOKFDNouFisDVZzKZTBQwqHuKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUclXEvAOtnPSBlyycnUEIn4Gs6xgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGHFJs8K\nkcJYQWRpY1Li6Y6UwawjaKH85NHNPFxZpRawAiEAiMfV7/yyb95GN3wv2wzQnEWE\ntXZ3z3BYP2jkj5O0G4M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc729", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `729` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAaWcv8a++Vnk/K6sfCJEqy69MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxMmJkNDdjLTc2MGEtNDZkYi04MjkyLWZiYmM2N2E5YmZkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRjOGQyZTUtMTYz\nYS00ZGVjLWFhMmItMmEwMjhhMGVlYWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfvKI0UGBoiipCiulSAtFyqFxa7bcfkctrDuKgAk1d3U4/j1plKMcD6d7WVch\nuLSJ1r4kqJUXtNre5lk1+nl0hqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmjZAyQwQHc02nc7wx5uEs0FXTDUwHwYDVR0j\nBBgwFoAURxD43bDVt8ZFEh4SelIHgVaJ0kQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJEWm6SqnawYGJTaJvD/7zanpFDZEyTLYRwNeKsVA06dAiBA+H+mKkCz\nuTPVJCXrOd19u/ji5CCYAGsMIbj/gZEAbw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeI/j67njBiLZC0ZvkVpSebYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTJiZDQ3Yy03NjBhLTQ2ZGItODI5Mi1mYmJjNjdhOWJmZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaf+JwyRY1yUCTRpnx9q0FirenCcqePWIs6uTki3Syct6A\ntT6p3s+qAXQozX955um9Hi5U0eFJFEvw4qj0QHGdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURxD43bDVt8ZFEh4SelIHgVaJ\n0kQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANH+faLWKc5SqtA779dCYUoI5OI9w2rHiXZJ74I/z0uoAiEApPE9VGmT\nNrskgY20fuoECa3lP8C8+Ayq0TtRl44z22A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAeO1ID5ZIlVzqPtiFk147mcDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRjOGQyZTUtMTYzYS00ZGVjLWFhMmItMmEwMjhhMGVlYWNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDc0YWEyNDYtNDFhMy00ZmRjLTg0OWItMGUwYmU5YmY0\nOTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESQMKojXqaVWSLMCwmRgPKl/p\nW6l2qB/lUbjFSRQyQl7D2qzC88fKZBDNQ/aqwlTQaXyNYWTm/vntsHBQ12BVZ6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmjZAyQwQHc02nc7wx5uEs0FXTDUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDf5aUU\naQS//8+mP4W8oT+583XzE3ECet5zFil7bcYo7gIhANbtNeAl3RHmaidwLdfvoI9N\n1cF13lSErLLilxqGLNYz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc730", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `730` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAd7LdvKJqMVa/EfCb5tHmzI0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NDZiOTk3LWNlNDEtNDQ3OC1hMmVjLWM5ZTE5MDAyNjc3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU5ZDc1MGEtZTVm\nMy00MGQ3LThiYmEtNWU4MWJmZmVkMTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL+wEVb0zeOLDTcyY9v6AeiYxUPBKy8FYJ+Z6GXy8rsCqn+jVh/X80TWJzeII\nm+Xd6l3UHc1Qy9w8JS8UPSrWb6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj06lQ3e+wvgOz2DsfFwcHSA+iQswHwYDVR0j\nBBgwFoAUG+tsIhfvj9P1w6q/FZ7HeLuiX/swOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCFu2Kfkr1hu6YtzKhEAzssgO5UTSb7lhGMyj/V9SIjHgIhAODjKhK8\nN1nepBjwYBWQiHDMfbfnQXE5jfFsDumu3act\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe5iLp/XH3wZPh+fW5/adnNlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTQ2Yjk5Ny1jZTQxLTQ0NzgtYTJlYy1jOWUxOTAwMjY3NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASozquKVSfmiW4hVMRVEtaYQGN5M6F4QiU2CznMOzg4tVT2\nFMYv1n26rmn3LDEnw+0fuS9YQGlYYG4Q4n5RpuTBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG+tsIhfvj9P1w6q/FZ7HeLui\nX/swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMW8G7hq6Y1N8k/Fy+Wzt54dozfv1ENXUdWwoK7uhHyYCIEbK40KtIp9q\n5UlO6dNheRplYyemWro3TMEy6a1OCy4g\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAXiSs3zd0xPrji89MICjFQPpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU5ZDc1MGEtZTVmMy00MGQ3LThiYmEtNWU4MWJmZmVkMTA3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjE2MTdjOWMtYjgxOS00Yjc1LTgzZGEtMDdiMGVhZWYx\nNDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFTIIyKGWsn2DJ5WDfspZtf/p\nsTB5EeiG5DzJJezHH4I8176B0JVUHScl1eYv1U4IhG646+mCQb0DZaY9Tkuzu6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUj06lQ3e+wvgOz2DsfFwcHSA+iQswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCova+B\nEZl4U8mCuYtnj05TgX4/J0PVATzzaXm0fm4qlAIhAI2/qkgoyWrWt4OYkbQQqx+H\n9cAWufK/R9Z2kUaYIskp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc731", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `731` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAWnuyWbI4HcrsvLcqaBNmDqsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4NWU1YTUwLTA0NTEtNGMyZi1hM2E2LTEwOWRhY2M2MTVlYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTAzOWEzNTMtNDU2\nNi00MjIzLTgwYWItYzcyMzVlNDY4N2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdGXbMSGV3IYRkxgyZSJApMFrEpvqI5kf6nVrkWN/HYOUsluk934YmteKu+lZ\noEdIWqliq2pTRGB/GtqnUpmJiqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpW90FN4CAyiVfVNUZhaNx/hnBvUwHwYDVR0j\nBBgwFoAU0N2rA2xsEKMqEkeimLKATQlYKzkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFC42qK8P3bZHu75ZFUuZS1DclqoEtNMCzsno/4L\nAUfKAiAg1qRNkvnFhCc2G6y+CDZsjFMsm4Pe8EDHqAEUAAdErA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT0xM8eeGaqbq3wRd59ivyG3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODVlNWE1MC0wNDUxLTRjMmYtYTNhNi0xMDlkYWNjNjE1ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYEwCEWmGw2n4dN9t/ORoUUZ8c9x/BUpRm0oqF52xBRUuu\nm8W+/CcAkFzsk5cqg9qjC065dAHgc2KC0eIx6xivo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0N2rA2xsEKMqEkeimLKATQlY\nKzkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIfV75CwBp7uFV/e1SLNrUK37SF4p2q98O2lFgdFmneAgIhAIXE6zbwppm7\nyzit5J0M74ruN1nSzBH7W6rDa+UVOBYf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXUH/9y7wifNkbkcCDCk5K0TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTAzOWEzNTMtNDU2Ni00MjIzLTgwYWItYzcyMzVlNDY4N2Q3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGY2MGRkZDAtM2Y4MS00YTM4LWI1ZmItZjRiZmI3MGRl\nOTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELzSUwnPlmXza2c8D39fCTEtJ\np9ml6ICqkuHOINf02xh+npcSblj2S8qF+Yyp3yspTGB3q57YBnEC4yj9YEmx1qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpW90FN4CAyiVfVNUZhaNx/hnBvUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIFgi+bcf\ncGsHNKZ5mgF6/XZ6TDqUBk2P/CeFx+9GgaT9AiACgVNUzDBGs8q5Z9ODJLowWa/0\ny+e6XDNbk+KoVlXZEw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc732", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `732` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAbkTZHnP8nAs5GUEIZcDNqLLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzZmNiM2FlLTFkZmUtNDJmNi05OGZmLWZkNWY0YmNkYjVjZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU2YjFjMjEtMTFi\nOS00ZDVmLWE0ZTctODc3ZGY4NDVkNmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMQC8A6dD/RcRy6NKWhmpclDhjQVL53i0TppizoV/IfMzKizrJPnW/ltzuQhv\n1aTLEeeWRumimQ5UWZR9FIcLXKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG2mZrGLlMY2e6r2a5kinJq6sLyQwHwYDVR0j\nBBgwFoAUsid8NMy/tAKxm6fYXvmdZgev2pkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFENlgam3QiYpSQQG6k6gWjJSU7Z7+JiR6x0e1zw\nloFpAiB/s+6j7Lb6f/sH/CO4Jx8GGMKab8OUnrBcYnXeu/694g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS9DKy63anebbPIjNoU4orfjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2ZjYjNhZS0xZGZlLTQyZjYtOThmZi1mZDVmNGJjZGI1Y2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyhzNG4QvSK3brjQKX2xwhkzTCKtodR/G5j2DdFYwTrmpm\nBHKxwxcuwI7OoW8uAJj5LPyQkNleudLSOda8uxLwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsid8NMy/tAKxm6fYXvmdZgev\n2pkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIazPwMrd6sACn651z4gHWOBltmQs//Uu2u003emOZ5qAiBbND/setED\nQHUYwIGO/8k2rX+mpzTTQnDlRoe3KWUttA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVXlePpC1UuBU2lY7PlCmrXkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU2YjFjMjEtMTFiOS00ZDVmLWE0ZTctODc3ZGY4NDVkNmVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTk2OTlkYmQtNGM5OC00MDQ5LWE0YTctOWJjYjA0NDU5\nZDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY+Xs39JSnWjHAetAz6DuBOga\nVqX8QLMTGZOIbSYvWV0vYt8iGQGavmoEObsFepRZn3SIGIiOlcEhXurT9GbEAaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUG2mZrGLlMY2e6r2a5kinJq6sLyQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCcAv3J\n1JMlVDFliYQjB2omxoHNPmghLBYDBwvDFXvr1wIgMUVrL2jeb52xWN/DoekKWJyL\nT5ySAKWpmBL3fGC7fQY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc733", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `733` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISATfy6v5rBzy+jD/5rqRh/22vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5N2E0NTJjLTc4Y2UtNGE0OC1hYmU1LTI5YjY3NDFlMTVjYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE1ZDU2NmYtNzQ0\nZS00NTA5LThjNDQtZWFmNDQyMDY4NDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE991BrA90XRe07v+QVssP0/8dsNzpQNIEIoUZEg6U5jXjVuDgxFV+1wslRgA8\n+l2S+5k+wO6agxvFj9U+92I9caOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNA/Z0Ef469MyqvE1wcQZu7EYA6kwHwYDVR0j\nBBgwFoAU7YTZSi4vewhF25zW6bQIxptG8vwwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIBqcNCEIRf4aCPqDd/PlXSesxp/ByD1CSWN4Qqo3fk75AiEA\n+Q+RCEN3NwrIC5oaWzKMurIWLO9/uezIyewNQWxZxAQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWPi77eywPbvs1Y+PBEn4XRzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTdhNDUyYy03OGNlLTRhNDgtYWJlNS0yOWI2NzQxZTE1Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnAtNK64nCevvODZdLelhaVGDDDvJ3NyNfen0f7WTKF0g8\n/0MS3Qpgh152HGkx0uwr+2WoEJxQWSvapLFSn4aoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7YTZSi4vewhF25zW6bQIxptG\n8vwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOFj3DGuhJk4IsP1i62Y+TRCv+2i5d3QUcK5LcFj6h+8AiEA5XDDzeR6\nh4GCLDO9ilo5Fi05UtVj1O8RKX7F1anQJMI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVzpeAn8npcw3K4RlA2MkrHQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE1ZDU2NmYtNzQ0ZS00NTA5LThjNDQtZWFmNDQyMDY4NDg2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTIwYjYxNzMtY2ViZi00ZjZlLTg1OGYtMzNkMmE3NGU0\nMzhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyzviwdLyLI6sXeV9OjucW+Le\nIC2Pcu+v0CEI7yUBHlly/1p4iZxOcu2GYFx+FvFz0puVHq5r18JdFBWVP+RJj6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNA/Z0Ef469MyqvE1wcQZu7EYA6kwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIDlmNPZV\nzKyTTOy9hPgTySL6ZDTOUACAJLmC2G3dqgBpAiBcPlxuJsYnI40HJjq1cYHGe7pK\nQDvMeywEiIvZO37HcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc734", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `734` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVsvOXZrHqPN/zhpTHF8rPIYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjZjU0YWY5LWMzOGYtNDJmZi05YWRkLWNkZTM1ZWIzNzU0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU3MTQ0YTUtZGVj\nNi00MzUyLTk2MDQtZWE3ODMwYWMwYWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEha+Y7LsXlAQYwu78u9lda0GkyLdT5K88MWZDMCSKuJ/qoTrr5tIsKkmBTWXk\n4vd6DVCUJUArZwrXsvHb+6EgV6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNKC2OmoQ7i9oHEd/2wo1eQOl9I0wHwYDVR0j\nBBgwFoAUsW+o2xOqmCuORD6Hh6HnB24GbGswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEtGhiANB8xtibC6OrVqNhAJV0lpu9FA\n0CCKaPcVc/wgAiEAhT8QWsTO0/dTT35v4miS2pvy7yUvE1bdwqZexycCDdE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ00vSBYuGfVksbqMUtIAD64MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2Y1NGFmOS1jMzhmLTQyZmYtOWFkZC1jZGUzNWViMzc1NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYYXqROGwufiPf1Tp3a+KiJ0aL1iw5TbhmiUVdAnhhCKfI\nECtB8indQWu2R6aRBT380tWaRJm0yKkyCbnCkM0Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsW+o2xOqmCuORD6Hh6HnB24G\nbGswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO3h4PXzsVWNu4SmRlWaaYSSF9m7hYoSdYmvH5AC/+lsCIQD99ADZ8BYg\nDtqmQi3U3eICrxdBrbifnYpyAFwk2TX73w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAbHj3PvVUGWoZwd4BfRyXOKCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU3MTQ0YTUtZGVjNi00MzUyLTk2MDQtZWE3ODMwYWMwYWFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWFkZTc5MTYtMjRkNS00MWRhLTkyNTgtYzc3ZGQwZTZk\nZDQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENFPLtTYFUEJF/eijMl3YhUsp\nknXAC8EQnpOZVrrtuhXjfnaSBiQTwgi7VAdRsnLoORiO1um5OYiZeGnzEtW8F6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNKC2OmoQ7i9oHEd/2wo1eQOl9I0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGcI1x4B\nyu6L4L2Axjx869rulPUQuED+OQ0/5r8mV1m3AiAb4h+fAr79fimIaVCd56ltBM2T\nYMvvhkYmmR1qWqv8Zw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc735", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `735` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAYfIoAFM4dqsSb/bnhSfXEuxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2ZmNkZTU3LWVkNzMtNDM2NC1hYmFjLTM2ZTkyMzk2NGY5YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg4ZjA0NGMtNjU2\nYy00MjQzLWI5YjEtNDEwMDljZTkwZTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXagUyd4C8vKF4igzd0+vfONRnC2Swdw7hbFJAGpmu1IzB2XXC5fvG73mmn3J\nLssUiMcHcjOxkOSk3jkhG0nORaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaiSi877HSp2eOMIjC8mr9F1heYwwHwYDVR0j\nBBgwFoAUPhX7ucCZJq89H8YV0fbcuaUkGoEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCltanprO+is5TNfchwltV1GwsxDxq7\n4opMIn66K5WDnwIhAK5IM5LvAZlWa5onnw8aZeWXElpMpQQDuXvWwF1rbzeV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVdlpfFxcrfrxj2N2TKo0kSUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmZjZGU1Ny1lZDczLTQzNjQtYWJhYy0zNmU5MjM5NjRmOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStOlxmRb3HpDt45s/8Eu7UovcsUDMXyQ/r+zC3TghQ0TYl\nGuw22j+icwwg5VO5hDlh3ZQ3kHBaMac449bdk9tOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPhX7ucCZJq89H8YV0fbcuaUk\nGoEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJWHwumUlFJEujCW71zI2hKBQmGmAed2QxgWOo+Y6m3/AiEApRbGfajA\nssYK0bo1028j1npfnjbD/PrzpwNt+naJy6Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISATw2dEH4v28uWx0m4f3bdaV9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg4ZjA0NGMtNjU2Yy00MjQzLWI5YjEtNDEwMDljZTkwZTNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTFhMWViZDAtNGNlMi00MmY5LWE2YTgtMWMyYjlkZDZk\nNzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzBnKk0AKdURtWhnAvayZ/AZu\nUEpdduSZiirg6qbAcK1gtRE0rV7dH6WAu/ecrEW6QxK8i+7C+7wSSVSwU1QoiKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaiSi877HSp2eOMIjC8mr9F1heYwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDK1ENp\npJ9F1AWbSUgyWvREussLEqcTFnyBUkY9E1qwkQIhAIjjtR4kvJtEmF4hjhNbiAuR\nbWOPCFMD3reJmQ3u1TXN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc736", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `736` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcSgcsSj0DOc+vAtqdvPoUZwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MjA5MWI3LTkwMDgtNGU3Yy05ZTczLWVmZTY1OTkwYWQyOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY4ZDRmMDUtYzRm\nYi00M2VhLTkwNTItYzVkNTFjYjNmMjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErD7basyRbjsoM+5/kvNKcTEhd+UhvIkdq8czv0OUJDrEvdeZo6pdtQEutjPK\n7CRi7silfE8CADPl6blsw5QpM6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEL/02Y8OOXR48a6s1X01AZ/YKfcMB8GA1UdIwQY\nMBaAFHW1AVFotL37QgHX4C5uYSiGG9m6MAoGCCqGSM49BAMCA0gAMEUCIQDCtl9z\nKZ39UyYxqhveLKIwZ9fAYsDjQdb5flkVdhcqhgIgMaCYbMNpWqwbWTxllsXhTGud\n0XaiM6MMbA/qAhtR0+U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVhnIz7eANCsUBQWCDOx6HsdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDIwOTFiNy05MDA4LTRlN2MtOWU3My1lZmU2NTk5MGFkMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQeJpjjgkGK9zpQhBNL35AyVkpS4D2RbVlvLyFRKzUyZkH\neoMGRTS4gNOeaFDOsC4vq3qA7fB+8YRolluRrGX1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdbUBUWi0vftCAdfgLm5hKIYb\n2bowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLYZVcUYZopgkL+lithHP+jMaN6/wqfJpKQxwvGa0/RkCIFqVQ6/iOXtA\nyiAcTtefjSDQcYTgqL3LVxEzKBzM+QXV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAZiraq49J6h4WPHnq0U3xmlQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY4ZDRmMDUtYzRmYi00M2VhLTkwNTItYzVkNTFjYjNmMjAxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRiYWMyMGNl\nLTQyZGYtNDhhNi1iZDNkLTcwOWFjMjdkMTg2NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG6AGaQO2tOvyPcqzX4puOOY7GPycvI0+QON+CWzI7RP46obGMLkASZa\nQktrBmNmzwJhX+oVeZ/iZZLXc/5tEwajVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEL/02Y8\nOOXR48a6s1X01AZ/YKfcMAoGCCqGSM49BAMCA0gAMEUCIBQLDhOMoGoL8LfH0uvS\nbwVENKX2UDXcz4RazWDxvmkTAiEAuS/lEWavoypf0AtflXicOawb1SWO/R54Hcyf\n3q3jRpA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc737", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `737` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaugRmeStaGoPccgb3sg6JKSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiOWYwNzc1LTkzNzQtNDFiNS1iMDcwLWEwNGNlMDM4ZmFlODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJlOGMwZGMtZGVi\nMC00OGY5LTgzMDctZTNmMTQwNjAwMWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFLOSlITsZMP05iNwn7D0DIsDdjBS2uYbZdB3FX8h1dgD4j/m9Jk0I9cBj+Lv\n7fIgWHcKnHSuNVGLKubZWt9PmaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNhO7uLWh1gqMi8nITlgpxigYT/lMB8GA1UdIwQY\nMBaAFJoJ9iOk351oj+1PwGibiqEFvZd2MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA2pBt2z5ed/ZGWBiyjb8s6Rehzzv5kv+4\nVUic1IpQQw8CIGQbqWB+IAEahFIrW+KxcOFssbUNy2e0PKCn6CdXe7u7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZI0cSVrxWRIygXtYV1AYsR3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjlmMDc3NS05Mzc0LTQxYjUtYjA3MC1hMDRjZTAzOGZhZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVOiJdyObAJBibmbOqYhOglA/ZMy+ZgmJVWV8kUDpn3IXz\nlbanWSHa+jEZ2gKc8suWhHEL+h+nSSEIowM2v/1eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmgn2I6TfnWiP7U/AaJuKoQW9\nl3YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAr9jW24tAA3IEpYojyaSKztGeE8xLgBvKDkCd/AAdD0CIQCBYprlJ9ZI\nXdV/qudnusJEVfN12K8VSn+hLlcYwWbV8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISARIrw4mMZ2uEvxAOWXALf0y2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJlOGMwZGMtZGViMC00OGY5LTgzMDctZTNmMTQwNjAwMWRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMyYjkwNjBm\nLTM0MmItNGFiMS04OTI1LWZkMTQxY2UwNTE5NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAaRCqZivKq9XT9dpfRe1SydjZg+EM7xnpM+Y3V6VCVC9/Dv3sZuO/+y\nRPWrd8bUIt3GpVvvyaIheyDdnN5FY8qjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNhO7uLW\nh1gqMi8nITlgpxigYT/lMAoGCCqGSM49BAMCA0gAMEUCIQDY6eCcCO3ppxbU8gTy\nXHvMspBD0KPj6DXaQs+F9cHzlgIgTI+D3/G8oR0becYO/itDBPG9dhSoq4uXkcnK\nXmMV0Ic=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc738", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `738` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISATmAFIWsSwOj+z4tcgsihv60MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkZjRlZTQwLWNmYzktNDQ1ZC04NjFjLWE1NjRiZTgzMDIwMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQxMDAzYjEtNDMy\nOC00YWIxLWEzZDQtNDA3NGMzODMxMjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj6NRW2gU+wVviMeFLQoJKChxetol57Ji43IRfgOQfKLGBS2MmltY6s2p/X+G\ngWAZoqnOi/2LSDMnrq9QO/YphaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKDGxS+UzpQJQ0tee4RDRBIIPBnuMB8GA1UdIwQY\nMBaAFETnBVLNebl/dxC9qTYedVVL3kFrMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAyeqPoj9cjpIyo1klUIY9J+us0jfwaESnT\nGyJBeZauaQIgf29758tMqjistkt+1lUeFUH+c1SNCKxMgZKoQ7axq9E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbR8oWll1eH+c6cN9+3gXGDBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGY0ZWU0MC1jZmM5LTQ0NWQtODYxYy1hNTY0YmU4MzAyMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoXO6pqiOOUBjH8Fz0gZOm/NOlkR6qhfeELU9NZNgXa44z\nJ/3euqQ6JZYpR5u+DB/8rco3pRDjuoLunX5QMzE9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUROcFUs15uX93EL2pNh51VUve\nQWswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHuitCiQrqQhmK3t4I4jFTqnZvlYbJ26g9YoNsUokfMMCIQCyqICGVlUa\niU7tVdoHBX1zJbl4H8X6uC7ZPRT9Xkby+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAVuRy6J9GVPq1YZoeo3yLpiFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQxMDAzYjEtNDMyOC00YWIxLWEzZDQtNDA3NGMzODMxMjEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyYzM2MDA1\nLWI5NDktNGZjYS1iYTA2LWYxNjFjODQyNGU0YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPpgaiNes/vqtIRiT34K5IoSqobgY6TmyS4WbKW0AOuypZPFmA0wlSZB\naXk5y/2FHrA2kEDzBWlC7iEfEVRsJAijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKDGxS+U\nzpQJQ0tee4RDRBIIPBnuMAoGCCqGSM49BAMCA0kAMEYCIQCrn0ZU6RufJPhu+jjs\n5kI/V4ly/vS7tdZ0vurPQG1YnQIhAP9U3K2iE71GbECGvq4HKiZAp5QJm1NCcmTN\netzAJwqq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc739", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `739` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAae7EY7H9ixfzg3n9ANhu7L9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1MGRkZjA2LWQ2MTktNDA2Yy1iODliLTQ4MDgwZjA2MmE3MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjNjMDRmYzktZWFi\nMy00YzM5LTg0ZDgtMWZkOGFjOWMwM2JhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2er53J/hvGPjW9SpoSrEQM33/IKPqeh82d/SQ4p3AtsX4uxRqUwaQp9ZodgG\nRLPlP87xYWSdwqvrMQcvKsnlFKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTZjYK2cgGfXvNXKDTEHG8TgkengDAfBgNVHSME\nGDAWgBS6f0NOiwSj3MN8ohtd5ndm0VeI/jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEdMSrJJK4o8Rkus/3wk0pRPS1wHH1zQ\ncnSPUTDDoJG7AiEA7NM+fyhhhjir9Ygtm22toCh29vGshAeIC2mlkDleml8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdO0Gjy8SIAwFbEjWGT5XkLPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTBkZGYwNi1kNjE5LTQwNmMtYjg5Yi00ODA4MGYwNjJhNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfolz6NuYPB4cz6dE85x3b0jp0I/LtzJnGwWibyUKKTPpR\n/G3sZXvULpd/h7EyFaUQO4ezQxN48jJEsmROrufdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUun9DTosEo9zDfKIbXeZ3ZtFX\niP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL67B/cgEt7mRtFF2HYyivCrcFHbZKreW1YqEbzvKyMJAiBubVMuDsva\nzSewXu7PgdfrQc33EPk3SKbCBYqfioNNQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAcLFXxJKSor/Rl6NJ7Z3mkscMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjNjMDRmYzktZWFiMy00YzM5LTg0ZDgtMWZkOGFjOWMwM2JhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFiNTgyNTc3\nLTgzMDItNGM1Zi04ZDZkLThmYWRkZmY3ZjdhOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJdXoxVZRCRTCj/dj+2s0WqpzuRWhq1Z/nYnSJPhlSl1amBPP0iJZ/FD\n4770WlTWY6Di293TGGB0RqkK35fGJKKjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNmNgrZy\nAZ9e81coNMQcbxOCR6eAMAoGCCqGSM49BAMCA0kAMEYCIQDi/HlhDRFNmv0FrbJq\nGR0DR29LKT+K07VntiCk7zk7JwIhAL4ZBytm7lpb3wQkHOH6UZOWa9G+LKono2Ds\nZXsLeDh6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc740", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `740` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARNeMxlrPYYmDqHD7SWc/qxzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViMTVlZTRhLWQ1MDktNDJiZC05YjdlLTc2NThjZjRlNDFkNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEzODBmOTAtYTgy\nYi00ZmZkLTg4MmEtMWNmZTgzYzJiNzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHHuYmgdclgVouvC7NlWQIcAPDYJ0NCFCzoUbUtlZSoE+lv8sg1HCrrT1FHCN\nbb2Za2M9x7YRQ0R4mjNAHFMdsqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEgqHaWfP7+hP8z/LnnJoyXoZRAwHwYDVR0j\nBBgwFoAUDn6+jkCvH5LTu0l/4T8RuFGpylMwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAy3MyyvIVAT3KB\nIXu+2n4iZl/n+ZhjSJsDK8NXCCBOQgIhANQGcbDKHa9qcylW7VR0xBCpIWv5QCv/\nR+0TlY8y6C3y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbXwGB90WSx2aOwMFrcDZg10MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjE1ZWU0YS1kNTA5LTQyYmQtOWI3ZS03NjU4Y2Y0ZTQxZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPXtHudb5kB8SenGL7YTiW22bfPEswNHBbDWLfbrnERsvT\nqphE1HFvoRiuUw1DlxZ8P0uqszoXdEW73aGQURu+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDn6+jkCvH5LTu0l/4T8RuFGp\nylMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaSuN9DZNoNpL+YHTnWGHxWzjBfVVtt6Y8UAxFI/c1KcCIQDCPvr89pwX\ny4nLOpMkmEH9U0AcQdOi4QZL0EZ8hhcTfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAQyfLRm8OGPbuTX17dEQCZgeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEzODBmOTAtYTgyYi00ZmZkLTg4MmEtMWNmZTgzYzJiNzdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM0NTRlMDdm\nLTA2NzUtNGNhMC04MjA4LWY2ODBiZGQ1NzYyNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOZKcNDYe0/Xax166kh6RqZQITgXeyitcfRNXJ2R9L+FBKiuNPchsCLv\nOPRoBEOqkmgXbsT46nPM4A0UUeLvLEijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHxIKh2l\nnz+/oT/M/y55yaMl6GUQMAoGCCqGSM49BAMCA0gAMEUCIQCSQedzN0l9KC+1Ct6m\nipnkktzO/KigAD6d+KsJwoU2+QIgWnfxjNeLnGgY6CKODsDvFr77iq3SirxWRa2d\nCeUDDjU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc741", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `741` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAd04S6MDBGLB9Ngl4cRKEFfUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzYjczY2M1LThkYmMtNDFhZi1iMGY3LWEyMTQ3MjJkMzQ3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVkMTA1MjgtOTJj\nZS00OTNlLTg4YWMtMDYzZTgyYzYwZGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgo8nM8buXQ6SZz1ID0uXjEdpY+0QdjGGxR1cOjlV+E8SF4d4E3rjSQPXsM6X\nWndyNa2J35kIH0WWBAzhlOs0NaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx+wIXRBaLM6hMmSo6os8pEvptiMwHwYDVR0j\nBBgwFoAURSwW8LpcA/zfh7QND6lN6BU6G2swJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAmfJg5TMtFzAc\n7GBdfzt6oAXqcsslgKnKV6NAlKv0ZrkCIDqnsxdbEF8aGTWlwq0OLCAip/nDQyyS\nrm6KH2ByR2/1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXw1XzwEstuqvK+Yc2iRPHaNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2I3M2NjNS04ZGJjLTQxYWYtYjBmNy1hMjE0NzIyZDM0NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmSDhG0TprmkPtk8sIJL2R83V8voWDX+hdF8g4bdoU9s9l\nSxkwXySMN9nAf51D7PxCmOQaQp4VEE6Svi0Ie95Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURSwW8LpcA/zfh7QND6lN6BU6\nG2swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIRirVkLEVlb1vrZ8RaVVddWWHZeOyF5a7EFJXfytPz4AiEA/xsFS2rg\nopy7zI3ZNoSMoGX5DQ4rD6yyZNZhMJ760BA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAS+Pm7P9hmPXowyE1SaFMkjtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVkMTA1MjgtOTJjZS00OTNlLTg4YWMtMDYzZTgyYzYwZGFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU0NmFlOTcx\nLTdkOWYtNDcxYi04MmIzLWE1YzY2ZDBhNDFlMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEpwORm04lafsaEXgNiyrKtF2+NODv1er0kaOYGdHbxcPTuubUpT+Oh0\nV450NCftLN0gnMaZzTU5yGVcQo9ndaijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMfsCF0Q\nWizOoTJkqOqLPKRL6bYjMAoGCCqGSM49BAMCA0cAMEQCICmFbTpr3R1jIvmPtJ20\ntmQi8Aaxuy2zL14oUjhEfBMgAiA9YKiGYzGOrdeaIoDdC248gzueMobKgmmzGZgM\nd/gb0w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc742", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `742` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAX3MNT2imQ61lHv4DfhC5EseMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNjZmOWUyLTU3MDAtNDhkNS1iNzNmLTBhNWZhYTc1OGVlYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQwZTIzZWMtNTVi\nZC00ZjY3LTk4OGQtOWQ4Mzk1NDNkYWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElprYQi6PceqGYBWCZJ6HnxVTBkwIAFpiKkG2JbtM5STUVBZOwxh9dvpo5RQq\na9koICyDjJTxokpah3+ZCypM5qOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKrnM6jSBNouwz+R0WmK+DFdtndQwHwYDVR0j\nBBgwFoAUkXUdei3WOCKntxo9j8j2Y+7HA3YwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAk0pSQdI046ssg0awaDB7w\nZHqDSSmf06oFc1hgx5eIiAIgU1fOTINKUl3MiSlZ+m0GomODlZ9/HQtUESG3PDVS\nG9Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV6CXHmKsTwrdaQJ9R+S2u54MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzY2ZjllMi01NzAwLTQ4ZDUtYjczZi0wYTVmYWE3NThlZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6cUnHlRfOnjMMDKSbHIlGlzl9JvCzt6GaeVmU7KzWjRBW\nwvc9DisG6ev2993PBwn26+zRktEGDXoQ2gbxcyO6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkXUdei3WOCKntxo9j8j2Y+7H\nA3YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTtpW4UQnoFxNb4z/fvVyBaDRotvoZaER9eMOZBWNcWoCIGubsi303ik3\n5VGeoueMG/s5fFSSLRZsWvrQI4Kl7DBv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAfE/kmHw3jFkuDWmGPAzkFSyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQwZTIzZWMtNTViZC00ZjY3LTk4OGQtOWQ4Mzk1NDNkYWJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE3Y2MyNjJk\nLTYxMTYtNDZjNS1iZTc2LTQzYTFkZjAzNzc4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBhOITBniWQ7vvdFygrZuo6cp0Xjly2GflYiPHr0oYCnsZHXN2awIxTR\nansS/wKyO+DItnMwSrgwCJ5QPLGMUfGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCq5zOo0\ngTaLsM/kdFpivgxXbZ3UMAoGCCqGSM49BAMCA0gAMEUCIHoUkX1Px4Un4myzYwYP\n6V2pFEPtVLm+QvLzvxp30+M1AiEAytGmhP3wVcWUSKc4FgcNYGYGr34OS8E1GrkF\nXZoHBrw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc743", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `743` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAXIEhz0h1MLLNEexj17eMz92MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjYjAxZDQ2LTUzZjAtNGJjZC1iMmFlLTAyYTQzODcyNDA0MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBlYjkxMDgtOTA1\nNi00YzcxLTk1ZTctNTczNjZhMzA2NTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESJFYKHp/i1xpz8imaspaCmjru4pOecw1z5tTY8Vx+Czz12Et23pwKvlhTtXW\nlGxUYRIcH2KRGBfrYSTOwp2VmqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+vPOr+rc0Zxa1X1C/Ewqq55WstowHwYDVR0j\nBBgwFoAUS1Y8ciilkVFrEYo5lxCUzenXmBAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA1LsY\nylRG/9ixVr6tJiWg6PK1jsIqesOpd7WOKJZZnvkCIADRBCezAr2awsVGbogdd0wl\nNQyDlwsJpvOx9GuY119d\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcj0UKYnV0v1Ys88QRF0Ip2MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2IwMWQ0Ni01M2YwLTRiY2QtYjJhZS0wMmE0Mzg3MjQwNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQMpwmjTHRlI3rYDwC8tr0Nfw1vLQAIdW0ZP2ZwV8qlcgN\nMCd10OxsX//FX104M2otBaU+x+eYwxWUFknHlP6bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS1Y8ciilkVFrEYo5lxCUzenX\nmBAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLicHQTS9xRENFDlk1k2MqrU6Ep0/mBl5Hd1HMbtOYvoCIAH68m8mIENw\ngObce/KB6ofyJNShYxRbhuLqPAmTnzNM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAVj5OVorW/8SuZ1gibqajT5/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBlYjkxMDgtOTA1Ni00YzcxLTk1ZTctNTczNjZhMzA2NTdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNhMTdmYzQw\nLTVlZjgtNDhhZC1iZjEyLTRhMDdmNDNmOGZmNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIBExLjiwGFc5fUdwqtDLnY2kc5acLvfaxIHI4/1fD8BZAeyBpHbokc2\nnk0aFJ6/MG7eVbTPndxPvGZ1OKbhyAmjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPrzzq/q\n3NGcWtV9QvxMKqueVrLaMAoGCCqGSM49BAMCA0gAMEUCIFy0DkHYrpwuQjoTwgjt\nlLY3mvJTI64PPFfPzO8CXYVvAiEAvfW15dPkgqqNk3OgD1p7pwJaB+gmeNiG7/wX\nMYgh1JA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc744", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `744` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAWytgz537RXdSut9AzFE+B8QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3OGY1NmE2LWMyMTUtNDI5Ni1iMWJjLWYyNmI2NzdkMDQ3NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBjNTlhNTktYWVl\nYy00YjU2LThmMTEtYWZiMDQzNTM0ZTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMAz+ls8eeK0WOvLODtILd2V7H87DQDaZrCXVn2tSq5vFRfYG3k3R6b69vFbr\nBg0+I7YywDPqceTfVMgyVJgqCaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMQNhFy9Z+pGh/4olLLH7HtB/A8IwHwYDVR0j\nBBgwFoAUQ1D2oL1OseVqn4KB4Et97I98J2gwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAmwJ3\n0SqN9SdT8L/TTDAW64q7xDasid0xcL9mGR9/6S4CID22XV0QzsZ/IogCTsMYSv9O\n60ZkSI+c5SJRUFUK7rUq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZciHuVoLGusCq8FM28Sff3GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzhmNTZhNi1jMjE1LTQyOTYtYjFiYy1mMjZiNjc3ZDA0NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATD2RLTo0IvZslmykgnHulmiL7hAKAfVLjCiYZKIdhyeF4J\nTg0YUyhdl97E66fyj9xwoW4Xt+1IycXjEg6drNyto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ1D2oL1OseVqn4KB4Et97I98\nJ2gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM58UOS6yLaNWOOme/w0Qb4YcdR7if7DbnqkyKDwa8wUCIQDoFqbGS3ti\nHfVzn1B85LlgV0wPBsCkEUt/fFCeFM2pfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAdNe9Rblma0rSSf3o2W1so17MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBjNTlhNTktYWVlYy00YjU2LThmMTEtYWZiMDQzNTM0ZTkzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyZjNiZjJh\nLWVlY2MtNDRhNC1hNjkzLWE4M2VjOTQxYzI5NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI36ZHikZER2bJOyj/w5AMAhAIs7H9VU9uhIuZGTg2TbmFZbfXfkKzMY\nRL01kwTYNwBCKF0uLaUKhnr8QIuhg4GjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDEDYRcv\nWfqRof+KJSyx+x7QfwPCMAoGCCqGSM49BAMCA0gAMEUCIQCipsYQdDG+KFP6KPGN\nzGsH5QYF0k6KuQyOQZl9tYDP3gIgI5bCirNiCn+KxestoUd2lS8rVJJo1Tj3LKKw\ncizQU8U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc745", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `745` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAWGY9XWYuqBjzu/ej9N5PcPEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxMGY5NWYyLTc5YWYtNGZmZS1hZmY1LTE3MGNhNmJhMjFlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRiOWM2NTctNzc2\nMS00YzY2LWJmNmEtNzI0NmZiNTMzMGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgeEFLGP48yYOdSmlARTMTvk2PRiEWTO79KinRwwYHJfhNim+F3biTurZblWf\nujZAnDtE5cKxX3/jyk9Gl13e56N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFETNYjh3bpN85snhP8aEDTC2SxIjMB8GA1UdIwQY\nMBaAFDuK3MrVpYpON7YAXTxXUVpTWPneMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAUcsHLAWMFZVwRCe0fxMT+zOKl64WzD2/a\nI2un0WR8MgIgdlCIICM/xXxbLBOjqRGIYdbGBxr7mdJ4jN8HtqrBU9k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaWw6uzD7Pd/3F05ZRDOWhhxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTBmOTVmMi03OWFmLTRmZmUtYWZmNS0xNzBjYTZiYTIxZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2BnnCKdAtWLKH+A3rgnX71/CzJZq/k9ia3E+v3VSM05FC\naQI+2NdnhUGqMXxM/YY6BkMM6GuS2LggdT7jB3KDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO4rcytWlik43tgBdPFdRWlNY\n+d4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMDVfncEsTag6OZLN8T8hO/7oIZRzJlWtSpTXlifljJaAiEA02mTNlOW\nmjz4sAsYmt+6SDIN09/1mXHvA5Hmx3GntAc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISATIEE0madoBKBVxyunBr2AcFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRiOWM2NTctNzc2MS00YzY2LWJmNmEtNzI0NmZiNTMzMGNkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkxNWRhNzc2\nLTk1YTYtNGY4ZC05OWI0LWJkMzMxZTdlYWI1YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG0yxbiqetzFvfAi7vKlKsz/5zqRgm632pp3/+nJrRu1F5rpmsHWAjnx\nXcxZwtfARRTXW3zIBvWTmB48hH4VWeejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFETNYjh3\nbpN85snhP8aEDTC2SxIjMAoGCCqGSM49BAMCA0kAMEYCIQCRsyG+VDXE3avIG5h9\nmge9SMQRGijQwgFyGLY8EIYT0QIhAJeyrCWT/Z0VLWYIHwLiwgfEfSIJwRN6sIyC\naGhxqOOM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc746", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `746` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAaZ/sL7uzSVVr+QspiAX/6yKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3YzIxZWJhLTM4MmMtNDk0OS1hNTcyLTljNmQ1YjY3YWZmZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUwM2U0OWEtNGFj\nMy00Y2E2LThmMGQtZjFmNTBmMGI3NmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESsAb/+/Jyt/s8ER/eO27fmljyneeosnPcr/rTUp71wRToT0Xrzh0kpKopFaZ\nJ+pCJEpNC6nNkQYGFhv3WblAMaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJkBc8kc1fd30wcsVNmFskK+ay8wwHwYDVR0j\nBBgwFoAUMWOVRQiUWc4pnX+6djJkxbp/uTQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgIZGBTV95+5rl\nXULsl5PLfvtHiSoLdJGiAQoQLV/yayICIQCI2QfGp4nlk/tQOuWXsRJbpy0XzyRA\nXQl8kpy7S4SlwA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdNF1ZjGsiCSUKCkhlFTpw25MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2MyMWViYS0zODJjLTQ5NDktYTU3Mi05YzZkNWI2N2FmZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1hTZ+DcGohRCrKLMpy+FOi62adLTqxcKWcwApNA6qmLDJ\nz9tD3dMcV4G/MqIA4cOvxJ4mWW34ZUW06GYhq7Iko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMWOVRQiUWc4pnX+6djJkxbp/\nuTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALNoApRRgA1zHzxHa9b1be5ymH4FjVmcbXrjKAZaFuOxAiBUi1pICr+Y\nyEsSEJMFax8PiNrBjyCJe5x0ttcTPtRMuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAQhi63KyRL7fTnLDavfoIwC3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUwM2U0OWEtNGFjMy00Y2E2LThmMGQtZjFmNTBmMGI3NmUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM0MWJiZjEx\nLWJhMmItNDc0OC1iZDViLWU2NWI1MTUwMTI4OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKe+SfzXcRw9bdl0d3rNjHSdZHExzDCLUPox/EYC+/L+k+JIQAH3PS7e\nWGTgVbZabS5/4egOi07oU2uIqw3iWxajVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCZAXPJH\nNX3d9MHLFTZhbJCvmsvMMAoGCCqGSM49BAMCA0gAMEUCIQDUGIkfsrJNB6IWBcOI\nXV7pONkDyXsHgymRVy9vTLxuwgIgZAdDjzAdTIzw/5nnO87+k7Dt8vrKZR73zrEr\n5g+m0IU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc747", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `747` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAUns9kLZKcFSLN/PZltWwSGuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxMjdlZmRkLTJlOWItNDBhOS04YzEwLTJlOTZjOWE0ZTg3OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJhYTA1NzAtOTU3\nYS00YWZlLWJhYjktNGYyOWY3MjE5MDllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Zp5MFb549RIdXCkAFn9h2JxF7Sn9fLthEN6BKcwPEv3V+iB5hd9+8GyLf0T\nAchhLCNhPaA9S+7y9yjBSgOLRqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKeM3ncUsTXbIeKin3ei1AkJSpM8wHwYDVR0j\nBBgwFoAUOGmbWqEHU3raycl5WeMAaebK+QowKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJJMEBZDL+AH\nxsP/0qnbDJmK27XE/PtRo8m6gBFSLhn6AiEA9iGcD9kwz8heaLuMB+/pBffEsHoq\n+OfR0kYS5HjovVE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeyey+bOt6BNqwbRVR7g6KN/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTI3ZWZkZC0yZTliLTQwYTktOGMxMC0yZTk2YzlhNGU4NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLVY3NVXEexqpxzXZi4iu0hUKYVaGvEHmaGjhSRVHlCfHs\n5SbeTmoZFPV8DyVxL24kVDCVxyPOFih91TeS7e4po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOGmbWqEHU3raycl5WeMAaebK\n+QowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAICQ8n9dhkCKQhxc4Gij0LYRWOFKXMpo+eKoMXnQZbbuAiEAorhraN37\nPNg19o+nxmSusnyInESS9G/CzYuJgtBMGvs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISARUZSNPBwWCtpySlm1OQ6az9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJhYTA1NzAtOTU3YS00YWZlLWJhYjktNGYyOWY3MjE5MDllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDljMmE5ODBk\nLWJmZGQtNDUxNS05MDQ3LTkwY2Y2ZWE5MDJkMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPmUb3ggOlq6/usqj3wJjqG9w43323OXcWYU2LsYiEm8CXUyw4N5JYNa\nnWbJXvCCMPuERJhetk6saqdJPddoae2jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCnjN53F\nLE12yHiop93otQJCUqTPMAoGCCqGSM49BAMCA0kAMEYCIQDrzOV7i5YaRO7m3xTf\nH/F+vAo4NRTGZYxk8o3N1h7fkAIhAJT7zVXpeKzi4FsXubdQVvq8MNj8YHeiXfYA\nla9LvgcK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc748", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `748` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAaimH4/m1PcmoypkYGkXCjxkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViZjU0NTNkLWVlM2QtNGJmOS1hZTFiLTRiMWJhOTE1MDBlYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDliNTc5OTAtYWU5\nMy00ODg0LTgzNGYtOTk5ZDlhYmE5NzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWl8gMPckSO46FQvQncueIdh8CVWAFZU+glwS+aj1txvcrs9O6wW7uyRjMntu\nkHtJtNI2uxGiLj9E0qc7c987xKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+n6MLLn428OE4hcnpd50a59SUJIwHwYDVR0j\nBBgwFoAUcR2H0qI0hAapyeTe6D2YsAv/Ef8wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD71eopvBK1\ntDtXXb9gXxcGOYeJVpqblaxopuJo7F7q5gIhAITtzaVFABGvgpeqnIt8yJWN9P8Q\nw88sYOCFBWqblwrp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf702Pv9L9MEQuRfTMwLu7daMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmY1NDUzZC1lZTNkLTRiZjktYWUxYi00YjFiYTkxNTAwZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqzGjkoplVgEvnMYe7vNMUo7Z/9c0f2v047Im0PcDRKC96\nski75tlYofAY87CSu+qiSBVVQC3XkeFIzQbWs7Uyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcR2H0qI0hAapyeTe6D2YsAv/\nEf8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPdK/W095zubvZGPTJz3yqSI/XUadDiWauJL6/TghW+YCIB0cxVHxEFRD\nH61AfDluJFsKoliPuxIqc4Dky3MEqlJF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAR/TRdoq21/8Ym+pozbwsNQQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDliNTc5OTAtYWU5My00ODg0LTgzNGYtOTk5ZDlhYmE5NzRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZiMGY0ZGMy\nLWYyYmMtNDBmZC04N2EzLWJhYzgxOTM0ODVkNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHkfhlKc8anoL/9Tuqmyip4QUPVzDYdgytdGmtEmWaqWLI93Ex4EJlPJ\n2sn4S13tatiD3rbcM3NyGYZmLbrr9MWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPp+jCy5\n+NvDhOIXJ6XedGufUlCSMAoGCCqGSM49BAMCA0kAMEYCIQCslDboamKxZcFwY7Oe\n1XRHm3djRH3RIDD0xQpW0+/KHAIhAOeIC0N2xE+Fbm9wTZMV0Oiojv5vCP+e0gC0\nVtVLhDuf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc749", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `749` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAfi/ZSLqTlMy9jDwufimYs2PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwMjg5M2YwLWVlZjUtNDYyYy04YTQzLTlkOTFiZjJhNzNkOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU4YzkxNWUtZDU0\nYy00YjEwLWIwZjAtYjM5ZWY5ZWNmMmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERcp1FpIZDJ30+PwB14bIM+hQbFvn6uOuJ2RGoZ7M0DkhtBAp9AWSsN2QN+hN\nREZNeHoB8Ps4IMwNJ8lhohY/jqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYpmn2nqCvbYBRyRwu+hiXnZCVqcwHwYDVR0j\nBBgwFoAUwG4iT/kA4X3gnHto6v965SdNY7QwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCyVcKPpzj8AiV4FQh2uVTdz8/Na5rT8nlXu2zasfigSgIhAL34RJJ9uWLL\nVtfZ/71jdqLNHXAs5sMWBmNWb3zf2J4u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUp4IQXnAA1wfvW4ig1ZwzK0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDI4OTNmMC1lZWY1LTQ2MmMtOGE0My05ZDkxYmYyYTczZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRmYnKX1/Rxm0rIkGaj3eus4eOXNzQkz9Vi8t6p3618Hrd\nijJVvFq9+haPEzFSI1d4iLejWkV5q+njGt+Ltea2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwG4iT/kA4X3gnHto6v965SdN\nY7QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM5zhSEdaxc39BjaRvyhHvNJFHeUNKxiHxj+2FCFURBnAiBpXBI5nSrh\nYC7Q3eQpdFruSl9SR9L6pRucWPnwK33DIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAXC9fyPxUCi7NBCmEgvbxFvUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU4YzkxNWUtZDU0Yy00YjEwLWIwZjAtYjM5ZWY5ZWNmMmRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUzZjZhOGVk\nLTAyMWYtNDJkOS1iYjAyLWM5Yzk3NGNiNmEzMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN7q9NFpGAoMWh9W9IoUeDiQUzv2BsIheSWWbnqLbD/snoYhfWnHDrBY\nZsdPcnqT5NwbwvQd2XTiv4E/yGag0XijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGKZp9p6\ngr22AUckcLvoYl52QlanMAoGCCqGSM49BAMCA0cAMEQCICDHB5A33EmY+RPHafN7\nDvZuTF+oNDwjc3yPi93R4sn2AiBg6IXx3+pqUh829brpCgUtFqHnp7hSOkTxu4T/\n4JSmjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc750", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `750` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbTMI7JDy+WBLbRt5yNW7Id7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhMDczZGI4LWI3NzYtNDBmZC1iODhjLTViMDE0N2RhNzQ0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRmYWUyM2ItMDUx\nZC00ZjNiLWE0ZWUtNjJlZTlkYjc3NjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErk1prJPRn7DWpchw0XAxjhXMaWQGGjRtHQ+3gK572ZdOma77SqWyjp2OJzc7\nD+uEnQv0WycD0nV8ery/90E6b6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJFVsG5HncEHHVwLix9uwVpRshpEwHwYDVR0j\nBBgwFoAUxciR5bE1vpecOvugdQ8/Fh5kF4kwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDmXNjTh8pcqRijWSgzLukXihzSj2TzDUiQ0DmOe7JbPAiEA79yt19celJoJ\nSLOXFN36FQV+qf/PepVtjQGZ2mmVF64=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWu0KT/BE76Wm3q/Q2NwMi9aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTA3M2RiOC1iNzc2LTQwZmQtYjg4Yy01YjAxNDdkYTc0NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrBdIsf5/0+WYfqYaEikXoRt5C79Chbkv8aDD0YaZyGzsH\nbofR3WYp4fhgT0LBoVOUKU/USZNIsurxH1GebwoNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxciR5bE1vpecOvugdQ8/Fh5k\nF4kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKPqTOcZ7ICljIuxJuaYPz5p66MDCZMwY9ORHmCwHQRUCIQD8L2KSg1MN\n3RTysDhHcV3hJ+bE8Rie2HekdKsOpaV1rw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISASFkXUyDII10d7lN97G79MRwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRmYWUyM2ItMDUxZC00ZjNiLWE0ZWUtNjJlZTlkYjc3NjM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY5MzQwZGU2\nLTQ4ZWYtNGFkYy04Mjk0LTg4NGIzNDMxOTk1MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNC3UOt8GbXxMs6iW2rx4APdbXTnsFKgG03c+4YZgfQts4FJOlRp+GER\nzD8jsjXOwrfRUPEUvfwmAAD4ViiRYoGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCRVbBuR\n53BBx1cC4sfbsFaUbIaRMAoGCCqGSM49BAMCA0gAMEUCIQDNyxyYY1m+n9qx3x0u\niZlY4JciFPaG3dWuqYdYfOiTtwIgDrtpxDfpuSF2IxS1pZ1xhouswzOu1ORABKoX\nKDRatDI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc751", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `751` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAfpQdu3A6uMVObfyRbajPiGRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjMTY2NTUyLTEwYTEtNDA2Yy1hNjlmLTVjMGQ2YTk4OThjNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2UwY2VhMWUtZjFk\nZi00ZGU3LTg3NDEtMTUxMzI0ZTRiMDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn01e1/xcluAXkt5vmaHRytp/+qa/IMhSB0DrWApFv4+Uw7Y3abIbCs4wsYLG\nkj3XVxdeJ7gB4vOreGqtY+7WG6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUozzdJKNZx6DGxN3mMQdFBSpbt4IwHwYDVR0j\nBBgwFoAUK2vvCUom6W/nOmFmE5L1b/M4z4owLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEAc\nKi9TThELCpQdIHAEKVM0pP76Aw0iIR5bsnFJzQjTAiEAoxaRq8wzlQXIurMNH799\n1k6CnzJjNZipjqGQtJdEL60=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXZQTzr6GpdtlDXDY+WXHUaGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzE2NjU1Mi0xMGExLTQwNmMtYTY5Zi01YzBkNmE5ODk4YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtkWK13BNgY0D5DxcomOpImwor6o6GAr3VVlhu8JkRcP6S\npcl6OHY0CpI+Y4QGqNe0mFjXtS6mnyWwi1ahupwqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK2vvCUom6W/nOmFmE5L1b/M4\nz4owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOuAqS3oeha74ZuKSx/FtAijLCHNsyodTXM/DLw4GPiBAiBio9EnYFsV\n4CK8wOAKuwVLkn2EdVo+1F7JyGSKgXj7ZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAbb5JkbNVwZDl+J4d8cOVawDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2UwY2VhMWUtZjFkZi00ZGU3LTg3NDEtMTUxMzI0ZTRiMDM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU3NzcwN2U0\nLTJiYjUtNGIzZS05ZDE5LTFjMThiZTkyNjRhMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOba75mvRyC2i1genjncuUpOXug/xf51RyI1BiGoIoyBHXCfI4FdpM1t\nMbk5KTwT3AjfCVe9z0bZcicqQU+trYmjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKM83SSj\nWcegxsTd5jEHRQUqW7eCMAoGCCqGSM49BAMCA0cAMEQCIAyj/PF0dmaSbuJXG9SP\ntlVEVtSBXtT3K2McB+PQMziOAiBohgj4h+brPkvVfhuq4bHcGC5A935Cps2Ezk7e\ndbTjRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc752", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `752` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWAx5hTIWmRLhPovTJSaKfwWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YmJjZGU3LWY5YjctNGJmYS05NjU0LTRmNzZlNGRiMTdiYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdjMDIwZjgtYjE4\nZS00ZWM4LTk2NzUtZGFmN2QwY2JlN2ExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBBB4ZtJjkuoC9C8rSz9jDNWhbdNuxCkVULl6g1tE5SI9+YEDiKxC23ndZxQj\ngE+7lR34Ac0z2s4qCPOnsTXXE6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxTiSr0K3C/mMkWRu9SpMrr7J29EwHwYDVR0j\nBBgwFoAUlOYat88GsYCgHQrteAFm7XGuBeMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIB0gXM8clP4mZ3ouSedqas2eDxCFktMQgVakF4dRXCXCAiEAnb/p\nFvJ3BShk3FL1DszBftxI5tKiPydej+7WzYg1y2A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX3/mLOnfS41hnFLQlPVAxC3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWJiY2RlNy1mOWI3LTRiZmEtOTY1NC00Zjc2ZTRkYjE3YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7yO6erfIXVavmpZFPiXcgzAagTFBq/fMObeAhn/mKyNfu\nnsqZYnzcjncFMHHh9nSM1Hw+L5rPx1nmfpmLh3mlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlOYat88GsYCgHQrteAFm7XGu\nBeMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDPfRPlyfBHddaFF+Hme7iLFfl03ZvlHPZxJHAOtLlSYCIQCpWzruY1mz\nxC3UD6hKRKqwRR1fV7rOIzILq32dMXMJDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISARStjSeKvhoSsB3kKa2CDlMwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdjMDIwZjgtYjE4ZS00ZWM4LTk2NzUtZGFmN2QwY2JlN2ExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlmMThjMjRj\nLWEyMjUtNDdhNi1hNzM1LTk1NzIyMTk0MWJjMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIVhPaUe45QuphTkVfYU+wS802QZUQCrxHyTk+QFxZDS0BVzwrvaRDsp\nb6S7fuf7EqEKILHsItGjJ5uqnbHyNWejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMU4kq9C\ntwv5jJFkbvUqTK6+ydvRMAoGCCqGSM49BAMCA0gAMEUCIQDJE+cq9VgPdHH74rOQ\nn+ocCmWGIfKDUVdXY1vjzgBy3wIgKCufok0cVktkPaQfpVMpWgU2UTjsupSsFVIV\nVw3sMj4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc753", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `753` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAbWUtHEZ4iUrtB3REP9ETNp2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyZjZkMDgwLTUxYWEtNGNkYS1iOWYyLTk4Y2VkYzMwYmE2ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzllOWQ0MWEtNGY5\nZS00YzNiLWJkNmMtOTgxZDc3YzEzYjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjW4g/19NA8VTeRo8VGH6IIUhYQFDmKgX34LXUreksYchuyFRe+9BpIXBRJLy\nAJEG+SUn3pTevyT9YBTP1g8M2aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwYGOZVjAOm1MYoLP75bJaZ86+/wwHwYDVR0j\nBBgwFoAUHsMI4pMTQia+XvkANTcsCmsg/f8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIBJwvq6SHDSzuSbTlDxpZB2ld4vd/fQso6MuET0kd7ZGAiBIK1vB\nr3TLekLyXvwCdVHBYF/ksj6GTpYZZdW2XNCZBQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAauxP/TM3pp4/XtLMEWqWLvqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmY2ZDA4MC01MWFhLTRjZGEtYjlmMi05OGNlZGMzMGJhNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm2C3qTFB1m5B/hiy+1Gk36xLRZq5u4gOEmlXvu5S0nR5r\npaQSRuWZF3amDEq22faPRYg5Xlr9IuN4WumA+t6Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHsMI4pMTQia+XvkANTcsCmsg\n/f8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKYkZOasD4zBN5EOeNaROJhSXw/oqjCYWCeZNBxkwCT6AiAsbwdYGu+t\nEhs75LIEhB8JgTALT0VsyDyn6ylOfp0XMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAVPLWaFEWq1akl8Q5MuAb8OFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzllOWQ0MWEtNGY5ZS00YzNiLWJkNmMtOTgxZDc3YzEzYjZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk3M2FiYTkx\nLWYyNGYtNGZkOC05MWFjLTkwM2IxNWIxZDUwMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPkp4BX13KXut06T4EutEJIsvgANKUNFEm+Eer1xKTY7mCpk3R4GYMhk\nK2kAKU2gpEZgV9EQMv4oyNMhO6jHkZyjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMGBjmVY\nwDptTGKCz++WyWmfOvv8MAoGCCqGSM49BAMCA0gAMEUCIQDSia9dw759zqAf7kpM\nq7TDHdZpUwpSLdW/VVRiQhUDBwIgaieiOKDvNuXZG6J1atDa/qZLDJxf8mH+2AkK\ngV6yOWo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc754", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `754` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAdfH/tcuqtNUo8LNLanHg3PDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ZGFkNWRmLTUyZjAtNDk5NC1hYWY4LWE3ZTcyOTQ1NjNiNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMzNzhmNzEtYmY3\nZC00YzA5LTllN2YtZmMwYjNlNGI3OTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn2wWBwT6wzIeoGy25SbTkVi0PqQJ0987R28Ot3GeR0iYSpwvUAV9ncIADbT8\nSp+doaLyecxcxkZdm6VeiVBZsaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDHThgm2KxQbDQX+HzqjCiHGYj1/MB8GA1UdIwQY\nMBaAFG9yQJCZHjmoHLz1G7gOkIdEnAU+MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAquG0uccginB8Y8GbTkxB020u1jOEtGX0\n/UT9u2ulnXMCIQCcq9YDBxvpWEUDcjYRWk3AZUzIMABT9MIzv51Y1K0w5g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXUbcdd3MibJM15P1BoE+zy0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGRhZDVkZi01MmYwLTQ5OTQtYWFmOC1hN2U3Mjk0NTYzYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbs4UcrcYb6PF7Ebi/mojysDrgEA1ABR2fR5Mtx1l5RIBP\nUCHhNEQHQ5mYus/mpEZSx0u2oFI3HAzZ06tBetMxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb3JAkJkeOagcvPUbuA6Qh0Sc\nBT4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALyOjBC30QHF0bymFtCQFmWZaP4f+gqy0WvZRWSuKALyAiB0RbZYgJAI\npNd2oeCvuOlb6YGhTdA/MEGq5kwiv/u3rQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAbHHmmYVQFQfeM8G7c/IuVZJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMzNzhmNzEtYmY3ZC00YzA5LTllN2YtZmMwYjNlNGI3OTJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI2MDBmNzRk\nLTAyMGYtNGM5Mi1hMzE3LWIwZjYwNmJlMTdjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBt2XI5GgD6wTn1IGAYcVRYacizsO3Df93X2WraY2zP8IecCwOtoP1at\n9iltINrHmZe/knK9cByZy8gfNcA2QuqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDHThgm2\nKxQbDQX+HzqjCiHGYj1/MAoGCCqGSM49BAMCA0kAMEYCIQC7yaRCYh1kFQon7jGp\nBC/ML9CBJ8iFOzywS0OmEdbQ+QIhAJ347dMNypchTPAik/CB2xGzVWBALzizsxDY\nIOyEVMMY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc755", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `755` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWz0P9NsjS0CQ2sLqO+ZU1iJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwZmQxZjQyLTUxNGMtNDg5Zi1hMDkyLTdlZDNmNGE1MDU5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc5NWViYjYtZjBj\nNS00N2RkLTk2M2QtZGQ3ZDcyYzYwNzc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwNkVnm1pQguzOdVt0gwY9eiIV7l+322BwIEcciC87YVBRE/cY6ju8ZRZTiOJ\nbqvIEjvKfpBt0TxVC8PkzS04x6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb+rDjSG+NeFtWqKk8+F2mSj3jRYwHwYDVR0j\nBBgwFoAUCt4x7lh/VtTlVGWholOiWTAY99owKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANWS9iXkg+jt\neDi27DnvrAxrn23vwgDmy3pNHFv+i8mtAiBJVThjicAvasJ2DOmka7iG50ADh5nu\nllBq7zlqWPOksw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd5PnwDt5pJCV16NqRXlGxWlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMGZkMWY0Mi01MTRjLTQ4OWYtYTA5Mi03ZWQzZjRhNTA1OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEyBGehqBQLeU4rCfNEQq1A6fmOg75SJRdOL+5BERjZryU\nh+qrVGYZrIKK6rQODj/QB0kmvr459TCTA4IZfK5Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCt4x7lh/VtTlVGWholOiWTAY\n99owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANjIbwVZjwDxNbcHf+GM5+f3SZWBsf71L2VxoPoPGtaFAiBU0XZ2DonY\nxBsrdCtN4awXcez93y6b6fRMUMo1QxOmoQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAUuSbwlfcVEOmSKl22o6waeBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc5NWViYjYtZjBjNS00N2RkLTk2M2QtZGQ3ZDcyYzYwNzc0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY5OGNmNGMw\nLTg4NzQtNDBlZC1iNGQzLTVkZDJjM2VjZDk2ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFQPRwQIDreoodmStgFpuVuO9TMbMlBTtgxlaWhWtJw8uIZAfyOc9aXi\n18FE/iCK5irly8LEDDSpsEgDxcyHEWSjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG/qw40h\nvjXhbVqipPPhdpko940WMAoGCCqGSM49BAMCA0gAMEUCIQDf7LSdNqVnwIgTamDr\nAaXCWfZFUM5zrH2O8F++9EYruwIgAeDPhp3HxmPn/przbMYqDgcBKXwSAxLe0Mv4\nPmSNdYE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc756", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `756` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAREGcW9dyFuKwA3E5ORy5DwLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyZGUxMWQzLTgwYzEtNDQzNi04MDAwLTFlMDhhMzE4OWQ0YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVlOGVmOGYtZmQ2\nNy00Nzc3LTgyYTktOTI4ODYxOWU0NzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYHLNzBidhEZMJwRY5JRoo380IyMa9QhUUb0WCtEI8TaE2M292KJS91jzSWOa\n3PL5DMnH4WLFz0plvT8t/uF7w6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhUIwZffQpr8/Lyx5slSoStLzDVcwHwYDVR0j\nBBgwFoAUpCKiH59qRCr+LRk/wtpQm/K9hwowKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJvGybe2azoV\nLMJAM1rW3UQb9Bl+fBGw3MK9POp94IR1AiEAwtRdNa1BjxTqavWiwTDobp1MuNKC\n2h3MIpYIk33twJ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAagvS+kegzLq0j/+CpFWafGxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmRlMTFkMy04MGMxLTQ0MzYtODAwMC0xZTA4YTMxODlkNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvJGCGCsG2LP+7QIHbjpLtVS88sj1k0/jG1J93OFHTLFpe\nFYaAVSxzgh53A+s3qboRc7nHEUgPo9yKvaNWBJ4Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpCKiH59qRCr+LRk/wtpQm/K9\nhwowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMpL9CZrJmOpBFa5gSqsE2hXzrBQTihvKL2s/t6sZg1aAiA48YPG5zRB\n/vozUZXedrUqlIGwLNMGsKLjMiV+C3+N+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAapYyBw8zFyJXB3MXGjLqTt/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVlOGVmOGYtZmQ2Ny00Nzc3LTgyYTktOTI4ODYxOWU0NzU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGExYjFmYmVi\nLTk5N2YtNGZlYy05MDc4LThkMGExMWI0M2U0MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBndbZMYBu+DTWS1vXDIm5f7VCTBFW0txJ06ZU8AqMiz/aSPWhL2GQ9r\nTfgSjCUPRODKmC1ZUneuZuAJk5bjAa+jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIVCMGX3\n0Ka/Py8sebJUqErS8w1XMAoGCCqGSM49BAMCA0cAMEQCIByTSWeyhHy9Cf5OfHzp\nf4PIBdftFV+nUAiuo2mVMNuVAiBb4bxWQpKGgc+6vcCsYCEigdbVcISUhY8fU2v4\n2t55Hw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc757", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `757` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAaybZnwDZaJRU38WNtzn9HUhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1NjJhZDMyLTUyNzQtNDA2Ni1hZWRiLTRmMjBjNmY1MmFiNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc1NjQ5MjMtNGJj\nZi00OTUxLTkxYTctYjJkODU0ZDNmYzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoSI/YY2/HbAzFua9By8sNhEhGCL5NIWxV/e3OZn5oj6U/Et73Rm88SO1mSqR\nIup928cKA3eW4A0hULz8XEXK0qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt6f72tOsGrSFqITfU2rlMk7/bEgwHwYDVR0j\nBBgwFoAUjo6Tmv7DpVIGVUQ3CvcA+YoYf4cwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC/Q9Y6vxAe\nxyo6tjFkaz6rPwgJxnynP13XZ7PYEUGQcAIhAJrKkRf5KKFthHnykTBW6aJ2JOOo\n+8Q8VzHBDOgcVfVu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfz3Oaw93ZFMb08kUIVRC+uuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTYyYWQzMi01Mjc0LTQwNjYtYWVkYi00ZjIwYzZmNTJhYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5vqqKuDA2l0gOPyMYPpPYXJnRd0dAuW37BBNyqE61MWPN\nRtbzFLxoG7OLNkN8neCR1kTnrGoT/1eoqkLcB9zDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjo6Tmv7DpVIGVUQ3CvcA+YoY\nf4cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0D3PuHDx//QLY4jcgMsy7moru786cblBg8sWT/lLxOAiB/uW0ojItw\nJmu4uvm1SHGNHnbWyxpOYCvEMy5NsWpnuQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAdLQPVbEmmEvWiEUvEpF3UlpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc1NjQ5MjMtNGJjZi00OTUxLTkxYTctYjJkODU0ZDNmYzk3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRiODdjN2I5\nLTBlZTItNDhiZS1iMGI3LTBkYmU2Zjc3ZWVjNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC318xnWMn3r6aULHWmpoV9lUeM7l7sLZGYJrNdPAA1g/lFYmB+OKoNc\n7cp60ZMF9c+ZCoH9FbqQGorl/vywSCyjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLen+9rT\nrBq0haiE31Nq5TJO/2xIMAoGCCqGSM49BAMCA0kAMEYCIQCbRDyDI67kjZDYP+Y1\nI9p11/WPkuC2EaGjpvKxfSmiaAIhAPtoDc3OrCJh1PmMJ74j+0vObgEl+OMXYnh/\nvWlfQT5a\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc758", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `758` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZUvl6WwBGFUixMdGBeixt77MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNTY4MTk1LTJjMjItNDg1MC1hNGM5LTYyYzNkNWQ2MTNlYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI0YTRiZjUtYzY4\nMy00OTAzLTkwMGMtMmM4OWJiZmNhYTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEune4r6KF+B5Eay3N24QovhXQk+8TpCmprjvYW3sNf7tUG+7QgMTDUbjq+ICo\nhMUn6JrmUCACzCaOhf4xAavCraOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIcAP9uB6X6CzMubGgN4mxkn8eZ0wHwYDVR0j\nBBgwFoAUzKeigW8Da3/zztRoR3rYW6FW2IUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDdjyJ2BTIrV8UkzsLWs3TexlQKOiRHumSqELO9ZomIiwIhAJGeBUrgdUG7\nwg7nxiL743pc26G8R7jbcTQvUyAOZ0+e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASFP5KjT2eCF9ZCucMMSVi3FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjU2ODE5NS0yYzIyLTQ4NTAtYTRjOS02MmMzZDVkNjEzZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZfUQ/34Zad3+KWSK8+lX7cB/FXpB+/SBO1CYTMoWD0o3S\n/MaBMzKWfbq/4e5uVhQBnt4LQ8OSWAbsZNMo7lE9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzKeigW8Da3/zztRoR3rYW6FW\n2IUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSlETvxXDvHAiFtHqS4gwFvbLOfKW1+M+8GVmrlmxhPoCIQDV204pDh/G\ngNBYXptvLZ6Xny0KJOtNs+XuNJsuEAG1AQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAb40DdL+6FRDWPmXLLLGp4BaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI0YTRiZjUtYzY4My00OTAzLTkwMGMtMmM4OWJiZmNhYTIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRmODdjZjE3\nLWRhNjEtNDJlZS1iM2FlLWYwOGVjYjdjMTk4MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO06Oc2ueMnaJbC3qZfC5CHtt4xAKrXTUB7uybL9V4dPpm6Zp8fulcxP\n/NzkAfF6cgzF0u0CcfZlDkcU47gIqq+jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCHAD/bg\nel+gszLmxoDeJsZJ/HmdMAoGCCqGSM49BAMCA0gAMEUCIC0vBIa5kPLobZPwOJHr\nZ/LYhKogUjM3y0pXeRgBNjEwAiEA0t7lmvN+EC1v3fKXDB0eI7fvZVh/KiNuxnyd\nb5+XWu0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc759", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `759` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAd1A0+nKjQfJSqOgDjN20KVQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlY2UzNWM0LWZhZWYtNGNlNi1hNzk5LWY2NzczNDZkYjg0NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGI3MWI1MjEtNzE4\nNi00ZTZjLTlhMTEtMDViYzM4M2I5ZTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOWswTDqor5GqYmZXdYo762EqI8AiN7Mko2bX6sX7fvt+HIHpZ+BN8TwRYL+J\nr2vF+BzxJp3Jk/RrUvQCFK1O+6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQwg2O+QL7hXtszS1F7sCKsY7wMgwHwYDVR0j\nBBgwFoAUeIlL1Fy2uauvcUWgbb2MN2c2gngwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIC67epokvQiW16fA+u9AnpmYkQBEInpddevR7VPQHMLuAiEAjtmUy1TGwriI\n6P7PoeYnSXF32iWnE/Z8Wud7jjCqkAA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAadvHYAHOV8keKAxxDHmJvCUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWNlMzVjNC1mYWVmLTRjZTYtYTc5OS1mNjc3MzQ2ZGI4NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTM9j0znWyhdGin75DQ3ld3EYigNzIM9H1yoK8rq3XNffM\nGx98Mpt+uFsFqRB+w3qCN8z3JTwCVwdhLPl04667o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeIlL1Fy2uauvcUWgbb2MN2c2\ngngwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOGRT4DiB2LKgkzepVkEczqIaZSyPdI8/+RS16X3KD5xAiAOOZ5m4OLl\nPVyOTPJINPIbKlxilRSALA8baSGZYRHHdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbegAwIBAgISARt1B1XpGeZ52Q12U275pkOCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGI3MWI1MjEtNzE4Ni00ZTZjLTlhMTEtMDViYzM4M2I5ZTQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI0OWI4ZjMy\nLWZkOGQtNDM4OS04ZmQ2LWJmZmZhYWZkNTMzMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKz5z1LlrVe7yjIHpKkz7c1rcfmzK7nHbYLCG4CXcTgWzEfmNwGUGAb6\n1PhakpjBG7orb3KurWz+D/AIr48JXLmjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEMINjvk\nC+4V7bM0tRe7AirGO8DIMAoGCCqGSM49BAMCA0YAMEMCHz7my0asfmTFQ7N0oUvo\n3KaSo90Ac3t5hvtYPpL/WbkCIFQtwc29VonsZ4RPzr0eNJsHXrF6XYpV0qdLELyR\nAThM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc760", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `760` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAa0JUmw+slFyE3VK7EuTohG5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjZjhkZGViLTAyYjUtNGI0MS1iOGY0LWI3OTUwZTEwOTcxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU2ZmE1YWUtMTcx\nMy00ZmY1LTlkOTYtZjBjNzEzNWY4M2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzRExBFOQ4PzTjsj1D2zdVJDN+lcWCoAfSmCWLLHUwSAi8Y00mKYSDEwcVKRD\nfQEMCNHFNQLUjj+UL6+vmA025qOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJCesw4K4oN16vSjaeAs4JLhfwF8wHwYDVR0j\nBBgwFoAULmyxgz2d/ogaHsbwi3Ije3M+6IIwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCK\nkzQ0WIePVvDM/SxsaskzTkVBbMjqoFfGeX5Gg9Ck5wIhALkb6KucyU1fwmSyk+ru\nSJ7dTyTNxvy/KXEnezlkAUDJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdm3hNoa/xxJ9qAv9JTFPyKYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2Y4ZGRlYi0wMmI1LTRiNDEtYjhmNC1iNzk1MGUxMDk3MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzCsrIriyD6oaKh4TROUUsTqTYIx9Ec986pFEMvrP9CTk4\nhZlLzayA6CYY+8KuB3il0HqFbWsiPLWgBho4xfBlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULmyxgz2d/ogaHsbwi3Ije3M+\n6IIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOq9KvbjrjxuaoDuCcGJEkBxpM0mFzAnQH38N7VPoypcCIE/TPXW/2JEU\nIJGMv0FdlWTRjaA4ydjhKIgy7uX1suy2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAY5EP6Pcdxx3KkZE4ox5EXKrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU2ZmE1YWUtMTcxMy00ZmY1LTlkOTYtZjBjNzEzNWY4M2JlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNmOWNjNjgz\nLTU0ZTYtNDY0MC1hYmZkLTBiMDhlY2Q0OGQ4MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH7k8Hk2ZirR51DklrxllXELljlJLgU7EFqeEC5VlLXDnGTc1HNrW7uf\n/QgY5Ujws8Rnj2qBUH6z/cfTWwVHEHujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCQnrMOC\nuKDder0o2ngLOCS4X8BfMAoGCCqGSM49BAMCA0gAMEUCIDs0R/Ndsw6HgKPMduhL\n5gvdpR+XPW18EUOrqtQr8kmOAiEA2JtdbV+0plG/u8O/lDDou38ps0JQsP9U2R9o\naQtBuug=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc761", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `761` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcg7XgwRAFSV1o+vgWyyGoFOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NjRlZjVmLWM4YTYtNGU4Yi1iY2YzLTEzZjRiZWFmYTRhMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzIxYWRlM2UtMzZm\nMy00MzEzLThlNDgtZWNjMWI3Y2IzZTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5I/m+pgauRxsEBM+0o3qY3JRueU/s5COJFh2T7SHElU6NzYJBCAduzaSjTnR\n7YPppv15yqCka7227RazMHm/dqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULsmEdilmT2AAsl2fTthSR1yRrLgwHwYDVR0j\nBBgwFoAUJwEsuP3nONei1AlQcWWLrNEvj2AwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDDU0FVatwEtqytA2DnuvDnMvCoLQyke+WUzPTs2DaniQIgJ/Cs\njdvPIdQF4GukDsi1J5Yzx9uo0niAjN1K50PXU7o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVvgIB9gE70LDTn7/VWPPbu6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTY0ZWY1Zi1jOGE2LTRlOGItYmNmMy0xM2Y0YmVhZmE0YTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEZMk5kQmWSugRZsVMjXRpryqIc5VjSaQtgZT9RTyrjU4I\nSX+gFqkjr4TmiRmBW0DisV9zvKrdjx6Agv8+Otw+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJwEsuP3nONei1AlQcWWLrNEv\nj2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANB6/pmvQpAl/OJlahxDQu/MXW9xHBggUCTTqji7CgPhAiBwLG6eEq37\n/qRi9kygtFLBG9WDxxvzK3bCk8521Pb77A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISATCWS1qUaFvNUwdLRJhKAfXIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzIxYWRlM2UtMzZmMy00MzEzLThlNDgtZWNjMWI3Y2IzZTkwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDljMDQ5NzI5\nLWIwODktNDI1MC1iMDdjLTM2MjM5MzVjYmE2MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCSI+er37VEFudHTvn2+kJTn/tHi5MnHiwQnRjU3TxRYWCZqdRBHX+z5\nQjseo6vNJVRPIsm7PiI3MB2m8VrosMWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC7JhHYp\nZk9gALJdn07YUkdckay4MAoGCCqGSM49BAMCA0cAMEQCIDJmg9t9vxWSIH1kRlXe\n5l7Yw4cthbuvsi6X567UZIbMAiAPgR1VPBC5KdpHVmR59c+nCFCcS/YvCLVIwtVv\nInnzPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc762", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `762` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISARfWENIOtbMyrahdJOLPZABTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjZWQ5ZDMzLTVmZGItNDUxNC05NDk3LWZkNjIyYjNiYjg1MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ2ODk2NGEtMjdi\nOC00NmYyLWE5YTMtNDM0ODBiYmVkMWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGqDQzkfqLFula7ibP6qer4xQ11FXBrfz04ekHL3m7SFGS1AHNxuSQ72ooW5T\nDEODnuLVpJDuqaOLVZBk6I5TZqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsTRAvD195latlhmoyZXkKvdgmTQwHwYDVR0j\nBBgwFoAUgXdu479X5/mG9Pi9k6gPqeiAa2UwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCs7rGjNxAk/Ecin89EZ/PzSV5uT2BSsbUNspHxDxSc0gIgCLLi\nWLZD00AL3XhofIgLLDvliaVuv8GBzmkbGBjLJr4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfmJe0tCkFIJYOjfuOXt2bbxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2VkOWQzMy01ZmRiLTQ1MTQtOTQ5Ny1mZDYyMmIzYmI4NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToJ7R4Q/RP441dvp7D9uwdbtpNIrE2XwB0K7BC9qe88k4a\ndyKumSTYsKBGGTJL8Khs1H1aBbF/VlafaDXvI6kno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgXdu479X5/mG9Pi9k6gPqeiA\na2UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbHtT2dFKCriLEgACxJNv9l+5PEu1kGfScpkT/Gkqr/sCIHkDikqflrfA\nQe0T7/etSRQUxZ8Xtn4mkFjsXkN0//mU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAUwJujomOQAZWDd6xDZW0z+pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ2ODk2NGEtMjdiOC00NmYyLWE5YTMtNDM0ODBiYmVkMWM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUzMGZjNzQ4\nLTQyMjMtNGFjMS1hOWE1LTdjMWFkMmM3YjM4NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCs7DFQOUnzf8rhsrRjLcSy9Ncr9OFHrDffBHX9h/bTJTQkgzN2gpfns\nc2uzlqP3xB7To1HeN7r4C+w9Vy830VOjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLE0QLw9\nfeZWrZYZqMmV5Cr3YJk0MAoGCCqGSM49BAMCA0gAMEUCIAWjfqeYCI+RrMU2nxSx\np0kvrCyKDZqh6kn1gKU8o55RAiEAkT6ilcO1YwX6Qn3dVIJ9OpUEJQCSqhfUFXx5\nSKOYCdw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc763", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `763` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAeJ1jWs/pxA8WGfOcCD5LXyFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExZWFlOWI5LWRlZTItNDY2Ni1iN2Y5LWQzNjViOGM1ZDg4NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY2MTAxYjAtY2Zl\nMi00M2IyLThkNTgtZTEyYmRiYjI4NDFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK9djeANHRrfDyxCRTcOQT8UKf59fL+ynD8CHPR6xyXDHOS70geZZ1aKhpuw6\nxQ9SO1SRIEJyQxzUhfs/ADgtNaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSIP8YuLY6x1Q+0bRS7dehqVccUZjAfBgNVHSME\nGDAWgBQPpFyb1DvqASKW0b3ePnBf9RAXGzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCtzVOMw/VQ4pFNxjOgBKB4zJyHlO6p\n26gd48gUHq6e6QIgb62Ark15j1y4etvHIYqAJd5YrUN4Yj+H2xgLSCrlg8M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWakDddFuKJjfPD+tCXTjA7IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMWVhZTliOS1kZWUyLTQ2NjYtYjdmOS1kMzY1YjhjNWQ4ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlN6K0gnNrnhPk0YU8fiwSVfIqF17rEOoSCicYWg9RD4gW\n+YNPTW3Uym4xg6nVBVJBPRGshEovAgrh7q6Sg4wSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD6Rcm9Q76gEiltG93j5wX/UQ\nFxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQzutt/mxFLrknyjtKpP00G9nM9yzlX1wZmniFwYg3/YCIQCSQt7/afns\nz+W+L+UsTGEjzbivTBTmdQFcReqR5FYUQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISARHnRp+z5N0aDqOJsVGZvW9aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY2MTAxYjAtY2ZlMi00M2IyLThkNTgtZTEyYmRiYjI4NDFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDczMWQ1NjRj\nLWYyNGEtNGNiNi04YmQ3LTdkZDU5ZmVkMTc0MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHE6EQiGainY9lStWOSNJMzZqvvBl7ifNop/VcBdSYOjOFDoDpgHpD87\nk2l1TQgwWV6MiIyeOK5eEDGRzZYTseGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIg/xi4t\njrHVD7RtFLt16GpVxxRmMAoGCCqGSM49BAMCA0kAMEYCIQDE0YgGEeeo5nRaBA3l\njyhB6J3iGJ9RunQCynIKUnsrQAIhAJY7i0GYNGCz7q1c2zsCjar84QJShgXoFVkT\nxE1JtnJn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc764", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `764` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAftzRLvmkA34HqIfY9NL4EIYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZDVlZjNjLTI0ZTUtNDhhNi1hMTA3LTE4ZGE3MGZlM2JjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVhOTk2ZTgtOWUy\nYi00YTkyLWI0NzgtMGMwNWVmZjE0NzVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe2RpFMmKwItmuU38LmvWEeNFCD9vvIY47g2+dAqCvb1tAhALOi5wrqpGu4RV\nGiyHGPp2D4ru9LRRwUD8/i7FR6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7yynMUeU+M1v4Bx6WchHqjWf8+8wHwYDVR0j\nBBgwFoAUkgiSligOHOBiROjXF7TE/56X/T4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDnkBkr3VFF\nEkGqLnNfioeSpco8xexr/4tAfnR2SeYpOAIhAIcUQmTxGlAm7vYgj5azLVS2KNcE\nj95C2g1/J+eX9Vde\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUlmZdMDa7vWs3FzcQBEyv64MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGQ1ZWYzYy0yNGU1LTQ4YTYtYTEwNy0xOGRhNzBmZTNiYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTP1jsc29mP259V9Ln/ai6jHEq0lq8C/h4gBYOh96BcF2W\nIqQO8nmCUoyv6aH3r+Xmvtd3xtZAxOiZjwbDBlzko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkgiSligOHOBiROjXF7TE/56X\n/T4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgInYOs4K3PVnErp48rbaaxse5VekUGAH6PZj6r84YB1oCIFnTdKO0K0BX\nie3fst7g/v4/xUeeA/tCsFIut1O96PGN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAeq41+Adc1UMQGpQm2YECEMJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVhOTk2ZTgtOWUyYi00YTkyLWI0NzgtMGMwNWVmZjE0NzVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDExMTliYzll\nLTExNTItNGU5OC04ZDc0LWZkZDdiOGFjNmQwMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAXHGGUd5oPXQ75Zd9+T0LkyLimZsUY+K8oyI/9w+QAQBysHkJKruQX0\nn1PIzkudWgDBPP+cVdMrI/pXpHhulGijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO8spzFH\nlPjNb+AcelnIR6o1n/PvMAoGCCqGSM49BAMCA0gAMEUCIGuFFHiAh5kFNbVL17MO\nKFxcX7RohorvI4mtT5TQnnp8AiEAzWxhvGSRDQNeIF70v6Rb2meifoQNVbkSr4ib\nknTY8dg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc765", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `765` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVXAhic4wsXcZB/4JOhTibmpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlYWFkNjljLWJkZWEtNDczZi04Mjk0LTIxMDU4MWFjZTYzMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzI2MWIyN2EtZjFk\nZC00NzAxLWFmMjEtOWNhOTA4NmVjMzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVoLEKVsxNWnI/K8f+ZVPQDZ02AUEFwzXVBXhKEqfqx3l9Qy6AKi0RFni5LW9\n/db8BGy3qvSSdi+5X8cRE5jQUKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMVqVDu6Xbd0lOlkOuz8xKv1WGO8wHwYDVR0j\nBBgwFoAUWDs+pHMo1Jek83k5n8zW481ZiU4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGRfmPxF9zxw\nImQl//GenLP4e4m9ZoZDM1t/Fa6e6P4xAiEAxSs71c+wRrDsGvl7B1lytAP6QHwR\nFYzvrnLyLOVhmJI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbRllkaw3GMZJBGaIpM7h5LdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZWFhZDY5Yy1iZGVhLTQ3M2YtODI5NC0yMTA1ODFhY2U2MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqasdh0LNd/ts593PISYHcOhXAa8ElprcgHdgJtGUJIM3l\nPsVW/yR8FU02xs8M6fj92qRIAOkV77jhMVzq3g67o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWDs+pHMo1Jek83k5n8zW481Z\niU4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfpC1umByPIeivNzong4xI9VR8UY11hCnSFTwfxKfl5sCIQCJWNs4rt1c\nJJoSwYiacZO6693iaI7keHsKFd1eNnB0mA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAbdHw2r8PNiPXurXNdv1YC4YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzI2MWIyN2EtZjFkZC00NzAxLWFmMjEtOWNhOTA4NmVjMzk3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc5NmQ3MDg4\nLTQ2MjMtNGFkNC05MjdlLTMwM2E5ZmRmZjIyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBTLmbDYQIOaBMQjnZ7iNX2k7dpqN3IPAvtYyORlwHBGVY29V/Kw4dVC\nTcew6+/6S0FjoNY87XO/Y1BYlVw9IzWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDFalQ7u\nl23dJTpZDrs/MSr9VhjvMAoGCCqGSM49BAMCA0gAMEUCIFRz1KNM0rCvbVRr0x67\n7QCfHv+nqettGwpB+9KRtYHeAiEAlPSEIqRtDPTiaw4wElhxhYuw9wzr/1+1nsOu\nVf1xfYE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc766", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `766` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAVeMeKlgYB5kRX7xnoiP8f47MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MzRkNTE0LWZkYjUtNDAzNy1hOGIzLTVmYzYxY2JiNTNhNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZlNzAyZjUtY2Fk\nMi00NDhjLWEzNzAtOWU1ODMzZmZiMWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ101qDS43y+atTcJmhrrlKdQPZE9jKgj9P1ZbFpm9dgQvFk1xaXbqTxhZvpE\nXWr12J3cHXiTzIyTfIaQOf6dXKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUobt1AUJY7WNRK1PPysg2XuwLSiQwHwYDVR0j\nBBgwFoAUmfS90idYb9GI/9GODRwzzDpyD2QwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiACK47aUZCQ\nsYD/xqI52nYQGK2m2Z3cP9zWZvYT5s6KMwIgb9HROVqQZzZs+Sf7yWFR8obhFoq9\nFs+WgO9dLhfEcK4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXUI6d7Hd9nlV9UJyyvlhaAUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTM0ZDUxNC1mZGI1LTQwMzctYThiMy01ZmM2MWNiYjUzYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDQN2aysNNYXFQWk0ZQo+jP5tKx6VvJyZlZAxo6uQnMTi5\nASDjSV6/8GzCHWa/NZMTzq3YdPYtl0CIQsUIbR7Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmfS90idYb9GI/9GODRwzzDpy\nD2QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbLbGHhcPw9TocmYktV8l1nFhI1ZMeYZ+MRfOml+X3dACIQCH/mBQ/JKC\nABrnFEKibrP97p/MpXZ9nRF5jXcPGqlJaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAfZAT1uMC1/EgIHDzKw3GmGLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZlNzAyZjUtY2FkMi00NDhjLWEzNzAtOWU1ODMzZmZiMWY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY4M2FiMDU3\nLWVlZWQtNDc0Zi1hY2RiLWUzYzk5OTExNGI3YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC6ovp7iETzLd5ByLfIZGkt73MO3AAqbe/alQKjAlFcRfa6UoQku5KEK\nkq9IwczHKOaFFeim2aXEwcAT2wWPyDOjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKG7dQFC\nWO1jUStTz8rINl7sC0okMAoGCCqGSM49BAMCA0cAMEQCIEE29pKw4oSA5u0dkgmT\nsQ1j/YN9onU3x3RyQkNm7EznAiAe/KxqQMUAnqXh4+MsHur0BlpcY76MwXQuJ9mj\nt2CtDw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc767", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `767` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASmbeMnXbDMfXUQED5wjGBKvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyYzhlNzhlLTIxOGQtNGM1Ni04NWNlLTIzZTk4M2I3MTcyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAxNTlmZmEtODQ3\nMC00NzIzLWE2ZDYtY2MwMWU3ODk1NjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi5vWdMn5ik0F4XkLAwEEOnkzXe3zQX+lYUdCypRgg6VYqKAqhb3cNJ7Y4Zpj\nQsu2wrPi/EZa0Qbi6DH/4zOb1qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKmZm6SW2YBQYCxR17Q13dOJsDb4wHwYDVR0j\nBBgwFoAU9jbvEcp09m61LSLeIlQ6JwhGHY4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiA6sSr3akKDI9ESHrhlm3aqfeDO+t/QgGIlRtaOQUHVcgIhANBbPH9466BW\nBm7FS0EhNCXYtTu0hBIR/94GOh0mStXB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUbUL2NvqyqUtJi3xbaHG9c/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmM4ZTc4ZS0yMThkLTRjNTYtODVjZS0yM2U5ODNiNzE3MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPPJM5xNKYaQXenG9v2siPOUHiOJmb5fFSIWzliUldX5a/\nNj2kQqGgtAedU7a/bG5ji8z/hRKIhHoPe6kl1mhlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9jbvEcp09m61LSLeIlQ6JwhG\nHY4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPjoIBSaemCTEzrW6v/ihPyDwS49/dqnoZxer3hhyTwXAiBG1MVtwr3C\nMT47GZnzMWyPixqF4z1YYI1dpDTLC2RDmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAXE5wFzq96WDX4Zi5pwuxSVUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAxNTlmZmEtODQ3MC00NzIzLWE2ZDYtY2MwMWU3ODk1NjAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE3ZjBhZGFh\nLTFiOWItNDViZC04MDYzLTc2NDgzN2EwY2JhYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOqbCrit//gT6PuZNDTkIoJ6d8UTX9dDKU78hC+x91m9glh+OS7SoygE\ndL/rCoe26M1/EBjcQMJp/JN5hM5upwijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCpmZukl\ntmAUGAsUde0Nd3TibA2+MAoGCCqGSM49BAMCA0gAMEUCIQDDA4mBkNLE4bf4ccG6\n+w7QMIxVibe88wIqRS6Qkcr0SwIgBAFCfzDlo3nB6QD3Fiu7TA+2Bgon7wOEXCl/\nzqa5R/4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc768", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `768` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAeb60pPXJUG4z9teT0+7mJcJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5OTAzNWE1LWU1MzItNDhiMS1hYzM2LTIxMmQxYjg1ZWEwNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U1MTJiNTQtY2Mx\nZi00NmEzLTk3NjMtYTk1ZWFkNTgwMGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz201oRejfwLXvaiZSzI+5wBFKPbvu3zmRvpRUp0sX0fqWbjm+a4wPagfbNma\nnyIQjbn4Y66/PWYyrgV53br98aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqYqgdrg1EHjp2I9dSwfQ4DnEVegwHwYDVR0j\nBBgwFoAUJKBBSk+nqFSyishbqiWHYCG9MMgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAka92VGu/SrbXRufbhgjhs4ZlIZcpj+STjbE+AGukreoCIQCDaqWVhMR8\ne+7tYlxgG6hWG6N/8TwQHrq445Y8vTTCcg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZv6gf+50kJ1Dnqk+yzRLYWAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTkwMzVhNS1lNTMyLTQ4YjEtYWMzNi0yMTJkMWI4NWVhMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBk1uMxhkE6cDcim6o4BkLbKiPwg/aLuwxlTlkD6gFrsEM\nmvG57+p7aaHXLgJclxcfLBn84lDrg+thZG4GEY2To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJKBBSk+nqFSyishbqiWHYCG9\nMMgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgd95zJE4nVDZsWOxl7C6bWo2SZRH2q7HyrECiHp+Sy0ECIQCvQcRcYTAG\nfpysRm/IcYHf9Sa1jOCUxsVuvkeus9Gz/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAVnQ5NT8Gy9rWC/0ColFxYTOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U1MTJiNTQtY2MxZi00NmEzLTk3NjMtYTk1ZWFkNTgwMGMxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdlNzdmODc5\nLTNmYTMtNDAwOS1hOGM3LWI0M2RhOTQ4MjY1NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ5YJ065UaSZTKezIPMxl3ZBxQPSkVvAelVSk2UVTx/cc5LhiwOhe6Rz\nmSLNlbKzXPKg8zez+r0BGfIVbrP41gejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKmKoHa4\nNRB46diPXUsH0OA5xFXoMAoGCCqGSM49BAMCA0cAMEQCICnelMHGnEX+6+lh3X07\nipLpUu8KAQJqGO15gF+dY+XlAiA2kzKNv/lBO0x+2S/6ZBggvY1ryOfNwif57XYi\nTsTMPw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc769", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `769` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISARxER5n5JxYMUJ0X04GZM1ibMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMzQzMWIxLTVjN2UtNDNmZi1iMDc2LTVhMjI4OGE5OGE1ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU0ZjU1ZjAtYzA2\nYy00N2IzLThmMTQtMmYyMzQwOTY2NTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbtDg82UpOTSgy3zPr/fkSfHupa8tKR3mL5+Ycpj/KrT7Hl9spWbea2bg2dCN\nk5ePsu92xzjHEc4z8I7D/TEp7qOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg2CzBISc4BFoOo53/NuLRmLiKHIwHwYDVR0j\nBBgwFoAUrz5RAeeE96SxH342EfEwSUrXWi8wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\nraGE2kv3iTP7kfz+mInnb3ppt1kpTTRjnp54iKHbYEMCIF9OiSUXUAV03Xn9oQUc\n6eX6Hm6UQqYatUaO0zCZjyz2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbDNqVpgBVJ3xm3AYMfzEZrKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzM0MzFiMS01YzdlLTQzZmYtYjA3Ni01YTIyODhhOThhNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+oqOMmp53BWXvdnqSKyFQYlXIeMJwWYL56xjN0xyBU8wD\n2h2dzxlwLuoAoFrkKBkSPxrgPinQfoSrjb4Gj8R0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrz5RAeeE96SxH342EfEwSUrX\nWi8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc4mZNNBwoGLjOdCObD6GKlBP/nIUosQcUSzDkzzaPGQCIQD1cjPN20nQ\nhLrfZDFUbUiiQxWhKcteiVEgb9bgBycRvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAVzoXzokQ+McDNKzkomuzASoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU0ZjU1ZjAtYzA2Yy00N2IzLThmMTQtMmYyMzQwOTY2NTA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM4NzE4MzY5\nLWVhNmYtNGY2NS05ZDM3LTU1Mzg2OWM4NGY5OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNyl5tDQV8uwEDXOWe9MwGH7mPvWBJRADZzt7FubGQX+17AMpuqQZ4g9\nldQQlRUqMwtJ6XMhotxfQlt6/tB4ApSjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFINgswSE\nnOARaDqOd/zbi0Zi4ihyMAoGCCqGSM49BAMCA0cAMEQCIAig+Msy2cgJpfozIEgJ\nIofY+C0GIUFPZriNh/ul/6LDAiBaygoGlhohRiyxvX+el7wpT4/p9zC/GACS4/iB\nWM6ZIw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc770", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `770` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAdzqGzkhR3nlzQJelW89IbmgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkYmFlMWM1LTBlMGItNGEwOS05MGU2LTkxMDYxNzIxYjU2NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU1Y2Q4ZWQtZGZm\nMS00ZmNjLWFkZmItMzFlMTY3Zjg2NjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpOxyZ/pEQxfjLkbSsnBYtivObQROEzABeb5KWtpII366O+GGoHRumD9sON6Z\nPg9Ey1SpLsgTxN9ocFFWHCpJJKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8zkB/OCQlhs1zGvY/YWDThHEnL8wHwYDVR0j\nBBgwFoAU4/927a0xXcjp2L7CgFzM3DG7oFgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAjEp+neYRTzCd/4RXFFyiW5j884pxE02qtVcr2EFJrbcCIQCg\nNrz6TfmrZV4XCLoZdO+T8q8sy2P8+He32cvawM/e3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX4LnD1wnVtl6XBB47gP0hWBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGJhZTFjNS0wZTBiLTRhMDktOTBlNi05MTA2MTcyMWI1NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT88BYAmNcqUGth0folyusToKqWiES22QKXBr8isV+XiL0k\nDphL+N0knph6beBivNAjD9HkG3I3Vg8cjjzmJQhbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4/927a0xXcjp2L7CgFzM3DG7\noFgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgczCN5ZYDgrFwONKj+HF5wN6djrFFpkfy7RrQK2FzcV8CIQCcM9gu6kzA\nvwnvzl65VrlmH4WeD4NPGUvFGhwSTClztg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAbA6u5QeEwsLhiu4OuYvUKfaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU1Y2Q4ZWQtZGZmMS00ZmNjLWFkZmItMzFlMTY3Zjg2NjBkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNkYWMyMDM3\nLWQxMjAtNDk4MC1hMGE5LTlmOGVkMDEwMmI1NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ6Z2BIQ/Nft26oZIRxf7SEIxuSXqeBia0fP2n0GmYQVK2ObPPrbX8Mv\n6+G8RX3DzD+a0S7Cu4K4G2nxhhslQmCjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPM5Afzg\nkJYbNcxr2P2Fg04RxJy/MAoGCCqGSM49BAMCA0gAMEUCIEYDY1PXnVqfH7AWaD+m\nn3mB0w+bZ4k/3sybKmSg2840AiEAjYzWDDtoV5BPF0ZYuynaKH1VfX2YPOg4H7kz\nsWsL6Xo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc771", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `771` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISATou7yPJtzz5InCJmIUW5UBPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5OTUwZDM2LTM3YTItNDZjYi1iMjlmLWZhM2IwNjIwMjg2YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU2ZmE3NjgtMWRm\nYS00MDEyLWExZGUtNTk2YWFmOWNmY2M2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQORyYIS3UWIiwB3WrDzPSq4G2MKNJCunUuyyPWlMDYV7TfvBvSatOEyh7ovR\nGrPZKyLUrHzdVLltoXEgQIcrF6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeMpxj0RiM4b4Js/nlBaMGjX4NCwwHwYDVR0j\nBBgwFoAUPT8xcJ14bbe5um0tUYp4ZHuWIZowPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiA5vHtnU4nWxyuXQ0L/6gJZ0HnuzgVJchVQsf7BhuFnRQIgAVdv\nFDhMNByNlLoxqLEH2MtWjLwdctcbyjgSBNROU74=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQDvM5gyG2wnuBe5CxsjIwOZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTk1MGQzNi0zN2EyLTQ2Y2ItYjI5Zi1mYTNiMDYyMDI4NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGUrwgJTL1GTcdYWmHviFcUmslFtPOU1368D+FigI0uMOO\ncyUjd+6TNKmZMrLnCZ2eY08+vnJupYiMRg3SZDFGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPT8xcJ14bbe5um0tUYp4ZHuW\nIZowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC3AqgDkb/IjXoPRNZKYQ8KJGyVvdLDCIcr2Jj4jJ+lwCIAzoHWREhLpm\nTdL6PD9k6Qm7RtMmlENLLaxy+yJILorh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISATg5QmatceNN+Td/EbTqz32dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU2ZmE3NjgtMWRmYS00MDEyLWExZGUtNTk2YWFmOWNmY2M2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ3MWQyNTRj\nLTY3OGMtNDc2My05MjM3LWE5ZGEzYzkyMjBlODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIaLs5xH94dSaFsIbyKGD9nauqs1F55tecz/z8siCI83JzWRmqA0X2El\nZygb9doyJ2P9khoBMq/6IgoP6co2NrqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHjKcY9E\nYjOG+CbP55QWjBo1+DQsMAoGCCqGSM49BAMCA0gAMEUCIQCZlBRodkw/k1vJJXlk\n9aGchdYA/vYLS0YwN+mF8WxKegIgIemhoBM63DYc1nwdsjHm+xha48Mlz+1Uzo8K\nc1r52TA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc772", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `772` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISATuX+QumneRW/CZ2bGX4iiCxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlZDViNWRjLTdmZmMtNDBlYi04ZjY4LWJjNGY1ZWQ3MTdlOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2MxNzk2MjMtNTlj\nYy00NzNiLTgyMGItNGQ3OTFlOTM5Yjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEESkElmHEJPK7gC66KuTUgnnWTAYqorok3z9jPOWfJy09pGYISaNuwa7PsARq\nwjrtcJVCXaKCzI37eTiiAD+rv6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjoNJE9096ua9ynt5F+65dJQ4ZjIwHwYDVR0j\nBBgwFoAUQp9LHmzE/74Xwnu+IROwUnDgmzAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAqQvIbj8Vm5Cd\nJmy+huT9rjyf3+hKXS2GalU0R3bdn/4CIQDaFK07ZD1+8mqJssq48EO2yXRNAdtv\nztGbDkV7oQl5MQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQDhhlvwqqMzrWXclPdFapiFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWQ1YjVkYy03ZmZjLTQwZWItOGY2OC1iYzRmNWVkNzE3ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARv4Px9wxPbxzfQgFVlJxEP5EYcCS8uUIA5NXmorsM6It2X\nlB2kHKqwA+VdaP1P6iAVN/XgW5OH2TTnUqjGEQ7mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQp9LHmzE/74Xwnu+IROwUnDg\nmzAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgS4U92SvfISN9tHJJbM6pT5XzpnJSeDoRWgXSQTYlbiYCIE0Wt3L0b1v/\nZzApiHOXUCjyN/J2kEOY+DlpYREr1/5G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISATeHSJ/bCEGG9wUs94xBAxlLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2MxNzk2MjMtNTljYy00NzNiLTgyMGItNGQ3OTFlOTM5Yjc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYxODIzNGFi\nLTM5YjktNDQyNS05N2JlLTkxNjVhMjQ0NGU3MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJalsGw6BbzjnKm61meBK5aH+ODW2TG+ZU3sw+8SjRJCcj2r4eTS0oL/\n2FmDPwuF26oBe/TE90g5RZbwyhNRNayjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI6DSRPd\nPermvcp7eRfuuXSUOGYyMAoGCCqGSM49BAMCA0gAMEUCIQDF2LQvDT0mIy2mfUXT\nhFpnyAX1d43wANLTHs3sX59w6gIgKudUAZ8R+qC24VDJ/GYC671pblz87jceIPd0\nEuUwWBY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc773", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `773` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWizBu1PLs01voMx6rvXTYc3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjMWU3MDBlLWZhNGMtNGEyYy1iNjFkLWUyMWE4MTJiYjNlZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBmMTk1YTMtNjQw\nYy00N2VlLWJiMDMtZGQzNDMyNzQ5MmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERNtlttEC89Xp4TYTukD0wvO07j92Wu8LY9/XgHosSgObV/mqwFLxWym9SL2t\nII039wR/VLA3hhpYeM1A3vpFo6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHjzVe167568PoZ0qj2WAJEqIQs8wHwYDVR0j\nBBgwFoAUimim6/YURd9PTkQcAT543bC+BFEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHaRSUT+Nd8vPP4rZ9XNTE2siWCxQr3LW/vCFD+5tv8HAiAQdy3pVvwKYdLN\nHvWzBikdQqdhwhMDppR39dyVRn/aGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAde83+5/L2j9/R0H1tIIKhVPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzFlNzAwZS1mYTRjLTRhMmMtYjYxZC1lMjFhODEyYmIzZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOqyyvY4ani5sffkHEvBTuMnkj9SMzHucFttYqa9r6UebB\n52doZFqUSSXNjyRblmSrpMMGyFPeCbltJiaSbnxro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUimim6/YURd9PTkQcAT543bC+\nBFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJYCARkfFpBWuDhTpjQkYXfKk4tSbDg+KROdn4NNXf/9AiAhGn0fPxbC\n+c6IA5x/KPpxzlBduK/KbDqJqz0uDo7hAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAZv2v/a9eb5t5UZXMOcSS6iyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBmMTk1YTMtNjQwYy00N2VlLWJiMDMtZGQzNDMyNzQ5MmIwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZkMWUwNTVk\nLWNlYTMtNDE4ZS04ZWE1LTQ0ODZiNzI3ZmYyNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFgzMVLBh1rnvDhb1khukGW3v2+lwt2FKsaJiAKSP9hGVxiX+dh0/0oD\n8+WAOhmgU2Ck1OhlkvLM3k0sD3eTAKqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB481Xte\nu+evD6GdKo9lgCRKiELPMAoGCCqGSM49BAMCA0cAMEQCIDCaSF+RGGa3c4o70AfX\nfGMDd45ewQIATGfpthbZkI1SAiBT/oZrshPT4LZiU+oJOYs2zCqPcMJCckkig6PH\n8My0lA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc774", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `774` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdoGm9wBZ8KOSQKruVod52YbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0YzAwYzlhLWJiYTAtNDkxYi1iYTU4LTNkY2Q3OTlkZGZhMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQyZjRlM2ItNzkx\nYS00NjdjLThmMzMtMjM4ZTMxMTk1ZjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4l8mNK4+40aca3akmaR1a0QeNFdud/6u0VkzUgN1rkeVl+DrKh4LMW8M3kxW\nRQ4cchxXwFDWMfJ1VWLcIsGPbqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcsWtp0qhLt6WiIaXhpDLYkRcdCkwHwYDVR0j\nBBgwFoAUiQQKxnmwb730DOY/TbIqcY2ookowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDJfYxKWJpRwe1rNgLRRmkvR1tSnhOeCyS3qYNWCQMeYgIgM6qXt8o65mwC\nDJaCaxlzQzEZhR7+dcBPxuugYsDolo0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASfSFJlRJeV/NFY17nKXxOh7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGMwMGM5YS1iYmEwLTQ5MWItYmE1OC0zZGNkNzk5ZGRmYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGoxqhSLux9EcnZcvuXT5RUvjAdK++roHSc8La8cqeEurv\n0od5POh3X2HGuQhUAQcaQH4Do8j54CiZoTxbdkU/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiQQKxnmwb730DOY/TbIqcY2o\nokowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHY8kKBJYg20mVHdu+/sZeDDaLIL6SCCjjufG1gzss9oCIH8SKL7W+Ald\nH+QLLK4D4w0ejrREzGcrDyIZ0rlHEArw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAeXkjZc4LacWyclSg6lSao3lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQyZjRlM2ItNzkxYS00NjdjLThmMzMtMjM4ZTMxMTk1ZjI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc0NTRiOTkw\nLTI2OTYtNDIzNy04ZTgwLTJlN2ZiN2UyNGMzZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAR4sM9dHzqFvEYnZ6JMV3fFGV+jLzUD1QyeQluxCQY2c2d+gPqmP1Ka\nzSBKaG8RT9BuQBs7Tln5PbsUwP5jzMijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHLFradK\noS7eloiGl4aQy2JEXHQpMAoGCCqGSM49BAMCA0gAMEUCIQCKhSEW/2a1GxPuE0MF\nfL747F1md1Wk9gXLwRKbryeuNwIgUfZdXJbRJjbNy472z2sb8yvv42Ip9uu3eXR1\n4l7Xkh8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc775", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `775` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAew5LWoGqF0nuk2hl6zOdbfiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjOWEzYjZhLWIzMDctNDIzMC04NDk1LTcxZmU4NDgzM2UxZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y0MjdiYTctN2Q2\nMC00ZjlkLTg3OWUtNTA3OTc2M2IwMGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzarsychl2ZFl/ufQVwF4LsfPTgOSfJvk4miYtaRm6KFZTyKFcc8dqyCF/vYi\nDTZo85EF34Y5R2lemmru4FB4r6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTJDRJQ1kCeW4NrpeCswdcW4NuZswHwYDVR0j\nBBgwFoAUkpVEK7bHvdHi2/ZLbMW1w5GvYeswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAEEPrOxqCTPqD3UaW3eEngJEaO8ipUEFZp6pZNnp6hqQIhAKeN4WdS1krd\nE5TRKxQPFk8WQo3INGPxdyYMZGqzquMt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXoQn8IDPow6pxQZLOxHGB3+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzlhM2I2YS1iMzA3LTQyMzAtODQ5NS03MWZlODQ4MzNlMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCavJe/NqVFedrueWCrD1jMXL/Ai6+GODo4UV9jPeUgdhy\njnfg/f9J246kLRRa7BYCG0KJnuQQqk3FDXneLNYpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkpVEK7bHvdHi2/ZLbMW1w5Gv\nYeswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIbGAZViQMwTUp0zgcW6QyVmSmzwFzNcxVk14pFUbFf6AiEAjTQLSa+z\nZNjDpmbi3NDwNBvzhg+5EaQ9XwaOT/J7/k4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAVdoA2yF8dbfEoB3IXZdcsL/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y0MjdiYTctN2Q2MC00ZjlkLTg3OWUtNTA3OTc2M2IwMGVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJlYzkyZjIz\nLTI4ZWMtNDY4Yi04YzdiLWYxYTBiYWIzYWU2YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBp2POP+xdYEuztSxLOsf4vX72wOwtEnu6prp4oi+UZ0bYxlOCN4WYZe\n1q8qw2c4gIfCMWU+V8CXDTkZAWvETfWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEyQ0SUN\nZAnluDa6XgrMHXFuDbmbMAoGCCqGSM49BAMCA0kAMEYCIQDzTbhCdDRA9k/Q7WXW\nPFfUGlj451FfnZtbeUpuCCmRkAIhAPG3jfZBOcFNwTFAbROmYMPiG64P2pJWs65Y\n+7BRvT95\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc776", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `776` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISARR9Pu8s0/jAKCOOprY1Da5DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwMTY3NmJjLWIyYTUtNGYzYi04MDFmLTFiNDUxN2IzOTBiNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIxMmJmZTUtNWJk\nMC00MDYxLWExODQtOTA3MDE3NjJjYjA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeMX3S/euSdlfAnRrZ0QP1//M7nfh67MupKuJg6BWWfpqB4jY6Xp86UnkG5km\nr5AEQz3fpxL/UWAWOZXtSuxFjqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM33wxqB2OO9fO9Y2Uzv34fAoscowHwYDVR0j\nBBgwFoAUN1Knv+PbIYIlJ1HL6vYDlnLdIKowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA8C2jh9s1eS24oaGup/Xlf/xDJhQNbWO3Xi3SYIaM\nsLYCIQC0WaKLs5PnCvrkY17DU35ho60zbbc1iHF4i27SihuITA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXnfL9s4BT0CUsQMRuURIRFDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDE2NzZiYy1iMmE1LTRmM2ItODAxZi0xYjQ1MTdiMzkwYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpB54U3aSgwBnxtuAPLg1L/T/lqyMvBCWXtGZw4O+WtMbD\n8rn4bWqNxepNVneZKOk4YZ6tE2G6XtOl3scbAyxQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN1Knv+PbIYIlJ1HL6vYDlnLd\nIKowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUYQpKBsU65J8Qo5y1/uaIbiyJjr3fLqBFip+IUUAf28CIQDGZHtbNVgR\nxDQsETBVOOkLSTnEddYUhf3Soa663EdqTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAZUpc39b6VPw7kguSTJxrqHWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIxMmJmZTUtNWJkMC00MDYxLWExODQtOTA3MDE3NjJjYjA1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUzNTQ3MGJj\nLTJlZWItNDFiYi1hNzY1LTI4YzEzZTg3NTUxNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB+0R+2ReEi3+FuysLBtS5DDBf93Sf2njUCji9u8MOH+TWKf5NJPDSvG\nwmWfWSKOr0zI8kOqPY7F+GrRh4BrFWqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDN98Mag\ndjjvXzvWNlM79+HwKLHKMAoGCCqGSM49BAMCA0cAMEQCIEHs9cMXz0sWFuEjISyi\nNsIvg47cpN+xLhfWLs7yhLvcAiBuLGuPh/3otV6SN2soyqBcXFgpsmBylFAoMe+C\nHT09TA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc777", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `777` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAbuWIyLz7diiWn038zG+kpkUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwNzRkMzY1LWIyOGYtNGRjNC1iZmMyLTExNTE3NzI4ODNkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJlZmMxMDQtNWNi\nYy00OTUxLWJkMjktMDY1NGM4YjhhNzE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQoGiv+UeBJZd76FWkt82i6bd+yYGPXFvdBNe+UXQXZOYkKp9Im4iQGqN3QgS\nR/+PoPGGTMLtR2NDogFgX9NkeKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUprCdqVJhZpfx9gyPTgq90vDZvewwHwYDVR0j\nBBgwFoAUKRBF3c1rOQLQFOC6adJEwdd84SYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAPEiAqPqPo7DVR+Ugp72WGWkIIyGan5/NTk3p4L2pL\nEQIhAJccaoI86kMdKjYnRhkORAysYYm8PnGxoYshdn9CHx0g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVEapPGSpx2nggG9bogwHPYyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDc0ZDM2NS1iMjhmLTRkYzQtYmZjMi0xMTUxNzcyODgzZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdyQ7gWbANEApsMindLReThjejpFtVwiJ+pzt+7ny6PT94\nDHlupVQMYVdcJEU4j4J+Vpb+j2F5gG2Xa9/PDs5Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKRBF3c1rOQLQFOC6adJEwdd8\n4SYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW0SrUFDWHS5S0uOerqWYUeYpLyejQUsj7KRmn1B/zj0CIQD6J+w1ykaV\nP4Zpy/ZYNw1za9332VTyYRvSk9PAHWfEYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISATqg+12wJKXTDmwyL9MsBSCSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJlZmMxMDQtNWNiYy00OTUxLWJkMjktMDY1NGM4YjhhNzE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdhNjFmM2Qy\nLTNkOGMtNDRlMy1iYmNhLTVkNzM2NDFiZTFiZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEKBAssBAY0IGu5Copz8r+eO9XoW9TOAXR3ujTev3GwtQIKzbC6Ws2Zh\npjoy2wUe3k33V4fnp0fFuR2odHGEOoSjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKawnalS\nYWaX8fYMj04KvdLw2b3sMAoGCCqGSM49BAMCA0gAMEUCIQD1s47BMBnwI6AfXTd2\n1AEKBuMRgn1DQ5X3HqJhiRnB2gIgWJtu8/iyyTxhMX0utuNMqDJIVvboC2pS6u9k\nXVdFWwM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc778", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `778` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAfuKCRO7Zk/9OtO/KwbjA/hKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhNTIzZWJmLWE4NmYtNDgzZi04ZWU3LTEzODAzYTQ4ZDI0MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU1ZWM2NGItNjlj\nMC00Mjc4LWE1OGMtNDAwNTViNzUyYzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEydsQIKJ2Y6/P+BJ5wHewNJCBg7mx4B6H6OvAhJT+vOg9s7OQ6ai+PQzZuJ37\ncq0O83GnEpPy3sT16b8nbwiqI6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ySlssRPuk9akBKYBvpaSwTr1F4wHwYDVR0j\nBBgwFoAUvtbeSmloULfmQku7fpFDzjlDZBEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA1QJbVybCyXopCi7Gx6yLwZlxAIs3IhsoipOt67VAZDQIhAIOl\neqS3xFwdt43dmFVTb5qiGYPGJLC7NLU1QBz+uuiX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV6fYktXt7A/nXp8BiF0+5c7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTUyM2ViZi1hODZmLTQ4M2YtOGVlNy0xMzgwM2E0OGQyNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrG+VZbhSDSr73s9tdKMM8bLbTn3IEVIHfVxoyDbaS64Gl\npAiMAsGfEbUJMAV0epfcpYAtCN6kgwX+/Nmj7oBao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvtbeSmloULfmQku7fpFDzjlD\nZBEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOQmF+TieX+AFQ/QDOkDOfH99X/zmH6UFXZjwnWRLukLAiEAsCXYf7Xg\nOHWE9ajVktOSAfFtQgwMbeUgl9wqoIaUdT4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAYLC3h+d9qcyf/JcXXxYAryZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU1ZWM2NGItNjljMC00Mjc4LWE1OGMtNDAwNTViNzUyYzdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ4M2Y3OWMz\nLTlhOWEtNDU2OC05NDA3LTYyZGRhNmVhZjk2ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC/D4L2nZ+2CMFt0da54aEK6w5c/SxyDh6XFJxMcW5WEOVQTi26LCgBh\nf4Xh/8MC9eE0kv3yQ2c6VT7uHtdY8mqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPckpbLE\nT7pPWpASmAb6WksE69ReMAoGCCqGSM49BAMCA0kAMEYCIQC1HuetrM/7B3FOxKmb\n3ltHjkFLVxYd4oKCnPwsB2JI8wIhAMjNgTv+JiMBtO4q4rdtB5bJPSQW+8AaAF5H\nIfYlfP8x\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc779", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `779` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISARxHkJRthq1u4u9U2eLsxG4GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwMzljZGVhLTdmYWEtNGRiMy1hNTI0LWYxZGI4NWU4MzJlZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM5NzM1YWItY2Qw\nMy00YjAzLTk5NjAtZGU2N2VjODRhMGM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgeV/6vzmBPorKWvRIaH0p/mIMMM5bXFKvsGrtYeOmg8yf7YN3A/LSk0M0iUH\nr4LBjglod2XWuE7Pmmvk/bWpYKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9URwefn2z5xrdU8vglT2lu6wW58wHwYDVR0j\nBBgwFoAU7xTR9jOOZAIwH1RXTOpdQ3nF/hUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBFNdOmpm6XmznGNAPrUw8V6Fp151kR0Anh\nW0pZzE2xqAIgNuYUWbNC4JSAgCR2F70HUIgAQcF2MQtNaLEVd3lbxok=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfcPN/LH3woPTLtqq20RStJ6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDM5Y2RlYS03ZmFhLTRkYjMtYTUyNC1mMWRiODVlODMyZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1FGzY4UwQ+ZiRDrRxiUlmkCEuHwvHZC3ZLr88s7WzIIuj\nTmZLbBbLRuhp3Gd895H+TtvAx9MdXJG5pWO+s5vXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7xTR9jOOZAIwH1RXTOpdQ3nF\n/hUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJkT4pk7gAjWt1aqW9wWoaV9kNWW5FLWpN/ybI9A7Vg0AiEAgn4qXpxQ\nBDWgbvhWHm/GgzbE1Bnr6LnIZd7lIj6S8Dc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISASC8SX5nKciUBUACoTYDArD3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM5NzM1YWItY2QwMy00YjAzLTk5NjAtZGU2N2VjODRhMGM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFlNjM2ODli\nLTg0ZDAtNDkxOC05OTFkLWU4MDFmNjA2MzQ1ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBjUj7U07qUrOegWgsB/jz/RWAem3CSRnlBRU1gzVi7q4NLJ+bKK2Zeq\nIlhxHgxqh385yDrFWaF9xO3wwCbYAVCjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPVEcHn5\n9s+ca3VPL4JU9pbusFufMAoGCCqGSM49BAMCA0cAMEQCIDmC19rZxBIFyAPNG7tu\n9MA956m80s4eLvyKR9HIn0lPAiAXtj7d1JZY0I54L4A4RCW+VbVfbLjG6H+bjJWX\nOKLftg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc780", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `780` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVeLVL5Gc1R/doQB0qz4CgEUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhZDgzZjA2LWJlZTgtNDU4NC04MzI3LWVlNDBkNThlNjFlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDkyZjE2ZTItMTI5\nZS00MTkyLTkwNTQtNWM3YmRmZGE4YWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEbxulagJzDnFPGLIktibSvj/NiDVTb8FCyVLv9RazSoWnU3oDl77mFjghb2V\nJt5MOF13GmpQb7zfGYzboRvJTKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCGhcS/3zNnFosw7FFYQ2nyPOO9YwHwYDVR0j\nBBgwFoAU/3pqogShQViOXiadrd6LCQBnUhgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3qU0UQuIkVx5uOpBQ9Fa+YRbqlmdaoTD\nzMVXQ4SaVMQCIHlFqbCSXr5imih2KZUg5xwXJnMxFn4o2wdtcW3hAaUo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARzVkfaq33TpnQTTYTqPMlDpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWQ4M2YwNi1iZWU4LTQ1ODQtODMyNy1lZTQwZDU4ZTYxZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3OaPOe1ynBMdVFgh58ql/3JGQWQ3cVmLYC8lrkCQl1k31\n2e4ySImre53UurgwBrPenmVWj/0DumqieoR/jVP9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/3pqogShQViOXiadrd6LCQBn\nUhgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALu29uL5C08bZ8a+LLAtlfJEY1dOTJm0ih+qSyQbxILKAiARn9+hKmsH\n2saGzGV95K8PLI2XeQ5G/B1oDBMbh8CmPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAaWIl27SAjZkCPr2PPuvhL2+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDkyZjE2ZTItMTI5ZS00MTkyLTkwNTQtNWM3YmRmZGE4YWI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJjNWIwODlm\nLWJjNTUtNDBhZC04YTkxLTZmMTJkNDMxMDFmMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA4E4TrF2gmRRZzwYf70DW2iyEYDMxQfRzYiuzZeJgrPvamFiBbWlo8t\nxHAIC1wCBrtwqIZpvrcdOHNwL83hUYqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAhoXEv9\n8zZxaLMOxRWENp8jzjvWMAoGCCqGSM49BAMCA0kAMEYCIQDUytBnydSAsK36omnA\nqFal3f2Mh6SqxpK8BYRV7GEH/AIhAOGUlqc8f/SY0hWIS6P8QseZLCWwL+Xi5Kyy\ns7ReQS4e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc781", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `781` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARGo5k25ZwRnEOl5wooRGbKDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4NTc1NDE1LTgxMjktNGJmZC04NTg0LWI5NzA3NjE5MTdjNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY1NDUxOWMtMmMy\nMy00YWI1LTg0NDAtZTFmYjBlNTIyNjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwRFXQq3y5sdO9jzPEa168ABV9WvD2EV20vqQ3NUYkyqWKTjDFkZGcVheUeVk\nEfOy4tSYyc/pIMZUTMNuzIGQT6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+xakVMdkzgl00wUiz9VpRDhz8HswHwYDVR0j\nBBgwFoAU9gfEYwQrIDKSTfLkYru1lOBEooswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAe1vncLe4rImcf\nwaouEgK4IUtJhs96T8uKKajp7GfGTQIhAJ4oNRwPiD2fpw3TF6RoDtlhmZq8jenR\nflghOWVC7GJu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfrZoR+ewKEy0SXcVoo5hvXCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODU3NTQxNS04MTI5LTRiZmQtODU4NC1iOTcwNzYxOTE3YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpudnk3igdaIx4mzSLJFxBngmuUfc2SbCsuN2owmkMyByS\nq07bEpBcSLsuesnbAfq6MVp8Zs/5WSDU14h2mHuOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9gfEYwQrIDKSTfLkYru1lOBE\nooswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKsG7z8d5VMPnk6MO2V39hxklGhebslmoSLMNMiNqJa/AiAQEIO2WcJ4\n1AbGTT3dgA4ZzqUBsXcBs5nitl9U5iNXDQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAX/2CpRH8U4Ek9SSMnARNuYfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY1NDUxOWMtMmMyMy00YWI1LTg0NDAtZTFmYjBlNTIyNjMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE3MTA2ZjVh\nLWRlNDYtNDJiMS1hN2Y5LTJiOTY4MjZhNzM5NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLiWRDEAFSGI5BKegpJRoVgUQwIG1qo0Iyax0OsOT7Ra8kUO5Caz1VC9\nXDUtKpSRIPr4V1rGRyFmWqPav/GQ9PujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPsWpFTH\nZM4JdNMFIs/VaUQ4c/B7MAoGCCqGSM49BAMCA0cAMEQCIEhxUuWOvK0GVPHfX/K1\ng2bKryElofCpNFeV/vXsqxZaAiA/v+wA64QVspgk28wstA+KA+1P1e7+IBCCgB4d\nkPNZHw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc782", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `782` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAR9V7lpNoyQeb/VrlNBsMdZjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNmEwZTFkLTRiMGItNDhkMC1hN2FjLTNkYzQ3MzZiNzBmOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQwZDIwMDktMWY4\nNC00MWE5LWI2YWItOTEzZDBhMjYzZjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkhOJYnH7MnyY7GpUa3eaQ55L+2owf0SWEjT2i/lHfAf/d6OBwxeogmlgirUC\n9eQ0Pu4AmXiuOu9PH7Rb0bL3CqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCvIYaUF2tnScspSzWSw2dHw3EcwwHwYDVR0j\nBBgwFoAUwOqg5UCWn2gKW+bIYF6ncIbL+xQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCMufZgKwuGTxm0jOm1YK6qb0pSg+aJqbez1o4uGo3MnwIgTyy6TcOZohfu\noJzoV6sz28uS3O291EXIEyf/mKP8SAE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXPliDsYAxLpjgAStyEwPOPIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTZhMGUxZC00YjBiLTQ4ZDAtYTdhYy0zZGM0NzM2YjcwZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARM6Z8sm6iB+NDNfP6r68IYwNVO+J3ahH9fRTNL5p4aEtWz\ndjnorlVSUqedX9WFbDNmiG5DWfwaoidABP1IUzqgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwOqg5UCWn2gKW+bIYF6ncIbL\n+xQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIVzgFWt5+IE2PYNOlrFuzAxlXx5SKGMtZUiWTDBBUD8AiEAyjWarOdi\nzR0nCiowTrUdICkxXYvk/RNbKPn/JZfdyQ8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISASrTTesBEnCxvOeoob31oNN8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQwZDIwMDktMWY4NC00MWE5LWI2YWItOTEzZDBhMjYzZjU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRjMmI0NDNk\nLTY4ZjktNDBmNC1iMzlkLWM5Y2ViZGUzZTc5MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNHXsc0Rm1cMlUhsnuu92DeofBgWH/3EedaBHos/zu6DBej53+lCNbYs\nCzJUoiUpErxyNa6S8rcgVWNnIToGtuGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAryGGlB\ndrZ0nLKUs1ksNnR8NxHMMAoGCCqGSM49BAMCA0gAMEUCIB0DyYg6g9wR0nadmDwo\nO56sz7uZ9xTm/F93+OgEJpADAiEA7jx0/0A57ZM8HsfoF6Vikvwr/AVpSpvUKrtz\ni2CH4xc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc783", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `783` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQZ9VRoKhZFRgqTK5V9+g+uHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3MzJjYzQ0LTE1MTEtNGZlMy04ZTQ4LWFiMDcxZTk0N2EwMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIwNTdhYjYtNzgy\nNy00ZjE4LWJlYjItMjk0YjY4YTBjNTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+7gcsTBuDxD5wsjX6KkFrevUiil30VoyOaRovLvUlE2IRneC+6K6D8Ht4g+v\n4IzeSyXl9Vt9SbZPZjZ1pTTnvqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcQPNTCDgGzVgmE79R1FxUabEHuUwHwYDVR0j\nBBgwFoAUuRu+RxbhoaCMb94loeX0y+uMSZgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGJjmONGPOQEugLSIE1VmyRc5pkkf7f+yz4khKZHJcWZAiBrjS0tutEwZ46S\njnrQQ3ltOx2Y846iXKrCRB4/+D7NiQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARmCxv3OcpuuIv6mfIN8+baSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzMyY2M0NC0xNTExLTRmZTMtOGU0OC1hYjA3MWU5NDdhMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcitwh8FGGlX1EXXfYV485uVsVqs02l82OjQ8jbmigmYKz\nWOfLB/eP2DmGW4ATP8IJaR/El/tGxD58uHIO6KYJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuRu+RxbhoaCMb94loeX0y+uM\nSZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALySeccNQnHLaf+2IxxrpkxXoWqGD73jm053jCsjBf+5AiAcPauTCaYw\neSFDpsrd3AwXnFAylPF7sefQ6t9C1+VkVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAfr6R7bRgFKs6Oe5vAniIGj3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIwNTdhYjYtNzgyNy00ZjE4LWJlYjItMjk0YjY4YTBjNTA2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNkNGZmOTRj\nLWM0MDgtNDhmYy1hNDVkLTQyOWE3NGMxMmYwMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKZuy+uhndcO4KU1wCxcwiSD4t45fIMdFOK5IWzKQS4ZXr0LkoND/oe+\neKWwFDdD0lFeMHuoxANUlp97ssF91lKjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHEDzUwg\n4Bs1YJhO/UdRcVGmxB7lMAoGCCqGSM49BAMCA0gAMEUCIBSG6SzdAq17KFh/JV31\noNbIgr/39vxFIH4jvEY/61uOAiEAnM6IzElXXPo6zrt4mjXPFZ4Ebphmhp9UPb2/\nGSzHwcs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc784", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `784` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYTRU322bQPuUHk6gKkeN7BCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxMDhkY2Q5LTMxMWEtNGQ1Mi1hMDUyLWQ2ZmE3ZWM5NGZjMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc2Zjc0YjktOTlm\nZC00NmEzLTgxNWUtODY1MzRjZDY2YmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJJXHThvSGvtxPPqOa7JpX3HKYZlPf5HoErcEvmZEWiImbedTXBkXmMQ8aL+q\nXQFazl2IIptu6Xhsvort8fD206OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6PuD0ZvTIxOfbQfKT+yzQ9Q2t9wwHwYDVR0j\nBBgwFoAU0lt5cF1XIb8Cnrm9RAih3OMVGxwwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAiwXw+FC70rMkhN8ibhEWlJmml/jq0E8R1flMsAVHCVoCIEaIjzSLmi8F\ny4qqJmzHDfsSYzERzK4PM86xz3eksFHn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASHsrKSE1QJ9+jSdxDuVlGLPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTA4ZGNkOS0zMTFhLTRkNTItYTA1Mi1kNmZhN2VjOTRmYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATa4ZtOphCqBwZxeyQ4HL6holjM5KvIpmEEb3AlN5MpZeOZ\nH9XCkJZTfEBuVzRCAl9SDZaOXoWzulUtrW2lAF70o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0lt5cF1XIb8Cnrm9RAih3OMV\nGxwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMfSqH8FA9sjPTpTUrvboc/VI9AcRXKhFynV3K658MM5AiEAzGXGhTko\n/OUQ4JH5SmWVghRzQgApk7CGoKyg3N972uw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAbNBG75kyBvJdy+Q0WkyIDRsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc2Zjc0YjktOTlmZC00NmEzLTgxNWUtODY1MzRjZDY2YmE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVlMTNiZmQy\nLWEyZGYtNGMxZi05ODg5LTg0ODcxZDYzNDA1NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPehzEr8M3g7Dg2L721ExuW7+M7gMZSJvZ9oJq+6ECjjr2sBhKm0mRJD\nXh228xV4X1OU6NM/VjFmJ7Xb2ABeoOqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOj7g9Gb\n0yMTn20Hyk/ss0PUNrfcMAoGCCqGSM49BAMCA0kAMEYCIQDTjNy+aFuzkwqnj0oL\nQGqQrYj87dxcz4xkSIU0IOQZ/QIhALjwyMT9TavIVl/NBagf46d7j4ZWqVtrJIxw\nrwOJ4nJ/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc785", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `785` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcj9zW3xfGMfjKyh1Z80lyLuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExZDRhN2IxLWE0ZDktNGY5NC1hYzNiLTA4ZjNiYTA5ZGJmYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJkMzM2OWYtYmMz\nZS00YWE3LWFkM2MtN2NhZmEyOGNiMjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM2PrrplL0rNhb9YWbulMyf6IwY24RsrvgbYsmoPVMWn5ZQmNiPMhGcH2F5I+\npu7e4/AM8tanFb9S/4G17Of8taOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8x11HVywmLFJwsgIaVvs092Ksy8wHwYDVR0j\nBBgwFoAUcn8qA2+JmuWzUIAGO1Zfjkmjqt0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiALqtHnCZoyWtfPtf60xOEISiiNj9+qBcm+/z8GSXU5\nRAIhAKAIEPGjKs1wH8FGxElSBsll0bl1/WsPccoxNU/0RTGO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV0C2o1DS+BZsNgWev9gzvUJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMWQ0YTdiMS1hNGQ5LTRmOTQtYWMzYi0wOGYzYmEwOWRiZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqH/0Bw/ZkRcKB2GCcnHJpsqKoG270cLgQL/EXS0H3Q462\nv+3/t025bZ9fDXjoAilNal/rvz5g3Kqj6SfZ7LH7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcn8qA2+JmuWzUIAGO1Zfjkmj\nqt0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaxtBZExr/5MKV0Jqjo+1dX3dduEcRgVLmrkTmbc5LoUCIC5p2ZmzqMPj\nmIBspOuAaxNQOXa0R9jIVgpZvs0az0X1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAbh6qg/VoXbJNInyrQD4UBLfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJkMzM2OWYtYmMzZS00YWE3LWFkM2MtN2NhZmEyOGNiMjM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYyY2RiZjFk\nLWY2YjAtNGYzOC05M2U0LWZlZmJlYzQ1ZDIwYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH0u5Xi9ZnE6k5avWMfwq6PdPmHvAI+9jJ5BYdS6pbpqJTsIYxw1W0ut\nQqbagmjKs4Y2RT7Rxoc/eTJF4J+Kw/ajVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPMddR1c\nsJixScLICGlb7NPdirMvMAoGCCqGSM49BAMCA0gAMEUCIGnzCYKPeJBDYP+swkr/\nqDCkxPiHvk5QrrYnCMtoPCcPAiEA7vpj0BZiLNPqDOaXwxbuBqdouuCPUwZvW1sn\n8D4wiPk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc786", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `786` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAd5jAY1B3YTvi1QbAJ4ybWgFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlMWNjN2RlLTIyM2EtNDlhYy04MmUyLTcxMGFkZDc2OGY2ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTFmODIyMzAtMzMx\nOS00NWIzLTg0ODUtZDQ1MWM5ZTQ2ZGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmODYBoWJuSl1Kwyp7vmSzgrEpzxiYdQHbS5mjyY+lf2X+4simYtfv4SYNiEj\npke28u45uDE8nULIYLaNjZ/KbaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURi1i+zBRjR+NDUbT+liIfusZsmYwHwYDVR0j\nBBgwFoAUZZv907b806ieuGsH7izB+NEZ9SQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAGkhmhIL5qTfywUzykNksnMgi87D0N9rJ0D3KhA/YH\nWQIgVjBi4GC51ugfxewtAFEp7y4xLfZBG2D/FMbOwOnIH0w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAScBC5ufsheqbrHteBNTtiyVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTFjYzdkZS0yMjNhLTQ5YWMtODJlMi03MTBhZGQ3NjhmNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4CcTPmJebCjdUPBK78S+UauHEPzvKkoAAQvW1wRpzpdci\n3KnixcTduwf9Hme+et9XSV8buYLlMDpA9Rnog9pQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZZv907b806ieuGsH7izB+NEZ\n9SQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPE4G6ZUCp4pLMDhDaON91IddDdoHBPsy9CpN2mukuGDAiBXK7Gv+xDe\nBbMqt/NUEFHjI72R/u9j6fv7wbmhThbuzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAS+hoXpkqPlEmt5f07XwbbEnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTFmODIyMzAtMzMxOS00NWIzLTg0ODUtZDQ1MWM5ZTQ2ZGFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM0YzgwNDE0\nLTBhZmMtNDE2My05NDJjLWViZDdmN2U0NDJjOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCdwJjjy+kLAS5rphgCNKCw2EO1FF4ZJiyLGB2o4TBKWN+7WYhArE+/4\nSIA18wOxizTSqOOK/y7ptvpoLp157gCjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEYtYvsw\nUY0fjQ1G0/pYiH7rGbJmMAoGCCqGSM49BAMCA0gAMEUCIQDaGB6eA4ybTrrcwJ+c\nrabISLrL8c8kvrFZGmk2Tlu7rwIgTlUCa21noo+rxq63gJ8fjN95Skm4p4mOP4Y2\nTExxmJg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc787", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `787` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAfr24UdzG2VcRArQPyplMCbKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MzJlMGZlLWFhYmQtNDUwNi04ZTRkLTdlMTM2M2UyYTM1YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI0MzhkMTAtZmUw\nMi00MmZkLWJlYzgtNjNkMTIwMjUxNmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcs0fayFoS/9fbiddlGQ84KlOAu3psgOefyyM6u73Jk0EjHamZAddGGnabvb/\nLlY2uZ2sHXBU968VNVYm9hUj0KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxHPzVgXyYGN9RTrVkS01SV+zIZAwHwYDVR0j\nBBgwFoAUqTkdxVJ8PMgPpnS2bfvoFjdbs4cwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAmSgVXOIEU4z67ksKeXYOeecM4JlO8bicxt5OSydIQuMCIQCJ\nvHmuOHjzafyyg7UWK2EmknqAZOS3xnz9EWzkZ67gFA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZevOHoOjvifTdHqHmk5K1aVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODMyZTBmZS1hYWJkLTQ1MDYtOGU0ZC03ZTEzNjNlMmEzNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgUB6cLllhOByBY/tWC0sibr+KuYEW/gCQRXk6CiNwpJhm\nxlrcFLSAPlAEE7rQ3uVMulhZaUrLgDxwbg6bocUZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqTkdxVJ8PMgPpnS2bfvoFjdb\ns4cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJQ9gM+8JKgilQdqJEmuf4LNpajNc7dggUa0IHPOlLRRAiEApja2qVM+\nzqiuXhYmMTxdWQLpr+dUsSSMEi+zCr4Q2xk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAYDMUSTbScy1yPFl4mQBbalYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI0MzhkMTAtZmUwMi00MmZkLWJlYzgtNjNkMTIwMjUxNmUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBmM2Y5ZGYx\nLTJkMTAtNDUxYi1iNGJkLTM2YTUzMWM5MWU2NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNRBWpp+EfIuMSP+0xRIdJqUiqoxlMRau9oF7Jf2U16YGt+syJEyVs0D\naj5IJBmOsboDakB+SMYkFszGBbxvK8WjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMRz81YF\n8mBjfUU61ZEtNUlfsyGQMAoGCCqGSM49BAMCA0kAMEYCIQCW/ES/2lHs2QsbLTZx\nnXmez5sFowu9qQtqb27gA9srIAIhAOlH+WbK5hZ8r/4DbxenX4/F2qXzCS6tKSkS\nwhuMfJE8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc788", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `788` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAfiNeFlSI/A79bn1BJ35SNEwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxNTJiY2Y2LWQzMjMtNGRlNy05ZjlhLTFhN2MxN2E1OTI5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA0Y2U3NjQtMWQ5\nYS00NTZmLWEyODctNzdkYzlkMWYwMTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXVhD7VXrksBmc1f1nLsNlxI7r8AblutOFQKRAHbHL5TsFHlPh6qZUhuZqBHA\n8IduzwnRYxZwBytzc4ytjKqgzaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEImtY0FptExDebrrcQwEcb5ImkMwHwYDVR0j\nBBgwFoAUanW+TbYxSZC+QIV1+AY139uavEswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAi/3hhr1nPKIz0X8KcJCCqDPiIupn95pF\nVvkSJ8ximnUCIQCbtcd12vprTMPFw7GqsC6uJWF6SEEdwR5SnwW/jkinrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdtX85nYMqF8t9ZslqS34hj9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTUyYmNmNi1kMzIzLTRkZTctOWY5YS0xYTdjMTdhNTkyOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfXtDLKbCyNvw1KEOJKGRwJX6bsh5aU4m4TjZ6+AeK/FU6\nrtz8zYALRM7gM9W4C7HU9ey5llStoUBQ1BqFGbbQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUanW+TbYxSZC+QIV1+AY139ua\nvEswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKoMGfywthj+BCIdsoO+/F8NUMt+bvIfcIm3O7Iqo5FgAiB+UcozDKEr\n3Bd3q3J85MlC8k5GLrjci8UN+aixSQJEHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAZEujoMtw4o9MEcZlPFP3bkSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA0Y2U3NjQtMWQ5YS00NTZmLWEyODctNzdkYzlkMWYwMTY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM1MzlmNzE1\nLTQ3M2QtNDFjZi1iZjdhLTI0MzJkNDUwNWVkMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD6nPr6TKvuiYZYNwk9jBRfwKp+4eX6ZICVEHHVO4PgMJXyh0o4nT2qL\nwWCqY7SwozDMyJQsDoK2AWS8m+CKkWijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBCJrWNB\nabRMQ3m663EMBHG+SJpDMAoGCCqGSM49BAMCA0kAMEYCIQCYx9rtPx6sisvgaBUH\nL6MeuIpgw/ENAPeSPCCQe7fPJgIhAMlNlh0DGNmbuOPtosjUgSri6SMOSR0PvQ4v\nVKyaIRTY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc789", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `789` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZaTNK4d4+UlXICU3dqnZdmTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4YjY3ZDZjLWNjNmUtNDIzZi05YTk4LTg5ODY0YzE3MjNmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNhYWI0ODYtMjNj\nOC00OWRkLTgyNzktYmZmY2EwZjllM2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGm5KW/nG74svpqaDCwRJIEOAo75JxLFOdBTSyy69IBV+lG4H0g1opqWkemT/\n52QHqBlHRDEy4KnolprjllUC/6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx1OwVn1HUiEj60FgMml7iE3OrnMwHwYDVR0j\nBBgwFoAU2CFnp4kws8VcU+QeaSk1gvedtg8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAtFy95UdisidqS8Lq+BgKL/wbU5hXYplak\niC492PTBwAIhAMQsre0P5KDG4+sYLKznn+HtaoKKjWNyEeGqkrxYMx3q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWFhvVZBXs6BsuMeiH9FHYTAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGI2N2Q2Yy1jYzZlLTQyM2YtOWE5OC04OTg2NGMxNzIzZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATx06KH/zlEQ928bRNub3XgCHvHIG9uF1DFY099x8oRG8AK\nnGbxhZqv/oZXdL+Qt5IHDpDf3fqgFcK4D3u73Grjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2CFnp4kws8VcU+QeaSk1gved\ntg8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRmuxBplH4luKvIeNw94tI0psO2SDETQukkQn9Zc0KBcCIQDgWBhTbef/\n7uKrGUURba6sGhiyFgCvay4HZ72SJYOGOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISASZm3V+rlIuEzZLzaIze6m3QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNhYWI0ODYtMjNjOC00OWRkLTgyNzktYmZmY2EwZjllM2YzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRkMTY4ODEx\nLThlNGEtNDIzNC1iZjNiLTA3NjlkOTlhYzdmOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMcYjOn7eY4CxJsIIU0srayER9BMDE5oAfLZZuTbF+GLUoHMwZ2T6jnb\nIKhX8265k9IYB/ehJHLc3qIHj342J5WjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMdTsFZ9\nR1IhI+tBYDJpe4hNzq5zMAoGCCqGSM49BAMCA0kAMEYCIQD3L6cpz5D4V0U4l6Lb\nAcD6YBLSmEHBGiwnzeZoYphQswIhAIe1anFDOZSbdNNfStOHArpO0kNtNbyHUUT1\nphd2w9tT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc790", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `790` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAfarYuD3lWwVnwkbTeYD55GyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiMzNhMTdlLWI5NzctNDUzNS05MmJlLTcxMmU0MDM1NTRlMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVhNmRhZjMtYzVm\nNS00MDliLTlkNmUtMmJlYjY3YTkwZDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESpJmNmvpSSkOvvScxnNmJmxKTEbWsJ8mQ+ZTD/HklYnMpib+C4831OloADyr\n8alQ5tF5rGKcS+Ng0kO7vGEKeaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSwO6E4/CCIdA7AnuZM2QwFB7xqUwHwYDVR0j\nBBgwFoAUzyP8QF8FFBougL57+BJuYsMmLMgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC+6sQoEaZ2RKMhcN8RAvJHLzFv\nPMhFwiac0tiNQem97wIhALCM/sHobH3+6U1ITCNH0AtJVUNY76jne/puzj2bCODr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT9MPrUHFYCdYiH1bCg2+Sh7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjMzYTE3ZS1iOTc3LTQ1MzUtOTJiZS03MTJlNDAzNTU0ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkMuW65m8WusKe8tWmWUh923fO3XRhOHxjYbH96H+QvG9W\nLRPyV+ey2Gwm9A2SpqBAeo5TeRN26XKWqeZoIhnho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzyP8QF8FFBougL57+BJuYsMm\nLMgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKV+DXwyG/Z9fmoI0L2Ht7utc4etUcfm1aCRIieZYFTDAiAE/q+hFy3H\nVqipfLusQTg2HOdb3HJqnx8WyVXWWiydZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAcy8ArPaPQIq49WjPKiSRudbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVhNmRhZjMtYzVmNS00MDliLTlkNmUtMmJlYjY3YTkwZDAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg0YjJmMTM4\nLTg1N2EtNDY2ZC1iZDU0LWE2YTg0NGJjZTc0YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNiVSxnRnsqcKdGa4ZB4LZxBMig0LsRgAXdA2Wio76YJdxb1WDU+e/52\nMAADaN1fhfX5lpbHnRH9XcXudS98632jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEsDuhOP\nwgiHQOwJ7mTNkMBQe8alMAoGCCqGSM49BAMCA0gAMEUCIEnkP4B8oyfUQUJAbfvH\nOW56IH99oNLMK9nuWYvRCq2GAiEA7Jgg+DaRjdBcLT3/181xkUM5awZulaiR4yPf\nXSqWFio=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc791", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `791` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAUxP/s9Don/qXgCv+s1ESkdZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmYjJkNDI4LTdmMGQtNDY3NC1hNDQ0LWU1NTljMGI4YmQxMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU0MmQ5YTAtMDIz\nYy00MDgzLTg4MGYtZmMyODMwMjg4ZWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsgu1cBptmZ0FZL9M5ZXlekQb+Q4M6AWSqoxd1OAWLsr8oYKLgwkSdrIab8ih\nkkXFENg/o81VJzg3V7F4Ij1x6KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxwF3R4aU7/e4HZx5LkrhrzM2nZ0wHwYDVR0j\nBBgwFoAU+UGrVKe/NOaZGmJCzlqw0VdC6vowKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOSbxQ2g\nwJ8dbRcMkSw0pSEHjBBHo8t5ngUIxYWal8uZAiBlhagFCCoi5EyrwxvZiQFGevan\nRVj4as67E/zbQCoKOw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbrgKGBeNbrlMkc4+BrXAvjAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmIyZDQyOC03ZjBkLTQ2NzQtYTQ0NC1lNTU5YzBiOGJkMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7nB/kVI4z68A1NVlwTaC7mhfgZGhMANFwPvLmBm9jHp1I\nwrMJaA9Blp/EWFuanjngY82Xw3upZk/xMD1Vil1ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+UGrVKe/NOaZGmJCzlqw0VdC\n6vowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPghZFrGHrVcY2ft0irLiOCDUoeoldLSn63CTf6gIGEECIQDmSmEIlR31\nZ8dQgd6U19AgoGJGH5BYWbsZnYUq7jSFFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAeEhuzcVhSVsYE0nGeUzFAHVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU0MmQ5YTAtMDIzYy00MDgzLTg4MGYtZmMyODMwMjg4ZWQ2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU5ZmZlNmNj\nLWY2MzctNGM4Ny1iM2IyLWI0MmY4NjliMjFjMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGJ9b/97FRlXG1nHAE5Jrox2+L71zEcDMMzp+lszWnqSKEDLYwu5nWhr\nZY9XVGlO3lemhnvr53Y/y6RlpYuAaNyjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMcBd0eG\nlO/3uB2ceS5K4a8zNp2dMAoGCCqGSM49BAMCA0gAMEUCIFEy6nbTNUaI5Uk9k0JP\nynHSjS6FZ646k+l0lyXLm3UCAiEA3AeMvkENOE8/+vsB2x/88nc95fF5KIKxTLYZ\nW37fo/U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc792", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `792` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAcm6/rhiXcasI3u7Y6wTpg8hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkZTIwNjc1LWJiZWUtNGE2NS04M2Q2LTcxNWJjZDYwNjRjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUzZjE4MDMtYTMw\nNS00OGFhLTkwZDYtZDFkNDE2NDE2ODRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8HjHmmaN9jcZndbWorBsgvJZXNGdAbwXOu8g6+mhw0vRQm1Z19cBsnzcNIU4\n9SUWHNbEo8uORlmZwXMJcz1WmqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHW0jDWP2faXLH9fLQs4q4Hw4Rc4wHwYDVR0j\nBBgwFoAUIWxCEGBh6Y6zFf3AwOKrRZ3QTM8wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAOH6JA4q\nwdO8OnBW5JrGlUVWkiXA/Ddexf5d2UrZ/7m7AiEAoruTBDDlrApvrw4shAz6iddO\n6aX+E0umr83mbAc0SiY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVPRBGOHoPqb8n61UDalJrrZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZGUyMDY3NS1iYmVlLTRhNjUtODNkNi03MTViY2Q2MDY0YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFlCez9h11gxKsRXYd4ba7fOZs2wxN6m2dWF1yj95X5zrv\nav3CFFwNmnS6R6Zc2q2yqOjmq3TdgIRlDODCbP1+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIWxCEGBh6Y6zFf3AwOKrRZ3Q\nTM8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLa7IP8yWEFgemCQQOkiyZIMtSYDnARUb8v9wvZSvNDUCIQDTK/1HjTX4\nTCfwqE9N8aSzoXomnRAYXQHmCDGjiMfFUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAa8in/oqhDlkwW+DH/upfpW2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUzZjE4MDMtYTMwNS00OGFhLTkwZDYtZDFkNDE2NDE2ODRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY5MmU3YThl\nLThkMGYtNDVhZS04ODdjLThjMDQxOWI1NmU4YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEz7Zl5LjgeHZE4Jy+OLM628k6HG+AuDnqc3ZdvIRlFJVyRO6qPUULWo\nip/shCbzff51NhzQ9MHrXe+j4s5cfNajVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB1tIw1j\n9n2lyx/Xy0LOKuB8OEXOMAoGCCqGSM49BAMCA0gAMEUCIQDlp1SExbIBw2au5S94\nRD5pcAZrTO+7XgZ3b65QyeX8eAIgF8kzarO+r8BDJ7pmfJsgvaIfFF55oN030ciG\nLtMr4Hs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc793", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `793` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAbd38D05tDf4GAFKs94nL7yHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3ZTU3NzQ3LWRjZTYtNGJhMC1hOTY4LTI2YzJlMjQ0NGFjYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBiZjQyNTItNTRi\nMS00MjBhLTk3OTQtMDAyYzE3MThhNzQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1fhXyjfh32FP4wRVydBBkxqWBhbe9nEjbp1A2Y/G+OpXLOkJmfLZGRCvZElB\n8bkRd0eD+l1WOJ33kTlPid2Mn6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQU4P6s2JdmSBhZv/HBbvvygBOtowHwYDVR0j\nBBgwFoAUEITL/yd8FNKO3GFRZe+4tEfL4PwwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDiGMVh\nTFQNYG8U60jYiiweXO4m5gAxFR9mfpovQqPUgwIgPZIIppkyt/o7clgsElq19tw7\nwXBOHDBzniIDlBPA1Q0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV4dUEWIdBku3ZizUhL9brrwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2U1Nzc0Ny1kY2U2LTRiYTAtYTk2OC0yNmMyZTI0NDRhY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuJ3AzVMYaVc22r3Q49OZY89CEi5kJsexfyCrnrKl9C9Lp\ndJQxMHK7amJ6cWtlpOfQMdwF9WYXILPVHUjvrCLJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEITL/yd8FNKO3GFRZe+4tEfL\n4PwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOf3XsU+FVb14zS63zoQUy/Vg4t18AAgQqVMMz/vQ0IwCIHTPzsI0ufcS\nZEDuW7LOVCVUkJkgNoqqwsufiNvMs745\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAZV4tXiPvdaPmy8LQZIeYLqaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBiZjQyNTItNTRiMS00MjBhLTk3OTQtMDAyYzE3MThhNzQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM1M2Y3Y2Zm\nLTQ5NDQtNGQxZS1iZjIwLWU5M2JjMThlYWM5MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOtow3Z5bVb2UPGOuhLZG0Jq1/yvuj1AnlD+vc7ynN+A1z5aMP3wnJZV\nBDvcI9Intn/anr0cw/d7PfG3F51pQJOjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEFOD+rN\niXZkgYWb/xwW778oATraMAoGCCqGSM49BAMCA0cAMEQCIEJOWIZvT2noOS4WSE6d\nZg0Khsjhe+X2OjWZc5iwoIzrAiApeHs6iShZyhhUg12P1jeBjvnBNewG9uW2dy1d\nBDMPsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc794", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `794` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAWow1wJLtsYbuh7FzJHazCJhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViYmI1NDUyLWQ1NWEtNDg4ZS05NGY4LTI5MTg4NDIxNWMzNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIzMDFmOGItZTMw\nMy00N2NmLThiZDUtM2U1NTQxMDU1YjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0qdjFUL9UFE65fKSCIglTKRMYjZ0IGgcppysg7Uh0iSJiG0OUceR53A9u3Yx\nZwkyM+mUa9j6fCDrDIpFayIH3aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/asa6wN6mohuv+FmGXZlWeGbT+gwHwYDVR0j\nBBgwFoAU3pwJ/69foFaTg/8CalPlNFsqVnEwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCnU366HefP12OY7ltynk8MaFuIGjeCtBX8WOEec7l9PQIhAJIbymxf\nRkqO0Ji1R7xuoyYfcSqluXcldqU93x9Byo9g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfLL0Yb5eRIcMH2tJhryU8LeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmJiNTQ1Mi1kNTVhLTQ4OGUtOTRmOC0yOTE4ODQyMTVjMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7R4rkWIKVbfJamwv/cLZ/rUvzobDm1v18SXsRiCn9G7qj\ngD6eev5MGnYdPLB3KNIXRHTheDKLwCIcouFS/hTio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3pwJ/69foFaTg/8CalPlNFsq\nVnEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIUGv7jn97MIHW+uEjHRneRkoT5QckwsXA2cKAQvLXqwCICOA1njmTGC+\nXJ0ajDJJU7fL9s3dEyt2rfPJUXzE66Jq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAd4mThLdxOn7aLTQ9OILAwGRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIzMDFmOGItZTMwMy00N2NmLThiZDUtM2U1NTQxMDU1YjQ1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM5MzFiYzhj\nLTI0NDEtNDg2ZC05MGU2LTFhOTQzNmI0N2VkODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJHAdqlthCf6IKRoRGfYz8ztFzS/McmJ9jBdSfZC5oRMg8Q13Ub5/kZ3\nPYuyfJOp38OmgJCdRVY9U+jsBYtlaKKjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP2rGusD\nepqIbr/hZhl2ZVnhm0/oMAoGCCqGSM49BAMCA0gAMEUCIQC+/IZJJTHaZGG6jHkG\nXpQ268w8atAAsw+BiZXeHDSI7wIgXvE7PrOY8LzjKxiJY30FvU78cmo4cM4sBCiu\n3aKGW3A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc795", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `795` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAaYghn2LqjSQk7mtqYtF8yydMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjYmU0YTAzLWYzN2ItNDRhMS05MDRiLWI4MzU0YzI2YjFkMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjg2ZDY4NmUtN2Vm\nMy00NmU0LTkwNWQtNTEyMGJjOGY2MmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnXJuXs/gDKxDcD1iSbj4eNlhiDFLLJPYNHgeY2xTutb98dexJ/ZD94b7afVU\n5h+MwgWmEDMK0nAAkYxwAvyDVqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Mf6qdfCjN5QCDUYkhK4Yub8fQwwHwYDVR0j\nBBgwFoAUW1qqlY/2XlgWqWWuKu/w9NNKdCwwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIBPZ4VRVm/qYXp3RVoovAXNNn59pltjPAfp+7hLMUDLMAiAnjkw6yuKT\nS+525yNc/mFCYsBuKtC79pOZBioUN7pjPA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa5pxKIzOlWhBVEf12zg7X6TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2JlNGEwMy1mMzdiLTQ0YTEtOTA0Yi1iODM1NGMyNmIxZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgPL+WsUx6o/w56lENR8Ecqjy193Cs+zt3GOKl/l+AnEkz\nbMnMAxSNzALzy4eq2QH+RjaxU3BB0KRvv/Jl/0fXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW1qqlY/2XlgWqWWuKu/w9NNK\ndCwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPZTcDjbKcMMcbYnA4ONfsNmUoJC0yVl3gmUqxudTuF+AiEAgsvWvHXp\nqmF87nuBTjhIXw2h7nBTOdaiwSE0PhEfKiQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAR9lm11lztbxdGtEIwZwnEkKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjg2ZDY4NmUtN2VmMy00NmU0LTkwNWQtNTEyMGJjOGY2MmY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA5MmM0ZjMw\nLTg1YmEtNGJmMi04MTUyLTg3ZjFmNjFjMDMxNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAuIjZ6w4THVl99I2eqX8jNi7YR0iZoXz3908C1JaKnIJR+bwSo14gZe\nRXgtIr8Kt2Kxl4uI4jWvgXZPVnVmlISjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOTH+qnX\nwozeUAg1GJISuGLm/H0MMAoGCCqGSM49BAMCA0kAMEYCIQCEq9BoJRFr6tykxC/s\niovW9kOEQk3MYwCGZab5Z+B3hQIhAPcbxT2l9oREXUXHJBS+B6FrM5Ls8JM5ep0b\neByMMC30\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc796", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `796` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAUVwHishG9eNLWcvl4AZgVBTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkM2JiMzE3LTIxOTUtNDk3OC1hYmY1LWFjNjQwYTFhYjA4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTYwNzU4MWItZTlh\nMy00ZjZiLWFiYWQtNDc3ZjgzNjBkNmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXsl/Cu+1ndf1Z/NLIQFPKnFPhELkaabfl+c/bh2TSFxdNtquqj7ZsKYBZAx0\nLLpsRlDd6Ts1OwD1oEpqTQ/UwqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH7XQALF7vuY6QfML0cd6MAMX2NgwHwYDVR0j\nBBgwFoAUtq93tcG2xQJjdLTkLZjw6ekhzCUwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIFQzjxDXXnA0o7iuw95wpJjfaqE1tAoNNDogXIc3wt1SAiEAwYCyFz3tnEX9dl70\ntzf+ROyTAFFUJrVS/Fbmg7BJV5I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAauONE+ro+0X2XZ/lnlAgZC3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDNiYjMxNy0yMTk1LTQ5NzgtYWJmNS1hYzY0MGExYWIwOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwfIQmMhQBT2unWUkyjtUu4w+RiwhyQEs+wGJadwoP8CO3\n8oAZMOZ9Doxx4Dxn0NYuvKjamKg6HrtACJQkmyafo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtq93tcG2xQJjdLTkLZjw6ekh\nzCUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgb6HyxDGuMPLvHOLEkohLCH1cF+O00Xm6Cz4AfUI40/ACIE9kx4mpoTHI\nNam+bWvEeu+9NhdDmVTffvyzTx+oEmME\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISATxGuUjB/cbsdUxHZtOV2EpXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTYwNzU4MWItZTlhMy00ZjZiLWFiYWQtNDc3ZjgzNjBkNmM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU0NmU3Y2Zh\nLWI5OWItNDAxZC1hYjBlLTNjYWU0NzY2NzIxMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPFNnZ3tk7wLNu8ToWk7EcOAOEIEjdIVvK2v0t7ICsy/3PmEhAFCl3Fj\nJTQHGQ2VhTrNbNdo5H+hcIQjq8vaSg+jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB+10ACx\ne77mOkHzC9HHejADF9jYMAoGCCqGSM49BAMCA0cAMEQCIB5UCx6KyXpMHKGYbkme\nRWoGIqYbPiKPt3homsJYBNFGAiAvPaap7ag9R7Xv9k3QXGzJhwb5FaowlFah6IPq\nkRyF0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc797", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `797` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAV33V4Ieoff9keKv9FioGYmXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlOTcyYzIwLTRlOTUtNGY5Yi05MTI3LTJlMDQ1MjJiNDY5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZiMWVjNjEtYzAy\nNi00Y2UwLWI0MDMtNDAzZmYzMzFmMDIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpW/Hw6NcGkxdfY4vqoto8RjB3cXS4rvflYc0IKc4FKlBD4MN7jCVyQV9ux/A\n4FN5gHpw/ybOg6r7jpbfSjW7c6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7hpZSLgnljPgawjGib+0wpyJaxEwHwYDVR0j\nBBgwFoAUONmEnLGluK3mC21kG6Z67nT+2BAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIG2J5FlN5qwWcTyOzEAMAHH0DMxN20Sat/JHgzcfdOR4AiA6\nFYKyqGTn+Tjex6aFmVg47uYHVSHsN/NQDDnTR7gPTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb12HiaAdvV/Fvi6+V9/R98CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTk3MmMyMC00ZTk1LTRmOWItOTEyNy0yZTA0NTIyYjQ2OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBaVKtH210vGoIEZ9GnWiP8mpqVnBwZWdBftI7Mhqqf8I+\nvEwTw0eJNZ+0BFGwE0JJDisVZ+tslzKVkY2q+JImo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUONmEnLGluK3mC21kG6Z67nT+\n2BAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALZQutO6uNdFeddFN69dI6VxV7P9wPa4Kd3nWt2/9mXYAiEAnupWvAOT\nRyREJGoEM7KRuhLduUmWTe9XB/t0rNAXgvE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAea7SJ6Ef6CN/bV+rUo385jMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZiMWVjNjEtYzAyNi00Y2UwLWI0MDMtNDAzZmYzMzFmMDIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk1ZGMzMGFi\nLWQ1NmItNDEwNS1iNmEyLWQ0NjRlYmI2YzBkNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCjQru6vh/jKpTVYArLvZz05NBpkhRojOxWCYsnoyRqqiYO6AthYA+PH\nTMYJbbWHoo852xCquuv0HTIrOcRnBIejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO4aWUi4\nJ5Yz4GsIxom/tMKciWsRMAoGCCqGSM49BAMCA0kAMEYCIQCv3LrEqKci3/IA2pEj\n1DYSgVS+tvjwfsQg+3qZEXNdzQIhAKUtI8xhHH812IX5u6KcpQ9pyzgvCHSHQ4rC\nPZBp/5Va\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc798", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `798` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISATyhdQ3Hb6QrmbQzdUfTENLJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmZjI5MDViLTM3NmMtNDI0OC04Nzg1LTk2MmFkMDk0OWZkZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM4ZjkzMjktZDhm\nOC00MDM2LTk2ODUtZTllMGJkODMwYjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4B+FiWgswTIq1TotuZVnanes+B0PGmuJHVKoqpV1GBBp+GOLWBgxkdLwkkxC\nW3KLxYtzSebwvhSLebO60ff7daOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK0sareeSX2l8zB2Rh48oCtqci28wHwYDVR0j\nBBgwFoAUfbsgEVsslOx7CdLdQyJQ7jrWPyIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIC4NMXa4czKrkP2E//NYsZGvW1RpU+KSegBQ4Zun1rNFAiBv\nyvEZcowppCEN86ocl/DliXTy/HNxxvODgAWjEWtfOw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVB4FxCkJiP6BPuSh9f1m4udMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZmYyOTA1Yi0zNzZjLTQyNDgtODc4NS05NjJhZDA5NDlmZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqMxSGwSIz0ZUnC/63DmLf5y1aivPWJ86XOB+1v0wdvXGa\n+J/0jmV+oAz1hIveqkP/4IO7z+JIESnkTr+DFRRqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfbsgEVsslOx7CdLdQyJQ7jrW\nPyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKMGuWIM15uLl0eHbn/mm1xMKaM9FagC4hlmZw1gvRf8CIQDeaYkKCaHC\ntTQrfpUTiXhP50snqeqyM8lLIu/ZSbDS1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAXnPmt4/J282BaOAKKCOGJEhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM4ZjkzMjktZDhmOC00MDM2LTk2ODUtZTllMGJkODMwYjE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg2OTM0YTk4\nLTYxOWEtNDA2ZS04ZDA2LTY2MmYyMjYxN2ZmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPXCKQ11p6Y5dti6h9rD9k/xQeTv1CH6aKWTSOYoQGl3fXKq6YhjZllz\nEhHbhRgQY2AkZGQxUSyyXp75JE4BcqOjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCtLGq3n\nkl9pfMwdkYePKAranItvMAoGCCqGSM49BAMCA0gAMEUCIQCTFWZNCZkaQ6MvrH+k\ne564E2ngrZE0xEy22HFcFI14jgIgY7QkD1+2kXW7R6WRBasu+uX3Sd/TWB2SPq02\nocqZTMc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc799", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `799` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAceEDGWpmHet8J87To5XdloCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxYzNjYTI5LTczMjctNGJkMC1hMmM2LTAzOTc5NTg4NDhjYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDljMmQ0ZTMtYTBi\nNi00NGU2LWFiMjctMmRjZjhkODE4MGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/ANvfBuejpC0ILoFFRyApnVFf0sRmXqVZFbc5WBZddlz7L0lDKjgyRYBtek+\nJWDw5M5nl2MVPGEK1zpCYRhaPqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURRQ54iNBbhq4TUHG/iDvq06Ldb8wHwYDVR0j\nBBgwFoAUgP8dU2L5kLNsWSiQzmoat9oTGsEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIC7jTdTTGwS0\nokSLnvnIZ4GsYCTYw6OHhK1hpFTZqLm0AiEA1l0LNleyGpAe60tMelpt+HUzEWtY\nRiTNudfc/rirRuQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZFhb1FssWBIThADie9lndFZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWMzY2EyOS03MzI3LTRiZDAtYTJjNi0wMzk3OTU4ODQ4Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9s4SqL5VXrr1ZqiAhV4sIId/tA0vNrTFBG9nvZrFCHMPd\nKt07YeTuJD0T0VmcOePfTEUL8ovNCEKiCssaoUCuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgP8dU2L5kLNsWSiQzmoat9oT\nGsEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOpTYoHIovcN1zrOvep2nWGigfLlCCEbNQjl227Rvp4ICIGz0YnzGeNLK\nu5bWe+YkmGTVQga/Ymwc2AVgOJd2iFKc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAewoiyNXt44WqJ34cU37afZJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDljMmQ0ZTMtYTBiNi00NGU2LWFiMjctMmRjZjhkODE4MGM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVhYmYzNmE3\nLTlkMTEtNGY5ZC1iMDhiLTA3ZTc3MDI4YWQwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGbldFxFKAfBRjp+uT9ONT68s0/13F9C0JeG6BH//xfDkzdMU2kck5gb\noo6DEn2yk0FhNF+srRk+gMHwYbDEa8yjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEUUOeIj\nQW4auE1Bxv4g76tOi3W/MAoGCCqGSM49BAMCA0gAMEUCIHs8U1xAkMsruB76vGEo\nReilvzhdPE5P6MUi4p54iHsFAiEA7PqiMPsRQT9ZJJQAYhoJUFxgs2hrsO11LWhh\nYtv2fec=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc800", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `800` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATPHLE684MLM6ay+DE0sh26NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzMDc0YWI4LWQ1OTEtNDE0MC1iZGYyLWNkNjg1YTA2Yjk0NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMyOTA2N2UtODU5\nYS00ZjdkLWE2ODYtMmM2MjEyN2VlYmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+/oPxa6HOU0caGvzz28GPpbJUwwehogh+2V46YRbHkPgvk8XhfPgXY4UX+MS\npt6XtMiImJlLcA0zT5urRyg/0aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1sJqTMq1cu+fffEadhAuo4c5UUowHwYDVR0j\nBBgwFoAUMRSs9kGv3vkIr5C9aDv0xotkfxkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgO3aIK7LxUQJVf8tFz7FELfscoEvk0DO8zmMecg76TU4CIQCzjxOerQyi\nlONL+MN3wYGbqIjnkfAaAOhFMvPY0z8A7g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVK1ZIxSqLqhLAclicg0i9PWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzA3NGFiOC1kNTkxLTQxNDAtYmRmMi1jZDY4NWEwNmI5NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq29Q7cI0FhBlHrItwBlSzjyNcVp/F8l54VZlew/g65yeP\nxNBk3670lXYy0K8EePJv5X+16gAydQlRf/LgEZkdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMRSs9kGv3vkIr5C9aDv0xotk\nfxkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWKu0Z6oredOY/GqBuZQcG+5ae/Fer5IUCJzRoeL/MKoCIQCYQoEzyFpv\n61N+SCGiHVOPkOB3rhV2PuvAQq1WDO7nUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAV36RDa2j6Pp8mGsPf/9euLeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMyOTA2N2UtODU5YS00ZjdkLWE2ODYtMmM2MjEyN2VlYmY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM1ZWUzZTIw\nLWI3ZjQtNDMzNS04ZGRjLWFiODNmYzM3MDQ3YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB1aAHJ0E0Ngr9TPMx1OuUa0hEahFvLDLxzMSLxwrYXFlgw5tiAzX0Kc\nI4H/5C63PI2sLNru3jcL4TslyI+Lk6GjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNbCakzK\ntXLvn33xGnYQLqOHOVFKMAoGCCqGSM49BAMCA0gAMEUCIQDpHuQLV9fdHwPyG4CJ\n3JphS72M4CGxeqrBr22nSkVMBAIgK/VwGrc4xdl1xpGIl9Zb0SbjipRS7Qcv9NDs\nwclKoos=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc801", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `801` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAYZ7k597LNDaaoUTU3q6XpQSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZjQyYjg4LTFjZTAtNGVjYy05YTgyLTUyYjg0NjNlZjk0NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmIyZWM0NzAtN2Ez\nNS00M2E2LTgwYjYtZjEyYmYzOGY3MDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaL9ODSOWZsHNdXuXAR9yXXsjWTXzFvNBSlKQ7bwjWTSXpYz5HJWQJmJgJVsc\nyLFI0vGyfyzpcUoB8KyHrrmAtqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxWJ0pvdHp7PrKD/dDDA2M4TRx0UwHwYDVR0j\nBBgwFoAUSXHTYDmRQ0M6M4k0lJsATmNICnYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgaJq9MMZ5F0hQft6BFAOWPpTxVFYS1x0eR8AiXfaA/kMCIQCA4JsLzGuv\n2l8bjrnkVnGoYcgEY0udxB3fagR++9KQLw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbBE+KEgBvy3PSSmxKepUf62MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGY0MmI4OC0xY2UwLTRlY2MtOWE4Mi01MmI4NDYzZWY5NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASO36GYXiTludfUmHymsqHZt+w0ZdRiBa2SWZUq8haj0Eee\nFLe6+LxrdDMhqehwUE3i364/8t3UrDEse4mqufG8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSXHTYDmRQ0M6M4k0lJsATmNI\nCnYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXRw/sE8gTxuwGOKAk0FBL/5vUvmgX286mFZ6MQIi93ECIGqP+eEkkyci\nm6YflKXYsfGCv4zU7juOx6htZi3wsacz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAdxAnAexyj0borx7lriO5ym4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmIyZWM0NzAtN2EzNS00M2E2LTgwYjYtZjEyYmYzOGY3MDVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5ZTQyZWEy\nLTg3MzMtNGEyOS1iMGU0LTM5YjQ4MWFhNzQwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFGMYths9OgS9SVg9zB2HndVKl7pjidfD/7ocTdYuW5ZZvz4U3pBjbk1\nauEJowdgtLM4q5VpBi8Sae5pdNw1GSujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMVidKb3\nR6ez6yg/3QwwNjOE0cdFMAoGCCqGSM49BAMCA0kAMEYCIQCBWhVseP4q08/kVmbd\nr4qXkooP1pcHjmrDuqbNjWeSxQIhAMdoKx4W3uPeJ+/T+kPbyixNVC7rSyOygNQz\nBeqqraAk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc802", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `802` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAQQhlCYmVbccRCPehFxeSRk/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1YjlmODI2LTA0OTEtNDFjMi04NGJiLWQ5ZjdhNmY2ODFhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU1OWQ3Y2ItMmU3\nYS00NjFhLWIwOGMtOTcwZGM0MDUwMzg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE23hMFOaVbEFqvObU63vuShCQwQ9AOAI+BCZmOZO9dxsfA3qkYH7AQMooJf56\nUXD9OCTuUzbSeTuL71EduCXYc6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW6OGL92DAUyfhVNCBWXJ0MnXoakwHwYDVR0j\nBBgwFoAU7TDqyRT7OJojQC8epZI7mhm3d5wwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQC8iWOcsC9KE2LCqoUDhWsl7P0pS4dvnqw5DZbjTMESXAIhAKn2rSgx\nLKfuN6mK6iuIIlnGNorzWx4vNRgZYDwesKfD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARXcRX2i7L4mhp7Vv6WUsbqCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWI5ZjgyNi0wNDkxLTQxYzItODRiYi1kOWY3YTZmNjgxYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAPsicCNp6DaRnk/RjCVSe0qjrRIPN0uA+FCS2DdY0gA5L\ndF+5DC36Z90BroFqSVfDGhzkjKyTddukY6j5CPx9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7TDqyRT7OJojQC8epZI7mhm3\nd5wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZAaMU2Hnwcncws0rzsXmqgm+8V+K+ibzHC4OSv3WifkCIQCyanXjdegd\n7QU63Y882hkRuuXMWV9VQyIWPkWPaFFavw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAX7TEN0jgFWEAGtCa877w4JJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU1OWQ3Y2ItMmU3YS00NjFhLWIwOGMtOTcwZGM0MDUwMzg1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU2YzEyNTg0\nLWY3NWYtNGIyNS1iNmQ1LTI3NDM2NGM1NGI4YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKUoAPCxPWdHGSW5IhtsIXiCrjZrlZsBYoYyxQc1DOO69yi69hxGW65M\n6SqCeU202Wx9+YNZ2+aM7pdQio6gXVujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFujhi/d\ngwFMn4VTQgVlydDJ16GpMAoGCCqGSM49BAMCA0gAMEUCIF8f6DkKrxxM2x56GOw4\ntCIUUnRkNspLpx5QUvL5M9wJAiEAy2ZjmiAvpm/TGUtNgpLWDyMu10vCBK28p1rb\ns5bne+I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc803", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `803` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISATdZSn6xIIdbBKavjL3mHhoNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyOWMyOTAwLWNkM2UtNDExNS1iM2UyLWNiNTViMWVhYWE4YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFjNjQ0NzAtNGVj\nMy00NjhhLThjM2YtNDRiYTE0NmQyMGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoLd9TgFbYOTg3uTCaWtDM6jFG4//F81bIFVzH0yrMXGqKIp2xNeJSEW6rM5Y\nz/aLcNB9N2h4ir9X2MIPN3pUo6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmyANgq0hW6mGe/bDPfqN+vP8vMAwHwYDVR0j\nBBgwFoAUblAtMKCYpeaL2/dl1x3jW+G7rT4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDmWbhWshUapuXalGBfay1p0hobYJQUkUZKfkyE\nDZaSgwIgKkXi6H2kgsCB+jH08NMQaU0WPujbmq3TZG5n2iT5U9U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb4vLmU4HWhYMtI32QLSo9CAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjljMjkwMC1jZDNlLTQxMTUtYjNlMi1jYjU1YjFlYWFhOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS02IgD4qA/hdfZTWoqwZXu0cwb+GuOKGTqqz0dpx/2DTVA\nSeVX2uxCzyqdNandUfSkKB1BbPySQP1kKhit4M4+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUblAtMKCYpeaL2/dl1x3jW+G7\nrT4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbzVGUi4vAoSo/FPrqOpEDx2DpzaToAuRV7CUoF9iWDYCIQD7TExGhDhY\noMhPjIMLfmy2hktcNiGxo+SVpTJ/rxGFmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAVouVIUAb4L+vRbiiLCsY9zuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFjNjQ0NzAtNGVjMy00NjhhLThjM2YtNDRiYTE0NmQyMGRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhmM2Y5MWFm\nLTNkZjYtNDk1MC1hN2U3LTZmZTA2MTM1MWFlZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOk+R9VHCZUKCdrDnbOpqIXxV+EIxU/jLEfIAZkCDliQHqjZjj7QGq8Q\ngWIb4FeaIUa9HvUG/GZEh1txQOz8cKmjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJsgDYKt\nIVuphnv2wz36jfrz/LzAMAoGCCqGSM49BAMCA0cAMEQCIHAjfXAp/Q4hRK1fj9I6\nfKOqekIDiBAeURPMZzI44YxeAiAgoYFvNslOCPLS+aHVlex32wLjJdFz5ShdfhrR\ngjtyiQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc804", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `804` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAcrq1xYJwlfVyBgLDbd0SApBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlYmIwYTdkLTg2NTktNDFmNy1hYjJlLTNkOWNkNzY3OTg2MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRkOTg3NzMtNTEz\nYi00MGVhLTlmMGItNjQ3ODNjYWE5NzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe6iLqI96ofz8fIsLRmn69bvScZiLBwgOqaYPgwtETkBRuEBWAPLwwz++999L\n2ar0B4aVBnY101A/TPIm+0AknqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6hsKunDojId1sF//xhJ2d0zl6+QwHwYDVR0j\nBBgwFoAU4uPFRrY6cJCqcvt+Xl7lh9lW7QswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC0wXaZg48+0j8NkPYgnPN6NUQdYPVXZ2oJG8y9\nYrP1gwIgWfDYBOkWPvK1HJiwmQDfLSIAf3esVwAV/nyladxDnCo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXi8BgM7qhZrU5mDUUE2qravMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWJiMGE3ZC04NjU5LTQxZjctYWIyZS0zZDljZDc2Nzk4NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARL3eQkDvt2OUnwzO2XmcAcelkNbu4lSZgVFaUyMoJHsIM5\nDkWGMW29WMwEgCHkREd3P3EnihXbM1Z/HMFc3IIXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4uPFRrY6cJCqcvt+Xl7lh9lW\n7QswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPh/1Q1ALLCWAQwDHKPDKzMhaeqlaNcSSdCb5H+ofxI9AiEAqKU8yerb\njllK6ol2mKSJAQZMEy7GYdU2Rd1foQL55hE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAQkJlA35s6A5jJ7Lx+H/JL9+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRkOTg3NzMtNTEzYi00MGVhLTlmMGItNjQ3ODNjYWE5NzJiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY1MmNiNWQx\nLWMzYzktNDFiNy1hMzdhLWQxMmJkMjIyMmQ2MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFKiUTuz9SE2hvykcNZ/ePQUCp1P49fM6v1n3wgelPvUMIYiF0ctW2ZP\nIKVgR9V5Q/3TQE88OW5S42bPgPaelEujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOobCrpw\n6IyHdbBf/8YSdndM5evkMAoGCCqGSM49BAMCA0cAMEQCIDhYHopLlUlytgm84obE\nJXAYkSxtKhmnGaDyV38Xs3BbAiBUHUPG6qAxpo4wkLKN6ijXUWI3dSroLMy7K1zW\ns1ZyYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc805", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `805` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcZgr4V8NOVGsLAEhife1cPFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiMDUxZTJhLTMyMjctNGZlZi1iMTRiLWRjMTYwODYxN2UyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjEzYWVmOWMtY2Nh\nYi00ZWIxLWI4NmYtYzJjMTY2Njc5YTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERuimTvmYY7KpUOxGvtp16jEJtmCMP4dV66mAI882m1FoQp2RFvYIF9PU+Por\nPswZ3G14cPcdGVFCckGEMbF+raOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU01yAKMPNww6dTW5dG+9FodOQEGQwHwYDVR0j\nBBgwFoAUIFmDX7vKMpT/dA5HToo3bsIPiwUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIGlqQfgJL/jz1X49pxQ7C2IORbCg+wMd4KdeDPdmAbjdAiEA\nhStXrTYWp17qNebuS9cFN7q+IxHTjB8ymB3fU3HBAwg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd5MrzAn0Ru7OaE21dQiGZ0AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjA1MWUyYS0zMjI3LTRmZWYtYjE0Yi1kYzE2MDg2MTdlMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQj75xl/wDyNRVFBsqOpmcpM+K/cLCM/BdwBAIHhLvXeSm4\nNZHurBWP7Qbu22BxuAPtDcrh4SzCPeiPRT9lXBCpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIFmDX7vKMpT/dA5HToo3bsIP\niwUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJHrq/eJx5O3cotLRIzkWca7uh+juF5/u4zl+vjcwqYcCIAoJnu+qPa7L\nPA7Jt9N7UtTt7XBcCvy+surDS05mWmqD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISATKoIK6pXm4fTJGK/h21C27FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjEzYWVmOWMtY2NhYi00ZWIxLWI4NmYtYzJjMTY2Njc5YTAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ2MGI2ZWNl\nLTdkZWUtNDg4OC1hNzczLTU5MGNmMjViNzAzMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHvYNhHjihd54NPpX3a4KF/NTG3ncL4kMYcoy2qa1Svg09CBLZhcM0Ci\nmnvjtNftM/j6loEVClb4rdb9hgoZMqqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNNcgCjD\nzcMOnU1uXRvvRaHTkBBkMAoGCCqGSM49BAMCA0cAMEQCIDY8I733zIEESMv9QUMh\nP4z4TiOfItC+eKn8u3sz9imtAiBUE3UhZsFPn7rZ0jQKsgfW/Dy91oPV8K1AtLAR\nnfTntw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc806", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `806` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAd1cAeWH9jb1ioMZ2ZzU/IWJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjNWM2NzdjLTYzYzQtNDI5OC1hMTY2LTNjNjk2NGEwODYwNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDkxZTQ0MGQtMmUz\nYi00NTA1LWJjZGItNzUxZTc2M2U4ZGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyd+zP7pqJ5rqetcoeXIHDn3ErOA2D+G9B5xqxNDBlVzD0Dqpw2aoV6MtmHxt\npAqKuOyys1MYNy8H3UAdPgKKvaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpNOgTFezMbMQ/q4CFgk9alRqlaUwHwYDVR0j\nBBgwFoAUNdx5ry8Ocj1lAeiidb3nq59VY9YwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBenj1Z+NWVGG1GgqP6gyLqv9Xa/wNy8\nF0OGAxLad7MfAiEAvLmwXQBxil671Qw7VEMVB1w/4JwAFTG/OgJXZlohekY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVpwydMMw3eEp9abcYjXo1PIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzVjNjc3Yy02M2M0LTQyOTgtYTE2Ni0zYzY5NjRhMDg2MDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ43KiwoBtqG6FRo92ICpqeD83uOmygSUvOnS0vBcaaTIed\nNI8AmzlUy/KZIuQgkVfLMgm4WUe0hDkuumDu4Lhyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNdx5ry8Ocj1lAeiidb3nq59V\nY9YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKdkwg82g2ET+ztL8OfsSjg0Ixm2Pt3u7YPjs9s5LRa3AiEAxZz97tay\nedrheYNysglR7bVFRkXJE3Dq5Jd2wy1j9nw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAfYQpoBLaru1N9kE1TVWimzAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDkxZTQ0MGQtMmUzYi00NTA1LWJjZGItNzUxZTc2M2U4ZGIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg0MTdhMjU5\nLWYyMTQtNGJiYS1hMTE4LWIxOGUzYmJmNmFhZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBMXmoHhYn+o3MdsmdGRSZ0GEVJvQ1TcY1Xr9Lm/PSHUKflbJArOsBsZ\nkYHrECjuTQZh9V3kfyjEdEcegGhe7aOjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKTToExX\nszGzEP6uAhYJPWpUapWlMAoGCCqGSM49BAMCA0gAMEUCIQD+KVloiQ4uknvK86p1\ndhNcGdreWR8EIdYwyFvGp7ErCgIgUrOIU/sIImqVHsU9N2BsFvjMTt0S4HF8XVw3\nSJGNcQ4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc807", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `807` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfd2pTPFbn7gx/d/UJUQkiqUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzMDg2OTM3LTM0ODUtNDU3Mi1hZmU5LWQ1YTVjMGEwNzUzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdiMTM5MWItNGI0\nZS00ZDQyLWI4MzQtOTkxYjc3NGQzYjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdQ0vXVaNc6i8IfdVIMlQAHmsYOFu1mSHB0BQnVpoY3cozDyhuDbiKmtJKx3B\nw9sN/t6IPZ21uQEqEomat3Ozq6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURtMfbJfr5hpuSObqEgEOBR+/DsUwHwYDVR0j\nBBgwFoAUVuS+CT7KL4Q/F+KvzSv2Zaj4AmkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIAmFjr6JnmWOdGkxyhYpQEEfCHhCFs4l\nueqftMCxy68vAiEArzCmjU57+7p9FKESa+8Eu704lr/2OpWmg2A8i8l776E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQOB9nZshlWfQK8sJgoMePErMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzA4NjkzNy0zNDg1LTQ1NzItYWZlOS1kNWE1YzBhMDc1M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgJXafLQJaIj3SGOx4+xxJDqcd4ZmARee+cSniO7bAJZ+4\nmTkPYv1EoWAOuV12l5BfWq3GVtiQFT5DCfBsyZwjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVuS+CT7KL4Q/F+KvzSv2Zaj4\nAmkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIkj6QBr7Or4VbMJWDrrfqqdrJPcw6aWewZeE+HrCvCeAiEAjEXgmAP0\nII3g/dBkdnfmOfwRZub34mtS1aYAd5vuca0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAb9LOrI2jVbpHdqR2p5KFeyVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdiMTM5MWItNGI0ZS00ZDQyLWI4MzQtOTkxYjc3NGQzYjNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIwOWZhNDM2\nLTUwMWYtNDQwOC1iODNhLTM2YWFiNTRlMTdiNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLLbZU1VB8bsuJWDD4E+o2j5A9CuR4IzVagkR/rnC9oqvESLgOcZkzhu\nvG0xwqq5K45owyyod9stYhSc6eVBZqmjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEbTH2yX\n6+Yabkjm6hIBDgUfvw7FMAoGCCqGSM49BAMCA0cAMEQCIE0R73U4xzlhmDLHQt4u\nfOJOu1fSMgpWBqOaUVqtfRlGAiBlc9b12oXD1aVYMRh/ltbJTNmkRUTiwfoSPubN\nHISDRA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc808", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `808` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYwU5n9I3qBaiIyynr//1a6vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzYjgyOWQzLTRjZTctNGMwMi04ZGQzLWJlZjM1ZjJhNTU2NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhkNmE2YzEtNTAw\nOC00OTQ2LWExOTEtYmU5YzgyZTVhNmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkSy64ethX3Eg3soLp8jkuZZHh1DX7i4t5ujIqx8cK9G5PWF6YTimHaaf8mFm\n/3oBDdn4dCqrQ4Ndcv7sOJoOpKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTjIWsl5JFS4WlEc7OZVz4zWvVu8wHwYDVR0j\nBBgwFoAUF10hf6nmwvN46yTJIH3H0VWi+bwwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHlvBdj2fW/Z\nWKzGJsHHjlum3GvRnpyvgMZPbJjNLKkhAiEAj9N2BucY7WhtVbVdrNvKwJWooasH\n0Avqi3WSfuYDANU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASuPld3facxqExp2eqCz9ZXVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nM2I4MjlkMy00Y2U3LTRjMDItOGRkMy1iZWYzNWYyYTU1NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtSyFycPfACxAKuWPbcY/YWzKA9wScZwVrHVUWrPmKLk6b\nC6+M3mSCNTOHYJvDtTXN548w9vWQBgTrT60y07bxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF10hf6nmwvN46yTJIH3H0VWi\n+bwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKdu1cz9bX69PCj8bCec+4tO/2Qrh7JgtZk98UDANGLgAiAWdKyky6ay\nsLb4h1rT6+r1k4jIFiUFpz1i3scTwdjW7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAZuKYiwp7qGyCiV0kxnABxFcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhkNmE2YzEtNTAwOC00OTQ2LWExOTEtYmU5YzgyZTVhNmY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI5M2E1ODVm\nLWUxMTQtNDUxZi1iZmIyLTljYTY2YTE1NmJlYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKSRF9fJdySWx4hAxwd/sPGUfQsWQLy15wCWKxqZd1jXsMkipOpM4OzU\n4Xsh1gSJ4r7HV0bbCw55J6TadeL3KJCjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE4yFrJe\nSRUuFpRHOzmVc+M1r1bvMAoGCCqGSM49BAMCA0gAMEUCIQC++RhS0xItVNvF0LeT\nUExUVGODAjnvUoT30X/9FsKFJAIgIfcOlBsHhSxq28Tix9uMjv83X7qVNsyX8myK\n8s1THXA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc809", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `809` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAYkyuiu8E6GnxTn0P/MxNRplMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiYzAyYWE0LTkyNjktNDIwNS1hM2NhLTFjMzk3YTkyYTc3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM3ZGUyMzQtMWIx\nYy00OGJjLTg4NDAtYTkyMDc2Nzc3YWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJaNLrPUWpyGqx+JmYCxR9QkIkuCFElxvr6kkOLyKJoxAbYZtMgaXBwz4VZgK\nrxCd1HWf/IoqKkBq4NqvHtur3KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqAkgqKnq65VhpOrrVwKlSDC2muEwHwYDVR0j\nBBgwFoAUGSHCO5EHsT5e2DedCjqtD+9ioFUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAICDCGPWhWssVvFLkOZLxvd0ilwxIMe6aqnzFDneTP5uAiA/GcpsgQLO\n64LV6bpUy43L3B6voOZSU/vaaCOD0ub0JQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdZoRiJLP6423ROWU62YI87MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmMwMmFhNC05MjY5LTQyMDUtYTNjYS0xYzM5N2E5MmE3NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ22cDmLsYzZvIyQs2srP/MTHi5BK3GwlRcSqNs+dZ6zKVl\nugOf1oMOikhZadTTOoHC49CFdgqQgTYxEnC+i8kbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGSHCO5EHsT5e2DedCjqtD+9i\noFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM03AByPBORKVF56AMBU48tcJOoC9wmpX6BTj+Sd9wySAiEAybgIP5nG\nq/vHcl9RDtlCaBwzrTu87hpn0KjYqJ24/Yw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISATOgCQkPAMwAEs/TXKbrssK2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM3ZGUyMzQtMWIxYy00OGJjLTg4NDAtYTkyMDc2Nzc3YWUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZkYjY4MDNm\nLTE5YWQtNGRlMC1hZTk4LTBkNjA5ZTVkOGZlYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNHHRAHgHq+h5r0DXEkBPE0CfI2xo5Qboe8u6nUyagAUfc0betm2bVAn\nZfVo61krgvSWSaVEhXgj+SFdts6guBijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKgJIKip\n6uuVYaTq61cCpUgwtprhMAoGCCqGSM49BAMCA0gAMEUCIHVKxmQkcIcNpsb8Idpv\n6Vzc6n3f4yB9yL3HbSOIQexhAiEA/IL9EEBekSotrxl4JRhXj7d9Ficws63QXilR\nx/4K4Ho=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc810", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `810` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAYb1gMrNLBHYL1cr7UNrz2kMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1Y2ZkMzlkLTdkOTItNDMyZi1iZjU5LTNhY2E1NDc0YmZiYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYzYWU5Y2QtMjg1\nYi00MzFiLTk1ZjctYWYzMTViMjgzNjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6iPmFQf47q1vZPa67VCwa1bi9QeF18UNyltPZgoZCYXER/thmf19e0u+xw68\nPhg3KsT6qWLL/RCRg3VUVZLPVKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+GZkY2XTGgxyuW/mNqeas+lJ6CQwHwYDVR0j\nBBgwFoAUuIAYbVzENCyeaqE2r6gDiP5bIrMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANqf+pU9myBNqJbsobFR01iuIaAXU5qTf0cbMYAqmvNxAiAl+X0CZiRL\nA7pYlggFgI5xT9P6Wjbe3OXzg44Qp2TDKw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUyZWFymZKuQDecReC094+WWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWNmZDM5ZC03ZDkyLTQzMmYtYmY1OS0zYWNhNTQ3NGJmYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9zl/HE8qM3gqpLuqklW67x7j8A9E/LSwFBlpgQcwqplfF\nIiqioaG9YBCB/KG3aXr/U4KdVoqDkqk0c/rkvJ7lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuIAYbVzENCyeaqE2r6gDiP5b\nIrMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgasXODumpsX7c0HWw2SkmyCn03efQRkgMAN/v6Fm+9tsCIQDCDzs0+1Kf\nfS4laY574cWEgIMpHAJKyMuDgHFjYTeaHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAUC/rYXvLb3uYXuMIlfaR3w8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYzYWU5Y2QtMjg1Yi00MzFiLTk1ZjctYWYzMTViMjgzNjNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYzNjI3OTAx\nLWViN2QtNGExNi1iZmM1LTY0OTkwZTAxMDFlOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN6XkhjjhP3q2QD0JpFmDpXkpfbgOltWrhtrOlkJE+NJOjit4fbXQp4S\n7McYGllZerBUlrZhaSp+iUJbJQH93DCjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPhmZGNl\n0xoMcrlv5janmrPpSegkMAoGCCqGSM49BAMCA0kAMEYCIQDBSZMcDIBT6K5+GT7A\n46YVPyD6alJnXblczaUsUOERgAIhANIh51Sxw6zpIuneh8ynZeCQTYcj0/gpB5gE\nrtXmo2yW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc811", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `811` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAeTI51fnCOj8h5uO7J1qI/dnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3MWVmNjQ1LTYwNjgtNDdiNy04OTZiLWMyZjczNDBjZDkzODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA0Mjc2NGUtMzkw\nMi00NWY1LThiYmUtZmI1YWIzYjMwOTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECiDwgpN1rxvbheBor2qGpEpkjhwC2hYODNwqjDADYhghhGffBdYiKm5Lo1zm\nwSCdhC1VT0ywW915q1gde1O3wqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqPMjErSvBZ9nzUhomXRPhuw7KxAwHwYDVR0j\nBBgwFoAUcFuO26Fwtv5bd7BRwtm6g5JsImEwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCCkJMoD3xkf5UgM9TD7q3edh+FIxvapxCNExoTogLe1gIhAMu8xMQn\nGjFFB3aPWC0/pEYjs4b13PeuOmIJzr4F/A1i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcDwbSTyLet97DeQAft6XCb6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzFlZjY0NS02MDY4LTQ3YjctODk2Yi1jMmY3MzQwY2Q5MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZxIvr/sgSt8kfRv6Qy/9ytbWb3y2ZZkYsG7/jG8pLIhGa\nmFVGJkUUBzXh3noFvzKek7E07IO2O0aRBFfwzfpho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcFuO26Fwtv5bd7BRwtm6g5Js\nImEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZPlomwYSBfI+b6d2iMEaGM16/TLMCwZIc1kQBVXQiQQCIQDUL79kfVF/\nymEzLVaduxRRWTXz6vpzup35RK7yRwk2MQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAUWC0OA0X1EpCFjjJQ08e9BoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA0Mjc2NGUtMzkwMi00NWY1LThiYmUtZmI1YWIzYjMwOTFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI2YTBiODUw\nLWRjMmItNDk2Zi04NzEzLWUyODIzNDFkOThlYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABONZ6/LtXu3KtH0Y+X3pPjUvRRPaXjpm1b7VrCn0kYiT9BO5s1MjgqYx\nXMM6vrZPbepwEUmtDDCw10p6iE25UJ2jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKjzIxK0\nrwWfZ81IaJl0T4bsOysQMAoGCCqGSM49BAMCA0gAMEUCIG8hcicIRMX5JY79o4E4\nDoArq+Tg4/vuAkbhc+UMpMS9AiEAzTFndUfxF3vlvnrPAbQvT0SRet71PKANq8JS\nM5i7fp0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc812", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `812` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISARVfLvD1ErRZ4fYD18/dfHDpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4MjYxNjczLWY4MjEtNDlmMy05YzA5LWM0M2UyZjQwNDNkZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVjYjI4ZTgtMjJh\nNi00NDVkLWEzMTktYzhmOGM3N2FjZGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/clsGENzZFLVhBX9/YTZdx/Re9dk+hlaAMRd4OHy7hWnjDg/nK7u2lnEM51V\n7Qn59fnt/OYKfljJN487AwODK6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5bKQ8rpWgeT2WOAY6pRw10JGP3wwHwYDVR0j\nBBgwFoAUnk+ONAdqMi6mMtLLz+5moXPZB60wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIC6JY0VvueL7+Fciv2b2GxasvzdfZ2ZD0SBVifx7\nMhWYAiEAgTrT0tjnMcy7+kqKrl2DDQPNCpLkXqsnLz9mXQgowCU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATiHM5ISdDwPe/MBmbZHigq3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODI2MTY3My1mODIxLTQ5ZjMtOWMwOS1jNDNlMmY0MDQzZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZsTTAEVYGE6zeo3w9ApsOjaoYZdLX3JWw5MVlt6OoxDTz\nrx9gRk+wjZadSv1RHB2x6BFiFpFlEHdcR3dHhgtdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnk+ONAdqMi6mMtLLz+5moXPZ\nB60wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPTWCsmgJWSrIrTAOIgc89yPpYV4TIYDggoehDil2q+gAiEAvElL/Qvg\ncGv4iry8Kxrsqsbea328SroqcR0eABKTUUI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAXAmf/3Xd4SyUraJPHazLIa4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVjYjI4ZTgtMjJhNi00NDVkLWEzMTktYzhmOGM3N2FjZGNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA1M2YzZjdj\nLTEwNmQtNDZiZi04OWViLTQwZDFlMGQ0ZWFmMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIO1JdHMddIMegbROcXTVpTcvdKZ2tyihyOgCsmorQes/HQ7CqvZN2C2\nYhUPZNHWdglNMGqkOwJCipMmDEJPYa6jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOWykPK6\nVoHk9ljgGOqUcNdCRj98MAoGCCqGSM49BAMCA0kAMEYCIQCpLvvNgAqJfyzIIvNO\nmQPw+Qlsk2cJkpTdIUuq9qMqvgIhAIHxPnJBjaMDAQ6FfBQtJVfraWiahtATX05a\nC56v0WSE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc813", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `813` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAfz/QTkFyvq24IQF+uzJTTckMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyYTI2NGVhLTFiZmItNGVlMi1iM2E5LTkyZWY1ODY2YWMyODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVmZjY3ZDItMGJm\nZC00ZTBmLWJjZWMtNDc2N2MyOGQ5MjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdMZUFGXXlOX+UoHUguTV26VSvP2woPhk4GYnYnJefhN9NMfD1AmXjWwvqMWp\neMkEy1tbWe62hbshUIKb8qhCZaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIBcbN1TmAj0Z8C/NaBBamaMkIGowHwYDVR0j\nBBgwFoAUQvVaIVLAb+SNq+lmH5Mua2daLG8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDkY7ctkpXH3yfWVCUP1nsSG48W07sJFjITPgnT\nOWkS7wIhAMbvTDFZIbNaVzsoD5uATiCtceFF9XBuuYEmK7IAZiej\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARDymsHwCgliR0lrZhTyE1HkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmEyNjRlYS0xYmZiLTRlZTItYjNhOS05MmVmNTg2NmFjMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShplQ5KUSdPxPaQHnNX1dkPhadB7BmylLsZtEYzhxLBamB\nXAPJqOuCP7rUQo3x4smnU2rsIjuBuDjhJNCy+TWPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQvVaIVLAb+SNq+lmH5Mua2da\nLG8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMb9jymnXGU+z/IpWyLfuZsMm5sGM9yxrszflf0tqKAnAiEA/tcBC+Ab\n317Q3TYN42YcJwnZqsOZZQKSawRrCzXburM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISASroxxr8M+I2kbFsrOxVszFHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVmZjY3ZDItMGJmZC00ZTBmLWJjZWMtNDc2N2MyOGQ5MjUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRiMWJiODNh\nLTVlMTYtNDJmOC05YWI2LTY2NWEzOTg4MzE0OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN+bYiWkfLQrQBNmNXKUh83KUOJpKEQBMtzyc9MTzO/cmF61Jx+F7z5N\n71p7m88Z766/eR8FFN3Gspej2Xiv4N2jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCAXGzdU\n5gI9GfAvzWgQWpmjJCBqMAoGCCqGSM49BAMCA0gAMEUCIFUfFbCidj3mRK4nVH6E\nbm4etAD0m2Omas3PDBDoqGh1AiEAgcIZRpNJlGlMODX/VvLGUCg/lH4heXq6ZGcw\nbkodoOM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc814", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `814` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAecq0ApM1a3+lAR2qDBckZl1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmYjIwYjg3LTVhMDMtNDUwYi1hOTE3LTQ3MzAzMTI2NmE4MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI3MGM3NWItN2Q5\nYi00MjI5LWE4ZDktZDc2MmIzNjJkMzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1TO0T0LmaGyc1nkRDTKrmL0EDGgMR88Ubc3E0YUGd1D9+tbdVBD2lIKDP6Ra\newcAFRZb6MvxYuGxBhLjgiUwMqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSLXsk4CIvaMPOw/UX+oxQ7tSAa8wHwYDVR0j\nBBgwFoAUcI9VfzdC6ei73uhyMuqb7fQuGfcwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCGgxOZkndpTWFPzNepMgnqw2Gpwsoj8TybA1m6wPaCgwIh\nANBDCL0c+vGviKhrJZfZdiWW+v/jVCpg3CRECSTmcGRP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV0aUdLiiuT2HNp500ETBI+UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmIyMGI4Ny01YTAzLTQ1MGItYTkxNy00NzMwMzEyNjZhODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSYe3KLfGlOYCXMSQ2OqjPxCEzv1/Am427iWNt8bmQko2y\nT7ThCCC2uL1YWDJxqEp4dkecPLigyH1/VE0wQYvSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcI9VfzdC6ei73uhyMuqb7fQu\nGfcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSqzKe+0bopeqclElf0RPEl//m3NBaK/jtRnOmX2DkA0CIQCZ/k/+Bxci\nq5VnKzRRtyI1i0SDCTpdG35wMBWZLDH01g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAUlMSkG9o+jdCH6od61lhT8TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI3MGM3NWItN2Q5Yi00MjI5LWE4ZDktZDc2MmIzNjJkMzUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMzN2E3NzA0\nLWE4OGItNDAwZi04N2ZiLTc2OWE2ZTkwNzdhZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAolSxxU+04rsK6ONXRLlDGf6hcxZBdGvg9RNW2YKEx0VKwqC+Sxn5Xi\nIMbMQ/i/l0pjmcLgJ5/SaWCD7zyc8gqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEi17JOA\niL2jDzsP1F/qMUO7UgGvMAoGCCqGSM49BAMCA0gAMEUCIGVeGVPZQBSGCCo6mjDa\nfayGPbX3QKrXYeVNrtIZgLHqAiEAyGJpzeW1XKFyH6JGkWDnsAPxO6zJibsNKMua\n98HWFfI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc815", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `815` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISARZ5Llxw7SR/aBq3VOnpkWjDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkNjYxZDU5LTljMTAtNGNhZS05NzhjLTYzYzI0NzczOWU4NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE0NjA1OTEtMzMx\nYS00YTMxLThhMjctMmE3MGUwNDhkNTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU41Ey2eukItEFh+T3FXrI7NuPwpdX47e/MjQJyH5JEGcC5CmHAtuXOIMrGYi\nWQm0sjtStLmXLwO7L0naNqyE/aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU735rQM3+6PaIVfBomISs0CJOl94wHwYDVR0j\nBBgwFoAUCClQngkprKGcGE1npI5BbFsWWK8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBuw3tA9dmj41WRaX5w+0K4CopX5TSSm\nV2tXGR3OwnlnAiEA/E8nlaxGNOReS07gcbSc7FgUSUkhqP7OGoTrwIpv43E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVTb0YvA0E5EYeqmJnnuD07mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDY2MWQ1OS05YzEwLTRjYWUtOTc4Yy02M2MyNDc3MzllODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+GcB2Kgy/4tGrR+i/1nvUXIwWp7dRM1E+r7qjuNV4d/sh\nXADDZ/RRnGjZFGdO2u1UMNtK6JFHeuPqdTCIUcfoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCClQngkprKGcGE1npI5BbFsW\nWK8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJnw95r5Wng9SmMEaSkvKHm6uGH1tmw2osHdbJP8F2CkAiBc6v5ZvXXT\nwA+qfWKoyoz6OczjN+TOIZ3qdZmzdFFHNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISASAqX8ceTESwP7V9UxMsReBrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE0NjA1OTEtMzMxYS00YTMxLThhMjctMmE3MGUwNDhkNTliMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRkYWRhZDZm\nLWM1YTAtNGZjZS04MWMxLWU4ZjEyNjNkZDU0YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHY5UdsPZwcrhqTTgwpSFpO4mLDDJ0mqIH9Kd1Hh+dwYIZIEpjrpTl8o\nNrB58O//01//8Ysk/iSBkloT71rbhIGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO9+a0DN\n/uj2iFXwaJiErNAiTpfeMAoGCCqGSM49BAMCA0gAMEUCIBv5buGY8sH+wpcLSg/w\nb71p+DDiqVEewkpm8jQ3QR9FAiEA1tZ46HtJJRUaRq8glkbF2Jj3PuHIbtPKCyjl\nSyLFwek=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc816", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `816` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAQZPDzTvCZolKC1bZLgPppHOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkNDBlNDM2LTlmNDItNDM5Yi04MGM5LTUzYjYyMTRiNWQwYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjJjODVjNTktOTE1\nZS00MmIzLWJjMzgtNzVkNjk5OThlNzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErHj8RxQwMs6SvpKIF8ZeXklyvWWaHjNN+0I2kBAhwbiII8NNsELw2pcnwepJ\noYakVTZs6DXu0ws863LdDsRCraOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHJzRlBEeTZcsbpMLA0TUoMPBCyswHwYDVR0j\nBBgwFoAURez6niIHVy4w2JpoEZ3F7ftVSXswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDWkjiVNpfTUJmsDHLM8+H5eEX7BBg7\nbmgrMeQksTzuwwIhAP1H5ZN2xUyoBQ59FLpxSCoV4f3Dr+dx+u4vFDor5meC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQcnOf/PtrSf9aRD8zYw/37UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDQwZTQzNi05ZjQyLTQzOWItODBjOS01M2I2MjE0YjVkMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlBV9xUV6SMQ8a6ImSQovNbf/C1DIJcLU8I+OOQOemhpPS\nti+OmAb/HWE4IhWoDd6QO/0O+kE+pjb1cIsRhXzao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURez6niIHVy4w2JpoEZ3F7ftV\nSXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPIpCtBrN47Uiwi9MoyzgxeEnNlOqyBlYocHteQz460HAiBQRJ6UFERs\nDpKqc2jEdBfGWbquMezAPPf2nvfakFmjAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISARtlP7KNOgVYqGNwbGQLM8LUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjJjODVjNTktOTE1ZS00MmIzLWJjMzgtNzVkNjk5OThlNzE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZlNzU3Yjll\nLTEyNjEtNDhhZC05Zjk4LTAxZjJiMzRhODQwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIOFwzquPjC6/NAug+gGbTrQt15eiSvYUK76hKdkec0Y4FHFcdK4n4J/\nFepz8h4aiwH4190H788v3SaMAS9C13ejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFByc0ZQR\nHk2XLG6TCwNE1KDDwQsrMAoGCCqGSM49BAMCA0cAMEQCIH7sA+CqkstG5r1H0qtT\nTeSZsBnODDcyEmeNafsd8T6mAiA9sAx66YQ0oLPbaia5qG7PEXNjybuMjRab9eiW\nLZUzhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc817", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `817` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAbE7Yggbw0rX+WcalF69i1dcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1OTExOGQ2LWNlMjYtNDJlNi05YmJhLTM1MmY0ZDZlMmIzYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJjMTQ2ZmQtZmNi\nOC00ZWM0LWI1MTYtMTNkYzkyZDA3NGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIaPj24zOyVYF6LdCJJFVTxc8fhdn7wkY5SARmHp/cOlJjELGVyUKUE9syRkE\nON3ql3F6fRN8rN6hbPSYLq++B6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAYLN7qPXDy9SdhfgUukJearEKX0MB8GA1UdIwQY\nMBaAFNHE6hKAYdtY3Cq/hIgIiyO9/hCcMAoGCCqGSM49BAMCA0cAMEQCIEfb8vXn\ndKhnUSFI/zW/r/rT5W2oK/XXNHAK/c4yFpukAiB+XiOV5lpalMxcJCqinz2HbKA9\n2O4lfZbP75bnR4lzNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbpEoh2N7/9C02DPz67O67WTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTkxMThkNi1jZTI2LTQyZTYtOWJiYS0zNTJmNGQ2ZTJiM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQX6MI6FsVqeC4neKnXHI3RQTV4xJ8/4uEkJxH1IdOYAl/p\nyXoMzol6Wp/AN3TV02nR3ILcqp24qoAPH9unIw23o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0cTqEoBh21jcKr+EiAiLI73+\nEJwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNrWjjXGjAPGUomUvfuT5xULUKNZ6Ix1F5ny+mczCn/wCIQCPcV0H48/t\nojwEQqshyfiMo3onvo1A57iAWqEu/mdiwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISASp3opXiq6v3kD3Tg1bH4ILxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJjMTQ2ZmQtZmNiOC00ZWM0LWI1MTYtMTNkYzkyZDA3NGE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMxMDMyNDQz\nLTQ2MmUtNDk5OC1hMTkyLTc3NGU1MWMxYzYwMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD3Zh3VLkZVGZPw1NJ8PJXBlvFwWt4DnQcN48OfJC7DBXL/Nq3UiAhgM\ndmM/W2qVvABObORkCiS61/a6WRxrAtGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAYLN7qP\nXDy9SdhfgUukJearEKX0MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgPpsSVnorZofcSOu7ksNl3f5ZWGTnXw8fXDaIbc2VY1gCIQDmmQBtYDrykgH3\n7WX0SpAAZsepULJ12KZsffndVD45pg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc818", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `818` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcvyqyNRjECrJVWMpteFXJnsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1NzQzODY4LTg5NWUtNDEyMi04MDI0LTVmOTI4NGI1NDc0ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTZjNjNkZDQtYmNk\nMS00MDQzLThhMWUtMjE1YzBmYTQzMWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdJRR5R5fjnX/sZLwqTeUduiJ7p1iZaUoN9Oh2xmn59OUSinofGw7kHnVQAZ9\nGjnAs0ke8tflRQQrHM9WXmC3IqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKd/1FBsgkMF0YLIcp1PL9WvUNZSMB8GA1UdIwQY\nMBaAFEsw/47Jg6noI983y4Fw+AftRdbAMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiB0akHEkEEM4YVynlJUZNudjFAYgHcknsQ2\nxMbybNfqsQIhAKcfn1/1YeMsjHo4IPV5chja7ezDjcPpMmG2DMIuy6Hm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVTd5eIz7eRZKbFNLHKmzke7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTc0Mzg2OC04OTVlLTQxMjItODAyNC01ZjkyODRiNTQ3NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsq5mX1UmJaJmBg0to0IVdvnZfSkNIfINJMBfsbQkjyIjk\nTX6JWr0mf32MI/++oGB/CXBl63dLxrBqZl0Z9yDso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSzD/jsmDqegj3zfLgXD4B+1F\n1sAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA4Q82zjcp2wYy6oLvC0P8/3cVlHfrFqsvATYAMiIDT4CIEVAJLg2wHjR\nX3wNY/U2AI14bnF10UaP6SjpmNBLvqlv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAVKgzXuEgiKHgw03HKlQ5wd+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTZjNjNkZDQtYmNkMS00MDQzLThhMWUtMjE1YzBmYTQzMWIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYwNmMxZjc2\nLTRlYzItNDEzZS1iZjk1LWIwNzUyNTEzNGNkODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAHqz4OabrAF7QrX3KNiqPR90dYyazY9OjIV9l74rHnJDFbE671pu5Ke\ntJSgqtquLMYA3cAEEO/xCeKyyXIS39+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKd/1FBs\ngkMF0YLIcp1PL9WvUNZSMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhALm8i9yZfafe1FxMhmJOhFOl+msoUdjKyrx3jhpLalDfAiEAxk5Fhngo/vSG\nZKTKqTG4otPD+vt8eHheEvUj/LJOgJM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc819", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `819` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQD1F6OenLtLVaCUgzhxzvC+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxMTQyMDMxLWE0M2UtNDliZC1iNmUxLTY2YzE0ZmYwMDNmMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhkNjhhNTMtN2M2\nZC00NTUyLTk0Y2ItZTk1ZDk1ZWEzMzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJecsUTriWxlViAZkgq+KJ9I4GllriA6tkpuZTOud/T4NMT0T4gHNTnkR+ieG\nFCL2K+bBNUDkzTFIRWR5gYwRBqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHngE3oaes9pYEr87BcKKk7ADmxyMB8GA1UdIwQY\nMBaAFKD/ddbW3ZJ2oGXdT4QDKZprBWqTMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA9hwCQJhQziOfNFYHWlPiloOhmr2OMKbh\njBYYI7wLOS0CIF0aCgzOz3uMn4RvY5i6Jx1gBkLMu36PkPtgEIsDMnI8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb4kUp4yGDO4VjHc21CxpLxgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTE0MjAzMS1hNDNlLTQ5YmQtYjZlMS02NmMxNGZmMDAzZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZJEYio6mw0m6aMLAMKTY5gDUDyssFoT3wvCkxmFMPcrnS\nCRqvQyuW4vSkWSsJYj0Veas9VvBy0tfSjWBW2gTno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoP911tbdknagZd1PhAMpmmsF\napMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLECf09578UmEgDaTtw3PSm3cpDiQafLpC1uVf0S1BRICIQCDCHHhQZce\nJ/HWcgRyo6eVobB4y32TT3o4rxZ9vksHrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAc5vCdTZZ7L7ABFE06uFFZExMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhkNjhhNTMtN2M2ZC00NTUyLTk0Y2ItZTk1ZDk1ZWEzMzRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkyMzRmNDVm\nLThkZjYtNGQxMS04Y2JlLTFkODhiMTkxNzIxMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHpQdwNSZAFi/gZsz/VMIdrvpu7iCdjwyIUfKkMVuFcXsaTyyoQucw5F\nqBYDpdbXtoALfdy9cnB8lQJjzky1XrejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHngE3oa\nes9pYEr87BcKKk7ADmxyMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgf3FnFXwugUIA6FbGEjpmEHnQpBVLx2+lcHTtoUrsXiECIECnJLyGB3iAf0s5\nfCrREyuKDu/S4915xP8sgIqOKvwH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc820", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `820` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVNQ22vz/u6fgBxzRwfvaWdPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMTczMDE3LWNjMjktNDVhOS05ZTRhLWY2NDVlMDQyNzg3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA4Njg2MDItYzA2\nMC00MmZmLWFhMTEtOTQ5ZDMxMWQ5M2QxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI9dTD5zlpt/uyfIBtJaSu7Fg90cYmcfe9gcV3cS0895J6f+8ha+oAqDR4oTs\nVuAOv+D2J1wv3v7h0TnbYO1DoqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ1R2mz+oDU8KaOZX3dbRMBOeRsvzAfBgNVHSME\nGDAWgBTNJ0wPrBIWgMnVO5S4n/rw+SZIaTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIE5dXK8YLdfRBx5q0L1QXoipF8XAfgkh\nktOIr8WhropKAiEA1PyzDO2rE0J52TQX9MDmytdhO+fo5IqMOVTLaYmhFSI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa8zLtoKIiN2rqyfMFBFOnYFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTE3MzAxNy1jYzI5LTQ1YTktOWU0YS1mNjQ1ZTA0Mjc4NzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDoqqWHnhO4+gFF1/pU3XDsMmeX/25AHmqXIHWuf5YxdaF\nRu/Nvt+KR11O7X56jApckbA9lIysPCyPXHgWBSoNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzSdMD6wSFoDJ1TuUuJ/68Pkm\nSGkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO4ChX5ZFSYuxZeqjY3mWhZ3tZ093wkcEgaBub9FnQ78CIQCVbJl7IAjz\nLnR+JL32t8YZBfeQ30+xWMmygMCvOhpPag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAf2f2RK3B1bqCM4q5WiU6EZdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA4Njg2MDItYzA2MC00MmZmLWFhMTEtOTQ5ZDMxMWQ5M2QxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhiYTU2NDlm\nLTViOWQtNDRkYi05ZDU0LTFlN2ZmMmRhZjQ0MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEUzaVDfnyfaucoe1skZvPc3V/8u8/XkMRB3gbWcKxan5tjGJfV0TnCd\npNjvdRJ3yXWbhx5gmwqFIzCXFs+JMTujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDVHabP6\ngNTwpo5lfd1tEwE55Gy/MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgSGWMY3Rmg/o14b/ZoKVTUu5v+4Wqqbj+S/E9kjuW0zcCIQDc6TEKFqdq0d//\n3eqGjsX+RsyTajmKjVeEw0ODUKz6pA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc821", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `821` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAZThQKxNPPdzk1VeRw9q8zBtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1MzBiNzQ4LTk3YzctNDMyMS04ZmI5LTE3MjA4YTQ2ODIxZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzNmZmY0N2EtNTYx\nMi00N2ZjLTg3ZTgtMTA2YzRhNTYwMGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERFqjNtzcW7Iyw+m1OXK6391taZ43F5NYwUasOo8xW2Y+2MMIC36oMtK8giFg\nQBbEKEx7603E5+w9jFCLIjzqFaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUumUG4OlZfL/uejmvmdVW7+huNSQwHwYDVR0j\nBBgwFoAUMK0HtMNVmSZGOM2pzp8qgbAQlC0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBDniKRLxvkivJo\nxijbUpGUffaHWDqquV6V7hB4Vw3lIwIgSKzuFw9fqJT0JmsGMg2Vb2UUayHwb7Lq\nOCo9R4KlhkA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATB+4LNYN0L1RAFDNwWZczukMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTMwYjc0OC05N2M3LTQzMjEtOGZiOS0xNzIwOGE0NjgyMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXEvTmQ/FcFIMMesH3EwMQs81Cyp5/rh+PgKXXj2cHq5C0\nXuzEga2fRDnHtwCrfZgy0C0EuhWa0Lmhp8say5ANo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMK0HtMNVmSZGOM2pzp8qgbAQ\nlC0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMQM5nHt/tkYtPDUDufQdRk/EpYX6Kx9TOFqrrUE754JAiEA2fGhRaD3\n7j8lWlsk9F7Qe1MxwQrS8mUpxDc8dPpvnOo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAWVSOBvstxZMD1O/j48dY17dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzNmZmY0N2EtNTYxMi00N2ZjLTg3ZTgtMTA2YzRhNTYwMGEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQxOWJkZTli\nLWQwOGYtNGNlZi05YzNhLTExZDkwZWY0YzgzODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJDnyDEA/LO8NI00eN1A6QLtJXPocQRnvtUFndR3LsYUobx07ia2uaNf\n4HEcGhls+wlfhJXdFd9yNtItYxjccfejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLplBuDp\nWXy/7no5r5nVVu/objUkMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgATHhcFzjqfiL+WVi3a5ak0KdQ42mr66zOGdCuiYULAQCIQDGoHS5Po+058Q+\npK0TktZiPHHQl4nvlnRh2aBuUuGALQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc822", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `822` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAaCu5f433frTJq/GOzbHvOljMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjMzVhZjJkLTc4ZjUtNGQyNi04MGMxLTIxMTBjMzA5NzVkYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFlZGZhZDgtNjc4\nYi00YTFhLTlhNTMtZWMyYjY2MzgwMzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/M5HSTehh9xbLY0d6asjjDS4pcGlKY9zhxC9FUnprupJ09pcUp+4EL6UuelD\ncU6UjZkXYeI17SxqzsXsAMNQ86OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPDckIQuxVOJLShWrJGyhfFyC1dkwHwYDVR0j\nBBgwFoAUu8TXCrGmtz8i73/OCWZoaXeUQZcwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA8pk3GGfFaISb\n9vqO1pszv5AY3EEdABVCGsFZ3RSefF4CIQDH6In1RTFThsABVELa7PIoQlaxsiFn\nD36Y6Zw0+xtuBw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVUXhMEusEoJ9Fi0r7prtTiIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzM1YWYyZC03OGY1LTRkMjYtODBjMS0yMTEwYzMwOTc1ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARF4RLJeGqAkc9boHgJcu/yNI/Qw4h9d+RpyhaTlyqdMOMA\nAyXKCGulS6UTffWTPJvTJm8syMhBmcle9J3Lah+ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu8TXCrGmtz8i73/OCWZoaXeU\nQZcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKpen6n89nPayIZAt/dPbavw+vJVMt5RDghacTK3Dp/JAiEAwL1i8V6Y\nqvJfV4+zoYYcLldHesTlG1oBhiCEgETdjw4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAcWWyitJnfl+AbpSOLZ3O0MeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFlZGZhZDgtNjc4Yi00YTFhLTlhNTMtZWMyYjY2MzgwMzAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ0ZjMxM2Nh\nLTc4Y2QtNGUyOS05YTY1LTk3OWZiNGY5MWM4OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEbfAw6HL5N2lUSWKVIQc5yegxFC9JqSfqTKp2SloR4oIkNMKKAcxXkD\nglVsJHZEdZPXgrofvAkmukHMDm4LSwOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDw3JCEL\nsVTiS0oVqyRsoXxcgtXZMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgJGTW1wAH9CbCcV2Df9wVzW4uKI1jDTx/87AtS97VWBoCIQDfwvtk078uUt24\nZlKyR2nI5VmfHWZ0QCAUWNibrNY8Mw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc823", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `823` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAQfLzCL16BL3E8V8h+Q9zrQQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjZjk4NzIwLWZkYTctNGM3My04MGVmLWQ3MWFiY2Y2MmZhYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY2ZGJhMzItY2Yx\nZi00NjYyLThkZjEtMzJlZTRiMzdlNmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErS8NJmzWRv8OA7cw2Mb07bOU/QoNywPu6eFgj/6/Mq9WwFtKe7FactZxvQlk\n3SZ1CldV43aINYg8y+h5z3zdYaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf76WYQhZTKW8gFF71yt8r4Ss8qgwHwYDVR0j\nBBgwFoAUANd1oR+vHw6/jrIFga3WgQ2lEj0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAvAL160Ctrnq/igj5KcE2\ny1i5lBMIOY38RbCdQNuABvkCIHKSVpsrAgD/6DPwJBUUqgW1WPgGmK44pn2b3WEC\nWAdG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARo31yEG1TAgjAIUm/ZcDXAsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2Y5ODcyMC1mZGE3LTRjNzMtODBlZi1kNzFhYmNmNjJmYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ69cI+U62t073gRYmXQ3QAMVEgDF2hvSBSDFrWM7gVS3Vn\n4ju/I1w8g4+1gQt+qwiOB45zwRlOuRXpmbuaWqDvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUANd1oR+vHw6/jrIFga3WgQ2l\nEj0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRtWrCxlTEDZj8KMDvi0NxXFfTlDNcN6wnuZMKJ9XujoCIGm5ShfVM4KP\nkuxNFL7ivXpshdR+OUTkeQNeUyHo/rUZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbHgU3XYPsGrTFqlxYiiQPLpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY2ZGJhMzItY2YxZi00NjYyLThkZjEtMzJlZTRiMzdlNmJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJhMzliODVm\nLWI4ZjMtNGI5NC1hNmU5LThlZDVhNDVhOGVhZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA74ovRYUqYl/bwGQQqZ2xfsnRe0uinnxNmpWN13Bik3FOhN04Ez0iP4\ngsSDMZzclFZ+y0ORtAM/eddC5bMH0ZCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH++lmEI\nWUylvIBRe9crfK+ErPKoMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAIZZySnHe24aG675t4Zq0YlScf6V96B4USRGe0abL78wAiBt61CU8FbVOca+\nEcY8deE+hzMWhbNRbC1I3CHh1oPWbA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc824", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `824` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAZXvvVKwdmLOZacdjb+HcodDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjNWFhODhhLTIxYmItNDAzMi1hOGE5LTgzYTExYzdmYzA0NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY4MDZkYWYtZGYz\nNy00YWExLTk4MGUtZDRiYzJjMTJjZGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC2T2doFuyxYLo4MApEXN9ItI+NeIDMiwglf6EK97zauANZwhE+4IKnayL+n1\n9zYGVQVrm5uikdPx/knj5TsroaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVmRTpzCrZ4QdmrkS17jgPMBBQigwHwYDVR0j\nBBgwFoAUrBqV39r1pLX8CNCn63x7DJegRDwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBS+FdX\nE/Hjd8RTtHQvVm+b3pQpcJHsnIsDAfWEcLqL3wIhAIFnGrouEN2OJAG1CB0gFBdP\ndotjRsMm5ifJ7CrfqMAx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQopTlh9DZeSYQbePHfZkqfaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzVhYTg4YS0yMWJiLTQwMzItYThhOS04M2ExMWM3ZmMwNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCRUZ8NDc0LTUohnytdkw3qgMJmxdaAemni2SzZD2brobX\nggGGGTt1FRcEPHB7/edgetoSP1Myp9jY40aiY4D3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrBqV39r1pLX8CNCn63x7DJeg\nRDwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOyumaQhJoeqnqCOf6aUNkC28qfHV0EOsVh0n+nyV/YYAiAjIlxB+yFG\nQkOIJkq6ySjlIlLcuU9Koo0bHyiPy9FN2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbhsNvPdO5u9walj+PFfi4QlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY4MDZkYWYtZGYzNy00YWExLTk4MGUtZDRiYzJjMTJjZGEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRlYWRhMGU2\nLTZjNTUtNDM4Ni04YmJjLTc3ZjYwZWIyMDAzNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABArgVie4V9A+Yui/1G/q1q1y49Df/KTCfVwmRas2Y+ojNyFqOGzVaB4e\ngREWH2M5G1apSX1WvdYiqXCGjokfPRqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFZkU6cw\nq2eEHZq5Ete44DzAQUIoMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJg74kkXPkis9AnfX/43rqiamyo/pkqez6qMwhXCsxuWAiAJKBdx2YCtBXBy\n+QXmEw/PuoblY7NU34uBbFcH01tm0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc825", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `825` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAXmWFsr15eqkwr/zr+Mn2uhCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4MGQxMzU3LWJjZjctNDBiYi04M2M3LTJiZDk5YTdhY2JlNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ2YzZhMzQtOTQ2\nNC00ZTdjLTgwYWItYTA1MDQwZDFlZmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGZ5db0cdcljj2sZDBQqVCjV92Iz74HBt3hJXERLEmJLAN01T5U8J1Ypj7Vx4\n1nvCPIe9XVR2yypu0Lw0XFZLXaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHowXw/FfwcbiXT0mIeS+v1SwO+kwHwYDVR0j\nBBgwFoAU+2NruDt9QI0ECFLVR1Ec0sxOot0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBsYx3z\nqU2VxgWMESz+2W6nyvRxBJNz9ksU0mcAPOLzCwIhAPOHRTvGrhzGSmeNYlAaoEJQ\nuMhH4d3oANe8SnBz7mTM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUYpn2Wg9lkUZcged9hgthC2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODBkMTM1Ny1iY2Y3LTQwYmItODNjNy0yYmQ5OWE3YWNiZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLRMowFd7dYMEHKkavb/Wxy4Adb8D60TgbckaNdelH9jWP\nRyYzALkeX9iFq3khh/C1FRSMdAsdNXMKuBU0N4AKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+2NruDt9QI0ECFLVR1Ec0sxO\not0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOylPhgPP6pRdcMisThITWs3NlakPXocfz2vz8ebfuTZAiEA6HtXJF42\nnE0TEOzizlj7gVGaXV8C8lZBGK+GWvEexfs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISATET0TH0SEJiyrPZXHVIbe1cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ2YzZhMzQtOTQ2NC00ZTdjLTgwYWItYTA1MDQwZDFlZmY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE5ZjE5OGNh\nLTBjMWYtNDAyYS1hNmJhLWViMTU1YmM4NWIwOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP4CCym+FGJRwFzQAe/KAPPMLlO2WCS5ESXu+neNIVWAhfQ2SoDcGn+o\nyp0ruuoAlfH78Y4z2GJJBkRqmuwytWejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB6MF8Px\nX8HG4l09JiHkvr9UsDvpMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgZVwXQT5QGP8MzztdseGFEd1kAyBQv8vbpAQfKwbU2u8CIQC27f32fES8FAmk\nNGy/OOJabmouuHfCp9WRQCNE9WjwAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc826", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `826` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUVG+7+YXdXZhuanVgRGBE02MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxMDQxN2E3LTFhNWEtNGMyZS04YTEzLTI1Y2U1YmFiOTQ2YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZiYjNiZTEtNmQ4\nZC00NjA5LWFjOWQtY2NkZGYyZDJiODc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtV37jBZqVyyrEhpW0wSCK7f0NRUdzhEw+bBPalgBZfCkU9FfJ+nKVNJztvdw\nIkG/U3zaInoD+kzDw292tiHBT6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFG6OYhauAXIGPIAoBFD7n1c+y0s0MB8GA1UdIwQY\nMBaAFMTlqm7PImjFv7+7OHNO8hZy2Ls3MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAub/AVOR0bh9Cm5U9oFyuyYoenl3uQbNcb\nE6JBbLbSrwIhAJy4D8Zq53O1YFoFNaOxyW8qBDUX/+De9UE6DFP1gi9s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU3WVr09A1g7AV19CRbPYrLJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTA0MTdhNy0xYTVhLTRjMmUtOGExMy0yNWNlNWJhYjk0NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATY1xy7c5JhVqODcGnzrIdzOsQh22dUg13Sjn0SrSQk50IQ\noQjp2sNUNKlF7uPpFa8k5+mL/ESgjJ0M9svc62Fxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxOWqbs8iaMW/v7s4c07yFnLY\nuzcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLbcrJhljhnVZOBnAShvU2LT29BNxje8Mwuv7uBX2kQ8CIQDyPTgwd7DT\n2WKVfkFo+RtSL0oS+/6616bM3E5k0RXDtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbBUQYHjZo2k5/8HKZ+POLv3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZiYjNiZTEtNmQ4ZC00NjA5LWFjOWQtY2NkZGYyZDJiODc1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE0ZjFiNjdh\nLTdiMWUtNDIwNi1hYjhmLTI1MTFlNmYxNDE1YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOPXMF3nm9q1iByNQ212tYZKxYG2LywBb1kKG3yn9IdnpYHUNwANa3Y6\n/nNrBPJ2u0QUes8EkxpkYDQhJFZksZKjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG6OYhau\nAXIGPIAoBFD7n1c+y0s0MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgWlWH4g8wMw+emFsPPiHzntNOLWthk7x08JQt1peuqwsCIQDbUzFeypaGkh/I\nZO+I0ga9Q0chLBB5SRhnrryVy6mUwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc827", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `827` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAQOTFYHKLjHnAto12pw849ijMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMWMyYWU3LWRiNGQtNDZiZS04MmViLWY1ODViNjVjNzQwZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE0YjBhOWEtMzYx\nNy00ODIyLWI0YmItNjhlMjlhMTZjN2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEovukSoVfuwcK+056zVzxMxllqGQzoeDQtQ6oZv+YXMqXJwPP/2URy5P2Y1ll\ngoXIy/M7j3g1E/V6bdeHXI6XuKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPtbHSiJ2IJMj9Tdqiiiw6FpmEU8wHwYDVR0j\nBBgwFoAUEzei0Ui3aiCWXlhOcXazC1UJzuAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgd01FNS4v9p3M\nIv723Vlu9ZEEZKhCF312kjWD740GGa0CIBFFGSaPU5lljGtQYAydUF/fw/yOaJDv\nkuEdNrULDU3M\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAREthzI5HAKYiyVaxIMQhjMwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzFjMmFlNy1kYjRkLTQ2YmUtODJlYi1mNTg1YjY1Yzc0MGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzY3/ukDKFusXWMdJKCMumVaMiWoEnelDQOqSBZk5qygHu\nkDwbAEXDcxUX13xRBhPxHGLK7gP4kxF+9ZbdktGNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEzei0Ui3aiCWXlhOcXazC1UJ\nzuAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWlKbABA5Ze54BXoRidC9N0ri3t7Wxb2xHraVAPZnq0MCIQDTiHZPdbJx\nKZ9UYHT1wbENI8UCvAbUnhEkHIlJlBSF0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbJOA3DmmEkdYXsjf304kecOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE0YjBhOWEtMzYxNy00ODIyLWI0YmItNjhlMjlhMTZjN2FlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhhMWQ3ZjA0\nLWZiODItNDkwMC05ZGNlLTY5ZjYwOGIwZWJkYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHMhn5py4g1joCJE9xn8BlJm6X3Gjm28apyfryQklOqkmZuS21jB9u33\nSjolW8NXkLEbQFC/Y9hRIGrv+3pjeI2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD7Wx0oi\ndiCTI/U3aooosOhaZhFPMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgSbJdTAo7T8tqXd8+IM99wog4zCjJ7MuT9X8sBPwwbVUCIQCMnqgBJQ/Lryg4\njMMU//cKZ/BN/BHrdII5xvhkJVYVkw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc828", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `828` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAepq8SWEW1+kVDfpjLYx/HrMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMWE4ODI5LTUxNmQtNDE1NS04MzU0LTQ5YmYxNmI0OWNjODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFjYzlhOTctNGJi\nYy00NjA3LTg4ZTktODIyMmQxNDNkMmMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8PX3KIZFx/OhE+RPrdMxTKphKkOKO22+N6Gmg27KWGyYPShKyhX7fC8xJo53\nAcLYWC+hx9P/fHjx+YCTA8gdmqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiQK1C5oSfmCe9Bw3ojSeVsfoi48wHwYDVR0j\nBBgwFoAUhxGicBCgAhk/eckFOlOnZpZtAaEwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANhe/e48Yaev\nWPcftQ3Z6mFn9sbRLqdg0iiXzPO7r/q6AiEAjiDhXIPfjN2CbbOmxX0zKKWEaGMU\nqe4KP4CTi33LBCc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATQlfOaGJHUGKRRYTxNt6MJKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjFhODgyOS01MTZkLTQxNTUtODM1NC00OWJmMTZiNDljYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQacUbf/XbSUCRcD6iC8hP+mL2CTPreLryfaI63ZoMM+mm9\noaPJ4ZyYPMmHsSfbXKLdtJFtUdZqdmhdw+/19Yguo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxGicBCgAhk/eckFOlOnZpZt\nAaEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAISiajXdD26tKe8EcsuYoYv1kwxWJsjaUyGa8zTQwwfxAiEAhDkVwBtw\nlGWuEvXnY9l8gQskNdxV7npSC1X54wNTLoI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARVshJPbVooaQTW7B4bBlwnMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFjYzlhOTctNGJiYy00NjA3LTg4ZTktODIyMmQxNDNkMmMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJkYzg0Zjhi\nLTA4NDUtNGYyOC04YjY1LTFjY2IxZmNiMGExOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGVMYrNQBiVyeon6wF29TVTUnIOukbqPbP8BJEisUO0Pw/RymDlh/G7x\nf+cIPys7wlMdulUFrka8PuKQsO09uVujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIkCtQua\nEn5gnvQcN6I0nlbH6IuPMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJzKiOPvau9u2UF/31Hm7CXW9e8DM7hoYto7YZporYdDAiAhoRBwApViGjPu\nGJy+q2MJRhzWZzBBiI/v+2cXr+kVqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc829", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `829` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAU+XReRIZclFF5eIhOvM5AjPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyYzk4NjY0LTI1NTYtNGMxZi1hOTk5LTkwNDIzM2ExNjNlMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZhNzZiNGEtNzhi\nMS00YzI1LWFhNzMtZDFlZmMxZWYxNWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkxupooXpRWitOfFQomdulKozCpTFri3W2aSqnDkLQBfz1ZjYM1sOM9xjQdKS\nEsYQ5RMMUzFXHB40YIlqxuOxT6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcleswVPMQwNbU42CQIAnVvucKKMwHwYDVR0j\nBBgwFoAUKLrh4S/0yMpd7d4gMdc3VabZhAAwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCh2wCMGr2I\nZCSIpcCNyIBf4iQqAfJyPW0HqOv6jLbMsQIgdlfwmfMnn1yd35u8yVYgpkIorKE9\n9FXWAEOMuUbVxTY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX7R4KjFxJNJJ5SIsnC5Y3zjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmM5ODY2NC0yNTU2LTRjMWYtYTk5OS05MDQyMzNhMTYzZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWhxAPbHJfm5DM7R3GukwknJRMBKzKGyvGBz9mNfrzJC5Z\nI7yG5Vnp2Hls8mrrPCVJJLxvDtQJK+mk8XymjOoGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKLrh4S/0yMpd7d4gMdc3VabZ\nhAAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN/o7xFGqeBqnGtRKiTL95hHViGvQIklWHzWm6vgn5nECIQDF8St3E9o0\nxpm9jec7I0FoQ7sAg0Xq/XFA7WPucsf09Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAWn0UzNTTdFpvMg2QRszQprYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZhNzZiNGEtNzhiMS00YzI1LWFhNzMtZDFlZmMxZWYxNWZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM3ZWNkYTU0\nLWNmNzItNGYxOS1iZDFmLTQ5MDBiMGNhYzc2YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFMpf9M/Ep6l8r/nQKcDNPu/7oE1ZZIojafrxqjbumxCplHURrcyjcvN\n3ezAbJBipCE/uFRAy/tFeHt5uMZtMhSjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHJXrMFT\nzEMDW1ONgkCAJ1b7nCijMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgU+aeTkZKyyExnZQwwaMfYTt99vZ8aD2qJBpv3GZBU9ICIQCtwHeGR2j1ZAkv\ndGGcD0NmJbidJ9I/CUu8EYjfNEydtQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc830", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `830` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAV1T3PWbTsNrk1wSiJKlolACMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlZjQ1NjMzLTQyNmItNDRkZS04YzMxLTFmYjE3YmFmYmYxYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmZkMTE1MDUtNzY2\nMi00YzRkLThjNTMtNGQ2YTJlMGMzZGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgC39WB40fmITDNd/nvpEQz3zkMw/HBhV5Jic1TgU3z+RYwP4zPnnbfGkfCKD\nW7eRZnsBHgrOb+BMFIZUe0IMNqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSdv4Xzc6Cd8a2iZLjMaLqSf8aKowHwYDVR0j\nBBgwFoAUJsDG7XCwxTgrFwbBE55hW2vPD/4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEkegORRrPo2doMIBvroYAJIElwioI09XAocQ45JK3oFAiEA2rv0ZmcogmA9\n/F85xk1JqivLRVVOgNvw6thbCOpq4hM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVxA5G3LwvLTA7GkFjz++tesMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWY0NTYzMy00MjZiLTQ0ZGUtOGMzMS0xZmIxN2JhZmJmMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+5f5xN9vwJ5OLrZOp0zl1vMWLQQP4JcVv3KySW+2SZDhB\nwz+019z34KYdAsx2mICaptedcLuIR/RWVscdtQdlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJsDG7XCwxTgrFwbBE55hW2vP\nD/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJqit94wW5pgd3XcXUlszD/BBN6iOStNg/MAY0akTa3SAiEA0BPWWbk0\nNwhqZsyx0ILYnmKkS/pQMvtGfqRlcsrRfq8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAfCvjZTkfhDIwSDgzz+57PAkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmZkMTE1MDUtNzY2Mi00YzRkLThjNTMtNGQ2YTJlMGMzZGJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk4OGY4ZmI0\nLWYzM2EtNDY5Ny05M2Y4LTI0ZmIzMGU0ZjhkZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGzEqaGBgRIiZGtcedA7wgmxTKcsSBb/Bq+uPQEefSNRme8oxW5zk4tX\nEfINWrnRNxNsdnZGIsGQ3Lv2HpNlaR+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEnb+F83\nOgnfGtomS4zGi6kn/GiqMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhANbzE6xjsBAD3W4YxjKfLEsY8XrbqcOLE1vj5ayjYBrYAiAPb8FuXLc2autF\nrwtMA2wOn644XvhtwgHA6UqkPRSLXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc831", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `831` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVF8rIqZBMIXZjywfBu9JkWIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwMWYxYzg2LTIzZTQtNGYwNC05ZThhLTcxY2ZlZDQ4ZWIwNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQwMTNiMDctNjU2\nZi00OWI4LTk1MmMtMjVmYzJhNmFhMjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAgJap0M4nFk98L1IDXUX5PdHyNMyECKpj9t6LXIqY08cqm/7DzGbPFYKJNa4\nZKA/VK0oSjT951SAE8v9TnbfgKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGifvjj2xPd//LaoGQ1O6prJU4GowHwYDVR0j\nBBgwFoAU1py3CCD5Nxf0+2u7t83SoKHPkskwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCCgBqez+aQ1rBKFO1tMlFGEBWjtFpOsj5XZj+tVb4JSQIgHm6mrVvarKVR\nSDU5KPNQBEr5D8yxj9K8+5KQAcB/uYM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbVnqNPAj5Cxobw+nBXghfFXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDFmMWM4Ni0yM2U0LTRmMDQtOWU4YS03MWNmZWQ0OGViMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnbxuMeIDV8tPstL2c1nkbFP2+4xX4PnavDvoIECZlsL0w\nOSmMBL1pfFpMEjl2KYihBU2kE1vsNaTUGkhG3OPZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1py3CCD5Nxf0+2u7t83SoKHP\nkskwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIeNA/+6X2RwsxXCRQgj0A7eX3iMCAY2vhhYvxqcsc9/AiEAyIjzdk/c\nky4sTBiZjOePn5udfHov74NFc9/TfIBmsps=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAc86JxuLhe03PPJUqeY1XmVjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQwMTNiMDctNjU2Zi00OWI4LTk1MmMtMjVmYzJhNmFhMjlhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDczZDc1YjFj\nLTgzOTQtNDAzMC1hZDQxLTA1MGRmZGRhMWNkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGNZ81l73ioIbAPgRKWTH2U1Kg/5t+4ZL8Am44b85N946RW5TBznBI2H\nNWyq7WGJMVKsjcuHtF/hcdyMhQt7V/WjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBon7449\nsT3f/y2qBkNTuqayVOBqMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAN01ptjU83S0QaK1QXfYPlvmrT51Xucow7dfpAXGwZHmAiBcmdusSTHiWi+d\nzSzIl0mvQMbhJ5zItGKP0CCkrQhF8A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc832", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `832` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAbMqEsXzwxR6pDSHXQlydGGCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhM2I4MTAxLTk3NDgtNGI2ZC1hYWQ2LTljNDg4YTVmODRhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDMyMmIxYjEtNjIz\nZi00M2ViLWE4YmMtMzViM2E2NmFhZWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETRKe/8LLnrj3Tud11Vsfx6VbeRjTLGOPw3CpU1L17Xj9UqLZudsO1e3B30cr\nVPkbcTUHSx/MD0NMgG0/Xt2RjKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPWJdEtnTidbHWVpjYyeQkfuOWhMwHwYDVR0j\nBBgwFoAUvHv8ygCsPuUa7U6HOcaV012kDzQwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDD\nRR/2GtIOe6ZDEwpKJeDWVmk8efYbDY6nt66nYpe43gIgALYOWJNwqSkyT0lXRBGZ\nfrV/IPsd1L8CZzAJKrsmJSU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcgFe9WeqL5icGvcFzU1rzAmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTNiODEwMS05NzQ4LTRiNmQtYWFkNi05YzQ4OGE1Zjg0YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQU1icO6cNu9QPIVBQ512UfNw/C017eYpGCe6kU0uq1q+vc\nN/ExOYAY3oHF/ZLudMrarME3+1HNKL4v3HxoumzEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvHv8ygCsPuUa7U6HOcaV012k\nDzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHCl7LFZA7T9UvLPi4AmOnAVVWuEAy6oAvb4MHjfSZAQCIQCOkwyGuek2\nERANct/baryyEx15ZCO9FAvHvneSri05lA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAXhchqZJ9dzB5oo+NWJ+9gIPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDMyMmIxYjEtNjIzZi00M2ViLWE4YmMtMzViM2E2NmFhZWU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUxZGU4ODI0\nLWY1OTYtNDlkMy05MTIyLWY4MzM5NTAxZDA1NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM64d6TDf1MxJNdY46kAXD0LJspJdOc5x5o+GiExN2x/PGrjzElLY5DL\nMoqzePErcv+56jdKTcfBC2O3om84A9+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD1iXRLZ\n04nWx1laY2MnkJH7jloTMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgajP8QJMpihdqwViURmTqw/HuZGN8TIkg7yMbbeu0RNsCIQCNOczyqDxCH9Z4\nqkiEjq04w90lgYBwlTCtZs268QsUMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc833", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `833` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAeBFRUrsWTIkFnProCZmN/2cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyZTc3ZTViLTA1YmYtNDFjMy1hMjQwLTkyNjkwYzNjNDI2ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmVjOTY2OTUtMDNi\nMC00YmRiLTk2MjAtNDEyMGM2NGUzY2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPA1xgEkgpKqjQNAfQh+572zQ1uApVQVdAO9GPg2W7Zq2Yfpyo4vZaCiAVJbe\nTE2D/0Bpo/8PiPl0dokxbP6Z56OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYgnYAXfa572hQbBpWqUXki5ypm8wHwYDVR0j\nBBgwFoAUXps36YvTwqF1JJ3RCGmzxsRrjVkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQD1HwpyAlv6GURxbZAFhq65WcTHm+NwELQXC6pcGlMmwAIgWUtE\npmjR4TioDav9WC9TFQYVPP8utL3+FbdPnJrh5o0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaBMY0f7rLmTUYujK99ojajMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmU3N2U1Yi0wNWJmLTQxYzMtYTI0MC05MjY5MGMzYzQyNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDiNeLnIsfYsRjVyPHIPeRwkSaTbN66E3KwA+2VnQbFV06\naWZ7NlXg/MerNUKY0hxEZDcFmJ+7ZlU1pY51Xiywo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXps36YvTwqF1JJ3RCGmzxsRr\njVkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJEsA8cNmQ/k4vb/coaY2CqChh3aKJiJHqZ1g3t0T7yoCIQCbEgYYBW9k\n1UpG3RRNLTwye6dJj/cdFQ6n0/d8vLNLmw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISATbRnt6ehstxXQ31SEfZcNPcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmVjOTY2OTUtMDNiMC00YmRiLTk2MjAtNDEyMGM2NGUzY2YxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE0MTBjODhh\nLTQ5ZDItNGViNy1iNTk2LWUyNTRlOTIwZmJlYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB3gWQhJXuX6b8L3Hj7mVbarcwyGZO//2rCU19cGPqE4QAXyt2b3ILyi\nA7QECx0qMpfIcAjVmkwAvxJrZfk5+h2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGIJ2AF3\n2ue9oUGwaVqlF5IucqZvMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgNcE0Tff7NrRFy1dC84G5Q28vYY+X1BbNApTvt5leF9cCIQC6KkMKqtHKaN6r\n0G0EV2OEOqe4fq/zi+1XaWYJ4rE+/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc834", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `834` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAXf2mJK4tEcgg7WX6jxN88DZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0ZGE0M2UxLTVlNjYtNDRkNy1hMzhkLWExMmJiOGI4YTYzNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2IwMjY2MDgtYmUx\nZC00ZjdmLWE2YzMtOTQ4NWFiYTI5NjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpuEAFnrFYacHzMlIwfIwL76+0ru8yIWtvmRDF6Gq17CnWU1L0lFkxBCq9J7X\ngOjDBg6XPYprkNNWcuA87McCCaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWl4N5watRrqO+lOCjSZWvGuqkqMwHwYDVR0j\nBBgwFoAUNH0QcxayG5wWXzbECBK+t2gR5vEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIB1jeiDP4147jCh48xfjcL69hiByErRurI1mr1mrjQgcAiEA46hN\nADJ1dpJ+bXe2KMaCTrJkZHTCjgoFI6zsB1I3yh4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaQ203X1v6vOxJHN0T1+xPb4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGRhNDNlMS01ZTY2LTQ0ZDctYTM4ZC1hMTJiYjhiOGE2MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIPl3NzoZd2oCnZXhXfy9V0gC/l4WxeJy/eUbJH8aFR9C8\nY/kK+Zld0nlkzCa2HmWelU4bES7Rnij6ju7h9M3Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNH0QcxayG5wWXzbECBK+t2gR\n5vEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAPU+630f0rV/u0Z0k5DoRntqlZVaDMHb9KDv5u/Xh1ICIQCUy4WUrd5j\nQurpCG7/UDNwPKkbbkXhyb19rkGHjOBEuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAfZ22QHjzJWpgZ3AgvXpugPyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2IwMjY2MDgtYmUxZC00ZjdmLWE2YzMtOTQ4NWFiYTI5NjkyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQwNTI2MDVi\nLThjYzYtNDE0MC04MzlmLWE4OTMzZGVjOWNlYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOmAhr6ziR+lFWThsVgc47rX9OiaJ4WuIad/LbR2Lqf3oc5GhyzKAA+y\nu17WX05cIRTLRRkgqIssvOc+LCZxRU+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFpeDecG\nrUa6jvpTgo0mVrxrqpKjMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAMd7ASZmIaot0uybkoZ+vOTK5NsD49Uyo/LWkEhgTEL/AiEAudeLzp5Ls9cs\nw8p45y5JG/X7ZFWZ6AOZjp61Qv1GLlA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc835", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `835` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVIHLcKS7+Qs5ngLTm1dYsN5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkZjJiN2RlLTkxZjMtNDgwOC05NzJiLWY5NjRhMjM3ZjdkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM1MTcwNmUtNmI2\nNC00N2E3LThhYmEtOTFlNDhmN2NjZjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/YeS1SN9CG6aj9LF+fHKgfMqF3bYhlWLTGoKj4a6c3oWbmmt/L9o+DtzIsnc\nHVN/IIZwZ0W6wjFEw+P0JLEuJKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBDRVqcneokyFoUb+NxarvNlNqWwMB8GA1UdIwQY\nMBaAFLlyKNJv1rxmEI9lwFVZzblqZbjEMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAxgotp1voCGDdXEr8u6ZkDsITUWUNq9cl\nVWX2SMyujysCICyPHmI0j19b5OJfYnUoDoAvTjSA++0yCPSMkV0RW1Lj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS6jDaR7j5VI10k/JKK0jI7jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZGYyYjdkZS05MWYzLTQ4MDgtOTcyYi1mOTY0YTIzN2Y3ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARomvut2N27pKu8YcmKiouprLtEoHdDjIjdsVhRkr2wDo8d\nghTrYmE4kLwj24tBFKHroOhP5cmHh0ZlHNbTM2KAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuXIo0m/WvGYQj2XAVVnNuWpl\nuMQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAInxjbwg56/auxhXLhZ6ddGHF835eS2SenGS//zR8cbrAiEAzE+s5X8A\nimbpBD2psbpmGhDMaaJJasFXJotp516MHEg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAcpq/X5/pwZQvemMmikp8p6cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM1MTcwNmUtNmI2NC00N2E3LThhYmEtOTFlNDhmN2NjZjk3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhkNDJjYjQ3\nLTM3OWYtNDY4Ni05OWE2LTAwYjgyYzk1MTJiNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJWYjYLcVfIIbLjdSYbCP7QxWftrnNkzsFAukl2uyzLfZFetG9/aFn+j\nbjJzC1Xhc0/cEBvcMwfcaKpBhDcnQk2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBDRVqcn\neokyFoUb+NxarvNlNqWwMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgIh8d722ZxH6hO/TfLxMknIPTVE59189IhETlksUvPuwCIQDkq7rsbXH04pda\nwxsdfDbbDghERyzdspZ0cQby0Bn8Sw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc836", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `836` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAazgu8AwsDJ3yy/Qb7dref+SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NzA3ZTk4LTk4Y2EtNGUyZS1iMWVkLWJhYjc3MDk1MzUwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM1OGFjZjMtZTI2\nYS00YWI0LWI3OGQtNjBjMTUyNWQ2MjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/L93cQegs67so5pmbhvsbPaOb/R8V2gUTx4eolwzgEHOEZ09KgSbNXcCyaCJ\ncdmg1XzFJFFvKJ9CcTymmpMeO6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9TrrUmpnCbronp6Tex4H/pv1VAMwHwYDVR0j\nBBgwFoAUABr/c82dK3VPEn4agOgsYFZOskIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKcXRYOz9q9V\ntQYSun3vGoCOjebjTuBt22bic/Eee7IxAiA9EPeqkPcaFy1Miw/ORWb79uPevuBB\n5210ErDaSO3sxg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY11dL07MjrTP/F0PbW58cVvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDcwN2U5OC05OGNhLTRlMmUtYjFlZC1iYWI3NzA5NTM1MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfvmvQnrz/KMYJrP0forRuuKIxNrf19hWbpIyjHqwFB5py\naOkGU+mTvQsfFAQUk6keWBDL/XazRaQLXjVBZH24o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUABr/c82dK3VPEn4agOgsYFZO\nskIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOp8mRNgldxFR6t6SzUPtEkPsAeYbDWMoMIMG3yhk9U2AiEA4eJXVNPW\nXC9Ng49POfLbFT8kTYcnB85D3iOwkY7GzQw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAR0hFT2wmKX/tdAVddMBFUe8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM1OGFjZjMtZTI2YS00YWI0LWI3OGQtNjBjMTUyNWQ2MjI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA1NTNkZjg4\nLTU4NWYtNGM1OS1hYzAwLWZkZjA3MjdiMjIzYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGIQTx8BSZ0EOsa17f33GFTq28bjFPKvq26mLgVCJ5IniKSE0YiE1mDc\nieSBZ54BZBP7G0gKdfNOhyUdAMO1inajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPU661Jq\nZwm66J6ek3seB/6b9VQDMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAOvJgq0AQlQ87AvlUQws+ep6z/gfC0QMSF6YRJ+XmeSOAiEA8iwlPWyxrGDY\nEIIT9UN9RmtXmyG6lkPj2aIgK+natQs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc837", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `837` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAUCZzFTFcKKw/wGK9oCxNP6yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMmUxNmQyLTIyYzAtNGVlNi1iZGVhLTNjZjNmMmNhNzE5YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZmMGRmMGEtM2U0\nYi00OGM1LThjY2ItMTlkMTk5ZWJhMmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExw85cNcwJ5dCKcHJDyCk6w7DdfDU7ZQmSV1pDNCfoifUBbYhM1tzd8QTYoFR\n70+DcaH7lZzJb5qYw6/xhIDrS6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiJi3yRljOGlwxu8PTtK+Qd4FJkkwHwYDVR0j\nBBgwFoAU9JuJghqfY+XM/upB1Xg1nT9SthQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPkW4EttJBGd\nXXC2nzTZGq4pMffIOOUFrMqab2flv4+QAiEA/AU/2c2yrND0C+ylYvgECE7LGHrC\nxwc5mmYpTjg/rHk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdtaOEMq1ff1Ik2Qh1f3O98CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzJlMTZkMi0yMmMwLTRlZTYtYmRlYS0zY2YzZjJjYTcxOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjq+miI9jTyCzxXKUVjKcwoPz/T7mUkzoaJ8OlzEr6GQqn\n0AUdC0XDYvb/chmOvBUMjcM45qo9mzJ6jKY5o6iyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9JuJghqfY+XM/upB1Xg1nT9S\nthQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV3nAoy+nItDn7+z06ZbbLTk+OzhM07eTOU88tGB3wxcCIH6pPp8XMPun\n79DxM8m3TMVkGmHkcGxeG5/6+NLLRVHq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAWNZuQQprZwW/yC13XXh6Fx3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZmMGRmMGEtM2U0Yi00OGM1LThjY2ItMTlkMTk5ZWJhMmY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE4NTA5YWM5\nLWE2NTAtNDVlZC04MWE3LTJhZGFlNDAwOGE2YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDpgMLCx06Pc4QsbmuP6R1f18a3oTZ34mBDvEXziKoO44DOHMYIo72kf\nT2wgkmN3K4mcJU2bTzeGbvt6RrUgCnKjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIiYt8kZ\nYzhpcMbvD07SvkHeBSZJMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhALFKNkljy0WraBlZp4OLYMK4fw6thMnYY5uk4wUs/Q75AiEA3vTnphuuWSJB\nl0uujiTfhS0hemv36StPDnWQU/w1ZlI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc838", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `838` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAY62Ij8wQ1FfRASu23Hi82FmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1ZmRiOWFhLTYxM2EtNDQxZC04YWNiLTUzYzY2NTBkNDVmNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDdhYjE2NmMtZTI2\nNC00YTFkLTk4MzctNmRhOTdmY2M1Zjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU35PcSz7DsOVNyxVagOQqViPryjmB4vLaVo/OeJDT7pBCv017tuQGnMPtYXP\nnQsXxvvYvKpqmchmxlQAr527nKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVgK5FbCtgubr/h1+q2i0yaFxhNkwHwYDVR0j\nBBgwFoAUz0uo5LuNz4xx2fbIl6M/+W1uo2wwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGzNN+aEi3hT\nzaSXHiJYk1ZILxK9BptMtJ4uxw+CN+VNAiEA6wZROxoONhpDzhHbMAoUKrIE6IiH\niy+bpDOwHKOJut8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXhJYAKb/bJToEmYfyY0ECN6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWZkYjlhYS02MTNhLTQ0MWQtOGFjYi01M2M2NjUwZDQ1ZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5htKzfcvW5CRwUhNzUrmlm6IPJv86rALnxYSE+3kiK0qp\ntK0jwxz+nD3oX5g++Kz0jh+2gJI5ENMKIfo5cEhDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz0uo5LuNz4xx2fbIl6M/+W1u\no2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdmgR8k+dA7ZujTPNyE1Z/s0Y2HWmmvW6fG03kRcKA34CIQCeWqqtxcAl\nPGuFr9sfzTUr0l/F6b5BF+WrpKPwzRAf+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAdGH1fCDgcbDs+n6vy7f8wZ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDdhYjE2NmMtZTI2NC00YTFkLTk4MzctNmRhOTdmY2M1Zjc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRhY2VhMzQx\nLTEwN2QtNDUwOS1hMzBlLWM5ZTViOTU4ZDlhNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPVnEmzCvANMfEHv8NHbwtaQ/jGhHzQVF7IeKInh1CfkvgBvVugHYCzr\nDy23Sd8xgxGlbInKljOP2x5dZrz4MGmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFYCuRWw\nrYLm6/4dfqtotMmhcYTZMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAI6TeIsLK6rDu0SUEuhktp98D655oUkVoI3OjFq7qiC1AiEAvRFSX1xxGTQe\n715ddusHTr3ctxHwmBHfknhJ3Xt6gT8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc839", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `839` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWV4ivORb54h01zA3p/q3JkGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNWRmN2M2LTI5ZjUtNDIyMi1hODc5LWZhOGQxNWMyYmI3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWYzMTA3YjItNGQ2\nMy00NWRiLWEwZWMtNjM1MWVlYjdkYjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ0RYxpN+kNcsmYsvdlghnGlvyv7Gth46LZNjh9Q37QkLmb+CCCNQl2KoMCcF\nTr6JOH7qi+rgLo+rHpaXG+QnMKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDBHI2AJxv8JWqAXIOmw+gwxYqY4wHwYDVR0j\nBBgwFoAUskZihR5ISVNJpQa5FhCx+B433O0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEAViKfd+ImvvAPw/g1uP6fyRuZmBr+InpcTenTKcog2AiEA0CCezkNcIlB9\ny/UilzyjgVpc17zlkhokmuol7vF5aTk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbeWYUvcasgoQNYEL+QtTDC9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDVkZjdjNi0yOWY1LTQyMjItYTg3OS1mYThkMTVjMmJiNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASl3r/8xhzCxh+UcQZffcI998ebKBIk7Pk1fRt9Pu2XDGk6\n6JLblYytlDp3SUomr1taF/lnaXhkhx/Z/iYLTg4To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUskZihR5ISVNJpQa5FhCx+B43\n3O0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdv2/9uxCAwfxBzt5LLfY8raNIy87c6YTBQHoHzaKidICIHIq98SDnio2\ne2/yUAVJ8SvW87wCOnnjihCU3I7dzgI9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAcw/GdZOIsv/0IBFSpT2oemBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWYzMTA3YjItNGQ2My00NWRiLWEwZWMtNjM1MWVlYjdkYjQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVkOGZkOWQz\nLTMzYmQtNGY1My05MTBhLTQxN2Q3ODVlMGY2MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN3+hiHnSc7l/vazzMr4TtlYQIOeRayBgiilghEfYHIfyTNdRjqWcWvg\ncPjIsrKsX07dsWDMRYaL8xugwvSc5xmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAwRyNgC\ncb/CVqgFyDpsPoMMWKmOMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgMEJL3bPzK68tdUaiyJNdm668Tf6kSKyRu2gKby4Szy8CIQDdJ2M2mxRC4N6C\n05XwurZU6g8BI1a4tr6HEQ/SfGgTIw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc840", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `840` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdX1AlvJXdcIqvq4/BhLK0nhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5MGQ0ODYzLWFkMWMtNDcxNS05YTQxLTdiMDQ4MGFjZDczMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFmZjRiNzUtMWNl\nMi00MDkyLTg4ZmYtMDllOWEwZTI3NTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYlJ9pEY6GTEpXqxkne/0dnpbx9msS6Y2M1NIjUk+ixe7QJq+4+nFmSCVGrZW\n++pI9+lSq2g0a9Snpmd4m5/ejqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgZGQqle9krCffU6D4qinkNHCjKkwHwYDVR0j\nBBgwFoAUrHerLFkSA/qv6Unu46g9xIpBRd8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFNti0rZkWrpJ8CRi3pwjU0MhdbLHJUFZw291+TgvaYrAiBd4w5fFo43iXjL\nnk/jpViRiFknP6YXjh+UASNTu/q5Sw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUCVp704rjDgmCyffP5EOBCYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTBkNDg2My1hZDFjLTQ3MTUtOWE0MS03YjA0ODBhY2Q3MzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARI10c2vLoYhzFZA9z5EAzHl8vk98SIUkOiZ7Kny5Hfw4Qi\ninE0y4nX5ezyx6mlI++QkaacWywCFXdUHom96GUro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrHerLFkSA/qv6Unu46g9xIpB\nRd8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPGLMjW901mHB3TXIaaOs6AvkjsuNpNoOx89EvG8Y1R/AiEAlevz6Mr2\n7U9c3KuPgOMcbth0wLni8guv/a5aRNuB5/M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAY68lLkZTs7DJtgLJslK0aanMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFmZjRiNzUtMWNlMi00MDkyLTg4ZmYtMDllOWEwZTI3NTI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU5NTlmYTg4\nLWIzZTgtNDg1MC1iY2FjLTQ4ZTQ3ZGNjMjdlMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGUxsUENrIM1FEgkXxpndMMeR2bsSe1FmVBdDjRwIV1jqIEDyMKpfLx6\nr3QoHf8YKLkx4Z8od/WGX6/sy3fscMKjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIGRkKpX\nvZKwn31Og+Kop5DRwoypMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhANk/u7gfWb12HmygHa2Cl6XwlVcwb2G0Sj2D/JVWpX5AAiAzLl+3lKNtlSkU\nbTSOrwAy9kin5Cs3xj2Im5B7e/hm2A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc841", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `841` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAS/PZf2rOfPi69V8epomgNEzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlZWMyYTgyLTAzZDYtNGFlYS05NmMzLTg3ZjE3YWQwNDNkYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAzNTliNzMtNDli\nNi00MjNlLTlkZmEtZDRjY2YxMjI0ZGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJDrZcMeoSi5ATN/aw3n3/Lj/axubwIxHrYFY/sjEiztwm8g5/xdhQQUuN3Gq\nHsLh8beD36l6WEUHsYvDabIRs6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGXgdH/1cg+3hbborp3N8mOLTc4YwHwYDVR0j\nBBgwFoAUhmKqMYTaDvn498l9Kb5VtOJ79VowLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCD\nSsLW8Jph8r1pXErEtiq0AbOhb4FHeG0jyFqurAp14gIgPXJVFxVInzoPRpuAiZTP\n3TOSdDCTrT6ycBzb33DOSxg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ9Yr8jIgpAD3mGMSNilHeR0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWVjMmE4Mi0wM2Q2LTRhZWEtOTZjMy04N2YxN2FkMDQzZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASR4aJglVFLOrzWUTyuLQsAqB952xEv74XMPUKJ/GPsJ9cT\n40sLzI8NU7zW84PuDfhPTt90NPriCstOiE6LorsZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmKqMYTaDvn498l9Kb5VtOJ7\n9VowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfBqfXpYUfrR01x/VyjL6SJB3ET+GdB9mQpPI1qFxWNkCIQDveS2k2T39\nLClBsPa7X/6Gl1Lnzv865u2ycmke/vpg9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAc4mcUEfjhn6xQO2iKudQoeMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAzNTliNzMtNDliNi00MjNlLTlkZmEtZDRjY2YxMjI0ZGI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRjMmQwNDBj\nLWQ5NjAtNDc1YS05NjJlLTFjZDc1M2M1NThlNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNTv3/4vY8TQuATI6Q1wScjklnK1wKAMioHXDVzCoj9MQ/gz9a6Fv9RM\nky3bZZMdzVhAPya6enJ9C96zvfWc+d+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBl4HR/9\nXIPt4W26K6dzfJji03OGMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgL4twNeoJ18Px4D7p5y1pQrvGoGwfJbi4EZGyVeFV38QCIQChMALVkdw7neJ0\nXNh945R9vFCgsv+2YKW/KFRLa9LsGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc842", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `842` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQPHtDmNeJMvexxxQFrk92bJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0ZDZmYTk1LTMwMzgtNDA4NC1hYjhjLTJkODQ3ZDMxZTBlNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNjNDhiNDItZGU4\nZS00YjRmLTgwN2QtNzQzZDE1Y2RhYjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmppTTFcgQofOMs0yJpCRGGPXXXuOk6iUTuYTaSHxQjJ8ijjeWxxzHlotQwLs\nd+CiwaDQCgRQEYW6p6qjW0QyvKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX4ZLhyGfHpnFbboU1BqJsRdfIDYwHwYDVR0j\nBBgwFoAU4pWCZ2i1zJJ7cCMP6BKRhE+Zfn4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDHiDCbOSiRdBXbMXMqNgX5Zrp/In6Z4r8qoukObfEhTAIgRleC\nrgFDsu8anIJqYs4GGDJ2xbD2xrVwQC06HxWCPXE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZd8cBDRz7EkGa1GEEXL3ZRTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGQ2ZmE5NS0zMDM4LTQwODQtYWI4Yy0yZDg0N2QzMWUwZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSogxyDOaJhf9isMtjhk+oasP/7HlKbXUqkG0MxbdiLLZq\nldsjiJMOWLnY9vxHNqRVDaTp0QzVLINZlZMA/0HDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4pWCZ2i1zJJ7cCMP6BKRhE+Z\nfn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOV27tMlishAxq+V3EVfSQpSiUzOtqidQGroi8FnVgtFAiBmPS0pSB8S\nbibsgkmxiz53btnRr+0EctVzwuUMlIx3AA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAf7ScN3B43Blm0suTWS0ZM6eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNjNDhiNDItZGU4ZS00YjRmLTgwN2QtNzQzZDE1Y2RhYjZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQzNWM0OTE5\nLTg4Y2MtNDgwYy1hMGQ4LWViYzU4OTM4NTRmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ5Ic0U24OOoJmfjLlk3628ubZSel2SO6PvXTtbptdF5qQXPLhm/3Cst\nOHCWJdtOendgtprbzN9F3zhrDJc6UhajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF+GS4ch\nnx6ZxW26FNQaibEXXyA2MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJ+WrPpqG/kw14Mo9qhgWYYNy5qZmjyjETtb+XmgxmZ0AiEA9U1tae2qJzTA\nEFQPNx6aTW0yI0U8le5qXnHv7oujqcU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc843", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `843` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISASIdL23UjuuLCfnrciWNKtAVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhOGFjZjNkLTk0ZWUtNDk2ZS1iNDBiLWY5NjFmNmM1NDFmYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNkZWYyNWUtM2Rm\nNC00MTJjLWEyNTEtZTVjNDEyMzIwM2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy5yATehb2ZCApwrhiR6bgJ3plmPcUSLV3MX3P/XYKwXR5EI99dqZQHQMX+B+\nNRO3sVI8BMYRW/U5jQRx+H1jL6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTjzngHsCU2W2DPCcj6C/cKVw168wHwYDVR0j\nBBgwFoAUGO2vO37vV6/lYDdrud9wrjUzRZ0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIDdzccK89FAoQ88suhYVd6ldNACKMwnGT4Wd/2klwRuzAiAa7itm\n82iVyqbbkf9hMywkcpZgaz6IhefCN1iAzrNA1g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXJXLO/KMXRVwyK5perrusqrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYThhY2YzZC05NGVlLTQ5NmUtYjQwYi1mOTYxZjZjNTQxZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATM+GWhLJvCHWvUNsBNXUWQ1e3eq/Dx/hWGDk62lfuC5rn7\nm5TyBhVMADr6WWrVXcO9yME8krw7HqHFhvc5BT9no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGO2vO37vV6/lYDdrud9wrjUz\nRZ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMOxaBo4fMbAKZpcTpdcGYwUiCuw3AYgvH4gmyr7hywcAiAwXLwcfAd7\nTz3NEFgCQRW9p9+6c9pd8iSQzXoLvPRU9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAapb0VF35C0NtMIVudI8JM78MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNkZWYyNWUtM2RmNC00MTJjLWEyNTEtZTVjNDEyMzIwM2ZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNmOTk4YWUw\nLWQ0MmEtNDhhYS05YWRmLTVhNzM2OWQ4ZWI0OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNcks0a6/OOj0TTSObvrkgMlJHD0gP84rqfmAWCflYq8CBat4B6nWyfx\na8FBKwW26f3VQj9768D5VwoW9TvPYE6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE4854B7\nAlNltgzwnI+gv3ClcNevMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAMIJj865K32kwIaCZzbw0U4eaiR51UzsoAehucRmsnSLAiABrcCtz8fzzlEJ\nNxE5lo8S1ypiRAD2kLBvRbYpDwxVYQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc844", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `844` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAQx5+QT9qo6CJym8ibyCX1PkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5N2I4ZjViLTc0MzctNDYzMS05M2U0LWEyZDJkNDk5ZDdkMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA0OTAwOTgtOGVj\nYS00M2FlLTlmOTAtYzMzMjY2ZWU3ZGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcJoyXR9FMmd+LWGsl9dTc1SIh1cYnU7HMivMkDKcPsqI3y3tEaAhw4oSeWAR\n8eWlhDnvk/voG13N2pMtXIaBGqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRKLTn2u6RBLrfZKuEmyCD+lgssJzAfBgNVHSME\nGDAWgBRTHYYp8oDPA8mbpvv/4Seb0tsPVDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFSh6khRCBvbOUdcDJu4OVgleCXR6uoK\nY0cAzqHNI0FJAiAiAboHscS5pDcfkdJWq2nSveRCf5z7X7kOPbTT1m3RRg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfuYYXzEQghqCcJmpITaZ/MYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTdiOGY1Yi03NDM3LTQ2MzEtOTNlNC1hMmQyZDQ5OWQ3ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQH87p4sFEIQEanulb/IVUF+vc94C7dKyCCKOBG0TQwHYmY\nhzZQQB4xxmbFgZojXgn4CbWAICfF0rjgurBoU1wdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUx2GKfKAzwPJm6b7/+Enm9Lb\nD1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKeB+vdXTAGFHC8yup8uW7GsCd+lfh+JGxCSIe6vozf0CIQDuAh5WfenA\nfpTp18olFa7MvlVodZ5Y0niykuQfet4zqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAd/xCpH1xYQz1Qec1q0nUO4yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA0OTAwOTgtOGVjYS00M2FlLTlmOTAtYzMzMjY2ZWU3ZGY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI1NjA3YTA2\nLTdmNmYtNDQ3OC1hYjYwLTNlZDY0NmVlMDI3OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABONEtcBP0eZHj6nTTFdVxLqZZaOAeLJIj5HOIYbdOh90KVCwd7RIlK4c\n3kcfiJN488ZebEv3VKNhqFn/Viz525GjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEotOfa7\npEEut9kq4SbIIP6WCywnMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAKuXQ/8cbZjU0nroPU5mDEAQ/jv5YEgTCWxNDqGnS1MJAiEA+b5M1C+qU/Yg\nGJdwWolLUTkRRfZaAjk1DjbhTO9WuLw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc845", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `845` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAb1F++ouoXohMAsYC/rzrtQWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZWJlMGNhLWVlYmUtNDVkMC04YTAzLWQ3ZjJjNzIwNzQ0NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzMyZGYxMDYtOGRl\nMS00ZjY4LWExYWYtMGRmMjljN2QxNDg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESeJqfBvBZs9N8cKijokTTAV1NFkstxe7dY7U8zSEhbsXYesSoW94CsvfEbDR\ne9lU3s258vC+audz2LVB+HSucaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKj273SlNSfANFxqeZo+Qd9OZk5QwHwYDVR0j\nBBgwFoAUUPF/w6FZ4fG4sEKn5ONqFpnrM7gwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICtmDdhqBM8P\ngiXFALL8LEiNXQN0AIXLfad0ljDcyNQYAiBwWiof8MPrXqsL989aIcbILvLrgYUb\n919qLwxEd9Godw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYCVDgdYPyHW1e400Jjnb9dAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWViZTBjYS1lZWJlLTQ1ZDAtOGEwMy1kN2YyYzcyMDc0NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+NSVSzEwQj+liqGY0Jmv5MVxtvtGePUm5PZSuY1MaUK6W\nQM6qIgtQrbtQQt1wLYQvWwJZgkim8Wy3vABTvS7Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUPF/w6FZ4fG4sEKn5ONqFpnr\nM7gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOKlERMzK6yJd2gk0mcCznAi5Ikal3GXJFACImAkxLQ4CIQDY4Cu0WH3F\nP6tRWxlaYJYsaN61/Yj8vUAZhkKFGVfI/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAT0laIguI+cvX0fBZ4AfbTQFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzMyZGYxMDYtOGRlMS00ZjY4LWExYWYtMGRmMjljN2QxNDg1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg5NjY4MWQ2\nLTA5MDQtNDAxNi1iOGYzLTgzNGJkMGRiYjBkNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBI8/f9iMMDF14ooOk1j7fgOMBa3uf7khVFz8j4GGdPymPDddihKQOYq\n2YBehqW+2dTS7JSEWG/WfTm6WZrKchSjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCo9u90p\nTUnwDRcanmaPkHfTmZOUMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJBy3sIqqRO2oprYirOviKDH5EraFIirbl0DPtVbbIpnAiEAkNW6hboawqMn\ni6H9HJGWaU2f5E/1BzTc8gb3yOVKO2I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc846", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `846` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISARBTvusGIh991/7o//eOMQ48MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0MDdmY2M4LTdlMTYtNDY1Ny1hZTljLTY1MTNkZGRmZDViZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2QwYzBmNzktOTdl\nYS00MGM5LWI4NTYtNDYyN2UxN2I4NDMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVhqqngNhJzRHOfCM5jjBA07AfbrBMEqMPaow9S/NsnRuy3Ocx1hnv7I9KoN5\n4me4NaFpxssqnc54Y6kROjw8JqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnZCPo7gRn7VgqgegJxZ/nbdEPncwHwYDVR0j\nBBgwFoAU8/nVlzLwUKfFSROefqcNfh6+hi0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDwCTnoKGpp\nxqIq8OixMcna5QQexnjjOZmWn0f1lC4M+gIhALo6AdlSIf9eByYjq27/W6foXSRb\n+BwkSjPU5OFlPSey\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARzSOf2pGhKEmag8mYIS5EdgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDA3ZmNjOC03ZTE2LTQ2NTctYWU5Yy02NTEzZGRkZmQ1YmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2DNv+aUzD0GsPF2zp6ysezoEky3B24a6hcBK/5Y9SPCBj\nAeyH9/qrFksKJj4qhVFvWRgLv8+Y0QCnOjZSQHlxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8/nVlzLwUKfFSROefqcNfh6+\nhi0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPmrMb423T+AVZCjJFGpGXDM29LsaXTgFjQ/q4IgFb7UCIQC/VawbjxXo\nVEq0AsSmLoXT+ObACHelp2s34jFedpC5ig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISATEPBTeCcBwbKrFLMwyHzmraMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2QwYzBmNzktOTdlYS00MGM5LWI4NTYtNDYyN2UxN2I4NDMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhiN2E1ZDRl\nLTNmMWQtNGE1Ny05MDY5LTZiNTExYTcyYTU2MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAHIKT0uKPS3mr3XYUNqisVzrIhRvUq5iGJvM65EBcKPDpHvvusER0Gx\nPgw38Ipbfjff7dVSLu91gO3rHM/3SayjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ2Qj6O4\nEZ+1YKoHoCcWf523RD53MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgJbE8ILdqZ3MSrNfS0rFSn7dCZ0dhvdWQR5A51iOq5kgCIQDTTDF13ur4i8Ra\nUZmPnNxdOqTzDnO+LziXc6PvVqnEog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc847", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `847` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAURe9TBug/n+Utos7nDJuNbOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNjc5MzE0LTNmNTUtNDM0OS1hNzA0LWU3ZjZjZTAxYzYxZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmMwNGYyODYtMzAz\nYy00M2Y1LWJmY2MtYTIxZmUwNzM2OTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXkZfbbrisu51kP2dtsQGRvRmjodt0ku2AH75aVumpeazMaXGrk/zpw++cflI\nsW9u1rapw7L0faAHA0/m9hxw9qOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5fChUVzZjInJJsQcbjM/Y1Rs6SowHwYDVR0j\nBBgwFoAUm1aNEazjzcQ386CkCPxNXytc5MowKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAi3XXF/iiS\n2l2npCC1jqbeCWsbpqxdI+15Jky/Kyby1wIhALSo01nKaCRhLnVsbCHSEpDtKOVI\nWxxjmO5hs+tJpiC0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUdkkbe4w4gI88JhhKqq/KoPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDY3OTMxNC0zZjU1LTQzNDktYTcwNC1lN2Y2Y2UwMWM2MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS764VoJTEPIIzJTfXgN+mIiHoEEaexV+XVyc3tv9LVIMYI\n1jOTB2fd1l6lZa5ThH1HUurP6pMJwwWBNZ1tni2co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm1aNEazjzcQ386CkCPxNXytc\n5MowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNshRMstUCoZrT5Bazj8rJ2uIjuTnSlotQENgsoDRcvcCIQDCzpolSKwk\nMP5XiLSvaQmNnXr4XeGXMwGBsI5UfPfPYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAYEktPUCZmCcRrKBT4vRrJMUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmMwNGYyODYtMzAzYy00M2Y1LWJmY2MtYTIxZmUwNzM2OTJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNiM2I0NTQ3\nLTZiYTMtNGRiMy05ODczLTkwMmM5NmM2ZDA2NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLWVoaifufRJ87CJnERhdxEFLxebcckRz0UjWx6H1B77U6KLAxhup/rM\ngFxTBxlVPaYafFuxUPqpjfMMHv/g3QmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOXwoVFc\n2YyJySbEHG4zP2NUbOkqMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgP0w7PSPu6iDqDUtLtWtHYYPYJqosbuI1TutfJLtZMVUCIQDFHqQmHYmCdnX8\nLOIpqwS91lEAt0mYe/agk4YPA2y4NQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc848", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `848` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISATmvsF1PjvwpSiIxKLT4iTMLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhOWUwZmQ5LTU2NjEtNDlhMy1iMjgyLTIwZDkzMGZlNTc0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NkNjBhYTktYmE0\nYy00NTdlLWI3ZjktNDllZGNiOWM2MmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3/8cZm+PWlIcItvr0e13QGrH3jYjOhWU2Qyq64ljsXyHw67QC315if6mXDmy\nwMl8qme8pICJmtACwLs+U+odfaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG0lkV2N0qEtBnB9qdEEKn7KS6ocwHwYDVR0j\nBBgwFoAUqDb1FACgTqFGZohFwyxN7usuiI4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAwLQIPQq7Bd34QDCQoguoVKVOhFESW6h4gd20IJNHkigCIQDkAQnZczmN\n9YqqjSBcVaA6zEsyJYohwTvSX2mNjw7SFg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWZ6WFQaU3hc4oNH5u0F7vYYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTllMGZkOS01NjYxLTQ5YTMtYjI4Mi0yMGQ5MzBmZTU3NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtLf4K1wy5c5iKenA6mY2H9e/723lNEV7VmBMyym/Ovdre\nvueXFhgdtLJYmY//ewMXilaZlwkKeHZlpnJBetvao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqDb1FACgTqFGZohFwyxN7usu\niI4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTwFokZkKoGyo6kMe0Y3cnTrATIQDG3k7wsKfMb40/H8CIALxMt1KvTor\n+KQP1qh8LFer2wazAO/heJ87K/9KuzyG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbJY/+xCHzmdPz1nY7bp+71eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NkNjBhYTktYmE0Yy00NTdlLWI3ZjktNDllZGNiOWM2MmI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBjYWJkZjVm\nLWI1MWQtNDE1ZC04ZTM0LTA3Y2IzMmEyODY3YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIsVsNmkmt1y8bLd1E94/zC/VgLtbRUJUWIuiF8FI21dUTnmlDqraSGH\nrKHkI6+xLxZHtYaSsNEILGLzosVOUE+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBtJZFdj\ndKhLQZwfanRBCp+ykuqHMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAOYpxbXFfsGZ0p5cgP0xTbjZOAaarpM+7Yjn1W0Ui9jsAiAYfCNI8VsYul/J\nqMF64S9ltFINdo8tklwTclAP15Vr4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc849", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `849` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAa1oI9pc98xEAohNrxyMdv/8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2YWRiYmJiLTMyNWYtNDMxZC1hYzRmLTY0M2M0ZDk1YWU5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWU5MzAyMWUtZDkx\nZS00ZDRjLWE3ZTctZTJlMThmZjE1MjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK25c2WVVzXCRdjpRRjGs0Gpq7FPKBpvqwA205slA7YildPUrzkISEf6QVAXO\nOlrq/nPSxe4Dg0lqOu+tTvst2KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5aFYUAlFzEwqUE3VZQDvmPzgTBUwHwYDVR0j\nBBgwFoAUKTk5L45bpC8t9YqPgst3ONmzJjkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAL0hSUG5tzvdMBXtBpfrsIHO016u/Oee5YF7C+YdGv1QIgf/jqe5wgJwH+\n3KndSxSUMIU+/Cj5SKprjg/qFyVF5gI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeW1c7ujuqjlQ3MxSC/4dl03MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNmFkYmJiYi0zMjVmLTQzMWQtYWM0Zi02NDNjNGQ5NWFlOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT92ann+1z4xBw2cFU0zXSHsdbA8E4+BKojNiiFOdG5kcfh\nIVcLtGhygNA16n+005ptgEAJ9q2Zfb/e7GHBQuj5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKTk5L45bpC8t9YqPgst3ONmz\nJjkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ7MGihFMfONaZghaojdAUasCERZ3NCYvJxhUdY8za60CIGYXRvky4zM9\nvcvJRUepVwgdo5crbOEygevX/Ri29By/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAeo3YTX6fL7rQOCm54C5vU08MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWU5MzAyMWUtZDkxZS00ZDRjLWE3ZTctZTJlMThmZjE1MjE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFkZjU3N2Qw\nLTI3N2UtNDYzZC04OTIzLWYwNDIzMTRlZTk0NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH9Ivg29fM1xlciHMcI96tUB3X/qhhL6gSpE6mZqB1m0OHy7RTrlLIjz\n2on/GkcKYaSAzu0t3maRgvPp0iXnulGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOWhWFAJ\nRcxMKlBN1WUA75j84EwVMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgBidbAeITM4PMb3H6qpldpE56y6VhtI85xl/Y1Ammqm4CIF4vXT2clYVpdgw4\ndbZEPS88UVP/lTB5YX8S4z0wLddr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc850", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `850` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAYIu5pS8lCReW2lDMYRe8pD/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NTNlMzAyLTVmNjQtNGExYy1iN2E2LTkwYjc0YWM5MTdlNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDYwMjIyZjEtNDcz\nOC00ZmQwLTg2YTgtNmZmMzVkNjg4MmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnwdcPXsCRdK2og5aSthjX/0aRubs3Pi5ZN4mSAnE/abTazz+tMllcgLB+yNW\nL6hKxHFpJqak18MftcVUyEL+XKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2rUFoSI92U/tJVNgLNQrj2/0lI0wHwYDVR0j\nBBgwFoAU0AI3KHKFBcD35bNw0nJbzORPkEgwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n4RBY2e0Daor1ynJvK9Gumj50/0xe7EO1Cf/Ufw8xWAcCIEVtmc6HCPbISpbyxEDo\nYdYBthDLWoVfl+ISrp0HaJcB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATiVeEz1xHNCZIN60oFd2gW5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTUzZTMwMi01ZjY0LTRhMWMtYjdhNi05MGI3NGFjOTE3ZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuwyVtXv8zFziuzv3KKArZB8T8SsRDXeE7AomKYWUQQOtj\nr+qY7qOC/WWwZPrPHlwuHNrFOaathVGJLejN2615o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0AI3KHKFBcD35bNw0nJbzORP\nkEgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMaZA51GMLy6viDgeFArbn3d6KSiOE6cwzBEUG/mQ5ovAiBsL03zvjKZ\nicRqcCEy218GpEKg/jGaKdXbd9pFjUELEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAUBUZ2m5hb7d+gDXQ367OewRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDYwMjIyZjEtNDczOC00ZmQwLTg2YTgtNmZmMzVkNjg4MmNkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhjMzA0YWI3\nLTY4ZjMtNGEyMS05YzVmLTE4MGJmYmI0MjNmNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIJctgvvIArcndMXiZ9Fb9S1J18aJv2xApRO4C3xiEoyPeT9VpaPsHPM\nzYu4KMK+5REKkJxGRlkyETiHlgycVW6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNq1BaEi\nPdlP7SVTYCzUK49v9JSNMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgCihcfVxOpgJy7rZ4c6OKrdwb7f7phVJTNz1wJRQ0dQoCIQC5eXFAnfda46kO\nXvQOAqQ041AUI43koBkWdvbVFW0RAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc851", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `851` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAev0zzleFnT4X9EGuAUq5OBlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1OTI5ZWUzLWQxYzEtNGIzZS1hNTNlLWE0NDUzNTNkNGQxMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmEzNWRhYjItM2U4\nYy00MDQ4LWEyZjAtZTA2NGJjZjQ2ZGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVUzZfG+ToqwC7eYlSaEJ5YsqOwBJBL+d+64xOM8Zbha1mzwrymoki2BbttpB\n5ZXTIoMDyQcOLETW97IxkOgFk6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU72aoi9E3b6T6STpgk4rywyssyd4wHwYDVR0j\nBBgwFoAUgCewh+tAEFX0kxbkBqVCzCrEHSUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAli8n1PIPJu3ZF9qr7qGUTbAWrY8/8L8MrkxeLz0XjQwCIEVj\nQblg/syDkQSc/9ahDEMYixUY6nUA9KW36kRDgM+3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARWk5yfSoIpLw92KrDCpeIw7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTkyOWVlMy1kMWMxLTRiM2UtYTUzZS1hNDQ1MzUzZDRkMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzTNz2moXkfytgJJHsR2c2jQ1heZZvadGydTHV0D8NQHV7\nk5wXIWbwnWpC8czz0Ec6TkgJN5wF1RxY+4SrDCgIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgCewh+tAEFX0kxbkBqVCzCrE\nHSUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIUIFEHqRoVJt1kYw/Fz+CGXG20/CkaFirfrbnM6Nw5YCIEvszYYic4t2\niraD6Xhxx9MHYt4lqtlnjvrrItxXsEz0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISATi0itX23icdtzzbzs6fWZfnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmEzNWRhYjItM2U4Yy00MDQ4LWEyZjAtZTA2NGJjZjQ2ZGRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI4MTE3NTNm\nLTBjYmUtNDc0Mi1iODgxLWM4NTU5ZjljYjMzZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL3C24H50xida+deojAqtzIT4jlzFQUQfeZH3eNcz1w/me4nTC+ngveH\nu3cc97Jg7EsDjsav2lHCJywE50PCw1mjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO9mqIvR\nN2+k+kk6YJOK8sMrLMneMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhANLrpDUpEJ4mTNHVi/HSAPeFmanvYmi7ky92dAdB6wPpAiEAr3r5P+grw1uE\n4+3pOHf8d001S5Sb60bQtqGywtOHGNY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc852", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `852` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAbLTrRk9lP0ODkjiQLmd8M/hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlMzBiZTUwLTBjN2YtNDFlMS1iYjc3LTc3ZGEwZDMyOTRkOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVlNWI3NGQtYTM2\nZi00NTQzLTg3YzUtNjk4MTc1YjhiMmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeMFOrbxdq33cYX8YkNvKXNWGH/x0QaEEAhen8nttbQFGUSISvI8FWh9R7Kwx\nryv2uA3iTCBNS3di9wy5HSlfSKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNM6T4Ar00qH+U1QRc7WfZF6+HYswHwYDVR0j\nBBgwFoAUxwo/dTKdJpxly1vtShFwMo7TGWgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAvRjD5/wJv3NQoDZn2sVs5GvLEgRbMu6ZXWOwS7jC6LMCIQDt\nkSZdDQFGb0Wz+2OGYZ5HFkF5qjAcuSiimLee5vW86A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS/CYO1JYMDx3oU/QyUCLz+mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTMwYmU1MC0wYzdmLTQxZTEtYmI3Ny03N2RhMGQzMjk0ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwSTrWjEO8UgJuvQBVssBRy6XsJkZz4h0yl42Avc1i655n\nx41L0mZmjS906qUlpGIyfck2fe50eDI/+BgaYoC4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxwo/dTKdJpxly1vtShFwMo7T\nGWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDggLVYhOmeTeR863M/R7fSQl/Us15u20o1xUD8t2PMUCIQDiy1oci3Xy\nDxltnFAYZBEkBhc/zQSTiEwHsEzIZHs1Vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAXItSa3ufn+oRUKFDzUEl9inMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVlNWI3NGQtYTM2Zi00NTQzLTg3YzUtNjk4MTc1YjhiMmZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlhMTRlM2Yx\nLTJlYzYtNDQ0Zi1hN2Y2LThkZTlhNTY2ZmYzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCW2fI0zr/f3MfNu4sauBnDdR6IHg9DnR0317RZW8FhonZojzYECgT/Y\nTKQMX3r9TVDn5D9vKIArE/xA++jCrpejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDTOk+AK\n9NKh/lNUEXO1n2Revh2LMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgCrVwpEcPM8imnMhLah/c8XUg0F7d3666lamFVFqDJF4CIH+iLTJQYguEfAy+\nFy3TVKzVjXQlZ1ggZ8++rQrZSIS5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc853", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `853` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISATnlggkCpekbzMDtqaCE2TwXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0YzViODAzLWRjYmQtNDdhNi05ZDUwLTYyYThmOGRhOWYwZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIzYzE0ODAtM2Mz\nNi00YjY2LTk0ZmQtODUxY2Y0NmU4MGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHx0rwyb2IWHueE8nxHxRTBQVtBojmMWU8UU4Ac3D2Q3Xd2eGOxC0eE5Lfi3y\n8VRUTFYjU+12kWA9THECKFPFbqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsQaQyoq44qLP/qwTwF44aA+fkocwHwYDVR0j\nBBgwFoAUExptAT99NW2ND52Mj4dpRzqrO8MwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiB6tCnKWJblBmXP\nddF7trx8gb8o0IgtIsjcxoV0I3+prgIgV9DtApHeh6noxCBfVALosezc20tEGsQH\nX1O87mPgJ1U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWWhZDYiLZsgGS4jKDkD6ArgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGM1YjgwMy1kY2JkLTQ3YTYtOWQ1MC02MmE4ZjhkYTlmMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrpzsQPTeXwBDJUsXxIv29OGa1cU0XEqW/w3zYoKS3vaPI\nnOeCCJn7CpUg0Z29aDkOauXeyO3x0PvDJYbbU677o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUExptAT99NW2ND52Mj4dpRzqr\nO8MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKTEY2dl4p4Mu0/PN2X534VENbTi3K3wFARDo83uZe6YAiBbGUneTkxA\ngnAfcN4g9+ratJOgG3R22vwN9AVz3yfMFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAazHVreBTANp2TQiOCt5x/7qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIzYzE0ODAtM2MzNi00YjY2LTk0ZmQtODUxY2Y0NmU4MGIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU3MDUxNTkx\nLTNiODgtNDUyNS1hMDE3LWI4NzJmM2EwMTBmNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAbfRhljdnZDR1S+kL303pY3BAtU6X5Miv5ViFdvbTHyqA4uGTc1S1jf\nmoQUZGkDR9ZvCuD77K4L3DBmE/rUH/ujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLEGkMqK\nuOKiz/6sE8BeOGgPn5KHMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgX1EZ0OtOPmkV3PikCxma4WZoglVapZbYxJ9AKUb04PYCIQCXUMmDsuiVo6ed\nWmWZBNq5Mkz9lQ9nQyk+PiKW9jEqBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc854", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `854` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYHhUfiuVnO1clW7w4aRetEGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4NmQ3NjUzLTAzZTktNGMyZS05ZWVkLTVlOTMzNzY1Yjk2YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFjMTBkMzEtNzdj\nNC00NGI2LWIyMjUtZGQ5NDQyMmZiNmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx574icA+4Y4sSYnS37fEHjKfp+VzgUBM5JMXVHrqoLExvn+pcw6eBzGqtSLm\n3/RQAUr05utaiqHIiGZnuiD2fKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ/6dMhttNIDA5oGqEXtuN5TXtaMwHwYDVR0j\nBBgwFoAUjND4C/FK+XfaIrYd8/LerT0IY+QwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQClpZqUoFSChu/t5kCLuRDSBHbYgB9d3yJLCOYCnVGsuQIgCE0j1LxJq16b\nm0UGp6ZAMh5LznFQK4sugdHcciZCw0s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV2+5hKLY5IhHfAmV0Y478F/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODZkNzY1My0wM2U5LTRjMmUtOWVlZC01ZTkzMzc2NWI5NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKIw6NekurLvZqJSdhc/BxnRf7EDDLrhfhmnaC0oZHHT7n\nx9EWHYOTsdizdPd2R+JDp2VlY2scgoUVfm1S83Wco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjND4C/FK+XfaIrYd8/LerT0I\nY+QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ6+OhbnXvL1v9vKEIMd8XqYpz2f6MwVT5M9NbVX34ekCIQDgboLsnpM/\nd05ChFo0Zn0/cqVp7QPbPUt/TebMmO0R5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAXaP/WmmMQ6jVn5rU6Z5ujT8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFjMTBkMzEtNzdjNC00NGI2LWIyMjUtZGQ5NDQyMmZiNmVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM5ZGU0NDdl\nLTBjZGItNDc1Mi1hYzBkLTRkZmI0NTFhNDI3YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLX+i5GNov+/dvyJRL0p/BkJa097pQ/YzIp1AOgYBeRnMyOMI0ABi+Kk\n4PWVHm7Q6gJw3uwoxXD2aEcduHswp4yjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGf+nTIb\nbTSAwOaBqhF7bjeU17WjMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJaSY44y97+uGXRWQyDdDcEMsb2/o+zNYtg15U8lY0kgAiBvHRkPYAuOXRM8\nbTgVxF7hyZRd5v7FSe23oNu3kG073Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc855", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `855` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVN1mzmdpLUHhZIzbItAq8aOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NjVhNTBlLTQ4ZmItNDgwZS04N2VhLTA4YjM5MmY3ZDU1ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM0OTNjMDUtMWFi\nZC00YTU2LTg3YzEtYjdlMjVlNjY4ZWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdSoNo7BTW6MfrKZldQkZbaRqgOZRs8TU2G2zhYKGzhjFfMoWx2IPtoW6Aa73\nrgWVKEMBcIP4xrjMiYkcZ6Ae3aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsjkZaLR8+iBzu1phVY31mimR28cwHwYDVR0j\nBBgwFoAUw842n+ntL6WFIWjbplzWZ7PV9ckwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD6z8TqHbG7J7srVJP5bXmmovzIp/c5+w9fv06/nqTamgIhAN1anycujOYk\nWMhP2dIQLTMf8RLHVfJt6w7bs28iw9av\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdGf+eEb06qYZXlFvAWHA9q9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODY1YTUwZS00OGZiLTQ4MGUtODdlYS0wOGIzOTJmN2Q1NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSPAz0ea5oqA+a7X+W43eKdrAshQJnGgs4dt79gWKEijjb\nj372P83f3jSYPZCgZbtBfFwo93DCygl2UbteBTWbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw842n+ntL6WFIWjbplzWZ7PV\n9ckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUsMReY5ykzFVOeDapaoOYMYCBfuiR/IO/e4DEBTRaUgCIQDZnUxNrwsu\nTQqH7YfZbDolbquYxQCOvdYUn6om/eSDGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISARvyDf6sgf7S3bO7cHuNPzGUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM0OTNjMDUtMWFiZC00YTU2LTg3YzEtYjdlMjVlNjY4ZWRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUyZTVkM2Mw\nLTA0NDQtNDZlMy04NDAyLTNmZTQwMmIxNTQ5YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN8I2Bhb9XgXaGwUygKn+39IJh3fqaiJzShmNCyt91uq2B5oyxhIxMIE\n6PmEz1BJPgDtGPj3t9w6EG7iXEl+ktijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLI5GWi0\nfPogc7taYVWN9ZopkdvHMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgEN5Qs2iir76gpQsJxKQlsQM0oRE9l3u6sYSmh7x22cUCIBS8gkIakoN/CGiw\ndh305D9P4yFVTPSXUxR+2ZScfVGc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc856", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `856` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAXE97BWUq+8dw0unNhna32a8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3MWU5NDc0LWVhMDctNGZjYS1iMWI3LTQ0ZDQ4NjdjNmY2ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFhODg2MDctMzQ5\nYS00NjI4LWI0ZTctYWMzMWRmZDNjZDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhqi53yVcvOr7NS15RpS75w/KagEhHHqTtEF4w1Z2r1j/K0DnIjVtMw77+Mmv\nXzJv5J2laMn0Tpg/NdHY2ivOMaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Vt9HpQAb8dgjNw+QjXuHblh4z4wHwYDVR0j\nBBgwFoAUcc7pPodKMUhmHvSKXfloLaq2zJYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAOiPR0twHsbnh6dsIZc9CD7LnXUtCvFmIcp+2MfPHd7wIgRoIazxb5P1IQ\n+4/SZURjvLy2ZWlG2aepSoFT7SPxLH0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaWyV2tkeJ1L7ZtYHb7bry1uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzFlOTQ3NC1lYTA3LTRmY2EtYjFiNy00NGQ0ODY3YzZmNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT910174uelX+iD7dTvP04WFcvyuDBA1gK7B9rh/MEGPPpF\nSusF6zbrDRTqqXp4jpj0u+ZLrmFA3gaAoXzPd0Ako2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcc7pPodKMUhmHvSKXfloLaq2\nzJYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOzHqsxqZYKcyOu3FZ3mR8+9SurprR9gh0iS/UIK2dGDAiEAhYO3Kox5\nr+7CF8dR/AOgbMVq82peNkrVpXkb++s7KFA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAT+6R/5cgVXW0FRgrPMcgUZYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFhODg2MDctMzQ5YS00NjI4LWI0ZTctYWMzMWRmZDNjZDNkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhjOTVhZDM0\nLTY1ZTQtNGU2OS04YTVjLTUwYWFjYTg2MjY3YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOkynH3dS9D01e139zgjYEOBORZxnFfesBgwuLn1FpfclvyWkAQx15w7\nDcN5aktLIsA4k5SgExAP9sgJxrn//YijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNlbfR6U\nAG/HYIzcPkI17h25YeM+MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAIvvbl5SfMmv+u1gsgwndV4AQDgke2NFr6hKWWUi2Q+lAiA0G+hDTPzmub2W\n7M8pXWWhkFdVlxpkRSocWHWyDTLxNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc857", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `857` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZ+QqQOkdfkIZ9aC5hrs90LWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlOGIwYWIwLWViZTktNGE4NS1hNjBhLTYyNGFhNThlMGJhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhmNjM0MTktZWU1\nNS00MjEyLTkwZmYtZmJkMjdjY2FiNTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFdURUjBVaMOjmk/rYQ4mihwdk1S5xi6zkNKMsmeVXB03rOrlt/D5ilTxlr92\n6ioHFMQC81AwPfbR8kRkNfpq4aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKg9lkMFi6KYgQ7r5EB9BSXWUwzEwHwYDVR0j\nBBgwFoAUz5RvEbR9b5Bvg+SqM8PqZh0E120wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA3lwfnc/o8YGQcUm9P658puH2QHF25a6UjiBclF0Y\ng7oCIH9e7oRWhAVKKBLTfOTfG2FKmmpRQxJCIIhjGcsbNzT4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAecKRVFN855c4VE/FLXAl8aRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZThiMGFiMC1lYmU5LTRhODUtYTYwYS02MjRhYTU4ZTBiYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNONrzPoNpNLIWeL51jqWWmoaAY4kq876Pdqs79ETr2dlH\nS0z74nveVXeVsDnuTbktR1TJuqSBkJgV2M+4V06ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz5RvEbR9b5Bvg+SqM8PqZh0E\n120wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZL5NMKDy9CP+wEL0YoAuE8mRVM+5yH/0/srFuApAtesCIQDkhZtjLCgX\nv9s45QiJtmB4cPuYZHBvinjcpDNnnHAkrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAW7/kzHOgihMGnUA9r924e4OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhmNjM0MTktZWU1NS00MjEyLTkwZmYtZmJkMjdjY2FiNTZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdkNjQzNGVk\nLTNiZmUtNDY4Yi04MTNlLTY0OTU2MDhmN2Q1YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIrO/S68X+wL4mVm8jremRrCafn77ur40IzTSrBmILvzXSSpIUhIQ7LJ\nTPVef+il2iq+1pys7L3RynE8O2BUPsijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCoPZZDB\nYuimIEO6+RAfQUl1lMMxMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAPUQi9xToDYUKs9G/lzBxIc0mMekSTEde5VAx1s6tjdBAiEAxrhx1qt2M79N\nH+DHm9n861tbDV+LoPtUqoVlciGGv+U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc858", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `858` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAfHH9TQFzD1AB7J7RjI935hiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhODAzNTkzLTJjMGUtNDU3OS1hODgzLTdkOGQ1OWJiMWYyMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWU5YmM2YjEtZTgw\nYS00MTdlLTkwMzQtNzc0MWJkYWIxZDZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELbH1zGtCVav1IgVjlZ1k3tvsgLlH0pMWbAEIkzFDMmv8h0j9lvyxuEP7A2mg\nSH3uV3Y+ygUrZTOB7sa85GAiVaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrsQXNw6jAggJtuqAVscIYyQwzYIwHwYDVR0j\nBBgwFoAUdTyczr4YtwtcG1s48W+l+y38XhMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBFI6/W6M4hy5F+S7Nzu5VX+d4N8Q+CoFIHc82m1dUS\nEwIgfX1p0iJL00tXBUy/iGeY2XxPGslb8+/N/kMp6IqrkoE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVHOBbqgwop89kjdgeUQqtyIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTgwMzU5My0yYzBlLTQ1NzktYTg4My03ZDhkNTliYjFmMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBukI4GmDil2iXBO2Xd2JZVCNCe9Y5qLhhCQVvdqG249+s\ndSIFHnrzy+Hvj8i2e1ih8zT+j2BgujG67IUoB/xho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdTyczr4YtwtcG1s48W+l+y38\nXhMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeSfv3cgrKzyFaDS9PqiM5+/OYdmrvoRDDDXJXQdRqEECIQCyx22ykhnP\nT99T2nkK8P4ZBUiAiSrupgZlzC8+CgX4OA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAWgNJyAbcysI89mRuGMZHEcBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWU5YmM2YjEtZTgwYS00MTdlLTkwMzQtNzc0MWJkYWIxZDZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMyMjdiYjNl\nLWNjMGUtNDJmYy05ZTllLThkMDM1Y2QxOWY4MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDpC1gRv/IfD8lLeUATdXAyXoUPSnuzDtn3hn2Hz5wtg1IKv1xx4bPE1\nuRPgdhNGu0roXDQDGtYHlzVVoE/ig1ujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK7EFzcO\nowIICbbqgFbHCGMkMM2CMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAKvNd5GOL7Wq+QOunc3kMYp0jYbUePcN5ZcATQ+MK2Q2AiEAtv4VogKir9Ik\nptmI2d+0oE2K2kVEuKqnaQGy5PAcgQQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc859", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `859` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAe21gp9FySQu57VKoZSBU53JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYTU5MDAwLTZmOTYtNGNlNC1iYzMzLTc3MmQ1MTRmMmQxNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ3NjJjZjAtZjQ5\nMS00MWFiLWI3MjUtYTBjM2NmMTY0ZGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6w6v1c27e7iCgT7Nd1lg+lnbIM1gDjgWNh2XRj7DtA8ToX24BlnMn521yLh+\nT8eGBbavPvYGcY3ARp/Ji7iSz6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPdl1qDlmxCoKGzUDP9+r9BhxU5QwHwYDVR0j\nBBgwFoAUvPVXkNjHQeR+STkiKnDYOyNuA3wwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAzl7HwHXWQZe5499cu8oTM75eBF3FBTjjqWM0pvUdHdgIgA3MS\nw0qjbiDOKCFkZsT8cSb7mrHmlQaDQH8fJr5o7Xg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUJ+VE0Enh56p4bdK8mAAHEYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmE1OTAwMC02Zjk2LTRjZTQtYmMzMy03NzJkNTE0ZjJkMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ24jUoDrOw0J0eQKgXXQAzCJ3P+7DszNLoDCZW8rYAyPuW\n016GeCrIUZFwX9TI6dqAOoFglkEIlYtId1DucXS9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvPVXkNjHQeR+STkiKnDYOyNu\nA3wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOEI20Ri59AxQXBDlIqc70vsmIaNg/eTtK49gkT3gESJAiARCDU8Wcfs\nXJlB8QafzyUn5g9H9tAhf32Ph0rn2AbddA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAf23GWWd8ioQ9dIVmr04z5g6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ3NjJjZjAtZjQ5MS00MWFiLWI3MjUtYTBjM2NmMTY0ZGU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE3N2UxNTIz\nLTFmYzItNGY4ZC1iMDY2LTI1NmRkZGQzMmY4ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKXfyUFojqfNeYb/IeJN3MIb3FL4erYFHar3/i/hCLHq0IwyYY4T0x4N\n9+lyWnGWsDYY9A4X5bWprXemozKx80qjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD3Zdag5\nZsQqChs1Az/fq/QYcVOUMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgGQdxsil7PrZ3yiPrTWrl/V2eJZi9zK7bK1r27dQ6/wsCIQChzfTYjH3mZ41N\nsTTMYADUjQnnWrLWfMjTNOup7XmNZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc860", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `860` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAbN47RXpYHMD3BKO6dt7YzRZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMTU1ODMxLWQ0NzctNDZiZS05Nzc1LTM5OTYwMTNkZTEyNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU2YWUzZmQtMTU4\nYi00MjE2LTkzZmMtODVmMjJkZGM0YmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcg3bADHYxfZKJqW0aLXKvp0MK5VqSohqVyH+W3BI+u19PHqxX5LnXC1e7CQu\ncM3n57dSGS7D9PlY210rVWX/TaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTIbjdFSdbQVuNmu3Oyt4bwKMHKMwHwYDVR0j\nBBgwFoAUUojBDm4O2CLoCQOh+AvPVNyFoX4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAz6hZXhV7LAc6H5s90Kl2bYSBPlyxVAeJ\nJ02MxxVqnZoCIQDoZPLaNV70Fv9kaG5DzsJH6lw95posxr2HaPTZRea8iA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcLMMkIMvkZf75q8poxuxu2QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTE1NTgzMS1kNDc3LTQ2YmUtOTc3NS0zOTk2MDEzZGUxMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV4NdaCgYCWLk+io8Q16Y+T15PPLtthluYoz7/yBhQEMEb\nguPcBon/3l5R7reDTI2Z3+JZS4zBThiS641tS1/Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUojBDm4O2CLoCQOh+AvPVNyF\noX4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC8B27YRJkllsrr34EgFbP+uXnqLi+canVoxU15nOVfgCIQDXorrznHaz\nG+2t7C7tUV5JZ04GyEcW6gVaEoFnZn3N1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAQFhGACWqaPuvt0iW8SzVRpeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU2YWUzZmQtMTU4Yi00MjE2LTkzZmMtODVmMjJkZGM0YmVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI3NzBmMWVh\nLTI0NmQtNGJmNS1hZWIwLWI3NTQwYjQzYjE0NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI5x5vbRRDcsBT1reN/84QBSekN1W9uOuuhzDz7IPmVfNhzMrlKtBsLr\ntm5Elf3npIzM+y591L8z5WmTZ3YNbKajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEyG43RU\nnW0FbjZrtzsreG8CjByjMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAMcP0KNaM7EUWSRz8qR6aNRHu5i3NZa3Ty8Nf96mTNnWAiEA/TFR5O+sXoj0\n9/tJJBRiMSLkZZ/zT41jhf7B4bKrtWg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc861", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `861` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAW3nXzYyjltLeWXGXrN/80H7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmNzM1ODRiLTc5ODUtNGI2MS04YzYyLTBhYThkYTFkZjgxYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFhYjFhYWUtMGI4\nOC00OGVjLWE3YjUtZWYxY2MwNzIxOWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVCe4lfjyO0WSgVKf1nAJtagjdd3uM1QbryGQ5lXJnt3QkLuIlisxGja70Lgi\n937vB933e7AqzSF1mzsojEccPKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEd9BeT3TYWWpG73wlkmWjM1QVJ8wHwYDVR0j\nBBgwFoAUG9ZWGSTTLj4nan4Ry/eKVbyCdXEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA0ow7qNUDfBEiX+6MCKW3p3jujykBaOSB\nalYDAFeDhQkCIAQc0pX2h+3Ud46OBWvaYwy6xElno2W3KsmXYYmbSd0g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYhY8y3SWX1SEGES+VrndQBRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjczNTg0Yi03OTg1LTRiNjEtOGM2Mi0wYWE4ZGExZGY4MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJ2/ghBKaGAbroT/fslgdA6Oi41SIan1E5HEnfnK3Kem3h\nxa/h06QrruYDta2dF2w16pulrug5OlbdltM9fdZZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG9ZWGSTTLj4nan4Ry/eKVbyC\ndXEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKI9V2J3RFgq1FKVzpJFBy80CtT0w/EFwbc97HWZ/YM6AiABAbNmfloy\n4Tjfg7UkraPZyLnsDN3+CfteRkXpYF4ypg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAQmcBzt9X/P0mySJ0lCELREwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFhYjFhYWUtMGI4OC00OGVjLWE3YjUtZWYxY2MwNzIxOWFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRjNWI2MjZl\nLTBhZGEtNDcwOS04ZGU1LTU1YWQxMTlhOGYzYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDEPfKtgWSAxqFzxxcT+2FYJz6dKF8kAc+RpsV0QEA1CTCkxtZ94rK6Z\nGNFcKM64n/JyS3fmd2g8xlZtrG5G3iCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBHfQXk9\n02FlqRu98JZJlozNUFSfMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgXVnYg5E/Z45QkrjBmiOV6vx6tgUQEwJm5RKPZPs0yaYCICo8hm/ZTLGPX4Cj\nMWIjxfd7AhFjlY5kbQwE1611c0sm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc862", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `862` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbNtmq2/YPW/Ke9vD2tyc5seMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3MDdlY2RkLTBhNDMtNDI1Zi1iMDhiLTMwNTcxYjYwN2ZiNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ3MTAyMGUtYTNj\nNy00ODY0LWJjNWItMDZhNGU2NGM2YTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhNMYzvo3ckXZReMYfsJUZQHooiY2cTZaAYbxJsAtB71Ra+ocZkZzQSInBWml\nysuU9lB6MZQxF1677ZeWLAEgEKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULgDTvXux3QGgDtyuueJBnlVbrSEwHwYDVR0j\nBBgwFoAUx7O4BhXb2PV0ooqTOp28i4hWVT4wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBH2iKRDFTWz5nG\nEO93eQsifbB+poNnBgOrSGSKxEHtPwIhAPFlQj6i61vFT9qBGFCCubLZS8zjgcMa\nsu3aSZS8fycA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWlyqwT4jWsqVS1wrCJP+hi5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzA3ZWNkZC0wYTQzLTQyNWYtYjA4Yi0zMDU3MWI2MDdmYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfK4xDAq2ScvYz9ZIK4TPG5AxhgxmxllrRfFSVT0Nc8ERK\nyIlZlvr3fJtcgdB86ZyoLdeHszyAnL2/ZwKUxrJso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx7O4BhXb2PV0ooqTOp28i4hW\nVT4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ9UIX1Ut+n/ejjcfSPR6VbjIiwmv8q0cxT2NeVpEr7wCID4VRBDj0Fxo\n5pQ0bZd8z4Oyi6EX+JVqJN2/e9q4cUJN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAYfhBP607Vncn3nYi3d9DqtFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ3MTAyMGUtYTNjNy00ODY0LWJjNWItMDZhNGU2NGM2YTQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGExNjJmMDRi\nLWY2ZDctNDQxOS04Y2I0LTM2ZTdhYWU0ZWMzNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFql1lqFD6PpSQ1rU4PGO2zmq8T0FugwmLRey6pDWmDout6PnXhOJVn4\nsYq0WOGgj2rQjyVK7vXxt58KRtoAv/yjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC4A0717\nsd0BoA7crrniQZ5VW60hMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgf7A5dnMRveI7Asnc/6fbU4oazZEoTpFF2hfYqi2FoBcCIQDKSqzbmJSpfNiO\npIvkS0tdGmd4ybcc73Ai3vbFzgIPEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc863", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `863` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAf/wvPT34vWDp2cmpd9S+CTyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyNThkMmMzLWQyZjQtNGI3Ny04YmFmLTY1OTQ1OTg2YTM5ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI3ZjNmMDQtODA4\nZS00ZDNmLWE5ODMtMjhiMDNkNWYwN2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsckusfMFTuMGSEnYKz3UghtzE1iReng4neMBU4f6kluIAy72PREUrph0EpGC\n8f7THOVajF8uAMSxp7XZbAOq86OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJMcpme1LLpH56x1eCS1fuDctYhIwHwYDVR0j\nBBgwFoAUH9uUBwCaj9KUWeb8Uger22cs2PEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDADN4gEiAe3cmLmTgLbszCqdmjlUysUEA7r9Phx+7pogIgCi3y6mFo+p+b\nKCwqTLHzt+lswyw/xOvpjZyt2iCz+GE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdMbd+KOy1Kwdmy8i7i4oh7FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjU4ZDJjMy1kMmY0LTRiNzctOGJhZi02NTk0NTk4NmEzOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZ8HSQzR8MyGjX7WzH+wTdAiJE+MdqHzdmY09PK5WzRgD6\nlNIFVFfu5BxvZRXZbULGHIkkkPnBg9Q+cJjCGr+8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH9uUBwCaj9KUWeb8Uger22cs\n2PEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKMn2EO5DLQshKhCiLc+0YQ+Ar7fPT06eZQ4IJvZBZQoCICH0xDXfxTTA\nutx21t/7Vk2UuYIJL3cNeToR4PW6wcYA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAXBWQxv/zN/tg+Z4KrO9Ko8KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI3ZjNmMDQtODA4ZS00ZDNmLWE5ODMtMjhiMDNkNWYwN2M4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg0MTg4M2Mz\nLWY4ODEtNGNhNC05MjdmLWZkNzRmYjgzN2I3NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAPICEyrn09vsJJuLig29k9GjQHSaDjmCzIzkc1bBsK2fLqJqzFGrqnp\nXqUL05jsa5Lu4Usgvy2wJAFt/Zh7Td2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCTHKZnt\nSy6R+esdXgktX7g3LWISMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAK+BY+9PIJIard2whjLQ4u6mU1ud6yxNVX5DKd6kmhH/AiAji3HRi84T9UJq\n4xmd8qQcC3ipQLmME7pq2XZPVdOjWg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc864", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `864` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeRIT1jmTLAiusNJ13/nGwiLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNzBhNzFjLTBmNDktNDdjNC05MTAzLTFiNzAzZWVhYjQ5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc4NGU4ZWQtYjA5\nNi00NjU3LWFiNGQtMWQ3ODE5MWIyMjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyoH1MFe79x3FpCVUOxiSpjN9ezTcfzxm07eEhj610nUqxeOEtxyL3RXzLLs0\n7RR3BxBHjBUgQ5VDWlGYa+EkuaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTQfdR/FrVS3pDDfZnmdNtQ0Sz2IwHwYDVR0j\nBBgwFoAUL710VeQwdN3OTWackmCWVysq7PcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICLhInzM7mN59XhP3nIJ9Ys0gUdpOAerojsOHCBbVaGzAiB35cqRR1htHzUe\n+D7t81tDaxya2NTNuNli2jsUqAuxqw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdTyBH96VOs4vz8P2oDIAA5zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjcwYTcxYy0wZjQ5LTQ3YzQtOTEwMy0xYjcwM2VlYWI0OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAzoe0mdseL2IHjwZISq2UZz+xyISV1qGmAp/RePAGaZk3\nUgYEhj2zMKXr5srZyhYnC35ElzE8wJhw5Y0L1qUXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL710VeQwdN3OTWackmCWVysq\n7PcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAa48v2TCKQamAXXb/wflAufp7kmbnzcC8gU8sb2kYpoCIQD1mjR44sR1\nGIUsB83w4kIkEu+N/ZJy9fekRECzG8YtHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAcCgRL7+LCPKoWJNoOrQcdE1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc4NGU4ZWQtYjA5Ni00NjU3LWFiNGQtMWQ3ODE5MWIyMjliMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk1YjMxZjBl\nLTY3OWMtNDFjMS05NDU0LWZhOTU2MGU4YmYyMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCVP6VHPiMoMUaal5gIJ05eIjdl9G1JoEaHS02pg8AFSatCdaWDD+N3m\no9iad8YbiKsbICaFdHGt2SSbEW/5VhmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE0H3Ufx\na1Ut6Qw32Z5nTbUNEs9iMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgP9uLORSfTHetFI/CCYDqaiiWPaKKpB+8DxfXykXn6IYCIQDENdk+Hni8Sz9/\n83F9I4WlGmnraPLmPG+VTqW3PZmCpQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc865", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `865` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAarSSjMeSUbacDrEIbpjC+2VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MmI4YjExLTg1Y2QtNDJkMy1iODk0LWMzYjdkNmU2NmYwNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY1YTM0NjQtODA0\nOC00M2FjLWI2ZmItNTM4ZWUxMWE0OWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwY2ygUlQtgHd/1AKMOYOlKUbxMPEdjYrcHj+DJJY8zEA1197+k1ga0vUefzP\nDi6tDnK9PusiYTX4EIbmKMN+VqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9CrF4FHbvE+cmRAHga/uWRr9bHEwHwYDVR0j\nBBgwFoAUd9368dciJtB3Kfnc3HTksDXUcB4wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAh7+nKJFOU9yLLxZ2JYLaN1KioAuQN5akzU0NHbXloiwCICeT6wmiNCZu\nDejVVJatxVeJR0t1wtBJQOY5+MnxacxT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYh0ZgJemEFNa0kD51Ebp9eEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDJiOGIxMS04NWNkLTQyZDMtYjg5NC1jM2I3ZDZlNjZmMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZNQzvFb3Chdo1ZxhRGXjIBX1229gHp/KWFYQRDdZ/sA+V\nQRUWzLdC26WhzieOsnNf8aPvKYxSs74TZ67zaoE+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd9368dciJtB3Kfnc3HTksDXU\ncB4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZNO3tcPA+HjP1HeRNRc3G5v7FC15ADh8l83298JisuYCIDB6BGKBhpbd\nCbBaY69OFnVmqeiENGZDN460ZPpeOhZi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAXDqO4qwW6fYUhAHDYF3FHxTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY1YTM0NjQtODA0OC00M2FjLWI2ZmItNTM4ZWUxMWE0OWE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcxYTU4YjU0\nLWI0N2UtNDRjOS1hZWE5LWQ5NzM5YmJhODZkMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ7xNXGzoOIZWUbENSYlXMJ5g9bh+MFJb1yVUbikAycC+CeQ4fQmOsNQ\nK13ON2ewhWJYKnFcjmXqXGesnqCSElWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPQqxeBR\n27xPnJkQB4Gv7lka/WxxMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgPBGHOKCjkk+GC+i/4UYoQJALYtUEgi9h88da8ud/D+gCICC8JcZLWzjhlGvQ\npdLz71PPRbft8fh49ikoAcvC5XcA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc866", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `866` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAd0GJTO429sIp+hbb+rvW4U2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMzMzNGJlLTdhMWUtNDhlNC05NmY3LTljNTFhZjVmYzg1MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGM4MWY3MjUtMjJj\nNy00YTc0LWJkYWEtYjE1NmY5MDZlMTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEixpPn5VThaXyrVjNhbpggVHwdlbbpflWWSCYMrGn1FRF3yqbZbf2TrPu+7MG\n/LoNBP3IAAlV0t/jRz+0aFmgEaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgSZuzhqsnOt/owWm6wKVIak72HAwHwYDVR0j\nBBgwFoAU++jKAptSpwZRJpNRlD6dmDixtB8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA7ZZTHnKAHKWNT5wO0soihrO5hc4M/cK3ZUPOqYEC\n65UCIFYIP54ZKoLixThC7UpD+RDmol7SYXUzf+57XuNNfXHL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYzS+hVFdZRbLbblDrEBgNKFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTMzMzRiZS03YTFlLTQ4ZTQtOTZmNy05YzUxYWY1ZmM4NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7f9e/R4jtt8O/2TwlEL8+uPsa3omo9GuYm0pPwQJcAuGk\naLMfbgUAewuL3ST4XMNg6Th1qjXkfEPu59keT5Ezo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU++jKAptSpwZRJpNRlD6dmDix\ntB8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPnKWhKSqiMHdb202PGldkyHjyhKPl6XEvP7J1m8w6JLAiAhor1TjuWm\nurHPInJkcrALGWoc/ul8pSicZjkJMzYckQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAQObs4mNWFluvRbY/JXcPvWhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGM4MWY3MjUtMjJjNy00YTc0LWJkYWEtYjE1NmY5MDZlMTgyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ1Yjg5MmQ3\nLWIxMmUtNDQxYS04OWY1LTAxOTQ1NzYyNzcwYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ2iaE0du2YZrCHAq4SvvVCnWdpBeiX9CIFAjtj+aEesOt2gMOFgyvad\nEOci9rK1Gq59c636bL/7ToK4kWuVgG6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIEmbs4a\nrJzrf6MFpusClSGpO9hwMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgDjwuSgkeP7UU28LCYpQZRQ9DvSDaVRceiCkY7wnVu48CIFNHOqVPpC9QlZpU\n7tJD9cwEFDxTQIjN0mrieeXHimVF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc867", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `867` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAQEh6L23P3EO9hOt07ZrGyKnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZDIwOTcyLWMzZTgtNGMyOC04NzdhLWUyM2I5MjUyZDRmMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJlYjg1YjktZmEy\nNi00NDFmLTgxYjYtMDEzNzNkNjY5ZDRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKWhisAVbB2+ix9Q9E0NTtouG1ij7L86hDqAJNku5ZZxOoWbhUc9E3LF/s6sU\n3y2PTMdzzQc4TEJB4JM/dgvaRaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEvlA7wZF6nhNP61WEqiAGWJuyZ4wHwYDVR0j\nBBgwFoAU4r5QtdovDbHl2qlzUG88bG5ZohcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAi+z1nBRjeHsIYNiNvy9c0j3fvq4vbm9kFSVhu5u1\nWs4CIQCBwhtRi75Ctxi9pVAQBlNmI9qLJ8pUWTR4c0eEW7Qq4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZZaatCYEHFVBLJl2ApNOCC7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGQyMDk3Mi1jM2U4LTRjMjgtODc3YS1lMjNiOTI1MmQ0ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHalZ1QGreQMF0yoR6e4Cl3n1tS1phyboXI9iMarbizCTa\n269GCgjj4m63FM0FsHxjo3uk3xGxX5IoveAWzA/Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4r5QtdovDbHl2qlzUG88bG5Z\nohcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbPSwbVzlscTa6o9rGkfIo3UqTeo4td8Q0oMwIydwvDUCIQDK9JleZWCN\nrzZAiEiBvRatOgze2/duvNLFsjJjwLYaOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAdyPBHprowYPt0Z0bn+5KLf/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJlYjg1YjktZmEyNi00NDFmLTgxYjYtMDEzNzNkNjY5ZDRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVmMmQ5ZDQ3\nLTlmZjQtNGMzZi1iNDc3LWNmYjBhYjdjNjAyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGF0nn5CAA92RUyIlDwXEFQzNeukprvzfWCnJ8c+aStikyN7GGxaSzsA\nCnaG0f/hYbuVOZRglp0+5hcSJaEifJSjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBL5QO8G\nRep4TT+tVhKogBlibsmeMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAL0f9iLw5p9wmEkjJjIG+b+hGsaWHyd1tCzsCVGV4VY9AiEArD9jNknnyP74\n3Cta+J4lcFJgGbPKvFlzOybHhJKJT+0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc868", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `868` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISARf6vS/ZLBndTdNRT+DLVuyyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExMWNlNjM3LTliMmEtNDc4NC1iMDE3LThjODA4ZDE0MGIxODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNiZGUwNWUtYTk4\nZC00MDljLWI3YWEtMWQzYThhM2VlODRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPgXEbMAtZLOSK+HDITK3aZQA7VDnQDCnsiMMYeQKZ52aqvfQKxs1AiNyQqsJ\n/jWkCYfi83OC/EgIiMr6rz9jc6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzLJ4dFomPpc8lz94LTv/V1Sq8ywwHwYDVR0j\nBBgwFoAUGBBzpruqfhVlsUSlA9DxQfyxEVwwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAl0Xufs0tQT1yd2s43SMKVTsC1SCaIIMcZBHiktymFR8CIQCi\nQwZiSRy5evce0lTjTXM4OlDde3XVIgIqZUuauee/Zg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVBOSQApKGRQvFWQYIAGCZlRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTFjZTYzNy05YjJhLTQ3ODQtYjAxNy04YzgwOGQxNDBiMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1j4KZPks17zQH4Q3k+SFiLg0Xgf0B+VAf269v3WTIRSmr\nZdm0iDtLWGbME8ApvTSyDJixgdJk+04Cmd2mBnuso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGBBzpruqfhVlsUSlA9DxQfyx\nEVwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJrfAZ87TKTQ8MxlVrPFlQB+iD8Tv3YctlgXc9z7jS9qAiBWZpi46brS\n7L+F5zn1xw/5Rr4xkScH63lWPLVgOW91Vg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAfRHiqj2w+FJYxLloBHaO5t7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNiZGUwNWUtYTk4ZC00MDljLWI3YWEtMWQzYThhM2VlODRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ3Y2MyNTk1\nLTk1NDAtNGNhYy1iOTFlLTA3NTZhMWFjMzZlNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIPJ/ZQ7XpHQjCcFfxzRtJZPyl1sO0ILR+9FyHoS2RigoNFjx9T7r+8a\nd6ZOdCtKLi9OzW282hh+8fbDSw+HCLyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMyyeHRa\nJj6XPJc/eC07/1dUqvMsMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAPiF3u4lPuzWx6JsPHYKzrP6jpYptA4Rog4BH+wWu5NsAiACEJfqP9hVWp1W\nK1m1KN5F1Pg9IMBLKWTGC1ilXdrNzg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc869", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `869` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAULXfZyKNcl81tEFKxs7fXMFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmYWFkNTM5LTA0N2QtNDk1Yi1hYWM5LWJlNTgyNGU1NWU0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA3ODBkZTYtMTdm\nNi00MTZlLWIyY2UtYTYyZGY5NzBjYjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmmv9nt05yUruYGw3dKuJDf8Ih6NoJ3vT0YgOYM0yncvGazuBmcbqUB0ivGWh\nLeLTaLltWFEEQXzTbPH+5Ml7dqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc2qpSJJHwqPrLygzy4B0N6W2n9swHwYDVR0j\nBBgwFoAU0vW4q/VrzDeSjUCE2oaT1QLEFzgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAygET8IGwrydWIkK0ZGGilYAVNaVL86ekM\ngqT4JUdUgQIhAJNkxoS8P+3rUQeXLbD0L0GRsDSvVBmHICmgd//PjjF8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfYBctQCQ2ZL/8lE0c8ShZHgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmFhZDUzOS0wNDdkLTQ5NWItYWFjOS1iZTU4MjRlNTVlNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtbcmThPaSvY08PfEqYtTfPrFUcb5ejkXagiMY//4dNWDk\n4b2roei0j2oKn0DtyjXyv3dFnDiNbCFc6YpUMpE2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0vW4q/VrzDeSjUCE2oaT1QLE\nFzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIge9iMUSTbaITmLXAZxjZpPzvYvU/4UzLBVOTaSrrr+swCIQDBmccKW9zE\njPzO21+E4ky1GDxcKdAkKz1Ik/MdpfIDtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAVM8rdOBcETf9L2GKiiRx0XoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA3ODBkZTYtMTdmNi00MTZlLWIyY2UtYTYyZGY5NzBjYjYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNkYzdhNjI1\nLTc2ZDAtNGNjMi1hYjE2LWNlOTNlZmQ3YjJmZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMsc2wGLFHd/gR76TSvUMM7Opxon437+nT2gb/ZknWC5liC9LWf8savQ\nMs6zs/h53SPYIIZ39S4SORcc0xqdzL6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHNqqUiS\nR8Kj6y8oM8uAdDeltp/bMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgVibxba1wWHfcr61e2UFi2dMmUt/JKdRuUmWsGPOCo8QCIQDR1Jzmcq9BlWNz\norLCN7nyb7PnPt0FUNNrqPwbYtF2rw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc870", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `870` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAS55B6wbRMA5J1TdkW5dKku9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5MWQ2OGUyLTYwMGMtNGY0MC05YzNlLTllZjQwYzE1ZmYwNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODhiMTUxMDctNTYw\nMC00ZmRiLThhMTktYTVkNWYwZjE5MzFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPPxkCnEC/+zJgUmQg+sHmS2HC2akjJrakch18Rh861p+JAZgn9k5/yxhMkNs\nvrTfpfIDEGVQk1X2ZNe52ERt+KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWx/svw+GGdAQk5C+XHzGgzlpi3IwHwYDVR0j\nBBgwFoAUsUjX7N3UbRFKX2I5UkLbDQTp3ncwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBfK7xzJVl0mMtNsWBH4P6JPbabOO3W/qvq\nTBI5KBbnfQIgSZjDP33N5b3E/R0EeQd6R4o4aWOejmbefg0flu1lqKM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbnWilwAy7/7bFraj6j5RX9JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTFkNjhlMi02MDBjLTRmNDAtOWMzZS05ZWY0MGMxNWZmMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8bDsOx9iTExFjGalWqmvyaVcxRffJCpd/I29hnzbQTIlZ\n+BLzO1YOGvQpBCh0W3wqsNSQqGZbqYKEnZl9hIy/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsUjX7N3UbRFKX2I5UkLbDQTp\n3ncwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKm5+HxsgRdwKSNd2YpieUUY7gycKZFsuukwSB6x9MQIAiEAvjaMbhqG\nVp08RoZ7jOk2ByPpniH4KwyOnGxTfAphTvA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAXh/QAaZp70QWjMVMLovNaERMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODhiMTUxMDctNTYwMC00ZmRiLThhMTktYTVkNWYwZjE5MzFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVhMTE1NTVh\nLTcwN2MtNDM1Zi1iNzI2LTZmYzA3NzY5MzNiOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN6hgbw+gF1HOZC5SyiJJ6yHPhFHD6FkkSGQtbK1me/KHNRa79LX7l9H\n+17yvnu/NzCUeNZ/0om9MyVG5Y8XZIGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFsf7L8P\nhhnQEJOQvlx8xoM5aYtyMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgR/UrT9Wz2eH4+iWGrAiZiWgAmGT3dpn6bB36r7+LucoCIFM31qdUC31NG/C/\nD/aUsi3isvXG5gT4KvQ7o96AAB3v\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc871", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `871` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISARq+Ltq1RJfI3TxTPhlbaOElMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ZjgyMDA3LWM1ODQtNGU2OC04OTllLTQ4ZDExNWI5NDg3YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2IxYWZjNzEtNDdl\nZi00MGNhLTgwMTQtMTY2OWEwYTMzZWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIZsv8b0A0ZjSqgBbzNHW8jqbCj2yiDIouQyKwEOSN8MTmNtfe/e9g6tFfcnA\nzNOw84X4uwcInMSKyxzGW0dQfaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa7kLSdmiJ2Z8O+vdJp9OFqWG8OMwHwYDVR0j\nBBgwFoAUAMNVD5q2CnMzzojB7rJPOQss0hQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDY1av9tp+ka2cyy+B8zZjZhE8p\nk+1EFlhi0GcH8CiEGgIgKXKw3Xky3wbozmgEgUvX5UBcNcdW1KCEJQA+OYfVmTY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdNb+l1k/RMj4hCai2A9pYZUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWY4MjAwNy1jNTg0LTRlNjgtODk5ZS00OGQxMTViOTQ4N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLk2VKxy1I3bAO6Wf4y8AN7mPx3ble9A9Ws1prz+z9/EXT\nXrcv1/EZsDumUeeQK391xmVrlawUgE/1uLVYqT2bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAMNVD5q2CnMzzojB7rJPOQss\n0hQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOTXnRfl6cjMRqSDVe9/N0a4XU027BR03mIqX/wUbptDAiBP60pRGHeh\nfzoAAmWE8z9y5JG5u0Y9o1J/ibVyRfIxpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAS/KHsOomBmP7wchIDPygUfHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2IxYWZjNzEtNDdlZi00MGNhLTgwMTQtMTY2OWEwYTMzZWVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUzM2RkN2U5\nLWU4MjQtNGI1MC1hNjM3LTE1NTFlMjkxYzM1YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHXQjf2t+sIBM+P6ckohQZJMIkoCvzqIUitKCSwqNGx8Ut4MtZBj+R1y\nyi4AouavyzB+juwe5ja+Q73TqVds6UqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGu5C0nZ\noidmfDvr3SafThalhvDjMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJB8Af3p7bXqwHo9knABFlvNHh+80m/2P29NH1CRgN0aAiB+SwftaC8I2avr\nOOmWx4PP9+1Q7/78APb2WQVwiCxljA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc872", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `872` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAWyWY7amF+P97Gymiqzcz6gfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1ZTFmZmM3LWI1MjAtNDYzMS04YWZhLTFiYzA1ZmZlMzRkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFiMWI5NTQtZmNh\nMi00ODdkLWI2MDktNTM4ODA3OTQ0MTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaGvQo/NeMJ/oilJF74OJWSO5RxWR+XIRxW6gnSyMraKw+9oHjKDj7yuKdM01\nzs733KNbzK3p57KNkXfSmz2jRaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlggQdOoTUNxzJ7Td2B5n/KIy8WUwHwYDVR0j\nBBgwFoAU+cuCL518Nu1uM0HlHzvpEZ5wY4YwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgWPoOXyti\n3rZAWE4R1bxGesRrg5ngML8BbOoS4dt6yMACIAWRu9uT1u5Aj9wmd4nESbXExpFR\n3Uq9CKpYUM0W3Ye6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWsLrnJ5rvko7qh5Eed127nZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNWUxZmZjNy1iNTIwLTQ2MzEtOGFmYS0xYmMwNWZmZTM0ZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQiOcpD7//oZqhGMd4gaRjEkjpWJRKHVOabcXuzUq1qY8A\nzUvnE5E/tm+6cOtopDUhqd0RxgUOISz9au8wkvXbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+cuCL518Nu1uM0HlHzvpEZ5w\nY4YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEhzZJs61ccqOu1F9DD0u80P2Kz0zKKOSCQyag5lQlbYCIQCaYUvKks2U\nWJ81e6Cih+YS+xe2AxDLsEVmxBKptyqkMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAVwhqhSlMTTQI76o2eHFkryfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFiMWI5NTQtZmNhMi00ODdkLWI2MDktNTM4ODA3OTQ0MTdiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYzNzMyM2Rm\nLTFlMTUtNGNmOS1hYjUyLTAyZmNiMzI3OTE0MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNqJ+J+DZu5CGwydHDXx1aIv8jEVDwa4t/8tF7L0g4KxVZBEjRadudp1\nePDG5FrtwcSUbofNO7k84qcWQgwI43WjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJYIEHTq\nE1Dccye03dgeZ/yiMvFlMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAMu/wtF+euMYHnw7Mmig+dGUYsICU60kjtbAO7BpaeFMAiEA7KZCPUy34iWr\nqdYV7qByKPffZ0z8HouNmctMdzrvT68=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc873", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `873` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAXyW1AE6FLKgmRsBEKFvG8IiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzMzkzYWI5LWZhN2EtNGZhNC05OWRiLWMyMTZiOGRkZThhMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE1NTBjYTctZDM2\nOC00YTI2LTg0YmItNzVmNGM0Njc5MzQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDQz3LR8rHQ3gak3VkXBPObBObIB9m/zyOhxvuEqUmLgS+GeT9COSlEShZHWN\nEyh0cZyIQG/laHfdmS9HDKymsKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXg6E7csA1Zsmd0+2PJgoKLIHVF8wHwYDVR0j\nBBgwFoAUAUWY9Y1TtBmxuCrCh75+b234Rz0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgUmfR+PTi\nXwM/32VIlg6NKKhn2+JtDS153plSN+NdTIsCIQDYDS+sT/XSYnAPB4VRhlSNttoR\n4kRdXK/mohueJ9d+9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARznpxlfv+otNRkdmAx4GaG5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzM5M2FiOS1mYTdhLTRmYTQtOTlkYi1jMjE2YjhkZGU4YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIVsfoAA8ncLsIGvjXczri8tzk4GeV1F4RHfiF+u+A8H9M\ncR8z8OT982V0oUmZuGWMeLkjiWVcMtukAeJLNMvlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAUWY9Y1TtBmxuCrCh75+b234\nRz0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA2ibTh60lRMy1UQcym3+3X3J88NDI03vWOs9v+YSIKsCIFfyHpkP8HD0\nIRtXCAXygX+znuHP1r4LyWpS0zsdmrPw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAbhH3SiBlj4K7U9eOkv3b6k3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE1NTBjYTctZDM2OC00YTI2LTg0YmItNzVmNGM0Njc5MzQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgxYTdmM2E2\nLTJlNGEtNDlhNS1hM2JmLTc3YjkyZGRjNDMwMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJNQJ1JnjaFXTzkavgdnoHZIZmkU4bbQ9HcDIWVj+rQM9Gq/tD8vD74/\npJ0nSfxqP1ROSshyeaAzu97WkOhZF1WjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF4OhO3L\nANWbJndPtjyYKCiyB1RfMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgH3ym92z+8aAWDy9fWKvqB+zTNMeS0tkxA2GGYkN5FwMCIDxiYPGbflSJq8XV\nm6azllAjY6ba4gLMXmygWBfufCFv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc874", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `874` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAQ+d+JKuX7TfcRVWV/jUVa+iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhZDVlNzQ5LTM4NDItNDMzZi05NzljLTljNzZiY2Y1MzVlZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRlNGQzMDctNjgz\nMy00NGRjLTgyNTMtNjI5NDhiMDVjZWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAicTjiiseJ5W9eGd9v/P1JVZpIGre/ya/9Hi1GZQ7PVeYlVVKIe0q2mZ2bA3\nUzd/5tiSNxStvLHXL+6wAOXVU6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUndy71Q3KU19hSZeZua3vGddjTfQwHwYDVR0j\nBBgwFoAUjgihq6Urm9ad63nlOV5bDxVMWLUwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCKfCRY\nwrWbgmFwnNJEymLQa0LoMn8MG9skKB5BSMAiUwIhAKWWZBNNQVNTrd3gU2+AK4Og\nP8w14Nc/EXtA31jvMVhP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR2t7Skxo5p+OHeTU9LThVF/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWQ1ZTc0OS0zODQyLTQzM2YtOTc5Yy05Yzc2YmNmNTM1ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8lBjcdNfFzVsZ7Nsu+Gaj36Mgm/sTnQsE167tXZOtFTSn\nOghKziYpMC6IqgI963K1JWGIgd55oESLRTJcWnooo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjgihq6Urm9ad63nlOV5bDxVM\nWLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOVUaKkM6WcLWuCLrQdPwkhCtlqyAkdvdANUqRp3EG7oAiEAoo4WksZm\nuzcbGa9/3BN7qZaktkdt7q/sqHzh8bOKNQM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAQOglk7fnTqwmC0PoKAy047bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRlNGQzMDctNjgzMy00NGRjLTgyNTMtNjI5NDhiMDVjZWQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRmMzFkN2Qw\nLTA2MTctNGU5ZC05MDJiLTA3ZDI3ZmU2MjNhYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAU11hgegYF4xxai8aJPU5ZJjxZP87wNjjsRx/edMt05Rweq5sDfkfhB\nWyRYSXus2fIXQmOIdVnhOWgu0o8gPNajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ3cu9UN\nylNfYUmXmbmt7xnXY030MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAKxilzqok3/M2tjKXXFBjpX2bL18B+AYqt82ZmdcjxMCAiEArWI4ckFq7kb5\n1HT0H8spdaG98iAQiuhnsNKZvBLTQDc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc875", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `875` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAc14NV04hQhYHoAAh+VynWlJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNjJlYTRlLTg1OGQtNGUyYi1hM2I5LTdjZTZhODBjOWM0MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVlMGJmZjUtZmYz\nYy00ZmUyLTgwZTgtZGQ4Yjk3NTU5YzllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJso2nq2BBT/5eboBxPlLpLebUi8U8ulJqcWDx3P4MnOg+gc4UUuvdweLpgJk\n71QHW/eLvsIXgiBiw4xRXpgRaKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUistbNgIVLuMt/kVPWMftjUCXtXUwHwYDVR0j\nBBgwFoAUX+SKfWguJ6ei6H0trBweKH5736gwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIHtsqcq4sDm2bdkMA6yEnwXR86PHOnFSSQQyTSqDvzMWAiEAnI9N0GC6\nWpk2fnoPEAU6XxkQXJqohsvECRf5jThrthE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQYRCKZra7pGhjVNFLIkNawVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTYyZWE0ZS04NThkLTRlMmItYTNiOS03Y2U2YTgwYzljNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASew0I/OOAtiPSZP6DJIjL/0go79AwSZX64SZyA2b7D+/Vo\nWVA8I5NIZp++t+yxPcA0MlZa+UoA6NdTMm2OT9lko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX+SKfWguJ6ei6H0trBweKH57\n36gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBzyJggkBZD4xqqm19m0ZKsJsCUh1h5ZTwdQOVcUNNs4CIQDapbwdikSK\nXdv26NT80162l97DmVFhWCGte28aj+rTEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISARLNC+6JJMh7qYSuzwsXh4fRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVlMGJmZjUtZmYzYy00ZmUyLTgwZTgtZGQ4Yjk3NTU5YzllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhjNWNlZWE3\nLWRjMzUtNGNhZC04NWQ4LTY1Y2MyM2E2OTYwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBGmNU9HHMblN7zYZeXbypBskQ5HQnKmcbppBWZqe4XHro1qTUkGNnrx\ng4qqv+KBQR8vEPs3o6Uuof0PInfT8WCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIrLWzYC\nFS7jLf5FT1jH7Y1Al7V1MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgMq65oEo+ZPcudCRX8q3W3JxaH/giwUXhH2BVToOVGsACIE0RGbZ2gIwZlNos\n7sif9AQBeQgIjMvUx56BQnOijka1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc876", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `876` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISASk5jB+NZgrgiW8p0Nop90eAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhY2UzY2RkLTIyNTktNGQzYi1iYjY3LTY1NDM5MzNhNzc1OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAxMDBhNDktOTZh\nZi00YTEwLWJjODktNTBmMzkyZDU3MzUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKp5Q6XXXC18myhu6KHkJqHR0enWfq9jF9izsODOH4YxzNzUVZvJTpMKIQRuv\nVc6Za8zmqqfCTt9sDeqJC+9WY6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFMpNuNzLA7JXKpbzLZSoU2XI6b0wHwYDVR0j\nBBgwFoAU+BBlrBti+MHAodipOtBphDNESyYwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCFFuCuwBWATM92owaPhZdwBRt43BKYJTSVLDmdGMYL0AIgOgYZavAe\nXJNI+n0viQaUBUL5R9kQnWHbW91WlNRm7LM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXKbgr7JjBeaiXrYCiMSgl48MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWNlM2NkZC0yMjU5LTRkM2ItYmI2Ny02NTQzOTMzYTc3NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCAgdeM0o2WVwlzTNJ12X86gQhrtD6idDIID8c0yBEFF06\nIXLWGzaMoSF0YN+VT7vcJqYM5HAes5P1oVo6SiS3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+BBlrBti+MHAodipOtBphDNE\nSyYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP5R8G8pY5MQz0LwkPssTHvddXHknLU5zyOrZ3caZbzPAiEAqUymljuu\nxbW757ss1r6MqnEdk11EKfYeWTxhQ4iefUE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAaDQ3iJlGLy3xp6rCNKUby+nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAxMDBhNDktOTZhZi00YTEwLWJjODktNTBmMzkyZDU3MzUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUzYWI4YmYx\nLTgwNWQtNGI1My1hYzg5LTA5MDk1MjQzN2ExOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHTNc8J2MLI+yCP1Zo48wRTsm7fHue7O6EmqLqdI57a7EQMHemADBHlq\nXVoOCg1vWoowcnZ4RXQCGZN5K7+y7XCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBTKTbjc\nywOyVyqW8y2UqFNlyOm9MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAL+iPjtoAbUVC0JRC2ECegIUVi/+xJMrZ7O5ATYeqSAVAiBdom1iPOh55b2c\n8jsCAzLrL5iZ/9JFVhTV1HsZIoUBOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc877", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `877` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAR1KJ6u4GZDaBAgUQBBuvllpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlZTBjMzhhLTEzNzktNDE3Zi04YzVjLTdlOTUxZDU4NWFjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJjYmQ5OGEtNGJk\nMy00ZTU2LThmYjAtYzVhZDZjYzY3ZmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk/O4NIs79HMgRR/LnOTss3NYAja/pDnk5Ud8lm4knGxfEDG5HltPV1GQTdz9\n0o5QXlbvA0rI8DcfYVpZg6qfMKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAd50GrNBL2fseEzycs5zjXDYF/4wHwYDVR0j\nBBgwFoAUb8hmSb46wYP978h67ZYN/1s99eYwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIDonSDJBHoWDjvLT7eUiMzVqOacFZM96ExwcEFRbxsW3AiEAnMoZKK4l/i7oBo2+\n9/zZ/z6LVUUVnqEW0Ed3/kTOjlE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR1e0zVq9XL3WHJbqrrJySy8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZWUwYzM4YS0xMzc5LTQxN2YtOGM1Yy03ZTk1MWQ1ODVhYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDakHNpf+rOSwPas+pIM/wAcHqmwpdC0Uvwn1XtYCAT0GH\nrUmaiAnTCd6IW9lQDJvILLlvx15pAg0byhv1ENp/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb8hmSb46wYP978h67ZYN/1s9\n9eYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANMyBE8jsBfR78IylUZEhobSj/iNNzpvpw7LmS1zLRouAiBZPgvTuDxx\nthCeKw2i3RX6H0ntUiCct8jxMIzI1AaWAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISASR4lfoW4FKSbY/BeMg/xA3AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJjYmQ5OGEtNGJkMy00ZTU2LThmYjAtYzVhZDZjYzY3ZmQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFkZTQ3YjZi\nLWMyMmEtNDUxZi04NTkxLTg2OTliOWU2MTgwMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIccoOOxwI9F/WYQJICp6mOQAfwsEvNS/qHCbBIAOT9Nevqh+Hud9Mub\nswElKp7TbSVk58Q5deAgSzNtwxHxhAujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAHedBqz\nQS9n7HhM8nLOc41w2Bf+MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgTkEwkrz42iYQDYz4J1IXO+m4O4kP5gP0xxQ6RFQg/s8CIQCJ4mC8eOpV9Qyu\nAXBj/+hfsg467zFWydUeTFWx/rT4cQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc878", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `878` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAU6vtK/T5aO/0cCVrPc9HCFVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4NTU1Y2ZlLWQxZTUtNGZjZS1iNWMzLWU2Y2EzNDEzZTA0MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NmNTg3Y2QtNzI3\nNC00ZWRmLTk2MTItYWEzOWU4OGIyNmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOnDjoe5aeliXNAbLLszj05gpK9ILogkmyg0WeAr9uBwp4a3SB02RD1NPm7yv\nXNVi3AhADyHtkPLLLXL4ZGMXnKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUESeKOF39wEsghzIJ3bWy849zduYwHwYDVR0j\nBBgwFoAU7AsKwNcQSLyMDnA9WqRvET5WLgIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCXu57Z2oXEp09yRruTyJGXq+LLiTSt+219ECnKXVS2+gIg\nZUkzlA0mlYVWRp9mklzzppx1IYUwwH0KC8VAr/+/4HQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe9IJavFGvR1LjBIdXGDq6CSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODU1NWNmZS1kMWU1LTRmY2UtYjVjMy1lNmNhMzQxM2UwNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu1SAD79vK/0H1tKeGe4q6Qu2im7M2Wj/WgteJMR25uCLq\n/ZOnxOAKldGB1pXvoIy7Vc2MAThuowKhLysLaQ6po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7AsKwNcQSLyMDnA9WqRvET5W\nLgIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgb3TDEm02EYGDUePYIOc8BXm6LWUuMckStU60SqygZmgCIDclMTJ8BBPQ\nax3uvzbFDcv6WX+Ldiy/DdDw7lR6PB2v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAerwJyiEIc9CO3H0XAH54rnmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NmNTg3Y2QtNzI3NC00ZWRmLTk2MTItYWEzOWU4OGIyNmEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU4NGUzZDQz\nLTE2OGUtNDhlOS05NjkzLTI5YTI0MDk1YjBiNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIsbFEAaUa1fjqcK0GS/eUhRsaTHprJXLmDcZTaUUDXq+JSvcaUR4Sdk\ni6yEfAifmwIwtRpNEZAloAYVCQMKxFqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBEnijhd\n/cBLIIcyCd21svOPc3bmMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAITClQpzF9L5VB9gwZ0NFIttf9OXSQ3K5cYRUyiZH6NDAiEAxVloJxELfzpN\nLtJ5PdG71ZE3YGrb90AOaCOZR9Pk7i0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc879", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `879` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISASkrkbarT88j/msRLhuQ8qT9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwZjdmMTRhLTE3ZjktNDUwZS1hMDg4LTQ5NjEyZmFiMGJiMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGM1ZGFlNzItNDVj\nMS00YmE4LTg4MWItYzFjZTI5ZTk5MDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpT2Ts0KoJwGskIW2OlUzTuXrGzMgnETULZ8Bu9skP74eMPKwW3zqs+dnERGY\nWlXdIvbxSUVllRvaBW49LvmH+qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx1n9rA2osQS2j1MAQojHuszXr3AwHwYDVR0j\nBBgwFoAUVBnf0eLwnliyU3LfLXOgjzYDkqAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIBmbGvt6H7K+DJD2m1N60WdB7yR9/HPKlgRlfaiVUMkoAiEA\nvDnt6zKRlNQL+ozVKIKigUetzS5TDmKnXj8c7xzIdg0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWBVnucJAwYaq+AohSBT2A8PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGY3ZjE0YS0xN2Y5LTQ1MGUtYTA4OC00OTYxMmZhYjBiYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkrhYWY3E3pNJfh5nKRVPtearZwUL+zf6okESvmN7BqNJp\nFgc60E2NB30ooD8GMIr9QtkM7xDjA8RojL3FT0Gzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVBnf0eLwnliyU3LfLXOgjzYD\nkqAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL+zvRCcVt+ZS/NS6TKOefPLrLiDp8RM8B5SK5a3m6zRAiEAqhG/vxA8\ngjHxErhs/lXy/t5Q1BJpQUzrS6ZGF9UQz9I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAQGgvvH0ALKt1MTYIUuVHMhgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGM1ZGFlNzItNDVjMS00YmE4LTg4MWItYzFjZTI5ZTk5MDVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEyNzMwYzdl\nLTI1NzktNGI5NC1hOGYxLThhYzRhNjBjNzI4NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB5njBlDlnKKUwUpBhtZ1RPen8Sume7KPoLXPb5mOcHy8PWpDhT5IMN5\nMBT6zA0ax0Gvkril6Q7SXj0Eo8I0MuOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMdZ/awN\nqLEEto9TAEKIx7rM169wMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgEGDXSZmoBPyWtiZjvlH59u4NVTg0bV4lykERNlIt4CwCIQCtXVeg3EXJdlHt\nr6Xa6mezZ8kABBk8DMW9v6Ghjj2Djg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc880", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `880` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAa4V5xrQlPBsPm7HaXjPfsFPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhZmFjMWVjLWIwMDYtNGExNi04NDFkLTQ4MDFlYjcwYjE0MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTcwN2U5ODAtNzc5\nZC00ZDMxLTg1OTItYzAzNjRmY2RmNzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6akVqasuFP4lLFENqilc63Zerjw/gY2bYWX5df/HbZgkGqKC3IBs6py7KhGc\nl2LQZA0p/kRF/rLHqszfK1ZSMaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURa+myvBA0fomQzDf+KkEH1LGwC4wHwYDVR0j\nBBgwFoAUx0fdsISBqkkgi5Y1lHXcSFz61y4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCwo/d4TOdp\n1cjQX/p9N2hKXu9Acctp3Zbwp+arP2W1NwIgL6H1Zdxtd40/9NKkp7u2Sz5aLCsW\nNf4/EqBXHbCd9QM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATN9rxqxbeCd4hnvEVyGA5RzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWZhYzFlYy1iMDA2LTRhMTYtODQxZC00ODAxZWI3MGIxNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNs1KDW8JHmgyJfo+w0H85Gde7VWzV5olt1FlgP5J9KWNX\nBDIQkA1VH3QW1dPP0sa0rCcF4QRBZLOmcRvYsvCUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx0fdsISBqkkgi5Y1lHXcSFz6\n1y4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANrfesORSNWcxqQBKRf25aufSGoQ7M6sVXpd8v7BKQy0AiBK5pZvi5BS\n4A0Nw+vQbMuietLJekTkLjjc88eT9dgJ/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAazck/T+YJm+1cS4LZJdUiblMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTcwN2U5ODAtNzc5ZC00ZDMxLTg1OTItYzAzNjRmY2RmNzI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDExMTMyYmU1\nLTQyNzMtNGQ5Ny1iZjY0LTkwMmVmYmE4ZmQyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKPRPh4Zd7VsXlzFup1IK64KkHPpweowbBEYgP+PpK775FiHt3LbKHfX\n+cir/CkuhamHq28S3kJQ/TpLBKCmsLWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEWvpsrw\nQNH6JkMw3/ipBB9SxsAuMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJe7nREPkamDLytPeYNBtiuJ4uKkxtoKIHKR3tZcWcKCAiA9/DDWCNueFFHr\nQjYMFBgWyI9j3U0kNLFHJ1Qhkvu2TA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc881", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `881` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARboTZRWNWyi7vI07UfAzw/lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0MzVjN2MyLWJiODAtNDQ2ZS1hZGEzLWUwNjcyYmRmNDRhMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWI5ZTJhMGItYWZm\nMy00OTM2LWJjMTUtYzMwMzc1MGI5MGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiedd55uWT4zI8KfhvJLyVApPW7plPLVFC3ofQRyzSWWXmQvC0HqmCJeaT2bw\n/PItDoznh9B9AnYMan16MIFBoqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBpXP/mPHW7tEd1JOeGxFBXP29VQwHwYDVR0j\nBBgwFoAUaA/kabsquJUw1XkCgWKbJepJGPswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgLOeY68IPf/VoVzVAZKRtHFeY/fzW1qsEm5XtbZYX6y4CIQD34CxtPN/X\n5iVhWHqQ3Flb2KdzL1grufO9A49rWhtJrw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeghFOGxwMaQTqNQ2HIc/nOgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDM1YzdjMi1iYjgwLTQ0NmUtYWRhMy1lMDY3MmJkZjQ0YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5nbPMnTG2D0UhgbcBEHlH4Q27XIj+0DZ4ChTATcB45dK1\nA9r5MG7veBowIMuuxTEJwq2CVrGLuiaBJCedEhyCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaA/kabsquJUw1XkCgWKbJepJ\nGPswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ5t/aBN7ebJSckB1KLqKpZREMq6hdmbX1AMqbSkm6mGAiA619JqGUj6\nAg1CDmPtVwxq5Rxe23WIzWG+1LBmEUHYZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAUF53wTCh++KGMyGaMapVNfWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWI5ZTJhMGItYWZmMy00OTM2LWJjMTUtYzMwMzc1MGI5MGZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ3MWY3NTY4\nLWZhOWQtNGVjOS04YzU1LTIxN2U4ZDM2NDBkZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDrXnSZ82swYxGcFHaH1nwqrvZZCKeIThB1RS0QuAgXA79jWQKTVzeVv\nFNymO9mdrs5wSp6VXM6qnmDMtLcDDh6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAaVz/5j\nx1u7RHdSTnhsRQVz9vVUMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgGQPPIh1G8nAnYdDoQpwKMP2JwCFQT0SCqf9k9obcF6gCIQCdzRDxl/M6jfKZ\nCXP+JD90bFjpUH0ClBZkN8MjPUvdrw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc882", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `882` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAYT+GNrH/A+XeVQC741m33pRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4ZjIxZWQ2LTU4YmYtNDA1Yy05MWQ4LWYyYjFkYjM4ZDEzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdjYmEyMzUtNzBi\nMi00MWJjLTlhYzUtODJlOWE2YzUxNTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzv1fMU0yYvyUHCHn5RR0yrJw4IURtdwyxV/IlUCO1VAq7kLdB1/Nqh8CpegC\nwU8COqxfZMfwtlTZx0riKYwdaqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaC3IEhG2Bbhq7JwniQoSrhJIwZcwHwYDVR0j\nBBgwFoAUxsb4tr2wlVyzFODIvMWJUcJgRrEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAM8NT3W/ogAqYiehX1PtI5fq58GIedxMd4iQTTMh0mdsAiEA38Rwc0wu\nm0qPkfbigYUbHtm+WNQ0m2gPzo/XfKLQY5Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfL9iVblEC9c+JspRYvnuZIrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGYyMWVkNi01OGJmLTQwNWMtOTFkOC1mMmIxZGIzOGQxM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV0N0am93hwLeM/drVtIhLHJcXKl20io+Hlnv/SolMbe+i\nQghLx5ffpelS7o9btA4s6UA/0CUCFzozxmkHD4VLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxsb4tr2wlVyzFODIvMWJUcJg\nRrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcI/0aoyeHkd1i7hdLtVdXK1YooZY5YATmNdg3LZfYV4CIQDn5i2Lfkdv\nFPIA4z0vfWJFEG6KsP9VvETbEp7Rc7+6VQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAcMOa27b3IgaNKJMy70pmbHCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdjYmEyMzUtNzBiMi00MWJjLTlhYzUtODJlOWE2YzUxNTFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM4ZGZkMGM1\nLTAxMzItNGRhYi04MWQ3LTk5NTI0NTMxOWNmYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBMFV1mIPCJoP3/Dw34S43pfJInKnmCytCixGCHs2ZsuYHvyFoKp0XNU\nk53HRFsFcm+e8uJsGXT5ZWjKCA29kFujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGgtyBIR\ntgW4auycJ4kKEq4SSMGXMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgOGX4WQAo09eWjRXKv7WiuxXBgSvUaG8ZeBNrpxPiCiQCIHKkUPVECE6MARtB\n/OrwkhkgTfbpm35892SxchmqsDUn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc883", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `883` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeWH6JcaXh+C5bCxRvA2Uo8UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkZTMzZjZkLWY4OGMtNDNjZC1hZGRlLWYyMzkwNTU2OGFkMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE0OGQxNzQtYjky\nNC00ODhkLTlhYTYtMDZhZGIxYzMzZGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyyl9AuohOqyjqLY4MI8werfSBfPDCIktsuI+zIetzCp5StHA+6x6pm/cnbke\nInrNYsV1eK9hO8zPssY3sFWOpqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU186N7pThTr67BMdOVmehU6sKebMwHwYDVR0j\nBBgwFoAUgrE2/YijCX6imACJMpDwjzd8vHEwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDYSeezF4ozMPKDdI7kDSNWQkvgATvKiT4HDM4AtKcq0AIgJPrt62wr\nJGhI52KlIj2xYJC3Nea0XGJWIdNmA+VsVGg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVDldOEgRCIIWPAFHjqUwW0IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGUzM2Y2ZC1mODhjLTQzY2QtYWRkZS1mMjM5MDU1NjhhZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3b1CFaiC7F6s1oScARx3LM5b69pUxbfN8EcK/QNDrIyBd\n7xX3HEOJ4QfYPzeX1vm1aTERjV4cmNJd5kEF7oKOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgrE2/YijCX6imACJMpDwjzd8\nvHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMvX31KezHBHBsyjD9L+sQiOuT4xWR50S1bYOM4IEvg8CIQDXRBghMmqG\n10aJsFwxxiuAJrG/9YVbyUiaMIrx62piHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAfqNT9TLvhy7CZbdHkF/INwaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE0OGQxNzQtYjkyNC00ODhkLTlhYTYtMDZhZGIxYzMzZGVmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE3MzRhMzMx\nLWFjNjQtNDI4My05YzNhLWI3OGU5Mjk1OGViNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMkVqE7ZAjmgA/uLSQXBiy9Lem9clBZz2hJa7im3f6QxuBQz5lIecKoM\nhK0//U8/X7V1/xzG51ew1vXMJ2ZWUMijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNfOje6U\n4U6+uwTHTlZnoVOrCnmzMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAKyefNhaIgQrMv4JFTQ1rP4wGFUyrd/5Ow1nRXT8ej7zAiAKQ0lqVFeW3k9E\niu61Nb7X/FPc/tF62mHTpK70V9v9YQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc884", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `884` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAeksKz7D7+0fFqDan8bt8Y8rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZDEwOTViLTQ3ODYtNDQ0MS1hM2IzLWIyYzNkNWM2OGNmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY1MDI2M2QtZWYw\nMS00MzczLWJjYjUtYTgzNjU3YjNmM2IwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET/qenK0dserDpxOUVGAgGm9i4UXpW3hroSUm68w8fRQjuSuAdB5adUo4JnGn\nSD8Vn2YrWtyghRdtvbNfMArtzqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoM+rybjJM9KZLMIEWZfZcNxobqcwHwYDVR0j\nBBgwFoAU7GfObneciGoggwKx90E3nu1toWcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCRVy+arBSgXPe9jP6jSNd5lIBOJHW0lmEoSzAS\n9FNICQIhAIVMEQOL+2pj8rLG/upagO7tBnM1lIb+mndvSzAtaVI0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb0CEF3EufFcXQ1ktAjxgFq1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmQxMDk1Yi00Nzg2LTQ0NDEtYTNiMy1iMmMzZDVjNjhjZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjsk8j8ZRhuSxeDdGjKZ0GfhoP3LpbUKGsPVi+9jpkwR0M\n+j38Hqv8nflOgBy1eeJOjdJIVC00GDfkmMr+24ePo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7GfObneciGoggwKx90E3nu1t\noWcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBc3GYY4bl+gEJaX08l8s9gY8AAaeqks7CKQt+0mEYOkCIQC3YIwk9r2e\nWFLbgtcBxsX+hNJLCBSqEyHFwDZZzOWBSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAWYgHAZvLaQ15klWurgSywLdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY1MDI2M2QtZWYwMS00MzczLWJjYjUtYTgzNjU3YjNmM2IwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYwMWQ2YmY0\nLWY4YWEtNGFlMy04YmQwLWZkNmQzZGYyZGE2ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDMvYusLs0gbUOQ+gb9L0gvV/s0dcu/6ejM3VECIDVh5hdPwVEYzq31n\n1R0xa6Frdx3VPlFNhbomBjnKFF7qOKCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKDPq8m4\nyTPSmSzCBFmX2XDcaG6nMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAM7HOKhB0mXnKhhoKze6p4CzNnleUD74pYK9/VLXkZhUAiA/C0EnM9YPtc8K\ngCEsRAjjintlPkw8BOb7l4zHLFB/aA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc885", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `885` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAXSTmGSI2ZPjATuPcdlBGyOvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlNTk5YTJkLWY2ZWUtNDc4OS05NjI5LTdmNGNhMzA2NDY3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQwZmU1YWYtNjQy\nMy00NjRhLWIwYzUtMGJmYmFiNTA3N2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAfSqIy/bKAiZ4rNn062xk501U/zeghgSzxQ2KyQ72wwGN1JrCH53xEMVGixW\nTXDrpvd5itXAG8xft4OxVW7ugaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsNS4TDOgSD+yLkjQ0fOcaax+pr4wHwYDVR0j\nBBgwFoAUAO8/JQ96XyPD1JuFXe6p+PvpKmMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCID1kEzXjDb/58CGXJpKOL16bByk8qSvLdkRqtnAE\n0xksAiEAh+GsaQk7byKR0tMEK9BdnaQOQAAwEWrnCv9+fDvx6/I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWePnSnbISj7bnOLGtAjFcjbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTU5OWEyZC1mNmVlLTQ3ODktOTYyOS03ZjRjYTMwNjQ2NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATf9sFnaZ74sY73i5w6vMPa4+G04AYp6XDzYCk1dF36sVJ2\nxFDqY0UWcYTQzDYvNovD9ja7b0JkNMuAGo5O4nYAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAO8/JQ96XyPD1JuFXe6p+Pvp\nKmMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGhDFOvyGOFjYKxsPzHvuQPhgUCvUkgOW5x48gITUmmgCIQDqeaOcPYnC\nZQfJUYXZnB3mE+jqouw4Ggvgl8lN0uj1zg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAU606h6t8huc5XvFgwT7qeHIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQwZmU1YWYtNjQyMy00NjRhLWIwYzUtMGJmYmFiNTA3N2E5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE1Y2U4YjZm\nLTJlMDktNGQ2MC05NGQ4LWVhMjY2NDZmODhlNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGK/wozfuWaREZWx8Qlmd+1VhpgLNAxEdM7obpc1f6vNi1k1wD5+ok2N\nBux/GUnpedZfGMwQ9sdcvKNXw50EI9ajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLDUuEwz\noEg/si5I0NHznGmsfqa+MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAM+ZxJZbzsz4EfN/WI8Kwh7KUrTzqZncc1sw80ZPzAIdAiEA0hxIHiCnH9Oo\nqiq7hHSysW6bBCNh0hlWDHY5YSwhTw8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc886", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `886` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISATkW6chITa7VPb26TfrAYGFRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmYjAzODM1LTI5OGEtNDYwNS1hMzA4LTM0NGIyMjkyYzljODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjgwZTQzZmYtZWMx\nYi00NzMxLWI2YWYtY2FlYTVkYWJkNGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU7ZC0bOdHNlXpjqkCZ9h/hFjiOjL3cbpfLpsftbd7FA96+OS7aN0mYmjTlGe\n2vcgVyOLxDrOw9TbovvL3t8ldaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpkEnRbv5UlyhnWkHP1YJ6M+Vs9YwHwYDVR0j\nBBgwFoAUEPyckmdG6NcE/MR8ksgGgn+3jX0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCcOJRh3wE/EahI0MnaB71bcQzwtawObd9euUPq9RZESAIh\nAMmIdn8tG+Ed0h4JAJEBe04EniWADf+L+CiL9VglLpb9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeoKxJzdXk1LDS9QpwHAj5pgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZmIwMzgzNS0yOThhLTQ2MDUtYTMwOC0zNDRiMjI5MmM5YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdgLsRJQLigUOaV34MKOC7QrQVSPtN8Dt+PxFRawFirQUG\nd8NzTigQJ1yyHwZSV8QfgenvF8nBhmLKif0+tPBno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEPyckmdG6NcE/MR8ksgGgn+3\njX0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdhqazKMXrkwcrHa8IQf+Lv4nX4OnXUPq0lRQWskeStMCIQDtI0G3zMIN\ncQLmglbzPMuc/pgn9sMv+QKnBDLswced4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISASfp+R0Y6JNfD6FgkUMbG8EkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjgwZTQzZmYtZWMxYi00NzMxLWI2YWYtY2FlYTVkYWJkNGFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhlNTBjOWY2\nLTI4NGUtNDNkYS1hYmExLWZiMDNmYzNjMjg3ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP8rPu5xDbCYAd6DrpdZVyPTl4xTMqnMwOk8hz06mjy3Lr1XWIVY69dn\nDuc3iolmkQ2XRd6Fiu95denRMySFC3ejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKZBJ0W7\n+VJcoZ1pBz9WCejPlbPWMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgbMGvHhkPktZ/2k1ARA2QOPirhJ+ER+ZFSNYNIyuW5FYCIFAS9wsILI1t8S0d\ndO0xiQw02p33T440Yy7c+jGLccBG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc887", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `887` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAW6XD5EISgqNRdie7m4xrN/6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZDc3YzRkLWI4MjAtNGIyMi04NmFkLTA3YWZkMWFlMTI5ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI5NjE2OGMtYzgz\nOC00ODA5LWJjZWUtMzMyMWIzYmEzOWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDLNMG/5ey6PFZULrQlYHqpxMGsm5zrjcqm+UoOG9AwTgePKB9OBm42eeypW8\nDTnvy4oTuGQ74ESale4fPdRAvaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlh8yufJFGkZ8vMHVeiz6WhABYsAwHwYDVR0j\nBBgwFoAUl1QSWrswtskQctRfMEERcpGO22MwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCixfE3D9ND1IJSXgIAiNsI2ZO5nWIC\nZz7o1V5llGT/xAIhAOsSBFSb8BUp9SJlZh5ccjE3jjtXmSpbknOOEJzmaHM5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbVTYSASJVPx3aAk/P4+qbkJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2Q3N2M0ZC1iODIwLTRiMjItODZhZC0wN2FmZDFhZTEyOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNZzdYFH2MgVddITvFrFh4z7YqqkRX8+0BJGnsjdyNcYu+\n1ZphwAKSlGS1srcNpqKev4PEzTnOqGYw6yuNasXzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl1QSWrswtskQctRfMEERcpGO\n22MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANHy0KVFe4E+cGTNFhCXWcw0L5znvo6ZV14kukPr7E3mAiBFroRJjIMM\nRRELRd/sC/lcOUK2MlCm6a50Qwb09ZJekg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAesn0vyOfpbL18KrbUeX8vmfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI5NjE2OGMtYzgzOC00ODA5LWJjZWUtMzMyMWIzYmEzOWVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRjMjQ5NjA1\nLTViNzctNDAyZS05OWIxLTBiYjY4MTk2OWVmNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMnG5RFIP5MH8CR7jNneIiNrc4ZUAc/xCtSn77LKD8Zs1OIj/RGKmJSC\nCwkOgiyGILPEaF1pvXkr80e7HUafR82jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJYfMrny\nRRpGfLzB1Xos+loQAWLAMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAMBwgOzd1qFU52uO2W09v4GZQtVm2ZKRyDn3tWoOjQO5AiB5PxydU+01XwoT\nS32pt2b781UkkMlD3bAaczW6pRnFxg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc888", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `888` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAfF2ZGawte2iMjrpy20dfAbcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMzFiZjJmLTM3MjMtNDhkYi1hOWQ3LWE3ZmU3MDAyMzcwYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U5ZGRiODctYjQ1\nOC00MTlhLWI1NzQtM2RhNzk0ODMzNTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErT4wZhe05T/vk3FFARfPrpCHr/j/uqyuMtmtmQh+vS+bJirzZleh3vK0ap0v\ndMaGHIj/3VsFhsllBqpyGBhI0KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4QbOY2/sDN8b6M+PWEUm4O/lqSYwHwYDVR0j\nBBgwFoAU7BfQ56hZhCrLspWilD9lBKyA+74wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIFXEVqzp88JBfoC7KX1hi6uVffGE50TS\nS8jQxDraGnLGAiBEai7EoCXjQuwd0MMiKfmta2lx+Sk/iZQcEOPuLsgkLw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXIh0p0IRvTxQsNTQGYJPW1WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzMxYmYyZi0zNzIzLTQ4ZGItYTlkNy1hN2ZlNzAwMjM3MGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASETC3IY6QTE9k2Sy8UjnbUn3jdM4Nuw4TuL/wBNGg7E0YA\n7Fkz8WcRxdnMoqDjBjMuP7MIu1Q/44JklGfH180Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7BfQ56hZhCrLspWilD9lBKyA\n+74wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ7b/KQdnlZFqe5WZzb2fOzJsiDkU/MxKGdGRJKR0vAFAiBfbwwKbJUv\nmAKpp813s6gmpC/Q6g6nFBDCHR/cnfVY2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAa6YOkiAEINeGikhzIkiFoh0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U5ZGRiODctYjQ1OC00MTlhLWI1NzQtM2RhNzk0ODMzNTgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIyZDNiMTA3\nLTU2YWItNDBmNC04NDBkLTBhNDExZjg1ODY4MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFxkCtnkFsecguOgzL5Ugw9d/VPYoEkodLUpSmw3tTIPS3UhOME4RQY4\noD1b4X4k1hT7pGg6iPxmhk2JiEaHshmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOEGzmNv\n7AzfG+jPj1hFJuDv5akmMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgWH1R//EtHOqe7HeJnG/xudknuv5nniKRVEXmw6iiMrsCIGUZcXd36NwmnO8g\nvQoK5u3JgBNhzP7LsJLySwr5eSBL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc889", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `889` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAY4EoIcOgxP/QRHMS5bHBbqVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1ZTFhYzhjLWFiYWQtNGY3MS04MmMwLWQ0Y2NjYjNlNWU3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdmMzVkYzgtY2Q1\nYy00YTIyLTgxZjAtNDBkNGI2YWNkMDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/9j+qHLj+8G2iwc8A2OdHVl2TYjA70nns63mpOsO358PQgSi7ZHSTqhtZAFx\nFmNbxkRVr+Dhln3lUsbT8/QftKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURLe5Yew64YKZ2P2hohR6Jf1dWPcwHwYDVR0j\nBBgwFoAUgC7DYQWhYK1GFZGshCz2al6nzTgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDcj9jCfWS7\nKOY9pRbkzozrzwT0H7e13erLQtpwGFDgXQIhAJIIyvEWUqjvkJyzfCLPhSEXfLP5\n2hcTqd/qdQMD/oaM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfhc+r/vi/eCAWvlLTQwc7+VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWUxYWM4Yy1hYmFkLTRmNzEtODJjMC1kNGNjY2IzZTVlN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1QHK+XZ94AvBsUR4SfPnE0zWHm96oUzGc+029uBqFCn3M\n4aeELkDEZPQl6mKEHJEVj4ouc4a7rX2zat+eb0ePo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgC7DYQWhYK1GFZGshCz2al6n\nzTgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfju1dIFBdTdwzl1B0iKcEs9+QmfhChSXZ7ZEFKNFSZ8CIQDJdDoWpiCg\nVZtFyh/lM8q8g7/Wb7YRL8ZozvwwL6EZfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARj0yMa94JSWfYsF9NIvcXIVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdmMzVkYzgtY2Q1Yy00YTIyLTgxZjAtNDBkNGI2YWNkMDExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJjNzJiYjBi\nLTUxNWYtNDM1YS1hN2Y0LTRjNTA0MjhlYmNlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEQNLCr5wAoD8kZEWAUveN6FBu1/uN4mlyKjKZ7TqeOvL+K/ZBiRD0Ec\nJeJO4NCZtTcaqyrFwh+tA65WvY2YmmqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFES3uWHs\nOuGCmdj9oaIUeiX9XVj3MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAPS+5aI0h0M1HQobUkWxRzS91rkdnL4PGhUh9+JeF0GcAiAsQe+Qt8Sp4EXB\n9X0wGxSvLkVQU8RCM4DsLtJ/TvVGNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc890", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `890` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAXN/37z4nNWKf/b/JJ+n/sL8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNThkM2JmLTllNmMtNDdmNC1iZWJmLTlhYWU1ZGUzMTYwZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFkNzI2OTgtN2Y4\nOC00ZTAxLWJlODMtNTNiODcxYmViMzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6VK7sH3Td9oveP4iSjIdJjzdbPYPzkT0XktEdvCBQL1xbXYuxm3mR7A+Mw3b\nB1teRjB5eR1PdZcZuGG5BkB25aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu2qHqAtud4I6My9NxgzPNI0+oxgwHwYDVR0j\nBBgwFoAU7UxIChg+/jYv/KeiHPApwpnTXS8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgVVZv4nPeZ+uAAS6XOMG+U7kEsdg3lU9Zp6vnir9qJ6ICIEQBX6KOJD70\n7kLFjzfJPRYV5TRqRSWZvqrePnFxcfNJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATtZaJ+1fon7TcMn9/ujbaW5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDU4ZDNiZi05ZTZjLTQ3ZjQtYmViZi05YWFlNWRlMzE2MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP0hsUT9MBdbjC3YY8F2mS1ftsVkReki0StgwnRM0QO+Rc\nwR/l+T3sSE6hkZaYDII1J153iZe08Dw/miVO4uI8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7UxIChg+/jYv/KeiHPApwpnT\nXS8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTMK4qEOb64vR2tT5FcmOpLEvhOlxHvfz6nqewNV9SHkCIEtEA61DC82U\nCZpwx2cejwrq1lfQ9XNovqecwyA7EjF+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAQzMVFZ08XL8OgeGngqlkeEvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFkNzI2OTgtN2Y4OC00ZTAxLWJlODMtNTNiODcxYmViMzk4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI4Y2JjMTQ0\nLTQwMTEtNGZmOC1hOWZiLTgyNDUyNTcwOTE3YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGA0AYgCWwXengQ3OJ7E1QCA33EQR+bJChXcEkecaCM+YbJ0h+36qJCf\nJ7R6ipZvIqQZeBxI77OQ0wVZjPfuVtejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLtqh6gL\nbneCOjMvTcYMzzSNPqMYMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgG0Jtrp7lgkeCgTOjPhvx4UCLkc+s/JDrXOvjLItYDRYCIFewJUrRvNtuHsPa\nR04KKD8A3+x1fuZPbBqjqXh6InlT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc891", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `891` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARruK3eFymYHW9jygMyvQjPUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyZjgxZTkxLTJkMGUtNDdkZi1iNmZkLTVhYWU1M2ZiY2QwMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU3OGQ3NDMtYWMx\nNi00YzQ1LWIwMTItYWExZjk2NGY1ODZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBlPyDUUrJ/GuBSP19NL7P2yZfd2EY1c5gMP74VEr8U4vLD7dQxmDA/3bBcrj\ndhq3YSrKdja4h/BBAB8CC6EGSqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo/1W8X0UnZRh2E8aqbSK9beRTc0wHwYDVR0j\nBBgwFoAU24m3pjY4k8csca1ZaHGlToNv86UwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgcIwO1BFHoQ+OEz7UQmJaKvEk3KJOds5F4VBDXwawZ0ECIQDIfMgdt6pd\nev6nzlSVYT0B/jQoEaFxxYWYGpaTpGHAvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYPFvuxTePQqJA3sluFjawYWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmY4MWU5MS0yZDBlLTQ3ZGYtYjZmZC01YWFlNTNmYmNkMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYerXV5wimgb92IXSIROqH3adicEX39B0ubUndUQ+SS1dc\nF72f+q0IZOONnBylRYoSGajr+Xq6cN6hdRKWnHz5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU24m3pjY4k8csca1ZaHGlToNv\n86UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGZ1QuH2n/YbPsQ+vwbkXYsnmsCe2sJSKJNroVM/r6mMCIBs7tHtTjmqa\njtLTFV+U++7aKKaxn17mK8KGcjH5iLVw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbTPBrKQ2bbB/p8mCr/fZdr8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU3OGQ3NDMtYWMxNi00YzQ1LWIwMTItYWExZjk2NGY1ODZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM4MjE0OTdi\nLTE4NWYtNDgwMC05ZjczLWQzNjBkNjEwMzhkMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJEnMQim1Fk0VbM9YaFJ09DSjsFWbxA4Z4tnFgvIHfRqBHjefkS6Vvdj\nKQuCo3dInOWQEOK59e7wEWmswdb+5qejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKP9VvF9\nFJ2UYdhPGqm0ivW3kU3NMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAKEuA48Dli68tt6XGSbe8Lzi2pNAf/56pqMf1Uyz8B6dAiAPsiR2SWrT5uqu\nkX+xGFYJo2gugHCx5yYX55y6gkV/Pw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc892", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `892` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAfjw+uv78/q4QrmUCLSrdDM4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4NTE1MTFmLTM1MzctNDczZC05ZmI3LTY5ZWNlYTQzNmI3ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJmOGE4MTktYjI0\nZS00ZjVhLWI1OTUtNzJkYTgwZTJkZmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBDSiQ8gMuLxBBXKghamzCDEdho4g4n3HRw6AhD2HosqKHcA9WEK+XH1QWCeO\ngkPLWOs65cjWeWwrddI0mxbTiaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuGa0N06EW8tnibMIgPvp04OkUxwwHwYDVR0j\nBBgwFoAUYlnQL1qBp7VEN9kbCtKwAC7Bgq4wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIG+P7laux7CE7g4Ce66K51+m9MXnw5KpkvuF7rJTfNsPAiBfvLCD1+tW\nT+iTPOJVQY6EAT7kWJ4O3ReJFUV9P3iyAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWZjJUptWE4YUWHh9NYuKKzPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODUxNTExZi0zNTM3LTQ3M2QtOWZiNy02OWVjZWE0MzZiN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7irIv3FZpAdZeAjc5DQr4nUGDElvuBCUMwFu6EwN2OIiR\nXkOuEo11AqIurzDSRojEE5JFjs+kTj43/LJA7s/No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYlnQL1qBp7VEN9kbCtKwAC7B\ngq4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBq3ysO821/Be8zOtZ+NDj4/0MUFMGQYZFOetN00uUBUCIAzzDlOvifUm\nwmezaFuoif7E4HFspGl+qKh+aZ0o+wgo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAcSh/ni/GXRemGUbAhm0w5K1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJmOGE4MTktYjI0ZS00ZjVhLWI1OTUtNzJkYTgwZTJkZmY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRjNmZhMmZl\nLTFmZTctNGQzZC05YTU0LTVmYjI5NTY4N2UyNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDy82Zfp2It75abwuT5YBF/AxSy3HPrk1vOsyd5DDrafE99TM6HCJ+kQ\noHp+7QX079R9ZG8+uziE1ip4o/DdDjajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLhmtDdO\nhFvLZ4mzCID76dODpFMcMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAK8NwIo/LtHXl+LcBmWvLHYqRGZEkLv1KQId3Zj+gpX3AiAUjhZQakfg5nS7\nC66M5iqb3cX58wvFcmOuZGgT6moEiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc893", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `893` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAVRTqaSCAI6DqcoPM+0MB68zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzNjBhMzNiLWMzZWEtNDUxYS05ODlkLWE1YmUyYTY5YzU0MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2QwMGVmZTYtOTA5\nNC00MGU0LThhZmYtNjIwZjIxMjVkZDk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELphbEXAWtHdBS1PPwHuPCt+jBp30PREuqRNcCcznk1VnRqVU4f+RD/Ung6Dy\nxoGSH/TiTx87aEZEUz5Ba23D+qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOnbQEgK7xKR2V+LquWle+g0GOI8wHwYDVR0j\nBBgwFoAU7yit6xerBgg2ZkP4+w3oslN4Qt0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICvy5PlrXf5KZtrGo8PVGRyYkDg5pxxh3Xjvr/S9\n5C0rAiB2LGhM+EoBiewRPSIyxGOp9pSqKsCLoaAAF7rYiM4wSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAboCAY+9Sqh4stK8zqfrMY36MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzYwYTMzYi1jM2VhLTQ1MWEtOTg5ZC1hNWJlMmE2OWM1NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvz+72wNzXncAFfLeoQDjQAL48X9CTmOlttrq5ep20EVB+\n8lHS+bWkgwhevVO1yjgCixhSRIAe9/Op1WN8rWhOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7yit6xerBgg2ZkP4+w3oslN4\nQt0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOZ20UWqegLcS+xTCMoPOtsYmfnCdXR1Lj00lJLoc/s1AiEA5B5R3MwK\nxo5JaQ3cWDpqHrIYn8mJ+0Evq71ccuZihxk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAdk2MoAMHLQLScPhdNjlfLxTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2QwMGVmZTYtOTA5NC00MGU0LThhZmYtNjIwZjIxMjVkZDk5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIzNmEyMDYw\nLTJjMDUtNDZiOS04NDU1LWE0ZDIxMmMzMDc2ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK0e6m+kbPexTr5wF83Dr4d0WO+T3eyQPG7cBlssG7JbOfJA1cNVgB5G\nB3oic9eEChGX7g+n1T06lnEOkLdlt2+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDp20BIC\nu8Skdlfi6rlpXvoNBjiPMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhALyLjjbEJ81FcjbwyG737d82nxHW28PJSsrtajGo8ty/AiBKO67ArgWZQL2G\nVeKKw8IdsxteFYp11xB8GeKKKBhR5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc894", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `894` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAW6/mEieYV6WVytaHHPuGhqmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5ZjI3OGU1LWEyZjctNDkxMS04ZTg4LWU4ZDU3MWM4MDQzYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg3OTllOTAtNzI3\nYS00ZWU0LTliNTYtY2JjNDhkZTdlNzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpRhaSQ9sTLJdnkoKBz8j5ZpM0wptYJhYt01sdpbv2hgIwkMXsf35CYil2kkI\niEQkppTrTGLaXyUGqJVhyip+naOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP9GKS+AGAKNWric7HKq0OiKHxQswHwYDVR0j\nBBgwFoAUIdg+vUMH1Zm0yjfREfrFZwqHPFgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHzyXc1UEO5mxXq+9gnTmBOLnZzaQ7g6+Q0jlhJR\nkdHNAiEAk1baifHgBAK54/5NloYGnCmyBlXsNtflxlDphdN423Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWmL3LfNdVuejqM9K9ZnQmzEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWYyNzhlNS1hMmY3LTQ5MTEtOGU4OC1lOGQ1NzFjODA0M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToXTR+92+bGMl0AGtqEzN1vnYSMde4TnGn40Jt1b4IqrNr\nlYv2WSG+EUMh91TIO9V1aOYAj85CeJCR5Mgk9AyUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIdg+vUMH1Zm0yjfREfrFZwqH\nPFgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALiXoMk9N/MGL/wU8qp+9mQ5AVKPlALKeku7kZLeLgWLAiEAmCgnTM1C\nkVEQ9V5X9kRlcdraZ51bpEvhGwFKzGzmcpM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAZOUUNp500vV5LuTifWvKUuyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg3OTllOTAtNzI3YS00ZWU0LTliNTYtY2JjNDhkZTdlNzZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFjZmU0ODA1\nLTM4MTgtNGE3OS1hNmFlLWM5NTIxMDJmZGEwYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMh5gyeuqzyHqGt+HzDZcOxXkv6B5Y6CUsSdUgKhZBluWtXrRN/Sc8CN\nMAnBS86Kdyz6ExcpYkMSVXK97Nj50NijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD/Rikvg\nBgCjVq4nOxyqtDoih8ULMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgdcmojbBbgPG3C47KPINXl5A2+kpS5WXEk08D0WMr7qsCIBIfJo4hKdgFPfHu\nVu+JyD5NUxGBtqc7qr91I5DOHRsc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc895", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `895` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAZG8Ufphscq/vdLM1sL7dwtNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NzhmZjc5LWE2N2YtNDNmZS04NjUwLWZjYmY1NTZkMDY3NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZjOGYwOWYtNzEz\nOC00Y2ExLWFjZDMtMTU2NjA0NThmMWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbS/QU6bvr2d4thrRaW92uTmzT62LeIfABOzojxHgxhVg5Xs78pQ1qETOzwCO\nK1gjMlP3p7qQCVN1SAN8MZKwXKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULdhSe0eDo8TpbCttw7fjFNRWrAIwHwYDVR0j\nBBgwFoAUSbjibbYFhNhyuPhSHnl/Sj7Ob90wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCICqgC44Kr6KJM+6UBNOy4s8Otrf9iQTWSB9afQtDaEUfAiA6\nq48/lemx0/1QTkKdrWXElG2p5u7Onboz40jcxqzB4Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXuSH3R727VpxgCutBhfHWrtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTc4ZmY3OS1hNjdmLTQzZmUtODY1MC1mY2JmNTU2ZDA2NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwHfZOye4p0n+LQovzaqikDfGoveLlADed1t0VbCEg1vPu\nJjwlFWBh9t6nVetu0K175hWymwSk10OXAvq75D+Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSbjibbYFhNhyuPhSHnl/Sj7O\nb90wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNFESmYs2YNkFxgPUjxbNLZMjvMNNooUFes7h/X5daukCICF9EsiCr42K\na9HZiIzKbFfZhQWYQdEtOVANoJBYSEez\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISATBmCRyTL1jJzRhAhibu459zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZjOGYwOWYtNzEzOC00Y2ExLWFjZDMtMTU2NjA0NThmMWU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkNWE5N2Y4\nLWQzZjctNDI5YS05ZjcwLTk0NTczZjkxMTRlMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJz+vZpDcGmSxt1zI2gbUYowGHe4Zh5u1H9+Ir3XsTRTaLjaTubYK+gl\nQrkNzPwyjuWQm8lKftqg0nl98kSPuMijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC3YUntH\ng6PE6WwrbcO34xTUVqwCMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgHb7nNXOIaebRHuerHUL+zwZpad48kWhfIsyvoCx1TUgCIQCqibCqzSIdpW3k\nqtvV89IybLSFwHOQunnyshbIH0KosA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc896", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `896` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAS1LcsoU8yK5HnBLpbKU1V3NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjZDY0NGY1LTVlYmYtNGZiOC05MGU4LWMzMDczNDNmZjIyNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTUwMTM4MWItMjE0\nZi00NmNiLTljNmEtYmE0NDZlY2M0MDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESbOZizwRUHQT0YVcORcXVIwNXFUZH9ubBxtNGWpV/z+Sx56MisSKOYDtbGRS\nzjnY1pcLE+MCmmnzRhJZ/fwz8aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkUpaLch3dKjeM1DrvgDZIubIVdUwHwYDVR0j\nBBgwFoAUT+YnjD0fHKDn6xmRGqFNRh6oBGcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCYoV0QInMSFl8QNnj8RifP5fBZmDf7\nRmCjPy/UX9+/7wIhALto8oanmaLYoDjnmakPkiAwyk9ohlJLNPwlXigqL734\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZMy7PHKx/u4ooBClFmO0FcSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2Q2NDRmNS01ZWJmLTRmYjgtOTBlOC1jMzA3MzQzZmYyMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+zRXSrAuUy2wHtjnroANWzxlHMT8Pl3kxxVo7wFO4idU3\nbaZKZyqLdG3JOdojiaRW19FQ2ed+P0zWEb188nTOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT+YnjD0fHKDn6xmRGqFNRh6o\nBGcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALpp33nyENZVXWzF0s1Pfjo4QtQNFJbP6hCp5qdKurWJAiEA+zH0eyKk\ny/cu0KcRbM49TnYngvmAAZnE7Zb0ZV6tu/k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARTfLM4SWMnUql9BB8uaEhphMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTUwMTM4MWItMjE0Zi00NmNiLTljNmEtYmE0NDZlY2M0MDNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMwYmQ4ZWRl\nLTJmOGYtNGUyOS1hZTVmLTk3MzIwYjJhMDJhOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM/vRLO8y3wxwbJgiunDnx/BbTAgt/YxOP9nDFqEzo7sPMjjJUKTeROY\nt+60ZgSXHq4KbsuA78mRFCYIG+Obp6mjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJFKWi3I\nd3So3jNQ674A2SLmyFXVMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgV3r9F17m3Vu4RUQIof9EorZtJc8N8CYA7f2J08IeJ2wCIQCsk586WuZvmUfa\nJ6jeb8HpQhvwtQVD2IK+l7AohLhNGg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc897", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `897` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbQz79zFzI3VfxyTm3olZvhlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNGNlYjRkLTM5ZDUtNGY4MC04MDVkLWNmMzAxMjA5ZGRmYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQzNDQ1ODktZDQ2\nOC00MjhlLWEwMDMtMWJkOTQ2MGM5ZThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd7wClTh4vdrMuxDas8qMewndcncFrapcAaNJuAiTzete05Hao8kWFOMion6I\nkjPsd/xpX3MhQHp3WRhojWEdpqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaB/VJhyDlo0BTMN6NkgNLZ8rU/YwHwYDVR0j\nBBgwFoAUSoioUIOgzmTpmKUpv9eQGwpM/rwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDrwWqAoYcR9B5UjXSEFt32SCxml8Qd\nHLsXEA3JrD4KLAIgA2JVkl2zdqS1x9MX/59coBYNSEJGJuC/5o3gNzta6u0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASrOPhytjHFrDZWVE3YjGGz1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDRjZWI0ZC0zOWQ1LTRmODAtODA1ZC1jZjMwMTIwOWRkZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS/+yK8YcKmk64QLCLKR3KexdKEb2MBeoUu1dHKj5Zh1df\neexp91/35IBVfrjvP0RyML51Hq1FniK9mcxGSQcAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSoioUIOgzmTpmKUpv9eQGwpM\n/rwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAORaTihr1tbxX+s3djzZQQ7ZTK0Og5eerisDqfjD/sTQAiEAgBVcOo0n\nFhIjQDLeL/fgykihcURh04lieNx+1nwUjo8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAaOBA+k1tQ9ojWUN4cI7Xn8IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQzNDQ1ODktZDQ2OC00MjhlLWEwMDMtMWJkOTQ2MGM5ZThkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM2Y2JlODMz\nLTVmZjgtNDk0My04YmVjLWM5YTUzNzBkYmRjMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJwfpXhFVAXpEukQvH1zD0CeIbIgUq1s0/+qlpGSObouYNflQZ7Hfj+l\nmJBFhSAF19mRp1LaK/7muKDut8hjK3+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGgf1SYc\ng5aNAUzDejZIDS2fK1P2MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgbckTk5meOLVRRU2lsiqDMhXsdWoKCniv0kyaJxKfrzYCIEWFI4GpPkadi01K\nc1hKfP5EwsctGA8ylpgeLef2cvyz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc898", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `898` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAa/h19t5MMEHYZFqG7G8PU2WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlOTc5OGMxLTQyOTgtNDE0MC1iMWZmLWIzZTg4MzY3ZTQ4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE0ZDA5YzMtNmEz\nMy00YWFhLWFlZTYtMWM0ZjEyNWVlOTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoMe7ubpS7VCZodFSxE8Jj5r++wZ1mvUhwd0dWcDV1wmwGmwXEN9GUgrxHB3d\n16cy5pTnSwqe8sKPkAuLwzqFN6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGDtnrKiQQBhH+DpCupzX213sbcVMB8GA1UdIwQY\nMBaAFHiGNsDQ0qszg/3NF09WuzkEfwMzMAoGCCqGSM49BAMCA0kAMEYCIQC4Zc+6\nF/VfkPiMNNdxoJ4BsDY6baf5jyJK13GNus1jOgIhAKfj3HV53/KNs/XEKYLrLKwJ\nK9yAvOUTZTmRuRRZgKWN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXqUQwBPDRzHnIitIS1do3tFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTk3OThjMS00Mjk4LTQxNDAtYjFmZi1iM2U4ODM2N2U0ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaVAWSNMMUqZOADVWEzGrTSDpJgCAauQMXAIRsbTbxGobf\nkuHNZzjZ5/HBcTHW3GZJXoZdrOCMC0W1Zk+KEOf3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeIY2wNDSqzOD/c0XT1a7OQR/\nAzMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALGgIqJMuDLoiH7GLjc4dxdeiP/EYuf1aR9Xq7G8An40AiABvK6gx80Z\nAJOuzDs2KUUff1xjKNw60hQtAa4ikUMalA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAfrqk5gACf36Io2SYw0f14u1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE0ZDA5YzMtNmEzMy00YWFhLWFlZTYtMWM0ZjEyNWVlOTE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY3MWFlNDhl\nLTgxNmQtNGU0Ni1hYjA0LTVmYjIzMjUxZWMyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGXRffurDiTmK4XQZbsdE18p/EcYO27vsJGTqPeBgdLJ+tVfIIBlWyv1\nvUNcytCxmr2Vsl3kxpPyRk2uXK4AxF+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGDtnrKi\nQQBhH+DpCupzX213sbcVMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAPc00qZpdsCMaxLu/QHz+aF8nX04qDxClVCwRa2g3IBMAiEAnt44Q1kH2RKx\nrvw2KPCeyan75/hu/TGmGkwy97W0qbQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc899", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `899` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAQ9bLdDMOWfSmNQWU5Z2uHFiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwZDc3N2Y3LTJmOGYtNDQwNy05YTkzLTI3YWE4NDRmOTY0MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUxMGM1MWQtNjZm\nZC00ZTIyLTg1OGYtMGE4YjI5YWRmYTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/2TW8r3W9SjwAqcxUJaTwYXABQ21FrdLlOIrg53sPzpRHs2SeJaiHxkF10FT\nGZ2icL1AMGVtoqU08c8JcSl4o6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC4myqThNq4rNNvT5a40ud76ebGFMB8GA1UdIwQY\nMBaAFGQc2GhTDVonFQrzgmPBV1bh9zWnMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAQACwfrimLZ+7yF1wDnpCb8OUypP5JxQJD\nsZmUeIYzCQIgcHdS2ir3hoRW6wiHy1pRlq7uXh0X4CiY5Fl+iHljVWM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVhgeLPqPPDhZ6Ds2R3XO1AnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGQ3NzdmNy0yZjhmLTQ0MDctOWE5My0yN2FhODQ0Zjk2NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeRRZM65UjT81nXgNXyOByXD1H3BZmPL6H8huP91Hdcli1\n6M/FQSTz4uZf31dlk+dbBL5V28PuOG/tsD36V6dso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZBzYaFMNWicVCvOCY8FXVuH3\nNacwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPnpy1bgqTPhLZ4DyuBgANCy9AahJXJI/WntXu2HBuqNAiEAtUGO00y7\nvkF8vwSxpU8BPZ9Q2VTICJjnFBWrrffIL00=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAViJc4YLoRGmdB5luzMNAYZzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUxMGM1MWQtNjZmZC00ZTIyLTg1OGYtMGE4YjI5YWRmYTgyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ4MzZmZjFh\nLTI3YWMtNGQwOS05NzY0LTY3ODJhNWNkNjNhOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAqqW6L1038X8B6zCFE3S0sGGnhoRggtoL4N+hZxHtt+AeKgrR/K3gVe\n7OcucjaXTG09zVzdXiba5Y4Bpx+t0DCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC4myqTh\nNq4rNNvT5a40ud76ebGFMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAMwDN3vdqWhs7K6IaPO3ZtbntltFPsV8M8ysj4BDuW19AiAw+icvVi6tbAw+\n5J45kI4kQcqv/Jg7b6q36Ubmd8DwAQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc900", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `900` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAYA0gXRn3aWL42D0f9yPJGboMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzOWQ2ZjRiLWZiM2MtNDExMS04ODUxLTczNzJiNjE5YjA1NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhkMmIyM2EtZjIw\nMi00OWZjLWEzOTItNjQyZjVlODgxZGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfTMkA+DDDg7tSYvDZUOjyr+fO5nxI2RxbqzStqI99uzlBTfmDEPvv5OQNppj\n9X5avqiSVox9dbEkT55llcMiZaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN2Xj4Hv/ibbeTTmkZW52XzE2XKhMB8GA1UdIwQY\nMBaAFH6FkbyxxCV9OXQTNFitiMy3LxKFMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAcqCBf82pDpAdNtJ3Ly5wX6FyB1Gvy0UD7\nAxkEWMiwgAIgHPyH53aSVlLsfMyybZMUvsPq6WELgaZlJF5scpdHTkw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVM91tjVXdHmsnwFwjWBGa6WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzlkNmY0Yi1mYjNjLTQxMTEtODg1MS03MzcyYjYxOWIwNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScwlXoH/TF++rqprbqNIaMGQ3HQ77qbGgDcFTHoZIxaBeG\nOwve9vURYTYZHR0HGneFJExBHKdIoC8B/ulZp3Lgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfoWRvLHEJX05dBM0WK2IzLcv\nEoUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgajztvHz1LPmhFENCci5wdzVApG4onVaYMUITDEbjILwCIQDonz8k/1Qi\nuWWfSODH9wW+rJNcXQHpom76ml67FRwzbA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAQtTHrROSRanFcH/yRjbKLgkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhkMmIyM2EtZjIwMi00OWZjLWEzOTItNjQyZjVlODgxZGI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQxMGU4ZWM2\nLTY4ZTItNDYwZC04Nzk3LTA0OGIyMjZmYmNhZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDlX7KTfGkHC9ijCdZwifq/RZy2+ck6WIqnDC3qvWwj4AsDMjSodXNX3\ni4ywFQIQgBXKnhqvfbZ/Osyp2NCzv6OjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN2Xj4Hv\n/ibbeTTmkZW52XzE2XKhMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgQ5XUG2v7XSBMfJgbptVqtGVIrVicCPmknGi7+Vxqc30CIEJ/uJU+kLIsmSlB\n/LoWDqpsGYH9snNS++PgTXD57Wxj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc901", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `901` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAZ1sjpYOqVUCdaM2jnglrsOAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5YTc1MDVhLWU5ZWUtNGFjZS1hMjUxLWJlZDc4MjY4ZTg5ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NiYzk3ZTgtYjkw\nOC00OWQ0LWE1ZWMtMmE3OTczODcxYzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh9m4+AQfD9ZlVcyVLEbvuJ4APbOIRTsYWtLUmkcQZhRFxOPcIcAVXRInnl8q\nMv9RZVruqdNb9Gv+lf8b64cheKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTuOPLXXmIMFs8UZqzDWD10SYaHjzAfBgNVHSME\nGDAWgBRaIJFMPTvg1Y+FyFkiOyzH/KBBkTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAO7mydvnGW+ImNF25ad6idn4KBuB9NJ\n2CIv+H9S7McdAiBNvnlrrMV7jwHVAdwxrpZRGlD3Te3aRwsoIdyMdsO2RQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUirLPsEdSpIri3VtBWfPZqNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWE3NTA1YS1lOWVlLTRhY2UtYTI1MS1iZWQ3ODI2OGU4OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/FyXgAvs9Kcemk0L7MkWtTJ1gP1GeYCj6qkuwOV1yH/h3\nqgQyk5rDkVLzpxHRda/2s78qeC2BvmlAfLIaSDCRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWiCRTD074NWPhchZIjssx/yg\nQZEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKCHBSjbJ2n6gZJLta0qsRS8OoVx9lUovx+HxmZDDnFfAiEA4iA3KxAx\nflhPEevZu01+osrB2Pn4mP6j985ZkFbenaU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAd6Z25sdlfP1LWYJG7M7WfWUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NiYzk3ZTgtYjkwOC00OWQ0LWE1ZWMtMmE3OTczODcxYzJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdmZDNiMzk3\nLTZjMjMtNGVhYS04MGRiLWQ4NWI5ZDg5MDQ0YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKzZjaIss/jlUHwo6BltREayv+6tyt5++pnVEyZhSE6967FwUGMifn7Y\n5qLu8mW86Cd3fwENbwxWEfDgmHCJnTWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO448tde\nYgwWzxRmrMNYPXRJhoePMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAPbLJH+hCyL7LsWHSJOMZyBezxhpIvRxvTPtsRtuzMMBAiBIe1TR3TKKxp4P\n/jZ7Bv9ZlGQ1h9lTdq4SrMUbMsQQTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc902", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `902` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAYjXgtG+pXm1adusjviH7jJcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NmIxYTFhLWVjNDQtNGVkYi05YTY5LTE5MmJjYjExMzMzYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc0NDU5YTktMjVk\nMy00NWU3LThkMDEtYTk2OTNlMWY1YmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd7qv3McnDP2S916curJKk48dcuIYs7dCd3iGrau4MWiOk54pN0Ps5I+bcKAR\nzkEZFIdffPu56YSC81GKocOJaqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV4jyBcJDHaeVlnrXOhLUhh79YGwwHwYDVR0j\nBBgwFoAUyyDMLzDhJeD82sDJ9yMY+Y0P1MUwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBV/JPPLa5/9Hh5\nZaKA2cfJYF5MVhBnU8NR0qKw2we5FAIhAPeLy7SHEZVLdYG76LYPE389dA7j9pbc\nNAWGLq8yj/hu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVOP6QuFiBlXpy2hh4yOxmbgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTZiMWExYS1lYzQ0LTRlZGItOWE2OS0xOTJiY2IxMTMzM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBA6lzK+EXJP8/Cjy7nrpQtklkMYNkIsd6tlTniqvY1cSO\n97ExuAsYzHC9Lm27j13PuOrDpr8jELxjnT71q/6po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyyDMLzDhJeD82sDJ9yMY+Y0P\n1MUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbQyyDrPDaCMxwbmi2C/OJ0X/FagQM95T7/Zwh+Lh0DwCIQDS1LbNzpvb\nVpylybakNP/yMzG1bE4GqxDCDTYkvuNu3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAYyGVBn08703t5HcsGCb+B5zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc0NDU5YTktMjVkMy00NWU3LThkMDEtYTk2OTNlMWY1YmE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZlN2FiODZm\nLWM4NjgtNDU4Zi05MDQxLTYwYmQzNmRlNjg4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF3URvfFw99KDwgJyf1XbrTD8CcAr3wEzlGPZX6F/UH7ESqExwprZafn\nIgtPNETiH5i6/j016aCFh+TMEtTVx7ijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFeI8gXC\nQx2nlZZ61zoS1IYe/WBsMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAN5O5qHJu8toQeB1jn7t9BHCs79vLbqwdm1AaiCd1kMJAiEAiGoGvvXKsSSy\nwYy4eN5V0faxKP7fZVqq0hUWUZvypek=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc903", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `903` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAafvWq+B2iP1XgMAn1KkP8RbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NThiZDBmLTE1ZTItNDAwZC04ODQ0LTE0YWFhNzI2YTkzNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFiNzRkMjEtN2U3\nOC00ZDQzLWFkZDEtZDg4ZDNkNGE4MmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWpH3BtiXjgVGYCqKhCCI5t89IDwYmxbLQI+1MoB+HB+CFkmwerV/vCkcF6Cl\ntCV8WtTxeOXkdmpISO/Ij4G+GaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3WYiVyRY3KEZBFGHTVZMHRuKAQ0wHwYDVR0j\nBBgwFoAUutifSvJsJoQ/jm+f1hWe2WBnOpAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAjL+uze/0THgR\nLZw19YlecG3ArpOVK8wT/TzYwNDsO0ACIQCIemdUib6106HMyTWOGY0bYWsFD+e1\nCcJSdfPACGnp+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc3rYtsTmLzEk4CyeyJp1agAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODU4YmQwZi0xNWUyLTQwMGQtODg0NC0xNGFhYTcyNmE5MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTopCQdcg9lzk6ttV8c9QOqwjR9LbQZqbIiqfgXxpl37w2\n43w47RW4QTWJ99UCxb9CHSRP6q1N7AIdE75YrptPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUutifSvJsJoQ/jm+f1hWe2WBn\nOpAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO1sXb2vTT5hWYAnqr2axShAHicyZlY2KNwYm570TSUYAiBJHxrMEVX3\ncyV8hvTu8XTReGdcENqdaUSXv4//R9BIXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAZBlRYfsMjDNdD3hIjDz+U+4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFiNzRkMjEtN2U3OC00ZDQzLWFkZDEtZDg4ZDNkNGE4MmI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk2OGEzZWY4\nLTQ0ODgtNGNkYi1iZWJhLTYyYTYyZjNkMmViMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCFh/PHZFSbVcffaR8GSqlBDrKjXadumm3hb3u0j/7jkjEsbFFrUIM/w\n04NRUxP6jGgOMfUaZojl14JM0aJHma2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN1mIlck\nWNyhGQRRh01WTB0bigENMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgVd4WPH7KuFiyiw2jU65dqmbPmQimWPTqtl4sxTpDlTUCIBMSwAkhLSgB4dBr\nv9aQttaFO3sSLp2opMNR0GkfYLdM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc904", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `904` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAVhcLKtnHekNhJfff+r7Kn1PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkY2U1ZTI0LTBjZDctNGJlOC1hYTJjLTQwN2U0MDVhZGJiZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBkMThiNjUtNDMw\nOC00MGFlLTg2OGUtNzU2NzMyNzZmMjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfF+cCojRLPjpEEEGm8Nx10T7fmNIu687oniTRdXJxNQeZ41C8rdufP71wzsF\n7+73NDmwGcdgBtxUErs4khc6HqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrgcF1jYFw4W4jmNkYDrPqMyjQigwHwYDVR0j\nBBgwFoAUZfoUQNMR0dtKzVFMdpe0ot0hyLcwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAgxSgHcJIQ/fq+Ge5c41I\nAwU80vQ3Ou6QRr/MTRDthNcCIQCPrSFXnFyMsEIfGl0SYxM1bSacgO0oo8QbkSci\n6kGzhg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeoKpIHtA4o7YbeAw7iBbki4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZGNlNWUyNC0wY2Q3LTRiZTgtYWEyYy00MDdlNDA1YWRiYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8nY2vih4aav9JATfeZe9y95fgWXnsHQNyJ0IJMKNTmAdE\nmsYQwPchFP3UPSRGpVWRT0E2Ay/xab83+EGHnkFYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZfoUQNMR0dtKzVFMdpe0ot0h\nyLcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAISeLhyO4qj8zvrWsHAVBI3P4NXzTyrwfkLqbq3IMC+rAiEAq2+UqClA\nUaUXTS5UjmBaGYkeRq6iIAEsBDajVYLNzD8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAeIKRy+wDbEqhOo7z+0ohnrQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBkMThiNjUtNDMwOC00MGFlLTg2OGUtNzU2NzMyNzZmMjc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkwODI0ZDQ5\nLTc5YjMtNDNlMy05NDIyLWYxNWU4OGFkZGFhNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG58zq81aRogwQjDNoaGOaqBSvwH6fwj+ZGROKGePH3uUWVecbd2qJp1\nDlDrKRN9nZeiriF5asqXXcO+wj/5N5GjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK4HBdY2\nBcOFuI5jZGA6z6jMo0IoMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAMAqOhZJQuUPw6x4lXa8xG/aq/ohUY5g/x0pmt9CzX5/AiBCZvxp6saGhufo\nWkvaBRU2dKXDHaJGu1rNEi3GasW/Cg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc905", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `905` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAaxHefiY/aUfNu19llu7hUJcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkMzE4Yjc0LWRlYzgtNDI3Mi1hYmNjLWY1NTYxMGU0OWNjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjAxMDZhNDktNDhj\nZi00MjUxLWI1ZDUtOGNiYzQ0OTQ5MDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzFmPKsp4eatGnKYOnnabzCJdlGMQzGoXF4dMkRR2JTySWWB8DWeyRkhKwtuD\nQodqSDN6Zb94Jlusv8Q37p7JB6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbb9xf0HS8XRVDyQhtGMIr77W9i4wHwYDVR0j\nBBgwFoAUKGMfPuO58DSiK3EIkUUNW6DzTKgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBtMDbw\ngOVnsi0Fsf15iAaH2oDrQMJscKpEpGcyJOYH0gIgQsRvMew/dd+O/jz0ghBQuawW\n9xgw5XDulP2IiLPVeIE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ1jTbGAmp8PCIaY3gLOToe+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDMxOGI3NC1kZWM4LTQyNzItYWJjYy1mNTU2MTBlNDljY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHMF0miupn5uIq/JfHwLDfff+9ptKjR+p/w0if24aFz6Pj\n+ayqraQOfNlGj6h8qx3zcpaYAcaidDU0iOoAX3vvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKGMfPuO58DSiK3EIkUUNW6Dz\nTKgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBG4WGloYC2FIptJ0v6S+NsCYQpkIyqgSfQU59aYybr0CID8Cmwdve5pu\nMgxxZVhFvvrNiyioDQ97MW4vohfrhjCU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAa8nWxMjEFyxHQ4tUmCUrfFsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjAxMDZhNDktNDhjZi00MjUxLWI1ZDUtOGNiYzQ0OTQ5MDBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNjZTg3MzY0\nLWUwZjQtNDYyNC1hNjY4LWZlMjQ4NGU3MzZiMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH9b3gQv2z2IrcCWUlgWP5h2qG6fUdETegNI+dvOVH/RrUNOoCPEo4Gl\nXpItD5wsMviFlEjsg0mKtTUe1lw2//KjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG2/cX9B\n0vF0VQ8kIbRjCK++1vYuMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhALLWL8XloB2J77LZY+RlHKepYGklr9erXbfu4O3iWBPpAiEAg2w7sjeB5Z/V\nr/7Aj7OXqGLUu/pF0ZodYHgDOf5454o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc906", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `906` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISASJgTmPElPvBdvtJrPawccWRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0ZDM4Y2RjLTIyODUtNGUwOS1hZDExLWQ4Mzk0N2UwMzYzNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhiNjczZDktNmIz\nOC00ZDRjLWFiM2EtMTg0ZmYwMWI1MGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9AoqIBTEAmSs98K9OE9xw6RN49wOVPJUM1aAqgYKsPA+IylmwKzU9eXcL5uY\nVXm8HWESDtl7Op+Rok7Jmv08+KOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2fDqIXVAjnxqE8zYuccxp75CsBQwHwYDVR0j\nBBgwFoAUbiC5mStcoMrL2e5bfRkLgoqVOFwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBkclPW\nKtatEAGESTTO3zm0UdSxcNl23RyRnsxWUrc4MgIgLpiUGtOpPqNpt/k85kow9bhj\nW+qq9JExgSm5kozWNSk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXWW87/5WrpOwQGY4rJX8w2SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGQzOGNkYy0yMjg1LTRlMDktYWQxMS1kODM5NDdlMDM2MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwFbptZ53WVeF0hkTLfJ6kc3fZiV/PpU0cOGdIYyEtuDfQ\nmd+9bB8RDUXK4+CcSJYaqDbv+arKIJSkAHOoavDDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbiC5mStcoMrL2e5bfRkLgoqV\nOFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYW7Lzn/GttPMrkxhsV1OGleWU1BdQUgChvTDlCjNSNECIEulW7TQDCm4\ndXtCmvv69UmdSvsWXKCRWrwp3YBNeWyT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAUciwJ2OcncRyEbJxo79WK/5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhiNjczZDktNmIzOC00ZDRjLWFiM2EtMTg0ZmYwMWI1MGQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU1Y2FmZGYx\nLTM0NzctNDUzNi04YjgxLWJkMjVhNTVjYjcwNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPHhM3py9zBsURBfQ9xgAHR32R5Ut21gTC3SJVDPp3Q9EfHcmC7E/gmn\n8362hZWFgAOSRU0qSkum/mZryS/FM+ajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNnw6iF1\nQI58ahPM2LnHMae+QrAUMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgeO+Gdaar1ZFB3K+6n2+Ew1S1cXmNMmZSmhpCrHMQIKwCIQCtJQ273lh+LbDi\nd8Nvd08fRrYZPQvOTs/Uc1DJNczRCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc907", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `907` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAb2+qXob3evktBXDYQlyWjWlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzYTFkMzU5LThkNWItNDFmOS1hNGQ3LWQ2ZTQ4ZTZkN2FmNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjAxYTc4YzItZmRk\nNy00MmQxLWI2YTgtYTM5OGYwNDdjNzc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7dXhR7GfNtzH5z2OdWHw01IG9wlvP1aZse6ZD6yLm8xUR/VL2YfLyDLgAN/d\neCh3CUeI5JLnOpsEaWcKhJP4GaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDcU/I9E7VshGooeX+4kMaciZfOgMB8GA1UdIwQY\nMBaAFAdPXdaKgaXLV7YZGDySCSpaCXFhMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAtL0J+yyhWdETMa/iPfepZB32L/uDi3W2\nJU8QrXDpXk4CIQCtZYw8+UQffMG9xTMuVk3LR4LeKm9qxFOx5sAajXK3jg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWyb4cqITF8bIOwHdbaWidcZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2ExZDM1OS04ZDViLTQxZjktYTRkNy1kNmU0OGU2ZDdhZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRW/m6DsZGGajRO4zjrNIAhJCHZW+Z6YDPd8Bl0xuhVW2g\nSoqAFLXCu53dlmFypycE4GDmbuq5QWpUeYfV6zmZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB09d1oqBpctXthkYPJIJKloJ\ncWEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJUPddKgFVy1V6f2LW+/n/+heIvTp/V0vodn7m6yCV+6AiEA0LbWX8qJ\nLAVdRxRtT85t/SVrse9nzgO1pQzhsDRLGZI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAepYKK+N78FzroK+Kob7rzGNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjAxYTc4YzItZmRkNy00MmQxLWI2YTgtYTM5OGYwNDdjNzc0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhkY2FlZDQ4\nLWY2M2MtNDA3Zi1hN2EwLTMyNmZiZjg4MjY4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMw4KQUifIC6BGG43R2eCxLJP7R7JXO26ih4RKPSF8dwMkapTnZN7BAl\n5st5alaZApxF5Bm4OBPg8KO0i6ljNMGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDcU/I9E\n7VshGooeX+4kMaciZfOgMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAKTAErCWvraweQrQqYLrjH7kts7pRfzmN/Ikdf+Iy2l7AiEA+Z9umUWOP+92\n1ZBdgyjOwzwKb7wUkjWtLyZuInEMAkw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc908", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `908` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAe0HFBMIYKxJcIRpAvPPFF22MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMTNkMzMyLWViNTQtNGU3YS05MmM1LTA1MzAyNDBjMTk1NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY0NzQ0MTQtMTg4\nNC00ZWUwLTlhM2MtZDhiMjlmYmJlYTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdunbh6rZRSP1oWB7Y1NuI4NBXEte4yEbnaMcw+IpYSQreBZFHoB7kXhLp4rP\nbOXU6IiM2fGpQ0MP1sccimaUoqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUob90RVhHBQmfJ5zlgO/SinSkCNowHwYDVR0j\nBBgwFoAUxLeC9qUimXzVbkwJQLJm85qJnVUwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgKJFtWvw6TFXR\nT9xP3piBw0xTim8zmHOX+bPBsTRC/tICIEwySYWFL9mIYfQm4zMPaN1k51YFVgn1\nBd35c7EQKs1y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS00NokPnTzhhrByxGoYYEVXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjEzZDMzMi1lYjU0LTRlN2EtOTJjNS0wNTMwMjQwYzE5NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARr6WwcSLKewgBTBqB4MH7l3ANE0K+ehxcmz4lBYl/KKe0+\nPUtHKSjrH//EAJ/gyg/yPzZzWMwd6idR94foFuego2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxLeC9qUimXzVbkwJQLJm85qJ\nnVUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOn/kMwzNklo2YfSu6ZZ2nmQ/Vs6de70rCugQnZZ/BmhAiB+DJbAH1Pe\nwubOZojT7DrmpSDEG0YN8LqHovEOYRBmYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAQa4PxqYDlWBlV9O3r9y/YLJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY0NzQ0MTQtMTg4NC00ZWUwLTlhM2MtZDhiMjlmYmJlYTllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdlYzRhMzMz\nLWMwYjMtNGJlNS1hODRjLWIzZDVmMWE5YWQ5NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAMHE9Dc6BZHlxqpnI4BSbojVrh7p+XnT0VTeQiwv0AGKkFqq9GR2Aum\n7B4r1uLw2ar1vOs5wDbKkgFtW5pGxwajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKG/dEVY\nRwUJnyec5YDv0op0pAjaMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAKD92oVHN7S24gHYTbEUbDAdi+s2Uo21GIYb9MJIZqjvAiBiz3kclx2Rhe0s\n7O1ZRExt0CWuy1vlwJa9Q1bJoQVIFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc909", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `909` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAdcn0M1dP9WZ9sURrg+plrJeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmNTIxY2VmLTBmYzAtNDdlMS05YTFkLTIwMTJiY2ExMmI4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc0OTRiNmUtZWM1\nYS00YzBhLWJhMDEtNjM5NmVhOGQ4OWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYftS7hQERcFl5mnR2j5neg1COY/YmQqw1eChFPjEUzQofMMLjRBe5xa2svKF\nC7EMw/qaP2e2XkKVl893oqpPn6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB0ZVd+a3YcNdb13Ypu7Xboco9dwwHwYDVR0j\nBBgwFoAUs+MsD8kIlLjmkd3h+EWG7Wm2GOIwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgEmz8dTKhlvAE\njHSDI7fYrbZtt2fZvYC9f9cR+JKENCYCICt5qPsx1lYv3LfAL28zsyriK4fg/jSG\nDrhtoruGOwgu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASyE8jlj9R5LuRgGs1D595uTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjUyMWNlZi0wZmMwLTQ3ZTEtOWExZC0yMDEyYmNhMTJiOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuVYPBmzFnsOUzqewEVLgleaYg1ppj5gA7hZHFEO1T7IfZ\nQXGi2+NDsEjchC8bZrA0JKMdXqriyrBJJdkCXUrVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs+MsD8kIlLjmkd3h+EWG7Wm2\nGOIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKz4ICiU/aBUmpWJ5e2R73YoG5sXSggvkX12FP/oqkTNAiBkgZ3xFWhN\nob7nh7Pj+bxWQoUTBLQfS/wMnPRHcJtGsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAeqTd+O+be1hm5hOIhIKQ3d1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc0OTRiNmUtZWM1YS00YzBhLWJhMDEtNjM5NmVhOGQ4OWM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg0ZWVjZDBh\nLTA3YTEtNDMzMi05NWVmLWIzZWZkOWQ3NTlmZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABACLO5SF0tb0BUlUft9Jp6E4Uu9XcRB3xh/IAqJ/Xn0ut8W4RNV9uxOF\nPXSfBD2cz7MrV4jXQUrSJOdCD7FSIiCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAdGVXfm\nt2HDXW9d2Kbu126HKPXcMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgew/tAu316TZHi5tvC4Rv8yNo4Zh+bMJOeUV1bWzwMmECIQCjRe063NQ6axlc\n6NdiVtYnKOpDgv1rWrC1cT8nOIRM2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc910", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `910` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAQHy9FJnE9fe0UxAGRZ5bmotMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwMDdlZWQ5LTgxMTUtNDcxZi1hZDYyLTcyMDNhNjliMGEyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE5YzUzODAtZTA1\nZi00YTY1LTg0MjUtZmJkNTUzNWQ1YzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQZtbI13l9IGD5MtiCiwH645FLC/3cYM9b5bB5N8zcVRC7DG1V/LH/CgFUFce\n1C2J0y16WyseHJA1+zIJcLlRvqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrgp/yxYDeSN06W+bnnbbEqXC7nowHwYDVR0j\nBBgwFoAUeauwYhVc5mwBxL4gqRh3JsRusH8wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCX763+tMZs\n7aXq2kDgom49HkpsYREfiW7E/NttZUD5UQIhAL2E6iCIP7ArthCr/zSRBovZlKsk\nYst/vFlRFSL/TWIe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaHW4HoV+5yXjd36tBOBfktmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDA3ZWVkOS04MTE1LTQ3MWYtYWQ2Mi03MjAzYTY5YjBhMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgBse5vGsfARbwHjC4f2GjxCyCfSltKEVGM62SGfgdkudc\nusBtFE7k41Vc2nK7GPP7auFYY/LY6612iQOOLp4Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeauwYhVc5mwBxL4gqRh3JsRu\nsH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI7XY1OdZpow1ZU+sAmYNq1gqr//rDT/wzHlbUJy0RskAiADziIhNmZQ\nMvBGh0l/AX07FuOhRmlCgSQJNFjNhnlfRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAbKjQzPSXur+F9vWr8HuqbuzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE5YzUzODAtZTA1Zi00YTY1LTg0MjUtZmJkNTUzNWQ1YzY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY5NWRlZTk3\nLTNjNDctNDI2Yy04YWMyLWY2ODc4MWNjN2ExODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDHjDQQzToVlxrpLIqHZLRUupYJiS5vTFpFEEObYeVyB7Yu6/dnRDFg1\nLGloKLO2tZ42VvQBP/9ji5mcYbLHAoujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK4Kf8sW\nA3kjdOlvm5522xKlwu56MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgG1q3weOfl7NjjG1jkadVdJi3k4QXqdOtEkV8o3IppvACIBAkGC+JqNP8c8YN\nq3ylZj5VB7S8dAFzMFJ2leupPD9g\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc911", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `911` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISARE/3kHRtDnUQcOf8zJMB0b2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlZDI0ZmY2LTZiMjMtNDhhMC1hNWZhLTE3OGFiZTY5ZDIyOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNiZWVkN2EtMmQ5\nZS00ZGU3LThkYjgtYjAyZDc5ZTBjNGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKQEORRyUW1YDW5TdRLCn9pXFJePUb92X6KKvOQlsKYnVIyTwM8+BHc4SqYus\nAyi+X+mvjZBT9S/BMroszv7F56OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj6DNpzmh00ByhupbnONa2RiM/8wwHwYDVR0j\nBBgwFoAUsD77bibkoHmCT5orum0+f5KqXxowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFfCax3I0odkgEzneVEgEhzWDpWHL3Tn2VCbAskfgJqQAiAM6tOSjLrzGh21\nneE8e0Md7DaVHBE4bnrQMxDPYRSrpA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc+T53JX+988M4g2PY7GW8a0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWQyNGZmNi02YjIzLTQ4YTAtYTVmYS0xNzhhYmU2OWQyMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzDgNBaxYD4gsJbKfsTbWcArVfujZ5Kt2CuvSkUjPzXBfa\nrIjVgvdy17I4uWc1rkuQ5q+EUcsB/Zltn/fZZg00o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsD77bibkoHmCT5orum0+f5Kq\nXxowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALgNYY7jpmPUh58VGAGAy+gvVPVV1Il/v0LKmYsrEB3EAiEAxDrwjQE0\nYxcjlBQpCwGIQcrEtQmaz48dO4rnJKS7qXU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAby9EdVaBlAfcyIYpCRRAv0ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNiZWVkN2EtMmQ5ZS00ZGU3LThkYjgtYjAyZDc5ZTBjNGNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMzZGY5MTli\nLWU5MjUtNGYxNC1hYjJiLTlmYTgyMWY1ZDliODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB8wFIYqMMF5w4ZE2LLf6cx8kaNERqf2cqD3fEwH0zfg1YXbntSuExOP\nDcxM33JPqMJNYpSbIL80KqyK1gdPSU+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI+gzac5\nodNAcobqW5zjWtkYjP/MMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgf4Y22BueEf7LdFT9YTLdbejANwsmEVfT8Ab+igygWzMCIQDCmSU7JuxFaoGb\n1ApDNuZiUAWr6MIG5Gb+Ef8MQQgwJw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc912", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `912` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXa9K2B+hjatCv8I2oNdgs55MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4OWEwNjc3LTM0NzctNGExMi05MDlhLTVlZjA4YmUyY2ZmMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2YxYjkyODYtOWFh\nMS00ZDdkLWIzNjQtMWEzZDM2YTE3NTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF4eGj4xxezYXhfc5Cb3PRhUNSb2aUmVEbqY6bnkYljiArLoZZYi1wkQOtjpK\nnmGwjAcWqNjntg9m2yB6rV9sx6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEr33bWQ7VvU/qUl9Y097mxfHd6wwHwYDVR0j\nBBgwFoAUsYiFcFQ/hiULgKrftmynpu5SkW0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDABcuSsIE1zIu3jjxCn3mG3iKkrHcFiUZI5WmRe7njlwIgQLV8Y6AuhLfM\ndG65vdMZRTJ5IhGIqKps8SKU2UiMmrw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeHz+Lcw0a6KxhSm3Ael94xFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODlhMDY3Ny0zNDc3LTRhMTItOTA5YS01ZWYwOGJlMmNmZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATv4zIcdsO0BAub1cs1uqfLiyqewhZaPgIiNttbWSb5j1QH\n1kQUcy6S6J+aSlMR0HjZQwiBrjG46M4ulkGFtzYwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsYiFcFQ/hiULgKrftmynpu5S\nkW0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANO7HOWrnUM3Ol/dnBrpgyXzUg24dVYlkuRNazCefYobAiEAm8GVkCzM\ni73spLDamN96MZla6r8iZjwz1PDD1V9q2HU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAenzdspazWclG/yPOtpZU6YaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2YxYjkyODYtOWFhMS00ZDdkLWIzNjQtMWEzZDM2YTE3NTRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRlZjYzYzZk\nLTAzZDMtNGE2NC05NTk3LTRhNzIxYzczMGRkYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKJLYMx+wpSBVjXe6HliEZX7nTd1uEes2qrfnCyOMRUkWdOut+KPT+D9\njHZQCbcp2lUg4MpByxteuzbbH5VF2eyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBK9921k\nO1b1P6lJfWNPe5sXx3esMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAOKnEHP9y04ZssxIrdk/KInNJzKhF26jwE+0WMI97k85AiEA3uF+jcvPpubd\nXlx5+zAzt2HjqBkVwkakr36tu5f0dSU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc913", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `913` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAdQudGWJbk+7E5O2f+Kt8k7QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMzY3NmI3LTJiMmUtNDRkOS05ZGY5LWMzMGY4Y2ZmZDNjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU1NGIxYmItMDBl\nMi00MTVjLWFkNjQtZmNmMzNiOGEzZDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYbTSujOjmY67ThVVNHHiIJ7QZK/VcrVAsxsszEJFpzQGt5KOBdQxIg+r2wJ4\nqnbLttUd0EDfMoCr9sFwcsi4pqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU29pv3V/r9COOF+p3ZOvYAZo5bdgwHwYDVR0j\nBBgwFoAUu5AFqSLe8boNCtJ3U+KE3V+l/hwwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDd\n2EU3mYDkvP4Dbv6DP2WBYEj9g4ve+8RTzG4eySKIbQIhAOJaBkYCI/13wF+6XAo7\nR8yz/J7o+iMtyAwUN8ynVdl2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZxw07beII1FcXZhc91Hf8I0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTM2NzZiNy0yYjJlLTQ0ZDktOWRmOS1jMzBmOGNmZmQzYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0rJSQ15z31UgOcDtABnqgEpD3JP3NKsYMXz64mM3AMdli\n8dQMdwWzu6bZ2/aStjwr+H8r95TW5p6JbCM+Uq7Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu5AFqSLe8boNCtJ3U+KE3V+l\n/hwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM5KcEjXXU+nw8E85dxjG+5VMCfnM8Fxqpgg3faUhSKhAiEA0EKqh03l\nKxfbEkptTdJRMNb/jO3LBhgDjWsOywTawhU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbABBUeDQs5ZD/+DFWuByrGeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU1NGIxYmItMDBlMi00MTVjLWFkNjQtZmNmMzNiOGEzZDU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQwMjQyOTM3\nLTUyMDgtNDZhMS05Y2Y1LTM2M2ZjYjhkYjI3ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHQ4wbqkF50ubVo7Mo6oQDP61T34zZSSZzCIIO/2Edr08MzTpYNo8Lr3\nluPx+tblDW3q0v/HqcuC3c6SVaFMX6SjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNvab91f\n6/Qjjhfqd2Tr2AGaOW3YMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAOmiWBe1qrAsUyQglfTlnrCtd9tCpydczGl4BtVwrp7JAiBtH14KmpzQFVmC\n9CQW3J8s7Vz7vdRWLBLqBR4CqfitbA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc914", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `914` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAdmcj/bq5Sn+Xx+2Suzk//fsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzYWY3OGI4LWU4OGUtNGZlNS1hMDIzLTZlYWViNDZjYWUwMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQzZGYyN2YtMDBk\nZi00NWQwLTg1MWQtNmYwNDdjZGZkMWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQbuIAt3A+J9eMoN2qtat2JG+LtqOaffFSTwvJSilr9qe9ZgEpAGWhJoEbPtF\nx9vb0h3OJI5fq2CLKPvGDcdliaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSrE9I/DQBbZzv2/Yab45Ekrz2wkwHwYDVR0j\nBBgwFoAUf8z5e1BEiiSB5sUCdbTkjcojcL4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGfCLr8hPKwAYMB7yu3qmE+8GumBqUYi6tltcSp77xyIAiAVbVDP\nUc6BfWk7P9dF5ZU0GNSZgH85g/iMb4awfVXuAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYQKsIxi2aj2jxwj/2ebhp0QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2FmNzhiOC1lODhlLTRmZTUtYTAyMy02ZWFlYjQ2Y2FlMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0onErASc4I7xn6zdT4bBhR1rZjsz3fqeBfFZwTODBTRv1\nL3yM2G2RkkjR4K18Ijrx5935JgPFxSAX+PJo0z6po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf8z5e1BEiiSB5sUCdbTkjcoj\ncL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMujc7AUNKr9NQ+OG1QsvXSbgGQZfIKBjFZH0WxlUGJJAiEAgSKU8j6a\nQl/kGuTZEuif68GR3bdc8QDKSdI/hHlY17E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAcLkxQy4Dh0AuIphLPjm7a6VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQzZGYyN2YtMDBkZi00NWQwLTg1MWQtNmYwNDdjZGZkMWM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUxZTY3ZGJh\nLWMxZjAtNDNiMi05NGMwLTMyMWQzMjgzMGFhMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOTKrMylKn7rsnPb25jQ1h1byRzZwIv+4h08YOphoUE4NUxR5TC2NF4a\nIjKAkNLuemTMn3C7rIhvWsKEUHFgfgCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEqxPSPw\n0AW2c79v2Gm+ORJK89sJMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgMWTUwPblZeWNCGyW7987vdvge06J3cuPysbI++gcRiUCIQCtGIPchqidpwgX\nbKN+JlMmN7N3vNnqHmwLaR3C2ED5bw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc915", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `915` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAWqdqwiFlAB339MvyHvWF1fzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2OGU5ZGM3LWRhN2YtNDVkMy04ZjZhLTBmMmI5NWY3NzdjYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTIyNGY4MDktOGRl\nNC00MDBhLTg1MDQtOWZlMDRkMDE1NzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBEBYUj6jeClrkc9cECcTL4UW8QYzToOjKu2YnHZFUjwChiC5hbkJMsosvz3C\nxhSJNpqYIhoILc3V3EhSivp2kqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd3RufHq+mkrYXqtJwghimXqXjSEwHwYDVR0j\nBBgwFoAUD8PgJ9i8Uh9B043YbPesOq4RTdowOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDd8huQQ11n1N3kX0b00BlYC9Vd8tGBJ0oCQJKhCtiOtQIhAP0b\nrzX6kF3WYLJyHtsCpCXQwbh7Luehk5k4EhBejIb1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe7jtjCxFSMiwMm50bh0ZY4vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjhlOWRjNy1kYTdmLTQ1ZDMtOGY2YS0wZjJiOTVmNzc3Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpW/e/p7dN/seSjP0+WqRjWylszQhDPr+xnB4qk0obDI4V\nbrSWq0YJY879InUEBs1sJimciNHJCj3IJAEUkzaFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD8PgJ9i8Uh9B043YbPesOq4R\nTdowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQD6IfHJL08FvCZI/V2dBKQKBIiAgc0hLg0JrB+dcwmUCIQCmAU467aLz\nY/jy+Hp3Nc1dxOH1q6GcTMHRNj58eI0m3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAcnE3MhlcGLRn6vdph/ssDK8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTIyNGY4MDktOGRlNC00MDBhLTg1MDQtOWZlMDRkMDE1NzdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYxM2ZhMjlh\nLTE1MGItNDBhZS04OGU5LWRlNWI5NGVmNmMxOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGcJwxgm/FmeeDplQR2ggV/Um+DFkyqs6HIs9JX06Yev+LjzVSthVP7G\nhhip/wsX75xb8KNJUZNUWwcT+LrVm46jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHd0bnx6\nvppK2F6rScIIYpl6l40hMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAItKri/LIkFyWLnDBHyIgxpdRKVxQnhUxhfurEr3AYPJAiEAsPlf+SY+5FCz\n5eFs8ioxVXHEkyH82jA03OJnSvm7EEg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc916", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `916` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAbPPlpuVp90OZnUehcZRUy2+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3MjI0NmJhLTk4OTctNDAzMi04Y2JhLTA0Y2E1ZGQyNjE3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGJjOWEwZDQtYzU5\nYy00MjgyLWI4OGYtMzQwODBlMWVjYzBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIx+5R5iZt+Sw9/H+hEWmtQegszIJmObHmQzCboBu/DlO7ggPoMHAFloA7jlp\nzZB7zu/STn6GytnItI7Qug3GeKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFL/rbJqumDP4bhqCqoiSPpL92GhMMB8GA1UdIwQY\nMBaAFNqp/hR4eEj8X2CbYGMnla7hxgFHMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAxchyFPywnvm4/aqyw9OrEvTkwUPq0cg9\nsfFe0rE+D6QCIQDFNzEBmT8ny/oGvihbbqhcBztbArEGc7dE+fLIxVvfSA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYqsVqSzADvduLfVgYS1jikGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzIyNDZiYS05ODk3LTQwMzItOGNiYS0wNGNhNWRkMjYxNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASU1x82DwySYRElPRH9YkhfghS05qAykt6iXqEHbhQFYYzq\nhHmfDfudjlJ7RfCAfXWGGkcB36srQ/blA3xGlfG6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2qn+FHh4SPxfYJtgYyeVruHG\nAUcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJZe8TlDZc1hPn/+OdSGC7F/zF2pw/0iUT4XCcYzqXgmAiAr2hJW5iJa\namSnAcj6ZLDqs5p2BECXOdTyavxEUioX/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAUTHZ1PNLcwMNimTDXzI5FuMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGJjOWEwZDQtYzU5Yy00MjgyLWI4OGYtMzQwODBlMWVjYzBhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkODU0ZWM3\nLTRhYWYtNDI0NS1iOTZmLTA1N2E0ZjUyNjcxMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMxyoHGOtN+/NUDrbwAvj8nJrIdNJMEeOjQCaPkoSkFwmAnIp8pqjZNj\nGcQDjdisIevvW94dQtiiFebUAV7Ze3OjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL/rbJqu\nmDP4bhqCqoiSPpL92GhMMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAIPFJ5iJOZtyOlTXAGb9pLx1kucP9tidn+8v56hHXF5kAiEAod9EdwSOIyrQ\nwmEdtG3VIaFwGhDuJVsSMwAhkbJSU1g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc917", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `917` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAQ8tCHUGFL771Z2J0u8dJuuOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZTgxMWQxLTRkMzctNDk4Mi1hNjg0LWUzZGMyZGFiNDUwMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ1OTM4N2EtMDlh\nZi00YzVkLThlN2MtNTNmYWQzOWQ4YTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmGBiZWKzT3WUf7ekl0GRdFZYSnL0c3FmoeETaYT+bGosDzTRNTZ0/2+MqUrd\nik0Y4sh9E1FQAwVkOKSVF6TOeKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYUm9Wu4Zd9lWJ5zcI1hv4qAMPacwHwYDVR0j\nBBgwFoAUylZL48Uy76ufTr/FHUJQc2g34uIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMCmaY0k/vY4\nNnV+vHTgOpcGiYjL9IaAu5bzqoRJPO5zAiEAjOxzls6LDLck4R72tRCjlHHzV/9O\nNZxDkCklDqGb/gI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQlvc5lbTvex2N9CZZtDXO5LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2U4MTFkMS00ZDM3LTQ5ODItYTY4NC1lM2RjMmRhYjQ1MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjlok3t6/4Eq0bsy40RMqacsFZCuawZxOVFDv6EKxTsw0r\nyCtNqsXpxXiREQ4l8iey6kE0mO0KO67GPsshkkxKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylZL48Uy76ufTr/FHUJQc2g3\n4uIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOXVcgM9TsjTt7CBfM6wDBNOuOrUVRE3xe29SlqqYnBUCIQDJftnPedU3\nqjvSGQOKofAEPugTla2r5+SB2UIB4I7Qng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAVhDNxHFt8z/IQg7C6lvyqQCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ1OTM4N2EtMDlhZi00YzVkLThlN2MtNTNmYWQzOWQ4YTNmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFiNDY5OGZk\nLWRmYTUtNDRiOS1hNjU5LWI5OTk2YzU1MTI2OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCqm8zrWL6s3pnJsg4EHGsfTNzrGX8e3FCDiaCtZduwADQ8jTisSIazN\n8EGhFBIEeCWPa7QixtIcekWY2EwrnOmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGFJvVru\nGXfZViec3CNYb+KgDD2nMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgBxGWmeBNj1cLYfpmZg1zzd9YyZ44Q4hQYF3vx9vjOO4CIGT906FgPxgC7ULt\nAt8ylENteC2hdSFBhd8A8+zl7MHT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc918", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `918` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAc51kusETWREVZexgxakXAyFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3ZmE3MTI3LTdkMzItNDgzMS04YjMwLTM0YTM5MGM4MTdmZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRkM2QyZTItN2E3\nNy00YjdjLWI0ZmEtZTRjZmY0MjIwMjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUYfF6va+jo+Lt15Afkvu6sYSn54639StWPZ/aoZCn55ZOSnNI2huOi0vR8sE\nfgdq66WJoP3DE07ZE0KcT/P8laOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr0cSZDQQxt8JrVNjrSeXj/S2JoEwHwYDVR0j\nBBgwFoAUaQ1el0O7rysiCKAH5jE6XpMuikEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAO8gYmM1lwlN\n/oi6QYTwUmY0Je1LhTwfWz2hJa76kEucAiBJvLo1H+Te26PgtmmRpaQmwd2QAObp\n9d3pJLp5LPNbjw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeGRS97aVVp7LnsstHfOUPjqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2ZhNzEyNy03ZDMyLTQ4MzEtOGIzMC0zNGEzOTBjODE3ZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCV/4EmF1Fetc0FMAsPn5DyHk/5SJ6Onh0xk7EvG0o1x+d\np7gqG4LUQLmxGFDWsq8lUUGV+4fPrgr4x+fj77Aro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaQ1el0O7rysiCKAH5jE6XpMu\nikEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIHKZVSxee4a5GIA4LMeNZr9CbNBaEA+VvkBqcJBOfGPAiAsU/CJTnXk\nRlqVx27PNKiNbcsttwgTdeDVJJ1i6j7TPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAW+j/33c6v7y+sPlWL7+VfLzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRkM2QyZTItN2E3Ny00YjdjLWI0ZmEtZTRjZmY0MjIwMjRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJlMzkyODE5\nLTU4OTQtNGQxOS1iOGQ0LWJhOTFkNmZiY2UwNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFdTFl7sJDoe/2MVGwdhC/acRc1tgned/+xN/4LRx8C5Uv24JZ9g+Qjv\ndCjgz3Fsdw3IYRMjeTQzGDTdpqxWlNejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK9HEmQ0\nEMbfCa1TY60nl4/0tiaBMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhALAadCDaUjvkBMB/pEqyI8ZzV4DE0GdWVEloEKqjibpLAiBNNuqdypTT4hXt\nPIdSZCVyHACFUE5xHYSvJtCbaXN1Xw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc919", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `919` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASIGESOPJ1SgZXvdOujlr854MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3MmM0ZGNkLWQ0YWUtNGM4NC1iMTQyLTFjZmIyZDlhNWRjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjAwYWQ2OWUtZDJk\nYi00NWY2LTg2NmEtY2EwYjU5MjcyNTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK7zshlrQkKy+2vozsYc0KuhGTc+6U+S78nljdvUWjiBlsslRZAmQN8rgJv08\nXDrUWwAKS3kc8kkT4hD6UOqHwqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnKwvAqvb/KHJQfg2OwWf+WBguswwHwYDVR0j\nBBgwFoAUghCn6EO9Nw4DE9ZwNUrl+iDyjggwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCHXJ2sOn0u\nRDXLxr1kOMhdKE5kRsL6Unjc0vIR6O3eKwIhAOYQ2WP+t1y9qMp/5bRs8sasQpwx\nced/yGNal3didHRK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ0/XRAdczJ6HU2vNwEt4RB8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzJjNGRjZC1kNGFlLTRjODQtYjE0Mi0xY2ZiMmQ5YTVkY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMp8XAyNFD4BL1XQl4dGgtDDNsFEHrjj2QadaSsrNl2+15\nRpAa3d2fIjVDVAP0ULZCvoUnjjsEFXTf6+mLJab5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUghCn6EO9Nw4DE9ZwNUrl+iDy\njggwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgerFDZGATwZHYPLFgZS1NBBE5pzsQbMrQ3E6mMaBjQeUCIQCMILnov3ro\necBJyaUxoitr36ppTvZQRv1uMjImYxrxKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAXvJoIbfQ85UgvJ/Htx/qjHxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjAwYWQ2OWUtZDJkYi00NWY2LTg2NmEtY2EwYjU5MjcyNTYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFhMjU3N2I3\nLTBmZWQtNDQ3Mi05NTI4LWE5NjYyNmI0OTIyNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHMNkdN+ZjsJw4sCRQeM+Yl/FAAMn7lnn1etl3I2QrxUZV6EQBu1h5ek\nHpPMK+RqyBDhjhUeWebyuPQCs3/WeeWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJysLwKr\n2/yhyUH4NjsFn/lgYLrMMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAORYuDf3GSi6o8IBWMhPRmK4nQ848j1v/osL/tLXze5BAiBLG5rlvcBXOGZe\nDdG+PS7/3Qi5Ngvpn4WEXvbWNrPlMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc920", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `920` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXQB2kR785GNB8Q5DQ50RdLxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxZTg4MmNlLWU4NDItNDczZC1iM2VlLTUxNDQ4OTZkZDcyZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBmZDVkZjctZmQw\nZS00MTJlLWIwYTEtZGRkMmY3ZjEyYjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/qwAvUSXnIlGAlNIHd90RxtrM7c34xc4BzAT7K1T/0E012u6oeQWvPLQZvFT\nQybeKTDa+KuxQZPIKKFSUOzNLaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1eQGG/9GWU6SWaPdJFlVJ3zS+oMwHwYDVR0j\nBBgwFoAUYvuGYfVwtfCm249IYeXb2q5Sa70wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCVqz65zBvGl1J3xXLybf3oeZ4xpsCrmBPSZ3fcS7g9IAIhAMgj/8TKdFlp\nXnQm6wI1KyoJfROe9wI731GcAHIpkpsv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXzHotLn87mxTsSbedmK9vKzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWU4ODJjZS1lODQyLTQ3M2QtYjNlZS01MTQ0ODk2ZGQ3MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZWak840xfmDoBBdpFfswO6R2xYVf376/2pyBBvpic4oPh\nQEot3hRKzrLzvuZeTjy58GnFaMLYh6Cq6itf46hmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYvuGYfVwtfCm249IYeXb2q5S\na70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIzUXBQyWdSPOvGVZWDVl3Y0xXm5XibIExwbjDdWyT02AiEAsb89MHli\n4jZhB4CSz0Tyn5bWig9nR0Qg4xYhFWnQNWM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAZuCsO+V3kzYUpkchzECWtR+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBmZDVkZjctZmQwZS00MTJlLWIwYTEtZGRkMmY3ZjEyYjhhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY1YzEwNGUz\nLTcxN2ItNGJkOC04NmMyLWFkNmVlZWY4ZTEwYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGwQvZsY8szl/sDQInkA9FNgnuTCJ/1/ETjpaeWDbeM1mAa+seFnito+\n6gUqyQWrlROb8qTLylLpFviSvaUplGCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNXkBhv/\nRllOklmj3SRZVSd80vqDMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgIP/NT8DJx+HqV2miCLLXT14z1NMBmSVOkOq+2tEedHsCIBRxjhJckN2JyO6I\nehI3aCW6DkC9enNKfiUZpqGPSf5G\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc921", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `921` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQ9D1uLVe/YH8qygdmMdouE+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1MjM4NDFhLTlkYTItNDc3Yi04YzhkLWY2ZjE4OWM2NWZmNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDg2NGM4NWQtNjU3\nMy00MTc0LThiN2MtYTk0YTA5MTM5Mzk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXdljgzscwYjXf4GUn2d1/NNJB4Qn0umpm6dlWXG2s255hbm3iwKn+rZqZRbA\nuINq2rlLAT/1OTyCNg3FxLb/0qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwqYk8jlsIl95mv5YIRoOmbmu6TMwHwYDVR0j\nBBgwFoAUL/UD88dnl9AzTcSaxSWe31g5/PcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDaYoX+TgHYXFxGaKy3LNPebHhQ6WGS0mcfIfC6cGY9FwIgfRVpMdNkpte+\nFAis1ww6/YRMJR8EOp74z4IUbrVqQcU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcHBMRd2r1zhEQUkP+xz7ShVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTIzODQxYS05ZGEyLTQ3N2ItOGM4ZC1mNmYxODljNjVmZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDLpwmJcZGybzqGsmWWp9TgSn9H9hX8hegZ18eOLFmn6qG\n5ApIxQReYsJ8+mNrF4iNU7z4D0Uze/4xz9M2UkGeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL/UD88dnl9AzTcSaxSWe31g5\n/PcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALkH7pu0+3wS0sjqcZwcoDTs1v8HagiocorqZDhe190AAiEAkXjTKjcp\nlEBQ0l+bWjF6IfWNTBYySQjM+OR5ZyMNQz4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAdWxI8UK4rQGK5+7XnMSnrzPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDg2NGM4NWQtNjU3My00MTc0LThiN2MtYTk0YTA5MTM5Mzk5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU5MTQ3ZGNh\nLTJmNzgtNDQ3ZS1hZWZlLTFjMDJiYWVmMzJlZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEsroswhMKbDk37UBu9qwhasU9kTKCiUR9DpS7uOw0hASqTJSBDZ1uN6\nw3SrOPM/vYpzYO5/ke7A1y6BBCuHf4ajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMKmJPI5\nbCJfeZr+WCEaDpm5rukzMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAIp2EJxSjq+2eqHZIyVBXZws3bufvyLM0p8h9DVdpZ2HAiAvDWEVWnNqha0S\nci4w/tchKRZtAoAdtOxM0hCYPdnh6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc922", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `922` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAZnIOhc2X74b1IdxXvbb8qqXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkZmI4YjZiLTNkODctNGU0Ni1hOWExLTI3NTcwZTE2NWNiZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE0ZGNjYTktOGNl\nMi00ODk4LWEwMzAtNmM0YmUwNDdkODJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/1xLY0QAUz4NUVjiUBW9+O1gjI9nD3+JgI0ia/Z7Dst0p8yl2aQLwLKYDJ6O\nCR/DQNXq+gEz47w46i7ZOf2pPKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Z42ejtKtjAct+DfTrz/Hslti2gwHwYDVR0j\nBBgwFoAUD/ffz5UnAbMi8ocKBTJwfqjktGcwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFtt\nS5MLwyftreacQyaa2C1e6ctQLA1fes6UQEz2nl3CAiEAzs/WLfWP4jQNYR21o0fF\nNH7wGNi8hIxSJ81FPRMxaFw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaoZKJ1Bp5poSui6MxSw4rhUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGZiOGI2Yi0zZDg3LTRlNDYtYTlhMS0yNzU3MGUxNjVjYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDGGS/91guvf2s/j4nYy/fMg4pK1Mx4U6mLkyEny1VWKuh\nSRN37ebwWBIxE/P7MRVYwVqCa6Lz1THblT75D+uOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD/ffz5UnAbMi8ocKBTJwfqjk\ntGcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUrELij4qe1MlzoXGqVml6Gj1yr8/EZoVLHK5+0NCRTUCIA5wE/lcEMsL\nvlxE5CeEhnMVT5CQJCfpByRXhmc7+pcL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAeDhifMP2qVOaJznEJ8WahmuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE0ZGNjYTktOGNlMi00ODk4LWEwMzAtNmM0YmUwNDdkODJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNjYzQ4MTIy\nLTRiNGUtNDMyYS1hNjlhLTJiYWM5NDI1ZGJiYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMqfCY85fjnrcVs1/jZlZpk4iBGVC5YN6a7wi8hW8XpqCLs4BaK0DtoH\nulNi/cjbyIAMpFKlsoW9q/Vxi+Gyu5GjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNGeNno7\nSrYwHLfg3068/x7JbYtoMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhANjkhTjjDcW8YDSHZ75Ig5FE7OkJLZexhb6gfuppucqiAiBfKdD81LXNEbKt\nt9jBK1NcicGl4u1ZX49X3cLomrZyAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc923", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `923` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAdBsAuWgsAoc7v68eG3/3BYLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMTA0ZTM4LTJmNzQtNDY1Mi1iMmIxLWQ2NDUwMWJlNjg2MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODllN2Q1ZTYtZDRh\nNy00ZWU2LTk2N2YtZjI2ZjFlM2JlMDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsABtRuhdXxgAaragCEJ8HE4EdBi3BI1ZWTf0pgeLUnoy0uiDZ62lgGRi9yh/\nzRr/d97JF06M6msmdxjK22C1w6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1dbnerjo7Pojb3FQ8PQto+BF/YwwHwYDVR0j\nBBgwFoAUR2RMOReMZ6e6TrtrGHvkF4+OUj0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICVye5MvbSg+b6sHWE9y+t6NgaF5QjqF+owT8/hTVZtTAiAmp1gM\nxJgdNuE8qrzsq73/fb3yDK3tagXSbJXUziCEBg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY9/JlOOfc1N1vhJ6Qetx/2XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzEwNGUzOC0yZjc0LTQ2NTItYjJiMS1kNjQ1MDFiZTY4NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS75CrLv7J1e5z5jU0xFzyzF8QbZYuFQ9ABuBGVjDUgkXDd\nr4MxL1ayXgplBXj2hfcmF6X7UavCC/eQjfRJjcExo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR2RMOReMZ6e6TrtrGHvkF4+O\nUj0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIp+dZ5Yf+q0rWCUjACm1+g3/YvpBLizmhaZguZkmDJlAiEA7G/1e2k7\n7qIkGoFnPz5bPmo1PBoxQijvkIbrkcOhg78=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAfqCb5EblIFBPuGgFee2buo0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODllN2Q1ZTYtZDRhNy00ZWU2LTk2N2YtZjI2ZjFlM2JlMDc3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIwNDI0NGJk\nLTdmYjktNGU0OC05MDQ2LWQ1OTljMDJlNTZhYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMQ5gk3dEjvCZS3WLfLpwoJ22d95VfO1/PvZsI+jGFzql6lCRTXGHk+m\n7lGjdlo9gYJQBYTFPg5abfZAwZ3C8rqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNXW53q4\n6Oz6I29xUPD0LaPgRf2MMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgUrEYgbuooCilvtUJ0rWydtD4ZmUVfJMbgKkWgmo9G5cCIQDGJR1yZZ5VAm5K\nSX+VcYkq9iVGzr3elw4fNNd6v+Udpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc924", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `924` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAdcAG/enCyFLvEsiLiojFLuSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmYmM3OGQ1LWMwZDItNDQ0OC05OTk4LWQ3ZDc1ZTk5NjI1MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBiMGYxNTYtOGYz\nYi00YjczLWI4ZTItZTdmNDBkMDcwNTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvNlx4RYgdqpKfMB4vrhdQJTNuc0vfy5afXtZLahe1DD4lBuU9i+qfCS1c3KP\n8LAtgsZ36p3HRS2l1Oie68HniqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYN8FETmBuDZqB9a0g4UE2fdgZiYwHwYDVR0j\nBBgwFoAUBR3yOo1O8RSE3eIB/Ooas6GTA98wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGVAVHU5FG5PPhwFIA3m5pdEKTw8nhHfWnm+CCjbaanZAiBIZg2z\noEw8kBCRqUAKiVJISoNJCdK3taPkj4mWsco6LA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWFO6sAjS+G0ipztfkEGPmJzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmJjNzhkNS1jMGQyLTQ0NDgtOTk5OC1kN2Q3NWU5OTYyNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrsjsO9yjAjj/CzO3g9JRNuJOZCH4X8IGGwANvu5pltL81\n3LNaqMqDtarpSCUAfvf/fVfT78xA8DV8cInYGHEHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBR3yOo1O8RSE3eIB/Ooas6GT\nA98wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKzd2HeJ/QOyl7rimRBTl/04DUWjVJVHbxnfXNqo616xAiEA5tl7syxe\n4gM+YsRW+CCOJU/+4or8j6H114vFN+A2DpI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISATCIZXlSeHJjLQeuYmv4EId5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBiMGYxNTYtOGYzYi00YjczLWI4ZTItZTdmNDBkMDcwNTFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZkMmVhZDM0\nLWIxZjItNGI1ZC1hN2Q5LTg4OTgyN2MxYmE0ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCMklyjey4mDjr76UMlQMXa70SmBvbjhXrPumw2UA4b6wwwLiH1u26QV\nTZmF9tfigYF23DqiCZZKl16EYes7bU2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGDfBRE5\ngbg2agfWtIOFBNn3YGYmMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgGOsYihQS2Ndq1nLsDsicgEPqX2MGX955NEt7nU18PfoCIQCDLFPI0vTGXhTW\nfWbk3ta4ZVbiOdErJfyr1sjKmBdekA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc925", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `925` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAUkNtyEbfTHghqzvzyyOnw3JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwMDQ2NWViLTA4OTctNDM3Ny04MjBlLTBmNDU1NTI4NjkzMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYwY2I3ZjgtM2Zm\nZC00NmE3LTlhMWItOTUzYWRmNDdkMjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb1+VpzjPTPr9SnwQjB9rmLKuNwjgOX2NJW52emLFHtWfqB5m1J6FS+G3rYiJ\nWzviEkDQCf981zXqFWcPTPlUwaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSN3uW/+hJci7Qp+7HYq0iqa6V61DAfBgNVHSME\nGDAWgBRnvpsAKrgcCiMltMugzAB5eBSxuTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQClcIRBAZ4o++BnoxRKpj1dXtes5J/k\nMsiOK5VFK/juAAIhALQTeeuZsg7H6V0OOpwL+TfcTuKZcGNbxQI6gLro2xp9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfGLl5q7NDZ37LBsqqn+BaGDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDA0NjVlYi0wODk3LTQzNzctODIwZS0wZjQ1NTUyODY5MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4tbCm+yASK5KPx64sbBjwGBgI02mVYlSa0XVP7ospf2HB\nfnZAGRPY6E6kLpH8bSW6tzrFLxV3xkOs0PezZTZJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ76bACq4HAojJbTLoMwAeXgU\nsbkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALexDM9/ITiOQu0Sc05xFFKsbyUwCgmzAMUt7bLVUWDIAiEAy2OWN9ys\nVSzHYrS/K8oCEkyYMpf4G63Atfd1IfnRbVY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAUYuh7HQvrEB1AXyR3p3ni4iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYwY2I3ZjgtM2ZmZC00NmE3LTlhMWItOTUzYWRmNDdkMjMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUxYWYwMDk1\nLTg5NjgtNDRmNC05YTI0LWQ1ZjZhZDJjZWZjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL11dw4M8xR4Mi7iyVTF3kQqGA1JbSHID0KOnGA51lDK6Ecj4L/SnA6L\n0e7uxZIOYkq3LVtYem2L1mN1ArPURuijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI3e5b/6\nElyLtCn7sdirSKprpXrUMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgV7QfZ04a5k5xO3ilc52DXJiKGyx+pOCZetV2h0uigUoCIHEoK8grvLSn41q4\n3sMQXxGKO/NQtA03qPrSYFKIhBc0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc926", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `926` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYWUE/nfQBEI+i2zeQc6Y5riMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2ZGZlMTdlLTliMjctNGIxYi1iNWM1LTI5YTkyYjYzNDhiNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQwYzg0OTEtMmYx\nYy00N2JkLWJlMTgtZjJmYjk0ZDdmNTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIhm5OSn3BaxypXh3Q2MazY5kIrZu16zPm0iWGizjSZ6FQDpkvb7vCP1g0oBn\n4WOEmFIttdZPBQx7/NmE9+t4vaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ9opd7jB/fpP7SPkzeDqjLdo62IwHwYDVR0j\nBBgwFoAUBrPaoPeRaBaj9ieWJvM6KKlKDVcwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDaOqJHqCyi\neBscjDn20jSystthn5/bBKQ1YD6AWx2omAIhAIFZOnUiqiQRuxg0OFaw4rVzk7BS\n4XreGL/HFdLDgmzA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcz2S8c7shmp5pyO0rv/GKxnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmRmZTE3ZS05YjI3LTRiMWItYjVjNS0yOWE5MmI2MzQ4YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlJpITRkV/CHOYLNDpttk73Bfand/LdBXRcde5/nh59OZ7\nhUl1b9N2AZgu03jQbWfrvugO6nB77gJfSYM3+lY3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBrPaoPeRaBaj9ieWJvM6KKlK\nDVcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV6wtOE3iV9O3ZDz9KxHc/ClnDwgO0N96HYrFcpz1Bj0CIENu6ljuvBrz\nayua31d4of/HxGoy3a1GEA8BjixZhBTh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAafZnNJJ508dK+djTvjoq9gCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQwYzg0OTEtMmYxYy00N2JkLWJlMTgtZjJmYjk0ZDdmNTM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMzOWNiNTJi\nLTQxM2ItNDM4OC1hNjVlLTA2YzM3YjFhZTkzNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHuFGtRVh/OstmpatbCB5+Pl3YGNyKW4c/3OrnsQcuv2xwAN+Q6U22y+\nNIf2g5mhi9vvi2GlyIHdvX+9f3cRsVWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGfaKXe4\nwf36T+0j5M3g6oy3aOtiMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAMxabFwpsClXnzLNEYLcOWLLEINZ1elB+PN5O99ennDcAiB3nHR5E/du8cDE\nwczikpUvn+ZmoRU08aEGk1bYQLgsWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc927", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `927` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAdYEJHJRnlqa1830e3vMRAJvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZmIwMWU4LThmODEtNDc1Ny04ZmU5LWZhYTNlNzc0ZThmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM2NTExMjMtZGIx\nZS00ZWNkLTgwYzUtYzgwODIxOWZiN2RiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0leeuzvHk36MmX0rTZ6ypJPgBylc5cjhvw39VhwIgJCWbas0S7ZlnlRLGBqe\nAEGSMG/+3B9QaXGQVwr3n8eIqqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPB0O3L2CwvaqfK/xgSZdxS0KevQwHwYDVR0j\nBBgwFoAU8P/HzpXpyApjNe6hR9DZ5NfsOhUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD0fhlqO8Ee\nHT3nHgYBvfpfycn/591oWdt2onKv+uqeJgIhAJgWOUtLudjoW5T6htseJrQv/EWd\nk5vpZp2hI6Jl21qk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWctdCVkGTgxOliTKj/mTGbcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWZiMDFlOC04ZjgxLTQ3NTctOGZlOS1mYWEzZTc3NGU4ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmei+8Rw7yaQNh81+CWukGkLxopVkT4TOnZ0P9DwZOl3Pg\nOO7thpTCRBJVrYdTq6eUyOcZO7fn9gvwMT5H2BWko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8P/HzpXpyApjNe6hR9DZ5Nfs\nOhUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIbl5f3GsSkK9fjkeUpbFR4KmDMCTbjRcId1cDEw6eQKAiBuwT6w0Wsn\nh1RVG3Bz9wUaizbCjEsqosrC/InkKYgsZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAQZgXaatc/vJj02iKa+UTAoSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM2NTExMjMtZGIxZS00ZWNkLTgwYzUtYzgwODIxOWZiN2RiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY5Y2NlOGI2\nLWExY2UtNGUzZC04MjM2LWUxMWI4OGRmZThhMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCmara1h3gI0RKbTIfMmpENeEbmVkzc/FNxturWETX0zLC3XT+qpSBJ7\n9L3JSpfqMPArCObyObmfW+eZbcKPcoOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDwdDty9\ngsL2qnyv8YEmXcUtCnr0MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhANTKnB2FPf3vn5ufMp3K43R9uWxreacjtewj7KTVdF9cAiAJEH1IywgIiH2r\nCHQijUQY6KHcegNxAv1hxXfwJ/DcDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc928", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `928` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAQHe+++m7zOqRitLwBfcMy5UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxZGRlN2M3LTNlZWUtNDRmNi04YjRkLWIyNjExM2I0OTAzZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg4MDk5ZjgtMWM1\nOS00ZGFlLThiOTItOGEzMGZlOWZkYmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjfZM4ynXaV9H0FSrm48ggeke6KsyY6wiZAwBWODi+dTM164PqoqTaYNS/uVp\nIsZthNjzQA1li4xSFWraqyPYP6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWMQ9lxqQr9iPwchRRT2JbatNQUMwHwYDVR0j\nBBgwFoAUy2ggKUOWT42MoJIJAC8PKprHZQUwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAvH3h6bXvB\n4WyhKduFsLEPjtBeadTg2NcqaXJ9zbYJWgIhANiAjZ0lT22B4c8jE68m5H2WcDhr\nR5P9Bl2terVo2qR5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVhTm8/P01DatrH0bnWQhjLaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWRkZTdjNy0zZWVlLTQ0ZjYtOGI0ZC1iMjYxMTNiNDkwM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7ALuz+BOUFyfXDB+ytqpD6aTHY9TftC4Ma088aiKM+OdV\n7klkeVHNq73lp+wTqKES5RYE0b9jc5r/oYfXrK2Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy2ggKUOWT42MoJIJAC8PKprH\nZQUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJnn32CVWo8uJ/bA73CXKTWQfFaAxXojHzib7b/7OlvVAiBOlVnulqOv\nGXzz5POBLvDtuo9T54XXRWFHa0jLv62Sxg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAfH5ZaYOfdxfJn3vqiTf/n2gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg4MDk5ZjgtMWM1OS00ZGFlLThiOTItOGEzMGZlOWZkYmNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc4M2QzODNi\nLWIyY2YtNDRjZi1hYTZlLTk2MjBiMzUyZTY1MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGliUuISo7XlxMhIDCcnQJMyiO0j2oSiZ7SwS8Rt7L+PWCLV+a/IZNxu\nY+2EcZANzkqp5g9GxVH71Jd5bmIR1EmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFjEPZca\nkK/Yj8HIUUU9iW2rTUFDMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAP2zzWorWLpibXY1z/m47CiKqA7akzDG1U/E2Zy+1QMIAiEA4jcVOCxTSx0p\nB8d42R/oNLDlNTNNwxnvi6U2II1CdL0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc929", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `929` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAQEW8UPP0KRQbwyg5QwcGu5JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4ZTk5MWI4LTE4YzAtNDRlYS1hNDE4LWNiYTI4M2YwZWQ3ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRhM2U0NGYtZGZl\nMS00Y2IyLWE1M2UtMzc0YzJmZTUxYWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK4DMz/xH/I61lhCs3UM1jisDvmmMjwNc1MyoevX9N1CFih90swjsp37koi/O\nbpZ9nj+Aj0d0DGpc3JJqmsox26OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpUCVK5nSJAC9ChLyCXOBZTSbDnAwHwYDVR0j\nBBgwFoAUu5T5/j1C6hG2HprkcYkm14uoclgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAybmh3390PSs1DdqF4L5dicWfW11Xrpy9LgJM/akotZkCIQCmWiQ66S/X\nr16voPBEVFm/vQE7/4aLY3H5HM7rSIDJEg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWJd4g+kv6Qyhp3cY92O07BwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOGU5OTFiOC0xOGMwLTQ0ZWEtYTQxOC1jYmEyODNmMGVkNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+YSIUeZsk9cSuwxRHuXmt5JXD+sD5HHXnnI/o4YpCrjCZ\nFQRnSQTDV7hI+XQkd5GvR4D7ai23mdrnTsLFeLJco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu5T5/j1C6hG2HprkcYkm14uo\nclgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgINZn647PRGBGGWmPwuRS1BOPs5JYadr/yEVDKMpe49ICIQCVmiNDH3XM\nc5QygVEpFslNfYmZQOPRP37xXZ+DMj6zQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARs9wBonHbw18I1uQ3pSMAZ1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRhM2U0NGYtZGZlMS00Y2IyLWE1M2UtMzc0YzJmZTUxYWNkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJhY2M4YmMz\nLTYwMjMtNGQ2Yi1hYTEwLTczZDIxZGI3NWRiZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCQ/RyjFVPDNQ3E3HmMFz6vMkT1D4KR2b/0ZTPSQ1Zzsur2RDtnUXKRf\nWafmBzCTC8ob968Ez57vHvQHKARUMHCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKVAlSuZ\n0iQAvQoS8glzgWU0mw5wMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAPESzZhBUKbEy6klWC6CIRBhMn/EMOZBGaIC2eILInMxAiB5XOyK9zlIS2kC\nPVmaf8K1VgGsI5QCQypvJuwBEs0OoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc930", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `930` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAdoXU3+n+06uOUEngffXFMkHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhN2IxNmUwLWFiNTYtNDI0OC04MTMwLTRjZDU3ZWUyZGQwMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZlZDI4MmUtOGQ0\nMC00MTQ4LTk5MDUtZjQ1ZTc3NGE0NzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtJS+0aYSPiNV4UXPuzWtgdiXg4SXT8ZwuHj74l5Mh6Ys0ySr30ZZVv9COSpU\nQYUSig8mvrQkJzvymzfQ7CBRWKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIU5oeylYzNrUuRWwQRt6IRZHI3MwHwYDVR0j\nBBgwFoAUWwIpqkiUf0A1jaNIkdM+6i4ESekwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA4ORC88AOLR6+PxJYX5w0juTjMokJRnpqWE6HjAmtOvgCIQCOKGoEfN7H\nlr0tc4SIh8qKV0Uiy5RDbxDvJaKLU/A+nA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZoMInEYbM6sLMziIKeFkLnxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTdiMTZlMC1hYjU2LTQyNDgtODEzMC00Y2Q1N2VlMmRkMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVcAtKUMvy7H7iqTIcP4hIPyjrgo3HVyLM03J1aSZ2tKLM\n8iiM8X9m3vPEzc94g6q0Wgn74R50uz1HfeGrygAIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWwIpqkiUf0A1jaNIkdM+6i4E\nSekwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeLk6/VxcEvWC6vrOLdI7v4wupsfVz9L25aRzn/wfwtYCIQC5lRTpUxUA\nurApwCzkEUX98ElhejKdiJ+J7L3NUttLXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAahBUYiut3E5qupRPuBVc0BSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZlZDI4MmUtOGQ0MC00MTQ4LTk5MDUtZjQ1ZTc3NGE0NzQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU5YTBiMGFh\nLWE3NzUtNGQwOS1iMjgwLTYzMWQ4YzM4NTUyZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLAMyemGhiibsjwqHrGIxW1H/fHwlJd8wd3Zw+bOoNkbEXsBMyuSAPin\nAXbUnOJe8lE8dhBZq5qorcBqckyYKMujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCFOaHsp\nWMza1LkVsEEbeiEWRyNzMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgHiRIcFN1CgjoJUtdtvlddlQahWxQO+HnCxhAJ0chTo8CIB5B538kezHG6+EE\nMmPJINeU1rrt5FUo3hbeMzKyQ8D9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc931", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `931` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAVNcaJeRUT4/sAfCLXs3jkhHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNjYxNzRlLTc3NTktNDM1Ny05YWE2LWIxNWU5N2ZiMWI0NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDMyMjY3ZGQtZGU0\nMy00ZDY3LWJjNDEtZTUyNDk0OTQ1MjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHAeQrlR7k9OrB7LbCw1rOnU6OOFNxzzIebMPMLH87p3bBWUvh3mtgbluOGgN\nVFEHM6ozfLTwPS/aAg9c9tj/uqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrX7yioVqUX8O4QOqEB390ARkWFYwHwYDVR0j\nBBgwFoAUpGM41ep3XoL/3r5KAOTZw6aZCsgwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\nnufo04Fwl85tgvfMB/r4moItHeAusQQuKONlsW/IJ48CIQDDZt7r3ztgBExloLGV\n5K9WITvoulekqz64LjUTg0AJJw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAchVquxrmzJTWqMZ5IvyFv1FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTY2MTc0ZS03NzU5LTQzNTctOWFhNi1iMTVlOTdmYjFiNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGdcUxDxliZNIBVB9ReX3jKTiwNqdXcRXQ/uCc1wmVrQV2\nx8JyhyRQ8qli6pn/OQmdLTA5qhncSIebTDdZJd60o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpGM41ep3XoL/3r5KAOTZw6aZ\nCsgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI3wMPH5Y4apfICoCBDMKpMo0Hgp2yta1BS6VzjEZSx4CICLdnuz6gcZR\ngyF9SYiQ517Qs4jHZjVSFOTV+pattCQ8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAcT1ux/3PPtawurk7bjpNmKuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDMyMjY3ZGQtZGU0My00ZDY3LWJjNDEtZTUyNDk0OTQ1MjRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNmMTI0MzRm\nLWFhYjMtNDhhZi05OWRkLTczZTlkOThlZDY3ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKDeixNZQ/2DcXnW+ks6ehDzFycLRai4wiIBNEgPXISefnCGyd6LdBev\ns8TNyTaxnp3gwDd7jHEQwy9MquV+WSKjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK1+8oqF\nalF/DuEDqhAd/dAEZFhWMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJTf8A7O0PtMlsEHKwMptTFh+Wxee73e2xt5iieWECIqAiEAq0Lu+4FcsbEv\ndzch0p/Ta0SBFXzqwXLplRsnfMmV3GE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc932", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `932` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAanU3LYjfk41qLTsgZEDCHGMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZDhkZmYzLTAzYjEtNDI2Yy05ZDUyLTYwNDY2OThmMGFmYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ2ZTU1ZTUtMWIx\nNC00MjEwLWFjYWQtZDYyODFlYWViMDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJGxRqmg8XOM2upbHmmeUmyRIMgBraH6tjcqhrP6acGPDqAxxLrlft8yYWIE2\ndS4Tmm+C1QE1NLdtxnQ6WkRfBqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC5rMRIofTwnLZuXanBrSd2UDlA8wHwYDVR0j\nBBgwFoAUE/0jyNFl6ImjDg4OpELp3qMDTRIwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAv3Zb3iobGzfjjEE3E3ThQbnDCuYOW1Oi+z023nlgR6QIgc3Cr\nKsRcJc8NRKhdf1kOpaN3b27ExCuy7SpFmMMqVZc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdhq7NPpQbV7wnYyo5LSSKGYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmQ4ZGZmMy0wM2IxLTQyNmMtOWQ1Mi02MDQ2Njk4ZjBhZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzekeZTkgh/pX/4nqXkBiq5H/pK2sclIIl1NfWi9REQoKR\nnWtfERPLgvdJ3u/CmnpvgwXdonCnA9igwHGc+25yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE/0jyNFl6ImjDg4OpELp3qMD\nTRIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgftn1bVDb4cZqYwE7JIIg3g7z/9/uk3SQ7jk/85MDuhMCIQDbCF0qKKaz\nRvtpCPNwsbFxsAcGiowEwM858PA+lYgmCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAYVcjF3/k/Gjr2Fm8vNWxUGPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ2ZTU1ZTUtMWIxNC00MjEwLWFjYWQtZDYyODFlYWViMDY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhjOWEyMjZk\nLTQwMmMtNDNlYy1iZDk0LTZmMTQzY2U2MDdhYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNunOB5YCT9OqyyQ8ugH97nFMRKGyvgjAhEc2mfcMkB0w4U+zPb8sa2F\nV1rAqffbqAPsrY8kOOA3vWPy6rDzWc6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAuazESK\nH08Jy2bl2pwa0ndlA5QPMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhANnKakLN2W2788sjlvefaryRt09DPZBBKL4ZTecgXu6SAiEAsoOvpic9m1hy\n2Mu38AA3dC+r9Y8FcaPKX+oZxV7gEw0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc933", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `933` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAWdtPosuqqrm7T/rUeLLo/FvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2OGU0NTJlLTAwYmYtNDI5OC1hNjk3LTlmOWRlMmNlMmQzNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBhMDcxMDItYmI1\nNy00ZmFmLWFhM2QtNDRlZDFlYThiMGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED2RhYpF2GpRnm3WdKH+YHP60NIAUctw9wYmlnKHt8OIb7ZWBiCkvBiGAzDGD\nnkz6jomYZ6Mnxpu93LrN2gcb8aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUaL1BDjVufFxxXnq7P3/+fLQLzYwHwYDVR0j\nBBgwFoAUsX7xIyoPBXgPxzTPGFA12qm7BdgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiANsOgq1WB2ctvbyIZUYkiETvQ7e+yu6c6g72hDlYrPgAIgcVYT\nXmaDUNk9aqxWszHQPimY4dlv9SjnOknLIWEFTcU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe0kbUmLaFyJhW5h+vOW+I8RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjhlNDUyZS0wMGJmLTQyOTgtYTY5Ny05ZjlkZTJjZTJkMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJogxeQGCGLHchvtcWd2JofF9Ftbu2MLG/4ntcURBU+u9B\nI/sYkeDzcZzoRicvZHcXQu8jkQnCTpGsDBKi+w7do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsX7xIyoPBXgPxzTPGFA12qm7\nBdgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVTWdCDPx/3H/tQwqeLOVozWG7lnqxaOe+QssRA1vN9ICIDQJb+cAiYVI\nzAjLvK+I8dEovzDGZIA673mAbZMKbokd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAeTkwberapDqVeCwXK8A+c3ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBhMDcxMDItYmI1Ny00ZmFmLWFhM2QtNDRlZDFlYThiMGQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYwZmEwMDI5\nLWM0ZTgtNDViNS04YmY2LTBiMzc0N2MxMGI2YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMcKicwyGu3HT8fgl+IOPQ6Qs0UzWNc51s0Xr655OKqUKzlfbYH04aeY\nghBiXsbPzl4cWSu3a5dvajWPhKOeJa6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFGi9QQ4\n1bnxccV56uz9//ny0C82MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgM+dijFdO6B52pOvWTkWEJyNIunFRpL4uTdiUZbrJy+oCIQCmRZzKyQ+UHaBK\nHshHZQ1YU5UljufymAJeLeNBk9NKhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc934", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `934` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWuoJEkW550LI9ZigWn7+VWcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNjA5MTMwLWJmN2MtNGZjMC05MTc2LTUxYjMyZjQ1YTVlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQxNGJmNjUtMmE3\nNC00NjgyLTkxNTgtMGE2ZDZmM2U3OTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtZLK/vVyY0eEIVisTkTuHVus2D4DlRe8C3ly/YqBWGxjQkQnSZtWfG4wRoPT\nUv/8OuR1cJ25tVpnqkT4oZBrraOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnGRNbBDUGtJ4RLtHLnZb1hBcp4MwHwYDVR0j\nBBgwFoAUXgJCdyeLOPOWUv0xHMahX7xXI14wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAozItCteLI0ew\nuV7m0N/z/YmKGuV2xUNGLaQqB316m94CIE2XEpWOsDe99vAtPdZthbu+ZcwGy1JS\nZdJCyXvlsRxm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXfgH5jI4Hjt5pZkJe/EFc1sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTYwOTEzMC1iZjdjLTRmYzAtOTE3Ni01MWIzMmY0NWE1ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYsZsmZot7ckb+tWRQ7P5szJxXkWQdNR3YKHnPVsTT6aJk\nsvczzi3CgemEWhZzERzO7fEJcrmhe0+SQCCVLEzjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXgJCdyeLOPOWUv0xHMahX7xX\nI14wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX7z/Ia/cBr0qG/OnX6B1edaLZjip7cWQLvbHi8Kn4OwCIQCoILGlZOzU\ncpkdXeg8FjMPDKcS7RLty7InqJKWYxBXxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISATFhFyrsFJaD7rtkx1L7SiqgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQxNGJmNjUtMmE3NC00NjgyLTkxNTgtMGE2ZDZmM2U3OTY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk1Yjc3MTE4\nLWNjOWUtNDZlYi1iMTQ4LTVmZDI5ZTgxMWVjNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJGuJ8Rt+5zY/mPzBiglN1KamgVVLACWT0zjEtR/7goprvrFxesYEul0\nVs+Bs+lunEMjQL6Ktd5VSIA33tX7mOCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJxkTWwQ\n1BrSeES7Ry52W9YQXKeDMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAOSONwPWchQdRt8ZPXtlYDxLWIpUqEpO5oQ3gnEnqQ5/AiEA5bUhudJXgI7K\nMqTDpiDUMbMgzbkji7MtAZ2TDGib0Aw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc935", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `935` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYIEVN9kAWLr8R9ZvO1Nt6cXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3MWU5YzEwLTA0MGEtNDZjNi1iNTM3LWEzZGU3N2FkMTM0MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJmMDY1MjEtZWFi\nZC00MTcyLTljMzQtNTYwY2VkMzE1MTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaUNzSGwklWn6XyaEv1p1MDEnlpwkfBjH90Ki1VH0V3LYvfvPqa1UWyHCGVGK\nNcdVtROQuE6wqwNTxDnkFhwZQaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyYFE/0+pxvZeXnQXbE1Hl4fY1jcwHwYDVR0j\nBBgwFoAUfhUHWPhxONBTUNx6gFFR+NBkfBYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIG5r1FCSc2w3Hc0QernoC4++tnw4X2BDmSbWdOCHTSYqAiEA1PvmiaRT0F/H\n708DBx+TlhW+w7o9rWcbLTLcykwf5jw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXSEDlllrXwYoOBL7o4whrRsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzFlOWMxMC0wNDBhLTQ2YzYtYjUzNy1hM2RlNzdhZDEzNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATx+LrlGo4lQ51X3EL8to+wRwiHCnxpEzO7zn1p7gEdpfUd\nirYBl+T55ZPmFPcPiKXU4S7PldtJj4ZrCY1ixpAVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfhUHWPhxONBTUNx6gFFR+NBk\nfBYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUcGjHPjyhLZKfkfjqbsPBXYbCA8zPBrWiaTZn6Z+u/oCIH0o49cpguBh\ngZIUa4b7x1qyDbbND1zI6lIrON4WL83q\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAVduhn5BRNUw2tedgaYsVyWMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJmMDY1MjEtZWFiZC00MTcyLTljMzQtNTYwY2VkMzE1MTU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJlNjYxZDJi\nLWNjNmUtNDQyYy05YTUzLTQzZjVhYzZkYTRmZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDjEqdlOgeH6J6b0S5/MW3PS8WfujFjhAsuAOog5s9Q4KNehfHrgnufZ\nz4AZT4AAVLWNgEvQzkhmj3LCPH9s2nKjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMmBRP9P\nqcb2Xl50F2xNR5eH2NY3MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAITC0AXzpVQBua93+5CPcTAqd3WFGXwx+w28VyYgfBsFAiEAnxCaGPyigw4O\nkQ+eabfiuZ1RyZrEBGJ1QK+Ydzm/Rxc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc936", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `936` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVeFkdJoCtEoSqL798nt82cyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiYmM0YzhmLWZlMTQtNDc5MC1hMDQyLTZhZmRhZjIyZDVlNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQwYzM0OTYtYTJl\nMC00ZjZiLWIxYTMtODI5ZGIyZTczOTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwz0TJC0hAI/WjFNn37RdD0rMmupPFvd3mIqX5Hg/qLQSQDJ8Qltmbj15Y5/S\n8LluPrv9AF4ljbfq2pb8qVkMGKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHHmQhkZ6uwEecpzf4mg5FTnh7kAwHwYDVR0j\nBBgwFoAU4MPUUSlMVx7jL4gWelLt+7Oxb78wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHgWTv7fR/zWVU428R1ZBOPDUIN70TwmKpKYcKHFfb1SAiEAwtg85BGUEGzD\nf7n934zmofESGyxyvlxWqpcgL8TMZ3U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVeAFDpYHUrvLH1Iy245chYEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmJjNGM4Zi1mZTE0LTQ3OTAtYTA0Mi02YWZkYWYyMmQ1ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQM7XsAf878/VBWplRFdJRIFhj8ufwzRUTe9JjGFBrMP2zn\nXp8RtJd1DTuHwywImpA/+2bZpXZWcK2GxjnrRvUno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4MPUUSlMVx7jL4gWelLt+7Ox\nb78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU6h19lg1Xg2OVf+mb8NqP7pe9OpjhwkhVb8FC3OsD8kCIQD6okzfzFXY\nFD9FM61LZFGpB//y5ltQPi4AD95CwPh3IQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAb4ieMh9LCRtV/2fRcibbyYeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQwYzM0OTYtYTJlMC00ZjZiLWIxYTMtODI5ZGIyZTczOTA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI4NDIwZDY1\nLWJiOWMtNDhiNC04NGQ1LWY3YzAwYTk5NDlhNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBZDFGYU+T3OM+kA5ocR9VCIrUmn3U3ZOoSK7LgH/+6YID+7Y3XkBQkc\nkrtxwMzi497HHIjTH2yaBm4WnZYW5k+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBx5kIZG\nersBHnKc3+JoORU54e5AMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAOU7IC2UFozylVw2O6pKDWne+9mBsesmuto9FZfcIlbaAiEA4ED7JXc/Folx\nHdP8zLNrZ8FC4BuvKtxng6kJaaN1OzA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc937", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `937` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAdQ468Kj8K5Txg2aff43Ba6wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0ZjdhYTgyLTU0NGMtNDBiZC04YThiLTRjOTVmZTE0NDkzNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFhMWQ5NzgtMTIw\nZi00YWU3LWIyY2MtNTRkMjhlZTAzMWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaiSPpk/XsuUl2z9MsGrotnOOQzA47jPDCEqRnTY/jDA3SJlL+S/7xya8avLJ\n3gYO+n/1qkyPmKvz9EP8bBBZOqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsiqWhvEzD0JW3YAIzkmPIFet2aswHwYDVR0j\nBBgwFoAUsRHDyrkZPk75EdU34gacru/kyccwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA/nYdA/lMyLOSNgabmBu+4MRfh3avSraudARnjayoZcMCIQDDf5VDHgA9\ndB+diUT0mk/dOKr3Q2xor3C8zwqgiYXRig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT7B4Ub46zQpQURv0TPnu5ljMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGY3YWE4Mi01NDRjLTQwYmQtOGE4Yi00Yzk1ZmUxNDQ5MzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASX384iaAXZ92+7ROf1MJS7KW9JLCI1E6uQgC7fuNVnYuq6\n8pfrnG9OMHAl2OQNpaDCfjUYzHSBljtUPPrZ3HeWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsRHDyrkZPk75EdU34gacru/k\nyccwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMPhtYi2lk0Rwoh+XSACP7CarxvuN0xSdn9T0C9/wLKsCIQDM98IyODmc\nNmaNbdgJSSPGRUWQc2PdDR5uT55eWGsltw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAf8egL11M1L/DFF8Zxp5Rr30MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFhMWQ5NzgtMTIwZi00YWU3LWIyY2MtNTRkMjhlZTAzMWZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlhOTQ2M2I1\nLTk1MTMtNDBhMy04ZWU3LWJjYzI5MDc4ZWZkNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCvmUWuZ4NRe6TJOglNdZ8iCqcWVbNHAraMmQSGU51DDtWTm4Ms88+HH\nynFZIp0UfPcmkbnOHPUOzjo0ParT6fyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLIqlobx\nMw9CVt2ACM5JjyBXrdmrMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgZLeNUF4yMe7/3KOzfEHgdOuzv9wH1Nm3LlRIxjv6Cv0CIQD815B9Txm9KQPN\nO3T8hYRgMXi0OeN3etTjErgFuzFMOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc938", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `938` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAa+G6MJyoHAf7PjKzs0ZYRtDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzMjA4YzNiLTc3NzctNDI2Yi1iMGFhLWI5NjVjNmY3MWUzNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2UwMmZmNDUtMjU5\nNS00YTFkLWFlM2MtY2JlZThkZWE0NWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJB+SJ4wIcJtn1Us2yASdGi4SGAKZjZB4Sas4zbJl++R9wwPhFRH3LcBzPAi9\nqoY8VS1jv2W6M8bqBHCDyVmUjKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXVr3XCqsjmo6zzsPJ4VUDIgG54swHwYDVR0j\nBBgwFoAUdmuM1ZFo7u/SNeup98pe/OKAsRswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA62zkcyBgjnsc0YmGlx2mW804jYBh5CyZs3EWuS8W\nCXgCIQCt9Nd15RU+xNeyD480VlrarVPZDlWyNeenocghHSsHHw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWHQfRu6Z9lO1SSUc41ea8gkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzIwOGMzYi03Nzc3LTQyNmItYjBhYS1iOTY1YzZmNzFlMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsFjFzyzPagqphRBWT0WqD3hjPwgRx1Azy4mEX91xCTVHn\nzW+WmSm/2+pfz4gpsstcsd/gh62FIjHDLRaPzTvro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdmuM1ZFo7u/SNeup98pe/OKA\nsRswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKU5sLAaUQQQgfT5QMnZt5w+otjxhejeo5PdHQRKD3xNAiEA0DA1l6Bn\nn01axRi74qNOWauJeSEg62v7Ims3hdbQC5s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAS7kUyLNhNH0OmOKQ+sht+PvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2UwMmZmNDUtMjU5NS00YTFkLWFlM2MtY2JlZThkZWE0NWEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM3MDczNmE4\nLWFiODAtNGJkZS04NmM5LTU3MGVkZmE0MjEyMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBTkYHlh691OZH5GwCbr0ViNCKdJQwlubVbYQnoggoGm3cvhGTOSR2Kw\nx0eLvi7FKQf4A+BgwBIQe8MmLtY5nMyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF1a91wq\nrI5qOs87DyeFVAyIBueLMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgfQ+dnLKnnqSFXm1jWo2QxOy+Fj6Pb0rcU60sA6wcckICIAHz80BEMrTZupbt\nDgJaL4Lg/dNl1cG4wNtc8p3c6YQp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc939", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `939` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAb0howlcVJica9vG+/Waly29MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwY2Q4ZTM3LWRlYWQtNDI4NC05Y2YyLTBkNGY2MTFjODYwODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgzNTA5YjEtNDJh\nMy00MWZiLTgzNDAtMzliNWExZjQzNGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFcJCKjZRURJTwFG6M+t60KlKasVPDnZWDE+yv4tWrRw7Cg4oARNXjbEcvkcb\n12lGf6GQKt37pNTpY74RM3ogIaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy481iJdkUXvJdA+ofSgMtx9MqGgwHwYDVR0j\nBBgwFoAUP0CMCy2cqKRRzS4j2XWOI2Nenn0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAsJVawzH0ADhQgjcDttZLXOdYjjxi3Z4sFHT6uR5X\nS0gCICMbTKYJgjSGywRvE1EuzHTPyYje7/iG8iP+Tx3ADL7m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYl4a6h0w5id/PC9P5IvQfChMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMGNkOGUzNy1kZWFkLTQyODQtOWNmMi0wZDRmNjExYzg2MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQF0ZD4AJXWIGr8e3z36MDxkJNKjJ3bh5LGKt4k8QjJjRpj\nsvRWqSdtHK8QFTMgHANJuuO5v83lEESmCZ5ZOUEso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP0CMCy2cqKRRzS4j2XWOI2Ne\nnn0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK66P5PB9eDePc7iHUMwSSaAYaHwSMcCN6kuX5WMw2Y7AiBIOqza2UaC\nSSnIkudZzGRUPnALlY5NpXwjrcCIfn61Tw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAcgWnZXj43r6tw9nrv88y/tBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgzNTA5YjEtNDJhMy00MWZiLTgzNDAtMzliNWExZjQzNGZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhYmE4OTg3\nLThjNzYtNDdhOS05ODUwLTFkZjBlMDE3ZGQwODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOBdNxuDxyVyDjNTut5nmOsyG6P1NHoGkq3ljQkUgjVvCzZN+5XKozlK\nwYTjd00I0qVWNb3BjhktAFC0+GJeFBWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMuPNYiX\nZFF7yXQPqH0oDLcfTKhoMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhANgOTdHMNGfxGSTso9fcjghTnXFMd9NuLM7CHMNZr/4kAiEAvyeQ6M5ullnF\nDjxdQSqzafEXHo+T8H3g0CnAUb5pqlI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc940", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `940` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWno+DzAvkt4tvgJvVfsAGnJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2ZjZiMzZkLTQwZTYtNDhlOS1hNWVkLTliMzE4OGM1OTIzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE5YzU0M2YtZmEx\nOS00NjU4LTkyMjktM2Q4Y2UyOTI0NThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7VgksegHPqjaCZuPwk+0Q205sNwd8InYwKa5U1w0Lz+0fPKh97LsUq/uiudH\nxQqsJKlsEqZ/cYJA84FGdt0xQqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqGipEhhtcABTRPv6+kgifQhiNHIwHwYDVR0j\nBBgwFoAUTdTnXocSBj3dSHCXp1mJSysmQxwwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAk0WHWpwADqw9130fAikEP5O2fI0jZB4Ak3iHZOXh9EQIhAMPS\nKGk5DnLFhpaqsfK4sS55vwZkKYnVNEgYL4jLTKUG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZHyJwtYq+yQ6qKKzKi9h0sCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmY2YjM2ZC00MGU2LTQ4ZTktYTVlZC05YjMxODhjNTkyM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSS0/NRKOyV8YE9h+V6WzJBO9kGRnXRxfeAmfas/A/097c\ngJyeI6PPFF2WonfRsGChQBrMoTewVe/5rzeNslgzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTdTnXocSBj3dSHCXp1mJSysm\nQxwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALXcJidp+dJ8vpo+JGHPy5WKd5jJdm4EwLIjxUy3K8ySAiBHBI35Ncbl\ng7bOK2FA7M6YSKk2asFTNvMhKOeZMWiouQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAVGA4IKHb4+2ni5MAWaJqSGdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE5YzU0M2YtZmExOS00NjU4LTkyMjktM2Q4Y2UyOTI0NThjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ5ZDA0MThh\nLTA1MjItNDczNi1hMDcwLTE1YTRjMzU5MzdjYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMAn8woAcxxsQsBSebLnd+HANHK7RVercMqFI0PqqetMmUqAKJ++mBBr\nxOJwwlsBnv3Z5KmZS9MFcmCyvVfY7d2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKhoqRIY\nbXAAU0T7+vpIIn0IYjRyMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgbjG/MYw6+r+7JnOGR9amB4Tk+nUV4ut7LdkQq+lZPNkCIGrqmOaE8vidK64E\n3QlqN69Nr24B5QhinF+Qs/M1Qg0E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc941", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `941` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAY8cfynj0RHcKuTamyqR1f+WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjYjgwOTUxLWZkMTAtNDk5Yi1hYjZiLTk4NjllMDdkYWJkNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk2ZmM0YzgtNTA0\nOC00YTMyLTk1ZWQtNGYwOGI5MzEzMTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdB3GhCNTmNs6/dQ7IN+FQVVt5SGR7+nWIZndmYzn+Zat0kABUqnJt8eSvGsl\nL8nSiayPC0BjIFdTk5uG7uDICaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjz9IqPxQjYt6qcDfhuOOdELhitswHwYDVR0j\nBBgwFoAUSXyfWdA08Y500h9TPUlWHjE7k4IwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBa560mNkibv9jDFWNDuNPrnThk4Iur0gHD\nyuzb7t3HCwIgShRDqHmW/ofv8QgnUWT0tSq9JDeY49ryxG6i3ve6WPo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAST5fHvpGlPJen9f+iULe2VbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2I4MDk1MS1mZDEwLTQ5OWItYWI2Yi05ODY5ZTA3ZGFiZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQw/Egzi8TB+Tdf/hJNslzxGHAuTGAUw9NsKtZtki8I6YHE\nGLtwDMcViIEBwUP38i/zJK1fPsPTJZYDZSCilFxHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSXyfWdA08Y500h9TPUlWHjE7\nk4IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPOotrUSLej9VERf9U2QAqwPyuHcDbtUQNyf8hXyjxFhAiEAyHradxj1\ndUekRgb8wFx9/DQqZSyBhsbE0r9kTuMTr5Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAaHxFqcBnrNcoYZ3YcVrVHjqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk2ZmM0YzgtNTA0OC00YTMyLTk1ZWQtNGYwOGI5MzEzMTJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEyOWVjZjdm\nLTQyNjctNDZhNi04MzEyLTlmOTcwNTFlM2VmYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAJjRdmYvQ8VnilRA6ygMjUycQ3uj4i4WNCYdTa7tE+wqu91A25636oQ\nf5jTbyny8gLYp96B4WAWjdcuH6dyIO2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI8/SKj8\nUI2LeqnA34bjjnRC4YrbMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAMUY5cCffD7hi89TZfuM9UKdKCf+r3IP9JMuXfdK0/WCAiEAkFBHYOlz0E1F\nJ6M8wKWjPrw8m2K/Yv4GzoBUCqzcwNc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc942", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `942` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAegMUANXftjy+7gpG7oxqSvZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjYzAxZDk0LWZhM2EtNDQyMC1hNjhmLTRhNzAwOTY2ODg5NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmEzZGIzOWMtMDU1\nYS00OTg3LThkYzAtYzk1MjNlNzEyN2NjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEISAfS6rjRmaVu+09H8/EhjAIsn/nQzUo8EbbtZ0n+kbaDbPlUudLyXCJEF/G\nAqlikny46jWW/mlXA4swMSAjAaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURcvSBNn057P1lrSbWyxzK1RqdygwHwYDVR0j\nBBgwFoAU4SiwwbPYXHjGhupW7QV4vRjSucEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAlpwUV6jqLyZsAyR8o1fswDTbliGtwrISo\nX8XAnjPQmQIgKMyXKShbs+G7A8xts5ZiwjGwAjw2dmjnNZxI5s5iZ/c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVZov+o/4gOWSaAdCWUEq8ZHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2MwMWQ5NC1mYTNhLTQ0MjAtYTY4Zi00YTcwMDk2Njg4OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScEK0BUguvswylDPYaoJSYc8bdNogIMorEvBuQrVbuCuLq\nYQd1fxuukfJB5JPXM6t0d5P4cS/MKefSt9BIAp8Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4SiwwbPYXHjGhupW7QV4vRjS\nucEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD7lPvixi3drtQvUQmeZ8PrEffSXuLd1u+EGbP3Ys1CMCIQCcbIzhcr7i\nJYX2s/6nd6euAgxarjLl4KPRqIzX0ibSDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAWSIEoFMhyPQzuqTlc2AdkyhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmEzZGIzOWMtMDU1YS00OTg3LThkYzAtYzk1MjNlNzEyN2NjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhhZWNlZjky\nLWI3NjEtNDAyNi1hODhmLWFjMDg1M2I1ODE3NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNB/E/8meVu5aZiyuuXZnQz1h2b6uJsRiIgQL3njrtm/3LvXxCQrN1LD\nzsDNF1h3otlANVCYaCreCPY84Wdd01ijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEXL0gTZ\n9Oez9Za0m1sscytUancoMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgW71qrc4Q/pJGlITQtfDCtwZRrRbORuNWH7K+u7MqHvwCIAePdFxriv+NhQfM\nzbbXCTSUEeLVf+GDrvYW4NLMvrln\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc943", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `943` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAXo+QsxVZlriDIgHqvRymYmzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhZjU0MDVhLTk4MzctNDUzNS1iMTUwLTU4NmQ4NGNmMTA0YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTMyNmY4M2YtMWJj\nNS00YjMyLTkyMjQtMWEyNDJlMTdjMjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV/6CJ9xWqlodXhuZ/cOejTT0HsjTnXZWTjdEAOiVUo6LJfr75vPbZrWExli8\nxOl4B2FNGSf1RzJt6wMbYiaGEaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/g2fWF5+GUAZnEdwmss6BakZ7JAwHwYDVR0j\nBBgwFoAUaFDgiytTJpQ8/o2pkNSgkYZ6lqowJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEApGGbgW2GLQHG\nwQDzUgRs5Nmo3qIVjpLS7oAquJgb+5wCIQDhwjOe1kI+CI5ZNOR78PWcE4VLGObM\nxTNUQMI7PkgTNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW3tnd10L66nQyhiC4ty2T7cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWY1NDA1YS05ODM3LTQ1MzUtYjE1MC01ODZkODRjZjEwNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLmru6H/K1LGd17uCqvbl233+OvSEe8nTNN9jRv9GAoora\nI/CVBG0IKFB+MJmOp3TUqTm0tqQhXWaGG4KwZDzao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaFDgiytTJpQ8/o2pkNSgkYZ6\nlqowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK87lxsdzeFddx5RicZL8a4sfbtrBcI5k5NNtt+dPpk6AiBhryh3k633\nMChY7s2RX5nhz8L6dC4+Dj/PDqiSXFtsNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARnI1BUn7GyJQnFMZZcHL87iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTMyNmY4M2YtMWJjNS00YjMyLTkyMjQtMWEyNDJlMTdjMjQ1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRlZGIyZjRm\nLTU3M2YtNGU5MC04NGQyLTZjM2Y2ZTA5NjFkMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLOIjc2rH5daGvQcvkZMColocWwtj7jcPFYERWCcqY2xB+KeKzmTuheT\njAs5I0Ltimkp7zc6txDdmqSXzyl4X16jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP4Nn1he\nfhlAGZxHcJrLOgWpGeyQMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAN9TNr1mhelmCHstSmI3Qr5CqEBuamEGYCYJcWEJ3GhWAiAoLBJMDPR5pyCN\n+hIa8ASr26vVegW+CLHw5f0UHqoMqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc944", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `944` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAebgqY+SUvOI2ngSX4n3sl1HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiZTgyYzkzLTY1MzYtNDAxNy1hNjNkLWFhNWRlNTMzZjNhNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFkNjkzMDMtZTIy\nYi00YTMyLWJiNzUtMjc2MzdlNjIwYjM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnsBS+hiNaqdzr74K0gNWSAYDbZa+91rZ+W48me09z7RnDHYqbyeidvVNyQSC\nE7F3eCQ1BLspuehNzNvdxwxI+6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU54L61USLHTiUwn8RziDnzFJEjHwwHwYDVR0j\nBBgwFoAUeR5JRuZgaSIWBrvY8qCh/ckcigwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCR88+SUqMJhjmEh4rE+jigsOxyoLwTiczaWIfUr+9NhAIhALhzTj69GkYr\n6y+I4LwDMT3FNPlV0+RKXnYDt0DEBDsh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWxkI3L3OKjc8G9ATQDqnVHPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmU4MmM5My02NTM2LTQwMTctYTYzZC1hYTVkZTUzM2YzYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCOy+4izbPtE9FNqjvQbKrFInHGT4sJ41rzn0mZFEPY1ye\n0hsWBn81ByQrgYhr0peEv06XhkkcvBF0gGjO9Ebvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeR5JRuZgaSIWBrvY8qCh/ckc\nigwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY6C3+3/f9vs8mdJz092cROrzj1s7pCJiD2aRA1Vx1csCIQDwfL/qO8xC\nPMYKzjy6OCZ/7xgWEpbY5XbAbw7b5m3qEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAZKxHcxLkOrzYvuh30O0sv1RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFkNjkzMDMtZTIyYi00YTMyLWJiNzUtMjc2MzdlNjIwYjM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDljMmM5MTY3\nLTYyMmUtNGI0Yi1hMTZkLWFkY2Q5YjNlMzAwODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGL+eVAGXoZHy4eazMXQxT+kDe0QYo0trANwws78F6BR57RvQNGRzDl+\nCgSVL2nFdXe8V0H7pwg415zBjOBKYbWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOeC+tVE\nix04lMJ/Ec4g58xSRIx8MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhANZNCSPuPdl4op13gUdt4A3ktLzYsCILHexu0xQGZ/fmAiADcsBPUUcI1bgm\nBhXACMb1WSlo0E/PygYb9RD2Uh2hDg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc945", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `945` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbYIs+KUetgwoDVpu/NAyUuAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5Yjg1ZjkwLTg5MjctNDJhNy1iNjllLTk3MDg3ZjIyMjQ2YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhlZjc3NDMtYzYw\nNS00MzVmLTlmNTMtYWQwNWVkMDAzNWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJYD5tFOdp35y9QRbU67hf76twguPlPNDMLYUXcqlJci4PwJIYfp32xDZFvGp\nqNVM3TCfem3nYXS12IaidNLHaKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8RHmAQILZxJEqDEQw0SCMTf//kswHwYDVR0j\nBBgwFoAUYhbsR2i1fq7utak5QqfvoFpYMAEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD4ANdPFp6R9cnxmTVmigf6oAauuRR1U32FfbEp4q+X6QIgQNAL66G6n7ct\nVwUddcyJYaA+0o4lK6ViNxLlz6iyOT0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXd3F23WVTdOixH6ZElbGX3SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWI4NWY5MC04OTI3LTQyYTctYjY5ZS05NzA4N2YyMjI0NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfPOqAy4YglFhG1fQULBNrDMtQueYTQKoLsnXcklT5yqpw\ncFNP23htp0ue7j5zPFLbMLBkvU8rZutXhPEOzgxho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYhbsR2i1fq7utak5QqfvoFpY\nMAEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI1sWV+Id9XiiFZff6Vn8yiLU4Nq4p8Fu5hjilPUuw+yAiEAiNOAxAgT\nTLj6v4KdhL2LOP8w3d/DNMDtKd2WeZaaItQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAekWCarwUhDitzuXGnkVsmspMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhlZjc3NDMtYzYwNS00MzVmLTlmNTMtYWQwNWVkMDAzNWFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDllZjEwM2Ux\nLWEyMmYtNGFkZi1iNjE1LTAyOTIwNTU5NWViNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPvR/mocUGHgD7MFmOvMsdKJG+sNncjPBrzeneXvnU3DQahhmw7nFcHl\new+pnDRsSrna474UUqnJJabeKFzmuZWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPER5gEC\nC2cSRKgxEMNEgjE3//5LMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgFsIC/zCuS9R9qwBnm5u+EBDEtPwgbw5Q4WancT7N6tICIH5xEwHTiWvsi1ub\nnUiN7FQW8+q9JC67BSK8Y+B2BuSB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc946", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `946` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbU/jppKCT6nR5Vxx/WRNbhkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxNDQ2ODBiLTBiYmEtNDQ5ZC1iNzM0LWZlNzczMzAwY2Q1NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmExY2QxOWYtZWY0\nZC00OGI1LTk2Y2EtNzc0Mzk0ZWIyYzYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHrtzKckCuW2ZIBgZA28yM/JfQA/U6A8kreeilo5s7qfI04decukK3345WIOo\nCPYvTQY2fARpDKu6vY/wUGvCYqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnRuDz4N7ci/3QzOPGKnEW/QuBaQwHwYDVR0j\nBBgwFoAUQE7wBD7UuCz0NXLxUMStVp21RIcwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA79O040GeRohgsRmZM6YK9rgqALLU1F0/EKXW+LZM7k4CICLF+mhsF/wq\n3YoQae/aaA6QI0hVzxq0C0taBpiY8ZLw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW2M3jrCnqOEEV6ylY65NBaQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTQ0NjgwYi0wYmJhLTQ0OWQtYjczNC1mZTc3MzMwMGNkNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzrU1i9FjGjqQAIBmOrObAaPA0adE/EmgYo/Gg4+PoXU9W\nKXsMkn6DM4TKSVC1Pg7QrYdGxT7hu/APQyw6UAAio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQE7wBD7UuCz0NXLxUMStVp21\nRIcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhba8enO718sg3GZXHpi+G7ofkL0+QfE3G5BBweFeP3AiEAzg/jrq9T\n244/EMWyDlwmLOee2kENk+8SN2xHb8UdCtQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISATt1adFv4rLv74PEyWq65UjWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmExY2QxOWYtZWY0ZC00OGI1LTk2Y2EtNzc0Mzk0ZWIyYzYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkyYjg4ZDcz\nLTExNDgtNGNjMS1hNDIwLWYxZmUwNmU1NGNkNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJXgIYOHbYo7S81xfytQZVd3scT4h0MOmgAkmkMly5Jx5MuLJxVSSg3+\nl1sHGEQLsV97CDpqoRxNih3EUvRXLQGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ0bg8+D\ne3Iv90MzjxipxFv0LgWkMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAPaSPZWQQNFTZRcNsnY/YTTOslG+LLZZk1spuqGRKzy3AiEAw0ByBe+1Mi77\nw+3xnRbVWUkuOB+1TCG8qKXSiDEORLc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc947", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `947` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAbWF4i4SOww6EJazAyyX+5uMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxMDI1ZTA4LTNmZTYtNGQ2Yi04MTBiLTExYzdiMDFkMWNmZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI5ZTEyZjgtY2U4\nYi00NWRiLTgxMWYtZGRmZmU0MWI1Yzc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc8U7Ee8WbGZKTab8lAgabn2xlDlo5F65m+d9CY4EJ7XTHFFQQOO4It5oPNPD\n7DW7/KbObCJ9ISetMYeevZDBjaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ8mawryZMVjQOMb4HiXIMXoBmeswHwYDVR0j\nBBgwFoAUg7SO1LnhCcZJkkqB8HdD/axVAEowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBtp5ow38a42ZHSA55zo8G4UTImTzZVHn/+Baxm8m5g\ntwIhAKfVVyA2tbfrB9PPH4tLs/OZiwgJyHMjzxohdIsl7uwT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfgO6ZF6CxCBbtKhBmbpKXPsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTAyNWUwOC0zZmU2LTRkNmItODEwYi0xMWM3YjAxZDFjZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARX6vk0nXsn5ZG98LD3ryLmuK6YIpK4gV19L8MUjAjjXgLT\nn5IIJL4iSruQeK83pyyjcoV07d6PwA1a0H08txB2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg7SO1LnhCcZJkkqB8HdD/axV\nAEowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJz1A8Sesr19ci5xEpZsophciyIZ6Ey8UTaVF0a4t8NACIQCxjUPQNbU9\nEpBAZvqcBu1L/GJIAynXTYvUhn4XR5WA7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAWDF6vd6pFm81FfWs1T0N5YEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI5ZTEyZjgtY2U4Yi00NWRiLTgxMWYtZGRmZmU0MWI1Yzc0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRmZDEzZDdi\nLWFiMWMtNDU1Zi1iOWFhLTY3ODE5NjNmZjdhNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBoEk8yHe3Xos4eMthFbPt3Av0R+FJuh/Mw3355C1zxFh92hwyit1GZw\n6PtAyP7+nZAP1Xe729jvz0RfmhH/9kejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEPJmsK8\nmTFY0DjG+B4lyDF6AZnrMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAOZ3XFCn93APwBln37mGJWNXwvfTbZ544kAxI1xNSju1AiEAvXtwbYwZn3yh\n1eqdpAeSBHv8Kf8PIni72/k97za1ANw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc948", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `948` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXLpAVduz/7VjPQxDkTd6IayMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzMzhhYzc4LTc4NTktNGU5ZC05ZjUwLWUzNDBlZmU4MjdiMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTcyOGQ4YWEtMTU3\nMS00MDE3LWE0MmMtY2UxZWYzMjNkOTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED8LVrZuMkdU3lY1LRIkJ0/YFY0DqdtHN18eS+XvVsr2TE3F0r34vu5ZUJ9wk\n6VVr8mjXY71LqZ1cDCUyXzDxaKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPoeoXwvspaNAOzk6apm9q7ua58QwHwYDVR0j\nBBgwFoAURVYyy/D7lmWgOMLjL2lvgbEk+UUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBaghQBdS2Hf0K830HL1JL+LbJwLkWwGnd1cqEUlbwY\nRQIhAI9Q6T3Y0f4KZJfEZ74DvyBdckNf9qchTz1B1Eqdt8Aa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXCqYy/Wq7jL3AhJjYzEwiIaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzM4YWM3OC03ODU5LTRlOWQtOWY1MC1lMzQwZWZlODI3YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFKugxG5IA18ju7rgDTIzhOzondigttKApxDlVtxh1gru6\nmm1DH4RBBBqEe5xA1xFqWDP6kseee46p8tJVwUrTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURVYyy/D7lmWgOMLjL2lvgbEk\n+UUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJtk1VjNpyKatpI/qNfLdGTOhFw5W0JJuXJHNeXMu6UhAiBW6ivVssOx\nTWlnRI5UflApTVou5b1g1wTh8yTIaiTcow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAXz0ZteZ+Y20Lj5dEvaz9pBxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTcyOGQ4YWEtMTU3MS00MDE3LWE0MmMtY2UxZWYzMjNkOTU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc5YmFmYzQ4\nLWZlMWEtNDM1ZS1iM2FhLTNjZjU5NzNiZmU0NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAjZ+/sn4WN/giQh5xXlHjUi1v5DlT5xNo4HkAQ/WXajmEFWLITuGwyn\nsU+IUfoWmqAXkrB53rNAfxFWLn7z9lGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD6HqF8L\n7KWjQDs5OmqZvau7mufEMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgeoCXGhgBFC5R+iw6/WI5dhdSL/pzyPf7/93jHyPj6CICIQCw4W6MP4tHGVlb\nnWdRmZ5CiCYh7sc+o9fnK8Aw76Qgbw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc949", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `949` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAdITLTd7jBLZhpaJ9mzkcFxzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxZDQ2YjI3LWQ5ZDUtNDUyNy05ZGM0LTBkMTYyMzUwMWU4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBmN2I5MGMtYjI2\nNy00YzExLTgxNjYtNjNkMjYzMWY1Zjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvS1gp6gxrl3gSUvfS6N1XWnNQH31bzbC98MUH8fygFY4WZzxU7AlrqBvvzz+\noyjqZ03hHcCJiW+bTeiaaWRcpKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrp2qs1YFCILngDpS1yFPvZHsM0gwHwYDVR0j\nBBgwFoAU5KaQEQKAvwswx5RHNdUFIi+uXb0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAy++NMid0qVFnvDEJU6aIklW5mXVUIDQM3T7g1U1sMxkCIGsy\n7pfpDIpQ9Ap2gaB8FxiLix4syifVy564tN2KKJz0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcAEodWk4TPTkYNLFRdkhrPlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWQ0NmIyNy1kOWQ1LTQ1MjctOWRjNC0wZDE2MjM1MDFlODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASj70FF8j1hanePLsuPMCBgTu3SAt4BhKid7TlrJOBVuVDo\npQR5mDGLLLs8j1kyyEyEeyytM04anWjmgVLW2MnZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5KaQEQKAvwswx5RHNdUFIi+u\nXb0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSJaLbB03TEb/drRkQ8g0ullfEjZEwv9zOpXx2TW7kRwCIQDo7krHJqHL\nGPfbHrFH3Y3sRPOs3WVdtx5QPmGIQNqaKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAXXdlYdJV2/tO2RQz9vB67jRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBmN2I5MGMtYjI2Ny00YzExLTgxNjYtNjNkMjYzMWY1Zjc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkwZDQxMWM1\nLWZhNmYtNDU5OC1hYTU1LTFiNjhlOGZmYzE4MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEgq/9CbXTPHamz8AQKjGmvQ9iUVkJYgbavUZFJeGRpnldKAjY48xFED\nKdFSBALhZwa1XCNpGEC3HRAocRyXFu6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK6dqrNW\nBQiC54A6UtchT72R7DNIMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhALuRPyhLbQCVjxBX9uVonXtvqoxlD+sMxMtCQb3HInXFAiBXmdAbSIeqBoK2\njrOiiVGLaKSMl6FWcNXFnEZmdTI8Pw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc950", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `950` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAQPxeC7H9NK0QZolQsB2zlITMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkNDUxZTI5LWMzMjYtNGJjZS04ZjVkLTFiMmY1OTZmNGQ2NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZjZWRkOWItMDAw\nZi00NTQ0LWFjODMtZjkwNTA4ZmU4YjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElE6lalTcVA9TMMDuab8pVQ7Q3zdvmut6EqmFmq8RmeeDnroGUAqFonJsRd3u\nt9sbmHQ0itvPCKSM4+wPDwLUV6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCGNz1MYUUvPA5bxgBIA7rJFB4RYwHwYDVR0j\nBBgwFoAUrzV/y3YUjqWfwBMKvQ3XmwwZGlgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB7TDyfrmoG+sbvPtsF/KpDlerNJnxpG40d\n/Y9AzdN7hQIgetqkNpGim0cGuhJlWkXVJBuKyq/WplHMlmoPnNVuq6c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaLeu+qdYSP3iMo7SV0vtM9qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDQ1MWUyOS1jMzI2LTRiY2UtOGY1ZC0xYjJmNTk2ZjRkNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGPvrWhL5PFD59mtfKPrwLIpBOAWvpECnVCe58jwEH6hWs\ntpC12fqPkQb9B90UVHo2Hl/5z2PWXaEKApeM8M+Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrzV/y3YUjqWfwBMKvQ3XmwwZ\nGlgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNkl5cI8Pm57GUFmVyJOVWhqvQ9bDJl1+LvslZkm8ZpsCIQDdtPRdFGTP\nopJME48cHYVPmmwqcICh83t07IIQWxcsCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAaz36C6pcRK9aGUtliEjiArTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZjZWRkOWItMDAwZi00NTQ0LWFjODMtZjkwNTA4ZmU4YjdiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ0NzQ5OWZl\nLWNhNmQtNDM1Ny05MzA2LTAyZmMzMTI1OWMyNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFr208luPZOPxlTy/W+F//lg0G/iDhXDWVowINMYk9PTmyzJnzyjkBHx\nyNtvgT40tLFq+4gsfePzuvQtbOaB97ejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAhjc9TG\nFFLzwOW8YASAO6yRQeEWMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgctyUTrx3Q+4vdkuGmj5XO6jP36ZVKhmjAtjnNvT3en4CIC2GeVduiL53vDzQ\nf9YZ+NBd2zzvUqI74aNb2jNDu9EU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc951", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `951` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAVNagL+fllHxl/0bsY1flWIEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyODYxMmI5LTQyYWMtNDgwOC1hYjQ5LTA1ODMzYzgxMDdhYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE5ZDBkMGMtNGI1\nNS00Njg5LTljNWMtNjI5MWFlOWVkODczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoLST4cuYvWkHCwMmQEHtCxphx2eURuF18/DndYttsvnYF9W1G9nzbYU6CBIr\nFYjvqF9iuyvXBJam3cHOqiGWg6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDpQAKxKb/+7Xw8u84BnNMhglHh4wHwYDVR0j\nBBgwFoAUY906ZIEvpfLwLZEvUQ4JtcSYU50wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA2ptm2ZueSXQN/Zt9TQ1boYMGXXr75VHb\nz781QgLzWVoCIQDWr68dYqgiH4ff4h4fcvrFYibSsv8+n8Xlr8otMPM5SA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATfhnsjhVjGjW74JqI+6lRlwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjg2MTJiOS00MmFjLTQ4MDgtYWI0OS0wNTgzM2M4MTA3YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkygH1tui1y5Pv3yZbhdffiN/WJ0cP75TEeNSVenzyVrv5\nGGFgH/hWVaxhm6JonnRJcYCrf/DtF1m4TJMiDaTno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY906ZIEvpfLwLZEvUQ4JtcSY\nU50wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIoJd/xafBzXtATnUyXkf/f/ObhGtqJ+aaPeMVS8qAA6AiBjyRPD2IM0\nvAn4evNZaJ7G95kmeqCdcSV8eU4FtRcFtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAXSib506CrghZhglrr3dW8pCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE5ZDBkMGMtNGI1NS00Njg5LTljNWMtNjI5MWFlOWVkODczMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVmOTQ0YTc2\nLTRjNmMtNGZhYi1hMGM4LWYzYzE5ZGYwODFlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKn8xsUL61ieFPORTDzVL6JPLc2bt20Rab0Rh7apWDnwO3dqzxIVF2KG\ni3KtPurfg8o/TnGQnRFITCG/OEQ4tjmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFA6UACsS\nm//u18PLvOAZzTIYJR4eMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgPe3dWe1rkcNfs2GNSGud1DzLpFrdzhu0Hz0nnfxdnZkCIFBuPP7AuIcryQVh\nh/Az/03r6I8+C7Ni2DKtJH20Hcpi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc952", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `952` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISARTrg/HDXZq2k4Hp5FVRKaqZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhYmMzM2ExLWY3YmYtNGY4Zi1iYjYzLThlNzI3YTJjZjFiODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM5NDFmZGQtNmMw\nYS00M2EyLWFhNWQtYWM1ZWJmMTY2OTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETPj5YDYhUaJj18ll8A71uG2umGX1UKF1iWlRUPpCkytlHJfUzGurjrFsx7FI\nghdhvS7dhEBJVuD/D0F8YSiITaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS4v814nacFE3Ng/VUmm5OUAQF0owHwYDVR0j\nBBgwFoAUD2YEtTstMfuYnrmuvQ0377giHMowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC3MPrg4az9pvqYw1pN1FJBYI6w\nglF8NPkMtmM/mQFFTAIgdf+HeGdRDWXNKB6x+BwmU+0OoXoSfh05aHubO75lETk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAST7uwnn+VGP98gKquVUDjcrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWJjMzNhMS1mN2JmLTRmOGYtYmI2My04ZTcyN2EyY2YxYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGL9gBoR+MbYd4WXvyPCMupQvjXLdHlXufXqla8YzAGC+c\nniuvStuBkvSrso35PbS9H15EhfQPAUqkBzcPVB6po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD2YEtTstMfuYnrmuvQ0377gi\nHMowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJLXUMlEJzo1bhnfubu4mMERRSnYsNC3oKdIqBvAhV27AiEA19BSBI4H\n8HmVmL3xX9h398L/kQ52SXkd1XAUzwy7/xQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAWfoWg2BAHnzvMVyiNz20hvlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM5NDFmZGQtNmMwYS00M2EyLWFhNWQtYWM1ZWJmMTY2OTZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIxZDU0MGYw\nLTEzMjgtNGUzYS1hNDg1LWU1NTJkOWYyNjExZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNYDtnAc3o30GnYWNddAaOB54fDcx/bW3MAtvWIn49F6hvp3mnAQ+8Vg\nbuEE90YAh5peONix6VabyPoQP9kzM92jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEuL/NeJ\n2nBRNzYP1VJpuTlAEBdKMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgdqIo6/4JIsSwUcEbthV+mEgdLAWGiohGKCUj6ftVPesCIQDAx76SDkGoKSfI\nM5ZINtrEPExK91g653B6WFDMJ7cSOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc953", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `953` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAWAzLNZX8/uvqNRh+OlLeO25MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwNWU4MzhiLWFjNTktNDZkZC1iNTNmLTFiZDcxNGFhYTg3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RhOTQyZGYtZDky\nZS00NTU2LTllNWEtMmUxMDg1NDNhY2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIka87UFn+hxTQ7NbJltOFTmF23acP6ymcTW56HdwD17voi42pt1TnOjxvcyw\nAhh9bbfkNr2TjaGzCwAeSdgLvaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0EVbOsPNF0aRShaUV6VjsOtnIBcwHwYDVR0j\nBBgwFoAUsygaMCzziYftoG7+YxJBrMj1L+0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMgUbq2d\nJpms+1vSrsR1CvKP/TQRAtYNfYCG1z7WE3AMAiBt5BgDQjL7urK92OsChkuFDU8s\nZtzc14sAbbgD9At/cw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc2fjzuCZ6OXG7l6jRtyjDuvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDVlODM4Yi1hYzU5LTQ2ZGQtYjUzZi0xYmQ3MTRhYWE4NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLsJ1bfoW2KyaEMPHNlbz/M1Ct0GXWUtMc7d0KIeSPVKDi\nAL/elo4th+FqE0wUVdJqgWIXqT5RqOfvJaFqhzqwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsygaMCzziYftoG7+YxJBrMj1\nL+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIDvElyx7MYiGF1Mt8sl+mb4k/6Q6U1fB0RUAJDUUskdAiB3LYYAzi+c\ntJmsfnLS/F9XZuhlDVhG13T5AYmEPHU56g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISATmby0SMvJmg/jerzMeKA+/yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RhOTQyZGYtZDkyZS00NTU2LTllNWEtMmUxMDg1NDNhY2YxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdhYTI1ZDBh\nLWY4OTItNDJmNy04ZjlhLWJiYWZhM2QyZGQwODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGRMfEtmInLPyXbe7X0ux/1KsYp8wGo6nfX1GWa1ce5kX6XwbWVO7dOs\nwY9o/Yk5gahnYXD9MZ2hd8Ll9rYAg4CjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNBFWzrD\nzRdGkUoWlFelY7DrZyAXMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhALss6xAUF32XFO69uA+T327fGXX+4My0f3XgY0YK3x3TAiEAg/GevXfeF6jx\noXz91ZaV8oihk2qpUmjPFifDh0FwR+E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc954", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `954` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAWLTs1rR+/d7cmMj4BunMU2ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YTAxNGNjLWEzZmQtNDkyMC05N2U3LTMxZmI0ZDY4NjYzZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRkNDYzOGMtM2Rl\nMC00ZjY4LTlkNzUtODc1ZjE5ODBhNWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6SbBDPBgQ1l2sY/DAtrEtXK75a7zqRMP3ESHW9eFdiKMfkwCeTOzJVMPJdeQ\neZsF8GbO4Gn/PO6woRISJqvOgqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw5fzQ0ExFr95l8+nM7l54t9chfEwHwYDVR0j\nBBgwFoAUvC7wfpqmh+7Mq6jvWUIaCyYjAV4wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMlJKzMz\n8ZihB8dUimFFXadW3ZaezFmRevQgKUmjyqVnAiEAl/tSJrrNLagfi9FfAG16Gg/n\nem1I5Gc4rEFRKpVMGAM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaB0yq3Rh2vKDb6caXTXSQRPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGEwMTRjYy1hM2ZkLTQ5MjAtOTdlNy0zMWZiNGQ2ODY2M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxVs4RNuRIIAlOaUuqEswCerXz6lJ4p5UGSgzxO+ZX/h9F\n3v97We8lodG/HV/aBhmaOJO0eX66yk6fsD6+9GPGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvC7wfpqmh+7Mq6jvWUIaCyYj\nAV4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcOvxt/9lCIUxrVP8msK9UEdgEQ93hDEgzFknwTjV3o4CIQCqNfpQOZdz\nnZLUBYqcfxf5D6SeXMgypxwUfuX3Q/WWmw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAdJSVEqBpr9aVXmHjEiRsj9sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRkNDYzOGMtM2RlMC00ZjY4LTlkNzUtODc1ZjE5ODBhNWVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYyMzFiNjI2\nLWVmMjYtNDgyMC1iNjhmLTI3MTI4NGI0ZDIwZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEfTygddGvct18CqDl8uuISAb05Kb+tSSGVgM9x/gl/AnUpezcLimM0k\n7FtsUdh1dEAhxlWqU78D1Jj/jSRD8fyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMOX80NB\nMRa/eZfPpzO5eeLfXIXxMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAKpTjZlNqB8OgrV+yySYSucx4+SUr9KI4Ptu6lztb3JRAiEA4Us/p1Z4lVQ8\nH0RcXKurXG5GrxtsmkrRGeFVpHSKN2c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc955", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `955` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAVUQNEsiUZQRXxXBoJnb1dYDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5Y2U2YjE1LWNkZmEtNGYxOC1iZjVhLTMxNzMxZTQwYWExYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2VjMjM4M2EtN2Qw\nYi00Mzc5LThhMzMtZDdiOWUxZDc5ZDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEshP4o17BO+7YI8zwcfYZzmVp6dPex+Smq1c6sOGDP19N7F0nlZW+PvHzjouz\npR/hmMb3qxXWW5cjf2QVhBsZIqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Pw0gwhfX/SvrKFCBmbGt8z6r9owHwYDVR0j\nBBgwFoAUhdQPenmzx2p5eH7l3MjJvfawEVEwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCCjre7\npv8mSEthe9jtzloQQ/C10+YMdYSzf5/CG6RcoQIhAKFX6LyLygmwPNDt8Yrrfsuv\nLoh0Li/rErwjEcrQdhYH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcwlyZ/ALAvps5FNzXcNOv7TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWNlNmIxNS1jZGZhLTRmMTgtYmY1YS0zMTczMWU0MGFhMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg0mVa9oPeNDjexBOSODH9uB3qlOLSj0kcZdPorvXju2eS\n+hOYwmNMFg3p1sYyjIPLmnoRY2GVelycDGzAnnTgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhdQPenmzx2p5eH7l3MjJvfaw\nEVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHDsGRaB6wNOgPA29+PLzqb6OO/KLFOWD5AdrDcX71wICIQD+brKmWjZg\nqqesAhymmPrPU92YaFV8IBBzU/OB8n9sEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISARVMPwiJUR/fhTshWBOcyp0yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2VjMjM4M2EtN2QwYi00Mzc5LThhMzMtZDdiOWUxZDc5ZDI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYzNTRhMjhk\nLWQ4YmUtNGI2Yy1iNjllLWMwMDEyOTU5MTRkNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIhLsipAHXfjEzH3Sa4cp0NffwAIv5bU4wKWUTjYcashiyg755MZAnc6\nPG9GRJinKyihkgR+zp/2/DeoV7VJO32jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNj8NIMI\nX1/0r6yhQgZmxrfM+q/aMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAKnb9pxC3hDD190lEmBrihWLAd5m7Slkeqv+At2QhWkWAiEA8Bi9Wm7l/Ukz\nQ8eqddHMfWKgTv/NeVOSy6rF3O+9X5o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc956", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `956` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUnj21OP3I15OXeh/Pa360iNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlM2Q5NGQ4LTIwOTctNDlmOS1iNTdlLTY1YWFkYzliNmZjNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk5MGI4YjktZDJm\nZS00NDA1LWE5ZGYtYzI0NjZlYmFlYzc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbLqzNPuaTg0PZERnWC2V/gSgjr2yD19+jgt3r5ouE0ol+k42ZhHyO0OTtsd6\npIqoNzy3ks6imF4RxxWNPHZqWqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdgizB0Q5yb39OhhXReJbGdIZsPgwHwYDVR0j\nBBgwFoAU2TUwORNjrAKxnR5tB6ow+ZbY58EwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIDVYVxLlrTg3Q24Bb1OQ7qC5/l7J1lln0XRnZm16YWA0AiEAtBqZ8EMP\nWRa5t7nbHeJBEjZ6zFUfUMdBT9MBcdkS+Ww=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVCu0OwtFaSdtbqG4Bz9q8zkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTNkOTRkOC0yMDk3LTQ5ZjktYjU3ZS02NWFhZGM5YjZmYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFB7KKPolsmmWx44suqK74O2m7l1s3kdby9HF9bjvwLHmy\ne8pw/hVgyBXPO7YuJUheMNwWjp3odvzn5CVAFp/uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2TUwORNjrAKxnR5tB6ow+ZbY\n58EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALbw8+eGJHXejzhDuzU9qNdtACNQhqz/KEmOyUrjrZF4AiEAhCfqdObi\n8DlggaedJp01TNMp0PdpKTq+YdlfYMWbQuY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAbnjU7R+q18z6v9hrPUbTkp1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk5MGI4YjktZDJmZS00NDA1LWE5ZGYtYzI0NjZlYmFlYzc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE3N2RmYTNl\nLWYzOWUtNGE4Ny1hM2I1LTI3N2I3MjBjYjlmODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMLYIT+uNRUrIlA5Az2JveVFDy0BJSCVpvC5Okb10KxjFoGwZ3f5uxyR\nuIMKqvCWgLC/t73Iyb2pDSr9oV0H5mCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHYIswdE\nOcm9/ToYV0XiWxnSGbD4MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgYpp1IAeYI5FL5usEf1dUuRg/SBx1pAybgWDhah9ltK4CIFrAQk5KRQ7Ykc9V\n4ta9m03lU5l+7VjGisFMGEWNIVGA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc957", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `957` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAY5ZJqA6idjDlUAuiBa1duLkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMTdmZmU0LWE5N2MtNDFiYS1hMWY4LWVlNDhjOGU0ZTNjODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRjYjYxZTgtMzg3\nZi00YmZkLThhMjAtZmVjZjUxNmFmOWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUYfIXIlRMOV9EY27C1TJaxndltco6LsCQLs1Q3IjhIqjGqIppGLEz01hnpbO\ntAmD7yZ2W4CW4MvtWJuYXtGx46OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs7EP14nPgSCGHBWWDGY1087cjUQwHwYDVR0j\nBBgwFoAU4kj3aV5eh3K0xgeGYns8pdKd1/8wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCC4lON9jYRc8nhyYELTDqwy77ILEGez6IHvDYNm51+qAIgZG6a+0qf\no9gPuEr9Dr19l4a7Ibajp3nu8Oc0o928T2s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfhneIRZZGDZgUmM+d1DSxTfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjE3ZmZlNC1hOTdjLTQxYmEtYTFmOC1lZTQ4YzhlNGUzYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXq2CHYC9Qn9Pq4VtxhaWjamEb8LD28RD7I83RK8EDKsoi\nNMnPCrFszGj+nF2zX19OvgZ9SK6eBgAGkKiZb4oho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4kj3aV5eh3K0xgeGYns8pdKd\n1/8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOaA+OnFFKdN9z3OhH8fII3igDcSXD28TcL+EYf6fxztAiAyiq+ZhhTa\nWl3DBDdFdEpzZiHS6VZ9MpAFXNx1WfeGzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAdJBgjiB3tpejYyCifRCbuP7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRjYjYxZTgtMzg3Zi00YmZkLThhMjAtZmVjZjUxNmFmOWFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIwZmUzOTE3\nLWQ4MWItNDc0NS05YTk1LWI1YjUyOGU4NWM5ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ9zrGCLToh3/5fB8FxbfKiezwr8R4ao4A9dNlSHMHD0g8eCEm0QSNeH\nN6Zpe7qhy0zx/bjxHt/r6ksK3/LQ7HKjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLOxD9eJ\nz4EghhwVlgxmNdPO3I1EMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhANY1iqhTm5kDRf3TSN2dZbXswFeCICzv6BRMC7NfXYqBAiEAxnsygCxdqFBi\nbtZYfvC0mLvYnsX0YBUhXts0eo7qfgA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc958", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `958` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAc1PJE6M8pyQMKKPdK6leHRqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlZjMyM2JhLTBlM2ItNGE5MS1iMTJlLTlmYjNkODE5NDc5ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVhNTYwMDEtZjAz\nZC00NjBhLWExYjEtOTY4NTE0MjRhZTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEozMTqyYZhNys6VcI2EeAi2qSp6imlV/tY60geGsTylrtm0kDYnVbxV64MS2F\njLQ+JorDP0sXVRngFKi4tI6MyaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUchmCSpia80O6oGxZoX0IoIwTzHgwHwYDVR0j\nBBgwFoAU5D67L/T3amHYuyqRtb/WPjvGAbQwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQD5cfdzw6G4ZO4XS7byPrBWCn0LD7xCqpuwWoS5CSjbRAIhAK4QqpyhZr4KTM45\naBNpztjx6UYNgtsVjNtutMa3//vX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQC3EyGabLar27dMfOplNXoaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZWYzMjNiYS0wZTNiLTRhOTEtYjEyZS05ZmIzZDgxOTQ3OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLB/EZzMRMMWQDZsih2BNdLs7EMnEKQmqJ3HBV70yWn1O+\nKPmL71LzxLSQ04VnuQX3sbb5rw/Ml08KlGJK4nmzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5D67L/T3amHYuyqRtb/WPjvG\nAbQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPAkM8izhPD1jCWjXyQT9EAzwO/6woFnjNC32M43tNIUCIHwUmJqCKRvj\nSUM7f9PIOLSvsXRmLNJc5jjD8IYQxeNi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAU54t6uccFvbUybawPUGylHjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVhNTYwMDEtZjAzZC00NjBhLWExYjEtOTY4NTE0MjRhZTQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM2NGJlNGNk\nLTk5NGUtNDM0OS1hMjBkLTA1MWE2ZDRkZGUyNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOeI/IWyiOdtHi6rdeh36v2mlABYhgbIHkP1FqmAvWTQdCzXYO/9euXw\n3eouNfY+Uj1BimreK1b+PU3KOVg1L6+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHIZgkqY\nmvNDuqBsWaF9CKCME8x4MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgXBKwBTvmpcNF8Pvcte5GZ+rRdz5a9Uh4fzFlsccTc6oCIGF2WrWgmoZd40k9\nxtrQe34H+kylYSGzKJB8fb1v7dN8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc959", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `959` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAZxKxLjOn3ji6UYBHwCBQQ04MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1NmQzZGMyLTgyOGEtNDE4NS1iNTkyLWUzOTU3Zjk3ZDU1YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJkYjczMjMtMGRj\nMC00ZWJjLWE3ZmYtZWIxYzdlNDZjMGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7xJbvvjOXg2FAndp4pZ7dP55IvfmxycibNswzp5IKqVYDGwJl/TWLyWiW7VZ\nEDIpuOczBvptNJZClm7hO5/3maOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7TmPQRiegyC42zw16Y6/Hj7o8+4wHwYDVR0j\nBBgwFoAUfRF6MIPCs1IdMRVEvZVR9zR1CkswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIHZr6fceHgiSx1804ssjhGqS1dsV64y/DEAhRdVcnzd5AiAd\nhU1BmaIx9tPjXnRYumyZ2sh6VsM3AZBhdUQ1DwkbUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZtyFrvhyk/kMbND5smNm7wcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTZkM2RjMi04MjhhLTQxODUtYjU5Mi1lMzk1N2Y5N2Q1NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHsIAPRJt40No6XlE5BW+IH420805QI9Lxb77RxaY55D/h\ntqMLLUB9+bjDkHCo/Zn68MlPQq9Ngo+Qu2viMo3wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfRF6MIPCs1IdMRVEvZVR9zR1\nCkswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMi9BKDm5WBpMMMCrVq7j+WTaPFrdK8Z48d5rFyPhUGICIQCeeXZmcQaC\nw+Ecg4AsavyUx+unIeZii6O6ex9dDCOtVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAR03KuNrLkjcGwLW+jReEf35MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJkYjczMjMtMGRjMC00ZWJjLWE3ZmYtZWIxYzdlNDZjMGI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVhOTZkNzlj\nLWU1NTUtNGUwMy05MzFlLWI4YmMzOTRjMjRkODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJMbFzDJgSzVxvzTCIJbSD6epXVhw6HAZ4wpn3OwvLi3I+rv6/BW7bOC\nIwc8g5WRUwlWWP1Jk2wiLrmpamVQvrqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO05j0EY\nnoMguNs8NemOvx4+6PPuMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJV2fgtHpDsI2cHTmAbOA5NMUHC4MFX11i0f+2iZGa7pAiEA1Unru9qzxIaj\np+nDblSQzlLbVFrm/2T0u+qdfdurL1o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc960", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `960` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAdxymtlNf/oimWoqjX+CYkjwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwOGNlOTVlLTY1ZDQtNGRiZC04MGM0LWQ5OTYxOTUxOTJlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdhZGQ2ZTYtOTkz\nMS00Y2IxLWIzYjctMzgyODkzYjk2ODQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE76iLJx4/PKGKJqrDZuBdDT7L5qebRNrCTsnhr0y/Xt8y55YpZ9rVQv7JBBJy\nLJw8UNxT+J6/Va/cW24tmmWlqaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCQTcS6p7fT+gUh4eQhvuhTVgKQkwHwYDVR0j\nBBgwFoAUm2pES5GIkSHoLJIhCa7/9q+2yHswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQChlpJ1yrtUIEZvXP1B9uynN+w9wtUwgayH9LFqHQN95AIh\nALOH99Sj5XjlV3l3s2hEww6g2JAVLg+qEH2adwTHW3+r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASnreAOjaJea4q+QKDDHnjZgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDhjZTk1ZS02NWQ0LTRkYmQtODBjNC1kOTk2MTk1MTkyZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5EBT67nWMh+F2ibPd8cMnNBTX/Pbkc0Js+vmUI1e5gFk1\nPknW42wUZAOEksBS+qHBVPTjCqqZZPapQPmpIo7qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm2pES5GIkSHoLJIhCa7/9q+2\nyHswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMRjPlRbM9rnKWSDAdFKu3dzVidET7KGJkzMqXT43rleAiEAxUAwDeZ4\nYxJo8LZkZvNOjqhHLnYKDqFx7FBNgFg5l1g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAXrfYXJQCgVh1A5IldJXtGgzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdhZGQ2ZTYtOTkzMS00Y2IxLWIzYjctMzgyODkzYjk2ODQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJiYzNlZGJh\nLWM0NmItNGEzNS04NDFiLTc4NTZiMDNiNGVkMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN3D+akWyoAEqOWRKP5YRD3zXStQOrXDUghbp2G/KpdEM2i1RTpUoJj/\nkvd0R5I6PtbNsUlWgLr68vy5DaUSIaujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAkE3Euq\ne30/oFIeHkIb7oU1YCkJMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAOJsy4Dxxl2yM2K5hxGSJyP8Z70VBQRbbt1IH3njcCEmAiAhEY5oXNfeqN6V\nbdjjK5J70qQx1ZZJNw1B1dPVeRo7ew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc961", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `961` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAUIY5w9vRaWgGDw0oq/DQ1PRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExYjEyMDk0LWUyYWUtNDYzMS1iNTJhLWI5NGVhOGI5NDdiOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjIzZTg1MjAtMTky\nZi00ZDk4LThkMWUtZDBlYWQ2NTg2N2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi7Z6YJ1bt/HEFTpOwRtLWVn2O9GCYNZvvzju8UYweHwHFUANPTsL4gj7/vmx\nE3k/6A/M009gTyE6AWmTFjWwJaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwDDd6YxNAb5M5iXlJKY8AxdLeMMwHwYDVR0j\nBBgwFoAUQGMvJVsIHt8k+a/b3Pld6mCzYogwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDXUHFdNnt0\ndRCYeIrQ8uFbrjd2+10wfSj9++t8eJ2IygIhAKxfu6PLNNNEDVh1BEfVM9fBkmNh\n83igqVVjHDoDmK/8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ+1oWrxi5+0J6Mhg9qaigHVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWIxMjA5NC1lMmFlLTQ2MzEtYjUyYS1iOTRlYThiOTQ3YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnYXMeba0LTGTRBRVpV2MCn1ig1nSOJ/5NRLrAU4EYg+l3\nKbTLyWKHF39rAaZaPKB+rv7Pyn0u7K1knxJGOcggo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQGMvJVsIHt8k+a/b3Pld6mCz\nYogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOcBcpo6P5V9UzyPgx8rmLBm3+ET7p31DKaVTNNYCKZ+AiBxLLJNCIq6\nlM/jlmJfzBN0Q37dL8cVkoin9sl3tcAjkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAW9yPDPoR/GyLMCTXkhUFEyyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjIzZTg1MjAtMTkyZi00ZDk4LThkMWUtZDBlYWQ2NTg2N2U5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVlMjliZmEw\nLTBiMWMtNDdiNS1iNGFjLWE2NmM4ODE2YjAwMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDoOLHvKrxgRWekslTPVGrGmFGYweRCyfW0f4jd7P7Vdf+Up7llHoimh\nKzUfj0BMIpMkXGv+W3K3mxQjhKz6cQWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMAw3emM\nTQG+TOYl5SSmPAMXS3jDMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgdwwwMaVNOiI3UQc21gHH0cnEImcHXExajzx+2DGp9QUCIQDBOB9HiqCv94V3\nlLDBhmqhhNqZH3qPuKLpG5nZpRCsug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc962", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `962` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAVBJeTdJrToQd8oV0N1a8z+OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzM2ZjM2RmLWNmN2MtNDQyNS05MWZlLTAzY2Q5MTIxNzFmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ0MGNmY2ItZDI5\nZi00M2JkLWEyNzQtN2VjNDc5MTdlNzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv2V7i5DM77aBHWVXFyE9LU+ALFnLip37CK/VZsc2yoAKoS3jy8Aowy74KPfO\n4sE4G7mxfUEmzaoTIRWPRZ4MU6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTXaojf+wokk9Hh6JkaZNvdS2XY4wHwYDVR0j\nBBgwFoAUBXj7f3UB8o5IqhDSgSJW245KFzMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAINv5oV4HxYcjzVrCs3Cdhs89RKvibdmSVJZ4WGIGJEVAiEAnaNwbJF0\nCpyk+3E14UHB0D89ZEWOkRpkOXoaFp/7TvQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZIFjLA9ucEqQZ+/unfGE2wAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzNmYzNkZi1jZjdjLTQ0MjUtOTFmZS0wM2NkOTEyMTcxZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQE6jVToe86bKBJYUiaCTMo2GX5ceV8rg/fyH3E2z0CgXi1\naeoLHlMNsd/vMTcnfCd+oUywMLX9SIVddcV3lLouo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBXj7f3UB8o5IqhDSgSJW245K\nFzMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfrOB1rnqNgcPPKuPT4QGsoCjDYzDKq6PhpC2WZO0DpcCIQDBZ6mU90T+\nmgA8TwrBKSQ1hyhaR91S0GDFpmFVnuolhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAZXmde61Qf0qhqx/ELEcu/n7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ0MGNmY2ItZDI5Zi00M2JkLWEyNzQtN2VjNDc5MTdlNzM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM0Y2QwOWQw\nLTVjMWItNDFiOS05MWI3LWUwNzRmNzIyNWIzNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABACKmpGzMmjoQYEaPi0dMROIsaNOR41D3FmS8PQFizZPb2+ndh9v8I7J\nNuExVbILD3AaTxb38MZCCdVkXdPqSyijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE12qI3/\nsKJJPR4eiZGmTb3Utl2OMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgQjsvFzxAnnNArKpTSp8ui3Esym8pS38yRiDeMYI+SL8CIC7nZ3Ss9i5+gJRo\nTBqjmeCXDzF20Mwv7ASfYam8SBkc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc963", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `963` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAd3NxX23J3ghLpRM82SIIjriMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmYjk3ZTU4LWMwNzAtNGE0ZC1hZDk3LWVhN2E0NDVkODk0NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I2OGIxYjAtZmFh\nYi00YzUyLThlYTMtOTFmNjc1MzM2MWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt5Y6DEGp3ADhdv4xZMqJAq+9dh3bxleaFxCAHxmYzqI3gFIBkP+DbXCKRBQ5\nXexMHStR5no4nYu+j4LJqoDDsqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULLMcJ7/GK74zi1G0p+n7h/0RjeIwHwYDVR0j\nBBgwFoAUeb9WDJ2owVte3fI2E6eBMkLBMpswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhALE2f1XajX3aUbuNEJcZkthWJQK3/jyC5/ydgC/pyje1AiAivX15NsOs\nJBtT9t8R9eTebcp8xiiUPdywRIk/tUU67A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY3bNoJdnHLP9lqtaidM2JpxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmI5N2U1OC1jMDcwLTRhNGQtYWQ5Ny1lYTdhNDQ1ZDg5NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEOItJB/OdksY8hLqfuy4V7cvcK2Sj2f5G9g8BDm8B4g4a\n5FPz2jARHHjh5lis+lwSyIWlI3aMadE3AEdhSxKQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeb9WDJ2owVte3fI2E6eBMkLB\nMpswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgASTIZfvDzTxuQLoUTVhbB84jcfGbOgCoFdhacalqOksCIQCfv1J3pQcQ\n5NKdmT1fqbpzehnToshCRj/s9xUNHB7R6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAb18Fzgvz8kRznP2fW8RmIG2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I2OGIxYjAtZmFhYi00YzUyLThlYTMtOTFmNjc1MzM2MWZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBjNDZhMjg2\nLWFiYTMtNDlmZS04OTU5LWQyMzExYmYxYWRkZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO6sJRdCSiLuqwhc81WrflTo+glVlj3PwVRdKBBmbf/TrKt1a9pHNBOX\nlFSPTwFGKcHtVJ0YKtKZsoXBVcZjalqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCyzHCe/\nxiu+M4tRtKfp+4f9EY3iMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgcdzbWuLYM0DT77pf6LawIlXHBk0qmsJ1ZaezpuhkRo0CIQD9YwRFmrBcMlBf\nCRqU4SnJmlP4pK0h7JM0+rxFWD0eeQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc964", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `964` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAYKhstbcp55MNFaznpAzVXqSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3ODY4MGFmLWRlY2EtNGMzZi05NzkwLTc0ZmE1N2U0YzU3ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ1NWE3ZDItNTNl\nNi00NjcyLTgzMDctMmQzMDMwZDFhODQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaU5gzhZh39aMPUdS5QxTU65ijDWyl0ZJl12NlqWGb3S4ueuvW5cKTDaDrIs1\nlqSsdyzRjEHYPiVO2PplB6GN/aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhNl2B9h35+r4XE5GSLZohfHUDQYwHwYDVR0j\nBBgwFoAUN6lce6SNAsbhaJ3X/Qe61SXHTNIwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDVsOlYesx7i1O4jVnD01v0dHwN9xERqO6W7trHukMW9wIhALDRtJWz\nkYFS+0YySSiUBCYbFPcEBhdoCE7aPimFXa4r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbnK6AoL88Xn6WqMjyhqvttuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzg2ODBhZi1kZWNhLTRjM2YtOTc5MC03NGZhNTdlNGM1NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZaXjervHEzG5PgWAVP2Anc/cQq/4J5Swbu1g2wEWxFLRv\n4vmMCPkyiPCfOeYfPyC0Dc80Ds7GOs/Fx3tqaHXzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN6lce6SNAsbhaJ3X/Qe61SXH\nTNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdsL3zVoYT5fO7jIMB2Syhx9KPQ6wrr9T+xHudQjVRVoCIQD9gbehyLxv\nb3N8EWtN2a+9KKIDd4PKNKIaOSmPFTqiVw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAfWpQoclkEgEOEV7EBSO4EqtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ1NWE3ZDItNTNlNi00NjcyLTgzMDctMmQzMDMwZDFhODQyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1MDg1MDQw\nLTg3MzQtNGJhYS04M2QzLWRkZGM2NDg0YWZiZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKbuUR2fNEpiBTMSqa0hBjG0CjLOcFHg3q3882oMLtkX81ZjeGXy0F2J\nt1o4C00hXX2BPvBEbqZiOhIr6Cmgs3WjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFITZdgfY\nd+fq+FxORki2aIXx1A0GMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgfPfsu3H1HYQJc06MWOvc08RIvlOElEZbi9xGqilIalMCIA+DWKVjDdaQ0CAl\nhGPyL8Ys+5IGio3pab/9EiFAydUw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc965", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `965` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAQLdpjYS/uvEYaGRO38JPEmHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNDMyZGYyLTc4YjEtNDVjYi04YWY3LTA3M2RhOTJlOWI0MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM0ZTEyZDktMDM0\nYi00MzBlLTljOTctYThlOTBlODdiOTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5xTNFJMYRo4aQ6roSb/8/XAaOCK3WioAqCa7mOE011AC2v2dD9pLPCri7BAh\nzzSMRF1gkL+iCmZvK5JI2HFm56OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqYw2lj7oW518mMYJPXOfD9EBWygwHwYDVR0j\nBBgwFoAUK6H7K66Wl0RhNkzOyU7zKgrLp7AwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQD6fxRYlkZXk3WaZOhxOP8Eu6lUBx1HXkmdCAix\ndNam+QIhANQ2AujlQhWy8LqmWz9oCJasXM58N61csg6nD6kUBRDp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd8q3MZ3aUst+IgWmET9no8rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzQzMmRmMi03OGIxLTQ1Y2ItOGFmNy0wNzNkYTkyZTliNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAiiDggN2cKvVWDSMUgVrjVcoqmjCZDHZhSleKpTldwtSA\nmyPEjocGF4FnINBwBEbPwiu0gp6iIVORRsImjTldo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK6H7K66Wl0RhNkzOyU7zKgrL\np7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF2q/2k9BHw4WHPUQI2GqUI+FLyXp9A3/oZkkWBTMv98CIQDqa48G6pW6\nxw8sy3eTNQv5j13kShrAMlEA/R5hWCwMZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAbhPy+0b2YdYKQCN6kayUOMSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM0ZTEyZDktMDM0Yi00MzBlLTljOTctYThlOTBlODdiOTk2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRjZDczZTRi\nLThhOGYtNDdlNS1iYzNjLTUyYmI3OWNiZGE3NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCNvEoZ+P68MwQzwJRCCQqn7GOKZFbR6qmU6HrO1ss6ZPrMxe0oph+mB\nOIyrGGYSK6COH5wp5ib4D52bn84woN+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKmMNpY+\n6FudfJjGCT1znw/RAVsoMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgMpFGtKdh4qiwm59r0rcyIpyQ74o7eDxPe+n4JEESw9MCIF1wYzE4AvWD1rAd\nx1SkYXiSH4Sg9cZ0Zj/m8r/tBMz0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc966", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `966` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgigAwIBAgISAXicikLhLKff0/P7+p8PPUVEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyMjlhNDMyLTQ0Y2QtNDc1Mi04ZTQ3LWZiMjE2NzExZTE0NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RmMzA1NzQtZTdm\nZC00OThkLWJlZjEtNDJhNTUzMzE5MzQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW5tiIQB9St8kmHuGoSgj5Sypvk5o9h5diBD2QHXMTrvnUmgtLLHsVCvn2zuA\nUGMz+A+M5vlT3iazqAXXEUeLqKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0z7W9E8Z8LFW2OTefZMfmpvJb4QwHwYDVR0j\nBBgwFoAUhBv2fpI0izGeGrGIKORuze+43vYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0YAMEMCIHI7LQ9CesQnW4tyCVnNR1s1wgOti2BFbsdu/qw9\n21LIAh8F5G1hM0dZb2wR44a/phQRYNgtBM/WQVRSzufvwaTq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaWtcvoKoHx0wfi46e1D21kzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjI5YTQzMi00NGNkLTQ3NTItOGU0Ny1mYjIxNjcxMWUxNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkyGF1jh+K1JX8MyZmGCZTDUs63P0Ro86Eg5tokdrJ7Php\nmDnUSQF6JfNDsQ5NbvZzzjB91DWpQGCCvVuUXk1wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhBv2fpI0izGeGrGIKORuze+4\n3vYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOmG10SCw5Q8yAeyEBwcNfg1i7DICG8snIhgVVvEXtcbAiAApFSx5bEj\nBPToao8taUU6TRMCWsASCiaIUiB0HjWScg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAaL13q9lswR+88frumM3oEkGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RmMzA1NzQtZTdmZC00OThkLWJlZjEtNDJhNTUzMzE5MzQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdlYzNjNGE4\nLTljZjItNGQ1ZC1hYjZlLWM3MzFiNWNhODk1NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFKmsjsiR9xAJYKCZ7zCluT/dS5WtRs0oIjVjjbBI9xk2jhz3/h9I6Hj\niBmoS7jguNftaLteKEckpbIlbLeJhNWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNM+1vRP\nGfCxVtjk3n2TH5qbyW+EMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgacKOJaPin6Ve//xaawVZLxWhF07ALL0QhnZ23fMCcZgCIFAhqetbC7Yvatrd\n48+79MWHN/uwjBZm2NmtMLH3bCeA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc967", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `967` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAZFpkA7oAIPQC5nEwUHT2EWsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4NDY3OGRjLTZhYjYtNDI4ZS1hZTIzLTUwZDdhZmZhOTU4MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRmNTdlOTItOTJi\nZC00YTE5LWEwOWEtYzJlMDJlZDBiZGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvlqpra6LX+OOgI7Yn+LJ8E5RYh1sNTIkNNgkk0wzgwcALpAfNj+W5AuyiC1X\nwZRdCEc4YLOBT9qiquZ2P2NoSKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhnJnmqP9Do2gaV0jcOnO8WqySyYwHwYDVR0j\nBBgwFoAUR3gELrenxmqPSI7Pumc3pckTg7MwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIHUFWBpW6mUBPnK+gIv1bn5NI0jCiHcUwp01QAcRgqjLAiAt\nZ81nbnrvpk3b/990A8Vmiz1eqJ9vvYKNW9ngNW1zFA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQFN1uEads9Lit41Kq+7qOLjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODQ2NzhkYy02YWI2LTQyOGUtYWUyMy01MGQ3YWZmYTk1ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmDJCJnzBrzPduuBIazjpBaReN9zvrkZ+qBECkUcsLnOSM\nop8Ih8bhHLYelDMoOyQkjoLqnHiwumGWnjCzpuDEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR3gELrenxmqPSI7Pumc3pckT\ng7MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGXbZMcjoMHpq2nza7tiqjQnxpSEMYEN8R8fPUtIdRkMCIQCdUsbiAogm\nAPqACTcL58uAyBruyeIUB2RMFMJb7TXDLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAUPZFeIqQSXvv4m6ikyQxlb/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRmNTdlOTItOTJiZC00YTE5LWEwOWEtYzJlMDJlZDBiZGI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZhYTljNDZj\nLTkwNzQtNDlkMS04NGU1LTY3YzkyOGE5NzNkOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKmJ0hsv7eVIoEbOVL8QKl8yBmWaNeVUgb/qsg6Y8xrgEvFK5vUj9Zap\n+ziGEap5IAuWBKWfk0TB+CSl7ubVN5OjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIZyZ5qj\n/Q6NoGldI3DpzvFqsksmMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgaL2CT3ZBsSz5hqczKx5smk/mjK6kUl1t2gsuLnXyDq0CIAPJcKsBnEkAH9hF\nbuJiAhxsBx2OhUb2ZFdOBQPnwDrG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc968", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `968` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAWmLBQHmEir9s0a1toJ4fe5BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkYzBiOTcxLWJiODEtNDViMC1iOGIyLWQ0OGRkYmMwYWUxOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNlNjg4ZWEtYzU5\nOS00MmQ0LWJiMjgtZTI1Yjc5YjYzYmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf44SJQz/VsxSpAbY28fm7DK6aWenNCYWQ5l8LDfQHsrlsfFEftVceGzMki+H\ngaP2e9IU3qZs8wst1mRwv/ElDaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL/jZG+0L+d64D9px9bRDVlC4q0MwHwYDVR0j\nBBgwFoAUrnWkeGyr3jJ0+n/bFy0qXzGOs3kwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIAV0IbutdsfUMn3D3nX09+82+EBlGbPF\nWrrkwFkVqhkGAiAz6gLRAyHqHvn/lxZ7wL/6WXw+ZyvQzqlIa20KYaWRcQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbanyI8ZF5pzmQV1eUg/CelmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZGMwYjk3MS1iYjgxLTQ1YjAtYjhiMi1kNDhkZGJjMGFlMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ29I6lr9GeT3Dri97PsNleiOmX7D5k3hnfb8vC84hR47e2\nGBxiQldX/cBrPViRRJBPaIrW5gjeYTWTyqC8deqgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrnWkeGyr3jJ0+n/bFy0qXzGO\ns3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKp7LrLvQn+ZgBbiE0TynYXOikgWp6ppTvyB+f2U+Q5yAiEA9JLsEBkh\nuuONjLgnjmXuwubAXXyXqA/GZo5nO+YA4zQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAfVSzJTOGds2vmJjqbriZdWbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNlNjg4ZWEtYzU5OS00MmQ0LWJiMjgtZTI1Yjc5YjYzYmVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcyMTZjNWE2\nLTg3MDgtNDAyZS05MjBjLWMxNWM4ZmViNmZjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFG2V5QjO/UOgZGKgzicc3dCV/m8wdzLsuPbfzyxPaQP7KiYNq9BoYQD\nj+tAwDV3xdv9B7vfcFmdxPH1EGiiyPGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC/42Rvt\nC/neuA/acfW0Q1ZQuKtDMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAMWteR+49mBLoVEt3qRWmZOy0NnPSbtSW6DtIohjPnqeAiEAzoWgIuNha7i2\nHML84IP0wbvp+GkFtWdPS6I1anG/BVo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc969", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `969` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZGzvGG8xrus0PmWCM0nsoaGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjY2M2ZWE4LWYzYWUtNGJhMy1iMzg1LTk1NzI0MDUyNmJmOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc3NjljMzUtYjUy\nMS00ZjFlLTk4YTUtODE1MzBhMDc5MmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ4WqgvxoXgn+VFHeaMYz3sFnMCfNmdr5PNoX+gvH742ueIlNG6KkD9TEfF50\nCX5t4Afg+VfyvI1pYOf6FEuo9KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXxTookyKmnAEdRoKXzjGdYT/ZKEwHwYDVR0j\nBBgwFoAUkn42vrZ0wJ065PwzLaFly5uPBWcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBU2KWExCgWVt35wSZbEnnxiipWWDgXi\nWnsBwkzON2+VAiEA/dODNXxBINY1vxtEFvgd01WrNjZvFDPa0iiH3WiO1Do=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbITvflV0Cm9avTFfXb7kg2uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2NjNmVhOC1mM2FlLTRiYTMtYjM4NS05NTcyNDA1MjZiZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/DgsWCRvqAvRgpe8jpTKG1KojLhFY/d7UV34VO3yHk9iQ\nSYYxxoHZeeTEb+nJ69TIZ9l278obIc++tR8uqGKHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkn42vrZ0wJ065PwzLaFly5uP\nBWcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFYI74dP+Tzxm0S5d8PJLU0HtTVBYVUxl1VfYdZZ49sACIQC9Ot+IbR4D\nCI8GDrAQbGOUcyyyVxj+AMO39wtq6Kct9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAYbfpzZy/ZwRXZAnRjG5sN5iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc3NjljMzUtYjUyMS00ZjFlLTk4YTUtODE1MzBhMDc5MmI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIwMTMyMmI4\nLTE0ODItNGUxMS1hZDllLWIzYjA2MDZkNjlkYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHRm340rwAbpVXxS2KSiYB0QTcGuM5qIryUWHAqbLW8Zy0385HbcxMzz\nW1StWU7xJBPRxazQEK8U626sCl2NFPajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF8U6KJM\nippwBHUaCl84xnWE/2ShMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgDnDpSSCBv0K1C8RYI5OQvUXsyTnptnzRSCGsH4A7oQ8CIHagxHDL6q2A/ilC\nKVszXVlCyTMPpfzy1SxEeruHj2yL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc970", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `970` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAdOQc2A9ZrmAgQDbyD3BOKnzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NDBjMGI1LWY3ZjgtNGI4OS1hZGNmLTYwNmU0MGE5NmY2NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgwNmVjN2YtNjYz\nZS00ZDBjLTliZWQtYzlmNjQ2MTZlMDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV/DEMoG/B6jmvG5qvdMHOQMaHDKZWgsckB87QRwjVpEeBvbrr2JrkRwxHWNL\nOx8ZbxuFlMmPwn/rH47mbh1G6qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzISTcgmINVm0xM1/ApXulhDrm0QwHwYDVR0j\nBBgwFoAUt3jw5OVRg+iT9Blf/ecYa13YaIEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDs2XLt6rz/\nsE5oeKlTuo6dz7W7vfsd3BZq7Pe8scbzawIhAMBik6hSYVTo1Z1N1+Mo1c3DMr5+\n54TAHLrMp/4mG2m1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQlF3pCSa3VHzPi4600cZbGSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDQwYzBiNS1mN2Y4LTRiODktYWRjZi02MDZlNDBhOTZmNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQauzqPgdLb/rXR+jXEy4wwXsl1lLc34G3Exll1suy5eO54\nHdGji8AulUv4ElF63q2A5t+14iu9V7Vm+SbMJzToo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt3jw5OVRg+iT9Blf/ecYa13Y\naIEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMYOKLmbXuAd0KZWEM4VtdTDFBTCvcD+QUUczhh1NmA7AiEA72rDkagf\nB6IKpHLJr89/Nxw0i4DZv3WU9LhWBP89q4A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISASHOSz4TzCe1nfvehfnKneGtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgwNmVjN2YtNjYzZS00ZDBjLTliZWQtYzlmNjQ2MTZlMDk0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM4NGJiMDQ3\nLTZhN2EtNDI5My1iYzdjLWJkMTQyNGUxNjA5ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCITe8gMYllywbK+K/GAFLXAbKQKH7UImqF0cHHFZDGaY20FjeKx9NgG\nFI6nxLWMveV93DtjYG4bG9hcLEXHSAqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMyEk3IJ\niDVZtMTNfwKV7pYQ65tEMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAIY/4P6YEr1Ib+eZWVvasAk94lvCi2ydEXO3Omqq7BAtAiAF1e872ZRbl3Ky\na4lSwwGJbg91ewH7v02I4U1wkJsINw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc971", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `971` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAdA1oSrtKwrnUVmN7Q7wbqeWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5NDVmYmU1LTFiNzUtNGI3OC1hYmFjLTk4N2EzMzc4NzE4YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUxZjZlZDItNzhk\nNy00ZjliLWEyOWEtYTVmNTc0ZTRjZjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfq3UmDzwDP2OU3ZlYhClr5OOBR9UOYJRu1AcqpkUcAJNg/XvREC+FWfygZd6\nK/ldOAtSU6qZVIrFqNpzsiHdr6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU49SUPTHPwzzx09DKOBtlwKHi5kwHwYDVR0j\nBBgwFoAUOjLa7G3XuagRzuM+SCY+H7bD8JswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgLLKqEcdB4bfQNIKtkEpQ0EWaA+/0gbBj9SVrH2CD/UwCIAQ2Nu7/0GLB\n/RRBW3zrRyq+ashdAoEMk2oFERXIUcAJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXjqR+fetpjzcxrJhtdWisSPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTQ1ZmJlNS0xYjc1LTRiNzgtYWJhYy05ODdhMzM3ODcxOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9nCw/tlcXnnMV8kgP+ig9gD9DTZB4/GTXD3zDdGxqe+Fp\ntC09Ou+0Eb+9db29F3xGeDm6ZzmySQD3+hs+s+1Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOjLa7G3XuagRzuM+SCY+H7bD\n8JswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBwoax7S1TgpO22yvYJlFsOYvHGE+srz2j5GO5LfbVaECIQDZc+CH/24U\n/Z+12y8MbWEdwYJ5OnwgmkhFjg+vox/X0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAT32nNuyhPp6G4t0pPn1k0NYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUxZjZlZDItNzhkNy00ZjliLWEyOWEtYTVmNTc0ZTRjZjMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA0MDQzZDRm\nLWQ0ZDAtNGQxMS1hYjY4LTg0N2VhNzM2NmY5MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKCCufr6BWvtHP1Dy9iGG92mPCT2djvnwAi1uTNHNADnGjU3UOf8o5U9\nHZUl8MFXWS0pUY8NDxdBTBpJE1pRJ8ajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFOPUlD0\nxz8M88dPQyjgbZcCh4uZMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhALamrLKwUSMGui62gafumI+trH0fDDHRksplmSqACqKXAiEA2AwA5Iwf0FE/\n4mS0w73joiyj55FT+6E2p+OINUNFXbg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc972", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `972` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAa6pB/qZsH+C815/TrDZDN2bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwYjA1OTA1LTRkZTAtNDhjOS1iMzRmLWYzOTVmNzIzYTA1MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg5ODBmMmUtYjMz\nOS00ZTcwLWJjYTktYTIzZjYzZDNlYmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkO/H50z8VgRI16/opDXM1WsXZyvkGcI5mYPNpL5WWJnIeJbw4T/TN87jpoRO\nuv7lFaq3fel92+UGCjKEG40hT6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvZ/Y9/e2WO07oxuXVVN4wQ4gtqIwHwYDVR0j\nBBgwFoAUhCsLblvF0UmR8ooNB01YSlq6jjkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgP9mWs9+aDEmX55umXwTpccP29sWgY/w8twPqbdCx17MCIQCpUk3WskY7\nS7+d9ZxFyFXI+SATPyueqRBSf1M4o29yGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWKscFwGvluknJOzonllRn4bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMGIwNTkwNS00ZGUwLTQ4YzktYjM0Zi1mMzk1ZjcyM2EwNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+TxccOU7PApHtLM6lAR67xDCNuMhNzelpK1+tXq6IbHRd\n28U/ozccaljl6RxpdBPG1ejYM75RiTj1OurY8XIho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhCsLblvF0UmR8ooNB01YSlq6\njjkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUQNjQBgqyxOGCB3w7VA8X7liXajmokTnhCMaXk93oyYCIQCHTTGFFIfC\nGglE+2DdzcWuS/wyQXVdG0XGWDnCDZzMDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAUOW58S3rhqVMIi1/Dx6RlBzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg5ODBmMmUtYjMzOS00ZTcwLWJjYTktYTIzZjYzZDNlYmNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI0Y2M5ZWVh\nLTBkZTgtNDYzYS1hNzc1LTg4YTdhNmE1YzFlMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP/ietXVOaO2KNePROWSvFderg2ZJwG/M57PYcbOCtbyusLKURCjh2c7\nx2ooXPMbdzD49T+rsebkazvsvnD190KjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL2f2Pf3\ntljtO6Mbl1VTeMEOILaiMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJB8Q2VpJ1qfgVGKGNJk54SFBGGpYWomSegB2iIh1z9rAiAOLPdHxMegjci6\noLq1eCXO6dsl58TeyJUKa3Ag7G4ZLQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc973", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `973` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAVndqiM71S2QbK5R2qw8taDZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2Mzc2OTE1LWZiMDEtNDJkZC04ZDI4LTQ3ODZkZmRiYmM0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg2NDhkMjktZmIx\nZi00NDdmLTgyMjctYjk2MDE1NjMwNDJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe+jIFLrNuz2yHXbLI6RDM6BcPoUJmp6Znmgik2BvQYLMEeQcEnkNmcpYyei+\nIZ8bdHxEPrXAk9PrOPhp+qNzAqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy6sAikEG8PceoWJxEasSC+ibyUgwHwYDVR0j\nBBgwFoAUDddHBHYamS4FVtNpAfp4i2Eb6vowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCnmNonNg31nIphSWff7eC9j6v2JA+1WgyEWptK7duBwQIgfbLzBJy4\nus09qsxCyDjdqFGQIlqnL8rUo71/iFpcUBY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW1zftWYzfdt/B1iHESYBw65MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjM3NjkxNS1mYjAxLTQyZGQtOGQyOC00Nzg2ZGZkYmJjNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0kH1ETEbLmyi+gFeVSneAfzXuJ9ZeumcIPaNM4/eO62Xx\nemPdYZLy5BAlw45J3zK+wbICW7/wfxLh6HiWHtETo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDddHBHYamS4FVtNpAfp4i2Eb\n6vowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgX3TLvYXEAJo/rdeZSAl2mZusce2I1pxykVCrInA7ctACIDVWbRkpt++D\ncA9nOZFvwk0ZQ2G2ak0F72gK1nom5h+G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAcOo8IdQVjvq+e4TR90QxPlrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg2NDhkMjktZmIxZi00NDdmLTgyMjctYjk2MDE1NjMwNDJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI5ZTZhMTYz\nLWFjMTQtNDM1My1iYjZmLTIyZmUxMGYxZTljYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAMb6LelDKoFhoIKEn4H78dhdxpKlvRudsKjyHPWGMa6SUFbFduFO2ip\n0ndf53bNi2q9m51I7glglzWIZmtwPOqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMurAIpB\nBvD3HqFicRGrEgvom8lIMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgGmiIJyCKYXc2g+DQOq0SzmgRFUuGr2ElxIMpykoedVICIB8KlOezupH/eR29\n87N7Lkws+4WcV0YKCAZvVNatWlJ2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc974", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `974` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAcx6qv8jGQ5X9v50x4Z9KVnhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4MGI0YTAyLTJjNWQtNGQxZi05OWU1LTJkYmE1YjVmZDBiODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJmYmI4YjYtOWMx\nNy00NGFiLWJhNmMtNzZkMTBlYmVhYWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvY5163B1TIQBkyt4C4ecv92fD1JsrL3CIukXE9E4S3EH+Tjvle21CMnBcHLT\nbFyfyB3eS16gDCK3j6Ieo1SPZKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe8/LxnNxXlpH8/iN3uSxl21e6eUwHwYDVR0j\nBBgwFoAUvy/yCuHL97xzeEQCFbjxxSZlCRcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICqZtlSQWh0ui1sMU/84JXeRZ88iwW4OmQjTUhvU\nF84wAiA+UAibFHGTVDOgUDtGFgWNTSUhrzbpOvQVNGcgkeUY5g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATkYCMW+OjfG8cze9WLrLDq9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODBiNGEwMi0yYzVkLTRkMWYtOTllNS0yZGJhNWI1ZmQwYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6xgbw1nZpNXCOLEwCYjicDxNBGKtAdqsNnIqf92mIGD0A\njCedr0VJWmKGdQpYBvhVUi5fcqYPnEyQ0ijypQf6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvy/yCuHL97xzeEQCFbjxxSZl\nCRcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP5cDRfVl09nLFPqWeTrPj5M6LqYQaPZHf4kHkRTMoqxAiEA9lJNkJEu\nNI6y3f7WYrjzU6eA20z0JM7kuzgLOwrk5xI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISASWt1vAMfIdfWj2KpIf/iSfqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJmYmI4YjYtOWMxNy00NGFiLWJhNmMtNzZkMTBlYmVhYWEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg0YjdiNDQz\nLWQ2YjctNDRhNy1iNDNmLTI5MzdmNzg1MjQ3MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKWsPGg3u0R6EMOcM3AfAOGtgiKdNf7t5eqZxUqfVfzvKU9lcEQHuPa7\n42eEnJGdLz2lakzNuq7/9PP/idLCSX+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHvPy8Zz\ncV5aR/P4jd7ksZdtXunlMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhANvjA/3tYRWzmLBZv5uSQrUPQNuCDD9SuaOOrW+a6Uf4AiEAryN89QvEjji9\nm8VYTpW7xf69pM/vAKSyuRuIHMvi1z4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc975", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `975` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAQaQ4TfAjHG9nwjPML1bu8cyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5MDVmNGIzLTM1ZGUtNDllYS05ZDNhLTVkYzhhZWMyYTNmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNlNmNmOTItMjEz\nNi00MmNhLWE2MGMtZDQxN2I4MWNjOGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6n17ScgGbSvECJx5XVPsuJ9qxNFHAfi6LzNjUf5/OBmtKdvD513wIBW26KYg\n4US7pkZNqTMuyqQlZxn80fYSRKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9sybazM1JwON3crFdd8asiyQqwMwHwYDVR0j\nBBgwFoAUA+EDrCZGeGTfKtdbN+De/Txcq4cwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCJ0Nf7xnDtZ6+SbLvtxwzgKtt2TKfHxo+gZ9bW\nEx4rmgIhAIKcYvnNdXnFf5/ENawIdZ2DQ76F2ov4WzdGwbFVsYTn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUxvsr2Kmt5ydX6yOY/KdinlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTA1ZjRiMy0zNWRlLTQ5ZWEtOWQzYS01ZGM4YWVjMmEzZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNV7f4cm+zYsjWm4ECZCKn1nhDyTOCXBL2BGbPDad+h9gP\n/yWcWjLfWiIdJri4B5NCsWaaON+y/LNsimijcjrDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA+EDrCZGeGTfKtdbN+De/Txc\nq4cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIpqAw5GtUTublKjK/sS55wc10H1D+HlQGkvQHMDIlqWAiEAmkaYDWtv\nfVCNFgMHIQp6kJNiYyDJe7GRVIYuCSw+8EI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARoQ6ybYj9e0KLbAw4H5oHb6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNlNmNmOTItMjEzNi00MmNhLWE2MGMtZDQxN2I4MWNjOGZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUwNzc5MTk3\nLTVlYmYtNDJkMi05Mjg0LTg2ZDg4ZDdjZTJkMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHbhSitc6/4Y55nlrNRwC3w8DvcwH+CRXp2aL4igylz7VO6kHUR4ueG4\nlJGU8bolnSVY/tOWcke8Og5Fp/PlWIGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPbMm2sz\nNScDjd3KxXXfGrIskKsDMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgalxY5b+smsiv8L9If4jfndo9cBJFSphKio5fPL3MkDcCIQDfG/2AuEXl+ArD\n7spA1/hX1uGzrWT+uFNCHIXrlBpBNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc976", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `976` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAfKrdBRfFlVNFlTkKqmcoul8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0NmY5NWNlLWUyNWMtNGZlYy1iM2M3LTM0MGJiZWY4MDczOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ1Nzk4ZWMtOWNh\nZC00NzNkLTkzMDQtMjAzOWM4MmMzMTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5NYusNMkO5lBg1HXT11vUZdvh6BEyzFjMDgUn8KYcYn/5qIct1kVlBlW3MX3\nW3JtW2FJAMz09c6slYJC4gHWYqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhDUPK+rI4mHzqraC2OqHvHgLkeYwHwYDVR0j\nBBgwFoAU1LIFJIx2nlf30oST/mDCS1jhZ1cwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIEM6gx/sN3AUIOcScZXy2ikYzP7gPu2O7+wVeF8LlVqlAiBu\n5vg4XeCrBk4IoZLqpilCNyMjzO1r4lYC6bmRff2rkw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARMNZ6nhKZ8HpjbM4QeZzsxqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDZmOTVjZS1lMjVjLTRmZWMtYjNjNy0zNDBiYmVmODA3MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtXH0zM2CieIcjbDX+lQM6Zx34iaEESMllwOQuHKjZjVKL\nblQQjrQn9vBFCicvvjRSCOddWKJjVfQ5rAqLdZ3Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1LIFJIx2nlf30oST/mDCS1jh\nZ1cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRWNXIdKE2oMMZbQdim0cmuO1a5Cth4mUONqmek/iPZUCIQComnLwQPH5\nBsGE9h+m0vntULZSwDOU8xw041j4o96igw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAfgbUK6BI8OId7u/s1N2vVCOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ1Nzk4ZWMtOWNhZC00NzNkLTkzMDQtMjAzOWM4MmMzMTQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY1ZGMxZDc0\nLTdjMjEtNDkyMy1iYzE1LWNiNWUyZmIxM2NmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP5vIFlkhyA534PLOUTGf+imhMretkFuM0fH/mfl2Z0alWTHWsRk4M3b\ns8Z8+CrhabHEP0Oy1I3iyHruwwSXyvujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIQ1Dyvq\nyOJh86q2gtjqh7x4C5HmMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgVBZWzqj3QcOW11OTRKT0qvRO2UZLxZp+w+Dly+Cyum4CIHiTaKv7AcDaH9E7\nkdGY4rIzi7nBFsDWB+sgjVQks9xk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc977", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `977` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAUV5mLPLBwbkqBN1Hq9KdXptMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0ZjgwZmQ2LTA0ZmYtNDg5ZC04YzVlLTI0MGNjMjEzYjMzZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZiZjg0ZWMtNjYz\nOS00ZWU5LWJjNzAtMTljNGIwNGUyNzc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqfyRO6rc8RBjKFntr/TnZnGkz6fejdvLmRG/XJstfmiXViXhPsmqbIHvJenN\nB+i3U2yeTVhE5wnMGQ18UsSmfKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv2k+HfeMvOROKLpqG/HfLWBSmN4wHwYDVR0j\nBBgwFoAUV2XI9P5yzLrCO/XguFTCUMt9DJEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIFEM3UwMx5qZUB1vudq8g95Bwl5XPkU6\nZWu7Vho6TY8RAiAhJHbI8c6VxC0UDPRPOREoZh2RBngcFLa+C96tTkeEfg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXLsqX2d8TREYD+CkxlfCKJkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGY4MGZkNi0wNGZmLTQ4OWQtOGM1ZS0yNDBjYzIxM2IzM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARI7BkatTyfTBaKBqo4wMgGaRVrJzPhomiSg8jxbqB0uHBU\nimKyr7JxiIdHAmNjc29dOu2OPKRGxSAgwcuFhRAdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV2XI9P5yzLrCO/XguFTCUMt9\nDJEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPocOby8Denja8ecyTNhvEEeYsR6D5//5NMklKhrQBMwCIQCNvqMY6wH+\nHFmjMIqlTCoY06agbybMwRDTur1BAdrPlw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAfkV7D7CI3HRgVihyBo461CMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZiZjg0ZWMtNjYzOS00ZWU5LWJjNzAtMTljNGIwNGUyNzc1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ4OWEwZmJj\nLTg2M2MtNGI3NS1hYmE4LWVjOThkZjczODRiNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEX7Xk6Kfcqp1e9vyoNGV7mEhvkTSqnSLLYtwGdl2oiP/oNXCZlSNgYP\nnyq7XdmLI9rv/8gPt0i4sNDZxPpRsCGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL9pPh33\njLzkTii6ahvx3y1gUpjeMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgeyUugRPaBj3e3j/scyht/phWogIr929GXBr/a0DreIgCIQCI4DFfjwlmLgOg\nw2zHSm2FIqL58LH/KsdK+lYyO8rCIw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc978", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `978` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQe9wchFOwBRZweclkUVBA9sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1YjM0NmYyLTdhYTMtNGU5MS1hMTdmLWYwMWI3ZTQxMTgyZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQzM2QyMzYtZTdk\nMy00Y2Q3LWI4YzctZjZhODU1Y2RjNmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPNIbJUVziK0xqMs4oPthY/pihGe+Eq34j//zHZ+wY82R0MlnwfcSK4aMhcnU\nOrS4XA324ZDchLt4KsL+ZJNgfqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4sKvi5m4cK9eHDGBC5GDXkCjil0wHwYDVR0j\nBBgwFoAU886Ed+nzQVARoWlTTPd22FwBduwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQChC8nalH5/LbpGwK2ik/1fIS+3C3tw\nQXuPq8MC70sVZAIgCPcqsM7TrJblfY0cLsDi80Qu0NJIqVkC0zKFD6Ue0E4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAchTqXribgVN/NPkpKTXDuCOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWIzNDZmMi03YWEzLTRlOTEtYTE3Zi1mMDFiN2U0MTE4MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7Xia7pN6etEvHOovLAWFGhx1Whk1RjTrzXYCaTndyZK7N\nU9wOwI6tQrXECeEPTs0clZ5SkvlJgYqHRkmcJs8so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU886Ed+nzQVARoWlTTPd22FwB\nduwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPiR/MjGzka4QZKN1xzDeg47nODq8FExkuZvKYBDdSG4CICv8vXfBDSuC\nl/ZZ08QfJyMulJeLAJty68qVMiNjV0sO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAS05Oq8/wTVWa+s4PpXh4EbVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQzM2QyMzYtZTdkMy00Y2Q3LWI4YzctZjZhODU1Y2RjNmIwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU4NzZiM2Nj\nLTVkMTctNDliMi05ZjAwLTE2NjA0MDIwNGExNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLMJpm9Y0pSxH07WvFGZCqIg3CByMUe3SqPRXGvY6YoUWfHGFi/XIsG4\nFQQBpFNel0NUZTIf88BueanKHRYSSwijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOLCr4uZ\nuHCvXhwxgQuRg15Ao4pdMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgH4+Fkc7bkq89XtyT6JtvJpBsVH9IpzAuKYwtIIK6JIACIAyE1/XcMz9T0WRG\n+TFPOYCyNnroJNY1Aaae8sbN/p78\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc979", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `979` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISATs1jnehHH42w9ITvB93zL9gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyNTc1YzM4LTg1MDgtNDBkMC1hMTVhLTlkYTVkOTA4ZTkyYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDMwNzc1NTYtOWE4\nMC00YzFiLTk4MDAtMmU5MWFkZDhmNTI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDBiRwrE+25/4G/+T7dH9H/TckzMv0YOBVcrN4Uqh1bl7h+jZymZZaeN80bZR\nWsnxDKuoYkRlndqseGEKcNvwWqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGtAPkIIcQT9tEv7+Iouunbl4TKZMB8GA1UdIwQY\nMBaAFDPU0ve7sqcScCwm0h3zck6Tw+qpMAoGCCqGSM49BAMCA0kAMEYCIQCVFthu\nIRq303hvjfEja9Wb034uocWi2AkqkLbLA6mxRgIhAIbekIGepiRegt+LLx1xXQR+\nWQXZoDxyO7JXUkQfZ4LS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbJLFsuzvJPdl4JzON/Fhe2DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjU3NWMzOC04NTA4LTQwZDAtYTE1YS05ZGE1ZDkwOGU5MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQve8d1RqC9D9eN11644SNiJMMjZ62L8HKgXB1sblLlXqOu\nX2eA2Xn7/QlVgVGqHt+JZWCY7lDa2NJ5p3LsBdu7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM9TS97uypxJwLCbSHfNyTpPD\n6qkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE0WE8wkm6hSqvwnkb872ly9M9ugIVL4bfWog6STeuTACIEsZWuRyNsAH\nA5mIo3XE5f5xJ0tYCAljnN26Y83cqbS3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAe0MmKQnumIwbBogykUYRwV1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDMwNzc1NTYtOWE4MC00YzFiLTk4MDAtMmU5MWFkZDhmNTI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYzMTk0MDg5\nLWQ1ZTYtNGYxNy1iMzZhLWEyM2JjMWRjOGRlNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBjzCOrOpWFrd17QSqFL/uRWEwnIEECZwnSinzDDK0xHWXJNHtb9cDyT\nMZuPMVwEY5mZTl+Oa+kDpyTF5nVKDDKjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGtAPkII\ncQT9tEv7+Iouunbl4TKZMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCICPsRPmvstpNpBg49N1TC6MHQbKG7TV+JkViCmF/24QXAiBS\naelUEOrOVmCUolps+2+8vRZnswtnODUc9HJVH967eA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc980", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `980` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISARdjdaSKDy9tfWY4jPbAX+sqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmYjUxYmNmLThhNzItNDE2YS1hYWJjLWI0OGJjZjcxM2I4YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNjNDI5YzYtYTkw\nYy00MTk3LTg5NzktMTg0MWQwYjc3YjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESzpMw/uUm2kntxDrpAawohn6c7VMX0vCWkaOuGBycGYbXx61j3C5ekbm2Q8/\nzllQPTx+dCaKSvoW2iS3Q/9V/KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAydLDa4HzwAukP2wArkQK+e/jwkMB8GA1UdIwQY\nMBaAFAIobPOCkOgdAT55Damf32jUJlUtMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB9vYHVMvll9YReW61Ne7Wkn1jLC0bWHCLy\nbVM9/dr5PgIgfBhr+apZHTuxayFzFyHpeG7nw/28V55dntc4n0nQqMM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUk+uOkjo3zIWNOTjh3UsGKYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmI1MWJjZi04YTcyLTQxNmEtYWFiYy1iNDhiY2Y3MTNiOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjlLE7YGd9iql70VSjFWwnAZd/0YIPv21+QLOr99ZcCXZu\nUD5Abk58ymDDVg/P5iPlOoKmSbeo0A4IdpXQF7oMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAihs84KQ6B0BPnkNqZ/faNQm\nVS0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK9sXiaUU45FNhM+2UFCftNA5vIwvCI6SU7g4lmw0FmNAiA+x9ewpKZz\nS/hqoKbApS7XXbduJ3CFHcK/TK2yG9/NpA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZnjEMyWR1RvWhE2doog7q1zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNjNDI5YzYtYTkwYy00MTk3LTg5NzktMTg0MWQwYjc3YjQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU4NGIzYzNk\nLWNmZjgtNDgzMC05N2UwLTIzNjFhY2U3NjBjNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHcqDEDdlYW78+lSdeULNUiiaHlRCmcE9w3aZD70VzXRbab45SCI/o6E\nAwdiqxlA6z6J4+ZPMBq/dIs2zgHdS5GjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAydLDa4\nHzwAukP2wArkQK+e/jwkMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQC7vpoFnAKObdATr3frMBbbgW/jIwqt/RoA4vk3C99x5AIg\nZAq66fwqReMI6ghQfJVuNPZht6phzOlxNPtjeewUfho=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc981", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `981` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZVf3POfyR90XSmXSUErSwN5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljYTc3YTQzLTRmM2YtNDk5My05YjFhLTJkMjdmMjVmMWFhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk2NmZkNjEtYjMy\nZC00OWVmLWFiMzctMTI3NWI1MWFjOWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzq+qJPpj7dbWquSI6EzeVkU3ibyt3WbK2EHq1UNBszvcRXrvje5nHM2Seb6V\nuzun8csfdqZwkSiTOzb9UJy0iqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBDXpjtmSkMgYWIJw2H7KhGY+ojNMB8GA1UdIwQY\nMBaAFFeF1qViXKQjh7qLHmTPXVP6GfC4MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBjN2OGoSkEJieuZEbCsCh021979d0VgQWv\n9TQExutQ0gIhALPP+FVRpWIgIw5Zn4qzfBbxXn+RGQaNz5BMxblAuGao\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXk3NuG4MzvpCM+U2VY0d1RiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nY2E3N2E0My00ZjNmLTQ5OTMtOWIxYS0yZDI3ZjI1ZjFhYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/3g0WVOjZCLfFKKQKd2tGydGilBRVsMRUfabJZ+HKwUYy\nrQIwnmhN6gaoNk6szVvAXF9af9EFwV9prCFLJPM+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV4XWpWJcpCOHuoseZM9dU/oZ\n8LgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOgx7QUQq0hdPhcYNA+d2TiQp0NIEExwomh3bBxK8ak8CIQDI1jCzoTJr\njz7+HLftbvveOzXqmosQU1zLM6oZYFFLmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISATIcptfokEbViAa4v9LBeXvsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk2NmZkNjEtYjMyZC00OWVmLWFiMzctMTI3NWI1MWFjOWNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE2YjcwYTM4\nLTE4YjQtNDE4MC1hNTU0LTZkNjQxNzNhZTk0NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEP6zHuSeqahNrRwz3pKkFnGas1BmhD6pAJYJMzbTAOuqF8aLF50OBLp\nkdcYtW+YI5THEE1hCPRxliPuk8mf3TSjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBDXpjtm\nSkMgYWIJw2H7KhGY+ojNMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIC1z27iMvHYdgGH7UhMwJ4mNGSwTBKtnIhFMhNJ6PXkyAiAZ\nitTxRzm1m7kMWJfGP7zuPmrL36z9QV0meIvRCjowLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc982", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `982` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbpuH6t/huSCuh342ZXM/o1GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ZmY2OWMwLTdiYzQtNDVlMi04YTViLTFkN2IyMDYzNzEyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVlYTMwYWItNWNj\nNi00ZDM0LWFmNmItNDBlMDkyNzY2NDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESQS0pXYM9rLPWXNiAzyMi4ziRuVhbUjIgB0vYJ6930/Q6m8J3JrbskqASeO4\nfl8YGB/r/b1NCWDuq+ezXKCAe6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSlWz3bUJOz7V5y/q6OHl0+i8mg/DAfBgNVHSME\nGDAWgBSTCF9lJn5BR5QSBdAbVrKwCwzSlzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCHPu9m8mcMFYeIyx4ZC/Z1HXCXYuzk\nxeMKsKFgIu/TlQIhAL1hGSTQ2rblQkC3asOuDwW8tNwlUKss5mdKuR4lrW+G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbjFip6/CftO5OKjh66azBzdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2ZmNjljMC03YmM0LTQ1ZTItOGE1Yi0xZDdiMjA2MzcxMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKMZzAbAgyE/HJUclAsd7mfZc+YDR+CKDMXJ6AVHEPRT4W\nXD9cOIa7yjrkVwrS4GKSaU6L9bDBGBt4rdo+eoE/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkwhfZSZ+QUeUEgXQG1aysAsM\n0pcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL1Y+r5MFH2Jc/+F8503c7HjtFXW4OLPjFO20CRQ3Bi8AiEAvpY9eCkO\nff77p6NIbjq+vNcyvzrik2ZUb4bx/hwA6bY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWe/9+vSZI6Rq254jSoanL7nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVlYTMwYWItNWNjNi00ZDM0LWFmNmItNDBlMDkyNzY2NDY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI0YzQxMjNi\nLTU3MzctNGZlMS1iN2RlLTY4NDFkMTBmZDU5MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKLyMr0l5wmnpMsme69rJ/IBVwMPsv3fUCW3j1BxPAdQi+IeU38K32Ux\n/2UfbmQnUH1Q+b4kYxaOYp4vE+L1HtejcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKVbPdtQ\nk7PtXnL+ro4eXT6LyaD8MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDRS/z4fmHj1Ae/LWQ6SK2s/9kZe2kIgJ8Tfix0ZoAo8gIg\nO2Y6iuT4XC/fcHwAdKakY5iq9eHcjqLFqe0fyBZYZEA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc983", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `983` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAYFqnFWmZHsZdn0UjS0rbPlOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMTk1YTMwLWQxMDItNDIxNS04OTNmLTZlNDU4YThjZjdjODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBjODNjMGEtN2Zi\nZS00ODljLTkzNDYtODVlMzYzOGMwN2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESnlX9lu+xR2BC53wB1UEH1MKoCNgDQUFYsclPnz7lHtyK1lPsaMEXM8TbN/M\nILc3qKziC/jkKtnmnrslqr4YUKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu0z4/DQr7kYDVEMu2YrjIa3YMp0wHwYDVR0j\nBBgwFoAUmPNQLE75W79xH73gXK5TnYbPSAowJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA+DYIf9zxOxb2\nK2AqvuA1QHdqJNwg1kqlWvuzi6YpUGICIF8bLFcaLmfYntKUIh+jgrLx64BqD+lQ\nxT6BPxFA6V8T\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYM8Bn+UyofuoaN1RAntl6HAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjE5NWEzMC1kMTAyLTQyMTUtODkzZi02ZTQ1OGE4Y2Y3YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASC+H6jJETR78uT/3kBoDBJYz/1PEqaxKiq0xT/KWr69Wdp\nr+5ah3c5vkNX56ooeHIsOpMYM4L5nyDvxXTG8VWpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmPNQLE75W79xH73gXK5TnYbP\nSAowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM9pU5acriMcnkUrgW7Y6v15jcYMURmJ0dGWjqELxRIUAiAMOjKEi5Ep\nbH9/eku6AP+btgO6n0bIG4EAep1PT5DOhg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAcuZooZFaRrwXDjW9WQAnH3NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBjODNjMGEtN2ZiZS00ODljLTkzNDYtODVlMzYzOGMwN2VmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkMDJmZGZl\nLTczNTYtNDg2OS1iZDdkLTNkNDA0Yjc4MzJjMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNDTIncc8/DtCylRZJprBySxxtwBzFMMta254a/gYoG7EK4dfd2MatpV\npxW9cJ5Dsl/8VBbFPJJOPoTpyoCKx0yjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLtM+Pw0\nK+5GA1RDLtmK4yGt2DKdMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIDIndcLNu+8DAZeCfD4y4l2gWdJXQ5CDVJ7LShwLMDDDAiBZ\n61mnxkbIffzBd5vmqsHe+Ad8r7mQyP045Vbq/dlZRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc984", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `984` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAWJjNAgwpDlRo2BHeMeOEOqVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5Njc5MjE4LTYzN2MtNDNkOS05OTI1LTg0ODkxMjU0ZWMzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I0ZmU3MDUtMjY1\nZi00MjY5LTk5YTctNTQ4Njk1NzZiYTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+VstEiKOE04SYz+ES45NmUtwmyaDQJdzfHrBM+2kuw5BVRyZFSnDnff3rili\nG9wAwAdt0FWbMa7JdzVQvCtMiaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdV4Y0BqazNRxgufpp/ity6tJDIowHwYDVR0j\nBBgwFoAUZ6B5002YqUMbKal68Er+NLLjHL8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAglC5Onoe2VAf\nCSoocqw7bw+OYjAy7T4Ieq9a8B98Ur0CIQD0vuvMqDmo2dZ4Bbrg3B1iw6alPQFM\nSdI7YUb9xVZ0Cg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATTBTn/tD/PPw+AZVqGh9BL4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTY3OTIxOC02MzdjLTQzZDktOTkyNS04NDg5MTI1NGVjM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0FM5fQNAzFTNXMUYOagLlkLomSEPBDEIlT3YlEUACKmg8\nvpU5OWHedO0KTkGGGJQuTiVHXBctGDSt314loyG5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ6B5002YqUMbKal68Er+NLLj\nHL8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOo1E1yQbOuCw1+AkaOub3aZaVvFlqECYwkZDes/3NQMAiB3H7y2wzve\nTQcDL6PEtP9zHltFW+vzBQvMddqh6uLukg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfRKkf4auIcjQOF7oqIqESIkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I0ZmU3MDUtMjY1Zi00MjY5LTk5YTctNTQ4Njk1NzZiYTkxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIyZjUwN2Qw\nLTUzZmMtNDllOC04MWU5LTNhOWFjZTI2YzYxMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGXO0w5LOysIcAv8MXe3O40tTRDOxEGnWUIXbEc2/YRYrlTOVHNHJNPa\nznzHKEtetBJkwWqz5c0hcSH0Sx69nUqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHVeGNAa\nmszUcYLn6af4rcurSQyKMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDoScT6kuf0+Xn1A8ac4+RV25mHweNpopzSrwYOB8lmPQIg\nDksQaMAJknKzgoLGKg4hOXknJM9y8AtuR+FOMo32Mpw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc985", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `985` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAf5OWH+OBl4iPXY+sNRRKWn0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MWUyZGM0LTljNzItNDlmOS1iZWQ0LTU1NTg0YmI4NzhjODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY2NjQ0NDktZTQ2\nOS00NDlkLWFmNmEtNzRiNDVhY2RhOTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfs2rTOFeqy8HGCkMzvJoqiUJn8mdwqNJf6xhQ/aRCaOlfqQkr1rGnfsYkHyK\nMOut2l2xDFNJRLlp5GrA8sfHkaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5gjIhrALbL6vJBqnZyHYkH0A7fkwHwYDVR0j\nBBgwFoAUH7IuzrWgJt+r+yfxZG/3a2CUceUwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAzmnZ95r5TfV++P0ilqGSH\nx0NQf6g+4aY2zxKkt9TwzgIhAPHM/sNeiJwPmCf1y/4oydBbOm410wZnuL8CCSIK\nGB3q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVjh6lPVbsMGizkmgpEDpcPmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzFlMmRjNC05YzcyLTQ5ZjktYmVkNC01NTU4NGJiODc4YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDzIGVBJZwLjeUjKPbaTlKEd/bZdO3iHvwTSjzi8fj0zHe\necSboUzq/60r0FtYwnU1AChJ5eYMw8zqZBZzpZAOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH7IuzrWgJt+r+yfxZG/3a2CU\nceUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgabwh/9rHHS7SHP+esA1R6LkRoklnugLNH/dicyv2V0ICICXSmXkmJcaO\nO2wm/0IuJfmDi+4XLf8hav30SvjGT6qR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAcK19D1iIt2QCho9fdKGRVXKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY2NjQ0NDktZTQ2OS00NDlkLWFmNmEtNzRiNDVhY2RhOTI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ5YzZkMzJm\nLTZlMzYtNDQxNy1hMjc4LTM3YTBkYmEwNWM3MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPlPNbaPiX3LGGmHh6Uz+V2Z+G3f65OLuEA3/muRzbfm8qWM+640QHLi\nKp/GYkkTuwCkg1fCMm5TkUQvfhEL6IyjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOYIyIaw\nC2y+ryQap2ch2JB9AO35MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQD5zVFBFiofAr2QcG38IJJvCi+o+1RR+kvckjHLUjtFgAIh\nAJeDXQmza1MIY46tbppwembSXIUd9pKL1jEYki7n4J2R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc986", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `986` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAU6cZZFYEbe4/o4DZsnVmhJ3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YjE1OGNhLWY1MjctNDkxOC04NmRhLTZkOWU0NjI4NzVlZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzdkZDg0MjgtMTY5\nMi00YmEzLTlmZWUtODEyZDZmNGVlYTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMPhr166uKvVzS6gxH0ss86S324wPoVV5pADEnr+svuMvnNFYj4WW4pqOUeb1\nKl4h0aC4VP9hvyFjdYAlWd1WoqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJOccF5hWR41j97MZEB76NM75FlUwHwYDVR0j\nBBgwFoAUk//odKF8Xzw7ptJGtzRkOAOqbCEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAl5RQx\nY1hleDbo5IKWVujddJpKzklnRQen5/JP8gx5MAIhAM9V64FYW4q4d2hA/6QoSHyc\n7Gw3CGNfmsT08RxvlPLu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdzdk9Sx6kuqMozWD+tGuvyxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGIxNThjYS1mNTI3LTQ5MTgtODZkYS02ZDllNDYyODc1ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0IDqCwHQUrm1X/xq2KSekyM/l4cJ/JeSDvplhQsFiU1Y/\nh9Zb1sQndp3hDFVbgEQQWWhBE+LJ5owp2DhAfk3co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk//odKF8Xzw7ptJGtzRkOAOq\nbCEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANjByIyL5pLyyhYFpzEPG/W5ZnUgh+Q/lcKw4cKI3GmTAiAhiQNvasw9\niX8s4j5nNn6swD/u+kiSWm+I4vHPAPvH7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbGReKxp1vMvK0FGPyurvVWDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzdkZDg0MjgtMTY5Mi00YmEzLTlmZWUtODEyZDZmNGVlYTgwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4NmRiY2U0\nLTk3OGMtNDk5Zi04YTYyLTc4NzA2NDk2M2I3MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEUTqgr/N5ZLMdPyL+ua1Ya5fIQi0CuA7AFd8WhibV1exIfMSSbThGDL\nHyCrdPGHRY3uxIOihRiuLCYBr390cR2jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCTnHBeY\nVkeNY/ezGRAe+jTO+RZVMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQD6wEZY1pADYAU5JSRhV3j9jYT/VoslxBl/AheqxkPPVgIg\nAUv3oP8J9q6SrP/fyBBJJxJ2nxytSZNMxECMErRRhX4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc987", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `987` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAU8MYYp1RoeXOlWaOm6eFCfAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwYjI5YjFkLWRlNWMtNDQ3Yi1hOWUxLTc2NmY3NjU5OTcyNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBlZmEzNGEtNTNj\nOC00MzEwLWEzY2MtNTAzNjI1ODRiYTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES84kz326ueHCa8Y9nXMpms+6voB8K/B79Gu+45QtHTa6+h1A2XfyUhYTN24l\nlFcnP0CrnECf7VXrk4iRUaB55KOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSEaD7nT4wKWWFiTJU++Kd6gizAEwHwYDVR0j\nBBgwFoAUZ5CgmfnSRmFb5FVKuzMLTC2bUDIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAxbbp4\n6ljNRFdSY1MeFFlOKQJPUI4VJAqBk2YZaOTL1gIhAJH8vuAP6tubNlVxGY8XSduP\n2bq2tlg+2X2/5SiMs6Hu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS1F/0NSOOi4K5WJJLq8rB1nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGIyOWIxZC1kZTVjLTQ0N2ItYTllMS03NjZmNzY1OTk3MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfzk8I3hjlSktgP216Ws4mKQF3EJF+S5hl5KA3OvSgJtHU\nbjmTI+voWRYpRq1v4oO6DQhLL0UNu3+SlqgcGn2ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ5CgmfnSRmFb5FVKuzMLTC2b\nUDIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZKYurK/hPQdHISMdbCATtwv8fDwHktrHPgS9qkJnLIsCIDDsMlsZDhgy\nfp2r1Z7AjmXz+NAwIlppC89Ujc7A0ofh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAWRfx/dfYexBQx7KzzYoecxjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBlZmEzNGEtNTNjOC00MzEwLWEzY2MtNTAzNjI1ODRiYTFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNhOWYyYzdi\nLTY1N2ItNDQzMy05YmMyLTg1NWQ4M2M2MTcyZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGyI2wWAa0wvXNx0uDN7Y0TRcQ1u8Pu9N3m//+yDA2ncXFy47vArBR+q\n6mdDDKCaS2FYfBWGHvmPybPNege7JzqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEhGg+50\n+MCllhYkyVPvineoIswBMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDeuqd9dG0rKu5IIuR21xdDzF5Hkrd3RI5p/ZUSHHnbnwIh\nAOrFVLs9dI9h6F45CdxaSgA+qL1a1VCejvzuvxU868Mx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc988", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `988` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbVQAur5VPC/pA9VU7T8KqlAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0ZmI5NDJkLWYwMmYtNGNiOS05MWQ2LTRmMGQ5ZWE0YjlmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVkMmY5MzYtZmM2\nYi00ZjBkLWEwOGYtODhlZTc1MzQ4YTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEklszXDmkBWEqLgUX++EOtM5Mg+rEZXuP7ZFVjs2/Xnjq91b7yeyt0CgcPIGM\n7rx87BrG6ElqB9HJvC2ZuaYaWqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGco5YATenTLZlHHJ/AlvPJERHBTMB8GA1UdIwQY\nMBaAFFJdT3MdBIT3dfwt0O4sC2EDjTg9MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBNfc46+WdsTEsJuZEOW27rolQqTMkfJW5V\nUn2cThSlfgIhAKl2pC5gKIXMiNanf2AN94WJJsSFe1s4AaIwY6xAIWTs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfgzSoRsnF0heHCrUt0Qt2DeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGZiOTQyZC1mMDJmLTRjYjktOTFkNi00ZjBkOWVhNGI5ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvMPGrgSEMGqWOYgoVjgEtzfre9XlExW+sAp1WH7c6xSBN\nsejM7Spi5H3E+XQsxiD9ku66dfyqJ/M4fm/nSLNXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUl1Pcx0EhPd1/C3Q7iwLYQON\nOD0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALK9tVGBqIE+rsUf0dd4smP2kaiiGgLG++/b9OeiD/dSAiAHCEjQIu+3\n4QDJzSIg+KbCr/tKiJeqQ5w+pwlA0y1sYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATTHgDLVLNiiHCIi3IdIMt5OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVkMmY5MzYtZmM2Yi00ZjBkLWEwOGYtODhlZTc1MzQ4YTY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNiYWUzNmYz\nLTI0NGUtNGExNS05ZDhjLWQ1MDc4NGEwZGM3ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK8baK5cGaU9qSUvozxpBkCSQaq8QX8C8yO6bzlPPhLjsQJd6MPA1kH2\ndf62KR0kR0fl9Q+KiWUHNGmJe9shWIijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGco5YAT\nenTLZlHHJ/AlvPJERHBTMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCAZ4vJNbvtwcFtbsgAibQ7m3WdImHYG4heMB96UW/UEgIg\nEpLLL3c18lvvT2TIVGAW+ztTFNoS2nDlo+WMhLOMR/4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc989", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `989` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAeVVdCZRtIB+5UeddF6pZV2YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjYjE1MjE2LWE4ZDctNGUzZC05ZGVlLWU3M2I0ZmVmYjA4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU0ZGEwNDYtYTZk\nYS00NjFlLWI2ZGItZDZmYWE4ZTY4ZDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFBcS/OTVXFdCh4blehKN8ociLqoRg6lDUzbi+3r4a3Z7qdQxM7XqusDAbV7b\nV4cGTezij+wWmTWO6MMAOF+/yqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyDU6fupNcRkYU4ieywSQQtsD+NgwHwYDVR0j\nBBgwFoAUxrsXSOfvzUPVkarN721JJej0PecwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgMtALLGD4W/7H\nxT+DhKflnd/oY9Agyo+ZpuOzjwoxlxUCIDkCJFrNx1R7lFC8/446VABmS8JI5nIa\nRuOerDBwkNcU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeKRfrDt9n02Qs/fl/RapgLaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2IxNTIxNi1hOGQ3LTRlM2QtOWRlZS1lNzNiNGZlZmIwODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLO/WuKDVJNIiPtIKS0OEl7x4d6MQqxM4LwoFzS/wIEoCZ\njXm0PwwaTS9ARZGuakqQ4ag2Jqwu/CsaaOgpR+WOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxrsXSOfvzUPVkarN721JJej0\nPecwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJrzrM2xLHLAW8fRPkQtWY+cgcQwahkW28vSfeT8WyRzAiBub4FlgIem\n64joWzhWIusJeL3uWgD9pDOd7mNgFLizbg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAa06UaPgYgpLMpJdTjyk53GRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU0ZGEwNDYtYTZkYS00NjFlLWI2ZGItZDZmYWE4ZTY4ZDZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg2MTU5YmEy\nLWVkZGUtNDQ0NS04ZWFiLTVkMGI5Y2MwZjkzOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDQqut+j8ELtMEU1SNJGpnLLvrzKGp4q9WAvjjgoAa9oIXfu8Z9BjNXr\nkmJuRHBO3V95/PIs7zG2r/EkX/AKT22jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMg1On7q\nTXEZGFOInssEkELbA/jYMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDaJFKXNqZEJzbLIWAm2NNQBBEu2rT6PD7tfapjZOkuRQIh\nANBlbqejhQf6BOrt8rcx71eMHGe9OWCtEMNbiapGj3ad\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc990", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `990` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWGoMUSRBEYJQpGef6wNU4IcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkODU3ODBjLWMzYzItNDFiMC04NzgwLWJkMDg4MTAzYTVlOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU5NzAwMDItZDY5\nYy00ZDlkLWJlNTMtNjY2MmVkZWM1NjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhl2g1iCh7UoizqoWPb5+v55FgGyT8tsyUZ4VgUmbvwaCQfPMGEf97hA3mlSf\ndRO6Ol0yDGmY0wKvYYIVbk7A26OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc/8V2ae7Ae8DqncRnXABzqmRMfAwHwYDVR0j\nBBgwFoAUROK/jPud7N+WdatIjPHaFDkly+0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMNK9HBKGxG1\nlxFoTFEH7kY0LT1LuHie3cBSnCtEe8dwAiAfoMT+Z0UW5lQHcb5f6XXTuPT1KDji\nBPJWnv449CjA0Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVsEiiy9/NEXIRGZf7sernNeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDg1NzgwYy1jM2MyLTQxYjAtODc4MC1iZDA4ODEwM2E1ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTl4WlIlqHgo7bkomot+1THaGfkVZv91ymT33hhXt008EA\nGrAo5dF4bpiRAE/KGXCvw975mjs7FstKYajV7Paco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUROK/jPud7N+WdatIjPHaFDkl\ny+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMC7qwzwXySeuoe8omCSvGIBMEDeQtqbOBdPjQ1FYHgiAiBMH12T4hdG\ni267dbd+vueFjAwluNmaei3sYwaAmUApxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAeGnxZhDsOlKjEzce0XwvR69MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU5NzAwMDItZDY5Yy00ZDlkLWJlNTMtNjY2MmVkZWM1NjMxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNlZDg4OTlk\nLWE2M2MtNDQwMC1iZDZhLTJhZDM4YTYxMjdmMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBk59biNDNWqHpHdo/8/d/3KE9FExS2UyFauSTnDYbx0doZEOOkECZDy\nXrv138yuMSN1IY61/xhzoXTnfGyBrZKjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHP/Fdmn\nuwHvA6p3EZ1wAc6pkTHwMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCBBNI1ngdjMxZ9xFlaQVJkm/g1pe0eMPGZP3AxQZaKAgIh\nAL6cDrp2qxDH6RAACY8metMfI7mx85TXnUcCGh6frOUK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc991", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `991` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQ5cwXCIKX4/G3wGZ+qvtYLMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkNGE1MmViLTFlYWYtNDMwMC1hZGE0LTIxNmEyMDk2N2JhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRmNzA3YWUtOTlm\nNS00ZmZlLWJmNDMtNTBjZTk1YmRmODk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1zGTo0KqclPjlv9TOWRARVBtUKsNzEtFzOgTYFl1Iy2/6O2oXSU9/eDrEKxk\nNAphIe73hMLnleEkUhAahzUHIKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJKoM6NhdWruPrFOPoU0wjbSEYBwwHwYDVR0j\nBBgwFoAUu8x0luOcFnoBmYFp22s8Mal6uvswKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAbMy2kkUesr\nKtfV3QhHPfvc13GTRZzZp9n3O17AsE4AAiEA+8ZvHat+fSagwdLonczdonHL5Not\nOHjgRcCQhENA2B8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUwcqtxe2uWemqw4uHE+zSDiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDRhNTJlYi0xZWFmLTQzMDAtYWRhNC0yMTZhMjA5NjdiYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkG75zn0VlRjGuTu6Gxpyh6Argniil1nf/y5I7eHPDX/5n\nwv8SHt/F5cI0SJgqWsfgVESxhSN/QAXqYtWj4oZ7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu8x0luOcFnoBmYFp22s8Mal6\nuvswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJtGIsRf7ofSmhRqJ6/uMa78PWCYIsNNP7wU2DJ0SwxYCIDPz81DyiNeW\nFCxg41M8FIbvmf4EA+1D350JPEZo7nvw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAV1tjSlX1gvE4arkcgPJ5idzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRmNzA3YWUtOTlmNS00ZmZlLWJmNDMtNTBjZTk1YmRmODk1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQxMGUyNzBl\nLWQ0NzctNDYxNC1iYjM1LWIxNmI0MWZkZmRiYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBZIeDNwpi5Sdryl8F72yx5s95pKN4bSpSC60p3y1hzmIqqUYcQ/n7Yn\nI0aQ+zxVRunovZdeM41c9RvlibLWeKKjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCSqDOjY\nXVq7j6xTj6FNMI20hGAcMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIH6dKwBhFytn6drvjKar7qJvzXPGxCjdLekNKjbhFk2YAiAK\npi0H6RIhZBCEBlK0OsbcSwPgjtf4QGCXj2GLBYHqIw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc992", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `992` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASGnAr5pYDPheMAlihtSbIt4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjN2M0OTA4LTM0ZDItNDAxNy1hMTI0LTY5ZGIxOWZhYTVlOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI1OTFiNjMtODdj\nNy00MmUxLWIyYjAtYjg0NDIzNzYwZTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuZvp1gGmrJHfjJH2cZkY5HMADGdfg6ljwIdTjqxfLHJ5RHH5sCIuBz26o18F\nIiz5ZStiiH9RqxMcW3Yj62h10aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULe44ARrCIQZkpYA5dMsIVkuY00owHwYDVR0j\nBBgwFoAUEEAdQW/ntISkRYBiwCWGnTiQyRQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEc/pvhEPrsfC4cT4LbV74bBzSINZls6hX4V3UvfoGKuAiEAsgn2e269EII1\nXlmMltlTu9biRndVJrDxJ42D796i9wc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVV6gbnvfTujh9BqVgFi1tUTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzdjNDkwOC0zNGQyLTQwMTctYTEyNC02OWRiMTlmYWE1ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpsJd9JOKUnEdLQu3lFX1cwFAGCNeZg+iDRGtYRpVsbMte\nvVVymoiQHmYdaGOj+mmXf5fYMHEDdX/ykjco+9hdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEEAdQW/ntISkRYBiwCWGnTiQ\nyRQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMQw3QRCudomK8IR+6c0puny86ZduAETAhv8ZbYY64ahAiADUo5y+ebu\n3plo9/4mZOdqzqfaUO0jIjEBe64CIUfyWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAcgLI69fTQGrQ23JvScEb9aQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI1OTFiNjMtODdjNy00MmUxLWIyYjAtYjg0NDIzNzYwZTI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU0ZTkwODM3\nLTAyOWEtNGJiNy1hNzI2LTMxMWE2MTA0ZWZkMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJPYZo4Etw0MivT6dFpg4VBVoCID4WqkIKvnP+H8PfRuAza6U7TB1E/o\nwuEThV866JlagWlcn4/KT9h783VP4XmjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC3uOAEa\nwiEGZKWAOXTLCFZLmNNKMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIAKuy3NPE9pNzBnpv2uTt5KULJzmDvjQTWjF4i9ZZXLIAiAB\n+ZQgwmsGsLY9UNLUxUr+lVpPSbnvxV06s0zyg6he2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc993", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `993` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZvzuY95NaiNccB+V6blnkogMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5NzUyMjUyLWY5ZTUtNGYwMC1hNDQ1LTMwYWMxMWZhYTRlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWE3OGI2MzUtNDVj\nNS00NjQ2LWI4ZDAtYmU1NjM1NGVhMWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiXTgwgxPbjqnEP2wkTQhSZ0NFpR3ro+nB4BsAcssYUpo0V3ABtnSL0WZdiaV\nju4dmcnEhTD7J3pcPRyygl7ZJqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhlsWFxfvj2VlbydebnvsWlb0qngwHwYDVR0j\nBBgwFoAUBCQeeJazFRKQ3uEHb+L0wtY5qscwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIG+DSfo3BpblwAEFAoTJruq+K0V4cMJyj+w7uADXZOyxAiEArkdvl0EehDyd\n2sAcJmuOGQs3xYGuFrZ/Vyp31XiAL80=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVvyVNEFxGgwhSLS3wzueDPfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTc1MjI1Mi1mOWU1LTRmMDAtYTQ0NS0zMGFjMTFmYWE0ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS8MFTxHWYTZQYyOnuiv+xTYGqB9NLzYPLVjR7ZhIhqlvz\n0keT5/0C1IKJ/kHNUCkmnjZo6wjnzAY3YAqMzCFLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBCQeeJazFRKQ3uEHb+L0wtY5\nqscwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANO/KMaPJ2WwnNMgOEWWyO+Ntf2bJFr335nMgRkZpCsEAiEAvxAO27e8\nPZXPGduZw0n2RhuGW9UvCrCYzp9eA133OcU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUxDG/mVpjembdyJw+rO/wtjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWE3OGI2MzUtNDVjNS00NjQ2LWI4ZDAtYmU1NjM1NGVhMWU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ4N2YyY2U4\nLTIxZWYtNGQ1NC05MjRlLWZkZTMzMTc0NGRmMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKpfLVOx8uLjrZldBVEH+RISWB5Cckn9CLTfxEqReMUVUJFswC/bX+Ho\nREZJYGMVFWF1/75D0MvwrHFSweqvcb6jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIZbFhcX\n749lZW8nXm577FpW9Kp4MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIDT/xCIrncQ8xMO0Rh3fDFTd+fIrsznwMHavAXuyIOKBAiEA\n6h6Uc8nhZbzYo5alP6TANKTgbx6DN0qu9lTXuuh4okE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc994", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `994` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAQFauIgGDmmeYhsEFnFpYZuFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjZWJiMmIwLTg3MzctNGI1My05ZGNiLTNlOTk0MmQ0NTQ2NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDMyYmU5ZmUtOWQ2\nYS00ZDQ3LWI1ZTEtMDk5OTdkYjZhOGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcIlmX8KGbdFneVNgv5PdQIBHuD58F9PAe592mRvZhhAu0FSctQN6AQC+VO0D\np+y2jJvN/GHOnX3KFsNkgHjJcaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO4n4TkF1H6xYj/dAhonX5fmaaaQwHwYDVR0j\nBBgwFoAUDeF1NR1/btYGTvq9q+Yurfb0ArIwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIC1e\n2Ue8Y2XEELpfmX0ejjA3Q2YsXNPjjPJsvgBMYcSIAiEA5DHr/SOF925Lsn1Gj4DI\nq4ok9mdDMIctFss/zZ2igOk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe1XC6+my3qXrlnYyV04wht+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2ViYjJiMC04NzM3LTRiNTMtOWRjYi0zZTk5NDJkNDU0NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMwmG6BvXr9nhVaE1MR4mCVqteaiSvsnrRS2vq8j5LZUwc\nbEojJx6bNiAlSewU6TfJ5svfHblz8mxzMVYhGe27o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDeF1NR1/btYGTvq9q+Yurfb0\nArIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYTU+Fd9ngcyR73OLor5o51xm/ZdWYM8JwQj4rzHLAOICIQDfPrlT3Ba5\nAezLV3btvotGIl/HrTS9v4UplKjwqKSx0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAT6CAge2dFjJ0DcGHE02Q1AjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDMyYmU5ZmUtOWQ2YS00ZDQ3LWI1ZTEtMDk5OTdkYjZhOGIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUyOTMxZTM5\nLTE2Y2MtNGQzZi05YTkwLTAyYWE3NTE4OThlOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKxg17OCK8Wp6t7IRjOoVoOC6wAwlCw7XmJH6Qwoc0WXH8QHY1f4TuaD\nQ7eg6jpN0C8FOJMQOxC0V8TnJG9vt7qjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDuJ+E5B\ndR+sWI/3QIaJ1+X5mmmkMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIG2nJLzkRDqiog71Bb6fyITL54N7SqKt8k/tR1jiqhVYAiEA\n4HE1pC37elmjYHmtftTg0H4EOLlLxbnzFGCCdsib3ug=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc995", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `995` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYXUpsnwWtUV5f/3YTAKfz8fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ZTFkMjA3LTM5MTgtNDEwMC05NjIyLTEzZDg2YTIwZmJmNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAxMjNiZTYtOGQ0\nYy00MGRmLWE5YzQtMTE5OTZhOGUxNzcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1F7mHDxphgAt5DLmjlvFRCp7gXxV9IduAf3abfaIA2Yxhswd2L4EV1ZosvYm\nQV4h0DhE2cSRcQ8sufVdA6tYBqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGEsSbQRrv9N1O8KErBFD39T7jiQwHwYDVR0j\nBBgwFoAUBNzm/YWqjvi3EpxJ1Gs2sLX6xF4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQC4qdhnGqhEFbj7v4R/wAUGKdv67tRQMHNZN5OM5gnE1QIgalmS\nhUqkFx8vkui/PglSGwBSCnjit/FjTbF7wlSYXRw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYwFLOPch73/D6wntduOF0h9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGUxZDIwNy0zOTE4LTQxMDAtOTYyMi0xM2Q4NmEyMGZiZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhZPVW1expD5q/LEi7+3mkHu1+5houkM12CUDcGe9vwYKk\nlwOPEMzG49jP3p6879acz+lUM6eXY+E2zvGMqfz2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBNzm/YWqjvi3EpxJ1Gs2sLX6\nxF4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT9ZrhDtMB0OrlD3wZzHbZpiKYJ7x/lt+KuOenAU3qN0CIEq2SqsxGCwJ\nSSDC4RkvLpoQoHNtbWCFyRA/Yx+YMMem\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbyOjAe2Pp6wvTrBEBugzc6FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAxMjNiZTYtOGQ0Yy00MGRmLWE5YzQtMTE5OTZhOGUxNzcwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFhZGUzOWQz\nLWFhM2YtNDNlZS05NDMxLTc5ZDNhM2IyYmFmMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJY9OyiNXXDuYr8X3/URA9WI02dkffZnaQJ8kXzQ5qFe81q62RwCd/mc\nxSUhtZ6lhAsq12oz5gTa1+nZoAx/6YWjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBhLEm0E\na7/TdTvChKwRQ9/U+44kMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCbqD0ooJixk/XgdeACF1HyrS/BMBSf62D3WlIrJvNrtQIg\nFhSPf1HXNDVh3SdTjmOhh9lHWH+BSRXEwDRKGPUuGP4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc996", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `996` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAf+gAwIBAgISAUuQmcyzvrelaJHwvBpUN2ZpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhM2IxMDA3LTRmZjctNDkyNS1iMDA2LTdiMDA2ZDNkYjc5MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RlZjQ5Y2QtMTBk\nNC00Mjg1LWFkYzMtODkwZWIyOTU0OTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6wHDQvkULlDh7hpihteaE1rRWDrYujER3dS8QJhsMRMc7oUbQaZ+lgttOnA0\nfs0qr6WtbazQEjAm1MPvKSt526OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUwQUsoVIEpsGR2SQ8R4VFRN4cWgwHwYDVR0j\nBBgwFoAU+C2Lz3NE/VZE8W5zVZ9Mwh0XeKkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0YAMEMCH3v7EEXxjDVMwshRITL6+723ern5pwH9WRnqZP6RI2oCICwWlQAs\nreqEJAYqpmsjEOyoa8oJj6OJZoIx25Y4wct1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWkRT+MneNkBJQN5u5/jusAKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTNiMTAwNy00ZmY3LTQ5MjUtYjAwNi03YjAwNmQzZGI3OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1rBP0IhlCenR/4hc/EeqMde6wpjHHxIs9nkQJnWd0nTAa\n6tJcYih+qyYpUTG6Dw7X5Tv4zoN7RrZvIfbX3wvvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+C2Lz3NE/VZE8W5zVZ9Mwh0X\neKkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI8VQuXXvYCO7Qy1CMA7JckmqSd8L07e7e4L45Dw8PjIAiEAuaCL6qvA\nu0X8kYK+y5yxmbv+bI14G3eT0vFW+r4+ObA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfYv97/ows93iL5pWKGh1VkvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RlZjQ5Y2QtMTBkNC00Mjg1LWFkYzMtODkwZWIyOTU0OTBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1ZWNkZWVk\nLTIxMzgtNGQ3NC04ZjU0LTljZmNlZmI4OWI3ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFTuXowgtnp49ypgek6RS8HKsk1yvNC11US4FXGoaJWCmaPwSvboARQX\nyyDWNDKZhlWNP8jqxuemS9VratJwaHmjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFMEFLKF\nSBKbBkdkkPEeFRUTeHFoMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCID02ycOKqlZL2QHHZok/wUG/oMJk90VSCMXjpigQZMSmAiEA\ntF56o9mhDuN4X3ySjG0NKiaMac3ZeA3W6y2Yn5rlkGU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc997", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `997` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXF644806T6Ebsc3id9s3ldFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZjcxNTUxLWRiNzQtNDAyNy1iZjEwLWNjNzQxOTdiNjZlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ2M2YyODItM2Ez\nMC00ZDI4LTlhYjYtMGIyYTZjMjg0ODBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7rKjmXvwpCK94pkHbS7XD0S18FLzg8muSeBe8lngFvp4v9rlVBuSgzA2G4qf\n4BoObr+nUcD2Fz4NGqdtuasqdKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMCnSBhoOrUATMhpd5n3XDlNq1NiMB8GA1UdIwQY\nMBaAFP6BtAGFs5xYihbHXKxQ0wxMIfQJMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBGCOBcw4HNOdlYLS+t4JlIh7CNou2ODkfX\nq8xOpZiH4gIhAMiJ4gxHaV0xug6kpgB2ZXCDyokS55byZSSGMJ6hsZeO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc2/WJsh+J80z/ToDD1cHECyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGY3MTU1MS1kYjc0LTQwMjctYmYxMC1jYzc0MTk3YjY2ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFHvTdhIkgqbRnT0m7X5c+57SSxnb74WgjlfSX7jze3wA7\nD08zrW4fIpWWYk/psWKvBqhFsnSY/k8AIKnx4+1Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/oG0AYWznFiKFsdcrFDTDEwh\n9AkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL0UJncSrM3cq2n40RlGYgHz25fDE8FcHE7q+R4qlIuvAiEA/pfaTo/1\nVZ9/nhDlKDryf0xgJlYxVoXca/8ajFq+6VI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAf8H3134gh3yrdovVYWb8W5fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ2M2YyODItM2EzMC00ZDI4LTlhYjYtMGIyYTZjMjg0ODBkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRkNzA4OGQ5\nLTA3YzQtNDVkYS1iODE3LTVlYWI4NmIzMjc2MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGZemFL8GzZL7cm7qr/Hvbi+GtLJeIzk7VVl6BjgNumceLq8XBZojv1P\nZ6B6rzuM3X/SCc/03mW+JAsEISX9tmejcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMCnSBho\nOrUATMhpd5n3XDlNq1NiMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIFj+XETP2fpsRohtvIzd/k3EqG415RQXP0mxevpRxZKUAiAn\n1KvKyPYekx8cri1XwI0X2JCQDQGonFtjYR49NxlcxA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc998", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `998` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAcJxqzx5vheghPjvkZz+qxxkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMzc5Y2I5LTFhYjMtNGYwNi05ODQ1LWI1YzQwZDA2MGNlNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ2NmY5YWQtZDNh\nNy00NWVhLThhZWQtY2ZmYzMwMGZmNTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe2jW/pMm6GtS8gqAfRg9fu7F27FbBjV1KPt9wb88AB5pl/dxzVIUf1OgtkaR\nvHzhSsPg3qkKDZG6B8HZKo1EzqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ2EzEPM4xkL3vvFYlTGhuq9/UXMwHwYDVR0j\nBBgwFoAUEQhykAzfQHk9Rbfnpw59y3FqzxQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgKyU9KaAKKssL\nNj9C3g1KoRQI9cFIrmlx100MIyxcVSECIFsL4xMgTUT5SgulbjQGYVVty2lve+Kj\nmJ60aShYIJmP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASfC0aHABVMseDXS1rZW+sp4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjM3OWNiOS0xYWIzLTRmMDYtOTg0NS1iNWM0MGQwNjBjZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZRpGbNeEgxoQJiadqMUOFRWRbx+qU8V1juZth4+H2rSQZ\noVezF3FwYEZiHb2m2dlvL43E7hrWs1g5i51+rR4mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEQhykAzfQHk9Rbfnpw59y3Fq\nzxQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgS6AbApjF3hOUxrxBw3HlNhcSB9+CoBwaH6Tgp2jEQYcCID7+4B21DQ6G\nQr0cjEyvzWc5IiEn2ug/NooRI6V35Z6a\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUzK+Xm2Kg4YPSXu3jurz4I7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ2NmY5YWQtZDNhNy00NWVhLThhZWQtY2ZmYzMwMGZmNTdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRjZDJkNTI5\nLTVlMjQtNGNjZi04MjY5LWFlMTZiN2Y3ODFiNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABInQ39wL+FrN7+WsuGtOTmEbZSe+45HvsbOPQprm6+X/Al0X9VRZTyXA\nA22LTX+1DkFlHrRKiF60wsMQNr2EUpajcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFENhMxDz\nOMZC977xWJUxobqvf1FzMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIFYoeHVMBtbZMZNBIZKk2LCanWTqmAUxYgUB8WlinKMYAiEA\n6pdZsHieEPjhmJB8Uy7+nVEUYv9ONiz/2xrCknYXiE4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc999", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `999` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAR//azY2Lc7o2LFBy5z/48bhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiMjBkODFmLTFhNDQtNDVmNi04MTRjLTc1MjYxMmJkZWI0NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZjNjc5NGYtODI3\nMC00MGQ1LWJkYjgtZTYxZTEyMWRmNTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1LSwX96LbuiOV8FSU2OS4dgHtdkQGRdoZUyhvZKWxlf6IZ7PmfbbY6Ek7twV\nG3Qilfis65hUW9yD4282lINH/qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9iRv6X/ZBGGzf8Jcf6BstJ7EVwAwHwYDVR0j\nBBgwFoAUsPObHScBw2pptMWAsJu/MWSw6pYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgUB7X5q5BrQQb\nxzs9ipM+L0kxcY2NBA0h9VoO9Hbmgt0CIQDE/W+7euZs9/Mix7odipKb/tzuRr0h\n8HMSTYJDPJGoGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVWMvZeAPpFHdLZPA33eGDjwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjIwZDgxZi0xYTQ0LTQ1ZjYtODE0Yy03NTI2MTJiZGViNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSUMLPFKzdN1tVro/bytsjLV2MzvK516LPbI83IsBrMi7x\nyqfXCiqMgn1BoPo5I42Of6/2gAs3hmt1C+KKvwyPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsPObHScBw2pptMWAsJu/MWSw\n6pYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPGOhpMbBWP9336hrL19nkSDncHTfYl0wYVppZ9tnluzAiBAWEnIUxfn\nwlVsMbV+15+ZTBv5fqIMWYkDXhIOW5JvzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAZRmhc5Zg7fGVp+0oxWolmgQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZjNjc5NGYtODI3MC00MGQ1LWJkYjgtZTYxZTEyMWRmNTNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg2MDJhNTdl\nLWE3Y2ItNGFjNy04NGIxLTkzMmZiMzcwZjBjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEZnEor0HnPuMZ9bQT0lJWQKmN3zvNbbSF8u8D2tHDyLGTYCf7iDfHwy\nHoS27FS88wztUT8O5Q1fmRKs+FMhrxCjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPYkb+l/\n2QRhs3/CXH+gbLSexFcAMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDicMu/pnXi0V6pL3TddWX99U0DTUP/O9M727LG8uMmJwIh\nALvzc6y80OaqmCHAXGtzRCj5YBRo7oHTCQnYQozdNFGd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1000", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1000` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAVQW7ZPI507junKlnHCEdc5cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0MzA5Y2Q1LTY3MWItNDZlNy04NDg3LWZmODM3NzIwOWRlZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg4ZTUwZGQtNThi\nNy00ZmQzLTg3OGEtNjAzZDI0YTEwYjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEInZfyaVmuIy1W04ADzSXyE2XnNJzKf5lxyY4c5T81t5gSd3lzkoVZWXrqb/m\nEsAtbvqfvKz55eyGuJGxREyA1KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUexJGqG3hHDGApjn9aimvk9YZSVEwHwYDVR0j\nBBgwFoAUZkwMwmRdhkB1J+1Q2hYZBp5lClUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGWQrknBglqP\nEb/WVcv5VzCj8+oSnLMUVxLR8QhuG1/UAiBd01DJ8JgeeVtYD42U/V4SfKSRF2rC\nk+4RsYIB+VjPlg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUUgmdUVWXq6G69U3lKY9XNsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDMwOWNkNS02NzFiLTQ2ZTctODQ4Ny1mZjgzNzcyMDlkZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMc8pHudAVLyFLYyTARTPv5aB6+Q63S6pE8AL7gTkZd4ix\nV47u71qY2ZQsJ1vnKou0gIo2JaYh/JyEoM2VGXnPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZkwMwmRdhkB1J+1Q2hYZBp5l\nClUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHS9I4Aw1ks6nQUyxdlJsFTu4MncYfqPfpgHkRVO76ZsCIQD34HwsY37P\nm2NRh7XrjRrc21wXAzbKrtZKQ0LPlIYINw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAewZdtU1zDdgII/UUTSO5roPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg4ZTUwZGQtNThiNy00ZmQzLTg3OGEtNjAzZDI0YTEwYjZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZiZWNiZTQz\nLTQ5MDMtNGFiZi04MjRlLTAzMTA3OGNmMTJjMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEfraEWXk1b9OTtifCK6qIX6UBm/ushhRQj+Laak/CUhB7UhQtNri3Yb\nMPy+Gpu8OLgDYt8M7f4nkYI9FeCjn6qjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHsSRqht\n4RwxgKY5/Wopr5PWGUlRMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIH86OoMs0KwnWcRy2IF7RNpO81/yJLxbsVnn4joq3VevAiBH\nd0URi0g2I5u6a8iuyiFS2JV/MxckoDtLF9TBAsLxjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1001", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1001` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATGtb3Jrp3an8jRvBKu4qxiAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhNmJlMmY4LWVmZDctNGFiZC1hOTJiLTE1MWY2Nzc4NjgxZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTgyNDYzMTctZTgw\nYy00YTBkLTliYTctNmMwMWU4YWUzNTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5Eljt3bUETtDcBX7k+z4n7SoMFMk8YL2LLe6ySvdj47ytFH/6WkLxnXch9ZV\nN4x0Iek7tImOSY8rCHP8UAHs1KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzNYZ0/VOpWPp/PfZ+7DryNsSoNYwHwYDVR0j\nBBgwFoAUgOXkK1hAZbBo1BiUltXCaQaW9IkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICXIyEOSnMIeLNEOJxVAN7gAd/EJJfjbJdUZeNA4C7L9AiEAxweSR1yzeweX\nyJzK+N1p2U9bmGEEDVcZ+/ZoXp4++Tk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVyyc0CkWw4ufmgpsFCSr431MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTZiZTJmOC1lZmQ3LTRhYmQtYTkyYi0xNTFmNjc3ODY4MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHM9oYjS55D4TviTKarcHnpabdOgP4z0/kw4eufGOcL0Rp\nWGraJYUpiuODWqLXba4HYNgUpZ3Meoa5y2i0Icbro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgOXkK1hAZbBo1BiUltXCaQaW\n9IkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKrNawdtO+1GPFOBGdXZVOcvYhM6UHYV0Eq2abNrU9m+AiBMgLaP3tsV\nszJcSrC81+62BhXwFefN7N/9z+VXFYV7mA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAV9gwucx20dmpOipnsGI5bY6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTgyNDYzMTctZTgwYy00YTBkLTliYTctNmMwMWU4YWUzNTdhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgwMDE2Yzcz\nLTk4MmYtNDNiMy1iOGU3LTgyZWE4NzIyMDQ0ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFB5N9YGhb1tYbDKDG1fPVBWOHUvXo44PxuK6/Bqgpg1UMLrQNeY6v8Q\nkNrDd8BRNHLG2jRIU4xYO90wvkxUJdajcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMzWGdP1\nTqVj6fz32fuw68jbEqDWMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIAvt2aUXbn7FkEKEPVI9iLQhJsldATLZACdvyG0/RWQOAiBA\nqVncTN3cuPTiWRzzECQ1FUEdA3jv7PUXC6zQVIDVcw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1002", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1002` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQvxIfgUqB4eIm2zsVSHDc65MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMzhjYmYyLTRhOTQtNDUwYy04ZjhmLTZkYjY0MzgxODAwNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZiMTdhZDYtNGU1\nZC00YjlhLWExMzItMmY2MGE4M2JmNDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyonHXwWIJEzo43tlHx4xPOVp5CbX3YldKYVukuTUnS0SJwujhwMLDR4ACq76\npz/IsDBVJXrLX4oCRMbi1/wIUqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxjhTDcNI7Kho/ic4qKKtZQ0bYB0wHwYDVR0j\nBBgwFoAUuoiacfW2+zdGjZZIm2emUauoVG8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFXGdrXFcaih157/DI1bVJnPLRO31T61FxUVtauSmNMXAiEAzPKhKVlwILSZ\ngH9tTLRhNCXQuWmRhCOkXbzmyQuA+zw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYK/7bbLkCs8or6zcbkUnBdQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzM4Y2JmMi00YTk0LTQ1MGMtOGY4Zi02ZGI2NDM4MTgwMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5euEUqFd1V190xN1dtb2EbHqWQ7wMMdzg8t9pqMP4Ew6Y\nKFoY1CRI5aVT+VlXeZlhBZgz3JjZ8i2rTRx1CQIuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuoiacfW2+zdGjZZIm2emUauo\nVG8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgT7nV51Gpql7XTrKa1EVYmjZvA9l69GQx7Iibb3FrV9UCIQDFD62ZCT76\nYwW6pOcVRm8n/2P7sgLvfvRr8AVsZb3YFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAStf0TeSvV1AIn5W0iHYW9dTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZiMTdhZDYtNGU1ZC00YjlhLWExMzItMmY2MGE4M2JmNDgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQwMDQ5YzFj\nLTdkOTktNDEwMC05NjlhLWU5NDllY2IwOGZiZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHpmUctbm3elcdyYLAVYdha/k2YfYsrmnckii4659brCx5RASyLi6J+/\nk48gIgv+3pRP1UNBRT9fAZnyEeUZn2ujcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMY4Uw3D\nSOyoaP4nOKiirWUNG2AdMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCt38hnGbIHOLZgNNMt5BRHN8hw91ziMyHgjSNCKb48QAIh\nALRNG+R7Zk+h+uhUjlYCdg2cS7mC+X4XohVH6ZHcBwQD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1003", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1003` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAdMZEWfD5z+VR780gD/raFJnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkMWQ3MmUwLTE1NWYtNDlkZC05MzQyLTg0ZjYxNDg0NDg2ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThlMmVhODgtZmZk\nOC00Mzc3LWJjZDItMzU3ODY3NTI2NzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8mFLEFsyOn05KczJi4nAdFFiDywNDFiDxv/B9sBWyKCPlsiIzi+zrht8C7MF\n7IhWjqFKjik32ca4l0bVzBSUlaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/etuWN1p4nYG8XiQsXoHRkOr0zkwHwYDVR0j\nBBgwFoAUu2lahr1TiaUMqnwi1mdKxW8IGiIwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCa\nXo7/qDZBryxLFhc33wo6V5nBV4FN8klRO109v5W/jgIgex8tzZ2qomnnuwkgEMDe\nbBIZqdkqi/8QPd6eNld7GLE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcUBpQM0k0m3xCbjhzQYnHqUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDFkNzJlMC0xNTVmLTQ5ZGQtOTM0Mi04NGY2MTQ4NDQ4NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyPY5O0nr0kwJZXdZ/ap5sUJhUa90B2jRWun8HmGTa5HMF\nPyygznHn4YSjJ9+vopmEKPb0Oy08p2oHAKHWOpbFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu2lahr1TiaUMqnwi1mdKxW8I\nGiIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYqjUYVxvYvFKDnLudq5p+0QILcV6/p+A8lgLRqTxv/ACIQDvQITuWgo1\n1Hu1yo7icQurHWICXHclg8ypAeXd4D4JwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAd8YQupDHPCCGxVpuoYgW/DMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThlMmVhODgtZmZkOC00Mzc3LWJjZDItMzU3ODY3NTI2NzlkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1M2QxM2Yz\nLWRkNzYtNDkwZS04NzU4LWM5MjkyMmQ3ODRiNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFU5uOQoIlZUDYRmeaxIuKODHiU17iwcgcP+W0Cc7N4IPSJJgb2rE2pM\nvhb0UAZmvvvAqfq68v1xEtBXnmDDA1yjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP3rbljd\naeJ2BvF4kLF6B0ZDq9M5MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDqKtBvytzSDZZDsFr4a96dS4/YHjBpRePa6hGYghs4qwIg\nNOAUPh8e2ZtLtwI+jGYr2Htiu2VQmIim5oKfBHlpbxI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1004", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1004` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAVp3l2OgTmSw7Iz26g0o/i7RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1YmExYWNhLWExZjYtNDY1Yi04NjgyLTdmMDkwYWI4M2VjMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFhYzdmZGMtYTRh\nYy00YTVkLWFmZmItZDAzMWEyYWUxZmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDtGkxQSsLacx1gDBX1j1ChjSSZHCyVDw16Ri6778L/XPykNNU6MU0tBPo336\nWHxm9RS6BcVwEun5zrjlKXGeeaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9RJjbX5R0VsoGxe9soLRmz9t0gEwHwYDVR0j\nBBgwFoAUqd5812eHFDFosKRcHVrgwgYNARcwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEEj3oQs6H7WwrFyX2vEaKNwThxLiU5hdzdNV5lawFb5AiAucU/n\nhE6av8IWeM2EPr1HEZoZE/3u1FH3eOBoqU2IDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWxOs053R9lMEcSgIkSB3NmrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWJhMWFjYS1hMWY2LTQ2NWItODY4Mi03ZjA5MGFiODNlYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHAdVLcUJK8jNM/w8Z5pxJgzeiw3MTvACdHKdVdno+gJaW\nTaC7Xi5zrvlU6uKXAHQX6mYVir0HxmNoBetmk9xwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqd5812eHFDFosKRcHVrgwgYN\nARcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXeCxmPmX53PI71LhcX0yTIGa40gtRgMjQBggNkk6kp8CIHBaMLDWg8Qi\nHUyvQXVuQj9giaMdOjNrJ5HV2ZmKan+n\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAV1VC55STkzcQBunnnF3erltMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFhYzdmZGMtYTRhYy00YTVkLWFmZmItZDAzMWEyYWUxZmY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFlNGQwOThl\nLTRmYWItNDM1ZC04ODY0LWQ3YTdiZWJkOWIxZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJpqy4yvRv1qGvIddhI6rTkYw5TEl0130/BhSD0Ih9AKaxzSHq7X7+O6\npdLCGUHnQSJiCU0nkzNKRAEYSy4kdDWjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPUSY21+\nUdFbKBsXvbKC0Zs/bdIBMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQD+0Ru17ANzL/Vu259dLtQ/vFQbqMNP51LYThY85/d6KwIg\nLDJRRh9IUVAcWJfcO8KGIKobdsGTaOq+Mhma2HLk1K0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1005", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1005` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAab2wJELCg7iGQwaGE1YszWuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyNWI2YTE1LTIyYTAtNDI3Yy04NWZkLTdkZWFmOTQwY2NmMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ4MWZmYTktYzkw\nZC00NjBjLWI4NjEtMDE1MDg4MjBiNDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENLwM2QSDWPoXO2DHqTZ0UQBJbUB0VRHDJHibu2evvnzufT1R4J33jbh53Z2v\nb6W8RoqbXnhEymaVdtvWpFSnrqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiOAh3ErDCXK6wFj5Sxk5TbGyUNIwHwYDVR0j\nBBgwFoAUmBapxR9yc5L7LrIl5OUVKDQta2AwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIGIPu2OQIRxR6QhTQwIS3QbJxwDfmGzfLUbUSw4lZq/vAiEA5ngL\nfu/wxWhnjow2qieeQxwxX8AT+6mL3uxA2qG/8rk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWiEKKcteqOBIEQok446WVe5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjViNmExNS0yMmEwLTQyN2MtODVmZC03ZGVhZjk0MGNjZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUGk6s7rMKHZQrSWvjuWJg0ToH8u+aYq79UbC5rfh9pG3V\nQcwH5CtdZBggdK6mVQFAgO2Nt21j6cEV9hyIa0XPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmBapxR9yc5L7LrIl5OUVKDQt\na2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPxrhOgMO2Qq4CyJvUoHT8v2UH1q99OLkkYBoW/7pc3eAiAnZfOxdoUg\nhwRk9OakaW2cC6Az9mwyEeNEVcfGcDrmkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZh7XIlNT4SXuqQko/HXUmezMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ4MWZmYTktYzkwZC00NjBjLWI4NjEtMDE1MDg4MjBiNDAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlhNDJiMWQ3\nLWM0OTctNGU1Ny05MWM4LTdlMmZiMmQ5OGVmOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH5zgL3AhNGYQSSZkFcUaeGBIHvi4ssNHlqFlIMgOJQ6foN1rhzSMurH\nqUYdl7pJNMAqV/GTf97wfX4B+Ijltt+jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIjgIdxK\nwwlyusBY+UsZOU2xslDSMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIAVtnG66wk7XKeog0VmJXFyGNUbUzjADPivof1kbXel1AiEA\nrB2tRvDH4hl6IEbJipV8U6Hpjm7ErZRorjf06yupT8w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1006", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1006` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISASuQ5gLBjiF7JKsdQ4j8NX95MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlOTcxMDZiLTFmMDctNDM5Yy05N2E3LWNlOTJhODA2NjFiODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU4YWFhODYtODE2\nZC00ZDg5LTk5ZWUtMGQ3YmJkYjUwNWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwJPzw5kQ7fGzUOtaUJlv7/y7xWx4pnlLS7TWCIlCTVE9A3/0NO1efJtQ0kx8\n/hwQnC5WYhZZGdo3j91EeE2awKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSiwWcytEkLY+P3Q1URZskxomVi0DAfBgNVHSME\nGDAWgBQXpNAk+HnuTp1NrbI4NvLpoFGj8DAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDbnoJGJVFX/MgqWd+HO/Io9rVSRASX\ngmpsslbB37J6dgIhAPmNEFF6fKDsBS6duoLDGP/JUs6DcwV4B3PE00E0gltG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdjejukdwZO9chhBLf/H2vd6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTk3MTA2Yi0xZjA3LTQzOWMtOTdhNy1jZTkyYTgwNjYxYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuBHRaZ/v4TFazaMQGJyK3IQUtm14eXlDT/jYXcMKYEsdR\no+HuL1ysNBhNW/JV1Pcz4soicx2maaSaVD0wgZPSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF6TQJPh57k6dTa2yODby6aBR\no/AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJYCQFrfOapcUAfEMdAdrrfL2ZraCeXdFe1Nq0JtQvrACIQD4BWqMjjxf\nk0tQlBlAgzE9I3ev2LapDx8ct2N15zfikg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQwPGeEUUm4LSWcKQNv/Ht5/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU4YWFhODYtODE2ZC00ZDg5LTk5ZWUtMGQ3YmJkYjUwNWIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRlMWY0NGNh\nLWNjMWUtNDExMS1hM2UzLTA0OTFiOGIyYjMwZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOuZ5WleM90xzHJwMttuDnLTIJ41kQ34BSgUQzWN6SDfK9h3VdMLPU65\nx68misba7TFLMpW2qwTjyvlcxS1Vl3yjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKLBZzK0\nSQtj4/dDVRFmyTGiZWLQMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIH4Hx4tXEh/UBfNeMwsnv3lNu+Td/EFUfJJsH77wZrs7AiEA\nk1ytI6ez8cIps1OMPiE0GqYE51PQaYMoSO5tYz5WpqU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1007", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1007` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAcMCaMZEvv/2A2ubJoH1IJtFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmNTA1MDRjLTc2NDYtNDViZC04ZDI2LWU0ZjJkOTNjZTEwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQyOTMxY2UtZWY5\nZi00OWExLTgyODktZjRkYjhmYWRmYTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECWfADFdxk05s16gKGtuSt0KRa52Cymfv5prDGqMIneS+J5WgnTC1GDx3EZj1\nh+YG2666gkobZvexdkzXmI4OE6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCLdZi16czq9+3l+RmcOqAwCeKKYwHwYDVR0j\nBBgwFoAUvdzSu94YlBeadLNERb3exvSmTecwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBQUMxyPthUs\nQTXHJ9kbzbsRWcJm+0/heBS3mU6zIkH6AiBqfYNP+WfkCZBsYePDA6PwwVp+tWx+\n0nQBD8ptUx4McQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATGgDvmfCAaYW+6GszrPBSq8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjUwNTA0Yy03NjQ2LTQ1YmQtOGQyNi1lNGYyZDkzY2UxMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbgDlRlik0R4vEpLEVzm8AZr88DkHBmpbLUp35hxs1iZkh\nhZ9ewha7eGN6Vdr8j1y6KlUKhTT9BDlRg4WZgSnRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvdzSu94YlBeadLNERb3exvSm\nTecwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAxfbrAjXpFwVXR01DKCIdhbZkYigmnPmZXX6v9Osa8cCIByuaKP0k/EA\nB3JWdFaoyw5ppi+dHGb464jWZhgn22S6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXbkNTpO6Np3UIF0y5512SeeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQyOTMxY2UtZWY5Zi00OWExLTgyODktZjRkYjhmYWRmYTU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3ZmMwOWEw\nLWM3MjEtNDU3Ny04OTAzLWNiY2FhOTQ2MmY2ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHjjIRqjGcbSlwRcUm7IvDr9s2CsszEIzcEorUrXixs8wpJe1hShv39F\nVOUBMQ8XqgvsoIjkhU9SJSbWWT7qEPOjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAi3WYte\nnM6vft5fkZnDqgMAniimMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDi3vnDsFK8EI6j/suIph7vhr+r3xa3XnhGtxmHQJq5ZQIg\nKrZ6vArFRJjqoi3vXneoIegLuzku3cRmRs8p8syP7aQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1008", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1008` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdxCYVLkZvpEEmMuzvIz0BrTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzNjQ5ODkyLTJhMGQtNDU5OS1iZDk3LTUxODE1YzFhYzY2ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhlNzA3ZDMtNjAx\nZC00ZTE2LTk3MDktMzY1MWIyYzg2YTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXSNBGHqVQy+XfYR8d9sKG+VeAkUHLV2Q6oLYT0PwlrYS2buZtkRHZN8iYjdI\nwBlcWKKmnq2w1lBqHnfbD207A6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtvHgZ1ILR3SFiSRB6xUpTHEyJJUwHwYDVR0j\nBBgwFoAUbT0vAiHL50cjqVHkfjnHAI6XCAQwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCE/Lia5OSf\nEWfOV7T0GNgu6+wBHH0xCIpUOuyjpjL9MgIgEubGoIR6kty6sT0gHvCDeIIrYuYh\negjEuWCdBZlQUQg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXkQRDNT8IgT0wvk0WZH1VS+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzY0OTg5Mi0yYTBkLTQ1OTktYmQ5Ny01MTgxNWMxYWM2NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLAHS9Y0fJAeakbDV+kPkIGLkBKpKFgO58X81ss2suzTjc\nkRgwP6W3X18/N2UdJEB+S2EKJ1cSErXgABstDQPCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbT0vAiHL50cjqVHkfjnHAI6X\nCAQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPpUQ+uNQkCaX/UzUZzxHWOWR64ULNUvR2lMU6XnsauOAiAHzO8pbgd9\nu4n1E9gSwcQF3pETfjmdv/WiCwVebeve2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISASaN8hLvlaLosfSEX+ubC2OrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhlNzA3ZDMtNjAxZC00ZTE2LTk3MDktMzY1MWIyYzg2YTFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3NGFiMzBk\nLTE3NTUtNDBjZC05NGFkLWI0YWUyMThmZDhiOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF8kZuuWpcUklHgMl+Lx2A0z2j2wk9ELz+a/i1+JEmG6lJrX/wZkYhZE\nrlJYo3CaUp18W95TkC0BwXxAI8JKBEijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLbx4GdS\nC0d0hYkkQesVKUxxMiSVMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIAj28hUvvHwhBJJ0XDaTwtg3nVo4Pws3OSEehA89YeszAiEA\n/caTRH+ofKjMl/oOCqfPEvvJbx/4/ew0sDBFNisVVd0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1009", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1009` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISASfobx8kr1hcTkLV4zvfa4DxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3NTIxNTFjLWViYjYtNGE1OS1iODk5LTRkZjc2MzJhODZhNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDU5MWQ5N2ItNWYx\nYS00Mjg4LTk2MDYtNmZhNmU4YjBiZDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKPElExGVO26d6C5iEdiI8yU4JKsIDo3+zzxFxKQTUXs+mjxNRQhPFFgb7U5R\nDG5y44ixtFemFa/UItAVlT5Dj6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV+Sbt39HLBGXUvHrynBp8UyQZK0wHwYDVR0j\nBBgwFoAUS6YwoEl3HoqsOth4o0Ti2hgmMzowKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAqbj20wwG\nwcfOusDyRLIsrS+JgFCjIiu0KFB6xYtLU8UCICw1TTKe4/SuavP+COD4tvP99h6q\n1eInP7OOrLMwH5+H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYfOCe8wKU/120tMG3t1+N3KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzUyMTUxYy1lYmI2LTRhNTktYjg5OS00ZGY3NjMyYTg2YTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASObyX/LoqjtfykpI5JnTZEvGavM7mCmERh+Gc8q1Rs19Dr\nrz82YQHUv+1OQbYww0n/GU2OsLglmMt0jizjU7rHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS6YwoEl3HoqsOth4o0Ti2hgm\nMzowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYhb9v2C3yf5d3FDQE66M8UjBUXjtNx+SmpcZRoH8oJ0CIQC+TM/bKdh4\nBVV8q1Iw7N+cOnnKpl9dqmk4i3lz5kJ8Tg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAXBdooxNx7TDdsmsnp5qi+rKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDU5MWQ5N2ItNWYxYS00Mjg4LTk2MDYtNmZhNmU4YjBiZDJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY0OTVjMmFk\nLTE1MDUtNDUzOC1iZTNiLThlMDEzZTU1OTc1MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJN1etee2fjEeq75D+kdQQ0nnTDlTUO6NFLDIWYDicvle+mB8dqVRWqS\nUdx8TCzZrm4mdXTf0AMgWQ2PZSQzPk+jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFfkm7d/\nRywRl1Lx68pwafFMkGStMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIHQWXO/f7SCbzA75DbePmRwi/Lu0Jsc38mFMcvW07rGCAiA4\niV/CIXLTcf0XtQlj/HCk8YXLr0YN8T0+iqKOFMyCFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1010", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1010` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbrvO6m7xbMoilBT5ecGlA5VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1OTc4MGZkLWU0MDgtNDllNy04ODEzLTJlYjI3YzhmMDE0NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY5ODgzZmEtODAy\nNi00MDU2LWFhZDMtZmIyNWQ4OTYxMGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu6kkS+8xmKuBGGIgXdwMiQqSgUV7s521wSqP46u7vNtWTc2L5s11HGzzV8GO\n8ajzWyHr9wM1DKUqOW6lQmtCuqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW/XiPp3DSajuEz6JrzmvFeo9rpcwHwYDVR0j\nBBgwFoAUKol2rAYg49dtJ030gqj+md0yyGswNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiAorxozr73jbP0Xf6NGmt124KuvegkUKYOuHMlH21BmtQIhALwkPvV+fMYJ\nOCi4C7rrHIo90dPk/KBbfkSfSLp2vGzc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX4YFX6AQn2fD1Xera7I1/bBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTk3ODBmZC1lNDA4LTQ5ZTctODgxMy0yZWIyN2M4ZjAxNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlzuHgFZeTXdtt+tBfjlRixW3jfRN1YlaPLigOjfNcKgWR\nOSutxp2p4SybUYSFjq19c/d30iBcgrQSnx+AEYVBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKol2rAYg49dtJ030gqj+md0y\nyGswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL9x8uEr/KOJHkQ6TznQvLuKQDnFwGQ6bhkvF8a9brEIAiEA5HbMNphS\nbi9XrtRvRSmICwuDjYtAsYIdsLRBYeKLywU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAQcQ/QHVhtjZdU/tVPKbgn8DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY5ODgzZmEtODAyNi00MDU2LWFhZDMtZmIyNWQ4OTYxMGU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVkOGRjMzgw\nLTA4OTEtNDJkZS04ODFjLWIwMTJiOWRhMjgwMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE2m/uAu7MXCWRsUrJi92elVm9rtPGeB1tEu7804RSAWs8AVrymo4S7W\nSaUoIOO9c2qoZHmifo96uIbprCVKvUCjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFv14j6d\nw0mo7hM+ia85rxXqPa6XMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIGuRU7IlbifLA7rnlm0i9VBCqzoY0r/CCgaPEpnlU3dfAiAY\n71m2Up781E2/pwefqwJnHklAhnrPC+r0LwNi49DQSQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1011", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1011` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAVxL/43WqDfTSZPvwRQ3irIMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4YzYzYTlmLTVjOGItNDEwYy04ODcwLTg2NDViNzYxY2I5ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ3YWY5MTgtMTk5\nYy00YzdkLThiNDctMjI3ZDdjZTZmNWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP5Fb56MJBTBaMeVWuou0OlrgoxND/1l6h6xLxDx5G9Nf2t4jdkHfSa4kFdBh\nFgGiXdO10XeTDyaNGRL3Yr6NwqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkckyX+5N/5mVfd3hlAItMW2kQMkwHwYDVR0j\nBBgwFoAU6pzyMBLv5bMWHrTkGMhudyUgqUwwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA5LH3Y/CNjR9XZzqx+hyF2eXPib98I9f19nogUXuXTTkCIQDe40Q0SvcU\nJwuqxUq8gk10f4wdmIzz6EnhGB0d1xLAGQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXB62+bbFp9XwjG/dRXZrnU8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGM2M2E5Zi01YzhiLTQxMGMtODg3MC04NjQ1Yjc2MWNiOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZhHB5H84l7sImas6o02w4uGIf3wAfbVForF6vUp/w32pZ\nHguETXKY6+aztiB84pui5YhFuT8ZD7yRZNQ9SNryo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6pzyMBLv5bMWHrTkGMhudyUg\nqUwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJZT0Y8cw0qTd9Y+9PWFGUvMFDQB8CGFrmqUFvSNZ0OmAiEAmI2cFBme\njx0NpSyy7/SKy0rmMNgKyDo+9rJwI8DdJd8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAY3t+WcHFbM9PqJZnFXlarMeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ3YWY5MTgtMTk5Yy00YzdkLThiNDctMjI3ZDdjZTZmNWEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMxNDFiODc5\nLTQ0NDQtNDVlNi1iNDZkLTc4MDFjZjBkMWQ5NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLjSPCVcL1rUcqdhNg38HYfPoN3rzbUopZidAO4Y/bHdOw9iStfkO+rs\nkkUODbx6waoQYZJp+FUO/DBEmcJDUyujcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJHJMl/u\nTf+ZlX3d4ZQCLTFtpEDJMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIGzVdnjbru6f1+kQ+7qD/BqpaMj+axUKju8f5+Zan7ZoAiA0\n5ezT9f0s2JQZMCowgmQple8E9ROKIdBn0IQjooJyow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1012", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1012` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAUQTldReaWMbLn2l7RnIcVh3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhOGI5NDQxLTVmZjAtNGQ0Zi1hYTMzLTkwYTdjMDg4ZjIwYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI4M2YwMzctMzQx\nYS00NGE4LWFhYTUtZDkxNzhmZWJmYTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOuM83kPdWElv+p9zy3Zn2AWQRn86eL8TN4dVdP3ufpeQWaRjhcJWCESKhSPI\nTG0myBOkyPV+KjJ9ExgmZcjpDqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxZC/RxCHDLGIuy0ZtkpF/CAvKJ4wHwYDVR0j\nBBgwFoAUHu+Cuz8JteioKDM6gYzBa5F7jA8wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiA7\ncoyoxtyMsOTu6Q5EWBkgdxYmBNVgkRYDQeTKkX04QgIgVGZ5ccdDf2cL/hENG5BU\nmqfP/0WH8ecV/DWFEZzxJR0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVzEHS2gUhIqZK6NrMQsJ8hdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYThiOTQ0MS01ZmYwLTRkNGYtYWEzMy05MGE3YzA4OGYyMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQIG6gijyN6vMmTd6jeiuU0iZWnm+6kwC5AZDI4GlqfEdu\nL2cbMFwSuWd3i08zB+XTfNjKQP3Z5tIs1pjSyw9zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHu+Cuz8JteioKDM6gYzBa5F7\njA8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANpFaGqe2p22nUNB4LvX7GIkNOcdvr0a2oupv3nZEZPDAiAi9R513lg2\nfsByXIfGHHxrabPZn3k8TgYnVa0CULuX7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAclil81S60qUakuBnPqCqO2jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI4M2YwMzctMzQxYS00NGE4LWFhYTUtZDkxNzhmZWJmYTg4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRiMWE0Njk2\nLTA0NjYtNGJkMC05YmZlLTk0MzNiNWNjYmRlYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNc5+q1/9ISbcrIz01MDIUh56stAmxsTgG3DCjGW1wbXXGDLDULS7sKW\nWe2bwanv2yWBe0ENoweBw/YtaxjluaqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMWQv0cQ\nhwyxiLstGbZKRfwgLyieMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCp62tw5s+ZtkN+Ew7S9ULXk/MzB0k7tqXg88KkKX1tDQIh\nAKX6tnARxLLd/E861D3OFRrape96UdN36jjg31rkXRRC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1013", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1013` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAfOl1mzpCXPqD5D8aPmvdkdjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxZmZjZGVkLWUwOWMtNDBiYy04ZDQ5LTliMDk0Njc5ZDVhYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY1NTM4ZGMtNmRj\nYi00YmFkLWIyZDItMDExYjliNjczOTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDT7so9ecZIhvG9z38+H5uNzxZ0cW9p+QBPdP+IuLam3MuGUvDrVOIYD/FKn8\nHlbcwILmUqzoyMRaMxBtrkFfr6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5JDFykx+21qGQyZhoWgLMCNT2dIwHwYDVR0j\nBBgwFoAUy9n10iIUMeag6zNFKc7R0dVNgBswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAeK3fo6hPdJSJ4LbU3+x9AOXmI9hZqnJUtLzVGvK11lwIgCqvQ\nTi5sEZRr4IL/zTCWm7a/PT5VKHvggY0n61uuQP8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVo2Y6SAH9jLnZ9t97GcA83CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWZmY2RlZC1lMDljLTQwYmMtOGQ0OS05YjA5NDY3OWQ1YWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjcmlaeAUbeQEI2EIrGz8v31H7ZK38CTbSV7GkRuANn2qo\npMGLHPTBD/OAmJ+LATLUL4+RHCAQ7vASsWWupmTdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy9n10iIUMeag6zNFKc7R0dVN\ngBswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTu1R8yAmiuSKBruZ7JvD5LPUxXCJWcsolvGzHlU6EMoCIDZ8zOWR0z05\nL5vFkhpmsgyvk7+WEm0rb5Axttqh/JQP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVgJjBS2ma1WD0VeZ1jQpLpBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY1NTM4ZGMtNmRjYi00YmFkLWIyZDItMDExYjliNjczOTViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZmZmUxNjNi\nLTBiOTEtNDA0NS05MGUzLTgxMDA0ODJlNzExYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOMW0VdgWCMIcXkOjd+YAJc4edgIDpKfMPhSzbSI0+yhuX4fCvmtD2jd\n7OrNMcbKXHE+Rj8xFQmxhoI5nEMGRU2jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOSQxcpM\nfttahkMmYaFoCzAjU9nSMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCGoIUYnrFJl5LCBkK7JDiSexI59REplk8B6+xZpptyoQIh\nAO2G6zEuSWY77OqAHkOvZTr9VsC/I0bUxQgvaby9bf0W\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1014", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1014` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAavv+WHHbzg4RgUMblhe+fumMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkZDRiNzY1LTU1MjAtNGM3MS04ZTEzLTM0ZThkOWU3NjU3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU2ZjZlOTktMzA1\nMC00YjA1LThjYjgtNDE5ZjI0MDNjN2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWPSqx5rBxo1ziie0UjXBUX/Kqc4XsiVKw1t4qQLaG4wc8Y45UCql+rpm4YMT\nKsYv8CqpvMgOs7mTfy1H9c6NxqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS0o1WLLI1lMZwH0/rPEpQUMLsuIwHwYDVR0j\nBBgwFoAUDB6n3U5ZOg2qey3J70ZJU9GXvs4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA/VpSP1Yq/5z+vT2MqkgWkidAHl6pVRZvUBC1o+x/xLwCID4z\nMdTJqieiK5CTIBapLqpsyUh4Jy1fE9yonrwC/24Z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQoC6pMgJHGd2UBhpmmtXNuWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGQ0Yjc2NS01NTIwLTRjNzEtOGUxMy0zNGU4ZDllNzY1NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxQkv5Hgd4XZJSwET7b6pEA1XRrUVSePuj7tV6mKOZcEUD\nguAdjjKIy81UtnlgWxzGMdJotRLaij5rtJlo7kkPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDB6n3U5ZOg2qey3J70ZJU9GX\nvs4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPhBMB/WNU5ITHGmsa0auQj0mbWi8xZKbA9KRxlBA6MqAiEA/S8QHwgy\nlwueBn4VLUd1WlUduMWYDAtZ1/GKzS6aLs0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAV2ck0tdfgaRkuTkuNPUgtqCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU2ZjZlOTktMzA1MC00YjA1LThjYjgtNDE5ZjI0MDNjN2M4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4MjcxOGUz\nLWQyMzYtNGIzYi04YmRjLTI1ZTBmNTE1ZTIzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIRuzzdKIO1/JPu/DNd5Vxe3/G+3oi/Sd+7K4US/1kmJv7t1R1L5aSdz\nTYs+nMbf2uP5A6+gwLZ1eyz39lTbgQGjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEtKNViy\nyNZTGcB9P6zxKUFDC7LiMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIHRyLARwrvSVMrtT+uuJeEzqpZU1angtzU54/V33uch5AiEA\nw0uPDV3oL/rfiEex2PMzEYG4/XTH72L0mgLqT4S93Zs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1015", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1015` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfL0ef/Xu4nhQHfT9HSJt/e+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZGU2YWM5LWM5Y2UtNDUyNy1hOGY2LWEyZThiNzZkNDMzMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNjNmNlOGItZTg2\nOS00MWU5LWFiNzctMjQxZDY2ZmY2ZTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa8ToAlZ19EzDpRS1lkQ8/GJtIStgXwPqjLVvo+D3fI7JeE91H2JYowlBgnbI\nDdibVY2hHETGESXKG/46KjhZFaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtkO6hvpvdIAGZJZBDeqL+EhvvekwHwYDVR0j\nBBgwFoAUr3Xd7uncp2wlfSNtqd4iOjGncScwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAFn3sjNhqKSykJ\nA1oqNFpHg2n830rHw9htjAGAsCSKFwIhAJGWvb2ysqusj/BCckO5CtrVkv0HVLTG\n8bA5irpZe63u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQsCCszJZ8Bu2Ef42hcY8U7RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmRlNmFjOS1jOWNlLTQ1MjctYThmNi1hMmU4Yjc2ZDQzMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZE/KbbW1rSSr3Ec2tvRiSSzkg8kf4iBjSfaMHmVJHmv/H\nTdvjeMTeuxjkklXJq7mUdXet2rECoKZwRJaP4hzno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr3Xd7uncp2wlfSNtqd4iOjGn\ncScwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgR72cy3MPtqdCd3MugxuGAzalb8rtO8bgZDN3ZUEK5sACIQCUnININLNy\nPKm7O/kcj3fk4n7W7sw/xdmwf1YYgpqAyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAftGLl4o8cN/VdctAbqfjzyxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNjNmNlOGItZTg2OS00MWU5LWFiNzctMjQxZDY2ZmY2ZTdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgyNTU5MTE5\nLWE5MWItNDNiNS1iOGFlLWYyMDE5ODJiNGM5ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABECZehvjT0gaVHRicJdHvRNisfRJ/AZ+PtfzGR0MN9pGb2VBpKDq+ACg\nnPAFQ3cJAqz3JyxNhpqT8JfhZmGwQQ2jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLZDuob6\nb3SABmSWQQ3qi/hIb73pMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCID9XEdFF4EIlSvDn+PDPObYbj8cPeqBlScJDnFwCAXKTAiAO\nrTFX6JkXQIwC4Iqsgf3nBz2TcU+sVWKlnjPRggwmMA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1016", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1016` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAXoEIZZRPRocqqwuFpR5dE6YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMjBlYjc1LTlmOWMtNGYzMS04MmI0LTc0MmQxNmI3NWRjOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU4MmY2NjYtNzI5\nNy00MDZjLThlMzUtNjRkYjUwMmVkNmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIgcUtqxsR6D9bXnGpdIfFJSGQeF8oVm4YDDoRG9uEISRk9dtUDHdWkL90YN7\n9nFNoQ3dgv0X4Jl0/WLpBAVqHKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkGx9G3DBLa7BFTwe0V2iAVUDDVMwHwYDVR0j\nBBgwFoAUR+UtgHcVrhcZtA57nhQ2zGSjkmgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGYY/KE7e071wQGMQWXzEiLr225BbjW3pQbvmDMR5SNOAiBrYN6K9FpYNKKt\nT1bF7wc0T4tY72+z7dJzBsYJ7Ubigw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS9Ug3c2uLNCcBfG53ZUxBysMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzIwZWI3NS05ZjljLTRmMzEtODJiNC03NDJkMTZiNzVkYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmBuTEYTbzNrFo/Faolrf7+qJOM+qYIa26m/uXD0+IMwet\nXm8oEuH5g9VQ1ZYcc7WR8Os+3cjndmenu32ZTvIzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR+UtgHcVrhcZtA57nhQ2zGSj\nkmgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ9gzzFrNE3VNb196rj+ecTQtZICQ8rTAj0rkY4u3lxvAiB+w8VOrHYC\n0FW0AWn09ks7qW472sm4swwpPPBSzUmoJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAe4/eSoAhUyNAab+7XM8dXKuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU4MmY2NjYtNzI5Ny00MDZjLThlMzUtNjRkYjUwMmVkNmZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY4NThmMzlj\nLWUxZjYtNDAxZS04MzI2LWQzNTI4NGQ2NzQ4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOfygf2BNazH/NS9CRL9I+UC5Hs6zS6vQ7shgRwGPOcRk/9egDRX5EV8\n/mNaiPVqYgQpbLK2cZCjFoUSrhM2LV+jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJBsfRtw\nwS2uwRU8HtFdogFVAw1TMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQC9Mba8j1HMUVkpcuKoabGDboOj126WUE6F9tmozskbJQIh\nALhHFd1VFJtjHr4ZMTZlDVxiosew4ngdl1KgHgJwU8+M\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1017", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1017` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXohA4GgWvR5I8jnrxHOmO2kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzNTcyMDdjLTgxYzYtNDlhMi05MGI1LTZmMmNmMzdmNjI2YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTliM2MwNzUtZDk2\nNi00ZTA0LTg2YTYtMDBiNjQ1M2MxMTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER5+eHe5bpVoCLIq62wQDRCvcFdRTr1VclqpE/7NyAt3ozuVX/JcI3PO19RVV\nvzqPSwPxkUctGPF3Hw1SuyAgYKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjEnTxbUPV603dtacGYN0yG0V4GIwHwYDVR0j\nBBgwFoAUk5QUT4MEyOlAqAhD7gi7BY9Fh14wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAv/SvY5mdf0rafSjFiHc53pUgRvIsY8i7rC/+M5NEVeAiEA46/eL389kuqi\nfC10oTOWha3UUjvwS6NFC+wK3vW5ETs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbcnxiAfHNYdjaec0hYwV++pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzU3MjA3Yy04MWM2LTQ5YTItOTBiNS02ZjJjZjM3ZjYyNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjQhkj8biuhcDHGahSUNeha9Stwyg9gN6zNg35lPDUkAb5\nlch30hRdSZ/pzdvyuJA02UMJ2Q7G6f/AInrpqzXJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk5QUT4MEyOlAqAhD7gi7BY9F\nh14wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL7KZ/P/X+Q42zFlqLQbxd/0Gc8nrgk+QYMFlEgLuyknAiEA+oyHfsCn\nAGhijZFrGDODbkUUi/NxaUtDYBGzmkX2Em4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAUMAoqeUvrptSjvmVJRVgJBbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTliM2MwNzUtZDk2Ni00ZTA0LTg2YTYtMDBiNjQ1M2MxMTlhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ0ZWI4ODQw\nLTFlYWEtNDk3Yi04ZTU4LWFhNTUxMGE0OTdhYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH5oOkbRCFngFlcZSw/OGDI61BtLKEVx8HBc1Wlz4mOV88pJAgrL9h84\nU7FnG4cLO0iq7YiZKd9QWytUPSXxlcOjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIxJ08W1\nD1etN3bWnBmDdMhtFeBiMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIB9PFPZVzM8WfVVEhbVAjX/f/mLA0BqnnqjR34bskaEXAiBL\nnRvK7wnsqIJKwHXHqJ7/UP8tuuVzUj5cVSVIyyHi9w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1018", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1018` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVm/9GOz3ZKmPWVMePTa0cM4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjZWI5OWJiLTgxOGMtNGIzOC1hM2FjLWU3N2ZmYTE3OGU4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZmYmUzZTktNmQy\nZi00NGFhLWFiM2QtYThlMTJjODc0YzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbJEXhOoBo593N7MMmvRxErDF80+pYvsHPx2kN+8163MjsIV0dgxe/pYut3R1\ngV+z6MHQFSPMbk6Y0U1PMExpFaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7KRhIWdrN9WjQyIASHwxhxbclpUwHwYDVR0j\nBBgwFoAURGofXt99esDs43TwVEtlJPE7ifAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAii9u+rk7o5FHP3yrcAOdZcTA1qp57FHQdtfNhTFJGdgIhALhGFDbisguO\n9P8Bf00EP5Z3hM7aOezObxEzCjFo1XSF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU/marVYBmzZqk/yLjTl48t/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2ViOTliYi04MThjLTRiMzgtYTNhYy1lNzdmZmExNzhlOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8+d3qsUsFIhtU4CgUy4OZdKJ9r8i4s8bQg/G+xpRUM9X1\n9Gs/gMuTn30Q9BpsOk2IjosWSTUS2YdlLYqmN6jFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURGofXt99esDs43TwVEtlJPE7\nifAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIQJX0br+XfbZiEkbrtOP+a7XxqtM4wWb1myG6RKaYZmAiEApqoLlpFM\n4PhvtDgRrjd3XRyrO5EemEHPZs4JQJl/0bc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAU+NykI0UDfPLpDWVxRAkSPRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZmYmUzZTktNmQyZi00NGFhLWFiM2QtYThlMTJjODc0YzEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU5M2E4OTc4\nLWIwNzAtNDc0Yy05MjlhLTY5MGY2YzdiN2JlYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJDGL7Op85cPYp4f/xODh8B2L/U/lHVZb6J9ooPgFfcQ01TbwSK/7o2n\nJLDFzMC7/8nsTW88zkGIZ4KKOIrcb8ejcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOykYSFn\nazfVo0MiAEh8MYcW3JaVMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIACKDuKCDl5FeHWZA5eio6Sot5t8Rhwi/84l/ufyJlu3AiBp\nheEwWh7YXBxmhaATv3sESYrolhfoX93xh6U9wD4X3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1019", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1019` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAZOeJNP5HqrnNXi6Vp+GpL/IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNTY3NzMwLTNhNTMtNDA1Ni1iZDBiLTQyNGU4ZDYwMGQ2ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUxMjI4YTItZTQ0\nNC00OTkwLTllZDEtOWNlYmQwYmE4NzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgsBpRZl05O0aFORuml1QtMGw/mTIz2hMXcUCl5QmX9D0bd7Qmcze7kQGXZJz\nmmmUIfcLs3HlmVEhX8ksnSJO36OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxZktSexiL0dUl2gBrD+bRqZpm+owHwYDVR0j\nBBgwFoAUj7T1c2SqsDHEsiVMZ/2/zu/qr6QwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBoSm0+cmxbPCBeO/z7ktqFJlSVamhOZ2mKcvIkBC5z\nGwIgIUxfbZJ1ejCpAU1es9v/ONmbtBqB84c9yIcMXU1eDzg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASSgVjWfYLlkEnNCj4MK6IlXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTU2NzczMC0zYTUzLTQwNTYtYmQwYi00MjRlOGQ2MDBkNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQ8Sbqisy4c9mI+rdJ58LVgGfbDyupLmN0RD0pYPmEUD9R\nW11lEqvDNEwRx/StPbUr4mM7yXOtMpEGX/p5/uqfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj7T1c2SqsDHEsiVMZ/2/zu/q\nr6QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfFpk16EzU3CZRzwPY+3jQqxpUjEy22rOVXsjnolAXJYCIQDHQjzJCglc\npBlLx1QBXFObNDaAohvVUZ7Hjjjgw7uU3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAYOytZrcAbXtZxlY3LKIdcLaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUxMjI4YTItZTQ0NC00OTkwLTllZDEtOWNlYmQwYmE4NzQ2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA0NGVhYTMy\nLTY5YzQtNDNiZi04NjkxLTFlNjExOTUwNmM2MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLU59ux5vFR5rfzljdN9zQM2CIpaXmE9t8mIyehowkdy+0ScphjTZOCt\nOgFQHyprqw2cmQTuSNd06i6YaqhzncOjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMWZLUns\nYi9HVJdoAaw/m0amaZvqMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCbxzRfwr36WJC2U5RPWX7Mr3A9nERhGp6BgBWi2tm+xAIh\nAKBlAaGMQ6yK7NqJ9bm9nG1391BrClAnFspqdk0Ii4Oa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1020", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1020` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZaCJAXcFEQ+bTPUt4J8h0s1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlZWViOTI1LWFkNWMtNGZhNS05NDIwLWMwNTk0YjNkYmIzMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdkN2JlZDYtOGI0\nNi00Nzc3LWJmZDEtZDA5ZjNhODM2YjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwz3a600XXTcaygUeFRCTvxW7kpynQhw3npkgWeCBybbRY/zfg4TxE/FFOo2z\n5pd/0YjceP2JE1YmlM5zz6HKwKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeIWP2EsqdbXQ3l8YLmWD/UpC5lEwHwYDVR0j\nBBgwFoAUfbFdsqrtDL6V+Cd8qGgNo5TGmyswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBUqB6XfQiV+qCJYBquynSz62AKGPjg8v8CxxoZBbtx\nUQIhAJYIIP6k3DJ9GbFsnCNoUzyF/iBKUiIfq398uWWyty80\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVa2/SK4DqknlqhGBy0HN4FSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWVlYjkyNS1hZDVjLTRmYTUtOTQyMC1jMDU5NGIzZGJiMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUIgFnPbJL9RDMcCg3fAxtXBeW+C0dycDnLG+d8qhpRuRJ\ngzrACDr8LVsCxbIoWRQ+Gtoxh9VFmay0k4ef1N+yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfbFdsqrtDL6V+Cd8qGgNo5TG\nmyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPPAntRqz7J+mRvXuY5SNYV9a6ao+Q24dW+/AyfZE+HoAiEAmg/E+pwn\n69zCc6lve0+ETcRQDyAXzXPKKSyupV2jLvY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISARmPHRuxGBpY3dhA0G/KufQlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdkN2JlZDYtOGI0Ni00Nzc3LWJmZDEtZDA5ZjNhODM2YjE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFkN2JmOGE0\nLTIwOWItNGMyNi04NzU4LWUzNzVmOTQ1N2E3NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIVuK3HuKVPJmUhGksMWx5Xwh7J8AYaiTaAPOmQ8djECCW2+9t2AGgDx\nqhbQHM670r32bkSEzZ3xeklVTQC5CyijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHiFj9hL\nKnW10N5fGC5lg/1KQuZRMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIBYLNdNswt+Qp8HYZ4UzGh66/XTq6L0QE3iHnSpXl2/AAiBJ\nA1CE6+pbCTXR73uDn82WIzIN5sLSVNj56gPLVSGOdQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1021", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1021` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAUIAtayJ3RIiQpQQrbiWK004MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzYTlhNGIwLTFhMjEtNGZjMi05ZmM5LThjN2Y1YTNhMGFlYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE5YzU2NmEtODNh\nNy00NTVkLWI0NzgtMTg2Y2JlZDBhOGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkUqZF0/Lnw7TCBrVln4CjRq108eDkuPiyL0RTyEev5EQKi9Iw+2U+SjCUwHm\nuVWSLJCn4VdBO1sAwbFnb1p0yaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd0nTcsfAu5ul0x+kzoP76yemWnUwHwYDVR0j\nBBgwFoAU7Br9PGgJJvb1hpv+HlKuHSE09H8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA66vAzXW/2iZJTGWQvGKWPvg39zlQg/EqXaNWZfzI6vACIQDx\nbluIpEP+MsOafTl+vtFZcB6iZ8HwAffr2RMfPpf1mg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc3tvDvoP6nhrVYozHrGIC7oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2E5YTRiMC0xYTIxLTRmYzItOWZjOS04YzdmNWEzYTBhZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+3K38rwT/8BBKvxx23fLRZN+nPGvzaZ1SxEis3HY4K5sx\nNUlsnMZLuxku3zsizfn1ynRTNcgraLZ7B2ZSeyQ3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Br9PGgJJvb1hpv+HlKuHSE0\n9H8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK/s47lCIi1cHI1Ffj1Hq4CPqvDiDMO5V0lmSNIZ7recCIQCCpYj+JGV+\ne7x1eR66kxW4mux4o7KALjgdjrij+NTawQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISARMyS4C+nRxOIe4zPbTPrdbJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE5YzU2NmEtODNhNy00NTVkLWI0NzgtMTg2Y2JlZDBhOGM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFiZDJjMDdh\nLWQ0ZmItNGE3NC1iMGQ2LTVhMzZlZGUyOTMwNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNIhyhjw8ED0E0sFrt+X/7UCcmkvO8juNytyIUsg16CFnsGMdl9ey6qY\nwco6San+jjtqCoS24iuJN3jHtTliFgWjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHdJ03LH\nwLubpdMfpM6D++snplp1MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDo2/MW9WthyCBNUvnlM5gOjSaxnG1ijfTmu6NtqgPBQQIh\nALnGViSGW7lLdRuldeIan9jv+g8gsMOTTpTv4wlsHdhQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1022", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1022` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAaMn54hfUiErnjrPMiG2/ESaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhZDRkZWQ0LTQ3MmItNGM4MC1hOTQ2LWE4NDhlNmI0OWM3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjlhZDQ2NmMtMzk2\nZS00YzdiLWIwMmMtNGU2YjUzNjMzMDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6HcKZrD9t3SyKGSDA7ImCoPPw5EqTOKwBjauK0ZnPP7ky6NTQIikeZXJuMRs\n+n7jjkIlu0FqWfkgQPF9LtwqfaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGpKtP9cwW81QIl2uzinQ/iTGVxEwHwYDVR0j\nBBgwFoAUXjuglBqcQY8TgeBiylu0WP5fOjQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA9l/++6M2UeqGK85PutGp9n4tBN0qlYpV\nDYoUDV31jrUCICHztRHw9LCu1jrmpKSxPTMu9Kx6yiBE2k47MWz/16rU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV2exWF/F6/F2dwEIiyMCZvjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWQ0ZGVkNC00NzJiLTRjODAtYTk0Ni1hODQ4ZTZiNDljNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT06uQ7TmtFZh0PQccLbI9qmusEsmVmD7UVuLx/8sdgG1Ex\na+jbycdeBRx3To/mv/LQRBCvKz7xRcmKzrqe4IFxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXjuglBqcQY8TgeBiylu0WP5f\nOjQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXovLuSkaR2l9/iILI4/eZ2rINqujwFjAFf/+EQOy1U0CIDs+XUM+iuQ6\nJuKKTVK40Ut9n09w2OAOP1MigMI3dRWb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAR0/24kVfkxdevddeLWfQx9GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjlhZDQ2NmMtMzk2ZS00YzdiLWIwMmMtNGU2YjUzNjMzMDNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQzNDk0YmNi\nLWE5YzctNGVjYi1hYTgyLTg5ODBkYTIxNmNlNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFXGH11EvXJ09IvdWZ4kc6flKvPqimPzsV2vjJqd4JfaGCsgBXvpLOsx\nPKu98PcZGEUa8GbKK0aGkojm/o6e6sSjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBqSrT/X\nMFvNUCJdrs4p0P4kxlcRMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIDwvDZ4a395PHA0uK9c25Tbn8VrXEUJSPu5EDwy/NraBAiBN\nOCcKv7YSBSWkADcdbP5KZ1EQauLlRgvnUBofDIFO1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1023", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1023` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAXWWgBR2PYj6ZFvp5qmg/e/2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkNTU1NjY4LTA4NTAtNDE4Ny05Y2U0LTg3NDBmOTc4N2U0NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY2N2M2Y2YtMWYw\nMS00ZGE0LTgzMDItZWJiODAzNTYwZGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi5vSwEmputv/IpI5DEN3A4B1qjFPCY7WOWl8/R99vaL7p3HD3+z9nJXVpy9z\nS4Opa51yHznXwvyT5VAAETJx/KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf9rnK2De5jkBOQ4KVK+zufzwBSAwHwYDVR0j\nBBgwFoAUzXqCE2PMyMhizWXm+w3esTe5JvUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA1eS+iKtcgHcRYfe3UxentNb4GkAi1qxN\nw6Xu5/ualwkCIQDNkz3t3cKAD28D3Roy7MN1VV35n1H431D8zhReGIelDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbYREKH1sIIE3OUIAk2sv1vpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDU1NTY2OC0wODUwLTQxODctOWNlNC04NzQwZjk3ODdlNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMxNX1rWpc0vojFBiz6fj9TkO61kAHi3GL5niWYlUJrGkr\nQ6njgiJ1PYfSTfhIztvJWBZK/L4Hr0CFKyvHBGgdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzXqCE2PMyMhizWXm+w3esTe5\nJvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIXVvW2KwOFUkf2kfqQo/zW1Mik7WlVwClCi3M23349GAiEAgGbelB8Z\n/cfWYaSpN28zTZJGokZ//9ntelHaa2emMa4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAfZaaTkQ3YBwN9yPar1bMBO4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY2N2M2Y2YtMWYwMS00ZGE0LTgzMDItZWJiODAzNTYwZGU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY4YjRhN2I1\nLWUwYTItNDRmYy1hNGExLWRiMDNiNjVkYjkyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ4XPHkhztjVQTPEajJEX4a5eiht80ErZS45pcejaLId0JbNiz27WeiP\nldnIGGLf2C7/VMYtGie3KXwgHNHTXzOjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH/a5ytg\n3uY5ATkOClSvs7n88AUgMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCgRjD7Z11oVpvfVEklGAhallh9IDLGpEKWFrSwvjnEGAIh\nAO5UasbeZRy3xwzhsKpp1nhTB9fnylowLzTgUxdiqFZA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1024", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1024` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARdYqZoxUakdDVP4dvy0tZ0gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5ZDE2YTNiLTAxYWQtNDM5Yi05ZTUyLWJhYTMwMjY1Y2U1MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFiOGZiN2UtMjk2\nZS00YzczLWEyZTYtMjdiMjI5MGYwZTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKcVoj3Qdy16bW+7z6Xu54k+YpetOHxvpy2Bx/JqbYiQJs43fFbe8q5LqDUa9\nmVN1vqhXkG6McfrsQcwVOCeYM6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFzqb+DF0YcpWtv7S9QTkkhwBzBMwHwYDVR0j\nBBgwFoAUah0c4x2P51LgJ7oVhpNxwiFmSAQwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA/nZP8HaCWeA5\nS+B8Q45qgiOxQTtAPsigNTd204nBUZMCID4A4v/1Nug98zZ0HguAZn5PGBc3HSxq\nUKTl0ot6kZya\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARreRoLpC4mQ0vSgqjSYveEoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWQxNmEzYi0wMWFkLTQzOWItOWU1Mi1iYWEzMDI2NWNlNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpR5GmCtwROkDqxFEjkYCru2fFrBCf7UrxDglLDElhiMEu\nJ/XURgcGECUmOkDBzlT8o/bkZTeRVPAibzR70Lk3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUah0c4x2P51LgJ7oVhpNxwiFm\nSAQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgexE8fpQKur3LG9Q5KQbqwKIUbHcLx99oyHC4IcIvlNMCIQCyZQmrT1Uk\nvqznP+ISMLEYGqnkefbFNAVnKyRtC8pmeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISASxQWLs6ckBv48fXwluXD1W2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFiOGZiN2UtMjk2ZS00YzczLWEyZTYtMjdiMjI5MGYwZTg0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMwYzFlNjFl\nLTg3ZmYtNDIwMi1iZTI0LTJjZmRkYmQyNjc2NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHblgONZMRpufI5I44NEqhw4Q6n7PGFwEVHubgWpiCKI4CB09eDhAv3N\nOMsdBeuglwJ2CnnEaJlKja2QxIBNIHyjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBc6m/gx\ndGHKVrb+0vUE5JIcAcwTMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIDl+uHkg2Nei8aKP0JuArPmpYEzkMNp1nvoAct21gIjYAiAL\ntSLgZcBsgB7fV5LcKTRfolNYgWGhO8V8n/r0maOM6g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1025", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1025` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdK0zJssUZ7INyvFGRakaMxMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxZjYyZGZlLWJiYmYtNDNhOS1hNmRlLTY1NWIwOWE1ZGMzNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTE1ODk1ODQtNDNh\nOS00N2FlLTllNjQtZTkwMDM3ZWE0MWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQFIlfPnpATs+vlDcrcxA/SGb2xt3ptuvN+NTp0K+gWS9J55DH8qOad2rpSgE\nuLVKUstjd255gVfki9JokUNNVaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4yULOy102b1UARUEqxKwbDBepdgwHwYDVR0j\nBBgwFoAUMYfogIMTXutDdTW4mkeZLciFq1QwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDVWvY6/TxPcM+dajtoHvgfDYNWYPZ37x0vmlAWbgkudAIhAOZrur44g5St\nZMWHMKkDgAJHeJpF3ecRADbh+QMEoVck\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWH50twisYQpvJfv3vUwTW67MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMWY2MmRmZS1iYmJmLTQzYTktYTZkZS02NTViMDlhNWRjMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASruP4P/7SzkDLBI5z+07Ff0eg7nZQVkRRuscMiLkv7S2TO\noL4ps7z06z9zwptrKqsuHAvqUdBz+/gSZOI7/FLfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMYfogIMTXutDdTW4mkeZLciF\nq1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIL8uyKQJE+nftbyyhLBeyFFFwJRWNAC9u+GuA0H7zYACIQCWm+673DoN\nH63pk6yvBghwjGZ8XBVnMY3Qx6ZB9z5XSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAdmb7HaNiCTVoaLKFVzQhWHxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTE1ODk1ODQtNDNhOS00N2FlLTllNjQtZTkwMDM3ZWE0MWRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg5OGExZjRm\nLTc0ZjgtNDJkZS05OTIwLTM0YjI5MmNmNmE3NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCQzQwMVMl9Tt9nm2BxkuxuxdyAzJl0D+KisSKb7X3P3ZnKY6tYpQGx1\n8g49BHMbTu2iDoR/PJ1yRPPV/phoIQCjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOMlCzst\ndNm9VAEVBKsSsGwwXqXYMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIEkxvXQ4aHKmUcCYeq1whQ04c5KVSnkOZneMhiIMrXjuAiB2\nuzIfwAGaE1W92BuTKMTYyUKdKRssLJOC6MmKIXlAHg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1026", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1026` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAYTrWIqyOs+9v5BViXA/QsaMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkYTNhNjY2LTNjZTctNDcwMi1iMTc2LTFlY2YwYjM4MzVlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ0MjVhOGItNzQx\nYi00ZDc4LTgzN2ItOGY2OTQ3NDY0OTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESGZkkdXUuxBiXdXcyM0HadyG6BiYTxcw36nbvBFJxvLMVyLUAxd7sQUYZ1nb\nlQjpLWCohV8l0Ih0eTzc7H9WAqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjnuXw5Wg+xcolx/hAdgkRD7PhSIwHwYDVR0j\nBBgwFoAUn0074dCcTbq6ZRYEBf7l+uEKfdIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDf0vticf66HxLNhw+a7umDG+k1aM26zFeOgiZvPHh50AIhALM/bZwOCoxt\n9Os0sctw4nR2CQSJhgsufDydPzOBvKqk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWBKqjTqRV50/YYnpprXntifMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZGEzYTY2Ni0zY2U3LTQ3MDItYjE3Ni0xZWNmMGIzODM1ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgcgB1ZlZJXpAywABAC0MZSfEPWD2JgpTO6ofyF+SsrsU3\niX//ZEko8Flq+ivX/FfEo6keled+Pr0M8IYJj1j0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn0074dCcTbq6ZRYEBf7l+uEK\nfdIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIPd7NqpCgj7d7rgqpQugGyO4vzAvwhYyAshCEXkCxMnAiEArkQuhSIr\ngFZDUpW2GstTvG+DfK425HfAB7yWr0pI16w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQEk8jlOnxeGNGGEh852OC3QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ0MjVhOGItNzQxYi00ZDc4LTgzN2ItOGY2OTQ3NDY0OTg1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRiMzIyM2I3\nLTkyNWUtNGNjMC05OWFjLWQxODU4NDYwMTcxYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI/1niG/Gj5tEiaxPHwtzsPVMmIPYUpdZl+zGnirnVQeq+wWdOfe2YBH\npHF2VAbQgx4gKZIodvZpcStlcW5pQBOjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI57l8OV\noPsXKJcf4QHYJEQ+z4UiMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCGZKkkCYHPp3TygS+89xO7fyR0bO4iTXcKA1aSbdEM/wIg\nSlxDTuAGo8lcTq4KpBsXzhqY13PzKm7RQKf1Y+h6KvI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1027", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1027` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAWkIECBWsa+Bf3XqGVvUcIGUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4NjQ2NjU2LWVmMTUtNGYyNS05NTRhLTk2MWMxZmYxNTRkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZkZjVhOTctNDMx\nNS00OWUwLWI4ZDAtMDkwNjMyNDQ0MmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWgzZpOPXQ7wlei3GGn+e42uvwanP520LuTAb6vvY+CIKZkFMw/1m675xB0D1\nysF7gUcIJ/RHZV/CGhu7NTyX1KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU85nH4s7JItX8bMM48XrY7CN3p6wwHwYDVR0j\nBBgwFoAUI9xKul4q58uXW3hznV3bUNkylBIwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiA0Kv4SDukAgcNN0LZLBcf11U1rO4DcG+sUKG3zcwtQdwIgZ5KSMJ4Xm3+2\nGZMem4zH//88Y6eae6xcBKCefR9pEhM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASvdJHUReHBrlEAHoaRjUHMGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODY0NjY1Ni1lZjE1LTRmMjUtOTU0YS05NjFjMWZmMTU0ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaDLyEgYGj1xsMc+Lbzfj3AJf/btqAsx7xcWp2Gc+De4Nq\ndSZ0mHTYiugG/tTkG6fLV+eEl+rw6+3AC0DEtbw5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI9xKul4q58uXW3hznV3bUNky\nlBIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM2xPNCClqUB8VbTiLrwLAFhYWsRn3TQkin/Gr0PwLiwAiEAvd8cqLsP\neLv/95qKttQIB3DC6F/1+LAFBTnt/8yWjLs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAU1jPv/5YrbXhd4c2pahflT0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZkZjVhOTctNDMxNS00OWUwLWI4ZDAtMDkwNjMyNDQ0MmYzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM0NjA4MWJi\nLWZhY2EtNDczYy04ODFlLWI5YzVjYWU3MmFjMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAeWhFR8zKnyWzMls83RUz+7Nh97eFTYJCPkICgIy0Joqbys5+nvol4I\nklcEpzWlSKQPV9zqU1WwL+nydZNY6gujcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPOZx+LO\nySLV/GzDOPF62Owjd6esMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQC+sy3cMcYCTraG0OQkOuC+VMi3j6aHMULTqGaZS7T3hQIh\nAOaAKMhfHI5ozv8O6zF3QjugYwmOV3pPDp+4TXNI1Uxl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1028", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1028` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISATv3p6wAOk9CiAXWA8IA51INMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzNWViNGZhLTE3MzUtNGVhMC1hMDU4LWUzN2Y3NmRmZmRjMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ3YTFjOTMtY2Mz\nNy00ZmE0LWFjOGMtZmU4ZDkzN2FjZmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzHEHOdyfxRRYzzcxtWyaegm2TBBo09gd1vTVyMxHUGbxn4aJiDTJoNMUuvzn\naNeDcwLRLrq/q38TjFZ+bgx83aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBZjgaVdxeJI8Y3vSOUy3IZxm/JMwHwYDVR0j\nBBgwFoAUogpIcBGPKhf4XFZ6XGQlGSS2Q5kwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAuGoLWv1KQ8pqy712PBW8tKqbefMwuw0/rBTr2XHO\n0aICIQCoHKRbPrQE5RDCHRsWAwCSw57RUKVhOP6ddm2FivXWUw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeP0/Wc2axElRAdkrMiH1tgyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzVlYjRmYS0xNzM1LTRlYTAtYTA1OC1lMzdmNzZkZmZkYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkKtJRmqIIY5ryYt49KzbWDn1N4CY4EvYW5Db8DTpPeoQk\n9M52EjsSyh7A6O/YzTPU1Y91QQYkaGnGAbortzcpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUogpIcBGPKhf4XFZ6XGQlGSS2\nQ5kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPSqPYDz9ICHjNnGqfqfsPNeeE2svwmbxufrI0AKe8TACIQC1wzvSaabz\nPzrcwLa1auMCPdC96a7dqLJCzL1qD8K6Rw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAeakNh9LegNlpx7UE+Y8GNimMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ3YTFjOTMtY2MzNy00ZmE0LWFjOGMtZmU4ZDkzN2FjZmRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk1OWZjYWU0\nLTJmMWMtNDYyNC05MmZlLTg5ODU4ZWRlZWVkOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPQQJ3q146S80ZkCI1tBlPyNv2spMn3N0dtZVPQKALnUobIJWKBwTqaN\nJT4hHSNGJVq1Myt8zcVrT8Z/XcJYsGSjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAWY4GlX\ncXiSPGN70jlMtyGcZvyTMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIB9PwJxpVBk5IcY3tkwFB82QJ2LNvO6r3wJl7fcq3rX0AiAe\nR95m7zF+A91EE0hrFgx/MEY3FwVyrpuexlD1vWaZoA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1029", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1029` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXU+A+4j3vw+akClkonml7wdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiOTIzYzMwLTI1NjEtNDdkMC1iMzFiLWRiMmU5Yjg4ZDM2NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQzMjdmZGMtNzA1\nOC00MGQxLTg1ODEtNjhlZTNlMWUwYjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq9bXWychGxGsZf9OyDQQGZYI45zBlI2zWEIUHxD0VbsOcu9FBa2v880H8407\nbWWmgYiwtMkL287lowR7GVXvPaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvD3HTtnKEm0tDDloX3QIM3fFPZ8wHwYDVR0j\nBBgwFoAUUdZuJ7sR+2oUH1BPPSfN6quFsw0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAyFoDDf8AMbVkISv1XR15oTQnNJFS2G48epGVMZHN\nPBYCIAa+6Zb/9xEC8zvd46TwLB1/aePUNL6aLTtHSyaaJaSt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWZ56U0oX3p3EEXz4wI+l8KRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjkyM2MzMC0yNTYxLTQ3ZDAtYjMxYi1kYjJlOWI4OGQzNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASosJatNVrMv2W99J8vxpP3Sxv1ry9DBTTlckw+OYWtRcyt\n3Vu4/y9o5yjGMiVWvvYj5IXxvRF2NoPwS/PLj/eZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUdZuJ7sR+2oUH1BPPSfN6quF\nsw0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKtpGesqP0ZQ6AeCP4AkXnMx6HL4UBsnlQ9BwmeunlrDAiEA8jquOEbd\n4IxXMhfJU32cZ4Z3mBGIxllUubderT6DOFo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAbcme+CizyfXR4up8XeVFB6YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQzMjdmZGMtNzA1OC00MGQxLTg1ODEtNjhlZTNlMWUwYjY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQzZTBhMDU2\nLTBlZmQtNGVkNi04NTlmLTVlZTRhNTUwMDI0ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEWtJ8NlI+0pDnHYeuTlJk1nNnIO4kz51XvwiDNRwkfK1LN6a/B4gklx\nrA+kurol19PMXg1TrUAAcGNySBMVV4OjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLw9x07Z\nyhJtLQw5aF90CDN3xT2fMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDIWq+wO3muTl0GAibzos7jI2sPUXrwVKdGyE44O2mMsAIh\nAN7gmQenBkxERC4aV9l0hiiX31528Hi94uq9Oswqmf1D\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1030", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1030` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYugyd9Ob/CGg6UjN/B1sEgRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmYmU3NjJlLWQ2YWUtNDE2NC05MTMxLWNkZjQzMjI2NjQ1NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc1NjBiOGEtNmFj\nNi00NGU0LWI1MzUtNjU1NjJmMjU0NTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuhQLqLd3lFAaGcmC2dNwxDxISH1iOgfBp+rR6HX7hWcznPDCUL+t0Dr1hDjk\nCRzH0SzoL4k5Ci71jUlP2YXrc6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU58Pf2XxEu6xBGSMLydQNw5G3m0IwHwYDVR0j\nBBgwFoAUbGxtyo+Qd4F8shFpIgelxwZ0kb4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAWg30HS/W1hMjk71ud8tv1zNGciDuINwhUDqhfWGM08AIhANU6\n/ZWmW/vC5S2+gT8zjspIGQ9AJxg980WBeVkjw7md\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATIFWeUrCFeed5uU2lJkwZj5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmJlNzYyZS1kNmFlLTQxNjQtOTEzMS1jZGY0MzIyNjY0NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvvf1dbK395Q3/qurCe4j9uK2OnhXogcTwUt+hoVj5J9H0\n7I98eedWKrDakGzAamE7AFo9zaph0pkrtIOLvrDto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbGxtyo+Qd4F8shFpIgelxwZ0\nkb4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPmpLsiyedoX9BfEQWf8sZIgXjXbgpoMtzQJwx7mY9JTAiA73eCOGuFm\n6Pri8fTUb49/wU0EIfDSJSBNo1gHLKIB6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAdzpjTvtevsRhB10IweHCVrWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc1NjBiOGEtNmFjNi00NGU0LWI1MzUtNjU1NjJmMjU0NTM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI3OWUwODIy\nLTY1MWItNGZlMC1hYmUzLTE0ZDAxNWNhZWQ3YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGkeCpMDRCTXwtvqk9DJbGeyriWIce5cjRFngy3EoNZSm8gaMiChYUof\n2CiFjeISxuuW59xNcZZQZm+2chnP/POjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOfD39l8\nRLusQRkjC8nUDcORt5tCMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIAIgItkCwHDH1hGovyCsxnmDEtFqnhvfRE7HRYmcMyZPAiAI\nwIjboDxK1hCzoQb3x7bQmaWT+fs5ZfCER7sI+l1XSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1031", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1031` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAebJ8od5oVvNE/pDDNNd+M8FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5NjA4ZTZiLTFkYzAtNDI1OC1iYzVmLTlmNDAwYWYzNWUwMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMzZGUxNDMtZDgw\nYi00NzMwLThlYWMtZGQ3NjRkNjQ2YTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Op3Tt7ZmPF36R2axbsFSEbME6bvwl9WJfboQYn7fqyPJskWSOlhCzYwhI6Y\nV3sDtrBRXQwPSMPAY6FvYLdmraOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUavpFxNbUT4stf+z+ownSWjOaOJMwHwYDVR0j\nBBgwFoAU2cLvop2a6cM5kbdgumVKFIu63GgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAgObt+t3HSjvZARQgFpjBy5AnJ8s8AO6j\nM0sQ/hu42v4CIQCWWKfpvEiI3WdILCt+useM/eYR0V9KTOMdJnXS9Eq5rg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfh4arOPwfsBDtFcGxATh/4yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTYwOGU2Yi0xZGMwLTQyNTgtYmM1Zi05ZjQwMGFmMzVlMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARC3khqK/DvwyBeKwvMBtdJ/ovkdCDZyrrzC84Nnel8Vd6d\n+quD6oJBfUKQAFcdK9BlHoMpD6SISyvqpnPBAPaPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2cLvop2a6cM5kbdgumVKFIu6\n3GgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgapMkcfcVDkFK46n91YVjuTSddyWFiaTHwakUYt2DkL8CIBT4MS440mRx\ni8lckDn1ZklCczwJ942Lem+WjD5U9UO4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISATblPA7+HPx7+vTi646z93IFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMzZGUxNDMtZDgwYi00NzMwLThlYWMtZGQ3NjRkNjQ2YTc3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM2ZDAzMjEx\nLThjMTktNGIzMi05NDAzLTdhOTY1YWIzM2ZlYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLv28gskWdFqiZ6alwMr/+pbwhCF0v2GAnuhEEz33Md7mKT/cQ808vUH\nL5bqdGmWkDnbSBQm63k3+xB8MjF5r5yjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGr6RcTW\n1E+LLX/s/qMJ0lozmjiTMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIHlIz1FtqE1UcUJ5UgDwpulzXuX8r9oF2DJnkceADzTyAiBl\n8I08bbwuYAlN2mp1yxcNT8qAzf03pSAUYx17pTriag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1032", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1032` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAdWRC9n7j1WF0ORO9lfRR1i8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2ODJjNWNmLTVlOTktNGUzYy1iOTM1LWU0ZWU3NmM0ZTMyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkzNjE4YmUtMTVk\nOC00ZTVhLTgzNzctMThlNDM1MTA0YjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENuSuQIFeRKvJVR/2DG6sdSBpbAZybDmyw25qTOpttODhq8q1P7oHNSLmWAwW\n/BZOPMiTy0XRJfGAkRWLysvTYKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdt7zxmaqNk+YfJjjLSF50clcQeIwHwYDVR0j\nBBgwFoAUAYe01jaM85nPcSV+0i9ej+GleCMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAj1lN7W5KIBgR07UQRc/04LogOPEaDuNIy\ngI/gRteeAQIgR3S7HuAQjfKt6id1RZiXT7pcmkTO8A7vRj4Wbt7i1vg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZhdl/8JZbK/h2LPnB8ZSCdjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjgyYzVjZi01ZTk5LTRlM2MtYjkzNS1lNGVlNzZjNGUzMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFACmG9iv8kZEgXmLo+nsB+Rc8n8DOCwWvukcBZNE9SXtb\n3TjPGP5/gx2bmoDJ0Yts3U9V+hQXgWUmKcHCqvPqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAYe01jaM85nPcSV+0i9ej+Gl\neCMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPa7niyJWSKLBS7k81rOIRAquwyORC36sbvYajl7QH8TAiAEyu/69BFn\nI3t1BmiiOEzzgIPq7WiI3zCXjv2S0PoKyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZoylSSzwJT/AQeu0tC2B8gbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkzNjE4YmUtMTVkOC00ZTVhLTgzNzctMThlNDM1MTA0YjExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA2YWFhYTZm\nLTZjOTktNDMyZS1hYWQyLThmMGJlNTc5YzRkMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLy9ImA8egp+KrptKZEzrCCu4sfyTzzbowNgmrUO+Qum+oGttM2fz9QN\ntru4J+/Mc8a+4/GRwpzb2mto+Mfky0SjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHbe88Zm\nqjZPmHyY4y0hedHJXEHiMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCID8a+Nc4vLfolXclrFYM9cycCInVbEyXMmSuhJxEIQg4AiEA\nvh0Y67uGIC93vvyUOuJ/krgIkwLlOVlA36xmaxMDBZk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1033", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1033` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAZsGy4gGWXRtxkzHBpEDAq81MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5M2E4NTYzLTQ4ZTMtNDQ0MC1hNTQyLTM5NGI4ZjhhNzhjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI3ODMwNTgtY2M2\nYi00ZDhlLWI4N2QtOGVmODU1OTdkMGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ118xZ6tNdZ721Hv5LQV+WT0Q+C3ra8sTbxoOuzBCy4dESFxkhBgCNKK3gcu\nKljSkQ9IbuVMiL4y02LaFmAekaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8iQNvuQvU/69Rd+BqPXz8jnd+PkwHwYDVR0j\nBBgwFoAUbzYp2SVjCDlzb1Wpyof88Uc0FZUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGcLDeoCZf/QSaYEXDBNoZg+lfGw\nhs8dfYIwlskhDJbzAiEAhf1cJusHuJM31rtlE4xzOBu5+QolWjtIf8Hi7M9As4o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARSHfmBi6G5yONevm7aKZoQxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTNhODU2My00OGUzLTQ0NDAtYTU0Mi0zOTRiOGY4YTc4YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASS0RJqPP0/WpOCBD57IcaMrqj6WTrnu+e2vDjxcqwTXB2p\nr3Y1Rp8JBGtZqp01sV1+2w+F/SgIlydvlvgXQmpao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbzYp2SVjCDlzb1Wpyof88Uc0\nFZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWDdEsBCLP1cv9/tH1W4FEKQlRo7tS1HzgE6Ks+bEJsECIA5INUykGCRn\n7cjxYDHXnlQuoQrS0MpDdkNKGnHuTxDj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfJoHEGQovfBGqjiRUO3huwkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI3ODMwNTgtY2M2Yi00ZDhlLWI4N2QtOGVmODU1OTdkMGE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUzYzkxYTJl\nLTg0YWItNDY1Yy04MDYwLTc3MWQ0ZmFiNGFlNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBQTkpgEz5IiJOXL/W+fPCsXcwqiQY+iqifHBMOS4uvDM6J01Hcvsr7Y\nGSQ9QZTehL16C0iFd4oi6hBAbaclCgqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPIkDb7k\nL1P+vUXfgaj18/I53fj5MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIB69RJKoFb3c71cP2tMVN2/Gia0W7t52nnyBSv/ll8epAiEA\nn1HwyaBau4iP08MMD8NuWBkjHHBkB7accVh6kKHDqD0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1034", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1034` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAd0XN57xrCmWo4hd93iZBctbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4Y2Y1OTIwLWZjMDktNGVmOC1hMmNkLWJmZTczNjA3NWNhYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODY2YmMyNjEtNGM3\nMS00ZDNmLWEyOTEtN2YxYmVkM2RlYjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj0mjAkCyDULHCfMdK1Gye6LuxRKFnMGiqVKnwqieAfUycaR9Lrh2qTk+BX7H\nTcSdIsnECo0yypqGPjfQlweuxqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFjF0Cw+H6VAmU2rderWyiv9LteswHwYDVR0j\nBBgwFoAUIo/hBIfbtr2LZ3BhWeWjiFXnX5QwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgRPD1E9V7\nSAjGdDgkA+q5PV5XHUzXqTDzttTMKctO0t4CIHpS7nfifuWa6qGFLF/U+KdXENoG\nuDg8DX7Y63osEyWy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY4DwbdzDu93H1bSsbQ/iMuiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGNmNTkyMC1mYzA5LTRlZjgtYTJjZC1iZmU3MzYwNzVjYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSyk+tv4mUUlFXt7rkx4tyqrt/iqzi2LgOWWvps45G5qSg\n7eXcABHLtJPSMAPH3GkuJ6VF3wi5acwJjJCB6OINo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIo/hBIfbtr2LZ3BhWeWjiFXn\nX5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga4PWyb/ZOMkC5/1AMro9qFz8rcT9flu9ADwS9uKK3NACIAr8aipKg2Z2\n1KP8EnYlVJjb498BGSqAnQVzXrCNTlrQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVUXUaEl97q0RhnrA3vGBSzxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODY2YmMyNjEtNGM3MS00ZDNmLWEyOTEtN2YxYmVkM2RlYjdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRiYzE0NzQ4\nLWZmOTUtNDc3Yy1iMGM0LWUwOTZiMjAxYTViOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNDH/FE7MOPnSEYbBNosflpFINn3BzBv9oKMc3nWd+GegCTvU88P9Rym\nNWRoqlda5MMf+5wM7GISSMOpGVqd7KOjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBYxdAsP\nh+lQJlNq3Xq1sor/S7XrMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIFlKWzy8iP1l0iCMKbp8GZrYTDOsDufUFtp6mM4EFbljAiEA\nn5T9FaQAhx5g5LFlf8YTlG6VuIjO3rY8v2+Juiocbs8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1035", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1035` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAffNWSKJD5BsswHomYYsrnoHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkY2JkODQzLTU1ODgtNDVkMi04ZjZmLWY2NzJhMGNmMmU5ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBhN2ZlMWEtYWNi\nNy00ZTg2LWFiODItNmQyYjE0ZTc1NzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECvgSX2+jLQ6kCUaXjmG/QposSAk+gMfqIvkVZpXLvt6yYnBbFJq9Q0jsNfzx\nUkWJvn/N7Pds2xPtWz7/SqCIdaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfvUhzg0P8yuYwwSQg7SUBnyyQHwwHwYDVR0j\nBBgwFoAUwMgypUogQWTp/nsU+XF31m/dQagwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgSxRhe6bm\nZ8nZrNqEhkHIywDgoqj1sm6DHhJyXhie7n0CICoI6fdUq5etvxzlqUQmmhQA0rjN\nmXOX75onvGc1gZ31\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfAiksD8JSiL2iQCJAEBTin2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGNiZDg0My01NTg4LTQ1ZDItOGY2Zi1mNjcyYTBjZjJlOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSfEdj1SbJSxe9sZxHiHzxTAjt3Ly6edhCTffTVrs4SiVz\nxk8JfnAad7MTYBx4cTvrqo3c51nAU/5Pw8SmfpaXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwMgypUogQWTp/nsU+XF31m/d\nQagwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVASzKN/fUNkL5PdO50uZhJ4uDPOSsY1L7MC7SlfAtk8CIHdH72ItujF4\n34itvLAI4oRDn+JJOIT+gWfdGEvAkNL5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQyD5Xigx9/UmRwGCQlBG5xyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBhN2ZlMWEtYWNiNy00ZTg2LWFiODItNmQyYjE0ZTc1NzU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJkMmIwOGVi\nLWI0YzQtNGY1NS1hMGJhLWNjMTBhMDgwYzVhYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAAdF3N2YavwTGfUFGjZnlKO9mkpaQ34Yh934HIZAdB0SHm49yAKZ6XG\noNzILu74iFgCl2CJtcTfGPxc0mqxCfajcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH71Ic4N\nD/MrmMMEkIO0lAZ8skB8MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCQQU339alYQ6sU2OSvmjRPQ2T6+4jyDowBzkp7yjo1iQIg\nQChXquzPQxQARw7DmHkcXtH3jrRbeCW8q65UMCUsY+w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1036", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1036` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAbozFmV5LJF+NwQb9EnRhsDrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkY2QwNjEyLTMzNTYtNDQwZC1hNWFhLTg2OTU3MmNkNjBhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmIxNzkyMzItMTg2\nMC00MWEzLWE5ODItMTBiNzllZDFiYTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE86CCpao8Oe2Mhv3+1t352h7vjY4gSubXVUh/sWXaSpS8caQo6tXUachVF1IH\npmbF5TXd/i2EFxU8D8GWY/3AHaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV1hYbm8AKQ833OXPJJi4jvE6VDswHwYDVR0j\nBBgwFoAUMix3JB3rr+voQsHFOS7Ag6q12zcwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFvQEML5\nuapfF27VUhMSLFYwo1oFjdETOAtDu9DpUbELAiEAitw4ESap4qtQX8iFVIKH3254\nceQSI/uI//FQeymLjJc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaLTc0cc7RyI803mgBpRzj/cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGNkMDYxMi0zMzU2LTQ0MGQtYTVhYS04Njk1NzJjZDYwYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXuKBlKFgy2G9UYcArpJ5eI6tU/mmrCyWXK0eR/9Z7+RCm\n9N+3bbZN34YOFK61s3vToGBsUgSzNhj6Vc+ACPXUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMix3JB3rr+voQsHFOS7Ag6q1\n2zcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKyat5Av3AVBZ8ox8gtJplUEFj6vMUz0FE4fRrn0zclkCIFcIIW1/aeTQ\neEj11IH/c0ue+/342Sn1kDuhyseyBJEJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAc3oUDSdhEfzpJykgYZD2DjKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmIxNzkyMzItMTg2MC00MWEzLWE5ODItMTBiNzllZDFiYTZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkzZWIwMWVh\nLTBhOTUtNDg4NS1hZjcyLWRhOWRiYzlmOWFlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHTUGCTdl5Sk5RYfouCsy7KDPGBx2pT2a4VDU46xhPoqPRFDF2xNXohT\nirET+6JplmKmQhsHGW2qCBdd1veIfh2jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFdYWG5v\nACkPN9zlzySYuI7xOlQ7MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCICKpXyZeVtpGNjlPgAkbrS4zN3sDFzt0EmSQdtutLIB8AiAe\n8D20z8D13rnRc0JJ1qRzbHA5AiUX/FFChOxY3ZUU9g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1037", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1037` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdS/2RMTkcFkSirZSHAWtbObMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NzEwNzY2LTIxYjQtNDFkYy1iNDNlLTA2MzFlMjA0YjZiMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQzNTFiNTUtYzdj\nOC00NzU1LWFmZDYtMGYwMDYxN2QzMmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWqW5PVE8J2zjZRDWb5DBYI016D6bR3I/2VDabUrSYubX1oU2ey8628B3fBHC\nJHO/cROcCmmTOa25LsVKd8+bWaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBFbE+cw+lraPz7Xn8tsfs1CsN/4wHwYDVR0j\nBBgwFoAUHve5bMxr+7DPzd+m0UjPBPLjHbcwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCMSF66PcFeThi0g1B/hHlwST/3/X/udXBCFCp+hanz3QIgaoWrq5wa\nHRI4ODgyb/M8MEmX2HJ5W6Tm3RxvRXJMbIA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASMoZjNqlgwSPW0Wi2Yu6VRbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDcxMDc2Ni0yMWI0LTQxZGMtYjQzZS0wNjMxZTIwNGI2YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMFAfJIGFrzXhoYxvbANdU3LkZXzs4awRMIJ8W9AjsyN0s\n2h596OjAcngYrV+QWyW00lk35+NVvi3C+gfrTDD9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHve5bMxr+7DPzd+m0UjPBPLj\nHbcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXn/gcr97vpAp9pAorY6qQninxT8MhWWPI6A4JHlkiZECIHG0uB0J/003\ncBokVij9bkESzVN/ZgbuL+R5B+lPRBSe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAWfY9nBICXSIn4iwQ3C/DYhnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQzNTFiNTUtYzdjOC00NzU1LWFmZDYtMGYwMDYxN2QzMmM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdkY2EwNmM2\nLWMyMDAtNGJhMy1hNjY5LWUwNTQ1ZjJjZWM0ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ7QliY21SvNUrGu5LMpIybevxbCgZ0oE7V550UfT8gENDOAgyNoZ2nr\nr1VPEYiO5a2EPoBzL2rYJJhMnErxAcujcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFARWxPnM\nPpa2j8+15/LbH7NQrDf+MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIHD8nyr5AEedExzEZzDcMTGznb/d7zc43z5Kh22/L+adAiBk\nUhYmS8ZSA2aptQRN04595l4D6w6J2SaZp97/51WD2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1038", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1038` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAcZhh2tjBGaIGssyfW/zzLuTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5OGE5ODg1LWMzZTAtNGE0MC05MGRmLWEzM2ZiMWZiZWUxMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZjYTVmZjItZTk0\nZS00OGM5LTkyZGMtNDUxN2FjYjVlYzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbxrE48fThdzmjLany8wFgYCJ5aXUML1Q1kvCs0LS7YYRN6Jrh7agHlJe7TYo\nI0QoCJRObWev3yhiM3wqiRJA36OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOIYIP6BW41wKknsCfzYqiIEiMDswHwYDVR0j\nBBgwFoAULoVqZsQa7TC579UVRAFJZ/Fa44IwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIAs4rA5JgvlM045ZN/cCeWXI1tAkuFwjwM/Oi1Q8o7sdAiEAthQrYXAh\nXYxFCURucJS5WCCsmNolXfMbW0suT7TCu6c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATTq9MjwQ69V8gu0a2SN1lBvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOThhOTg4NS1jM2UwLTRhNDAtOTBkZi1hMzNmYjFmYmVlMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSCUHK0xly9xPTK4WfBkMv9vsevcPZHEJHCTpNBdbjiwiu\nakSvRp1Z2vrtoip1jqSQoeeoQr8emh4qSTumPkzho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULoVqZsQa7TC579UVRAFJZ/Fa\n44IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc+woiQVfJYO+RgxxMLoSEMwFUR7xp/vN1EX43iiRWcoCIQDBp++wkymJ\nRgkzqLd+FFOlPev1XcIXasJlABUnwTt4pw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfDbVd8sVaMiaPybL/TCo6rcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZjYTVmZjItZTk0ZS00OGM5LTkyZGMtNDUxN2FjYjVlYzIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg4Y2NmZTFl\nLWE3NGEtNDk4MC04OTJiLWEzMDk0ZDZjZGQ0MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB6CqTfI+79wq8MYkEQk0CHK+nFQVXUTaoZfFHHkJmILogMaaSnv+Jpq\n6EHi3uUhH7zAz2IROKmRGSoqW6X0h7GjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDiGCD+g\nVuNcCpJ7An82KoiBIjA7MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIB9l9Pm7UFapZ/Ip/NE9jGaS8KKA54LvOzIQiHmtgR8HAiEA\nv/f6AleeIftCQI2b4uXJtHB9mWjU6iTMwfZ2iNgiQ1Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1039", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1039` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAeoLZfPfPCQMAuhjuq1du935MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4NzcyYTc4LWFjNGItNDg4My05NDYwLWU0MzIyZjVlZWE4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ5ZWEyMTctZDNk\nNC00YzJjLWI5ODktMGI4ZmIyODg0MDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0K3bBnOfAMwKsrGwpIKdev5+9mHn94uRH+x0pifzSWBY6+463ZJV5L2RhE/g\n+Wqu1yCSZMdKhaltbxbbZm+Ej6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURbqX8iOgcEEaZjt3SXA8dGqvfIwwHwYDVR0j\nBBgwFoAU1NmX3oIPN4YH1H79JI6YlEOwenUwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIGoLPoHTMDQkP8as3mYyINIVVj1aRE6lu4bKSrumDb/MAiBrpQyKlLz5fRPSpPgO\nFm3/LrmuUb5pw0OoJVEYjrBy4w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAce7zT6fFGBanjYv4ZQ7VqJGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODc3MmE3OC1hYzRiLTQ4ODMtOTQ2MC1lNDMyMmY1ZWVhODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwViNGfcdyiE1ukkIOyGg5uzH9PvoBZY6xC+yQsMJxioGI\nxtldw5AQ3gEmyjBf6mkwytj4XwLQd647OVWAnJ/Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1NmX3oIPN4YH1H79JI6YlEOw\nenUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOqjnQMuXD9ZZdXAZ7a8dufwCHRnDHZ5t6t3zs6gijeECIQD3dsMKu5cG\nZIbX9GGvvFotTM3IKiPOw/+kyzEBw0gW+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAQbsWESXjcwj/nwlr+V0GBA7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ5ZWEyMTctZDNkNC00YzJjLWI5ODktMGI4ZmIyODg0MDY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhZGZlNzc3\nLWYxMzUtNDBmOS05YTJkLTg0NTNkYmZjOWYwOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABExzw/zE16HuVjstGtgknGxmgmm3H+R5GLaKhTDztcl2n/WY0+FA+CrT\n9+4UfBwDFZ1jQF1xLB4X4M7u8il6YfijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEW6l/Ij\noHBBGmY7d0lwPHRqr3yMMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIEQYg2s/ufXQeshas6MRDb8qVSq4Tfouz/PzP8AxvytCAiBS\n/EIHdPAcFbzWbn+qzF3MsBoscZocnVcWlirw4H0y3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1040", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1040` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISASwF6UQujNKJjpGHqckYBf3JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1YmQ0MTM4LWYxMDEtNDRiNC1iNGMyLTdlOWE1YjZhYmUxNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWMwZTc3NzEtNDY2\nZS00NDM1LTllNTQtNjg1MjcxNWExNmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsuLtLUh6J4de9KT1OaxjEGPeUcEMbi+gVlvayibPVBm3HPghr1Rm+o430zX7\npE5KqE7bIC0Y+C4kC379+8aDk6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI2CLtbfo5EfB6apuu4UZG7s8q/kwHwYDVR0j\nBBgwFoAUJr6NfBC3bD3p8peoFBdigvMkIyIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQD4RZUfdC6E99GRsJ8IFqnBhovc4FN5cHkgwPGjTmW8dgIg\nNxMdJwowRbyqpacBCSxcc0wzGTxDrrxMGj03FrVst3w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATRJh9oGd6iYXfhGBNnAbxfZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWJkNDEzOC1mMTAxLTQ0YjQtYjRjMi03ZTlhNWI2YWJlMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASA3kE5v27XtYN5MYr0DohxlxRr7GtzomzvSGS3jvcxXq7Y\nkGn3XjHRxCTYkaGavmxe9Bviu1R5Lt/YdVfcC2wXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJr6NfBC3bD3p8peoFBdigvMk\nIyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBfyjpQxdBgv4DgVDQlYgwyHYwA1k9jmWa9Qu8A3yZzwCIBVCaHbBfD9K\n/XXKIL+ihBAlRn63kVUal6VjqsqKZtNj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAUdouQ+X3lemLbkIYfqccCXyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWMwZTc3NzEtNDY2ZS00NDM1LTllNTQtNjg1MjcxNWExNmZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdlOTNkNmFi\nLTZlMjYtNDI1ZC1hNjk3LWJlZWQzYzFhNTI0ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDJAXcTpJjBt9YeCNcpNmiRjwqiIqtYYxcdaoQiO4w2bvfoTvSqqO2pR\nOOd8TF+QHH5ONZhCAkKyh+kxPVPfUGSjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCNgi7W3\n6ORHwemqbruFGRu7PKv5MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQD4lpSg6dQNSIboDtYVXoAa/zd1Uveeop8VMvfmFL97lQIh\nAJFZlZfRdZf5Gu6QbZ0HHGAnn8XQSGAEyju5ROuvUWDO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1041", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1041` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAe9pRb6KxAgPbOS4cpa1JRIAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMTU5YWQ2LTJkNzctNDg1Zi1hMWU0LTQwMzcyYjNjZDc2NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc1ZDYyNDQtMDVi\nNC00M2U5LWE3NDgtMGFiNmI3YjU5NWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENpKOppC9RmX77lxBsHDN8iBd/pIbST7oyhmqIq8vMkSNwxIZV+LcZPFrVeBu\n5hxGLZcJtIfUTNIsN1rYrNty5KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9r4bVJrB/IoAohgjxdj8OCLO8OowHwYDVR0j\nBBgwFoAUzb1TBlFDsTHha+zY8856yVya+fMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQD3CwEHSiCm5pnNe/uswpXdedRk5RNLtnwLnzKulNTcOgIg\nXTZLT5HMBFIksTdzvS8hsw9mOmMr0C30eVmGZWDYOkg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVtpUrw8c93/aoFcyJqA7W/MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjE1OWFkNi0yZDc3LTQ4NWYtYTFlNC00MDM3MmIzY2Q3NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZSCtJZGniOVYwsDVhPYgtdevloQw1Ef+dOcplE/jtk/qj\nktbTxV/gJHfOSkCO49pUCNnN6QDTRwkB9020MXlno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzb1TBlFDsTHha+zY8856yVya\n+fMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJajiQFhcbS/nKMlaChQ3j8DEoKfckbOazvEQqSpTvB7AiEAt8ik6M1W\nWfP0zBJBsmWxo40kjUi/Vi/L2P2tTJtnD64=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAbpkBTRdDAU67S+T6bkl3CAtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc1ZDYyNDQtMDViNC00M2U5LWE3NDgtMGFiNmI3YjU5NWY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ0MjNmYTBi\nLWY5MmUtNGNiYy1iMGIxLWEzMDQyOGNmYWUzNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCtpgs2lmmOpfcgXxfg73ckUiT8v9ajI8JX6T6BWhgZyXSDx+0hoW3QJ\n/4Zd9nkbwQHkwohhNykJY/hiyUAuGo6jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPa+G1Sa\nwfyKAKIYI8XY/DgizvDqMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDNjGmxJJwaTkdaKaDiE7nkqAgInP/BD2UbdphsXZ8yuAIh\nAOznbEr3HFtEks75XpqO0kG2Ym028tEE/YQbuc0HQ3hq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1042", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1042` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVuilVpAlr7OHnNggRNuec7jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmNTBlMGI0LWNhYTQtNDJhMi05MzkyLThjZTM2MWQ5ODM5YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY1ZWI5ZGItYmQy\nYS00ZDhlLTllZmYtNTVhMDAzMjAzMTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnwdXnYXzPJWHuWG2tiBikNByN5pNxhXfYciAMUV5GfL/kG8h/bhmNeN42tyR\nULqTCJu8EIo6rYOBNctwMEEXvqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWt5mX4Eh1Wgv2HCFh3AoDZKRRqkwHwYDVR0j\nBBgwFoAUXuDnoykXOdY4bJGg6xDOgqMvBJgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEVrgE1PAcDQ\n3wkfGduRB4r1dKuR5E7XID/HyyGua3Q6AiEAnmuUA1n3PeKYCr9GBsntmkA1Tdc+\nAAAApMKp+NoZNRU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeBNY0OtIDkarCc3GU/OJsrUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjUwZTBiNC1jYWE0LTQyYTItOTM5Mi04Y2UzNjFkOTgzOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATq58K+IpU57wM+VpT410RyNnylbiD8+AdiUm/jUC4FIQ+w\nNcP99hdnYzi0v8JyyeFz+pIBfyYyRDBsiuOvkt0Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXuDnoykXOdY4bJGg6xDOgqMv\nBJgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVJii4lUstw8VTdaQxc9QZMJ1vgkhSUeYRd6CIzKiPZQCIQDEWMdVSWQm\nPsUiGtjH9jy/ajFTldpHcckE/Jh9iLCzag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAT1uH5yK4gIGuM6RKQXhB6gVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY1ZWI5ZGItYmQyYS00ZDhlLTllZmYtNTVhMDAzMjAzMTA3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEwNGQ3YWE0\nLWY0NGUtNDI5NS04MTc5LTk2OWJhNzgwNzY5MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABONIaqMXSHhHP9Ndtfkd/ezf7yPBNHJgTj6V/e476Mr4XhtB7Mnmyc5E\nUJAWS8UKxLFUUL30A8vyNFAHqrVuiESjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFreZl+B\nIdVoL9hwhYdwKA2SkUapMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCMbYMeKdgXPx6X1YX73uupFr5NiKSa2qNs8WhRiPkkCQIg\nCyDIGFe/OQMkS9I0xl6Dotdeh0ETcuclrlcXKxukqHk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1043", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1043` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAaf5pzN/Ayqgmmu8eA7CuL52MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNTE2ZTA4LThlNWYtNDY2OC1iMGRlLWI5NjUzM2I1ZTZmMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk3OTBiNTctNzIw\nNS00YmFjLTk5MzctNDE5OTFhYTViN2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEABDDXsTUM7TOAEp+0rQR2Ayk93HM2EajTUThBwHwr66yKJszgB+yvsCwe5t/\nedpL6YJ796l9U2WTfs78y6TPx6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcIgxpuAkjolD14vtVCx0x6QEG+swHwYDVR0j\nBBgwFoAUuPOcdztU0Bp+Xut2JmMJTT9UhkYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAIcdVFSGTBlfNcCIJ8KfWvfw+hNX/+omw6F3f4EdnuoqAiBIgjKWfzlt\n6xlT/HsGlV6P8I2PWZMysfU0VtdktC7T0Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW2mOdLnSCgq4kEm/menbvhVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzUxNmUwOC04ZTVmLTQ2NjgtYjBkZS1iOTY1MzNiNWU2ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRKaLh59E/qziFgAjK2ZHVPSiYpnzwx43Yofk1OagmlbFb\nWJKNZj5CPtfO5z/V7xSHqWIUkGWngcBzrS/KeVIRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuPOcdztU0Bp+Xut2JmMJTT9U\nhkYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIu0blFVDBWbqF9zo9nqCrYJo9MWT3iClF7QFUfBHlxWAiEAi//xZ873\n1PYxHfI9x/IF+F3F63wkbF7SHVCGk6dJT9E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAekajsZ2AXR6ZZs9dSibJQEeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk3OTBiNTctNzIwNS00YmFjLTk5MzctNDE5OTFhYTViN2YwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNhY2EwNWIy\nLTY4NTAtNDQ2YS05M2MxLWIxOGViNTc0MjllYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDa+aGxckOfC2NxsZlGNvTVlUT4uCpov293Hb5k2cuyYLKVIkxHF6SrX\nQTbfRgl4ePuAzbc7zJ7kQe/ydpZGcEWjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHCIMabg\nJI6JQ9eL7VQsdMekBBvrMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDgWOvNW+z0EYfiJR3fn2Naf7LL45RYwf34rzZI0sP4YwIg\nQ8qyL5nroEVz3/YuOuzMtat4jxQOxTaslCB+J6SJAps=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1044", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1044` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAbi3s8sQbQ2zm1PoL/34MCafMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MWI2NTY4LWE2OTAtNGE5Zi04NjBjLWZiNzcwMWM3ODk2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI0MWVmOTYtYjg3\nYi00NzM0LTg4M2UtOGIxMmRkNmRjYmNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYmMsrjnXVq2+rqU4v6TSznLYcHg0WGHDWMES2906my6CpozbxhELqBNBi1Cp\njwiIFYJWPHGYB3Dz5yv0LrJWXKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU70Xag1e9llsbt5OeTzk9XFtZD44wHwYDVR0j\nBBgwFoAU6tMl1MmDm3ObR2EFuNEtgUwYVE8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMW6ZwW00mSVe8/yTd9tUE6YMSO35ZXG8bwNPUQeabl7AiBEcfCT4Z98\nvppeFIGwx5P3BgTqAv1JGySpzUJyautYRw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbtBlSyial0/I9eVuiEywwUzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDFiNjU2OC1hNjkwLTRhOWYtODYwYy1mYjc3MDFjNzg5NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnz8TKEpOpf+wHmekwpYvoU3XyPKYsqzuOJG/4+Ai9ne6s\n8o09eREEgaj6zaySW/OlzWzV9Q6KWjp7MOqenIIho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6tMl1MmDm3ObR2EFuNEtgUwY\nVE8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgb6ELkzAXEGh6glwF8gBkG4bU63P9VohMUw9PEZqvd84CIQDUtdb+iruO\nGmlPsioseB8RHJvJTYfolE5z6PIRX+voaQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAelX89QCtqa13XYfITUEnNdCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI0MWVmOTYtYjg3Yi00NzM0LTg4M2UtOGIxMmRkNmRjYmNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ0MWY2MTBm\nLTIxMmMtNGY5Ny1iMmU3LWUzZTgxM2IzN2RmMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOV9oSr4IHM2UVVmyT/mgl2o9pUl358ykDkli/da47ZQaV5lhczXP7LH\nsKMgbn/xgWCAlcI3IYm7bvEzyMdU0EyjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO9F2oNX\nvZZbG7eTnk85PVxbWQ+OMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCviVWXcKluK1FFiTbAm1v48eB00h6DrS/FJliH8XxDngIh\nALia28Yk1bPN08rplMOGYohGMzUfH6Yju7FcOhC2IYZL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1045", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1045` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAfriz27XrxgXXVAqWo0AfGDeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3YWI3OWVhLTAzMjQtNGRiOC1iYjQzLWFjNTA2YWE3ZjY1MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIyMTY5MGUtZDY3\nZS00MjMyLTljNTktNjNjNDFiMjVhMGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3w6SuZ0hLj7pPWK+YCLFoEAszbbj39y+ITbyjYUIj0+Qw2qivYWQ1b3C2ska\nWWz/32BeQfjzpMnz8z1YO2EQiqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNQQED2r+2jtPzn2hFyPZ3xZ5jSEwHwYDVR0j\nBBgwFoAUUM/lA/+oMhyFSkr1RSUOnK/6ECQwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIH8I91pJeBj0snzrGr7wndgdXqDiYDNlGmRrPtQ9FTz8AiEAqQkiES1B\nW13yLO4fPaEPKHIWQUSgf6r21OEmSB9GLK0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUGiXti9ChxIpaK7QmmN0eBFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2FiNzllYS0wMzI0LTRkYjgtYmI0My1hYzUwNmFhN2Y2NTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJYoiUjAvbcrKPE48M7jr1YAWzxzDIksDqLw8uBOBj7d9o\nonsGjrOUfutU0OevmmhYfuXVpEO0QGxumWTEeoKKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUM/lA/+oMhyFSkr1RSUOnK/6\nECQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJhxzvB6ul3GoiK6X8if7YCBgXjepE0PsCPbEAw4HZAeAiEAmdsgUXzw\nByEOCmPzKWz0tekfrJ8YMt4fLcuCuLEaX30=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAWgkZHRFgd4FnDgr10e/EcS0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIyMTY5MGUtZDY3ZS00MjMyLTljNTktNjNjNDFiMjVhMGVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhjNmZjMjgw\nLWY5MzItNGQ0YS05YTJkLTc0YzdiMDY0ZTk4NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGFFe2y/nEGAlvjVLDxQzOmomCHrSspA8NxXCunTyH8S/VpZY+t/svDZ\nvr7IZK1eQgdFodGXw7LAmEsbYXpZS9CjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDUEBA9q\n/to7T859oRcj2d8WeY0hMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCp32R8ENfoWudaInDJmwiJD4invZq9CB+Aq8rxI+mxiwIh\nAItcXrCURagsaFVehyt6pxx0vtV/kwIK8nYo0y8kDcPx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1046", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1046` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAVAbSIsj5U8vhC7es4rPQg+EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmODM2MTQwLWNhNDMtNDgyMS04NTJiLTY4MzM3YTZhMWNhZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjYyODgzMTUtYjI0\nYS00ODZhLThjMmUtZTk3Y2EzNGMzM2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERC/Q7K3K+pP08e4TL5VIY2VGSsGB9SsUm06/qUoZ3WL4iQKS7r5jehH6txTj\nS6fbml6zBkZeDbDYyfp7t9ZFQ6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3dHJBUvn0fRDU7Y//ZRtf9erwlswHwYDVR0j\nBBgwFoAU59HP+DTd2pZbe9W63VvNEOnfczcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIH7jXmlNEKMOyARsNYoVuYkVTCs5KMoTU7jtnbxh\nECnsAiBIBTb+b9h+PJ+NlEYtY3NVnezUpGpRsRir9F6KwOhNfw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQlq4Tp2pk+/5FMpV5HMNrUPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjgzNjE0MC1jYTQzLTQ4MjEtODUyYi02ODMzN2E2YTFjYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYBf0fLo+FeQKn2A6bkBeHbNCLeYDChUpPmDXIuhauXChY\n8VoModqxz2PkZhr3CV/NqWfKkJl2L4jk6kfy1UwBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU59HP+DTd2pZbe9W63VvNEOnf\nczcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANiH9JbE10sz3UnZ5+7tLwMybEOnvcVexv91XlsK/BtPAiAFbfgasAQc\nt3QSs9X/EXEYjzWLT82FWOpVDS2L+uhUxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISARNCyuBK+KIwEJZkAVgaGV0wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjYyODgzMTUtYjI0YS00ODZhLThjMmUtZTk3Y2EzNGMzM2U4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk1N2MwMDJm\nLWVhMWQtNDA4Zi04NWU2LTkwZTQ5YWI4YTQzNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCuDYLicHG96WVXfSH+a3FneAAMsoKPbzmTVKBuPjslCA6qxiHBzloeE\nRb1ttmgsUKw/NVmoeseLDE8q6v3XSfSjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN3RyQVL\n59H0Q1O2P/2UbX/Xq8JbMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDrmpMieTbn3WcGE37Ku7PIzrdh0vQtwlRbVlyqGiAnYwIh\nALHza8CyNd3eqH4/cxUkxiRuoiVq9qZHf77RofQG8+MJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1047", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1047` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAc1tWyqiBags14WgmqjVS174MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzYWMyODM5LTQ2ZjAtNDQwOS04NmNmLTI5MWIwM2Q4ZWI1OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjIxZTU4NzktMmY0\nNi00MjRiLWE2MzAtMTdhZTdjOGRmM2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+SJspn6StTfll25OYyz+qq4IO1KBb22ila1XeuW0lRSXZ0cU6nQF0BJawRUE\nNNAekxNI7CVXtYgCCttBCqN0QaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIzhy2qNHQLgfQhEgM4WzbREjnGwwHwYDVR0j\nBBgwFoAUwGS7rXYtpgsuNnNaIfLiX1duHUgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIBJX6x7eWAgjyT++R3bH+aOZxbct5czufqlm4F1r\n5ldsAiEAwUpkVWc+Tvsps9ntVykuS9498oA1Qm2vfkbgCMYNZQ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXelxQ3wbBmDBFmiZaOXMaKuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2FjMjgzOS00NmYwLTQ0MDktODZjZi0yOTFiMDNkOGViNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCRFy2p9IM64e27eVxhqLoMFVBC6BYbOsnTYAPpt0bGyKS\nIS0LCqQeuLgmQ5iCiGU6HoQfyQZEi31ursh8FA6qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwGS7rXYtpgsuNnNaIfLiX1du\nHUgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL8+T58i52szDf1oFKIumoIDru8CBhP6DnJsyHB7+brRAiBzWtYeBFlD\nln5qsJC/iLHDSDRMvEoRwj252pUdLDImqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAdhFFcZ4e6knT/U6a6avAsq7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjIxZTU4NzktMmY0Ni00MjRiLWE2MzAtMTdhZTdjOGRmM2ZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4OWQ2ZTA0\nLTE5ODctNDE3ZC04NzZkLWE4NzVhNmFhMzI5YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNovMtVZoLMNhB9zHyzcy/lVUPg98fWJs6xUNGYR1pRy+OV6CK4IM/Zj\nOLXaawAmjEmJAgsbu+Gk5vwOqIwkEdqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCM4ctqj\nR0C4H0IRIDOFs20RI5xsMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCnPW8KhkHe918dq1N0jDMKpHloH6nEyKq/cv+YyERErAIh\nAM0LEw+i5zmg/IQreOiREQ8m46Zol5KqPHvKV50+dILd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1048", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1048` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAbkHU15shKcQnM/o9w+DFgrgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkOTNhMjI5LTYzMWUtNDBmNy04NWE4LThiZDYxMjgwMWYyZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTE4MjhiMTYtNjRi\nMi00Nzg2LThhODAtN2I1NzY5YjI0MjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExmxKM2sBInZc0jmFcXVppjBazWHGYP5ZEX7Il6mcXJjYxtcX2JfSCK5Trhc7\nCh14f6OTm3k5M0/u4BVyUH7qx6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPfJeXQh3Cwx2LBADP6MQrfvDj7YwHwYDVR0j\nBBgwFoAU+ILQL4boJigoc5a5lwmqJ1JETgswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIDAVsGzYDyK2uuogKjjaRMgSEe1u3QifOyi9+wiu6wHNAiEA\nrsn1gKsVmMOcdt20d/KaLNB2oIgwJVZf/3vQWriUP3M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeCo7dpFkVJXl7hnbsB2eOLeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDkzYTIyOS02MzFlLTQwZjctODVhOC04YmQ2MTI4MDFmMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQb9AE5W/P0VFwoRX86BUyvyK5Zr4Tp6o5b8TPE+fENKKBr\nPuPK97rmqElX/KN8+qH1svsLmEDA+p7KSRYZbR36o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+ILQL4boJigoc5a5lwmqJ1JE\nTgswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMLMSQINnB1VzsyeqXTUDX7TVe6fbMOHOwNrVbmOlZOgAiBOwklvhSvD\nhB9AEu2/wugcDFsBbRtUCcLSpcMBZmSXMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAfS8gpccmrQ12ecgIiqMCVXSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTE4MjhiMTYtNjRiMi00Nzg2LThhODAtN2I1NzY5YjI0MjFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMyMzJhOWU3\nLWVkZDQtNGI2Ni05Y2YyLTI4MjVlM2RmYjllOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDfqPNAEMy3RA95oVAuJSW56lIO48knWVYyg/oZ/QRUjC9ZIyf5vLevz\nHe9Y/RZezCadbJm3ScdNWAtIeupscz6jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD3yXl0I\ndwsMdiwQAz+jEK37w4+2MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIAIBNz0G7IkYZhRpGVKBsvSRHcrKPaNB7VaioF2yYmSVAiBJ\nbzCT9/pEs9qVsnkcKqdDCpznELdJhWeYpy/t8DPbYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1049", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1049` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVdfbU4WXTtM/CxEkrZ6otF8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmNmZjNDBiLTIxNWYtNGJhNS1hYjI2LWYxNDgwMGZmMjQxYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM0ZTI3MTItYmZm\nOC00ZDA2LTk4MjUtNTU2NTFiN2JjZTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIDTRmu3tvcU7pz1X7Q0yE4TPPmxxJJi2tDOKzhjEXPy/0JcFFRjBgcYaVhlj\nEHPVPcv2iQvj1+OS07ELa9kvZKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtwAnO2IzlWTVQeBvWQ7S2CbXH6QwHwYDVR0j\nBBgwFoAUSDaeMo462v5MiW/FqISMGCIqYiUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCkUsDyyD6ugGdGs4h06xNu46bSfSVT\nbpdrvyG7kC3vQQIgRS9gtdN9BhU3g267V6+tcMnnP117ia1rl8SlW45CMSU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARpJ9MjVG0RAVylSg7X8yCF1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjZmYzQwYi0yMTVmLTRiYTUtYWIyNi1mMTQ4MDBmZjI0MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiV+UY0T7oxpFkoaSvmDQv98Wwv9gBCcStHKbRkQyOe/WH\nIc1GIiqfd4usA6hZ3ay5jGMLUGbdpcy8eyYWM4dMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSDaeMo462v5MiW/FqISMGCIq\nYiUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJyWMppXHg4D8ot5JR/Huh7mSE6qRxO1KvLewi6JN4mfAiBzd0PvQW/b\nSP7fEWEWgvrn9pp0dxkeGNMsesusB9cxIA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISASOqf8axaStvyQ/VPMYDE5CsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM0ZTI3MTItYmZmOC00ZDA2LTk4MjUtNTU2NTFiN2JjZTYyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA3MjkzOGNh\nLTYwNzgtNDQwMS1iNjg2LWJjMWIzNTIxNGU4NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGwphLPcVJT8w73tRzsvl+AD+BOYmIoChFOwJ2dnMh7iKv7aXCr+CS3f\nLd+OTmV9VlDkdMUE5zhojwEgHg5+2t2jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLcAJzti\nM5Vk1UHgb1kO0tgm1x+kMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCvWC3FsInVu/Hcus+8vD+pEZmHLyz31CRjuP2a2p0QLAIg\nclO8xdB4BmuEPFky3wRF9QbiGgR3ijAShvVyy2Hf/3c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1050", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1050` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAShuBJdLdbBbgNvwQ9BzIbwLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkODJlYTNhLWM2YzAtNDAwYy05MzcwLWU3MzM2MmNiMjA1NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzk1NmUwNzctYzZi\nNC00ZmJhLTk4N2MtNmUyMzFjNDBlZDIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGhUYL1B0lT1CsOD3Ln4JwDPQfhin1X9JH1chU/UGIW8ZC5hYXNPqVXpAt2gA\ncdLWhhNMhEPtPyQSYmBpOxX04aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv406mrT25mAyOLGTfZdyuowv0KMwHwYDVR0j\nBBgwFoAUoJ4hOo+5uiX38sNrKhPgguJrHf0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDDUHrlIny3FmPcpceNlpUT9CYNtQd+\nr+ZiPCvLx+PHVAIhAKqvkAXIjwI10FdeU5OcZAs/Ziu1WwP7NZHmghmDOjFd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAckS16TaG94u0Fx2oQQwILZHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDgyZWEzYS1jNmMwLTQwMGMtOTM3MC1lNzMzNjJjYjIwNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCaAySvd7hT4Em4RhmJopBA8GKX/1iTPZvsko471qkcBWd\n0/v+B+E3fwoMQWC/y9zCBe4wMhHeZIMRo9WTJ84ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoJ4hOo+5uiX38sNrKhPgguJr\nHf0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANFaB4wXRZxWeGvNs4+7NPX6H1+WpzfEl/4Fr0a/f3FDAiEA6QAURffj\no6f8DuR03omv+Th8/z3wecIBxXwMtdz0a3U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZ351GSDBgOpQztltfH+NmZVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzk1NmUwNzctYzZiNC00ZmJhLTk4N2MtNmUyMzFjNDBlZDIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhlMDUwMDI3\nLWNlZDgtNDBkOS05NjVkLWU1YTdjMTFmZjk2MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKBhe3tbjDiy4GxBiIWMSuRQ3YavOvFHY9KpmFAsCknJ93iBs4gDc+ms\nSMQleFm2cx+TNjsA/6Y6UVxEtUW9jLKjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL+NOpq0\n9uZgMjixk32XcrqML9CjMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDOfC6Kje3ajpuWaxNueFgc6xFk+UDOE23CabwjgwsYqQIg\nAOgtTzHSP0V35P20xW6jms//whwM4EdH2eBZx4bTD58=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1051", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1051` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISASzTc3zkvhcLrT6NfhOiJyJcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ZmYwODY3LWU4M2MtNDk5Yi1hN2I1LTQzYzExYzk1NDc4MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA2ZDYyOTMtZGY1\nNi00YTgwLThlOGItMjg3NjU3NGI0ZTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8rU8FnkuSr+R80HLWeKNXj8f4W26RXj9OfCpKrYjItpiEunQLnMBmRyZH//v\nUAGVDUKblNsSHvFGLJ/RtQ20d6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYIdbd12aQosbQN77tJv/W/UTPkAwHwYDVR0j\nBBgwFoAUtI9L/LShdbUwbnvr9obGPxt84zswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIG9QLh2trip0\ntqYdb+W01fIYCAa9oCkpKf78L4PLxPTuAiB3ywWr8wHTHl6kScaGwXplPpEyXIC0\n2X/Xve8lj38ZIg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaemobWNCDV7yt2DM9lFKuWzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2ZmMDg2Ny1lODNjLTQ5OWItYTdiNS00M2MxMWM5NTQ3ODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/sacFL5aAiy6bSMn1PTjUmJAmdBO8pQ/YV1fqQYHkGe32\nRFWh/niZFTwQDaMxm+ZdJXgjHE0k6sbgNCFCblTLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtI9L/LShdbUwbnvr9obGPxt8\n4zswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBxqRrOvhLBTx8OlrbGI+CNXxTnNROMYDr2uxMb4mR7MCIQDOKwzrVAWS\nI6bieYV3rCDyWyTy6Gblg1M5z6w45Ru8uQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISASyzrijibxb2Y3cLNJJAaBkPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA2ZDYyOTMtZGY1Ni00YTgwLThlOGItMjg3NjU3NGI0ZTZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEyM2YyMWRi\nLTUwNWEtNGEwYS04OWIxLTI0ZjZiODI4NzViMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLTmgC15B0E+y15Zxul1nGxtfqxX82ZB/Ke/2U9t2HoBfkYF92mM093n\nu5JnG1BQm8vbj7Qxm5N6JgwBCgg7m6+jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGCHW3dd\nmkKLG0De+7Sb/1v1Ez5AMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIDyY/3AIbqcgUrCdzQ7Api3DrJNf7l/iSSVmCPAQP0oTAiAw\nsU35jLbJIKacRQER4yXf4N5pQJCw9HK+4qO/8vZZ1g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1052", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1052` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAbib3nWIwFJ25XBFnBTkj2WRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1YzBiYzEyLTk4NzktNGRhZS04NzllLWJhNjI1NGUzYjgxNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk5NDZiYWItYjdi\nMS00N2IyLTg1MGYtYzlkMGZiZTViYTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2zGH/YWozJSFmx55mBEMUl3deWeTRZjRf3zgVKarI7Rxck+17v3vMNTJOGD4\nabxiB28yOfiPs+Or8xEG9s5iLKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR3gu/ML1U7q4Lt4WNOiaLgy3FAEwHwYDVR0j\nBBgwFoAUSjA6IkQK+Lf91ypsfz475xsE9kowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALykL2w6sweaW0Bz183Fm4yP51dXWsEHQTICK/70GTgJAiEAw+UQj+x5\n9aXVPUc25wUu6Ovyl5vXWsDvG95Ms5qL3Eo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd9lK6eh2aa5DQgcZv0utvseMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNWMwYmMxMi05ODc5LTRkYWUtODc5ZS1iYTYyNTRlM2I4MTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwanFG6snlbDJofrZbCX2YdCEAvacTW3ZRRtVDnBQdeGZz\nkuHJdJdDrolBlgkV8SlKityb2m/1ty7d6hfgcoAro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSjA6IkQK+Lf91ypsfz475xsE\n9kowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA67USE1CdHRRXcRujKJxDwQFNcCM0UhSwdyxWLq8YKMCID1R8yjJttML\nuBRA/M8OQwueIFXhWhpqHQvgsbYwUzF8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAexqrXTRwEjYvv5eGH4qkSPOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk5NDZiYWItYjdiMS00N2IyLTg1MGYtYzlkMGZiZTViYTEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFjZDQ5Yjkz\nLTE4MGMtNGIwMS04NGZkLTRiNmUzNjA5ZGMzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH2c5AA4UBhFs7GbH2TTANmhu5pcf+j5fHQMGI+dBTnmUcktuZOYzfor\nhuUR1TjBbNqoNGRyF3IySXTg2R0jjUijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEd4LvzC\n9VO6uC7eFjTomi4MtxQBMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIGP60lQ5DnNuSIzE+D54ZheS6vJJqkr9jH78siN1sBurAiAJ\nkEgHMsPkti1ZDB66CXiCe2zGB/PmPBEj/LujLZOzrw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1053", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1053` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXtCKf42JS4LXT8ew5t08W4IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NzYyY2JkLTQ5ODItNDM3YS05ZTAzLTJlOTc4MDEwN2RkZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk5OTNiY2YtZmY2\nNC00MWRkLWJmMDQtN2IzNmFkZmJkMWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0qup5khTuV11EGKNZlbK4RZjddF2e3kyM9SiR6X5kkFXZDWXUEkrGWit281d\nXvLiZsWqGzVmY0WA21y4KmvwUKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnMR9gF/azE4ae67yqEPi+3p9U8UwHwYDVR0j\nBBgwFoAU11fe/sl/T1ZpPBaUs6STmpFYCTAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgbmVjs5wDu140U4gB/FSxKuWja+sji3bQpmra/szvuUYCIQCLd6I2nMF8\n6TuiQmK+rSiQthIhp2geur9R0wKcLc/HBA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbsjVpJ4k/NdPkayxJKFVXPxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDc2MmNiZC00OTgyLTQzN2EtOWUwMy0yZTk3ODAxMDdkZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTe0u6inGvkCCVZqSW/IdA8hJZzgZJLdRTnqnc8wvLuPF+\nw21jd8+ziO7wRowNcACYCfaeaQoIBTLVS2FamnyKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU11fe/sl/T1ZpPBaUs6STmpFY\nCTAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIRxzQuZjloFjFRS+g6ip8XthR0tzT6DYMiO8om2VbewAiEApk4/8t4l\nZ9CXsOwXwC1fteAom7kKp1hbdZ56GQHzhbg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAfFzGdCqIRdArDG57YasBOEeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk5OTNiY2YtZmY2NC00MWRkLWJmMDQtN2IzNmFkZmJkMWRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3OWFiOGFi\nLWIwODMtNGU0YS1hYjNhLTlkNzk1ZGU1YTVjZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK1wiD0HwEU4WMiHpK7W0ns/4q4Q8bWDEGyGXqb4clBbSBjUzecm6guS\naH7n8zQC/lrVCVSnPZ4Aw2wDPgXj65ujcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJzEfYBf\n2sxOGnuu8qhD4vt6fVPFMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIEn7d9OfpZnixdKrJTM74d5HQFalR7vKssnj2MVi3Eh3AiB8\niUrbKBNrQVU1D/5MrSLNqIYLQIlDA/oZgw2xhViaLQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1054", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1054` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISATrc7cI4SR6nGiJo1Vwfk0rtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhZDdhOTAzLWIwMTEtNDk4ZC05YzBiLWI1M2U4Yzk0ZmUxODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2VkMjc5OTktZGZj\nZi00NTliLWE1NTEtY2ExOGE4Mzg5ZWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5WuSV6miRFS28L+jc9SDEro5pnriUX9Tz47tETISzmrHiETBsAzUn39/p1u9\nm8YZOBpXa5KxlaBtrUkYtd7/MqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAcEo37mQ8f9dW6hRvIjt7BzxDzswHwYDVR0j\nBBgwFoAUpRHpBtS0MyfdVE2EUfG2zcuRhYswOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIHfiJv3s1Gn4plZWI+nXTNZ12O6FjdMchjOSjKKTgEEOAiEA9TyTb3Xp\nj82du2LBPIn7L3o/ok6o3oqflxbGhq99TOY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeJawCbIL3DlnK04REFgCPBGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWQ3YTkwMy1iMDExLTQ5OGQtOWMwYi1iNTNlOGM5NGZlMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+X8CLFTTa1ZyBh3SRroiI1b2sZHKHRC0XZlXt2YghARsN\ndXrhTr5k2rTxiXShpB0UBiGAD0GXeLoFXkqoPi9eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpRHpBtS0MyfdVE2EUfG2zcuR\nhYswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW/b2leHyvqNJyQsumo3Che8ohJWC8YW+oj6uO5WpT40CIC1gf2UWj07V\nQLpl+NAG1ht1f/gMZnv5mr0zZz20Tjs5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVeeS7a2mGVv8rnI8q2/t5yDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2VkMjc5OTktZGZjZi00NTliLWE1NTEtY2ExOGE4Mzg5ZWJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFjMDJmZWM1\nLTdhMGEtNDI1Ny1iMGU1LTRmZDBlYjZhYWFiOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEnNumMVMlmTxAzxolMV8CJyAl+uPWpOz7FhMXzx+9761TK0Z+Tz+BQj\n4dMZNdftdSMtL/gPEpq9GETkUWuAPvajcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAHBKN+5\nkPH/XVuoUbyI7ewc8Q87MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCOGzWkSeyIzS25Vp8T693LMFzIP+FLQzaWsW6Nf3RdMgIh\nAPsIyoiVI5ppJRvKTghXR2lhRF4fBox/R1Qi8EqlfH6O\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1055", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1055` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUvPule0VH7hz5cSmFlZh2AUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZTcxMjllLWZjOGUtNDRhMS05MGI0LTY4MDUxOWNkNmFmZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UyMDcxNDItZGRj\nNS00ZWNhLTk0ZTAtODFiNzg3ZTIwOTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+jyCX5U2keutFxGmdo+oUybmfRY2ielM03ZIIyDo1RTGxFlQg/FHBYs3UUUH\ne09v8KQnZ0/T1j28JrcjBF/0KqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyfXGEzLeyBa2lS4mniKuGADXMiIwHwYDVR0j\nBBgwFoAU8cbwVGymON+1ERLdDnRNFwGwKuwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIFUgNuGvV39xmc8k011QrublGwcAYIHInHxJWwFq\neT13AiEAhMkxb7hhzDWUjuzYcaFXhHwp5ebtufGJMJIlKXzbZAc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARztxzizWFemxScu1tFvI1S+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWU3MTI5ZS1mYzhlLTQ0YTEtOTBiNC02ODA1MTljZDZhZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjjpNjqoF68VBzX06gtpjJ97xTgeTXJKeoKEmUjmKLapjb\nbD/BEuJ2svQOcL/U8dHYbALatCUibfL8+T5YhoVBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8cbwVGymON+1ERLdDnRNFwGw\nKuwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJHTcUNmUP3IqU0OH9/D+gMpvF6Iptc7DxydqD+fVc6bAiBMLyuFXtu/\nSbPL21YxBhO0O5AN8zo3/WHws2ZmgkC9QA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVCj9xgsmSBqwTZGAhajQEKuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UyMDcxNDItZGRjNS00ZWNhLTk0ZTAtODFiNzg3ZTIwOTEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMyN2U1NzFh\nLTdkMDQtNDUwYy1hY2ExLWI2ZTU1YWVmNTBjYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDD2Ah2gS90Q6GUBVsaXXwe5hnnILsMT1fsqOnVXLbzh8q8g/ua/zxag\n/s+o6VPtUIMjmJF06FLuJNMzWDkk+O6jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMn1xhMy\n3sgWtpUuJp4irhgA1zIiMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCJ6c8z79qPLUxi+QcEQzMzjBffxjcP9LGZAD2pHH0NSQIg\nCM1LkIA7a7yNHfPvIYz301UN82N/FjMeFqiEDLzc3IM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1056", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1056` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAR69zkjmV5SDhlNL5mTpIORxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkOWVjNWY2LWMxMjgtNDFiNy05MGQ2LTNkYjQ4MTcxODVhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTRhNjBlZWMtNDY1\nMS00MGUzLWE0MGEtNjQ0YjU5ZWFhYjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6fpoh5pLvEeKR6Y/CqU8d6Gbeg8aAdVTRrnFY14nQmqDhIjvgBVJDdNX1cUk\nKdmt/7yGQg5TwtCspnnxLmVfvaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFoXD7ePh/Sv7c59TwaH6wEfQjxEwHwYDVR0j\nBBgwFoAUVE+nOTGaHDIRgIaQAK4Laj9Vf2gwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEG+YZOKeGsvpSvLYXn/vAf2iq7EIjmF7NmDoZRp\nRToSAiB7yq0eZhglqQh54VFv2PMslw/KjQlqd5EBWBVBrr4svg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUYGUyFMXJNdjSr1Sc7ZBlNoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDllYzVmNi1jMTI4LTQxYjctOTBkNi0zZGI0ODE3MTg1YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQItLIXSXS15dgJJxjgwggzFUcKB8XjgFbP1zw3DMMuQs4z\nwYjL+LOX+OETGkl1yKocYQl8GXfsSS+V8pgBX9GDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVE+nOTGaHDIRgIaQAK4Laj9V\nf2gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPy6TODNpYmxXsk9aJrnBUzcCgzYDtsyiMlN3139tbycCIQD6JUJx3aqh\n6YBl0xtnh+aH/uczQ3AQYp4Q0wJBRzNKmA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAUJd2Ay5MIGVTKPaxXr4CwN9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTRhNjBlZWMtNDY1MS00MGUzLWE0MGEtNjQ0YjU5ZWFhYjZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU1YjBjYTA1\nLTM3NjItNDdiYy1hZWVlLTQwYzc2MWM4NGYzOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOeSNWlc/cm+4vrKtgXZT7XGHUx3FvvHp51hTy+4ivQ6pGmQD/tkWoMR\nJSQPzxaZzjUOIy6YI/8Kou+UH83sK3GjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBaFw+3j\n4f0r+3OfU8Gh+sBH0I8RMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCqvBp/UrtVJwYyUtwMdzSIYQUwPr4Keu60TtJ69phpQwIh\nANvWV4o+wGhUzje93Z6KvQKVxZUTIvdgu0Mj+ffeLPem\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1057", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1057` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISASURjpsGKtRriNaowvAjwKRZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0NzRjNWQ5LTE0ZTYtNGMzNC05OTc1LWVkYzJkMWI4YWQ1ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRlYTRlOWEtNDBm\nZS00ZTQ4LWI2MDgtMjI5YzM5ODBlOTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPrpdodIeraSJgByoecAAC9AYV3F/5A3qNGDZCgtmSD7AXMA34VX5jOiU9W5r\nnspgSyukFHOvV0DPJKRlq9jmGKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbFzgx4UXRRPzDK5lkbbr/0eGg/wwHwYDVR0j\nBBgwFoAUYPxEeNKJSOQ8MwczIFD/lkswmxwwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCCiZQwybrqcP81A+jmTt9gobRwVWqrZ0krCbitF9+84QIh\nAOrIWnV9IrK9VY7WRgeQJTgt0NU+1CqtWRx6iF3T2LC2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVb1T1MT6vP6PYjVrRzASNUcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDc0YzVkOS0xNGU2LTRjMzQtOTk3NS1lZGMyZDFiOGFkNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrxMfTjC8oNjo4vRG+T69NcXNxZ8wlSibQtuvUiscm2q18\n3ykhRUL8T6ANn0m3hmAY23jCXgygmejeEP3e5hxEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYPxEeNKJSOQ8MwczIFD/lksw\nmxwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPUlGmKANKiOaXGNMfr+M/5SI33hSpLPhoDb6FmJswFxAiEAn9IwfYGC\narcaF53BSozw2Oz41eMnctvkwcTms6sfVDE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZEXA3anx1jB1t8Yk3shiYidMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRlYTRlOWEtNDBmZS00ZTQ4LWI2MDgtMjI5YzM5ODBlOTk1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgwMmJjMWI5\nLWI3MzUtNDAyYi1hNjZmLTk2YTBkMWE4MDJlOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPBC4mWlXdVNy0pyghUWybON2xXwqOPGsVfz36dBPgJ4WpQRnoz25dRz\n/7HE2LTRnq6AnH8JlMgbovxquxuxJgqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGxc4MeF\nF0UT8wyuZZG26/9HhoP8MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCwMA0N3OvtLcdBxZR43uEX3i7q6U5uyDq50+g4locaOAIg\nYv0KrBtfkSiCmzDnmHLGEsotU5heEr5oh0calgLWjuU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1058", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1058` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAd2955P4381jy4BUiZLMfYQ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MGQyODAyLTJhMGMtNDNmNy04Y2IxLTQyZmNiYmQxYTIwMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU4MjNhZWEtZWEw\nOS00NmI5LWE5YzgtZWIyYzE2NGFiNDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGcQnpgkQzp8Nsmu8VH3Tl9EeJtOsdXjFkS7Pmopx99/pu7XHPDudsIbmHpLO\nbVJyK4XQtQ4kzAcsAAt4gh12pqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwW64ldvEQ5muBvLufNSfN4ZPSkwwHwYDVR0j\nBBgwFoAUyIGyv8u2NsuIgG2FwxdAO5+IrzUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDyxYhMwieSscMukXz+pTXYXv/InfPq\nThh7EHUKny42VgIgYp6Q6ksPphaKDQ1iH1yzKohDgpctLxB66g6kxOjT53Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT0e8NjS/S+BBL5TqtUFMfe8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDBkMjgwMi0yYTBjLTQzZjctOGNiMS00MmZjYmJkMWEyMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmKK126u3Z+zBetiDZ6iqBEB26sqShX3ghIQ5hCbmc83SY\nUdSa15ht9C/n5AUXb1oMZ9WW4uOADtoqm2GoBqpwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyIGyv8u2NsuIgG2FwxdAO5+I\nrzUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAICwMu7Gr94vGPpd7Rv19c9q1YItUzSoq2wCmsdtekbWAiB65l1Ys9L9\nrhvPSOppDMrVz0VcjOoM8UIfV/+jjRCkuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAcDKusuoIkS+osrNqFA7UFBzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU4MjNhZWEtZWEwOS00NmI5LWE5YzgtZWIyYzE2NGFiNDhhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY4MWIyZjNj\nLWQ5N2MtNDY3Ni05N2E4LTkxMTNlMDVlYzBjYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMxACqnOVivJ5/q1CApkC1Wm4D58biksgpPXNbD1D0+Kazd7W3VZ8w3B\n5SeiSaZkIzEew0Fjtq5j/7MNXpMssVWjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMFuuJXb\nxEOZrgby7nzUnzeGT0pMMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDseGUwvtNKLgSPImNaJpLXa7UJBLpee63bumn6Nn7vBQIg\nMQzpvq5rvcGKAa4CLojSB77c9hu0XMr1+hDrnUP9agE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1059", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1059` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATFaR7MXWLzOteXmAWiL1I8aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1ZjYwZDkyLThlMjYtNDkzMC05YWI1LTBjZWI0YTJmOTI3ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNjN2ZjYjEtODNl\nMy00YjYyLWI1MDctMTgwN2QwNzkyYTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELiWPP9UXPn8jNz4C8mfQ/GYetSABQp3R0xvrTWrR2Da5rq1wh9YmZvDdYddQ\nUMcT1DHCnCEusMSx1N8SdmECEaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxGAqDVJfr8eIvgYcJuCvhD0BbUowHwYDVR0j\nBBgwFoAUDO9H11X+pO6OeIbqzuhlU65pNGkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDJsbw1r5gIBIXEGFp7YrZ0i7nNTztY\no/qTb1P9Ql4MLgIgPtwoHd+KY4//7FwfO4JYz+7J0BlvD+G60rYk9waWobw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZtW0uoKBpiF3SW4qWFGD/QlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWY2MGQ5Mi04ZTI2LTQ5MzAtOWFiNS0wY2ViNGEyZjkyN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATv3UqkWEEJvp88vp4ziOyKZRrDpDjD3A5Py1mJ6DUoH4Z+\nCAhKMIfWIKSlmoz/BmAvGVrwonNzh9ai7IkIdd2io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDO9H11X+pO6OeIbqzuhlU65p\nNGkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKhvjAgKQEZb4b8AgDUNigDo0OoMndTvRLbWWOK1T3uQAiEAvCxfDXMi\nkeppGQHDP2LVzZd/L6LCuqK98QsqLprZ1n8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAWyW0AhY6vTzRxK8VGMdZtP5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNjN2ZjYjEtODNlMy00YjYyLWI1MDctMTgwN2QwNzkyYTZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJiNmFlN2U5\nLWRmMzAtNGE5Ni1iNGM5LTlmODdkZjdkNTU4NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIRffh2qd5E+8Vhs4JUWPEpyA5ClDJ0SOUn0QUL1wENSJQRME5GLavq8\n9cJWD2x0keCij5u8NnlT5bExxFQXj0GjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMRgKg1S\nX6/HiL4GHCbgr4Q9AW1KMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCedlEBsRMm2Nj88tdiXGQNHFWW9IY8xpIykhtlrbh7eQIh\nALXsGYlQsMdtdM2GeS19HWu6p3ArRuEo7ULEdSG4Qj/V\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1060", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1060` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdVQjJTPjXJDY1Z0udluFBKqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1YThjZjQ0LThlZmQtNDU3Yy1hZThjLTVmMjRkYzFiOWVlMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWEyY2YxMWUtYjJj\nNy00NjI5LWJjYTItZTI5NTRkOTE3ZjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELtHS6rhZ/4uXEUCsRNPhdWlrPeIJZZfRzQ3qDsjyCaT4sNbZ7WnNOGXMgHhC\nHsE2a/FPebToZD3IGOuAL1vdkqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN8Jez6B6S5TmUZ3x3AT82OvIv+IMB8GA1UdIwQY\nMBaAFLCud7kb4Yuimwv0qX/EiZhOSaIqMAoGCCqGSM49BAMCA0gAMEUCIHUQdiyx\nYDafLTlDrgCzGfQskHAgGd66YmIJkyl+a5HgAiEA6+aI38LC1tqtZM6z4+M9Lqq3\nVdj4uvoBQzcNFm9a7cA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXTxUsFn/fRzyC/D0Ek9KnbsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWE4Y2Y0NC04ZWZkLTQ1N2MtYWU4Yy01ZjI0ZGMxYjllZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBQveAyf2hIuBbb1xi9nXY1GrHjsacHRy5yRTMjlErsDiY\nMd45Esq30+Jfi/MdSHo0APuZJw5RMXe+1hpxPB+wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsK53uRvhi6KbC/Spf8SJmE5J\noiowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANOPeSvc+DVZqZmN0k7GdqhfyVA9ZxammmxaNC2zMOFEAiEAp82HwLth\n5/tX1eFpQqq1KdIXh5sppnRaJlWs+Lo2sOI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAWAXUj7eB6wMI1aofhq5EhThMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWEyY2YxMWUtYjJjNy00NjI5LWJjYTItZTI5NTRkOTE3ZjMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU2NmFhNTQw\nLWQ4ZjQtNDk3YS04ZmNjLTU4MGNjY2RhMjFjNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB65cvIwFA8lKW6aOFdA0hTpb8H9vyZz//S7geCfbS0wpoigNli3gi3r\nmcSzMKWE18qHyggo55G2UBOtqsJkdrKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN8Jez6B\n6S5TmUZ3x3AT82OvIv+IMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIF5AwYKIvf6SeDDkD7vgvgG0AF8GqeoaiQErmIeS\nL2krAiBfpGDqID0w7BGY7qr7WeETaklZE/XHcf4yfEbDcKTb5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1061", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1061` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZ0MFwNrYmYTbPpPLN1EprDAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2ZWUxMDJmLTA2MzgtNDM0OS05OTE5LTg5NjYyMTExYzIzYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRhMmVkNDMtMjk2\nMS00NjJhLTljOTMtZTEzMTE5YTM5NjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVSD+Ga7ebFGh0UNbY25KtbSwsORF+QpJG15AY/4ovP3oLceQvIkuZfR0v6bv\nbGDIqeweqStLHYVpJw0A/Sj3XKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLu2ATwQdJ/YaHrvZGHxJA+99IZyMB8GA1UdIwQY\nMBaAFCH/PysaiXFqSCFu4oJXxZHSGUIOMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAx4g3X5DVh5XofEJSt0JI7OaVbfbrLtRt\nNdE5HxyRq70CID1IkzVG6EQNgl8yk10CTdgqwdnJ2MWY5j06x6c+d8cf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbZzGbB758dgsOlcLyaaQd1jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNmVlMTAyZi0wNjM4LTQzNDktOTkxOS04OTY2MjExMWMyM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5S8RIfZjIGxAuegbTAdXHExYIE8RE+jxVVjlft1EjZvCw\n5A3rFEroMT5AMkifg65bSF2OD6TXRUGZRVEVsRvRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIf8/KxqJcWpIIW7iglfFkdIZ\nQg4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFYaI/KS+EOlztaoTwQ4bcNqDCujE57PM/NVnyTgSAUECIELdcppBLsr2\nNNsdAEkXuZzQwr2HmtMVSiOm8QHe8DQn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISATkZKN7UU3GMY5+yPXa2ZZK9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRhMmVkNDMtMjk2MS00NjJhLTljOTMtZTEzMTE5YTM5NjRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlkM2I1MTFl\nLTdkMDEtNGIyZi04ZWM4LWM4NTJlZjY1NWQ3NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGHjSxXqMUxH+G74X9w6xZuGje8dso5G1vPwlDCS44O3axGdSFR4NL29\nOMD957mPhz0w1PsgS1Gedymd4FE4M2ejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLu2ATwQ\ndJ/YaHrvZGHxJA+99IZyMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIHgsumuVW/+fSQTN2YHoZipuDPLIui1hdKbe8mQ3\nrcYiAiA5Qwj16xDKX3idJ63RRWbkBXiSkz5Bus2zVZlqPbt//A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1062", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1062` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVLn9CkjYTIoFqx63fKXDQ+BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmYzJiYTMyLTYxN2UtNDA0YS1iODNjLTVjMGZjNTllN2E2ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQ3YTlhNDktMjU1\nZS00MjUzLWEzYjktM2QzZGVhNjQ0NjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdoPlD+BXR5W98sS9wYmQyUJgw3G88vPljQBfKh4NLHkNgbdp9W/U5eoaBY1w\nump20GBtr2VAuHzVgYqspj813KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDBJJw9C6SIcAcDlxRIyv4liy/SCMB8GA1UdIwQY\nMBaAFEpCSiQHobcQn4ibFSz7YbhfiAUUMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA8vD95ZqIruv9ozf9jgifb0jzZmtW7VaQB\nftNEQZCGhAIhAOXUtR35frq9CR3LAJNX+R9Y4kk5ahYuZTOJjV7SgpDz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAckqfclzXISX4AuUftGeoH+qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmMyYmEzMi02MTdlLTQwNGEtYjgzYy01YzBmYzU5ZTdhNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASizzsH5fMqcasZCRcZWrCqREHtSTA/uzA75q0QTUT6mskt\nFOVvHFZ223IdLtsqsryaPvuHNsJgH/jeYKnvMaR1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSkJKJAehtxCfiJsVLPthuF+I\nBRQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAZIXw2nDcxe0xkD7qXERYVY+0pqIU2nqIB08POck2hgCIQCsQDXtac3x\ngWNRKKXmYLDqhhnAbiEBIFhfRQ+3xqDOcw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAQI7mNrwiSfnl2IcScTeYeOGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQ3YTlhNDktMjU1ZS00MjUzLWEzYjktM2QzZGVhNjQ0NjdhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJkYjU3YWI0\nLTg3MTUtNDI5Mi1iZGRhLWEyMzg4YmRkMzQ2MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKsj3CW0jH9fyePHg/Q0aQXNuBr2Kbn3KVm50YzrQ/9+t9+AhCGEKJGT\nf+R3zmGilDnLWHZePYwIzUokD9kS29ijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDBJJw9C\n6SIcAcDlxRIyv4liy/SCMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIGrmsxHuZ9xDzPS/bOJWrkA6mnC0Y/iaQz+7lJkc\nb2YnAiEA3irV92Sg92u1CxI2QESV5U2+z5A/TzA96wCuPM9SqtE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1063", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1063` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAYKZfZoCoJeyFrosA/+aFrgpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4MWEwYTY0LTAxYzUtNGJiOC04MTQ2LWQ2ZDU0M2FkNmNhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE5ZTgwMGEtNjE1\nMy00YjhiLWFhNjMtOGYzNGIwN2YyMWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/d2raDj1PRPXAZDusDixaX2y/3+qB0QHZJl/5iEUcBvH7nCO+y8uwN/V+NCi\nG2kMnf+g0l2S/TSOn7lsEynCP6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRQeETYme710i/PpuU8Qoua79vN7DAfBgNVHSME\nGDAWgBRbyoC5SFcX09Az1GtkbFXJ1ZNAqjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCLjq1KOhNW1FXj8axYFo3GKOYB1dY2\nRgff2qqwUq1KoQIhAOwKZ4eJQtdB/fvdjU9zP3QBIKsfraM3dDlPBCZko3uR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdRgV2sTzJiZYP9kj7oYCobtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODFhMGE2NC0wMWM1LTRiYjgtODE0Ni1kNmQ1NDNhZDZjYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAZHYj4XjqvNMI88MdBWFX2+3qHJvv6i6oFstv0zZUzzGU\nB9yfp4IidSkr3GYRyC5quvscHRTAinGdAwkzxCcjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW8qAuUhXF9PQM9RrZGxVydWT\nQKowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVcM877AR2maeq9gu3UkPQRajRcQdQoN2Ht1pc0ve4LkCIQDwOuxXHi48\n7eWAZx7xfpW32baAaz6NcEYQ1/LQWNhexA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAS9mlSI9Lfp91FJ6cIBCH/GDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE5ZTgwMGEtNjE1My00YjhiLWFhNjMtOGYzNGIwN2YyMWJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkZGNhMWE2\nLTEzYWYtNDIyMy1iMGY1LTg5NTM1YWQ2ODlhODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKZEqL3RqErB5JP/SC9jlT6VJO5y3v5igH2SBVCwbyZfvMQ5G3q5ORtQ\nwwWvhClW7rVn7yF0VZNFIPjQEGKaIkGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFB4RNiZ\n7vXSL8+m5TxCi5rv283sMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCUq5wku1B7hrADGSPkU85kg7Z8tX6jP/9mFFvb\n8hf8ZQIhAIjOPtGpsCWCaRHbEAPFymULc9XxTcon/NaGcGwwah1V\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1064", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1064` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAShsAODwZQ2kZXxNkmMq0WOwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhZmZiN2JlLTIxMDEtNGYxNC1iOTA2LWNhMTdmMzNlNzExMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk3ZDNjY2QtYzI2\nYi00YzU2LTkzNzgtOWZlMmZiZTg0MjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzCTfhTYouMXo+m4t3BmEbEjp08w9CvkGkypBnKnDmd8CPEjzHYj8HWNXgnx9\npGmdGJTlplJGD5brXjzWTwX61KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiDeAsyeMWnmt/T/lDfW3kWWB4s0wHwYDVR0j\nBBgwFoAUenOyUai4Azhyg+x0/RGjRNv7tH0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiA0Y151R8g8MVhd\nQkUHQrNGs74uRXg2SFPXSRYLTiFXFAIgYZsfHgtT8O1/BJCVOs1e5Pm5fVYtK9W/\nWDvnE7xN4VY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXt158ZoNme69jCfeHq9SSCfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWZmYjdiZS0yMTAxLTRmMTQtYjkwNi1jYTE3ZjMzZTcxMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSqa54iSRL3+yHVOUuztpdEb79w7koaIhlmxVX8LaDyYX8\nD3yyBW8oRlEAEsAbx24KxfIzbhUW/pW4wNUDZztOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUenOyUai4Azhyg+x0/RGjRNv7\ntH0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPczkAaJ41EblbCgmiJ6H471Y4eZjzQnZqPHF3JYfM53AiEAgsDmEaKp\nGtEs7i1e0nERcOyBdSPIUQgWbjfCrx6qX7U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISATQOULkqN1Nr9XXY+mxy0j/VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk3ZDNjY2QtYzI2Yi00YzU2LTkzNzgtOWZlMmZiZTg0MjU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc0NWU0NzRh\nLTMyZDAtNDBjNC05MzFjLWZhMWQyMzAyNzkwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFP1F2TEY5rrUA9podnfs+wdh/jpc/1kl+ANUWzhOuzscBjAnhLYRyoZ\nGMbHrLvXynHleirOP7BQWtWBz+xAHn6jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIg3gLMn\njFp5rf0/5Q31t5FlgeLNMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIDvRZPgswZRWpVQNV76jBcbEaH6poRzz+1Ve4Dfq\nTorvAiEAq11Okw+IlHJNMrQLbwdoym7KnCWEZToyA2ppE6hdeY0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1065", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1065` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQmgkxZSc62rdoM5Hp9ZnudbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlYzg4MWE1LWQyMmUtNDI4MS1iMjZmLWQxOGRiMTNhMDVjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDUxZTkwYjYtYTlk\nYi00NGI5LWEyZDMtZjI2NGJmYTZhYWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJmzakCjjLrUY9hk8Hf7toiHDguLPT+Z5SVK5PnGsWUBhr1mvk/Xv4ZS49Nj1\nW5+aU7d4yUBOjB7OKPkotfuB3qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUILJ6qhHXNfiiy0Le8hUCxty3lrowHwYDVR0j\nBBgwFoAUhxULAZD+NnH43Q1t9gklV7nf6iMwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA8u97Aav/iSG5\nnHaXYxOd27e4r8TsHdeWf+D5TfpRJqECICkVrASl9tLUzIU0TSqw38HfWKIvrr+o\nmmhpnk98Ww1k\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASPnTurXsjXjj/e7DC+xyl9KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWM4ODFhNS1kMjJlLTQyODEtYjI2Zi1kMThkYjEzYTA1YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRanCcNXoV8sNRGyFcEvQheGcunhguSnTkDTfPXvz8qN12\nanwQlAgffNrpieGRMGHv47MIbcGwNsQ0YebO9Qw8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxULAZD+NnH43Q1t9gklV7nf\n6iMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ4mpu5G7jfEMuXzfczTc5SCqJu4UPP3ijQQoE+rxhT2AiEA9QZ3ife3\nm5lSrMtiZhRcJfzmM8rNBHQLcmVnnzp+MPs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAZbdbwWxug/f8O7U0NIuLFbCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDUxZTkwYjYtYTlkYi00NGI5LWEyZDMtZjI2NGJmYTZhYWM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFiZTBjY2Ex\nLWQ1M2ItNDhiZS04M2NkLWY4MzFmZjJjMDliNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBXpNfQ8C8E5NAtIA47GYWcD0VUCi78ZsSwTAD08K7za3Prkt6Z8VxBC\nShpjniERqaD8FdQ4OQz7TbNfN7Yrr7ijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCCyeqoR\n1zX4ostC3vIVAsbct5a6MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDu0TOdeAj57Rz5oChkgWnVuDkj5/mhnDlUSwOY\neE37qQIhANfaoeCOfwAbMhcGQwjgqB7pBk1q+RZaa/C8UERSZ1jE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1066", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1066` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISASsokyezL7EQH5QwPM4F3+ElMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyYWI1NDVhLTFlNTYtNDlhNC05NTczLWNkNWQzM2E4ODhmYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZkMzY5ZTYtMjMy\nYS00OWU0LWFjNzQtNjVjMzIxZWI5NWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECDEsGZ5AssdFAu4AecO22qPVbaX9Y68GzgcVFSvfL3NPbEpf3/lOxDLV3cd7\nORxytYaUiIfGZqINl8NpyNHkSqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtZPj5QmbnKcWjqwTNqJqTE5j1LswHwYDVR0j\nBBgwFoAU5+6/Jot8VfEfKOTZp0H5klxif3kwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAuMQD+Kft7U3njLfmf75P\nLNf+d+igTAMu1v9c/pEsXWQCIH6uDNTjfXELerIs8gnPsSKWV87tva1YMUUPc+om\ng0JS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdro9nNcA5fTplKqrxu9kRoZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmFiNTQ1YS0xZTU2LTQ5YTQtOTU3My1jZDVkMzNhODg4ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJEY95NaWMqVUwNIRYvpc5FHs72N7z4XvyJeiEAvlq6tAI\nt3Q3LNkAX6Srxv6Fwd3svBX4mQcbp9hkD7OF/UzLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5+6/Jot8VfEfKOTZp0H5klxi\nf3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANnWRlJ3TDQ9QN0QKYS8Y+Y0aqDHi7vtFzUkEvIt0rxXAiA4HvzUH1WB\no3stqYMTlQdvZoX1qTpCQnOUCcTVb1TJPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAa6wsFmgLm/oG20qU33H6BJSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZkMzY5ZTYtMjMyYS00OWU0LWFjNzQtNjVjMzIxZWI5NWRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVkMTBmZjZk\nLWQ3ZGItNGRkOS04N2IzLTM1ZDJmNTE3YjA3ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCPnuArt5FyzUWoM52Ou1Mr9ECbnpqtwjURkXDQuuR/enC6Q37ItWL3q\n0aC3RXfPmBDB2ZLSCcBcyI+QKn2Prh6jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLWT4+UJ\nm5ynFo6sEzaiakxOY9S7MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIFDUjTkOrxNCCvdRsrf8KQ8SVr+LMRvg0JAI+nJw\ngDFPAiAgng6vAzpB6bmncAp+JawBmr06uiqVWM0GXfCNSycv8A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1067", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1067` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAZlBcWRXqplyjXJM9QAfVORHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0NGExODZmLTk3ODUtNDdiNy1iNTNiLTViMTBiYmY3MDQ5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAyY2E1YzItMjcz\nZC00ZjhkLTgzNGEtYzQ5NzA2N2IzYjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe/jJvWz88P7R0uX5WOghB9Bpnjapo25xUBeIJEJJ1GF6NCWw7mwmLbBwxfdk\nilj7TOuxYYotQifQQoyPN9trdaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfJ3FfH4a/8ozI8TBQVK5/sUF5T0wHwYDVR0j\nBBgwFoAUwoXaDQvACL6Df0y5mdYL+yo1BKUwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBLsTns\n5YQm1ZAa83hX2ltNNdR47VgMtQcShxldTziYrwIhAIT98tfeftNrmU9LJw3qUWCV\numjWZBy4Ej6CIY7yGSPu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWrb1YZcW4fGOw/m7omKaykkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDRhMTg2Zi05Nzg1LTQ3YjctYjUzYi01YjEwYmJmNzA0OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbWkodjV/fUmJiX9443pzAuuVca7GfF2cidyZxobHE16Bd\nDMIqQHwYxueGArThc7FS5eLS89rA05vQ5am0B7wGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwoXaDQvACL6Df0y5mdYL+yo1\nBKUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKB5ex+pAxvmLtyZ/2iB44MDdCLinOu8edV3CnttgaCUCIFPVzK2Zb90p\nKQnx9qM9QLtIcWx6EXslgzblG6ty7P4T\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAfkvfuehvixg6N15JsOKl2wZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAyY2E1YzItMjczZC00ZjhkLTgzNGEtYzQ5NzA2N2IzYjdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ5ODQ2ZmRh\nLWI2ZjQtNGRmNC1iYzNkLWY0ZjllY2RkMDlkYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABItJ7xySFWKAElaCty7PzCgvmffryK29SZbpvgmiUdhGiSAU7GyGhCWp\nbw6Y792mteONf+uwbhyaZ5itno7MjLWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHydxXx+\nGv/KMyPEwUFSuf7FBeU9MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQD5oWug1pErgNenRWoYHazj+nLx+v4o4U9/LFCb\nWuc1iQIhAKB8u6amt9rFYIQQkU/07Wex61HF3nZcd0jYjvoszDr4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1068", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1068` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAZ8ntxOAMYlJThuye5iyvC2iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiNDUzODdkLTI0ODgtNGNmMS05YzYyLWFjM2FiOTRjNmZhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI2YjIxYjEtODAz\nMy00NjEwLTg3YzQtNzUwNDc4NDc3ZjZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEid2+eQxNZR4DG2ShXbzbkKzTBc+ZO7MpNLV05WXwyWU80ljYly88gAXPI+/5\nz0VagOsOrC16yxUG18PWNcDtF6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDAwjCPgcOnnkI/NRhuzFZ7MeDoswHwYDVR0j\nBBgwFoAUGtLuzhruj0RiYq9VgoeU1m06jGIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiA/BN+7\nkCuBACHf1TeDnx2itRwq1doUZ4veGt+PQ6K9SwIhALWqQ1KOf3JURcIZPL2cUgj1\nU4gHJxVZwuGAO9o5+BEf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ//CFcX8qoL8k2SoGFDUIS/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjQ1Mzg3ZC0yNDg4LTRjZjEtOWM2Mi1hYzNhYjk0YzZmYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUNxjs9MaesW7CA77kubHqXTecsaeEbYlslscQRdweGGfX\nltR936BvYCYkMVwsHFgTDzgL78/G2p49oi8LeHFLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGtLuzhruj0RiYq9VgoeU1m06\njGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALgluKPDlN0jnVaCJMLjNgOdH5uqMy8YxZY4XgQsxSFiAiEA6xnqierK\nxRRc6hWIwLRA5v2TNGBGUvH04y8PgLy0wMk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAUP+VU3nWkywXlSplPm70edTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI2YjIxYjEtODAzMy00NjEwLTg3YzQtNzUwNDc4NDc3ZjZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk2MmExOWRj\nLTdmY2MtNGZhYS1iMTZlLWE3NGE1NWUxZWRmZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLWtpy+sieexaIs12ostWEN49JPUAJA2s5wWJXj0+KG/gLMwEaKsuZZD\nQitkS/BYBkWLDOJ0lfwNh1Rf9mHPRbSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAwMIwj4\nHDp55CPzUYbsxWezHg6LMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIBAutrfo7NqwlZnx9NU4b/of5ZDQCNnSJsU+HWv8\nt2FtAiEA0DYIDAb+DKqmXO8wTW1fi323IUvsVt5DtGoiSUjcCs8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1069", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1069` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUZbu3MiD0bBKHeVzYBKk7IwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ZmJmZDM3LTY2OTQtNDM2OC1iYzI2LWJiNjhiOTYwNjc3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZjODQxMTEtMWY1\nZS00ZmMwLWIyNmMtODg1OTNhN2IwMDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj3yU/Ws1H1MSW1Oa4Jkl7yB6rkQHcxPryHBhMxvA1U+7SKrgnBN1n2I/tmMP\n7tBxkremEtcOD/ToB/X7ILJB26N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDSBi6L1xgCLqXQR2ItZwWK7qHbjMB8GA1UdIwQY\nMBaAFFhsUwb1uHaSMSu54FEfVNbb0pFJMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAa9f2bWaWU+Irx/WPzrik/tMZXCr4aeMPz\n1F2DCEsE6gIhAIQHVOOFidSwe5k/ABsHnBSrq4qCtKGYdapw2TNdd3+g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASj+iNsjkcNZoSGz1kCWg9VrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGZiZmQzNy02Njk0LTQzNjgtYmMyNi1iYjY4Yjk2MDY3NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhLOjnmlAXJTgcYSV5e5fy3Jk8FX2goP4aJgA6ZpsS0C2H\nJ0YsR/VqBwo9v5Xc5HXi8/AzRDX1pMGlryJEIWybo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWGxTBvW4dpIxK7ngUR9U1tvS\nkUkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG7nT9cWR592EkVXUUV/zBLauXjlEdYuPOzYWwItqwa8CICBg/t7jusqZ\nWL2Zo/JgG2Z/tIJFGWNK6hmquzCMLDgs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdQxK7Uz4WaqQUAzMm1PrHorMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZjODQxMTEtMWY1ZS00ZmMwLWIyNmMtODg1OTNhN2IwMDgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNiZjYwYmZh\nLTM3MTUtNDU4Zi1iNzdlLTlkMGIxZDcyYjJjYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCSF2dFo2PT47449Sq0uX0TfJy3mMPKmmcXLXMe9LwZj4VoMs9bNqsCj\n/MMeSSSW/OjejqqBUEq3vsJi+Zi8U+ujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDSBi6L1\nxgCLqXQR2ItZwWK7qHbjMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQDoExOYDXQUkbW3xajbYLy32cwz/QZ5XAKBBkZj\nn5qFtwIgNTVTI8WKySxC93x37MTkxffQYwRpcgzdSfonWqz04SA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1070", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1070` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAaLBputN9ZmJJVjH7hGWxCoAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1MDk4YmVmLWFkZDEtNGQ3Mi1iMWJmLWIzMTViNTY0MDJiZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRhOWE3NzQtODg4\nZi00NDMwLTkxMzktYThlZWQ5MDM4NTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKok6jGb6KepV6D/gouHFXZLhJItOXIAg2QnzEpb0WOF06kzBm3v4DwDrB3Y5\ntRNsNar3LrKtiPy5bvVifYyW8qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJopgSch/D0TWrL0LCaLCrZ93XBQwHwYDVR0j\nBBgwFoAUiT1FltCsJ+qT61wrauByVlg+fLgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgBXl4VkwHN4FH\nNpZdklFY/KEUMqqtMI0hCDkQ+wqh6/ICICY0yxuUCDNqb4YVRK4DHCPH8IocriyM\nohDABwinmbF/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUGF5kz3+WXoegcF7BsFJvEAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTA5OGJlZi1hZGQxLTRkNzItYjFiZi1iMzE1YjU2NDAyYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGYhMDuSJj+0cfqM9eMXd8M9T7ZHmOMGt4I2Gna8YWPv8v\nzZRC5M7v1iur9PQc4Ta7i0WYV2/D/YJ0OhbEyt4bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiT1FltCsJ+qT61wrauByVlg+\nfLgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPff6B0uhlERY4dpTcOhTWpo/qIW7/msuT/B0DPyBgo3AiBLpXF71mWm\nRnYsw5kyZkE1YGSPth3yty4gam/FaDhFgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAYNMSI/BmMCc0LmYPjMx1l6gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRhOWE3NzQtODg4Zi00NDMwLTkxMzktYThlZWQ5MDM4NTE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIxNWU5ZWNl\nLTRlNzktNGE0Yy1hNTEzLTYwMGViNjkzMzYxZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKUtdiFSimucn5YIKSprEsmFtymOqw/q7cmuIUv6jqYWX8HTAqfbFLNb\naPGHkKIIg9fSbhOgNofClhSSgFFwDcSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCaKYEnI\nfw9E1qy9Cwmiwq2fd1wUMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIHYlFvcbpFBCK5VLRaUpFX/IUwKJJcx3oCsANE36\nflxJAiAru1w3xFiU6kF0m7XVyj3HUFU4vPi5gmXErHUViWHrNQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1071", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1071` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAd/jFHOmrRA5ridLOAONXiAeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1YmVkZmVlLTA1MGUtNGY1MC04MGJlLTA0OTZmYmMxMzVlMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQ2M2JiZjEtZDJh\nMy00MmZlLWI4NTQtMjQ2MTkzY2E1OGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4pCxmbgSs1Ld/d0QD56VaYylcIvHNW2eCIFKIZeEy8DHnnAkUU2b2fOt9qUf\nfoDJ3oUnK8vNXwQnUEaIZ09B76OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTi9JhKN8671JBXolI6p1/V8s9rswHwYDVR0j\nBBgwFoAURsvfP7JTVaf81uAi5urlJnGOPvcwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMYnuIbwOtB4\n+qD2Q/FX1PeR8BgzctzabofEx2VYPMCyAiBerPxl9kgwWh8VTOYSDy75fqf2+m5H\niwljFFyYi/05BQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb4S1UcL2orGxaGavt0YTlGlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWJlZGZlZS0wNTBlLTRmNTAtODBiZS0wNDk2ZmJjMTM1ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYVRgHfh3Z83Rp9wsfVyNSiZwDh6PO7BtFGHqpIsVp+D2D\nnaulqO3EO5JVjK7yobLcx5fbqL5R0CrxbzdC8ZJyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURsvfP7JTVaf81uAi5urlJnGO\nPvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQO6TDnDUdC8iuNdOUzcwDdrnOIoVNEagJKfdNcWRN3cCIHN5wi1d9yAm\nYX9oenlSpRZOGWq5E48tjEwmhhktTn6m\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAYHjN/+zovLTLmF1NcrFlCiBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQ2M2JiZjEtZDJhMy00MmZlLWI4NTQtMjQ2MTkzY2E1OGM1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyZWFlM2Jh\nLTljMTUtNGI4OS04OWE2LTA0YTdlOTQxMGU4YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIRTXnCU2raz2xqyyLK7npj+aK4uTELP+WLCrt5kxKQk9O5ZX7DZPjXh\nC1j3b6HIFUKN7ZsdMOmTzg2ubE+fpYejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE4vSYSj\nfOu9SQV6JSOqdf1fLPa7MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIDHbOufA02UNtpguduV++IJ+2bKLWv6wJ0CsP5s8\n0R00AiEArA+bdy2xoZ8wKIx1HbEMumBMDIBZ/8vp7D0/BDIqpvE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1072", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1072` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASoqjWdI9rJjOpkaUWghKmzlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4NzgwYzI0LTNmMTgtNGFjOC1iYjM1LTI1MGVkZDdlYjljODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM2YjZlNzctN2Yy\nYS00OTY3LThiN2QtNjE1Mzg1Mzc0MDU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERV+E46pMUzoGSuUX7DqQ3/jjn53Rspj74h8cR91ctsd0tCVoAZQBtlnyIKfP\nFe3WzbVFPG1OMs8IY8XG7wjWUaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqDGnSlpHqXzndHTPQXWPRCp7+SgwHwYDVR0j\nBBgwFoAUbJhP3Ge0deXLO8zNCiHnxdZ4i+4wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDtwA0psz7l\nazpka2kBkFBbqAMiD5jCu3HMslk7W1XwzwIhANkR2iTiUELilRGah1INGCDQzDv+\nOc1CK9efXvbwyRSg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXnaH38FsnIEnxQMmDvv5JkaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODc4MGMyNC0zZjE4LTRhYzgtYmIzNS0yNTBlZGQ3ZWI5YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZllV//3aACT+SOw6b1hPfrOqGjPfr7cJr19TyCGLdHxL3\nXrX6F2hG8k3ldl0m14U+BpHLl14aJpYOVqP70hxUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbJhP3Ge0deXLO8zNCiHnxdZ4\ni+4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfTflhUgVFLh3x2Mrx9uvxY5mYOnYPKE2Oeue+VCDEYQCIHJbTd7gCJt+\nsvHu1eh2QAe5YQmrKjZ+9Jj2zuHZaRbW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAfjpyLL0DtIORCZnchcSS/UIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM2YjZlNzctN2YyYS00OTY3LThiN2QtNjE1Mzg1Mzc0MDU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3N2FjMWU1\nLWMwZWEtNDk5Ni04YzcyLWYzMzA1OGNmYzM1NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBfMKXXSBr/jkfAoi0sMZAfJL1nwZ50aI1Us9HjxKazmBZu9HJls0stm\n4sf8Mfl5Aa/YUFzAVaDYFUiiQdY29SijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKgxp0pa\nR6l853R0z0F1j0Qqe/koMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIGlRn0CygSnSzNWjJYon36E5J/z0gpCzvEd06AKN\nPvfLAiEAh0JqXVqUjRKl9XCEQWPE6QFiidVM1o3fBoQTHRfE0xk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1073", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1073` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcXGZc9ccONwlXogDI+JfiwsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMGIxYTBmLTlhZmYtNDBjMy1iMDliLTRhYWQwNzFiNDlhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTE2Y2VjMDctNGIz\nMC00NzJiLThkYTEtNzFjNDFiMGVkOTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEun7INh1d88jLgmbny0oB19ik9YskJfExJMS1XolOn81M1HNMdXWWYkmaqKk5\n2muA9djo2jXaK7LkLT1b4T4dhaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2IrG3dSnbtjx69+6XpRZxg03OmkwHwYDVR0j\nBBgwFoAUoo4VfcW9h2LjNsX93mVUSi6tDQswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCoZU6DuodLM8rtevPH32QbdTYIstNpgVuvfTSpyxIakAIhAPqYiAVwG5+8\nYq13m22grLwSWdRsZtrSOnsuSbwPVtni\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYBBHz8hYesJtWNOxbKVk+D9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDBiMWEwZi05YWZmLTQwYzMtYjA5Yi00YWFkMDcxYjQ5YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTA0OMYitEY1ayFrel8Ks4DiherXJaFNIeo7TICd7tQ8dR\nOwpLfXd5gmMCrCFbeAAwnhTEI5q6JWSnYvX3/Jcfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoo4VfcW9h2LjNsX93mVUSi6t\nDQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK/2DU0/Fbx5y+sIaF+nb+cXwNIt/6pPQXjBT2SVeiu6AiEAwUKvJefI\n5P2u08+ZMZMokFyKQtdSB23kDEn/e2uq6Tg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAY/iBGfrIoQjFsjwsS4CZwacMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTE2Y2VjMDctNGIzMC00NzJiLThkYTEtNzFjNDFiMGVkOTZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNkOWMzOTM4\nLTgwZjktNGM2MC05N2E4LTQwZjQ5ZWZiZmIyMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCn793aH18Hgb9ScErbEs+YYG9k79v8F22/+PJ6LbljNpTJ2d9eX/QKa\ngtJUfLWuI0Ydf5WM45ApWU9VZUdpM/CjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNiKxt3U\np27Y8evful6UWcYNNzppMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIG+bnEfvufhrMQp3/PK3h3gLVnbmV9yTnHbG5+Ox\nDMvVAiBXbZohFWLsDrSZrvfkaE60GwgXR0LwcL/6yYJ87JH/Gw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1074", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1074` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARgHhtsPfWxbBxUNjzlKnVVZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4YjdlYjYwLWJmZTYtNDgzMS1iMDllLWY2MGQ1Njk4NGM5YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQzZTk3MGUtYzY4\nNi00NGVlLWI4YjUtYmRmZjJlMzQ5ZDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkAKFmZPfNH6fqAXnKfkgZURNyYOQ0jk6UANyJlD63F/m4bpWcZxG2kiO+E6t\nFGacWpjQaCK/qL4AhqArzXX/56OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTm+dGzHV8klm5t/FnlzlY8cDq38wHwYDVR0j\nBBgwFoAUsgEJ5V+4wkUYWBy52rcwdHY8CvAwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCIM8Hq//4eObiMDOESI2Qm3bjQl8vbq1Rd8juquq1czgIhALG4Fxxcho1B\ngXuoS8hrd9e3ITo2RlGslMSJYCQsxCL/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXILu04ypfT1C4mBsH36CoAwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOGI3ZWI2MC1iZmU2LTQ4MzEtYjA5ZS1mNjBkNTY5ODRjOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9Q90yo7jc49NkSFg+yz2mIlIAH9ocq7GOxE5lTyZz//2h\nTaHKG6D/Bwqa4vWMbRJaAqHz9im67QJVAGL/8bayo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsgEJ5V+4wkUYWBy52rcwdHY8\nCvAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCmEeNrxrL6qINvdAYConLr2tq524mowixv7FObleOAUCIAgnLTbREbsN\ne8X/w/Um8rlfLvymy2WgT6IVvhtb3vTX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAVvej6erRnvjGeXWNG5MEY8TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQzZTk3MGUtYzY4Ni00NGVlLWI4YjUtYmRmZjJlMzQ5ZDI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3MGY5NGU0\nLWIyZGMtNDA0YS05MTQ4LWM1ZGU4ZDljYWMxMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLxf3OLNztBjyVggNj45gCx/S03oafY0NsqCri6TiAhpmQ67iovhuviq\nVnEZ7YTddQ873F5mIwVF+vdKdtvvcNSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE5vnRsx\n1fJJZubfxZ5c5WPHA6t/MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIFDiR9JGfTtVfDr6E4lSvtelnObEbTvUtfNST34G\nl7D8AiA/pfzX/oUumlIpS6/2jxTXJzJ7f3jWA6fiay0+9l4CNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1075", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1075` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAZoQ+04qHQLMe3T073oYczE0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0NmMyODJkLWEyOGItNGFiNC04Yjc5LWY5ZGQyM2RjNDY2ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTUwMjljMzAtMTYz\nNi00NzViLWIwY2YtNGEwMTk5NjRmZTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHyKO7sUyg+IOR0GPyw91ygCNvVnhSJ6/bNCXpAzJZSFZQJnvq9hR8iWsf14g\nsRegcu9BcX2/Dx82XTEAmAF8qqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyfCcDs2zgScEG3j/CoGb7cyw+PQwHwYDVR0j\nBBgwFoAUcUYmkM2x4MqbOZIJ4UiwsH4sJyYwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICwT\nWCn3E7skyHtmp3UhspwKU5H6hCakfe7C6bhUEempAiAEMlzcyoz4UbB600ZRQVU0\nCNm/bGYkW9lHOuABtqUtNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWrqPXanC9ZexV+nMpE2UVMtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDZjMjgyZC1hMjhiLTRhYjQtOGI3OS1mOWRkMjNkYzQ2NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4l87Swa3ijfaCXjIy8zL2k6F4xlpPpyj+yobnKguAt3q5\nMLu66IK2MPmUtLDM2E5PHP8bcUNPx1nCXJ0q6vMAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcUYmkM2x4MqbOZIJ4UiwsH4s\nJyYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP5DtOL0TkcONwCnVC1yBQQox/l1pmRmjRllZVIoSO0YAiAeM7hWL+g1\n/VSM/9h3tWqdPSSgsA7OGZjy+uorfN0JGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAdp0Wi9hwO6iRsY+jDbvdQ9rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTUwMjljMzAtMTYzNi00NzViLWIwY2YtNGEwMTk5NjRmZTEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM3YmZlM2Q0\nLWIyZTgtNDFlMi1hYzhjLWM0NmFjZGQ0ZmU3OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEs2dkc8UwfW+VxjeRAglx+6pOLPB1aS7Qa5Lc4CCV10o3xyKEmBxPQj\neBuDyjH+2V65vtYNBqH9veuVaGtfDnWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMnwnA7N\ns4EnBBt4/wqBm+3MsPj0MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIEFyBxAxevh4YiPLz+0PmHCnVNzdANLttVWT4glB\n1B4XAiBFQ7YlSSwbEXD2XjyoZnbDyKkE39K0Iu4zGOJs8esMBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1076", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1076` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAW8j4iunsHd9n7SiTruKcUZFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzMzhjODJiLTk5OWYtNDdiMC1iZGFjLTEwZGFkNDdjZWJmZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRlMDA2NzAtZWM3\nZS00MjNhLTgxY2UtOTI4MDI0MWY4MzE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJzM6gZEaxAuWvapWDOD3P5bZoy7XZvgPE8gXSMB7gZ4uN7SeDYNyopnBkqTH\nxkNJIdSmkV1hbwZbPezLb81jxaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzHv/gM0BJAzkk81+C388mJ3tnn8wHwYDVR0j\nBBgwFoAUXgIPdgGem8r5c1TZ5mI4YUAIEaEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQC9YVl8QERIhjFpd8uNc4vQv6xI63JdR4jTzUdkEhFSnQIgBTtH\nvl2rUT0+7LL8wfofjfUUpx0h+ypwjkYABwpMWIE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa/Wq2lNb7OpUQEHPHJUarseMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzM4YzgyYi05OTlmLTQ3YjAtYmRhYy0xMGRhZDQ3Y2ViZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVDusc5AaEE0O7HcmI9IFMLj1umpXSwBdcc+1Crhkc1lPK\nNZlACOWdjJD975pD0nDhkczYv4Cj26MYiiNqVPCco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXgIPdgGem8r5c1TZ5mI4YUAI\nEaEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMVJKuw7NS8mKk2gxK6j19e8kuDL5fOSp6aBJrGGiHDLAiAQxAAx17Nk\nHZoPsfyLHkpSQnullCCKhxBC4wk9dOyMAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAZW4+d+F97WM2qFxAUUJw3OrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRlMDA2NzAtZWM3ZS00MjNhLTgxY2UtOTI4MDI0MWY4MzE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkZTcxZGMy\nLThlMjgtNGNjOC1iZjAxLTljN2Q4ZTc3OTI2YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBO36HEMrx1wDy6gPYM7dJA8wVGPo6zNmIbbMUo+gD4J8rqDh0pAbAlD\n+/rkjdNMdEVlCOooh+HDWw0hAinJUAqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMx7/4DN\nASQM5JPNfgt/PJid7Z5/MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCICo8jNlx62hR8K1eFpySyXG8Vt2ZBRMitbSKkVTo\nu8EAAiA/1qfmiPRGDj5p7aTT4zr43id6MypjJdvdshieDYcYKA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1077", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1077` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAUbz7P7XdHQ4jp1Ey24cQ4H1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1NjlmMmI4LWNjNDQtNGI5NC05OGVjLTA1ZjUxNTBhMmRhOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBkYzUwN2EtNDg3\nOC00MDY1LWJhZjAtZWRjYWVkNWM0MjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7saNVE7/nFhJYyEfhxnw08kCjGLznUmPNjvHACnsFFLHsL6qQF1damEyqSLU\nplnC07zdykUORABJLVMBvU81V6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcH39CfbZYRMJN7PvusxASfHEcWQwHwYDVR0j\nBBgwFoAUFBri/8mrQRYjqf+VUjs5IQhkpiowOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIDVWvoFJDmuULmzB1nTMLhQHWYcnihV1WR1Y3U4IMGU3AiEAlvCB\nar5luGEBp9GEjc+Fh6U4YmlOCiGNAFhBLej2r6k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe6Koqb1V1UXqp7Uwzap95vSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTY5ZjJiOC1jYzQ0LTRiOTQtOThlYy0wNWY1MTUwYTJkYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWVYPFzTItqaGNZl3zGjOb3oOZmjPKCZ49ldkD9zECV4FI\nsFRKWPpFd/jLt047BP5Af3hKJx2iXu11Opg2Zoo9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFBri/8mrQRYjqf+VUjs5IQhk\npiowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAJyIsWSxx+PqZW9FkBi/dw4OF+JqV995d8QURKRYyQtOAh93g+vKmEeI\nlUIg0ebYjHmtpfFuySmCylOzOtf1grAA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXZ+BZ2j4yVIsDciplrVedavMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBkYzUwN2EtNDg3OC00MDY1LWJhZjAtZWRjYWVkNWM0MjRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEzOWIyZjRl\nLWI1NjEtNDY3YS05MjM2LWRmYjRkZGE1NjgyZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHl3es6flQLux28jpRQCSCZTJ11iCPAiO8FtXl9VD+gCgp3wDSbzXtTm\n4KWblKPmOmHKMt8ruoxVis+IXriKlBujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHB9/Qn2\n2WETCTez77rMQEnxxHFkMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCxfU3yulvC/eesv8uks+B4PTydLQXL9sPCJYEe\nlQ/XDQIgBX3crNLWbp2B+7xzfelEx87Oj0zIPCESdzadv8JMNaY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1078", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1078` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAVmlUeIqvlR7Qktwz9SQfyLfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5ZjBjNzNlLWZlMTgtNDExOC1iOTg5LWNmMmU1MzlhZGNmYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQ4MTAzMzYtY2Q3\nZS00Y2QwLTlmNDgtMDViNjk4OWI4ODQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtOG+36w+Q/JiVkhiRhnDIYUHnlC/zIqK+AQi65qY2il7ZRDr2j3PRY3n4Xq9\nks06UUG3plztpxkR+ycuDxkZMqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFA5Gwhcdx8hIk0gpz6fTZlkWYlQ/MB8GA1UdIwQY\nMBaAFKXFPyhcRqyGC0kaVNpuCcoaSNWyMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAl2JWeDf+OxBQmb88QAcHyltAjF1o9MbK\naTJaUSibfKECIQC8Ihm6sVNQFDpDFdQ6de4SxjyAaZu1E7sVXuN/UHIrvg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZe65e4Maruxk/hu28A0CkhPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWYwYzczZS1mZTE4LTQxMTgtYjk4OS1jZjJlNTM5YWRjZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATScwfV8Hb02V3Vp0j9t5R2bbqa0jWZqm1EaYOb4lqxGLC6\nw/YsZh95QnivPIueF6Qjn15t/dpPbNxmJamV3JGbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpcU/KFxGrIYLSRpU2m4JyhpI\n1bIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALnSlcVARgNt2DWtv1OyorbglxYDzKHBT+pydhjXEtcPAiEA3zRy+wA/\nUT1CLEAZN4+dQCw/ls323TYPT7/3qErA5q4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISARCQ48bh6IsPab3G0ruMp4qIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQ4MTAzMzYtY2Q3ZS00Y2QwLTlmNDgtMDViNjk4OWI4ODQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQxMzExZTRi\nLTBhODktNDNmYy1iNWExLTNiYWY2OWRmMTMyMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKnI4cbtWG2LNSp5XXpdbnZS89XyLTsCrUuQu1Qxt7z+rEcX9DOITIKa\nneep7N/pwDxQ6deBXCErTuvstYjNtoWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFA5Gwhcd\nx8hIk0gpz6fTZlkWYlQ/MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQD8zwnjDzIZrVUrBwKk9pZmttWhNFPOE7WUmccN\nSza1eAIgG7dMGDC+Xl0UqTJHTdC9LW/y9An+QRJPF2t2FfOj4Jc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1079", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1079` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAf5Tc4auitDtyx/oOF2A5EPCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzMzcyZTUzLTJjNmUtNGNiNi04OGI3LTk2MGEyZjQzNjRkZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTcwYmU4NWItYTA1\nZS00NTYyLWJhNGEtYjEwZjczZGI1M2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE33+w/QN7Yxo2/XhrdW6/Y9OHfS+TK+rTOTh/zoRcq4yUPAVdPEinFgJmu3Gh\n42W4n+yHX1buLRnnXhyzt0HbIqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWuYAukrfNvT8Z/6+dniQQDBp37wwHwYDVR0j\nBBgwFoAUXngHWQZqY/VRSbmQSH7akxmq2k0wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMcWuTtzGYLM\nkN8MiMQuXkBUsL4hHnK4mUMRO9B+XHE1AiEA+bgJyCQHnuZNdE/T5gHt2h7jQEvG\nabJJgpIAU5gTcBk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc4h6vppZFb2IyIs79HTjsdjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzM3MmU1My0yYzZlLTRjYjYtODhiNy05NjBhMmY0MzY0ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASM9zFkEOkfqzxdOmMK+KMs2ecrJA45mfYko65lBh/VVORr\n5czybL6cdpH1LIRvN3mqFJCiPcF36sAnxQOUmYj/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXngHWQZqY/VRSbmQSH7akxmq\n2k0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANrhjtb6O9ViyGsSL5DKqJizXsJu3VRJlQMgXzIQbXDtAiB0wgKEN0sA\n0yHX/gNEV9psmMor/AwwQnJCYxWpMHc3OA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAffuMg+F9oo6xJxUhx6KKkBGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTcwYmU4NWItYTA1ZS00NTYyLWJhNGEtYjEwZjczZGI1M2NmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgwY2Y2ODFm\nLTBiYjUtNGQxMS05MGQ2LTVlNjk2N2RjNTI1MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMdGVyFTf3lqTX8m1dpdUitB3bPysD8pz+8tAy1bzgTPlkt1gBSb94er\nNVJie5Kr/iQ04q5PgvNLD/zej+fxorWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFrmALpK\n3zb0/Gf+vnZ4kEAwad+8MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQD+9yAhvAaHqk5cojWruu+jI8KE27yAQk6RAu3m\nWPKyBQIhANCdgg0WQNQSRmfJmsjhlOxWISybWND8PM8EsbfTID2r\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1080", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1080` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAW2gL80MGkY0NtEYjv2HaTOlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzOGU1NmIxLTk4NmYtNDRkZS1iOTMzLTljYmMzODE4ZDVmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmUwYTE2ZmUtYzg0\nMS00MWZkLWI4M2EtM2IwYzY2NzBhYzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENt0BklOFSIB/1y9WUiGQXI71CC5M/WSOZW3rNtT2ZVI6ZfEuuz7S+948/2pe\npXwXRj88Q1KmQdDpvntS7qJfcKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlcJ85CQaxNbGppHwznGpOaGZsbswHwYDVR0j\nBBgwFoAUL7fi4ZaXNhQJVQ0+cPn9Sfm69PgwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPrTsVlHuc0j\n8S+iehwIojp1Wq5F8eE7YD1sKiCaTE+4AiEA4DtUYggkaHninOuWrllyGp5i4u9z\ncV07VpjPJ3P3b8k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ91EKVO5lGtsDbsaQ0e+H7FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzhlNTZiMS05ODZmLTQ0ZGUtYjkzMy05Y2JjMzgxOGQ1ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV3SRqgL+6fcCmmVUt3HoOPzLfNwbMPx3kGD/N6n28eMmj\nd15vRQCPhdDMYGl7x1qTAG6P8W2Ha6bZza5TqG8yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL7fi4ZaXNhQJVQ0+cPn9Sfm6\n9PgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIACanh1xh9bvOFbg+rre2JxQDgkeDdEsxel2QuME7sRAiEAwfKSvsm1\ndCTe0RfqkVOjH4BlBQZRxZ87Owju/6GAYQ8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAUQDVMwIofG/vkXfRQjGS0iVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmUwYTE2ZmUtYzg0MS00MWZkLWI4M2EtM2IwYzY2NzBhYzIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYyZTc2YWJj\nLTdkZjQtNGQ3Ny1hNjUyLWRjNzlmNDMwODRiZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABON9xyEp/FbIk6P1VOcre6F7iwKQBuuo1oJt5gPF88Aa45wDcPRXqwnJ\nChVSN9AMTdXut5S11ph5B1FaDh0/ITmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJXCfOQk\nGsTWxqaR8M5xqTmhmbG7MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDE2bMPT3BWaqVeIcyEfDJ7hEwctuK/ioX3FsU9\nuEZ1iwIhAJ3Sjyhn4zw+Uy/GgV3YyNAA7Sv6UEhmtHG4mYlaySLe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1081", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1081` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYN5z5TgsD7VeanYIWJE5tWJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZjY5MGQyLTI3NzUtNDFkZC05ZGE3LWE5NGE4NzU4ZWIzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVkNzk3ZGYtMWMw\nNi00MTkzLTliZTctZTM5OTIxYTM3NzdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBSAJcojUaQepMYLfN1+73iSVulXmQit/u51F40TXC4+GKpgklJRd01GXGy1c\n4ucXEljDcMz9jSGCLRmm1URmXqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIgiuo7P9hKVS0G8MbVAZWCDqIAAwHwYDVR0j\nBBgwFoAUshcY8UBN0X9rfiZQH9ki1QiXf40wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGJQOEfO2fCQ\nzzb9btqtEEg0H3w9kEIIBKKkvW2eVxzNAiBLvmkJ0fYb9lz+9b7kN6pUDZzPOgeC\nL1/9ZPmmFq+XtA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZYkm647ogSAKtqqqdZfFzsGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGY2OTBkMi0yNzc1LTQxZGQtOWRhNy1hOTRhODc1OGViM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEySHDlSwgDgihf9C3rKfP8RmiZjeUqPhO9gtzba7l/pXR\ntVTG6phUPcplPuZ7j9SmcziMOnI86DfDWhn1rFG9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUshcY8UBN0X9rfiZQH9ki1QiX\nf40wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTfDH8ZJWuDx70DwwveeDMGA1jqpFCoZXPGnGNjObHzcCIDXHfoL4ickR\nBqKDzXmfTHAard47rMrh7xYGev+esRPF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAZaigw7clpUwBMz8FAz6Wx98MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVkNzk3ZGYtMWMwNi00MTkzLTliZTctZTM5OTIxYTM3NzdmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFhN2IwZjA4\nLWIyNTctNDQ0Mi04MDFhLTIzOTRiNDczOTk3ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNW4WMgjw4a3+DlpikYHCY3I+68HLfuWvIPuPoRBmTN9k/kfvErujXRs\nA/Gutl8Vn57RTRZMYe7UCMUIKX9GoJqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCIIrqOz\n/YSlUtBvDG1QGVgg6iAAMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCICiiJoUSU7WYJxax6a/mAHbIpILidYUiwrA2BwMb\ns+TaAiA8C74RxbIvddF2Z+rzbzjkxezOm+Ckk26oTI7kPw/XQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1082", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1082` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfsUmE0T4OcGhInRUjxXBC6DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhMmFlYTM1LTU4NGQtNDcyZS04Zjk2LThhMzAwNjk0OTIxYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y0YjE0ZDAtMDM1\nYy00YjRjLTg0MDctMDAwZDNkNmEwN2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJc7GHp/mzbQ9zZ1LqrviVHAOgB6lurXdk0tZyLyxCxHFsd0L96Q9pMWOBAS8\nbkfrSmXoA+hYf7ONzPkR0EQasaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG56ZvV0lKNHVOygkkKd0z/grk80wHwYDVR0j\nBBgwFoAUhD6bYCv0gqGJ0U7Rf0j5GeqBxMQwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAy1t9TYDCgEB46kfBcCMg9WpYxHzXfyX5yFKZ8sX/mYAiEAkh/+P8nJgDbx\n9p/2hf0gCk/xgnsQJch8VJiV5yilD1I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQqHsp46e+gDdcKv5oY4xarIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTJhZWEzNS01ODRkLTQ3MmUtOGY5Ni04YTMwMDY5NDkyMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5okrF+S44k/6gP7olcc9vOcRGjYgfffzhIO5dRF6YY0YV\nyAAULyy2m/DPag8S/ybnX59dAO9PPFLQEGfKnZF8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhD6bYCv0gqGJ0U7Rf0j5GeqB\nxMQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU3d53NXY5hxgO3TQi/8un3g/dNLN34jTkuTXbd3SenICIETDZeizWtxO\nLXxjwQe16wtu1k26f0pY854ZAmMCgt/Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAWXwYGUEnrvoDTdTRY+bswecMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y0YjE0ZDAtMDM1Yy00YjRjLTg0MDctMDAwZDNkNmEwN2MxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdhYmZlOTE1\nLWM5NzQtNDkzMi1iZjI0LTg2ZTU4MGRmOTNmNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEOHU8MGyEQYb47VDKZfopkH2hoFKBoRlyBPcbyOYEtoAKLU2TV/+jD+\nrujSHmEGgygrZHM/w2dSKoAoYERMQSKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBuemb1d\nJSjR1TsoJJCndM/4K5PNMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCp3YTrm3sSiK5MVCPfFmYA3tX0pjUe01HhSnVm\nSxyN1gIhANfzHBKK0yvUnhXns5HY7I3ywSSBofYl/92QmMpj2f2l\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1083", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1083` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYixlYYisQ5+cAkjuS1Tx/d4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5ZmEyN2VlLWRlMzAtNDM0Yy1hZjMwLTI5ODAxYTRlNzY4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGEyYzc1ODMtZmU2\nNi00YWFjLTgxMjMtODM0NTFiOWEyNWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJkNHnwgz5sth4VDA5CeM67B2aWRePlHDIw8XjwEuQ0Bf7/QJN9BWGpEfxNNN\nmQ4GpfK5DT/BxgxWPJfhX7ZlD6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNSqVyNLFcVSuWaXONrJuZ0zYIOkwHwYDVR0j\nBBgwFoAU+Zo7qEdr9gnhbqxe0+RzK9Zupf8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIB+kmpk650B+AoHwGva4WA9ZYn5/9VfLLAmLpnOLp17/AiAIjl46moRbbck9\n3GezIM93LxnLE++Vix6DXHQPPLtt5g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcHjsI1Lx+2AyhU0iaQQu1+nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWZhMjdlZS1kZTMwLTQzNGMtYWYzMC0yOTgwMWE0ZTc2OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARldGOHUa1DFx3mLdhYJuSNrWeFHpM2A2O9EyrWMH2Mj8on\naxmzEGvlgszEOtT761d+y+4V4FLrdmGLf50widYmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Zo7qEdr9gnhbqxe0+RzK9Zu\npf8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeMPFLrzdBhC46uPbqZ4dfm88n8fL3UvbJnJXnsMur5QCIQCL+3XeMnBS\n6+kVfU1stRhzlCysjFC4MUsktwc/79qcdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAYLulO93uMTn67JHqRFmLIAkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGEyYzc1ODMtZmU2Ni00YWFjLTgxMjMtODM0NTFiOWEyNWY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQwZjgxYWQz\nLTc5NjYtNGY1ZS04OTFhLTgxZjU3ZmMyODlhMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMjD45NjRKYnMvpDb5NVIkLZoHDGzSxiuFkOFmh7+RNM+mZ82jmy/NF9\nAKv29/rh+2rf7vb4kMuJf794+CGZlsqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDUqlcjS\nxXFUrlmlzjaybmdM2CDpMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCCrC7sRcI0pE/259op4DvsIkYyNuRz7PFZNwK4\n91x/cgIhAMoXxQA+h5O0ayoFGjdErTp749l3om2r1kOisU26XcG/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1084", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1084` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAad6F0WN9n10ubEzTQQyOw4DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjMWE3OWRiLTEwZWQtNDNjMS05NjVhLTI2ZjRlNmYwMDI2YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM0ZjRmMDYtNGFl\nMi00Y2FkLTljMDAtYjY3ZWY0MTBhMDY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvVyY49zTSE8hXlpolDZy8xcWl/V/33HLtTcH5yUzN2WbHv5oHJHSg8kSJxs6\njYIhJ2wGVOMEno4GJWq1bsYv76OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb6hUTCXqmengzq3TkA/vtZD6V4MwHwYDVR0j\nBBgwFoAU3b1orYSlFc3EPTQ70h5O0gTWNXMwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDE\n4XoOMCzuTpx1xkcB2kRMvoWjiZNSJwosv0m3Qwu9JAIhALHVk0wrkjRmtBL4Yl9L\n1TNqwY45jQfCb7BRFSuzPdf4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYAjrQbBER3JU8Adt0/Cll4rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzFhNzlkYi0xMGVkLTQzYzEtOTY1YS0yNmY0ZTZmMDAyNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToO91r+Z7r/sDOuyI/ZvYPKwwCidvdawxXhUYFhiyZiXfb\nKF4pYe4HYJFSE2U7BhTNrUZr1W7soJHNdFoHYNBdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3b1orYSlFc3EPTQ70h5O0gTW\nNXMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN4bSWeQ29fs2lQKrKgf7UqpTZhbexzj3/aSRtw0wvgBAiAhQzu8IeuQ\nIGt33cHO1ZrSC/yo51wL+lNM7GZEGg6cqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAYLT1mRwtcRzQXvZq9/ECSljMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM0ZjRmMDYtNGFlMi00Y2FkLTljMDAtYjY3ZWY0MTBhMDY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAzMmQxZTIx\nLWM2MWUtNGMyNy05Y2QyLTJmMmZiZDhkZjY1MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHQI1IUBCpiidkBMapPI19lH7KC7nZQ+4vOYIOwor+VQXSYs7AOj1rFa\nigcqCJzQ1cjZgKedGIT6OP8sX3n9QGOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG+oVEwl\n6pnp4M6t05AP77WQ+leDMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCICWfe+yLSHluAawO55nP7wzjmDXB30+CAO5eJbzn\nRxXWAiEAn8P+HufDq/EOkMd/Ft74oZqCpTda7BTPZCRthkbAoLw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1085", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1085` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWVf76FqxPS6B3lV3MllHGQsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkOTU0ZTA4LWJkMjUtNGM4OS05ZGM5LWU0NmM1ZWNmODdmZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRkZTczNzMtYjFk\nNC00NzVkLTk1ODktY2IwZTU5NWRmOGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKcV8IuJ2VZI1YhHHzymzO5LFO1f4JTDizSe8R1JjVESPrOludhMKBfsuJJk3\nUka94eIg38a2P3RdRHUMoV3XvqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa5AnL4UWfZ4XH87FdNddDjdgCw8wHwYDVR0j\nBBgwFoAUNNntr7e+05WLyQC3D01V3zLp8IcwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDksL/cqF72xfo/OcCFmRNG28JT2L3P0lfrsV53atLQYgIgG8S1\noyO4S7wBykGeUv3nlNGFcWdVKQ3dwkrcpx34GNU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUxriMB2vNKaCdC4+SR7xvogMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDk1NGUwOC1iZDI1LTRjODktOWRjOS1lNDZjNWVjZjg3ZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwGi2dcYs1ji/PIfHSm6hfXJSk+W00pURgoSe/OZyZ0F+Z\ngy6SMq1gS4C7ZT7+qw8l2oA0M5hzpaZdEdj/xiKdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNNntr7e+05WLyQC3D01V3zLp\n8IcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN5TiE6XPubIsOxLynZyj4fRExYkKmXK6YnKNbyChH25AiBUOa6+8JoX\ngn5rs6i+JmFgP69EUxz5vu7AoBJstycFyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAUK7UXXYDgb14dTlpmP50pHnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRkZTczNzMtYjFkNC00NzVkLTk1ODktY2IwZTU5NWRmOGM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5MmE4MGYz\nLTBmMDYtNGZmOS1iOTgyLTBmZWVlY2NhZTFmMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMfW6lJS+BiQHR8Fy2aRd5npBW55eBH6rynVsP8ZiNheE3Zv2jJXAwgI\nAGurIWLL27+1bBP1a9zzHGrsGtqJ722jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGuQJy+F\nFn2eFx/OxXTXXQ43YAsPMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIHcI0Mp0pQoeELz6DQDrXseTcjyLg+fWb9IYlc5j\nf2zKAiEAvbzHPsnQ7i+96Yh63ZLc6iXLkDvZcOuMNdARzNnKeRw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1086", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1086` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAeKtMW9UG+3rxmIDK3KRm9KMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiYTM0NzZjLWZiYjMtNDdlYS1iMDVmLWU3MmViYmViNWNmMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAxZjc1NjktZGU4\nYS00YTAyLWFkM2QtMjhhYjA1MGQyOGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExBpZ++KRLoRAy6q8NO97ZQwbO/dYfHX4tW0810Xn0hx79mXqlt7/yfUB1ViE\n0K/XE4ZskD1NWdQ+TPcTrCjVraOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgfmqYDoDvj2EH7WnJejCOYO2h84wHwYDVR0j\nBBgwFoAUUz4VS+9m4iIuP16TajJ5sxsmBD4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQD6jHNgx/sa+cXtj0nQ00pRAB3GIdH71l4WRPDQuwQLGwIgZOz6\ncHVqFdPWZwf1Et148ktllGasppFgsx7S2oKGw2E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY64j7W7ohLPw8hKpWSjmP9xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmEzNDc2Yy1mYmIzLTQ3ZWEtYjA1Zi1lNzJlYmJlYjVjZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgve6VDWNeguI3fkzk69WZhjIAZ2QiIcgtdYz69JSQ0oK9\n7HkmalPbII3ohBujaRzFAZTrERUkYNo+l1DXhJSAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUz4VS+9m4iIuP16TajJ5sxsm\nBD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQzYsY/fkE3MmI4C0lpqGRXEj7LzXBi7QmC/hw8ig7TYCIQDi4xQvDx2k\nIXd/F9zuMUSaYJCuhwV2of6rrzwLZJ06oA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISARQ3wCzVotN3GOxfwgQTy4DUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAxZjc1NjktZGU4YS00YTAyLWFkM2QtMjhhYjA1MGQyOGJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJiYmJkNTM4\nLTIxM2QtNGRiNC1iZWI2LWE5ZjFiZWRkZDYwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA+KYqHBqOUtMvBwrx2qvbNhrqAedHfKPVmRrt1sTQEN9/845iCvtsWL\nANV2WOE+r3GL7mUPr3FyNIM5pCYe0+KjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIH5qmA6\nA749hB+1pyXowjmDtofOMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIAn3ssB5aYxzhuP9kWcBIITRcyA1OkEwkc4OsF9N\n6rKiAiBG23BI/LtBoabGnZwbra5rLyzNx9v+X80ji08tZlqVYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1087", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1087` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcP6MTo+o9UihVhezKd6HyC0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMzQ2NDFiLTU0ZDQtNDNlYS1hMTViLWYyYjA2NTUzZmJhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThhYTRjODctNGNi\nZC00Y2ExLWE5ZjMtZmU3ZDZjY2NiZGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFylVFLFtl7367SjxCHcv4B7VAspsxsk6hOazl/SlB6UjXpCvhdTKMWAuqn19\n3JtsUB6RGW2/lsz7g5urJOIIbqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQZr/HedgoodKfVBtJ6Fr71DhqikDAfBgNVHSME\nGDAWgBQHet7bkQZuh23CTZwSvcrwNCBAjDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDq8N0nprC5LoytMtHMIbxlqCr+gkrC\n1WKDVVKTsOF9SQIgCdXL4IGXQEBwLDhlfDXGQQhvu7k3SBDFbNibscx/7pw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAavqDdDR8VfXUbX4i3ZM7QHuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTM0NjQxYi01NGQ0LTQzZWEtYTE1Yi1mMmIwNjU1M2ZiYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6gwRiTWwp+jE79nkQDEMFvVNGAlzURvbwS4EtZDH4+rPf\neX6IuYv2BZtejxiIs5W/08DizzOJscjv9sot/W0ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB3re25EGbodtwk2cEr3K8DQg\nQIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKiokItbIjRnTNgbHBlUb3cYkc5au2y8H4MxUCojX+daAiBbOWRZel5N\nBMmIGUlE+TE/oYIeb005m2TIZoYlB2XhWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISASXsIPqc11atdiOn0o5GkVnCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThhYTRjODctNGNiZC00Y2ExLWE5ZjMtZmU3ZDZjY2NiZGViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3MjhlZmMx\nLWI1NDMtNGNkMi04YTBhLWVkODQ1NTQ3NzdiNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFR3GspDPp40qhqNY/mZ0GEM2kUzJ9uXLnUxWEl2Bt2FLTs3fr1lxmzi\nZqxO8xcQ+RJDq/+MOaECAuuxiYFSWUajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBmv8d52\nCih0p9UG0noWvvUOGqKQMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQD+vF6n94XY1vCaEzsNdjrAHnsBMJ3+sPQWMNcT\n+din/AIhAL5RlLeIq67QDmFh8YkShFDPKMO2PHBti2gnjptQIGMc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1088", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1088` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbiCS9SN7jC2T0aP0GIK8nLtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmYWMzMWFiLTA2ZmEtNGE5ZS1iMjYyLWRhMTEzODg1OGM5ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNmN2FhNDMtOWJk\nOS00YmVhLWI3ZjQtMjEwMDU4MTEzYTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq1jmnJYwD2G/qEhn9JOweA+PFMM9wzbCcROWn9KKu7Yp4FTm3nVZy413LRjm\nAqGGJLmyCVxPqphJrDeD/DLx+aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaJQzE77zbSPcsyQ9D+yB4pqIDeMwHwYDVR0j\nBBgwFoAUATPpWNzqYGvN7Tac2ETzkus94wIwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIALk9st97mZm\nFoZE0LWybGxX0Y211QrMTbyIR5QtU4LWAiEAkZNuD/8N0MzZK/7SETFC+OfmOjVo\nhiSrB7BPXKEBvIw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbGxSOD8bHS6P2TnsAObW9rpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmFjMzFhYi0wNmZhLTRhOWUtYjI2Mi1kYTExMzg4NThjOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqIPAaKVspZNVvAPwhyZrtE/TzG7OJ/WADvcKpCIraMDnu\n+ROVaBjdfwwuexh7DjxC26/duIUn7p5JTQ1jNpkco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUATPpWNzqYGvN7Tac2ETzkus9\n4wIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXKCCUTpYFcfjUVtFsfRA1N4Mco2GStTP7EsN1DZ1/pgCIQDuwT+btzYI\nPcj70JJvwQCbXQOWW3mUF4P4ZmqFWjxC5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAdlfKiLeFdaEZAX87b6WaXHTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNmN2FhNDMtOWJkOS00YmVhLWI3ZjQtMjEwMDU4MTEzYTNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZiMDBmYmNm\nLWNiNDctNDA0MS1hZDI0LTk1MDdjMzgwYWE1ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDcr82uZ8veFeCws78jrKHE2p81Oj2b2IUOTU6LW8wy6KTne9tTHeO9b\nQQhq6dVlP+0HYZSXccxZEFtSw4jgNcSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGiUMxO+\n820j3LMkPQ/sgeKaiA3jMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIF3tB1J++4O0W52cp0Cw2HuzHz2Y1smpoqV/ggjz\nqkrmAiBN9y0TJ1Nd23l1EuHnPflPfAjFp2IFcL6YzVThSvql7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1089", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1089` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAY6UnlRbdS7lGQ7rzR1JQ5/eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2ODk3MzM0LTliMGYtNGYwMi04MjAxLTRjNTA2ZjdmZGM2NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZiNDNlZWEtYmU0\nYy00MmZlLWIyZDMtOTI2ZjczYWIwNTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqbufy0QYE9DSTuz7mGzEWl7MWUYRNJqrpb9m+AbZSY5b7ZFmu4DOn9v0nleq\njeUxdbZitoB0a68zixktlfInHqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnpx72oatbunSODzhSjlqWACjK3EwHwYDVR0j\nBBgwFoAULdu6f/QgU/8tWuV8xCsSriGq6ZAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCvcFCxn37d\nTvgPhmsuAxSCRAjGMKm0IE9qJBEEs/h/GQIgBJCozqDGkHHaBKLZtgW3eWAp17Vz\nhQzkMsMm17V9G9w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbxMXblFuqVDWsgtr1Vm1+u1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjg5NzMzNC05YjBmLTRmMDItODIwMS00YzUwNmY3ZmRjNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUL/i9W/gYSn0y5JIL1pRT0fg4XagRXefHWNe7Vf9adOGu\nEwmeS02bHZruLNt1FLRtapmI7vnHdbBl5OKeW8l9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULdu6f/QgU/8tWuV8xCsSriGq\n6ZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALyEXa86zUzXKHCO11R2ldU1OZuNAAMWGL9YPpq+yDMqAiByYdNcGewe\ni593IPb467bPL/XwCqBOm1eyihyrz9J6tQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISARPRQyTBvvbxgbxHUiLMlOF8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZiNDNlZWEtYmU0Yy00MmZlLWIyZDMtOTI2ZjczYWIwNTkzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIyZDZiM2Jj\nLTA2NzMtNDc2MS1iNDgyLTIwOTY5MTUzMThjYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ6dEETv3C+S1xsek9caP4c3xpdM+wILxkrngXEkRwZFQBC+MDAbXoLu\np3DOQNuwP+ZWJR2Pu11RdkxyCt4X9bajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ6ce9qG\nrW7p0jg84Uo5algAoytxMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIGGlAC8EjNGtww/BbBQxNb6FHLL3cilloetyFT5e\nsESrAiEAzlBmmvxziTnUWtft2NEif+OKeV1jARQg+87easEaxOA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1090", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1090` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAQWgDESmDhYh+LdrU8/N59MSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1MmIyM2RmLWY2YjctNGEyMy1iOThmLWNhZDUxYzFlOTgwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVmOGY1OTYtMzM5\nYy00MTlmLThiZDAtMWFhNDNmZjA0ZDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED/IrTNgtmZWXDmKDcWEdmeDnIejETSykDgo7uc8tb2yMa7dUdCwJvrI4ExLR\n7wyK7clnFQSazH/Q+yKPiJzwbqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmboenN0ZTh3D89crJqsbqiekwr8wHwYDVR0j\nBBgwFoAUJTuV+HJqczEBq6v0NuTsOAFkjm8wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAuBnb7p77\nywq7JhWTMZTFN2aeTkL3g8/8Oy9SV4w3RTkCIQDqVf/fN9qs7xOSao+u1wquuv6x\nnTxKsS7RXtr1Q8nvgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXUuAycHkuqGRlQW8VazuCK0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTJiMjNkZi1mNmI3LTRhMjMtYjk4Zi1jYWQ1MWMxZTk4MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIIiZfBunA8Yfxesz/3wTVpyjdicsVUTFQfkV9irr0lHml\nFRRpJiQYAMvIM0pmpuhuUchXsmqvGsNSpYmw+X+uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJTuV+HJqczEBq6v0NuTsOAFk\njm8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUKjPkQyxpaxc+odxS4kM+fUsmdoiaL021T4YHQ8xVBICIQCvdrVpMOzF\n5XJChrQPHevuTL6TJh9mgrN1oGgY8YArCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAaUCtDfbw/3vxEIjYGtwTZeAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVmOGY1OTYtMzM5Yy00MTlmLThiZDAtMWFhNDNmZjA0ZDVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDViN2EwYTU5\nLTBmOTUtNDYzYi04OGYxLTM3MmEwYjkzODdmZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP2PwMwrUBYPJIwHxChpA9XgpmPEcSAmKnVBRtJsat8qsE6AexELC4f7\n6CpiAXrc1+ZWrtxugEEToOeA0MglUPKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJm6Hpzd\nGU4dw/PXKyarG6onpMK/MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIHC8BKKX0NKYhTk8MReLHb4Cwp2UkovqaClDH3lk\nYASIAiEA0OwsjA0lV77pmAWlmcxYt2ARaHtU/wcozuwxFrHbZZI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1091", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1091` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAcxVpDM1auKU4zwTmjB01xvnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlYWNhZGU2LTM5MzItNDYwMC04MGZjLTdiYmM0OGJhN2JhMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNlYmRlNGUtMTU1\nMS00OTdjLTk5MjgtYzhmZmQyOGU2YTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk3dTRO8YkxaBHpD7/XUpvHog47TntPz7zWzrkCA9gWVOcdukGs34CO5pb8f0\nnmy+mlv0UVxPZ5/Z/fQREhEiv6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpgSRNTYoF49WnWGmkrouISCQOhkwHwYDVR0j\nBBgwFoAUIYt8tvGHKGkfnvQWAjL4rteB98UwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiAGzfHBbrKGT2PLxCGnHTSkDNvSaqvRFl0tsb7M5QZyjgIgQVaSh8nY8pxr\nrrA8Wn+KNWiUnCahoYSuldO7ZEadrp4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf3zHe0/PvmQaoWV/yZyprMIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWFjYWRlNi0zOTMyLTQ2MDAtODBmYy03YmJjNDhiYTdiYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzAGmS5u/Td/hJ3NmxHolJiveNOZ7wJ5biD1zLgLbKVWT4\n53ZR4yabZO2F9nSaamxlu6hT4nTTHWTcczRL6HCxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIYt8tvGHKGkfnvQWAjL4rteB\n98UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdeuS5h3o+oK8GrfI4M2G63J87Bx6NtuQbyC/ea7T2AQCIQDtPkk7Tn8J\nzHuDTQyt6BdoKFuRKpd0tERTzmwRdGXrvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAS4L4ZBizcX6YJvBtgzz7furMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNlYmRlNGUtMTU1MS00OTdjLTk5MjgtYzhmZmQyOGU2YTk1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3YzA2YWY0\nLTkxZmMtNGUxYi05MmVmLWUxYzU0OWIyMGUxODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO5KJy+NQqWzuSOGzJJr09t7t5f8miTDfdAHOd3LB6s081i/o9Uy8r4u\n5C2IrbJuSBRpeeAI0I/VDi/JY8UPXZajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKYEkTU2\nKBePVp1hppK6LiEgkDoZMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCqs3YXt5Io+xuVd9DM7vIGVT8snL3ExKeRXyt3\nmxp+sgIgdM+uJR3PpuCOZV+eNf3yQT1hhvGUEdPv8ng3CnZh370=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1092", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1092` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYZoAad8q1YfFaCzHHFLkb64MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2NTE4Y2VlLWQ1NjctNGNmNC1iNjkwLTk1YzRjNzk5NDI4ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDAxMGY4ZGQtNGE4\nZS00OGFmLTkxYmUtYjk4NzI3MDVkM2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES4See1n7BOyTE6xdKdCbpNvd3B7q28qVlR/BFQcuVIqHm2oVTuQbS56nEuYQ\na0KvxaPLjjTevkW+QA2sJPR7c6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVruGtIPTR2r59h+eWL1zTJ37leAwHwYDVR0j\nBBgwFoAUjXmXhNAPu14U6/EW7/Z/8cpZhjAwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBr5rtOTgIUUqZtGfQ/Xi2eXE2xvitqpPxlpQtW5P0pXQIhAIJlgYX6PULu\nAo3QRzKtpa64tpTGOcLKbUk8Lw7+mS5v\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaNgyQG4xKUYS5tNOqjhxb53MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjUxOGNlZS1kNTY3LTRjZjQtYjY5MC05NWM0Yzc5OTQyODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpYeLiAPpzbK5+dy35NDu8NfYs5men03cWldTp3AjXK2hS\nvrovlAc5abgGdVsHwm7klz3GNzE8YlX/3h1mrzMMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjXmXhNAPu14U6/EW7/Z/8cpZ\nhjAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALPPTOU63DMtq6kSJbv2nsmuI1DoHRw/tZfMVaOocWmyAiAHn8B3V6bD\nwV8y7cEjMPkccL/QU369L2/Ot885Kp4ulg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISASu9DH3htC+0HmBoGVHGxNr7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDAxMGY4ZGQtNGE4ZS00OGFmLTkxYmUtYjk4NzI3MDVkM2E5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJiZDA0YTU1\nLTcyZTMtNGY4MS04M2M2LWZjNmRiY2RmMjdkYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB/sSotMfIBNbnjfg2xkslTpKPtk9sBF+WeNV3vt/BqwqHfBa0TsHdCk\nWZiAiWad+uZXdZ4FQNe8khX/MwQRKcyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFa7hrSD\n00dq+fYfnli9c0yd+5XgMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIFTK38pBJCgSCSA/k6DPgYNXfdnoQ8Dn0da6+L7Q\nHau4AiEAlVJQZbicICqBfdR7vZZNQpyDZmKAhRFOtsIe2sVhkts=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1093", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1093` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAUPpkFKBUBwqM6FyB60h5mQ0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzMGYwNmE1LTEwZDItNDJhNC04MzY2LTI5YjNkZWViYWE0ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk3Njg3NmMtZDA3\nYy00MTA0LTg2MzgtYzU0YTI2MTU2ODBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElxyDL/BToNYCIoIgfkzjuq/k5xr+9oN7ynWjRj0XK+JAhVEXusqxlcQhLIXy\nVC2LCkc6uerQLA42yB4OpLFNd6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcC6+2FpUmT5bCDWOn4skhwKJxHMwHwYDVR0j\nBBgwFoAUkAIeJbSn8KHr0EtHn/raI23G/MIwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBO\nXpJg562LELhOhSd2n0pzfWKY7n4ch58oAkGb+uVMIQIhAMEwQUkijItzwynOaX6y\nYrJrOqQJOILbKOPQLjgQOp7G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR6H+GpBu3iSeyZSSNnw8+mVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzBmMDZhNS0xMGQyLTQyYTQtODM2Ni0yOWIzZGVlYmFhNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxmkGu6Ytr8wQhWtUHk8NagBx6Iw/jRc1jExcWNrwRcS46\naWceOAf3+gd6BpIQUc1JttFBj4o9pdxnche9DfZmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkAIeJbSn8KHr0EtHn/raI23G\n/MIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJQYvrNHdgGwWIYnj1JQH7pkx/FhlYbMLPWszH1GtWE3AiEA/L4uYIWr\nIrpNbWIXz5dW9xFC7sOdHs8tli/+olqneNw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAdkL3/8wE2Rg59LtUKoFQHYqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk3Njg3NmMtZDA3Yy00MTA0LTg2MzgtYzU0YTI2MTU2ODBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ2MDlkZTQx\nLTRlMGItNDEwNS04NDFlLTQ4OWEyY2M5YTlkZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMEvQ79eiuIcZnIkLYuc86xzLNRtoUd6VxDSEmhKEK84cPFKDwFsVGbr\nQJvAgSLSWyYSvo0vpL5aINXvZ3Xl9tyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHAuvtha\nVJk+Wwg1jp+LJIcCicRzMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIC7UWIhSB/kmvw6uXe79t0c0HrexfRGaVeLnPTAK\nB3weAiA8vep0wdcyHBJ+P64debAwTJk2j7ki4B2mjNzcuZgDAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1094", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1094` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYfX4FiCu8OD3c8t2f/YKit/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1ZWVmZDcyLTZkYzUtNDEyZS05ZTgzLTcxNGRlZWJlZGMxMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U3YWFjOTItNzdm\nYi00MzVlLWE4ZDUtODk4ZDc4NmM1NjgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY0MUe6HChkqi6G4A96lHiFj/Eh/P/rH/9YBV8yE2e16cybtsfkmhgdwmPLuJ\nqrI9gn70AyO10h0eR4ObecyN1aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYa7u9ETL3OT+uyYiyAX6E+SNJSAwHwYDVR0j\nBBgwFoAUfMJODAuYKzkDc2kkss26y7ircn0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiB0Q0w1VkLnMJDnrbKtxgZU4w7Xq1WfPfQDmLtrQbbWpgIhAMET\n2T4XIUGmGgf0Wp7c6EB9XdP7e0+dIpMQRbnBQmiX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYUAKHvSl/G4tfl7MmU0L6I4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNWVlZmQ3Mi02ZGM1LTQxMmUtOWU4My03MTRkZWViZWRjMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcZaZsgUhSrVa41kctsE1AUXlqWXAx8Sb1P2qI7YltkhgO\ncREW9dEqrv1Vil7lzdHJ1K7wP+gjYGR739DJ/kAfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfMJODAuYKzkDc2kkss26y7ir\ncn0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIFrRVu2Ud3s1ocoI2VWAaESDIVWyiccUAZYLZkwkAHDAiEAnsVjc7ty\nI+8nhe3koQFJUBp87HG2nDxgjIf4403hxW4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISARo5+qYZk8GpikTzxEzH48haMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U3YWFjOTItNzdmYi00MzVlLWE4ZDUtODk4ZDc4NmM1NjgwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIxZjBjNTM4\nLTlhOTEtNDQ1MS04NTQ4LWQ2NTEwNjFkY2I2YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABByJBZC+k4lEr9Y6IGqbnSxXGfjux9fHtlkhcSdBpB1MRcjDZymG11ED\nVwOiOYx3j8uFvQMKNxQS5A4niGgt5BOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGGu7vRE\ny9zk/rsmIsgF+hPkjSUgMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIEdVjpNfoIDWI2uI3l8/Pm5qhcu8xA2nczhH3M6T\nElreAiBeyMkBO+zlt8UviLOq3EAeGS2tFjUgwHGJtCvR0nOfEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1095", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1095` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAb7HnaKeOpCDcZOkd9R8KCWYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NGY0ZmI3LTUyZjYtNGMwMi1iNGE1LTU1ZGRiZTFjMWQwZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA0OWFkZGItNDVj\nNS00MWZkLWI3NDctZjkwNGU0YTUwMWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFHTwwBJvYwb6ylzL+R7FSHrYqip4kTGeIeIVVUssVkcUKWMbqKo1GrtDqI/J\nwt44poEqnZH06UD4j4r+cENoTaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVN3fcv2svj+jhFp642mQB97zKdIwHwYDVR0j\nBBgwFoAU6g+FGXdbj0A9IAZ92RSQog87vpcwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAh+B10wln7MEZAWH9i4dXYSeGJzA92pwWHnE1i5MXLXwCIQDf\nPtvcO+9ZODWTOsPpfHOwNfv8uO+SrbRe74+AFrfdUg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcLQucPEYJd0MLCc9YBERitRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzRmNGZiNy01MmY2LTRjMDItYjRhNS01NWRkYmUxYzFkMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATT05kU8ZUXiMJPPNhiQKs9lNwWlXYDtlYhVkpvW4B1jeAD\nxKrh+tK0RywjF2yYKWrrThmBW2ePBY2KyGgpEPVko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6g+FGXdbj0A9IAZ92RSQog87\nvpcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTntqud0q5BRzoyI4kzooamg3YsIg3q4fbB0VVlW4wsYCIQCbM9bfS9C2\nLCmiv7Rm/3mJBj4SrnWtJOv4wAWb9uA7LQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAWnvmXM5Jg+0ULGmlLcNX/n2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA0OWFkZGItNDVjNS00MWZkLWI3NDctZjkwNGU0YTUwMWQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZjNGZiZDg2\nLTJkMTMtNDZlNC1hMTFlLWY4MWJlYTY4YTdjZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPI2CXquH/xN7yyMXAFnqs/it67c7/AfTWiVf/Y8/lLVBbc0ZA0RxF74\nTPxYwIdvDQHsyMnjW+8j25HWgqFxx86jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFTd33L9\nrL4/o4RaeuNpkAfe8ynSMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIBB4j0fLaDMTXt2DeOLsKQfhujYUPhU98sbJJqVG\na6EZAiBDQNNzVTACe4qndLh8feepVr7wnZRoQxykbr0gLB++Rg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1096", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1096` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAVePC0bgpTWkbTF3ezpGU/lgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzZGE1MmJjLWE3MjctNDlhMC1hNzI4LTk0OTlmNWRkNTE1YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg2Y2MyYWQtODFk\nZS00YTI5LWFhZTQtMjdjNzdjNzUwNDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg7vu7My/Bd+3fa8/Q/F/K2wovjtXzxQtjHhkHooPvF3PzMmllbLpTxyCq3IR\noF/VJ2AeveyUEtwnFjzvecF6lqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPqQV/E9LrHYF7E291jAeWcXdUdEwHwYDVR0j\nBBgwFoAUFbOFR0AMN8wWHAGcdi9TxJaWZdswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBysVVs7FUFzfY8\nImv0VWDLe0V1KpcLmGQuCVuHX9HsnwIgWyZaErAgr4PpF4BCV8fvj9SSEUI1Xl8H\nbWCZg0JWVXE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR6LRmhT4RnW66WSsLaPamWvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2RhNTJiYy1hNzI3LTQ5YTAtYTcyOC05NDk5ZjVkZDUxNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQmy/GKCEwOLaCykVvpdlQRsWLZ7NjsA6rCbmDHoaTZnOO\n6ecVy7fgYQ3rKD7WAaf6xgtv3vm/1ZEognY0T2sko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFbOFR0AMN8wWHAGcdi9TxJaW\nZdswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIclVU9uR7Eww98x4cfs74B5h3Tdi4ONavkATVVDL7FWAiEA+b4Brirw\nGysIyFnTLMVSlxYoW1FaCwloxUvXlcP85K8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISASmxY72RH/6POxehL7B7qTGiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg2Y2MyYWQtODFkZS00YTI5LWFhZTQtMjdjNzdjNzUwNDNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUwMTI5N2Jh\nLTk1MDQtNDkwZS1iYWU5LTZiNTg5MGNiMmJkYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEkVEJoyo7SpQWj8XoSAF2YP58DwXz+3qyxd/s2rKCCUkDsrP997JplU\nmKVH+2HtyVQp2NK7czEhz3VcNSOv3mqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD6kFfxP\nS6x2BexNvdYwHlnF3VHRMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIBegiwdgzxJBzZ/dc1QYP0AQPDZ0d7CSZagJtVVP\nMkeMAiEA+JbW79jRje0t+/lk5s6KzGuTHHEaspHQcf6sIIQhcg4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1097", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1097` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdnc9q149sFDTgTZUfRioYoFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkYTI2NmU5LTI0NWUtNDc4OS1hYmMwLWJkNzYxMjg3NGNmZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ3OWExMjQtY2Q4\nYi00NjBkLWFjN2UtODFjNTMxZDI3ODkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECQLu116Xu0DRkeO5cyZGe4Fj6PIrsz7wwe6VPj2Eb7iEV5leUA1pnhIM8yXm\nk8dvJB2Zvyrgs13DPotO4ryAAaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg9Vem47wzDl4UhHm798tgY2Lh10wHwYDVR0j\nBBgwFoAUUxbmPUMtkqyfZL5uonctl43LIyIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDL+Rcv7NKkJnTyUtO27G8XaKGLU0nl7wo4HVl+pHcTsgIgWJShUeDHDIme\neiyA6o2LgvfyfAPPtQTyoHcPB65BKNY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARFdHi/tWm6dOFqXgA8c/AfnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGEyNjZlOS0yNDVlLTQ3ODktYWJjMC1iZDc2MTI4NzRjZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQT7wzmU/jYi81Umi3Sai8hZwayJPSbBYdfu6cE+wAdeXLA\n9IF4xewEnFz16jEKID9f0nawLp4NwVDN+omWltPOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUxbmPUMtkqyfZL5uonctl43L\nIyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPDNM0NCdT2dLFauYrXVRtDGFqN6d/DjQ2dkVa1vPTKAAiEA2WoDvCFY\n4VE9DiiN1jYhl0G3b8tDddvXZULSWYQ4qrg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISATfX3P7kV7C81cHibt5nmsqsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ3OWExMjQtY2Q4Yi00NjBkLWFjN2UtODFjNTMxZDI3ODkxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJkYzNiYTky\nLTU3MzAtNGQ3Ny04Mjg5LTNmZjIxNjRlOTM3YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOW1Gp0HC8uyBxlhT+FD7S/YlgZCe5ixjzauNetgt44VA9m6QKQGDY4/\nqRsM9T/gm1hsrf8TVWEEDGFcQoOv+dmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIPVXpuO\n8Mw5eFIR5u/fLYGNi4ddMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIFQB3wCC3aVPGTwrr/YscSCICw14IwL6VGeXNMgZ\nVtJsAiBX8su9xmpFEwzZmI6+oRKC+z8lJHjenS07Eufn0HQFwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1098", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1098` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATPH184jgZy9ywwQGXadCd3cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NDUxMTRmLTFhMGYtNDc0Yy1iMTRjLWRmMTQ1MDVmY2Y2MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2MyZDEyMGItY2Jh\nMy00ZTdkLTgxMDctYmViNTFjYjk1OWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXit9tM4ph9qqZ4uoI4ktZ6gm8Nv0LJ1Q+me4pcNOH9zzXtH1Qa0h688Swl7r\ne/e0KNjZprs6qomcFtsdy7NY4aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv0oRQf2cgBllnZqMteWzp98hmTowHwYDVR0j\nBBgwFoAU92SX+sJl9rFr5tOovB+Hqr14nA0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCpe25n0NCetpYqYpSvO61xotmTDBkUDjDUgb6kDxXfywIhAPg+MUdWPZKa\n2oWdyTdX9zgk8/HcLeixTKVt+BeQADhm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZZ1v6IzHLojZyL/Z3J81gu6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjQ1MTE0Zi0xYTBmLTQ3NGMtYjE0Yy1kZjE0NTA1ZmNmNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyIYoj/V8lZzxZUFzLyf70wwH6ki9V1GEQLsElvu2cOHQX\n66Kn9ltDtiLPp9KZqP/v0/9gMtIcWkGU7SSAe5ldo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU92SX+sJl9rFr5tOovB+Hqr14\nnA0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANUK3QJ+awAKqrFDJQUFtWM9rH6qBepksJcMbmzx7CHoAiBxI0yWb1L7\nfg9liqvfolDcNxb5mxCaC+ZPXChglJtyIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISATynlWLnWcqC4xoHKGNDvM0LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2MyZDEyMGItY2JhMy00ZTdkLTgxMDctYmViNTFjYjk1OWFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJkYmYxMzJi\nLTIyYTQtNGQ2Ni05MjBjLWIyMDA2MTAzOGRmYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI/TgQeLgxpL92JKB/tBJXuxHZ6/ReUO9Ub8vSpMY+1HBdBu6Murn0i5\nEugqCrCpFLV0PBHyXFaKZYyTL96BSUWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL9KEUH9\nnIAZZZ2ajLXls6ffIZk6MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCMMpFJMBjHpOhobzxQNLEK6bbk2NyDTKywbf86\nydO5bgIgcVwk7eoOC2DhC4LOvDBvdqcdvbXg3C5Z4xb8i7MzK5U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1099", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1099` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAV+6g9GjeZXD4xOrxkxEkTnvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMzdlZGEwLTIzMjEtNGY3Ni04Zjg2LTRkMGY3NTUwZWFkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNlMzU5NmYtZmQ2\nNC00YmFiLWI3ZjItNTZmOGRkM2Y1ODZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElTvwxcwwisZHoXDqFPKnybFZRmM1bxI5iCJO4vkAw7nfRgfDLowiygu4+R4d\n2XUArN9xqIz8D7EN8B5IsC/ClaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ39dhrFsCRAVf0getHLdurdBKmEwHwYDVR0j\nBBgwFoAUf3oPApjGKYHiJVvuvaNSHErwGjwwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiB9MLjDN2TCnKHs1nLKnVspSfhLx3n971m1PE2edR+GjAIhAM+2H2msP2sr\ntA8kCf0ys0OxZUHRYA0KxHe0iCwrcOic\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV6TywiutY5mVk3iky5uD3QwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjM3ZWRhMC0yMzIxLTRmNzYtOGY4Ni00ZDBmNzU1MGVhZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6JuXtBC4/pazA2kOjANWD6XWyJj+yiJ1V/Wmv9sbwE0Dx\n8mVGbLnaxNbxwhpLyf6rLUd24u1k3w/c/bUF54HHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf3oPApjGKYHiJVvuvaNSHErw\nGjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANgIqh8nl1uCWX21SW73IRPFheSFOPA19Vl6kfE7LDeXAiBPdX73/mHC\nctvSUft/THRfRjaBtf4hS4OCBHRfg/vcUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAWu5EpHRMnTaCRAA9MOA4oa1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNlMzU5NmYtZmQ2NC00YmFiLWI3ZjItNTZmOGRkM2Y1ODZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNkMjk4NDJl\nLWM3YzQtNGQxMS05ZDE4LWRiYjgwNDMzMThjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE9D/VRbSb6uyi1lCmP0Ys6oVykLRUvEM6sDxDw3CQymqKd9dX406k9T\no2xkBMEvrq6/9Uo1HLTN4pxc+XJcx82jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEN/XYax\nbAkQFX9IHrRy3bq3QSphMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCqukQM8aZb8KL52YRw2g3wblvPOskNLNvB4KfC\n2V/1zwIgGHlZJtyWDZG6jIndL+R6gCxPK1pOx7rDjelN1yfeoms=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1100", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1100` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAb2qwVh+nWYADXQVYX6xmZrbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2YWU2ZWY1LTI3ZmMtNGFjYy05ZmZhLWE4YmU0MmE1NzlhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZmM2UwN2EtOGRi\nYy00NGFmLWE1NjMtMWM1MzhhZDA5ZjE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgbgq4wzAkMugH7SuhrAY+5RWKldxxzxOucz1B33BBlSzPizvurzWgZgz2kAX\nqQ/4t/Up4dYg4TlhERj+/jmJXKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8LKdDXJmrQ0RnsEdFGL+kOxVOt8wHwYDVR0j\nBBgwFoAUzes0/4aOpbl+0+HDK01zcam2ckowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiB9hCV/irH1L7dWE7m4hd5zbGvose9TPknvbZALYCvH\nXQIhANieq2NchcplYA2LNljKlo4lM474fsyd3xG75rvkSFBv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWNTFYsP+W8aSvXXafyhXBjvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmFlNmVmNS0yN2ZjLTRhY2MtOWZmYS1hOGJlNDJhNTc5YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHNOahvq4XKj6z98j+2n51y+U1io5WsnOo9CelwJJQzcI7\nRNe/GP1KNPv7Otzt311sCC7899Dpu39328pfkQ0/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzes0/4aOpbl+0+HDK01zcam2\nckowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJYT8Ryy0VJTL9JUaPG4aJfxfWi5mcxJ5EzHjMjb6m2kCIQCtw9vuPTp/\n9BRc6h+4AOW2hq4/ldAx1zBWaw7v9w2QBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAU92umjY98J6/ME/ncKhj45tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZmM2UwN2EtOGRiYy00NGFmLWE1NjMtMWM1MzhhZDA5ZjE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY0ZDNjYjlj\nLTAwODMtNDA0MS05MzI1LWZjOTFmNjQxYjI0MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDYOoBIMCAKkoIDAgyXNLaJl6kyK38UXqPsIBkTGmPMzZISxgMiosd2m\nKYPc+BNAfQqihbxAkl7J+wCwPELpXcyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPCynQ1y\nZq0NEZ7BHRRi/pDsVTrfMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIF0xiOYpQWNn7ceWCqz1HhHNiSRr5k63tI3mSt36\nvYWpAiEArhcASa9zJdKuknUpmMPxxxrSZIHGsysqb2MwTypCeAo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1101", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1101` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASZMVt2/7PnK/DXtCJjrPmB8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3NjlhYTdhLWRhZmQtNDk4YS05NWFjLTk1ZjU0ODRlOTc0MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJjMTcxZWQtNzA4\nYS00MjhjLWI0ODgtYWRmNTIwMWQxY2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcXhQVcfQcOwIP2oa0p2bTL32d61fj7kiE70/4PVa+dsEnGK5OE6fB/9uv9Xy\nhQVPRRYH+lT0lPsKc6l32+iUVqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9qYYc0ClyPrPbaAYq7SMVwlkfB4wHwYDVR0j\nBBgwFoAU8DF9fu+K/oI/mqhEqY7JrGv5Si8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAh3Rex6fU1L09hAfjNawpkjqdCDk0fyzg1d7t2+Jq\nID8CIChG+LpyBLNKVQi51ZhiXv/T+0UyXeJLnPNsWg8Qs534\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWLbiW+7HReuwHkI3oun2bDhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzY5YWE3YS1kYWZkLTQ5OGEtOTVhYy05NWY1NDg0ZTk3NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9dusxsFob7HvbwaI0v6sD/H69JqtYpdXTveLbxSlAk1RM\nHhZL7SxkleyBF2MPWy7nXbJH4vWsWGFQYi/ThN6Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8DF9fu+K/oI/mqhEqY7JrGv5\nSi8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaKcMNqI5UEqo/aH8uzjf/fKCK8c7YhS1pyF9kpNXk38CIEWhxqLetr+G\n7Z8ZvzFlqGgAiDztNODMM7Nb3CarMdrn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAVi31MW+IC4UDuL9WmmSfC/gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJjMTcxZWQtNzA4YS00MjhjLWI0ODgtYWRmNTIwMWQxY2QwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRlOGY5NjNl\nLTM4ZjItNDQ0Ni04MzFlLTIzYTA5NzRiNzEzOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIs2ZQT92Xk/GWGp5YZWzzWx5Xh6TRCTa9aG0VpFoxVYGMRnaWJ3Z9IS\nMfSfV3M43pm1J6+Lf7emXMZPQEoHLnWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPamGHNA\npcj6z22gGKu0jFcJZHweMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQC5EGRuQu1rbblWq5mChfL5+E8zz5DGyW+N1tLY\nJsfyFAIgdwB15XJjiWDDa54eOCf9df59KRAdOfEqR8CykfFxKHM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1102", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1102` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAca4YoryOgCfUhbvQJCR7ZdlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4ZmVlNTcwLTk4NWUtNDQwYS04YWIxLWZiMTk0M2JiNjBkYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTMxYTlhNTMtZGI5\nOC00OGU4LTk4NmQtMDRmMmUyM2IyNmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5wHLG8f8kh28COZSy1IfPeXnNYgbyyu2cpgNAFMLZfndGBf85wvgk8ZEuxj8\nv8hPypYZfLeZArFqrLnGopXDdaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDYjJehJbFmNTp6nWZljY1Wu03DUwHwYDVR0j\nBBgwFoAUnejM9YcSg94PPAM/vrN9uYfVuW8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBOJi32aQH89PgQ0vXMrarl4Dp7Vuf7UzWhzJ5IvPg2nQIgbOrH\nH6mbzDA2A/0wQVaTWKwPlXCF2UqRqsmfvivD3U0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVdS+HuRTnjRAqxIhHXSCpZIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOGZlZTU3MC05ODVlLTQ0MGEtOGFiMS1mYjE5NDNiYjYwZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSkkhl4wAdu/wD/MIVm/PF5OdZrmF7B+T7EHUA4UfVGT8p\nVcxeCOQMij2nIXN7DTLjKKMNtw6g2f09h/tqPKUWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnejM9YcSg94PPAM/vrN9uYfV\nuW8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO+CXKU7iD+elmDMGW8E7Mnl4HKUsYt9wRZgzu+l6eRdAiEAjBHTwcYZ\nBWThcOgm1trz4Zv5cMtrd0foJzBA4zqfr+E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAYEy2Ma+BMqC5cGsKZrZCnHUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTMxYTlhNTMtZGI5OC00OGU4LTk4NmQtMDRmMmUyM2IyNmE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZlNzk5Y2Vm\nLWEzNWItNGE0OC1hNzRmLTFjMmVjYTI4NTY0ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDQXYmF3HHL/xDNbqVYh0WBiO/wyrJIgjV86aLXWbRFrYnHtH0STPDVm\nlKabhlhLV3uDnoheML+4xy+u5Sgtod6jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFA2IyXoS\nWxZjU6ep1mZY2NVrtNw1MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIDCufsmiY9W3KQamM7K4ndHHL6uDnlOOSHqiQkoM\n7nqwAiB8xxw+Po9IY90bKCOidD+yg3WHk2Y69E7TRvZFUplaug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1103", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1103` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZv9AHnPt7wGJIQAHU72YFHqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5Nzc3YjkzLTczMzQtNDdjYi05ZTcxLTliMzUyODA5Y2IxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGMwZDliZTgtYzZh\nMi00MWMyLThjZWYtY2UyZGY4ZWQyYzdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtr2qjoTDOqrsDbgMJFGnLH2tAhV5OTNjz/5guy3QhAut3jt790EYWxBl0YXr\nn+W74YHdPslEJ8vk7guErpIUUqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuKJrutUvEVBtV4hIJYqvinAKyOUwHwYDVR0j\nBBgwFoAUbg5AlbtsIycMye9mSMEgd1s4JwYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAv3jbFv0dpY70mmES512L0LlQ77lu63zL\nlq2zR4Pks7gCIDBqn3JCO6r5/joVFxQl+aVIGXvXn3WNmoit7/5Wle9L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc8QVoVkN+6qN7SCSNlwPiI3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTc3N2I5My03MzM0LTQ3Y2ItOWU3MS05YjM1MjgwOWNiMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSKtWAl3j9MMZzCDxMQsP6llRvjnpZ8tTqV94SGaYLR50S\nLSTM4vL9tjV/zhyilbsqNBFFqhVEhTaBEMFyCWk4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbg5AlbtsIycMye9mSMEgd1s4\nJwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIkQVjkGt6STu5krvQeqqgW17aJ+Rx7Kd8gNkhvUU5UpAiEAuNXPktSF\nEpukunfwt8mDEpCkOsXYkMaOsOa8qgBgzvw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAXx6wwW73r0Sgzc+fekUskJiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGMwZDliZTgtYzZhMi00MWMyLThjZWYtY2UyZGY4ZWQyYzdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgwNzhlZThm\nLWU1MTUtNDk0My05MzkxLWUwMjI3NjUzMTBiNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI2QmYeUf5pmZNnhG0cEqHGDynGQBdRwwB2wuGR2eOn4xsxcTDkt0aPG\nfKgrfE9W6E0m2LBLkqYl39HSlXxHSuyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLiia7rV\nLxFQbVeISCWKr4pwCsjlMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDbDmZXIleykaIQolokYOLxEo8afzcWmiGBgpYu\niV1QbwIhAMFysbWTeiWyOQvFA60/7Dn0GNkGuFTJ0wCUny5/QgyR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1104", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1104` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAYVlIVNkpGY354NWy5s2shDkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2YTk2ZTYzLWQ4MTQtNDA2Ni04YjFmLTRiNDkxYWJlNWRiMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZjYzI3MGQtMDFi\nZS00MTE0LWExYWUtZWVjYzhhNmMwMjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUwFQtB36/HEGG8TYKcy+Pg5elLQs1HBNu+2vGzp9sQIxLyNzM9A61zb4GURb\nbc+XsfSiiXaaV//b0SkNUn129aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTE6SU7qt6uklLLTTiuG1vPV9rtwwHwYDVR0j\nBBgwFoAUsGQpXRWXJTUMJQFMXrqd0eI9zvkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAn8bbntyogrTzlnwuqb44pifhiNW6PnUE\nrAK9lHUHMasCIQDkQodrCEquPqXy3hPX8K/QPbwg6tV5WzR5X5MC2EMdUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY1DYoh4QaiTiHrOKekaV14ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmE5NmU2My1kODE0LTQwNjYtOGIxZi00YjQ5MWFiZTVkYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8p6DMYPvlBTw9OvwpsDxJnwbG7S7aApG7X1r1Q1Zqbutc\nU3Ivh3wV6WTS0KdHHz9QH5AVqQ5yAbsy7ddzYbFdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsGQpXRWXJTUMJQFMXrqd0eI9\nzvkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANbS/0xzKqj+Ow5sjcsg1KTKH1uv7TvMJaApTI/WFKdXAiEAzJ3Xv6Gb\nzXLckM9PCAjb98tSj3IPWGXnyG4VIdzs8cw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAf6PqUjzd29sod0vQRQ1qywhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZjYzI3MGQtMDFiZS00MTE0LWExYWUtZWVjYzhhNmMwMjgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgyMzJhMWIy\nLTFjNjQtNGQ4Yy05ZjhmLWMzYWM5YTFkZGJlODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPUjNoztAHNXxJjqGChMulgAJWojAxsSNvPQPg+bfE9KO164WzvJ3wSZ\n4zlc2J2I8Pc1WV5foILCPUQCI82o2GGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFExOklO6\nrerpJSy004rhtbz1fa7cMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIF6NKeQxD48RpgKWJIDXfr5EFabSp/h5H9vZV/P2\n9g8FAiEA/pTM6Xjwp7kUaR2C8SoTw5wYFbFEaJaoRqSyQC3KyiI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1105", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1105` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARBC5PhxQwntK6kkkZFu0fSeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4YjllNzI3LWIzNzYtNDFlOS1iZDYyLTMxZGFiMTIzNGU1MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjIwZjYxZjktMzBk\nMS00NzNlLTk0YTgtMDIyNGMxZWMwYTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnZRftSCv9PyC7vtWkgAJrFUZmNYA+FYNTLoKmKVaWDbUxnsP0VWX5bG69FYF\n5f7HR2ib7CUrWZRhtb7ZGkOqvKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE8e25L6d6l/CGyozB/DSMo3NXLwwHwYDVR0j\nBBgwFoAU+daEKUBhm86wbOkCSpiV1kkhy1YwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBAcGpXSNyZMivN\nXjUhHEykykhz+rOhmTMv1uLTr7UDvgIhAOTliYBSZF/JbCC8b3H3vUzzm/IqDJ4S\nkNq97d2ciLTu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWMDXqdEuLC5+6pyAkYjUbQcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGI5ZTcyNy1iMzc2LTQxZTktYmQ2Mi0zMWRhYjEyMzRlNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4QI9q6OuO0TfTR8Cen+nKA6VwFJs3y/wIWEIPobBLLcip\n+3YznCfqzeL0fqwUGXc6Jzl6O9qzt8BBnn7c94sFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+daEKUBhm86wbOkCSpiV1kkh\ny1YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJtCoItKbxcqkc1GljZBU7Zy1e0Ix4XPsy0yE2DV4edvAiEAzyy8CmPU\nCftsyFH2+JBElLeQ/cY6uO3f0AM89el8vWc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAatJgzCQj9tUBjWxAbxsJYaCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjIwZjYxZjktMzBkMS00NzNlLTk0YTgtMDIyNGMxZWMwYTM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE1YjZhZjE1\nLTkxZDctNDJjYi05NDBhLTU2YzE1MTM4OTRhOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPQYgd3szk356DBKTRLOu8IZkEXD8lA/Bnh1GXONhKfvd+YYpoHoXP3l\nXtqUK9+LXTjtNzqN9b3TDk6r8jhPsTajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBPHtuS+\nnepfwhsqMwfw0jKNzVy8MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQC92/M+XV/Ps1azBgVUR5543u8NyvTkurDe1lP7\nFEieAQIhAPMolXWqi+NOgIHWEp0EUMDhi4G89dixCp9VjHVwNXBc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1106", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1106` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQTnhNgpBL9ZKLjWo2itleO2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhMjRlZTU1LTQwNjEtNDRjNC05MzRlLWNjYjk4MTNiZDMzNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhlNThhOTgtMDc4\nMC00ZGNlLWJjYmUtOTk2M2UxNWE5YjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKcqZzZqVWmpWPOgpsOpeLL2Wf6skQgWfQ3VUxX0Qke8qFXXcwrodWFxVWIpL\n91ZF7WN2klYbuHvipCmGYj4q/KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw4sFdqHSYCeXTldTzQ4DHCQ9aOswHwYDVR0j\nBBgwFoAUrFU1VimLtTqHt/V464WA6Vrjnh8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCID71srYhdLhhwXImqPN0ajxDY5stPq9G8zmSgXPiSEI4AiA3Lv12VKvJIHwC\nmjyKTGMA2hp6r5iKkoZZwlo4OoahJw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQvmFYfEIDA08t8oHrHBLwq0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTI0ZWU1NS00MDYxLTQ0YzQtOTM0ZS1jY2I5ODEzYmQzMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATs5AwG+D/fINMwoo3PfJD3qQySX9LiBfFPu0RD11J28ntt\nvaGapMWZmSDvE7VXUd9p0l5r4adqQ87nAedPGWJQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrFU1VimLtTqHt/V464WA6Vrj\nnh8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL0452KTHbJq91RO+fTiiHOwNIMw8Wg+/stZoo+qZ1KpAiAsS6dA3ABT\nrW2dDIX0KqLbcv6PJg5wHmvdzM4x2PWQPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAXHJV/2dS5XyG7W328i/6Ae9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhlNThhOTgtMDc4MC00ZGNlLWJjYmUtOTk2M2UxNWE5YjJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFkMGJmYzA4\nLWM3NTktNDA2ZC04ZWUyLTg0ZjhlZmFkOTAxMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLCUH1XtmKat6pMxy02Ud2hvhY2s+Pji/BDGOTjT4rxsr1HPmkJYizNa\nOI0BWjMhoaCHnP4vgvbDdTtZ/KarFeejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMOLBXah\n0mAnl05XU80OAxwkPWjrMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQD3cNrCofEYOU4dh7wifhrNIqTt4lCxvAlKkVYS\nE5i6dQIhALigCONgygFSRqqt0q+vJKeBIjYGaGUJAgtpEuUS94nm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1107", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1107` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdRIMoxytiPaYAqlegIQE8sRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyOWFiZDk2LTExMDgtNGNlOS05YTM0LWE0NDkwMThiOTAzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhmNzgzZWEtMDY2\nMS00NTM3LTk1MzMtZmQwZWQ1OGVmZGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+8YZN2HOAB62t8GMTy6gy2jKjlaF6Go8+iE/qCyW7EpSkFilqLMlgM9965ji\ntVpcCKKmBApiAdnaJ+ntMuPzj6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULUxVrPQ5GBJCleG3htlmndjV76UwHwYDVR0j\nBBgwFoAUHdHPaHPgVP8IvpJMMPpCsMqflJQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIH0fOqGyZJ7LVPSimNuzQ875jhdR6cUP/65Ktq5It5pyAiBMLO+dLQUfQaDN\nAolRFUv0rBgFsjof6YtrBoUkLo9dNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXJ3oU/aT0iEp05xF0s6ztWNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjlhYmQ5Ni0xMTA4LTRjZTktOWEzNC1hNDQ5MDE4YjkwM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDhbpNWCLZvykHK4xlvMeyNVgKX+Q3VI5bRF8ThOyj3hDV\nR/s1UZLgt737NvP7t9cNklT8QbUu8QytGF4L9C78o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHdHPaHPgVP8IvpJMMPpCsMqf\nlJQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRYVqa6Nl/1DI92lSaCreKUbk2reaaNCg6vSHgnLsMNECIQCZT4gVlKzu\ni5HXcTm+cYTXvHA4vh831VaaQcVH1RG5Aw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAUsugGqIqwVRihDO40OaHacCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhmNzgzZWEtMDY2MS00NTM3LTk1MzMtZmQwZWQ1OGVmZGUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQwODcyZDY0\nLTczNzQtNDljNC05ODk3LWIxNDQ3ZWVjMDg5YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEDuIfsA05/qaTZG+BOpw6JZlJfkw00cjqAjRYmsa68cLKo/PbK6TkNX\nHCS2W4+Rov8V9vQHLoAuBGRXNx30wwijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC1MVaz0\nORgSQpXht4bZZp3Y1e+lMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIBNQHeMnFXOOpCQThiIsP2fT2icqPeW81Jxl93g/\nX3iaAiEAxGKUyW9AvWETFJNzCbw0je7y7s2YRGmZ5o8MeAb1P30=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1108", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1108` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAS4Kr+dEB0AhDQB4uOg/JQCAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlNTdmZGJlLWQ1NDQtNDBiZC04MThhLTNhMWI4MDEzMmJmYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk4OTMwM2MtZTBj\nNy00OWIwLWI0YWUtNDk3ZWRjZTU0MWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvNNmSTF9ZRlPO+uu/k+0YqgvPFwhYgHoVLP9tlyhtICF0YrAmf26KHPktDVv\nDfk70GTISMOP7WuuGgVrQgvQbqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUqmcVts+rGoxCxO+TV9wR38ir7UwHwYDVR0j\nBBgwFoAU+Cv2R9Cr28JAFLg5nmJWY/bdpjowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBjSG77odKvQ44eArQLYzruSRvQUKmYApsWOIVL5HYA5wIhANK576kbYHRP\neYwta9qiCijU9ORkuQ9dLvT8VSPDvfNg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX/RUFXD9GkgmozPY21BbVbGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTU3ZmRiZS1kNTQ0LTQwYmQtODE4YS0zYTFiODAxMzJiZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASj57voL/FX/hePx4OnAfBKAKvZNKez8BHRuTyYVRbZMSo6\nD2r9A08VcYLAZN0IijVDP4N84crqTLf6OuI2La5Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Cv2R9Cr28JAFLg5nmJWY/bd\npjowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALMLIpmKY7ycU79ktLJeCpjmrxYNhT0XcUYjQeWSe4gpAiEA4eWF9p3j\nPDYPp5iYHJMqT16seZPMeHnyEe/YjTi/Thw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAZYAPsLDPQdelpHW+prauIpLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk4OTMwM2MtZTBjNy00OWIwLWI0YWUtNDk3ZWRjZTU0MWYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY1OWEzOGFi\nLThmOWEtNDVlNS1iMmMyLWM3YTkxNTY0NDJiNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABATCf0ezwfsSI9qNx6EvPuWVMf8ROwvBNNdJOIW70NvynukaawLyChpv\nKXrYpE6V8WxzTxxacuwDAB1LqSkkTjajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFKpnFbb\nPqxqMQsTvk1fcEd/Iq+1MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCAMXETghXezcNwB3RTOYvHVduLWqoOPxX2P8YB\nVnuAYwIgXF0kdU/g4QEfyXrWdZA8stV5OrjmyOB4Ruo/DjPWCuQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1109", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1109` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAT7RXGZJ9x1v9tdm48+CQ9cDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkNDRiNWZiLWU4MTQtNDYxNi05YWYzLWZiNDFmMTZiMzU3YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2E0NDEyYjgtNjUz\nMi00M2NmLWI2ZTUtMmQ4ZDhmZmJjYTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDdN27wviHHbWsvjliN+ZGylOH7UidWW13e8qeM5F6PnlRivAlyt8gPDU79a+\nYIrux0mvjqr03Cnx8O6dZGCoLaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU06cJitpp3zSVTUreQqi/Zb76WdUwHwYDVR0j\nBBgwFoAUIqywf9b1SWRJNPUHLmSGhdBMZ+UwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAuE8RWpm5U7ZorNlfVxqbyoysQiBBUgRYzx+rs4Mx\n/wgCIQDB5iNnOkiyJuaGN8CMtdCZGjD9hqUjdN8RlqCD0JI7iw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVRbsBivydfP+02BWAbe0Zl4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDQ0YjVmYi1lODE0LTQ2MTYtOWFmMy1mYjQxZjE2YjM1N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4it26MbJ/VrJ4RmVUceZpthc16eTEFBbAdGvoGNEF6w1s\nLhL2FgocVk6fYBTcIX4Bdobrvy2vkskHkOHA5e9Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIqywf9b1SWRJNPUHLmSGhdBM\nZ+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANJIZHeVZmYv4YgZUf0KyQonUNnV8dLsqfQ1cyS9LEgVAiEAuiK0elMo\nFIJHBNe5P7Tqpw3xHy5Q0DCemoNW9X4lpCY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAeYg8chY4yNaghUNE6MX7QFQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2E0NDEyYjgtNjUzMi00M2NmLWI2ZTUtMmQ4ZDhmZmJjYTc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYxODZmYzVh\nLWUyN2UtNDA3Ny1iZTlmLWM5MTNmY2UyOTE3MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBV79i7z1ghMz/vBNukgR/9IwmCNjdRvtzfDjGUAy9UOo5ToZ+a+vKnt\npP0lfrEHjthwOo6oa+9JkG+2vBQiKHSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNOnCYra\nad80lU1K3kKov2W++lnVMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIA4Kv9wdfAzIkPql4oR8Jl7ztZMCKRFV4sGUriME\nRg6hAiEAyRmM94wmszOuM049wvjl1ovXEh7+V+MYs1IkRaONxs0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1110", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1110` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAb74VzRXvRh4WgBluFV1TcnmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0YzQxYzhmLTc4NGUtNGM5Yi1hYzM3LTNjNjliNzNkYWQ4YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI5YThkMWYtN2Vl\nYS00ZmMzLWI0NDMtYzE1YzFiMTRkYzk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3vtZEN8cb7bksBy6pVy3XJmWnL/87+JMDWp9McWaPSRTKt2rhdhg4Lj/qkGX\nfEqDNPKL21+STESahJJuT/hpZqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUChjf9PfdPaIPvGuZNDRrjdLX5nkwHwYDVR0j\nBBgwFoAUk42r6q5XJpqRqvM4bCvjmz7561IwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAvmExScGVEtwwDeOM5FYhgtKNZMRneHUEu8m7vjBf\ntiYCID5CyQL4IbyCmeSRrR3G3PFWW1CMy1kLUrsfB1KnTQwm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATwjAobcurkhbU8GiTvaacGEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGM0MWM4Zi03ODRlLTRjOWItYWMzNy0zYzY5YjczZGFkOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6THzLEXA0ClCSuT7hcPkqlp83NLj0L5vSY+SQkqrkGorM\natrhOu/ltE1PIaeuzwxn0JFmh8ZFTRlG2yFh8acoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk42r6q5XJpqRqvM4bCvjmz75\n61IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDcy9+l6JmLNjp6mjAdAziDUTomYVSd+d2qiQ3QMaUf8CIFJI8UsxbHR8\nU+6BgOhFENfy+XVvSBfQkm+Gud1/U/BW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAbnVOr+kSWV+pzmMZ3SF5MquMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI5YThkMWYtN2VlYS00ZmMzLWI0NDMtYzE1YzFiMTRkYzk5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE1MzAzZjQ0\nLTU1ZTEtNDdhNS04YTM5LTlhOTkwNDYzZTJkNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL8Vb/pHPLDylFSklwRd5g3G3tr36/j/dfSEjAM+p58i/hEaRf+Lzx22\nhGsiDSHUuLXj2a1bfv9EcNQavqR3gZOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAoY3/T3\n3T2iD7xrmTQ0a43S1+Z5MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCoZd3I5JojgwfCZt9mDS7QnIYYRmhp3ts48rC4\nTmPMxwIgVQHXEwM3dwFK1hgPm8UwVchvQFfYPstoYz1k8FoKW3U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1111", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1111` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAR93xtLPalVuITIUhKPWwgTQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjODljY2E2LWU5MGMtNDNhYS1iZWI5LWFlZDU5MWY2OGNjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFlODViZDYtYmU5\nZS00OWQ1LWI4NTEtYzVmZThmY2Y5OGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtvbz5Ld4rWqB91aI4sxRYfaUOThMgodIJetKXCSXsvI0hbbhkDSDXwzFldqQ\ngx/r/8B4PHKJKV6m9f2DC3vvuaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsiHu99MrV413JhG6hsvH3FNWuWIwHwYDVR0j\nBBgwFoAU7Gg7w9YbnzrbsBPjUuy9u6OOfH0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBpJox3DOvFeYfuimyy7Sga1BRX3eAMaRQqN0q3hUGnGAIhANF2\nPo7q5OnzL7lhRpG+vJqW+vRGsRJjkh+gtodMURmO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcRyjsfuHX7iHccA+vTRXVp2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzg5Y2NhNi1lOTBjLTQzYWEtYmViOS1hZWQ1OTFmNjhjYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARp4MoTMS3G5OznBtO9NuGUjx9jJSC9C5UJHfs9i2BXYDw8\nPN3klOTOSgSNSD8yl2sg0KzzBQ2xNMMwkxfNnA85o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Gg7w9YbnzrbsBPjUuy9u6OO\nfH0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPL0d7OZrC4I2Ch0gLCpjh/CQ/j8X0Cp+SwfpJR9imVFAiEAtBJtRMrN\nL86Ie0gx1sYT+mzvRJhwQRy3V7uSq5VIyos=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISARc4fUySFJCYSXpeCbzzWv9EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFlODViZDYtYmU5ZS00OWQ1LWI4NTEtYzVmZThmY2Y5OGQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ5NzYyZTVh\nLWI3YzctNDRjYy1iZjUyLTk1NDQ3OWQxMGJhYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMXpHFO753uNHrOLLJB+EYsjJt/kFr12j4wLyaBS4HReR3J7AfgyN5dV\nLR5VLHnVwsm5nda9LT+PjZ5jrbk3Vm6jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLIh7vfT\nK1eNdyYRuobLx9xTVrliMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIEO1AViP8nLc8qCS2uYL9H4n8fpkJu2YheQmBOdG\niM9lAiEA/qRca980z9WFxvprTeFiCo9/fg1fXYaX8/lgm6B/q6E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1112", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1112` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAYdSJpsz3uqU0jhkdGAlpBddMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyMmNlZTM0LTIxZDAtNGIzMy1iNDU5LWM2MmY3NWQ5MWQ4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc1ZGZlOWItYzhm\nOC00ZDg1LWFkOGItZTJkZTBkNjEyOGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWyswygn3IIKE3j+DWQstD9KQx9yaVhiVfZs7qjReqmBBtgcWHv/hagwLQpzo\nq6UKMLkvOQyZeFuWja8X3mFp5qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhGwiZ+HqeIaVXcO3B1jXf0M3d14wHwYDVR0j\nBBgwFoAUHkaE/Smp7s/E4wQlcETovr7Exr0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBwvH9vW15/tLBT/AHzp4gJVolAB+h1T2We\nuqLhIMMRQwIgT7i9itUgGgLGm0u6wfyhf8MvUo4FfP6AHGawED8saB8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeFSODj2J2MyuiwHWaR9RES8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjJjZWUzNC0yMWQwLTRiMzMtYjQ1OS1jNjJmNzVkOTFkOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfMN28FDUBhy/TYRV9HUWo/D6bqURTUESmHqqq7KcCrcBK\nuOFWjP8qJ/1RmLonkX0AXQeKWof1A9SekE52ijfdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHkaE/Smp7s/E4wQlcETovr7E\nxr0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALS90nOpBiNnp1gjsPxSLk4I+nubKx6qaqrrstjBFp4GAiBxOW2VefYZ\nzJ38KVL1JSdQtoBluI9HGBOP0A6Sl4zwDQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAaPkgv36wXfx3PvHCtjWJb1sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc1ZGZlOWItYzhmOC00ZDg1LWFkOGItZTJkZTBkNjEyOGE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEyZmJjZWJk\nLTIwOTYtNGI2YS1iNmY5LWI5OGM0MWQzZTlmMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCM+hXXSPdBTTKzA2uV/JVtmP3kQD2sZf0qQADsNDPf1hYzDSyukqtlf\n7fkLKHjcfynvaqvCyP2+uPxl+pBCRvyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIRsImfh\n6niGlV3DtwdY139DN3deMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQD7vIUYds7IglfNyP8o9BvwBn3xLFICVfoetoJk\ntenKbQIgZBuOb+gTq21+jQ6aCUJX/n3TsLiCZbJs1/vZ/JoBtec=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1113", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1113` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISARz3m5mYyN/r8Z8GpiMqVsB2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0ZGM5NGIxLWI0YjktNDVhYy04MTA4LTgwMjE0NWQwNTliODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQzMTUwMDMtMzkz\nYy00NDZkLWI1MDgtNmI3YTJjMjg0OWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkTZ60VNSPw23kVHwHqh52xZ8goD2Xw4lV12nHiVrgO/h94TavO/GPlnmg2LO\nmE5Bb9kai7aEr/3GkAHF7JMwi6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB4YWHyXLtV1VtW02MXllKqc5vDIwHwYDVR0j\nBBgwFoAUBtyb/7/HrCAyV8F7rYTXNaW8e3owSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA+WXl0PSdlRcaFWNczLdnQKcQBwRB9Gz3\n2r5OCjSQ8QoCIQD7YBaEafGs8k9W9EMhrjA/MGxhpjrXzECFKahSQJPcdg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVzdQtSJCL/l7q8gDr9ZNQoqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGRjOTRiMS1iNGI5LTQ1YWMtODEwOC04MDIxNDVkMDU5YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnHIDQQeL3Kljwt34WuTAU8aDmj/Ed2ti+ipt/ruvErzTK\nErumCTqkT4PbTrnrCFqsSnoOQQkZthxgzH+eFJKZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBtyb/7/HrCAyV8F7rYTXNaW8\ne3owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKNQLYwvSA14WtZW+9ldDFF1fxHGcWaKnQuzZay85pjsCIGvViROknBZ0\nBt/3mAzbHIm9jv5zWCJ43JRAygoUNjWS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdo7AEoS8OCaSI0Ofn1QYIQYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQzMTUwMDMtMzkzYy00NDZkLWI1MDgtNmI3YTJjMjg0OWE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDljZmViYjdi\nLTA0ZDItNDkzNy1iNDlmLWRiYzZmNjgwNWZjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBoQ48yjZBddKRoYHbfEzaA1V3vVQWa94ch7caRhuYgxf0l0d/t3nqSa\npnLstEz+s3uIP6BIjcuMR6ggBQkup9mjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAeGFh8l\ny7VdVbVtNjF5ZSqnObwyMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCdzrewr7kI53f6VehWl1zD0x7CUkfa4p6RSpe9\nUUcywgIgF3jYkmSOkAKefqjYwIgWG4f7q+LH9n0W7TKa6mVqid0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1114", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1114` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAW/6OcMRlpcP3D3LBl8eu2GEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmNzUyODNkLTcwYTQtNDNlYy05ZWMyLTM5YTdmNjFkMzk4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ3YWI0YmItNTA4\nMC00Y2MzLTk2MGMtNjhkNjJiYmY3ZmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx5PQ0iOqyuRGLXfxDZsrvH4uhk8si/ok+7+f3kZT9urz+kLDaVkC2NxsWi8P\nMjXSifo7ZSetow2L96SME0pR6aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTXVYl+bI7yND3ixT+2tjpKKVXEMwHwYDVR0j\nBBgwFoAUea3/h4n5Z+/nr5voFUEXemqcod8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDfc3EjQbD8vdk4jhYBbSw4LQBF\nJdvfzKpeT9OCmocgnAIgM3mHz4QdWbyYfA6f+TISeXBaxkcVVxl5q6RBa2JlUME=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZNUx07aPtGw5CJw87UJOduBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjc1MjgzZC03MGE0LTQzZWMtOWVjMi0zOWE3ZjYxZDM5ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVVH8ErAG3MKt7pbWyrU2cJ4c76Lr0JvnmVX/ah94wBGjA\nEX1FKdye+d77dWGKKre1FdqW8Us5CiNFJydPiyDIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUea3/h4n5Z+/nr5voFUEXemqc\nod8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIzGiUHSrpQQ6Xa/I+cG8Dp8N7xGqnEkp21TQDgbREwUCIApSHSeBoO5p\nf7aP3eoQd70X7o+U4uGGE5A/CeCJqcmW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAQUjGk13ofFhoFQ3JeuAHU4cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ3YWI0YmItNTA4MC00Y2MzLTk2MGMtNjhkNjJiYmY3ZmZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZiYzA1ZWJh\nLTRiOWEtNGY2Mi1hODRmLTIwNDkwODJlZGExYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMckYeZXsaYmaSBncElRLGcJ0tnO2LqnJWlVEkOn4qmDFXnTmhHrKeLk\nAYdw/xibwNumj8d727TQ8YtDGH7MLLWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE11WJfm\nyO8jQ94sU/trY6SilVxDMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIDCF0yQ2OWR+wQDWTJ3L+WM0mGYfpr96z8tIS9hT\nFxzMAiEA71dDzdPXIJXN2seC/0uWZjWAjeN0/eVFQADD8JACb1E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1115", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1115` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAQMJ8PzMabJqzq436DtokoHyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2MjhhYTA0LTVlOGEtNDI2Ny1hYjM0LTljMWNkMWRmOTFmYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE2MTIzOWUtOTNh\nYy00ZjkyLTg1NGQtN2Q5NDkxY2RhMzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiRtET6T735E3wiu7N68u9c1T05EUKnECdptFnxeH/BC9ZVCCVLXMbNrpxZp7\nnRKjdQF+4ppbEPhmmkT0a6574KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw9s3rG6KB9JG8jEGg/Uh4UWi6WowHwYDVR0j\nBBgwFoAUgDSUTtZ2S5dyXOyBDzFA9cPWLnkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgY9hv0iDE\nkkK9ru4pAdbGg9QraKMYfIRGIol/fwNgTRUCICP+ljYF1K12mpmPmNyDvUZ/rZcV\naDLe8CjaHyYAorgm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASJpGFqoK4gMzpqarFQ0N+CEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjI4YWEwNC01ZThhLTQyNjctYWIzNC05YzFjZDFkZjkxZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASC6hB0uWFVXM08CmWBSKeEHJymWu+bPT+etAD/Pw9eJmWu\nBoblTgXCDZDWT0fSJ5l8Sd1qNGxiY0a1AeFOWNfIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgDSUTtZ2S5dyXOyBDzFA9cPW\nLnkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALJvJbH9mz1XoIxy7MbmqFVAOJalUArXGqa6aAwLD5ffAiEAohSFjU5p\n1H/gYOfxIsFi6k058ZPFxm/wdxgmKunor8k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISATsy/2lG4/4dfYisE4LrfbKDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE2MTIzOWUtOTNhYy00ZjkyLTg1NGQtN2Q5NDkxY2RhMzBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVjZmMzYjhi\nLTkwNzAtNGY1Zi1iY2RlLTEzYjEwYWNjOGU2MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDH9oyYtDDJwa/PTZBP9w+HtHnenox2mw3dyHe9yLNXiDYQ4GvCJsUNt\nt6op4wnye0C/Vn05zWcRbivry/IaaE6jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMPbN6xu\nigfSRvIxBoP1IeFFoulqMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCBWt3r22M3Jbklk2THtozBXWV6lxzEoMxiH0XU\npNV4AAIhANvogJURE0T6f86/3pk7cuDvjvkskO+WruLFzBo+H8J2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1116", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1116` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAb4McK/X36rdVioKau7MMDbfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkNGFmYzY4LTdmNGEtNGVjYi1iZjAyLTNmMmFmODQ4MDVlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJlZWNmMjktNmNk\nYi00NWFlLWEwNzktM2RiZWE0NjM1OGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjo4vAxTCN7oOEPw1lAhYdwHF4O/QTofcEuK7bwzh98Fh+mu4bF9vjhCl06oI\nU9C0zWjM3XtlMhGLM/2iHgGZkaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT3JghTU5pYBgH5HihMPBueGY0RIwHwYDVR0j\nBBgwFoAUGM4YxNUcRYpqbcJ1nY146fB2FlAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgBXrlx6Wa\n7rPMZObBLZmoO+gBLWdMsdK84huKzzx6f/gCIQD/pDtc/4Ah4eQ4itq4rd6Cao+M\nU2eZkTzYIrh3FY9kZw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWZv1ws96wGD+hCViELErPmeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDRhZmM2OC03ZjRhLTRlY2ItYmYwMi0zZjJhZjg0ODA1ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWBcrsI7Bh1uXONPDJeqpvTCaaJaKOrJNtUZBXEln+biHE\nRlMVRvG8pLaiIbjTDwLhNEAm+tGsHm4CImD1EPvfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGM4YxNUcRYpqbcJ1nY146fB2\nFlAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKxSu38h6KV8m4LtdImxcEQy/LsTuZeRRV2nFUVGKRB8AiA+dwEBQrkK\nvb72RAdHOTRZWIGj6Ou1Bn+UycT+OxE/IQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISATsxCN2Vhg4w76FKEul4mEa3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJlZWNmMjktNmNkYi00NWFlLWEwNzktM2RiZWE0NjM1OGVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJjNTE4NDcw\nLWNmMGUtNDI1MS1iNzA2LWRkMTNmZDk1MTEzYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAgELMFqGEaPgqEvq8VH+yGySqwyyu6Dko3tJE4XQiYELkBQPboAVVAc\niAYlcxaXDCSUBkXc+l5lfAOTm+wdj9WjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE9yYIU1\nOaWAYB+R4oTDwbnhmNESMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCOKsX0WK+PM9l5bRmaPHogjDuWqlLDeXr393q4\nQKRV3wIhALh9w8Jdhii/Py2zd8KpGwh08t/kwYyqK1TgkQSagmxF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1117", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1117` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAWDdDji4TkbhyryWnwxSh9jFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3M2FkNTFhLTAwZmYtNDhkZC04ZDFiLTg5NGMwMGMxYTYxNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYyZmZhMzQtZDI2\nNy00MTQwLTkwOTktMzFhZjU5YjNkODI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpa3yLfn/06o76knclA5fRLg5UYnKXDSqHx5FEu1NdM/CnZL9278iSrI0O2OV\nfTH1klXIXBytotwRN9sUYz/kT6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeCq1/DlrbR4VYdHeCx+gUedgkiQwHwYDVR0j\nBBgwFoAUx4yfv8TJD7TkuP1rI0V2smYTB7AwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIG4x+EVn\nq6ag0FOGllz2lrIEQiVSIqWIVnlPk59KvhpiAiA9R+wONacOSTL780zan8w/4AGY\nefGfrd0Jj0TAgdkyhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWcvnwIbP1KjHuJgRI6Gf3h4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzNhZDUxYS0wMGZmLTQ4ZGQtOGQxYi04OTRjMDBjMWE2MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyO45JiJhRYuvsBDrOQOmEQDaU6WjXUyS+f48bWrOKzWFh\nIzpG75j7Be0/ErOpr664zTbERFsJicJ0stIlPj+do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx4yfv8TJD7TkuP1rI0V2smYT\nB7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJacvHo27Dx+gMB+lk5GjeZnuUWnvUkA7IUGmKqxEIqsCIDx/yvzs8QTs\n24ni52SheU/mg2XSvQ3WkQM7N+1Xt6u8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdLtsGqdqfvSMtNzz0Tu68+VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYyZmZhMzQtZDI2Ny00MTQwLTkwOTktMzFhZjU5YjNkODI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI5MDk5Y2Zj\nLTU2Y2EtNDhlNy05YmY5LWUwMDA2ZDE1NWM1MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNdUBh73xnudxdpcdItPiUyNUsrWqyGZAEARIgHttSiI/G8ZrfqkWu+s\n5EKMOPF+SZz3aV1R0/d5NC9WNYVG9yyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHgqtfw5\na20eFWHR3gsfoFHnYJIkMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQDw29ZiLrLCO6FOG0pAmn/zqM9T99R0/BR+p9ZJ\noF778AIgISEDISSIXAx2htiLK4q2kbx+rjeyRxxQPst98r1yHGk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1118", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1118` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAQXCy74UPItDyPJ+ADPUNRRmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiYWMzOTcwLTMwZTItNDE4OS04YmZmLTMxOTc0Mjg5MjMyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM2OTZiMzUtMTQz\nNi00Mjk5LTgwOTktZmQzZTJhZTA4ODFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/YR7U+MFyMTBgCOs8OUwghcG4SbJJG1u+NxW1xNAOL3hCgMzHRD6oyf+n+Og\nvCKluNSBwccKQehQPPkf6aEJ+qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtGpu2kgIfIPtQ5OXATM3qUgDMd8wHwYDVR0j\nBBgwFoAUFhpDR4gaJ46sHsXPgA/reQjXX1MwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDzNoRg+Tpl6RRiPYmSL+G56nuhWuiPv/68pHO6V4OxcwIhAKxIqOYk\nWPQzhx0SCnA/3ViVqgiVbxokL9cCKeu7DhBQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUILuoyx2EHSWPVvtFxSDD2LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmFjMzk3MC0zMGUyLTQxODktOGJmZi0zMTk3NDI4OTIzMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLlaUlkHQ8vEPvvR8rZv7Jvpn3hwxWVeOo/ZMIrMy6XoeG\njmTLfiFqQOJczCntXywegioMkaVxj1mzeRM/VcVgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFhpDR4gaJ46sHsXPgA/reQjX\nX1MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgd/MBGQLy8IdpVkjvMJVoZbJeMtgw0vvU4boqMlcTWPICIQC+3jgUAXha\njKWxgH9Q33LS1JtN5Mdx6T/LLbTr4X5PdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISATNEnTzDnUCqe7ywVK02PKXdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM2OTZiMzUtMTQzNi00Mjk5LTgwOTktZmQzZTJhZTA4ODFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFkZTkwYzRl\nLTczMTQtNDc4ZC1iODJmLWIwNzc4NDg5YjJlMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOvFZcrQH6/E3rC8v1g13LIS6PQTw+UX+wW+XgkdsalnNE6tW6CWENPE\nHEpjejV0dSjfuGdwOoELmzWnzFxFRvKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLRqbtpI\nCHyD7UOTlwEzN6lIAzHfMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCICnwTe/KtoQBHl/o2vW4X+L32xel4fukH2WHRBF/\nOkzSAiEAyrHzYxeoluB2dVbZA3fsSzEpDGZP6S/+NfS8DFDoIgg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1119", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1119` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAaK/itCipc1UKCx9XqBuydyCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5YWIwZGEzLTY4MGEtNGY4Zi1hODgwLWUxNTRjMTRjNTM0YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFhYzliMTAtNjUy\nMi00ZmZjLThjMWUtNTc4YjJiODM2ZTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEWN6Orb/HjUw3E7/CrouNW+CJ01lvaQ2R1/kEXgjdH1uEbni5ry1OYNmHcOd\nkz5dm1cUmdfqMihG7I+A+2j6xqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW0QxJ6SPkhqNxiTUEt6+uWX42IowHwYDVR0j\nBBgwFoAUlUGcdnd/H5W8pCliz8XFBrW+OQkwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCcXIKzb/dZ63KHM1YwtaA/jJXPBlgAen/mE8I3qJmT4wIhAK5tXGAY\nk7FY0RDKS/pyBKOT66qWkVbndsJCtio7AnAB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZkmQbmnDR4wLUkIp2EqQPqQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWFiMGRhMy02ODBhLTRmOGYtYTg4MC1lMTU0YzE0YzUzNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATa+FMIwfHX37gnBcNvYDAKMh6e1oPDyYWVv2tfTajUuYbp\nWUO4g9qS1IUDdJiuFygqN+A9ZNmXK/LlhO5W1LHTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlUGcdnd/H5W8pCliz8XFBrW+\nOQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP7xBPe4uBEWQaJ2BDGefiVxBYi5z8ebpgdERy6Rw9hsCIHJq+ZBSdnfW\nahvpvE1SEVwR4OPNQeHu8+MHLueXhTQa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISATwXCkZ3dWxC+bWlkmJYLkvNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFhYzliMTAtNjUyMi00ZmZjLThjMWUtNTc4YjJiODM2ZTM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBkMmM0Zjhh\nLWU1MjQtNGViZS04MTFhLThjNzg0YTk3NzEzZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIpYTXhufODWvdHHgnUjL1x3jgGoTfE34PIxdLqaQGXuI/XhKFJEqvva\nJN/YA7gcANMoT+2xUTQblXgZLd/xBfajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFtEMSek\nj5IajcYk1BLevrll+NiKMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIBc2/Ej7BPoAOvUeajAYe2AhlonGav1Nzo4y32Qp\nGsAwAiBkRo3XjQK3kuH9ILttj7oeQY6LtTr64PlHZq9ilq1QNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1120", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1120` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAc5FUiAkgMKS14ALoAYFVOGBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NWZiYjZjLTZkMmEtNDhkNi05YTRjLTcxYTViYjAxNTgwZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM2YTQ0MGUtYWYw\nMS00ZjU0LTk4MzEtZWY4NWE0NTgzYzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/ghjw+J+lTEZLTGThm2NGG7zDOm3cC+1waoy8MqD3xtUo0yNKQI008bi895e\nYF6iX09CKo5RDrDrJeQDyKQLHqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiqNAKTmRl89YWZxcSYnWnVRZw0cwHwYDVR0j\nBBgwFoAUqo4kazqEOEBLOMSH1sG9CJ/cek8wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQDNroobdG7mzVEj2e7zM/d8pToFwP9P3pqCgZWeV6yHxwIhAN9MsLiYS1pPWT2u\nX5Sab6MqlaNl+38hRhWY8L2xVZxf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf/mwSAWJAU2OrjlwNzh++32MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTVmYmI2Yy02ZDJhLTQ4ZDYtOWE0Yy03MWE1YmIwMTU4MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASc/0Fh/LHlBWq/H44a8tlNgSOgVAh6PujjV9whP8Aw6s5j\nwOrAb0KrmDp4h52YIkdCgO/JS5WQpoaL/nf7imu+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqo4kazqEOEBLOMSH1sG9CJ/c\nek8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOIQfie/876r+Ax9YNv4lVGpKbjiLd/ZVIpfzxi2Em3SAiAxFvO+RbjO\nASzH+v7+JlA/6e63eEztl+IcQFTUg9yegw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISATryB1HJ/joZcsDzVQSRyX51MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM2YTQ0MGUtYWYwMS00ZjU0LTk4MzEtZWY4NWE0NTgzYzgzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZjZDJmNzA1\nLWY5YmItNGJjYy04NDY0LTE1ZWRhNDJmNWI3ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJuMGljoQQUUsYCRcTZvHvxPMzcOEVkRPTb/iOUPg5bL3njlqdoE233g\naqAdXvhnR0ojajlXdspyFmzMXm679hCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIqjQCk5\nkZfPWFmcXEmJ1p1UWcNHMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIC2OdYX9vJWuYEXq6qd7gfnlD9wj6BzOa/38bCme\n6kAfAiEArK0+FJ8IeYpR+Fgdf2GEzvLVqc1O4WBNo5wEUgGjz5o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1121", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1121` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISARfeo+R+za2yEv3QRONPe8vAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhN2MzMTBlLTU2NzQtNGEyOC04MGZiLTkzNGZjYjJlZmY5YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZjNDhkYjgtMGMy\nMi00MjdjLTkzNWYtMThiMWM1NDA5ZjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEePt9qHHz7J8jfH/fvwH5Wc+j4Rjt/+xpfscfSeD7TLmNGkFd98m3xQxwSoiJ\ndm2UF6ZwqU6LieLE+5Z2qn3RsqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxUI46tIiTROyaFbYhrxaaZ1nuaswHwYDVR0j\nBBgwFoAU8PyFGQe4uv6T0rlrSdx9w6uul5AwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQC15FdsHfXatz0S/MyYulJdJQeGut7+eXxwh3+JY2jfdAIh\nALvvwiUThgkZ50eRZWBpaQDXXL4tz5vWlzScE4aMX65R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVIMRgEmw0K2acGCLhywZq6fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTdjMzEwZS01Njc0LTRhMjgtODBmYi05MzRmY2IyZWZmOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgfyNOmsgua/o3pb6sPMHA/SSNMhikLbQ41bw5KnW/j05K\no99X7WKAJPcgPez5DFluKHs70KXwMhIUMnjn812zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8PyFGQe4uv6T0rlrSdx9w6uu\nl5AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQyn6krVfvwS0HcpEoGqmSDNJVYV/ZILaWOZBIgweSKoCIQD/Su1gvYpj\nLXP04t7Pto7TbYXqqakyr4bNSagJEIoLSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAY7bKEmBErA4II6tZ1Dr9sTeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZjNDhkYjgtMGMyMi00MjdjLTkzNWYtMThiMWM1NDA5ZjE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ5YjFhZWFk\nLTBhYjQtNGNhZi1iZGZhLTJmYTZmMDQ3NTE5MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCO3JChRFXeMuGUHuCoZiJq7ZGrajvhqO7zjb9zkpS5+g+sm2a5v2gbn\nzWMQSFHDlnJSvn4Ei1mEsJcGp3n0paOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMVCOOrS\nIk0TsmhW2Ia8WmmdZ7mrMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQDKOszUXtLcyp8DOJDvZ7K5CB4UjPkXdVwa0M5b\nA5VQfgIgKZo0ynxeefM2ObWkzzcyUB2DYfEv87xV5IKDQb2e3Ks=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1122", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1122` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAd/UROYrqDBUliMD9JLudvsjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyMmZmZjU3LWI0ZTctNDM5OS04NTQxLWFmNjg4ODkyNjEyOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ1NTU3ZGEtZDk4\nYS00NWEzLTkwNzItNGIwNDFjM2MzODExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEevM6UVC7OVrdD1cNTHUg8OcAZWhDwS+P6y5D9w/mKlmyRM44NcXRNAVSh1uO\nFhKhLm+2rHcDYHFptNWagnxV4KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9BJycHmvxR2vFNOWMzBX6T2ra3swHwYDVR0j\nBBgwFoAUZ6M5200clTInMkY0NZxclVxAiO0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCiGyQK/Cq0QpjfITD/chnTBVwXjnW1FgLrr5eGkLcwywIg\naj8dtR9CrzjwE9/pnHZZ10wm4ARNmTN6VyldJew+AC0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ+NDju8a7XzA4gi/+aB3JAeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjJmZmY1Ny1iNGU3LTQzOTktODU0MS1hZjY4ODg5MjYxMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBxOkIf/But0h+7HpP5k5z4Bd+tKXEsGAMVeGtfzcOyATY\nZmTuWfBKyQI6FTyomTRHzKW/x7baPyKkO+XjK5f8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ6M5200clTInMkY0NZxclVxA\niO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPTgcSCsBt5rn/r9PmUwZ3ZlAINj8guE2O9N+MLHN+EVAiEAiTPGO97g\nQPn+Qhsk0tkida/oPD27GmG+Fe2IHUyv2Io=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAedAZ756vb+Tj49Yf/N13nzqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ1NTU3ZGEtZDk4YS00NWEzLTkwNzItNGIwNDFjM2MzODExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY4Y2Q3YzQ5\nLTg5NzctNGEyZS1iNDk3LWVmYmJiNzg4OTI1ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO7EuFestBF8EQiArduaykDrmN5/aEIJ399C6JCCQDGSJu306s7I6Gz1\nv4vFOhWUBkYXiIHnXnP3AlWHBFXgpN+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPQScnB5\nr8UdrxTTljMwV+k9q2t7MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIAY66VmXeD6YJrW9H3Dz8cVpa+PUmKp5swPCicZj\n1LtYAiABWhT1NifP0lb3ZR0v5JmDfDkoimDhgVxf8cxgpwPe2A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1123", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1123` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYpRfN8mu/TA7EgeamxpY+BFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwMDIxMmY0LWZhM2MtNDBlMC1iZTRiLWU3YTM5OWIzYzhkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FjZGQzNmQtZTIy\nMC00NTliLTlmNjQtMzdkOGFkZGI1NTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvO8gpbPN+k1pMgO6f64TflZNhtKZLl2MhQyE995LiN+XU8zf1Sh3WD9zCx0X\noB1etYb2gBWHMb6GSeh4l1/a1qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPayyuznmD47sI4cBYdTBE2XEbWowHwYDVR0j\nBBgwFoAUf0NnqkOKHGIqy/bbO5/KZ6qlxGowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD22jXhu8iQ\nwqHrfwP9F6G7az10LWnep2trfrOZLg9J2AIhAPlkbba8SJpzGSyTtceF8Dlh+pv+\nQHDLnq9/aKlAILFl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU3RCOxQDlQ8mBtMzJGO+lsxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDAyMTJmNC1mYTNjLTQwZTAtYmU0Yi1lN2EzOTliM2M4ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyRHEgKyDI/HN1RirY4SCwrpevsf+snVW1fdycrZ6OpbOB\nB2RkQD+9e7ulc87ioRJmflDyUHSLyzQaj+SjJaqBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf0NnqkOKHGIqy/bbO5/KZ6ql\nxGowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgS5cGeL6wL6ytJoSwoGluC6FpJj5f0FYqWHDHsD39lvACICO8ZlUdZiMQ\no7ZADniv02kRYWpWU8ZHaurMV/3Lz1Su\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAY2TFuZ8JnY6x0TTGLqyWkxXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FjZGQzNmQtZTIyMC00NTliLTlmNjQtMzdkOGFkZGI1NTljMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVhNjkwOGY2\nLWJiYTgtNDEwMC05Njc1LWZmZGUyMGZmMGMzODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEWO+8AXkwSxQJM7HrmaYlK6AKn3xN82Sl6Uy+tX454BmU4elKMcRDLz\nOG18ZIhHM0dz6CRTJDdHJfqvva9KEvqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD2ssrs5\n5g+O7COHAWHUwRNlxG1qMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCICFJzfz9I+9LDNa8fT0V9Erl3ZOuFRK6QA6Fgfrh\nbK2PAiEAwnjV0MQcSAyV4/YiFlMe+LhDPJmTyTM78cNsvrtVHrI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1124", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1124` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAaxJPvH/y69tkvJk7Nl4pWr9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMDdmMDRkLTk5NTctNDZiMi1hM2VjLTFmYTY4ZjhkZWE5MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzk3YjAxN2UtMGVi\nZi00NGM4LWFkNTEtMWIwNDcyZTQxZDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcktmwJ+pocfjqH5FJwkvlhpuh5v+s/PiGmGzb8p5jv7IogtPsmOH8fDstrxs\nJeylCr3KLkmNXk0kE9AHEqibbaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6HoEcvYR7bT/7DwsZIC/2muFm5gwHwYDVR0j\nBBgwFoAU8zYifLz+HFbXbpg38rSa74UpWxowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIv2769mYSTj9U4tZ0GwWbm3tZIsFQjlEHwB/LCBY4PCAiEAoUP6FQd2\nN5bAbTTcSJ+LHmn14RCrgL6S2aS3IfLy7+o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARbXxG7lPEwWipO9vGOI1W5fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTA3ZjA0ZC05OTU3LTQ2YjItYTNlYy0xZmE2OGY4ZGVhOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXRpbj4i4ZHK5qiK9He3ChzYbimUSY9s/B+4E5kaojFbeC\n/hXN9wgH0/24VzrpBmuVyRVlDGr2cJ5E+CtWilR8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8zYifLz+HFbXbpg38rSa74Up\nWxowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMTMNf3WJcMkgxLZkWeHcjbhjlQASd7bbanJhaPmpzIjAiABPUQHu0M+\n0i6ZyoisuD6ROqadQ9WO2NWTfnKZRS6P7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAcR3m9fUU5SAfAeU5ZKChyUOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzk3YjAxN2UtMGViZi00NGM4LWFkNTEtMWIwNDcyZTQxZDRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMyMDFiYmUz\nLTU4MzAtNDM4Zi05ZmJiLTJlYWJjYjBkMjMzYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEC+nAXo5BOjF0YdxW1yRgm+9tViQQzGV6+cOeZ77rn6o3OiMu3RBD+b\nSVruIq1TGopHuTzSSnrudzNjRMzvJESjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOh6BHL2\nEe20/+w8LGSAv9prhZuYMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQDOZtNjU7vovtpoceE9JY0BXNdYXrMv6sK2m1q0\n6jnt0QIgczB5vU+Y54bZ5LvzX9v9eR2EvCpVUemvuUiX/YUaIk4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1125", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1125` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAR+26wl1hf8A71Rs+rR+DTP2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjN2IzNzYyLThhMTEtNDVhZi05OWQ4LTA2MTdjMmVkOWRiYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNlYmI2ODItNDlj\nNC00ODJlLThmOWItNGJlOTQzOGFjMTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA77KvOf0zXuauJtvyMOB6C2ipfmQoPKfF1x/9sdU2qP0XuNNCCdtEaHEIXDX\n9M4439kAhcxhwhSI5EInGv3cK6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+fmEig33v4b7p0LtXPV3KDzRJBgwHwYDVR0j\nBBgwFoAUU318UXjoPTpdn3RRSxkv2JKeHs8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgbiRum/MryTr8OXbqsgOL1EOJEql4uWulewIaliVPdOECIG8h2jX/5y6c\nHUacja5DUbuyu23FpmFpoBweHB9zUlCu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATmRTIpHUVElaf18M3UoqR9OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzdiMzc2Mi04YTExLTQ1YWYtOTlkOC0wNjE3YzJlZDlkYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2SR8P+zdL/Qcyy6BvcN/ZJwDj3MvYT7XJ6INFU12f78RC\nDG8F0fw3zd3wq2JFV/GhKF+Vbr3QxPpF4wfOwFsGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU318UXjoPTpdn3RRSxkv2JKe\nHs8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcAwRU+3g1PvtApMjBevSKnNBnWJFhHGGFCfYMcwfP0oCIQDwpbKDRP9Z\nqMTEPEbTiC6kNyixhIrau4Zc/iWGN9OPkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAYQb3VtXwriYEAPTXzXnoAtNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNlYmI2ODItNDljNC00ODJlLThmOWItNGJlOTQzOGFjMTAxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJiMDQ4MGFm\nLTgxMmYtNDQ0Yy1iZDZlLWE0NzE3NDU0ZWJiYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNr4QAi17xUPJqHQxoS0NXMxpOD/nTiR9cTuQgDDH9bF2RwFYSwQn4bF\nkJjDRqDI1KZZGhI2qE7wTTdgJ/A8BhSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPn5hIoN\n97+G+6dC7Vz1dyg80SQYMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCFL8FgPmqdR/0O6dHq2mpgLAkd5ZDfqH/bRbW2\nVwmo+wIgFixJsijMBrekMTlWeYznxhUIKktZu5p6aY69IJtms4Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1126", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1126` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAXG0L9jfME+ZBgpZgcJnjVsjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkNGUyNzc0LTAyZmEtNDMyMi1hZmUzLWEzMjM0NjhiYWU1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGUxZmFhZjgtNzhj\nZi00YWYxLThjNjEtOWJmMTdhOTYxNTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEICqbZXQalinkifAQnnwtzt+4SMU+/F9NkOPrFZ7TZEEcauUhi8nCTYSn3l5+\n87zxb3grM/zuC6Dly9Fvpbcye6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUREi48HL/o+YS0N0mGN01NRIZikYwHwYDVR0j\nBBgwFoAUig0acNjVb9m0P9YSm31nYWW6u28wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICK1G9G0qWmDhTHuEMwtqeiOLG1RdQhpfzLxLC3Qclj1AiEAxqB5S+KE\nkq28sQAM2FXuilEiaHKG36CtnsH1nemBIxo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVrEBazolkTv0kFC67iJcPCRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDRlMjc3NC0wMmZhLTQzMjItYWZlMy1hMzIzNDY4YmFlNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0+8y3gx8o8nYK7uhiPWcL5LB4QxzKythuSe0CETCTKaSb\nssyBnbWRKd2UTFI7qH8AHYx+TDrEiU6AsSrSQN4qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUig0acNjVb9m0P9YSm31nYWW6\nu28wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMvXSvEwVUbgH5YvnP2xhZpOKwEKVPr3iS+0R1Y9GpafAiEAq0/664fm\nPRm5uRq5JM+ixI9a3DFZLWV3AiTh3aMqUz8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAZERijTwPp3P8ofTTe9P+x3VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGUxZmFhZjgtNzhjZi00YWYxLThjNjEtOWJmMTdhOTYxNTRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVmN2FkMmEw\nLWFhMjUtNDIxYi1hZDJiLTg0MWI4ZDRjODBjMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPn0O3Wp90GQLQTKt24PTs/RLGbu9ThRRo9rA7pF569F/TMBKNETD605\n33e5dmhW1BgWb1j98U1YLx4fMalyDwajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFERIuPBy\n/6PmEtDdJhjdNTUSGYpGMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCwn36ee48KY7iOqjQJhqLCxv75LwiGxp/uiGUf\nzvMmDwIgRVn/T2YPhvO2UyB3lmfoxjCZtd82aIugyLtgs7zrE1k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1127", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1127` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISASmzKX7PybVUrPmdsk4CpVFlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0ZGQ1MTcxLTA5MDktNDJhYy1iNjczLTQyNjc3ZjFkYzk3NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc4OGE4YjQtMGNh\nNy00YmFhLWE1ODQtZGM4MWVhYjU2NjE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9TptU7urpoSrE8+n2R/7Tsxcc/txcf+YBTnfUXCdkmDIWGipo2l/1NBjtGJD\nSxejizJibY9+x/ZUoL5KOTsVbaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmB8r0BMx8KJZE0Y7QU3D0jQ22AYwHwYDVR0j\nBBgwFoAU+0RBgxCjBRgOcGWTywvfeVVFIAcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD6wORHFTX2zfhRRacg00oJrSYE1GDTZf+E4oVZ\nV5dWZQIgJ2ZJWLzyRgIjmwOZXAZD1pQ7s2nBlSwxbnh0MBoJfuA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQmtyTrACb6iCx4ScngMUR+VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGRkNTE3MS0wOTA5LTQyYWMtYjY3My00MjY3N2YxZGM5NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATU6xLL/VYx/pz+H4YDL9D4NaFUqv/g/woTmlhO/DvXjiCI\nydp7DWb6H+F9bk9UXrv1XTyGTkPKxCsKvlBr/wRvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+0RBgxCjBRgOcGWTywvfeVVF\nIAcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMYSDtk3o4TTve6e4ah/PLjm1hueI7ZmM/66vmmdHcfcAiA5myqpNf5p\nB2Ba4t1JzOUPaHsFapMEYUrTHA8tnqPyvw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAW0qrFe/W0qsSgrKjPfG6w1JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc4OGE4YjQtMGNhNy00YmFhLWE1ODQtZGM4MWVhYjU2NjE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ2ODAxMTBh\nLWFlZjItNGY1MS04NTFkLTgzYTNmNjcwNWVjMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFY4HuDsKD4DQRzw7qeKPciW8qcE+K8d9P9Y7kBNqCoWNz3NhV8UHugb\nwINvQIe1wFgpUN+qLc5GWtAANLplxtCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJgfK9AT\nMfCiWRNGO0FNw9I0NtgGMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIAY8f67PuBLTewzzesr8sAwy49a6U95tkXJ86AWZ\neKB3AiBAW5S6mu3SH+YE3et3SwMd+YGU2kzBSybJAndCAC/NYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1128", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1128` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVMTX760PoZGQXurDxXO2uPnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMTEwMjg3LWY5Y2YtNGI3Yy05ZmU3LTQwZGUyY2JjN2NkMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYyODQzMTUtMzRh\nZS00MGJhLTkzNTAtNjNjYjljM2RiYWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzWcssAUtxFPKW5nX1AlkIlTm1+dIie11CKTvkwFVOEIQ51T6gTOg/qMB7d6w\nLMJUynU3wfl431VQ1A77giS4wKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUer408gVFNVIhTKAKypJFktQysNwwHwYDVR0j\nBBgwFoAUe61zkadaWIF/DWEM4hTAM33OiJEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHiixuz/iLiyRuFBnCse2h05tWttgvYeF7jPpFmg\n6GiEAiEA1H0fcQz3AWZBeqCOuQujYL0EBe/MgLvfbOa7TkSugyk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW+w+rIotWMkzEQ8E974HYK9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjExMDI4Ny1mOWNmLTRiN2MtOWZlNy00MGRlMmNiYzdjZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHGT4dqemkMOa5sKVAHHS15FQrCB37+b2yw3ODiOUGH/NV\nHw8pZtog94B8bB42rgE2wmazMcpQ5nIvR2zwoMpwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe61zkadaWIF/DWEM4hTAM33O\niJEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANE2DcruJdzk0XAgQtvIPylnK4i5n7TcYFyEaDFQYmFpAiEArwsLgsmW\nkpnFQHPaDB3EWbSJCW1COh4xZDn9ER1mfjU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAbggVvUqOGj4NZG6mxVkV2tcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYyODQzMTUtMzRhZS00MGJhLTkzNTAtNjNjYjljM2RiYWFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ5Mjc3YzZi\nLTNmNTEtNDMzOS1iYTM1LTY5Mjc5MGU4NzU5NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJZ5f6zchWCk2Q92xYy+P7EEPfmVccoybG9OlhOrY0MOV4FSRsmUKowm\nbtF8zLPQK1BmGtCI71uOfAi4v5bx2eKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHq+NPIF\nRTVSIUygCsqSRZLUMrDcMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIAeTvQdHVWyHN4s+fPSmmqGJwyoXThVTxDDw5C6q\na9hZAiBWNJGhWISB1IYazfJ9kUyg0ZAT+DQmiFbiGBbeflBq9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1129", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1129` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUNZuiWMOdEnUzQpNMsk+MK+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2NjljZmRkLWRjYjgtNDBlYi1hNDdiLTM3OWYwOTM5NDE1YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTIzYTZkNzktOTI2\nMi00ODY2LWFmODktZmQxNTA2OTljY2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESsAP7Nli3NMlreObgJctSVJxzhAVZoDro35xZogkPzYiJhOyLMZ/RLEu51qk\ncTxvhIAGUWEelzCdN4uEv5JM76OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjjv7/qp4uxcJBB8d9co+G1v/9MIwHwYDVR0j\nBBgwFoAUseAQbCFxYXOTmu0nOh6stZuM4vswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCak8sDwjrGrwmrj2YwnMoBK2rA8CQeJsdPlIXQoYyZowIg\nODY8FPoRgwcJ4g2mOcHY+bPNhG7OA+xzrWemjMqHlbU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVh7DmF02cYTcxTGidwLG/EuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjY5Y2ZkZC1kY2I4LTQwZWItYTQ3Yi0zNzlmMDkzOTQxNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOnp2swrSrkO7v5QVuLhuFzH3gQo4B3FOfYSu3+jvAHFka\nyB97fTGEcbRD42Zwdsh8XhIwCzCDdFkDE7FvybG6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUseAQbCFxYXOTmu0nOh6stZuM\n4vswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMaCILyDsIpCykA0MmD7hdGIzpEUkF4QMGHPFj/2aWw2AiEA9dSBCptv\nX0qfBBn0YzcMx0CZbx3lTMn4Q2vJQyVMz+o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAQPzZ6iyhK40MHQJdL/zS47IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTIzYTZkNzktOTI2Mi00ODY2LWFmODktZmQxNTA2OTljY2QyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIzZGY3N2Y0\nLTcyYjctNDU1Zi05ZDNmLTEzMTExNWRlYWFjODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOYwztL/Sb37E6X2ryudTBrTy/FSAkR5APgV3bTzp0I8b9nK9hO4ctFv\nrgwO5j56FVvGr+rSzDmp9xAWkL52u4GjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI47+/6q\neLsXCQQfHfXKPhtb//TCMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCRgP8NQv8ZduMCGF6laHBuMEoF9n1qPAVt2i9W\n6f6DZAIgbvpMFqQJV8NXwfIBepcNdkGpdAo8UP2MufcHDxv5kwI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1130", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1130` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAbII3B7NTsGqYm9mhxRgY2F9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlZGRmODhlLWQxNDctNGY3OC1hZTgwLTkwMGMyN2ExYTIxYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZjNjAzODctOTNh\nMy00MGIzLTgzOWUtODk5NGU5NmNhZjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5KPhBVEiki2CCd/OhbSoAeVDVxR1Pu868fhx7P7D60iZXoivLrLTQ7noOnMO\nZ4DtAiTVI8ai0esuZ0Lb4rvrhaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl3xvaPACPrUjlgvxqFlLykkB6mAwHwYDVR0j\nBBgwFoAUKcipKcuFAG9B7MP2uQKRk1y63ncwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCfiRXmgHRQUX3Dx5m3OWIIHv7BGF3q\nbCijxgNJuX/JXwIhAJA5jPyQ53vZ2Pep8vHxLMLrzeY3KBbG6MzV0TeFdjjA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZx5N/Uuw59yoPYlGmVGoAblMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWRkZjg4ZS1kMTQ3LTRmNzgtYWU4MC05MDBjMjdhMWEyMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGejFPHuYqd4f1lbMs/JuM1r48eODv3ftqUdkZaNHv5eMC\nToDbKZ8jG4ZnDAGzGXApG3UX5w2gGT/kJxscuiORo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKcipKcuFAG9B7MP2uQKRk1y6\n3ncwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO+3jtJpUsKaKeCWxUWS68BnrTfamnqK01LyiNQy4awNAiBNX8q2KwOs\n/Ty6Rs7mBgeSbdhoZEpyUJ0e/ILbFTDMsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAbW271rBNX4CTNTYQKypRD4gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZjNjAzODctOTNhMy00MGIzLTgzOWUtODk5NGU5NmNhZjAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM1OGQ4Zjc3\nLTdjYjctNDYyZC1hOTJjLWNkMDY5OTQ4NDQzNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP3eOngIAZ4pTprHLigm3ZaytTJLshWFbnKokHQe2j0OeY6tHKPoOXIv\n42AI/CPVeKZS0bQpIBA2CQ5i2sY3rkujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJd8b2jw\nAj61I5YL8ahZS8pJAepgMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIC6DhrU8m9H0X0hZIGOKF29ZQx9ic+L1UhNR2PBs\nzRpxAiAZbHPreS73EO9GTsmfbH3coMkjbGqfoIOMzOGQ5oGqcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1131", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1131` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAXWtlbFwn1PmqnJfI3M0yK7BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMjViOTE0LTY5NzktNDUwYy1hOGRiLTEwYzNjN2RhYTAwZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUxMjZjOGMtNDRi\nNi00NmQxLTgxODctYmY3MmRmNGUxOGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXLSduHyXbRoGuQE0d42wZh1uM73BiuAalMmbz8k+vm3bCtvIA2SnhrrCQIXA\nISFyrsUluc+ogO+yfeyP/ICIgKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsyNooWlmHLl5dWeqKlBTdmIk1rkwHwYDVR0j\nBBgwFoAU6vg53NkCedm+ljs7A1Kwll9hr7cwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGvl9741YVrdDBhSQlhUQAEtt4ORTGfM\nPoBDz1o0coZBAiEAknUZyKv6IUNo7CCt8W2YRf8yFUQU0rPgNdqT279GL1Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcoajHp4LwBEnSJ1BFZ0hG9zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTI1YjkxNC02OTc5LTQ1MGMtYThkYi0xMGMzYzdkYWEwMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYicyiIBthAMl48xfZG8lMW4RbantgcIekLFIPT99dPtlm\nrwox/4m+j8HZfkZLwSMSeIA55enPD3Gu0DuEWOm6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6vg53NkCedm+ljs7A1Kwll9h\nr7cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIVj7v4Niw8Sr5/eb+/XlJhXAcTSljJUllbGL91MzS4ACIFbuOK+YyTuR\n/sDraewLNWi1kl9rMwGO5xQOUHcQCEb7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAd2tob9g+XZi1ddEbffkYNfJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUxMjZjOGMtNDRiNi00NmQxLTgxODctYmY3MmRmNGUxOGVmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJmYjc0ZmM5\nLWFhOTEtNGRjYi04ODIxLWJkNmNkNDk0ZmE4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBynW8llj4GF02HA47mzeMYdcBD3v+G2ZrZMWG/um1s+/QodKr+HqxVa\nFoXKOKg2ZwotcETjI68IvW45yVJbcZKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLMjaKFp\nZhy5eXVnqipQU3ZiJNa5MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIDVpj6flSioqU1ME42QtB1k8pJPWNZO+dcaWedZQ\narwxAiEApScD4EjWbB9TUF2oliudrT2OgYz9GnY/EL/U6l0/tUk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1132", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1132` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAeW65iMPgwqSJIWQ7ZDy6qA0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmY2NkOWMxLWI0NjQtNDdmMS05OGFlLTU0YjU5Y2E1MGM4OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFkNTllZTktZDc4\nOC00N2EzLTliYjEtNWJiZmI5NGQzMTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ4mfcyCIf155KCCC2HjrptmqzuHOlMvCUSMcG+j2OWFYg7D/XCA7ApNfL5n7\nx+kU9/bh4zQvefq5VdNaeOHCiaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjDzQGPhhMm+wNmwKpEL1BUrfiDAwHwYDVR0j\nBBgwFoAUIoT2AmyTMsXf/owSQ+jhyD9WooYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCPqCOvDTFN\n3UK4ccfYRphHlZWf0dJ7bO7uYbPHBhtkfAIhAMCfv0QU/CcKLYYhGH49NKLCbcth\nwM7c7OQnsrBPSBaM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYL00OuwSXzpFTUlQunrmG6HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmNjZDljMS1iNDY0LTQ3ZjEtOThhZS01NGI1OWNhNTBjODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDwTjnMI7kDo0tTK0WNUjysLbv5b0xAE4BKJh6MrErzwHb\nI+NXg8a8FjH22DVstvUyuvjLOzhEENpKtCUvnMOno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIoT2AmyTMsXf/owSQ+jhyD9W\nooYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO+WO5zvndn1P4c7tJ2rRqgbcc4pRhRZrulNNAGSaHoEAiEA/6thmxGM\n/QW6dpor4tdSccA4B9XcuPW/Sp6PWX9hLTw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAe7cwxdW/U6NysRhmb/ho2PYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFkNTllZTktZDc4OC00N2EzLTliYjEtNWJiZmI5NGQzMTJiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJhYTQ4NDFi\nLTIyNGUtNDBlOS1iODQ0LTZkMWRlZjQ1OWYxZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKIefwjGaB6/NWYO5847FMYETKDMvxuS2sSIvvxHk4PFAH9X3OBlyD/d\nO8kJw6NY/2xygbhHI+UqoApY37tzsNOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIw80Bj4\nYTJvsDZsCqRC9QVK34gwMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIG3MlcNT2kWlQ+qFLxVT5pQ8eWhHmsh8kMref3yM\n0jZwAiBq78vrd2xhhFBG4bqiJUfR6eD7W78vjQ1qwTQ9lz1sZw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1133", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1133` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZzqWO3+jcX3KT6Suh6NwgD+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwNzUxOGI3LTYwNWEtNDU2OC1iZWU5LWJlZWY5NzQ5OTdhNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAxYTA3ZTgtNDcy\nZi00YzE2LTk3MGEtZWI1NmYzMzVlNjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3UKQjreAFKQPRIJmJo4Hq+TDbq2Y/Cg74UbGuWdLt1P86T5ZNSTo8dxv/kM4\ncETxAxtMAYZiQAg46wpkF2R7oaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs4AspvKAa3ONZ7WlsguNQswqhxkwHwYDVR0j\nBBgwFoAUhtHwIX2bvsTXilT68gwnWXhg4zgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJ7QCCBNBsP9n3yAHjUoY5hLH+EzNCo6fYJl1OyTE+PAAiAIIOG6R6e+\n++xj4OoiUuhImRglu3qNDDGp364b+ConMg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWQQmqlTQTjpmv0Zp6V3pgSxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDc1MThiNy02MDVhLTQ1NjgtYmVlOS1iZWVmOTc0OTk3YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRY4SSjAAcsv6GOlMIrhmNcsUAXuvtkbS+XjdjmfUC1chu\newjvLtEQHTv5pD7AsDXjH7WJ9NZzDr08Ivwtg5Lso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhtHwIX2bvsTXilT68gwnWXhg\n4zgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD/48a0EGZjX6Yqx/+qzxb5JS+2ZCyR97iTyRzx03e0YCIQCzqr/wKud/\nHEAilYAwhwDZlP3mLv7E18/+nkOXqsStvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISARCvAk4Hh+i15A/VJUdm4zhZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAxYTA3ZTgtNDcyZi00YzE2LTk3MGEtZWI1NmYzMzVlNjk5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAzMDQ3ODYy\nLTUxZmItNGM2OS1iZjA3LTQ1OGRjY2FkODJjMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDadG2M8V74lNO6rrI1rc5KJSmkqpwajIDehp+66xcq+XR0XNaYKAgq+\nff4WqRnOjWq/NCLHUwPB0sW7Ro6MfMmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLOALKby\ngGtzjWe1pbILjULMKocZMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIHIpdv7lC3MHEYjNvy+FeM0JmI8o25NKVeSMw1W5\nhO/vAiA+WhcBNgApBS45OvEKEvPbUb7+mu1jwncNW+f+T+cqgw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1134", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1134` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQNb3uaElPuwUcTj3OS5Qx52MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNWFiMjY5LWY5ZjMtNGY1ZC1hNWI5LWRlNWJkYTk1ZmFmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQwNDBjOTgtZWUw\nMS00M2U4LWEzZTQtMmRiM2IwNjY0OTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcMvlKN5hKjHTtK+M5lp0ZSpuf+CBGSxFl8RiNK82WJhZALzLNGJn6X9TMPIy\nHendd0xn94FJwFwPT7ubv8A7vaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkxizto1GNqk3GyuTtgp/zSqR/90wHwYDVR0j\nBBgwFoAU6E/1Pqbo781q+YQIPN09jFjCDwowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAOk8ZkUOC+gEVORjPnpRvPfOWym40OnHgZivPCKGqq8QAiBzG1hIEJGB\nkej+SwLZYk/4lzyZdOtJsYGC1ovFHRwl1g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQe89wdSs6RASfRCqCWJ/kMrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjVhYjI2OS1mOWYzLTRmNWQtYTViOS1kZTViZGE5NWZhZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS37bziGtlz6Csib+6Np9TyoCfJETlMStm+/88o7FL0/NT0\nn8aTCSbI2s4LdOWRJCoUug9HEER3i0P/LP5OHCW2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6E/1Pqbo781q+YQIPN09jFjC\nDwowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOAoSZrmHAUBElDwiBJm5kfbcJrcprTd2mSjEPnEo4NdAiAljYzkm6c4\nVQ9ArQS54ZBY46GphMj7R3I7vs5nGTqWrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAVtLhyveJIxCVSNd/x5HAxWfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQwNDBjOTgtZWUwMS00M2U4LWEzZTQtMmRiM2IwNjY0OTU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU5ZjcyMDRm\nLTUyZTktNDc4Zi1hYjI2LTg1MTNhNTk3M2FlMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLG1F3W5RWqLThwDF5WMrZxTVambBqBEdctJb0gOS8jtRPkTw42PevXa\nk0Tk+EmGZW7bprDIr/iExoKE3P4y2jujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJMYs7aN\nRjapNxsrk7YKf80qkf/dMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIGeDhhWC/Zxc0bWdj+xvpqnmw3OQNHQlmgQc4++g\nVTDbAiEAn6+Cr0eAhwK/D0BFNIZJINSXwduGM7fa6crkREEECwA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1135", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1135` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAdN/j6tf4XSfEpwkSm7u+27ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YTZhYmFkLWFhYzYtNDEzNi1hYTBlLWE4NmY1NTRjZjU3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjJlNjQwYzEtNTFl\nZC00OTE0LWJlNjktNGUzM2ZjMTdlY2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXHcIXosLP8axUiiZU4hVMal8WSz/pFLMYciUW2+d5llG6bpT3n4QG+BFxcDH\nDuBVu/Zw62oIdj0KtlJhPB8WtaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTBnSh2JNlsA3Tfd1hXECY6u016kwHwYDVR0j\nBBgwFoAULAgJ6GY7cfj+isbvcRpucZv3Z5owOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBwD18Wu5QLeN+QbfJJ8RNPE280NAD34kWVRk9rUm6gYAiAF9rEqU8du\njDNCurbYmEpM/qRbFPOwnOo1ujzpqf+ZvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAclEurr82Xo/6GUevw9CTYayMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWE2YWJhZC1hYWM2LTQxMzYtYWEwZS1hODZmNTU0Y2Y1NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxGrrpDGyBvJtiPLjjX+rhoj25tvfztzGwTAgUqXJ//as6\nInGMiZDnD1VqbTnvZseNWNokQJp++Tdu6g3tfFBfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULAgJ6GY7cfj+isbvcRpucZv3\nZ5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS2tApL8njoB7vNLvyH9kOaze1ctnwgQss+T2aJQT+oMCIQDUdKkBKMKR\nB3RpAaHC5WAd3u5WjIVBgYra7Xu1YREvUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAaDePJwTdUXl+4zE/XjbgmqsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjJlNjQwYzEtNTFlZC00OTE0LWJlNjktNGUzM2ZjMTdlY2UzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU1MWM2NDA3\nLWZkNmMtNDBjNS1hOTRlLTM4NzI5YmJjZTg0OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKKLXCIAXN33u3/9HASn+PmkbhMlwXBKGzByeP0LRPE2xChxSIg7tcNv\nmKKvWNvaciGga3B0DbQ0urtcaNK1YuajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEwZ0odi\nTZbAN033dYVxAmOrtNepMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIGHFnqSJE/YB67i+MKp7+iWP8ZSBSD2H+8gFbN+s\nJPz+AiAW9Bf/5OZToE2J0nTI0LTFEup+yjPXPMOv7azeRcbHuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1136", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1136` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISARm/6eizb1YN3aj93PU9EC4JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlOTE2ZDQzLTBiZjEtNGU4Ni04YzQwLWVmMGYxZmU5MjE2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjljN2YyM2UtZWFm\nYy00ZGVjLTg5ZmQtZjNmYmQyODk0N2IyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEca1pU/asCXvRS2Ie5BmH8UiiSQrRoZmQbKldeguw9aoTUxwhI2yBfN3lehs5\nWdhkpEb/JRuPC8hcFrKupH4nA6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUriDJb8OW2/pi71hcNqzRu/GWYy4wHwYDVR0j\nBBgwFoAUQ0iG6ybq5UEFCkLPpY3+GH4rQvkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDshVMR+zBCqOKgDLO/Xq2W87UFTb7do0YjrqSt\nc3+FpwIgLJW1jsIj8gr8qCEhW5uF4fmUusyJao844pRahkDco6w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXBtfoKJgsFmWlamV6KjyXq6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTkxNmQ0My0wYmYxLTRlODYtOGM0MC1lZjBmMWZlOTIxNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNH+cwp73dNnwJynNdXvQzDUQ751ZQuunTy8v8sPBlHgU6\nWUzWqkgo9b/vh7ktE2S6FkuSc0xRFwYQTyz/ZxuCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ0iG6ybq5UEFCkLPpY3+GH4r\nQvkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP9ZA1XvcHwAqKOB7PpE4E5Kuuxo/WtxsSm1kgsHreDjAiEAoVl8vjIb\nsjDLI7pCvYcSwv1Omq9WXZVG+qfUfghF51Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdCfvoPcEI7ccrcyyQ2yGMUSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjljN2YyM2UtZWFmYy00ZGVjLTg5ZmQtZjNmYmQyODk0N2IyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1ZTE3M2M1\nLTA1ODgtNDc3Yi04OWFiLTI4YjdjNzRhOTQ4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNB5EvdtiQZA0twjRUgyNhmZHoRI9ix+75iDkSY6LfoNOUNvRHLbeYMn\n1dZkOfkSGCk252kpZ+k5ZPxW6DsYoVCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK4gyW/D\nltv6Yu9YXDas0bvxlmMuMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCICrSv05LH3d0694bfDGegXRbPpfCtm1zvqN5I4W7\n+8F8AiEAldfN4pNiLP4U5/dhcY5HxqmryBMwbnQ0y5Bi1nemmFc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1137", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1137` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAd5zEIJM4bhQ2oRVz90uPdwKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzZTcyOGYxLWRhNWUtNGZjMC05M2ViLTY3MDRkY2I0MDkxZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgxNWFjYzMtOWFj\nNC00MTRiLTk3ODUtNzI0OGUyMjZjZTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErM0HtgnNmckfoTIpf/ZhK1v9/aAjNVoibf8QKpvTFV0CB0RYb0zTvxeqmPEW\ny3O3UL/4TTueHe8nLdbkF/G0iKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9LMgsAFBqC6IchiWvhbHBTBtY98wHwYDVR0j\nBBgwFoAUgwyDV9uZtAIJNz90aKKrvStn29swRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIB7phThc2176ajtbOC44cyr0q9e+vRPAWSXkb+FB\n0Rx6AiB+eH3/JURJZ6onPwnVmoxJu4madLQSElSahbO+8+8bYA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASt4DPzMXZyc1wqtUo96Q8TUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2U3MjhmMS1kYTVlLTRmYzAtOTNlYi02NzA0ZGNiNDA5MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxrTZSdjGiUzytOjtCAQMccHEltGYqxm3vKCt3olwnVD5I\npy96UeVgdiQjzRacoxPcTx/F4jcNujnXSaKz5VjKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgwyDV9uZtAIJNz90aKKrvStn\n29swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYYgPoSNAnlsjeVd3NDWwAK7ybCXITzdetMxpKJA7vnICIBIMA11M5noP\nKm00CodOcvY0SD02KiLvnmaBumtUB3LX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAeLtLAReJL6aY9QhjF1rSWT1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgxNWFjYzMtOWFjNC00MTRiLTk3ODUtNzI0OGUyMjZjZTkzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMwNTk4MGY4\nLTgwNjktNGM1NS1hNjFjLWZjNDk0MjdjYzA1NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDDVwdrCeQ03mg59X4C6uzT3fOnIWrsTOinkkZLUfo0MrBLaWtGFwffU\nj9l/S9coeaHNtzvHmZArL3UdUGrbzK2jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPSzILAB\nQaguiHIYlr4WxwUwbWPfMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDJApmXjJP1PErDrtKwfdwUQhjYIzBE6DmbOyMX\nicO5DAIhAKx0MywbmJ5mIVa+nmViDasd02+LTtS7HjjPCltC097o\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1138", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1138` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISASm0sFNyQkH6PzU7oWoK/ZlWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyOTY1ZjcyLWI1ODAtNGNiMC04NTIzLThhNGIxZGIxOTBjODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRiNGEzOWUtMWM3\nNC00NjEyLWJjMDMtNDNjNGM3YTBmYTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBXJMV1kaJGAlVnsSB8qfV2tq5pz3eYc3+o8jh9p83iYw/Rg7Zf1KwV8xvGrU\nBj1reMMoCHlZHCHGkkVHs/HxBqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCkfPEScZOOusdohICVVZ242jYnswHwYDVR0j\nBBgwFoAUyJLGy/N/1fos56Jav6C3wcVQyOcwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIELlVhgyygH9xfgTXv6Fc9CVMWueOErdaAu6SEWh2JWiAiEA\nsI9UHrdrHWUo41CmeGsuuFh164+4Lo+dW8XfU7SaYLM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcpR12L+1eThkJlv7g8dWzbMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjk2NWY3Mi1iNTgwLTRjYjAtODUyMy04YTRiMWRiMTkwYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATal9M+A178PQnegObPKY2GNihew3GFu4+ybe6+gs7vm3VI\n0L5iddMj+LkSL5U9RT/bBfYsteUaA2JCbgHvxymbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyJLGy/N/1fos56Jav6C3wcVQ\nyOcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYwyXF3O5jgNFCoYsMGLTvhMucYUQe3bgv97mNDfCKCUCIFXr+WtBefWq\nBym+zCgdBHa265ehK/CfJ8ukKHqiOrJS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAXaDEXXdO4kcvK8nKVfsVDFSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRiNGEzOWUtMWM3NC00NjEyLWJjMDMtNDNjNGM3YTBmYTk2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4ODNhZDM4\nLTY1ZTItNDZkMi04ZjA2LTExODNlN2Q5NzhmMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJODVw9HLX/MJO31TlJ8UwWDUziPAyJgxawj9zahkCm2hBYOzJn9hYaY\nePFX8OV3calsCdzUlNqk3SjRwE4oCICjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFApHzxEn\nGTjrrHaISAlVWduNo2J7MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDwlJo0W7PmoAiBzq4RpHG4RmanMCog85S6Bc7J\nK0GBdAIhALnuQYG/jBLxq3C+BZkq6wh1yOYF4+gtrSpdKNiUX4Pz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1139", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1139` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAaBuOvrBdCJSjAKkv398zw0gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5NWRhMGRlLWE1MzctNDA4Yy1hMzk1LTc2NmM3NDA4MzdlMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk2N2ExZDItY2Mx\nZS00YTk3LWFlZWEtYjVlNDIzNzBkZmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYMNRCm3EljXyZWU2F2HfHKThWDrb1aCEhVNBYYOTBnboiVS62ZiLTi6YXV/t\np3m3Alebx/MD6m9P7HbAtcpIbKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwxliVjRSgbcZMx04PvPHUvDl5o0wHwYDVR0j\nBBgwFoAUeqP2dSVLEnOg3r9EboKB0B+k8PkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBHIzykMmGpvvX1/729ne97vWjqlW1V8\n/FhlFy0hbdytAiAWIxejbSKY1TNgEX7bw83s2abddJJwU6UDMxdVu1LTgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdQIAXTeWm9PQ2ZjfxWWjEp4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTVkYTBkZS1hNTM3LTQwOGMtYTM5NS03NjZjNzQwODM3ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrg+rF/vr25KRc3ITOJM7eDDQHmv1Lxmq7JlIPRDfZutCt\nBL9mIvm9A4ZJEbktiaOgmM4YVwfIw1VbTpP+5m7Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeqP2dSVLEnOg3r9EboKB0B+k\n8PkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfkHTPywDQXt5vJJzd09qWGrlaKtTW0yeIWkMtwsfGgYCIG1OibIwS3vX\nM9t6ljAjHzF/Eb1IKpngraR0f8kgv36B\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISARDMcr8q1NmhVaVpdpoM1XuFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk2N2ExZDItY2MxZS00YTk3LWFlZWEtYjVlNDIzNzBkZmM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ5MDMzYmM1\nLWE0YzUtNDhlOS1hNmYwLTk2NDQwYzc1MGVjYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB9DtU4mnX2gTLscWRAPjh4I/97qUuR2iW76DeVi599EAgQZVRy7he2G\nkVyUFYf/+3KJVQ8w72KBRNm4bTc67OujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMMZYlY0\nUoG3GTMdOD7zx1Lw5eaNMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCTOPTE6sDSd0ub8cHM7aXCxt0uvnG8xO14zhhO\nU4eLcQIgResGlgEboal2zsUCmxfuKH4v7QPRx06V8VUIu2EMsZQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1140", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1140` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVbQiIscA9lOxwZLVxRBbjHrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2MGVlZTcyLWM1ZmItNDcwZi1hYzdlLWZhNzRjMTczZGJmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNkYmRhMDUtNDE1\nZS00NzgzLTkxNmItODM5ZDZlNmEyZDUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFoN2TSg1zMzayOK8RCxUJ2GBuxXmm0l9Svocc0265ziJ8jeR5wT3jnGKKRP3\n3qIfEB32nVZK8NmYczRG3Oj1SKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbCkTU1kZnHa4ygU+e3ohjwpdmkQwHwYDVR0j\nBBgwFoAUOzqfHN34wgMpoFnlgQ87M34KKSUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCF9RCKecTV/bcasq5lEt2m9wACnlF1\n3WbyobuXUYPInwIgSOVSMVARpa7bRIgiehF8CQBwxqyhGMB2VDujcqhNXvs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQoE9RwFVO8kSYf6zKWs+y0yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjBlZWU3Mi1jNWZiLTQ3MGYtYWM3ZS1mYTc0YzE3M2RiZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLNQvmwfMKM6parp7O1DycLUYsfd37E1ACoqfe5Wc7S+WJ\ntMJ8CwcFGqQrMLUw/XTTbZRJLJDbP2d6Ne3WfquXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOzqfHN34wgMpoFnlgQ87M34K\nKSUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTWQoaPVyxqS48/0Sf569lVf63gQqfQ3vxpwQ5O/upVMCIQD5Bbc93D9i\nLq6/DdOpA0Pkhq0ska1lEBC2cZNuzURPog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAa5B12fWfUCJvQKKlmymw1RZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNkYmRhMDUtNDE1ZS00NzgzLTkxNmItODM5ZDZlNmEyZDUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY1M2M1Mzk2\nLWE3N2ItNDMzMC1hMGIwLTE1ODgzZGRiZTkwNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH3UBD86GhuwUi/evNnNkow6jT+boTNADqu1dUsZghBbzf1i8C14kOFP\nQM39tj+Txu2OfQQBZneH8Wc6FZelRYSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGwpE1NZ\nGZx2uMoFPnt6IY8KXZpEMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQC9QtDKiNEaNEGcK7tfscAmh70+tbxWc5Gjl7+j\nDojDKgIgD2bYnuqmVbD5C/hfjV+4rjednGoTDvgzwCn02EqzOm4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1141", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1141` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAYSRQzJ9fsXijHnlqYNFL3IqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkYzA4MDc3LWNjYjAtNDAwMS1iMzcwLTkxMGJmYWYyMDhiZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJkNTQyNzQtZDI1\nYi00NTdhLTllMGItNDAzZTgwYmVkYTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo2y0xKAyieePvsJpN82YPzzuAynfjdbg18ywsRVWKOYAEgHGZYRRwe5bLiIr\nGbixFgOGNGG6AiLC//D+2aEz+aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFChgfcabvIn2AUhhL7WDNSElEtsyMB8GA1UdIwQY\nMBaAFHj+H4pL13nlHdmm9Nwva5fbXKRfMAoGCCqGSM49BAMCA0cAMEQCIEkEfhSX\nB8HqXJJYdb3EJa5nOGrcyaImYXRyphvhGWq6AiB4pP/mlQfj06X1LyQxSiUGpD54\njx1+EXPvqEfomRzoyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeIwd971eWezhH6sSg7lotDSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGMwODA3Ny1jY2IwLTQwMDEtYjM3MC05MTBiZmFmMjA4YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQ/YvGXUw9XaVgnO2lhm5G0+lhnWtFrCd8n+TvNDfQMcWg\nP1eMhJ7MSDzyaTAbPOsMvPc9wZY6imJ/QF/EzX4Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeP4fikvXeeUd2ab03C9rl9tc\npF8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJMssYoKtRbER4L4/gUujO0u/r+C0uv3MB7bdi0hYrqTAiEAkANIbtTm\nN7aBXgVPe91seR2JigMy5/hCnC1qbNLSLHw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAZcb3BsIrNqs3KrTD5FT2K8xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJkNTQyNzQtZDI1Yi00NTdhLTllMGItNDAzZTgwYmVkYTRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZhZTljOGU0\nLTQ1NjQtNDIxZC05MmMyLTlkNzkzMzA0ZWEzNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCAp5Y6Omo66nPs94p6F5BXgNIIHLclD4wLUKgHd1eAxZBoo6/2yb4hK\nfwJ/ZkDx3q6wZseFXiLTgQUIOM6IJyajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFChgfcab\nvIn2AUhhL7WDNSElEtsyMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDgCyh6ntn9tj3wGqVaDgceKOje7Guyomtx6EBK\nQoBcPQIhAKjQFBd1UhFfMDyDBeTybxbMn6lYddBYl+WB+HFIJJIf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1142", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1142` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZzHMB8QKFbKzAZSBo2pHALYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0YmY3ZTU3LWE2YTYtNDIyNC05MzllLTkyNTJiNzdhZmRkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMzM2Q4NWQtYzk3\nOS00MWJhLTgxYjUtNTI1ZGEzMGU0Y2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd3/U1m/DeU4wjGuJexkWX7TD/ISYAotCE3RxwAzoMbtGRrsY01bA5jVocDDH\nz2SL0qwky/4QxYhguheeP4BG96N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJ1N6aKuGEEJ76vFljgY9JOrna0BMB8GA1UdIwQY\nMBaAFHcc9YjMAcVeD8EdgX5biF7qTUsHMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAUpgo6iRnKL+kbCTVs6Nv+139+yK8jKY+Z\ntOL8D98WQAIgLo6N36e8QFRHXKOUYisbCZpeI9mgaVhk1tnk1Goa9Ok=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc97I6Xq7h5qr6TmbRXRqZTCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGJmN2U1Ny1hNmE2LTQyMjQtOTM5ZS05MjUyYjc3YWZkZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5vDiLh3kRIDfpRlrDhgBox6upcvJCw+6HlA/hRr3KAkAI\nZtVEtfT+8VucrslktM35H9PI5oZ+h33RvZIyoCW1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdxz1iMwBxV4PwR2BfluIXupN\nSwcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPOuVxY67zL+kB1lyIZpbka6V3qcW+EsVmrmzKQty06gCIQDHPL4KRj6l\n4LdzYa0IeGs4IdBcw0vQtRm3qM0SnpdqIA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAawjPg4lvL73u1Pq1jPqT+pJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMzM2Q4NWQtYzk3OS00MWJhLTgxYjUtNTI1ZGEzMGU0Y2Q1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDczN2VlZTc4\nLTE2ZDMtNGU3ZC1iOTQxLWMyNmMyYmU2MTE2MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLqlmKzJlIJ9eneJxdbwo0rwJqFg9C9Pr131a8pR46AJlFD28KNjrcOw\nzPqnk6q8gr8K36xp2s4fae+tmDb4yxyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ1N6aKu\nGEEJ76vFljgY9JOrna0BMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIBP1lua0TaUz7ZaXTPWTatTDRWKtvXKDZNRZNpNV\nQgJMAiEA1gJF/rEEnb1QUEuEfqF8R/8CLpE5XM69fZoHvvmQmj4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1143", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1143` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAYj+bNdWkp2c6MY7mAH1B7xtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0Mjg5NmNiLTUwMWMtNDE0NC05ZjdkLWNjZjc5ZGJmYmZmMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ1NDFlMDgtYzNj\nNC00YTBjLTljMDQtMzMxODE1Mzc5YzcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoIgyV4XuhT8Xjc0IzLh9ce1oE2xEOi/mr4EExP+RWgvtPMY1iDEFIDDm5iQa\niXPckV8ucCFVm5yUKTaVhRG4DKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNW3buamvmbbyKY47TxkD8FaqZNzMB8GA1UdIwQY\nMBaAFCGplPEbysm9AyPNEq8idbQAvgjrMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAsgzB4u8XuLFWzhMH0JTsCD7Ti4k2mKss\nn7RgINUkI5sCIQDIys7/DLZKWnH6Wfz2RJF63ZOGr7+v4hGGONhe0SgddQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc06s35jNHsn0jB9ECDM5MfhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDI4OTZjYi01MDFjLTQxNDQtOWY3ZC1jY2Y3OWRiZmJmZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9zKselQ+Dw0V0F3nowi1SDAF69KwasQW5BjgENT03Xa3O\nWBpbh00R9aBpZGe8HsawORr3OCj/blfkdbYLMmDmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIamU8RvKyb0DI80SryJ1tAC+\nCOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMAYxkgINKbUpe/1rFz7/XfYqCcOEjss7RVz4r4eOvvbAiEA89zwS7LO\n/My5BzYyazngSODKUi4xWRodoZI04YD9kaw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAbX3JYb9nJDSrMpS1fvaj4qTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ1NDFlMDgtYzNjNC00YTBjLTljMDQtMzMxODE1Mzc5YzcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQzNGFiNzZh\nLWUzZjktNGY5MC1iYTk5LTY3MDYzNzQxN2I5YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG6K0RlEWK92JYVHR6zI9if/qp0jqn1N9hVDF7Re4iJfOMrBQJRJ7sj6\nKfh5BsgihEloepofhC7GLSz7kGAiJ22jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNW3buam\nvmbbyKY47TxkD8FaqZNzMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDMiwec1TULp7Fo98bM0voRco8c+qtmKhjv8Jym\ngVQV8QIhAOtEa2GFhJTzqqdxC+32N0617nLhyodzfwGCyW5D9ZVg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1144", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1144` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAddTW2xV8gpTQMaHC7PPlMgjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmZDExNTI1LTY4ZjMtNDhiYS1hOTIxLTEyY2E2ZWJjYmFjYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFlMWNiNzItMzFl\nYy00MGI0LTliODMtZTUyM2UzYTllNDEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8qM1M2yvNDpLBIg1TkX2NK57CC1A4aJ6Gou2GrKDnN4mk7PK+zdNyDa9KZQz\n8TA1La83JYwpl5lBluxs0BzL16OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR5J5fo5VO6S7I2hxHTsUvIoK333jAfBgNVHSME\nGDAWgBTkfZn/CDqEBN1VnGGLj6Ol3T5HdzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFMXNPg9t7UldjJkUxRK9ts+a3qd6zb8\nvJP4ou/iWDd5AiA23YjYl3sX69gp6eKXsvA8AHddGfFd96BinFXMWLe1DA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU/D7zuRWDnvM6pMLMlUYYTWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmQxMTUyNS02OGYzLTQ4YmEtYTkyMS0xMmNhNmViY2JhY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsVJEJDGtq1yY/EmwO+mgBHV0WlicSZpQvqPH5Hd9KpXIu\njLL15wOTxGpcaoIQwvp/qUPe/+AgiK6hmVuTyMa+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5H2Z/wg6hATdVZxhi4+jpd0+\nR3cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAcLKdWexW2bkKZUSR4seEwHR/kROyowDOU4kfqe/VIgCIQCyhOtH0Lyr\nSIQGNK/FjbxcVqiZLg//fzm0JIlUN6Pqpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAbbndilvDUrxMdZKT/IM4q/iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFlMWNiNzItMzFlYy00MGI0LTliODMtZTUyM2UzYTllNDEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDExZTlhNzEw\nLTlhOWMtNGU0OS04ZTNkLThkMjIyMzE4MWY0YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMxm3LbVMclnuOFX+girz6DfHJB/QbqkuG4XyJY1oYX+oQbvatRENFPV\nFauNqB9HItVwesrYitEBwXWx/sGSaOujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHknl+jl\nU7pLsjaHEdOxS8igrffeMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIB6EP7AfaITyiCG7xB2M7iVXvbEyqOXMdEx4D4co\njDIRAiEAii2EZXapfVphekwI3HQQDH6IQDMkGJ9uk/llXwCANqY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1145", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1145` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAQP1O6lCJHUKM0FGOOJhE9H7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzNmMxYTkzLWY3MjUtNGYyZC1iZTJlLTNhYzZlMzQxYTNjMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhjM2Y2MDItNWZm\nMC00YWNmLWIyNmQtNjJkNDc1NTU5NzFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwkUGUpDC5tJnyHdD2eu6Z5b7DuoSColDmHAL2hA/ACR8IP+C/9OzmgET54wW\nVb95T6XeG1FdxRDtTK6Clo+cNaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlh7IH4CD7lEpOwxQ4TT9uow0ANAwHwYDVR0j\nBBgwFoAU/A602UJjjQyIr0sjLnsZZXJFJbcwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAQ970tRsVDI6ZA\nHCz5DBrekkvJe7JkLQFditJ3xXCuawIgYJlovIs64uchpT3pdiaUb+A9uu/pktAt\npgqhtHTJz/Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASYHt8vZdU0q/x5V+12QYQ4UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzZjMWE5My1mNzI1LTRmMmQtYmUyZS0zYWM2ZTM0MWEzYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdmQv8J3EM2zhDTA9WmMgKFUhCIOEpKL3wXyNvlU98lfYF\nYFYB+RSe1AZ/D0MexmhSX4yQqPXE9nWg6CkqJNpeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/A602UJjjQyIr0sjLnsZZXJF\nJbcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD945rr9CqRBCpPuR0KAGW1BcyZVrKLcQhx71r9Lrh94CIF3dsF9JOk5t\n3z1GfdkvKGTwYbNLD6CQGJp2qtWCIBUl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAQ4W9LSvfN3wEP/XWDM2YJfqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhjM2Y2MDItNWZmMC00YWNmLWIyNmQtNjJkNDc1NTU5NzFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUxNTZhMjg3\nLTM0NDgtNGU2My05MGJjLWMyZTFlMTQwODkxZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHNfeZlwvP0pTsZBc5HtFisCsyJ4dxW9UNwCguhXhJfnqCHX9Q5pHacH\nILpCf6E3SyXQbU6Jv4Kla4U6UYqkKnyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJYeyB+A\ng+5RKTsMUOE0/bqMNADQMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIEwb3zJ40wc6D2mSvCMG9KBY6npdoqboDMnnxIj4\neOF5AiArIxkbUEVXy5Z7EPdJLn6FVHSQkKvoz5+G/3Q0mH0q5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1146", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1146` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAcJGskS6gLpwwZztWultr9MVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViZGYwOGU5LWQxNDUtNGQzMC04NTMxLTRhNzkzOTc1M2M4NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJiOTVkMzktMzNk\nYy00NWQ3LTk1YjctMWI4YTM4ZmVhZDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU5TAy8qay8R09uTkSf34UrWS/GXaQaFss9KMiLBv1HeQ8oVkesDpcLDOk5fo\n8//VQWLVN65DFCoaIVQVM+VJQqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlvuJp6aQbSjcznD5pqm2BQu2cTkwHwYDVR0j\nBBgwFoAUmAvj+DbWiQsan2kYY4nNY321udkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA0Nhn7td9E/Wq\nENS4lAfFTuIG2sQYOlNXW7SBuYY6ggYCIQCH0ebuMwYdYEuj6I3YmaLsTD9JoNWk\nLxz/AGCLSc5UlA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcQpLOB+sV30+l5pIbb1TJp6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmRmMDhlOS1kMTQ1LTRkMzAtODUzMS00YTc5Mzk3NTNjODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATa9/7WMXyDTGDPkdVgj5aKUWT0Nk0x4IPHIzcWGtZu9bfm\nOluX8IvD7HaNbi4Z+E7slNXRwA8gvd4GEuBUCF5so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmAvj+DbWiQsan2kYY4nNY321\nudkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBdIUMj0LnoNySqEGrvxsPTisE1jSlvJrOTqhizuKRW8CIQDAC97vauQt\nPN3cnuHCQElaLu2mM2U6ocnc1097W8kQHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAVh2Mb2FWnhXFLZzEqBwW2dtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJiOTVkMzktMzNkYy00NWQ3LTk1YjctMWI4YTM4ZmVhZDIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg4YWIyNjM4\nLTQ0NzctNGM4YS1iYzQ4LTE5YzQ4NTExMzE4MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBI859cUshTgWKL4ZMGUkPia84wURmXNYm/UA3VjvFrDDnux92PS83H1\ncMiLZIhBQpd/EG3a5utU7wV/W8GEtUujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJb7iaem\nkG0o3M5w+aaptgULtnE5MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIH+DWyedbw9/9THuCYosb5RCLw+IPeBN35Hi2ltw\nS1KMAiEAtiMz92sslK52d6H12iIt5mw+JnTsjJi6dSOxVENG8kY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1147", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1147` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAdgEezdyAN0YFMDRUkZUAVaRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxM2QxMTkyLTMyZTktNGM5OS1iMzVhLTcxZmUyNjhiODdhZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE2ZTA1OTQtNWRl\nZi00NjFlLTkzMWItZjA5N2VlMGU5YTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzA4VowkagCv3zEP87O4QY0xi9XhSELXnWthDcCFr1llRLRjSk/mJ95zweRw+\nTIIYu6x9rLve3V6VHoF7oyNc3KOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuZ/j3pdHo3Es6bQG/KP1cPB6zx8wHwYDVR0j\nBBgwFoAUpLBnK0SoPBMtzGLey+BMVyx2IF0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiA2FpAAyWxHpHQUc9E9qUfo\nDnzLuvk/mfZKP+9I4Z8MWgIhAK7BLmyI7pNd/xK3JWdAkx2PbJTD39tdzd8UhRYd\nbttn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb9TzoJDW4cYonnpzT4/UpQqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTNkMTE5Mi0zMmU5LTRjOTktYjM1YS03MWZlMjY4Yjg3YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASm+D4Pfde9pBNzy8ykp9KFkDqgtgN/XNwmj/VJZ+KQIajz\njEW5TFa4uvNIzIHxhnlbeHhw2N9Q0U0qbvcqLbZro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpLBnK0SoPBMtzGLey+BMVyx2\nIF0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANmULrugk1tF5St63rWdCRWf9lIUw8DwbADBC7CBrFVSAiEAjCsHYbyi\n6Xh3JYNIol9guFiDnqBK1WE3rwHene1mke4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAdN99nKBBoh5PSxUHeusT8FuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE2ZTA1OTQtNWRlZi00NjFlLTkzMWItZjA5N2VlMGU5YTgwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM2NTFlOGE4\nLThhNDUtNDViMy05NzdhLTM1MDUyMzAwNzUyNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKuxpot6gNK9JMQ1wWiZoDceY4hxfwM+vk0ye/pkpoBj8joj3lEHmxSv\nuFqN6fL3VahO8SDlYxB5u8YMcSDNeFWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLmf496X\nR6NxLOm0Bvyj9XDwes8fMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIFrlfbxqcskhIcVOqkEf0cqMBhb0goAUj77FaKfx\nPW50AiA/VrytSV5cCU3Odrd8zmADYkrVexOQyyKqIVQ2E6qajw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1148", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1148` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISATtBE8DGnjd0rx4lD/UmQJFXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzNWVjZjNhLTgwMTAtNGIxMi04MzdiLWJmZjE4Y2E4MTI2OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRkYzk1MmUtZjAw\nZi00NDM4LWExNzAtZGU5ZTc5MmE5MjBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElOhlLjEf00BYK8N/vomSWTqu+EL+hAur6j5xRBvJdwnZKgsgUAIpxgj6M4Mh\npXgZemMBWKeTEmymQU6iT2/35aOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVj8LgpJHjZR05c9/sMDKiPitONEwHwYDVR0j\nBBgwFoAUWuyfXd/DwSPCQkxPcBj+kPFtrTowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAI72Hl\nqgzfGHikd0I2T6e4FN+nTvXXyMGMTRUdRc89mQIhAIZYwhrQikOa02A3Hqj1KSR8\nUtVHuC0QiA3QC7GUnhjW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASG0VnhhD/E3lTxESCMrfR8sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzVlY2YzYS04MDEwLTRiMTItODM3Yi1iZmYxOGNhODEyNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScqoylsRqcT36l0p2/dDNNhaR1/YWFgnzTKFj3uwWYBjmv\n+dBLbVwHli66w7lxkOgR4OM7XZAyH0F7NcZNQDcEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWuyfXd/DwSPCQkxPcBj+kPFt\nrTowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMPCnEyNtJbDupCmX3YCLRjEJMVPs38YcUG4xACsBa4lAiEAzxaGEWTa\nbt/eF9G29cRr1cAAP7gQAjdAZDsEhaT4Zno=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAbPaaR9DqUvVNV89Tz92etwiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRkYzk1MmUtZjAwZi00NDM4LWExNzAtZGU5ZTc5MmE5MjBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdlOGVlNjk4\nLWVlMGItNGM0Yi1iMmI5LWM1M2IwYzYwY2ZlMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCdiIr4q7WV663Sx5W1AYFp/EeUhD1LihePsXFr0X6nlO4wvwL00Uaaa\njDoZlr2KISCxhZrJ/tG6uOc9PMJwrjGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFY/C4KS\nR42UdOXPf7DAyoj4rTjRMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCICiWxrJh/qBNq4rXd6xUaAUieRB8MwDUxZ1MJjIh\n4qTFAiEAtnqUzDQsMzoYKUnngwF2k7vh22Qcyz2EvbIxwpj4OO0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1149", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1149` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISARAqt6Ip8hzIvhHLMvdp0kv6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4ZTE2NDUxLTFlYjAtNDEyNy1iZTU0LTllY2NjY2NhNTQ4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY2ZmVlYjMtOWNh\nYS00ZTE3LThmMjMtYjAxNDdlNDk2YjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBiiDrWsX/3o3h1RdT+PlyWRwq5xFPDmuyXv72Cf17RR3ju1kQ5H6oF6Qn9R1\n6HQir4Z6LoxODu2bZ7lhhpnEz6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhJT6bht8ZT2Gd0b6tfybmSs9gkcwHwYDVR0j\nBBgwFoAUy3nEB25TEYcsDg+FB807hBmaJNgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAoN8o\n244peami1sCUdm5Hw84spjbhTxQrgStCrgCG/7YCIEKindBHpb36RrOwuUioopLy\n8lTFnuZld6Rkfb9xb0T5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQKU/iIx6qm+mT42GoWJrD0hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGUxNjQ1MS0xZWIwLTQxMjctYmU1NC05ZWNjY2NjYTU0ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpezWCHfUQN+qRHXD8vsIH2KaCqtAFqPlxsdkjCiKBlTwL\nVtncJBJ64YyGML2QdbRWAwu4YN/u3kQ3YS0WSuzZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy3nEB25TEYcsDg+FB807hBma\nJNgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAORRNfU6qNXtncvVnHPEzPsgWMmQGrvmPtNyOtBkDsRlAiB12dhyACQb\nBZUyn8AXhfJ+0QoNJYcmYeKQfVNnC+HOiw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXPSkZG0S2/nCe0WT7t8TD7DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY2ZmVlYjMtOWNhYS00ZTE3LThmMjMtYjAxNDdlNDk2YjNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNkMWZmMGUw\nLTdjMmYtNDVmZS1hYjIyLWYzMTM1Yjc2OTJjMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOFDZTvmyV4+Cg69+IY1+nc8uIeIdKbEIVRQb6OMsnlmrRGth1XDyK7Y\ncTykYPc7eu4hpaEhrvTcqWGDAZGVxemjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFISU+m4b\nfGU9hndG+rX8m5krPYJHMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIH6MLNXue121qJG9FU/ZdEEpGtvXcAIHrFTd8FaN\n6G5jAiEA2CCNp3oNuQYKdJNyL534Tv3rPP8yeDxeWeRavtYkOvI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1150", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1150` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAV9vNvTyzkmjyG6PzpIJ1QqnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNjZhYjUwLWNkMGItNDhmZS1iOTJjLTQzYmY2OGU0OTI4ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk2NGQ1ZTctYzk4\nNS00YmY4LTg0N2UtZGEzZGQxYWM4MWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaMwJGhzTtB2ABpRZZAGjpCEGjbDoMMo1lc+7TISEs9BSNUWt78vNvDUz70W2\nNNcDE+D+q/kXyfu+55QRmfxQd6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFVs/O5OHEep6uJ0V1mdiA6pVpk/MB8GA1UdIwQY\nMBaAFKS3PnCULFwj3OBUJ7rWcwXR6j3QMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAPJHgrBikA7r2N7MK7iA7DMOKAq73CQHbz\nma+6YzBCowIgBQu8leXZwf8vK/RWkPzgxTDVKBQskEalwaCzO+S3xHg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYDnA93E7ovXONEjrZfBRk5XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTY2YWI1MC1jZDBiLTQ4ZmUtYjkyYy00M2JmNjhlNDkyODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBnMaQi9t18tF/nWx5mwJ+KISLlwSJuH/SKBaAbsKdELXY\nLy4gSfuRk3ZN6i+0aKtaU5caHetTg5c3ulXVxWDzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpLc+cJQsXCPc4FQnutZzBdHq\nPdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL2HTuWxrOng0Lt5y6kTY1zHIQpO6WiWpxS8dXi3q/12AiEAoARNcdXz\nP59JDNgKpmRTYcB9lGPAwjh1ylTzowK51dI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAVka16Q4Wry/VcacvKbMHFb/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk2NGQ1ZTctYzk4NS00YmY4LTg0N2UtZGEzZGQxYWM4MWJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ3OTFiM2Mz\nLWRjNjItNDhlOC04YzhkLTAxMjM5OTlhZjNmZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM4eeiIdbk4mkzvqOfOrzKjibhRzZtTjSnPul6kCpChT6Fwj3V5+P0C3\nYplf0tJk/EtGD1VicCOW89PgiYPzOj6jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFVs/O5O\nHEep6uJ0V1mdiA6pVpk/MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIBryLy/OrB0L3CtPo00nFhtJBoYBdOT6GQgLX8hz\nN20rAiEA32HVcQNc2n47Pd/yd89HCOr6HDKpF24RCUDRYHVZhWM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1151", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1151` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAXXyLDbBpOM3vxWOFQJUt5BcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1MDNiMWIyLTMzN2YtNDkzNC05YzNlLWRjOGY1NzY3YzU0NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM4YmNmNjQtYWIz\nYy00ZTc0LThhNTYtOTk3MzRkZjM1OWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIEWeR1Izy3Ahwxyt1SqUstJarUkNb71Lq8fqo+bC2t7/K+XslNKbMb8ehZ+V\niKoGo0O+jPtUkKh3ofG88Am57KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUchtEWTzvkWe0gkGFh3e5dOWT8bEwHwYDVR0j\nBBgwFoAU55k6tqtdaCIZjpzimLyaHq8FYLQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgZ6Knk4Cjy1z5\nZXxo5e5G44/+UfA4acAumF9gXxoTGmsCID+52fniESBKH30++x8fZUsUxMLKV0Xz\n2QGKeWII4317\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb6qKkN2+GifIjQNN5cKhFOKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTAzYjFiMi0zMzdmLTQ5MzQtOWMzZS1kYzhmNTc2N2M1NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHLkI3BOyg0HHJHjlZVz/qH4fTP352T+PInRyoPNcv1bK9\n0as1z3U4j9RkRRLcfuXPJLzXpB2CHGsRBpAHVRRKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU55k6tqtdaCIZjpzimLyaHq8F\nYLQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYZmoRo4jAQtnA4OjVMm1rwmPB3UsjksoaqnyhQa8KvQCIB9cqP3xRlfn\nNg/zrf1hkZThtFvDtlXLy2vihh0DfHq+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAR5SPtmS2ehR24cFOrmltKwvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM4YmNmNjQtYWIzYy00ZTc0LThhNTYtOTk3MzRkZjM1OWY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJmOTk1YWY3\nLTE1NGUtNGNmZS05M2FmLTQ0MzcwMDcyNTcxMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCuilz7D3/yfOWscJ95aklRiVr1Znbl+RY79SdIFoDdIZNF1/jiVaG9S\ntcL6W/Tvm/4G9550EnoFlgVQDiAgI52jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHIbRFk8\n75FntIJBhYd3uXTlk/GxMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIGe6bX3+PR7DNVcXfRCLsinojPF0WpWWQzT5Zmcf\nKrc4AiEAurLSjv4o9bNNFAdpzfS/TX/wZ9yDhTGHhgHa1bAoS8A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1152", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1152` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISATrjMUbv621EKNH6IQDX06e5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNDM5MDA3LWUzZjYtNGVkOS05Yjc3LTgxODFjNGZlYTJjYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVlOWEyYWMtZWVj\nOC00YzQzLTkyMGEtMGM3YTZiOTIyM2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENKI5bxClZS5ErWIcIzCpAi9LBJ0esSO6QzEE6nLSSUZSzS+pJFG57a/cqJyh\nNKuX046IwX7j/v2w33IAxtPf4aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU25yGo4nVrzfmFSWOIA/F4BuWUFwwHwYDVR0j\nBBgwFoAUR+j9OqrtAN4+r/i545RR8OdPtlgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgJnj8H2r/5ZKf\ngcYRzRZndEYa5zO34begkqM7Ag+WWocCIDN+vfjElVGsXdjj/nDg9ajt/ZXNmYqF\n+lz57+PIxvkp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeVLrfRos6RdyKeGdJH35ZVEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzQzOTAwNy1lM2Y2LTRlZDktOWI3Ny04MTgxYzRmZWEyY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1f0GPUdoSruVRFpXVFZc4wqsDX6NlcuqI+T9EaYHJyIkY\nIokNd3Jcncds9rpBEMUwHn2/p/8905j9FRDhCWeBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR+j9OqrtAN4+r/i545RR8OdP\ntlgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOWpi2OPlU6n9lGk3l5fYEWTwqd8OIX7UYr1IjOgIrp2AiEAq93ADHp2\nAOxSYFHR5GNX6jW8utAubkylt5JyDYLuOG8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAVYQopm2+w5YjSmtB+IKW9MUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVlOWEyYWMtZWVjOC00YzQzLTkyMGEtMGM3YTZiOTIyM2M1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRmODcwYThj\nLTZiMTEtNDllNi05NjE3LTY3NTNlOGZhMGM5MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHreXgshIpoOUEdc+JvWusfGtaXXz5JaVw9V2TbQzi3N4VTGg3+tm76p\nCvcIWfKYvwb8w2ScxdFckpWsGEXtk1+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNuchqOJ\n1a835hUljiAPxeAbllBcMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDSHP+e+xSJlrGDP3/9t79GTbfRPSwXiOoLyId2\nWQVM4gIgDk1/dfUsy7vmiBeEsqf0/Zq86knVgCBXCMPuIaj95pU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1153", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1153` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZ+xS3mq5AvMRzHRZKqLIHC4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlZDI1OTM1LWJmYWItNGY3MC1hMmNjLWRiYzRhNTczN2JmOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI2ZWY0NTItZjJh\nMS00ZjVmLTgxMzAtMWVjOTNmZDMzYzllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESheZO3KYx4OStUgB+m/Ezm9T84pwxR6/X185U/kCBvognHE/DzmjQUXj4phA\nm5gSjOW6YjBCy9Afbwehw7mM1qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4TLBYyY4gojNJNt6AYEO2Dtp83swHwYDVR0j\nBBgwFoAUNU1rrqWdrGf4w7EoUc+JibEgJ9kwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBoYwDVbE34K\nb5MLvIVXq0H+yxvHmUxfut9uT99xFJeBAiEApbVUNyo2SuKEGpmgfJWZaD0I2dyi\nDOUuvHkf4CEc2jM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcCNrwr2HfENN7qLBLfVqyz9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZWQyNTkzNS1iZmFiLTRmNzAtYTJjYy1kYmM0YTU3MzdiZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbvfQNAw/5IuNViyv5gmYZlv7Ji7Y6GMj4+rTvUKHUzkj9\n9zPW30JY02HDh3TSM8XuZMnj9ZNoelf4wzygS8Bio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNU1rrqWdrGf4w7EoUc+JibEg\nJ9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPvWRXtlUxPS8uXdWmDTWp6Ztjs6RBzhnG2NhvsIcWFYCIQCU72Wx8oGQ\njlvWpAds3EVfSGCMwyfW5W4b1FQEwBwBaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAfHTAlyLaBcQO8xskpoUo58tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI2ZWY0NTItZjJhMS00ZjVmLTgxMzAtMWVjOTNmZDMzYzllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhiNDkwM2Rh\nLTBmYzgtNDE4NS05YjFiLTJmM2RjNTUyZjg4MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBuGeCgp6FQDdVFx/LJ04C1iql7JNZblAvORMqAhyl5rn9Ul59rD1Mz7\nCioZq5zuHXo/N0K0DMDicE+NJw+kk56jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOEywWMm\nOIKIzSTbegGBDtg7afN7MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCICdR9A0BJ8ORyFiRixCeR6MiGtcfhZW/NruqXUvI\nbavYAiEArG+DiejNZfFWk7i657qxmMZzODVky5nlAUgviVNRLtw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1154", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1154` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAblp+BCBlTWEfWGtuk4QKDZiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5Y2Q4M2Y3LTVmMWItNDZmZC04ZGRjLTliNWU2ZmU2ZjI1YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDgxMDNhY2ItNzQ0\nZC00YzhhLWEzNGQtYjkzYTJmYzAxYmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI+2icp/oWpyzSTOmYNDee4xAWh/NWYNtGAj4V9NlMSk5keatoU3EZguAJm3A\nlZso9B301ECaFiVzTlRNY79KCaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnyCrQSpX1tLr9OAtRLbRGdqPN0YwHwYDVR0j\nBBgwFoAUQZw5aaeFUt1jM7w8J+4PviGsj7QwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFof18IeOZ6+Jy8Yq7VdVRbJVqNzM/3trYfh2DbTdN1zAiAzkM3wp0mU2FLy\n0n5ikA4sQLBIi8/7Q3MO+DLcWFpIJw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZRyOaYtZmemsNl7el4alSEAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWNkODNmNy01ZjFiLTQ2ZmQtOGRkYy05YjVlNmZlNmYyNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKYLs8OENO9FPoWyM+x1glmWWgbxkuewwLMzjsK3wczXPy\nBhq8uTOiLCiQv3k9sdoHGyx1b8P2V5U8+xm3ri6Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQZw5aaeFUt1jM7w8J+4PviGs\nj7QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOsTSfWiozdjEUzTCTedP4K+zFH5VbfiGknd391SlyiMCIQCxyY5mlI9t\n9s4pCJUrdKXdIABUvj6V+YnsI+WY9nE/AA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAQzK7fMPqIUxoVoZUAcmNzmYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDgxMDNhY2ItNzQ0ZC00YzhhLWEzNGQtYjkzYTJmYzAxYmY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU3ZGU0NTdk\nLTZiNzUtNDliMS04NGEwLTkxMWFiZDFmNGQwZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCud2gyxQ9whcOZJlVvYlIxFsXZtPPAyAs13wYn8Bg/FECgcQBmkHomy\nWsZDgKmVZbU+htq0NVfq/7WMagzlx3GjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ8gq0Eq\nV9bS6/TgLUS20RnajzdGMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCaf/2NPkVBU6VzicZhZ/lnlOOu1UbP3FxcOZx6\n06y2twIgCELP7MJUNMWyZuj+uhNnn/NQmUldodhaN9k83ZyA2Us=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1155", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1155` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQeAXCf75LEqpQfXjWj/oJcsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4OWExOTIzLTBhN2YtNGFmYi1hYjYyLTYwZDI4YWU2OTI5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBjZmI0ODItMWU0\nNy00NzQyLTlkODEtMzEyODc0ZmZjMjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDDDtEJwDOxACKjCGFmgI+4Dan3u07Fax619J5jipMpYNEYZQ8dypwe3EgS0C\n0Li6FwbxuF9p37VlnWSQ233+vKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUieyVgcFWh3nDoWCY+rE7xThTbqcwHwYDVR0j\nBBgwFoAU0HAGBpM+yZzhVCrxuWd2K0Zp8GowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCpOqe9GnaLNlfZ/AzabwCrXSIY3fdNd/QnwVNmWdbOlwIgMAE6glpbwUZQ\nGLy4OmeE84lFgzHM8/VK2M22MgdyG2Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUt4wbzFOBRas5/cNfgjQk2cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODlhMTkyMy0wYTdmLTRhZmItYWI2Mi02MGQyOGFlNjkyOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQusVreLyBO1tt9cbtTxgosEq8dnlwT/PlUPqSrKisXVsoM\nlanBGq5aq3JOKtQFh8VoiAHp10K/YIpjaqGeVzIqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0HAGBpM+yZzhVCrxuWd2K0Zp\n8GowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI6hilyCDf8uFCR3fyBiEy4hnyIQpUHeIRxP3g7lo//kCIDV89UnIDiqF\n8BfvnmGpHNFk7bd4xU5NDl4nW63rTi4y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAW/NL9V5qHbl0oJc4cBAK8h3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBjZmI0ODItMWU0Ny00NzQyLTlkODEtMzEyODc0ZmZjMjA4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYyOTRkNGFi\nLTdlZWMtNDMxMy1iZjViLTUwOTM0NTM3ZTFhYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAvW4Ha+klAEUGgRdJ+via4z6gzQpW8srkxwz3ymekmbJt/65bp/XyXP\ndEL3qP1dtHW/2pgyDqlTEMdjjRDgg+GjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFInslYHB\nVod5w6FgmPqxO8U4U26nMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIA22yQpyHJ5HzXeQ/wilpuUOILjj95LxduH+K8sf\nRCpIAiEA7a8bH1AFMOzXb9tuxSSUIB/i+vH7SLYgVwCD8kR+15Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1156", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1156` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAXFShc6Y01rMYFMP5PEHbCWmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5OTViMTUwLWVjMjMtNDg1ZC04MmE3LWI4MmE4MWZlZDY3NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUxZjUyMzktNjRi\nOS00ZTUxLWE1Y2ItOTJhNjllMGIzNjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUZcVaoJ97sTopWiN0a2boObwxwnS3RTYMtJBEela9MfJOB4YvUdzazTg4QbP\n9Z8SpCEPUcCpAR4e0USsooIlIqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwOrefrSB7SuiUyWzp6XhBV8Po64wHwYDVR0j\nBBgwFoAU8268nHPpcehTVCtFdQtWgg60T3EwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIC8h\ny6SdT0DeZY5TMvXUgEAV2qevnT/WQvRHQZJDPgp0AiEA9Lp1zVD7kHK4TDGmce6T\nAYT0fJ+nNT1h9a7M/s2AuPI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX7IJzp8CvbPvMt4oA23CK5NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTk1YjE1MC1lYzIzLTQ4NWQtODJhNy1iODJhODFmZWQ2NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATR9ftlsWyDWLDcVXIabsiVHWmENCjqJLCgjyyijwEaHCh4\nq6jQ+PueE6BEtYAxEnXbzOZarZkWzy82dQbqNpYao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8268nHPpcehTVCtFdQtWgg60\nT3EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN8H64pL/D3soGMyjbUlTjerlbg717Ts6muoaK39J3JQAiAmLjmEbhI0\nPPEc7FODToR/7drYuqf/LVIJ5sM+7807ng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISASaujO2PzxC9zjVTAkH6EMb3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUxZjUyMzktNjRiOS00ZTUxLWE1Y2ItOTJhNjllMGIzNjU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY4YWJlZDA2\nLTQ2NjUtNDhlOS05NmRiLTk4MTE0MGJjMDYxZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEy7ILTkP6g1ilrCo7eweIyW6h7/Lg6mipl2tVErU2Eum+bvn/lyqMmD\nS9LQLgThkxqqTqRCs0CRq6TTchKC8amjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMDq3n60\nge0rolMls6el4QVfD6OuMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCyGhxxRm4qfYMIrAP8eOPn88ObBgDIeKddpzqB\nBJQoOAIhAMR4tMX53rJ27hfRgGv1GTvzfwP8xLsqg8Ed9AxAFBfd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1157", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1157` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISASKWWdBBSisSo3AEpP7tsk/yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiZDc3ODk3LTE4MTAtNGE4Zi1iOTA4LWQ1MzE0ZjM1ZjU3ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJkZjg5YzAtZmJl\nOS00NjUxLTk4MDAtOWFkY2UwZDM5MDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6YqRN68zwXe0pCt3zYxDjWnkt5VdMVS/qMDCoOGk4708Pc0gau0reVH835Sq\nxRtcuzwMC7/jp4CxO0Vzpy3F86OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6WWi1Gzp0Hu2FdHT4ESQ7ANnLjowHwYDVR0j\nBBgwFoAUdr9Mb/AGRvH/no4K5T2QBpIoHMUwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCID6td0x+rMq8aV1tNlnDWKSQ35al1m7ge2fE8eM+/zH6AiEAxW4N\nyLs6hfRzUv1PsUf8gjMxXSnIBok8cNTAWodhzEQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARHfW5ffcwUGBSTUtxJdgOt6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmQ3Nzg5Ny0xODEwLTRhOGYtYjkwOC1kNTMxNGYzNWY1NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnOPHlWuTWEW7/RHvlP0USA/oUni9uuSjS8PHlOhk4PIjx\n35sAjetzXeaxgOsD9xOMtFbrIec4s+9HmVwfZfW5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdr9Mb/AGRvH/no4K5T2QBpIo\nHMUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZqcZZO2ZoXwjJUM+3wEcUzudT2kWCnnD8e1qexWSj/QCIFb5MkXjnQKJ\nQutik62pCWXz62ROYm3JRvBrMCxHdhEL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAQH5o+UFx11MCUX+0fej+WuUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJkZjg5YzAtZmJlOS00NjUxLTk4MDAtOWFkY2UwZDM5MDcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJjY2E1Y2Rk\nLTkxZTUtNGRlZC05MjFlLTcwOTdjNjQ3NTc2OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEi1rI16L7HqfdTLyNMpPy6jQyCDIUyplAgl5rc/jR8zgiIaFUgODSSN\nx1YCVbM8c5QmwST9dJGhbSKpQXOfoXyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOllotRs\n6dB7thXR0+BEkOwDZy46MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDGVSYJt2y02LQqDKRZ4BuuF/nQcK2OSnrY7TX4\ndM+AXAIhANvcbxsEaS+DIiCkqRN5X6XvolLGTtQ92ExOUvlr6cyk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1158", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1158` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAaApmPK5TtbuwjFUo3tMvR4dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjNmQ2ODVhLWQ0NWEtNDhmNi04ZDhhLWI4NzFhYzUwMzIyMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk4YmI5Y2ItMWUw\nMi00ODBjLWEwNTItMjcyZTg0OGI4YTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG/U83htbZ9ESrm4jtS0GGfubXVOk+2Oxv7q2yZI8OL+mhNHa4D/2DRGotW9G\n4Txl0xMs/B20K3asQQ9B7IJSA6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOT1VK+844Ub+8zqeBFpuV15DHzYwHwYDVR0j\nBBgwFoAUAu3oApH+YW1g20TlFeMOorqnmvIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICLoMbxZaNTZE43hhNKPNPlctGxqTRtjenCh1FtTpOYxAiBNP6Xn\nbw/QgHa3nCJxT19thnOsD/XnKQjKvsxPLKAADA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdefZwgSiTp6km8oEAzjz/01MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzZkNjg1YS1kNDVhLTQ4ZjYtOGQ4YS1iODcxYWM1MDMyMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsldl07m3OdjI+aq1OZMMpR97taruLSlxrhmuj1GFX6Z/l\nvnC8b53DAzC/VwmkyAwY3hD/sPwPrEkIh5F9F1Tfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAu3oApH+YW1g20TlFeMOorqn\nmvIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ1+1axg+YqAZjAumYcl/8tfA3m13q25I9dkv/JMF1x4CIGALz0+V9zwh\nyN0YxNZ+kKyaS2drZQIPvF7spcJzH21d\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAf8OBXbLUNFIGAD0bdTxyhHbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk4YmI5Y2ItMWUwMi00ODBjLWEwNTItMjcyZTg0OGI4YTJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ2Njg4MTJh\nLTNiOTEtNDQxNC05NGYxLWEyYTdiNTEyOTQ1MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJJStFDff2HwAAVLiHmwm4Pd+cn0bQwdQhiL/xXvqvga+DFn9zI4fZvY\nvdYFHS44b0fVZNV6mdyl7SPR0zIgEaujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDk9VSvv\nOOFG/vM6ngRabldeQx82MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQC54Z3HHkSjDRDdIUmnED3r6l+P114m4VXtf4Si\nGm+H0AIhAMXgW17PlnizcL7SbPYVUKzi/cjb2BTFs4+W1+vVrow+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1159", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1159` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZcZNRm1S/Wq4gvW0aVtLO5BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZGU0ZWUzLTIwNTktNDAwYS05NmZhLWEzMWUzOWE3NWEwMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU4YjcwODUtMDZh\nMy00MzRmLWExZDMtZWIzMWVhYzA3N2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEImL3PmTd225biok4QesWQmUZyXT6cXrwPqTV8wq8n+c1fL5KC4KHdpN2aMDl\ncF7w9FlfnbBfN5pZI5L1Am3dyaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFACqbekVqRSejehei+jyworRfDDfMB8GA1UdIwQY\nMBaAFF0F+643o0vsrtWa3mHrsdzSCK0SMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAYDIWXIU8kfRYLFLAJncxzjaFSYS918wup\n3dRAeARRiQIhAOnfXy1lLz+0WjtYI5XYZPS48riaM4f2B1eKATOsHXEw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX76hvmM1to44/Ng3OJSXdJfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGRlNGVlMy0yMDU5LTQwMGEtOTZmYS1hMzFlMzlhNzVhMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHrCbVqKzad4iXcfCtP6XaKf7ny1gYdg3KcLO2aVSYX2F8\nq2KY/KfJBX+oN8WjBy0rYRgOkvf0pL4LesCXJPkpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXQX7rjejS+yu1ZreYeux3NII\nrRIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWPHV26FNxFGO5lqdv1xRwK0GanF+90kU8Rk/dTmvLLcCIGEq3TGJYWKw\nE1k2krFo8h7gVOeZq/e4ldnzhMcLG5oI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAbfUOaU/FhO0W0x2NUaShtaqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU4YjcwODUtMDZhMy00MzRmLWExZDMtZWIzMWVhYzA3N2I0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRlZjk1M2Mx\nLWZjYjAtNDEzMS04ZDAyLTNiYTc3MTJkMjU4ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCXoBoDQt116nCOdZTKKGH4L3QfBHpJ3+D0e9TpfaDk3uJ4BXDEUDEw4\nh/CCAoXABbe2JoWRjS2Wg5EEpww3lm2jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFACqbekV\nqRSejehei+jyworRfDDfMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDc26x6bOJbJFSkMn1hu/XGVHL9do85WB+ChwuG\nYl+pwQIgEPXAK0h3QmhNfBjj5vnpm6vnycj3QEQGYDaZ8WuwKr4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1160", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1160` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAdqFyjeng6hFrtIbmJxVd/KPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzNzQxY2NlLTYxNzAtNGQ2Zi04MDE0LTNiYzJhMmZkYWIyZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQyNTg1M2UtNGZh\nMi00MzIwLWI4Y2ItYjYzNWNlMzRiN2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvGmFwdCj8jq0LB5zvhU2ZDy6Etn2c30FCU2Fnwo+pcv8IePy4hlxec7Poo8C\nW+cQLnaCh709D2jVGpUCHPBC5KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPRy0IvUYk9EZTZvYntzLkhKCpbMwHwYDVR0j\nBBgwFoAU3GUGvhYbkE9/K+LdvLqhSguysqUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgWsbUf7+tbvNn\n8nwS5vT1HmHlCkHJs3v1HJqQwcqdwHsCIQDJohBHWxh/n7HR7+dYJHAl0UFkFX0R\nOkH/Tu1iYIslng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbIkMhRd+bz/+GL+SEeJ6eILMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzc0MWNjZS02MTcwLTRkNmYtODAxNC0zYmMyYTJmZGFiMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQd4q53VQmUODVFM7I46VZVDRewdxL48kL/SqrpViSJh9rh\nxpurTo27mXqN022TMVadb8nmZ4S95EI38Ml70iP+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3GUGvhYbkE9/K+LdvLqhSguy\nsqUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANkZiaMoeHMf33LPuHCN0L4zVyF4BfF66bFiaktydIRlAiB+6UHuAQUf\n6JWsnTI3z4/I7xy8kSQsRjMj0elsQ+T+LA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAZPBc+wSoHE5BVbhGqJKrVFrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQyNTg1M2UtNGZhMi00MzIwLWI4Y2ItYjYzNWNlMzRiN2YyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDljOWNlY2Vl\nLTg2OGQtNGZiNS04MDBjLWM5ZTQwY2NkMmJkYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKArzrrW7AQxChPh3PT2SM8R2HAirCqJqGwvaTb0zn8nfNq76926m8f7\n39AVC+YNB4w7h7KVGF5zMAN/+7bArlujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD0ctCL1\nGJPRGU2b2J7cy5ISgqWzMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIAHIuutsHp2WzLWRduRZ243VWe0hD+u02gXETIAa\noWxEAiAQhp9uAN+/6fwmh/RJi2vv4I2qvUlFEdz6dwXhS1c1+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1161", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1161` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAeHUx1meedR9dWRfzMakFEoIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNmFjOTE4LWM5MGItNDZiYS1iZjI1LWNlMTk3NzAyMDBjMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I1ZDY4YTAtYzUy\nNC00MWMxLWJiNmYtOWMxNDI2NzFjZGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsi1at2TU7IIVvre/Gn2zTPRTk+cAkfacI6gKQbqnpfH01wU6pgwba0uJucBQ\nUvnpUP7XcKGVIiRIOk6/dEUJQqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs+ujMidnS0wtWFTSqB9z0o4isTEwHwYDVR0j\nBBgwFoAUcisyKBzDgO3zZSgOxO/CuST3OgEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgC9MxpN1po4Tg\n/N8JTDxeh5i8HgESdFQ5Lu0FlDhiM4ICIHKVpmIsREESa+76TVy8gm7yYvSRQ4w3\noz3OFQtycXKI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc7rj0xTsIGI7D0OW0UpFQdJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzZhYzkxOC1jOTBiLTQ2YmEtYmYyNS1jZTE5NzcwMjAwYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6f6UpNVMz89dVkI9reXHHc0AiqLB2txLFxdonlJqZUWF4\nUe0GIhlWb9Ke1GKfk5BDUTGAO8FRUkoNH1M098Npo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcisyKBzDgO3zZSgOxO/CuST3\nOgEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKoeS8KblLCbTdFjNb7GcjowoMKOY/b9w8MPH3eHc1J0AiEAotqiytMe\nXMF0PEhYjCMl0vMELfsxfDNE6Sy4uV9b9pI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAcqYMYI2eRlvqK1ayEfow/AkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I1ZDY4YTAtYzUyNC00MWMxLWJiNmYtOWMxNDI2NzFjZGUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYxZTYxYTg0\nLWM2ZjMtNDJlNC1hNGY2LTUzYjljODhhN2ZiMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAQxZbcQkIf37jdBVyedodEXuFLXfyI0dFpzW48p/w26a774Ey+qqVLz\nD+a932pVPoIzCA24bdTnqFU/W+n6grKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLProzIn\nZ0tMLVhU0qgfc9KOIrExMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQD3W+cBV8j5z4Cr9lHeKu7G+XsubnrfNu5OHoFa\nLVRo0wIgCCaTZaPGn7SAb0mephOeG7E+a9r87sPl10C6I3dalfQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1162", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1162` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYXs2geJGKSpG90prmeRR6iCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4ZmUzYWU5LWViZjEtNDM0OC1iNWI1LWJkNjU4YTgwYTdhYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWViZTY4OGItMzM1\nNi00ZWQyLWIzMDQtZTJhOTIyMWRkMDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOZiBOUrfmszShzRiLh/DY0rUQxb2RPbBGaXJtQ/MXTd5bQF/57C4Cx/q13hZ\ncJ3FaaznIK3/B0X1kYkr2hg1PKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy5h1qVgHamHkHHAY/xk1cS7MGAowHwYDVR0j\nBBgwFoAUrUJp0Kvu/PTjpuBfLtpSQ7cjCAswKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQChXM8f+v4P\nsM4afvylChBm3jUc4OPq15I5B4mVTOBo/gIhAMR1aHp7ZkOF1cyAqxhejgmudsCi\nXRlFASBVyet+PuQh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQkCNUARJM8yMv6qd4h+/oN8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGZlM2FlOS1lYmYxLTQzNDgtYjViNS1iZDY1OGE4MGE3YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHdyESSRxmomqeWVgtD5zPlr9YFNERDRjc1UWL3W/lYNiU\nJ1wqz3YQYdBSGdABkmD6i+FAiwYqMDfr30XMKNh6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrUJp0Kvu/PTjpuBfLtpSQ7cj\nCAswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcWuNi4HVXLdyUfGG/4ZJ/7cdaJNnFEYnGnF4MainmWcCIQD+CqMgdXJM\nxRRi1/Y1DgJjfTHYjzaXysVqZLYP/7BEbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAZJQZb8ICOB/Bfy4R6rh0JtwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWViZTY4OGItMzM1Ni00ZWQyLWIzMDQtZTJhOTIyMWRkMDA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJiNGJkNGFi\nLTA4YzYtNDI0Ny1hMmViLTdlN2UxMDY2Y2RkYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMajDn0Qu5klH14LEMRPNwBZm9Ny5Slrs3VX7x9DqQv+cD86LS51mUCN\nswOnw9wALTgVCHeDJXPyN0fumVK3YyKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMuYdalY\nB2ph5BxwGP8ZNXEuzBgKMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCICPZpjswO0sVuI77SToVZr1Ey3TuBUSkVunLjgdl\n1TaqAiAwf8NqOKnjZCP+v9BwrMrAgfPMrA6bA4liavSTnk/wFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1163", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1163` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdTOs0PLCrJp51vDUOWbxGZyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2OTRjYzgzLWIyYjMtNGFhNC1iMTUzLTNjYjgwNWZlOTdjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc2NThmZjktMDEx\nMS00OGVhLThlNWQtYzkyZTgzODQ2YzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2dfS3gmqHkqMsFnVaIvDpVCx0KzfxqfLps/ElGZiiZPIa2G/g8HpPJxLfbNz\nlccKUZpnBA6fLVgPHisCRvBx36OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpChfwyVaKIy7/Ho3oYhtOIHe0XowHwYDVR0j\nBBgwFoAUbzNRbm+SiHzqU3B9q6ULDMvhK58wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHerzGXGUxJX0ux63amLpXaUmeszjWW/EmMRbhSWmDuSAiAxB2t9U1j08Fkl\nZTnEnHpF0sLz68ognhAXz9fVv6gVoQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZBshKMqNRv3ZwWLy9qohJCaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjk0Y2M4My1iMmIzLTRhYTQtYjE1My0zY2I4MDVmZTk3Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaMm5jhpVuax9oJIx/RC/FWt0RCk8Y+Jf+z+5yFd8hiF2q\n3ERFbJshhU0URl/Ia2N5SxnQO04UJKW8cQtN3w8Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbzNRbm+SiHzqU3B9q6ULDMvh\nK58wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJVWKLHBHMaD3JehbNPvT/Xesx4vEyPJvyOIh3fUi5a4CICxT7CQD7Jz8\nxTs00qCUWkWiBosx0MGnjZ67a4bkGZ9c\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAdiBgq+Ah+BiPVYEnQceR0vKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc2NThmZjktMDExMS00OGVhLThlNWQtYzkyZTgzODQ2YzQ2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDczM2YwOThj\nLTZkODUtNDBkOS1iNzJjLTc2MjQ2OTc0MGVmZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH+j36a550gqEzpiHQW+aGi0iZsiUfJqFYgIKLGBj32MKMwSpyN+XJil\nyxcU99d7RBpUi2noer4LwI2oYuoYKbijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKQoX8Ml\nWiiMu/x6N6GIbTiB3tF6MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIEjCso+ZgYz2YKXl4bdCozrItVsYBmFHn8zgRcws\nld/OAiBF2JdYutxoY0RG38IszlSq15NylTa0FUg9hOIO9jOTSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1164", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1164` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAfaZZp0oL5HRGbvwmI3zwTCvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMDU2MTkzLTNlMzMtNDIxZC1hODA0LTUwNzJjMDYwZjBlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJjNmE4OTYtNzFl\nYS00OWE4LWE4ODMtNjA2YWRmNTFmYTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb/j16y/jugBdr0+UG65NBz1uOD+HId714olqQ1+EXgu63/cKk7oeHH41VJjp\nghMtxLxO9IPl2m9tRZWduodi8aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9OxeQgoYr6B4O+us9K7IyQ+ufckwHwYDVR0j\nBBgwFoAUOHQY3f9EKjQGiwX6IMRUZueD3mkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCh+UG5IhA0pVxr0NJ5xUTvWVVoymikf0Rq3pgRAl5UFgIhAMD3oVe5iBOO\nJqDN7Ek7ENIU+huym/RO4CAFkhd/EmJ8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVLa5TvkYzaOitD/uNItd6AAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjA1NjE5My0zZTMzLTQyMWQtYTgwNC01MDcyYzA2MGYwZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbRlowWNfB58K/iI1k6pTWSykPiSft7gFxSLDpRYcMPpEN\n7vtMSKKXbU7GcrbQKfSKqyi97nLOThO8ytLU+F/Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOHQY3f9EKjQGiwX6IMRUZueD\n3mkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgew0h3eWTR4QgvpZYaBmcGtNZzygs9y6Z1M6qu3FdrfkCIQCf9Tb7ns8/\nAIMxn0iCKkOgdlzIniiYZ52AIyz00vANdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAf6MHvnqlSFFjZIl1FLBEZ7UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJjNmE4OTYtNzFlYS00OWE4LWE4ODMtNjA2YWRmNTFmYTllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFjYmEwMDQw\nLTljMmMtNDVjNS04MzczLWE0NDMxNDhhOGI5NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJBHrPdjkC/t+ObNSiE+bk/7n1a2RELSkkrjHqJXgRpwCrZ/QeMcaICc\nwSeaVtExhAC4WPu+LE/Puwi6noXTZfGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPTsXkIK\nGK+geDvrrPSuyMkPrn3JMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIFzrFWAZOsTK3SwnmQ1L5Ut+yETsR/BVooC9wD3G\nsoRpAiB5njftyf03ahCxBWblK+2rqMubfmaXxWWDzmu7MKuTHQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1165", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1165` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAbfRAYe0dSaZD1860X/C1buOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3YzU2ZWIyLTdkMDAtNDkxMS05NWQ0LTM3ZjZiNTA5ZTdlNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTE2MGI0Y2YtMGY0\nOS00YmMyLWFhYzQtNTA0NmIyNTQwZjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbOh0wroBF0MpRQSnL1PtsBdovp+k5BTuwU9mTkFNftvTKvpkux+uoGwaPIfN\nEPjGmAKpafgHp7I7uS1Mex9LBqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWlRmM2LNocxYNqXKNPQ9bmfcsP4wHwYDVR0j\nBBgwFoAU1F+E8WHP7KorKNVNl/UcEQQzkzkwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHPv\nx3xEcBJ1lXrN0aEfc7kQ54HvgqWgkaa/m7OZevzZAiEAySPjiN7ZufNGzJ9Agx9o\nn6irG0ypevN924dXVTeGhwU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW9SJUS4P6cOugP/kHgk0HyCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2M1NmViMi03ZDAwLTQ5MTEtOTVkNC0zN2Y2YjUwOWU3ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMdwRnYWJbV9SKlZJBPl6ZGW9tVVMvE6STv1odtzvf89VF\nmXpg+8f/AfestxamqzA6viLPfG8SxABSYzChmEawo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1F+E8WHP7KorKNVNl/UcEQQz\nkzkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIl7MfRbFJRDbwRpgX2Q6IXUf4fKjx1TCtc/neKU77p8AiAEMUdBB9l3\nFx2BLv1OaoozmHNvKQ+0OsB6zFqzGZVyKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAQNiM41jvGt6yl0U/85UkLRoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTE2MGI0Y2YtMGY0OS00YmMyLWFhYzQtNTA0NmIyNTQwZjFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM3OTM0OTZm\nLTRiODUtNDhmZi04NjJhLWY2ZTQzOTkzODA1NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFRtfsIxjqrlJQ3bACM0kbQppP4tzN3hTf9V66yRqD2MRKL0IcMU44rU\nWY6KB+HRdTHdmBmIBaPYOc4IOYOOIQmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFpUZjNi\nzaHMWDalyjT0PW5n3LD+MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCbHvqsT32bvBkKLKBIlRjBrG9c7XDxV9Ylf7xh\nmZpZ+gIhAKeD5Uckn4AWgn/baq3QANMAj+vVQ0ctdOZwuE+ToT3x\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1166", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1166` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAbQQFbne/fUII3IGHKMmQFG2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1NmVhNzUyLWZiYzktNDc5Ni05OWVhLWRlYTQ4ZmU1NDBlNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmMyNGMxZWItYjI4\nMS00MGFmLWFiNGUtOGFmYTY5ZmUxMGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+wqkHoGprep3aq0ZWAKmKXZ86wXabd4RGkFNfUSZlKg2Cmh7ro3uK3HU0Ftd\n9uvj2eF122jYhqHZkWt+AJsngaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpaTgZbfHbur6GonfERExQ/T/ByYwHwYDVR0j\nBBgwFoAUstroodAwnOpa7Cc5YpVn9LrpYQMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDhtgDNWElN9WDINbGz8iW8RnZ6Ncou63TXMvlXmHcYnAIgOYFi\nItTg3OYSJLc7tRfAUhFbvDLkfO+HMgWO7dsn1Vo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY0WtjGliskwX/JMDa68hU9GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTZlYTc1Mi1mYmM5LTQ3OTYtOTllYS1kZWE0OGZlNTQwZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiUTytyN1gW1OhKautcnNDFB55dC93oEzf45dhrY6hLVXs\nNC+3U7lFBv5nf8peGdGiPvP10nkzwCWkmhnVPNZko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUstroodAwnOpa7Cc5YpVn9Lrp\nYQMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSZO9EFcPYJvXGe5ttD1LtprW5SdmykPpcD3jtXzr7SECIGF6UQO5eAeT\nDnSm4EFtuv1scWbg8LCdH0T1ewo+W9gi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAQYiPV4jZZFqIdi8Q8eMfUBcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmMyNGMxZWItYjI4MS00MGFmLWFiNGUtOGFmYTY5ZmUxMGU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyYTkwMjI5\nLTY5M2QtNDk0My1iYWQ4LTAxMjlkNDJiNGM4YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPRl9l6wLScSVLPyV8kl9ny/6FnGM496NsDbZz3+PFYW73szQxS4iPm9\n0bGObviCf7/rWl3PQTvvWt9OKy/gL/ejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKWk4GW3\nx27q+hqJ3xERMUP0/wcmMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIAq3r8qBYnwXzUYwy2zr6nhIglRgmX0BULE+hYKX\nRLn6AiBdr90OH1hoWON4tqI8X/mYy8qCL3WYN3mrMquRkoFdlg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1167", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1167` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAVXzvrs+939/pLaFZcSXxjQMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0NmEyMTgyLTFjYmItNGUxNi1iZGJiLTAzYzM1M2QxMzgwNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY0YzYyMTItNjA2\nOC00MzQwLTljNzktY2M2NWRhZjZmYTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdgyJrRwtqu42okS1NTtL3h5N5+jnfswWv/o8+w2nA9GectKOUsn2xyy2c+XD\nYeTsR+BWZ9kfT2jTk7DhXZxhvaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuLUVv/GfE2sNs53fpOlIvCJfXBwwHwYDVR0j\nBBgwFoAUSyeoZscMGU1ldt8Ew+x5yDfe9UwwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIBeOfxGNefdIjZhcvOGITMTM+mVxq0n9GfhVLPk7ncfLAiAXKV9o\nZNGXKQNGTv/kU8c97RqC5j8Gi/M60f6b1Qkmqg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa9xoJdZrnngExnG3V/pex1RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDZhMjE4Mi0xY2JiLTRlMTYtYmRiYi0wM2MzNTNkMTM4MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyVZqMilhLUapkpZl+yO2RtQ1Ge+VozxDQvIJ8tF6ULR+f\nNttMnZ7k6BOchfwOWIK6squU2+bTYTxgH4hr+un1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSyeoZscMGU1ldt8Ew+x5yDfe\n9UwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY2jWp/WL5+H7QznCf81fKoEpanw7FRCPsr8995AiJgECIE9Q0IjR0QV2\n8fuPni4BRYd3LkConlSrsAJ4BanjMKAd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAa79spTUSIAGR5tCd09oKJEZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY0YzYyMTItNjA2OC00MzQwLTljNzktY2M2NWRhZjZmYTc4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhjNThhZGI4\nLTBkOWItNDdhZC1iM2UyLWQ3NmJmMDUxNmI1YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAvUqo+Kvp/Ni/COS6BMAdWJ8A3lGOq4QcI4B2kw/FZuAcsQykQSZdu9\nTarlRQzykw4+vCrBJzKo8RdgjUkxoSOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLi1Fb/x\nnxNrDbOd36TpSLwiX1wcMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIHsD3TUYOmerF8GOhsVpTbWRf2dpWWLycX2hHsXP\nSojgAiAFDdsdklSVGpyL1t+JsZyq6sWdwc/gXMF72EjDvyldMA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1168", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1168` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISASmdjDzXS74yX24gJUh9GbdBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljZDc1NzI0LTBjMDAtNGVjMC1iMTk0LTI0NTY5OWQ4NTllMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg2ZTVkZWItNDRl\nNS00NDU1LWI0ZTgtNWE1YzNjYzdlMDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErxHLt3jEneCf+1WQo1XqW92G3SpclcKGlod0keQHRrDDrC1HqTdf0d475Ero\niOT7jqi0acwnEMurmjqNtCTEsaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQQGFhxv/Yc5RAjLEkXSgXShVAe5zAfBgNVHSME\nGDAWgBQ2lcBAMp5RwSKKBAOjr4yjj1sHrDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIB28tfJ0wGc253ORh6vWnI0K7BnK8kKc\n7a9RMnb4szsvAiBVABcOhWDfB9d0BMYxS7rutok1xGdg6i/mXQFyunsKiA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf8kdNTGJ60x6oomxmT1B68rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nY2Q3NTcyNC0wYzAwLTRlYzAtYjE5NC0yNDU2OTlkODU5ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwQdPNY1Lo0iwxWP4/SBl0n9TOGpyp1msueK6mETGyHXmf\nIZw+p5BPItwlJ+XGrckcBnHvdO6B9BZFhT6Z0EEKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNpXAQDKeUcEiigQDo6+Mo49b\nB6wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHT5h+awyQJbR9aeklvAREX3MIfMLIH62j4y1fuPgpzACIQCfNmEeJWhp\nhFyi/eY0YQeCdZ5GSVa+UxUV4+vp2CZq4A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAeizqw8Ad2isST9l5Ij0NiURMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg2ZTVkZWItNDRlNS00NDU1LWI0ZTgtNWE1YzNjYzdlMDZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcyYmY2ODFi\nLWY3NzYtNDgwMi1iYWNiLWQ4YjA5ODI5ZTUzYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMP8nCGcL/KhIWNij6KpxoijKDHjY+7k0U2x9egO5dxCPHGmBdrfnHEP\nQ2513VkDG0Hnf4V5jA02+GvEQwfvkz+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBAYWHG/\n9hzlECMsSRdKBdKFUB7nMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQC/RCsuVkPpH03HDMLy4ps8l4pg5//MGi7x1k/c\naZEjbQIgTiY/6e5tvCkURdGPPwUp0vXAf4L/HlSHYQrgs0HPEMY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1169", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1169` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYn7KNS04lnxgHsYWAXEn059MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5YTI1NTkyLWRjZTQtNGJhNS1iMWYzLWM0ZjFkZDAzMDViZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMyYjJmMDEtYTNj\nNy00MWRmLWE2MGYtOTczNjZhM2FhMzMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZcaQV5nmOU1IpFpzat7enT8c2ssBs8Dg53b+l/wmxQmSiyxCCQiNFgmaVsMh\n3Ma+vkFDiu4UENCuXL60GjY3FqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYBCtUuSQlB7iNzrP6k/d6poKXLUwHwYDVR0j\nBBgwFoAU35D920zHL2lUZfLB68wRiQKLfygwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBcYpPiVfdKc\nx5gJf4Nl+0V7e8DlW+Z93tL38BhqXT8FAiBJ900brJNrX6fSE1nvDsAzpoEzYgLz\nUzdqBEoVQRvXMg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAecvyDwgjFmUZq+4s+Se7xARMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWEyNTU5Mi1kY2U0LTRiYTUtYjFmMy1jNGYxZGQwMzA1YmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStGkOycfRYBGjyl360cTF77MVN2PNOMmfO/GoC5XBOuZkK\nUvYwa+hkOX2LQe/p5CKM3+WdXuUWMXKRvXZ6gKTLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU35D920zHL2lUZfLB68wRiQKL\nfygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN2aQiUwY1t2rA34M+LmSCyDmVEAKQdPN7qyKGzSxAvHAiEA9szWl9iD\nUFv7DEhAi89nMjdXfPbE/N474MYgMAY2T0U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAYeQ5iebkK/nTqT8cN3oY5H+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMyYjJmMDEtYTNjNy00MWRmLWE2MGYtOTczNjZhM2FhMzMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAxZDIyNmEz\nLTk2OWItNDI1OS05MzE5LTY4MzA2NjBiM2MyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM7iSwrjFoqTbnTyaviXUD98+lH8BSsPNhVUMCUdjALP/DDWVRTAu0Ck\n3sLCA9YFcQuQ0626Y/rhM2+RAXiBhPWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGAQrVLk\nkJQe4jc6z+pP3eqaCly1MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIBJJuNapHDMXyTnq3gXFGGCZYn1a1GCkpkWDZLDq\n60oFAiEAtT/Hd2o4w6yc6H+I2/A+3hIccaTMC+NMJQ9ExHsmKkE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1170", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1170` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAXxk4lVcSfNPn3akX+jmdMDPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjM2Y3OGNlLWRkMDktNDk1Yy04MzRlLTlkMWM2M2FjZjE5NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM5MzYzNzktMGYz\nZS00NzUzLTljZmUtNDFmYzNlOWMzNTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERI8YFWJklK7CIof3LiFxCMpoA8ZBixcEc9ksSSRYXzWXrj/ZvIaAP/VGS9S6\nf6IqvdCdQ+e5MhD6dQ2PKZrz8KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvRFknQuVuv9sdpy6mx9F3CTCxSIwHwYDVR0j\nBBgwFoAU6nzyCr+LxTfzLblxCsCxfjgfCI0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCA/YGXZq38\ngcmhHVFWU7Pchw16er++ZrZIC8MTTHPVVgIhAJvmRNAD37IV8eLP3R5byLd6UxeM\n/KFrRNPb9jg3QCWW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfrroUyE94LwNb+RYnhnGqkrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzNmNzhjZS1kZDA5LTQ5NWMtODM0ZS05ZDFjNjNhY2YxOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/Q6sDZfSHD+mUY92ymdCLcbwLEIgI6KGrs0Jg6ahVGRuH\n/ZXazgz7x5ho2GTtWY2ZIH4BsxtLdoG5XAPhk7Xyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6nzyCr+LxTfzLblxCsCxfjgf\nCI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMuceeadUF8wklWLCFcElaIaQdavBjhbuQWw/mwITVV8AiBx/PH7W9/V\nRS27/nXVBDWIdxMs1D27fI0t/S6+6YEWXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAedboPGjq2EdgEujVRJlnQWrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM5MzYzNzktMGYzZS00NzUzLTljZmUtNDFmYzNlOWMzNTAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMwNGNkNjU0\nLTk3MGEtNGZhZS05ZTRkLTgzOTI1MjJiYzQyZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAYszU1hCgQ15zng6Hif4OuqD/MqdC52R77CFNRRqX0+ZMRlD5OIw2ng\nCDFmB0dg2hoF3EkraeC9uRxWWtyVaWmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL0RZJ0L\nlbr/bHacupsfRdwkwsUiMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDvYwpPQf5/oT3C/r73sXHJk5JkuedCMYn5vzLd\nv3EZgQIgeVAaq7S9jC0CcZS4XITQjDn9FroYhrd6Ws+Uc41Qozk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1171", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1171` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAVwM9LJI8HXU3nErzBYFb9EOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1OTg1ZjUzLTY5MjctNGI4OS1hNTFhLTFjNWZmZDk0Yjg3NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y1OTdhOTItNGIy\nOS00YTMxLWE3YmUtNzdiNDEwMWZlMGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM0Lv+UdeFOSyqbb1GK2asPWrIdjUi60DXTUQ1ZBywqzXafCl2fV2ExaJDmKb\nPF0DwNmxOVfArtMWY3SoZSbOAKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHaHX+2VAbT/VktZOS5ccpWMAMfwwHwYDVR0j\nBBgwFoAURrjwuUIH+hm4T5/o3b7V+Ltx0zgwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAMKdn6335b\nMXUP/8BIqmMUyR+1sBO004qQkWoIDu45FAIhAJWiZi53Mz19Ktdlel1PGgrpOdVV\nHsQmk0R0LfjU7rXa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZqbRg1V7J9PIDPW8AFzg6XfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTk4NWY1My02OTI3LTRiODktYTUxYS0xYzVmZmQ5NGI4NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI0L2wTr69IO+CVj08UfjA5kD0GG7vbt4IieR25tmnqp+G\nV9Vx4c9BBetk5o2BAkZxgHUvVr60XMScWmfjiJFwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURrjwuUIH+hm4T5/o3b7V+Ltx\n0zgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMEfxkDbvX0da6uoqazrBkQgpmOtexmM7vAXuxGKR+u0AiEAr4n0YQWf\n06gCp+8BEjoyFyjsHbBGdlxp5tZy2WPCdA4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISASeu0lTtM8EO9I7Ei1nxqUxpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y1OTdhOTItNGIyOS00YTMxLWE3YmUtNzdiNDEwMWZlMGUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNkNTZjMjBi\nLWM5OTAtNDM4OS1iMDNiLTJhZTlhZTJmNjJlYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ8+QykfttxXYYtuIWP5UXnEX5sax9BDPRvKq9yAHRWevu2xy3bZwZ3b\nsj5VFNcN3koz0AWND87jnHo/9sI2Eg2jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB2h1/tl\nQG0/1ZLWTkuXHKVjADH8MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQC/vFTZDCAYD5nHKSo+NeDBVAcWA+jJGldQAA40\nT2oWnAIhANINfPrPPpb/eKxj5L9QF0FDngkS47A31U6C7I5VGbJX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1172", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1172` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAaCH/ZsRW9Zow7ddjAKnu/XCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0N2I2NmQwLTFhMmYtNDM4NC05NTQ3LWM3YjljYzg2MTBhYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU2MzE3OWMtYjY1\nMC00ZTU5LTg0YjUtOWZjMGRjYzRjMDBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE42T2MkuPtCwCuhCjEBbYDOJ/Bdj4Rh3P7IY1s6idM3CuwQuHobVs9ObUzHl6\nZiuCoQX0QLJa6DhaEcO9G9zZGqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvnq+8bLkEtZCuEXWaEoF9Y5Gt/UwHwYDVR0j\nBBgwFoAUkDczFph04PMxMymAzYr5nBk5lU0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA8H1qxGbp67PqZApyCJ2+ykDlxT9Rp8kt8wmYelikucgCIQDCquCqHr8L\nK2E9QM+j9HC3R/osJuVHGkskTrEco7GNjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcrHbiIwbyoTAc0VybHsW823MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDdiNjZkMC0xYTJmLTQzODQtOTU0Ny1jN2I5Y2M4NjEwYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWz/TbqcEMpwRylvmcgkdhSw7vOHyBvj2OeHCTiz7PlB/O\nVTSwgIEHB7t/Yze4Ort1qmIW7e1l+u4X9eprQH9xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkDczFph04PMxMymAzYr5nBk5\nlU0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSI8Ws+7FkiUt9tyqM/ISwnI8e7dZiLE49GayXUNMYZkCIHVU0NY5TPxE\n1eiBT685UYTmR35v36MAkgi+AxEnx2D1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAdP7polA5sce8j2uzEJsfGfWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU2MzE3OWMtYjY1MC00ZTU5LTg0YjUtOWZjMGRjYzRjMDBlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ1NmYxYTgy\nLTczNjgtNDUxNy04NGM2LWJhMzQ0MTEyOWQ3NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJAFfQuXahEvuH8sAL8quea/sV9v5POGPtdgwb0g9cNqIFfN+HNR6fzJ\nSz2LiFP8DyJUj4E83NDTVsOftNtOcTqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL56vvGy\n5BLWQrhF1mhKBfWORrf1MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQC8VURP+9WyHMqCPjFKwORI8fTZfrbU7QqJVWr/\nsPgy4QIhAKIPTkZrKzWcEiKlWoM6sslLUZ3EKOIVoKRuJJFytM77\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1173", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1173` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAYBV6hbXTngkw7RS7w+V1SdsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiODk5NzQ2LTQ5M2ItNGVkMi04MjczLWQwM2MwY2RhZDhkNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc5YzM4MjItMDQ0\nYy00M2Q1LWJlZGItODA1MDRjN2M5N2RmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj8o05q/fgiGjf5xEkeCgoMeTVLat5llVuRftIFghMsQI+XX479zjcoFh5e06\nyyOt022WrvYFxjrLLQ6BcejzJKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/3roGRvGIpLQg/A9cF6+vseBC9wwHwYDVR0j\nBBgwFoAUu89ykPoicNuEtkXB8jxND2hxgqIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA89sgoN9VHICOu9lZCuBScAK325oz6m+jiABjVz+E9B4CIQCK99MbcoVp\nK+jIM/NuOSoSmo5OtWsaO4fR9Qoa4+C8Rw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVHrH8ggS+9d90SrKH/kSFEdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjg5OTc0Ni00OTNiLTRlZDItODI3My1kMDNjMGNkYWQ4ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3QHxc923n20kCM7HuPZ9xD9wbSkXP/WCCspYKiomrXINk\nuBDrUhUvoW/YW7nB5pHW4MhFhsUIZy+UWV9OvCB9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu89ykPoicNuEtkXB8jxND2hx\ngqIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBnBsfA6d0DflMBtBGXG8E9Av50sjiucPPmUBXT10dsgCICm/zqqUhB9D\n72sLgs3xZ/b/2mm+agJZZymAoXd8qvXX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAWwDO5hA4io3uwZKqEusvnOSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc5YzM4MjItMDQ0Yy00M2Q1LWJlZGItODA1MDRjN2M5N2RmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5MjRlZjhk\nLTI5NzYtNGY3YS04ZmY0LTJkMzk4NTI2ZGZjMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDN9AAGSoY7gTNSl0S4QtoKESZmnojSK98ZZUIzoLTonUmRxyeG6P3pA\nDyL5uG1asabRSsgYBT4eJh2dy43miwGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP966Bkb\nxiKS0IPwPXBevr7HgQvcMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIFJF5YpjiM6oxosnCKLNXewzH9AdpYfOvr4ixpAv\nPNc3AiAl4cpcut0xbDrGY1LGhUXkQxNcuYy/saexTE1RhnY8zg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1174", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1174` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAbI4agTgPQP8SWFp6b+tAOTOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmM2Q1NTZjLTIzMGUtNDBhMS1iZTljLTQ4OGE4ZTdmZmE3YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU1Y2FkMDItZGI5\nYi00NDVhLWI3NzktNTk3YzIwMmUwZmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcYdEm7hGZaXZtpzpSkrZRhZb6nf2ML7XTQ0mKqhKQm/8cpt1IxoBKewWEpf0\nbhugRL3HQhHZZ2rDHy7VkLb/HKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZPAGciD1paOc/I/IUqZd8RimvV8wHwYDVR0j\nBBgwFoAUnbcGt97ZWuiU/qVLdBltLE9qgiAwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBm\n6OO59Kca8ImU/MnX9NDnf9350fzitCHIVtLisS7jUAIhAMhZbQaXyYGdPsNM9Qoj\nPOMGmtDGgklAAIgRmTbdZX4S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVKNEdBAGXjJn8zBLtMjbtitMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjNkNTU2Yy0yMzBlLTQwYTEtYmU5Yy00ODhhOGU3ZmZhN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhZMGJs/roUBnfMM08oOSJccLrBbehNUs/tbOt+pfTSkMf\nYYgDGTErPU9eRrF34Nm9UkGPUVUGH5zUIaHFFVhno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnbcGt97ZWuiU/qVLdBltLE9q\ngiAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF5BARISsT22Xg1jqwR5itowrtUGsaaM9INgoHIUsP9oCIQDBPCvUhCW6\nmQ6Cy5IK5Yu8hW3B7285ZN2QJDGDnIky0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAbHqY9501leEKyNLOczMCMhgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU1Y2FkMDItZGI5Yi00NDVhLWI3NzktNTk3YzIwMmUwZmVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE2M2MwYzk1\nLThhODYtNGQ3YS05Y2NmLTZhMDliYjVjN2ZiODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEShy1zrxWJjhdfHPrCXStd7sasJqMZSZrGrcwdSCbwWoqkHyYQ36Z6L\nfPusuhB15MdCTJ5FjJilvPTVC1jd1UKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGTwBnIg\n9aWjnPyPyFKmXfEYpr1fMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCkdVtvAOC6QK7LzgNqX/gaNeqpsKH8b0Z9pIRi\nnWQorgIhAJ8J8XMtTW3ZqMFHlrA9mncq/8nV+nGUvj34a0bxDhkf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1175", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1175` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAVDuUj292CfaC81d0T3gQqOhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxOTYyYTUyLTkyMzYtNDQyYy1iMGNjLWIzOTYxM2YxZWQyYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBkNzg1ZjctYjky\nYS00MWRhLTk5YWYtODNiZTI2NDk2MmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2s53HBpR0SR+Lbu9PgeBeP3baMiqRMazB83zZHwRvTZKCMKg1tu2TOGRVewM\nSmNGwRUU7hUPzxoMr5NBGp6ul6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrWrS9havlDRZKnbMEYf3/NPp3eUwHwYDVR0j\nBBgwFoAUamjchJCF5uY7UH1jsdFgpm1qoMEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAm5NJ/dJWtYJDK4X04gt8oH/fv1qJ0IrmCk8kqRXvaeQIgCSzq\nzHOcxqQ/xCNyzqR/Lqq0HdrUGSrnJKr0YjSeFmw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeUTNvBDzAFQAmlroBT+/940MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTk2MmE1Mi05MjM2LTQ0MmMtYjBjYy1iMzk2MTNmMWVkMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROPr5I7ilnf3AiKS+TiznDZna0Nj/V6bihtY1qvoTqicpl\nKInDBpnXOvJXhmjQlGPptKKRVZ+hehd3McJIkQ5do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUamjchJCF5uY7UH1jsdFgpm1q\noMEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKJFCKaruArdCvC+ZC1S2yrMOBsMVC55m0QC8ZYRtjutAiEA43hBP2ME\nD2500QGBvaCNI1o89Gh0BhCMNaHu+spEkeY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISARnhvGKaTnCYm8K4KeZeDyr1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBkNzg1ZjctYjkyYS00MWRhLTk5YWYtODNiZTI2NDk2MmY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYwMjA3Yjkz\nLTBlM2MtNGRlMy05YmQ1LTY2ZDk2NTg2NTNhODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI9BbVZ4lYTc6/e0MQBZTawPQ34nQvq63FP5IqQw6SQKeRnwQTTYbcJ2\n4xQ9M7QlE4fGQA0uIa27xAdL2qOtpUSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK1q0vYW\nr5Q0WSp2zBGH9/zT6d3lMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDcrNlWYBuwHLIqvVkhOGR8oqy8mqU+hTuouMhK\nkq0uvAIhAJRt9wJkIUmx0wW05TKeUDm6WW0gUc2ZkEwRHkKKJVCf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1176", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1176` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAX2KkXFkjBztRwn9N58pjPgSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhOTNlNmNkLTBjYjUtNDU0ZC1hMTU1LWJhMTRkMDBjZDI3YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGViMThlODAtOTI3\nOC00Njk4LTg5MWItMWVkNmUwMTE2ZjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEalwRNA7kSwJ+w236sY2SbBjuVwbD7C9pHm1+N9cS2AvtqDg3sgrdOq7xl7JH\nOoJFqGqp//lZcpUvLKAMBynN2qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU431ATgTFb5SxTnHoXhLy00SV6AwwHwYDVR0j\nBBgwFoAUT+vhdQJI79yTRXhZt19X4vr1VuYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBIf54pWiVQfQmRtrqDrDpuPR+NoTigzh5RA2cFOwOplAIgMZZZ\nIz/g6xYZxUYlQtW04FOUKEPchHTlu7PSPtprrTQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAThPq3BnYf6XYbi45ZjfQ2oYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTkzZTZjZC0wY2I1LTQ1NGQtYTE1NS1iYTE0ZDAwY2QyN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7FpyD734gXMq9eqBWUJ8dxUm8R698YXdChAU3vLKxsMkU\n1uqfx6iQ95iz8Nfs/Qt4jtwP1ztcpCYNK3CLH+tEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT+vhdQJI79yTRXhZt19X4vr1\nVuYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLZHr0a0FhuduOwPEZBHIrHEkRIOkyUIK+N4ELUnmAhECIGOeoXAoESNj\nlwhq6G6N9zFU0oRbgt/vGepW45Psotwb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISASqAlqPHyfZYKPEZ5TkKsHpwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGViMThlODAtOTI3OC00Njk4LTg5MWItMWVkNmUwMTE2ZjcwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZjZDI0MzM0\nLWFiYWEtNDI0MC1iMmY4LTg0YzQ1ZmY5Yjc5NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEtibqtOzWgWrhZeVrvMMBBJeUYH1PNLDwIenLtfByoFv2r+Sv8sdc7o\ntrj/XF8UWU7aqPcsSSYjMUEyphAmXXajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFON9QE4E\nxW+UsU5x6F4S8tNElegMMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIETzwDXtEu80gZBv7R6U1oUVTTJYcV95O82qYV+l\nwiJ3AiEAtYSP0xSTN0TJG6GBUT+Nujbq6YbgU/xaIlmJEw2TlmM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1177", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1177` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASABhOKX17Wv1efBxSgDxuYpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkNmVlYjQ3LTdjNjgtNDQ1OC1iMmViLTMzMWZmNGE5M2NjMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmIxMTNjMWItNjZj\nNS00NGQ2LTkyODEtNTQwZGRlYjVmMjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpyLJDDb9OohxZOZ7ETDfEBevZD6n2Cy4okZDhF21I/wMjuge4GH6tkaRhuJP\n5w5lplm7TCU6CA4hSjXzoxvTXqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyieqfA+c0IFt/ghfgIrJ0AQ3r6cwHwYDVR0j\nBBgwFoAU9UivW2sTbLz6ghG5HfI/EH92XFUwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBCFJ0q3/NaRlzD\n2zXdTS49KyQOBCQwgk9n2fVRE9tXnwIhAPWuVi0/9Kn42wkvxIuINFAX+yJNxnKE\nkbHUwnHN5hb3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWpi8+zzS73m6JaTItbOzRLGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDZlZWI0Ny03YzY4LTQ0NTgtYjJlYi0zMzFmZjRhOTNjYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCwFiaCVPnGJqz6RflMy+ReuK0eM2HpI/vQrrZqXBpA8RQ\nuKJc8mcoE+quoj8RdBWyMZmPcTDRjmowTcSOywsZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9UivW2sTbLz6ghG5HfI/EH92\nXFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD76Ewqbp+lBnD0lTs28t8CezgfqHdYTRmKNNCCvBcDQCIQDoTC40e6pA\noM1uQHi5izDJ6iTxLc6lZTv3gxBs5cgrlw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAXbHBZ1degZVKnvNkbBmjHDkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmIxMTNjMWItNjZjNS00NGQ2LTkyODEtNTQwZGRlYjVmMjE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY0NzRjNzI3\nLTVkYzctNGYxNS1iMjg5LTU4NmZkOWRmN2NlYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGWWu8+R3XUozGjjrgeq/S3g4vQ9AjOJeZOSBWhbEbSyPF5E3v7Vdu6m\nGgeUcJ0RFPPackWzSGGJCbns/XDYnGOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMonqnwP\nnNCBbf4IX4CKydAEN6+nMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCftUxNKGJfgBlp8tn0M/n2NXXwVoqDuNlL5OvI\nRwxe+gIhAI48Vf05zrMr8+gSyJIIjpoVUK6/l4l+WKzdT9+9zdHq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1178", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1178` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAcUhQBxDvSMG/8Y2ru36IvwZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0M2IzODU5LTJhOGUtNDUwNy05MzgxLTc0MWE2OTEyMWUxMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFlODFjNzMtMjQy\nYy00OTBjLThjOWQtZjFiNzk3ZmU0NTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK1jrGaFvjmYDaeJLmXj8cIdozMP9ofK+5+GippLu62RJPT1gwYlgqHsmVv6o\npn0BV6Sl3Y3C9HSzP/sMK2QjiaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbdGb67VuezvduNFiIxiPCUkB9j0wHwYDVR0j\nBBgwFoAUgmGYZCDYIr2mA2qEy4bBFcXsw+0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFR4V9gnm/zLgp9zTTNd9km7021l+rH17AeXm7rpnIW8AiAu5ONfZQaYiLAR\nLe5ykE2O12QYb76cgEMuv4ljwzrn5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXwcraGkBrmTBtlkqfuGyh2sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDNiMzg1OS0yYThlLTQ1MDctOTM4MS03NDFhNjkxMjFlMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVzeuVmsRf22qcjNzhxYhnlFtITZ1o+SvWcrpLwKXafXYq\n+/UE4vHgulFqKtj6pgo1m63cErLOwtvdacWT2gSUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgmGYZCDYIr2mA2qEy4bBFcXs\nw+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMD1Hv5BQrHGtXlsdfr29oHzlaPmnc5BRPvEiQtXqpdkAiEA81yhIy77\nMXPk92ZVhOdO2CE5w9JfDrcJjXbKkIKIuhw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAY4wnD5gCZPOAYUgQIRfKgYuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFlODFjNzMtMjQyYy00OTBjLThjOWQtZjFiNzk3ZmU0NTYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdmMWNhOGI0\nLTViMTMtNDJhZS1iMDI5LWI5ZWUyYjkzYWM2YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKXi3srSWcjluQvIQ2B2yKDd2MyLpqv4mVmhcE5xxcFkcn4JhPk7kyqp\nxyC0YL3K3E2N5sg6XDstL68MLNDmowajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG3Rm+u1\nbns73bjRYiMYjwlJAfY9MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCBm4mXk+QQWjlZrz6E4+8oUMKDi4+b9OntFH23\nY2+wAgIhAM8IF4eZEW40oRLS8IO6m2Hh6GwalkEPfCVqTqWuH7s8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1179", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1179` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVZFaIS9iIeavLE6G7iG8q4DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMDVjNzNkLTRmZWEtNGI4My04MjQ1LTM2ZTkwMDZkMjljNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlhOGU0N2YtMjQ1\nZC00MzgyLTkyNDYtYWNmMWFiYzA2NmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGhSJruta1KY8joAC6DhOAJKWtdXo2Ue9TPfNqi8051z773SSBVwvFlv5nGgh\ngd0rkbUgry+YfftZJuyZYyp7wqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyPOBEDXlgORJy22WF7JOB/zPymQwHwYDVR0j\nBBgwFoAUecTwKH+oDURdLVbHHAQk+mBYh1owNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAxW3eiYlvUwIYSl3QwLVoQQbvE2ZhZkW5dCWA1xHKeCAiBQ3tSYY3kvPUiP\ngcwf/TXJk/K00NfwjbkY9bdC3lWp8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS2lhTN05pK/TFXAbFrhI8XfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjA1YzczZC00ZmVhLTRiODMtODI0NS0zNmU5MDA2ZDI5YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMXpcpo5Ykev+EgzJTcq+PT43E6Y9P+cDqtBoHVsx8DRap\n45Xev12l1LHyIv/bySQ+g789CXfhxQBOoQhqdW97o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUecTwKH+oDURdLVbHHAQk+mBY\nh1owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOApehZxoApiW7Nskk7wVeLc27XqQxhh/FF+LBCdq48eAiEA0IKKkryy\nOECfdLBtS5uY+EpcXY+uVA6xA3S4V6tumyU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdUWOREiBl7ksrFbNQ9a/IaYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlhOGU0N2YtMjQ1ZC00MzgyLTkyNDYtYWNmMWFiYzA2NmFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFkOWY4ZTQ3\nLTc1NGUtNGFiNC04MmIxLTAxNzQ4MmRmMWMzMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOEdO/iJQ3/CYaBgU/UL1YOMI3o8dPhhnVSwQRc2wjl6yVWp/7qkEPCK\nf2EnQ5+FGN6qa+NQsqn8Trxe1W7fVP+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMjzgRA1\n5YDkScttlheyTgf8z8pkMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIH9qQN3tCUWS4+fNMEyKDona1S1YrD1akLSlNyEn\nguGOAiEAjU/2VE1dpS5Wr6WyUW9UVmtEV/MWFKsJ4zhxiAY98pc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1180", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1180` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbuGlKvGb300vHEkEXpuSpK9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwODA3OThiLTBiNmYtNDliYS04NGZhLTlhNWY2M2JiZTcwMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjMzMmQ3NDEtMTA2\nMC00NjEwLTkxMDktNTI1OGRlMjA5MDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqQFuE/zNWbnVfwlqjr8LW6pmceeUqEeCaszq+17mYdIlls/F8797ecrTViye\nQ2zHAjZs8Bsv9QWSnfywO0hUfqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZLz3DiPNlDwCVDmsAiL8TwrUHlMwHwYDVR0j\nBBgwFoAUfDWjIGO1KDWXtWDSbDo4m76WJeMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAoKLHSgA68lal/U6Z1x9F0YB/GjJ1z9nLBOZpyC4yCVYCIFvY5Y7K2Rsr\nxAAU1oPnHkhjuZwmbjvorbxA+gxSQDPj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU5hiIEgz8BQ//SZR3GZzM0QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDgwNzk4Yi0wYjZmLTQ5YmEtODRmYS05YTVmNjNiYmU3MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnF4qIeiIVs8ccg8nK8ty/Ct0vjwsJMrcxplgxHN9JdEUZ\nrX1MAqANsIWir9XLgT0GouliDWkBnE70/HSuY+clo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfDWjIGO1KDWXtWDSbDo4m76W\nJeMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE0BpyFkw8cG0GhxDZnpl5+oD7iK1esK8iAcqHSnX578CIG3U3ID+5wV0\nTeV9/MVfDLTMpt73WBqIc3Ypp6hIIRJW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAb/IRFasEHTQvri3rRnFbgeZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjMzMmQ3NDEtMTA2MC00NjEwLTkxMDktNTI1OGRlMjA5MDlkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFmNGJmMmI3\nLWUzYTQtNGU2Yi1iZWE2LTI0MzNjZGNlZTZkOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNH8bv6p2Lqp2TvJ5m3oVzuWL7xAyw9Yx8bR79/feRIO+puT2Q45kSnp\nZOvMMaP2dqOmTm1TSS4TY4fVkX9nd9OjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGS89w4j\nzZQ8AlQ5rAIi/E8K1B5TMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIBKLKh+y3PIjKwct6oCwKHSPmZzBO0HMhAnFaZyZ\nowsgAiBVTQxMHskkIeVWb49Kv/ZqwYCdqDW0xzErZ1K3/RFPFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1181", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1181` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISASAnjnzTi478TAH3rGCuB49iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4NDNmYzE0LTc0YjQtNGU3Yi1hZDhhLTkwOWRkMWU1YjBhOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTEyYmNlYTEtOGEy\nMi00MWFlLWIzYzgtODY3OTcyOTExMDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERJW9GmALWkOTMJWaY94OF+POkFyPUqN7uLuwdgdfWhbY7IZn6AXRdockCthD\ntRJ4YqY80wQwsMeN/qpycGeU8aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUniGFC2YbvEVA35EULc16kgz/yS8wHwYDVR0j\nBBgwFoAUs0vifBWGw6otOBSVHghBCm3fuL4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAqEspcz8v3VQQ58gfatW72gzvShZdnmjVFwgjPAaJ\nia0CIQDuXZPUlKOArAvC7rQ4iyHMib7QfQzA1TQEetuBSC6MGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARa0FccIDNF/Nrd5XIB87XcyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODQzZmMxNC03NGI0LTRlN2ItYWQ4YS05MDlkZDFlNWIwYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm2IMwwMPT/ZXI8yXtgSyMsUrbeQQtgDSRQfTODq1NmiBA\ngkmjhse7A6yw60fGwrrdw1fZThTiEOUsKnQmGXC2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs0vifBWGw6otOBSVHghBCm3f\nuL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPy4cQPbuLFk8is+LsFfXDWr4LCMMNacwujZlVLEVLMfAiEA7ADeRB6/\nULJTgXTCEAxwVQVY+vDY7Q4PL2W3cW1pQBE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAWu1MzWzS2BR67ZvY5wvqV2WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTEyYmNlYTEtOGEyMi00MWFlLWIzYzgtODY3OTcyOTExMDVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhkZGVhOTQ0\nLWI0ZWItNDRlNC05NjYwLWVhZTI2ZmM1ZDI0YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC03ogtXQdomK7fjeWnYknRVTpMOJy36/IREPtn5De50qjVtzUS14T35\nfVnM+I3Win3KOXHgBDznqmFAG1LynzCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ4hhQtm\nG7xFQN+RFC3NepIM/8kvMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIH1QPAutdLoCTRzBRmMhbV9VWLSBZvjBZPnt69WM\nKcVFAiEAxtMBKZjbg57Zg+dLG0NPBdWh8ZMiE70i/g8gsrxECAI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1182", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1182` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXO7j6tKllfowqtPL2QQp5FOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZWZhMjc2LTg3MmItNDI5Ny04YWZhLWMyMmQ4ZjdiMmFkNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRjMThiNDktMjY2\nYi00Yjg4LWJhNGItMzU4ZmEyYTYxZjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk0n9wJ8eAJf2Q62Y9X41AuczXGgxo82cMyBQ0khCnFIeqV6vGeuqzCng68GX\nPjtcQ9OQHApZ/RSLEoYSvSts3qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEcAg+siQxoqtf9QTiDnQ3bWt6h4wHwYDVR0j\nBBgwFoAUudNQl7wo8y5WZT3LaruIAm8kK8gwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAkOhM03aFZp1VvJKGBTAlpwb6CVvasNWQqTZzG5QD\nh18CIF723YWCrQWFySIFpf0z/Vze40ku2WLX6ejJP6zC/4pw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfppI7Ef4vPykqS9j/qD6VOjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmVmYTI3Ni04NzJiLTQyOTctOGFmYS1jMjJkOGY3YjJhZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm6lemU+FSc+BOKB0vg3hbS8SJ7ohE7qLHfp9WedJTHCHx\nVBxUKtgDSE0o9wAJaPCWscQI1mMu7ufsOWW86bUJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUudNQl7wo8y5WZT3LaruIAm8k\nK8gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL0aMm4dBfCUjiL+YVezwhFxiXM4tC92EgvZ0PpVztx2AiEA8G5BFRvf\nDgriSWGBsv+hixLN8uNwDgQBDxvlClI27OM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAeJV4TB3EvGRGyQ4jxQoPnZ1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRjMThiNDktMjY2Yi00Yjg4LWJhNGItMzU4ZmEyYTYxZjZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMwYzhiNTNi\nLWU5MGYtNGU5NS1iMDljLTZhNjIyMWI4ZDYxMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLukYpCFu8Zfvem6zJAZSpTJiAl4OoE5fPdafELs7T+gCusvy81EOF7w\ndUdVXVZ7xFWSE1+9rrapX8uTaCv3hFKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBHAIPrI\nkMaKrX/UE4g50N21reoeMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIHfKV7Ag2VwYxC2Hq+94RAPiTnBHOXhHBsDFDfJ7\nB7WPAiEAtOiikwt0xfoV9rtfm/i6ABX1aSFr4Dxw1PPafbWyzvM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1183", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1183` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAQNKUqYzqmc5QgrPGBjYmdWhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1ZGFlYjE1LWMxMmYtNDhjNC1hZDlhLTQ2NDdjOGQ4ODc3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFhMGRlM2ItNjhh\nNC00YTAxLWEzYjEtOWE5YjNjYzkyYWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx3Sn/wkXe/1tWtVgYH327nda2YBXfbdo1ppbEatN4TvVi0F39llCQ6c3LLp5\nSXEhjD7itXILA1I5xUVGacFduKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFx4jPkyQVBzdueAmADOCvG/LfAEwHwYDVR0j\nBBgwFoAU/vgQAgXAfPYpjMXaLDqte8GlTsUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAuHWQ3VqmqgZNAD57oPXsReR7O2zduUWlNBJLobUHjQ8CIQD/\nFAdAfpkijYCHmq6MvQHc+e4qsKn77bcQzKfn1q3Z8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAerALXNwfaLrVp+j7wyW4W2DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWRhZWIxNS1jMTJmLTQ4YzQtYWQ5YS00NjQ3YzhkODg3NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS68nv849515uA2lj9WSVe7+gf2goUJfUIF81vdDBhgTJ9R\n+EMaz9Wzq+CztsM9ehW/LJOJROve3/uiWalx3bIHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/vgQAgXAfPYpjMXaLDqte8Gl\nTsUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFJrDTd3r557TXftI7WiaCwPBdEOOGEo55k6mNePYAbgCIQC6SVUW3bFI\nqSe9Q5ozB02dX8ifLHu8czfi9+iWoTLXSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISASKvquVjlypDjRaDoN+m0RH6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFhMGRlM2ItNjhhNC00YTAxLWEzYjEtOWE5YjNjYzkyYWZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZhMGNlYmZi\nLWRjYzQtNGY0NS1iOWUxLTZlYjhiNzNlMWIxOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBACedIdP+FHS5mMHfCeNS0pkWOqwZGO1fx17Rmnw85Au6fj7jm6nX59\n1p6rZRWow5QATBy+4b8bxjFVnPDg2BKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBceIz5M\nkFQc3bngJgAzgrxvy3wBMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQD+nQPjb0KLDMrs8yVk1+RB7jmbJsf76Xt5ckRs\nO3w7JQIhALPGSvJtOntVUFZuarq4Ynv3cevnI2cj+WeiPugvmqNQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1184", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1184` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARW6VHgjpEYtaFA7xGrk+l3vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1ZDA4MjFjLTgyZTQtNDJiNC05ZDgwLTcxOTA1NzMyMDA0OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZlZjc0MDQtNmJh\nZS00OWUyLTk1YmYtZDI4NjMwYjE0MGQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUn2sY/jmmS/WqJko0SzUi7osAZUQy/NaCeK/8OkvPxrKQ8ybIiXIMDoquypz\nCX7B31t+DmJFbGrbCUWBemWq06OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDLn7eGyVTEP6epyxsiPPj1msxsowHwYDVR0j\nBBgwFoAU9WUREn9al8WRfsGJ8h6hmvjAiFowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAwFGdCqrxSPbqOV1NNsvJsm0o3Z7CzQ3op\nZBm6Q0iSJgIhAJiN4Kjh6ztM0OMeEXG1Tx5FzZuS2eEH0JosapSbQobX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaBpwsi1AO72a+fMO250NO4AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWQwODIxYy04MmU0LTQyYjQtOWQ4MC03MTkwNTczMjAwNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQBi+VlnxgYtsrJpn1ChlSNh9Lj+lgbn/fIqKVYP9XmLje\n4fgbgp8D4fhOH4/lVy/Z2GG3x8L/itqmVkq3R9Gwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9WUREn9al8WRfsGJ8h6hmvjA\niFowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJc2GPgt2Je1Nqc+T4W6TjC1qwFYqs0ezTgTtYNq2BIFAiEAzAkeOCxZ\nDoY2oTnRPkk0oxob8GvJTljSqKEvx5zCKug=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAQfWzBUEslbATirvMdGxRCzyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZlZjc0MDQtNmJhZS00OWUyLTk1YmYtZDI4NjMwYjE0MGQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc0MDUyYzNj\nLTQ3ZGMtNDhiYi04YTkzLTk5NjY1M2EzZTgzMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLZuU33gVUZ+I0AZ++ahNbh38J1ACd8diRGU/wl62+2ImCGDIlfBoY/j\nx7oRfbd467DfE381Jia1TQPCIJOT42GjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAy5+3hs\nlUxD+nqcsbIjz49ZrMbKMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCICxeeMiZ+PIvhXKjoQnEZ3vrgLYfE0Zsw1tQ8LEm\nqmPWAiAH/eOxzHR598KH6mNpVxn3V8r6yqacTSGa+bYD5a2Vaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1185", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1185` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZDGBtxDarrvGxfBXItX6WVYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwNTBlNjYwLWNjMGItNDM1My05YTg3LWZhOTJhZDcyODUxNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU2NDEwY2YtNTNj\nZi00MjAxLWFmNTgtMTRiMTE3MmMwOGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmFyYeJjWxM8Gwf3rI6DwLucs2occAVBRIRW7vIqaS/ulwenUwwi4Qe0fRzM6\nDmxNMUocnnvU5yBWpmxKhE6b5KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6msAKU7wrwe5NJ4uhWA+EnfmSF0wHwYDVR0j\nBBgwFoAUctIfxzciuXDMITyrHx9wO1vDeUYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA9Qwm/3dL8HOoxrL5am4Ov1cw8vsE0FRl\nIXs1IcZdj38CIBjVUVQxnWuGxFyrdWLZT3RrkZX04e2ZoUc9EJU7vhHF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUlBC9g5/mfXggqXB6IrO6zAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDUwZTY2MC1jYzBiLTQzNTMtOWE4Ny1mYTkyYWQ3Mjg1MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7AjfNVzEKKvKY/J1f6tbeHemBDinMUvIMYBoEXS0BQjHC\n9JJFZsKRf7zs+/njuhIqOsLCxcvV6XvThS2u9ZL7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUctIfxzciuXDMITyrHx9wO1vD\neUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI18yQdw06EXsrzp0nv2LjTyl0dbxfDg55qxH2RVcyO4AiBi3BLycRD5\nVB24GRvvr5cCNFDRwCVId8XOFhTXp2ld4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAfqzJqCtR5IRQMHyc7KmJtHZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU2NDEwY2YtNTNjZi00MjAxLWFmNTgtMTRiMTE3MmMwOGRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZhZTUxNWM4\nLWQ4NzUtNDVhZC05ZWUzLWM4MzU2NWIwOGYxZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL4ppCm4aWKDdk9/JjtdaAQxEElEBVgGjh564/wj4muRx+WCkbd+anju\ngrw4xiuiO7wfxh0uIZ87ojYVndu0veCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOprAClO\n8K8HuTSeLoVgPhJ35khdMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDJ5lAvRcHB2Jbhzwfw39z3uPuDtSh7JmCFXTpI\nC7mGLQIhAPBxJilhh/39Wheg5+unQYG019EiRKvhaaNuTPzocmM6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1186", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1186` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAZIxN2PPbENAPfRD0YwLo6qYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3YzcxZWQ2LTBmNDctNGRhMS05OTRmLTgzZmQ2YTJiYTVmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ1MTRlOTctNTM4\nYy00NzBiLWE4ZjEtYjcyZmE4OGQ5MGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC42U/nu5ah6jHjuPRiZaClUCD++wLIHOmcFteJ6LOuejPOTEQUqNeE3GuW3X\ngi/nO6xgu+ivOfh+/GXouzzIWKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbkLH1dW44oIj9mTdEz2cCJsKVCQwHwYDVR0j\nBBgwFoAUOko3/WYXa9bUPtTp5K3UYu7LsukwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAlaRLhQfQsTXL\nflTt6FpeFxbJhcTm+u33BUtNjsOp6x4CIQCtI74KLiI3pyzjx/7djG3kV1JGIsTr\n0jETaNiObT0vYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbbaJOynfpHaYKee2tWHGM/sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2M3MWVkNi0wZjQ3LTRkYTEtOTk0Zi04M2ZkNmEyYmE1ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrasXKTbWgFrg9eMLCd4PMyxDdVhNFHfnDxTY+9YIvp+3J\niXCFNENHkp8lPHy0pboWCSUr6zYP4lHyY8J/dh9uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOko3/WYXa9bUPtTp5K3UYu7L\nsukwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOLqcY+en1R3hb8g64ISeXAU/HpPfaK1ewXy1xg3hSgcCIQD+7y91sCLT\nHPPPmiriIaxNMcCIhCEGyjdAqbulpL/2Fw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAQse6haLP1VkS2Qn2HjKcbngMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ1MTRlOTctNTM4Yy00NzBiLWE4ZjEtYjcyZmE4OGQ5MGEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU3OTg0NWI1\nLTI0Y2YtNDZiNS1hMDM2LTcxNjMxODQwZjM4NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGPlB5LeoRCV46S9m89Voad2skVoluPZ9XEUPBZizNZziWognGpICT+m\nAWjIxCZkawySQutmWNVcUuNYe+gsJd2jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG5Cx9XV\nuOKCI/Zk3RM9nAibClQkMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIAde4ZlrU7c8+IPm4ryykWY73WjZ61pFI9WxoCye\nCXWgAiB/NqIMKRk8iImH+bU0HICG6Cwexim3TgP441M9mWMqjA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1187", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1187` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZYFLt83EvAcOXhz+8vJs28YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNTYyNDc0LWE3MWEtNDM0NC04NTU0LWVjMjJlODMwMjgxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY4Njc0YzQtOGQz\nZS00NjBkLWI0NTMtNWNlOTg1MDMyN2ZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4p2PoFTwPLmRgrKOeZRlHwrMOvBhI7qczc12jNfN5Kqts+zua9CWtoNRfLdQ\n5O6CPq8+JDd1fp8Y74+WUTJqkKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHGxMGhSmpcCvC4Wn1PQ1t8KOJUEwHwYDVR0j\nBBgwFoAUs4Wn0iX1/a+dci5Nz2dyJGRDOHUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDiR51my+O96fjSuQmV5KE9E5fqFp/Bwd1EgvQ6IPyelAiEA5FgW89E7Z0Kb\n4iC9pTruVo+ZhkBBBQOx9xv0oz63mFY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZjfdQQl+KKMsgHvFJdA8zCLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzU2MjQ3NC1hNzFhLTQzNDQtODU1NC1lYzIyZTgzMDI4MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9eyT4TOaA+ay8R6hXsTXcMBEXfE3wwmLo8iREb06YTlfK\naUJm9T2Xihz8iNzvpAwlEljfxzUeSvkfsrnydzMOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs4Wn0iX1/a+dci5Nz2dyJGRD\nOHUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgavU9Z56HyPFN3LskUjPEi/d2N0SAJPGCKcHhl2f8T5gCICb0fmNq2YkE\ncrL8xQ/vaQbr1yETHwCDr8iBUvx+5g4y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAUfBsmX1Ayk5sBopuA6PO9+aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY4Njc0YzQtOGQzZS00NjBkLWI0NTMtNWNlOTg1MDMyN2ZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDExOTQ1NzYw\nLTQyZWItNDVjYi05NTI0LWI3YWI4MjZlOTVkMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNDUHsz3hPM686nXHy38jSt9+2phrMevWeMWfiI/3xNo6i+tj0y/+DqL\nj8Xpa4/OkManW2aMEWoVV/0Kg9HiBsOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBxsTBoU\npqXArwuFp9T0NbfCjiVBMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIAQz3Hlf45iRs1LY8gGieXwTeY014rqaG2AB68eX\n+twGAiASgcyxrF0XTj7rY/tHmdqeCWXkqyVhFbnKqHoauwWndw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1188", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1188` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAb5iU5WQzm43YAOhE2U82A/gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NDhjMDJhLTkzOWUtNGNjZi1iNWMxLThhODY0YzYxYTRhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJkMzdlOTgtY2Fm\nOC00NjMwLThhYmMtZjU5ZDgxMjgwYTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEci5n+wJJhxTDrHfNm/K8NvpdDFzhXgjMLCwId3H/DxhsJnHe0u8jxTWkzx83\n93uSZIaV0LrE5Q2xYDdPomcpTqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhvCioFdelGyFtovjIqukZGuTel0wHwYDVR0j\nBBgwFoAUw4mqzc8v8CoqTry8n8r7wH3QzEMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBJ3KVVTNE8/IeuRJ3Ft40ujROmVpLRkjA4RgdnQRBnOAiAotd5Xp6weiept\nez3a+rxJF3UUOcL6RtlkXPRITtln/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASfDUNqMhyRnD4URWRVS9EHgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODQ4YzAyYS05MzllLTRjY2YtYjVjMS04YTg2NGM2MWE0YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQO0u3jlLRrhw570SCiLjD7f9TLEsijNQV58w9V2VuSeAaN\nIW2mB2D4Y76TpPlp7/4MgPtjPQZCGxosxMjVRSHBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw4mqzc8v8CoqTry8n8r7wH3Q\nzEMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOuYq0l02V0UQgd4tPlc9o38mi+Uz8NxV1//z1zV9vRkCIQDY7WHXrmXz\nIcYhpYQ/ezYoc3Ov8y7T+dt7P8UfUkr9xw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAWsmknHt0LefxVuBYM9RuXitMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJkMzdlOTgtY2FmOC00NjMwLThhYmMtZjU5ZDgxMjgwYTQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdhMmVlNjRm\nLTFmZDQtNGVmNy04YjBhLWI4ZDdhMGFhNmE2MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBm1byFpGM1eTFnt98fZQYvsrP1DIYmN3jfSOd6WeFnGkjrKR6tAPpsc\nnzu2wuywFbAGBP6RQ9loxp6trWVC6BejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIbwoqBX\nXpRshbaL4yKrpGRrk3pdMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDZLOQhMdfc/qgOhKSbeNDWcR5sawAGxv6AFwuL\nee+LQQIgbPbVKnM72LECq8/5SlZlzzHLlXpFy+GJu0uN8Rd2Ip8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1189", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1189` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAcivK5xv7JX0XA+zFhcpms9DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYmNmYTMwLWZlOTUtNDM3Ny05NTIzLWQwMmUyMzkwNjNmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM0ZWVmZWQtYTYw\nOS00NjRhLWJjNzYtNmRmNzM0NGZjNDg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzuvbGsyv6kUqqDBpjz382wEbJY9PM3hHUSXeNx7TnxX/7zxQolbjK/4hj8e6\n6S7Ss93d/o3+ODwsGRM4WrdhrKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHq6ZIWXto7yq5GbMvd7mRz9d8XQwHwYDVR0j\nBBgwFoAUt8kCJdoK/9xYsNZw3tSY7uDOCukwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAqRCuBIgSptBHBrBpmkLz6pW1w8ePFyUf7iiOaYFaXUwIgNz5eyjlJVVu8\n6spK36fxfvSmt3+sGsb3nj2cQImF4wk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfVkKARIF3X0iL178ZpIPMrKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2JjZmEzMC1mZTk1LTQzNzctOTUyMy1kMDJlMjM5MDYzZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS85xIdZx0p/OfMgMRJVplFzBGkV/7POWACr7XGynyadA4q\nfO0DasYCGswy9ptVwPi+8umVxE+1d8kZO/0m6Di0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt8kCJdoK/9xYsNZw3tSY7uDO\nCukwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOjEtwobewp7Y9Iu7a8OMdeh14Rru89g5vkO5Aug1zQ2AiB8Z1c8ibca\nkQfotp+wHIzfsWc0RY4QfMJHh3KSipsxXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAcFru8ELxwTDZDKSzuEdZjKjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM0ZWVmZWQtYTYwOS00NjRhLWJjNzYtNmRmNzM0NGZjNDg1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU2MDIxY2Yy\nLTFlZmQtNDFiZS05N2UzLWQzNGM2YTVhMTQ1ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNRgxsC8e3cPHVm028P+PFeeqlp6Weurlief3dQ1Zf9mAIn+C6tCQnb3\nlbsH75Bq153yYU/OmJcia1DcWbEYzdqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB6umSFl\n7aO8quRmzL3e5kc/XfF0MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCC9TnpHi5v3rmH3VQuVoULg2dWaDlUOwvnaLWC\nZ3KmpwIhAMLr9iVHTmGHucjIuQPBn3GwQIZrtSW2Uz71Ol2NCqqz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1190", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1190` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAQPualZfiSJXN52LnKLsaGAOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxODgyMmI5LTAzOTMtNDNkMS04ZjZhLWFlMThkNmI3ZTMwNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk4NDhhYmEtZjdh\nMi00YzMxLWEwOWMtNmQ4ZmJlNzU3ODdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMAGrHDllHdjE29jouZt19+LOygcNiuKz3wEi07qhAYHjqhEps3h+0wjrBzKh\n7FXk3Vnv1yJ3ufb4zV0sGAklM6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXW1XqQULZkKRsbprZSdKUlkA2jAwHwYDVR0j\nBBgwFoAUeMub7m1MfuMqgzzDKXWMDY+fYC0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA6wkLnmI2NHoKmzCnlP3V+elfu8bN7rsQNHEw1cdZ\n+doCIQDNerotJiHnNlI9n5hfERVejnMaBkned019KGjGyVluog==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYidwMG83LvpHUMMA/0XnMP7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTg4MjJiOS0wMzkzLTQzZDEtOGY2YS1hZTE4ZDZiN2UzMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARICuPcM4winx4embputxOSUzFPg13rvIlDYhdhnBdOBVE9\nAIhzvH4H62biQHDAXUo5CMKqd2MuZ4mHv4lRR5jWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeMub7m1MfuMqgzzDKXWMDY+f\nYC0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEkyyGbuNloQEeTFoCq5+Blmq6PriC/sjSP0CuTKwjxQCIQDvKQ7UG5pt\n+13Wv4DHr1/LjObAUveyjGUynHdvWhXNvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAa8vzxvcmfxN0yjqEtVBYqX/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk4NDhhYmEtZjdhMi00YzMxLWEwOWMtNmQ4ZmJlNzU3ODdmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI2MjAwZmQ4\nLTg1NTQtNDY4NC04NzkyLTdjZDc3NzU1NzA3MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD18h3K9PztEb4GZOttp9C6b8CKYWmSFr9CiyUS8H7wYZS4Nz+ykW14z\nnLVW9nJjIaGj9s3TCUGmHoOuQQqtwHOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF1tV6kF\nC2ZCkbG6a2UnSlJZANowMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQD2QJSbUn8wganQ7EUgHnyHzcPcJ/NiEgtPVzob\nKx13nQIhAPN/kYAvBpyFcw1zg2TMVPq/tlMIYOTZy6rxVKAgxL/n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1191", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1191` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVUAYXu9oDWCPfv3J2SXXPRbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjZGYwYmQxLWFlNDAtNGU3NC04MGE5LThlOGE5NzdhNTIwMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTIxODMyNDAtYjA0\nOC00ZDlmLWE5ODktNGVkNTY4NjgzNDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkepIyNq8ZDjBOMaOmXkUoQpHuWyWYEFLcyp4W7SaWMLT2eQMWrSTAZwGo12D\nkuzsursps17KDMiHwMFbEgMxjKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrjIb82b9tHtuw8uIXd2iBrG29mIwHwYDVR0j\nBBgwFoAUjkR1lMq6QDeDMj5Gn88StbRr6PEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA04lrrS2YekEOWx0GDmdTjioFe0FN8CqvPbMSjax5\n9PkCIEBJXSGhmsWWGkuNfYlpzQnJ7Mphqi1NYN+j6PaL4pfS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAee7aCIW+CnBiaLBZfk2yvs5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2RmMGJkMS1hZTQwLTRlNzQtODBhOS04ZThhOTc3YTUyMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJ9JPQWyRkGfkIP1EsAVrtAq/kGTiiHNdD6ZEfApa9A+kJ\nmAwSomHqhbQEE889WpDrUFa+jbovz+95QfP6I02Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjkR1lMq6QDeDMj5Gn88StbRr\n6PEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUCkDD8Q6F3rHfwmLDBf2JE+VVnUZZTIR7pIc9Rm9wcICICcsriIniPvv\n+jWE5y4pfMEtPBBpaD0wPDg9MpvGveBn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISATKRagta3Eq+0v+Xn4Gbp2QoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTIxODMyNDAtYjA0OC00ZDlmLWE5ODktNGVkNTY4NjgzNDdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU5ZTM4MGRm\nLTAzYzEtNDYwMy1hYzc4LWRiODhiNTg4N2Q2YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABClDrxzayVL8KXe6yhZWxBpNnCTFX5pNK7Zn5TfybtCUE3oCy+lCnJ1/\nd1z96IwPao1Km0NY2II64ivX31l/4NyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK4yG/Nm\n/bR7bsPLiF3dogaxtvZiMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIE4JDRc8ykOniRnq0G4YFypmc18ja1vAxP8A/dmX\nRkGaAiEAm1IMTIZDaiF5egU4dkIHTLxf3xQKm7nXEVJDYI8re/M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1192", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1192` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAbzNFVU632IIzRe+pG5BgntXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0ODcwNzgyLTk1ZDMtNDM0ZS04YjVlLTU5ZGZhYjVlOTc4NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGI0YjlmYzktYWJj\nOC00Zjg4LThhZDAtNjkzZDc0MzdiY2Q0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAzShpu9gDOGkUh9qrjRI3KJocfDSx97cHdwFi7kuLj1lK0ur4GWV2noTwRIX\njaDnbDjcBg9+FlnMcLokxMk+iqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURhM4HqAPo1nAGEC1wFS8ZcSOUQwwHwYDVR0j\nBBgwFoAUo6ihSvtg/1PwuUQYmoe4UVCG6o0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAk2xnDucYiY0fcEMbYjpKJ1hN9ZgbKpC5tk+k6G0cdHYCIQD0\nYjGnwBKA85OqAOkrLUVB/fsSf+ESwD7Ps+2n7sXj0g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaIeqg/jxoYTfjAUhY7emNKYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDg3MDc4Mi05NWQzLTQzNGUtOGI1ZS01OWRmYWI1ZTk3ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2QMJwJU74u7yQ32tilD28+Q82xXAXTSyeXHkpnK1k8Y2/\nfdZO96p30AKj42ooaUFdqGuHs/LfNxlt9fysFDXio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo6ihSvtg/1PwuUQYmoe4UVCG\n6o0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTaeXk1EX0CVYTXvXQfqmVJDUy4uCE1iCag15jnwd964CIHb7siigYNBF\nmrEPz4heu0puwoCS8qPuy6fSOfL9Gf1w\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdIDDLM9nwS/Sor5yDTmCzY+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGI0YjlmYzktYWJjOC00Zjg4LThhZDAtNjkzZDc0MzdiY2Q0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI3MDEzNGQ2\nLTFlZDQtNDkzYy05NDFlLTMwM2Y3MTUxNGI2ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKireez8ENaAoeaBbTsbp48z4nt4qCHNsGkEPq+oQLd9Rp2rNMCEzQUj\nYFGQgcdRMWc5mM54DX6W3WNWDIqGrxqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEYTOB6g\nD6NZwBhAtcBUvGXEjlEMMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIG+O27cDf1nJQqCUdxUKKcpUMxaZFdhn4PNkLZVo\niarkAiEAtZE0a79YrnN7wM/kZPB81BiwI7IzC1TDdWCL6e5nSS4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1193", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1193` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAZ3wPX5n2m9FOve4vRqAEdMLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2M2YwMzRlLWVhOWYtNDU3Yi1iNWZmLTJmMzAxYmUxMzJjNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWViMTJhZTctZGU5\nNi00NmFmLTlkYWQtYzBjOWY1OWYxMzk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPU2mCmpVGCDKhQjtrwQ7NU+hWktIBsJH+XCqH4QEMlDbP/6ogF10FdeCQwXn\n8MufimFW2j6m7HA28eENjJZOkqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUasPFinQzVEd0LX41O0HiNuWZNLcwHwYDVR0j\nBBgwFoAUtMPUjDSjc3wV75kQ3XKMVmxWoC8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAhMo0xOYzbud2FptsfVChHRn3v3/DfLHkY\n6v5NPSwrBgIgWQviz0VD80bYxmfu1ZYBVP94WpUpL7srZua2ymKL8Hg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVbY8UVfgiKJRi5B3akgvvSUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjNmMDM0ZS1lYTlmLTQ1N2ItYjVmZi0yZjMwMWJlMTMyYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQttLP1BiZZhicb3hi2hocizKnixNGe0cwFVykCRFPb5k5H\nO3ZyegoFLQZGhs9a0pypKIlTcZTnaAAouPeBYi5po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtMPUjDSjc3wV75kQ3XKMVmxW\noC8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfxhuv/p56o9V3SM2OpCCAGsMVy/2vvDfQnFf4hr7mnoCIE/C25jfIE4s\nezmOwizMGa+KBB79tvGP4tMJkQNaUNzl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAfC1kTipFD4TkJpxDapMi2pYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWViMTJhZTctZGU5Ni00NmFmLTlkYWQtYzBjOWY1OWYxMzk1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAwODVlZGNl\nLWE0YmMtNGE1ZS05Nzg1LWJmYjU4ODhhZWZjYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHIIJysSjarcTG1R/02WIvL2jcfpKKpTzTqabkxgl+TeUSB4AWhknqK1\nZ6E2OrhAmSX/B+uqqIYWIi5GyFkJoBGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGrDxYp0\nM1RHdC1+NTtB4jblmTS3MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCHw67gHcbr9tXc+h1DTbfSSfOlKo0DrPX4z+nSODI\nyM4CIQCSlARi+SWR1iNgwve7Mukx4JqpEwVpVIVRpl4uXZDJsQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1194", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1194` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAT7ZmuB6rNj+BL1v65LqnPR9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlZjU3NzJhLWRhMjQtNDFmMy04M2EzLTExZmEwNTRhY2VkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY2OThkY2ItMDVh\nNS00NTQ4LWI4MjEtYjQwYzA2ZmE1NGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE36XF+D7MmZ2icCXHCFI1Yo4skNdMMLpmdiFskmskJ2N21Cp6qMWfAcImJlvE\nZHVoWyTgsOvKKjlMPf8zz4sU2qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWCbGbT4wdIUEYS9c7ElShFWzQyQwHwYDVR0j\nBBgwFoAUZrevtd8raUwziuhLtaPq0Z69gm8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA8b3ufA9ThzsD76K53bu7vItvHsEtO5KYp\nWE4+rABJOwIhALEwpabh7SC22HVjb2XiskgqYkhKh/dliVLLze50IGdl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVv9IN/Us2NfOLLmceIngjUZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWY1NzcyYS1kYTI0LTQxZjMtODNhMy0xMWZhMDU0YWNlZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMY9wmYaq0j/624raaGXKXwXv98DebbtTxYmWRKDhztBU1\nru5cv1KN+LkewGD/nIm5B7KwkTp3rOsPy+2zlMA8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZrevtd8raUwziuhLtaPq0Z69\ngm8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZZnHNbgxsVumepN3M1gW1PPPYLuFhTHdDyFEo8klFR8CIQC2wQJ034Og\nQTac7iLhcBpEdc1vBp4tJFLR3DeocrAEfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAXUrhAfNaqNc0GQuiO/4oagQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY2OThkY2ItMDVhNS00NTQ4LWI4MjEtYjQwYzA2ZmE1NGY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE1NWRiNGZl\nLTg3MDEtNDM5YS05ZDU2LWQ1N2JjZmE5NGU1NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIUpPxGPUucuGtGCyYsF37seBSb3rdO0aWibZ2+o4IVF+30EPgdX5D1S\ngHyE77sNou/mFQEfiDEjfdih+erEW02jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFgmxm0+\nMHSFBGEvXOxJUoRVs0MkMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCosnVkNSGcj65vpjPciV2fExCOfW7tgtd/894k\n/ztcGgIhAOViQFKr6aL2ef15TuWmMSylObmEmgt7vOlcPdakxyQ8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1195", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1195` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfrRv6ZRyrIowi73F8+YDhoGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiZjg4ZmIyLWQwNzUtNGZiYS1hNzM5LWEzODg0ZTYwYTMyNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFiZGZjMTMtYjhi\nNS00ZmE4LWJmODAtNjg3NGQ1YzJmMjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4UKrdla2Q7K0pDymCuxWqqwojyxECCY58rCHG1C19b3AB3hAFxG/xlMNkWc3\na15/3c9Si+YdOnMyvuvwsiAmcqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwXalS6u/5VO5WXcUOAQw3ChbdB4wHwYDVR0j\nBBgwFoAU+c4fk8OFGuPUdepuA4tFi8doTU4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDa8OFlrHP2RCt/2vy3Xjj72c6X\n0cE9Oy9WTiz22zbaiAIgJaFSejQ2Rcdwa0bjb3KxeVDVnRaYqM3AMskIY+w2edM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASY1+5Tn8h/XbfjPDDtTaIFCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmY4OGZiMi1kMDc1LTRmYmEtYTczOS1hMzg4NGU2MGEzMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEwLUdouNz3WHNYhsTH246e61K5poA5p/MVfNMM4VfeMOt\nnqnbwvrFVJ1WEIVi3kabAenNclkNo8wC7DaE9b8Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+c4fk8OFGuPUdepuA4tFi8do\nTU4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKsQYEuFZyC9pBKtEcnbiPxkE80cHoChWv/lnd6on7TTAiAwhq8qNPzC\ndUXsQT5Sq4gIzxVyKhyRDMOVCBHC/UX2hA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISARkvNRUD66gap+bC6s22OruoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFiZGZjMTMtYjhiNS00ZmE4LWJmODAtNjg3NGQ1YzJmMjFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY5ZDYzMWFj\nLTJjYmItNDZlNy1hNDM0LTM5MmM2NmJkOTJiODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI04yZa375ivHRpaocLVX6RY13lop1L710crXZ4V3Bm16J9wXW9mBb1C\nVKB/Qojz22CT9cjd4Gcxoi8+074Vwd+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMF2pUur\nv+VTuVl3FDgEMNwoW3QeMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIB4XGA00zJG1mwPq6510ZoI7n98NQyMk6aKRjB3b\nNwVZAiAXySPL6M3CGXNFHU16wjd7VSMKMJ/NAr62B7kHsH63qg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1196", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1196` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAe6Xw69EquPC9Dm8YCcPe9SmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhMmQ1NmMzLTk0ZjEtNDQxZC04OGMyLWMzZjc0MzNhMWZkNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJiYzRkNTQtMTc1\nYi00YzQ3LWI3NjQtOTdmZmZlOGI5MmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK9HkEi5gZpYRqf9ra+OUQmrMHI+lgJSW0WWIL/BrtK54lVgxDOO8y+Tyb8KS\nbjDYHINIVP0VPaYMHoKPH5mvM6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdwO5uWnIj+QOHVq8r8kWbFyPyO0wHwYDVR0j\nBBgwFoAUJ3VBcWxSwtm8qowyym/gzvrvMpUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANfj+VXc\nrOEsQVoXIdGmB8YqzqyKuO9lfhD0tsYS3UJ0AiEA9A02X2hdSiUPCNWFj1VPLk56\nawTCwoTQhXSxfKiBZvY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdIQbNI+EXllLUGyxOrYMbz6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTJkNTZjMy05NGYxLTQ0MWQtODhjMi1jM2Y3NDMzYTFmZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASh+JCxrnrSd9MRMyjgMbM2357Tf8TBDymmW/vPEGlpAfxk\nzpBUzrTP9aZ4/bHza9zpKjo4j6JjaMkgDYDts9dFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ3VBcWxSwtm8qowyym/gzvrv\nMpUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOVR1z2Ny3cDpqQFxncEwN4wI9h/pECMDxpUXXZrxmWgCIAlVT+zuPWPh\n9zOpmWoVEoM74zLtxMopwH4l79p6hxea\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAYqW6m0KYBF6ABsBXhtmumgUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJiYzRkNTQtMTc1Yi00YzQ3LWI3NjQtOTdmZmZlOGI5MmJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE5NTkwY2Uy\nLWM4MmEtNGFjYS1hZTIxLThjZmRkMzdkNzVmZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAtc/9xz5sN15/iZgRYnCxnEtbbd47fYTmVSna74vMvtRq88m+LUX66D\nppGFzbDwe/d4LrMCcahLclsxRkjPpRujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHcDublp\nyI/kDh1avK/JFmxcj8jtMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQC1jvbf1et4u2bGEShq30lP3vCyKGFJNz2fsCMa\nVFnKTAIhAMgYF+4u14zH6YxW0qEDmRpMCCdhzgYJw4xaJel1cUBq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1197", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1197` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAeOn2zEZGTAt967l3aXd3LZXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3Nzc5NmEzLTdiYzctNDk5ZC05MjY4LTkzNDNkYmE1YjViZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjlkYjYzYzktM2Q0\nNS00MTE2LWIyZjEtYTk1OTQ3NmY5ODY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENETg3lS6a0sJnmuxuWDZFZUTuIQRD6gVzCYv3QyxUmt9odvBF/GyOdBeCa2G\n9XNXXeY6MPfEO+z7TJkqwHGqdKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkXAQm/+msf/E8mviEJkEwLjdriIwHwYDVR0j\nBBgwFoAUZgV0mxxwNTW+pHsMz+FYL2BVdhwwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgJyDyd9Ne\nT9XEmZ+0MUw3hi32qcZo6LfHM5T7vb/8tcUCIGaIki3jXbDQSiQxa8gb/ShhHEE/\nODSTNEaBKDCvm8pd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAabuh4tM4gQEJA8knRo6lvnrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzc3OTZhMy03YmM3LTQ5OWQtOTI2OC05MzQzZGJhNWI1YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8UD9V08QQqFxZ5qyWOuLKsgwaJs62BLXcZruucRBfKb2I\nKOwApBOtLcpOhpKwYE4AiNBnswK98ZahP3Mrjog1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZgV0mxxwNTW+pHsMz+FYL2BV\ndhwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTO7uMEARu0koOT2/X0m9xCohIzAV/LzbSf4TFm8ZgBUCIQCEpl5AMmMB\nYoUY61zxQCHxbQxmdTVvrCLaXpMU0Lhh2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAdsillsi9m36neonAOUeDcDZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjlkYjYzYzktM2Q0NS00MTE2LWIyZjEtYTk1OTQ3NmY5ODY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIwMzM4NmI3\nLWU4MDItNGQyNy1iZWQ2LTg5MjE4YWYxMzJiOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKBAEw1ZL7iGbevVI57WJ/BnYkks5pgkPyKoDgoZXT3tCRCKeu01yxR/\nrhH2urs07gOVsLpCqH7sG8p/TOT5Ct+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJFwEJv/\nprH/xPJr4hCZBMC43a4iMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIDOu7EgiS/EHrWzhdD4q64tI5OE+FMuBmAe8Vm7u\nZ/6nAiBd2UjWubzEF+TP2e6CRpNF0Y7zwHFRFbX9gREKCZgUTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1198", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1198` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAQcXdFBlP4O4SJoRHjoF1THCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlOWQ0YjdiLTQ5NmEtNDYwMy1iODcwLTg3YTMxYmJmZGNjZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZiOWZhZWEtZmQ2\nNy00MWE1LTg2OWItMGNjNTM2NWZiZmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH2ep09PW1AUMALVZVVdbxPpSW7weFp4meWSK0ys6/IWhkjYfue2XgZ2XIM7d\ns6DYDalcy71EKFtbRraIRt7pOaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvihMUorlPRDL4aTtJnswqBnkhqowHwYDVR0j\nBBgwFoAUPBfVf/p/cW74+fmxLrJtYa1eUDIwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICHV4dRm\nhF327NF7EISuOZ3kAEg/0CrAuAT4QJqTMgZLAiEA0oJqASW3ErumPBWzmIgDXkJ7\niXdn4OJlp5fLvlBG3fk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATQsH1EjKlyTn3vUVy8FUV20MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTlkNGI3Yi00OTZhLTQ2MDMtYjg3MC04N2EzMWJiZmRjY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1XbIXwkNCwNaWigbpBCFGY/LOiLK8JlHumlsJFwGaTQwV\naWh+2FGmgC0kUYcO8MFWEhWK7nSg6kvpvRTwqkKoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPBfVf/p/cW74+fmxLrJtYa1e\nUDIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP81nCYWbeTOrcBqEyQvKGu5gMk7Qm8E/pxQiBRdIgPzAiAB7Z28ylx8\nMYJ0pykw2qyehWKLNYHZ6R4v5zKEFqplIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAW3zCuj9JDscedAxtWrqqhLDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZiOWZhZWEtZmQ2Ny00MWE1LTg2OWItMGNjNTM2NWZiZmQ2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNlMTE3MGUy\nLWViMTQtNDNiZC05M2NiLWVmMTA2ZTAxNjVlMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLuq/Y/Jc/+/OnpJThOfdWXmVlViGBab7E9r++QdxQ6J+hZLlpCP/6ur\nJGgRPZZMgR2eXF7S2+XArAApyt27x1ijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL4oTFKK\n5T0Qy+Gk7SZ7MKgZ5IaqMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIDr3l496yz2Peu3CUngehzj1/yClsu0j6TuMHfet\nXvp+AiEA8OPgnZIkRmG14k0elY0cvPbngNuEVEaKW+DhTPjJbK8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1199", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1199` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAScZ8JSPNX+V9cXMokY/ipcFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNjM4NjQ4LThlYmYtNGRjNy04NzU5LTc2YTVmOGQ5YTNmNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmYyYmUyZmItOTQx\nNi00YjY4LTg2MWYtOTlhMDljYTFiYTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFLJicM1h9PuQUAoDm61Jk1TKcessAXcRDXTNK2YLh4IpKi/DrDt5P2ATfFx6\ncr37OPcaCltibg/yzdOorP5McaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbQuNdVasbW9QY8WVgXBp/vglv8UwHwYDVR0j\nBBgwFoAUxRa7+bUqHa0qIeGL5S5Gf2TKIBcwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQC7I8ui2/XVubcnlJdEDN5x1nzhXsJRCgt/aM4/TExSzwIhAM7wU2zl\nVw3Z/2LjHo3QNpk9Y+qzf1gMGR+j1pk4QzwI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARTY0mz/P2D6a8yoCZDkdTKkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTYzODY0OC04ZWJmLTRkYzctODc1OS03NmE1ZjhkOWEzZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4Gakaly+3AzZb6OHFNT+cm5Gp4v2xR9t1R81mic9Ghysh\ndRz2F68a5HjCYgFFibz9n3MZoDaTxS88i4TEWUHDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxRa7+bUqHa0qIeGL5S5Gf2TK\nIBcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP3F04Mt+RbKq4o5tlFM2fqALGoAKGCNJTM1+pJm9UEcAiEAwbaqhTMa\nxoQRij4boSo12dOeelXBK1rngrYCyhIEYxY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAenfzVn33lNve821LiuKUh23MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmYyYmUyZmItOTQxNi00YjY4LTg2MWYtOTlhMDljYTFiYTZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFlYmRhM2Vh\nLTFiYzgtNDg3MS1iZDFiLWU5MDgxNjhiYWMxZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE+P1RcTchYFefEj1HjYh1gab4luSLzMJvW6UrmgYfoWjjAVguFINy5a\nkR8hP9M0rZjlqQwNVTClOAtrfNoSrpCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG0LjXVW\nrG1vUGPFlYFwaf74Jb/FMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIHs2HSbBWv1ffBviesC2ajo8rzIfi6U060QL062U\nzBgYAiEA3PolwuErGwnpBKUmz4KWwZeNKeFwAO5ReI5u36LE51M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1200", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1200` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAQb/EEoqzEtRiKrFftk1pBdYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMzIyMDZiLWYwNzYtNDE3OC04MWRhLTA3ZTY2Mjg4MTlhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJkMzNiZjYtNjdm\nZS00MDdmLTkwYjktMzRhOTJhZmZjOGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmZUtE4lNl/fCpbh8wGVA92VRlMHnTHwY7sZV3cmEwdhxROCmjWnVpc5kAWyV\noGDTg3ElPH5cKXdoujxytukGc6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeJL1iCR17CxogHI69TsTJNi3GScwHwYDVR0j\nBBgwFoAUzRKjXoHHU8yBJ8hus/hdQ5Bv4JwwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCDnJzwCwgeXRnGcTezwVH+Bdb/jcMFsu73J8GwH36zJAIhALb5Q91c\ndyhXkVM3ZbRTIIhBcYMGaY0akYWDPG0zfnls\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASQ+qi9bZzXeJsMyT+s39F1fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjMyMjA2Yi1mMDc2LTQxNzgtODFkYS0wN2U2NjI4ODE5YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiinK+bxUiYJv+Ubjv1+Xq8y1yoAd71WTZSflOyO9RguPh\nlDcQUnKGYPzT395ozPdktOI9sS/cPlW4wectYULmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzRKjXoHHU8yBJ8hus/hdQ5Bv\n4JwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKx1wSBqlcf8eU/aXeLbacYeFyS+bfHf+KzUQoecdzDzAiAYXeB3ZaMR\n5h/gV8Z1i0oE80TBiamzzCaYcj7sO/ETvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAcu5acE/HGNl+Gb56m0f4UXXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJkMzNiZjYtNjdmZS00MDdmLTkwYjktMzRhOTJhZmZjOGZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM2ODlkYTNh\nLTAxYmQtNGU2NC05NjVhLTVmZTAzZGRjODc0YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA7vtCv7vRVB8c6EZtzxbPsbMbljW9n6UyVeuAGQikaTxIhdNGpgQPGo\n3jTDBVZwa7S5VloGcmQBk5Ps8d/SlDqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHiS9Ygk\ndewsaIByOvU7EyTYtxknMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIDqa+Nr8ilGFp5JqkXDHeaxuRHQ0Gk7UcA/7w57A\nq6l+AiAOdJ0KN4/tKpEBNESsNTVX+BgvgV+IONiitrV4WS6EAQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1201", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1201` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAT2qtEtyKN/njEvyz4gg3wF0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmNDljNjkxLWNjYjgtNDg4Ni1hOWIxLWJlNmU5NTFkYmJiNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc1OGIwN2QtODMx\nOS00ZWNlLTg4OGQtMjc0MmRhYTQ5NzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVQ0AwJJIEtGDaYGA+Mt5YjU97+0SZXiiJ7wqHQ514RiaCGscrmOVo9pUNu8w\nm988REts92MYVaVsbc3FVnKKOaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE9hmS6XD1Khl6lrU490GvNhaDgwwHwYDVR0j\nBBgwFoAU4DIImUg1CdoFonzCJ0CFYuWo+YcwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIA+lTvxdVb8j0QwMmJr8nq/FuIhwmb4bN4YbO7S7z/FnAiEAxKL9GBKX4J+zoT2c\nR5EBw6eDqQ9pX9dnJoKCs/YvB2g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATqsGfmDUhgcY8XMGdHw1oUkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjQ5YzY5MS1jY2I4LTQ4ODYtYTliMS1iZTZlOTUxZGJiYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYjwxHn9svHi1YxO8O6wA0V/2FPbYAng8h1p13pzgmzOQs\nYX1iuIyC0rilVkXNrlCBhOAy2oT5qPfM9KQYVij4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4DIImUg1CdoFonzCJ0CFYuWo\n+YcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB9lhUO2e1PQcQ/ciVZHZ1gpYCaDG4ppdU3QDir02b/UCIQDDEJnlLV9Z\naZfLUns3LFsY8ws+O3A9bB36+bgHt0h3bA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAfgYIxitZRucYDnvbM7/KsN0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc1OGIwN2QtODMxOS00ZWNlLTg4OGQtMjc0MmRhYTQ5NzZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI2ZjdiMGU5\nLWNlM2YtNDAxMi05Mjk4LTY2NWYzMmIyOGRkYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMi89g0kt4DIF9nHokxtQrxLK3zs3yf5ReDONDBb5JB4mc15tu+FUUmS\n0G+4J5GO1XWUi1VbuDUtWxqy37njSvajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBPYZkul\nw9SoZepa1OPdBrzYWg4MMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDPdmEeMG7hxKmjyN11PNijKkZ9oLHxK3I/JM4z\nSZqtWAIhANUFcXJjpLXdYcIUz36jSHP/HtU937/U4ivkTiFBQz69\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1202", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1202` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZGJHRehQwreIBYX4TFkFo0wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4ODcxYTMyLTc0MGEtNDBiMC1hZmRkLTE0NTIzN2MzODllYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDUxZjAzZjgtMWJi\nYy00MDM3LTg2OWItZmVlM2YwYzgxYWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0gO2L1h+MbFUtjq4FZG5aHp2buXj/LnLaMcnKTwEeajbFSTE/5FiapOob8oN\nfeFHJbczos77FEKnZ7pLjZTzTaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZYZBX3VoG13ryt8/HxXDDpnWXFswHwYDVR0j\nBBgwFoAUmFTnUCs6kEt6vRLs49ssDYoyddMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDVXcnVi3x7uDUyut/0hgssCpW6NN7HYmTmD716G/fkYwIg\nO8lh119ZDwqsZ6CTtx6WKPpkRyf+oc8RF1qbBpiwX7U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVExqxYUuHs56HkO5yt/rVQKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODg3MWEzMi03NDBhLTQwYjAtYWZkZC0xNDUyMzdjMzg5ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1CJQjqKPeojSU2STsrFlbyt+BUNSAry54sV6hEsaZ27/S\n4AXUb5QLR5bfDeVQCk0Ri3zFs1oR0zsvJx1TTCdUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmFTnUCs6kEt6vRLs49ssDYoy\nddMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKpNJjbDF+IjcvjEJBBocxY5ZE3Hv2mVHDiTzaSwz2eQCIBGnwMyjY2z/\nDN1dYuCgvVVWz+NqJcskSRaXdcGTo5s5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAWIQdaK9ZkOZ7qs80xIZGVxkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDUxZjAzZjgtMWJiYy00MDM3LTg2OWItZmVlM2YwYzgxYWQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVjY2ZhYTlj\nLWUyNDktNDA3ZS1hMjQ3LWM5YTkyZThhN2Y1MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK0OFvVczA1QeZZlxDsHYR4/GxiWjDXLzOsgFlAaqtDYmMCVQPdhS1jE\nJIXNwxBh51oCPrF6OXqphTyZmO3tITijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGWGQV91\naBtd68rfPx8Vww6Z1lxbMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQC6aqTAkvMrcryUocNAUY7kzocuyGLz4+f1yHro\nG1uEXQIgaAWaFyg/YN6OTcp44rC3v+VbDO6ouNNKuaFF/y0ux/g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1203", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1203` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAQh/uxigpaIj7UMrVIgaKuwHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5NDkyMWM5LWZkYmItNGY2Yy1hYTJiLWIwYzZiNjE5MjI2YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRmMTEwZjUtNDY4\nNi00MmVmLTgxOWItMjAxYzc2M2Q2MDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5TIt237KGVi3IXG1JIFUHpTnbWFuStDe/WsExyQ/kP5tf0sB21BusOPULPvn\nljeOPHg6SC2+Uu3sQJyl/AxK/qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS2JQTolDDP1Ll0KaUQ1rs4lpY54wHwYDVR0j\nBBgwFoAUBaq8oaaaD5+epW4OZEGdlO7VBykwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIBpGciRLfv9TLJEpoUWQBdOnoUJ0DSPtCzGmyspwI9SWAiAz\nZB9VhXdqM8SFi8FFiceZLymh02Waenz31Hwk+UtU2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVSWSpyEkgpeaeCbI4qlI13uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTQ5MjFjOS1mZGJiLTRmNmMtYWEyYi1iMGM2YjYxOTIyNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5D12dzHZl3JZ9sKhaKCMs+Kn58cdR4a7NZqfOr0Bj8fpU\n5uMB1b6ol1rZwawFBkvnDJUobsCXiRYWK2cJX8JTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBaq8oaaaD5+epW4OZEGdlO7V\nBykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKODwRCl8L99dffAOAXH16yNw1hT2MrdGfvlEVMThFIqAiEA/qU967BC\nYkm03gjKaW5fEMHMREjcJs11LUZqSZJDvsU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAaXdGCh85QbX0EocPOWYXnjzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRmMTEwZjUtNDY4Ni00MmVmLTgxOWItMjAxYzc2M2Q2MDA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ3MTIxMTc1\nLWExYjEtNGZjZC1hNzg0LTAyZmY0N2U3MTMzMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC/7QR53xYtMV81EfGTOKKPKdxSHvFNODXEZARxk96Ey5MWJ5bDHt6/4\n8SH2iUZAXinWZJFpFVFSE3p7U4SHPO+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEtiUE6J\nQwz9S5dCmlENa7OJaWOeMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIGFuBZ8rHIVcH7xaH+4XUp5W4rnnk2ydX53OsHKQ\nQu1/AiEAyT3gC4VctsgupgGVykDDGheBznS/QeH3D4jefpGxv5s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1204", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1204` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAV7XO+RKwmVbwFpj9WA4YIfrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmM2E4OWMwLWE5OTctNGZlMi1hMjIwLTVmYzMxYTU3MjJkZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJmMTc3YmEtOTll\nYS00ZmNiLTk5OWItZDUzMzBhN2M1ZTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9lRgMqxXLkk91JTwMS8dzZO/XbAFv4dtOvLWpgVj8uurNOG7t+gIiE/PSiXF\ndVRuMkydfelcM6iTLxxrhaTzTqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Hajsyy8JTniXOmh0hgb2bruLKMwHwYDVR0j\nBBgwFoAUhu/rD0E5ZQlD7RynnpgzOA5LlwkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDSW2kpkzRA\n7wzlJyfCEHi8VLgVxXUvmG29DcbK7bvTOwIhAKIeX5CW9QdhatPl83BOQVie/yX1\nfXpMKKjemgBycqrn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdHEIniCbgCz3SAZBcxgLTsUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjNhODljMC1hOTk3LTRmZTItYTIyMC01ZmMzMWE1NzIyZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASB0Np8FB0HjY6MFoNOGvam7d6Go7i/GeNDMNG1aqQt90AI\nGPSRD/THlkkzgHyndyXTPNuDhdRlmGfuDLNNBfr6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhu/rD0E5ZQlD7RynnpgzOA5L\nlwkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJkknCQ4S5xDlHcsIM1xWeIcu/m8qwIT0PSdZaUCixbDAiEA5EPsN/YT\nEdAzrBWcjKfX4Dxre/bUFRXWh3vGzZGr7N0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAZ8HM5NlyLp/KRBjEROVTGzRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJmMTc3YmEtOTllYS00ZmNiLTk5OWItZDUzMzBhN2M1ZTIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE3NjQwY2Qx\nLTA2OTAtNDU5NS1iOTY3LTRlOTJjM2NkYTFkMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMYR2lCvKtbt5edU7Ff0ltB2u4rvCv8MXM+zfEJKQiQ0RPtwe14y8rf7\nnTe6ewwfJOc90Kua5IaX1Mb5JlAnDsejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPx2o7Ms\nvCU54lzpodIYG9m67iyjMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIALcwlPjqywK4+/87xkMu2/Rjdg0MUtdVYpkP8pt\n8wGXAiEAuMWiz+SaUOX6NInvQxrvz4TsVQJCbRGvDpb84pQdhBw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1205", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1205` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQimVKoupa+9fcs2JjPFPCQiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NWRjNmUxLTI0ZGEtNDIzMC1iM2MzLWIzMzJhMWNlODMyYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRlYWJmMGItNTM5\nNi00ZTc3LWIzYTgtMDEwNjQxY2VlMWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh3bKtqLmfyqxc23gUv0+Ask+YN7DznISMyxwTAftv6Xo1SBPvX5Nntn5Ok94\nKNbC2lbi/VErGGOkm1Sk2mpkk6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdl5/M0ytnZW+PY9mN7rfSf6p9jwwHwYDVR0j\nBBgwFoAUVgAydVvwEiCf3zQL8m7RknnOGTwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANx6HtwdDHgYZgTF9fsRZq/HxLp4S7CbdHZ49gf+Z/cMAiAKPcGzhAxT\nYL1fOOXGhJvS9iRqNcIFmpbOi3aZNxTA6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYkGdcO7VWUZzgL6AfWHzFPOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTVkYzZlMS0yNGRhLTQyMzAtYjNjMy1iMzMyYTFjZTgzMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpBAXpmXuNvG4x+HcDMkbYY0FTkoYqExkwW9EDdTt2RwgR\npr9c71GXZBjc970TK/I3JIfOUSU9ATgqZ8LyuOwQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVgAydVvwEiCf3zQL8m7RknnO\nGTwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK9JBQKJHCodjAf3MGTfkgk5X4GoAAsUHE91cswDqQ+DAiB5ZGWQZG4U\n3WeP3luHJzQE0DuHdxDHU/H3XB8Io0kcQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAcihrJxj0LlBb9aF+083WuxIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRlYWJmMGItNTM5Ni00ZTc3LWIzYTgtMDEwNjQxY2VlMWFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJkZDUwNzlm\nLTcxNWEtNGZhMi1iMjEyLWFjZGZkOTE4ZTllZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGgUrQxNptZx//XaQ2jLolCy+yD3AvYxnWIsWqlu7NjRP6OFmIeNAort\nvLGwXh8Hh1u7BdS/UWM5XBOHFaYIzNOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHZefzNM\nrZ2Vvj2PZje630n+qfY8MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDmpuUA3G/dKrt2FlIyifQFuQi7SpjPB641hsBN\n7nv9HQIhALD1L+ZPjFL6QQhJJeSiwnbVt+VS6BJCOX84tWiCVogb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1206", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1206` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAcSMvT2VR/QCkB7aVqDcIFoTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlZmUzZjRmLThkM2MtNGRjMC05ZTAwLWQ5MjEwYjVmMzI1ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgzMWZjZTAtMDJh\nYy00NTFiLWFiOTItZmIzNzAyMWRmNGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbOoLpQswnT4gHfuVATOeZ/g4NGi2FkBFD1HqAoFqUSEAg+STF8n0heWUG84Q\nnuuFC/laMsQC3kuarTGIcYPfaqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU76E7W/OceHV+05ec94mkxbjkuL4wHwYDVR0j\nBBgwFoAU/YIGqfGcKhICWn8ANHmXh2ZPMnkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIhANCEg8REijgJt2+MgkirxQ+mWMQcc35qrlD77FNWrq9hAh9FnlZpbNUM\n5986yA9L0JC9zMSLem+jMvaDrC2o/Fsr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAexUAxRwHWrZAEUSU4YwXfrbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWZlM2Y0Zi04ZDNjLTRkYzAtOWUwMC1kOTIxMGI1ZjMyNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjY9vpljN05kUk+ThLWH/ToCWhkSxr8HnBry329p8SXFI9\n0BkKkpUjNpOy/c767TBiJeqtcZw3HJyDDJPmi8k2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/YIGqfGcKhICWn8ANHmXh2ZP\nMnkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMNenlng6/V3ny37iTRpZkGTua3T/0MXG2LGvDSpYoX6AiBxp2oIldwc\nnfqbu2P6GDMoKew16mvUpgi5PIBTpTsm3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAeLCH4Xh667CicjwMlLws9x+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgzMWZjZTAtMDJhYy00NTFiLWFiOTItZmIzNzAyMWRmNGJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM0ZDNiMzk3\nLTc0MTEtNGEzZi1iYjRkLWFmZGMyZjZiMTcxYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKAVRNTFdL2GPHYFKy8GaJFQHr2j5ICVdqaaQZD6aVp2nggC1xfrx6ZU\nqgmzU8+XgyPiKxaHzVl1k9MhZCol/7yjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO+hO1vz\nnHh1ftOXnPeJpMW45Li+MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCICMvaIPmmh6W+640WAUvjVoIVYy3ZnfFmEQdXwC1\nn1+VAiEAuJEQSkcXHDWjim3ouR8oSL0OZS0TlIsZmkofw/dzGME=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1207", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1207` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQH7AV2TGYTPcm/UsGR+0jAqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmYmFiYTE0LTZhMTctNDE3OC1hNTU4LWNlZDI1ZjBlMjQ0NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRiNmE1NGUtMjQ0\nNC00NWZmLTg0NGQtNzA0ZTk2MTUzMTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAqpzGCpoEg+fBAZGrCAKJIPCYHx27n1zeQftPl0+feZzn+aGpfmxBc9kgaGl\ntOHBLfhzOKseumdHVCMWrTzz96OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYD3q1jqrKrzK8JiMP+VIjAb3SJMwHwYDVR0j\nBBgwFoAUi1F7sTnUnYCGaRVROpIlJGj+IskwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIH1iVEgUbnJ4d8uKOkuFppcQJi5gz1vYS+HBLUtP95wrAiEAy+JNNygQ\nAsxlMHvXr+acmcB2Ui1zSMJOzYRzlQCnVn4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbRDONv5PBN6JsmVZExFAqnnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmJhYmExNC02YTE3LTQxNzgtYTU1OC1jZWQyNWYwZTI0NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWBapP8SJoU38txZ6sgKOlTAZIbEFlCrX/xspAbDmhQp5X\nnwcLvIux7h+LjdLTeXDJC4hxdE1Y3o/oDbfpF2q1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi1F7sTnUnYCGaRVROpIlJGj+\nIskwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTouL/73WIBtvCRhrdPo2g8g4l6gLuatdl9BVeiyM/nwCIQD3ddTfcWOc\nASnkHmjKM3fp3WZ6Og5ZbWlN51c/002i1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAUeXYNnYTYpVppzgZeOxgG/LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRiNmE1NGUtMjQ0NC00NWZmLTg0NGQtNzA0ZTk2MTUzMTE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVjODJmMjU5\nLTYyMzktNGNjOC05NGMyLTU3YjVlZjliNGQyOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPN+sr71Y2ILffUDZuFNy4s/rJQonQXxRnfxd4snw0aImDopov8B93Qs\np7ty09m7xTP/oNfnP8zIPcmirajVMIqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGA96tY6\nqyq8yvCYjD/lSIwG90iTMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIBQ4gj7WbGeoWnp25JshhT9RBHN3tOmNfpGiYhnB\ntU7AAiAd380ukIYgDrrDWekRYMXTJVxegCNekhu1Us+HJi8w4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1208", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1208` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAapapQ5NEKSBoqm2UzZfbeKNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2M2MxMmUyLTZiZDYtNDdhYi05ZGMyLTU2ZDM0YzRlMDM5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzljYzEyMTAtZTMx\nZC00Mjc0LTg4OGMtMGExMDE0MGYxMjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy6HHwOFlIDj5OOS50siCNv5c+6eOEKfHfuFUZthpw6SccscfyTvaw1DzpGYc\nHk3/kRIDc0PM4JTl0uQ1dbT4dqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhzTLMDQ72Y0GoUILvuGB6/9856UwHwYDVR0j\nBBgwFoAUZJ9dsiVfRFdeM3QhnBs49rRvS6swRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIAz5wSUprevMhFhn/1UHo7bI8zgWQoWqRMuwnMQ0\nZ/yqAiEA7MMKjrAbsg9HRSKp1pGYsCOTxjzLXJCsXyHy1ujNcpM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAePSoKnKE1u39+8dZ5U3anIlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjNjMTJlMi02YmQ2LTQ3YWItOWRjMi01NmQzNGM0ZTAzOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARM1yYWoNOyKHNCY1J7lWzXSNaik3RG/ABLCZfGHd+/oyBn\n2ZjCRZVXdNFr8FIN0xYZB8gbj54uQXiaD/9inRhLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZJ9dsiVfRFdeM3QhnBs49rRv\nS6swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQbmtUVHa7E6e9PHE8NPvCNku5/HFO8sliWqkW28IXYkCIQDkMSGa6xCb\n0Bx3s0VCmlz2rbBbZo5/BhH5UmMyGhXL0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAT+oJVKbp0fc5XPbnXBmFNfGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzljYzEyMTAtZTMxZC00Mjc0LTg4OGMtMGExMDE0MGYxMjA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5OTM4ZWE0\nLWM5ZjEtNGI0Mi1hZTViLTY3NDMyMWMyZWRhZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLnJrqxMqz2INCgjXdRBuS8/CCTM9cjSl3oqmILivguGszTx7HN+6HS4\nMPeJE5ouCNllXVGgRXY+3VK7jlw/kYujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIc0yzA0\nO9mNBqFCC77hgev/fOelMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDGtRdKfUkSi6Z+JSePEP9GUiAUhOo436QBX5of\nmIdhlQIgVxaPCd8D1TzcPICWEVI488NpTuFkZ5QXZgQbgNfQZl8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1209", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1209` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAWCZo0gfIXbvDF7QQ+GdEsYoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5ZmFlYzdmLWM5ODMtNDkxYy1iZmYxLTZjMjg5NWZkNjBkMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA5YzJiZWItNTFj\nYS00OTYwLThhYzgtZTk4YzRiMjI2NjQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2JeMaaK/3XPgEGb0KUwMDSsmk7H9ulFEUiLs1euGKHeCeOjibWzfbhxNAjIM\nUO61a71Om5+UIZzLXac8sKVaj6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx6IK4nG4AnLrtTpTqidDlmHlDAcwHwYDVR0j\nBBgwFoAU0lmxDA6iOBZK1NoZW3TagWNNRVIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCsp18LeZ5YeunAn+nuM896+jcuv6SMeTMebzOd\n7I1q+gIgY4naRXTvLH6yP5QYSBZjyR/C3PhgxetzT90/k0416lM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQhmbQaAcTVP54ZWPNvgyMBKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWZhZWM3Zi1jOTgzLTQ5MWMtYmZmMS02YzI4OTVmZDYwZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJYRmnQ8aJ6MW2ablkuylOe7FDy4CNs7Q5OVpHTUtaRB4u\nbcRa3uItgOEXRwjM1rvp9EFh+uhXLT01fHyILPUDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0lmxDA6iOBZK1NoZW3TagWNN\nRVIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP1+g5w9pGOEHfQwBtRTVJ8py3G9bJGGmC6KcjGGlUlrAiEA+Rv56O7o\nJ17Z7WmCntFubUU9VYd13ZCnIGt3oY9lVOk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAa4tbd7EOn6P2UXKJu4ym3IQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA5YzJiZWItNTFjYS00OTYwLThhYzgtZTk4YzRiMjI2NjQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIxYmJhNzUy\nLWM3YzMtNDVlNC05M2IxLTk1MzY5NjIyZDMyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLpV1kyFGwhR3dwK7FsWmnMa/21aIZvhzLbzS+l4EIjvznjfUqawC5Lt\nM3mRsOgdxegEN7H26ON/67i+I6B6E0WjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMeiCuJx\nuAJy67U6U6onQ5Zh5QwHMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCGzL7WXinMEsxQEm46LioH71/upTKGPMGiIsEc\nAbsmZAIhAL9Te1NFt2hMvXwjf8gmuW/uhTZdHuRNxzF4sl4KnPJb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1210", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1210` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAUhcXBnivvFHSPmpL3gvO5yUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZmUxNDM4LTFkMmItNDVlNi04YjRhLTRkOTQ3NzgwNTBjMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTEzOGJmNWYtZGVj\nNS00MzljLTg5NmItYmNkMmQzMWJiN2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/D1zLV1Fy0IAiJ+6xzfBqTJprcXKmWLryGx3NTaOTeIYjsVRAXMW69j5hXJh\nhe4fUAQUDap02W2IF3/BFjUhn6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgUiQcR602B4PSHQb3ypYqub2CGEwHwYDVR0j\nBBgwFoAUczxNS2LurYlXadDh/sDdLpEHOSkwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCsPA2WLF9rRtwykG8KeVn03JZJfOctOB/jHTe3AbT06QIh\nANj3klxWgfpT6GY9pFwd6NWfH8NonbCWpKdAZOQQfMMu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWKJeh/EWbgkKJAkhLm9keqQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWZlMTQzOC0xZDJiLTQ1ZTYtOGI0YS00ZDk0Nzc4MDUwYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyhhRkR4kcfAmJk7mTD2HrsLmZ9GU5fp3Z5mdlhfwdJ6QB\nPIuLTG+ijwBbSxRB/rjFUSzfV27R7VATMSSTuvDXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUczxNS2LurYlXadDh/sDdLpEH\nOSkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGNzF0TxFGEFah1gVhbTKvNEq+SrttTVMNdBa9C89WPwCICMUU9RDMROk\nh12jSiw73ML3tbgdCJ3NLsINzTBmmqgV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAVFIOBqzb1WNv30iuFB/p1w4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTEzOGJmNWYtZGVjNS00MzljLTg5NmItYmNkMmQzMWJiN2ZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDViNjBmMDVj\nLTFmMGItNDUwMC1iYjI3LWU2MmFkMjJmNzIxYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABChx2aG+pYxSNdlUmwcbADYZsV6dvji08zonyBnNbvwhxBqY/1To4UJo\nxunzgkMfthVe1jNyr4f2gwrgfopCnI2jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIFIkHEe\ntNgeD0h0G98qWKrm9ghhMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCICqidC3p7nTzsZywvKnadkp4VnXMEQv4ra78Msnc\nwCdsAiBz9/pxQytmESASDrpWVpr5AiVmMkZaqpdXXhk9cHKmog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1211", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1211` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAcrpZGK5VPg74oZoM0s29T+mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiZDU3ZjA3LTYxYmYtNGVkOS04ZjJmLTljN2FiMzdlYTY0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFiNDdiYmItNTIy\nYS00NTk3LWI0M2MtYmM0Mjg5OTFjN2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6ko5/w3+FXFWFeFsUdfETSYD8XTi3Qw7bOIsGN3Dshk95HL2ZhTq6TxKTUVG\n+7GW3wcoghZcf8fmZ8vmfMV0CaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeRfpur9HjkN9ER/xLjI8rCWHiwgwHwYDVR0j\nBBgwFoAU43LsfzRcx/IwoaMqqv1EgNM/qbwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQChzIetQ5v2VVdPx22l1tk4JnjBmT8M\nVpO4rnUcxpRafQIhAMeOnPa7Ogo0g9FqJVUeFp5pyIAwautg6IK1juxfowAy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWilBpDcSmJas13+DZ3/dNbCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmQ1N2YwNy02MWJmLTRlZDktOGYyZi05YzdhYjM3ZWE2NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgHREe2MOA6bQd/aKdDta3aRxMhYpEvNmi3iVQroMPR7PB\nhsmhHS9DrzOUPkvDYLRMu8PhvgO/vAsoX5XHfhlSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU43LsfzRcx/IwoaMqqv1EgNM/\nqbwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPD5Ej/LQzIL+XOL+0zVS6W1Vi36FXcL58FSxuK/R5uoCIHQ+jCuLOLGf\nqJftJ3jpvCyE30qjLV2mHG1toQw6MBWn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAd/QkhHhbiM4iYnejz7bmoDtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFiNDdiYmItNTIyYS00NTk3LWI0M2MtYmM0Mjg5OTFjN2I3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhMzhiY2M0\nLWEwNjgtNGI1OC1iYjlhLWZlM2VmYzlmYmYzMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCMPKPQS9NE/W+d4O5jmLhK3VeA7tr2MniR0f5VRxygy41IBhKurKPSb\namYl0mAb9btk74YaQOhcnKS5/28oWeujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHkX6bq/\nR45DfREf8S4yPKwlh4sIMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDIm5rLJyiHbs2EObq2AzlWcKY1BuwjWtgNMPzp\njGKg+QIhAJ8pbVSkWwjBp8WzmrLLutT1tk6f+Yn0uNYQqQOEfJWU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1212", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1212` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAV4Tnr7IBAYe6NxI9u6/hbIYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4ZWZlOGRjLTgwYjQtNGM5MS1hYWUyLTA4MjA5MTM5NGNlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGVkNzVkODktOTBi\nOS00NTY2LTkyNmEtZGVlMzU1NDRkMmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaykWuB+Bbo2lGvgp248dJdID6K/RjiV6bNPgO68OCb7T4atlPojLtBhdtNtX\nIUYbDTHhyqtnHtsTwu0Ia9ntl6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7JfEaJPNa0OnDWhW1xDQNKRBkTswHwYDVR0j\nBBgwFoAUCpDiXpvWY5sJUaoh2y0ZjMdH6d4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAtf5HediIPfZocw6zqigMHvhxOk5qLY\n9pAVKrP5WrawAiBuUZkG7Y1uoNcOgGpaH1qEVumZ++cBCZXYCn2SAztZ7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaqH/DE7nexSOpfBQ0fQd510MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGVmZThkYy04MGI0LTRjOTEtYWFlMi0wODIwOTEzOTRjZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHNbmUfvH0CC8mw/WaLjXVDI5J4pOr5hPlMyhuGyJ970JB\n2q3GUAl2/iMLQNiYLafciClofnN71fUegjQw9ddbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCpDiXpvWY5sJUaoh2y0ZjMdH\n6d4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGzSeKvVamv3gpy2OGlw9YW/aiIuQ5u5tQpcdaHfVz1ACICESmgA+Czna\nKnv9lCqi3ZQtU3AFOcevZsBldZOE/FIG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAUa8/zzM43aZPo2yR7eH7xeEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGVkNzVkODktOTBiOS00NTY2LTkyNmEtZGVlMzU1NDRkMmQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU5YTJiMjIw\nLWYyMjktNDBjZS04OWM3LTNhNDIxZDliOWYyYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF2vzWzBVQ43EQ17N47LBzyepN8yvEKSczdfvCGsB1IjJ10+h6Puc+gh\ndod0Db7O0SJVj6T7PLLUEuM00/EqxmijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOyXxGiT\nzWtDpw1oVtcQ0DSkQZE7MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIFHgDdgYimzqNTXhABfHmR7EVsIuruW0fGxdxtNp\nX/HHAiAlso/6efsD2B4+1s16MJo0BJ/IS6xByqKTQneas/3wIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1213", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1213` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQNeUd+QV9tBxqH96r91aE0QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmNzJjZTQzLWM5ODAtNDdiNy05MzQyLTdiOGE0MWYwNGRhMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTZiOTI0MjYtOGNj\nZi00NTI3LTg4ZWQtMDBmMzlhNjBlZDI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE83h+4IZJb9S1fwx3yRw1fEOnGBSjrD+KetB/Ki0ifu1ZeKh+D7deDBmBq5ua\n7fC5LBDwAFyEVDadXLgEyGkHFaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsYiqrNRNE3WjmbO1sLp+khCZpWkwHwYDVR0j\nBBgwFoAUO1f7rWiJX6YUMhi0/TLLDD+tGU4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCgR3ErVcJb\nllMYpS4cWahiarko2F5XV8PaittL3USJiwIgTiO+B6v7Wzeicuoi4K3+n+VqR8cV\n8s5j6wApSlQ1YqY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdKAh6TRDxWMJOfeUHSJttHDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjcyY2U0My1jOTgwLTQ3YjctOTM0Mi03YjhhNDFmMDRkYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASP3XEfYR0x9e/uuyWcWSmfvd99en09Z8MYkaXThZ3fk4sm\nBSJ4zcnfxLJxI/emQOHmuHHNcIWfaH4tzWoW9UHao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO1f7rWiJX6YUMhi0/TLLDD+t\nGU4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBgpuHTHZNTVwoLJ9yXWosFPiP+OrBdQ4+yTCOJXJV4UCIQCG6T5cT5nk\nmdQd3vDK2jdP670LmK/kS/uwpma2aNoW8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAd/Rb0dBZ9rIUA0HaYFbfz3EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTZiOTI0MjYtOGNjZi00NTI3LTg4ZWQtMDBmMzlhNjBlZDI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMzNTdhZDhh\nLTUxOGItNDQxMi1iZTU2LWM5YjRlNTc4ZDVjYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN1SfrpMrKd5W6qcIBYOazwPfjVnl/km0XUXOfih8yKpCqpXvMqoauAH\nXUWpzVpcdvrbVwyMdjytGgw6Q/+QHamjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLGIqqzU\nTRN1o5mztbC6fpIQmaVpMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCIx77PsRYbLZZ1Tt57jjK5SpQxpSk4IG4TOKC3\n2tIScgIgfuaj/gDgHaVO6k+IDrpqxrWnC9G490C9In3RmoEMwmc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1214", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1214` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAb6wExeOp4UHB1KkoFpvTSLkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlMWYzMTM0LWRlNWItNDFkZi1iMDBmLWVlYzMxMWYzZGZkOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFkYmJjOWQtZTRh\nNy00YTg2LTg4MDQtYzA1NzhjNzY4NjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy9gkZNGy2SwoTvaMvTPv6ze4/NGgNBN76xf5hs/LbA8bvn90DWdz7XI/3uBt\nGQYTxgpeOxsdLFwNZf0EjjeE4aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXkpM77rn3GOe1n6TKmIeOx/BejAwHwYDVR0j\nBBgwFoAUV3h2tzctHmkDoxObHtl/q8Tg4T0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANATvGVjBR3wyqxnRFLJWTtL316F8QTzYU2efLW4GkICAiAY6ut/iloN\n4vBYARkIlcabhcvNXVXDuEjh5Ua7rpaSLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfbOMRkRK6PV3co89iV0m/2vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTFmMzEzNC1kZTViLTQxZGYtYjAwZi1lZWMzMTFmM2RmZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6wctdGcPKiS9mNaHJwMmxzxdEBXwXTMTQu3PRH1pOiXZD\nehhF1jJyTx6NEfT8asTBLi774LJUM00A4mkijthuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV3h2tzctHmkDoxObHtl/q8Tg\n4T0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPb2PPoPehwQ1VjJ/Gn+s2T6nzd5KL5QJ5kYByVjqsMNAiEAj/kdfwqf\n9yVSxj/VYr6OUf9KaR6LIe0XhRuGMC5eF/o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAdXM3gBDBuMuZXDlKVhbNY2MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFkYmJjOWQtZTRhNy00YTg2LTg4MDQtYzA1NzhjNzY4NjQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcxMWFiNjcx\nLTBhMTktNDYxYi1hMDYwLTI4NDMxY2E4MzgyMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG5qJVJweogg3E70ysfUJR0+foKMDXmEmn3oB8+GPn6VP/FonTLU4SK5\nhP820wiHCHIjo1uKCmxr6oa9sNgwo1ijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF5KTO+6\n59xjntZ+kypiHjsfwXowMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCfpKxQrBTv5BV0X6kI2qgiKkFmCyDavKu1K7/F\nYHrfEwIhAIyGJS9rSfiHbO4TQMXbMTPwEdo4pEmGAB7QXeQ4nNUO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1215", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1215` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAenaH89pWbTkgWY6VjhVPd7oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZjk3YzBjLWI2MjgtNGE0Mi04NmRhLTZlOTBiMjNhZGE1YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y2NTRhYTgtNjgw\nMC00NzBiLTg4MTAtNjc4ODEyNzEwYjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFcKGGa9Wvh6XTSR7G4YGmd2FRb0dvu2YptR5Aod2br69Yeecqf0peHg3Yc3l\ntenkKvdPMQC0ZI5A1kP7cbnQgaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1fAp1DMAihxbGvFCNb6Rl85I4sgwHwYDVR0j\nBBgwFoAUqkO7EAjAgFZUcQjuKsKNXyY3DVowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAO7zKGxGSR43mPd+EQZmK5XiJ1on2D09cS4RMzJfS3mBAiEAyaQKETO6\nP4a+4JtQCyKcAKGCdTYXCocgokfL3Rsg0M4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQtGFBmsUU0dHLaOVdFC20TqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWY5N2MwYy1iNjI4LTRhNDItODZkYS02ZTkwYjIzYWRhNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIvGv9CL/djqwyQBvzfDpGpHfD57RVcdPqfm8t4TJ5iebk\nvWNMQdbbL7TX8Wi0ZSf1abKSKi4VdiTQeIP6Gbhko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqkO7EAjAgFZUcQjuKsKNXyY3\nDVowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdyBAQuZpO4UT+x2xrwlwX5ywX/lsW7x1rL3me0aW3/ACIQCKQd80xLsA\nDZshAgS2S9VwH27YKgYWrnkmB7mdkCXL9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAZL7tHUCpzj55dZPhjp3Nl9hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y2NTRhYTgtNjgwMC00NzBiLTg4MTAtNjc4ODEyNzEwYjc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyMTg1MzAz\nLTM4NWQtNGYyYS1hMDI3LTY2Mjc0MzVlMjg2ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPCJdQ4pD3ddXIV7zoB+b919QS8brnWg1Xo4v3MCaKipE8DiK68nI/u0\nYAvgjhWLYkw5gavISa7ICwzZ179AxPajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNXwKdQz\nAIocWxrxQjW+kZfOSOLIMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIDuIhnUf2H+P4T4VcdjWJwdb3V6xtCfwTz7ILu2z\novzWAiB+YABt45eRwXpmwTBuWETeL4x9IP7N6ZO0bPfI7L+bVQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1216", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1216` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAQvYZHmda3QCvyBbwRQADxWmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxMDkxMjc1LTU3NGItNGRmYy05ZDdkLThiYmRiODAyMTg4MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTgzN2JlNDEtZjAz\nOS00YmYxLWE4YzgtMDZmODMzMzk2ZDEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElKzrCiUHcDL8z3zifa1YY1N+TUci5X1VVFzkXk1OsRh0UFfO/9bXhrUypRJG\nyM80OZ6TkybfcLDcswUScOeQ2aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrwz4iCZoSWFZ6xwQuaJgOUypro4wHwYDVR0j\nBBgwFoAUJ4oQIJYGQTqwXLXBR6jgiXggpfkwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIExHQfiHhfuki9tw0maWw4u4FmA0fPL37DFm+c8V9SseAiACiWBfKHKK\nUcFdheGmJQ8Q/Ful0JG7n68w2XrL4hibFw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdQTqe0TZpuDgrhcVBeNWJvLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTA5MTI3NS01NzRiLTRkZmMtOWQ3ZC04YmJkYjgwMjE4ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASylFRR4KqxR2+D8Wsjc2q/QMYYUwxYFwrw4vpYkU+7i1bu\nt/vAnABUOZOSwLXHiIKhHHju8WKCYxiVlfpIG/Hzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ4oQIJYGQTqwXLXBR6jgiXgg\npfkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF7AwNCYu972voTiXIgkFQ9WNLZHAALZ7T37/PgVfzrgCIQD/GXTdWDPW\ndQkEIBtgvHVWbqfpDoehR+qOxCS2+TgVrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAfQ2e7hOECAMbtCqMtJe+yrfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTgzN2JlNDEtZjAzOS00YmYxLWE4YzgtMDZmODMzMzk2ZDEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI1MTFjOTU0\nLWYzNWItNDVjNy1iNDQ0LTAyOGFjYzE1YmQ1OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPp3nqGdx8MPCx+85Wzvneh/eHgPqjxd94Sk/PaTV9ETopAu3Am++4Mf\nFGJWjMWb7iDj+k4cVG9ewcmYbbtrRRejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK8M+Igm\naElhWescELmiYDlMqa6OMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDMyz4f53h0t4mSnqLNv0URy+BkA2QbhkSiiDTa\nWhccfgIhAMSYiyLg2LOEgpFZvXaJyxhYzrcGpNXeuX23CJXZtX8A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1217", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1217` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAckcX2q0DtmDQcgP+eFOnHCgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliMTNhYzM0LWEwMmEtNDg4Yi05YTVmLTIzZjVhYWNiYjUzNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjViZWMwYjYtNjFi\nNi00ZDY3LTgxYzgtMmQyNmEzMzIxMmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpoYmniptAiOc/0xiV8wj5aLeIr8dJgHgZ+usnQRqvsqots6ZipN4OEE6Ywmh\nqIY5Kom2KxvYce0ggs7NyECpkKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQuP3qhGkbkTfBXcp9c4K9LNk3eowHwYDVR0j\nBBgwFoAU40tIPrdqrL5fsGNZeEuQ74+iWrUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDkFkOagChUCdOSipqhhXsJqjwigL19hJ7JeOIqI\nsSzLAiEA5coCn+/0Wvrq3w20W7oIpKR32tEFPgmEp6yFTe81At4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWPQCNYjEUbF/GrQhwrRH53HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjEzYWMzNC1hMDJhLTQ4OGItOWE1Zi0yM2Y1YWFjYmI1MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATz1FeHb7vzsqE8iCIuLZBgafyfy4jWh0Tbhz7l3jKlcL3U\nfCyI1CdAF3olPuL1rjYBRRfza7oYfx6Gwuwk0GNRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU40tIPrdqrL5fsGNZeEuQ74+i\nWrUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALzzQWyjt4nUawk0SzihYIrugc8Qcq+EVwAxiqSSut8xAiEAkv5jc4iE\nqsW833A3fgi4aohIIatokGdCko+x9+/U+4c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAU/cJqEux4sun2+/95SR9Z+kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjViZWMwYjYtNjFiNi00ZDY3LTgxYzgtMmQyNmEzMzIxMmZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ3MGJhY2Q0\nLWJiNTMtNGNmNC05ODZiLTdiNTA1Njc2NzIwZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOZwfjSMe4BGe3TMw2i/TLx5DYhui1v4dWIUMnh9p+NyaPUKx7ai7UAl\n3zmht1Bss9ODhhqp/iBaAWk9R7JhOaujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFELj96oR\npG5E3wV3KfXOCvSzZN3qMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCICG5mIKd3L++i/7uwzU/jibkTDVAMKyf3eUBeVY9\nv4gxAiBS5WT9GGCut1HVt03awSPTtAFF40V/zlHM1gZZVSUsqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1218", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1218` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAfyW0sOPspxemY9jcUhzzx1SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjZmQxZmFjLTdlOTctNDFkOC05YjRiLWMyMDNiMjIzYjJlYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk1NGJhNGEtNDM4\nOS00ZDE0LTk0M2ItN2YwZWE4NDRkODM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY7zmqrf+xWKG7XwOjkpPRbYtEDg+jpSt2p/g4L1pPVefSdoa5FkUTyX7wkpp\nRv+bmjOdVIBjVAyIMBhfEm5nnaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ORGOHbwdJKZ+Nx/o0l/mSrlGaQwHwYDVR0j\nBBgwFoAURCNbmqqx8xUUvpqTaiulv3w6FF8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD3nF5abmd1r3A7avcFbRNXgpj0ILXhnVdE/ogx\nAVfDqwIgFSyWP24UErg0e5TqM4vZJos1EgiP+OAg8VZReYlClOw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQm8pEoqoTnQ7ieHwCmWYdmGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2ZkMWZhYy03ZTk3LTQxZDgtOWI0Yi1jMjAzYjIyM2IyZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvTvn+JE5Mzsp5XsBpBLtJISWqugg4cHA34Fc+5eVmpDxl\n1rENS1zgrDB3VrpVqV1++UnCEt08OG5LhKp35Lb9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURCNbmqqx8xUUvpqTaiulv3w6\nFF8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJPs569tn4G774m5F8r9az3wgpcet/+P8UScoNTDjCXsAiEA0Xx9bYH3\n4b8O+O7U3WuVBDPb+M1TDNuxNDYrMAdS+84=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAZbvZF0dZYo7a9n7vmWG/PdAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk1NGJhNGEtNDM4OS00ZDE0LTk0M2ItN2YwZWE4NDRkODM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVlZjgyMDlk\nLWFhMTctNDRkNy04YTM0LTdjMzYxNTA5NmEzMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCI8O9D4heXmxMXKpkOvAvs+F0TkyitYLZrEzhyy/P7atAKEytmQTg/g\n/Pyse9WXBXZUU8UFQaxKrF/K5iS/dFajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOjkRjh2\n8HSSmfjcf6NJf5kq5RmkMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIB9e1uwLn1JhPxxjljRzsSpbu/16KUko49AMXYK9\n8ZiAAiEA+aJif5l0k5auWGEb2Yjb5EGWTSHcFtGjzpNvhdEJh5Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1219", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1219` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZChry/kc8DpYYAbgcdEdjR5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ODI3NDRkLTljNTAtNGQyZC1iYzYxLTc4ZGZjY2JhOGI4YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE5OGM2YmMtYjhj\nNS00ZGE5LWE5MzItMThmODAyYTk2OTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENwRVB9RyEqoFoR0gDBty9HzbPu+b7Q8gDpwipw4tXnQbM/qIVeXVOEEZ518/\ng4p1fnSidkiVlvKdfYbGwi3YDKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc2gDJxrDCT7nPabZmFqYLnj7UyYwHwYDVR0j\nBBgwFoAUf2i6wdcaUeMhfNHQt2BhC6dY0BcwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDyCDUgXVXvzYffYOMgK2vbPUPPaZPc0xHM4rC5CTm1KwIg\nKZFsdj7k/+UtC0azl1cLJaGYXcxCt1fMV5yaRnzw/ns=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeiMgW+w3FcrRzTlAU+7QMDGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzgyNzQ0ZC05YzUwLTRkMmQtYmM2MS03OGRmY2NiYThiOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvINbTc6YwSdcfSw2E+1y7cDfos4AtgnbCFMC8HBqqNkhd\nr6Arjx7LBf/9soRXvP5LYOJPMg9SWTDh23VmTmdso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf2i6wdcaUeMhfNHQt2BhC6dY\n0BcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOuzUKv6GrYt2fSxCYw0jNrcB9CAYQ2fmlgbNHEOYq7bAiEA7BMEFq8E\nYMRqMKJ7p58aCjgA/V9UHSYs/idiZt76jlQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAT9WoqZ2NrHpd1JmTsVQTQsJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE5OGM2YmMtYjhjNS00ZGE5LWE5MzItMThmODAyYTk2OTcxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgxMjk4MTIy\nLTlmYjgtNDAzZS1hZWVkLTZhMzBjOWI2MWE0ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG5Wh2P/3EHqT6+xtY8Qy/5S87bTtbHNU5R3DWZcUx1Kr3kM10MIDrzv\n7atZk4oZq7HIGmaz4x9lk2nY5BkYsaijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHNoAyca\nwwk+5z2m2ZhamC54+1MmMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDgaqud55JlwIw2XK4PPoogj0PHSSrrtqdc7hyl\nMrfemwIhAK7ILXbmdSvvkWK4alm5VLlf7LMxhSHDhT56nuaEx+ax\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1220", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1220` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAb67+5t+q3lWN5MFm8FaJ1WLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhN2NiNjJmLTY0NWEtNDE5ZC1hOTljLTY1NjdmMmE4NjNjNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYwOGU4MjAtZmQz\nOS00ZmQyLThkNjQtNWQ0ZTkwMDBiMGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErWksqwVsGg55PieFe39JaETbmO+30ipE31/tJPgpnrdWuggf8lKPcuOTBss/\no9qd4kaKoMTT7f4jLdkxQyHPbaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU3hw/9PBXo3HvQXrpO2pee4V90cwHwYDVR0j\nBBgwFoAUw/iTNuzTDj3Gtd25fgNG5H/v0gEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEvATbSVvf+aIqCNvoa3kdww5B7CPYdP\n32Y1OU+5120nAiEAqFBnK1ScJWoSXTT+QIiL0z45tq8Pbl+jYiuT+7dcqU8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAazbQ8NJfTbJRibOOLHsDSdyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTdjYjYyZi02NDVhLTQxOWQtYTk5Yy02NTY3ZjJhODYzYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFiDVYPYI8wAYEgxLZOa12cctzJZlA0uCmHGaHyuJHCiu7\nZEXIdeMR9+sc8vZt6LjAcZBJ+GfR88uM6UIioPU3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw/iTNuzTDj3Gtd25fgNG5H/v\n0gEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMjR+6TYzEYsboJonjlx5f21gLjzvmtHwzRWxZZCwka9AiAUo9zxfzAD\nj5jIo9HCvsB5B2C5kc43XHfN+W+fOlLT7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAalsqeuCWV9N2jKNIa6AClKDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYwOGU4MjAtZmQzOS00ZmQyLThkNjQtNWQ0ZTkwMDBiMGU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIzZWVkNzcz\nLTY1ZGEtNGY1Ny05MmNkLTEyYTI0YTY4NzdjNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLu/3mLh9TcSP/I0Pj5xY3YSgxoHXFSuoPMLO06q1ToT0FcTJTpU042e\n0/NnKzjoIAwyb7JX8Dc4ej7Qr7JJY1ujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFN4cP/T\nwV6Nx70F66TtqXnuFfdHMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQC62LlEmd1b1VfdXDvGXsnSnDp/9nLF+Tk5e/uD\nFQIcEAIhAOVkEn2NM0+ez3D5pci6ufUbABEkV8paMdNc2KbQef1U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1221", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1221` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAa9fzHcsWJ543SkEFSX2Lg2QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwNTEwOGRlLTRmMDUtNDU3My05NjZiLWY5MGNmZDdhZTY4MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVlYWU0ODQtMjRi\nZi00ZDVjLTk4ZTQtMGUxZjFiYWVmMjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKB99Jkv4aCsxRs8wxMrairXgsfa7oeeC+fJDocdGxo7r0LXevSwL0c/G0D2m\nT73EndvVI0hEl6VrJ8HGd6QJp6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa5sscOuJa3QdiNAuVoLS4dWaL4gwHwYDVR0j\nBBgwFoAUh2XOZXOjafIVtHkm5bNSib7D4GYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCl9DuyjuABTEMAe6k+5fSoWrK1Leph\nut/Z7+qxAcUsYgIhANFURG+TjskjJkUgSA72nPoQzjAZIXVyV7XoCPU2lBYh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARdGcpR+S6Njt/oO7OjtufvIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDUxMDhkZS00ZjA1LTQ1NzMtOTY2Yi1mOTBjZmQ3YWU2ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1qTcyPP6cNEjZ0+EmOB2YdQq3TV56QN9N1yS8EeKhZ3IH\nt/oq9qk/jDWRpLJ23gUytyEYE93aDEAZAYF9ll1Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh2XOZXOjafIVtHkm5bNSib7D\n4GYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMR7oqgFpR8u8g8r3XE4Zc+GnkqeDIrPFbW4LfJHtPKPAiEAicrdugCn\nRIrC326H0An2j1Bpu/SM5VFWet3UxA8GdVU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAflYkghBwwMz4XcJbml/I48gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVlYWU0ODQtMjRiZi00ZDVjLTk4ZTQtMGUxZjFiYWVmMjdiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkyZDIzM2E0\nLWMyYTUtNGY4ZC1iOGM4LWI5ZjIyMGY1ZDAwMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIb86gzzfoeLo3+1WEhX9Ie6rRPNCxDWeSqTSOU1f4XTeUxtK1pR5PAI\nngIETlApv9GAWZPL7ZhIqNqBr1vu7r+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGubLHDr\niWt0HYjQLlaC0uHVmi+IMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIGtaoUbMEnDE5gxLute14KUwoYasf7HNkSB1P4kJ\nEkXPAiEAnk+/XLd31kEIxHG4f+FFHsz+A1PINeUzS+dShGDMwPo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1222", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1222` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXJvMp5WOspnhzosx4DD32b5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyZWU1YzE1LTcxNjAtNDU5MC1hNTRhLWY0Y2Q5NzFhY2MxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY4ZjIzMTQtM2Fh\nMi00ZmIyLWExNTgtODJlZjQxMTQwNGM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbtYN4lzffH2JYdnQVbA+Pwp+2sqsnC891XRnAVTPOS5ESN9yih1EEVa10kKb\nEuxdhVoAMEt5RriUOZFviYqTY6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC6KVgsaXfNV/q22hvTmVgKODSAAMB8GA1UdIwQY\nMBaAFKubSMSvxDYkL6lY8FOUQwlxjSF/MAoGCCqGSM49BAMCA0cAMEQCIQDYAxud\notxBcCAQZIskoVC8f0TCmqHWNoQxSqFw8dCVhAIfE9XYarVFpMs14jV7AKthRsB4\no5iIUXplcPUwXzARSQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASmHCPSe6nvCWugSzD59YGR6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmVlNWMxNS03MTYwLTQ1OTAtYTU0YS1mNGNkOTcxYWNjMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCCz3MUkuofxtNNYrEXRPEfE2/0+oLMNx0HOjeCFD+Gdyr\nnoHdrWwv+DDIp/LBy04aBe09oZoE6ZojcYaDlT0lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq5tIxK/ENiQvqVjwU5RDCXGN\nIX8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALGj1HIoqLCKpi20SZVyaTa+7G9oDXt07ReU3ywgVdlMAiBQqssKSuUR\nL+RslCyNHf5STqphda80ohOaBBzce5/Xpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZBuBxNVFzjvAa1WTl7/gBPJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY4ZjIzMTQtM2FhMi00ZmIyLWExNTgtODJlZjQxMTQwNGM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgzZDAzNWI3\nLTI2MzktNGMzZS04M2VkLWJiZjUxYTRlMGQ2ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFzu4EPHPWLjPaWvNkstRotmavM9FtY1Kq5773c6LSattKdKmjixe2fB\nM+paU7QPcXGGtKaj6bedDNUJxig3MvWjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC6KVgsa\nXfNV/q22hvTmVgKODSAAMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiARiCcw5XlBUKZ/F6M1SwP92Sm2TgCA3trSZGHCy8FrtwIg\nWm4GsLH4nlXp3bSC0KuSA9muTh+QMsVipxUH9QtktAQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1223", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1223` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAdr9KViOzJ3Y7vCkXN2QEqjUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhZTgyN2I4LTBjODYtNGQ5ZC1hZWZkLTI0OWJkZjNmOWE0ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRlMTc2NjMtNjAw\nOC00YzlmLThjZjktMmEzYWY5OTkwNGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENahkjSIsNZfLh5FctFA49J1Y93HfLF2mX8EsSxzQXEtf1GA2Hz0kHy97rYyd\nhF0lqzjghxP3b897/ONkt2k2gaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMOJgFTOlf3EJuP7qjlLjAI6o/elMB8GA1UdIwQY\nMBaAFEYAaDKAk+gdEQrs9PEbgigBMO0IMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB/iyyN6lLcSrtIpJTVC3BRtxbnlcGBZ5ip\nRmihI5FXnwIgAWCk9qZ6rmQ8FAJicJqKkLMVNEhQQMpFOSfY3BI+Vdo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWwxFYIPGWGVPrTzlAxlCwT5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWU4MjdiOC0wYzg2LTRkOWQtYWVmZC0yNDliZGYzZjlhNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATShd9ug7Ij2mhIxPtibj3WzBpKnhYPaxOk6YYeOCHBjUrP\n/CeOBlprZCPNh48mcmQeUnWlZZahxfnKnJ8zdob0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURgBoMoCT6B0RCuz08RuCKAEw\n7QgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALqRXgMDknsWBwaV2mfWWsGbtFOgb1MA3t6swwO6eR7cAiEA+wSaSPnS\nI6QrkzglzN5/OUHqbzKvHwPIaz18gywuAdw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATL5G3iWdxn0ymhPlGoZdy89MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRlMTc2NjMtNjAwOC00YzlmLThjZjktMmEzYWY5OTkwNGIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1ZDgwODgx\nLWE3OGQtNGNiMi1iMzljLTVkOWFjZjMyMDIwYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHDg5VLag/T7BCZrEwjWig7eEaKgM4Nhyo9CFtC0wbFP/8liXATK5U8t\nCfvv2/eU/p4Mwfsreqq6gkprI0hiZMCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMOJgFTO\nlf3EJuP7qjlLjAI6o/elMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAoxVmCceKSgv1enxdE9YxVn5wqv6pId9200sDVJLtMzkC\nIATB9CUovBgEuLAQmE8VCJBvmd+YY4Zgpw/qkJh5+Rmw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1224", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1224` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAaneqh+DTE0a3VPG8BS7rwyMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5NzQyZmZlLTc0MTktNDBhNS04ZWFiLTc5ZGExOWFmODAyMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzEzNDZlNmItMTRk\nNy00NWQ1LWJkZDItNzE0MGRhMjg0MmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHXv+26g0T0jal1hVzVh0+nh5WZbX15AIpeeQCYUkcjGTxxLrVfosPzf7gwc2\nR1oSlwCVMXXf7AGge1eNykPPoKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGvyMu9sNHBuW8tVWtFkX0IHiOFMMB8GA1UdIwQY\nMBaAFKHSrhsg+6n3WaL9/1Y/rN63pEIwMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAyjPhHJn5urBtLAGS5O3CSAf5u8kpHP0R\neQVK/S9qzVgCIQDkdQCyTlS6tpEtdzE2EDt2K5pEBsIDEq+Y9to8SwZuLg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAark+eOeQ2pANJ75yUcLCH3fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTc0MmZmZS03NDE5LTQwYTUtOGVhYi03OWRhMTlhZjgwMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWOhBHVZPcT1gUAIB5aPVvK2XJcMacNTpT04zStOAessBL\nH2FyPtJYUzFgp31B3xEDVYD7CKPRsgo640A2hBS3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUodKuGyD7qfdZov3/Vj+s3rek\nQjAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALZJe4eJoW7ebhDHG7gjWVJ02AvAoD45GwelLzQwm8m9AiBE1Th2lx8z\naIx1G3RbWIYgCouN17ooq9lbQ9fB2ZlEHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASEq/7kyrxJwkEPK2vs1mo+9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzEzNDZlNmItMTRkNy00NWQ1LWJkZDItNzE0MGRhMjg0MmYzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc5MTc1ZmI4\nLWU1YTUtNDRlNS1iNTBjLTY0ZGEzMzdmZDQwZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJe0mlSKTTe/26t0x18kdk5fDfViuBAugO+c+XTAhJd95cw16/syPHx0\nW4Eao5YaaAuh637o4C7w8dg3wti8ojujcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGvyMu9s\nNHBuW8tVWtFkX0IHiOFMMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAmrpbUHxBsQepGqu9Rn5LGHle6aKUgnlGE75J7fMpG7wIh\nAIC+Ou9HFAkExQCWKmn+duFOevZfZv+lhb6878aEZu6c\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1225", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1225` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAb/QPe+wYkyd83xRxUTIbXT7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExYmNlM2JlLTZmYTMtNDRmNS1iY2VjLTA1YjZmMTc0MDVhMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZjNGMzN2UtY2Fl\nZi00YmUxLWJkMTItZjhlZTBlYzQ5ZTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO8wMa3eVpuaLn6tsqPF104kW4UUeyK0476MX6n/mNWbkONzUKHt73xsNC6p/\nruY82AvP843u1tXsW/KJwBA0h6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTvJUdw9LyhpNMvaQ5Xekaqjm3lQjAfBgNVHSME\nGDAWgBRxYATCrnYQ6+Relq88niMeHZXaSjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAxhw3ttXM7oNPImBLwtzKEYTIpUFgYL\n3a4toX4LsbuvAiEAjuiDcalwoau57xTVto3wOVP7sGmUVQp4J+1F9KAO9Uo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY+RhosiJRdcVydpnTWiY7c5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWJjZTNiZS02ZmEzLTQ0ZjUtYmNlYy0wNWI2ZjE3NDA1YTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATR2SgSdqmRFVmZ0A8Vj92833gqu3XiAmJcWiqDZcXoxlMD\nLnxLVRdNOl+xGdZcB71F6lK86MiaMMeanU3A+/51o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcWAEwq52EOvkXpavPJ4jHh2V\n2kowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL5hvH+bBZeno4lxSK5UNxchN9UKBRVsesDS1ibqFHErAiBaXmMVz1ik\nDaFrPQ0r2NpxAsHBVwP8RmUIQA51lzATXQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZ+ML7HnSbvTl9lOeM9D3eb8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZjNGMzN2UtY2FlZi00YmUxLWJkMTItZjhlZTBlYzQ5ZTYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM0MzcwOTQ0\nLTg1OGMtNGEyOC1iY2ZmLWE4NDNjZTc1YWNhMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDR8qlfsUh7gWZx14wUjhPS5GqfMdHCTlTkeLJYY9I57JHmE5LHueu1/\nj/+hG+UtLWvtG6EgUDPXkq2MHJnztsGjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO8lR3D0\nvKGk0y9pDld6RqqObeVCMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAuEkmPZO3bkyc5xmYqTC8wXIvg3zIbqNmQSwXUdyMKNcC\nIQCj3w1a9/6JAk10ykhPYa+2AH4qv3kULXviv7v0FGpZhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1226", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1226` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAaedRox1MTGgwBGFeaMCsgvyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NjY2MWQ3LWMyMTQtNDQ5Mi04NDc2LWZiMWYzYzY3ZjIwZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFlNDNhM2UtZmYw\nNC00MDEyLWExMmQtN2E1ODEyOThkOGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQD20jHd59TiXpKfP62WZXlNxDQqrVw8etu30QG1QDF+zyZL9jMC0Jf/lEULU\nzho7Lq3CZ1DWvWbU556Xyqzpr6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXv8esgZQK2Bj2VqQUDP0A0t9wXYwHwYDVR0j\nBBgwFoAUVI2LBDOph67nWsoT9CYCX1JAsdIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiA1+FnBIMg+IfuE\noXvcTbTfUjYk8yg8BoRnVZEEMXx6vAIhALJTwqnkrUGGIykxwJp0eebXJSxyCPzZ\nryZYM/SfUwY6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT7Ex/wbv56Iwtz1SKyfDT6OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODY2NjFkNy1jMjE0LTQ0OTItODQ3Ni1mYjFmM2M2N2YyMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARI17yWQh8fLhB5F4zX2DsIxEmPfWdOH7Jnd1Erbrm0RnBv\nsBoi3C6XZCYQGe3PTGW496mVehuFe4g/wvNH7MHko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVI2LBDOph67nWsoT9CYCX1JA\nsdIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOrOczDbCoHh1ItO6fxTs+iqw876KpYeCHwk+untGAVIAiAqZvC0uVPq\nM2SU7yVrP1aZB2bl52P3YVnI610YXqKeFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAUP62SRbfculXq1gQAFQLVeCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFlNDNhM2UtZmYwNC00MDEyLWExMmQtN2E1ODEyOThkOGIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUwYTg5Yjhl\nLWJjMGMtNDM4ZS1iNzhiLWY4ZTBkNzJiZTM5ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLNrXkzjFztuYV5w8mzD1ozAcNfK4rG7WWkRWuYBlB4j/caXNfKPtZfe\nZABVgajBz7M0Mzwxsu9ISnTJ3eP0mnSjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF7/HrIG\nUCtgY9lakFAz9ANLfcF2MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAqQjenbubPhS9zoiQHZG95YWA3kOJVu93Xge6/2g+Z0UC\nIQDW3NryDsPMRmNlupa4qCJuJe019MKicI+ww35SfKV2mw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1227", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1227` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAR3MZbsx05zsGfmoZmoJTcyxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxMDhiYzNjLTA1MjEtNDBkOC05NDIwLWM0ODdmZDgwMWJlMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RjYjZiYzUtNzM2\nMy00NWVjLThlZTMtNzlkNTNlMWEzOGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEILXeWqNUXtPw4fbgQC3OtT+MXiNcmIrHXJzw9AqSgM23ATFyHBYxqKRSgts\nZ8bv5PrtxYn8m3krJqUWI+sbTqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx0N1Wvnf9SudeYRVJ5bEEGQX2sYwHwYDVR0j\nBBgwFoAUjAN5FTBYIhE8Ootg2nqBvvsfzHkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAoCqQTWRY2p7E\nxPsosON4yqPCIGBT/ZovKsXTjENLiygCIA1k3hn/uHDJsOOO4+CrBvqrG1YCkuU5\n91gxfVpn7cRm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcDbLxERtMwDGSuBQJlJx1SPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTA4YmMzYy0wNTIxLTQwZDgtOTQyMC1jNDg3ZmQ4MDFiZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARb+oThmrwZAde2nbyXuQzogrqvTAT7XGW76ZETsQrT36T+\n79OtVmUDdFQb+wBEx3wf5rtXax8F8NYv1saOXlCZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjAN5FTBYIhE8Ootg2nqBvvsf\nzHkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE2sxsas1xT2VV38yih6UHme2C9Q2z7sWmdSV/sEU1eUCIHWjfFIwc0sR\nEDwBCFwAbMd/F0/3yy5P0J1pDdnc8/Po\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAX+de0/IEMFSaxCPMFygjT6EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RjYjZiYzUtNzM2My00NWVjLThlZTMtNzlkNTNlMWEzOGYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ1NzI1ZmU0\nLTNlMTEtNDJkNi05NGU2LTNhYmIyMTQwNmRhNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK+BARi1fS187Buq3nBjHoC390OdaX4DhpYAtOSUWs5krSTiBpDrn8Ey\nEbsSeZnWMpq+zqv1d3AXhika+D7xWRejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMdDdVr5\n3/UrnXmEVSeWxBBkF9rGMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAwZBqKiUHa5T04xjq6YI+/6EkgiqBX/3qUKpFOFRBqLIC\nIAH0+p2KhRZpEN+F0ivp0UnWD07o5qKmRKaXOiSVxFtt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1228", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1228` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAW/IL1AoA2j/2NzqAvz5EkvdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjNDdmMGRmLTQwZGQtNGJlMi1hZGFmLTc3NDIyMmJmOWZjOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmUyNmFhM2ItZjJl\nOS00YWJmLThiNTYtZDFhNzBiMTVjNzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV4k/X7MNTuPwi4mo2msRJzlzGnldq8oSgh8AWceJXiv7FRFT5ApM7VIjy2B5\n8t5DeDPxgrEV0BtXlJVgqEYuj6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWY+hCb+iiNs4T7nTi5juKNOfeMEwHwYDVR0j\nBBgwFoAUQl6JVHhWWpSr2ftuMCD4Fuqm9hswIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAt6oYBQ+Sk6RNG78/A+nq\nsTLkhl/Xf3VLSTFIwXMU/QcCIFmBDCu9Vy26odTaAbB7r3CzCbMcTg+HssWSe3+C\n9lzI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQfkvAxLLfT/gH2zyqYeNtdTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzQ3ZjBkZi00MGRkLTRiZTItYWRhZi03NzQyMjJiZjlmYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9T8W1gS/F33ZlVeC7vH82QsMH4LCLOJhEJqIiXyRP9iAR\n/xFCOMBNo2Wm28IvHL7JIJZLqJb2mDGegsqo9OHro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQl6JVHhWWpSr2ftuMCD4Fuqm\n9hswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIAopP0ImnKJEs6fjAvObEujv9iFWW1ehlpdefeowTWwCIQDTxwgO2MCt\nVF3wg+gFr5mbp3Qdt5JZC5rXl5xZA4OvIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdfwRbCzsKTqURii5XUOM36lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmUyNmFhM2ItZjJlOS00YWJmLThiNTYtZDFhNzBiMTVjNzI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMwYTllYmM4\nLTJlZmYtNGRlOC1iMTliLWM0NzFhYTVhYWIwYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBLa/L5zUbR9bbNbMmQh6WwOkyoiX12h2//XGqMnNpDwHazEw8Wd6BhH\n9oUTf0CbGaO0rj0yFq5x9bWjwBP6GvijcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFmPoQm/\noojbOE+504uY7ijTn3jBMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBU29N1+lFgJtewdHFeCvgXRvaHsKSh9+zImD6v0PFTVgIh\nAOM5NypQ+Mw/hnh4v4f7Fww2g9EPqz8IS7+Q5DBt06vC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1229", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1229` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAQ4VHjY3CYHLhVJ4jamgrjwzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljYjM2YWQ2LWVjM2ItNGU4ZC04Njk4LWM0MGE4NDczMzY1NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAyNGYxNjQtM2Zl\nOS00ZTcxLTkwMGItODRiMmJlMTIyYTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErMIMhGsDg4uJ+t88wQrZZxyNu8/XtS9nNev87B2/Ke6ApI8NFznchtowc2Oj\n2KIrDhNCFspoxWvvcL2WOZNynaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUROi/2K5WxAMPnxJB0njsBAR9XNEwHwYDVR0j\nBBgwFoAUpPIrRTEy4tWIuFhQmTlGEzXBCx4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAnW6Ra\nL+Ys4w/gOyydG3pme8lgewsDHHyanjh49Y4yNwIgPtoqXoDaAOUA/SYrQgNh830J\nc5XIu4UAcl3Ok/OF7FY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXaRy3mzxGBuljia7HX6ilAEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nY2IzNmFkNi1lYzNiLTRlOGQtODY5OC1jNDBhODQ3MzM2NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuVkZpq/IfrvFGPRZ83PYa5c1s8p+VhA7wIpPlTGxdPOet\nag5KSmLuhy6qvBeh6LV7827RBXryp45w2wcySdI5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpPIrRTEy4tWIuFhQmTlGEzXB\nCx4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI8t91my30N5qK1aieBU5kkHF0fVPBQwubjhItX/iIqIAiEA17W4L1Rn\ngEUOfSbUlDiVkgm5RIf1zKGP43of8ZTa+qY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASAeqZQxmWo9w47V2rHtieheMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAyNGYxNjQtM2ZlOS00ZTcxLTkwMGItODRiMmJlMTIyYTE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNkZTJlYWM1\nLTI4MjQtNDkyZS1iMTY2LWUwYTkxZmQ3OGMxMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFD6VdHEY7cPHi2l8uTYfWNWBLpwWY+ZbfKnPDBB3evtCVe5YQoer6CH\ngauLxuxBRm4s+7dVVkoswZrzaI09bH2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFETov9iu\nVsQDD58SQdJ47AQEfVzRMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAyMqGCt2k2W/ZNu4cupr8K/3dOMexbrjjR3TjA+8MBsoC\nIHTzv6S0sgNkDRULXqpbFJEJO4OnieInYFCsgHSGE9er\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1230", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1230` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAYIZiGnHNVUE0EsjpEV8HmPSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmODA3ZWQwLWQwODAtNDE1Yi04ZGZjLWUyZjk5MGY2YmU5YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhkNWM2OTEtMjA2\nMi00NWNmLTlmOGMtNjA2MjdhMmNmNmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4GJrn0d1EmxbpAZzOh9kzOec3UIupsrmO73bVUWXoFDK5v3ci8brAG3M49MI\nXp1nHkTtlQs12Yxp60gqe3ZivaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgvLwpwG4Sc6sVDproY45nCNOLdwwHwYDVR0j\nBBgwFoAUO9neshhqB3VsT+7F2RQzdUZgFCcwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAmgwp\n0DraA1Merw+RBl2c1dn8odOe6HsU8XFjwUsmB3oCIFP6nYVSxarR8Z72oxyQAvT3\nl1O/ImJFlETzqznIfp50\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATN+X04Vq5+vK5qLtYgfmv93MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjgwN2VkMC1kMDgwLTQxNWItOGRmYy1lMmY5OTBmNmJlOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbyDTH5Oym4hnFwT5MF9+Me2YIwi/vkIwD1RG6XjI89cp/\n4Z/hbaU3pjJz6bYNLrbQ+pAFfhPo7qXfRuBfp2DXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO9neshhqB3VsT+7F2RQzdUZg\nFCcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM4517qU826XWVmPhXOJFGJXE2xoZLDRiV8lQhBO2CcMCIFj2pEH4+7kC\njcZUdhny7EPf32tP8P95nqw93srB2Hq9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXcWrKQsY6mtFJRf9UyWTZQ2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhkNWM2OTEtMjA2Mi00NWNmLTlmOGMtNjA2MjdhMmNmNmQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQwYzk4ZmU3\nLTlmZWEtNGU5ZS05ZDczLTczZjdiZDY0ZjBmZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE+Lx5VH5oeD2A3ngKkDlihYoMafM0kZ8z35bRhlk2nW7IEtcq5DQnqv\nb8MWNfJicW9oY79AnLCPeIzgm3Ega3CjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFILy8KcB\nuEnOrFQ6a6GOOZwjTi3cMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBLH2HSKtBXpKJXTzGdLNic6lAiwDu+cl3jxanUhQGW1QIh\nAMqFXnZXCBCCT1FvxCH7tz5VBSuXIzHjQxfHx3xmo+Rq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1231", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1231` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASZbWc0qeXt3ZULUSLIj1JB4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxODQ4Nzg3LWJmNjQtNDg2OS05M2Y5LWQzZTVhMTllMzY2YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg1OWMzZjktMTRj\nZS00ZGQxLTg2NDMtNmNlMWFmNTRmYmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe4ik4y8FGAKIO2c459rwXIDzgKRtrCayM5E3RRYGJ3UooikQzbjPxo3RHoSw\nz0gK2/WUwfw6vbVviiGWJCM71aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNltGLnJ27V5qqaso/ggJ7/o1gjvMB8GA1UdIwQY\nMBaAFIwUYOQLGtc/o7dk3H2c8rt85wx3MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBn+ElcY95m7va6fRn5fiL0n6Lzb+jxiVZM\nHDwwhUPQcQIhAJHuhUvuFaHXnXG0UQcHUTHPviP8IAEMfPvjqYNM5nqF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYD8F3xbTZ5k5UB3jO0K0eLLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTg0ODc4Ny1iZjY0LTQ4NjktOTNmOS1kM2U1YTE5ZTM2NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPk1rYUU4s815i0m0YoW5diKePAQtOyYKZ/9Ylq4JTm/sT\ni7Gh3dZalxfB2fctRmpa09L5fmKMVjNOqiIoGITso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjBRg5Asa1z+jt2TcfZzyu3zn\nDHcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKmmxElo14XC2sfaFT2miVnd9+F4w4TdeXzvclEU0hvNAiBcHRwtfIB2\n2Lp9jPKMpLzMyrha3YCREd0pdBNUZepo1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAVb+kzuPY7hHmkrF34qEK9TeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg1OWMzZjktMTRjZS00ZGQxLTg2NDMtNmNlMWFmNTRmYmUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZkYjU4YmUy\nLWE1NmMtNDg1Ni04NTAxLWM4MzJlNzMwY2QwZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLm9idO+nC95Tx0q7kKC/+NgybQFURCUAL5xAmXVGkdnFLTR/sIA/CeQ\nVSCkUxt+s/Ev/SPAHGrksN2yec8XMUSjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNltGLnJ\n27V5qqaso/ggJ7/o1gjvMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiB69+bxi/GgEUlg/EiBd1Q+EC5skm3q1aq2zV0A3lJ+8AIg\nRp6xG3F/sFscBk8ElX+djOQ3SeZOupt4D185YETKt2k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1232", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1232` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAaePt/i0/KMShDq7cn4e36a8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkNDQwZWU0LTQzNGQtNDU3My04NDEwLTdkMTA0Yjc1ZjBjODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjExYjk0NzYtNDc4\nOC00OThiLWE3MDItMGY0ZGIzM2NmOTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH/OjDZN609hV0iBh5t7P4wiF/gz9qvKz9AZ7haR1kdsOypOLPzmOsbGmFPRd\nW/TyOjt9WX230ZmOgj+ZajpYGqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJl0xKYy9kEKqPd7FyVjCb2Rtxp4wHwYDVR0j\nBBgwFoAUsCurosrKyjnOoU4BGk1YVIhfuq4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgSN5mbQoqDIbc\nJMp/LDYCPfzMT1tfJIAqAqIyf3MFWk0CIHfxHAcvi8oXAbq4//Y+pxvQvVgbElWc\nbhCWVlSZsFgH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW8zo3qttVQ3PrKP0XRpqg1eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDQ0MGVlNC00MzRkLTQ1NzMtODQxMC03ZDEwNGI3NWYwYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFoznrWXpPtI2Lnd3uuIYDnQHvIpWZj41IyT42BTVVBDPm\nwMXmTkQkoSdRftpJxiEL+QcgXRiBT8RHr8Q+nMa7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsCurosrKyjnOoU4BGk1YVIhf\nuq4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH65AEzFtMps7wJiUNpe2R17+S+QnushG1aCBO2oPGl8CIDx90YyI5Z5M\n1HDx5iqn48T9gzt3TUJahBUX7QFGexTW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdRoCdJWxsW9b+ueCriSZNk7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjExYjk0NzYtNDc4OC00OThiLWE3MDItMGY0ZGIzM2NmOTFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZkMmM2YTI3\nLTY5ZmYtNDFjOS1iZGIyLTE0MzIzY2E2OGNjNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL5JdgSwS/4xAeaN00W29/Le7AKlIUwAA+RgZDqD9jQVILezQZmY+TOJ\n9fGsIWCWZHG6TRcK3JVTay8gQxH42byjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCZdMSmM\nvZBCqj3exclYwm9kbcaeMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAy8AFWB1j3hsYI2GFR896yMMLLHr/OWlOLvbsWUJFJJAIg\nG6oqtTAmw93kH4GWyZKP0FlS1dL6a4Au3IySZf5bKl4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1233", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1233` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbuZz86Cg3ktSGXCd4XdJSt4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwYmQxZjFjLTEzNDktNGEzMi05YmUyLWZhOWZmZDUzYmZjMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI2YjdjODYtN2E4\nOC00NjNkLWJiNjUtOTU0MzI5NmFiNTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYy7K63HyEvuAoT6imrvroSkIMV3ks+X2+FV9y2h17jlblwR3LV9IgD3+xEyz\njNNeny0iog6ZEAHfRPgJfuraEaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwATTPRG6xuzxTU/Ys/4m3nxgJE4wHwYDVR0j\nBBgwFoAUwkfTDQ0szyAOfnla+SA8nK4Zd5YwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKuxzIT705BK\nwGEGH8cc+/V+3p5mm3x/TLONn23kZcuPAiB6Svhzv2EtnCx11nHAhO5nVpaxL0Xd\nFDc0CgB8hYidaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAccTBIVgy40ssXAkJv/q2c6lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGJkMWYxYy0xMzQ5LTRhMzItOWJlMi1mYTlmZmQ1M2JmYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAT3ifZaQeGYSBVRA8JsGudnamoixwc/oZcrbNVl6+D+oW\nGmVuKfGJethnh+DIuUo/JFa5e8kBFeV9z1ZL32dQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwkfTDQ0szyAOfnla+SA8nK4Z\nd5YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANBH5TEddHpvEtjhqcWWyRsQyHd+RJdjJ3P/L4+9/XtVAiEAqPyrllzy\ns5vHcGpONX3iOxcmUqscpf9/8B5X2BQr+Gk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARAIt13k+DKeZfu8pd8Zv8SAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI2YjdjODYtN2E4OC00NjNkLWJiNjUtOTU0MzI5NmFiNTMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFjYWE5YzMz\nLTdmYzktNDdjYy05OWQ5LWJmZTMwYzk4ODZlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA/B//4yMM15OIcCKivcUIl+XW+KK9yZQgIWYT9jFMZyWsZWfuK1cqui\noSm9hgKHbFUyngXLw91ry5lB7JK0TTOjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMAE0z0R\nusbs8U1P2LP+Jt58YCROMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBTdjhblo2ooACsxrcJL6H9MX0rrIUmTomqu1CPPE7wuQIh\nAOi5yd4ykkvn1kLfkO9SkeCxznSSPFbi8+eg5UQNTpB4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1234", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1234` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYIEM/XnKlUYlVt6JPMhc53YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiOTdhNGE5LWU4YzQtNDM0ZC1hYTMyLWVkNjliMmYxOGFhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc4YjA3MjUtYzE3\nZS00M2VjLTk4MzgtNGI2MDg1ZjE0ODkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmjdch7wVSkn/U+jMW+CDM8yMfS83qtSZ3X6Gv+DVeVYi+d+nEFImdv32j5X2\nGKMN15ctxdxmDzupcXfD8pM2U6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaYUUpsaanryd5UFy8a10QPKWc6YwHwYDVR0j\nBBgwFoAUi6tTLGq0ZfUhVbNDdi0jtOK6T2QwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCbEfNasxqn\n64gXgtV2viKyRMKqHF0rFkmBV40iKrDNxQIgba9D4zkwTD6LnwAYyJaeoalYySLG\nAQlQHWRuzA3XEHc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYC5qBdNJibAKEdnD6pWWI/CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjk3YTRhOS1lOGM0LTQzNGQtYWEzMi1lZDY5YjJmMThhYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/eFhLspa/9e3exPfgVxZUTgHCX0AE3gDahSFR3dSgAA9h\ntqix6lFXP7b5TYtmwabjUrni0jpsdIR1DQUXgAiqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi6tTLGq0ZfUhVbNDdi0jtOK6\nT2QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALRnIbCdNis3ldmcmtA2zqGQCVOIJnFvdjY5H+6oPzvzAiEA05EDTrZv\nb/h/aMfaFGqsbjMBdZ3+2Q7uavRJnZ33R1Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATe+0U+mhZpkW3PHiFDni1eIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc4YjA3MjUtYzE3ZS00M2VjLTk4MzgtNGI2MDg1ZjE0ODkxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA0YjUwZmU4\nLThlMzYtNDNkMS1hMTM5LTgwMzk1ZTMyMjg5NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAeJNhdOHlc+XQ2WwDmuw2GGAYkLU8m67cx7f9NlRcv+tghh6/TptErH\njqswMvRhAD0RKeFti/SAWIqq9rbzWgijcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGmFFKbG\nmp68neVBcvGtdEDylnOmMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA6POiT+ig6qZLzG1fMHN1XaNqhtzhnuGoR0IRLHRe/u0C\nIQC4t6NUBM9IKppFC4vLU7msUym8VkoyMPnQr+lwM4GBvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1235", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1235` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcXuFmAoMQ9BJP2xG9q9v4GRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4ZTAyMDA1LTJmOTEtNGEzOS05MmQ5LTllNzlmYzk0YTU2NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBiYjQ3MjYtMDI3\nNC00ODQ3LTg2MDUtNzQxODM5MWQwNTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9SDngNmUYqJZz4y0LQlviDT/x+BvSaEaG3Q87ndqTrejatsIlh435BI1Ini9\nJtiPhJ+LNNtMWElwSAh8fQvvF6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQPFQSDzZXCVwQKFelNeWJnwOu/MwHwYDVR0j\nBBgwFoAUZc2HO/rK/vwt6lySeCXuXil9cqMwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDUanlj5g7gD+as/U8uAaM/qdjGsaCSbSpW9Ig0YwskmQIgd9120+IjEeTe\nu/nljivbTL0w0x0L2cD9UJfUeyuZhl0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUf5LS+tog+qWUOAw2Eols/AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGUwMjAwNS0yZjkxLTRhMzktOTJkOS05ZTc5ZmM5NGE1NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTguTnJZRPjsNZ5OU5muuxF6xjc8Aethjf1xcvCr4noYVx\n3bmCJWcNbRHrddE7HvffdKlXmZE1qg6SxeLRY+dOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZc2HO/rK/vwt6lySeCXuXil9\ncqMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDcTSRmHRokZAKMuP3L1+gQ8UQlObv1hK6Q5Dx+FNE/wCIEoeyWMD9Bon\ntA+ZyZuNIh7UQIMMzd3C/8Aa62QX9Gmv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAY7gI7Df6WMkVIOCNOQEZNRcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBiYjQ3MjYtMDI3NC00ODQ3LTg2MDUtNzQxODM5MWQwNTE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVmM2JlMzA3\nLTIzOWMtNGZiYS1hMTRmLTdmNWEwZDA4N2Q1NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBKW0zmM2hzb8LOOYKBAgVJYA1dgx3Yx9TkM33h6Q3Ib8gRH7/mEjuj6\n4MNS88e4alHlsHbD9ozCx/Jn1uMAiu+jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEDxUEg8\n2VwlcEChXpTXliZ8DrvzMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAgYLTC5DKz4Z8mcDCydXYpCD9pmhR/bv3BaKCoO98p7MC\nIQDQo7MheIdROyBSJUUglyHGBwUu27ISUoN7pyck6KM+Yg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1236", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1236` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZhiFHrHsY7WOz5JM/jjhOfAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczNjFjOTNiLWQ3YWUtNDhlMC1iNGFkLTRhZGQwYWE5Y2I4OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UwZTc3NjMtN2U3\nZS00Yjk1LTliMWQtYjA3MGViMGI2NzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyomZu7WJVTK0088Rz87sbztD34sO22QmL0KGmnMXF9aUyxt/TXAJ2bQSyhP1\namiQXetf8SpNqAalBmQQFEqF8aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKngFTs1IMAEIfrDQYQhuq0hkt/IwHwYDVR0j\nBBgwFoAUPTlNtX+VsQkymNPT100jhd/i7FAwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDxcU6s8xy6f3M/mtJC+B9tnlvKYMTMsfcLXHfAKqX14AIhANf6vNrbv/56\n1dAP7Qo8vf6YvWSE1tsiZ/mMd7zNKpBZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAacHia6/lKDbBUEc+rvBiuDyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzYxYzkzYi1kN2FlLTQ4ZTAtYjRhZC00YWRkMGFhOWNiODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARM73LYiEf7WVfrA3/ot2YjeG8HPslAO71TeaBSDWdueJNQ\nFR5QmpVQmudJjORuFcqfbF5Ie3purA6RKxwz9Jooo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPTlNtX+VsQkymNPT100jhd/i\n7FAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKJkFGJYXfk7YQnFb1AGiPx3u79wYGFuGYzM5Ptq/1fLAiAjPb+vnz43\n3H7fK+ozR56HxOa3+s2xUMn0HNU0tqXO9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAeyt9U5YrecRodb8lipnAUaKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UwZTc3NjMtN2U3ZS00Yjk1LTliMWQtYjA3MGViMGI2NzY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIwNDI4YzQx\nLTIxNjQtNDJlNC04MDk1LWNkZjNjZTBmMzNjMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJvx0t4bJNCQDe8VI6yJPhQPAMlDoB9ae1r5oNzE4dNLwqP8QYhtNDyc\nCMR1TTk0Ix5CLGAvhN2eMokprZlm2+qjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCp4BU7N\nSDABCH6w0GEIbqtIZLfyMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBSYtvi3vfdEbJizkq6Z5C+Hl/Ml5EEUUsESJDxs8tW1wIg\nVlJyhWvEjKg/Cte8fguFUmHU3JYth/Jtic0Dgkkh76o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1237", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1237` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAbZ7uvQrjqudGLHzn9pIeBpQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5YjgwYTdiLTk0ZDUtNDE1OC04NmY0LTVhYmU0YjJmZDZjZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRjZDgyZmEtNWRj\nYi00MzYzLTgyZTEtOGZjZjM1NDM4YThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9ZOXDAG3lR3nTCMbF0Y8NNgqLZ1tc3d5XX1qDisCBrSp7ayhbDYO5uVOjIhv\nY3Ak7I310wgMn9sabvmWp3C/caOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/JftFtlsTStgAdWG6o3563IBbeEwHwYDVR0j\nBBgwFoAUp8U+EqNsN1rqMxOUyai7cSrKpp0wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCJ\n2Bwmndgu1dYLRWoNP0Cj5sKdaRKxI6GoL4+IY2L4UAIgCXZWumzVRIMyqMyNvjll\n6ITSF4EQ4VNqu7b7pv+6/Y0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWpEfU7OJkavK+znx3fYD7AyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWI4MGE3Yi05NGQ1LTQxNTgtODZmNC01YWJlNGIyZmQ2Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkyAYuM+aH8SnlUW976nOp+vb0j8NJXo1pYz7Mqr0CufL9\n+qzVXFCX2LCj226mb/760BY52MvMdncpRYvS62q/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp8U+EqNsN1rqMxOUyai7cSrK\npp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPTziEfh8xK4o97nirJYt1FLcyz7ikW3YEFPODZDod9+AiEA/6YE8VVn\ncsDIEzNe5NFFZNh+Lj7jnUw0QCVAuoMi1CI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAS9aRdk8MMm3ziNsVBQWRgLLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRjZDgyZmEtNWRjYi00MzYzLTgyZTEtOGZjZjM1NDM4YThlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM4ZjAwMjYy\nLTEyODItNDFmNC04MGFhLTdkM2M2NTliMjZhMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDsZQRhrcuGtXTEvv34qQs+rnZ1LS77L795V/wXYaFKt6nksGcrGc3wT\nk9Jw1GwuDVonfPrcYPa/zjiOwK02oe2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPyX7RbZ\nbE0rYAHVhuqN+etyAW3hMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAqvHPbYnfYAWHiosw4y63ZYyRjQMQyUkAgXy5hBQx7xAIg\nSE+uU654tlWYev0R0kaRqvN6cx61Ri6eisfJutPHWwg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1238", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1238` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAS2ElhJ0Xz0tKVm1BGOQ+X7EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyYjU1NmY1LTAzN2UtNDRiZi1hMTBmLTcwODhhMjJiNmZhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA0NGE1ODAtNGY3\nZi00MTc5LTg3OTAtNmRlMGQwZDk5OGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjm0pBffoKhqzr5rUiCcUMPUXgG2Kt6WWJdNWRTXSxzCyo18ExVcJOHdhy9Ir\nW+na2FbEo7CcDgRAwtio5bTzHaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnCHl8VqHp3dd7ey2na3Q31pZ3mYwHwYDVR0j\nBBgwFoAUmu1CSWd9HRqkFJdkd1C3op+Nts8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDhRuHpdwS6OHHxN1sFjBk/PPiMlAFmdQAlVZKf+pdg3QIgeA/R\nSBOr0dOwVaU2qaZrwgY4EBVYb0EEhARZnJcwP8g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASaeNYA0eHFhePLwMqgzsMD1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmI1NTZmNS0wMzdlLTQ0YmYtYTEwZi03MDg4YTIyYjZmYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATT8+p7tqHL6T/pUWmKqPscatcNKWQsanQv48kxM6OEuMOJ\nhbM3sIec78oTWM4KnKm0kN9ZDtcsTrxEQw3ieRCHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmu1CSWd9HRqkFJdkd1C3op+N\nts8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNfphkOdjUPtvH9QTVdzcBLBxW7e6dkjFvUlWii5jyJgCIEtpJfn5LIZr\n5wAxp8roqCQ81OKbUbNlOQA7AutS4fNU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAS/0V8qmrCewIYlnDu5RuXg3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA0NGE1ODAtNGY3Zi00MTc5LTg3OTAtNmRlMGQwZDk5OGZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1MjNhN2Qy\nLWE1ZTUtNDNjZC05MDQyLTZjZmFjZjYyYTcyOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIoGWCCzcwiZPbFh608LF42d+cB8/jMlYj6DRdqkjSCt6uKmt/BCC/f/\nxkZ4rbwWMQDcw+BnmMaLGwq3AlsTXa+jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJwh5fFa\nh6d3Xe3stp2t0N9aWd5mMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAhexTkCz1IAcx2YSGLQ5ubWNkqgboqUeALoHdc5XVepgIh\nAOFzMDMIcvCrLtXI2KNowm/JzKE+juci3nf1qX8gYi0c\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1239", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1239` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAfPm4EaVD8VL6x0qr8ndhiPfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyMmI4YTI4LTlkZWEtNGY0OS05M2MwLWM4Y2YzMzMzYzI4NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IwNzcyN2EtOTJi\nYi00NzZhLTg4NjItZGEzNDlkNDg0MjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjO5nwO+ip9ks75VM4AixkXz+1O+IDi46Im5/+gSNDbOjtsiWdngReGhBlTZ0\nBotnOdBpuYLMkqXV1XLc/a6BXaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgfPjQ+hzZoeTNAj3irpe/CKXnDowHwYDVR0j\nBBgwFoAUqddtVgQGAygZ6hz2JzHGxyZZM50wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIG1Xo3OuvYvDnv3n2VEt3TNg+WiVaQCs0+p+s/+r2aRrAiEAkZ/v\nTs8KQcry/yKs6I8TEqjm2oa6h4NEp/WUHp682Fs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXSvBt+SNoZTWRBlw7nCBeHPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjJiOGEyOC05ZGVhLTRmNDktOTNjMC1jOGNmMzMzM2MyODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASs+YtnVRtlRjbf4u3a8dlbxv8crZZkVZ5Qg4ExBmokfOda\nt4n9OmpOJAK/7Z/CQBSWDqm9xjwzd3GUDVh0t5R9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqddtVgQGAygZ6hz2JzHGxyZZ\nM50wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAICTnWCm+snl9DEAgHOqHC8U1iMQayYe+KmDRTn/8oeFAiEA409MUlhT\nMsF2dRZaSDDadV0MCHhB4dkdwz3ESVekTr4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQ1zj/9SuRv60/vAvOrjZQ3RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IwNzcyN2EtOTJiYi00NzZhLTg4NjItZGEzNDlkNDg0MjA2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdkZjBiZjQ2\nLTAzMTAtNGIyZC05NzE1LTdjZjlmNTVkMmY2NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNPWce4G5e2KgVVm+N+kVReGzm9gDGI8zZkGfXVcY36BGvHdERfi+S39\nX74+jg9a01CmLy/wFneW1HIIp1U3h76jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIHz40Po\nc2aHkzQI94q6Xvwil5w6MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAzfchYpsq5dSTh1ofnG/IVzBG7/c9dNsYBxAVJAmH2rYC\nIQDy06Xf8RYyCvPtZ4MMSMdPcqDKCayGGO1aa98eMu2rUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1240", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1240` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISASTiVAZUg12gnsXgc5YYovDPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2NjgwY2QzLWNlMDEtNGNjNy1hNzc5LWYyZDcyYWU2NDdhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk3ZDUyOGItOWE4\nYi00YTkxLTg3OTEtOGE1NTdlNDcyYmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzgU+yl1pys20lMUdLsnO7xwCmFWPgvTjDzmyfGO2o+lu74TefpxziXEXhfjf\nOr27ABtANfxC8qRsrDnNcpl9V6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIqtW0BrwZKsyakuyR4XpfpjxYfMMB8GA1UdIwQY\nMBaAFLRVg79NudX8aUDsVWz86wfamw0NMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBFQSFWrxeNS70TvmKbW2Ytfk+qKwewBpV5\nxxLq48bggwIgMvc6x+Hnn6RPajhN8io5WBhPxGjurGWCb2+DBKsxKbg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARDGmqrMFSDdc+ug0XIuW7HAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjY4MGNkMy1jZTAxLTRjYzctYTc3OS1mMmQ3MmFlNjQ3YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEmQRku5/6wEVwhwTyVV1+ZznhaiSesrlMX6SBiqMj+CvF\nrViMw5A5ACCJEPCOwnIiSClOVCxhiNT/gmZ+cLQoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtFWDv0251fxpQOxVbPzrB9qb\nDQ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANkEniLhKAbUmSIKAynqN75b1nSrBgwVdeX7EaBywT2UAiEAp8TifFzQ\nsBxy4xb9ZnpsCAUdCjLBHOHiVrMjEEk0kPY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAfAU7gblBxzc1iRoFLRtk3v4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk3ZDUyOGItOWE4Yi00YTkxLTg3OTEtOGE1NTdlNDcyYmFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc1OTY2NzI2\nLTU5M2UtNDZhNC04YjQwLWNkMzExMzI5YjU4YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFtEX76I3++osCijQb0DjJWjQo3adMzqG39z/37dFVNH2EpIttFshCNg\n7GwUK9XGd3UGhxHC+E2KwK9xvfMiLX+jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIqtW0Br\nwZKsyakuyR4XpfpjxYfMMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA8ZCm1qY9knD0hpPRnKwgXUilZUxhfiN1v74qlOG1LVgC\nIQD0s2q+vpOzALubqOFz5Y6lw1S7IAv10Y02hQqBigg2Tg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1241", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1241` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAXQmF9tNVMiy5xR5VUjq0il9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzYzFmOTk4LTc0ZTQtNDZkYy05ZDMyLWYyZDE5MmM2YTRhYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgyY2YwNzctYjU1\nZS00ZmM4LTk2ZjYtNDNiZTJmMzIyZDMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4GkN6qiz0YwmR2oDuGthh3BOpCZGWwcp0xIXhh7fK53gJ/npzWPyDSGP91RC\nLQPpBNsMiUJVYTX8ZWGP4/wBYKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO3EvV3MsH9UU6Xo8l4Ni3BLd+IEwHwYDVR0j\nBBgwFoAUkg8qajaNnHen0Wh4F6cpZvEoY4QwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgJ50aHGSBPHb4\nAJjT5uJDZVeKuxPYPwsZyzAqVFIVy48CIQDXwUOQR1jj/JVJ1z6Gy7arPBvhTPkq\nPkGdnMrXPqJvHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATO66WscdXiqsJ4Rw6hKHVS0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2MxZjk5OC03NGU0LTQ2ZGMtOWQzMi1mMmQxOTJjNmE0YWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRYi81C/DSXqhUkFpCjpIfX980dUOM28uSKq1DE4CrU65e\nInhe4D5/uY5CRZnH6Bmgm6ZLOaL8xaiJ1S/VYiIzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkg8qajaNnHen0Wh4F6cpZvEo\nY4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPkS8NBVwHDAVH1T/1VmzM2SumSQwwZHMi04Kc+Qf1BbAiAQssf0HNwH\nbYEASHGISpDiUMrDdsDOOMBwFT02YQzhMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAQa+4sRN7DlFSI87I+d2dWF8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgyY2YwNzctYjU1ZS00ZmM4LTk2ZjYtNDNiZTJmMzIyZDMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM5MzdjMDUy\nLWI3NTYtNDhmMy1hMWU3LTczMDdmNThjMGZmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFW+R6/hw4jyuMaMnYz1ndBkvUBqFcKbneIaQPZikKSEOvQJtSzSqZY3\nl39jRbSm9FVpUZiUwcG1dBr+GAVJ/+GjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDtxL1dz\nLB/VFOl6PJeDYtwS3fiBMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiA7fGzOok6myPViIXPnfItkVYibO0HqsR/1o/4n8xBV7gIg\nNgR83wBqyvVyUkm03YlAPnXJaPpb1oyqO2Cs1YW7O80=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1242", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1242` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAa49iHzQfU3Grp5jR5R/5PdgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhNjY4MzgwLTAwMzctNDQzMS1hYmZiLTkzMDc2OTRhOTY3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjEyOTQwODgtYWZm\nMi00ZWY1LTkxZDItNzk5MjM5MzYxY2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtJ2WVt2cCKPlSINo0NCo0crLH21Xy0pvOY6YNndLY1x0D72236PcKANedftz\nPHfJQg73XGGXAe1MNRhpcU5+haOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1bCAEvV2i7lMqiEDvd5xsn8rv8IwHwYDVR0j\nBBgwFoAUpYUDOg+1SOmB0Da6hYJobZO+ZdcwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKfcn5LRb0M57\nHnwe2SJ86uw0/4M4jE3xf2H37947bsoCIQCvhNXqdOSZ6mAJjbVAxhSbY3vXb2+A\nf5MsA6pIv4s5HQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQvqZYTvgB643iUCwz//gfj2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTY2ODM4MC0wMDM3LTQ0MzEtYWJmYi05MzA3Njk0YTk2N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH6+o+haLj1TJL+T5hyF42/B2Y8jRuxdt2Wfm+3sDUY6NW\nTdCucSGicxrc4aZO7f/GITmH38UiWxZT2v9ubpZGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpYUDOg+1SOmB0Da6hYJobZO+\nZdcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIqS4aeIUFdxzXEANA4fSojUNHygEjZrYfWVVhijt8GsAiBCPW1CubLi\nUT8k+MSd/0oTNcHRUMnUQDSYmrmSzLWfXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUSNWN/C0myQ9ps+5rbTLCfCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjEyOTQwODgtYWZmMi00ZWY1LTkxZDItNzk5MjM5MzYxY2U1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlkNjhhN2M2\nLTI0ZjYtNGViZS1iODlmLWNkNzU0ZDlkNWY2ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHORJPTi+HYvUTvoH5s1cqbwF0QKP5cwM7b/2l3jkY4YDPN4lpZujPqx\nYXvnwklh+0vKmEyTf+g5VBLuPVUUvvKjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNWwgBL1\ndou5TKohA73ecbJ/K7/CMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAlVAJ82XGD8WIsuzURTYPjh4JeMXt6hOELyz0PyE14q4C\nIGC2yCTppVJuVAbOcD2SiQnqViWZW/BJkF4qoKyqiATl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1243", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1243` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISARpQeaCEW8PFiDiOhVhl9LeoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3NTZkYWNiLTNlZDEtNDdjZi05NTA1LWNiMmFkNzM4ODFiYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWM5ZWM3NWEtZjc1\nYi00MjZjLWI0OWYtMDQzNWFmZjllNzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQqk1VKPCkM7dYaRmGr8UBRKyWZsUMZdINTc7JIbQBe4YN0sdkNorJR/OxmV4\nOaWBAlOohzL6lhKbooRcCSYRPqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Wbio/A8ONfpMrcp1Lsftql1HB4wHwYDVR0j\nBBgwFoAU7SWWKrrZUpGQ2AoQBSeoAle+UrUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICapyVd6dUQR\nrHjym55EzDp1y2bFq8MkpTF/q+dZbdgEAiAz/ILRdJi+GFB4clSCzWvbPw04ec5W\nAtZPQeysOQnvLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAee+afZptp9XvHZM73MFOrDdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzU2ZGFjYi0zZWQxLTQ3Y2YtOTUwNS1jYjJhZDczODgxYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWR1FwuYICnNevJcSfw9gri7tBbK/ChhDn40r2S4l1KlyY\nnkKuPL+i0OGFwqwqHgRTDxCbVsiwKouNhFGEa9oZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7SWWKrrZUpGQ2AoQBSeoAle+\nUrUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaCNw+f63EBJMhopOYFOVHQ3IjdLnzEU7DqlSiRlbGI4CIQC7eMFJAR5G\niw9uKGL8CisZ9t4PhfwoTdz7bDUUr3hD/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAd1Na9O6PmZW/ljoR1ZfzrA+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWM5ZWM3NWEtZjc1Yi00MjZjLWI0OWYtMDQzNWFmZjllNzFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgzODc2YjI2\nLTBkNmUtNDY1Ni1hMWFhLTJhMTdmMmI4NzZkYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOxbQzbmPcv5BICl4c8MNxuQRau/Y5TpCyJXuCPRd0Aor+222evgN/aN\nqLXfjujoWyLa4k1bmLgUs95pFUUJJ/SjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOFm4qPw\nPDjX6TK3KdS7H7apdRweMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBodQnrFVcjfeMEdy+mEfkDkSPnOsocumctJI+nx6iy6AIh\nAK22QwivdRITXHoNR57sRqltE2KAZVtnYwYzZCLdc790\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1244", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1244` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAenbSOg5QqnMhOrF1YCiJ3hjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3OTBlMDViLWExNjItNGQwZi04Mzc5LWRjMTY0MGJkYjNmMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmM4NjJlOTQtZmFj\nNS00MzY5LTk5MTYtNjBhNmEwYzM1MWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzWhqvvcz6OgumCmxF4HSHwA0+82h8kgC01xMvuA2I8FbVHM/W3RRTBNn80fZ\nPSRcx82jIzRSiJJQ996o8B8ASaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX+ATEpGUcXGJbSewEm3QtDTc0iQwHwYDVR0j\nBBgwFoAUwQtp6QIveG9rC881TLUrdKlLx6EwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC1P9WiUkCa7bC9N3SCQXnPYMhwEkJYJIm4flGhF2EG0AIgNNxhZqddsgOJ\nEn6u4ECwHfrnROhreiIkdF0Dnh4q+s8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUFnc9T2xnqGfjrX3JZC4yUVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzkwZTA1Yi1hMTYyLTRkMGYtODM3OS1kYzE2NDBiZGIzZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdIjdaX0HQxYXdIt9lEmhExstb2ujrjycW9/8zP7CxIIEP\nbgvHP8IykEIuPHOuWqGWVYclONOU5hSnvCrzU/9Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwQtp6QIveG9rC881TLUrdKlL\nx6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALkKoX+fQaTuXs+U+oOAUzk75vyPqxibCgLOf5F2ZJl2AiEAiaCWJSIy\n13gVsm7LQTz8xayDnvmTPyLoNA9UGJW/VJo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAU0Qpy9SqNa1/6sIm2EDCBIhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmM4NjJlOTQtZmFjNS00MzY5LTk5MTYtNjBhNmEwYzM1MWE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1NDlkZjdm\nLWYxYmQtNDk5YS1iMzc0LTNiNTkwM2I3OWFhYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMj8HWumWs9uWDqx3bl+fNT8jCKdHR6LeY4QZzj+oGp3AvR2p58h76gQ\nIZElffgDYbdsHcZfoOtMHZihTvhA4gqjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF/gExKR\nlHFxiW0nsBJt0LQ03NIkMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiB9HbcpJ+uFtmZqNbdGyqWSPjEQJaqYnksPjhbSCBX7kwIg\nZA5h77nKZovjv0hA3g7XRBHPJfdfuVx7FLVyGkYPxG0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1245", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1245` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXaVkoi8mzXA8W3UqInNMsFFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2YzhkZTE0LTJiODItNGM0Yi05OTlmLTg4ZDNmNDQyMDY0YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDU3MGI0NmItZmZm\nMS00ZjQyLTk5OWUtMDE3YWUyZjA0MGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5LNCYH5lzNKa0W2w1ozwIOzS+pRxJ27ffTZx0XE3z1vG1Zq4TUB4Fe3fvYTb\nX2RAxtvOOxfJmf73IlgouvbAdqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGIhx4yBq7PA2/wEAQBbLx/NsCAQwHwYDVR0j\nBBgwFoAUNKSEYFLwIQOVzqwVr5nALZrcrxcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCye0HwFPrjnP8PIoxa+C/74K9FapVEXGOCWY2u7lUEZwIhAKY3HTAEUlc+\nJXhCldpJ7qZZ6OZBKFMEaxw6eYoVLxPY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZVBNbxYZ8BogEczIkmRdZejMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmM4ZGUxNC0yYjgyLTRjNGItOTk5Zi04OGQzZjQ0MjA2NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnBGVhz+1jH48zFj/nmqY1rscIMvtsokEQusHkqEFMqUK8\nUHgldpLAzlSLWWV5ytodJ+avJ9YKzM5B6LkdsLweo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNKSEYFLwIQOVzqwVr5nALZrc\nrxcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALAGzX6+X/1nEWNXlbWyevHRD/KG4jDSuAtah+jmxwrAAiEAnfX+c3os\nvgK+bmeaKiWD2sZ1oXRLHS87Q76gcME4lkA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZOWcUs2CX31RrIP5kN9ylIEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDU3MGI0NmItZmZmMS00ZjQyLTk5OWUtMDE3YWUyZjA0MGRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE1MDM5MGZh\nLTY2NjctNGYzNy05MzgwLWU3NjZkZGE1M2JiMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP07GlMp+mXwyOQwuy2jy14vd3zDJ9O8xUziCulN812/cTzj/Twaq8S8\nUwhlum38dcuVxzR+tXbDfMB5tVx/0MajcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBiIceMg\nauzwNv8BAEAWy8fzbAgEMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAxM1q0Dfx+Tf3IbparTPQ//rAabfcwZ8vKQUirH0d6sAIg\nd9enlzzD5tFBACEHBpjTwVkEMzKsODfNs/zpq4mlt8I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1246", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1246` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAXmaSTYuR2DJhuD8yCu/q06GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4MmQzM2YyLTZjNjAtNDE3ZC1iMjMwLTY2NTVkMmUyOWE3OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQ0ZWZkMDgtOWY1\nYy00YWY1LWJiN2ItNDIyZGJkMjI1ZDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELmWSMIBpCwbuC4HXLeZsD7MEwAkTHxdgYfTXLh8GF23qvQNH1GnElR43X6U+\n8WswgLpPSPXnA6Y6tbUQEYWlqqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhRA4Dlmq6dVbd/TO/0kHvUq8RhQwHwYDVR0j\nBBgwFoAUPzIDDAAiHT0PjsuQ5bb9bfWnu1kwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCy\nlF3MOjliv9HB/DKQbxmlgRiP9IwIQlj0bb8qjwHu/QIgYuvVUQzBIZsaDrq30NEb\naiN35ql4+2Wrn/E9mXsWaXo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeK1cNK7T50MBTjdemiLpDDuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODJkMzNmMi02YzYwLTQxN2QtYjIzMC02NjU1ZDJlMjlhNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwFDxEGzC4nLBdXVSmqne5IXyolRcBfR0zRPfmGPZSKLgZ\neS4nkTuvMLhw3d3aT9npi1mjiSiljW+wgT1hbiR1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPzIDDAAiHT0PjsuQ5bb9bfWn\nu1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPZdz22JHPhUPFeRpNObnfMsf2wVP5AvCLgyQBdt1Hw0CIQDnz2alEoY7\nRpT0OB8AVBL/yBA8ojEpgxxWJKKmLSLuKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATvlN1WcFId2IV30gJwefVPCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQ0ZWZkMDgtOWY1Yy00YWY1LWJiN2ItNDIyZGJkMjI1ZDcwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI4ZGFjZDA3\nLWViOTYtNGU5Yy1hOTJjLTAyMWM0YmJmYmQwNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHZET0Uy7+C2NlONgEMjS5/cbd51qQilv9bBWvjV8grzrsAYig+HGhVg\nDM1+xO4MPkuE8kqJ6rl37mhww9SwxVijcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIUQOA5Z\nqunVW3f0zv9JB71KvEYUMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBAb8+9ku2NG6D7NUSEG/c1L1SYDK+8/WOoRWX2+3DS+AIh\nAKQjW0oP2WTMVfMMQj5FmFkLfOi7l9Ssg3TlDqTytnU0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1247", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1247` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAdww77Ql30IzNhYI/BJ/nU40MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ZmZiZWQ2LWFlNzYtNDY4Yi1hMzc5LTNjYjlmMTU5M2YzNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjIxNTFhOTItMWM3\nYS00Y2M2LTljZTMtNGIwMmI0ZDRlNjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnrOIprIHOy2J/bBJvg6E5QDnLOEq4FQszc32NNVf8F+tau9jd3Lgc3pjYEvy\notoA56QiWGnZ5xus1Cw/Yyy5I6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqQsT6uSg7/yzVQe9oD329AMAoFYwHwYDVR0j\nBBgwFoAUMGai3uPDt63JDHDtOW6yEv7h/5owOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEk7cjAweqG6DPsPCC1BVCRG+4oCdG+Bj89J3LNqQxQXAiAWKVym\n+8L0KEt98XDp/2bI9C1PUlSEcN5wTq7UM7AhIw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARnhNO0zTDM/P4TO2nGwuGYbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGZmYmVkNi1hZTc2LTQ2OGItYTM3OS0zY2I5ZjE1OTNmMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATInWkZ+S+t9H+uwsLKi/HYl4feOynK4G4VE5bkiRCRW1Lb\nM5AEFtj6MxPOZRLJv2kvWwp2ltr0aqZpv8QdzbRoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMGai3uPDt63JDHDtOW6yEv7h\n/5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMJuh8pMZt9IJo/Puvdm1NjxQeOZb8TWseUPQJpF+mLdAiAM6dvqrxLp\nugjv+ArSHWiFDfZcYcGNbmaT1LeeFJLhVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWsucXYuhzI3NJmO4NRUF3tZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjIxNTFhOTItMWM3YS00Y2M2LTljZTMtNGIwMmI0ZDRlNjUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYzZGNiM2Ux\nLTcyYWItNGNjOC04OWJjLTZmY2RiZDExODk1ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF1gePhmsUIve2e/V/LAzJ/L7VEY4QVI7pclosf2pcFSStwNDNsD3aEY\nGX+B74vhFY1NgZxxgmMbndtt0dnnhpmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKkLE+rk\noO/8s1UHvaA99vQDAKBWMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiATLj0X+uarh1T00X2DYueywUVU2YGvqcFsbahtKn7RZwIh\nAIdELpGPMY598DNV7GFLkLtQGEnbJp6cwAX/2+L5cbr4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1248", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1248` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAQF9ziq4PaIKUg/rasXvh/Q2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlN2M4YTVjLWQwYjYtNDdjYi05ZWEwLWYyYjM3NzhlMmNiNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgzZjk3MDktMzk1\nNC00YjhhLTk0ZjAtMTM4MDQ0OWNlMWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGB2eRwxvretrNRUpQOZOFCvQEWLzqZrVwnLcnjjOb0qT3uhxcZwpe+9KOwQJ\nbJE665rQwZi7tRsIVBdp17rQ7KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpXveuD9f2vw0ouoPIJ5R4QfpGx0wHwYDVR0j\nBBgwFoAU1c042mF78dAALErGc/XPWbh1eaUwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIDHz0UiSOY2dEBi4cgZV6u/EK6bBV/CI786ZUqdbOZUTAiB+ECNH\nmMJR8qJ4faImbnDHfsHygF3ZiSCkIlg5MZUJQQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZEAxbUP3IznlyIeCPFlpTG0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTdjOGE1Yy1kMGI2LTQ3Y2ItOWVhMC1mMmIzNzc4ZTJjYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDmWBhwbUsSDWUpp6IwhoabktFE7Xvz3Mr0NgTcZs6z0yN\nSa6gkBcuUsD5O2Vmd6tkQrj/3gLh2SPUStb/8ggxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1c042mF78dAALErGc/XPWbh1\neaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLbfcjS8FeiWh+Gv2w2jRhrm+Fv206BHZgLBR85OqZYQCIQCBbfiTBhAJ\no1oJpvqyrruiqD5QKAwm/JQyl3QPC7iYRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVuIn3vph8lqGGxkEAjvREo1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgzZjk3MDktMzk1NC00YjhhLTk0ZjAtMTM4MDQ0OWNlMWYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU2MDU5N2M4\nLTdjZDgtNDc1Ni05YTJiLTdjMDA2Y2FiM2VlYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOEaVdHTCHa/fa9kyEbfXgN+VVZbwKm8hNSwDnYgl7wz/NiJWwdndyWi\n7yxqOEbNuXQTi9JIUYQe4SQgGlxSARCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKV73rg/\nX9r8NKLqDyCeUeEH6RsdMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAvbWqA+F0Y/w3hasYGBqPRwEXGQoonHoeW4YZWKo7P0kC\nIEU7RWj1k3RtJg+8JH79ZO17yyjiyp0b7wUcw6QZj+/Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1249", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1249` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAZJXjSYhLzqPT2W8htAcqDVuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzMzcyZWE2LTA2YjEtNDhkZS1iNzU4LWFkMWE1MmJlZjc2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU4NDNhMGYtYjk1\nZS00OGJlLWI5MjctZTEzMjU1ZjQ5OTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJR5pOYux5egQ0u4bjtHNFKF3OwUreOQqHPLWNlpi7p02+vp/dSzEMpVWOXic\nefGDLBSsAr6vzKZeqxAIOzjGw6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR7eiLhE3PcqBW1D/01OwFBjK5YnzAfBgNVHSME\nGDAWgBQj7WMSxVgmZEMNOjvuUMKZ2+YMfDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC5968wec4PynNO+UfWKyPOQRwNfFl3\nbQZlj+H7LU9MDQIhALLrgN3cTrzhQHoy6Ob3Bejfhi14A+2IsPTn3etOC+zj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ9/06rYwU/0Ubt8s0JMcJ1xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzM3MmVhNi0wNmIxLTQ4ZGUtYjc1OC1hZDFhNTJiZWY3NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFZrnVcWuKTbuBxTqgzgpAKrjOGitOv3sS5eveGyKDWDCj\nLWcK+BluE6yEtNZfnmcI+79BJ0O7gA8nVlXWK+D9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI+1jEsVYJmRDDTo77lDCmdvm\nDHwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU7/isurAK9QmUL4VouFNwpwhhfzTxjc5jIGJbe3zbfQCIQDljtx6dt4f\ni8nT5/uLn8jCpQPfppc+9HSgzmNppTMDwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATRUvwpwKyU7T+8v5TBy/ft+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU4NDNhMGYtYjk1ZS00OGJlLWI5MjctZTEzMjU1ZjQ5OTFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYxODVlNTMx\nLTFiN2ItNDMwNS1hNGZlLTBiZTQxNjc4ODYzMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKX2Hzqhu9XBx6TvFRkJpofn02RNpmUJk64Iu3ApJu/RCal1Y/xIBj5q\ngZVphxygpWcBdVHs7S0q05d/KuQuElmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHt6IuET\nc9yoFbUP/TU7AUGMrlifMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiARpZ5jp6dTasorbfrWcb9zZvrrluCfxyZVzZvOHtGSfAIh\nAIWp7PFSSIZFLlEIq9ihUpTIdgyQMORw7EAeApDR0QJX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1250", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1250` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAR+DUOGse8kxLtVVPy+QUBhuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0NTRmMTUzLTZjZjItNGM4ZS04ZmE2LWY5MzJlMTkwNmM2ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU5YzM0MzEtYzQz\nMS00YzI3LWI5NDItNmY2OWM0ZDYyNmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXARtwBycgg8dUqjyRwSr6IPWmw0AG05eLCQekDO4scAo86XZSE2EwjUA/wXf\nY9tMvW1MC4paEMEg7U57XGN+XqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCfNvdi28VOywclORvuGr3Up6iU4wHwYDVR0j\nBBgwFoAU1BXciOOfAqZ/vP1sfi+X4B+aERswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEjW13XPw4SI\nxWu8WUOLd9HSwr/c0o4I3rvY98kBTNruAiEAwlv82vdqOhR6yYz+ZNbjyh47ICYA\ndNzh4OK4YKwTI2w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeH/O66uhlwsX1VllWdbnBp0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDU0ZjE1My02Y2YyLTRjOGUtOGZhNi1mOTMyZTE5MDZjNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQckxtdVq1ZCInMYEWc8GVCSo1EjBtMuyG9R2JcI5C2/qvB\nDA7GkRr241qi8X2U8y8z2dbIMV8QPqBn/J3G/2m4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1BXciOOfAqZ/vP1sfi+X4B+a\nERswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIQNb/RnziT3Bjq+vWFEkvFf7kKlDz1jQco6vT5hm08wCIQDkr4R646/N\niZjUCEvkwtHgl2N3MDxhIEIBUhaWIDFsTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAUlivFI0xZbtK0qWmWXxKI7xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU5YzM0MzEtYzQzMS00YzI3LWI5NDItNmY2OWM0ZDYyNmJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1ZDEyNDA0\nLTI2NGQtNDg0Ni05NTdmLWFkNjRjMTQyNzUzNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAuivL8eOhoR9WWqwrFlHPVvQQYRdMvRjVFhjxufPHBh3fxXGQ0Pu0xV\n4hNLnXnuKFSdrSMCHQiNNSo810b0C1OjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAnzb3Yt\nvFTssHJTkb7hq91KeolOMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA0e0TbAU9/pZOd3XBt2pn4OQ0zJ1R52aadlSa1vIglNcC\nIQCUBmCDMpu3i2ypYhiFUyhwycmGsVnZodCBsq1dZpKKyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1251", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1251` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcu566LCiF2KPxeGR5Sfnv1SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NmRhNTVhLTc0NzYtNDE0MS05Mzk1LWI3YTk2MTNiNzEyYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg0ZmI3NmUtYWUz\nMi00MTViLTlkNzItMzFkZWQ0NmI0NzU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELNps5diAJSNMJdow1HPPjFlg9dgTJqjBfIZ0j6mEaGVVBCVGauhn7fkl89jB\n9x2AGsjuTaQTYZiCKwobMhQJ8KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAKxSeSR4S1r7vVDAGU68AfcHH8gwHwYDVR0j\nBBgwFoAUo1+VwtvbuFxUAC0V7SrQ7+hyB8cwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIE/vbymRsJD7\nYjug6kcEzJ2+xBG2R/blibnM7gm1za/uAiEAogPANdthiDXjrw2NErh+wCa4Ez/D\nrpWYqqMX74CBYTI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb8TSN3pscsUp57dVTGsb1xRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTZkYTU1YS03NDc2LTQxNDEtOTM5NS1iN2E5NjEzYjcxMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHT0/ZzKn93g2yKI96pE/R5DtZMUsJJ/woyIAoQfjogVek\nSRgz5V3IgrfhT0rWecSGDfDRpEuLqYwwocht67/Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo1+VwtvbuFxUAC0V7SrQ7+hy\nB8cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYn8FvzNmvgBtiyFmAv+l5Nf7vRtfWWcTToSmaiTMqPsCIHSIExYojPMH\nb+NMKjjXRgedSz2jU/bs/mqAQwVg0RmU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUeRJgsosd6RPQirly86x46mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg0ZmI3NmUtYWUzMi00MTViLTlkNzItMzFkZWQ0NmI0NzU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEzNjA0MzU4\nLTQ4MzQtNGRjZi1hMWEyLTJiYmUxYzUwZjk1MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIlrnQo5Lx5N7hXjlI82FlSXhN4zCVX/tEnMJuPHo56sGE9QoPrFGQuN\nIOLkPfACFVbbwVm7uSTWXUPrkdf2CfCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFACsUnkk\neEta+71QwBlOvAH3Bx/IMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAycCCVPfhIPlvT0yhfUsVtxxEiH3iLyroRGPRZLprchgC\nIA/LIS1n9NWyhNXYv6iF3m2VVO5ZdEdDS/DIyF16RXh7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1252", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1252` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAYUiIZfurYs3msS4hJOTIOX5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwNGUyMWY0LWY4MzQtNDA2NS04ZGVmLTIyMGNiMjRiMzgxMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNkMGU0MTQtMWZl\nMC00MTFjLTkwODEtOGE1M2VlZmYyNmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELIIGOxU2rXhKYjTWND3JiVdKguC5d4AQpQo9dJ+z9Iwlo5LPUUhVoHU5TQyj\n23KShV7JT8m1ba0LlBkknRC4FqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnYj4emjXHhvxmWAAzjwczC/3KngwHwYDVR0j\nBBgwFoAUPHQ7Ep14Qm/xT1bpZYINjrxTV7wwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBEBxcnVpt+\niDNngCfgtrwMkNZ9Wy4UUOIQF9tlO47segIgcYendNL9HQl2jh7/RHCbN70ae8Hp\nzBkP4UgAvgyEXkY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeThPcFMrq7elgiLDW1EirA2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDRlMjFmNC1mODM0LTQwNjUtOGRlZi0yMjBjYjI0YjM4MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5d81uo831f9EA46uEbcUTYVCSNrz8z5kZ8CO+YPqNW1EP\nSJtyjsuvUcxk/PTppI7p9H0lp2OhuEIQ1IK+8zkWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPHQ7Ep14Qm/xT1bpZYINjrxT\nV7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJTq74DCBUolDnV74temqf6NhJEVmDlclrm582JAhu+nAiBkQnPG6Mr/\ncEWrGOEkGmbC6amHX7y6kzHvecRAmbAmPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAc2EI0I5mps2tt555DTr/ZizMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNkMGU0MTQtMWZlMC00MTFjLTkwODEtOGE1M2VlZmYyNmNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1ZDBjMDA0\nLWQ5NzYtNDk0NC05MmM0LTY4NjFkMzFmNTQzNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEf9rq5iITXE2zaJtbG76MakCz8doeR1A1p16KcRgLk2WYAs0uolkteQ\n5fW1L4Qgos01B0NpBRNQ4JznqHrgtDmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ2I+Hpo\n1x4b8ZlgAM48HMwv9yp4MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAz6i0K4Qidxw2BAAS7tyRYwOvYqxFZgyAVZIKUzGkY1UC\nIDlDEAhi6s1xjZpCmGY4MWofBQC5nSsrgi0/NmTXAeKV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1253", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1253` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAciFc2N3X4uqA+I/Ln9r3dCLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxZmIyMzE4LTA2ZTUtNDBiNC1hYTFmLTg0MmU4NTM3MjJhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdmY2I4NmEtYTYw\nNC00ODM1LWI2YzctZDVmNDg2YTEwMWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPNROnnhCVSxr4nJyx7a6U7asTOV4jNqjQgRSknA8skE2rDofdRmjj3ooQnJG\n/sL1eJ0x1OJUOw2YMUYa8Cicz6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM58rtv5SO1lGQoR8+9A+7iq2vn4wHwYDVR0j\nBBgwFoAUYfLdIAQu0S/uxThbZ2QDKw63I/kwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiA29pFg09ohOqEuEVMB3C9S/sO2p92WoWdNnpQadRN5qwIhAPXxo6J72m05\nXDsXxhO6wijTKcOISOsGxVCEiFzzfOpr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXmpMCjN1fK0Qo7k5+SgUwAzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWZiMjMxOC0wNmU1LTQwYjQtYWExZi04NDJlODUzNzIyYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR16s0oyvP5jAY8BrSeiK3WWa9rcl7V/1+F2rYWRIRVLobP\nHbG9DtC6gmPdQZetQDKjk1tUE2siEAeAAbTDiDNCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYfLdIAQu0S/uxThbZ2QDKw63\nI/kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgT638/mXFFYC8v0IbIsZ0dt8oBHCmluImzAUvCpM/9xECIQCUHtbc20Yk\nTXXswDYdTch4ig4fBTPUi7rZogIpKN0DJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAS+11anMlbBL00eRX+GMXRwRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdmY2I4NmEtYTYwNC00ODM1LWI2YzctZDVmNDg2YTEwMWM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMxY2EyMDA4\nLTMzNzEtNGVlMy1iOGU4LWY4NTE1YzBiNWUzNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJUJe3wNS97ia6IRBlVOGUdOq4yGnn2AX5iPVrkLs8HXhehL/CJyiicI\nShS2fXFaWy5dNRh6Rv62Ndl1ViZ2B7SjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDOfK7b+\nUjtZRkKEfPvQPu4qtr5+MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAhmOxSwYUxIM3Ycom1iClqhzhP099sxua/VXDeyTn7dAIg\nUmx1ml7JQtoAh874I0eZIHhWZJKmzNna9Odo/QU7ydc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1254", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1254` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZSrLFMvls+2wlx25/d2TSNEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhYmJhMmE4LWYzNDAtNDQzMC1hNWNiLTk2OTllNTFhYzgzZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMwMzMxNzUtMjE5\nOC00M2FkLTlmMWUtYzIzY2YzYWU5OGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkLu20O3VW512qom2VtJ7C1lNMe220SJNq2x6YojPfssXYCbGwUaKJ1jz/qJO\nU6zz0GasAiaTxhqFw3PFT/u07aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzDOPPjSgcz2SjE8fq38gBI16cVkwHwYDVR0j\nBBgwFoAU0F3hx/5IVOv2qEE1Ef/F3BDlGMkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiA0I3npEVG0u55ArTkuzQri3PIrc2ZZhGIlx2WvXssX6AIhAPRdqV6Jv/0J\nIjsoi/V2nZo8C+ubsW8XLz0L1zknKx/S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYHbZMkcDTMwivAB1NMpc5B7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWJiYTJhOC1mMzQwLTQ0MzAtYTVjYi05Njk5ZTUxYWM4M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6XEYDRnaMW1ACZwAoayLsYNmvcE38f73cAnb4w155Pw1N\n5PiUiJ+sii1GLGMLhUpw8uftHVv0oxJv89YN1tKIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0F3hx/5IVOv2qEE1Ef/F3BDl\nGMkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ3kFESRYPAePjyo4vdDQdqvnnldoyag34uuDpy2B42wCIHamPiMzj1TP\nwsvladsBSqkU0akCvYfD9qafEbX2G4+E\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXA/HQMT/CZ5L37wzjDaB1onMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMwMzMxNzUtMjE5OC00M2FkLTlmMWUtYzIzY2YzYWU5OGE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRiODFhZWQx\nLTYwMzYtNDM5My1iMTgzLTZkZTg0OTdlMmZmZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOB1XaEzAwGFY3FuT9BZfBtVp4yrX4tY+3wtyyNNgsnVQVrvUbH6Unjl\nvyLZg2HeLk0k5QBNlOWeJJD740bv752jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMwzjz40\noHM9koxPH6t/IASNenFZMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEA6RTXZtmvaZ4tQCYexB15lWgACqLPNhTWmZ4TJEvZK0EC\nIBmaA5cVfoFknLuLL4lxnvKKpc3AbTEZxr45kYIKbwfg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1255", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1255` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAby1UGrsIkbRq2HsoPoQ7Kj7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzNjk1YjU1LWY3ZjEtNDEyMS04MTAwLTYwMGE0M2VhNmIyNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA2OWFhMjYtNmU3\nNC00YmMzLTg0Y2EtNWEwM2I1ZTdjYjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr1FRRDVD38xo/0Q9dlrgelL0+b6k4bObU0SEauVn6GMNI40E3byiOcl+7/kh\niWsQskES4nwKTWNpquYKCmuM9aOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbLb4V1BNU86cjrCaHuZitFjjpvMwHwYDVR0j\nBBgwFoAUSOCzl2GnOMSQEhwcxS6TvXuKCJ8wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAj\nbi53+6bh4j8uNPimFf+W+Eod3Ld+hNRoZt62iI6tywIhAOA9TnFPRC7EM8WLttsJ\ncn5YgWgc67wIeJv0TFc7bguK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAebxVuB0tPi2AyHwH1rNcH1wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzY5NWI1NS1mN2YxLTQxMjEtODEwMC02MDBhNDNlYTZiMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzNZ3/UyQpGBV6bXT93NBLiCOau86zZ+k9PfueHtjyUcJA\ndU30NJLAtQbzV+ylL22ndqhaiCEjca19J96VLcORo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSOCzl2GnOMSQEhwcxS6TvXuK\nCJ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCsFb90/h4rNzXTm5nN7UfbnyFIF2/+sNx1mqT9T4ZnsCIQD9t65GB8kQ\nZ1Ii+vLnvTHxWRNuUUjR+oKgGClE681vmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAaC+PRkV5Ais/Kn/S0jxORN9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA2OWFhMjYtNmU3NC00YmMzLTg0Y2EtNWEwM2I1ZTdjYjk4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFhYmM3MDhi\nLWE4ODItNDYyNi1iMmU2LTY3MWZmMDgzNDU2MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNZ2TpR5vGwn8t8vDDgChJqbd6juEFweYHtSQYKjfRhZkRLNO+/uLzV3\nt7sqA5byqzacb5UlS5cYvc9qaU2rxFyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGy2+FdQ\nTVPOnI6wmh7mYrRY46bzMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAFi28PUfMXSo4ZXXg1aahSa08QIA0xlU68Lg7x1/ruVgIh\nAIQpImXc8STjYWt3HK1gvR2ebZo+UAbBu0l4Or2qn04w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1256", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1256` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISATvEKXRP/23Dy7kBx/b9khZYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyZjE1ZTU3LWZlMmQtNDBmZS1hNjA4LTA4NWExZjc5NzFlNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU0NmE3YzMtMTRl\nMC00NDJiLTgyMmUtNWZiNWI1ZjMwNDgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfIZmf4p6cHY3DtsNAmKbs6CzWLYUJtFINpfWmBO1ZIe81IZTBwgltMITpokX\nbtHPkxX+c24xEQVYNt5yISpl1KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy/3ez+I2s/MSFHL2Oc1lFbUsBJIwHwYDVR0j\nBBgwFoAUEWT8ACEEZ8W0gTCNOUgjn0AAvGIwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAyfTIeSRcl9Q/GlEMWmfWtZZeheQGlEZpyWhNQDucczsCIQC3\nw+fQcgB1VFXQxiDxsXlebr/Kv1xolmdY6a+2kq4AgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX/K6Z8+2F52U7r8qSvdODcvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmYxNWU1Ny1mZTJkLTQwZmUtYTYwOC0wODVhMWY3OTcxZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQw7QdeFtg7pDAM5R5LbiWdtptHa/+8pVZNKpYzEl6LsV1J\nKmbyxJuHdVaRzEAX2KZwr7UOxXthVR0Nnqllc0zZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEWT8ACEEZ8W0gTCNOUgjn0AA\nvGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPXXoPG/GnH1tLdfb4V9xxdX9NWd02TxcjdoDCknvCkVAiEA+b4noXUD\nM8kgnQXrFJJnlFgMVguffbQvFqAI0aNUbK8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQGk+aB7njk0RddjaBcs/Y4BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU0NmE3YzMtMTRlMC00NDJiLTgyMmUtNWZiNWI1ZjMwNDgzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVmYzkwZmI0\nLWI1YjEtNGM3NC1iNGViLTM0Y2NhNjM1MzI2OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOoT7425DDVnIXKuI5YbvljI3HpOvt3WbYf4I2Iq7S89LRNNtuPDQ+JI\nAm+S61kgY+jTtMy0TgK0sXA4+bcQFg2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMv93s/i\nNrPzEhRy9jnNZRW1LASSMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAi58O1Bjry1jA5v0lj+zp6P2tbylOuP7M9SaWpTEHZ/sC\nIQDRAsSCUTTRpYCWrtnCUScbcepRYqro2wu8HPkH+ozJ8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1257", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1257` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAZWL0Da2icTJeoW+rl3TN8eZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3NjE1Nzc2LTRhYzAtNDM0YS1iMDQ1LWQ3NGZiZmVkZGY2ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVhMjk2MGUtNGQ4\nNi00YWQ1LWE5ZjUtMTg5Y2I1MmJkNDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOXC5yuRo8q1te5D/XAXhhLvM7GVAxCxzGSJqMl4wiH0Nwmnr3bPzWVkSb94Z\nwxzv/MZpWOOtnzxdPE54TJzjcKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGYdWxIkx5kVFDdRim76cPkTRXbkwHwYDVR0j\nBBgwFoAUKokv3TQ0KB4vI+a2T3LF+peA+3MwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiB8QWdWL/21i0nlVHxbowj3PQo/4J2I9rIHeafej/ZD2gIgWFbM\ni7auJlwMV4xJpsG8vyEWL/9BdgFmfH+w6DSZuLU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAez4UP1qtEIxtmecge/6C9wkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzYxNTc3Ni00YWMwLTQzNGEtYjA0NS1kNzRmYmZlZGRmNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpbKuYqlXEO7hOzebCL8hpNfZPNFaJY2xRcwJfuHhOFlGt\nbzgJJRfJjSnjUJko9kThfdQsAAOWLu5w5Mp3C/R5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKokv3TQ0KB4vI+a2T3LF+peA\n+3MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPKCbmWVKFcnews59XzFzA7BEdWzAtiatjXK1Oe2uescAiB3kkVRBG4W\nNGeEJn0h64ekOtMxCBoJ0BeUrvd4ALR0uA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAb67wYI9/1RDtlDe1MMExGpKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVhMjk2MGUtNGQ4Ni00YWQ1LWE5ZjUtMTg5Y2I1MmJkNDkyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBkNWU1MjA1\nLTRjZWUtNDQ0Mi05ZDczLWQyYjNkYTg1ZTYwYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE+VECXpkJVYge+dvIdhQUoNE6ZOB6Om0Fx7+cbroWoc8w/SM3nCtF2G\nkSlV5zjX1P6QaUjdRj91vgp+8tyZx/ejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBmHVsSJ\nMeZFRQ3UYpu+nD5E0V25MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAwdzx6pIzkMGugQLnGabQcUVMV3pULA4XGlk1BRfG/xQIg\nCBL3RmKn4fPhq5VdZjxPRhDZjf4GX8pVkCopw28zjg8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1258", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1258` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAf6XcYwtnksVxR9E4OTz20k/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5MWQxOGM3LWVlMmYtNDliOS1iNThiLTViMDMyOTZlMzdmNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAyZDYwMmQtNTZl\nYy00NmNiLTk2YjUtMmRjZTA0YWExMjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFEScLlt9R7X+AScK/xGwvXRUj8r4KxprKhZC/qJt8BRfDbzeVtxxLJFxtzFE\nSiH5TXaWKeyF6Nxd47ccGWBHQaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcrgS1L/6TlOOi0VeEBHtc7iqS0YwHwYDVR0j\nBBgwFoAUdsO9oxYewPTAgl2c/R89gDCCQYkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiB7S/JaaQJOnz2k\nvZTD2U0wHMzlS35sK+v1J2aF8V9AlAIgI1kvYH6wS2II2GcDSOi0IHYEnXqd8cK6\n5ejMkXTLs3g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV8z53iTe6URiUXhWsd2B7wQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTFkMThjNy1lZTJmLTQ5YjktYjU4Yi01YjAzMjk2ZTM3ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzcOykzEsFA4EBiJj37BsE/fxwZWxIgiDYC+0OzSUR8fgA\nXcSWBaR28282vbZLfdJDSUtd+aJnm5DNMVxiuSQVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdsO9oxYewPTAgl2c/R89gDCC\nQYkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALpgY+uYw0FAiwWSY50QQMBB9QNvdkyWLzKXg1cLnNB+AiEA7K3onxxa\nkImTfAk1PIM0DLTkOQcAMKS1ZQmIdO56EQg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAW5Ep9JQpg2jhLFYGMiszrIVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAyZDYwMmQtNTZlYy00NmNiLTk2YjUtMmRjZTA0YWExMjcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE0ZWFiYzZk\nLTljNzktNDdkZi04NDIxLWM1NDFjMzIzYmYyMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEZeA1hAhMzMkifs2hwRWpbK2p0rXX1YyRq0DZ4kf87/ynyZuv9tdnjH\nVtChT2u0TlqbN3iVi1AjHaCcc9Z8tGmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHK4EtS/\n+k5TjotFXhAR7XO4qktGMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBhyK7nTOp6p0mweE1KsvOIyvaWDzu+7fS+EgxuzQvcXgIg\nMjvl0dgO00N5L/Bd5mjk69f8y5w3JxhS5Q746YLw3Hk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1259", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1259` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARVSfWenwmn9FYdqrImM7+KkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNWJmZDQ0LThlZDAtNDEwZi05Y2UxLWZjYTA3NjIxZDk0MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRmYTJmYzMtMWY0\nZi00ZjgxLWJhYzAtNTU0MzdmZWRjMDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEToxV+mg9jbBqqBSJdFolcmXHC4N03KzRfUfrQmqufiC0LaBR5cwkKGitmvXt\naY0DO1qhEZrP25fY6F0Gz2tF7aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR6+JtDi1mFWf9eZ5mDBZLcieQ7wwHwYDVR0j\nBBgwFoAUoY/AZyp+ix+tvaTfrjHecVFiJiMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEq+td6Xt1xnGCDi1G8GjOE3sS7SIEtuZz8lLZTRSmFOAiEAuEQwfmcN3Lh6\naD3oul1h3zlzg3mCqNrMfunfINkVdRY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeZ7UfmhqCeHrSNlpG0KGIK3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzViZmQ0NC04ZWQwLTQxMGYtOWNlMS1mY2EwNzYyMWQ5NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCf36gMY8doYf/ottkyuKy5hkJv0ASEQJbKuyP4sgBrPH+\nuWjMr3wQChL6vfYrJ0xtTKmuRES5D8E1N0ZpCP/Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoY/AZyp+ix+tvaTfrjHecVFi\nJiMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALY5wfgQpUP4rlWI1rR3Xto6cKqw5qZi0GJofUHLtrlkAiALajC6ginU\n46tAXPfPOTrYR9jnVoAY5R8OkrWOZ29J0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUSKZkWdpjOwgEquUqxAoPIhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRmYTJmYzMtMWY0Zi00ZjgxLWJhYzAtNTU0MzdmZWRjMDU5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkMTRkNDMx\nLTczNWMtNDI4Yy04NDZjLTU0ZTgzMGUyYjIzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAShYPJur4Z0CnUyFhQZJaReoVrs+MgKI+4jXPkGHC91ZCc84K0fhgOQ\n2ClISjvvJz2Z0fE1xtW/4HaXCZ4ldRSjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEevibQ4\ntZhVn/XmeZgwWS3InkO8MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAMSqBcGMNyGWEqWvobL3le2YaOCNLWI6QS0jxpfNqFMwIh\nAODYr+Y+L7ZRVkd/ZeXJ4UbqgpcnmvAQktsfTVLMTAMN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1260", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1260` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbaCL3t35Q0+mQkVOcAyMMfoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllOGVhNjA5LWIxN2MtNGIyYy04ZjMxLWVkNDdkMTBhZjBiMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmYwZmU4NjAtZDY5\nYy00N2ViLTk5YjItMTk1NjkwNjc4ZDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXeGBWFdBo7k7gorXOkAOcrG3n5hoBOq4kugLNizL9cxJaqcH9E3/L2DeZIMi\nPWoyRzdtOdwbvmLTXHP2ioBIMqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULieviLQdTKsDJ4O4aQwaZBKxZwIwHwYDVR0j\nBBgwFoAUUygAB2WmMZzMjMvDs7rvJCNKqiMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDS5PL18bNBTqGNwl4CYD4cehcfH/BKi6KfEvi2Ei4HhQIhAP9XTZx5qKv9\nt0ppu+YiDSWJn9rl1ytquiMtdGS/UB80\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYCTqtR3NAwoKjuYxea32jnSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZThlYTYwOS1iMTdjLTRiMmMtOGYzMS1lZDQ3ZDEwYWYwYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT273uDELhKzmyGEQ2jrnOmZd53zscrE8x8bZdpwrvZ8cqi\nOTfGxOJk7meSkUp7qBI2a3P8K7nTahSUH7dmsa36o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUygAB2WmMZzMjMvDs7rvJCNK\nqiMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOgdP4Z1Sz8kvQnucCFQ231q4jpjVJ+VJfEGywES4JxrAiA1aQ/5K6+l\nmwoe8RQ+7bvKaZoibhzU7MZcnIm1gFwAtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARqRRsWjyS/ah5xsmZh7EvzHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmYwZmU4NjAtZDY5Yy00N2ViLTk5YjItMTk1NjkwNjc4ZDNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU2MmI5NmQ3\nLTM5YTMtNDFjYi1iZjdlLTBiNTZiZjQyMDUyODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN7xGkrtRP8yG9k4gF1YkUcRpwcsr8qYPmFsyx9TtCVZUeKHIFuZd2mm\n+bWD+sA8f1fWyQLCGMHAOmSlWoGdd8qjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC4nr4i0\nHUyrAyeDuGkMGmQSsWcCMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBhyJiOcHxLhcno1x0JCKFa7qqP/IoldiUMB7Xp1aEdjAIg\newWjcYIZCOWH0SV0QKELSDxXSIM++Y6LJWIiTbQmPgw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1261", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1261` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAY8R7t58Sr3YorDh5gnE0PjpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MTIxY2RjLTY5ZjktNDY2MS1hZjUzLWExNTc2MTNkYmZlYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU5YWQyNjEtMzU1\nNy00MjM1LTg0YjgtNzk1ZGZkNGNlODJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5GE0mPZsIpFRQlxVFa62VDT8LHacXHiL28K89eYo6XsRzFty8V/eHw3fDsGG\nCxtBeGc5t+Yvb+5UPshZ/WzyFaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX/jjunzOwSgTxOBbmltJj6aEzkowHwYDVR0j\nBBgwFoAUODsglC8lmDmLLQci+MpLD4VfXD4wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAUuf4okYWTn0kdncCWBVa5WRNGvrvb1rkfpLutEW5WWgIgdvxfXB9P1/1N\n8lRE4vV6jPSdNaXXD9wsCtr4iGdaQkY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWTEd+6qEqbAf/P8pOeo3u8AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzEyMWNkYy02OWY5LTQ2NjEtYWY1My1hMTU3NjEzZGJmZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARr3PnnaBWhmb+c7EyKV8lRtzy0PPKLUWHts1dftmfSbZ7w\nNGGDHPUgbeeUUJVwMEfGyJDDUfpEbA/+wALUDTjHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUODsglC8lmDmLLQci+MpLD4Vf\nXD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKu9p6vKFEWQqvGBC0PoWykhhyIeLpLtGS7ccQSgnKTUAiBIrtmb1hA+\nEtITuqSkbZOtoehIWZWbFtfu+Q/WX7vV+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfTGvj7czvicNxQjmIo01vaZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU5YWQyNjEtMzU1Ny00MjM1LTg0YjgtNzk1ZGZkNGNlODJiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyZTliMDdk\nLTU1ZmUtNGFjMi1iNTNhLWUxNWE2YTNlNjhhZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG0wlWLSlYa9rS+JvZ4ah3FDTZtOpCZlwYlohk8THfUqAPhNBLp3wllN\nIo5S4tDn8X6WA39KeFnhw5iPUsUsTVajcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF/447p8\nzsEoE8TgW5pbSY+mhM5KMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBK+Lo7svY+9JknFHg5TC4T7ilXbQnxcMS7V4zGRi/K/AIh\nAKGMiSFnJLIMaW7uSLo1LRRwGe0/kBKj0heqNOLTQA9p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1262", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1262` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAWWsKXZ7hnFPCtPkLe8dqDVCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMjlhMmUxLTI4MDUtNGM4Ni05ZmE3LWRlMDcyOWIxNGMzYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI0OWI3NmEtMDZl\nMC00NTIwLThjMzItNzJmNTM0YTYwZjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEzGQc7rUCoOma0e4XDculSt0ZafuCrsYXStZj4h/NqXfm2qEryoS9l5iY+cv\nlvRMyDtcubOfVsf3y4QsJoyEAaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/iIhGikZej5f4JgsPuPZJsPOMUUwHwYDVR0j\nBBgwFoAUcFzKTHAy+1pbpjFT4KsuxfzUB78wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAbm1xPtTEcSg3NOusCEf7DJo85xOpzI9nknBGKjTJ/\nDAIgVt3Ax3gDGn3WlFkzxz4JmRHaF2taEhzhieoCrRKVmH4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYKW6azEXSsRCFdd1G7vmfSuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTI5YTJlMS0yODA1LTRjODYtOWZhNy1kZTA3MjliMTRjM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASk7WU3ejaA9QwEanDl9yamRoO48R3SN59ThntpE9A+rWUu\nx+ZZ7t/MMZE13VoS6lQy/YMXYIpj058SsBs3Bq2To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcFzKTHAy+1pbpjFT4KsuxfzU\nB78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgccreowwaaLOQ8Ux3WKuhYU1Jnl0JOkYFVvorZRpFy3ACIEQ6tr7NOyb0\nDnI3TDtOMWv0mGixPzkyphXK3LindZsO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAUGqqqDw+UezxuNSL1P++yjLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI0OWI3NmEtMDZlMC00NTIwLThjMzItNzJmNTM0YTYwZjVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRlMGM1ZDc2\nLTJlODMtNDA2NC05MmU1LTgyMGRlMjEzMTUwODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNi/R8H/1N6xhD6amu26ldmrD1AwXdbyfKVqOrMzPUWiC2voolWCjR9c\nNruAA9rjO/Ds5mGSF9HBkdE/FLQ9BFyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP4iIRop\nGXo+X+CYLD7j2SbDzjFFMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBGrD5JwnURcbl7CQBArpKZd9K35dCyxYXZaheLFdQx/AIg\ncxEcJnyo719P5/Oo6LAiCilFnYr/ihg9z5eH77aUtDg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1263", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1263` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAetsIurkQva3f8krAxTEt3DvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3ZGM3OTM4LWQxZmUtNDcyZC04YjkzLTI0MmIzMDg3NWE3NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDliMDFiYmMtZmZk\nOS00ZWRmLTkzMzItMzk4ODAwNjVjOThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzkJW018h/hVaDxdMPHS5jRtFinp02xLIhlKDInWRZ1nDLLuAQhN44pZ0mSEZ\n0SAIrED2vIs9ijXLNcxssGonuqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbKOj59FiUIjAwByiP/PgzdAj6mMwHwYDVR0j\nBBgwFoAUKWDsnFJ2W0v1R+7d3/2dhA1+oywwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiB4GALeEMmeggNEOcihglk8xSY7ZRx1h1ZN4YaF3NIF\ndgIhAP2I7cr2COAD7YHFVde67KcCD5JcHl0Ns48EwkN+9HKt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe5lWHQLtONYKTq+5Ujuz/o0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2RjNzkzOC1kMWZlLTQ3MmQtOGI5My0yNDJiMzA4NzVhNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReowLn/V5UbSLkAhQt3ZUBbCpA+sOzD5PPX3pVebMUuaOE\nhsv6/ILrP7mtlezBDRBZG+UUs756RcgCmDbB60wXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKWDsnFJ2W0v1R+7d3/2dhA1+\noywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKVoHZPtTL+mz87nJcfUsyx0YtNOYG4lmx1ynW6eMG++AiByRvEN3bZM\nxqGP/eTJoOyCRl48Fb9eorg0UP5m5eBRQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUPzMXZFXHvXJTtnnk8yVX42MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDliMDFiYmMtZmZkOS00ZWRmLTkzMzItMzk4ODAwNjVjOThhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIzZmVhMTU4\nLTdjZTgtNDQxNi1hMTJiLTJjMzZkMjUzNWU1MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA0LeY6UWrTihoVTqa/lTUOIAEFONLknN5Ky9i+bXgyYJXHWlPgtsCtF\nfH0u+k3Y4ul9smBxqfvG+ZK5VGSpzgGjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGyjo+fR\nYlCIwMAcoj/z4M3QI+pjMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiATEWYAkJRD1pKQuSCfkSSYjIAQg+4+wJafE6bWFKqDzgIh\nAN+UqwY17+KPtwUFtbjIZEV4p9AD3HsVx10ygHi0Jm/e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1264", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1264` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYjlyi6BioVIKaGh/PVML2E8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzYTJjY2I4LTlkOTMtNDE0Yi1hNjkyLWRlZjZhMDEwNGFlYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc4ZDkyZDctZTRm\nYy00MzVjLTk0ODUtM2YyZmI5MWYyYjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkIlh2w/Y58+zFFcsVmGmPoOaxlDj89SgO2MJswr3m2SHIhu8Drh1YAiP1yl8\neA2GUMDvCURURsDj6F2pVKL6D6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvr4YZr4wurL73ixcuSRTjN5kp1owHwYDVR0j\nBBgwFoAUt+EPghEv92x+FjHZ1/XafnXNVP4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBl/6IWm943AsZMp7Eg1LuoklPoYoQ0sRX9xARmsMRDdwIhAKsh\n3SXy/IPcit7b4WSXAP4kJe7JuUxS/VshGvBtW41Z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR8MPiR2bMz8A3pusGvHZGGZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2EyY2NiOC05ZDkzLTQxNGItYTY5Mi1kZWY2YTAxMDRhZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5DaIX3LADIH2uF1TcX3QfPeonMFjVKqwckRaVax7JiI7R\ngv4gLXh/a0lwQ8FNdyms+9H8Wms514Uo5oov8ja9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt+EPghEv92x+FjHZ1/XafnXN\nVP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbymLt6imRG9FNcCt3i/R5/6M7ksF7F1Kf0bp6lqhD14CIHuPqCKg8e3O\nt+E+Ko6Baa/v7GHHtdNwhUj87VS+b0ug\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAV3ShCJUiLslhL8mhY0fk3daMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc4ZDkyZDctZTRmYy00MzVjLTk0ODUtM2YyZmI5MWYyYjA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZlYzczODVi\nLWIwMjMtNGM5ZC1iZGVkLTU0YTY1NTc1OGRlYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPzlHIsQZnsegXvxBp/s3jFRzVcx5wvSJ+veuWEcCZeXXnl6Z5QOsJfJ\n2eJNpuImDYrcrCK5w0mhArSH40WxaB2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL6+GGa+\nMLqy+94sXLkkU4zeZKdaMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiA0KV8q+KMVzL0Fq4t9V9LxZOTxfISN6PbnKDeu9EJ+RQIh\nAOC9M1Yukh7dwu8+wfOyTr18pcLRxy+u+8BDEirw//C4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1265", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1265` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISATXNLpitUoHJV6GEuvg624MEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MzhmZWZkLWVhZDEtNDBmNS1hNDRkLWM5NGUyMWZmNTRjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzllNjYzNWEtNTNm\nNC00YmYxLWE1OGItZGI3MWQ0YzM5MjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL8BTTYMQ+yYavR+JUiXw94h/hf+Cn6ae03bcIjDBmoMYrHgI1tV4XhM20xBr\nPA7JqfflFQVN/EpZ+7Lb22LW96OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrKGYIO2cnuCl4WcxhRBr6qoC7ywwHwYDVR0j\nBBgwFoAUTM00NVAjou0kLRgIWUlwAx7wItIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAqxOxFogtAnq9AR7vtUWq8WhPU5aM5fj/\nOFOpOElm6LUCIQDa1SmHKbVud/S9an2jIgmr6Vr8c0p1gAuMlWJi6pmBfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYxM3NR5ehMP3XML+ZpW5gl0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODM4ZmVmZC1lYWQxLTQwZjUtYTQ0ZC1jOTRlMjFmZjU0Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASt/wtj3d5pSUyA3EBRpBcdGD8bV99CXI1kXkpLA7+ObV9U\nhyaVsKAMW4wlRxENVcbKyy78GBe0V9U24gb7TMA6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTM00NVAjou0kLRgIWUlwAx7w\nItIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKnKw7WjiWbzreb6PWZKolXWOT0Lzz4Q9fA9r3gIihcXAiBT+430LMD4\nNnUy3KgrsVqzbkNH9NyTpUwnGosn/vhB3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASsGFnAmzJ44KcPPjGNVgcpsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzllNjYzNWEtNTNmNC00YmYxLWE1OGItZGI3MWQ0YzM5MjYzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkzNDAyNWVi\nLTE3NzEtNDI3OS05MjEyLTEzMzZjNzNmOTAyNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPx0yWFA/a/NcUluoctS3d2fVkoA2SwbbtKHuAsbNn6EW63et1JUsBgf\n1/CfgLRYizrNhYrmGVQ+nCEvgBXjWWijcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKyhmCDt\nnJ7gpeFnMYUQa+qqAu8sMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAmwSWHKSVP3wxW4u3auYN+Z0xv1A37OueyoDAd+A1n7UC\nIQD4SHV2kaiyi1iTc4mN/q1LqcBo719ZwK9ig2kM4Ocdyg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1266", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1266` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARTnudtmWpD1xpqCen6hAva1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3Yzg4OTI0LTcwY2MtNGM2OC05NzYzLTJmOGM2Yjk3NmFlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFlMzQ4ZTAtMDg1\nOC00M2Y5LTk2ZDgtYmFhYTZiNThjODcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZDy5AzgpOpt8BNZc3camYpbz/Bh+us2T9sxJnWppEvx9rawQsjkTdH7U+FMH\nDDfkph6P6J5NdSqOp8RWfLybHKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEWlM2Ko3Uthw4vug+zLrcJU+Tw4wHwYDVR0j\nBBgwFoAUJUP0wgMVKTQpRQdNbnp5MAPss5kwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA1IXubMOEexn3CkK0GiJlyTqQHPfkggKI\nWtosSAVoguECIA4o9ajybVHXEqNNgthEYkfQfN/4/Ix75ALAygtfR9Na\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe6ErARsO6tvqgRsoG7AlZ+VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2M4ODkyNC03MGNjLTRjNjgtOTc2My0yZjhjNmI5NzZhZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWN3xhtnsCBW6Ns5J11CZf5NH0CLewP+5ZZYOv135Ywr1h\nb7T3hX3P8S40vTNr3Tb/TQzQeXZdXe/4PCydOA4xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJUP0wgMVKTQpRQdNbnp5MAPs\ns5kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPWJN7S+kyGNTsaOc4t6FERNwe3JxH5U/WHARdy7r/VIAiEAsT7gdM0E\nOdYBHwmHNrsXfbuN6FZM9PyPTC0X3MlPAWU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZ7qJE3m2rnjBOiLaR6MwFwCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFlMzQ4ZTAtMDg1OC00M2Y5LTk2ZDgtYmFhYTZiNThjODcxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIxNGE3MzA5\nLWM4N2UtNGRmMi05NTZjLTkzYTgzOWY1YzY5YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCi3m3gUVK4vTqlxCgIxc/uQfdpDoKbwEyKUyQNqzkMNsecmrxjsmcsP\n993RfnJOWwSrbfwOU6mJTwTBq/6zYySjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBFpTNiq\nN1LYcOL7oPsy63CVPk8OMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAkUrigjGPeGz8Dz2aro8CvulawwjAQas8HcMHsegul6QIh\nAICpuRRcryROe5YxtGRYOjeNcmYDgQXOEWBBV/01ua5a\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1267", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1267` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAR/F5vk4BhFbJIz+9+zYWDaZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNjAxODM4LTE3ZGQtNGFkYS1iMzFjLWVkMzNjMDA1Y2I4MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU0MDRlNTItMTRl\nOC00NzJlLWJhMjAtYTczNGUxODM4OTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEae71oPUfBOZM/RQK2XkZqabo80VGxrd10d4JdS0yizBTLm6Od5cZ6oP5NrhN\nhzbi8LJRjvHIj7yZ4kvsfogf3qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIlaNgu8F9JgPJKJHeZFRkGaD9gEwHwYDVR0j\nBBgwFoAUPDdlUPxqeLjIMMvGN3yKhqeYh2IwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA6aJlVwVQlAbMh\nQR7McRq/jIVKe6SB16aLQnSnWExWCQIgAssUbJBOh1uCQ2+u4g4KQo+mkL/OIzoh\nczsOAuRQtug=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR4y2AWAPudfelzSrP1hi+PdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzYwMTgzOC0xN2RkLTRhZGEtYjMxYy1lZDMzYzAwNWNiODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7mGYMGrSeCdaSrXYhb8ohZhI66LXTBAA+C4BakWFZ/9ru\nu7RlGUoiMtogIN3J/r06HiacHWh+ciIXUSaXJfsxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPDdlUPxqeLjIMMvGN3yKhqeY\nh2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgap/DLy4WM7I1de8qTIUEK68RAGfnzcohq8prH5HmUiwCIQDmZzwIpZ1v\nlOJS3qndBzLiq11K/rQGa/LRHVR1zC4+ew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAVabWSMJ0lB41OpRUkefI8E+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU0MDRlNTItMTRlOC00NzJlLWJhMjAtYTczNGUxODM4OTE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM0NjExMTk3\nLTY4NGYtNDg1OC05OGViLTUyNDg0N2ZiYmYzMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJXhVmKGrvtPanHIW2Lo2DgickSCvlNQxeBz03tHI0QjDgAReTWWP61h\nfRUQEJlnM1U3H9DqVoo0iGJz/AIBgfWjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCJWjYLv\nBfSYDySiR3mRUZBmg/YBMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBcSIGFPq1VdLDKs+CA6a2FzGl4g1p3Ko4alja+x8oHDgIg\nC1ZNZ/4P2Mbk5eBLWQEIBPupgRad3aN0D05myb3AYvo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1268", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1268` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUkvhEZKb1orPJAWmbgrrDU5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkZWY1ZmUzLTVhOTktNDNjYy1iY2NkLTdhNTExZjg1NzMwZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjlkYmUyZDgtZjAz\nMC00MzAwLTliMjctN2ZjZWQ5ZmQzMDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk0EtM8WDs26VL7e8njgYiBwSe7Gcj/KWJvalKCFrvtDvHDP4gpAaZUZzClcp\nqHaM9jICh1yvh3avPknzsAFIeqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUABmzLyKFFW5Uc37MFbBfd7OZCzYwHwYDVR0j\nBBgwFoAUF7Iy5d1QNVGrikNdM2HGyFVYiikwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD6ZVMphitftMg/fcr0jiLuqrDU3VfsLoxyjzaoAsn3xgIhAIFS7SlNmfgq\n31mTe8TBfCTU8Tg2nByCFg+qhOgLeou7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeRbxWQJZrCcp3N5e4al3ecGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGVmNWZlMy01YTk5LTQzY2MtYmNjZC03YTUxMWY4NTczMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTFh2Uy0G8b4AnsCvY9Hy1tOCgaPdmMaI30v2rYQ/5EJBA\nX2nhCAeo+7MhRfQypVAIzkR/42Xr9/KbPSMNMwIVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF7Iy5d1QNVGrikNdM2HGyFVY\niikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCy0r7v/Gh/tpOsjhcUog3EXSNG1BHiE5MOC0jD3k1yUCIQCfLkAbz7Al\n4xxGStyTvR5ov0c7H25X46Bd7yqL37NH9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAYgzvV4oYodK6u+jdxJIoOrzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjlkYmUyZDgtZjAzMC00MzAwLTliMjctN2ZjZWQ5ZmQzMDYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhkOWVhNWIx\nLWNiNzUtNDBkNi1hOTcxLWZhMzI5ZmFkN2E0MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJJdxLqQ99xAG9Iqr51A/95rp++AduBnI+VFgvAJpyzNwULcAzLsZW1j\ndMF5aBa+isWLkm9NK6yPBl9EM/00ItijcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAAZsy8i\nhRVuVHN+zBWwX3ezmQs2MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA5CHy1sfpvc4VDBYq/owbOuan7+luVoBz7r03F+9TOGsC\nIQCMA5kL2FiuaHhG2eUMF4DHXBLdwoLE2tg0Rq2uZPltlQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1269", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1269` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARudoyoepFilO2jVRBkwhAinMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNjZhZjIyLTcwNzMtNDY2MS05NTY3LTIyNDEwMzIzZWNmMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZiYTZhMjgtYjRl\nYi00NzQ1LTk3OTgtZTIyNDRkNzdjZjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO7FX9roEuYeEnn7sS1mpyRv3H+ZfId3KejCOK0pktZsMC1fSbKA2DwqE0Hsp\nbrF6ZOLTmcbKsc4lRQHOtPAn16OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmJ8di+IJvuTUn6/FbHJjVbsH1CYwHwYDVR0j\nBBgwFoAUsUZ6gx6wC4EzBUtnwsxr9aOz4o0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHkEqI6TLAN20hYtVBNQ0LmHJ4sZOEZWRIawhBk8MCNPAiEA+8xt2hHKjImE\nDmCN4n7CunS42aofkuqpPw7ONQdGKqs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATJS86XjPDYEXw/piKJkepI5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTY2YWYyMi03MDczLTQ2NjEtOTU2Ny0yMjQxMDMyM2VjZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJ18zNGfx4Zz/6Gz1HoQ5lQC36Ttly6Ze+QYgwp4bPZub3\nwGI36WXOCPUDDaMKuhAUhtSeGQMc0wOxbxX8ycvVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsUZ6gx6wC4EzBUtnwsxr9aOz\n4o0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANOQ7P/qddO7uKpzVoXH8RotLO8kmpYXJP2pyrViY4ZyAiEA+riEEXjj\nEk6TiN/LD6jJViPkVzEsFdEK7oZWjl9W9pE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAffOjTq8QeyCQ8ECBnyeUsRiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZiYTZhMjgtYjRlYi00NzQ1LTk3OTgtZTIyNDRkNzdjZjBiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYxZWNjZTIx\nLWYxMDItNDFjZi05YzViLTk1MGNhYTc0NjE3ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIh7Ihg4dSAzmQ2Ipnw0+hiy1j8EZrrNBjsR7tB+FflLZkk2v5hupSid\nXkwKlNd818E+7PkV/SxSTCQb/LO7gQajcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJifHYvi\nCb7k1J+vxWxyY1W7B9QmMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAh5zVmyoFfKi8q76jFO+5y8s1sm2kq+8yfcKQ/rd7vxAC\nIHkkqtZD5RB9xtzgSLGy/O+WoXsmqw4BTeIhNBUiCpXp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1270", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1270` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAWDZmngp/Nmo+XGIhhQcNrZHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyY2M4YTBjLWU4YTQtNGUzZC05MTA3LWIyMWE1NTU3YmM2NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMThhZjE3NDYtMzU1\nMi00OGMzLWI4YTEtNzBjMGI4NTg2N2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXmYKFHDvB2UDTdcIf7pmlf8BJC2kOdmPbDZ56fdNHytaZTwDU87pY3kMyvBC\nuExr+trsYNnQM8iuVSdd83ShkKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdNO52QY+skbBwiRi77ZjPwMgbjEwHwYDVR0j\nBBgwFoAU5AbzKpUPgPmr8xrqyBQeAmHv/9cwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAKX9xtKXgwv6JQ+FLx8KVrqqDiP1PvcYaLQvibX8Rc2AIgZsorg05EDLDu\nCrJKYFIaYT+/HQ7ad0Zm3rQ7BWAOGbU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX9pJMnp6cMXQReiWvp0CYRRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmNjOGEwYy1lOGE0LTRlM2QtOTEwNy1iMjFhNTU1N2JjNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKuddGgSM5aQOchWRufODPF6L4ND9i8FsXUBl3p4JElY+q\nHUwr+nSz5Nj9M3IMFVmR3BLfKqVeokM3McFvP1z+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5AbzKpUPgPmr8xrqyBQeAmHv\n/9cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJsiUn1/Q9eFkqQ91QaduXMQFOqJUazyqjKcYp2i6Iz7AiA0YksGbuUs\nwugFI4uVtTBgJEz3wrxOW1LP2nfDyote7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAURzug2yFnJcVz5taY0GfqoPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMThhZjE3NDYtMzU1Mi00OGMzLWI4YTEtNzBjMGI4NTg2N2E5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc4OThmODBl\nLTA2NTMtNDE1NS05YWYyLWQ5Mjc3YjJjMTViNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEsiidBByGa/eHzjN/rqDEG0OoMpKWJqL/b788g8reCNMmP7DZoC0CTp\nR/yjj7f4ZEzYL2wEySdgLbGSfJCObeyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHTTudkG\nPrJGwcIkYu+2Yz8DIG4xMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiB9IOOelczM9/Kf9XDuPEOprIgqoszXHuteU2qbDmdSCQIg\nPRdV+EdjzN6ljnmwsvFlubkMZrNU5BLjdwxTlp5Mxro=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1271", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1271` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAXXh0Es6+CtNWvC06SX6d7XBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzODRkYTA2LWZjOTQtNDZmNS05YzI3LTlhZDBjMDIzMGE5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZiYjE5ZGYtMGQ1\nYS00NTdjLWIyNmItOTZkMjU2ZTNkZDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbcxeGUwcCaopfXpNDuaQVCzh8Hp7aS174Eb2BXilrNdLAM4IAwfNrHAUcZok\n8oJ9wyyTSG1nPFs3dvFMsrkWPqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUzaEnRHO2zYJR0kTDFKX1D48DhcwHwYDVR0j\nBBgwFoAUBbG//aT6O5/aDasWSBmYS/CJ35kwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEArlo1zhwV0fZb6sfvxSs3pzr712Jn3rQWZyI1vX4+\nmU0CIQCLKCq21kqHaeoq7rsFD1frvvQdaDEQcc3jwVQ1L7GLow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATZNNRHIwO/eRGhS4HPVRgdYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzg0ZGEwNi1mYzk0LTQ2ZjUtOWMyNy05YWQwYzAyMzBhOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd5tvldh+vmo23U6H0XV9MDgqWvd8Nx35ydXphUFceEecq\nRn/ppkPEhTYYdE7ZUnf2iX0d88MRhBlVZnMp3UJ2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBbG//aT6O5/aDasWSBmYS/CJ\n35kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIV32WGxu0xHUIFjTL2YZ4djGX4mxSBtGgIsznJIV9smAiEA0Q208TM/\nSMr1ueMXe6YQJXGl9R46/lX4/su22+54mFU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAaSg8jVTj2IbX+vSFTj4iik7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZiYjE5ZGYtMGQ1YS00NTdjLWIyNmItOTZkMjU2ZTNkZDhjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJlNDI3ZWUz\nLTk0NDItNGE5YS1iZTA2LWM1ZWI5Yjc1YmY4MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEilNjtbx13sOUpy8G/vyjvnA/qb5AlIaNwJQYOwhiSgFlgR6Q2P+nq9\nvkocS+RfE0CG8v0kEpVtQqwrjX138hyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFM2hJ0R\nzts2CUdJEwxSl9Q+PA4XMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAUoB+oFRVnmLGyBAkD7xo93k5hijql6YcT7+acPdEHDwIg\nYi65ZTj1JDOUN6wXmlqpAi0IEBEAKKqrz4JrhaI3dqM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1272", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1272` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUFm6jyzPE1mk3F3eEExBJWoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwYjk1ODIxLTU0Y2MtNDIxZS05MTk4LWJmYTFiZTQwNjVlMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODc0MjJmYTAtOGM2\nYi00MDViLWI2NTYtN2Q1ZmExMTcwZjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW+oKodFtYCjRzenwPr3czMUTwyW8HQjzXWJQw2ZxWoDeIwrZIE+J632jXl1R\nFMO3+sIiEhm1I8a0CU1wdtYtz6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn8OifAS7PPHsEBCPYGF6X8HIDSIwHwYDVR0j\nBBgwFoAUnDJpnWWq8nO/ON3NcHhNVAUt7L8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiB/0Hl3RgwljrgYYYEhBtYsXedh7lS1QiuJma6jQuVx\n8wIhAJ/50EnJqsZ7mD4wKyA+4IeshTWyae0upYrUadqjrGdL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAamtVrIOlQw4JcUKTYpI0jp7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGI5NTgyMS01NGNjLTQyMWUtOTE5OC1iZmExYmU0MDY1ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAakVi/A+1FdnAcr7Vaoqllzk7eOfQHkauhyAHTor2u1T9\nHRTbe4t+8ZaygLFIkZasYBpMyYitHtiRu4kGFqOvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnDJpnWWq8nO/ON3NcHhNVAUt\n7L8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUkACSXXobbQ3p/HUNKv4nKREP/HIdFykYXYDSXO92t0CIDr4Wva1YXSe\ndjiOFYQyuON7LpL1563Pdw76f3xxNQiB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZV4dj/SyedHzqvkJTijwPV/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODc0MjJmYTAtOGM2Yi00MDViLWI2NTYtN2Q1ZmExMTcwZjIwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJiMmQ5N2Rk\nLTJiODAtNGM2Zi05YjZhLTAzNzJlMDEyZjVlODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKErmnB7QUKhiIRf1TJPOj9WuqbJT6ol5b5TxuL7c/DI57f4unbEAVro\nFnCsBjglWlNdsRc+RGQFsJC/blxT+kyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ/DonwE\nuzzx7BAQj2Bhel/ByA0iMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAh1WyCJ0zkiZFCRLi2fSpzkpYz/kZi8oadoDrTULGAxwIg\nP0/7DmHzbFciA9T9NnEp1KgmiQGk6XBnCQsyD88EPcg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1273", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1273` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISATG8WbEwaD2Gkag02NTSt2MMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwODk1NDFjLTdjNzAtNDEwZC05YWEyLTM5YjM2OWYzZDcwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTM5MjFjYjYtN2Uy\nMS00OWY3LTk4MGItYjRlYWM5MDE5ZjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEa0FNz6J/6IuP3MQ3F7SCMoh00qa2HobJSls9nqzdYK6Ol8UT6pnFSZ1iCcx\ngI46TYRIBsBxxn0Exa6UVPkVg6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw2czwx/tq7qW9z8RcO5gxs6c9fYwHwYDVR0j\nBBgwFoAU1ei2OItOLuhxDrSW1m71btbIIZkwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA9MJKLjpFEMLaCoJ7IuKLqMJSz9Bl4fFtW7d1g7Eg66ECIGJ5\nKwYs37+ZvUCUNqjzCQIcg2w6dQJgS5bpjXaaPKJk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZqhUYTo0HMvXWok18bSX7QEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDg5NTQxYy03YzcwLTQxMGQtOWFhMi0zOWIzNjlmM2Q3MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWXaW5WpQagdYu8GWgAUEKimvLyCzt8rAk9WmbymYLtHf1\n1m3kh2e5+aMq3iJnQPO3oOCBWf/POFVF+Ft4UCS2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1ei2OItOLuhxDrSW1m71btbI\nIZkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCIsB+V0NDqpxngmBHfikbHgCTnRzOU2d7EOw/i6Ek/kCIBkUDpt5xuwe\neXnW0ueYMt2J2DWyHaPh+/gEQ+fWGuUP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQ0neQkEolChQDpS+SAj9m56MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTM5MjFjYjYtN2UyMS00OWY3LTk4MGItYjRlYWM5MDE5ZjY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYwYTkwZmFj\nLTcyMzYtNGMxMi04MDRhLTA0YjI5OGQ4Mzc4YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEYlPvBqLerETLai/FKqXbwm/W35RsIEHwjdRjrCuuof0rbsBPpwot0n\nWlRZYBfCF29r2f89NTVX6BZqOlQmanCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMNnM8Mf\n7au6lvc/EXDuYMbOnPX2MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAvgmzeb4A7+lYVmtZqL/yqQRCCLG68OhzvMiGf0p8ljMC\nIQC6aVNbiY/0kt3Oe0uErWVf19YMVLXabVZjYBjYC2PlRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1274", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1274` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAeiJs3ROmJDCuOXEkRzw1yjAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwNTMzOTc5LTIzNWUtNDAwZC05YmNiLTZlNzNmZjBlMzQ0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGUyYzE4YzEtYTIx\nMS00ZmUwLWFlNzctNWRhMGY3NDQ0NDQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb2Si950q7/LXGMpXpRsE/YSG1mSJ5FVleAevENOmI66y0iexnLj8DMUV5A1x\nTtGB8E/XcRYpasZwsFmCVGg4wKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeutPXYfx8qXkohB3cK86/I/C6vwwHwYDVR0j\nBBgwFoAUjwgLPBSbLxO7DoygFvRGrxynP6wwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAntiVnIONELy2TBQ2coAjRiBs1LW+Q16d\ngmbPAg8QGusCICkb1cxT27zEyxmT22cYNJcJqNx0gW60kkEKCedMCA6/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQaksGBIPHmP2dLV/fDd4xSwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDUzMzk3OS0yMzVlLTQwMGQtOWJjYi02ZTczZmYwZTM0NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+Avm2f8jqyaK62UVB3MuX9AUHaPjZfyx9eSYvaw1F/Ei9\nEXWT+em5Bz47iITRNO1Rqpv1gCA7qJSrdWGCLmLgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjwgLPBSbLxO7DoygFvRGrxyn\nP6wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbqCQS/xIDP7nNFBigKrlAj+xD0DQsa33UpvuxXd9etYCIBMNPFmLRg6D\ntfHVBJ3f4t+BUiqo4e1je61PyTCQ+c2n\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWWP6KfqTcNDYUsNWVgLtowQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGUyYzE4YzEtYTIxMS00ZmUwLWFlNzctNWRhMGY3NDQ0NDQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUzZGRiZmEy\nLWNmNzUtNDEwNC1iYmIxLTQ2ODZjNDVjN2IwZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBD3rloGpI/a01I2EtTFI1OsUgNNLUM8/5E26ro7BpWlnkwiEzHaUciJ\nT1XvZYDS+X/QbVxiUMdIDQWeVz8rwWKjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHrrT12H\n8fKl5KIQd3CvOvyPwur8MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAjBpQ7FZzD/WaRVSGuO0dFv6PBhISIqBalSU4ViRbumcC\nIHBPRH8+7auDfnnkaDAFEzRgXJQ3ohy6J3zLoDcow30E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1275", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1275` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAS6ggvAAaDOacEscQVY4bI59MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyNjcwMGVlLTRiZDUtNDAxZC05MDc1LWJhOWUwNDZiZGU4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNkYzY5ODktNGFm\nZi00NjQ1LTk0MmUtZDUzNTQ2YjE4MmJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE32hFQy+ggKUpAtA01lWgybHdcjNFGRFeher/Ax5wpNbGAYuTfkBr7OuTzrBa\n2SyU+Pm5G6bhOgl5VQKwiQIxgaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+vYuxYUYTbmu5YTn7UFTr4/ofE4wHwYDVR0j\nBBgwFoAU/1QWTws48DN/Xgh3cTX542nvcXAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBju9UxjWM2WOmdMHPJJZmaK0aJiSg6MQD0\ns1mJSsYFlwIgFAd8Az+odbQr/VVb7GGt1y0SOBYSb6e4sDsyWSd0dLw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbsf/gyGN3/5L5dFGqeEl7siMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjY3MDBlZS00YmQ1LTQwMWQtOTA3NS1iYTllMDQ2YmRlODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmQMUoJrFtkCTHBGaNPPps2YKCy8wgiI+7uJQBlj5yFlwF\ncPPqqFQY+FVLEfk9U8hLXn6gOzuUvBqN0TmVtCDPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/1QWTws48DN/Xgh3cTX542nv\ncXAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLWPWkTEp50gVydx2uCArpgoIiWSmDjg72ElDDCMpIaICIQDDLbs5y24f\nSbmU6s6L4aoJzAuNHrqZKx32EDJeR2HOUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdUL8ejY7wtoMPIC0ywVDxdCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNkYzY5ODktNGFmZi00NjQ1LTk0MmUtZDUzNTQ2YjE4MmJiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEwNmE3NmY3\nLTZmMDgtNDY5Yy1hMWVhLWUxMmY0ZGNkYTA0ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEjFE4WJAMW5b0Ppqj1xjsxyXuMHfdQw0ywTW56HAmJmSuPgsMI2ob4c\n/wfO70r1IizCKFp6RuWxZvsaYiKIvkijcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPr2LsWF\nGE25ruWE5+1BU6+P6HxOMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAgq3VPd1VPdC+cixXIJwk92chgBTz3TpcN/RiMlFNa2EC\nIGLwyUQzNY5WIUwtyHnNsEwZO/4tANGHfBh3Ab1Ko7gC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1276", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1276` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAY5jPBaVm1/i8tmZB+fGo21lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmMDljZTU0LWNiOGYtNGUxNC04YzczLTFjZDdlMzcxMGRlZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWExMDZjMjYtMTMy\nZC00ZjUwLTg2M2YtODMzMjVhMjA5YTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvD+cXKe8meArof+mHKkdEYa1vv4xVQeyke8M03QAAVu0Y7LvaEZQqX0Sf+Y6\n9n5Cd2cNTjyqkzAxQN+BOHxZyqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKpmhGGtiYYbnAODajyJ71ymmZF8wHwYDVR0j\nBBgwFoAUkadTdTkLYoFh+6vY9/IWzCi6t4owHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIE2TOMnFqsO3cNIB98q1ddadEaCK\nH1aNlnmVfK9G6PFZAiB1Q8+9ScTwe1iP5kZq16Ev304e95+4eBTM8jpm81ElLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAebg0aIUlIiG6cNiIrMmxz5wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjA5Y2U1NC1jYjhmLTRlMTQtOGM3My0xY2Q3ZTM3MTBkZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUISFoBd1h6TJM4aZrfdS88Kr/ulv9qmvcuUrI4UdR9DCW\nI1UoPB5USpDOj1gIf1ejfcr9N4zAuXadkTDqYYvbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkadTdTkLYoFh+6vY9/IWzCi6\nt4owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIBxNRxOvr4IP1ScbiIyOZWab8vns7zw8Vm+zcDaZMmQCICl0R52neqqH\n90PgI3sYqATK4Oc/esmIwd4pLnehaxC2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdS5tnU5vo32XwIYi+ExBjH7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWExMDZjMjYtMTMyZC00ZjUwLTg2M2YtODMzMjVhMjA5YTJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMwYTVmNmVj\nLTFmMzMtNGE5Ny1hYWVjLWM3MTg0MzAwYjhlMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKbvlcZQxiy3pjiTswGb4VyMONzsOxg5IaNHDYIudRGspIosmhaQVswP\n7jRqhZhu4Wz1EDJjuSXgz3qZ0yYYfGejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCqZoRhr\nYmGG5wDg2o8ie9cppmRfMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiA2itJpWAN/hyA41J9YdxHgDE+CI6rt3Bj2O5AsF8VWFwIg\nFvaJHN/gxTsLcuv3eAm5gmViKSkg8xJ/rAGubqrkeao=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1277", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1277` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAfYR2it5J0+0C8hIwQRF2urZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3MmYyOWY5LThjY2UtNDNiZi1hYzc2LTA2NmJmOTAzYjEyMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ2OTQwOWUtY2Yz\nMC00YzljLTg2NzctM2M1NDhhNDg1OWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETBVkB5hRd3xHO7OKCzDZ9BcBZYlLblnakmuvJboUKM7rdONqkeVrl5EuQb7r\n5heGyiwI726Hdy/NPksSptK6y6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjpr9sA0Cv4LtBIWkPewbeD7VB34wHwYDVR0j\nBBgwFoAUT62Fi11uepBxnxkvdOtcQHhCzHEwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAKD+DWQb\n9y1EmoELmNRqx9AepGQ0/cNkOwdLF23ny24/AiEAymHoYvhDBGjhiCYfVQnDZae+\nU4CRzNzpJWbUWFjv8Os=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQx4IeH2C9msMgtjMycWdrOqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzJmMjlmOS04Y2NlLTQzYmYtYWM3Ni0wNjZiZjkwM2IxMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZpt2YzlbDe8BXAPvsewuq9iEsl4HQcDrphayOEjPoUUcc\n/ZqOXZQyoMG+P73O6hJAwtkoWlnvuJz/eNp4V71yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT62Fi11uepBxnxkvdOtcQHhC\nzHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIfuNQdqrP9CVd6DhDKbeo2zpxPVRzKbydkD6YmIRKvgCIDwNhamDDCXb\nTzaqvpwpQDKqkJvjWYXUMSwsUIn61jhn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAYwAR+2ZTuNuMPg0/w0SM14mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ2OTQwOWUtY2YzMC00YzljLTg2NzctM2M1NDhhNDg1OWY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZkMTZjMGY5\nLWFhMzAtNDY1ZS1iNDZiLTliYjM0OWJlMGQyMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC9gO+GL7u7+iRa+ySiOlyoDMgSg/orwEMx/Of3rQiT15pjvC5mBVmqe\naxYGszD9Zbqk5GgmMR8MfoCRCNGr6QqjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI6a/bAN\nAr+C7QSFpD3sG3g+1Qd+MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBL8iR1jG0Ys/z1QrQt/zOWiWlhs2asBqo3q1I0nmFr4QIg\nSTc8g/YYgNZM+xfzjRPpI1nb8lEMwdCU8/NBT3VaBnQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1278", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1278` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAQ33Ml21Q3yxO6s11v2rQkiLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkYjMyNWE0LTBiMzYtNGQ0Mi1hOGRiLTQ5MTc2ODY0MDcyMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE4NjQ5YjQtODYw\nNS00YmM5LWFlNDEtZDQ3ZWVhMjA4Y2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl62UTjewhgyG3/0pqKBD+Q8ljqJOSjZxDHa8b+Ia/wkuJDHb3xQJ4/XAHssj\nFMSE1RBcRS06qmIgso6ZzRSmGKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu0HY99r5whBKnWWxWzaz4inGlcEwHwYDVR0j\nBBgwFoAUPTuNTZmH3hVtPjPBtjuJh0s7C8EwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMc9Eodc\n9JG9OlEDjCEJvkWm5x6l2G50gh56uKiBTHZjAiEA1/9MoiaautSPzRnMrOERzwrc\nc4Xd8srNwOXx2Bj5anE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe/hzbYB57DHGk0PWJQXHSXtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGIzMjVhNC0wYjM2LTRkNDItYThkYi00OTE3Njg2NDA3MjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKcJwS4An2LpKdBDLp9Wo1q+tFZXcfRIxc8IZLQ0ymogMd\nLenqLkTZOnYlp9o1kFPMd+4HImPqaai/nO+0w20Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPTuNTZmH3hVtPjPBtjuJh0s7\nC8EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIxiVbRGpYojECUJkP0StJXMKPgFwdY4eTmXLqKGR6YVAiAkTn2suOz8\nhRyGmTPD7/POl3Sv/Ys6KKrxBYIY8ulZIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATAC9/bcU3vGMAAZoW3L/8hrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE4NjQ5YjQtODYwNS00YmM5LWFlNDEtZDQ3ZWVhMjA4Y2NhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMzOTUwMmFi\nLWU2NjgtNGExZS1hOGM1LWM1YWI2OGJjOWEwNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIOC3rCzrlXZjZXjD8FHUB4lh64uwc14FUkiINYpji8JtYFlxPtXsOSI\nocKn/j+jmMwfUgDh8Ga4JmINFnnccZKjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLtB2Pfa\n+cIQSp1lsVs2s+IpxpXBMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEA2b6YZUzy05YumjeeeuyCiI5m3t7toPbUE8TLCFrRMuQC\nIC4Meh5RtNTeKbewm2eH1aRCxXjZ/IJBQAQODc+5ilG3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1279", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1279` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAeD5hjnF7xMfGAEmHaDq5DWeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyN2QyOWY5LWMzZjMtNGFmYy1iMzc1LTJiN2NjZGUxZmNkOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU1NzM1ODEtNmQz\nNy00MTRkLWJmNDgtNDgzYzYyY2I4ZjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvgZz06tM5Z6sJyQCZFyN1v+wjdceFwWT9PkIuXT0Tqd3hqhPWW1PH5bXH8uy\nfGt6bdLwipE8/GOOzttXGePRS6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULaH5zTVg0aMsPbM8Az335Kq6WT8wHwYDVR0j\nBBgwFoAU2nB7ZQrcESJEtnpMGKuorRMYVzYwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCsQ28M\npD7stPZLYx34xk5AM/w4fj66YG6JZqYEWH+FGgIhAPZ8VHWFvfmjpMOawWi176WN\nEyR2yYgrEeNY+EBxrEmE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVneXmlmcS9RRS1J6lMjRujfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjdkMjlmOS1jM2YzLTRhZmMtYjM3NS0yYjdjY2RlMWZjZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4I34/cA8IOLVqGI7Rvi+qSi1Lnm2RAKc3aANTetID/CVR\nWl747mE1JC4zCsNKzTfbcdIOUob/i3c0WNlc5GBCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2nB7ZQrcESJEtnpMGKuorRMY\nVzYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXyqFYIR2gB8OZcDzdfXQ07SrVr7vIeKXdeLiCgNL92gCIHFBJkS/C1V0\nk8HoxjpoRFxQ3SH54JP26H/f1++4Di+a\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARc026XZugyLAZEAGsooPTv8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU1NzM1ODEtNmQzNy00MTRkLWJmNDgtNDgzYzYyY2I4ZjE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5YmMyY2My\nLTRiMTItNDkyMS1hMWVhLWNmNTlmZWM1MmMwZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF4hLS8n3yUa1ea4laosLhfa1MLdZolkytTVsk2mLOjumdqzAcf1FxGT\naqSmBzhR0EW7DF9zpJIe+hbMnoegRUijcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC2h+c01\nYNGjLD2zPAM99+Squlk/MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEArl+zqO4mdtAOJ8wrSbCzzLSPqo5DhAROKVSTeTnHU1IC\nIHB2UjiW0AkZbLcRwB8/I2eGQ3PToDTjuBqGvqbFGT5D\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1280", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1280` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAeXoqwvuQdbbu2fhNgqBXs70MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiOTk1ZTg2LWY1NGUtNDk4ZS05MzcyLTFmZTFhZWMyZjE5NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzllNDExOWItZTJi\nYS00YjM5LWE5OTMtMjJmNTcxNTc4MTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4MswEBZISiA57o8cJa+wtE0nQLRU/CRsQXHhW7M1LGYfbM8vay/fSWcv6urV\n5PhtE/ORo4ItSfb9VHCWeTPL2qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgqjFVSeDDlQIMqE/gS9ogXzNNBgwHwYDVR0j\nBBgwFoAUKjbGOl5uD7pDILB6NTkp6SQTbogwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIEwAdS1FHBi8UeFBNhAobYrbO5cy/y7S6UJrChHPocS+AiB7ighQUdwX\nux98+DhwUfF1psKhcJs0KXuW4rVqiltPvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbaR0GIrcsM90mzIci1Ts6QwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjk5NWU4Ni1mNTRlLTQ5OGUtOTM3Mi0xZmUxYWVjMmYxOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASF9x9ap2IrchFYiRkwl68EXN7QKclZeSH9plMr4ST0LHzL\ncUZSYO2VZcV/VqU+WeVOwITzIztrIovGhl8jLnV0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKjbGOl5uD7pDILB6NTkp6SQT\nbogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKg5a91My8o7xXubF+a5DnEZKwFEvjssZy+zTR09bCusAiBhP+RwZDfj\nHAi07p7tfxA1kbJJojX5qiUoyHUzl3WrHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUDksM/ZNyXfHJ1/1PN5+7IqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzllNDExOWItZTJiYS00YjM5LWE5OTMtMjJmNTcxNTc4MTUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY1YjUyYzY0\nLTM3YWMtNDI4NC04ZjFlLWI0YWM4MTVlMmUxMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ/o02TXxEDFXDFlHCB8vP007iLtPhqevkUQ5v3ulmebn1iTlJTmI/5Q\ngiwlrZMHojKs8+oKLhxwEAV66H7FcLOjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIKoxVUn\ngw5UCDKhP4EvaIF8zTQYMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiB8jPQpwHRoYJg/XGl2CQM5hoz9MP2ERuO2Tuj27cQt4AIh\nAKxCu4jTIzVuNTM+7LvpDEDXSh4csTBGppmbxujbxjQs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1281", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1281` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAX5Y6AkbSCyhV9/+NViPCDsqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlY2U3NDZlLTI1ZjItNDA2NC1hNDdiLTM4MGJiYzhlYjlhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzllNTIyMmEtZDVl\nZS00YzQ3LWE5MzYtOTk5MmRmYjhjNDlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV6UJak/GGr6MAuiWwpZvaSJR/FuIIEi+sNjFWIVo2nmATYEVSnfbQlPLYbSI\nLDeoq9V5X1rYgkt28mcbVWxvRqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0X/YSz35tnRAWExbL9veZQO9GlMwHwYDVR0j\nBBgwFoAUxssE3N/I4JNwlLMCQMpnK2WabOswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCvkIx8m9mavMhwb/8Ueln5m0quV/n2tmnPOaDuI1MmCwIhAId7+5LM\nPzWAJV7ksOU9sVAwX0kw5JPm8yJ8bqIhAJox\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVBmnW35V+/ZuYGcLxmelLUAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWNlNzQ2ZS0yNWYyLTQwNjQtYTQ3Yi0zODBiYmM4ZWI5YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSseEnvon8A2Z71BN+EFBlfW9i1VXSmjHeDPz+qd0hMW17\npTmVgL9/hTkZl0VTBJ6UugbgViVQUFtp+moEkLxTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxssE3N/I4JNwlLMCQMpnK2Wa\nbOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTncpbj/IFJGClLZr1XRJ5LiaG+PN7Fp7sms5Zatt4KECIQCUTYSLYlK8\nb8FxqtR7tlQ11QAqOJRCClQ3JgQ5a8uNYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdAimEzYjGkxKqHMl1CCV3UWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzllNTIyMmEtZDVlZS00YzQ3LWE5MzYtOTk5MmRmYjhjNDlmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRmOWFkMGEw\nLTdkZGYtNGZjOS1hNjBkLWY2ZjRhOTQzM2MxNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHFLK+fZ7DuJWMLlTFiHB0ugQLM2tRxlvptbWQ3Y8NjjCPdFSs27YK1/\n+g6JK7UWaxCe0hfZH0OQaKxv8meULB+jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNF/2Es9\n+bZ0QFhMWy/b3mUDvRpTMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBYE7dbUEnokKFtZgUElD3Dn37a7NIA0c4f5JpknpAnNQIh\nAKHQSeN7veSipda7vO02uCER/rDUbI9BCod/b8HMpG0B\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1282", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1282` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAel8EwRioH6L22fpNW0FN1NZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhODI1M2ViLTdhZGEtNDc0Yy05M2Y2LWIyMDRkYTQ3NmUzMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE3OTRiNjMtNTUw\nMi00OWRiLTk3OWUtZjI4MDdhZDFjMzk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOcGWHytQaLYb5fwZB86TB7vcLWtAMTmc2a4ZVzldWuDt/QfXXeIo43FwDPc4\n5vKNenG5zTbci762Ux8Afa8kLKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2gDkWTK2YwOxSeawUQBi4lhVuYYwHwYDVR0j\nBBgwFoAU6boKaex+1DUa0du3Q8ZUmVmvmBUwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQCNyy7bLxC0ZKdx8yTkC3SiSBwzHelicAO9/ia1gOLvGQIhALfT2e9+Z9LyzO5b\n5iLMDOvcw2wMYSqQ/A1+IRYcUQsg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWOwCC9eXujhcRO2S3BOXUIAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTgyNTNlYi03YWRhLTQ3NGMtOTNmNi1iMjA0ZGE0NzZlMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLwVtWTG1CG1/NZF4WXqN2h8siCcv31TVV+FRsLzYODNuc\nQ9m+cXIdbGzUWnRPi9kO/jAvDGJxGH7gWD0GWQbZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6boKaex+1DUa0du3Q8ZUmVmv\nmBUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfbNCUuVP/qPOahw3vRdyyFloHf+HpqV4O56J4ZDQXY4CIEsDpKgugToj\nh2PtjfVR9TTTKGEYFMQx6Xv8S9KjwwuX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAT8A2aLX9fmxvrGXpO9XXh74MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE3OTRiNjMtNTUwMi00OWRiLTk3OWUtZjI4MDdhZDFjMzk2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIyN2M4MzU1\nLTUzMzAtNGVlYS1hM2ViLTRiMTlkNTBkMGFlODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ8QEbn0VHGvyGO5h65d4aB6ooJ/2u39tuMnBCYVxi01ol77d7b8o2vW\nWMqtYkKLACm3XLyqX66DBKO79NXps+CjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNoA5Fky\ntmMDsUnmsFEAYuJYVbmGMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA1oDRK8grmRWo1ykT8OcBHnDisE/40OGr2oXmVeBIA7UC\nIQDUkSZgREypA3HWTZGjF4LDYfHl/TjEmNpGZzENCpRt9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1283", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1283` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISASbtEB9M6huXh+6eZSqe2hNTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmNzc4NGNkLWU4NGEtNGZmMS05MTM5LWE3ZDVmM2I0OTM3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjkzYTYzNTItZGVj\nMi00MzM0LTk3NWEtYzFlNDEzNzMzNzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmTE+RXGSevpney0iebCtHuQmi8M59YLknEebhTylbE3alDLVMd5aC49gy3uv\nCFJdDvKb0WRn52jfcxRgXqANP6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWMr/sMqB78na7HXlE23HeZ8PNDMwHwYDVR0j\nBBgwFoAUE7JaMWr3zzlEgkkX7gFlp8MHMlUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIHQ9OjOXShrVTvezPN2O5/18309eV+MbWdnWcya7KEavAiEA\np0BeYljLQZ0yR/cNYlGt7qGG6R/Q7Sh0NWk4i+jJ9uI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcqrIVrKRpsulKnO5+ojxE6/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjc3ODRjZC1lODRhLTRmZjEtOTEzOS1hN2Q1ZjNiNDkzNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBj2HxdqWp5yjQ6uZ8VYYID4tYOXsEtwxCZ29/Oz5hPRgz\nO+b96d0nfNZaZzICmgNG9I8RP7Wnzae6tp4wBw93o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE7JaMWr3zzlEgkkX7gFlp8MH\nMlUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgflfYXR6INIy6OBmEaO9jP0TbooRqiewBjw9zzYfEGFECIB3QnvDArRcN\n4cLpx07tPOcQtpq8xwwuerYaZcn9zTut\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARy0ZWcJWtANnCvipmvbLYkKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjkzYTYzNTItZGVjMi00MzM0LTk3NWEtYzFlNDEzNzMzNzlhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVkZWU2ZTky\nLTU5OTgtNGI1My1hNjg0LWFjYTc4ZjI3ZTA3NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHb8lrouYJpy6NX1qz0Ly1Uo0n3Cx24ze5bx6A8021qAWu19eTIYZxX8\nO2Iltk8RLtChjzfbW3LoYfGKlzkrumGjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFjK/7DK\nge/J2ux15RNtx3mfDzQzMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEA93qiIY1mbgKeSXEHKXTiOuaEw7y5+ybUy7TBT59ldnoC\nIDoDyyfHlBfrhBwFfTifERxDw4fgL5Ab2UXYRa/7Euwl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1284", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1284` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAaBk7yzDVSmz8HW4XiH3xibNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwNzhlMGYzLTY5YzktNGMyOS04NmE4LTNmMGMwM2ZkNDk4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVlZGFkY2EtYzQx\nNC00Yzk5LTk2M2MtNTg2ZTE1NGQ5NDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETxnOsdkxlmEJbteqDgjb/2SZ6JtzlJ0O9n6co/CBD6DzFeQR4zJmcGpE9lTL\nCTFw64NRKY4hdf0ksP4pWUXxaaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0wvnHcCn3pBaUW840xoDk163PMUwHwYDVR0j\nBBgwFoAUr4RlymFIhV562Ts0KgoBboqQHocwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDbJKTPKWA7crCpbHGMFZ7OHg7IqKA5h3IP/1ZaO6lr3AIh\nANK3856NY0R3e3oazAAa/DqLwCgAQXnyGvqsu1+7gRT4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVpyrKczpX+fSvCXUKP9KDYWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDc4ZTBmMy02OWM5LTRjMjktODZhOC0zZjBjMDNmZDQ5OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsOjYGhN5flDqsSnBXRNR6aKl9sf3nXDx693af3bAV0L8U\nH2ME08jugYFjRNJrfSZ/z1ircXPeDNs3WBwwwS9Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr4RlymFIhV562Ts0KgoBboqQ\nHocwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJjCM2bMLG407k/XwJ32SC6KgbDvUGYdHQkRgiOHZRf0AiEAoB4nDzE7\nVd/NW+ZUPCTS3P9Nyova/N+1IjfkPZ78QTk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAf12eTWvut2KxMxAMribHNHiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVlZGFkY2EtYzQxNC00Yzk5LTk2M2MtNTg2ZTE1NGQ5NDZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJkMmVhYTcw\nLTgxZmYtNDA2MC04ODg3LWU4MWU3YTA0YTg5MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH9Jhxjzxz4ycca3vrsjp8WJDlGH1TzGvjSRYE6S9j9xw0O3AQVjZ85U\nYuUURvRMEB/bqvX1KC+f0CafrU+l2t2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNML5x3A\np96QWlFvONMaA5NetzzFMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBqISggQnvOEEJB5ktL3eLwK5sL6ewhy7TA/ccc1r612gIh\nAONDm0+oNc+MfMIb0479AYVefcqatNjXJnp7B0NFv4u4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1285", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1285` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbIur266A3tzjwH+n/uHgPVxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNTI0NTEyLTdjNTEtNDhkZi05OTBlLTVlNmEyZGU4MDFkZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZkNmJjOGItZjE0\nMC00NTQyLWJiYTctZTFhZGI1NTlmM2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWTuTcquPd6eH07b1m1sDrIhxX/hw1ZxATMSvFduimEQ9HFkOrhXziEWMQDwf\nMtDJFeK82SnBC3PgMgwCCBUEWaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZCXO55fe2pWwl1zTZZ8gRtpTvn8wHwYDVR0j\nBBgwFoAU4EiVSeeuJ4vbtY8oQ4CvDdAM4nEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCQfIlYt9Wv\nf/jHlT4GGtkgtcm6tHKTHKtsjhg4fRmifAIgO3LcTBMAFaN3rPJLqcFjDBJU+4Q/\nuPsL4UF8LKYfjq8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX9rf0WYXbWxXXQXZHvQJyqnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzUyNDUxMi03YzUxLTQ4ZGYtOTkwZS01ZTZhMmRlODAxZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI9tJFBCghVGlhjsZCgXDYCDUPQ7iIoX4CEmtrZNSqpagX\n6jAtoAYmU79WZVY3qe69RnoY7GMiE+1LeukVK7mZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4EiVSeeuJ4vbtY8oQ4CvDdAM\n4nEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWK/GucnwZ6X92/i6eOOdpFVzF/1ulWoJfrYQ8GnzRL0CICf7Q29ZF88h\n92QpCHXwRauQdWUlLmws+LJueKs9j3yU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAcT1siKn4mTNpeSbSuSbrjrLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZkNmJjOGItZjE0MC00NTQyLWJiYTctZTFhZGI1NTlmM2VhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZhMzMwOGVk\nLWNhY2UtNGUwNC1iNmNlLWIxNjg2ODQ2Y2Y4YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI0hsfIX5IXsqSRbzCEPPpnwALV81zes3fzxGCNisp2p69Hy3I68LSu3\npP1b0jeXwKVqsVyCP96oNGLIcG+f5UijcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGQlzueX\n3tqVsJdc02WfIEbaU75/MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAili3mUPqU1w2QU7PE/3iQRHITX3i18AD2/yA+7OVM1IC\nIFB2u0tlsVm103auBVG28g4BUrW0eZk6SmkmL5WrdqC5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1286", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1286` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXL04VoSiLRVjyUolROkkesOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0YWNmZDUwLWQyMTAtNDhmMC04ZTgxLWI3OGU2ZmUyZmIzMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGJlMjBlYjMtZTNl\nOS00OGNlLWEwMmQtYjQwMjg4ZjA3N2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqg2GSHxsaq1HjaxsIpiOQT/a9KbhMUpWACvT0RNzcvGsPUr7cpz4YpiTgbG/\nkFSJo/PftXLPeBNhtl85lCpy/KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUELIvLv6mqHMOuac8mk81OMGSAlMwHwYDVR0j\nBBgwFoAUD+tZ8KJftUVu8SLGh3jMAs5KH5MwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgdSBP8a97fq2si74ZYeRQpdPC90BFsNUxks2oTX1/utoCIQCNQUV2WDO6\nDSee4BAd6i8ZhMwv8RBroMxy+PNJjfG8QA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ5ncp1mVPy0xJRVMuujUW5TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGFjZmQ1MC1kMjEwLTQ4ZjAtOGU4MS1iNzhlNmZlMmZiMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZv9qYLK006a+C170nt//NBt5chARcO/TG6AB37BnaRReX\nAT/8OI1MlZ+XnJaMNQdLdP7Xig41ydABeU1LCT3Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD+tZ8KJftUVu8SLGh3jMAs5K\nH5MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIWeYS320oSYkexIoRoY+H9pxGk7XyD9JYS61vRA8c5MCIQD7bz50JqkT\ngDq1+LGjI9lV9dgnqnfhRjMvAeiNGcFvPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAcVO1ZMJn/61FQl+/thRWtWRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGJlMjBlYjMtZTNlOS00OGNlLWEwMmQtYjQwMjg4ZjA3N2E4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVlOGU0NTQx\nLTY2NmEtNDY1OS04YWVhLTBjYmNiYjY5YTE3YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPFPdCHDem4P7xVJ3SzdfGQ6v1mV/SbxSyeJIWqb4NMjGdsBYxvQimT4\nWFj6iUfC4JTkPlIpOqU3INGbp1ZihiujcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBCyLy7+\npqhzDrmnPJpPNTjBkgJTMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAzOjW1xYMcaA91sysU72ek70jBdawWQ06mUgUVRKSsCQC\nIQC3UKzKZpWxcAHjq5pLsJd1DKa07kAW6BMKNtaF2rFNnQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1287", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1287` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXGehsV6Bwszq1GE/kpwI8WIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyOWRhYzU3LTU3MDMtNDYwZS1iOTRkLTI3Nzc3NmY2YWNkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI0Yzk3ZjQtYWRl\nZS00NGYyLWI5ODAtYWNhOTg0ZGI3ZDMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoSJhpHT+z6Zh6WnwRmLnmHaUJDv5HYCfpTTrD4rxUwC9S5Y6xt705dWCWgtV\nn9Nxhm06bxTBIAgB9V6XHQQzg6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSUKbLjYiDl3M5ch31onQmhKnLTUwHwYDVR0j\nBBgwFoAUBG8ufVgWfwDfdTflfAfhtzhjOdcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgUsGRYdGMeVGFtfxAF9Gc3E0YwYdoI3ja6+ah5Zqao3sCIQCs67VqHgad\nGX25UL8XlEUpqy9uakOh1ADI+z2w0uRmlw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARIXsJA1uJHZ4wm+UmZIsQTQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjlkYWM1Ny01NzAzLTQ2MGUtYjk0ZC0yNzc3NzZmNmFjZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGR+cXPDQ9CLvvMCSan9DOZbW2q2ut28BzZHsMc5v/otNw\n1vFDqsknRbpIVoYjUl5iwrpbY401jL8JWt9K/Gu7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBG8ufVgWfwDfdTflfAfhtzhj\nOdcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOqJB9gK+92kBaNXpwCy1YuDNPG9VjkaKkrkQ4o5F0w4CIFcvyMKktrOh\n+WrHl1uZpnezZgr1ppRQSriU0tgutdbx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAXHXWkumS7zFc85UQKdWRn3QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI0Yzk3ZjQtYWRlZS00NGYyLWI5ODAtYWNhOTg0ZGI3ZDMxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJjZmY4OGI3\nLTE1YTMtNGU5OS1hNDdjLWIyZGNjZGM3OTU3NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA2fzZn4ke+ZGrPXnUm+Uz+uq1L56E+pc7UgcFFW467HOZ1W/XZanMDv\ngKq8Uf5pHRmR1nf5Aiynif5CZ49vasGjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFElCmy42\nIg5dzOXId9aJ0JoSpy01MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAtLXbC4XRz39M+OB+uV2kHeuNe7GoUO4Flziiy7x2fEsC\nIQDxUzcdAPjT6WpU8tTqBjWGnURMhZzSAtPSIRcCskg3Yw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1288", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1288` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAbufjshlGX+M6GI+vRjCYHNDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzYzE2YWE5LWNiOTQtNGRkNS05NjY0LTA0NzU5YzAwZGJjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZjNGE0ZGEtNjZl\nMy00MDdjLTg0MWMtMjFlYjgwNjk0NTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP0EMPVYJN/SjLxHO5o6YpOsG+pAn4TgEDJjy/kBvLraCCLN+8RnmHeuxBI7c\ndntN++H3mZdUhJ6LrZQRU7ZVi6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULGqo/k+B41rvgolpfq/DtFz1HrUwHwYDVR0j\nBBgwFoAU0Q4KQXo6wlCJP0GwebgzC+eUF3kwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCDU0QBjZo2iv5qaF7ggvWGboYcknn1w8epZgyQSC10HAIhALSpzgcO\nHHZCPbqEPQmnajHfhPCLYGl7eS1PJcIGpVnF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVPpBk7Rxh5DWpFpW8nt2JEtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2MxNmFhOS1jYjk0LTRkZDUtOTY2NC0wNDc1OWMwMGRiYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnb0+CDmgTAwze2s8YpnvA/VE6E+SAzWc+RYAX+J/XgDdR\nSgjGqg/OeD7xMx1pO9RlmxFcudO7OyMtj9MfgRL7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Q4KQXo6wlCJP0GwebgzC+eU\nF3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANNX3gc34dLn+EVYFJjOnPzZBG0dldUVHHtHa4oRgvNmAiEA7LTlFmlK\nPJ/1DsU8oXvXti99nu7rxMFgkrxYsBQameE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdwkWOAD+1YEUVqe+S8vGCs0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZjNGE0ZGEtNjZlMy00MDdjLTg0MWMtMjFlYjgwNjk0NTEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFlYWRiZTVj\nLTEzZWUtNGI0MC1hOTk5LWM3OWFiOWJkYmU2ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBPZu2clPzkcsSZsZWVYKhi5OGrEwEDm0xV6J3COSc+BK+iM6J3FVLMZ\n0c2EN0n+Cl+/kcVPS6/v+qqGsMfI9PmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCxqqP5P\ngeNa74KJaX6vw7Rc9R61MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiA9AmKMcauBgozNF/29VdSFmtcxuvrUEYraHOidlbMULAIg\nam5nQoAQoZBPjWO+0+1rTFgjkkXC//wesSXKrt70k80=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1289", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1289` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAVA/BGD5LIInMpDy45vBCsDCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyNWE0MWZlLTM4YjEtNGJlNy04ZTk1LTE0NTFmMjYzMGNiOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgxM2NlMTctMWNl\nZS00N2JjLTk1MDEtZjVlMjA1ODVmMGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmA1TafkXODkzm2tnwLdYHFooA4TMS9nkOyYj2szm69f08t5MNJMKkPxBx+4R\n0PODthDho1SJbHHtzVhB6cnbAaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8zRCWlstNmSShTpEzHTAvOfggpcwHwYDVR0j\nBBgwFoAUY0VyLtXao5COx2eJIwelTTshG1kwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFFFwZSBUZ/sMPbB8/+j+Zcd4/Z6Pym23tSrjlrD\nLDGaAiAsBrbMJgv5FJK/acj/SJBp/tXZ1HbEmsOeMMRIu7TwEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYAxmOD9mO7p06WJTBduYrhyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjVhNDFmZS0zOGIxLTRiZTctOGU5NS0xNDUxZjI2MzBjYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6bdXhPz0ORbnN6JaCHucBCsXnIQA+uEe0KjNLrrOzHsnB\nQ7umSqLtIJGauLL1RaS2KtKC+FqFkkFFEl6GNfUeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY0VyLtXao5COx2eJIwelTTsh\nG1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQIdDp0wGzKNXS+On5ktZ3UIiy4U3tRaHyLjUXCMPl7ECIQCsSKwKnVuY\nv/bJ6dDrsh6Yw1L/5nGZUJa+KlSgIuGWUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARXGtBHV7BcTsod9qvqvmVchMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgxM2NlMTctMWNlZS00N2JjLTk1MDEtZjVlMjA1ODVmMGEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY2MTI5ZDgz\nLTBhNmItNDdjYi1iMDI4LWUyNjVkOGVkMTI5NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPTy1br6ZdwR/g8feL+PfGR52FQQPmQUL4QT/mtabAjQuMgmQzlp7T3X\n0SF/8RUZvFsvz1mRCq/o28B2DQdl/zujcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPM0Qlpb\nLTZkkoU6RMx0wLzn4IKXMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAh9UJkKwOZwiPwdxYfx92m5hvrv2yCtM6ncUngsDnyKyAiEA\n9hqDPtlb7IsBN0KoCBvFeOoBj4PcPHCiNSf0xYsZ8pQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1290", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1290` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISASpSx6jr11o0OB3zKjnQZWKKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyZTkyNjNmLTRmNTAtNGQyZS04OGM5LWM5NDA1NDJhZTJhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGViNDRmMjItMmU4\nMC00YjAxLWI0MzQtMGM3YWJlMWI2YjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpjnUtY5T7kNb72hHwlvXS4ol80qLbRCY/O7CEBY4mvOaU2CzQq64dXofekBo\nn/vz/i5kkGxh1KRDY2fGOkj/kqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFF27S02JQYtlGVC/0gnVCAWMxNcwHwYDVR0j\nBBgwFoAUwF5VrYGplxxtHnjP7tbC+dNhcAIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCwdnAb6lq9E+s9aYxjSJ64K6Ez7Tn6imBv6Woc\nzC1AVwIgarY8qjesUZ1PaYbOUS0zW2r0O0bWyS2GFMTpP1n6g0Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXtgC5Wj4Ei4k69rP9fr3zTqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmU5MjYzZi00ZjUwLTRkMmUtODhjOS1jOTQwNTQyYWUyYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxhIeFu7CwN6mDaZzXFZkKPsIL9XhXKM4LHZHHDUKxBJQq\nw1Laz0y7gtOB+ER43exvCo2SjVR0evmwxDKi7Eveo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwF5VrYGplxxtHnjP7tbC+dNh\ncAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJyVnob3EeuICECitStQ5NEdSYAdf/pTVjtj6LOVgvCUCIQD5L4NZ3df0\naLcWyDcAbDGHYvYlkA4k37Lq4KOK6z90sw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfOEeYu3WiJtjMtL6RzbBr+AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGViNDRmMjItMmU4MC00YjAxLWI0MzQtMGM3YWJlMWI2YjliMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRkYzZiOTJi\nLTUxYWEtNGNhMi05MjViLWFiMmMzMDYwMWZjODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEeUMcVMyac5ggmWj23Cndi5AgjcA7OoIXOttLylBF9bE5DcvCWLdmlW\n/d5xoY6H6NfYVGyIGgCkGIsNoBfnn3KjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBRdu0tN\niUGLZRlQv9IJ1QgFjMTXMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAArNn+kCK6tU0IbklUXQ7XgIDvO9Rxtp/tnIadofdAmwIg\nSRAnZ1UbqrmJO4WURs4Wu9u5uFu6YVjMzT5lR8aaGSE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1291", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1291` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAXOM/60I/j731r22JuPTYIt1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxMWJiOGU3LWNmODctNDk2NS1hMDI5LTdkZWViMmFhNDFlODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAyYzc4ZTMtODgx\nMC00NzcyLThiYzgtMmQyZjYyMDA3Y2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUaK8ssReOoPVJxBJ9d2Rq1A3ut36IZ2HVCEHSK5LYS5MGICrD0djcsaLOS+I\nPQD4mHx1YcBqouMpasQtatOgY6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ind84rtH6TRTgHEOT2CwQ2wOIQwHwYDVR0j\nBBgwFoAUk2sscUNTtfjwi9mCGNhuWThsZDAwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCyEa4lyGTKMy1ep2U5WrWMOH4qTCZxpFmxCpZ2KKStrQIh\nANWa+yYzDRjgEc1PrxQdmFcCsbo1xfMUmMXiqbIxlPeg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYbk7+xe1jJALFexwqyfPG0lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTFiYjhlNy1jZjg3LTQ5NjUtYTAyOS03ZGVlYjJhYTQxZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8cK3jdc9ttR4dk6f6C/Cmgw7EUPBKtWkBOtF5RYalc+pM\num/O4edPicthPllqEQu4AARlZXT0KiWImjyo0Riho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk2sscUNTtfjwi9mCGNhuWThs\nZDAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCXeagYxLVFTiv79GnK2M5l+9L0t6KTUMRmW4n/zO1bACIQCYfJ4bNcJW\nyHH+SuGtSSFHGsS4OJZC39v46CAz0yASpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQ4iWBGqbURSaNaqEaEmsLppMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAyYzc4ZTMtODgxMC00NzcyLThiYzgtMmQyZjYyMDA3Y2NlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyN2RhY2Zm\nLTMyZDQtNDlkZC1iNWI2LTMyYjZmMWE3NTBjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNf2lRVsSswMot6POx+ThMMK4+D+M/OcfKz7hybP5Bbb+Zwd2w9cOYvj\nDKVMqERAIEEL3SyYbqVkccX9ka3p7CWjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOop3fOK\n7R+k0U4BxDk9gsENsDiEMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEA5G5EPtSEIrk0tL1aUat9b1PdwfQuy8iLFD6VEhyEqycC\nIA5gN9pEfzmj0mbt8x6hCZWrOWYOnEL5wKHDUXn3aJ9e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1292", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1292` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISASR35Ackq3gYXRP4hycjkY+FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmMTliNjYzLWU3OGQtNDBjNC1iNjNkLWQ2YThkNTAzYWRmYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk3Nzg3YTEtYzMx\nNS00NTJmLTk0ZWMtZmY2YmE4MmI3YWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZONqmPq5O1ieU3f0JOMYxHl24ERqP1FFWXZi9ykUPPT53+FrRKwuIZeQCbBC\nCRUA/G1a2ta9JIR3IlTqlfZlVKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZMAJBgrXzDqmfudl0dW0KZzWuLcwHwYDVR0j\nBBgwFoAUskD58n9lwhwxo9UvwhMKx9GedC4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIHdexs3u2ztDgOR37sF4UEuoMNutkqcm\nxLTi1+QMxLhJAiAWzxeZIk4fvK3fKPFRKi1bNWi4mBqmTBD2XrASVYjjuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT8b62Hhw6DPR6fPZciRHf+LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjE5YjY2My1lNzhkLTQwYzQtYjYzZC1kNmE4ZDUwM2FkZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpETBBGPGaYGTGmfPQy6CdcQJn2aFoH051zF1gpaYIORZP\nQs3qpRPKJs/oIAxVj+c63S0J5Dx4KHvHtXn98nAuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUskD58n9lwhwxo9UvwhMKx9Ge\ndC4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMjDC7aXtuXStJtxtHtheGjte0wCWfrYtlJvjCxRtmYAAiEA81WMQWBF\nGHDVHK0N1hzQBSspGA3PwDOWoXHNJBv7vmA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAYVMZXNIhVEXLFZ00znmb57SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk3Nzg3YTEtYzMxNS00NTJmLTk0ZWMtZmY2YmE4MmI3YWZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlhMDg0YmEy\nLTM4M2YtNDQ0ZC1hZjY3LTY4YzcwZjJjYTFiYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAKAztQZVM/TtD+qWV4gAjYUkHLzyfS0DYfHfBgvTkiVP3+UQKaNLVzo\nxcN4QBD2Z+KxKbkGBDjxfDpx1/vye0ejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGTACQYK\n18w6pn7nZdHVtCmc1ri3MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBt2TYZ2B8dNeXWOjTUwqcLqVi71VRO5rg0fAcWAglkogIg\nP9T30pIFqtpId7Uc6GEO6L6UkvpeY7K2ILcAeN1i7BI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1293", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1293` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfC293CT8eVvK2c/bPjW1PTMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MTkxMmNhLTA2NDMtNGVmMy1iYjE5LTM5ZjdiNThlMzU1ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhiYzc2MDctZTVm\nZC00MjYzLTkwMmMtZWRiZmEwNmQ4OTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7R0J/8ceR66FgICtQrzMuwVTfGL/jsd3D/i5i8vLBLtYtdTagKfsybH+QA2i\n8uQjdGPVpKGwMzuQtX2+U7abTqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjLSfxsZAIAI6r4VC4NQ2MwhBZGkwHwYDVR0j\nBBgwFoAUYbIGkcXznIkadninpMlg73alM+owSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCgu4wtY/EnJo+uBC49mbJ6g+ZbJYWS\n9URjH91pGG0eVwIgDCQqCDOkfdkEcxlaE7IaGCrhYEIt40+NE0UW9S3hz+I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdyR0suT+fekbGzRKvItvCx/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODE5MTJjYS0wNjQzLTRlZjMtYmIxOS0zOWY3YjU4ZTM1NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDF39Q9sj2QBtHeb5fAfQbC2iaOin/ttT1ccrfEkqp/aFL\nDclRdlbINKyL9mxPatcW0EirB2O4b7cvbpa1RZ6wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYbIGkcXznIkadninpMlg73al\nM+owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMbPfqpVs9hIrHxlGQUQrsfVjn925PyxKmdJ+SWG8e1pAiEA8W4mySDx\nZdVEcM3qOr2xYY53Hxk/tI0v+yLVqlagZ3I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQRp3yEIEz4ZIPapnfFjkEKEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhiYzc2MDctZTVmZC00MjYzLTkwMmMtZWRiZmEwNmQ4OTY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI3NDAwMGU3\nLTkxYzAtNDg5MC04ZWVhLWQzNmE2NWEwYjViYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNsPe+Z/G0y2IKdmuHbFT6dqspuw5wg44HmqPTARxR+/1vY/J1BVFpEQ\nNd/vkAYHyI6h05ufKHbQJWOxnTmiTRqjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIy0n8bG\nQCACOq+FQuDUNjMIQWRpMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAt31lMwLDQrRWqvsNs7fioZJNimNZMLL5y0mbKCXMJLgC\nIGu84QQCPwiZcPqnQeF+W/yl8Ybw77OeYQeOt0LxOrD+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1294", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1294` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXIC5NSjxh8VOOad4pNweE+BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MDdkYmQxLTA1NzUtNGE1MC1iYWYzLWNhYTFkMDU4YThiZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRlMjIzYzYtOGZj\nZC00NTQ4LTlmNzctODE0ZWY4NDM2NWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDPq2+/VxGb7EweZ+yo2R9KNbTtKziqM0CevNrxWpvGEZPtMLqcG7E2AuJNaI\nfvAdiHHiXT83GnYIDzxrVMGFM6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGowPCzkwjzWxzUna1Wd0BvFX2bQwHwYDVR0j\nBBgwFoAU2/stLQbgpx5NHog/6qwApKC4Ik8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC4SXQSfd45\nn+73bYCNFEbqvvBPG3kIa40tHunXcu1hRAIgV4IPIPlgjHIJOm0/iT75XFuOnfSg\nOc/EBNM/egA1ido=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUKFiwGy1XTQFZy3cQ+XIGYuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTA3ZGJkMS0wNTc1LTRhNTAtYmFmMy1jYWExZDA1OGE4YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNL8Klio8FNFqmEMs1tteSH70kgVzOnpq6mGHtUgIwaBo/\n+YNPMrTpip0ru9ShjscUd7iC9TeQldpupeftdPfro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2/stLQbgpx5NHog/6qwApKC4\nIk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM5Y/1XaRk2Elm33qANDz4GakFD/5bL4gDFwFFSC7xEWAiAsfqEdcS+v\nEY4ANz/lc9c5+1Ek8dILMNQAHNLbzebCLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAXl/Kdq+DWpQOJHX7qDzUL4MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRlMjIzYzYtOGZjZC00NTQ4LTlmNzctODE0ZWY4NDM2NWVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg5NDcwMTgw\nLTJmYjAtNDFmNC05NDkwLTdhZjFlOTg3ZTE0ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFHZgZuTiwMU09GjPoou6bkQfK7vfN0184oLW8cw14h1ykE7R8W7Chyo\nujP7AZI9GRmf85xZstbY0Ux+nX+wQLOjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBqMDws5\nMI81sc1J2tVndAbxV9m0MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiB/XVptbgsh3ThCYyljmmATxW258mf0yNKHXUai/mAMEAIg\nRBbHUyr4Jtgwyd63uEePz4azIMCCAB7GibSpg5JbzE0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1295", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1295` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAZjzn9Cx/xQSXL07om3qSZ7PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjMjdjM2JlLTA0NDQtNDQ1MS05ZGMwLWMyYjE4N2M2MjU3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjAwZjQxYTQtZTli\nZS00MDNlLWE3ZGYtZGIzMGFmZjUzODZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf+KoWetHqN1KGaA87+1J+gpYAZkOEKXnccsHeAPNFewJjdSL7feqUVGxf/6e\n8ghDiyFrLE8hay9ho5/90upmO6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr0EbspYtxnNM8Nf+OSdiOdLPVOQwHwYDVR0j\nBBgwFoAUFt2RUIlWdaf8Bc8HBxA/+usvVyEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANAviWXgFyUYgtZuwDqzOH4IxcUwW6iaQTcicqq0AfDGAiEAoikHf33h\nOEedUPFFyLX3sx4IrCQ+RYXHhcuvO1U+jRg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXJTiZ6UalLxLYNKC8Z6OUw8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzI3YzNiZS0wNDQ0LTQ0NTEtOWRjMC1jMmIxODdjNjI1NzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqnKdDPXTIny4W1r65l+RpXO3frqqf6LRTkqTE34coiE+p\nR+jN5gKRjJ53kazKLTI3rf7+/XVc9tAONU5qr4l2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFt2RUIlWdaf8Bc8HBxA/+usv\nVyEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALUToh1xykoVt2rF2+cvaqKC1cIA5Dpna+jAW8xkgK6DAiEAwNQvwP+w\nU8lDv7+tmnSXWydD/izvsw/a3muESoShDTs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAa20+D6cRPJzIH61k85bs6XeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjAwZjQxYTQtZTliZS00MDNlLWE3ZGYtZGIzMGFmZjUzODZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA2NTA1Mzg0\nLWI4YWYtNGM2My1iYmM2LTcxZjcxZTgxOTAyYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBn8W1TCnZiXz5Kh3MPoa6cVZwNNTawbHcVeOCJt8+rw1aTXiZCkJ1aH\nv95UFBtqwK7kli8howJi3segWK7WsSCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK9BG7KW\nLcZzTPDX/jknYjnSz1TkMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBga6EvvgGJ+9TZcEvY3QQaAV4NpgEvLs0FGAS+91wYjAIh\nAJKEyDjyI2xsgeXOqMTs5SVhuGGqDqJ2/PRJwlF7IdiP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1296", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1296` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAWfwUCD1xIPOFZaNzN5Y4M/eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiMWVhODM2LTIzZTktNDgwZS05YjJmLThkNTFlYjIwN2QzYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI2MDg4ZmQtNDZi\nYS00MzMzLTkzMWQtZGVjYzkyZmY5YzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmwJi2qC7fzlX6RoDijGwCk37CUVvz4jDJrHwi1PnWnQZff9ELXPKjhe2Fk//\nFMRVbnkgOva8hp7EgazBOK+zSqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdqlTwXeJTNAhkAoQjPm0Vw0XU+QwHwYDVR0j\nBBgwFoAUHXsjpzCMjUEo2F/0Y+7bVQQN/30wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMTBMgvZMTOi7oNBSKr+e4G0uPA8bIlt/nheHCV6khiLAiAMUR1y7cb7\n/z/5gkEaA+rWFt7V4RiunWzR7feAwwBUhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb706Szu7+ID9PqHfsTy8WShMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjFlYTgzNi0yM2U5LTQ4MGUtOWIyZi04ZDUxZWIyMDdkM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLXddcFfMLhucoRZzLM+d6ZYcndd3LTlCcVO7tf04cRRN4\nZOxvv78RG2BRi3GtBEbI9bbwX4hSnF9EKLagi2Jno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHXsjpzCMjUEo2F/0Y+7bVQQN\n/30wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMWRo3rcpVdfYFsSYW5WSgmAWYqUgALDUjX8LIlUQozJAiEA1r6B7E4h\nBCGYqH+bqID/ymfNq5qtVVflEMjXcGPacAo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXHBeTPHsV+fLg13dXxjSvZkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI2MDg4ZmQtNDZiYS00MzMzLTkzMWQtZGVjYzkyZmY5YzlmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE4NzkyNzY5\nLTNiNGMtNDM4NS05OWVlLTZlN2JjZjVjMDVmYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAdNJHuQXzfFT+Zw0ODia1Gz0QuQA/kGmfuJXUHtTlSw1n8puvUOPXO0\n7UqUyyHV752mx6VjGIYCYmM5zWZN0lOjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHapU8F3\niUzQIZAKEIz5tFcNF1PkMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAPAPAOsO8OX9NUPp/Smwo2dfM3Nfm5orKo9h6HA9qdHgIh\nAOC4LllqLlVil7imO4gHmmeuh8W32RRXYqpXeeA6UX6z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1297", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1297` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAd8Bc2U/ZqOnmkQarRcL0OgQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2ZTM2MzkwLTVlNWEtNGZmZC1iNjY0LWIxMWM0NmVjY2Q0NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTUzZDE3NzMtODFm\nZS00MWRlLWFkNjYtZDk0YmJiOWVkMjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESO8HGWT8HgZ6gVuXbpSgOXWe/LbL2Mtw2skXImgZt0U22u7ZcO3kTuCKS3tk\n/t530RJVd8FXR0j5sSrVEcNg2qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIcJJbnfO8aQQC0C32Jalz/WSchcwHwYDVR0j\nBBgwFoAUZ0S4IBPGMvU1d23Rl5zU6OnFAU0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCID4hWbKhpiPIxhFsHUk5MX0ei5YPVqs+ZM4fImyaNuQ9AiAQwymjr99p\nxJWM62i6Av2VTITThps10mqpU0nHx5DjAA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfwEW0qraBH3/AQg5BixaUqsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmUzNjM5MC01ZTVhLTRmZmQtYjY2NC1iMTFjNDZlY2NkNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiVkY5xRT65FR+0c9S99Ml3lFmiQXVowDkTt9eMSE5fzwb\nE6CwSOk5ccWM1E29cCes4fmi9fIuhi8K1nACNCdKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ0S4IBPGMvU1d23Rl5zU6OnF\nAU0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO4apBHpeuNmpvCYek4SHK95MDra0S/hyi5ZnJWXHnZ9AiBP59/fJZF7\n6EdNaN583tIOpYXQx74uIVSWoSVJYZRHLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAVaVd6bV+HRP0hjn6HRFnjpQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTUzZDE3NzMtODFmZS00MWRlLWFkNjYtZDk0YmJiOWVkMjA4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkMWQ3N2Uy\nLTI5NTItNGZlZC1hNjE0LTg5MTg0YjZjZDk1NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGgJ2ePBKq3ns8FjqwCormWeGa+wr/bY+VX+oHkXTcL+vwGSc+tbd0G6\nfdv0BnZB0DgBnKfyhR1wuCZvWUzuERWjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCHCSW53\nzvGkEAtAt9iWpc/1knIXMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBBtNrod7jQN9n9yi1Mre80OuE470DW6xd9aohdZqTkuAIg\nNdhUEefL/yEhfQ99eWXRubFo4WXnJJCrVLiT1ZcqieA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1298", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1298` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAanwKFr8ipz0yaLdTOS2SGElMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMmY1MzQxLTYzOWQtNGU4Zi05NzE5LTI5YzZhMTYxY2Q5NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVkNzhkZjUtNjFl\nMi00ZGRlLWE1YmUtMTU2NjEzMjZkNTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmGO2zQKPNGyy2Y95xl4zKsqBaV+PI29bZaRJFVqIsXngmxXlIq8gUxl2GT6m\npbe3eXcgNWP3ReZiagDGmJvZXaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxKfwrzYZEC3/DqU4vLXRBDgMn3UwHwYDVR0j\nBBgwFoAUbLbSzEiRtS5kKD+RQNpNET+5R3UwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC2MOxCKPn/VYR82tsxs+HIq5W2+cGY8T2BDHnL\nUCP1dwIgI25oEaCUjrPSp6L4y/4IitY6FaWkk7pkmjyQtBmyTHo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZE2hu3crE46Y4VG9B3d89bRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTJmNTM0MS02MzlkLTRlOGYtOTcxOS0yOWM2YTE2MWNkOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFbiH0obg+w7ZwouMdkbzxjRm93aY5j3cmL0mu6ecPce0R\nnUm/nBy1nWhe0g3sy+hl89/GO6BzN+PEruZ8J2k4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbLbSzEiRtS5kKD+RQNpNET+5\nR3UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALxt0WUt1acC+4SPsiIbCkJ6PoU0kiudYjFzuiArliueAiEA+/1z7a21\nsQR3NPDWItcztXsvKJ7cMhcggYf8GRKJ9nI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAX8k0ySHrNRlXW3P/mXBgS9dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVkNzhkZjUtNjFlMi00ZGRlLWE1YmUtMTU2NjEzMjZkNTE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM1OTUzMjc4\nLTQ1YTgtNDBkOC1hMDNiLTcxYWYwYmFlZGMxMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF/h4ind4boJLdOnm65sQc3E7zWNGdvqRafZWWbyClFsmj3oB4QFMuZK\nSv0hW+lJzXs13cy0X58pqEHrFFAUuYmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMSn8K82\nGRAt/w6lOLy10QQ4DJ91MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiA03lUoPVrNUyQMRmFDtregiECtgAD+9t+ZF6R5+jp5/wIh\nAM0KnYRN7/4G31FXPLIdUEVez64MIIR0Q5GKPE1MeAjr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1299", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1299` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAb3efecy+liqoTmg/50/vM76MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzMWFlODE4LWNmMzMtNDI3YS05YjJlLWQ0ZDIxMzc5Zjk1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhlY2MyY2MtYjBk\nOS00OWI4LWI5NGMtOGNhYzc3ZjE1OGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELwREkufWfJ+m4hQpsXw9ocAxGXTLEgckDV1lx/K/xD9wOIFZhsF8OsfeImMV\n/KXnJA+wMAk4fSOdSUBpucOW06OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwzz2HKy8bxH6iInWuwsPMDZkAUwwHwYDVR0j\nBBgwFoAUpmX4SuI41V4pf0oEwzhRsGHBCSYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCZy3sGAJcc0YA/XoL/YcfjzfPWOzt25Uba6gre\ni4r2AwIgR6nxkVB/xAwJmSPxUfo92Pl1/mkTm7y0en8+jx+uuh4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARyZ7WiRGMT+e0h5+GpqXZHlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzFhZTgxOC1jZjMzLTQyN2EtOWIyZS1kNGQyMTM3OWY5NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT++IuHaeya9g9t4lSdGG9dIZxGj6tR39l3YwgwVhaKGXos\ntu3vK5zon4L4HKT5gjVgFZIwm9CWTCDeuBq6oTnho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpmX4SuI41V4pf0oEwzhRsGHB\nCSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaI3LdGiV0mIyn3TiEKaNbHbNs91yez3/IyWam1hWSFUCIQCzsXZZuajz\nZLw5NpWrScWujeAKXJVu2rKqz3PWsLWE8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAaeCAyFCwbyTLhcmpxaZnHB/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhlY2MyY2MtYjBkOS00OWI4LWI5NGMtOGNhYzc3ZjE1OGYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRmYTczNmU5\nLTAxMGMtNDVmYi04Yzc4LWM1YzkyYTc4MzRhYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCoRJmQnlDAFuxPjhh0OBtUnEtWKiLJ9YjzkEl797RzbQ66zgdcdcy25\n/xxZ04+1YO0cxvbC+u5iKD0DsUZSHFajcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMM89hys\nvG8R+oiJ1rsLDzA2ZAFMMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiB4MjAp2hHGcXHsuuUdCRnr7ulwqa63kVkzfEdusUuHsAIh\nAIPAU61YU8r5fDMOWhH+uxwvPxTAPghVTJZE/MS/xnAW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1300", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1300` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISARNNq5anB/nc72RGhbH4VsgrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjZjJmMWFiLWE4YTAtNDk1Yi05ZDc0LTVhYWE0MjYxMzZkNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZkZDU0MzMtNTk2\nYy00Mzk3LWE1ZGMtYjdkMGYwY2ZkMTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgOD/OWJrThfW1oZw+GEjlGgdU2395mpQRsRYU/AAc1a/TDHG3ZKcnMJfLAb7\n2rYTtUAAzImowBE0j1AMzPLcoqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtQy1C9EgUyyvlZgsjN+MPaASzsgwHwYDVR0j\nBBgwFoAUSqPy1zkEZAATZWPajgXw7Yz9/S8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCeHWwerGaKrFIuv1mHd8p06YHRi1Xk0/DskNGnEnBOYwIh\nANlZsy3J+XDtzb6gW5cupbkFcxYl59FRiGADsK/qkPyh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWwCDZUcXEQTzZgXurNgxpzRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2YyZjFhYi1hOGEwLTQ5NWItOWQ3NC01YWFhNDI2MTM2ZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKjOnPwcRHXls/AKsXxJSyXjBrwvs3hVWhRB/WcKaunbDt\nDcJFh3CdLHy2YcdUYEAC0s9H3XK+f8IvECk+KHTxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSqPy1zkEZAATZWPajgXw7Yz9\n/S8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRKR+SR6Is9hFnSa9LkAA0PsFxU2HhwHFbwhiahA4wYYCIQC9xIgN1NWg\nU54G3xDWlPwSrPmDNZaG2AZ06KsuOwJO8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWwDdbXxbm6meKOrxQUWANj6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZkZDU0MzMtNTk2Yy00Mzk3LWE1ZGMtYjdkMGYwY2ZkMTBhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEyOTg3ZmNm\nLTFkOTUtNGEzNC05ZGFiLTljMmJjNTUwNzA0NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEePWYXMRH3MmbioDWBcEtuIk+JwOV9Y25g42rOyLYWmSJ3eXs2L0Q7P\nMAixCLvtXAkKwK9IEFXbSPLnZM025a+jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLUMtQvR\nIFMsr5WYLIzfjD2gEs7IMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBEJFNPibkLyfC642TCOmi6QUNwG+JyZ3RGnaPbhMUToQIh\nALPgJC8DORJC9aqmX9Hxee3hcsZatnKHtLwMZKmCA6LV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1301", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1301` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAc0e94jomxKgF3o7sjjwa4D5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkYjdkNmIyLTkxYzAtNGNmMi1iYmI4LTg1ZDVjY2JjYWRkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM3ZjBiMDUtOWM0\nMS00YmI1LWE2YzItODc4MTY2NTdiZTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENtMNcs9vhtw+y1fB6uU4xGjE+6ZqiKQ9RGI62jRRdM7kQNMOh8dLk0jLLmPI\njY8BCYVwqZ69rhk7Jda/EUmjaqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFh1ek/M0wXShNUNjOT9hSTcai8QwHwYDVR0j\nBBgwFoAUsSDfugtioeg2T7kK5YT1i8/ZQfowSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCbzBsRF64KWQeF9BnMB3M1O/7a6bPB\nEWqazBNJpZPFXwIhAI2FcUtavKl6xkQQNhhxVxfsMIwJ82MOEcQ5fI0KI+cw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY5TvFO8zKPQHoPLhP6CYB0FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGI3ZDZiMi05MWMwLTRjZjItYmJiOC04NWQ1Y2NiY2FkZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASY8UhUpTtvWmj279XQCEjHlhsRyxil0mXA/5OwlgHTS1tt\njZoNMHX8rPpYy/MGGW10siL6O8Me9YRZ0fFcDjo4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsSDfugtioeg2T7kK5YT1i8/Z\nQfowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM01v3Yw8sVAFQ/UWozBtLpfHb7GZ+Fc047rNZ1cOqrCAiEA4RvfXfOB\nCj++CJ7OwX5A3FmYjOAkyckZdxdcw5v/dOc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAaAQAPK+w45YOnW2H092XzNvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM3ZjBiMDUtOWM0MS00YmI1LWE2YzItODc4MTY2NTdiZTI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5Y2M5MzI4\nLTg0MTMtNGQzZi05YmRjLTRjNWQxZDdiODMwZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMXg2gDrhSo/nx3j+C9InIJavrXHNga8xwGE6/Mk+xfRpRSgRMDnFqKs\nkS8sooJw42rKKlr6dBNVuFObbfjSW2OjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBYdXpPz\nNMF0oTVDYzk/YUk3GovEMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAoosX6Bj+Q/LYmC+pHJt4caLv9dp1t00iv2URDRzLUKMC\nIDSdYPj5jQwCcX93TQ2o9ssOFXfWJfIN6+jKjvYbxXR7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1302", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1302` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAYwNAvewv6w14gShulnjV1i8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3MmI3NTg4LTVmN2ItNGNiNS05OTg3LTNkYWY3NzRiZjcyODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzdlYzE0ZjQtZTFm\nOC00MGE3LThiYjYtZjBiZDZlYmNmZTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs9Y3MDUPqNyCDkOEJezScD+ZHe94+uHMPLvWe1D/qVmXtXemRa3YtzjsIQIT\nVVmgLBpKSZOFHn7jPldFfBpYeqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy07wdU6pGWd/mn/5YcSyQF9t57kwHwYDVR0j\nBBgwFoAUxTY08rueWO2cCjcCSME+FniHqkMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC0TkA9Pi7g+QXkdaUgYMKgZhyruBIF\nXIxCXv6BUQJN8AIgTijoaKLVnIH4WU/Lu4tDuJ4xkpP+WddYwybTNNsh2ek=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS0HRIzPuPMIr5nKYuUSIUoJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzJiNzU4OC01ZjdiLTRjYjUtOTk4Ny0zZGFmNzc0YmY3MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFoTIADZkY67+A2T3IULZBpACoVRkzdomS3fj2XbDolNp/\nT1v3xg3qLvtHvmJb5rNk6G7it2mkVKH/u+rLRv59o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxTY08rueWO2cCjcCSME+FniH\nqkMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJJhoYvw4lTIWTrhfx/+7Cj3bj1GWOBD7Z1aECmGPlbTAiBPO+mZGOkh\nHAAAwmad3M/56kgaRFqiEoYTQCkl35uCeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARmRZumO5usRuRSgRs64SWJCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzdlYzE0ZjQtZTFmOC00MGE3LThiYjYtZjBiZDZlYmNmZTM1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhmYzVkYTVk\nLTA2MWQtNGRkNy05YjQxLWE0NjRkMGQ0ODQ4ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPPmf6w210p521v5G1XskvPKYu8EwurHoMbkhrM6/ta4/mLqXi9vOIyq\nO61sO7SilIexYoMsfFCgKPeA++ighg2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMtO8HVO\nqRlnf5p/+WHEskBfbee5MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBYZ6u9WgCUssuQFWRLoaenfog7WOXlzr1fg0cxuTvXAgIh\nAM1qBvWP+GeTbeCrJrPIulpsKl1RpulhHchucwdhM8rr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1303", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1303` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAR0tj6v89IUn2V6sDkmU4ASQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5MDEwYjBjLTgxYjQtNDA4Ni1iMWNkLTc4YmI3ZTBiNTM3NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJhM2M2MGItOGI2\nMy00YTRlLWJiMzgtNGEzODcwNGVjOTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+jvvEY53sf6BkTeI7k5BwRWpcpWyM5LfH9aIq6Z0OnhBZd0xgjccH78Z0sRZ\nO2lR+7N/9oKB8giijNt9yO5yXqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEx9xkYIImLnkg+Dx8HE6C6xZyfxMB8GA1UdIwQY\nMBaAFByUk91wD/ZWGk1NhjIm+8YZg8nzMAoGCCqGSM49BAMCA0gAMEUCIQDWnYTR\nD4Pz1U5OY1CVSr9PuaqMOzN6kBlbk7J3ikipMAIgSb1Ql2v4aT+dtoL+Td+IRluq\n7MrYo0sz2TrJgePQDhY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV22PmV+Hfydv3moNwJwBpBiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTAxMGIwYy04MWI0LTQwODYtYjFjZC03OGJiN2UwYjUzNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRg5hYqUPmzfKtkUCxpdtLGj8mMLO2POEF0MGYW5UjjQ74\nOhA6Hm5IHjmW5oWM4fNaNIufqmo0L3cYBlSPS2DLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHJST3XAP9lYaTU2GMib7xhmD\nyfMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALBThtedDNfncaqmyCb8ZnUKqCM0h1bHUfxl6vjsJo+2AiAa3CfSTEa0\nrsmAbtd+7wNqjnIGN4zi6Y0GmixM1/OBlQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAS744R74+Cc6sRsn5Fqg9L8EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJhM2M2MGItOGI2My00YTRlLWJiMzgtNGEzODcwNGVjOTc2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY3YTlhYTlk\nLWU3NTItNDkxZC1hOTAzLTM4YzM2NzFjNDZiODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOOL9jez5Z+lpIFsiGXmF6yTL0Vxo3FdnZEh/ejfk/SNyXUx/iPIzg5i\n44ChNEEIckPVa6JvJW2gvnSAmP28oWejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEx9xkYI\nImLnkg+Dx8HE6C6xZyfxMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEArj4hHPVQBnCvFl1YL/yG8U/8P7zK5NK49s2y\nKLabvwgCIQDKfvgjwpu2masqXwi24tJx39mNtOlERwTqaP56uyJSkw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1304", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1304` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQ1wJPjZZ8vywqeiop7wR3EvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZDAxMjNhLTBhY2QtNGE3NS1iMjJhLTdjNzc4YzFjNjI5NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNiNjUwMGItZGNi\nOS00ZDBiLTlhOGQtMDNiZTU3NmIzYjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0JE0jkuiLTyrY71Kluu7bOs7hYi0HiAmbLij/SmxtzSv85VN8imIlB5tf37j\nXw8RV5EYMalwhDWkeq2d5OKGt6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOsRrAqp5BO7cxIm6oKGxg8DT6WEMB8GA1UdIwQY\nMBaAFN7FTD8M8JPsaOAdJpieaPmz+3a9MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiA5X0PL4eziWz21+FBml6P3psKaWNfb1oRv\n0R3P40g6DQIhALN/oba3VFAjWQexgPRtsU2KyynvHMzmIsAl2ksf5Yjw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU0JNurQX2I3lHZJVT0EfoxVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWQwMTIzYS0wYWNkLTRhNzUtYjIyYS03Yzc3OGMxYzYyOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQr1yADClrRuDaex6VSDZAKApniheA/WeuRsSNfxX7/yChj\ns5UzAsG6zcBql3Qz1jyd2Vljmk5FzK6IrMiYyjXHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3sVMPwzwk+xo4B0mmJ5o+bP7\ndr0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIhFQW0Umf+CHsV2HTWsR2ikALYWYF1aHjILP8WazO7kCIEzhRgqbkkMM\n6KFOaUpWen5RzX8a2VSjq8H5L/Rt7+fM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAYnVMq7uB1gGpl55S4g8D5BzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNiNjUwMGItZGNiOS00ZDBiLTlhOGQtMDNiZTU3NmIzYjA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc1NjA4ZjJk\nLTFlM2QtNGExOC1hODkxLWUwYjAwZDcxNTBlMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKnkUiAI+wsNA2Ndt1nlJEhq8brjdOGEf5rwU0KcUVdCA3aeCeivKKhE\nIpWSOqjUAbS2V/nRFH+6xx0qbgPTSJajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOsRrAqp\n5BO7cxIm6oKGxg8DT6WEMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA4nPhGK6Uek3F+w0XxxdLDp7SDmpeOAI+STym\nm7R/OXwCIQCV1/jKFKBsUrIPd+GGIw4nPvBitwsgpFOjlzD2vprQ/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1305", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1305` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAQdUcbXttWHR4nxhxwG3Uex0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwODhmMzEzLTEwZGUtNGU3YS1hZWFjLTRmNzdlODhhM2ZlZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA0NTU0MTUtNWFl\nNy00ODlmLWI3ZDYtMjdjNGUzMmQ1NWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj5rpgS3KCMMXQUi83ej4ZrCcVt1bv1VtAQz4GU3MQOgzovSIwJmpSlPw5VJd\nqKOvRdRBUIm9t1L2Xnv0nBZZvaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJovN4DFIdQMYbVJuizb32ShkUccMB8GA1UdIwQY\nMBaAFKzY3B+vaRPDodiF454t+5lHss/pMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB/KUoM8yyCRweGioP/gWbDvijVrazZi3IL\nlaZdIhXIzQIgBJWo+GuETYq2T+PzeXm3KvvhUiHAT2soiCYfatR7COI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXLHc54hmkEnpSP8bL9b8MkuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDg4ZjMxMy0xMGRlLTRlN2EtYWVhYy00Zjc3ZTg4YTNmZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiqgTEl5IML+yqqK2xZWHWAVel/834kekXEkXEFLS145FH\n/+YPyYZm4d6aq+JcVC8LL864rf6YID4SUospTE5jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrNjcH69pE8Oh2IXjni37mUey\nz+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaAPOH23jqHVvn9UnetaqhGXzhdma2gUNwNDfvYcUhkcCIBzC1q1gh0O8\nV64inamLV4q/pK9TbTiUe+Y8IVwYmLsa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAVD2MGHvNZl18wyVUvvN0QmVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA0NTU0MTUtNWFlNy00ODlmLWI3ZDYtMjdjNGUzMmQ1NWM1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYxNWMzY2Fj\nLTU1Y2UtNDE4NC04YzI2LTAwOWQ4MTIxNjE4NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAIgXggmITzlvObJl3qU4hfd/v+CWQTbwFA9/BAxR5rEbYyyBQGWUll2\nY7OaPifp2bPdgnoC2HvwPamf7kXPoJWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJovN4DF\nIdQMYbVJuizb32ShkUccMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiARdGZXh3kkU56gDSfjmP+ncudGoiOlxecEGv7j\nXcSFOwIgFdVa7JZsEj6u7TA5GACYxYmmN/E/LGBOTW+UWB/P47s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1306", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1306` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISARG93Z8yKFvDPDp8E2rXCJZxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNjA2YjU0LTZiZjMtNDA1Yi1iNzRhLTk0MzJmYzQwMDRmMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEwYjdlMDQtY2Iw\nNS00MjY1LTg1N2MtZjYzODRkNTcyM2M3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjTmjQ+SBmxDUcCYvjr4/PQ2cMYZkPE6ckuOu7EaohhiRUw3roVM9yWlkhmYH\ngSIgfHUOlfxdBuXzEVv53xDM6aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS1C6uLW2r4DNBjg1M5Ixsz0yzpYzAfBgNVHSME\nGDAWgBTGPXf6ZzVAjMI1CpFZ0MhF7Re/EjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDFsZAqOVGALIcAObTKMUZR9NDcLA9V\nf9CrusipOyW8kAIgZNHMv2m8WecEp6o9alyQBfNhNRLQpDztulJxIP05vuM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaWFpplgnUmCy2U6Vh311+XqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTYwNmI1NC02YmYzLTQwNWItYjc0YS05NDMyZmM0MDA0ZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyVjh3XtqDBHgNTzKKR33hpEoIDYam5dldPFYYw6RRAaQK\nc/oxW53t7zlC+SgevhCU7a7jLieNt2Ln60pYs6Z5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxj13+mc1QIzCNQqRWdDIRe0X\nvxIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPOuUV6jkhWGVN6vwF3JKbfUodnnb6ZjPYN1cx2blb+HAiEAmOlwlnjh\nSeKEKPHEllLikyHKXEP7pmniIJVY9UnkYBc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVb0RED0uHy77+ojAn4va4jAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEwYjdlMDQtY2IwNS00MjY1LTg1N2MtZjYzODRkNTcyM2M3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFhOTM3MjI4\nLTc4NTEtNDZmOC1hZTE3LWRhZGI0OTJjY2UxNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOMe6mxyQ4VGO3gIk0pt2fRpOKQbU0KVRa3KqkpiezoUGAUOkOXINyQ6\nb3jhqnki6PJPhzOMpf+iuR0O9P+SX2SjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLULq4tb\navgM0GODUzkjGzPTLOljMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAzLQ1awJTnX+UYHrGY3crAdk4YcHkOPr2uYn9\nyo5tVS4CIFB5FX7EvV/aUK6VqzCSHT3+CPZs2DSkb14lXDv13OuW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1307", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1307` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAVPQ/bXWkTFQ0p6XVnigh3HKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNDViNDc1LTRkMTMtNGQ1My05NmJlLWY5MTE1OGMwZmIxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMThkODJlNmMtZTMy\nMy00YWFkLTg4ZWMtNjk4ZjFiNGMzMGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbcgPNuzTPLkwC91zTPeDqQES0pJLqs99xXhOumgVOa1JZugojAPHEOBQJFHb\nI+jhk6hYBdT0IThOXqy3t6NC4qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8mNGOptxT1h2TNhK4o/hP8rN7r0wHwYDVR0j\nBBgwFoAUQmiXW/oPntZg38OXP2mnMzTsJ8MwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBjSOGqV58yF1+Y\nlVIM6HPN9cJarMD3XubUd21c+lpQyQIhAKw5+9uSeEsAEGzXKl95wZUpG31RNy8Z\n58P3jRMGiW8c\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc8TdBdKb8z5KbKPtkVFeOBCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTQ1YjQ3NS00ZDEzLTRkNTMtOTZiZS1mOTExNThjMGZiMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATN8Jwv/tVtYcMcAzGYJkb0yGEVBo+0/ymSGos6ZjOHESdn\noYdbi8B/wu54Xj3YUksXd9d2ZYB1F8IwqgSHy1UNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQmiXW/oPntZg38OXP2mnMzTs\nJ8MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANyFJTeKdSRQ66PRjdd9AyBHCs3Qsh6y9jql/mdflx63AiASDvO25VLv\nX4jQpJj7wA7vIQcnFcxYhl7+SxqrojYzuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdRBSBfXF94OwF0kF0lNLMM4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMThkODJlNmMtZTMyMy00YWFkLTg4ZWMtNjk4ZjFiNGMzMGI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVjNDE2ZWM5\nLWFkZjMtNDJkZS05MDQ4LThhZmFmMzYyZWYzOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPCAHnJOY+aLNqltIUtj/DH+R1H7plYlEC2jgVF5N8OZ9IiergsqJzEa\nV2hXEWK4/KOoqK4MRLybhPbE/5T3YM2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPJjRjqb\ncU9YdkzYSuKP4T/Kze69MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBD1YyD7wa9p0X8NqOzSHBZ5UBnaaP3x9SXOMWl\nyJSV4QIgbjbVn/UPMoyc8Vb+p4DhS7+XjYUJMQaiZXFPnRGWYSU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1308", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1308` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAW6cLpQtH2gICSjl92Gb/5dXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViNjczOWU0LTlmYjgtNDU1NS04NzZhLTE3ZjNlYmMxMjY1MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgxN2NkN2ItMWZh\nYS00NWYxLTg3YjEtOTYyOGUzZGY3NGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkG3DO47JOg8CR+6pISD+zWM4o2ldLEcEti0KATlKi8JdlwCNCa4FvqKNidJD\npSL6wnf0ci+2AEciajsuFN1PBKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEfAf/pdr6UGFcB1OTgFrjenSC60wHwYDVR0j\nBBgwFoAUXhb9+Sbihsx9Qb2Iz3BcNBJvZ0kwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBKsTFg3TEsodWf\nnTEc0knU6E1gM9U7uA4Ai/9OWxhf3AIgTXWL1FEkNEr0+s3F11QDUHychL89pArP\niyYEcUrinMs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbewEof5Umkdnf2jeeyY+jF+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjY3MzllNC05ZmI4LTQ1NTUtODc2YS0xN2YzZWJjMTI2NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIk9lZ/5gJv856OlhX9uRP//3F/UGJ9e1KpFQ79PB8IbnV\nMDHKUbb74Dc8VdJC78SCEA/4pOCDcfdrRtW5/16io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXhb9+Sbihsx9Qb2Iz3BcNBJv\nZ0kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIrjrS0GkT7I+A3YLGax7sIKjE9Mo2JaxJkuVspIm8KsCIQCU8p1YAqIF\n1e1F4Hr3bbcTiPoG/qdcKamLSxnwoycyDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAafAstSaTvFPW0Fve8x2gFVFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgxN2NkN2ItMWZhYS00NWYxLTg3YjEtOTYyOGUzZGY3NGU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRjYTdiYWQ1\nLTU5MzktNDc3MC1hMmIyLTkzYzcwMzRhMTdlZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPCx+iP/cWe5v/Z6Si1i9wozzbU0vaRBlGWRRanxiozw8OoyvIHZKb/M\n84SxvXQyv4/psBwIelKmEjdJIq+5jhCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBHwH/6X\na+lBhXAdTk4Ba43p0gutMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBsmPFs1wDuFX4ndWRF1fOXJRoM5CZj3bGRbF89\nwLRWfQIgGNZe3EdMoezA4jc7JHmAqp9o3ueidwUsWQhkQ8BSorc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1309", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1309` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAci7XTB+OGsQ3piOHkrvf+wYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0ZGFmMmQ1LTllNjgtNGVkZS1iMjg0LWE0YWI4YjJlN2I4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk3YmIxZjktYTEx\nZi00NjBmLTg4MTUtYWY4NmQxMWM0MjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETftSBmpUchIvqPLMPY2LTDKCWt+ircND4QPgNJZ7X1KOLqy/76utjW7g6mNX\niyR2WVatRI0g0wDpB08FXpfosqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ldLX4fRnXMYD0M4Ak25fm5TJqowHwYDVR0j\nBBgwFoAUHsCUoz+Mz77imxpjFSe6mA4nupMwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiB9EMo9SMBH8agbpsPoBlby\n3C5UnwHZewJI58MfHwZQ7AIhAP5+PYNNhHeyek3JdbUeh51VS8PprmIHrWJIbd0n\n3+G3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcc/8okpa3FdbIsFoe6GYqJzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGRhZjJkNS05ZTY4LTRlZGUtYjI4NC1hNGFiOGIyZTdiOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqjeIKRfsyf2qv+Tbk6UBbvGn3lk7uWoHSEsKUjLEks7UC\nWzbhpeSTCgLOV08ID5gRcJIiyjbL6wLwFTVDNpHoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHsCUoz+Mz77imxpjFSe6mA4n\nupMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP90GWtLHCqPmU8ObyLUyhJ5w2R4ik2gT1kLlCXOZRoOAiBkjkpfo3SU\n/bNKws+fiQrnGaZLeR6t4b1neEc8HUXZCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAX8Iu9Hlnwhzr5IOVt1PhwpEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk3YmIxZjktYTExZi00NjBmLTg4MTUtYWY4NmQxMWM0MjJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNjZjUzODVj\nLTliNDYtNGMzMS1iOGU2LWM3YmY0NjAyZmI1MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOX8rHY7mc3UNxKo33Owicvz2ubd8s7uZj5CrFiwIEOd7DKWQP9USs+w\nHm1CHvywKUr7KHR9mS/fpNycbmEb/9KjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOpXS1+H\n0Z1zGA9DOAJNuX5uUyaqMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAfLWJclT0jwo3TcEAQ9RiNGavg8DMV6thfjhOz\nmzgysgIhAMYooRB6TicuKfMVyYF4f4Qlqq1ihdgk4GNPWszSu47z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1310", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1310` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAVs/HO6SK/lAZX54I/N95eY0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3ZmE1ZjIzLTlmZjEtNGY5Mi04YWNjLWMwNGM1MzM5ZjhkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVmYmY3M2YtNmEy\nNS00MDQyLWE1YWMtMjQ3YTUwZWEwZTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbNj/GLXaZpu7gPZlnMhvLRcwpmGxHGcIoRwDM+UwRuys60E2Ywn6tF15GXuf\nYfF4jp/rvLObblhD2Ex4ZsKb4KOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAqxVMPAXvGMIdkOqh/eAvwXebK4wHwYDVR0j\nBBgwFoAUqX/e5FkO+wpS5zgSkcHn7PBRBI0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBJ5J+a\nVfkOXXFWMjTBLGA5Xgyp4f6lpwwmWw+ffdsPUwIhAN8TWvAtubqY26SPsqZsYTns\nLUb8jyw13vkJTsSaXIWr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYwU3HIxcgYzov6ci7Gz4bg6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nN2ZhNWYyMy05ZmYxLTRmOTItOGFjYy1jMDRjNTMzOWY4ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATS4pngZvVrdvBlO2GOTPrbhNrojnIyRm9GIZWp+HBskbDT\n8aE0MH/3wsiGhFFMArqAXPGvYYhMyxM/QgX4Y/C3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqX/e5FkO+wpS5zgSkcHn7PBR\nBI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXgba7vSASHcjj6TprdKNtmAKC3PfGdELX6VQZqjUc3MCIQCJ2n0N6u/w\nZM7BcM1FohFYCNAhhlcuKXvxUDSP7TVY8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAc6vhn+USNSI5lO30AXZi8ZRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVmYmY3M2YtNmEyNS00MDQyLWE1YWMtMjQ3YTUwZWEwZTAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU2YjA1YTc1\nLWI4ZmItNGMyNy1hMWVmLTQ4YWQ2YjFmN2RhZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBUJrIIu+F5czzJEaxF4jrNkRv6LCOfKaihCwc8+Cjb4Bcn6heJIwK1k\nuqP5SkFzvr4hjeNVP+sm+h7B2QXcjfOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAKsVTDw\nF7xjCHZDqof3gL8F3myuMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBzEMpOl5JvAY++o6+Rn6oKCib2UuXKXcKCVvZ0\npneRYAIhAIqVrRcwwo77WAUxt6at07J26gKxcvNDp7DNTtdmwryY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1311", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1311` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAfCcpRLCY1bDXF9nq1aIsqfgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmNzVlYmE5LWUxMzItNDc3Yy1hYzI5LWI4OTI3NWJiMzY4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZkNjhiYzUtMWU3\nNS00ZjQ4LThjMDEtYzM1MGFlY2FmYTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4rIIAQhJhS3W7f3daI+cMJtYQSAbO0LqiOHQkfGSN5hIyZ1BEzKr380Uyvhs\nZgjTxmz3P0GYUOCFlRLB7N9j+qOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7qz/gMJ4qJuEeUWDNAgiFHcjupswHwYDVR0j\nBBgwFoAUZRUGM8RsKPvr3IePuQ7BhVJa8JYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAtoEn\n7Lp/t17RDA4GUIil5b5T3oJbd4Hm9PdG4EJLAF0CIGcBQch/F7zCqO5HtjWe4QsF\nCFgkuBGMG7P5EayWP5ui\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaiOMZWIBwq3l5wzZm1kkcmRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjc1ZWJhOS1lMTMyLTQ3N2MtYWMyOS1iODkyNzViYjM2OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBSZQJMaIPCFpD8FFtrq2ZQRX1hjqKgSRUHgTtoK/cDHcx\njeJjCYzJmgXVEyrm8uluIKYi/xJo1T+lW+14Mtgvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZRUGM8RsKPvr3IePuQ7BhVJa\n8JYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTTF/F4iarw2jUjW/EfYk0YsR782t7OFQNsu/Bx+bBsECIQCIXVv9U4/u\nOW47DCEJl4hkSCtYDMjoLZhKvBZGlXHcbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYSEwNu1+o3d/y9gCyCs/9xaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZkNjhiYzUtMWU3NS00ZjQ4LThjMDEtYzM1MGFlY2FmYTdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhmYmI0OGMx\nLTM1ZjEtNGUwNi05NDRkLTNjOTQ4ZDZkOTg3ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOBlHrMCodaqTC3KoGF5nPoN82t4adSnrnbZlhezhyJQQvql6Bphr1x0\nkXYdcReNSIqnXsJ6mSx4PvVWo6SQcoajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO6s/4DC\neKibhHlFgzQIIhR3I7qbMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiABK0hcKEoSlPt1VjtPsqX2U6q3VBJbgBYlrDsk\nI3hr6AIhAMmPx5ibSuoKIaPeQIpy0AW5BFLh5WvyI60Nc38/oX3r\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1312", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1312` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAXmC4S+sCuMMZnnsKSq6GJ9NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjY2U0YjBkLTk3OTctNDUwYy05OWMxLWRmOGNjMjMwZDRlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVhODRjMWQtMDUx\nMS00NGQ2LWFlYmMtMTBiZDNhOTMzNjQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExWj8IuBye7L4MTGywExuRiEzqWlMLpcptxknCYcnTnjjxoU9pqkoQxa/slnl\neZRb8f2XRyOAz/tdyJ4a5Aa5/6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC3j3xAtzjNbTirNCA28Voko9ppuMB8GA1UdIwQY\nMBaAFPd0/NwV8PaYKH+TWgZxnCp5zYIOMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB7WYpQco53uD2FqxDLr9+aS0BILamLE+FG\n+zqHgLcLIAIgEmvMB5UYyxaDuIW5r9JlTdpUv7Y8K96ww3tbTa/Gl0o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa6djVWd/76G7tGXX48+uISDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2NlNGIwZC05Nzk3LTQ1MGMtOTljMS1kZjhjYzIzMGQ0ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASza6v/1X4MeJ6UejPDLd3irsIUUbMxEQN538plFOS0kNbx\nZ1LmNhdtVShIPEZtyx0m/Xp1USPY06K2tY/TQE7ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU93T83BXw9pgof5NaBnGcKnnN\ngg4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTSMj4rRqzEjdMpIPg0Ne5VQvE31hIdgfWgQIb+q10pACIQC0hvThgucg\nh3pkl9TwDpLTdZ3tPOEIHQZv+0Ea8qra6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARDzYEYZkRAWQFVgixRvxccDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVhODRjMWQtMDUxMS00NGQ2LWFlYmMtMTBiZDNhOTMzNjQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJiZTU2ZTRl\nLWIxNzctNGUwNy1iNDQxLTljZDA3OTAzYzY2NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEPQpq+X+fhaLyxHwS03ENuh3gCFV+hSIqgxHP/6AYPHFPjcePIi2xYI\nWY2cckCMHACtXrt/GthPwYa3n5zU+E6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC3j3xAt\nzjNbTirNCA28Voko9ppuMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAgLK/Txfjq//AJpz7N6iC/OuzY2D+1xeSpBDW\nCYQ2y8sCIB6h5KX9G5yxRqcGFYzbFUc9R5koJCn1j34QATkOys+Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1313", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1313` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQZZTszWTH5bnpK717LoYtgCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkZmViNmRmLWEzMzMtNDg2MS1hYTBhLTU0ZDc2NDI4Zjc4YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBlNjJmZmYtNzg1\nYy00MjJiLTk5NDMtMGRkYWQ4NmZlZWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwzbOrYXWcXO339WoAhVd+JxG0PdyXxYL87WkKiDw/L/7Z1yJPBxzdcV2Sw3Y\nkgu/NYmktXiXOBJJO2w7aEYP7aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU46aLjyP9in/rXjG7lxeZdXoVC+owHwYDVR0j\nBBgwFoAUPPHxmfR7U/aZpi9z6mN3c4yj7Y0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAInjXrjhZ9MG\nJgYfxMHu4KU8/EdSfrwimFoEBNbE0IcyAiBvmTVrwu7eTpzuCwHZiRzoDYaADdMZ\nmPd9+c3unv925w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARzuvB6Lsm4uDDCX7cSeRxMvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZGZlYjZkZi1hMzMzLTQ4NjEtYWEwYS01NGQ3NjQyOGY3OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSU5PLqveSARn3cV7OqxS3eX2aJjoE1oFHx70Bqb6g3mPa\nJcJIDy6YK3JdEZHJXZw4j688ao15zCiyutS2A0P/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPPHxmfR7U/aZpi9z6mN3c4yj\n7Y0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKJ1+OTrgBTsOMX+/3TBkltUOig+ZtpYAfHKO4rBUO7MCIH3lohyiScax\nfW1e/1Hprd9x7cpw5VTmwz1rbkOPLOJT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAafg/PfTxv755DKanbJ/8JHgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBlNjJmZmYtNzg1Yy00MjJiLTk5NDMtMGRkYWQ4NmZlZWRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQwMjdjNjEy\nLTg5NmMtNGQwMy05NzI3LTI0NjRhMWNlZjBkOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJDpJBKgzRprcurZ8p6eQWT5JQEsXxMx6GMTixve4wA4GaT1TYGJYB9u\nQNp9SARa2/n/c8nBNMGGr+0ovju7W8mjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOOmi48j\n/Yp/614xu5cXmXV6FQvqMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiA6T1vP/nzFhvbbUJZjms/YeWAhgjPx03zCcqRS\nKe/6DQIhAO2CSHW7qZMCC7CxpbPy/tg0CwlSjlxmSxn2jwPn0Z3+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1314", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1314` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATSXDIcKVaHqxHzqwuR16y0SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmMDIwZGE2LTEzMTktNDA3OC04MmQwLWFkNmNlOWExNTk1ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY0YjI0ZmMtYzU3\nZS00MTRmLTkxZmUtYzdiYjU4ZTE3OWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfkPGtL7mSi6SsChKjHqtspodH8YdOO58t//Ngu6YqbZ2Yvml7keA0h637A56\nh9hhJZ3NwwO6IdxIvrKLVFxq26OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz/1ejDHtqmjwYFiBx82I/qJmD/4wHwYDVR0j\nBBgwFoAUGkGx5HrS1o5YSwMtZPQqDfpJIHwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALgq3CCXLqmi\nsTYR3HPD62ft/RPick0ifqgdPUL0hXaiAiBfRyWb+YoOF90Zc+iPOsuHqbtjojTv\n7A4l4U4NxB8Cyg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcbptHambTAwGu0zBarBMyQVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjAyMGRhNi0xMzE5LTQwNzgtODJkMC1hZDZjZTlhMTU5NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPPblQUnXcRp07cDV04Q7zv+3d1YEWiCDGoqtcL3JFvb3I\n+2L9iQecqdcyUh/DXTxaIyOh/ItOoq4gaFFY8xD/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGkGx5HrS1o5YSwMtZPQqDfpJ\nIHwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcUELQmhJAG01rIwhL1Wvj+As+bcnIlMS3j41S9fBPP0CIAOdwRRwPOPf\nAqLwykCzdPJPD+a0Gc2SD1jzzdqF120D\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATnkd0W6PWfpFScdl+u3UHCKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY0YjI0ZmMtYzU3ZS00MTRmLTkxZmUtYzdiYjU4ZTE3OWI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc2YzEwZDQy\nLWJlNmEtNDQ5Yi1iOGZjLWU1MjI1MTJkY2FjYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKG2K8i+kRFuPVXzieBa6DGnQLeaeEcorPipnu3M54bNIMXXwz+eWmV9\nih/JgWwn+AghSjLqfHofBE86jYWKGGSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM/9Xowx\n7apo8GBYgcfNiP6iZg/+MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAZCTFFGAm0dY4KTcfBmGjXqqnUTVYFQSRoYCLX\n/j+7/gIhAMQr6aRNRzeFp81ioXrIqwGHTzvQwn1Zl11eOsE+EaEb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1315", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1315` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAS3ul9D4ik25rM2kDfKPN77sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2MWMxZWM0LTMxMGQtNDZkNy1iZjJjLThiODRmM2IxZjc5MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhiMzFiYjctYTRh\nZi00NmYxLTg3NTgtMjNiYThiODAyOWYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0IbopMxw2HO9QbYBfbRXR68PD2VkGDRZ2Fm7Vbt15WNrn1wes2BqTB3tO9He\nZ8/rzSrUmBkJVIcp1DdZBsSPlqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFExxYrxloA7n5CEgPrgSP8TSnNMwHwYDVR0j\nBBgwFoAU0gGBl8Kueg5U9aWYN1cxfTAu2o0wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCbzGm1f0D7\ns2DBdRoIjy6U27uMsUWq0HlPxSq3UdjbggIhAOvUOpzAxG1/QITaPUI77QIm+th/\nbop1yHmH7J8h35GN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUX+WQVzdvoCq0FkJpl1UewvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjFjMWVjNC0zMTBkLTQ2ZDctYmYyYy04Yjg0ZjNiMWY3OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWofRP5yO96CtS68uDDFIRPuOCVwT9Wmu9ckZFGH3hiHod\nhdpa5WUlSNtZFcnPoFJ6ZaNcUC/AUlnPzNDuVLdUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0gGBl8Kueg5U9aWYN1cxfTAu\n2o0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJVtujDWeiysLcagwyGdNbIuvxlbhdqIZBJ5WYOfArLDAiBfR1roxejC\nIiC2Jt61Vyx2/SzN3uyMJgpkjeT7SNDG+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATbEP6wCsRNCnGg61i/6X3upMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhiMzFiYjctYTRhZi00NmYxLTg3NTgtMjNiYThiODAyOWYzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc4ZTNjZGM3\nLWFjMTAtNDI5NC04M2Y1LTQ5ODNkNjg5YzgyNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMRk7kY1vygEBBl1fy5KgGf0Rr+VlvPOqfFWYRKhi/XhnugcBBQayZ10\npuqcJ4SNHQ4oOZYMUh2u9ZbOfkJe1BijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBRMcWK8\nZaAO5+QhID64Ej/E0pzTMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA4tnKB0QFhIg9ArbIh3ze506pxt7u3ek4Ou5w\nZMVUepkCIFWKST0JlfTs4/z0TjggmDTnzc54nP2Z2WREjMDLf7bb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1316", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1316` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfXobjbbVpy2LM1ACfDITbNTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyNjU4YTdmLTA4MDEtNGIxOS1hZDE4LWQwZGIxZDE0M2Y4NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGZiYTBhNGItMzBh\nZS00NjFjLTllMDUtOTQxNGExN2VjNWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg9yjJ6V19JRg/HOHorwTS3aSAFnuCHCPhVY6b589m9DrRcXCazGkXehfZuwe\nZ7HWUx6dd7rVQjHwcMJFtsNefKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqCO5/psTcTYUJlasGzjLPBDoMtMwHwYDVR0j\nBBgwFoAUmQh/NH/4yMPUPJmjy9I9gRQxWFIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGAs1NHLz9JqPl6IxCRBI/W0rkwMsa5QoP9OsAT+r++sAiEA8/Hedm7ANnlk\nmmMrV8GgQTjes7x3iX1Boc8Y7QMQ4Jc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYYxk77aXJ/tV5xa33ezABvGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjY1OGE3Zi0wODAxLTRiMTktYWQxOC1kMGRiMWQxNDNmODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR2Z1n3G8YoPlaxNTqFV3Qz8GbKR6TGYq/YWToRabVMt1D\n+hYY1qHOL3PXx2DpLSMq0jKLMiaj5xEgbkBLun0jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmQh/NH/4yMPUPJmjy9I9gRQx\nWFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeR40PxwRtYvjqdAlV/fH/HBzcFIkDmr9OfUm9km1ekUCIQDb1liQm7+L\npcsoTKc0h4q6EFItKZDV7gmOP06LJxUe/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAU2SbsDceckP9GwZZ6BLRJdtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGZiYTBhNGItMzBhZS00NjFjLTllMDUtOTQxNGExN2VjNWMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMxNmYxMTky\nLTdkNDYtNDBhOC1hZTJkLTQ3NWZmMGQxMzg4NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLYEAOb24MBmDECghrLjerzTYQONwzqa64DCuexaGzdEeNE10YLhm5mJ\ndxUnUxIOsApOqLBifbjSKhTGQ3aTFRijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKgjuf6b\nE3E2FCZWrBs4yzwQ6DLTMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAnvWc5fE2muPmuVU7GMsT7xuctQ2CBy8pyt71\niqJ0LP0CIEqsAMfLGN7cJqiNNrWkUsJTYaYXQJBvjCwMf0y5sIGu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1317", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1317` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAccvdW2lk+IYGalHh06ZEVcXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NDk4ZTBiLTU5ZjctNDM4NC05MzcxLWNkNTI2MTcyMzE5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGVjNGM1YTEtMzUy\nNy00MGZmLWEwOWYtOGVlMTk4Y2JkOGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF+meqX8Z5IuGDSd4Y8mxvV2ZD7U0DOMIcOv+tm9VGxfODMPiLM7Z3i86swNM\nJOWK5NNDgiEmRoSgAxmbkSerlKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwFxrzKQaXK/U90iiqrr6hFszcVowHwYDVR0j\nBBgwFoAUEHEHEgpO9eH5OrHDlQB3I24XHicwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD+30AJ4eGVxVXfs0Oy3CjN01M2IiLVGBS6zgzQhds37QIgaXzxZe6liTGI\niKLfn3ZsxYH3jW+8KvLOkm5vxtDorHk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbF1lTh+tC+zvjipDMC0V4ZkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODQ5OGUwYi01OWY3LTQzODQtOTM3MS1jZDUyNjE3MjMxOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5gtd3ASEiL2e+9lf53IdstufHdQiW4xF2gCZLfw48cUjZ\ndV07t59wUjdbbKMiXP8rOLF/Y0sDfbvBvCcBDy1xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEHEHEgpO9eH5OrHDlQB3I24X\nHicwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMrz0dGeDNJSt1pLAmkL+qgIX/dYhKepX3w/LPUBsdKTAiEAmQyhWn1c\no/mL4HNBUSBLJvw6zjnz8H62lRfHvZKpu58=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAYc5rwkYgzfn8E1dMW904Q4JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGVjNGM1YTEtMzUyNy00MGZmLWEwOWYtOGVlMTk4Y2JkOGI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJmYmE2Zjlh\nLTc0NjktNGI2Zi05OTcyLTk0ZDFjNWRlYjI1ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHq63IlyUThtuew0Z9Gi91OahLiimCHMnZGrZEW0MPJz/HqAgxZXXGGe\nXu4e7PPVkTxUFc7ojl84dTNV+bG1WgOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMBca8yk\nGlyv1PdIoqq6+oRbM3FaMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAn5E1iVkdIsM0gg0KC8+ImM88/uuLkMFVfSDvu\nChaxvwIgd66urKCnfJZRv/qgkRWBMR/OHxELrV+o3Q7g/C0zqbM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1318", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1318` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAdHYQt5AulHC8+V1RpEi/V8rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiZDJkNzVhLWY5NmEtNDg1Yi05ZDZmLTk3ZDhjYTI4NWVkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU0YTQ4ZmMtMWI0\nOS00NzM5LTlkYzktMjZmMTg3NDQ0NzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7y5lX7A2MdJO1T18e28sAfTpaa9ij0BAn5DTYqvxZmheKlC+9Mn46wV8i2eG\nkNrCWi5puxrje9eR1eAwTBQ4+6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCp/qaEV2N3nRqPCnlsc087493F4wHwYDVR0j\nBBgwFoAUyslV2Cyy/2OB+bQxriFIdHMjlAMwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCC\nyIpjJjJhaDb9ide8mdHFg9Q0GH1AWdh2M6kxmyCLEAIgLefY1elHNqpWVx1sFJlR\nvwxSxG5mhEQcISDAqkLlTKk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcnnEAKEl4pUF7c6n0WpgbzmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmQyZDc1YS1mOTZhLTQ4NWItOWQ2Zi05N2Q4Y2EyODVlZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxqiKi0jtg7VaNtLeDF8N8jLX8T0NEpp1ZtcgOekIRfUo9\nY+/8hNxm/sggUMUrKEdkyTuoZrd30C6O/y3n9z2so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyslV2Cyy/2OB+bQxriFIdHMj\nlAMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOO8KdJjbXlkFHpnolf9cMnfCw8KzE2UhW9bsn6jfieyAiAwu2e3+NLu\nykammfUy83i7NMk8LGsN7i4YmhJcRZWuUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAVJZ1oh62y502EihKDxDgy9TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU0YTQ4ZmMtMWI0OS00NzM5LTlkYzktMjZmMTg3NDQ0NzM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1ODZhYWU1\nLWJhZDctNDgxNi1hYjUxLWQ2MzYxYzEzOTY2YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFO+ggQrslilzuYTokMDfMW0tScvqqUACU362JZbcOffV5EtLRcsc9Be\nxXCdm0yLR2J0f4QeLVkI5yHkEt63o0qjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAqf6mhF\ndjd50ajwp5bHNPO+PdxeMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAQ+G1SjZWuiEzFbi/TPV/hrTYiITO320k9eoKX\nf8k5agIgQbJ4o1K6JK4k07wv8B7J9jPaZQe+uUGmV4URzrlnANk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1319", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1319` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAYsilIJnHIrPZT7m5eufsrzcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkZjE4YTkzLTc3NTgtNDhlNy1iOWM2LTMxZWVjNjAzMzFhMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU5Zjk0ZDgtZTEz\nZS00ZWY0LWIwNGUtNzMxM2JhNDg2NjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX9gs77V7dEyyCxebjZ+nYTuOwER0NelUA6AYiURCvP8HpEm8PyAMLrimLLUA\nA+BI9CPxHjJDY/bTIHyaaZPWp6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+DULyjss4vIJr+4WB07++FXZb+gwHwYDVR0j\nBBgwFoAUY83QoMIvyxkavwUXE1sl3Ql0eQ8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDOwL71chYvCqjyICnrNxl6i8eOMM0r+79tyjx2GqbLwgIhAMwV\nNONkAWsC2GFrFyOA9FC9MNP+1ZfJS98FpRz592Lc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcSDhIx1d6y3I7ugbK2ahik0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGYxOGE5My03NzU4LTQ4ZTctYjljNi0zMWVlYzYwMzMxYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuZGZosK8dimqEweWCj1vtMHgr2k1GSmOklXFVIG95Q+n4\nz1XfdrNg/cLzpMBB8Ne7QYHMER2Cr7UWPBe+FnZeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY83QoMIvyxkavwUXE1sl3Ql0\neQ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVZum1q8gcgqHRZGVQBaZPH3Tib4cGwMDIKZvZhBHW/YCIQCdGxuQlJVg\ntzrOJJUTTz8+I8jt4/uZL7pXGZXwfe3tRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfS4GDQ+oKwPsOuBonK69kUdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU5Zjk0ZDgtZTEzZS00ZWY0LWIwNGUtNzMxM2JhNDg2NjZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFkMThkN2Zi\nLTRkNTEtNDE4OC1iY2RmLTVkZDEwYzgxY2UyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM18oE5VTCyM+kXWZuQZ6LcaY5Y0ND52xHQ62PxfPW0EL7cQyNp+ImbP\n+zxIF1Pygsoy63YB54ZcJqY4ZVTu4eGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPg1C8o7\nLOLyCa/uFgdO/vhV2W/oMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA7garxeZ/wTYQXeG4SqM3U6k9Yo/j+MSNiTj0\nhVBcbpwCIB04ZDLENV0MUjzHMnKSJH8DQTF5xJi1w2BBcgiuuQGs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1320", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1320` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAaSFkUwg8CRvFAzCsu7EPF6yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmMmMwM2FjLWE4ODItNGJiOC04NGY0LTE1OGJjMGUwNGNjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU4MmQ3YTUtZTNl\nYi00OWYyLTk1YzktM2VlODM5N2YyYjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf8TFteoehD4gCHdjSryc8zmr9seqpRIITKAEgmJ7G75I0DEK+5KSmGaHOTXL\noQ572oQa1AM8rwHmpdulXBTNPaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuStjFpEBcES1B2uCiI7xkKyZN+IwHwYDVR0j\nBBgwFoAU1ZrwQRiXh/pUFl8ZrhCIyWikBe0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIAVo6Ae2XIO984LWxgONGh8H/oxhbIBwB7Hy1U1JIrKFAiBLXS0q\nWsgghkd3fG9/BCn8LTzD+hWYAHwfji1TTIHqsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbZmtBRUiEGtlZscrl2gNI41MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjJjMDNhYy1hODgyLTRiYjgtODRmNC0xNThiYzBlMDRjY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDOiGStKsR+03X+jJpio2Z6bEFAaiLU9twqGNvLUxnQPcg\nXTTWsXsVIfU1wPUdVDJrjwqOQ2Otr/n+Pp3HtPAqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1ZrwQRiXh/pUFl8ZrhCIyWik\nBe0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQa5q+0B+fPOBrd4XFW9qaAHXmor1vr79h41OGvwNyjwCIFevTWzut6v0\nshOplMmjC7jlTQSxwbNMEwu2gpGOB57u\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISARwPbJnSzgyR87YRnOAceiAeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU4MmQ3YTUtZTNlYi00OWYyLTk1YzktM2VlODM5N2YyYjA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJhNDIzMzc0\nLTNkOTMtNDU0YS1hYzUxLTIxN2UyOGVmYzIxMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCh4Kisl2w8dYDhXZ6SERcS417824xVKjcJnXqSuz3/jW7/gV1TMeHqF\nm3vWOLZPC7vwSrrE+/UklyhU4xsJiZajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLkrYxaR\nAXBEtQdrgoiO8ZCsmTfiMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA/vMsw/YT/SlLXiwTmD+VXk0baE2qVVv66NGg\nT8FRKWQCIQDT+LxGnTrSpYjveoaKoUYSqsrweWCPX7L//ylj179Qrw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1321", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1321` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAeivXpHXtG4PYwpGKGA1zjadMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjZjI5NWRhLTUxOTItNDIyZC1hOTJlLTIyNGZlZWU2NmI5ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZlMWY2NDEtNjYx\nYy00MWVkLWE5OTMtZTVmMzg4YTFiZTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhUYnNCNOMCniTaj+yNxTguPJfmZhtJOrjwOV/uQrIdL/ihP/mtV1TqTusOtO\ncp3agwA1gXPlFepErOs76lp7kKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEFmG37Q1G2lPVzjS0+z69Zan9I6MB8GA1UdIwQY\nMBaAFGNKIwZEeT4uekJb1mLLipuLK8L/MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBRl/5TbQjWa7mYnv7ERvuaZD5crs3DY8eL\nu5iK1pdM2wIgWhfCT5zPtR2B+77FmeBwmDTIaa4Nr1KFComrsFv0jLU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbAtBg2nir62NRjJZsT9DU7EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2YyOTVkYS01MTkyLTQyMmQtYTkyZS0yMjRmZWVlNjZiOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbf8QnUW71dQvtA8nY2/izJyq+DK+raS230+KplnlIyDDh\nDSQi5IW53m8cIC8xnoyCawttJLOv9Aicbhl9tyEWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY0ojBkR5Pi56QlvWYsuKm4sr\nwv8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE6A0INX6FxQ6Z9Nwq8iwyt8KH/SoZ3QjdUQEnqmBuIkCICQZR6tVfmQi\nE+FVLBBerwNLtueGIha0MmthGlNsB+i1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISASrnMqFAJ4Z5S8ciotYSih97MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZlMWY2NDEtNjYxYy00MWVkLWE5OTMtZTVmMzg4YTFiZTIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcyNzQ3ZDZh\nLTdjNmYtNDdlYS04MGI1LTFhOWY4ZmQ0NDg2MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG7u81IBAwrfSGrYUWueI6rjIvg88mISwvyP3+G/eA8V4I/vpINAOn20\nVjZu32snO63CVmHN7eElVZLbCVzrUM6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEFmG37Q\n1G2lPVzjS0+z69Zan9I6MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBu+JvyfPesB4qV7qloIkmM8DKIUoMYMTWbV0jF\nYE12DAIgbR+bzPMMC7LaQ2YSnOp14GzUuNVhGuYO4lFmnc/EUj4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1322", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1322` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASOpRwC/JQlHQJDQ39j9sOWVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyYjRhNDQ0LWJjNDctNDZjMi1iOWYxLTFhNjkyNjgwYzA4ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU2YmQwZTYtYzE2\nOS00ODBmLWE5M2ItYWVjY2I1NTk1NzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUYdeTlaCZsShBz43DZCxiOm2fnLWT4Ac4F3dpcfwMaeB+whV/F4arAFGF1ry\ngITd72V2prVeWQ/tL5EEYMsFbaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa7AhMJyosVXt36GaKSuwaDS4NFIwHwYDVR0j\nBBgwFoAUBYP8+/ThXeXddOicpiAesXmKS7wwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALgOt+JJNg6i\nGwqQViewKcDhfRg5lbQuoh9AUvIUUz+YAiAo3gpZyj3XLMIF9/b9KMwK++SXiSL3\n4NYWylvuyqZmKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbkgJoPviz609q0fDkC6hYlNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmI0YTQ0NC1iYzQ3LTQ2YzItYjlmMS0xYTY5MjY4MGMwODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZN87pl9ZGcwGS98awYbgjEb9jsgrHJ85iMee3PICo2DhY\n+c4org9qHsSTHJL5/I6N7OcctyIODH7RHJTvR3Qqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBYP8+/ThXeXddOicpiAesXmK\nS7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANA5hRaxQZU/s39/hdG9jmx6GyqX6nh+up6ewmvPbPSoAiEAvN9S26ll\nXybeLzBBRbgcI2dbvaBD3aKTKU/PNtEEs9k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAY9gFBFq1Z2i5cT8d671ucydMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU2YmQwZTYtYzE2OS00ODBmLWE5M2ItYWVjY2I1NTk1NzQ2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY1OTkzYWRi\nLTNlODMtNDNmNC1iZTNjLWNhNGYwNGM3YjdlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAIL7gnTSYAbkfGVpn9i6kTXcDbIXGHhTjHjEqYLImZGft/w7HgoZnMN\ntW4aBvGv6Mt5XVjeHXsvwRbfQFo2TuejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGuwITCc\nqLFV7d+hmikrsGg0uDRSMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA8SObpUlFes/ixup1wj5eSdvOr9OhMD/7KgBW\n22IkCnsCIQCAIml8b6qNsf6jyjOLpsxsq2Y/i0Qg7hOBwz1Jgcjw0w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1323", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1323` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAc3mfY0vHZIm4PgxfGkNNoNpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwNjVmYjA0LWU0N2YtNGI2Yi05YzA4LWM2NzJhYTFjZDNmNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M0NDMxNzktNmNi\nNS00OTU3LWE3ZmQtNjg3MGIwMTY2MmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ScJvy0qJMe3ki9kp22XW5GRfvqykt9wbgaE44gAW+zdOi7r3kbCnsX5vYNk\no5xFihoGQ+L+iHY/2As/8einJqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzfNQSc6shxPNY7n7FsbGWJYqUOIwHwYDVR0j\nBBgwFoAU7KulqYnOp5EJ4jm7DdMpsAqgLlMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgI3AFbai+srPh\n72CJLcA6Gxb9utpi77vPFlK4+7MAciUCIQC9G/s03J5lQa5mgyzKzUAdAGxwYNoV\nVkbSrE0ghJAS1A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe9tNJPh3tD4wKmzuad3ybngMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDY1ZmIwNC1lNDdmLTRiNmItOWMwOC1jNjcyYWExY2QzZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHh7nMnKn8yV7ZnsVZineqwIyx75K6pq7x3HAbqaaA5HK2\nMBEDzMtFkBLfRUTHLEgwKgZVHrKDf/rQ9mucVQAgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7KulqYnOp5EJ4jm7DdMpsAqg\nLlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANTkWb/Fdx42WZ1eHlA6hl9Qv/+4YX4VqylL5nbHBFDuAiEA5V1yTKT6\nCOFOmdfJSysokYGE9D257qM54gNqsDq5Zus=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQ4FcreyvPVxNSniWmXZhYlgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M0NDMxNzktNmNiNS00OTU3LWE3ZmQtNjg3MGIwMTY2MmEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk2Y2IzY2Nh\nLTVjMGYtNGUxZi04NTg1LWUyOGQ4M2Q2Yzc3NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFQSkz2BFlozR+MWWdtpopIrHXYi0sB/l3Ii1uzwEaA/h8l63KSqPWS3\nOG49kZmvU1l6CiGb9Qa7Jz37FUw/9aSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM3zUEnO\nrIcTzWO5+xbGxliWKlDiMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAu6hKhNAYTbQfOUJvW//Fxi5+eXjipf+Xj0HPc\n5yYnEwIhAKq9q3hFKa6UqEcc49/f358zz1UE9+XQzMJ8VV3NN1Pu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1324", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1324` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfFVCB8kF0oiDRc9FRPmQql6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3MDFkNGJmLTcwMjItNDE2NS05YjI0LWU0ZTYxMzRjMTc5YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNkZTY5NWEtYmJk\nZi00YTEwLWE5OGEtMTZmYWRiNGI1ZjEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWXel9HSBTtd1b7cb5oa5Col6No4C/xpTc+oNJozDD9XTc4wMhr15jhVPCbRU\nE3pUxz2/clD/bSm+OEIU0en8aaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEGbEbCPI0usLTrJy0sb4e7Y9W4gwHwYDVR0j\nBBgwFoAUeqlvXPxudA/d/ZELZ2662TnG/tYwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFvDoB9XhlID\ndQeNIk6OApgxwulXoOpexJTr85IwPh0kAiBlGNamK5DacjNYcm50QWE0KUKLTg0M\nl0BxnxsquE5xgg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbqQ7tn7FOXbn1nFiO/sJjwxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzAxZDRiZi03MDIyLTQxNjUtOWIyNC1lNGU2MTM0YzE3OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOXp3r7LXEJFThADx9NCd01mJln88dHGQf6Is30NUzdUGS\nFB+QoBcwIgWX5vPFaMTyS/IXS8ZFtElj/c9+ufgjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeqlvXPxudA/d/ZELZ2662TnG\n/tYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWEXrYaZcFDmt5DZYneZcGWk3ws/Pem6uqHbc1H8LzQ4CIQDUOQUhmCsD\n8a/49hVm36sV3OwZr1ymdb47SPTI7gAWGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUiHr+spNF4NDS3lEyay7QgsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNkZTY5NWEtYmJkZi00YTEwLWE5OGEtMTZmYWRiNGI1ZjEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI1NzEwYWJj\nLWY3MWYtNGMzZC05ZjA0LWQyOGZlN2M4MzFlZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCEhE14n8eCmE5tSPjfPTvpcL2BoX3rOB2nAr0tt6Nfo4dP3H4DZBDQq\nV04qt3kNrKCubq8PBDNzkvYDL9DTLjmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBBmxGwj\nyNLrC06yctLG+Hu2PVuIMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAjb6lTUuEBOdiIUb8dbOJm2/TMmqQ1yd1gAoA\ncR4Bj4QCICP66AOY+QCCX6/MBjT6szbeL1r7sY5SRVFNqvB4XPqr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1325", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1325` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAQ5Jserol1h4eTPzV0i7wr7bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ZDk5ZThlLTkzZDQtNDE5MS1hYmNjLWE1ZTRhZTRhYTc5MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTMxMWM4ZjQtNWRm\nZC00NzYxLTgzYjEtZGM2NTk4NTYwMTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExnyV2rDeYQg8cvxsh8qJHKHbDXT9B/+A1NUX2DNLAXu2vI7AZ+fs7tT3m5np\nYLg1xS7/YVE7F05fMEBrYHONaKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW1dfC2rbJWWhuCki0ycL4GCp4n4wHwYDVR0j\nBBgwFoAUPmvE+MwL/bgHnfJ1tZ+f955D3XowNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDxXbIfEnO6loRIFXfu7KTI5ipiFsWL0D6FQw7jnj60CQIhANTYdoyL9nVF\nfsIhqauW+3jSur8X1SXY9QbQJTW4IXeT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXzIVpeCjaiUTogmcn3LlwUAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWQ5OWU4ZS05M2Q0LTQxOTEtYWJjYy1hNWU0YWU0YWE3OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyzdZY+lu2Kg7IiTDcj633I+K26/Us/TZ//VOGWZbsq2TZ\nE4HlUfrfTgPSpctyF48XWUsw95Jbt1HYoONG4BR3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPmvE+MwL/bgHnfJ1tZ+f955D\n3XowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIWyGOl2gfoQAvr9sLpoCtQ/SpdmohUhyt+8M4+lPmkUAiEA+7bAKinu\npOn45Szyy4ZQrdiBAJnJ8rjo22p5OOTpnE4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAU7KGTNmcwcNnk9v5mTELyMUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTMxMWM4ZjQtNWRmZC00NzYxLTgzYjEtZGM2NTk4NTYwMTMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA0MzE2NGRi\nLTRkZTUtNDVhNy1iODQwLTY4ZDE0MzI1Y2IxMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFssgTvQacZmnemwzkaEbzuD/P7ZpPf7Kob5E3HiXoCliFrq/ig4MZCF\nctaTp6hgxkVIW/rfGlD9iOIf1sqrvE+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFtXXwtq\n2yVlobgpItMnC+BgqeJ+MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAthQ3/Jw7abddArkObCfvQx795cLJvislAVUK\ng5DRtkUCIG5t1i8ssy7bI1Hi482N87eD7Uj7rHQUZZ1FoNLzTewy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1326", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1326` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATCMPa+0o5WGM7YsVOJyB0iMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjOGRmYjcwLWJiZGMtNGQzMS05Yjg1LTM3Mjc3ZThkMmY4MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjViNDIxYjItNmNi\nMi00YWE0LTg2NjAtZGUxMDFjMzljYTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYuqa3bRoSac3J6+/HfSP8shisTOeyYy6shDnXizDLYHxzr2pdUJWIPkaYzmH\nD66GgUZlN6r4WyTZXT/iVldhKKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEEJ8cWghytwDao0riFT2tRl+WnAwHwYDVR0j\nBBgwFoAUbVuidJCEtksZwAYxY6w5quV3fvIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCb+z7kFWIQIq7P1Y8/TaNys46nO7qZv38PjR8L/jFAsAIgXugEXYg8aoSo\n9Eteqz+SpfyaIYVyTkAKg1P/iko7yF8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXyh0nmFdkcJL/w7CT8vzkbhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzhkZmI3MC1iYmRjLTRkMzEtOWI4NS0zNzI3N2U4ZDJmODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdrbFSnQ34m2bLRyacfyVZB+kKcO1C2DPDa8ZegFrd7y8n\nApEw4HU4htF7JfsYXJT1tpd5TsZAH6h/Sdv6CWJOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbVuidJCEtksZwAYxY6w5quV3\nfvIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKqnAHrak5VRNuAdkeFbXaTDeFO4heOJS1LhSB8N9/xHAiEA7XQw+6to\nh8QL1+r5+bINe4JWr6zWdmjr7iAr1XkrmcE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZzSlTDVtzDLZaNzPFu2T3hFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjViNDIxYjItNmNiMi00YWE0LTg2NjAtZGUxMDFjMzljYTUwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJkNzIyNDhm\nLWI3MGMtNDc2Yi1hMjg4LTY0NTlhODhkNGRhOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNuOMBeoC6KnBChjs7y7f8K+9O6c2kqDcPd/LK57+3OOB3s9xrAI52Vi\n7atGP6myp3KN2h+WU4678iL9qszVtFCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBBCfHFo\nIcrcA2qNK4hU9rUZflpwMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBf24W+vB0YspWsjS4DvWPAl4KSQURI8Iv6nqQV\nTCZY2AIgH3vZzBmgnlEF0s/ou9M27kHyiCbQluUEVQNw2ZMfsMk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1327", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1327` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAV6ayIjoz6IWykCcfgPEBJmdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiYjg1ZTYzLTE3NjAtNDkzMS04OGNmLTc1ZDgwZTU1OGNlMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBmYmJlNzgtMTZl\nZS00YjcyLTg1OWItYzllODJkZjg1NGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9DPYSTfdkjVBQDlNlAXvcHLQiJSpFj3fkIudORF/QtAsA2LfmZi+Xdo7pSUP\nso1NmwJlT/2D72aH8NM0f/tZbKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6zQjqFKkzzol1ay97493BaY//xQwHwYDVR0j\nBBgwFoAUn7aY/SH/Z3tx3j8OctMc4hP0IBMwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHUS\nc7jrQFTaepXcTBEvepnUwgClucImg6tKbdoWDJseAiEAmvZfaH6sxoQrnAlpjViZ\nlUf68/YZgRYBBFZ7HvwUGDQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS6/HVz4lcNig4RjSGSEQ96QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmI4NWU2My0xNzYwLTQ5MzEtODhjZi03NWQ4MGU1NThjZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJPig1NCmCdRePsb/Agw+7X8d53dhThXFfg9kQgSTVLV8t\nEouJA4FMsOCpzFCZkk84pqY/iiqyPcqNaqufd7ZDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn7aY/SH/Z3tx3j8OctMc4hP0\nIBMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOmButhxr6n7qoMH478XWc7q5c25OxeCoQ4ym7IB9x3IAiEA1s7jhrhx\nfCEFYTRzibWU36LEwCleDTp8LGeMeMT2JbA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAR+K9FvXtHX9MJ3BOFy69oNSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBmYmJlNzgtMTZlZS00YjcyLTg1OWItYzllODJkZjg1NGU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI1YWJhYWQw\nLWIxZTctNGYwNy05MjFlLTdlZmIzN2U5MDQ4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAehxHPfSpcwrjktoaq4q5s8CXGMJIWThltOQqaztoZJrpNe4Y8uEtfH\npS58GUOp7XBZk+jNd5BE4LyfvZD0w6CjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOs0I6hS\npM86JdWsve+PdwWmP/8UMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAualGAowozoXZTVEo7A+b+EKgoAhVEBSyaVdp\nQLpum3cCIQCgre8Y+DzvypqkrdGOtqKqu0xq7v1hkOp0H3OxxSoV8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1328", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1328` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAc3lBWpOFi2d6Zb8x9QXYQQ3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3ODVmNWMyLTA0ZmEtNGVmOC04MzQ4LWYwZWY0OWU1OTQwYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcxMzAyOTktZmUy\nMC00OTJjLWEwZWUtN2MyYjM1ODE0NWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbpbfTD4rYLeISpD0A0uUG46p59pcS7TpLyfHfJIxjJEK3jh6l1EbuvvbjJtp\nW+vbB2AvnLToss8SFrR0UTs/6aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm2T2i3G6HPkVvl0uT6/RrS5dIdEwHwYDVR0j\nBBgwFoAUvAdvrkFaq3QFczbgZl5uOTLeXfwwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCkRWu9k6mpe1jKcc3Y7UjbAfbtYmQyM66uoL173ETdvwIgBinq\nFzVyJPDS7s4UPWBvmglu0BeIDGkVXAAnjHSsPMI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdi3ZI4s5VTIz7VItl7vgt0dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzg1ZjVjMi0wNGZhLTRlZjgtODM0OC1mMGVmNDllNTk0MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjpkgVp3VoiSf27Uz9VMRnpkC8SrG+JwhJvkbyIl1oy4hh\n9KttZ7h5XOTluVzAEf0sDKSSSQJ3kJx5l7ri++QXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvAdvrkFaq3QFczbgZl5uOTLe\nXfwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKuqbWhMkQuMegZscdFQuWywdzgvj8ulm2HzRFz/zBIxAiBDlBuUaJYA\nSUh913QT4SW6KBMr3ZbtE9yQhhhsxYVTMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAeBZzvlue4waTH1t9oxVoXSyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcxMzAyOTktZmUyMC00OTJjLWEwZWUtN2MyYjM1ODE0NWU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYyMmRkZTQ4\nLTZlYzYtNDI5MC1iNzk5LTA4MjkxZDY4YTBkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE3qYcJM0j20mxN7rovMEeuWDUR+lZHD8XFrjhcmKvv/YTeIRgB1nGxc\n8bDwOtD8CyoAx433NR855iMUU26VQHyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJtk9otx\nuhz5Fb5dLk+v0a0uXSHRMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAjGpzQlMhuvQI77WUaDqG9uVCYBbNKz0QidUQ\nLxne34sCIQCQjW3Uxl/78qLPhtBtQIA8A5QLVTtSzkr4CC1lF3Spdg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1329", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1329` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAR7v42ZXnGLiCPBfzygQx+0kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMjI5OTc4LWY4NjEtNGE0Yi1hNzdjLTgzZDEzODBlNGY3ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDUzZGRlMjUtYTUw\nOC00MDViLWJiMTItNGJkZjEzYjA1OGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW65rvtJGDxNAVeV4uiAa8kLenX2EFCdQrotlkUfiycVeMPL/rSLmVGzOBf5Z\nxk5bybTkBHDVvqoEoCk9oLYnZqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU85cPjhoe6rwVOaAaCmsV9PkuqRQwHwYDVR0j\nBBgwFoAUrQnc17NNhT6iTuMCdU2h4INp6SQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIGKUa7P7QFLuuOAMJfOQP0lX/5afv0N5hhHX41Oqj/5vAiEAmzQj\nlrNZewo9j3Up5hzNcfAGTI4jjE9L7v5n7gFRKqk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaisQY1ARRJpYZES5zfqFpq5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjIyOTk3OC1mODYxLTRhNGItYTc3Yy04M2QxMzgwZTRmN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgD0f7SxSVt8yvfO8hot/b3J4HmMqJuSEEfOYOGSlLp9TL\nxtSCnuq4pPBXL0d3i+m7dZg6iIaSdNRHaiOs0qtHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrQnc17NNhT6iTuMCdU2h4INp\n6SQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO9/zegNddkXWKrPFceccJaaUx8pfJVnGQ0E7R5l4qDxAiEA/x83sVoI\nAZIXDvHM0BgxXyvDtk36zaHECQNsOKvKnz4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAWPaQepy2LN37cqOj1wqIN/3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDUzZGRlMjUtYTUwOC00MDViLWJiMTItNGJkZjEzYjA1OGIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZjNDI3Mzk5\nLTJhY2EtNDE0Zi04MGVhLWY0Y2YwZjI0OWQ0ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCjly2oAtqIAbrB0DMVwjHLw+PF9sbU8j2HrxU8qgkXH5v6Fvddyz7UJ\nM5d15WEv8mf9K4IexIVZGJfAaA3E6lqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPOXD44a\nHuq8FTmgGgprFfT5LqkUMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA+j3IdKtg9XqE17+ZFiIYNq8JPpzpaUprN1Dh\nP/QvCmQCIQCOaHyUrOyvNJHhTQwBB4LHT67VLjMK0ZAu/lmDWKvvrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1330", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1330` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAZuWtvJ+vIkZn1/Un31OPL28MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4OTdlZmIzLTYzMjgtNDEwMy05OWRmLTMzNjJmNWI1NTBkNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTVmM2YwNmQtMTli\nMy00MTc2LTllYTgtZDcwYTJhZDEzMzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExeJUENYEvHz4hWIjrwXoKUmGU+nzzzRo0q11g6rqQ1sQSzE6PWrrWmKq48xj\nLgka1nWa8SrIO3uOaqyeQAP86KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQGGC7s3kPffcooOY/4FCm2YVzCSDAfBgNVHSME\nGDAWgBSBHYVxKwQAh2vZSO7XM3W73WQ29jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBq03PF/XDYshgo0wsDGHACXR+maXAP0\nXtXggFwQol16AiBnKNautskTp9ZA9BezHV2yXEIT/vs60MAhP+qXXac6TQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUer8Mhj9dKmolaf8z15l5ubMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODk3ZWZiMy02MzI4LTQxMDMtOTlkZi0zMzYyZjViNTUwZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4OMZ7RVl2Y9YZok/eqJgEAp6fAS1YkgXwY+AaspIbsPue\n3B/2VIVhHr78g680NpELWFQqOwYEZ7Aa9Y9o9u+8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgR2FcSsEAIdr2Uju1zN1u91k\nNvYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIB+p+3OmN6ILGPk5LhUdl/PKVTfRZ45Yk7OdFl7/MaKAiAR2cvNeQsR\nJCL8CTDBPuo+9YaftQ0Z8Ggd9cTC8U7JUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAUC7E6/ytVzRZNeV01pYLBWaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTVmM2YwNmQtMTliMy00MTc2LTllYTgtZDcwYTJhZDEzMzIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk5MWMwYjUy\nLWM1Y2UtNDJhMC1hYTc4LTVkOWNmNGM0YWI2YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKChvHldNgFxaqW95yClhl5DHZ6a4nbc85ofzD7Sp0Iq0GE97MdFH6d4\nJV/uDvWHEqSYlZV1OMZK6bbc/z9yX5ijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAYYLuze\nQ999yig5j/gUKbZhXMJIMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAxDyw5uUPxJpf207bMcD34nC5G7i2yRdUyBKiX\nuGEbXwIgCyaMvI5IrWtcUkH95CUNKWAKOzkz8EEAOimX8xOpEhA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1331", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1331` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASiJDsJvoVK+qPbZOxw+t0zLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0OGY4ZTYwLTBhMTUtNDkxOS1iMzUwLTUyNThhZmMzMDQ4ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZkMjZkMzUtZDZk\nMy00NGRkLTljYjQtMjg2YjA3NzkwOTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPfsLqZvz2as1HklI/Ub3FKV0b2xGCatzCtGu7jJSSmKPy7aJuOT8Yd5R6+W4\nqZAltUVAByQMn40PqTuIO17wVqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCflUZc7pMxJ/L5fDZBcOqEcCF/0wHwYDVR0j\nBBgwFoAUbX5ZA+BT+CX8OZHXHEh9J1RBAKYwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCczp51BYu4\nhr8aKz5DZcteQOG8pWr0ibyu8Cl8aEX1NQIhAPziJxcg8w7LsYRPNtqvbvikZsZo\nmeWqajhB07d9OJ69\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT/j6ZGudB5eGB+jiWInrXI2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDhmOGU2MC0wYTE1LTQ5MTktYjM1MC01MjU4YWZjMzA0OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2Ik8wvN9BQWjnk0lH7YBlS68K7fdNE+3Aup9zL+7imU8f\nzzJpHZW+ctqgYRybHDI64rzo4PNJt1WUmtvk34U1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbX5ZA+BT+CX8OZHXHEh9J1RB\nAKYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWH2P38ba/tkxtuNG3rAR9Y69u52jkFARxMYF0Cf74AQCIDotdPZPgsOQ\nktNxYJ8luYUsL4XH2pkIqegK0b0ppKFH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfM5Qpq2sPvkqWRQYsovy96RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZkMjZkMzUtZDZkMy00NGRkLTljYjQtMjg2YjA3NzkwOTBlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM2Y2EyMzUy\nLTUyMWMtNGRhNC04ZjVlLWMxODBlM2QxM2Q4MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJEIxXkdAMsmKfWAwJvd8027x09LH0cEziqN2M65An13p8gQPdtgJfMu\nJrX7lGGMI3++C09cLebDzVwctFSCus2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAn5VGXO\n6TMSfy+Xw2QXDqhHAhf9MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAgci7hFOrmgZDHErTaI+WQwTVbT8ZQhSC/hP/\nFYups2UCIFOp1Qu2OtKxdGCcBbXtgXSYwzOgmGjN0z+iLZP7kgiS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1332", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1332` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAck7H6vosUSpN3JZK0+aGG/QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4YzhlNzBmLWNmMmEtNDAyMC04MmY3LWFiMWUxNGU2YWE1ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc0YTNkNmYtYWVm\nMy00Nzc1LTlhMWUtYTA5YjczMWI0MzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb1KN+I472hhFiyfE407VluQKyYrQ6x5XNwEdmXNKDZ2AGGyLGg/v2Chg2aq1\npwA51pL58gPcQ0CYWqnCY0nLWqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1WpjxyUBBmC5i7H6NZgjj0fKyy8wHwYDVR0j\nBBgwFoAUberQ5hiLPMuojz5+ABHQiQvZh5wwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCsM0cfSfrX\nqhHN+s8t57AAVGdpVB/wqWwppKcuoLaDTAIhAPryqaH+3pk3fnkUghXDAtvi/fdO\nvaYblwSzu6pHjkVT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUAAOxdiwVfC+OWC7Opidp5HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGM4ZTcwZi1jZjJhLTQwMjAtODJmNy1hYjFlMTRlNmFhNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASF6tbfPAaWTbRG9bOwUUs1X4zGYm4gE3eaAunmy342/8MC\nE3YVCMOW2txoFVytz2naP+RY0poyrpK4wGWp69T/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUberQ5hiLPMuojz5+ABHQiQvZ\nh5wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMMnIUdilgj1YNtPr8LSSqYMRDQurQHiNsudEipagpT9AiEAvUmh5NWX\nIqv+UEWEfDbmR1f/A8rEi0ZgqpgHOlEDl7Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAa/AsD2Hus7ITzmWZi207XIOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc0YTNkNmYtYWVmMy00Nzc1LTlhMWUtYTA5YjczMWI0MzM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA2YjcwMmY0\nLTZhYjQtNDMzMC1hN2RhLWRiYTg1Yjk0NTc0MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIV2cJZm7nKwxDiEtm3k7x8M0ZF5wokVHy/UpmHHmmFhCxsyerJd/gRv\nNKuoWbQ3c3WE0ePCQ35s8vzkT5c6ppejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNVqY8cl\nAQZguYux+jWYI49HyssvMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA2b314OpJ/O0ZFLv3uChhHZIdsCMHiHA+A5tc\n4OOrAM0CIQDp1qDtZT9Sb+40j/zPo9B6rpcFGmAtqOybSlUFYSEwxQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1333", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1333` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAR7apUI7DT13ptEepXnIerc5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkY2VhNmQ3LWYyZGEtNDQyNi1hZTcxLTE0YjczZmExOGUyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDExY2QyZGUtMTkz\nOC00YTYzLWI0ZjYtMDc4MzhhZDRkMDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdv4C0IZo7qx3K/IPpsh2vlc9QpN8p2cyt9ViEOu2AS3Y0zQm0fXeHpHPSHLY\nuyGbjGak/Gj0pD7ZV++Hvc/pe6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT9/nyS6wugQ1x+KjIBqd4VezCQ4wHwYDVR0j\nBBgwFoAU7d506cBwPQoZ01dzvPY8V1FWYcEwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAs259PH1rl\n5ZQNjGWg6i1/QmBkL6WS0KEhbydcGuw51gIgIVFoBlAjMvoZxkTlyxTymqd/uPKc\nwGEOL1eqlCkrbC0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfVFP+Ze9EQe84qLj0uVfc/QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGNlYTZkNy1mMmRhLTQ0MjYtYWU3MS0xNGI3M2ZhMThlMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpVVJnP8K4FAabtJZNNDJp61+nnzKhqgJq4XMMJY6XtC9w\nLrWodZc9KxDu/RpMG2mVa1OCFXHFpT7FqvZLtND1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7d506cBwPQoZ01dzvPY8V1FW\nYcEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANu82mDQyPXH2E9YkiGbjaVgq56ym0M6LuWsUeKTLtntAiA0FbB8kijY\npOr6pVjs+juzdZE/nqEl5WF0ZStGwKntig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbsg6wjUV5onA8RH2VqtbEWwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDExY2QyZGUtMTkzOC00YTYzLWI0ZjYtMDc4MzhhZDRkMDZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM5M2I2Nzhl\nLTFiOTItNDlkZi1hZDY0LTc1NDFhODkzODFhNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIuI+daYAE4DwRNA0i8o21bLPikBM2vQ4BBTteK63hL5trob1tL9yRhW\nnxcrtyOiV3rhKBLOVhNZ4+/nUVGaOY6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE/f58ku\nsLoENcfioyAaneFXswkOMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBOWWy+wu4PGYPc6V9rt2tXK23+2Gb8Fyek7ixh\nORdrvwIhAPKmRAtC5g+u8Baoyj6yBRAQxmm6aUoCX6cVinm15m4r\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1334", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1334` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAeH90OsPCl5CN2cKrSNclwpfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkNWMxYmE2LTRjM2ItNGFlZi04ZTU1LWIwMGQ2YmYxNTJkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTUwYzEyYWMtNzdk\nMS00MWQ2LWFmODMtZDVkOTU3YzVmODhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnjo2qOSDR22BBeNB0QX2gfwqditG/UYO68UtzqV7WcCkK8YJCnZaSYFTBL4c\nPfO07GYrCRtrM5b/hLDRFJIXz6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu2fxuNTexvrjKDmbFty0c+bf8eAwHwYDVR0j\nBBgwFoAUhBbELhai03b/NzpyEXAUuOfA0TswNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAnr4EnDYE79GPB4DnEBOkI3chHfrcn+scaVFWSooj4f0CIQC842Yccech\nQy3rOtnU/Xstb0T3z2APIXsRpukk0HnCCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZEgoDw7ZB2VDXMKVMD+WjZjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDVjMWJhNi00YzNiLTRhZWYtOGU1NS1iMDBkNmJmMTUyZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEKCYEi37vjc/mjJB6psE0xQwrifQTaEDkyNRvlmBTartX\n5vKijyvlN3EUBabKMZF00OWRXA/hiHxJwYve9Rjuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhBbELhai03b/NzpyEXAUuOfA\n0TswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL1Z5e0LLMLBgsRxZW5TIGP6axGMkDyEaW39UJA8p5UTAiAgYbhYsHkn\nFS8rP+P0Lf927I0q+Z9dLb/dxZzISAsoRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbI8n7ATNaPKv2HO9yGN5MyVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTUwYzEyYWMtNzdkMS00MWQ2LWFmODMtZDVkOTU3YzVmODhhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNkYTJiZjM0\nLTZjZGQtNGVmNS1hYzBiLWVhMjQ0MzZhOGVmZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKVxgp6M5wN17KGl5drnCj1JPa2IvhO/1U/8z6pdn1ZaTJRSotBsuSe0\n/cElNQZoN0d8w7rLuDubOu6Cmzrlf5ajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLtn8bjU\n3sb64yg5mxbctHPm3/HgMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA2ztbqog/dPlLA3laTy1/o3EwaWn3A7zi3v6au\nMGI+DAIgetcBSzKTOOCCT4ms35Lx9zfxOjPa/YjG6oy2tc/kKic=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1335", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1335` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAW1GsJYDC2BWSMqNDXcUXvi7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmOTE0MjA5LTU1MGItNDAzNi04YWI4LTBkNzE1ZWExMDUxYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGI2YjBjZDUtNTBh\nMC00MzZiLTg0N2ItMmI5NDA4YTEwNmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/oLBPybxy4iqxOu/MupG+csPwc1dk0UOxeq9hL7/qe5seG3G5QTFt3Sh5kYa\nOGnciSsCXvCBZhIY1cDd2cQHEqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO1UT+3f/IAiiHliKcZMghqyQDZ0wHwYDVR0j\nBBgwFoAUBmxN9Dq+5JgMO5OjtMJPyjJLBoYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAgqvb/p9aIf/yr0huEXJ4NcNzNUAKcANoKRSZhOAlu9oCIBfxY1SM97rJ\nwoeeByPEzqa34sAyEDJIVU95o1mxUmy1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAREFZ7VjZjF+s3YioVb1Da1xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjkxNDIwOS01NTBiLTQwMzYtOGFiOC0wZDcxNWVhMTA1MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdf7CDGXPUR+iKpHmyuVbP30gJVAl9txhRWrbBFtuXTAFE\nbm+1bEPW0KvJ1BEQ8ZoPUek/JZ2xg46KHn7vEu/xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBmxN9Dq+5JgMO5OjtMJPyjJL\nBoYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOFQLLoYZVSiKs56U+pejsw29WUJSZvSUXMTWIILjcsyAiEAwQOM/FPF\nWmacN06Vfl4iq/0o6co+7EX6YKPXvQ9lp+s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAQ5C0k4ug4zSvKssrlNdlqaAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGI2YjBjZDUtNTBhMC00MzZiLTg0N2ItMmI5NDA4YTEwNmY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNkNWQ0N2Ix\nLTBhNGEtNGZmMi05NTM1LTY3ZjA3NDM2NGZmNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIoVDjIGnXnvu6h9aZDo9MyMOV01FR596WjbK+8sSm/kN6m8Msp05OFb\nhPJvdJ0XGsoh1TOTwBnj74cvAxLt85ijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDtVE/t3\n/yAIoh5YinGTIIaskA2dMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA/pz/TY1O28mwmxVUSIkt7rixttmNNjiw+rZU\nRNVulfcCIQD4o1l0q/MMhJaI9MCOn8VqJgnXssQYX67mBaKxZvROhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1336", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1336` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAXdYhf5NVcPxCtU3eTu93kL/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MGQxYzU2LTY1NGUtNDVjYy05NTBhLTJiODc3ZjE2NDQ0NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2EyN2U1NTQtMTc0\nNC00M2MxLTlkNTQtMTQwYWQ2NDE4NWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGoL46HGTqeDjk1oe6+v5KtLYM9aVVt7noJiC5hOnkYGnaVUAIEKYE8pivczI\np7QqaJ5OAEvK4UdifEFkvTWUrKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUogGk+tm2IpfvEiyIGzMHNNEzlU8wHwYDVR0j\nBBgwFoAUct4PtyupkunUXXX8KobzY6aiVYswMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n8iWIQMmyD1fgieNiTgRzgPjcZV0N1pEZE1DlNRRHausCIQC/FUROdVhcSv7jSTAM\nw+6rEfWIG3LVFlwpJcLEGNOYOQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdaZX0Y6JUV2uTUFXSmi/rO/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODBkMWM1Ni02NTRlLTQ1Y2MtOTUwYS0yYjg3N2YxNjQ0NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8js8B7b0dI11zc6zOUi4GUjwCyFI9K988FDVvVeS13twZ\nZbw3Ohv1ZF8y+5CGkghknD9snZ/bDqxX7yym0a7go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUct4PtyupkunUXXX8KobzY6ai\nVYswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ5p24YSKEOqGvVgu6vw8aMOnbPy/GPE/TP/tXoY5gqgCIQCI5+wlr+bZ\n0De35bloPy6Hv+cT3wHoMVsjEBmPXrBjgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAe1ZaOSlulVa2zwZ7TsvkYoHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2EyN2U1NTQtMTc0NC00M2MxLTlkNTQtMTQwYWQ2NDE4NWZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ2ZGIwNGI5\nLWNiNzItNGY3MC1hOWVhLWZhNjAxYmNjM2EyMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIYsPCG+qaQX8fsxBtQx6log1exhYdPMbk9z0v+Kp4Z718LBsvo29W9n\nIUZMyESq02naE4jCTajnE6YjTas4lm+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKIBpPrZ\ntiKX7xIsiBszBzTRM5VPMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBAKkpHuR268BJEHqGendo/b4c7CE4N4DEDgvXx\nXDPivwIhAOPV7nNsUi4Dpp1ubdGh2aDZR148PS88ymOk7emEELN4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1337", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1337` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAcuSLZsF2IXMyFcX0CALXSXgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlOWU0ZWJjLWU4YjAtNGIxOS05OTU2LTUyM2M0NzE2YzQ3NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzE4Yjc4YWQtYjdm\nMC00NDc1LWJlNDktOGMyYjU2MDdkNmUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfc6VoYdET14CTKRsnYT+3TCmZqnbyTcVaGbN2YHU7Sb87Gpai0V6VDM4DW1W\n8P7cozNdPQZpGB8iWBFg901rcKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjsS3nbanrNiHbTmoLgSI3/I85ZowHwYDVR0j\nBBgwFoAUY7uJj5x1CR/Z+aLamQZnZ1NnMEwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiALhSxx6QcmaYJh+J20+BQZyHDmsHJhgBE0qw+svzfQMAIgAr0p\nnEJoQXGvTcxpxVYU7SQF2hymUP5KcjavYexzxRU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAULCxbIiuMFx5aBNViZ/AoY4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTllNGViYy1lOGIwLTRiMTktOTk1Ni01MjNjNDcxNmM0NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzbJwEzaM71kERxsvo5TbLcnlmy9RQzARXGZjCwryusn3m\n8Gf92Z4MTIFfdWEUgTkb2Vhw62tWrV6r/a4TOis0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY7uJj5x1CR/Z+aLamQZnZ1Nn\nMEwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJlGh9MniXcsB59s8TrYqtpdph3AXk2hTHM9qUZCmdtcAiEAvDuR+5F3\n0hUNYwRc+X+aSczXY+feoJ9Pm0i0XAFAn7Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdfv3G+G8jqy7uLzt1pQ/cHGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzE4Yjc4YWQtYjdmMC00NDc1LWJlNDktOGMyYjU2MDdkNmUwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRlNmFhYTE4\nLThkNmMtNDM0NC04YTM2LTU0YTFiNGE4ZTUwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE1nEDcxyejSJo0batpRq0n8ZTkC/U1ooqBybuMg8y2l3UVAWeLU8WfV\nLTgc2BN1sOxQXgff11UW7mrg6Zl9DhCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI7Et522\np6zYh205qC4EiN/yPOWaMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBx8V5+2DYfD+ZWdbJ9zg3AQy+4pIe2e4kLW8C5\nCd7O8gIhALuh/3VBuq/rwUWvJLlubsZ0+FWZ6w/smZlA1UaY6/d3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1338", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1338` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAZXl7R+/z6zGKeLmkzD3AHpYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4NTRlNzk5LWUyZWEtNDk4My05MDMyLTEyYWIyMDIxNjc2ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY1NTNkOGEtMmVm\nOC00MTdkLWExYWMtMWY1MzgyNzc1N2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEK3TDwBsCWrOVdIwzvMYHNcrhWCNKW/9BqwEavV1GImbnGX/dQBPAfBaxjoZ\nvCCdRPI6/C7sbTzsdEaEMaqsk6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWhqE7oWPAeog8Yw1mvLgIk7Ve9QwHwYDVR0j\nBBgwFoAUe77HRvQvWyKfKY11LFJdzeX8ZIgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiAJJCWARUeGqvfF4cwAU+gAudglM2U0sbt/lCVeRrwkMwIgZAXc\nLvwcVxa5kijG2sniimuvy/VeWMEuOIaj21zMSm8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW/jTI5UfMEhGew2I3xmSe1gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODU0ZTc5OS1lMmVhLTQ5ODMtOTAzMi0xMmFiMjAyMTY3NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPOCRFX8vCBbH91fdcyOIvfRvYlZ4nnX2+0Qpb3nEMxn7Q\ngEOQzlqA6QLLeF4GCd1X1j1pOh6/KA3fwfajJN8Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe77HRvQvWyKfKY11LFJdzeX8\nZIgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIfdoQH5bWOyK67H5J+YRWKTCelB6BGsU813HdO5UUuNAiBEiJ5M/5bO\nf5WrBne+EeV9ZeRnzEio5wa96Sn0bHK8IA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASUh+3IEtQ86V0GzdLWc+c32MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY1NTNkOGEtMmVmOC00MTdkLWExYWMtMWY1MzgyNzc1N2ZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMzYjU2YjA4\nLWE5MDktNGI4Mi05ZWQ3LTlhOWI4NzVlYTExMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNO6T5pwXDYQfdKocEKhVf/NppoZnII0rnmWBfUlF1VSVtfhqqx6djii\nFtRI7Z87oIRyQwzjLiL+AmO9XLBRNJSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFoahO6F\njwHqIPGMNZry4CJO1XvUMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiADPbCyxD8ZYn9mDQnKzyVPkJH8NkwYUeHvADta\nztmcQAIhAOAQT0OuoKLqcaNLg1akVfi7/DUCnZWRQYqWGKZ13Gh6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1339", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1339` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAap4lImba7nJkOgzs6Bdbc+nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjYWMwYTFiLTU2YmEtNDRhZi04YzU4LThjODM0YmQwZGJlZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc0MDY0YjgtOTVm\nMC00NjRlLWI3ZDQtYTc2M2Q3OTY1YjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKHjU4MM5t7OEPnEX/r2std62dNgKW2orwtQzf7vdWirdiHOMNHCNAWljHhtv\n0Ga2iFHxZeJVAIuZirxLneIbEqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULIz9ygsOM1pA2uq+kJKnNkUp1RUwHwYDVR0j\nBBgwFoAUXcMr5WRN20HnN88BYQ6MVp9UhmMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA9FXO1r1J/Xn5\nWo8D/cWZaVQ6iQosOoEVkLgC3/FLUJMCIQDT5ygYOK7WCXrw+IpNAz4+C8NOeynJ\ntHNtZXHg1USFYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATWghJ4+YRiI0uMpGVLvl6SvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2FjMGExYi01NmJhLTQ0YWYtOGM1OC04YzgzNGJkMGRiZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6LN8ur3j7n6DW0MJlMRgAMTVvTtkYgeo5LQzX0Bca331I\nCpdKzpuchxykicHTP03HQcbNrqjlRQJecPk/gnm9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXcMr5WRN20HnN88BYQ6MVp9U\nhmMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMiBOo6o6bk7TAyyAoILVeZhK7jcx2hRu0ieBVDIvCVQAiEAp4Q+rzVi\n26nlPhlHLGtjGj2TaukkBnevp10i3ybx6yk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAXQaLjQ4q9nI4nqIge3BfmE4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc0MDY0YjgtOTVmMC00NjRlLWI3ZDQtYTc2M2Q3OTY1YjVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVjMjU2ZTQ4\nLWFiOWEtNDM3YS1hYmJhLTVjNGJiZTRkMzkzYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA/0kqeQpMqeopgFyBHXu8JlePLOWZcPTQpYd9zsjP/bKodijKz21C+K\neNhFS3I4BNimIYesRaRgmWBAJgQKOxOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCyM/coL\nDjNaQNrqvpCSpzZFKdUVMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAyZMGQX+HpY9IKHhI0hQcG102MaTxHbLnFUTyK\ncgW+HAIgRzpJVyul7QbTImVnqjXpn7EnCg5GsZnxRSJGnLvlrK4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1340", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1340` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAY+e79pEdya57lnEeyCEvucfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1N2EzMzZmLTAzN2MtNDc0NC1iOGI4LWE5NDRkOWE4YTYxYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAzZTU4MjYtODJh\nNy00OWY1LTkzNzctZTkzOWM2ZjExMWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2J5GpmgTPK0KmdqphmlMQo8ZOfzCr91kRbXN536P6O9ICvWypsgxeUSgbiqd\nofvgSL3wj7q3eJXls+wCPCc6U6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbNoQB7WH2ii2hgLDx7eDiT87//AwHwYDVR0j\nBBgwFoAUhWuERtiblQX231hOgNMdwB14TeAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCT+z0ezSfoyrOvQCoubcIxVBbqO2zknZhBSa8lRO0ECgIhAMWbMzKaPNfJ\nnnI7DA87KTGbxyvn8lK+R64fpJ3zhXKh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAalZn0y2SvYbkuUSHnAaUhgrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTdhMzM2Zi0wMzdjLTQ3NDQtYjhiOC1hOTQ0ZDlhOGE2MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbzb167g6dURpe3tHc5ktr1MXI74QlW2+tA8wjFnv5mERH\nnLYaZGBdpQL3QVhbXsq+Ke7spd/MFJNilOx4b/6yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhWuERtiblQX231hOgNMdwB14\nTeAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIRV9L2r+lE17AgDPsPz6lPvZK+13pkCZ+Y023lZU2NOAiBPfaNyd8h7\nK7Oipi3t8w2G5gGKU5Bg/TE1S24RPX+Swg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdw2LtpajlPlVcC6auNvZQHKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAzZTU4MjYtODJhNy00OWY1LTkzNzctZTkzOWM2ZjExMWEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM0MmEyODE4\nLTM1M2EtNDdkNS1hNzU2LTQ1NzViZmE3NzZlOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIr/exCjK9IoL2q3qVZIQQ5qUsxVyO1xjAK1PujR6/GWguOu2o85hm0x\nbxtfw4E6cao8SJqYpB5m8QrSIRPrErqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGzaEAe1\nh9ootoYCw8e3g4k/O//wMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAZBcxQOq3h5mz6f71cYaiuCYCAadgr7M5GzSDA\nGlQg3AIgPi2MtMHJDRK5iZRsdO5vcxoT9jtRF8WUMimZt1i0hFA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1341", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1341` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAW7ORzoWjAvDrh7cGVmhMFneMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MWQyYjFkLWY2NzMtNDU5MS1iMmUxLTA2ZTQ1YTlmMjRkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU3NTg2NjQtM2M5\nZC00OGMzLTg4NzItODk4NjRkYzZmNjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfzWeuGEZGhFd2fohIDXH0311CHMs1gi0ai4hT/ZmRgLe8Dtm9fJq1v58/7vw\nv70JC5j27qPEKAouczR13c2pWaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMpSKAr7z2uF12tedAwnhL1F/CKAwHwYDVR0j\nBBgwFoAUH/mWmVb9bqPW/gaQYpwx66C/jx8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDTHH6Cmd96xCqaxrgJBY0UoTpa5+DcQOqYHsgVmQlaDAiAHhwrCemh+NRbS\n96C5t4SKFliJGqa8SS68jYxgLIO+ZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASn+HX+Et+bfYmFavxkb6amWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDFkMmIxZC1mNjczLTQ1OTEtYjJlMS0wNmU0NWE5ZjI0ZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1EMkOU5fKz+2k7dHuOECBzKW3ZfAtqh89+SayXXg0pQe/\noerB/HdHinvlYYrr1JrAbaOz3VW/0Y1X6owPRq8to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH/mWmVb9bqPW/gaQYpwx66C/\njx8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSYHL++agDhjnDXRd4wa3Xrj4pehzOWWzaaHMNjxiDwYCIASlDd87gbsI\nDuFZ7wHQxhqv5WtqoAfdNw7uzF2487eL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAZHJj4o+gZCliO08Sx9wzfzjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU3NTg2NjQtM2M5ZC00OGMzLTg4NzItODk4NjRkYzZmNjM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY0NmM4Mjc2\nLTEyNjAtNGFiMS04Zjc2LTcyMDU1ZDgwZDQyNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGCXo5sp3AaszxuRZF6QEXMTX4QD0OKB7UlwG3AgodFJut/WVS/vXOVH\ndKGvTAjUfLQ07hIJkQ42T6/gRRGoJOajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDKUigK+\n89rhddrXnQMJ4S9RfwigMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA//1wEwVx9xTb6pwcOJ1eF08+V7nhwPq88w3V\nTqRRlnICIQDLGsyurYIrcIfRP3N55uKuxL6FoYsuvFFLKWgrLohISw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1342", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1342` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAfSrBs7GCdvJAiYadUP14auZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2NTA4ZWI3LWFiN2QtNDhiNS04MTk3LWM1NDQ2ZGY4OWQ2ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM5Yzc5NmItNzM5\nOC00N2RiLWE3N2EtNGM0ZGFiODE1ZDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3R5YxaZJ8ck3Y8nx3JnsOhjVIKLM3pBcluZgZQDW0K/1mD/80y/ukLlsudUx\nKWyMdxpcHbM6M4OV9bd+0u52sqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbXRZR/DUlC8wl9zsTIOPHOaAt6wwHwYDVR0j\nBBgwFoAUgDWrHgCZruPKNmhfoS5GMrE0QV0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAosaOm41tjsyll5eEVfVdvxZmHi5NEmO2CheVloleTRECIQD7ky+LlLb7\nCczn12guBkMsqc8EbhoKU11WHt1BhEXkdA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfiLnRuCvNaUSul7Uvk9JfZ9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjUwOGViNy1hYjdkLTQ4YjUtODE5Ny1jNTQ0NmRmODlkNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqBtiPgjm0lq12xs4pJqb9PrT/zOPkoDwErAlWofPl/2a0\nQFD8uMTM187YEW72LJbZECStsRYAELBxwpJaU8ZYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgDWrHgCZruPKNmhfoS5GMrE0\nQV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIkshK/D4fqEjfCKOdprhNyij2rqH9ba+B6sehv2i8SVAiAFAVPa1tvD\ndLS4HvTUQ/odAXjIQaS3VSGjD9PFm/Rwzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQwhN0mnj9ildIwFAcLznshdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM5Yzc5NmItNzM5OC00N2RiLWE3N2EtNGM0ZGFiODE1ZDhiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI4OGY2N2Ex\nLTcxOGQtNDVkYS04MGE2LTg1Njc3MjEwYjQ3ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNASHP9e8Ig7gUKT15EoOVYTGWJ6S4gnhNCu1vq9wRtS/Vzx0jY4YsRD\n0jBV+BnOZniPWCrtiM+HfDTl9UsyA5mjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG10WUfw\n1JQvMJfc7EyDjxzmgLesMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAlD7rjDhjEdNMIqA1ZJO1SQlNr0cku9MGgxj7T\nuyZtIgIhAJiWpRSBCMGSMkhQjJEvlEIB5226JipxlyYMbG39AHEU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1343", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1343` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAQhZ/4AkB8SgR1govVEh+ib6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZThhYWM0LTUyNDgtNGMwMS05YjlhLWVmOGRiMDE3OTQ0MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjYxZTk5YjQtYTcx\nZS00Y2JhLWIwMDUtNThlNWFhMzIyZTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX6eS7LDV5DjHJrSrMfzLGjeWDsHafIJGrYEjZ8jEsO+ud4olkdJdkxAxLWuD\nUQDvWTMSqKmVV3yZcCFZQtaJd6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAYFhPTP3uv6mSs+fbeaPn3fadVUwHwYDVR0j\nBBgwFoAUY+Y+XMhQnUFQKz6FTpqBUZvZgp0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAjhzlm2/Tcs2+IkxtB846PL9PEO6TBRlI9sdLxaw1\n92QCIQDzGmYcUTnTHFpOJ356kcrwttEG1I454Uxv4Q17zcVdpg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcAxwNlNNzlwARihIttCIY6CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmU4YWFjNC01MjQ4LTRjMDEtOWI5YS1lZjhkYjAxNzk0NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4zOma/ysqNOl1gQygHwtxR508ehNN0Pzc3IXKc3SbcL7/\nZTLPTPsQP9J67PRFgjOfuYAcKt6jyxOiqsVegnwio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY+Y+XMhQnUFQKz6FTpqBUZvZ\ngp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL8smP7d6JsIBLs+ZA76LxviMBVi66BvsOIzQb7OwLSVAiAYJ9XhFJQ3\nHIj4pWOZ4xhDNUL8fLJTQB7WpMhQK6sEMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbkJnvTpTMA7HGF7pQiK5/ynMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjYxZTk5YjQtYTcxZS00Y2JhLWIwMDUtNThlNWFhMzIyZTYyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRjOWRlY2Q4\nLTY0MzktNDk2Ni1iYmM1LWU0ZWQzMmI4OWU2ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN5x8BUmQOvr+6GlMOG5Q6K/dEMR5xMAtNrl/fqliI2SaGneLIh/nH9h\nK24NEmoe78ILaCTmCElEv+0BYK0iDtmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAGBYT0z\n97r+pkrPn23mj5932nVVMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAxrld8j3MenALZ0Ve7pAK9R8c2ylCpTbUqw0G0\nmnrSBQIhAO1qGS/IVu+CC/+GQ/iTx4ZWhPhOq0FKcgLULcUS+xk0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1344", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1344` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXHZ8icoDBEDnxxbYjNpg7zmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlMmNjN2MyLTdjOWEtNGI5Ni04NDYzLWJkY2Q3YWI4NTk1MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZiYzljNmUtMDQy\nYS00MjEyLWI1NTctMGUyZTEzY2E2ODRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2tmpgLPBqcgxX/x2zJTgEP5LZd0/TDP+xEmGZ3WuiioMB3LVu9OfVBf3XNj7\n+ZAjZYVpclrOM1B2yWtYg7+OMaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz14w9am0JbckGUMp/w+FO74SvYIwHwYDVR0j\nBBgwFoAUTq5MqabLD/Wofdsn29v8o3r6V9gwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAyVRa8DIL+yCQ0cwiNMYLEyQqWo3NIVxMR8BUlepj\n7xsCIBCGZqkEuiHsbaRXd0Apfe+h4VIKhBNqORsrEgaBhDLM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARy7um5I0CGdngSxNSmuB0oHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTJjYzdjMi03YzlhLTRiOTYtODQ2My1iZGNkN2FiODU5NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6zcfJp7n7cFHBQXDVUJ+nj48ME8YkRD2uZ/CCo9geWVkc\nexpPJdPIrMvZW7A3yI1ceYs6dqUY+0l1Qcr+7dJXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTq5MqabLD/Wofdsn29v8o3r6\nV9gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPFYYzUxyi35OdF89grwLPXUEGVZeITvcBqLmixNKh5iAiB5+f/kA8zj\nXpwjhBYZ0HW8LzvGW/LjBrn65Fol1vDjCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZCGvDc803nBBFny6Ts2BYgWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZiYzljNmUtMDQyYS00MjEyLWI1NTctMGUyZTEzY2E2ODRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYzMTg4MDZm\nLTY1MzItNDIzMS05NTE2LWEzM2JkZDIzODQ0NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP4BzrrmDrxWaliy9mp0+c/giHd0gx1nQc9IBDA7R5DsoQlSZv0esDIN\ngN9iWJdh1e1hMs4q42OPG5ckbDPf5+ejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM9eMPWp\ntCW3JBlDKf8PhTu+Er2CMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA9iIzseo6Lc91rp1mwTc/koT27rffOeP1RjQzz\n5B4MqQIgYuze7DAoKZ/Uy1h30mY7E9oXWqxebUBXSfG7BeRaDTY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1345", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1345` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAd1F1hFVawZv7SW7U9VMLnFEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwYWYzY2MxLTVlMTctNGRjZC1iOWYxLTIyOWI4YjFmOTFjMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTEyNjAwNWYtM2M2\nYy00ODhkLWEyYmItMzhhZDkzZDhkNjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqGp+XF45mcYgWx0urNMhXJgu3YGlUZsdXNdMpx/huWEkJ/ip8ojq/Qo+8tPS\noCCPO3t/yWeiy8wyjxJn1vAcHqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzDxZnSTyw1u4fSbeGvjsS50KwAgwHwYDVR0j\nBBgwFoAU8NuQLW7HQnXTXMzXpnpFN7KmuFIwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBCysCT0V9ef2NkUngRFlxrmrIuSY/hdn+fwfHjEpd+hwIhANfw\ngr0oeFO/5hQhlO29Mnfe7gVn0KYjgIxi7v2F0rIF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATeCMKnLgaXYzcU/cIKjqRu1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGFmM2NjMS01ZTE3LTRkY2QtYjlmMS0yMjliOGIxZjkxYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4fS5SNDCGWV5oMQzt81NDTlWajQDA5WeTNcbVYuRMJFQl\nIBFJJBQMAAOaXSW/4QbTZLY11TAuhwZzowcXmTDto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8NuQLW7HQnXTXMzXpnpFN7Km\nuFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAwMonbEInVWxujZffoWRSmpcAUIJsVt/KvSsGZ8DBP0CIAmzRZ9wQovt\nHLXoV+fhtkKdpB1Ojt/vVHISjk6ad1EL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZefCAFjcWEBnbH0U4SamolrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTEyNjAwNWYtM2M2Yy00ODhkLWEyYmItMzhhZDkzZDhkNjhjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDczNWE2MDZk\nLWI3ZDMtNGQ0Yi05ZTBiLTU5NjFlOWFhNTU1YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEAzFPqJN8T/GikqhBL0cVdL3pwYvO8rMYKyVEWDgwUkbdixnUIUeglw\nG+qmnXdOTTyStPTxLRR56aRXCiHNNQ6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMw8WZ0k\n8sNbuH0m3hr47EudCsAIMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAn1/OHnIpzrbIzXC/eIuD5EkEzBXRJiaADSNlp\nTzqA1gIgJsli/zrJvScXBM4HIrX+45m7KE4MzRDpECoLcK+CE/Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1346", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1346` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAXthoofKsfCUfDZzSsxSj46kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0NGVhOTI0LTA4NTUtNDY0Yy05NDZkLWZhYWMwMzIyMTcwOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBiNWJhMjAtMzk0\nNC00YjgyLTkyZDItOGU0YWEwZDJmNjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEg4Zd078yG7IX1WmEB3zaJYYduvX1KmMkWgYHvSrmFFiQI9zfRUFWu97Pi3l\nmTYr94AK4oIv56TUJRycMdy2FKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUspxgNEE9NVh8Z8Mth+3sj3cUPjkwHwYDVR0j\nBBgwFoAUwPVIrTIL+vPT32vrSituiqGdTOkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBqKPFZOM9c1cL6wpVNYDcbbrtdr993zbdT\n3XkPbEjuTAIgV1m31jXdxWcvKF9VwYkQp9cnMi0kOGkhe+h0bUTvZ4A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU4pLP6Kxq+lmCROPtBfLj4hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDRlYTkyNC0wODU1LTQ2NGMtOTQ2ZC1mYWFjMDMyMjE3MDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1ldcXUAbk8iZiDaS3qsNpoxxuWl3RA3oZfoQNLnkaWcWs\nWz10JAMaMDKWk54YYzbWzmzsvEu5Ch0VpuixHtANo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwPVIrTIL+vPT32vrSituiqGd\nTOkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVw2NFOM2mf+jk9cxh1/lsAHfiNg4SB1x9fJgTxGPKMwCIDLdFYOG2NTM\n+ZP4FyNv8P5Tp+OIJaDn5sbLu3jYS5uG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAcEDRC5svH1NTYVBuw8bm4CwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBiNWJhMjAtMzk0NC00YjgyLTkyZDItOGU0YWEwZDJmNjY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI0MDE0OGQ5\nLTQ3ODktNGIxMS1hNjEwLTNjYjQxYzVhZmY1MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM+qXD+BhnpZD4H/zSeFKATr5aEZ7fspd0smntJWv9ULNurJ9X441w3R\nDdIA57RId0pBFLNUTFfq3z4h7tMg1rGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLKcYDRB\nPTVYfGfDLYft7I93FD45MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA7xZ6E2FkF276rw0K87KseP5P3tBDQQhdq7R1\nWrfPO6QCIQDYSwGEmSurxjIgCNFFr/5aCvgSwLCqAU7WDmPmRSjDuw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1347", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1347` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAVsjtSfutDJJekq3aMeVdBTOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkNzU1NWUxLTdjOWMtNDYyMy1iYjNiLThkYTA1Mzc1YWVlZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWVlZGRlNDMtOWQ4\nMi00MGQ1LThiZTgtMzQyMzEwZWY0YmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8olQYpieoNbGfYjgDT2pSWr0mTo41aCdXpgwlwPrEw2txt5pugmkUab5nFUz\nluvjmrAkADHYm0IYj06j6U/xeqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnfd0ftJ7WFqC1Ib7K4hJgQuvGRwwHwYDVR0j\nBBgwFoAUoXE4unN8awvzXbUgxepq5/s4LN0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBmFI6aMP9ru2E6Gc5RpDxGK39a76Tiz6Gg\n7+HamlI4zQIgJPTLWHvf0reLViGWY2Piyiuzh2CURU/cyTJOSfvz3w8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdCCWM1DP2BV0Mqw1YRFicfnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDc1NTVlMS03YzljLTQ2MjMtYmIzYi04ZGEwNTM3NWFlZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATa/8UMIRkzDVHp0KSFlQS8HCI6DU5yvaDzk+QG7S4GfiTs\nDzFWw0yzGc9nGwbfjF3p+CLt06buGwuyAoBMuzZVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoXE4unN8awvzXbUgxepq5/s4\nLN0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPe+0XK5R9UOPJvSYrZexS26MuG0++/g75kTuHNhIqTiAiBHzf7MAoNa\nQOnczeEr577OEe6RWNd13VHR6NVnWv59xw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISARwlOQquUEglduYqpqj2j77mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWVlZGRlNDMtOWQ4Mi00MGQ1LThiZTgtMzQyMzEwZWY0YmU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJlZDAwNWFl\nLTdlNDUtNGQ4ZC1hOTNhLTkwOTBiMDljYzQxODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA/ZWnX0bmIhwXN90wuKM5swXu4PKThXRiZkXuPawGQideGsInfetuiH\nogZh01Q/xBnOcgYg7L26Ge54kFxKndijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ33dH7S\ne1hagtSG+yuISYELrxkcMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBiSvoLvmq5yUSjk8qnFIJ9pMx0abm9SzmhISsP\naQ0T6gIgPDVBgqCaBZRp4h1TWjAn5CfSgTMBWERFD3IIUUizKrY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1348", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1348` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAdFfeSpgztv7FT+KmW5ZMROrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NDMxMzE3LWQ1ZjMtNDA2MS04YzA2LWQ4NDI3ODQ2M2EzMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA2ZmRmMzctNjc2\nNi00OWU5LThkZTItZGJkMTliZDk5MGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEejc11MInAf8ht5fXwTK92m2qDysBzt1IeqAgQEdUdNdjy14Az3c/tzNM92cz\n+K5SoYsqoW+hPtWGFPBxaWj+ZqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwjOTrnq6NRfDD10QSTEuA7KNzukwHwYDVR0j\nBBgwFoAU65x5SOAQv+exHDQL8vFhDsoM4gAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiB5adQbQoP2X5hi\npRPtI/7zgFGVbReEEZE72e/+Bcy0DQIge1WuYHaHibzZnSqcKpbpZCxsNmxwYsrZ\nTgi7OwouBhM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASOteHZLC04r9aKjCFjc2J0uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTQzMTMxNy1kNWYzLTQwNjEtOGMwNi1kODQyNzg0NjNhMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6SL+6JdeNBPaPNBdzs/WdJmZQbDvbgHHkk5VhyefjU28P\nwKdJ1iiG+cH0fbpATqlJBdRUZrstMvZ1nSuCHANPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU65x5SOAQv+exHDQL8vFhDsoM\n4gAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDgLNeZ+HoaQk8b/fh9edlWKlrU5Quppv6jI2egkaG6YCIQCx9BhIpH6Q\nw1/Rnd7B66Kfjf09Ko0islJFMS07dcWlUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISActKcckFjAGv3vR/EXcVHhjqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA2ZmRmMzctNjc2Ni00OWU5LThkZTItZGJkMTliZDk5MGRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUxNzg1ZmRi\nLWE3OTQtNDM3NC05Y2U5LTU1OTIxNDc1NDYyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIEySOsTUq5kOXzAK5OwXbtJZ9BP38b+ILtgbkRi/k2DpTit8qN0ZNHb\nq6pCO1HD8ZiPuiUHv6gVOwVSu5M2sAyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMIzk656\nujUXww9dEEkxLgOyjc7pMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBEDNjCmnvV1YKh2NGGlyPfewpVJdaUySMVbFEn\nxuy6+AIgEJS0h3+re0TYSHV68S+QrgNtc/4UfxAYev7SKt6gMAs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1349", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1349` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdZjk2vU85Aezg1/bZ3jcAzVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1ZjJiNzM1LTJlYzQtNDMzYS1iYjRiLTA0OTgwOWQwNTkyMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2MwNGJlMWYtYTNl\nMy00NDhkLTgzMGYtODc1M2I0ZTdkNmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU7LE2/gtVnulO7Q9eVWVP+qvfC8HKsKpiYhzb/l7NrViZbCfA+2AIc1J6PYd\n0ZIfuOZQ/PreoA3aKBeKpLxu7aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1SPwKGzUipSRQlfaUs81CGO4ztcwHwYDVR0j\nBBgwFoAUIGwhZb2wR/nsPgCz4QzbfGLa2jgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCnRnHSZGJBQSdfbnRjAftFqW7OcGvgiVI1CK5zQeLCEgIgcwbtIeFfiikx\nb4f6mZX8MnXul0KjNpM9uwQUM18HTco=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAavBjjHkk96UQmmyop0OiHlTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWYyYjczNS0yZWM0LTQzM2EtYmI0Yi0wNDk4MDlkMDU5MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+sZDY7uNERAVPWVicl9HoiTljUKOitj/OthZAGBGA4+Uj\nu2k7IgcyaoyvPdQMEE9/jkrJREKMKMd+P2Zb9eEPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIGwhZb2wR/nsPgCz4QzbfGLa\n2jgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTu0jyV8m8Qfhp0pnevoJmqZtp/PwL9Om/cu22j+pAG8CIQD/gr3FnhNn\nFeaohubnd4Og9wl6pJNOuRdx8VqJn5L9MA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWyocWTfdS5pwRf6vB9TbMWBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2MwNGJlMWYtYTNlMy00NDhkLTgzMGYtODc1M2I0ZTdkNmI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhjZGUwNWFm\nLTM0MDItNDIxOS04ZmZkLTJhMjdiNWQ5Yjc0MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJOcoTyQ/E9rZjKmK0KpsDZcYCO0P8Yl81irxtbpZi6poV1Pyud3JPSK\n+9f70bItykFz7GAKtFCvDhvRtUYxwp2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNUj8Chs\n1IqUkUJX2lLPNQhjuM7XMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiABjL99wDDv1W2Uw0nljSMNQPu0w3OS2nWltlfp\n9Q7dBwIhAP/JigdW5pZWwMApMB04JghfXGyThoccvBWw1qXjG39m\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1350", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1350` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATzHvTz2UDVl70myRACZhPk+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1ZDlmOGFjLTY5NGEtNDA0Yi1iODBhLWI2NDM5Mzk0Yzg2NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJlOGUyMmUtZjMw\nZi00MjNhLWJjNmItMGNhMGNkMWUzYmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Hdphezbt6ZiTvzZwHUkNkng6oEJXO0T9oSDWXi/om/ltrVLzQ6ACecWpvZz\nRsteeTNdHqpmrev8wBnSd6aj8aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1uC2z/DWvBCWE9ug+Uyup1agJt0wHwYDVR0j\nBBgwFoAUV4JSGG8qRc4Ae+x0DiVBwtE/oyEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCLeM7rpOYZO27Z/43Il/fll/1qXxVzD9Baw0CcEgMISwIgTbwxT7P8MZ2G\nGVrUfTYoWw63eW+hgtyu+saiJUS6TTo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWMmOnvAyJbXutRSVtlrWy4eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNWQ5ZjhhYy02OTRhLTQwNGItYjgwYS1iNjQzOTM5NGM4NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFIVJDBlIzRrjgFILcMkS2cEOaSEz8pkWz2Xgc/ndCVUSQ\nEn/c7HURfD90Jt8bcMHruNMEzOLLM2Lnn0tSBNzLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV4JSGG8qRc4Ae+x0DiVBwtE/\noyEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEs65J+XyYeqOsR01AfJOv6Xx/32dBMJ5JErRAXZk8NUCIAgy9laUkmsQ\nG9f9++YdeILW8RH1nPHBvzRRKOCxXkTc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXyIbq99qm/QIxXoC963zyBnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJlOGUyMmUtZjMwZi00MjNhLWJjNmItMGNhMGNkMWUzYmQ1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU0ZGE0NDQy\nLTBlMmEtNGQzMy04ODAyLTI5N2IzMGJhN2NiZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKhdWniWVugQMFYNCuVrjgI5PooNjBc3ixXXDLqvl6KtClV+HxQ+Gyin\nDZq7BO9dMXKiVyBC3uobL/tE8HrUUn+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNbgts/w\n1rwQlhPboPlMrqdWoCbdMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAlNnaY5zOB/6rPTjNTqK2I6HPeEP0qKycJFbZ\nHjuL/7sCIQC9Y0LZg6yvcJ4u11IIxdFxRMLLt59VFj0I8Nf+wW37Pg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1351", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1351` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAdeQEDGwz+maKy126UE7Ti0RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwY2JmNjUzLTY4YTMtNDU0Ni1iMzMyLTJkN2VkN2I0YzdiZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmViMTY5ZmYtZTRk\nMC00NzFjLTk5ZmEtNjYxZDhiNTRkNDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVkd9/P/WQun38xznHNkR2SbmMWZz7ENOis9xdME3pmgBzphMLiTX5OtHYyhc\nth1bvZNhb3nzIUv+tIbfa1BXOqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpxCkKZs2qg3pQ+79GdG/ZxXwLOQwHwYDVR0j\nBBgwFoAU255EtvObiyNwF7DXlxdmn8kgT+owNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAnPQn4R1es5cHek5BuFGzIbgrjRpWkhebnbgRGOAAuQQCIQD1OH2ns4gp\n7Y88CznH+sK2t+Q+wEvoqtUNrXNLpDFlxw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeBZbWvOUkQtOXroaXKNYD7eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGNiZjY1My02OGEzLTQ1NDYtYjMzMi0yZDdlZDdiNGM3YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsOzXOL6kYtZ1Mhtn1kd6BMuoScaaiFAAk1w9RgxLB9OCV\nEPxEu5ijzqlo/3RJ2Bz/8lr6sFiefEQyhjTcWBCbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU255EtvObiyNwF7DXlxdmn8kg\nT+owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCtIiKRgLFdBKbAlV2aO+doalRyF5SStQGqdYpoIRxGwCIQCLhbJW0YLw\n88rUsSQM41AY23bCpcHocBKh/dcNqm16sg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAV+a93ydEHHwiPJV3fz0TgfHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmViMTY5ZmYtZTRkMC00NzFjLTk5ZmEtNjYxZDhiNTRkNDVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQyMjI3ZGY2\nLTg0NTgtNDhmMS05MDEzLWRkOWU5OWQ2YzI5MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC0Fb0sCRnPaMtKvqi1dcbvHvXAphKUYWGSF7G0/6k2HMYSCNIQAser8\nLtRii3ofmsWwxvwUQJ5VjQOEKb2MhDujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKcQpCmb\nNqoN6UPu/RnRv2cV8CzkMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiA/Eem6BlJj/dLc8LElaihq/XDd/HqkJII5mgEY\n0PuqLwIhAP2UPNS+eu69HhW2t6Em1xvJoMughJiPPuXof+HaHFMN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1352", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1352` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcqtRxMOrenFBOgFWDthzCOHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzZTM2M2Q5LTdiODItNGNhOC1hZGUxLWNhMTNkODBjNDZmZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhmOWZkOTAtMDc2\nMy00ZDYxLTkxOGItNTg2ZTZmNWFkNDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnPRt2t2ju1mZkzNLj8EbjQ9AOTbF6yjqGBWAOqKl/AHmWNELqOXUgx4DjVSb\noZj8fex/eiFTzXLlHue3R2QPC6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYl7VSqu8ZXX9VhpA8jIT+qiIZUQwHwYDVR0j\nBBgwFoAU4zt3Xf7e268zmTZaUCs6LCf1+RwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAECbnfqiWnxrTB/V5+FXUOyuVqOk56+NHMXkE0q4cn\nGQIhAIqtPyG8AOt7bkzwcNHemgm3DMb5vBx7RvjFa+B0/2/v\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU4XgeRMeqwJjkDPY3HYbr+kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2UzNjNkOS03YjgyLTRjYTgtYWRlMS1jYTEzZDgwYzQ2ZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDQIWlKk7AGUMn+U/uFpXzx0jkp4b8iYajLexRS8gzxJmX\n/BvVZl0b6turIgJ6gDkycuoHJX77yYPWSsfgjwn5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4zt3Xf7e268zmTZaUCs6LCf1\n+RwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcGttOKIWHMERYy3QlqIhHfNR6IolFY//YIFxFjk8hf4CIQCsJmgWBRGy\nIfZt9JPxZb/vHaJVCcKEiYGKAzZXEtKktQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASgzCwTND6ex5hlAUZYDCduCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhmOWZkOTAtMDc2My00ZDYxLTkxOGItNTg2ZTZmNWFkNDZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVjNGU2Nzky\nLTFlOTgtNDVmYS04NmZjLTIyMzA0ZGI3ZDJkNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJA7V09jjBCRxrX02+LG08EOF6avJ4WdZvvvYhH2HfpAMCqF5YPojPgs\nT8MEJsWOav8IV3xKCN3KIgiS74L8S5GjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGJe1Uqr\nvGV1/VYaQPIyE/qoiGVEMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAyf14k8rs6R4phygvck96IsEnJiEfCvmLy8Nr\nNuEJutECICET+cuY5Gu/3SdFLFNpCwnCpO2WNrEmCkRvSLx/h0bY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1353", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1353` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAbTqnt6bJCyxm8I+TO7wIM0CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3YzI3NzEwLTA2NzMtNGUxNS04NjMzLWY4YWYwODg2OWQxNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVhNDIyZDctMDI2\nYy00OTNhLWE4MmQtN2Y4ZTVjNDNlODY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiHJB//I9NAaJ9sfaLYDmPuCkYC8FJ/vUCWcq/hhY9BK7Tiyx8ic7tD229ISP\nvVSE5b30YPsFzyc00iyuEtV8mKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDErv1tixx9+kxBVUyIp70imMw78wHwYDVR0j\nBBgwFoAUM+85ThmfX06qaQU2gkBAGsk1P8MwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiADEeb81n2F9mhl7Vsi3FJV+UNFhICR0AuFoddaC9pH\nxAIgVHgEq/8259VxbLCTC05HISQZb65XZsXnaTCCV5jY2jM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASiW8fdf/F5vAfx1v0gtN7vsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2MyNzcxMC0wNjczLTRlMTUtODYzMy1mOGFmMDg4NjlkMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJBXYj5KT+I4n1RclfxlI1N1Dr6tsK6G74qPU6xyRHK6eC\nu+f2/UcC0N8RLR6Ltdu6ErhiBDPp8d3tcA3Ut7BMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM+85ThmfX06qaQU2gkBAGsk1\nP8MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEtd7eFVzkmqXugCcF+xYQoAzVm1ly3BCSnF8H2cigqQCIHaSUcvkhCYY\ns5NG4aH7E7ZG43698ZPaVPrDHec+Xi93\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAcyiANLbatq1VahwRHVk89XIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVhNDIyZDctMDI2Yy00OTNhLWE4MmQtN2Y4ZTVjNDNlODY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ2ZDY4Mjkx\nLTAyMTMtNDBjMi1iODUyLTdhYzUxMWY4NzQ5MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLNo8N9RrYP8Ld0gHc6UxQFGQT4E2eJYA1dirjDxqF+KVolkVsnOM0K7\nIo2KXCSJYoUmDQtLgPwDtIFjVwDYJCmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAxK79bY\nscffpMQVVMiKe9IpjMO/MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBiNNl23EXX454o+W/dfvFlSdKBu42R3IqaJANs\nNJgcpgIgPzUGodmpgjZTmOe9JKLR1IQ2i+xSh2Y1gVbyW2QNIQc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1354", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1354` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAUizdUiWLDMtcFR8Pe6fhAqDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3YmYzYzMxLTJmZTctNGUzMi1iNTQzLTIzZTY0N2IzMjkyZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ5NWFhZDktOWFh\nNC00NjAzLWExYzUtNDNmNzlmOTE0ZGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE53w6ZrmWUt2T7ic6p6eBxzUvEBI+HUYOT2g3XIzOEb3T0xQ8PMYW3sUOo10D\nHbRiCVlkZTk0C/OJDzW6MqrkbaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTQhtKgb4FwGP1F7dGBxejpZy2w0wHwYDVR0j\nBBgwFoAUmgsiwJtFEEnjG6uTB1y58zls0+0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAo51GTV0hOOeR2rTSFi7iOv1Q0xIMey/+tCqXhv+mix0CIG5D\nKU8+s0KdRCWPgDctEKuTGSgLBgiN8ZzBTUFQrClk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXhyIoZ1fB3utimJb227dnMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2JmM2MzMS0yZmU3LTRlMzItYjU0My0yM2U2NDdiMzI5MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0Kp7/Zf5G+QyzT0bzm8hRz4XXuGG53uILBLperx2OVPq2\n6QvpoNrtV2PIpWpKy31L7VzeYDN6VWZq5o13Kwgbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmgsiwJtFEEnjG6uTB1y58zls\n0+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJrKzA7ZU54NY5zgLVosv4XTrMzVbtgLYrcB3id8vcmkAiBL/8prD7/u\nQTxJu3hTzcfPM4Ci3u3XvD40TWweJ4qPUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbTqcZBjCYvR7Qg5PgQgy1kpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ5NWFhZDktOWFhNC00NjAzLWExYzUtNDNmNzlmOTE0ZGU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQyNjg4ZDk1\nLTFlOWItNDRhYy05MmQzLTQ2Y2MzODRhODc1ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLWFMYCmrseH+DtbfR44jQ56xeAjICS7P7WzbW7iXHby5pMYOs7/JKTJ\nd4WeVlFgKNwqNOC5T4ZXZ9nAScNU7PajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE0IbSoG\n+BcBj9Re3RgcXo6WctsNMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA+T6cr7CeYS7QLbJdPykZbO+2+BE3yIqasruY\nrmLriooCIDzTZLNpkPwn7vi91eADcyvzI/bfCuYfkZ3HI2KUv+S2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1355", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1355` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZAkHD7QQ8+d7UFIfJDxk0X7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzY2UxMzJlLWExY2EtNDg1Zi04M2RhLTI3ZGE5Y2NmMWYzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg4MjBkMjgtMzM3\nNi00ZTI4LThmODMtZDA2OTE5NmI5OGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUSe5kNiJ3InUv+2+3XfCMT5zLlu91fLshKUkWHQ7oNBLDEUtE36Wuqmklq+H\nlqkBBWv61tzmpbiTnfAo7qtyGqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM5Q0mwK93agQuAR3tTKZ/GY0FXcwHwYDVR0j\nBBgwFoAUjjFaHiFC5V97mGXvewKOUJ6oqjQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA0MbpwlneAgFIieOGl69a2YkrQDVpTcI5\nq2sHrKewpXsCIHPTQYlPUlTYUH8YLilRtwk59nXT/zqVFtoCHPOE5eT8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXH86vhUnf9ZnMUJXQEXqNdxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2NlMTMyZS1hMWNhLTQ4NWYtODNkYS0yN2RhOWNjZjFmM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJ9pvs79RW/neBxpkpEAOTSf/oXI3tHfNAD+JzSG5zhVlu\nsuAHy2r2k9FMbrLiCHBMZYWL/KkASsxWrjHqI6QPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjjFaHiFC5V97mGXvewKOUJ6o\nqjQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIK0sTjveaVT9g7dB/w09PgpEs17ovhPPxRWr5AfIQFcCIFkRQrqO0Eki\nJxPEDvvzhGwYjZ/P8KiBNylPEwq+d7ys\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISARtgdpsuGFxIkY1dB5uvOQ94MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg4MjBkMjgtMzM3Ni00ZTI4LThmODMtZDA2OTE5NmI5OGRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI4ZmQ0NGNi\nLWVhMzEtNDQ4Ny1iMzJlLTBiNDhiYTg4NTA5YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBjpeEhuMPeCw63r6w8V/DpQ0p4xj1zE9n+BsH02qMVMpshnmJl87kSW\nrtALbZ0PiWD4smRNz1I/xz4R3HH5MZWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDOUNJsC\nvd2oELgEd7UymfxmNBV3MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAo0eOjfLIrlbeyqdJ+Kp+4Rqeeq/6R6KaAqZ7\nO/mnB20CIQDb6RT41sqOIqTf7oUs3OemEbGGN3fYje50d52nMzfWGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1356", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1356` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAUezoQdDgp2GFSMMEQClfsBSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwOWM5MDFjLTQwZDEtNGRkMy05NzVlLTlmNDk2ZTYyOTM3YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhiMTg3M2YtOTMx\nZS00ZmVlLTgxY2YtNGMzNjI2MjIzMjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/cW4RZtSrgKDeddbFNZ59Fi6JTPJ0Nxb4B37IjJu3Cq1C9LOjNm72E3KPzep\ncDlmlp6wNTEdX1bYfyL3OZTKBqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+JtHFOPUpM3zg0/FIkKuiQkRClwwHwYDVR0j\nBBgwFoAUDuqr5XHrD55B3HGVYkrc1+Q7hBIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAsRYzIMQTGMkPUr078GzlSlQxvo2hXLsv\nXTNb34tRIOICIQCBJsKZn4Lp1qfK9wEFTEdW2XKp2FN9trgm+B8VlgBOxw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYpySzYMV4KCwjJANWmVi0KEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDljOTAxYy00MGQxLTRkZDMtOTc1ZS05ZjQ5NmU2MjkzN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkgKcrkk6gCtm3RekD0MmVtDXIOjkwjiluqjniVocE+VGn\nUbdJo7MccgmZuMDB76z6veqJkW6siwjXJ6cobGUro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDuqr5XHrD55B3HGVYkrc1+Q7\nhBIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIH/8myRZNcVwvkqYFiTSApnDFDDz46GzUQC16/12u+5AiBUcYOyGVd7\nOQt/n7YoJu7W5GKd8X5KVLaK5fxc03ZEXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAUSV3SXtckQqk0dDLCXtjjUpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhiMTg3M2YtOTMxZS00ZmVlLTgxY2YtNGMzNjI2MjIzMjY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIxODZhODFl\nLTVjNzYtNDc1Yy04ZjZjLWZkOGUwZDU1YjE5NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABATTulYX0fqxBXaqdtKfUO8WrctK/GbEHUP8Lv9pVXR/wW48OJ57sRqo\nbVNSNaOMU3nzJ3mx9Bk+xbFAseM196ijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPibRxTj\n1KTN84NPxSJCrokJEQpcMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAtIt1nrqOSjqwqCl/IA1bqp20Z3tToH2/TtV3\n60UgRxkCIQCqHfRcDv5GTlECkKHq6bKTAntBrG96+X3/azDD80Xmpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1357", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1357` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYsQ20uKUGNJVOS1AAG/S/L5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExM2Q4ZTViLTBlMTktNDc2Ny05MTMxLTM5NmVkMmFmMjZkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUxZWJjMTUtNTg5\nZC00YTk3LTgzNGYtYmZmY2U1MTVlMzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwcUS9Puf1QGXpY2QiZgZP+AP2wHkH1hKla2WJW2irg1027kJWN6VKN9IpfqB\ntJMJbdaUZAg095OsI+hmYakrrKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK9tkLxaI7Jh75ZDwlnHeCFFL1mQwHwYDVR0j\nBBgwFoAU33tLOWFmxTcIEYiQt6092bNMzdEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCL1w/h+TmEGIUyVyJFrSeYZ3Pw\ni/y0PtsZ6bbagaA48wIgWWZQLAS4ejV9yCBy6sIFvsazPOn7xW7tL7Y04GIJbCU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZnXc35VqXvV56egVqySU8mZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTNkOGU1Yi0wZTE5LTQ3NjctOTEzMS0zOTZlZDJhZjI2ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlBO1JHYRZnVEXhc5b+z2TWJiPuzmqxbYUeWfTuYvx21fb\nWsbH7MGjpdbcFQf+bt1bjpBh76pxMCvkunHsq/REo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU33tLOWFmxTcIEYiQt6092bNM\nzdEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOckDQEMppLoWGY6X6C+WKpKVtPHilWhmZaHDvhkZTOwAiBq/waFs40p\nhmdm3+WcP1Z+QCuVQuKmb8ikn0ZdJS6OZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAWYnNmGWCNNL2QoY97Lk9mB1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUxZWJjMTUtNTg5ZC00YTk3LTgzNGYtYmZmY2U1MTVlMzFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUyNzdlZGJi\nLWQyODUtNGJhMi1hMDcwLWFlZTg1YmVmZGUwODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOkLJJ39CYtqZuomvdWjZuxe95ELE/9bsCye7HY1Dj3VwV4urgJ4sNsb\nuZMVneCvyj3AYUjlmAsBMZxWK1Qod8ejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCvbZC8W\niOyYe+WQ8JZx3ghRS9ZkMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiB+y9KYUoaemhmFDYCVdtKb6fNxexE/91PoOJKt\nPPexAwIgbsDePV6+asfcZIbZ0rH1UZu+lK1RBLbZFGN8asaqjl4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1358", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1358` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAYkYVaDcF5LU8nVRgzjbFd1ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNjA2MWUwLTI3ZGItNGVmYy05MGZjLTM3OGIxOGM2NzAxNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ3OTk1YzQtMWMy\nZi00MDE3LTkzNTAtNWNkOTY4Yjk3OTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpSPARYtjHdeHJQfItUP7kgSVGTWdHM65fxnwFqVWBWqVfvSk3CP350nOWrPM\nx1oEImjlHbPEOPeYPjubsVWubaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCepNpsHH8ktQ5n0TUA9rfF0JjB0wHwYDVR0j\nBBgwFoAUK0yTAx16zrL3T5FgZnQapJfiXOgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJHjmNFw\n5SfknrvuC72TbglN5sa5IpqwV1DJxCJProasAiBpPsKt77Bm+cI1yuUM8n+gXWmt\nT1NSkKNGg17gWMQL/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARV4XMjtY+vAKG3MyuLrsdz5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzYwNjFlMC0yN2RiLTRlZmMtOTBmYy0zNzhiMThjNjcwMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOOfntu1s088I726oGCzRkWhoI13+6mv6cLgtVRQRDN9lC\nONEo/7qj82TVOmqvmsAIf2JVuTz+PfiJfaFu3KFDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK0yTAx16zrL3T5FgZnQapJfi\nXOgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPwY06Pc7XKS2TncBA91F0t2I+pXAN4v9CBngYe4h9PmAiAU+yECWP2i\nW+wfotwWQDKKG08YhLfOFcAsH9Bu4gLWmA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAY5WJu1ieeB7BFAfC7wTjQFaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ3OTk1YzQtMWMyZi00MDE3LTkzNTAtNWNkOTY4Yjk3OTZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ0MWU4ZWVh\nLTFlYzMtNGJhNS1hODcwLTY0ZGE5NjVjMjI0ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAG5nqRlfVTe28cbmKRdLssAeO9UYiM2Nd5LB784E2QnTMP9aVFOL7nr\nt9g1qV+pBco2LGEqOEoAMrj7c1hVPPSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAnqTabB\nx/JLUOZ9E1APa3xdCYwdMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiB2pGL4iGdGdnCOp2DcSBlN3mEIDZSpsvC2mURo\nWtJYJQIgYgVirk20yIJh11GTnSTT+q5Bszfds9hSEOvfzH0bOIE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1359", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1359` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAZSzfYZUDJI8hBF4C1gyj6ilMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3YjEyNTUwLTI4ZTgtNDM0ZC05YTE0LTk1MDcwZDU5ODc1YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWViM2RlZjktMmJm\nMC00YWMwLTg5MWUtNTM3NmVmNjJlZTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE52uvHsVrWW9HarfiT2iLpB5+tIfzZzYE+jpj4qmdZUNBXoc58244RY3Dyfd1\n2iKPDubmPV2BrOeUyUZFliGmJ6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0ZCV32DRvxmurQUNSzBMx0sFEeEwHwYDVR0j\nBBgwFoAU3oKzCchh12yf7ocjyGzQo+rq6tcwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgUrLSxRkK\nWR+DjtUOWAQQM3BgshN9zZ8WW8ZN1pxEyeoCIGeB6U68w1nhw8W7IodRSZvwujAJ\nYMPW3LtGyoFNn1/J\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb9yyUGOmScgXookzBP+a5GBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nN2IxMjU1MC0yOGU4LTQzNGQtOWExNC05NTA3MGQ1OTg3NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiaHZpGflZS1t+WESSvcKr04tmLOaWfBjPCqooCwR9tjrS\nSHobKzKrNjFW2gvpVwN4K5XYlRSO4Hp1CY9HnsD9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3oKzCchh12yf7ocjyGzQo+rq\n6tcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHeXhofp7hjhqGk4IY+f5cqoKX7OaYZUjmQajK5B8mYwCIQCC/5AanewS\nHxf46M0/dZSjv6I1kqYb3k5mjxj+GmrX2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXDA7z77IsmX/B0KzcAUkNHNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWViM2RlZjktMmJmMC00YWMwLTg5MWUtNTM3NmVmNjJlZTUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc1NzhmMGJh\nLTk3NjctNDgzMC05NWE3LWE0ZDY2N2ZhMmZmMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBAvhlnVzl5EsJoHNfhoAWs/mvfnUce9R5yISJ+kflwLckZFNhAya6Xf\nCJXF+autFFWUG7p/s4YZbIsTBhmOIx+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNGQld9g\n0b8Zrq0FDUswTMdLBRHhMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA1dGa1z1KjrAqk7cIcMFDsMQAd7zSqbcTc8cw\nZ5dccCsCIQDhdOsrdk/i1jrKvDU7D9Sumy5C1tju3RdB1SCj3xuD/A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1360", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1360` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISASp0iqQBWVhmoaZbjZ6bT77rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMDJhYjFmLTAzNDUtNGE1YS04ZDAwLWY4NzczYjQwM2VlODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU5MmExYTMtOWQ0\nNS00OTViLTkyZWUtZTI3OGM1YjE5Zjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgG0lmNCVsGvjT6BJEhhAEdgC2xO0bG1hNBVoYmTHHMpnNvDmIG+sVLM/iWUL\n9M8SEDmABXbs2DWEVMECQwiZ8KOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWOZHdCO46oG+h+SbJUaw0htwseswHwYDVR0j\nBBgwFoAU6REjfxBen6bep6/U5h7Vk3sGXrUwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDL+VcH1\nBRm6oyIDDBrNblLynAVEsBmB4BJDcoQQkfSZAiBLd1/BsSvpNzm1i339thGmkUka\nkXu63EhOS7RVAHBgVg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd33odM/axBxQkRjCzPwXFB/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTAyYWIxZi0wMzQ1LTRhNWEtOGQwMC1mODc3M2I0MDNlZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAx6Ew4pblcmNGMDVWeeImjGEB1LX0M2aL+aQt7ZAalnWH\nthbf7NH+5J3VwLAjHfICNGQpvT74XnP6V2cNZkP+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6REjfxBen6bep6/U5h7Vk3sG\nXrUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbIdJWceOXlfLZnAVyWSPXv2+kyNS8SpOf0i+xBWcl9cCIFyR8YHUtzNW\n84awUjQ/dLroS+ruh9clR5pPUCEwMumt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARzTjAX5kt8iBSV7fXKlkck3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU5MmExYTMtOWQ0NS00OTViLTkyZWUtZTI3OGM1YjE5Zjc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZlMDAyOTY1\nLTE5MGYtNDkwYy04NTcyLWRjZDM3YjZkMDVkNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFit7ww5RxRGYMyKjaZ4DsIu3xm97y+7e3Beqmeg1ZJ863ff3hkc/JJf\nM01EQU1R+4pT6hMOpMw46C78zZE3H4ejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFjmR3Qj\nuOqBvofkmyVGsNIbcLHrMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBwvePXpVwybyFZKiL19q0PDdl6yKtcdpjHqEuC\n36wLZgIhAKqnZc6fxClia62/E8/ZgC0ZCasGTi+gTgsxU0sGXUw2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1361", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1361` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARyzg3FUPyKrogL1kkRqSRWIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiYTUzNjExLTc0ODctNDRkMy1hYzI1LTNmYjc5NDI2ZWRmYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ0ZTQ0OTctZGY3\nYS00Y2RhLWJmNjMtNTY0OGY1MTdkODA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7SLt6i+ucH8x71DOf+hZmQyEyXo9MUBSNVOTmWK4LuXrLAlIN/wazzIN67F1\nf17XY24EOIlN435qlOrDSm8qh6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULZVMPXxcaDnSGxiZKVYc1b8m9H4wHwYDVR0j\nBBgwFoAUPak26zCmo1/dcuUwvlKJDajSowUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCAsp/rF9LdCTDYnYZ7Xy2A7BhkHItdfFo0iW31LzN7ZgIgQkt0x0LG\nJe3nngZL419YqWMkBftBVtTOzxkvDycpmhQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQhQuqeIMUhqjQbkN1CJpWbrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmE1MzYxMS03NDg3LTQ0ZDMtYWMyNS0zZmI3OTQyNmVkZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQRNepoBgqysUTGbuvY6nM6zVleX/ui5paeqJeNXm5QHZ/\nTf8EZRp2834Qg1Vjx9xKOq39BotW64jzwSZZ3BfTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPak26zCmo1/dcuUwvlKJDajS\nowUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIF4avxrnDxdrQ4igAxPMSUy/G5WHHSy1WkmaoUOXuLjAiB6G9tLz4Sc\ngRjMv82o168aYuv0FX+8jWGBFvHvKeZMLw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAS379C6cHddKssQrPePMZFeEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ0ZTQ0OTctZGY3YS00Y2RhLWJmNjMtNTY0OGY1MTdkODA2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE2ZDNjYWQ5\nLTgyYWQtNDdiZS1iOGY1LWQzYzhiZTY4OWY4MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLdq9c0ZIVsPJmi35ZewGteS4ksJY2KZTkv9ibthAzIIhglqpjVU9Wlj\nS9s+Zt6nIb5t7Fy8ySn9XyVCgRm9lnajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC2VTD18\nXGg50hsYmSlWHNW/JvR+MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAhtVmAnKscrLvAYTwzakbNzKmu+nILDr6Py1S5\nO3zLYwIgGx0CG8s5e0WE84SfyCTJVZ92rBDyEtOKyuSQNW3nKP0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1362", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1362` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUTpqrXJCURjUzcyuougojptMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2MWM2YzRmLWI2YTctNDI4MC1iZWU0LTQ2ZTk1YWZjNDdlNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY0ZmNiYTEtYjdl\nYy00ZWZhLThjNDUtZjA5NmFlZmNjYzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuYwDjTdGf+NLKVKBVgKTahsg5Hpvp6WzvYvxRo10eYvCBChJdVzJNqDaVvjO\n+MVl3cXdTuDWXP2+RmKyO/dHvKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWihnYWeRdHnKDAl1U70dRMMKxUUwHwYDVR0j\nBBgwFoAUaMSG4kyKAJPL/U/tyvo+WL9/nnUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCpBj7dTb8MhD5IFmEV6G3+j/l87Cuh1RrKbbUsnUVy2QIgCLhYIjJG\nFVfnlhlvC9zTE9Yg0C1mURErP7u+TKjhRug=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ1JWzmdRnrweSzeX4geTgAcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjFjNmM0Zi1iNmE3LTQyODAtYmVlNC00NmU5NWFmYzQ3ZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1FH3mRMB8KpX3HX5jfsK6nTlLzx0U/RcLuyu0yaI0nLTi\nAfwR4OqwAdK7xmzE0wgglGDpnGCTwx8Jis7imZ04o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaMSG4kyKAJPL/U/tyvo+WL9/\nnnUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ2RkSM+5qcH7QFgw8RRmLVRbt8ol8BDoZ+vbFITNjHkAiEAsAwe9IkD\nu9tsO0h8dwV31MHstwf/zzttF0h58kcK7BU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAQEXzwYF5L0h7S2ngYKBa3WjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY0ZmNiYTEtYjdlYy00ZWZhLThjNDUtZjA5NmFlZmNjYzc4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEzMjlmYzVk\nLWU3M2MtNDU5ZC1hY2U3LTg3ZjYxMTgzMGU2NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAM12fQzKflbIrYOc6f05S+u0PhalDbPNV47Y9GfFbF5OT13uU95rEPl\nkI47PijcLz3GPtxr4jW9J9S7sNnGTW6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFooZ2Fn\nkXR5ygwJdVO9HUTDCsVFMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAhzTH76g/nwZoGuGnS+kjJKTZ9awG/DJmPT6v\noW94J7UCIQDjN1qOf6aZt9rrgysmwSRTX86+hRraX98/ljaUIoYLMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1363", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1363` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAe7I2X6qfV69UucwhNaceGr7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxNzliZjFjLTEyMDYtNDAxMS1hZDRlLTJjNDBkMGE4MDIzYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFlZGNhYzctYjM4\nZS00OGVjLTk3YWUtNGQ3YjdlNTQ5ODZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/ddf6/91UBtEeVvQg84z2XYeWZX6zWP0ICwF7wCg0dBSXrBIGKGPDUUoDp75\nQE3QFOQnthlI0af0+Q6WAyD286OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL8A93E4uLCznK/estbeXLramBUMwHwYDVR0j\nBBgwFoAUJ1pgvAkiRpZioFswFSsmlca6UrEwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIB9DIcVOIcqELTA4vM3q9bJCA4bI2tO/Cq1a3A8JS4SFAiEAixEBZSjaCzyM7UHC\nUcYmgeRayXuHjH51nX5ZSOnlZ7g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZIPuKMg/7UC6fX+0JwblZAzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTc5YmYxYy0xMjA2LTQwMTEtYWQ0ZS0yYzQwZDBhODAyM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScbfjTApF/aX+PkOujYG0PnhS13Awn8xVj1mvhpP2Zrbel\nwRGhsXhCgwAhIbyVsZX1VCwfnp9VKghbFaALWAHxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ1pgvAkiRpZioFswFSsmlca6\nUrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEJgPVefyFKTZic20RmYdFIJEgqhRkN8re80DeCWZ/Y4CIQCcdaksdh17\n4o6KogG6azQFfbjKhXASIQz/avbEmLbRVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAeFBdBGIxHrfrERffpNBqXVLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFlZGNhYzctYjM4ZS00OGVjLTk3YWUtNGQ3YjdlNTQ5ODZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkxMmYwMzc2\nLWE4MmYtNGY1NC05MDAzLWI1NmIyN2ViYjg2MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI0jRG/oCV7EMgQNEkvIbXhuXiCaelT6YHKzuhtLDTQ3PD0h5ubC2t/c\nSB/n4wBjuFatK0KC6LmU5rIiAaJrvtqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC/APdxO\nLiws5yv3rLW3ly62pgVDMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAw/kp5KOohVLxvGv3+8z3iDnH7nu4nnPDgTDxZ\n0KRNvwIgZZU5nnjVYI0fXquYip3ME/eNtdTXmjtuQkXw5o411Nw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1364", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1364` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAXjCMnLPZdoeCl1zcsp+A7QUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4NGZiMjIwLTlhYWItNDRlNy1hMjEwLWM1OTZiZDJiOTJjMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE3NmJhYWQtNWE5\nZS00OWUwLWE1NjEtNmJmYWRlYTNmMzVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPCT/QtnP6Z+iQMQcgqiyoXdLbpeSzdsP/jj4tQyF0LF3tcKLtfBR2Z6Stt/S\nlYFMpp+XTBtbINiZGzz5sMHIDaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8A/djuFm73gBB5IQIzDYkT8tpTIwHwYDVR0j\nBBgwFoAUKdUVGTch2h9YwVy5v53l3wievlcwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIH9+axYRUvYiPS5QTKYj2Tfr4N8tw+9mXf4LgLjQQGb7AiAN\nZUkdHItdVeDUiW1UXdwFaH/+W4iaeb9q+3dNTc3brw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR4qf24UtDfpbf+0GE3h4ldpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODRmYjIyMC05YWFiLTQ0ZTctYTIxMC1jNTk2YmQyYjkyYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATi0Q18HdXhmY/dwvG0dqtSzEtdYkSqMTDbL2TCYlxhxQ5O\nYdrjbujYyK4yuQLyyBKyQqrwwfW9s1bTzeRfDC/vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKdUVGTch2h9YwVy5v53l3wie\nvlcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFmPlRrhNXj9jSoOq7WHNcts69PII3kzA9vT6d/kUK7ACIQDacEsant3c\nBybZYJDffdcK4CHnMAgbGuwk7ps5wYJZtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAd0RFseOt2D63dOhPMPbqIplMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE3NmJhYWQtNWE5ZS00OWUwLWE1NjEtNmJmYWRlYTNmMzVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ4M2Y1YjYz\nLThjYWItNGMwYy1hYWZlLWNjODcwYmU3MzM1ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCWi/gZOD5KG5q6xFEU9RcFfsiJVy8oqYAREQyALWMiauf7P15Uamazf\nV56G3DJmZ97r2OYyc47MRft2T8H6K9qjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPAP3Y7h\nZu94AQeSECMw2JE/LaUyMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAk07BcrB6PvO4JG5UiQQkm2TN/NXVAsS4cnEs\n+mAY7BQCIQDJf/aqEHTRQyjyDsG8lQkl40DfA/T25pIraATecR5WcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1365", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1365` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYbu3y4VcwCyQtwnn0/JKnFSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYWZlODBiLTUwMTYtNDliZi1iZWUzLTkwYmZjMDZlNjk3MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ1ZmUyZTgtODZh\nMi00MDNmLTkzOWQtZWMyMDVmZDc3MGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOxRTvVZsCftXel2lfjIjM3I4Q31e8U92V2pzV7cVFaw3XESoogAC8a9ZCC4P\nlLMtkCNpKcOzS9GB5SUlFNy8KKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj/VU0fDBXjMBLX3ZZfFUG3+X7+UwHwYDVR0j\nBBgwFoAUHfpcj3MApRnvchttfvr/2y/adsswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCQhUehiEKA8yM7v36lUUBYOz/v5W0jw1q1EbxqbOcC5gIg\nPpg8jElROUxOew56+Ymp95cVxaSfTwXHxk5v9lx7qZ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdUDDriPZmBBr64pQfYDI3GRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWFmZTgwYi01MDE2LTQ5YmYtYmVlMy05MGJmYzA2ZTY5NzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASo8pnkIc++EicFPv0E7wYHrMMy7ICakzk4CIyNtTMGVEzH\nu2hRdk2KZogZeQY6QAyyEMwmCNRMyYPAMUs9Zehmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHfpcj3MApRnvchttfvr/2y/a\ndsswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYSoCP9F2BESChQC66WjdrzyWJHwbv8A2O2j2omhDdTACIQCoUSlKK17l\nZttxeNoU47gW5W/nnKMbvdQFXwpldUgSMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUINKrhqsUCyacDXaVOLJdYaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ1ZmUyZTgtODZhMi00MDNmLTkzOWQtZWMyMDVmZDc3MGNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGViY2JjODZk\nLTEwNGItNGM2NS05ZDZmLWU2N2RmM2IxMzIyZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEmk+zVbV0Ij0M+6QKtyZoJ/UfI4gn6cwPcThg1qKaTJvcqQkWPCAfGN\nOwWlhkXPnryOZ3+GfEoCFsobALKZvIGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI/1VNHw\nwV4zAS192WXxVBt/l+/lMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA7Fz3CcS2ABwuTMHAGQ5D5fzq/zD3hQs1jDF7\nfeWgluQCICQSM03+N1hYTWonDemKEouZAvm4xN6LRbayUTDXNxy3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1366", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1366` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAavojADZqwfqg8hji4L8NDfuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0OWExMzIxLWQ5MDYtNDEwOC1hN2FkLWQyY2JkOGVhNTQzMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDZlMDkwMDktNWNi\nNy00MTA5LWFlYzctYmJlM2FmNTIzZDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX9wjCxpFZkF5A/9CpAabMireAGaqQWb1I8F4CfzXBncHh/xZNkzDp1l8c5a/\nRco9PKDYixtPb1Ms/v1voC732qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT4Jk6jjqab7EFexzfwFyLnfWu2cwHwYDVR0j\nBBgwFoAUkZpVJcOtvDERUZEBu/y+pg5PpBQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDcoJr+LNZQ\nrmlHe9Wj7vZZMfFrUdhTmZ6Lf1Hcwr6YngIgfY6mlNs6BwIcPCYxPHZ+KjOjyP1U\nlt92NlEQOM7ATxo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdsHDD6M1GutaWtHlr6sGLNBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDlhMTMyMS1kOTA2LTQxMDgtYTdhZC1kMmNiZDhlYTU0MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaenLgipXtqn0kOi6BzYsktwdD5rQeZ0hHNur4tR6d68ZT\nuz7Wu9T33mInAKxoqVbjgjGZhhUVHRL7U8AoUA9Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkZpVJcOtvDERUZEBu/y+pg5P\npBQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeaJkUctTbd+VNEawib3Rw67SD1wB2tWRvN2/tGQCyZ8CIQCroVIFNbAB\nUYE08ozZIDYr8mmybLqetqYwqlswLBO9Kw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUTkhRmnIHbgN9RTRxj9mGbEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDZlMDkwMDktNWNiNy00MTA5LWFlYzctYmJlM2FmNTIzZDA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMzNTAzMDNk\nLWY5YmQtNDg0NS05ZWNjLTU0ODRkYWFiZGIwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFyDW0OWOZQ0dj1BWJ8NYceJfh9NksC5K3rDlVw5tsWYu47duuDfd6ij\n0u2PYFB+6nnNVcopVM0g1Sa5RyiP4NOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE+CZOo4\n6mm+xBXsc38Bci531rtnMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA9ThfozKEuOTDmuSoZF9RN3zZ7p8ShA02mOOJ\ngRcxmEsCIDZL/ZC21dM+4VgaH0gSvJ8VhBmUTUrx52sfFdlJ1stN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1367", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1367` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAWWexsB6xtzCcfAJq0Cl4HntMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NmZmZDFkLWQwNzMtNDJjMy1iMTI5LWY1NTA0YzZjOTZlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRlZGRhMDEtM2Rh\nZC00OGY4LWE2YzAtYzA1NWI2ZWQ3OGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmp5O0l0LaLArBUgjfhlzIUNBM44vvL60UABUX/JlbA0cRT7Qo7BhWUE6IkVA\n8QDW+AWMT+sxB3imngvPCEA4FKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdvO3nX/j7FcTzGww6SWY4IcqeLgwHwYDVR0j\nBBgwFoAUNjeFOWA2c1X+jA1ocUfdC2D7xIEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgMW9w9bdxjx+WVJs95BMShqI5orQo/BKB4BHbA/9dkI8CIQDj5WZKec0S\nuSfF+y5SeoxwfWby20I1GOC8kRxFx+Q5kA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATbKzCAYpwIlqbE+pDiyP1gNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODZmZmQxZC1kMDczLTQyYzMtYjEyOS1mNTUwNGM2Yzk2ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuC/6Awwo4XJnSrtgamkAIH50ftrW80EsniHI6m+FEydLs\n0+BG/8NCI99x9vVTO5z8xjRBX1Kjw3G8HlEubbTio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNjeFOWA2c1X+jA1ocUfdC2D7\nxIEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ8jO3RXetI/8m/adtMLWhyD0vvy/RSYDMZizxs+R4xUCIFd6BrameNFW\nN2nlONjLIHLr/FOkc23DGIGa9tvcXYwt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAYkNRj3xTCQGDd4E1BcRkeRBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRlZGRhMDEtM2RhZC00OGY4LWE2YzAtYzA1NWI2ZWQ3OGEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQzNDU0ZDBl\nLWRjZjAtNDk2NC05ZDY1LTgwM2U4MjBkNzIzNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL+STiD+xjLO9yQ40Ix61n0v7O0BCWUZJ+r8nC7RuN/dwA3T2U7TblOf\nRpu96gBTASXgm3P6298Btff4SN5a/V2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHbzt51/\n4+xXE8xsMOklmOCHKni4MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAhXWfLif1/ai5OHR/SBx7x8XJmmlRSLPaOF/w\nHnMK/6ACIQCc0RB586rGZFujzXmLvNeWwbfgS0imWuTaETNVqbRm4w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1368", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1368` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZpR2eP+aufbr7to65vqbc6hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhNGMzNGNkLTIwMzAtNDgyMC1iNmUyLTU3NDZlMDdkMjY1ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg2NTQ1ZTYtNzlh\nOC00Y2IwLThlOWYtOGViOTVhMzA2OGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw6oxQNnATnoz18ySydf+LeiskNG+nzElIag2N7iJf/+TkMSiMeIwtN68SahN\nPwU2rr6xPjBCtInZayaCuBsrpaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1KuypbLvTMzXmR0AkslMJuYHswQwHwYDVR0j\nBBgwFoAUOeiQAS/blvxxNftLxQDj+UlNchkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0X+8PPHOvNsAUQ+KE8b3fmmh6b9D+dYm34fPGsEDSuAiA7+6kpmKtN\nXOU23/pAk3+dAOGDe+KVLG640cRJj3v+5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAciKcAejfPgu8BxRlYCEbBgjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTRjMzRjZC0yMDMwLTQ4MjAtYjZlMi01NzQ2ZTA3ZDI2NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSOWGOfFywKt1cKibPC8gKpNQ6ydM4l4Hle7g2z/Ib4Q7e\nYVuthBpBwcq7IeCg7wPTCdhDV0IKGWmjL70vfsYco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOeiQAS/blvxxNftLxQDj+UlN\nchkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKoPRRi/T2VliY0bhk0khZJOOiDfvV63Pc/4X94DXwuQCIQCLtIaZjbZR\npAajgfYh9hNt/HHS3TlfNtijeF9vXpSVnQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAZwfLbp7k4CUH34BjAK2X5AgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg2NTQ1ZTYtNzlhOC00Y2IwLThlOWYtOGViOTVhMzA2OGM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVhMDkxYTVi\nLTczZjItNGMxZC05NmRlLWNjNDY4OTA1ODNmYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBnfwHozPketnDR5uUwdfeF3zpxDPfhgekyXAYcWMPF5aZ/6C2CarQE/\nfx6D6MedRD6uaX81LBLwHVk0E60dsJijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNSrsqWy\n70zM15kdAJLJTCbmB7MEMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA7vePb6IMNnE3Ny2NPmjm497n/Ai9uAJ2vGGH\nr8m6CfECIQDqh0tulb26HjSbPNXNjFnFWvAFAl+7JZuy3LX7u3ARvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1369", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1369` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUk2jHAT8SJJe/AFc1hSJ5v5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxYjNkYzEwLTMwMmItNDBkNy1hZTI1LTRjN2QwMzk2MTBiNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI3M2JiZWMtNDY5\nMi00Y2M4LWExZDgtM2E0MTY4YWE5ZDJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE35jz0SplWUi3LFnzGSJOO/lqv1f+fWBt0kdSREODP2K+G9vzn7b3okbKb122\n4J4yDZHvI3W0VKEIlCy2p8M0h6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBIVBRgwGrB2OxqMkfMx4l2n3Q2gwHwYDVR0j\nBBgwFoAUrUa6ZuU9UnTrovGgBBahEzMTh5swOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIHl3C3iI4gmaz6Pan2qcao4d8mlfkm9QTBvZIVVd2rMGAiEAsZ1Cn82B\n0lSua3asc+dUb85G8kbw+mzhECmdc1H7iGw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdoeCuMSmNOgvnDqv8O0UxwqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWIzZGMxMC0zMDJiLTQwZDctYWUyNS00YzdkMDM5NjEwYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm+6ykO4tz3Cvo292ow02xH8P9Xqpv2qJ9tAsir31gxpvR\nReoKjUuu69ghf/647ab/3VUPmy+Sc0wBWKcF+SWRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrUa6ZuU9UnTrovGgBBahEzMT\nh5swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBLXoQmeLitxYOmpv5HsUEv/86RM3aQRu4vNn0BR5NHoCIQCHfKk0rU6I\nekHJLUfN3O4W7mURL4zOHYCiIXya0/9ibw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAd3hYEJfXbM+YAUXGGKHcRAOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI3M2JiZWMtNDY5Mi00Y2M4LWExZDgtM2E0MTY4YWE5ZDJiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5OWU0MmZk\nLTBkM2MtNDM2Yy1hNDc3LWM0YjJkMDFiODQ4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHhFqq/CQ9lLJ4zc5tElgEGCRlAb2JsYIjZOJuvQ2VfkUotcYoYiFKY6\njcAhNrBfWyBr4G7tqhmhgX8Qb/PVFm2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFASFQUYM\nBqwdjsajJHzMeJdp90NoMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA29M7yoJDFCYMgAY8kzgTMygtQJAXTIafFOJC\n6QS2+o0CIQC02GiiY2b1JSZJfFzsBMEwxhqNvRtM+W67aob8BmSmwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1370", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1370` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAS7T2iho88kEGwYrjG917PLnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzZmUxMjdhLWNkYjMtNGFiMS1hM2FjLTIyMzQxNzlhYjkxNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTViNzIyMjUtOTc5\nNC00M2Q2LWIzYTEtMDQwNDIzYWMzYjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcNaWEs5GKFGhaSGOTBvXw5TBZ4T5tZVoZ8IKG/s8yR22MVQ1q1ZR3K1GWuWf\nHQqfJxnhjbrKh++aLPAgd/RgoaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy7x/bULawOirJMlEWNKovyZwQIEwHwYDVR0j\nBBgwFoAUlu+oZEVSTdHSqt/Tv9qGAE87HTwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCkI8j25re8mQ2SO6A/XDNuCkM16qVmvBYIlqgK\n+rm5tAIgFiN3QDcK+oYYMr0ZJ4IloqQvqBeR5jxJuunlui0/sAE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUwO8Oq5mKkOOWrP7kpWkPI2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2ZlMTI3YS1jZGIzLTRhYjEtYTNhYy0yMjM0MTc5YWI5MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWOBF0zuCWZScYRLd9XtMPWgb79vBxEZg/A0uponHolSWx\ny3di/Uj65GJ3BRr9e2v1KmGBR+8aiXsdbfRp7TkAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlu+oZEVSTdHSqt/Tv9qGAE87\nHTwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANfMR7D+Ta2z3V/GxaSNtkUi4RdYgigd/FhZqHZ6aIBZAiAEJIYdjE5Q\nBu3nZ2q1X3f0Yn+hg9s6gPwqYw9F0yEGAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXfnOIriSIRBm80CvgMhVEz9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTViNzIyMjUtOTc5NC00M2Q2LWIzYTEtMDQwNDIzYWMzYjY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNjZGZhYjQw\nLTZlYTktNDYwZi04ZTNmLTNhNGUwY2VkZTU2ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGYTNS3Qodyum1bErThzNGlGll6nWdzTkG1Of24oCu3q2TewedKiQAfF\n07xoAfimUNiNClWMY4Ri5LEKYRSSwZ+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMu8f21C\n2sDoqyTJRFjSqL8mcECBMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAyLhdt+FuDOUKEJYxZcaOsLz0lV6DEbH7GCE+\n5aXiL9MCIQCLPQ/P39ahqvpbbnGCNvhFjJjsWN7UNaGgJrPYv4MGvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1371", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1371` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZeycHiW4uRgGunGVvLqaLaeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyZDI1MzlmLTRhMzktNDY0ZC05YmQyLWQzNzZlNWU2NTAxOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ1N2U4ZmYtNzNk\nYS00YmY1LWFmOGEtMzJjMTdhZjExY2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEORNVbKzeDjFmWFaRWs50liaoRwQRu3REhHE3qUW51K8mW/sgzlUzvCoZ9YoU\nHjUDEQJUYsfVHNX4zAwPenH69qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlqrunRyJuIDobhgVadyN8/PGCfMwHwYDVR0j\nBBgwFoAU60EiE/dxx297X7vYIi0AW6lR4yEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCCMFulsMKFh24mRxuttVFKBis0EqPOf97XPwhP\nYYJ7YAIgbJCmubS5OmmdGbqU2FwDhpL0TXgN5PJgT++e3R34nLA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWd5oIuC7KpQhS+KyFPxEY3qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmQyNTM5Zi00YTM5LTQ2NGQtOWJkMi1kMzc2ZTVlNjUwMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNOPHcK+EJRLZV5eYsQdjoKYilMTQDgUidgas4xO42Kwqo\nQ1YR5OhKoUW32jibycOutCQqJRk8iaDED+PU18Elo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU60EiE/dxx297X7vYIi0AW6lR\n4yEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSFoHSHOsiYVrirBB2vFVOGcPYKnpcCkpselqrPAF6WcCIQD+frqZV81t\n1mzJLZySDqbPKFOhDts3Lj8r99R/9fLTJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAaHgv+/vBtOBi0Zi1zWTsgUZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ1N2U4ZmYtNzNkYS00YmY1LWFmOGEtMzJjMTdhZjExY2FiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRiNDVmMjg5\nLWM1ODktNDUyNy05ZmZjLTQyNjViNjIyMjNiZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGUvWJ11J53GS0YGMZRDccFo4W6zx/NzghvP85+TSL+1Ou6cpf7AJjsX\nr2f4VbBwZe9v9P+5z42zH5lyOSuQc8ijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJaq7p0c\nibiA6G4YFWncjfPzxgnzMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiB3zqdENBjN4ZpG77mOpmbTah0R/EsQmdCdV8Rr\n58+c1AIgQwKUi7wt6pXLY2u2WT+JXdhq5kNf91KCzjovlSWpkc4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1372", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1372` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAT94+M35InEInlrtoSt4Ap3SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYTMyY2E2LTg1NzQtNDRkMC05M2EyLWNkMDAwY2E0YWNkZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdkYjhlMzUtY2Q2\nYi00ZDVkLThhOWMtNGZkNWJlN2Y2ZTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERsXAkweENCga8b7CLi6qasLnUuBAC0mNoN4vBi1e7+uu0rTb/jW/TPvPmAdv\n3pSXXlmv6IrpIOICUEp6jBqTtKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3+smMaK3eYk/c6ipwBz5TljjyK4wHwYDVR0j\nBBgwFoAUzL/+0yTt7R3Ew3j5Whw3wuV0LUUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIDTUOMvbEluALV7xO2ogMcSts4ayWWf4MpT/E+Ky9Hy4AiBi\n/Lu6sw/1IDQnurmKVtwEaA+ioomm/InVrU78vpb1fQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT9Kab7T0YudZ5m11Q6Z2vZUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGEzMmNhNi04NTc0LTQ0ZDAtOTNhMi1jZDAwMGNhNGFjZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMFWZoce0SjYz2aPdtahYjNlgT2OPTlXkj0rsCoDRYuDdh\nY2PoHBOuKXxJqcLtgDqowEW//8aXA+FlO2193310o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzL/+0yTt7R3Ew3j5Whw3wuV0\nLUUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN6OlUo263ZBlQ3xC+6uszpgp6ASSrFVr+0K3IxWD2tEAiA/UYJtcSC+\nDnxPMgLAqnC6iyfHvXvWj4irvtuzpFa5NQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbUUwLu9iebLq1CctGsgJS64MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdkYjhlMzUtY2Q2Yi00ZDVkLThhOWMtNGZkNWJlN2Y2ZTIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZiODRiM2Rh\nLWY1NzktNDg4ZC05ZjkzLWMzMmJjN2FhYTYwZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLtglLzuSse6iId5MgiV2BQ+AmVtU6ru8nX5xrGlOJpaGiRR+Wm9URqB\nerjwKhG/nPnNjzDB/oKnq6sp5QZPTb6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN/rJjGi\nt3mJP3OoqcAc+U5Y48iuMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA5v5h3lDA57y3pObrhvoqYKTe3C0dzepoJyrAZ\n0bo4GwIgXqRcfHVmSUd8dXAzBbXlhZJwag6cg4I8+5gB+zhw+4k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1373", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1373` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAY4DtUK9Iiy82Rd/nGNYF306MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwNjFlZDBkLWFiODktNDU3Zi1iODMwLTlkZjkzNjBjZTdiMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQzMzMzZGEtYmI3\nYi00NzA4LWFmOTMtYjc5NDNkMzJiYWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7G3derLQZGWXpr1xiIsNzaPeAPrP+Sk2UTdY8eMoHZR/E4BjewplgHReydSL\nUZa/Nl5XFqk7dXMg5r8tQmJMuaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZW747xbN2N3uYW1ONwbFcaCjHywwHwYDVR0j\nBBgwFoAUJBfMw8PPFRTSuuFA/546CyKp+f8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDkZTxXz/Bu9XFnXueMmOXYUuF1nggD\nyAFrwyhi9Tmq8wIgHnepALehCqOjs4T7O2+fUddP1Sr2jJTGKP+sm4FAmbo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeGyKqwg6BWE697rb1Alctq8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDYxZWQwZC1hYjg5LTQ1N2YtYjgzMC05ZGY5MzYwY2U3YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiDhyuHXAZ1arwk1tuCNTJsjEIJn8ZMWSTner2Edzrmzy5\nEHeXZRY9gecwwTLocdT/fTkEnFE6oByGtEXffQpZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJBfMw8PPFRTSuuFA/546CyKp\n+f8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMerq9Uj+wztx1YH0rghSiqiwLzW0Qdb+SUpybPBqkaUAiEA0A0Qos+L\nrtYvVFJbbpivhVk7iDgBaU3hZugV4nSc4UI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAcfpd+WsYWHOZ/i64yYlkSysMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQzMzMzZGEtYmI3Yi00NzA4LWFmOTMtYjc5NDNkMzJiYWNmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcyM2FlY2Zj\nLTJlMDUtNDc5OS04N2U3LWRjMDY1NWJjZTlhNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD96IQaiiuqaqgEeRSuGhwJTOP1ZL6abdqQwz3lyV9svprjC4pQWTQXU\nKkzS1nSLo6Qw0C0GwtzmKlwdN9GCR9CjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGVu+O8W\nzdjd7mFtTjcGxXGgox8sMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA9W046VYAHQdw1UONGi0+SZUHOo+ltNZJR8EPJ\nTrwAvwIgWagOdJjELCP/hQlz+50BMcxuCcxCnjIoK1vXNVvNOD8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1374", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1374` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASRKndi7Fffa/cgMbgLt741JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5NzhkMzk5LTEzNGItNGFlZi05N2E2LWYyMTkyYmM5Yzk5YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQwMjNiN2ItNDVh\nYi00NmM3LTk2YzQtMDU1YTRkNzQ3MWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvuuMxFDsz6KshWv3ojgEB/adSt6ljwX88svNYPKyRH3QTvwOoYpEiaBKn17n\nmjrxNKas+0s4pPvLj5zdIbIYzKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOLLK8MmZXWlH56SZjDB2wBups4wHwYDVR0j\nBBgwFoAU31LpUF/zP1FTWdjK2Kdfjj4enBIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHatUlHIHj0T8UmYeTDwVztjemh3u9Jg\nwKEmpraAVxgjAiEA9UFskKTC2feh7F22oshs/74iAICr6KyN8bpR1qlzR5k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe+1hBfb6DOV0fDTtFRTHOhiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTc4ZDM5OS0xMzRiLTRhZWYtOTdhNi1mMjE5MmJjOWM5OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStB9HPcCGln9yvjgq+XdSwov9BGrW6HGUhCZW5bY1PuUEx\nvWmDPXPdztUzxwevojJIYEt2KpvUe2Q1qHb5jgCLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU31LpUF/zP1FTWdjK2Kdfjj4e\nnBIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRom0vsodxleA5imneQ5PBGo/Kcoo6eXRZc6ou5SJgzACIBKimRwhjYbw\nABt9a6JFvrUqyT1FlszxyyIdI/G7AIBN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdBWjL7MMlql0Ew2WxahEV/aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQwMjNiN2ItNDVhYi00NmM3LTk2YzQtMDU1YTRkNzQ3MWUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ5MzIzZTUw\nLWUxZDAtNGVhYi1hMTU1LTQ5NjFmYmQzYzE4MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDYlMRgLFJKgmUzgld+5T3sXexzscglLdEGeU1ng1mCd6zdEeuEmgjcI\nHh4/QW3DCrNsxRnZU/hfVDtbHnYY9qmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKTiyyvD\nJmV1pR+ekmYwwdsAbqbOMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiA4VqRGJtHYm+5MbfGNB1jI7+2APAY7K8BC4EJJ\naaE0ogIhAMQsB/5z9c7mgzsyAynVnBzRXhbejxUIjfpObOI0bRI/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1375", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1375` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAV0ySttXsuhNMMu0WnZ18qQ3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzN2FhNmJlLTNlZDQtNDNhNS05NDY2LWM5ODQyMGE3YjAyMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBhNGI0ZDAtM2Zk\nOS00MzU5LWExMTAtNWE0NGUyNDRjNWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFIDmAtktaEUIxAJyIPn4WqsGpV2ye1iCHh8f/krx24fNdBTm5v+7S3KOYoNk\ni+LybjEwyWAOqDLQ2kQAcFPu86OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnTeDdeBM+p+wDQ1XYq7b9z2hSXcwHwYDVR0j\nBBgwFoAU19XyDg/3Rk5/QRSp4xxVS7u2sN8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIChO8iYbuQr/\nZXq7ToscCdCGcWY2tcPtSCwjaJyFDubKAiEAzSFhjy4jDmG5bIEXbxNBfhU1Z6+E\nbvn617R9bHjQWIE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVtz/wbOGg9Mbuy/h2jge7wxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzdhYTZiZS0zZWQ0LTQzYTUtOTQ2Ni1jOTg0MjBhN2IwMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbDabMIl0pGpX3+6K2NRy3G7FJypKpNlyPVan7ne33lLTs\nTTB6FpJ84IpzuZbdTXtb+obBaLiAFQhoGuPXk30To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU19XyDg/3Rk5/QRSp4xxVS7u2\nsN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfL7pV0HPNSW9TNBvdoNGX4okbM6vTry9zpGl6lCmKKcCIHUzSVnFJOhz\n3e/tCIWf1rrohsR9Pg3iHfBe/N5DLdkZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdHycAvG+tLStuOECmEaWIZdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBhNGI0ZDAtM2ZkOS00MzU5LWExMTAtNWE0NGUyNDRjNWU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE5ZmQ5MGI2\nLWM3N2YtNDI1OS1hZTNhLWJlYjFhOWE4ODg0MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOdc8iVxX/uTb5KN8hY9AZNAZEaORfNvLC4deWjmM+Q4NW6RBxINZeIz\n+0f2XcVjtb5V8db6LbcOp+jwzRa9MbmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ03g3Xg\nTPqfsA0NV2Ku2/c9oUl3MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA+fOHHr4AmNjW1OOTc/po3Zpo6vKH2f5CZHlx\n+Qb9VUECIDRIu5tWsjdxKsM5C4FQJGdnSRL5vmIz6foluXnq51JF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1376", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1376` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISARpSAyK/6vDUv6oQRYrFL2JVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyMzdmMzk0LWY4NTgtNDE4Mi04ZDA0LTQyZDhmZGIwMmRhMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU2MDRkY2YtODZj\nNS00YmE3LWE3ZTUtNTBmMjc3MWFiMTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE69VkifbTqEgTFiI0rWFHuxKPZjJoiIG95ii/juYuQnz/vzMovCYsIiyZeyBl\ndAhhij4LPODaR+rvAe5dm3Sey6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2ArE2xwlXoGjvqKex6orf27YOjMwHwYDVR0j\nBBgwFoAUlaQOIDE6tQo+FekRrsQ3mHd6n7wwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJFOSl3e6LyLYfcCLVfrUlaPFewdTWSLRlys4YR3TDCiAiEAqBhJ/kP6\nlrXEMxU3+kJSQG2lX7R7CDkJx4RPu9mIGik=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbmEoUL89sCdZrmzhf/yytNjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjM3ZjM5NC1mODU4LTQxODItOGQwNC00MmQ4ZmRiMDJkYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGnwptOVtysEiWxYtNMcokggvGiJcdvNd506tnIgRvawIS\nf2PD8obkxVHDuZr9LmoFYUPAEjLuTCTEUKHDWSdLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlaQOIDE6tQo+FekRrsQ3mHd6\nn7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKD5yQ9NyJ6o16lioLbiDV0dkfnzbjaobB2lZ+xV5mRYCIQDOPqKKUDUR\nODBrM42pYnH4ksppW/e34Gs0TJrD6kqnXQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAYNyj26Z35hewld8TW8Y3++IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU2MDRkY2YtODZjNS00YmE3LWE3ZTUtNTBmMjc3MWFiMTkyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNmNGY5YTE3\nLTMyNTUtNGI4Yi1iMmYwLTgwMDJjZjhjNTBjYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAoENBWjPWidl9FdGVRtmL1W6tn4JysnZPlRns5ugx2qXqgS00SEM4t0\nNQtN1cnhyLDAXZqGBLwlKImCCWufZmejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNgKxNsc\nJV6Bo76inseqK39u2DozMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBcV+EnkLKzTdch0yWLfyJsS8vI2ebd0MkCb1ZJ\nnWcLRQIgHmk5N0Opv65KOuzgkjKovESigU9MBu2CYEeZNeN6Icg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1377", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1377` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARVaqJKYqKg3TgWXRuaZPgnbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMzIyN2Y3LWUyZTAtNDk4ZC1iMWNkLTQwZmIzMGMxZTA3NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM3YzAyMmEtYmE0\nMC00YzkxLWE3NWQtMGViYjQ2MWEzMzdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECR4TyB0j9pYALDnSgy1swpwXVFTf40bwLOMXMBPOIDxME3bWzI8K34EPGIr6\nw2SyLalCSsndei70pe3v3b505KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJP2A3IgXt13292mtW4qgU0NOwyAwHwYDVR0j\nBBgwFoAU3vSDyUmRhipfVxzBnQHxLWX+lEIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANzv7BwrLBrOaP54cHvOuLXx2WEvetvoKOvznjkYR5E5AiAjvNQKmFJk\nVnYY592PXD6A1c98mLKiAQeENYOhj68M9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc+7SqW8VYFHWRmc6Xdcb9ghMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDMyMjdmNy1lMmUwLTQ5OGQtYjFjZC00MGZiMzBjMWUwNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1TK5nh6Gfdb6FhiOWGnBhoFeDobaD0C0KHCOpqAlZEahe\nxhcdvIyaIzTED4icrluB9yErbo6ZTcpS1lXlNkqpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3vSDyUmRhipfVxzBnQHxLWX+\nlEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANUsRosMPyJzqcdkSffQbJqqhyQOexyw49OX1I7YhPWxAiBpBzDF8hA2\nWcipgPx++AYAWl31qputCn/Zbal/WVxYfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZvSBCGtqZj3M/yvRNZp64alMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM3YzAyMmEtYmE0MC00YzkxLWE3NWQtMGViYjQ2MWEzMzdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdkY2M3YTYy\nLWY3YzMtNGRjOS1iMDllLTA2ODk4MzFhMjk3ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKBBkkt8Rrs7yDfk9h/dIeJJXI2jiN1rayTmB6inftx7/ZVTO6wmJudH\nnCAa+W7UhFvhIeO+ip0xy0sBM3g7vHyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCT9gNyI\nF7dd9vdprVuKoFNDTsMgMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiB0S5KGGj6+aAJa0mIb7K6HBYFrllPhWfb96IBI\nO8W+lQIgGRYpa9RFL2eFf9LqEU9WcMEjl/5+fd03i1HljvUihE0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1378", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1378` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAQ1jWZd0JkxsX+LMYRoZpA1uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMGQyODY0LTAwZDYtNDZkMS1hZWUyLTUxMDQ5NTRkNTMxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFlZTVlYTQtZmRh\nOS00MGQ5LWFjZjYtOWY5YzY2NWM3NDM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF5OCAVg7ZhtZxAhSTTKw6ShTKOBvUWImPYmc6IyDN5lzytKr14mFAtCT1l6t\nn9mDY0o5fi3A5itr+mrZCIkZEaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH7tDOR3q64yNLXbqqDQ2Zc2p+bAwHwYDVR0j\nBBgwFoAUxTd0WKAsMxlk50WQADP6S+ptBPgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQD0OTy1Ez4NzdY7HRLk0qEwtN37NLWHbIDmIrJFSOiuywIhANnDVTxx\n+S6JgjHQHzap0TULHlgTWqd2hKkaRJdQ3bdM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaaSO/stcnibptIGzy4eZMwtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTBkMjg2NC0wMGQ2LTQ2ZDEtYWVlMi01MTA0OTU0ZDUzMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHLp6ZnU5rWnz4EDCUha+3fZQT7cioRgj/DFLgqoaZyhBi\nJjcRU7yua5d+NUbKhEdABD0RPTNbxUpPlVjWRoeko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxTd0WKAsMxlk50WQADP6S+pt\nBPgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKYCnoMjoAmWXIOI1N5P1d+Utp7G4ODqV3An3k6mKrvPAiEA+R6LsbFv\nJgENen/Tv5C6Zekp2TbMJleZstJQIu2kkeM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATErPaa5wWOXCCyElS3+h3dbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFlZTVlYTQtZmRhOS00MGQ5LWFjZjYtOWY5YzY2NWM3NDM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJlYjQ4YzU0\nLWJlY2MtNDc3Ni04MmUyLTFhMmM0Mjc3NzhlNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGVRncW6j67nk/JDHVem8Ee9VZtdu6GaOkwNeamV3zFIr7H9Sr9L5oTo\niCAs71+PPPPopyU/+Ypt3k3PjaVvngCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB+7Qzkd\n6uuMjS126qg0NmXNqfmwMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiA5VxYbU5CTI1ia5Vzgso756clBPgmK8kJjXazf\n01WL7gIhAMcXpdwuSMhw/Hx+WI5xM28fAfw6OPIrncx8M2GpRa40\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1379", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1379` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAcGDCDrs42rCJXIrxodX5aJbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMTE3ZTQxLTcwN2YtNDQyMy04ZmQ4LWNjMTdlOWExNTI2MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY2ZGMxN2UtOWE1\nZi00YjI4LTlhYmMtYzY4ZmUwYThmZjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuDgruWazsaHYFnjLwUCmJsuXf2P7LvjouK2UOLyTP1pEEca/Rli4FHu0L6KW\nstHdpHxSbyCu1IUJckPuPh2+LqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd6UK7SJvaKN2nTkg9ZHxa1/YIekwHwYDVR0j\nBBgwFoAUYuoPoR8AFGwOscgvJHhrwNudFuwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIAPDJUFtSVRGejl6QNZ2WFqFJUFrxuiLW1KTkCPf\n6RX4AiAiW35iz4OIc9J8K+36rBYEqCewilunESU0h+tjzP28LA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU/3TcwTDpOpjchFdh9FWxQbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDExN2U0MS03MDdmLTQ0MjMtOGZkOC1jYzE3ZTlhMTUyNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyKt/Wgk+/On7smW1J1jIgxtfUHEq0kGrTbcWTmUc7ns4Y\nxEy6Dbnlvf+pJZpbFRTcGbVun5OV9zaLs34Sak3Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYuoPoR8AFGwOscgvJHhrwNud\nFuwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMITFlOu5rFjyKURAe71YTiZX+kOlwYnL2YXpccewS5GAiEAklhduCAD\n47sXFKBkvmQqQPJt7KrziksbQQf9gP8FmOM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbgxST9j9mZaQ935+dktIf2TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY2ZGMxN2UtOWE1Zi00YjI4LTlhYmMtYzY4ZmUwYThmZjMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNiMGM1NzJi\nLWZhNmEtNDc1NS05MWUwLWUzYjc3MGQ2NjI0YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEg9p23cEa3lvB1BfsbHjRAju+aZi4QLBy18rtxdtGdMrkI5ePOMrSF3\n6tLqVIGRrSr7yqPoZTuyj0/14MaS8kOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHelCu0i\nb2ijdp05IPWR8Wtf2CHpMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAs2IucAw2DweSgQbw7j3Htx7/c0ThiKQo6KBhG\nZTxJTgIgOiUCINlLFf+lJMQDVLCoGdctxbWdnWPFcw9X9/RxkGQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1380", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1380` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAcN/fr1ieThsZkHsjQkgMAwsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YWJjMTQ0LTFiYjUtNGE2NS05MjA1LWYwNWVkZWYyNzFiYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM2MDAyNGUtYTA1\nYy00YjRlLTgwMDctYmE4MDI5YmNhZmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHkqGfJZIQ4k/PiDcBeKKdcyimmUS0i39TeTN31GDwdCkveFARCKbLWkJ7mEh\nnnCTUCXWtSMWYFAU+DFlj5w3FKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYrSzz/nWttG4fuyFjsaPcjobXCMwHwYDVR0j\nBBgwFoAUBHRVXuY3P5hUIDsmh+Omj7wTW+wwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCdiuJGYriehUp4AaXLIOHfScoOz/Is0mphIDmp\nGhWlXAIhAJBSgYKD1dPiWKY6eCbZ+eeZjr5ssC1CWHv03s7huWbz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASL8IUaPCFImEvhVh5Tw4910MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGFiYzE0NC0xYmI1LTRhNjUtOTIwNS1mMDVlZGVmMjcxYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd2DTCtmhHjVPcWMpfOVSDSO7981tOs3Jqj2aJ9xfzy/zj\n4ES569iSIzNQT2hXkxivCE+ZyjNkJkd6+dI9jG1Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBHRVXuY3P5hUIDsmh+Omj7wT\nW+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALqQGlefsSVW4edJRz6HtdW6o4ICfUmxwihKmVagjz/bAiEA4MQs0NMB\n+idWy4RpiqqwhGOmmmLybIWgc013z0BKHyE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVsgVCcPxmVxQRyJVqBeuktAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM2MDAyNGUtYTA1Yy00YjRlLTgwMDctYmE4MDI5YmNhZmM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc2MDc1NjM3\nLTQwMmYtNDYzMS05OWZhLTQ5MDlkNWYwMmRkZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJYDQq57NUZov69c1s7Xi3m1/IeJ5PLau18G1QHl3RVbVNMeFCc56iNP\n1WB0J8Txa7uz2COk7EDEfDe4DSsKY5SjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGK0s8/5\n1rbRuH7shY7Gj3I6G1wjMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA9B/RZuAE7L+qnrRT9csY7b9yt2vjGyffpPT7\ncLXufE8CIHIwUOcJwXxc95/I5BpKu2dXKXGAW31+1tyT/suqzI7F\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1381", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1381` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAQTQuS42c4MFt/kjanwqh9DaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhNTQwN2JiLTY3ZjQtNGJkYi04ZmFhLTA4MjM3MDJjYjlhZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUxMDE3NjItNDNm\nMy00MWYyLTllMWYtNTczZDFmZTk3YTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU4ke1KCn9QzSSDWHeSzPaikn/VOzKdT7fFhkd5aMsSIGHnAGQJiY0XTFpDfM\nkpJ56q2PemxS3Wtd1QENVLuRQqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUec8VxTAFXa6ftJ54a/zgoZIsaqEwHwYDVR0j\nBBgwFoAUoYByTrayi/6ZqEigIuxGGYYZ7VgwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIEqW9Shb6L2CT/5uHGbKYLPf2UbICIP5+UxabVPKL9AcAiBl\nNp189oC+AQ4/3XhWz61jd/xI3bZZ6DggdYrQDFV18Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV9UPCsAHvIy4ATU1capa0t2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTU0MDdiYi02N2Y0LTRiZGItOGZhYS0wODIzNzAyY2I5YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuG8IxhtOoSJUDzLCrJaga1rL7jkaYnFyjEALHQ0EFemgF\nikNHArxJ9oY3cDd02iwX/DfHCYxAm+njodP9DQTFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoYByTrayi/6ZqEigIuxGGYYZ\n7VgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF5opzctEWGlPcJ/wS8h7xVWaqG9de+F5SHVti4Z552UCIQD4VVyaUCkV\neO4tX84UqNiE0ZZYqWQsESSVYe2BIc5bVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAd/G1rYTnsI57DCCG2nLy0AtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUxMDE3NjItNDNmMy00MWYyLTllMWYtNTczZDFmZTk3YTFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ0YzZiM2Jl\nLThkZTEtNGMyZC05Y2U0LTAyYzNmNmFjNjhhZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMv1LopFCrNhwbW0JHqreNECkgPlP9eCK0QzWHUIEGi6dOGPXAeBfrc0\n61WV4B2d8s3kJhlmrmJjf5Wie4xsJL+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHnPFcUw\nBV2un7SeeGv84KGSLGqhMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiB/MDWhutib5MWoLI1TPt2b8yaTj8j2Yqgr1RjM\n3DzaAgIhAOfWYttvRREpDfQvJVhltghN8h1s4Y6W/hiZfKWG9v0C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1382", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1382` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQqmlA9smpmv0D6d/6eDQaBtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3MjM1MjM0LWI4ZDgtNDcxNy1hMTMyLTU0YzRkYTM3NWRhYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI1NzA3MTEtODFh\nNC00MmI1LWExMjItMDI1NGRkYzNhNGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbethm69WYUczVp1g86yALU/7oAWJIYzPqfptQW0LDDfZk4QlkYyTNZ53sR90\nWlJ5WAy+/4yQ1QOqdrQMHJWZuqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtUguSIyt07O6XKiewpLy4WCkTT0wHwYDVR0j\nBBgwFoAUlwWIEhEaPn67XsW+vkF97SS7XbQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIEqi/WVTfxP6wsuD5AEwps7W+5D8cF3J\nQhkVCwsUTdjMAiA0jacWK5s6TobGf3sxVeaA88scqbtMehOicERswnl/0A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfzFdHy6e4Pf+PtBaon7mCF9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzIzNTIzNC1iOGQ4LTQ3MTctYTEzMi01NGM0ZGEzNzVkYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzUaTXfqcQyWp4Kwg7Nobn5/tnsyG/IUqFCIVzyuJzT036\nBA2msFKLzgAPWsXUiJqWafqgK04+lSfPsgibnYklo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlwWIEhEaPn67XsW+vkF97SS7\nXbQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALI+hjrBAMjVcLzVzW45XqkzuFIQH4PHi9+sS/OJNRvaAiEAxDcutj3B\nhl+QjOAT02j9yxWcT5/m1U4tMQ3iiSm0GcY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeR/4nyoS8jJ1TuxP357aTw5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI1NzA3MTEtODFhNC00MmI1LWExMjItMDI1NGRkYzNhNGFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYxMGU3ZjA3\nLTZmOWItNDJiOS04YTFhLTc5YzhlMTAwMWMxODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAyjcxJHLQm/wW4DsWEppFdblGsyW7KsotDoO4R9/FV3Ud+s4ib3iJe5\n2WR6Po7QSDzFHn5J9gmxTQEEtp/jSjqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLVILkiM\nrdOzulyonsKS8uFgpE09MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA+ISm1txua8wT8qdxUkRV4xMRxzZfHCcLQ67N\nkccETuICIDWPYgQcfPDhiLc2F+/H+q+YKWteYKNXIYTmIPiP6PwB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1383", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1383` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVPFR2x3dwaGS3U1BgiqpWqPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4YTE0MGM1LTQxZDctNDA4My1iOTgxLTQyMzkxNDJkMjM5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE5ZWQxODYtYmQx\nZS00ZjNjLWE5YTMtMzQ4ZWJlY2Y0Yzk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE77rDKq4yJQ28nXa4pb846N4kLZuiL7KVR3WNmVn7W3lZTlUi9lIuTi01hNLj\nTOelXPGnjNMcGDhuAK6Coe4+laOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdHJPq0yyNxoCTfPMn6yi+gY+/mQwHwYDVR0j\nBBgwFoAUzIh7jsbpf9rrUY3OehjHcUUXfE0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCZQNBMji5VUy2r+9bDjxMDLlT7P4h5\n4SKsRk5FGJSBGQIgWOkG6BgVu+NVT31j9XVdO0kRq+JgC4mbs0i9DhOmmoo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf+S5PUe38YRUFlkD7TKNb91MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGExNDBjNS00MWQ3LTQwODMtYjk4MS00MjM5MTQyZDIzOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmaFhIQiFFJNG4EXo6pMMJ1AAXT2jRt/P/hVLQg9dorIPw\nqFpzGli9R5M44ZDhX1Rn1Yp7Nnw+2f9mSfS4tHruo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzIh7jsbpf9rrUY3OehjHcUUX\nfE0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJthQrnYNNJDpcWg05kbqJ8T6bF1RfZTqsrrd5FoJBYoCIAKQ6gmx0GaY\nMwNtRrYYlS9NbC2JIwdik5h4EGFrl7to\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdvRguWdFhJIp47ywjGr2zBHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE5ZWQxODYtYmQxZS00ZjNjLWE5YTMtMzQ4ZWJlY2Y0Yzk0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE5YWE5MDlj\nLTg3MjUtNDlkNy04YTE1LWRkZmI3YjdhZjA5MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBveREqoZFL/hhnVCw0z6D9Z09oHPkN3KroYXUV2LGXCUnHQvBVVX93R\n2Oj1xlkV7CUGOxskkOOxOejVBw6/0kWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHRyT6tM\nsjcaAk3zzJ+sovoGPv5kMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAa7HwtD9u/Zkk64thZDFBlJu7TGR57trH5icek\n+bxlnAIgFynB5hXd7m2tu4GBn3dvxp6uqd4FJagAsPRWg8ccY2o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1384", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1384` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAa5wQsvUMRXm4NLvrdRY2oUAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjODRhYjE5LTViZDgtNDM5Yi05NGVkLTE4NDhkYTMzOTQxMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI1OTY5ZDgtZTU3\nNC00ODhjLThhZjctMTZmMDg0Yjc1MjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbXrQrieoOx3rymoUS7nNYJpNiRoRUwoH422twsZKMYaJMwORw2DLobxg9nXh\n43xWazsdFDFhVj9n/KEKtPYFx6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLvPJ0muRsoB9rszhkoKS02M8gyDMB8GA1UdIwQY\nMBaAFPzn5v0tSPhUR+1uLS9h0Z2oXQ/9MAoGCCqGSM49BAMCA0kAMEYCIQDRRvXl\noU85EqL+0ucBa57xZ9kUverPTVYrOmfG5qDLdgIhANsXyuIlmxtkyN9ilGdSB3lM\nZNy8FO4F0lEUSGVrwYtH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWSPFnMos5GGhBeHY/zR1OkGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzg0YWIxOS01YmQ4LTQzOWItOTRlZC0xODQ4ZGEzMzk0MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv9uGLE1jqcEaFz4/TASicRjWvuwcY+pXDXVZz7wBosk8H\n3s+r170aWAVUalzZ+YKIHPDLb3QhWFN8poXyRC8Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Ofm/S1I+FRH7W4tL2HRnahd\nD/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANdKbZafRLgVVLtoWrpewMJWpP7jp2tKN4OBvc4HjUybAiBx871MPvvF\n+c0eGKg1CJC/1QNvnfnhVeglUh6XmXcYFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAc73c5lNACJlvoDOgAGYS3EMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI1OTY5ZDgtZTU3NC00ODhjLThhZjctMTZmMDg0Yjc1MjkyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQyYzhhZWVl\nLTIzN2QtNDY0Zi04YjEzLWQxZDJiYjAxNmM0ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDerDZOTmWeLhpd/bG8MgtX7v/nk3B4IBtrk4IrP+iR9mgi5OMQk6oSj\nNp40QL81xsF3wierkRYVdWUbymkURKijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLvPJ0mu\nRsoB9rszhkoKS02M8gyDMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAbov9FPuoLPScp7LWx7rHOHW0ktu8p1lhbbcx8\nluh38gIgB0Fz0CJeyZQIjg64Fqy9b7p1BHXVuJ90bOZpIUo7SI8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1385", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1385` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdDqj2oTjju+E9hYpNPBQcSmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyZGRiYjNlLWIyMGYtNGMwOC05NTAwLWYyZDY5MWIwM2JmNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjgxNzY3YTMtZTRm\nNy00NmFmLTliOGItZDdiYjcxZGU1YTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE32lHkr9Alm08dUtvW0yC6KXpzAQXJWsr9I6cWjhX9bMs80KamJVcPs/N5zAx\nXN/AdQZP7tf7hgyVvCxHfyN+AKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFI1Q5UBrhKyIHQeZgLM9fbaFhVkyMB8GA1UdIwQY\nMBaAFFsUeAyvuEnIGHvlN3lU4luxDekaMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBzluPSje5jr/PBB5kQLD2yIAwwV97H6tw8\nA/6nIzbcWAIhAKVqWaI4LVBtQ+QEq4W72N4Ucmx46lXxqePyB1GrnL9H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYawjb91jumApeDdcdLQ+0P3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmRkYmIzZS1iMjBmLTRjMDgtOTUwMC1mMmQ2OTFiMDNiZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0RlBcQ8eS5fahyv8fJ1ILFBkRlNeVxhER+xL0SThi8otI\nFF3nwFrwFinwArvtDi7GyiNTmm0mkO4VJqpAnWnYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWxR4DK+4ScgYe+U3eVTiW7EN\n6RowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVFQsH2veOUvvnve1wpQQ4XBIloH+KYgx+2+9LMuuiFECIG8GEXOa8dy+\nlxJDEdl5yVY16Z97Q2qMzFMFarvxvKQH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAUMALp+6GXEJWIVfDgt6ZYqkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjgxNzY3YTMtZTRmNy00NmFmLTliOGItZDdiYjcxZGU1YTU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFkNTZlMjE1\nLTgyMmMtNDE0MC04ZmUwLTc3N2MxOGU4MWUyNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOwDWUgGbkWL6rmYttzItRXOxcvfuy1whoWPEUORnNRfiWXE7waCfF4n\nAgFijhFyDyv2uj04EoX/58txLtiLiW2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI1Q5UBr\nhKyIHQeZgLM9fbaFhVkyMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAhsOCjbCMb2wcxP/vd+g9JmZ1azph2XMzVx7B\npMEL38wCIQDe8ZOZqxU5HD5k+zePjc7JKNVlWRPnF4TGzKG6+DJfEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1386", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1386` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWeHlZazCg2THpXLpdVmnFrRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3ODI1ZDZlLTVkOWUtNDMxNS05YWZjLTM3OGJmNjFiZTFiZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBkYTkwYTUtZGJl\nMC00MmRkLWE2NTYtYTRiOWYyZTlhYmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETCF0PJVa5q4snfCXihe8d8+liZX+qpY2zs1/AbV4AO9Neu/PCqyo+Gsco90p\nXavZAYpR/zbemc+ERJ94imkWRqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOHCs34u7IO2KBsBRAq9KmMAuTJoMB8GA1UdIwQY\nMBaAFDSWujtIw2UdWVmzsCnsfCGMlZu2MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEApy7+SQsmEyG/wlG9PVjrH8MuzFvKUrcy\nXwPvKe54x7kCIDu0cU2CqIO8fYLdJV3J92V3LcPQR94FdZWl4BzSnBzN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY5djPF0LhvVDtsOE+nHak4HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzgyNWQ2ZS01ZDllLTQzMTUtOWFmYy0zNzhiZjYxYmUxYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQp1SY0DOG6Mp9EXSw+qa7ex/HecEwcWE0LyOfQk2GwK0q2\n/UiSDk6Wk6y+7Xi66OOFFJHRJ0yG0jbpSL0GNsoxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNJa6O0jDZR1ZWbOwKex8IYyV\nm7YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIOZR8o58KcAu6y1Nnj1Qg9HDmSzJhkNQPEeDz9EpkvuAiEA+lvl05qa\nAGK6Na0I+ygiMGC7N7RZqyrvq/AViJQ4Cwg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAUhcULM7EHdKF2iapHHIlVxGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBkYTkwYTUtZGJlMC00MmRkLWE2NTYtYTRiOWYyZTlhYmM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUxM2Q5OGU1\nLTA4ZjgtNDIzYi05NmI1LTE1ZDBmN2VmNjc1ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCrmrPG+YCV1odv0pBYuVVQwnx10hxJWPBLDCnbqa9Qt5abSGupUUgRo\naO8ubhLJpYcBVhQP5WRW+/EqwHPOGKmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOHCs34u\n7IO2KBsBRAq9KmMAuTJoMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBLlyW8q1Qkz4SZkN9X/tOmdM+T5U8xZY+wZhul\n9dZx8wIgOVWizmt5bAVa7X4uwRbPuECNB1+l0VYnxsT0n+IEcdc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1387", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1387` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAeVbOfpLJ/KynpA5x8vB9gEIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliMDNhYzEwLTRkMDAtNDI0Mi04ZGViLWIyZTQ4NDdjZjRiYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDg2YzRmZGUtODVk\nZi00ZTU0LWIyMGYtNGViNzk3ZGNkMzg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELG/7rjuZ/fDob7m0QgyvrUYwwF23ywMowVHyrKAhIuqdyjCdn/chE+l6iv8v\nCJModKvl/7zXJizKgXAiiyM6B6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSMXrXy2uhUPIdEVpds5m0MQ+oy6zAfBgNVHSME\nGDAWgBRW/79vGXNEO/zND151778PzFzDXTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCar3cvM2+HzK64Nwyy9rXybvQp7v54\nyHYrpGld2wijtQIgce4O0dDbY+UN1UbBknS8ylz03oQLgcvVKhCxq7p+RPM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQiv1LypnaL/4/bsTeJ9iwRDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjAzYWMxMC00ZDAwLTQyNDItOGRlYi1iMmU0ODQ3Y2Y0YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSfyktF+horx634pdG6Z410W2kDt979kQ5A8/Am7UegJfQ\nM6tpMz63ObB8IavRuqZWw4kkI43Jd50Vi6Iplt2Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVv+/bxlzRDv8zQ9ede+/D8xc\nw10wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANUoJnC6zmRYMPlNJ4oB0XeI4j1/MUWc13sX1LM1BjrdAiBaDHDYCEmZ\nEOSIsExUeQEeKCpqg/h7PGINTwXbF6O2eg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeykbj7KOMCqVOux7uL/lvZnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDg2YzRmZGUtODVkZi00ZTU0LWIyMGYtNGViNzk3ZGNkMzg0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZmMmFmZmEw\nLTk0YTQtNDg1Mi1iM2Q1LTdhMWYwZGUwZmRkNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAt49rUcF1fVgc17xlW99U7NPw/DCMBZcD0VuEc0WTloGCOB+mXDTJdp\nOnI4YABhF10VnEI7ZLkjoatAvMcP4mWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIxetfLa\n6FQ8h0RWl2zmbQxD6jLrMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA5ryywA9GlzO+katYLgmeRuOO7bVAhpobhj16\nvouim6ACIGVZyqK5KA+xQJcOWedeNnCC6DFmziEbmq+2beUh0upD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1388", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1388` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAQoI8JYD4GUvIL9r6eeuR0vEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiOTRmNDNjLTBlMTAtNGQwOC1hY2UzLWFhNjEzYjYwN2VhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I2ZDg1ZWMtYTg5\nZS00MzViLThiODQtYzY5Y2YzZDgzMWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Tc0qt+AzEIw2niWjBYen19F3HazvgIsUuarfEfBLsQhWqYqXOlAWNN6J227\nw8uuzJf7hL6HihBfy7wQweC19KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXVgMIU6QuAaYJaToln6jUM42NhgwHwYDVR0j\nBBgwFoAUAJbLz26IbjtifDOtWZWZ3ftyTpswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAreiknYD162hz\nFYXcPBiL0tx+2pkfvjctuMuh1/gz0koCIQCblXo+Uard/9qmEQvdE51qxydnCxmN\nZBweRoCpMx3tXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASfuGOq387DzyxC94YjYi3KvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjk0ZjQzYy0wZTEwLTRkMDgtYWNlMy1hYTYxM2I2MDdlYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe70zKOwkL/lwYuePT1S666KEmdQJDxL2Xz19eGywYIlfC\nfYSU0/8mt7M6eRkbQHZVNp4hKEz/x0FzShV6dgD3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAJbLz26IbjtifDOtWZWZ3fty\nTpswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGeLEuA7armx0EPjBD6e7ujZdPLh4PGP8onjvD1pUjDYCIQCc/wMZmSaA\nNoAQRZ3Pf/kSiLa2okOoEGxGlKokZVaNJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWeasXWDwXBdC6GSxIpl0GsBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I2ZDg1ZWMtYTg5ZS00MzViLThiODQtYzY5Y2YzZDgzMWFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE4Njg5NmZh\nLTU4NDQtNGExMi1iMzk2LWYyMjU4Y2IxYWEzYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMo1FSkzvWxMXsV5DbZ6PCirKy59C/x26ze78t22p/O6il9WzboP9/YF\nzhVPJ+MtQVC3U6yKPxdzmewLyTrlJNajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF1YDCFO\nkLgGmCWk6JZ+o1DONjYYMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA0xe+TZ/rnklW+sRsfg5RJMm0ZkHuoyN4f8je\nqHklGVECIHf7hFD2mbGT9qt4q7FzxMvsqTuV936oo/SU3Z3NPYyC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1389", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1389` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAd8HYBZB6jXYfNy+CvAQJtgzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1NTdlZTgyLWM3YjItNGM3Yi05ZDI2LWEyNTJmNWUzODRjYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI3ZmI0NDEtZTI5\nZC00NWZkLWE1ODQtODY5MmQ0MjgzYWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEszVDKzNde2eqll7fLGP9/1GnFVnYpmwhsiTa6QxsFevwumoTkV1k1Cx14vdi\nP/+6Ta/5mEgud3mmz0kM5oUXUaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM43QE5/mh/t7gT8Zn3R0yewdQLIwHwYDVR0j\nBBgwFoAUc8P/hc6KqeNtWboUEEx15ubieygwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBb46xnZbEYXlz9\nd98xOLPhGvT5JlKNfjyFSTY6d7trqgIgViHANxfesZWdNcGWZoqKk9hcygwkk0Fi\nfzFia/DMUcg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS8SAI0t6Y3Osbirjx8R0X3sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTU3ZWU4Mi1jN2IyLTRjN2ItOWQyNi1hMjUyZjVlMzg0Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ55CDNzf/TLPjbMGWtGEK8BIX6z1uFUB4uIxjynGtb53Tc\neGupg1pyvDeaGlurH6IFTZEXfYcR0qyQ9yTmaDRwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc8P/hc6KqeNtWboUEEx15ubi\neygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaUc66f3R4aOh0Eg3+5hUgFaz/Jv/d3tTlzkDrdKnzL4CIQC6lFgVxVtq\nbu8Ox11ehkbnrXqCdRoAz4D9D/dbFtxlCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAXfTjQt8jcuU1thvYfg/sygBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI3ZmI0NDEtZTI5ZC00NWZkLWE1ODQtODY5MmQ0MjgzYWU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVlY2Y2Y2M4\nLWFlZDAtNDliZi05MWI5LTRhYWY2ZmI4YmU1NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE/tIXcpSHzeB/a1eb6XjZM9hPtoS0ijbQ+zfUQDk6m7o7B3POMSJ9e9\naFNfWI+/iGSkHD8xYzWgGPX7D+uG48OjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDON0BOf\n5of7e4E/GZ90dMnsHUCyMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAseHLE9+SlEdvFvqIF6eVWZYsP2Tuoi5DbzEPG\n56XN8AIgafhCAGy8m2ji+u/g0gDJ2kLflVzL6LfdOgiz/acneHs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1390", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1390` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAeFnYwyXUf3yrK3wM8GD/axlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1MDEzZDNjLTc0M2ItNDI3Mi1hOGZkLWNkMTY1ZDg0Y2FhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk4OTI4M2MtMjRi\nZS00ZDYwLWI0OGYtZTZkMTgyMGQ5MzUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvYV+N8Az6mnG1hr9MvoN/xMj3Lmqpy48tUdN+3xmGNGMtArWaNi6WWGHMbxp\nPqUdFnMA+bi6HfQjpCCEvAGjfqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4+LkdtXTRWXBI4QOHAAN9aW3CkgwHwYDVR0j\nBBgwFoAUpJuk/RDyI6LumA882/WHSCWBW4wwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiB4dXrkMcHLTVXfhrfdF3Rh\nmdareU/vnUQZbl/HPkinQwIhAKP+Pqh8aIq17cMVTBbB6GBCfRWw/XIQQUDvIx+P\ncjoq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAalIB96xrty4eeZkvklWMrv3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTAxM2QzYy03NDNiLTQyNzItYThmZC1jZDE2NWQ4NGNhYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuWJLyYwg3GTT3Kl5pzOztzCLtUoybyq23MsSwjs1FHYeB\nzqcFC4Zj44dLKb1nKXnAPnxtovJmebS7mAoycpwao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpJuk/RDyI6LumA882/WHSCWB\nW4wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV/ph5L/2ePYU8G7Ujo2c6/edTuA+YUcymjlXmh5y8XQCIQC6kEl0h/vE\ndsQaz7tpztSNoU8Gcr4acZWWEsTXzLzDUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAdw8o5DViHgiMfnsDZFV2R6uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk4OTI4M2MtMjRiZS00ZDYwLWI0OGYtZTZkMTgyMGQ5MzUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEwNjU0ZDM1\nLWFiZTktNGViNy05NGFmLWJmZmJiMDBhYjk5MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE3d1K+oFbmMn37unFWrrOcPbI28nQaTZwvFz/fJKvgJx68DOHK8gUyl\n9B7jV6Ehm7oiZCgF4o4eU/XEmKPFJWmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOPi5HbV\n00VlwSOEDhwADfWltwpIMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA19JpBzF+QCKeKZNRyGixfvJkQY3B83x5KcYw\nPaVKHEICIQCnIjxQN1hb0cXxZG+XZsAldRMkzLyuC5s+e0po8uYOfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1391", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1391` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISASxCOyb+pRlFTKtXLcby4P/JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkODk4OTYxLWY3NDgtNDNkMC1iNTIxLWVkYjc5M2JhODFiMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM4M2M3OWUtYzZj\nMS00ZWU2LTlhM2YtMDVmNzRjOTllZjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb2lR9uC6tOjcMi5cI/EoPpLcS7C2fYjCPUi4Dy4yUrywncm/tIxDIfczI3No\nzNN133c/Dot/EQZvGE4qgEP9baOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqlbwUx9Ulk85z8d6q/qGVb62IMUwHwYDVR0j\nBBgwFoAUJcS72u+X97bvV1xMB3FsfNqqNSkwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAqLGg\nE02EZ2oixe3PLHTjnPHmtri7NQ3gBMnG0sRgmL0CIQDsyp4BNC1acfU7H0u1JLbj\nYKVtC7hY6x1IDJf9Udv8pw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQHSGUnIcEdkUXU+iblyFfuhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDg5ODk2MS1mNzQ4LTQzZDAtYjUyMS1lZGI3OTNiYTgxYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDb/IJg6kaQS6sBwp5BMBAbfwYG41nm33OAu50FZ+HtSuF\n8lZ35D2RG/STGtUjnHoqj5GYrg3SWxJqQuVK7AnSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJcS72u+X97bvV1xMB3FsfNqq\nNSkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJxOJCpq/4w4egQYszwNK/nJ8XPH6GHiekNaznd/wzMcCIAZBbNanLDSx\nAbCGTA9aDt+KBRkhBB0p5AA141BnD4oh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAbaOVcy703bbvKLwFdrNQZPiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM4M2M3OWUtYzZjMS00ZWU2LTlhM2YtMDVmNzRjOTllZjUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQwMTBmZTFj\nLWJhOGMtNGEyMi1iNzIzLTgxYjUyN2Q1NmQyOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI1ns98u3aBpJJFKNPpQR1cK1NcWrYNGjCPPiE4j9/S83lN/bAjLonOG\nm6LpX8G/5+W73FiTuRcYv0w5Ron2gvOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKpW8FMf\nVJZPOc/Heqv6hlW+tiDFMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAlO360rTtNt/cuuAwCXH1tgnafBoPQYOZGhoR\nqb9UT+kCIQDVPYw5M2KSOdr33gcSE5fiYAsh23AX3Spzlb5XaqmFsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1392", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1392` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAZK7z4RrHmxDW/nmsY/irMyaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzYmY0OTA1LWZiZmEtNGY1Yy05ZTlkLWNjODMwNjVhNWI5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFmODhlZTQtNDk5\nMC00ODBiLTgwMmYtNzE4ZjkxYTk4MzA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEve74MekHZK105uWXdWvUhy1KdQyFCY8hRyeoSgepb07pwhLWrjKs1wIDA+u3\nHnMg/OltprJgEGViDrIaslTKjaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP1UJjxqB356tgETzhj4KfYhhw9AwHwYDVR0j\nBBgwFoAUKQwCETrLYhRtVFab2bUi/b4X/8UwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAwNFJm\nOs3vtporZ1rj+eY8RELjmLYEeftW5E0HMDG4wgIhAILLdpwUgHElg5apez2Aw0S3\n/i0wKjMcvPLrMsUOjORW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfNj02cW2v6Jtskq1Z934IJjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2JmNDkwNS1mYmZhLTRmNWMtOWU5ZC1jYzgzMDY1YTViOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi0S7TZx4Cocv4iBq4yoH8NqR//5VyY+uIIMDfCCtpvYjM\n5OlrbwkD3ZyjqeuO19TuvSdLz3DrMvK0Aw0OD0txo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKQwCETrLYhRtVFab2bUi/b4X\n/8UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJgmBqEavr8uDxsCGGxgq/x68wVzjrhniJ9HpJQRehghAiAl/Qw9ZU7J\nnaezkbQhC5hNZ6f7VaeVDLUMDJqdOHeAug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQ/5VfD6p87pVZLBhDbh4vs4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFmODhlZTQtNDk5MC00ODBiLTgwMmYtNzE4ZjkxYTk4MzA3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDExMzViZGU5\nLWUwOTYtNDZjYy05MmMyLTIzZjY4OTM5MTBmMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO0WBXuBgiBlDvuLG8dfIoiZskr20raJqFB21/cVkfJBq37fJu5kMHWJ\nwGttnh7rloLWj7NAJRD6SLG482msEnajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD9VCY8a\ngd+erYBE84Y+Cn2IYcPQMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA6mInFLzCzYdWEG22KDT86ZS2MLZNPfXf1KZP\neK+H/g8CIH3pvYYyYpPh3m5gnLYtvQM6ZPBgZlaf3OS/kdCgBkfi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1393", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1393` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZjEmdwEIFhDju1EWdlKDkr6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmODcyMThhLTVhYWUtNDg2Mi1iNmUzLTU3Mjg3NmUyM2E4OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdjMjEwMTQtZTQx\nYS00YmZiLTk0NGEtNjk5ZWIyZGY2YzdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeubWlmxQPO4gN5xo9vHX4t3MeCLQ3rI4WNvyfdko2x4KitIBForFSEmJKfSP\nNj0zVJCIS2q3rM3jmO6gTMzReqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEtTeE1XrWgwdJ+GLMnV/rVleFfEMB8GA1UdIwQY\nMBaAFOV2TL2iPL6zpAY0fvau0drns8lRMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB5DojFPCwQ5dAL7ZognG93/ki51sOmg3GT\nTNsSmoo3+QIgO+JGT9NMsAa65M4WKlvnE7/997auLS7wXpyHQh2KArc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd6E+SVJnh3hZ0TR7/WbS7WYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjg3MjE4YS01YWFlLTQ4NjItYjZlMy01NzI4NzZlMjNhODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOqLLQVWYJVK281KTq/AMPz59NIP1GGGnQzuSOj6C3vj9X\nqvojj34+K2BiFUJOsJ+29yyIosLnPFmPBJS3Mfeoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5XZMvaI8vrOkBjR+9q7R2uez\nyVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALXWYae9WKbIwhNLrYKAO96YfI+j8rNusw8bkuwmxes/AiEAuiQ2ONia\nScSEKxBm3ML7dWP3NcuHVnY9+Fruz5StJ/I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfNsGIz/R9Dvu9tC/fBXcRUGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdjMjEwMTQtZTQxYS00YmZiLTk0NGEtNjk5ZWIyZGY2YzdmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGExYzc1MzRh\nLWM4YWMtNDA2OS05MmFmLWU5ZTE0ZDY3M2RlMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI3g36+bzi+WEx9iEd0dgWPmzqLYcLEmK29stikTq9NY23rkdvpLDcoh\nldfeQaC2WoxQ87XF0ZH4K+1GrtypYgijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEtTeE1X\nrWgwdJ+GLMnV/rVleFfEMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiACgaEC1fWRUPUXxH0ujBOKYwpW9j0gMMppWJQI\nYtNaRQIhAM/45h4pZ1nwGyQNlJmYW5ZQGzvSPlUXuVd7ScaqzRgy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1394", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1394` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAb0rkRfiWGkF86qxAd6K1BrUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxNmM4OTA3LTlhODctNGY2Mi05YTRjLTIzNDgyZTFkODJhYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQxNTM0N2QtMmNl\nOC00YWI3LTlmNmMtNzg0MmZlN2JlY2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEphypV8bKWPJKfQ6JbPFyiGk4RMsQSMb7bNnilV8xScNNVeHwcBvEkDdGPZRF\ndKAQAjY8suBJh4O1qBdyFoEbsqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUngOX81RBzonVjZ/11jgmX6BAFSMwHwYDVR0j\nBBgwFoAUmw2ULRkj3ehB9TMIFmfYYvIKbTwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgQ1q5Zvrfjr1N\nTpkghzZTEySL8AY3Ry0Mluxxzxbo5eACIF0ZMwjgNBuBJcrSzDy8CRguA7xAH4aM\nZ7og0Q25exiU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUiyg769HiXow/BD4KtYW/zoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTZjODkwNy05YTg3LTRmNjItOWE0Yy0yMzQ4MmUxZDgyYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3zf2MHcpJnuUZNVbsifl1A/Wpq+NDuoIyx88tLlLcE8QP\nAkAqqoVrEIqgEbpt6ETWdgIKnkKSx6bxX1GzPkllo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmw2ULRkj3ehB9TMIFmfYYvIK\nbTwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF+TWtcpX1fCaOf6lZVY7V2wP2H6TEPZoM9kx3D+OLMYCIAjd+guk9qea\nZm5y4Z0DXMA7e0v9qiDY4Xp8La5n++Id\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAZaN5P3rXxZ5YVaQWMQx/u5lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQxNTM0N2QtMmNlOC00YWI3LTlmNmMtNzg0MmZlN2JlY2FlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYwNDhiZDE1\nLTdlZWMtNGMyOC05NDc2LTk0N2FlNGViYTQ4YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC02NjlV/mIJEFEWRcvDsnzjwXRLJJ/ylETTc68pwOLM0bBlqRnQnVk4\nFUSy7reel/LR+ifRhTFP0hUuh/OjGXijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ4Dl/NU\nQc6J1Y2f9dY4Jl+gQBUjMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA8umdRW6oDsLHKRbifMRAJA+vs0bHmQDdJaxC\nrWzmPqYCIQDaVWS+GQ1svjvCkQ1HDR+IR0MrncHrphp35SYNbBtrFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1395", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1395` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAeamWoaWrmctWZVBXzsdWV2vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhZDEyNTU0LTg5N2UtNGRkNC04ZDk5LWJjNGM3Y2Y4YWYxZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFjZjdjYWItMDA1\nYS00ZjljLWEyOTYtNTUwMWYyMjg2ZDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx3/7H6Z6Da2fRul7iXK5zxzFtP6mAvzXonhcZ8IANxDyMbWjSv2m9T2RIjYY\nbKQDUCRspMZuWaaDt1ihKJ3y2qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUNsSo9axAcktKHcXlyMkAmFbaVIwHwYDVR0j\nBBgwFoAUA1IdwEzV3s682lcFpZB929T+huowKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPiIABNCOLH2\nYk091iDAbsD4Z8yype6lrxY1ThAo5KMKAiEA0bmpY8BfwyaXOxUQ8Z+LdX/x5qEb\nJ5kB7Rnw96YseX4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQvDRaNMd/K6SOFK4pt5LGWcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWQxMjU1NC04OTdlLTRkZDQtOGQ5OS1iYzRjN2NmOGFmMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQW/E2JP8JnaEYs9PrBBiXGp2rQ+HH+mu3f/bOXzT/2b9yo\n6+P5AH6wQzZfrrLWmoxGMfiFz79cGgJlxVexYPmlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA1IdwEzV3s682lcFpZB929T+\nhuowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAJAYLrcF9gsfkgm3Jc0muQ6BggK8F3iGwdpP/MwrQbN5Ah8jRCP85lp1\neepIoRdqFwD6IEFWRsZZBGboQS3cLnrk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeLLya06IO011qDv0QL1xf8UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFjZjdjYWItMDA1YS00ZjljLWEyOTYtNTUwMWYyMjg2ZDkwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE5ODdkY2Zh\nLWFjY2ItNDczMS05ZDM2LTdlYTM4OWIyYzMwNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJp8RLAUBkyhOg4VmRL7cu6xkR8uwsVL7sBx7HK2iThO+mAZZsLEzzuJ\nsdqYb5pA8gsa/5tgrPwZ3otTsnw/m9WjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFDbEqPW\nsQHJLSh3F5cjJAJhW2lSMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA2AbaJeKHhgfKOOsH/EcOVp4ZjHmVvg65CpUY\n3hCfBQECIGnMORIpW4l++EqE+s51yD/8YbCBO3RNo6BZGrQV6l35\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1396", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1396` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZOvpLp4hFzsSTGZmLqDwzePMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3OThjYTRhLWFkYTgtNGQ0ZS1iOTBiLTNlNDk4ZDk3Y2U5MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc4MmJlZDgtM2Zi\nMC00MjAzLTg4ODItY2IyNzU3YTA3M2U0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHurLOUbV918W2YEusYn15uQiS32+HR6an8oT8cLfUwsWn+S/6iD6UHLBb67E\nBZ2pbtzI0tJ/AZ9grO92e2fXkqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOPnSbub/zCvHXnNgIlfY3At0QVcwHwYDVR0j\nBBgwFoAUNmV/VJPfDkiNJ1DFERdL9d77/qwwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIC8HwEVaKoKW\nyNd1ib0Mm5BXhWRvgiijV7gPXLoTUSMuAiB29kakyykWZdK89vd1GSmRbo+qj71o\n78DLRnldvHorBQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe5IxBkhS7ZJEkD9eOWepvt4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzk4Y2E0YS1hZGE4LTRkNGUtYjkwYi0zZTQ5OGQ5N2NlOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASb/5NFQh+1oXesL4Qv+zjey1dHTWfrZjT3ejRvCHEdosqz\ncBTmBU8/rSS4uVb2OK27ILJ/8mcUPnQp6pGPGGgfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNmV/VJPfDkiNJ1DFERdL9d77\n/qwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJBWaI/eLw+y1wQeWOOUhj4okXAheirqzFIIh0pKM/6eAiApTbIzL/i6\nkpLDZ+0tPyyDGXXo4XA1YwTx0VjpQIb3Aw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQ/V16gCyaGNw9843ihjYM3aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc4MmJlZDgtM2ZiMC00MjAzLTg4ODItY2IyNzU3YTA3M2U0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYwZWM5YzE4\nLWRmMDYtNDExNS04N2E3LTlmYTQ0Zjk4MTRhZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABInbs8gmRISDNbPvyd3RZ/ZfTmGdYslJ7/vSpXB5H0LEG8zoS/d5tbWv\n3T/cUlYyaJwQq9D7+qLIaX9sTA9M6O6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDj50m7m\n/8wrx15zYCJX2NwLdEFXMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAquP0a6vEJ1j+qKrlVwAIY5GuHFN92AEEB8x0\njfEsF7oCIBBrmW5GyV0P/KIi3zD8H+Uq3i5OJelFNJMWt7mLYRbw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1397", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1397` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZkDwjlfg3FTaS9v8tDKg3GtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZWY3NzFhLTg2ZmMtNDRhNS05MjE0LWJkYTYxNjMyMzVkNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE1YjQ0YzItMTk5\nZS00OTNjLWFkYTMtYWVmYjJjMWM3MWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5NmY4NoNbvis9FzdxEVChWabhbKp3btPrp6KZXe4CWlFQABvlbqVQYFRfOR7\n67FMZo7JVHRbW+qaUWzWzPv1R6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI1ASl2evfYSB06Lalri1kYOXQQswHwYDVR0j\nBBgwFoAUmlB6IddksiupXZsCEKSu2y9hHB4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDlTIp/tMYNzgE2v5mRmpxks0UpwpUQIkW9cc8maRCFhwIgQJ6WziSgM25m\nMPL0fIssFOOhraQNNkHYP2Urn8L6xDk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXy7AEqbOhXYrbZnuCeqGl5uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmVmNzcxYS04NmZjLTQ0YTUtOTIxNC1iZGE2MTYzMjM1ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPqhAiWr8CV4Cuxma2RysLfT4V0/SZdmBCPyyVgVT+SNdo\n+a7hvIac0SL3OwdZziNhyCknjbL53Ij5YfitFr3Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmlB6IddksiupXZsCEKSu2y9h\nHB4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANjJwThPvg4wTU5t54ZcVo/IWAHEYdMhSYrgAV2gAnRhAiEA+rvwMfZv\nLKZ3vMYK6Nss78C11TP8x2n3TIhJkvzEcQg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeVko1ZUUjzYEb1X9e60SgXPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE1YjQ0YzItMTk5ZS00OTNjLWFkYTMtYWVmYjJjMWM3MWFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlmMmNjNWY3\nLTMzNWQtNGJjZS1iMTA3LWZmNjkwYTVjYWIxZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMnYAWHbaslG2T/TCWWZEN8MMB6Q7BM1Xu434vfzII+B/Tpv6uuvz0Lu\nvQZw7R134VXPff6HpCcw/ol6WRVrnzijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCNQEpdn\nr32EgdOi2pa4tZGDl0ELMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAsBAZEGDok0/gWxRjr9+aeTGLhN3g5zyQ1DYu\nTEBdDA0CIAgD65JxhWAGvZjDr2s4lSHV2d4CdJHOY+5uG5O1k72O\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1398", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1398` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASNCyqqwbCs0+Ng7T7ZUNRWJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlYmYwNTQwLWUwOGQtNDYwNi05YjE0LTQ0NjRkNDlhM2U5MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFlYWYyNmItMTZh\nNS00ZTMwLWIzYzMtYWNjY2RjOGZjOTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4ppcW1hPno218QvVMRUqS6BaIFMeve/1FKo86J4AxAtUl9sUM9/40MLRBG5A\nbwQaoRSMxDlU/AsvA1Tzz7e35KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKlIfIZN915qHHD9O8xDX2Cj+6N0wHwYDVR0j\nBBgwFoAUg3lkFllbIyuvCQoTkLB6bUK3XDEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD0OxkrWCxUDKh9Vyi7Ja+vHfF21SAB/zjghkjuqrfgggIhAMfm8B+5Xj9l\npL8UapjDCze4vSN4/+Evgos22TE2/ZT3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYj33QI+uX99E49wd1mmKxdpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWJmMDU0MC1lMDhkLTQ2MDYtOWIxNC00NDY0ZDQ5YTNlOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9fk+JzEvDu4OG9FZT5cXtcICMJIB5fiZdKgYFvAQ0teWi\n7UGPhUy6hh/ag10QAjgIvDxazLo4lmm1Pd+8S3l2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg3lkFllbIyuvCQoTkLB6bUK3\nXDEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcXW4KcOKXze9PHbvD96SLDnpC3aSX/TCnBVdr/honx0CIQDM4xGhUzDo\nqe/J6WDoLphbeUd+vAlU6RfSrseW4Ac9sw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAemJsswgMcDvNQNYiiqLkPkCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFlYWYyNmItMTZhNS00ZTMwLWIzYzMtYWNjY2RjOGZjOTU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY4MzNlYWQy\nLTcwNWQtNGJjMS1hOTY0LTU4NjY1MDUxMjkyMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC14+gUZN/moSyLKj1wNqtLUVy8auvRgZLncK601G7j5qYmemER35FZB\nHwK4bs+IcHc1P7IAhq2iDLYQ2htRUfijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCpSHyGT\nfdeahxw/TvMQ19go/ujdMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA++eQNh02Bzlj1WjyQAkEE63ZlPLRjxDW1qmn\nJqRFnSkCIQDnI9a6woM8CxdRz+vJ9w3uQl9+nDT8GEK5vmcFCZHdiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1399", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1399` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAXpfUNVc3Svh9bTTMchHJfKrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxYWE2ZTBkLTcxYWItNDNkNS05NjkwLWViZDMyZTJlMzg4ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWYzMjhhNjctNWFi\nNS00NmQyLWIzZGYtZTRjYzc0Y2EzZjNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE57dFihOS8HU9eBkmT2N+qhzy919IpdD7O/cFLAYmrjoQakIHW+nwEOY4U5su\np6D5N/CdE7IRIJ3i/WVjxpJoGqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxX/si+iC2Wq5Vf6FXeo8rAINKHIwHwYDVR0j\nBBgwFoAUBJ1JAe2mjQFiSGDkxEfZ3bezJYYwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCq\nWrFMAO1blGSr0FmpTevEpWE+YWpsu+Ois+jwDfSwwQIhALkttpITSFAxqmRsVOa2\nAnq/Wy8+pBrqgn6PNvPg2ov/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARTD+dwufNiOta+1lSgkXs3JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWFhNmUwZC03MWFiLTQzZDUtOTY5MC1lYmQzMmUyZTM4OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/AGuZGCKCDyfdjAXdC+KgePPtU4OyPn2svw/9GkDWV8Mm\n5evWiecRBiXMiv5p1yjQjbjalEbCYjQ5dEow1QTOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBJ1JAe2mjQFiSGDkxEfZ3bez\nJYYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCzyMhyGYfbqKQYwsPS1tuW1zn/dFxcmxqqyk9mN7Wg8CIQDBs+cVf6Ij\n0PH595QAnvlbNAZapjjVYUHsbD8pp4yiHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAd1bShM1T18piG0uULFUPl6SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWYzMjhhNjctNWFiNS00NmQyLWIzZGYtZTRjYzc0Y2EzZjNmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1Zjg2YzVi\nLTA5YmYtNDVkNC05NzY1LTY5YmE4NTJmZWI4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEkq1lJ3pNtyuC6bBQ1eU9TgD2TL/+Uq8YXBOwu0bA3i6v8DEnFS723B\nDZNFRcTpbJY/yXig7YEXdFd05s/ieLSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMV/7Ivo\ngtlquVX+hV3qPKwCDShyMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAjKf/C7wRNEUxpKCYQKRE0KBlxkEGG6IWYfRu\nkpaT9QcCID5VQ9SxFqxUPZKGJtpO8m8XpVWvxiKnVzm8BU42eO+h\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1400", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1400` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUkn4VyVphiziz/0p6GCEfiLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhODg2NTFjLTIzZWQtNGI3Yi05MDllLWQ0NDc1NzNiMWFiYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2UxNGFkZDctNGRh\nOS00ZGMxLTgzYTktOGE2MDBlYzljNjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERXve0aCM0MgG6BZmts6NSzgS9SMnW2GJqK/KLf8wlgeymqKTSTBaTGkty6oT\nZ7xGLrpef9rDHm3XrVNGlX7EJ6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfX1ZLjQ6aGoPZgSXexhTAW+hSVkwHwYDVR0j\nBBgwFoAUouMtXS6HJvKiALHbiXaicQ0VcGEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDNjRng6j81kglbaCXZ0NQNQR+Hy7LW147hor8sns23zQIhAKmk\nKb6YwrPFtpp/+Y8LPyZmOVbj+TwWyfT7D7yT2gNu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWAxkfzGmZveL00BLpnGl+oNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTg4NjUxYy0yM2VkLTRiN2ItOTA5ZS1kNDQ3NTczYjFhYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATci1QeTcIFenXXvOy642jRXBj/MmF9XGPScbvYuclhMK65\nIJaeFtQdIFlMeYPBMMCIzSAcJeKULaoBZ7cHYidWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUouMtXS6HJvKiALHbiXaicQ0V\ncGEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALQNT3EPRHoak8qAdGFvSLiaDe/2YBPfIgCJbkjceQAbAiEAlzVzAvwK\nXapLb5GfguBF2GZGPU/4dLygGGdIF+poxRk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAX/PtOnmRkieIFVrN4zqH022MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2UxNGFkZDctNGRhOS00ZGMxLTgzYTktOGE2MDBlYzljNjJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdmNGVlYmY1\nLWU2MGUtNGFjMS1hYjJiLTcxOWI4MzJlYTUzNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGzTO2LBkBo8pcjKEoMSmlZ7S8D0h/ZPsVzVzbhVKSVC98UllcWzyERr\npKTVkwW6dazZ/x+Uh78cGzw4Lq0xgfWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH19WS40\nOmhqD2YEl3sYUwFvoUlZMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAsp700bWFIHQCjnilKfUSKTvaNDa7IfxEdj0D\ngn+3d0MCIQCeB1CgLOWqieXG5ir+WAOsLskVVjCziJjFi95lvy0JDQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1401", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1401` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAXtIc6ox+GXKCXjH2Y0W4e0LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwOTMxNTJkLWYwYjgtNDRlOS05YjdkLTUzNDk2ZGRlMGYwOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg0MmVhY2UtNTNi\nYi00ZjA4LWI0MTMtYWE5YzAyYWQ2YzU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd0o/CTbojuLqeNDuzwVeJxE9li+mHMSMIZkS2+Ljg/LCyUAgcEuP7u7CdYhj\nzq5skN6M57YuR/BVOpf0qh+I+qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk4x5h9lLrOjekoFRCzknJeMNta8wHwYDVR0j\nBBgwFoAU0qREk1Ftc0nudI76F9nKok7UxOgwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQD0IRk5nGQztbZvItomGpCGHWveW7ZQEyTMy1bCvkEDbwIhANpi\nUBgYkE544OJLza3LCvM8n6oMX959+Cw6515i0s0O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUUO0E23U86FgflSFYHmyg4TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDkzMTUyZC1mMGI4LTQ0ZTktOWI3ZC01MzQ5NmRkZTBmMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASa0mTMP9yKip6OOxKEaQHxlaC7uR+YMnHM8/UcWeamMvuh\nVAX3dRnooKh3FFQ/zy6uQ4N04fvzZ/IKjRag4LEHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0qREk1Ftc0nudI76F9nKok7U\nxOgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP4/iGXftQzU+yPzcXajQZlO0iCUscD9BRVnM+hC8HcfAiBFTdgqJ6MV\n906+aJrBwVv7SN5wz3KSJLoCIZFavgLQhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAa2BbFfoc8/58dCBHCJcvg38MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg0MmVhY2UtNTNiYi00ZjA4LWI0MTMtYWE5YzAyYWQ2YzU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE2MDQ4ZWIz\nLTNiNzctNGMzMy05YjM4LWYxZmZiOTg5ZmZkNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG72MSKWTrDposn9x1V6G7UX5pZYWN0sSgNAazERsOkYSUsloydHwAqr\nHu7p8lgCxc8xabi+PmUxazO2A1rwEXKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJOMeYfZ\nS6zo3pKBUQs5JyXjDbWvMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA3ZXORdrYciSnxn+Bj5fT7gLLrYJA51w/IOtv\ncuB3mkMCIDD53Y0w+Ne5A5qrgFjg1TJP0ATMdPrR9x2XnOo3hHw6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1402", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1402` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAQe8QVsnoxVi3fj9Z95ExSsrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlODE5MGE1LTE3ZmUtNDY0ZS1iOTIxLWY2ZjM5MjNiZGYyYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg1ZTEzZTMtYTgy\nMy00MjBhLTkzMjgtMWE0ODUzMTBhYWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE34Oee4e7oXn3OhULqBM4A/KeEBr1+9gNek+8Z3gNrQF1rn0liTDwjQUTbKVn\nvaYBguQR76aTUw/rR+Qr0i1KlqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN+wPfWg5f8g0FJKOqxcFG0FoDYXMB8GA1UdIwQY\nMBaAFPhmuWcr7GfiQiNnFNi9SiBrXmNoMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB2i0SDuE1F1rVyzINbgwETBE4L942T10tX\n91nkqrSm9gIgSqjXCikXj49gqnbxpgZaqdCGqUfEeaT/XS8yhH0LjBE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ6M/DNuOpdZ+kBpJPTfFe/PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTgxOTBhNS0xN2ZlLTQ2NGUtYjkyMS1mNmYzOTIzYmRmMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+QetvFUZbRHPCMv1Wz0yOmt2vU6pdJoz3eDJLpBicEW9q\nghkeHtsSv/P4i1HpXW4JjbTlJji7OmEi5QCorMiIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Ga5ZyvsZ+JCI2cU2L1KIGte\nY2gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOfT6RrBXDyy+ekr1nlyEEj5TGiXc00y0nP1MzITfYGpAiBwRKmokDLs\nBkC7hu3GcTHLV6N0nc3vKUkNvX/3/WiI0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdcYKoF1qjXxtfWzW2JeoWEoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg1ZTEzZTMtYTgyMy00MjBhLTkzMjgtMWE0ODUzMTBhYWI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA2MjdkMzhk\nLTFiZjEtNDQwOC1iMjY5LTZmMzg1YWEyYWM2MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPJ8WT+ed1ecG0br1fscWIw3ALcamEHIq+mVt1iWLfZklRsdmNmbiBFT\nWA50IGoBryRWjcwdEDp+ySwYypwK6FSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN+wPfWg\n5f8g0FJKOqxcFG0FoDYXMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBlfm+o2s06M9Wf6nQ+xiizlhpLEzVxbilwy7qc\nTg4GUwIgaPXP0QTw1fNALFsJfLz4awZFq1IbFnLQs1gRQKMoe3s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1403", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1403` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAfneoraWxeEqiuqgneKYsTu0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzZDdiYzFlLTljOTQtNDFlNS04NDAwLTljNjkyNDNiODI3YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I2ZDk3NDUtODc2\nMC00NzdjLTgwNTQtMTk2MWIyMzViNzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOfCtlNYm8jRETd/Xj2j4FqbiM0lN5dj6V1kjq5nKgkNFk6fGaOkQf4VddWcG\n+nDdrrYW5bQY31tOokBnn9F9uKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSgC+BS2Sfp7ZeVFkyAw2qvoWw+wwHwYDVR0j\nBBgwFoAU24S375xQMItkAAZN0cb1ToxQXg4wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgSN14+q8jq3vI\nw1LL6Q805kCmRqciBbIRmUcF8ISuZMUCIAQV0Neu77iOPz+8gB35pRBGlcXIb90a\n02TFhbbgFuTh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQjX4zaqZs8cKymvuMaypJTfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2Q3YmMxZS05Yzk0LTQxZTUtODQwMC05YzY5MjQzYjgyN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1r+BhWXVsTyKyPRX55gjH/pe9dCKvwmi648RX1jhFvrAV\nXoBUwT/fRsVAfvWTa2xAUNHvg7FNCm/RZNZc9lnAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU24S375xQMItkAAZN0cb1ToxQ\nXg4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdFsg+iU5jBYej6EdN3SfjDB6tVtKar7CRgqPAdrEz5ECIQCJAsNoSgan\nwjX2y4jmjZKZ4FLiQ15HRv3/tfqndVFsJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATkMxdLW0rcGva3eOD7LLc/aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I2ZDk3NDUtODc2MC00NzdjLTgwNTQtMTk2MWIyMzViNzliMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZiNmNhMjAy\nLThmODQtNGVhZS04OGY5LTMzYjQ3MTlhNDU0MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNI5NDJvU+1cqAPp1npwwc5Cpto4zdgMuQb84u9GwDLiZAmWRBURRCcs\nIEMt+81qx7wOSAJje0nd5oiWEPtAtPSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEoAvgUt\nkn6e2XlRZMgMNqr6FsPsMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBRUPvzwFqiHEuSAf8Z+BB6Ppl7VuJytrBMASex\nNKVSFwIgKCsDyew3SGspNN8lvkOEHWIuD/ady+mIWq8tzsfp118=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1404", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1404` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAa7aJHLZdw0FQdtNhvU1phLDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1YjgxNGY3LTg1MDgtNGQxZi05OGZhLTVkYzhiZThhMDAyOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZlMTBhODktNWZm\nNS00MWM5LTk2YWEtMDJjYTE0NzNjOThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbq3TB7cDkRm56dFRNoqbX35NejyHI13hGogIXzCwRdyMRu2ozkpAvBYtSZTh\nFhmKVSwwQp40S0kxCT266ToagqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeTOdxDgYAcyWEDOUBnZaM7+N/NQwHwYDVR0j\nBBgwFoAUGtyTbQgz/eE2nWOm4O1h3WVdN4gwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgDeF0Lu2HRu9T\nnta6KVu+8TM+gPxKSNbNLo2usuk50/0CIQDk7p5Wly4svjvtOuF83aTmEBhg/Nw2\nHf/RdwSMUnk5lQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeJwe+AbmLAMSCAG+kHCyrDrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWI4MTRmNy04NTA4LTRkMWYtOThmYS01ZGM4YmU4YTAwMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMvHibeYaCcHktSh56AK7W95y8iTpaxkSrsDV9vZGhgEXM\nX1eeIwR+55T5IoygNdid0VDYyrIH5kmrmQMepoOXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGtyTbQgz/eE2nWOm4O1h3WVd\nN4gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIAYu7SF7aAafsyQ3GlS4A2JucV8WiWs7/xdA8eku8tAAiEA+AQeE/Iz\nForPNw6kmX4RMWnTjTWZpx494b6DESHoXjY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISASLfpXbqiv97nuIUEfZZ945SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZlMTBhODktNWZmNS00MWM5LTk2YWEtMDJjYTE0NzNjOThkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDllZTE4Njk1\nLTMyMzgtNGFlNC05Y2UxLTU4ZGRlOTZmYWMyMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJSXvHRMI31A1PAWOz7HRYUctxGZd9fa9EJsqyPUpPSwVu+gWOU7Vu+6\npNwDLGH+Ne+sJdMAYEWXxgaH6YA88qyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHkzncQ4\nGAHMlhAzlAZ2WjO/jfzUMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiATC3f3iaAtIR54pjnazf2IViHI9+M3Rw0G8lZm\nJYIGlwIgfOzuV+j+0bcKppKLDkv0Pit50lGtE32ZCRPLOmYJPQI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1405", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1405` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATJtBzzK6TUHOckH2G4M6pUAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3NTgyMGMzLTA1MmEtNDIwMy05YzdkLTk2MDQxY2RlZmM1ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBmNGNiNDgtM2Uw\nNy00MzAzLWFkNGEtOTE1ZGNjNTkwMzUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1plVmpSBz4kS//EVk1/D0hPQLdiGBUocL+idjMlCI1HcOhx/vDjlFJ5uQr/f\nD0ytj1Czmm81ZPsxCD/PzPTx1aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIrQdAhcc67QURjm0bI70leeg/AswHwYDVR0j\nBBgwFoAUJhLWmwmQaelJ4nj41d+Uy02CXKIwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDhuRcEOanZ\npKPbqVDEYOR7pclBwhjzVn5xJ0hwAfkAegIhAPkydzo0r8WpJJNjDXk3gMktQ+cg\n99y2EFw7SZcNXw4Q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWyJxli1Dcpni9MmXPs/6JGtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzU4MjBjMy0wNTJhLTQyMDMtOWM3ZC05NjA0MWNkZWZjNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2M8ubO+pORd4N7I8bMHbXmkJYmRaJJe0Lf+29ifFFImub\nMW5lB4OsJOC8pHmuEqwAYthSKymGOvbTaRk/XJGho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJhLWmwmQaelJ4nj41d+Uy02C\nXKIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPcpp/PdfsbRfMSLCRi89fo1/EjwZ2RX3S3EjmyHCIZlAiEAhW4QMUnw\nqPloISIbLRLU+Xnl1KsriQ6S3F5SUgKRusg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAekDgtgOvoS1hLFqgbp9GdfwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBmNGNiNDgtM2UwNy00MzAzLWFkNGEtOTE1ZGNjNTkwMzUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIwYzQ0Zjll\nLTFjNGQtNDBhNC05NTRmLTllNDk1MjAwMjI4ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLytjWauFL8MUJqLTI7rLrR0rDVsgARubsxPTlRtK3k+bY0EUGqMqcgJ\nMFkAUncZu9BpB2a4W5w4DnlKlnIzu8ejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCK0HQIX\nHOu0FEY5tGyO9JXnoPwLMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAz4f2mQnk5nR2f6sUGwfG0aUY9qumpnH8wLtt\nlsJGvHkCIQDmbm9StEur0eF0Vh1dZS3vh9Atpa8oVuBqjOgz05acMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1406", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1406` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATGVc6dHO7ztWZLpAz0ghoSIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxZTVkYzkwLWYyMzYtNGZlNS04ZGY3LWMyNWQ5ZTM1YTIyMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjcwYTU0YmEtZmIw\nMi00NDYxLTg1YmUtMTc3NjY4NjYwOWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEATyMZ4FEbsFbOV9WIjZwZv97lk5UT7h1aC5DHV9SZXfPeC9/l6j1BzJexcdv\neTNM+DSnSd1QFHq0HK+i8nc/XaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/jWuzxpH6+KWwbWFufT4Pmo8FFYwHwYDVR0j\nBBgwFoAUX+5zE6CtJSaMqPvJ4PvbL0TGhfkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCO7M8GIFLNnfBrq3wP1uT+HfcWUjeR0w9ad4t0F2uo+wIhAJHBDsP/vQfS\nWpA+Muax+duFkeROu+5/t0zZ8vDuBSKP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdrxuyvxGxVCHTtTNpdzXhPoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWU1ZGM5MC1mMjM2LTRmZTUtOGRmNy1jMjVkOWUzNWEyMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtZUZqMCzKgjfFlSvMrmjl87fegn2XCEN6xsHDRtHSJRXv\n6RIK68T0ZbJYcHlMwl1XcHMelji+6k1Ays9ovbsAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX+5zE6CtJSaMqPvJ4PvbL0TG\nhfkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMk5NgV2HMrZPUpZdzlrOoyofS4s7qr0I2Dbd61RdbL+AiA2Cbt+jAA9\nPwY/4yagtK6UQ40ArRpQlz5jU0J3Ngq/2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATd1kO41r4/sUuUS71SsDX7gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjcwYTU0YmEtZmIwMi00NDYxLTg1YmUtMTc3NjY4NjYwOWFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdjZWY5MmJk\nLWYyZmYtNDZiZi04YTUxLWMyNzk4ZTg5NmI0NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEGTxqxfQcyt2cSp2ZRdoWIrV/44YYWX486I7gquCpqDnpTCMjXMAoJh\nPLYZKBZRPNFGLtoxwTLBx0xuhFhRPJejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP41rs8a\nR+vilsG1hbn0+D5qPBRWMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBpVqW8KwkoWarSkJr05DyiPOK+eOYpSuFBePrU\nYo1q6AIgXJJ5wAQd/Sddo1D4OcbXhzeyhCc/EoUyRXc7pdVD/Sw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1407", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1407` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAV7qWO+c+RxVBE3ALweB1FYrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMjkzMzkzLWIwZjQtNDM4MS04MGZiLThkNjNiOGEwZjYxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM4NDVlODEtMmEx\nYi00MDQ4LThlY2YtNDZkNWEyZGMyZTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOmNiQpFQL0CY5p7E0IXGFDTFPiVJ0KgRRrLI2zKeKA+iA9NpxN98GnLmTsff\nI2wnR2PSj+6M6B6Qnw/1mEPbj6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJDelOjRxwBa2KF174ZQ+0jCzgIkwHwYDVR0j\nBBgwFoAUyeoeZWO0gb/EhHHoSBDU0sQbCs4wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDXd5UQUNWiw08DRZZWhqB/BRr8iCP7s+pMGY4K9O5BKQIhALUGngCShX9X\n3Bw7467EyB52EUUtBkioq0WwBMwVikzf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaO8ZYwHQDB8kkxppj8aU+HPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDI5MzM5My1iMGY0LTQzODEtODBmYi04ZDYzYjhhMGY2MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ835/CiL6pr3QDyVYcULV7Yh0SCRUjMrP97mTgUvndABYI\nZHZlPsfKRUO6p2P/EFkqUvsieVtgRwRkM+WB4Ga9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyeoeZWO0gb/EhHHoSBDU0sQb\nCs4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIOe83FhWPkbjVTB1U0ezz6MCy2ZziMMNNzj55QQ7DtsCIQCNiFq91wb0\nzb2/3MgcGoOk1mbVXNDpkfvgOqDUSApCcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAdDp1nksft0zciYuqVU0MZOMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM4NDVlODEtMmExYi00MDQ4LThlY2YtNDZkNWEyZGMyZTkxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIwODIxNWQ3\nLTY3OWEtNDVjNi1iNmIxLTI0OTQyNTJjYzU4NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLyB32acUq2eA74yhHFlwjpl4QpyGQpr/EoHZJJ8XI25dqPYZdkwzfqd\nm5FbvRbtQr6o7QInFarkiRcIawiiDVSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCQ3pTo0\nccAWtihde+GUPtIws4CJMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA9fIypP1gzi1saevtf2kXygaWqC5gLWYmt+g0\nbjIFhuICIQDB7nHtY6aHZ65Bw5viS7x2c4mEGZuJi6vgF1TXdFYR6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1408", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1408` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAfVN7YW+Ra2lcrRXRsktWYDaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkZjg0NTUyLWYzOGYtNDA0Yy05MTE2LWJiNWIwNzIwMmVkNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzljYTdhMTQtMjQw\nZi00NGY1LTkxZTYtNTJjYTVmYzI3NjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEONOses0Yjj9BQ9nhXzboBH8QGGoyBLBbkOmVDnVMMJpxU26ZLgJ4D8iKtVwS\nLKyWPAaBPC4UI5P4dvHoTQ9qu6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1/tugm9oT3mtuMfKh/+JikpBIdAwHwYDVR0j\nBBgwFoAUtDqBtUuOh/hkTF8yn9kVhgFdy0MwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHdi\n/LlTAu4e4LPSGvhWEaZBa6XaDlMkMnZY7WXEO8h/AiEA2O1rc97cdmD+sAvXBqDI\nccV4kWAUnzd/sFUy1+Hn9Vc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa6auXKh2LmP/Lid6iBcOYahMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZGY4NDU1Mi1mMzhmLTQwNGMtOTExNi1iYjViMDcyMDJlZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJn2NWzsdkU2OrOsa8hGAy250JGfCSvcXMGZP1bHt7uicE\nlTo/2U59AJ7H/6qRyCjDplnik3uqbYCnwDGXQQuUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtDqBtUuOh/hkTF8yn9kVhgFd\ny0MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKKFPIpdAOkrfHuyPpKKnf0IGzN7E6+4BfzQGT2kzU2zAiEAyBUR6//k\nghp7wZNTaiyEJfJBWhHejWBvsvvFL6AapV8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYnmwpdaUigg2OvW8YsxtYvKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzljYTdhMTQtMjQwZi00NGY1LTkxZTYtNTJjYTVmYzI3NjkyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDExMmRkNTlk\nLTE4NjMtNGE4Ny04OTQ3LTY2OWI5N2ZjZjM1MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOr6HHSGGpmXcQBdxFb0z3GRR/G0q39qEY4o7rP746iTjxibNU/Znrti\nSCShUzePjEyzrJCo8AvDihID/dl+ADSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNf7boJv\naE95rbjHyof/iYpKQSHQMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiA/+jhoYNXqcbw7LUiHB523ss4xN4M8DiyVTfH0\nkFFZCgIhAOzFmM2aTmqlx41C+4orAQCEAo00AJSvJO5QVCYfhcOz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1409", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1409` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAbG4bUsYvNkjqFemO5amBasmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NjY0OGU3LWM5YjgtNDIyMi05MjViLTcxMTYxODA5YzFiMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODhkMGJhYzgtMGQ4\nOS00OWU5LThhOTQtYjNlZWNiMmI0YWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEke+gxm/bRwDK0zJJagcHoIMYMzTOBtx89TFd4FnR9ldDfpJ1N2FY827OWx9f\nhzRgzaplB3px52pUMUPsHQ7VjKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdHJdOQrHCrLvyfoW0KS1EbhjTqYwHwYDVR0j\nBBgwFoAUV4A9lsc2i8vrjjSXC67Pm5ptefswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDAiclz3jJGt5xuX4eYOYdi3nhVVIcL5trocXpvDRS0JgIgf+0H\nGADSCSm6aMVMig2/GOw1Ge8xCVFBy3a206zpV84=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAawMRfhr+NmUCIAQfbfrOF5FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTY2NDhlNy1jOWI4LTQyMjItOTI1Yi03MTE2MTgwOWMxYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPQHXbMH6D0PlY32UUqZta90gNqQ+x395uuvufJ4i4ZE4/\nOCtQB9qJLvGdFbBV6X9Ov5PunrFZE1WLK91I/fFNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV4A9lsc2i8vrjjSXC67Pm5pt\nefswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPm2GDyDPuHHDSZflKQPZW8C9gO+YSYC5m4mys5gevhFAiBVmg0n0Zcz\nkPa9emclKXK4X1parVXvaJ90yBj9WLtzvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUQZfjYmjXvXwHOlexzmCKxCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODhkMGJhYzgtMGQ4OS00OWU5LThhOTQtYjNlZWNiMmI0YWQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY3Y2JiM2Yz\nLThlMTMtNDQ2NS1hZGUzLTJjZjVhNDZiNzFkODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP7z5o8vtPd+lsiN6lR9cDWkTzvj/wbTxaAVixF3xkY1qOXUZO1gJnOJ\n+aRkiUjBQqDezIAkydQoZDiSOe76KPmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHRyXTkK\nxwqy78n6FtCktRG4Y06mMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBg2gVDkoBQt36Qducv7v6FDNtSp2B85TI6Sqc5\nYCyuxgIhALDLZN3Dk0r5E1yiTkBuF/ELaQhTubs9/TWAbJFr0KOH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1410", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1410` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAe+K13842FENw9eMwVRdKUW+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkM2JiM2JhLTc5MjEtNDE2ZC05ZjU1LTVhMDk4MGE1MjExYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZjZjM2NGEtOTI5\nMy00MTY0LWFiZGEtNTg2NGFjNjA2OWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFO7DU9ZpLxEazjB3+abJ3KVfWJmy+0pf0vWuAJQf6ucpLVuoXYWcq/EXZ4fA\nU4XBpv4y5YiAbH54LhhpKXmvqaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQD8UCVZ7tHIR/5VPSZFVaRwhsGIwHwYDVR0j\nBBgwFoAUs09ThqvSu3vRsAPUJB3hVF9INVIwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDK1+MdE3RhQCzyD4FqhGajH9GkBG1G+qw6sRhRkJN/tQIgTgav\nZDJjEcIP+/yDQ5xTCBXPW7KzRLgR/8nUI9FQQ58=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeMN4jlfaStmQeNstcE9way2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDNiYjNiYS03OTIxLTQxNmQtOWY1NS01YTA5ODBhNTIxMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLGQ3V72bA8Gd3JpcXooVqJyU70AI/zXPb5Z+92ZtZPBFJ\nDVfB0YDR5TX0dwqDHdZ2QIVANl9AFD5xOxDe890zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs09ThqvSu3vRsAPUJB3hVF9I\nNVIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKVrEkIJvke6XMCifG6Mtdfc9ZL4THSDL8aAb90GUBAUCIHqFsUEyw+Ec\nx/vhVnVepxlrdNdph0xnjxcC2E8DYBZK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfagd+2k0dhesdgJ6PUG1EvhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZjZjM2NGEtOTI5My00MTY0LWFiZGEtNTg2NGFjNjA2OWQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMxYjRiY2Rh\nLWMxZTctNDM3OC1hZTk5LTYxM2YwODFkNWZkMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNNGwSjk1geEuiRDCrOAksfHILvio5hELuMaIjGucfkeEdldTYB4gmif\nnf/uX+6Dep+i7pNMfbMOLdGhhktZDYajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEA/FAlW\ne7RyEf+VT0mRVWkcIbBiMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiASqWo3bCHEMugJqQ2+5IYOfUH/k6GdbVTuW3Px\n8aQgjwIhAO03idmU5bbv57fESKZNMa95ShUkTdCUOgreF+dV+xeG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1411", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1411` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdCiZ+uHO6MF4KXK3DDHPPi2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1ZjE5M2QwLWVkNmYtNGExOC05ZmM0LTcxNzMzMmJmYTc2YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmEzN2UyYTEtZjJm\nZi00NjEwLWE4ZmEtY2YyZDE2OTI2YjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ/GtB3lOeIM0CYXECt1CBz4mUr+++X8pjivs9DvAZE7h7ssTF/WRAo59/JGr\nLabYLO7DaW5T6RkOflYOT6dHs6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQjl6R3gjq+69N5ys06JMNEQ7U8oTAfBgNVHSME\nGDAWgBRKZ+1mzrAQuIuuJ4PZFXTpcVXoPzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIC+SQT09X+PKIjIzn3+x81w3aPSZnecn\nsGqAaTVLDNfdAiEApp3VTc7t/IZbVYWLpnTcw0CB/ZLPVqmXrfK6QSVh7fc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATnGSPZWUHVbkbbOdmEvV18pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWYxOTNkMC1lZDZmLTRhMTgtOWZjNC03MTczMzJiZmE3NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfnNokQ0QvK35Of8oWhdOB9FaFf+XbgTTa2t969nbLCDJh\nkBdDBBnmN53efO8ZDrDs4i0OfQs4TojgCWw5fBmfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSmftZs6wELiLrieD2RV06XFV\n6D8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPY+O8s1van89otL8aKFNKvY2ymSbL8r6KtAtDwJH1DwAiBplQ68yj12\nupOdW8w8Dm7H+MNl0pHRVEueaIF2Ssf5eA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAaLjSMZP1O9Z7fHUlBJ19ZPZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmEzN2UyYTEtZjJmZi00NjEwLWE4ZmEtY2YyZDE2OTI2YjU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc1NDZlNTli\nLTlhZWQtNDlhOC1iYjYzLWI5ZmYwNzgzMTg5YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOwtK7G64WVZImi2BTDPuGWGmPKnHaKGFgChFwZYUff9HraKUmM9Bpei\n9iXZfsjDnzKoT6QqxSK1qDZW8bEi+R2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCOXpHeC\nOr7r03nKzTokw0RDtTyhMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAfOTFc7x1VyT5QobayPq37G1FQ31oQh1MR8jrc\nEA7YHQIgdnIuqJdQVNOwu2OHpvVLqPRklno0gX8wi4LOKNsojdw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1412", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1412` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZCZJ++CeESNWxi+qSa2i1vHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2YTVkZGQyLWEzMzEtNDRiMS05YmFiLTRiZTIyMWRiNTFhNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY5M2M3MGItMDNm\nZC00MTMwLTg3OWQtZmM4NGVhNDg0NDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOO9ej8jFGPGHgZykSAQ6dqelC+3plJ1ym+uhZByp0GmQIvjYbrUVYdNA+lQw\nS7MhegOwZpTr7JS+lHp/FhaFvaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqDN7hTpk2uT2JKdj78aQ/usXKBEwHwYDVR0j\nBBgwFoAUq8OF6HaEN1Y8emD04Q5LDDFEFYIwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDS5GMA4g81A\nwACBcpqOJKycWKq2dCuRBxjS1QAR0l6zAiEArapt/Dkgi1TG/SbZHMMdAHqSwVm4\nnXu7OTujBmL75vs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASTI2XUH2eAnm22S+x5stxf1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmE1ZGRkMi1hMzMxLTQ0YjEtOWJhYi00YmUyMjFkYjUxYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOKM/SAy0yc3wqA/VbKxheCgIDftfvU2E7EW5NWDJuxtum\n0A0SkmnrDvOFIgMYXJVjIwTIXcbo7a1QPw1pDUUoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq8OF6HaEN1Y8emD04Q5LDDFE\nFYIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPNfwW0j8WpyvICmwvuSFcNR5MXLFQUiIN1WrZyzoUoUAiBfqxLHotnw\nAmZiKAp/r2zh8hSbmhAHvPsp0xklUsUcsg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYGv0NPyfedY8XehT7Wm1XpfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY5M2M3MGItMDNmZC00MTMwLTg3OWQtZmM4NGVhNDg0NDU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBiNzQ0N2E5\nLWE4MDktNDU0Ni05OTA1LTU4ZWFkYTJkZjhiNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMxXdnWYG+BHWZpVd7buBQqpwSe5L6zV/AqgIJGmGUriaG7te3BthzpO\nYgygkflAzqAewJwF597Fnz9Ah8duZL+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKgze4U6\nZNrk9iSnY+/GkP7rFygRMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBe/B9iFbVEPtcjIs8f780OpjKCsH6/welhPvxp\nAgftVgIhAI0zkrp9hv38iIOOZNVOmtHlvMYuwpiWHbxB9rvxZBEU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1413", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1413` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISASsZUsZ2GjNpWbWRYo0FKtfbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1ZWRkNzg4LTliMTMtNDgwOC1hNmU5LTljNWVlMWRkYjc2NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThiZDQyNTItYmNm\nOS00ODJkLWFjMGQtZDU3Mzc5YTRiZWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuwMC4irEiTzD9lkQnW6Bm1rVVb/mAm9an789woriBET9YsoPbSW5ItR2/h87\n5QmrY26S9VF6wrRzmvtwgrvWAKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ4IqFxaVZ7cv6/Af5NcCXKV9oUUwHwYDVR0j\nBBgwFoAUWq2D7DIlFEa9oLu4IGPS0zHzSNQwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIDFoXT8YcYCK\nbO1XRObUrTVVCrcj20+OLJlWSidIGdrIAiB90o6qSe30nfZg4whGqr2+F/+t/q5R\nyK/1T60dQA4f+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU/AG2b8uFKTOrOYBr9bJYQ/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNWVkZDc4OC05YjEzLTQ4MDgtYTZlOS05YzVlZTFkZGI3NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvl6lMWkJIYMpW3mghNcTDTPX+QP1Q/0POGtJObBbKcuME\nmXgTQ9qaQouJhJm0dscCk2O5ay8HQolSNNToi9r8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWq2D7DIlFEa9oLu4IGPS0zHz\nSNQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLwTgLMYI1ppm5xjFPGz1lZieeqJcqVJugRa/GXsoFLoCIFpeW9V+N0/y\nMoYvxvP1+/0O4gYarlyxJOIn4rGUpjUy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQdMbmwvc69Ne3rvizUkAoUTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThiZDQyNTItYmNmOS00ODJkLWFjMGQtZDU3Mzc5YTRiZWNmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUzOGQ5NGVi\nLTlmNDQtNGMwMi1hYzFlLTU2YTJlZjc0OWQyZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEnkEv0NnHqiPT58glaDl5Ws92YZGPLKD3/AJoBqZGT+xHWR4GYvPkVu\n7H8ZeE231RAcUd5hZqQcp8uKfQ4Np8yjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEOCKhcW\nlWe3L+vwH+TXAlylfaFFMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiA8d4VWN7D00jarDmJkexTzErv+VqiM//5B9/PG\ndVHzfAIhAN+twP2mI1ZptLLq4R2kz1S5uGGpWgtguCfjoxKnezJl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1414", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1414` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAVhtoZgzP+TMyWYcMfyAhvzCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzOTExNzBjLTkwZDktNGUwNS1iMjM1LTQ4YjlkMGRlODQyODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM3YzQ3NjYtYmE0\nZS00NGY3LWE1ZDktZGRkYWZjOGYxZDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg7JkcYQNqACnrLfMLtxrQ2LyzJOpoAzc240+ocv3QfJc4e888UwFO2koQoL4\nTgb6yJ25lF00riyIN1kg6DwxT6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+JVt4XzVlds33jdUGgx0XbZ0ie0wHwYDVR0j\nBBgwFoAUFDKYHEWcj6gH2xl1URplJeTy5egwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiB0HNrz9x0F\nN5VydWPdQJ7telPg9BVOryT2cn+eJaZmPgIhAPmcCl+EAUsCwx6zuhbyXnNMdon/\ntuAqLNIhzYCEcPha\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAakhaaC97uRMvzgPZ4tOha1TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzkxMTcwYy05MGQ5LTRlMDUtYjIzNS00OGI5ZDBkZTg0MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7ioq80/7EFvalQOSGSxiUnHklnJbWXwZIpQzpkac2feQb\n96Zr5I/e7aRq9zLRRJDo9F14D6994BWUkizkc25do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFDKYHEWcj6gH2xl1URplJeTy\n5egwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIge67Y+/x1R/cknfmqL4AyDROkWsJns0HQyETOheHVh5UCIQDSC+btysE/\nHiQ+tW/F+oH1588fyP8zDLtBJmb5Hv+U9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZL5Nsl7vMbB0r3H5nOWM7BDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM3YzQ3NjYtYmE0ZS00NGY3LWE1ZDktZGRkYWZjOGYxZDc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNmZmEzYjZh\nLThkMDktNGZiZC1hNGY5LTcwMmJhNjdmZDZkMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKbFmqrUdU70KLsRFzZZJ0BU2MoCdaA2TEOF2SE4H8QHDdug6+xi99JG\nBigsTXNK9fqSrjhJ99i9IqydsBKWzYGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPiVbeF8\n1ZXbN943VBoMdF22dIntMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBGaaG0l5bagZgV134+FVYGxsDCurd51h1MQM5e\nfMBWAQIhAJg/DLXiUMVINcOt2y0c470lgrwUp2dDfYjnCEqV2tIu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1415", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1415` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAWw06wYcARtRR29SazkzYcwDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjYzhmZWJjLWVlNjAtNDcyNS1hZjI5LTY5NDgzYzJjMmU4NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmEyMTBhNGYtZDY2\nYi00NmMyLWI4NWItMWMyODY3YTk0YmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuknQc3GG4uSp59Z2soRRfzM02HUDcSj/KCrQYzREY6M0bu9o3ljsAZR0nhw6\nX8MZjYe0LbdjiOfgVE+XMPRKg6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXlmX4FzQJ7gxZCmd9X3xns9+9LswHwYDVR0j\nBBgwFoAUqUksY5JavgmF2dgGpMflHb1nGi8wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA9zumjRz7nRVpuiCecrfCrTf/3h9HsPz244QUcScuihwCIDX83NwxF+h+\nu9g2ItZwzjRnLxm/XFJnOPcAhghEwGPC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARE8uwE8zI/4H2KWTX36X1MLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2M4ZmViYy1lZTYwLTQ3MjUtYWYyOS02OTQ4M2MyYzJlODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUFCgDS+xGCcHrcXe8Ly8Y7OpB1vX0bWJhDOLqrVvyYnFF\ne7iesnNBrgh993OKNiT6HTS3SggFDp1doOvsY+Dbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqUksY5JavgmF2dgGpMflHb1n\nGi8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTN3JlCETJODikn4BW2UMnK48KMMLXBZdj047KSEGXxACIQC2Hi+e/E7L\n9jT5DUyJlKPmjwMr7yVcQffKnqPuE2nzdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAekOHe2co+0GbdX7O40VdXGuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmEyMTBhNGYtZDY2Yi00NmMyLWI4NWItMWMyODY3YTk0YmE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgxNGY1Y2Fh\nLWRhNDktNGZjYi05NjE4LWZmYjAzM2JlZjYyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPHiWxMCDygmEYBtWxcWnPD17K4IxsApXPbE76EiXjuPIfilLj5dWABk\n6dVORMwhpD2Qfbjkwt9KHGBjPPXZEIujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF5Zl+Bc\n0Ce4MWQpnfV98Z7PfvS7MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAypuAfRMk3vQL5usJXdL9nkpEOOVT7ZN0jV4x\nS1kjVqcCIQDxZlJXZJ0itUMvTPqA+9bQONR/Z7njSYz1MmwLqe7pRA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1416", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1416` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAbX+DoC+6VNmVVAUppdMy0AaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MTU0NDA2LTkzNmUtNGMyOC04MmFjLWQzYTkwNDA3OTlhYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZiMTQ0OGQtMDYx\nNy00MmYyLWJhZTAtNjUwNWY0NDllYzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6tRHgw43pfCagWZUPxdq90Yc5Jo45O815L4FTHhOTqPlPRCLroN88E6zzmuL\neSFQ/oVB8Nu+NwJAEhGGPKuCT6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi2mxwRSvfSeetMJ5o8x5aG1N6NYwHwYDVR0j\nBBgwFoAUGkI90cqOepcB/e8H36w5Qkw4weowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAeH03qXH31k438JwI2yIFyHSt/uid+6Wj7smCb0aWb0wIgVB/sgvRZNp9y\ne6PiUPZofsqpagN/WcZRwF0mCvQm9cE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbxigJyyE9G9O/ARnz38QBWfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTE1NDQwNi05MzZlLTRjMjgtODJhYy1kM2E5MDQwNzk5YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZpc10Sw6z2S42jc3zJI955wl4Hckywt0ZMfWyha03H9wQ\nRpdPFdp3i+lZjNcTrTl1/ly//mmvif+/+Y/JIgm6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGkI90cqOepcB/e8H36w5Qkw4\nweowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgInOF8kOteAzw3hYJmrzoata71C1AvV8xbJfnIHSlTiMCIQDCcmsyf2d0\nmvHspgT6ALb7Qql+9wDkDK2EigAO5ufllA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAXT6OMvIbUZ+Hke8ltitT0n6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZiMTQ0OGQtMDYxNy00MmYyLWJhZTAtNjUwNWY0NDllYzYyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDllYmMzN2Jj\nLTY5ZTktNDY1Yy1hMmI3LTk1MGQ5NjgxMGQyMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMKOS+qbm3z4w/y1aaPBsJ3iHN6EfFZjI5Qzi9HFb7Iu3TV8hqUemNLs\nLZos6MlYqdPaIubYl1ImVPeyjsUxS/yjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFItpscEU\nr30nnrTCeaPMeWhtTejWMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBG/jYFdWGTxAg9cwQP7s27D9Acu2BueqM56t+O\ncUTplwIhAK6t1iakMOR2ENp721qm9ikmj47Z9Z8AHhrUZrjAC3As\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1417", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1417` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAaWwsnNJRAw0sC7ryhTmZe6JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjNzY0Y2M5LTBjYjUtNDAwMC1iY2M4LTQ5ODRiZTI0M2FiYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM0NTUzZTEtOGM1\nMC00NmJmLWFjNDEtZWRjM2VjYTMxNTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuJGsv1tXyZVBPA3ZHiGJwryReO1KyjxQ3BMjZJyqGjJPJa/w/NHraenyaovZ\n4RT90EyJyt19DVKr6cqO4y1AsaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWXHInc0EjNka+nAtrR4wmzMtMTswHwYDVR0j\nBBgwFoAUiCz74Y5QxNA+wf5/GvBPQ6zmaJcwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n84C9TR4mFRkB/zN8N9x4MPFtamaV1B5G9h1Dxy32yC0CIHYwjednHeFS/43E0Lqg\n7ylp6Qax9dfwjoPCPoGTV8ph\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUWWy6Kur5WzKwUfWWduFqN+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzc2NGNjOS0wY2I1LTQwMDAtYmNjOC00OTg0YmUyNDNhYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDclsWeBwLaa2jG+kPJ2cj5K1zgiXuRFwiuePmykrzpeAp\nhGTmqViGcYOdjkg7ZBBnZZtYNnONoj5nuIxFzur/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiCz74Y5QxNA+wf5/GvBPQ6zm\naJcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIkaER6hMD8iNvl1iKJ2uZB6uQDE1FHpksjp0GTBQIXgCIQDH1puSCJGd\nV+bA3DN6jJ+ueFfernFjUmDQ6Rew+hnKPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAS74ELeZvwjUVput2oZ+RW2MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM0NTUzZTEtOGM1MC00NmJmLWFjNDEtZWRjM2VjYTMxNTdiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUwODRmNGFj\nLTc3MmItNDM0My1iMzY3LTNkNTY1MDA2NTJhMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPlgum04PmcnRWQtQR+xosq7B1CWGAM65at9hcHbD0kF5W7jceKs/mxz\nYgIgAkTgVSCUIYSoHIjxJB8TgirfwYejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFlxyJ3N\nBIzZGvpwLa0eMJszLTE7MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAtCSXRs4QyrtXaoguwi30O7gbf48+wbTQcP2D\nsiVQOIoCIDScJ0yM+fr7ye8RZb1mcSu/76HuW0pPbePZMYuFGDvX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1418", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1418` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAfZe2uhmMU8F8pcCejOtYjUSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2ZGE0NDRlLTVmMTktNDkzOS04NDVlLWQ1N2VmMTk1MTRlMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY5NmZlMWYtYzQ4\nMS00ODdmLWE5MjctZjlkMzI0ODliYmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEepLMHUFowJhitnLeGxp+s42P/rLsIb26Xid8fb3HGTeUiIRIqXphGEHOSX3e\nqYcqoSKkiDp2SX49EUUK51fkkKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1R/45AZjSxMIxNFlGN6IfpJUj1QwHwYDVR0j\nBBgwFoAUERBeXp81WIEqw3zV/MlL2KGfAoQwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAxiZckYgVqjuB8Xz5b7FZ7usF9Vtb04k9ixxzri6omowIgP4pQ\nMWNVBEw3dutkr/cvlRateHkQryfjUBOErNqYP2k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAddZ+CTwzqcCsrLvYYiKuTJYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNmRhNDQ0ZS01ZjE5LTQ5MzktODQ1ZS1kNTdlZjE5NTE0ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMxiffnjNyp4k4wj5HMY5RfwykmhHiqIHhEVcNaxb4LSr6\nO40Bqn93TUJndK0DrODCMlEnkDfGq34+mWKvqzWQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUERBeXp81WIEqw3zV/MlL2KGf\nAoQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcCVH5Dw9rjIibqJ24L1ZG2eioa8TvV91iabQVeun6TgCIFT7uzZUaY6H\nVLN4LwwE1uOjlCt+5EvMxr9NbQV/FqLz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAS7uS4cjF/SaLWQDoy3Dt2mQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY5NmZlMWYtYzQ4MS00ODdmLWE5MjctZjlkMzI0ODliYmMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ3ZmE5ZDI2\nLTFkZWUtNDFjMi1iMzQ5LTJhYjU2ZWM5YjA0YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBwOWMJcMHUhnhPim/BSRgV7FnxrOwd2QzamI3qgN4V9+T/6DlfoBaI1\nIneysL3oPvaOeCNE3FDWpi27znq1TJCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNUf+OQG\nY0sTCMTRZRjeiH6SVI9UMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiApwIDd2LIY1CjVkILAGDdqTWXwGdyp4bmJYBz0\n6Ua6kwIgObZX0vCZP64s8Fbi24cJy0UyWI7uJGImkEtUiMumwNs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1419", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1419` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAeabRfsxVzcF4Tdh90wSJ7EBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2YTUzMGE5LTUzMTktNGQ4Yi1iMWFhLWI0OGQ0OTgxMzY0ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQxZjhkMGQtNGU1\nNi00MjUzLWE1MTktY2UwODFlNmFmYWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYZ1SCP1O5VY7JYWtbglsnwiSaSWzPbQ9SbCF4lTmmqMgzK9M7C0Nvds3BDc9\nBjZa9CroWJVoWj4HAnZUjeVmH6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeRKWLiejXk3JjlEpc8PPwVxI+qwwHwYDVR0j\nBBgwFoAUhS8e0LtLuxn5sJCQHJvYZfGanjcwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBX3OvCuMFsFzPtfB0VORPNkega+FfRqni2LY/1qx0rVAIhAKiJ\neIdxUdebBxD92qIWDOap0lukKvWdPCP8tjmAXtwL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaGAxSM3SCjUkoEVo6j5ej2xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmE1MzBhOS01MzE5LTRkOGItYjFhYS1iNDhkNDk4MTM2NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvgi2mheVxvqd7r7S6whLA0Xs1yA7fxIecCN1cADxJYdry\njdo7uNS0H7wd4IHhxDP8ZqYZxgJZmKZvqmqVQg96o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhS8e0LtLuxn5sJCQHJvYZfGa\nnjcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPU4odD+WRu0C5sop7iMvmU88yUTnNRKtT0WU/tQDvBECIQDogrLAat+R\nfV+S2rRlZCUd73T6KNpmUyWJe9ZaNNVp3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAcUr5T6f3FjyQAf7ApTfIFrDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQxZjhkMGQtNGU1Ni00MjUzLWE1MTktY2UwODFlNmFmYWE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFmNzYxYTlh\nLWZlZjctNGQ5OS05NDQwLWJiNWI4N2JmMzIzYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK7knIqcX4YKo0hNAz7fRmQUGi268GSYNXgYiVRVSHAsVK423b+DsI7R\nsM/w0P/ggcWci/W0eybpRE8hg6wBLdCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHkSli4n\no15NyY5RKXPDz8FcSPqsMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAwNjvF9GMD90NGoDDZk79b8BmojDekI4ihp9F\npURjL9ECIQCZWZvtoO/lAP1SZeB/3vBTzil6N4Bg3qKwWKhMNo6xIA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1420", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1420` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfWc2LliVnEPDqT3etgW3uhPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YjcyMjFmLWI4NzYtNDI0Yi04ZDJmLTgwNTliMzg2ZDYzNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U5M2IyOTMtMjYz\nNS00Y2VkLTg5MjQtNWE0OWRlMGU2N2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYkPKp1LIwhim0mcfXgSQr/HCVpWzqZMeVwmT4ezbZMJX1DePxp4Q17sCSYIM\nqZstZCPi48zsFFxuSBx1alPd26OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD28xB+lUQqPYUYn/J9mX6kXlWmMwHwYDVR0j\nBBgwFoAUNIjHPrJC2e2lMElqIWOnLCqw63cwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiB3ixF0sKde5bL0\nlWtSgcWo+HovOLRnXYnthHwHKLCAKgIhALZkWO1hVUTXjQ1gINWMj5/Br3jleoFU\nMy64tKQaOqhG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeWIhUViJVDt4KzGenrB2qxJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGI3MjIxZi1iODc2LTQyNGItOGQyZi04MDU5YjM4NmQ2MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkR6ItdCa4Bx8F1TleRlVQJcQRCzY5h3KJr6gDjQAu7W2m\n57CdpJUN/idkYloaDLxgslEmhXeQ34w2L3IoCnj9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNIjHPrJC2e2lMElqIWOnLCqw\n63cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOdmwIBO3IpFb+Nm8POwpWcq1r5bvEYc4zaXS5FOoSPkAiEAnGQb2KrR\n378wPJP13Hm0MY6DZLFBkBuyf+3kUppI7as=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXvkzTZSjyGKw3sGTaq+OEdnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U5M2IyOTMtMjYzNS00Y2VkLTg5MjQtNWE0OWRlMGU2N2MyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI0YjM1Nzgx\nLTY0NTQtNGM4My1hYTlhLTI0NjAxNmI5MzVlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAr4Sef8PIlfJ9f291sQbEmPZNvYaK1Et/WWIFbYg8whXBAfaL85yuEN\nXEJdf98FvUncvQ4OFHoJ9MaqdWk99n2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFA9vMQfp\nVEKj2FGJ/yfZl+pF5VpjMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA1f5p+VkkXQXj3RnK5/SGw0LB8E14EtOMb3hX\nIKgnxDwCIQDA64MKtoADs4wgEoViHvdRWkvgrNUyQnPHFfJE4XOIYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1421", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1421` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYGV+Suogbai9uTKiPQD7zs+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkMTUzMDgxLTlmNzctNDQ5MS1hYjhhLWU4YTVmYjk3ZTBiZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjAyMWRkOWYtNDNi\nMC00YjI5LTkzNTYtY2Q0MzI5MzQ3MzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEisGVqM8oHmXqHnXnGAh5cQAnAfSMe9e5oRsb2zEStTMaq6EsmS7l9THzk+7K\nYRxw35N3Aw3C7t8IdrB2kidYfaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDjwb4rWwxJoal1jIPq500Y8jLRUwHwYDVR0j\nBBgwFoAUlQR6I11EUdm6OfEcESOszi/xtY0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFol52cDaxni0R6e5cn9hqdM0rvBLNa9+HHvqhvqtNieAiEAl8aWq8wjVFfd\nalY1u0NG65Dm5CyX6QRlJAhNoZxXlDc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYc5IWVNTXmEsM1XM/f/2PSjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDE1MzA4MS05Zjc3LTQ0OTEtYWI4YS1lOGE1ZmI5N2UwYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/wrq+ebCE8QXVgFXUYOMQOaEVvJvKaaraQ/BG7t8JHa8Q\nDjHjTpD8j8FAuZ/bHiXEmTcbTHFyA2eZVHA1vTI0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlQR6I11EUdm6OfEcESOszi/x\ntY0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEwCoNf+AOpzy+p7WuvDLQWNNZ1KaE3gizTtSaJzeQsECIGXGTiFLh2dS\n5hEZu4bFe2HxxSDTtRE8kLdXLm1slS63\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYRPO4X8AG7b07amtH/+I9YRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjAyMWRkOWYtNDNiMC00YjI5LTkzNTYtY2Q0MzI5MzQ3MzhlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY3ZjZhZTUw\nLTU5MjItNGRlZC1iNzdkLTU2YmQ1ZTA5YmY1YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN7a6EucN46CMDjiCyGEuxirNHE+ovuz1OcK/4xJ/dcN81KpmJN5Q5jg\nKsziTE3WpA2S1ds6I/xwhfQpoKf9mXOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFA48G+K1\nsMSaGpdYyD6udNGPIy0VMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAzhjrrAxk/8gJ31jwpjfZggCCKDiTvygQnVsV\nfKR/0TACIH4G5rvJMsTr4mzZdJn1N5bvD9iq1Qnv0vfbfTQkijU0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1422", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1422` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUk287gwLgBPTszFpGNZZytaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhZWYzNmQ5LTBhNDUtNGFiOC1hNTU2LThhYjA2ZmY3OTEwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGI4NmFmZDktMWZk\nYS00NGZlLTlhZWItNDk3NmZhNWIxMjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO6KyZ+mgNrLmbk7Ir2m61Qe2fuchdhXz7DhEZBMkPP+xBsmQ1EklgIYbFM6p\nXzRStI1KWjBTfD141ltDM/wtmaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdue3MLTVqOUESjP78cN2VZM5K60wHwYDVR0j\nBBgwFoAUzYTnfw5oKz1WhAf+NBhWP6p78t8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDfT0hrBdMRcFpMt6sWQ5+vdu42unf2u/ggPJp8trzZ+gIgJoovqV7uvC/8\nDm+ZoqWykO9jLTT0RAfHIBsKaOAdyNY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASyIdMNCADPtILA6t8j8kmjsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWVmMzZkOS0wYTQ1LTRhYjgtYTU1Ni04YWIwNmZmNzkxMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeIchINAxMArasg7IcZguYbpyaId1APqtIgC/4nPbRBsWq\n846KWsX/bFFP601Ykz7x31ufBvokXGvJjzJD2iOjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzYTnfw5oKz1WhAf+NBhWP6p7\n8t8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCNgMg/HZmaVqZKKYPn47dSs5ZCwsIZhKyvj1nTxvpS8CIQC5xRwaoqA2\nf4OAeGeE7ZLMHe1sJ/3eRt3cV0NaLqUyYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAc4juwv7wnf/UDFn/NSFf+hzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGI4NmFmZDktMWZkYS00NGZlLTlhZWItNDk3NmZhNWIxMjZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUyY2RlNDc3\nLTExNzAtNDVjNS1hNTY2LTIzYmE0MmMwY2FkNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAB1Rmgs12FR1vb5EB6vGU3ACcXv7L3z53iki0OsnZNkR2Eticlu6nwH\nrm0Cl9xkdU0/hs7QEl89uwc7QgeIZROjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHbntzC0\n1ajlBEoz+/HDdlWTOSutMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA5TdTUD3GCJLrJGcdLcgpp9kgctU4+fs3R5ab\nxCa1cRkCIQCOdzoqfj/o11FUutDeT2IxFae79bsXGU2/I96Ua7UaMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1423", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1423` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISARlZktSEN3Gojs5YmuZOzRZGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYjM1NTU4LWQxYWItNDBjNS05ODI2LTg5MGYzMWJkZDE5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRlMWFmNGYtOGJm\nMC00MjcxLThiZjUtMTMzZGRjMmVkZDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElonwu1/gTpeFMWWjJZyZhxHPD5EUvRdOEOEa1288hv4hTlEup+PCU0RmVdxj\nsnleRnSsIKv+iDJoypmwosBbbaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcpPFzedLf+CFq0AMIy4UxSNAeIYwHwYDVR0j\nBBgwFoAUJVYuA5kssCyC6VLYwi3uPDC+QCYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAgo3nVEiqX6TrAhjIkKuBsUUWmBULLU1JY0w1AiJ21cwCIQC9cxKycFD0\nwCGOlG8dUr6SmTHuu2/foznJyLUnB2Wehg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVdbLOkMj9RKtGRKwent7pmyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmIzNTU1OC1kMWFiLTQwYzUtOTgyNi04OTBmMzFiZGQxOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqXEiffCZQdgNO7C1/eNz1DUNPkbBSGPWbjGNF9Oo6hqj7\nwL7Z3qv09KwRnwOAI1AI+JPOy/DuA9q+mbU5ecHZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJVYuA5kssCyC6VLYwi3uPDC+\nQCYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbRHgkJK+M8Pj1Fu/fk8MHrG5DShjOB6hlK9BM2FZqTQCIQD1n09CjqUU\noA5H66BBKNYI/47y0A8YMvJ7gExqUXWnVw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAW7m9U/MUyXnihZpDduqBOp1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRlMWFmNGYtOGJmMC00MjcxLThiZjUtMTMzZGRjMmVkZDM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIyZDVlN2M2\nLTczNzItNGJjNS05NzI5LWVkNDZhOTQwNzg1YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD4uvPm7mZ9Mhl181PmSW7igcuRZk37e1ILnQQt99lWyLAyTI3INb2h+\n7mX3YGVVmlxhXV56mNFjpqIQnNaL9aWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHKTxc3n\nS3/ghatADCMuFMUjQHiGMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA+EEwwMhuxKLvvdPr2wRsqQ/AMEYDdfVgXv3O\n55pYoIMCIQCGOOcyovpQL1DinpuAZ8Xbp/rfu9tCOGiabEwMuw3VRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1424", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1424` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcR2RVEb8RYd+VONGHhCWOkpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViM2E0ZDUxLTExZmUtNDQyZS04NDg4LTU5OTI1YTZlMDkyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc2ZmQ3NWItMmRm\nYS00ZWExLTg5NTEtYzZkNzM5MmYyZjE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8s7qcFqwZk6WEaN+EWvec0WUEx6vVFeZ7h+Vsje8c2l+dx5fbcQg5JVSLC2P\nm6uY0Nc6OzUTguqjGdCE9hLBQqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCyzGqE2LzetgA7578R4kyQIVf+swHwYDVR0j\nBBgwFoAUVixLu9emvus/Spb1giMNEOh4WMswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAxLjiXCJWhtcIeHqyZCrkeo21kz7FT4yqwjfE5vr+m\nrQIhAP6vV9ytYXdNdq3X/D5tWyOlvr8Pkj3iGst5re0vrD83\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaT8aKUbrxry1YSQUIxXVt7GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjNhNGQ1MS0xMWZlLTQ0MmUtODQ4OC01OTkyNWE2ZTA5MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHTX7KE4GH96j4HQ9i20IWWsWR4yWjAMCpuHQiM55GS6Pf\nagzHHs7dWJwBfTcU8JIampQ0IV/yA3TZmuXVgnqEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVixLu9emvus/Spb1giMNEOh4\nWMswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaB4FHVI7fOIWeoV+9XaNWPspGwsKiBqv2djdUrEFGy0CIEijFkrTui9S\nu2zzp44TgM8vLapZK66h9uVZ4hOfbTIM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAd0JRk4l3QHHWpJChXGwzgw3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc2ZmQ3NWItMmRmYS00ZWExLTg5NTEtYzZkNzM5MmYyZjE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI4NDMyMzMx\nLTcxY2QtNDNjNS05ZTRlLWIxNjUzOGZkNzViOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPZnMVReMrf91VHTYqkGNiXCVZhsS6jVFiPBIFC3AeGdfV8o4h05QFW3\n0BfZ4O5RkySAO6dmSvYJB/rNKv0k5uOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAssxqhN\ni83rYAO+e/EeJMkCFX/rMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAT5eloSuipurR1XfFdijQIXC2fTv8YS3rjMojo\n3ifWrgIhAIMtwdPdFZ4/ebi9wToRtZB2nhYnYFX6rQxhp/Lr4JB5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1425", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1425` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVjhuRKQ248UPiEKOlyYD8JhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhNThhMmM2LThlZTMtNGQ3Yy05NjRmLWEwMDA1NWQxNDUxZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM5MjQyMDAtMDZm\nMy00ZTQzLTljODQtODZiMmJmOTFmMDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGqRx2aAGfQ8T9Eni7lM8Ee563q7J9abh+oEVvhj6Mc82/n8AgHpmIsAYAGfP\nQGkgB+cCCYAIwMEP4kAsTEUQw6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpFDPbRTtN25CVFZ4l3mZhGKGPVgwHwYDVR0j\nBBgwFoAURNVNv2ndk9qL39KTgWh1r2ayuhMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAt/EVnGCXUStZeg93mW5RYyMYJq1xl8odZBDyFUB4J\n5AIhALe5hNUiWlPuOuDopsbCMVBWVPp3NowfrPSCTobkMhQ3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY9d41r4Cm9IfdItUbZzC/veMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTU4YTJjNi04ZWUzLTRkN2MtOTY0Zi1hMDAwNTVkMTQ1MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQ7obEQC+aOkRgxiLQenmp1uJNy60dB5Ne1R7SO56ub9db\nxAXqVDW71otSaFG40OYNbCS0XE+9w3zBJpg8CYQNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURNVNv2ndk9qL39KTgWh1r2ay\nuhMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKDl3Tpp+8hl8GVbHtVtS6fxyAYQ0Kvpg8a3yhEa7BHYCIQCcq7YPUcZj\nJ2VLZi57Q/vAUzLnLtM2nd5za02skdlu3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAfoSOF81zumcZGBqBthPl1NGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM5MjQyMDAtMDZmMy00ZTQzLTljODQtODZiMmJmOTFmMDQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMzYzhmNGYw\nLWYxN2EtNDAyZC1hZDBmLWNjMmU5ZGQ5MjQ1ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGW3mQANka0Wb5hXWZfppBkgaRIIClkqnLMZ2Zg6LdCrAAYZuy2hOarU\nbCqMgAZdonGTCIo8+Md5MRGLXBwdZnKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKRQz20U\n7TduQlRWeJd5mYRihj1YMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAYnC1ZOGQUs4ttyyw497wtEyWdMoGdhsM4CIq6\nBJZ6SwIgeHEHL37E0E6zWN9yNqo50ibGaQ9i9ctbgTuF8Y85c2s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1426", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1426` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWxeK14b+5oPdh/XJ26zFn/nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5OWRkYzM0LTRhNzItNDE2YS1hMTM0LWEzNzQ1NWMzMWJhMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFmODA1MjMtNmJm\nNy00OGE0LWE1YWMtNDBjNTJkZDg0ODAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE38EckwF8NIjuRHvlQ8IRZiuoVZLNM775kpqqlzj4+gQRjmIAi45/uixpOtO4\nK+qCeomfn/ZGKOm4i/0+okLMk6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUffd6UXI8+0Jnj55v34tVbNHAq30wHwYDVR0j\nBBgwFoAUkk1E8WieoMH4lHqXjp3aUtDahX4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBq5pTnSdCwwFvT1PYgWvmYDEOCxk4ukvW7nCj5ku6S5AIhAL6H\nTxNB+OGMZjmXcLcAFfUYxwA+YddnITNQEZK2CPfa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR95BuoYYTOud9MiRI3BKOq+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTlkZGMzNC00YTcyLTQxNmEtYTEzNC1hMzc0NTVjMzFiYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQE8Gt058EURu5PZSj4jFUA1OCeLmNXy2hlMTpaY8EKMmMC\nKWFa07jCb1dIIZpEq+vhl7GNjaxjAjX5V64MAzAFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkk1E8WieoMH4lHqXjp3aUtDa\nhX4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMq64+TYeiJfJKq/RhuBzwRh2yBJxEQbVh+VOdysls8GAiBL84hbhg3E\nSU/k9HEF9WjMTUqF2U+UGaJ4Un0wOV2wew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISATCEcBMBdLEwNivFFTsRsmdaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFmODA1MjMtNmJmNy00OGE0LWE1YWMtNDBjNTJkZDg0ODAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBhZGQ0Zjhk\nLWQ4NGMtNDQxZC1hNWFkLWVjYmU0OTg3YWMzYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHEX3U3DhQVN+TcL9SCefQULgFx0++F+Zod3M2OcHIkyz/yIdaZZtsmh\nzGJfc7Dc+KE9qoNJ7flYLD40b1KS5OujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH33elFy\nPPtCZ4+eb9+LVWzRwKt9MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA5hvCadD4xRY3nZN+dozd8xZ/AY3v5MyvcbaP\nnxhuquECIQDfLzLXRpoeLSswjRKWswfqPPBsc5Us79E7Y9rO8Q8XoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1427", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1427` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATulA1d9PmaUR/2D/I50+GBiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5NzYzZjY4LThkM2EtNDE2ZC1hNGRlLWVhMzY2NzJhNWMzOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE0ZGFmN2ItMDlm\nZS00M2E2LTkxM2ItYzI5MmNmYTliODFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExJu78/iUNfZ3jryAc6XNbvFLQ8woMiB7XB6LZ8WrkZQOtVbqNjxSPd2xunGn\nVHOGRHHX+0zVJvDPp292g0wqL6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcVCOKDFybLY/raC6ff0MTm9EdlAwHwYDVR0j\nBBgwFoAU0/H6BWYxqC5V4uw3tUjtI77t+KowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBT17n0/+UJZzYyy4eqNg3w3em3rgc9WgCB\nnLX+9qKPEQIgbzjIPumK5dRoD50Eyh7Z3nTB6rGG2eakxFQszowKlOE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYYNMYjy6ZyTV5U9xiEJFjlvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTc2M2Y2OC04ZDNhLTQxNmQtYTRkZS1lYTM2NjcyYTVjMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzKKNGHuxuK6gy8r2ZUKABE9Rzm12VhzgVOS5v+3yti0Uq\n1R1cg1xpkPKBgxMaBd73yV14b0kZzQGul9VBE8sio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0/H6BWYxqC5V4uw3tUjtI77t\n+KowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMs45cEcGWCBwkyTpSiV3fEnZWFbxJWgIUsIYIBczzJNAiAHdavRf/mA\nK9i0uQ92crZPWftVqbO8EJXLd8Cx5v4+Vg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARljIXH4d62WdzYxgCk4memjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE0ZGFmN2ItMDlmZS00M2E2LTkxM2ItYzI5MmNmYTliODFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUxMDNjYTAz\nLWIwMjQtNDFlZS1iZDAzLTJmM2Y0NGE1MDQ1ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMU/Iuu16sZzIiVfAPTkD5AVDAjO5JyDnlzFV25L6wAOcEPyeLFoANny\n560iu6LnsJJupeXWi6TbT3pktqcyORujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHFQjigx\ncmy2P62gun39DE5vRHZQMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBRtk7qO0esE1JlKEPoyx/vTpixllZPYqlCtTqX\nqeLLYQIhAMBZhHZD7ry/jAmS2Kk4OeMurqHWc3D5k/yP9L7ujRqF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1428", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1428` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAa56IZ4eDgzjrjGnEyv/wSLKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmOThkN2VlLTJhZDgtNGNjOC04N2EwLTQyNjYwZmJhZDY0OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ0M2NiNTgtOTg3\nYi00OTZkLTg4YjEtNjdmODg3NjNjZTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDv0xg00laUtRR9l+cMFbQHXnuDj/DhOhyNOg1aT1Jo/+rO0PQkTMHqGbkSfd\n09IrtnDHtyAhc5IPlRt8xhfR8qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUidjxu5oCOOY8wsPBjeTnz/pzQfMwHwYDVR0j\nBBgwFoAUN9+PI9uP/G8VowvHVqKXfwKXFT4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA5xkRjhe6x9MgdUrI2t6z53zdCxve/XUD\nbudfhf3ram0CIBsQoVvv/ZBzOuhB27V//W0i+KvztjwuDu17RgYZMZem\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ9URWOcjGUaFJPEkDgRAktfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjk4ZDdlZS0yYWQ4LTRjYzgtODdhMC00MjY2MGZiYWQ2NDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/Y5pPfBd8i3jjx+t6QGmloWiF3ZMFwEhS8QDX5I0omRtj\nYGll6nxQ/sbPPoq28fDZSe66U24gb9JR5DpIhbOco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN9+PI9uP/G8VowvHVqKXfwKX\nFT4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPR0BfIh34Pfn2CrdkyEWlbSOahdCKr/Yz9lbftSrIJcAiAZr7Dob92E\nqWXiVW5AVwWtHAUuqWM3vR/uFA7nccuy1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAf+817iayASMAuaXSvkmrOQpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ0M2NiNTgtOTg3Yi00OTZkLTg4YjEtNjdmODg3NjNjZTAxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcxZjFhOTk0\nLWQyNDEtNGJlNC1hYmQyLWZiODg2NmMwYTA3NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJGSI+a9MIi9VTrCZeczepjP0lpA31Oxb4rpxJXbhxn3NWN4bJ6ZIXsk\noSK97fiqW431HOzLFknT0qgEN9MXB4ujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFInY8bua\nAjjmPMLDwY3k58/6c0HzMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAsJy4fYkjc8zmzPICAqRyBQkhbrd7KBr/dsQv\nucgt0jQCIHwLMgB9nME9S9UNpjAXKZAlBilPQcoHeCW3A6qmRTQm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1429", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1429` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASsYS30htGMApMrGH4BxHuPIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3MTUxZjhjLTViNjEtNDJkZS1iMTkyLWE3Mjc4YWIyNzE3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmZkMzE5MzUtODRj\nZi00MTIxLThjZmItNTBmNmRjZjExYzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpXGEUPOsD7LqercjRqq8I2PW8F9ymuiGsfTBxTUCEs5uZGvb7JrOSsvl4g5x\ntaAaNeHeKV3GzzvPsx85pUdVrqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeJT3XHe5CNVLiwaFfyKG1E4sknAwHwYDVR0j\nBBgwFoAUCCX5sDp6Yy+/NBb9bady85hGnfowJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAoAFAcDiZwacW\n/MD8BTpR/4C2lNo+kBV5IERNU7htQRMCIGEelrYLglfNMV+OxgIkbeTkRmPYEsM5\nXs2wIUQK2Lxw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVZvogFD4yH6OMUZ+VTp/KiUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzE1MWY4Yy01YjYxLTQyZGUtYjE5Mi1hNzI3OGFiMjcxNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/m1lG9Xd1rD36WEtn3KhqfqnuPL4EMtL6Ga/5yVsuHv4F\nCqff4teL7ddZPtylu8TMqYM69yObcZfiS2aF2kavo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCCX5sDp6Yy+/NBb9bady85hG\nnfowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXtD2BtF2GsdT15xte+fe07xUg6I7irI8WmNTsRfaVu0CIQDP2fRZGUqP\nb11gKvIUTEOTBni0njHABR6YEezItaY33Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbdknooB03NtwBUrMvy+BLkEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmZkMzE5MzUtODRjZi00MTIxLThjZmItNTBmNmRjZjExYzJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFkM2FmOWI5\nLWM1YzAtNGE1Yy1hN2I4LWZmZmUwMTBhYjhiMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI/s2g2452OUA1vYEVEsbnDUi0wQw8dIGJKta+xblj2Q4+4n5BCLU+up\ne3tcCUmAjMXnEOTAsKIQdRQOLx8fqjOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHiU91x3\nuQjVS4sGhX8ihtROLJJwMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAxuYlLPNRo9R+C8zO7MYdtC3ELaLZVXcC0OizJ\nE58sFgIgKDUJHJlyF1tdrivsLz27DCMR1V4274c2KkoQn3nTFOY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1430", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1430` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVM8+TuzMWsay3KMX7wsf9PDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4NjY2MzgxLWJiNjktNDA4Ny1hNDgxLTExZWUxZjFjMDQxZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk4MmQwNDItYWY4\nYy00YWE3LWE0OGQtZTFlYjc5MmQyMDQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEADNKbUotX0GO7CtvYoL1nMY+8aVXK/LxPgVVqntGXqNp0WLUr/+S+aaq+9jF\njL5bIXcdweCrdNwAgRVdP8y0DqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxJzB4sfHesCddnel/AaFTNka6n8wHwYDVR0j\nBBgwFoAU0tbJL1ddae1h2dZe7IRZ9/5JhL4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDdplZIJhkJx3pI2BxyLSB7md/sXmY8xoA0mcnycTwWMwIhAMZDSnvPsEqm\ni70ooy7Px6mOJNrEC5irTBZteFEkI3zs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdK+fBRPpLTZj0fNRzLud6NQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODY2NjM4MS1iYjY5LTQwODctYTQ4MS0xMWVlMWYxYzA0MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASN28+oHH0ugu1/JRw+WlzxciMvJ+VATCNbN2xMK9jYXZ66\nd5Sq9DU6kaqFlzT4b3hI1DfBOtOuWjYaXOYS4G+Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0tbJL1ddae1h2dZe7IRZ9/5J\nhL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOPju4btE7hYifOHWeZjEtcgkEx6/wMchvSDFQn0UR9QCIDO1oQ8/vt16\nlrOLRos3V2yWuqmJk4jRsCf9q+/Mzo4D\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARSbP2K/rX27yRXZ0QpydAqOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk4MmQwNDItYWY4Yy00YWE3LWE0OGQtZTFlYjc5MmQyMDQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEyOWExOTNk\nLWZiNTItNDYxNS05MzgyLTQzMDQ5YWVmYTc3MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHTflXOcSpm5q62NiXXLFFPm3x01qjuySVy+ufKQrkx9xy4g7p3Bwh97\nNlf5C1t7pxBoWBHg3OxRcr2p1cJAojWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMScweLH\nx3rAnXZ3pfwGhUzZGup/MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiB9HZTkn+iLdPECTjtm55mhogXRs3ihIyhwhb1q\nVUuQugIhALID+m5omKD6wiY5xxVPLjfNCm0wBaaVJ7Td4e1jDC/p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1431", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1431` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAabPsdpd66CjNHIBMLcZM66lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwYjk4N2IxLTNhNDYtNGU2MC1hMWZmLTM3ZDM5NDlhMjdiZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAzNTYwZmEtYzFl\nOC00OWU0LWI2OTYtMjFmMWVkZWQ2ODcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2YqgSSv2XDqEW8ij13m6bSmrl5cSjaf8uzmmRGTtcAMeEnFV9pYgaF3Vxb/z\n0tcGSs7KwKChztBvaz1yePbe86OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6VNrB35xGAfjL9zI1Cr15JhnMxowHwYDVR0j\nBBgwFoAU+6oOzS89c9fkkbRGDl3dmq9+4LkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC3eNk0RIXvM4rJCuVq6d6UBLJIlw4qoLQjBkaxBHWx5QIhAJctNelzygYF\nVquG/k4NYjTmjxD/l1HxPk/Ep0YEGFBv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZU8WKwxfv//ZI5Idq/ZlJoLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGI5ODdiMS0zYTQ2LTRlNjAtYTFmZi0zN2QzOTQ5YTI3YmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9+EETKCegDcqqzid/91hg4RN5EXlgceveVH/u05GIpK/A\nWEAs1DQ5q/6z7oWdy9HgYhnrp2UvHSxPMYK1V/D6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+6oOzS89c9fkkbRGDl3dmq9+\n4LkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMPSrpaGZTZO9SH2ZnODgAptTJHKNX95T9h/aiQiB+RGAiEAvfnV9uUa\nNloxStr2csvC6BZXlzeg+Vrd4f4+sxQE64c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISASaffbSJwO6iZAJ+Y7jCtsWxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAzNTYwZmEtYzFlOC00OWU0LWI2OTYtMjFmMWVkZWQ2ODcxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRmM2ExNjdm\nLWNiYjAtNDBmNS05NWI0LThhOWQ3YTlmMzhiNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOrL7YIZtOsDKz1JbZD9zHLgEADGFldtiRIbqVPIYXeoBbIm3E6BF5U6\nLN58cLzI1Uc+ncazV2JMhAkMuZyMhHyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOlTawd+\ncRgH4y/cyNQq9eSYZzMaMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEArdYXCiTBd4KXSJWtULjATsTsBDPefJUE1V7M\nwQ5PjtsCIQCENaQbHpd3m28uk1qHNUmisOrWhVZTAOYIbJ6f9Yjjrg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1432", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1432` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAUiTTcOba62aXkiftmYvRFVEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlOTRmODQ3LTlmNjEtNDI0MS04YzJkLTI1OGRiNDUyMDU5ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTllNzExYTEtMGNm\nNi00MWViLWE5MGMtZjViYWU3OGEwMzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi41P/TCniyxrgFd3RVd6wdqHkpDs/euWX9TxD/eYzoEbomrqiH837fzbP5dv\n8Ya+BwefnF8o+0erH++ozFCTbqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyIPXG2oNVhFbR1MbP7XCCVWT++owHwYDVR0j\nBBgwFoAUod8so5vvZFjqJj1juC4hG8Q4eoowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBn7Taa2I/rDU/8hLf7jPJJsLmYGRqKpeuFZilSCZ8OUgIhAIRYjaIbX6CZ\n6HzkuSGu+SlINkrRbGplGxWVGVMMpmbj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQzjhvZP0aMinbpfXXtfNX0+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTk0Zjg0Ny05ZjYxLTQyNDEtOGMyZC0yNThkYjQ1MjA1OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNGv29+W30RrT5MJpW1ZWTLHPBta3Dgd1HItYlDlGPb/kO\nSB76oIWsOfGjNjBC4UAh0cBfXGzw8vlhhsehv+ASo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUod8so5vvZFjqJj1juC4hG8Q4\neoowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIWoUMBbVH7zuhO9Oa6yT5G6Em3c1MwbSfYyBONGE25MCIA+LlubuDxGs\nXJbizvRVG/fSMBKoWAziLkgEU8kcR1xZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASOXCKhS1d/CQU1K0QjiIsV7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTllNzExYTEtMGNmNi00MWViLWE5MGMtZjViYWU3OGEwMzhmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMwNzRjMjBi\nLTk3MTMtNGJhNi05MjhhLWVhNjlhOWY2Yjg4ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFbT7Zk3MDNgXOSbQQMU1Jtx/QSF7xg68i+s3zxBB5pz2v9C5CtkeDur\nIkjHlchAdcds4LCi1Or0WXGDHu7Oc0ijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMiD1xtq\nDVYRW0dTGz+1wglVk/vqMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAdpu8RBAyLsafsPrQJ/bnoe+Fkw8lJkUIgdA9q\nMsJ+9gIhANVfX5meSL4wqKj4bZ561HyGXQsCmeCsM51U3GUdg0qP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1433", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1433` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAcrmdnw3LG3ZPP90auR71Tg8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxZTAyNzdmLWFkZDMtNDZiNS1iMzU1LWJhZDQ0OGZhMTM3YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZiOGZhOWUtYjUy\nZi00NTczLWIyMjYtYjBhY2VmZGUwZmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsXyWBjhn+HEC0Jnyj8sduC1RkGE2pJky7oAB5ttleurzy3vUWqvjL+6FWRtG\n86kHSdnUOHZCzTiFfoNgA0vPuqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBEl9KOlfCgR+30EzsnGK5+YnyscwHwYDVR0j\nBBgwFoAU801cPTBjuNAHbq5q5dXvpdFIFmswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA89i6yiyLX/XQfao3IjHcKCdKHBCQCBqc55RAS2f6\niCQCIQC33oVypjc3jurwcEHhBEBAM25v6f+V6Ml91JKa2zI9BA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVtHkQqGfMKbzjAnSqMfEJApMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWUwMjc3Zi1hZGQzLTQ2YjUtYjM1NS1iYWQ0NDhmYTEzN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHym7JizUcTLtD3P6uLf34yH0o3vxUKZCIiWK4ytYKOky0\njrI5zG/55RBqR8jUJmZWkP1zgVLecWqMUkGd//1Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU801cPTBjuNAHbq5q5dXvpdFI\nFmswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAlWBwheXfcIAaV+hYtNMIXp5l8562evjd7LZQ6A9kIMCIFDUj4fgZCao\nuGhQibtdAm4/G2ZdMkaobszuDPfP7a7z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATnM28Mcx9PgVmoTjELWc39jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZiOGZhOWUtYjUyZi00NTczLWIyMjYtYjBhY2VmZGUwZmEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZmMTJkZjVi\nLTVmZjQtNDU4Yi04YjFjLTZkOWM5MWU4ZmQ2MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCHCvvwahyx5HKPvheIwTzmCmP7Vv3EwEcuGCwI1/EwVbMxIJxBffTI0\ntZDuz+rFCkE0TDGTwNNCFcpYWYHSfUajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFARJfSjp\nXwoEft9BM7JxiufmJ8rHMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAFiS7XIYjsS3fxgmLL6q8GiE+LY7OXtX368I9B\nGIC4tQIgWuiNbBtHDff8XoZzT7O1c8lzUpyCErFICpdcU8WdQ3s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1434", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1434` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAWH0WnnSo0yGjWaN1M0BtFI1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyYmExNDhlLTdlNWQtNDE2YS1hNmViLTg3Y2E5ZWFlZmMwODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmZlYjVlN2EtMTll\nMC00Y2QwLTkxZjktN2MzOThhZWNhNDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH3FIEs9C5Iigi84qkI+bbXv2UKceHiHlN6lMTdVNkv7b151zpkaQp/Q14CTf\nj2N9kpH6/syQhbFQ4s2NWLzCd6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJKQXguUb+f2GNpq4akD3VdMF3jcwHwYDVR0j\nBBgwFoAUICYDKeqea4LNLN8Iq8zClkPq//0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA909Qc4Q2LC+9B4YjKfHBwFC12uUHiQ5qwaNZ72x4\nonACIQD3rYYMe6uFk1pFAtwnE5rrk3z3CJi2rEWVLx3ixTkAcQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbcQXgvoQfeL4d2J6QOmJ4HLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmJhMTQ4ZS03ZTVkLTQxNmEtYTZlYi04N2NhOWVhZWZjMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFUj/z9nwrF6R80olNV85FzDL+VPWu+5HAUBY5s2FDYmGV\n5suqgTw/KlKSXkAcTxh6nlpIKmyvO/032zzVE6yQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUICYDKeqea4LNLN8Iq8zClkPq\n//0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOpgsN4WApvpTfOrlRyUCHEpryJsZLFuMekohU6FzEpoCICTQfts8R2oh\nPErZPRj0c5HV24WR2PPqj89GZtoqTzTh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAWHUht4ikStXj3FCLh6CrGntMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmZlYjVlN2EtMTllMC00Y2QwLTkxZjktN2MzOThhZWNhNDlkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBhM2ZlYzQ5\nLWFhYTUtNDI3Ni1hOGU2LTczMDUwY2QwZTZmZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPedHLRJJYlzCrbRiGCZ12ik8jtUB0IIX6ifikoC7gcYGApwVzTX8cS3\nPLvkAyp0P/Ukb7ylvgACJQBvcf5xmfyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCSkF4Ll\nG/n9hjaauGpA91XTBd43MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBfzYvXdq9LeZ/UkzZ2BSQiAEd30786aNbJ5S76\nWx9qaAIgdivmalAoXiWsFNd/xKN5ezAMu2ZnEngn5fKfl1Dxgss=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1435", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1435` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAS3X/ZSSF7mAB7FfFeC3fdeuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5YmYwNmVjLThjZTItNGRhNy1hNDM1LTlhYzEyOWVlOTAwZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRmY2MwYjktMzlh\nYy00OGFkLWI2MmQtMzYzZWQxYTFkMmJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiEXTLvMZezOeiCG6gWPRT4a3KSJdlMIoJ3Xeavxyv7KqqWJU4LuLtshWlUIK\nLQGkNNeKc7jFZJf4rIwu85+H96OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcDBeSzsiu6RiE4a9fjQ2Pbm0fZkwHwYDVR0j\nBBgwFoAUAaaG0nMVuXrBsUhY3/Z5ioH+ecswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBFyNyxsF0VkFgQAgnnOmVrSu1ZOQjbf9cOEb7xTzZHvgIgfHbV\nG/nYJGQXESZBBPs82ix9ChWdVzQpk+Tlq11nAGI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT6OEo2hYvF6Ns2LwUBDqzXFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWJmMDZlYy04Y2UyLTRkYTctYTQzNS05YWMxMjllZTkwMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATD7889kWoWvgstCnbR8FZ5sLORiAvx9aEEYzKcpCJmr8rr\n0AOHSbs7dpz1/qbsuocePTAg0Zl8hLm9zkPSWnQLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAaaG0nMVuXrBsUhY3/Z5ioH+\necswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZHNi1DKabrQvSX3sl+gFgWD1DsNbPAWqDjruLALNp+ICIFdFNok3uCs0\n13Pp7zfrHOg8KcX4CCkAOWUOMgAGDC9A\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAWWiFKPhmAcycMjeDModDegUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRmY2MwYjktMzlhYy00OGFkLWI2MmQtMzYzZWQxYTFkMmJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI3ODM5ZjJi\nLTI3Y2EtNDA1Ni04OTRmLWMwZWY1NWIyNjdlYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOINJ0NJJq9XVyfAmAZlXyIMHQyjLxh8JWdJgDS/xyniiH6KTAzpAIDM\n1lW41LWdcDQ83OymtCHYCnmjD52H1fKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHAwXks7\nIrukYhOGvX40Nj25tH2ZMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAvk9FHePxxVFNDcQHzfdNhhGMZVb216bSihXL\nFcqJY0YCIQCxYWN5CfOMYpM78YwkAvVnuEXYIE8z688g46HvCcPI/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1436", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1436` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAdcafQdlYG4FYgdJRtLkKeV9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyZmQyZGRiLTJhZDMtNDFiYy1iZTIxLTljNGI1N2NiOGIwYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNiY2U2MzQtNjQ3\nYy00OTg3LWFhNzgtN2E5OGE4MTdhMTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEerqbg1GR3kmadeZ8vf5rHbscDdAbJQ5X6qCj1s0oCMyi5RDme3dFAKSfJxgg\nvSxIaXEQ1r8CS79DQaE6pupe36OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvKLF4Iy784G9mzPo2TVwHHuNZh8wHwYDVR0j\nBBgwFoAUwOWuWdPvP7iP0R25wsAIaI0kR0AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAGzrcmlChBfQ9Vmo9GsSTfJdjlRDNjNF8o\nqIB/QFLZgwIgO1Q2bkR5rntYi0X3CkRnNLYITISQOaSlQKa1S7sV6Lg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYLDMlpgACHkagVq/ozp420AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmZkMmRkYi0yYWQzLTQxYmMtYmUyMS05YzRiNTdjYjhiMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsTjWva3CQUMg4tboHFrbDslIjEufI87xvEvGD5OIc9nid\nbQ/Zjk4Ql6foGduxs5IRrK4zm+S8ErzJHLUxtqmio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwOWuWdPvP7iP0R25wsAIaI0k\nR0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJnYXpgtt0ez11GLIr/5rv0I2D0CuGNpB+ITCRyaHE1eAiAP2aH7V226\nnAWM17FfvUb4ZZzzUd0gNQk2hiRjTun/+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUUbijDTYMzzB1mISv4CoAk4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNiY2U2MzQtNjQ3Yy00OTg3LWFhNzgtN2E5OGE4MTdhMTA2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc5MjM2ZDdm\nLTQ3ZDktNDFjNi1hYjllLWQyYjRkOTVlMDk5OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP0xWUNAxCcDYaiY6tlTeBk5rCLLHJdqmyAhBy1+jt5+fN58cLd6NGl2\nZo232kwlCMCu21UE/LPmTCz2rtR9iK6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLyixeCM\nu/OBvZsz6Nk1cBx7jWYfMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAMnzump4JyfAdhMLGi/+7jSlagtlgBUimftqRq\nciJOxQIhAMixc2nvlDHzMNoBjVdzynTDQCzDR1SoKyBFEP6tyCOQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1437", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1437` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAbTUFJR/0ZmeG4UVxc1lZjQeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhMzc4NGZjLWRlN2MtNDMwZS05ZmE5LTI3OTUzOGY4NmI0ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYzMjRjYzItZWE5\nMS00OGRiLWEyYjgtN2QyNGQ4MTA2NTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAkJqnB7wz6kLlMqOOVjkc4VNAVhthS8vUYlYyid8plFxEH6hjLvzc/q3gOHc\nJumfncoFkqeJrMhJiWKNzvBH36OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuRiXhJtufxsC0dEk62d/3FQI+SMwHwYDVR0j\nBBgwFoAUijKRABYbkM8A0D9WTqEwLvzfCckwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAp3edvrV19ZU+T+l7yASx27Wi47OQ1nId\n9oumfj8OJzcCIQCrNFip9uKRhUPVfvdGwgGViEasFgL+DuLHdEHyGwbStg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdQ5h/G04ClFnDFJYog/3nEmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTM3ODRmYy1kZTdjLTQzMGUtOWZhOS0yNzk1MzhmODZiNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGKKCDWGknyUteyLAuTjvzmnDPPzUjk26+x+qNd969rMBH\nLUi5kVVHXdLIprO/ajxmWCLFjuA/kkzbnFHHj6dCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUijKRABYbkM8A0D9WTqEwLvzf\nCckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMEaLLb6IXMzQNXJpu5lojyzQ3yA3X7W97PF3Ne5+3cmAiEA3dVx5gvY\nn/qzip9loI/IQpjY5G8JmmEbY7beFbwrPfc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaBHvBAZaznfhTd300gDN2JMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYzMjRjYzItZWE5MS00OGRiLWEyYjgtN2QyNGQ4MTA2NTMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ5OGI0NzIx\nLWY4YWYtNGVkNy1hMTJhLTdhODRmZjVhNjQxNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCypBaMUO+NsjrxMfQ8Es310Ge5vcwhvIOWme/dRg9Z7gJLJ6ccf90O9\nGGGYNcYsioWh7yFnBLZ7xOStpAP/ou2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLkYl4Sb\nbn8bAtHRJOtnf9xUCPkjMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEApTHOk/11DjcFKqNIXrzOKs5LpO5DrLRtMuvD\nNS30jdMCIH4tmCoUi2CTeCwKi9CjqotxJN/P0jSY6c2ftx4Ljgy8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1438", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1438` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAS8C3mHkzHktug7Y/BaEd3aIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2YTlhOTI5LWMzZjUtNDMzMC05NmViLTMyMDA0Y2FlMDJkYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc4MTk4MWItOTg0\nZS00MDQ1LWFhMTYtMDFlZWMxY2Y5NzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9JG0PnHJDF3E9ExYz7Q4cJO2JwPrlTsRlbUI+sfjM89oVQ7pwjM0FdLSmtym\nhN11RtlTtX/vhxwEmCkyygbxBaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjhdbVrOJl49RoxtEo2RX5XmJcvkwHwYDVR0j\nBBgwFoAUpLF6ZP1CVTtpYNW7c/zIqCL5Mj8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCddnC9lLImOn008C192gj3iB6J\neHpeJ3Gs6lh0/u0+CwIhAPtkc8+ic4FewfOO4xxNBxTZXuaZyj+w4slN76EXFr98\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd4U5Xz5/F4hdZWCoE69IFK2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNmE5YTkyOS1jM2Y1LTQzMzAtOTZlYi0zMjAwNGNhZTAyZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkeFHVu0P1Im+RacEwvsr4JW7urrFenKoLnYFoMHCP7p2G\ngNQwiOXFNjQceX58H3TmzSf/f8I2uvHWf4c1jIHpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpLF6ZP1CVTtpYNW7c/zIqCL5\nMj8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOersSeIigewcI5rxs5V+DOw9UfRcRkbYBLcKsc3l2UACIHA3BKOcIBv7\nGppEuPXSvKTRxDnjNhSYZ+3RFsg7jLe9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARScrZDtgjBDV4XoKK58cAlxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc4MTk4MWItOTg0ZS00MDQ1LWFhMTYtMDFlZWMxY2Y5NzIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI0Y2MwZWE5\nLWQzZDktNDM1OC04Yzk3LWQ0MDY4OTdmNDhkNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABICSuJ1n/rn6xShBO+3Q5Bpdc3yM3k37IKhTT8w7MaOpFj301RnCFshu\n0MJ0VSMHcuDFMay+x25fL+Yd+ehjWHujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI4XW1az\niZePUaMbRKNkV+V5iXL5MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAuUP4pfuVshCeb//vcZ2AV2WTBoK82cbNdFGX\nDjMbETwCIEZ4u6S07WpFmKMKnENA+Y2+xSHjXIch20VICvskizdE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1439", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1439` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISARDPKc2qTJi2y3Szgin+jTKyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3MmI4ODdhLWZlODMtNDYxMy1iYzg3LTJhY2Y4OTVhZmU0ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGJjY2I4MWUtNWY0\nNS00Yjc0LWFmMDUtMjk5OTVjMjMxOThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Q/ykafciZDcb+5v7xbOu70bJzCy7vaGB8Xp6EfhY6NKDK5mQhfkh6fjevZP\nLtDcNTQQJzL84I0BVvTJOAx0p6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfeas0Ma2RxaMYrgUOnMuc/pqt58wHwYDVR0j\nBBgwFoAUXny6/sx0+qi2Dt/76WQvWS4Gq8AwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgTHIvM03o\nsYAIg2b/3osYPUwJrpakGi0qpz8K+vO2yAMCIQDXl2WWbTWPV/1EUvR0umQ229Mi\nPdgQeYPdkd9/BcONWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQuChSYuICfBPwE3HplTGsfhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzJiODg3YS1mZTgzLTQ2MTMtYmM4Ny0yYWNmODk1YWZlNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFsHYz+tqBNhVA2D13qdoq5v1GpXFQfn4Qmw0rkQcTFEL1\nG/u9tq0n3zi2FsXHumEBJd/cPLyWZbOVGISfWX4+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXny6/sx0+qi2Dt/76WQvWS4G\nq8AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDWiX1PEAwygunqit8TarOKrmPVRtvO5QEoz2WoZnnwwCIQDfrdPYHygM\nmpE1KH92en4jdXtqqLe3wW3MoO2GaVfHEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfTbecfx2DQYxxMB2gybSgsRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGJjY2I4MWUtNWY0NS00Yjc0LWFmMDUtMjk5OTVjMjMxOThlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlkM2EzNGEy\nLTRhNzMtNDc5Ny05Y2Q4LTJlOGQ5M2I4NDg5YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEb0grS6E/LQyR3e6fyDxq9sXhRgjIDc8qmHaCDsBxnszMJ+nqbejrKU\nmBjdaXoxQy+2BqzIWJaL6jPLx9/nvXCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH3mrNDG\ntkcWjGK4FDpzLnP6arefMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBL9Vdag8MJoJkWyGJiJxqNooMaJt8qI0uIWNaT\nipll4QIhAKTMGbDWt1pyKgwQLBh3mPemNUCNeUXDdKXPXn+WGQPz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1440", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1440` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAQ5+UPQTJvEmQ/8qpGYeyP6fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMjNiYjRjLWEzYWQtNGU3OC05ZjViLTM3NjY2NjkzNGM1MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGJhZjY4NWYtYjMy\nNS00NjUwLWFlOTUtMzRhNDgyN2VlMTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELMJaLx9a+h4f7TT00CoVEb4tAGjMM4nmaqnsIxtJDrBTAtWxlOHIy2B7Z8lW\nS1R/XULfORYBlBfw8fzVZiTacaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP9fXuYw98zZ2x7cVlYwAAbenRkMwHwYDVR0j\nBBgwFoAUhuhTcvH4WLF5NWE9diaaS0rtGcgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANfkRtkM\nzGkwt6ddc0zuIGbJf5n5J2q6sEiwezC+5orFAiEA0dvr2k2SvUKdhmQ1yxqOFYyD\nent/T+cv30QiCilOBJo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAesY/inSg/lkf4wxzbE9y6kmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTIzYmI0Yy1hM2FkLTRlNzgtOWY1Yi0zNzY2NjY5MzRjNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsYjih73/r0wfxO7CAIIaab53YELj1BAaKIBjtaAGJf4tu\nMwnouCWfwLAVS8q6TEE65ZCjsdKOu4V8zjThIe3oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhuhTcvH4WLF5NWE9diaaS0rt\nGcgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcZ2kBFqzKCFacR876zHUsf2/4kDUWDPr4aK/uiePSswCIQCEBbph3soI\nJ5u5aAW4vfCjKVcLmzqZWs8KHj62sJdTjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUtcse9n5L1PMsAfXsrvynTRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGJhZjY4NWYtYjMyNS00NjUwLWFlOTUtMzRhNDgyN2VlMTEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkzNzYzOTEx\nLTcwOTMtNGE3OS05MzRhLTA3YTc4MzZjZGYxMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJdW3poakMQelu0lXLD9/C2K7DadFyPy5YP3biv7/Yzfy9TFGchzDbZE\nOrHVPSOyAkJE5rm0gC7wc5r0MwOondGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD/X17mM\nPfM2dse3FZWMAAG3p0ZDMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBKkoaa0zPAP3pUZqGplzmQ+VIrPxFOyHqL92tQ\n2KWYzgIhAI63LljVt1otk/T5a84YaZ2oR2M8D2fyaTfFiIGHcvQo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1441", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1441` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAbRQlVDYH4xZlvq41SrIZb/eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkNDE3MGVjLTJjZDAtNDc5OS05NTM2LTIyNjJiY2IzZjg5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAwZGMzOTgtYmVk\nOS00OWM1LWFlNjEtMWViYTYxYTBjYzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC8HOBjZ9ZvTy8O19s29JUTQxZWNSev8+OeAT9JK1QwcWostCY2NYnPUJ5o4U\n72pPp3x5/j7a4FZuY3SE6bZhSqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYpl46njPdUe3GFW5KeGQVDa4sRkwHwYDVR0j\nBBgwFoAUWWu5HObeb3HqxvKyUwJLrlcOSGgwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCpM1wU\nqMCz0y5OpkRziGG8FoSdNV02bn3TShqcgdySdwIgWH7mlCP9hX9BLnazCAEA01u1\nHxLTIFifzQ0xE9L7y5E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARIIJsX1FTCVGzXkWYD9clWrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDQxNzBlYy0yY2QwLTQ3OTktOTUzNi0yMjYyYmNiM2Y4OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRsRpRo7yU02CMKm0LvMG6S7gFpHy1fC2ii0QDcKS+7qFB\nFipfpaz37WnyaP4hPPNrw4q7szAqVu8KHeXnChUNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWWu5HObeb3HqxvKyUwJLrlcO\nSGgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaiZg25Z3VZFtxTNT0mnC8Ti6D1HM8/sfajDPbI1GlccCIAj+B65hIYHG\n9NyegUoT0V1aLYbSuIW4h/u+Mmn4nnVj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAUNU21nUvBgFBsrzw7yVpC5WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAwZGMzOTgtYmVkOS00OWM1LWFlNjEtMWViYTYxYTBjYzkxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRmMzVlMGMw\nLWJmMTgtNGZlNS05NDZmLTM1MTBlODQ3NzI5YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO4inqQ/eVdt2GVeVxhft5O23D+Qb/ztWcSSHklVEusLO9T2q9YIaXts\nmdmWRSea4Py0H/jcLJhmwLSQsu4/HPejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGKZeOp4\nz3VHtxhVuSnhkFQ2uLEZMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBlW4EZOg2ioX6oPvo00eiqXQmyfDSY0aUfbHH2\nMPOsBwIgEU+lDWsQypUN5VLi4d9Cadv5/9dqylNjPSRKU2fcH18=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1442", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1442` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISASWl3IskdKzVL9JVt7RTy9asMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1ZmMzYjdjLTg4ZDUtNGQ3MS1hNDBjLTFjMjVkY2Y5OTQ4MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FiZTliN2EtNWRj\nZS00MzExLTg2NTAtNTM4Njc0ZWEyMjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEukSkiu03Hdv4UB9IcDXtyoaBusKq5Qu/gmygyn0oArjX8RdGjrE40K/JbUlf\nkQ225qR1tgNCHb2spmbTw4fLWqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUiVagwAA0ERQq6GRkWUtrD6gvUAwHwYDVR0j\nBBgwFoAUFIXFKWwEqAbP62GgY1hq/Wi42yowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCAH+EmRUU2WRjEYAWk9zLmQhOoL2nRTVUvJRht4y9d1gIhANuPm3E2\nW/UK0txG1Z6dfkD1uA7lnxx+eSGaireqHTV+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV9jdDHoMGc1TSp2LUQhhAauMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWZjM2I3Yy04OGQ1LTRkNzEtYTQwYy0xYzI1ZGNmOTk0ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARskJtgKqkw6AKeduDpgt0ZuIvLNW+RQ5soXvsUFNjgedLt\nY2En1dmTtJlHJA1NKyg8wP9Lah+xeFNAKygCQwdQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFIXFKWwEqAbP62GgY1hq/Wi4\n2yowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPVNondLMxRzqV3NAi3N8TpPQGdRNUh8kNvniFDr86CRAiEAmHgs9thX\n8HUOK/ZCcZVJsCjoLN8jGxebpU6ISw7yFr4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQ0lLzeahpaPDCvRmSVkPrcvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FiZTliN2EtNWRjZS00MzExLTg2NTAtNTM4Njc0ZWEyMjgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk4MjlkZGM0\nLWFkNmItNDE5ZC05ZjFhLWEwNTk1ZTk2Y2U2ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNNcZxrzQrgFJNSJmvvdsnkIjJP1WtSosp2KV+A2koFktn120buzpLQR\neOXFMstkPm42cAfkbfx1qOcCvy4sAFyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFIlWoMA\nANBEUKuhkZFlLaw+oL1AMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAgVphFKKsSE0offDUXTMidWRDa/QpruGrYs2V\n145h6U0CIHKUr544cd2FwdYErvyvOJI6WNuwnx1SUTFhQf8KvRFi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1443", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1443` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAaXLt01SBMd2lkmF/OtyzT90MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMzQxOWQxLWRmY2MtNDE0OC05NmYzLTkxODlhMTdiYTIzZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZkMjM4NTAtY2Jj\nMC00YWEzLWFlNzYtZWQ0NThhMmUwNWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+bWfwmpNhdefmwZx3KH3eCPnNNlD5GmATD9bVOpa6DKTg3e3IG7MnulB49bV\nCzgL8Nt2UyHLctfI2guQaNAUB6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIAGv5poXMXBtk2SYn/VgbEbauo4wHwYDVR0j\nBBgwFoAUBPpkT4bAHjlCAz8WkV7iGBVlLhowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDjlJi814i1dmckfESCS5mt6eN9wGMjZsDdmJnywC4oRgIhAPzZHMcE\n9VHIH+v73YtzPKijfMCaQp+IZG0TMwZb1439\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcFCtbMpLNJZxMDPxOjiVwwXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzM0MTlkMS1kZmNjLTQxNDgtOTZmMy05MTg5YTE3YmEyM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPe8lXB7YVfPcw0Qabzvxz57LPJkWFT3q7yLoQmk/rzif6\nYCQN4VmXz6kVNDyWT+h6VlGqKIfd8/M+yz5e+8eyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBPpkT4bAHjlCAz8WkV7iGBVl\nLhowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQOKjRJjwBKT0afYXlNNvDIn/De7WGC0F1NUVomV467cCIQD2nJZW2oOu\na4UdlzmTVAD/lcbKCRLnjqLlqN5++M1YfA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAclnCnqPIusmNqjRZ1GFbDodMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZkMjM4NTAtY2JjMC00YWEzLWFlNzYtZWQ0NThhMmUwNWJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE4M2NhMGVh\nLWFlNDgtNDIyNS1iNjEwLWVjYWQ2ZTc1MmNmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIAR0U7kVBwMDxvoHhp7AyQkrShniRxj+VkAxiYZtGsy9ZyaxmgUSd2C\nvYKndZ4X6j3Fr/YPjiYMWvoH80JK6SijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCABr+aa\nFzFwbZNkmJ/1YGxG2rqOMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA+sQJgQh3kNZPr1lbjAe6Tucds9F0//3JbFge\nYkAMIKMCIQCsDZZIJnTtD5trL9JfEaZlKznjgyjXjq5KdohW3h2vbw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1444", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1444` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAV4j6qeLXf9DA/lFj3h2iZeGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwYTEzNGYzLTA1ZDMtNDcxZS04Y2E3LTRhZjA1ZTkwODZiNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYyN2Y3YmMtZDdk\nMi00NDRmLTg1ZDgtNjA0NzIyY2Y1MWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEucO/DABZ+ckwOix8bi1Y1m/McggkC+EnInnDvLI6KfI3iYeXjS7s7KKVp8h7\nwid5E2vT+jK09CRs0nq4T7XrZKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQjIBi+mB+ImISHlcrhhA4zOohGcwHwYDVR0j\nBBgwFoAU3EMAbRAaHJSfuMv3p/KIiGERlrIwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDseKQbGJBkRj+OhuaN9BfoTvkybf03BTcxIOncKaC3kgIgUoCpFgB+eHVH1vii\n9OkS+Qq+gaFlC7RB4OSuFm46jhM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASNWrXmUpOKXUseNmaLhUMIQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGExMzRmMy0wNWQzLTQ3MWUtOGNhNy00YWYwNWU5MDg2YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASg3/KSQnRLjeWApeyn1P2rjtwJ/8Z99CjBHdBQiKKsGEWN\nl8sfwQAGxYhZg0Q+lwKbl4+BpP/PV8nqB3VNKK3Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3EMAbRAaHJSfuMv3p/KIiGER\nlrIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPiaoSOZLwod0t1lFpWlZ8eXAjyYXCyu7wrdEusEFyyyAiB62BI+2Qcl\nviOYWkTVXaT4ZT33In/0xdrrK0yIEU5eJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdQdYktrtMf67YdidA2nTGl8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYyN2Y3YmMtZDdkMi00NDRmLTg1ZDgtNjA0NzIyY2Y1MWM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM5OTY0NzZm\nLTI3NGUtNDI1NC04NmRlLTQ0ZGU4YzRhYmFkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIEXvW69vbExLPnLqCjz+MPbck+NblOVJUDZ8Fc7NzH2uJuMZzyOyyN7\nstBvulW021yqQzW/TNx8A4TX1Vzr6lSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEIyAYvp\ngfiJiEh5XK4YQOMzqIRnMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiB41r0yPQVkEVEaXy+7iPaJTJGGnbUXhWjQbWEt\nG7FBDgIgV0uAUWkZG6a4yTID5QxEYiSiipKZhY/qwBitoWXYp5Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1445", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1445` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAYVDG+4vusvg1xEVC2meNBISMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2OGUzNDVhLWRhZTMtNGY3ZC04ZDc4LTgwZDg2MTM2OWU1OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDExMjQxZDEtMTFh\nMC00ODg0LWE1NzYtMDJiOGIzYThjYTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZaaR3hJk85cuWT3lcWZIJyahHlgznGgF9eNV/8dvacb9QC3MTP0sCdu0c0On\nzbGBhsR/X2bxetHR/jxIo6d0FKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/KQdUVWnm9ED6+0TF+BgutCOJS4wHwYDVR0j\nBBgwFoAUBVjG7u+xROllilXcKMnbxEMIf70wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIBhpj9QN+gu7FTsY+qn1E76SKOZzUhBuA+2h5FOw4Sc2AiA+\nVvkLj+Fr+lLmw/e1KfIJJ7ANUcrZdRNeP64D5SHjIw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQp2kSof/V4PG8i2mPV21Hb6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjhlMzQ1YS1kYWUzLTRmN2QtOGQ3OC04MGQ4NjEzNjllNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROAdJdr8zgHtdIKhwhBWHpTWAAicF4KW5eMJPSMIskctNZ\n7nd8Qj197BXey1mVB6AVP7is+Fonp3CKrM02KdYMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBVjG7u+xROllilXcKMnbxEMI\nf70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANViZzteXcKODRq8UkH9CGGl3FLWT1K4RbGsHtcXFUEuAiB7X6Y/JyLG\n7qihy3SfTq11wwjsc/KprKnAiPVqLxTgYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAedh/VLCtYDtEqsWnjRx0SUEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDExMjQxZDEtMTFhMC00ODg0LWE1NzYtMDJiOGIzYThjYTE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZhMjk5NWU3\nLWIyMGMtNGY2NC04NzcwLTZlNzAwYmZmNzcxODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB4CJWngoIwrLuynw2eYBxdcF2d+sYiuvpPZqYo/2x0FY62UbjX95m26\nNsZqvDp6EKcJriI91rjKwD7xub5qMSujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPykHVFV\np5vRA+vtExfgYLrQjiUuMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBsOMRFNOXxNtmos/YR1JcTDnbyNbbThgLIfxo8\ndxNmfwIgWRctyf0GPJCUlua/x1OCyEPedmUAVzXqcSID7Pqf7DU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1446", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1446` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAayNwavQxg4M3COALUtJ8GikMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3NTUxOTZhLWNlMTItNDhkNy1iZjhjLWY2MDJmZjEzMmU4NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI4ZTM1M2ItMGEz\nMy00N2JiLWFmNGQtZWIyOTZhNjNhN2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEph89WZNlV1l70YjOqRkMKz6uli2LoQSzeQTybjBSmAaoL7eRbGp5pd2F6UCP\nibiHHs4+QnLqoLo2vfbx31cTw6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHb0Tv6BqqwoC0r6RTJHXVg+p51gwHwYDVR0j\nBBgwFoAUTZ8uPQV5S7mGaIjyZ9dXJ1dloAowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIH7BLY5PeKTtk9B58WNynZeL5Hu4tbeAzn5PuSljvHH6AiAf\n8vkJOANh0lExeO1rLln5nap44+Q6zuOcxDpe+XHS1w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS3MqXbjj3vVNnDDdA9KG8fnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzU1MTk2YS1jZTEyLTQ4ZDctYmY4Yy1mNjAyZmYxMzJlODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQij886cGwwnjRANQvledheVKzhJh8jI+x7k/b3RNITBXd6\n//R0jigZAsPRJvy+gxq5AJiP+jtbfxk/YqW8qHIOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTZ8uPQV5S7mGaIjyZ9dXJ1dl\noAowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM3xJEy7IOvjne9F14jtL4dUyy0+zTBA3qIG0ERlbKWKAiB+2zHBqznb\nIH3V0MBMTvGKl4OPlvaoXpqhuhPM6SqBwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAf8DpEL7A1gEb1RFjNwuFyNiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI4ZTM1M2ItMGEzMy00N2JiLWFmNGQtZWIyOTZhNjNhN2JkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEwZTZmNmRi\nLTQyNTQtNDhhYy1iZTM1LTEyNzY0OWE5OGQ0NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPHDb3k8PKg9dJAhx9NX/ZBEjjTHM0iCf6lOeOQ7SxZRTqpif4Q5Ax50\nuYThocFwP7XLvQQbb4FDf8Z2m3zLq6mjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB29E7+g\naqsKAtK+kUyR11YPqedYMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAutSQfW+pqQdCE8mDU4mhphghLlleW7Un2vck\nhgDzevYCICdk/TSRdsbiStHA6zh3GWVoEnMFYWrqsYne1yokCLgt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1447", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1447` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAfg8mD6kAfdeNcGYFiilnUSDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3ZWUxMGM2LTk4NTMtNDcyMy04Y2M1LTc5YzI2MTk1Y2RmYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM0YjBhNmYtNDQ2\nZS00YWYzLWFiOWEtNzkxMDJiNzAzNzZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErMrpso+YyQ8BfkPBPAplQX/sq7xi/ecVaKfE9g3Ti/0d5+NdA64gABFY4+oi\nlwqM6T1ifQEv5sxnxWGX60JXEqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgGw/tSVnVOZovJcF0Z1HfyGs27MwHwYDVR0j\nBBgwFoAUWhuaUFSRW3FWJyjGF1sy/8oiAlcwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHhzuBWNVBGI\ncB+OJd7bAJxWWMK2mtXoq2NBh9MGqGwGAiEA3uJPb4GmhN2QKIAJn7MBrlvFLhF2\nDbWvqLUdpYmz0VM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARRwDRswhYm+sntjLGJ1eYmRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2VlMTBjNi05ODUzLTQ3MjMtOGNjNS03OWMyNjE5NWNkZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWZN9Pexl05TK1F+UlNJQy3O9C2teFN5V3iCZyB/uovLSr\nLrfUFsNSwLD8rBVXgPaOgkrkBnnopkeDShDNCS00o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWhuaUFSRW3FWJyjGF1sy/8oi\nAlcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIgwhMx8y4UswQE+dM8oD2PkRz/LiH2xzkpCYhpZRoY7AiBohVPpqMhG\nf65Q6z0UepM/4STwJpdTIo0dkweMMBE7vQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAfblktiCd31MQ1jRzRy7WRNZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM0YjBhNmYtNDQ2ZS00YWYzLWFiOWEtNzkxMDJiNzAzNzZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE4NTBkZDhm\nLThmNDItNGQ1Yi05MDA5LWU3MDFmYmViNWFlNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF/PF7lwNqZqRD9jMVP/s7z47AvK6YjDyMEQbqB2jh/8MmVvJQ/++d18\noQZinbUzvn7sA4hGx6wsgqmXPuPuOjWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIBsP7Ul\nZ1TmaLyXBdGdR38hrNuzMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAWh1cQlcVrKGVCRwrL3m+H8cpJg8oWDnn6BQ1f\nPgB8nwIgEujHPJlbV64Dw1O9kT5llG2965ITa5nsJuOmTP4q4yc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1448", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1448` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAYyPn1fSwm/dW0b6pYmgG0+1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwZWRkZDVjLTRmMGUtNGU5Ny1iZjdjLTIwZDcyMWVlMmRjMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQ0NzhmNDctZWY5\nZi00MDhmLTg0ZmEtOGM4YTJmNzBhY2IwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExz/FonquT/P8dAmdKCYp0dXcxACGVqZ4r7vhGpja8IIgKoADa4HcHL/8jOI1\nxaEH/Bvo/fPJ7RA6+TwRwE2uqaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa5P1m5oRfesIpVTVqAP02rzjMaAwHwYDVR0j\nBBgwFoAUWnvrO1nTWkz8Tr15sKPEmnxWGTQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgZSCB1o378oxcM2nIE0R7L+Zquvog/4DvS38uk6fYO1ECIAwacsktPcMu\nPp552s0/hJ86asFjFpf4mu5dPqvcYLkA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf9oNUmCbx3SNf1Bow42aGb7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGVkZGQ1Yy00ZjBlLTRlOTctYmY3Yy0yMGQ3MjFlZTJkYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpR5s1uORu8MJg74ig5C4b/O+g0Ej1dHmu4GFITel5Sx/0\nlpE/lj0UIKegusca/xrmjHvc33wbZIio5G0RdubVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWnvrO1nTWkz8Tr15sKPEmnxW\nGTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJraD1IUu6PKVNpDmBV7kDqkcG99P8+Gt4jdUpR3u5goAiEA/VQz6j57\nfcJfxg6m1f5ksVxxScwTOI1fW5hK+5jggoM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAUuwxT6L9VOStKyvCsQyGjpwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQ0NzhmNDctZWY5Zi00MDhmLTg0ZmEtOGM4YTJmNzBhY2IwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDllNGM2ZTRh\nLTY1MWYtNDI2ZS1iNDhiLWFjY2Y1NDEzNzg3ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF2u+OTXsGqohs3vYlr9fHRg6Bqdcn4KhfiWs7HFDIPRZOc8LguLXG2u\noJykaty1obSHBLg6UC7OwiaNqw1l94ujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGuT9Zua\nEX3rCKVU1agD9Nq84zGgMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAzEFK1rvJ1gG/rF8ijqKfK5S8oVKnyCBbjQnS\nC1RTdT0CIQDTZQfJYt0hSutt5B+x8UZjcAjyItjqZ61B4i4w34HYQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1449", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1449` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAQjAS5HiDuMaqjb2HNEoSBbSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhYzdjYzc1LWJlNTUtNDFkZi04YTQwLTg4MzBmN2QzMzBkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQxNTE3YzItMGQ5\nNy00MDRmLTk4NmUtZGQ5OWYxM2I4NDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8TjZRTu4t3W8k4XL0xAw9OMsTdbIpbyUqjPjuxdeFr+/3HnFvEkcaMhigZFE\nX5upJCeXON6K5Af8KehyE2ftSqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURH4fg9dBVwpfX15j8U3m7b3rCLowHwYDVR0j\nBBgwFoAU/kVMfdqcfnekwyEPAIw8D1HS4zwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgATPWD8ak3HyDU29kTTojP8qME+5oulZiLqZHC8/4pQkCIC8TFTitg1Sg\n3m3X6p87hAx04Ygl8hlt5rGXYzGZcGN/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ+8K//kFZ5kbWLSFbT7Ck3QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWM3Y2M3NS1iZTU1LTQxZGYtOGE0MC04ODMwZjdkMzMwZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4+Wqz/Ocuxnk64OOt+vKnP+uAjWfk3i/BsUmKaTEt4WuJ\ncjeh/5ByJ2fqbpKUv39S3IGRTrANJ8CJC9HFaq2mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/kVMfdqcfnekwyEPAIw8D1HS\n4zwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP51M0zwBLRMcEOfuqXN+9kYUKYJ2XxtkS6/LnHmA9bRAiBqfY2dcet+\nES+y9Bhj+GcszsLKy1sZyLE4jOPOS+AGfA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAX6nRvz77sqrg8qxaMHxJ5+UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQxNTE3YzItMGQ5Ny00MDRmLTk4NmUtZGQ5OWYxM2I4NDIwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUzNjQ2ZTQ0\nLWFiZTYtNDdmZC1iN2YyLTdkM2FmODBiMGM5ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAEfmTtwyQTXiU3SYffFRzGyYIWMjlNJyPSo07rlBhug4P7nSTt7sjBn\nA4/CavhhPGqnz7Q6fPCamkbmY29b/GejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFER+H4PX\nQVcKX19eY/FN5u296wi6MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA/Cmft5tr5HeqGSA5poOcqDlMGgL2HH3ioa4o\nCuGkoTUCIB2IJUMzx7q/3ZH8yrMAIzFrprAN2LuMvtqTzhGqxXri\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1450", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1450` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISATqetLVaLZlhZ/n3n5XhwQqdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwMmM3ODM5LTNkODgtNGQ4MS05NjdlLTM4MjhhNzQ5NjMyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWExODNjZDAtYzA1\nZS00ZjQ1LTg0OTgtNDI0M2IzNmM4ZmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf8BN6YWmNKplxPAgctPHBNhlpkLeYtfl0RwXb6t/HZseeo+Y6ey7T5ZsVZvt\n6oxEqiP3XaHY81wKli8/2X4b6KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj7UJCDbb3VP+0XQqhB7VH8U/ufkwHwYDVR0j\nBBgwFoAUFP+PZUm7S7iJU6qQqNKpos3xLUgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCwsDRvRdPacTc4XPFqyNVdpK7JDuZL43YF0tbTcdl8bwIhAJJOn1m+\nUOdZh9WXbQWdeBx2CnLxtBCrwDCV1SvMjPSJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfJ1O3vAi+73DYmooKkvCzjAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDJjNzgzOS0zZDg4LTRkODEtOTY3ZS0zODI4YTc0OTYzMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIlsLIlt5Dz50hOQYQO2nbUt4R9vlYcxUk0VR9XhKgX1Ks\nRg6w1CXnhJfOHaol80m6OApyaC1Wgjez/EbpG7Rxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFP+PZUm7S7iJU6qQqNKpos3x\nLUgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMPCtYPDIgxzaGDPloZRrGgkoXaoKQE1dLnSJb6+CqqVAiA6oSUD42X/\nPfR9vui/yMouof4OkRYc3cBwlUCjuOrP5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAa57YEh7m6ZcDUExDkb9OHrGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWExODNjZDAtYzA1ZS00ZjQ1LTg0OTgtNDI0M2IzNmM4ZmVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDViNTRlMmYx\nLWM1NGYtNDYxNS04YWI3LTFlZjFiZGJlMzAxYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFg+6pOFHOYMMylCX2BcgZl9SpeNg7+BS07HDrzOpdNmnfo2hj7eftAd\n17j3Szn8VH5iBua1juvZsRzP55/t6gKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI+1CQg2\n291T/tF0KoQe1R/FP7n5MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiA6/gCMba5Hh+sxZSSm/TQNWksvCZ7MwvBreX+d\nEkXcWgIhAJSGSsFsX79CZADpry1Ga7ANEwXTsaYFiQM8TJbbtYOr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1451", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1451` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAWn6ZLYqjwnA8uaOI3fWDaqiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MTg1ZThmLTg5MTAtNGVlOC1iNDc1LWQ0YWI3MmVjYjcwNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRjNDdhMjQtM2E2\nYi00M2M5LTg3MzItYjI3MTI1MTQ2MDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEULLOaCKyKmeKTSKVYx0k0I4y87ikTZCBJd1ZFZa7PB6RXMg+TM4J+uHwu95a\nLt7Vd+se17HLJqS8PV8w/1vvhqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUBl2sWW2z8KKAAn6ZpKqOlWe3rUwHwYDVR0j\nBBgwFoAUJiMnEjnuS9YPzKKkc48jNeKe8xQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD/M0eXh89uZsCFJqa5Yalt2Zuj4Gd9AuvGswM1\no+WchwIgWLsRUog79gRJgM6xx4UKWG/GIxyAtLw8sj/wjscb2YA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbffof8ij9sssUYZHcljPnOTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzE4NWU4Zi04OTEwLTRlZTgtYjQ3NS1kNGFiNzJlY2I3MDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGypfwiRuXUqWy9oPqr++4KyyvxfKgoibOCr5AISE+lv3L\nqkRB5OjQZTV0NjDeM68lkl26HpFAzTO4OdVfVFyzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJiMnEjnuS9YPzKKkc48jNeKe\n8xQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKJTowZAu53ugkF7pCB4Tzc+/EPDNpnPmFcAeRUcny8WAiEApYmmqY98\nFtKO1Ha5kZsOaQCuE3zzP18e0zBYM4aRd3k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATXzsDXEiLbxEWHtDnIxz2U4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRjNDdhMjQtM2E2Yi00M2M5LTg3MzItYjI3MTI1MTQ2MDRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUxNzA5N2Ez\nLTQ0OWYtNDhkNC04MTQ5LTg1OThlMmZjYzNiNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCkOtfUhuj6PU9nRBVQ7EyLcD6/rQYOt+VJlGxehsti8ljc3kwlrcG23\nLvraFIS4FoEyIl7xE+nwMGp8rHDTxeOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFAZdrFl\nts/CigAJ+maSqjpVnt61MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAZO9Z+8UyMF444Aaj2eZFcJ3TFsQi4e/Fs5MGA\nAl8YTQIgcH+A6DFjNsSHBQeurCRk2RB8w83jIxAmMaWta5Zq+vI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1452", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1452` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAa1UWqwupVxYBTRTwk7A7gTZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ZGQ3ZDc4LTYwZDYtNDBhMS1iOTdiLWExM2YwYjQzNDcxNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWIzNTA4NDQtNzI0\nNS00NWZlLWFhMjMtZGM3N2NkYjU5NjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Gu9SWD95l1QfKamzW6xnci5OLQVtpRZ4/z3bYy2IjsLCOsAItYeqPqO74AH\nQ2ZHXsclik/yr3Dku72jKJmIuaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB6gFuJjmknSbu0PxCQaZ0SxkyYMwHwYDVR0j\nBBgwFoAUI5qPHYQO9vUUOamfbyl1h/Tl3DcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQD6Wi1tve7hgD4n375cXDlAh1OTJldiCwuwF5Pa\nG23f4wIhAOXeM3n9gTURnrP5iKlLxgH+eREcaSxAe29HUHUd4l0/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYbElfePhExoL6Dz4hLNt8gfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGRkN2Q3OC02MGQ2LTQwYTEtYjk3Yi1hMTNmMGI0MzQ3MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/eAL74TP8x5i1zNbw46FL5XecIghuhoSRGmfpaUZ2676x\noiHTKvkggXYtHH64txJgBziM52J+ktXC3Gsh6r9co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI5qPHYQO9vUUOamfbyl1h/Tl\n3DcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM9EcyAj5Oaptzge0Fv6lwVKqNnNua5zr28gtz8XShrVAiB5GEce2SZW\n0cwNX9mc7o+avhOQZlt7drlu4CESUViBuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAbA+FB7QTDr1iTxyCY3/3obtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWIzNTA4NDQtNzI0NS00NWZlLWFhMjMtZGM3N2NkYjU5NjRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM5NjhjZTg2\nLWQ4ZTMtNDI4NS04NGZkLTEyNzNhNWRlMzY2MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ3NrP8ysACsDlK9tUoOucTK7fRIXeJ90D2XoDfOsRSA0M6FLVs+I4Jm\nhgJ9lgqJo/Bz20SmCpNMXVamkJx4nNejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAeoBbiY\n5pJ0m7tD8QkGmdEsZMmDMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA++ucc02h6YFBN0PWtrd24cX84skIZEtPpdp4\n2RQW92kCIQDnyQOnHXOiPMUch2WjZjoUYl5LOyhYXZAaNHCJ4gKOQg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1453", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1453` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYdE5TUGWjHcguWKdcnE8sMnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlODc1ZjVkLTFjZTQtNDM1NS1iZjBlLTU0ODU3ZDY2ZTM3ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE0MGE3NmMtNmIy\nMS00ZGIxLThjYjgtYzg4YmM2OTE5NzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmfIXZSBLR0hD3CxTkmSlqDDQVb2qYQN3+i4nsI5tVG1fpRTUXH6wQtsRqKjR\nJZK2ctCHv0USQ3wuVrOIuF5+naOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDLaVPpha2fDNarAA2FiAuzLYWLowHwYDVR0j\nBBgwFoAUWN0033xzmBPUFAJ/YZ20etU8imYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDgylyYOLM1TYIWLrPyhd93tfjQtxHDmeb2NYJnZqdCYQIg\nDeot1NlnQMqvNHNJd46a9l9EIYPVHaTgh2mOa4c7D+Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVIziv2gtdDPjeu7zl9oqWG4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTg3NWY1ZC0xY2U0LTQzNTUtYmYwZS01NDg1N2Q2NmUzN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDjGExnnnaPsGZdx9oeK2KuBDvZe/YB2ujcs2Yr6XnmR3D\nZhjh7bXcRFua/5Chc6Ccrez3Tf80YmGP51FNDxpJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWN0033xzmBPUFAJ/YZ20etU8\nimYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeVhcuMiHVNvtUpMHsETQqi1OkdGfVcR5QnT2nHQduNsCIQCu9O341llu\nlol2ICWMrI+DNogj/CJyG+noaokikIXHBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcdux9nwv9JN/lSPxuDa4ezwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE0MGE3NmMtNmIyMS00ZGIxLThjYjgtYzg4YmM2OTE5NzY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE2ZDEwYjJl\nLTg4NTAtNGZhOC1hNTQ5LTE3ZTIyNmU4ZjY5NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMJ1uu6Pmo0Em+KDyU+NPy6ztRAmTBgqpiFgQRhTFzhQICFWTNPLeYC5\nxcp/iIGOzcJGTjHvJiqx7C8VtJ3zr4ujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAy2lT6Y\nWtnwzWqwANhYgLsy2Fi6MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiA77ik/7/6aCy06P1xp4G1KSoY9a6vnsOFAZMOV\nCmBTpgIhAIZ5N85ojYjhPXqTxA4yZER2mHndPBcvdnva/Bu2HwVF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1454", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1454` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAYMAcuCg7bNIkyBWmUMniw9MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyYTZhNTNlLWMwYTMtNDAzNS05MjRmLTczZDM2YTNjNzA5YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg3ZjQzNzktNmE5\nNy00NjZkLWJjOGYtNzQ3OGZjODI2OGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERgwaP+CKT+l4OvwT8C1qH21/0v/J0Da6qbm8PufsiFW0NhMaoWoseZ+DfYHt\nCYTD/Afln8MAF/9Nd5vK4AFa4aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo+6yD/BAHnLZAZP/zHuoJY10fbMwHwYDVR0j\nBBgwFoAUEifn8A34cD4SUzUuqYJwTK/CTTowSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCAb34+jNzt4o1qHkRORltG5m9iW7/u\nv5QxPLfv4m+uKwIhAM8HFRRf4+FFinja8fiKcHiFz3skhAfwg84CRDq/1hKh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUxWQT107syUuy+EokRlEJYjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmE2YTUzZS1jMGEzLTQwMzUtOTI0Zi03M2QzNmEzYzcwOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpfnpg/9vmjRa0C6fddQCpZ04NBCTjOPW4G96hVsb1XiT+\naJAarYnAQV5WK7kkO9jQ726VzSK9keNbR4Px102Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEifn8A34cD4SUzUuqYJwTK/C\nTTowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALR1/A9BUd++MBEE3lwNwqbzlSDe140Cje3JYedCB0LkAiEA/Z6OpKVK\nY26in4hYngmSh3mciMRLQ8s+6p5wZZiswXs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAbNdr2sX5nkfqoVGmldbVQu5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg3ZjQzNzktNmE5Ny00NjZkLWJjOGYtNzQ3OGZjODI2OGUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg5YmU0ZDU3\nLWJmZTYtNDFkMi1iNTRhLTAzNDg0N2M0MWJlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAR4uPWK6mN2LcIYtrXLoCVqt9NBHXDq81V/sAGx1sRWYvFzjczx27OJ\nb63NZmEqzkD6kfai9iqq1u4ml1AIKnyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKPusg/w\nQB5y2QGT/8x7qCWNdH2zMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAr6EhLm8RjwI+i9wH4foQLfkhpYjsKiA+Y3+d\nnGqnsWcCIQC66EtNjEYnZ+gDlhD68UMRPe7kJsxo+V96LuERGI8gkg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1455", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1455` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbQxu20vdfyWGq8dEiFm94/lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlMDI4NmYwLWUwMWItNGJiZC04ZmJlLWVlZTc2NTg1YjNlNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA0Y2U1MGItMjUw\nYi00ZjAwLWFhNjQtMGZlOTQ1ZGJkMTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPbQditvxZ/EMwL45GhiIKNtPQohjcWIPh/RKvbgetgtV432y8T49hljCZ9T7\nCODQqMQ+PMvLyo+0/dZMJdBO0qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyvyzokzPOKNjS6om50h15S39imYwHwYDVR0j\nBBgwFoAUcDNulz1vkBPZKcNWvlcTbo0OQjowSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC2ZkdAeik2D2yDMB0wQdMbu8D3u55p\nF59KGwp906VhVwIgKHim3kbTTzgv6/8IABsp/8GLRlUmWHv2i0iDb59PeF0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdghPAGa4FV03ZLRw+ZnGsoCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTAyODZmMC1lMDFiLTRiYmQtOGZiZS1lZWU3NjU4NWIzZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASK1nRs/kTuuHP+9NslbbwMYO+B7veUMwwdsFqARYVrqp3V\nKSdha+3VjGkISwSpjNnZ62EDJpJ09Hx4/DPl65hGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcDNulz1vkBPZKcNWvlcTbo0O\nQjowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUzwM/UMNCYKgmm2+6b62NA2GqvUbRHIWeh9lcJ0rTYMCIDHwbTNvcG6l\nuMuKUlol9+2czCB3ZYv5I8cbcalN9U8A\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISASiFzxyo3UQUfjdGV6/esYtKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA0Y2U1MGItMjUwYi00ZjAwLWFhNjQtMGZlOTQ1ZGJkMTUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNlOTM1NzAz\nLWVkYmEtNDM3My04MDI5LWU4ZGE3OWE3Y2M1MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPJzXgYhbxkiJDvw+RXaulv6MiAQmkYFn/0vRO18lJ+vy/v4hRq/Beu4\nLfmmS90tl4dc4x0cz7Bcce2PngLerMWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMr8s6JM\nzzijY0uqJudIdeUt/YpmMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA5J+7CsLgkMXKciJes9HS346ruc7YI+vVMzs2\nyqQurfgCIQD8JU61Hg0eFQhLp0kQ0D8pd+RjYvBlQ8bzDBTTLCwrXg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1456", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1456` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASj6p3w1NLQPJr6QYG0XrPb1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZDZjYzYzLTAyMmMtNDFhZC04ZTA0LWNiMDc5ZDMxN2MyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRiNzM5YWQtMWE4\nZi00YmY3LWJjNzktNGZlN2M4YTU3ZmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELC9ylUri7mkvULm9Pyh42US0xZ+55maN7yM/NhfdOZK6nuTQXOX6i3pkCoH2\nLEXBEeqX4Q1TzP19Hn549wQr9KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVZM7KjsI7di3aiV55KlbG7Bl3J4wHwYDVR0j\nBBgwFoAUYOBwsXisp5F7GheHKEfmS1uVyR8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD1fUcWzx1O\nYX0YqRvTuDYnatae65tEooDzWDYzXB0kEgIhAKFacDthZQagxWVub6GEwd6KXLIG\nKSyHJhcgzsXL5OlS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQM8TM+TES+wBTi6nLeoPIBJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmQ2Y2M2My0wMjJjLTQxYWQtOGUwNC1jYjA3OWQzMTdjMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATos5ChJCpB88OlssmQoYqFU+81B1nAQ4WVNiU3CB/KAi5e\ndp9FO8TmMe62ijsu/SyT0/WehVHiunVnP4TH16+Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYOBwsXisp5F7GheHKEfmS1uV\nyR8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALy8arUZzDOemmpNYMa2vbieD6VI6a+Udsj4yrec8tIxAiEAuw9h/Phh\nPDNzYsBsPajpM34xV/8PfPJd6HENVJV9pA0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZhSuwI4GeisuwN6y7f5jq1dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRiNzM5YWQtMWE4Zi00YmY3LWJjNzktNGZlN2M4YTU3ZmViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVmNDZmNWFl\nLTNmMTctNGQ4MC04MzM2LThhN2Y4NGMxMDIzMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOxaXIoyf6j1MSGusXAKb7okDGi/W7ITGBCyfRoCwweUAvo+vOlgT24N\nHmxh8gwGmSEGRo+LlCcDoyizx8Wofl2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFWTOyo7\nCO3Yt2oleeSpWxuwZdyeMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAnPphRix+/du6SNQ9YoJXi3DboVts5l8FVA1nX\nz8MqCQIgY+nUcgnQuTfu3YoaA3Qb7UIU/RAbG8ZmYHUGY2pfrWo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1457", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1457` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAce0m82czlFUASaxVNRvYWTtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNTk4MWI3LTZiODctNDY3Mi05MGZhLWIwYjYzNmVmZWE1ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTExOGY2M2YtZmQ2\nNi00ZTczLWI2MmUtYTg1ZGI1ZmZjN2RjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXoNIpCos3PWn7yoO6yxxcuc6Xv5atif4qSFYIuw8htAQlGitbr4YtT0GGUMR\n6m4zX7SM6NbglSvRP89oph9ZH6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUSKG0rh96Ql5sggpr83lrQhHU1MwHwYDVR0j\nBBgwFoAU2srMKzOGXpltU2d4Usb3mxcgdzgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgHrajMCm//iJQGkwE+uzXT459ndhDJljhHdk2CcGxHYkCIC9Hdgbubinl\npwu3NTIQl90I+jb9tylvlkD+3KWspEtz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVQBk157ktSaMgbXaJqzkGv/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTU5ODFiNy02Yjg3LTQ2NzItOTBmYS1iMGI2MzZlZmVhNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXyrBa+wRW4diWJfzzNYLrmgJT49FKSoEKYLGDnyK5s+Ga\n4imTyyhQIXn3ppq3snuKyph7PjwOVU6hcIaeMLOGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2srMKzOGXpltU2d4Usb3mxcg\ndzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBKE4A7/C4J1Lft0jd1h0cgC7kZFOTTZGPhITSnP6gKICIQCIEMlzo34M\nuCOxq/n8f6+M9HMeoWD4/GvG4vXthT9soQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZJuMzbnZ8Ra0dtQZj+L5ZBAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTExOGY2M2YtZmQ2Ni00ZTczLWI2MmUtYTg1ZGI1ZmZjN2RjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRjMTAxZDFm\nLTA0YmUtNDUwMy04Mzg1LTVlYWJjMzM3Mjg1MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK2Eqzqiaj63WlFH/mLe4mbk1snWNcDdezE9YG2ftBnLaLkmhdeD/Ufo\nRWg1wytoHrDieZl+RYqss33zt5gHqgGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFEihtK4\nfekJebIIKa/N5a0IR1NTMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAuYizzSwWjbCku+3zmSHlcvSFPunJaQ6r1BMIN\nzPg+zwIhAPq4s6GYvkhg5zKt43ZPq1LIJRduVkFCCflVXUeXh5I5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1458", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1458` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAY3kSnVsknh7GwmqmZKW9wopMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0MzNlYTI2LThlODMtNDlmOC05OTYwLThjNTJhZWQyYmVhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ4NjVmOTUtZjY3\nYi00ODc0LTlkYjktMmNmODM4ZjU2OGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL+GtPQvxdJNT/8n4wgO2jfL2jxKr3oTl7GfrW51wx82KVt8lnLqClYSiRmYf\nmdYd6HGaMlhC8JddeJcYhlFQFqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt0llL9yf+w3U4Bu6ctqYHnDpZMkwHwYDVR0j\nBBgwFoAUlXPrbN37/IVax1/auUBywj0d1GIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhALoJV27X2n8WQeU+EBC7xBMYi4nNSliAq3zuy1lVOt9qAiB8uC1ZuYQP\nFdA5WOHmRz0kknczoxxIaKjtxARCdf0pAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcH7Mzej2i7LjGfExTgV6eryMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDMzZWEyNi04ZTgzLTQ5ZjgtOTk2MC04YzUyYWVkMmJlYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEOoWBhpSL4RZqGBI+kjBP8Mz6iRRM/gHC5KlPtNbpDTYC\nc+qtkSNhaiSqxbPqpDDW74RREfsXLd2DhqAAug08o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlXPrbN37/IVax1/auUBywj0d\n1GIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKL4CD48KOBHUDjtj/+BpAKkOJvMyefNrL6j53VHE+s5AiA+2PJTLom9\njsiIjxUSvuwnFYs5gBBAxiFHKgd+rNt61A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAVMzoc819u8Y3UtIBBTCXmSfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ4NjVmOTUtZjY3Yi00ODc0LTlkYjktMmNmODM4ZjU2OGU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU0OTQyN2Zj\nLTE2NGQtNDljMy1hNDIwLTdiNDYzOGNiMDhjMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPbgSIgD2ExTWrgCylXvWoH6d+yYzUiDtYPkqK4618Z0y0g0+tzYVbUx\nBfmKHKc4/LQczqgi9xoy6loWZdwV3DGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLdJZS/c\nn/sN1OAbunLamB5w6WTJMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAyiEH44Lb3LprXy3L92xDM9s0ID75WWk6rZgaU\ntp1rIgIgfEaYs8zH4UkJe58LtlU9NjNBHySH5U67OM+fF6rSh+k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1459", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1459` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAeOeXPS4bEXsmIrGjbrpP7PiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2YzY2ODhiLTAwYmQtNDc0YS1iZjA4LWIwMGNmZTVlMmRkZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhiOTU0ZjktN2U3\nYi00YjUxLWFmY2EtMmQ1NDkzYTE2NDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOfyUt0htLyivM7r6ll3HN2zkJULRubIO7un4oGu8gPKQM/me3rh95vdl+3i6\n0QH/hqaLDuki+7GW12mWQPZMv6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPWo4mccNhcwJGaGbd2arT9jSPGgwHwYDVR0j\nBBgwFoAUdlkT/C/Luu0XVnHs74ph70nObEMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIAJRSpMQOxxkfWCwcOcFcjla73KX0AyxAhHajz8G8MKTAiBLKcDusC84\n1k1+3KAAl59A03NM/4iY1Oz+PYhYunG5Tg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASVHGCXbk7sC/NahMve1FtxtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNmM2Njg4Yi0wMGJkLTQ3NGEtYmYwOC1iMDBjZmU1ZTJkZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqCDPBWzkNaYlU9WREyEtLpMYpmgLanYSKN7ITFYU6/Mgx\n2IPhFiDEwMr9hCwlFDVxnXj33aX2FlAdBDLdJuAgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdlkT/C/Luu0XVnHs74ph70nO\nbEMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc4apFGREfshea6cwgwH8sKFKxIrggu3gqx+aDZtgn98CIFc8tUCmfw6e\n76SowjbHaAVdeU5RZ67kGvoui7eDB2j5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARHey+ANX7Zuytr9PHKinvsdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhiOTU0ZjktN2U3Yi00YjUxLWFmY2EtMmQ1NDkzYTE2NDc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRlYjA0NTg4\nLWU5NjMtNDc1Ny05NzIwLTVkN2FmMDcwZTcwYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA6lCX5aoSPXJA5L07w+VKAHOa+YZo8cagDtrvTzRgFzFqJG75vf0J0H\nA62S+JK6/gp5shT8mH4q8ylPzRnHV4ujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD1qOJnH\nDYXMCRmhm3dmq0/Y0jxoMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiB7I3ZozSPPCAW62FIAQ6Y5XVlWLj+bm+jgA6PR\nCHbXqwIhAJE7Pu1Rs1OafOPm4yO7dhGsCrvX2N4ikYIfxh6ZPTtC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1460", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1460` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAdXsfhftIRyX4i0lJ7vwi3JOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmZWVkNGFmLTQ4OTMtNGQ3My04N2ZjLTdhMzhhNDI1MmYxMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUyMzhmNmItMTBk\nOC00ZDZmLWFmNmEtYWZhNjk1Mzk5OTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUq5+bxWAYJ4AxwcVvj2L6j028iJ8LpqxEBKshBoxgiU5vrZoxrM518jiObr0\n2+lPD9w++ceF83t82l8Yb93Ab6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNuFaopfQtRN5PDnixAD34QrqFMkwHwYDVR0j\nBBgwFoAUab9HLZbbGbBrC2LvFnUBO+3p7xAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIG81ayL3i0y6AqXAaZj2WcszE92D1HgWueTTtaj4\nlHPMAiEA8c/IuUzy7G2/dn6Bx5EOCHpNoHOkNFqnqa/Cr7LQ/Uc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQgI/O1mH4yDGWdSFsBoinm/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmVlZDRhZi00ODkzLTRkNzMtODdmYy03YTM4YTQyNTJmMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATD8PGr2TOM3uyRHjoq77rR8XH1e2MLaw+6fJVIZ0FtimmC\nnBU76/G6iunsDNu9TtfMaJAlMoVw57VdVPDRZ/Wxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUab9HLZbbGbBrC2LvFnUBO+3p\n7xAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUFRU5nMxzTWMAVJ2ZcJOGrp9mUD7PuCQg8cIy7OBTdsCIQDFlN/Csbud\nxglM33a0snd1luXHB7Jc+LiSM+XJ2MObGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASnW9IF6QQHQ/JSx6FvPezAjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUyMzhmNmItMTBkOC00ZDZmLWFmNmEtYWZhNjk1Mzk5OTZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJjYzVkNDcz\nLWZlYWQtNDQxYy04YTJjLTdiZWI0NTI4YWVjNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKQKbyySqvvZTpKgHm1n+kr7Q7Pm1npxQRYWrBrVd7lrn9iKAxlrQ5P2\npWRbSu1HjBVj7u/XlBmc6hrBvYtFOImjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDbhWqKX\n0LUTeTw54sQA9+EK6hTJMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBcndgqpEwumAvvAqDMMJ1pNkNVX+cYU0iMHceL\npqJtMgIhAMRQEDfoYf6oT/3XsVXJqKtpXe5dsZ3n0gf4xKwxlegq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1461", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1461` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAQBvSn907IY783qAj4M5vKssMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3OGU3MDkyLTk3NDAtNDAzYS1hZjFiLTQyNGU2NjgwNWIyYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQ1MDkwMTQtYWRh\nNi00YzExLTgzMGMtYzlhZDA1YmJhYzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBwzPMnTVecGAh/RcUQH7rH6UDIcN3nd/06zjJU+SMvmqftf/2uQJCf5ewXf5\nbgKGTWFw8i1V0oRUvpDnG3LpDKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeN9Kw5crEx18pCkeyGDFv2GJA68wHwYDVR0j\nBBgwFoAUoMPLMj88/18209jxF6uoWAsJv4QwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICkEG6eAKcuTK4KOjJKwIXacYU/y2CUo4pLNuH+u\nvdLeAiB+qL8qIBo1bS+VxC7g/MEG3m0napqXpscZMPdzcw1FmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYAomaOVk/GcOXhcAT16EIbIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzhlNzA5Mi05NzQwLTQwM2EtYWYxYi00MjRlNjY4MDViMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFaVQ5r5lQecIJOvOR68340eg//uMy4b+cTgobXmbIWYkV\noTtNsRkV53Uvl1YzUyONgzt/7lLFyxC/DKSoGTUBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoMPLMj88/18209jxF6uoWAsJ\nv4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYiRgWDuUvWJAVCOuQG5pvFR3fSYOrDTrD5vB5Emhk6gCIE7kPEwnJhEh\nbgc5lsdxUOb4Iuy8Fn4EGu5HpWqpKJOt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAXUh51Un90K14h3UAA4eSynFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQ1MDkwMTQtYWRhNi00YzExLTgzMGMtYzlhZDA1YmJhYzAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUyNTgyZmFl\nLTMyZDEtNGFjNC1hM2YwLTJlYmJlODhhY2Q5MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJUmR82naoZxpoXTyxdBzagKPg2fPWjnnO2YqXXcpZywIC1uH8OK/AEC\nkdb9qe1IaRmOlZctYWSfQHXZRhpmtrKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHjfSsOX\nKxMdfKQpHshgxb9hiQOvMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAvq16SftDPZUsZ+M5Nzmu9VICSW2or+Y/SoN5Z\nThrqYAIhAO/HOsDdeVPB+795d4pJTCX12u6on8IA/pJRocmIihFT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1462", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1462` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAarn5BtnnhMDknr96hpJ5XfnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1OWM1ZDZiLWE2MzUtNGM2My1hNzE2LWY4YjQ0YzljYzkzMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY5MDNkZGYtOWEw\nZi00N2Q2LTkzZmItOWJiMTRhYmZjYTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZkz8kxP8PXty5YJKRUmAxT2qu1+BM4XSO0EIm2jVkoPt/dY8T3wmGr3dNYC0\nhcaEJ0E2ICgr1MY43tlEfQmCrqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqTB04Nrk0mPv9RC/jg4smILWsqAwHwYDVR0j\nBBgwFoAUnkWYHsQA+EzDEngDnRyH9H924PQwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCoNDwmZehnnkWV+8UIirig3UQk0SVR6qHj26L1PSP5RQIh\nAKp+84cTnHTPvUkaW+IlXFjNzOy6xgLiX2EhCXmteCnX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASMNYofpvtbe3Ex8pCUkl0JMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTljNWQ2Yi1hNjM1LTRjNjMtYTcxNi1mOGI0NGM5Y2M5MzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmVUILo2RO/b81jWJPhLepEqSt6akXDrUDPvUhKn5ptrlm\nHhmpy/L/miMRFMdAT1OXjzi+PyN/Pk0OHNL54hb0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnkWYHsQA+EzDEngDnRyH9H92\n4PQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANZ1wSfMqlANM53WTEamKr+tDnRgH9KP+ggw3UcS4iOSAiAXHHC0RSvQ\nzgmRfaEaWZajRRmjKFUbxcA+94YevWcWzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZHZ0+tl5g/e5+FsgcIHT/mhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY5MDNkZGYtOWEwZi00N2Q2LTkzZmItOWJiMTRhYmZjYTA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNmNWM5ZGMw\nLTdlMjItNDQ5OC04MWUzLTg2NGFhYWNlNTllNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHX3FHxw86dX4kZi8RcupG0a7ctw7LVOCKX44+uR61NA2tDHiT8vFvA6\nTGo5nZnxWRKKMqg8TfPeeihoA6x7C3OjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKkwdODa\n5NJj7/UQv44OLJiC1rKgMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAyxrEEy6utP5BeA4kOGk8Op6VTOqCRFaaupAx\nRnShk5sCIBQstX+kMM5m6eHIDaFiXv0qHxx7Ym5aj2m2wfOYqwA6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1463", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1463` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAb5Xhh9VIA9W8nPCYe80KV5GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzZmQ4MjE3LTVhNjAtNDczOC04NTgwLTkwYzM0MTJjMzIyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU3YWU0ZmUtOGFk\nZC00OWE3LWI3YWMtODliNDg3MjAwMzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIh77xoCuLoYIEecig3V1MnQYSAuTTIGE7qaoOtr8F7h/tYS+OsEDnoWyg++H\nft0DRmiVxjxXLGsEE1vwfAZWvKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSJf+NiWw2KRllbC9URIJrUutpiEwHwYDVR0j\nBBgwFoAUa4/ezF9UK5tjqKodQUg8QzopkEQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIHVMXgGtoelVtSRvLO8mS/PCfjb54Kx6\nmIWqXUdA8bcJAiB1PIC2YCJhsuvSUAzLaVynuRHcu+TtvtFjsx/qL+OjZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVuazRtlAJlsUsMjh6Gi/Wv9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2ZkODIxNy01YTYwLTQ3MzgtODU4MC05MGMzNDEyYzMyMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTnjXkq98tCjXCH6OSCg45wIWEDQu2F2jQ8MAG8V3DyOVf\nlelVE14Rayu5qXfSL9OEEa83OAt85wqvELQ6g0NAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa4/ezF9UK5tjqKodQUg8Qzop\nkEQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALVUqKtXqRS6i/3P2lUbskk1LcYBwAGGdll0eCq25w6lAiEA/BR+l+qC\nBIbRcRegR58Onis/o3fKanKM1xkjCGg1NZ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAVAeDlYHFDurXWZNl8nULj71MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU3YWU0ZmUtOGFkZC00OWE3LWI3YWMtODliNDg3MjAwMzBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFkYTI3MTcx\nLWViOGEtNDJmOC1iYzZjLTc1ZGRkNjFkNWNjZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLKlQlOe+8w3UgPzuNjK25UGG1gmaVW28AUCWSoDGY4SW4rCvGiiS7oR\nmwLtvdjNyaKq6CBVUTabWErxCZxRQHOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEiX/jYl\nsNikZZWwvVESCa1LraYhMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA0ZhVS2e1O/QbGaTNzasuCLDKWK+Zu8xXJTJS\nfRRObOUCIQDccXFDfB6xixf+KjW1GLDsxA91rnmDss7imWzFB0E6Gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1464", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1464` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAZLZFDt/OIVnbhZGSq6ur7OFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViZGJjY2MyLTJhNjEtNGZkMC04MDMwLTc3NTE2NmZmNzc2ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWM2N2U1NzgtZThl\nZS00ZTkyLTkyODAtNDE3MzM4ODgyZjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpCsmlVJOcgFRpoQqMzYrY4QTQ2olt5a5xKM9GF8Orf6RMYVrHokcsbDV6lGs\nj2cADs6JlYUl2B0kwXtZ/m3x/KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiyiWNDZRToChs9FFn1XgqQxUpogwHwYDVR0j\nBBgwFoAUyQ0griLTxOhDfhNm852GyZaf+18wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCzDSrfA7opuJdNwo0+yTXMEhOA1o9v\nmlVIO5vrKiZ7EQIhAPdnffLfneb1ZkFtth4N6lLWam3Bp3C7vGcEzfk/5h6T\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZwKEyfnpiBigSnxN5UrMSnvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmRiY2NjMi0yYTYxLTRmZDAtODAzMC03NzUxNjZmZjc3NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqsuKcvLS2aGyVHCwF3LTwmkm66Q0vvFJjIcUyyamD9xDf\nBR0Y6eQ0YQBC1KtPo6JcFhtoP1ho14kQYTB9uFBXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyQ0griLTxOhDfhNm852GyZaf\n+18wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPShOx/hwzT5LWhIAtOwwfqwEI3HHMRVRRPR3ywu2RE1AiEAyFCKBkz1\nERqjQ0p8T3nokzkhl1diomCOyjZ3okD51T4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAab4d4qmH3jvGtdNASrtY66GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWM2N2U1NzgtZThlZS00ZTkyLTkyODAtNDE3MzM4ODgyZjAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgzN2EwODdm\nLWJlNDAtNDkwYi1iNTM4LTdiYTgwYTcyZWVkYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP2gItRH0NzjSxS1ueINce7O3XQ9Hxqhxn2g+aPE0KomlbJyAXqjvkmn\neWGV8ee5hUMzS5ydgfN0yO7bS+0JzaKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIsoljQ2\nUU6AobPRRZ9V4KkMVKaIMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAkmsM1i5vAweK6PImWqSap9gUxq8Ae/r9t+zR\nifU3q6gCIH6Gbeya5Ii0JiQwfL+c3yWdM4X6HOIr3ZCf6b41xbMp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1465", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1465` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcMMQVcKq61k2Gt6BTlEmoR0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyNjlhMDFkLTY5ZWUtNGRiMC1iMjZkLWRhMWFhMTg1ODkyOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRmZGQ1MDYtMjM2\nNy00MjgxLWFiNDYtYjExOGUxNWYwYTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWuQcRciLD40EttMKu0LVF7VkRkRNpmwh7URpv4qsKRV9O2e8WL1A0j9tKjl0\nbD3dWabVEInfX4rwtWRrNQqM3KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHlPXJ+HNCzU54U6peYgj/8jicfKMB8GA1UdIwQY\nMBaAFOIQDns8AWOlZnv5jZ9h6dQ2e5j7MAoGCCqGSM49BAMCA0gAMEUCIQCNylHO\nn3Ne+IM/iqlbVfGf0O08rSYduJ696K35m1SZWwIgY6yjdkzxKj7st/izBVHj45vi\noCvh4KZdzoSFkF01zBg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASEyJNbcwan8Fkt79qoRJlhSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjY5YTAxZC02OWVlLTRkYjAtYjI2ZC1kYTFhYTE4NTg5MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWKNLoMPC/Dd0ST1kPsYbwSCzPfSNDCKDFDpW/U6CYvlxF\nERir+r9YSZjNPITOBmBAjJeALApOUaKRwUIPfjsHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4hAOezwBY6Vme/mNn2Hp1DZ7\nmPswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHXbh10ciKxLRNCSeCPxqtDwoTVoTmHVSRQhJ82u5UIYCIFOaYCPxXEWQ\nruhCPK+/bzh9Afr9t7VucMTqrzqJFEyt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISATCX2TznUBIZQs/Sqo/zG0ylMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRmZGQ1MDYtMjM2Ny00MjgxLWFiNDYtYjExOGUxNWYwYTAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMzBjN2Ey\nZC0zODgxLTRmZjctYmE2Zi1kOGM0ZGVmN2Y4YTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQRn8gfHoqjpr3u9cNb1eAQDLtv37jzoByABl6XsTGVB3b9IOtMqIb0\n7SGWc9CGGEn+TNNRxK7eOqNxpws11+Poo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5T1yf\nhzQs1OeFOqXmII//I4nHyjAKBggqhkjOPQQDAgNIADBFAiAXc4ULns2ZRq1H9Bxv\nhy3kfWQAlRJNbBJJMd23m2ucOQIhAOx1aXjR9EibneluSW8tcGtXmVF7Y3VT3Bm4\nnjIEAcst\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1466", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1466` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWB54MVh6eEXo6fthNpPBb92MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmYjZiZjQ2LWI0Y2UtNDk5OC1hMDcxLTExYmRhZjE5OTRjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZkMDVmNDUtYzI2\nNy00ZjA4LWEyMDQtZjk0ZjJhYjk5M2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElyJg9LouTobZPf+pMxwcyHJsgwgdBiJzJC8az7v9rgth1WJLVmwxCyQp9Su4\nnutw+EfXXR7WaAwUicOwYKeiNqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEY9o9s4yG9ehJY2a0k1iIDJMfD6MB8GA1UdIwQY\nMBaAFG3zRZfF6qOLqWWrMenmIBSKpZleMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAnS6z9JAowXd5kIGMmB1cCbKfIbVHpcp9f\nmh5FmGHLHwIhAMmCsoD+lootk7FIrFOD/M/uNf9GU9LpyowHRvTZ/gOf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASjGpiBzb7DGXkdNRdLf4rG2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmI2YmY0Ni1iNGNlLTQ5OTgtYTA3MS0xMWJkYWYxOTk0YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREULGOk6aa1jBCaWOaP8Jr5Fko0aSJioTBNy2ypwvEQcj3\n5los0CAxwFYMKdZXmMHDncSS+za1ZTcMD+DTLRs3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbfNFl8Xqo4upZasx6eYgFIql\nmV4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJumWqb6kC8wYfBWOz544ZZCfPRtvYtsqbsWArhCjpX0AiATOzWEnIaA\nAsVL5OG7VYJmXSogewBSQrcIawjueTRG2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAUZyfg3wt+gJNyKonblJpCxjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZkMDVmNDUtYzI2Ny00ZjA4LWEyMDQtZjk0ZjJhYjk5M2E1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NjMxZjE1\nMC0wNDdmLTRlMGMtODdjZS01YzMyMGY1OWEzYjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARzTW8kY0cUrxDvg7Lz/Hzt3ikhRzPJHQLW6RH075UC4Own1OnL0Qx1\n3fubJ0E5Wa8WRwawZG+EWmiz5Okroejto1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGPaPb\nOMhvXoSWNmtJNYiAyTHw+jAKBggqhkjOPQQDAgNIADBFAiEAoLOZGLoy0DLUK3o3\nV0obSQJXkIlX8YCqR8dKdVQMw34CICEuBnkhQA6QQ3iExr5FoS4pc5dclrmmyTC5\nOxD6Y+V+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1467", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1467` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAdtYyRIaZ9AsG1cI/bpRYsVxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlNjk5ZDg2LThmNzQtNDNiZi1hZjgzLWI4NTM1M2RiZWVkMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY0ZWFkZDEtZjgy\nNi00NDc0LTgwODEtNWY3YjMyZjY2YjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExLkInvg7rjZLY+rS0mR0ic9DF35/sn9OTFcs7gudqkiZTkO6UOFvsXfI3t4X\nAN6Xl8zpBhEQNA/Xg3TfB6HDJ6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCT7wW65Go/qDjlPBgqB8/A9jXeJMB8GA1UdIwQY\nMBaAFK7sKfTkRM5/tFKEV8Mbr018sEA0MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAwTLUPSja+I83prmBWIXLRQQA9uLz9bhS\nhSGGNXszpKUCIQDACz6/BSxaGKX2C0W9qRE5rVStXjeS2Lcia4TpRWA5cg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeQ1ElmoBlwpUkr6Nc2eCeB6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTY5OWQ4Ni04Zjc0LTQzYmYtYWY4My1iODUzNTNkYmVlZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlDjB0pfK+epRnYtW07LylwsR5NuN4RgVXF6ImRi+95ut8\n80j5bzLV4khqOTqAiGjpFwuL1o2poE3rsV6Ei/vmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUruwp9OREzn+0UoRXwxuvTXyw\nQDQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTBQ6N5O23npS+AxBP3V3aOx4I0io+zXrdXpmomqV17gCIQCmsHUoINou\nKPNBYVD60J22MXixkh8tbjWWQStLnVHUqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAR5c+lX9mPM3Kd86BndzZgvMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY0ZWFkZDEtZjgyNi00NDc0LTgwODEtNWY3YjMyZjY2YjQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1N2YwYmM1\nZi0wMDEwLTQwNTMtYWQ1NS1iOGRkNmFhYzhmNTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATERPuU8AHFOsIoWxJ/xm9xa1B+Z3VAalqI0VpXH43wk9JezZfwBJLL\nYwxeGLIVFXxCjBLDlzUwaWeJJEmvbSvoo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQk+8Fu\nuRqP6g45TwYKgfPwPY13iTAKBggqhkjOPQQDAgNIADBFAiEA9pJAvi2aodPzltpa\njrDnjqVSrRAwUVZVELwJmaDnUHICIA3OpbzGjC+EIpC6HxlvgXs7ucOT/1gi3QTP\n1PULdVZ7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1468", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1468` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVbY4pkCUfrKvudfseOUBuE/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5NTA4ZWQxLWEwZDAtNDExMC05YmUxLWRhODZjZDMxNDAxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAwZGUxZjMtOWZh\nZi00MWJlLThlODMtZmNkNWRjYzQzNDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7fSy3cr20kuEc/Xkltb2I64W0qwzfwd1t5AmbKOM6V1ZihXDcaafDRofcjzW\nBy158xQXPB69xrKo1sZYH/0xWKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS89dJaHbjR0QW8kK8mNPiNGJIj6TAfBgNVHSME\nGDAWgBTRqvm9L9JSv7lO+DpV08cpjS+GQDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCqOaeo2Kxgt2E0vID0tW6srifnmahR\nETrG34sAYgCP3AIgBvAybxVl+B6niVcWlYqtNXTZtxZxfExq8H1V5OYbj50=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARtS2MYzwfaCPE3aoyCfUX33MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTUwOGVkMS1hMGQwLTQxMTAtOWJlMS1kYTg2Y2QzMTQwMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASa3z+jO9KbL8m30GkLwwydQf28FJET7l+BZfKQcQEke3IG\nZodsieC1hKE+2xmYFJUBiTZAj8G0Kz0PWtMVlmC9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0ar5vS/SUr+5Tvg6VdPHKY0v\nhkAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKxsHdn7BvwsG6073B7VgNY4gwfLrVg2uFKUxfDxumCpAiEAnV3NyEfu\n/n+4NlfeYmSk652RplSzrE8WpaKshJNH3OA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAd0x2X+5PY0XHC0GU6hO3RJ1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAwZGUxZjMtOWZhZi00MWJlLThlODMtZmNkNWRjYzQzNDljMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZDBmODY1\nNC0wMjAwLTRkYzAtYjNmYS0yOTg2YjljNWViYjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARs7SBzeg+xFn7zHrPFfTnjpbCkmKLzMQS6ItZrBfRo58uEeds8RnpH\nvQblQmB4+v88wmQptrn5/RVXtorsUZeao1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS89dJa\nHbjR0QW8kK8mNPiNGJIj6TAKBggqhkjOPQQDAgNHADBEAiBlomOEUm+4DBhWCuqQ\nup/bPtlM7TG2F/RWJGnFxeqRFQIgY+pZZs4LjppY16C57l6fkG6QkJl5ZCZx+PP9\nBg56FAE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1469", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1469` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAT+Z3tc4Tq+MGaVryyjpv40MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1MjkwOTk3LTBlOWUtNDJlYi1hN2NhLTYyMDc4MDg0YTExNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVjM2VjMzMtYmQx\nMy00NTcwLThiYTgtYzYzMzY1OGQ0MTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIaJKZPm6zcqY98XLpZxE+O9IyPnTN3ksC12Fv+spXVxVplERU3z/OeRwCim1\nSBgrXi5MVX36k50wcmr+BslqUqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMZWOBlqNHeFA+/jHCztteO6krFQwHwYDVR0j\nBBgwFoAUJn2LEgKoAMLvH/e389ok2+/0cAkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAZnAlrTBD7RDIt\nU1PWdH38V+v+Ks09nLufbtYntrv1/wIgfYhx7g0lkT5eiGOuRGEsQheZjpPTxHrh\nE2mqWNqLw0Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUS6uPBiaWOiFnLFrginaQsyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTI5MDk5Ny0wZTllLTQyZWItYTdjYS02MjA3ODA4NGExMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwhk6YVqTtVCgUuY25U1TngFKgInlKCDadc5L330wWyjft\n/ZsCMlPK8m4anegGFoXhEdtTs5MxX0TQgtd28nuho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJn2LEgKoAMLvH/e389ok2+/0\ncAkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO2lDvPZ0JMBWeJ8/qtlWygmjeMHj17kfxG4jmJ0QHTfAiAGLwsfb2ke\nyA1BDLj+oeIDBBoQ6snTYOQshoV/S1yqZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAZa9R5kRB/e3wBP4ryCbrkYBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVjM2VjMzMtYmQxMy00NTcwLThiYTgtYzYzMzY1OGQ0MTA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2OGQ1ZWFj\nYS00M2U0LTQxOWMtOGY5ZS05M2Y0YWRkOThmMjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARDKDfpc0dWMudZNvh8/qpE/hAUyIXCgdns9u4GoVdoZsnT+hc3Hha9\nEBRE1Nt20/fUUtPRZBNILKrvkQJ9If9+o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQxlY4G\nWo0d4UD7+McLO2147qSsVDAKBggqhkjOPQQDAgNHADBEAiAymuECt4yIeP3WufbD\nmBJ8uc2HH5mtZ4crmG/QKr0lFQIgLtkVIBGDMi3lQMfdw3Zc4xwHmQBmYY/5mMoS\n/PcGVTQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1470", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1470` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAcPTyTvdfv/6v0gahXkFj1x5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMDk2MGI4LTA3ZjMtNDdmMi1hM2FmLWQ1YzZiMTAxYTdmMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk5N2M0MzYtM2Y4\nMi00OWU2LWJmNGEtZjE3NWUzMjdlZWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJW+uUdgzLhNoGem5w1pFXWUhKJY24VEYzjYPZ2QIrx8Yg9lEOpsYqqg9kbUX\nTg21Ku0KD5j0aiAlWlB6j5G0OaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3DLvk9dRsRpOB+UVz59AvbVlLHowHwYDVR0j\nBBgwFoAUfg33dBALtBemeR+rZtAnLlVUiHswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBbnKyU9C9V1MHh\noPhelyG6cPJJ3xy3GdC2CC5uQ3qZ4QIhAISQwQ0Kxh9hJ4Qcz3uvZ0UtRqCkUtZq\n6AvvRFWsNq/C\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb25wG3SDV58Rx5d3yCVBWd7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDA5NjBiOC0wN2YzLTQ3ZjItYTNhZi1kNWM2YjEwMWE3ZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEfCAEqYbV6jbd6pll7S6f+UVBeRwJTvVCotuGWd0V5FDD\ns3alxPO1f/mT8UiWZYJKkU6YdcpCOm1HrRXT7St9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfg33dBALtBemeR+rZtAnLlVU\niHswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL1DqoC1CtslA3pigI1b3qwUJvIieFXZ9h4crCrj7kPGAiBNc+iwbqUB\nW+xPXCLZjteB1LL9uHXjY5aVpOf4sGGPEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAUMYDp1XodxXr9XRdCQXyABoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk5N2M0MzYtM2Y4Mi00OWU2LWJmNGEtZjE3NWUzMjdlZWUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYTc3OWJj\nYi1mMTgxLTRjNTUtOTZiNS1jNzAzZmE3ZWY4MjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATCHYLHadrS0fsAip9V+lFfl5jnDBAcbQd5N0xjbT1knT/IEFtlVTG+\n2uJo9azijqxxjlXd3yvPNFv+T1mN8UAOo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTcMu+T\n11GxGk4H5RXPn0C9tWUsejAKBggqhkjOPQQDAgNIADBFAiB5hppb5MNHOBBZe4KT\nrW3sR6NqeoKmmOeARdJNAEZVcQIhANe8H6KoC1zvqoUVCdhbRveNwhROSnBGRMhw\nYGHMT1mv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1471", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1471` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISASX2IEZ8ymMrkDvN1DWRgOdsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwMGZkMjFhLTBiZjItNDI0YS04ZDg3LWExNTUzOTM0NjM3YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFmOWJhN2ItMTIy\nYy00MmRmLWE2NTAtZThmM2ZkYzI2MWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMD77kLmwx0TCpqQ4mOWs0r6pZb4pIPBqnnN3he/MeBSTnpXONWyo2k9/ANeO\nKkNVGFcI0k6LVO1xmgDQjXZwaaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnUr0eyYoPpo6voTgTqLPn5WF0gUwHwYDVR0j\nBBgwFoAUaoniMJE66fvhbke3wHqtAxoc3ykwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiB0UWNXFw/sQntrW0h3vzT5\nni0RfwaCNIoy1Pn05Wxd4QIgWuMR1khSWTQA1d7xW0YSYX2lYN07VcKrtOHAI2DL\nHQQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd2uGpqY7g+rBhSGh1G6YvjMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDBmZDIxYS0wYmYyLTQyNGEtOGQ4Ny1hMTU1MzkzNDYzN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKJbvoqRCBvsHUmwLkz4u/5cI4AFftQo49L61qy7pFX6SC\n+HMQXm25IaEHPYonQFuTPIt2a309c4MSy7gESqFOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaoniMJE66fvhbke3wHqtAxoc\n3ykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQev4m58ySn6DgjT5qFjEUaTPBf7t1EtJZDJdB8Wi8EACIQD/7FfmgcUS\no/bS2NC7JJ204Ysxmkn/r4v/WlRZdQlpzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAVJELrI1PZ6cyV/No9XEnRXIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFmOWJhN2ItMTIyYy00MmRmLWE2NTAtZThmM2ZkYzI2MWRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YTQ1ZjFj\nYi0xMGM2LTRiYzktODMxMS01YTQxODEwMjM2YTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARXAGAbj4weGfvx2kVpf5Y/PqH7Gymhzvi21zXoDjLk7F90eAYeteuT\nrQn8lM1cEHjl0GfpqXbGuGPh/F5V0rDGo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSdSvR7\nJig+mjq+hOBOos+flYXSBTAKBggqhkjOPQQDAgNHADBEAiEAviG4sFbZjjkFWS7Q\nYEb1C3PW+O1H1XCxf94HYyfs9rICH2kjUxTBPUnEcChd+7JPKZfIYHIaAqqmoXRc\n2Ac3cIA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1472", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1472` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAQRs64vvu7dgHyt5OPVvwpwEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MTgyZWI2LTQ2MmEtNDY5OS05NDNiLWU3MWZjOGFmMzM5YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQ0ZGNlMzEtMzU0\nMS00MjBjLTlmMzktODdiYWVjYWQxMTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn4ZN4KgiYiweqjM99/E+DWUgtQQlWowi4R3SueWmk88X/KhPcT4QVaMLUiCv\nmJaiOuVwDTPEqk8Iq8k3KEiLUKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKTZ8uSF4Iw/wCnFHxk8GDyQejT8wHwYDVR0j\nBBgwFoAUZ74HbluR1PuHkLRQjuS3Mpi5JDgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBfleh3\nS9otuc0e7ViE7DFD3VPx1zmahiXsS87nm0uODwIgS+IaK835NgrtElNW7O2sRh3E\niI3U0jfo0FWogiamvtU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATAuyIk64SJpLMIpxMNArAEXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODE4MmViNi00NjJhLTQ2OTktOTQzYi1lNzFmYzhhZjMzOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwrm1OeY0g0IdQZMaDcUXRBpL6d+xy8vB3O2PPpdP7AVED\nyiwRBD6KIoP+fHJifr4t071q1moIOtItzjut5jJ9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ74HbluR1PuHkLRQjuS3Mpi5\nJDgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCqllpYY8NZkUsmdYx7JN+c7xQED41Yf/R9ZHKl48tv0CIHEz+WdqQzxf\n0cBTXz+KnPFqud7u+Z93lLil0wrOCQRw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAeSVts8XQ2ep/F9yO52KAf0cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQ0ZGNlMzEtMzU0MS00MjBjLTlmMzktODdiYWVjYWQxMTRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YzA0MWVm\nOC1lMjQxLTQ3NTEtODhlZS02YzJjMzA1ZTQwNzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ7PWEOXvTztJL7JxPKj/EqDd6IzcaiI8Vay6/ZadKzU3mZZLt/exSb\n1V5G8EGTFTJgaVnbkjxua8SVbn2VRVmho1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQpNny5\nIXgjD/AKcUfGTwYPJB6NPzAKBggqhkjOPQQDAgNIADBFAiEAxzDPJusjLWSa4Ixx\njJJh58EvXb8RousoXSvpSjFYa/gCIEoYrk0IKr8vmIMknUp42PJxJnkbLszI+wIN\nPVStuHay\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1473", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1473` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISATTk9Ksqq9H93zW1rci0YoJGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiYmMzMDgzLTU1YjQtNDc4NS1iNzVlLWQ5NDA4MmU0NGJjOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDAwZTg4NTQtZThj\nOS00NDEyLWIzZWYtMDhiMjY2YmE0Y2U3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh/7g921L3z8yTkoeYGn9mPS+9KQJyVJjCJcjj6c9dGqC4/AYeZTI6qvRzJCq\nEzRfaI2/mLGMOjUzxK/JTIsnPKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdMSR4eZECvn7tv5Soi82HSoCihYwHwYDVR0j\nBBgwFoAUQ1jAPHHnOSZm/m1TofPUyWSAXm4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAguRK\nR+X2umVXh5uHceSBa8eroxu7ws0CLQv9y+iHkhECICM6+SM+qJCJRzR/COuSkizF\nSj8r8qk+uE4F9Ea7B513\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVOZyhRsyJVx+8E0kCkeVyuXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmJjMzA4My01NWI0LTQ3ODUtYjc1ZS1kOTQwODJlNDRiYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxCHXUQ+RCt+YbTO6OaNVwlRXTOlJ3mchhda2cBFIQ8PRO\nKWTNtYsoEd/z0japS0s7lNC8cgeFxam5bR3PGadho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ1jAPHHnOSZm/m1TofPUyWSA\nXm4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXjhS3TRTVKcCCN836L1MBKg0dU5PM1i2UhOcVSu/K/sCIEZPo/7gH99l\n2we/S1YT4YqikI2oeLgyVL3dH0biqMWl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAXz6M5WiNKVRp/iv7Spw8IVeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDAwZTg4NTQtZThjOS00NDEyLWIzZWYtMDhiMjY2YmE0Y2U3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNmJkNGJi\nMy0xMTEwLTRkMzktOWNhYS02M2Q5ZDM1YTEwNTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASJZ9O7Omre4t9x+m9AtGKWKz68LfO0IoHvTlibUrgo7fNS3wXC46U+\nad55bJaLb5XQfQR140DbMluY1HoFOLVwo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0xJHh\n5kQK+fu2/lKiLzYdKgKKFjAKBggqhkjOPQQDAgNJADBGAiEAkUGRZX1BEZXIq/tq\nzeW6geLuUDN8aYlGOcF6LwhyikECIQC/LRBREHvgNBkwFnZ7/BqRmKgOEx5qWqAU\nzbXe1T3TCQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1474", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1474` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAajH8+FVYcNpKoOIYT7c6G+IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjMDJkODJlLWRlNGEtNDljNy1hNzlmLWY3MjkzZDkyZDE3ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWExZTM0ZWMtYTVi\nMS00MzY5LWI4MTUtYTQxMDlmNGVkMDEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXYvDdm7UD8TotMudmys3hFL5p51qdT5KGtyT4GK4FlzOL+mGx2asYc+A8SIm\n8pWwUaPaqwLRzmn9WBQ1XAUqqaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEf8sIwYarEI4XQl8mHf3qRXN/stMB8GA1UdIwQY\nMBaAFO9CF4hr1JmZaouAALho3DM0nBo8MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBw+LE+VqbPaTZPTzqOVc57sprDneE9JHcq\nk/CZPQUoNwIhAI/p9q+FLqgUDC1bMhw/Iq7RqY0BeI5h0wPghvNBk1rM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXhIAeTuvQMKxQcowYW8NTE+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzAyZDgyZS1kZTRhLTQ5YzctYTc5Zi1mNzI5M2Q5MmQxN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWEkk/GTNkSvcO/ffM1nVdliXFZ4a+9v97Fe2Ob+1BOnB+\nczH79mpePZfAuSvPrxKFh0s/XB4ZgnNIX6N2I81Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU70IXiGvUmZlqi4AAuGjcMzSc\nGjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV0VAwTJdYEY1GgC42Lqt/F30oOBCpDEu2PHa7+ystkQCIG9kXqWNlo/B\n7FuE/rGdnfs2Vff/frhMEcLHTPC8WjYl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAVy+6DEWlPGkJzoJvFnvX4s2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWExZTM0ZWMtYTViMS00MzY5LWI4MTUtYTQxMDlmNGVkMDEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYTc5Mzk0\nMy04YjcyLTQxYzUtYmMzMC03MTM1NzdkZDY4YmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARX9ydmbaBu0S8Kr19NhO5VQVvd1xCJFH1APNjW6xIHhm5P5nY3KRax\nhmQYazizL5ECST0Z/35ddLNME5DBZOHEo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRH/LCM\nGGqxCOF0JfJh396kVzf7LTAKBggqhkjOPQQDAgNIADBFAiEA5sUHqX1svIQ9ZBOY\nOjr/OFwCpqeGM3qd9Flgh4nL1UsCIEXOayugnP4BIhkroDFHt//uQYuerEp6Rbap\nnmtSeToN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1475", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1475` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASU/oPpt1o9WY7+TTxaymXJiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NDNhYTU3LTU2OGYtNGIyNS04NGI0LWI5NzY5NzRkODczYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYzNWFkNzItNDM2\nMi00ZGI5LTlmYzEtYWVkZjA4YTM4N2U2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErwIVRM335MSQ/iEkPE0NWTovZep7NfhpvVQY6EmCm31p6JH0Q/yWwDQi5qF4\ngZ7QEgRYFmlP99cawadUuz9HZaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsbnfCupXXst/4yyR5ubSG+A9+P4wHwYDVR0j\nBBgwFoAUCxmkNraszB5sXDhlQdJaoqS3Rs0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAP2tOsP1YtgF\nFkLgtWezZ7n5xSf+GP3UUmIrymqgxo1KAiANbYjceVH/uoOw78H1z2GFVeF0ik06\nAaxul4qfcZIdVw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZflw1b2XuZHReY3WGi1d2vRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDQzYWE1Ny01NjhmLTRiMjUtODRiNC1iOTc2OTc0ZDg3M2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqM7HBJoc52xM4kHTekoVIIabpoqZvOh8n4X08060cZk/S\nGW7E1L+jCpSGX0NkcwctuxlEX99VvUUIdWcvmetNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCxmkNraszB5sXDhlQdJaoqS3\nRs0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgec+6gmbaIqTch56UW6a9yZ1W5ChMsCrDztNd+/q4O9oCIQCAN3Kh99+I\nkM9NzPK577XduGPAUdNz7Oh9VKgogjzuqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAU+HnmRM/ZXbQnKXC5YeIaSTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYzNWFkNzItNDM2Mi00ZGI5LTlmYzEtYWVkZjA4YTM4N2U2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZGZjYjUx\nMS0wNWE5LTQ2ZDItODhlYS05YzIxYTNhZmQ4N2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATJun3Y6acUAAWZNj2KGrHUk/jBZC4cXsDZzni+f2SGb1nGw3A+jLBU\nJaZXqwD+ycvSFZbWMCVDFqv3UW7JKaq7o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSxud8K\n6ldey3/jLJHm5tIb4D34/jAKBggqhkjOPQQDAgNJADBGAiEA+diwIXWIWI60P7jx\nOe3QWZTzdf2bUR7zE8iDXXLlnfYCIQCCvfEt5QCG6k9BuGh+Qgt5MxH85CXy6/kt\nKYWqQ5vgOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1476", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1476` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAUt0pcXe48fYbTrthVNBAcPhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MjQ4ZjQxLWQ4YzAtNDdjNi05NmM3LTNlMjZiMjE2N2VhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFlNjA1MmYtNzc0\nZi00ZDU5LWIwMTQtY2RmMGQ3MTcwOTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvCGSC3Fi0a3rWCJu/K69gvduMqRz2Dhzf+Mm54pMVghOa4bgktQf7z/Ffvhk\nBQCw45DVJy+ceHeDCVbs0xJxIaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd3cDGNeSt9Fi4PO6CKeXk2FguEAwHwYDVR0j\nBBgwFoAUaJaOS7V71JCqS0VSW0cC0eaqKtswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAL94SjKuosbO\n9kVn6Z5I2eAQxWdKX0RyEOCkr3h8aGvUAiBVjLLNXPwGt+56ruhJDwGWEsO+6rUp\nSbh/XWBqn1xJjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATiQthNb+L8wzkLbtYwaInbEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzI0OGY0MS1kOGMwLTQ3YzYtOTZjNy0zZTI2YjIxNjdlYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASU+JbpPiS2/YgaaeBJ2OCXi3vehXiaKuNAIdFMx9/QVSc4\nW13wbLeRH27a3NDFMRdtrhri5oC3HWOc10rlBUxSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaJaOS7V71JCqS0VSW0cC0eaq\nKtswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIBGPwkkMorpZ2uuSF9lZEHpeojuM16nl9OilW1NUDAtAiBweTIVU271\n2zntIK4UslMClceDJiO7vfwSo8ibzP+A1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAcGrq77adxsb4XvOkrgQiTN/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFlNjA1MmYtNzc0Zi00ZDU5LWIwMTQtY2RmMGQ3MTcwOTU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZmI1YzUw\nOC0xZWQ2LTRiYjUtYTAwMi00M2E1MDg0MDIwMjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASU6gfecNk1KzzvuNpVlG77wMOoleP5gWRt++21cfGY6xrqkw0J+7Zl\nrIX9Ygwdj5gVHjKe9J0xRaFFtQYTnjh7o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR3dwMY\n15K30WLg87oIp5eTYWC4QDAKBggqhkjOPQQDAgNHADBEAiBeUkA4ncLlJC9IAVbo\nlIjgqruoZzuAAf24bjqrJDHXLgIgZqmemC2HHdmk+tOMjPnFG1EPP8/2J+7DwPmn\nZrF9eBw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1477", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1477` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcEjHK96Dd4p3AeDhM6+ZrkrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYTI3OTg0LTZjZTUtNGQxOC04NjZlLTQ1MTMyNzlhNmEwZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVjYzQ5OTEtM2Ex\nYi00NzdmLWI0ZmQtYzBlYjZjMDZlMzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWv88i+mas8ilHD4kGabMJo+yqw8IamMqNdh0mXbkuAxBvr4sSiFUeuiZFfNJ\nr7lL0DBzXBRoOpS+g6FMJFSWjqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6b2BaLlrXXi382L9ZF3BfC8dUT0wHwYDVR0j\nBBgwFoAUVOyl579UX7DbMYS8tYdN2AREtBUwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCCwp4JhMyy\nHS9tmA5Kf1HwX056mMpIfTorhhgGZr1/0AIhAMDD07CnFOLmRHFl7sybBNlpZJYe\n4mRnmLOQP+Srz1jP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARYjNhKoMHWsY5CxsfMrYE4uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmEyNzk4NC02Y2U1LTRkMTgtODY2ZS00NTEzMjc5YTZhMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCuY2BYCViEMXHFuscdcE8bWDWxH6c7pg9zfzaJCWdkxF+\nzF0ROJhALRrHmvmzBINkKosKidotjU+zAi31PhPIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVOyl579UX7DbMYS8tYdN2ARE\ntBUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWxcExljUwKFevmnThI9kTbBOpZ8p8T8DHKOdOcY2PzACICR7CdViutp2\nnHobd3hrPRH7NqSrzyuZcMf9AISZEFNf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAe/R5l+WnwIoZznDRfP6Cbi2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVjYzQ5OTEtM2ExYi00NzdmLWI0ZmQtYzBlYjZjMDZlMzQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYjJmZTk1\nZS1jZjUyLTQxOTktODk3OS0zYWY1NGFkNDk1ODQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT0QBuBIzwjR5v+wU0J2ZW5z/qSRYMaRHBg4ubl5ZB29ArGauzOrvTi\nnGgTGp2bRkFQAK/SjuvAr/HCeqmURTMyo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTpvYFo\nuWtdeLfzYv1kXcF8Lx1RPTAKBggqhkjOPQQDAgNJADBGAiEAusO3nG3wcPcktC6f\n30Pt6FT+eqk8jw+bofeLRRHR3NUCIQDXcfRhyop/FsXrtyLS+J/gAXmWjdYR6GAj\nMGjYnuCUDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1478", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1478` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAf4btatPQuNcqJDs+mphyw7hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZjRkYWUxLWMxOTUtNGVkOC05MzYwLWQwZTA0NTA0Mzc4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I0Y2FmMDAtMjI2\nYS00ZTBlLWIzMTEtNzk2OTExZWY0M2I1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE65E/TF14vVAJNcDJSMBUqWi6Cpss6l50ZO4UQ8YQ3QL74b0cCuWDuiXUu90d\ngBuqMETJZOjs6n4KbZYftGkHe6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlSSfvm9YMIGBWAdSxQAWSgftzAgwHwYDVR0j\nBBgwFoAUeBbMrL+Si4UBBl4StVaZwGIo0pQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCkkbDwFNyzi5x0GSoJgBu7SPHe5xOkvifxWanG2xDiYQIgUQsrKLhKZZxv\nBSBXqBawsBEMMNfcl7iCZDy6vqDhC5k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXfG6J/fHDfBKPZbLmENpV7RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGY0ZGFlMS1jMTk1LTRlZDgtOTM2MC1kMGUwNDUwNDM3ODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNrnfkI6q9rJ0A+xwfMTvQMHPZ+mVhY51i8KOOAOzFJTEx\nKHX/y1TuSwYsuQ8au+M5GWL94trdKgGVqEu6QKONo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBbMrL+Si4UBBl4StVaZwGIo\n0pQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLsbyUyu7xSbKufw7eHxrvQPIkjPVEgISfdPy5UlvCUUCIQCcBmV0T/sj\nBidweclMXEeLDaaAcesNrL0k7Sg6Peo/5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISATpENEAWj1FLHDHGUoz1HJZdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I0Y2FmMDAtMjI2YS00ZTBlLWIzMTEtNzk2OTExZWY0M2I1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYTY3MWZm\nOS1iMGI1LTRhY2YtYjdhYi1jNzU0Y2U5OGJmZjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ66jzHBPeVAgGbWBT9w4PzmTkTIQXdXbeqIb3Sd51AyXqGXbaVZyQd\nszPGQlC3SHpvl5Q3hYiMoqd32vB8eNwyo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVJJ++\nb1gwgYFYB1LFABZKB+3MCDAKBggqhkjOPQQDAgNJADBGAiEApNxiPIdVTn3dOxGn\nmyhbNiKJztgkny7mxBgWqccRIzsCIQCwzndmnfe51iFsumww93Itbz+rT3TtpMHb\nFnXcNIXOjQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1479", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1479` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAeFIq3SfqkaSHqnURWeAhf7iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNjFkMmUwLTcyZjMtNGJkYi1iMWNkLTI1MDA1NmZjYzI3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI3MWYyNDktMDA0\nZi00ZWViLWIzYjMtMGNiZWIwOTk3OTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHnjA3W+yCZdgwEg3ND8ujzL99vyOrQp5naJBNyJ59UNy0fLVeaVkEDBJuaay\nn9oqSPUe03g73z7p96XAgB5Xx6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ulnM1A9HEOOa96ry0YmKv11c6EwHwYDVR0j\nBBgwFoAUa55zcX+fgduqeKHO5J7mLcImsagwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD47wz5/VvEkgIQTStmQmIzoLckk4agKgh6Q2aOep6DMgIhANpY0+rdVnYA\nyT8fwf2glaIWcaQwra6+ZorKOQj481in\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZgQB0N+Luv7MBhx/Gn+4NxDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzYxZDJlMC03MmYzLTRiZGItYjFjZC0yNTAwNTZmY2MyNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSYuefqkMe5IpwNUjjg+XhaWH5fFAb6GIKpe7F5uWvtwVe\ns/HvmhRski4NzML7V/sBoV+hM9QCTNAZbyb61qaco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa55zcX+fgduqeKHO5J7mLcIm\nsagwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIj5OM4Kv7/AAwQ+gNNMbNeCNjQp+xaUi4nWfFyktIMfAiBgJtbts86T\ndfjQIpyF3/t0D7KOBA5rPF0WuB8nNdXoyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAdu6lCst2CeGXGOZJzEu50SkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI3MWYyNDktMDA0Zi00ZWViLWIzYjMtMGNiZWIwOTk3OTQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MDc3MWI5\nNS1hMmUyLTQxYmQtOTNhNy0yZjU3NTgxZGNlM2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAToKRPbs8dmhnbMntwtfvG2gQeM9wL8P9Jr8z7xADrtQVlTleSOoTpx\npsSAr20AralSW0u0GLu7iZYrGBudD9Y7o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT26Wcz\nUD0cQ45r3qvLRiYq/XVzoTAKBggqhkjOPQQDAgNIADBFAiEAj92rjKn7ZPCiPoL+\nyG9goBe3jeiYZ822ox0UXUK88roCIH43VgzndgjWzobIzjHWT/HNYqqA7YYBfhrp\n0RreUBkL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1480", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1480` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAZoPXhRDOZLiZHTJwJbpa5ClMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMzA2NWJhLTExMzEtNGIzYS04MzM4LWM3MWVkNjE5YjU5ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzViYjg1NTEtMWM1\nZi00YmExLTg1MDktMGY4YzIyODRiOWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKtzaGkVXc0DtL+uPM0O5uFvZnhmyvApVjVIdwqmiDJY3pCRycR0queURSB3C\n2WaxXTYwk5UgCJI2dGapJGGqR6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtcccwreyJw9KHIYexOQdlqFHg0QwHwYDVR0j\nBBgwFoAUt/NsUlZKdJiDQFidvX5v4Tje7zswLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICIm\nX+VxjNI69IfvefnFsm7zq0QGOzucwbcNfUIvhWJlAiEAyQgboX2EikL4ljHWG53c\ny1oIS6Ismj/OTlVX8maaZIg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATwDdOCbAxDJlo1be0bZZpYLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjMwNjViYS0xMTMxLTRiM2EtODMzOC1jNzFlZDYxOWI1OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6HenZhMhUUDJt0g1/AZtIJZtH4ZVyI/2cizlB6BP6oAzs\nsERQwy5SG/KYLmNu5rq481w5fSp65CSow8PXNIaCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt/NsUlZKdJiDQFidvX5v4Tje\n7zswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPECb+YcHAQlx+q4FLuRmUk7lEONpa6HMj65KvgOWgl4AiBLLihto77k\nGUzw7Ce4CaDkjMDQPnzcHefJWeJjohKI0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAShEBUNFimTJeb+OzBGCNMaFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzViYjg1NTEtMWM1Zi00YmExLTg1MDktMGY4YzIyODRiOWEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkY2Q2ZTUw\nNi0wMmYyLTQzNzctYjQ0NS02YjMyN2U1ZDRjYTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATcOp0Qa6WEK+I5NlnnqBekOcQLpi6bTZ722bFlDvS7lQvZeOpOsbMD\nD2CIAC7uX32eQZgA9+2+djaX5bpBHi6Yo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS1xxzC\nt7InD0ochh7E5B2WoUeDRDAKBggqhkjOPQQDAgNJADBGAiEAtwu3/Vj2HopSYPrT\n1jRs2GQ4qHtcm+NYaUnBnMiiE4ACIQCb69SBVhkZ/X1wVHCImExpMorBFI5c53/Q\npco1C0Wpdw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1481", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1481` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAdt0GI6+70l0iqpPh/yE1FIfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NzVkNmMwLTI4M2EtNDRkNy04NjlhLWUzYTg2ODc1NDhkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTViZTcwM2EtNmE2\nMi00MDZjLTgyMzktN2IzNTIxODU1MmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhMAb9Zhh6Y7TpgE26G1X205JZWnOaELnEjzH2cBsa0n5QixPLXZyJstBMlPG\n3WGaHrseo0XKknG7eoT3pHIhPqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM/08CZnUeBRv7CYD0f8fRIcHrkAwHwYDVR0j\nBBgwFoAUUVi041N0iAqmueoW9DKRUGT967owOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCDrGC+9XPV3VPds8S+4WaGCht3/40RuA96U2DwbB+7SQIhAN5Q\nTPk6UBuaOmnwjmI5fjnRwzInbYkTr6q48/Lvj5kf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ9z8Mfs4s6o14jw4nMUeaN+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTc1ZDZjMC0yODNhLTQ0ZDctODY5YS1lM2E4Njg3NTQ4ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3t1pQRVJ5gI+acE5MUQcSZo2V6GjZlbMY5RUHOvGoN7jU\niUeinrXSbHPUp7ZfK63VCubIawvYK/C4V2BCqVkho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUVi041N0iAqmueoW9DKRUGT9\n67owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY5uK9An7w/hAPff2di7kP0XrbAVfEyIoaTFCHfAr0coCIQCc+a8pJG1g\naDiNM3c6djh0gqYBzrmInn7KDKNxWm8vEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAYwCv7nxjc7OdoxsLAgOdTT9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTViZTcwM2EtNmE2Mi00MDZjLTgyMzktN2IzNTIxODU1MmU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZjlhMzk5\nMS1jY2ZiLTQ4ZDItODY5Mi0wMjJmMjgyYTRiZmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATxFhwbbcWwkbd3j7PyUPNNmOoxYa0MqyTZZqajrGkFi3PGESNDcxsQ\nSz5nnP48m5XC+go8s5EC6EoVGizWzV29o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQz/TwJ\nmdR4FG/sJgPR/x9EhweuQDAKBggqhkjOPQQDAgNHADBEAiA4NW2R/5Y8C9O18WOb\nz2GKMz3nhQnKz44RvV0aMBr9dwIgC5J4ji9bsJcbpXwQnBlDNG7zwNAYgddMQ5NU\nVKqDtjc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1482", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1482` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQPVmikNu8XoAmeAtXUVVab6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5M2Y1NzA5LWMwZTgtNDc5ZC1hYzAxLWFiMTJjYjJjZDUxNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmJkMDExZDAtZWRj\nMS00OTJiLWIxNjgtMjdhMGJhY2VkYjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaZzQgQoEC7zE2y4Q4+yQI0EV/1dJfCu++trXnBHlu4tFuuH63oRAEyy8f6cE\nOJxNCCHjwT4O+3XSBoSdeHDSdKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyGcSCQ4miehngtPmbF5Nk9cvmeMwHwYDVR0j\nBBgwFoAUBU/oBkT+Xje/RoURPpckUiAsdKswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDFys0KesBejN6t1+DeG3NeFyMNdd/cWL7ZRX0ihZVGeQIgCej5\nZBaRKuDY1mFMbdwWpTBQu3AazFeGBWGp47yqyOo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWxPu5Eu+14+tvZUbJXSMEBxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTNmNTcwOS1jMGU4LTQ3OWQtYWMwMS1hYjEyY2IyY2Q1MTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiQT7+I2qQDPGeaCr7nuvS0hzBNkB4mKmNyREuttoYH0Ok\nXnmnBfDCh5y4vWjgFG9ABTbyj4cssf87hyOrgKwqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBU/oBkT+Xje/RoURPpckUiAs\ndKswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbcMI2bBqHV2mYOsXEuyLyVTHiOG7bJV70l3OzBRE5/sCIGwD1JPefx1v\nCjYj3M3CahjVE0A8Cks31ycxMoJdaWfA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISASLdMG+eKCgOYPbftKFT+8V+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmJkMDExZDAtZWRjMS00OTJiLWIxNjgtMjdhMGJhY2VkYjAxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YjUwYmU3\nNC1hN2FmLTQ5ZGUtOTVkYS1mYzRjNjlmYmFmZTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASvDWJ9lSofRWvuX95kFaOtsGSppF8mV/2ErdOQ00rq71gdrQrzIwtl\nR7sZ/6/b8DPL6WyBASSnnfy7umD9kHpAo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIZxIJ\nDiaJ6GeC0+ZsXk2T1y+Z4zAKBggqhkjOPQQDAgNIADBFAiEAt21OC6BHCAfaC9Jr\ngouDMjuIRar/nhPeSPCDgPDGJW0CIHJ3An1jBAOHd2vRc8rnEclLMK4JCBmSibjJ\nfisrhSPm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1483", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1483` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASD02pyoOeIYRzFFUOMQsyGaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlYmM1YThmLTdlYzQtNGY0MC05ZjU0LWNiYWY2YmYyMTJlZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJkMDM5Y2MtNWVj\nMy00ODMxLWJiNDYtMGYxZmE2Nzc2NjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdjQLO3FMC9hCMijzO7+IMtm1XSO7HLwTsmdNTDdezWWoxeLvS7dmoCKr6O5J\n/vC+c4zbaMzB4BZnKVTVBtLp7qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLzpM7+BGdwyjSV4e9tg8aGJ4p9aMB8GA1UdIwQY\nMBaAFNg2anQr/A3WgSuuI0koPCm4KxviMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA7ZK0Bk5nxOAccyXhjQ1OkZxdkoK41AYE\nnJVyfGzrl0oCIHRjCxUcaPK9+fjy0hxX+Sjin/kYXbn9tFvaDhW1Nip1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATPOJCuDpg5Y6SjKrybl/ofsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWJjNWE4Zi03ZWM0LTRmNDAtOWY1NC1jYmFmNmJmMjEyZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5LJv35jX5NTKXj7KWsNTTc+f1MwVytYV4aGFWN5Kh7nbp\nun6l6wSovbLloyVBqeOgqL5AzAH/JNc0dv8kTjSUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2DZqdCv8DdaBK64jSSg8Kbgr\nG+IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMx1cAxATADGR7djAJ7cdKmgDMUvYUckG7PpkwwHammIAiEAvisZJh01\namtOOsebcggk7dmfJML795zJ6lMQVFMGSiQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAVWOfQ32PfdXH821br1gLy2IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJkMDM5Y2MtNWVjMy00ODMxLWJiNDYtMGYxZmE2Nzc2NjlkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNTY1MGI1\nNS1hM2EzLTQ3ZjEtOGZjYi1mZmY0N2QyZmRmM2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATLxmtaGAGd/v5ejnAsssNqOcaNdXYuvTDFS7wKL6Fg+SAFz2uwE46I\nk8cycwcVTvJWePURTxT0mlh3/Ahso6Gro1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS86TO/\ngRncMo0leHvbYPGhieKfWjAKBggqhkjOPQQDAgNIADBFAiAgoyc5YtyHttLTpwBQ\n7a7TC/MPo/cMcxsPxYlv/p6GIQIhAOFZ/KWdt15keIb+ZewCfb7weYEKaiGUIPAs\nrss2RceZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1484", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1484` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAcE2AbBND04Yv0HyoUosN4KlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MTJiNGZjLWQ2OWMtNGQ4OC04NjdmLTQ5YTcyZDNiODMxYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg0NzcxNWItNzVj\nYS00ZmJhLTk5MWItMTM1NDg0ZTE2ZDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqn7h7q418kUccX4dCwEdnk7200DCiHEkEued2med7N6Cj0VOWWh7T6qaIWmQ\npqdLNOWQ21l2lS9cFVL5ReD8bKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnH70vxSYOiPZruXp3KfykTIcPwIwHwYDVR0j\nBBgwFoAUkBP4YJoMBvAbZx1oCV3YdQCVh58wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALBN5XTDUo45\nrWIPuDzU7qZqqhy/DcihamIKe4uLMrgDAiA1u4PP5cJlK+M5nvJEfH66YM42s281\nu985gxR34B1XKA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbs9HMNHQpB2kjnNepMOCEKUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODEyYjRmYy1kNjljLTRkODgtODY3Zi00OWE3MmQzYjgzMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASW27okKkEGyZXoXYRiMb3duhNu6pzr6WIa8cQY2t75MS2q\nGW0mDt3sLUThfqfzQHjcVIr2X5w0op8X4ClLR0Ano2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkBP4YJoMBvAbZx1oCV3YdQCV\nh58wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY+JxBRYsYMa6HfMGwbEwcWdW+/hbXomkdvFRkTPHO1MCIQCgpVGpVfBL\nZqFZCSceMHaTM1UD9fc2DXI4YmsbztEvtw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAdYCLwpGLM6g2/2s87ROR+StMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg0NzcxNWItNzVjYS00ZmJhLTk5MWItMTM1NDg0ZTE2ZDVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMTA3OWU4\nNi1lMzNiLTRlMzQtYTY2My0zODhiNGY5M2ZiNjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQnNyzfJb5DXY5plR2GklYbDBh/lNjx1ckdb8XhSfVnPO2lcIt93lPW\nUhYbMRNKNey775MTA8hfgyBsjtbON7f2o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBScfvS/\nFJg6I9mu5encp/KRMhw/AjAKBggqhkjOPQQDAgNIADBFAiEAtOtDaqXwGDvMDaWc\nnOkwsSKnfUAGHPTEF0Q33HSGdlsCIDVIKEuahPV6AuC/515kptGBPSrmWwm0kN7r\ndq01DBxn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1485", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1485` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQHzp7ZLmm9oW12NkZqUlVhrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwOTFkZDBhLTMxY2YtNGVmMy1hNTk2LTc4NWIzY2QxZjU3ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVkNjE3OTgtNmJj\nNC00NjZiLTkxNTEtYmQyZWQwMTdkYmI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErw2+P5TcVo+5xyIAZqfES7Qh/SyIu2yFhRSBLDHeF9OTuOIdcul4LmXwgIin\nmYtw2w472qBYu68BDHmh/XeHb6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeSuudMO3tn9MhfAzGugAZCPpVUUwHwYDVR0j\nBBgwFoAUk4QyfP1FF7WUV5gXUxFGE1pVwfgwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgc9T4s0o/jCoE\nGw5TcuwzWc/ZquitDLa2uzF8Zp4ie5MCIQDzk+YgWlmEta/hQYcz1AeB9+zf9ZnX\nGpK1VKqhcVCKbw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASEPyTVszjIiV3mIjwvkDvopMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDkxZGQwYS0zMWNmLTRlZjMtYTU5Ni03ODViM2NkMWY1N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdtRab8R50MUOMUBti7fC/3oRpQQj/WGQGpLRlKyqdYT9D\ndaCZ+/jZ/xknr74jJ+1JYab3WhUH5HyYT2h6dUspo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk4QyfP1FF7WUV5gXUxFGE1pV\nwfgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALsiR6fpaTDUEXgQjboX2eqZ4Hu05hfhPiCAlJnTln7dAiA154AxXfg8\n7IV4Cc9pPClqTajv+mq7OvYCP7F2Rft8Kg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAc3hkTFTcbJJT5HA06RXFgnrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVkNjE3OTgtNmJjNC00NjZiLTkxNTEtYmQyZWQwMTdkYmI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMTJlZDRk\nZi03NGFhLTRlYWYtYjZmMi1jNTMzMTJmOGM4YmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASvCrRWzqHB5zx8hjb8GJM449FrxdpKsfJk7N3bPBjzEArzGHQhGTYy\nsSHuIlgAB0z8AeJGSM9K4dLdNI4pBrDmo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5K650\nw7e2f0yF8DMa6ABkI+lVRTAKBggqhkjOPQQDAgNIADBFAiEA+WwbqWkRGLuCagML\nr5XYEsSy0q/J3LxV94t4bKB2XVACIDuIHUP9cG7yE0nmQUNHSgbLAPa82zDdRodd\nujbV5c4Z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1486", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1486` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAQjhNdLpB4cWeMSJMzFjBTr3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3NTJjMjBkLWNhNDctNDc5Yi1iYmIzLTIwYTZlNDg0NDNmNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlkMTM3YTctZjli\nYi00YzBlLTkxZDUtZDZlMzM4OWM4NDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1r9rX+nvsajiQjTCse/k+zHVFD7uLvJTe0CjgDvxNYpe+hdSBGf2wM88xwDg\nRmcHQnQ+Uandz4BSwhvcf3hwTKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhAD1xe8HWsBQ9LdSFJ1S1AQ3AaUwHwYDVR0j\nBBgwFoAUtGrsCIZgnMNZ4D2oBj7RTZNiONkwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCzC94pB2+n\n5qkNOGrsbHAtPrXvbktu0EQueuFylVySywIhANsFTvTKTI9yBy+pHBbg1aLmeMoF\nK9ETcX7HdHSqM6qj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXU/09B2ku4dnY/dVt7cRBuXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzUyYzIwZC1jYTQ3LTQ3OWItYmJiMy0yMGE2ZTQ4NDQzZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9xH37MJdSkGS3ufGM/APj5OclfWjgfQR8+WuUZpIhWTAi\nLTAO2inSagLWE4aNx3uaFoYJP9qSGegv/08wR5kzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtGrsCIZgnMNZ4D2oBj7RTZNi\nONkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTOPGKe1mI2oR+RXjjO5YOhTadfjgSkY1AF0rlcs2T0ECIQDIQthaIqeF\nFI0Au76kIC4+4JiFc6UnLcLjTSnptDP2/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAZHgEDWyhkXiGTVWZbgnzyR9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlkMTM3YTctZjliYi00YzBlLTkxZDUtZDZlMzM4OWM4NDA1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYTg3Zjcx\nZC1iNjA3LTQ0MTMtYmY0OC00NDdiMTgyNTA0NWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARky4slehLI7YpPCfS/D6DUGopJ8AVW+N97usxDrbZe1z8j7VXw8UX4\n3uzTH9bxj5XYp3CHMzZ1+I4jEPYbEz9Po1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSEAPXF\n7wdawFD0t1IUnVLUBDcBpTAKBggqhkjOPQQDAgNIADBFAiEA3LENyHljImj4ojYS\nHCo49SJ3BkVlnj9QbSln1dVRdDsCIDPJmeVQrPdMx+wDyGcAfokm3+wubVJpCwRg\nhpS+xiA1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1487", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1487` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdo7vuPLLDCUJU8/VAs8O68PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmNDI0YzNkLTc1NzktNDJkYy1iYzc2LTkxMTYyNDJmMzM3MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTYyODEzMWQtYmJi\nMi00MDhiLWFkMDEtY2VmYjVhODYyNjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuifOJ/rLcspYz36lUPwB1UWi1SmInR7f84nLNjHU3VL1m5tT/NKOKLveMsbo\neztY8gN8FdeffbyvbXJerpX4BaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfw6utL+v5L3QlH8RpQpX6JHyPV0wHwYDVR0j\nBBgwFoAUjnzXBJgH2xQ1Hr1gfJOmn/GokPQwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCieIDBk550oUqUi5lBnDQWYQ3h+VM4/p6z29/5NpTsNwIgRZYIqcL+2i3K\nIcyBNVtBpcuyzftWmFcxHSeaxyD62x8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAecR/Uh+dSpVr/Iix16tb0k9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjQyNGMzZC03NTc5LTQyZGMtYmM3Ni05MTE2MjQyZjMzNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQqT96JG03NkK7ak4IS2O1cgW1ABTpBkoH6wnqRRyHaS1j\nvFZ5kWBx963BFxwCXnrDCkL2DMGTciKNyp8Yg1HSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjnzXBJgH2xQ1Hr1gfJOmn/Go\nkPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYihy0ArIhyU7bVSjm9zvH4JxefXP4fXl9FFEBD74QI4CIDMHnvs5m8bm\nAA1dFZLdqb6VNw3kquHtX++EM1qajMS2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAVICi+kfExLRO93pWsRSUZrJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTYyODEzMWQtYmJiMi00MDhiLWFkMDEtY2VmYjVhODYyNjliMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZjI5NWU2\nMS00YzhjLTQwNzItYmE3ZS1lOGRhMTU2N2MwMDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS1UkFNnaSRtArZlRwcPD5yWPFwzGzd+qYCWWgbyoWpzowPcAUUyBdB\n4A9t8jGoVpTIHNoC8DYeTtR37uqUMK94o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/Dq60\nv6/kvdCUfxGlClfokfI9XTAKBggqhkjOPQQDAgNIADBFAiAB6g/nqqJIW1ssVyjB\ndEubTS9LgYIz7mE1CaI61DroJQIhAPTAjLxAUvCAjn+geo2EnAFI+3xHUd5u+f3M\n9ayevgii\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1488", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1488` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAb6HKx/qiiZzRU5AhUpcNmonMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljODY4OGQwLTIxOWEtNDY5MS05MjkwLTBmZThmOTVkZDBlNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ2NWY1ZjEtYWYz\nYi00ODA4LWI1OTAtNGE0ZWQyMDliMzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/8XMwFhT6lfmMn4KKNOAhCaVp82j8WVnIK3+cR+xQKNrHL7JEVwadMpclEP/\nZrbZScOqf31f13YxEnIfbh1WLKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIPKU3v/rONAtR0FPpiQcExPQ1IQwHwYDVR0j\nBBgwFoAUXPylfeY4Pn1FHd/NnxaGTZeMgs0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCy0UzbCyhqRKc1xhvY4h/WwR2I6XgGgLiN7HUy3SE7RgIhAIvW9kfYDpu+\nMzD3NXQYZkEq4Py6+tW8u62Lnb+KqLms\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ1e+cVL7flM4FjZvhxa/GjZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzg2ODhkMC0yMTlhLTQ2OTEtOTI5MC0wZmU4Zjk1ZGQwZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlYXkblSMEirzydtKIBDa/sz87NED31M5akXHo+xr12mZw\n/tqo2pP2TDVtEVicsNL2qXc8JoQtkrjGZWI/o3Nao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXPylfeY4Pn1FHd/NnxaGTZeM\ngs0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZr61cjIQ2QQDAcfkK3LziqAssHuA/z+h3h1XV8WaVg0CIQCypjf7i1q2\ni/H0hXFgqeWkXb+QAjpwNwEcbIbjwidGwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAVhMP4bdDYXRG8vaJ2EsiOsoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ2NWY1ZjEtYWYzYi00ODA4LWI1OTAtNGE0ZWQyMDliMzQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhOGVkZmNi\nNS1iMWI2LTRjOGEtYWMyMi0xMzRjYzQ3ODg0MzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARe3VXIQj8YcdT0j13tPd1TyNJ8OJ2v4RRFaGhE7bf34Sop6b0ux7fY\nCTmH+6Mi/EVeRxETlLznxykpi+bAiTRFo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQg8pTe\n/+s40C1HQU+mJBwTE9DUhDAKBggqhkjOPQQDAgNIADBFAiA2l7RZrcIRk79/f0EP\nfysFhqBVU9AWkGhZYc7c5mJUHAIhAKOeL/MOQj5IO2rE+tdYzLrRnWQNiRNQ54d/\nzB9FVPJ1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1489", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1489` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAblG5Ucw9Kptqd72ko3+r9pRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ZGM4YzRhLTllZmUtNDIxMi1iNmE0LTI5MzQyZDc5ZDhlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBjOTY0MDYtYzcx\nZC00MDcwLWEwYWMtNzNhMDJhNTczM2Y2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEnOYW5X/rMIpfIZwOL21Z8zChnhdYuFZDzJ5jpQ/I/Xg/WWWzJ0h10uH2Jpw\naa6HDmG2UN9duY9UBHTvdFml06OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwEuMuNoW2rPb/sNiW6YS6SusZjowHwYDVR0j\nBBgwFoAUtyy4D/P3Oys+9AEnqQD6FrQ0R94wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCZ\n7F6+lMxTUy42cXzs41VRJWq1MW7MzivJrn6wSFtcBAIgAmXuXf0HPnSrqAd/TY5d\n29ObtN9vONUP7+m4L4dPpXo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcUIhNXWIRatd19y8ESXPWVEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2RjOGM0YS05ZWZlLTQyMTItYjZhNC0yOTM0MmQ3OWQ4ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfDVWNuoyKmYi2CsZx7XCVfvUNW59U7au7pZ80Ib4bE+aN\nhYwp0cYrgqVn7UQntl4mIixDPHF2frbCvssfMbQ8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtyy4D/P3Oys+9AEnqQD6FrQ0\nR94wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga3yT/2fT2QMr4rb5k46sWzuhVUcji5AxisINCDXHMhECIG6JWWS3NlE+\nngVx14nKWH5bhzioDToM2N41H/x9+X3y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAbYE1+v5i2ZvF8l9J/b5YtxyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBjOTY0MDYtYzcxZC00MDcwLWEwYWMtNzNhMDJhNTczM2Y2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiY2FmNWY4\nNy03NGM5LTQzNjgtYjM1Zi01ZmNlNzRkNTEwNmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT3eyg5LXbwmrlgwOieDF6mZRdoosQpcPwpyjTado0NvuCaP1onnhi4\ngG0cdWNiFzO4Pp25Ao5vpqHv7n+cnfQ3o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAS4y4\n2hbas9v+w2JbphLpK6xmOjAKBggqhkjOPQQDAgNIADBFAiAp9GS9k8p0lHJLgGdp\n3LAUpEBscxcrulst+vYJhR11NQIhANG6K1zZwWVv9ghSR6yachY2X6tzSRZG157U\nO5MOIGAC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1490", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1490` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAWVykrScySRL8YkZoFCIewAAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NTVkNDUwLTZmMmUtNGJiYi1iMzAxLWNkYzNlZmM4MGZiMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmMxMDFlMDctYWEw\nNS00YzFhLWE1MWUtYWZiN2FhMjQ3NmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmKKJl4lKHXraehuuz/nUKaM+oxeSxSO6f9NaoPe2B6Jxfr8Y/sM3y0LVsSbl\nRVtCChGs/lHiK3pv/PiHT0Is5qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaKTBZO9ZKLAl/85XRhJ/qzDrIZswHwYDVR0j\nBBgwFoAUjUEzaLW8mlpfjk3p4KeR2zOSvw8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC+nYYm+L1lqG6Iv6N+EwP0vCyKI0iHL6w2LnqPpDPR3gIhAMUv\nQOt8bREkBN7haC5QWOfFrKQrqnhPI2yQPrRVjDPu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX5dOSw5yOdg3YmQACNsH6YdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTU1ZDQ1MC02ZjJlLTRiYmItYjMwMS1jZGMzZWZjODBmYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfFtaB+sFS3LjOu1v71Ym6r+Ofd/TPE59td21xHApTSeNb\n/tN28+IQPLPbpGQIBXCoaY/p6uoJqITnbNSD8q0Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjUEzaLW8mlpfjk3p4KeR2zOS\nvw8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUlthaMlds16DAAXTm4lpWp4VmyYugHJ7RwjaJeF949QCICXlOtXJsNgY\n7Y4mEfksy5TgbvMpl9W9fyBqT/7+uUB2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISATnSWzOa+m2TBlPfA2ToCOAtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmMxMDFlMDctYWEwNS00YzFhLWE1MWUtYWZiN2FhMjQ3NmFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNzM2ODNi\nNy1iMzlhLTRhNDEtYWFiNC0xMTdhMjU0NWZhNzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR/XHjj5ANYIiGewjadpaYa7B/1ERanP8Y2kJ79ru9irYwnFuIJkJmp\niXxDpGjAJKAeaLxGdrumj1DHLoqUOwYEo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRopMFk\n71kosCX/zldGEn+rMOshmzAKBggqhkjOPQQDAgNIADBFAiACVJUUCICzVErQPG9K\nBRO6Wfw67w3DzLdLPBxYx3foXwIhAM3ZX20+lpUU+r1iUCgaL4g+vihfOrJjBIW2\nVu3Gmr19\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1491", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1491` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATuQYTB5F4si8qnyNxBhBgmMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMzE0MzhmLThkZWYtNDYzZC1iNzMzLWFkMzU0MGVjYTAzNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk0MGNiODUtMjVj\nZi00ODMwLWExOWUtODk5NzU4ZTExOGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjrQoW8Yl0/I1KLocVHLYfiWJst8ruQhtxe6s0NJdjZnATJaog1pT5c5Rsoyx\nXfY5Ha3wWMPk919QchuOYFL736OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVTswPrPB21jMR88ldmMwYtC+FaAwHwYDVR0j\nBBgwFoAUkPogvIIMa9NRZPoJWjGc/p6RDZ8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIEVKwjH7/q/3H/EM3pXRJCnO42rPo/2aADuE2Rkw/a9IAiEAynkV\nkB+VTPYb5RBM6IQGBpwDRgNkSorbbx4NCNE/08c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe2WusR/TELY2o+TXuXefHCZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzMxNDM4Zi04ZGVmLTQ2M2QtYjczMy1hZDM1NDBlY2EwMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnf9bj2qFcBKYprOiGzJxIjjXugXSpKMvDaTDdvCUhQvuq\niVl+P8NzQp+vM1WTCDSc4rgmuML6rma9hlItr4S1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkPogvIIMa9NRZPoJWjGc/p6R\nDZ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJDCvoXiGoKan4OGYQvQvpTe+zQeSaYSJmMDiBCQHm33AiBi6BnLgh9n\nZU7svhfRuyiiJlTtMBQ25wjC6CeDJ37pgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAbIJImm5ap36jF95kmXe1Q4XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk0MGNiODUtMjVjZi00ODMwLWExOWUtODk5NzU4ZTExOGRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1Zjg3MmE4\nZS05ZWQ3LTQ4NTItYTZkYy1hMjdjOGM2Mzk1ZDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQe/2p+mxCjBCxxW7oMfZ7ggwgZqx2fJWOiqYgg1X0wnjEVdhucMwZx\nXOaDJ7XxBJmBPbhRMBLdM8YzCMqXbaR7o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVOzA+\ns8HbWMxHzyV2YzBi0L4VoDAKBggqhkjOPQQDAgNIADBFAiEA1PlaTjPCfn/x4ttn\nfsT4Lt25s6/fPj8LWcl4g8TEt+cCIF6YMuhSgxTKA500GfMiFIeAa8Fb2IyyF736\nLxk+rKK4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1492", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1492` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcBk8WJ3xtwHTQqZyHmDOA5TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2YzE5ZTJhLTZmMTEtNDBlOC1hODgxLTk5YjdmMTUyYjU5ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzViMDNiMmMtNWIz\nZi00ZjA0LTlhMjAtMzY4NWJlYWIyZjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjo1PDRrFnKrVR+h1XYJ9LQkCn9jk7GPSxp8tWvrFTP3qY5/SkJlBdYzlhfv4\nnzM3O3LWDgynLX/PVHJWqkcSXqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRpCww0dC0Numm5tbIntdk1m19AvzAfBgNVHSME\nGDAWgBTgSdalLUNwEHiGX+mf1SGsVA9cYjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEgTAVKR/vrzHTvkZ/bX6yQJlYJ5pJwV\nq2ee4C4Sjs/QAiEApNB5FQkUlJIL7wYU9Gesic6Bnsh9/tjhZZxEVTfTab4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaDd6FraUpwFB7sishiwezG2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNmMxOWUyYS02ZjExLTQwZTgtYTg4MS05OWI3ZjE1MmI1OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6p5R+VkcoXhVDq+YjuTaifILLSmoDwL0kzNF7J16XAhwM\n6fZBxmWLXAC8i3uZMoW8uXMIikyFHyFRTl78Xk7So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4EnWpS1DcBB4hl/pn9UhrFQP\nXGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIMLqwH1yNV2ssWkWeMCH1Ftg1hMByiT6kc5aU/eP/J4AiEAg8V5Z2x+\nnAyzaxV4IdcR0PjYLT2htjK8529saHSWOIM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAR5AAotdI4prloU9GriWf3+QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzViMDNiMmMtNWIzZi00ZjA0LTlhMjAtMzY4NWJlYWIyZjI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMDRhZjI4\nMC1kZjc5LTQ3YzAtYjY3OC0zMTRjMjFmMzdmZTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASmJk+RVuLDX7GUTNxKESIPjv9/PLv3OgqOCJa/RjYLzuXaeDCYvEJO\naxty8y/FMCZKUl55usjXcjKOghE/7e+jo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRpCww0\ndC0Numm5tbIntdk1m19AvzAKBggqhkjOPQQDAgNHADBEAiAWGrGIMO1tcpUrtlqx\nJlO/TLRLkQ/q16bT1APJBppFIwIgSu+o3FSElP+Wyc0O288AiqnS9an5+EWqwKOC\nvFk8IX8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1493", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1493` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAWD+0cKOaa511s0vMTAsCJHsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4ZDQ1ZjM3LTU1YjAtNDhhYy1iYTg0LWRkNDQyZmJlNDRmNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNmMzA5MjYtYjU3\nZC00ODY2LTg4NTItZTY4YTVjZGRhYThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhZRShV+sAv1kOwgecVVhRD3+koTwcI0aQjfR4KpMTK82uMKIhDsZ5PLuFtIf\n3HhcR870U+O+GtvBYYz1llZ94aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYgBB6UxrG8lYEtKCWuzhk3MxnrkwHwYDVR0j\nBBgwFoAUCejqNT/m0qJE4leiyGhA9WUGvIgwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDcMOdIS4fW\nf12Xa9WQXT/KDVthzH6SylSI0zFxn73y/gIhAI7o67LET4bwYQYZtMEmwR96mIE9\nuNFC6r6DtPH2ei8z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ8aslsVe+y7B5DegRr2L+dhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGQ0NWYzNy01NWIwLTQ4YWMtYmE4NC1kZDQ0MmZiZTQ0ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8O/iRK9GBmwF1tsKFMDMvTYjGJwkJ2EaiC06YchMzkyyj\nBpPzei8zgMD/h3nMP33uhLugIIGJIH3UDwkC+MjJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCejqNT/m0qJE4leiyGhA9WUG\nvIgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYN/qBYUkvVp9uGTd3SOslwVstGNPMQsKif1OIflTniQCIQCv5CNk7DJv\nSh57SuMlhpraAfTC5GQX3VfEhyKGO5UxLQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAeytKwPeZileIbb6y5K9pLWFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNmMzA5MjYtYjU3ZC00ODY2LTg4NTItZTY4YTVjZGRhYThlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZTAxYTFl\nYi1lNjM5LTRkOGYtYTBkOS02MTliYWFmNTc4YTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASxz/po15VhbdRVllvuGZiKkwdadVsyz7Yl+sLj7WhKELq0Z1mnnr2n\nhnIn2zPuMG3znD10sK0D0Nv4K+PLIb/so1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRiAEHp\nTGsbyVgS0oJa7OGTczGeuTAKBggqhkjOPQQDAgNIADBFAiB1qHlaWtvsP9PFn8+l\nc6pC/w0CzSGKkslqYseyTC2v4AIhAP6iRE22YiG0AST9kxc9VLQ+Iea5xwrV5cVt\n6YjYYKLr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1494", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1494` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbZo2cr3qdFexCxZM5moPtC/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4ZmZhNTE0LWZhNDItNGMxOC1iNjViLWJkZGYzN2MxZTAzNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVhMjEyZjEtNTJm\nZi00NTE4LTk2NTAtNTAzOWZjYWU2NTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUIvNFl5fumqD8Nz0PyzEtCLeU1in2n28TND3Ze9XckmlBMkTMtiaRcisWZvf\nAA+xGP6wqXB3qjGVBRYPl91RTqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu2ebpUuz6ayKgnUuRg3MKIRPGeAwHwYDVR0j\nBBgwFoAUom1zAw6ZM43p7MJw/aHUfJfgkSYwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCpqzxJOtH7\nl3SGJjK+Gi/9MBaXpA73BBZ4mFj9+7WHqAIgWbfud277fc3tBZ1LgmjnttyrNgA3\nf73cjxOYyTU3KJ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXu7y7nS4D2sgUCNPPaOdx+PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOGZmYTUxNC1mYTQyLTRjMTgtYjY1Yi1iZGRmMzdjMWUwMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrlxQMRvFcH395UUbSKb72yQzrCtYq10va69aqyGpeik7S\nY4A8REnWVl48+cug8otXpdhiZxrkpoNRZ6J1Nnqvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUom1zAw6ZM43p7MJw/aHUfJfg\nkSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUmb6OB4T6WKBKF+Kq4jBd0xjZtSnQ9YBj0Z8XRRHeJQCIEW0zQaZ2L8o\nXupGztrtTsBuB+EsHnUxP3m3D4CfLAhB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAVDe/WqkYn00IUypfmOg7lHBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVhMjEyZjEtNTJmZi00NTE4LTk2NTAtNTAzOWZjYWU2NTdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4M2I5YjJm\nZC0wN2U4LTQ4ZWUtYWRmNS05ZjQ4NGQ1NWNhNGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQU60vq4tHDMQQyw0sgtJA7SQMFkfhKIeAfDRDUMCeJGwxK2VLakOcF\nh8QhXeufpoMIW52T7B+Nvnn+dOMA5xqoo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7Z5ul\nS7PprIqCdS5GDcwohE8Z4DAKBggqhkjOPQQDAgNHADBEAh8cIKexb6jSE/Mxt3JQ\nUsIVkG0ncn6QcQsmdeQQPQl5AiEAvh7xkyNrhDY4rfYmOW+uzOlLBrak14kGCA11\nhWYK8lg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1495", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1495` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAU002oUP3MHyrMqppmtqu9zZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5OTMyM2RmLTdlY2ItNDBiYy05MjM0LTIxZTgyN2M4NzM1MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRiMjhiNGItMjFk\nNC00M2JlLWJmNTAtNjBmZWE0NWY2MDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwhfpwd5N/pJTbnsVQq2gVbAHOoX1LVpj0mQsa/47DoH7CHkrVbw1oC5Fpd+b\npPAvbG6J1h4gmP+yUG6ShtQ2Q6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEs5G7XV6pkJ7g4xIAbYL6iyHc2QwHwYDVR0j\nBBgwFoAUYfFRQZbCbk2qxMGpeqemqgUrUSswKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAtVAJPi2I\ngcTKTV4w5ftuwdOrz/bTtPu3KU4AxKkiGGECID6CVSFRmuR4KSkxGgmmZ3BFI5x4\nDmmnnYFDpQ92F69x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa61SeLt8qcyUVQ7uEgR950RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTkzMjNkZi03ZWNiLTQwYmMtOTIzNC0yMWU4MjdjODczNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGwJzhMAav5ls1I2RvnAZAl/9sAc7nQm1NqCWCgMm3oBdO\n0DDcYu5I1p84Zl1+hQMMsncAbk3JRNBMyC8usPqJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYfFRQZbCbk2qxMGpeqemqgUr\nUSswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKJgdYCzw3asBTYnMdSK75Mf3LU8lZLpO5pkEZ0/rvL1AiA2Bw9Peqti\ndJ6nZSZullX0Rg0HMLa5czT5JvcwXyO3tw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAQ0/ARIvDR6kZFlsjIfKCcbrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRiMjhiNGItMjFkNC00M2JlLWJmNTAtNjBmZWE0NWY2MDY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNTFhYmIz\nNy05ZjUyLTRiM2QtOWY1Mi1kOTUwZWU0NzBlZmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATB9peDBu6qtdgQRyeo3oRe8iCufumeToJjdwaL71ZAjLDuUADIU5Fg\n5YT+bH64OqlDtxTgnCRCQNdbVCigz2pko1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQSzkbt\ndXqmQnuDjEgBtgvqLIdzZDAKBggqhkjOPQQDAgNJADBGAiEA6IINyIIseZaZ/QVB\nyEgY6yk8BscNyqDUzQHxyg0Jp6QCIQCpokL2Hdk4wlJtrzpePQevOIbB7Aw7mE30\n3nU2bhG09Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1496", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1496` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAaOIOXPGGp12GjL5sWRU7o4FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmNjRkZjg1LTk2OTEtNDc3Ny1hNTQzLTE3YTQyNjlhZWVmYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZiZjRjMjEtNGM3\nMi00OGM5LWI0ODAtM2VmOTBjM2QwODZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXVQcUG5yALFFvDQ9ORrSnX5GLiv1hSvUNzxiFx0IOU3C/Of+El7s/7hUwoOC\ngbC3LvUZR5ms+EzkL1O9nGiIe6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+I83KpFsqIM5dNRQSYZj4jL1xOMwHwYDVR0j\nBBgwFoAUCS5ab6tCWCvet+rQtafpzUqYHTMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiBNztT8MlSJ3DF/0X1cB+Y6XQOPpZMZJKyA70YPUHrlggIgHfnVWNNC70fp\n2t5liticBiVjj/5flGOKLWYFPJTe814=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeraFFw/uFjRshEJi/5AlrvSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjY0ZGY4NS05NjkxLTQ3NzctYTU0My0xN2E0MjY5YWVlZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATASP3ZZR2cp1aw7hBtpSucgRR6nY36UnVOgzCFc57cFP5Q\nPOW0vOYTp6ZMT2VY7xAJjFRyFZQfRpBwc1pca4pyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCS5ab6tCWCvet+rQtafpzUqY\nHTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKO2lafJ+M0UMiFPaH99yWW2ur+3nl7/4lL3hM7jDHTFAiEA273UuW7N\n3nG5WBhr/M+M0EioX30Bb2HqgqYo4p+hXVw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAf3BfEB7pzT/bqQkMAIpVFIYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZiZjRjMjEtNGM3Mi00OGM5LWI0ODAtM2VmOTBjM2QwODZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMjQwNWIy\nYy1jYzllLTQ0ZGUtOGRiOS04MDJiYWY5MTk0N2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9j4/w54YDI1xegWJGPuuHbSJxJJrd9fllpbIYc1osThEhu/t9/COu\nCRntnDundNoq003QdN9UlDVtc+dIdjnvo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4jzcq\nkWyogzl01FBJhmPiMvXE4zAKBggqhkjOPQQDAgNIADBFAiAbgPi1wtknNES2/Txw\nmTQ8K2CjH9T4w8HHL1VcnCZw6wIhANtkTBSghyxEjiW4fXQ8erXynurezTJ5z3Qw\nerDuku1O\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1497", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1497` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZuOQ6QONIFhDXGYW/NSgtwcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0YWJmNzM4LTY1YjMtNDM3YS1iYmY0LTA0ZTJhZjc0MGE2NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTEyOGFiMDItMjAx\nOS00OWMwLTkyYmYtMGM4ZWJiZDJmNjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPZp2TLHEBYmdGOg1A9k9CfaI5DkTuDX3NgABYTEyCX8RyNdfuomWApLll4+i\niz9++0NKglYmoycSbT3h0P4lAKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqxicWbNHyHfrHF7COixSxyuyzeYwHwYDVR0j\nBBgwFoAUybxiQYrqvwatpsAuo9Cqe7ivkMYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAtiFZvm1mMi2H7Ph15e+f1e0pKl4AUQw58Ty/UNFC4dECIDzO/Dcf77r7\nHStkfu9XYarqF9U01LxO6prVZDTVCyey\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWlzYozw866fuLmWMFvOBFz9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGFiZjczOC02NWIzLTQzN2EtYmJmNC0wNGUyYWY3NDBhNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwCO44zKfqsazXsOYVeJzxu3uosU8Fu+1mhoSLv1LYnLvg\ncwt97YUPyfSpOaQ+2TRTsq+ji/6OankdrjfSqvzBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUybxiQYrqvwatpsAuo9Cqe7iv\nkMYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIPoEm2TyST0eXnNLhN9MIC1vk4mbpY6VNOxvPual1WQCIGmXy8pvydgq\nZ+dzbwbYB6RSe53E9aOvouLwK90YztPD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAcMd4f0RzUFyCwrKumlJncx4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTEyOGFiMDItMjAxOS00OWMwLTkyYmYtMGM4ZWJiZDJmNjQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NjEyZTM1\nMC01YWM5LTQ1M2MtYjljNS0xOWUwNTY2OTMzMTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATsp5PvVzHS5EYSqwUS+N1mTVnlYEqR7vUXAvpkBSCIIqI9hpShSvfX\nRLe0vtMnwpVIhKBPnVVMAY9x5zL201sOo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSrGJxZ\ns0fId+scXsI6LFLHK7LN5jAKBggqhkjOPQQDAgNJADBGAiEAhcu+6V2fLoZx5oB6\nIAqWo1HOog2QsRvGrm9JSsHkm28CIQCn1qEpEvDotM0U48+34/qUAwoshN9E3GxL\nHvER4+cpGg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1498", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1498` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISASa8MuIovxVKssBp+4czT0XnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhMmVmZTYwLWI5ZTQtNDg0ZS04MDEwLTVmNzJmNGYxZWUwNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDExNjEzMGItZGUw\nZC00MmE3LWJkODUtMDdmNjA0MmFlNjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7IILs1aHTbVpL3jkp8QoH4k/AiIzI9Aizp9vnIfvWK0ZXSQJeHnEadqwh9AT\nM6nhSk5oPfafcdSk9P0eKsOjL6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2+z1d33q2w0ETWnYIXXrBt5wHhUwHwYDVR0j\nBBgwFoAUdon9ai1TBnpu2GhWS1PLr9oAYKowMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAa\n6BtisUpgoNiFlNAx8xpFWz87xPt8MjwHxGm+nS3lcAIgTz4v4PnMvdX0u8sSh98V\ncnK9FeGQNi7YUoXlqdxNahk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfpXTTTqSJac0ltBabx42TqsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTJlZmU2MC1iOWU0LTQ4NGUtODAxMC01ZjcyZjRmMWVlMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASE8a0syym4JMRTcFMU8cjGuY6diTrogk03nERuPRCZ5CYz\nr41vlV3E01mj3cFNCcDYikYJm/N8gKMF4Eh+Ip2Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdon9ai1TBnpu2GhWS1PLr9oA\nYKowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXC/ODBja4RwUH1txgWJmLyb+hz/zujIYoqrVwsjPFvMCIFwgZHkkvG8u\nYRvmc8f/IJjji4nLBaWH9CZg25GS7pTg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAYkxcqsGKVLlecB96rDTWC5/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDExNjEzMGItZGUwZC00MmE3LWJkODUtMDdmNjA0MmFlNjUwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZmU5OGY5\nNC1lYzQzLTQ4NDktYTBiNi05ODdmNWVjMGVhODQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR8GCz9o0aJxUEwTROZdRorsreJOttVoOtahzdFMxR50U/+SintrYsP\nRCCCSAZcvjsGSJ9KBAm8ggQV3Pt3vYE3o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTb7PV3\nferbDQRNadghdesG3nAeFTAKBggqhkjOPQQDAgNJADBGAiEAigBMCvgJGGn8N+LO\nTtFKhfbudzbYtQJj6kJserXsvfsCIQCwyuwv3vtvW/98H1rw54lZ0Rmdtf9usO7M\nXdfRXFxhxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1499", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1499` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAbx8K4LT4UQnY0tKikfl31RDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NDFiMGM1LWM0NjYtNDE5NC05MjYyLWUzNzc4NjNiMGQyZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdlYWQ3ZWUtNTU5\nMS00NGVkLTgyZmUtYWIzMDU0M2M4OTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz2sGotvfZZataE2tuXB0+Q7m0pJ9QIq9C5UnQnQWBHNBujXm6Ik/eac/Aow8\n7xP+1DKYzITcTTce1VylmqR1e6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7dsyPRfjWzWHoCRHtmmmmlncgSUwHwYDVR0j\nBBgwFoAULWz/Jo2QCVuOF1G7FNQAiE7ALrEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAmU+MbvQJKOh3K1Qhayb5v+irkZX6Lv4kwNcWj1YZYnICIQCs\nb5TJ7ZAHtQarBXOMYIm/1qMiqLPbY3CNy8AFFmwcag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaDGcAd1G00MnclilShsI5maMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTQxYjBjNS1jNDY2LTQxOTQtOTI2Mi1lMzc3ODYzYjBkMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXQZ004QCUhNU7MxhSDB7c/AoXa9N7m/sEawtKsGFDNadx\n9+cp50XUaW0QRrILciHXkX2tfXHpM2m5p1hO7YM0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULWz/Jo2QCVuOF1G7FNQAiE7A\nLrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLVchSOBH6E/pyy8iKRTh3rApviyAZ9TryERNs+d4TFkCICM3Lk3xQHmn\nn2guhO0V9FFVXg0e8Z+kDrei33gBSJyX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAUfx0Jp9k6BOrgVdkwisLKkIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdlYWQ3ZWUtNTU5MS00NGVkLTgyZmUtYWIzMDU0M2M4OTZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNTk3ZjUx\nNy03MzU1LTQxMTAtYTgxMi01YTYyNzgzZjc0MjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ11utI5YFrU8NUEAtEfNaShdihveegzcA9xQxKa7yL+mTpY/+lexpE\nfPRgQFBbPNFGZhWwc3gYZkIIobXjqJr4o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTt2zI9\nF+NbNYegJEe2aaaaWdyBJTAKBggqhkjOPQQDAgNIADBFAiA6EScZh5Nuf1ADzF05\nbCfelk+UN67COatdEjhgEPgWMwIhANwewSlVG1pvCFJQaUK6I5cwfLJ+3xtYVlY4\nADPH6KAz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1500", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1500` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISASSPfh0WVdLzWNtJh7QQ1j2VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5MjIwMzU2LTA1OGUtNGMzZS1hZGJkLWVlZjUzMDgzYjRlYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjNjODMwOWQtMGY3\nYi00ODlhLWI5NzktZjNhYjM4OTVhMjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZaKUZbIoDG0t4j/OQ5cn2AFBFDE1tDp46A2ouj3r8fgPcD0lAj1OxyR2oUzC\n8QeWvu3qmphzVKQI/+zkIMircqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUayRwHhZtgDFUWu+My9wPJxRB0mYwHwYDVR0j\nBBgwFoAUAoaLFn7UJLowJuBL0r5llQnMZXQwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA6ls16TDpT4A+ovAgatwZxA9SyPcB5NA1+f+gL9igeQECIQDm\nfN2zbNhJ+HthYJAF8TNh/Qi4hAFMAuBNE6HInmyOTg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeC+36izAy4Pb0b7b4O+OAKIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTIyMDM1Ni0wNThlLTRjM2UtYWRiZC1lZWY1MzA4M2I0ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjihOeWL+L4iY/6O0AH8kF30dm1MAi/fkPo4a4Bj2gUM3a\nryXE9YjF7+bOaSUQMVGgkCCp3a4bCQu51gTw6nF8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAoaLFn7UJLowJuBL0r5llQnM\nZXQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMm1B9lJbKHTtZ47+ZsJNrUDc9Su1dtz7L3k/WpOTckyAiBce0WNpsGL\nxyzaSeCOY5jqdUZLQ4E5Oh4cVFc0oIDfbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAV5vRRGIk7jW6IKVW7WBfGS+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjNjODMwOWQtMGY3Yi00ODlhLWI5NzktZjNhYjM4OTVhMjUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzN2Q2NzA4\nMS1hZjhhLTRlZmItODkzOC0yOWZiNTY1Y2FjNmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASeeBbt+TYNL4oJ74D1h/Bymb8HR7iOzvugUD5eNJxFVUG7/Tt6ferv\nFSTm7S6pBiRR3pZV/ErHrWWFd1oVR074o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRrJHAe\nFm2AMVRa74zL3A8nFEHSZjAKBggqhkjOPQQDAgNHADBEAiAQUjswKfFPSAXSA9jx\nYpYhktD7M54XIhq4MKTc6rl2BAIgISJRDPbhMePj6kv7wweuoL2W8I+UO0SES5u7\nnFLZvNs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1501", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1501` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAYBmPatF4espoFCTZLUFWtD1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkYzgxN2ZkLTIwZDctNDAzMC05MDczLTQzYzY3ZDJhNDRjNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQzZjlkNTQtNzc4\nYS00NjYyLWE0YWUtZWQ5NGYyYjFhOWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq0ySoY690hwedxAxIV9AtA34vg3fcYkSIy7yCZj4yeicXa3wLCo4c7XjQImj\ncCs1JOF9QX2WuVIHOhZl8UuYsaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH5cHovMtQJwe7E9h19OWVD/wIyUwHwYDVR0j\nBBgwFoAU188j0hlppwiYsbRTu3klU3QPh2cwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBDHhn5cyxsXrwm\n0oI9qR+47qCfu6AOVRJO4iTqfT8uBQIgElhRfwFGk6koycbMwLnKWMlY8SV1GU/w\n2Z06hFGTegw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVfSw4FZxgqGOFq+t3QrJ8G8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGM4MTdmZC0yMGQ3LTQwMzAtOTA3My00M2M2N2QyYTQ0YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARomq6Y4HsXSEOmps9cByTY6A8ZJdxRjrOQJXyEazSBkvjd\nERGlo97j6z9aoPMymBhjghm3hltQruENavH8gQADo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU188j0hlppwiYsbRTu3klU3QP\nh2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP7ke+KsVk3rFwnRe2nGnRhjgfctelKetU3rMED1RN/6AiBW3slkaFT5\ntDuRGiLx0RrtaxKNdHqJoQxTnQ33x0uObA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAQJAC7V6MiU7hMvynWrIDoL5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQzZjlkNTQtNzc4YS00NjYyLWE0YWUtZWQ5NGYyYjFhOWI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NTVkNzY2\nMy1lNmIzLTQyNmYtOWM4Ny1jMTk2ODI4MmE2ZjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARJ0EJt4B4k+p0qxcmbZrmmRS2dCoEywnLmC/8wOUwyaWuPOqsbIVQr\nQjwR+e/tK2eJbiNoa8RaeNtWzGhxvk42o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQflwei\n8y1AnB7sT2HX05ZUP/AjJTAKBggqhkjOPQQDAgNJADBGAiEAgHTwCzP6biExecmY\nuHQG64rZph2A3PmVd/jxaKeJ1BACIQDCKzquHk1V4X7t93WYCcBxoER/rXSTfIag\nfhCwfV7CqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1502", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1502` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAR82xBRpyE+xIsPx8G1/MLHuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxMDViNDE1LWJjZWQtNDYwMC04NGE4LTdkZTI3MGY2MTY5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNkZTFjYTQtNzQw\nZS00OWM1LWE2MmEtOWU5ZTgzM2VkYWQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEadr7M+rAWxPwBsdKP0R3OcQuUigXWMjROzEaR8TTXikj5btiSNC3PNvDGxBd\nFzGeUykd7CxylN2+oiOKLNxjZ6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX6WNZNjPRDgJi5vSd3qC7MfJw5wwHwYDVR0j\nBBgwFoAUOyVDv1gOeXB8evGOFLiilR08UWQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCHyHYP17Q6ZMBtWj6h9go6cgg432A2wG6e+wnULv59EcCIQC3dn9vo5QB5DPl\nkWK51TqFNX99qYrx8EdpnJ9vane1vQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYpaBlzFatzm8ycB23S0HZwVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTA1YjQxNS1iY2VkLTQ2MDAtODRhOC03ZGUyNzBmNjE2OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/3Yv0AKC4EcQSbpfMHetYJVrYlKnLIE1pN4vDDT/w8CIP\nufD1cq0ckXVV12QHhZDoSun/UzrZJUfWOJk2ZdmQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOyVDv1gOeXB8evGOFLiilR08\nUWQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf1OtUjvp5kD9tF8VT2xt9dhzesCjdoXsKEHOLBEYMdECIFC2PX4f6yhk\njvCzT1unDmU9dcbWsQ4InqjQ5urXAvOG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAdUXx1LXO8mMlj1rSbWZ++IzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNkZTFjYTQtNzQwZS00OWM1LWE2MmEtOWU5ZTgzM2VkYWQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNjkyMDk2\nNC0zZTI5LTQwNzYtYWQ2Ni1kOGUzMDc5NGI5MzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATqSoOFpCg1ikfzH2pfK+uRGRhcx0rI8wPUQmyED7g1JbORbCo4ko7i\nG5+Dr02QANuk2a9XTcruzTyj9kfzA2iWo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRfpY1k\n2M9EOAmLm9J3eoLsx8nDnDAKBggqhkjOPQQDAgNJADBGAiEA8DrnSbT2kbi/X+if\neUYepLNudZojv3pP8GuD6qS1m5QCIQC6zTvbcS7FxUSNtvWNlkE/JgbQcIifLCxr\n94j4yC8tsw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1503", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1503` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAd64ZKGokw8JYomZSd/31/fKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmZjBhYWUyLTZiNDQtNDZmOS1hOGJiLTdhNjljMDFmMjExMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhjNGYyMWYtYzVl\nNy00ZjRjLWE0NjMtOTk4MmMwMWQyMDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9QDfozB7dB2FIvOVbTIwyNV5LaSe4Zr/TfbQMogrlEgObSu3PndgSL2pQobp\ny3KBEwa5jiRKlTo39kok0gLmWqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj1Cld5IcZAvwWh8chnyenM+6/4UwHwYDVR0j\nBBgwFoAUTJY0DxMr5Jv1/3JhUj18xrjYH2YwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCmTxkD3nLew77lLsdUsVTIBPFTINClUlbie5tlk/GJhAIhALx/M+TB/MnL\nyCkuABBg1w6VTl5tD8Cy+v8fuS2J7O7b\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVvkmV08RvSlmX+IDcoAybjWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZmYwYWFlMi02YjQ0LTQ2ZjktYThiYi03YTY5YzAxZjIxMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKZal9/REtMtdipNM4IfEKjRk3qRlzOihRCmG+HilhadDZ\nFot3Mw53pW3JRurJ4GmLvvviCFaI4zLEPHgtHHb1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTJY0DxMr5Jv1/3JhUj18xrjY\nH2YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPxyfN2l7c8RWiPXES6cOCVQESFZhjpWkeUHBxCmedeKAiEAqTyKDGla\nEdR7G2nteFc7LGJqHMc77n4mhdhSufxRfTE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAct+qbpfJcTdwDJqIBXSaTc2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhjNGYyMWYtYzVlNy00ZjRjLWE0NjMtOTk4MmMwMWQyMDViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMGZkYTI3\nNi1kMzVlLTQ2NmYtOTNiZS03MjZjY2JjOWJmY2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASjyDG+cPsOgP0YB8nKQYvzmOX6emi8iJz2tQA6re2J0oNXEpwdeBBf\npprIL6jRWT8vlxGKK6uyMdcd69mVj98xo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPUKV3\nkhxkC/BaHxyGfJ6cz7r/hTAKBggqhkjOPQQDAgNIADBFAiAd4onHPt98+Nl8w/qG\n+zGQiehLJYdoMGOm/WuELWCJsgIhAL7QL0IlZAJOgciVIifieMXnOfjnd2Edg9aO\n9iVnR1Mr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1504", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1504` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZ7hI96onm+NHJbPPnVcbx+PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwNjUzMDc1LTkzYzgtNDU1MS1hZTNmLTJhOTAyOTk0YmEyYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTMyYWI2MGYtZThk\nZS00OTNmLTkwMjItNzI5NDk3YjUzZGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjPYY4qrudkvun/hRwtwnbQVF6qSLzNf6TsASmztaPQ1Nkbr5Jkc1ekd8ajas\nXd//GY1r+2mYLTbE/sATSKNiCqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCdQfv6UcuC/OZCX+c2MtmZRFXogwHwYDVR0j\nBBgwFoAUjmkIBRrrzP3ZC5wyOt/k6nOY+uowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA9rZIkaRmGS6+eIP2h1zYdD5s5YO/7crMZCxYWaPAknICIAU5nUI1W0KV\nhLPXXxzwSA8gqyqRC0ATvSVVy2BKqzLU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWEyeivgt8FZjWuhpeUv9cVoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDY1MzA3NS05M2M4LTQ1NTEtYWUzZi0yYTkwMjk5NGJhMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/I3SuiPmiGQb/4wvGtTjmIs6V6HuLaGNukaqEFmWje4HC\nKUoUIKE5YwO3134Rg/JKdP9MkB+ZoqPbuZouVW2Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjmkIBRrrzP3ZC5wyOt/k6nOY\n+uowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPuhaayBB4N86QIAKsDF5bz4C1hDo0l2ePsOrUsXyPmYCIQC24KzJ6WNr\ntZ4IFSFwZDIGRDKPRx5xSjzWZj43Lz8jGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAcKybfX1kEZjYYIvig0L0b/1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTMyYWI2MGYtZThkZS00OTNmLTkwMjItNzI5NDk3YjUzZGMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNGNkOWRl\nMy05ODUzLTQ5NmQtOGQ1YS00MzMyNGMxMWM4MDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQOC8OiCFkRaDQxHBTjSLYDjyEkpEhRynGCUaeX71///BGjw4rsXDCe\nKP98zIyP9YgYlmOIJzzfvZj6DHRtLuXwo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJ1B+/\npRy4L85kJf5zYy2ZlEVeiDAKBggqhkjOPQQDAgNIADBFAiEA/AttyXW6gpwFdbm4\nc5OPFK0xkH02VTBMZHvYSuhPaAACIH1Er4l/fWy/mZP+xA/ufjKj6yNBupRWt5ZN\nimdVS7QP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1505", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1505` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAbFVNLnYdsibd2VcFiqxHksqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjY2Q5OGUxLWY1YjktNDRlZC1iMWI4LTk1N2E3MmUzMTVkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDVhNjc5ZmYtMDk3\nZi00ZGFlLWE2OTEtZTE0ZjZkNTQwOTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB4OT6Qx4o9jXbDNVy1w0c5vlYJs379TJCTvwJKK+4VjWi7JHc3SUTi/3QFI+\nRnY2+oKgsYin9FyYjUD42ixdeqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlNcnDpr2o/P3bJr3oF4ikuCBUZ4wHwYDVR0j\nBBgwFoAUkr6rJ8TJtM7FN+ZfKOUpL5pVYWwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAgf0cmHAgq6kX+hGc+uuS7+ViHyz6akr3Mg5xw3ug\ne+oCIAn9/zurL6AO3MjpWj6LgTq9N7vbQ6X3pcL0crnTPhAZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbKiDjtEBkpnVkbti+I6teFCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2NkOThlMS1mNWI5LTQ0ZWQtYjFiOC05NTdhNzJlMzE1ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARluP5G6B5sm+JgZw4cd9VHjLbPZDMyNkhpGOHZUYtSM0aX\nwHFvws1jMMHuN7Bva7LwrGwc0f1/v+AALnzwC7uBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkr6rJ8TJtM7FN+ZfKOUpL5pV\nYWwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI9hle2SJkUjyGbA7M2Ml1zbopP/dxdDIoBfmy0NuOQAAiEA38ra3vXN\ned7GZP5AXSfnct+u+olS2WoYysZR902VCt4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAUbH+zEqkubxGkUi9Vkg6lmjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDVhNjc5ZmYtMDk3Zi00ZGFlLWE2OTEtZTE0ZjZkNTQwOTZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NTE5ZDA0\nNi01NTkyLTQ5NzUtYWUwOS1iN2YxZmRjYTQxYzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASohP1s00sMxSuEOdL0rq0W+Yw29+Q76wxyaKznZm8USMxEjNGEQPve\nIIxr3jqG/dEndVhDh9wSy6itJsouFkACo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSU1ycO\nmvaj8/dsmvegXiKS4IFRnjAKBggqhkjOPQQDAgNIADBFAiEA+Tpf5fJwgRCYDm80\nb1nWcJHreMmqm0amdqK9NB8pTP8CIAycDDDJOkjfNd3A8axwN6I+VwwqCTKQY2hl\nlOE/ZmfM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1506", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1506` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAbC31FPYUjVw+U0UUclMLCJBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmOTQ3ODU3LTk2YWYtNDhhOS04MWQ4LWM1M2EzMWI1YThiYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE0YjBhOGEtNWFh\nZi00NzBiLWE3NGEtMDMxNGYxMGNjZDJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsZy/fE2Emgln0leN6AJNm7HkXE3WDSfd9NjdEbXM8aDuNtdJ/fZH3pTU0bdR\nZLR3se2A60V65bk1KKyQ+6rAs6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJkGaW5kZxOYBqnL1IwmobzXFocMwHwYDVR0j\nBBgwFoAUyC2oLFOxWJ0qfcv6Yzdm85KlPl4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAm74WzGMHDcvsBkjSM5mt3GnaW3IN5S9S3+J3lIVh\nDX0CIQDW2q98AEuE7HIFG+K/ipNfP8//VEMczlHLqwGPrfdwkg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW2fnicfZOor7xVjjlgIN2i+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjk0Nzg1Ny05NmFmLTQ4YTktODFkOC1jNTNhMzFiNWE4YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3y9jcfAvxvR+etw71xytTFMQYLtkxcZGGp+GUVMPUIeoe\nN5fhPxzvBQK9NfsMp8Xz9+iOAuYt6VenVYgf6hbJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyC2oLFOxWJ0qfcv6Yzdm85Kl\nPl4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPG/F1RE+I50dzWQDbMDhCDDzpy1ZbA9SwaPXE75BfTSAiEAgn+pp+I9\n8KlkgTdvPQVLD50IKrnyrxGVAkwIUkUo+GE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAW9ivydPnaltguoaVqhYygHLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE0YjBhOGEtNWFhZi00NzBiLWE3NGEtMDMxNGYxMGNjZDJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMjYxNmVm\nZS0wZWM5LTQzOTAtOWQxYi03NTY0YjM4ZDFiM2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASi1Lu6r7VNeR7Ju5lRQfULUnTgr4rOaW7nusqjwT8hyw2InNmmjqAy\nq2LmyaBA15w20D0L29nWHYhrwi1z1+VEo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQmQZpb\nmRnE5gGqcvUjCahvNcWhwzAKBggqhkjOPQQDAgNIADBFAiAEIQgN4z9esC6jVxBA\nhfHLBUC5yKubs6wI/IEHr+zR6QIhAJTYEpxQRDDsY7GW0elQa9lrP82+n+zLQca/\nNsSzcSee\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1507", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1507` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAfFLKaXlk5AIqopfM2WmIV0/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkN2Y0Y2Y1LTQwZDAtNDk1YS1hMTVjLWI3YTkwNGEyN2EyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQwM2ZjZjUtMTRh\nMi00MmU3LWFlYmEtY2JlZDIyNzMyYjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWCIvV5cW2blGhPH6nJ965loa/dmSgJoZ/2+tbrPVbthF0GXVBNGggYd2BKz3\nbYWkv4il0qZOnejMD4tf5fWGfaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5CNYk7TVJHymFi5K65YvtOkw1jkwHwYDVR0j\nBBgwFoAU95MM7q3Sjl0E8EqJvI4Nq5Uh2ggwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBFBayIcalecWYwmHpJoiWRZbobrHHSw/vgDjIZBHm3ygIhAPaO\nQizjRHthhaAORgbQMbqlY0Dk4qi4ePWaBDeRpy5P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATM0iG7wk3IR3qzGvQNuw21+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDdmNGNmNS00MGQwLTQ5NWEtYTE1Yy1iN2E5MDRhMjdhMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6WeOGWGaSzhsu07bXdT9ZsBZf8H9fwXEF3uNxA3UvmjZp\nQTu1ypcF+EhdwFhxs9XGxceFdcxhp2Qo3V12TlA/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU95MM7q3Sjl0E8EqJvI4Nq5Uh\n2ggwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOexaB08k1gi0zTONwm9ivhoQE0fLparng2/QDoOzrk5AiA9FFvDaNnT\nAvZ3VKfi6Vy4w9bB4PDX17q5JR73eg89VA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAXfLnKr2zQJqxrJv0o0vd9dzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQwM2ZjZjUtMTRhMi00MmU3LWFlYmEtY2JlZDIyNzMyYjYzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZjFiMDcz\nMi1kZWFhLTRmYTYtYmUwOC02MzFjM2IwMzdkYzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ/wstTYxjSaCj36+R5Nwowo/Ockcz/W/4ICff0UwiSEy5n9LTePLfG\nIH6oz/z9b4ANeve2tiD3GOM8iLMeVWmZo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTkI1iT\ntNUkfKYWLkrrli+06TDWOTAKBggqhkjOPQQDAgNHADBEAiBm9rARBXIbTILozh3t\neYL3J6cppeEna3AnDxX7eUGBsQIgQSxFdYMgE/zRs/zYrOjvduLNe7RNX3F6XDzC\nxXW+5tk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1508", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1508` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAXHv6S+Thga14/zsJasS3js2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlMWFhNWI0LTMyNDUtNDA5My05N2I5LTY4OTljZTRhZmU4MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzlmOTY4ZGYtYmE2\nYS00NmVjLWIwZjAtOTI2NGYyMjY1YTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAsOdonHz2q80KJDS2eG//uMfCRfMmP9As3VDfz57MkNGAR1UhTDDbUfWvK/X\n1BGE6j0Qge/bZHdQC3AuoBybqaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+xwU9vUAti3+UEW76r6P0g4pMMQwHwYDVR0j\nBBgwFoAUIiuKL6PJTr/bS01atPnomE9TbjkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAFQDQyHIpPVbykaT3A2QeJVY2wqTI2wJ2Q\nG28auL4t5gIgIrNGlIcIHiugRphO4DW5YQyFdX9mKRRV/eKU8OIG9dQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAecD2t8BKcaUVaycQ9uLcIhdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTFhYTViNC0zMjQ1LTQwOTMtOTdiOS02ODk5Y2U0YWZlODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0oS1tQiGvJEodpHrkWnoCVl21y6ocz3Ntd0jNGxWp1TUp\n/St+N25K9DBoNttAcQc2rR/AqG/TY1c4shd6elc/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIiuKL6PJTr/bS01atPnomE9T\nbjkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc/osI0V0N4kXxsltI8wRMMn/4O3TQgWqOlP1DzWskEUCIQCclRxUSDTG\nGv9W9On7TBomh3N+/a6u1euaExzmwe6Sfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAY8dmV4/k2NcqZ7O19EsOGsZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzlmOTY4ZGYtYmE2YS00NmVjLWIwZjAtOTI2NGYyMjY1YTgzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ODY4NGYy\nNi00NWI1LTQ2ZmMtOGY5NC03YjMyMjgyODdhYWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT1Tzd0jlpIg19N+hDNzaxDkbpfbWoRLpmzueeJa37cQizNiUMUYdn9\n5LbpGO8O6VKikcqhljMVgTFitDenBF6go1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT7HBT2\n9QC2Lf5QRbvqvo/SDikwxDAKBggqhkjOPQQDAgNHADBEAiBmSFQh1t6MYq0OiyIj\nMeQc9vgpeFLzjIwtILjbuI51tgIgBfkKbSitnPLWu5zCH03atxWhaGpaIl947ryO\nZwG6QwQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1509", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1509` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAflC3cmkejle+pQpywfsDMsxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNmNiOTBlLWRkZmMtNDAxMS05YmFjLWVmYWFhMDAyZDllYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI2NmMyODgtMWE4\nZC00ZWVhLWE4MmMtZjk1MmUwYjY0YTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER8gNcGJlii00vLNovEC2ZmfgYNgGUjP3aLWmNHIiGBvtvMuLZPIqX8NtMfXV\n+KDChXb1X/WRsAJvJb4npwEUk6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzwAC6xtiPZvG+n7zcpMR8QD2IAYwHwYDVR0j\nBBgwFoAUsFVNXrUA0SOcoOJY4+p2P+FdWokwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAEKSTrv3hVUM+hrr4TlRljRB+ddvl3sjGr\nzoizfLj/dQIgZZTDh9AuJspgzYl/G+gslRrUAuVs6bQY81lslP7ZkmQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfXCn2GWai6AO670MN+YTcGzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTZjYjkwZS1kZGZjLTQwMTEtOWJhYy1lZmFhYTAwMmQ5ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbvuA4/tkIoQfKklDPBrGd8A9imPSW1VibdVuur+2uA1Je\nkWzCGpRRWVBs/hSAdxKnwzL46cW7aQGWsXvoSq3Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsFVNXrUA0SOcoOJY4+p2P+Fd\nWokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANu2Oj4z3aQr+bcf1zoDqtH3qs1qwVYbLFhpRaknhJbAAiAH2AznF2lP\ng/jmdLERGuj+K0nD//Ktsi7YEgi1OnzB5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISATm8y+bmGVIqwfzDXSoW1hmWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI2NmMyODgtMWE4ZC00ZWVhLWE4MmMtZjk1MmUwYjY0YTg2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2OTZhZjll\nZC00OTUyLTRiYzAtYWU5NC04ZjY3MTg5YzU4YWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASucPR07bk2EyiXs0YG0ErQ/YPqPuu4FLG01bJ9MkHZy0edsYv5W3rM\nbgKpaKbXBWs3/vMykFh6BvRwzoTrgqMto1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTPAALr\nG2I9m8b6fvNykxHxAPYgBjAKBggqhkjOPQQDAgNJADBGAiEA+w8iJYrHoLIDzb4j\n99UNC8ZnimWFYuAJW/6GgYM0kOECIQDG8LNyw5ZQUDsyCuGbg6r6OApltJxg2mQC\ngMV+Kjim/A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1510", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1510` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAdJa/Rh/qO5MLW3vrRjfZl8MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiMTU2NWE1LWNlMTAtNDAzMy1iNTk1LWIwMGE1MWE1MGI3MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQxNjFkMmEtNGFi\nOS00MTZiLWEzMDItYTFkMjg0OTNmZGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERo9YPtUGZf3gmwILAADoBgl93SR7OOBSyOd/6yYu1Nx0VYpIF+q8F53Gc3kY\nJHGgHGPihjM0wKPdXtzV0hbx06OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKK5xbeWwBBQuZyJclvvFIVOdT/cwHwYDVR0j\nBBgwFoAUQRlPHu8lEKJqN5omhShZdfKqQ4kwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB205U8L2/qQkyl\nGXDsOylOnx3su3XMw7oeLXmeebcDowIhAOu0j11IFtBX7I620/Gr+TlzyKW4z45x\n62DqXvuiAg5F\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfTzWxTQKzxw9CSmZdQOaRWOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjE1NjVhNS1jZTEwLTQwMzMtYjU5NS1iMDBhNTFhNTBiNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSyYbvj+1sAjWHaI7u9rcAvr2b1led4MFvuAHrerIT1ct1\n1zgi1mr3SNoANCub5+iRH+9rgbHaFUgBsGvG8j9io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQRlPHu8lEKJqN5omhShZdfKq\nQ4kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTMg3IcpiZBdpvRdLipSfI9Lg+/KjRcpv5ITAnaVSFcoCIQDXpMJibrbn\nPJ6QwiniOpWyUR7qcoPolp6v92zS8Ll1EA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAfdFlR7s8JXJYdexHZKApMQJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQxNjFkMmEtNGFiOS00MTZiLWEzMDItYTFkMjg0OTNmZGQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2OWNkYmRm\nOC04YjgyLTQ5ZGUtYTcwNy05MWUwN2YzNjVhZmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATrerrEj9Jga8v3kFkgYpzHZ/pfgk7XqLnuWr7BF8ypq+oz8p+HCn9v\nkj3UtDPUGWcE9HgzAm+0qpL5HQG5ypPto1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQornFt\n5bAEFC5nIlyW+8UhU51P9zAKBggqhkjOPQQDAgNHADBEAiA42GpB2yB3yGBQQcEu\ndDqIzjK3NqV1/peGl935YF3JOwIgSQc5C/h2AtKjAkE8ayxrmqTJbmMXpGieAibt\nbIs4rZs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1511", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1511` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAS0s3vZPsZmGPm94ugQBMSlAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5YjY2YmNlLTlkNTctNDkxYS1iNDU3LTA1YmE2ZmMyY2JmNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc2OWE1OTgtYjlm\nMi00MDA2LWE2M2MtNjNjZTA0NWI4NTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu6WgArk7nvdigQ4dq0v2QYPC4Cczuh9BY3MLxpwtGdp/4xnWL+TOkIpNgok8\n+5v/+Gf5YB8rGbwQ2DC8yMlhDKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOu7ZdG/QvJfniz6JRaUXdlyE8xUwHwYDVR0j\nBBgwFoAUMo2jzN8tP90x1+g32utD7Ot3ox4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBJ4ZQzPWFqCvfHkX9XHrrVr1vJCtA0eB65qKY76MbT3AiBNIgw8iS1UjbWV\n7yP+TrT+oKwlHYtlB1NgwRAGx/6AQg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfs0IFwBIp5hVM0cbUn8LkrBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWI2NmJjZS05ZDU3LTQ5MWEtYjQ1Ny0wNWJhNmZjMmNiZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQz3eBdmM8ZWkvso2AuIsHvRkAgCRQnPr+CYJc/73cg/1ns\ndEriohdmVdC+Vv4Sxb6FuxRwGGYtcf5Y2Mb5Cnwpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMo2jzN8tP90x1+g32utD7Ot3\nox4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMQQQtGBm6V5B+XWV6RBJEMQFVkLKowl7yTHZfIza8EcCIQD22S1dDIhh\n0UcQaMC0fU5F8Wrz0tA1zOj005gjuuuyCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAWugQ1f50ZHlLpG+hCrmRp93MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc2OWE1OTgtYjlmMi00MDA2LWE2M2MtNjNjZTA0NWI4NTZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwM2IwNDll\nMi00NjMzLTQ0OTUtOWZkNy0xMzg0NzU5M2UxNjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARKbKsGRAXlJQskcMTu6vFq1++98LV8qOModgrVXaMxPuBMXdsWLtvZ\nT58PK+OGH8qv8/P5nIJA2t/rqWyppXSDo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ67tl0\nb9C8l+eLPolFpRd2XITzFTAKBggqhkjOPQQDAgNIADBFAiBBrmGSyyJQ0tLEhCMN\nXzrJY/ChJ0l6cxuuPe52qxCSsQIhAIOZOcUe2JpBqlXYWKyHpsdjXgAmBcf0qvEi\nweRoo5Yh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1512", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1512` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbHOCAq8R+ggob0OJN9Z+37AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwZGJhMDRhLWQ2MGMtNGRkMy04YTZjLTg1YjlhMmM1MWQxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVhNTExNzctMzBk\nZS00OGMxLWEyMGQtNmYwODI1NjA0Yzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc94RdVgSEDsixuxPcECRFprNi27MxvhxbosDzsrfUJrXVj7L++4jYGR0Ky14\nYc5BMsz/6gPGco3cIC73IHnQZqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPxTPAnBauzyyH424rUToZFcJYFUwHwYDVR0j\nBBgwFoAUNnDztMEzL8Tfugejph4q6PagYtQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAitoNm/x+zGNZTM6+coyueaQUjg+crbJjj3N6VgQYKjAiEA+Hy1W2sEWWd3\nmq86zEBDsUznRbGOOjjp6BAt2odDmzo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATSwEX9CeuV905/GLneE8M+EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGRiYTA0YS1kNjBjLTRkZDMtOGE2Yy04NWI5YTJjNTFkMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDTGr1tSnmw51o/sieV5pNn1iqzE+G0lcngShD+CAHgcKA\noOru3SXXB+KPHjyi4OtFPX3YJq97kCYRLPWNJ3Tyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNnDztMEzL8Tfugejph4q6Pag\nYtQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIjQBWL0FsFEL/9wrecdsmMgdhFXLBTOGBuO8b25ls0cCIAFAAYY6LiIs\nwlkzrHDDlv1Tx0fuC0agTdPygAY4+onp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAUm8jPLWGOOSxlBEN8cBRFM0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVhNTExNzctMzBkZS00OGMxLWEyMGQtNmYwODI1NjA0Yzc4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZmFjOTNj\nZS04NmU3LTQ4OTEtYjQ2OS1mMDM4MWZhYThmMDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATZqCRQP43djOc/9bIXtoSKURRyD02g5uJSLIfW+jh6yCfj873MnDD6\nup2zUhpwvVxuF0Sl1PrUK6bmnx4WCZhyo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ/FM8C\ncFq7PLIfjbitROhkVwlgVTAKBggqhkjOPQQDAgNJADBGAiEAyukePTn6RJa5NLcX\nfP5eVMX0QXd30nRmP6mIkE8UxTwCIQCOeuNBMeAifbOzp7xydYo41WYP8vwhIqua\nc+whuPyO3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1513", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1513` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAU7jtMpjC7RVutvZi1b81J+MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlOTJlMTZiLTdmZGEtNDJiOC05MWEwLWVmNDJmMDI2Y2Y2OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI0MTA4ZGUtNDhj\nZS00NzZmLWI2M2ItMzRjMjk2OTQ5Y2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0qCJUrbp7o3qRXJRVW4kaGQA2OeenIh3qiOIgTGzHh49Gjmbapl0s7jewAjT\n1fV6fWQuvLoyiAqUQxN5jXKEf6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBADPoQD8Z/1bGiikAQpPM+lih2AwHwYDVR0j\nBBgwFoAUpyMCL6phC9u/xd+1BIIXrEKjTlgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAqCRHtZxxt2mJCNpe7OqWXi2zDM0xld6+NP5bUVCVzJ4CIQCWUOpFoKg9\nWaWQVkPdyQmaZWq3F5J5IOjyMrcGlb0coA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYN9supWKarIyVpXmrJM9B7pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTkyZTE2Yi03ZmRhLTQyYjgtOTFhMC1lZjQyZjAyNmNmNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFFw4RyA6ogdSEYvfcria2tjUhEOFGE2NYMUg9719qqZWD\nfzrKHRA7kOAXFGxvDd09Rrb2sfbVsCtWo9Lwh9zYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpyMCL6phC9u/xd+1BIIXrEKj\nTlgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANez55UIhCmqna/uGBQ+2iflnGB5YGPqdbTkzhBduRoLAiBmCiX0Pziv\nAOajongozE5SzbJQt7bH9jt9015efdaq6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAYTatkE3gwukMHNKtyy0YWFNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI0MTA4ZGUtNDhjZS00NzZmLWI2M2ItMzRjMjk2OTQ5Y2EwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNThmZjNj\nMi1iNDVhLTQyZTYtYTQ0Ny02YTg4NGJkZGIxMjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATIGqHIclrp1EYbb+G9lM+Fc8X4g6sM0cnvKTfqH3kI5X3ZljQUNeZ7\noDN/8pPhoQfgtA1QCEvOwIpATu4uhGgDo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQEAM+h\nAPxn/VsaKKQBCk8z6WKHYDAKBggqhkjOPQQDAgNJADBGAiEAgKooh2kZntWMMSgh\nGqWLn1FN7UzHyd1cQLDiMjLneXACIQDfymHieOZHIg5XqoDg5EdbmC2DGJRxSB5K\n14OHpUP0Pw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1514", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1514` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAUmVrkv/OPNLkYyLLGCGjT6FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmZGUwNWM2LWYzMWYtNDkwMy04NzAxLWQzMTBkZjlhNDI1MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NhZmI0ZTQtYTk3\nNi00NWVhLWFkNDgtZmM2MGU3NDgzYWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2uVMLP1NAurSXb7hTu+gw8pC8IXK+F25rVDfqCBPwgVBjxUWKSCAihFlXwhx\nRez0HPQX86I7dkHqk3x8hAnCQ6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU691jbzPzRM9TFoP6MFw+ww/JvnUwHwYDVR0j\nBBgwFoAUu5jwrwPmyAlnD4TVamBA+DlmmzUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiALJ3cRVpACrRek5dkffrzPna18geBOVImP9R/Yg4jO\nDgIgIKUDNi3XxEvmRTz95WF34rcV7JyxYPOS5fIHrLB3WNc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQkbJBsG3KCEoH8r8n1RY5fZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmRlMDVjNi1mMzFmLTQ5MDMtODcwMS1kMzEwZGY5YTQyNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNmb6Djv+ym/lODe0KIXdJgA0KDeel6zG//I1XXpQPtLCB\npP/6wkiWg4/ecUbpWulVzjaG6FUxEM38ak+4Jfwwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu5jwrwPmyAlnD4TVamBA+Dlm\nmzUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCOo8xh0Alg3gcVUzFjcpzT+Ypl1/33ZmkA6UpFrZq/0CIFbKBXn++JyE\n1tm+ROFYxq39grp3Hqk6AMdr4FFp/TWR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAQPbX2zk7BwwLZAKF65ZKtKNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NhZmI0ZTQtYTk3Ni00NWVhLWFkNDgtZmM2MGU3NDgzYWIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNjMyYWIz\nYi1jZWY2LTQ4NmMtODFmOS00YmY3ZTQ1MDEwNmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9ujuhPp1oNelw4vdzTH7vJJLAz6uPbWlaea+FDnyCobAU2wqGCTvG\nc+VzegWxGvdUW0lR7hWqIY655YnaM7yEo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTr3WNv\nM/NEz1MWg/owXD7DD8m+dTAKBggqhkjOPQQDAgNHADBEAiBIfaRsnzMlYLVD18Hh\n2VbM9jbQEhgH+q8DTUkp93SsygIgDMibgqrS0EvLZkluCqsqgjAKjyTkE6Mo346T\n3ywVJok=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1515", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1515` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAbyE5a47/sIyUMiNMEGoeMn8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmZWY0MDkwLWIwOTAtNDJmOC05NThlLWViZWViNDUzMzhhNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDcyNzk1YjgtN2Qx\nNS00NGRmLWEzZWMtMGE1NjViOWY3MmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyqDicITb9XaymghTL9uprLbhh7wPeXGXn0+l/VbGi7Q5evtijyqFOxVi41et\nuC374djAnVNYptiwhJnas/bfVaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu2UnzQe8w/nTC6S+IqgRkuQdqSUwHwYDVR0j\nBBgwFoAUdspCXGTE33X2iEJSj4GIOuSHG48wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAp1kqklDksQbpipzfbmQkOOiSWVb0aHvcBDGdu0GS\nZJcCIQDs3+krxzY9VgyJ6G/5/6/U/gBzycShlX50MECIYu8Q6w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeCMGrGZ4lwH7PKv7J6tUy+oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmVmNDA5MC1iMDkwLTQyZjgtOTU4ZS1lYmVlYjQ1MzM4YTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWFBBht/R5C1VbJOnPqRcDt2CSgUIf8yspAYs5AaiEsXFC\ntFlrUxkBsjAgnDa5OQ73pxNALH9YlrN50PwRjUPbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdspCXGTE33X2iEJSj4GIOuSH\nG48wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN2EA2V9m4Zmg4TbU8/xBUfgkO1CxvFEfYAKMbEIZFUICIQCRRrNNfsiU\ndMpWzG50R0N/idGVkrlE6v/Pmr3a4gK45w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAb1nY0g0Xy60TGSs0FyL7Nd/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDcyNzk1YjgtN2QxNS00NGRmLWEzZWMtMGE1NjViOWY3MmIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MjAxM2E2\nNy00MTc5LTQxMTUtODg3YS1kNGNlMGRmM2ZmNTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQS2f09RYiXUtlUlu7LoCHJKIaZQDcx4SmlYyLBiKeo4KB4hez+3kFM\nAzGqkwHRMg98g0CPIIqo8YOGOm2/KhFXo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7ZSfN\nB7zD+dMLpL4iqBGS5B2pJTAKBggqhkjOPQQDAgNHADBEAiB3wP4E+Hr2mcXTeS89\n9G/a9FLPSVXISxsJsInPM/r2TQIgVppQfLjg37OeX8hoyuVCXTg6L9iS0k4vTFU6\nyFyMEg4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1516", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1516` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAeMerA9dxbx3Whh/AOOtr294MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwYTBhNmM5LTBjNjEtNDI2Yy1hOGEzLTI2Njc5YTZmYWRiMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZlNzA1ZjItMjhl\nYi00MWM2LTgzNTctODQ5MWY5YzMyN2IwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaoH12BmGun5sybsyAIA5aiQv1TnFvj64uACT3bgFea10J8dmO0h3auaXdbuR\nYcQxPNqLk7fnIKkh1suJu8gfp6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO2hqHIDVkv/z1cU37iUymzuTm+IwHwYDVR0j\nBBgwFoAU3h/4l50odZjpi34sQb5jiJbrJsYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAqEbY0cEIV/IOwO4FwL0lNbD+GlA6dpn9lIrflvebwygCIATj\nJEBdDbkj9J35+mu8pynyh4cqPw6xQAo9zuYSh7y/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdelS7aGxsjUqWV7guBIH+NEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMGEwYTZjOS0wYzYxLTQyNmMtYThhMy0yNjY3OWE2ZmFkYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1A4A8X7Vu3gh9OZlDIMdJ0bjI4YFDcVBJyWO873UK8RJj\nWBt27XemsGwEU3erIPDcBtOWlGCQLQfjhPKNSGP7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3h/4l50odZjpi34sQb5jiJbr\nJsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIg0FzI3rbn7Eb1g8rdPjssd0cG2X8HrQFfsRq/BP57MAiEAw2EnpwZS\noonZaiqLwJJQ4SJdX2asHQZU/xxhDkVuNm4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAQM++kIxR3kQgCaoWSkSzcA+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZlNzA1ZjItMjhlYi00MWM2LTgzNTctODQ5MWY5YzMyN2IwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNmIwZjMw\nYS1mMjQzLTQ1ZmYtYmFkMi05N2RlMWQ3MmE4NDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAThvht3C4gxe/nYK/y8Nlh2ELkPBsl7c6BjiHcK2A9+S/JncaoJaH+O\n87vcgWxeVqI/spsCsekjLyGARe/H1sUao1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ7aGoc\ngNWS//PVxTfuJTKbO5Ob4jAKBggqhkjOPQQDAgNHADBEAiA6UZg4DamHxjAGXo5o\np8QBA1YHjS48lfoN/Fd/S5vSGgIgA5l1V39nJs+yeylnIhgOCBrrZYic82gS7n8V\nvpSuf58=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1517", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1517` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAVMp/IyqaF6teUZsoisXl3mnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4YjI1Y2ZmLTg2NzktNDVjMC1hNzc4LWMwYWVkYTlmMGEzODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjkyOWFiN2EtNjc1\nZi00OTNhLThlZWItNTkzZTFlOWRkOWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4cEID+z5Qbfl+BCXHdl+oxhZi1svHKQo1kQPea2tYnS3I+gfAwWsiUmGfBXO\nQudiuY9OO+cqifkcnjOLrqWPUKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/mEvndLNWkyCK1DxxOKQktjemQcwHwYDVR0j\nBBgwFoAUisfytui03+HcOwnO8PScphhpcm4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAkZpZXp9y6m+jQddEDDPZWEvkAmvTbMQi\nS3iJJ2XW8rYCIQCq04CSe5ofQ8mPBiz/6YzTtnMnileJYTjc93EzHCZh6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQErJhb3HpI6xRub9scfcvA6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGIyNWNmZi04Njc5LTQ1YzAtYTc3OC1jMGFlZGE5ZjBhMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStdmumH+VX5CGdaoIgqwnB76vB4Uk9lQ5AutznepWTNMOv\nDo8Jwvc6il/hIem7cv05p6Kfm5sn4cZGeD+vUe34o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUisfytui03+HcOwnO8PScphhp\ncm4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOfBUtklHAHqSv4YQAa2wfGURdMimSHQGjXSZWUwP0hyAiEAieZrjSV7\npenEvbWj9nCFaoOStFnX2ZMy7MPSqB4QNXQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAY/Qt1CmMNCRb/ZjbeYVLL5PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjkyOWFiN2EtNjc1Zi00OTNhLThlZWItNTkzZTFlOWRkOWI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMjM2MDg2\nOC00Yzk3LTQ1NWYtOWNjMC01MmEzYTYxMDY5NjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQoSzOdWqRbCQo54YK64NqaQZzFFvg5ywnSXbkRw2j3gCEIrnurG2P+\nvkrFt0EtuE7HZYXmH7VLJG4Dma4PhSKbo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+YS+d\n0s1aTIIrUPHE4pCS2N6ZBzAKBggqhkjOPQQDAgNHADBEAiBvMguNmnYeGZ5ZKxK5\nm/MlUpG8U6U2VBLA/m5drajpPAIgMcEk/0P5LPW2F8qJBqFGSmQ4U2+JuFo5WGDH\neqYlGeg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1518", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1518` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAUphTfV93aBEdJamSoxVpThsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NWFjYmQ3LTk1OWMtNDY1OS05OWQ0LWNmMzAwMTMyNjgwMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk1NDAxZmEtYTA0\nMi00Y2NkLWFmMDctM2MwODg2MmExYzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvVDRzezhHlcsEGUE3YN0VWbsY/GoDAMhkXNEWeFuZ6gxeu1GRAgdRlBSq+I+\nnlxTQnPtCZFkSGngCShv3tsZjKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ0B85e7wtdsVYuiNlbI7VjzkiQcwHwYDVR0j\nBBgwFoAUTMPRrO7xun4FrlX6ipGezSxqdR8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAh9cq9Yw2xgngddJ2T54Y8pwrjG3PChKEIVh\nOLiJeoALAiEA3QRKWXZz3jJUgxlP/jpRMcJX5U3P6QBsCDVsj/XYCc4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARWgFkpiQkoOj9URJC5kbEydMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODVhY2JkNy05NTljLTQ2NTktOTlkNC1jZjMwMDEzMjY4MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzWZQ9riMjzqKPjRmdqlzqWU1WLQ7sB34gI2SXnseZS16d\nr+i/jV8NLUv+IKEH2ornUfjod27z6sWFnpvzFiVJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTMPRrO7xun4FrlX6ipGezSxq\ndR8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKH89FwfQ13DBOHJm7jx8VvYTKrMy6juq8aUCbBx6E1DAiEAod3OrZVd\nH6D07IZ2ZS2hq1wGQlrBTR3uRDFZEeKH4Mo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAb41JXA1cYZwDJIgpo72E0QTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk1NDAxZmEtYTA0Mi00Y2NkLWFmMDctM2MwODg2MmExYzIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMmIzYzkx\nNy0xNzY4LTQwNzgtOGUyYi1jNzNkNzZkMDAzNTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASxLR3//RUOTWq15PmC4M2cHQNypmkcLC83SSglvVricKAAn+95YXV7\nuhekjZrJo8gdu+97seW+A17RUFIXhAQko1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQnQHzl\n7vC12xVi6I2VsjtWPOSJBzAKBggqhkjOPQQDAgNHADBEAiBRKTM48o+7tyM+6y/R\nP5Zg+ctuqUyj6DKCMhRwn0Q1XgIgYjvdBECMBMAfqFCMqj2OHuvHTpOlL6VSD94S\nVm7Sle4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1519", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1519` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISARBVKOUZM1MeMruBhqmRNHQjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4NTM4YjZjLTVmOWUtNDhlYS05NGYyLTJlMmE1ZDZhMDViMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdmNGU1ZDItMjEz\nMi00ODg3LWE4NjEtNTJiYzgyOWIyZWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO8SV6rb8Llo4ocOQFDqZYJrQsjtrB4Ak4kDZ9D4F35VpM7x0uwzFfJmBGX33\nSvcIDoobV9ls7nmDszDrCwzHv6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp1leHrKGprg9Ep5a5oO4SP+UYVgwHwYDVR0j\nBBgwFoAUaByWR/w61pEBwWvc8YweBTWoA1gwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIH+WSpuML9bwRY2bl+WytGRUn8G1\nMQZcyD611Gi3WcaDAiANCQN5MCtr5xk4x8pSG4lgFu+dVb8Tn/K2Qj07cZqwcg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcjf1NCJgjPLXFkGSpA8nx+yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODUzOGI2Yy01ZjllLTQ4ZWEtOTRmMi0yZTJhNWQ2YTA1YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeR7YQuAwVwgqzYLYqjMcOMfzqH2g9ypXjW9MszPbNHkGs\nDK1JdFa1dJCyb0JdpnL8cEKTAUvZvRKC6NwW7ZCxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaByWR/w61pEBwWvc8YweBTWo\nA1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN9KXld1wNcZchMnr4i6Yn+8aDmBHA+m9+klUblTJSNxAiAwkaSSRO8I\n9tECNWoD5Z3NP6tZbT12P92IU1iqhGZVhw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAZs1RJaj2kBZU+StujLIWEMVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdmNGU1ZDItMjEzMi00ODg3LWE4NjEtNTJiYzgyOWIyZWE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YWI5NGJl\nNy1hMDE2LTRiZWUtOTljZi0wZjVhNTE4ZTI3ODgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASzx1KrgPTm2xM9+KWpjs1Rb2KEoiCZu4s1Q72+ZGIPDbKBDdXNf2Qp\nNgjszJgkxUO9YvYeTMcUfmnB8PIdEbKuo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnWV4e\nsoamuD0Snlrmg7hI/5RhWDAKBggqhkjOPQQDAgNJADBGAiEAsuBWdVuvqZMuRnhj\nSxDVKRhCoeU6vsBiijdzz4disGwCIQCGFALGrCcutO1Vf7wCa4arm9lxc+Hqg/Z1\nv9dEPU6huw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1520", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1520` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAZukvF01ZbfX1+RMw+0Fcr/cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxMTEwMGY1LWQ2Y2ItNDEyYS1hMzBjLTFlNGE1Njg4YjkxNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM0YTM5NjUtOWMx\nMC00Y2ZkLWFlZGUtNWM1MDkxMzg1OGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYYOzscx+u2L7XmrmS0DtBxZBdsvVj2nHmi4EWnVUw65pOAG3nHoFqUX41SHd\niOwH8G17bImy1ChqjSHNaQ8+S6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqKFV/dgmU4bapsfiWasfBU3+A4YwHwYDVR0j\nBBgwFoAUf0U4ZTXdD6dptsllbMqa2bQVbaowKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgCMEYxH2T\nQ7e4si1tkQyaJpyEiWNVDQWOKQtvrOPUu5kCIQD4KrPI1TFom2Kkrr7QWkz0d7P/\np2osAzeJ2VPwHeBPKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX+qY1dPSAe+aINxtMTZtcVmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTExMDBmNS1kNmNiLTQxMmEtYTMwYy0xZTRhNTY4OGI5MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCbAKsaJFMtyJPhocPifyYXWDoN+/VbilOXwAO1l6UCKy3\nIGuVX5/9NBnTvPsMqZ3atEW+XxeuXhNwu/wWghMro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf0U4ZTXdD6dptsllbMqa2bQV\nbaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANIV90z8TnQAMsdCcQZ2W1sWq90k37MEmELhKiCnfrA/AiB7o7ZyZUFl\n6trZ9R/bPpN1q8+bfU3TjlUjBqZIGPjWNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAffA5oLzLIM5TvCBsPtMeEFIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM0YTM5NjUtOWMxMC00Y2ZkLWFlZGUtNWM1MDkxMzg1OGRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNDQyZjk5\nMy02ODkyLTQxNWEtOTE5ZS03MDQ4YTM5YTU3ZGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQa6QXvQd1EXA2ZoNkQgzo0M56QncqaLGhUvf6XoUCE6q9iKbYoSojz\nvtnMAWrTmGxYmDfOZ+pusKipto1aXIYfo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSooVX9\n2CZThtqmx+JZqx8FTf4DhjAKBggqhkjOPQQDAgNHADBEAiAxyk2bN2uXw98xsq3Z\n+ZfhtQ/qyFiCSf19D094c2T9JgIgWLvsPjzFjYCgOBgP3jOYpptrD/Bvh7/brpIo\nl+82S6w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1521", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1521` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISATMeBUPmv+54yE4u3goKpcWEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhMjg3ZDgyLWRhMGYtNDQwMS1iZjM5LTZjOGI3Y2ZiMTc1MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjkwNGYwMDktZWUw\nZS00MzZlLWIwNTQtOTY5ZjU4NzY4OGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcB/Q6iCYY1sgaqFUZuR2wifBrLhD+CbJ41zqkmsgh8EbPWWsjX3GZ7DQs/JN\nbJmYZGDkaQgt7L/8MAQXgLIX5qOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsMaD2iIAY7+tyZeo8X+UNhkvnBwwHwYDVR0j\nBBgwFoAUkv5BWcSufqoGYQlIsleDhDfhQVowKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgcmofWD3x\n+B5CyxGqRlqV2vUO/5Pr0dD/j+ri2F5nnpYCIEp/fw3+JkObhuUdA4lCekfzdPFM\n2M1vb0ROZhD8HoPM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZkW1+mqB5VWmZaLDC9JWTkUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTI4N2Q4Mi1kYTBmLTQ0MDEtYmYzOS02YzhiN2NmYjE3NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASa2LsVALC1+8VapXlMgaefmY6kLVFCRGR8U8NfbkQjq7HY\nuwQttENYm1n7U3a0fHW16EHenMUJLCpX4CAjv8kSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkv5BWcSufqoGYQlIsleDhDfh\nQVowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK7IAIkXVqS3kL1JkT/oRiI3b4FEg5aQDsevBDVpRFj/AiEA38eG9ni1\nxhUXacY9v5KsEsjKKxOTTEoqgtEx6oEbzGM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAdB6YDqy8/J3lxsWsby3jvCLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjkwNGYwMDktZWUwZS00MzZlLWIwNTQtOTY5ZjU4NzY4OGYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkOWNiODY1\nOS05MTQ2LTQzOWUtYjRhOC02MzgxNDk3NTdkY2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQKRBS9ZQDdLbvOUUC86eoEJnTWjox82CoKMs+fh8X+uG5P+0i4+lV/\ncfrn9clN54OY4oLeYs4Cbgr7Sq/ToYPKo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSwxoPa\nIgBjv63Jl6jxf5Q2GS+cHDAKBggqhkjOPQQDAgNHADBEAiBssFRFUxKBukqa4qtu\nIfIC2GcOFBaZNiUSjSiIasU2ygIgZZEeZIhPl27yQsLcGlM6XhSS4oGiUcZd3+Z6\nCSicOjo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1522", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1522` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISATt6bjpOj6GpxnTdOatznNPdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5ZDJjMzBjLTg4MzAtNGQwNi05MTg0LWVhNjdhNWUxOWQxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBiNGIzZWQtMmVi\nZS00Njg4LThlZTctNDVlY2ZiMjZiOTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0gh8WQk/ePkFF+PvN+oQ8RN9i3IN961lWMFgsWFdAWCzuCJHtz+8Pg1qmzOw\nAI0Dg6VlE+MkC4KwQrov17PFHKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz/+ux8HL+H5QkYCuEJYeJMJ+MN0wHwYDVR0j\nBBgwFoAUw28SIXETQJg0OgMoSm6a388hU+EwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICo6bs8k\nP1yYE0ZyRVwTVptCbaRcXZQOQhr/9KjmYnG1AiA0YTrwiNGEGuVDqobxdFzGUKsf\nxUC1kRmM3U4QZqbe1A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXuXXqYsDdDLe+r9BRgcSwv0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWQyYzMwYy04ODMwLTRkMDYtOTE4NC1lYTY3YTVlMTlkMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARanX+BBaAefvheJWS33D2V2t3yEpjmcd+ogDv/8j6HMK9Z\n6Etb1FUCat3zwWzKwls8u3iqD323bgcZbML40QNdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw28SIXETQJg0OgMoSm6a388h\nU+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIy0NbCvSHUdI5H0ubfhkt0cTj5oqwqqBnzX2QNo7bQAAiBtKOSLheDy\nheCwnIGNlN22yeV9KIZyfD/JP05v66BUMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAU04BxYrAG9g/jRncfBefyW4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBiNGIzZWQtMmViZS00Njg4LThlZTctNDVlY2ZiMjZiOTNkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YzA2Mjcw\nZS0xMzY2LTQ3OTQtYTU3Ny0zYjkzNzk1ZmY4YmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASKPY+pEl7IeyHQyKeuWLjUH+ASpIFrs4WkwSjgFIgJ/DeJ6H56X5TT\njlTvYa0iiTNLml8HlyPoSLMXIvtv3sg0o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTP/67H\nwcv4flCRgK4Qlh4kwn4w3TAKBggqhkjOPQQDAgNIADBFAiA2r8yh85zUdln78t+H\njwKW46jkwGMfZP78Qlakv2LfUwIhAMlFhxbfCyw0TLFsStnTdmLpl+eK8T9tC1sk\nEE3lHFkc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1523", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1523` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAajcYXyFTFemNBaPCS4rzQ83MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwNzRhMjgzLWU1OGUtNDRiNi1hYjAzLWEyZGQ3MzZmNWVlMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJmMjI2OTgtNGJi\nZi00MWM5LWE2ZTItNDQzOGQ5YzVlNjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgZn2Cr8zqp/9DfFjL+DDtPfMEZuEiYTK03X1l2cW2TIHEW4MUBHztVctMbrg\n6mOuk8bLDY2+Ier7OZ/81oFylaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyt8rOquzCUuFWGhVPQbc7RNDHV4wHwYDVR0j\nBBgwFoAU82T8lSyaRZw2v1aBxw8ereYfu5IwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCICYlLBj4C3USOOPHNZOUHiJBeQ556bW48tpnzw8r31OAAiEAoON9MYmx\nN9HGuWTvMhuBrMOaNpG6ksoCY66a4y05KWc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAanEIyshClBQlDtX/bBcr4sIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDc0YTI4My1lNThlLTQ0YjYtYWIwMy1hMmRkNzM2ZjVlZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTNA6XWQTE2SQa3yziezg4rRnvHqx2ipikVRagixIMWC67\nFmbPoliZrfCvafoXtaSW30P38TfB04Ug9xGW5RwDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU82T8lSyaRZw2v1aBxw8ereYf\nu5IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGGsfWlQoNk6E6zScJi9un5jbg2aVKCQ8lZpWiz7zpl8CIGwzfmTE6LjQ\nB3QXDTRtV8W6fAI5V9HiS9gyC1q26YON\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISASmvYDYfNvtbRwRSxihfmxA/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJmMjI2OTgtNGJiZi00MWM5LWE2ZTItNDQzOGQ5YzVlNjllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjN2ZhZGNh\nMS01ODc3LTQ1OTYtYjU5ZS02ODY1YzFlOTgwYmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARrIfnuNMTmbUFj8GGk8l6IWBRUAjZO6ZZ7RmeDP2lem8jiUTJXXWJF\nKrXqbdUh8mbHXFkOc9Ye7IQ0cz14q0jIo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTK3ys6\nq7MJS4VYaFU9BtztE0MdXjAKBggqhkjOPQQDAgNJADBGAiEAml/PNQuQWNqTfOmu\ngVNq7LcoPmVUE+jkKlG0V82BPWICIQCw7d3HQJ+kP0XxgMyfcksSpEohxOkmalwg\nvG1AmtvYfw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1524", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1524` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAWQ6YbjpzMu+Q8bWUUVF22W/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExZjNhNTVkLTg5OWEtNGQ5NC1iNTE4LWQxNmI1ZGRiYTY1MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk2NjE3MDUtMzk2\nMy00YjI5LWFmMzctZjVhMzI4MmZhODBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXWmWNVEnRNuZ1NNXvJBjEV935uxnpyv9/SbQ1P3OEa06FVK4YHkCb6ZCh6HM\nUCawAbMET3ZEDQ6cn72BQq3tNaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbjVXEie18GtUKZScZPecWtTcn3QwHwYDVR0j\nBBgwFoAUqVZZ5qMVT4MMbM95IxsQbvqNdDwwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCX9dROEvaO+i3IlWdAKFKzN1DTnAiFzj6eT2z15XSQ4gIhAIuMojDa\nnPooINTPJeOB2RGeCtu+4v9u7pH9cAIPX2m+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb56IAkedIAKcZ0iPuVrxmSRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWYzYTU1ZC04OTlhLTRkOTQtYjUxOC1kMTZiNWRkYmE2NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3PTbOqaTRL2suVnoGXumbd8XF2IWVUhu1Mcyc7jgkmndd\nTdUCEPZ8xB4hM13vfMI686Vv5ZU03owi2a++YzZoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqVZZ5qMVT4MMbM95IxsQbvqN\ndDwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeDxFEzRqPoyayWESJsEzv31NAKkegk3b9Jt/NgsFMfkCIQD63d0CWzAG\npVhMK6+e8iLBsRRCFHDPMYs1YSn2WBhTWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISASas7bbUF3aYCR4d3kb3CV+zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk2NjE3MDUtMzk2My00YjI5LWFmMzctZjVhMzI4MmZhODBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZDMzNzEx\nYy1kODFmLTRjZmEtOTUyYi1kMWEyNmMzZGRkNmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQHvhkaNPNUXst1kut40y+P/2IRpeGE6uiJEc7hyzxJvO5EODaxX64Q\nJoViq35tamnOCq+I/foWM+zuQE8yas7To1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRuNVcS\nJ7Xwa1QplJxk95xa1NyfdDAKBggqhkjOPQQDAgNJADBGAiEAiIA9+dgVnUI4lwcR\n0HdnLcIcJbJqEiGKRY5inBv0YWgCIQCJ504i8s1DmYNepNATDQxNpRmjiLDIabZD\nd1KbHqOQUA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1525", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1525` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAVkayTUq2QpfJN4vpCrLTshmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwYzNhMDJhLTMzY2EtNDI5Ny1iODRlLWM4MzQ0OTA2NDZlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU1ZmRjYTEtOGIx\nOC00NTQ0LTkwNjEtZDI3MTc3MWViZDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0BDAn5kYZBFkOwfuyvRLXxv03PcXJb+ObvT0lTwJsE/q1hdFiPdQ6NdQXj37\n9Nywy+43HWNOJnl3zy/ytGNaTqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8msgmrHZXpyVlRXKGgdO0NfxuZAwHwYDVR0j\nBBgwFoAU4XoeXXGj2G/MVZ3kWlAxKWg8K6YwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIC0dnMhwDUxCav6PBT7ojBQP3Y7eDPXbrNm3osLdC5qUAiEAmB7XIBZpNx+EKN3K\nurPvz3FPdAoNEinaI/cUf4iAgLM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXLIDkwNgWsbFE7K/UMd9vJdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMGMzYTAyYS0zM2NhLTQyOTctYjg0ZS1jODM0NDkwNjQ2ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReSTIYL+EPOr2LEzmY8HnIi6jkmMXoOncPAOOnnSxxYaJd\nnX/1nq3TxafWdD9RiZFEisU3xMbw8Xa2UahbrNM0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4XoeXXGj2G/MVZ3kWlAxKWg8\nK6YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ8CjvtpRLd+NzE+EX9DPmsd/L70Aj4zdiDuTKBFmTLoCIQD+bAXTSgKB\nIQjQRtaCnsbsePlvmwNQD4I2MvCF7o0//w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAeZiYAIei/bd2INRmbHPCVFiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU1ZmRjYTEtOGIxOC00NTQ0LTkwNjEtZDI3MTc3MWViZDJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiM2NjY2Nm\nOS1kMjQ1LTQwMzMtYTBkZC01ZDllYzlkZjA0ZTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS9zS8bXbYPAA+JrtJ+UECHgZiz4ak6zh9E2KOQnoYqlQvckogcUEbV\n8hjOgAUcnwv9HblA9K4j4sSQH/9zOZvjo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyayCa\nsdlenJWVFcoaB07Q1/G5kDAKBggqhkjOPQQDAgNIADBFAiAlGnzQ9M2N23TombSh\nKnUlpbWvRItWVqefYtFJ2RrBYAIhAJEZWSOfOLidWa00sTjJ/9u3MUaRM8Xldz2z\nwWmFuIR2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1526", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1526` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAXlDm7w6bAa8JTt1dIpEUxMSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxODM3ODM2LTU5YzUtNDE1Mi05Nzc2LWQ0NGFhYzlkMzc2NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA0YmI0YzgtZjlh\nNC00MDYzLWE4NWUtNWEwMGM2Yzg3MWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEFGz3iFGyPnTHy8Uab+3hqKjowJd2DqsSA79YWmqeEoPFgoLEgxThRFC7AXE\n+3E0DutlLdsInQOrybNhUMano6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdHrBQ6wodJISphxQwcUGSiZnXwMwHwYDVR0j\nBBgwFoAUu1srLQ5ufizKbKvRLGQC2xkI/DowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCXjkM87Bb6pSLM4UkKAMuCWecYovAOK4Ls41gOGJtryQIg\nQstkITwI1J7zXIE+6tjEx1MNTZBtflLDBuDeFyXaU24=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQpQsylvZ+6D6FjUqHNcq1d7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTgzNzgzNi01OWM1LTQxNTItOTc3Ni1kNDRhYWM5ZDM3NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8i3PLh+7cqda25++6cBhPkefdXNTsww3PCPO8P3JwcTe+\n1Cx0zg/AzAsqF29GYXihKk7HirxMPCSqpW2f/UWFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu1srLQ5ufizKbKvRLGQC2xkI\n/DowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbPF/NCveF/A8qm+zVGy4HkdKVzcSaFdjmL4CW6jxqBoCIQDF+rm4v8um\n412q4uroiPaVlzY+pCy6SxQ1nyEovJdmaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAWhlYCUBy9VBroynjTkBFZZjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA0YmI0YzgtZjlhNC00MDYzLWE4NWUtNWEwMGM2Yzg3MWRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkODkxYTU5\nZC00MDFhLTRlMTgtYTZmMi05YjNmNTA2YWY2OGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQyRjkDDiYx0Zzc+kWntKB9zs9YopEPO/R5EQ1GPhguPcz7Npm79w9/\n1AuR1vXcTRD3UjiDHu8ZFBri4+n1n+Voo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0esFD\nrCh0khKmHFDBxQZKJmdfAzAKBggqhkjOPQQDAgNJADBGAiEAn9OP1lRwOH99aFrf\nLBJZNLEL1Snr09wOK6wDdszZYgwCIQDmtKmNBV1lsGFoDX3rWRP+fqpiZ/8ajG2Q\nCxnJnVZxSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1527", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1527` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAZ5NzSo8/B61k6zvFqzUkMoJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhZWUyYzQ3LWVkYzMtNDE4Yy04ZGEzLWQ2YWE5OTFhMmQzMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q5ZDVkN2YtYzA5\nNy00YjllLTkzYzQtMzBkMjBhM2NiOTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZBXT2c0MxX2sqVDK6Ds/upURA7xT86UxsWALqymBCvIaTAymBl761jrAunha\nVuN1V7O8KzmYlRxrI5O6ezJ1x6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURqpbh8sufu2EcTObnnS9MfSygjgwHwYDVR0j\nBBgwFoAUTcyDdr8BdPFbsXHr8ZKGLJSbIEEwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCICZcImTat2LzH78i/SxdZ0BCzEWmGNvAGwjrMamYSvngAiBd\nA4lk6AMPR7X/GpYDMaV/Q998j/zsnR4BRycmBqL3vQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAciIsGgYJPlJA4cvHgMllubqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWVlMmM0Ny1lZGMzLTQxOGMtOGRhMy1kNmFhOTkxYTJkMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASG+CPP8xggDIT128k6O3UJZWRUDP14w/PcOgmXwckJH3uA\njRIxr1DyDkl8rfXi2IY27CPoYwiVO1C21acQlv8Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTcyDdr8BdPFbsXHr8ZKGLJSb\nIEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPFKWdG839y6Ck0EL29t7l6h0FnUE6XXHiY9f9Vl0eJhAiEAypxdQac5\nz954srKOrjb+UU760hS5+BPJ8XNwCoxLKY8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAQDkzClt2jGM8gHNHNGasCm/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q5ZDVkN2YtYzA5Ny00YjllLTkzYzQtMzBkMjBhM2NiOTA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMTYyYmQ4\nOC0wOWFiLTQ0YjItOTM5ZC1kMGE4OGE0M2I5YzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARQQ0Fmd1ldYKGumBQQqwPgywqHT5HSAtwH6CNEP8gimxwnuz88y/AG\n12Cp2GWYZXYDq6L6BxAD8c43TEK7kcFqo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGqluH\nyy5+7YRxM5uedL0x9LKCODAKBggqhkjOPQQDAgNIADBFAiEAxjRvMila5+OC6EAv\nrs1q87VfOM5uc1Qaf+3lT3HOoTcCIBwTB4EGAoaeL+ZROsoWoARNBqhpLbXItogp\neNuOjRXs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1528", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1528` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAQgUctMh8d+3UFYzN/vkNkmgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjYWQ4MTBhLTZhM2QtNDU0NC1iMTY0LWNkYjI2YWE1M2Q1ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkxYTVjZGItZmY3\nMS00OGY1LTkzNTktOGNiOGYyMmVhNTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMgX2uP7WApiUS/mvW2PD06NgarTCHP3c16ZHmkSu17qn0O98M2kBEBimCAKx\nlRR9j8f5AeropxDLmbpbHdMrY6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULXdlA3PoYYdryA9mtmwHeiIc1S0wHwYDVR0j\nBBgwFoAUrH3JVDgDc1NInjVLI8TY/3nOGGgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDIEz91bZwj\n6U0k5VnaVMECnmj9qMz3DB0Y1mHnT40sVwIhAKhaEjcmXwmVtb4OLfip18WgnZFk\nPton7pbTWuZ9nNcB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT6eG/fGccTr0DtwyS8X8eWLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2FkODEwYS02YTNkLTQ1NDQtYjE2NC1jZGIyNmFhNTNkNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlTftbyessvB84cTJDlxbAAxtda3ZvGHTMSuBtMJKnszWx\nZ3bSFJ9SfEYrr3D2HUxkKb/VG26RGg691BKptIjio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrH3JVDgDc1NInjVLI8TY/3nO\nGGgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMMXq4gsv4UFbHLAI7lsYPy5ZHyA3eIKyaEJlBcJLl0MAiA5fUQf5eXV\nsF+ceuJobtTlo77YbkBAfx2tJUe6OyDsZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAY09KCm86s/aeJnt8924C/8SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkxYTVjZGItZmY3MS00OGY1LTkzNTktOGNiOGYyMmVhNTU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MzVkMDE5\nYS1jMmQ5LTQ5YjEtYWNlYy05Y2JmYzVkYTM3YWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAReJgkl9GfDMGBxHseOOCrC92a8MghOVw5jRnk+Eyr60GhUvqVU6STm\n0a8PvLUuMF9RFLzqY3MFbKfstKir9Om2o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQtd2UD\nc+hhh2vID2a2bAd6IhzVLTAKBggqhkjOPQQDAgNIADBFAiEA2bHO+zkBU1M4ojFY\nkknMiR6jqDadF0EYMw/F01LpkrcCICtC3Thmx+O/+gFLzC1uzp8UIJYxiMOA50N5\nQguYn797\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1529", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1529` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAVVRuC7fv8xGhEqnTj60vs7sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkN2I2YTUzLTAxZDItNDJhNy04NTY2LWRlZjg2YThhNjM3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVjNWM0MDMtMDlj\nYy00YjIzLThlNWUtOTcwNmFkYjRkNjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsii+oTYxp6T/ccnKbA0djdxdGuzX6QCgKUp7UhUL0ep0tv+UOZiBT9+bKQIm\nL8Zd1+D3SCFAnxWTe3Y0cmHPsKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2aP60A8DHKT7+dn67AqlhS9A+YwwHwYDVR0j\nBBgwFoAUfC03OqNCedKf17Gz/+AnfUv7OQMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAP2IS6A4T7+dU2z1xcjaqltyPjQnfJ5xzzLjTQMYSYOeAiEApRZjB6kW\nuAp0QvBBFTw/YQHht9Prj/t+HxREO9vCpXA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUyxu6/uz1TdaXgZTJ+3GGlkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDdiNmE1My0wMWQyLTQyYTctODU2Ni1kZWY4NmE4YTYzNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzpNLxpoB3qbogDEsO3lIbPqx/bNWYgtZs1iqCazSrktnq\nsOeZWLEO8IpWOokQX1c6M9j60oZES08BR76IsY+po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfC03OqNCedKf17Gz/+AnfUv7\nOQMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALYiK1/PBLIs6/fG4zEmdONmaoDAiM+XuMPS49mhmoQyAiBwfSGuotim\nm7M7x5SZAQPwivhBmpZ67DwHvV9mGow7tQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAbax3FUa+mlByuT+1HrSj5v1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVjNWM0MDMtMDljYy00YjIzLThlNWUtOTcwNmFkYjRkNjQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZGI5MDdh\nNC05M2IwLTRlYzEtOWExMC1iOWE3ZTcyZTVjMzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATbUfQGu1kaBL2lyVQi50y1oc4VSurvpq5VT5DqqFGRyxvcO8PLzBy9\nUvlHiYWD0ObLZoTkgFGmhwAyuLTDENxko1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTZo/rQ\nDwMcpPv52frsCqWFL0D5jDAKBggqhkjOPQQDAgNHADBEAiAdfbE1idoT2UVaWxlY\nsesp6Y5UDdC6T56SJgytXE5J5wIgX3ifSXA6dAVMEGb27M9YLgXbHOEWHEKTMZfx\nPgvVOoo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1530", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1530` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAQkBOiZH1VBsPoJivN3ayN6MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzNWFlZDljLTI5NjAtNGRlMC1iMDAzLWZlZjI0OWFlYmMxMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAzM2E5YjQtYzMy\nZS00OTBjLTgyZDgtNDBiNjI1NmJkNzQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1q1Eiok9cah/f03xPTN6NabfBTCieFjSgEYGBAtcWXcfd1h+qTebMZOd1OrD\nR7iBtt5+syF3DiQJce/ApeRquqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnSEnh3SYtLY6FA896ruOHcrWr88wHwYDVR0j\nBBgwFoAUmGmSmzCUsxM6ss8G+jgDIDrtKv0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgG72HWhvg2Z/hEAzFfy0dlxqo+FCG9EM4qhbwBrW12/ACIE7bFk1NdQcF\n6oTMMxyQ9xAe+6p1TQkwnpasjPUA1DSD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQYs60TtgJRXYPYQoJq/4GWVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzVhZWQ5Yy0yOTYwLTRkZTAtYjAwMy1mZWYyNDlhZWJjMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0cuyYIAC6Gjalgi18MRrrwIJ+A+dwZk9gfcN4bdmOVgat\njIFZ0aaJUBzOgKYE2Kz79tmBxUva1b6f5HMqiLz1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmGmSmzCUsxM6ss8G+jgDIDrt\nKv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYfskWXz49TbHW2x8y3fa6qXtW3Z5hWCtDSXOe39RzV0CIGYHIaT2Vw5F\nqfhwVDErAh2VIu+YgBEp024miwJwroKe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISATf6hTNPkpVmAhFRbk6yK+KWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAzM2E5YjQtYzMyZS00OTBjLTgyZDgtNDBiNjI1NmJkNzQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OGRkYjAy\nMy1hMzYyLTRlYWQtYTg0Yi0zYTM5ZDI5NGJhZmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATjtINhLA6MWVEdAEwaJm9HfTTw5d71fJCcuKmN09rQDaHWG4+xQCsO\nVwFAfrHpD9Hw0axZUNqcg+QtwaAhtQ/+o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSdISeH\ndJi0tjoUDz3qu44dytavzzAKBggqhkjOPQQDAgNHADBEAiAM/0dGS8bhJg888vNY\n0ddxA7pIHexSihLFw5pO9klXNQIgUOhOGpGeDZuqNS779cu4kVcIeMlUjZYczVLY\ngVOspdA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1531", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1531` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAYDXV7mO/W+d0btVncJ/SqZnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2YzFlYTA0LTcwYWYtNGE2Ni1hMDk4LTRmMjczYjcwYzRkYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUzOWNkNjctMDBl\nMy00OGVkLWJmZTUtNzFlNTU0OGZlNjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFJ3RsUFmfZYk6qIBPuqcqj7uRojUegQ5x0abSrIRDgaXJ3Be4ArbKKoRl4PQ\npDsB6+p5Ri0+FihJQZDLjvJbZ6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtMVsXGH1vo5uempbIP3TnaMJDkEwHwYDVR0j\nBBgwFoAU80ThgIka6kvu+WhaxL2SuzfrsRQwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIG3uQdpaCTrdFtGfj96z8dyT7ZNmUMfGI8vUbKWXU7kNAiEA2SNzHpEz\n/9zRLc4/hDVuBwiZdOioKeMyPWgaAsu0a4s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd7mfYGvtFZntTReu3fvND4XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmMxZWEwNC03MGFmLTRhNjYtYTA5OC00ZjI3M2I3MGM0ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUvdFiOYggS6UiAKwcdJgt6R2HhT8hm8Zy2FSMCklWI21j\nbci1uevEtybz9mXgYLBLuEwZ7YTk7gH7azNZlUZPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU80ThgIka6kvu+WhaxL2Suzfr\nsRQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKt57iWiee/FAJANYS99BVjlMs5dw0uJPGoJ5pJ/dCmMAiEAjCJb1Oz5\nEKynJS2Mm8qFdU5+Xk9QsrAS41CaFlY2ZH4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAUBhoFP+VWdRIcydQgzhfceaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUzOWNkNjctMDBlMy00OGVkLWJmZTUtNzFlNTU0OGZlNjlhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZTY4OGMw\nNC0wZTQzLTQwZjYtYjFhMS1hY2E0ZWEwNDc4YTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR9oQ7kEZOCr8SV0vRhWWIn8ZDE9ejPzYC0Q+XqI6xkdAc3OygIpTxZ\nosMvME6DZ/X2l253ZCaJ2gEd4GuiLss0o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0xWxc\nYfW+jm56alsg/dOdowkOQTAKBggqhkjOPQQDAgNIADBFAiEAlcxDNjLjzc00Vbn0\nXat3KOmK0q9wwJMkNGg98HSVw3sCIC4dNfIG9u0nJnKipH7v+LGce2z8Zq/YIBE+\n5MpqhN06\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1532", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1532` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAcjSBaaIBB6kft4Q1ogwAx9OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1Y2Y3Mjk5LWFlZjgtNGQzMi1hZmFjLWI4NTZlYjg5ZGZjMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRjY2UyMDUtNDk2\nNS00MDlmLTg5NjEtYWUzMTQ2Y2YzM2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExsy3MsTVysPRYAsEgHeR+LAYJHMsB80b25wNt07B57K6Beqc9SQeXfekCuIr\nwSQFv/nD0HVrDzN2hgaQug8vSKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTjwDLzIQjlEwezk+t+AXCfHxtuQwHwYDVR0j\nBBgwFoAU1dQSV2qDrpYOzYj7r08GvkWE0XAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQD+DFqQeFgM1VzfL3uR0nUx7jRzpKTmQkb3I4g/\nJ8Jz+gIhAOXeZh0oFqtUX/NpWKVBDq2FdwpDOhf+oTUg7xj9Gl6s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR7YSp7OelrncT7TMuZ+IhusMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWNmNzI5OS1hZWY4LTRkMzItYWZhYy1iODU2ZWI4OWRmYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkPRCnrW9g7RLjFjmjAdBx3xyFWM1L8g1/W0eNpfuiDepo\nWS9LP4Kup3VXc1HpugFdosNaNmWrCh4OVz1XPuJko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1dQSV2qDrpYOzYj7r08GvkWE\n0XAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL5UroOn5tofb1jISTjMSwEwAEbA9+Yiur8ZzPiaj+ztAiEAkbqDGrZV\n5/NQiE9AqDxvvfsMtmRXgvc7YodoZS4EyPc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAWCvhtypCHLKqNLSaYjxpfmHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRjY2UyMDUtNDk2NS00MDlmLTg5NjEtYWUzMTQ2Y2YzM2ZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNmYyYmY0\nNy04YzQ5LTRlYzUtYjAwZS00N2Y4MzczN2I0YTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQHMaP2//8yLmgy7Hf+fyx76WR0y4NrHmoyFxSVjKX530PlBHyddxIE\npcI1vwLHuEdK9dMEA2vvnxJFjI3NIpnNo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBROPAMv\nMhCOUTB7OT634BcJ8fG25DAKBggqhkjOPQQDAgNHADBEAiBHEM4MXqyw8L73u2lq\nbGL331+2FGYWl/u81iDGhbiSGAIgbGIuR9kXVkjOj/nX/12VkUWO3/2ZEgv6XtKi\n5okn9JA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1533", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1533` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISARQY+Pqv6MHcM4Kw4nWPgAlrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlNGI0OTFlLTNhZjItNDYxNi05YzBkLTRkYzZhOGM3ZDEzODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYzZWEwYmQtZTQ4\nNS00N2RiLTkxZjgtOTFkNWZlMDAwZDJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh8+5037a8y9DHxT9TW4/AhzPwH9/8ql6HMoA2K1zWt/cXeHuceXpZNmr/1aU\ng0YqVfaOQLDK/tdRzMh4U0CQf6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfSu9rNqRnQnc3mwbhLwO71hof0gwHwYDVR0j\nBBgwFoAUoupNKsVEcGkOsyrykkGam9DgOUUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQClijm2Jn0nEADoqIzqMvhnl65KQrvudIcv9Bfl\niPH5swIgUYpRd1i4CMCBX/rT8+8naE2UFUMWSsF/4fpf0Aq9JjI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASYizBkqaBkUuttcQhHPwu0FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTRiNDkxZS0zYWYyLTQ2MTYtOWMwZC00ZGM2YThjN2QxMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuRT9zl/Qyj4uaCNjHDTsZQOo0rv1g8jwZDYkBxccejfdt\n9T38kyjinGKoJTq/HNK7O4bJ9N+R8GRVBl/J7ev7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoupNKsVEcGkOsyrykkGam9Dg\nOUUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJEWjIa6XTZ05MQm85/kSAfYyQdHrR35y4pLhdG0kYv2AiBQoi2PuiKw\nLJ3ig/HNPHTi4tjxHnUVWXbNdHKitcv1Jg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAdgF4vFd1/BfAQjmvwZiW33KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYzZWEwYmQtZTQ4NS00N2RiLTkxZjgtOTFkNWZlMDAwZDJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZjE4ZDZk\nZS05ZjIzLTQ2NzUtYWM4MC0xNjMzYWFlMjUwYzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ4i8yyKgbjSnc+LNYElo4k+EZlewptP9FmfSPvwN7M0SRyW1CHfW8g\nfYcX7e8lZgZQYSRV2htrdbBzLdXS8mk1o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9K72s\n2pGdCdzebBuEvA7vWGh/SDAKBggqhkjOPQQDAgNIADBFAiEAzK/SkrsfQNNTZX/w\naeqBp+1Frd1afGjIE0xSeHptfO8CIGYDwzz2tmYdjr0EpqLN/W3f1q6qXuB21K/a\nMAHbAAt2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1534", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1534` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAbFSC15xb1mfSVAsYOhyZRu6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyZTYzNjI3LWI0MTctNDY3Yy1hNmUzLTc3MGNjNWZkYTU4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU2NWZiMDEtMGJl\nMS00YWUyLWIwNDItZjUwODg0YzRiMTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiH9n4A/3qc07018VeivJUvqDC5prN/A4JN6WzqY4ruoV6Sri4VCDtlvvmrzK\nUPxqsORXiWJ5Mycq6l2WpPmo0aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUViEyJz6ILRmlfMlcyasHKuBzNOMwHwYDVR0j\nBBgwFoAU6AiasBNGe0Wq0hJ+hjUOr3SPIwYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCYPhAaOdMoVywIe8C43GBp8hrgrUim1wWxfFtm/d/vMgIg\nJDFCwTr7+4i/XDbs2FSvRr8eKo7WlEon5cqx09E1Bww=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ7a3984Celx9UdlF6gnrklHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmU2MzYyNy1iNDE3LTQ2N2MtYTZlMy03NzBjYzVmZGE1ODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzhEdFvwHNSubGIIwB7uZZsmnjxIr11W1ME2hLXMPCYi7p\nO8BRQ0Wcil1jKZKueV0q8QhEE2nMX0+siCj8d6WFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6AiasBNGe0Wq0hJ+hjUOr3SP\nIwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANwbCANH0IpIYQ8yAhx4c3Xf9c+juuuNRpJ+kmpAOJ4xAiEAqGI7PxOG\nqyL37yHEwlr1j9++wdX1UfXm42Q8hx+3zo4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAbWV54Nb/kITjIK++CaIgX2zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU2NWZiMDEtMGJlMS00YWUyLWIwNDItZjUwODg0YzRiMTRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2Njg3M2Nl\nMy1hNWE0LTRiMTEtOGMwZS1kYmVlYzA1ZWJjNTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARcMuxqcInrGYzh5aMWUfQEGP64gZnFJFOe93Je3NOfU+UhQz81dpLo\nBhjbeWg54hWiEEYoBCocHyqZT2ddXgOCo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWITIn\nPogtGaV8yVzJqwcq4HM04zAKBggqhkjOPQQDAgNIADBFAiEApb3/Z4PTjECaNnN+\nBg8/AMr9sHfV48JDJoFiQUOx/csCIGJih8HoeVDhaHijiN72C4NSNUrZzQ0UEH/C\nuOYd+pas\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1535", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1535` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAeQ4heZyNjd1LLIahumhPdjEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3MTJmOWVkLTU3MjMtNGViMi1hZjM0LTg2NDE4NGU0YTYxNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhkYjIyYTQtMmFk\nNy00YzUwLWIzZjktYzU5MWVkNDJjZjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZE6ISNct6uXRFKOXBvmasIjUL08BUOC6wA35RY+840rV7D5QJ1Gz8eDkZWiq\nSReWyWpZwdNYDtjp3jHJlR0oEaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhpNEUeO7xwscWu/9yF/wKbP2GQEwHwYDVR0j\nBBgwFoAUjrkOhqM+uBTqJqzhNNpy54hGOXwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGYneSoIjyb4lbKxRUGC9shGjpZsgDU/\nLAyuAx5T/YONAiBAeKVOujTfJ6dWEUIy9aqIhrrNMhLCYsQHLURXu/KWlA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAewMr7fNDArmC68QlIzqBlb+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzEyZjllZC01NzIzLTRlYjItYWYzNC04NjQxODRlNGE2MTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoEWRteF14l+Ee692mCUoAH+FfaquKyKotxgNfOHMhcap5\n694aCQlwpkd60Zc9I1RgI7jW/70uhEXoeLuCDIRHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjrkOhqM+uBTqJqzhNNpy54hG\nOXwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRe664CR6Ij22HwNv8PyJzID/RaKdl3ElI+PFNwHqUmYCIQDoDrtPKfsl\nPxPlTGzzOIQ8C6I4BpeTJfJJbwRsMLae3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISARt/n8UZDI4VOA7FMqLXl4QyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhkYjIyYTQtMmFkNy00YzUwLWIzZjktYzU5MWVkNDJjZjZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMGRiNDY5\nNy1kMGIzLTQxZmEtYWY1Yi04ZjVlMGMyNjBjYjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQDwTCtl1INsBG8xHK5MPnpVD0/L4XlGqrXVUgEUvDsZbkEsXux3owa\n/jxkAsRz0i/T2q5yDzYRM/q1cuZDxV6zo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSGk0RR\n47vHCxxa7/3IX/Aps/YZATAKBggqhkjOPQQDAgNIADBFAiATp4lJfk/T6SrNCQbp\n/qP+TIM095zR4lPrFc2pa1fhqwIhAKX/td+blJ0stoosqFqE91KvuksfxP8a/Lh/\njy/pDJJh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1536", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1536` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAT3SuzNOkzI6C90nYFV4MeaEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzNzBjNmM4LTFhYzgtNGZmZC04MjQ0LTdjOGZlMjg3NGExNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjkwNmI4NDQtNTY0\nOC00YjNlLTg4ZWMtZDNjM2I2MTEzNTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/ZyngFtxiRAmE5Z8SESYatH5hE83hTBx0UCUWaTirIF30iHdgleMpbxNXMsT\nVERrcsjLAYUrBz29VsRKWU2mvKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgNLGLV591Kh6/8reDVBCqLG+QTowHwYDVR0j\nBBgwFoAUVZpcJz1EJDX8O330C+ZvIngP5+8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCM1fuUnbUoKPilbpr6ywCztudWuC/5\nFOUOQNjumW1IqgIgbkCn83xZiGdoLZX0sjAIKrm3riwoaCHFqIcKNXpjzGE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaqKQ3DDclmt64ofcgIokh5sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzcwYzZjOC0xYWM4LTRmZmQtODI0NC03YzhmZTI4NzRhMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8rG0xT+s8Rg23ebOwxh1sC/umuL0J/R84u9p/YdeFJ/p9\nNeBkx/piyCQkgqttGjDRTreMqmxTZYYBSdwtSEwGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVZpcJz1EJDX8O330C+ZvIngP\n5+8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbqhZElN2YU/iQJasvUa7c84p0TKxiPfgCx/Z2craj6kCIEdYz+FfSZVg\n6aRBk9q4EgWKsiKLcCIPUPR85J4gjlFW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAVVLWSG8/ZvUnIIOUq3OF3/+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjkwNmI4NDQtNTY0OC00YjNlLTg4ZWMtZDNjM2I2MTEzNTRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlOWI5NGFk\nZi1mNjMwLTRiMzItODEyYS1hYWQ1ODNjODE1OTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQAeCLPMw5cqdcmIkFf6ktp4t7jaWhiTAF3XgwmeujG2k1pXFrbfF3i\nOzbYwv7Mj1m/voIJ8dQqwcAwIJpk+/A8o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSA0sYt\nXn3UqHr/yt4NUEKosb5BOjAKBggqhkjOPQQDAgNIADBFAiEA9wlQtyuYHKq3CTiD\nVk8UWHH3ZiUi0/zhXQCe43DBlxwCIGq7YIOCOsnROzOsNaZ6542RXhSdDgXmmlpB\nFfhDofV7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1537", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1537` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARMEd+hOxtFrYh7CgFBnl+e1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNTQxMWQzLWYwYTQtNDUyYy1hOTU5LTI5Y2JjNzY5ODNhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWIzYmM2MTctNTI1\nYS00NzI0LTg2MjgtM2QzYzk0NzM2YzQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjay5NJ1YTF7FL0/nMR0qrk3imDnaRIISik4jOxf1QLqr7ti2gkWYRkwSBGMR\nS1VWQ//iTswLNDDFztfrNEHUSqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2fBT14e3KdRAg6YRWT7xTO7JXB0wHwYDVR0j\nBBgwFoAUYR2/hK1xrAIQzSiPXWtOr349RJcwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIB5sJeP1mSJV\nNwCiN3v3ioQHm7WeHwFU8C3QrI5zFDS3AiEAopImSn+cXUJvlw7k7tl+lNrP6Aoh\nCmj5pCjdnCpfvQI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAek/WPNXd5i0sZ6D0b371W7uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzU0MTFkMy1mMGE0LTQ1MmMtYTk1OS0yOWNiYzc2OTgzYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrNJEOPZQKUdNFYsfU6poKlEEf6ChIwUVFC28cntGWbtLj\noCRzfFwyWZ2nQFSC/un0zdGMrL9dA8IG9OzcwW3Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYR2/hK1xrAIQzSiPXWtOr349\nRJcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD5xKoT8nufNhuewfpUPaU1iazi5XgE6WdGmKC2+6aaICIFYKRXkfW20j\n0pPeWXPjyQDVYGN0APXJS1nOaSdYCemn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAXBlp7Kwd/Kg/z08LYObR1U+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWIzYmM2MTctNTI1YS00NzI0LTg2MjgtM2QzYzk0NzM2YzQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNjYzN2Jm\nNi1jNDI2LTQ5Y2MtYmNmNS01MzhhN2U5ZTc4MWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQmxEz9K/AeqGkDs7uZuKnY2PdyfSKuzah6rHUUdiltq+tU9cVXYQGe\ntp59uMHlG/gyot9Gb1qiM1T1eUUAQk2Oo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTZ8FPX\nh7cp1ECDphFZPvFM7slcHTAKBggqhkjOPQQDAgNJADBGAiEAp9NYEtjLAfkUy13H\nMPncuwKkIaGAOq1EM3VPAY4EIlkCIQCTCkUg4k11h7KuAewGjNQqzrSxLBwvvKtL\nMt2YVbpgiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1538", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1538` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAWcjtAkVn2M2Cs0zKQtTBG6CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1ODMzZDVhLTUxYmYtNGExYy05YTlkLWIzODdlMDkzMzljMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI1YTI5NDQtNWJi\nNy00NTRlLWI5MjMtYjQ5OTJhZGU4ZDRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYp8Q7g/TssSK3AZwMCvosYAdWKnhC+Yhqlfzs8NxgG25Z8jARV0wZytkZnLr\nqklAeL4wRBnwxNwbpn11p1a68qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURWSA31PhOV8hSKfxXaXx+iTchu8wHwYDVR0j\nBBgwFoAUQulRgA3/mAlQUHxjyE9notdLF1AwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgFcUGbAvqBfw9zat4SIqODL7RJF5ONO3o1OkgN93cvzoCIQCN/6UgO3da\nhc8N1ky5PJbRfRlEsVsvQIT3HRX0dgHErw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcV0S7paKThdubIwDDNgcsBAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTgzM2Q1YS01MWJmLTRhMWMtOWE5ZC1iMzg3ZTA5MzM5YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWaggV862n5xd9UAi4ozLzd949cwAqP4L1+k2EiAZHhmfY\nhPvRN5pV4CIUFVTTjNC9Fu7DVb7FF8hGZxfay8tMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQulRgA3/mAlQUHxjyE9notdL\nF1AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOa8yU4WQvoo27DBH35t9YYCPigRhBODmsY6KvgnXjuECIBwNR4e1v/Hj\nI0hpV9ax3mbWGB8m7GoE/lz9w3t3dAW8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAUkuIVVhVM/DDkgB5cH+1yVHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI1YTI5NDQtNWJiNy00NTRlLWI5MjMtYjQ5OTJhZGU4ZDRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ODM0OWVj\nZC03MzliLTRjMTItYTU5Zi0yZjk1YTliYWZkMWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS1FUROJy6+MdnmqHZmfjB2m9QEZgDdgcY8xrSi/O2FMctCw9Jm/pTr\nIKKgljKnFGmwwl4zgpTALjUlheXiYaEJo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFZIDf\nU+E5XyFIp/FdpfH6JNyG7zAKBggqhkjOPQQDAgNHADBEAiAUwL6XHWgfsuNIHtuG\nqKh87lZUu2DbM49XLmKmXuB4ygIgZnQlbG7oFCNTSpzbo1xa7gYfFvpHkBfNmb3c\ni0fOl1A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1539", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1539` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAUr3vXYL3XZYsFksoJHMhtaPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzOGEwZTQzLTE2NzMtNDA2Ni05OThkLTkyNDhjOWJmZTBhYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM1Yzc2NjctZjk3\nOS00MDk4LWE3ODYtNTVjOTYwNWYwZTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHmLaP+hs/HLn/CLko/ZsDKv+aEB2LNiQnlDdmeUlNHgMR7a+rd60fgbemgsN\nCauSwMO8hsuhr/f8D3WCtALsRaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUimOk9wTe+gcJpMtU+4KdhC9g0OwwHwYDVR0j\nBBgwFoAURWHyibqgvgurgWxkGNFyFJM7IwYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJqFseVTxBsW2NOliquSzAY69jYk+RZP1CSKd1C3wvrUAiB26Av0k8yG\nTidKwwzXkDVTHaRN4vBeISZ2M8waRwhlrQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYn1WFcBCGW0Q4hH3bZguPcmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzhhMGU0My0xNjczLTQwNjYtOTk4ZC05MjQ4YzliZmUwYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9i7PODSxbmZyfFxUFzOTCEvAIcIvRUvvtNctyid443Nia\nsLUgyvxEIgHoPkL4U4TN+3Zso3/G3n4Ndl//8sjqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURWHyibqgvgurgWxkGNFyFJM7\nIwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXaXxvCylQqw4W8p2R/SZ3iMvw1cbYByIN4/wo3c9/NUCICL9X+u21EqA\nhUgXyS/NCkZI/2APzBhbBT3X68M83jc+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISATlQTSXWkKu9G+3cBRe0Yn4tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM1Yzc2NjctZjk3OS00MDk4LWE3ODYtNTVjOTYwNWYwZTdhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MGU3Nzg3\nNS0yYTM2LTRlMDgtOThiZS1jNWZiNzA3YjNhNDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATQoSn3guTh4wuu+yno6RBQ6X6U+TqMFexrYbZrY2BujIvEK3+gyr4k\nPdtiS0Gd1kusjV2hJ8AMLLXY1+UBgm6mo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSKY6T3\nBN76Bwmky1T7gp2EL2DQ7DAKBggqhkjOPQQDAgNHADBEAiBGYLiFr19Hhc4/aXAv\nYHHyNslBk5SOUELNbL1qcFQ4PQIgepeB9vpwKWgnq/70v1lVcL4+m067Q8BJCztk\nD3m6HqQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1540", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1540` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAWb/sLuCDO15BtR7w6Um6CjnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1YjdlZDhhLWFkZGItNGZlYy04MjMyLTk0ODE2ZDRmNzBjZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA2MTc5MTQtZjg2\nNC00OTBlLThmOTItOTQ3ZDRiOTUwMjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1d2WPjlSFbgJbpg6q2eCZmgi6JPOGcBcaHibbbhUIBNLvW28jHLeo8Dxwxf6\nOp5Pa0NIPeWk68QvlfX5s1VUeaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUftLC3n0GZkCJVah0zAN6QYUXtXUwHwYDVR0j\nBBgwFoAU/lMaon6diUbtMhQLobM2I7dvtsQwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIB8tF4BigPb9KjzgF6LGbrSBqa73E1xQ6eMD50OD9bT0AiAtfl8J1j99\neKzsUZpZ0lV3XGrpQ2tIVaRXpGIyjm9rag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ1W7UmhEPjIRtPM9RxHy1fyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWI3ZWQ4YS1hZGRiLTRmZWMtODIzMi05NDgxNmQ0ZjcwY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNMAENzP1yA2NKLZu+KiCttF3uZ624wEcJCAtMmPMquN6m\nHY9izYtZS/LdEGdm+2he2FbnCjaQPaPt8KNkZ5THo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/lMaon6diUbtMhQLobM2I7dv\ntsQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAORUJFrojJI3RpA/lcRmfD7hChSqfiRVbxblfRkRRq8rAiEAl5ji50g5\nj1bEtpTobmKjIEu/SmGqs/E67fOe11yQt0w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISATVnNZaAON9KiZ5bUI5aaOx4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA2MTc5MTQtZjg2NC00OTBlLThmOTItOTQ3ZDRiOTUwMjU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZDQwZDYx\nNS0zN2FlLTQ3ZWUtYjE2ZS1lY2NjZDg2NjU2ZjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR750k+rxosI0j9E7bMBuv9ZY3huiJnqm9/gfyg2Reb14Z/IeFQBKNQ\n2kBHYNLmTuO87ojn0IZk4LgmrRtDtCtAo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+0sLe\nfQZmQIlVqHTMA3pBhRe1dTAKBggqhkjOPQQDAgNHADBEAiAN3MHG+rdRSZpbl+IT\nishm1vgODujAUqdi3ToHRxJDBgIgVS7UvbZgDbXySmC33z0OgF4Wp/VKKBoC+bzp\nFxJ53WI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1541", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1541` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAX2QtEcd+F3r5qoMPwLMk+unMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjYmQ0NzQ2LTg5ZTQtNDkzNS1hNjNmLTgxYWQ5YmUyZGZiMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTgxOWJhNzEtMmZl\nYy00ODk0LTkzYzItZGM1YzZmMTJlYWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo/a9WHr98pGRB++4oa/m+74nFaNUwODFa6PpjLRVJpuHAshRKbuQKQ4Dy24I\nP7qV5UDIvBWEM2+3v6zv/g895aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVBHQcWeYtfY1VTCbygKOFYObvaQwHwYDVR0j\nBBgwFoAUqSp11wXZ0x7WBHh5QJX+N7H9jfgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBQS/8ke8fB8eWuyc4txrlGIa/7sgD96YOvfSiwb\nF5uvAiALl/MB0b3vcQpvB94TUG0D7cPw4jb/BWcvVg5a086lvQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcU2rogB2FudFGGCXExBmVtNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2JkNDc0Ni04OWU0LTQ5MzUtYTYzZi04MWFkOWJlMmRmYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhFABDV7Yc6/RyDXc7I1rqDJSQyiHYsowch0UUDmYux4WN\nOTtCn3BXvDHNb+5GF5m5i3cxPz2rhgJuV4wRbfvoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqSp11wXZ0x7WBHh5QJX+N7H9\njfgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXSDZLNaGYIOqxiVigChWcr37Oxapw1dn0bu3GGp6FD4CIQDyM05FTf8L\nnCUST1eNp7/EngLNlttUyHUrFU6g+YZ13Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAfLLuDwCRYWZP2ABqny7uTSZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTgxOWJhNzEtMmZlYy00ODk0LTkzYzItZGM1YzZmMTJlYWFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZDYyZDZl\nOS1kYTA4LTRiMzMtOGQxOS05NzJkZWJhZGE0NjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATLZ5FiG82EsklsksptqhpJDDR2URFNKv2nNmtBUPR+hDkk0umO21mq\nvURhKZaWgNV8wnn5RnhF9H+6N7oA5tPNo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUEdBx\nZ5i19jVVMJvKAo4Vg5u9pDAKBggqhkjOPQQDAgNJADBGAiEAlpki6fYwcwH5dQFd\nbF8zHNp7euAmoCp6iJDQHrfUXqMCIQDhjQmdc4C8aWkf3BlfqSB0vEMWciukEKdx\nh0Qs7BLb7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1542", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1542` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAe/5InJkwWf2jXaTbF1SSsgVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkODdmMDY1LWRmN2UtNDhhNC1hMDM3LThhZTkzYzJjMGIyYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRlY2FhOGUtMDk4\nYS00YjEwLWJiZDQtMDc0ZDgzMTQzYjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJbtzUWbI62+aOwXpUfA+rmkrTapzU/movmcvB4Mb0kaKAJcz8AcLC8Okdo9X\n5HPRx9ldXwHHScPRh5kfesW27qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp20fEqGd4tHzjSTRFlRWzrEWmV8wHwYDVR0j\nBBgwFoAUmykw/84hxU2PkOKvPniObZ3FEoEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCfE6SgytEh+u/6/Z89frue6RHUNKjuBhVE5D9G\nBW2weAIgKQn62r83KCNCrH9LCHH1lHUexEt0MBq9SLr70OzcMuU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX7iK4keO0bHmzUByOFDbrgkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDg3ZjA2NS1kZjdlLTQ4YTQtYTAzNy04YWU5M2MyYzBiMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzRO9zS24Hn9K/daAiQopH8k9VB2R6EdBhQB74euksc62B\nIb0XKArnIf8PFjPDbz2d2zIu4+TL0rOSULMEqfYDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmykw/84hxU2PkOKvPniObZ3F\nEoEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBSlkFWNxaU5A8i81tb/L0IdPeCUurY4N+E9Ewgd/HbgCIQC0aEW7/fox\nEsBxSttmuRcoPPm0Wtj84CG8m2TxrsjYOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISASNkUEuD7s+drmp4VVUM/waRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRlY2FhOGUtMDk4YS00YjEwLWJiZDQtMDc0ZDgzMTQzYjcwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNmEyMmQx\nNi0wZjkwLTQ2ZWUtODdhOC0yZDBjOTQwNzEyMjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASvJ5dMwm46YIW9+JT4a3sZ8c+7k/0ofHqSUu5UdzCmqkMwzI+JeJCb\nixqUG5jxlF8XfTdl0WxRMaK7ZB3ReWkOo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnbR8S\noZ3i0fONJNEWVFbOsRaZXzAKBggqhkjOPQQDAgNIADBFAiEA+5Kx/W9EkL5n9CaF\nFI4idcM+odFBCUvLHTcjPZ9j0s4CID+/Pkl0qdfJhveegH35lG2vXJRYShfz68Nk\nxnNN8w0I\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1543", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1543` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYVV1kbGLfX3KqFkapKXcd7zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwMTU2NDg1LWEyNzctNDk4YS1hMWM0LTkyZGEwYTY2OGNjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTcyYWE5ZmUtZGM5\nNi00ZjU0LTlmMGItNGMxOTY5OWU1ZjU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgLDdV5H0l2MVeHzMwg/WeaqRRldlASEz7LC5kOECnkTT5YTHWrKKuIof4hU0\ncwuQJkCq42qeqki2lJEhcrDFRqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Dsplhvd4HQyIoEhSP32TJZnuZkwHwYDVR0j\nBBgwFoAUtM3pHxBmXstTWKOdc5uNipKW1TYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQD0A0KnEXRVEjQ56ZNBKRWB9juZDe5SJOS9iFu1kNMcbwIg\nSombgXUoEfSMDduk+UjiziLRAxG04WVarfSXjWG/9Vg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVQ6g+oNrNQLl7nIztf4Rwc6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDE1NjQ4NS1hMjc3LTQ5OGEtYTFjNC05MmRhMGE2NjhjYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARK+YSBXkfzRyxLrZpnsE3dwQF7KobEwb5FSBDKOrx7ZHAO\nRuXagwDFtvzWAFpfofMYyMgLbIBYKS4QmNyrMxx8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtM3pHxBmXstTWKOdc5uNipKW\n1TYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJNg0SWqSL3q4IjR7Fve+MH1Py01JG2KNnfY9soG5dbtAiBbkFtFiCNW\nMki2ksQ3owjKSrY4HyedbVlUI0cum2h6bg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAf2C5r+0N8gciE7bMHTc/dTTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTcyYWE5ZmUtZGM5Ni00ZjU0LTlmMGItNGMxOTY5OWU1ZjU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNGRiOWVi\nMC00M2Q1LTQwM2ItYjNkYS1lZmVjMzRjYzUyNTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATBdpbi6Ojf42A4DltyaJkOCYt7do06pBwsnlLmpXYDfPEwTzJ4kZQK\nn84qBheMgbl/gb4xq3eTUwU7XJ81rRl8o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT8OymW\nG93gdDIigSFI/fZMlme5mTAKBggqhkjOPQQDAgNHADBEAiAUaniA41ehv4NsAeKZ\nyVG1rm3KkrTQphqFYXkxILJnKQIgBKNtN8d/ccJSu1styvTwEDYjekh4pYOm8QD9\n810IMi0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1544", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1544` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAYSWBU7EPFvX2yBKpDq4VlJMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlZmY2NWY4LTVkNjEtNGRiOS1iMTUzLTk5OGMxMWI2NDQ1MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTExMjk4Y2QtOTM3\nMS00OGM4LWJhMTktZjk0NzYxM2U5MmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEENl8e10Au/7rX4yguGGqnwuEemTbwvMaRU/ATcqU6LAbgU4u6HHVa3JBkrNi\nntYj7M2VvA3gaR8ATKT40KqVUaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU26dxnEt1wcXutTyplln3224M824wHwYDVR0j\nBBgwFoAUdQfwiBr041/LCloRnWbfQ8FnY4MwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAZYTt5noECzu5IzZk2HsE2U0wgsRGLe\nwPQ08zjfb6x5AiEAxhR14HTRbKQ2wBc3fmStQUi0WOcIrbVEEFCFptJ7o9g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVovo1cdX/a80bQV5OzcjD0qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWZmNjVmOC01ZDYxLTRkYjktYjE1My05OThjMTFiNjQ0NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATofsXzmvhgHBtthU0J2aw1xdDicRQUx2R2Ncdnw6RhwtwU\nt4dYvSNGx0jSlTs1EjIWnmbLji2ka2SYRHo42bCVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdQfwiBr041/LCloRnWbfQ8Fn\nY4MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHNpdKH5rNNBYQm4rTuou4JXqJ2i1Lt7Js7Nqh/5JrMsCIQDJgs1cmmXB\nuB8M7f0OVXfXYjgHtrJH6tgh+VKv9JEDEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAV0L/v+w0yiRyElulVZl2gFiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTExMjk4Y2QtOTM3MS00OGM4LWJhMTktZjk0NzYxM2U5MmE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMTYxMmMw\nZi1jYmVjLTRiM2UtYTAyNi1kMmQyMjNjMDQ3N2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQs6PZNimlj1uwYY5Y9yZjLFNvL9vnkkPG9JPdY3WL3t9SIHR/P1jh/\nzF3tYCk45urDE4fQkjKd/cj0itgyqspPo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTbp3Gc\nS3XBxe61PKmWWffbbgzzbjAKBggqhkjOPQQDAgNIADBFAiBmnFbki7XNMYGptdwy\n3SSYZjsaaPd6kMyndfa1yOAjxQIhAOFtkAPj1NyI/xokJLvqkHplZxjycfUnL1R2\n+GQ2KWeW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1545", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1545` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZHBZ+HMNomFb1iqMOAp6a7zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmOTljYjc0LTdkNjQtNGU0NC1iMGMyLTlhNmZhMzAzNmZlNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFlNDRhYjEtMWJh\nOS00NmM0LThiYzYtZDlkMjI4MjM5YWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd3EOr/Qn6CRbO4+uuiYENN8JzS+1RsLawh4FX+cr5Xfzu8Vg6u5JQIMFRvBn\ngfsJU8yeKTJgUAf6J78M6+D4nKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFS8Derevif99vJ+bCTUMD6US8PIwHwYDVR0j\nBBgwFoAUqgxGk/9JKUikZWV/wqqudO9Od80wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGtTYNh4CgFsLnRmBpu01YIV1gE2g685\n6IUtB5IfFZxzAiA+O5zY47qsDvLGyCnIeZL5cxfHPHRo9Evn1A4yIau/zg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASRPv6/6NM6U9VGkjdouhZVPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjk5Y2I3NC03ZDY0LTRlNDQtYjBjMi05YTZmYTMwMzZmZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2JVziBEZjIrYUn3BRgnNlFW/Z50HgeMw2tN1kO1h2XlUR\nw12hKrqm1MqYn4h2x8ULnEzzY3DKyxALMO0t/treo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqgxGk/9JKUikZWV/wqqudO9O\nd80wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALpGV7Ao+kiOu1iCSK5MJxwsTjC4Is+k1uOTr9Yo/v7GAiEAoec8vCr0\npi9HNv+7jMyidArrpHleabdDEFUWeW2geic=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISATun98HMOcSrIdHmLl7pZouOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFlNDRhYjEtMWJhOS00NmM0LThiYzYtZDlkMjI4MjM5YWJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxODE1ODBk\nZi03MTVhLTRkYWEtOTlhNi1lMzA0ZjdhYjUxM2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATyaJ2x6N6SAxAGWgJ/PrLBnkRKgZR20GaBhuU0/OeVNpvGfeUr2Fud\n20DpD7ndDTIEMtXTxSnm6tx7LRIguerwo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVLwN6\nt6+J/328n5sJNQwPpRLw8jAKBggqhkjOPQQDAgNIADBFAiBOaK1oO6tR3kOzmq2D\njNUzYcfQ1KQD9ZitimMWYyEKMwIhALXjlxEaDWEwyq0wZFYCyUjsqihGaaLmWDh3\nhPW7hONe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1546", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1546` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARk60y/tD8nw34rFM5d8nfkNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzNjdmNzg0LTE4YzktNGFiOS1iMDM3LTEyYWEyYTE5YzA2NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY3MmEwNGEtZTZk\nOS00ZmE2LWFiZjYtOTY3MzVlYmNlNjM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWuqKroYfzPsWgb430YBr4nB/vk3ufndswjTwlTiUp7uRLUAx1wXv9BL3q1OD\nXxGlMs124uOvv3WzdUIX1x3CiaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAn9Cbxc2BgN1/oCZFea1dKMPD2AMB8GA1UdIwQY\nMBaAFBMqJJq3OYEzZ3PSuFEbDrek/HLkMAoGCCqGSM49BAMCA0gAMEUCIEfXDOy5\njzLZK4rJJGng4Zfvk260eb/JEDLeM0dCi7xTAiEA27Cn0A0uLe+jUe8ztWSjjx0y\nkTqLt/B2Io7LtrgOFu0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAewqKEXsfHWsoztfejOGmHQ1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzY3Zjc4NC0xOGM5LTRhYjktYjAzNy0xMmFhMmExOWMwNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH4plSDnXqAo4ESndJBfvzvOexfxnHrBOB0g8QE45WU0W+\ni8CEAd09oTPswhKcgeu+L4PpR737bVq33UZC6FITo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEyokmrc5gTNnc9K4URsOt6T8\ncuQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIo84Wl5Myca4eEdPo4QRavwpJckNIKCxNVIMXhmYN1EAiAj0D0fgp00\nZBFozVgnTbx9hy4qmtfunG80br4nFx5DIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAY4Ns6qm8lT5eMR14P/+NibVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY3MmEwNGEtZTZkOS00ZmE2LWFiZjYtOTY3MzVlYmNlNjM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYjFkZDE2\nZS03ZWY3LTQ1YzgtODhlZC1jZDlhOWZkMTRkYWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQlIzYR2RyF8HSQ0OgkSgkam+vJyveOVVwZgbuJxz4B43c8LSkdOy3B\nBd+rbLukN28KSY3vx6sloSDhAYKB3PLAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJ/Qm8\nXNgYDdf6AmRXmtXSjDw9gDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQCQZkfnG44KQoHmncREGeliPvxpAQEhm1/6KYdwXUwZZAIgQxHiDJ/QNchm\nir4NaEM9K1h3rZZC5pdB9/pOQY8A1iQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1547", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1547` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAU7aF0n6XWSFbZ0wVHwJ6oKxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5NzljYzFlLTk2OTktNDQ0NC04ZjQwLTZiNzhhOTQ0NDNlNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEzZTQzMjQtNTVh\nNC00OGZmLWE1OWQtYTE0NjVhM2Q3MDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZo0Jeuxamra07fxgxRylHZowFMoSPst71sh3fhg8dmIChLMfpktEEEDZ0LIH\n1B2+7mbKFYEBD1+NSOzYmPaG+6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLxX5euVAX1dljBrLnwH7LH3+S4gMB8GA1UdIwQY\nMBaAFCUBN0UuuhWkREXa6YIk8ZLI8IT0MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBQrL9xY1IWDGSv02BdHLKoHALgHOrM/BW7\ngzDqAbtf5wIgVSVsoWAXkyulKtJRdc2So40OS885U1P90KoKTUffpLE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX7CnHN+s7DUNeP/hULAA/imMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTc5Y2MxZS05Njk5LTQ0NDQtOGY0MC02Yjc4YTk0NDQzZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPHZ2HnQNiCKwCKgH9U6pKz6Kb9Z2z68smuLj28Kvf5wG9\nhn7U1je+f/EBTwG1rDGdODaBqlOYO2aEtG+rKFE2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJQE3RS66FaRERdrpgiTxksjw\nhPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP6tLYL5xcPV4kKdsEJI+eSCLzTupwJkbRxuPGu+UVygCIAtB0R5fqCKW\nCfbBiFqS53AGEywWB+8KNURV9G6bL6Xj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAYEW8BEBTN0AaVuFVWfSLITVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEzZTQzMjQtNTVhNC00OGZmLWE1OWQtYTE0NjVhM2Q3MDhhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ODhjMGE5\nYS00ZGMxLTQ2ZTItYWU5ZS01ZTMzMTExNWIyNWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASKhfzuoe+8IlQFzs7XCc9jmJxEAlh1/uJohFlpId9Z4qZeTef5vhLU\nlMpQV35hSMQc7s6Koy7OCOFhHDySWOTko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8V+Xr\nlQF9XZYway58B+yx9/kuIDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQC6qKJ181iKOmkv9D3awsFDAoxdLSI0bCy/iw3UsyYxEQIhAOu+DdheVPAG\nM3knDD9opbcH7X4gAFn9AiyIwMUrlC5A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1548", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1548` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQ+hRN/y4JU8fwdJKzf72VP6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNTkyYjhkLTMwMGUtNGIyMi1iNGY3LTE3ZTVmNjY2NGE4MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M4ZTVhOTQtYjNl\nMS00MDY0LWJjOGEtNGVmMjE4ZDhlNTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwdR+3hFVVhPkcWxfRGGMt4y0SK2iJeQBUw5/iJ80t/YAYPl9agnALVuZ+lCP\nZ1Qf24v/SSNNUG417kdmz9Qz16N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFF4nSQDfHI8sOblYYdPmpVzRmpgRMB8GA1UdIwQY\nMBaAFFoPC4RMuJ9GJFqVaG9xqI5wFlbbMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAz0PyBWU3jfuxQvEJGWOeR+rfk/Ed/Iti\nU6MTtj1tWdMCIFKmC57Bl0BEHBTddl2TXc37pC7JkwSyv4Ub7PSph5+m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARTIqDW4K+xVcHq6Ug4/EAaZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzU5MmI4ZC0zMDBlLTRiMjItYjRmNy0xN2U1ZjY2NjRhODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASx850AsdymIQg3X02ritcwZQhWVu/W93Gr5Y3wuDIhbLsp\nWWzKwnV/EOSaQ7vMEjaQgBYuVbOTpkrOnipdzkCro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWg8LhEy4n0YkWpVob3GojnAW\nVtswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAISusVwxLz2w4SWhBFOzu8oEywiKezBNUJTGdN0IfBlSAiEA1i2dghd+\nJ82m/ixmrWzBJyzEDI450OFivnw2934CZrQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAU7k/JMIaxYvdnOKo8dFeptBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M4ZTVhOTQtYjNlMS00MDY0LWJjOGEtNGVmMjE4ZDhlNTk2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MzQ1MzRk\nYy01MzU3LTRlODctYTZkZC00N2I3NDZkM2FlMTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR9JF6Dn7kB7K208nifBrcJMDqvlL1YOWy8mAUM8bV5hvJNFS9fuLuE\nZrw/CRCTyqQY7HLQDgRmUwvxonQ+8P2Jo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBReJ0kA\n3xyPLDm5WGHT5qVc0ZqYETAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIAvO1MyAvgNuvl2K+YuYfbgQPECf8bWzoLSvN7Ki4rJBAiBvUZjk69onNyh5\njB5UCc4ZH+qIcJoQRT/dIfaGPgUjWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1549", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1549` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASypVLKqGsV/39SdKEaL8aPnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2ODUwNGY1LTk0YWEtNGJjYi1hZGFjLTcxYzY1OTljMjNlYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI0ZDU4NzEtZTRk\nNi00NDA0LTk5MWQtMGY5NDZkODNmNGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfDDAeQTVz3YqlkR+QXRppjKMg624SlV9bXLFKGMzrP5nTrbMsqsSdCIg83sX\nmKROhtsC+6c0AtEm/zhoOdcrhqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQpELpopL10/VZ6bxYa7fSBvLHx2DAfBgNVHSME\nGDAWgBTHUyFiUNaUCZ6aG3/fAKumBnhudTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBA7P7J6nnozquICh1a95PsTyX9Y+aRZ\nOqezxsamJ6cYAiEAt+h9KuGHB7XxSV/TL5SUmGGu/7tFdibN04LLX1bPfzM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYjF4gA9MO8+OgBcJlN2cx8zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjg1MDRmNS05NGFhLTRiY2ItYWRhYy03MWM2NTk5YzIzZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR72tRNUC3dn1wIysEqlDAYpgkzjkv7xUnUllfmEHJ1wfuM\ncFbEaLNJVMcZRMrjfkC0hR3q6rheaE0ARBWtlQ+Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx1MhYlDWlAmemht/3wCrpgZ4\nbnUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOlVcb0JppY/ssXbHM8irHF8DxY13QN8O8zPyJuLTzsUAiEAjRQYrYVj\nieBb8nP6kXV0YnmkWuONvfa4wNv35e1kDUw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAXlxtit33eEuXvzEynpMGROKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI0ZDU4NzEtZTRkNi00NDA0LTk5MWQtMGY5NDZkODNmNGViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNTc1YjYz\nOC1iMzc3LTQ5ZDgtOTFkNS0xN2RhMDkzZjUxMzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQtbkJzpz9RStHpq5pKTchM4248q0wO5ljJP4pcICYYpb3ALpiF3Qlp\nl6jMbpcZzE416+1CpaNB/lX2lOL1kMFco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQpELpo\npL10/VZ6bxYa7fSBvLHx2DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQCqiXKT2BUdE4pV4MB3V5mjZzLygG+NW2rRMDRNMXbsawIgXztIS6zavkv4\nA/IzQYm65egm0gIhC2n4FqpWkaR3Duk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1550", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1550` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAbSZh9U3+XqqURfB9FwTIxd+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNmNhOGJiLWI5YjItNGM4OS1iOTc3LTU0OGVmYTRlZGIwMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODExZDZhNzItNGM5\nNy00MzBjLWI1MTUtYzQxZDk4ODljNWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhPIH6N8O8xtOh+QsB6bVoP5Ib7eCYrRYqi7IDXkxH0K18iJkw9LavNkhz/m8\nrP/Y/wTRviSq65q0mZXogFoovKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcwWOMbeolefCYi+eFhej7DFR6SYwHwYDVR0j\nBBgwFoAUGGsfQJLcEcNUqpRc3JnyZO7mcqAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEArVqkEs1l4Nvd\n8/kFCVfuemQnWXqB4VNav4E9WiSvFjwCIQD7kv3BqOVecmuuyk9tAGQNvzOOBwAv\nMYstSjizWd76Ow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcpDYmJytynPBydeI50Kc4F3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTZjYThiYi1iOWIyLTRjODktYjk3Ny01NDhlZmE0ZWRiMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcasY0Z1UJBKyiB42lVEGNNi3l43A7xhcpPMdS1OYGkhMb\noYMGTucKW3ugLOxZx3WgNxotTbRvC9tVdAyAJYJjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGGsfQJLcEcNUqpRc3JnyZO7m\ncqAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbyIGkoAhoBsBI0uGvvUCy90AU4hgoBBn2Jy8ao9dGJMCICtDKBZ5uMdt\nqxpwTLqA71bnPO+BNY/NwocHLKw3VXtb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAWYmMQljN7kyEQBYDs8kZ5ktMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODExZDZhNzItNGM5Ny00MzBjLWI1MTUtYzQxZDk4ODljNWFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyOWVlMmVj\nZi1lODc5LTRlMjYtYjJjNy04N2EwZjI0YzI0MDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARPDA7JDSYWQc9jadU1/h8rdZLgxGy3r0KOWJPKek6RE6M7n6J948nj\naYPiGvyVPkXPiB5eUOsnV+PDC7u2Qzzzo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzBY4x\nt6iV58JiL54WF6PsMVHpJjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQD7dnr1xGFio+9iArRpUJXsQktskWIDs/5zjbqeI1XIgwIgN9sUCt+M6QxQ\nilQFM/rmklPX+/wHCl2tPYQndLYjPKQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1551", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1551` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATNA9MQoMClpJ//pXsYAobxFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlYjNiNzk5LTU3YjEtNGQ2ZS1iZTNlLTFmMmZjYWI5ZWU5ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2VkMzI1MzgtMjQ3\nMi00ZDM3LTgxOGMtY2QxOGIwNTY0YjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElz/A7PaDIDUO1HIw4eAquthG3qu4rW+uDzY43xpe/Wm9nLPT1+rCM9FIKUbu\nz5KXm4a6eoizP7azmAeA9gUS7KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlJ/ComrgMwXLfmGdB8OhnT30npEwHwYDVR0j\nBBgwFoAU4tWtD13xpQibwuGsqrubi0gXuZ8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAtSTHN+UVPtviN\n/vPIFWVj6M2hlIWAqfg6M6Fh8SWi8gIhAOLU9bi/QVtJC2DL7k92Q436gd3TD9oQ\nA+9b8wKeT9cj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR3POXpLqDBOrUaN63uJ+ksdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWIzYjc5OS01N2IxLTRkNmUtYmUzZS0xZjJmY2FiOWVlOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS49aDrIaDz+Q/4QGKmL0X/6ilkWkeeCBJBN7NNQYLZgPbZ\n/5tP06Ansl2aqSata3ppbvVzB7JhjDqR4kWJ5t05o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4tWtD13xpQibwuGsqrubi0gX\nuZ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZwDCeV/Y2o7/26voVjgArjHdZX+oPXBGQtQkfM5phZ4CIQDfdZdlDyrp\nBM1ltjx09qnhSD9iTjHMgRcSqTvIg9D2Lw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAfy5+Fl+SixaGJkdHkzjtuuAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2VkMzI1MzgtMjQ3Mi00ZDM3LTgxOGMtY2QxOGIwNTY0YjY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMjAzZjZj\nNS02YWRjLTQ1YjYtYjM3ZS0wOTI1MTY0MzI5ZjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASRZL9hy5zuyWkL0UWVwjPVccncRdAm314+b9Fk3VB15U4J/FCEDXFq\nzeuD5kqfjds/hrVHSWnZe7YRfXrdXFtJo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSUn8Ki\nauAzBct+YZ0Hw6GdPfSekTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIDujL5PeA20c1Q+8sVXD8gEetsa6zgIYMTVbVtgJuU7RAiEAh05noOmwrt/N\nML1qYRtoGxun3AljNhzPy9RkVKnbYhY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1552", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1552` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAe6OG806Tq3562zSPbEt3M69MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3N2RjMDg3LTY0ZmEtNGQ4Yy04NDM0LWE1MjBlMTRjOWEyNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjEzODE1NTAtMWE1\nNS00NThkLTg4NjYtYTgxOGExYWFmMDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEywG3SYODWyQ2vji8ucQB2Lr2wbXyvz6R68QTEpTHLLAAxmKgUvCfRk/9hH6E\nQchoSTebF1iyg0mNjhkK14DW6qOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvbnUkmRd1R8vnR1KTUACC7Vk/owwHwYDVR0j\nBBgwFoAUdBULGO9f7l0JhWUSYVmsr7U/zLMwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA+ByyWdibZ8IuQPrWUS6c\nBnwPwzOH0lnVFbnkfeUjDIECIALZDpbApZua0lY+Bze3bi4gZ4NrbBGiP53wB0hU\n9N7I\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXm1r2rCh3J7s2hpV8EfOhjpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzdkYzA4Ny02NGZhLTRkOGMtODQzNC1hNTIwZTE0YzlhMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+tvR670jPlGDNxnFhHQDETuDcsvl1+qk50M8s/zykzk+W\nL8IhrWpKp1jvbyg8oZKugBQLuR1I4HeXkEwupZszo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdBULGO9f7l0JhWUSYVmsr7U/\nzLMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO/V7YtLWlO0gYcJjXW3fvvgIDlrqOxEJX/IutHDA33rAiAsNUJ3HhHN\nYjM64qyrwk395uUQgE6TKg3Yc7ThoEES+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAUwGZyL0WBmShrxvqrmZ8sDSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjEzODE1NTAtMWE1NS00NThkLTg4NjYtYTgxOGExYWFmMDcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNWViOGRl\nNy0yM2Y4LTQ0YTMtODhkMC1lZDE5MGE3OWJiZDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR5ZjVG2SzBlDbh8XWVXp2S6x2IZwzcFcschzuNPKUh6J4ycHWA+KRH\nA2umaLfjHDITj5/nskQZ4lix4zh+QjLro2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9udSS\nZF3VHy+dHUpNQAILtWT+jDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCMIicBI8VlqYaH80Hi+XbBBbl1iabPjfhhSuhQk9zWHwIhAK999MK3X1/y\nwshaknXMNcW0m2dSHrN6m9KmzPxhn4hW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1553", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1553` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAdNY84DGzJlsIpY2ZavweYsaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkYmMwYTFjLTE2NTktNGUxYS04ZDQwLWY2ZDc5ZjgyM2RmMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY0MGFmZTAtZTk1\nYy00YzAzLTgyMDgtYTk5NWU2OTI2MThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeZJNateyqtAP46lMD6IetwrIR3CijTf9dGSsvUeC9TGpwTMYmAkbZvhAJuKw\nVCNaKjRD0fA8TcbUXXwhp16fTKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOl63rtidYhLF4XlnZpERVE0HgcQwHwYDVR0j\nBBgwFoAU5La4ExRUfOKvv77Upvt9nGiOH0cwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA7KZu\n8e/PNhQShc1ein4upBiqxlc24lIkN63VB1EMiukCICM/6VNEm+bizAUwyWkJ4Kuo\n7PDtiw3GrNNYIcU2A+0s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbcmTztpZ5+yl9gTFYbqkRdUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZGJjMGExYy0xNjU5LTRlMWEtOGQ0MC1mNmQ3OWY4MjNkZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSDAfMpYy5bdhujTnzLtba2+imaNyo0hBsvrBqwCnlDn7i\nhSqs2YHrqQ6UJ1KDj/VwxNTQYHrba0jpEe1DG8qPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5La4ExRUfOKvv77Upvt9nGiO\nH0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgT1G3gWd0TKWLMf2Rw1tq2FdPgT0Gt8fqIwEtqxMO3+sCIQCzM5ue/5sn\n4AM2OHBhwxc5KafSBH3hHEY6GgeEmVcnZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAcAv9TJdvZmtt1+VDNd3tA94MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY0MGFmZTAtZTk1Yy00YzAzLTgyMDgtYTk5NWU2OTI2MThlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZTA4YzQx\nOC0zNmM0LTQ0Y2UtODY4OS01MGM2ODc2ZjVlMzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARVVo8BddnPmozi2H/9axPVutQRl/Jcw0AhV8mTEtTqHnq+BoBr7jXX\naL7n4OemSZVOp3OL6C1SCp1IeW/n65ITo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ6Xreu\n2J1iEsXheWdmkRFUTQeBxDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDu2mpfAnBO4eOxwrSuB8UOO3qlt23zbeS3pP+2OmmHaQIhAMZhZldLCPDw\nYNlSzU+IKnev/gkhjRWW6xspz3/B5ZMU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1554", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1554` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAec8lj/q0rPd0GxKNc2cjMmSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNmVkZmQ2LTA4ZjMtNDQ2My1hYTMzLWNjNDQwNWUzNmJlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNkOGIyYmYtYjgy\nNi00Yzc5LTgwMGEtYTkxMDViNjAwMTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtotYbp+2Bv/yf3b80th3J7BNygZiYlrf4rJELiLZ455Wfth7xNddaAQuG4qW\nRdhXffI4QtSpi/PtiAcUIYzrCKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU76n9x4aB7/lnTJ4bku8gpKDJWKkwHwYDVR0j\nBBgwFoAU4NDA18ckMNIl/56VUjhOsFP5a50wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAswlO\niKLCQ9g/QdQcSuIh5XO0ns444eScQRW1eHne7wsCIE18pONQGIMTD+pcpkmqUbvR\n0AidlslPmaFo9XstPv51\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ945JvHF13L+4dfdvl9qxRoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTZlZGZkNi0wOGYzLTQ0NjMtYWEzMy1jYzQ0MDVlMzZiZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqFnuJHAWwAl1L1V+IJHdQm8hd9/f3O1ZTqq21hRcFLSYt\nD6rYXVZSqYgak9EDjjAQssFYA+wm2Y1dqn4IG2J8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4NDA18ckMNIl/56VUjhOsFP5\na50wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANyXuPmU9GAKjfAtrGOaR8BvgUjAV1MwgYS0umBGCOuYAiEAm2Pp/yLa\nPtYm7nSDoZ3FIFa9FuhluKLTz/WyeUSSctw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAXl8MRnCtOBvZ+C2sDn644kJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNkOGIyYmYtYjgyNi00Yzc5LTgwMGEtYTkxMDViNjAwMTcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYjQ4NDI4\nMC00MmQ5LTRiNGQtODE5Yy0wMjU1MjA3ODU1NDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASIIhaUf6yljdtx6/TqEgn77ELTtVUbsRw8oCwfLPTT/ypSkCj+ZhR3\nIejkeXNpaJHWt/4o01/t8EnwIyGLHfo7o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvqf3H\nhoHv+WdMnhuS7yCkoMlYqTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIGE8JA1f6w8IOkA758tV3C4fkbjKd/GexWYrc23a2kkvAiEA2Ge30woUBlRk\n2jHPuOB2HZK7EBp4epfBLo+nSix94Yc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1555", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1555` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfRaX0/xT13/LpNUSqGKbDLAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiOTNmODcwLTYyOTQtNGZlOC1hNGJhLWIwZTBkMWJkYmY2NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg0MDY5ZGMtMjJm\nOC00NDM1LTgyZTItODNjODk3MWQxYmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmbuvUrc8WzgRbzSnbPUbfXZmXg23dVLuOuQ6RqznpkE17Y0Vi1ZilhOvwev5\nlUPSvvTq7lBm5EkGd0fv0ZQPZaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMvDMHvvj48x5exJ/wNPG6DEbzooMB8GA1UdIwQY\nMBaAFDQrdlSWMoGFvAsTqhMzIHQVBiwsMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA5y55yddFmxrEWI5wE2Vr6dA0C54iAU1N\nkv1GJZNjObgCIGSjTNeKb7XmJoJOjGA+pSYwwpUgIJfN+3bGPZ3jyAdQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVS9sFdb4aMUtZ/ykoOiEQ38MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjkzZjg3MC02Mjk0LTRmZTgtYTRiYS1iMGUwZDFiZGJmNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGWHt+PMIUD3IB/FWi7Da2KprV1H0Pg159+EthHLcCjmaL\nqyE9acBQlwn41Y0MKeJ+5InHvX7XRmLzBOiDGoXQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNCt2VJYygYW8CxOqEzMgdBUG\nLCwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaQtStpz/tyYO5og0PbiSTP2nl4iXJk3D0sk8bXbmIAsCIEchMQ561wZW\nj/uVxSaGXczg/2rVB+CfSco4horgUXwE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAQVXM/niVlWIPya9CtM9exX3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg0MDY5ZGMtMjJmOC00NDM1LTgyZTItODNjODk3MWQxYmY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwOThiYWYz\nZS1hOWZmLTQwYTMtYTMxMS03NGQwODc4NGE2MTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQYR6Ka7uBNrJY5990gTeTHGTL8SRIB55fjvCN4fy4KZ1LeNtw48mX6\noTd4Whc5SWtVV2dJ9gKtu9tn5bY7BIdjo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTLwzB7\n74+PMeXsSf8DTxugxG86KDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIHaB2cfIu3dBDUhvBPc4JhAz1r5syHmNndPdS/+HlIEpAiEAlu4zGSWxdjqc\n9+OOhqnTzrBZJimkLN8YqIyyzoLoDwk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1556", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1556` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAaAmWaZZuG25GCqd+O/YMdqvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3YjhlYjIwLWJkMjAtNGVjYy05YWM5LTBmODNlNDQ1YjYwYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZhMjZlNDMtYTZj\nZi00MWUxLWEwNzUtYTE2YTM3N2YwY2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw+rwSp5MgCinBXuVtamMJITFbg0xamk7mmxYyzGWQgNT5iOOrg2YrPhicfcV\nmXDPYHofDBcq4fYgzLEbzGFw3aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHfNH1j+8UZV2/v8UjndW/FuzqJgwHwYDVR0j\nBBgwFoAUWBDDG8WgxFyOqvQt66CSBw3nj1AwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAN3cUgCuDR2R\nRs8ftcLqSwFy+CQWiEcH7p3b0Z/X3b2+AiEAn+dK6w4+vulukOr10uTOyq4SFM7a\nRcvN2ITMeF6rLm4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASBCw/YpV5Z9DDfPiqrdtM5lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2I4ZWIyMC1iZDIwLTRlY2MtOWFjOS0wZjgzZTQ0NWI2MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATN/GJpN5FCRkrmEGiiILJasg2XbTAqAGK11xH8uYyJvjeH\n3XPGEbkxI98fmbZ6/PiK9koFISp4/loZeQg4uqsXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWBDDG8WgxFyOqvQt66CSBw3n\nj1AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIjlyOYXDaNHLppM4E1e3zZ6UTjK8a+lY32l0Nn1HM5KAiBOG6iDHK49\n8eG1SY534F4W9r1xpX4yDblj3caP5O5OXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAYpkZNHO+rg8msjoPL4coQeCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZhMjZlNDMtYTZjZi00MWUxLWEwNzUtYTE2YTM3N2YwY2FiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MDJlNmZm\nZi03ZTY1LTQxMmYtYjYxNy02ODM5MjkyNmYxNTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQym+6shWMEr98I+kulp4bYyD9dj9jtgkJuelw16MriOdcAmP+POmrz\nxT7ZZuyLO/d7xCn9uEXRCie9LFrlGS4po2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQd80fW\nP7xRlXb+/xSOd1b8W7OomDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIB6dAIQ0dyjZNcZEiSyF0a0iq/qtqfrsJlimpVuzYw+3AiAIXtaXldvnk/WP\n4v0AtDIDyzP0xmkCBZze6Z5vC9GkYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1557", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1557` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAaSwsTYZpLvd8wo9AY6HsaGiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ZjYxZWEwLWI3ZDctNDE4MC04ZDRlLWRhZmQ3NTQ1ZDAwODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE4ZDA4Y2YtM2U2\nOC00MDI1LTg2MjItZTQ2NWQ2YTY5NjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtsWFCN/RwTByRowfy6N1F/SVqSxUC9nIRZnIm+JaPnfxBymZzDXxQT8b3q8O\nSRdfVAyXCdbaBxCdNexfQkXK2KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBeJRjVli9+pm73fpR0CskqI7WUEwHwYDVR0j\nBBgwFoAUEk5ZqPeIvDSbjQsJvDzVBJg9ho8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKzoioC54Ktbn\nt/wyOa45S8VcPA7Z2NZwvaAwaFQzfTcCIQCnQ/2rpBCRP37Wm3z67epIKjHPVPZe\nSpXYby1RJ6Oxig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUSJFNGYaLb3G1uWEjjOufYvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2Y2MWVhMC1iN2Q3LTQxODAtOGQ0ZS1kYWZkNzU0NWQwMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIL5laPV28ZiQ7MyQl7AC4bMtTThe5465jrr9W8pOWUR2S\nLij3fjo8nagSeboktTmeBnWshAWo0+P1nUfkG0OLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEk5ZqPeIvDSbjQsJvDzVBJg9\nho8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIge4Pxy++Ty6d5TL2UTYIjnoN4lVH4a1WyIuAcg0V369ACIQCmSiowPNSq\n9P/y77XyqEU+OUlOaOOTHu8S5WYBWUxcZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAe3zBzWJp5g6uejaAMrcZz+PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE4ZDA4Y2YtM2U2OC00MDI1LTg2MjItZTQ2NWQ2YTY5NjE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NmQ5YjE5\nYi1mZTMzLTRkNWItYTZhNS0zNDUzOGY5ZjMyZjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASFNKSS2yX1te8JqRDUiycnPy6ETD5G+ly7aEHRk984JLdC+J2hK2tB\noh/JcEkoCNCBeIzbxWxiu0hABTdck/uko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQF4lGN\nWWL36mbvd+lHQKySojtZQTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIEYsQ5BM4ItwJ6sg2cLyPa78ExQQW4x3wMZDSQ9htuXEAiEAtka6v4uDSJcs\n69yGnciYT2+gmsRl8bLeGTkJIfGIKic=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1558", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1558` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAUdrthaDtROnDS1RVSigqEmxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZTMwYzIxLTYzODMtNGI1My1hODgwLThmMTIyMjU0ZTM0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTViNTBkNjItNDJh\nMi00NTMzLWI4NTktMmNmMDJmNDk2NTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/SRJFgyvAPOCH3pjwit+GkCH6uhc4iHwHoqmmMXb10R7TC7oekBmnVri69XK\nVVigpfFD5n294P05si4JZGdCfqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3JR5VDGA6PEsDcv4hzLaYhI50KowHwYDVR0j\nBBgwFoAUxWYzSgFZt7m8VlDoUNiyLkZQeAIwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD+6iooltxE\nGAD4AHknvzst0IufhJhJdVcHlt0xk36iKgIhAPEsRWoTEdnqAHyflqwLCx+Ejzts\nP//qd1SxRIqEPTS1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfR0Dfcru/52n+XqpJWOMk9HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmUzMGMyMS02MzgzLTRiNTMtYTg4MC04ZjEyMjI1NGUzNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2NWGJTv+thZUjLZNVa2XJ6eMDDR8rZx6Qja8KSCalDwgn\naKMRNk9KgtKhdu8UjYmmW/Q/urP90W3VH4FMZk0Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxWYzSgFZt7m8VlDoUNiyLkZQ\neAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeC8s3uC56Ir8vndQUXWd0gCgr12cgGiYs+LE5ZSlT4oCIDsloLqa9Kxh\nuTpJ/lxywDbc5Z2zBbc3wATaI4bwbPIG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAWCbx7Sr8VSu4N52qAgK+JSAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTViNTBkNjItNDJhMi00NTMzLWI4NTktMmNmMDJmNDk2NTUwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZDQzNmNk\nZi04YWMwLTQ0ZGUtYjc0OS0zODExN2U2ZTE0ZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASSK+AigQUvNpjr/1QTcNQBinySr4TcpKclDGx+vsSXrhmzzQrFmtzN\nOTqALJXyFI17TFzFLZfolbDv8fnD5yQNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTclHlU\nMYDo8SwNy/iHMtpiEjnQqjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIBmG2u62u3SHW457Cqk7DC5phLxnD5Lqr7P8qW8IKBJkAiB+2w4L99hIhPqV\n9gOgqKRN36bHjaW+gRpNRNrAtD0r1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1559", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1559` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWq0S1LpScgrv0YGXAMrqrjVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1MDI0NGJlLThkNmItNDExOC1iYzlhLTA0YzUwY2M4N2I4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2JhOGRiN2ItNTE0\nYS00Y2E3LWE1MTgtZTQ0YzdiM2NhNTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6d9b98SqyZSiDgIAYYym0+CohXazf13m5DLJy22rZ+PcspnnIUkkYUf3Rs44\nrUK0x3esDt5RmDy+E7HIAVAfYaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIeeiiJz3bX7Jkj1RY7lAfaYxLKEwHwYDVR0j\nBBgwFoAUvwRbVXBNBvDz0ZUhulpARDMqd30wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIC9arTbTqW7RBEsLgxIyDshcMJFQMg8Jfk11VWhCyqBYAiBhicepoK7WUppE\nidYt4Rfv3xti4yFNZ4Uwhp0G3q4Nvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUdnJ1GTdQU/rKCD9/rH3wvaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTAyNDRiZS04ZDZiLTQxMTgtYmM5YS0wNGM1MGNjODdiODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2KVSsSt84Y7KrSuyA4GnImRPyS94e/2Dm0oV7kq5lsq1r\nP/3/aShUl6SJbiHfJFhHwEUqA3i3ae1ywwJ4b6Alo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvwRbVXBNBvDz0ZUhulpARDMq\nd30wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUwcRu8bb86FxdVi9vYbp3F3zhnN8TgbgXMsEuosHyeYCIDslc2bQbqr3\nV/gI9+VejcsdiRXB5/3Nssm5MB7MMcGU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAdUJgtuiLc4vXjsFF7hKtnwvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2JhOGRiN2ItNTE0YS00Y2E3LWE1MTgtZTQ0YzdiM2NhNTNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYzFhZmEw\nOC1lY2I5LTQ3ZDgtYjJkNC1iYzRmNWE0NGNhZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARZNIYJuu5rMFwVUbVeaxi6zKCbHxXHrxabMeuUGZ9GRYuMlSXdrpG2\n6FiBP9JvgjDt+GIz+AR7WGWjB8HfTNZso2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQh56KI\nnPdtfsmSPVFjuUB9pjEsoTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQCl174NziB3TRe5W6A/vtj8HsNNq5h+lTuRoeU4cRBs0gIgd1SPIc188Mxr\nALjzbXP61/huE9AX47R+ggDuzw/5u1A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1560", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1560` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASemH1B+wyTtVOkIL/HVS1/eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1OTNlMzY4LWFjYjMtNGIxYS04ZDY3LTJhZTc0YmI3YmEzZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk1NGRhOTEtYWYw\nOC00NGEyLWEwNTItYzg2M2FkMGVhMTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKp+avvGNXvVgGmCEKOkEqflcbeN2Ki0U4DfLvbNHJYLL8GPVxI9k8OkXtkHR\nYJMMYKwo6F3jjF+f+ObjrR9T+6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdK5MIiw5MCQD3VAqgsKq9X1g+GowHwYDVR0j\nBBgwFoAUBHoO5B1XhGsI5vno/s91hOcBNaUwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBHLTKAefUznIlWrScLt6duTv2qn5EcHACI+xDUHvtHcAiAPhH7Of3u44JIK\n6mUK+9Lh//m61pM5C4NnqJvSx9+CZw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcwx1o6P3FSMnZ6TCp0JjauCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTkzZTM2OC1hY2IzLTRiMWEtOGQ2Ny0yYWU3NGJiN2JhM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQTqZ5GQ/OfMvGZ1GO9nVImTBDRFQCqUbf9FMAL1toi30W\nsJnDMlktoeleN3AsIBwax6vC0oac4ts0MLUOY24Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBHoO5B1XhGsI5vno/s91hOcB\nNaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNO26HU6vqV56jGW3iSBrJajkOXTB4PTHyiRI6UTrSkgCIQDaNjzSCovN\n64QKAUpHCBhnr+zYU0L+JH2Q2diWfiOYNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAdm3lA6Cow/Vvhmb4vpaTS2lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk1NGRhOTEtYWYwOC00NGEyLWEwNTItYzg2M2FkMGVhMTA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYjFmNDA2\nYi0yOGRkLTQ5NmQtYTgyZS0wMjk4YzgwNDZhOGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQeJ9t025m0NVj7cydXIv/3ODlyQVc6BxsC7PX3jNu0VM0kpeN0u1/p\ncj0cq4smXAtPIf5gbob7CPYXgxT4F9dXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0rkwi\nLDkwJAPdUCqCwqr1fWD4ajAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIBnE6aSMiUBAvRAqgHOg25cxL/gcdNMATQuyc4wgJoYxAiEAnfj/ZUjGs6d4\nOBmaVO8qojyGuLFAa5vESsP6IL4yRW0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1561", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1561` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAaUwhEwLFOFURTu6CBou+UZjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4ZTFiZDA1LTcxYzQtNDQ2MS05ZmY4LWE4OTU3ODk2NDgxZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg5Y2E1ZTItYWJj\nOS00NGZmLTlmZWEtZDY5NWQ1ZGE0NWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl2KSgiUkUrt38Z5T/QfZV5x2Aw2xHrKQIhoMY+mYnzbapDv8lIkOvyFHIroX\n/hjK8IUA/B1V1j9fyJkyI77Uo6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM4E7/qAl1SOA+KVggRnwfCu0c/wwHwYDVR0j\nBBgwFoAUpr6t1rP6tugB3clc5blf+RrwByMwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDo\n1AkrlBoq2q44udJ6X+HoLynZN0yKUQ67AqtAIXZ34QIgQS7EMQqgiOzn2XoCjzEf\nXks4rEoApZYawKAOtrqYtoM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcLJ5Wt25I+p2XFVhaRCL6DEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGUxYmQwNS03MWM0LTQ0NjEtOWZmOC1hODk1Nzg5NjQ4MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATt8acHLfGbBHs21+3B1aKOE29VOa1jttKBB/HUyf4rIr2N\nHOK3ElMX5EOhrBHm4WiVmXJYwcGQo0xOhV4SKBaVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpr6t1rP6tugB3clc5blf+Rrw\nByMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALbPpffYNKgxQc9lNFfTo5rMGpKGyUQ2U7OC/HdmsdW6AiBZ0jlYi3mL\nRJJzr4/3GSOiacvwfHmvljPsDmF3JEhwvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAc5L6XnOcMqWWgsy6DMTQjbgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg5Y2E1ZTItYWJjOS00NGZmLTlmZWEtZDY5NWQ1ZGE0NWIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYmM2MTk1\nMy1hZTBlLTRmMzUtYjJjZC0zZGM5YjZiNjdhNGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASQ/RMhBYiPlGrfwmojYY/MrevlTMvwuFUvV4hHCwzBgv0BTk+Rp/Mz\nHiBs/g2akvcchU0urzsteh0eJH8oIAEmo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzgTv+\noCXVI4D4pWCBGfB8K7Rz/DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIEaIenRjgOFJrPtUMIYpO7YyaUO/trwagNYPyhDvlhyHAiBxooH32kCrRH+i\nDN0srOUgOUHv148YUwB995tH6yspNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1562", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1562` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQIgvMDuOnAMoGb/92iw9x5SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiZWE4MTJjLTM2ZjQtNGI2Zi04MWQzLTk2ZGM4YzQwOTEwZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ0YjdlYTktY2Iz\nMS00ZTc5LTlkMzAtYzhlMzI3Yzg5NTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeELDkcj4XpQPX0vfuVEpePfH+SUXOu681hUh2h5cGBMqmwUWQqZ8QaqtJxep\nRU5EjBwBnL0HVb8xLnmwfn6s46OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjSzq5yaEJ6+9r07Rt9sE1W+nviAwHwYDVR0j\nBBgwFoAUE94o5C1JOFRoZVTK36hOXGX1JkAwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDFSDfJzsyKZcWfbaWVukyWRpBTXLRa3ADKtV2YXQ7/xQIgE/gR\nEHnAOFxIsZ1K9lBsWG7PVH/nH08h/YbJfAaJybU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfiuQqJ2kx+/+GNS3kBX7X0jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmVhODEyYy0zNmY0LTRiNmYtODFkMy05NmRjOGM0MDkxMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+8Am0ckGODNrZmQ9yV+1cA8mBi5i21zWYaqqulqducIjn\n4+qJf83q8kzZbbOQ+BtCemDGSZplXAvEjkw4ZsKWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE94o5C1JOFRoZVTK36hOXGX1\nJkAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbLrFrRz4KrgWTz+e9iRNidxK4MogmjpHe3udGgKJm2oCIEcxVnGmH8ui\nXg1jybL/My+2DDOnl/eFYq0YEvFsaVUd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISASRHYrKUsf82yPuz/XSh7/bbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ0YjdlYTktY2IzMS00ZTc5LTlkMzAtYzhlMzI3Yzg5NTY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNDc5YmI0\nNi01OWZiLTQzZjUtOWUyMy02YWRkNmVhOGNjZGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATH7jqIAij7D05AURz6SYTat2GIVM9ICnYrgIjvPhoe/02/0I+SlYUT\nH4ewjYudC8yjfMVgFR3dYBAXXrOadHsQo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSNLOrn\nJoQnr72vTtG32wTVb6e+IDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCrInsjXnCrPd0F10Zr1C6FM4f8wVoPU0xxWsj0BUFqGgIhAJKO6TTPuw8O\n9fowsMAMRMvaNyHKSFrOgtd6hk3hhyt1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1563", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1563` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAf9wyBouaW2hX+zU86cJV0DAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MzBhZDI3LTNkYzQtNGQ0Mi1hYjg1LWNmNTZhZjZlYzNhNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjlkMWI3MDMtZWFk\nOC00NWY3LThkMTYtYzQxNzQ2NTAyOTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyPUKcDf/qh0HWzKK/sDl0WSkyVcCi8RVKmZH0s1Ke9yQaZXbjuqLfPnClZCA\nQ5fFyGlI2Bi3Ivsqv3Z5XmFjN6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvFyyVBZKhEipEbcQ8Qb2gVwYoHswHwYDVR0j\nBBgwFoAUz/DUILLKf0w7uAX4JjjAVdzwmtwwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGRKQrBa7Nb8Hr82lv2myrpo9gRLgU6xsupekyLdQEywAiAPRBZ8\nWKqVkW115ifztGaK67DswG1elm//STfTqKWsWQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXySugPS0ubOTRXolhw+Rrq8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTMwYWQyNy0zZGM0LTRkNDItYWI4NS1jZjU2YWY2ZWMzYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/bJTvlZj++BQ96Pu3++vjJA9OtJpDwqsxJQU6wHzL9/cL\nl1gf3C/ng+DKAY1UJePZPNEV9yRJZ4QEh06EP28so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz/DUILLKf0w7uAX4JjjAVdzw\nmtwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJLzvyXeiqftPrhpNFTKiNNdfl6dtCVAd0Mzbs0bN7yBAiEAuHRHeVcR\nQOgwu6vt6w+iEGZCCwr5Um9fO0EwIXSGaTI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAfEDniJnIhuvrab4MKuhCyL1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjlkMWI3MDMtZWFkOC00NWY3LThkMTYtYzQxNzQ2NTAyOTc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YzM5N2E0\nMS0wMzZlLTQwNGEtODY2ZS0yYmNmY2I4OGU1YTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQoqRosY7jUjhj/D2djksqyADl47eNSXvrRiSkGbQSlAy8rEab3FicP\nFg5P3n/t7C3Anx4KkGBzUHTHJHEIYQvJo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8XLJU\nFkqESKkRtxDxBvaBXBigezAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIGUVHl2544LR8kpoRTkogCWs8kNbXxOtOuWEO6dU5f8qAiBFVfIN+h87FaFR\nrD1XNfA5PBR1BFatC9FPX+URkr7zeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1564", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1564` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZtKp1fOT6/Ntgb2QPkYTwWxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwN2JiMmE4LTM2YjUtNGFkMC1hOTUwLTYwNDg1MTFlZDE4YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGMwMTNjZGMtNmFh\nMC00ZWYyLThhODUtNTVlYjg5NjAwMThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQEzVk57p2bMa0KsvewjKooJA/fCQKQmCi6NvjluQky5BSthk1IBCRWOwHTus\neK4SPCn1SMiHKZUltAjoYQYr+KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFASCeztfxz4mlX2aVdKrcb5jVZChMB8GA1UdIwQY\nMBaAFHXzEmZMRcexdU3qVNkcAxMjM+1jMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAujVLMg7IQCzukd/0aIW24os8q12LxggM\nvws6D8qVX4YCIDr5vik029oTCArwtH31wctu+WPM6taaoa8Bo8poZULM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXXKOozMGe2432DJGIEoXNyQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDdiYjJhOC0zNmI1LTRhZDAtYTk1MC02MDQ4NTExZWQxOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATC/YsQTnvgtotbQjza0FUbsof+Yw2k6vISybCb1LuFwfIO\n4B7XyV/0dazpa1FHunCYs4sbR0hZas8rX0134zmto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdfMSZkxFx7F1TepU2RwDEyMz\n7WMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL7l9IfA1hWNEDkmXyyB7XnkzU0uqLvF8wwtRhQFLj0ACIH5qp8imB1cj\nmkctiXsCYArK1gvvXyeeLcPFp17bPbR/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAUKv/oRtFieBpu1FLSsCcaX/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGMwMTNjZGMtNmFhMC00ZWYyLThhODUtNTVlYjg5NjAwMThlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYWRhYTgy\nMi0xMGY3LTRhZTgtYjU5YS1hMjI0NzJhMjc3NDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ7wq+Hfl0lF+4rudc1tthqZOSBSC7FuksNKrOGZVxan/IBorK3joEc\nkADPP2o/2chG1ZHGy02t1pwY0psWx3zOo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQEgns7\nX8c+JpV9mlXSq3G+Y1WQoTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIDvz0WyZRD3Hw8O+edvaiDn7Izg79YNC8GWyAx/mvo5CAiEA/XqlIKnbkeWS\nvh8zVUP0fiuxKDtG6lFBHwCsLu4RW9I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1565", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1565` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAbNrpKQjyCEXwrGL+Osu2k4TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MTliMTEzLTU1ZWUtNGIwMy1hOTZiLTQ0M2EzZGVhODBjYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk0MGVhZGItNzUy\nYS00NDYyLTkyMDgtZGRiZDBlYzRkODBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYg3rwZptJa58EnA8JsBnad2VfDrP/Xvyw4Fi78gog/wOv1EEkpWuvAM9+14N\n1md58wDLQuCTsGuch6PjhRwI66OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzojoKbKHhFfL7LAbzfRkOzzgjaQwHwYDVR0j\nBBgwFoAU3b7RB6a0+ccewkL+JhtobxnyRQswKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAM+9i+ijMS6x\ne+aDgFfG4wOpWPaXmzx8JzpcaGxv/KUcAiEAl0oCXj5jAtlNOUlULRKJwV2jm349\nNTkd1wcvd9pNG8w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbhRB4yBn8P9M9ZY/+o+FfFxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjE5YjExMy01NWVlLTRiMDMtYTk2Yi00NDNhM2RlYTgwY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR30mRN1kfTDCfPwx+8J60GUldYQNwhjQn6npD6/Fp8GFRn\nA5NB5KUrU19Gr24o57SQkPsGdZqI//QgAJq3fHwHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3b7RB6a0+ccewkL+Jhtobxny\nRQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfKflZRb60jL0NmQwU4dg/3j/v4kKqbB3IUJpFv+KjcMCIQCKKv3DEl0j\nwN+4qEdpQ9dZXTaUsmxGI8+mO81UZGSg1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISASmsU4UcxOMMM/CClcwwCiJcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk0MGVhZGItNzUyYS00NDYyLTkyMDgtZGRiZDBlYzRkODBlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MzIxNzA5\nYS0wOTI3LTRkYWMtOGYxNy00MmZkMjUwNjYxMmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT6Zdd6YJtUYQndkhW6Llszwi/INbU8s9rMBV2qQSNZ2wdnY8k98R58\naJ+RMncM3ckyyl/lHiemTjq94vMExST+o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOiOgp\nsoeEV8vssBvN9GQ7POCNpDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIC8qmizFIuat4wV50cfGrSXuZRVaKOlXdYYePrn92js6AiEAhqQV8vESvjJE\nK8Ukj4NfudBU/1INOftI7bC3Rh2MKGw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1566", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1566` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAUb1SNmIWjKSiHPtKUnbZFoDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMzg3NzMzLWJmM2QtNGE2NS04NGZmLTg1NDk3ZTk5YzVmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTMyMTY2YmYtZmZi\nNS00OTVjLTk4MDAtOGMyY2M3YjRhYzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOGnU0spUmvXptJnwW2ShOTq+h3lafgcKzTHJ82/s9k3QjbTyXzyzdfl/h1nu\nHAb1eiPG10PZMoI+Xgs3ZjXOFKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4hUDWh25XN/0qL1h9Mvt1rx8E4owHwYDVR0j\nBBgwFoAUjJSDO1NlKcynjhB+phTAaKcRhxcwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKlAV8X+Ea/X\nd1bCWHmDQgoHy0vEln7//rT5AYfjcNowAiBHn/EETXbSiGedWc/omgRRIR+KntKC\nKEPZjqThzsfWvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWLiRLYuFTZGi4dvau/FvIWzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzM4NzczMy1iZjNkLTRhNjUtODRmZi04NTQ5N2U5OWM1ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEhZkitp4ysHJaz2Ik4gFCPwKPsddKwRApU25BqHYQxQjd\nCW4U+fdsplgHDrPFa2g01Dq2uPXIANRgR1PUexDRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjJSDO1NlKcynjhB+phTAaKcR\nhxcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALe17PXklsvg2zLmyA3nkAwy5ANVFtDRb5th6VuDZdN2AiEAzHa5gAAM\n8Pb1uPa/wHYoimiUD0i/nK3eHLheYZZf0w8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAXAJtEdVva1sl+q5hZLSd1MpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTMyMTY2YmYtZmZiNS00OTVjLTk4MDAtOGMyY2M3YjRhYzc4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZDI5MjAz\nNi03MTAyLTQzNDgtODAyMS1kNzlmYjM2Mjg2MmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQAulL4T3ROGyrKr0VwPGeXX/edgv5YMnvZgLuS/aeWI0F+3Jibpxcx\nZDcff4Ne/lVKYCxxsFnDeZwNNUncf8W8o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTiFQNa\nHblc3/SovWH0y+3WvHwTijAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCICIJ/fRdCxpUcWGIlylcNKrABfh1XF7onbIsuuY63tV8AiEAzMbdnUgPi3LQ\nmSDHeT9+SEHxobrHR4l1XNxnuNMx0mQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1567", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1567` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZ9R5bzAofoX73/B42Mg34dWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhODA4NWEwLThiNDctNDA3Zi04MDg4LWE3NTFjOWEzMjM2NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQwYjU2NTMtZjNk\nOS00MzAzLTgwNTQtODhlMTNlYjI4ZDg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOYe6ZOLPr3ljWDqj6spZgJiBJ00WfA1H/sUscSoz4qmLihhSq7Z4QIwPHuM1\n2I5YBYICR4Rqab0V8Q7onh8w+qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlZS2HwDV60U/ESPBUdeOh9Dh+bIwHwYDVR0j\nBBgwFoAUqGzCOxTrVVsfGHLqa1y3YYojZP4wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDA8nKsVntB\nGhuib1IAdVZmDfVKJv3gbld+oCSWLq4TAQIgE+NqF+wmg4/8lzN/kTaQ8bb6GnVx\nCyje3ppxkSNukxM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb1rwpLvbHK6dmzFTG1jC/nyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTgwODVhMC04YjQ3LTQwN2YtODA4OC1hNzUxYzlhMzIzNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwMzkFhrixGNAKNO/L/lWdPBeefLVL1LXd9JIckwS0f/iO\nhCjUoYRzKyWPn/gyY3q5rcATVbgOgB5hisNQ3hsMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqGzCOxTrVVsfGHLqa1y3YYoj\nZP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJqbKBIp1cHrO+evPzfB7qEC7xZ9GK659W4JYG0+IGw/AiAG+hzRUElM\n8PPolL2p14tp0UgUB5C5s+uQ/q/YaIC/hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAekl4afSx0p4YR1e5AdS+XrNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQwYjU2NTMtZjNkOS00MzAzLTgwNTQtODhlMTNlYjI4ZDg1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNzc2N2Ez\nZi0xYzNkLTQ1MzgtOTQ1NS02MzljMjM4ZmM0NWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS3H9zlWLJ+DKG9CwKLasxzrycScLXY6wSWDCWCNT/UgkWfQ8zvq1WU\nRjrEysZc6U366r3BZvt8BvIAwbfVpitvo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVlLYf\nANXrRT8RI8FR146H0OH5sjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQCqmPMTq0CBRx/LL3lmERl6SpnViHtRK9JNfkEs80xisQIgbN/kwDbxuPLi\nQKh0PUY18xb/MQt1+i8Fznbg23Uy0z4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1568", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1568` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYCmqkJscpkWrb4dW3bvbzLlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhYjVjZGZhLWVlNjgtNGYwNS1hZDIwLWFhOWI4NTk4ZmU0YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RkOTc5ZjEtM2E2\nOS00NDI4LWE2MTctYjFmZjgxMmJhYWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgWnveTZ7io0HocqBPzh5STZdOF2Zn+BG1Eigv+QpmGGI4QDXtxfCmNEtXlVw\nbTMQ7XoT15HOe/zoLhEHMCEwPqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9wJRLTPpbx8usAiAd/+NO6QENg0wHwYDVR0j\nBBgwFoAUzzSHs6vEoXSQx3WEJ0Bmmv+pjaowNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDMihzBsFWPC3ivW6OlmVQzhiLbMimKCnBuqi4lnuF/hAiEAx00/QkcJCNhY\nKNerAw6q65ZwH8LthsttaVd/tf3ImcM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaPl0CAgd6B9HevyFTX8OoC2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWI1Y2RmYS1lZTY4LTRmMDUtYWQyMC1hYTliODU5OGZlNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATX/RLLHDeBK6nG9KRc1kSCXzx8zQh1Z7svvv3kFzGTNubf\nW6cEHCxElPogE0mGkTyvi9iw+YTdjLqhfESR6JHno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzzSHs6vEoXSQx3WEJ0Bmmv+p\njaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHnwDBDQ7BT5ElLKsw5Li0dnkf1SkVXFcwE+3YHHB5QoCIQD2cbXf7H+F\n6TcY9rNyBjqT6hp1xXqlsrf/4gJ1FYjX2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAalbxxcTaVuACrryZqwNq6cRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RkOTc5ZjEtM2E2OS00NDI4LWE2MTctYjFmZjgxMmJhYWY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNDBmMDBk\nYi03MDFiLTRkYmEtYWIxYS04NDlhOWYxOWNjZGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQKpQjt94Lcqt8XvdWIjg+bS3gTVqQNXEzGsxUxCHai/qsMVpLZEu3D\nyoFrsa/Fi0QYtDYRNdAT827kpkZ5BURKo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3AlEt\nM+lvHy6wCIB3/407pAQ2DTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIEKKfAnA3TdTXbfyw94Y3TG8hoJcKBJai+7/HAv5R1uQAiAjzijcHDwXH1Pr\nN4EBYa2LfE3BNkX2WH+Z37HOfcvPdw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1569", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1569` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfcgZbBuDddLOKoZnxfTZzdaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmOWRlMDUxLTcwNzItNGFiMy1hNmI3LWRjZDg2MWU5MTE2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTIyZjc4NTktYmE1\nOC00NjdiLTk4OWQtNTc0OTcwZjljOTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF2eQpwd7mvUeVYMjMbWqKfyAbp6M9a9BGkCA4FfKi+0KvnDElGO1n1RDaO//\n1YObnquvriwjSYz7Dn9rR0Hw+aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWstAcMTmBFitvRCpbS/Uvl9OvS4wHwYDVR0j\nBBgwFoAUbFUhnYTVDLq89ytffeMPqd5054UwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEjDeCCxrmJhlWY2hGLp7RhJ0uP3IZHbkXcj7FSd7f+mAiAslGDgOFAYTUP/\nlU+eVVxlPfRASv7PaGSRqfjiqKby1w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATTa4xXc1cGcOhmQmY7MNxdUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjlkZTA1MS03MDcyLTRhYjMtYTZiNy1kY2Q4NjFlOTExNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQU5l5uHf5Qyzp2tH6HNJeVY8Ak53d/2H5QNFFk4qxjGGUU\n3Yd+yLUW44YFUjoEL2FIGBwaAxlzGpxTwbjWITSno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbFUhnYTVDLq89ytffeMPqd50\n54UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKvw5JyNuNeSWhosNKluBCk/uVjcWm8cy/bNrEGcqWAcCIQDo5bmy0/xl\nmZ2C0ERJsSBujeLpS/38U/b08oFzE6t7vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAfudjpSnZHpDjbdz+UfJYpRiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTIyZjc4NTktYmE1OC00NjdiLTk4OWQtNTc0OTcwZjljOTIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZmI5ZDQw\nYS0xZTQ1LTRhZTQtODE3MC1kNTQ3ZDRmZjQ5NzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARr5nA26tIrEsatO/BABbLUz5UovsjS6jIYPJOoWsd2JYf6kukTI+yX\nsnpAnRQgTqXXvbx9uX3NohaL0Uta2xZWo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRay0Bw\nxOYEWK29EKltL9S+X069LjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIEuhpFvPp81lz3vCEUeP/tgzYLhPPkcTU4io2xLli8z5AiEA+Xfr8l3eRIVg\nY9GN7kNKQdWro4SASJp8/XVuwqKALvg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1570", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1570` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAatQklCpAJpOxsVzdGcJDhFQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhYWE0YWQ0LTM0NzctNDJhMS1iNjQyLTk3YWE2Y2MyZWQ2NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBkNjc3N2YtMDlh\nMC00NjYxLTlhNDItMjA3OGQ1YjRjYzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETk9hnfZ8C6yzg7ufKMOQXNBh+1+GMfWMwMnW/twaYZXpjcnFAohAQNzw//QT\neJ7k+GtyhiHeu5SSmabbnNTizqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe79CmYhNOVQ9JyvvlcPfm2MlZVswHwYDVR0j\nBBgwFoAUZZO0tQQbhLNDsNR+Sce/Y9QYT5YwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCk\nld1cs2UdT6+vqWuvmFnolCrHxApfQx6Vl63gtoqzfgIgUlmIKDyZeOWwKnWYcw3t\nebDo/a1FsPfmbnE0mYtoHXQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcXFg2N+0qOHg8LYrfCaUH+rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWFhNGFkNC0zNDc3LTQyYTEtYjY0Mi05N2FhNmNjMmVkNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6vGVb21kCfEQ8K28tI92hdHzJT1bzANAY5KLiZSAvj21N\nQY+LO/3Q0iEtNB6b4HxVWZD2AA5r/7EiSL9zHBg/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZZO0tQQbhLNDsNR+Sce/Y9QY\nT5YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO1W9YAPWGjBrGX+Waa2bo4X+FwF3jcfQBIbXLZCZXmbAiEA/LQuC7Ry\nlGYDX4tp9F7NqxzI9zzGpb/unP2bQUhkPss=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZGsqvkG60pBLENLacF1MPbmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBkNjc3N2YtMDlhMC00NjYxLTlhNDItMjA3OGQ1YjRjYzc4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0YzRiZjU4\nMC0yNWMwLTRkNDEtYmNiZC1kMDI5ODM2MzA3NTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASPJ9p2VUwEp+o7NwR8kFFMF0tjseurxdcibmjR8oZZMkFxmnyA79LC\nJZiWScoi9vISYkoo6SIBdqry3ISN7axFo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR7v0KZ\niE05VD0nK++Vw9+bYyVlWzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCID2DPT6LjsHYCkedgB1sQRUuyAnt5ThSKQw5oXLPHEG6AiEAhs4qg4Li+diD\nJ18iUyM+1FyxNy2iF1270NgMPjfxNaQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1571", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1571` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAZpB7MldO0DGrm7GUHAv4D3hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyZTJlYzlhLWFlMzMtNGM5ZS05YTU4LWU5MTdmNjVkNDY2ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDVlMWE2N2MtZWNk\nNi00YTQyLTg3YWMtZmNmZjE1OWFmYzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz6bdzbr3N/Z5wdKVSyZv3r1AmaIcB2/rPHpLAPBZ+1l5qVTOwqYLnKng4E3R\ntpVAJpMB737gUx6nfFAJox4reaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnwO9WLPHpDS9viFE9y940dOwd58wHwYDVR0j\nBBgwFoAUlto+/2u1drVHouwoIOyAbCxkxjYwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC/yv2eiDuAnx+6q/ynAOFtupOw5PFkJS7KMKlX4GqYxgIhALX8\nt14ycohKBTG9lQq7rl0N+EbiFvC6WPHmjlbniCum\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVVqtMI5DpAEWV802XeWf+0nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmUyZWM5YS1hZTMzLTRjOWUtOWE1OC1lOTE3ZjY1ZDQ2NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGxKQaAbL8dogZ7Z1fZLVzjPuEPbQUo1zXg1uNVImc31Bd\nFCBJiiFKl8oj1m+yJRhnz3uBsXV2YEfsS98DjOu0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlto+/2u1drVHouwoIOyAbCxk\nxjYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANvbrrM2VJEbHQO/qETrETyGfq62+B9UuDKnOPXqhJtkAiBCH8H2wPw3\nl7Wu8tbv/vWdWyXaRKU3n81r8yUemwosVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAffDkyvuNX1hydlsy2RHEJaFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDVlMWE2N2MtZWNkNi00YTQyLTg3YWMtZmNmZjE1OWFmYzE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxY2RkZDdk\nOS04MDZhLTRkZDgtODhiOC1lMmMzZDAyZWE2MmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ7NA5NoxQLMNY21VtRRDtqwVP/Q6EiYgf47G4RVT2YcZhultu6nEGS\nICS6QDxjn+UA/2Uy8VIMxgObtO5MShuzo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSfA71Y\ns8ekNL2+IUT3L3jR07B3nzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCICQBVNlV5kdgUsBRRagBC5JYbadD7vJRTfbEoq4KedHdAiEAk6Z1Ru2nXJXZ\nALyZQiJcnITJcTBUarSTfvFic9GTsnU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1572", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1572` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVsMNjupKN0hFvMPeXakUBA1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmY2U2YjE5LTkxMDgtNDBmNy04OWMwLWI5MzllZTJhNzk4MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBhNWYyNDItZjNl\nOS00Mjc5LTg0YWItZDc2NTI0ZmI0NTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2XDazR1AM+oludFNIMu3IhvwjVD1xlhmVhg8L0ZtN9KZahnTUwLqYX9Y0xr7\nN0YrI0dg05GJqsDhYoPsozONWaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUspD2YkinatZBVD7EUCA5Xmt3PNIwHwYDVR0j\nBBgwFoAUU5AHxjpF6TtXGLxkd2FcTVzRSLAwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIEUFZwvnDWgg/wUXoJjhHTkp8OQ2/5VFXQkNJFUi9SjTAiEAqYkm\nZe9sU7rWu4GBwKpbKJFKEObg0YTmEIL59xryEPc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ7zQYH/hP+LTTsj7T0F4VplMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmNlNmIxOS05MTA4LTQwZjctODljMC1iOTM5ZWUyYTc5ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQtZv5Krc6su7koWkFliXpZOPi0DJFhA99+w3nReZCxzAr\naqpbs/GUF3BO7EwfylShF12XujA3olmgfwirZ3peo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU5AHxjpF6TtXGLxkd2FcTVzR\nSLAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY+PEXUw7TDq9ErMm8fbntl2oUZDTFL+Fp3stvfke3P0CIQD2r0LIkz1x\nyVNKZA1jPbBV5TFFo0j3XfoSpWZr5nH2SQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAW/VYJqd048KUy6u8R6FC98uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBhNWYyNDItZjNlOS00Mjc5LTg0YWItZDc2NTI0ZmI0NTAxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MjVhZmNh\nMi01NDU3LTQ4MTktYTZkYi1jYjA3ZmQxNDFlN2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQIJI8BggZX2BJfz9Nx15iGaQc91TQccq4MgfFflOjl7wpBkMrnLTnE\nIdIwY1ornP/UykIqKF96aBL1C3GfNHXio2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSykPZi\nSKdq1kFUPsRQIDlea3c80jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIF25lSlwbKMdJ50eUYwFQ1LOTn0JkmuUfNzjy0XdD9huAiEAnUJpdFHR3Ljl\nYMQqMiBvau9AEadUSZB40q7yxowBu5g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1573", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1573` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAYb2u0QtNHrxNKJvMVFVz9e1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YTQ2YTgwLTNhMmYtNGQ2NC1hNTQwLTQ4YjU3NzcyZTQ5YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTEzYWJkYWUtZDA0\nYi00NzI3LWExZDQtOWUxZmIyZWM1NjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp5/Qymk1U78Pmd7xUN4+g2RTRvHTMHCdZDGjXzs/5qxwo8cf+jgIokF2O7vf\nfU3CRWjazVDHCpfpSbOXxzsAFqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQVrTENy/xmNBkNd9EB8IqCwujbyjAfBgNVHSME\nGDAWgBRnxN7JqlJzG+eTMoEJ5WXL04jX4DAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDpgbiHbxpo/NA27TRn3lprWZgTKGNu\nub0eZ1euldOVIgIhAKnGfcItptJxn5Ki71xnhkJ22wYSyfBAxogkU0Notkw+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVnXe4wG487bIMqtv4+QZ+ogMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2E0NmE4MC0zYTJmLTRkNjQtYTU0MC00OGI1Nzc3MmU0OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpC3S3h17qW3XFWWU2yt0MxZl0mXS75FYCMAhtGvfDdFT2\nObmShqWi9OX0wmBPEOzbufoo8JrH+cGpoACbCYDoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ8TeyapScxvnkzKBCeVly9OI\n1+AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKNIG6T0Oe4C2TwKNw8j7fqqmfzj3W7+SDrluYR2x3r4CIQDpw5J0P6mr\nzc0d/py/pl9k5kl+N5aahiVi/MVq15IvXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAc8vTqco/eYo6pCj+a/uYHAJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTEzYWJkYWUtZDA0Yi00NzI3LWExZDQtOWUxZmIyZWM1NjVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMmQ4MTBj\nMi02MTY4LTRlY2ItYTc5OC05ZmFkZDU4NmJiZGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARjfyLfJ6lAxs9qNPbaSkmCNvzSjkuadkJCxBDm4BI2pnuCqtRx1MDa\n9Y4kTbRfydEskHO9bZx/1f8AJLInW7Bqo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVrTEN\ny/xmNBkNd9EB8IqCwujbyjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIGGTYbM2QNFjgZTvU3lJp5EfDtA4xZvFtGrF39iYP31tAiACjPLMVipJz9qP\nKvl6satQEv1QB8avS23x1nHKbeSzjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1574", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1574` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAaDeY8wL2Lktle9/PjuBqDo3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyNjlkMGY3LTQ4OGEtNDE0My1iNTg2LTBlZWRkYTFhOGRiNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUzOTM2MmYtM2M4\nYi00ZjkwLWI5NDEtMzkyNjk1ZGFkYTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmr+sRWcZjw9dHN085mdiIIeWv6f/M459X2CDWANg7ZD7yduf2+zj086PQqGL\npyTYC63gH7z9znT02g8gEdsLyaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ2HXLT2McnWrOHSUSKMCouCjbFgwHwYDVR0j\nBBgwFoAU7R8i+yA+gyDiqIdll7t4V7KlnOYwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCnpKmZGJ6k\ng+Cy01r+Slb6ErmWmlFq0JobjHSBr4MTvgIhALa9K8iGQ1Ydxp/SGABi9oNv++T0\nzYgkI4g84S6X9PM0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAactFYqBX3D8tyH/dofEwSY/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjY5ZDBmNy00ODhhLTQxNDMtYjU4Ni0wZWVkZGExYThkYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuuAkyZCmRLReBDoIAX4KeCJsoPWQItltflpHSjLSdVl7M\nnadhYUAzYp5dVWgzOx/W+WMe25BGPcV/i7i74W0No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7R8i+yA+gyDiqIdll7t4V7Kl\nnOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc4tXo5VgJ8GqdPk4oxz3FQlkXXt44vDgkJiOhSM92hYCIQCvqC1w6GeU\nicwUj2rg4RiMQZ/u3Xz82e2YypsCLWyR1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAdS/0hrpRfIsw1Y0he2X9LKGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUzOTM2MmYtM2M4Yi00ZjkwLWI5NDEtMzkyNjk1ZGFkYTZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNGFlYTdh\nNy1jMTI4LTRlNTQtYjlhYy1hYzUzMzU4YjdiZjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQy3B7RCiaVTW0C9ffmt8Ieu+g7ESAdYJ3W5H20Rp6Yl5IO1F80y8DW\nLclsDaZwS2Bf/xCoGYFts+MFt6TDIUmYo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRDYdct\nPYxydas4dJRIowKi4KNsWDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDiYEID85zcobpE00rlgtUO7lB2jovi9Teei7FpDuSWfQIgdhBTxYoMiUDD\ngcWQPqYVboqWvL/RMA1i9CO+DdBVcFc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1575", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1575` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAagf6CHmLt70EBKLG3riMfcMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyYmZlN2ZjLWEyZGUtNDRhNi1iODRiLWNjMjBiZWZjM2Y3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY3MDliYmEtYWY5\nMy00OGI2LWJmMjEtNWQwMzUzY2FmY2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/v5+f4QNPEcIiYeCD5JhzTbPoCQFPXLAG8ot9nXHSJrgxMKIauxF32Q8H2Ye\n90sAdoGa3A4L2InhoRQVjjgD8aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwgC9WDnipgEiE9NQfCviL4ne0acwHwYDVR0j\nBBgwFoAUSCM2la2uCIlU9HUrFQupBDTbmgkwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCi3ZcYNwWy\nd8qYBBqmazLjswO89/sj7U5oBqjrvFHk/AIhAI4gQitCfGrCluIcxBxbXyXpy6cq\nDuWUgFdECt92ndRO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYGwGSHCSVtcTQrg7AZIVm0JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmJmZTdmYy1hMmRlLTQ0YTYtYjg0Yi1jYzIwYmVmYzNmNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGnup6nc42ouq9duAuCdQ452SzZf4cL5GUnirFHoKyihWo\njWvBjqkaAv9XuFvEkhpWoANoH7aAe3XagM/f+nlFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSCM2la2uCIlU9HUrFQupBDTb\nmgkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ3r+joEowOZBUScde+ASQPUR8Bcz1rGBJeZ/ZaY68kuAiAQiQzG+GBq\nGGjZFgdXe4hnOKeXcVhVdU2hDk5f41k0ZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISARSBHXIXUfCZKAYZ9PyvaevLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY3MDliYmEtYWY5My00OGI2LWJmMjEtNWQwMzUzY2FmY2M4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjY2UzMGMw\nMC0zYjhkLTRkYjItYWQ3OS1hOTYzZTllOTdjYmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARqLDJ6ndB+Z4fCgl3wzA/wuzrEr5BluiJLe6STxoRkYINZAiootly6\n3ZGKi4FiTWy3ALkhPNnWlA6CngxEFNC8o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTCAL1Y\nOeKmASIT01B8K+Ivid7RpzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIEnXgD21CJeJ5q8/mX8CBGKISqyPsRWbFuqgJtqTSjivAiAe39ytJbLRkDHR\nYsVp2X9RhV9xfNjG8I/OUxkb6zVRaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1576", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1576` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAf5Iaep1WzYrIwMIlIleop8oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3OGFkOTY0LTI5YjgtNDM1OC05Mjg3LTU2YTZlZDJjN2RmYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE5YjQwYjEtYjZj\nZC00NGY3LWI0MzktMmIyNDJmNzM5NDFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUQetNcEf1yzNBikfFAtS2j5070IT+t5LELy2QqeQEE2pMrMs7Z1oNOpQgb0l\nO+6y7hTqOzJzQLUUh7alkdWK+6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPbta7GfG5FSOZwvksVLNXdsoy8wwHwYDVR0j\nBBgwFoAUFInyJ8WGIjeiL2g74h5eiXJhbTkwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBizfwyIgCm\ndxb7yvJ+xrrccBN+JbcOgJTR+BaYTNFDkwIgUSKtMXg8jtQie0j64Z+Go+Pgubi8\nhzlf/M+7JP+D4X8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAToH/3KVrs/mle2DdN804rrPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzhhZDk2NC0yOWI4LTQzNTgtOTI4Ny01NmE2ZWQyYzdkZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATO/Mw5cpFFksQXPF7GpTfC6OsizZZ1K56QR9DCnr4FvpL3\nP3t3TsLZNH69aCWmk2EnpIYP/qyohwLlNeHXqHNFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFInyJ8WGIjeiL2g74h5eiXJh\nbTkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHn+itRZhqLfq+IwXuLz/+cjeLAKC30yL1awsgdoqY/UCIQCuvD7lpTY9\nT92/3OE0SCB3kxd56NxDROeE/PCBbLyliw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAZf88iZfrjZ0TvM8Irfwh93hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE5YjQwYjEtYjZjZC00NGY3LWI0MzktMmIyNDJmNzM5NDFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0M2NjNWVj\nNi00NGQxLTRjN2ItYTIwZi1mOGI1ZDNlOWZiYzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQeSpu5qnqGZtPuPGFOYkqGeK6eU8fGUQFiK8XPyNmf839IR/AoqfNJ\nxJm8ZQ46U0xWtJ3hMau427WqWVcMuXKIo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9u1rs\nZ8bkVI5nC+SxUs1d2yjLzDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIErSxmMCTwWnxOMe1kPFV2VohZ2wS2es5V9mQ+LhSuH6AiA3IzsFU331wDFJ\nAeSPIFtUairQZ6VkV6ICQ8pIUbJ9cw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1577", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1577` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAWngEiXfDxdOd9JHlvwTmwLwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4YTMxMjEwLWVmNzEtNDNkOC04YzRiLWZkYmJjZmFhMGM4NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY2ODA3MzYtMWMz\nYy00NDRmLWFkMDEtNGNkY2YyODI5Mjc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhGNTA4TUkcEl1gYUbzelULcy6JuTwQKMfXQA8paKlKOyUBCb8y/tjtvGzigO\ne3KvYQUFbUhGXjiv51pZ9HYNVKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR1lRqbf22drKA+HB2gH3b1Qp5HYwHwYDVR0j\nBBgwFoAUDKgSR2LeMBLwx/reKSFjuNdNtSkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAndDCIQELwDsth167B8TcN1P253wDlHPMmUzjusngYRACIQC3Esijopry\ndFb5vTYjlSFuOnJ4numIbtsOQO+oBlahpw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXTyR8kQkavD9JA4G0Kai0o4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOGEzMTIxMC1lZjcxLTQzZDgtOGM0Yi1mZGJiY2ZhYTBjODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThjMWLw5NunwUJUO0Sxah+uQK7boV07B9P1T1b/t9jUa8y\nQOqMUlCjMB8EMPLumM+vOn1vJ2CandZLELlBBO0ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDKgSR2LeMBLwx/reKSFjuNdN\ntSkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM5WcmYOaC/44t9RqB64ewW+viCtqf38wFmZvno5AbVMCIQC5dcnMjRKv\nAjyeszsPoeF5jVGpADzm34Fum1Ry+tH4eA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZ7L2ce5RQqxzpZu4MkmTppNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY2ODA3MzYtMWMzYy00NDRmLWFkMDEtNGNkY2YyODI5Mjc1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYjVjZjcz\nYy1mMmY4LTRlYzQtYjkzMS1iN2ZmOTRmYWZhMDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATYHZipZGz+4GekhCXhlUHfe88q309l6GsWKBDBTzO3H/mVzv9icqjg\nBO781pNPDGTne1oNrpicveK24A13lhdZo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHWVGp\nt/bZ2soD4cHaAfdvVCnkdjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQCHLlomFk1dN303rkrNinVessKoKjsTCl9rkuvMUA0cHAIgBqhdRu9ey4OJ\nDKtpZlbiUSL2V2MgNFCyFsyFHcPz/l4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1578", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1578` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQK1iTxKe2tmnRY7wW3cMQBKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2N2M1YWVjLTE4MmItNDcyMy1hZWU0LWY4ZGFiNTIyMzI3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY2MTdkOGMtZTk4\nYS00M2Y3LTk1ZDEtN2Q0NjAxYTliMDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Mpfo8bDpVmcegoCj0fn+XZy+20w+gzKtiP+4fx8I1NhNDKv4YHxu22nqQwv\nTk7s2pEkH+DDOCa7/yiHoXpFfKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz/L1Tkb1gg6ezeEcSjNxG82g9zgwHwYDVR0j\nBBgwFoAUDmiOuGc9XrY3hl8t1ld3R5aPqFswNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAesgeAMIeisLkUnc3QuYMti++srR8IHLZ9xCXbjXh5VQIhAOfT+uswTlYg\ns0w0eNsRq7XiPyRHlL+q5FudAVuWOBgu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY4ykbAoX8uV+l8/kxJoYLXhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjdjNWFlYy0xODJiLTQ3MjMtYWVlNC1mOGRhYjUyMjMyNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAFsA1udRGwZUWiFs8yRVvopJv3ZiLIa2EAASZqscBg+oo\n8TsiLPDnUNEWx/PGaK9DCI9lJcGhnqEtXmYsr2cdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDmiOuGc9XrY3hl8t1ld3R5aP\nqFswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMQRYAIiwRh9E3xZy+/Wnf6QIli7CwfTJXLCtMil+BfSAiB+hQuzy+/0\nYz8qOt6KubwN9EPe/223lqbVKwUDRHh4Xw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZUdfCbiVJDXfxsBm3cozewPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY2MTdkOGMtZTk4YS00M2Y3LTk1ZDEtN2Q0NjAxYTliMDYyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NGViNjMw\nZC1iNTMxLTQ0NjAtYjVjZS0wZmE4NzdkMTc5NjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATApha6Mgrtwk/jZ3fTAZiSUv3eg3baCu/wbikOc+XaVhfP6F6SZmrW\neMlTVprXxQIXsDl7pvW3eV8JfZItM9oHo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTP8vVO\nRvWCDp7N4RxKM3EbzaD3ODAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQC6n9ZNNVmRj7N0oXnDDmH7terPe6qt6HxY1sAybiFD4AIgQ8kWxiC1jCRb\n/ZGk7KQg4QSXdgTkGzZAL+lbKWwZIa0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1579", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1579` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISARqIfrV7VDenl8wE43p5jq3jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzOWNhMzBjLWI2NDctNDk0OC04NDRmLWNiNDMyYWEzYmExMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVmN2U2MDUtMjY3\nNS00OWJhLWEzMDItYWIzOGQ3YWJkOGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpUUdNOukOEYnJRWiv+0PX/n+ecMTqi2U8/klgiUyuPhgbzzd9oEndCv+9bqA\nRfzbw/Cn0aKNxtlkcJWiG+HixKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+sMbZV6TiIKvjKJJjZIlBobIBLQwHwYDVR0j\nBBgwFoAUdN2mkwaAt9Xu6ajbYhf8l4lb6QswMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\ntD4nkh8MJYG8G13VHdnaV2/4Pnk8EkWRKQZP8lXsEL8CIEGm7qsmx634NwI7a5ne\nv61hdUdoFF+/6sMumKvsZGzx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYhVX/XTAL5hprdCKeoBBrfnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzljYTMwYy1iNjQ3LTQ5NDgtODQ0Zi1jYjQzMmFhM2JhMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmgj7MEJDEdT7xpYHbPyKau4wk0zv2TisMfjvVPAJ94NFW\n5nCRKIyTvVsGFpFFlSU6/2EhlyHPBh34K8qElIMdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdN2mkwaAt9Xu6ajbYhf8l4lb\n6QswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYyVOSluVe3W5EuEWyLHliGN32LimZdZuuc6I5stPORUCIBAhZnXXL4ab\nSMqbYXyycIWYLVi/Ia4bt1PDiFQ6pQ1n\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAexliXy7QXPzbUv3S9MKN9fiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVmN2U2MDUtMjY3NS00OWJhLWEzMDItYWIzOGQ3YWJkOGM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYWI4MWU4\nMS0xM2VjLTQ3MzYtODU2MS03MzAwMzVkMTQxYTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATdxLzoTUbbf8UMvMOd+t5jP6puhFXfCQ66Cp1Tiikt7TL0XXSMbAGv\n1Wdf0/IFVMzFAcnQSYTRngFGyuM93hOPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT6wxtl\nXpOIgq+MokmNkiUGhsgEtDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCPDZgafHmUu/1t4pjSVOHQ71OZE1YAvEuLJ7TdNd0XcwIhANn6dWNN8LZ8\n3wLVbx0RCnKtg7IeTq1lfEaMf/iIP6DY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1580", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1580` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAScDHSQAPep27TG4nYK6eeFEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmZmJhMzEyLTQwMWUtNGY1Zi05NDBlLTIzYTc1ZjQxYTA5ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ3NjJhYjgtNDI0\nMC00ZTY1LWIyZGYtNjNkZDIyYzU2MWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtqrlVIH4kOmfpWMhG9ZhneiE9f5sJHghaxwCRVLMaRrVtbQM8y4ApQveOgmC\n2ZsLMxTjYKv3ulEWNw6s9ZYWdKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5SJJDeijiFzjsK63hhf19iVu3M0wHwYDVR0j\nBBgwFoAUL2gnGXLc4J6TqT4TIufNtnSPAlQwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAgnIQPcwCNaga9GMwpPqWMbmrRInHeZS++lDqKhYwFBcCIQCM\nJJ26zQ7BWgwBj7YBucTNSCy2i1KY59IPvHiXpxCqsg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbqcEW1WgMdz1m0uUYWKTDqrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmZiYTMxMi00MDFlLTRmNWYtOTQwZS0yM2E3NWY0MWEwOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARE/YBWEeEDtpgdxBofWOxUolpzgiVcx0t7owcCXR6b/qod\nifKQFfXmpSqNlP8DWDiGG6c1ORiWcbosHG/F4qRwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL2gnGXLc4J6TqT4TIufNtnSP\nAlQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIXiBqoVf4C/tLRyF8vuGundIgWVV5iAXYqVt9TJ1rivAiBLLaB1iNP8\nnAMo2C3mVChglrgdPz3nhbNnzB6BWSXGLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAa+9j0yh6RcIWQXF/fXR133JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ3NjJhYjgtNDI0MC00ZTY1LWIyZGYtNjNkZDIyYzU2MWUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhM2NmNTFi\nYy05ZmZiLTQ3ZDgtODM5NS1lM2Y0ODIyM2U0MzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARrD/VoZKvyZU3cMXZsTK12OhE2f/3tiPXkXcAEMQZa3jzPtamxNRb7\n0mPI94WwflqG6OhlVW4FblPybQb/Jqrgo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTlIkkN\n6KOIXOOwrreGF/X2JW7czTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCICGnUEau1kJ9PbAzVn9p+d8DHK5/tl7/4Jk1ibXkocSwAiEAsFGTLzpWHfvc\nskQL9qmig9Mms6F/NuCoAD2WlrEuyKk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1581", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1581` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAZk7nc2OrroGkiAAIUy50tePMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjYmQwOWZlLTg5YjEtNDQ2ZC1iMDNiLWQzN2ZiNzgwYTU3OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVlNTg0ODAtOWQz\nMy00MTUxLTlhNzAtZTBhMDA2NjZjOTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+WnOLT0GiUpG6BfENHi3c4aA3HiLV8ww5izzopssp1QWkABghUv8GmXfPXn4\nnJaKISPIYzVsJgVzxQFM3K+ZDqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz+5zZcEQnsGUnQ8wwpXeD1i03+0wHwYDVR0j\nBBgwFoAU4LRkQcMcvOlilrZ0Fk1PS3t6qn0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBb4j60rCTKNlMW/I7tRc2lLstIvZX9PS8dpb59GdkL7gIgONSk\neTTA8yvbbVrgkzkQOn1BcnNKWEw4T7gjSwTTukQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXVHdCf1iuAtCqd3eba4epErMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2JkMDlmZS04OWIxLTQ0NmQtYjAzYi1kMzdmYjc4MGE1NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkIC0ipPTvD/VsiCckivgQij2KK3Vg1OqZ8OqiVd3Vygpe\nmKvRnrLR400hPsw8TJoqyJ3DwtNtDFX+6yszuqVWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4LRkQcMcvOlilrZ0Fk1PS3t6\nqn0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJJKC0ptfE1fmhNmReiOExjUmFJRXQwzEIWvnibVwzDRAiEA+A1LbBCK\nWyl1dDevE8vp4KnUnLMvs83d+gSFG3VuCbE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAT6RKagWYykJj1v94qlWZf0CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVlNTg0ODAtOWQzMy00MTUxLTlhNzAtZTBhMDA2NjZjOTVmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZmY4MzZi\nNy03ZDgxLTRlY2ItYmRiZi1iZDU3M2Y0ZmYxOWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQvt9XPySIU1R6c7wJRGpyoZ7LMRhvcbeEMqMzxB1oVwWHYnR+xe79c\nuDaSV1caVuGCV9P9v/Wlj536S8IyJQFCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTP7nNl\nwRCewZSdDzDCld4PWLTf7TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDK0ANgx0CAhV+pL8JNRTLuUS7nfIhNT2+DuN6oBuym/wIhAMU3usr02855\nCL/xlxjC8FHzjLUTMOn5qxtkHHQNv/0i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1582", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1582` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAdrwxhCygNmowLJaJNI1MRx/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjOTg5NDNlLTVjODktNDYwMS05NGZlLWRiMTI4ZDE2MGQwZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmMwYTNjYzQtODgz\nNS00NTdlLWEyNTUtNmIxOGVlMWNhM2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWhZWblIK+fIzvlUQ4Ej/9gAysME2hxSZBMH0uASYEKx1YKc86XG+oZ9EUNiH\nCndoYKXl5ISRdtAaXKl/MPBrd6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAKiu7Bzmp5OLVcvxyDmZ30jyGG4wHwYDVR0j\nBBgwFoAUeSTB8i+Qp4IIpWJNupL4nivb53wwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAwodrXZXvFNTo\nptSpAX5XdhqCm0om4Mg2hxVZLVawLJ0CIQDQGA5QJnigE7RhAji/2SiJwFFHej1K\njGFHYy7omwCzTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQyhd+fCre/BGNPBN29pIQeWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzk4OTQzZS01Yzg5LTQ2MDEtOTRmZS1kYjEyOGQxNjBkMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5MW5a1n2GmtUxsqptdfHjdOyvb++k0dRh2hBqaz2nv9VF\nzGZxAQMuceUVSd62Z+/3vjrLjcfVKyPDKNr22/2Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeSTB8i+Qp4IIpWJNupL4nivb\n53wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbT/BTK/KdkDXc/rI9q1n89AGZ8MDBJz0rz9rDIhYGnECIFza8Rrw+tAh\npphR1TsiTKXCHqV2AYo5p9lqlw2QRQMs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAQ3wIr/kAjglzB/jTu9z99FVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmMwYTNjYzQtODgzNS00NTdlLWEyNTUtNmIxOGVlMWNhM2ZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MzQ3OGYy\nMy1hZThhLTRmYTItYTY5Ny0wOGE5NmM0NTRkNDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQzQSGW0CL4wg5NjESwwuqlN7KaLrzA/ggv0wYYQlafEHRYIpPquALp\nkuJJofzlZXbl25q/1KzejwZI1HJMk0j5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAqK7s\nHOank4tVy/HIOZnfSPIYbjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQC+YUK1dyiUsZq94K9p1b2nPp2k3rdkw6lPNy/WmZTPnAIgR1eToxtk5iJg\nz/Tyt1YkqBDmzjH+UdaSVgD7cJD4G4c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1583", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1583` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAa/por1+96xNyGHhdDIJebczMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxYWJiNTZiLTM3YzYtNDA5NC05N2Y4LWNkNTkyYzU4NjQ5YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk5ODE1MWItMTEx\nZS00MmVlLWIxOWYtMmEzZWJhMTNiNjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIBp0UmF6dgNzdHOCpK8h1vgDdy9L7mOR9e/pNlNRlF6lIch/cFOVvnEvePoA\nrtmyxat8MSgTjx2mtxownVtEEKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPbOtz30vrNze06MANtE6nqvf8UcwHwYDVR0j\nBBgwFoAUx+hWbSAFSx4EBo+E1iKjlBGhuFcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCMbHFLrDLGoYfe9fNtlXGanfKLhxSN7325QjU6liWIYwIgXhBJCmGIcPU8\ntfHs7rOTUHid6fO21Zj5UY7/SPNqYgQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARlwrbAnxTHmG+XWgqAwf73xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWFiYjU2Yi0zN2M2LTQwOTQtOTdmOC1jZDU5MmM1ODY0OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbjkFpxRYDi6pyvdyN+GyB71OJO+iRtMprhA7TgCH3q8U/\nokCXai4YemgM9hJLpgHQn9tLSjgH7Kfj/fznVLspo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx+hWbSAFSx4EBo+E1iKjlBGh\nuFcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTBhaKN3rkSFVScXAwippmaxx6FqT5Ap6WdeJ7h1bFMcCIEw8o6sC7rL+\nt+nCJUruzbRsJ/q2msuBB6anudoMD7Lb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAaQkULoUFS3GRhhcZfVr/k9GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk5ODE1MWItMTExZS00MmVlLWIxOWYtMmEzZWJhMTNiNjAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OTlkMGE5\nMy0zYmMyLTQxODgtOWQ1NC1kODgyOWNjMjQ2MjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATGtPpr3HtBRiB33f9VYt6N0GYerigKAoFORszmedc9r80joqGKLCC2\nVTqTJ+Zyho7xzH9A0Mrysla7OCEaxXNco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9s63P\nfS+s3N7TowA20Tqeq9/xRzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIGkMq63DpaPKiRKvXfrE2WjoOQgYr4ofU165yjGYipIGAiEAgkqTtAtpzqge\nZXFhdIibEwUzwyqGPvcNYSqWTk1CxWg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1584", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1584` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAf4kWnio8xp4Yg1YyKddDLXtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlMGJhNmQ2LTA4MDUtNDZlOC1iYWI2LWQxNmFiNDNlZjI4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdlMzY5ZDEtN2Vi\nZS00ZTdmLTkyNjMtMmU0MDQwMTNkY2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoYQutnrXPK5I4IhvyukSRnxXMrzd2qCEshG7yXm9Vj+iHKWwdfNoWoUPLjS5\n3dgBCc6LxZwCoHYj0jXTBOC+mqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzuMFdztCq5t7o7WQ7WjZtoT2x/8wHwYDVR0j\nBBgwFoAUh2IVnycTnMbnsnjzOq8AtzVa5+0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBWaG7VxcfquhH4Q0qtev0gzUQy0HBSIvNQ8kwNwWDd6AiEA6yE3ipvKkORQ\nEwjIzutI7wfnglilkTg+tpsMTnLVHXc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcf9pGmzSvSbDSGt3eL6DclpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTBiYTZkNi0wODA1LTQ2ZTgtYmFiNi1kMTZhYjQzZWYyODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9veR7PBasZCknK0UyTVz12+pesCh7SD0jzQ/En2/AhH5a\n3Ffv0JqPqlCUQwqARQxptaaJ6SsXzsL/GjVXuw3Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh2IVnycTnMbnsnjzOq8AtzVa\n5+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEGN00SvYVa/7gTFv/ZNJX8HEx1eiMIkFSCgR1XB8JyMCIElBUhcoSZ52\nQLie9gkaT9W1zn7A5n+cDfZ5sXdjppRJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISATxbTF9s/9otMkjprZWQIaP/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdlMzY5ZDEtN2ViZS00ZTdmLTkyNjMtMmU0MDQwMTNkY2E5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNmJlNWRj\nNC0zOTM3LTQ5ZGUtYjNkZi00OWU2ZDEzOTJkNjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARFcZJXJK8PDdUX6TKFFWVVndNORRnZyn0xZT1r8TDLsRlIvTJRbrT4\nq6aQc6AlRX3nOKPeeRydzbTAWRVCMz3qo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTO4wV3\nO0Krm3ujtZDtaNm2hPbH/zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQD4UXYjPtYOQQcT0Jow1/0iyOcpSIKmSS3hbITv6TWzhQIgU/plJh6hJyLD\ne9vIfjuN8tRtU11P6xfmdhVvk/TRfYw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1585", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1585` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdjC+f7Tc3UnujIT5CkYv/zFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljM2Q1YmJmLTkyYTItNDgyYS1hNjRiLWZkODYwMmFjZWY0NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE3MzZhMWItNTg1\nNi00ZTQwLTllYmUtZmY0MTYwYTYyMmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHuKQvxqAVRv1v6qS5cNr3S3BamYoxjSZVLVzFHR7tRraR0H0uz9xiAoRt6x8\nLbHStIlmdvQ0ZSiGx/YjjqP0uqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXAYWeqo10Yfk2hyEQR92+G/IvTowHwYDVR0j\nBBgwFoAUhH1jsJ8F+0u3aiaNgAvKSnlYwbowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA9bdqMtuds9WWUQZjTm1ItSIh+lLix0kHpGyXBpqz0IcCIFXvg6UtgZ4R\nVEUa+L1v/j5X9dTGQn3eP7uHgvvIgfUs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUCfr0wygJCNBI6DWZCd84ikMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzNkNWJiZi05MmEyLTQ4MmEtYTY0Yi1mZDg2MDJhY2VmNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6+C4BQJDFzFTvwvfeodZSbzyRalkTnnNTOYEILAX9csnJ\nL6wDphW31RaunnOWD7Lj+JNw5J79GKJItbKcRY1xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhH1jsJ8F+0u3aiaNgAvKSnlY\nwbowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMXaBiVYSmrb/vEU3+eONZg2YLVh1otjW7OsjpZX5eSHAiEApdFnc1uN\nL7lN1cy2ttCVowJ+AAQsLq6IOcRYc6uUlWs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAT2n9tfN2K3dEaAyujulB+4dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE3MzZhMWItNTg1Ni00ZTQwLTllYmUtZmY0MTYwYTYyMmE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZjQyN2Ey\nZC1hNmY1LTQxMTktYjVkZC1kYjhlYzk3MDYzMjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARh0y2zCHO6/JXo1/ePy2II5JG8+uQ0WLAxb40rA0963PTvVlgZMYWb\n7TUFSizhgheK+5vez7DgGcfjX53r8WVno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRcBhZ6\nqjXRh+TaHIRBH3b4b8i9OjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIGy1Xd4vN41uQ8qLi8q/hWicLs9b1Blm+GaTsTs3xiWhAiA2uXzdSBZ1xqei\nx5z+LFf8fgqp64b75k5eXIYFdvp+ow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1586", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1586` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAf82G5rHaSJ8Aml0Oz4KbeD5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzZjU1MWNiLTYxNDItNDcyMS1iOGEzLTYzZDNhYTQ0OTRmMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRmZmQ0NDctNmE4\nYS00M2E2LThhNmQtMTM4ODdjZWViNmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx8BKFojLzlGI2vWF5n9SYlW40GxYW/xKYIjx9RzQ3keRdjPY+Bj1hKwM0DDg\nv0v9mWVZRGxAP4VMfccL29yvDaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqwxMJP6dstAqRORsv34F/LTEMKkwHwYDVR0j\nBBgwFoAUTHvWDv4Qk86qw0cbbxKrpcl4QygwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEApRGPz156miH7paNb2JP8qTPF9wENdWZyjvIlWZW/\ntNECIQCtY86Woe2EW58rasr88Ft/gZeODWjG55ubdQn/taApSA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARNdXmahWo0Vxr0ra/XtfJA4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2Y1NTFjYi02MTQyLTQ3MjEtYjhhMy02M2QzYWE0NDk0ZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATp4Vwuc6x5jeiOnRdwFhd6/MLBRry+ncSqgYL9BcygI8/T\nshaEXWjtg8dFfJ82QueMUTZJvHrlGudbBqlw0txpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTHvWDv4Qk86qw0cbbxKrpcl4\nQygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALjzieJiLh+kVrCC3fHpZQXObXrM4kSaDbEKm3M+12r0AiEAvOlSMr0+\nDa3IwX82FoxTU7wD8gth7wRF7qoT5ufUrWY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAbwDq5mwdhG2LMcEYCznE+NCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRmZmQ0NDctNmE4YS00M2E2LThhNmQtMTM4ODdjZWViNmUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NzQ2MTcw\nNi05NmY0LTQyZWMtYjVlYi00MjczNzMxN2IyNmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARVVVUB1CiKsTu9Bz9zzCj8dwSJDgO2MlUkXL0xDSX7lI/zAsdEuMJQ\nH5imUUbpCL9yZeSZcVmceyHv9W7CqLzLo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSrDEwk\n/p2y0CpE5Gy/fgX8tMQwqTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDEwZf2X/Z+yHF5jDyRfSqgEw8TQSLIdTo2X261XxevVgIhAIhVZNTOJg0Z\nTroVl6bUZ5BMcuCRPuz+ddYOjJRPJ7ZB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1587", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1587` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAU7vneABB+249DM/zB+FyiBrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZWNmMWUzLWQyOTItNGMxMS1hNzYwLTM3MWRjYTIxODE0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTNiZGE1MTktMWU1\nNy00Y2JmLWEzYWEtNTY5NTYwNWQ4N2I5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9+QX+Ua8/WCFeg83ZPRk3xFwhoAx0U3xndvXdel91RVymP+baWt8y4H21lDW\nP02xPUMFwG7SuNut1ZRMyZ3coaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHH87P9JCMokWQZJ65mvKsY8vou4wHwYDVR0j\nBBgwFoAUOIgGYlrpy6+3+nIUJAW7X48ZZNIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiA4p3w1Nv2w4UoN+mb2ijsfitCtP+cPEcnkFpC1hUIO\nrwIhAI1GQw3G7vICA3HBuFKI+/3FKX6/Nu1TDeWxHu+CRZjg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdfysN3Dpuw4AphmTBu1/Sh3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGVjZjFlMy1kMjkyLTRjMTEtYTc2MC0zNzFkY2EyMTgxNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx2qHCfgiugx4PzgoaBHdMFO1yK0p4gR68QQ0cB91cZBvc\n12/J6v83PlaOixmFDhmVCMX1xJd9Qi4/N5VF96uYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOIgGYlrpy6+3+nIUJAW7X48Z\nZNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGNgIehGapu6wbI03+yEap5BrdYBqWRnGs21bxn5GpFMCIQDA70pHoSs8\n7N7a904FB0uP6nn1tz2nL/eOzaGBbHvTQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAYawluDLREzoQkZkpD7t4GNLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTNiZGE1MTktMWU1Ny00Y2JmLWEzYWEtNTY5NTYwNWQ4N2I5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NjE5ZmUx\nZi1lNDkyLTRmYTAtYmRhNi1lNWZiYWM5N2VlMzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASfhiPZ6XUMod8IMjE/ne8tGz7iTs+aVJ54i/4wMOmfvTCcrUnYOMda\nOV4BwSIKJyN3y7mJiGwUsYuf9dxzBG/Lo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQcfzs/\n0kIyiRZBknrma8qxjy+i7jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIDvY2WxrYe62ym4vpE+WUwtdwdOXJFtl8SOpkOLbPUjzAiB7e88Iy4/siIqr\nu7tgAw+qA7pXNtMa19qeY4fWe70bLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1588", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1588` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAY5Hgp163BKbMD+R7tLrmdSTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViMWI4ZTlmLTBhNmYtNDAzZi05MTA4LTFmNDBjNjk5ODMzOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg4ZjIyMTAtM2Q1\nNi00MzBmLWJiYWMtMTM3ZjM5YmU5ZDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHe7VGQLLCUZHi5ByR2zD1KfT/Xfk1Nvze5FU2ayKlhZnC8JaabckFvMTI3nc\nopEy3bNZLWPV8uxDmNyHds2vqqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgbf1oqNHAPdGFM+pzoboKGcK2LkwHwYDVR0j\nBBgwFoAUxGaowFHAUHil5O4C4AMKf9afhNcwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBOKmbbEQen7Fzx4tA6GD4gINvySSlkwOFAhOfveiju6AIhAO6u\na1zDHq69JqC/tpDFmxjiVt8ui/iZ3onVnCuK+mpP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXdSZwHJYh5ETriyNqpssSywMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjFiOGU5Zi0wYTZmLTQwM2YtOTEwOC0xZjQwYzY5OTgzMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATx8iM9OAxMoXB+HqBC2EN6w/2GcQxw7BYKDT6plve55Ipa\n3E7BJe0ElIwQV+4JjDAq2voTR43m5qlhIvXNSfnko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxGaowFHAUHil5O4C4AMKf9af\nhNcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQW/PC+UkY+WLAibjdWALAd8VgL8+ZUseuSFmasq8uFwCIQDxSGrO/3lB\nTFSp3sAuz3ZzA0uOukNLz8ILNAeNR4T8ow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAconv/lPC64WIyko3HKSaqLrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg4ZjIyMTAtM2Q1Ni00MzBmLWJiYWMtMTM3ZjM5YmU5ZDdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZWUxOTMy\nZS03OWJjLTQ2NTUtOGRjZC1lZDI5N2YxYzcwMWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR81mB6YuQHlwGruxM8p+TyXWMGKN04rjf4FUpshf98Ja2oMnF+4a2B\nRr+6hso+2PuHdzS2w8iAmETK3LlfgpAHo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSBt/Wi\no0cA90YUz6nOhugoZwrYuTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIGMTDDZPf+PPP0N5vUHaQAnGuQ5BQe2xAqYzl82jcY7EAiByupfApfE+mvbn\nVzEzPaLgAfwJ0OVX8BjqkN+6p9G15Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1589", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1589` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASDL1DWQ5o9Rl+33d/KFGUqAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwODYzZWRmLTU3ZjYtNDI4NC1iZmI3LWQ2Zjg0MzU1Y2ZhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjliOWIxOWYtMjBi\nOS00M2JkLWE3YTMtNjljNTA4MmNkMDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGWBtamBd7wcTZuZPHS86Nr0AMuoHLKBtwDHoI3x4KJHKrv9NyBcYN3aHLDt6\nYifWTREh+rMz6GxAhbotXdoX8KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUryVYLGni7eNLyv7Ns2StIRTOaYkwHwYDVR0j\nBBgwFoAUEAcDhKH7qvLwThhF3Mo+EFcLKTUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiA8mb4jcOnVoaSoHusE/9QXCVgWOHAi39BH\nzqznYp0LjgIhAPx68waZCVA8JGwxtSeuQ9gl9P7udwt+E0wN+nKOwTWT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATHwuEY3WzmVNUz4CZJD+rgMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMDg2M2VkZi01N2Y2LTQyODQtYmZiNy1kNmY4NDM1NWNmYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxWLx5HzNWASIPEg+S/XMVPjv5YHo9oq2+Ixg1yEJ+mydA\nodxAhMVE0ssFHqCSaI1VK+sCJDGMxQc0n17fOmS4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEAcDhKH7qvLwThhF3Mo+EFcL\nKTUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd1c+/s72Wv3+mhLAtC9jfo59VOCz15zWQs8yIh0uucACIF9PM75zTbMW\n9kngLnG2pDIkEuM5vYv7Ug8pwNzwD+6n\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAVvgY9aRBRFd4tUBPNXRem7vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjliOWIxOWYtMjBiOS00M2JkLWE3YTMtNjljNTA4MmNkMDU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNjEyYTA5\nMy1mNzFhLTRiYTgtYmQwMS00MWVlMzcyYzFlNzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQWfN3fZqb90Rawh8XoXluQ62YYWagBVCjnfNbQg/ibB6DzbigZ8S7B\nqBKs3hMM0jGREG/nWGtNjWRqFbmUU3ATo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSvJVgs\naeLt40vK/s2zZK0hFM5piTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDMHBjdR+DbZodtBYFC8rRqmC6Qaae10SldXqqJkfVwRwIgYuct0MvCxPCW\nuhZtIrUeb/bw4g4a6h8zMxGW9wtk4jw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1590", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1590` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXp1r10M5uZmiRniCRThjmLUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmODMyNWM4LTdkYjQtNDQ5OC1hYTFiLWViNWViMzhhOTA2NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAxMDVhMDMtZmQ0\nNi00Mjk4LTgxMmMtMjQzMmUyNDg4YjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWPtJgYBAtkG1qmM4XokpFFH6G2SeNIZxTX0Rlh7btIVdhd+7blVnA1uvaql6\nGlkq14eJsefH+5MkM6nTTDNnn6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoUjvtvkBfVM7oVoy0rnRlLhMI3AwHwYDVR0j\nBBgwFoAUATFdKoLbN17p9j1QgGiLeMj+pXQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAIv5YOCHHgTE0xcFjAdYc7VdzIPXTweawt\n6js6hoEwaAIhAPoF8dPKxvuWiNCcIm5za3flkPUm7CVQaUO21Ei0JQoQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZuk9s4kGI7t5Q9raOujrquqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjgzMjVjOC03ZGI0LTQ0OTgtYWExYi1lYjVlYjM4YTkwNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbjkNkSCtIV8UHH06aySBwKalM4gmqB+yDX7QzhxmOnx77\nc4dst9ENjdbbmLqurWfwwxSgQYHpSNLyvQ9HiPxRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUATFdKoLbN17p9j1QgGiLeMj+\npXQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPiYIwXLde8lVIX4mA6coWZEiBvpgkFdEs6yYqSSYk9bAiEAhv30u3z3\nzCoKKpY62OP+T5Pr7Ylc6HU6Aqcz04J6KDQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZEkLLl8QP8w3fzLVUABuru/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAxMDVhMDMtZmQ0Ni00Mjk4LTgxMmMtMjQzMmUyNDg4YjY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMjVlNTJi\nOS0zM2Q5LTQ2NmYtYmVkMC05NzljZDQxNGQzNTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARuvX+LiqIV/LKBd4Sp3RTeCi5DHU5DW3QXXiDaB4I3zaouevqV4inR\n6v7xXdPGH8AqOJjNiCbssWDZhVowItlio2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBShSO+2\n+QF9UzuhWjLSudGUuEwjcDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCICUpc/uXdhUGxot36IejzZloL5FuppRae90ENcelk6HfAiEAnIhms+Uh032g\nY1+7cecWla7UXGTxCsJ3CGBPcuJ6Ly4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1591", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1591` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQASh3aX6i7LwH9oqWZVZvBqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkY2QzMTNkLTQ3N2QtNGJmMy04MjNiLTRlYjM5MGU0MGViNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc0NGIwYTgtMDc5\nMy00MDdkLThiZDQtYjk5ZDVmMWY0YTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE90xGoBnwfqnLvCZADmJ+m5vdrmlkgReD1NQPtFPrjKX5F2pzFfYhOchqpJ6Y\nh0qbU/h8+iVrurKFd3+7Xbu3VqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU02vNeOmThaUX1pmnSWzsz2kWWEAwHwYDVR0j\nBBgwFoAU/RvedPUmBaTKX072g4gQZWwE6uswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB2AQbWl9N7NhnC\nvQHAOmjfp6N5TC7nCpIUdw9QDz40yAIhAJdpInKIUnGpizG6T/J7LRjMhmWPD+HP\nv3K6o8lNeAw8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVlbMvvaK9dw6F/tdDj3KQZSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZGNkMzEzZC00NzdkLTRiZjMtODIzYi00ZWIzOTBlNDBlYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqqhDGzy8qw4Xgftfi3V+cLDYjBJBgyuCgzu5yBHWfZwIb\nF8F1nR9Pke8+3aBTNLz4f+nQCl3FJYPrQeZZEV4Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/RvedPUmBaTKX072g4gQZWwE\n6uswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGTJ5Ota/cg9LmFZwyqQBtiw3wwFObrNk6etkoHJW9HACIQD4zictvV8o\nbMoCNlGAnr6T7qHs1omqRg1VSx7xyMmD6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZpaxYd5emxHV4OQyGRT3corMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc0NGIwYTgtMDc5My00MDdkLThiZDQtYjk5ZDVmMWY0YTg2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2OWUzNTgw\nZS00YjM2LTQzMmQtODg3NC00YmEwNjg2OGU2N2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASre3L+d3tQOt1HnekPWwdTyQWPTHdu2orf/v316U7GP16Aj+9vYxhj\nFqFvP7S4Zc/B+PUGmY00DhBjZArYCBfCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTTa814\n6ZOFpRfWmadJbOzPaRZYQDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIAYh+ECLltUXOGgDDt3BiJ5Wyr/dz2E9bE3cYNfKeoaqAiEA1Xppd9XR+ivC\nX43v91AfeYQyVlhuF8TScr80oUYpNlI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1592", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1592` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXuSDzABoAwF2MFuROkBkPjYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1YTYyZmU5LWEwNTItNDVhYy1iNTkzLWVhOWJiYmI4MDFiYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNiM2FmYzMtMWQy\nNy00NjEyLWIwNmYtOTMyMzgxNGQ5NDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4gY5YyauIb/TLLsiS6jTCjOg01xp8q+GfF6QW8fBahqm09vhrCIzQ73wbhuO\nQ8/krZ7t7mW8rihsrPthZFrfSaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3kTSUqDzjRnxS8BT4ROJVMhW2hwwHwYDVR0j\nBBgwFoAUTrys/h0eZv9W65bRuRNbDSSeJCowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDVylLQjhFCCYwK9ssVCLEkrEOixcplWUlnJzChDcBjcgIhAMZYfr5+ywR+\n2+BtkAvHxFuvUI9nRKbY5059Uan1t5Qs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdlpkc2ycfUAtRJBExLZ6OtnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWE2MmZlOS1hMDUyLTQ1YWMtYjU5My1lYTliYmJiODAxYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIjiS07ynerbzgsZ9qGAiINnQ53VVkVcu+s8TmxjOudKY3\nt3+mVnH3RJy3ceo4n/wwvHHSHwVwfgIbEiZGq+j0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTrys/h0eZv9W65bRuRNbDSSe\nJCowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS8tXzOtJCRERdoTkUBgVJZdoFwU96MMpIfcRFYgrITsCIQCQJK5UBpKa\nIQgpRCHLR3vPvIexgl8C9AYpSHf8LU8vcw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISARwGefeLjHDJXuI4CyOi5ytZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNiM2FmYzMtMWQyNy00NjEyLWIwNmYtOTMyMzgxNGQ5NDZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MjJjN2Ji\nMi0xZTUxLTRhNjktOTI2ZS02OWI3ODM2NWVlOWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARypCKhmfswsfnIOVnx+DSeVHEy08V/UdabdarbPJerlGZ1PfX6C6Wi\n03g6eVpxCM4ZrCdAJ6DaTG/9PHKTcvUAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTeRNJS\noPONGfFLwFPhE4lUyFbaHDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCh6IcAoYhqJ8t38DZQyG3IrpNmeHC+hgMya8QOMEfYZgIhAPZeUkUq6LPv\ngdR6HGVpx36UgYaOjiS8FcTm7I91o8MD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1593", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1593` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAamvrVbBovL5u+Fx/0iU5akQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhZjYyYTgzLWMzNjEtNGM5Mi1iZGMxLWQ0MDJkZGM5YTcwMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUzMTdkMjgtMGM0\nOS00ZDFmLWE3YTYtYTNmOWM1MzQwOTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbYsOAq62oPmIsEs4unHWj2usxmw8eXUvOfPJ6w6Nx+5FInlkq46rLiRywZtj\nQaLh4C892hqlGxp2WE32/nuz/aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU470vz1hXCWQe1KaiCUYTcq6+3OswHwYDVR0j\nBBgwFoAU4zlS/cf0pF3CJ8DcY46bUxWV8IQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDaSGZxUkozUh1RDaBVkSuQ4VoG9p6CqYIBRV4FMauuogIhAN+9Fw/RxHjt\nz17yTnPEs5+/D8iKZ6HwAz/36BVu2H/U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWFKYdFrOoKpmFdtCUguOk/HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWY2MmE4My1jMzYxLTRjOTItYmRjMS1kNDAyZGRjOWE3MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9phdkEHefJA60CIkCsqzOXOwnnTPtNVOJq6Fk4GUiNH/Z\nwolsheixRxXvazGdSl/x3l3TsgCP9Io232AKPFEWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4zlS/cf0pF3CJ8DcY46bUxWV\n8IQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdjj2gV3yKuYq9PkYKL7OXJVEfx1Cy0NoNtbd6Y2J7zUCIQDR2naRtFPa\ng47TBs1wkJVz8cFl1N6rXPUl9ugrIuwy0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAb/O4Up6jZi/16b1DcNeZ7uvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUzMTdkMjgtMGM0OS00ZDFmLWE3YTYtYTNmOWM1MzQwOTE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNWU2MWFk\nZi03OWFmLTQzMTQtOWU0Ny0wNDAxNjM2ZmQ0ZTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQF6CHpr52KgtiX77366g86n+MltZnxSJKTCsFqfHs8p+iZn5F96uw7\nyVASCJ1CxDv+OxrqunIVPr1HR+qRWVpEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjvS/P\nWFcJZB7UpqIJRhNyrr7c6zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDTDrJr+eimFJ5zFryUVdH4foTVe/mEQ9nRMjt7pLzChQIhAJcpTx/LNCu3\ngzb6Q+j172ImMovcri+BlTvFE2CWWG3T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1594", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1594` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAUNx5o3Aj3fyC/iuWCSraQITMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmZmRhYWY5LWYzMTEtNGUzYS1iMzRjLWJiMDk3N2I2MWJkZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAyMTdjM2ItZTg3\nMS00YzgyLWI4ODYtMGRkMmU4MTNlNDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEko4xR3hBV2V2SFDdyYMupaFm3hz7yr2J1XZpDYQr2V76t+FyXldLtgOPed4a\nLfTkfqUGBNvpIBRs4dsQRxTypKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUod8yNH9Dw/6bej9IEeI7VLEP9lswHwYDVR0j\nBBgwFoAUe9oERRMBJO9GLE4U33WMA3/zXy0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAxJRaGalUmUoCaA/qLOZ5PKCSCPb3g1QFALvIijKWxvICIHA9C283/vy/\nG2aDACNxqBQUywP1402G/SIHGWs0JzxZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd4QSfyFBTJlsC6JKs+/MbyVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmZkYWFmOS1mMzExLTRlM2EtYjM0Yy1iYjA5NzdiNjFiZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQldogWy2pYiRa11qfrj/M3Aaq/8DiBau0iTAy/PXwuKIA/\nv3JPUYTV2MAQzjqGvbunY3mGvmZ8OacvHCqC6XOuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe9oERRMBJO9GLE4U33WMA3/z\nXy0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBl866idPX6H+Xw23eE0Kh42NaEjNNt031spVHfFaSi8CIChysLHDa0uA\ntIefBIsboQNgQPuAcR6QKDo1hifXZK6I\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAbJuVawnBI6sMPSEMedPSg/AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAyMTdjM2ItZTg3MS00YzgyLWI4ODYtMGRkMmU4MTNlNDAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MjVmNThl\nNi03ZTJmLTRmNDMtODMzYy1jYTRmODczN2VkZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASh2xP5ITvgXDEwPt1P+lULjRsYb7zI7KIIECftM0aTHGd7Na3qjZ+0\n1t/CkY1qIYNkWvhHB4nJvvZLT8X7EQCmo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSh3zI0\nf0PD/pt6P0gR4jtUsQ/2WzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDjGcgBp3pDsI4MWJca7qvK2IwiahDb8lHOh/oeALx+WAIhAJXWntAsAYBS\nKQRXAvM+ToG8GQ6/yu92TjXl4pdPf39R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1595", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1595` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAS6JEO1F12ozS3bf8za1pJBfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1MmFhN2VjLTFmYTMtNDFmMi05NmRlLTJhMDIxODg4NmZkNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY5NmRiMzYtYjdh\nZi00M2YzLTllNzQtMjY2M2I2NGE0MGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGX+b5jHwa5nI52GU9ArD735KjJ1IBsvJFwfXrC1gdxIS6nPKt5G5MrW/+eVx\ncFquNJCK2NP3RCVipCYCUKxJKaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+aht1G6QQb9cskk+2/G1USJ7hNQwHwYDVR0j\nBBgwFoAUcImn8zzLwD8jH3aEje3ouySlKMMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBZbiJuB3yIFMFVBzpeWE1MHoMWfy7qtgTPqVDjibRZ\nRQIhAM1CcNLFB74Z0ih8psSMnbN/GoLWx+Zt7T1ttvUVrSrs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ+zqgG/HPjSmBX7ObvarTmeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTJhYTdlYy0xZmEzLTQxZjItOTZkZS0yYTAyMTg4ODZmZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1XtLQhwRn0Dmje9Ah/dhwBO0VD+5/uWmhJ02IUWD8x1bc\nq5jIcao820sgjsOWMaCtL9zJWqTDKz+Px8amLdFYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcImn8zzLwD8jH3aEje3ouySl\nKMMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVU4TIv3HO1cYBs7gbXtD0rorAA92fRgJFo0EPGIP2kUCIGVb/QMxfZVG\nf2MRtH8VGOKt69hbwuP1PidPs/5D1KyB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAd3gLtlLiB2ltZKjAKr94qhSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY5NmRiMzYtYjdhZi00M2YzLTllNzQtMjY2M2I2NGE0MGU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MmQyMjUy\nMi0zNTY1LTQyYzYtYTU2My0zOWIzMjZlZGExY2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASLb5LtX1ldD7ZW1rMeuLKdWvujSmrMupSZurakV9lI0nta5AfKuoUq\nGbB2FHuxD9bdslPYaHxB95gEN41nkA+Lo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT5qG3U\nbpBBv1yyST7b8bVRInuE1DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIAHMzRyBahPWkcnXEIhqhLPkaOscrI4bGZHh/et6XvK3AiAEMc0OQmOSHYSe\nU18R3BJcXpDy9d+z+8rc7KebHK9tYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1596", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1596` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAfEfG00bZS3osZS+s93tHioDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2OWRlNGM3LTE1MjctNDJkOS1iZTA1LWVkNTA0YTVhNzk1ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdmYmMzZWUtYmRk\nNy00MzAzLWFmZTctMGY1YzgzNTA0ZDEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO5qc1ZIJj6lrLK+0Adf20TPuC0ZhM15FMEkqjF/yEfb66QqvpqeK9LDHChpe\n22qxHYvxQ/J0oAGO+SsEtNjtR6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxho1SrRRcQFVW2gkUfInIm5t9pAwHwYDVR0j\nBBgwFoAUCLay+RAQl/srwkqvgwf7NTSkNNIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAiaCcrRSTM518gikxEfzBoKSYEvG5MomzXN/75tfZ\nNgECIQCejGmxM1CeD+vYfHozq6UX7hUHhnrhTSbTciTcd/Lz1A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVR4d9+IHVkVJ314QfL4pLyQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjlkZTRjNy0xNTI3LTQyZDktYmUwNS1lZDUwNGE1YTc5NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnGdxeF6lpVBTw/VdjSm7FW5ak00ySzsD+w94uylKQ+KCk\nnZyr0M6xnhutHXMBXQcuLmteB6ZjGr/WB2sqAvMYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCLay+RAQl/srwkqvgwf7NTSk\nNNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAICuv7oZ2jkHNwXEjaiF2b4rXzToJKV91AavECCxCLZNAiAaGY35ZYUy\n3wThmolFc5488qR578uTYLQ44hTEHmgUIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAQR0jIF0vdgrnZBR/C3685OUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdmYmMzZWUtYmRkNy00MzAzLWFmZTctMGY1YzgzNTA0ZDEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NDc4YTg3\nMC00OTIxLTQ1YzEtODcyMC1iNzY5YzFiOWMyNzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASbJ+CskZ8CcgjCjrIB6K5YeQyt7CXCP4slMjYwQHZd2t0FG0eg18tn\nndP7Qx2Kb0xatgfAOHLy9XbFUv9CWZcQo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTGGjVK\ntFFxAVVbaCRR8icibm32kDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIG0HN3tO6atyPjpqw8m/WpBdILNtzRUUsll50XW/0+p2AiEA6kfUEVZVbiw0\n6cUNW+LHv4A+MWH5YHrGzZW/sz90DZo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1597", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1597` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAQsc5mcbAUjb8mQum/ijAKELMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiODhkZGQyLTc2YjktNDNiZS04MTlmLWIxNDI0NDJiNjQwNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmEyMGFiZTktM2E5\nZS00ZmNmLWIzMTMtMjU3NjEzODkwNTFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz3qv8PKoWNV0FxsLlAzcpk6EU4ZFkalO2N3+Aah/YjunoGERiLjT/dCLHHa5\nAYOm+IRp3mIyKj75SSYGQqTemaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdfRy8yIBoLmcAVFZ4jx3AZfcc8owHwYDVR0j\nBBgwFoAU0GEQDpnqziBhTWVWaS4k/SVwVtEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAxYqXon7Lxjr/7iuJDLTFeVoyVM/qSXDFLFGBkHDaTVwCIQCK\nN3ixM5ZFtA8yJrGSZJpoEazGeCKsjSMZFix9ULq5eQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfvkCwwODkIJxFTSIgWjkJp0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjg4ZGRkMi03NmI5LTQzYmUtODE5Zi1iMTQyNDQyYjY0MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbLcT60cGW1CierzC/sxa9S6CmOWcUaESSpUvCVghVwrlP\nPCJp220HGubhvkHKaj+rAAIq0NcxdpZ4BavnhZ9Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0GEQDpnqziBhTWVWaS4k/SVw\nVtEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANwzTrLjKLT/oVrVzLzuqRdpnqTT1q6JDAlV46TOHAI/AiArrld+dPg3\nwKWi78MXziv5KhSbvFeTJkby7CUW/8swTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZqYyUwzQLEPX/mlhP177aGdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmEyMGFiZTktM2E5ZS00ZmNmLWIzMTMtMjU3NjEzODkwNTFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzODIxNDYy\nZi05NGUwLTRjZTktYTc4ZC02MTJkZTU4OTA5NzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQH+7f1i/++AW5kMohMzatx7OMSA8yxz5a0YKKEjP9WCeitYOG+a923\nZD+XDEtVKpz9YAp5sWieTy+WY6kn3tveo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR19HLz\nIgGguZwBUVniPHcBl9xzyjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIAGQUwx7axnBvu2AuxjYYHSLDkEasO0D5HNbUJQTDMuOAiEArx0uet3zo02M\ns2PFVyH8n7VJB4SByM0fCcdjUomzkqk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1598", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1598` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAU0tyNPaHWm33jiVGZ3X8kzhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjYzg5NGU2LTljMTgtNGY4MS1iMjVmLTZkMjE0YzI4MmRhMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlmYmJhMGUtOWM5\nOC00NjY1LWJhOGItNTg0MjllYjRjZGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4U8J5QshpEHv4tumCHhnx63o9VGuSHdt8qq0eQzTcHSmpzNyrxTq/3a9QE3H\n+z2PSQS3i/XdiybOEULaCFDLXKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUN71CdLKmgLlniKG3o/vXZhnFucwHwYDVR0j\nBBgwFoAUYbevRGf4cHl1xDMVY6G8/Hnd/j4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAj+LZlFGBIuWgUqmmZfUKOmnIDK5qIJXI\n9pO9AyyENfwCIBSVY1hBxUEFGVC0CTe7hiFLeiXAzXhSsYrmWq+UyczO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXwRZcS3DpbG6eik3Kkca9nbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2M4OTRlNi05YzE4LTRmODEtYjI1Zi02ZDIxNGMyODJkYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQddwxTkMuGwsmv/jfEqCSR8lEpMg4s/y8W5SmcggGolrl1\ng4uPx2GIqFPFUAiq97rkCyL05cqT+ajxMQI4oHyro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYbevRGf4cHl1xDMVY6G8/Hnd\n/j4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK+qLrAw8KG1jvxGTDpMJeil6LSJ94w6rrmVprDQmec2AiBHpTd4n3kz\nzLldkX3zFOLtTd2bZAQ3ZI9163BBAA8krQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAYWadnngEIXvQEZwGRtGEQknMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlmYmJhMGUtOWM5OC00NjY1LWJhOGItNTg0MjllYjRjZGQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZWY4ODNj\nZi1hNjE3LTQ2NjAtOTE3Zi0wNTA5MzMyMTgwZmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATtxEV3saTuIwbPaC0cHQONq+qnuuORaHqRw0xesloY6Jhg4ABWTmFO\nfvHDcUJztZ88PXZ2F7kGGDX6YaQjdugDo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQ3vUJ\n0sqaAuWeIobej+9dmGcW5zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIBpR+FuPa76yOk1797sc6u7ByF5ehqYRKQPe5lcsEMB0AiEAwo3f0ne9W0BH\nD3cojxcXCs8yv68j3EFYYJB0eR0Tn5U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1599", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1599` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXFo4mMqhUCPFWDBw1z0gOJbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1OGY2OWIxLTEwNzMtNGIxYi1iOTE3LTZlNTBkNmQzNzIyYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRlNzNkNjQtNDYw\nMC00NjQ0LTk4YWQtZDE5MDYwZmE5OGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETKuhGWtti+1iDGozCVD8HTX7EhfpfUUsRa+tRdWXNnENgliCx0mlVy6A5AeY\ngUgr+XmwuFcZrxUqZskjgmiLbqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcTg7s+xr1TpZbvML97hFUnBEWf0wHwYDVR0j\nBBgwFoAUI8WwQfQIsTO7xYwj8IbPb62QfLgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiArKRB8uUjX7dnehaEbnYY2NadQX1QGlm2H\naaXS3Ib6sgIhAPaH1ABDHHmXslNOMtZ3SVG6ZUOyHDWAixFFN+SJ6rXJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeXi5LPCcidgWPywIG6Y0Re8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNThmNjliMS0xMDczLTRiMWItYjkxNy02ZTUwZDZkMzcyMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATldxWyP6z+8pYUaAxdVb50ZtPAGl0n9o9GTgHL4h3sZRLy\ndUpY3rIFO09P3LNJxRp4hkIZ4fMjKFXa0PMKPYc5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI8WwQfQIsTO7xYwj8IbPb62Q\nfLgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEm+J7c4/azvFAwJNOEbnYJYgtkF6kPEygiTYN7RBtNgCIBM2Poa9+Jgj\nHNnsNlI4cSMzRKiB9nuRgz/5hXztSq+4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcmgAwIBAgISAUGqJEYg0zJxPj6AvRgpfiRNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRlNzNkNjQtNDYwMC00NjQ0LTk4YWQtZDE5MDYwZmE5OGNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYzc1NTVm\nMy05N2QxLTQ5ZjAtYWQxZi1mYzMwYzFhMjE2ZGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASXNTaFHShTwVM5TQJqYAPAEo+qmyAlco+upPIpcHanpBq77RUEOvoG\nokmQdkQsgGR6oJeuioeHeCvuehDQ71IGo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxODuz\n7GvVOllu8wv3uEVScERZ/TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0YA\nMEMCIFqHj6rMiH/P6+USbCYyQ6j3fRfiEA1gFJBhxYfnpUy/Ah8lkw/Hck0IlxSo\npRM889mDJm6QkBSbFngjM/08H7nO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1600", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1600` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAYo4dxgHWh+6Renr9J5yd16zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkZmJmMDJiLWVlMjQtNDM4ZS1iNmVkLTk1OGQwMDMzNDQ1MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcxMWVjZTMtMDlk\nZS00ZTdjLTlhM2EtMmQ4ODA1Yzk2NTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs8gWTs25ZXQSxNkjUNQM3ewSCjBpV3qw5TXLxeJRNJmRgpLq0tyNZALTdWI0\nByR6rmlU1Ku9qcDRDeYHKaGogKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiTGqMxRkrFWR87KnBwtsoPD2u+swHwYDVR0j\nBBgwFoAU46oJ38FjrbCrcjZYKFKNiRbzlrcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIH1ZW5anDi5vpv2pKrQPACdqJjnU\n5UlSYmf5BpOP2d2/AiBsYCNDhL2BPWn4a5BhxW+fI+1CPn8Nsmo6UpZ1PyKhJQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATkRhMHwmRXVM2nCJRzwlMNaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGZiZjAyYi1lZTI0LTQzOGUtYjZlZC05NThkMDAzMzQ0NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpdTjrdV7TAX8WcYTHFxy2cqt6M+oi+vwuCE3ayUt6gmp/\nnGGdc/xA4uRpRnR+Ot5XXI+QSHl83KBOo1KFQfDJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU46oJ38FjrbCrcjZYKFKNiRbz\nlrcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQVbvFUyt/1Ut6rse9FUPWsvSHzCRD3upFKeFA6pKpsoCIDWzqA2T+zdK\nijVaS5I65gjsokLOepzoM2HBUdawfiM8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAUOAf/TwXJ6gueXSOVKG1jiBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcxMWVjZTMtMDlkZS00ZTdjLTlhM2EtMmQ4ODA1Yzk2NTY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMjcwMDQ0\nYi04ZDI5LTRmMWEtYjgwNy04ZjAzYWE3ZWY1MDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASLOuLo84Juc4i++WZ5+6AmAmMYFR/FqxewZmZbGD/BoelcjnRoldId\nRdDF3t+gJ0EJhopQnS/o1jPKpYV0as/Ko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSJMaoz\nFGSsVZHzsqcHC2yg8Pa76zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDKa4ZsXEs89jvVICMhIMggu5qx/R2xk86qWvhKsMxSWAIgOyaZlxi03a+w\n3BZSa3NV8DvGTq7xgiOB8M95aWqhywk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1601", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1601` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAe63vlFkEASlVVsrLtEu0ZHMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2M2EyNGM1LTY1MTQtNGUxYy1iYjcxLTMyOWU2Zjc0MzQ3YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFkM2E2NzEtOTU1\nMi00YzI3LWIwOGItMzk3NTFlMjU1ZjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX5FDbyFJZlg/3QOIp+wPgeEu45iKvaEu7OJBw6ddZL0pZ4O5YBQE3JGPGuoY\nvOzWNxUZ3cNvVjLCH1+EbBZS6qOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURT+5taGgEfUYPzgN+qsr2oHfq0cwHwYDVR0j\nBBgwFoAUSU6EUCDSfWC5irzE49oVq2JJXS8wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgem4NvksO\nxrYfqddvWwN1Qk2g/Aea4TtfSZJE6jbjwcoCIBty7j/v62AaeIDc0E6ebrkOD2RO\nWOXV1cW7FCcQTLqF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcJzFiu0jJKDP1NuEen/jQ/mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjNhMjRjNS02NTE0LTRlMWMtYmI3MS0zMjllNmY3NDM0N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjj1pYeOGEQn1hykXmRy0s/j+CKYs/V2FC+N0LHPNWscvc\ng4k9uONjj0Rj9VHhe7rbGefQuH9HDA7mNuZTlZWZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSU6EUCDSfWC5irzE49oVq2JJ\nXS8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPwhEvsn2ozFMNi/d4fr1jqX+/+Y/HQEUrXphlhL15KdAiBik7eR1cel\n6XbJCBL/gOHVtT6OS5ej7JXeKs3Fxb85kw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAbQdx5CseJvjmjiDol4xi9KiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFkM2E2NzEtOTU1Mi00YzI3LWIwOGItMzk3NTFlMjU1ZjY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OGQxOTAz\nMi0yYzMzLTRjMGItYjY5ZC1iZWEzYWYzMmY2NmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATjoAugQdrEr+YQ+82B3R4m80GYu1ZxYwa07qOhxnOLoEnfQIsoLgDx\nH9qfHfX0cgx+PnCOmt6pKMEB9OORSkXAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFP7m1\noaAR9Rg/OA36qyvagd+rRzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIFyaODOGJxi/fGIiuHA0cVOjOedM9HIJmN7LNBzTk15zAiB5alMJuN/BLZPi\nwXSGO1NUw12OQTnz0B9H5izSnxkM2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1602", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1602` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAbz0RTibe2t3c4QZ/eioFD1xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZDdkYzYxLWNjNDEtNDMyMy1hOTYwLTg1ZjdkZDlkNDg3OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU2MzhkNWQtMjNi\nZC00OTNlLWEwMDYtNTQ4MmI2Nzg3N2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEizH5pJx1XX6X1rZfZVxvVkmKUqzaAjh95sriJlR1g1qXRoSZ8BYhc5IQpLfA\nMPC+dXStKV1uOS+aTCHsvVittKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCRsSzRAUUacjyq3D1s9fkrPgck4wHwYDVR0j\nBBgwFoAUI5fvbqTIZhwayPdpI/gbzOAmuEUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgJTt82FuJ\nNlgbRMsJ4lfuAPbfdkfPnLvTEWqSihxJI9UCIF6LXF2SxJHBfq+39tPR8Wj2oG7g\n5AgXElCA7XA5lkMo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaVfTjOv19i8tqSihyJbzssKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWQ3ZGM2MS1jYzQxLTQzMjMtYTk2MC04NWY3ZGQ5ZDQ4NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMXwPNGckWdDVCQV2oWe5HFe6e/x8JZHiV5g0C/MutiXmC\npb6RnKdPsq94LD6zf7k+WJI62AFEAuKbCuXY+8/Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI5fvbqTIZhwayPdpI/gbzOAm\nuEUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIVDvNoCo+NOoF1IygC5MJEpX/n1LUwFMUA92RI1uLnwAiEAh8HnG9bz\nUg+yczUBFwfAHfqwgzCO8atUnsRWITMS7Sw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISASrT3eQDEUJlJil80ErPeN+oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU2MzhkNWQtMjNiZC00OTNlLWEwMDYtNTQ4MmI2Nzg3N2NhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYTA4ODgw\nZC04Yjc1LTQ4MGUtOGI3Yi01Y2Y4YTVmOTY5ZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATJbw4V5tKqR1JJD2Z1pagqovg2qV8e2tZxSx/EYh6azyP9oqepC8h8\n+DIO7ECpEsGPt3erpIfDh00vHyyBHh7Uo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJGxLN\nEBRRpyPKrcPWz1+Ss+ByTjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIAm/BOGrMvxMnJ9HlNGsNbm+MU9YGA3O1B4u8pDWo35LAiBqlLS68HcvK2o0\nexnKNTQ9YqaFSQHmTD8F2mVHOE9A0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1603", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1603` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAekU9ctG+G70s3v3pZ0iPupPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlOWI4MGExLWU4YjYtNDc3OS1iMTliLTI0ODAxMmQ1MDc0YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFhMWM2ZjctM2E0\nMC00NDE2LWEzNWUtYWRhMzU5ZWE5YjEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExMetDCqTi/NG4LOqPQtzS4QHGOYunL+GY47YK7prVPNoo5LNWhHp4/PJszu2\nbwri8FL7jTMYimj+Wu+2TcR2waOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5IidiQSvbTY46D8OuppOloThCyQwHwYDVR0j\nBBgwFoAUSULnjwSS5bpB/ld3JNaqX4n8yo8wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBS5HECg\n9AETmK+Lze3YHq+d6ifnk9a0eIXIt/gbBELbAiEAknGUxju5wH5HHwMi4DNn2oXo\nO8ENVCgYHmaRRM5ppSc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAadUe4nyOr5kv2cIVy8FdWs6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTliODBhMS1lOGI2LTQ3NzktYjE5Yi0yNDgwMTJkNTA3NGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIpDre0z5YTv7RYRVwSZK16KCCLf4FyPKOB53j8DTeD3xx\nQqueWKDg5HFg3njvTP9CFXI6gioTor67/C7Sz8Odo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSULnjwSS5bpB/ld3JNaqX4n8\nyo8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOo/Brfv49rFlBeMA5vTorJJ4RO9qpdnnx3oggl/EkH/AiBrV9IoS44X\nNuCWf8U8xWRNZquWowTVn7VHDLqiY2ggLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISARBJyQEpxec6uid07VQHQIZXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFhMWM2ZjctM2E0MC00NDE2LWEzNWUtYWRhMzU5ZWE5YjEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NDcxZDhh\nYS1hYTlhLTQyNmQtYmRjZi05MmEyNDY1NGQxMDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARrYrBfRsKAl0/+iuFJgQ2AIGce/Ow/N3BWZYed/PO+/IFhGovEF4BG\nXMUE/9B30q0Wa8cZAnnGRE916r83xApLo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTkiJ2J\nBK9tNjjoPw66mk6WhOELJDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCkiKTJ8fUmDvuyYerViTgO1Pl5OO7ud3RLCdldLXBhaAIhAKznglncnTQ/\nyDuVpB36jr+agoYjboqGXRPpapDbHtrO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1604", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1604` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAd5jnUwAuPEqyfdizbVTn8cLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjZWExNDExLTZiYTEtNDFmZS1iN2IyLTcwNjFhOWVhNWU4MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQzNWMwMzMtZWU0\nNy00ZGIxLWFmMzgtNGYyNzFkZGFlYWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkRbdOTQt5GnCM51Y2fX1cV+v2jZMyaUHOrsw50HDC9Lzx4zI2dOTK9lSrNcw\npnfNtMSBdE0tvJfhMU26pKybf6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQSpWNFrLA5MsJM9ttbSIvoLlR7swHwYDVR0j\nBBgwFoAUxvqfsoBtghKvXGOZrtrZ0og7VhwwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDX/1NGsZsCuHVGGEIg3rm2d2jQ/LotELugX8A6lfnu3QIhAKc7QnOO\nQJrZLSZt0oQtJawkfso19+PZj/NLFb9SZMol\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWKsU8B4L+yDMNOL69hv1WqCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2VhMTQxMS02YmExLTQxZmUtYjdiMi03MDYxYTllYTVlODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0PCtLRbKW7Z8KfpqvHpxrqnD/9XBNTwQ7bfrMYKcu0X4P\nGgbqz8bFbAAA218fmTRCtUFbWC1uWsQiBC9R4Jmqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxvqfsoBtghKvXGOZrtrZ0og7\nVhwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGP+Reni//ICGWdaeQsvVFAfS6o4dd0dFhcCddBbVIukCIQCs0CkCWttT\nL3m1ALvWSDFyS+MD3SL+Uj/l6fEprhYIog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAUDx1WcJakdTsn76QfPwthfcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQzNWMwMzMtZWU0Ny00ZGIxLWFmMzgtNGYyNzFkZGFlYWUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYTljNWFh\nNS01MTVlLTQ0MDItYTNlNS1iZWRlZDRmMjlhZjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARRNWrolxKhHVe4s0wTW/drtojWj9Q+qFpx1qgBLY7+h0vL9IJsVjM8\nDs+ugBxWfga5QnPjxZNvsvtPwPJ2BUhUo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBKlY0\nWssDkywkz221tIi+guVHuzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQCBhMYyEsbcNmU+vqrXaW0YsUb87Dypg+mw6sxsOWIxdgIgGLbXfcn6JEl6\nhu2p+FqL+upxBPlFSZCv22VJJplM1Zo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1605", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1605` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISATgR4ehxpHUY/lTO/loBI4nnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNGNkZGViLTM2ZjMtNDQ4OC04YmRkLWQxNGY0ZjdmODFhNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTliYmZhNTctNGQ2\nYi00NjRiLWJiZjMtNjgzYzMxN2NjYjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEygMPWwGKuvpnJTAGOSTnxIOUTeCXb3QrIrWRhN/kEy2hts+XhgT1lRV/yXWa\nA9bM3MPJZtqf6O7oebXhloAwnqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+DfQzbsj01mwHCaFnSbO9PfTRvAwHwYDVR0j\nBBgwFoAUGHYDrpwUgiF7qms/Omhxug2MExUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIDvNTq5LcY92OlDs8U/6w30jAvfWOJedk4XumBf0Ogy6AiBEkv4sYc8b\nBX7MwhC6WjcNZEKPAzRaWF70sHcpM67JUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAawSmRaLZHER3muEfAWVijIHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDRjZGRlYi0zNmYzLTQ0ODgtOGJkZC1kMTRmNGY3ZjgxYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/+k/SHrKsJbmRSLFwdlCdFj+tXsEVpAf+ZEy+J0bpNw8P\ncPo8bEYu/IeZ96MdNWO48asTMRIrdBDaVqKfdVPUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGHYDrpwUgiF7qms/Omhxug2M\nExUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANhfl/yLDMcdiUGYkjZCv4/kiTCrX4DFnjRlWOJBSAd8AiEAkAIG7Mse\nMCcv6nto7eMMvqPybduEXSrS86n+1z0mAjc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAWswaOiaqv4J3AlPk4lWJOC6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTliYmZhNTctNGQ2Yi00NjRiLWJiZjMtNjgzYzMxN2NjYjA2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZWE2ODU5\nNy05OTVlLTQ2ZDMtYmY1Zi04NGMxNDIwNTk2MDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARlPZlvlLhdb3fKUHBaGUTvnHFJjzA+oY5wWgm+ufJaRiWCaYdzwBPz\nwnLgT2/+WHtrhbpBKmebz+1o9WP3ByZMo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4N9DN\nuyPTWbAcJoWdJs7099NG8DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIFnc2XA0p7gLDAwQ6i1qLCTcyWO43Dl5vtw+3RW9pHUIAiAOdeLVlJLD/SlN\n5Nx64o3BGC33XvA7HYQr1rZ7/uM1tQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1606", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1606` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISARAzDKTo0cjcQEHsDGR+zb06MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZjFmMGEwLTJhOWQtNGI2Mi1iOGJiLTM3YTIxNjNmNWFjYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNhOTYwODYtZDFj\nZS00ZTdkLWJmMGUtMTdhYjMyMzA5NzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEypHYguK55cTddsr0r0gGqXVxK0xlKD2Kp6xEE7wJRKWsD/dNlhxPxh/1SUgI\nuFQrquB6B0vwm7cIqrS0fuzZ6aOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4qQ3tzHFgFwe1G818F9lRbuFPyUwHwYDVR0j\nBBgwFoAUn43wByJZeWFqwTCrn4PIkxxUXMIwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIBzqPotDnLtA2CWVbX2mvOhReNVFguFjy3b3258yywL4AiAxzqxXzuYv1ZvYa7eW\nXj72qCjStINTKurlH9JCDZcyRw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ9RK8zm1ivsUR945I0yq6wiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWYxZjBhMC0yYTlkLTRiNjItYjhiYi0zN2EyMTYzZjVhY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSg42uyB9+i7N3l+fM8dJloL92ozL7J2hDk/Uy5azP8EYn\nZjyAjl9qZTIudbFr32IDv8LNI18vQgtRAZMhvo0to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn43wByJZeWFqwTCrn4PIkxxU\nXMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO5/MTE7Lq9KuKHbSIN6Zod3eWNoMGeCw14Ae/mfNTswCIQCu3doRjdeI\nUeScq7d4ZiwWUY8xMXOdu86j90/auGGmrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISARQIi3Pp5nWC95/rT0xmd4wPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNhOTYwODYtZDFjZS00ZTdkLWJmMGUtMTdhYjMyMzA5NzBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZDdmYTcy\nMC01NzcxLTQ1YTgtYjI3Mi05ZDQyYWRiZTg3ZDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR0iVejB8C+lBU7eOKFul4CmSQ7GPaJbWAiGKfDaIAzpeiuVWrtlvGA\nqXQBbfGn7KADsVLUbSUEezMbdPPkuLX5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTipDe3\nMcWAXB7UbzXwX2VFu4U/JTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIGcj43WpzZqjA0Tn2F96ZQVwHrluPBgnbg3Xz2LP/Fr7AiAJ36SrrFD90lVt\nRvxN9zswvI6EavkP7md2ChcV6bTs0w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1607", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1607` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAXzUn5ZOLqHRpYrLtpiEM9UMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NmViYTI2LTE2YTYtNGM0YS1iN2FkLTk2ZDY5N2U1YWNiZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDllNTI1NWItYmVi\nZS00OTM2LTg1MzYtNGU0ZGJhZTRjMTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7acXBk7LfoNa8iO2o1Ef15vYux3hrBLpqr4W85dr+cdzzTvHHBhB1qlNGPG9\nQISTHU47oaEVkJW0FsA6jYsigKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUucVjFg0ZQpsONV1oGDO7+Ndl+/owHwYDVR0j\nBBgwFoAUu+FIXgo1Ds37ghmowex50oEHkyswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCbX+bxT7nHDvmLtjIOWuIXFn4XizPgBxUutJX+nqyktQIg\nSWUO/43rjsiFmb3tApEmwFi7nfHlrNgOfoAv0z9YkVU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX0Ced1aw0rCWibXqyOlZ+VMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTZlYmEyNi0xNmE2LTRjNGEtYjdhZC05NmQ2OTdlNWFjYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/Uos04z8sWeEfsYTiDtf6VnQJkZroDovtDl4U9t54d5Bv\nJBMBsrUNn9alFzfbSIVDYXvoPAqRrf3ncTXqnZOpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+FIXgo1Ds37ghmowex50oEH\nkyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcEnuew/y59f7JgJogBVkcv4rCy2WfyxAgNLqJLiNjfoCIDTQLMDeEI/c\n72jRRPz55ApRg9Ok3GvR4vWi2S3c+3XQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAczJaFX+lsDAMTmu7E6ubJpwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDllNTI1NWItYmViZS00OTM2LTg1MzYtNGU0ZGJhZTRjMTA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MTA2ZjZj\nNS01ODhkLTRmNDUtOTQ0OC04ZGE4Zjk3NWRiYzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATqSHSo86ep5carJzcLUeppG2PvUdSzY+iDDAh3cG9F1rpP5gmbT1Ug\nd3paC6pif5/56GSdHnhChF7wblpagBomo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5xWMW\nDRlCmw41XWgYM7v412X7+jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCGQ3HxPABk69cBKcO1r3JqvC1oAFWbVnkoX/6Gjxr0AgIhAP2js79K+zkQ\nJ2Nt3hVJ3ruUY39D1IPbIaeGKzjWmRmH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1608", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1608` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISASAOLQ9F8i+uqZWp+YuwhTkuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMjk4MWI1LWQ1YjAtNDRjZi04YzRiLWMzZTVjYWUzNGJiYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBmZmRkM2QtMWI0\nYy00NTBhLWI5MmItYzQ4MWQ4MmQyZDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbSYZSMGZMqJV6D/ca6a8wYpPaawSVjSFKGTEjzESH+InxMSF7YAZbXL6PSC1\nddx6CXY0bqHKGyvGKiulVhyi9KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6KxMkljmPdofYkfArJx9K54SM+UwHwYDVR0j\nBBgwFoAURVSWU/eAgfThyoMYHFCVzK3p6nowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQD/JXH9lVjEu4XwbcxpnJZveNeqP3DsXVOQZjanlH2wCwIg\nXRBGqJnXg2yb/uWbIaU/GtZ2FX0BxyA2w8Ch2p5uLXY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT6pLYvIRoGFDF0AOjGD3Ic6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzI5ODFiNS1kNWIwLTQ0Y2YtOGM0Yi1jM2U1Y2FlMzRiYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMDFiKZ3psyE4inl/L4H6RnWxX2rvKGxj74rL2kGxNaTFx\nPGdi8i2d659t7qGTiX1z5++6kV0bpCUiuLbRRnJyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURVSWU/eAgfThyoMYHFCVzK3p\n6nowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKtFNuZLwea0uU1vLZMjHfupx3aL1SbVSL7FWEQTzZ73AiBCgyUreHYO\nr8+/tTGGvowhQAaj7lCsAS8pJWXFe5B/JA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAUiYa6wIfvJ1IuyDOo/72EbqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBmZmRkM2QtMWI0Yy00NTBhLWI5MmItYzQ4MWQ4MmQyZDY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMTNmNGYy\nYy0xMTE5LTQ0OTUtYjk0Yi0zNTQ4ODJlNWVmYzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS1OfEeQFCwAmk8OSY/WeGWve2O/cBJrVSH2vrqZTy7h0MFaDx9a3Hy\ntz2VJIY1za988GMBD6BHqEtIx+OjsNO2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTorEyS\nWOY92h9iR8CsnH0rnhIz5TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQD2GXiqO36iTM5URs3JSkBLo93KHjeXz5hZrXLHPBtnawIgMGZOWyJ2CvGh\n/zTOIhIWElXIhcmAT75C97fJojNnHaQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1609", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1609` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVLu2IWAvr4uIQJrZAoFJm/aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1NDFiNWM1LTNkYjItNGM5MS1hODA5LTBkYTMzMjk3N2Y2ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM0NDliNDctMTRk\nMS00M2I4LTkzNGEtM2UxNmVkOWMxMmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERy/1OunN4KWMa5EC4g24lQAkCR6NkaxxGB6Zn4DNLHDH2M0PHnlsb8XXsc1U\nFqs8VJgVF1SO11+kIz+PQPBogaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVlaVpySbJz9eXzPJvCafeppEytowHwYDVR0j\nBBgwFoAUNeHfMXQKZBIZin/EkmGNKr0qorUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHsDQjxmm5zK\nrPqforZJKz0lUBGbRguIzl8171rRgGN2AiEAuVNKmxogWicheFTCliDwKe1ZXSNX\nxg+sMWQmbEHMbcg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARtH+6JmL7eEL7PG2sDRzz/cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTQxYjVjNS0zZGIyLTRjOTEtYTgwOS0wZGEzMzI5NzdmNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARH5tGkQoyohkFK+oudxSZgKrV0Yo4Ma3VDdkodZq4MRJd8\nRbJ8inxmv50Y8Qp/HllpvQHZSOX9KhiRMe3yvGHso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNeHfMXQKZBIZin/EkmGNKr0q\norUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPGe70DNNLMvc1iNEmpTdyDyoBL5GGSfVhpHravKntBhAiAYOLyRwBtF\nzZ4CYUoOd6mUNR4t1G/AxnMerjaV0wKjMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAcsvqVwNinJv4GrZtB7UO6T6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM0NDliNDctMTRkMS00M2I4LTkzNGEtM2UxNmVkOWMxMmY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMjQ4MzBl\nMS1jNWEwLTQyOGUtYmMwZC1iNTkzN2EwNWRkODAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQjuZ13OxnpGIuMK+5O+6zPnd/NCZt46gCg9IhFfZ8pzouEScZoanC/\npWINxmGb1oNrAGUJ2Kj3p2KHZZB7QHf1o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWVpWn\nJJsnP15fM8m8Jp96mkTK2jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIFsiDiM/A+5MotVugW8cROs3QObjB1aR/JwchmWDGoYRAiB8S/3PsD0zBbXu\nXsZ07PvB825k70VM96VqPrp1bYzSNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1610", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1610` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAUxEsl66df5eKJryteXA7EaAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMDdiYjQ3LWI5OGYtNGI1Yy1hMmI2LTM4MTdlZmQ3N2JjZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVjNTVhNjktOTdm\nZS00MTNmLWFjOTctY2EzMTU0MTM1N2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7F1qA150f4+l92In1dtJ2eNR3DxrGw6QJAuP/R9gfgqJG4Yo/ARzJDT2+qff\nKK4D/IEAjZ5mUbSClzSNwQkwSqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqRSUJdx8nHtrknYE3y5ue6SDLT4wHwYDVR0j\nBBgwFoAU+Cq/NMoYJZ3M7LcYpk9Yu6m/LvAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgCd1ToO/75YE8e4dY5pl0ReVVuijB3QknrHq8r907O6kCIDV7GE2qcszL\nSSyueBQp6wpSxJ0hnJXWysChg92zhEAQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeYlBabZQVFM+w97PMlDMrtZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzA3YmI0Ny1iOThmLTRiNWMtYTJiNi0zODE3ZWZkNzdiY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCZIaIb82pwRqimDema61l9dEzGqcdlnA4xYT7+q47rUkb\npvLaqIHI4QN08HCrZ3fSxX3SkoNOtYFPS/nbHOoHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Cq/NMoYJZ3M7LcYpk9Yu6m/\nLvAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMFfqg+jbd6IFxe1i5W38jdfUtTuXFtD1pv1hZucGd6ACIGqSuBCiC6Bm\niAX2C3ca4g6eEJTd9cIn057Apuy0kXJd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAft54kI9inSIAltJnoRv8CifMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVjNTVhNjktOTdmZS00MTNmLWFjOTctY2EzMTU0MTM1N2MyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MGZiODhh\nOS1iODNiLTQ2NTQtODkyMi1jMjdmOTI1MTkxODkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATY38o0xogmCWx2RajQxEgmK4gSygyPCUcSsOzTm0LyfgkLO2ui0TVw\n0EjKwzzEUTtC84YxlnIULwlD3Ge6PgXAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSpFJQl\n3Hyce2uSdgTfLm57pIMtPjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIA46LrpdjKdO8GweuwVvo+hMeYr/AQwUZ3mzyIj/PAxPAiEAsZezBNITQDwF\nec9nH8VkcsDQcZWv01embLhwYSmOMIQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1611", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1611` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAWsKEvdJBfKm1tCVWhmn4z/bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxZWRkZDk5LTEyNzYtNDVkOC1iNDY1LWMzM2Q3MjVjZGI1ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjliOTE0MmYtNWFh\nZi00MjA5LTkzYTEtYzg1NGY2ZDM5MjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDiYVUs/eEq0jFjF0uUocCv9AN9WpY7d711eMBDGRKPvtFgRzuwQRvkLzVBAi\nlfSlZtUV7bvCU4RlPzJGOovBL6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7N3RpGaDkl9L4/OWKjjcCj+hLnswHwYDVR0j\nBBgwFoAUQUExV+URBzOnS6O2JE75f0punDswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgBIEWdNa14P6mLmVsw4G3P1SkhYF/JLueqZRNUEwnao8CICPM6/zglvZW\nO5c0feenqV6lzns75dDTPjGGYuqj2M2+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf4M4ewkIa+SBPGiJPeBQIOSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWVkZGQ5OS0xMjc2LTQ1ZDgtYjQ2NS1jMzNkNzI1Y2RiNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATC522aCOB5Ks1u6mIq6nsNM3METdBvuCCvB5oe5pPejHZE\n8VCRPpF4X8m9heQggw2t5oeEKG0wSffJu42VI48oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQUExV+URBzOnS6O2JE75f0pu\nnDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf2SxgY81EvW86GWWq7DhX5HsN2ncxCw9HjTCaMr+tPwCIDEIxY8UJSWR\nr8a2LO6hyOePHi6bwFRZ626Qp941qcDu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAb6GLNEcyC+5grIzx6CSs+kyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjliOTE0MmYtNWFhZi00MjA5LTkzYTEtYzg1NGY2ZDM5MjIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MGYyMmRm\nOS0yODEwLTRhNjYtODliZC05ZTg1ZjIzYjhjNzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASRWj2IFKWn0VDA8qyQDLsv5kZXVHjxEkaYUtcJrqyiW59e9KSNj4Xi\nRvUFEhU/LLid7pEKssNUCyl0teAiCcQIo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTs3dGk\nZoOSX0vj85YqONwKP6EuezAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCIDYPL1tgrQPqzP8VTDBS8rSs/UNbXWn5IAOulNO3XPAIhAJF8Lq9oOMx0\nq2uswEYaB+qhCewpuc2zTeaN0jqGzhGZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1612", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1612` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAXMeWLHJdP5tlii0jkdP7kj8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2NjgxNzY0LTgyYjItNDc1YS05NGZhLTM3NThmNWRkMjE2NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYyYzJiYzAtNmIz\nNS00NmRjLThkOGItMDAwMTlkNzFkOTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBPA+g8yk01s5Il0rvDDQhaYK0+SulKHNFhbPac4M3CMyH3eWVWJvQGMELciT\n6GYoJT1k6Tf/CLDnrdxJmzeLoKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkO5DA4GloNZdaS0rvPEPHypCIk4wHwYDVR0j\nBBgwFoAUn4/fJik16iblSDrTXC8EKc4QmzgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCHBYLUwD61n//hnNbdO4yYUkNPKA62dsfzm1l47BoDAAIhAIbZ6/ql\nmAUa9t9YAPQvn5d8D2hvsSD9bwxCeBRgZrb4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVZux0+oLr8F/+fanVITeJzpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjY4MTc2NC04MmIyLTQ3NWEtOTRmYS0zNzU4ZjVkZDIxNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATakF5tvYd+B3l5Xfnlly+3iaUgzbTIig3cAF+xXrlPt9Jk\nGxxf6B/X4xGHzsy+F7HzmMm1KdygZF7mEVFerQoNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn4/fJik16iblSDrTXC8EKc4Q\nmzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMf3B3weUGDiriLLNLnfjt19U+lx9aQq9aMFjCDqS3NTAiBTHs93u53R\naJZCNyyGSFuk3K3Nj0FKNeo+GCKeLrw2Pg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISATJn2Ci45XPOZftDpXtbP7i8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYyYzJiYzAtNmIzNS00NmRjLThkOGItMDAwMTlkNzFkOTAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYmFkY2Zi\nMS04MDlkLTQxYmQtYTVlMC1kZDg0NjMyMTQ4NmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATMy7pZnA0M2VCb0gHEjAa3A6o9R6vVZdA8IVmg2IA0auuN2DZyV2z6\nFv3okb/k7LrHpM08Wd0tVAv8fonxQSsKo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSQ7kMD\ngaWg1l1pLSu88Q8fKkIiTjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQCO4cVRHRVB3SgL0UgRWnq4QY4WGMgzHbonprNpRJPH0AIgCb59hTQpX8gZ\nXxzZ7GROE9+FgzWNt7SfV86/SgP9fNg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1613", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1613` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQmGjN3ERONmflk1ILWiEeZ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2ODY4YTFjLTI0OGItNGQ1My1hYjU4LTM0NjYyZTkyYTdmOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM0NDk3YzMtOTY0\nNC00ZTA1LTliODEtNjFlN2NlZmIwYWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI1AvzrsuDlBtH+LWyFqbjHgqwNMeDYbEiGuMcx++hI8A1IiQ4Dgs2b0MKNm5\nlImLC7pWlsDE1AIcwx3tzs/SKaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVyEn1GJRQRADKy4t+WQOcvTUAiEwHwYDVR0j\nBBgwFoAUCPCH0OA0aek5bUqH4uBUHzq6Uj4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD7PaEis6ZdrNsERGl9gKN00Y9ssEL6Ka6ejwEq\n5lE2/wIgPv1jgR2cxCrT9EWNvjlA/rAVgSbwLZ0DCxfmzMw0ePw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXM9kd9oKlf3Vow7pPIfSychMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjg2OGExYy0yNDhiLTRkNTMtYWI1OC0zNDY2MmU5MmE3ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8YuL5S6ctcfSf3GfvDDR/A8oICRY+9EIxt18/22QTzh9m\nkycIiEDG2vtuFfYF3kAqJlUiXc3BqFEHZM7kVhPgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCPCH0OA0aek5bUqH4uBUHzq6\nUj4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU1FsTWtYPaGguq2wsLjgYzMJRO+EtiQCb6ggn8Bs4OYCIQC7uNcpsGlu\nqZvRW4yEYN1UDBU2oAOyt4VVZBnrM6BjVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAQPTSrmrXuNyT8L9X/uO0/LjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM0NDk3YzMtOTY0NC00ZTA1LTliODEtNjFlN2NlZmIwYWM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MTE5NDdl\nOS0zOGNkLTRhMjQtYmYzNC05YThlMjFiZDI4ZGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARoTk4NcAvge2YwXvSbin+CdgGqD9fPTJeAJ9yBaC892V7jrn1N/d50\n6MUKzksHnD4wr5fGpJ85nK4hO3kEXAg5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRXISfU\nYlFBEAMrLi35ZA5y9NQCITAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIClLuA2sfG55bpyCaXl+KxpXY9FPxkwTWwpU0Tt9sKb7AiEAtDnMBLITrEdC\nP9JgyMFKqVX9CU6LtNOzS7E91tTztJQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1614", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1614` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAWqrgmAeP5swKB0XjLqqThj3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYmU0OWM2LTU1MTItNGZmYi04YjQ3LWM2MzAzZWE1NDI1YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIxMGY1MTAtZWJl\nZC00MGZlLWE3NWEtYjA1NDEzM2YyNjgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5+HUeEggQQwAobut4tIgKc8d0sl9mplgp80CnHj5Ylyd6FmSrQSOIcyYz2Bs\nQHT531TyAuggiM65M0iYtvIA06OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAbvgXOU7pWxWu37b9AFUmpjbuOAwHwYDVR0j\nBBgwFoAUyffjgMrur07u3Zz/wxqzHTC8QQkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIAS/bNSgn88hq16JGXFT24Hh1AouhvA1zCeQOwsk\nIGV6AiAUcylfbh1+P0YThposSixSnEd8wfbzLdIb49TaXHXuCw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQttE6pEPrZtJOM4MCFD+RA3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmJlNDljNi01NTEyLTRmZmItOGI0Ny1jNjMwM2VhNTQyNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMMRjAdddWh65VraR12DFnGbM/sNK+eI086XFnq2Xi1Ueu\nTAlSe/+4hMuDwrghu+QvwY11j9fXWS9cp6oepLmao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyffjgMrur07u3Zz/wxqzHTC8\nQQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeF4qD1Lcn7NsSqR7aNUAnqr/N4bexP0NiybrqXj3tWQCIECP3zfYZ8lQ\nctZlIBZaxxj3JeaseVC0L0BhZfUNT948\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAXbovctkiLRzg9Fp3Y6DX9DOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIxMGY1MTAtZWJlZC00MGZlLWE3NWEtYjA1NDEzM2YyNjgyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmY2U4ZDA3\nNC03MDlmLTRhMjEtOGNmOS0yNzczNDAwZTQwOWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARVjj59ee5ZMufUljx1OrD9PRGrWgndX02SVyHZ5MDN6M353wC/royV\nZwzvYFxgDqoJ8E0fV1BSkS2jbgDYF8uGo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQBu+Bc\n5TulbFa7ftv0AVSamNu44DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQC7BfjgE34lxShHfN/E+Cc2uxdeF/FoC1jxiVOnFmM2PQIhAK2Fh4hFKjVa\nNAYvmiqmd1yT8WxAbyYodyBsygCYwdDX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1615", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1615` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAbNbBKCAIg1FLc2mzbB/pm6jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5NWU5MjdjLTVjOTctNGQ0NC1hNWM5LThlN2FiYjlhZmVjNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWEwM2I1NmItODY0\nMy00OTExLWJkMGQtZDkzNjI2NjE4NDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8sQ76qe+/3CHilr3E85lphFCj93I3CZeUZm1gHu86BX8tdBZ2b5AkyrWYmJn\nFO4VLUMFpGxx6qynV6bneIJuq6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdc4PhomPANWasmLPYeDrDCnbVJYwHwYDVR0j\nBBgwFoAUjbt7cxhuLauQVRMq1FfXtbMzVnIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIAdCbGmAcQGnPv+wonnQp/9BufqnKgRE7mIKDhvpUvMbAiBk\nl4HNuv5+d2TL5t1iE6LEdspVr0lNJx5D4pz0XFb6Tg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAddT/fyEYKfrGC7Qj5vuY5h3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTVlOTI3Yy01Yzk3LTRkNDQtYTVjOS04ZTdhYmI5YWZlYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKTAzLTvjT6TZBluBuFaUhP8QRjAmu13CDP8n3SPPhJPCv\nVETAWJejX2uy3SR0OQkaCDaRLwWoK+9bwRyY/B0Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjbt7cxhuLauQVRMq1FfXtbMz\nVnIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJKjszZwHih2WrQ3MfHc2o66MRrcZlzOCb0EirrVwfRKAiEA40UamTh0\nv2q4DdOJLxWtfHu4j3VNQSElZWntkJ21+xo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISARNXvKB56YJ+pmQ3wmOzNIj+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWEwM2I1NmItODY0My00OTExLWJkMGQtZDkzNjI2NjE4NDcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkOTY2N2Mx\nNC1hZjUyLTQ4YWMtODI0Yi1lOGZiYzE5MzVjMTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASQ1iDoaoM3WpvXq+SC7kd/Ez+V/uAGpDGY8LCKjiTcOaHtR6gVnpSa\nG4mXw+VgEMlVBRCS34lgiZ0JmkD/xHOQo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1zg+G\niY8A1ZqyYs9h4OsMKdtUljAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIAcdJV21ZA+ewDGdBuS5iAbHyhbiNxUwai2lzlU5MehjAiBe6FQ94+yl0DqN\nAKkTtVLDtQ1QcbofjJaI9h7mj8USjw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1616", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1616` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATjfpo7Gn+9eOCodR8mlb2jtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxZGVlNmZlLWFhMWMtNGM0Yi1iNTRmLWQ3MGY3NzA1ZjJjNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDliMzQwNzYtMzA0\nMi00YTk4LTg1OWItMDllOTg5YjZlMjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEONhs+zUOTqKiwvNlciICi5bxOYwZrX6atqD3I/eMHeSFD0x2lgUE88xLFxKv\nDbjn1G6OmkAhUt4U7wNVNz/Jp6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb3hITk5PP8zr81BprsdDp0lQEOkwHwYDVR0j\nBBgwFoAUwADU6ZQyVtNwRPBTPML7xO7cej8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDI2lCFWbQpYnQmcXcCYDc61hANKkPh\nVUa86iXzR+FaqwIgfiTlaMaGZYP+J6HpAbI/uDl0uQBdz1D6BTn97F6QLIc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb2ocsjWXFESxAB5nBqX6OeiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWRlZTZmZS1hYTFjLTRjNGItYjU0Zi1kNzBmNzcwNWYyYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZjpCpiV6ksTtY+IzB2DmXrFjYd/Xk+tFaGcJw2Mw7+3NK\n6+A7i9WB3PgemOnw2GLIF4LRakK4M/5Zd7u9csOuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwADU6ZQyVtNwRPBTPML7xO7c\nej8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPsXFza76ZGdWLxJ3vi4CdfkYRn1WOSPKAvNjaWDmCvsCIQCXrNxUYlTk\nnM8c+mm4OZuSFmBBVd9K7hlmp6zrG1pq3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAebWbbT+FQos3TVdChy0yWOJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDliMzQwNzYtMzA0Mi00YTk4LTg1OWItMDllOTg5YjZlMjFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYmI2ODM3\nMC05YWE5LTQ1NmQtYWZhOS03YWY2MzEzNjMzZjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASSS52k0pGuDjXHu3sKtjxJsxDjDfGVXWmP1Yn1is+WsjIOumFiiJt7\n9ecKBiiduI9zpXMzKpJ82wA7kRHrFj39o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRveEhO\nTk8/zOvzUGmux0OnSVAQ6TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCICZ36pYc/cwD3eYYq5JZBGawHAVzHcGgj8n8UHnuNRE7AiA8rZHzAya+Cgkg\nzOZaujn1EEj+mgZgHMANZRTb2BFw3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1617", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1617` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASd73CbFFRlO7vdQz8UcTdYwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2N2NjNmQxLWFiYzEtNGIwYy1hZGEwLTdiZTJlNWRmMTFjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGVhMjgyNGQtZDdm\nNS00NWY0LWI2NGEtMTJiNDgzOGIzNWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEehBpaQ3xRXwQsQgNUV6rbP0QJY6OfE6CC/RSrz1f8Zm9hxwGKhEILcYBjjf6\nQiK34AS3WQkmi9RJ49918ba1XaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6UYheBdm1TeE0fa0hOeGgkm36GcwHwYDVR0j\nBBgwFoAU+TP8qdIFZSOlP/170FuXgapzPQcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD+ybacRCjm5CyH1Nv2xpHj/w6Nmuka\njaObw2/YFYucNAIgXMTycZkpIykXROK9NiOfYjX3V5T5aBDJVFqkjNbxYdo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUVQKONtjUn3MnByLiyESgerMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjdjYzZkMS1hYmMxLTRiMGMtYWRhMC03YmUyZTVkZjExYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2CWAFa0Tbi8IoxK4hSTytbeJInXQzacxEp6EJGPS/QC9V\nzoA1UB6e0dFrZM8sVMsAXZXdY7gblXu7uHtx/POno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+TP8qdIFZSOlP/170FuXgapz\nPQcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMEwo7+6eVpKlhdwSfZmQgoh8e7nKbgOOeUUQgmlnjWyAiEAyg+jwViL\nQER3dpFlJNeMgOK7Atrd1A70wtacLmfVFZY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISARKOQ8S3KxzGRO4uRIXcv7npMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGVhMjgyNGQtZDdmNS00NWY0LWI2NGEtMTJiNDgzOGIzNWIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMWYyYWVm\nYS1jMGNiLTQwNTItYmFkNC0zNzNlMzU2NzA1OTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQVx8FT/8ijVg4L0XIHEFnrB0LtwOLepjye6/Ms2zU9KadOdGoEObkO\nLKeAjGiB4x3zpf9wxkpYi0JjpWPVjnUKo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTpRiF4\nF2bVN4TR9rSE54aCSbfoZzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIBV7oAsUzWWoc4SlH6nl1IgkY9RgyFcS6IpsuZQfsUirAiAt3XbnA4IYxQwZ\nVSRn2MTS9zuwS5zpwx/huMiHO5z7Cw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1618", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1618` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAeob0OjoHb85AWteLpotlZ+cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNjJkZGZiLWE2N2UtNDI4Mi1iMzZiLWZhZTY0MDc2OWU5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJkNTQ1YTgtZWVh\nNS00ZDgxLTk0NWMtMmNkZmRlZGIyYjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe6saXe4YW2kAvWgfvTMgesaEOahYTCzJI0n9lRRl3mBckqBno+T1ORN8iC/V\ngBgoS6o9fIeMvXryFgSK3q+OG6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYiCbQRTSy3qmbbO7PAzdVLPC5HcwHwYDVR0j\nBBgwFoAUTOAoEUL2dLbgf72hhXc3y3/QposwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDN+tqu9ew4\njE//7VOaCLH7EIiqtw+BReN6tp0VVBQMawIhAM1hty2Dxyk/3DbxHEOazUv09rrF\nUOSB+XLsXl/ku3Fb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeksr3gH93ehYW0nNtIXUQfSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjYyZGRmYi1hNjdlLTQyODItYjM2Yi1mYWU2NDA3NjllOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIrO1EHbjgjsVdpDgCp1+pLzVKj/mOXmptAioBrDUaVJNL\neV5ztan5KWrmLptM3JEo804sK4bdS7d+NC1bMWg1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTOAoEUL2dLbgf72hhXc3y3/Q\nposwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMSaGAVF4CnI9VXP2r982lXPI3zBjBW+KILO8DGo2/JZAiEAooUS5sOG\nhi4ZECW9i9zlQcfpQ/Cl721jCO1EA8O/O4g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAbJ+1Aa1ds8HAd/YEkSbgfFFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJkNTQ1YTgtZWVhNS00ZDgxLTk0NWMtMmNkZmRlZGIyYjU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMzI3Y2E4\nOS0zYzIxLTRjM2EtOTIzNS1iNmE3OTRmYTA0MmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQWg964nK+miNoX1xuitRpMz5euzHfVztrxh58bzkxSFwTGBTPb5Irr\nndc1as8tHUrwQtuaguhgzIVu0cKZHypIo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRiIJtB\nFNLLeqZts7s8DN1Us8LkdzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDFmUidysLk+LGOJHhtQzRocDPJEu6dtcZrETqNtKCTjgIhAMHs3+AWKtAw\n1k5Gg4HQkU9rtXQ9X3WQzDRPYJ1Rn3m5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1619", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1619` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAWMx5N8fmSAxM10RsZ/kC7IaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhY2NiOGQ3LTY0NDgtNDA3Mi1iY2E1LTljNjdiOWQ4YTIxYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRlN2FkMTctYjZi\nNC00MjkwLTgzNGMtMDgwNDE2YmM0YjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiBWgYbtBEjOWVaF5W2G1gY+Zap8X7K262aKzSviYPnRfPlpd94oYn3wD4h/S\noIVmpFUTb/F5a1SwMS4nEuv6LqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVHbnCrwcCPAWVv2atLxrlHgY5dEwHwYDVR0j\nBBgwFoAU2JK4YmcNk8yneWBjperuv8hgCPYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgX+0E6Nh3etLU7JpYvMR3utXYoWSuItVmuAEXcUMEwpQCIAs7+e63xYx4\n8Wv+B0HMIeV4KiGCY4dhqyplvxPgS3cF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASQY+nguVMhVEk1zTpN3+vLPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWNjYjhkNy02NDQ4LTQwNzItYmNhNS05YzY3YjlkOGEyMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPtVrlgRw5/QlMBTRum7R++IRZogKhFcVUMwLbXnCCXmq1\nbybUn9Fh4q4h42xyJtn4DvfrigVOB3es8LcEyr0jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2JK4YmcNk8yneWBjperuv8hg\nCPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM+MGdESs2rePdeC7s/D6PE/RCFbX8dVKOC2Zu91dta4CIQCZIYCa0sQQ\naaHK/oqj2VNLt1F6rzEdOqW74blKKHZKMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAcAu6dkJ1wrCODdaq7ppfddTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRlN2FkMTctYjZiNC00MjkwLTgzNGMtMDgwNDE2YmM0YjA3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkOWRiZDUz\nMy1mMTIyLTQ3NjYtODA0NS04ODNlMWE5YTRhZTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASY6XdicGsrPCC5FcJ1gnj5al8HH7+wGpVQZjM6JSee5ih9RrjlyU1e\nszY2D38ZDi4alvNZIy4D1oHVnGB6dDbSo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUducK\nvBwI8BZW/Zq0vGuUeBjl0TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIDi9ABoI/biAjATUQ45znXwL5HW9zJS2p2B/3jaXKVWhAiAqhBYd4UH0MyxB\nmYw/N+0kYTfdrC5urrXyG7iOq6xCfg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1620", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1620` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISARslnBP5NyDWSdACK8P3fGwVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3ZjhjOWYwLWU2MWQtNGMzMi1iNDMyLWY5YmNlZWE1ZTdiNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ2OTExMjYtNjVj\nYS00ZjAxLTgyNDktNTU1OGNkYWY0N2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWPHX70eLNhWkXZJKeZmKGclUI1NQYFtt7KrxPlVOz4Se6ZbNnbXdQNU2bkbz\nyxBRWLIIk2PIin90oIrSqn5VD6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqtbM3iUPZJiHR2suWBwicPKkpsMwHwYDVR0j\nBBgwFoAUPywQnaaHCPE2XIHIDv9rfED3ZgcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJuNVNn+RqTYv62AaINjZjrDL/9H4sW8crwGGCM05piTAiEAuTji+E2p\nQQikaK8mU+/LBCsgYDD3/8ifGhI2r33C4JY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQuiyyG1JPB7eedWDytKpA2gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2Y4YzlmMC1lNjFkLTRjMzItYjQzMi1mOWJjZWVhNWU3YjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXpXgUhd6Ikh9PyooKB7Tyj4LVH3XU4Ifpl87D0gCLPuM1\nuetYB7n8W2dC8eoON6yh7SsuHfSqRa5UNOaeGIBlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPywQnaaHCPE2XIHIDv9rfED3\nZgcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALJI9tyFXgnA5K1rwXprD7nQwbIopTtYZdEvmx8ZfLdUAiEA92nbK6yr\noTRb/oKjM6aAtTe2GP+9J8eDxLxZCrbPdhM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAaXGZolfmXMdROrwkaRPXUyNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ2OTExMjYtNjVjYS00ZjAxLTgyNDktNTU1OGNkYWY0N2EwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNDIzYjgy\nZS1iOWZlLTQ0NzQtYjViZC00NDEyYTMzYzYxMWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASFjNFZ61V3WT0wc+Hu9y/k1sLNw9IdHH2qRCDuU1FBQ9314+dthkwb\nwH/ZK5+5ceeTmT9zB54FhM4rRRZSFnE+o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSq1sze\nJQ9kmIdHay5YHCJw8qSmwzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIDw2PdAm7UJLklgn1GFk3R4U1J5HrYI6n0X/X4bJnf2HAiEAqS1oYGa6VUUN\nYawZ+5CNURg5zSxSvX2qK6M7NLZXLLE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1621", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1621` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAXonRsmrwljlx3H7tRcBCC4nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5OWQ4MzQ2LTE0YmItNDMxMi1hZDVkLTcwMjUzNWJiNThlZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NjOTJkZjctZmQy\nNS00Yzk1LTk5NWUtYzJmMDViYjc1Y2RjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENz1uzbpO0tr9lmLdnX9rNGSWgHEdY53xEMLJ2qHxBfu7HZ8jzFfrJQjr/Deh\nnhiwNOj7RT193R2/TvQwbhItNaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjzbiLI6n0k1SScqVTUVKgYFh0tYwHwYDVR0j\nBBgwFoAUr+K/deaC08DW/XQvxThDPuJEz/owOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCUuU5WKSJzXwzUp78JRB/ktUkRVGhHSZ81aloTR94cIQIgBdpZXkdf\nutCwUz5sGSEZoI/0D/+uzLLqJChTm0ZJpU4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWbPnyz3X9WXfNnj1VGdN5RyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTlkODM0Ni0xNGJiLTQzMTItYWQ1ZC03MDI1MzViYjU4ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5QwmWVBjJQJ6uQbg86G92CnWClUuxy0ohlvac1pjC5tz5\nxa1o0k4oCIaKf+8N7eQtvm3n1yeC+nEtn60rWcvAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr+K/deaC08DW/XQvxThDPuJE\nz/owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOZQorvgaMHHyGkfpMv3DxqflR6Q2of7fn7kA+I+VE8ICIDWPAugE8nX3\nqCgr71F8Bux/oybVzGdXl1dZU6YKQGz+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISARXS1mV7VaAss9FfuV2rNHEpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NjOTJkZjctZmQyNS00Yzk1LTk5NWUtYzJmMDViYjc1Y2RjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlM2M3NjU5\nOC0wYTFiLTQ4M2QtOTdhOC1iM2ZhYzk5ODUwYzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQDbgUmV2IQUdHfYekqpeYClZYviqeDES0ima+DsAbm7RLyI7nCtNTn\nq+4qIg1Roca5yM/xC6PXWSNsbbTk8Cgdo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPNuIs\njqfSTVJJypVNRUqBgWHS1jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIGOh5l4d5D/6mcEI3VSkwuBPrKq7UeBxKpa1MDgoxrRPAiA6h6NAgHJxx6Rl\nXn0vDPTMW0rk2hKX7GZjKlNbZC0TQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1622", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1622` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISATq18vVYsLNCGKv0Vco2iKMJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlMzAyYmUzLTIxZjMtNDYzZS04ODQ5LTQwNjVjZjhjMTYxYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ1NWRiYzAtZTJi\nMS00ZjIyLWJiZTktMTEyOTljYmUyNjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp7sRMdYn9rsorbSmqszeFnLJz3WXOFhL3uZTjVTIwAGlUBU0Zkcro7/+Xq9M\nQJ2dbkTw0tmcMcmD9CC20u1BmaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ8+B9yGlMBxn/Hny9r7E8BTa9C8wHwYDVR0j\nBBgwFoAUCGdd7UANB781RaJa0w6ZQ/zAZwwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQD+tmvp94JpT7FYm5e34CUl9lVZdskG0ZBY0u6p\nX2kZ0gIhAIYJi4NWgKzuVuG429VRx6Gs35dmg4dFj1Im+9dWstQm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZj9TOn1Nht5cg46r+oaK3VgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTMwMmJlMy0yMWYzLTQ2M2UtODg0OS00MDY1Y2Y4YzE2MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCWBAKtpC8jTNMpXGPX9CxVU1UmTSpMMMCH0rbT6vm+y75\n22YyMdUvhED/rIilQRK7PU/moCnE7vVPYZk05r1no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCGdd7UANB781RaJa0w6ZQ/zA\nZwwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga0woIgggbM1UoJkMeGg/jMj2r5qhOn3CxnTav8t2hrECIDlFJ4AZzjRs\nUNhgYNqcsHGMWsn/D7lECJxt0hWVNgHU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAX7brOflR5VcjfQOxVFg7RBGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ1NWRiYzAtZTJiMS00ZjIyLWJiZTktMTEyOTljYmUyNjRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhOWIxNTk2\nNS1jYjQ0LTQ0OGUtYWRiYy04MWJhMDRlNWFmNjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQiZp+maDDoYHd1yBitfJ4az5cOXASaVtIaRWlrc9j5l7SNFnmNe8wO\nczYXS4SSj4ivLHm4ARso4lKA8QHKB13eo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRDz4H3\nIaUwHGf8efL2vsTwFNr0LzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIAV7cYr5Boac38kBQXvY7swJaOYDzhye1vee67lshFzWAiAXSlik/r6pszts\nWgXvBdQ2a2NGp6G96RI5CbWGM65hqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1623", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1623` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAe6ZJ0ptKtL+BscyLqrCLypZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMDBlNjRlLTQzY2ItNDljMC04YWI3LTRlOTVkZjRiYWE5ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQwYjJkOTgtMjhj\nZi00NTIyLWFkNDYtMzQ1MmVlMjUwMWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX4Kmaw8o/RBW0U5AcIUZTmj7msTfYe9IBJi9lDI4Q8FYYHnesDIQwaTryWzh\nLCCucIJlM6153dd5jMHPHO/2lKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWasJsFYVf4W5Qt6pfKA4V+SgYU8wHwYDVR0j\nBBgwFoAUCAMXiuHwL344xW9C7o9GveT//T8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCgpGYA7rzGQNCwPucf3wzGsfypnymetQ/oedPz\nQ0m2EwIhAICMsM50knBtAYQy5UHPbNlFHTCpnhJQaCsjbLSMJGeb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAemRzrH0i6aJz5bdW/xWpBegMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTAwZTY0ZS00M2NiLTQ5YzAtOGFiNy00ZTk1ZGY0YmFhOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlcmFjvhR4st9ZZsqLyf0UXpTO47yFxnHSrdiYPUJcYga3\n5maq26IhvxLbfkkRJ7ma5/Mjz1IbbtPCnrhxnQx2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCAMXiuHwL344xW9C7o9GveT/\n/T8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgT8qk/0zApj4IjAqYtaKkZycfrYgmpWoEgCyP4d5bi/kCIQDyyaigmJ/B\nv8w/rko4VhDY1WLo+suR7GvvmvPxxhV6DQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAfBGJNipk8TYFDDxfc3gY892MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQwYjJkOTgtMjhjZi00NTIyLWFkNDYtMzQ1MmVlMjUwMWZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNzhjODIw\nMy04NjVmLTQzZGItYWQ3Yi1iMGUwNjUzZWZiZGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQUU9/Ps3SAhYSj5vSTgpoT8RdMDEXmYJ8yUJWBvnk+mWI1siltfSda\n0NF8gxb+pU+Y440A4Oh6QxzGSlPUDMIlo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZqwmw\nVhV/hblC3ql8oDhX5KBhTzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIDyU++DS0Rv+vmSLukDhsrtQJxNPaM6f4fo8cUqv4cNRAiA5LglZUP77xoAv\nqB9ojvmghsXTAAl6W2YDMTylWndUKQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1624", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1624` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAWGEzBdUj8Gvzyfo+1Jc8UphMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkOGRiMjg2LTg4ZDEtNDlkMC04NTRhLTQ5MGE3ZjBkZjEzYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgzNmU4MDctNDdi\nOS00ZDY3LWEyNTktNjI3NTE2YmZhNjcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBYXPuyHBycFpKvQfdimDzOtQJnUDGnE2kdL7drlu2NHIZysQoR+aD0WBhmV9\nj6j/ZDUyh3vRBVcibfT1+NmlAqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXsuVmel3ounY3pLrjks1dp54rLQwHwYDVR0j\nBBgwFoAUWbvyb3fpSRFFtgPbH0MeCEuKXRgwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCaXmSc51hFczAmChGVtNQHvCGGgZ4GeWKFLuT48TBFGwIg\nJz2hnnyAhylO4GeyuQrHmPOWUZ4jfeqS1BGwpV/uSl0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUHAKWPrzTVcP19uKXOApi3/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDhkYjI4Ni04OGQxLTQ5ZDAtODU0YS00OTBhN2YwZGYxM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0cuHydXKqA/gsLyCi7LdwetJIMKCkMG938BIkKFIxCavP\nE8Wx7oTj4kPvWHtYIBnbNmp7Q40bvXjiAqzvwqs3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWbvyb3fpSRFFtgPbH0MeCEuK\nXRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJbrWX8GzX37f3TqgTdyDGeNHXi5sfpGmFTl59OvqEAZAiBLEJ4SJ9VU\nq8TTIf7AVSgXARZ8efMZ7ORkEfwiUg/p2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAez8euJ02fsiyboXMuk69YmhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgzNmU4MDctNDdiOS00ZDY3LWEyNTktNjI3NTE2YmZhNjcxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZGJhODk1\nYi01ZWM2LTRhMzktYjQxYi03MjcxZDlhOGZlYTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARG3N39eXGMuvyPWwm3lQC0E3WkgBRdawRvB/oAz+6YSJVSp186cg+u\nijgymX3lW9EEefkW9Dzwv2Tkw4lGGOuNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRey5WZ\n6Xei6djekuuOSzV2nnistDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQCFmMLSkOH8KhnGWS9/94Ad2WgOEEI6W5SF3u1jV6M3IgIgTEGLBNwsvVDR\nev3g4tY99dXn6WyxuKKUuG2qpmCjzXo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1625", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1625` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAWYHyIeKybsavoBQeg0iaWr8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0NDYxY2YyLTM2MjEtNDA2Yi1iOWY2LWNhMWZlMTI2YzRkMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYzZmVhNWMtODU1\nNC00NzQ1LWJhZmItZjExYTdkNWNmMDA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDkX8CViSRgcabMmYVPIDiYETOsrfkZp2Ia0yMoo3UCsmqZXZ4ALjZp/gK5+j\nq88ZY4XPGia+1e5mTdxseW1uF6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVBwLVDT3mNEsoHdDE45rYbZACSkwHwYDVR0j\nBBgwFoAUryiiefozRnGnGriznVuJ08/3AH8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDiKzTy3z6Xe5jdkyIAhy0Hi3Qjh2S7\nI6CceFwG7R2MPgIhANprSqo4a23AoMKQHBhz/poIADg5CA36AkTPpTpet8GD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaBdPKxdu4yRvp7C5PkOEDLCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDQ2MWNmMi0zNjIxLTQwNmItYjlmNi1jYTFmZTEyNmM0ZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbqg3swnT/5Tq2PeLNAAa3uIyzRNrjMlbwqXD05vEGcn97\n9rLLkSQ75FfJS27hnycdN6kdcChQuFiFAnOSjRASo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUryiiefozRnGnGriznVuJ08/3\nAH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALtNgfYs3QPkq8W1QoVpYZXIzepnDPlb/EjjbR2ew+ijAiBvH3YPxJga\nDUBidNHFkYJq++wFCMLxogBQlLZLtcmzkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISActZ4F9ySpGunAc/eXQ0OgjMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYzZmVhNWMtODU1NC00NzQ1LWJhZmItZjExYTdkNWNmMDA2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2OTRlMDY4\nNy03NTNjLTQ2OGUtYmM5ZC03M2Q5YzNkODgyODQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARUZxk2ofBwIp+TkfHVQpCBUZQUvbveHWQq/G2USIi4IWXFvf3Vr1/F\nojxg+7WNS01RoSHks5rFvjy8bA0f+uqVo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUHAtU\nNPeY0Sygd0MTjmthtkAJKTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIF5P61c2UR/JGhYD+qseyPWb6a3H14WMmqho7zkrFXHOAiEAzNiqLi97vmpA\nCNIAPLtcTrX5Bmebu9ZP4iYk/FVbTAk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1626", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1626` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUDTP38vgO1iaiFsaRnEcs+QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZWYzMzJhLWQxZTQtNGE1Yy1hZGM1LTEyYmIxNTUyM2IwZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBiNzg4YWYtZDhk\nYi00MDQ2LTg3NGMtN2NmNjc1N2VhOGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeOq7SFF/MV3A8CvknVXeDSF+yHrAgV7q4Zf8n+4iVts4gKKdghVgEoZCd7/6\nWU6fT7/192WF266czDwOBjNl3qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO3FUtg9q2USljMjOGo0+oQQc6okwHwYDVR0j\nBBgwFoAUe0kWKQbA9u9uXJC8aiNu4g2nh3kwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC2wcriBh258DA5mkJQDlohsGPsL7LE\n5XfKA5LDgUoi8wIgdx17/YxRBIaEIVE9pP4Ys6ZaDmaPo892847ITgQmS9A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXJaFOnHQC4YfduKe2KFu574MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2VmMzMyYS1kMWU0LTRhNWMtYWRjNS0xMmJiMTU1MjNiMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZXzfhgZ0GvlDnU8C1FpQOtob8i55cHHp7oCeu+YXi66K0\nfnx1o0wF+FRis7Y+bvPH0uCBEEshZ9ni4YFKYc3fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe0kWKQbA9u9uXJC8aiNu4g2n\nh3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIge6rtXRk/ksXiiysQCPe1jYv5Slxzw49BU3qprS0xq2YCIQCda/PRUIAd\nAFlFxXuzoVsV8F/w/Lc4xsIcCoKnl2tb+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcmgAwIBAgISAbbjueCnTv9902a8j9lECpEFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBiNzg4YWYtZDhkYi00MDQ2LTg3NGMtN2NmNjc1N2VhOGMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxOTVkMGY3\nZC04NjRjLTQ5MTEtOWU3Zi0zNjE3YWU2NjgyNzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASGpc0bYOoqmR0QGyd9J9QgA/XbOAlkljhw0AE5qIc8H3ETtCXcLIH6\nQkzk2+4U/bK9/nIozAnOHvoVoTQ9JqQwo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ7cVS2\nD2rZRKWMyM4ajT6hBBzqiTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0YA\nMEMCH2WtGOFPB0vkGBBkXEb2fRPNfNpedygrUeTWkjJ429YCIFoF+88zGqR65muQ\nsqn8en8FyvY6CzzvuD1tEcty1v+2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1627", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1627` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAV+orZbU8AibiXXwuCWb/ITAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZjc4ZTcyLTZiM2YtNDEyYy04MjAyLWM3NzJmMjA3OWM0NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk1OTQwY2UtMmFk\nOC00YWM1LWE1ZGItYjc5MmZhNGYxOTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHk5cll7Nwg29P15uN5vdOtOMxHfhf3LYJ4pqsG616EYFcBvMGO1jTlb40PiH\n2blVL55ux+JbS6g50KJxXhoY/qNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFA6/8nC/1qpgGzxnDI/uNPH7uq0nMB8GA1UdIwQY\nMBaAFJGy7P2uqEcqKCcjkZsES8Y+0Ng3MAoGCCqGSM49BAMCA0gAMEUCIFUlKZx2\n/wNZzXURdRo3mQ6ShWK7XdXv6+Ve8lB0LKXsAiEAn8moMf6GJDnk+1UMmaUb4smY\n5djf+/SvHk8wMyNV3kw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa6aE1aXjvNNhXsf60lGDZUuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmY3OGU3Mi02YjNmLTQxMmMtODIwMi1jNzcyZjIwNzljNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZcu8bIuKuPRcCYhFF/QDbLoiLVEynD0ocYzfzvsSVyxc9\nsOotF2fOZQjr3adgjpPI+/biRlxPa0B+6qIj3+wCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkbLs/a6oRyooJyORmwRLxj7Q\n2DcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAtZbWN44h1FBOEpDppjLXq7suynQm+rFQn/TizQBY+0CIQDXXWVf4TR6\ndLjLks90Nhu8VNAAWlMJ7/Blrzp35fUvGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAdDQ7Lx5CKiW4amRL6azhSmvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk1OTQwY2UtMmFkOC00YWM1LWE1ZGItYjc5MmZhNGYxOTk0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYWM3MDZk\nZC0wYjIyLTQ0M2MtYWUyZi00NTBiNTU1OWJiNjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASBgZysGZC/uABTuNu6hd0/wlIPI+dQZn7L2LWg2UBpbBN9kTdrqt1A\nfLI3jG206mUjEUXpEBjw7a2aK7Auh4dMo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQOv/Jw\nv9aqYBs8ZwyP7jTx+7qtJzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCRjZb+VKYkxQOE5Isvx43ZEURXA8gEU5INHbxH2XE7XAIgIuyHR3ZXYKXG\nB1L+Rjf/dmBisgPLgoiGQLLjWY2wNMk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1628", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1628` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZ7pmG5sqx32kwP/OAzDk2dhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3Mjc2MDYxLWM1ZTAtNDZlYi1hMDI3LTg4M2U5NjNjMDkyMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg3MDE2ZmEtZDY5\nNC00NTdjLWEzZDYtODllYThmNmY5OGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfHUxmzDKAh+UzgHkXKotJnuKXMb7Fdobthl1BxgebFxR3YwsXhq+jZhIAAoS\nKD/MGUOjALx8anKo6MBF/kyCSqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMeUSQZ0sviVxjROMFtprp8tS2gTMB8GA1UdIwQY\nMBaAFDZk5igAX4pqn6a9+b1TtbHvguy7MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA77kdNkLLcOVb6r6KczN2XU9d06i/Rq33\nDmJJZibNJnoCIQDmwKKq7gZvmfCLT6ptXLrP+bwwpLZp488cncIMjEyDpQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUqfD5Y+RmrDZ+5ElZSKM1FhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzI3NjA2MS1jNWUwLTQ2ZWItYTAyNy04ODNlOTYzYzA5MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYSRqECSdTYzRMj8gntLLpatjwskrOeRhyVEvJeBAmOCx0\nQDFkYS0tdTPWinySAzQG6/8QSNgOjzWQTx/c2CxIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNmTmKABfimqfpr35vVO1se+C\n7LswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN+inP8GEO43poLXMK1aOgUbKZ5A+PmOD8HfDZUdGDCmAiB7IrIabUZK\nwQimjJYu+AW5JqIxoVqHThx79CykP+bDcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAaneiV2TLWa5i/n0jDgSl2/BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg3MDE2ZmEtZDY5NC00NTdjLWEzZDYtODllYThmNmY5OGQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzM2U5MjQ4\nNy1kMDA3LTRiZGQtYmU1ZS04NmMwNWYzM2RmODYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATIcglQ8WcSFL8WvbIQfOaeCHNnQijgWPys3AkzFrLBqObEXbtJG6pJ\nUUQgCTwMigXNiy+4DqOURUFmVsuUGOsUo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTHlEkG\ndLL4lcY0TjBbaa6fLUtoEzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCeMDGSm81MZh/jJEgnyHWT9JC/NTWZdPcQ81zDIaTVSgIgYzEO0pgihpPA\nqE4O70WT4Pc2Oytm/phG2t26MOQFxyo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1629", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1629` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAbAOGmXaLFMg+EIKF2dVVemCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2N2Y4YjZlLTljMjctNDhkYi1hMjMzLWY4Yzg1ZmFkNGMxNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc4NjUwNmYtZWU0\nYi00OWRlLWE2MjAtMGE3YjE5ZWQ0ZDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExgk6dOmGvtpnRtQhs54+6jQxAKYdrCt8e3621vcJ+N7y3wh7ajAw/37CdQpz\nyvuM6YJgaRj43SF1XF2fkgde96N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIBDrHdJrJ4nzCtFhqpPNj3AtvIEMB8GA1UdIwQY\nMBaAFLVmOoxmn0ALVyytpEs3iedqmVp/MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA2LSW6unBKgMDnwnp9Sarhr4r50kSH77u\nfTEiXOVUd9QCIQDzcrwqHpnQwDS4SU3/QA+SLcrkxJ+TjlGl4GfWt+s7RQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAemgdplxkbzo6kYN8WCrfpVxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjdmOGI2ZS05YzI3LTQ4ZGItYTIzMy1mOGM4NWZhZDRjMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXI2jGlep5hQaEDkbiFGZaVxwMP8FROtWgugZxm0luHqfh\nt4T+UO/7Lc+lwKkW3vQj20yb76z7gLoEfh7/NjJNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtWY6jGafQAtXLK2kSzeJ52qZ\nWn8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOBsrcDleJDdlF+r0o9pqyjNUNva5G3TnKtirT+5E0dkCIBjyjTuGL8RZ\nzpxkbzBjese2r/qTvGM0votxpNUELuEZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAYzIyR8nuiTsjqD8zwl56UYAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc4NjUwNmYtZWU0Yi00OWRlLWE2MjAtMGE3YjE5ZWQ0ZDZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYmQyN2Rm\nZi0yZGFkLTRmNGEtOTczZi01MmYwMzQ4M2I3NDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT3ANIPZZnqa9ohYg5c+gQpv8lxuOHtZsQ0GPBj9N+ErUzbywZFLU2Y\nm6R6Sxe8NzXasHz62rAmc6Eqq3SBqlg6o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSAQ6x3\nSayeJ8wrRYaqTzY9wLbyBDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDmZgNDGT54fgwnzbaKQVJt/9P8oiYbKlzkPNWfDCVktwIgAhAUl+dg0Oeh\n6xC1JPUWiZUiergBhwQMcVJAg2NLixc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1630", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1630` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXwmWvNcB2+866IN3z/5UlZ4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmNjYxMWIyLWY5YzItNDZmMi1hZWJjLTliNTE5MzRiODdlYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZlZjIyNDctODNj\nZi00MTFkLTg4ZTItZGQyYzI2MDhhMTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbedpP4Onhf66ENO/mjFionX13xvthou03XTKRLyW2lpefimgKNYtVnAK1pSt\nlaIFQJ520n4k3qwsqh5jLKsBwaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ0RgtOPm4ps/udKbtR0LVzU2oYjjAfBgNVHSME\nGDAWgBTeaaXmVtRSFPVn0x98lJcL3GIjBjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC1HEL4/76J0v+EHrllOQdaOYi2DIqI\nli+Pxm9K3x8AVQIgQQ9525ER0QlBpBSU8+cVVfqMPhn2Zp75XMW21b+EByo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVkFOGwBVWOBz35gaCzViXZ1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjY2MTFiMi1mOWMyLTQ2ZjItYWViYy05YjUxOTM0Yjg3ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb9hdPRXkrWlkvtYdQ97rwf1adlkYgQma2MYxEvOdZgfR6\nXnHEaJR8i+mR8IuQRMlBbKp+gWZGKB4bkneVv5RQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3mml5lbUUhT1Z9MffJSXC9xi\nIwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHwuFaevz7DmmVniYHfWd1wkLJ5lxudvxigBMPzFYuuwCIQCdNZla3lA+\nmPoadeZYlLbTTSMNmvOdJqIHWICbiBKhyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAQIbXBaRA+U4CVQbDGvp8NNHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZlZjIyNDctODNjZi00MTFkLTg4ZTItZGQyYzI2MDhhMTcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0Y2VkYTkw\nYi0wYzYxLTRmZGQtOGRiNy00OWY4MTMwYzkzMjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARxxKPgesfHS0W/VdiOhys6OSq8aTxi5+XR6iyvIL/NkA0JNqvg/+U9\neDEsG0GT+fTMy4o0X7M8OI6IN0ZHV9d1o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ0RgtO\nPm4ps/udKbtR0LVzU2oYjjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIGdZDhNJpSjCKBgP5pAVeJz4nDSFK8PZVjopwAA1qv1jAiAlc9Ipe5S0tDoC\n0T6qbbaG18JyvKtlHkgi5zUh7KXadw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1631", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1631` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbwbnn2hN14e0t2fHufFYKiCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5NzZmZDk1LTg2ZTgtNDhjZS05YzQyLWE3ODI5YTc5NjhmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NmMmE5ZjYtNjZi\nZC00NTllLTlhMjYtMDJlMTIwZTkxZjQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIhTZgKtm06rqTElRJiRgAe//3shuJIvJABrHSHJxlWQq2IqP7yGW29Xf/KfK\nYigftxwqm1/1H/+MWW35le+fqaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9nhYg8+1gdqxZn/aNO8+t1+7HgcwHwYDVR0j\nBBgwFoAUlnhj+lfFosLxP1VLdttRpFTxFJUwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAiDRNaliKHsrt\nwfs7i6qJ7r9+X3sx2Kfu38ZpMRvx4tACIGLWScOqVLkkcDy0DsRWszHKwxh5A7SG\nXpyL5O5tUBnv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQJRWzGy23P9YsTmwR6uJN6QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTc2ZmQ5NS04NmU4LTQ4Y2UtOWM0Mi1hNzgyOWE3OTY4ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV33sbNAn3X9rhvAWR08NnF6oqx7ZTPgO2wM4RWQl0oGsh\nElO3puNIoKjqK+J8AkJV2ygudgkqtDzHSFuwOLdno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlnhj+lfFosLxP1VLdttRpFTx\nFJUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMhHy1Am7wiONLkwZHnTqdRyARUb0RFujauaHG4+txKXAiBu7zruLb/9\nJmPT32DUqc2iqggIsKMh54pc9tcikelyyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAfSQ0A943Qjq/uoEkoKTPQXiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NmMmE5ZjYtNjZiZC00NTllLTlhMjYtMDJlMTIwZTkxZjQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYTFjNTk4\nMS01MjQ3LTQwMDQtOWI3Yi0wYTBiMGVhN2E2MWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASc2BL9pRXNABEVhgxIThfIar4fO1/F2B3wFYCaJM2oQqyRlnDO8mCP\nFIVVQNOXMY35lTCBHUfxEstxKpGO3NgXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT2eFiD\nz7WB2rFmf9o07z63X7seBzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDUpbEle6bbwM+iuByEmQnc2z8YFXlnAYR4vBbB4XrFpAIhAMG4Hp5qiz3R\neb7XIzgI3Bs+Zbv540/LrfIEdsEBkIsr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1632", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1632` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAYqKVUG8HrQe267cBXzVnwa8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MDY1NjM0LTQxZjQtNDkyNS1iMDkzLWI2NjIyYTQ0YmUzZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNiZWJhZGUtYzMz\nMi00YzVlLTljNTEtNjc3NmNlMzUyYzFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP8wib9LOoUv9ArFFr74BhuN5GD9+G7D4LJ9sMzjjaYrafOsOyOLFzlUXqkyY\nGFIdqSt/lFOViltzOLjhatnkNaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI1xtqRzbkCr3Q4MOUko7Tf4//IMwHwYDVR0j\nBBgwFoAUNvCQbQ1lzr/ctrp+4UCW62AnqYIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAeUtP/bL6fN404\nvs9jAPqcEuRyqwps93xuqACMriX1ygIhANDgzBvlEAHuLjmP5oiud37EERk4yE6o\nNC/fk5YFagia\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ6SgR0Pq0UtrZZqCQdRvNZJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTA2NTYzNC00MWY0LTQ5MjUtYjA5My1iNjYyMmE0NGJlM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS31cc5CKtpGbJsgEPZgyf75UtXKG/67xKa0w/iw8TXWwn0\n8OH+AjBBM9qSgqth6UFMwvwE7vIYn1DP25SsC2oco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNvCQbQ1lzr/ctrp+4UCW62An\nqYIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOSnOBXQUZINlZsSqFiOPgg1t+zfzafcd5XNM3KyXAKKAiBEJXFslErV\nEF7FXdXOpSlZIgvvucAjsRjUr/Cm9cVIkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAYk4ZwglbdgPWY8BHeVKUy6IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNiZWJhZGUtYzMzMi00YzVlLTljNTEtNjc3NmNlMzUyYzFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNzg4YmY1\nNy1lNjQwLTQ3ZTItYWM2Yy1lNzM4ZjAyNTEyZWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATKPSRsUXdVvJ80gMcKLv7+XzN43iGE+YSSYiHvDvmdHfA9jlXcGXot\nFU9CTOXcBbJj0yKiVRr673Mg/9N2p3R3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQjXG2p\nHNuQKvdDgw5SSjtN/j/8gzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIBBGB6bxPOEkdkwXq5/fPgIJCYpELY9iatY1ti/SqhKLAiAOppirgdVtwtOB\n09loIvJxa2pDpg8qqZbjK2q1cdOnfQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1633", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1633` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISASradgsnzFxxxVZkE94xw01mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YzU4NTUyLTRmZWMtNDU5Zi04YTUwLTRhNGRjMmI0NmExMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgwNjJmNjItZjIx\nMC00MzJjLWJmZGYtZWQ4ZGIzNDk5YTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKm9n0Phkuho6R1jzStEkjGIF5urjYoCOoS/4YtCIKFV5q0LndQSMxnEatREb\nvXLjZEIcvYYgP8CX3M3mlcq/0KOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXKM4LPLr7tgV6kPefVq/VSaTwQQwHwYDVR0j\nBBgwFoAUp/a5LGVm+PBWtn+iVX0zhPPfWuEwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBpi4Jo0fVA2iFZrbRV8QGg\n9DCAN2Phbr9dVLPqlqESHgIgH9FVP6T7CT9UXl5GC5XR9iPiI02bkvW+hNIEao+P\nBmc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWNcIpQH6SMWzHCIED01omBDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWM1ODU1Mi00ZmVjLTQ1OWYtOGE1MC00YTRkYzJiNDZhMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPtJSo6ZyJGgAkt8Ts9GTY4IPF56VAFnR9Ks+HBh6wAwz+\nOU5/d8Kbep0p7okZMZZCzJll6CduZAqUFAtaiOV9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp/a5LGVm+PBWtn+iVX0zhPPf\nWuEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVrMHeImWhC1p5kZoV/Jn7toL+iivELpcbSHBU9lO9M4CIE9OvjOm5qoV\nydAV+EAbWttK0uPGgjnlpTR4z4+wPCIC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAbbwVF6neJow78ccN5bYWKQbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgwNjJmNjItZjIxMC00MzJjLWJmZGYtZWQ4ZGIzNDk5YTA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZGFkM2Rh\nMC0yNmY2LTQ3OGYtYWQ4Yi00ZTNmYzY2NDljNDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARsDGyEmGcrmXUsJaq6Je3wxkomFv4dv6t9FUnjfN4W21Lz04iBhCDz\nzggxNMRCJQl/kv7lYwDdyU6gXfzbipA6o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRcozgs\n8uvu2BXqQ959Wr9VJpPBBDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCLe6oJiEcMKZLr2p45Vc/5LTNVO24aUDbEWqfNpDzvpQIgeeKL61ZF4/EQ\n4JDjVuX7h3T7md/xuSwI7nj694IciaI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1634", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1634` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAY0I11NB+4UQI6yxAhn/rkhmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxNjUxZDU2LWM1N2MtNGJiMy05NjJjLWIwYjIzOGJhNGFiZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJlNTQ3Y2UtNTcz\nZS00NzhiLWE3OGItNjUzYWQ2ZjlhZWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQg/0SM0rT8hCKfk80SGP/HHbOxXb47pWEosxVLmaUB22maF5cZSxAovg7ihR\nWwYFjoG3g2FA9qMhVbDOGrJr0KOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG171mFNQyAu4389nLymZCsivS28wHwYDVR0j\nBBgwFoAU3MM2gzEU+OUHDJkcXvx2Sz/nR14wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAwsGU\n+7lCM+jo747yNREgHCqGUyBH1dWaCj2XTYRO+eQCIBCkiKzBwh6XxDtJLWjGNTa2\nWOu91X6q/+FlKCpbA1vq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVwm1yqjwsN2AjMCFGGLL30RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTY1MWQ1Ni1jNTdjLTRiYjMtOTYyYy1iMGIyMzhiYTRhYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnqupnxgcCf4l3iFzSZI0UZ0GAbXtYtvOvMDzBH1QXaMtm\nyzUQE28/AQjGErJl7ApVMVIC79f/XHMCQt7XxIVWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3MM2gzEU+OUHDJkcXvx2Sz/n\nR14wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMjaxnwSWPnSFMZowf0lrkc1QyrkE6uDYoKIU1j29lJwAiBHyPQl3pt6\nqzPPZ3ALWO4PrOTsvie8U+0w7gP8q7uPgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAb3BWuOO4gIZuTqzYo5iKIO7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJlNTQ3Y2UtNTczZS00NzhiLWE3OGItNjUzYWQ2ZjlhZWIwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZTljNTk4\nOC1mNTRhLTQyZmQtYTlmNy0yMWI1ZmIzYmYwNzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASBui8fq4TR41ftgUFQZUzWuwuq6sj9g1HRqT6W/3H0hrxXAsLw20/i\nRqmyePnx0MAcVyC5NMsLoUrFpuw0SWHko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQbXvWY\nU1DIC7jfz2cvKZkKyK9LbzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDmq4UyYcEB/VrdIOO116f+R6vlJLqnyVRcadBWXC50KgIgRiyIA6HFzGTi\nbsdKYOFfKiW2rKg9liCrZx/YC3H6P5Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1635", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1635` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISARFK85eq+mgRVxP1KnNjSlGMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2N2M0MTRiLWQ4MmMtNGVhYy1iNzJlLTZkYjlmYzMxM2RiYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY4MmViZWYtNTUy\nMi00MjJiLWJjYjUtNTM4ODgxYmY5NzExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt1kDFDCyGVu2led627THPUBHDeOU7Ny3NZrduNZfjeaBgOAhIVfvGNNsVKVs\n1gCh3v+s4bTczkdOHulvvNM60KOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyvI+ctA90N4GBaEU+U9oveLhBjEwHwYDVR0j\nBBgwFoAUThFUKv0Vi8pGG/Jm2i210FEEAUEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA4qi8\ni6ZGdvAqmDsdPwDM2SN3N8PTnjzIuDNVtoj/BLECIG3Zi29G/ZTM+N9Kq+v0c+WA\nH0M408szM61BWKs8EH0j\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcmTeTQ6+0+bYkdM2U/zch/MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjdjNDE0Yi1kODJjLTRlYWMtYjcyZS02ZGI5ZmMzMTNkYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFsi1dCoxrBocoWbe5UqdYBJITlSQY3IobQYD8JE+8sG9+\n9H9V6IyHDuy87lpqbnN2Ugw0O7jCso56jfkd8suRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUThFUKv0Vi8pGG/Jm2i210FEE\nAUEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPquiC6LFABMilxPmZ+JKLrIeulWAQ3Him98gVlR3s7qAiEA0rmY2b30\ntZ4Zkkeg++6YieSCDT1AgXdB4/UD9UK4KPw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAXaUfrAg3/sj9bYTRQ/0LbDEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY4MmViZWYtNTUyMi00MjJiLWJjYjUtNTM4ODgxYmY5NzExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OTY1M2Fk\nYS00YWE4LTQwNGMtYTJlZS01MzE2YzAxNzFlMzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQXEbf2V+lVLbFhUsmKwob6NKWzvKp1G860G6Xa10ntiUayZ0ePZ6fK\njWz78OYSUZglUGPvjhBv8+wI+DMa91sdo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTK8j5y\n0D3Q3gYFoRT5T2i94uEGMTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIA97hsj/QSeseDz+RnQ5vd213TeqwxnadIiGGtY6reHjAiBmQZXM42VoTAWe\nagrQaPhsMB37Y3/Gj5+WovDzrT9/fg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1636", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1636` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaPT+NSfeUI9whLgcKA3uR8PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNjY4ZDk5LTI5MjItNDhiNS1iZDAwLWYxMmMwODNkMzZlMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFmZDJjZjMtYTEx\nMS00N2VhLWIxZmYtMzJiNzFlN2Y0ZTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER9TZ+obyqWXO7/KZu+jrDJLsRz9VvKdWIEmrWR0kQnuzo0DaFUEmZfvN2xmQ\n/A1cMsAITdoFJkD2+U/NCmfHlKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBmRkE2lU+ikKl4DkBdbYClcNyq/MB8GA1UdIwQY\nMBaAFGpvTHUpukQpXfcnpeajfKyj+kMUMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAhBMK5YiVHmq9QpsmeRbfV6fiVT6iyFYX\n7kMGcAJjuDICIAPQemFx208nYQgKgsjeA5BfshFveYY1osICRR26+w13\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASPS7LGzV6VM+MCxboMSeqK+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTY2OGQ5OS0yOTIyLTQ4YjUtYmQwMC1mMTJjMDgzZDM2ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2OcSFk7u3M5Xr8XN8h4r5V5xSH21vY9X+es/0/7/mAVKO\ngjNDbXxD9i4rwEQCEkv+4GYlweNIQsUbZ7NRIdiwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUam9MdSm6RCld9yel5qN8rKP6\nQxQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKoR7ALkUjl0ke/KcHgd/M2vTGXkKMujRBIBWLy/P/mxAiEAmbyY8aWn\n1bg6VP7XyxzBjg+8WZYHkFgxTa9T6x4IOkk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAYiKzL3hW37EKHV93l34Sr/xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFmZDJjZjMtYTExMS00N2VhLWIxZmYtMzJiNzFlN2Y0ZTU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMTViMTkw\nOC1hOTY2LTQ4MDEtOGQ5ZS02NzFhMzAyODk0NGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARPnVzwsM2Rc46xexVhGX2+j2gAPzvoA3Xp0lrzguSaeeHvgnQRNK/D\nbcH48zXvYMUz+7QBVtFwPNvTo2Ajqbooo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZkZBN\npVPopCpeA5AXW2ApXDcqvzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIFgjuWl5GPnlTQL37rryhVEkWrT6SytAwjMJO5JgXIq8AiEAja7kwuClnvH0\nj1/V0BZ08GdUWK1vVxDE9yeSx4T28fc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1637", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1637` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATLq+hVaKjibEYVKevxg0146MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkMjA2MWY3LTg1NDEtNGRkYS1hODFjLTBmYmIxOThmNTllMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk3MmJhZjMtNWJi\nNS00OWMzLTgxMWYtMWFkMDU0NWFkMzBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJQXFKIEmP73458R93updES+E7P05TlSuFTtb+tBJ49JHcGeUTtfiHtU36gpo\n3Pchv8iFW51/arjAxdNgAlpoUaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSunOV/DxPKjWmVfrLN81SI4awREwHwYDVR0j\nBBgwFoAUoVNcZBvx2JFy3yLaydoRR6YDGegwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOImwm/ArmUy\nMPO+wyCIa6j1nNsqhG5ljqwhAcu6QrmKAiBwBTbC3sTAqvZ+0Eyb/DCmb8nuh7Rl\nPqICdBEsfxkNmA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd01/JGNEIoF1UfXud5/uGKDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDIwNjFmNy04NTQxLTRkZGEtYTgxYy0wZmJiMTk4ZjU5ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdP/iGTSHvuE8sxABUXzpDwIQWUczQwgZ6MWL1xzG/Zvxp\nQnwlZhRtn/y5FNxtZRuX8LsFT3xyVY0pqFQmXWMno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoVNcZBvx2JFy3yLaydoRR6YD\nGegwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMkwNSrPly+yaDZLKIouIjXwO9FuFvcenkr4WnvO/jBgAiEA3lKNPbk+\n1/VA/1FJ8US3nHi/MmDr07u6ob9D+oifQlU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAdqNBdWN2kYUmGm8MV3YdrYkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk3MmJhZjMtNWJiNS00OWMzLTgxMWYtMWFkMDU0NWFkMzBhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4OWExOGM1\nNS02M2FlLTRhYzMtYjk1Mi1jODhjNWUyOTliZTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS0xtexcsNQ0UH/CD/PqQB5MLK/QiKU+TS+kvmF8MAHJ7NGfev16g+B\nlNJyQ3Y/SOdb8KF8ojRvNZRd4BVoWyflo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRK6c5X\n8PE8qNaZV+ss3zVIjhrBETAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCGfejNMD9/r4SC0mvXCBj3wWvsyboGkza04Kxo0NcTVQIgTYH+4MwTHcMl\nDgWLQEyrtLtMBR1t1DubDXNg8vi1rF4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1638", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1638` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAeIPkW8YzJV8pxRj+q0EL3wWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NWM1ZWRiLWRhOTgtNDhjMi1hMzM2LWNkYTZjMTZkN2Y3ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTAyMDZmNDktMTA2\nMS00ZTE4LWExNjEtYjY1MzY2Y2M1OGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfIUD7ytefiyxc/RqHhQd1a+8doAqPV4OSQURIkQqc5OOKEY5SMM2eZxO/UPP\n46w7waYmymMix11FZWZ7MfRCrqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF80CGeqBupbJUXWzBvFFioPTSqcwHwYDVR0j\nBBgwFoAUqAnn1dpj4K3vGLptm+mrPF6Jw2MwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgUiPmY8YtSPNS\no6eXph0alK6S+whANY6Dk5HP/P+xinkCICzT0U9+8hHqhTN2WZvfpOn+2qLJWb/x\nFQYZzqVAMlib\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARlaAukMA+OOQtTxjUTBAtUBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjVjNWVkYi1kYTk4LTQ4YzItYTMzNi1jZGE2YzE2ZDdmNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQJCwfCKG7CVmpaza/4/wEKqTvWzcpMtabrMZbpff2paLO\nqlHW51ruIjTRZ03kpkaFhlspGK9niG1EuJUt2x8Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqAnn1dpj4K3vGLptm+mrPF6J\nw2MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPW0iuAmmLEKQFPY1EDYNCqLCWlV6s48dOUxeMbuzPBtAiEAk58dNko4\nQuE0ST8n/TGWLMaLau2LpDjaymYSTijI0po=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAWPvReEVtL2UfvNsKS45Dt3RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTAyMDZmNDktMTA2MS00ZTE4LWExNjEtYjY1MzY2Y2M1OGE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNDVjYmZk\nOC01ZjhhLTQ0YTUtOTBhMy1hOTQyMDVmYmRjMjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARhknJMn1Jz4zhgy3qjYo1lKy+fBa6b5yBvoe8C9CoGc9GwYX3Ly7W5\n7oMcrjBooWW6ltGxHei1VNHZqEjpV8Zxo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXzQIZ\n6oG6lslRdbMG8UWKg9NKpzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDSjcW6M83AKcb3JKGDkjTN/Hq2xC9LmCJ78OPpVcXQQwIgFJt2C2G6AWjX\nZN3+F7YKrAJItdxpTNKdSPBmvHFkO/E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1639", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1639` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbAo4Bqzvjka1d5j4YMuoGiVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjMWE1Y2I4LWJhNmQtNDU0Mi05ZjllLWY3YjcwNzA1NGI4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBlMzZjY2YtYzQx\nOC00NDI3LTkyZWQtNWNhNzliNWE1OTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2fYsi5hlsCkXL0iOITWF7Dnej1ufL1Oo8lQ1BfFvckatLWhYLKfOjqzGTxrb\n/IvbH/uU0eaJfwCA0wHRbxLfAqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUacrOnWbfd93U6u3E0ICphYsDxJ8wHwYDVR0j\nBBgwFoAU8KL6LzvUyX82EJA3HksGfHevYecwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDj6MX5I1i+\nnktwo2f6yNY/b1vaS/SrqjIzKuII32otiwIgZhibhu31YW5BtmtXSNDoQfc4YydJ\ngD24RUFRPKa2F7c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcWWu0dk4zzUsFmYqx1/otoqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzFhNWNiOC1iYTZkLTQ1NDItOWY5ZS1mN2I3MDcwNTRiODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQx5PJ2XRWE7sVbu/hQNrO3spDys7/Ut7AAkJaisoreLotf\n3sz/RsdU+Y5VfqYOLy/zxbkzKMiDqAT4YC+x28Muo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8KL6LzvUyX82EJA3HksGfHev\nYecwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFcXqcBPAIA2e+ndMF3KbPb3stNBLBxJV5i9IfMm2n4ACIQDNnKYw6N/k\nJ8GKssW2LfID8Bb1JbVVxxF1zMJbPoxUeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAfg3zzNZrevJPCmFrSubN8i3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBlMzZjY2YtYzQxOC00NDI3LTkyZWQtNWNhNzliNWE1OTU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ODRkMjdi\nNy0wNGNiLTQwNTMtOGE5Ni1lNWZmZmNhOTNiMmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARoFKkzYjz0Q+6d047McFVLFWSLnjMDLnVTJSw5S5YUwyZKIE6FmoQI\n39hKcMyQ85nF/344Ejn1LQ1wG2pF5iito2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRpys6d\nZt933dTq7cTQgKmFiwPEnzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIFWibk34XKPsLffM2G/AjNpI4QIQhMeiiacfeT2LUQR6AiEAw36B9aBv4pKu\n52QId1Y+SO6lNswi+8OC8VXKsGcyW90=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1640", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1640` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdWsCLItE9PFJ9MZr66H3IMZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllZGI5ZDc4LTExYWEtNDA1My05YjYxLWVmYTQ3Yzg3YzViNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjViZTg2YWItZjli\nMy00OTIzLTk2OTAtYWM3ZDM3ZWVmMDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpo9HHtEPJhakdaSwXYo+cGxFk5/zykCAqCc7M/9iEhsSuyx0en+SD01kTsFE\n10dK0AjKVJATXwhCGrwjyUEVIqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4SYJc1l42pVv9adc/gTCmyEsk8kwHwYDVR0j\nBBgwFoAUGXuXIAUWYvkrmZKhjORd9blhB1YwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHR7cQO37NnQgMewJbBol/tPX/4GI7rWpo3KSbnW/fBaAiEA9vFnOssa+RTq\ndRVqY5dAssSX7BDSZUplW5ABWOYBS0s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY9wQAxQUmj+xWwz96sotapLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWRiOWQ3OC0xMWFhLTQwNTMtOWI2MS1lZmE0N2M4N2M1YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATr1CMKVz4R5vwACPIl5ZUPyO1thaGiizXtngfxte+z4s+E\nzFmYGU2bJ04wRl48JtjsIaW3Qb3WTBCL9tG89juAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGXuXIAUWYvkrmZKhjORd9blh\nB1YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB8ENmwG+xsU+/1K5/k2zIYiKXKLwKB5ta0V1j/PE+EECIQC/W9m2z1/0\naBJajI5vfJvhWeUSKfGGdQBR2k7vv37NrA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISATZCUgR1mgl/EqH3gcjgYZYNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjViZTg2YWItZjliMy00OTIzLTk2OTAtYWM3ZDM3ZWVmMDJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OWVmMzIy\nZS1iYTRiLTQ4MDUtODJmYy0zNzdkYzg4OGJmM2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARtnzt1kZax6h+McJk85J5BSqQPziP6f51KNY7EEPMm+fT8qqh6rGta\nPAX7XodqfwWYE0cUnR0oIuekQJR4g/gwo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBThJglz\nWXjalW/1p1z+BMKbISyTyTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCID2WBX4HPgj4jBCthjp62TyDUC7EE73rUaOcAH8PbYtwAiBtem8/wwcveUiX\nWoD82o7T8bvMegeZM42tYLhOY+PU1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1641", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1641` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcb8PbHq0S7UZcgyj/SqFASSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmOTE0N2YyLTQ5MTYtNDAxMy05ZjVkLTJjODc3ZWY2Y2FiZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQ1N2I1NGYtYmI3\nNC00MjZjLThiZDAtNTBiNzg1MGQwMjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf73+uf3mOZ/rHdULCSx63gbbL7XzNrrVkXYrcMj9DueQwgnZtQ6gDWLUSbAS\n2jYvqqRhT31Fj/BFu94PVVY1IKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3W1Q19tOZmcSPSH7kok4lvbTMR4wHwYDVR0j\nBBgwFoAU8qyNHCY+tVEg4Rcj4ix3hBYVdy4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEwNdKiHt2ggVYWY+zgjKgW/lKzNNAUIk77XdgfusX1FAiEAj/rc6EMN0SL/\nj+o2RyD9lSmyCP/AIe+4cMLpDQLFtPI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR8MDSpJSitD09I/a6YM8K2uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjkxNDdmMi00OTE2LTQwMTMtOWY1ZC0yYzg3N2VmNmNhYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNqRc/6UWyXBCoTTIqTwtSpAk/hf1UAioqeeDGskqDMyv9\nZY5xx1biI78Vn2/9EK25R2/LJONT4cu98QuEYR+8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8qyNHCY+tVEg4Rcj4ix3hBYV\ndy4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALB0rCTIWh0YvGymdVi4wwUtP64vURmYZpjv4xi1G8cJAiBx2qqgqNb3\nTIGnnDufe0Vc86ch/mrwlAHd6xgTY9/g0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAWfQ0JYRgrybaOWMpJbMgg2dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQ1N2I1NGYtYmI3NC00MjZjLThiZDAtNTBiNzg1MGQwMjNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMzc3Zjky\nNC0zM2M2LTQ0NzEtYmQzZi02ZTkyNGZmZTI2NWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARLS8qzMqF6FCbkwrTiUPkDkfXUvucaTKw8PjvwdsQvRlHuG8m75L1p\nfffCgzDcdXTvdL49ytJ5HwmM63nEkYhVo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTdbVDX\n205mZxI9IfuSiTiW9tMxHjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCbTQj+DfnKunbZoTRLFUz9ckJF4T7UYN/jMavj1YWD8gIhAIk8wz096w8O\nsbZDXIlPg98sY0gVFIh6CfTvm8d9VN69\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1642", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1642` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAYwNlw6CDSw5V7X5kJRMdid8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3OWE1NjRjLTA1ODctNGZjMy04NzNmLWMyZjlhMmIyNmQ3YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM0MDk4ZGUtNTg1\nZS00OTlmLWI5NjgtYjlmMDgzYTgwOGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFuI+hDoCSSGi7uQZfJESmfDAiCTxfGXpNHUjDB3gw3P6UsC5MktZ7FTG4jj3\nRax3saGn+9PrBvpPugd/G1hAuqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxzkydOdFt8cXwaGHEysjJDeMaQEwHwYDVR0j\nBBgwFoAUkDLxgZNlDbzEEHykNkXe3kuUtwIwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICK5\nr+ObzUpjvaWILnWcHaMtI+cKVn5xaaHXkCi3hPjzAiEAzz2DSiknbrqUp/6WHGo5\nTkKxUK+V7PhaEVyS9EWYmb0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT1QWwu9y0ZYgAsyIOmbw5QeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzlhNTY0Yy0wNTg3LTRmYzMtODczZi1jMmY5YTJiMjZkN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPwqiz5cazbh2hvlloWmI+9q3SRQ7ZGd/quoELIJB23rk2\nt2oMfmr36aceVIV1FcA39HN+wcTxV5GSUQjcu3F1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkDLxgZNlDbzEEHykNkXe3kuU\ntwIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMUnOUJ3ruAXPKsDh2697GyzuGAHO6XaCESHZTwEYgsdAiEAwi7VphPa\nPJ/5VBUs//LxsTdxbeTX3F1x5mob8gh2YRg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAZjX0HdEwIZTDLJVIppQqOdEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM0MDk4ZGUtNTg1ZS00OTlmLWI5NjgtYjlmMDgzYTgwOGMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNDI5YTQ2\nYi0yYTlmLTQ0OGQtYmVlNS1kNDRjMTcyNTkwZTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASmb5EpC4ix31jLNcjBikpsgSIAnYAel5a5JflT0QWbUXFjf4DKoQRU\nFfa7BodQoCuUu0rwQy6iF1DkZ8JO6aAeo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTHOTJ0\n50W3xxfBoYcTKyMkN4xpATAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDBZJ1+1IcsJHrps6Qsy5XPrAtvae3Iv3w6J6LjyYneTAIhAO0n4zUkGD6J\n9DLAKawq8XoLFcSlK1VLROkdcN8bRlFh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1643", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1643` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAbkOG75n2kOdHv7kT1zOKGgeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MDkwODU2LTExMmUtNGM2Zi1hNGNlLWY4NTRmYTNmMmZmYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM1OGNmMGYtNDJk\nNy00MmZhLWFiOGQtNzkzYmI3ZWYzNTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbKsbOdFY+umTZh22sobZ+YTLLtnkGvOF8PCtctJqZKvcmofMzrkY/c38WFg+\ndfwEhpmCJwvV3SDmcLy6unwdoqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGW3pqEsnkwLRlA5Eu6Pdfv8aTFIwHwYDVR0j\nBBgwFoAUqB5RU2wtgUmVGZ5vuSn2IuZQPI4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCpaI1FlbuSgtgdjIAisZPIKv6gy2MbjACeYFaALy+aNQIhAPKO\n/dEcCiG0uj79kOXipmnfoxLm94NsCu9Qj6HZpBLv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVtajCAP6R3dWKQwao0ScAZLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODA5MDg1Ni0xMTJlLTRjNmYtYTRjZS1mODU0ZmEzZjJmZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlH4ZTety0fMBykPVlKZhp9z+QZI/5JYIaAnAVHTfMI919\nPLTmFFeU0/H+IbXXq0FpLjSCRxlFEAl29LkWZBe1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqB5RU2wtgUmVGZ5vuSn2IuZQ\nPI4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWRGyiZWhJrYNcVbsrxZ6jdXTgUGUuIIfyUvTaIinf1MCIQD/WCk9tkHE\nFtcH+oJxrnLfLwiKDZiDl4HpzgLNiPJeug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAd5uHFdfHQgPEVgejeFWDi1lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM1OGNmMGYtNDJkNy00MmZhLWFiOGQtNzkzYmI3ZWYzNTU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYTU2NWUw\nNC1jZTc0LTRiYmItYTY3Yy0zZmQ0YWJjOGNkYWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASYIA3oB7zYKyZxN16CYooz+iXZTW/zt0dNzintuVodrKAXC6u1iPMC\ni+5xXgG9VHu7+koghZU4VlnIFRT7YLZdo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZbemo\nSyeTAtGUDkS7o91+/xpMUjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIA9cYjKC0wa1E3zv84fxOPZLSl0BLWvHpywwFaNdVL/KAiEAyFRV6+iuFKM5\nGypXHqL2vnuhyzMOM1YIHXipNhckomE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1644", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1644` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUUsDhiYFr/FZe45EvNLgpFsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmYmNjMWM4LTVmNGYtNDY5OS1iZTAxLWNmYWQ4NmZmNTQ0ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYzYWUwYjUtZjll\nOS00MjcwLWJjZWYtOTQ5MTRmNjRmYTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER9m4qxpJlHQxw2zsvQV9d+DOHg9TMdbHt5GFjjS633yAKFxP/ejztIjZgRal\n6PiGVpYLVHHRoPWUhiTn+KWdiaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhqMaYkqsgD0AnzUqKrMU/t343IgwHwYDVR0j\nBBgwFoAUL0x7St+m5kcHUZDpcs/MKDngrdMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDW6k9OjsxmCPq/zQ48JCaqFsO5ZAsF1avUtAfwF4TZtAIhAKLw\nI8hXUsU6RHVp/B4EREjIHOyF++AqjjYXWiV7KVaJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARSuPsBA7T4ji9HavdqEibkxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmJjYzFjOC01ZjRmLTQ2OTktYmUwMS1jZmFkODZmZjU0NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQY32ChuX88qUPrkpyuWdw/dtm7webYoSLqbMZPwa87dNPt\nVCJRwRrjsCJMw+oUBA35h7gPwM/a79qDZv6nEBSjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL0x7St+m5kcHUZDpcs/MKDng\nrdMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKkKBiRHwJwlWqHfd3uFMcYeXufFJ7jbQqGG+ETewyPgAiBbDfnkdLWn\nNuvmYQ0i8RDftz8a7SNR8CBm76rCbdYgUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAS/Xk5p+4ulTpS8MayP+UTbhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYzYWUwYjUtZjllOS00MjcwLWJjZWYtOTQ5MTRmNjRmYTNmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NThmMjAx\nMS0wMzEwLTRlMjItYTkyNi01NWJjZmNmNGUzYTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQkpvb3qp/fOVdhHPkIsMb+V6BnkRzrB3Os1MoS6W4h9VmHyTc6qAXE\nx7l1v9CDiCfuu0VzVFjgkwEeb2zU6ZWuo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSGoxpi\nSqyAPQCfNSoqsxT+3fjciDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDHC9cUtwW3h16PFyW2KruUVGGfl/sdU1Pb1MQtLpH1wAIhAKI+awOnnJIK\njCUMMDOpEp1BdwWEjOiRdexyFGzSgvOm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1645", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1645` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUCCoFOVo7pgb1zJLotgLKeVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZDg4MDg5LWE5M2YtNDhkZS1iNzljLTNkOGZiY2M0YmE0YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NlMDg1MmUtMDY1\nYS00Mjk5LWEyMmYtMTIzMzIxNWQxNGZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPPijPDDaDer/wlnaJnBTHPBTPGd/krKIJURhmgkAbHCzwRTQmRb7i9sG/dra\n3+DEXbCTfxm4p+U8xd8Bf7Zd+KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCKe/jOLi5mBuHtY1cWx8IRWvnCBMB8GA1UdIwQY\nMBaAFD3G6MoA81qPUahqS6cSrUBjqX3MMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAyqOaXfbT+e2NEfhQm1MoSsMNjYsuYns7\niuYntVPwBAACIBEWj7oRP+xbnfURjrnB6BdMyXCZ2MuDaTDjfTV++vQZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASMRbGWy6IapSpXR5C2SHwISMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWQ4ODA4OS1hOTNmLTQ4ZGUtYjc5Yy0zZDhmYmNjNGJhNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrmOQaNzzI0BSSbA9dx9Jzk7iff93k/6hutvncJowZWlDG\ntM8TSD6eZwBHz4gvk164Nbce3IkoQY4IUYGIbnWOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPcboygDzWo9RqGpLpxKtQGOp\nfcwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcxtFlq/hsTq07JNdj3GxcoGvazubFRzZ0e7V3aN63AYCIBvJf+hKzn+5\ne4gqdKQzZpAY9ncMI3IbqJHLe/atwb/I\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAfzjyaAFO1SHXLkuWe+YJBXrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NlMDg1MmUtMDY1YS00Mjk5LWEyMmYtMTIzMzIxNWQxNGZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ODlmZDM0\nOS05N2Q2LTRmZjQtODIzYS0wMDFhNTJjMGEyZGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT89lwoYAAWJ5oEVUNCDbzCErgEV/Fb4wFBQQDESeydJr0f8/J1sNXA\nbknNS2wLsuMFgwowkpwn4lsLagL43rrDo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQinv4z\ni4uZgbh7WNXFsfCEVr5wgTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDNMRefgzrXE8ZwLI06lwzJOnq1YxnPV+XMPdu3F9mUbwIhALltW0xctqKc\nk/tbcFywDh8Ntl8dTycyCgUKO8ewtGKZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1646", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1646` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAai2yfz0qLgTAftJxbh9RVvUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwOGI1ZDk0LWI4YWQtNDA4MC05YjcyLTEzZTBiMmZlY2IzNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFlMjdkNWUtNTgw\nZC00ZTg0LWJkMWYtODJhZTY2NGZiMDEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES373tVEtM/xinsHPo4arCqSns0BCSjMVdffWYSFhMPzpVMbH3lBV2dctHZbA\nucQ7i4tfAkBqMs3Ku9+x8L3lgaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8cB4nDDxNZsDenEwDRnn+h2SjHAwHwYDVR0j\nBBgwFoAUFQ8bVPp6kU4b6bJ5Aljd9hBSBPMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgJd9GnNoi/q7k\nxgm2JOr81/3pssHtmKmLF4MXvswJiRECIQDDhNT+M31EE1UByr+QYs/NFCnX7nNO\nC4AJVrw2ADZRrQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe9zsU3/6OkPLxcQ8oY+pW+PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDhiNWQ5NC1iOGFkLTQwODAtOWI3Mi0xM2UwYjJmZWNiMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARl/0b9zHNeAiy3iH+F1C9+MsK08iLbuQrlrtmw87RqCyRw\nagmKTp81VnRItSVUeH+0tQ4PMx98faihTD/87MbEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFQ8bVPp6kU4b6bJ5Aljd9hBS\nBPMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMyPDFOQ/eXUTk1dAZE0FF4FDIWuyNUismhqjLZhx3FpAiBbcGUhDm8c\n32Wuh3/kB4DoVg1iWHCdmBuxLML9lHe9pw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAVjTjntMlmrnyzNpruAT7qipMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFlMjdkNWUtNTgwZC00ZTg0LWJkMWYtODJhZTY2NGZiMDEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NzBhZDUy\nZS1kYTEyLTRkNjItYjZmOC03YWI3MWM3NjQ0MGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQsaz5DRyJ+VXlGD0ddX0i7IMBaaGMiuIJZuUvh3SMHEK+kW7tbwAql\npbSsBKCalS9+VAjuTmNpV1hn+LuzFfgCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTxwHic\nMPE1mwN6cTANGef6HZKMcDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIHEmWT6ZoH4QmIB2ovnnJDOZ4cL6wB8vFPZe4GQgAngFAiEAlgX7VHwD9Cbs\nYfwi+E/IEZyvfXDrxFqZsXBEoL9rBEU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1647", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1647` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAeh254EN75XMvQqCPuv+2PpJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4M2YxOTc1LTVhYTUtNGI5ZC1iZWIzLWY1YTgwODgyZWQwYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzEyYjcyOGQtMTJi\nOC00OTM3LTk2ZjgtNmNiMGY3MjY4NTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECt7dl8yv0JARRr+tdjpesKg36eSy8mD5XLCoJBAfW+0uZuAVHgTHNng8vpyR\nz/ORZp1+grjZ80kTQHDda/MvK6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFezGUN7BaFFgEPxbQtDz44s5v1MwHwYDVR0j\nBBgwFoAUuONl9Y/mJxRV/qthk0Yar1CEImMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgQkLoOlo8iyh1\n6F1dOIBcYbPAdnHtFya1CTPr2NdGwdcCIEhYuFaKAGmS3MFMBx4Qrb91HtE7AWj5\nqbv4/iFLTQUV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa0Ggb36uC7a/+E9VhSMs/Z/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODNmMTk3NS01YWE1LTRiOWQtYmViMy1mNWE4MDg4MmVkMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGpde5rVf5oOtI0BpyGYqBljtB8g2k5az/kNgsZjhXa7/W\nuo0X/Q+hkowbibhJFL4Nw/UhcA1muoz/caMshmzdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuONl9Y/mJxRV/qthk0Yar1CE\nImMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP9g4Sqja7ydX9ODT2b8FrgcDnceXN+vpTfo6DYDSXsMAiAi58xDsUZB\nUXK6H9E4yevlAfDlvP0zj1W4aFvlUtGcPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAVPnt9wjtTCKWXGqJrUYBIGIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzEyYjcyOGQtMTJiOC00OTM3LTk2ZjgtNmNiMGY3MjY4NTU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2M2ViZWMw\nNy1jZDc4LTRiYTctYTNiMy1iMGM5NzgxMjI3ZGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATA+0scatWtosVoEi7Jn//81roffvmbIj/z2WAjwQX8iH1NMjAwwxYo\n3RdGPa0Zw8o0wMall5BjeEhEztatICifo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQV7MZQ\n3sFoUWAQ/FtC0PPjizm/UzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDPvcPNNTp7+9zmTN1JWHjys1sPmzFkBfeczGDgZzvt4QIgc+Q6vtKNLKSu\nL2WUE09cldTNZ9XNIGtjaYnFOgktVcQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1648", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1648` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWJ4LE/1fCZBZg10XNewfuNNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NGNhZDhkLWM0YTktNGM1My1hMTA1LWRmZDFmYmEwYTJhMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWNkNjczMGEtYjA5\nNS00OWQyLWI2YWQtNjA5ZWVhZTllMDZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuRkMte6VSGMYNnVuuYK5/v0H49suRCr/cQ+Pb2Jg4XpV0vZvPcp3VI2vupg3\nsfbcMdYtczlr+JJrRMj2CVza7qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3GLnQXwLvBPgRjApCF5SNecMpl0wHwYDVR0j\nBBgwFoAUa+dcmGCCtLuwNN5lShsEJ36+HkowKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDSWoXcGPp2\nDHTNdUGF4YiTuKStwhPKP7w6zLm0jm1BvgIgONCV7QBWqJ5PwOoKchbOry0iNpQz\nQiqIweoZuePaffI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASfMKTLWLVAP82It1AG7WPeJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDRjYWQ4ZC1jNGE5LTRjNTMtYTEwNS1kZmQxZmJhMGEyYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2VBhK6Bgu2gwsYjN4i0WXXdtgawFlVH4sF9/eYFlrx0JX\nJZs/UbGClJkUyXx28lQF9NUAENlRHTa9+ivc/Y3so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa+dcmGCCtLuwNN5lShsEJ36+\nHkowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP+LOM7EyjaCVZeXvaoBBr/xQMMdtS1Oj7MjC9V2EplmAiAywNAOohzC\nbqe/UV2oASumoAEqbB5g6Z+0/6XXrs55aQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAZZe2/i4xaylHFnU2ef2cOzrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWNkNjczMGEtYjA5NS00OWQyLWI2YWQtNjA5ZWVhZTllMDZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YzRkYjBj\nZC03Yjk5LTQ4NTUtOWY0MC0yNzg1YmZiYWRkYWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARptH68XrP7r7qK6NxPrVa6XjAy7Rw9zGFiUgkVRN3Wx7SNurhw2izO\ncRBF9ji+SwEch3CgPQNS2FbtnJtvXuh5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTcYudB\nfAu8E+BGMCkIXlI15wymXTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIGthAtBf2edWLcBI+4G78A7BHswe4FT/Nsu+z3UhnzQpAiASyfGQFW7afV6r\nrXMCf+7tECiIyLCI47GKhnLZ6xYNig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1649", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1649` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAct7udbZ500P9p+vQFp9L1M/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyOWE2ZDBmLTNjYjUtNDBjYi1iNzExLWQ5ZDliMTI3MjU0ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjYxMzViMTUtYjVl\nMC00NzU2LTgzMjYtMzgxODNiZWM2NWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEolSHbH/O1K/6h1G1tduc/zlgqH2XU2E2fmf65RQOG5o9S0oBS1Y0EUrMTEG4\n0+WGuLgE2opnicFTBxz2L7SGbaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGPsdO9kipB54aI7cNRz0bafH+T4wHwYDVR0j\nBBgwFoAUFnEFCa893YgDsLqrQqGMQKGFJLEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCYA9qNiB8stRlXNOwyKEQGmHnuyT0Y9tuFi7fruDyOqwIhAJxGHQ/6z6+P\nQC4FhB2HRc99+s9ThNj58wwPyBZoGAX3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUiGOcLvwSbIpM4uee3+Nji+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjlhNmQwZi0zY2I1LTQwY2ItYjcxMS1kOWQ5YjEyNzI1NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfSBOTRIWOA27YQrgHhstPxNca/tmXZWrubEaW+V77aLu2\nY0qfmWbcJ8t+gR9kV7nBuBq89Pvgz3ICKJ3E6Bnlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFnEFCa893YgDsLqrQqGMQKGF\nJLEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaHIdCMptgafVyXwL0Q+CH6jfpAfB76zsJ2k+l+uYeDECIQDEf7j51eAR\naHG4Cz4LxkknMFCSV52QE8gWP5qeq4hpWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAeicOvNf8P2lxlOL1sgBUjzZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjYxMzViMTUtYjVlMC00NzU2LTgzMjYtMzgxODNiZWM2NWQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyOTJmYTUx\nNy1iMWE3LTQyNjQtYjAxZC04OWRiYWIzMjRmNmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARuEMawPm7MzZh/Ufu8uPkXo0HascEWqAWwBjAk08WRvmVyjrSSfZMH\nAeshI/0IcE9Oolt6xKBoq96IQNQHw1Hoo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQY+x07\n2SKkHnhojtw1HPRtp8f5PjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIAeCjIdjMuuZyzfzqInGtsGGdLfwySlLXLi0+67bJIL6AiEAsqOHRMFuDlQF\njbJxi0eae7kHa9VNFdNFCrzHkLIUx6g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1650", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1650` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQa2t0Nw4g6jq0FHJcl8E8VuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1ZTVmYTk4LWRlZTEtNDU1Yi1iMTBhLWFmMzNjZWJmMWM2MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDdiMzIzMjItMDkz\nMi00YTIwLTgwMTUtNzYyODY3YzE2MDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/OwsPBszY2qiOhEO6/w2gNAhlbmtRpg1Eo9NqxfgW18oRKKysL9YYZqgoU7T\npPpR80bKvyP17lWFIw6dAaWkdKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPQ6jDygf0xsLvG8Ssw9JefvYHikwHwYDVR0j\nBBgwFoAU/p1NnxrWFandIo9l2kF/wYkGr9MwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAJc57hYbVRqYJVHVV8rGndPGq3DQSdhPvKMPDsbWTagAiEA1a/XVLkDuaT0\n1fMN9WK4wV3iYgyTs1U/jcdf0Hm9Fp4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcfsSSazRlJNdHhImIuWHRYiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWU1ZmE5OC1kZWUxLTQ1NWItYjEwYS1hZjMzY2ViZjFjNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPA+xUOAs1XDQlpLhyjnkA+stqpipVRLnO/VUnXKlgBMCY\nuf3AHlOFC9i85CIM5ycbbhyZdmHDsuoKL93xJhrFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/p1NnxrWFandIo9l2kF/wYkG\nr9MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAImbNlSR/8FMUIlf03edF7tgu6H/7L0KsNbEshM484JTAiEAmKHFQKYM\nWxz9mI4TqQ0R2h3rX8IGt+zax8nWALhNY2s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAWkVGmjCMM/a3iGn0eNrelxnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDdiMzIzMjItMDkzMi00YTIwLTgwMTUtNzYyODY3YzE2MDBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmOThmYTJh\nZS03MjE1LTQ4MjMtOTQ2NS1iOWYwN2Q5MTZmNDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARiU+1F8O2VlaMoItnwg83f4RcetxfcQ4bDC9I0A0E/Wa7FcKP2rAPD\nAt/5E3lBYBwdghzA+7SJ6y3SPBpa3oldo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9DqMP\nKB/TGwu8bxKzD0l5+9geKTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIBudErLUOVs7716xXr3Q2msDBAHbdqYnYOBK3lHIW1WPAiEAvrZl7CmDrDlz\njpFdPEiNsVPpgHiZaSzRiBPZN4ztHGE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1651", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1651` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAbkpmVFfZP8CXkEkCy3PJPZOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZDI2YjI1LWNlYTgtNGMxNC05MjY4LWIwNjA5MTQwNTc0YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDEzMjI5ZTctOWZk\nMC00N2VmLThkYjEtZWVlZGM3MmI3MzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERZGjHrW4FmwvjuHvinlq2SgDP1f5troe8StML8to4EuE5bbClKvRbUJdQheC\n6+3lx5nHEioUGPCumtLfsX4gBqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrGkskylhbp51UKXrsxEu/7KZW5kwHwYDVR0j\nBBgwFoAUw5tZgbenPbbE8+SlphrVrvY9JTswLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCg\njy9FTHruD/ua5IuMVmcv76iCPW6H1TWyGbOIElzkJQIhAPBJ8iyU4/a7uGRDiZhG\nXoDXO6X03OYG8+Ii9kUcHBQV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWIQsMuydZOUZeeqmv+8ps2lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2QyNmIyNS1jZWE4LTRjMTQtOTI2OC1iMDYwOTE0MDU3NGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI24QHVxEpqZ1Ioz3ZCYXPyyCKKsyg7Bv/8MMPDx2Oe1Q1\n6DHKQK1usvZFzG9WwTaSnOV99zA4fl7sm8n9ZOd0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw5tZgbenPbbE8+SlphrVrvY9\nJTswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPZmsj4uAT1DYzwIMCwxFtGV+IvefwloiGA10Yyx8GWPAiEAuZLk90zU\nRG6fAv165fd1lbibHaB/UCh16fWBSgIMLjU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAV6jMBOhwT1xgsodwZc/ZZqVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDEzMjI5ZTctOWZkMC00N2VmLThkYjEtZWVlZGM3MmI3MzEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlY2E5ZGZm\nNy1mNWE2LTRiMGEtODE1Ny1iMjg2MjhlOTdjOWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ0VLrpK86NiT4kB+gH/64EOYiNTmqkvxkiQY/CcvXMIZkIZEqtXtw+\nibfRdUK98Uvyydx+MI5hGg5EBPKa3wElo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSsaSyT\nKWFunnVQpeuzES7/splbmTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIFt8VTgzzMYO74bO+eI0ztmXYhj2TsripT/aiR+jpEhYAiEAiU7QK9mIMAy2\n7Tj2WYHi1jGJeHRPoNnNpFR4kD+ih8Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1652", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1652` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAdKbCRnuFy6PBeavd65YFaDrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1ZjJlNDAxLWE5MjYtNGE0YS1iMGMxLTc3NDNmYTA1YWFlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc1NDkyYzYtNzIx\nMy00NGFjLWJiZDEtNTExNTkxM2U0ZDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2YgY06Cr6s61/5sjezIDWlyhgqE8S56GysTNJr5DXFmtjyAMki+CirViZ2Rz\niVPBEyAhd4MsJR6iIvoI0umSd6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQLC0eILeh70dz4nD/1TtRJ7OekgwHwYDVR0j\nBBgwFoAUiiy5gaPeWBU7M8JkQsUfdVZsuGUwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCaWO2CkXXy0UQu0LgJe3iaYuM2aCWoX/qfHHxehROMFwIgLzr8\n+TaWGdZ56YO9aonwOIPpvyZs1C+Y0gpMEMrgfmw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZfb8h6XOdoF5QpKKICE+To1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWYyZTQwMS1hOTI2LTRhNGEtYjBjMS03NzQzZmEwNWFhZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfaAmB5w9M/uD1xPO6mNwX/sXWxMlEvRY5i88hPP6qd2NM\nh1xqOLL0miGrqmf0vi307jqeM/1eXuD6TE1gpIMVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiiy5gaPeWBU7M8JkQsUfdVZs\nuGUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANQZIB6TdlSOpHBLctytGmO2SIdIDVi6rmiJzjOdQVVEAiEAwuW8puai\nnlU6jYlRYI7wo88PvkQd6nr7UXkKE5Irs6g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAVPp9CZk9rcWg1HuqADc5gRBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc1NDkyYzYtNzIxMy00NGFjLWJiZDEtNTExNTkxM2U0ZDA1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjY2M0ODhj\nNC0zOGQ1LTQ5NTQtOTBiOC1hNmZlYjQ1MzIzN2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASouWGBOyS4lcKc5+rAtbPQgXpN4XJhCW9TBYTTPZxy5fHrB4TllbST\n7TIVHvpNVNxALOKINbEfT6beKw3onqLoo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRAsLR4\ngt6HvR3PicP/VO1Ens56SDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCghZvtyjzPwQldjO0ffs1pxZy0JK7De8lQjFAphkFZuAIgCVk+SnwHQ4gK\nqYIghwEDM8hMBNf2Nxx8uGIKdsv/ws0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1653", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1653` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAY3tH+RwppgQtq/ADTBcirVZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4MzViYzkyLTA0NDgtNDQ5Ny1hNDQ0LWZiZGE4ZGM5MDFlMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ1OTI1OGYtM2Qw\nNi00NWU3LWIzZjItZWQ2YTkxNmQyN2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkWBKxDn1d+RPJDZ0oW2dDrHVvu3htawahF60DjGQsVnmBaxTw1h6I7IUmOns\nvPNEQz8WxvYWHPKn3uRe1C7ZRaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/zDm0JNqKxUy/OQby7FkHDZzPLUwHwYDVR0j\nBBgwFoAUB7vqt7pSAEYArJ+JUT4bpowlfkowOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIASmEMDNpRMx8ARm41YVwL7R2fCxc3RWEwCuQsHr9UdnAiBfDQyv\nePg5kShRClSN49BxlQqunA7BUh/YZi8Mel5HQQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQk28WPf4FHqVBc+auFtKJk3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODM1YmM5Mi0wNDQ4LTQ0OTctYTQ0NC1mYmRhOGRjOTAxZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScgCCj45qyj8mQGsY7QXZgyCFrQaO3Bfzx2NiIs3pG1cPr\nnyKofaTgFs5oTmE4Yo3yZ7qjUZ9+w7+OXoaQQbfuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB7vqt7pSAEYArJ+JUT4bpowl\nfkowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPHI8KfCercAiA7jqP5tH90AivHbEjw1OgV2d5uxRZ20AiArf0K4Pg9a\nDoLy4rNwUdqulAi9OO/pX+o8pYkEnab5IA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZHHZXxveoP3aJGI/XXKu0CcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ1OTI1OGYtM2QwNi00NWU3LWIzZjItZWQ2YTkxNmQyN2NkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYWE0MWFl\nZS1kZmVmLTQwNjctYmIzOC0xYWYxMGI4YTNlNjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASy14vKRR5IAU5g0Z5xPifHMvoe1EevQAK/dpC11b0TUUYNFwheP6aw\noMd+0LIc/TkVeQNmUsFnGK5UGdDGlyYJo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT/MObQ\nk2orFTL85BvLsWQcNnM8tTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIA8rKsatNzDbVLkfsT9QHDLdDhuDKyKYYZqV/ulfclsGAiEAhhr/GnHIP7fC\nGjItbtDXvWyLqD+R4rw8TkP/EEnm/IQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1654", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1654` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAR/vBkC1x898R0m1TvopoQ+kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0YzM5ZjFlLWQ2N2UtNGVmZi1hOWU5LTZiYjQzNDA5NTYyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTM3MjE3ODItODJl\nYy00YzFlLTgzN2UtNmQwZmZmZDNmNDI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBfzqDzA8kTjSLQxWVpHJg5BOvNdjtRa0im+rFow0BfyqdYuK9ScXInogBS8T\nwA1h/X1HU8AjbAJBvKSHenDl7KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR1+uL8iW2W5KYb+QF44/MTYNJrnTAfBgNVHSME\nGDAWgBSdVJTv+nvqdVr6AeMF0kopOPUM7jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDuOxUrpV/44Cw9VDsaY7H2Y2hSGwMM\nctPUOyn8NxxEUAIhAODg7/WglCeXtWgWOKHP2fTq9rgUY6ijst3CrfNoFOgL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdWVdphgBclvAx9Dyn+JB8hGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGMzOWYxZS1kNjdlLTRlZmYtYTllOS02YmI0MzQwOTU2MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVTOrPIAd1k1eTsC5vQYl9BD0EVdMTkML4lHCDxxbi53sd\npCfcFPgA4OyJXeBTJ7TvWCtzXsfMayx9L60AHGbZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnVSU7/p76nVa+gHjBdJKKTj1\nDO4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVZHYu6KHEXTjadK8YUF7JziSmPDMBF40+sR1l7OkA5YCIA/7ykAiF1jP\n/E0nYRX5PgMzgguX5lCI+WQ030POaAlB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAbcAgMXsZzFaIz4S5x1m4LeuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTM3MjE3ODItODJlYy00YzFlLTgzN2UtNmQwZmZmZDNmNDI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMmZmYmYy\nOS02MjkzLTQzZTctYWM1Mi1jZmZlYWYxZDAxYzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT8xPNqZuwJLoTAX84bEKbOytYrRGNNb/DIG/tKmko/8HcZqR6vJTgY\nnnSIQeVPp3j+6KiskfhmEBXIA7DruSaqo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1+uL8\niW2W5KYb+QF44/MTYNJrnTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCMxg/6YdeqePIIT8tKmtx6uZefCG6CBD6ma419+V3bNAIgPqZJ1oaBB8Nc\nzlJJ5qzjhtCYrM0nwh9ZVUpBeLsySVs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1655", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1655` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbQXJjsHW5KD548jXt021NWHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3YjU3MmM5LTI3YjYtNGU5Mi1hNmE2LWJlYzJhMzBiZDQ1YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM1Y2NiNDItY2Q3\nNi00YjI0LWEyYzMtMWQzY2YxOTAyODI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEstYobc4aiYVtil7dzTFeoZhIHbhlQbRVgDfXZHZh1ZMnaUQM1lbSAuWZ9U0Y\nbyMxFoWlT/zoPPqa3TYzkYnZnqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqE/r4IXU+Go6uzsf7RBI4hfGmtMwHwYDVR0j\nBBgwFoAUJg0VASp7ZrEBi+/4UybrV9O4XjYwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBudJsVAIFr2\nmXZ3GwR6igFOEo5sJbkFXgcSLGlHmMO5AiEApY6JmabIbAOvw5BYLL3M8w6WrIhx\nD4J27tM6Bz3bbUY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASHEIMAqZkP0C2V+pmJqysZcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2I1NzJjOS0yN2I2LTRlOTItYTZhNi1iZWMyYTMwYmQ0NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARReKWU/Qn1VcIBdybh+ls/V4t7dCxlcTDadJ51686Wk3wk\n0Wu9UU9ajGMMbDufYKoJXkH2Q0b3l/XTHyKHjlaoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJg0VASp7ZrEBi+/4UybrV9O4\nXjYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL8vYZcT98Ehbf2Ya/yj4y1IcAlPqPDTa9SvdKhjIlYrAiEA6PU4n1FL\nPzM+T5MLapRCczpxrzMNPtxSsFYr+O+84L4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAbzdGHtRfJSBWsQPBhSqsPeEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM1Y2NiNDItY2Q3Ni00YjI0LWEyYzMtMWQzY2YxOTAyODI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YWNiNzEw\nNS0wNmYxLTRiZGYtOWQ5MS04ZDBhMTZmNGU1OTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARsfAIdgSRxMb+POQFi97shDflh5ot/nooH8Bq9zM9SN1ByffQhtXQG\nN7KxtmzKSrYXUbXBppDaUE4ugLQ2rHZmo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSoT+vg\nhdT4ajq7Ox/tEEjiF8aa0zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCaEMizYdBrfmqraPpKOWa10Ll11IBCn147SSfXLNNeAgIgXe06KGKUVRg7\nOxzvpM0CaFrQ14j0cBG+aGAIWIy3j1Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1656", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1656` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAegDyrmaGLqNYvbczA6B9kLVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNDA0MzNjLTg5ZDYtNDBlZS04YTkzLTdmZDUwMDE3MzBjYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWVlMTk3ZDUtNjEx\nOC00MDNiLWExZjYtNmYxMGU2NTMxNjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELYkOoJu3ugxPhoapTjKtJuCiKEaSeGH1KDEAYxSvzftc/WHfZXpItWjhjy2m\nwuF2hGxF1BS5SUAmhJpUKO6yjqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUee9pNhGgD9ZmZAfe4LBGPl2Vv64wHwYDVR0j\nBBgwFoAUfxEqnX+8LBkEfclRKWFjyS2fvdswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHpp8B/mPOG6\nm8RH5QFX/1yPL8zeHn/sXEbIsKTrRzzTAiEAg2EY83el16SwqNoE3J3jHkJmBQhq\n9iHgQ/hGRfhi4zo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQZuKylL9ymU5NQUXvVERXSQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTQwNDMzYy04OWQ2LTQwZWUtOGE5My03ZmQ1MDAxNzMwY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMEwy281Cc7jsRnaMieOo0wq4Ze2CYo9lOg40u/vytNV8m\nyoiz2GQHHzJrdaS05NXkihQBf/DjpZgwDtgRHz7do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfxEqnX+8LBkEfclRKWFjyS2f\nvdswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ2JSoCsikGLz0BLOKOnLbM6+yuHy5Fi79h1XJnAd6yACIA9wS5zcgB6x\nj3KDqMV7WabDdCuyX8emyM8UeGUbf/tX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISATOe1Po4+EiLhyBKmgygS0t7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWVlMTk3ZDUtNjExOC00MDNiLWExZjYtNmYxMGU2NTMxNjA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMzJkODQ3\nOS1iZTViLTQ3MzEtYjFkZi0zNThlYjIzM2I0YjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQUuF+6WtRNVqb03hAoXzjMXFfsft96N8AS1u5eK2JHU0cXmMYeBUC6\nRrBoAWux8EUN/Sg8+AEnqMUJcGP5x81Ao2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR572k2\nEaAP1mZkB97gsEY+XZW/rjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIG8rFGaSnw673uHqpdvgq9MbPu4O0pqodMoSI6SpTzc8AiAeP7eBM6FDYNPU\nI2YSvVG09vYbNGLg6oYU9NNCjgs7cw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1657", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1657` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAYHJNLBlEVL+QTEFjEjDYZZZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0YmM0YTZlLTgzZmEtNDVhMC1iZDg3LTU0OTdkMGQ3OGQxNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmZkMWRkMmMtYjI2\nNy00MjVkLWE2YzItMjgxMzQzZmJlNTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtZblW0gi/XDjPIi33tc+xdsdNWTCMBiOr90SMtxh5ERszzNCWvHHt55QQVYU\ngTkItUWnCx25F5PEeb3WbZxDlKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV2Myls+FJ+KnEk8RHNyEJ157XoIwHwYDVR0j\nBBgwFoAU5cA+P9R27OcH1cN52+TcbQ0J4N8wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAyqQTpade\ndyTeB+Cx9zEyrgaQQFNSCawM8J2WecYYuwICIDkT9+sVmZw+t6PG6dLPWccrGl35\n40kxZuZHZi6hhbrP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaXzqvY9lReSlhJ0KfsZhIOgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGJjNGE2ZS04M2ZhLTQ1YTAtYmQ4Ny01NDk3ZDBkNzhkMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvbmCEAwg52hHJZEefjIxYOkNq+ds8XWyNSFg2uiy/Pehg\njIj1w4N5m4bVLzB09i4GyS0sPfL3XcV1qvnkYdzgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5cA+P9R27OcH1cN52+TcbQ0J\n4N8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNcqWzEn9Tay/gHZq6BIKmkoMfs6Rhb7cpS7D1x2haPwCIQCfssWaXCMq\narXTyh27rEI8HQGBGumcTUkVyJzPlkkUzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAWSg2IV5SILuev+H0GpDsZXbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmZkMWRkMmMtYjI2Ny00MjVkLWE2YzItMjgxMzQzZmJlNTJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzODNhMzE3\nMC02NmE5LTRkY2MtYTBkMi0xZTNjM2EwNzRkYjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR3seXjoUAl2OjapwghM8Rtv97fi4UHQj5HWLh/pMtgxivtV+dM6w+9\n2HKGj9fjCZnF0EX9UMJWBm06Cfv23AQ3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRXYzKW\nz4Un4qcSTxEc3IQnXntegjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIAU20z1uGL2erGtvgtnsQIqo6Lm+BOFOjle+4xO00goFAiBFwBXeBJ4D1Aqy\nmA95cHYEmBfSYi//PdwPBHxYoKF4mQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1658", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1658` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAUWP2Ucydl2d23oR3CMiLxhMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhMmNmNjJhLWJmMmItNDBlOC1iNGExLTNiZjI5ZTMwZDhkZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FiYTA4Y2MtYmE2\nYy00NGE4LThmMmQtNjlkNjkyZDg1MWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9pKNHRsL0guEAoUYGohRwmuQK0ZWh1OOQIUmYOCjiiIzT7b8VDI77WoLutqG\nWpRk6wcpWsfGaQeOs6nvejmBWaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbWTOrXmP0nS3NjVZCYtic12DGrswHwYDVR0j\nBBgwFoAUxH+LLTZ3G+yCNw3T39d5mE7aogYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAu/0FhxTZC+j3vl+Th6yGr6uN6PJJpdh+4+xpaPaNQ2UCIQCvMSHlm1U7\nkgcgBvSPexxb8pOkMNPjaeflyLXDlFObQw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXtR3hYM+rWUQhCsd0U0wYdSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTJjZjYyYS1iZjJiLTQwZTgtYjRhMS0zYmYyOWUzMGQ4ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZLKAt738kKPJcWyJUk26MyMxlrwBJZehGxQulPDzJ532F\nChlSCBId2FIzG8uEGT2SvXVXPOnr0Ot/kyFv3XKao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxH+LLTZ3G+yCNw3T39d5mE7a\nogYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKeV4Aaogak+i6ZLmGaGqhAWR50paNQt6R/leRUdm9mQCICfHvCDNDYpV\nCFmdbuM/DJ7HTXFSQQs6CvSZkjLzqseP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISATuybwsmy4QZSRKvWtpKTtHkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FiYTA4Y2MtYmE2Yy00NGE4LThmMmQtNjlkNjkyZDg1MWNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MTJjZWVj\nZi1mNWQyLTQ1OGEtYTRiMy0wZDk0N2ViOWFjMzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASTFo+/LlhDjAzlOmRUvF8A/xcBK2x7KZZODHalPefffvBtb6uYHfKY\n1QK4unzHDdRSeRglXCNDNM4zfwCwze2no2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRtZM6t\neY/SdLc2NVkJi2JzXYMauzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIFBCr8F8I1ATtsbno9lwEgVvKkliEJc0KjiNzMTynoh9AiAwqEUsqLSCWc5E\nqJgGuZ/j9bem8ceCF/vx9r+SN6ZJsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1659", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1659` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAciOdbblrRBabQ9Y4Zld+jbyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYmM5MTU3LTljZGItNDIxMC05YmViLWM2MzYwMmJiY2JjOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdlZGEwMzctZDky\nOS00NWI1LWE5YjQtMDI1ZmU0ZTU4YTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuEm+YAxRMgEVg/o0/MhTvupkUoCGREvlO+iRiu/y8HV2LwIwyq2haSLSu0Il\nE6tOQFvPpAMEvGLyq0UQ1CBwSaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoJQXaV4v2xKmOHmJIBnooeOe0pMwHwYDVR0j\nBBgwFoAU9GRnVz/zEW36A8/6PZbyzjpUXM0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAzMFRzDK4TBhwEcuKLkalSOX8zKNIW7UuYm3760SJ/k0CIQCfO7E1DwBT\npqOACXEz165GqHG9aE5ugzWFTmEU695AdQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbTfUaOgPo4A828SAC49e6mGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2JjOTE1Ny05Y2RiLTQyMTAtOWJlYi1jNjM2MDJiYmNiYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmHfw1g1JyG9O+JL9AM39mJAoMAKx4r+1lvasgQxltCA7l\n1KfhO5aoeohDxZbhaDJlfgpxcMVXbz2sxLmdLVZJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9GRnVz/zEW36A8/6PZbyzjpU\nXM0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOI1SUjoS9h7rqVUHL9S5mNXj8ZtqA05bfCgFOPJwp4fAiEAskqZTVHr\nlsTI9LrJ3IX3WlAeFTuR/+gkySg3Y879Z0I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAT+M6zF6gbjyz9hWuYT1/mPhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdlZGEwMzctZDkyOS00NWI1LWE5YjQtMDI1ZmU0ZTU4YTFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNGEyMDg0\nMC0wODUyLTRmMDgtODg4MC05YWI3Y2E0MjI5YzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQACJc9l3gaLFF9mj8LHRWoy4eg5p9r9q635cMa1AFSmOkKOd/oVhUK\nkCq6LrO+VcX5o5lkfF7kR5QOO+M7v6jyo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSglBdp\nXi/bEqY4eYkgGeih457SkzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDnO0c8S5z4AFPPCJ8sAIVaNsceBW+oFbqvYdVt1Ml82wIgLtw8XWWQ9J2H\nT1UPlqI7u4zoAXpEOq6WqkMKIIuUlaU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1660", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1660` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAUEaV2oos3JBof30IMuG1b6YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYzA5NmE4LTc3MWMtNDEyOC1iYWI4LTIwZDc4NTBjNDBlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM1Y2I4MWItOWQw\nYS00MDc0LWJhOTktNDYyMjQxMzNjODQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQOf3kjOmzfn/MMETWNq2hyw2UgUr2YqeME3HBS7cj3T3BRJtU9SmuxnUCxix\nWsmEz4XDp3UbK+CFrJPZxwsq0KOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKJFTdWR4ZD3KG+I9vKDRC+Y1mjEwHwYDVR0j\nBBgwFoAU+roM4sDT5W0O7Yrf7a+1bhBv++wwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiA8\nicrYs3RAHzYTbBLdJ452xuzxluR7PxNs21bH/Cg8gQIhAIeAOhZnYhKyF6qqR5AJ\nScoq3pmLqptr73ixNNGX9UzO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZgpbo3w9MRJbCWS9Gg7VatUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2MwOTZhOC03NzFjLTQxMjgtYmFiOC0yMGQ3ODUwYzQwZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQL3HwplEQicbAKLWWFQFIWHbG08WCx53PLK9vcjvpj+0h+\naws5y2awggVY6nV8pgUGoRcO9YkUDEzzrOE+IiyNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+roM4sDT5W0O7Yrf7a+1bhBv\n++wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcfmXV9Q5RpNt+0/fFq8VWWtQGzBFTdWJ1ozXbPkQ5LcCIQDiSCx8OZqP\n9aTsI+aRmx0JtFxA5w+vhyZY6FOufStTfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAdlr4X84iLPR3N9qrr7AytTsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM1Y2I4MWItOWQwYS00MDc0LWJhOTktNDYyMjQxMzNjODQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZjIxYjdh\nNC1lZDJiLTRhZmEtOTM3Yy03Yzk2Yjg3ODczZmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAROOZgZvbBi6fzDyG7GNHDgorfxI4sf7ofsD2Ni2taN548+jeIRXiM4\naP4trprkN9pOqLPr/53psyfMoz4gnG8Wo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQokVN1\nZHhkPcob4j28oNEL5jWaMTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIDC+bk7SaNN52x2/eKn+O0YShuQhGufhheHGNr/mjcE4AiEA6ItWUqmKpzVs\nEPcigjo2mWTaN5X/W7pcHI9Doe4j6L4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1661", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1661` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAdggbAuH+Fw5N8d1SMrmyD3cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NzkwZDU1LTBmODktNDA4NC04YmM4LWM0NDkxMmUyM2Y5YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBkMjk4MWYtNDMy\nNi00YzcwLTljZmYtM2I0ODVjMDNiOTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsnGqe5ulmKjf13KHntgjWO9DAps1nVWL1yxojuZQpFyGbz84+fzJw9LkbTwX\nuBMZ4xNvdxIH5Baq9sHEtANcsqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJaWHnh6ZyDHqvrixJ4qNnvi8qKYwHwYDVR0j\nBBgwFoAU7VYTlt5VF2YDRS7+QjbNuy00uWUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAWoFpJ+GQRe4bX1kjgDa8Hb5xv1l/qAbmsxeq2P3RqvQIgXtsp\n8QJzRYlumgKbM9cf56HLQNIDjBaDTWVMtVz2g/k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU1vlaQv/LY0lHapnsNxajDkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDc5MGQ1NS0wZjg5LTQwODQtOGJjOC1jNDQ5MTJlMjNmOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/pcLskdurhIg4i/7qKR74hDRbRLVo2knDuDBPQ9QFZM++\nuEl4DDy3lYYvbB+YUg96lGWoBs0GVHwVjvFymhfeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7VYTlt5VF2YDRS7+QjbNuy00\nuWUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOR/u4vAVBKcmgt6yzL9Lt/RI6O19AHW/rwufdleYWicAiEAgUlNy2ji\nd/+KfVq1pxFo2TDLtQgzdg5JIx9auBz3wTs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAbhp2qwUMyExdItmtfzxeZJsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBkMjk4MWYtNDMyNi00YzcwLTljZmYtM2I0ODVjMDNiOTZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMThiYzgx\nNi01ZjgyLTRmOWItODJlZC1hNWEyMTAzZGFmZGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASixdF0wpbRQPMYnQhS53kdRWiUopxjBwSf2qcay6EKwO++V5R59Uui\nAU1Y4VCKLDmVlbAQ8uy7yS7ajjrxw25Yo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQlpYee\nHpnIMeq+uLEnio2e+LyopjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCpmrmprzHm4L3ouZsSk6bRQC8P6aDg+PKY+q/S7DNqHwIgNVcjpeDPq5fo\nPUIgSqhVB89JQBtrJEWY4hn2Ypry/Sw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1662", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1662` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAas4OZcPJSxOo5dkNDGZpR1BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2ODJjZjI0LTkzZmItNDc2My05Njk5LWU2ODY0ZDRkN2UwNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEzN2JmZDEtMjhk\nMi00ZGQ3LThiMTQtYmJhMTQ1MGJkZTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEswJ7yF6S9GcLdiTmKGIC6ryHnF2GbilI6Xy7F7ob9B9cKtAFOqofUzTOgsV1\nt1oCuLwmBW6s+KutYkY5yTteaaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp3NNEUXL2atxapAMKD5fUPE8E9swHwYDVR0j\nBBgwFoAUKPlBm5qQiy+tGMtfROFMGQOIVQ0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAxtu8j4llooPx+vGhkooR3Ibeqzpy8QbyV13owz8Enk8CIC5q\nhQbW3vjgtEG6LYDRIoSAlbVFpamLYnTnO8+dZ2zv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARCO6xXKQEGvzNkVurylIuTcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjgyY2YyNC05M2ZiLTQ3NjMtOTY5OS1lNjg2NGQ0ZDdlMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATG5g3XybvyiwskOvv7E1ZvZ357EytnGj9KEQLvfhEFAnKV\nk98VhohNt9XqUWyPhpJSYCOTjJEfUIyPG+evGM7vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKPlBm5qQiy+tGMtfROFMGQOI\nVQ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANzRIcUwKk4qOYHKV2GTVQN6zjoaVmzqhagN48Ihp5kkAiBpmtqXymZO\neKBsoaiYjDMJ254tYpL7IIuxXTbCbPGrZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAf1SQa2mJWDxYXazRW/iF97QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEzN2JmZDEtMjhkMi00ZGQ3LThiMTQtYmJhMTQ1MGJkZTNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZDM5NmE5\nMS1iODZkLTRjOWUtOGM0OS0xNzE1MDBkMWFiODgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQhGlN3SSZWNqc3Qf4LIkOS1nV8KSwFYpo8tqpWPHCEv2CL4eyMfCAn\nYOPs/CbqgTCIyaUMoor85y2VoAWh5nl7o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnc00R\nRcvZq3FqkAwoPl9Q8TwT2zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCqCSkaPY9cSjZ/OxyhRQPCKORbeP6dn0YzNmdjjUN7MAIgcEuOS0C9gHUe\nyQZI9XUexmPjmGxo2wAg1w9/Mei8css=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1663", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1663` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAVtsO0MtEVWdpKHXJotZni8NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4YTBiODk5LTk4ZjEtNDFhOS1iYTEwLTRhYTY3YmRiOWViODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVmNzQ0NTEtZTJi\nNy00NTViLTg2MjQtMzM2ZThmYTFiMjY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcQj2Nf01T3/QTCNVTg9sH1XA5pNbI6lpz81qZdy3FY2/in8nhgckzfZVBLg+\nKuaRDXDWnmOcwONXBhf4k7+fAqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU09Zpc3Nf1DPGsyjOO3qU+S7ke1kwHwYDVR0j\nBBgwFoAU7dljJEtLLf5SaqfhYN+0uJlYgjMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAKfBTe00Z0c1Dr\navjb7NA+oi/Eoch5y10PdITg3vfTxgIhAOCWDgSWC/KhYqGGkFNbCZ+zr8a3VTXY\nhpv2ZvgL7IJc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV58Y+IOH9lQWILbsgjU6/JUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGEwYjg5OS05OGYxLTQxYTktYmExMC00YWE2N2JkYjllYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASb5B1bmL2geILl8y+WPrb93tsMx3xwWyRTSKnrTXSCFDi7\nqg1ISS9fN3R0TTl8AnceRUAF+pf3FCY/FLXlSXIxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7dljJEtLLf5SaqfhYN+0uJlY\ngjMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKdinIC8bEdzFXQNF6RzBbfe6NR0qLvbJF8yJ/2RuVswCIC+cObZdmvs0\ndNtauJUfWmQJadGVuM4e6BB7rTarxgVp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAVCYTo5fa2C2dgecFeUN+mUyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVmNzQ0NTEtZTJiNy00NTViLTg2MjQtMzM2ZThmYTFiMjY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2N2NkMWY2\nNy1iMzk1LTQxYWUtODUyZS0yMmIxNWE0ZWNmYmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR3MgXACp1Tw1eG/BUi3OaGYwJKIV7HMm5l0I4aPquckZRFM2yq2bVJ\n4JH+zmRC8lUugy9bu5JYD+tCyvhSHlzbo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTT1mlz\nc1/UM8azKM47epT5LuR7WTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQClEkSCQWoQrLc8TYQCsHwBLzsKaC0UqPr3oWhnCV89gAIhAKiTh09Egb+Z\n0RSNeixmDnAb9SSpnVNsiYu3S27ZySgo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1664", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1664` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVsAwlkFJLaBG1em4mKChzJzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzMTAxY2IwLWM1MzYtNGVkNi1hMWMyLTY0NTIyZjM1ODgyZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGViMmI3NWYtODBj\nYi00MWJlLTlmY2MtYjQyYjhiNWMzMGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqI/nQPt5L79yAxy5E2o42mNyqrkdwFBy04u8gb19VheBaQYgIg7ERYE1cOCn\narREiO2NhOQwhLwd1frfqCuVf6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd02R9okLtLtzPk2b3eqRqd2BN88wHwYDVR0j\nBBgwFoAUrp/Z1zjp/esrZ3h3JGoYR67ws4UwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIExxyNCGVs0j94hdvbfqGAguAJ8v6Q70irt8dt6PTs8AAiEA1CEBy31W8SyP\nfIiu+pNBJH1qDQK3IoJ7vFZ+7HfKc8s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU9x3V6wc4Etxs484RSYBq58MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzEwMWNiMC1jNTM2LTRlZDYtYTFjMi02NDUyMmYzNTg4MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIAmMoTp9LK4ILD0whaLqsPoy2KxP4GeOqDuEInJVPFZeM\niow+ZOXC6jsNcjHh2D3ATaCmMAp7BnfYSJPekcnYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrp/Z1zjp/esrZ3h3JGoYR67w\ns4UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMuXkCdlh8DcDfyuNfbQpRO+ErL1bd7wyusVPElLBdUTAiB42u/OHB8m\nyZoOfCOc+2NJTvvgxYTiNk8LXlIgnD/2FA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISARcghXF5uTU+IUwYcS6WdYjPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGViMmI3NWYtODBjYi00MWJlLTlmY2MtYjQyYjhiNWMzMGUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZDg5MTli\nNy00YWNiLTQ3NzMtYTlkMC1hYmNjZTg1MDhiOGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQmLO5rQAixOt1twr3gxZqp8ysrKMBe5C3dW5P09Vyi7xg+KkRaY7iM\niK43Ylb2gpXyuh911bGpX0hCEXP9q+6Po2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR3TZH2\niQu0u3M+TZvd6pGp3YE3zzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDTk5PF/KqyrvBSNfayLTf5h2baz54vPFTOg+Ehf/zIrQIga7Af+cYHnjJa\nD6tOdKJN3Jpc8Xsx42whiP35peY0Wno=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1665", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1665` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQhxL+QyHui5ZRJTmxbNB34oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiN2Y5ZGNlLTQzZTMtNGQyMS04MTU5LWM0YjIyZjlmNWVkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQyMDZmMDgtODM0\nMC00MWVjLTg2ZGItMDdjZDhhZDM4MjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvKwi+PEiEx3UYCqKECTnHhw2jHIW6Rv+ZCtdZttcfFN5+yVwMzq6dFP+Q8aA\nBdawQizQdOyT/QTVuqrulvQmT6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw1VnLfR/r083QI6STi/QidSNjDswHwYDVR0j\nBBgwFoAUnlY5Bec1Hu3LPvQ/5N/rL1u2izEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBa5GoVCtedyHzJ+smFjxLT3yZ4W4E50ZHxJg1FxqDJBAiEA1pMcHReG1xxh\nGBuGZWo9lz7yQ9Ek1oXaAyNXii6ZNuU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUAjVTxwhCk6S6L/HFOnZO0AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjdmOWRjZS00M2UzLTRkMjEtODE1OS1jNGIyMmY5ZjVlZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBffyqIwSA3kbhCKU+h2CRevPcXG2RpVQ84Z4Z0qSvrIl5\n4pFQu09CamwaelGCGKqoM79IOce/YDhKUEr2GHmjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnlY5Bec1Hu3LPvQ/5N/rL1u2\nizEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCNyBDg1RwOjh1L2zM9c9Ik/bUG2Ibhv0jkbIlARIQ1QCID7bIE6Sqynd\n3S8sT9AkQwunbFpUax5r83CRksbUvi+f\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAS9LgLlGjVkrtgySKdAGDjMJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQyMDZmMDgtODM0MC00MWVjLTg2ZGItMDdjZDhhZDM4MjY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMmQ1NTg0\nMS0zMTI0LTQ0ODgtOGZhNC0zOWI1YTQyODU0NDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQrTcjvVztEYllr8udu9NU8b+Xb77aihHkC+HGmG7oD8iDMuguw89iJ\nQyIwURRAIGjzIbzaOv8YS3rmYdWl/5VKo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDVWct\n9H+vTzdAjpJOL9CJ1I2MOzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDEq739EWi6ovOd/Sp2Us2TY7uLCAS1RSG9qSWt8MOqqQIgLW1NITn2N9gX\nbHt3AgictA8J0H1oVsemJrZeqHmtea4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1666", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1666` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAT6Uj9BaZpiFF8IvUSTqcSYrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3MDY2Y2E1LWE0NDktNGU3My04ZTdhLTIxODQ5ZDg0ZmQ3NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI1MzIxMGUtNmRh\nMi00OGIyLWEyMzAtODNlZDY4Y2FlZTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+Tf9sM273bGYzaU6d49RpOOtC1aKUhMcRdvQXvCcYnHEO0ehb92o2XAaMXNN\n21w1Td5E4lrOnZNosMPnojv/aqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU33geKfD0b1AxuQxxuz/6AT46Te0wHwYDVR0j\nBBgwFoAUE3sB3Euv0ZF6OXCpEYKvtOZ5AeAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiA0p7OvoGuknrOEBhoDc/25DcUq5nMYD9yGkO41OGEDSwIhANWKPAzTVT+x\nC1mbhkLL5u4tG+Amgr1PmOOAr9R9tZWS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARZ7P6zqQ6qsnGfO8fS0jo0KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzA2NmNhNS1hNDQ5LTRlNzMtOGU3YS0yMTg0OWQ4NGZkNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1NEM/wlxaT//YqLWp2koZMRVvCDSC0OB70h/CYHaNPBO6\nvsnXpifIV7cGDiyRxIpFhxWY+PsCJsR80r4ZcCPAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE3sB3Euv0ZF6OXCpEYKvtOZ5\nAeAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVg5gKhcoVy4f1V6Ef9zTmtsYddbbVQE8K8kRYlCWUUYCIQCPIDs0HgaN\nTRSkLGI5qUpIALP/tFbAmfLBhMHO4VCX9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAV8CK2SXJXNVemcrRZJRHbo7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI1MzIxMGUtNmRhMi00OGIyLWEyMzAtODNlZDY4Y2FlZTg0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2OGY2MjVl\nNS1iMzk1LTRjMWUtOTU5OC00YmM0OGE3NTU5ZjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASEM4A/XenHygq6xgeiO13++AK9K/Ne8Fbh5oyxvLSetFz/EpgMoaNk\nakEwPEKfirXHeqGauyRSaKYbnWu9URmgo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfeB4p\n8PRvUDG5DHG7P/oBPjpN7TAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCgGKiVk8ZVfxBolL2eVsDMkFaKQLi1Xv5SrvGnvouGPgIhAMw9W/W1Xval\neuxC9jzN6yN+UvezFhfAzYkv19qguoTr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1667", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1667` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISASYWRljR9NMlcHz9VIxSlTkZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2ODJjNTM5LTcwNTAtNGU0MC1hNjM4LTExNGU4OWQ2NmNlOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ4ZjU1YjEtZjU5\nNS00MzlkLTgwOTYtYzExMWZkMzEwOTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERhOpqRnzYxyA9vItYW4+xIVJKmkrMUqRURy8MzNiNeR5IbwP9yr4CF5LKQEo\nYbUutYJoR423I9TOVsVzrmwqjaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqq0IpQ35JqGg8ZU+UqXkpEUguxkwHwYDVR0j\nBBgwFoAUDtpYnilW3/knuwf7K4fRqASansYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA7pKrUASWs/tvRzGjLtLpqL4/sXqU1PBCpoWdQlv3\n45ICIQDpGgXTxvpXjkN4rDyq0f4k72lY2nT3xIFLcjctFZYOHg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaV9sPDRjj3UcKZFGFr0lmHDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjgyYzUzOS03MDUwLTRlNDAtYTYzOC0xMTRlODlkNjZjZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdrHIbQFrW6m+BPZHLICiHWLJJ7SpLjJAwEWHOeJGYoUZi\n9q6yGZPtKsCs6cvkOd5zQ2yHelvmQ07e6ksxzbTco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDtpYnilW3/knuwf7K4fRqASa\nnsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN2/TagY66WWQUim/wk4UsVGh0gW5TH3RNkYOOz+eQSiAiAR1k4l7hR4\nagvuzWp8NC+XO+JcFyxqNU1RPvUVq7imYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAT1jpdUBaPvmc8Jr84CvHdJFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ4ZjU1YjEtZjU5NS00MzlkLTgwOTYtYzExMWZkMzEwOTZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNWFmYjUw\nNy00NTEzLTQyNGItYTU4YS02ODIyNGRjNzZiMjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAShgxePxNRtuv9tm9i0wFbBqpfQ38BGXZifOz/Hghb3IsMXorEUziFk\nBXQ8EOz9KCbdHILF3aaGhiGT6hVCtTFho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSqrQil\nDfkmoaDxlT5SpeSkRSC7GTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCICqLBqMg2cqHOXuGQ6yKv9zOysbjMGaDnoCc0B0xNEcOAiEAscRfEuDuxdsT\nPrHeb6d5RTL+Pzhue8cQANet50iV47c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1668", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1668` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAR+vwf+ZkaeExYAWWiNekHrUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3N2FkMzY4LTRlY2MtNGExZi1hN2JkLTJiYWRkZWVmYWU2YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZlZjZjMGMtYmM0\nMy00ZTY3LWJhZDQtZjNlZmYzMjU3NjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJGYB1Sv9nt7L6JcvBwZkxuW7kLAxDNK77+l3q7uMgnd15I9rI7+fDhEWfJFJ\nazoau0KvyF2WCGxvaUuqd5C5qqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMJE5Ay2BFPycldapPLebYykEQpQwHwYDVR0j\nBBgwFoAUBBg3tV/qXgRwSyLgkcsBU4x949wwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAfSjZOvsimMNgPbJwdxgPngHIAVrayG5XZlvlfeNU8\nUQIgeW95sW5rJ4Y8D02sRZUXmZRxVA6bivz7j5imrDk/HCM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcA1hJJwV7ID5f4f9uTDaGylMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzdhZDM2OC00ZWNjLTRhMWYtYTdiZC0yYmFkZGVlZmFlNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+9Q56stJIJ5lZ/dYg2VNt1GkZ8noca8gGggfDz5AQLvl+\nlFIJcPD/xN3gcd43AZx1uFMEhl18hK/i+wa0zyago2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBBg3tV/qXgRwSyLgkcsBU4x9\n49wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPE0weALPgdc7KBvbmw7m44lAXFulS7NvET3p+a+/RIHAiEAp2oXN17R\nKp9k2cPHg9pwdJbPdhHaR2kHBNcRiwDHHzI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAQujXdqWIR42ys0jS9FDrdSiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZlZjZjMGMtYmM0My00ZTY3LWJhZDQtZjNlZmYzMjU3NjQyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YTc5MTM5\nOS1jMWM5LTQ2YjItYTZjYi04MjRkNjFhMTg1NGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR9LvVDrj5/mcUn/g1B4oEDSNfDiobnCqNNaC+LO9ADLe9Bk/rHQvGY\n7RFwkU6qZm0XugFC5rCoY8Jj205ij2tyo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQwkTkD\nLYEU/JyV1qk8t5tjKQRClDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIA8XOqZ/KC/A/n/NJAWlIbnTfvF8FiWcEeryzZsMfRhFAiEAn4mYuS2OzE+y\nywM+DGSV0abvV+eRZcdIp/KKuqRWQ1o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1669", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1669` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZH6gyWzb+4dnb+ceU7PV0/BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzODEyNTg0LTk5MTYtNDZlOS05MWE0LWFlMGNlZmFlODU5ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE4Y2Y0NmMtMzcx\nMC00OWM2LTg1YWItNzA1MWQzNDRhNGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaY386z4YgVD6Gn9ytlbBJv9RXXYc12e0jpUuaKYx4UfZzncMFKzvKoK4wi+t\nKSgKiOit1u82N/wWybZTx2qpkaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSpuaLfiutJSC+2rM43yBf0aj0BQwHwYDVR0j\nBBgwFoAUV+/dOHjY8OBuR2yljNLiX5Yc5G8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiACbuT9AdW4H/Nbb1V++/6BF7uIQIAcMp0akMYTsNXUpgIhAJP3\ne2ViAd+sG+0iBen+l/LU6jFkeaerJ86BRI0SlQqz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbLvWJZhXgt/bS+cEADjimDpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzgxMjU4NC05OTE2LTQ2ZTktOTFhNC1hZTBjZWZhZTg1OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9Kzx9HneQpa8P88ezmfjFLgSSkpQGOc/AekFz8H8fXIJ+\nG6KuCl2k2MJO6TtvfjATZWc96wu9QWquOteGMhido2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV+/dOHjY8OBuR2yljNLiX5Yc\n5G8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALvpxEKts8MZ3Sa282qNVYpk91CHhn/+hhGuFQVL2pq7AiEA9M/gmHho\nFDz+Uin67ZUj+kzoklYgEKMbOTTAv9Q/KbA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAZWXB0/xaPuOcUeMMWmX+2cRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE4Y2Y0NmMtMzcxMC00OWM2LTg1YWItNzA1MWQzNDRhNGIwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MmE1ZWMz\nNS0xZTBkLTRkYmYtYmZlMy1mMmMxOGFlNjYwMTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASKPxFcHAfrFr+XgtkuJ2CzbkF2mvUfldmrTJ6/X3b3aPbu8y/24A6i\ne8Wqnkh8Z+0o/eBVxqRQPVRw5YAHF7yno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKm5ot\n+K60lIL7aszjfIF/RqPQFDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIFJLGDX0140YoiZmgn1pKaOsP8JHtoxB/dArK+wqjZWiAiBoF8iSezRXlrgk\nCzV1FyuM1mX4udTUfI3qTSWOZGpMFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1670", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1670` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAbKJzeZNYhUvnbrs1DOrRen/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0OTExOTU5LTBjZTctNGVlMC1hMzk2LWZkN2EyYWViN2E4YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjY3MTA0MWYtZjEw\nNC00NjQwLWJiMDgtMDM5ZTkzOGY4Nzk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcOlVnuiM0lHqOTITURiYqcTunAwUnJ6i52b4qDH47AefabApzQ64zkuQaOD+\nOOm7553g6oLbLi8f3g6RRkE8rqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUykAU8aWMp3kdo7axTnTwKzDJxeswHwYDVR0j\nBBgwFoAUIzyMvvy624PeK77SFogfwOwsjCEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAkasq7gk4jZTlgqW6c2yEgE2WBMjzyRsH\n8W4u8luBiLUCIQDRYGey7FlFYrOeCrFfzPCAAPQUd+DhDyPEeBh3tTYA2A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb6QYNQ/Avr5xmZtW8LayNGqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDkxMTk1OS0wY2U3LTRlZTAtYTM5Ni1mZDdhMmFlYjdhOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkJ/ejjSfj3G+0w0H+qxBI1iRNFAaIzRpHNzxzWAr+P22k\n46FUjhHXiVheyGpdqelgWevpC9RSft7APuQvPGUdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIzyMvvy624PeK77SFogfwOws\njCEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAID+/+uefqg4Fyp672z0C+OvrORHT1dgQ3fdpWCKBtZrAiAzYQbOSF6M\n/RlzT3q/eP6eNK5vgiMcV2DNEFUIAgbwxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISATV4gYqYEZstCQYPELG28ctdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjY3MTA0MWYtZjEwNC00NjQwLWJiMDgtMDM5ZTkzOGY4Nzk2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZTgxODYw\nOS05MGI0LTRmNWItYWM1Yi0xNTk1YzNhZDlhZGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQFqGNiOLXmnsI9XVHb8kVpo6ei38VVy410GcDm5jsfja4XG45F7BzV\nytj0bviYEjKfIF2VSvY9gk9a1NLLWmEmo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKQBTx\npYyneR2jtrFOdPArMMnF6zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIB+XIz6zVwWYgjrHpelnJN7kpV+RGWRqlQbehCHN+93QAiB4v7/SjTS0qmJ4\nPoIBHxyQuVNwG8k6ZzITA7sruNVQUA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1671", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1671` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISASgmm37Ph+3cl8Wzho2L6I2AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmMjFjNjY1LTMzMDgtNDM4Mi1hNWY2LWI0MDg1NWJjZmJiOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgyMTA2M2QtMzBk\nZS00NjM5LTgxN2UtYTg2NjE1YzVhYzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeoSrvhgrknCzWbSJVNe05I4Qc6qMg1XSBhnZQo1IwdcJvviA9xa3GTtA05PL\nVYgJ5fOO+MWlSp6ix4x7aOKJlKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwxLdZR6vrFNr5QE7pp+DYy3Kdp0wHwYDVR0j\nBBgwFoAUrbLFqjW9PJmiuD8IPWUoSNbk8LowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAdpOITSYqIt0mi2WoS7X+GNlWbBxPBwzPV\njb5ehupGvQIgPsBORNYuS2LIX7FrBRxVpJGDqrGzB3t7aoIJtcz8iko=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfPds/p/UES+utd9EH4V6kDFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjIxYzY2NS0zMzA4LTQzODItYTVmNi1iNDA4NTViY2ZiYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASy5KCUK1/Sq+LyvNFDfmH3V1Ribhs2TfbCvySfJg+E+5OA\nyD+XqGoRNQu3rsc+RXHhTO50HkEln6cl0g1OfPBqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrbLFqjW9PJmiuD8IPWUoSNbk\n8LowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIga1Vf5bdFc6QtNnbFM0XbSemgdh9QvHzCXAvkSSdc6UsCIQCWQMLfmO+U\nDlcQVJXYrPM+yGT5yjz0Ko7lr7J0g/b+ig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAQfgdOkKr10u7Qp7s0sah2BzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgyMTA2M2QtMzBkZS00NjM5LTgxN2UtYTg2NjE1YzVhYzM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYWMwMGQy\nYy02MGY5LTQyMzgtYmRjOS1mMDRlNzdlZjMwMDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7fMB+NjW3UOy7HLe/Nw3PAw7kiw8O1DLNlcGlO8k2q+Mt0K6tKxr+\n7XpuXWQTHJKmCuhTOQqw0eqh1DIlIKQco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDEt1l\nHq+sU2vlATumn4NjLcp2nTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQC68UtoLo8rFNRYesi5VxFNKnXKbm5Dw8cTX/lUUxauBQIhAMtx5GlUQ4QI\npVuFHraUyxlucGiyzC0hTMu5EqIXfN3D\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1672", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1672` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAV7sxyRvtG9eIReramRafdx6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1NmRjZTcwLTM1MzctNDI5MS04MmYwLTIyNGNjYWFkYTA4OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRkNjg3ZTctODM3\nZi00ZDYwLTlhMmQtYTYzZWUwMmFjZGEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVxtydoNz5fmvE9k2VEYFnxmigpkycve37pb82N5hSs3/y9nBde9AVRxkz2Fe\nayViIbu8aJb6h1w+Qpl5oSyY2aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULZM7bqc9agl1VNqsYN9IDrZQWXIwHwYDVR0j\nBBgwFoAU/x31K7wZqdoE+Lb7srkFgeBBdlwwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAnFm8HJUFvGEj\n3mg2lr55lAi1/Id1JdAPg8ZUOoam8tgCIQCbDrFKf1yjTMLrg66XuHGa4K/rR83w\nYj14dei5BfJ3xA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb/tjOXZu54kEcbDH5DvE0vPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTZkY2U3MC0zNTM3LTQyOTEtODJmMC0yMjRjY2FhZGEwODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRedGQ3qrCF8NfRZVM0oRPShNEfD9BZwl5OkMUDeYIp5rl\nEZ/AY3m2ttSlClf3L3g1I16ti2kQ8xqiH9R/hZnZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/x31K7wZqdoE+Lb7srkFgeBB\ndlwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgemzv6gfEkaWpS4aulTfTGizUBa1SnAqUhNrH++13GdUCIAe6Xxx6JX/7\nbnU4GeWGWJ6BHaT5Z8stA+KiLFfCCsUv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAXxCx/woNi8YpWlBDEs6uha5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRkNjg3ZTctODM3Zi00ZDYwLTlhMmQtYTYzZWUwMmFjZGEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OWNkYmYw\nZi05YmE4LTQ4MTMtYTNiYi1lNjhmODNjYTBjMzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASFQmi2b8yZmrFnIkdjdUpe+KLlIcHWAekGrZk1eQv1oHN0u5Uz9skK\nn8h1TCY5U8FAKlkDHBMQHpqAKSD/tvFSo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQtkztu\npz1qCXVU2qxg30gOtlBZcjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIH1bbJrkOyYCxjXDvGiEoDMKrmh9JnOuUwdveYn2FcHwAiBCSKabvUG7vvNI\nBTZ99rGHH91/+2oXyb4sDHNF7j4uiw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1673", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1673` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASNHXRtHO3Ah4nZ7aN/VrStJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMWVlNTBlLTI0ODQtNDQ4ZS1iMWZmLTM3ZTJiNDNjY2ExYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJkM2YwNGUtNzQx\nMS00YjYzLWIxNDYtM2NlZjgyODc1M2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES9V81ubVEqS5P1cxhm1LDv7sC0kDPiDlk65vcJCQsdznlARE00lDtu1O3SpO\nJH4AdfqvbxSvf73knO2+MQv+c6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUToO4B17zSBG0mOsPOqMMCo60IjIwHwYDVR0j\nBBgwFoAUbRBUd1hZ6qMZ9TUmi+dg5PmxlvUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD8cOcjx+t2e0P5PAPD/H5lCfiJCwcscWKKtserIXZvCgIgW3LJWyt/7Rju\nzNS+gZYQWcUm7IbSCXWMurU3PqeFgKg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVT5j1PojGI6xZtDqLwnFNWcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDFlZTUwZS0yNDg0LTQ0OGUtYjFmZi0zN2UyYjQzY2NhMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBgiTS0keTpCeevNtKvqyKa4zhpnp7xbNxu4hww1gWpiJu\nSPBie7k92aDq4ggGw4zl96uw3XVvIY/EBn6wkDjno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbRBUd1hZ6qMZ9TUmi+dg5Pmx\nlvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE+jWsQ48VxCFqzKswrFowLHmGljwHSNtd5/euoCnEwECIQDlHF4Olt+f\ndfdlm79QZvPpmF4JYkBVY7NH6sdGnQxmxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAfIY4NFB99OD9aK4DyPTU2VpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJkM2YwNGUtNzQxMS00YjYzLWIxNDYtM2NlZjgyODc1M2EyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNGYwMzli\nZS03NGQyLTQ2MTEtOTM5OS1kNjE3MWNjZDAwMDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQYnx9UyuI0dOGULae0Eyh1pM9f598qwMfvgmQUmcs6DFpBEB5p56Uw\n2UJwtc+N6MfV6wfQIWXku7kFzGCh2M96o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBROg7gH\nXvNIEbSY6w86owwKjrQiMjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIA+rjqOtfPMt5sSs9zIVkJlwb2F6SMDygdd6RTtygiOqAiB3lAj9YiviFsCI\n0Km6fFE3Lxhx7nbiB0f7fhiKeA/e/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1674", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1674` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVpYOo34saZ9d5KHLaNblu30MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkMTI1YjYwLWFjYWUtNGY1Yy1hYzc1LWEzMGVlY2FhMWJhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE1MmUyNTEtODQ5\nMy00M2M3LTgwMzEtMjJhNmJiYjQxMmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmAZoHqSeoL+uSrVld8rq48IPd4buCfgThoP9/r3lSs6plY+Qhjt3G9SEZBzO\nRDF4n78M7Y2vtImcq3oWT0nuxaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ5Z28WN3vBgHIH6n19vBrF2tSAAwHwYDVR0j\nBBgwFoAU7yXtiPojH8WLujtwLqh3X3pdgXwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEXTpdLQyEBkCP76sVC8pqeKSC/G00fNneYQP5HZ1E0RAiEAphGimJPGZQtX\neKj57NcLPstnwC5CiqYA9N6+D1RqX/c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVsaMzgBZ4I4ppjI2pXMbZgiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDEyNWI2MC1hY2FlLTRmNWMtYWM3NS1hMzBlZWNhYTFiYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS24U48vWY0f58y2TcfvHB65BeM4EkrbS/fEZJ9az/sIS/p\nJ2jk50l92CfOxQrBAZEcNVRmtyul5Q+C9xmDeVuMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7yXtiPojH8WLujtwLqh3X3pd\ngXwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPxWS5nCM2V4ghaLmoCwdox4UmrxeaIjibmLc7ek4tZsAiB6xys5tyXD\nBT5ow0W8vZw4G+pMxTUj/QaemrliU/pWvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAZcrwSGti32nqw0nSBz65/PNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE1MmUyNTEtODQ5My00M2M3LTgwMzEtMjJhNmJiYjQxMmI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YTFkZTBj\nMS01NmViLTQ5ZmQtYmU3Yi0xNDU4Y2MxZTY3MmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQkzON6jly9L7wNDd5QbFAXjonXPGjYMC2Y9zxLRw7nCBzW7AiLFhlH\n/7PB5ncTELdp2PQ7uOfLoTjx/VPvUojvo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRnlnbx\nY3e8GAcgfqfX28GsXa1IADAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDgcclkrBKauQ3Iopb5bsrWGl/9b/D8O2tsi6uwG0aLxAIhALJZwznCrga5\nLPxc7usNDJ3MTbHk/NTYRo3zex98W5KI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1675", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1675` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVYToq5rLZ5sDUyvPzCyU02DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczYzViMjdkLWQyZjItNDk5Ni05MzlhLTllNjU2OTk4MDNhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJkZTg2ODctYmY0\nMC00YTYxLWE0MDgtMWM0NmQxNTYzZmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDnUHPmP8kZGk6Z9dKU6GAq8o6NiFCHhXxJ8BkGLpUOLF3L6BgiuOCRrnoU1L\ncC8MHeLPBxQk8+ukj3EaTpAA/KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnnJYGqql3VlehvsxhS2iFthloX4wHwYDVR0j\nBBgwFoAUwGamCS+S8I0jtruf1Ekzc1Y/FCUwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBXj+T/gbkcMRQCDq730qqWYtj66HzKOV053SPYLTgjswIhANw9tsUCnegX\nnUeo5oNtJB2SRIJjdsJNkf1pa8yywgB9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR//hhmWca3KmlvYAlJYvU+aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2M1YjI3ZC1kMmYyLTQ5OTYtOTM5YS05ZTY1Njk5ODAzYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmkJpdU94/VXFrGrkTcf0GfXreDyXHNdhMXEtZWk9wltW0\nAK4qfjxm+wF7AQpi69x4IzrwksOZrd6OkxS2L+b+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwGamCS+S8I0jtruf1Ekzc1Y/\nFCUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANHWNDyFzZXKAX0F3XyHdBAEG5yzrqFUR0On2VPsbq36AiAfHYTuf9Oe\nQds6Odl29wkJ5YSLytH5MmePYnMWtijunA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISATbJ9//ZpPvB/Ba4ZJUDdONNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJkZTg2ODctYmY0MC00YTYxLWE0MDgtMWM0NmQxNTYzZmZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYTUyNjk2\nOS03ZDE1LTRjN2QtOGQ0Ni02M2VjNDM3YTcyMDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS8uJTpRmJHjygOHRsgWJ941qFoerp8pXZDRJ8UyLsVkEQPCD3sZ/SR\nzHJJjQ64Suc1k+VN8B/fgIVbMgWutJUMo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSeclga\nqqXdWV6G+zGFLaIW2GWhfjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCICZ+a8AM2uODiCEwlMjoLZOdAJim1Rus+VBR8EIrpZA9AiEAuhCV0KhWUmWd\niSj+2eIKqgtI289KweIWFkaUaMy7YCI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1676", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1676` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYhqPOOqosbt1xhJg7YtkDl3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhM2JmYWYxLTNmZmQtNGRlMi1iYjZmLTgzN2Y5ODFjZmI5NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFkZTkyYzItZjJl\nNy00MDI3LTgwMTgtMTlhNDQ2NThmNzA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn73eBxkWalBv8+tA+b1t4oz7JktepHHUXuguCZbJz478G5RF/wxaHdUNklrf\n5iHrZy17PrO0CdO1QtySAgJ8vaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEe0EdE1XYeARIbpQL+hmqmqzj78wHwYDVR0j\nBBgwFoAU4bWJJwKDafoW9viFwuURBW8lMk8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAjabsCYhmcNlTgzJqbHSJ+CQVKW+Dn2qKLl6uOvlO\nth4CIAo8fRfUffbZjKTSRWDCZSTeMSfDJ6B2YHJTVyZEyN+N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYgdsRO3AjMIAK+ExhGS1lSZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTNiZmFmMS0zZmZkLTRkZTItYmI2Zi04MzdmOTgxY2ZiOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxgb6K9DqvmYr/Aoc58t0ZD3hARnvCspdAMNVFAfP+3vJJ\nZkoIpWvIhOeMcdoMWhXx30QRUFscaSv6qt3IW88yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4bWJJwKDafoW9viFwuURBW8l\nMk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVlyMymAm1+UUlfL1/Z4h2cohC1CNlYAd9FL2Kfo7cFgCIGvYTjAXP0MB\nWlkiwl1fBHWMTLROtpkvwZQu1s6DjHcj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAXbXrgTxoo78OdKj0TO444tJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFkZTkyYzItZjJlNy00MDI3LTgwMTgtMTlhNDQ2NThmNzA1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZWQzMzI2\nYi1kMGE1LTRjNjEtOTNjMi0zNmQ1NDNlYmJkMGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS5+TA+Ls/YQWf69fc5OLIQdsCUKy6J0ntpIuEW2+tZLobQJVyfuJyx\n9sMBb2P7HQmZOcc+S3AQ9Kw5wakV3Vlfo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQR7QR0\nTVdh4BEhulAv6GaqarOPvzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCodV/mBM/KMkxlXISmIOb9WsDcEF2tvKqSh19jzOzX7QIgZK2sRKczAldx\nkIgptmym8oXcinFq75lUNAEJpJbHUnc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1677", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1677` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAaFdN/vVq2iZ+Cg/a5dq/F0gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmMDAxNmE2LTdkODQtNGNmYy1iMDQwLTgwYmZlNjY1NjY2MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ3OTVmNTYtZjMw\nYi00YjkyLWFjNWYtYzRmZmQ2NzliNzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEELo+EcncnzY/qPyEkLUpmIGBVYx7gZTfKlVqT7r4ihxaZnqY7b6/SoBV6czz\nS01TWnds7LhzPUb8n4DluP3umaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyEHRPYTMJywVQ2WlYsd6WC+Mik0wHwYDVR0j\nBBgwFoAU6Gv3Hdb9O3XJnsrxHl+UbbwQtoAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAq90Sv3TKhqcjhejSngH0aDkO5WDzRq1FeRvAg8d/\nd/YCIQDqi06GQ492r3T4cEb7jSpH37pATqSeoZNOmAy+lGKiAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT+yOlH/CH2DrHFAj8Kk/V/7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjAwMTZhNi03ZDg0LTRjZmMtYjA0MC04MGJmZTY2NTY2NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2YTn11DljePAXe/5XFUBIw5ydAQKqNFyygJVSiIBZfxKr\nuwAT/fw5Xx+jqNdmwikssNiUozsZCD06uuP3NC/eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Gv3Hdb9O3XJnsrxHl+UbbwQ\ntoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP+wBhYujYXHntk+w2eGi76NjAc5zfyW4MWfQYqo2TzzAiEA2cYmEC3g\nf8oq65XUEL+hsFc3iWyDM7Jv49pjEmICZ8w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAfLQWlCF8vpMWNgXa/ZJVUAdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ3OTVmNTYtZjMwYi00YjkyLWFjNWYtYzRmZmQ2NzliNzVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NDhjNDli\nMC0wYjI0LTQyNmEtYTk5My05YTI5N2I3MDMyOTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQcMPhHjs1ZLzXgAv0q9tLoPiH5b+eH2dU7TTXT69LLW6Bo8DCZtEWV\n3DtdJifyZULCenJG1ck2gwcfaTnDOrQ5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIQdE9\nhMwnLBVDZaVix3pYL4yKTTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQD4oMkPmXsp2VbDZk5IFzFwIMq5j+KFO5Xg56AjjFihjAIhAIooV8VKES2F\nsNzu9STr7/EMzX5Zr56Bg6l4nWUSQpR4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1678", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1678` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAepQd8+IjiSwPw0ZmDZgcE7MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkYjY3OWI1LWU5N2QtNDlhZS1iOGUwLTc0ZDcwMDk0ZDU4YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlhZjAwZjktOWMx\nOS00OGI1LWI4NTktMTY4OTE0ZWFlOTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfc7Wo2L56atFCFSy7oF542UH2usTqNqKAS0ic9gSztM0d70BfEqVs33pu2Yx\nYbEwrdL2QJwE5iDAT8TEfVYIYaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/CIZ+YH74IiJrdh8AD+E0ieQiLswHwYDVR0j\nBBgwFoAUGtlhD5delKaJcpzfRf2FJW8iiL4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBz/HaNRPWpOnHcc346WmRZn0n1l0C41iz3FrwBOVTNggIhALHJ\nMPkkbv5poZovagyDNIzP+f4S2ZjZlyIYHXH4NL9u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATY4Du+3J6H7ozB6mlRg+3+qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGI2NzliNS1lOTdkLTQ5YWUtYjhlMC03NGQ3MDA5NGQ1OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmgdaVqgVkVSK5OJ+9gyGSq6GUQfg8b30NKNEYcjID0qKJ\n4k2dvYWiR6oEtSw2Sqd8YzETgkgNQ0v1nu1unUi1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGtlhD5delKaJcpzfRf2FJW8i\niL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ0QYrH3ztRajNHzOq+6uFfOP59auESVRFY/B/ptH+W6AiEAtRwil6S1\nfz14yxWiNH593FfRssRB7g+5hhRO87IDENI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAaAn4Rf2bCM93KnR7R2T9Xh4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlhZjAwZjktOWMxOS00OGI1LWI4NTktMTY4OTE0ZWFlOTRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMGEwN2M2\nMi1jZTE1LTRhMjAtYWM1Yi1iYzM2YjdiNWZlMTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARGi0wuu5E/TVKdOr/Jqy37Lk1VulIbwuQGqZKxXZIvFCn9waDIVpH9\n9NnLXtLcTgVSAXB5RYskC4ZOQT0yG5wFo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT8Ihn5\ngfvgiImt2HwAP4TSJ5CIuzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDrNzB7YcuMfGtq0xAPhf8QP5qU3tKR4wkpGKJmjilxKwIgLnuHdcLi+WWT\n7cfrZQu1UMM4A8sgeOY1qyq5vWRHcpQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1679", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1679` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISASjYy8giPG1CQyGdeao5IuqTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiNzA2ODQ4LTViYTUtNDE5NC1iMDA1LTU2NGUxY2UwYWIwNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhhZTRiZDQtYzMx\nMC00MDQxLTlhMTYtOGNkMDBmYzY1ZTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyd1D6j7E93Denv1wo3WmywIbK1kv1tPfWDPzMLVQO7ePwcnLE9NkGwNDnlfI\n7sB/z6rNJLRaq78ecjPPmMsbzqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUahIJX9tdRh4l0sl80W1hLv0nki0wHwYDVR0j\nBBgwFoAU8hq7QyDaZr5cZHM9+nFazIU41/kwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBqfq+zJwDs4+2AakXDsNwZidPYRLJyMAdb\n73brcBVa8wIgYJ7UtbRvyeSKMqOdGoYkNlZtPjFamM9MG/I9PDPMXBg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaAuAh3jLEdjOZM0ELn2VoL0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjcwNjg0OC01YmE1LTQxOTQtYjAwNS01NjRlMWNlMGFiMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKD0xyA6+mU1YMRQMihZd4uorkqtZ4FY+67j+CLU80Or65\nMj84eK0AWeg9fDK8r5S0Z+JpQu6FC9lYfAlFtku3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8hq7QyDaZr5cZHM9+nFazIU4\n1/kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMwmzxfEhaPq+GYdQ5Wu25CU+V3c7x7XWYWXOkq8EUcGAiB+eD3BwtlY\nFgQ+UvRgk6OV3jmv4tZz2mlJjGygjLfRcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAWWtJ4DHZdW5vLXBx6I09vRoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhhZTRiZDQtYzMxMC00MDQxLTlhMTYtOGNkMDBmYzY1ZTU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZDhiM2E5\nMi00MmI1LTQ3YzktYmNkNC1kZTE4Y2JhYWE1MzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQP8SRoHBnDwReQsKbGgCWQWMq/ZuRYUUX3C6jDT+Yi4pjNqTElgn1x\nKCioVRunKyUUPUm4haJmCvPjB8p6hMQRo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqEglf\n211GHiXSyXzRbWEu/SeSLTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCTGvl2AVeBvuh/QYJ4YoBjEzYE7JjqoTKPN6CAg211/QIgfbVcwZoSAzKt\nfAhnLTl6hPGuU39LqBjGBSU9zrmOFkg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1680", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1680` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZh1UvX3Ss3+gAWBHHenG9WmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxMmNjMzEzLTU3NzMtNDljYy1iYjEwLWYxNjQ4NmFjMGRkZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNjYzVlNTktNTA1\nNi00M2MxLWE2MjQtZjk1ODEzYThkYjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX4F3bigkYxXiRGOEfXVjG7VdgMPyw2FBoRJB0jLGyWCRVyVskkRGT8krt4of\nEhH64HXOKQ/PB8EdHeyY9ogLE6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrLo2fRzk1yjHgYchhAQXI2e1hC0wHwYDVR0j\nBBgwFoAUKQQ2qkyHh2F//Dtl2BLxk+/b+w0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiB3i6nsyGp75jtVDXncRnrO/x31pAuhNxNm\n5Rr7F7NdewIhANqRV/JB6Nmtir3ovOGQ0fy5Y7FjFh4JbI4nv5EAwy8u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQgMJuvOs2Pg/cXieYGdInZcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTJjYzMxMy01NzczLTQ5Y2MtYmIxMC1mMTY0ODZhYzBkZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvpGE9c40VOM0U5OwS6bvHtE0e+AedrQCbLSVhZ9N21p+B\n99bJXYUkYPLL0/UtKwldDZynciDwKGO6s+9A0usso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKQQ2qkyHh2F//Dtl2BLxk+/b\n+w0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUIaJzpTO3X6vAxO9V+n/VNeEbMlNqjeYooyy86/Ky1QCIQDMrmlhJF1s\nfm2F1BA6qfuoJaF55xt9/RHfMf7t0vmqOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAd9nVX8BLXleycB3+GjgnGVlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNjYzVlNTktNTA1Ni00M2MxLWE2MjQtZjk1ODEzYThkYjZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMDQ3NDA5\nNi0xNDU3LTQ1NzYtODhmMS1lNzNlZTkyY2QxN2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATVasBUrMoWyqPTmsqtiMN0vdv7Ix7GqCeZZ9uvyo3WnizBaBffulBr\nBrVe6gatC9wZWxmj8RuZPur6mxsww13ho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSsujZ9\nHOTXKMeBhyGEBBcjZ7WELTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDHYGrtHlHAZO1XiOdrDCgqmDyemwLqgbVhxAIjSo8ilgIge2DWcT7gdvTq\nWs7WaHuARM14BJ/vdBmzPT0YCtcI+A0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1681", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1681` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAbQaT6eaAx4HJvjgBxIAc/QkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZGFiZjI4LTY3ZTctNGZjNi04MjczLWMzNzEyMzhlOTgxYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZkZTJhOWYtOTI4\nZC00MGNhLTllM2YtMjkzZWRhZjk2ZGE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7ybH0LWDe61n7A9rsOhhMEXvDN3rVMlVxARutv6Gg1sixDlhmYu46WSqlezj\nnXkHORWAIu4hTWsMqtDS5P7cGaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUikQHwE5JuxnYOre31UzPU2X/RGEwHwYDVR0j\nBBgwFoAU9Ctrq3+O4fZ364zT63giNvXV8GIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHVWRn4uYv5o4ZCHzoGsOdotxYZw\n3viVU8SdwqNnErRkAiA+n+RJdRzof3u3YNXLlNggPRiKLaEw19SztNl2e0ShDw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW9Cz6NfBwSI+BTsqx+e1jUyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmRhYmYyOC02N2U3LTRmYzYtODI3My1jMzcxMjM4ZTk4MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiZz0Qq2iLriypwgtYs1zA9BXD+EN3eVIsXxhBkAcdciQQ\nDVikyV49VN9xWUEtqMFsCQbexG/iqBlrA59Ahwluo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Ctrq3+O4fZ364zT63giNvXV\n8GIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIge10TeP54SW7gAHysVGNJZ6XOozfrDWM1dbpfUCAHdGUCIQCZCvD8Tcr5\nM2HEMVDmpeGpcLcsJNaXO/Mz2KCOhg3wYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAdSN3rBaVW+o9VpdJky8++MiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZkZTJhOWYtOTI4ZC00MGNhLTllM2YtMjkzZWRhZjk2ZGE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NGQwNjQ5\nNi03MjRjLTQzNjktYTJlNC05NWMzZjlkYzI1M2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT3v2W83HalEWqKFHT7uGJ1Ni1VyqrCGQjHuDR4qhVgSSWTY3cQS8r9\n6soUw4urv6xiE/CLvsK0k+vCxmjoyDGbo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSKRAfA\nTkm7Gdg6t7fVTM9TZf9EYTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCxFz9ruL0sRddmVe/SiNO4Sna5H7qZ6U91wHAn6JDe4AIgDbEL8r9XCC82\nzIzxydVus+KyJT+oZr/JPD93DO4a3a8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1682", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1682` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAdeKh0yAcRog9ULkmERYNqWFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1OTBjNmIyLWQwMTAtNDQyZi04NTdmLWMwOTdjOTBjNzY0NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc4MjBjYTUtMGZh\nZS00MzI1LTgzZGItYTM3MDllODE1YWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEILZxzRvG5Px2pU12wKu2g+JmbKndO6yF3Dal1gPUKUfPBYd0xAHdWK7oXr/h\nIVcMIe/jDK8cY1YWU7Q/PFiw9KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0aMX6yfuOKs43USgOUYhcvywBm4wHwYDVR0j\nBBgwFoAUiILohNVilrszCXFQeL2bIHJEomgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgEQa7CWXq\n5uZObkRgurkpK7+D5bW9eOmM6k/liRwPYsECIQCiAoUibQcuMIEoEF+785FsRPCT\n9oVYwTPe081fZFtjcQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATSOPHKzFBpnl/5ffbwh+w+WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTkwYzZiMi1kMDEwLTQ0MmYtODU3Zi1jMDk3YzkwYzc2NDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2meDEhYluiN0Jrm44a6seh09EHJJQajCWVocGKwN+TZOc\nqzNeIwVqAbSeRR79aORBstlKe8JAhOwysU8ftjEGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiILohNVilrszCXFQeL2bIHJE\nomgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAParIlypd/LbPKgfa/cX/mAyiVQT6riwXP1MN3gCi0fOAiEAs+isrQL8\n/g+8Xu1yjFJs4xgGGo6dc+B+VV9D5FoDPEo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAaK8qg1RYuASqvO/Fka/3T62MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc4MjBjYTUtMGZhZS00MzI1LTgzZGItYTM3MDllODE1YWI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZjMyM2Q1\nZi02YjdhLTQ4MWQtOTdjMC00YWYyYmQwY2VhN2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATPdq8BWa3tEAWs1rxuzbaXlJ+0/MtgBo7FEjweDoDiFBHogsHVR+Kz\n3TerEUu6p1VAi0XvqZ14uSXk/OLNr6T8o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTRoxfr\nJ+44qzjdRKA5RiFy/LAGbjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIGBQ8x/SQRui0JTQd5ZmaLS7aY+++UxAi029F4Tzbmn7AiEAg0m/tNVbVy0p\nEd/JZxhjdFa3KdJGB1H9YolXEcLrAUY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1683", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1683` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAY/Nc74ias85YzQcJ71uNdyyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1NWRmYjQ0LWU5YmUtNDdhNi05YTNhLTMxNjdhMWZmMjNmMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTJlMzgwZjctYjhj\nMy00ZDdlLTk4MzAtNjY5NDkwYmUzZmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE++aDRmghrQe5TL4lHjq4UTkMtqYHrA9GBH0Q5MpKTgumEESaysuXajPCDfz/\n79yqwX3ejsJOPyO4NXrDxv8ucaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7x2WK3UcXbdJr5xng2tjYHmymJowHwYDVR0j\nBBgwFoAUU2z2yqLgbfyD9yTBp2TLaoVfUDcwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIO07zlf\nfOaTG3UQyi2B1pJ50EQrPnXpmG3hUtZgk0O/AiAwMFo5GbaSLfV1Er2EIS6CD0Q+\nH1KOGdRqHg5E7mZIMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaoPolsp8tO279Od9Cwj49H5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTVkZmI0NC1lOWJlLTQ3YTYtOWEzYS0zMTY3YTFmZjIzZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0eu9z2gc2sf01d1uDEpznMra0ilbu88qO0G7tE9hrsDEN\nE1osO9+mWUrpA+AasPcvFdec4ZeXwSD5iJ/RqiF+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU2z2yqLgbfyD9yTBp2TLaoVf\nUDcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDFwjiXh2L3x6Y4sQ8VcF/1o+cc7QMWLLZqsQSqq3x08CIQDtuMtLaJaG\n6zDR0/8eqZa7SmDvHiqJeHQZgeY4F40Y8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAQhDSOn5OA/4C+wytGB8+ILOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTJlMzgwZjctYjhjMy00ZDdlLTk4MzAtNjY5NDkwYmUzZmFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNzFhZGVm\nNy1hYmNlLTQ5NzUtYmZhOS1kZDJmNDNhZmIyNTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ05OKDS7T1ubyfguRqEA+phLNS4KG6zeMnyPNZKBicZWPSHQce+6QQ\nvCXQIdIBDw764JwBx84NkWcXv9Lwwmzdo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvHZYr\ndRxdt0mvnGeDa2NgebKYmjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDLy6biHDqnxJt0YAG0L4zfqo6VCakcljVr+RRDLAfJ5gIhAKcEJCIJgW+6\nr03E5CqFxNZx29VhEaDHrWx+uuHxammq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1684", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1684` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAX7NFrvV4cfQ9m0xRfAp7tZAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5YzA3MzBkLWRmODgtNDYyNC1iNjkyLWQwZWMwMGU1MTM4MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTczZjRjMTEtNDBk\nZi00ZDViLTlmODgtNjJjZjQ0ZjNiNDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUMzGWPfVJ4tVF3aOfvbzddym4AyAa1hVGYD8F1MDYiA9MeQyWw7bqkhZmVld\nu245jzyDb7jnTv1jBBwavPeU8aOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWC2XsuZycf7GY3dRd1RhYuV8SY0wHwYDVR0j\nBBgwFoAUBSlsoFm2HFZ16BPt/vvYi1uYUhUwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIH50v8UP\n8uipC7KBEflsPMiYxOTqWLQztchio5W0v3aWAiEAj1Zu7HiHIKBYMdnF6JS++jqC\no8hjNDYPh1SQr0kSl9s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAftNagEjtVQKDxtsv3cto8eTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWMwNzMwZC1kZjg4LTQ2MjQtYjY5Mi1kMGVjMDBlNTEzODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARl8MgFoKfTxrBD4PaHMfakxcj8Vx5xqS6et8C0cxTGzMxt\ndoUqwCMhHxZhl+fsAquWlURIJ+zLe8aZIPqBv+qoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBSlsoFm2HFZ16BPt/vvYi1uY\nUhUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgd3u0owfT5antLIiH5LndtI1fXbPsbm+0i6BZ19KadFACIQDBvkqLRIHr\nacLhaLiZCnEcR5rq4oyjTOhxxYBDM0F5Lg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAUPi1VQO1DpVrezyPNB/wNNIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTczZjRjMTEtNDBkZi00ZDViLTlmODgtNjJjZjQ0ZjNiNDYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzOGZkZTRi\nMi1iNzk1LTQwMjYtODZmZS01NWExN2I0M2QxMDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQLZTGuKOH9FbAgDov7OlBg0igFNcLP1O2NdWehV36b6lp0xUy/jUZM\n6m3SEEjRwPO0aFkLJ5DQh9IJ6atDL5TBo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRYLZey\n5nJx/sZjd1F3VGFi5XxJjTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIDfvE+MWjHzOIoobiBRConZdLbIpurQK9NT8kDOgbRSoAiEA0aSXI8QwSTsN\n9geRoOfBYJRjv6PPb9/AiPiaY/LR+DI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1685", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1685` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeIEg3qdE2QRfOUKSbDsX+FEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMTEwMDU3LTc2Y2UtNDllMi04MTVhLThhYjIyYjEzODk4OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBhNjFlZjgtYmVm\nNy00ZDRjLTg5OGItMWYwNDU2YTQzMjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtnu0EMpPr/R202sZGGtmlLki/pysQ7vqa/uhOlsbaIHS5yqaTPYqmGbM6Jnx\nrIIXgI1uK3T5KqrtktgR5sGlVKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNhg1XZWFCRnNkhnye0Oj1CGOp/wwHwYDVR0j\nBBgwFoAUIf3uO3NrG1576v9zmRfBRfO0IZgwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDNKeSlVgAA/xf+HYSEobXiUmU/NHmuUtFHVQuTM8FYlAIgOWZgtiD1\nDTGbbVs1LIKP4NYzweD6yCn4tZyZHhuHsk0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcJaoY40XUYr4dZD5b81TfipMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzExMDA1Ny03NmNlLTQ5ZTItODE1YS04YWIyMmIxMzg5ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeG0A/WC5T6wc75KlTmVZLqvpZgAPowjL+wQipzEn/GS2j\nOLWttaVz3Z21cbAUBlBtaQhPTvZFLwN84Gyo31klo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIf3uO3NrG1576v9zmRfBRfO0\nIZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIbNFyJdmgYErc1qIkVbgawj+toKTTziFg/M8X5QCFngAiEAsuaCteaF\nPnvGT2Dzy0vOG2rnqB5ofGQCgHerrWM16mA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAUzc+o6ivxZ9BTot81zQt9M5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBhNjFlZjgtYmVmNy00ZDRjLTg5OGItMWYwNDU2YTQzMjYyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMTdjMDA5\nMS01Nzc0LTQwNzUtOTk5Yy0xNmExY2FiNDMxOTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS3C1uh3PtOTObYWUa6+IOoAajM5DJ3f02jyYCDPJAYZFG+p7Nf2z5s\nHNC1LDmzZHV1RUMaGu1DGfW69K3SeGNko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ2GDVd\nlYUJGc2SGfJ7Q6PUIY6n/DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIEv8K0/yzoJ2L23SyydT8UqCjQp7sV2sYdODjMDHiZXXAiEAgbFTfpZgIxTq\nHlySSLkIcd/SurJ68mlNn10I1hPT078=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1686", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1686` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdjlZDvyKRf0JGHhxb0TTFr/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmMWM3NzZhLTBiZTYtNDk1Yy1iMjUwLTI3YmNlOTM5MDhhNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY4NGM1NzItZDFh\nMC00YWE4LTkyMGYtMzI1YTk5M2YzODc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd1O5Zx1Wn4oLwFwfJHfUagk5mxV/m9C8oLDMLzauDJEHKR6PyqquD6iqF0oz\n39t11on+c55z7xop3CfRLvd/qqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyV/2+Pm32nfey0QpFjd2+i6hsLkwHwYDVR0j\nBBgwFoAUTNs4V102OVVXz+WMGgA+dmg5ix8wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIHQw5+jOOGYoPzlx63/UKSSqCfWk1X5kkeu3Y00b5OQNAiEAiiJ3jRxi\n0V0HvrBFoESgfussBV065fIi1V3wdnJbg+0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbsVixrm+718ukhj2CevRvE+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjFjNzc2YS0wYmU2LTQ5NWMtYjI1MC0yN2JjZTkzOTA4YTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWhrHPESPjMwO3yy4iuZdS6/UzNGyhsUCrLsjS7yJZ5+vI\nJVdHpFjjX/iUVALUbe46w4vhZgN/lEM54RRVwccYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTNs4V102OVVXz+WMGgA+dmg5\nix8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgct8+q+18/21QEuk64k6IfgiyQNsO3AeV1Rcpcv4GsuoCIGqdPZlYNFJE\nHIP0CfsoLig+LsiAByhyzDj0TGN1i3Cb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAbgnhm2mSwrU7VJXl89DkDaJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY4NGM1NzItZDFhMC00YWE4LTkyMGYtMzI1YTk5M2YzODc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYzNkMDYx\nMC04NDNlLTQ3MjktOGM2OS05MTVmNGJlYjFlY2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASE0F+BUzxKYbfTqFxVQYD42/fSfzC5XfpC3AMttg2xA0HQKggbvS4N\nk4d0qpGIugh7ymX+8Pcyave2D8iR0dh8o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTJX/b4\n+bfad97LRCkWN3b6LqGwuTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIFLwoOc5WNEfIwXr66IN9+UbBcxIVD2kyCp+cyj5U+TVAiA0/25zKnZUAIBH\nVrLKm3nvYag5X4zJ/Iqt4iOL40VWTw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1687", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1687` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAWbVlKkohhtExkwepDC3Lae7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjMTYyNTUyLWRlMGItNDZlNC04M2MyLWU4NjRhNDRlNzk2YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhjNjc4YjgtODJm\nMi00NzJiLWFlNTYtYzVkZDBiZDZjNzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4Q+unvkPvIL0C2zXl8xVYAY4V1OkyxjO2AUNI1K0hjVSW5Wiv7EnU+YNHZ8E\nKuGRbCoCw++jGxK50zCasdZQl6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl7n8cDUSPN0q1fN2S/z8AFYta3UwHwYDVR0j\nBBgwFoAU4Ohxe4NhteMRzFRgdQR5G0ZJU1cwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIBdByYZnfh6iR2EDYB/kGRLN/PTtMEaDkfiIY4SnRAt/AiBiX/nOwXQttJtBRZj3\nj9X7AKNN3UC/9asKfKpAgLWvlw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATeTHaefKBL/UpP0D7j1NPKHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzE2MjU1Mi1kZTBiLTQ2ZTQtODNjMi1lODY0YTQ0ZTc5NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARW8JycYr0WmIAIXa2l6bAmcNGRtJOyQBDnSAhpmfbD3Syz\nKDkKT4WUitvESIXwGFZnfMUScfbZyuvyvOyO6TM7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Ohxe4NhteMRzFRgdQR5G0ZJ\nU1cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRXHwkl727Nwr8nlkTPdkvDSsZUEs30scjcZmcpsHdv8CIQCh9/O6LGw0\nbvv9/7Oyh/6NY2HVtyrmTVJBwV1UNReGPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAdWKAaBTEeLuBpv9XVL6g9uJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhjNjc4YjgtODJmMi00NzJiLWFlNTYtYzVkZDBiZDZjNzFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZjdjMmQ4\nYi0yMTVmLTRiN2MtOGQwZC1lMjc5N2VjYTNiZTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASSnGw9WYVVLHb+3BNq4dRIXxE0l+SPqKE2sYV7wMC3eAw2HmZf9WkG\n2otY3lurl8yP5qEr8GUoeErKFXUBCuY0o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSXufxw\nNRI83SrV83ZL/PwAVi1rdTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDGus1FUjtrc1W+XgLGF1kQ4acgc7s0bXhtPadTczI4RgIhAJJnfqWifB3U\nb93eZ5dR5BOmk4XR9zgbW4noMYDt/Syd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1688", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1688` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYjRmtMRgGQM+bhkBEngwWcTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzZjJlNDRmLWI0N2UtNGUyOS1iNDBmLTMyNmM5NjRiN2QxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhhMTcwYjUtZmVi\nOC00MTMyLTg4NzItOTcwODQ4OTZjZjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE25mQ6ll30knJWeUf3LRJnhxQmhEb0bLYx1wZA5XemQS/h65poBaN/R14uEwD\nnXMi/3giAeEthwXUsvjMvxhzOqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjM9CyvKsfWrevjiCL+yexG5o14gwHwYDVR0j\nBBgwFoAUdEfqSSe8+pwnSbLKc1INTOQkFdswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIGAF4HWy+tSN+rnRuOkWA8LLHDsK3H4dK8wLovSnKyACAiEA\nxnoi61eDPymG6JYK1cgCf5/HMoXAPvW3CXwIYuL7Msw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb79S9jH3k196B73VeaZ0T9gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nM2YyZTQ0Zi1iNDdlLTRlMjktYjQwZi0zMjZjOTY0YjdkMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTcEXS/CnoD2bmOHd0g22i98Q1EiGpliVBej589jAeJXFn\nZ9ERC0sLdGfku+oaKhK91MxLjbpPbFRc3HjUK9Ddo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdEfqSSe8+pwnSbLKc1INTOQk\nFdswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIxcjcEhAeNQIBNCQaocOlnTH6MWny2jQpt56fB/idukCIQDwJBgLiZLv\neiLaJOWI0cm1wtifv56d36hDKchLlyRl2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAXedNHYVz3HNCHTaAVdLMfQ5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhhMTcwYjUtZmViOC00MTMyLTg4NzItOTcwODQ4OTZjZjgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZGE5MGJj\nNi0xNDc4LTRmODMtYWQ2NS1iZTkwM2E3N2EzYWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQhlFhesO9iLcMUDje/s/oCUrxEWYwlvwnTY2MZKLMs5QQo+Jnl9epX\nOC229V+XR5qh1122mf7Ztl3/J3k+J1q9o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMz0LK\n8qx9at6+OIIv7J7EbmjXiDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCK1GOpC+SidmQYbBtSUMepYFjHeZ5n6TgfjCFYIE3+5AIhAPj43sgGheNf\n6NbBc73DgnEX8KTBXZnAwXGBnLagpFbN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1689", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1689` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAd7dZzYch7xWmscyIvPNgBs4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNjExNzM4LTFmMDUtNDBkZC1iY2Y0LWJkYWNkOWEyMTc5NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjliZWRmZjctMzM0\nNS00OGE3LWFiZmEtZTMzMGViMGVkYTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjE32rWRHemHpwZD+AtL+j4CAs+/JiAiOsQ4s1dox2Mb3pNyPv96ZF0vwxc3f\n0Ue89gUR6Y+WI4KM7o9KZwPzuKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpxLR4EVWoGUzb4uaNWYHQ37TX88wHwYDVR0j\nBBgwFoAU3sH534v37x0883ZI029YfVl5IuEwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIC9ABDnPt3SW8FGrCQIlQ+6XyjZwYx5FXmrpheuH+tqbAiEA\nyiYESYHJv5meOEkKo3OQD7xOH5ls8k7VK70twqu99Ao=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASDVnDx/NcRMoxgTy7RxB6//MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDYxMTczOC0xZjA1LTQwZGQtYmNmNC1iZGFjZDlhMjE3OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRguFIJvA4I8NhC62OInJx4WP+y2FOPWsN1KIAU0wiKJNm\ny/L54ru3L+srwPsQgzL4c5dRWLlUWPupsvLXzs9Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3sH534v37x0883ZI029YfVl5\nIuEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOQznUjWaq/y5qATGt9hwAGgkY8limcS6ILxJIgRj4KWAiBZrl1/5rs3\nL0a/BYv5jTMAmLBF42TgqcS1PQYdITqgNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAQU8z+b9U4KiVqTLz33dT44/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjliZWRmZjctMzM0NS00OGE3LWFiZmEtZTMzMGViMGVkYTkwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMDE3N2Fh\nNi03Y2IzLTQyNDEtYTRjYy0yZDEyMDM1MmMzZDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ+6OZ7DsFBdty65VD85YXsmla8/PnWGJy+4fiu4xguoFGzfL3B9HCv\nAQ3I7A5SFtjeLkJt/vgUB2gIhORX2Jb2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnEtHg\nRVagZTNvi5o1ZgdDftNfzzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIGcHl+J1IgyF1BzBm6naNHiy0V2JkeWnBCc+D1hwEoSgAiAgS26g2GBkezxe\niNhHcjTF/SXwR9X8iOIijgJek1Ux9A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1690", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1690` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAX2bvjcMrXxjM9nlyJ4npTCuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwYjA5ZGJmLWIxNzYtNDg0OC05YTg2LWY3OGUyM2QwMDliYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGY1ZTEzMjEtYTA3\nZC00NTZjLTk0NjAtMzQyOWIyYWE1NDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg0gC9gtujDt4Eduip8cMeAgAoPizBNNtxcYEyEdhiZ31h+rzTrC5Zbr+2646\n1uREn3bRi/8k9RlHFdLcuXL+baOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyB0g1Dim1VJCoeKcpgfPQK9ADnYwHwYDVR0j\nBBgwFoAU/4YFCg+5sv23u88rTWc+/nqp5IMwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDnCYtxYbzl\nEJmNQFV2+mwywj/Evjpc9ya3hZE8vTrmlgIgR5MEt4rerOCC12jvjmiZxuajHUbe\nX3Cgfe0jXmzxzao=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcS4e3hrLbmewXTjnYP0Cv+CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGIwOWRiZi1iMTc2LTQ4NDgtOWE4Ni1mNzhlMjNkMDA5YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBZYBZwujfF2aLrgzxywYhWw9Jwz3EAhmncRHsTw2GzeCR\n3w6ZtKM5srv/4yp5BQX/z0HK6vAeh/f14OFK/LDNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/4YFCg+5sv23u88rTWc+/nqp\n5IMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJNsTHrWxEVEGyqyLYhblUcK6+abjyXKo6i63eVJiUygCIQCQT+FkqFWX\nr3q01hIDgHF019wGISxF3AmsbCkX2Y7iXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAVoTtcoemBuwZvTuw0y4v/EXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGY1ZTEzMjEtYTA3ZC00NTZjLTk0NjAtMzQyOWIyYWE1NDUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYTdmYTc0\nMS05NmJmLTRjM2ItYTk0Ni0zMmIxMzhlOTJmNDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARq8Ps72xHXuIWpKxDn8ti/FmZX4pj0QtU7H1zy1nzLF+AXPZz0PzqC\nZoF+c5L+s1Rhe6xHT3OndQO9ZHRlGvn7o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIHSDU\nOKbVUkKh4pymB89Ar0AOdjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIEFtU1t8S7Yi10DFMpeGEQeucK4o/sfefwPpPeGQfcdhAiB5xZcKXDMMskgZ\n4Qy1Q0ZBw6QewsviWKNqe6mBEBH0gA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1691", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1691` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAaK+WKP4liAD0g2N3Ef4VPbpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNTIxZDFhLTFiMGQtNDk0My1iZjA4LTM4Y2IwYjBiMTcyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY0ZmM5ODQtZTMz\nYy00M2ZhLThiZTgtY2NmYWZhM2QzZmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2OHnRjHoG0iUhPjKectwiSWAF82vrMp0Wh5aZYfbSZ4EiY58Y5ojZ0D/wR5h\nCuEUSRduj3UJaSBIGnT68OVtaKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU35ZBFUlfJ7gONnzUCa7lwaK7b+0wHwYDVR0j\nBBgwFoAUt4Nlpg+ekKUPndgzZwBYXPb+5vwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANOEY5CyCyeCdfV+bq6Xw7RxpdkyLfo+Z1jEGjxts8bAAiEAguho4yBE\n/OKyJRDQB6oNsj0Dkp1HadmvWi31HnrQz4I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATtjIx5v92gOYwA+pqxcNb2+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjUyMWQxYS0xYjBkLTQ5NDMtYmYwOC0zOGNiMGIwYjE3MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5hcBtlHVKHEPIUWCRkcMxVX+t/xC1mBVDPJBROT3N3GUF\n1E6Dhp/J+BKgFrPEe14TWV4dhkQRzjcgFcxcC+2/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt4Nlpg+ekKUPndgzZwBYXPb+\n5vwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ6YS7lCqfpCZZAE2SaHFBGs0LGqlwTORMlGPsahEm8wCIQCqDMKCJ9IC\nQ6j5UZ7/5CIMq1fkZ4ntNj5tUlM91YsOeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAYWMvcywa0VqGYfe24IIAztZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY0ZmM5ODQtZTMzYy00M2ZhLThiZTgtY2NmYWZhM2QzZmZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNDk5ODZj\nOS1jMmU1LTQzNzctYjdjZS00YTE5ZWMyMzcxNzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASbfY+yPyQtNC4WS9dBTcf9rSBeqCz5945AFFeKDOV2MR9JEybKhAKt\nKfjhcgUwWVJLIBjJJFG3vND9rQBaOFiro2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTflkEV\nSV8nuA42fNQJruXBortv7TAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQC9WPyc5AfiZ3wQsT/1WURY4/obgDTz/tprfceaq1HN8gIhAOzxcXj1+H9j\nDCFq5goXJ3AZtP8frOQ9WykKBioWvprp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1692", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1692` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAWBiEBwEMRDbl1E9Xn5Y6TIbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkYmJkZGUyLTIyZWMtNGE2MS05MjVkLTExYjA0Yjc1OTIxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNmZThlMjItYjdl\nYS00NzQ3LWE5YjYtNzhlODBlNmNjY2U0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUd8zM3baOBnZ3SpQFYZ+9K0mXEwCA/TSOGkvs32vHivZQ0gKEJpxVXpMaK6J\nzp4FIk+VvLSwKgLapVePkr5I36OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5HHs9Itfl+0VQ5d7WI4xZADdaVcwHwYDVR0j\nBBgwFoAUZx1K7h4kPL7kUK90FVURXUlkFAkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAM4t8wJNdnqMiKC1F66jcOnAMC5uK0ErBKFhtVrCIlFMAiAjk3RKrrL+\nk/L4bNpVpQWM93XSpRVd6FFeAv2z54gDvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXd4Sob4lWiwCy6F7EmwcYfzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGJiZGRlMi0yMmVjLTRhNjEtOTI1ZC0xMWIwNGI3NTkyMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+bZcdtjInEB3oAtJiHS/rYVQtLO/e+hlBmgvj+tj0KGuM\nnn8oJRN4AHJt4jt0Avm+1xgnpLfsVeVbNZilNJ7yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZx1K7h4kPL7kUK90FVURXUlk\nFAkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJN0bqDWpvD8L0v9K8ORk+dc+vx65ZLu7XHVQh1k8E4HAiBZiGXLOjRh\n4Zo3IHIGX1OpdYSSK7mqmfa72qEYoW6+bQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAcCAjS8Kww06/i/A+A8FSphRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNmZThlMjItYjdlYS00NzQ3LWE5YjYtNzhlODBlNmNjY2U0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMTU1N2Ex\nMC1jNDljLTQ4NzUtODk0Yy03NTQyOTU1OWZhZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR1LGOvOImTF+w0+yjkxVjM18/oKFJxQoPBKo3F9ZZuB7zxgic70wwX\nMJ35irTHbzQGZvwNFDX8EK+jZaUA/D1Do2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTkcez0\ni1+X7RVDl3tYjjFkAN1pVzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIClBphIJXYHi6+JPLfPrXuYblG1P+lDhr7wXhnx4Xzp+AiEAvHzui9u/c4qv\ncgSa2TdIJMpsL2PikLACJ05kw0+hmO0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1693", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1693` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAbTV6fOVx6TWULOb600iwqCyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyMTMzNjZlLTYwNjMtNDAyZi04Njc4LWE5YWVlZWE5ZjFhNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFkM2U4MjItMzhk\nNS00ZDAzLWJhZjItNzU5YWVhNDI3ZTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+Lq2NkLHtq5wgdSFRou14hvIlRUdrbmcuwAjUBYxpkj1Ry5gXDFBcPSRc85t\nDlEk7C3bcvqUUzLFO6IlBb7z4qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ3oJa51edC7y5x/sejWccpmpuxkwHwYDVR0j\nBBgwFoAUG+kOqbwUFXENTet1jWjtISkprJ8wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIDQruc0X/tmnK0cUnSih53QTSK+8PUvhWROn1yDYuFouAiA9KMo06kq4\nia7ShHztJaeh/llL8bmIlU5JqiU2CBpDVw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAero+Ltws50O9/WZq0fmU/7qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjEzMzY2ZS02MDYzLTQwMmYtODY3OC1hOWFlZWVhOWYxYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0Fs5Ts5xXzlKH8AJ2x2E6YC5+NTorQ6yNmQMdU9Gignr5\nQMN24EwV/vwSs3G5e3tuhoXv/Blh0lgjmllWQqg8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG+kOqbwUFXENTet1jWjtISkp\nrJ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPh42C/OzXFU1IOHqJlnwoWiy3sQhWQpC59gS/4GGeFIAiEAxyoppSAT\nWGC+C13wpsc6W/ZzWwCTEL05K1ZAlgib6Eg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAeLwEz0lvLNlKmzPcAxNgSVjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFkM2U4MjItMzhkNS00ZDAzLWJhZjItNzU5YWVhNDI3ZTAzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNmY2MzU3\nNi1jY2JkLTRiZGYtOTFmNS0wYWQyM2U2ODkxOTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ1NESm0IwkZtE14vKLkeVHkAFzmMlRa36gEXCkN8bkKhxbBveqGZNG\nsRjSbaLBqfHZBGQiAEcoqebC6T6yd2/8o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQneglr\nnV50LvLnH+x6NZxymam7GTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIAk7qrIZT5EEFfV1ACdBrXf9874S9itmtqoFm9u34BPRAiB7Vkik34D5Pc7I\n9iQm9/gbRnxFJzIeo5fO4rtc9N940g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1694", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1694` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAWXziZBKQS0sAHRm5bmCXvyRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzYTJhMDdlLTQ1Y2MtNDAwYy05MjRjLWYxYWQ1OTZjYTAyMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgxMjBjODQtZjhi\nZC00NmY4LTgxMDAtOTA2ODRmYmUzYzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVWrlpTdRFb2uDbZ5ljkkuPexPPtF0jxmizxYgt0WPF9S5e+I/c2n/iAALzv3\nOmBzuJMBAexsxZHCtTTLnjuzI6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfdOxauTPeewhT67u6ekRIp+ILI4wHwYDVR0j\nBBgwFoAUUhfGditSgYrPJVHWAN1Dyg8P6mcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIA6kV8akVXSJJHtiKSt/zUUNuArPKTGLrCRe/XEx\nSH17AiEA+t/u9Kokuud5FocZZ80o6Y2KF/q876ga6UETEhS8kAk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQXoAKj/BAgcLY1j9ONqStVgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2EyYTA3ZS00NWNjLTQwMGMtOTI0Yy1mMWFkNTk2Y2EwMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1MeA6JhdBf6rgLbMs3cP+++BobXbfXhx4orW4jsqGiAzb\ngTzqGSOBRJc1vBQJz59liwYAeFeDYfkQPMtTe/dmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUhfGditSgYrPJVHWAN1Dyg8P\n6mcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNEltwj/bQZV485kzY13Y0J2sUOHyBSm8rMXCegedSJwCICYdip9OYacL\n3k+bmsmUt/ikz8iuZRZSSCAVXGnNn99z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAcM6gjxdq0N/SANRZwPHGnNHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgxMjBjODQtZjhiZC00NmY4LTgxMDAtOTA2ODRmYmUzYzU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MWM4MzE0\nNS01ZjI3LTQxMTMtODgwMC1hZjcwMGI4MTQ3MjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASTZn/tOzVd0q0JOalMof1CVZAWdbtzpb596hQJyBnmIqHUfxX8wCN3\n8qkZuuFWkDAKgM4SCMV4OpAJcPckkdswo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR907Fq\n5M957CFPru7p6REin4gsjjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIGKiPsMdTu+onuJGtQdB3bS46vpsmx7GVa+p1n5P474dAiBytKQzD0C3PQf4\ngDBrV/NFEW5B8RFUkLrc6f33xch7yQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1695", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1695` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISASpGAzOid0bBbbUTJje11A6FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NTliNjNhLTdmMzEtNDQ4NS04YTM2LWEyMDIyMjRkMzNkZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRmOWMwMjUtNDZj\nYi00NzE5LWFhNmQtYWQzYWU4MGU0MDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwcnWThF2fImrgES07fHgkxoXHONcgvXuUQBsdAC2ogfG6s2FDlz6TyzX9xUF\nh5756FqInF2N2P+VqDOR44fZ0KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBow5A532Xo7ee+1Jo2VsgXhw5oowHwYDVR0j\nBBgwFoAU4LJNiawhIwvJPnmKSQC7RhsAxoowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFO5roDBnuEyK2I2G6cneWUbex12zrde3gBudN/a\n4cIoAiBujRo+ra/fN4tvLaP3yeX5BOgIDNChoL+0EVR3r62Y6w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbclLx8CaRio7AIfWPoKDRZeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTU5YjYzYS03ZjMxLTQ0ODUtOGEzNi1hMjAyMjI0ZDMzZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASR1nHnrM7un7WT7BiPdaSH4OBQzrJvG/QR2+JoWDBx/Ax4\nPe8JMNnMflDSxDU4NNhKImvDWGeOizBccBQA36Fyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4LJNiawhIwvJPnmKSQC7RhsA\nxoowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJO2W8pRCh6pBleG0VofTCMr1LLPbUg2RD/uwmWf7M20AiEA1qXabvla\nKOJBwgDqtEe382tlAjrgYri8llPt/16dN4g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAaTeEH7nZDUojLC8C/h15kksMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRmOWMwMjUtNDZjYi00NzE5LWFhNmQtYWQzYWU4MGU0MDBhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYzM2YWEz\nNC1iMTJkLTQxYzItYTg2Mi1mYzAyZGUxZTJkNWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARPxuOtbIRnW9Cts+S1OEfRPbibBXxyN+am5GoEneRFVfwR8kINLWEu\nTZ5sC3G1MNCTVNcyCXFN7qMn0Xc+Z/6Ao2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQGjDkD\nnfZejt577UmjZWyBeHDmijAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQC1XFa764zBvV+0ATiFAzwuqJ1FqjIaYoFJjr71yrdcNgIgdeW5yNLIj39A\nnpHFNUeXneecSnBMcIifNfxYTOZF0ks=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1696", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1696` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAb4ysBH4KMGEgUcvDzYBkWH4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2MDlhY2UxLTZlMTgtNGVlNS05MzBjLTI4NWIwYTk3ZDNmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI5ZmVlYTYtMjQ5\nZC00MGY4LWJmYmUtMmY0ZmU1ZWM1MjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElhBk2isLK3qAPGlEHKSNz/0kPR3OoOCEc8KVZH1Ps8ROTuwhKhUEm8ZUL/ms\nbu7evjDLY4wH6KqQLRUkk3hPHaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3irtljfkKxxZit8c/YjJxvMzaYEwHwYDVR0j\nBBgwFoAUvp7J/pKwelvDoFXmR/1GB4OkoNswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIFC/ryL8l2FN6YjHFY6cW7VNA3DiP/0HQL/bsGOvfMeyAiEA\n0Li7hxtVmEBK7FygkkpYrkagUrVbVnH43KyLmuU6aZg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX1R8d2peIg3kFH3LcJBKy+JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjA5YWNlMS02ZTE4LTRlZTUtOTMwYy0yODViMGE5N2QzZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMSA+RyrttZs2gFQrbNFVihYWLt6cuTdYChC/qz3/Q57G5\n8jwYfn9CzO55MKV59nL+K7yMXwHKwGlMysmfIC/do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvp7J/pKwelvDoFXmR/1GB4Ok\noNswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANKh76PyXHlnPnWlbpVreYgD4c/3dVdsilEhbksdbxcMAiAuw8QXcatj\niznsRwXUCK0Go4y9KKrpLB0MtA5Zlh8QMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAf5v0ObLV6OV41TsCyzc8ZySMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI5ZmVlYTYtMjQ5ZC00MGY4LWJmYmUtMmY0ZmU1ZWM1MjZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYTZlNWUz\nMi1iMGIzLTQ2YWItYWFlMy05ZjlkYzk4OTU5OGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATVrTF0eG7YPGnuBrkD7sqpoaIbMr6nung4Vlzy/E+pPnBKwAK8FmZZ\nsUKPnsN4FPIcsBJB3ZDc8foXgbI+XKiNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTeKu2W\nN+QrHFmK3xz9iMnG8zNpgTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIAD1a5RIxLPB0ZqpbhYlYFE+Aa6GrHPjHeH37rs6g207AiEAndvr02F9kqQW\nNbEO6PUPAWZYz4UOAJgOJE/RV+O95jU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1697", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1697` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAb4LJIaIV/MoQQAByNvmcr4MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1M2FkN2U4LTgzZjItNGUzNC1iMDg3LTYyMmFlZGRiN2RiMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDEzNjY5MWEtNDc2\nNy00NzBjLThhM2MtNzZkZDk5M2ZjZTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF5NELxINdWV/yPQtR7c8WRKX+S+IQUry3NQ07jluG8VY8kITsbJCyMIIkDCs\nqcWq+WHHZ4GbnYbon3l3aMW9HaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHImNZYrNhreCLndhygqzXcT145AwHwYDVR0j\nBBgwFoAUCKlphAoTh551Gvhhux4wHgRC+bgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDV1YILwjudStDDrQ0hzeOt6FVTZLnft\npXSgVZXBOdduAiEAoHPGFrCpJ5mnHuzgHGxV8qCc5Opu/z0csbArcZEef3I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASr0mJ9sBS2pOL4rB7Djd3tEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTNhZDdlOC04M2YyLTRlMzQtYjA4Ny02MjJhZWRkYjdkYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASs/jWjq37zpleu8ecbvhucqQNzbFZNsEgkhAPkz35QJa7u\ndeplAZA4nthJZ6bx9GQJnJhqmetth3fsqqk6cWgmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCKlphAoTh551Gvhhux4wHgRC\n+bgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPLN64Hb5uBOHtRPtY9qkcU/KMPthN3uII8qYSnl6crhAiAeeAF507si\nxCSPkgtgp6vMwPt5hMMBYGu3I+fUYfmyCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISARyyvqxjTnqFJBkz44/NRtwnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDEzNjY5MWEtNDc2Ny00NzBjLThhM2MtNzZkZDk5M2ZjZTcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNDBkZmM3\nMS1hMTUxLTRkOWUtOTBmOS1kNjYxNjRlYzNmOTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQAhdEMA05gc7AQDAIf5iu+pHqKVpdRxZvk4Tbfq080eHxOO3qCF/OR\nCTjbRkoeoR14ng1LQkDOwEwXxFyHLCaQo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQciY1l\nis2Gt4Iud2HKCrNdxPXjkDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDqQ8s2C8eCnYRq3cOa3YyMKQu2XHuWtRjBSkr7szdaOAIhAO+xzGBD9LLB\n9N0Lkmet76dMDgQyIZi233hM38/hQwN4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1698", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1698` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAedahOMATiGXW1WxGHWa7MhFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljOTdmNWNkLTViODQtNGI2ZC05MWFkLWZjOTg4YzBjZTI2ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMwNGFkYjktYzhj\nNy00NzBlLTg3N2ItMzQwMDc4ZDFkMTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErMyzQKa9A+bTUIaY3wmSPWPsZVLudtPwXHNi9TsYHWL+ZuRR+lJXvbYkQurU\nCpgKPD1wc7nKK0h9EEj4cQ94XaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM1NC2xAdtYQk5z4+iSAgiUTzSfAwHwYDVR0j\nBBgwFoAUo0lBAyxPswxxvhWnQ4kFcvyfYjwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIFQcvk2bFqX/V7IviOuav1LguDYckUHa\nkvzc9Ebo+c6+AiEAmoW0Sfd89Yris0S9cIrdbKRPxbDF3uVeJ8HnXI83RmE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR1Bzv3GPBPPrVBkOtMpcyfCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzk3ZjVjZC01Yjg0LTRiNmQtOTFhZC1mYzk4OGMwY2UyNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4JHDz2qjwTVn4IUgLJDeOQNMH2B6tJE44PJnJ2EmCt7tC\nGNGe2XDlLI3HcHfPwomF5aixhuT39vuT/bhegV1Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo0lBAyxPswxxvhWnQ4kFcvyf\nYjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJvRfiQEniNnvgglAbiKqNJNvOtZpztqP9lZjHnrLFMCAiEAodQepJRj\nK5osyokeoJYxhOsbCJjGkZ8DDEcofoGt5ro=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAY7VYclNTcNkBo1U+IwFH5d1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMwNGFkYjktYzhjNy00NzBlLTg3N2ItMzQwMDc4ZDFkMTFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MjA5OWMy\nZC01M2M3LTQ0MGYtODAyNy0wOGU3YjA4YmExOGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARUfFhB09PUPStChmOdy8PeOB6GDq+J2eCLHThKRQ6H54OXEbzxhxe8\n6jokkGNV3ipyl6kZ6uTBnO3BvnhNjTw7o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzU0Lb\nEB21hCTnPj6JICCJRPNJ8DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCUa4xgqPM445MfpDMbUy/RcuaZnTaLPhd2I2w7Y/VmIQIgBvnK165SkbLS\n/f6mkC4LzHubHhJSvrxr/gZ55HmZWoA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1699", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1699` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAdk5HlvIjn9sP8IlG2jv5D7kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzZDk3MmQ5LTIzOTgtNGUxYy1hZDc3LThmNTI2YzBhZTUzNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM0NzRjNjEtNDhj\nZC00ODAzLTk1NjYtNjA3YzQxMWE3ODVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjQAwsxkYlCkjI7NocedUJNNCuaDkzhmlTp7t1iUsZpwNAX4uTKeVTaVdLXOs\nPuE9IXTLkDmhX6oelyHP0OLo8qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5FY38Plv6PAioFGOTbRbTM+1LfowHwYDVR0j\nBBgwFoAUt0UEoKACGf8X/Pw6FxnKe5Hm18UwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIDoPQe7ZvxNj\ny8YFgJDx017aHVb4KVFmHtmJMomQwPKAAiAa+49OFHcnFh8j6x0gr2rC21XqEuY/\nXu4cN+hUr77TuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe3nQFaZAjH/tfJtedKDRFNTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2Q5NzJkOS0yMzk4LTRlMWMtYWQ3Ny04ZjUyNmMwYWU1MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR95E/GIf7sDyaTKBLkVOyTtkLfx5NvJU0nlOiP+2JUz1y\n6ZSSYjERZ1uaED1LJF9W+adV3kgrocPcqk4ms2EZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt0UEoKACGf8X/Pw6FxnKe5Hm\n18UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMqsDMIJmQbqRtNo1wJXrsCIkcwi2UonZYlL2rMcTBy8AiEAwhMuTvDr\ndD/JlTLS3h//U9qp6iH7JeYFQRHmKEZAvp4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAS3DEvuD5J7KkOKRYJQBN4vpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM0NzRjNjEtNDhjZC00ODAzLTk1NjYtNjA3YzQxMWE3ODVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MTgyODcw\nOC04YjczLTQ1ODctYWM0My0zMWM0YzQ3NDM3MGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARjEKpu8YXJRys3slOC6ZIY08YV221O3NDHUl52BmVlWk0ZsN54IpVp\nUS3raT1d9XPuCKLvs5R7o71wMQQxVBkJo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTkVjfw\n+W/o8CKgUY5NtFtMz7Ut+jAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCHRiN7rBxKFGokWPM6OL5C1f8QBVT12LIdpsR3nlGCiwIhANxkvXHoS0aT\n1i1FnqQ/pFK6ZRcT5YYvSnpvZIJ38bwr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1700", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1700` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAcnyZMWfN9681nF9ie72mXwaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4NjU5OWQxLTY4N2MtNDg2Yy04ZDU4LTViYmZmZTExODk2NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmI0YmE0OTEtODFl\nYS00MjA3LWE2MDYtNjJlNzc2NDdkNTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOsVEqtQEPsrD2/vd7pR5E4E4RQO3cMbFLFQ58tRRS6g4uDuBvlatH16hcRaA\nuLcuAlH134KNYCJA+8b9L4gcYqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzwikDm3te26YnuAKW3QaSyetywswHwYDVR0j\nBBgwFoAUPGJNfa3l94AiabLdMek0f69acKgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAI16cvYb6UIdpuWzjP2nssAQrU6IB5+ST3N+al7na3d2AiB8VTCMK/Jp\nbV4NrZcBAcWwvhQv6v0l204KFMuTytOvmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY6BM2xLKjEVQdV1s83zQ/1RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODY1OTlkMS02ODdjLTQ4NmMtOGQ1OC01YmJmZmUxMTg5NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGs3g7QdIKpqCLAZONdE3DHLBmy/4UANL88GfzVTCHweuJ\nP/JPD6aFqMj7zBPXG3eCPEKAevxa61z4k6OI9R/Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPGJNfa3l94AiabLdMek0f69a\ncKgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWy1lrqf3F5q3/SlJIv1+MmpwgUYodKbaeMJKIJ3yn8oCIQCayb1B85yL\nrGgS7uCD/iiBAtsF89QStS5dNEjDAkdErg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAQFl0TC3dSS6PGvUdf5Ekhs6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmI0YmE0OTEtODFlYS00MjA3LWE2MDYtNjJlNzc2NDdkNTA2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5YzVlZTRh\nMC1jNjVmLTQzN2MtYTFlOS1iNzc0MjcwMWFhNjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATdFplyLI1lyNxsxk2SEZ1fIJ/LYHFF0T5VwQncaB1SBEgZMtEh8RhX\nx9qn8y+IRBDvj+BDhlw18Vco7It7trqco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTPCKQO\nbe17bpie4ApbdBpLJ63LCzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIGKyAEA+wtXhZQGGB5XdlX5PfQrfdJuCizVKdSjQB8cYAiAZgmlCH0ZwE8g3\n/xgRRymdWqMLCADpjFpSzEpvItAc8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1701", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1701` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAdMzPBSJcKdsXDBeBAjd185HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NTgyNTIwLTU2OWYtNDg4Ny1iYjE1LTMwZjdjOGFmYmJmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjNmNzk1NTktZGYw\nMy00OThjLWE5OTUtYjRmMWE2NTBlNTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECMREvZTTb7ItFtUx1HnchpEOzgyXE5IQK06ZMej7EXriEc0dWVk0psH+4EsL\nyHxPStUd0TDxlbn3V+oYFi9m4aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURO1wcpF6TFwybM8PhpmEI95MpdQwHwYDVR0j\nBBgwFoAUmCnPe/807BYtrnPcQMjO5+HWPTgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKICWYHDHJU5zH28kV305c+xahu6ZS0yqGHBkc5KF8rvAiBVG57hY+je\nF8JeMte397JVagfYLJHK3yb2h8ri1YYryA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARZPJ8XtmpscJXu8cgCiI7LKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjU4MjUyMC01NjlmLTQ4ODctYmIxNS0zMGY3YzhhZmJiZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNs9FCnnCEHcxMbNxoCCA7EEmHsW+jUoI0Ayw4gcGwLbY8\n57FDZT2HQALJy1rhJLgSqOv9KNNmVKIyTQquI/Cmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmCnPe/807BYtrnPcQMjO5+HW\nPTgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOLwtzY5gjCtVQq7mtNfI7jrrNU/s6AktnSlaCZyS7CRAiBUFQZGGnKK\nsiCEcfTEtHAGxxbILjTO3OAohIinNIBqRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISARMeNP3SYKF8oj3LV8paYIHZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjNmNzk1NTktZGYwMy00OThjLWE5OTUtYjRmMWE2NTBlNTNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZjVmYmZl\nNi1iMGViLTRkYTEtYTQ3ZC02NzhmMWI5MzdmZWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATHb96YpIiKFQRIMLzOJzvgowTQM8TVbPssyxdpIl+cCn0mpODW2NZD\n9Upq3dy/xRw9wCGebAvy8RwJCcDNkjSmo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRE7XBy\nkXpMXDJszw+GmYQj3kyl1DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIGwuRJI+t4p9oZxJtPNPKt0IqB0As5esU9Abs3PsNOCcAiARMIi7Gu7kiukx\nKKXwbnQ2997+kMARCnzZdC2RgEDY4Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1702", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1702` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAfs24kWSdWSClW4hGDqlVGkaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkOWJkNWM1LWUwMDAtNDRlNS1iNjYzLTNhMDQ1NTE3MjEwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRhYTg0M2MtMGM1\nYy00MmYxLThkN2QtYWUxNDZiNjVmNjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAwFS/fTjV5KQui1sQb+3Z2TCp8M5Jp3gYmjVTo7W8ZtkLzFgXTW3BowO3Jb9\n9AupaQ+bwTqC9MUy45zC3xpr06OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvqO6zDBeHS/xphNsNL5jRx+LnNcwHwYDVR0j\nBBgwFoAUIOu8vCeu/mQvNp4c94D2OAasG2kwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDi5AT9g90f0gYk0aGY2o04KBPpFgA4oeJQfJaBopvcngIgdUdvTefD\n/ryhbv1eBq1rI8GBDH7vgGtKwjMZImFCduE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfHhTIJIje5tpDrW1YuKAeq+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDliZDVjNS1lMDAwLTQ0ZTUtYjY2My0zYTA0NTUxNzIxMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASK0Ap8dhChcWtVZiJs85sEEhYaEN898WIX/dLS0RV72BZx\nrGswCR8ai9FzerSshk49UhzbDsdzLQuDea9BRXsMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIOu8vCeu/mQvNp4c94D2OAas\nG2kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeTvaeDst2UKAQFJfrIzdmMmWVi4PFJD48JLQHPN19vwCIQDla2o+8Kwe\nzzP2iJSCz+6+Hu4aj1TaeurXXiySjiRC7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAQX0irIWr1ADZghFtz3JY7VyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRhYTg0M2MtMGM1Yy00MmYxLThkN2QtYWUxNDZiNjVmNjk2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YjVkMjg0\nMy02NGZjLTRhMWMtYjgzNC03NTYxZGJkNmRlZjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATnXmE39dwo4kbSfDxyy/jzTr4PDjy9zLOBZK1l2woyMLqEP9Bhe281\nxB+X19jsl07jcFjmWPd2gTzprIvFAYxWo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+o7rM\nMF4dL/GmE2w0vmNHH4uc1zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDL6dfA74d0LpgJnREDjrDi2u9KtykKsU+8uh9ulISkrQIhAMrHYGq3YDCR\niydPxkU+Z/iMduiodqHz0U8tBN4TPxL2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1703", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1703` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAVW13HX4FU+bU2FR9BmW8JI6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlMmIxYWM1LTI3ZTgtNDE4My05YWY2LTNkNDVjZjNjZGE0YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTM1YmViM2EtMjli\nZS00M2FjLWE2MDItYjAwNzE2NDY0ZTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtqqw8AyTKg7F241gVJb0iq3+WazQYJHTD6DigUO/doANec+Q8SrwlSGgFhfB\nNe4CsHb83rEZfXfP755Kc4+UcaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURSpkMige2SNJeaRWaszLo0//YLEwHwYDVR0j\nBBgwFoAU0C6U/mHWGC350Vz5Dh7Sd/OnZFwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIGGbGZ12IEo7UlAosEtQdpbGXIo3ROKsW9bC7oJI\n7tc2AiBif3DVAv4iwzUTJDCFeF24GtMsaAAAnYNn0zyA5gzxLg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAff1TaX31IQQb73DHTLtaDULMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTJiMWFjNS0yN2U4LTQxODMtOWFmNi0zZDQ1Y2YzY2RhNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR61BZghBvXZSK3SW5zl3kpr/ayFkx4Q9kvekZ66Mir2HBt\nYOcaeVpMptdvyNE7ZlEIkG6BWziX0Yqw5SQPkLVzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0C6U/mHWGC350Vz5Dh7Sd/On\nZFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfk9TRylmgVi7TEK1jeGcVWxHCyqQvL/aw4D24Y1+Di8CIEHwo5A+qgb8\nh7ZAoxFE/1eXOYcn3h01zev5GZWvgbXM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAWIxY9CMgUNjofIbOA5nUBTiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTM1YmViM2EtMjliZS00M2FjLWE2MDItYjAwNzE2NDY0ZTM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MDRjNTIy\nMy05ZGQ0LTQ3MTgtOGQ4Mi1kNWU0OGM0Y2NkMmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARwB91bFwhR+peubwhdpJgAhjgFYXaOl4OVpsRWINj39CFByDwbGlqt\nj3Jh4EZcf4mmczxX2jrF7yEEkeBxhdQxo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFKmQy\nKB7ZI0l5pFZqzMujT/9gsTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQD4uo4wV26/lLcr3X/SpmH7XAiG6WnV1wEFn8Jhjk2KEwIgEXywG4Sij1Tw\nuShdYK6Vga98ccxj9Ou/YgIWW++wFwk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1704", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1704` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAUMZJwi1pT7vAHsvHshYyOJHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlMTU3MzVhLTI5MzMtNDJkYi1hNjM5LWI0M2EzNzNjNTljNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBjZGRmNjItMjRl\nZC00ODhjLTliOGItYTI2M2JlOTJmMDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJlD/ye4Z1RUO4DlPLjynX+yiiWh9A7ZS+sefd+9J0ejmlS5GezO/sv3J/3tD\nR6sZmovIdBvDntmL09o+zLeTdqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtx4/s7RUeXZUiWME/aJjocjNL1EwHwYDVR0j\nBBgwFoAURf7apt7OuBL0+wKCl5H3ksNkK6kwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIDT1c7EKHbt7i21ioRss3oPi4mho31nAmCbgj48S\ngGcmAiBn9/xs03DAgBUOZr1xp2JEClvYP8mh8+EUj4vgvxbGMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARRBgu2zdVVBA/1toTWxj/nPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTE1NzM1YS0yOTMzLTQyZGItYTYzOS1iNDNhMzczYzU5YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARttW1r1k2hA+/9g3uq3I2Xnvsj4PVTPk+93LVytFNWkne1\naDccf3u580M4SfgFCKM/gPG8jk0rhEiddlJAInzFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURf7apt7OuBL0+wKCl5H3ksNk\nK6kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL25myxCmViUEHnKGKNBcF1tQU4ovZtgZHbJAEfgoQPbAiEArsWUsiMR\nZqaKyPIlkNdfIU7SgnkTZnkSOcD4juPXJdY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAcBSQPtYCw4FcjN/1pP9xdGLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBjZGRmNjItMjRlZC00ODhjLTliOGItYTI2M2JlOTJmMDIwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYTY2OGFl\nNy0zMDcwLTQzMDktYWFmNy1iNGQ5MjNhNmQ0MzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQfSBLeRFTREHrjVAkIHAxQONntXh5rCrmoqLx1X1b+ldZBr4oWp3f/\nNEMig7QWNnQpqx4GsbTy6jF3O18hFFTLo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS3Hj+z\ntFR5dlSJYwT9omOhyM0vUTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCzKCqpHXz650xXOlVZStVvp92cM6JJX5NAN1UB2l6DqwIhAMZYYBDQSJM8\nDCWXFfCcx1InYx+WmVrBvNou9E9p/Kba\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1705", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1705` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAfMP1wfGV6jVXnpJ290jqEWmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0MGExNWFhLWU2MmQtNDRjNy04OGJiLWQ2Y2JmNGIxMjEyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JlODY3NmYtZTE3\nMy00M2VlLWFmYmUtZjlkNGJkZTIyMWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKVkQ7r1/Xcbl5dDX4ne5cP4qMw7r15H4Cbw4DVoMMa9H12W2Kq14fdz88PEc\nWSOYPKaGYBaaJa2JRw1Nxw9KZ6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuygFvwvdaJrshSlUh0Y4uMuyQ4AwHwYDVR0j\nBBgwFoAUc3+kBYNxEFcmA1gFVFQaOynVzAkwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIE+9iT3mO2q5QYtZNiFhEsODVi/8bSkTvQ+u7FmpefrvAiAh\n9Af2kmqUbnG4n/HVF0j1Ki1AkwYKDd0u/bthu36CVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARO+bEBblqyWgZhSwig+xGVKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDBhMTVhYS1lNjJkLTQ0YzctODhiYi1kNmNiZjRiMTIxMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARu86kFKHa3td6ps+ZupMP40kvEnIlszSDqlBaddAA5QOLl\n2jJLruws8hcJilhtf5zg/LLjP+slEOa4pWVXbNOyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc3+kBYNxEFcmA1gFVFQaOynV\nzAkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTHaulRYLG8RXpW/PHhSez61iMl05dBsI3PV936atLY0CIDw12R67YxTq\n+M59sg+UcNBzv7VmK2aVQlzuNJh7FmTE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISASvKJrzj8f/xC1s7hap3w7AiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JlODY3NmYtZTE3My00M2VlLWFmYmUtZjlkNGJkZTIyMWU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMTM1N2Fi\nZi02MWI3LTRhZGEtYTQwMS00ZmQ5YjE1ZjVlMDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT6r057lwN6E4H5WQg2k6wtCZkVDn5+gkGHcufBCO6t2zN5wwyKYQHl\n68npWjz8surjhnwtqx+GCD83fO8ZHoLZo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7KAW/\nC91omuyFKVSHRji4y7JDgDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDlB7PjLcUAUj1jLCIRGKA7Kw8LELz+t+ecezI06++U+gIhAJS9Oihg+6IU\nLpM0c/LABurWWp9xhskaCeYfiJya0wm2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1706", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1706` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZBYAnmIQKSZTR8j3k86uznGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MTM3YjNkLTk2NzEtNGIzMi04MWQwLTAyZmNkM2ZiOWUyMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI4MDYwYzQtNWEw\nNy00ZmYzLTk1ZmYtMGY2MjYwNWJkMTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEadYqPr7lqLC3+5DYY7vmkdupj0oe9Yr0o48rraVVYZYXNcQE32VTbtk/4X3x\nU++5b15OUDkLmF4HXjuenBaaoKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKZgT3LPfSKl9YJPDFqU/HBvu3L0wHwYDVR0j\nBBgwFoAUxJNvzwEb8iXNt/f1/DydzrN7QdcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBK/n+6RQwl7KlQha61cj8BSKO7jj939\nDty5NMCgcL/sAiEAtKGe37JrAypPwJLO94/LQImE0bS9JOtEsPtvwBjBAF8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb/ZHJ77gkzSK/k/MdbV9PimMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjEzN2IzZC05NjcxLTRiMzItODFkMC0wMmZjZDNmYjllMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzpxpRQFhHFxxB3vrGhnghYXHOurLpNKg2cMgjXQLKXkap\nqzZrKMWgnpQyeXunesuizH0ulMBYPDacFHyCz8IKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxJNvzwEb8iXNt/f1/DydzrN7\nQdcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMGE7k2RDuSlRiv/KaCQ33mggbFxnKN7ke5C+n9XbcZtAiEA+leXT3TV\nXCbtCQyvwDLzG9umvHky7VeuBwfv3oeT8FM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAcdh0CEyLJyXkYf3IMLit0LxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI4MDYwYzQtNWEwNy00ZmYzLTk1ZmYtMGY2MjYwNWJkMTk0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZmFhN2E5\nYi00MTg1LTRiNTctYWRmOS1lYTczZmZiYzZmZTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS4uQ6TBL5zZZPSA+LSQ+vIbePQCOTYks5fbjLnttF2yAS8vft62Hwm\n0BjygFHACA9uWFRsgO75IeZIKreTAuMBo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQpmBPc\ns99IqX1gk8MWpT8cG+7cvTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIDRUapqmXUw7+z0jAE57KyBl2VAz+jjdiD3Tew2dczVPAiA/V9SR6F17yp7G\nWaUq+yqASkJ6GLQPoI3iJYRdmFlqRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1707", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1707` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAfYd+iVMe0kaxRGYLIEFMQMpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxNTJlYzA3LTQwYjAtNDhmNS05Y2VkLWQzOWRhY2ZjNWQ5ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJjZTRmNWQtYWY2\nZi00MWFhLWI5OTItNWQ2OWVjZTI5OGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIaggVT04NE6a5tred37JnkgTeZmOmhE46BWS1s5kvEFPZxJFoa48fknWH5z6\n1fvlNwygDtRCjfDvrjdKtrbjjaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgUoYbC4VSBc6WmFqIaTeZQgwYXkwHwYDVR0j\nBBgwFoAUMJaazmxNIkRqqlwYpEpXBl7UZd0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIH+DFOPr9jKA6tQ8JRvc3MjkcWTXX7IR\njWrS0Q5NDNaLAiBS+FC8AGshnbFkrVcEZJY1FmskZda0Zso94MxE5Twp8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAew7hoO31ADMKBNCveXvkz+UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTUyZWMwNy00MGIwLTQ4ZjUtOWNlZC1kMzlkYWNmYzVkOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdwUsonpGiH/W32IUTPk7blutMQdQpNZUIOWFffgI/mFEx\naoTvgKmthP5Za3nyOTT1fhNYc0LxwcXtJRPYBrBDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMJaazmxNIkRqqlwYpEpXBl7U\nZd0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALA4UGgZwXR9RJAAaMjbHWt87nMc2BXcZuC8rMgw1nQxAiAm77OHY/UB\nEq6rvm4Wbc/qg0eCU6leqvR6fPAJZL+SMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISATOlQmDKB/0LGV3ktrvvOotFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJjZTRmNWQtYWY2Zi00MWFhLWI5OTItNWQ2OWVjZTI5OGYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYTcxNDQ1\nZC00Yzg2LTQwNjctYjBkYy1iZDMxOTUzYjZiNzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASWffdfh3XHBYI7gZgVxzFj0CUf2FvZ+MuirmxrglGC8wjdNLOV7NO5\ngStAfiXhVoNmdSTKWDUuj514HIncf3E9o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSBShhs\nLhVIFzpaYWohpN5lCDBheTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCWK8U5FGo0bdDJjYKyNdncTMrDMVWiFEt7Vw14Lu1XUwIhAKW4vUL/6Aj3\nAOGUyTkgSwDhubPAQOIGzb2/M58m5G6b\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1708", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1708` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAf6xavwC8ym2dknGPIDzk8loMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3YjUzMDgzLTExODktNDg3Zi1iMzAwLWIyMDM4ODQ3Y2MxODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU1NDViOTYtNGE0\nMS00M2JmLWJiYWUtZWY5ZjY4MTVjZGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuIpKoXW3Cw30Bzl9KfT7K1+5GmUJuGhk1XSPlYgexdNYgrYj/nfKrkY237yz\n+2AJNJhkRvgoAwR5v/1HYpIneaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDgv1F09DnB5Z4cI0NEbR/RhQbq+MB8GA1UdIwQY\nMBaAFJQaLcd6KBzqn7OMsgbQ1Gx6EBkmMAoGCCqGSM49BAMCA0gAMEUCIHs52bqq\nHQlfz41rOGlDSD+cuFbs4WbjJfusIfQDCV1HAiEAnLC0Ar2F0fuZFgFBsGVh9Duc\nzSKNQrDJns2prSNDKTc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcBWRD1qHjKsUo/kDgY5dZFhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2I1MzA4My0xMTg5LTQ4N2YtYjMwMC1iMjAzODg0N2NjMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTcWBLj7tuHx/jcAisHtwd48ulevWzFVC1o6+W9VHf7Q/G\nyVu0HzQhwBw7O9zsAYTwntwjI6WGDQbUpvti4w8Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlBotx3ooHOqfs4yyBtDUbHoQ\nGSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAJBxZi51hMI7k/scCxbqnYUQraw0VXVkb+XJG66Kp1MCIH9fP+HmbW8S\nwD2qxyRJpfAIPZOgQmkbSvIOiZjQFXKh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAewqYve7FiEiVIHw6k+bYhr5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU1NDViOTYtNGE0MS00M2JmLWJiYWUtZWY5ZjY4MTVjZGJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNTNiNTRk\nOS01NWY1LTQ1NDctYWEyYS1jODhkMjBjNDNlNjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATQCLhHpuRgDV3vCplG6UXCD95pkg9MbzQYkQyEHIPEPu4DEqDlf4xv\nx/j7VO7TKZVN34+JY3wpynEYJfVLpzHio3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4L9Rd\nPQ5weWeHCNDRG0f0YUG6vjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiA5qNsDPBoTHzYL83ezVme7vnb9e/JO36Coegl0eoWc9QIh\nAOleWFRgHDOoStQlwQuGqZMb/qKE2hBLpLuynEytkjA0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1709", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1709` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAQQkQYk6W1gEwTaKLastPvNqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhNmM0MDZmLTdiNjEtNGUxMC05ZDE1LTliMzJhYWEzOTYzMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE5ZjUwNDctNjg0\nMy00OGFmLWFkZWMtNTliMzc1MDE5OGE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVDuH2i0Dak0WHcUw+FQbQI7Z9ambHj0+jvElfFF2+rhjAaKKw+nbjslKaWdU\nD6Uzru6ofUln40P1alinPDIPYKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLEsy2uvZzvT1nEpagFhEKhX6Y5OMB8GA1UdIwQY\nMBaAFKZ25lg9Hny5WG085lYlOhWX5tvQMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBygzcd2gEgpyeLV9ndc+3aUlvV3z+Tc1OO\ngEoW74/mMwIgKo66Hn3IekMhpOhuGneuNOUoNqKWOljrHMV17r1hY+I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARn9ztSCz4Fq6HMvOWtihHpyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTZjNDA2Zi03YjYxLTRlMTAtOWQxNS05YjMyYWFhMzk2MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoMbOjNEim7rqmBcHAaG5w4gYOUPOA9KHe/cHaE0IO8Y6J\ntTi0AKU9ApD5qUB/w/NkoZ+jsbVxQYyXvRVsqx0do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpnbmWD0efLlYbTzmViU6FZfm\n29AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC50CO8akVPlTQdTe/7h+Ht4JfAkfqWVcH8/9VX7fdhsCIQDsemcinpAl\n8yOXMRU9oxS/KLuxkWBRKaP7l/h0ur5zjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfyFM2oeZpvqcoganV6b3t/OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE5ZjUwNDctNjg0My00OGFmLWFkZWMtNTliMzc1MDE5OGE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZjBkY2Uz\nNC0wZjdmLTQ4MjUtOTNjMS0xNDM0ZjdkYzM4MWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARM2925l0+usugXuN1zkLbWZaJnO2UfRuoNhRpgIA+SBl6K/w516o3J\nYfZLjUJNm5coKVZGQXOM+eXfoIdI0WTfo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSxLMtr\nr2c709ZxKWoBYRCoV+mOTjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBKhbDc+Tj06LqIfhC5HtnUjM51THtZ63SaC0l5aO2yjQIh\nAP3giTm6dysZd627iEq6AcwMNjcbm23jQ0YwFLV71z+T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1710", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1710` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYBlrLiQ4lRW9gErDienCYNbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2ODM3NWU5LWVlMGYtNDJhYS04ODE4LTBkZjM5MDI5NDUxYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNmYmZlMzQtMmYy\nOC00YWIzLTkxNDAtMzBiYmRmYTVlODc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXLKb2+zKjAwmr0Onxf4Q0M56gE4ntYWOJbum+Ijdm/hVaE6Cx53k7IVoOeAU\nNtj/rhGpoMHQqU4ePsvije69waN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFK08QzIMOyGBmevAdtkHnaoEK4wwMB8GA1UdIwQY\nMBaAFG1ZXVXJsPKtQjRIA82jycFuvU4ZMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA9YHQ1ugYYWTk/+gxjYkMSCBxQskh2LWG\nmNl15JLz0KECIDsPcQeYPg5OPNJnPpOaGwEMze50+0gEpcMQ/W5q+6jv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYsyKOW/1FpmBiCVS1dea+D4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjgzNzVlOS1lZTBmLTQyYWEtODgxOC0wZGYzOTAyOTQ1MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQo35DhgTnGDyrDnuC1L74aD4MsDHIzWSEPe+Z/EtlNc8vR\nBZ3DfDb4T9dMCmF12gq66usEl7owF8bjrYhsXDvWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbVldVcmw8q1CNEgDzaPJwW69\nThkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMPfAPJo3KORCmKnW0A3ZiVLHM++pF8WqznQNrGa6KUcAiBxqbcMoffI\nJbqgyr91B/UZwl0YPW8IbTiWkeeWiYeX8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAVbqYAwIXUGws6qsNoEjjG+KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNmYmZlMzQtMmYyOC00YWIzLTkxNDAtMzBiYmRmYTVlODc2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NWIyNTVl\nMy0wNGY4LTQ5NzMtOGFjOS1mYmE4YTg2N2Q4NjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQmW7sckDTU4jff2pNlzQgouGVI2tiJPg6U5hqEVSLriLtRVQnq2NpN\nueGPqWb9COYEAXVsqfT2qmylRlLXyGieo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBStPEMy\nDDshgZnrwHbZB52qBCuMMDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAjJJGlj0HXewoAdBobixaB2KHnL3e84qWDlZj3TQPHk8C\nIQCjeEPTohRmpcsqc6mTD56maLrkR3JOaOlrO52wI7jBaA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1711", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1711` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcoBjFLf7ePLgSB20d3kpwjvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiMzhjZTJkLWExODQtNDdjNC1iMTgyLTcwZGFjOTkzN2NjOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY4ZjFlODAtN2Ux\nMC00ZWUwLTliYWYtOTI2MjFhODVlZTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8JfJB9YuGr3A50XORNyQFH04TrjxdiKbCsl4jDjChcBM0cnVEPQ68he8NYKC\nte6kTg9+9fISRVFCHyiL+BHnUKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSYpXiy2xw8zqN6ZO6xDw1OEq2NfTAfBgNVHSME\nGDAWgBR17jT9nOERc7juRPFyhNOdmy/LAjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDgGgaUNdbO8fmpdallbWl41tTkwbUI\nYEYGmKravYnigwIgMMS4KmEYRSByiYnZJVZRAPsNpQ+6lNzdh13II7Hbnys=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARw/2A+A2inFAxGw6svolMe4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjM4Y2UyZC1hMTg0LTQ3YzQtYjE4Mi03MGRhYzk5MzdjYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEUtp7kRqcFRjUBJ0Q91d0wyssGKCNEFtFbKPgjfBwoGy6\njYLd1I8gtY/B37A/HdgXdUWxm3MH4O51DJwhyHGmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUde40/ZzhEXO47kTxcoTTnZsv\nywIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYKZnd5s7I2kgC3u9IVVyBtz9gRDF6bZl3yHdk8ZBdksCIQD2PTcUZ+lF\nDrUdkEJ7vzRAS8r21gbTP639T6ngG73M6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZg/Yu6sltBB3XW3XJblg4F8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY4ZjFlODAtN2UxMC00ZWUwLTliYWYtOTI2MjFhODVlZTZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NjE2YjNm\nOS0wMWM0LTQ5MzMtOWZmOS03ZmExMjk5Mzg5ZmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAToY7KbalWwRW+CJpTSko71iQsHGpNkRvsj6RfUPoEkz3pFhDbqmPbL\nnTKCvnkzuLv25TOp/Wd4rOWmvfCKWf2Po3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSYpXiy\n2xw8zqN6ZO6xDw1OEq2NfTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBbOsH75hnT89HCRrVMnPwXfhY7nivl8DlZSTWOV1XbywIh\nAP08bsUHxbGyyMQ6jqR+Jt/mmUgMfoaXVdo+cdB03yqZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1712", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1712` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQ5hhjQbfC2uNoDjbN7mq/48MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiYzRiMjkzLWRlN2QtNDRiNi1iZjYxLTNjY2ExN2UxOWVmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQyZDUyNjQtMDFk\nYS00N2VlLWJhYzEtZGE5NGRkNDkwNDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuy0pGVl0HTWnbQ9n9S6A833IB//IQqfWW5i0fPgoutMZ75UVDLVZMuMTiU2Z\nD/GEHcEKB1YFpaJaM6c2NYLc8qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURWa/hEfXenhbDnlmwzyQg9DsugAwHwYDVR0j\nBBgwFoAUB+Qa2LzuEpil6mw8yC61czzfXu0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBZfdScciwbbpwj\ntbhVD+fv4RzxReBoK/4zWgvlHU5stwIhALsCiYsnOCHUho7++jLiN+3oxk8q2KBD\niuWPAop6yHst\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd+LlQ6kVrEC3opKaw+SN4T5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmM0YjI5My1kZTdkLTQ0YjYtYmY2MS0zY2NhMTdlMTllZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvmobcL5lrahq3GvSfuQV+ugRaFFgjEOLn15tRkkowvgRf\nheZ79cWeZyQ0XvtldhexRrS4QITk87EBispce7Vno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB+Qa2LzuEpil6mw8yC61czzf\nXu0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYzdhWmISiVavIIIhSf9CWA2GgA5SxJi9GwNNChppG20CIQCuIBOEtpUo\n6D4NGektRRG5rmywIremOmOLukjGQcQVcw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZ/bwP9C+rLl0m0JdTPO3tKKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQyZDUyNjQtMDFkYS00N2VlLWJhYzEtZGE5NGRkNDkwNDkwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MGYwZjdj\nOC1kYTViLTRmYjgtOTFmNi03Yjc3YzQ3NzlkNjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7yBekgYKvd89svfBUkiELbW+/EQkQa+jlH1cCxbUv3L8yTZsqy2dQ\na1qu8mSJ6vuftnYHCO0FDqPnNL1YNyIZo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFZr+E\nR9d6eFsOeWbDPJCD0Oy6ADAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAnVThZ5a29nsglNmUErp/0YUM4hLbiIv4dA6/drq0tq8C\nIQC3WkH/jLlBgOHWAVoKuxUS7yw5v8ba9BJzZ/ldc0vFSQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1713", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1713` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAV767fx+dJzCWcgQyjqgxghfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlN2U1YjkwLWY1YzktNGEzZC04NDk5LTE5NDcwMWYwZDQyZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2QxMGVlZjktZThk\nMy00MWE0LWFhNmMtZmM4NDliMGE1ZmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExIVbc6fmcP4HM4eWqBBTeD5Qa7Rriv8NmLbwN9lrdyIpFGjJtkAnfauLjPfe\nh1QJl0ED2hcUghZow7Qk4yUyaaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuOODo78ceCV+3EJu4kGcNc6t3oswHwYDVR0j\nBBgwFoAUZJ+6VsonWs8EMxD3NLmppfWJOP4wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAlunvsDPZSCqC\n3JLtroOJORWi/szOFnYehrjcH+LShdwCIQDfhM39QKo4FnNUvmIccPY7FYLwB04i\nCaGEZk4tGgWwsw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQujYkClCtk2bbPrz/W3p9YXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTdlNWI5MC1mNWM5LTRhM2QtODQ5OS0xOTQ3MDFmMGQ0MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgwDaZv9bKhWuu52mP4oOu8soF5qL/xI1CYEU9t5iJKqC1\nTlYE+pvQy0I/oL9NaPOgIgb4zD31M/YMmqIULvloo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZJ+6VsonWs8EMxD3NLmppfWJ\nOP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXh3uVaDstXDJVLtkCyTm019d2zXn0LWlS4JGJZC6xukCIQCVasGECEK7\nrQe4D3/euS2aLj7+sJKVaiMssbM6mRpsaQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdkBaMFR92p6U6aM4x6n1j6GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2QxMGVlZjktZThkMy00MWE0LWFhNmMtZmM4NDliMGE1ZmVmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3Njg0YzFi\nMS05MTk5LTQyMmEtOWM0Ni0xNzdmMjZjN2I2MWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAStmyiMooxhPrSiE+3ieHUriODO91Mc/UYmDVfrFft58fZkbGUwNbJc\nxQVQxL+/r4dRCPIWJbVAsA6aa4+RKudvo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS444Oj\nvxx4JX7cQm7iQZw1zq3eizAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBlNxjDPGMz/5EOphd+xB50tLWXAAaRnPFnYdq9LjZT7AIg\naQPaiNNW397QOyo6ylqbjWorwwwZ9ezGXcNlQaYYXMY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1714", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1714` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAQD9qn8msrofxn+TnoEmDi63MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlYTEwOWRmLTc3NDUtNGJmMy1iZmU2LThkMGI1ZjliZDM5YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ1MjkzMDMtZGE1\nYS00ZTJiLThlMzgtYWUwMzhlMjg5MTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQeeuzka0Vm3BKfZz8Wme1l1cVCQE1WHakCJCgi+5xmbsDTd6HOxEmTQtYxvi\ncn0wghawrvFTWt5wxd3s0Txgr6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi+NJSXorBH054Ox8OtoY1zh1NhwwHwYDVR0j\nBBgwFoAUTLHUh3Dn2GFAawUUu1vUkCGNlCIwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAzX/3cS0aEsyZl66YsD52B\nK4WJXSXavgUCKfGlWXdaHAIhAPcG9sGM0uGr9ks5UiV+h8iMTQPRdRCugus6TZxe\nVWmi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdHYy1AHNw7zg9OkNMmWThGXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWExMDlkZi03NzQ1LTRiZjMtYmZlNi04ZDBiNWY5YmQzOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR428QsDo0jU5FKOWqLIZsXATC4HbOSSoMg+KSzn3lZ51gW\n8mEhfxRGEuDcu0+m3u9ZA2IrDwyA2i7wbLKO5bVUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTLHUh3Dn2GFAawUUu1vUkCGN\nlCIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXYIus99xvyh9YIyId2MHlSWFROkURderdO75ZKJaSssCIQC8661Q30TM\nJbzclvgfQPOKSEvIhfLHgx0YRCKuPfHlKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfx+Duzgh8H2+Yo/mj8KIJvKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ1MjkzMDMtZGE1YS00ZTJiLThlMzgtYWUwMzhlMjg5MTAzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkODY1MGQ1\nZC00MDU0LTQxOTktOTViYS1iOTg4NDA1NzJhMzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQF3hjUfgfkMnzp/o0k8rpoJRBz4tDj1xGiQ5GJMmjUsgL3Wot8qB5N\nanD5qLvcphRAH8QZmDqGHfFidUrjSUUdo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSL40lJ\neisEfTng7Hw62hjXOHU2HDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBH7Z//MOmoiNt4gXvNaDSp6qrD9lYQ11X651fz9YSC3wIh\nAMBqOISzTCdNEbjy+HIRzKDXeCT0zKNZP2e/Aw2Qdayu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1715", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1715` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAWx6EeDkq1H96g0Y4AK7OZ9yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMWZhNDczLTQ4NWYtNGE1NS1hMGQ3LWQyMTYyODdjNDYwMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY2NWUwOGItMzJi\nNS00Y2ZjLWJiOGUtYjY3ZTA0MjQ3NjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn9f1q/tdj8hF8P/ZlSFbBZrnt4AXHq0cy73f81752oso2XJMaBys0Sfz8bDh\nw9oqF3GOC9ghpNRmdJnYwCrer6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy2IEmn1s9bH5NHaLkKSmzekiv9swHwYDVR0j\nBBgwFoAUijuqMGL6balnE4QpHGmaGjLRkP8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBVB2YD\nATH8B2shPR8AbCPnKAkjg+xI3+k5QJYUyjskggIhAKmdvJZu92IflX8eZySMmOtT\nnpqiEk45iQfdazi2/TrX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW4huaAiD3kSuq1Go9ty4j3GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTFmYTQ3My00ODVmLTRhNTUtYTBkNy1kMjE2Mjg3YzQ2MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARh8fOnrVtKEHlV7H6sFgpbf3XimchGNui2e6yaYdqel6zN\nnU6y0XWF8Ax+/3sePVrNwJC3XSCcL2zuro5g5zbXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUijuqMGL6balnE4QpHGmaGjLR\nkP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLmEAZCkgx05cZnWgekywQSJjgx3flfugmFUHH9Ii1yECIC7THHtHUBa7\nr0y+TwAQyNDkCbjOdZ6GH0OVP3FIc4Op\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAU7rOCDx3Lf9Gnrsh4MYUMiOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY2NWUwOGItMzJiNS00Y2ZjLWJiOGUtYjY3ZTA0MjQ3NjZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNzI0OGNk\nNi01YjlhLTRjNGMtYjdkMi00YzAwYTlkNDdlODUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQvfYM+5aH7ZXh4Eiu2S/gf8KK2PLmvWNhT/cTDkO3fJd6FidxKyTe1\nCrL7khAiAFYVomuv4UYI2lPgw06f/kyvo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTLYgSa\nfWz1sfk0douQpKbN6SK/2zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBkijW5StGohT9kn862Ob7vJl5McPk1T3K3IQhZbFAatQIh\nAIz1e/p6CIy7oGDy0GmT4qq4jEu1uSXrqb5EWLXi3XVT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1716", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1716` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAVfpzOgPUrQJR3vbmQe1pVbbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkM2ZjM2ZlLWJkMDEtNGJlZS1iNzY2LWZhYjVjMmY5ZDU3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRiNGRjMzgtNTMx\nMi00OWEyLWFlZmEtNGRkMWUxY2RlNzYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcOzdoRoMWAo6UjivKyMQhmK12AhAv8h7nr2uOU6KIeHh0UNnZECFYga9XXNF\nTvzJsUeorCp/RI/6FzkHwVQxEaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYN1+uA2PrKkny76NS8s7cE/makUwHwYDVR0j\nBBgwFoAUWAHGQo//LBzRv63Wwff55Q46MDIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBsUnXf\nCVF4dfNwUHKR3MbQn81X9A/tD4PWm+596H9kiAIgPQeFlftqF7RmUJhh0st2f9wO\nvGTR7CRDwJDxRmmWuZw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARpHK885+QTUxbENvzuYOyQhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDNmYzNmZS1iZDAxLTRiZWUtYjc2Ni1mYWI1YzJmOWQ1NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSBCxTqoF1rJOBeJcT9yZcxRBbdjDVI+J/h5a8kAp72/BI\n3JsJzrqbOw5h8WIfiPOhLoiPga0COQNHq4owsObBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWAHGQo//LBzRv63Wwff55Q46\nMDIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOYdsIhR9SEY3UmbzLAWkqLRAnVMhefVd+OF+sMbPQ4ICIQCCbtixlMRA\nEIjQywD+v6SqrfjQNTcdvSHGLgJ1Lv7A9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAXNBWBtZ9C7otngFfIgNLrKXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRiNGRjMzgtNTMxMi00OWEyLWFlZmEtNGRkMWUxY2RlNzYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZTliMWVl\nYS00MTZjLTQ3MjgtYTcyYy1lN2FlOGE2ZjI5ODQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAStZqiJ6OizR4aUB4r77S99sHihtBLDiXgB0c8rHYRJNjmeZiLl+ajd\niiw3vEhMx8ySoHHzEjNe91Nv7OcKDugMo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRg3X64\nDY+sqSfLvo1LyztwT+ZqRTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA42JSRLMVuRDBKYlKKYaX2/KXEQ9UYfh/mA3+ceQLZl4C\nIQDt1KcaJDv9LTufNymaMQEp7DVgp+/18Qco526fIgTN8A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1717", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1717` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAY6+QNTmCm1l6RPx6Sl0ltFhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwNDk0MGY2LTNmZmUtNGVjNC05MGI0LTcyNDVjYWNkMTE3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE0YTk1ZDctMjAz\nYy00ZTMzLWFjMzctZmIyYzM0MDFjY2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEgkG/SYo5CnMaPaNyqJNHsSXdxq41WKelHbUK0Hf9X3Jp661gJfBxjdGb87w\nTnhfXumIyqXXqsvUWRrZwuGdl6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN60DpEE+FU5gJhfYb9zlIaVDvX4MB8GA1UdIwQY\nMBaAFLpOM0BhM6FjRreeF22NcpSW+VzSMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAJrhU6etp2r4U5/DKz+qD6unoH2O/+Usbm\nsyXAP3/YIwIhALNaPL0WpNuEgjVNc6VAMWcTv1e78OfkfcSWBOKLxxJB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbsjHFoeGEoe3pD5m6h4icovMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDQ5NDBmNi0zZmZlLTRlYzQtOTBiNC03MjQ1Y2FjZDExN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOEudc/YesJZ7ukMdHXIOwLlkCoj0tqn7GJ912adjiDJ7M\nCZ7x2x+C6CWLok5v2nRWxyR7iwtVjEILFkfDImaTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuk4zQGEzoWNGt54XbY1ylJb5\nXNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOGXarA7BFlpA/B5CqmG9AfJOtNVK0IrH9RbIEpdBfwBAiEA2PGta5bc\nnXOPTaIuvosR0rFzrwz/G1cO3JNe5E9c6sk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAaibzzyb7q9uDjrwqbuisuE5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE0YTk1ZDctMjAzYy00ZTMzLWFjMzctZmIyYzM0MDFjY2YzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZTYxMmI1\nZi1iODYzLTQzMmQtOTNkOC05YTRiMzRiNDhmODYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATUS2MhFP7j5erWFPgnCCjjdRD5N5xEmyKc6eb4pfSCOe/Ckv637VN1\nXRXPySDO/x+lv3QX8NcM30eBieU++V1So3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTetA6R\nBPhVOYCYX2G/c5SGlQ71+DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA9dim6OvbO51Pg73mxusbpMbtmgpG0m0s0BHy4fa8eBYC\nIQC5sfXU34pEPsM3PuhY49GE27ZO/rsb9iAO7BaipDI+BQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1718", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1718` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAcFtqjOSA7tHB0edczGAF2d1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1ZGExMWEyLTM0NzEtNDJjOC1hZDdlLWVmMTRiZWJkYmUyZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc5ZTMxNWQtNDQz\nNi00MjZiLWFkZmUtMzc4ZDJjYTA5NjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj2RoLO2CoomXvzeL2IVj53n37V3NNtSjtg3TVftd6PSdjoe0CPApgFQZ+iyU\nffZ0Il7i2MejuJ4y6djEDupsbKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7sNQ2KCzdTrY6CaADp+qsJEqsWIwHwYDVR0j\nBBgwFoAUW5++UUnvk7XqjwlQm5+oUSSS4eMwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALPyXWUBnQgB\ndAqjHyaHd6TjIFpR9dbtSwM2C06vqNwJAiBeb53dZThCi36T6cMgGIvZjGBcikqx\nL8DCywAxBAoNlQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWKUnFaFIN8QNm+FSYKbhxB4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWRhMTFhMi0zNDcxLTQyYzgtYWQ3ZS1lZjE0YmViZGJlMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASirhJ+WBZzxmj8kJRl2sFNOLp/Hto+2rojiMgW2OrZXFa/\nuE2z4IctvBndWWstcak+PJUy7Q0VRIynkPa39hWco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW5++UUnvk7XqjwlQm5+oUSSS\n4eMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJdMvGYld1HAz+608Lu2ezoTe/6OWoOQv99cX44jnrDeAiEA7OiLeprJ\nrhcPh5C4yStup/oA31bi2T2WMne+An3UTy4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUoI8MtD7TieFzU0wLSrWTabMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc5ZTMxNWQtNDQzNi00MjZiLWFkZmUtMzc4ZDJjYTA5NjZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhN2UwZjNm\nMy1iOTM0LTQ5ODctYTc5MS00MmU2MzFjZDZlYzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS6V2ZgCHzgSPf4M+vF7CNW2R5KSLDmbpcQrjqXCt4x6FBJHyItVgH0\n5b6KyO01kCdyRYE4dR8e3zzNzEkonapto3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTuw1DY\noLN1OtjoJoAOn6qwkSqxYjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAV3x6i8x8XVupau3lQ4mxcHSM0K/jaVooCXOzC/C83QwIh\nAK6XcC7Eud1GdxUBydTJpyag4jiihD+JCq0CIYOyt49B\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1719", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1719` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAW+3Nh3XoaoL1DsbmOQn7SXLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxZDg2YTQwLTNkZjgtNDM1NS1hMzM1LWNlYTRjNDM5YzBjYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU5YTg3YzYtOTQ1\nMC00ZDJhLTgwOTktNjgwMzg1ODJlMmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeFjZfz6j1Yl4vCi5oicL5Rjs1GmbOJLFJrcqegVFghquxZ6x70Dsu3Y36Wgw\nNDZYkKZZeHBuzglZh/pcjP9E4aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHVVxQU9Uwic/c/tF2xIPYfVzo7AwHwYDVR0j\nBBgwFoAUl9S7aXmMebizM7dDEyTenru0KNwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgFC25BAVMIbvY\nSmdw+Qlau6Ga1e2AYp3xvQ7KdjQOcsECIDqkTxv70/L/Lux2QY5P+uoEqHNfOJ7g\ndLTV8BW4ug12\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWN+CYr1nvEC6U9Lmz//ks26MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWQ4NmE0MC0zZGY4LTQzNTUtYTMzNS1jZWE0YzQzOWMwY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlbLEuyYP1IWKwIMvLx6aKK3iJhHSmk2LnahrDZOub6iCl\n4jYh1umdmd1eqW5tk1xkzXrqI08cXFJXi1ZZIWd/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl9S7aXmMebizM7dDEyTenru0\nKNwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgb6+zcQ1Z40/wIyEFw9Djy7PqXJZt6s6Y7k+ycKvP5b4CIGGOLKpo7Q4W\nBBZV5ohBDvXGYYdZNF/0PAUSgsWpvWbK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVZmtn48/EUsx0BnQ1geVve7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU5YTg3YzYtOTQ1MC00ZDJhLTgwOTktNjgwMzg1ODJlMmM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYTkwNzFh\nMS1hYzg3LTRjNTMtYTZkYi03NjdlMDIwNGRhMDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARBVVWI/zX2ry9CGnIX2LZjVWkH6xcLm6RZR0owVLI3sRPVpVcRjsLc\nPH9PBPJuIRwHAA9ragEwWjuiU2VWI7dso3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQdVXFB\nT1TCJz9z+0XbEg9h9XOjsDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAUO5lFb6u2hoON6XQ8RbFV0LxNQfh04Oh4RrSD02XSuQIh\nAI+ytTKVcTBpLy9tC9OISnqMPpA90EopcVZ6WzM05HlZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1720", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1720` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQiyjYxfJe7C7YX7XUTHqz4dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjNzllODAzLWVkOTYtNDkwZS1iY2Y5LTIxZjFmZmNkYWU2ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdkNzIwYWYtMjlm\nNC00ZjQxLTlkZTMtMTEzZWYyNzAzZGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDbHMrPwRS5WgS4X8dXZTs4Y5hvD1pRO7AFvY0zAjBAkDArRaMgyOthUQz/Jy\nKlF3psZHL492I1bT1JBOf1bHO6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfa1IX3Rg5zkvDXE4hQYbwGO9M4QwHwYDVR0j\nBBgwFoAU6FTbsdMazhDAtwqTIwMQJnDB+IIwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDTFScTGy2j\nCNpmiKfZliGpy4fxZISCfAuJC5mc7nMubwIgWHvtk+8h+7dEHMoTpi18G53mT5Dp\nRpxcenRKULPTM7Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARnO3bIYOdl8hcmQ8ksQ7av0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzc5ZTgwMy1lZDk2LTQ5MGUtYmNmOS0yMWYxZmZjZGFlNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJUiZiyime6OnEfUuIP8i2+XMLbCfPZBAi9tFYmTZYLwpB\nOSlXZZegUEFKfR60cPTZQ5R4+QxQMukRUoldzIa3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6FTbsdMazhDAtwqTIwMQJnDB\n+IIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIHDUGinN7cTbgWAGuNL9YDSLg0WyUSgyqKusevFvW9gAiATjK030RdM\nuQjdfipzhDxLhInMzuj/9u51/AWPMjn+dA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAcxOshMfS2n0/pgVKpOzxIdoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdkNzIwYWYtMjlmNC00ZjQxLTlkZTMtMTEzZWYyNzAzZGVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlY2RmZDli\nMi0xOTY0LTRlOTctYjA5Zi1mMzQ3MmYwZmM3ZmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASAFZA0h5Yco/f1gM/eSOKxaFhTje3sYgB+z0Q9mkqr0V5pmNY/pQQf\nbwgjXecibD7V+zgi0rfGyvO4RfXT58hto3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9rUhf\ndGDnOS8NcTiFBhvAY70zhDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBuOarRKueMTIIkGqz6wATEnmuDWh/c8WovfGeO1jiw+QIh\nAJZo8tejJ31/rmsrYEGrUIJKxkVC00+ZsJaDqhFfALei\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1721", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1721` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVpYNVgwkDGJ7ES0U8lpneloMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3MGQ3ODZmLTJjZTUtNDUzMi04OGViLWEyYTU5MTY5ZjY5MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ5NmQ3OTctMWEy\nZC00OGFiLWE2YjYtNmY3ZjNjOTM2OTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExCc6oyT58uOwGiswmsAgrQovaE2wKZxHKdIJZqZ998JwaBfytmvzBCYbMGVL\ntDlfXK+s9zAo74706nxdyYQtaaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw1iIgGhZ31+tcbD6FqPMPx9/+EAwHwYDVR0j\nBBgwFoAUTHp5vovGgKeKSpo/B1VrfHx6ZmQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCoHzh21spZ0CsPVzBe269BsZ2h5wk0RuMeETJ4IX+v6AIhALyVRPXYl60X\nxAXiLKftn2J5t+jFmNKgce9wW6Cmx1yT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXESod4T3ANv5ZJnK4nYbxy8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzBkNzg2Zi0yY2U1LTQ1MzItODhlYi1hMmE1OTE2OWY2OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTfMXTmKmBxeZ6X8Hy0R3PRsrUIpmr98mo2CNbYIa3LCWR\nuP0wefJ5V+DCCYRdh6nHuVfLafaJOiaQ7Ql7wwwQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTHp5vovGgKeKSpo/B1VrfHx6\nZmQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhRl/qT4PDvyFsiC3xYBPf0iMXPXmBhADeiMx5Ko+ZEAiEAmzgFMchg\nLv09ypKHS+NiXsEPSyDIF/a7JGEC2euZ2sA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZFbT7jQuzq25kTKvzdQBnrwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ5NmQ3OTctMWEyZC00OGFiLWE2YjYtNmY3ZjNjOTM2OTMxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZGYyYWU1\nYy1lNTc4LTRhZjItYmZiOC1hNzcyMDVhNzc4NzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARJtoLX8re3dDmg/sVBlzTybBaVIOxXQ/Ct3IZTp5IX+mddedcGHrcb\n4kBIh7vVa0FT9j4USJc2rZ1c98jtwBy4o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDWIiA\naFnfX61xsPoWo8w/H3/4QDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA1eLl4O6e0kjNwBP9pOPUhb/A0q0WK1MbPfH6O7SrjE8C\nIQDMh1Nfs7eJT564clyi+dChSfqMmBZrRSHxG6857qVslg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1722", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1722` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAaH5Zy5KcYxjYuORmHg5/vSIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlODM1MjgzLTlhNzAtNDVmYS1hOTczLWZlYTYxZDU4NTcyZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFiM2E0MDUtYTZi\nZS00MjkzLTgwMjAtZjlkMmMzNDczZmQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr7KWBnl7qw5e3bSQ21FPhYHVFNZf77r688ddnlXzD6HZNDcj9rNCBQGpBo//\nXW7rRjpeHKb+3qjJhisQ5FgqpaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJkX+OOmlWJOE+mCx1RzCKs05wgcwHwYDVR0j\nBBgwFoAUdgO8oowIb/zpJ+0aplSRK5UoZB0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDMGu6NRRQ4DcL7y43Exi5/c7C1epEynQUpaf7Jx9JEcAIhANWraAmEoE5i\n22v0L5byiPdn7YP8FaQjTI3g84teaPMw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWOrDQytMOoDRz0Nrewp8tonMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTgzNTI4My05YTcwLTQ1ZmEtYTk3My1mZWE2MWQ1ODU3MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3X5O5DlTRSNK6dG/jfqtu1VoJR/2N+zHnVTQYLuVpjYSR\n/51ktdX0qaTIi1R3dFtxSVBV6tvkMujNLz6ZGZugo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdgO8oowIb/zpJ+0aplSRK5Uo\nZB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOrosXb/vpz/RUgRRhhtKZn3GbGU1+V6y0LsmGCm5qyvAiABBou7pE/X\nYImd0gTY4+OqJsiEkawlHfICjy77Fh9Vmw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbTYyRj1/E/mSE02RTH637FCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFiM2E0MDUtYTZiZS00MjkzLTgwMjAtZjlkMmMzNDczZmQyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MzJlYzU3\nMi1lMDcyLTRmNzktODE0My0xYWM4MzBhZjMzYTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARS0JC/wRTSYxZHAJ2v/x11aaK1Sbo/shk9msr9z+zSCM5mczy8eoOq\nWuYiKlbp5UrIk7cHHJJOugj59Tw6Qb2mo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQmRf44\n6aVYk4T6YLHVHMIqzTnCBzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiA9oN3ZiRnILC77aEfMrX9DQWqJwV/dkTAmOtpV+TstNgIh\nAPCyN8Q7OvDgfOIXqcO8hIj8VYis7n968C+WY8D/gWmq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1723", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1723` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAetovbDwRpc9g+Y5G7lF28fFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwZmE4MmFjLTRlZjQtNDIyMi04NDZiLTMwNjZkNWFhNDVjZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYyY2EzZWEtZWMy\nMi00N2I1LTk5NDMtNzY0YTYwM2Y5ZjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7NnU7TF6NVz4xqYok1RXiEg+lQfPF9C49nOpQJwulxX6Np/PRlTBDniHS4Hi\nCrGXy2a2y9Ub6gho1XZ1K3HRE6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNTthu9UfLJany5wuvi1Z5zuSJv4wHwYDVR0j\nBBgwFoAU4xNj+wtUL4xwtMsZd76yOk3hRcswLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGxn\naDJoZuqHSf+A4G+KRYSmbJtyinbeDICwig8UnPZFAiEA+Kig99whylCesRIh78zi\nRPK3gOx8InYm79ReXtxzzeU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeYVmuORwjrlWmqJUlxwGGzRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGZhODJhYy00ZWY0LTQyMjItODQ2Yi0zMDY2ZDVhYTQ1Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPbjxzl9HmnOGbZtbthCykKoQn7QWk+ccq43HgkUZEzHLp\nMm3L0QNR7v3a9K5NXgUK6PmZA35kItCsCWiBb50go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4xNj+wtUL4xwtMsZd76yOk3h\nRcswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPnl6PDRrZABzJ2xYLzyUdrJ5gLHZvOruK3J4unXrOu7AiBs501C72Aa\nBIaDmqJsw5k2f/5RgyTN3yXNw1+K/NCk/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbYLXDcbD6OOMQ0h7FFG8/SGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYyY2EzZWEtZWMyMi00N2I1LTk5NDMtNzY0YTYwM2Y5ZjRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OWRlZjEx\nNi01MDlhLTRlODEtOWY5Yi0wMDE5ZGQyODdkOGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARstHVlWDlA4JC/4SoUV+XZodenDeScfOfT0YR6RrRGG3e8hDe2DW3P\nyFXyC1MoAJ57lGnEYs3cDZZ+kDm5jTmEo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ1O2G7\n1R8slqfLnC6+LVnnO5Im/jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEArZjjbTf7o0XU5gYkN+gS4mS9iL9b6lWteL7NufgvgL0C\nICdyzhxG8GNSTQ3vhYNXgCZbRq1REtTeH9WcnqCnD96G\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1724", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1724` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAemybDelz7xot+HZWZTEX3f4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMDk0YzJhLTY1MGQtNDgwMi1iMjZhLTk2OTZiMDExYjExNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjcxMDkwMGYtYTMy\nMi00MDZmLTg4YmItZjUwMmRlMmI5NjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfkBUQXvWv0yziiASXvGmb3+rSyRtv+5610LlodboRbPYVS9PsaodlzC3l+3w\n5oOA/e6tx3ojfJIUMoe8sXRgd6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM6MQFKao7OaaSBBvXiouPX48vuAwHwYDVR0j\nBBgwFoAUC7wp1rNMwzxvzZT105OQ69fcbrEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDha3Jh+J4GFruRujVq0J/nglYLmLKE96YxNJ6cvo2sYgIgFgzA\npfa6XncyGFV6fQjFw22BllQGLcoiureB+Pv0Wv8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVVDCU31nvXz99K2kvTpqDxnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTA5NGMyYS02NTBkLTQ4MDItYjI2YS05Njk2YjAxMWIxMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYyj5mSKfdpf1kS9hrsy0+lla+gf5H2N4zGFVoWMR8UHMs\npQL+t/kYv4KUG2bxaCTLGhlYpPdmjpYizYC94XdTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC7wp1rNMwzxvzZT105OQ69fc\nbrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSmsZh2O4XQ21oIFEt6t4QDUsbsuDORsSymhINKTYD2wCIQCuSlBb/ba0\nOcBCBW3OTEmoeLjYwDFIbF9zIe5vYJ3X6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAekyZmbqTijzNMorFX8dKDkDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjcxMDkwMGYtYTMyMi00MDZmLTg4YmItZjUwMmRlMmI5NjZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNGQyZTVk\nZC0xNDUxLTQ1YTEtYWE3OS05ZTJmZTU4YTM0MjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARK+rR3TpsB2mnLe0eBcTW9N6XPdiYuC6J/z0Rmefjs0I+ivstZZrna\nNdKHnmDlrTRcdrnGPMUzB6jq/QtmETWmo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzoxAU\npqjs5ppIEG9eKi49fjy+4DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAut+5ZfncHJYSV5i8gDHNnh2wOzZx3lyGu9jtN6jTSEYC\nIQCs9XiEFys1djpGA6kTIYmn+ExxP3/hcurvk8+UVn3jVg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1725", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1725` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAT+Gp1QSvcXqvcosmnzLlR+qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4MmJhYjRiLWNlMWMtNGU5Ni1iYmVjLTAyZTA5MWFlMDgzNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdhZGQ5NTMtMmEw\nMy00Y2E5LTlmNWQtMmJlYTI5YzE5MDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDvQi1tl9kbZdswLeN5z31maF4+KR4q5JSMT9B0w1iaPtUSu0go+rU8WspFWE\naUrElQRfRpuM4YMNeUWDNCfzkaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeQ/CjD3uvGJ6FFyQom0W3lqXKNwwHwYDVR0j\nBBgwFoAUdo/MZbjxP8ri09s5Xpoh4Wqb7UQwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFZ/3hi8+D7PHF1LgaNvZcL7oeMqz55kY/QQ7OOui1RWAiEAmSx8\nfH3BNXvdgTRq1R1wR0ADdTiC81pYMS1SAxBnsTI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbOKg/Ku+nedJoDbCb9x+/lwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODJiYWI0Yi1jZTFjLTRlOTYtYmJlYy0wMmUwOTFhZTA4MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYNlOnUOEf8TPOA3awQSeOOxZh6Vt+yN+LaQB4BcLFlL18\n+yhgy5N9o2R5WsdpQw/ooG4ej55Y1Gm1y0mb1rLJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdo/MZbjxP8ri09s5Xpoh4Wqb\n7UQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOFBpp3Z4eqaGOI8ZFzdu8wGSl66Y8csxXLic7BfxL8kAiBEMqizI3uB\nKASXVx8saD9UnsoQmCo8r+3Qu2m2jlxldA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAe7CN6wHTqDOZAvArsbrjB7WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdhZGQ5NTMtMmEwMy00Y2E5LTlmNWQtMmJlYTI5YzE5MDAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlODQ3Njcz\nZC0yZjgwLTRjY2MtOThiZC0wMWYzNzkyOGY5NDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATYTy0apZFzccQIFqVQEO2TBCZLpqYmuu1EgVtG0J1lI6cwmsk/eHMi\n3WbCl90XoO2bfXhOG0nwgDdH/+Nw9sX1o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5D8KM\nPe68YnoUXJCibRbeWpco3DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiByunKeFXprYQoPPhfyb0jtOdqtdDOd5ac7cKAvsvt0gwIh\nANj+pkL8OsP9JUS4U9WWfidAIrCbkwNqszkz8fftYJ01\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1726", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1726` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAU83ekb+PcodPuZx4SAjXpyqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYjFlNGI2LTM3MzctNDc2YS04OGQ4LTZmNzMzYTQ4NmEzMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTAxYTY4MWEtZDA4\nOC00ZDBlLTkyMTEtY2M1ZTA4NGVlN2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExwzyoAIja6v2Kd/V3J1vjZNPskST2G6u9KcPwF5T3a6jRZZm+VhS0LWOZ0mo\n/BOLYSd22WImJrzuZx71wN2x5KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFH0oDBqNS1gUf0jhi4pLbPq46VPiMB8GA1UdIwQY\nMBaAFEfFTBkW0SGEJTc0epWUBBbnXceAMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA0bZVFgex0qmbwoviu5hAnXDJoRn72rBDw\nPLngaXsIjwIgE7v3kq2y8C4pH7D2BaCd40Xwfgi4pwYQpFlHqovoP3k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT7HEniV9Ldogs8TeQxdkYFsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGIxZTRiNi0zNzM3LTQ3NmEtODhkOC02ZjczM2E0ODZhMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNNTt0phJ7Mep6EQHwstg8O1vmO+7IkW7UndnDom6YjzwW\nI6M8FYglQGhDKNdtqdJ0V3Iy2GcsnW/PoRtB00Dso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR8VMGRbRIYQlNzR6lZQEFudd\nx4AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYl1saD1eRf7DBp+RRgSl09aM4eGZFWS84weujZLXOlwCIQDR6C0r69Xk\n/pc8mtqORHWCZcRuArctzNxE/sk30VhELw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAWyziWlI4vRGA/H28/z9PEh0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTAxYTY4MWEtZDA4OC00ZDBlLTkyMTEtY2M1ZTA4NGVlN2NlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZDNhY2I4\nZS1kNmI2LTQzNDItYWExNi0yMGQ1ZDI4YjYyYjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARKSnu3cnJTHCXQbIUSlk2QRjATALWg/1R9HuqEqNVAJa9tTrmDUcnt\n7/egWnVKD0vucIeC/qjjItDsSawUOqMzo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9KAwa\njUtYFH9I4YuKS2z6uOlT4jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBOpnJCnCSiYzJQrlsoZcuZbo7s213abOX8XrqEesR8IQIg\nVlrlQtWJACQEbB/UQ0E13QCVFffu3pgyeY6/p7l6fO0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1727", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1727` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVXlYxN0usv+hFgSOCOogcj4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2Mzg4N2ZjLTM0MzktNDg5OS1iYmJmLTcyMDdlN2Q5ODhjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzI1MGIzOGYtYTYw\nNS00OTNhLTg0ZmUtZjg4M2Q1MzkzYTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXLNKdgtAjfQBOqyvzhGDUWwdmM4oBubWm5Pn3JcnI6lS20gjgvfOhiXQGB0J\nUicsT7NIA7PS9ApYDryb+HlWTqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFEQvtFqJGayFKKOf7/t/N3tgr2IwHwYDVR0j\nBBgwFoAU35JN5Y58xPNqP64wjJ3JTtKNg64wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOtHNoN2lcZZ\nHVQf1Q5sBnUVZtWf8eRx0NLuC9LfWtJPAiBEcybJ5/de7hhBSXpfBvhPXgB4pgWC\nv1Ctgx93Yd+gYg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS1B9JOBA+tjdWkZZaQReB59MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjM4ODdmYy0zNDM5LTQ4OTktYmJiZi03MjA3ZTdkOTg4YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk1JyOJU9rxhsvfcFipHc71CyRvFccU5eXDezu1qR2eR5h\nTvwxLTPHHJUVyb6JcQO8T9Zhn1vqhTYGxC+eMbaQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU35JN5Y58xPNqP64wjJ3JTtKN\ng64wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO3gNETXaTVbijd5ptDX4CUPAG4itbq+GEoaV6tLfCpVAiAt/QMl/s6k\nl7v/osryPl57WOxlAwbcR2aH6FvXb5Z2+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXh0qSeF8eqvp9zvyOCqu/BuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzI1MGIzOGYtYTYwNS00OTNhLTg0ZmUtZjg4M2Q1MzkzYTdmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiOWRiMWQ4\nZS0xNjc2LTQ3ZTYtYWRiNC00ZjE1ZmQxMTAxMjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATjgeELIV3SMUlTJgEHFBvDuDSX+zSaHYzSFomenZzrvFteNDUjii81\nHjhtTrAYs7hAYqfpyVP081Pn/RiWcuYlo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQURC+0\nWokZrIUoo5/v+383e2CvYjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBp+2jZUHPt+vCqBt6STBVywsPEkqd7dSewOZMLzNzpoAIh\nAIHEyQeFMJrZWWcaklKnDIGlcwBCj6jkhUXXGdVgFBUt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1728", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1728` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAYVKEaoygJKhjIVKsHs1WlryMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2NjhlNzQwLTU0ZmQtNDM4My04ZGY5LWY4MmU4NzM3MzVlZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTYzNzUzMjQtMjI4\nNy00NDE1LWFmNDEtODdlZDNiYWIxYzRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8tcZcjaNzapSp+/e82ABE4HZi2EqLKFOALsuKyl3/WtCAgUcydCeX44TsPb9\n6vFacIzxwIThkr3+W0SJeMBGj6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkwmBS4TmKle3QYwdBURsvONXXWAwHwYDVR0j\nBBgwFoAUJWFHlalJhHnYbjc7ekPA4lxitTEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMQuYQaNbNzp\nK+ePRx1IB3Ec9VgnHQaFmdxeKY7cKH+kAiEAr/N1MKppZDgJJjR2bkkf3i5laTek\n9z1UKP6Jlltgmms=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbf2baRi1MHG7c13N4PFyIRXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjY4ZTc0MC01NGZkLTQzODMtOGRmOS1mODJlODczNzM1ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkESUlVto6/ui8VLfpAXEXcfmC3SfGXmKehTWNXzPXRLp3\nFJxmqhAi/lxSaixsQUPONmcZt56x4HN7svIwYSF6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJWFHlalJhHnYbjc7ekPA4lxi\ntTEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPTgkHImOrNTzAe2kAuv3sSYyxUtdwnlXt86wEHExLCnAiBoBazwbjdn\nFJJAf2WAVrEOrUZrNeIQ7/il1Mrge5/7jg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASLVGG5+mrDvGHEZWNUxEeXIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTYzNzUzMjQtMjI4Ny00NDE1LWFmNDEtODdlZDNiYWIxYzRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYTgzZGMy\nNS03MTU3LTQ0MDMtODdlZi1jNzAxYmNiZGY4YmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASDIfkA5hH8MlheILWaI4l3nyAGiFWFoN6Tr4WNrAf+Tdwip8JQjHiY\n6ebHecl8qUHId67VBitJpG0Cf8cF6k9mo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSTCYFL\nhOYqV7dBjB0FRGy841ddYDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA9mnCeilkyo+oZUTM6LeyNgmEPuZkHbNkm1peZbv2hYYC\nIQDZDJr6750IPVn6cIaMP9osDEJGjBOfgSd7rYpg6HWQQg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1729", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1729` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYmliNs9Z9amPPVSZs8sPg0uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0NWRkMTQ4LTY1Y2QtNGQ0OC1iYjUwLWY4ZjEzNWQzMWMxNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFlODg5MzQtYzZj\nZC00OTAyLWJhMTEtZTBkY2Y2MzkwNGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAzy44xRHZ30joK8T9nwxq35o4sdnGMupzJTSC7MqZkZ0KyCrWbfC9JAPxagy\nZDMkLP/VSvIwiEgWa6lNZCyIbqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/TqwoOO+2cSCSzVKuSYxxC0se4QwHwYDVR0j\nBBgwFoAUBnw/StQsD5M6kZy+tbHn/GnjmwUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFBw09I7CRWR\nQ/ds1Ebfmxha6eHEAcw20dHUovOVSxjTAiBq+11QEObrZnDSnAdvxfVx7ZqREQsf\nOTQLiH1h6h6vhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQXM6p7cD0cZC3nYkvgKamCBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDVkZDE0OC02NWNkLTRkNDgtYmI1MC1mOGYxMzVkMzFjMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9SQbhfpoVdi+kiOx9ZaSsoK49a52FPG2R6VEE5rI0wTIN\nTvd7oApJue/gsKWB43DEOYK999OGv0oQgNh+SCgWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBnw/StQsD5M6kZy+tbHn/Gnj\nmwUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALrV6hpgI1UGSyLePXe/7C2YRzRhRqgS9o3tV7alAFuNAiEArZY/Nb2R\nOyI4kEWFhS6ZOwJCso+lsEcPd59PlioqEBg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAX73QMVVHP15S47HNB64d3wDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFlODg5MzQtYzZjZC00OTAyLWJhMTEtZTBkY2Y2MzkwNGE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YjU2Y2U0\nYS1mZGYyLTQzZGItOWQ5MS0zMTBhNjYwNjM5ODYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASzo+9q10Flnr7KlAuFlZ0Z/aKrtk+Nk8ujQiuQo2sSZ4j7Y0eZIsaN\nfEN8YbgurQE6H/aXSLtJ8Gvt78jn04sio3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT9OrCg\n477ZxIJLNUq5JjHELSx7hDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBXO+/fzNYv1zqt5Vl9P9n6OaA2mtJGnn9YmAzL/gwdDwIh\nAMLh2E08T/xtz2pYqldUfNLXZ+ljuiqmRybAICjL2MSD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1730", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1730` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAV3+CFPBoHiB6YWAA/fb4oLiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxNTk1ODI0LTExZjctNDk3MC04NTNiLWQzOTBhOGVjOGE0OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA1ODNmZDUtYzQ5\nMS00N2ZmLTgyYjMtZjU3ZmIxNTc2ZTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERTDgP6oi+eUDQZDCTGYzvksVL1f/VniRSKrjm46KJbsLCcKoTVcM6fi9K2Bh\nIrNwsJx9bA1inmIxDoU83QxslqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdKQ2tx4k2OOvBVO85ewcicQAelswHwYDVR0j\nBBgwFoAUGEDwAm3i6EX6OYtXjIQ694Om8NswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDTxcjggKrfrD8HCulyycESmWw9PbPzBcFjA04JKQdnrwIhAM/svl8evMxR\n3WT3T7Kwy5z1f/ku9otkwOj9Z15BIRPo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAad/les+HczgMvJNM8/MAhp3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTU5NTgyNC0xMWY3LTQ5NzAtODUzYi1kMzkwYThlYzhhNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASunIeKUMb1bf8cIJJ2M99GEtHXHqf4j9L2GIpScfu/A2ff\njzWWPKkW7xMtdp6Aso1aE/IJOQTpPIX/zaidqZL6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGEDwAm3i6EX6OYtXjIQ694Om\n8NswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIvvm3pX0zMTv8aJUk7uJbpjYBoUJC/s9BUeHoekqaDCAiBvv2Qp/o5l\nreRtzfXDCXG1QEFURyTH3kVzBprS07f1HQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISATd7oQD30xemkDjXkJD+jiApMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA1ODNmZDUtYzQ5MS00N2ZmLTgyYjMtZjU3ZmIxNTc2ZTQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZjJlMTdh\nOS1iZjQ4LTRlNTUtYmZlNS01N2E1YmEyZjJlNTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARhf3bF9XQCXbCkOw21qTJftgAm7g8mAWd1umXb0fHbrKmkhRJ6saNl\nhh7H5111BQRk3ziGZYrTaSz0XI9uLORYo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0pDa3\nHiTY468FU7zl7ByJxAB6WzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiAVT4CyCZBev7rINKSqjZEhO/EbtTrG2Ovv+vVp2A564wIg\nBDn78MA8MiySftMWJtFY09gpjj5wcN/f6sBu8H8hGrU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1731", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1731` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATD947H6jBx5DXsGFEHX2PdtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMjQyZGU4LWViZDctNDQxMS1hNDA0LWNhYWZjYWNhMDc2MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA4NTBhZDQtMmMy\nMC00ZDI4LTgwNmEtMzAwNDkyZDRkZTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8xogM0KKQTEK/U0RxwJx5OS8TqNhKutXrW03X16bJJopptlYTmf857A6HAKt\nLBqvJowxD0DTbkBLxalkjef9GaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxxUuNREvymrmH99/BPv8Hk6kJN4wHwYDVR0j\nBBgwFoAUZBp2/EYUYxKiNo6wueh3wkyD9tgwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHdeZoq/hS/+Crel6B38Jq0Y+VBKYLN/NEi/NzPEyrCWAiBbp++bxzd43cNn\n5ZDSPMO78Ydw/sF6agWNKytAQJKMWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVajFoki/1+wE+4FMfzP+AqfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjI0MmRlOC1lYmQ3LTQ0MTEtYTQwNC1jYWFmY2FjYTA3NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT88XucUjnR/ZzKWadYrnryUZB3pQHK403R2Rng3rg8CbM+\nH7cHtRloXRhgFObwXcXZ2sYkxAnBESphhK26huUco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZBp2/EYUYxKiNo6wueh3wkyD\n9tgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIhMBZuRUA67ltZD7LniCCTNuRbtNfBUAATjnrnJYXzmAiASWs2iANuR\n02IczXsj+S3NjhaAwf+4LJPA8/Xr7d/PMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARnv4daNn6v9z9FUhToiF+MXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA4NTBhZDQtMmMyMC00ZDI4LTgwNmEtMzAwNDkyZDRkZTUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0YTI2ZTVh\nOS1iYzc4LTQyYTItODhkZi02MmU4MjFmNGRhOTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASsFFO37FUzAsJN+F1l5YI/tNwFZCQH/i9sQEuKPrigO7fMXKFb8VDU\nsAzUOtSmVOeAxt2m6n7Wqh+F1lD8gfPVo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTHFS41\nES/KauYf338E+/weTqQk3jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiAr/XXei7yH/HMw2pvUcggaw0YWVuLfEdeNeTL+3Dh8CgIg\nbhbnlIQAGqLB7KmD6Bnjb2oFZn0WJKZCHHc4+Pj708w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1732", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1732` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAQfY/owRPvEejPp0g/2qMQ1iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3OGM5YjdiLTQ5YmQtNDI1OC1hZGU5LTA5OGRhNjdiMTY2MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDkzMWM3MmYtNzky\nYS00YzFlLThlMjktYzQ5MzRiYjZiZWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX8KyMgzrkQagJ0y9xsonBHu+bpjedCTfbqW9cjLTGHTWIVN416rFWmp/SYHJ\nlwR+GMc/jAwemh9L1eS0Hs2hUKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDOszvruF1pgBsYyXtURHKxjb6OMwHwYDVR0j\nBBgwFoAU6V0hxxnR7zlIxxisPqRcuLdx6mkwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDU\ngKrxg8gwFcH03R+0Fx0Tt+PJ63ycxlmekEttGuKVzgIhAKMqgSqlNdmrebGDCNCD\nhPt/zSUumZc5e/0Es0NKnmwJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb2oFgw+l/i9g2y/q3kAhGk9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzhjOWI3Yi00OWJkLTQyNTgtYWRlOS0wOThkYTY3YjE2NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQumkQ7VcLRlUNs2MMj9TWQCTWRZonB2zgEyDjwIohqhZew\nGUk42v2mjn4Dy5UOaFge5ztZClT/unH+J+tlPX/co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6V0hxxnR7zlIxxisPqRcuLdx\n6mkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK67UTnTYlDjVLt1g/e7mDBC2X7wXmlD24/MrygxzVu/AiBK1ioE1obq\nGAEom4KERbDgAy9/8xfVsBAi/TkCI6wMvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAePb96ePZiew5EO7EF7UFCaHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDkzMWM3MmYtNzkyYS00YzFlLThlMjktYzQ5MzRiYjZiZWRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNWM4NDcy\nYi0zNDk5LTRiYWQtYmZmOC0xOWZlZjQ0ZDA1MzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQiWWdzIrbi7WobhSo4UuNDStWuxOYgQAoGt19WodMsEQzF5FxCELwo\nrBo+86iNRs7ba8bC2BmCOize5UPktMO/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQM6zO+\nu4XWmAGxjJe1REcrGNvo4zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBuRdFA90A6lOU68dOV+y26S++8W9w0YE/Ow49k03CGvQIg\nOC+qF+f69AckPXkxRi8FH47DThR/l/4rl4fmwY9Oa6c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1733", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1733` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUigTNGTfwuid4zQhFrkbaczMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmYTJjZjcyLTMzNzUtNDg1YS1hNTdmLTk1YjEzZjU5MTEzNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJhMGI1ZjQtMTcw\nYS00ZDMzLTk0NzQtMjIzYzdmY2I2MGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1rTpqddPL3TcBUjwkLv+oAKEmnd/e5Ac9lnxMmXM1YE6DfRDTgH+Dnp7SXPv\n2z3Xz14y+PgaCbhOCvyrIi+/GqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfmyPlnCpDrDnNtLeQMJqeU05rvgwHwYDVR0j\nBBgwFoAUn3odlbh5bu0IAU1CXAZqSE6iqCswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCFa75fPZOGGeXEL4+1jBP2w7lbA6A/eThM+L4JQ5GkcAIhAJCg\n0dGFn/eOasKFRz8OeGlin2qaoFOvS4afaqK1NM8O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYcr9ugZ5gP/m57sBeIughClMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmEyY2Y3Mi0zMzc1LTQ4NWEtYTU3Zi05NWIxM2Y1OTExMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmlT7B/PselS2s5aAvvwbOUQtSm7AHGqpE1OcFbpeSwLNy\n0S8Dyez/WUvxR9rTJH+NKpBqGo6bE3WKXP19N5gSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn3odlbh5bu0IAU1CXAZqSE6i\nqCswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOyiW8MW9HZKOW2zUl9kVpIEuDBYYWsK/zo6/yqpT2XACIDmJNTJPoxII\nfDP4+4yvNQd4orzIqxYMHHSL5Dg7KG70\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAbs/N+r3ETO8hZbj6LXISlq+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJhMGI1ZjQtMTcwYS00ZDMzLTk0NzQtMjIzYzdmY2I2MGVmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYWNjMTll\nMi1iMDJiLTRlODUtOGIwMS1hODc2MTZhYmNmNTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASPisGDvTFoQbwpyBtUkUWgYOHnicxcDM1t9lT8T8ENGT/QtBjPdJbF\nUuMiuVSGKSmVYj0GHfupyJ3Zuf/s0rKno3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+bI+W\ncKkOsOc20t5Awmp5TTmu+DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAzJKymA/Ypbf37Kn5UOU4MME6f3NeGe9WESvEbh7XtfoC\nIQCuI8KvakywCGydhMxYfG1OeJ8fa8UlA+1wbaklBvrALA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1734", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1734` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAU1QsRB0skOtesPQXj65DlO8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5YzkwYTM5LTdjNTItNDVkZi1iMTkwLWU0Yzk4Y2ExM2Q2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJjZTcyYWItMzMx\nOS00ZjI3LWIzYmQtOTJjZWJjNWI1OWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ7NhkxizhFsf6OVwUTAI9Y6Wig0AsNzbX6qQbOy11NCU5hengjaOyhdWVyBO\nrru/R27q4Jor2ODOl3KCvB+D6KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrS3nXBP2sl8uOndkqZiFX6Ukl0EwHwYDVR0j\nBBgwFoAULnsRznFe+MAORd2YB/EdAPHcLpYwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIGD/GhDpesFVB+54P20a6s21jONy6a9G/Al4HztCqfaAAiEAs9TA\nMdiaDna8vWp5SbECCu2meYNZp6EI+dql1x5xC+U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ75lbYx8WGDmYF5GBPFtFWYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOWM5MGEzOS03YzUyLTQ1ZGYtYjE5MC1lNGM5OGNhMTNkNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5SKW5Gtq0maxuvyoLx4L/WhkQpI3wRheQr5bDc1JfXHTv\no7fqV2gQCWX9cIHG/29SpU5lLYOoTUiuvj/Yyj2oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULnsRznFe+MAORd2YB/EdAPHc\nLpYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOjDjAj3s+L0galUmCrwWrrh1qII8jw4Ng8U5ffPatuwAiEA6PrxOUy2\nmqbNglZq730Os7UN7WXmsRho2qqN0qg3gVw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAS5e/qAjF3cy0pp/e2YacK8YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJjZTcyYWItMzMxOS00ZjI3LWIzYmQtOTJjZWJjNWI1OWU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNDY4Nzgy\nMy05ZDBhLTRlYWMtOGM1ZS00NGU4NjFlNGU2MDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARsZDhr2x9GekfKGFJ+ryDCUzIzVR7dRK0+ZRg3x8ajMDDb+oHabYWk\nnf0eJ01mFl8QoMW2Cb4oHHCNeulEDwqwo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBStLedc\nE/ayXy46d2SpmIVfpSSXQTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiB2lcU+tfDR8ao7dtuGV3FQpgFpo7fb/USgRI4FhG6k3AIg\nEv6pKlVKh6nRND02G0juW6jsysC3hctDSbayR6cMTXg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1735", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1735` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAWkFaW12xdVkPQ6sMvDZWpMxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2NjVkZWU3LWIwOGItNGRiYi1iNTQyLTU3YWY4MGRiNjdkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGUyYmMyYzEtNmI3\nOS00OWY3LWIwNDctYzRjY2VjMDc3NTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdkevhnJS+TOnGbgzCni74FUuUHaNbcrylPIhccAPR7NdYBBkhYT9hm+512e5\nmkbzr5GTUyEXpqhvPYOvcABUrqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTfCJC7tAmXLhf8O+oceYSk4W5V5DAfBgNVHSME\nGDAWgBS/T8552NySHPCyXwnWNXovHqSqkDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD+lI2CDEUfetT3UGlJpfHGcN+PxKyL\noInbUrFtlwDK2QIhAIigxmIKZSpQnsVkrqIPi3l+2tPrtAvU8dMWkEw+B7eC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdXLL/WNld/armCcI/Rs2Q5NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjY1ZGVlNy1iMDhiLTRkYmItYjU0Mi01N2FmODBkYjY3ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2BlP17PBEl5de/ORd+H4bw9baKtJLggHH/I5qtB6TCcWE\nL/eHEtkcfH5TqPSEOdPeFZKEeHUgASBVcXM21zURo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv0/Oedjckhzwsl8J1jV6Lx6k\nqpAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJyquAqqwjVjfKnCLtmP9/MSsPOvAQUlEPXeOd81p7a4AiBpdmtizHcd\naJtwd2hWqg/CYjbqqxU02W9mQZ0dJAnrXQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZTs/G8GJwbDL8qdLik3650WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGUyYmMyYzEtNmI3OS00OWY3LWIwNDctYzRjY2VjMDc3NTVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OWQ3YTVk\nZC0zNWVkLTQ4ZjMtODJhMS02ZGRhOWZhZTY5NDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARcxXRy06EjkMCo3Pzv7YF6/N9IVQ463L9v0Vhm4/IMRRGQd3sldn5Q\ngK54I2Q4W9DfOynY4l9NyUgrOfPXY+yko3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfCJC7\ntAmXLhf8O+oceYSk4W5V5DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAyIicFIFAUqO90jTt0JNxDUU23G0JNOTUYOAMn5XkV2kC\nIGSiCVv53A0jZj9vIdzMeFvnW8cpxbv7h2jtPv6qpHri\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1736", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1736` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcBcI4K3FCq9rbWs/zHjUtZRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZjQ1NGJmLTFkY2YtNDU3ZS05Y2Q5LTdlZjkyOTYzMmQ1NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTczNjE5NjQtMmJk\nZi00MWM1LThmM2QtNDViYWFhNDdlZmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPzjI9fW/sD8HT1ahA7qW5a5VhhyN8JkijO+aGO0tI+XczcAkXku8ol0IfK1Q\nR3lc7UIFat61eG9w5cxpzunVUaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyv/mBE9ys2SGl5GdF+X4sjI8WucwHwYDVR0j\nBBgwFoAUyJzGVTPfYjdLN+qfsXAjD8CrYzMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHvevQqpOueD\n8SukpUoazT1zEzxmsy51IC1TyOxTTEtBAiEAvP2+/xBglMz89purRLf/wGsMajbr\n0qV4QajxlT0pmOA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe3cM/Vdg18FRKhqafXtCk1oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWY0NTRiZi0xZGNmLTQ1N2UtOWNkOS03ZWY5Mjk2MzJkNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpH5B5RqgjDakg5TSBV0vWQ1lXthJhv2SFhcsNB1dRniUk\nMlkz/RiCGHitiqDJDLc9FdynjLp0KDY3hihzkhYRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyJzGVTPfYjdLN+qfsXAjD8Cr\nYzMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKch2u3ZBhTXqcRg/tKsLFkAthY0S2p4awZdIwwLLQGHAiEAxxl2M6Q2\nKaUxEArMS3bliwoOYCCery7ib94R1S6mPX4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdp3i/nMJoKPjxU14oI438mxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTczNjE5NjQtMmJkZi00MWM1LThmM2QtNDViYWFhNDdlZmNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNGJhMDUy\nYy04YmVkLTRkMGUtYWEzNi01OGRlNjI3MGRjNDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATBCQNPv/UNEYRApMA5m/ou25Q13VdGIT7ur5mIo6EyKJAiBTw9U3MG\nyUBVpSkaDh9Vneym/+jTAqLazT/lmBMqo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTK/+YE\nT3KzZIaXkZ0X5fiyMjxa5zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAuq9lUnQcQMrsM1yRolD6RAjty5LpLpZQmDNYLSHD08AIh\nAMH5XxhW22Dx97IAkfryeZTtEM1O27YoDzO74bzGlKVE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1737", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1737` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAUC0DneOeI9fDWVE92RA9wqDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkNzc1NTY5LTUxYjEtNDM1OS1hZWY1LWE0OWQxZDk0MmZjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI0N2NlMGUtOWIy\nYS00NjgwLTlkNTctM2RiYTQ4ODFkMjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOiJB4SWMj2tzw5MauRg4YILlfv2GZJtecJex7vrsI4idyX3scXOG/NqbcKb/\n1MgaOhRnk31jObac6+TFjs8QwKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHpnZpm2v9TdnxlNwAsd5zD34Av8wHwYDVR0j\nBBgwFoAU5zC5ywEl5gSjmHh109zcFECN2fgwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAlSyMIyuJju\n3La2AKVaalRlkZxmnEvPwP2lsSIirWAEAiB07lAdoE8INcy1HhAjUyOn4UQ+ywBz\nhwn2uAXZc2KsKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY0yGkUdEWCxsxKQAs/KKBTtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDc3NTU2OS01MWIxLTQzNTktYWVmNS1hNDlkMWQ5NDJmYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiqLda3J87J10vhYOTf3UY310XHtwTmU7Q+kCSRS9b/RNs\nyslRVdLawT+8AUscHmK/RMneRSqf9Bluup+4RmIKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5zC5ywEl5gSjmHh109zcFECN\n2fgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUpibycbhxEuDbrnjnt1bAP5EDqXKiDp8zf3cwwq3JhcCIQDZ/F5NNpzC\np7lgwLUccmmXMcGRG7Ibm/GDkAOx1f0zUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAWAceOiplbAsMQMy24I2MOYCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI0N2NlMGUtOWIyYS00NjgwLTlkNTctM2RiYTQ4ODFkMjAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMzA3Y2Vh\nYS1iNzZjLTQ2NzMtOGI2Yi02NjdjYmViY2VmYTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAScPvgjFqCSiw3BEEB/pkCsRUVLd0euvaD/mUeEx7SOBxnPUWq2Tn2w\nt4vs+c36KuLMozgY+TKkRzgaRcsvIXtKo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQemdmm\nba/1N2fGU3ACx3nMPfgC/zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAvnplGfhJT9WWd4VJwrzkyPhay8Ao8DyC0exqXOZ+zK8C\nIQCJQSGwDlSy1vwDpOhX8cgBx6WTLFRLo2/LO8Cr1uov8A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1738", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1738` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAfDIwBt5h00+nPuF73ELlzuBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzMzVkZGMyLTA0NTAtNDZkYi1iNGI2LTYzMGIyOWRmZGJjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJlMTVlNWItYzhh\nNi00ODkwLWFhY2QtOTMzMzNkMDc3NzY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyPUE/aWj1O3Zu5yjL+W4317h0VbGdtuBoXdlnLyrVe7HXhioYO0xtXW8Ax5n\nhpMCvqQz4DKKaVBm4m4ZnfYzfqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5AO7RDmDbLoi1U1Z1dQuy028wwIwHwYDVR0j\nBBgwFoAUKxm2RmcP3iXbMZdkC75eX+wy23IwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBLdTF3Qh+W\nPJXQumAY/VX6Zv6+HZoBSSGsG0b8zz76ZAIgfbpPREPmTJtsf206YR8AvVbWAtvk\nLRwJyMXbpla6yqI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYU3L7vWNweruWXIZhFOQSNRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzM1ZGRjMi0wNDUwLTQ2ZGItYjRiNi02MzBiMjlkZmRiY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvxrS0gcC+ku3a/J9CowYwK6bBHmEwlqspudp227NclfAF\nTBeKsUVJ5WB34XwuybzK4tvbxOR6u8N47WujLOD9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKxm2RmcP3iXbMZdkC75eX+wy\n23IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJb8i36P8q50RQTzDHPOclCoGf/8z1AkMuVeOUq5D/UcCIBcCc9jlqSks\nwu8wox02WasyaymBWDOXZxbAOKg2UpBX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZ/t0xIggSmw/yioOYdbYKp+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJlMTVlNWItYzhhNi00ODkwLWFhY2QtOTMzMzNkMDc3NzY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYzYwZDg0\nNi1kY2YzLTRjMzAtYTFjNy0xZDgzNDk3NmEzYjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASv0dwaHLAccIRoh+7OlVbHiw+qTNjgJjRQ5exOcAkm0g3M1TNGTSuv\nLKyepQ1SbyNxD72fTCyPwWZ8A936N1HYo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTkA7tE\nOYNsuiLVTVnV1C7LTbzDAjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAwrMeS4qf0AFCYQMdHFneq4pe3hBO4B2taYravbsav3MC\nIG5MMCPmzIimnhWd5qmox7Lxi6KY7U7u3CPJEKlV1ZI3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1739", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1739` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAXbMiVerCnDKQwWsKq+HgcibMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxNjY4ZjFhLWM1MzItNGJkNy05NjMyLTRiNGVkNTAxYTNiMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVlMjNiOGUtYTkw\nYy00N2FiLTk4MDUtY2RkYTk5ZjllNjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgB2vrJyVHPCjguHaVGqtYCliqF/ttrS9eSe5MN3dAjyGDyurnpGrqKSBbEvz\nci0tRYMOAdtXAjeJaa/NrldSZ6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8EgRbWiVvu0SdtEJFLMqFk3D2F8wHwYDVR0j\nBBgwFoAU+bPDa4zMismAT9xmKZI7o89nygAwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAi2kHseBt1Np4g6PaVNuwmZywjzOP50keJ78WIQxoEy4CIQDh27unnl7n\nSSGVaDcEEt69eX1XMp0fVksW5OtiLKBo7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc1EL1a6XAa2a3fe/r2/u6SZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTY2OGYxYS1jNTMyLTRiZDctOTYzMi00YjRlZDUwMWEzYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQc2VgJCsROQxadM8VEaiT2nkDPWXInmM6jzP0rocAq6x3G\n0w3krEVmIDehom5d19O025Kec07K0qvg/1/paAqLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+bPDa4zMismAT9xmKZI7o89n\nygAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMsEPZ/+TzDMfc1gaqpfTEEaMxsAXofQJG2oAOiwrU/vAiBo43HqyHxo\nZYpSnPjHHRdR4qeIzDGGAlYR0TKFhH2nBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQ/Vvnmrg/IZV7NUGzyllI3MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVlMjNiOGUtYTkwYy00N2FiLTk4MDUtY2RkYTk5ZjllNjAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNTU2ZTMw\nYi00ZjdiLTRmNmYtYTZmMC0zYzU2NTQ2ZmM5NzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQzwzrdCYtB/MekN2PzUHCQQIH+cGtYCnyToNDAkVUI+SuxkI1absER\n5Lbdl59hfpnF6HRRxHeXQoQS17pp33Hoo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTwSBFt\naJW+7RJ20QkUsyoWTcPYXzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBSJ4COU0YhLP1TM4AgqjvY9YW8qV27vaK2JXLi8ADwVgIh\nAOlV7DBZSwRCnwqoSlrOl+wmeu4SNJX2rnX8R71TAZvl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1740", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1740` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfSDHI+TjStKYirQFvuyp2zKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzZjdiYjkxLWZiMjQtNGI1Yi1hYjFkLTgwZTFkYzI2NmExZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJhZTRjY2YtZmFi\nMS00MmI2LTkwODktOTIwNDBlMmZlMzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExuGE9W+bBptX+cUSPQfaVbnPk3TYRDYVMkucNIhVkkXNXYrFJgkL+z2NA64w\nstkgeOukcyGNpcL2OvTA+i/SbqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfn2CvGGqsGIh7ikp+IFhBIitZVMwHwYDVR0j\nBBgwFoAUiEcMJ3sZmUhEJgCrFyjGhFXDyVQwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBlSmhddFvbkqoV81OEik9JpuXzj45IIYAy7KvnSH8mFwIhAJmMYuLEafVk\n602bpmKOTWKV6NvrSzZx8qVk6j9278eF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWQ1z16bXI+OcjHI+PiFbdQqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2Y3YmI5MS1mYjI0LTRiNWItYWIxZC04MGUxZGMyNjZhMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsNpEy73V4s6VFoC+9ROhICvEgMnpzRbgLsxecKr93gjvm\ntjcV4vR7FDUnOcBswS1j/Jws+B96ifCXQCOe5VpBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiEcMJ3sZmUhEJgCrFyjGhFXD\nyVQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIh05CxPOeiw0xDwBqUp8Nyl7N0sbZpLvKVAmkYaqL7fAiEAsYCD2uJJ\nkdk7OIrP7wohFG7JGyniaB8xz5MyynaVrpw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZO49/35Y3rYrxzQRY8nzPOxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJhZTRjY2YtZmFiMS00MmI2LTkwODktOTIwNDBlMmZlMzI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYzdlNzE3\nZC05NDYzLTQ2OGMtODM0YS1kNzY3YWRjNmFmMjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ+M8Fvwx9nPiaQlI2F9FfyRKhahHSQGYhGnPiKqADFOMzvuYWy6YAq\nlFxNtI+R4ZHSwOz7SQFARc+FlLbztlXbo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+fYK8\nYaqwYiHuKSn4gWEEiK1lUzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiB3t2MhjGLUbXvhJ4SGxP2LLuw8jzqzLqcYNRngiA7DfgIh\nAOi5YU9RkjD1uK+njTGa1L35GPFYWXOAhPHXpxf6szEJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1741", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1741` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAU/QfQmoMZQqGcCbPDzt0M26MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMTNkYjJjLWQ5ODgtNDQ4My1hY2FiLWE3YjcwZTk3MmRhNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRmYjcyNjEtMDdl\nMC00MDlhLTg3OTAtNGQ2MThjZmI2NTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdM5s+N3ceexowIGD2GeBvIFIlY1vmTvnaDUChGTrno41FfwLnYOQ6xy5N6XW\nR9slV9XOltI6PmTG8uCgZRUwq6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9WirQS6YxfovsQMuvecI1Omyo/MwHwYDVR0j\nBBgwFoAUN4tfI4bbs1G+qYlX93fipj6FzMwwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAB\njQpVk46rqbnrqdna7emZl1CjeRCecylPdHp41wjhDgIhAJ76m4eQHb80LDRbr6M6\nQ4QSbDjafxdML8m1VVVbRFu5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcLvT2jDWjBMp1K8DnG4+aQBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzEzZGIyYy1kOTg4LTQ0ODMtYWNhYi1hN2I3MGU5NzJkYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+x7ScjQdNCdP2cmdbvJEYPjmU3XgT+UoWmwe+7OojAWaR\ncvtR1+sLmGUcSic7Ma8wI7lU4hDRiGflitNMdq73o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN4tfI4bbs1G+qYlX93fipj6F\nzMwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSq2yC5THK4XgX3GEncbuONEEVA+PRw1p4sEjBThMkTcCIGzVeVTEdY3m\nhdegbJ6qAaQC3aZGjLSmLUN+ffYCX5AA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZ0Wucy8JA26n+evmLAGyRAaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRmYjcyNjEtMDdlMC00MDlhLTg3OTAtNGQ2MThjZmI2NTIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYjJjNDM0\nNi01YmQ3LTQyYzEtODQ0Ny0xZGE5MzczMzk4NTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASbhWqbcYqVTWOVj7DTdmX92JA5scko5RawpW07sKMzNbpk2g/sswAL\nUMPJXvllV2ic5btpCtmVqUma+sUyarmRo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1aKtB\nLpjF+i+xAy695wjU6bKj8zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAiURNUJuq29ISA6u+kDzolB8kxuhjTDkAUHUEvXA+D2UC\nID7EueVFMPQt0HYJfj1wQmDq1Djgax+452qIZyuGx3Uh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1742", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1742` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAectfXvC4m6X7NVxrX7jZQ9XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZmY5MGYxLTliMjEtNDBiZS04NDAwLTliZTkyNjJiYTQyYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGRkZmQ0ZjItYWIy\nYS00ZmFlLWFkM2MtNTJjMjU1ZDI2MDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnbnIwSA+PUFXsETiwVFwbKobZZkD2sgHtoi5mi03KBWZW0R7t+HL8Ja9QBHb\nP4cqe+ifbZc/bHDTNBq4FuRHwqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUecpqCmEl5l/CPYxr8+m4z5pkJHMwHwYDVR0j\nBBgwFoAUKFNXQI2WFOFWUgno1DM0I9JnLqYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiARmB5LpwC3EKuhGXJMLWi6i11q3jA/lMPEe+CatQ3rGQIhAI6B\nt4eCcpik1qtCktUhlWOibFdxMhDff1eMpC873rSp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXqxs3fop+n6vUrtq/NklbZeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWZmOTBmMS05YjIxLTQwYmUtODQwMC05YmU5MjYyYmE0MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASz44V91pZYc+rSfG1Tm3lmspA+ZB9gRsMEbOvdehVHIM4s\nO2otSblQLv0FsIvl+KOxIX87H0GKfkzhtTL7d1WKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKFNXQI2WFOFWUgno1DM0I9Jn\nLqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIwEfLodhx92x7J3AmK5IdIzyI7u8kdpqP7rk83iNGCMAiBa0CTBK433\ntPlnWn8Oi1xqXEgQ0qWKUiwEI8naagKFkA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAfxc8tl7dKrHfXcpsBdDkWYWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGRkZmQ0ZjItYWIyYS00ZmFlLWFkM2MtNTJjMjU1ZDI2MDE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNWM2MTk4\nZS03MmI0LTRhNjYtOGYzZC1mMTM0MTk4M2UwNTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASoa9CjDI1tAT09K4t9jJum4OFZmrfaJ+jMwNVfNX6eQ4l1NEV8wf5K\nKNJkSVy2TeilnWYS3nVtc152dwmvoo6ao3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5ymoK\nYSXmX8I9jGvz6bjPmmQkczAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAvNfFOtrVbZUUXcYnfrWn7M7HCGX8rzQKPlLD9XlL0jUC\nIQCzSoGund7IWG+U98SYS4I+rn3fEByQVKH8g0u7GUNXug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1743", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1743` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYycSpJkK7uUr2zPWZYSkzAJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNWU5MTA0LThhODgtNDJhNi1hY2I1LTBiYTc0NDYwZDgzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU5NjM1YzEtYjMw\nMi00MWIyLWE0MjUtOWRmMTc4ZmRiM2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaThP2nF96/LPT2C18HO7G3k9b6gPn4lI1P3PReGqXdQ+yfDPhOKOHSSw9+UH\nqnShyJx5Su8TMwWRN82froiVVqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMBeQ/yL0ld3AHZ0qW3YE7bilZ80wHwYDVR0j\nBBgwFoAUpmrBuLnDBvrRvd1z9jjDyVIyiKwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBEpICcPOlBJg2/+VOcJXhF2MuVzvV92nS+DunLdNWfLAIhAKZU\n55XTlN0xaD341SmgtMaaPBxPtwmat658wBbTOmum\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfKQr9VVQGdwgKRA+D6W0x3tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzVlOTEwNC04YTg4LTQyYTYtYWNiNS0wYmE3NDQ2MGQ4M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6loVCmH0cu7pa9YotRjK5cAPT8i6RdqXboHKHZypq6HRo\ni4gulYijI0iBK/RaFC2w4N1GPo6fZOFSEsuGXF4Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpmrBuLnDBvrRvd1z9jjDyVIy\niKwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL1ELZ5yqZzoYSMZc1yXvWrLyaSQHvUtHMVhFxxPFcM8AiEAmLuq7vvZ\nlv3CGfxDokw5vFSF2F5/sH1eW67odqBvINo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAdFQk1m2MLtP2usiIyt93/z1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU5NjM1YzEtYjMwMi00MWIyLWE0MjUtOWRmMTc4ZmRiM2YxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjODY0ZmRi\nMS1lMjMyLTQwYjctYTFmOC1jZDExOTA0ODliODEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASB4T8DTtI261QnpWuo/aJvBEyQ54gk1qt1QssDn95wq08F13uhDxsd\nWl3LHgL3Y7DTouZz0TKN6CfZfsOD79iYo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQwF5D/\nIvSV3cAdnSpbdgTtuKVnzTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAoYBcptRyXtjcph7ddRnyiNoUivttU6vHUqYgns4uggQC\nIQD/xC+cy3HSGkA5To+q48h1ziNLnuRi0hlnQN07WZdNXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1744", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1744` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAf3P5bcM9pCbNOzBaUbgzpBSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyYjBiYjUyLTZkZTYtNGNjYi1hNzcxLTc1MGQ4Y2IyZmYwYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDEwOWZhNTktOTVk\nOS00MTM4LTlhNDctYTE3YTlkOWVhNGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoz1vFd7UxmblEp+R139FmTvSBghO05Ip9GshHbfNfOe9CJ+lHwq0EGa+rPFS\npA/p+KiWyfzP6M5ZdeebnhIxFKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV3egUz980ff8UD8U54bHo05DUkYwHwYDVR0j\nBBgwFoAUUFGh4DusnvlLPyuucD3Yei1x+GAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAx4rfM78tjUet\nJiiByfQJcpB/2ewhte4dmGSAJ/mv8acCIC9M4hA7eGzEyrQBehh786o3aQfGzuwQ\nMUg8ZbVOy6fz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfYAfW2EuDBQJ9G70a/O7cK2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmIwYmI1Mi02ZGU2LTRjY2ItYTc3MS03NTBkOGNiMmZmMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQxWnoYEVWRJqtGEG+KfjLOLWb/grhMnL1YG1HnFc4o22P\n1upaaz4TB1uMvbgqEF7Rbc5iTMPXE1rzICEL3yvTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUFGh4DusnvlLPyuucD3Yei1x\n+GAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcSCqcwXHfLzRc7NgOObfh9X9BbdTf4y4/CcVB3SZ0N8CIQDnLg7TAk18\n+EzdRWiSgRtDggiVsI0HUbZWAYqnCMHpDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYGNT5duXXvIo5OEcBnRHQmtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDEwOWZhNTktOTVkOS00MTM4LTlhNDctYTE3YTlkOWVhNGZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ODMxYzY3\nZC0wYTI2LTQ2MzAtOThiMi1iOTVhYzIzMmIxMWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQxlGrkcfMGnWjgckzxJYQsG98lu1YzQem5a1tq4lt482Gkh8In5Ih1\npZGuxGGAykhIKiqPS2K+YwQPFYIRVbtEo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRXd6BT\nP3zR9/xQPxTnhsejTkNSRjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA3mnwOk4RPHyAJXGfXnyWr9BgZoBaA4IHOXAjmngYCRcC\nIEb92s7Sra1T41Wpk17IQZZ2bY8ebpXNwhH7JBsa2sIt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1745", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1745` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeAcJ/+onjSYW9QjsqOh7+4uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NDVlY2JmLWVhMmYtNGRmMy1hMmU3LTI3OWI0MmI2YWFjYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk1NTc4NGMtZjQ5\nNC00NmNkLWFmYTEtNjg4NWI5YWY3YzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEszyQvF2MODtTQ7Zid57vyorkRKYotOZhtValJWlsOyjYogjh4LXLjfnDwZfJ\n36sejKJ9rIZoZKVQ6Lb5guBDPKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjT6JrDUCpQvRIa5FFRdK722JzcIwHwYDVR0j\nBBgwFoAUs3uIZArSNXMBi+Y4rXPQr9RhMsYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFA8MWJPse1bpujqorKnaDtt9F1jPcbH8rCHuV9fV8wLAiAz2Jio4IATqIO1\nEeqWCKNhD0Gl4KdljlTIvJEMGy/oFA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS7+m7yA6bPyKqie0L1iwZtrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTQ1ZWNiZi1lYTJmLTRkZjMtYTJlNy0yNzliNDJiNmFhY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnC3w2PUlFo2ZNrPuX5G2xVjr9+VA3dI9U35fChHlgg1m2\nq62ze1KcxKtS1fCHODzeGBzbyfNzoRsQOd1ezxVeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs3uIZArSNXMBi+Y4rXPQr9Rh\nMsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK9LzKn3ErdjnVB5b1nakIja+1qYrp0Hp+4uept2Oti+AiEAoSQf6aYC\nY9ydu9tF9t9Lb1OXE7uRKc6Mi5sBHlbrdbk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZAn8dvZ/yIs6590Mf0geIMbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk1NTc4NGMtZjQ5NC00NmNkLWFmYTEtNjg4NWI5YWY3YzY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNTM4ZDQz\nNi0xODhhLTRkMDQtYmMwYi02NTc5NTZlMGQ1ZDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATDFOD3vuyLjx7X985He7ZRTvVJ2PAwdm+nQjcaawtVFMZrid63kQwb\ncopKzltIkzx2rCxAVN2SUQPgsDXVD+ezo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSNPoms\nNQKlC9EhrkUVF0rvbYnNwjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBQNcx4ZUpcxjo/N0cXB8xUzJNFtqf2vB13nSWwhC9wFwIh\nANaPJ5INkIfErCisvp0/VYEaH5uw9SXLCLq+V7omnKQy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1746", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1746` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAT4AhBFr3yC6xR0Oxt6mU2L3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkNTIyMGJkLWE2NjMtNGRmOS1iYzNhLWZkYjRlMGZmYzJlMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWRlYzI4NWUtNGNl\nOS00MGI0LThmOGItY2Q5OTgyNzU2NWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgUEwXDp8vylx4SyWmdUtiFniut6qwI95eCeEWXxQaFTSDKrb3PONiqCBC/tH\nj22UhanPK3Sf0cZRGMdJV9ol3aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUU66eLzs8L4VqIjqeDLrPNhBj2swHwYDVR0j\nBBgwFoAUpgIahgBUAtK8zRoK0x0rsJefNWQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD8mXBxgRCAxO4zecD61pdYFwwELQ8rCzrZQD1eCEwuygIgLTzm4MK0irKF\nVbdLKc9ixuxRSHAphHL95oXrEg65VO0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARoUEhzglX8ZngJMxbV79Z0VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDUyMjBiZC1hNjYzLTRkZjktYmMzYS1mZGI0ZTBmZmMyZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxB6wouoCqeaXAG0/GiywxKdRHDAIxRIua8Wlj1vAtKEgk\n9kB0TM4pXaCHis8kUDujpAiSjlFb9GGkpb+oYrRPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpgIahgBUAtK8zRoK0x0rsJef\nNWQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJmTMd4t6FjezfDPj6+v9acNo5UPnFT63MS3/n0uUwtFAiBsvTZ1uumc\nataXZfesoq39+Db3Uuqb4MDv00mQ6W7MrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAXXVXjuMJKUCwsZ4W1FnphkAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWRlYzI4NWUtNGNlOS00MGI0LThmOGItY2Q5OTgyNzU2NWNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZmIzZjVl\nYy0wYTdkLTRmN2YtYmMyZi0zNzI1OWE3YmI3ZjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATXDeW9so3Z5KgjeNGJbxlEhlfwCc036PKfk19J2toFXcL9wYEPCpr6\n974dMkIdM86AfN1qizHw9LsVA0sJT3npo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRRTrp4\nvOzwvhWoiOp4Mus82EGPazAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAhI44BaqIDyhLC0Z5bn/3EAY7Lehj6ux30fV76G3fVMoC\nIQCEie9mKBGpdRO7Gk3MTIfECxdiOgJHqFOnuOlmgOt5Mg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1747", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1747` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISATv8QIKbqhXMDSVsci/OcF/2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0M2JkMmI1LTM4ZmMtNDVmNS1iYzY0LTY0ZTE0NDAyOWI2NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYyYTM1MjUtNDk5\nZi00ZWRhLTk3OTQtMmNmYjNlMDIxYTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0cvYokToIps0cj7g+XshhvNIz55beDbqtA/fedDhgAvvRiSXnbN1Wb4462Ux\n+LXrPV83cmoJlCG33ACkFQo54aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUojUuJDc/UO7IwXdmiqlIXHjrRfEwHwYDVR0j\nBBgwFoAUnrJCnMegaRCXwigRLpRB9uz0G0kwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiA2gkVnX3W+wwWYLIE93ej4hEVx7VZqbWLyAnBiHcrwZQIhAL/83wct7EYg\n7ccInkKhfX7Vq0lcVKCOAuLiigM9AN8l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcal3CAyQUyPnxxcpHWWEP9HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDNiZDJiNS0zOGZjLTQ1ZjUtYmM2NC02NGUxNDQwMjliNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYhSRUOStOZYrVU3o4u1BMe3MYk8CvFv2+E5YUVXp4bALP\nqkb2jk09tU7ntsl/mk31uRbjyDhHArpy9zvzSLmCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnrJCnMegaRCXwigRLpRB9uz0\nG0kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJrC4knHtTMv/Z9JUdujbsINNeAt9Jj7zwcaPkvMRvKLAiEA+gRKL2Aw\nACkNCLyNLY3v+JVoRUwrWadRRatOFm5udVM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAbS9JPV626WVTPUGl31I5aRWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYyYTM1MjUtNDk5Zi00ZWRhLTk3OTQtMmNmYjNlMDIxYTY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNzFiZGZl\nYS1hNjk4LTRkNzEtYmZlZi1jZWM1MWZiNzg1YWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATgOZc7AM82U7w/f2nHJWtZaBaRA+2qzlyh3xtH2io6WDPbePLmLb8s\n0sZTZ14/vCwIHbVpNF3gt5zc1F2heCUCo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiNS4k\nNz9Q7sjBd2aKqUhceOtF8TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiAb3vDuBfRkINYlqMObfZ/jGp1UQSa269jR5xUQuksc7QIg\nD0k64nNMwLmXMAwn1v/nPnk5ISCdELr8r/D3m/OKKjU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1748", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1748` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAeRw/vTWmPtCEvvskt3zAC2CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkN2FjMjdmLTJmNDMtNDEzYS04YTUzLTE3Njc3MTc1ZTA2ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDVhYTRjMGYtYjEz\nZi00OTU1LThlYTYtZmU5YmU4OWUzODFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElqbuJRwk9KZ4ZRGUe1RPm5qBMLxUrH7IRoERcvuWb1Q/k3NfjGtiLUY/GbSR\nifkhXczyIkDSrrlr/RylutWS/aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4HveAFIKU6Py1zAPMXNzDxdTQ5AwHwYDVR0j\nBBgwFoAUGLhEefHos0Xl4U4ZST8MIvmqAL0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAfVbdWIiQqH1m2MkUR4sTGm2QZYcqF+EWyRJKTNVqT\nZAIgWi0LYV6aZlk3wQrRYRTG84jmoEsqhV0dYT7UITZSgQs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXLGCOmmqgHpNeE3njFO8v9MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDdhYzI3Zi0yZjQzLTQxM2EtOGE1My0xNzY3NzE3NWUwNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARU3yOQQttFOl/1y5qLZ3l+UUylYuxukwcXu2NRVQpDJjiv\nFg3kgSyvWfMnm7/WpsPxxT9HxizYiZQc29Xf6SNyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGLhEefHos0Xl4U4ZST8MIvmq\nAL0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALSrCKuXqQ3wy73/TEKN5QDWQptV+ZD8Uw61arq18JodAiBmNtO3ZJuG\nihw+WVCUYeRXTN8WKGN71Uk9wHi0pjfnrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAWXGUrnFLb+cf/QjZoWWYxMpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDVhYTRjMGYtYjEzZi00OTU1LThlYTYtZmU5YmU4OWUzODFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YTgxZDI1\nMi04NjRmLTRiYzMtYjBjZi1jOTA3M2YxNDRjMWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARiyh15Yxo3JeIYuzw2C2FqZtH2WLXcky9j+pA5HPe9+9r+S7OtN0yu\nNOZUwinfdQSHMquocHsbiW+fJfob1NQZo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTge94A\nUgpTo/LXMA8xc3MPF1NDkDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAjzSCtnz+Fw3SeNUa+ttMUHcO6T1f+8KigHMLr/QiyYIC\nIQCAc9OzI3mw5cjPcEQCA53VLf3pbxPm66rcQpV0iM/66g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1749", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1749` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAfHKkWEcw9LPdMZah0g+laCbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjMDk3ZDIxLTA2ODAtNGI2MS05ZTI3LWM5YmIxNmUyNGQzMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZkYTlhOGEtYzEy\nOC00ZDRkLWJiNTgtZWZmNjY2MTU1ZWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7m+EHy+iVjK4fglXnAdTZP4u2oNpJN+ueiek5fY7PY2MFV5AdWGJiUfpJ9UM\nAoX/dIfg/aq9OZ+9jiOaPXz4K6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFQDryPRjnyUCibqINpgusVZCf9EwHwYDVR0j\nBBgwFoAUEs8l1kgkBcYD4Qdie4T1JlXnbOQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA4pphRO18KmcrOQqGP84kAdLzKwVkKtXYxPEnkYrQ\nQtoCIQCbNi6N34dd8a3bAR9NtPGIxsKgmhG4AMOCv4dHYSH5cg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAch4rzP4Olqacd7UxpVwISYKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzA5N2QyMS0wNjgwLTRiNjEtOWUyNy1jOWJiMTZlMjRkMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBAiQyyHD0y4vBWEvjeLDoZV1XOUUaIjU0ZQWjRxVXq+D9\nGWYgEoX1+SuCiPQAfysTm6xCeSMMA9My1IiNjf/2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEs8l1kgkBcYD4Qdie4T1JlXn\nbOQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJpfuJD4xP2c93kS7HZQb/iNgXbY3dkIF3gUCgHpszXGAiAVlheMY1+4\npBgmweNe2/t2EFIW6K5S3whZiFadzjO+Ng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARX/bsOuQuOmNjvErbTks4N4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZkYTlhOGEtYzEyOC00ZDRkLWJiNTgtZWZmNjY2MTU1ZWQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNWI1ZmY4\nMC1iMDdiLTQxZTMtOTc0NS04YWFkOTk0OTRlNTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASPly5k0FgbMnN7Ygrwt2c/pFGCDS6UL/h+pu6cI7zzdE+wpc6DhjSh\n9lxVA7Eel8Y9HXwCbveqipkqMRy41Ldmo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVAOvI\n9GOfJQKJuog2mC6xVkJ/0TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBy649OzFpuKUJvftgR+LIT4dZDeLkox+jLxdSTzcvT6AIg\nZk0MLgxniZDDNW4P9pZib9+ftgcBOzBY1jWRrNmyMzU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1750", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1750` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAUKg/S4S9YJnodJugLHgFjs3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZTVjY2YzLWIzYjQtNDc5OC1hNmVkLTExYTAyNWZkYjFmYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhiMzA4OTMtZDky\nYy00MGFjLWJmMDctZDFjZmI1ZDM0Njg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzRaN7zeZIzFNV1OBW409GrFG+iquJ/QBkF9xRfDSnCvYBdQNJ50MkTZqVINv\nhblRCclZfmfnPH2JayCmJh1/uqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Xk94hsdrELtDDBuPxMqxnxNC8gwHwYDVR0j\nBBgwFoAUhahIDEeqGSsYPE0XX4dxKQfaeUgwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAzZKL5b5CqpPDflX6HZ0m09yrP7OLJhFxus9wxjOjUfICIQCT\nOtXwE8k5piZ4Tzws99/FPFmIHxMRzbNXTyMfr9JtYA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASSFGA6dcCccgl8qEjKrFko1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGU1Y2NmMy1iM2I0LTQ3OTgtYTZlZC0xMWEwMjVmZGIxZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGVZT52IiU1+BzfkCNgy5nOvS5Mt2oIkxhPGRgCV3xj/U0\nnR5OtNYa3O5kL2cWxNS0gQE9+hGPBZorKxUwP2mao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhahIDEeqGSsYPE0XX4dxKQfa\neUgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKJ7Gag2EvXhAaUGWP4tAvuVOxrrdsHbhht9CDTO9zfkCIQDk7QQbJQB8\nlrfjCvQru95v9WcyJBBgzZeaOvKuJmQ2uA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAVtPSewBw1gR/KdgzfenB0idMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhiMzA4OTMtZDkyYy00MGFjLWJmMDctZDFjZmI1ZDM0Njg3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YzhiMzE4\nYy04YzI2LTRiNGUtYjNlOS0zM2QyMGQ1NTY5ZDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASkSHfo6JCy0XFtv+0FdQQfV7RDZWe+klOUsTfKgd0Fhuzltcy+GFdF\ndRYa7OVY6i0O3Bx4TbBUrtEqdQJNiJRXo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVeT3i\nGx2sQu0MMG4/EyrGfE0LyDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiA/tsRuedQtEjMbg9UTf6PX5UT/qfURYg3KLoqmjJJulAIg\nGRpcqDkhUdwDaNrsr4zgc89BR1KLoQ3n/iSG4c2PscI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1751", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1751` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAYOhv6kbh8gQWs7vluFY4sLZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkN2NjOTgzLTFmN2QtNDIzZi1hNWRjLWM5ZThhZGE2MWQyNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI4YjMzOGMtZTA5\nMi00M2Y4LTkwMDgtNGZiOGZlZmY1NWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO3OeaJizgC5yoxzahhgcyQ9LurNKTsFlZxcowsNkqnNJQ1nOrNWYjvvriNZJ\nwkSj+Ft9n8ae7hwQgkLLhcyoy6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOeRZ4pUDYnjabl0nSiVJRk4R9wgwHwYDVR0j\nBBgwFoAUlhzGxRURcDuwnU+ab4jxfgq5/WswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA5w0WRfaPGxOkWMmy44uGxleTgJNQ+lgX\nhioq2ZdLUoMCIQDH0e93oDsM4L0UtWbDVW/vQf0+xJWUamMPxPRJEdtKPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYqC+aDIZTCdY0T3aZ8jsJr0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDdjYzk4My0xZjdkLTQyM2YtYTVkYy1jOWU4YWRhNjFkMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4316wahxUwGE1zIpQx02wVtdl6V5hbiGhnf4yA3z9j5F/\nd/kV1tgydmJP9fpvUgr69AJGjwq6jFUod2OE5oTpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlhzGxRURcDuwnU+ab4jxfgq5\n/WswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgArvd3tRVvUUbqYC8O49XllRFkD8abZw7siDQwJj8VQACIAhS34EuBcc+\nrR2bRfrPBrerXL+NuoJMNLWh2Cf320z/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQlpATYAUG89D/JK/OySrT9VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI4YjMzOGMtZTA5Mi00M2Y4LTkwMDgtNGZiOGZlZmY1NWM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMDgxNGEz\nZC03MzllLTRhMjYtYjJhYy0zZDgyOTRjYzAwNjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT0HLHjKIH1mD8NcoBAqaw3UXeItzdBbywG2qYHGur9HxJCrxPdBZGr\nmjgTb3sqRYHaYqopvnTg7JkwV6eebRFko3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ55Fni\nlQNieNpuXSdKJUlGThH3CDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBlQjcznwnYlJOWvXj+MQy2k2hZABKJ/Jsa8g/smOG14QIh\nAMD9yeZ/7UBiXXPy3f+UuuH/g7iZMlxlmI0yW1rwYn8B\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1752", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1752` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATyJFe20alUzdkg33n/3WKxiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxMTc4Y2E0LWFhNzUtNDQzYS05NDU0LTdjNzA1NGJiZWM5ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDJkOWU5YjctYzBj\nNS00YTUwLWI1ZjYtYTllNmRmNWE3YzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7org3CV4ehHs7pI5/orfm3vghRT/scHZIkgKPA3LECqjHJENDf7T9Pnzyg4S\nl/sYBH6dztOJYumQZIHvesIsWaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHYQKKlkNOXHRei9miKkJKSHYhy8wHwYDVR0j\nBBgwFoAUZKEgOOPajnaQMjLV1SVuqIp7xT4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBZv+0cYYblmBl5nFqoFRmXNzPAtWroWWQR\nsUSu5OW3hgIgXQenRu6kK+/e4ldm0VDXNBY3OdCcEdrT1eMaSm1dH+s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYMvQSYuW1CKSIRk8AgzlreoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTE3OGNhNC1hYTc1LTQ0M2EtOTQ1NC03YzcwNTRiYmVjOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwepqYE7icD+tnmkbTqBRnu34+NGV0Inf8qC6Abm7xqglj\nLtKBNArd5B7Bmct08Ztrzn6i16dSRNHJw7nV6/X9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZKEgOOPajnaQMjLV1SVuqIp7\nxT4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXDgMDwm/GlBoai/cYatpQHyVGBoYYR8hQ19HmVK8XDMCIGWABxizIKuF\nE9ymn0huSpEQQgSzEIXdWeMefHr3vxQJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAe1XuP7Qn59WRPRypmCF56UgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDJkOWU5YjctYzBjNS00YTUwLWI1ZjYtYTllNmRmNWE3YzY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNWU4ODM5\nMS02NjQ5LTRiOGUtYjExYy1jZTI2NjMyNDAwYjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARPjrHqE19N094aX8uSPWhZyOuo1IvI8iGAsM8h7Vr5fP78Lhh8AjQY\n+6aq2tsjB8Wpk41EKNirsiWo7M2sh+Edo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQdhAoq\nWQ05cdF6L2aIqQkpIdiHLzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiB+7w/v5fy1Coi/JhJwUzAazhbPw1EXbkjVJDN0qQMugAIg\nJjl8EQpqUp4xz5ry0rsRwPeywppsY7Mbba22PDGM2FQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1753", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1753` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAfy0cwJ0m8+oCs8Fgpl9HCOfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjYzhkYzQ3LWI2OGEtNGMyNC04NTRkLWJlYjkwNzJmNTA0MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFkMzI5YTgtYWVm\nYy00NDNlLTgwYTktMzJlYjE5YmZhZWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPBvRPxSZEbtWr28TTn0/r0htDfGWta1VJXxrPv9dTWUfnUGhciiCbiiGbk8r\n1vygP4qQNiffgm/T51D+GVLbbqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbEVAF6v/YNNTu2Q2E0lzDwQNMLQwHwYDVR0j\nBBgwFoAUBCDlyqoC/wYj3an0BD0lrDc3FAkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBEwlQ0sXIMJGqH\naRmV0sHjC7lOMXPVl/IeYTHq6I0xzQIgEyA5Rsv98wppMNDOCuoSZDVgKyLe6TKo\n8+378cefykk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT2fGalKwLXrgTv+bStzYJSjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2M4ZGM0Ny1iNjhhLTRjMjQtODU0ZC1iZWI5MDcyZjUwNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATR+SuekEO5GUS0T4yBX+Nt97NamHxLXkx52C4sjuorUFBX\n9Em1tdIGwye/RtmK4rVoKl54KG2+v4vyAnF1aTKyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBCDlyqoC/wYj3an0BD0lrDc3\nFAkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALaXEMR38Vz+0FxDugbQZfVUPLMxbE3BXK5+DL98yX7nAiBCu8KlJ281\n3NspOoaKLpiXyJQtndXkKZDMovIB44rlhw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAS8ogJSSjzdhFP/KRdEA8GVnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFkMzI5YTgtYWVmYy00NDNlLTgwYTktMzJlYjE5YmZhZWQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MThjNDY5\nYS0zYzhhLTQ3OGMtYjIyNy1mNTg0M2UyMTYyYTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQvOPOEd+NF5xf5OfKPsIW5Z42LYYjpsTAKdIzOEYA53yTDOjBo+ZNo\nEIzsHerevbOaYB0enJt7ftXoMpXO95Kso3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRsRUAX\nq/9g01O7ZDYTSXMPBA0wtDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA8ekTgfypdx7GXGbBo/AeUpwUv0Y4MygR7e3tB6KPbzcC\nIQC8wQlxl4Mij9WxXzG5xm13u9KYdcfVpXMVVzYA6/5STg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1754", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1754` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQ+tlBgmNskmkBrEUlT4HV0jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MDY2OWM1LTk4MWUtNDFlZi1hZTBjLWY2MWM3NzQzYjcyYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVmN2FlZWUtZmQ4\nMy00NzllLTgyMzMtNTdmNzJkYmI2NzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDfcTdbOxqcyIGIjJZ/lwxHcfWRF7XE+LVq3Oxf114QM+OP1DgNlpvNJg7CCx\n/kMG/v8qlpR0UPBDbR+o1VYuwKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7FWBOJnkFsPk0vizbRc+/+CJLDEwHwYDVR0j\nBBgwFoAUnCddUqkSpK2ZW4cOuIL0aRCrl5kwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIETtUbo84KwwR1vr8aRfHkrIu7dN//2VI9QhoEs7M7FjAiB8YMbqyF3qJr8p\nsGRNmxwNJupsjumjryOV2p7ARY5nPg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASOp4Kcxt3t4XY5/0JvhsVF/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODA2NjljNS05ODFlLTQxZWYtYWUwYy1mNjFjNzc0M2I3MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYtxEPV04UWdoenK/Y2D+QjLxht1ps1a2UCuXAguLYYX3v\nCYIfLqK8hNDfn/+nNqQXd6PFQxeavMMXxSgCyZb7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnCddUqkSpK2ZW4cOuIL0aRCr\nl5kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgX60orBQTTxfbMxevm9y8k5q2+PARFIY1sEYc9RgkFR0CIBhCgNUDHavk\nJQUUCgySzc3y+sFisjrvI/oMJXzlAGSY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATN13LHc+aF5+Vp9bFfC015xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVmN2FlZWUtZmQ4My00NzllLTgyMzMtNTdmNzJkYmI2NzQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZWNmZDcw\nZi05MTg5LTRmN2MtODBlNC00YTBjNzZmNWI0ZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQiVEaRjTzu5A3ixIBq2rTxSVsP8Rxxruz+wQKH1IDRDhyl6hjRn9iX\ngQqY5/FK7eKDxp/HFJLSylmqVnzaDJ83o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTsVYE4\nmeQWw+TS+LNtFz7/4IksMTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAwrW6llFj250SsLe2epwYEb6HSf6P2po8iqw9o/l7HuUC\nIEGN2DCEuTyeK2ZiRbiA3TMXl7Ubf6JqpMXD1osNx4JH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1755", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1755` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWCUhnM4c/lU8iXOzENuHyFbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4N2YyNTNhLTQ0N2MtNDg0MC04YjBhLTM3M2IxMWRhMDkxNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVjMDhjZGUtODVl\nNC00MzljLTk5ZDctZWQ1ZTU5NzUzZjdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtxDTHoHhwRH2frmZjWG2qxiuZkX3gnZ3VNbVi+IVcvshjQrpC5SnWcNNtW7E\nZCC0Vtq2lU90jpg7+oz8sMdu3aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXq8hC7GLt6tfCIjq1EwXCztMLhEwHwYDVR0j\nBBgwFoAU3U7KAYG9llQKa4Oa/xrtfduCARYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHFpRSywlXPB/TidnR4WrhBL3jxdaA8lplgKcMoDtqswAiEAufM9jIge1JE4\nRAX4rjhXqbc1nyI2qFUMnsrxu0alaD8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXItQafFawLWXwy7HrrHW5yWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODdmMjUzYS00NDdjLTQ4NDAtOGIwYS0zNzNiMTFkYTA5MTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLjzJUcAHuvX76w/uOy4KG27Izv14TJccyePd5lYG+nNbj\nlyulxdptmXhgqByaGNLVWmFrhXPPSK/xCq72xou4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3U7KAYG9llQKa4Oa/xrtfduC\nARYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN+PMjidJFK53FewLZc+pj5fzTjvNh744Rnti6vdcAzgCIDARn2S9RJp2\nvWk/h8kcI97SLNEKPMuNTCXcpdpLDc8/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAaPU08Y2kvGuIxuTvXm/q5jDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVjMDhjZGUtODVlNC00MzljLTk5ZDctZWQ1ZTU5NzUzZjdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMzZiZjFh\nNi1mNTU1LTRiNGEtYTlmZC0yMmUwYTU0ZDQ0ZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARQWdjPwwXbKkbQ1B7XiFV2EAYZ62Jw7iHGib2wRb9v1X4TFNpVfJgv\nJ3u7PGw9+cjybb9NhlV1d/be3GciXI6po3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBReryEL\nsYu3q18IiOrUTBcLO0wuETAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA40vlT9KsSrJlavEMeIFKXttBda7AclxTa20oAB4omzkC\nIQCLeHu88aS8vSWZpVY7+tDR9zCGVe8Xd61R+nIruF/DAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1756", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1756` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAZWSIATJw5tjTKC6u/jkeAOAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhZDU0YmVhLTQ3NTMtNDFjZi05YjAwLWU1MGM0NmRkYWE4NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFhNWU0MzktMzU1\nYy00NjRjLTk0ODktZjQ0MWQxMWM0NTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELXHIgqk5wNOdG8uLi7jvXkg7Lnsq6Va1UK89F8rTPcvRAyIwwC4x702LKLY1\nZjrD4I0CoK4xejQRaIOf0DysLqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXQhWlGXsS372Xm752V8yuV0OYFkwHwYDVR0j\nBBgwFoAUheXMgTbQtQURxDXaX6VqortbTIkwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA3w6otEvvJYzytNrNukwNm2aBVu2epiIWXRVfstbq+fICIQCJZPn7WJ+w\nI8l7oIBnOTj8CY3puNl96ngRsCffhfUE/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASGRYPW6+ymCQDjzthsEoqELMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWQ1NGJlYS00NzUzLTQxY2YtOWIwMC1lNTBjNDZkZGFhODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7XdBepwviYC9X1TE0HSc2Dapg2MzyiU36nGAkvY8/SWxX\nvuBW1zzgsXc9pfnusGNAtAHvflf/suH/BEcaoPMio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUheXMgTbQtQURxDXaX6Vqortb\nTIkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ7LMdIl6MFxOPHjYXVCX25oHq12VyA/8Yp0pZqfzbIlAiAGWjc8NSIh\nrFy6dOW8Gn6CNURqy8IGzRe+K16w+ExmXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAaZiL8w/RhJ4NRnVHmiRWZCoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFhNWU0MzktMzU1Yy00NjRjLTk0ODktZjQ0MWQxMWM0NTFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYjJhZjEw\nOS01ZTdlLTRjYjQtYWRjZS02MWZkN2UwOGU5OTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS4gBiTRw8JS1YB3yfwokdTEAzJc4RYginP7Ms9YpZLQFw8evMsErwb\n8y7+fZL8Kkn2ry1rrRDzKN8ThKvjNYPeo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdCFaU\nZexLfvZebvnZXzK5XQ5gWTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA3XBhO+BASB9GVv/hgykhrxy3Irq+euh6+5TJ3okwjwUC\nIQCKU0TUD1ddWj+6P203O2T9IXCPzGOZuWoAtv+lRV2FQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1757", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1757` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASOq+mO7LSscfsFKdolhufZQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3OWQ0ZmYyLTFjOGUtNDQ1My04ZTM4LWU1MjUwMTk3NzRlMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTViMjg1YmItNTNj\nNC00NDkzLThhMmItMGM2ZTI2YWQyYjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwCsEwFiwD6xj/9SvVH3cUoxEKIAdAs6tAhsoBLWRBtT45QWdcWHheO14KI+i\nSP8oIymGZXRWNXgB/Ohb58kp8aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhyVl34NCyzIvBZSHhdk7PAic97YwHwYDVR0j\nBBgwFoAUaXnbguLof8raU1p6JEWZaOUXYxYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAwy0VKY+Fhek5m+ndvU4JEnEnyEWXYlGh/Q+prn9zR\nZQIhALLuPCUkI6zuvc8hUtZQzE8u6BBda1jFSHe+VdgvjidQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ3i6R3BaiYsUmototxrmRsNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzlkNGZmMi0xYzhlLTQ0NTMtOGUzOC1lNTI1MDE5Nzc0ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5p/IeKP/eWFxhb+srLWLjICxqVfdYLYFkf+W/LvjKeCEU\nvb+wwrFdAKjc1fsn6zZi1hIQXpFlWyHXc8xh8JAwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaXnbguLof8raU1p6JEWZaOUX\nYxYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOIcg2dWRVVfXt5l7017GHTwc0gQ6AtbQv7dgr9hcwXECIQDiyo3HtNI9\n6/wC0/dR7LiPNYzjrMRLlQP6857GbHRuKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdsJxFGUmnj+vyavsdlSj87vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTViMjg1YmItNTNjNC00NDkzLThhMmItMGM2ZTI2YWQyYjVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4Y2MwNjgz\nNy1lZjUyLTQwYWMtOGZmMi1iY2I0Zjk5OGFhZWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS6mmpfEPbobwcigbI33aRudvBSOttM7hBNReNpFLjWBOnLIBx4LY8A\nHatRS4JI/89GhMQCg2iXORWFsQKrvm88o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSHJWXf\ng0LLMi8FlIeF2Ts8CJz3tjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAz8ZDGQMdMvhtZg39P6VWn659kDRDrzBiOnGiyHAory4C\nIFisbSyrClYwm+u1yZBhxWDEZZY1FeH1JJy5dAV9X9hU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1758", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1758` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISARnuTSHeF5wllcFIefPwrg/oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3YzdlMzhkLTNjZGMtNGQ4MS1hM2Y0LWU4YjFiNzg0MWM0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QwZmE1NWUtZDcx\nNS00YWY2LWEyMjMtMTI0YzFiZWVkYWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0fLkMPIN2QhN8jmqqvUFSO35kbUznT68xIQbZxqjxmwqeP0gmfU3XK93b7D+\nLgXK31eYcIHm+H+7LfP+OEHhyqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+ikA2Cf52z6GUW2slTy4BIcP9RowHwYDVR0j\nBBgwFoAUOq/YC3BcX3C/iw/ruK3wCOi/PqcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAlirA3FQGLRpW+PQpwzoooYnAzP5cgccwC41e2Ru+\nk6wCIQCQM65lXEOlp099FgXlRl2yv26jWOd9d8LP7KRM/ua2xQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAfl031jVaGgmJMN2LccicAI5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2M3ZTM4ZC0zY2RjLTRkODEtYTNmNC1lOGIxYjc4NDFjNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRDuC/iS12rNeEJhOm39fVMjUNiQvYVv8dRXKhzOMaxGKh\nqvQRGWbcPmxUlGsmQQ3GgbmreTEZGIIm1s4ccMcSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOq/YC3BcX3C/iw/ruK3wCOi/\nPqcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIgHjw2AjdfQZELa8Mak1VhItIKtVjnPPVwbcpvyYDXXcECH0UUj53saMwB\nq4P4/7wNzli8Zmd+r04zD7m4YkpE0wk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZ2JHCDkRrhyCWSCMJGwfTJwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QwZmE1NWUtZDcxNS00YWY2LWEyMjMtMTI0YzFiZWVkYWI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YTJiNmQy\nNy1kNDcwLTRiODctOTA5Ni0yYzdlZDY1NmIxZWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS5ymyZAHrymJaJ7E9Q/mx4zSQNNwembb5ZHb8wxDvat6LkaCK4PjWp\namVyfTzJcJhPXg3Svh4aRF6JJCOEliawo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT6KQDY\nJ/nbPoZRbayVPLgEhw/1GjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiB5Ay8rx0jVSzblCNKwDdI1VBvxJK1D6ehVlgXfCFGwNQIg\nMe9hSet/pkSjAUKssDzkEZeB8WU9nuPuU99Vd8HXExU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1759", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1759` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAWcv5S43veHIoWvN22fL+On5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYTllNDJlLTNiODktNGI0Mi1hMjkwLWY5M2RiZGZhZmU1NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM3MTEzNGItMmEx\nNy00NjM1LTg1ZGUtMGIxM2IyNGVlNjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvBAE/uvcdDexBEWeuF/h9Qm6ZZgZ+wGFXQwT9VhYAZZowIUXr0TsCnalD7Xm\nhhfGKIvxDTN7cM1uZE+2mrod0qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNeCRFvEgwolaQow9pew8Zcnc/fEwHwYDVR0j\nBBgwFoAUjhGkut75KVIoHH2NnbsfPU9tqYswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAjatMg9ECIHd7pKP4XZgnBJN47/sEK6LzWKvCVcCGaFQCIQC/\ntd7fLeI3Ug6OoyKEYpNp8I6rVOuLBYszOLEpF6NwjA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAVtDkx8zVbwfO+wNdfrIEw14MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmE5ZTQyZS0zYjg5LTRiNDItYTI5MC1mOTNkYmRmYWZlNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJX1NjjAWFx/OqdA/l3VRWBYi9XtyT++X1rQ6fl39wLcUN\n7GBrSLHX6AsVrvoViib3oWM/G39ycrQPXHtQsD6ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjhGkut75KVIoHH2NnbsfPU9t\nqYswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIgM8tP3fEQJkOPE96XHlc9OHFdMT8ZnPjeCUcwYH5W0TgCH0DEBTE0AjBS\n2q+y5cNQAx6TOc+thcyJR0P+sGwY+3E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAcZeZCHUp76ucV84DVtjKgH/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM3MTEzNGItMmExNy00NjM1LTg1ZGUtMGIxM2IyNGVlNjNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZDc1MWEz\nYS1iY2NjLTRhMWMtYjRjZS0xMzY3YmE4NzUzOTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS3nw7TsBX7lG4X26LOISxOhgKy8bxJebQ7+9/NTvc242XeGKfZTn2T\nTRDL0w+XbZKD5FzBPOIi+n9VgItksEoIo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ14JEW\n8SDCiVpCjD2l7Dxlydz98TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBpX1z7GB3y2qVUe2U0OyvC5zbGypzw82zPuxgdN0HcEQIg\nC0gvBBu0rFvLNpKkdTSMdqpB9jorARbdP8kD9j/SEFA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1760", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1760` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAeuDpBAUtrKCFgEwi8KrmuvhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MDgwZTJlLTY1ODUtNDFmYy1hMTEwLWJjN2ZiZjhkYWQ4YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNjMGU1YWQtZGM5\nOS00MzMxLWE2NmQtMjNmNTc4OTE2ZThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExzBUoVTN0gbX6esSsImXVMjnp4zh56H0HOfZE3It7UjkPB4weocLIsCBvfBT\nLmv2TFlqL1pwMoqz6kmrpP4l1KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFJRUw9WJhQAsqZDm1mAFl5iWF/kwHwYDVR0j\nBBgwFoAU0YtfOU4GHXBr3i91Dm2fVXeiR8EwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBqtY02GeGekeTcEhOlST5pwVGYLPNecWup\ntxhcrgIQ8AIhAP32K2R+wSsCFplat+ZCKD4Svvez+u6Gr3gZ0K7290z9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVQJAddFG4rxfnk/VPcHAHxUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDA4MGUyZS02NTg1LTQxZmMtYTExMC1iYzdmYmY4ZGFkOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLEgc7kXU+0YXtMiEJJTHgIFjG7DZaT1Soo8Cyf/y1xYyj\n0E9i4oFe66n/Dxh3CfVdq0lAIF0LOvlLvCf1FcpAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0YtfOU4GHXBr3i91Dm2fVXei\nR8EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWN48fzvm6OQG7ZRqt2GCOAOw5LfBwkQCCq5evn98iOYCIA3XvZQ+QKef\nFq87u3dGEyqJ2f2aRzLyfVxA9xMjaoJ7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAc85EB9VEV//sQgnKd1NihhTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNjMGU1YWQtZGM5OS00MzMxLWE2NmQtMjNmNTc4OTE2ZThiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMGNhNjll\nNC1hYzdkLTQyMWItODY2Mi1iMzY4ZjRlMjVjNDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR5+7qwUCmInZ3pd/IKmv+wduBv/9DGePgzpJQbea3zAFNB/YlNAsrY\nWhsQdB9rTElnJE6ikX9PczXNdvzVUkhro3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQUlFTD\n1YmFACypkObWYAWXmJYX+TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAqieToO61nddiwBP2JZD2Bw9cWhEDrTAjM1c7p00EFcAIh\nAKVXpI5lMngY/J9Bse3gxkqR9A1GrFLF2NpDRRshjez2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1761", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1761` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAb7qn+g/L7RKHf2pZxhwqhsJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MjQ1NmM0LWE0NTMtNDg0OC1hYTU1LTI4ZWI1ZTM1Nzk0MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWI2MjViMzEtOTRl\nYy00Y2Y2LWJiNjAtZGZmYTIwYTgzYTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx7iAWbDZNmuPx/UeCfYEM+fOCWYaMHMiBun1ctwqZJva0qHRDqUUe08Cpx9L\nZ6eujYy7bVVAp5htsdWGG/LaVaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzhi5/IoTOxBWxloK0iXmkxXHptwwHwYDVR0j\nBBgwFoAU6JaNHnJbhmlpKEIZxL8ZIAwpncEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA6k2QBRoYP4eCfTvsBe6ljxV6cg3Rd0zyx\nc0iFpPchIgIgddfDG0MO2CEx5tvETgY0ykv8BFDeh90KJDpjgJBsKsQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYgGbxvhS2nazaG1OBiD3nU+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzI0NTZjNC1hNDUzLTQ4NDgtYWE1NS0yOGViNWUzNTc5NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATErBkKwnEU9CRXUN9Y9W5Z6YE4m5SHWUFae5cu7jBVFzIA\nn9Mp7mA3G8fRLaLkmFGb79JcDg56OsZNtnLX00ado2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6JaNHnJbhmlpKEIZxL8ZIAwp\nncEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN7XBr2nSvdwNfn8dUnUlvSluYh1brMbis9C3VKSZ6x+AiB2Wrgb8Q8j\nI3UxpdTg8KcCVSlEtxoanBG7x5iJubCoRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWA/1wr4YlvOuq5GFuYrCpviMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWI2MjViMzEtOTRlYy00Y2Y2LWJiNjAtZGZmYTIwYTgzYTZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZTU3YTI4\nZi04YWY0LTQ1NzgtODkxYS05MmI1MTkzNmRhOTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATiC0DED5g33Npcx6smNyyU+2gPK3hgmhorrJhgDInk3rI3j4gx47rH\nE76aXkISxw3uENwwURaeAPnDwkhnybyco3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOGLn8\nihM7EFbGWgrSJeaTFcem3DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiA4uQEA5ZooKGVL7tzhAci2hFQSJVk6cX1FdwXG9sVPHwIh\nAKbDw41DuaZ860eM8n+KjSTC4uq/439BdPrl2NezSGcv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1762", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1762` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdmkRs9lRST0OuPHh6vIy3xTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZmU0ZDUyLTIwZjUtNDcwMi1iZTYyLWFhNTcwYjMzNTg4ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY4ZjE4YzUtNzRi\nYy00NGE0LWI4MDctYTdhOWRiYjE2ZWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl/OV6TxoXokWlTOCCb9uscC4gjy+zunct93ydGCudhgROvHQKKXltscRCuNr\neoxFkvZZgfFqpUdRZBkBu88xmqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzkpfEIqXjy1aEl2THgiGOV2QqRgwHwYDVR0j\nBBgwFoAUofNp+lEephLHcPbaLgnQP3h7HT0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDqQcW0QQaODFLkOLJo1aFFo1Jd\ngHhEgPUzBRZnwPvwZAIgQq4Rvp+rEJtt/6Ed1QHkN8zrUxoxUdg9TBXnNIReH5c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX/x2a1DFBYcLL32axfc2nPbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWZlNGQ1Mi0yMGY1LTQ3MDItYmU2Mi1hYTU3MGIzMzU4ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlAeTpMXSmUo685Wvze8eQ1uIlhSqSv5jBxdV5hd7ps/m6\nADoCNdMlMrUx/ifei3sE8IjGkg0IzNhxxcWjl5t0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUofNp+lEephLHcPbaLgnQP3h7\nHT0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYELBvcbUhooUN5Ndxjd0duB/txoGRxQguFxxVtuhbskCIAnRcvVPKvFU\nSIAtICtK/FllCJ0fCk6alV7POjzKy5IM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAS0AWncJP8m210Qk6DvRgComMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY4ZjE4YzUtNzRiYy00NGE0LWI4MDctYTdhOWRiYjE2ZWMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYTQxMTc4\nNi04NDY5LTRiMzQtYmVkMC0xZjIyZGEyNzI1MGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQfom2XFM3s/hBNp6eN9ffsWVYXhPrsJAqJYt6s9nVBfi4hi7lzHYlM\nkyqjxVp4eKWoNybpbQtYwpTwLzfA/naAo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOSl8Q\nipePLVoSXZMeCIY5XZCpGDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiEAg43zaqGVSIYRxNZX3viTaBYMUqZCrzsIb09uvNoIWDgC\nHx0KExUppBNpzNHxBGpvJ3tdo8mAEW1/uLShRlH5WJY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1763", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1763` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAdlAIZOtiOznaPaOvsaMKeTRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkNzIyMDg5LWYzMDktNGRkNS1iNGZhLTI0N2IyYWRjZDU3NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJmMWNjZjMtMzBm\nNS00MDZjLWI0MTItZWY3YmEwNTYzMTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfdKfH/61IrYWy8KeYAyXKsg8zB1ASkYspqqS/RTh7HtRaf7htO+hLohXaUQi\nJzjBurz1oQfpEMCjCbKRiVxZPaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUureqTEInJx/55l2/na/9Ce5YRWYwHwYDVR0j\nBBgwFoAU7P/7UxQBuCjMZpykRiMwN6IhGa4wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgZqI7O10D\nvADmaKXiD1SftySg+SBa9YTVq5cNiQCftw8CIQDW/c4+pZx74pnH6jQu5EgWliN5\nFgyh0rZZhn/WIv2aiA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaz9FRj6MKQVX3qvXYgXVBv7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDcyMjA4OS1mMzA5LTRkZDUtYjRmYS0yNDdiMmFkY2Q1NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQAR3d/J91LgZf9Dd8AFu5V61mJl8o4aN8k4PL5XMSbvkZ\nDqh600SI811nMCLowyHvitimmbgwXYrAIuzFcuOEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7P/7UxQBuCjMZpykRiMwN6Ih\nGa4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN74jWf06xBN4NOHkmurvXDSF/qYBPV5aABmJIQj1X3iAiEAldBhw83n\nxk2PSQpFaKHJ9j6+BxaiZFKbR079QyjIoBo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXq1tXkM2dVH05LmsYuDs3fYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJmMWNjZjMtMzBmNS00MDZjLWI0MTItZWY3YmEwNTYzMTUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZmU5YWFk\nNy1mZmFmLTRhMDktYWZjMi0yZTZjZDE3NTQwNTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQARrLpqtuzdZqv7rWZmAsJpvj4NQHYo8HCyWQc+AY6DdDo9E2ohsfb\nVwzd4253JIPopu5ihI+oS/Q0gDo0ck0to3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS6t6pM\nQicnH/nmXb+dr/0J7lhFZjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAyVJza3YOPo2rpaxFbGg/ATrwPGIzhUgXSaONe//tdBkC\nIHDs4z7l6kr5D3QqkbeOYRavcQCiEkZxoljVyu5LeCyZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1764", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1764` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAbxIjSQHEdz49oLTO89tvikPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiZmJkMjFkLTQ4NWEtNDQ5MS04ZWJmLWMwN2Q5YmQyOGQ4NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2JkMTIxNTMtYTMy\nYy00YjU2LTgxYTItYjU3YjE3ZTQ0YzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHS12lRXTkjD3rB7jsUtU6dpxY18sHGOSjsIJg2+JFRr0dMLwh1DbXTJTNACI\nlqV2YUkrFzt8ow9QQQHmOHNBE6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOrvTmhqdW66ZHuzliQ1qr8H6Of0wHwYDVR0j\nBBgwFoAUhId4fcYBQEg9DSR43i6fc7TOuyIwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgFFyNN5P4\niPKbo7DhthT/bOG0devf2ik0q7SVhEmnNeACIQDR6PcEHpzuVkPVIbzdBZZTTY6K\n9/Xwk3iMH6Eluaa4CQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaUz3wvllLdxX1VlAb0vHN35MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmZiZDIxZC00ODVhLTQ0OTEtOGViZi1jMDdkOWJkMjhkODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKvEpIZSzBKACv3ggsGOFXoDmgEOzhKAywMT7GA7Ldq6oB\nHl+dtAf8str9FyH2fETW+grxY4S+gk9g1ATarNZvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhId4fcYBQEg9DSR43i6fc7TO\nuyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOLGN7PiAlbCpmu9dwB5LBAYOKXek9EaWqKQecTydTPiAiBcL6iH+C6g\not2u8GnPN8WLYtjp4ux55MLILLzMJcTFgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAS8TvjNpcFZXe8+QLiSoAzOUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2JkMTIxNTMtYTMyYy00YjU2LTgxYTItYjU3YjE3ZTQ0YzY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MDk1OGE1\nNS01YTlhLTQ3ZWQtYTNiNy1hMGZkMWE0MzVkOTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATgSCtMgPvx6mlTbhkTMObaC/IOPf4Kz9bVCO/05HGDeXWnWShvnnsl\nQmh0h+jjj4Y67pjq8lhHHHtc3zvLrwqco3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ6u9Oa\nGp1brpke7OWJDWqvwfo5/TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBKddHVpeVp6pArt1xMNrqekTVXZSNBZgEovcnNObVAKAIh\nAPUL0ljA+A4o0eJiK+Pv4LXMxi6OFJxdIUURYQpOpD7n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1765", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1765` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAaiS0kU41ciJy12SGZ8eIzvKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4OGY4MGQ2LTFmMDctNDY3My04NTNkLWEwMzc4ODM2Mjg1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA1OTczYjEtNjU2\nMy00NzVhLWExMjYtMTQyZmE2YWQzMDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEby8LZ3j899tYVZC3/r2EIExVnV9po3JU7un/qgoPc0Zdi5qcutSB587wVy/h\nhmbSB1Wh6OQdt0QaUyM6HMJ/MaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYqjcD/bpEBZr7BdsAwNQK1imb9MwHwYDVR0j\nBBgwFoAU4H9LHgrqXzIJxXirSNNfGEb8za0wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIA7OfLBa\n5ZsfjcUx2fcgPrVP4bmTFjq3VrBmzReOrm+wAiBJavPJ+KdwCroRvZzt45K+RNAH\nfLUS8o9Xrdc2N3HI0A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYbjinFfg+uKLLaIKYkKztBpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODhmODBkNi0xZjA3LTQ2NzMtODUzZC1hMDM3ODgzNjI4NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS93Y0Om3sO8qpbxWmjEgjvucCD1Jd09Gk3oov/nvauvWTY\nSsi3vBXFaVsIyDBJN69tWmH27VNgUCxdf0AfvG8co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4H9LHgrqXzIJxXirSNNfGEb8\nza0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQdHyNXYMPbKExLIyArxTHgWHYY3HPI19tr+nraSMQgICIQDTWyWauSpo\nZhEPU7spcQyZM/6m6y/f41AoycAN5NMc/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXNjM0w3BamZWmqKjHoBz3xGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA1OTczYjEtNjU2My00NzVhLWExMjYtMTQyZmE2YWQzMDBhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNzQ2MmNj\nYy04YzhlLTQ2YjAtYWRiNS01NDZjOWI2MDk5MTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQiWLW6USW28BRaKDxeweW39PjtojeJLc2A2IiaZSdYoHq+AIr99Zkh\nrzCab5FwqIMEgj+bGOHBH4r4XGd9gx/To3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRiqNwP\n9ukQFmvsF2wDA1ArWKZv0zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA0tWtXRXq9e/2Z8zfn6ZwiS6OQF7WNxyBn+1oFfvVEOoC\nIEzC+Y9zde4RSXq11wKASMu+NEKu67fipw1wnCcUoFkU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1766", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1766` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISASPePc9KjZjrd+Q7dYzbQcVvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmZDgyZDdmLTg0YjYtNDlmMi05ZGIwLWIwODE5MzE3MDhlODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdhZWM4MmItY2Rj\nMi00YjYzLTgwZjUtYWQ3MzZiYzkxYTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl6JPEAhGV5LBUSrg4CGVgBSsiTncYlkwhldR89ZSAJVa12PWFXCejxE3fCNW\nztzeHQAWMqszNJfsJsVYpOLB9aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBLErWBz/Ss9HcbUQZbSr3G/aBYwHwYDVR0j\nBBgwFoAUE+JRBRDkdLG2YrjRe2LGSJ8YFVAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIEXZ3bbUEjwU5tVekE1ks1Uc3L66GvFaVZxRWzZQdgsmAiEA4vQ6nyQc\nU55XHp11ylG5oKFu5QMAYMjhaFjE0fnf/PY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbM9eLZTgw9rYtCWqNGwzn01MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmQ4MmQ3Zi04NGI2LTQ5ZjItOWRiMC1iMDgxOTMxNzA4ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQe2+0OJsSh0PnFXff0xI3z2zm9uAkwEsxHZDx/HI/kSqFz\nZggyCdvpLa6laSz8YQgaYRv0jVPMK9enf2pnj+2/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE+JRBRDkdLG2YrjRe2LGSJ8Y\nFVAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF2dO9vrz7LzBM2EBKiYa1F94/y+ibFM5Foncr+RP55ECIHj0SCWhk8m9\nF/a3ZSkzBTYisQL3o+UfqAupCMiTjRxU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASdY4L6UOvXsnRs6z+ZagEYVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdhZWM4MmItY2RjMi00YjYzLTgwZjUtYWQ3MzZiYzkxYTQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYTk1ZWE4\nZC01ODI0LTRhNTEtYWFmZi0yYjJmN2M1YzEwYzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATZMNzDZP32yz1D9zyofJY1e1rJe4/8z/R+vkO4+3xwjkvNC/dC+1IE\nR7VCgy7uEorlarkT6rLugrmRXwNYudEdo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4EsSt\nYHP9Kz0dxtRBltKvcb9oFjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAh3I9KU5rIGUFU6CslmKOQJutJ1FR/L2gIBIYy6YyM44C\nIHQTXf73qZwmRdDz5cJ7QxepMhZaKPaKwDTzrl5LL6S7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1767", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1767` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISATDUq5QKSS9oTU3OB1xADZ49MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2YmQ5ZjM2LTNlNTItNDA0Ni05OWVlLTU0NmViMzM2OTE2NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTViZTVmNWQtNzQz\nOS00YWNjLTk5YjgtZTAyZjEyMTQ5MDZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHcXcXPy7U54KgSo0r5GFHMoMhorkcFZbQZRxalsEuKsCSv2klrbeaceoN2py\nUhqkzsrtOml8YV9xdansM6B5nqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmx1nGj3pVf2lVjQZ+4MMAy6SRsMwHwYDVR0j\nBBgwFoAUf82/7IOpXHJ8fDT5aJRoy2ZpivcwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCU2WC2535ysJwA7ILKrqbQBbQZ2kWdRM/bYTix6oiA9QIgfj8a04Kj\n5/ijnz+gPCd18sV2fcoafR8I9yB/7lGiZTg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ2zvMTszY6PEbE4fxCCi5ewMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNmJkOWYzNi0zZTUyLTQwNDYtOTllZS01NDZlYjMzNjkxNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPoDzqeP7aHNe6ihg0ejR6zXQBVyJY2IA7CYqrA5bg+2EK\nmr9CNZB+wsL4RvzvzJS6Z8TNkEJgS6AQ9YvkMDmJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf82/7IOpXHJ8fDT5aJRoy2Zp\nivcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHwTbOu/8p+0Nuz1gjb2SYcJ/ray+Q79LYHlrRv1qM9gCIQDx0AzWxKAQ\nsFjBLY36kjXe1W74ZMUuGiziW/J4Zu2NOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQBWHUm52L3W1C/eE6xgsJjQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTViZTVmNWQtNzQzOS00YWNjLTk5YjgtZTAyZjEyMTQ5MDZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYjMwODE4\nMy03ODQ5LTRjMjctODI1Yi00ODE5ZjI2MzVhMDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATrch0w0AK6IkYBG6ucYqOs5FnFa0bF8i/JaCMkuu57uc7RAwn9DzDx\nAB0akaX4RllWVcsJVeyOzIqRQHzPHM8Po3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSbHWca\nPelV/aVWNBn7gwwDLpJGwzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA3t1va3gO3mp5V/B8Aac9pYqGDu9BmLXJyO7MUCjadbgC\nIHnAjKOtVmZBsXw3cnGuV2PROUqt32EE1+MSGa0KR1qV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1768", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1768` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAYIJOG96jgrgUFsc4fdMM8FpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5NTQ2OTQwLWY4YmQtNGZjMy04N2EyLTA3YzBiMmMxMzRhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGVjYzE1NTEtMjA3\nZC00NTg3LTgxMDktYWYwNmFhZmU4ZjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8Jah05jicnuVnc5wn0qdRMTU2ow8dJCa9c1kNjeICTpMeVDEDEFKtMZLS2PC\nVbged203RklrJSBwcCf3f1ZcdqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhcVKRzdVRBJ41tSO6ZsNe5sTWTAwHwYDVR0j\nBBgwFoAURahyhtBohozY0X6oNX7/2TNTaWEwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIDpsUuEU58lur8u9kqOYmnDo4VCWHSiwAjt7GLNxNR/FAiALOywOUuuI1naxJELL\nkkvR4BSXqFhxSuAy2amwpGifTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWRznnv9NaL5Unr4xO814b4MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTU0Njk0MC1mOGJkLTRmYzMtODdhMi0wN2MwYjJjMTM0YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdpptcAwyUCTumDGXtlRLPsf5gCqZlR3Kos6kco8SE9dzR\neBo5vjsjgVaThJmY8JABHFO2zySKdGf/miBjEF6Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURahyhtBohozY0X6oNX7/2TNT\naWEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXAUzCTlAp2xCy2gM0OrdxyLvyB3t3770J9tGdcNB/LoCICzaTuQ5Idx7\nwtSd9xkN7S7ivEPmOfMmO4tSm/7WaVL4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQq/MuGPA0MJ80txI10gceGsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGVjYzE1NTEtMjA3ZC00NTg3LTgxMDktYWYwNmFhZmU4ZjdmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMmJjNjM3\nZC05YzM1LTQwMmEtOGU0Ni0xOTZkNTYxOWVlNGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQCPep905EwGqBTt7japeJssbzuVYg4kMkliFjmCUkP5sYjE/T6Wie1\n4vejniIf/RXsiRj4TVKDSgTQfL5y00DLo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFxUpH\nN1VEEnjW1I7pmw17mxNZMDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAigmcHj1nsjMqtrUYkQXWZAlFWfze46yPprLcm53vZsAC\nIGvf4xpcWQ6iV9tfHQK5RpzsSjMQ85UY6gNj8IZKklmu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1769", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1769` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAR3DqERRLSXu/0sAwDILPfqrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0NGQ0MWE0LWEzYzEtNDVlMy1hNjc4LWI4ZWZkMjBmMDliYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTIwNWVkZmUtYzJi\nMi00ZWI3LWE3NDEtMzkyODRhODlmNTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERQA+aMkMztyd6e2VGXgkVQZrTYWDudYekFJ+46d9iLwMuXxNKr4dXnMzwb93\nsFNX31ppFV8/Q+i4wuyAu3sUL6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2a41EzybuIeM8iCf1cc2dQXzJDkwHwYDVR0j\nBBgwFoAUgLPneS85h0CCcpDt2h7k+YOHSb0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIHjpGUmsj3evtf2GgMxP9q+1IHCM/2YMgNuaIWBMJxPeAiEA\nuH2SPmDRHP+oTux7Z/zaZM5+ck567T88nStdZWDpPHI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcCEx3nEqYJBMCGM+9kbrIcWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDRkNDFhNC1hM2MxLTQ1ZTMtYTY3OC1iOGVmZDIwZjA5YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASj0ouLlJ7ny7yBfkrkdOoGhlfn+MOk7p1J2fhJl/QB8Tj/\nzQKq8phVXEFJZ/haAAYwaCdJXD22KDmumIs5QzTJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgLPneS85h0CCcpDt2h7k+YOH\nSb0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMXp4flmplRn3MCyvmMFkigOp6AkyxeW5FOICnGnOql0AiBBBxeUUeDq\nIMAryDLIGiHpaa9lE4iOuy2jeQZ8BudF5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAaIBUTI7CthMiwwTxRe7dfDvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTIwNWVkZmUtYzJiMi00ZWI3LWE3NDEtMzkyODRhODlmNTkwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OTlmM2Yy\nYy01ZjU5LTRmMDUtYWIyYi1hNWRhNjNmYWQ5ZjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASgBA39QIxkQ5isaEOLWedTzPFA9Q/hzHA3dM0bEJYIICIfVbpjPh5c\n8VAMZy5f6IcB782zNi95r2YFW+VYABKio3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTZrjUT\nPJu4h4zyIJ/VxzZ1BfMkOTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA0I6KbotFShrxddHs5WHc5rzPOznrrHmVluYwc3HOfuQC\nIQCijJTg4nFeRVfOH+Z1kkt2hDEt1moWp4dEj0Cj/fyxyw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1770", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1770` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZHRojM4d6gDwe3Yq8d9Th3uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhMzFjYTE1LWNlYmItNDk4Zi04YzQzLTM2Y2Q5N2RkZWYzMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDljNzM0MGMtM2M1\nZC00NDhlLWE1YmEtNzM5N2FjNTIxZmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3ZUn+6Qb/Lz/jdtxBWV5dKsbY1KPWri/XnNuRncysOZZKp9cCNKhYZdies+0\n7RvnxQczmxOyCP7vZHsEW1ECnqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsN6XHqIK8LsNOocnBPC45lG/gY0wHwYDVR0j\nBBgwFoAUY6lhtsfdr0wymAfkfFyn3F1oFGEwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIHxgd9acMMGEcu+zuCM7+DOE6aBVV8g/WPnFLglYFCgTAiEA\nlX+zA+TWb4qx+HnBAr7yxlUSQA6gvA1PBOJYlmc+IoA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe/7N+SNDBg1kf8aspwVDRvTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTMxY2ExNS1jZWJiLTQ5OGYtOGM0My0zNmNkOTdkZGVmMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQL0+nUnvDeGQCYZwcBMUeGpJBgpkIzJyeFjAFHFwQno5TC\nRMqS9mme3t8ggT/yZUmkYaRvqKMQcNLS9bhwnolEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY6lhtsfdr0wymAfkfFyn3F1o\nFGEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgExZgRCG/Xj2xQY3GBVaE3ZLDdBZxQOxZBaLVGot7kYECIGSCvzW6Ka/3\nIRibATmpiegoz+Q98cFZiaOjkmknIpSV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXCb+NDj1W3E1AxbvxcU8DXcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDljNzM0MGMtM2M1ZC00NDhlLWE1YmEtNzM5N2FjNTIxZmMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYWYzN2Zh\nYy1lOWRjLTRkMGQtYmE0NS1jZGU4M2VlYTJmZDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATKnkwmg9OPGwZLAFwNX2O2q6J20KF2QG67BpKW33ADhnHECDzLyzn6\nqzD4UQTvfudm2c/AkENqEOI7C/Nqfw/Ao3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSw3pce\nogrwuw06hycE8LjmUb+BjTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBm9LnpfEZN+HOtRxynZl4aX9tML3uSMup6tGRL6pW2ZAIh\nAMZHi/SngauH4m5T0uww2HgmfUcnUgH7lhor6dwoIH6L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1771", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1771` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAc06EQ31l2+Vv5Vlc82XfKUWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1N2ZhZjljLWJhZDEtNDQ3Mi05ZTUyLTVmYzY2MGI1YzFkMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRmZDU5YjQtMjE2\nNC00OGJhLThjMDgtN2MyYmExMzJiMzUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6gSQyElKoIU+cH1EXxmJ3rlR9Ga+eYvFgyMgYLJrK1MnpBVyx1KYj8ohzpVu\n0A3jy5ldAoj/1e/xo8cTr/aCg6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn213u8GOaacfz1XmkEIl9nxy3E8wHwYDVR0j\nBBgwFoAUC8dTKfiCQ9FGjnTnCedwkeogqS8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDqCMJ1+8yO\noC6BAIAWeeMw++vgh8AohetfEBYVp+9OYAIhAIyjnQv/G4nu2BO32bNnTtUZcCkb\nJIN7oDlRCitQ1T/n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARz1elq/qjZpyUSgZ3kfCejvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTdmYWY5Yy1iYWQxLTQ0NzItOWU1Mi01ZmM2NjBiNWMxZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTnotWhNN4wNnwHFHj1/knmoyAx0Yucde4f3lHtjlNbRg7\nJ3mAW/nMqtyH2USFSb9OeYRQKodVuFBwQ8dlxsl6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC8dTKfiCQ9FGjnTnCedwkeog\nqS8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAInUyNxs9uQ2bE6+iwgu6DzysvWpVhAUjV2m1tCxs98gAiBm7twfC8Dk\nnRGHHK8qVcXgMv17l4yaku69TamK91jF2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfGK86YlevR/9aICSuvQYWK+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRmZDU5YjQtMjE2NC00OGJhLThjMDgtN2MyYmExMzJiMzUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkM2JmZGQ3\nNy0yMmRmLTRmNWEtYjZmOC03OTVmZTk5MmZiNzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATa/+nyXQ0//hNXBT4KIRknFFBjjXndJLN3lbIk6o7gjnTX4+3YWFp1\nhxlAmuYc/JNi2wmw2PxX6KgwoPpSriTuo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSfbXe7\nwY5ppx/PVeaQQiX2fHLcTzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBloZssf8uWyL1Qy4vdNT7as0LEefYvtDRkcsTETvwMPQIh\nAPTsyUFyDnqCV/CCCmCPFYTRQ8Ey+SnzAagmZQxxfPfX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1772", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1772` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQFmS6uwEJSIH/0j7FLGpqfAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3Zjc5NDU3LTFmMmEtNGUzYi1hNTA4LTNjZDRiNmYzYjllODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQwMzYxYjYtYTY1\nOC00NGZkLWI1OWMtNjVkZmZmMDM4ZDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs7vmtBNpIifM4GPIg/of6RuhOkx/BdyAHqw612+dOxn0vBJXF6ldIFjs4qrr\nHwuhD1HHB0CFEDswePhXeVGv46OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6DcMLzXUImXxVLfpvJGeIbeCV+wwHwYDVR0j\nBBgwFoAUxkcEZwxwmTEtDwZsoN2cC4gltJUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIk5ND0mkOptSynFxNMzxHP9oI1Z6duoylbYCwHtNVubAiEA8DyI12Fe\nzXBKAvD2QcsKCnxMS3rESj38Xao61rku/Q4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAddYd9fTqChGtcBKUY/kDroyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2Y3OTQ1Ny0xZjJhLTRlM2ItYTUwOC0zY2Q0YjZmM2I5ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBdkvxjGCRl5UEDJHURGLNsGXUeVBANsmMlAu6sRun2jsF\nCgmBdQpPYqjJdDB1XaeYPD4esqyROhcwZjOYnAego2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxkcEZwxwmTEtDwZsoN2cC4gl\ntJUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOBGyHbqZObCtiVfiksui76UMuqLgVYfGUKfxyKZv33WAiEApES4kPoj\nFxBhr8EJJDstTlx1Yk6teMdE1NjpOpp7d04=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAX2zxA/OiFtgZo8twSzMvRkxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQwMzYxYjYtYTY1OC00NGZkLWI1OWMtNjVkZmZmMDM4ZDA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MmRjZjIz\nMS05ZGFiLTRlYjktOGMxZi1hNDYyYjRhMDY2YzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARzQCd6OBP9bE05h2gntl001rxPtFgFxGJDvPrJbPno7w0r1dKg4k80\nUSqwWzDxXaWg0RxUda1LzDvfSvacpxfso3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToNwwv\nNdQiZfFUt+m8kZ4ht4JX7DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA075+C0hCfvGdISXs0xESmFHCu+G7e7XeTBkSCRYthBcC\nIE92Vs+BXBmp0LGEIsoqUjVUFMo6GIos9EYRQUesCA4u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1773", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1773` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAe7tRuz5dEOyUddPwplG4EgPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NzA2M2MwLWM0MTItNDJmOC1iMGJmLWQ0Y2NjMDE3YmU1YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI1YjU5ZGUtMWVm\nZi00YmI5LWI4NGUtNTg1MTExMmQ2MDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5pGPGMOKuW4rdudvLz/D4VewQOUI8zbexMaEyvQ1DrC72qQDTq8BzCNkWoOi\n9aBUC8rsmA1epnvW9jm4ZXnKAqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoG8gusCuUZFDgjIrEMMDsEYeohQwHwYDVR0j\nBBgwFoAU/9sJMpZLy4tqLKovqjs33/kfLZIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPe1iGAHxUtP3tE0xq3NMVSQb06tvFB6c1kXHDXx5LMMAiEAp8kUc0SV\nuS1hh809GQFwv3K63kTxRdhThKi3erKRejc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe1cg42FOMWsDccX+y0i0yPfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzcwNjNjMC1jNDEyLTQyZjgtYjBiZi1kNGNjYzAxN2JlNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTc3gYbaXG0Ib32ilWViYmLDT3XeDF3TjEQqS1Wq9Q+xt9\ncoL1JbH3+Ecjm3VCjmeQw/LFNYuh3zm5MX66k8+vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/9sJMpZLy4tqLKovqjs33/kf\nLZIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIFYLF8hGjZrWKiWF+qzsqGHAnfJAyh3gO23bE0uc3wkAiEA+PS0PaQA\n34grnTBtch3j1jxU/SBVGj57at8wpqdWSoE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAUcN90lYvdWBNahP3z6zH+esMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI1YjU5ZGUtMWVmZi00YmI5LWI4NGUtNTg1MTExMmQ2MDcxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZjVjOGRl\nNC1jNzMzLTRmZGItOGE0ZS0zYWJmZjc3NDc2MzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARveJF6eeC/oyT2XnmLQvj6yHo7/IfnrkEz6WaKz4BSf/MWjN2k/duy\nRhZV+DCi7jCAETo+3xOPhwbjMKFXTO/Ho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgbyC6\nwK5RkUOCMisQwwOwRh6iFDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBBF9m22a30Mwyxblq17mU0pCYTXXO/ZWoFIoMjLJuBbAIg\nMTvLHZUDB7nTzamW3h1Z2KAmzFR5noiefGrPWwnTKTc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1774", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1774` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARSzZJfjPktNmyYZeDbSDSfSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwN2Y3YTAzLWUzODgtNDlhYi05MDU3LWYzMTg0Njg2Nzk1ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBiMzJkMzgtODg2\nYy00NmFiLThhYWItNmZlZDViMjdhYjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuaHT81heuD9bjnozlu98IptEkkHcX/38qvG9pmmCivx8OAUYrMqn41AvgRdF\n9hkbvLAoKrZRTMfRbOKyCTi3RaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4jzVyY0BCr7YC2fAfHzOoil1vSswHwYDVR0j\nBBgwFoAUuYKB3B2n305qQMY2N8c+H0IKrBMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQD+WOqUN+UC2/lektGdpZYrJso6VTtcIkT+miU3W+3ZAQIgUx1jx8Dl\n4xOxRM6agD7cabo4rLjo7tO7fSOV2E3EZTc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARtCTQ9VAiJGbPJaB4jbWYD8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDdmN2EwMy1lMzg4LTQ5YWItOTA1Ny1mMzE4NDY4Njc5NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6RaGhkC7ygnnT1jCHd3H2iqGPuchGNQK/dy0uAYTQBQ0R\nAqQ5StZvRguAUlHG8Ed799uEBKbMXE8W4Cnveah3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuYKB3B2n305qQMY2N8c+H0IK\nrBMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfqf3H/t19/DEKuOeCs/09GXbJlWBqU0sTOLPYu1lGPECIB0dWBujIzsZ\nOGAjP9OAt/XMDT4zSWd7/uKYyHjc5lxG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAaoR6eQZXmx+RO9Zx1LegDvlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBiMzJkMzgtODg2Yy00NmFiLThhYWItNmZlZDViMjdhYjZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ODA2Zjcy\nZS02OGUwLTRlNWEtODcwYS0yMWY5ZTI1ODBhMTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASp2OWnSdG0mog0XoqNlns0sZHz+Ag2AQqm54ZZHAOF67NH+CT8AHCW\nG+OA7I3WOtDUKYa4E336MVWufAfhaLC3o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTiPNXJ\njQEKvtgLZ8B8fM6iKXW9KzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiAQQ0096iPgfqBfs4Z/92W37cNeeYTBPabNzH4PdjA7xgIg\nMKFTyb7eqICS9v8kG6+u+KSJ3JM8w54hAf+xHRfzQX4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1775", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1775` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAenASrk4hg0p/S3stoPUeRdjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMWZmZDcwLWQ4NWYtNGM1MS1hMDI0LTBlMmQxMDY2ZDk5YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUzY2MxY2ItNTcy\nYS00YWFmLWI2MjMtMGJjNGM3MzRiMmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnjwd28rP+dxFeW4IhnZ+AjjpbWUsx7R0/nTmmB0P+WH3K2CnobDscz3Ul2Sm\noxSJd+pJnJVmQYjEXpmUC3bn56OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWpX63Ww97nQUOhXEmgml7pRFoCIwHwYDVR0j\nBBgwFoAUn27cR6FA4UBKjXVe/lKFjov4M6MwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGBdAvmQPghK1aOCG6WUr54PUBbmCirm+a18TPim\npiNVAiEAwStQsy6pXC4In3lUBN6YAgB6SgexC57L1lFi3BXz+JQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWUNKX/wjarI+IjEw/HO2aE2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTFmZmQ3MC1kODVmLTRjNTEtYTAyNC0wZTJkMTA2NmQ5OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKGnso1suJcf7/sGdAspfOCgRIY8Y/QmVkoCoCQqK6IKSs\nm69fiYi5/eRe7Hnv0wm24dEPzAvl5MefZpM3dAJGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn27cR6FA4UBKjXVe/lKFjov4\nM6MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPNyLWXl6pAxcVypqQ7iTCZ9NI/Q/IV3AQ5k35ODl+m4CIQDIP34mRNBE\nAfY130lmjr2kuiBvcoDcYX8S0fkQ+0sv7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAaN8lnGN1e/oGWiTvInw81TQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUzY2MxY2ItNTcyYS00YWFmLWI2MjMtMGJjNGM3MzRiMmFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NWY0N2Q0\nNC1iM2I3LTQ1NTUtYjZhYi1jMmI4MTU0OWEzZTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT51zhwMR6Mwps4g8a1WxdHlqz18+vB2Xk/3zyk2oLZ9ermsKG3vpiq\nCjF4ATHtACPznOczAW+h/TSjK662ARQpo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRalfrd\nbD3udBQ6FcSaCaXulEWgIjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAsDdBdYfzdKBQ0M7WaX1WBk5FmtZBtfAUJpSGd1upZCEC\nIQCexGwyH1Z313RpcLG6SMn4e1PXYiHAtjktdSt9q0vkkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1776", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1776` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAcsN+H4ZmJIEiDGRwuwaaw9MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMTUxMGMzLWY5ODgtNDlkNy04ODY3LTU0M2Y3ZDRiZjQ3OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDM4MGQ2YzctMTI2\nZi00YWZmLWJmY2MtMmNkNzEwNWYzMDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElz2sy751EDqpdjJJLuDs0WCnS/wyDoaiErafMwGN5bxduQOc8Nr9F/fs2f1T\nAwEN5E3RVEIFsMe0PyeCdCiTfqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpTBNX9h7v/dclC4p/Xhuay8pyQowHwYDVR0j\nBBgwFoAU4tNzzOMr5xQ/DstBRO8lSVrsG0wwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDM4kYItqWa5PUMmlsD2IsPpLFe+WZtbv46xFTH\nw6wilAIgX7i7y5QQp0+WnGR6zmjG6hyUDRcFCVQ7hnnla920DTo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVXi26EWun0wq7a/oncuRB3MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjE1MTBjMy1mOTg4LTQ5ZDctODg2Ny01NDNmN2Q0YmY0NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy0U3bTexTrgMi2nGjR9oow4ML8CHqgTEFjtEayien+DVC\ntUlJdTmesMd+TckpWypqVjsZrjiZo5Y7aCKySNhso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4tNzzOMr5xQ/DstBRO8lSVrs\nG0wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALnvkT2sX42a+s3ewUBvqBqNNLiEDPzFFiecVGOXlp2QAiEA8SKgTEoN\nNSn/qlv7aPWoiPxtYzy+5puYs+eHASmbKg0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAVsb8rZbwyFA0G4hP0/euAhAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDM4MGQ2YzctMTI2Zi00YWZmLWJmY2MtMmNkNzEwNWYzMDViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYmQ3ZmJj\nZS02NGEwLTQyZWQtYWNkZS1lN2U5YTMzNDA3ODEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQxrjG/Ybvo8Gz182YS3Z69teN+CmndZ02Tplg6YcwSmz68HORpirda\nSRlCRnIQsUYiqadAIf2JGcBNQAtOdJbRo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSlME1f\n2Hu/91yULin9eG5rLynJCjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAvWacCShZWGiCE9WSrZVSAC0Vnje2WkuLrsmFBEF9ZDkC\nIQCfRDBq4xQ2Um22NejGoLVYQnOImz2oL7owXcyPqPc2Lg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1777", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1777` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAWvJUyumlFSJmJdE33wXdhYgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjYjc3YTIwLTg2MmMtNGUxMS1hMjFiLThhNWY0NGM3YjYzYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJlMDJmYWUtYjI3\nNi00NjMxLWE4ODEtZWJjZjdkOThjOTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyHd4/NBFkK8BCC0/cR2Mzj3QoEFKQ5xLDmsRrgXvsyyBRTHNUbxmxeW04q5u\nw8Wq2poYnpV+tcbCFvzOIUQvbKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULO8UN/eO2elDoowVhJkSvUcp9x4wHwYDVR0j\nBBgwFoAUp3kOm0rIfq1vUuSW0uVJR/MK12YwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCICm6IgJGGBN8sAErxmtr+jn/ykR4nmFpKEqhZWHXeR8tAiEA\niwY0VlKblCcyL4OaFAwU4sOT0BT7ZQRV7EYo5bBnCxc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASc0IhX9heS3LGVBW13hGwIaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2I3N2EyMC04NjJjLTRlMTEtYTIxYi04YTVmNDRjN2I2M2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMYwJMRK2iL03t/fp1Aw6WE8yyi6C5dzXevbU12Ga0KHnZ\nV7cSKfyd3Rzf6DXm/kyKAFVNj4/x7PIFCppEy5OJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp3kOm0rIfq1vUuSW0uVJR/MK\n12YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSgA3JCn4PKQ7i6SUHm3mhNLIqla47CQ/0WU65ejUIjUCIQCcH7cG4U00\nJunEarmO6ivZA2NAKti+LObfx8+EBknmGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZq/k2heigYPoI4iDjAmBeHbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJlMDJmYWUtYjI3Ni00NjMxLWE4ODEtZWJjZjdkOThjOTViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NzUwNzU5\nMy1kYjVkLTRmNTUtYWZlNi0yNmM5ZWFiYzFkODEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASboe+p/mGjGyQ0Rwo18b0a4q6440VV+7gyC7cXySvB0qH4y02E7e5y\nGcmZVJ3sKX3R+7uIr4P4L/0mo7A2lGnwo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQs7xQ3\n947Z6UOijBWEmRK9Ryn3HjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAuJTcntFRG+21oxaeh17jiNnvtxKiAsbgUbz5kPoW5twC\nIDgW2pwgc40pLJEc8fckLiMUKNao5XGJxUcRzB99V4d0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1778", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1778` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZvM0PGyypp9YlX1Rt9mXsgnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MjRmNzA2LTVjMmYtNGMwMS04ZGUxLWJhYjE1ZThhYjgwZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY3ODk5NzgtY2I2\nNi00NWQ0LTg4ZjYtM2RmY2M1OTIzNzA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsMxtDEcpuGfSsJl5wVT+QzeaGCb0Em8YmXpa/7vpy0eapVC9ownejkIJ0EbP\naglxH24x29j27VUQqrRf6BjoBaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaIAvJpDDrdiiwO8RLkDOidWrYVUwHwYDVR0j\nBBgwFoAUXih1LtTPI8U1Ke1CbsKPHwU9pSgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGLH0T2UDe4jppT3QRtyCTGsucJwUocf\nbeNxlKm/5OeZAiA1SxNxHjMWgpHPmBzKNTpPKS9rMl19+IB5WeCIENl0mg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe0ox6UPIyPylkaUAP/X1mDFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTI0ZjcwNi01YzJmLTRjMDEtOGRlMS1iYWIxNWU4YWI4MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASn9Ibr0TzTDr46BXKuEjicuPbeSWbV41YRe5vZtW+WVrq8\nmIJPyR5TCHqwh6Q6Eh6gz5ib1rq+aRFTvJzs2Zzao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXih1LtTPI8U1Ke1CbsKPHwU9\npSgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALj9yZGdRFsE/oVWcDr5rLBG4XJ8xki3GKap/ED2am5OAiA2V6n2yWKP\ngFkyLARBudn/RxXCssfzsteuZctArl1Fow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAc6IWQlyFqqgSxfJjF07fgq6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY3ODk5NzgtY2I2Ni00NWQ0LTg4ZjYtM2RmY2M1OTIzNzA4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNDFmMDU5\nZS1kOTRjLTQ2YzItODk3Ny01MmExZGE5MjhiYmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATjszxvs8kyWresknWVzxLt/pUoCMROiy0xwaqHo1aJqhRpEbF80k52\nLmX0E+Di10aIUNfKKeUE8bKCsmvBXlxco3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRogC8m\nkMOt2KLA7xEuQM6J1athVTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBMY7ojPI/BtOqkHAj1eF/YlW1qva2fMRf+NuiV6j5OfQIg\ncbB6RmCpNars8HoFMS2qBh1s82Ub8foSzra8s6xVbWg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1779", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1779` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAe+8z2uLav55+Yqfx6sylj5fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyZGZiN2IxLTVmNGQtNDI0My1hZDliLTk4MzJkMWE0YmM3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQxZGVmNWEtYTAx\nMy00NGRmLTgxOTktYTVhOTI3NzlkMjdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXvtnfBlSJ7CEoLnjbsTLt7HKVsTtPPpfU3CIDfOm2Tjrk3mUpJyImUifQIv2\n/Riq7iZ/XmKDvCR3ts4gDSG+pKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSluAzoxiEGNemW1BQjfUb+wBdNwwHwYDVR0j\nBBgwFoAUHrxxBByut1TDpySqjl6qHz3ZSQ0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDUd2YM60ZUJ6mQmZHdX6K+RsZg+g+9\nQynSEc1wGyPbsQIhANlIfSWyVME+dhxrcdi12JKwPp480c4kjNG3nvmwGQjn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXhP3NItP+YvKxhVo0Y465DzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmRmYjdiMS01ZjRkLTQyNDMtYWQ5Yi05ODMyZDFhNGJjNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsUV303g58Ok0wSjIq9VcE450RxxNwvlP4bZmEHHUkXNO8\nbRCCnfNnyo4jZ+cEmG/y+UdxP6Be0YVYVir0Mhnio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHrxxBByut1TDpySqjl6qHz3Z\nSQ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPmx4/Za4Ni3YHt0hrt0TYWhYMsc2Y6/+4THFsjhroRIAiEA+rYyBRYJ\n5E9aQChiinoBVAu0k1XcBRCnys1M+72qoXY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAc0BRXHG+SrFrZgZbnZTQCVnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQxZGVmNWEtYTAxMy00NGRmLTgxOTktYTVhOTI3NzlkMjdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkM2UxNmVl\nMy1mMTA2LTQ5N2UtYWJlZC1mNmJiYTExYmNkYWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARBttggdWHZQWX/eUaoCMnQb1vD5SV/LpiwfDeniZD29oRTLiSeGCVA\nB72W9i7dM4jHFXLiZB5ffGVK7QWSWoGno3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKW4DO\njGIQY16ZbUFCN9Rv7AF03DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBH8BpDCpi30PLWoD/ogH02tkeI3Fy4wxshZi+ILDoNOQIh\nAI7+mfh4S3IRaOLK0FyHtnDqnDk3J7Ff7X1rMzPu2x5W\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1780", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1780` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASWLVMjFonKNMUz72kEtIDy/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNTU5NTZmLTU0YmMtNGU4NS1iYzBhLTc4YjFkMjMzOWIyMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg1Y2QyMzItZDIy\nNC00YzEzLTk5M2EtMWEyOGNiZmMxOWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHmRwVCoyMtHMbtnX7fWH0fgkHgMlx9quh1lYQMFxvbDugKeP5Z9DD6HjavjL\nX2qwNjfpg1uu2kOQS6wx+D0swqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6cvF/Mio9qJQ7ydV0VCPZbgv5wEwHwYDVR0j\nBBgwFoAUiLYXgIzZjaUcgkGDQ2YUTtjJP1QwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDpjRooA8to\nuwm0Cwhnlp7DsW0EOTlhxPkqDPXcT4H1uAIhAJaUhmhavH7m5a8GypZmZuQf4/GF\nIoTsgLWRsnub2uIo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfMY7y5564zXv79RWyqZh1/1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjU1OTU2Zi01NGJjLTRlODUtYmMwYS03OGIxZDIzMzliMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrsGcIlzLBbp03J8/sJkh3Qy7Bp2vsrSaxBBE45nWAtei4\nm84chdaew4g6ssElo1Zx5YX8s/PcKh7B9xCC0TDzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiLYXgIzZjaUcgkGDQ2YUTtjJ\nP1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYjJ3WCge81K5tKjL7xTG1oOCv81CQ1xnD2eLzcM1szACICX6tVWGmyfX\nbk5zpAY6uAukX6Wv9BJZVKYdl7ujA8X9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdHZhVq+xcfUYfEUuNn3tlNmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg1Y2QyMzItZDIyNC00YzEzLTk5M2EtMWEyOGNiZmMxOWUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZGJiZjlh\nYi1hZWNlLTQwODQtYmExNi00NGMxYzhmNmVmODAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATaDy1c8tSpgyiHiiHU6uzRcmCDp+oPIgeDzCgVhJCk8c47kbkD/KlX\nNTQsjmsll0mdtsl9pgOmcCakseXrDskdo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTpy8X8\nyKj2olDvJ1XRUI9luC/nATAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA83nHJJUX4h4gfYh62Hh+/WCLX/nfe1oLn6sWt8TneywC\nIGsbK/A3Z67tKm2Ny9C/E23HclldANlZxAvf565CXm8w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1781", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1781` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAYmTFJr7y6zHYeoAYa4fX4dsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2NjRiYTY0LTY0YTctNGI4OS04NWMwLTFlODAwZmQ4MjVkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQxZDVkMjAtOWQw\nNC00MGE0LWI2M2YtZjhjN2ZhNzhmMjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7vyvz8nlCheJGU/Qe9RRFbWW3fnyAWhFGUPFYxmTMvMibL4tXgSx1G9tx6j8\nra9VqwILu/UrQ/arBzHvca/MLKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmufOBb7WsPSdwD3M11+h8LXSXVYwHwYDVR0j\nBBgwFoAU+v1XBp+lNEZTMRkJAgJMrhl4uCgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgGBNrqX2uVXUabZTJLBEv7f/iqGlyiU+8FUQ0q1VuOkwCIQC9OkiE2tOG\ncE6Jpu4TYuqePrv38WYHrwoIEMKrKXlANA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUZkKyWuvH2/34/ziyLOU03yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjY0YmE2NC02NGE3LTRiODktODVjMC0xZTgwMGZkODI1ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbGOxm/huz3EAy4r4YO4OmS3arD7HT0juutygB0djCVVC9\nQSyQnlj/xyLj9wWxFtT/9XltRprxZiuRzBSrqL3Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+v1XBp+lNEZTMRkJAgJMrhl4\nuCgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMeZLYLjgKbAHGapsx3oXYFR6apfPUGd5H8R2m0MkX3HAiEAmmisbzBT\nzCpHtWpJhMvNBKfrXNQUcE4EI/QIin8clag=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAcVfWbd2SjRECfMzjRx8rvoQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQxZDVkMjAtOWQwNC00MGE0LWI2M2YtZjhjN2ZhNzhmMjlkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZjM3MzY4\nZS1kZTZhLTQ1YjQtYTU4OC0yNGYxYzMxOTM2YTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQrg3B8tF8Syy/VPCZlFwsNZpS/m4FsIL16EY1Tw3/iCSSlNqkprCMg\n/aaIyP6hwH243yP/9UXpQkGFvCUh00Pho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSa584F\nvtaw9J3APczXX6HwtdJdVjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA9F4binVFEDsjGRm0AyKInmfa6FEJD46OtbjrDNK7OooC\nIFoaSNUBUD/J9IKtbcrHBRje6NuiWOn6yZtnq2KnDZ1f\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1782", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1782` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAaQwRakKlGsKrY1PTUXrfF29MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmN2ZhZGIxLTJhOTAtNDUxYS1hNTA1LWVmZTkzNjE3ZjVhNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M2ZWZlZDctNTBk\nNS00YWYzLThmYTAtYjg1N2M2YzAyOWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr/klu1Kz4m3uM71eY4uKbgrxcLQsDbh/kAJ7vlXGLnJpGpBLlnPHV5+mTEqV\nAtZrf0JGcKIumrfWLq/6lnJERqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU40phuA6pSpThu/eQeryAhknm/9UwHwYDVR0j\nBBgwFoAUkIKygEkekXLAAtBRRUH9VngrCeUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAOw/yJ18CpSmZQta86ub3PLcK1SPLuloeYN4/51W9JewAiBVBcXDx6dV\nHUrBoJUSjUtVbUlXgmH2evRbAzHwSqLVSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATti7tmfAIbjyWoox3LN+77LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjdmYWRiMS0yYTkwLTQ1MWEtYTUwNS1lZmU5MzYxN2Y1YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBwGLYcWY2AaSCU9E8V/X/dPuOi0IkWMGeDnMNEgDGYikM\nsm9XutioPPVUcoPMbjQNnZSAtgW4Azy6cCosdfr6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkIKygEkekXLAAtBRRUH9Vngr\nCeUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMWTgvxciHAzuD/qrIzgae4zK4KEA0Pd5dQZZQgeKj6oCIQCDsMdtlFhH\nXvZ9wmw35fnPhWW2yO4Vsf4uFIWTDvKhhw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAanCld4m8Rmf8LLyUvN4yLojMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M2ZWZlZDctNTBkNS00YWYzLThmYTAtYjg1N2M2YzAyOWE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1OTBlNjM3\nZi1jNjhjLTQ3MTMtODRmOS0yNzQwMzU2NzA4ZTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATpUFaKFu21T/PLU3vzGDkdSpAr/nKWEiK7XNd7kYXuRZDfXZh7DxKI\njTKn9CZ+k9clyvt0ojMcwPgBC4j9mPG7o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjSmG4\nDqlKlOG795B6vICGSeb/1TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAhqvNRx+v79R9WA2LLhiWuC3Zk+xZEV6oQZ5ny509ijQC\nIGxsKYSbNuOSxFLyjVmCCbmdGQcv8XuoOOqQFm+Ra8P/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1783", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1783` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAXGY0/0RDRxZdoMnv4UTEwUeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1ZWZmOWVmLTk3NGEtNGZkYy1iMjI0LTRhZTI4YTI1OTY4YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE1MzEwNDItOTlm\nNC00MzYwLTg3NGUtM2JlZmU4MWRmOWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3nVAIVeGT4+pJzDdhjrvf2GJwbpZVnInoCeR6mNFDju2aUqKWQE2ctF8P8/Z\nBqstHLHJr8ZkY+uISj2dcBEBNaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCQL0fOPj9o50hf1nDEBIMhHr66gwHwYDVR0j\nBBgwFoAUsUrbBsHGa5+N+7i3NqTaLyiI5p0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIAutMJyPMy8jpd7oFCoW66vFlOhuGTkyw0tC1fcikUIBAiAFLh5MBq7J\nPr12L5byeyoHtHlGm6hkTfJ8gv8tZ0ipUg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYBPLDPfd7gc9wl0XiqiC2nxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNWVmZjllZi05NzRhLTRmZGMtYjIyNC00YWUyOGEyNTk2OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKq40QJm1PYG2We6g0PTRDnWxpTK+FeFmWCX5SVmfTfSdf\nncXAMa3hpZe14AkRuQmsw8esta7qH6UK1m9B+gt5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsUrbBsHGa5+N+7i3NqTaLyiI\n5p0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRZtXczSngd3LAJ4pUAOw52vwN8V2scKAw6F/9JK1+4gCIQD0+yMpj13M\ne1EaWYsvfFzB3eEyyGXbYCG1ixuimCpLFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAcoxinHID9dIQWl0fCkYXbsbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE1MzEwNDItOTlmNC00MzYwLTg3NGUtM2JlZmU4MWRmOWVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYzE4MjQ3\nNy0yZTZkLTRlMmEtYjhkZS1hMDA2NjBiNDRhZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASaVnjzFe/PRmjUG/idpE8jzW1HjY5Y2L/7mc65fBH/4rbS6dMT8qjL\nA2ypVZL1qAx6HJuatq9WgGAlVvwfXhoKo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJAvR8\n4+P2jnSF/WcMQEgyEevrqDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBQakBuxOE9qXnh+12hxTznly90PHPT9jtX0WonB4c7SAIg\nMnRllONZ5Sr3porfuh/s5o2Ry6OBGa9RyKeg21+3CYY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1784", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1784` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISASUFpgI86/gNHB5yOZjVBRunMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMDMzY2YxLTAxOTYtNDM1ZC04OWM3LWQxMGM5ZGQ3MGNjMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc3MDM0ZTMtMTRk\nNi00MmJlLTg5ZTEtYzVhMWExYWZhNGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEClTkcSk18hFaogwug8UMwPmHL77EAqACMmsd1koIy561yaf/Day+FOBmM9MF\notawzesMgL4as6TaVia21HanhqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqHmMXMGXptQdbiY6pxDshiWl1TEwHwYDVR0j\nBBgwFoAUCmn+1Lyrtai8ZVtuiVxUU6Pd4KowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDZRJqzfuocNcW1DIIwWZLCQquWM8AB7EfSa+Ue\n98oq9QIgBNBT6I0hzaMWcdJvsGgBNOfgWMh4n/ek+ZmsJ3IXjPA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS+U6+Ya/UEWtmKv4dLKD6tBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTAzM2NmMS0wMTk2LTQzNWQtODljNy1kMTBjOWRkNzBjYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJDJREPO5NW7ctb0HylnCNOXI+kp/wNIsSgMO9+ri8FQfV\nBPKMlxvwYJFIOSKiP0CI6ml4v/3yZjPXBbnzJC/jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCmn+1Lyrtai8ZVtuiVxUU6Pd\n4KowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfWtjpYobKjPcMZgo7modo4Xzqjo9R/BtrZuv680zb6sCIQC1Y8fUaRXh\nmFzTv3nTDJk7fHbiusMDVbitD9kY9SCXSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAf9cU55UpUIa/FclYttuIEtrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc3MDM0ZTMtMTRkNi00MmJlLTg5ZTEtYzVhMWExYWZhNGE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMmI0OWFi\nZS03NTM4LTQ3OTgtOWFhMy05OWZiZGFiY2VmODIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASBK9rJ6rcxTyW9u5mR48Ua0THD3wwvIJrurW7/8Pb7kmFED24ITAa6\nZkQvarH690Wwd/mhQUdK9OAUDN1hD+Jwo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSoeYxc\nwZem1B1uJjqnEOyGJaXVMTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAkK0iDBE6KO3bODmoLQxwzoB/53LBaVdRgef1YcUWJYgC\nIBe/PCsxYGKoVPvQh0gNkq2WHYEUnyStIA9AezRANWah\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1785", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1785` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAb5rQgrqvq8f8r090awOtp15MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiMGZlOTcxLTUwMmUtNDJmOS1iM2ExLTU5YzZlNGI5YzBhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM1NWM2NDMtYWFk\nMi00OGQ4LTg0ZjItYzUxNTFkNjg5NGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJaiw20xkEHBFGrmFEzPfKRhb8RgsEgaTDhRVHXAMYn5wfNvQjTidNjWlFNwb\nwxCRqCeF2GG9uDKT7IlER+LaP6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ72lRNDvm1EZ4b1QlXGYQKkrwzcwHwYDVR0j\nBBgwFoAUMxqbPNG94RB+5fIRc4PDQ0Xp2vAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDS3BtS1ZlLNMg7Oks0IO4Efdzvoupvc7J+0BFD\nBGtJ9QIgX/iVVsHSv5wsk2ke29XqF1aP5sP83f5zHUoUAAXQYeo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV3lnb3l63LztwD9fJyWkoTQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjBmZTk3MS01MDJlLTQyZjktYjNhMS01OWM2ZTRiOWMwYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmUA1f38HyCNEVs++8frI5C/Tpp3IAqUy6FBvd2SiPV0uH\n9gl4ygSit+4VYv+HSDqRq+iIXu4WOFqkpVoFnSCZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMxqbPNG94RB+5fIRc4PDQ0Xp\n2vAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIsjn5LHY4glbIM/g5/oOS4HzmkX3y8SztH9yHxf8m+oAiA+phv1G3Zg\nCtBByIFr9jYzqCiPORQR5/3mzOBqtbVs9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAe5rvuxdTD0q+6uazZT9kHZeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM1NWM2NDMtYWFkMi00OGQ4LTg0ZjItYzUxNTFkNjg5NGU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNTU3ZTJj\nMy1lMTY5LTRmYzgtYWYzMS0zNjNkNzE1NzI3YWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQNdMjkVnI5lZ81XeENawz/AIHOLCDpa8mE0vG1CAG2VJRiDLKqHZAA\nwoI6+puU/BEfxpltQkoryf48qGcRT+bJo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRDvaVE\n0O+bURnhvVCVcZhAqSvDNzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA9o/fyP2ghhRBVPHWAHzO7LexwXicnGolkBPEdD4nwKAC\nIAvaDKDBGgxXITLGU1LNWhQ2FPRJ/aBxjnMaOwMQyXHu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1786", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1786` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYgIX1mbYJFvi9MxnsduYIzgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3NDExN2U5LTI0Y2EtNGUyZC05NmQ0LTk0ZDg3MThkYjAxOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWI2NGM5YTUtMzU5\nNi00ODlmLWIyOGItYzE4OTE0MzBlZWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE461LJRnb9ihc0Tp4v3wGnMpX3h2wXtNO4KuFWJJzgbF+HuP9R42oFP94Joe9\nnsWIqffof03laKMuFazDSFFhZaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwAeBi/hYO/cYHxzGQnUX37MfvKMwHwYDVR0j\nBBgwFoAUjgrtDHKOUFpsJBJgxCRHwL9s4IMwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIFSAuUcUCssWgjm0q6g1/evjO6BEqfsPbmKsR8s0ROVFAiEA\ns9MKGNv79DN+jccvZusuX1YnD+OiE/ZcuMtoJKFmSFI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAThKo5j0siE35gJaVVMYJ9KrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzQxMTdlOS0yNGNhLTRlMmQtOTZkNC05NGQ4NzE4ZGIwMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS+nYUhvHrJ/7hXNQZb5tHy9sUH2JQ3LYy2S5hVUncJoxm\nrSmcmgDoCwMBHGZ5g+w8A6wh9a6158jhSmbGD71oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjgrtDHKOUFpsJBJgxCRHwL9s\n4IMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW6S1qZMzL/YW+zBhxy9YY4OXF0GkYXbI7uFApe6Fi+sCIA3vLplew63k\nmJE0kP4MCmm+Y9IMTTPO49M/xdeZzcRl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQj5ej6OEL/CSQysL02Qf6XvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWI2NGM5YTUtMzU5Ni00ODlmLWIyOGItYzE4OTE0MzBlZWE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZmUwNWVm\nZS1iYmI5LTRkZDYtODc2Ni1hZjg3M2IxMjE3OWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATMYee4u0dYE+A+O7VzTgLRHyiqykIi3YSd4nd1J2ZCXIaoYC04nQly\n5Wdbub1WWuUsVHvKs0Pt87Cl6qDNmjl/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAB4GL\n+Fg79xgfHMZCdRffsx+8ozAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAkDiN9WbAKAoUf9XARvTvTClHD5P5waor6wDm0EhFeC8C\nIFmytZPIFq8RCw3PeLJ2Zl06bKsb2L5uyGfk0n2Xb/X4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1787", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1787` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAbApjTTrElxeEJhQB+j793VyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2NDIzMmZiLTQyNTgtNGIzYS1hMDcwLWZlNTZmNDk3NjUxZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU4NmM4ZDUtNGI0\nNy00Y2EyLTkxN2MtNzc1MzU4NzcxMGVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUdZ8A3bMcfGAFOBASxKi26GZAuO4bojAt+EqgwdFp4Mo1M628HpkULy03d7m\npjiRTUusuSjcmFxgSluJzRxHZqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcwiSNZx13kFMzHINTvSHRuAdKrgwHwYDVR0j\nBBgwFoAU0iBVC89YUdpvoTzVdVqwOeuP3hgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD/DbpniEdAnin0QQOCl5sKRVwzFzQO\nTly6yqbKz2jeGQIhAJxmcPldfUDXIOKp/I/9SXznxLYM6JVePVec+GCdMQlD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW45OLFbKSTALYWBH10onAYOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjQyMzJmYi00MjU4LTRiM2EtYTA3MC1mZTU2ZjQ5NzY1MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAzo18mzXj/Lfy3roidiA5g2Jax93ncvUv3SJf/NcHhdjo\nUp7ZCd9Ot/GOk4oEBJmhNLugJBl1dCXnS7wViKtHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0iBVC89YUdpvoTzVdVqwOeuP\n3hgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBC3o9a10J8mK4fHpBNWi1zmL+HOyFJXZk3sSVyekk9sCIQDKySLy4bI9\nmeYLufhHVkLR/pfrxM9YgExBT58LoviTxg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAasivMMmXr27udxZuP2MRVypMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU4NmM4ZDUtNGI0Ny00Y2EyLTkxN2MtNzc1MzU4NzcxMGVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3Y2JjZThl\nMC03YjhhLTRlNDgtYjEyNi0wNTVlM2NkZTYxYTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASGnjXzTnDD9zQ+Eh1c3bbj0ePi9jm/YthreAQDeL+TIAY2nTCibW5s\naY2lmNYkdiC2BJ7TlIBIQLWCvwpdX36yo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzCJI1\nnHXeQUzMcg1O9IdG4B0quDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBej1LokIP8z7earYnwo3hp+FI5BGMogl156y2DaZzb+gIg\nNmny1/0oTXc9h9aBQnNHnKVobJceBiDJ1l/SDJyy7/c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1788", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1788` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAR32rDQk+GufmiFOE6UGn2AdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YzZlZWU3LWRkZGUtNDUzOC1iMmZlLThjODBkNGE2NWMyNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWEyZmRkZjUtNzgx\nYi00YWIwLTk2MzgtY2Q4MzQ1NWRlMTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqVGox2GFydORqfIM4BWu+QgCZrutqcQaL8b9CUZjSlzcO4F8NPSICA7zEcYm\n20B16reFLfWpZrQutrixetqkL6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUehxFUiCTYFvqkInCDiPSGxd+fYwwHwYDVR0j\nBBgwFoAU2cWELCBPDLgQIKJcwVHN9IJoYY8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIHIHD4MCVgKLG57SbyA3XK6jhpmeqUzL\nAetVX7fIZiV/AiBHEsdVbRPcoYmnNlWrDWHZkuabvTHjAtrWo8gfYXQgkg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAawtKp8k63/cA5fHCZL4nSHSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2M2ZWVlNy1kZGRlLTQ1MzgtYjJmZS04YzgwZDRhNjVjMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7HZv6oBR0PrHgoe03rK+v4+wfSbmBwCgzw2S67qFpecPA\nR1/DDbrY2h82VQBc93n89bN5Vmj0q/ThYT5n8P+0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2cWELCBPDLgQIKJcwVHN9IJo\nYY8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHRxB736aAEEFTPl/F0m/X5k832q+fmuDuuTVzCQexB0CIAJXNHMX2puP\nssXWKAW3bWG/fJZm04UFNnDo0e1uLWZo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVVRkSGDbrVDyu9mJWjYLplSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWEyZmRkZjUtNzgxYi00YWIwLTk2MzgtY2Q4MzQ1NWRlMTA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMzkyNzUz\nZC1iMjhmLTQ0OTctODMzOC1jNzFkN2JhMWY1ZWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR9Oe3R0wARwcxRR3RwN+ImR9jS1uT2yB8l4FywwBblCuxZFO8E27ll\np2Kw9rUoqDQoeihOjPQ+5C9wPIPVbS6ho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6HEVS\nIJNgW+qQicIOI9IbF359jDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA6uP4G0NVVF+1cUcsy11RBCa9pq9fcQ8xW/2AsGHcwAMC\nIF+IHga/ggAjf1XwMOwQXzngLkVzF3OSlZXamB+fjSX8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1789", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1789` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAag9c+r8iIgcDkSQo5MONLjHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ZTA3YjZhLWYzMWItNDdhNS1hYjUyLTE1YzRlNmU2MDFkNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2IyYTk0MjEtZjQy\nNi00ODEyLWJmNWEtMTZiMTA5ZjM5MmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3bnPGeNzmJWWkhfKs8N57cC+FGLefy5ZiuGCYDj1VSIMgxI2jGrgJx4doLYP\n5QFsOKnk6t+aj3QPHuGzqQUXlaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOmo+lX4vhURJI6Uk+FL/WiTSdu9MB8GA1UdIwQY\nMBaAFKr8LIZseEu1DoaylzEkVYPe+JewMAoGCCqGSM49BAMCA0gAMEUCIFn+tX1H\nTkli3HV04MsN32jemhr4gydH1p39SyCmhy65AiEAmlURvQBUpmw9009gps/WOAKa\nxp1gdTSlU/sMnkC1lCE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf73FdM2X/aGUrrP9bdkLJORMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGUwN2I2YS1mMzFiLTQ3YTUtYWI1Mi0xNWM0ZTZlNjAxZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStuusKBlOg0xl1fte24gJpD9go2eVhKaWDciSb1zNBC7mS\niXR0+TLitPI9YLBxvoCtTKfgFioK6o5TDVzonXjto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqvwshmx4S7UOhrKXMSRVg974\nl7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN3Emj4nkIYg2prkOwqTkI1TpjZhyU1oAQrvTKQflYHDAiArT27coIQ+\nE6kUuKqfYQ7FENkM1ZAbfpVs2EzgJ4iaqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAcIFfp8G15NF/FiiemIeO789MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2IyYTk0MjEtZjQyNi00ODEyLWJmNWEtMTZiMTA5ZjM5MmM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0YTAxYjg3\nYS1jZWE5LTQzNDMtOTAyYS1lNDQwODI0ZTBiYWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT67NSOwuiHirrsMSk2ov/nk+EKXz9HnelqRuKuvzEyF2QtSecAqxmV\nZ9iEHXzFsfOFoUrMIg15qyU+a9E4R4Z6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTpqPpV\n+L4VESSOlJPhS/1ok0nbvTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA/momrUjhwo55eq3uZhlZGrjPVQLLWPtiTXB/\nMXwBEQ8CIQDXwOnQhBm86xE39/v53VaNUgZR6UCNXy3Jw8CdiCJV/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1790", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1790` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAc8CMkLuVw2v+83P33OzsCxyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkYTNlNzI5LWE3YTQtNGU4OC04ZTg1LWViMDFhMzUwNmZmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThmY2Y5NWYtODMx\nYi00ODljLTlmN2MtM2Q1ZTgyZmVjZDM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErJT4V0B4V7yPIbRU25yU4oG41dKhxbLbCKadnmDYiWWLKLIx8N4a15XGqc7E\nEyTImlQsmaUXu3gZ+C/8/hfuFKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHgpmaKklAGgXkRuL5lzOqPG+reJMB8GA1UdIwQY\nMBaAFB1Xz/QDzfH7EWyUCwqDtKRw2SEcMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAmTINQO/PaffxE7oEV978okPdZd3+bd6TB\nUCiunuykbQIgUuIVSCWBhfDZSoIBkUi2voV4Yg7eKrvYh2PZsX/g5H4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARhsJGg/PKuvzL/l3u+tzBpYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGEzZTcyOS1hN2E0LTRlODgtOGU4NS1lYjAxYTM1MDZmZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQn4ZIO9L/lZN9vGrG1EO+36dAqmm2vqmadDGp8PuIK0KQN\nq4P18s57LkwVtORpv+6hAdZ/lcH7wM+42ACGV/H/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHVfP9APN8fsRbJQLCoO0pHDZ\nIRwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJHGviR6Nw9QXREIq42HDLNrFjn2v/9GhyCP74kvprIqAiBV8oG1pKF1\nFCOZOr3yvTV9qzrC82L/8z0ZfPI/dkL1Nw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAR4+or+CdnHDRF1k6GZM+mKhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThmY2Y5NWYtODMxYi00ODljLTlmN2MtM2Q1ZTgyZmVjZDM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzOWJhOWE2\nOC0xZjlhLTRlYmUtYjJiYy1mMzc0NzQ5NTQ2MTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARGlGO1KH4i6pCvCbo3yInaFFLk+khwnAZcRp8UwTFTRsrB0Bx1IaY7\nzjJuKg6zBE8/1zJk+Nz+own6FJk2oCnqo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4KZmi\npJQBoF5Ebi+Zczqjxvq3iTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA6bvaAaPf7kw0EBzNFZOpqozc8xOpgUwkPh3j\nxrJKPRcCIDA7AojPE5gbsnAs3PrUV3rL8K/c5vnV0J6NnoV2v7MG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1791", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1791` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAY1E7tAPlaC6b8xy7pKF/kd/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2ZDk1NDU1LWVmNGItNGVlNy04NmRhLTI5MDQ3N2NkNWRhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU4NDZiMjQtZGE5\nNC00MWNhLTk4NGItODI0NmNmNTJlYTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVGgpS/3kO66Qb+8jKj85UFiY8QPT6XY5UlKnEJJt2YLzzsXIYdy7Oo86jVnb\n+FOGxdEdd5zCZ0CDTzEO2U1EG6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOqvQqGc/+bvON+GcwqOkb9sV+r6MB8GA1UdIwQY\nMBaAFLfqQyuaHdZ3VSsokiTazUoof3jlMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBY5fVH3tP/3QCdXYW2ReNB128IaWLPEnyz\nIFVqECejBQIhAIAlucP/B1oEddVvvyU2C2DcwnXUEPpAcq96O40ph3S9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb3NZ9Zosy0IQ3eT3II0AFJMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmQ5NTQ1NS1lZjRiLTRlZTctODZkYS0yOTA0NzdjZDVkYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxUFOqEjPaCBj79FoH62hw9lhiIbP/GJbVM6d+wMwoWKZT\nP9iMQyly7idi+qf4iiJ0wM9Ca/gWEGg+PsaTUXYlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt+pDK5od1ndVKyiSJNrNSih/\neOUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMY7zSrJtOgJiMyQT4ntTxulqK0PqCa4ZbPFKEyrnfnMAiBN5bF1/Q8k\n9/GBwuWt2He9rRKgQr753GA/mcJ35WSZBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAVKuY5ttsrOOy8rjHfiy2jfbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU4NDZiMjQtZGE5NC00MWNhLTk4NGItODI0NmNmNTJlYTViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ODkzODEw\nYS00YjNhLTQwYWItOGM0Ny0zMmMyMmFjYmU0NjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASVF4nRO0Asvu9u39bONhBnALOjte6RQTgVqPVFmsGpT2mDhA0fQZO4\ne5cdj82GwsaPV9cWEbp0FOwKy5flyHe9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTqr0Kh\nnP/m7zjfhnMKjpG/bFfq+jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiATEapaHieS42ug/Hn2ATV444pfX2zY155htdU7\nwqHwyQIgNjaUiv/gLl3XaC76VvtsRIGqPOwH35OmZbuZYkoi0nc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1792", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1792` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWFVcazVYBQE+81JZ5VXLBcPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkZDBmNzdjLWU3YTItNGNkOS04NmYxLWYyYzU1NmNkNmQyNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFkM2QwZmQtN2M3\nMy00OTViLTlhYmEtNzczOTMxYjY0YmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExNaVchymBgJy/UkpUfekvKVBuA93lKk7Mh65mLEmFNKCqRng9wy/P3m/hr1D\n75Hvt7XInWm7KQ9PTwpdd2K1k6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTMbhV5aN7oQxW7vV7GDxp9EasW6zAfBgNVHSME\nGDAWgBTxD9UkIR81NXaPg5Ha64VMGuIbgTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDa+KMdQOq8dwF54rxbUD8nLXezoWAr\nRi/dK0xcaQ3FyAIgMR8XW08sIQFraEo40KLyA9FdQeWoglym1U+v71ywVaM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZj3PF6UkU9sipAqh4gX7cZdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGQwZjc3Yy1lN2EyLTRjZDktODZmMS1mMmM1NTZjZDZkMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUrIjnfirVGf98uA8JFNpO9aw+jl4Shb0DSTJ5Ru7Yvmmn\nnwn8Yu/M6DRW4HJjI3+jokfaBqbawrypZZDxMUdXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Q/VJCEfNTV2j4OR2uuFTBri\nG4EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYgBdOXT622VjGUZ5VC7EzUDWtcXOS0S/rpCjDzZaB2ECIA6VvdpRlRGN\nBWtkVBjg26cO6Gj/WwrGgvLWFBhIVZY8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAT+QfGgbuF7K+S4kfPzbfRx2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFkM2QwZmQtN2M3My00OTViLTlhYmEtNzczOTMxYjY0YmQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YjBhMDcx\nNC0xZTk3LTQ5NjItOWZiNy01YmY4Y2M0NTI1N2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARqWM2KpHRnKGvnL4owsyeidfFwl4210wzVcxmjPjaVp9wOX7dxyjRL\nH3BDXHv8uMFR4WUMJ2FXtAitSqJkL1xgo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMbhV5\naN7oQxW7vV7GDxp9EasW6zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA4rpXFB5xEy/1xsfHmaPbSfELjOdH8G1zwFBs\niA1/D/ICIDH7usUg+4LkgHFmkCShCRylqNSRRBCrd5iiA/+bG4wE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1793", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1793` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQC+rpg8EuNM/QElRsKvbvPoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmNGRiN2I4LTE4YzYtNDJlNS1hODZlLTVjODk0ZmJhZmU3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA3YzY5MzUtMjEw\nZS00NjdjLThmZDAtNmJlZWYwYjU4ZDc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESFBfthBtkYRfpr1Pn8dht7e2R3BbVzDB0Ls4ew1x/Kf8LCqNF623uSROG+qB\npiQJ3gWNk8ddckn/jnwQXL5/VaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUypSEnpRbgt5XmkdVUR5rSI2w3SAwHwYDVR0j\nBBgwFoAULoybBJfiqUxq5OW1R3zvtXCrxEYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA7S4VX01CqoFg\nm3fooRSvzzEC4dmdJyNhFigBVHnVnoACICDUF/0cbcSj/R/HqC5nv4jRIk4CV7Kq\nSFHU5+8jDOtH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdUt7d6IxiYYGtoQp3dELcOoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjRkYjdiOC0xOGM2LTQyZTUtYTg2ZS01Yzg5NGZiYWZlNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyMffKGPUSZrC5mqf/e3RvQzrdCixVxryWVuf6ISZCrx4h\nqa0QGt6uOp7fF3sS5a/BsPNWHoM++y4ONC48Tcdoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULoybBJfiqUxq5OW1R3zvtXCr\nxEYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbTYpIK+lCfwhhVu9bFDocBJeDNY3M9p95lnI4ZDCtgoCIH6DyHAC7T/k\nb6tp5TXzNoheByBFie/m8rykmf90OZ+p\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAU/yEA45TOo6XjNlBBWtt3yrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA3YzY5MzUtMjEwZS00NjdjLThmZDAtNmJlZWYwYjU4ZDc1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYmRjZjky\nOC04YjgyLTRmYzktODBkZi0xY2JiNmM2NzhlNzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASgAci74SkJFd1f+Qhfg97C34pFNoKo4nv22egQtunJe2slCdoaojRx\n1Tw1DIkrforLyZ5pB9sAw2MdujrTvVn0o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKlISe\nlFuC3leaR1VRHmtIjbDdIDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBXww1F1HMICQ19juQOYem5b9P3wiVqmKkJgJM8\n+52vkwIgdFYtXMbytGTVVRjKTmlW19p0Pwvh5YsvZ4+WMK+SdEE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1794", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1794` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWdm9RnqEjPGN7q1Z0Wbtli1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1MTM2Y2UzLWM5MzUtNDZmOC1hZDAyLTViMTU2MTA4ZTczNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI0ODM4OTUtZDgx\nMy00NTFkLWFlNzMtZDAxNThmNWNmMDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElxGPEqNXQa0afI4y2fMMQW2Fwm37OPc6SngLy+oWZ011Ahkw0wOY6qO1YDdn\nDF86WXj4xGGeTnCY+pD3nJCH4qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsJUmHA8jwjYxIGZnbL435AR6c/MwHwYDVR0j\nBBgwFoAURYQvFQx9ZFPw8OdOAukDtaMogykwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAmGY5CGctYDL0\nFZDiApeiLMIaNwGOeH8xLgv2oxc2CegCIBP8nGuqajLYxun2Lwu9dnZuQMKyibyO\nEXD7+DiHBeWG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQw5CeffThbrLICrdUd8zTE3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTEzNmNlMy1jOTM1LTQ2ZjgtYWQwMi01YjE1NjEwOGU3MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASU5vEESOs0JwmXvdeUTHK1zXWMo3/QkIZKHr3UesomtzyC\nnOniaTiBjdMMb1RKrVrnjkSZs/xZVTbIQvimkgC4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURYQvFQx9ZFPw8OdOAukDtaMo\ngykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKhzpXduzEGnZCK0D+7Ljspxsc6yRA9czWjQHICjaPlbAiEAzmWhsg5b\nfX9jGh1NDS2Ya9GoSd+uOUCw7djuJKU9gi4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARz7/jJQvSfqETRny0kYxVRmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI0ODM4OTUtZDgxMy00NTFkLWFlNzMtZDAxNThmNWNmMDY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0YzI3ZjBh\nMy05ZmJjLTQ0MjEtOGQzMC05ZmIzZGJiOTI3MmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARM6VofzIqlg2b180bW0bbovkt1w/zzdCCJ6q9XoMK2TUNt/a0io/Cg\nuqTIhtOi3KhYyp7msbNfnvc+hJULUTFxo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSwlSYc\nDyPCNjEgZmdsvjfkBHpz8zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAbvHwQYT4XHW+wlZvjqpJj41qKZzj7HFkU/S/C\nvZdeAwIhAPDJVl6+0yMZam2oGFRUmPtgiR+3zWakB5CnoFRMXX0y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1795", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1795` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAai7MFwCR68ftzdDpmn8T+4HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZmRkODlkLTVhZjctNDUyMS1hNWYxLTZkNWQzODI1ZjA4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE2YTAzYTMtMGQ1\nNC00ZWQ1LTk0MmMtY2U0OGRkYjZiZjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYXaS97X9Dmt9C7kj7tWT6p0S1OCuRrHGbO/hNLSTSXx29dIrif3JUbbWstX7\n9kJ5K0gW30TslONzoAQ9oM5LfqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz7vx8vPW48LhUobahWDFQolLCKkwHwYDVR0j\nBBgwFoAU39gItsnULEOrq3zEK3zCzxiC9n8wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBnRssqldJ9Blk4BxGwwYTk\n2cGkqxBPV0LtALp+HqQYYQIhAKi3LXsSukvQseDR3ELRB9N5LZzyt/LnU54pCttt\nm2U0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcShK52CMFWG1qJ+poEXPQPNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWZkZDg5ZC01YWY3LTQ1MjEtYTVmMS02ZDVkMzgyNWYwOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2m8RxcUxoq3GoGP3f4oXdwoxNEY11Of8oohyDyvYsrtPC\nR9d3fUSpBapjYVX1hYSjzo6SGRvtrPmGevIAM8mZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU39gItsnULEOrq3zEK3zCzxiC\n9n8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMtaCaHga7kqhKAS3mFQfw6m402Mpmp1PofcanRODcZLAiBTPd+DtUmZ\nUcRGQjMQj5tMVmegH28Y1SrJUBvaJPJjvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAclDTz+n4DyYMtUgX2FAsLdoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE2YTAzYTMtMGQ1NC00ZWQ1LTk0MmMtY2U0OGRkYjZiZjQ2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYzAwODlh\nNi1hMDYxLTRhMWQtODdjZC04Yzk0M2VkMTMwYjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR+sCWLVhFeg3yGocAwk5CU2ks1o7BjsmoDyg7ZTh0CBpgamhXz+NMV\najadL1h0kmfXmJ/5Ts+x8BmGYD6fFHsjo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTPu/Hy\n89bjwuFShtqFYMVCiUsIqTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAvoDHLmxoqLCG+E+EMWJWm2UZ4tQq00bFXAn5\n5W0l3xACIFFLBor50Z4ucaBMnOMm+4qMgkAGrobX+w13+1B0ROjB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1796", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1796` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAV2OTJDO+CKA7uQb5u4HLeTzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiMTgyY2E2LWJhNjEtNDllMS05MGM5LWM0MGY2MjExNTE5MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJhMDhmMDItZTI1\nYi00Mzc0LWE5OTEtMDgwNGM3MzU4OTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElkC7cYKOW6l9oI+YkkAzPkC3ZOF/M4cTb7M7bZBkMfCcOlpf5bS2dt00DW4m\nmUrdz7M++lcqJkGBJ2ZYMsGVmaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUajjC45xTm27dSkE/hN4AZ2080ggwHwYDVR0j\nBBgwFoAUA9sCUMBA4/6aTtrP3JTU4H0aDoswLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBX5HPO\nGUWYvD+WWmzmdSruKecifKe+WrqZsEDRZMaR+gIgCmZ91NBUg+scAk8ZLU3zFlv9\nNij/osHjDz9USWKjsGc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARsqmwoaF7aDM0PUeGHi37BQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjE4MmNhNi1iYTYxLTQ5ZTEtOTBjOS1jNDBmNjIxMTUxOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2wgb/qqXYTIlhMlcqYdXFmKcyD4C1TZbUWmE1lkDkYreY\n2vYU3Z9mung26FQrVjzqVOcEnC7IHG7lwYmAeChRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA9sCUMBA4/6aTtrP3JTU4H0a\nDoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEKXRpntd0gidu3tj/aYp+r1rkTW3Gar+NARz4IwdGdECIE44/FctAYDA\n3VL1apYwLs6R237Ms2edIQhcWrvw1b9H\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAXEerSBAbBhHerNwj6jZnir1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJhMDhmMDItZTI1Yi00Mzc0LWE5OTEtMDgwNGM3MzU4OTg3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZTFkODlj\nZC1jMGM3LTQ2OTMtYjQwMS04YjU1MzgxYzYzM2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARtIF47lKXdHAhbq7fgUWawTkgNZg034DmZX28vLZyPUPw4hvCcmcS6\nIIanOD1llRPWZ9QvLUwbIRlGo/NyEfOio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqOMLj\nnFObbt1KQT+E3gBnbTzSCDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAlmvoXPh9/3BubJrRnW4UJUIZHZp1LLt73ikw\n3ZmUJFUCIFxLdZImrenPYA0PTYK0Lr9l0/F9A+/gxcf+0khYVxTV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1797", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1797` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAUe4LlgN0vOnKgMaAK0l3Oa5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3ZjE0MmY3LThhMDEtNDI2ZC04MjMzLTQ0NjdiOTBkYTliMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU4MjU1MmEtODRj\nMy00YjQ2LWFmYmUtODczYTMxYmFlNzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPH3m2OtSLC02rxk2ByiHrAPMeXky30Mc4W/TA6UarzGjrnIj36UoClMX88CK\ne1iWIzDr1S1AS3lier7UnTcZJaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbh01oUIOICJNzRMRq3TkKjptlKwwHwYDVR0j\nBBgwFoAU86cs7+EKlPAEmDu1/ISbmnGfJ6MwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAv5Gu\nZ5OWRp3OF2q1+pY7D/GCx/9l29TPjRrdGdH0UMsCIAo9d6L/vkfh4UfOZ5nDZehH\n8cL+ebsJQ7Hf08T/emBM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASBUZ1+ohcOAOzOswH0Hi6b3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2YxNDJmNy04YTAxLTQyNmQtODIzMy00NDY3YjkwZGE5YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiO8F9jBPe8H5JLUtwT+ja/sk8ZdD+gJcoMEspGVf2QBj4\nZA2Z44qe81L8YPwmJU1XGkgxhsSIIq9zhvknTaGNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU86cs7+EKlPAEmDu1/ISbmnGf\nJ6MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTF5gzCnPYXU1VkDqGEv1iMpDHXEtdHShJ99z2SsATCYCIQDZZC3gpHft\ncyXPFWwvv1c7NMiwxNP1l/Su+1L6IpAGdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVJkbnkeFyiESq0uWvopchWGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU4MjU1MmEtODRjMy00YjQ2LWFmYmUtODczYTMxYmFlNzMxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNTM2ZGMy\nMi00Njk2LTQyZDYtOTEzOS03MzgwNjdjY2MzN2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQmgRChLw5ntbyGtJ+fkV/AwpnisMhH3BENYUsdf2UwJuk0hlvBhW22\ngvxRPTjdWL1gEUF7CVF3ggYKd06bPyz2o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRuHTWh\nQg4gIk3NExGrdOQqOm2UrDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBUBhRozW/Arr8NGOVRE7/KVdF5XH0vCNUXH4Nr\nYpeb9gIhAPItDZ5JshSPmOtTaYGEqJPwnjH7Vk2oHDs7GuC+E+T4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1798", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1798` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZCBA+BOj0KfOK5PbyRWEk8OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhMDlhMzNhLWNjOGMtNDgxMi05MjA0LWQwNTUzNTRmYTE0OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJjZjY5NjYtNmE1\nOS00YzZkLWI5MTUtNzljYzA4Mjc4NWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs3oUA+S7RXz6TcXNwhH1ULjEqvpnY8VWMtCaMvXkwQhS7q5niASF+VDBCBkI\ncSjsfUJyzkXktIPC5RQLv19j86N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJ515iHO4AA0tBGSSJMGBqCieJfPMB8GA1UdIwQY\nMBaAFPcZ/Nix+uFyGMfFVHEtf5WueHFPMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA/bCwtcqGq2Pi7F0504k5zWbyoeUX4y5k\nLV2ugcOBWYoCIQDufDbQoj7h5C1EaE1PFG23gw91qI8SJ5LxYSWYzmFbZg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfYsrer680cYLin10KhNABwPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTA5YTMzYS1jYzhjLTQ4MTItOTIwNC1kMDU1MzU0ZmExNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6sEXudMCD0MzC0SwnPM8u+hUBR2E6eUmgMHUBM/00BtMY\nsVxVHYVVX6ehu9K1O/ICcJm2Qg6MKZjN1EZghm0no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9xn82LH64XIYx8VUcS1/la54\ncU8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJK5rrhteeGHHRvailoS/fK2F/MlrCDm3sAzGOgyPbGICIQDKsKEU4ich\nEhMFLmD6wkDuNKwmQbeXe4qSevIIkhzedw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaicslJ8bv1H8Ph9UfkxNy7QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJjZjY5NjYtNmE1OS00YzZkLWI5MTUtNzljYzA4Mjc4NWE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZWZjNmU1\nOS01ODFlLTQxZTYtYmFjNy1hYTI1MDg3NGRiODkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS/sXZUfYGKSyB1fAMQhQ/7GYRdKca7KC8t6RBNeULIa5nYmZjcFshT\nUv9uCAWZXLMnx7+DKlCyl4qPuL37ZieFo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSedeYh\nzuAANLQRkkiTBgagoniXzzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBqHtaSNlF7x9ZzFDbTgjqncS4xIldxe0DJHMaH\nNiI3kAIhAMMFYDfI0u7mRqcc45Mo2JFbUMG5MUhFwyhG2+1337Mv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1799", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1799` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAUsTRYx3pYZqMcgcTQMllQgKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2YTUwNjRmLWQ3MWEtNDJiYy1hZmUxLWVlZjhkM2M5ODE5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I2YmI5MWYtYTcy\nNC00OGU5LTg4NWMtNmQyMTQzZjJjOThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPm09ul7wXALUSPGLxyl1PQSUjsHiGuoKFtKh2zRVy5k7eTaXqBQNBGbDHbg4\nu9hV6tYvfzCAPKY3BpD7tXE0p6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmej2JjSethbsknRV2w75GzX2YtAwHwYDVR0j\nBBgwFoAU46yiWIhsyY8mWBqVj6YMtMoBUg0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJ1uGliirf3k\nqZZt1g+bGNb1iZET9dku/TBTFpFIfPmnAiA1HDMUe5GSttLW7/ztBeE7a5UP/PK/\nH2Q8A0TkGbP/+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAas0+r3JUiVTizffQcelHK8dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmE1MDY0Zi1kNzFhLTQyYmMtYWZlMS1lZWY4ZDNjOTgxOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbP1tJO/XbvZ8Q47bUCvvudKcOOkQGk7Wki45m9Ebc04Ww\n7hC8TbGIJ2fheC0NqtA4MxChSUAAcasWZ8kgrQzYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU46yiWIhsyY8mWBqVj6YMtMoB\nUg0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCcS2Jlz83lrFl3bgmDWisnBxkIjgQchbBFQkarly7hcCIQCSbE2z03Cm\n8RybxhJOxxUub7wJf2PC0nWF9SXvqVpkTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeTG3oxnL7G3wDvworf6g4gVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I2YmI5MWYtYTcyNC00OGU5LTg4NWMtNmQyMTQzZjJjOThhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZTc2ZWU4\nMS1jYWRhLTQ4ZDEtODk1MC03MWJkYWU2ZmNkNDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARyIgGkX90yXagD4sJxmjMNrDLx5NsQvxyCEJmciDlHfWGO+CLTfm9S\nOTpUzNguQWugczhvCNnTOPKar5/XZeVjo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZ6PYm\nNJ62FuySdFXbDvkbNfZi0DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiARq+JAjVnbQk648IFatk0TKSGrL7oPU5TI00BB\n/SsN0QIhAJ3OXMnMoSgWZgDgmSNPSYs7gJmpRFSTZq0vDw48X4sq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1800", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1800` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAStTWbS3+JfeFYt8pzp2b8qJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiOWM3NmE5LWI2NjYtNGFiYS05Yjc2LTRmNDM1MjA3YmNmMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdhZjc3OGItOGNk\nYy00YjljLTk4ZDEtNjZhZWNlMDhjYTA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELvpL4s7ycnP5HqSe1r6yqZKEiF+hpiNApEP6xGJzFPJ8YxtrVAtacyA367gI\nztw6ZBYTXtjsUffKh5SKLr1HyqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURJygsYNPs5h7PXE0Pkf+s5UAqNkwHwYDVR0j\nBBgwFoAU2yd4GTd8LwGX/jxjWZTLhvDUe8gwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgRN3gze4SqXK2\nyboZSpl1YMGa+xYj41PO9fWuFFqP3kACIQDk0djoeaptd+GNsEvvCLirnaWGiiCT\nNK3wU2cf/jtZbg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXAUY1RAdmVkH0PRmMcJd28zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjljNzZhOS1iNjY2LTRhYmEtOWI3Ni00ZjQzNTIwN2JjZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATImZp6X0ylwsdx5OK2xqUwmeKQ42cxK5LzZIz1TC78o5D6\nQ0CC3Ff/b46skGGrOvfRGPRLUlBg3SGLRMv+HZyfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2yd4GTd8LwGX/jxjWZTLhvDU\ne8gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMEZCZnizWW24XuJ0HFIyI+ucZPtLcKLSBgj1gkG6vezAiAjsnxtBPS7\nv2WBMm4dlxtEgPVrr5hJdIZoht5iAeEzNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAauIn259AI5z40Br4EFjKi6rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdhZjc3OGItOGNkYy00YjljLTk4ZDEtNjZhZWNlMDhjYTA4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4OTZmOTgw\nNS1hNDM4LTQ5OTEtYjAxZS1lYmQ2NzNkOTA0NzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQIibYQAK0VqOAg7FtoW1+F+X1EVfsrK0wWOyjQkYNsITKbNoiOgV5q\nbU2M7SGnG/yr1B5g/ladl7JsVkbl7nfKo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBREnKCx\ng0+zmHs9cTQ+R/6zlQCo2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAmndbw3qX9V3Po5Zhp7a40UR2Jicuzw64K4y8\n/dy4YxMCIE4HWXv/PweRUWl7RTDCLXhJFxW2I2VDeIvFCtM3w5VT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1801", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1801` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAcgyi7+ptnc2MqvraqZxBM9LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZDllNjE2LTk4ZjQtNDk0ZS05OGQyLTllNDg0MmRlMTViYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I1YWUzNmYtNDQw\nNC00MjU2LTg4YzEtNDMxMzM0YWE1YWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7FKmitEsSpxFH8XPKRikr7wQ75TJnP+2+XED7vf9dof5BqSlIaHrPjXU+mwE\nufWgukpKE7XwfUtdxBK5t0/vLqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFnCwEAzq3GwbS1wIBcYRnjy8im8wHwYDVR0j\nBBgwFoAU6tcQ2coShc83PqauWkYpNb/wJLgwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGIbHDheb4K3\nb0njVRTjF0mQd2TTootxRYfZp2K9KKvQAiAvEz9goiTbMLZ3s/Nl72AthPn4qdKB\nD0DMopaFEwOZgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYN8Vlgob793j+a/7tjYft2mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2Q5ZTYxNi05OGY0LTQ5NGUtOThkMi05ZTQ4NDJkZTE1YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdp3oT2izrwjwoz2beh/RFUxcXgvD3pEjsLIwGWZRg12gX\n6sWjyQvEFPW+zBGv+ukhN9JxcorzB9osA1kVqyk7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6tcQ2coShc83PqauWkYpNb/w\nJLgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPMb9atxUoLf5v9Fp2bV2U1ca7Fc5pMH3tDWEvvsJYnXAiEA+9aWdPjR\naaTwxW6R/QAEX37WmlqoT7gYuA8rZwmrJ5g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQvAEe1I+zSNeJwsLmNDb13ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I1YWUzNmYtNDQwNC00MjU2LTg4YzEtNDMxMzM0YWE1YWJiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MTZkMzFi\nYS1hNzRjLTQ2N2MtOWQ5Yy0wOGQ0NTE0YTBiNmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQoIQ2s9Rb9k21YW2GGkGDZgp7ZxWsmzfnIdKPHKFci4gVI7Ar9/nsb\nbiTucAMy5e/LB2W27Nikh8W8bOic7rTlo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQWcLAQ\nDOrcbBtLXAgFxhGePLyKbzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBpbPNv4k22EVTg1JSQ3NzqBvE2tioJFMcO34qZ\nSa529AIhAPsdOQpAh9SAcO7nBwwMTnAIzWIsSQ8Z/6ciaqzDAAQN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1802", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1802` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASDIsc3tWCsK7MdIint2dsndMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3ZmYxYmM5LWFiMmItNDBmYi1iMzMyLTFjZDBmZjRiMzhmYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkzM2E0OGYtM2Qz\nYS00NDA5LWFlMWUtY2I4OTFjMmY5ZDczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsAu/oGfjsXdhUVcpCruVaPxSlgLE3eHiAiC3Az5UcedEnd6xjBsZQD0p5jcy\nRlTWxYsz8FJY1ZS5G9PjGmY6SKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7s5hr8YkYyrHc6R9LB/FovDSF58wHwYDVR0j\nBBgwFoAUgxcwWBgnPhUpONZi1l3rs6SgveswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD3JLlRghuTgEt2RWbJdAMea3kzAQihMIbcdenfypbDBgIhAP+pW1PAuRxh\nUsW1la/7VeLQMGzyHIJlLPCs4drbizW1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeG+g4MrEsi1YNtamjtgkxeWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2ZmMWJjOS1hYjJiLTQwZmItYjMzMi0xY2QwZmY0YjM4ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARU06OtkWPwH1yptrbom/VcC4P87Oos2Y/Cbw9qnhutjZCS\n89nf2asA0vGhxaVI+0Lsa/wplJbixjNQtA8GqLA/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgxcwWBgnPhUpONZi1l3rs6Sg\nveswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW5X7TYLVhRCQPFRPp3bHbkfLPRNBoIyvRprY2dxmwSICIQCJRLPsXuMx\nL555L3nNaqvnXCCcmD+mC3EbwwZaYN9SSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcTOtWQNez57/CbDy3xs+d4OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkzM2E0OGYtM2QzYS00NDA5LWFlMWUtY2I4OTFjMmY5ZDczMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMWI0YWIx\nYy1lZDc0LTRjMzItYWRjMi1kODZjYTBjZmRlMTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR6CGNLnjZgnAG4wYqqdU0Dij+eGSOiTxVZXkK06AwFxAekf6KQNzcd\nMHMoATKLrg1nEovWdq7mQ+rifqmfaVY7o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTuzmGv\nxiRjKsdzpH0sH8Wi8NIXnzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAhfk2aQ7QSg8pQGitenBJhBAzUBb/bus5cgmj\nqbEWZlkCIGPmWwOl4uZ+85q0PQr/0E/J1AKy3Roc5TTL3EcntBDT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1803", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1803` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbpiJPHFVqRVzXaa8VY/sPb/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiYzhjZGU2LTNmNWMtNGM1Ny1iNDc4LTUyZGMyYjU4OTU4NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzkzMzUwNGMtZDcz\nOS00NmMwLTk1ZTMtNzU5OGYzZjNmNDIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExhk7+XyMfh0g0ShhdaIXKv9qVWJQhE/lyrmja5j7VwzSsktyfAc3UIYtYM8P\ns3AejgWUamW63H55y/nl+fdORKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbIworZ36vQBCOrhiU2sWyKn4TEUwHwYDVR0j\nBBgwFoAU+XkOGYWF9vdkECxWXIV9ahuZKjgwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIG0XOG5LncOPAvzw/6C94UU+hgbBPVUpja7AxVQf7iklAiBjIIoyyblr/rly\nRV766KE7IeMNdipLfWoX5TRPOQj/8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdpe2Yw2D4DnMrhAAlb2lSBnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmM4Y2RlNi0zZjVjLTRjNTctYjQ3OC01MmRjMmI1ODk1ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+TTJpsKlL8bw14ufM7GoNvNwp+DLrD9OCJznwgVQeLdvM\n08dvCx7y5/PrM7u/yGLJzghmly0DNxfigbybeFlTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+XkOGYWF9vdkECxWXIV9ahuZ\nKjgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOiU4e38dMaCGxH2pZZXfUCAo1fwu7pCJlgUHcf/hzD0AiEAoaCZNSPI\n9qIK/S/6kWM1jy1siHbtF/aPCYUVRLGKyq0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWI7nb+R3EUgWkjnUs1yjxN9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzkzMzUwNGMtZDczOS00NmMwLTk1ZTMtNzU5OGYzZjNmNDIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlOTJmZDY2\nNy01OGUxLTRmOTctYWJkMi1lYjcxNGVlNTFjODgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARc1TRuJVH87A4+gWmOi2z2RbFtf6ffsdMfBQsdr20h0GYq99Tv7K3k\nt7zPLjyrYNqesn926ARQVkVlzQDyybaVo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRsjCit\nnfq9AEI6uGJTaxbIqfhMRTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAw4gad9mBo57kojqntM/F0Taj8K7dX4eQ4DcR\n8MH9RLICIFLQ2c8QWd/eK9P1okycsBE7TA1GFStC7dQV3rRMhR38\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1804", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1804` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAV24FgwTq2bgtEPlSlQBnpdGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwOTdiOGFkLTFlNWYtNDQyOC1iMWY1LTdhYTRjMzA5MzBmZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNiNzgxODMtZWVl\nOC00NmYwLTllZTYtYzRmZWE3YmJmMWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETNDjz2DuTW0ivV/2d8RLtYpXJ2U3PJHl2sFNzjEa/wDm1SOiIhK2yGPkHBd+\n/cPJix4dSN76f71maWm4RONfIqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCi3PwafjrORm1642YyJghgy1rscwHwYDVR0j\nBBgwFoAUwwpP93AAFQcxFRXMZ4eeKIreaBowLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFso\npWMqw5X54RWZ8vfs9CFCLYAXBMSOuLUEhqY2AWkzAiBdYJ6HX3otxZPXQ7KH+Nm1\nZNLM24Qo+40Q16jsNSHjvQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY8F1ROuQUQWPZ/Yw0H6PbxwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDk3YjhhZC0xZTVmLTQ0MjgtYjFmNS03YWE0YzMwOTMwZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQR9ortfYkWO64NFImf/VaxbT3XtGbn0/IGh3CyWssQVOPK\nhHET5HGLPlAth5si6vLAnr2EkKne8PwYuVAkwNT1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwwpP93AAFQcxFRXMZ4eeKIre\naBowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANQr1COdhnEmoxO1FUJwrjDqWkR/ZXIKBwFa15AeTGWXAiBLaAPFprZL\nPySk/34DKELDl7oR9++Uz8hXkXwS3UfneA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZfy0KkkxPtIO+gGEC5uO/0dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNiNzgxODMtZWVlOC00NmYwLTllZTYtYzRmZWE3YmJmMWMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZTYwMGNh\nMi1kZmYyLTQzNDMtOTE3Mi0wNjJjYjg5Zjc4ZTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT7J5i/Dz7G9eFnbvOc6QsvuQe+8R6g/bcjMIPAZVNvpAKiUE0i1+Gx\n1r3mhF95u3+l0/0d9E3532d7W7HwpTCYo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQKLc/B\np+Os5GbXrjZjImCGDLWuxzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAWhYjsy9vIR7oVBFIBQnCG8D/ETF/VHWitHABj\nbmefjwIhAJbvWsx+BJ5XNAx/KwEGMRs/Ki/qzOzd0o9QXqWBszdC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1805", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1805` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAYk8smMNRVxNPxUU6Z17ZQMiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyNTY3MTgyLWE4ZDQtNDkyMS1iM2RhLTZkOWZiODk0ZjI5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZkZTQ1OTUtMzAz\nMy00NGNhLThmNTMtY2E0YjcxMDYxMWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYwJsDfBt1zY7XQjPiC9OwzMr/pytOB4BRzAXlFeUjigDc5F5hg49E8+R83eG\n/xBfrwNLbRS/PSOQCQfXovJpXaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Upg1tGmcb3bplERIvWXI15GT70wHwYDVR0j\nBBgwFoAU1ONhWkfN2WoGnGaKxx+Ubpfnvq4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCHzBHmE1wsK/lbx38lD+TiCSvPln90Pm5mnzptiVb7o4CIQClDruA\nDbZlaPjO6XwOkRLdmsa7WLeXWyhdI7Hwf+dRBQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdrOApqnw0evZV1UNs7Ji/jBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjU2NzE4Mi1hOGQ0LTQ5MjEtYjNkYS02ZDlmYjg5NGYyOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhjeD7Mosl+OV+mS8xTWaQ32iOa1NuaGzAC1eb+Lrrgob6\nIUUKdRFrxVMNmRQVWSUZD1FUHi1jsfGpgUTuqei3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1ONhWkfN2WoGnGaKxx+Ubpfn\nvq4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc+9rUQS84dBRYJNP3Hgc/N8oC7+hqVSaK8WHdQQGAxICICaIcP/ZBuFq\nJZCZPGlGJPSUMr5mJFfvfIq512uaxcn6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfZ+hREY51PKxK+j3iFgyC38MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZkZTQ1OTUtMzAzMy00NGNhLThmNTMtY2E0YjcxMDYxMWNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZWU3YWU5\nZC1mZTUyLTQyZDctOTE3Yy05YTliNzczMjkyNTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATBNnPHzWOmRiK96AbtC77P/Pha2jQd2GkjQMZqII8I4ksPEdlZtLt2\n8NK6judL9FIpQIRAZEmbrLaPRM5gMfPoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTxSmDW\n0aZxvdumUREi9ZcjXkZPvTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBoH6EDBSfinJ0hR/oPyhHQCS8xfeNq3AsT8T00\naTFzagIhAPJ+EjrUbT51AldKS0bZYtvjHvrKExcQsSeb2yuvY/Q9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1806", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1806` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcoX0wNd8hVpAdlVJyQco6WpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZmQ5OTEyLWJkMGQtNGYzMC1hZjI0LWQ0ODdkYzA5MTA2ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzIxZjdkMzQtMTUx\nNi00YTRhLWIyNmQtMDgxOTAzOWY1OTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2Vs1j1zrOylPb901UTd4G+GhAbSk6OCYpGAsONiVqePlEDrUR+rDFGF+rdFZ\nmalwqYeVar1v4faXi27kK9aZOqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU464s4sOfZshehM2A+cLSwWjGqYkwHwYDVR0j\nBBgwFoAUBDGMgCynYsWmTEx3l/MVV2jhu/QwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCpBupwLokQupok/unrkYhoamqvdJbkqCC6Sk1Yn4HW9QIgL7ca\nkroDfqPrqlcGQVlGJ1fmIq6gVwmdty0FKsOu6rc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeiTUuGIqRTI51hpcBe/Wvn4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2ZkOTkxMi1iZDBkLTRmMzAtYWYyNC1kNDg3ZGMwOTEwNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1pPoqrSNY3HhFuV1BeHhHjZ1uCxpvIgStUHR14aabG1wk\n0UiOZ5gupmVkjkK/8QhdynNR6ENS3mnSgn+2R2Uio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBDGMgCynYsWmTEx3l/MVV2jh\nu/QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKXIZNQJxr+yX3KDjwF9lGBrFWOhV5qRpI+V6MX9MvfkCICGLHd0GCZGW\nGOLyD9vMav+zLDW66oWvQigHnnGfuxa3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAft7j1IubOmdaJtZnRCszRGaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzIxZjdkMzQtMTUxNi00YTRhLWIyNmQtMDgxOTAzOWY1OTk2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhN2JhYjM4\nZi0yOTFiLTQ3NzktODNmZS1mMjAxOTZjYWU0ZTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASPA8mX4VJ1vreDwErjjM3OndpQerOy43r8cSSyTLrFtDLQTKpY+mQg\nL/4o30cV7QZkCI674TPIS9l59EhvHqGGo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjrizi\nw59myF6EzYD5wtLBaMapiTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBp8KEQcCyp4vi4NNXkq4+KUeSy0FPhDI+dcyyJ\nP0gYjwIgeW6b53pnkMVdoV75P9uw9saqvK2wtavw2Sif+olosmA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1807", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1807` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAfl71KcZznpeJyvvVbuKC25cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ZGI3YTYzLTgwMGUtNGRmZi05MDUwLTQ3YzJmMzY0ZTM3OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc5MTA2YzEtZGQ4\nZS00NmQ5LWIxODUtYmI5N2VhZWE1MTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErvPM8ks+F+fmHmw+YuWEBBouR/yfJaaQ0s58jQvlVMj4vRLO9/MYVCf8HxS3\nUdS+O7UUYhnJlg4wVgYG6uFTUKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFACaOYutbQcKxDLFven+DwrO41IPMB8GA1UdIwQY\nMBaAFANE6sp66iBVo/V0om2uw+Nj7MLdMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAyFdk1cCTbWelQXtbGlALBx9jvA52Ewy0\nKBRNleco50gCIQC5vhyPC2mgQGgjF1TBG20N2bccZlQpTzQFo64+dISaKw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVHvU7dbzsxTddreLk5oEbuEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2RiN2E2My04MDBlLTRkZmYtOTA1MC00N2MyZjM2NGUzNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRqxVLmBYlkQ1aOcJE+G3kla8O66ePqQ2e/uabuUG4Swsn\nOIfDrRbyZbXIEEewAKeDGh5GU5tGueNxqzmTm+hwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA0TqynrqIFWj9XSiba7D42Ps\nwt0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKo4w2SEleajd/oftpQb4Z+jl6YlQfE1ON1DLaDrfzeGAiBz/RGJ5rGV\nYobxrbz5Bro/pHYdXZ1yaQQhY5yIHz1plw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAb/mE6ZdRt+MtlIY+M6OMI8uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc5MTA2YzEtZGQ4ZS00NmQ5LWIxODUtYmI5N2VhZWE1MTgyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5YzkyZDgy\nOC0xYzkzLTRjMmEtODI4Ny1hZDdjYzA3OWEwZWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARYsSsbktl5VuZnFkV9VKfgLt3gEalj0SPS5/CF+TiFz4rBftSnHtTz\nmeG7t+YneAV4VHwP89HbSdAT5Veyr2qYo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAmjmL\nrW0HCsQyxb3p/g8KzuNSDzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAxJVmC+Nuy71t9JvSpy7c7FyJ0JNy/hvzgr/9\n33UYb9wCIQCqW/u7Y0E95hufg7a2XPVH6NOHU1Zf0XGgBIdd3ntLUQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1808", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1808` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAc2UpLjiGlyb4k1NN0RobGlYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiNjU0N2NjLWZhYzgtNDkzNy1hMGRhLTlhYjE1MGYxMGZhYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA0MjE0M2ItNWJj\nNC00MjA2LTg4NGMtZDMyZjBhYzZjMWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEijupqhT/iOZBltepyZ5EhvvoNaFvkZ8B1cfmdSSuH7+yvqW/YiPlqCeYkslT\nIlxfm7rbi5uEgX26Q84o/yG4bqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUePu9/5MCuWvpHakftxKpp0N9CgUwHwYDVR0j\nBBgwFoAULRGAJKh4bnnaQZeAwyd1b5B56MYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgHVXX4z0GgS8J\nJXL3HdKGp06HeH7iMGTOmSMTkI2BtgYCIQCzLcuPC4jAe5Sc/pwjaR34vXRd+UNd\nS9Yye2E3rUrTsQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZHdtAeyug0yS8aOP3SSyB0sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjY1NDdjYy1mYWM4LTQ5MzctYTBkYS05YWIxNTBmMTBmYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8GeQWJLFQ4MPTEews6zy2puxKixM8almizuKojwfZvuIO\nmNpW40lZH/iAVf9XwqZO+sxzvuNT3zS/kkd6C4Nto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULRGAJKh4bnnaQZeAwyd1b5B5\n6MYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIqPLzoSTeSLjtse38qpNj74CMuYKmEbSdVsqJ8lXbM6AiEA70k1PFhQ\nRuvCUhhyNmHAaV5d1Vbjl+P+fp1b/9mXJ8c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAYQeDl34iNXgFsdqZI5t+SWwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA0MjE0M2ItNWJjNC00MjA2LTg4NGMtZDMyZjBhYzZjMWFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzY2E3ZDU2\nMS1jNWFiLTRlNzgtODRmOC0xZjhjZjVkMDViNjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS3FB4bqdrkD341llQni8KbofvsmPqqbGFkktGEd2//ppqUgCrmfH28\nAknL83vmogqc+5STPPq7RuV+jF9jN3M0o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4+73/\nkwK5a+kdqR+3EqmnQ30KBTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBeN2PgYbY2IFLeDkp5C/9EKRXHRr893Eulrhf6\nLW2sJQIgYIbKLd2E45QuVdRsetto1csltG9zZCyUggsxU37nmQM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1809", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1809` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAR+FY8yQfBWRHaOsJaM5Sc82MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyYzkyM2ZlLThkMWYtNDJkYy1hZTkxLTA2NDRiOGYwNDY2NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWM5OTQ3YWEtNzZk\nMy00MDNlLThiZWMtMDIwZjU5ZWUyZTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo3cWZR8nHldGislYnID6ng8RhMniPEKEIHB2voHjwkyRhywhmeZSASBGZXrk\nsGJ6YvzXbpdmkOiC1iHkdlmSUKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9NOvx92Bqt1P3APAM3hEUuM5IYswHwYDVR0j\nBBgwFoAUWHs40G78sZJIPhdh9sTRhMjdxjQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMMn3AG6h1cc\nGmOMCqnXZkcj9SVUEN+mECyRncuzqQE6AiBYAdVpttzF4uVNmpp4lpd95ZYLhIw5\nNgzJF8eZOKwqMQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASsH0QqYF3Iv7mxvzL7K6wapMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmM5MjNmZS04ZDFmLTQyZGMtYWU5MS0wNjQ0YjhmMDQ2NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoy+uQ/zLGGoX2CEj9emHdUaKgxOPn4+EOL3N+vCdMShe/\neuYNtweAQO7VXV7gwo6zy0/M66me/gfd5FAZAUPEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWHs40G78sZJIPhdh9sTRhMjd\nxjQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNK50lz2tfmw1P4Oc84ytIX1fAjMgG7GJkyvxf+Vwv9YCIQDrsHG4Eqsj\nCCUuDHJzU+JtyafdFDlLft2juuHL+fuZPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAROlJ3qzvHOwDH5BUug8vHMQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWM5OTQ3YWEtNzZkMy00MDNlLThiZWMtMDIwZjU5ZWUyZTRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZTdlZjEy\nMy1jZjU3LTRiMjgtYTFiNy00OWFmYjEzODk3ZTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQklkYYxkpYxNrUb7VWn2M/WvxkvoMn9B8z4I5iN/X01QQHnGhLCLMq\nAUkU4gvO6cefMopvODriB5FpbptaQfz3o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT006/H\n3YGq3U/cA8AzeERS4zkhizAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAhGEtipJAh78SoD088pENgZCRmVnucZmMJNul\nty8Ji34CIQCv3XdEvrhWQL/1LNMZf20xzq+4PsX3QIvc1ikJrXpTgw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1810", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1810` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQpAHXti9J934GNQU8zGPvB7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NTMzNDZiLTliM2EtNGFlYy04NGQyLTFiMTE3NzY3NDE4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhjNzBmYzUtNDdj\nMC00MWI2LThkMTQtNjk4MWY1YTg2MzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmIw9xoX8FS2diA/cCW9X29PvglRMC3nUWN6OBviPmCKoxlkqNWEdCSNjOp5+\n/hOBUMH4UjSo5fX+bun3A7iCC6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhYKXTADLthNPjzlY8zUPbnOIXLwwHwYDVR0j\nBBgwFoAUnO1gy/iausWKfZ2BeCiupd9gVfswKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDNDM5JAvGJ\neNU0+oHfmGWavuqHWqhvztBgRnZneYYmkgIgVa00R/fZ5THUX0pGD2Dwa9yulFza\nVtRNT7NlnAlEBxE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATme8brxftXvnJTWn+MtIXVQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODUzMzQ2Yi05YjNhLTRhZWMtODRkMi0xYjExNzc2NzQxOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATX8aZmT16j0CFhYdg0iOG2Fo61sCnu8pPKmiDEUJQuW/Jz\nUROHE9OUEU3KSTI9/lV1P282Ovbb4DtJ2l9jp7+Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnO1gy/iausWKfZ2BeCiupd9g\nVfswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA7euULHYjb5kc05YtSCi41yS2ykUw9iDFxSv5SCQoAcCIQC6jPjAU2u4\naNfsj4x3pLHAQS9EwFMMbky+Q7MXzk16Nw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATMePt89R2cw2MXO3XvJozhAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhjNzBmYzUtNDdjMC00MWI2LThkMTQtNjk4MWY1YTg2MzlkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMmY2ZDQy\nOS05ZTQwLTQxZTEtYWQ0MS0xYzRlZGM5NjU0NDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQp4crJ2aGHXeaADWvfSLaZiRAZUf4wv6RLI2Pve6AHdv8fCkbQB/Ll\n3APsT4THPwvAWm5UIF1Ye7Z20IFoTWV7o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFgpdM\nAMu2E0+POVjzNQ9uc4hcvDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAor1vBmV69GudOoZ6v4BUZ28q3xHuNdO716jDn\nt5EohQIgS78OMfZl5veNFZAhREb3TGghGppEM/0qh4bJzFe3QZM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1811", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1811` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAY29ikqcZyPOaj3R2tcNj2sCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MGM5NDIxLTdiOGQtNDQ5YS05ZDYwLWI5MWRmMzhjNjZhOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjMxNGIzYWUtMzAz\nNC00ZTUzLTlhMjYtZmQ0NDljYmU5MGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHt87KlEim2XANxqwe2l+aBF4AN9jLru7o4SUzhpSmbMw2be4eQs2IBUBoK3F\n94NxAakdn0cW18VxWpbglTsHcKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUub8+IhIOqjec31OK9cjuc5NL2AwHwYDVR0j\nBBgwFoAUDqUkSqDuHmEvhq7yFKkZyqye78MwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHrxbZ7uhdb/LhjDKR/DwnIhcCpQVmb1c7oFMAoIT5B5AiAdkpbGIqkn2thF\nm8sHsW7ZVgW2VEmy+ARnJISZ0FUd8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATL6PC62IUoQCgG/GdVd+lrkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODBjOTQyMS03YjhkLTQ0OWEtOWQ2MC1iOTFkZjM4YzY2YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8cIVsCqG7q3UagMzRIZkLCRFcKpi5YC6prgEgm4pWnFhp\njNAMKY2iWbn1SH/E4I1iB5xQAvv7rhMxYIpQuA3wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDqUkSqDuHmEvhq7yFKkZyqye\n78MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJzurmnTWfn1uSU8VdHAi6Nvrct0zeD8u5ybwDbIQHfLAiATctatVk1V\n2AAO+DYBr8GMtXTqlhX68MnE8iEb7M80bA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAULENsIkETeizJOoqc6bXpg1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjMxNGIzYWUtMzAzNC00ZTUzLTlhMjYtZmQ0NDljYmU5MGJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MjU0M2Mz\nMi02NmY2LTQxOGUtYjE1Ni1jNGZjOGZkYTQ1YTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASIMPSs19gEvF21WALLlCwmMcxFLJpXS6xoYPHrDkqBt0gPKBUvJ25k\nMjgYSVDq68qKhBSAjaHAFhUjFazEyQE4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRS5vz4\niEg6qN5zfU4r1yO5zk0vYDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA8dKpq1NSgQT3h6PKHwp0ldygB+wPxkK6aRwO\n5sGQYV8CIQDxfFq+rYf/CvpdV5dSCdSle0UFD7OP2G0jix7oi/n9+Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1812", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1812` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAaSGRbezV+ras069IbiGRAqAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1OWM5Y2M2LThmZjAtNGIyMy04ZmQ0LTMwMjgzY2M3NmM2MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM0YmFhZWItMTdj\nNi00MGE1LTg3Y2QtMzA5MjRlZTE4ZmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfuBogQrcfbw1EKgV7ZP/h/eh4B328HRs4JepxQ50lPtt9Ej8OTFD43srHTfS\n0hb+cbUCXc3dlzhyiVBJtAfTDaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9tGgiSDw3lXAn+jx1Oa4fG7yEYcwHwYDVR0j\nBBgwFoAUBx9ZW4recVA3ZWgD53Mym3CgPwYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC9Mv/qoWQZlL4FNrRoUm3aETfK0UzXl4Ivz3mmkZQNngIhAOV4ztsxHbji\nVUEczUmP4wQehQhMp52zqeyqn3OcZMdc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa/aUnWKlAyfhmKm5f/MDSTOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTljOWNjNi04ZmYwLTRiMjMtOGZkNC0zMDI4M2NjNzZjNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROANP5Dk6eirZqhp4ykaMoTKzWxdX64N/0nC8rgg70cQDq\nysBmFXEgo2ByWo1r0no/iKKTPkcstBETelhTQJD6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBx9ZW4recVA3ZWgD53Mym3Cg\nPwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIuf/43hwASwxFIJx8ZqgM7Qm5cJwN2LL50RdQd/LR4QAiB6MvMPB157\nuqftqYyRl76TfZjr/6Qkl3WQSIES9r+mGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAUObjY7TFOXZs5PSthIdop57MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM0YmFhZWItMTdjNi00MGE1LTg3Y2QtMzA5MjRlZTE4ZmJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYjE4MjE1\nZi1jNmUzLTRlODAtYjNkOC0wNjBjZDUxNTE2MDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASN5eTYfkgfJkwgK1wgjS2wzQ2zc97UUFinDdvA4/EBbDM5rOXaUHLl\ne0doK/Lhx1D9ur+8SDUD3NDv6ZGcpgoFo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT20aCJ\nIPDeVcCf6PHU5rh8bvIRhzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBP0FeUPFxvEvDzyUOfKDdnHatQO0htdrTQncue\nUkgLvwIgNyOMT3PKHNFz7FCvc8YgpB/cpWiWiZn91j/vvhdgy9M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1813", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1813` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAdMPjnHSw+Dl+tEZMZXMjCslMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0YzcwNzIzLTAwZDQtNDYzOC04N2NmLTMxNTk3MmM5NjJhYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY0ZTYyNGUtNGU4\nNi00YzgwLTlmZDUtZWY1NWNhMjBlYzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy8qRbYhBSaJwBeDJBmA2YgoiNAQbzeElDHct1vsL4KwmYxWhxlzM7x0zh3hr\nFnJj+hwZ8KcgObXUjTV3G90oSKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcywwvUTw2rguwnCu2S9TBP9ulJIwHwYDVR0j\nBBgwFoAU4ic+0mtWwRKhdAsPZCVVbFDdvCwwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICce\n4aOVaOLJ1ztmK1nj/CVusKVu7XsfvMCN/tEN4QrLAiAPnqGc9nqFMEIAgU/wmHYn\n+hdNmq3Vqwxwb/g0lggL0Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYZgfJj8pWdXCxGsJ2B1jSlMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGM3MDcyMy0wMGQ0LTQ2MzgtODdjZi0zMTU5NzJjOTYyYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARypHxUUaVBbhIUAW/uTtTnHh2tWbNkK5oE3UMEEQc46ZrB\nDPenQJrHFSA0JXw15P2X1hgWDmJ9MX1YdgSGk7oAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ic+0mtWwRKhdAsPZCVVbFDd\nvCwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIZ/7/e691XEdT/SwZiGV3DEvqjMLdDJclPw6QhhqxhDAiEAlYvM+pne\n65j/4Yr5k305t/4RIReYAZFHnUFCuD05l8g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbphYgRjVNpyArNT2VDzWpdXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY0ZTYyNGUtNGU4Ni00YzgwLTlmZDUtZWY1NWNhMjBlYzAzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZTM5ZDNh\nNi1jNTFkLTQ2NDYtYjYxMS00ODQ4YTZkMmE0N2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARZFxjcdbiWLpihWsJYJFYMN9cxscQGwNHSIZAI49W2S9PbIHwTSQ8O\nCZz18MfgFu1Isw5AUflBoHa+BTMvHzkRo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzLDC9\nRPDauC7CcK7ZL1ME/26UkjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAFXYo5wGjU65JqnH7jHxFgoVka9RZGly0FwkU8\nZxzP7wIgeBpb3SW+YIKq/NRdgqnNW1oWPUWWDQgRRN4TmBlGCsg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1814", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1814` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAQHAirwYdupn36zgO9bSfh8SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMmM1Y2UxLWNjMzEtNGY2Ny1hYzExLTA1Y2Y3N2MzMWIyYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWMxYzFhZjMtNDQ3\nOC00M2M1LWJkNDAtYTFkNTA2NzVhY2U0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEini5pmLOkDPkvYUpxOduFVGJQGqp2WkfGKRkFjcvwYcswkfCbjw50Erta1lh\ns+Q4gJ9CgFMVcQizQ01xHQjrjaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCWdKtljPWyiEEETsrflj70CBs14wHwYDVR0j\nBBgwFoAUjrU2PxkwpHGYvnUBEAP2bK//qBYwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCV5ui+U+JlNFEkn4i+kdko1hvuuQNgh7B4b6hg5t/xCAIhAOGA\njM2T9BOLizb/q1F8CZGGNk7LQqKrWoD34ZikqQYo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX32LEwqb7fyEu/1KlnKSRf1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzJjNWNlMS1jYzMxLTRmNjctYWMxMS0wNWNmNzdjMzFiMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjdxs2FgYHuAAxLFHJNBvhVe8ZMHwpBdS1f2N80VNYWxEn\nMJOm1HIzsA8r/3jK1mlqLJdoIhrUG5YAAFvNe95Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjrU2PxkwpHGYvnUBEAP2bK//\nqBYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEve+7k3gjWAQw+NhVYNBWwqQKE765jL8HR8o7nkNi3kCIHYi6CYesx6A\nfB4AScUX6X702rSZzXEmy+YdSN81xFES\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAYkvjhDANXzwpANtJ0lJ+/bTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWMxYzFhZjMtNDQ3OC00M2M1LWJkNDAtYTFkNTA2NzVhY2U0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYjZmMDEx\nMy0xNzVkLTQ4ZTUtYjc4Yi1hMDA5MjVhNjdmOWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARNB65gn0Qz8wvvHen+JiOu0EiaIuZACBiiw/paWALHaf2WYpBbGWeF\n6u05cc4tUgD8tO9v5/Pl7Za/iM69jmUEo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJZ0q2\nWM9bKIQQROyt+WPvQIGzXjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAbojx987ZLgNcEwiJrr8GILN0V/0KDVhp+dbRd\nn4vvFwIgfiVME5ybzLCOheO4jsl75nWCnmQhZqnyp3qe++Ff1d4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1815", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1815` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATH0pS0GkpNbN2A7dKQameSZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmOTgxZWE3LTI1MTEtNDBmYi1hNzZjLWY0ZTMwNmIzMmEzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA1ZjE0MjgtYTNm\nNy00ODQ5LThkZGUtYTRiZWU0ZDhmYjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjLFB/XWFH0Dabohig4mh7+8EoZ656oMP/+22t9hsb24CDXrTyxyLRh9MrMiJ\nLjbI2Ep+I2C2Ye5O05rJUzAObKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzlt7jpmA+y5znP5RhI5nAlw+zdkwHwYDVR0j\nBBgwFoAU1SjWXOG5rQ76MIKNenAWmQQ7NykwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIHtNuOjnE14uUdRAt7t4bjIfkqkn5cfuG7c7SQsCOLIgAiEAz87s\nwaatqeDvhpPIpqXz2djCnxlCi7YtbjW11GSEpKw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY24Wb+OZaZ+GZLoZ6DjrRXbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjk4MWVhNy0yNTExLTQwZmItYTc2Yy1mNGUzMDZiMzJhM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9cO05tkrJzk2S7P/ENEktL2PcxTgeAgnenT4Jh7sLfAYv\n3yIxKjV6QRv22RrmyCHdBdezpCK2n2pz/lUyhTr+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1SjWXOG5rQ76MIKNenAWmQQ7\nNykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgX/1M/mCrthsun9B0R9xexUmYjJ4A/NhQzrpWgNOVYQACIDzLWftNzaUy\nv/EPOarAcHf4vhz7ch06so74DQeo69Gc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbUIGWuTgvJyUjCj8gdzPOH7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA1ZjE0MjgtYTNmNy00ODQ5LThkZGUtYTRiZWU0ZDhmYjI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNDg0M2Nm\nNS1mMTZhLTQ0MTAtOTE0NC04YWU3NzU4MWYxNGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARhRZdLkrhx3NBo2becyGGhcqsA+Z49269wGNiAaSniKbeBUpOh8JaH\nfxnr32+BAVdju5OvVhFWg5swKLfMLNmFo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOW3uO\nmYD7LnOc/lGEjmcCXD7N2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBpTXWGSQrNLTGfekIr8bWUmt21TOCMJ7OH7Hc7\np9OqNgIgI/1+kB4XjbI6EOcg+Sax+y16+L5Wr7erV7Hz58RzHwQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1816", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1816` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcj+/en1+lpT+QSQwzQfF77/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkNGY3YjUxLTdkYzYtNDNiZC1hNzdiLWVjNmEyMmIzMGQ5NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ3NzA3ODUtODZl\nMC00YTc5LWJlNmUtNjQ3YTEzMTY4ZTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4SK7IucbVz46Q+lMq8pOHPOBRVJ9aRtqdw6PrGizPqYqSszaN/IqZXfi5fze\ndpnuVySVwYDKEDn7tbB0C9dQS6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQuSIM/1UQ1L0rsYeJcWVQYW8lWgzAfBgNVHSME\nGDAWgBSDoXupibAc40in+1VTdGblrhp/+zAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDU/gWhEPe66NU8WVS9MkyM9zGsZRLe\nX04oq1VW+UbQdQIgML8c4gOORSWOYYJeKlDRh0PwIsjVTFzS+LjaOYIpaGk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQOIHA8EDkg8zInxY923uu/oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDRmN2I1MS03ZGM2LTQzYmQtYTc3Yi1lYzZhMjJiMzBkOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlLdJeBrCvdFnELqr6MOPpQS6+lYKkP+e7JBX3vMuX9npR\nEy5Y59JOBmXeCy7gmYNQXTysS5anlti6eqtUagICo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg6F7qYmwHONIp/tVU3Rm5a4a\nf/swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOZG/B4jWgHnR3solSANNMqBmzi3eLWaRfDoBe9HUtqwAiEAj758t+8o\nqac39IKsX0KeQavc+07FkjiS2DqfDuLiML8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAUAZtY8iRl+DdhhlSZpuHkh6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ3NzA3ODUtODZlMC00YTc5LWJlNmUtNjQ3YTEzMTY4ZTUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNDUxM2M2\nNC1lMGRiLTRlZTMtOTllOS1iNDEyNDg1MzM2NzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQNwCUKLlTak/KDjs2+WshZX1QdM2vrxFm+krL8YVZrRjRhFZ5C5RZI\nXRqume25WYXA7MgpJAdoIYImh4lkbCXIo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQuSIM/\n1UQ1L0rsYeJcWVQYW8lWgzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBViPSoSJcMgfQgmb+lLERxwXrp36AX55yvcEm6\nyXDMigIgQvWTxvnST5z0wlCEwxsZTc358mn8wYlbHTl5KXWCoV0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1817", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1817` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAbElD0hT2nqUU4D+r7buAWQHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyOWNlZWMxLTMzMTktNGFhMy1iYTY5LTFlYzk2M2ZlMzk0NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFjZmE5NDQtMjQw\nZC00NDBhLTg5ZWEtNzFiYmU5YmQzYjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIgf+s7QEY3/46o6Z6Iu5eiMZQPp00X4hKamXqlrlGWwAZylGvcGxlzANKjLq\n2OMeaZGcXXAwnDY1RXlu5aW8bKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPucK2Z2ogiE1d/vPZLrc3OFghPUwHwYDVR0j\nBBgwFoAUz6bFA2szZ6GDME6nMcjTPDMYjq8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDJy0y1lomc\n/guvu5QhoGbqaYeZI9f283BrLS6/V/GCjwIhALp9YTVKplGDv48+ZJ6VIrUHZFkq\nY0cxbBGAA0dJ6CQd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWN/SBlWQYy0vh/RxsuU8IDHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjljZWVjMS0zMzE5LTRhYTMtYmE2OS0xZWM5NjNmZTM5NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARp6+/i643wO3Uq3itA8MUy7syMNhMjlxw1YaNYqak0E1gC\ngAshhieFNCjFbns5+B05kTZ3bCJ1yKeKF/0vB8M9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz6bFA2szZ6GDME6nMcjTPDMY\njq8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJerD8avGs0++fq6w/Eh91Bf5ikJEpLEYTSbsyYAi42ZAiEA6AVkMlaG\nCS0Qqe4hgguf8kKKz26h4XdGtJRZps+U78A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAR/eer6jFBwvSg/w1vH2n9mVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFjZmE5NDQtMjQwZC00NDBhLTg5ZWEtNzFiYmU5YmQzYjhlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YmFjMDBj\nZi0zMTcxLTQ3YWYtYTMzYi1jNWY4MGM0YmE3MTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASpW+HanSRNGJhe3srGGBGMxgmUc046J3yqL/Z7wXjUmpjFPCyna6Et\nfpVflNGuCuyWDfxFhWexihfFw+8yIxeVo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ+5wrZ\nnaiCITV3+89kutzc4WCE9TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBWluugkDovRQgnRLnDy2iWPt2dhtiL3SKYpDKG\n071MQwIgHdszSc6u0FlI22j1wT+fDqGU6iXOy6Ei4QadbIw0nuk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1818", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1818` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbjiilbiEKgq4yLO7TgaonJMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwMGM1YzIyLWZmN2UtNDg2OC05YWViLTQwMWY1YzlmMWRmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJiYmVmMTctMTU3\nNS00ZmUxLWE1NWEtOGVmOWM1YTFmMTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/ibBhm7VaeRy+t3wY8leEUOzQtbBDbpHmIbBDpEVtwzQBaR3DLRc1c66m6tX\nPWtDlGTRpv+fJXg4uwn6aMD2w6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHk8DZ5krVoouJuNdaJ2MUQmzQRswHwYDVR0j\nBBgwFoAU9AfInOck/V/YFRWIO+nfaHpqZI0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCGyFbmb9sO\nc7ZdM2VIwH5Njqe6s2xkz7jw+FpV3EnqygIgBQ6keiTbFWGWgmB42P+djVRvBXvq\nBpDFa1dr4mdoR0w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASxxT5xYwmj3IZq2D6PXCqZzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDBjNWMyMi1mZjdlLTQ4NjgtOWFlYi00MDFmNWM5ZjFkZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATf/DyhzWQGFdBaGyE3ka219fbnuRupKiPWX44t8QxfTugh\nnqlw9A8fvsFM2YXDkVx2RJ4V+EkfYV1rfXsbxQBgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9AfInOck/V/YFRWIO+nfaHpq\nZI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL7r8TWz+FsS6mPrAL0DhVKn1WzNgv09C7dUwbaOLS+EAiBIYQHU4CTo\n95VbC7d6NvhG3jM03MSxC0vq3iNkI+Il9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQzY/dH1k8gWbmvtSrajBEtlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJiYmVmMTctMTU3NS00ZmUxLWE1NWEtOGVmOWM1YTFmMTI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhN2I0MTEx\nNy03ZDFmLTQxMzAtYjIzOS1kY2ZmNmMyYzI4MmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQyNp98551eLKIm5sbZyNH5h0hq4xVOKNDK9SS5hW3Gs07Erh3TsefL\nL2wVlJiGs4iOPQXeQNoufC17byhwbs6co3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQeTwNn\nmStWii4m411onYxRCbNBGzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA21hGx1D+DGMF8N3BhHtAWWSsg3uXdpqqKxIr\npZ3RLVYCIGMDnchhJjc8oy7glRCOFLHmv3UzQk+isz+gCsFSYhn3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1819", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1819` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAegQcDO31rJNm9Tf0u/FQ6kNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxNDhmYWQxLTg0M2QtNGRmZC04ZTZkLTdkNWUxYzc2MTczOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFhMTdmZTQtMDZi\nYy00YjllLTk1YjgtZGJiM2E0ZTNjOGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcWAr2i0Ht/zI6jwSDpF0B6KXi7Berr4+DGL8l0iKrNfXxwTiTqyXL0YQB/1q\nLP0DWSbQREFrDPGI9TtZ+047g6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUukpnd0pKw1zIc86W3+GvisLcWacwHwYDVR0j\nBBgwFoAUj5zStebLgClbMhgwMZ6ipbU+6F0wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBcL5kIITwM\nw6LzAIv9ivuSglWu92eHJ1ucmaezsGrj3gIhAInzXaYWvT4sifQnc5dK636Euw17\n89+S4/QtOQHgqvOk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdF6hYKjf+By++XdkFnwjY7vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTQ4ZmFkMS04NDNkLTRkZmQtOGU2ZC03ZDVlMWM3NjE3MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASts1WMsht5c95/1lZA4lVc56IP58avJsR7+h9le85xNzjM\n4BxieUNdOXJ1E2Lxg/XrsQTjKL4PeMODN2NMEm6co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj5zStebLgClbMhgwMZ6ipbU+\n6F0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDrghpt0DoxUXiRdLrmeWueFcbOweosSz0vD9RZeH+dkCIFX6r0g0cQtD\n+xlhW0JCFUfZGrwdiCKu3V78Rf/28H4F\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAT78GZgVVBiMkGlfCq5BVI/SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFhMTdmZTQtMDZiYy00YjllLTk1YjgtZGJiM2E0ZTNjOGI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMzY0YzJj\nYi0yMTM1LTRlODktOGQ5MS03NDYyNTE3MDI0M2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAScqguWBpBcQmDfCpw1YEyomRyw4AR7BbE+LlsZchi+wMnuWhrbiwcp\ndVkPLZMCkohgA0nO8VXxquIuJfzhlg3/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS6Smd3\nSkrDXMhzzpbf4a+KwtxZpzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAtbs0HIN9+2VT5yBuLTsbi5zIN3e1r0iVxIV/\neyEZZ9oCIQCCqbMQSFVP8jqj95G2bGtelAHW/PweBa0w1F2aZ6l7DA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1820", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1820` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAcQvgRZ7icWIKJbQlJ7f+bNaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNTkyM2RmLThlOTMtNDIzOC1iY2FiLThkMzhhZDQyOGE2MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY3MmJiMWYtMDk3\nOS00YzNhLTgyNjMtMmY4Y2ZkODYzZjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElH/AsX7r6JaLKOkvRZ7JmqZnFfAFaxJjc/1CmXFT2SorSTzgHlv35vS9l2iX\n1z6hE//qktB/oE4FuRewCijktaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCmJSNw027qG/J4J0bV2MtlCu6i4wHwYDVR0j\nBBgwFoAUQ7uQ+IQiNL5rwF8oje8roWn1d9MwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiBZwmwt0eNsZRvb8QakhcJ+XV0LLSFcJOwi+XOMgohLcAIgPOFOSQuInq2M\nMXXc3kNl4YZwDiuAxKzRdsKbVQeGwP8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcip74G7cydeCxAOyxW6qLXPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTU5MjNkZi04ZTkzLTQyMzgtYmNhYi04ZDM4YWQ0MjhhNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHT1Czdwv/Es2O1RIeflTKcqcDbXIdIehtZoenoF+icXC+\nk36dwzdwahUZ4B8I3nYKvsDWHlcH9V4pU5K8eBS6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ7uQ+IQiNL5rwF8oje8roWn1\nd9MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWa1osWXO+QaEmHHh/qlP2Om+skadqglUjekEddzd/uUCIQClX1DU5bzK\nrA46a66ta2C2OWqVMiLIue5SMDSV/uCm8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAYn6a3W4DtXYgi2GHb13bFqRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY3MmJiMWYtMDk3OS00YzNhLTgyNjMtMmY4Y2ZkODYzZjdmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZjU3Yzhj\nNy05ZjAzLTRlOWUtYmMxMy03ZjY4OTA1MjNjZmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASLct8oljPjcWhQuc0Nndz+NRrIdZV1IUcDbN6oihTO3E392IZOtJ9k\nhVy3Onojacw9QV6Ozi2iSp7njuxWSSTdo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQKYlI3\nDTbuob8ngnRtXYy2UK7qLjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAoDUhQD8bGRrjUVOGN+H2X87xW3ceBRH33SZM\nZvwxgnMCIQCUP6LZQNakV4al6+uZfGGYHqPDIIgT0FTBX7mI7L9x0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1821", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1821` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISASdAOlDSUsbwMEmmVZuXPAvKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZDg5MDA3LWU2OTktNDdkMC05ZDhhLTY2NTlkMjU5NDUzODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZlZTA4MTItZGY2\nZS00YzM5LTgwYzAtNjY5MzIyODc0MGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESxdwSly0JDoP6eDMZcxH8h1V3NtTwY1AnDRe1wpnaBwH0qtZw+wkWVlI/N1Z\n1G/cEMSW4MlX+bpkS8ODo8Dl1qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa9IJ2ToxYaUf+XhOnxP9aRiCiT4wHwYDVR0j\nBBgwFoAUgoPowZEZhn75sAxhOVgjiry87cwwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiA5XOwQVoVzkWBIGo/QswnKKL65fqsnApK+y0Ov9QQBpgIgGUnsWOvWsSKf\nccRnQuEVCVw1vZ+COHVD5Nf7FXMLrpE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbQtPPy0MdMHEezJ83pR1UZgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWQ4OTAwNy1lNjk5LTQ3ZDAtOWQ4YS02NjU5ZDI1OTQ1MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoHsQgcRncRc0BHkgrPiA6nWcAAkfWwfvF98wckfltkkNR\nF0TSke4KItD8fbihL/u1nVJohIPUvVrbdQ3Pvn/Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgoPowZEZhn75sAxhOVgjiry8\n7cwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIdhR1xeGaXQMTD7GvyQbmxD0Sy6ElC0tUNZqVYMbvDRAiEAqW9u9tCi\nUlMKYKLKJHSIhSq/MMxjqlozYsEdxS7RYzI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYuQgnWxxFME58mZJdI/zPOAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZlZTA4MTItZGY2ZS00YzM5LTgwYzAtNjY5MzIyODc0MGIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNmMwMThl\nMi00NGUyLTQxY2YtYjNkOS0yMmUwOWY5ZjYwMGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASSvxbupDoYsbgh6rXXTTXP5jra2ZkUmZS+R/0XBfLBleq2xftWRtvC\nBiGDOydXD6hDYiWybiE48HaCgh7Yxiu8o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRr0gnZ\nOjFhpR/5eE6fE/1pGIKJPjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAX+N4wuYtTYDhMOwvWhtI1LRhfCrVyYWvTONCl\njTcKNAIhAIlRy6DnomIuMcxWpFccndAlIaWwihFz3h1Fj8Piaa8K\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1822", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1822` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAV94MgvBynU4+LXY/6n3Ayz8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ODAzZTRhLTRmOTItNDljMC1hYmFhLTZiODY2NGJlNmQ1MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmYwZDc3NjctZWVh\nNy00NTIyLWE2N2QtZjA1ODQxNWFjOTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExa7q6iPzLJ81UjRNmdjKX/vhYSpcOXS4QOTvAycsZDsnnBtOR2Tdhh0eWTlv\n9RrrgSP+dIK5IMCpXnO0h8GiTaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2eGZLU93vT0LCYcjDZSquxr989kwHwYDVR0j\nBBgwFoAU4O0rcZ22vvHfgqKUKnBsKkuxtCUwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n/3HVXD5YUue1DoVLmF4QZ0XqHJ9znsJZWBcnc3OLu6ECIBLwW5vy6eKVC0mgqw/D\nMww+6atSksne1p74tU9sA73u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATyzw7L5UdEaT/NNQNkjhp32MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTgwM2U0YS00ZjkyLTQ5YzAtYWJhYS02Yjg2NjRiZTZkNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4nT9yOoMLcU+bZsOV3oSbvPxdCzl/WYgepludxsAP7M4v\nHBzad6V3/FYLmBhAiZ83uWTbdrY7fIqUCfcTtTpPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4O0rcZ22vvHfgqKUKnBsKkux\ntCUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP3Uos65iHAZ8/Rfcz8k1kuGUTrIr8sXYljxzQnkvp/9AiAJyH91Oj62\n3s9WyI/nAoyloiSG8t5WHUHrqS/M0/7WDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAV1lM/CbPn3JvUlZWwOPgRPhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmYwZDc3NjctZWVhNy00NTIyLWE2N2QtZjA1ODQxNWFjOTkzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYTAzYzAz\nNC0wNzk0LTRhYWQtYWZiNi1hOGJmZWJkMmQwNTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQaNvqjMcaOI3xwkOxFAlK0GgSdPthmKWenWvapmv4S6peGzkFoVEHx\nUagG9Om9DCeBjONG43QG7sq/eAKbxMwmo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTZ4Zkt\nT3e9PQsJhyMNlKq7Gv3z2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAj81dlMoiDHNFaNbTaWOu3jvRrjP5G1yq4TWg\niu/Aoo4CIQDwz1w8HReHuVJP7PsWORLIqAhM5+v3Ul/78CZQLVhpXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1823", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1823` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISASQ8OZgiBGi5U9NQo/7TTCVAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2MmZjZGEzLTlhZTUtNGQ0Yi1iYTcwLTEyZTJhMzM2NzA4ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE5NWI0ODUtNDQ4\nNS00ZGJiLThjMTItZTljOTA0N2M0OWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzCUvTuGUa276hhnXl7SIM6hBOwirstWNOOCY3wFpPGh73Ykncx43jD1ebxEU\n9shbjuuTZZS6dSZSwtHqvLm8O6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0wrfPXzrzGw4xsGzbdPIceqxPgowHwYDVR0j\nBBgwFoAUNniS9BIO76l3lQDXIYQ4xgextY4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiB1NCjwxDXCU3fs1HFRE0j8F5wE4aL/Kjh3Q5neX+sLzQIgJZWE\nda+2aFnJ7Kkjg9BuQ9bjyl6OpxgWsFFcgoy3Qg0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQqqEXnq3OnVEIltJOpaaDsZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjJmY2RhMy05YWU1LTRkNGItYmE3MC0xMmUyYTMzNjcwOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgZ0LaPC6eGHzbHusLHD66zRlOfm6/pbSrVWdoEWt2+mMZ\nFrF9Cc8/vsjFo4paoCazAQuny+fmzfChdDnzHYKno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNniS9BIO76l3lQDXIYQ4xgex\ntY4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNPUhLs/ouEeYSD3A6wLgcyOhoBDO6HUj1lYV+ID4X0cCIH6+hfg8MKI0\nmy5jUFGXtVAnwHHFeEaxtlxhG5q4kPl6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAW3iFjm30Ilg/kzCw0lmvY3mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE5NWI0ODUtNDQ4NS00ZGJiLThjMTItZTljOTA0N2M0OWMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiM2RlNGU5\nMS1mNTNiLTQ5YmEtYTBiMC04ZWQ2ODdlOGQzYTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASSCRHQsUjKWeaASwjw9OPJ/6Zzgkb2h7+/D3pX96TTsZXdaJCozJRw\nbqszakMAOINer7CLztyiASWZ8ofeIuqlo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTTCt89\nfOvMbDjGwbNt08hx6rE+CjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAheFsudHjr4mmmtRUi+tZGVxf86952pyFwCyL\nINciva0CIQDWqPXKmN33n5rMf90VqfdLRcbAq3Z9MLLjuQTP+5DEEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1824", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1824` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQuwZOc4YC48D/HKII14CrVwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMWVmODY5LTg1OWMtNDMzNS1hMzIwLTk5NTE5OWYwN2QyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGMzYWE5MjMtNDkx\nNi00M2Q0LTlhYWQtMjkyYzQ4NWZjMGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEod/guTDo1LdEEAQkorUWX3LBr7i2FzmtZgceg4u73/K8s5x1g48g1IKFEz0n\nRinehzoxQqfijRE/dZRfxdzJwqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyKNga7rfQPB/BFhc5W/Di+oNuJAwHwYDVR0j\nBBgwFoAU3dofBUzZEP35bM7v9rcNJLcAjGYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiADB/ZMq1qnCQ0jTJ7CoiIDF9MTFmj8JvW1Ul/pwMYCLQIhAOcP\n1CJ36E1N1WWDDvprtbl8lvhcsvqhR59OtQFAUgMr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWn9q+SUHUwzrgfydiR0Sms7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTFlZjg2OS04NTljLTQzMzUtYTMyMC05OTUxOTlmMDdkMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIvio6ayQnJ1ZacGy+Qf/Tn8hC4lgm9t9uoz4jFZEJHR2W\nTgdVMQrZpp0pzGWdButG3ll2FHFLrEe7BcKDxD+do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3dofBUzZEP35bM7v9rcNJLcA\njGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOAgPYy0KUazA+t7EBGckNMFZOh40zLmJDfOqJtaulbbAiEA36yXiem1\nDTmJGG2T/FTlRYrCOk5w8sMskyS96AJICK4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdZUoHG4qoqMY6yOMw6EjOjTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGMzYWE5MjMtNDkxNi00M2Q0LTlhYWQtMjkyYzQ4NWZjMGYzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMGI2MGVk\nYS0wNzkxLTQ0ZTUtOWVmNS1jNTQ5ZjcxZGQ2NzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARcMuTWvfJintKTkk22FbEcnko7WnkpqUtiGyTJsQSmgchHor70OEtS\n1egEV4MtSDY7+b2MXlNZrPDZ7z1huCteo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIo2Br\nut9A8H8EWFzlb8OL6g24kDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA4P+KoxZJ0yzbSPVO47ElrjJS3nizYhq9UlYBU\nn2S7KgIgWfUN9BOoP3f3GpJNo9O/YMHkHOKQe1Gi3N0Zy46Cz+Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1825", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1825` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAVGpXAmeCXjYDNb/KQsKcoERMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyOTBiZWZmLTVlNDMtNDliMC04MGQ4LTQ1NjM1Y2Y4NzQ1YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg2ODU5NTctZDEy\nMi00NTA5LThmZDEtMDMzMjE3Y2Q4ZDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4/bOBStmTkFkcK9tPNkXZcofygbQpXzd8tcvrt0sTKpPN8oel2byoWQqK2Hq\nBYauGg4U4jzo3PvaqR/ooTx6vqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOGhLDkoKljFmyRoruIWRANO1EFEwHwYDVR0j\nBBgwFoAUSas5K5xgxofoxOImdMVU5CJ9U20wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAMLqkps9CQmP8r\nILHkYTkXNUHMGbKfydDm7u1wngQf+gIhAPHqDjXe5iaSg+KWBp5daXL3DxrBhh/8\nus0GECK3jcKa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATPJBQe5P8jURXE+EAbu+kB1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjkwYmVmZi01ZTQzLTQ5YjAtODBkOC00NTYzNWNmODc0NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQK0GCVAc7xnj/oCZ8NEUPuVKkqKk/96JLEO3lpMKCu45yw\nhgum/rIAGrSY++EDavbQehbUSQQeCEZTOznckEPDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSas5K5xgxofoxOImdMVU5CJ9\nU20wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHmLCIlX5ssIhbStQC5Bk/9yKzqDJZ8XoWO1nek0g0xkCIHZtjBV4kZn0\nW6/71CpCAHtVyHvOd0WlIcfnxEyhEBBU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATqIgozdTPcYMLTknGSYJnvKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg2ODU5NTctZDEyMi00NTA5LThmZDEtMDMzMjE3Y2Q4ZDFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YjdmYWQ0\nMy04YzU2LTQyMzYtYmEyZS1lMmJiYWY0MTljN2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATbvpA+cnUeS/dioInFjXETi/LNkSoFIpkrisa+tbrOYcdhn3rY7Wks\n5EKa8OZA4YtijdBq6AZPrii6uy1r7YYoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4aEsO\nSgqWMWbJGiu4hZEA07UQUTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBkyu9rWuOVMwZDMhObLJ1mM3U4ha4j2FOrVia+\nsei6LAIgX2ah6JMnVS4ZiQ85Mm6M6zghrzM25Z2WYCFSZ7PHxFg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1826", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1826` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbGCCsh+PRQh/9srOkD84xSTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0NmVmN2I1LTc2NjEtNDFmYi1hYWY2LTdlYTFiODhmYmI3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjEyODdmYzctM2Q1\nNi00MDllLTgwN2UtZjkxNDNlNjFmMTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsyEeu6yoJRGb2EwWc9wKUMWaWK/t231vQtQt7XZ4zKuS6KJvaEudFHY1ADq3\ncIB1Fo/4INX1T4Xw0kxrsXDGqaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJEB83+fAmHix7ZC2LFRsVJApAJwwHwYDVR0j\nBBgwFoAUu+PmiHuCshnEbQrzazPYunZ9V4EwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEkFW+cl6Ox34qv6RYPhgTY6X9qhsG7j5tCoP8jWrjKOAiEA8PXveh48q3ew\nroyy9wU14LcQUklQm426paFppheyu0w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVpy7EO88DbFWFDqkUp+P07eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDZlZjdiNS03NjYxLTQxZmItYWFmNi03ZWExYjg4ZmJiNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARffOuQxhCjjWq+3KKOy24PIAPMO3febAWkLtmkBJds0NLY\n1b4I4kKQlR4YnNcVfnsjoPaf8RUb51pNAL5ZxHVqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+PmiHuCshnEbQrzazPYunZ9\nV4EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIk2D8vM/4n+WoJTt98Yly8u/22iNp+pNGBm74jpQNlgAiEAwgdjf5db\n4Rtjl/kEBG1C/mOiTspgbKeOjCYXimL4oDE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAaMzWzFU0xT2eoiwh/d9u2AIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjEyODdmYzctM2Q1Ni00MDllLTgwN2UtZjkxNDNlNjFmMTIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MDNiZDQ3\nNS02NmQxLTRhMGYtYjI2Yy03ZjcyNDFlNDU1M2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATLWrV6uLFqQjsP61vE/VFMSrO5tiJzIQS92bphG+NQh/nNL8eh1akg\nkNVV+Y07/p0AuOu/9x5NaIoQf2IH/MYio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQkQHzf\n58CYeLHtkLYsVGxUkCkAnDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA8O3je6A2PA2avoWKQh/YDiG1YBq6oKM1XDdx\n5zKGegwCIQDvpZBs3x0QCajD3OXtYpPgvd7v3zRnxo0vkZtCB8jr6w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1827", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1827` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYoeMukmFHB9TIDjGbM4ak8GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4ZmYyY2RkLTRiNjUtNDAzMy1iZTBhLWYyYWVkZTFlNTUxZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTExZWRlNTQtNDA4\nMy00NmY3LWJhM2QtZWJkOWFhMzU1NmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERY72C/p45vecgA7zm9+0qmt/VERfXc+p+854u5ssoSg1pGCZNFEk3g6Ns/1d\ncUs3EljqudlmkofV8xgFjydemqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsuIrmoscINLbERYIDx+mOGKeSdUwHwYDVR0j\nBBgwFoAUuZTEWwlbI9hgkMZlpmYeFdnkbm0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBkloFWekKAb/4Z1gez2ZcQ71p0xOEsQFE4SOWWN/QCeAiEAjquBpLUiTQLy\n1K2G9zK7r+Onn+BNzEpyUPzKH6lJpAI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaF2hX6VLjHEn735Y32CWo86MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGZmMmNkZC00YjY1LTQwMzMtYmUwYS1mMmFlZGUxZTU1MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAWelhVbAroZWlwo+8VqkEsPFHkmVSeMAs14Shu/WhghXj\nLVMPDq2hSsH46hKoRE54K+shOfPA8BfrHI/BxgUGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuZTEWwlbI9hgkMZlpmYeFdnk\nbm0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIOQyO9DLInMshXm32nubq6ZCmb8QCuGqO1yYNfz/fFEAiBxm1ahYYFd\nCDYTnGrx2/zLqGb6W4iLzuHhYDIjQ7BHUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdBhpE5ZcPKOFWDRztvD+UiYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTExZWRlNTQtNDA4My00NmY3LWJhM2QtZWJkOWFhMzU1NmYzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMjEyMWVk\nYi01NWY1LTRhNGQtYjgxZi0zMzExNjUzYTAwZDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ+BcVR9UZ72Of2omgLf6Jy3NWUjZEfALy8639ynEOYVfsUMMNd7Yti\n7iNHhps3QY5mmPtIGQLHy6t3+NlcPI7No3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSy4iua\nixwg0tsRFggPH6Y4Yp5J1TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiATOcJgPyfLgqlzYsaEqlg/UDKJ4Lwix8kMOjCh\nj06xlQIgRrzOODrbsYJlW+KIvG3VVlnqgRDoohHuJB03EFjOtos=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1828", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1828` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISASy0WSQF9J42NYWTKjKKt6EOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3ZjY2NTEyLWRmN2EtNDc4MC05ZDA3LTUwYmU0OGQ3MGFlZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWM1ZjA5YmMtYTQ3\nZC00MGUxLWI1ZWMtYjJkMTRmNDE1YTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9ZWvnVv27tarRvUKdS6bii2seVPwgXKaX09V8eJZ03+dgKl3S8PlE6+gDi78\nLqKvF/ufMbO1uJpTYOn1c86lC6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeMlS1L4cRQn6EKDUjM4jxGqHh4owHwYDVR0j\nBBgwFoAUSWb8csRFnMD5xBIGsbkWTGX5r/kwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAylyzeNbwJI9te0gV/S68Bc6uFdB4tJpK3YhRoQGqYlQIgBRrKb++Vro7U\nzW5tg1+GA2YD0QMnn+EVMlCOQJglQJE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdStZgIKibq6p/RJCeelUxqbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2Y2NjUxMi1kZjdhLTQ3ODAtOWQwNy01MGJlNDhkNzBhZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVu3Hk4hAkg4vVI7NGsO9FYwdjVkjyNEH41b0gw/RMGyim\n1UI7cPVn/P0bHAUAXOyloyLZ5NLND7PXVOSVD1T5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSWb8csRFnMD5xBIGsbkWTGX5\nr/kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD2a7FWjEY82MRohO+2N0H2BsFiawYm2ZzLywytlz1C8CIQDOn0thesvo\nR2m85Ua85ynLdgqplT8Wdetl0jUAZqEnTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdQzqSm2FPJ/OBCicK7YNHKtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWM1ZjA5YmMtYTQ3ZC00MGUxLWI1ZWMtYjJkMTRmNDE1YTA1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1OTQxNTI0\nZS03YWEzLTQ5MDYtODcxOS0wOWJkMzI0ODI2NzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASvDMOkBZacvtABKPqONyeCNjjvDnG2qG+E6eNVZ9/5xhHkLLhmN8Xl\nimlnWZoSFnWnGmZ3Walwt4xV6jkNRtToo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4yVLU\nvhxFCfoQoNSMziPEaoeHijAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBrO+qBvo6BvcrJHeDcLkeLzAdnpCJE+KyDFw26\nEmSaDQIhAOiyeN5DXAES/4+Tn3kGpJCSPnIP2sTQs6VLgVstfFtO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1829", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1829` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZK2XgesQoBZn3nUAirGuBymMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0OWY0MDVlLWI1ZjEtNDliNC1hOWMyLTc5NjY3MTM5YTNiOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRlNTE1MWMtYTMx\nZC00MDllLTlhMWYtNjQyYzk3NWJlZWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtyaKEz9PSWIxewFX0ElcDF8XKFkOf9ADNDMoHgq279PsWLXLxDMvenb1DwAn\nyasgB3HHP1C81O1Xxd+gmj1K36OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURRBm/zsYpDooPyJuRsQH6FCJIOAwHwYDVR0j\nBBgwFoAUVwkK2Fk0StB8DmGjjHBaRL+5grIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAqx/AVo1UilxaY30U/yMeWNbaONKizdtwOZC/EP/Td\npQIhANYbQSQWC5maPEDE1aj0fRbG+fPNGMJClt7S+CZvPrmj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfP0nI/vjF2vtjnj99PMCIEUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDlmNDA1ZS1iNWYxLTQ5YjQtYTljMi03OTY2NzEzOWEzYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaRh4Znfduxh/ohjVZAk2k5cwGWrRoGlzQ/bclAORTFjp1\nsmhYTnagkQ7V1RVVZRpP6KEaNcr0ijHpgjFTctFYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVwkK2Fk0StB8DmGjjHBaRL+5\ngrIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANq2CQIDeEg6GZY7PS/BIxDHKtC4iO03AMXM4yppuc3XAiBc2+cpBA31\nTXzBPU8WqN9TkDCWAaDBl33xCBG/IwqOYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXf6yf4f2uYrpBL/Ktxr11tqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRlNTE1MWMtYTMxZC00MDllLTlhMWYtNjQyYzk3NWJlZWFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlY2Y2OWRk\nZC1jOTcyLTQ1YjMtYWE2MC02MDk3MTRjNDUxMTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARZJtm8FCwVruGARGvvdzJSut4s9q5XYLKZDgG2ge7bL49B4NWc/9lz\n2iJjR9tMlQDR0BEGn/E8je1SG8jWehwKo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFEGb/\nOxikOig/Im5GxAfoUIkg4DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA2yh200C463oMUTZ8szGARvvmbufUREO8Guc9\nOmSxy0QCIQDSU6QKjJ+Hmw1vF9HVtQXxg/5ce5kpihYbrn+p0KnGGg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1830", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1830` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVxMOZIkKID5MAcalS0fZJ4DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiMDQzN2E4LTcxMzgtNDFmMy1iMTk3LWUzNjdmOTFlNGM4ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTMwOTkzOGQtMzRj\nNi00NDllLWJkMmYtMWQ1MTAzMTk1OTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEubR/hafoNMmfaEo19zWkQd0qKBklKHPQDYdIPG6XzgwPe+e68jVPzPwmyjq3\nMzY5HN8V5Dr7jT9t81ifoh4YA6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0hPOLhikJTlKj5Rz9Jz8Yfnt/zwwHwYDVR0j\nBBgwFoAUhfLkeLqls45rho1Z2zVPh3KcMSswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBbwWkgmPwn6zB641WtG19MUU4WN/KUGzjQ3YmxZHNW\n8AIhAIkEQlYu2S3EZCw9z5wdTcirnT0QiuZnkgBjOASrlRDY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW4oeCj/IMwJwWRbxpPE0yZUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjA0MzdhOC03MTM4LTQxZjMtYjE5Ny1lMzY3ZjkxZTRjOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfpN9Jvq9tn4QbPqk+ZYwBQ2/KIwQ1OTHMaOKPbW5Wr8JN\n4JErOpcRCOyQXP3Itm/SC70AexmYcKXGF5IBTk1Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhfLkeLqls45rho1Z2zVPh3Kc\nMSswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL+5dc78kTrBZuMfVkgLqOiQMVcMYLi5gkTzSA31Tw9TAiEAmMwGiqyx\nGriXFF4hbAJVbD+kVpxaGk+qV5HRma6yWJ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISARaD4Igpy9dohbk3MRG/FktmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTMwOTkzOGQtMzRjNi00NDllLWJkMmYtMWQ1MTAzMTk1OTc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNDUxYmJj\nMC1lYWM2LTRiYzYtOTZiZC1jOGU0NTE2NGI2YjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARscYw259mu445dd7MJ27fZKFVTgPn0JPPBhOpavtFQmP+mEeyYXqyt\n2m3FBt3tdOb54Z2F8oO/t0aovPEj+bzio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSE84u\nGKQlOUqPlHP0nPxh+e3/PDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAkfHQl9YxSfJBxQC0DbT1hDfiPzTLasvNRLpt\nqKDwtQsCIQCcLtEbG6ZW7YIXjcfTFPgshIA/Df6lL7gkJNyjzhpkog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1831", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1831` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWvTjq/PuH4tjLjokcKFuxX4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjZjc4ZDgzLWRhOWYtNGM0NS05NzExLTg2YjNjNWViYWU2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q1Mjk1MzEtOGYz\nZC00MTZhLWE2NWUtOWVmOTZlNjc3Y2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGGzgdZCfe6bQF2C9L9luajmlrsjC1jFzEXIUCrFWrZhcBSVXlR7sh1q3idcC\n5gSqzi9xi9W6xSCLFu0pp8M5jaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgzsJzApdbq8fV4DMANeKSQrpG9kwHwYDVR0j\nBBgwFoAUHM/Wj7OyoQXxyIT3OKJ+MIIYKVAwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAsWGuKXM3jKBykbS53X7xhHrqtKka2BrN5z3tfBYWI68CICoH\nup1ymQ/mdeT7NP38SwZYA+Hy/glZjrVPsp8Ur/if\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdFCjMz14tVb/YIPe+aNFfMjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2Y3OGQ4My1kYTlmLTRjNDUtOTcxMS04NmIzYzVlYmFlNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhLK+rQ7e+P8TLHhbc8a/NXMqHmwWbVTTtOt/6U5kSCLXs\nosR6DLe+rjxWn9CzZqJx0+OaOzUDl0TIju3+NAW7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHM/Wj7OyoQXxyIT3OKJ+MIIY\nKVAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYo6m1XoTVrVbnn6e5oYV88flsDL4HCG1Y46CStEnWEwCIGNz4vVQffH7\nTWzK2w+xiP5h1Q4SukpT7zHmd1wtqy7u\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWl+Qs9+cQdz7e+ZWkDLXdUOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q1Mjk1MzEtOGYzZC00MTZhLWE2NWUtOWVmOTZlNjc3Y2ZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMmFjZGNh\nMy01YWU0LTRiODktODBlNS1iYWEzY2VjMDJkNzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARLkYBJudKRqWwRXs/aP/2rDJ06YlrTETspKnAgZmP1B40KqEiNa0sX\nFWkKe1CGnvnwUZrCnFkUDlg1YOlHJg+ro3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSDOwnM\nCl1urx9XgMwA14pJCukb2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiANkxQ2IFvYvSfFLxs5WF2J0Ly1IcWnxbrda3Bo\nt3BZNQIhAOKPgBNzScWCyWy4ST/mc30vtmwEalYkwJzI2IkukvcS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1832", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1832` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbXjoIMOW3hxmgCQF6hT6bsxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjYmU5NWFmLWNmYmQtNDI0Mi05Mzk5LTlmYmI3ZGZhZGNmYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjAxMWU4NGYtNjdh\nMy00ZWQ0LWJiZjktNzQ5M2QzYmY2MzQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9M6DFjLVXC0mUqHGUgVc7iZQ4W1XJteirQbY6RYKmXA9LvyARUatar1sK345\n9+HOQRYXK652GFldxziWs6FgTKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5sHLYR+ZRPCmeRJCjiQnQSebOJ8wHwYDVR0j\nBBgwFoAUUQ9tk+IaARES+x4bi9A1dCBa8bMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiA/6MrxqG9oYEj5keCc/1hV5xM2/B23igS0\nM4w2GQ54kgIhAO2u0L7AqF6c1Ckz0JQ0cJDoqVvVnkCfl7bmHcyKZ1t1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ25WzhxYYFjwcQ4G1vouGfMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2JlOTVhZi1jZmJkLTQyNDItOTM5OS05ZmJiN2RmYWRjZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARU3CRcdXBZAEjmIBFQilc+3S9ix8YIsc/aXj+tgBtpm6wi\n1lO70FL+/lNw9F59FuOaORF4/Qw1lQJCy6HqFBIso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUQ9tk+IaARES+x4bi9A1dCBa\n8bMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOXtxhmLdVykfU6XP2lTFPoRUTul6Z3rguTW028DwW7ZAiB5qCwJbxDA\n23+WorgHbdJMSW1wbhca3YguX/0I83JayA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcicL+PZYBUiGZUz08vqzFrOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjAxMWU4NGYtNjdhMy00ZWQ0LWJiZjktNzQ5M2QzYmY2MzQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYmI0ZjVk\nMy0yNGM0LTQzNjItYTUwYy03ZWYzZmQ5MjI2MmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARmkndNBJ7YCYjFbIVT75THGaoVj2dUz44zCofWm5vc6hn5wb585TVh\nygVDv2u51RCy89WBnl57H37h2hwv8hqjo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTmwcth\nH5lE8KZ5EkKOJCdBJ5s4nzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBU8h9nmyPWciCPiqFZ7znZV48nS2q39xYb4fUP\n5pfGewIhAN4pjUemkl+1cUrYhtmh+TuoR0TG8h/uDCfOqLgQeeHx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1833", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1833` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATFe9FtI5lYpDqSxf0TXAR/UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjZmYwZjhmLWY1NDQtNGYyNS1iZWIwLTRkMWY1NmNhZDFkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E1MDQ5OWQtZTRm\nOS00NzY4LTkyZWEtZmEyMzMzNzcxZDMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiQhcaVP9NjxP5DIlCGLhn+RpHhC3O5gi8xiIhi0J9c7bQmPryuf4X3vzy76A\n5cNoC4HxvyfbiUolwHRaHP4cGaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7trdNv+VaCqGPTPVavHlrIpP434wHwYDVR0j\nBBgwFoAUbf2NuU4fWrs+fHIdCMePNbHYUckwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiASqTNWCSc/LDbcOwy2Fp9qY0wbj7E0JsuF\nKfm4oZQhkQIgKLXsfGy5YM9d92Kp3nS/LNt5IsFZDeOJg4iwcykQC5I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdgjCBmht+OOwZQdMoP27Tk8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2ZmMGY4Zi1mNTQ0LTRmMjUtYmViMC00ZDFmNTZjYWQxZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQOUSYlqGv2an5kMll16dDzkS0aEeiJmCCkePZ4+IdbBZz\nbEUMx59aB+G1o5Hz7jiUbU59Ovd834beLR48Ztfeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbf2NuU4fWrs+fHIdCMePNbHY\nUckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMryDgqDIK5wyfPqqOhwORZzOR7QyHdMccWfcmAFa7sLAiAXXw5BK6ZZ\n1fryCNIaLEvIYN0Cj9JFOLO3GlBjciMjJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbwR/3CRdWQFcrHB2fdJYB8ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E1MDQ5OWQtZTRmOS00NzY4LTkyZWEtZmEyMzMzNzcxZDMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MDExNzMw\nMS04NDJhLTQ1NjAtOGY3MC04YzFhODYxNmU1YjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQtU5Hdp2+qifQB+qxZns3KBjTJ0Hzix9tBuFF+d6WCHgy1+sAOgkZP\ncRrmpyIAGQebYLYqqhPhpncLPsYs/786o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTu2t02\n/5VoKoY9M9Vq8eWsik/jfjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAueUm+CyxJNkeaVwkr96pY8RgaBrHEpUznxZGh\nn5/wBgIhAKptQITpu0Cwr7fgplts5qC3ovCYEFLoqTJMiQkB0F7E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1834", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1834` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAf2c6yId6KZQUWz/169j1rd5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjZjg2ZDZlLWU0YWMtNGIxMy05NDViLTkyNjUzYjc5MWRlNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGYyYzY2MWEtM2Yw\nZC00MTliLThlZjgtY2YxNTVmYjYwY2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExpwB+vunVZSRCG99/4GmgDhTsdAsSd2wCASO+RijnGObJTsHQPsM13NZAjGR\ne6fesxcWPZol7649PowCuSzlyKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMSmr9J7avU4sEag6+2CaaltaZgowHwYDVR0j\nBBgwFoAUczZh7Gci4I0zC6QiR10LsPHqOCMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiADp9tF3Ycyn3fm\nJe8CQ2vk3CetjeXaTeDwMN4g1CazUQIgfqbKoG1UIofFdJ2sRtL6YBWqnS2qu5qT\nKhh4y5eY4hE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVLG6iIliYIk6Y4iXmnne6kgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2Y4NmQ2ZS1lNGFjLTRiMTMtOTQ1Yi05MjY1M2I3OTFkZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9q3Qajb57qCjFMJD5Qjm21Z9Cjdn2O0fN7gtnm8rKST4U\nYM5n65c85gm2qlZhT6ce2+HntYtMmMd/T4vk/xnuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUczZh7Gci4I0zC6QiR10LsPHq\nOCMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI8Jhqf0RR6ZpVgBwKq01J9vGZlyUyMAUlIbicuvro8eAiBHCX14HYqT\n8zIxhMU56NnaNMb2BcOJMxaa7w9dU4EAIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAeVw3hiGhQznkljkMiVdUt7PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGYyYzY2MWEtM2YwZC00MTliLThlZjgtY2YxNTVmYjYwY2I4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NjFiYWRk\nMS02ZDhiLTQ1ZmEtOTBlMi1jNjQyZGE4YTJhMWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQOQ2kGEMyvc1edRmHxe8Bmz019mPZ8bJmyEBeWY0aflljiVxwmuOkI\ntU7cppo3X5Q1i+p2neJGHXCJR2vqDaSXo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQxKav0\nntq9TiwRqDr7YJpqW1pmCjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA389gY2fsWaYmVdO4ujzgCUxSvzxuStwlShDA\nwCxlp0ICIQDKobtn5mQONj32K1hNGcmvkg2xVCbVzB+1+nihFIcLhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1835", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1835` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASTP7NLkKwVbbMbDusoEZhl/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5MjEzYjBjLTQ3YzktNDQ2ZC05ODE0LTNhYjA4NDY5OWEyMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUwM2E0M2QtZjdl\nYy00ZDdjLWFkMzktOGM3ODM5OGE4YWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDedDkRF+meR0cwC8nbqUuKD3UirtdxIbJaIGP7Pz7fG70PR7LGQIxexhAbTC\nmcgru9h7GlK+QH7fPWOkO8Mh66OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwtAj8GHHsb9w+HV2OLeO9sX+chwwHwYDVR0j\nBBgwFoAUylcBg9ePcuADl7NUscQwXZFYotswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDIa3tAE63TzQqtikP+RrZBTYi/ojgWFCO4fVdu4lqT4AIhALxK5ZV6DHrZ\nuLv8XNXdzHcs0ZdcExKyfWzW2OCuA+Vd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfNTl5rSlIbLej0UHHoBUU/IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTIxM2IwYy00N2M5LTQ0NmQtOTgxNC0zYWIwODQ2OTlhMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuWoqTF1rEmQD9ZTf9i0+bM0e7kjAG+YMNbzzFM7ygxbRS\nSFpWUAPYv5EVZpXs/5BkrzqX5i4ReusAt1apmRCdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylcBg9ePcuADl7NUscQwXZFY\notswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGTlKrINpnIGzBa+82l8ZkKnUOL+5xAqRI1udw0DERwoCIFYY1lhuqDaf\nA58IgdRyPoyJiISGU7vCetbLhaDlFMF4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAWAS44cPsx6/gO5i1EjJpvzdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUwM2E0M2QtZjdlYy00ZDdjLWFkMzktOGM3ODM5OGE4YWE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxM2E3MTNm\nNi1hNDAzLTRjZTMtYjUwZS0zY2MwZmI3MzY5Y2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQb7CWXNwNPMQT4eWnXoS+aGzBEcyImzMQkkaNCR3ojMoy7oA1i4EB+\nfUB0VJGel816AcYcQQBhhAaaWDdYTpP1o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTC0CPw\nYcexv3D4dXY4t472xf5yHDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAlRlBYOKNxLoLz+9N0GBeMZpj53SGiiWf70SB\nmS0/3uoCIQDeK9qGuiBN5GOAfhNrcB5zBWtXjXcrVm5HdbsJnlziXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1836", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1836` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYhe71Sv3435wnElE1SGcSizMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2NzhhZTA4LTE3OTAtNGZkOS1iNzY1LTQ5YzU5MGY3N2NkNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU3MjE3NjUtMmRj\nYi00MDRkLTllMjQtMmFkMGVlZTRmMjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpDkEH54cx0URsBs4ztssC3YJUhjKjq3jZxrxXoW4cJGfUqq4MjzQ/HkvQ90W\ntJTr9HfA0vpfZNcFSs0Po8b9c6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIFc0ZQLo9AmWlu/8NX7l0RXIfUEwHwYDVR0j\nBBgwFoAUXeJZnj9PpRgS2SRm8Pfbpy/UUbEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCQzBqWmGUfWGK405gZe6RFirJrKEiGq1FQhBJISuxKmwIgKCQ4QEiSnytB\nZVKV6nvlNVxjGkvxMu9dtoQPBqu4sN4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbKsOh7+iXj2vFvDUgIB24eyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjc4YWUwOC0xNzkwLTRmZDktYjc2NS00OWM1OTBmNzdjZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNfUqTD4IT36uNPlDClV+1palkhkfms3yCO+aDIoIrOX48\nzajj2XRry2WoCK2ikY51AuPOw+0T97uSELIOLoHDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXeJZnj9PpRgS2SRm8Pfbpy/U\nUbEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAyP51aYP+pFXJHdpYqdHOkDY3GAa7LsRsuFgMDPuhgYCIDAyU0g3EeBg\n6pn5dWRJ/9TdQAs9e6tvVlJXuBAlf6YA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATKn/8ubf5Y0IB742BsX2nZwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU3MjE3NjUtMmRjYi00MDRkLTllMjQtMmFkMGVlZTRmMjQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4N2Q4N2U1\nYy1iOTY5LTQ5NzEtODU0My01NTU0ODJhNDZiY2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQz2lr7Dx8CZfG4KZwGNjqravtQmEyyejnknyWhiRo9LK0ZBW1dYJ3k\ntDsB1HsqZtqqceCCGEEl9HGgtuL7VYnWo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQgVzRl\nAuj0CZaW7/w1fuXRFch9QTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAqAghZ3yqnwzvlhYm1JHUtaym2xylAo8TwNLb\nESIkoJkCIBkhyO5754NCXwi53GflW9T7k8HJ8V187/uko/Q6H+ML\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1837", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1837` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAR9YDsjsBgvP6x51TQmlwV60MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3Mjc5ZTY5LWMxOGQtNDM2Yy1iYjNkLWI0OTZhMjFkOTYyODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjg3YzQxOGYtMGZm\nYS00MGU1LTg1NGItMTBmMTU3ODI3ZmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMK2OyWuXFiK9o0WjYK5uV22C7P/iLzXJrhxIYvjBFtZJK7AYFW966KDmXapt\nzBDAHsZxsxLbjiv8mrv9q7qpX6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAA41kFcviYhgp8guHa+4BQSkIqcwHwYDVR0j\nBBgwFoAUP1rtQXGTv0JATFYGZqDBxX/3gSYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBMRDtpthFDOuZIycccL33LfFUb1sNl33dwvHwHXW2CQAIgYghG4tKkUYge\n7IUt+GkqYwb57UtMdOpRWZo3Wx04iLE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARSatQvesiQEhmvjBatyXe3lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzI3OWU2OS1jMThkLTQzNmMtYmIzZC1iNDk2YTIxZDk2MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNRD0uXERt3cVHkImJQJEmGHeOv9/3sKGlrf8ZFTxmzqIt\nuyrwSEQcdww1twZfxo/51QbWCaWkzLB0FicoW1VSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP1rtQXGTv0JATFYGZqDBxX/3\ngSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFMcxKELOv6kVslUk2ocMTiHdqxspA7DpjH92jo4oFwICIQCw4UmL+EKi\nxVUMyXNpiQpQz+XtBlkY3BQ3vQmEBMVCFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZv1Y/tGMslWaPlapsKjOwBzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjg3YzQxOGYtMGZmYS00MGU1LTg1NGItMTBmMTU3ODI3ZmRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ZTRlYjdl\nNy1jZWRjLTQ4OTgtOWIzMS1hZjM2NGVlMjE2OWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATe9EpUHECBcTcT8YEq8aBxi4NyvVZWtt6QMc9I5tJ5H/uec+ytHXcH\nu8SZ0IBcfKSAMUnKJOKAK6gDaxF6jLPCo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQADjWQ\nVy+JiGCnyC4dr7gFBKQipzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA1xpBhhVyycIBp/0ANRdLtYFmxK2ADewGRuvP\nyfjK5yECIBrVFaaTXHsAfYI81TDPAV1U1mEiEJdjldpuOYdyDG0n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1838", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1838` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYxX4dBLtsHAd7CTtYcqb1MaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwODkxZmMyLWJjNWQtNGQwMy04ZGY4LTRhMmJkYzg5YmE4MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWNkNjE4MTktOGYz\nNi00MDRiLWFhOTUtMTQ5MGU0ZGJmZTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH+wM36DFje1uyPYcz/lskD9BUzz6GWVbe01nx5rVAa57uo2744O2MBaxvJ0j\n8BZM9dS6PX4AFVV4jFNNXqCzPaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURzMErljpzgk5k6oNAg8LDi6syLwwHwYDVR0j\nBBgwFoAU752VHFFNFoqAUnwTSgWpqlWkLIUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAiuaW0VhJF2s3kScde800QlT1X2/yvuXDRJvh0eA7\npq8CIHxDVbzY5yaoOgG/Vj1d6+X/vo0m2vzqYpIV5oj/BDU2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVpXvX5Tm3avBpsXwBzmtqLjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDg5MWZjMi1iYzVkLTRkMDMtOGRmOC00YTJiZGM4OWJhODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTBa4XZByAMXcnOCDUarmcm1kMIRKWOJRrGKGfto+tuWFu\newwZDgcvAp82v4edOvD8Z00qTiNxf5gutXmb/t/Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU752VHFFNFoqAUnwTSgWpqlWk\nLIUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ1iWjIi7kbIieFXra8uadsIAZW339nQ7Fu3lg8Me6v8CIHEWrYuS7V6j\n4b4tq3Fg/spK3+tX8p/u9TbkuIjczkI9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbtECrBNeY+l9Ewhy7CHo+Y4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWNkNjE4MTktOGYzNi00MDRiLWFhOTUtMTQ5MGU0ZGJmZTg1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZWI4YWQ1\nYi01NjU2LTQxNDAtOTFjNC1lMTUyZDMwM2E1ZjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATda7FnJU1uW7iGeWQH2hGEmUS3MCCyo99agCXZdCnygAeJRArpmy2W\nA6x2RRXuK1G1d1dvQMUye9cJRTn/ddCwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHMwSu\nWOnOCTmTqg0CDwsOLqzIvDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAA7eRUxhRf1WCau/EpLnYKobDb4VJfsj9NPwmh\nulR30QIgRI9fot+k2uEQe94/HVhT3pOXDa5/mV151tOrWThoXcU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1839", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1839` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAbp4vw4ghx+9QmeEYO6SR4bhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiYTBmM2I2LWNmMjgtNGE4Yy05ZjY3LTRhMWNiMDVkNjdkZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q5Y2NlYjEtZjAw\nYi00OGRjLWFhMmQtYTA3YzIxNDQxZGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhHzB6mKIhKRgM6ASyp8tMmt5kbrQZ/iKaSv5R/DwOUhLhpJo76gOvW2Nzjc4\nWHhT+f43TQNkxShVNS1MhtLZw6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxuPpCivHbqoIPmYuQoSKv5kx3C4wHwYDVR0j\nBBgwFoAUclnVBdgnDjkOLcvtJl2guJZyICswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAH1y+pnrXdiuGCpwEKq8rItFRnvRd4cUn4PW8Ogh1j\newIhAM8hhdUPp6e7vJxToYl6YLPPegIeVXU/gbiOAIIaGD+M\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZk/hk66667ykiORPp4hz71cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmEwZjNiNi1jZjI4LTRhOGMtOWY2Ny00YTFjYjA1ZDY3ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmp+vT9XkzRSZGBgn//Y46CpKLaxJbjiecDU+eG8yT2GcB\n5hL4DAZq1Q4ChNzmE5zc468YxV3QA9N3eX3rATDXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUclnVBdgnDjkOLcvtJl2guJZy\nICswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP7YE2FKfL2o/8Z7AwPGHYo4ZE79rDUeloE5Nal1wgYdAiAOH+GsoF5b\n+rsZJihg6j1DY/RaAXiUzEMZ22SBKE5C8w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAb0++HZ5RlRfCvL5FuuLdJ62MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q5Y2NlYjEtZjAwYi00OGRjLWFhMmQtYTA3YzIxNDQxZGI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NGM2YTIw\nYy02MmU1LTRiNzItOWVmYi1iMjQ4NTMzZDkxOTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASe8Aptfzv/Pjc28glkx7K+GaSTc8I6rh8X2lqb2B1v5yx47nI4UKB+\n/T1gb3GwAdTA8GPI0yFHkg7deWR8N/ygo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTG4+kK\nK8duqgg+Zi5ChIq/mTHcLjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAnrFlyU07dhDndbR7PmG9gcqDTp6m1SmdPXVB2\ngNLvigIhAMCDBfchpmXaNf6mjtvPb0zEu+zPL0VIEh5tslro+XUV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1840", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1840` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAdfHSTSuc+wAvAlE8r4QQbHlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwMTgwZTQwLTk1NTQtNGNiYi05ZThhLTAxYzE3ZGIxMDcyNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ0ZWY5ZDYtYTFj\nZS00MzE3LTlhOWEtYzJkYjE2ZmFjNTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOIR9jUG0yJ8nYiEHgH1C0D3zoxJ90W0PtXFoF/SmCXN2X3H8DeNcYyw9Pf5t\nM4/uryOzVGqav5ARNiUtab5/eKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOSBZhhFaujHzwsGXJG6v3q+nmbswHwYDVR0j\nBBgwFoAURVmiB8lzkk5H7/BGD8QKk5cFqIAwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiByBsYWgBlphEZFSprWhs4Yj37216qLgzrDOphRoj1gEAIhAJhG\njlpZY7Q4ODBOh6DUuvkwZ6Ac0ku/w1mXT1Vtdlks\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZbnxb5Zp0uwvDwpojF5xkZZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDE4MGU0MC05NTU0LTRjYmItOWU4YS0wMWMxN2RiMTA3MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7Amd4eIjMAkLAkgaXh1FmOnkEB4Hz4GGwMkT4RJFA2dal\nmlQkhwvOVb4U+D6OeUSD5qB7KcYw+IMMwy8npiBvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURVmiB8lzkk5H7/BGD8QKk5cF\nqIAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJmXvUfw4iZx0OH1gLNq7yHdimgydD9pP9AcNgqwIz0pAiAav/kAFw9q\nGRaIZoD1iLDk5inEt/NM3/QqgunuBrsyHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaYSFPcSuic3nZ07ONSs1RQgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ0ZWY5ZDYtYTFjZS00MzE3LTlhOWEtYzJkYjE2ZmFjNTVmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ODc1NTUz\nYi0zZmVlLTQ5ZWUtYWJmNy1iMzBiNjAxMTgzOWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASNULmlkZE8lPwyTs1BsinvahI/vNYKMzmgNn9JDMvGGdq3G7FoaJ7f\n3kmbXF0zelR0srBTLpwxb/e6qV8Cn2Y5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5IFmG\nEVq6MfPCwZckbq/er6eZuzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAPZvx1GqEe+/EdsjnipNdufkADqr/Z5f8FX+sK\nSl4W9AIhAKe+PSDdXm3huGJlLwmfmXDT/zvr09Wp1zBgBz/CCPxV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1841", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1841` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISATQ9PuKxtL0fxj/rdBBDbnyOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmNzVmNTVlLTgxMTAtNGVlOS1hZGY2LThmZTRkNzg1MTdlMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVjNjg5OTktOTJh\nNy00ZjA3LTg2MDItYzgyM2YzNjYxZmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHCS8C+B31fax5WZurAc79NbfntY5QhAtT9FHElzXckDAohLSzOaNxbV/LsBK\ntQIphLdtHgwFD5K9wHbj/BUw9aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdQVOXtCvz0E4Z1SNNta4pDCx2uYwHwYDVR0j\nBBgwFoAU2GLM/nLWiuKHN1DegBTYbSm4GwkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAiUk687CZ8OF06GDumvdbsJNcABmf6afZ\nvuGzuKqCRoYCIHKycFjGhkJILHkygpZg4QtCz6gmI6lF5aFQy1hS90R2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV9gSxU7V3/rdvs133H/1wslMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjc1ZjU1ZS04MTEwLTRlZTktYWRmNi04ZmU0ZDc4NTE3ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATS6zKP+/T/2/HG2baoMLa83ZUyZ7dnNUVOPOTdZTOU+hhv\nICjWG3gDCQVE0/83nMfhKtiYw4T/59c0e0w2NvIco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2GLM/nLWiuKHN1DegBTYbSm4\nGwkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ7quJpESwF7g3mBsa3OYhrfxS62H05X+xb0c4UOoULmAiEApcMJ7G/+\nET2ZLigTmYKUI4kLZj0cRh6+l7bvevW7MEw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVSOZdJzGP6IwHy8HcE3Hp8WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVjNjg5OTktOTJhNy00ZjA3LTg2MDItYzgyM2YzNjYxZmNmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MTc4NzZl\nZC0xMmNiLTQwMzItYWM0Ny0yM2VhMWQwYWY5MjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARt8maPJwwJbAOY7WAy92g4IIvTLrWAO5Tpwb6FUX4hgCNucOjUI9TA\nqztLR09WPqEe9shYr2z9TUud58RYYBzho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1BU5e\n0K/PQThnVI021rikMLHa5jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiB0TGRpgPnYTIgWLgsLFinkT+oEKJUzAmBGUrDf\nRq3F2wIhAL1NmdhPKGqNW4J5A1+zFnHV3siYQ2DuZjJtBEeh7ANi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1842", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1842` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdUEW4jNlNdJjcmosMzIzkWGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhZTgzODdiLTgzMjItNGFkOC1hN2M0LWRhODZkZWQzZmZjZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFhOTFhMDItM2I5\nYi00NWYwLWI5YTktNWMyMzU4ZWExN2VlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjgnbzsvOYclfjYN0HA7IUsxglcyQ7TmtoSKSr9P04MNXYbQEAv49V8Hxa5kz\nQA6LwZ50gK6gCLwTNt4muKLT9qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCieAJlgcYn9lS5BkgpZSSxEqVhYwHwYDVR0j\nBBgwFoAUZjgMGLmQEm9sK8PUPt9Qdcu1S9MwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBKugeFwhfzwYYqHkZQbrQF7eJGzhKwe5VZ\nzpfAOqfjCgIhAJKOMgvDVLB39Zd8pBDJJ6ppscVd0xddUS06xQp+czJH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATZ28UibEm5q0WYgPRKYEUYvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWU4Mzg3Yi04MzIyLTRhZDgtYTdjNC1kYTg2ZGVkM2ZmY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7JgXZrwyvk9f6czWeDZWuO8aeGuhv2h3+mhf4ovpTNqVC\nUHxA8/xeM/4HPdv5zJWZHhUDx/ECVALz/2YYGqBxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZjgMGLmQEm9sK8PUPt9Qdcu1\nS9MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXJS7IIEEAZuTnYvb28DVKIPE/EAd6NkTpFvXpp3+J1gCIQDuAxLNUpb7\nfmwj6ldIifOkTM+EkoetBnkB4h2vMkOiSA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAajOLXIfHJy3EdwPXdy/h4qWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFhOTFhMDItM2I5Yi00NWYwLWI5YTktNWMyMzU4ZWExN2VlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZTg5ZjBi\nZS02NTUxLTRjODQtOTMyZS0xZjJlNTExNDM2MDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATny3KHLVRITy+wMMpk64RDB2L3lf8to5Ay0VniaesKjCh5QPN7LR6B\n5bR0H2alVsczaTu0MOu+PN5oZaznRF65o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQKJ4Am\nWBxif2VLkGSCllJLESpWFjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAxPNMt09InAqvESwh+5IofZHawX/soMRK3J7Q\nBpskDFECIQCjTnxCXVcskbOTlSyGd3lsvftW+eX22xKpDEtEEXg2bA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1843", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1843` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdz7vzMR39rXmEvnTXWn6S3QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwYTU3ZTdkLWQ4NDktNGZlMy1hM2VmLWJlODM4MTVlYjE5MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjgxNGIzMDktZTZl\nNC00ODdkLWI5MzItMDExMzRlMDY2MDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFVm+KrgswG8YhwskRDGlM2RrSIBU5/54flxF+KjGmAETMxk3vbdNc19D7Mtf\neozyG3id0E/oenv3OKh1/cHmLqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGt37hiAPOKDaajCDGDZeBUe5+xkwHwYDVR0j\nBBgwFoAUYdq488XGenoxYux5IrqUvyfc5fwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDDtpCHRa8a+3rkrFWQuOhId/Gg\nbfUJ4H13rlg8TkwWVQIgNwUlAY9zITZf3aOKLF8/uEd7LmiyPQVdDqfPEIxEotA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVXzioNHF+ojI3IADZpIAyUrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGE1N2U3ZC1kODQ5LTRmZTMtYTNlZi1iZTgzODE1ZWIxOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoIBcwJE9KyCiqUkESGzm+AO4ZAc6jvsTyFwQIf6jWTsJP\nrQE5MjGDkLBgBBBgCsjyTB/5ULFcgSPh/rBLELReo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYdq488XGenoxYux5IrqUvyfc\n5fwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJsAA93L5Lsc1t5G48vGtGJfB6vlHLeufJvaZbRbbb/7AiEA1H8L4yve\nvqn/oVvyVnrzVnLnax+MNy0Vf9KyW5M+V94=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAcN9pc5LR8Ln7VBRppunmUN/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjgxNGIzMDktZTZlNC00ODdkLWI5MzItMDExMzRlMDY2MDBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZjViOWQ3\nOS04OGRmLTRhNTYtYTU5NC1jZGI5MWE0MmZmYmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARVIDq3wZpGHeNy+l0h2FK1wVQaAQJE9yLrIYGh3DwiGFYx61CS0Iid\nA1OpORch9HYYXmb7SbQLP87uA3YS8wNko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQa3fuG\nIA84oNpqMIMYNl4FR7n7GTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA4sBCCOuq7c14fAzVxsvR7b7krPdeWuPk9cUlM\n5ag4yQIgAOryt+iAdyqZRXVMGWgmIPs/DagOCo1lwXTTuYE9Uik=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1844", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1844` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAS/tVfPNcuyftaEd9ep5tYQ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzYzMyOGVhLTVlNWItNDA5MS05OGU5LWVlZTQ4NmU1NmVjYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTczNWE2ODQtOWUx\nNi00MmNiLWJiODItNDMxMTVmYzJmM2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsaMtPXMsrAzs19qZ67VvO/wqaLUZGZX8svR7wQuSCtLBE330Y01wM0RNMskB\nfSibeTkxheXIe5Frq7B7i4xfTaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZBL99zp328J7VYOIQsOOuxKZyf0wHwYDVR0j\nBBgwFoAUKXrt6CUeK2w/TwhpeSHGfd1uzvcwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPLCq9cT\nvO+qT/aZV1dRPcVB6++nogXAGSNTe1//BlElAiEArjsLJ8saXGETPznRAfwRSxRu\n8FIgVFxATWy3l5JlLD8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQl17zGg563f+zgn3kBlXr8qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2MzMjhlYS01ZTViLTQwOTEtOThlOS1lZWU0ODZlNTZlY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrlVBt+/K7WGGNEbFakhdlgwd8sKtOQx6fehERsKAajG7t\nUcPklzHXVTYQWdmE2w5oIjHEYcw9bwdH7SqcvMkJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKXrt6CUeK2w/TwhpeSHGfd1u\nzvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOIlf2Q1FO4HVrHcKUaZ+MmQgbK+wmLlSPGh87FPyst1AiBbLs3Qo+wT\n99w5yqP50zKF6qSRh0GZAO0kVNDqF+aUTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZMEwGEZeqX2UYPK56yTZbikMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTczNWE2ODQtOWUxNi00MmNiLWJiODItNDMxMTVmYzJmM2I4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZWI5MGU0\nOS00N2NmLTRjZGItOTRkYS00ZTRiZTUxOGM0Y2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQL1kjhppomtCXa3jIfMnzJPGTlpcn/TpR5FVwhmiHB+Uk6JzD5Kpe1\nzjYXldCERNZZoTyhI5/sz8z5EZty25k2o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRkEv33\nOnfbwntVg4hCw467EpnJ/TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBJkDGvUpK3gR+OyuQ6BpWCRcmAYBoAD5Ev6+xB\n172kegIgdE5sbnzxztToK0F6KVR4mOVvT/pO0ei1c9pIZO/Z5FU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1845", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1845` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISARCFXjH9aaySjCH0y05oc7r/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkOTNhYzdjLTI1NWItNDUzNi05MmI0LWRmNzk0NDlmYTIzZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc3ZWQ0OTktZjE3\nYS00OWMyLThlYzktMmI1ZDMzN2Q1YzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo5QSr6JJRHvntEwQnbYOx60ApfmJNelwLPR309ahZYj5MWTXySidiN7eUW03\nAWRce1ERiGaRUuW4RLL8EvlmOqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKtdLe9UtYbh0pf5DILQHEJaqZMMwHwYDVR0j\nBBgwFoAUYCRZfaSsfabVmvACqJ4tODK5KOUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgboPHw8h2\nbCIt18W1UZjAO/prvzsO4nbRkjrhe++CoAQCIQCsJjMbCbNDUTHeMz4RcjxqD8Se\naYWKozA+PTqNTWMT9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdBPY8tWa7YENyAMXhBV0hhaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDkzYWM3Yy0yNTViLTQ1MzYtOTJiNC1kZjc5NDQ5ZmEyM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASL0zO8NZv0kQ7zuCXiLGEmgTA3JsvwIjj5EDo+W28oaxSC\nbWAGEeiON+GnT8R5jwJBxSEx2LZG/QIBf/MFx3Rgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYCRZfaSsfabVmvACqJ4tODK5\nKOUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIlpkrB/OKPKbPEweTEdd+nTGV8o1elxpWMB0X7lJFOMAiEAhl+iY91a\nQVcW97Gj+/qeU7czDxCuUV7NtHauGxK4vUg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZwcyzCl8jZCbpUjRxfl1ErOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc3ZWQ0OTktZjE3YS00OWMyLThlYzktMmI1ZDMzN2Q1YzlkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YTNjNzU2\nNy1hMTAxLTRjMzItYmIxOS0yZGZhY2Q4Yzc5NmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATK3feBTa7C4t7qw9gfhw3X3fm6LdVANZR5Hz10TVNWFb3TSAx0Jj4L\njtPzXXzYv/fEMP/NHeelPAirCxgeJv2jo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQq10t7\n1S1huHSl/kMgtAcQlqpkwzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAS4w1U7G/ZhsRD38kIf+D0Fkh6G48PoFxlfIBp\nAfW2hgIhAKii8AujaoGGEzPspIjTp9xXF3nMntlZMPISdi8NATWk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1846", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1846` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAeP00OIENkORJZpaWgPGzxIsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2MDg5Mzg0LWJkNzUtNDdiNC1hNmY0LTNkNjA3ZjM3MGI5ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzkxMmQzMDktYjQ5\nMi00MDhjLTg4MTYtOTg3ZjI2NmQ5NjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF2gOhllwBx/jQTjwOr1YOPh5CJxP4L6+Co7K5oT5vISXyQdvRGwEs+Vfjeo4\n/mRmcsGdr8Lh6V2BBKRTBs5rF6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1iwZRoil/+JvppolaEI4TveVVBowHwYDVR0j\nBBgwFoAUbFksfqecYtYLEIIL+7E/XfYQIr8wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICFZVQnF\n+FGJkqDMYmHYRSYag9dMhkUbVdwue/YWk4SsAiEAsyLglJSa11bUb7vd5y0cIPak\nzxOOODTp08SLhr36WxY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR25Rbaiz//jfsryf5lzTJ5iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjA4OTM4NC1iZDc1LTQ3YjQtYTZmNC0zZDYwN2YzNzBiOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiQgKwHibjE6g8RB9L4Qgg9Z6R9ZOexA5GdUUR8SMZ0RBE\nKNnjvDL8GYF0sqLtPQOFeG+2dkjKkrasuExb8KCPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbFksfqecYtYLEIIL+7E/XfYQ\nIr8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMpx3rtMfoA1r8tQWQ6JzIm8OJeGWuqHle0J46rG4RnDAiEAyoceJyB9\nyLyegKNHqvc+bvvLzfm+5P2BqzPdp2Cmj34=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAa6CkNGZaFnUg6tBRYQjUCa5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzkxMmQzMDktYjQ5Mi00MDhjLTg4MTYtOTg3ZjI2NmQ5NjhjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiOTA4Njg4\nZi1iOWQyLTQ5ZjgtOWM2ZS0zZTQ3YTEzNmQxNDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQnPG1zQSCWnGTWwmX36l3jjc2y63+5gCk1xEz2Isk3eQChCc1uH6YS\nP2tHoDHxk4UpUFi6JN8gSb3aebzx9oWzo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWLBlG\niKX/4m+mmiVoQjhO95VUGjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBFd9XZejrl+Entpps90YOfXNnxvR9zimDULf5X\nJHZcdAIgT2irLeHfEFjtl9yc9uzOaTyPP9bP6k/4DCFktx8GVFA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1847", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1847` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAR3zp0+zWkBRFipgRGfCKCNuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0YzhlNTM3LTMzMWQtNGI5Yi05OTcwLTM4OTgxMGQyODYxMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRkZTM0NTEtYWE5\nMy00Y2NkLTk1OTEtZGQwNWE2MjdhMmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5hdSv8fUysoUfFsygUuCOpTxRX59kVJCyj7NQzAH/7ozeGrdd8zSu03BlEjK\n8l31Hzco2+Lg2PmJEGCryxZJ+6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUubEJioPNEeOu6r7J7ZAOYYxaNNYwHwYDVR0j\nBBgwFoAU39RtviX/wdZLRWlcrXyJPeGzzlgwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIC507VvJibixmSBxSM69wCHFIlHr7GCimZ0WxYncNchXAiEA92NocFQ7\nkU6VwGYZ/APexrmzJhy1LEW/Wiz47aLJbnk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATH3/li2J9f9ijv4cYF2TCd1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGM4ZTUzNy0zMzFkLTRiOWItOTk3MC0zODk4MTBkMjg2MTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb1YlFsg6gw7EfLxyEh3h2U2pJ38oAt1xTT1z7nkO5a0yG\nIRAzyONP+bqYFQX2l6UHAZJQLw6dp9ULsRp2sH7Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU39RtviX/wdZLRWlcrXyJPeGz\nzlgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL+qNpDq0B293eLqVEkoLPcRchqeIg0WC3JN0+vwIg16AiBQcyo4Tohh\nP/bkQF1uoruFJjy+cMCex0USh9IZ0YiS1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdfYFUEDNE4HttUHOT3/1LlyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRkZTM0NTEtYWE5My00Y2NkLTk1OTEtZGQwNWE2MjdhMmFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMmMwYmRh\nZi0xZWU5LTQyZmEtYjkzYy1iOWYxZTA0MTlkODUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATPLBbCcHNAb458ryvoYS8KtHwpgNqTvAJU03isZagw0DhXG5dSF7OU\nuV4ryWW6yDc0pVoLIBnznSjNUqAkjaqSo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5sQmK\ng80R467qvsntkA5hjFo01jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAm+DGMPmBSH7vb3h/uI0vICLKZSxMnYcPudv0\nD1Tg6VcCIDzxUSsQRfSWhTMhYkxJoe6Ov+S4XMVDz4gGFOXuAvHl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1848", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1848` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAVFrVEaf3LIiblJJAY1enCA0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlYTg1YzVkLTUwODAtNGRiNy04YWQ5LThlOWVjMDFhYTAxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JlYWYyZjYtZGY5\nMC00YWZiLTlhY2UtZmYwYWM1NGIwNGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEawRl+yr7g6y29JiGtWxeZ6yFKpOkz3tt+ftNwUOrLaZvAoxe+Vic1OPeTp9g\n/QPleNYpHg30ACW6lvh7dgkTv6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCkWMooVGtyPFmvgBCGLDOwen5qgwHwYDVR0j\nBBgwFoAUaPUFFPsqQN+RWcy8MrVSE7nR9l4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCICoFEi0jgwkQEV2jo9xfzHhiurJ7w+n8G9CU+467i/OKAiAQ0mN3vXQU\nI79+ssllZ38jmhuZ2NgluUkg0McbwzDpfg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb9P/VhM0CCEzrZ5VDbDtgiYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWE4NWM1ZC01MDgwLTRkYjctOGFkOS04ZTllYzAxYWEwMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyfa+cZU0I8adnQR6bvi9EZ1wrA5IWauXWutpvYdPM0meU\nP9i818p+xZbDVheeHYaTI1UB6tRpIMQwu0prhdqbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaPUFFPsqQN+RWcy8MrVSE7nR\n9l4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANfqs0yOuOnjIxELME+obS0eOh87DBRxiA26WZVyHex8AiBOk2OztK24\nPIbAtlHLmq1Lk7Za88RxGfslgyvkTOyUyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAWKUBD7mi72zN8P4wl7MlvuDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JlYWYyZjYtZGY5MC00YWZiLTlhY2UtZmYwYWM1NGIwNGJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZGU2YWNj\nYy02OWEzLTQxOGUtYTExMS04YjA2MzUxNGEwMTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATIDtJrKu+GXYJQXseDSEh4a6ZD9YXneSQ+I+0+x7/3CvD6t8q6M58r\nXhkQwhqtTMj/u2HqWznf43/n/EPI4u45o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQKRYyi\nhUa3I8Wa+AEIYsM7B6fmqDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAWxhD4szlixH+NybtNEy3/WWY6B6OEtWjGC4KO\n/85eMAIgQ7MtC+YGT2QViqtFROay6Yy/8j/12fYTjk7wIajcnmk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1849", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1849` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAVd656Uuq+Skp1IU96pWQDirMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4M2Y4NmM3LTA3NWQtNDY2My05ZGE2LTdmMmU4ODJkYmVhZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQwZDVkZmEtMDNl\nYi00MmY1LTk3NTAtZWQyMDc5NjM0YmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBwnNDx33TO3tIJFzjSU62V7xfWVc5lMl7Uc16jeLDm1s0uxYyaBwH5Hazdp9\nYj47n8wJjXOFWY2U9fOmzmWNZ6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU98cHOroBu1tsX0V6WzCpJIpRBMwwHwYDVR0j\nBBgwFoAU8qYRIB4wTHOtYlzPx0P8w/9QxvAwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDpNNkyMR7xRa5PQPGDpuzm5V5AcKVylLiiBw0inFlgVgIgLp9sOVzaU7cJfxDP\nFvPL2ap+qD32OPKPIU5MIVoicwI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdMBwSpmlITlZ5363eUyiQ4iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODNmODZjNy0wNzVkLTQ2NjMtOWRhNi03ZjJlODgyZGJlYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd1cbKyBYBnYc/tvOwgksU/0VbMO5GWAxCdimEKZv3uJ8X\nifhVcozt3RKIojyzBhG4DWQZAALvS7ps8dr2vBb7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8qYRIB4wTHOtYlzPx0P8w/9Q\nxvAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMMIN0j27HbpJHb5Ybfd5Xu/opcTTsK/tneYndvPpz76AiEAhJftotL8\ncYekSuq4gZeuGSkGrsRPEF8wUrcaDOvvXnE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAS7XwON7IHQT/ytfeQZ7IYrsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQwZDVkZmEtMDNlYi00MmY1LTk3NTAtZWQyMDc5NjM0YmU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYmU1YWZm\nZC01YjRmLTRjZWEtYTU3My1jNDA4OTZmNTVjNDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASlL4jYbSmN8GL7SHFJ8kYoRBbm5P615mmIOs5imAuDEt0VEhauSChg\nE4BumvLEIDcotUeBYufFa1plln6Lf1Vto3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3xwc6\nugG7W2xfRXpbMKkkilEEzDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiB2FI5/7UqH9hJ44MtgfvWOEr7TOt1yshPB1O+J\n2V6jXAIhAKM0wfSAzs5lfzhLrns8vk4YE3Bacp78VqglAdarSG67\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1850", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1850` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAXFfIqntjOFeEJjXUZpCGMZgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwYzE3YjcyLWM1NjctNDEyOC05ZGQzLWYyNWE5OWNjZmU0MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTM1MDk0NWMtZGQ1\nOC00ZGY0LWJiMWQtODE2ODE0ODdkNzgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmaB0SFfUmy3Q7qhDjAXlyOeW7I6Gkk1Nvi9rmzHS+5EDyqhDojKpgdioZOf7\npu4Xo2VTjcv+OtS4dyBeIvZJvKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXFAD9q4Pd8LiOfJ2p/mSdmR48pMwHwYDVR0j\nBBgwFoAUGO1bjAN5i1M0vfOqdGg2vlxVxQswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIEEVNioc6k1N85x7gi8M7wGVKdmF1D4wKpJ1CG6xwXinAiAk\ntLzknDqcK+lqubOIzIIyA50r8j4ahosQPp4GFR+oHA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYhfhhrdZvamb5ae9O5vjBX5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGMxN2I3Mi1jNTY3LTQxMjgtOWRkMy1mMjVhOTljY2ZlNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTaCKdobrtColowa8jo9WmxzBVMppVTmRWgQ8p0P5yIRn6\n/YF7/drxXc5BdGjKMRNwsagx0ngNLnDZrT6sSwMRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGO1bjAN5i1M0vfOqdGg2vlxV\nxQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANaAZ4g1eBC5zvFLmWe6NKcQKQsBrqnFOPlsaxWOD3MrAiEAyArcnF5d\ncMzh3p0ZQzKxVcH/DBZ4R5sqDvDVVJNMnMc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAeM6j+i8YY1LNO/1duPaPQexMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTM1MDk0NWMtZGQ1OC00ZGY0LWJiMWQtODE2ODE0ODdkNzgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNzA0YmIz\nNC1kOGFlLTQxN2ItYjAyYi1kZGQ3ZjhjY2Q0ZWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQKkYiLnPGA10p32MiIQng4YiiNbuDlHIKVROp/rB948No2pNPqTsqL\neQI3QUzumdkz46K+VzmN5KKC5C5FDu+yo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRcUAP2\nrg93wuI58nan+ZJ2ZHjykzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA3znM/2casz9ETtalsgoXaK7mkd85TKpR9dJc\nNK2M6OoCIQDRj3hZOgZ8cwcgpugR1CAkhTZPoYh51R8kCS8FJYjXwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1851", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1851` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAenvFQzlniivkJ+uSfifOGIGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMmNmYjlkLTY3ZTgtNGJjMy05YjA0LTE4ZWNmZTY5NGUzNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRiMDA2YjUtMTM4\nNC00ZGQzLWFlYWUtZDhlN2Q2NzA1YjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0h1JfQhp0AW5EgRMn0fFK9Itm4eAh9nT9i/RJYiXbaclduzr3v4fyjNjkuxV\neKWKFG9xY5vci2TWVo/SWSLjcaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK0UaAqFuZ2CTQOnhLYRdRtUgfPIwHwYDVR0j\nBBgwFoAUKpf+TUxQ9pxEFQJnwzJ+7PUIcfYwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCjiPLOxk5TXbyluDFMMWv/V0lrvQpaIJO6kDkCYJwEUAIg\nVW1BCGZgT24/oxyQsMQyi90zvYYJ5BIM94Z49upqQq8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWEpyyGoDgIItXoRb9MDY4xHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzJjZmI5ZC02N2U4LTRiYzMtOWIwNC0xOGVjZmU2OTRlMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsVsZwCbM0tcWoLfGgcE7rrPtk739DzqAqHiambjbemeIV\n1MWLXhMHwPA2GUC1iV94l7kOl94vyEbXuLDvws4Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKpf+TUxQ9pxEFQJnwzJ+7PUI\ncfYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfcaAewdNYBDhcgdhdytlAkgzHkPpHy0ganApuvLNowICIB38XfMsPwPm\nqgVooWxd5efzg1aO47NPN/nV0JXuY0rU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAR2mu1EO1PgIg6xgx9iOkZn0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRiMDA2YjUtMTM4NC00ZGQzLWFlYWUtZDhlN2Q2NzA1YjRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZGE3ODk2\nZi00NGM1LTQ3Y2MtOTFmYi1mMmM2NTY0N2U0MDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASDVUh8Pg0qbBhSsNdL9RWwzIosj6wCIFsheKK6AC7pgG+PDLlmFEZ3\nsHoGl3aV10K7aJc1CXXLMaxsbGLqXVqno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrRRoC\noW5nYJNA6eEthF1G1SB88jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAllaGGQ2VnHRnLBCzJrLkjAML/HlzkOfeKQD2\nwLPg9RwCIGr+nH5tdJAjftRPsZuwYzW/1eHwoDBXg8k/D5uoQh0p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1852", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1852` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVrct8bTiefKuSb3zn+YlotSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5YzU4MzRjLTdiYzctNDU1MS1iMTliLWFiODk1ZjhlMjQ4YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRiZjUxZDItYzgy\nNy00OTNiLWIxN2MtZGY2ZjhkNWEyM2ViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0V41kyDXzZsAj/R0kWZ8kOCJasrx9JSTY3Hn8n3qE00DEVQXdtpBBNLTVGYa\nbTSz1hyHMDrXBDxdOin4JdLFeaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ4x+IvnS2r5lyedOSwIzauFzlUAwHwYDVR0j\nBBgwFoAUfL3sKSWbpZyzI3bMIWDgU2OoK+UwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDD2myORUUk\nW7XRai2qQGBO89khXfb/QY8ydR1t6kPMZwIgIFn2ZLfHK6dCqqYSiiTh5mDJ4bkT\nEyrhlyDfmFc02/I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbl7WvCyA8iny7Te+j9kTAPqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOWM1ODM0Yy03YmM3LTQ1NTEtYjE5Yi1hYjg5NWY4ZTI0OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIJMGF3vPHaEue78wUZT227UQhYZJgZ3zoO9Oqg2/2LCCK\nUbC/uMlv0jmXqgKYXdxq5yl7fKQEj9N8l9FmJyyEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfL3sKSWbpZyzI3bMIWDgU2Oo\nK+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL/CA2ZjiuCRbCr2NBfXESts7MVJDHer4hVrE72SUiF0AiA5HS+2cew4\n/4cBeaVuy0NIs2e74cLy+09Zqohz03vTTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcwraMbEN3LvWIc5dxLVO4rjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRiZjUxZDItYzgyNy00OTNiLWIxN2MtZGY2ZjhkNWEyM2ViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZjkwMjIw\nNS0xYjlhLTQ2YzAtODViYS0yZTM1ZmI1MTY1NWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR3GQKsD18VWCTrBCgFGJcD7zppSASwuBYzYywXVBTB5LhLnujKm5hA\nRm2tw1nBoLe67DrtwjMX+GdtvNt2j6nho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRnjH4i\n+dLavmXJ505LAjNq4XOVQDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAm+peAO38GCcUKu8gF3AnuwxDeRBKQM2eMPJI9\ntWLD7AIhAN3IjZXwO7JHGN9A5GeqtIRAMcUJ7PL5w3m1yRZafPDJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1853", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1853` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAZ57FYF+wAfyXlVljAeqUIY+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMmE3MTYxLWQ2YzgtNDNhNy1hNTQ2LTdkNmEyMTVkNDEwYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQzYWVmZjctYTVk\nNC00MzZlLWFhOGQtMTg3NWU3OTk0NGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQOxOu5GMcrEp8l+0/ZIeiciWBhB3/4zOFalNyboyy2RJZNWzrjXRKKVheDU+\nBRwd1Ldwze9LuVrIPlXmoZvRX6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8jL1xpEf+Yz8/e9zAzuNNCWGhK8wHwYDVR0j\nBBgwFoAU9N4Ben4Z+gRGTs+bXco5CN7XDeQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgXgmHP96a26Fe9XisXGNNxhg241d5OFdC6TeRTaMFY0ICIEFD9a1VXi9F\nDrrHiBbYXV6xbWcAkAixWW2+6WwSTxNy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbGb722DtEeLor0TzYotgpdpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjJhNzE2MS1kNmM4LTQzYTctYTU0Ni03ZDZhMjE1ZDQxMGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2oDjLhLoHVGPzSDkdacrRUNqApd7ZtAobImLsoCPjLc0G\nnndVY0ll0LqJ4VzLmuDle7orXKBlVWecLl8plcvMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9N4Ben4Z+gRGTs+bXco5CN7X\nDeQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOLCNwFfXT7g34rpTBtf5BeD/zs1wN7LW19kH8c6jcadAiAc4s6NVYZa\nY89tPMkVxGanbtwNxnv6IOx7PsKG3ilJ+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAWhP9ter+qsKaqEt8F4koRSfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQzYWVmZjctYTVkNC00MzZlLWFhOGQtMTg3NWU3OTk0NGJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNGE0ZjI5\nYy0xZDY3LTQ1NWYtYmNkYy0wNmNkZTlkOTFmYzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQazgEiOZv6s0nWmObReanlFUXm14q+YCEumF7n43bYmSxIpcZIICk1\nTxZ7sPMojaM/4qNRi6Kp3IMdb2+RnyTto3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyMvXG\nkR/5jPz973MDO400JYaErzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA8H/ZIW9pJtcwROObtKJN/isnXSnUAOAKhL89b\nRbxxvQIgH9ycUSKHizIfO7mZsoOxfQdHSjQWfJuscjZ2jTdRYUo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1854", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1854` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARbvWLsXrXnymYG+odo3NVp2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzZTI5ZjYwLTdlOWEtNDQ4ZC1hMWI0LWY4MzQ2MmExODU5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg5NDFmYWUtNTgz\nNi00ODVlLTgwNzQtNjdhZDQ2ZjY1MWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1MYD1x7bz+CD5GLw6BAr1R2rVpRNA85tMtQOEZNn0LiCwSB4uGwrNjwHjQug\nmYeWpRhGxX7Z6uVHxjmUUyttDKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFRS3s87gF457TBalhXsEZcxoqTkwHwYDVR0j\nBBgwFoAULfR6z4q7liMfI/ksY7B9ZDo+QEQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAK9GQ3gxt2+5BNVjT+W1xVrTnu+ohnfmRPevk8RCf+RtAiANAxGC/+1C\n6IfzFYKq/u2OhdwDYSKeHdvN2/9lF2W9iA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYfWVhs+Tcxf7W/gQ8Psgav1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2UyOWY2MC03ZTlhLTQ0OGQtYTFiNC1mODM0NjJhMTg1OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaa8lPW3xq6cYlozg9iBoYkwmxej940VPJqGo+5KitDqGG\neMPLu8oeWa7fQ1i/QdLLBYS0Y9zb2CDeNr379kxFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULfR6z4q7liMfI/ksY7B9ZDo+\nQEQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM2fBqXao0yrfq0rdVbQ5Ypr0vrNEDcQSkOKQTNn1j5DAiBlaFBTYQuL\n3P+pWivlZZFzSvZ2c3sev6O3UB37K80QNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcr+datH2NY6Kd7Dv9dAowl+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg5NDFmYWUtNTgzNi00ODVlLTgwNzQtNjdhZDQ2ZjY1MWI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMDc4MTk2\nMS0zMWJkLTQwYTItYWE5ZS05MDg1ZDFkZjU4YjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASxb/ktu804bCzap0peOQbysn+AiRn81C0Uf+ZJXSB83MDs1qpvganr\nh1Sw90eOwhazuMmmYKHYnbdIsfFVau+Bo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVFLez\nzuAXjntMFqWFewRlzGipOTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA/7KjX9BDMuGaSMDBu/E6hU8yJZR2XQhreIGJ\nEhor9uoCIBMixzos3GzkF1Ck2tO0GVDNC8ioE9jdiLvsgvWfNBIa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1855", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1855` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAcarZslzYwbucqzxHHJ/u1kUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNzEyZjAxLTJhYmMtNGRlMS05MWY1LWFlMzg1OGJjNDkwOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTAzZmZmOTUtZjJk\nOS00N2Q2LTg4ODItOTk1OWMyMjI3NTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfi0yvi/kXbTQY6NK9AcKd06JrKTypsWRz7jqklClFtae75llETow8RyK3H7h\nDwREbBk4S60AQHDG2iL9m6SDXaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiLmLzTzPeEpdGTmF6D+FZzDKn9swHwYDVR0j\nBBgwFoAU8rAs6caHvNqWhX1Ut5rIDMhCHIUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDIKDclot6hm0CBPEEbfjHfaeeQc9C4UCLbYU1qEC7zWAIgTWnfbjGR\nEyQ44KLuHROgiZTDIZtrNF6YxcznOm4GV1o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbmWIfnFFTdgVJskFReT9IyQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzcxMmYwMS0yYWJjLTRkZTEtOTFmNS1hZTM4NThiYzQ5MDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzqzhHElMy+m1XJlTGmeKNBmf7Gh+0lhyz4ZNrg1HjrACb\noKAnnAsnt/vi4dLDFGKCep3ln7Nf6iz/UklnZcZ8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8rAs6caHvNqWhX1Ut5rIDMhC\nHIUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFsmPT5vFCkRugkUR1GL319PQ/RbZ6F/WmOH4piiVuIcCIQDZVQ9ErDHH\nq/ifdfn+3c5b5yVoK6CEWpfsdgQB1hQn5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdo+plV3BUxQqw4ZcIHQniEZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTAzZmZmOTUtZjJkOS00N2Q2LTg4ODItOTk1OWMyMjI3NTAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMWFiMmY4\nNy1iNWI3LTQzMmYtODA1MC1jYTE5ZDQ2NDg5NzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATTHqFWIUmWYVXokuu8B2CGZiDT5hZ1swVcKhChnHcDyK3KINszAWXW\nK6v4m1xQBH4wJyWDzWzICjJlIFvXMK1Po3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSIuYvN\nPM94Sl0ZOYXoP4VnMMqf2zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAQThTkfzzjDdn1J7Hg8+c2ryjuYuEnQ3uv7x9J\nZHH6vQIhAPPEuYfK7TSTxWMLPyRO+te5ZvnV0IQR/vXIe/UlcyHv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1856", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1856` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAURqulUj8wZ9D7u8aGQKkdW0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNWUxMGZkLWFlMGUtNDZmMy1iNWVmLTQzMGZjMzQ3NmM5ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBiZmNkZjUtMmJm\nMy00ODY3LWJlZjQtZjhhNWExMWM4OTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEljzsnm9y60ftLsQcD+/di0kyhfw4e2yhbGlSvV+LLQ68qNLTWgxSJrw3K/aI\n4DWT50wcbYuhkNi7h8bMZZ/0b6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3gdMWE8yTVixGqjII2g7mZcs948wHwYDVR0j\nBBgwFoAUpOM69mkeVxWG8Rtsxke5MIDoYocwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCbUxgQwLT5hsYZ7Is1o9QZK5jdzquV9y/xNvoJ\niqzvGgIhAKUaFFzzMS9r3dhW+r03owYni22tGFp17QZriNIzgPgA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdEo88KqHQ7aCjBk0OKx115gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzVlMTBmZC1hZTBlLTQ2ZjMtYjVlZi00MzBmYzM0NzZjOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7KMawMI/5QnBIXQUKr5bkfcjcPZDBf+ff2hHlJqBbDq7J\niKXNZZzFYdJkdeCq32wChrcfmCuLL9iSzKeRPQPOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOM69mkeVxWG8Rtsxke5MIDo\nYocwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaD38hjXx8hAc86xgQ/HrocWrUJts2SurMvO3YHwrilgCIQD7Mv1b2e0u\nfu/nibQekxZ4yjVsrUrzIhUT8vwe8qcmcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAXEi2PTcflVBsUtTmZBXo2DsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBiZmNkZjUtMmJmMy00ODY3LWJlZjQtZjhhNWExMWM4OTM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwN2YxOGY2\nZC0wYWZjLTQwOTEtYmFjOC0wOTM5Y2ZhYjVlZjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT1JdLAIlmjj9H+5Jb8+AjyBlTqyhMNMc7LVZp9dH3eOXxVige3AUsQ\nvXu6yBctDhwIN333CSS1u1ITlFKTgfS1o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTeB0xY\nTzJNWLEaqMgjaDuZlyz3jzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBjeoUE5JjvLAjIvVNB51N7wCMc+T06vNDr16PJ\npPkOOQIgZSYmerDeau0k4IgJqQnxXH3+mI9SRMtWodL4kTEVDr0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1857", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1857` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAWJNCsblSlbwbF6IAZtCIWSSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZGMxMmVjLTU1MGQtNDE0Yi04YWZlLTFlZDRiZjZlZjI5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI1M2FiYjEtMjc2\nZS00OGZkLTg2M2MtZmE2NWZlOGFkZjE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjWFgK1f7MBojzNGlL4s1uQ8PHts5wSRjXSu1W8YU8Z+affdMctZliZLmtEFP\nJEs69KYRZqHlkb47bZaKAr+pt6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZft5QGbeZm5M5/7Hr/YNo4hOQ0YwHwYDVR0j\nBBgwFoAUqvvd0BJuVs2IiWHHdlFl2YB7Fe8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCGjN8++i2fq4O/C6ZVxsmsl5JJPqzp1m5s8M6R\nPJ7iVgIhAMoGMMhehPdiOuh8X6p+25Ae9H/1cr1S0nqyqOROUbjL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZrVTi4jAm+RR01uDLpYpapWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGRjMTJlYy01NTBkLTQxNGItOGFmZS0xZWQ0YmY2ZWYyOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASon1Vn+b2KPTAU5RQ2MiyUQKzkRSFscHYmIspiu+30mnRb\nyY6JPYLpIxvAaoq8RQ0H+eHe/h3TIjMbiGF76DI0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqvvd0BJuVs2IiWHHdlFl2YB7\nFe8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVs5Ln4afTq/sFbggcWoycHpPbkhweNEnC8PJw4NEveICIAxcvYfe4h64\nhZXwSZzc7kDTJ01V4Jh7FKc0Fv7S1l6S\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATiW5QYj6+VBwTAOmnQ+QICdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI1M2FiYjEtMjc2ZS00OGZkLTg2M2MtZmE2NWZlOGFkZjE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYzhiYWI4\nOS03YzliLTRlYzAtYWQ4YS0xZTUyY2RhYzdiZmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQJySjukjpwJVRFYInPFBVo2DJXIodHMIcQ7plvXJZAzZI/0de5oGQC\naaPhzDV4P0/TXwZtSUUEJfXk8ZZg3GT4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRl+3lA\nZt5mbkzn/sev9g2jiE5DRjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiA/5xT914H8OD8bxW1fNUmXgZa3ZUHuyvgGZoCZ\nLlQcmwIhAMMmiRplhjBJUuCJ3j+4IayevH8qGNc0pha4ayR1WyXJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1858", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1858` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcSpa13hYo1G36ddIXZ5CxcJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxODBkZDExLTM4OGMtNDI5Mi05MzE3LTczOGE5ZGE1NDI1OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y3MjBlYTctZDNm\nZC00M2EyLWJjMmYtMjMzOTQzODFkYjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiTR7wUGCQTVBUERiW09owiutCeAuV6LQI89x4DJGIWJB/HoK1etYaYqxNYT/\nINnxz7rMmgT1JSzVvlkSBLHf+qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvmlrCJX26VB62HEofCc+mcnt0gcwHwYDVR0j\nBBgwFoAUzNZ7wCwxprdO0R6awN1gzppGnXIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDjpfs8tBIH6h5cU9eQLTfGvaM+YSrxQmXWa97NGjmHPwIg\nEuucozpjfy8+FEiPFGqpc+13EOxnNidWCIrgJHwzEI4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR2C59pGTsSYtFyyMiP34wh5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTgwZGQxMS0zODhjLTQyOTItOTMxNy03MzhhOWRhNTQyNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXVcJiqOogJtr9nmmawQcg1dMZVzw2qhLa2gcyIc3AHhMA\nMtEsNu42WcZNrTj93U5nZ/FWgK5ucKtT5pBa9QhFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzNZ7wCwxprdO0R6awN1gzppG\nnXIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOOxxQeGZyWN24fDiE7xpops/7OnvU2B1wuAZ2pl+fNdAiEA1WzlC2gz\nu1Oivd8aORbhAyGG39mn+mAZCkyAB7rCbMg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAeV+oevQSuL9gfH/P/CchkyTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y3MjBlYTctZDNmZC00M2EyLWJjMmYtMjMzOTQzODFkYjdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMDk4MDVh\nMC0zY2QwLTRjM2ItYjg5Mi04N2U1Y2JhMGQ5Y2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARpoC4Lgon5cttsxMjvbLg2FcT9mcEAfKxERDbZTP6FhgfmMY8Y2BR4\nDljj5YpGt6w/3Fg8RbKwqkgHXEwGiCQSo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+aWsI\nlfbpUHrYcSh8Jz6Zye3SBzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAuP7hOqSY2JTGy6HLht0ytGW5V6BCac35Ij1E\noc6iZeICIQDPmhupeBf7ljW6GDLtdggvRKn49Yo4/mt0Ms3VgAv8tQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1859", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1859` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAe7ZxS0JwMtoOkPOqrHYMZeeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2NjM3Mzc4LTk1YjgtNDM2MC05MTg0LTg4MTliOGI0YmJhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhlZTY1ODgtYzIy\nYi00ZmJlLTk4ZmUtMjI0ZWM0MjdhYTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv1CHMIK4JrG1BiuGG/DoSb/VmJXE94BCOaDBQxgbr+CDkyw0hOGBC9mo4Ao+\nyKF2Ne4CqDZElqrnmb8Axh/XmaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZMbRJnKW+/zj3SFcGp5G1ftb7WEwHwYDVR0j\nBBgwFoAU6M5ApU/73VZi29mVV9MXgGS5zUYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIAmjfajQt6G4L2CPtEXWwpHklZ0oZAXo\na8cOlqMwvMCBAiBjeApbcSRnqmXMUl3N8UTZiiWNmdB42ihmz581kgUDtg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARwZWxFIJKA/esPFKSHdOL2QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjYzNzM3OC05NWI4LTQzNjAtOTE4NC04ODE5YjhiNGJiYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3/MpnH16BVMTpTOzpXvLhy1ma48f0LCayXUphidJv/9+4\nJMwk+apRsKnKTWWArTURVw5ZKA0AWxP4a3E+4T2no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6M5ApU/73VZi29mVV9MXgGS5\nzUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANzQmkXTsQPZFGRFkL3eEARETyGowLfjfQi2UjuH58YvAiA411xbam8P\noWUIwkeqJ7yVOj5A65KlgvTKbS3/ULbVCg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAedednfyiOvJt42St42EFyqMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhlZTY1ODgtYzIyYi00ZmJlLTk4ZmUtMjI0ZWM0MjdhYTQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNDE5NTZl\nNy1mYjRlLTRmNGYtYjBhNy0zMTU3MTI3Y2EzOTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARff0s4YiUaAycIJq7Kb8hfNnU21a/tqZFC3aEDiUWAe8VQ3lrBFrPp\nATY5Sv6tEEhViAqkcUVpPoC0y2aLn2Too3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRkxtEm\ncpb7/OPdIVwankbV+1vtYTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA91uGTicyG1VoGV9Wr90Z1bSf/bovtsM4wzvM\n83mwmUkCIQCeaLlJwNhzQ0ZxIFD0kQdgRIrAPzfzgUtFqiU1iVcuFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1860", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1860` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAVkOAzTwh5g6WlQ7S6ejQ1bwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjN2JmMTRjLTc2OWQtNGUzNy1iZTVmLTg2YTgwYzJmMzUyYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTlhYzU5YTEtYjU0\nZC00MTVlLTgxMmUtY2I0ODk5ZGE1NDMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMSncih7evG5J3yX4b/3dWg0kI2bMJQc/CTxA1CQZEcZTxjhVE0vlMrc8yI9l\nJpYHhAyNHmvM03iNP0v35Zgw76OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtIgduzEZvYNkN1QkosW+u9fAjAAwHwYDVR0j\nBBgwFoAU5RzZspgSgJpgz0GcZAZQX08ojXQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC7KjTx+FQihAWllpM2UshPj0abbXzY\npwp3Ojpihvg+/gIhANYQw03AIWRL4AMB0q6Dgz7DQqdAFj8zFqXrosQQZd7c\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASVByFBp0P6/qKj/U8RHW51bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzdiZjE0Yy03NjlkLTRlMzctYmU1Zi04NmE4MGMyZjM1MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNKUIh7DO2zIFgqI+dIVs4EY1BDkInzmT4ROY0aY8a8s/M\n5PFaSY+6AgumFIJc6ELWEmcpHmJJQoOmvLjyBlQxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5RzZspgSgJpgz0GcZAZQX08o\njXQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIZtR3iU0kLNfcJUID9Bu3PJx0Ry5GJ4L4kSWT/i8/3ACIQDeuC6dP2Sx\nl/po3sxC+T7CR5AnzUc1D3j9MTJPRHraPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAShRNh5/toqBvOo69mUbwIERMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTlhYzU5YTEtYjU0ZC00MTVlLTgxMmUtY2I0ODk5ZGE1NDMxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZjY0MDI2\nMS1mOTUxLTQ0YTAtYjU4OS02OGNlZjAzZTc3MDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQi0aM4Wsya1fMrvBDDxomgWvqoLXHmeWMAqYlxjECFyEMdhQvl/NyV\ngYHNJmWTZddmoRD1Linw3SVVwWpGB2M+o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0iB27\nMRm9g2Q3VCSixb6718CMADAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBbLQyVG9sVHUuTnqcWXkBtJAAKXsrDUf++0+ag\nUdUffAIgXqAiAuK50rxZyCFLY4by+q1j6b9nafLA58y69tfCwEQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1861", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1861` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAZHjofEd1zenuKvSgSCrxsKrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyOWJmNGU4LTZiYzYtNDRmYS1hYmRhLTRmM2VhYjI3YzM2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQwYTA2ZGMtYmU3\nNy00MGFlLWFiNjctYzBlZmRkNTZiMTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEee1VnklR18ZBhB9n/Ny/J1x02srVsucTDryXEhGq6oZgaxuuwRXe/+cIkhDQ\nId+XrRGezB+ku0YsZoj1MuMIc6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzbZlvYyyl7yg01kUl2lNxwnqeSAwHwYDVR0j\nBBgwFoAUwUkb4kCu9iadFrvoq8bmN01VgRUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDsF7vW1E2k\nTIUDMq+n/3BCy5yJWUq4ihLH0cHRk3qrcQIhAOuwy1UVePT4B45wYsTJh52rkg9m\nShk+xtQI8/J0wsdl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAengzwuP158JXi4eu8f4bJBZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjliZjRlOC02YmM2LTQ0ZmEtYWJkYS00ZjNlYWIyN2MzNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATosd9+PfrMg4vfElNTN7ETFjFlTWsjR+pne2zCOaKx36pt\ntEMs+jugW/ppRHpL7f2ysgZFm+BpKA8l5nUY6AgFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwUkb4kCu9iadFrvoq8bmN01V\ngRUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIoRIOBRd8VvpyDTPMM3AkwybPMJtR0F/nen5G/XX6auAiBiC0+kqW4c\nWIFtgCpOCmjPmtuDaxCd+NmgCn0cD5yztw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAU7UflqQgAqaW/MGymr9IC6tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQwYTA2ZGMtYmU3Ny00MGFlLWFiNjctYzBlZmRkNTZiMTA3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkM2E3Nzk5\nMi0wMjFlLTRkYjItYTE5YS0wZjViZTBiYzIzNjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATJ6qi3xm+8ZweXIdKq/S7oemzSNIBeg+v14cDBG9VNH4fVXLcZSnhn\n3Z1VYMEj7DvMkVFXUoZ9hq0SstybTZSAo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTNtmW9\njLKXvKDTWRSXaU3HCep5IDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA4WOvkQnnjVFGUWooOTGqzrAxtBvPIFZSxb+R\nzVaOTKwCIG1Biw9Eu6xgvJH08nTC6ttw4/nZL/4+UO/V0isu46Yw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1862", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1862` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAW8f8a6N7MET8TBW76R4PKpqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMThjNmUzLTI2ZGEtNDYyZi05ZTg5LWFlMTFkYjAwNWRkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZkNmVjMWMtYTMw\nMS00NTdiLTg3NWMtMzIzZTA4ZDM5Yzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaJQy2MT6ogZ+iEMRG/pMrSxICUesncDOL73dHgLO0BNfBwNia2sJkqdzW6EC\nktruVMbMSECNcvILN+Auu9wrDaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvL2EI7EbdA5bdQYDF3j4HpCt0/gwHwYDVR0j\nBBgwFoAUhVRNIgL+8cd+EljJZI2pPeJYT0AwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMkzF5ASfXLVJXsPi+A3x0f8E/wCQpqSIl0FIuwrd3KmAiAsE9f84ZXG\nH4Qlm1tjLqcTDCqSq9PgjkK0evbqbH3LIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYu3lgFL0uxXKqgD4tTblHaYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjE4YzZlMy0yNmRhLTQ2MmYtOWU4OS1hZTExZGIwMDVkZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8+EOscGYBikbxBXNt9FjjV9PPvLnqOkOeiOExwWf+Yx75\nvVROyTQF3NLIgU2PfTrAIE3EP+t27iwnWvuHCmfco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhVRNIgL+8cd+EljJZI2pPeJY\nT0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPKiHl2Iz6Pwpq9+mRdTVCE5b/Q4Zi3TaUJVPERuXZFcCIQDKP5jDegNm\nV98zCPyFcrYNrHKOh8g++F6n3IxKD53HtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAUSQXrCL37AnLNApUpj0LZlMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZkNmVjMWMtYTMwMS00NTdiLTg3NWMtMzIzZTA4ZDM5Yzg4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkN2YyNzM5\nNS04N2ZmLTRlZWEtOGRjMy0zYzVkOGIwMWY4YmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS2HOM7QXhaurV/INkYpFD3x2zIC7UFQU0GG1IwB5xMGp3erZup1nFq\n/HsW73IUxIYJzNCzo8HshpwbwZSS19Iro3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8vYQj\nsRt0Dlt1BgMXePgekK3T+DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBDU3LUjb5wCWIp4dBhE/zlDxocONnX1e45NVj/\nx18bAwIgTeavSKAuIIBrl6SKcKnF2qwq06YVOSGGo09BX2oOeJE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1863", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1863` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfOPBliNZB5qkDCI35Gj0MuZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmYzA5MzhlLTk4ZTgtNDBiNC05N2FiLTQwOTk3N2VlYTA5ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY2MGYwN2QtNTM2\nZC00YWQyLTk5NTktODg4YTE4ZTJjY2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAY1ZeB8h8ML3gCuw40bha0+vf8k29LIHE67541Xg46iDIDUslJP3mj+p6UwU\nzHTOD3kYd25isZhagZIIcjLaUqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh6C61xzniluNockp6ikv3eJIA5wwHwYDVR0j\nBBgwFoAUHBqaFJojqyBbFvnh9mfQCGJucygwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAPnPfyN025l2LxDl+L06vzfUlfvAkHqyxdyrEEt7tV6FAiBIOjPO2AEo\ne/wwUX1c8an+XaL+WYqIhPz2Tb2en+uHJQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW0Bq82QkHsOMadNjzvm+oV2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmMwOTM4ZS05OGU4LTQwYjQtOTdhYi00MDk5NzdlZWEwOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqYTrn+kdkSiaI4phfKZght91RJvViZGCNHElBmvU/KlJs\no4FRFdktB8se90nCIzJKoLOlvrMYkh5PFVzrwjYao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHBqaFJojqyBbFvnh9mfQCGJu\ncygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH0kYIMLcGh+/qS00shgkfoadJYaIR24iFEcwLHxXFH4CIQDqdxE8qj3Q\ne9YnJBGZpWPyVjKvh64iKYErPRIVc97k0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdHL64w01TLPegsTCFgVlowJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY2MGYwN2QtNTM2ZC00YWQyLTk5NTktODg4YTE4ZTJjY2YxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNTczNDgy\nMy05N2I0LTQxOWEtOTA3MS0zYjgwYWM2MjZmOWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARtX3jMfUhmWVPplFf6rk4l4Gfc5KMvccsnDLelzTu6Uksgp1VKCzMd\nm8DJm+DHAxYSuEKCjXAqtJGNw07U452qo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSHoLrX\nHOeKW42hySnqKS/d4kgDnDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA/eAb7qpeTTp6IH+sUTa2pR6LcGVrq+AVenO9\nqBU+0mUCIE/qr0mY52EQY0jjCb8DST/+m18voqf2mQASW+AZNxPQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1864", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1864` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAXXyl2A10Ew0TB+OqwCFqB7iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2ZDE4YzA5LWFjYjgtNGNhNy04YWFiLTExYzI2MGZjNmY1ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q0MDlmMjgtZjQ3\nNy00M2FlLWJkYmEtOWEzOTRmODBhZGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENKJYAa7hjJ/MzjX7ARSq5wm9v5/xgs+UVBJQhgZSLiRrmjHneMgZXze/60YN\ntrthYZYkHMXui/zorAMGGbebFaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5oXjGF0sCaYgcuvSfDIb/dV+TwMwHwYDVR0j\nBBgwFoAUIVrMBKNhG+qtH0IGD7S1iv9I7agwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIGEg3nBwjzJRNRmhdYHunWC7gE2sm2aCfRsrk5jZfVmvAiEAkUTMd11Y\nw9Nau05KomIGJ3bcf1ghuw6xkUaC/iOsw2M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb/DIvA24nKaLQTYf5tPhJi0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmQxOGMwOS1hY2I4LTRjYTctOGFhYi0xMWMyNjBmYzZmNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREz2Kr+94TJmxUwMEVVhQ/fQF6d3rAJlxZCJzzfUBKH9Bx\nYQ0GrNq0QlyfJQbRVnw4ummMcjbug6ojVc+YYe21o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIVrMBKNhG+qtH0IGD7S1iv9I\n7agwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIkVAiBXHoJ4yG64GYxWXHVBUM+jsOkWPjDEMS5xPOxFAiEA01Jccwt/\ngsyqHVGpEyRuzAsgTbXNvOF33EgMjcz1YNE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAcbL68RV8U7DlHACoklsxCl8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q0MDlmMjgtZjQ3Ny00M2FlLWJkYmEtOWEzOTRmODBhZGFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZjY3OWU5\nYy1lMWIzLTRhNTUtYTIwMi1mMTQzYzU3ZmM1OTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQhZv7+wSU/Ba301w69n6XIXurNa1POe+fK1DZxO1PunV/7j3hjhbfL\npEHcvHyiYKeQQl9iPRVNZrlscMpWIhkco3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTmheMY\nXSwJpiBy69J8Mhv91X5PAzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAp5u0W1JO78l5LXqaqPQTdG/xoJkyYHRFuhRA\nuAFP4CMCIQCIvMtYdVcc6gadjlILrIDIonlgxQ1dPGa4CH0oMSJBHg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1865", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1865` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAdhJukN0lRbrTAupdRV86yEZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5OWY2NGQ2LWYyN2ItNGEyMS1hYjgyLWJjMzg0NDY3NzM3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM4N2MxN2YtZjZh\nMy00ZmY3LTg0Y2EtYTE0MjJlOWE2M2JmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6tgzf0vtR3CxoyFa6fYZCmesl3amihzXfipwLSgH3RlgnBzAVQ3XKBlcxvQG\nwW83wjbICp/PEhMOMGUcHaJetaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0WY3lDD2Nsi09RDeQu6ge+6zGiUwHwYDVR0j\nBBgwFoAUsmTgUKJSQYpRytwdgO/6OIqOSjMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIFboJpSPvyZwK0HuqsuRbAnnkfNvs4iL88nClGYT\nFW86AiEA/vhSrn23Pke3raZcT52HS7jzK+IwNOXXAyCdsCbOdyE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQwEX+LCO5cOLcPVlh+kzZb5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTlmNjRkNi1mMjdiLTRhMjEtYWI4Mi1iYzM4NDQ2NzczNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATu4VsqCJvYt8QN7U36FO0vNIRkK6WvlkmLemD2TGbPcnXM\nzCLRrur+EeHAShC0mJLBKkNxbXh9q81cLfex3/fYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsmTgUKJSQYpRytwdgO/6OIqO\nSjMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL2jffx/zyFFMHY7pY2TBogLQh0Dt44MVQlsMfBx9DjYAiEA+QV0dbW7\nVJs/AewxHyV6sBBtT9w9g+ZDKjht4bnHTso=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAV2i8zKURRVTndbPAkD5NGpcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM4N2MxN2YtZjZhMy00ZmY3LTg0Y2EtYTE0MjJlOWE2M2JmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNDUwZmFk\nMy1jODQ0LTQ5YmUtYjQzMC1lYjQ1YWY1MjNjZjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARVw65VErqPGam5kPxN71xTmS+0PZA3TBfZ/GxDqNJkO4sLyFRR0ktM\n/dwpljMVZYUUz1E7UMLPDCIwwMvXhXD7o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTRZjeU\nMPY2yLT1EN5C7qB77rMaJTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiACho7SGwR6vjTh3WONUDxMnJKEH9F564n2oNUh\n+96ScwIgXJYhzMBHP0sQeqQbNwAQZW7idz020r8LagBnStRvoZE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1866", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1866` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAc/o+8h2hPZb6aAOLgL3pA4eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiN2FjMzFiLTY0ZjItNDVjMy05OWI1LWVjZTk5YmIzZGNhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTgyODc2OGYtOTky\nMi00M2FlLWFjOTMtOTkzMmJlMmQyODRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0KfQXs/BeTRDg/wwh21uWuXEL6Jns8cyz2CfPNhcQ3l62QnOj1B3mviGSL9/\nDZboYxlWMj+P6yBvS5Qk+FBr+aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIqDdt4iF1jX29J3tJptttRC1idkwHwYDVR0j\nBBgwFoAUJUOxmwhSOmCj7nfzkHBo5uJlkEwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDrx01xOYmFOYNR5yp4BVnjR8UjsEigYOxGrtVG\n2rokKgIhAMcKqhrsyu4nXNQtcbmMlxY+t865ia0inHLyRsoBJ97n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaUQxGaJlvfMylP7gDKW97cVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjdhYzMxYi02NGYyLTQ1YzMtOTliNS1lY2U5OWJiM2RjYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnx0V+spiwJyC+j2r7lvH3sf+yGdbip47uLGdnBAxRJ0L6\nQtQsBWL9EGDHaVyFzHy6qM0jl3NVxvTMrB53kyt6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJUOxmwhSOmCj7nfzkHBo5uJl\nkEwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM1rdobbZyxl9U+9syagZClQMi24MiQXw/RQMqW/usf0CIQCitPqVD4O7\nLCxGx/vsWDH3j+FB8Xitk/cifYsxtURzpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdmgAwIBAgISAZ98Au9lzjsoLuaKvs/bg92DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTgyODc2OGYtOTkyMi00M2FlLWFjOTMtOTkzMmJlMmQyODRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NTBjYjQ3\nNS03OGU1LTQ0NzktODA4Ny04NDFhMWNlY2I0ZGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARuI/6UvPzcT7o1CDBFQxQ/elGLq1cMLvzbmfLf0RxzPhN7W7IBCmQM\nmgmj2aQnyiPBCNlh6MhErqzVmwnC5vhGo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQioN23\niIXWNfb0ne0mm221ELWJ2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNGADBDAh98+ojOSIFUvaciBfs5rYQWIxZPU8u89GuXMETN\nfQTbAiBHG1HwFYtIF5f4XWOBer/tHsaRO4s7yD7emZ3e9RwRhQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1867", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1867` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAR+0lVme2k+zvxCYwMYeyw+HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViYjNkMzgzLWZkNTctNGQ2MC05ZWM0LThmYmZjNmE1MDY1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRkYzU4ZmMtMjll\nYy00MTdmLWI4NGMtMmM0OWNiMzE4ZjBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjbCCvrsL4Wn/3Bm2bi2heX4PHf4OQsKZF7JO+35mLFAmDRj/ORmpnFGPwhRk\nEV7V0vNxyiA+IPMgwjBkljOtFqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh86ZijHwZkh8EYvLJwimFFPyn6kwHwYDVR0j\nBBgwFoAUsxf9GTgZOwp5GfYzxf5ROfyvcwkwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDj75RL2iwlfzfuHR3Jd12YlrY+WZxUR+jWxqe7YhhQCQIh\nALGrVsnSVgwUNGVy5ZLnZmTLU9uAxalz5NfZfMFgq18H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASIAXANDSCuAQKdPD6uN7IHPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmIzZDM4My1mZDU3LTRkNjAtOWVjNC04ZmJmYzZhNTA2NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd5zBImGnN056xBf8eivM8yri7g8WgFrgqvCSOAVtdzEpD\nHRYDRGop44RPK0FrI7TG2gms0S69A8oG/b5+sZNFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsxf9GTgZOwp5GfYzxf5ROfyv\ncwkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZcdPAu2VJCaAfkqbYBOnUgeGMaVxTuJSKwhc2ZMif1sCIQCO9+3ot5SI\nFR/GEcGge7cvFNqe/2k4dkkyTuM3h4JYHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVDaQH8j3ldx5IIjybf/kXjbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRkYzU4ZmMtMjllYy00MTdmLWI4NGMtMmM0OWNiMzE4ZjBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkOGZiNzU2\nYi1iYzEyLTQ2ZGQtYWE1Ny0zNjU5NDIyMWZmZjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAScx1hsff+Qy1CEG9zdfyq7hcSmb/y5t/dw+BjjjXepzyqXTV/XXKU2\n8wIoD6yq/eQBWrjgcUscEtFVMF7rcnTBo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSHzpmK\nMfBmSHwRi8snCKYUU/KfqTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAuyR029dV1vG+a+jefjgBNEuFBGXzy+9uslaor\nYT1pZQIhAOG/foMe0iMDTsdWrpCYCgqSA4YEHQVFZzWncd0Lby+1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1868", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1868` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQXJOUdRAs8RmKaQsXVVNHCAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMDM5MWI1LWVmN2UtNDUwYi04Nzg1LTc5NDRiMTZlM2M3ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBlMmE3MjMtYWI1\nOS00MWYzLWIyN2YtOTdkOTA4ZmExMDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUrUQNB4KAbfWzSuqaKvx0UblOUuQCAXqBR+wH6BNaPM17RVkv+mI6o8TctHh\nNwPYIhY8+4DjLoTrMzPcHsxyVqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvbYaHp9RDehbrhfrU8goNa9DshwwHwYDVR0j\nBBgwFoAU2kGpceKFYd/XlFFoM+Mjs08FHggwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIC2Fix++0s54QruHBI38x0m1zLhSNiDJ\nwcf98szjTU9yAiA/CH9f4oo9pNGQT/eAyYoIORFtp9sBz1QTdDA0gf8spg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWZ5s3v477GNEZVqtwaxdd2rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDAzOTFiNS1lZjdlLTQ1MGItODc4NS03OTQ0YjE2ZTNjNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkD3Ls2x51/wr+1YIRW3Yre7uqvv3oZqYUQWlEgU6QoDuR\niYfFhUBn/Oy5je3nvfu91tgcV+mnaLP7Iz6d+OgIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2kGpceKFYd/XlFFoM+Mjs08F\nHggwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANHiTkLbHd8sKi99nuFEgh1nWSym+IY879h+24NsP9QGAiBuNCETlUmt\nB2gjcY6N206P4MYvpoonJs7VVd7fc/aq8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdS/4Ol0dliiyk+QSvYi56a6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBlMmE3MjMtYWI1OS00MWYzLWIyN2YtOTdkOTA4ZmExMDk3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZTIzNGY3\nNi1mZGMwLTQ0NWQtODFlMS02NWZlYzA5ZGE4ODgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASMljfIDPB8pVKRTPhguCIfx66nBkrpN2U8pvCiJNMyfvHZsk67TUwZ\nNvzlTn9NHF//YfnT3rniF55wLHpeCLBTo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9thoe\nn1EN6FuuF+tTyCg1r0OyHDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAf9Loq1+lLL1ZiOds8MVWnO65QTreOlgbqvqsz\nb8/B5gIgcfVWevVdVn81+tM6JzIgfIuY9zKFIFYjO3nZL73kt9s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1869", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1869` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZxAaWl+6bVWHOol1VxHVxGAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxMWNlZGRkLTc5ZDItNDkyMi05MTE1LTAxYzlmNTljYjFmYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY2NTU0N2QtYjA4\nYi00YmY0LWExM2ItMGNjMGIyZmE2MjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEleBsobLnizo7HdcNCRZRANq0YbDx/+aREA0G9G/DoLk93iIwLpYqeJyfMnq/\n5ZodRayAPJPvaAvx3VwrSN6icqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGNEDU5HWZ98mz7nVefSbWUFBANkwHwYDVR0j\nBBgwFoAUysEo1ecS08ckC+ngHGgO5lhMc64wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIEK7JNU8D6lGGnkVlM/4DPx+xg91ne9f\nmNMAWMfseplTAiBnFGIvsyp3vqJJHJZEkDM8pisECFsQRr46MzToJB6crQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATaEclgIZH8874fe/a/5MmI9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTFjZWRkZC03OWQyLTQ5MjItOTExNS0wMWM5ZjU5Y2IxZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqK4YzKE8r076QcQW2dK/sGuLUvz/kdwvxTFh42jH2kRYF\nqShNEeeuHAozl/AviPZOjfPnBn6aP3PLLdf0V2VZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUysEo1ecS08ckC+ngHGgO5lhM\nc64wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIje3267Gz1ptTjwWQs8r26Ej90E6ev054QCdICCpYGDAiEA9nytB/n7\neOi+TL7Wv+tKmVQ76/3KpiCrfbfrF1QS+20=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAamKVKV4yw3Vih0jh07W6R6OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY2NTU0N2QtYjA4Yi00YmY0LWExM2ItMGNjMGIyZmE2MjRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZTdhODIz\nYy1iNmJjLTRmZDctOTcyMy00ZDkxZDU5MDZhNGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATQQAtwHC7S9uRFf8PNGapg2Ij/kw1dDW2PFVSMrEpedtaDKgVGXOa2\n5vSHNp/RM0RGqT1ab14BkFs2rrgz2IiGo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQY0QNT\nkdZn3ybPudV59JtZQUEA2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAhZjrWA6K0U8IYQOIPRo0crMUBFLveq0VvhEU\nUNbPTrsCIQDE85iO9f9XR1SPFjYzxG4nPQ0vyFfWVgK9UrvvAJcuSQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1870", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1870` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAeV6Y61Q7QK/KB8D0q3bpjAKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2NzRkZjg0LWE3M2EtNDIzZC05N2RkLTQ1MjM4ZmYxNmQ5MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTcwZmVkNDYtNzgz\nNC00NmRhLWJhMzEtMzljZWJhNDRhMTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEedLhA4Z1jaSYwpdI+Mo+1Tihv8aoBqYFqpYNq4kuAT0RDpL/ZEMDGA1YWPrg\nDR4VCSky7oCydt3hiOItKE3mT6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJmYqCt/ozQv6XbXgS0mulJGN8gEMB8GA1UdIwQY\nMBaAFMUzUXwnnG3D7NsC93ZHz4WMcEBFMAoGCCqGSM49BAMCA0cAMEQCIG8XKfSo\nZxpiN2vBI47uG9CxvFPT5NECFDR/MU5mNdVqAiB+CSaDrVQQEKa2iT7EVj4gMTKk\npCNbuSJaY6DGcMSjhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAffxtLs/iRhFgodOd7cZ2EtSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjc0ZGY4NC1hNzNhLTQyM2QtOTdkZC00NTIzOGZmMTZkOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQg2DMzl4oCR9HRhDiseLa77upw4wQIyFIG1rea2sOZW1jC\npiAp4zpfbPSWkeJ1PQdd6BrcEI1T8LMyFgCeRDP/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxTNRfCecbcPs2wL3dkfPhYxw\nQEUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPW7M9ed83YqKBbZmmqvDGtstCX0Kr0xm0Kll/SKWBd/AiEA9iWNz2Kh\nWVOmxGEwsaj+MU/ug4gGH50zzSyXT00je+A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAcBmd3fRMJ5BNFToKe1SjbPcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTcwZmVkNDYtNzgzNC00NmRhLWJhMzEtMzljZWJhNDRhMTRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYTE4MjZj\nMS1mOThmLTQ5MjAtYjM4YS03NjJjMmQxZGZkZjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATXmPJOQ2QunQPtdH52kb3I65AR+nN6dz3VLcPUZXPDoP7ZRZIMz7Zx\n3p/cGzx9F/mb0oLY/U1Vr9ll7uun80S2o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZmKgr\nf6M0L+l214EtJrpSRjfIBDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBARUKoWlXNtqHWvRytWRKfZ16yMwgD4FSALqSf\n838tbgIgWIwzZ1KNQ7uV0lhQ+D9hxJ23+vKuIw9vk1DOHSaVSAI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1871", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1871` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAT/zxeKhRRBMFRRa801kYgXZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMGFkZjMxLWEwOTEtNDQzMy1iNGMwLTRmOTY3MTZkNzRlODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTliZTM5MTAtODc0\nNy00M2UwLTkwYjItNmRjNThmNzU1NmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiMgneIacaHt0eBXhQjdu8uayVB7SbTxEnGfH/iDQgDbaSMsPd1S/vRwhZ6M4\nZRkQPUGXRQP0B5FwxlEmHHQUzaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPBGXQWqO+QVn8pc20ACTvwnwZb3MB8GA1UdIwQY\nMBaAFEWsfuqa5PlyDjDjogjZVu+lYsuZMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA/HTsKsAMPpr/DZPYY6EMV9Jrcs0aLCTh\ns1Ahei7MyLECIQDzKY3arrfW6dxnJbTgW48NHum8kBAFS73PZgAK5RSfDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQSSheREQqxr0pl+ZeTvB3gpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjBhZGYzMS1hMDkxLTQ0MzMtYjRjMC00Zjk2NzE2ZDc0ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARplz+QJnA4KhMO3Dfi8evDL2u/7nsMEkqY79kGko+Ub8al\ny69T1ybgFSPXWze1hUqFFMZzpXMjcvVlN3YizVCgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURax+6prk+XIOMOOiCNlW76Vi\ny5kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMn4SlvKWOVdwJm9+CqreEfGlFgTB2m27A1YcWjE0BdECIBqyQ/s99jFj\n0pDtgK28M5VdATNoRJCrTqa1VUIkz082\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAchqnb6LxnaAes5XuISJx7aNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTliZTM5MTAtODc0Ny00M2UwLTkwYjItNmRjNThmNzU1NmEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NjgyN2E3\nMS04ODhiLTRlY2UtOTQ4MC1hNzJjYjJmZThiZWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARhb99/r64jylNiKFpPN90T9NkBnaKtf+S7PtBgn7nGQghdEmfxCvRI\nkxBRQQbbMEyOCpBnycFdzS9cZVIqRM+Go3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTwRl0F\nqjvkFZ/KXNtAAk78J8GW9zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA3c1RKuDaq5y6s+eA3UGNiRO63pR9qXxasBYm\nk8NN2tECIQDqxrGcht69PlxgeGyonADn0HFDqmk/JYn3MRHWx5NqRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1872", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1872` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAao23kXalHCBGh+lDSnR07SUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExNTY3MWRlLWZhYzItNGZmZi1iOTNkLTFkNzdkYWUyZDYxYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRlYmUwYjEtMDQ4\nYS00YzhkLTk3OTUtMmE4NmQ5YWQ5YmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuQuUA6qR3iIQYrT58a0ZdOWrGTZvQ8DL29dARCD2WMvstD9Zb4xYvV+IGRMQ\nsbear0f46g08hYlaifb3rvOoY6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHTgfNgOos3Jbrj6KRU8CW5nEyhMMB8GA1UdIwQY\nMBaAFLrrVVCvTs+HDQyC+xpQZ5jVBqTeMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBGQbMdPszi3NWTInyRxSThyWAv24j8kovd\n1JtfJzDSqgIhALa+yXMj4ZJNvMPNVV14YNZSGCq/GarG2oVxP+00vQN/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASy2ELFStAlkx2kI6Cpj7IwNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTU2NzFkZS1mYWMyLTRmZmYtYjkzZC0xZDc3ZGFlMmQ2MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLgtP1iMN7LXqGGqCWsgIaTC4NcuBhx9mVAdhb75KYMeJQ\ni2wc24M63IqGdhMQuas1kHs+2+CDpnTOAgNQ+HzDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuutVUK9Oz4cNDIL7GlBnmNUG\npN4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKkOsCdTv+Q8dQ8EC2v44aT/qZGKNlVbhq34b7//oHM2AiEAxiGRR6w3\nMSBQqprzxu1QY1FePMK5SxxwpwWPb9LoMTw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYXJXzmMVP8UvXlDwNU1nno1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRlYmUwYjEtMDQ4YS00YzhkLTk3OTUtMmE4NmQ5YWQ5YmFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NDg2Yjg5\nMC0xNzk3LTRiNTgtYmE0Ni1iNTQ2NjZhYzEyM2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR6xJFGdHG48zHkQ90K62dJmtExM5wYfiZquyi57xW3UWYOGtTQVc0c\nGbj5EuVPQbKd4cBrQWjOIXNoyYIcwmNjo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR04HzY\nDqLNyW64+ikVPAluZxMoTDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBD79HRDCK0k/K7gbei5rN6E7nil1fQ0skXAEjO\n4WvxGgIhAMLwsG76Y9LvuVCp+lbAzAtkXo9GGqyMrycLxS7vSQz2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1873", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1873` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbLNJruRvoze8k/OXkpF2v1DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4ODg2ZDYyLWY1ZWUtNDJkZi1iOWVkLWZjZDIwMGFiNjI2ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVlZjEwNDYtZWZl\nZC00Y2MwLThjMDMtYmU1ZDQ0NTM3Yjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbJ2879OESo3ND/U7JQLUXLBpgZj58sxRQCIGGOp58DOcBTQDHI6zdmsR3Ksd\nLYAXuIkZPYswQYLwtkwpVQAdDqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRUH5xs+2PSbtGREuB1LHueVi4V/zAfBgNVHSME\nGDAWgBR968xLCZZJ6cxmE6h0ihx14bvslDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD8ggEEee+v/P+LPqNc2ylV+eQbbIWT\nFLTjJMUfVCcFjgIgdGRleSmF6xTYcRjEp3QtMPrFFI0ZI/1jPSM74bbLfgo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe2uOObJwgAT9M9q544F89AmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODg4NmQ2Mi1mNWVlLTQyZGYtYjllZC1mY2QyMDBhYjYyNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZf4JBghJV4Vy+zRlgemmzz52h7oLtwwnRIRdux9CE0lWw\nNKksUTCFh71MneaTHvg2EPH/X/YtyzMAPKHHZqXbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfevMSwmWSenMZhOodIocdeG7\n7JQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRUYnzTG6+l2KkR4wRTC+Q7RdUCS9xzB8/HJBR/YabUECIQChFwnoW6xe\nztfJ0SiCJHsl/jmfqY9xuun3HhbT93rmsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAW4Zx8JyPISLmxuHTlnd2eQ6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVlZjEwNDYtZWZlZC00Y2MwLThjMDMtYmU1ZDQ0NTM3Yjg0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MzVmYzk5\nZC1lNWRhLTQ0ODEtOTNlZC04ZjI0YTRmZWY3NmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQpK2ujWZjZUhcJCDBGMHuXI6p0Arj4Toblxw930IxZeyeyfUKJ4cNL\n4ieGyhfUBXyjZ4WfCBFtPzvvYnfH+GF1o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUH5xs\n+2PSbtGREuB1LHueVi4V/zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA2wrsr5Q5gw3NckVdN2JEGdbXGpSFWBk/XeqZ\n9xOQ4o0CIQDeP0SiPY5RAouYv32ygNg1h9tQosRJNY/fe6eBuRVbdQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1874", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1874` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAamXY9hqDmAzZ0xp5NJ0tQoVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlOGY1YjY0LTkyNjItNGM5MC1hNGViLTc2OGM1ZjgyOWRjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQyMzQ1MGMtNzFm\nYy00ZTc0LWIyMGUtMjM1MzY0MWQ3YWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3C3apQnNt43wF8O09H5rCWVCcCd36NtUcXHBLGvK2hqgGWW7QQeTg7Mu/8S+\nDf3ID3VHMrp+6nQ23oKm4xgh1KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbyhvu3l92/segdQtd9s0UF9fuw4wHwYDVR0j\nBBgwFoAU7BpDIQqVCAKQAXQst0bc+3rdL6swJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBQVuLEtRWs4WKX\nVDRmcFrTBxCS4zHMA8vvxUtqSjJODAIhANL9iCUHJ5CkJw/0pVhpLXadszzrmU1u\nVc3qpyiEANFD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZWvaebIlhv0nUd43gl9Ofm0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZThmNWI2NC05MjYyLTRjOTAtYTRlYi03NjhjNWY4MjlkYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCRBX5Rjy9y7pfBv6z8QfDbvQsL82kCGwTk9tlGZfNJ1TA\nU6ZnwcxFkTxuj2aBVKEQm/RP+RqxDczTB3r3HjAYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7BpDIQqVCAKQAXQst0bc+3rd\nL6swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANsilV074Wpb6oeIlfGwVXxSXBfkpcuUXqHnwTUAy16IAiBOSLZQYdKV\nFarEpBDJYiNx4jEzkqEGTcKi1m4We8fbDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARHCs8xtSreNyOqTPrNgrxllMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQyMzQ1MGMtNzFmYy00ZTc0LWIyMGUtMjM1MzY0MWQ3YWRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYjMzZWIw\nZS1jZThiLTQyYWMtYTUxZi04NjE1OTZiYzUyOGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASrpEsshPVEbNh079fKWkHlUifPC0wLV7Nlo+7Py/SGAB/DNXPAxf4T\nExyoDFB+kvMyjMV1MtZ8i/U+0yDRoUZGo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvKG+7\neX3b+x6B1C132zRQX1+7DjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAgB1JVMNJ/GalQ00VKMf9jG8+zbkQqke8K2ib\n5nq9TpECIBvbPDDRsBaqThhcwgdXZ2X63LzvVLa0tDXNXkxLTs9x\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1875", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1875` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAVLp4tLquus6xMsqdL1A+I0KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhOTJmZTY5LTY1NTAtNGQ2OC1hN2RlLTJlNDFiOTQ2OTAxZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JmMmFjZmEtMTY3\nNS00NTdjLTkwZmUtNGZiYThhYWJiMDI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjugjaAdKYRmzg2BOfYx+DksV089xRNKLQIaqcCN++JgXm0bFusr4FZm+9Oxm\n0QU/HyDzPvjQgOTsxYA6WaWzY6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDP2wGyEVp3GiuFy4oHoLdX4s6DUwHwYDVR0j\nBBgwFoAUpd0dhUrVhcMIluj98StVPvsMEdUwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAigLO9Wx0hviF\nO6sCSdluyPieIHCSnRmBXTFGOCwUnS4CIQCsPeqA3BibwrUvCpJNCMON7Q+++uCt\nwkzTyYfunA0Bgw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASRn1ImoFJpPlel+FUvWimTfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTkyZmU2OS02NTUwLTRkNjgtYTdkZS0yZTQxYjk0NjkwMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPplmlmsAWLKwXCPwHVaN0Usf3WF1gXvZVANbdOZBK1I/S\nkDSdzPN8364fUYOHWmNx8YNty9HbV8TAwZfSNao7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpd0dhUrVhcMIluj98StVPvsM\nEdUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN0LY06FGXU1imrEozfLkHW0ufiWG/EZ/M8F2Tj5cblcAiEAmk2yOpnB\npsEwIkstHV5m3Zu2bUVPWJyW3EgFKH5ftg8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfgZC5rMYRfGlSfeNkRXwRFlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JmMmFjZmEtMTY3NS00NTdjLTkwZmUtNGZiYThhYWJiMDI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNWZhMmNm\nMS0xMzUyLTQ0MjQtYjlhZi0wNWMwN2E1NDZhM2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQMHUyXfDHLoAnXRzHyk/oo1IKnFafP06nsKzRMnJLv0mcB2ylgrg53\nC6imqLXDYGP2kcM2TIa31wXUX5nFu6HWo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQM/bAb\nIRWncaK4XLigegt1fizoNTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA9EqmTrTDT6c8jGjocXm1zzN/W7V2GCW7Te+D\nW9b6uzoCIBVVH/jlUqM/S4QgUZlpUGSz3eEXP2BUh5xISAIExbzn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1876", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1876` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISASTRAn0OJwyddCG8mhh3Q2onMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5YjM4MGQ2LWNhNGYtNDk3ZC1hZjhjLWQxNDAzNGU2MWViNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmYyNmEzOTctYjZk\nZS00OWI1LWIwNDctNjZkNzY5ZDgyYTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4d+DZXl8OTLDNKNpZIW6nESJhEVwFi2l58D6z6hS6l7a3MvkYGouyQaif3X4\nvdjKLtfSDz5iLgGwYyzlaFcNPqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjudIu4ib9BubcGpPQd6/z58rXtswHwYDVR0j\nBBgwFoAU2vrMSTgiwwfx5iRFoJFVUuEUUkIwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiACEE1ggVf8cp4VmpEeIThp\n/0gFwMhQ9A76zGSxZq+utQIhALikCYUOGZIL25GM9H416OEYuScf8V1jCrY4ID7b\nhxAz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdX4Ge/g+OLhu/3EKsegESEbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWIzODBkNi1jYTRmLTQ5N2QtYWY4Yy1kMTQwMzRlNjFlYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQa/k+klmwUhXXnQ+8HWURxOQ2ZHdilhCDA4l5Fq6/9HMDp\nM+EeQsMOUIoHCeLln286N0Yhc6oBW4R5BHkfXCQ5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2vrMSTgiwwfx5iRFoJFVUuEU\nUkIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO/Tp4N0t52eKlYbntA49Eoo3r6a/HjoxKrief4106jGAiBAen5flvZG\ngtawla0nGiaUDrewu+ts6uFD3HT9s3tWjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVJeY6VuXOHr66JX6fJ1YnxvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmYyNmEzOTctYjZkZS00OWI1LWIwNDctNjZkNzY5ZDgyYTBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmOGQwYzUw\nZi0xMWFiLTQ2YzMtOGE5Ni0yZWVjZTBmNzBiODcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASddWithF/07bzC6XSGeFo44YDvHXdK9Y/Y5wDYa1cT4xRTpvPjZrbd\n/wkKNM2PReO3+cEazIPdR2O69O8ByFh2o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSO50i7\niJv0G5twak9B3r/Pnyte2zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiATi7zabKw3O/DZqC6RwWClJOQkZtQHBrr8P08O\nTfywtAIhAJLgGoUMVrjj/9q6C3dQ0z8+MwEKYzpRgHVzFf5M04Qc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1877", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1877` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAZZ4o3FgwTPKxxN4OCQJKzwPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwODg3Njc5LTNiNDMtNDcwZi04YjFkLWM3YmE5MTkxNzQ4NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJkODdhM2UtMjE3\nOC00NmI4LTgwNzEtNTgwMmNiYTE0MDg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKcjzz5Unk3zQRnjPgpcIT6feyHksz4tcmzef4mx/JwOwwjF5trjMvvC+deXi\nBepJJ4i9scMMx1GakQGvUQ846qOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuLuYCo5SCrbBKDvWZfUsETr8KmgwHwYDVR0j\nBBgwFoAU+HPvYMARF/RL8xLCzkzspKwzmNwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEArsws\nJGZ4fu715S3nrzzKcF04bb77aHvZadl0fKbhdUkCIQCYmbLJVRli3nzTESiEL/oW\nvxdm+aAQdbuDG81OZOQkQg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeLIBSBqJMWE1A6wwKYhP//4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDg4NzY3OS0zYjQzLTQ3MGYtOGIxZC1jN2JhOTE5MTc0ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToGZQcxSmUFolxdB3Uhx3X7w7qe4raJ49VeRgRv6coXVWz\nvfShmDuq4J0DtAJxC9sQsj47xfrFhyekAWi16Lu9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+HPvYMARF/RL8xLCzkzspKwz\nmNwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANu25Y1P+T0Pxbg1RyBKTPyjpn56yU+S4wahZwGVfFoZAiEAtBplaoFA\nYA4R3mn40OAV0CFtVLRKADP+E6b4H3b6qME=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAZzBp2W70Fv/qhcMWcYidvAlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJkODdhM2UtMjE3OC00NmI4LTgwNzEtNTgwMmNiYTE0MDg4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMWE3NWY4\nNy01YWQ5LTRlMjUtOGZjYS02ZmNmZTRkNzQwNzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR/ij+rrpfxN7k33Tm+/L0+ih1IM1+N+Ql1/U00jwB6YaRpSedVbpWJ\na8uIKKPKsMVJTDYWhmPo2FzE2q/yNI76o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS4u5gK\njlIKtsEoO9Zl9SwROvwqaDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA8NhpukQ+39InjHHvwsHzVXQzVxon8lWzfVM0\nR1O92k8CIQCsk8uMrBkyZ/gHr6GeH2BY4YOc1SNlk3y+hQf8b2j8dw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1878", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1878` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAdD7IuwUijqLAVx4hiFZEJLmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3MzhlM2VhLTZjNzQtNDY4Yi04MjRiLTA4Yjc3NWI3MjFkZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRjNDlkOGMtMWM3\nMi00ZTUzLTk1ZDQtODMxNTRkYjRkMGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErBqUPf81gLl23SkTlFbwwXzxG266QgD2SLwKWJmIuGOUDmP39OjWGNJrubo4\nUwP3d/vouzLSdpdSDr1xer7OfaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp7qXxp5tbSuir+EXJYnG3v6LH9wwHwYDVR0j\nBBgwFoAUcXNW7Xqw02Mny3V+baLI2khmZB0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBDViH/\nhgW1rEALq1S1l+mNn8u5n/RhfMVvND9Jji3GVgIgUbJoE7WAkNK+fR4lI3lKFbyZ\nfJu7SNXgze4IMbJRrLA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASaefGKIQQppvxBwS3++B99QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzM4ZTNlYS02Yzc0LTQ2OGItODI0Yi0wOGI3NzViNzIxZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROsXrSGJayvtsXd3nDx4+e95ZNhla7Jzo4wQApUhDU7wMX\nLptXgePXqKOvPfh2G124pZ2kVCYNtGZ3ec0dYPoIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcXNW7Xqw02Mny3V+baLI2khm\nZB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKEHyWZw1JoOjYvjnajSzeCrItM0GhhYGc1xbRii0CyxAiAzhRaPbJ/V\na5OC2T2vFCcqClaHwj8X2BFDVh9GxyOR7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAffoADAVMyNWtYjII/QvaafcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRjNDlkOGMtMWM3Mi00ZTUzLTk1ZDQtODMxNTRkYjRkMGRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2Njc2MGI1\nNi1kNmEzLTQ4YjctODdmZC03NDMxNTU5ZWNmZDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARbCCeYhnAc1ThVpJ26ObMWNPeGFVCj24GLbuGsLX6ULiLoglYVFgkP\nK50505uil5qbTrWezqFfHURfd9I3DUU4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnupfG\nnm1tK6Kv4Rclicbe/osf3DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA6a6cKtP6b/qF6cWZJ4ZP9NmVNV1JU0YSoL+f\nLmM3DK8CIDpdCa+AbyRxdcIu/bFapCwq4t2tvW/mi4STSzTixxpt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1879", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1879` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZg7SZLzlyRZCE5hTVp4kB94MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjMWI4ZDUxLTMwMTktNDU3YS05ZTZiLWU5MzI2NTM1OWUxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhiZjYwNmYtOTBj\nYy00MWE0LTlhZGQtNzY3ZWU1MjI5YTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd4V/y9ec67gQJlgX1gXe1XZ+WznYkgiU7rRdqf0qEjJygjee98mgn5E3ujKF\nZq29euTIPfJMMX8cysd8Xtht3qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN3+TZSnmk/B/rirwemUQYCulRJSMB8GA1UdIwQY\nMBaAFCD8WGEjyQj0pjIc8QmPS/+juKjkMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBsDab8wrOhsm0zC71qomnt0UzsxL96dsiI\nr/5nmPQzUQIhAOfGYSpKsc93sWYEkJTPT+dcTstM/3x8PkyWIxi5JsHF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbdgDBVOQCCIP/jCfY218JSAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzFiOGQ1MS0zMDE5LTQ1N2EtOWU2Yi1lOTMyNjUzNTllMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGr31CRxgp248Peq+pQtHc0paxznidW/gUVQtY5+L1DPjn\nXSN7/jHzO3NRi+qL75fme2mvIyYfWfCaLnuwwmTSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIPxYYSPJCPSmMhzxCY9L/6O4\nqOQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIeLTRm1qYtD2BcpvQC8/MYuIgRriAGOI3lgcgr9JPvfAiBTg9SFP7Ee\n0VPgKg8k5z2jcaxzaLov3LkZ2ABaZ59UwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAedlw0v8NM5mDDpF+ZOl6YK/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhiZjYwNmYtOTBjYy00MWE0LTlhZGQtNzY3ZWU1MjI5YTM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZjJlYjkx\nYi0xYzg0LTRmYmItYWIzZS0zMWFjYjRiMzhkNzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATwsIYuw1XgeYytLq6t7HflhEdWsbAsQVGo47g6D3XDjF7zfEdE3IfH\n8/HBM4du90I6Vp8/vDTAOFY/op/i5qMMo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTd/k2U\np5pPwf64q8HplEGArpUSUjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBYLg0y3jHNN9PbRnvT3EgQLCSuZle01CrX02tJ\nu40LxAIgFU6Vo6O969HKi2ej5pJ0S/pkxRVpf822W5nwaAD0yeQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1880", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1880` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAfHPL6NQmGcu7vG1xz8K+3D9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5ODg5NGFhLWRkODEtNDdkMC1iMWMzLWE1NDI3MDczNDA1NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUwODRmMWItZDYx\nZC00OWRiLThiZDYtNDUyYjVkNDU5ZmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8nKV5uNNarMcCpManewudRuB7P8ugNv9ijOHSg+9buR9nX+ikD3pQNUJCip3\nTWHxEOu37PSXsZ2iPzjsKcEGG6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrfY8gA3WLOxNN/zXEFp+3B2TzUwwHwYDVR0j\nBBgwFoAUGVurOXBBqF96/WwPhB01DFQ/1jUwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgV2VpS5SRPOQB\nMNU5VroZ854m0SNQL6cFUtkijywcTSoCIEVeUZ9sIfqd/Wcj3V2NsR80T0ZgyedM\n3V0jsWUuR+n9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdTU2o0v1wQOW8OcVackrZz/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTg4OTRhYS1kZDgxLTQ3ZDAtYjFjMy1hNTQyNzA3MzQwNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKCJo+jPLs6GKnoMM0Hq1+sZ9u1CCRSkCBqcPBRl7jV4bR\nrPVlDDbFodBo0L8d8CRLTJnixfQtfu0LcmqLP8g6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGVurOXBBqF96/WwPhB01DFQ/\n1jUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALu9uvl81Z4SetHYBSxKNtma9CIhu3eQXHzpfMYEPp9lAiEAyv7dlrcs\niaMUiGMS2hKzKuGHL1KcarzMVnSOYDCyFQ8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQSiPY4U4XJ8i8a8YI0nMC1fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUwODRmMWItZDYxZC00OWRiLThiZDYtNDUyYjVkNDU5ZmEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ODRhODNh\nMS0yYzY0LTQ3OGMtOTM0ZC0wOTIzNzAxZmQ4NGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATBB1AOrdSlHwRoaF4SDNOD4j/FvGL0jaYOd45f/ROVhOAbQc5zjjya\nvhk/6rRYXNBNwWy/uziSti1xesbh22lIo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSt9jyA\nDdYs7E03/NcQWn7cHZPNTDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAzh4zoU2jIVmIuT+caw224dsQb+3Hxjn+QA51\nvaZzBGACIC5gXMXpu3gDB2+5iH9l+UljLKQSCoorMGZe8IkVrBJJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1881", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1881` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAc9zRm+naE4ppdMgk7tUVKwXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhY2IzN2FmLThiMDEtNDdiYS04YzI4LTM2ZTNmNmQwMDM4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdhOTFkYzctNzA1\nMC00MmFhLWEyNTQtOTJlNTZiYmY3ZmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Dly+YptfN1BpnyVZnnqN1ym1pjUzC57Durr6Pr/JZbw02UP9xRCyYwOq0yc\nZXbaJuxxEoPz+OepmiHUuTQVNqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXJBvFGZXB1dWlUyQoL7Vif8e7zkwHwYDVR0j\nBBgwFoAUlW9L3RptuleKJe/k880TOtivbrQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAI9tfyY7XO4A\n9SYY4Rh9W4HlReLO0Qp2EZEmMwm8U95CAiEA6ECnv5rEO87ms89h6gX3a2R7ZZIH\nJoNEwDD4yuGM4u0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARv5qDa+kr1J/QJKLjTVy3vHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWNiMzdhZi04YjAxLTQ3YmEtOGMyOC0zNmUzZjZkMDAzODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkcg6MZobTInjlp4s+FY7KFByWqPs3Wpm7LSVpSQgJTtuN\nldxVEQjLXUun00zSK/cjO0e16Y1pxcOno4RxcBxvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlW9L3RptuleKJe/k880TOtiv\nbrQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL/qFrtiZqvVwGlr/GBJjA7Q6OldeZAOhcLtn0nqVIWIAiBzLazCckyh\n7Hp1JDwWu+iEAfQs+m4Ar42ZWFxXETeL6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISATX30ZL7Usb22DmZJn3VGyS8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdhOTFkYzctNzA1MC00MmFhLWEyNTQtOTJlNTZiYmY3ZmMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYjAxYzc2\nNy01ZDUxLTRkN2ItYjVlNS04MjdiMTI4YmJmNmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQmNqfMSOHGdQfvKljKa/BJP0BO1qv37cFa1aYW88VwjCkM+iJGly2R\neJiNv0ywIy9xnCZok3IVcZZaWozogKHNo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRckG8U\nZlcHV1aVTJCgvtWJ/x7vOTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAzU+RotO2wjYGgcjWVsP9QWoJnFeFyf5HS1lB\nNBnGcmMCIQCO0auIaOfWC2J3LfUz9fTqXn+EemYtu3yJ67Ny1/MNnw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1882", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1882` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASL/7aS+6SRa330WhnKsWl+BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmYzFiZTdiLTNkZGYtNDczOC1hNmJjLTY3Y2RhNzIxZWVmNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FmZWMxYTYtNTI0\nMi00Y2ZiLTg4MDItZTNjMjkyZDAwZjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN5Oszd0ysBMDwu47me03JU09JHxHuh1vvRPPqi5erZ+wTT+RRMhvTWKMYEhH\nipgA3o3GJjo+MgMuq+56okvN/aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmFYJVXvBqa3/JCIBvSyYGFy4VRswHwYDVR0j\nBBgwFoAUn8cNzpUSVkt8P1rpBCUrXqsmeU8wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICQBbTbD+2ss\nXWpGrmux+AjSM1QYNeHb9V/u2wpVWOMQAiEAxIsKsSjg84bpe2eqi8oX3QtaYO8s\nzIyd42YaVIPS3BQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARfBos/iJDnCx79ab1OyPcqLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZmMxYmU3Yi0zZGRmLTQ3MzgtYTZiYy02N2NkYTcyMWVlZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXk7ZeLtB3ktfRUZkDPEpo16RwYvxIC4ATZqi90Ult4Zqy\nkQeGT6lr4YV6rl0kjEhrvUxZy0EjMQLz8dLcuzoao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn8cNzpUSVkt8P1rpBCUrXqsm\neU8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbJziANtGIlWZCRIrt9bOQAe17niJ7kDjRtQDGswBpUACIQDeAdIg+8QY\nc3EiST5vPsy6oHF9C8503damDKNWYPfddA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAXpYfE4LkV30JDNeWthmiLTeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FmZWMxYTYtNTI0Mi00Y2ZiLTg4MDItZTNjMjkyZDAwZjcwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMTNkODg1\nYi04YzdiLTQxODYtYTg0My04YWU0NWUzMGM2NWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATk0wKfZRBQP6UmwZVVtUptJQ8HGpldINOMGeI6XRSPJFaWbI/Pj2H7\noXe+aVMcb21j2F6aulC+cXRjo9nNCnjlo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSYVglV\ne8Gprf8kIgG9LJgYXLhVGzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBZP1NabFtd1wVveeMfJA3s5/1y7gGL49YXtsXv\nBh638AIgbBK2Jq70qoBcXKiQZIdaME4yWiqruZF1Z+RDy6PS/8E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1883", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1883` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASxwsFufT1FoWGrGdPDiBuStMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5YmI3NWViLTFmMDEtNGJmNC1iMGU0LWNkNzEzYmFhMzkyZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNhNjM1YTEtN2Jl\nZS00NDNmLTkxYTEtZDJhMWJiMGFjYzYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvkVrp6QlhU7SFsjnXSgluI5rfL4f9Efxoer8Mg7JqyXAp9oz7Hk2NIhOIdHD\nDHGR/9xyLIGp5hAZ8pkw4RRacKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXfiLAun5LLNrg94WMCE+wj4n3YcwHwYDVR0j\nBBgwFoAU1/GoxNiyIwwlEVVZsh8/qNV4SwQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCKyu34HDcn5dzZwqRlwEm+BIpD1aw0kBWvqrQDW/tiqAIgCUPxQQ2q9hvn\nRZzI/yhkZNLa9HJ9iSUC7C2wNKV67hU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcQabz8JlRuERMK7a4aX81P6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWJiNzVlYi0xZjAxLTRiZjQtYjBlNC1jZDcxM2JhYTM5MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDbj0il2pemxSUicyhxNT7XoSZJ/ZCt3u3YsROHWFK7Rev\nCI/Fo/ROmsYgczR3W0ZfThJ+q63dhQEyuxuyuz8Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1/GoxNiyIwwlEVVZsh8/qNV4\nSwQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJOKSmecg2owZOpbbJ6TQ/RwgpV+VlXcW9tyPcDTs340CIQDmPmA53dc4\noKHSkviNeS4gYSAE/8gVB39LbG7ysukEvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQ818s5VLs6efSNTWXjdTJQcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNhNjM1YTEtN2JlZS00NDNmLTkxYTEtZDJhMWJiMGFjYzYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZTllMDUw\nMC01OWY5LTQ1ZjAtODI4Ni0wYTMwN2Y3Mjc3NDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQUZCpEpKO+kG7PK4a0UQsu91fxAJ3kxoxH5pJVadx+mDUwu1YGO1Qo\n5qhOMCkAcMYTuwokEj3n5Iixa0VSf1+7o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRd+IsC\n6fkss2uD3hYwIT7CPifdhzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAgf5tbZLiNVszZsCQFcPAJofNRcc4wPgWArI8\nB+ljphECIFLGg/oUWwXL8Ief6HLybgdmv9weyXe8yKizR3DQrM5Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1884", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1884` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZ2leNB+mYVz2Di6NPaJXuybMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhMjhlMTZiLWM5MDItNGZkOS1iZTZlLWE3NzM2MDk1NTFkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTIzYTE5NTAtODNi\nZi00NGEzLWE3MGEtYmE5ZTU4OTFkZTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq825zZcCmBI68rDquG0HDMXNKionyDrzgZOfaZ9hrLdgIMOgt7eEcTjmgQct\n8DO5faYQb+vukxBIKt4xuVHngqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuDzFzf6mM9R762zvco9hfd5EpmMwHwYDVR0j\nBBgwFoAU4bzW3hZCqjpBt5ag2X5YAklYtu4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCO4bOARPF1+1ZyvZq5xBDEShFE/C09zeMwzbNxopVwVAIgOmzB5RyN62I3\nfmf1khKJ4YDrW7Zda3jlhsayMizPMww=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY33fMLRJsbzVZuPD42hRIEfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTI4ZTE2Yi1jOTAyLTRmZDktYmU2ZS1hNzczNjA5NTUxZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkChFb9kSmO5Lc8OugBIik1yrQJ5t7PwHKovj53E9lXpDt\ninhvny3MQHuIRiRG74Em4MCjF/HUbQsB1chfXAEvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4bzW3hZCqjpBt5ag2X5YAklY\ntu4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI6DdBcLOPrVFygKwhfTzskVcwV9AR9XZgk9zSLBt6mcCIH8Wa9/pW2C4\nZWfGDayCeNqh1WDoEkPRXtgupw7Rp9By\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQBUTN30BacctdAAT5NEIQZXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTIzYTE5NTAtODNiZi00NGEzLWE3MGEtYmE5ZTU4OTFkZTQyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMDk5Nzlk\nNi0wNGJiLTRkZjAtYTFlZi01MDA2MjNjNTc4NTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQnzMk63H6KK+rfpV9AXVcg10Gso//IbCfLkZQcdVcWZl200k0m2CEP\nRchMY6B3392WiistijHMqHx17SJpEp8bo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS4PMXN\n/qYz1HvrbO9yj2F93kSmYzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiASRRU5shCPqZWju8s0mdpAibp7kp6Qn4HqWuOm\ntYbWfAIhANCbiCToV4kksJYb4IolBwKZyUPc1u71hh6n2zER22HP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1885", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1885` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAel7HKWDCa5pukgYWrUGiD+qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhYzE0MzgyLWE4NzYtNDQyYy05YzNlLTUxMDg5OTI4MjE2MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY1NzQxNzYtMTkw\nMC00YzlhLWFmOTQtMThkZjEyZmYxMDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUVKGqLtV6J4uNk5uqi1DEC+SoZDKW3oH+JMMV0UezcTTFbprN0Tssuu1q9fV\nWvSwYHLoMvS+bSVHea/JjTKsGaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJwZPifzVpmt8j+GziL6NLkccz9AwHwYDVR0j\nBBgwFoAUo1jFqG6BH1DXGhdmvow0zKswuBkwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDOM\nRAHPCxZYoMJZajcUiq5mpGB31B8uZD9yhYme4ib/AiBft2jNWX93UOBKk8T8cs6W\nxhjH0xJgOFO+GNM1ZRNc3Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa6xMlQFC30+JTe7fshGEYpnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWMxNDM4Mi1hODc2LTQ0MmMtOWMzZS01MTA4OTkyODIxNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbJBtVl3N0G4SY6jSDZN7ONk+1QeMwoQuPzVBphNy9a/Ru\nOPvEQyt0FINgj94iNLhgGdSBanadAvVSUnnZb9nDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo1jFqG6BH1DXGhdmvow0zKsw\nuBkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPP95kjcvVXK9QaF4jTZFE3n3MpCfL/osh8wnbY3rRfAAiBgmEGpb7i4\nB84aalLbh43zDwQ12d8cgJ1YV+rq3lwq5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAV7yQkJiv55vbQFmoaxJBAb0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY1NzQxNzYtMTkwMC00YzlhLWFmOTQtMThkZjEyZmYxMDkyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNGJkZmUy\nMi0xMGIzLTQyZDYtYjc1NC1jOTVlNGEzMDkxYmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARsDuK93Hi5remIG+3ISFh/oNeq6bDv4SBUooZqHy4COpDSNTB8a1/4\nGA9NEX09txxLTMZvo7JbnKZ8ZxymExUwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQnBk+J\n/NWma3yP4bOIvo0uRxzP0DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAh5uVF28EGePkgXRkAyDGv1Bw3I3uYmlDX7Th\nMaPgpRMCIQDgWql1jTBcfkzDNSyjwAhNx4z2eskJ6fax+xVxRrRJZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1886", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1886` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAaZZQEONupn35gI4fzqNdYqfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1OWE4OTUyLTc1NDAtNGY1ZS1hNjI0LTc4ZDdlOGZlMjZkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ5ZWMzZTAtMWM4\nNy00NjNlLWEyNzgtMzVhZWY4NDIxZTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElVfsz/BHoWjUOFP4IS6Gaezhlo2RhkP4TpPcgBBLM/gsA8ZBUhNSgFbUFx+Q\nFCN6RXM5QLuV/r39puqAvzGlbKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOuRJ7q3ECs30mBhk9WIRPC+8AigwHwYDVR0j\nBBgwFoAUMa5vMaSJ7+Il1RMSvWuohIUXoekwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIE7MSUpSc9usdhfxmtmIWXxfYT8r5Wye90SoMyFqbozjAiArE/mq\nrSw9t2b4P2On4IR81eLtRXLw8yvalmsZpowsaw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWUa9TEFYP/QqhdA4qRpbQ6ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTlhODk1Mi03NTQwLTRmNWUtYTYyNC03OGQ3ZThmZTI2ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcStLcfq8qwFRHZ4S59268dTZDNR5lOcOO3zaLvFPOxAP1\nlx4pk4E1GAEvxGzxag3M/ABaxqjpPwnJrgm8W7QAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMa5vMaSJ7+Il1RMSvWuohIUX\noekwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMw1g3GBEGN67fy3J0WquQxXyn7APTqZ2hD5pSgt9mD+AiEAvcbwI/bp\nVTno995F57fUpwJbMBQkJnTNRrotwL0ezLo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZwIp9QJcR10Z05ZYaVmSt7DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ5ZWMzZTAtMWM4Ny00NjNlLWEyNzgtMzVhZWY4NDIxZTU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMjgwZjZh\nMC0xYmI4LTRhZDMtYTZlMS0wZjc0MmZkMTZjNGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASKHZ+S/JozPOakWBoWB5KEoLRvo2hhmzuFkl+C2cUi4yRZGv1647VO\n/I8yiTMj/WgOUm5V0hncRMEjneA8Yavso3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ65Enu\nrcQKzfSYGGT1YhE8L7wCKDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBWeOAt9digQPolgzdacn8uW9/A9gqmR3i5aK4K\nvxtM2wIgBeCJsSgHt0JEsHcSARw9cG8K4s0BV4WCNZSINQ+oq8I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1887", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1887` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAb5DkW7eIekL7jc8czaRCc0KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmNjA2M2Q4LTlmODItNGQxYS04NjY0LTkxZjYxOTNkZTBkNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmZjYjQwZWMtNDdi\nZS00NzBmLTljNGYtMmFlOWEwOWY4MTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgscmTUqYE91V0kcvcyinEGSXGrImUdOvU5LYxOQl/W8G4Vxr6K9dpqSDgugc\nKyF+x3RX8+fZFwRI4Vz0Yw4g8qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGv/IoqJlu6B6arpgMmHZkMhqpYowHwYDVR0j\nBBgwFoAULssakJHf+vJblWQCkirV74MgtBAwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCID8Fswf1gN58rQ1bI1yBnZxZKlmHmn+AjOqp//NzYaN5AiAhbeTk\nBQANYuDP1fTHDC0/S0q3ffA28kwRQs+KbgBx+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASQbx8eNmyyccXqCc2ydyzJVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjYwNjNkOC05ZjgyLTRkMWEtODY2NC05MWY2MTkzZGUwZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARusoAc5+h1Dr6BW/aIsnIXNcpFtJoCfuMt4TZli2paVUtQ\n0gSMpYkW8aN5RdR7jbxOIj5fn84ILNNgAzYxfBMOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULssakJHf+vJblWQCkirV74Mg\ntBAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWqH1YWCZ5tBhWiojxWii92Yt/tL46CUNGUfbB8oHLQwCIQDGbnKSItMW\nx9BCz5JQmTHxprogTQtS4kXpk4dfDud5MA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAd4ULygKrcmAN2D2ZGVH/K0xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmZjYjQwZWMtNDdiZS00NzBmLTljNGYtMmFlOWEwOWY4MTc2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhODNjZDEz\nYy1jYzAxLTRjMGEtYTdlMy1kNTM4MTc0YzQxMjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATVtbReY8qaNbACKMey0OZ9SCPXmWLvCuaDIKTgX5t+O1iu4pwiY3aX\nj7UjrL1QQXAPpPqlJwiDT3J6vKMb166+o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQa/8ii\nomW7oHpqumAyYdmQyGqlijAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBJv8+EPeSG46HkKF+DUE2/+OegD7eQHdI0q+ez\nNc/yfgIgN4Ke1QTIEsL3dx5DtqXkVBpfKV4CpZTRzkA2joFbcvw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1888", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1888` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISATDOOry4/CpqT3JkqYADmIKsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzYTZiNDQwLTU2Y2MtNDg4Mi1iZGZiLTgwM2JmOGQ0NTZkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZiNmI5MjUtODVk\nMC00MTQ5LThiOTgtNWQwNGQyNTQzMDlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENumw7j/E8mIF+Bw0tnk05cv+6T8IKIPeRO/G0FY6ScKhEFXJQIpQu7HlZydC\nC1SjgpBriZxvEWJn5SgwZYwJy6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMzakl8bgZG6D8m1yEYFMxMkHZV0MB8GA1UdIwQY\nMBaAFAo8+aDfbK1pMgaF3s05xFC/glsiMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAtrOySR0pieACoMPMVY+2akE/FVMHupui\nZWwFizrTnwcCIQCNd+WCdZOidm525yab8NDJQaenvzxD/ZhREXH0taBbOw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf8dFYwTeGZ93tLul/TEA3JXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2E2YjQ0MC01NmNjLTQ4ODItYmRmYi04MDNiZjhkNDU2ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATx7dtjFwM37l2UXevkPLA9OAi3llDz1hmRXP8UDlNUm+TK\nQV19wdioyIjww2zfb6fDiRSBpiVsRbCUi9W7sxsqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCjz5oN9srWkyBoXezTnEUL+C\nWyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM+1moDpmwgpoFWYsQpgSoZcxWo/s6G9O+m2UsRntkXzAiAvaYRhFN+A\noqeifcyuZIoZSbH0AJhswlUusJzt93OwZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAcnoiMbChk6j4V1nFHyxejQ0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZiNmI5MjUtODVkMC00MTQ5LThiOTgtNWQwNGQyNTQzMDlhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZDAxMjNi\nMi1kNDg2LTQzM2QtYjNlZi1kNDZjYzE0NTBlZTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQBf/EyRBRHVL5OP5DmHGLpJ+2Nk8GcuPJBSMPjY/RuTsn10EnBJAuQ\nT4pZgyQEUl2QeoLIwV3sVIgs+BQLMOCpo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTM2pJf\nG4GRug/JtchGBTMTJB2VdDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAvbI0Tx2seruFdCF/vTmb1Wbq+8RQft3mBQ3u\nGvTYspICIQDAtC2Uo14USGpbM0OP/zkj9pTatbpohrfRsDG+G9H0iw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1889", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1889` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAakPB+C+YughgjnEIyYMJachMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwNDJkMDQyLWQxZWQtNDYyNC05NmJlLWVlM2Y0NjA2Yzg3ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTJlNjFkZDItMzk2\nMy00NzIzLWJlYjYtNDcwMjE5YTM2ZmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg70UxV06aEaQqa3t6yrlWQt8mBaRZAsp87IVNUKWP1WhKWahjzogR3RKR8lu\nDuI+9BOWgh0BEEAv5OZkwA4tOKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzTMNZkEmfcRzDLnyNV6M6IBPNtkwHwYDVR0j\nBBgwFoAUS0Gw5vRPcLEsn26UPJteliCLyVQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAN35+TwO02NO\nIayNYQmH6hlgm3nVcMjBneqpwAG/3l5YAiAuiaONDdUbXp40ltVirbtqpy3Q/Jlz\nuSD4ofmjGuDimA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ57GRrFKzXfm+bAyWzcWqRDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMDQyZDA0Mi1kMWVkLTQ2MjQtOTZiZS1lZTNmNDYwNmM4N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXbcwVxtj4WjrOiBcqKkwPT1IOfLvXVKJPF4Gfm7XeyoVo\nC+pg5kqg5NtPe3jD+qAjzS95fwTlyxQ9wQlPk14co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS0Gw5vRPcLEsn26UPJteliCL\nyVQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbuMEa+H+f623e58GjiJVlu74L+GW661IwlKd+Ug4ORkCIAJYx/nWdeZm\noJtZKnSihPQtYKAFVWze2kRQXx4MviNI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAbXxNNzVi/VYM1EmZG9muXD5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTJlNjFkZDItMzk2My00NzIzLWJlYjYtNDcwMjE5YTM2ZmFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NzcyODMy\nNC0wNmM0LTQxYTktODNhNC04NTMxYjk3MWEzNDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQZ9VBa18BvG5JcUqoURUEuNdrHqkkXsqwCeVmvjQNiw5JimRP57gF9\nfV5nsHipKxY9kqOGS/i+aLEsQg4QGT5Go3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTNMw1m\nQSZ9xHMMufI1XozogE822TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAv9ydb9ZIZwoUyOWgko1gDTOJ7cMWlLd+i5IR\nUMzrAgoCIQC5vmg8U1g5NXrVxsT2zJWELP/0TsmTcKzbF4HrYUnnfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1890", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1890` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAVwQMAa5vaqr8h5XtiBx46MNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZTg3YTc3LWI0YTUtNDRmMy1iMzcwLWVlNDExZTQwODQ4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q5ZjZkMGMtYmNl\nNS00MWU3LTkwNGEtZWZmNTNkY2YwYmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAeWyxb8e9zS3SuOfBVRxr5/ODKR32uJCFBD55AhWBl+lVm0GOVwHWcwsJu7d\nLx4l3QCZ4Alv8vPAsfbCFlAMF6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSy0KExkrm4mG/zb7dU+ajsu83WwwHwYDVR0j\nBBgwFoAU1GF9i8UC7XJTJZ8ab46T6GIQw54wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAN2uzemaU+Ab\nT+JetM/ISMXVN213OeRiFngEyLWLSCVoAiEA5u9MqeSHx6nwT3EkSKmGd+wuWvhS\nrTRCxLlXkR2LT6E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYayDQeWYIPRuzuG1/wqKyc7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGU4N2E3Ny1iNGE1LTQ0ZjMtYjM3MC1lZTQxMWU0MDg0ODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhQQFFkBG2CqdEkKlMYEG8kKDZxjIlCmzSLFmqM1RWPKfK\nWTnLbQmGmXxOas+kY8HJKwuV9P3BdhBKweKGdAz3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1GF9i8UC7XJTJZ8ab46T6GIQ\nw54wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUvkWbesRFEb9Jgbp7KLaLw9jgL66tS98b2cK9lj9YhMCIHU7xsicdcBy\nz/5Qn8wMqxmEMJWqYZAc/bH4jN0m9Brl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAY9Ip9FC22TV6mlUesEpj37GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q5ZjZkMGMtYmNlNS00MWU3LTkwNGEtZWZmNTNkY2YwYmIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YjE2YmJj\nMS0xNWUwLTQ1ZmEtYTBmZS1iMDhkMjg4N2E5ZGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASspeQODYgTCbqEBSfSeuhvSvJ5Swr6sPGw/HLOte0PoHwxSoD9QHa4\nPms51H3RXBdE3moZFsrxsIHzrwymka84o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRLLQoT\nGSubiYb/Nvt1T5qOy7zdbDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiB+WCDjIbP9NYgYmS0Dl7oP8pC1ADD4nPNkQq4q\nTbjsoQIhAIcW/LakOeRuHDoJVhBI/PRXds8r1PWHN422LaYS/ura\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1891", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1891` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAem+jWS08ft1SFMAxWk3H0KDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkMzEwMjk1LTllYzAtNDc4My1iMTU0LWQwNzUxNTE2NzU4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE5MjIwYjMtZjc2\nNC00ODNhLThmYWYtNGQyMGZkN2VjZmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg7OvKZQKHwJmhseCZ1bwA/agz80Cl29p2IMm9gxeaAwXpcDfCHc2ogQMRwz8\n2SZqQrZgbuFnXlsldEitJB7TVKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmhFy6NaE5AdinFnCgop2qiLGUQ8wHwYDVR0j\nBBgwFoAUG2nTeZC1zNJPZMMQPpM2aii9SHUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCt4rSvEkV0\n261Ql/kPnPf+7QWCwq6AoCvxYCB5SIbf+QIhALES/dz84yqR+WMh3gXZbf0hRk2j\nG9+RXLv3QLz0DxlI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQRWLw3IgMqSlvt1zbH+tgRhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDMxMDI5NS05ZWMwLTQ3ODMtYjE1NC1kMDc1MTUxNjc1OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARY+tktFYiYJEUesPfAUHTd3k/Iu+fte7zrWvCt9htBRpO1\nio8Y+54mfwQXrRAe41xeXa4m/NOHg4bvBsf3RCqJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG2nTeZC1zNJPZMMQPpM2aii9\nSHUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaxiGyzNg9PzHNe/TmORdNF31os//cirsXMScvZgXo+MCIBUo9440n/SS\nAfXOFMJuiPVnuotj14ILqJ/ZwZDA3wP+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAYlqEL15RJ4JEoN1IUQSs5MsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE5MjIwYjMtZjc2NC00ODNhLThmYWYtNGQyMGZkN2VjZmQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NTMwOTc0\nZC02OWZlLTRiNTYtYjUzZi1hOTFkZTM4NmI4ZmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ24UYQ+kILDs8u9RDIElq7h12f8cRUYkh2kFbNBw1TakyBD1FZx8q4\nT+i8FlT5qHu8AOjcpSSDjfdmwIdSjhTLo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSaEXLo\n1oTkB2KcWcKCinaqIsZRDzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAv1rL73wmI+Jz+Ls1WS9f5Ns+Za63bwMOb/J1\n1ZKkVS4CIQDYwSxzA4JuGk/TRx5dQIsfkftBWmEhn+heYlRDcXSNag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1892", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1892` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUqgP0yzR+shAnOE944sqAZuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzYmQ1MzRjLTc0ZDMtNGUyMy1iMTk5LTI0MWJmMjY0YTIzNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI5OGU5NWMtNTgz\nNC00NzhjLWJhN2YtMTY0MjY3MzQzMmI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvDTVzFR6MbxyxFIGc2AMH7sVzZL0uyKL18si4tdboY6YRfE2qm9JGVVewyFl\n7bGJmGATBh4DDzTXz/yY9iKNiaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsqk6ffGY+IDuqk+GwbD9x2KoX98wHwYDVR0j\nBBgwFoAUjNApeuxGpRqCG4viJyk8TOZ9R4swNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCTWn51hgsK1TJFM/iExDxrPEjv/p0fhF8Sw2qnKVArsgIgGMppR7MATvio\n2jUv83GTAJhmeahUAGWoCL4xUgqI4eo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaBu10YxrM91J3lcsSyO2zrnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2JkNTM0Yy03NGQzLTRlMjMtYjE5OS0yNDFiZjI2NGEyMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNZUcdB+PSOk5LPa/uN4UjZqNVPL95U0pbL+sJEZA2ptZK\n/FHA9VniCUbF0bh0LRsqkQPzHzLckD9TMA08EEZVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjNApeuxGpRqCG4viJyk8TOZ9\nR4swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIbjjXseE/ctRpzWzNT01Bg17nTHx/D94uSYLtfs2x/jAiALiMBTF9uO\nfeC3/OuDMg+2xEFTVD+MqJtwl7V5fYqC8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAf4PVNmOxowEKi9hviEYrafiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI5OGU5NWMtNTgzNC00NzhjLWJhN2YtMTY0MjY3MzQzMmI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OTFlYjI2\nYS1jZGU3LTRiZmYtYTIyMC1lOWYzZTlmYmJlMzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASAh+g53g9Ipipq4K5vEdDngG72fYpU5AVceXW/NdItE7jc1Tqi42Sm\n8WGubB1DhI8zFov1qO7DQGD/CfUs9NMto3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSyqTp9\n8Zj4gO6qT4bBsP3HYqhf3zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAssny7AsS21xe4zOS34RV72K7HPsKwVN90LOr\nxl4lIygCIEsLNuyK8VzXT43jc4cM/a6LiV4f0+fee009DMKjM8wb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1893", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1893` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVme+FI8whel7vvzmXoITyrYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NTdjZDY1LTNhN2ItNGY2Zi1hN2VmLTAxMDk0OTdlZDU1NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFmODBiYjQtZmQx\nYi00NGFjLWE0NzQtYTg2NGYxZjhkYjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHzM9RfzRrWO7zHFNKnhlpmL2sVysY38cQbAMD/TDnhZuNg+DSG/5ZRzVlf3w\nI8T8xVrOO20Y50U0B+l2Z+XPuaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAmXj39ZjdInjfAYXviSunNq8aK0wHwYDVR0j\nBBgwFoAU5/akNISzMcfqz+IZpvscMFC0KWYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIASZqxw449r2hIuy7p9WNPB96AvEqqmP/NXbTNpaQAWKAiAWJlRm7hYhAdPT\nUlpmHbuzVROWrDp3SSySzzVBtBu0YQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZpHd96GUza3/ZpDJYRGLkGPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzU3Y2Q2NS0zYTdiLTRmNmYtYTdlZi0wMTA5NDk3ZWQ1NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATU/UXheJxQ5N4jL0dNPt4ahR9rn/b6EAZsPNBGSnElmcym\n5kVJJIt/jyO3qhzv456ChKtu0sLwt3UUCAbPx7DYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/akNISzMcfqz+IZpvscMFC0\nKWYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALEwPvWrMh1VVJ4kl3eJl7Bc0CT85e0v9uZzt2TdDRumAiAOB/uPfHaM\ngmvUgpXepwIlRu4Ntp+KRXorF16KDFON/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAa0Bzi8bqMArVMYcFku40XbLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFmODBiYjQtZmQxYi00NGFjLWE0NzQtYTg2NGYxZjhkYjdhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MWUzM2E0\nYy0xMjY1LTQzMzItOGNhMi04ZTMwNDBjYjk0ZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARPx5HxF3Qj94BlQP22DJO/ak8nBWvMMgfIZMnYzXbleYoj5TvcZkxf\n1MehiJWky/sW8zlwNpfFhOrqkVIO/4Cio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQCZePf\n1mN0ieN8Bhe+JK6c2rxorTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAHHzbAW0vL98OjvrxR1qWMb3Zl7veIHtGrdnbJ\n55HwjgIhAPx0q8rsEIEtTncRcITEOoA87cKkWTwQls9j0JApItw1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1894", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1894` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAfGrOK//xI++bpuxAWQUVzGhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2MjE4ZWUyLTk3Y2YtNDc3Ny04NWJkLTMxMTRlOWYwZjQ3YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBhYTYwM2UtZmY2\nNi00OGMxLTg5ZGQtNjZiYTM4Mzc4Zjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeUGskMS7giRU9hiWjUGWHNybDOMknWjptnYLclUYBtYJlcUXUQg3S2pmaEuJ\nzCJxqWT1xc4Aey8PN8ZnK25phaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZNLXitWqchIGvtamyI7KHXpMv8MwHwYDVR0j\nBBgwFoAUTWVV/Hu27cMZ1SIFSpnwOpefRlAwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDQ\nGecLFWmggzptQMw3bLPISRL5tB+kkoUo++nT3E6kNwIhAKPcAEIjR3TL8az9Q6dj\nN7jLkb5HAWlNKYnmF5pUJlJ9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdscNME0cw2p46R/NXOIsjzjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjIxOGVlMi05N2NmLTQ3NzctODViZC0zMTE0ZTlmMGY0N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1T3H254WcMRjL4D+2/4O6wsBjFSInfWqmYy5iULD97Wlf\n84ndmkqO49Ea5l1mbwZBxNXZPERup7TSMs2bkaTqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTWVV/Hu27cMZ1SIFSpnwOpef\nRlAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOYUbz+/sF+fBRgCX2Vx01DPRXpZDvXvPys6MxfukBJ5AiEA2TroL410\noGD/0HNIKpZzAmiBPav0+wV5wx96RE5DyKo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAVYi/36HYkmU3SLY45+LWlFvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBhYTYwM2UtZmY2Ni00OGMxLTg5ZGQtNjZiYTM4Mzc4Zjk1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZTM5ZTE4\nNS05YzZmLTQxNTItOGFkZi01NzE1Yzk1NmY0NTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR3wmGiNKNGZIcvCEWfKyTpBRUX+R2dOuKRikIS8Gi28u5msyVXP7EW\ntBdxLpT1XsSKs9TB4jxM7ZYy7XqUm7dvo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRk0teK\n1apyEga+1qbIjsodeky/wzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAn/sAwO2BQ1CIB0B6k/A2VF9piwUXUQrplTCj\nJwo1cMUCIQDjfRn0NdCZIhu/1i80yN8etFyxmEzlk1PLv5r0Q0C1kg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1895", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1895` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAfXYB57Qp8Q9u/N4MOViiz/UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiOTA4ZGQyLWFiMGEtNDYyZC1hNjNjLTUxYzEwMjNhZDkwMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkzMWMxM2EtNDlk\nZC00NWIyLTlhZTEtOWU0NmNiYzJkOTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkUUhEnCjmIvFbZY9/ptvBUW6ovy+0MZciPQYE9UbLu+v29USAcvfW9iWKhm+\npBhvDno9q8CAR2LaIwVgjObXWqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ4p4DkS21pGNMwUbVviH6dSvd8kwHwYDVR0j\nBBgwFoAUhct9FU8me+rdjT9S3XKHLAX9tAMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDXC0rDbu9c+n3joJFdvsAjDUSs4marI12foyxVMsHdOgIgKHYI\nSlaGGiGPiRFNIqHZUl5vk9JzGROTCyimaIE1gOY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaYDNGF/E/vBgNOoJCzrU/OiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjkwOGRkMi1hYjBhLTQ2MmQtYTYzYy01MWMxMDIzYWQ5MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBx+EC3EsmF6wBq+08wH2gPPM4H79T8CTeiXcDwjRt2GAY\nsvmmtw3VzXgfotYa9kdEGS8fkCnYjqYG/5EMG7dao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhct9FU8me+rdjT9S3XKHLAX9\ntAMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR/mPgQhaArkhv95GEV4rCwUqJ/oDn7bz9uFwwi3U1jICIB1OgcRi8NLd\nXVcFALs1bPwpsy/TXBm9fV2qkJfaF14V\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAU1icztgdxF5CIY4pokkG2Y7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkzMWMxM2EtNDlkZC00NWIyLTlhZTEtOWU0NmNiYzJkOTdiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMmFiZDE1\nZS05MmNkLTQyMzQtODk4ZC1mYWNmNGQyYTEwN2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR9uJJINZDuQBC5RuNb2ibBLQawsJc503qfm9Y21/KpqU9OztNruR4A\nihlO1rPmUyfrw53lamAnxF4yhF24B6lPo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRningO\nRLbWkY0zBRtW+Ifp1K93yTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA/8zajupErcyopMR0m5oimxyguaL4P2GNMW+k\n3LwWnP0CIEuFjRr05iGJo3HGNWrwi/lONdL31Ojc232sDcRbAM6k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1896", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1896` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISASSQXN31AHD7vJ2xBL3LWWogMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlYTZmYmI1LTlhNDQtNDI2YS04YzQxLTgyMjY5NmNkOTMxYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU0NWE2YTktMmZj\nNC00MzIxLTkzNTAtYTIxMGNkNTQ3ZGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuBp4N1vx28JXKAnDuJ/WIzFbsBwyTlE8wX5FZTGubJbc7hhdPKQTkBnrMrTD\nvC2bUMSMyrDx6Dy+oJuhbZ734qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmCeshXSbPhSHibW+nkgj/MnrWQowHwYDVR0j\nBBgwFoAUMRDF14ILPqFttrzQDP1jj8m2hSYwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHsv2pjYH/zgkbAWk7Pidn3gPt84ZRVKZwlgionVw1sRAiBxnlgw\n/0EbO7dI0ozgo0HxAp2G8R3M74RvyFVCQM/Zyg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa1IRBg3y11fCBr4zl93160uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWE2ZmJiNS05YTQ0LTQyNmEtOGM0MS04MjI2OTZjZDkzMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVLbpwDbKp55D1qJVr0JNXpKQhZuoxd9+U8mPlgnm2RP51\no5YzXe9ZBRShCTpS8kgyH9AXhHZo0ERs83fHFsmno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMRDF14ILPqFttrzQDP1jj8m2\nhSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU+cQx4cy3+OeotFgjiTbpTetQwrbSO2SilnYQQw+nY8CIG9uIJl5wWrC\nIaut7AiCS058dgPZ/4p5VjLRSzAm5kgF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISASX95zce04Pc8Ak+J6xlIxjBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU0NWE2YTktMmZjNC00MzIxLTkzNTAtYTIxMGNkNTQ3ZGRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYjM5YmU4\nOS1jZTAwLTRkODgtYmEyMS02M2UxZjg4Yjc5ZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQqRZVDdbgNQJfIdiZ9eKuvZ02IX8iClInVv37bXv4QfBPcl5OhRhof\nt+FvHsk0PZpEQsiAT31L1+KHb7E121xqo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSYJ6yF\ndJs+FIeJtb6eSCP8yetZCjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAnEYIzDkJYvpa2G741Sh491D3CL/W0FPc2dO0\n1hUYhMYCIQC0cgBXPCiXzo+4vea76/9Zg9TTJbHOfGbcyRAnL95Lmg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1897", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1897` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWc7rZsQ8W9FkKk43tn8FcHBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMDU2M2Q2LWEwNTEtNDk2NS1iYmZkLTI2MGExMGIxNTI1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMxYTFmNmMtNTFi\nMi00NjJkLThiNGItZDIxNTFiZmZlMDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElGdJYndTgvFPpq8ZLGuq35y8FS5YNExcF1OZ0TWd83LjwiyOxKZ7UpIsltvn\nlfQoa+UAawsbq+aUnwEzolUxaKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQq/PVUolt/hWIndMI8h/7km90kyTAfBgNVHSME\nGDAWgBRQlDUtWFZTRerNVDREu1C9y2OhuzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCZRisec+TeYgDXZj+nLOWK2Y931ZAB\nusA0hWvIvXKh3QIgDNNn83gM5TGm8HO1DnH/aDdqMX/PC/VHUCIB9uae/WY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARwMUKbsG4T1xYuHPn3yE2BbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDA1NjNkNi1hMDUxLTQ5NjUtYmJmZC0yNjBhMTBiMTUyNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNMSY/S036NrETB5oPISS3zmOrEurjhjybGv9AJ+yS3jOv\n8S1E/2W/+FRCmHoSCk6TvElwbsbnumInaVbjPc1Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUJQ1LVhWU0XqzVQ0RLtQvctj\nobswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPp5hdElk5PaTRPHnKxTGJuLxKiLK9sZ7i8JpgEmvMszAiAaHbJL1d9w\n4DhOVTho8ctevMdcaLkILSyc6kUU+IxSvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAWViuIOTKKxoITBfaPD5icoiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMxYTFmNmMtNTFiMi00NjJkLThiNGItZDIxNTFiZmZlMDUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYTZmNDk2\nZi1mODAwLTQxOWMtOTI0MC1jMGMxOGFhYTUyZWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARw/9RGZJELylxpEHnAOvl2XN2DKRBRu/7LkVvO/zmWVLl1s9suI4ZG\nXUzL4KfhYFgAy8JrP5LAtNS/1u844wu4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQq/PVU\nolt/hWIndMI8h/7km90kyTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAkXRktBMzFlcBAYbJXM80HFOKgUSw1SCXlOJX\nBtrptHICIQCk6D2cXfVjr5dNBuc1nN15MvAzOLMF1j1vX1AcKJ47gw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1898", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1898` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAbuFMik93WEnZPWoY4vKUkxlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2ODU5YTJjLTc5ZWQtNDc1Mi1iZTkxLTYyMzU4M2FhNmVkYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU2OWRjZmEtZTRk\nZi00OTk5LThiNDQtYjgyNzdiMTJlYWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES2nFn9gjuKDvHfBho1qDqjummPA9AN7yVnHK7tHF7LEGyoWUvxXZQT4/B6mG\nUDtSj2m5w0MoeJ+dqX9F4HpDMKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6/SmTiV3PglJzkSnyXVED0HH+C8wHwYDVR0j\nBBgwFoAUzgYsrmMWfmeGXi++RgYDaXEc/AMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGKzaxJObDLz\nBWhx032Lya70WbECmNQk5DctsVTa9UgPAiADFZEifqIheHqsCYZCdkm3K4/qTVXY\nWnuNLrrl2RdZgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUh6n+4r5TDX1+ddbUr82NdmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjg1OWEyYy03OWVkLTQ3NTItYmU5MS02MjM1ODNhYTZlZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdwyJ7WISeyXaPkcVtCAiBMmyiG6lfvBfiB5IxgWtYuwEG\n/hbrbB682ClCMteJkSWOoiclyNhMQcW4qlA2r5B5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzgYsrmMWfmeGXi++RgYDaXEc\n/AMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVaD13Ngpnnk996CiqGxV+wDigFJyYu1rUy7m7INO+IkCIQD14EOtTCz8\nCdQfWnAjSHaiapgGicZ0w2ajeJX1HDO+AQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAVuxZedkvqq6vofV187LYJ99MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU2OWRjZmEtZTRkZi00OTk5LThiNDQtYjgyNzdiMTJlYWUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNmUxNTU2\nYi1kOWYxLTRhYzgtOTY5ZS03ZTUyNDYwOWI5ZDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASKGluSJAPEkttnwgP6jWi0vJ66PjTHkIIbwDIefd2aa2gcrXGDwYyt\nzwudtUwSSl1+KlCX4IOfGVSXWn+6GrlMo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTr9KZO\nJXc+CUnORKfJdUQPQcf4LzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAxAtipJ/wObr6BkWqJd+Mq4u5UezOTFUuay2MP\ndafrfgIgXaDa6d506QZvZPEyRnHo5IOuu5pm3OIgO+4m9qUBuLg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1899", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1899` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAWcxDexRrjic9hEsnZ/lu97RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmYWEwNzhmLTRhYWItNDU1ZC05YmI2LWQ3MzE5OTdmMzM3NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJhMzI1Y2QtNjk3\nZS00NGI0LTliYTItNzQwYTc5NDc5OWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW/czJmvmJJt4fw4g8xtJu03ZJ3wlzPfepjjE/rdZYYXl/nyvR2TvxBkQaEph\nIH9g84gjA6qsnUUCJ4zaOQVOz6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGZwxJW4jemIOF2WxRGxTE8qzi18wHwYDVR0j\nBBgwFoAU15MnR6PteBQxkNQGJYiukxw4g+wwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC+hgI9dVkZ\n+mfcF1Raavk1JO4IkMrX10ngY/of1jhv3wIhAN61LzyhmQs+kuPrLC0Z2L0J25Cy\n0JY5xKUkM3POlWCZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfzPOq4MVlZfju28gFlQXHQ3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmFhMDc4Zi00YWFiLTQ1NWQtOWJiNi1kNzMxOTk3ZjMzNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOm6UdFOUXCcohZ6s8xzdt9/N7ZERRWv8Pd28N2WnrMSkp\nLbbujs5We9QfClyZtRA4Y9ggYvs9eB4oKEDnxbJlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU15MnR6PteBQxkNQGJYiukxw4\ng+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBEPLKmAqrhkDQuA6B9bQkfyuuja+3OxrjpeRr7lSPWUCIQDfhORPhCiQ\nNFyQ9MBzkjFtS9oVWnOSMka64sGbgn2CYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAe6p9N9W8+Ls13AUAzUIOdpTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJhMzI1Y2QtNjk3ZS00NGI0LTliYTItNzQwYTc5NDc5OWQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NTlhM2Qx\nOC0wOTZhLTQ1MzAtYmQ0Ny05ZjhiMDQ2ZjE2NjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQxhHFvDqq/gHQi657nDQatPhCk/vPki5nBNnqKpcsqhWtZgXj0X5fF\nnmt1mfIDHIsvJvVR3cg4dvha3/eIHPhRo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZnDEl\nbiN6Yg4XZbFEbFMTyrOLXzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAuaw0hq1YEVV0U1OuE0h5v/tShZFQ2gZqqwQY\nvMnIJh4CICd7t8ua8CwrzOypOnUQLynaVJJ9tiN/ivcHQ7leJ5uH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1900", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1900` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAemRHSMn9W672G0KkKkZihOrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzNzdmYWI0LTg1NDEtNDY2My1iNmQ0LWZlMTQxNzNmYzIyMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJmMGYzNjgtNDdl\nZS00NTA4LTg2ODAtZjUzYWE4MzVlNjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFojdT/y0b+kHR+U/tirsg1ITO5UHXSuvjC7AaWF1CG2i9kAGylKLz/WbgtKl\nclKRUp8j51PevB+alczbH1rKsKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlorjK2dZBpklY20zf/GVM6bTEVwwHwYDVR0j\nBBgwFoAUKncMrS0Vf/UVxawdAauarEwVnRgwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAWel2zOyTx\nnehLiam1DHaKR9hMOznwtBLwpxBBEJK2GQIhANOf7YYS6C98oaaDX5SNwGg8Z3Y3\nPvXXn3cAwIP6j3vq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZF+mQHlXdK+u6HVDhf74gqLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzc3ZmFiNC04NTQxLTQ2NjMtYjZkNC1mZTE0MTczZmMyMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASk2BE2+aVvWkDXaXTxOAAgxH2SHVCJjyuOjFqmWEkwvbV1\nwinX05VNRZ2eSe4xTwbAXN/HnzN9wia4WS3AyU5jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKncMrS0Vf/UVxawdAauarEwV\nnRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALtAeYnAdCo4OMZuLRtflVMNmXohJU+ddFhOx/Cfk5rXAiEA8Az8imEP\nWlXb9wFMh/lRa2JYmgBP5JUqSrLTCS8h3bc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfvlr+tUkIPjitkZG6uT/2zyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJmMGYzNjgtNDdlZS00NTA4LTg2ODAtZjUzYWE4MzVlNjE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZjJiODMz\nMC0xZGQ5LTQzYmEtYWUzYS0zMzQ3NzdiOTlhOTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS9tqRcLm/Hf8m3WHbf1CTzLuklmPl5YsvNg9vOZm3CHlzdsovZIKZ2\nYEWTr0uMxrp/ZyxDIhV+edWHvxdg+EFoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSWiuMr\nZ1kGmSVjbTN/8ZUzptMRXDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBDkT6oWjlab3D9jGJq6IyI8Jg5aYpeLL41PjUU\nGsqoPQIhALVVMoFrJCZs+YfjEHYAwTtyQhka/vGuNUQLf2U28PLH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1901", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1901` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAd++BowokRgFJsy0BQBF+YTPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmNzUwOGUzLTQ4NGEtNGE5Ni05MGVlLTBmYmE0N2EzNWZkMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgzYzkxNWEtZjZk\nMS00YjgxLTlhNzMtMWFjNWFmNWI1OGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZCuJpr7DUktXVBhWpEYqKdm6hLI6DnnYwac2vcm7Gj2OyCje6qNxyA8sDpFy\nT6Am6loekvppNPksi5/dZZwCz6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR5h1SJJIrlW7AyEyCGjp6N5ThFgwHwYDVR0j\nBBgwFoAUM6ll0zKQR/cl5Or5SszozI7eIQUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAzXwZ8HMiLaQ1FogiAp2CdxKrh5ZSk7DTVlyG01URu3gCIFfAso7yR2f0\nV+6gV45c9Bp0vgMV8uRtSkK+FrbHQHaV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAae9wejtSN8/7qkmbeZl03GlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjc1MDhlMy00ODRhLTRhOTYtOTBlZS0wZmJhNDdhMzVmZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmfW85Vu7RLl1b/iUBKOX5m/PWdBdv+nrvHUSdeVw474/i\n/Fd6bPKmY8q8Ph+jGTRLhPZoSJCcWf0Qz3+IihaSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM6ll0zKQR/cl5Or5SszozI7e\nIQUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfZu+qQ/PJkubAn6EkaezViKmsBibxsnAqbypIlidK/sCIGze1We8PFRY\nR2N4lmOClYPI9AV0jGjW8PI4yw/mtJ4D\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAY+dhfrX/a6GGU0PKD/b3V4vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgzYzkxNWEtZjZkMS00YjgxLTlhNzMtMWFjNWFmNWI1OGZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwN2E4N2U2\nNC1hNjA3LTQyYTEtOTI5YS00ZjA4ZGVlYjc2NzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR1DNb2Kjkkr7Xb39p9tu8VH/BKKaKAnNajQdrm+57xJaOKKq7Kpx0Z\noDgJyZUzLovqI98mEM8aYWKeLee9zoYTo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHmHVI\nkkiuVbsDITIIaOno3lOEWDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiA/n1vP5RZHCcREg/CrPuWhP6vRxQXtaGzn8bwm\ni5q/1gIgOyHflmBkyAavW3+yRxIf85g+giKmB5+AEyUwDr6w6SI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1902", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1902` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZvJ3kt6SPBFa8W1H+uttzNtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0ZTEyMzZkLTUzNmUtNDJhMC1hYzM0LTMwY2U0NDc1N2YwMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY1MDhmYzUtYzk5\nNi00MTkzLTk0MmYtMzRjNDE0Y2Q0NWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmhVAp7UyldKS29y/X+FOpVOYOKN2+MyT4orw4xiIBBbCVcfKMU6MmDOpQinW\ngTrlWvNpAbJVdkeeci/3UhII9qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4eiTYFkIjbHG8qIVI2nIP3q9BfAwHwYDVR0j\nBBgwFoAU5mBbVPPtCkTnbcJn9IPgXtlcc0gwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiA7jOPqhSAaL+f51UFLdBMVGQvR+mjR4kYDSyE1N2lvtQIgLNtQDGm92LGA\nHtPCjS4Nmy3Ki0LtqWTzpXWgF859Cw0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeohayatTUhK7x2U8tzqFnGLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGUxMjM2ZC01MzZlLTQyYTAtYWMzNC0zMGNlNDQ3NTdmMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAhWQd4pcyadcB2h5BLUgtr8ZpNLXu9Zsl6MwkLkprQjC2\nRVL6sG5HCUaZqXINSgWIhgPmr/iJhVwU52tDavQTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5mBbVPPtCkTnbcJn9IPgXtlc\nc0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI8eSXgaM/R87Qny2b/iCsWMzEPyg2ij4k8UhkvzyaqDAiEAo1VGEyzk\nY65nhCiXtV8O/R0RDaZOOjgEF2G1tjS+jks=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfc0lDWy/Q6QbENyrByyLstNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY1MDhmYzUtYzk5Ni00MTkzLTk0MmYtMzRjNDE0Y2Q0NWNmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NGIxNzEx\nMy00YzcwLTQyZTktYTdiZi01MmYwNjk1MGVlZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQjiho8MOaxaj7VLinVhOcItqxOS6WVppDeD/If8fA5xgp7T2GmaDeO\nzM9/XOMook/d/hc6ocvSLDf10cOLLVX/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTh6JNg\nWQiNscbyohUjacg/er0F8DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA6FgpgFM6FHMS9/CBJe8mQQyEz/RiEuPtuZZH\n0gwUmGECIEp5x9mD4m3I1eHFjY0atpWgPYStdx+mUbADbRKgVHdX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1903", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1903` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAfT7RI4mbSJGOVf4D6V85MAHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViMWFmOGIzLTNjZmQtNGUzOC1hZDhiLTMxMTMzOTgyM2Q0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNmYjRlODEtYTY4\nYy00YWNmLThlMWEtNDdmZWRjM2NkYzhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvuFpeTMabbHKCbJ8A6KrtcmAfdZhFRNYKYikp2rRtfvRqUi/rKavW4hFQeqI\niLU2SP6Znrtq+6C2zy+PRYen6aOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDoPXXYw1YQGjJHCiMRF6w0mY6igwHwYDVR0j\nBBgwFoAUmtDCxGfnkoESL+CSQmIDkbtVKVYwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBf\nybYGAH5J7FP4MERz+YzdBJgfontNWJ6XoQkHM52PuQIhAKUtkBTDj3DKlF0VQgGc\nlPcq51QZLW4+KunqAfA6TRvI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU4sNk/+YOS9Va0nGbmURnICMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjFhZjhiMy0zY2ZkLTRlMzgtYWQ4Yi0zMTEzMzk4MjNkNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDzWgE7wCP228IJU9/xikS603rrZY1RgMuOLhE8NlVAwN0\nIO7KThfZWIXNiyFbjwulY1El1eAve7zkU+IMyX+8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmtDCxGfnkoESL+CSQmIDkbtV\nKVYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJpf8oIAMzuDUbqplqSQIm3LYH8+7jYsJvwQQbiuq1cIAiARWWU3Fljj\ngaBSIAWwXdFi2g8zywc3YYLEpAEYdfL69g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbhrIYDzIXoz9xRinffc1kRgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNmYjRlODEtYTY4Yy00YWNmLThlMWEtNDdmZWRjM2NkYzhjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZTAwODMx\nZi1kZWEyLTQ2NGEtYjlhOS0yZGM3ZGZkZjZmZDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASot3CZKg1jZ/dlFRT1CclrpobIZAUQ1DyHMo2lyTljqEww8eebMOn+\nmW+lYBXu+JjKC5v+NqKGlV+abs5ww/UHo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQOg9dd\njDVhAaMkcKIxEXrDSZjqKDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBtGB82mNTzc7cTi2ssdHKCLlQX8tArn+iWvqg9\n0tALywIhAJwuZrvvbIi5BvzsjELeWw4ATeeMkRuJhd77N115OKwe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1904", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1904` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAQ5lt23VDvTA5beSwqjrBITyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3M2MzNTcxLTlkNjQtNDVhNi1iNTI3LWMwNTk2MDBkOTJjODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RiMjU1NTAtNjcw\nZi00ZTk3LTlkOGQtMmNmMzQ2NmNmNjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWmMP1xtQ+rp5Mza2U9vGadLjp/BFbw4wVW/vWQHeWTdP2wfRlrLqBg9VGkjT\nyewthX0610zfHLF/Ad1W8k4LgaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhrWoMtKnP7LGtJc9ExmMC8oQfhIwHwYDVR0j\nBBgwFoAU96ObDsjU7B0WKZ6r1mc9+ztipBYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAltg1q7agwTbXkL7cFHw60FT3WS2LjLeLSk66gkbMAHgIgfVHW\nvuwuV4/xO7sZDiGNDX+SCeti8y+U6cK+RYXthNM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQeisqpfMepJwCztY5zalmHOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzNjMzU3MS05ZDY0LTQ1YTYtYjUyNy1jMDU5NjAwZDkyYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARksOHDqTzEEG9mf2M+9KS8ugmTZ6fd1xEUuy8g3cJbcvMc\n0RVEmNl/Cbj5tMs2p4Skva5fETXjkFmCxmOw8Ydvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU96ObDsjU7B0WKZ6r1mc9+zti\npBYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJUYoS3xOoecs3dFuspmW01yhA686KpvXCEQ2j9fk3GvAiEA3WG8Z/Ya\nJAPcGCiX/k1rUmTnpQtneRXO+dRSoyDjGwI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYZbWi+cdaaltPyOgf+wS8JjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RiMjU1NTAtNjcwZi00ZTk3LTlkOGQtMmNmMzQ2NmNmNjAzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NmJkODE1\nYS03OTA1LTQ3ZmYtYjkwNi00NTA4ZjBkYWNhOGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASHcFqjiAmp0x2M17JnpvemMGa/yj3AFc40zStBoPQJakrPZXtMVOJK\n1u0EKI2SMCcBzmjgdmYCEDDw5ZUuPGkxo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSGtagy\n0qc/ssa0lz0TGYwLyhB+EjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiB96ccCDsYBINrBCR6suhuhtwYWCfCd1idqzonG\nDXdpCgIhAPEtphcL4+spOL1u9PThGQF9OAK3xztx5m1PoFlmadm3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1905", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1905` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAQ2dr7djA/j2x0Tfs6FNh2AdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5NGNlNjFhLWI2Y2ItNGExMC1iNmJhLWQ5NTdhM2U4NTA1ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2JhMTFlMjItMTEz\nMC00ODBmLThhYjctOGQ0ZDZmMjBlMDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE39wY6vqzCcvbSQB/ODDkfwfVXmiFEfVDEQ/SV0WIq2TjsOebbxJoRRKRmOX\nafQyfVQfCsdAsztw32EAKu57RqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfNTVE7dVxq/UV5VEPqByS23EE9gwHwYDVR0j\nBBgwFoAUI+hEv/C3mWRGG9D5XhOBNg9h0EAwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAqYaD2AeK/t+TA48XDsO5UPTaPM3Rti4ANMMLEd8OuY8CIQCO\nMxwkVK2C4tT5c6e+n9EKv74tO/aUp/oIlgS7J84Bvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAerb3s91hgBk3msIMKbbxRgkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTRjZTYxYS1iNmNiLTRhMTAtYjZiYS1kOTU3YTNlODUwNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJFpdbR3WYodoX+RmmM2UXagXVgsLyLNn3J+xbEuKJcoqw\nzi1aP2k5AqfgHaXvMyINQ0s03X74R98FKCuRcdxho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI+hEv/C3mWRGG9D5XhOBNg9h\n0EAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIkQNWtQVKHfjaXymsa04gi98f8W5L4EMvUCOIlXsnFuAiALso9Ubv2z\nWAaF48qILVRKAxeVWOOBjcWjS44TPaemIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAaCFN9jQWEI3teUh/T4vjLVJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2JhMTFlMjItMTEzMC00ODBmLThhYjctOGQ0ZDZmMjBlMDE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MGZjMjBi\nYS02Mzg0LTRkMmMtOGFiMy1iNGQyMTk3OTllNWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATvFWVIwcRZvuPgZPxvAkIFI4mRytx0dapNH8AfpSeFAVRE4LEGqJSJ\n+O8agc9wHU6fPGxYViea51C0AnePPHtzo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR81NUT\nt1XGr9RXlUQ+oHJLbcQT2DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAfJ/sf98Wnf0bjYMjMmhdOxp9pGWBUeoXH19FO\n2NDDLgIgTLg74F+arqMrW0BBF1tJErBtsJl6fGxt9BsRqEDjdYI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1906", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1906` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfW4U0qalOZGEzZP+icgRrRdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiMjZjNmYwLWNlNWUtNGQxYS04NjhjLWE3MjIzYzI3M2YwNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDIxNzgzZGQtMzA3\nOS00NTQ1LWE0MjctMDEyNzRiOWYxNDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN458720dUwixHDuRo14TBu+jrqhC7auuuZDCRs4TdjCIIqMAfztf5+EUKdRj\nMYtsUdtXfrsmsSzpRYdAw6au5qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2DwxNkO/h9L84vqNi5rQyjvAnLMwHwYDVR0j\nBBgwFoAUeu4srJPlLOp3AjCexM04G7j7TmcwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA/Z7pNX47rLwP\nyUYuYBy7UZtUE4hH46ooX8a8vEigykgCIAdWsm6p5lUWGInde52xKjj/IyBBzjRN\nvhV0Xouv88mp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUfZaGkQPSPkTvClSz8cEtGfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjI2YzZmMC1jZTVlLTRkMWEtODY4Yy1hNzIyM2MyNzNmMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjCZWkvfuOMkRHsbdURZQdGXOHE++A6L7uZg/kac4K+MId\nNAmaPLkc+V+ECW7JcMM/LubkjpfbPF2rOzQ8EKPdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeu4srJPlLOp3AjCexM04G7j7\nTmcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJlR3YU0cV++oRnI8+ONKGyQaeQ2SdDZpR5G78Iqf8pcCIEcF5CQC95Di\nfn/2PcbotqqrODB1d4CdhCHgt4OqEIKq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAQAkoUQdGv9EUF/XvEPNUug+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDIxNzgzZGQtMzA3OS00NTQ1LWE0MjctMDEyNzRiOWYxNDE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYzMyNGJk\nZS0xNWM1LTQ3NWUtYmE1OS0wOTA2ZGEwN2NiYWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASBKrd2+5RzRal2jd3PP3wcj5C3Wih9ePRI6hrfbhY9bI4CTV7JHpYo\nIFdvrLGC6CxO3g/n9Kjk0x/aYK+xXumWo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYPDE2\nQ7+H0vzi+o2LmtDKO8CcszAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiASFAnoki/VIn6Txf2B4Ktf9sip+rf1zKB/XcCx\n6Unz5gIgWklsCAaV0+xES8f+YLejqZzrhpAzzoCsW+xItch96d8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1907", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1907` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARHrNrYdEjaWGJHISvgLuRSmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1MGQ5ZThjLWE3MGItNGM0OS1iZDc4LWQ2YjI4ZTczZTBhZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZmNDgxYTAtNWNi\nZi00NjljLWIwMDMtMmI5MzM5ZDRhOTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk8RBLL6z/wOhUwNq1Dubqi+fFZMru3BFYuVWPyOgaayfk38oVucLzu4i5tQD\n6DsxqKZsYidY9LdrgMXnHgRipaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcw82tA11tDQog5UWNau7mgSucn0wHwYDVR0j\nBBgwFoAUm2YykjH4PYB4uDgeocyuH0rRiv8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEjWcmRuO7/yanQtpP7Kx4b3p98ajyDWLVJqV+2TPra8AiEA0WJ5phvZWZtZ\nbBm5EduB2egM10mY69LuEu57PgVdBuA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY8C9ImC+ytVjRLbFinHf5ioMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTBkOWU4Yy1hNzBiLTRjNDktYmQ3OC1kNmIyOGU3M2UwYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAg9W1hQ3swmzhzeiNQYYrwT+diXQQVhlB9+TgNm+HYQHS\nFts1o+fQXnuBGgJa0clKaFoOY60YacLzWx/OK7jHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm2YykjH4PYB4uDgeocyuH0rR\niv8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOKydTr2dUM5w9ZEJJD7ocmBOTUK8Onl2lOiK0XgRJjpAiEAhnhOXR7c\nd5AYxuYEBmPbawrDVJ+aHh2/ZeUkQNVvxlA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAXKOAQ9Cna3lCcE9zWcn/hi4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZmNDgxYTAtNWNiZi00NjljLWIwMDMtMmI5MzM5ZDRhOTc1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MWYxZmNh\nOC0wZmI3LTQ4MDEtODJjZC0zOGNkNDIxZWZiYzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7Gss7gbO5eMpAFpaSf0YoGgfbcDwanofYF/pixHBiBhhRK/yIXF3G\nkTnpU0qzpbuYwUS3kQ4SC7vz7o4wXvKDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzDza0\nDXW0NCiDlRY1q7uaBK5yfTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAUdKR7L/r+VUEfXAyunRAPb4mzseJ/oZ9AM87N\n4PKR+AIhAJz2z95Muif9A7VHciDaZwsCCHRnGJGvmDEFfC6O+5N9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1908", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1908` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfu08y5rHetQLj11qNptHs5yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1MjY0YWFlLTU1ZTMtNGU4NC04MmJmLTNiYTZjZGE0NTA0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg1NDViMDYtOWFl\nZC00M2Q5LWEzOTctYTFlOWZhYTU5MjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfASnvsPwYGlrZYEf9TxCzqZK6UviQt23Ha73lhB79LxN5y+9390XtpoYjxoN\nQR5zH0fG/mPE2GfxvzGJiJjt66OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmfpuAYa/BZGUp95MAZ3OBJoNNpYwHwYDVR0j\nBBgwFoAUPubSrtGEtUtTDyGOqWpX7fpEN0MwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBHsU0WJ+3Q1mNypaocYUQ13qpNMZ6bqksUAj8ECE9W6AiEAwzJNgbhy16xf\nM/rOMzN/jTC1M5Fknb2+zYdkrC9K0BA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUl1ylkmoonY89fNcJBTNQXDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTI2NGFhZS01NWUzLTRlODQtODJiZi0zYmE2Y2RhNDUwNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAItHOQJohkCjKq+iswrF1XZGaczlkNzNrYNWj/MNXC+To\ntH249FjJYL6mmt+EjAY5LbrSBjDIHfXdBM51B7D2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPubSrtGEtUtTDyGOqWpX7fpE\nN0MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMB6U29YzGpH9KFWvWaFiWtyqNeNuzccge9I/M6S7Fm6AiAxumawQQbX\nI7xITLNe47O1Y1jWnObT8RSbB7n6n843MQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAW/qNFbIutE1djtvPvUn8n5pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg1NDViMDYtOWFlZC00M2Q5LWEzOTctYTFlOWZhYTU5MjFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYTM2OGU5\nNS0wZDlmLTQ1ODAtYTg2Ni02NThkMGI4NmQ5YWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATLYprXgOKCi1HCs1ejkR2ZVX1pCTjEGM3MNMNdYQoFQPNk+r6bqXYu\nOaEJDLmeYY14X0WaoxeHX/wtKjHS6XRIo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZ+m4B\nhr8FkZSn3kwBnc4Emg02ljAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAucWfUSgaprh50UmPWmWw1xDtY19ejKM8cFoCP\nN8VfqwIhAOlFCGTUG6sYyjGgml8aS2sVMm6YGjVux68IJMzBIL6H\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1909", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1909` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAUL9KyXTCD4nRWyr/pD/i5IsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkNTg4NmI0LTdjMjctNDk5Ni04MGRiLTk2NTUzMzFlYTI0NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdlNzEzMWEtYjhk\nMy00NjljLWEwMmQtNTI1MzE2YTZiYzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUTTp115KQopPO9NGV2lQHA1JDG/I0SLKKBctM9CB3JTdryRjHDSitw1kSev/\nw9JCuY8RucaikClFRKSj1kZm6qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURF3hlhFu66v+uBbO+sOj0ycE/IQwHwYDVR0j\nBBgwFoAUOYd1t3Qn/p4IRX0byQUd8gfcC2owNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA4woxv678mfM0OUVEAMila2EU1tO/zHQ4N67BJGPlGMYCIQDxixGe3qf0\ncuS3FhCURUvObnWiqvkV+ByCxlCfTxd0oA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS9i7eGt8Y8bZVLjj5TAls5hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDU4ODZiNC03YzI3LTQ5OTYtODBkYi05NjU1MzMxZWEyNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQX6LsoXodc0pwqBf2hS16wNRdCyoX8LynNJXjTKxqJP3+q\nJ7hZTwE+4EvohnYzouJncw/cySPaTxFhPybmkBMuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOYd1t3Qn/p4IRX0byQUd8gfc\nC2owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJkP+ZoGiU+7Jzxob4HHHeJbA55RluVm0ICfqOYZ+MexAiBHOwgBtGPG\nHpzd8+v8MnaWwW4dI6zuqCnTt3tzLSqEaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbDIY3bEZ7lXfv2Pb50G+HkaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdlNzEzMWEtYjhkMy00NjljLWEwMmQtNTI1MzE2YTZiYzIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMDU2NGNm\nNi1hMjFkLTQ3ZDktYjlmYy0yODcyODNjZDJmNDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS0MXfGKLbNiHd4ii08zWecy/cspQwfLlbJag+Mwf0cchRxqk183yDc\nDAA/ipKwuNCXmYz1trpM4tVeNhjhSV9no3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBREXeGW\nEW7rq/64Fs76w6PTJwT8hDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA6XxA6IZJKUXKpz7E9j0HWzkmU/X3QRhqKlK6\nqXiGixYCIDd5vXVprDtXifXZ554i4QewrgebpM6Duz7535sMDq3T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1910", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1910` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISARpeBhbPJjKguOCME0WZM97YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2MTJjOTcwLTE0OGEtNDE5Ni04Mzk5LWUzMmMwNDIyZmUyZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNkYTY2YTYtZTZl\nNi00MDY0LWE3ZjktYTg1Y2MyMGUzMWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiJcNIfvWcG6b+mlIfIsqpdH4lCvo6RsgIw5bSZcVK0HG8c2tTjftpkrNKJRt\nnLVRuzG2xvL91ziJd8Z7iGqmgKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/RewBt+hYjJpJYq3sNmUrq+/RiowHwYDVR0j\nBBgwFoAUCxBwvRU4iOqEB+115kwGrY9ILGswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA/dZ72ZiruAf8JVeRM0q9VxIBUE5WP1Jz5O3AC3Fx\nBV4CIEPB2z3ZD7VRSRIcsFPBlUqNrdqFq3tettARdHH/6go5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATkihdzJny0TpJEpAM9DfQMeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjEyYzk3MC0xNDhhLTQxOTYtODM5OS1lMzJjMDQyMmZlMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdXPT5k3chCYzFWPUAC2Wcv3eTaawd+bvAvHdtAM5R2PZp\nVUottaqqk5Tn1ZfhBkUs8d9tMFg1BNXh6n46Fw/yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCxBwvRU4iOqEB+115kwGrY9I\nLGswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdLhKW+dOfBw9xgq0y9UOE0ehbPEG7JTUYookraQGmwUCIQCmqsJ5us0a\n8KxGM+2yli7pwx3m5k2A77wayc4Viu4sug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAeLAnYHECr/YPhHQFDhEjRowMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNkYTY2YTYtZTZlNi00MDY0LWE3ZjktYTg1Y2MyMGUzMWFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ODY5ZTJk\nMS01NTIwLTQyMjYtODE4My1hYmI0ZjVlZDdjMzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATXzBEYpEx8pWwkrpFkGsFC64bYnNVHberEqfbag7WbQoYG2UtWw1m3\nn6zNeiVgHCOA4mPsMe3xKdPwaSDxuxY/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT9F7AG\n36FiMmklirew2ZSur79GKjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBd4df7zCq8Iwu+1kSSP9pxHMXgTx9LHg310Zs/\nQvW0zwIgNdGsWmy2Cz3I70o05E/BrqVC8q8rl6RQGdrvNHinO+k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1911", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1911` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISATfk4yyprznZ2JYY20BYde1yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhZTdlOGMzLTRhZGQtNGIwYi04YzM0LThlNDQ0NmU5NmUxMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNkYWRjMTItZjQ0\nMC00MjRiLWJjZDYtODk0ZTE3MWI0NjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwtMcL+6UMUuDr7/ZFNOLvtLehuvXJgrA0/ijcf5HslexyNL2X+MkEI+TPA/g\n4m5aMYS+45UemGPtFI33wehI6KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1xrNMwUkvt7bXQip2zLm+rlsZLEwHwYDVR0j\nBBgwFoAUXxKhQc9jRnqfL2Vff1mV5W2NpAAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAyw/MXEtSSSumZ9LkbmBD9wI7t24HG6JKv0CMt0OVp\neQIgWocIS1w9voaRbpcu1ftMe0dav3FqDOy4tpPuyhQXswA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAepW30jFFynhpf4iZmvgvu6nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWU3ZThjMy00YWRkLTRiMGItOGMzNC04ZTQ0NDZlOTZlMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStoKR047iZbStGQpHXM5h0CNyl5PGvNU+5mDyQCGzzfg9+\npBST4SYrB3SpOjvK+5w3q/OZGV9mlYRq4AqfDT4Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXxKhQc9jRnqfL2Vff1mV5W2N\npAAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF2OcmberXEySgGjZrEc4hf35pPpVatsI2z4kRDCTduwCIC6D4FZYV2EV\nEMZ1CDfRbUf3Kf8whkbRdIp44FbR2Dc8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAUJ3vinjWOvBJxUkMKB8aYLEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNkYWRjMTItZjQ0MC00MjRiLWJjZDYtODk0ZTE3MWI0NjhjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OGJmZDNm\nNy1lMDE2LTQwOTktYTJiMC0yMzRhMmM3OTkwZDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ3W2vxyCdVc1LEwwQsYbISjBiilR1rvUx+vfIDCV0K4Q339f29dLuN\nuFtH1PLqKT3JylVSUAqId1ivucVYz3X0o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXGs0z\nBSS+3ttdCKnbMub6uWxksTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAgcNkuUNnxrr2tvTAipj1m5wqXaPRG45rXQEY\ngQTsPZkCIQDmhdMuQ6tpCMlVHOsKsJiVWJC5RgOxIjDkuEuOI4swJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1912", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1912` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAeXTMSUb/iyZ5j6Ps/PDk65+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhZTE0MDdkLTI4ZjAtNDM3OS04ZWFhLWNmNDgyYjVmYTg3OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZjY2M5MzItMjk2\nMC00YmJkLTg1NGQtYWM4Y2IwZmE4ZDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6M/m6+MppPEYW1Y6eiuDfGUTt6Swu/+jSVzigLAjK+VulEvN5zPOc0kORYj9\nQuHkrIuaQ3OgisJ4n6t4agp3sKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn2oX/Lx5OVHrHruAuD3BQNzrnG4wHwYDVR0j\nBBgwFoAUYBkP4bP7RfC6O3Zf32m/AeLr9XMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBTpY3FdYlXtnXXqNDT2axyWFaS7I2GiHATgCrXVT3zoQIgCy8V\nI92Ze5KfcQfvcCQtg3lAq5g9hH4Abh7gH/OFNvE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUWuRi7RScEcHFODK6fzyBYNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWUxNDA3ZC0yOGYwLTQzNzktOGVhYS1jZjQ4MmI1ZmE4NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJV278TmAAJFkk7POHrxizNXvyzSj9mBp6d/bHy/4gNQ1H\nU+M1fIAo/2Y/MH3BCD16JTyUxl4Jk+5yDZTq44Myo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYBkP4bP7RfC6O3Zf32m/AeLr\n9XMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIfI5iH3sVPFVcnAKNJ1yrSHhIf1p5CJHCXA2SwsQoWTAiEAxH2iHO5y\nMO6NA0nNazB+5ih4c9CPLhDH+lGq7qdPaFM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAXrgCvGXG0cz8VeDTQ00TTP5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZjY2M5MzItMjk2MC00YmJkLTg1NGQtYWM4Y2IwZmE4ZDZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNWU4N2Q1\nMi0yOTlkLTRiYWYtOGYwMy0xNTNjMmQ1NmYxYjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATUhVJSStDhNcF/JOBv04KQKPbuZOfZlTSTY/Er2to2+lDXs3pFOoKi\n2dksHSE4GlCkrfiDWA2Pdr/FD7aqmrD7o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSfahf8\nvHk5Ueseu4C4PcFA3OucbjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiALhhlrdETKyJJEPvtLvYiwwf9MssawMe9gCpcP\nOmrKEAIgAbIEk23+9Q1w/ghCaBioVTh+XDAhhwrV1AXt/ZiDRdU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1913", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1913` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbGHsnqX22IPT8WBQKThC/oQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiYzkzMzllLTM1YTMtNDAzYS05ODdhLWI4YTNkY2QwM2YzOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNhYjI5NTItMWM4\nNy00YzJjLTg5Y2ItY2EwNjRiNzdlZGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjjQFjvzD0maffsHxp+nBLIvalDbcJVxPtCDkANSnqEcoOUSgSbbptrcr0QQM\ncRMuNAP3IMzK/FPd1zdk4BWo+6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZg5Sc12rVJdyVUn65fsVpOl2h+EwHwYDVR0j\nBBgwFoAUuIAuMG5/mO4IPCa1Fqo20fpYLtIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBP1ilxrA1jPUFto2oXPcWx54F3NcBiUQ/2\nBT8JRU2+XwIhAIexB+2Tuwqti8kVB4WiLTfQuiIvWfv0qYCKchhvAKek\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcEypgXhtS5ai3aDX7tx6tmjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmM5MzM5ZS0zNWEzLTQwM2EtOTg3YS1iOGEzZGNkMDNmMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHNQGqeHcgTbmql562Plj6KxDOwDvIwCJm3hc4mShk+QVz\nWqxLHcWbkvKElPZcPuyPmCj9khFzM/QLzftuENdBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuIAuMG5/mO4IPCa1Fqo20fpY\nLtIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgf8e9MaXasa58aDXVyLnc3Az2bQlbdj8ZC4t5tRD8KwkCIQCQNPqSvMVb\nqdCTfBO1oP9PwEUeR6oNeX0RQ1xpMHLNCg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAW9iuCiEgDvnpEhgGgIpyKKfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNhYjI5NTItMWM4Ny00YzJjLTg5Y2ItY2EwNjRiNzdlZGUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNDEzYWIw\nMy04NTk2LTRmYTktODU3NC0yMmFjYjFkNjRlZmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ1z4J+QqvvorSjexPMJum/j2bkvemIkEeX9BZqIfh2wPBBXuaREvVR\nFWXYqpcbmy5+4/RRHoadI6XXtWO9RN4Co3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmDlJz\nXatUl3JVSfrl+xWk6XaH4TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBrLJyebcX9sVJHSYPbFqFa/4Hb0QIiiwdHza89\n9EPyUAIhAPv7sLE0MRQlF+xwmJRvlKMTbti9IfgIIS0Cts5hFcZU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1914", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1914` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAfikKfU2aLHXew6Hev/hoOAhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmODQ5NDYxLWE0NGMtNDQ3MC04ODhjLWZjZWJkMjQ3ZWI0NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU0ZDExMzYtN2Ji\nNC00YWVlLTg3NGQtNTg1N2QwMjVlYjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA3+x5C/BNBgJ6ji3LKjkOgRHIEw2IlKzKymBrzNfLRYAy5eI24aFAybYjvDx\nhkpngyztarcqmjWcIQ0jxcGs9qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlgC8gLyhafrf/dnTIwuZZHrQ5nQwHwYDVR0j\nBBgwFoAUB4EpcuYKZCcIXcX1+QqcLFhh9sEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBnpwcLvFSWoJTeeocRhL7fopRjW23sF8EX\n0dFabziJZwIgD0KjzOzbQQ2d+gK5xM3LOCEVolEUs+sh1+MZzk5Zoew=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQx2y/nFjhxL1SFm2WOvPaKAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjg0OTQ2MS1hNDRjLTQ0NzAtODg4Yy1mY2ViZDI0N2ViNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATElPaY5/P5XKFnLs2dhsk629N/Lew8cECpLrcY3VAOdoLC\n0cTKg0ev0V6QOZucOZsn/nbq3b/yBVsSmpo7KmLSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB4EpcuYKZCcIXcX1+QqcLFhh\n9sEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOB1rFDdwjoikcSkoZ+7mDhKF/GuUJM55ryvN5W4E42jAiEAz2Z5aHLN\nlWcHplgE72XXFn+Mo/To8OOsREA4fYFf7as=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZUYzTGku6kKWoAeZ19J8NbaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU0ZDExMzYtN2JiNC00YWVlLTg3NGQtNTg1N2QwMjVlYjdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNmZhODcz\nZS01ZGY4LTQ5OTMtODVlNi03NGM4MzcwM2I0OGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATdh6zmyWxfREor2cZ0t88aGq9lI+dt0l+BpeJu5LBVQe/zduYBTH0Z\nbJ8RS2qtkW2wbymKpqxve7h/sea6nJxao3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSWALyA\nvKFp+t/92dMjC5lketDmdDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA/rQ/8/CO/X43+DJSn3VQpOEgtAcPF1Z8RduD\nBFa23WACIGtvh5WOR7yvDpJo0nDhYarobnhUPewth0GZ7uSsNppX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1915", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1915` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAcY2N42uIzgqeB9Zx104tg50MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxOWJjMDk5LTRhNWEtNDk2Ni1iNThlLTYzOTNlMmUxZTM4NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y4MGZlZjItNDc5\nOC00MDRmLTg3MTYtNWFmYTgxZGQ5NDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz4fliagOGKhOmbIodCob4qGPT5JUWnXgNzBtATiLj6wgQjm5pKsYwfDG0owH\nv83FjabyEvAy3gDV+cDVKdBAIqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfXoOb22EI57OP2cI0xvVsV4i5mIwHwYDVR0j\nBBgwFoAUJu/5cZTtYxNXZcFCT1nz7l1Vc/0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAzcH4qbTLxipO\nAyrF4j996JkIkedzd18wHH/TfQLe9S4CIQCULjFPWlnTuwKSQk2SogKFwWpcPHZi\nW9N470DmyhJq1Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa/0vvsmju/UYQhftvJ203DHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTliYzA5OS00YTVhLTQ5NjYtYjU4ZS02MzkzZTJlMWUzODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNQ/LDZQehyW6TiWcAZwLmZ+KaY6tJ/fLEdlzuAMp2pHdh\nqDMYiXLcZpax0I9yvwoqWJTncgUcrtbBsSSqgCkSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJu/5cZTtYxNXZcFCT1nz7l1V\nc/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANEqtKzdjDB8qXduNoN2oLhgbvNGajAJgVAkjps0CLNVAiEA4gFU/u/b\ncBEejxhqg+PyZ28w/9NLo7/6VKnH7pvPN6A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVYD58H85uMpkpqo9rfSAb24MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y4MGZlZjItNDc5OC00MDRmLTg3MTYtNWFmYTgxZGQ5NDZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYzVjOWFh\nMy00Yzk2LTQxODctOTk3NS1lY2UyOGI4NTlmNjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATbOr3gw313PcEUeZWfVh9QTaOnBYE27vsYYHaboj8wEJlsoiTQ1d0x\nQPmv09fF3Ve3KjjUgFQ2BBB0c/MeKnqOo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9eg5v\nbYQjns4/ZwjTG9WxXiLmYjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA3XG/ApN4SkOkZtigRYoH8uHDctGK4lxfcLMo\noLsC0ZYCID+UuCP4zMNi0irfYmKalEfTIp0212Ls5jrqudcGwuZj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1916", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1916` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAY5TU9xKWZhVKbLnksadkqNAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiYjMyODU4LTAwZmMtNDBkNC1hZjRkLTc5ZGQ1NjE5NTIwMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk2Y2NlYWUtMTgw\nMy00Y2I4LTliNzAtOTA3Mjk3NzhlNjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExxEUVxHeLcfTz9+54nvg+fT+IxceeZI7CpIrBJHJauoyGyyT/Z5BRqh2Z693\ne3wVjPfKk7dra9LafvEa+x2UQqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURTwElPmgzt9f8URNrhe3gJVh6b4wHwYDVR0j\nBBgwFoAUzzQEve3Jyd0Ixmk2DQF4FJQcc/MwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCIlJfqgE8a/4O2jFms87jOstOwOrcjil6FDsZkV1cKdwIgZ9D+OShsckxt\nk/+CVeEjVf7OrVaFO1C92OMPrTx8+RA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASK/KKKOZm/BI5oCezNl8hFoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmIzMjg1OC0wMGZjLTQwZDQtYWY0ZC03OWRkNTYxOTUyMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfPxmbYn19wIAFLA6fu9O2e87qJAyk+4i6RpqbKUL3dhOh\n0Xq5PpCZVo8MjKCaAu4WGvlhppAlReuIgOonEpQ8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzzQEve3Jyd0Ixmk2DQF4FJQc\nc/MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdk2IG/2WPR0ygjTIkFYu9pFr9ILemWMg5lLfOrG8xdUCIQCsvxdLBx2X\nyNKBSwiDwXhfxTep9dsgThAgPEgYdugl/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbdVXWaot+MH1HIHDa/HkOnMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk2Y2NlYWUtMTgwMy00Y2I4LTliNzAtOTA3Mjk3NzhlNjFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZjZmMGQ4\nMS03ZjQ0LTRlN2UtYmJmNS0zMWU4YjFjYTY5NjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASr4OpC2nRAJPpU7TiDH3deTB6t4RYP5viUbNSs869dhPiTLnHUnIhQ\nQxa9r+89t6YmHSGwjS8mL4bZ8t6coLGco3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFPASU\n+aDO31/xRE2uF7eAlWHpvjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAyauDwrZcq5opqv34oYMq7INPa2d60UNx/Xr0\nbUbXsTsCIGCwr6KM+ca4Q0AuwFlg+KxjLoO6zT2sVePvsshZmmyz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1917", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1917` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAX1AKZAzssKSyy4kQndH5c1pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3Y2VjZDg2LTViMDYtNDQ0ZS1hMDFkLWE2ZmVhMDliYmM2ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y4NTgzY2QtZTk4\nMi00ZTUzLWI3YmUtZjcxNmVlYWIzODJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIS0vpPzcBYJIzOQ6y2lYyOFOd3NsWnXecpL/TD/1k+q6qjhdNta8CsQ45tF/\nMIltY4tln2mUELCgwpnaxg0MOaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+BcverIV/2oI9NCxMnEfQI1sQWYwHwYDVR0j\nBBgwFoAUtgMwJ7O4hHbsywmx4dC3/7k6PzswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDUPBLd6MI/cyAL4fSNxfV+CGsEBUTfcs3+lsu4dqQBeAiEA3UD8AYmPOyr+\nU3EMZowTevbJo5Avw1z8XEnT+/I8xO0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXLuDnycJVWBq1YUOvEz/67cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2NlY2Q4Ni01YjA2LTQ0NGUtYTAxZC1hNmZlYTA5YmJjNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe3TG3zuFKAsUHiebrM4I/7/DbWS0vxJPM1bSlHUR8f36c\nwR1IHZ5v4ezV+hfoPrAciFcX6vKJs7QTWEeQAeMRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtgMwJ7O4hHbsywmx4dC3/7k6\nPzswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKYtqyHh7ATCpjG5kZRi2rGieNUG2Sa1IaUHhdc4zBiLAiAzYaG7DuWN\nyy9zCglnh5pytR5V/hfrcHb4D+dCGs6wBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAd4M6DUw5CJJAluHxOzYDpEJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y4NTgzY2QtZTk4Mi00ZTUzLWI3YmUtZjcxNmVlYWIzODJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ZDZjMGQz\nOC1kN2I2LTQxNTMtODk2YS0wYTYwNDQ3NWVhNmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATZe7BR8eNC+qsOpjkPDQR6bCO9AE/VKIQdYV+g8tr9xOSFtBO2/k3J\nTFoxKDgdK4fmPCo9eZzOxGkbsZ73RMVoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4Fy96\nshX/agj00LEycR9AjWxBZjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAPWv2b9VjNdHC7bveUE7NLL7WK7gRAuzpQfAdA\nG3/FWAIhAPYWVCh6MV/WHHbA+8owljT6vZSt6UzsUTFx59zwKsav\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1918", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1918` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAcKtBm4qdcSz7Ay1vVa4xi0kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlZDk3YjRkLTNkMjUtNDI5YS05Mzc2LTQzZThiNDFjZmY0NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY4ZWY0ZWMtYmY5\nMS00ZWY2LWIxMzYtYmVlNGM1NzAxYzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERO/4/v8IYVVmYlMtYQkPbh9ZJNB0D/CbwABa0AM8tyyZL4rI6DqJWq/Ked/Z\n8mgJ9Z6ktwpd216CheN5ME6LLqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7n1mSk17DhuiS5WgxIYWfxeh4u8wHwYDVR0j\nBBgwFoAU63vdo2EJ6IN3I2Hfh54T1f3CpqgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiB2aP7CcCFBGR8+48nMtqHdKFc1jv/xvSiQdaxDuJt4JAIhAMpAKchSQdzj\nl7pgFz/Bfi40/isqJ02Z81Kkw6CWxFTq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaadGmAKIXDZtPYFs+r/uLUtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWQ5N2I0ZC0zZDI1LTQyOWEtOTM3Ni00M2U4YjQxY2ZmNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT87uVcAkPQP17yMdH8n/7QYENR9+oL7xMJAqcI0l5IgeMm\nCO++4H65vRO3AXgo9Cx1aqnJPa1LMpVR63b4LMoRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU63vdo2EJ6IN3I2Hfh54T1f3C\npqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY82yh3DZt2Ex8PnIq0JLPUarmIVhxCjfxFayA7fpvNACIQCtcZ+ji7Ir\nzcMW2YZBlpxhqLi3Il+cL030Xtne4euWRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAX9e/YtzCIxOPBX0h3OPR5sPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY4ZWY0ZWMtYmY5MS00ZWY2LWIxMzYtYmVlNGM1NzAxYzE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMTJlZDE4\nOC0zZWExLTRjODktYjE1OS0yMDI0Njg2Y2RiOTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASxVFROu+5qZsFwJHQES/3y/3ErtPDE9PvgiD7fIbVNu647RLWmwRdp\nofvOvHbLiRkYJz/V4aESuVYV1pA7xF5Fo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTufWZK\nTXsOG6JLlaDEhhZ/F6Hi7zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAgsno5P3yUFb7fFYYFGajGWz3uOLMaDEjovQj\ndbBfq+YCIDg0ondDOnO5BY9yPLGcpxAqz2Dob4MZCfLbUCknJiki\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1919", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1919` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAc0sKj5rGO8ZcerSqgJ8ezOuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MzgyMmYzLTkwZDgtNDk2NS05NjYxLTg3ZmE4OWQ4MzJlNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUyNmFjOWUtN2Fi\nMS00ZGQ2LTg2NDgtNTYyMDY0ZjBiOWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7AENgtBkmG57AlzaKcyMjD66SNr+YVivFGMBsgSxqv3pDUfJgYpoK2xxDbDu\nLSPVhyYFxX6AEOgSxTQCPytdS6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtuEwQfRAwSK/UKgHfZihNxtiBswwHwYDVR0j\nBBgwFoAUKyCY9HdG7x/UwFfSQ1pUQg6eTB8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAqaMb6wK6lNylnO4LnYAQD/HhRcDhe8hMqTo/B8uqC\nDwIgcabyaG8bslIZ6VA9JaC6t5m0bDeCm777coPko0rcrFk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVPXTo/6tihKIdJnh02GlR3sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzM4MjJmMy05MGQ4LTQ5NjUtOTY2MS04N2ZhODlkODMyZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSnTOVyobVoP4Wk+vLg9lMYsC+ToydrkOh2AwQ5oQwfWXD\nk1Bv8BYN8RdvYvSKmNXQuNuijNdcb/3hyGdV92beo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKyCY9HdG7x/UwFfSQ1pUQg6e\nTB8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJtZgU6ayNZa27EM+BYLHTPBFljHjv/OE9ulNdNpEOt9AiEAs1Rhqcj3\n+Yilqx6gUfU0cHAiYAmWsNtOLmt35GMHzn0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAS8pBdMI0DVICHNU+gGTlquGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUyNmFjOWUtN2FiMS00ZGQ2LTg2NDgtNTYyMDY0ZjBiOWFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNTlhNDgz\nNi1hMGY0LTRkYjAtODdmZi05M2MwY2YwOTFhMmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQJTeT+fGjaBhFGgvoZgMg0tnnpK4CQj4B1qSMUzYSG5yt+9Cmchoxi\nSZz8gG4ieY8XAG1CNVC6AywlXOfhgavwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS24TBB\n9EDBIr9QqAd9mKE3G2IGzDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAnH7nTW6x7jFhK3aWJvOZgIZKFgnNOlgD2F0T\nneIdE84CICH9O/pVZTa+WoytJsf5bH7D2WbBJlwLBWIs3FxUryZu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1920", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1920` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVv9BEH3fStSFYnMocBrwYOGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4ZmEyOGY1LTViYzEtNGU2Yi05YTJjLTcyOTU2MDg1NDNhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc3NmMyYjktNGVi\nMi00NjcyLTljMWYtYTRiMGVhM2UyNjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDGLIYbK/gYEIC15eTSIJsVglNJFwpmgU27gQh3UpqCeF+Shk4/VUcl25DGmL\nE7iy0Fn79w0Z5A5VYqm8U6IFRqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMy9/7kw9gEJCIpKYEnlQ2s0ONDIwHwYDVR0j\nBBgwFoAUPzs8dZkROyLn+mmvjxVqe7Q6dDQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA5gsYWM5lS25XFtt+gDbs1jGJxKtEX6YXzX0uv5WK\nOqkCIFsKtVKIg0OaXwoWctFw/gDxFImUF8AZqwTsmXbpmUIH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXBJC+ZM/YVCzI8SGMKU3D/fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGZhMjhmNS01YmMxLTRlNmItOWEyYy03Mjk1NjA4NTQzYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpRwcX8e5Fk4casrskLJoAVK/aUVGklokLxa/+G9GFexQC\nDPblBDiMEViF2cSdOUn5ipWxRR/v16M0841oyiXuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPzs8dZkROyLn+mmvjxVqe7Q6\ndDQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJwfuqoP+tfaZTDBIxDcIUWfF4oxfywN5J78dr0BcTz/AiEA5cdI/2bW\nvYWsp/hW440BeAEIHA+NkWkpm3jAumw1wU8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAWMAmL96ByHL2nhx2Zrtp1gFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc3NmMyYjktNGViMi00NjcyLTljMWYtYTRiMGVhM2UyNjY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmM2VkNmVj\nNS03ZDE1LTQ3ODYtYjE5MS0xYjIzYmQ0ZDYzNTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARJwl2HUcJQ7ahtkSQdv/pZuUDykjsCFg8V7WfxliDzZb4BJgsmZ6Pn\nhmJiRthVQIRhMzbX/g8szoSDVQQiTb0Lo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzL3/u\nTD2AQkIikpgSeVDazQ40MjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA70zH9sdQw8EiLL3e07Hu8hK05cdK0elPzzL/\nvNFZm/4CIQD7w3RWSPsJVWxluWv1iGYmkf5U0LoN1GQLNM6WB/VByQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1921", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1921` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAaWuAGlqg5w3fBSnG5ps6XI6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NGYzMWFlLWNlYjgtNDJhYy04ZGUwLWVhN2VkYjMwMWE2ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JhZGFlMjEtODE1\nNS00YjIzLWE2YWQtZmQxMzFjNzAwNDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElMP5YZ2Q395kviLjKyop+TOUx6arQq1mT4nOrBfDC08QSq7/S0de0cefL1VI\na5BYYcY7u7vvFerNLaxwYT2QQ6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoOVLFqrjJ6COFhkccoU/O6X4AIQwHwYDVR0j\nBBgwFoAUt6ITpeZKlLKVUPOXhj4+U55VHZkwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAuXzTaFN7NPITg1S6UqOc9VlNHobrSTt3A90Kl1vA6Z8CIQDx\noYuqsMHp54UKz18jmhAovfEqa+teZ7c7Pmj033tC2g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT2RQ55iOBpQCW7W5Q5gz0LFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTRmMzFhZS1jZWI4LTQyYWMtOGRlMC1lYTdlZGIzMDFhNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQbbAPAzqGOSl6xdc0JdVT4KJS6SDSY456oA869Sh32RzX\nLWVtHY7Ko6d++zQHxHzty5cLxdR8LpQd7nbvoamRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt6ITpeZKlLKVUPOXhj4+U55V\nHZkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWlQjMIdv9oSuxY819ZMvX91TMXNjPNXUVNhgi+FDJBQCIQDZHSd5hhDc\nboBuzgkPcZy9bi3l+grdWyVueDaY+1Ry/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVLDhnRC78+w3NGbsDMEmcptMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JhZGFlMjEtODE1NS00YjIzLWE2YWQtZmQxMzFjNzAwNDZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MzVhMzY5\nZi05MmQzLTRlOGUtYjMzNy04YmM4OTM0MDNmZjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT5N6pHBdsy0DF4bme/bavAJQiKnX48++Vg1udsssV+1GOJP+mfo63W\n8O15EW7CetpWx38D5IcqRZO23W3XvbjJo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSg5UsW\nquMnoI4WGRxyhT87pfgAhDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiA/JIa+GdFn3zx/7qAbu2eb5JwkrBLFwhns0YDh\nXxdbCAIhALNNsfEwq6t960g/aFkik3M/dHxk39lX7wbgOpoRTDRq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1922", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1922` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAfvx1/3uSPa7lbWYGu6i4kxNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2ZGQ5OWFhLWMzOTktNDJkMy1iZThlLWUzOTIzNDIwMDExNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI1YWU4OGQtZTE5\nYi00NmI0LTg3OWQtM2ViZDIwNThiYmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIJBHLUN8Zbp3Rt1HyFaovkSJsTa0TISfounMIAIkTjiiHLDPoAnz96bRLvHS\n4q5cJyTsXi3mppTYr17qOR8YRaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1mEjpxO0GbmN3Oo4A3xeKJZrX8cwHwYDVR0j\nBBgwFoAUPTkMsrmyJfW5Y2dKjdRhhRsOVd0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBMcG+TLMDUk+4pOWhhfIM0fpNu+NrOVh03\nnIyaBZ+j/QIgFoc0YpmDGBtWNoiYa03z7eGC/wqu0RN+yja/OTaaRNg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbcCSVubmcPhinXa8DuSxG2/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmRkOTlhYS1jMzk5LTQyZDMtYmU4ZS1lMzkyMzQyMDAxMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThYWzZey/efx/pqjEGQ5VBK20r4LsPCIY4ycgUU4dMGQq+\n/dpM5UhjAgThNp3G1ab8wRBlN+jjMhZRtIGlf71/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPTkMsrmyJfW5Y2dKjdRhhRsO\nVd0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCK2PA6CgAnN+KYiiy9uRGxTEDhPb+XJPHvO1NRLNN4ACIQDZYXEH0J9c\nVdOBif29NSBVuieZf45xv7Q8O4lVE95h3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAaBET5ROzR9FZTNoMr1JfgDJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI1YWU4OGQtZTE5Yi00NmI0LTg3OWQtM2ViZDIwNThiYmZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZGNhNjli\nZS1lNjA4LTRmNTUtODFlMC0wMTdhMjRiY2E1NDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAROIM7ujtaJtODOpsO7Ghh+oNY7PpQrTwgxdfEapHGLRJ1PgU16Q3tD\nXeJHMO+8iDN9OhlgtdkzywfgrCgYjSx/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWYSOn\nE7QZuY3c6jgDfF4olmtfxzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAgXvr9MmUC63+q02l449f0DSMvBCEsbvH8vOq\nsGPgXAkCIQC4uvTUx/z+odcu2rdAHZSvAjz3AzfEgrxIxWPwt2sL9A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1923", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1923` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAURLgoBYFVvX41NoCZU44sg8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZGNkMjc1LWE1YTMtNDUyMy1iYTQwLTc3NTllZThkYjZiMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFhODdiNjctNzI1\nZC00MTBkLWJjOTUtNTlhY2IwNjEzYzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+wfL7j9B1eRRsT3nU2Lm5YNalA3ZMUdmCm+cRCUthkPU/5OVdB5RvSL2pYpB\n0OFq9y5n6Njh2aQvjr+oymSozKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeuiLpSjEXr9QfB+WO/VOmck2fZMwHwYDVR0j\nBBgwFoAUIhOoCNUmlA9O5LYADwABsleDoLwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiB8qzprZv+Q+glk8yejLaoKUKRLOimidUP8\nc/r8gh8LZQIhALTuCukldH2QrHg2Nmmy0hH/GDLhGq4BT/QB8AwrcdwF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYahlVwZal1e75tK4aUgw0DhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWRjZDI3NS1hNWEzLTQ1MjMtYmE0MC03NzU5ZWU4ZGI2YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQ3pvTBTg/BfqRica4kc4fLz5VqcvYqpPK/EVApZ7S/dVO\nbYPBeyfzvAz3JZJE8BrphvXTJTU7n8KWxtsfwTbco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIhOoCNUmlA9O5LYADwABsleD\noLwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYIOGDg4iTSSxw++xulXBX9vxxQl5qfsCQjeu2gffa58CICrSak5RmT0j\nb/gs0/3Dc+rmP4uljRfiDH7xWUnL7M4N\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAQeACUfhQCKPmf0hy4i96udiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFhODdiNjctNzI1ZC00MTBkLWJjOTUtNTlhY2IwNjEzYzA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNGMzZGM5\nZi04Nzg2LTQ2N2MtYmFiZC1mOGU5ODgxODVkNzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQF0t1ayUTjVeBYSOTD4Qzy2q7KWv1pDtG+hbSkRZzvD63x4+i+op4+\n4In7lph1rEPSZF2Dern+MDia/JLcm8MXo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR66Iul\nKMRev1B8H5Y79U6ZyTZ9kzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA/N672dmK81ZFRa9ZoqyXn/kyV4FRZSY9g3Qs\njRu+wU8CIQCC4w6u8XTWNorhxhVjsxBi7EoQsxihBDtNHN6+wfglnQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1924", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1924` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVKuOQjE4IIADgERMiIkCCLVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhYzA3OGY2LWJjOTMtNGUzMi05YTI2LTA0NjkxNzQyN2E3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJjNjE0YjUtMWRm\nMS00MGJhLWFkZDktY2FmMzFlNDRkMDE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBTNT+mDhYut4UKR4Ju4rle973n9+eCIXjACOVUX0Aevw64FDRDNiNIg9Tekw\nibLoLi6a+RoJ9eC2xGXE77uYraOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8f9OVf1/T8AwO2DzRiE1y29Xsv4wHwYDVR0j\nBBgwFoAUeKvAP+30lY4obIyUVjAnIxAM5WcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCPvCRiX6PFm+spEsWRC9hbTvdW\nRXaBYmsMl+p6ZBfwXgIgW2Z57MnmcgVoOXauGObaIuLyQlds8IU+yYlb7VH3K6Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaBcywgEWi/TynT7YGzpl784MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWMwNzhmNi1iYzkzLTRlMzItOWEyNi0wNDY5MTc0MjdhNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROVS/c52h7KH1hldPLcTEEZHzHe9XCyGismZguT5NFvDRV\nUpRu0ndhL/QN5MERmSGm3tJsLc5pQlWVpiyf+u46o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeKvAP+30lY4obIyUVjAnIxAM\n5WcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ9PJqVNfNFU7yl2DLjnt59iwuVbCkX7vMGJDoXdP3LBAiEA/pM4BnLt\no2+YlMtHM/irbYQnFifE55nbdImae6Rigx8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbcZaZ1NiYRVA245kyKgMPt2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJjNjE0YjUtMWRmMS00MGJhLWFkZDktY2FmMzFlNDRkMDE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZjc5MTcx\nMy1jZWIwLTQwYWYtOTE1Ny0yYTA3YmI3MWYxYjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATdR2iHwG+lojC2FFzq8gDIpQS703RvmMnWkHWZP3BBcx/QspHq7u2s\nI/oHoLYBqSxEzwwA2V71CPncwuk0D+w4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTx/05V\n/X9PwDA7YPNGITXLb1ey/jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAgJCc1ICr3mg6h7Vna3AkIkE+XDSHI7k452IIr\nsO+pHgIhAJ0xrLPOo8Tvo/446/Mb6/Vtcvq6JDfaSPlGd7Fujhna\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1925", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1925` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISASAIyKfFE4Qzbpp9k90IVdX5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2N2MxNDRlLTZkYTctNGE1NC05NDhhLWQ4NzQ3Y2JmMTViZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWNmNGYyMDctYmE0\nMi00MTVhLTgyMjktZDViZTc0NzQ1ODUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl03fKUkL/2Tb1mZ29AMBiJjOcyerAisYfqVha1tr9dVHzXEwiGz1l23DpmRR\nuy2eWGYUpZwdSB0glkaPrOl9sqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN1g8L8Bf25BTTdF+xka2CM1+fI8wHwYDVR0j\nBBgwFoAUyUkCV7mjV4VeG+GlTn9B3xZL8SUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgaASYZYEB\nj94QsJtvcmqHCbXcB0+1bt93aWoXDlNUXDwCIBYID3g1deh0RI5TIfJ/iY36uyhj\nKsoZ/XyaU6pkENQc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASx2uPI+u4j2+pRUA+HO8/PvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjdjMTQ0ZS02ZGE3LTRhNTQtOTQ4YS1kODc0N2NiZjE1YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOwHEe9SXCNGbKYsRgE1EIuvEAx4h0oOWHlwXwa04J1Rhq\ngQax84/ShZ1djp6arcenm0xoDxhMi7uxAppPGoBTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyUkCV7mjV4VeG+GlTn9B3xZL\n8SUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcRHMMfAWIBeurOmZC0vUdLc0OQd9RipktlXf48xWqHgCIQDcFsQe0ABd\nZwHjvGCYm50kzC2XwIbFfIweGqOBqgczkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAV8YeCAFmwB6YfOshLguCkFyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWNmNGYyMDctYmE0Mi00MTVhLTgyMjktZDViZTc0NzQ1ODUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MjcwMTAw\nNi04M2ZhLTQ3M2YtOWU2Ni02ZWQ0M2RiODIxMDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATTQxX5sdk67sUmN/T5ucL6xdmTECbUI6N1sJY3rqK6L2dumDF4zuc3\nJnzJjkw+j1hq+qzuCM97CnaZAorJlr5ko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3WDwv\nwF/bkFNN0X7GRrYIzX58jzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAilfN3SKHqFYqs9cYqXazqQmxDNickaBpVF/a\ne46APTECIQCDkwvfIVjsFjyolw/Wp3h2DEJoz+oUOQ70D6oH3RbWyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1926", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1926` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAZXaTqdpyrMMvIVZYqTAtQoYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4NjI3YzE3LWEyODctNGFlNS1iZjQ3LTc3MzAyYWY2YjQ0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ5MDFiM2ItYjNj\nNy00NmM0LWFlODctMzQ4YjdiMzQxZjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV/E1Y3Er+5a+1qlFFLOl0Hi9+zXumqz2jOMv42sVpTIekbpbTjDjZKMsgp3o\n+x4UWjgCbkPrvMEAyEYcglCCXaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNdit0v4E3H2qgAYIxIK8NTuLfY8wHwYDVR0j\nBBgwFoAUhQVzicfvkPMPMkvV2IfyU8jBRbkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgWezFeKqs\n7QDAAOP2fzZftlrTpod6NvuftRLYgQC12yMCIBP0b4AWWAJFKG/T210pCMWJHf5h\n3RdJuPX+xKlJ8aXs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQJKnOvSqj5wSmI6q/wIUP2HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODYyN2MxNy1hMjg3LTRhZTUtYmY0Ny03NzMwMmFmNmI0NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZDWHSCOeaGUIh+WeYNDaNE3OWFllHIV4m7kuX2zkqdf+F\njsQNcun0x6jbbzFKs+ahPxsE9laRz6HCYZYPI10mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhQVzicfvkPMPMkvV2IfyU8jB\nRbkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANMMQV/0fiaWC0nDo8bu3nzTP9DSRTRtfM8GPYc4e0d+AiAGFnWfNUVD\nwIZ33Y2DgngxQtL8s4rIZobM9QWoxv1kqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdmgAwIBAgISAeuQqjVdi32pf0JX+SlYmtaSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ5MDFiM2ItYjNjNy00NmM0LWFlODctMzQ4YjdiMzQxZjUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiOWVkODY0\nYy1kYjBkLTQ4ZTAtODdmYy1hYTFlM2VmYTRiOTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASgow2tFlo9SXmnwAPrUBqbQn7Z20Pagkd0DXh2NHyisE2Fx1hM/oOo\nVfwWI2jl0fU7bzs/W0RJqNHl1zC6cLvwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ12K3S\n/gTcfaqABgjEgrw1O4t9jzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNGADBDAiA8mCc2JMTE9of4ebxUqOANsvyBCkx1fGfnkJWE\nbRGVPAIfFCihdN2qa8m/An1Ect7lUKBdQr28/Ff+4Zr6f0RR0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1927", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1927` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAbgO43ygA6kvP14cfYcI0mBjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0YjA2NzgwLTg0YjItNDU1ZC05YTViLTE0OGQyNWI3MTZmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjRkZjJlMjMtM2E1\nNC00NzA1LTlkZjktYjMzMTMwZWViMWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZIyh2XPeVuqtcbau52VWV4QN2GdidLAR53hsnmOEDjbLPCRhG8zGuDPXE8sR\nIPGX+K8R9fSzVes6jnAHsLKN1KOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAbke1GgeIe2tyxrxKWPuXFVBTn8wHwYDVR0j\nBBgwFoAUPdXPFEsIteUU/rf9VBmK2rZitRswLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAEG4nBX\n6oo7fWn1gpfr/DlLJW564P5aGwbPuHwxI1DUAiBNOlOP+tUr8S9ZuuFHvTaRpLvn\n3a2pefFdbAz1RnMXFw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAao+O+rV3JcP++KQub3SjC/JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGIwNjc4MC04NGIyLTQ1NWQtOWE1Yi0xNDhkMjViNzE2ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuViPsZ2UcvS6OqkWmQbmnc4nkFAufhG8vJAlHwZ4y6bMO\nAZ50mhKTr6VGrN7i+pLH4Yp0SkNI/iMPY56CwEKYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPdXPFEsIteUU/rf9VBmK2rZi\ntRswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeuxIlI896IsS7BHuiu6q1nFwljpxEO8LYQOf7TFjv9UCIQDKckbT4eft\nUq26TH40+lqQAdDFhOvJOT++FDSinnU3GA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAccbukoGkDvgQxFen7R3qNrKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjRkZjJlMjMtM2E1NC00NzA1LTlkZjktYjMzMTMwZWViMWM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZTg0YThh\nNS04NGY2LTQyMTQtODY1NS1jNDNiNmU2ZTllM2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR/fDxfsBEWo+wUz2UsVPoQ6ZIs6xB48aCQh+m7k35IqH//GsdpCcRt\nT0FSNy1vBjhvQ/Aq/WFRI11QK08t/+BOo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQBuR7U\naB4h7a3LGvEpY+5cVUFOfzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiA3x/3I5u9kTbSd37Q6cJae1Lb5roVuu9eSLCx1\nQ+rUYAIgeI9GdW3VmJ9TjRZFQMuFstbEy4y1UZ5c8eaYaI+yqZQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1928", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1928` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAVoh6oeQhlPAZZ4Xg+WPytinMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkZjRhNjQyLTQ2MmUtNDhmZS1iYWQ5LWVlNjlkZGEyODYxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2VhNmY3MTgtMmQ0\nYy00NDRlLTgzYzEtMDViYzU3NGUwMzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETtOLcRAp019m2UbEeBhW/Zkhr0CCNFAaA20jQpF/k+nqHaIIRGB0+Z5edcci\nQiaI5SBn2mv2AJCEWx87cE/fIaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdDIuHn0tbc4GvcS/7H8YnheekeMwHwYDVR0j\nBBgwFoAUbcnINGK37b5hTC5E29hggXs9zjcwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIDzkTG0stly/PAWGn+UJIzCRKTEBvgvww7FCljrwhKznAiAZWtrmXP+g\nDuv2hUs7PeTZydft4qQn51mFNaYjAejI6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ7rS0JI3+lEC6B2Fh7gFPE1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGY0YTY0Mi00NjJlLTQ4ZmUtYmFkOS1lZTY5ZGRhMjg2MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQv8VUEH5VdyUldXUlfUrYP9lZlzeM2ba2OtJkTwdp9uQM9\nDePKBj1KE5+yaag8wyQH2/tlnJENwbaUYfnc3Wako2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbcnINGK37b5hTC5E29hggXs9\nzjcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPHAXn8TvjWETwwVhm71baWhap9WTriC9leLux95QCGPAiEAudESy2Oq\nnj5PrANTyGkJOZFP3PbZwGB1iPvBXIWcgMc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAb8hwHOpiGaVt31nQhLMmt0sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2VhNmY3MTgtMmQ0Yy00NDRlLTgzYzEtMDViYzU3NGUwMzRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NjkwZmFj\nMS1iOGE5LTQ4ZDMtOGJlNi04ZGMxZTJlZDdkNmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ6Ps4NkqXV/eSrBKIdmuSWmMhHUUYoxK7/ILv+15BVNWrG4mkKgOxO\nkpIIoRtHKZmEQPbXqyDBqijdeGVu6dLbo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0Mi4e\nfS1tzga9xL/sfxieF56R4zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAq6wH2dL1zNSZcglM+KAIOWYOU8EH4TTaCxf9\nhbaLDT8CIF2R2YpbHk9mfJSlx8mn1YhFRGFh/RPv0cFSLjOc79/k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1929", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1929` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAWd5oTEM1qGRH0eub66X7OTCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxMmNkY2ExLTc0ODItNDgxNC1hNGZhLTA0MjJmODNiZGZkOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTAxNTA4MmQtNjFk\nZS00NjNjLWI2ZjQtZWVmY2FjZTNjZDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8SCvPEUSvSUGx1bVPZDIgb4xOi3wKopVmQZUIs3acV9g9xRvh8Pg9T8O9cM/\nFyirurPjPvxZVX4fOJ5miMPPRKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcUrUwGIA0NTbqQ4TAPOnYzKToc0wHwYDVR0j\nBBgwFoAUo3AWUOE2Bqdut8ENNyJ3xUV+yVMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDkDWV+jOWWM9iDjY1OoFbFXDR8JUAYR7KXlVwj3XbGGQIgQEYBDlpn\ndlAjogbQMI/m4bIWjO8K+gewq0+zElc7TnY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARkyqqhjHlg6rkAuHvBUOmZtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTJjZGNhMS03NDgyLTQ4MTQtYTRmYS0wNDIyZjgzYmRmZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmgeuLKzkgGUtrCmio28pIF+KxWsfJdTkcPnFoNljVzEes\nX95aD4JqKWryN0Klj/OqRXnd+1uYOzV3UnAITJguo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo3AWUOE2Bqdut8ENNyJ3xUV+\nyVMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJpyatwSL5n1EAX22U2gZ2v0STsczgcOrYTkTeouXtahAiEAnaz/f5+o\nZv47fIRFaUhtGeJgwNttx9KPjEZ2kQ7D+GA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbGoTSZgrwFSsQ6+ztZfAM5rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTAxNTA4MmQtNjFkZS00NjNjLWI2ZjQtZWVmY2FjZTNjZDBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMDY2NDJj\nZS01YzAyLTRlM2UtYWZiOS1kMTkzYWQyMjYzOTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASO9MRUf0IzkKKMvTpJzC42RMpHfhnP/fXJ9eKG6DuLU/43t9ab8jOw\nn0fhPQZoGg0GveqaGqSKSSlWZSl6sJiHo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxStTA\nYgDQ1NupDhMA86djMpOhzTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA0Awtb1W1rv2FIUzHMxGI0tcpOm8pyQVFKHRE\n26wW90cCIBTMYK2Llql5HRXhroa5Gi6cTNF5Vse665FysQYRP8nt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1930", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1930` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAXrVa3nZYqQh0HxmJcDDSF08MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwM2FjYzhlLTc4OGMtNDAzMC1hYTNkLWY3MDNiMjUxYjJlNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGEzNGViYzktNzZi\nOC00MGEzLWFiODEtYWE5Y2M2MmM1Mzk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYmHckY0pkcNiV45SmxRFD2gY4BxUcxuwBSGBhwN0I5UAZi62TYB9Pbmd67EW\nCZZOr2c+zMXVr6FS+DbyYDuXAKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgFydU+SgGQ7bkzERwC8yTFvoN9MwHwYDVR0j\nBBgwFoAUYePk8ToNbmewFwVFjvQemmm2pZgwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQDBMGst4HVeFl8UrkVpgwoj0a+iUh1YXlaQkCiyjPoWOQIhAJ8Hob8x1tDHUT+C\n0HQI9PvI3F1/p9NKfNQDPSoP+YGW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQu+sBNCwdF1H3IXcv4VRbaqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDNhY2M4ZS03ODhjLTQwMzAtYWEzZC1mNzAzYjI1MWIyZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxnuSC6PKqzR6MmPfVzrtdxTvonI+0jX++139R+AGUrxXb\nJgtOqvv3hYHXqi+LnoPpwNA5yj+SLMoNIkMxgYi+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYePk8ToNbmewFwVFjvQemmm2\npZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgd1x4alhazY2KyMamV87hcJqEOf38ALkDfOEPG7CsSp8CIQDewHH4a8jE\nPI3neD2TlvVWuZ/LnyD6JELT6IWnvfp+Bw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAV+gUtA/cW0695RdVL31cAT1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGEzNGViYzktNzZiOC00MGEzLWFiODEtYWE5Y2M2MmM1Mzk1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMDkxZGI1\nMi1jYTM2LTRhNDgtYjI3OC0zNWZmMTI4MmYwNjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT0h9X5O+Dql98PBgsi2/GqVt8tjofiNnjMX0hO81+vYGAcd64yf6gt\nn4AiRvjeNcb765D/gTuu0/yHjbkzA0H8o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSAXJ1T\n5KAZDtuTMRHALzJMW+g30zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAgkygR34cDipw5sXTUE8w3BjGPMw4duSUDN+Y\nUFyk2aACIAn0l7Ez0QYL8XooTg0tdWv9WMXq5LnsTlELwC15eL/Z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1931", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1931` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAdfPC8NppGlco46cGBJcU6eaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhZTAzMWFiLTI2YTAtNDVkZS1hNTFlLWMwNjk4NGViZWU2MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE4NzljZDUtZmYy\nYS00YThjLThmNzEtNWZjNjI0ZTJiNDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERLNmouGDSNeZ3JaQ/jBCZMguZzyO8FfjMaRYML2KMtfqZcTZ0+tjiX2OrX+d\nMYAEf54bwi8J7+SAIl1NLB+kwaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmYgYeMDX/JjoQZjsWRi5BieZq+8wHwYDVR0j\nBBgwFoAUj3TDRiXyP7DERXcyLk5r/yTNGY8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIAE61lsyp16DAjOBsGYC/mDbsDoVTjAB97krf3HX3eU0AiBh\n74qouwV/YhC0ZYzZcJhgYGYmuBaE18bY9Yj2V/6gpg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZiz3k/jaQvNQjt1xRoSqwNBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWUwMzFhYi0yNmEwLTQ1ZGUtYTUxZS1jMDY5ODRlYmVlNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThKTvTlesTCjYHV/4b/TWufaAJERCyZZbPU7inderCAvNA\nwgzB8UENrrgd8l9TOTYkUD1SkPKx9PAh/luv6t6no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj3TDRiXyP7DERXcyLk5r/yTN\nGY8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMaYsV/FJ0iJcgeQwTCyxHjhSG8jUlVQ6DnY+J/ZnVTGAiEAgqWSAtxC\n68CK1FH2DXfn8CJ9COoxw6RxleN4J1JVcg0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAeKPUGDsSftWXO/pF3JMPkz7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE4NzljZDUtZmYyYS00YThjLThmNzEtNWZjNjI0ZTJiNDY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNzVjMmNk\nNC1mNjBiLTRmZmYtYjViZS0yNzExY2UxNjFlOGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ4Gz9Agw+nPdrGCf7+ZQiCHx7rWCC08qiQMla3iQZobcmVVIPlnbQZ\nPdzCxpuDepehGcZXnDH1WwdjZTq/JnKNo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZiBh4\nwNf8mOhBmOxZGLkGJ5mr7zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAw93Eqq64FRyikx4lfvR/OkRTaWFay2VViu7i\nOefcZDYCIQC0pahsCio65BezcAL5gNOY7ibs3o4GnyQxJ9l30Pc8Fg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1932", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1932` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISARkzdqfws+MZu3IK1RyPBEjaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiZmZmMWVmLTJiOWUtNGU1Mi1hMDFkLTA4ZTViYjM3NDc1MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZmMGRjYTktNGM4\nNC00YmMyLWEyZTAtMmZhOTY5MTg4NDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqhm9aMijP3XdF6zOztU+LVwxnlGy3bLOZ4MhV96hnF2I928hSJxrI7lvWGSt\nnSIOJN3wzDzx9EczWxCNYG8X+qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbS4OPagMMq9j1ntl+FaXK9yRQBAwHwYDVR0j\nBBgwFoAUVaVtXb+VzKG5S1FY0N1bhb3t/dgwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQD/Pxb+bOVQW7vUo8nM7/PZZ6l6O9tU8l+8dhT+xDR6PAIh\nANYxopvhm/azlxPm8YD6upX8vDsmb9HopQWOQzk2Zgp/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQfFCfm5ZEUmE/nhUZmKsw32MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmZmZjFlZi0yYjllLTRlNTItYTAxZC0wOGU1YmIzNzQ3NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQocYtMKsQ4qFyui2XZraKJbbapt18iBsVjfCW8GK0YxhSv\nVMH1Z8dh60agX+MYlvg43vl4J0gvLXWEH9wlrR0Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVaVtXb+VzKG5S1FY0N1bhb3t\n/dgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV9lCZfcMx7wPj7P5OgWYtQ+yXYLVwupw5zbEsL5ygWsCICuEWqVoDrlt\nsOihHI7q4zJxfbTjJwZYfrXf5UTWsfSc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAS5DXink0QrK0pm7T2rfJTQlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZmMGRjYTktNGM4NC00YmMyLWEyZTAtMmZhOTY5MTg4NDNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1N2M2MjY4\nNi1mYjUxLTQzZTEtYWVkNC04OWMyMTcyYTI4YjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATCDvO5F8I3UiRaDURW3umc5e2JIysw9H6YJS/XxnpYWYl7aaRbF8Kv\nB2sc7892VUTb+p+xaAlZnXzFzp3NVEUko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRtLg49\nqAwyr2PWe2X4Vpcr3JFAEDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBTdkPJXJOpOS+ma7Vs4cBN6HZ+zVxGhmqW3M6O\nztteaQIgO4Q1GkVL8SeXNZ4ou9mbAPCcOAOFs8dEDYmAAwn7fnU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1933", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1933` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbO5DXY4NDi6DiUkukU1i+1ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNDQ4MzU1LTk1YTktNDYyZi04MmI4LWUwZGM2ZjE1MGFkNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNkMWYyOWItMzNj\nMy00NGViLThiMWUtMjgyNTAwYzYyYjBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFDj+kQh9EaT8dg2T6HA5mCu22SOL65HrphmcXfcclvmX2qsxfynbD+So+LYG\nt73iTToID7nLHoK3cfXtH7M6t6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUN/b/fB5vSnpT23P6o/T0r21mWowHwYDVR0j\nBBgwFoAUt04l0GebwXw1PLMYIJGg0bdshn8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDyxS0xJzGCH\nqK469JyqhmjfI6Se7H71xnnExhrF9sVlAiEA/bxaKF21IrPJc28SHOJ8FtiwVoUc\nkczQDK73CXfiTZ8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATSccLCmvJ0OEvtEkLO++HLkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTQ0ODM1NS05NWE5LTQ2MmYtODJiOC1lMGRjNmYxNTBhZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvqCeyfaVN4tcRpMMFB+pnMHqoCuZwkbpGviNoh1hXmSqX\nLQ2FVOlwPdFPTy0NVtmdUiBwdJ6VAc4CghcqiTSwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt04l0GebwXw1PLMYIJGg0bds\nhn8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVolVLZbwExxewbQ63XY/Je3yKd4jXEEgmP9mi58iEwICIQDgF8dLoi9B\nVhAha4uAO5uEA3EYLiVe7UpZLfTNinme6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISARpipGDQsTMamoNKZEABS4W7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNkMWYyOWItMzNjMy00NGViLThiMWUtMjgyNTAwYzYyYjBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNDc5Njhk\nZC03ZmY3LTRmMDQtYTNiNi1jZGMzOGFlNTMwMDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARIoGZ0FcOcX4Er/T7bTd5EjNrp5HAeTES4a6crar2GMeJzX1/tl+Ml\nXiBHu0b4ugI/+CBL2UU+3JnCT+Izpbcno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQ39v9\n8Hm9KelPbc/qj9PSvbWZajAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAXXJ0m0Sa/9RiH7lywEJwv7mMk+H6i1thAHKYp\nrexQLgIgB+akADlNGjcHkAWD8Q2q6eHaibjfZy+jJITyDXO9y1o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1934", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1934` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISATEJ55XcPLYzgDtJPL5/HFEmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2YzJjMDRiLWUzMDktNDBkMS1hZjAxLTUwY2FlZTNjMGMwZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2E0YzU2NDYtYzBm\nYy00YzE4LTg4MGYtNDc1YmZkMDhkYmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoRQHtue3pS487XkKmVaoRv8uFKcqP7JrkfYVtV/ruCdufz89HigRRbubqalD\ne8UbvICn62F/F2MgYdXZ06mhFqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2rwtTQot6FIJG6tJ8fX7by6DIq4wHwYDVR0j\nBBgwFoAUasRhL4FzbN3qV1Vgo2SwwejVvrQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAKRQpz8Kr3F7P2PoDZExVB8Rd+zZ1m6CYzZ1BWO8+GLCAiEAsFyeWMua\nJ6IKN7LMoDDFc2ipiojnAaRg6zX9l+m+7A4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQYFSyCuf86aJxSInaQ22I0cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNmMyYzA0Yi1lMzA5LTQwZDEtYWYwMS01MGNhZWUzYzBjMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMjDdy/DP3krzoDdnpmQck1sd3eg4mcF3qNu7ToRLDdU68\nDmmfKgKhPT2AL9zfWIEJt2bi6IlcCSAwJ/k3MSmlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUasRhL4FzbN3qV1Vgo2SwwejV\nvrQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPn6oL7BCOKoZIKhcY73UiSIOH+aQbtLIKl8FshUu2QQCID7FRTgIc7/Y\nreScfZFzsgbMbh8fFQRurqvjZFGY7mIL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaCvjYhkjLI/cR8UxekJbXu/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2E0YzU2NDYtYzBmYy00YzE4LTg4MGYtNDc1YmZkMDhkYmE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYWMxYzJj\nZi0yZDZmLTQ2NmYtODdjNi1mODZiOTIyYjU5MmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+1yInUk3lhkqRFDsbXst6d4xFVjro/Zta+qYN9G7HACgQQlyOmHT/\netQ9AReOoJtzRgP/ZNmRLpTNXH1q0T2jo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTavC1N\nCi3oUgkbq0nx9ftvLoMirjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAi0IPyC1TiHNTJP4JQjdJ7ZT+G5YmJbIqavy6\ndGhQv74CIBTUpcnDWSho3tYuYsRNx29bP+v5fY5zVPLH2yKwVQrs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1935", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1935` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAdxmlBLpTRbTukGC1uiarnfeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxMjcyMDI2LTA1NDYtNGJhZi05MDk3LTA4OTY5NzNhY2M4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQzYzY3MTQtNGJk\nYi00NDhmLWEyMTUtYjBiMDNmMTM1YWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVto2c7b6DTm+8Ash9ZJ+c1nRi9qAGc0aU7Pi4fhh+BFpzJ5uy6ykegM312NH\nOUJ5PHEdRECuL83F1v5ldzHSWqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUghyujY9OvffHrLqLbbXUso3P/c8wHwYDVR0j\nBBgwFoAULRWeHfmmdEvEtG2t/asjvAeqGxgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAIFINDUbqyVZSAkbxHksdS02edwUFCCxzyM5OFQ+eFHgAiB4nG3P2Eja\nuiFCk4CekymckDkw6lsTZ6RtATpFxxwj2g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUkUW3nVZk2j8GAXJWnGMBb7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTI3MjAyNi0wNTQ2LTRiYWYtOTA5Ny0wODk2OTczYWNjODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASs7I7OhZgbKBYtRbpezNXKC6lxH29huCpI8TJZrxbYoydC\ngWRtYP1HH0APhlFCjZctvtrG0L8DhW0EBEgB4OAMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULRWeHfmmdEvEtG2t/asjvAeq\nGxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXaDD7XaQyO9EvH1H3VP3KdxKDfYXZCblT+MeT/bJQa8CIQCI6QVGhNOY\nJgqIsdnQ9JLtM3F63wWTBLhXVPeHAdlxjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdVqVNDLjisxkFJXWI0U8HnzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQzYzY3MTQtNGJkYi00NDhmLWEyMTUtYjBiMDNmMTM1YWZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5YzlmMWZk\nMy0wNmQ4LTRiZjMtYjQ4OC0yMzFkM2E2NzExMjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARZXeKv/HXb8279sHkag0sNKn7VZC4/tmvW61wo3QlPYUBYVR6266ca\nwBJRKIbosq6TAC+fCpXHe2LBgOyrKIEQo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSCHK6N\nj06998esuotttdSyjc/9zzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiB4ymfk2RegcChj6toFw2CBtwhP7rLNo4yCONBS\nSDKB+QIhAKgeUGC5JoxjO4WbYtZJBIdT16iuqJU6mgNwFqnFyClf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1936", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1936` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISATMpsEAsOkwwnydWowXr1VWcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3YTYwMmI4LWUyZTgtNDk2NS1hMzkwLWM3OTYyNDdiM2M2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMzNWVlM2MtODFi\nZC00OWU4LWI1NzUtY2YyZDc5ZDNjNjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED6cm/734bxpylog0qqlARt07d/WWjb3GfPRcOjqbO2g39PsnzyJvvfWV308o\nziQ5C5jCPa35u8wzuCcwKrSQ+qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU63JXJYGRMNXRxSmp84agNhDgWDEwHwYDVR0j\nBBgwFoAU/5bbK1i8NtjVKTRo7VvMUmvOA+0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQD9BPjlMSNdzhFDL51BBnOE4/bikb5AFeBnKjDjqchTugIhAO+0WGHq\nqmvwft9N+JIaHUfGFz71L8dmiiqsy2eagc/+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVsy1SkBxJadVnU1gUyq1eHiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2E2MDJiOC1lMmU4LTQ5NjUtYTM5MC1jNzk2MjQ3YjNjNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTRTbblhas6U3LWsFPQHeGmCpP0+oBwqKvIK+5Si/8HQFX\nMVeJrhCylQu7gaeJ3R1nOb19hVLWVEjKftfazUygo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/5bbK1i8NtjVKTRo7VvMUmvO\nA+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKzxwb4lzXW+2PUHtFQc1WaX9DwJicNkGGqx3EcKFh0ZAiBJpFiyez6E\n3MzWqbO5uaDFXNRRMighV2JhXqBQ2301mQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAcphHB9lWquekYbnu+sWqRUFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMzNWVlM2MtODFiZC00OWU4LWI1NzUtY2YyZDc5ZDNjNjQyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZmIyNjZk\nYy01NWI5LTQ0OTMtYmYwYS0zZWYxMWFlOTM0NTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS9NbyuF6XSdZazd56E9NfHq3tWcwcY6fYri7Zgldsl4W3EhND2WNRI\nAmSD/Fvj2PvcBngl6gTQeZj3QxSOuSwjo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTrclcl\ngZEw1dHFKanzhqA2EOBYMTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBtX3kXklZzCxBeRwy1LmLp8wvaSYVat1z+OY+R\nhekblAIgZ0Id6sMxdd9SoSupGjOy9KLeVVa9haGKTyI2OismiaE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1937", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1937` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAb0qY/ux5dpWuaBQbU7hAKtwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlNDAxYWVjLWM5YWEtNGRkNy05ODNjLTBiMWE2MGNhYzVhMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMwYTk3NDAtYTRi\nYS00MzNlLWI1NTItYTFmZGNhNDIxZTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcHDnRjIJugo6UXvOwq6KhWanOyNP9AX61zKk8agiG0wkDdfLRr68aAcoyI4s\nJ6QknZlx2jfqPH7deV+rv1EREKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWvNXtW1T5uzEJ/T3TYgqrbquFSYwHwYDVR0j\nBBgwFoAUsyiBkqwK5ZW88ndBhR7wHPfQMCUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCICaOnnu9IOXvtlNphjbWbCpTl2DPMhLk9zRXzLbO\nu4RaAiEAqhA4w0B7UbrMe/gnaiJvuLsAmvUTLSko+KwYBI5ZA2Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVglEjWg73ilJ27hAKkhTwh7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTQwMWFlYy1jOWFhLTRkZDctOTgzYy0wYjFhNjBjYWM1YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfa4VgUmHniPa8bfQZBJmIQErmSgKicRtwEG+BrGffQgtp\n10y199CP6J8do6zHcXZdNeqX5S0DRabKZrwVp+u0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsyiBkqwK5ZW88ndBhR7wHPfQ\nMCUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBE4B0tJHIiCt0gQ/z9fr2cKKyGYbtH7oO6O2GKyiSb4CIDuk3E1ut5uo\nTiwQU5LV3hwntZ+Hn4AmkR8YmHt1Mbfo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAal5qoqRj5Xv1xmjpmqk9CKbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMwYTk3NDAtYTRiYS00MzNlLWI1NTItYTFmZGNhNDIxZTgyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkOWYxZjg4\nNi1lYWQ3LTQ2OGYtYWE3Yi0wMzU5YzNmNGQzMjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQxSpjWIEVqv0Vr/vHzffce4AJk4ZAKdN+4gTWJ7XFqQYM2GqFksuKu\nZRHxPixSN4cW9IMP4vH+o7oXJYEwuk0ko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRa81e1\nbVPm7MQn9PdNiCqtuq4VJjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBNUNdF4yewxk07kd+M9R4UXB+n95fJDgKCzfgy\nkUVV0wIhAJINe7JKuOgrH0Z/BcjGXqsQ/KK9HkNOXeyn+nFAI1RA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1938", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1938` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAXpjfPfyiAuNZN4XQ+a3amIjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNmY3NmY4LWRiZDAtNGQ5NS05MGE0LTkxZDczMTI3NzAyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ0NGRkODYtMzFj\nZC00OGE4LWJmM2YtNmRhYTVjOGVlZGU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExYgZ9/m4AjG9Ur3Fa9j3sIzcrNOlB5qyuHB+lJhx4cq3FGcQhMMJITeQnlOT\nJrfV2YS7BGyPO0v5sXymRWLy8aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkFb6CO2kcd8vL9bDkRI841Q6SL8wHwYDVR0j\nBBgwFoAUylXr6UmrCXynk1/cWc7s2z48TkUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDqwXUu5r380CXJWdiBSZ7UD9b14MneoxWdkvaC\nfLIx7gIhAK3at8PKl/Vt+8v3JvKrBuA1s4NBEALpUelI52mQAtOV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWXRqwHsQfQCIGElHb4ulk0hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTZmNzZmOC1kYmQwLTRkOTUtOTBhNC05MWQ3MzEyNzcwMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKXiX3141dwMsXKwJKpFpWV/qMlzmv0k1oQnyBeIpOL9L9\nkFFt7V+FFGw/Np8/Qgi0aWR8ceaLMoRNlV6ow5TXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylXr6UmrCXynk1/cWc7s2z48\nTkUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgctd82Aqs/CKOfszpDH4/49wDyL8SWvXGiaUkoViY9XwCIQCm4jXbauci\nRpFpXvwjOuew0I4y2LBfFHy9KwCRxDdQRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAYZ/pMs6u/sQJRXO7/5x30xyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ0NGRkODYtMzFjZC00OGE4LWJmM2YtNmRhYTVjOGVlZGU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZmFiMDcw\nOC1hNjAzLTQ3ZjktOTQ1Ni1iYzY1MjhjMmIyOTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASt06FtyoaVZ71tNNWKM0/DtNmSBG6qIjMTLjcePwh99rmMrP0qNdwm\ntRfrqySidlRkUDEoqs0/hb68BGpfgy49o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSQVvoI\n7aRx3y8v1sOREjzjVDpIvzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAn1WzcIWQ6hA5BXEi2JWzczcSS5MdUexadukC\nrMvHqkMCIQDmGxDy2VhNzhFEv0gUchiZnIWwANNSjS8Lm1hF2idigg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1939", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1939` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAbDNpbtlftA5OhLnpFuuCUe9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1ZDNkNmMwLWI0YmUtNGY0Mi04YjgxLTU1OTQ5MTZmNzM5ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA0ZjliYmQtMGU3\nOC00MTNhLTlmZWEtOTRmODE4YzEwZjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf1kUkf175kvBL3BaF8V7b+OKj+Y+yhfg31GA7dp8fuqQOYKMFP5Td6A8jN+z\nvhb2X8Xgf6enwqyRce4/1F45IKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc2vQedzPjthGzQDE3l5MX1ZzKE8wHwYDVR0j\nBBgwFoAUU7zmLbZfuM25vCpkQp1opZNEK20wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIBi9Xs/McRS2R9UzQSLQR9rpmVcQ/gtmR+hMB4CuAKGrAiEA\n5P63W4pcooFNHstsxh7sBy+nyt4wgjXOxMdgbMmTl+4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXsWMIYheEvgy49OGQHY9DVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWQzZDZjMC1iNGJlLTRmNDItOGI4MS01NTk0OTE2ZjczOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFMyvzJ3PWdzDrVozZFyKc7Ij+uQX+rLwddFhk+No723zs\nlvxXvdigJn0vibcUh4e1PoErbQQKgRQnXBa2mfpAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU7zmLbZfuM25vCpkQp1opZNE\nK20wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdTT1kJYhK0LWGltqZReTnGIxmzNn6b5Cdhz2WdeUwAQCIQDv0ZDQSJ4i\nsSwwcvqP0HJlXY/x8Qr9bOTGmNYkl8mpUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAeVFj9eNVq3vqE5OOHTx4kFmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA0ZjliYmQtMGU3OC00MTNhLTlmZWEtOTRmODE4YzEwZjRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZTBlMGQy\nNS1kM2VmLTQ2MGUtYTc1NS1jZTVhNDJkNTI0Y2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS5C8malMR2uFYaYnHOd8ayHIsN34iafAfy5M0MyexWsupBEimpEo5K\nDC/Efq8+yHBWS4mB2iZ5qL84NShGDvYDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRza9B5\n3M+O2EbNAMTeXkxfVnMoTzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAqJ+X0aAQh0AzNDXIgW68aMirUn9Cq2N+PAVB\nkuqjQPACIQDiSd59dy9n2Jg4F3FzmZV8csI+wiLANyrecHVf9lzMAQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1940", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1940` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUg3eaE52hoG1vACh4OIkQwYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhN2Y1YTg5LTllOTktNGRiNC04MWNhLWUyZTQ1NTJhM2M3MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk1YzE0ZWQtNTgw\nZC00Mjg3LTg1ZjktZTQ1MTllOTZkMzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn0XZouQ62EkWnZ9jaDXi2C1KpGXRTbWXLEyoOS8p1qDBk04SJnyVltfQbImH\nynsltvwzpeGq6mS0gSd2sGB+DaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/yajGlENancj3YrA+vR4fZ8B4q4wHwYDVR0j\nBBgwFoAUGEq4UcP6rDX93+CfjklmuCNnKVIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIATZR9Rw50fxbMfc323eunYrubJtmbbE\nioe1NRLqPUTzAiEApQr23fXMIpy+6TyKnriPHJDhEvuLWaNgh8BRtRo6F7c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVDEed0QCs7MseNCTwTvUe3ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTdmNWE4OS05ZTk5LTRkYjQtODFjYS1lMmU0NTUyYTNjNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2I9QfKn42IPn5RzRa/agYvCT+maLvsoFB7xuiYyl/36Oz\n09ac4EKD2ktbnJMFHjec5jtwrdfUNmyVmla9XA4no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGEq4UcP6rDX93+CfjklmuCNn\nKVIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJxixqg4tLOwTU9x2lDVvAmgGB0B2bYtpv7f2mNaiWxpAiAbWlrAAhHz\n5rfuKmlcTiiQBDjKGR/8GeJIn/36iAkxkA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWjR73Wsya8vlbagDGNTQ1rdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk1YzE0ZWQtNTgwZC00Mjg3LTg1ZjktZTQ1MTllOTZkMzFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YzVkMDUw\nNC1jMTUyLTRlZjItODY3MS01MDczZDQwYmZkMGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7jf4yMt7njq6cooi2IAZkh/CGaQ6W1yN14xCdzcF7998Q3DUMO6rk\n130NOdRwn28g9HpxBMIAK67N0qpM5nqZo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT/JqMa\nUQ1qdyPdisD69Hh9nwHirjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiA92kRaLhbybHe0R/wbEdSao9TbY6zmdxEimhr1\nYf1OJAIhAPiELvaS+uOxToB581pWWnrOBMMcL/8TkfHw+7Mn8EoC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1941", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1941` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAS0mj5qHDgPQbZ3rgbNorjy3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MTlkYzU3LWRiY2UtNGRiMS1iMTk5LTRiZWM4MzJiNDcyOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTZkYWQzMWItNmE1\nNC00MGY3LWE0M2ItNzk4NjVkNmFhNTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyS0botmLCpH6LoP05FFejXYGhzYUpWqPe6B6XbTpwCC+ORGruMLTnHm988mI\nBLQYTSSHj5t7GmddqUbH4C4z8KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOF0mmO+5QRtEm9oCsRFxnV9ixbUwHwYDVR0j\nBBgwFoAUQKG+ruUlNyu3Y0f6nAxvAlKr31YwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDWwcetERscgCzW3N2uoiTdQhSaIEOX\nhXbhUQl4ZNNgawIgCtWBfKZSGeG6W7uGhyximly8r8yHhMygrMO7gVcc1CU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARn2j8CsfrVCPe0BKlXpTq+hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODE5ZGM1Ny1kYmNlLTRkYjEtYjE5OS00YmVjODMyYjQ3MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLct+NuZWmPMS9g6SzTXZY+M5x7Qsx3CfLTIHteGmSXHJh\nPCW8Ncyb0jdcWnbjvf5MlwP2Pa0GA3Sx6C6SOLz+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQKG+ruUlNyu3Y0f6nAxvAlKr\n31YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP/ruBIzWdCoQi2Cmnon/kjtsW321aqJGYaVESCdDfgeAiAS1i3jmoky\n/zPA+LLBBe/4Sl+gHllYwNwrK4lwU44I7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISASqShK6fGv4ibqSMF0l+IOJ8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTZkYWQzMWItNmE1NC00MGY3LWE0M2ItNzk4NjVkNmFhNTFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1OWJmZWRl\nZi02M2VlLTQ1YzgtYWE5OS04OWQxYmFlMGMwNjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARdScExmuOgwEB35diwPohuTPC4ZXrdxj0OUfH21rgQ7dUm+EuWAWw3\nGvmq5aur5DadGeOVZwWPmprqYO9SxtS6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4XSaY\n77lBG0Sb2gKxEXGdX2LFtTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAu5QkvrALpYYRwharzs+EUZT/GpXCy9ue45A7\nUNWb90sCIQC7+pD3EqG4Fu5L2pgb1056R4qoXfSM0anD9GchcQ7yCQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1942", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1942` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAT599EF7fvcpwVwmBpon1+6iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzZTZhZWQ5LThiMjctNDMxYy1hMDI1LWFhMzc4NGE1NzY4YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBmYzQzNmEtMmZh\nYy00MzIzLTkxZDgtMmUzZWQ0ZTcyMzZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXljv0FiWNupAud8feds68Q2mJfb3uQdpcC3p5Opt6YYBYNTP45eCRy20VXKi\nTegtOqAL3rDskBsL9qlMbfOcfaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPDJX6zJuU1a0HUGUIwkX9VRabpMwHwYDVR0j\nBBgwFoAUU7tlBpINfufubfWcM37yWAGaotcwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCoM+4uYxOs\nrfJnFX6LQjMaA7OH8NlDwvEbngMceorHeQIhAPQ4J3gvYIm8oK2M2V/AyOHbz2wG\nOux7jkAHUXDPhBoV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfJYPuz0XpQkwAHYzkIB3Uv8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2U2YWVkOS04YjI3LTQzMWMtYTAyNS1hYTM3ODRhNTc2OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlYW3U8JFliT9e7lQU2thc/+5YJfXhjPY4M+rPAni/HouZ\nDGq04jgaQF6jNeQq2GRnTABQlsVV68eiJh/1kvJZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU7tlBpINfufubfWcM37yWAGa\notcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJIEnsMe0brzUFqhbIOpciu+xelqoehe2J5edToUU01oAiEAjGs0ouJl\nZg5jkauDvHXz57Bcv5JUduPSDABqGJi63DY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYGSB/VZ7tUOwvteTXpJJPy7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBmYzQzNmEtMmZhYy00MzIzLTkxZDgtMmUzZWQ0ZTcyMzZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4OWEzMWY5\nOC02Yzc5LTQ1NDYtOGQ4Ny0yZTRkNjliODZkZWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQQtE+ldXucyLO0Bfs9TZ44JuGyAuK8hTikY9IMOkAVwX1J3ZDofCjI\nKAcKvSZSIbLMk6t2AHLfRGfi4jzC4yLXo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ8Mlfr\nMm5TVrQdQZQjCRf1VFpukzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAug/GwAu9L1W+HewG6/UL1/S9JebrwUH+COEJ\n8oU9lgQCIHWkQbheCfjrOzpiGgPWO90j2bZp2q8saDr/5jVSZCj/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1943", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1943` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAejYq0OIfvNAAnYK7OCJyK4wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhYWM1M2FiLTA2ZDctNGI4NC04MmMwLTlkMTVkNTZkYmNlMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhkYWI4MGEtZWU5\nZS00YmNlLWEyODItZTY1OGRiNTFiZTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGG4FfOqCkLmsTLf1K+Xu1sS427kXL57teAdRXy1WoaIYGKoKIyYgAChRGikV\nYfh5j+HXGtLP28Y+bW0P5rYQnqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnDKjzYxuk86YsoBKPRPEjWWlHEYwHwYDVR0j\nBBgwFoAU0bSzGnUPbLSBerKMdUXIlDeFuq8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgW9K+sC5EkIStKEfuGPeFoWTjRKoPf/JzMMS5zxMkOMMCIQCLS5LaCJy/\nfmLrxZzD5CgqPUpqw08Pu+aQn7LAD2q4Hg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATtjnH0Kozvui9JcINhwvJ1hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWFjNTNhYi0wNmQ3LTRiODQtODJjMC05ZDE1ZDU2ZGJjZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCP2zpjxstcgsz6g0tpOYrogAqPUTA3qdCcuHy9hR5MIsX\nvbpHJWqbzV2w/Jvz4l6x3fB/1Cov6lC24W1Wij6ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0bSzGnUPbLSBerKMdUXIlDeF\nuq8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALo/E5jmlBSguuGZ9el4uFVlahhIHGWY5uVfh4l4gLS9AiEA7es8tn1E\nocsxf0EW9OU3Cg5JqKkRtcefJtK8UlHB5r0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAfuzST6yD4zCqZIuWIhaS1N6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhkYWI4MGEtZWU5ZS00YmNlLWEyODItZTY1OGRiNTFiZTY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMDczZTQ5\nMC00MDNiLTQzZWYtOTg1Ny01NjU1NzNjOTc5YTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASfIHu59ohF+0ox9XfVxOSPF7PQ1+/Vy5rq8958V5EEZAKJHRePUZWm\nJqLxGhttUARDq4Hcri0F+c0QIitVy8Hno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBScMqPN\njG6TzpiygEo9E8SNZaUcRjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAq/SZyWFmMp20aT4/+Gb1xzt5N65pCoGiSF26B\nhCUd7gIgPKqzcpGhdY7Z+PGNrXuRiX6RwkyzVao1WOMUA7Ku2d4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1944", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1944` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAchXHC+oec0JDll4Uo4zMynNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlMzFiNDUxLTJiYTUtNGIwNC05ZTVlLTQ2OGU1MDMxNGI5NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDEyZjQ1NzEtMTRj\nOC00NWQ2LTg2YmItYmJhMjAzOWU3MDM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6BSQmKFA2PDFHlaUvAwGVl0WRn5P9nwqeTtUJGLj9cZufC7piOqGlkdb5gms\nx+nM+96GHwi3lw//sQ7LtIca9aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmW9YVQDkrOYhCl5MIljLVKBC6x8wHwYDVR0j\nBBgwFoAUCP2rjSdB5cIVMqlL5Nro65dBBj8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALHjuvrx5ndVNNsoN+s4p9hisxwlpdCVPFBFjUuX/3BGAiEA+I9caif6\nmuJzg7tSraHECrd2IsTyBdZexOoZiGhMIKc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY9hN6q/aGIOtHC45kSypoN2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTMxYjQ1MS0yYmE1LTRiMDQtOWU1ZS00NjhlNTAzMTRiOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+9uWeTmwmVc5U3K35UE3ozexNN+gBY9fprahFHR0VVqO+\nLOqSdtqDtaM+ZljAmst/hPR6KXdFYgBrq4FICVbYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCP2rjSdB5cIVMqlL5Nro65dB\nBj8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIQIpjMCRyihp9hKC5zADWyRcbsj9SmiWLmwHnc5Krh5AiBn2GJbxApd\n212DabNLhzPZ+S+iWJwhANySQZrWuzMoIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWYIEV67F1nbpc0YrCpEwbYgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDEyZjQ1NzEtMTRjOC00NWQ2LTg2YmItYmJhMjAzOWU3MDM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMmJiMGJl\nMS1kNzQ3LTRmM2YtYjcwZi04MjY2MTZmMmQ0NDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATrrqDwLmU8qAGzzh3sCgvp5MV9QD8+K3Ir94/asY1c6zRmRRwrqPAF\nYEg4cYr6SkgGYt3X20GHp+2kAw1Lz3T5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZb1hV\nAOSs5iEKXkwiWMtUoELrHzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBaASQNcIMq4pYFwXq8b0t8diohqj4oJVSIbeZw\npc6tDgIhAIuZXS1Y9dwt0C1aTSqiyxNKkA72rXegYzU0vQdRgfYj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1945", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1945` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAestNl1IBwaxfHZXNaXEcYgEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiNzY1NzBiLWZjN2UtNGE1Yy05MjU4LWFlYzhkYjJmNWIxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY0NmI0MTAtZTE1\nMi00NjljLWFjZGYtM2Y0MDcwZGRiMTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyAy3yIN0zTP5BKwUGF/IJTMYBNRFgyb5p9eFAo5wdHAgfm8C15KJ5RCdTnIq\nu5YyXB622jb6eIYXWZhuXxdb8aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1gmviBGtvo9o494jsyYcE49LMEUwHwYDVR0j\nBBgwFoAUaxlQD24DqdSmnkgvnLq1fOczMowwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDCk6lxWG1xV6Vo1EpaBf3ohAaWv5YGE8JE1lWx3/pagQIhAJP5aqwM\nBxNwmc8FURJ36X1MRmSJBgJQnrylKAEv0baf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdPhAWp1MF5oCRGeiBxyt+00MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjc2NTcwYi1mYzdlLTRhNWMtOTI1OC1hZWM4ZGIyZjViMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASL+7dxA/n6PH8uF9vHbRXqw9AGsdQ6Wf3foJgzWyhKqkWo\nv/wpAnc9FwidSKW01CK5IOBJF8jVO5CGFSlMimICo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaxlQD24DqdSmnkgvnLq1fOcz\nMowwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM8RFQ4lqtUbv3yFi+jfpU9XAcxrdtjjfr5SWHog6TC4AiEAhEt1Oiy5\np+xBFdT1+7g8ndu4Sn+7lhmM8mmltnlT4ZQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAeuHHpBR9bgkkmJ1PltLL4n+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY0NmI0MTAtZTE1Mi00NjljLWFjZGYtM2Y0MDcwZGRiMTFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMTAzNDU3\nMi0yZTU3LTQ2NmYtYTBhNy04NmM3Yjg0ZmIwNWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATodSfdTRTprCqQmkJc6jciFmN6ChGWjY5iKIvKrwgMaQOKpwJR8c/E\ntD0P5dWQXGZC2flXGEE/mqOhjPEdBcExo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWCa+I\nEa2+j2jj3iOzJhwTj0swRTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAiCLKAkr4zhrPejE+IzkS/PCq1YPsxbcP1aCAX\n/ZS9igIgImjB24WBXL+b3f4z74F30TatG/eR9Feczea+9OWbQGU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1946", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1946` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAT2SgXAQXQAcjl2vNeOofIR+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjOWRlMGIzLWQ4YzMtNDQ2My05Yjk3LTgzNTBkMjFlY2ZhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdkYjQ5N2ItMDE3\nNS00NDdkLWJiZDYtNzYzNjdmZGM4OTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHdfQprp8r6mgkiuo3pYFz576TY90zfX8RMTMqlVnFtevtX9O6K4MXY/Ct0KJ\nAev3lAhw6MMbAnvIGq33qG4TGaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTXCKIZPVnI4H+1mpgScqtcSrcO4wHwYDVR0j\nBBgwFoAUqIqP3OgdDfwwpIanEyhCxxzUPdUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDLiIG2CLzN7LF5Ienrdc3C+OmncxtdSpfowvXv\ndeOWbwIgaeXdE/WhGWzqc5jwZjF+RDoguURGYfr2S3j/fIrcx9g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVwf4UwAJp5TkiLtSmH8MTtuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzlkZTBiMy1kOGMzLTQ0NjMtOWI5Ny04MzUwZDIxZWNmYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGRCjLSPhB4BXxkbxC7oviOuUpFy6hFYS/1khZAUo7Nf6M\n/RvKaRAwe0f+j/Vj5QTUhq0A09bK6H/mJHXDSkddo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqIqP3OgdDfwwpIanEyhCxxzU\nPdUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOs6WQibYgQsL5c1bTg6H39ku5fqgS3hQr1uwsuVMZBSAiEAl9UfZG8H\nY5kmqSZyYVryk1KjXxrVN5WQ1VE7zJOxByE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATarpsY07H6VU+TH9ONoolSeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdkYjQ5N2ItMDE3NS00NDdkLWJiZDYtNzYzNjdmZGM4OTE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjODhiM2Zm\nZi01NGFkLTQwYTAtOTFlOS0zMTdkN2M0MGRlZGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR58+ioQgDp1jVn8HhdYuTobL0vJGJ7oq15Ig608BwKORTM5ISSf+JX\nRtcw2PS2GnTI8Dboe8bfymxXcEPEWMXEo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNcIoh\nk9Wcjgf7WamBJyq1xKtw7jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBkcL+xApA0DXJ8BdWFCCzX7HSKugZnbI/OJ1JD\nubF2twIgcHoXaV69wyjxnU5o8VbCFVSFEY6hZjG6vY4mnkfUMxc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1947", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1947` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISARuKne7g8QjpA8m1zEhl/FGMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ODAxZWJkLWEwOTEtNGVjNy04YTUzLTg5NDJmYzM5YmY5ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYyY2UxN2ItNWQ1\nZC00NTkxLWE1MjctMjQwZTE5MGEzNzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1yVOPS0ykqwNewj6RNrgEH+9VwImjVTDdOGhKCd36Wp1tUeRLmMoLIStTQzO\nahzzhAgtHDfEIsuKqOfTpVWlC6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlLaA1jUJtfMJ87O+WDGfHT+fdOgwHwYDVR0j\nBBgwFoAUTNG7HdmrUCPs/Ivy6QhH58DbAwYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDH78a141P4bhTbtAE0zZ5RcZnQRa6hdtXDglbb\n8BnTFgIhAPveYBOM+Y/dz3SOzMu1Zu8LPktALBWdSNVUkNQvnn/z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASQh4mucNTAmG7LnyOxBsSCyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDgwMWViZC1hMDkxLTRlYzctOGE1My04OTQyZmMzOWJmOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk5aILnBuqd1gNeRGz0D2c2SkycmsrsIyL9ehurISg7SJz\nzzbkvfL5LwQ4aS369NZ7URF63cShfdok8cZmVTOvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTNG7HdmrUCPs/Ivy6QhH58Db\nAwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKupZ1Py8nTG7pmCqjY9AP+pCwJvdckFksS5firqxf48CIQDqVWU3P0v1\nX2T2QhIL2tOn9PZZFEBkp0dWCkPIs6HEHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAc4EZ3o3Pwt8kPfjffqPiOImMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYyY2UxN2ItNWQ1ZC00NTkxLWE1MjctMjQwZTE5MGEzNzlmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MWI3M2Qw\nZS0zMzM3LTQyNmUtYTc1Yi0xMmU3YjE2YmQyNjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARJPg+HCuxFPc/07alCLwGEoJA3wgkyK6U/V50uuw7YH3Yp4yJpbOAX\nWj9iO42JX2cAu88FKg1UOPVT/bWK+12zo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSUtoDW\nNQm18wnzs75YMZ8dP5906DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA0pNxvnGWIwGH71HWgupN6fiSEoVxhiRaYQKx\nqBNMjQkCIBJnYtBlVvcjvfNKuhSPyPUpKmJY6NBJK193IHQAWllq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1948", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1948` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAb/uDVT8SThmPo0k/zJXXRabMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NjM0NzBmLTYyMWMtNDk5Ny1iMmY2LTkxYzBhYThhOTZkZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWVjNzE4ZDEtYjEw\nYi00MjJhLWFmNWMtNDY5MGI3OTg4YjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjfKdkXwzTDghm60UGtwn8ujx2rNhuz81HO0QBfvgdSPutMXhgMhUg/3Pvrh3\nu7ABqqViZc9sEciKCB7u3EieWaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOjH9cyrxPgLg6Fh/Ebbhrmm25LgwHwYDVR0j\nBBgwFoAUl3lq+W+kU+7rlvzTdBYpuU1vkEQwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCUPQjgXDBnJwXtbOgCiDvvuxdH798eoaZQdIDV2X40EAIh\nALZ+K/ABANRsBtcEIzHgyQrXqtzpCEvEdp387WxO5Xqr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQKTpW6iSE7HaoXIPHVA50g8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTYzNDcwZi02MjFjLTQ5OTctYjJmNi05MWMwYWE4YTk2ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnSfwu7yA1aDXzBG4N4LRjbYhRNDaBBk6eixLJbEa9XEgC\nfcDp2pav2EUDgz9WDMZSSwbSFozAW+BZB8H9Wf0Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl3lq+W+kU+7rlvzTdBYpuU1v\nkEQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANXbSBB5SbScaIxv90/hA16KxSiYQu3+eU9MQUQRL4NAAiEAriYydJbZ\n9irBJLDYxnvCykJx89fSVVDQ+jW2s9++gIY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZnp3kzXn4TjJ/f/60LI0TjBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWVjNzE4ZDEtYjEwYi00MjJhLWFmNWMtNDY5MGI3OTg4YjZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0YmE0NTBm\nOC00YTc0LTQ5MzAtYmNkMy04ZWEyNWU1Mjg5ZTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASzIcMlUHN0Fw0RMNDSgpaIUDx45gqR+dw1seQahbjAYZEm6BQPgti5\ntpn7RENr84oRu99RTiBkxItSwfN5Q052o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ6Mf1z\nKvE+AuDoWH8RtuGuabbkuDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiABhXNeqWAc8y0FX5XW9QxhJpQbQz4ZYYOqCJjR\nrgqAHwIhAO0xmfsm0vZn7ZwyJA4Q6JJdMnXH3WSxf/BBo4C/QFBA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1949", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1949` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAXrbMrFyDmaejvbX1Kock+QEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkOWZiODYyLTRlNTEtNDZlMS05NWI1LTlmZmY0MTdhZTA4MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGMzNTllZTUtOGFj\nZS00YTQ3LWExNWUtMGEyMzU1YzhlY2QxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiQEnaRzT9naNA3pr7PwZYI9HjyiJl6NoMewqC7zpMUuesujyfTaP2lsON5Jk\nexjIxypWrfdIZ2jSLhACzJSvv6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9X+XPglRne2VSIzCJ0qWq9z4C0wwHwYDVR0j\nBBgwFoAUH/umO2lmiln4XVRIu92jy/5mbFgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCenAwoFdst7Rnab+g6PNnESD7eTi+y\nQzQw6E4ODsI3rAIhAOrv/mFtj7sLks4HeIibJMu/mSPSEe6yfZl8tvF5Xehu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASg9URcPUHesF4amiKKYbE3iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDlmYjg2Mi00ZTUxLTQ2ZTEtOTViNS05ZmZmNDE3YWUwODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv7SrSVt6m3+0ZreFQfar/QZyUbKgtjTGL/AGaAlaavfJo\nzi51z0tUdXFFoGS6pN9ImIgWcZVzpqpkiIJDE1r8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH/umO2lmiln4XVRIu92jy/5m\nbFgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhPV2SpNhtncQBjN2Q4iHS7BcSVBeEAH8El73RZrrbcAiEAv31Dl/nv\nv0lXnArGD5vDWwsw1actL9s2vy4M8lehOWk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAabVFwr0/GZRdhZW8ANni7OKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGMzNTllZTUtOGFjZS00YTQ3LWExNWUtMGEyMzU1YzhlY2QxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNDhlOWQy\nNC1mNWQyLTQyNGYtYjhlYS1iNGM5ZDgzODFhNmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARqCPPOjOfo/VwReJ/37LxZuvU2dKAajrFvJUR/WRYRezIT6xdzwmsX\nP92upGnXjh3yyzvmgmwxXsK5tzf3VSc6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1f5c+\nCVGd7ZVIjMInSpar3PgLTDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAlSJ4+L9G3JZMajbk82GABjENpN9SjfsXU1v+h\ngJHIlgIgJdgxIvnwqPS702GxPL81p3SswnD2QV832szseYea9IM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1950", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1950` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVJorn3+N9wj1kMP4ZvUi/WsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YmM5MzI0LTEzMTEtNGVhYS1iNzhlLTZlZWQ4MjVkMTAyYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTRkOTI0OGMtNmYy\nNS00OTBhLWEzYzAtYzI4M2EwZDMxZjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYh0Hj7FToPO5Y6Utd52W076Iyt+nhUmhHNx/eKam1HP9ahUky5U64+hCLAD1\n78mIcLkBDd7ro23QzKfcxSKyiKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfQ7mk/8pr0Lbn2P3cxCtNmiTtC0wHwYDVR0j\nBBgwFoAU4zEuq3/4tID2IK3VX6+N7yvfaN8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIA8Jhw+V8NngMPospDyG2KqW/UjgLAN+\nGgUYSyxsV8SIAiEAuD2fFR0cKD/SRJX1ETaHZ8bIHuvkPrEF6llW+wgP1TQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYqd992G/3p45Rqqk1FrcuhGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWJjOTMyNC0xMzExLTRlYWEtYjc4ZS02ZWVkODI1ZDEwMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP/743bOMyZ8nU5JAZA5zG0WGVz34VYbzlKWOgUNb5Dicf\nN/hsHCJcJMXmSTcFJUNeF6zmV/YG34CCusG6u54po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4zEuq3/4tID2IK3VX6+N7yvf\naN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP2vt6Pih1cazbhPzLgrLipy8F5K/Z/3fnDavM3/6HQhAiB9eq+y7STV\nHioj8GCP5UVSFblCIFXZwo3J33g5SpimxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXAN+URI71qWtLe6MoB9ZbrAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTRkOTI0OGMtNmYyNS00OTBhLWEzYzAtYzI4M2EwZDMxZjgzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5OTg3ZTRi\nNi1iNmZjLTRjYzQtOWIwZC1hNjUzYjJlNmEzMmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQYD8VfdIfxJKa2Vgc0JADvTh7gqaZ2J5pS+f+OfhpKQA6t+Wg4P4kE\ngEMMj/xfTE3T+7alutnidrZiJy9YgNKoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9DuaT\n/ymvQtufY/dzEK02aJO0LTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAhP5OGIRZBwTV1K1Y2xmYiNzJbv/c6gXKSbxQ\nPepsC0cCIQCApzEXYHL6cMjWJafSMWCzG69XeTMkKhESgvjv4s/0Rw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1951", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1951` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAbuUvUBp+5n+SfeBk7iKdjvpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMzdiMWY4LTdhYzUtNDRiMi1iODRkLTE1OWJjYjUxOWU2ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY1MDU1OGUtZWIw\nMS00MGY2LTg4MjItZWUzNDcwMjJjNDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu6PDvs5uzybQr/Umwt+yuPT2ITKzPxeDRl7xWQJndQ+MsxBdUTbvfO13X4GB\nlgCsARerSRpKyRxrIy/GiiaJKaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKPKlnzcr+eZTr795jfaDKMdsHs1MB8GA1UdIwQY\nMBaAFEFwymSG+j7hpjxuDPxDXPcuzFwlMAoGCCqGSM49BAMCA0kAMEYCIQDxWOjt\nZ0fHNtuFZemQmHXg1GuNDpzF0jmAMZvox+haYQIhAPeSvcw1Rdxj4Dd+c2hJUGtZ\n4qV94md3tsYOEBeiTiy5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfxNUPgVhsAsVRub3/jmCjdMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTM3YjFmOC03YWM1LTQ0YjItYjg0ZC0xNTliY2I1MTllNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXEx5xlBjv3kqiacNaAgGDiFlp9rajjAI606FkVQ7MR7xb\ncf8HAgXJs+I5q/177qUvf6vUxoYIKM5LllKmGzYzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQXDKZIb6PuGmPG4M/ENc9y7M\nXCUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCwRM9AmiuD81OYs6UFF9dr3PbHYBjhnRLTOyJqYdOOMCIQCkg1Golilm\nrnihq4iRkHD4Jt/9iNWFpPwOV+yLDoMKxg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAS2kTa5/6XaPsgiu3KKPf5whMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY1MDU1OGUtZWIwMS00MGY2LTg4MjItZWUzNDcwMjJjNDg0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NzM3ZWIw\nNi02N2EyLTQyZmMtOWMzNi04MDM3ZDExYWJhYzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASKeZF7lz1q9nKv4NLi+ZDmCiMVF8I409KIBmry2aMykUCxL16DxAlN\ng97V2D1sGxVYj7AWD0AbAsJey6h6NM46o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSjypZ8\n3K/nmU6+/eY32gyjHbB7NTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAIpNVsRvkZdIHtT7GMZP6yXHsqWsZ/jhhT+yEZCLgOG5\nAiAFJPiKITHjOD2H19JRqyD31Iew5aJ7Rjfc8dcQeMo57A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1952", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1952` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAVYc2QvwM4g9G7VGR2EgFe8GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2MzA1MGQxLTAwYTUtNDA1MS04YjE3LTkxMzcxZmI3NGFiNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWNkN2EyZDMtMjM1\nOC00ZTI1LTkxNzgtOTA4ZTYxMTMxN2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED/nQBeMwRHWTzIdA4rwNMDFBpFlwgu41ke95u49cfNlTBFJMLnukusovRG9B\nd9csu/GGdOHCxpW4h1cl6jfXVqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHg4vaaSdlOnHLXSLZIUU9zYC7OPMB8GA1UdIwQY\nMBaAFAj+Ysj8PmBv3N3K1CfHjVAlzeuYMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAgBR/I6Crz9mUWlGCOOLo0qjOPbkIcbMs\nXcxRZHbxcXECIQDafgW1VoOq2XGSlBA4usq3Y4JfJVn7pRSUycd4YkodEg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaGGv9pznTDX9bjYmfwEfG+LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjMwNTBkMS0wMGE1LTQwNTEtOGIxNy05MTM3MWZiNzRhYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI7jxmi/KICsUPT8+4Bo/5EOTI2aph5bUgk2BkpdbSd0+0\nfDMEcVuEIeS3Yj4MCsUKF7rDnrpZLHiDYgZWMxe8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCP5iyPw+YG/c3crUJ8eNUCXN\n65gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIhrJ2sfljfI1XhrjW2Q7kQXLDxu60dQ3hh/owhNqx5dAiBeX30VRceW\nr55uoKqMY8iqtXh35eHWuQjTl4peD6q5jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAfUfq96zunyWxkAL36g/6rJxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWNkN2EyZDMtMjM1OC00ZTI1LTkxNzgtOTA4ZTYxMTMxN2E3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NjA5NGRm\nMS01MWYzLTRhNWQtODhjNy1jYzI5ODgyZjRjZDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASq7IN2cSxicu3X66W1kcLE92ut3Sh5IU3liBBGP6zOZhtr4GzbWKJO\nrbuO1+ywH98B67YPL4NYfGhYB/5Vxwkho3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4OL2m\nknZTpxy10i2SFFPc2AuzjzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgJv4kHg5yF9xU/Yq0oNh1r1u1axB7FinWRo5dvewxaSMC\nIG2aQ3gjmYtea1SoMRv1pC/Q4P9K7TvdVJu89zFd6S+8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1953", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1953` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAatDRjQzGRzg6k1Md8vIelTlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhOTJjYTFmLTM0NDktNGMzMy1iNWI2LTgyMmFiYTgzYmE5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE2MzU3YjAtMDg5\nZS00Mjc0LTg1YjMtMDY5YmIxZGIzZWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELqmXmpw5L/xtCsTq2GFHf3BSvGQVGlgPHTDZY+Gkep2Xm+eWMNBiPd9c+o7q\nhpQDOKXg6RdBJ38J3dFR7SUMD6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFG5CZzcLeYiy8100yJycpljMF58+MB8GA1UdIwQY\nMBaAFMiCjVatwEQn1nOjOKgLIvAlL+IMMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAyFZxtSv68wkNhJtMknswxl3228XkJlqw\nScabRFp+0jsCIDr9tSdUSS0q5kC7npTQ/pnfwnOyyCfgpBLAPELxO9iv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVOajKER09YHlcKKoweynj6eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTkyY2ExZi0zNDQ5LTRjMzMtYjViNi04MjJhYmE4M2JhOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqSMKHlT76yGlLFNWUp90NxAz3JDabyuOUnUmSu0omWbbN\ngFC65PzQ8ysWYucGVQ3nG+JYudChproffUC/3LGWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyIKNVq3ARCfWc6M4qAsi8CUv\n4gwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJHTxq7fcMHPBQWHjKr57ke1Syo7gyWKIJvQQC82RyKUAiAOuFzP3hXd\n2Eegd1qK4U6P4QjhIo65q/pJz+N9WM/Agg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAUcfh1DE/z4wPRFcy0LqhhGlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE2MzU3YjAtMDg5ZS00Mjc0LTg1YjMtMDY5YmIxZGIzZWRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMWJiNmVl\nYy0wZGQ1LTRhZDItYWZiYS1jNTk0MTM0NDQxNDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT2IjsCQ0hwvCWaowj7Jb1yipKAAlHKe/PLqkE7j7BL+rIKipXJFn2a\n+2oEzKpepNbp+Tq0cA521qc1ztYpIyOho3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRuQmc3\nC3mIsvNdNMicnKZYzBefPjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgOsB36ISwVzjwOStfffpl63742PUbodAGg3qMZovOSkQC\nID0nJAfU6SVWIC0Tb7uxcvYZRuDUIp0bZsbNz8TNA8M4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1954", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1954` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAbJLnQQp0ooaWVSfprnE0v8XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxOTBkOWVmLTdkNjItNGJhOS1iOGI3LTRjZjI2YTc1NDE1YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUxMWUzZTctNGQy\nOC00ZWMwLTg5OWEtZGQ3NmI4ZTY2MjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOtAwAQjpLs3FOm3belmQ8cnfXTc0raiaN1GDzuu57e/EcIZTdd4/wnJUshdy\naUGVALeB4bJZr63Vm/UkDX6bB6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRdnT6zsS2ciawyJwOcEK1HAy+TEDAfBgNVHSME\nGDAWgBQoD7t9JEDOPri/BCJd7wrXeJFqFTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFj9mP0LF/cPhFyPFlhc9HF/EvFRUFXy\niNi0DBYBSD5sAiBoXMmAHpBkSHp1ZW5Ti0QhhSPpg0i7A1GMTfMzdxQ+iQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd4GzYePiSdMZN0VSe7ELxHoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTkwZDllZi03ZDYyLTRiYTktYjhiNy00Y2YyNmE3NTQxNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS90ksUJXZXFCI/AmruTQoqpEPBQTC7BlEuj1h3Aqua4li8\nmEmXH/R6InDnArC+PsEFRrj/UK2EvAUuBy0I7mhko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKA+7fSRAzj64vwQiXe8K13iR\nahUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRSmWk7t3qvQCrO33hmkc0+/eXC6cNMOfr9vZm+SgeUUCIAUbfwIdrabX\nokBTh6//uvOm4BVcgHfQbykpIBL1/OdO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXWaMNZJuWJrCqnG6AaHrQ/CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUxMWUzZTctNGQyOC00ZWMwLTg5OWEtZGQ3NmI4ZTY2MjIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MmYwY2M0\nZi1hZGVhLTQwMmEtYjgxOS1mOTAxNTkyMGZhYjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARL9Gd/sBnb/R4t07ddFRKct6CTkQ9Mika4enrI/eZ+EJAQ3ox+1KRF\ncEp/pDrKNitbeQjc2OstMS2tEwXwYK7co3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdnT6z\nsS2ciawyJwOcEK1HAy+TEDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAOcV/zTxF/N6Jm1CY0kvEHOw3hezrG4ph70wFmhiQ8IV\nAiAwRbgND9jpuLX8iQyaEhK8lv3UmgXnwKW+yg3tiuD49w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1955", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1955` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWten3+QPKKb0ZYAHlHdNmoBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNWM1ZTY4LTE1MWUtNGJhZC1iZDBhLWJlNTZhNDg2MmU4MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U4ZDExMmYtNGY5\nYy00ZmZkLTg1NDEtYWY3YTU5MTk4MmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUFPXceYek/2Vd5PRoykuxO6SaW21JrNs/iP7OPeNgdFwNPLGwuRqg7krHjLX\n8lgIH2g6SAu84/k/kZeQeP3/r6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYScg9Vms87TREX58wALXrAKNAHowHwYDVR0j\nBBgwFoAU/7q4e2pqeEXzmd83Jm3Ir7QIvSYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiATbnj2GaFFp9p6\nr55CB6+HY/4b5CfKvlEPBbJ+fc65TgIhAPHyLCDB4sgiZX7XUBfiFc5ag0GSAVHu\nc1BtsZtO1PPv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaFVnCwWx0cmYUzEgd+nAV4dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjVjNWU2OC0xNTFlLTRiYWQtYmQwYS1iZTU2YTQ4NjJlODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT82amUEofkmCL5CRH/duiPN68dN8Liqd/d3QcQWUizdw3x\nkDwLnFDsBryxRjTYryQziTmH+vzk6FkLBhG52FDpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/7q4e2pqeEXzmd83Jm3Ir7QI\nvSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSURwjhBN5ZaiVRZsc95vnTTW65ktxDYteX4DBTwzm6MCIQCyshdyBy1E\nabT5LbHt0LOtNfax18HU0RBYW6c1tlBWHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdSgAwIBAgISAQq8tnLUJ9VTLytJ+UVUOW+NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U4ZDExMmYtNGY5Yy00ZmZkLTg1NDEtYWY3YTU5MTk4MmY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlN2YzZTJh\nYi00Yjk2LTQ4YWUtYmJiOC04OWM4ZDNlOGVmNjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATdY2S8e31j+Kg5wIjvzhEqF7j0rfKFAkiTQ0UFlRUd26WxjUGURO+z\n4U/T36lhBcrwiH9XjKhIZ4bTU8mf4236o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRhJyD1\nWazztNERfnzAAtesAo0AejAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRgAwQwIgPF4QalBUn1EX5nETAzg6RQh/L0f1Izrh43A9lJ9kaxoC\nH2tFJTXbjCzOybWBniH3UgF8Z1BL7UntmspywyuvYH4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1956", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1956` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAV5guIF2bkvJ/B6QN5L71Ab/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjYzJjNWU1LWE0OGYtNDdjNy1hNzgxLWE5OTI4NzE3YWNiYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc0YmJjNGQtNWU1\nZC00NTllLWJjMDItMGEwMWI2MzYwYTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeDeuKgaJTZLzBICnem4UBrPDSpUDp6NAk1EBw1VT/su12umjC0/4Bvyo2A7v\nQhbWnSZDw2YIbCfl1Ja2UqSiFqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzRSni7DAu3+Kop1/zEN4wG0sghowHwYDVR0j\nBBgwFoAUXK1bnJGqrH1tbq7HhJ+us5uhSjkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAo/1ZBH67RDjt\nuSDXZYHh3sTtJsPWUrSKMGnZREoVnsQCIQCO/9Fjetw/lAcG7jocJ/BbJKXsThib\naf1nVbDxIg+zxw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARsrRsIrwUuudnsTnoDH+CMLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2MyYzVlNS1hNDhmLTQ3YzctYTc4MS1hOTkyODcxN2FjYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbDqhVlbCvkNgklkmanw+zFMeoRoCknEXvWhTbqmWLMdYk\nCyvG7kwQGz2TPhA149YuFS0oL2Nv17Lh16gVzgDvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXK1bnJGqrH1tbq7HhJ+us5uh\nSjkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKjn40zGcsHNDQdlx7fAUPSrlk5jq3SoijgDvQmlRDAmAiBgL15EhSDc\nuU/tQekE1pggspxliQg1lAmej13AzXukLQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAetAixhvejfftUv50Ygm7vMqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc0YmJjNGQtNWU1ZC00NTllLWJjMDItMGEwMWI2MzYwYTY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMDg1MDVm\nYS02Yzc0LTQ4MTUtOTdlYi03YzA2MDYzYmMzNzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARUpDn6UPXxGySJli+0jYCVlDyEUnEu6zNibBjbm10tv3cETOeb/FH3\n/LyPRjL36Qnn/Sf91gm1oZvtfxZMpaF6o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTNFKeL\nsMC7f4qinX/MQ3jAbSyCGjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgZpa0MFRyNBZew266M702LutMMmkhHKAljElnwCLZz54C\nIQDOJr7miu2g9s1bplM8UhP2y4CUceSJ9Owc/rODnaC+Aw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1957", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1957` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAYIQE/AEgmfqbRcTKcbGPQuYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwMzQxY2QwLTA2YTctNGRkMy04YjYwLWM3YzgyZDVkYmFhNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU3NDYwZTYtZmZi\nMi00ZDk0LWEzMmUtODMwNDU5MDE5OGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7gGkzY6fcVPdOFNUkwvjtcjfWRvblZ6GFhn7Zya+0gVOKGmdGeZtOPbnYYQ2\nFE/On0D5QegETAgFSAWYllZzN6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAITg6mOSVKTUJx2IWyh83Yl973kwHwYDVR0j\nBBgwFoAULo7NBUCnKdLw+qe3NhkYQfNJWgcwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAnYmKMLa/iuzpkT9MmMZw\nkqIJAbB5Em+dQTbOunUZb9gCIGZbFT5IJ7XETUKuLt8RhcsxBmu8hzGotQI0hVM/\nyeIC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATNkt9QGI5qXD22gziHabmpzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDM0MWNkMC0wNmE3LTRkZDMtOGI2MC1jN2M4MmQ1ZGJhYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTE672D1S8kOXtd34goUsONXHkChGmExa3aBA35jY9Jmy1\nTLu0MJo2eYkqVQ1+tLvOgbH1e7iQ+OCJCHRm3XLAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULo7NBUCnKdLw+qe3NhkYQfNJ\nWgcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOQ0cK1JNMDVO0i3F/uB7wrWffO7FpMxkRZTuCyFLkeMCIQDlDfVAOQoT\nO1w0p79yHn4cDJPDY5E45ZKi3Z8PfQcGRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAS98AGRBl+jl2qWaYC+3b/G8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU3NDYwZTYtZmZiMi00ZDk0LWEzMmUtODMwNDU5MDE5OGE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNTQxZDQ3\nNy1hOTExLTRhMTYtYmIyNS1jM2M2NzEyYjY5ODIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS/eslm27Z9UIgf7w8f+ryGuJ8ebLF65ubsmfljCF6GdabI+U7uLDVP\nFLTiFeF7GIgHRULAz1g5Jr5mdovVSkMOo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAhODq\nY5JUpNQnHYhbKHzdiX3veTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAKQAD7PfVKkz23rH+T23GyCqNVIZdPSRQbgnF1MfQqgC\nAiBF07qge9M598V3omiRc4Zr/DDbOz+HORN4oKYkuY6gBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1958", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1958` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAaqubaaKI9VlDuR5/nH8qU+JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiOTI0MzY2LTYzZTUtNGUyZS1iMzQ4LWYyZTY3Mzg5OTQyYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGZmOThlOGEtYjMx\nZS00Y2FjLTgwMzYtNWE2ODllMDI5NzllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8FNAd2nJb+P0RmGZbNi5RhrakPDYV+snDHOTNnTE0/esvIhk3Apd/B5QbXOV\ncbBZYfKQpqJPD6vqRxnaauIVl6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVRISZzzZz+/0xOagRDBr1QujOKkwHwYDVR0j\nBBgwFoAU4D7YJhpVyLqRYYEAHqLZXdywcigwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBXWqxq\nqsqUtf7KYTUCohxQ7hKFPqVL2bxtA0IUhjCedwIhAPzTAKD8JPAExYPLxry8n0Lv\nUUJ13HHgFImVtLJNOZ9N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAebZbCPwMEDRR88d3Bv59kX/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjkyNDM2Ni02M2U1LTRlMmUtYjM0OC1mMmU2NzM4OTk0MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3STMiPOqzFO/s0nvlYCeMaF6ByNl0Ptl/HXDc+MbJRCID\nEz3MppuJCkzRxGsqIdRDr979Ba7UIDZqeYRFbmUIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4D7YJhpVyLqRYYEAHqLZXdyw\ncigwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGYkgx8/SSVTYZl8JhoSfkasPggoavNLCh7E54S8swyACIQCASf/75VLb\n2DAfy1xgDvQz4o70+Tc2d8D4jh42kRpJKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZiGKS+VTDXKDEG8X374VEWjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGZmOThlOGEtYjMxZS00Y2FjLTgwMzYtNWE2ODllMDI5NzllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YTUxZmJm\nZC0wZjRhLTQ3NTItYjU3YS0yNWY3NWY3OTgzZTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATvqZ1Nha1PEhqWtnzTjpoCUvrfLLFaVuF9Y2uSoKu3nrNnj/t+6UZR\nqFvJvnKLMwVII/O7vlZtT3+z4J/eT2hko3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVEhJn\nPNnP7/TE5qBEMGvVC6M4qTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAJgO7ryDvAbiy2+keydzx5c656lYiauGNqU/V9FD4C/w\nAiEAiuOKVxgrdvmuNJ48tP9vaT+ZykaXhaamQDstcSnNngc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1959", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1959` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAbVQpY1cnM9X0MOv39GVXw8PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0YjExNGZiLWVjODMtNDZiYy05NTYxLWY4MDk0NDM5MzgzYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBkMjBkNzMtMDk2\nOS00MTcyLTk3NzgtNDFhMDA0NDk5ZjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnrE9bsbkYBDnKFO0/H+eJLhKiLxGIfhhBAb7nieUetgyZzY7yrcWTMDULvls\n/lIHAmVDAbsgd/K6KIxDXrtNVqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKQrIAf88sWhPnboByaiX1DaWXKUwHwYDVR0j\nBBgwFoAUowkYqgHZRkTSE5LUdwT7M5dtBEMwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBOJ6L9\nSqNeqEqbz4YAUTDsZdCFx197rOQFN5ZVwWGPKwIhAJIE/vq/u2AgddP5xmSUTOJu\n0VG82/riLbEwiUwPEghi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbP/ck6br78CEihWifYGp9qwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGIxMTRmYi1lYzgzLTQ2YmMtOTU2MS1mODA5NDQzOTM4M2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8kLYcNqVc8Zlod7MtnyDRzIIg0WrnCMQE2O2e3+F1J0jx\nPI/l4Qu8Fq5dyP5joUOWqPeDhddLg3tKCYbqNb7No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUowkYqgHZRkTSE5LUdwT7M5dt\nBEMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN5Gv5bh7Fhu63Kd6Q/BbRyEGjgv2cTOxtpGb/AW8/VsAiB8FnwEvJQQ\nHG/MVwBEI7ecVuo7J5EHObzEZylH+HQJyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISARvCp3zYpXsobdMypa/g+R9AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBkMjBkNzMtMDk2OS00MTcyLTk3NzgtNDFhMDA0NDk5ZjdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NTNiMjA0\nMy0xN2ViLTQ3NDQtYjFiNy0wM2FiYjRhODJmYzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASyvWq69Hy1QvnD/Plcyqc43HE6rxR3B3X2PJgOhCvg8sz/asaIFGnB\nv6DcpMhMLEbRFnaqBO38/lMiG1kcBxwio3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQpCsgB\n/zyxaE+dugHJqJfUNpZcpTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAOHMacDPjIgi4MA525pIEvL3aUsN8sRz8B4c1JRuFhL4\nAiEAvFVwUrd0l4nDJh9EW5jOwlbg+w7qpDTmdQ72ySKByAc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1960", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1960` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAWfhk1TD8YEjNauGEldr5tSUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViYWM1ZDJkLTdjYTYtNGEyZS04OTg4LWNjNTBmNjRjYTNkMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2M2YjQ4ODQtODY4\nYS00NTQwLWI0NTMtNzA1ZTZiM2E5OWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYRU7tVqWvVyiEluKvWb3P7w+0aAihI535LaKGPRY5GkjOxXTGlhoeGruSKVk\nPNbsndaCNua3P1iG7TD27irRm6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBQXMSabAfg/pw/2EBT3T+VZqfizMB8GA1UdIwQY\nMBaAFMj7BI0dUMWZWrsCD1XK9i3oSbHWMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAsyyTaRjAuya2QbZ4KKlHdso/q6TqWgx9\nEtBYzZbRthwCIQDNo8xGuDdofjOy8dzIxHUUL2g6MRQpRgifM02pXxNFBg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf1vOxlsD9XMtJ6QNtsFp/IRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmFjNWQyZC03Y2E2LTRhMmUtODk4OC1jYzUwZjY0Y2EzZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCoVXVg7uvCjCfucbU0eKp0JyljdJNnGKq7NMl/SkFujoo\nl8AOSVzJrcXLO7TtZauuqx2vx/D4a8WRLXz4kHUZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyPsEjR1QxZlauwIPVcr2LehJ\nsdYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWtfBQXEMp7jTeyS1o9EhRwRlZ/dMpCQYYkEX2v4ju/MCIAaj3I5SEJ/U\nIRbkRnBfH6db68nXmaprHVeoAdqwMIRL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZcQn82VtY+ZfUVwjgKdnVl0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2M2YjQ4ODQtODY4YS00NTQwLWI0NTMtNzA1ZTZiM2E5OWMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4OWEwNzI0\nOS01N2RkLTRmYzYtYTVlMi1kYzlmZWY3ODM3ZjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS9stHE/1oZdNojg4PMEEKMsfvSicptdrep5VyIfsEQx+hNsx85t2Eq\n1LrigLffi9pFnDyOBzE6IPTqJJTdTtg1o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQUFzEm\nmwH4P6cP9hAU90/lWan4szAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAJek9sxodjE21KSsGXOiv1xIf0qFQlnNBL3mMdrG4+G8\nAiAOutIGEfT6zXWbYpg4p0PZAiozuPRHEfkyETV4I2lEoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1961", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1961` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAYCYWvnUw5O1nDo81TADiku+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NWUwZDhjLWE2ZmQtNDg0YS1iYjE2LWVkNDdjYWI1ZGQ4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ2ZGZjYTYtMTIw\nNy00ZTI1LWJjNzEtMjIxNWEzMDIxM2IyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExhNrszHHN1nKtbwfATqRrElUaPhxljFzMt1FkIuJ1sTj2P6xSur4I3MxIDE/\nKce905GTyHL7u3vzz0DyzuP6waOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkpj8KsT3v99PiBnSxLq1uhKhY20wHwYDVR0j\nBBgwFoAUc7oL3n0Ap0nh/ZcpEmRBV8ZXQ6owKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKWQ+1DUfeatG\ntBUACN2NztpwYM7coWJdF8n2Ev4I6FQCIQCfB9DKC2B6LtwItpINhpPXVrozfXqJ\n37MJ9csQuKekeA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARRX2/Re3dA6vmW8jO/8zwNMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTVlMGQ4Yy1hNmZkLTQ4NGEtYmIxNi1lZDQ3Y2FiNWRkODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUVx/jJmczii7mFI/c2IBcNhXDCQa471Y2ZI3MkoehtjzZ\nvgXeNNUr21Zf9PUUEB3l1jzHPm7JlRztO6ALDymqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc7oL3n0Ap0nh/ZcpEmRBV8ZX\nQ6owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEmMdiOP+v/2TkecKXRINMtndidnDIgwdGIquuhtfqKsCIQDsNptBaMDE\ntH9HmjUjwgMYMzcnnKu6NUvlxZO3rVcN4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAYsV3nckVeYfW2RKS0YBpYL7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ2ZGZjYTYtMTIwNy00ZTI1LWJjNzEtMjIxNWEzMDIxM2IyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NWQxZmMy\nYi03NDY5LTRhNWUtOWE5OS0wNTU1Y2VhZDY4ZjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARcJpt6PXUpdmmrSdW5uP6hjDW116FofDo90nZFgoNUMXEPwxFFryIs\nswffqUJTNYYeIXneEZXJWKxPLVBB9tYQo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSSmPwq\nxPe/30+IGdLEurW6EqFjbTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgCpzMWQWiEc0Tfl9L9ULPg+zPoeXb0V/ZrBuljyjUm7EC\nIDJ+BVTUvXQET0JRa4/W9/SwXD919hn24iWrYTdYGO06\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1962", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1962` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAZKX7qoyGB790KPjXp7UJViRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyZjUwN2Q0LWUzOGYtNDU2Ny04MjcxLWYwODU1MGZkNDhiYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAyZmJmZWEtOTI3\nNy00ZTM4LTgxYWQtZmE4ZTQ5MTdlNjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/25EI+10QF7okDtSQK+LwCJiqrrloMA5fZq2LnsOj2P990jov79Zp9W1rGWC\nojlUT0gNiZhvv856PXXmHdVamqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvWqNPlKRVcgY5VegoUohjYjmP0AwHwYDVR0j\nBBgwFoAUxn1ob2u42ybI1f2FHEtTTSXv6fcwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKlbKX6sTZls\ndR3y3ZP/WdMGFlGVW+BPZBP9gONhl698AiAxf31bHzeirdvYPxZR0YE0K7lFFXk+\n4S8hNwwSBOWDnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAczOAR85KuvpkS0rx9/1HXBOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmY1MDdkNC1lMzhmLTQ1NjctODI3MS1mMDg1NTBmZDQ4YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVHEBhkXeV9C+KSI4+fXDxdNKwqHtlxG5JgKX3inUGjRPX\n/LD1LTCuYGza+13d5f2W9ad7VXeUh5y4RhGt/O8Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxn1ob2u42ybI1f2FHEtTTSXv\n6fcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCpVGtjwEWy4myktFYvzBA6COXNRA3tM8KrtTGIvwnxcCIQDaPhTVL5uQ\nJTGPEkPSlSiObEOwYLCz182g2+V11VGezA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAa9iwvzw/T3QdiKn8fFaNN69MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAyZmJmZWEtOTI3Ny00ZTM4LTgxYWQtZmE4ZTQ5MTdlNjdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMGRlMGY1\nNS0zZjkzLTRjOWQtYmVmNS04YWEyNTAzYjcxZDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARcOxrDegZsxgRGkdskSOWbOo9CIgg3scAdLfUIhA5gyIdCzyWUHGio\nJ+g0yKzcUDZ6emYs6s7PdyS5/P222Uouo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9ao0+\nUpFVyBjlV6ChSiGNiOY/QDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAPF9kk+gFNW4+DAAy86ZlKIPiJqCt8QwOtXtHE/JV2UY\nAiBxsFUmKIqo1GZaVt/uLRVsKxfSUhKXE8q9VwNQ5vpmLQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1963", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1963` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUin9q6r3R69c35X3md75/XOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwZDA2NzY5LTI1YmItNGRjNC05NmYxLWQ0YWUzYTNiMmZhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNmOTdhMTItODBi\nYS00N2YwLTk5OWMtZTNmZjg1ZmQ0ZjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiA5hadKXDV+QKKEEcL+/aS/tZxlCDBeOk1zgCiisror+yMQoLgqFfCybfjF3\np6hEbFvudrepGH8OSdw2jVKky6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnlHjyjpY4mKuDes+iiNRQce0xlAwHwYDVR0j\nBBgwFoAUtNyImd7Lt28kMbqkVqV1N3IllsowKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICAMjyzu+ie5\nr70xv9A4zq8UqxwM+ctd9JIBlj7LKSXlAiEA6eU80M1kFZw+bMYAFoCdoojoBbFC\nA36A2F5toFUqZWs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaqVaBTmCTp8UFLVYdOGcyhfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGQwNjc2OS0yNWJiLTRkYzQtOTZmMS1kNGFlM2EzYjJmYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjIHFbnXnI9gZGGDO7mAK3egDmdNt7ZVY1hQeL0Rg59Mej\ncrsAuRge7OE0RNU26AwefxfnpehiKC2XAVFaijG4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtNyImd7Lt28kMbqkVqV1N3Il\nlsowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJUc0nFdN6Qxu3e50asTwTGgak2wyEaYkuwBgSNltc3CAiBLU2yoDpc4\nGVDS1nS9HiA7RA7BSFzIRsh2QYcrKSqktA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVLObSN6eLaJhh2btTuS7/mEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNmOTdhMTItODBiYS00N2YwLTk5OWMtZTNmZjg1ZmQ0ZjcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxOWI1YTA5\nYi1jNDY4LTRjMWEtOWNiYi1jMTI4MjUwNDVkYmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASz85+1UhYAykgGPc1fKN+DztWnPoCyGrh9isASUGJHaCQ+NqkSgwkL\n6CurSkbPsNz7IWlyGPv4MbK9+cIXjwCMo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSeUePK\nOljiYq4N6z6KI1FBx7TGUDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAO7zkXeONPjOsN6aBVKDow3WBMNOUVj4xbaaiKvRyjcv\nAiBJO8eXIgF5T6ldBEKiICZok1e2G3FSzsX1B7klcA8Shg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1964", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1964` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQ2oCGV1r9y3iM0eo8UgWwQIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiOWEwNGIxLTQ2ZGQtNDQzZC05NjFmLWRlZDI1ZjVlMjE1MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTczMzFiYTgtMjEz\nNi00ZmI4LWE2Y2UtOGVhYjJmMzM0NjVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERV0OnlOuIloJ24O3ub1VdEoBtubMaoOjCYPA8X0ASHAuPFbCUjGgtZHkOsct\nx5fKGNudxj8tRWee7qH5ZXP0eKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXPT1so9+guHcTA0gMrGCAKedEZQwHwYDVR0j\nBBgwFoAUO4YPVAxqs3YUlno0hiQo7QZCMiQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBJdhYso2gxxGG1t6iQI7F1xBLEjDdzYrWhIgXScYGOcAiEA0sORLY2+5eq6\nvM7Ih+A5hu7gAuiIxPMaBCqm8xeg9YM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUksZXLMcV+tHzPA3vy6/z8QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjlhMDRiMS00NmRkLTQ0M2QtOTYxZi1kZWQyNWY1ZTIxNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwZync0LLv7JjwJjpGrEXD9ig/eKEuQ7+5xyTPbESaY4GH\n9byj4aU7wYAFcksB/sFAB15q7rn3DebGNfCQCr4Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO4YPVAxqs3YUlno0hiQo7QZC\nMiQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfzobC1/zb+n1ll/wXf2kmXUhZQDiM7+3bud4vsTtoh0CIQC94/jan6KC\nNwKHYAKw2Z3RdU7R96rDXnXbnStUa9wJZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAUQPBgdXRZr/X0PzNGdhckPBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTczMzFiYTgtMjEzNi00ZmI4LWE2Y2UtOGVhYjJmMzM0NjVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYTI2ZTUw\nMC02ZDJlLTRjOGEtYTljZi0xZmVlZWNlN2JjNjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATVf5HzSE+Wou/z1paE89SdqunDKH7w58V9fiAtRNiwxl+cxThZPeb3\njpQ6OTaALoHyHlK4ypDdpc12rF8nANOFo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRc9PWy\nj36C4dxMDSAysYIAp50RlDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAPIU5VfNuXUiMCQkReKUlHQkCInu/TUSeReKzLGdRopK\nAiEA06jLtlNkGmHTxaIixf4+WgWAiIFPt8ZMw5WsVkyyG3o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1965", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1965` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAajqVWhJJKevQRAisgE2Pjh6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxMjk1YzhiLWE0YWItNDkxNC05ODI3LTdhNzM3ZDcxOTc3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMwODZlZTAtZTRl\nMC00NGQ3LTgwYjQtMTk3ODYzNDFkZTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs6nlrRa0ss76eG1mPBslRiM9qA/78YyZtPTp7TEr1oGOb3zXuAsKyTUG/qoY\nlUdN2g754DOcr53Id9mXJEIGwaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURczXR6oFAc3+1Cid1gOoi1l64LYwHwYDVR0j\nBBgwFoAUCtUu2XlvGSL2bw1Z/XUVNaCF8TwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDkLTDm+HubwUtTpz7aeMkLZnSfxARnBxea80vHqDQw+wIhAJGWyH5/NWE9\np0CxFSbHoRgQIPbKUUy9VuMRn74cTgFC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdcXmPlwiK7ZKMh6e/USmSDOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTI5NWM4Yi1hNGFiLTQ5MTQtOTgyNy03YTczN2Q3MTk3N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV2elNRvNlq2OtCsJMJhFZcQHl1ruWJqRjCbImxYfVdXKW\nH10UQw7tok/3/jQUjvrCgLzsI86N4ERM21r8PvHxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCtUu2XlvGSL2bw1Z/XUVNaCF\n8TwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGw2Z1L0myB+pCz1veTy7nSyyz6I6iM8mPuzMX/uzXQ4CIQDMe0jWl1ER\ncNP62WcMl7m0hfH+3oznk1ysnizGS/EFyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAYt2eWrHj08qIjqFIH5L258FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMwODZlZTAtZTRlMC00NGQ3LTgwYjQtMTk3ODYzNDFkZTc3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMzQ3NTc4\nYy04OTE2LTQ0ZjAtYjhlZC02YmRlOWY0NDNjYzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ6Ag/XMtlsEP98TmARmeLTBgOnhORhu+4Iz1fITEgNGjqakTyKDJbz\nEDIV2axmFVjro36EtGb5073CcEQFdQz7o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFzNdH\nqgUBzf7UKJ3WA6iLWXrgtjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAPB9lA4vQF5e0hrftcpJTOxFfxeTY49yztMEgFzEjqSU\nAiEA9pujgWztsqFv9LY8NHgucCmCyN6NqokLaNaZUM6UIUs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1966", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1966` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAZLYBTWz11xqb4LSwMzwbkeZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjMmM0OTQ4LWM2M2YtNDk5My1hMzkyLTA1Yzg3NWFiYWZkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE1YTk4MmEtYzEx\nZC00M2JkLTg2NzItZGE0MDE5YjRlMGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2D6LVVuMdAzmFpP71HRLOWmT0SDbUwo7S+aXE+mm9MvjYcN5dZkgxlByAxI/\nLWWqZU8rSiD1SYFZwSE7GRfnjqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNmHp2vDVRnZDBcgb+MjrpO0S/uswHwYDVR0j\nBBgwFoAUvfr+dURETsbIB7/EMdpz8ajYVQwwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC3\nGe7ZAHj/qRWiWWXN0VDJV7GTYBqjWwUUXWDzX7KTvgIgYgQ93rJporrRknnsuBfa\nugG3/nhQehep6hoCQsEtWzo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYGE8Q5rEVm9qM0pcV1tmuKnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzJjNDk0OC1jNjNmLTQ5OTMtYTM5Mi0wNWM4NzVhYmFmZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWZLk78qTaBo/m8QQSDVlp4RfsIH7S+t2BJkpjsTKGLwJ6\ndZPKan9afJBp58W1aAX74m/l4/PTxC79Mv2AZwG3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvfr+dURETsbIB7/EMdpz8ajY\nVQwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIPJu98WPJc0yym+xIH0TmxDGohY1EXZb3higoaJCEpEAiEA8ge8pSw6\nnZ0oECmV2EmnqJGeipHZRKKSDemu1kE6pgM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAcSt6DkCHzLDWnSQWbOa1iJ6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE1YTk4MmEtYzExZC00M2JkLTg2NzItZGE0MDE5YjRlMGZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlOWZiYmRj\nZC1hZjM2LTRmNGYtOTk1MC0wMDQxNDcyMmE2NTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASxGHIHsvqgA/aSzSUa9ai/b0DDfpiBZ9qRwQ+WyyQ41t61eu5MrrXI\nhn+UZfYhi9WZL3wzhdISSW1Dk4az9Puso3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ2Yena\n8NVGdkMFyBv4yOuk7RL+6zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAKMbH4WvGxwEk+pO+HB/eDJ6ROPzzjy9qJ8IoQKsLydC\nAiEAwqxTyBIsTAksno5mUDgePXwc7FpRMPFMUq7oipYzjgY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1967", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1967` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAXiG43nP0krZ8o3kJdQKejgJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxZTdhNmRmLTVlNTQtNDA1Ni05YTM0LWQ2NGMwY2IzYmU0NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIzY2NlYmMtZTIz\nZi00YmM0LThkMmYtNzUyNmNiMWFhOGMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGUFOuSBolG7NV+iTjjOXsLxgu0uHN8PdSMeRRZMc1kEQ+vHC+TPlrN9ZQiDD\nKXB6IQewHLVyxPoyQAOVbm67gKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrEJNQS5zqTfO/VzrSiYO9sBaBIowHwYDVR0j\nBBgwFoAUNAkmVbdM4GJjjmEgdQbRKQvEpPkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDx4mZ2M/uc/QGPDbkIaegWCNqXAFNvYN3hD5o2ayNlQAIgHz3J\nB30Th2/C2QGEkGMCPYFth5enAAH2adDig0Ft8Zc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW7/9wM5MlI2R+Mtl/YladHCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWU3YTZkZi01ZTU0LTQwNTYtOWEzNC1kNjRjMGNiM2JlNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATC5yizz6ePHosHEvdx709U4y1xtAVB5/gvvggJNxJq0uij\no7BdcwTrnjXTPv0lCsNMrF63WEK2U9oT/ch6Rdp7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNAkmVbdM4GJjjmEgdQbRKQvE\npPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZCAWCsHVPm8VVDV3kCW3Ht8eyI/ky1LF3tDmIHa8yuMCIQD7Aeze52AG\n3Nx8C2p96MgQ6ADUDkW1U2vQUmLboxqgNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVE1qRkuLtA9hHjNoVDYkZrcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIzY2NlYmMtZTIzZi00YmM0LThkMmYtNzUyNmNiMWFhOGMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNmY4MmZj\nZi1iZDhkLTQ0NTctOGYxMS05MzkxOWNjMDVmNzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS0cWJ+GsXd4L2mrwGl7I9aVw/DZCVikTgRMbQQbEk7y4jGg4C4KAXq\nzi6Waa3x9qVp0f06glNz4ZbIoevClKh9o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSsQk1B\nLnOpN879XOtKJg72wFoEijAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAJFz3zYQ1+QaU6pgB9ZOws0fHqvoJBsu6v9U+h8nVikw\nAiB4YS4PJ2lfBOK5uqAZ32/hHVR450cfszfgiMCc8KRtyg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1968", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1968` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAZZBbRFmJBjanzmFHrGL4BF7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NzhmYjI1LTRlMTUtNDU4ZC1hYTRjLWY2OTE0MmMzZjhlYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJiODZlNTAtYjQ1\nZS00ZTVjLTllMTUtM2U5ZWVjMjRkMjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoXDza2uNYGMCT8/Y+WSs+C3Jyg9MlJW5CESooNmNz6MMvakNhaxzdP77KOe6\nKHff6i8P87NjkxaNQ6uUUG5Pp6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUne8aU/u0fD6CNXYwKjhgXowMrLcwHwYDVR0j\nBBgwFoAUb9QPxg1jP0HZLtG5w8l1aSr0k0EwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDbenFsYED0a7Lkud90OuGncmZfHFEPaKEm263GB9ws3gIhAJIx\nuUG5IwL3SB+PZE393EmT3kqPda3h3347qVGWpqXF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATq0gHCJ4F4TcsNoPfm74x5SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDc4ZmIyNS00ZTE1LTQ1OGQtYWE0Yy1mNjkxNDJjM2Y4ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6x08O1KNFAMei3rUSBnGonzuwQzknlUtqYc5BC4KE3vla\nnZqyJ1dK1bQQWawXkiMIdlL7TrzCQXcRA6b7wZ4Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb9QPxg1jP0HZLtG5w8l1aSr0\nk0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAICDEv6MUk5+WzMB0BTuxC6RjR7XQOpfUTTT9Hke8zx2AiEA6Mbo/zEN\n/kxDSGfaa2eoo/GX7/0eEUf9Hc4IHmP1ijg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAap9zu6Obl05daViW3KIHE3+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJiODZlNTAtYjQ1ZS00ZTVjLTllMTUtM2U5ZWVjMjRkMjgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNmJkOTFl\nZC0xYmY0LTQ3NTAtODQxOC0xM2RlZDMzNzQ0YjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARcIElhMgZTyZXzWGERWFzLOKYum/sXqGHBJQH2+/UbnPtxiZrMSoB5\nMIAfmPvSBIv2o+54GEION2RQGK8kIUsRo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSd7xpT\n+7R8PoI1djAqOGBejAystzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIge/LD6WJBACNevfF8DDSVp9TNpCMeEEN4W51/j7aeSvoC\nIQCzvALV/p8KoJb/3UAzAWSIklov19PwRy9pAkbFmliO5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1969", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1969` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYlts5mRiWrvzlXSHBZOu8FlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxNTJmMDAzLTJhOTUtNDI0Mi04OTEyLWY0NTA5ZTU1MGU2ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJmMzIyYzEtZWIy\nMC00NTQ5LWI2MzktNGU4MGEwNzkzNmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKCDbsvzvQGbyHfewbuBSDra5q5NEnORzyZwTkQXwGctq20T4E5KIMLD0AiFa\nBLbcIjTKvPCIgNKm/Hc0CDIVW6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFG85FxKNbMYM5pRuo/qzvxXeILN/MB8GA1UdIwQY\nMBaAFJWTLy4Ai1jG+jfPKYSl9vo30qY5MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAwmZpKN+3/3yWce0TdqihJx9HmvZ3H9XV\nKk63Tymh8agCICqgS7+RP4t7QAfxFzD7GDzil15oj8sFfHy/lYAR5ZiM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe3DqKI0U9Ub67hJbLbMzdjVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTUyZjAwMy0yYTk1LTQyNDItODkxMi1mNDUwOWU1NTBlNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYdSAUKr95qH9cdUd3NXNgVTs5yxq8gJ+/j7ztD1rn1lSz\n6q0MsH10Q3BQXd9tsMiOErlxe2iV5UZ1y4GozmRRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlZMvLgCLWMb6N88phKX2+jfS\npjkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgak8oJg21s2yY1hoytF+s7tVIbaJweMa+u60iH37OB4gCIBqBKGZmNdW7\nIBUoQqNtR7A6xQ2ZR7DN778A5U1ymZuH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISARxyQF5XgnVoK62m463axASuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJmMzIyYzEtZWIyMC00NTQ5LWI2MzktNGU4MGEwNzkzNmY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYTg3MGQ5\nYS1mYzE5LTQwYjItOTZjZS1lNjQ5ZmUxYjc1ODEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATmAWJQ8v5CwoGzpj7yq4GbTS8bqUj6oXofDwB+dZ759wXvmNlTJutL\nZgGPaSBtDkbDKGEZqfOvyDKoFYS5old4o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvORcS\njWzGDOaUbqP6s78V3iCzfzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAJHKH86hQHio8Z/GfLPMsSs/wpqN7c1SAOvj4p+Q0xqZ\nAiEAw3EQaqXT5rvozaqx8YXsh4E9CCDaGUIAb115xuELk30=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1970", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1970` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARVXhmckW8PWgwHPrfx+CShfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0MDQxNzFkLTMyYzItNDNkYi04MzZkLTlmMjM2MWMzYzhiOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI4ZTQxMjAtM2E0\nOS00NGJlLTgzZGEtMDU0ODJiNzcyMjJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiy8FL3xvKy8vPweklnveXB2LIRUueJhABgtbfuYvP5A7xZIgIsH/+rHbjamp\njhySAMURnNPdTrWbDsxSZYIdLqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQxKySDa3V/777lzpi6aMWjWiZ1kwHwYDVR0j\nBBgwFoAUEdKxugzO88NH4QEgDNd9/bEcyQYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgcsXBgB/QtKGh\npLA/OVD/kd6kE9VGFeEcxfMrDfnI8WkCIQDz8f+YU7pkll9SWgbAQVVz0IujuJnr\noammYF/spk8SCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWyJh/V6wOWeJx7wpswqhVbxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDA0MTcxZC0zMmMyLTQzZGItODM2ZC05ZjIzNjFjM2M4YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7K7HNJG2CNQtRlR0CMglh9IwbGnMQUfcY7DypB4JVy7Rd\nRH4MwHKFi+jmro9ZwtLsbrJ7PsTxU321wHSgrB9to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEdKxugzO88NH4QEgDNd9/bEc\nyQYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI4LtNJkx91S8p6J2p1r4IAw/UzORL2O13ATcy6TKwKOAiEA1Xp+RRCP\nPK2Poj47ta5dvODFhpiqatyX2LotG7+uFMs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAfvySjUdFqbYS1bL5TmimaXKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI4ZTQxMjAtM2E0OS00NGJlLTgzZGEtMDU0ODJiNzcyMjJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4OTNhMjk3\nNy1jY2Q4LTQxZDMtODNiYS0yY2MwZWI5OTMwNzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASjRGp/Zur6Bg5zPYebW1lHuZ/sTWuIHiwOkEG7ATvhwz5ZNnMXUS3W\nD42dsoEQVLrOJhTeJVv1jDCOwzJOHi+To3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRDErJI\nNrdX/vvuXOmLpoxaNaJnWTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhALIFoL2sdqIRJ1v5ptr5ZsZiW3sMIR9sqz2FjzTsxOIZ\nAiEA79jivJBw3crR4zOGBN7OuljN2MP2eXMXdjqsLhRXysM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1971", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1971` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISASgI2i79g2xuJKTc3clTqvDzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1NGRkMDgwLWE0MTktNGU5NS1hN2E5LWNmNDQyZjAxMDNkZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM0MmE2MTMtNzdj\nMi00MDZkLWFiMTgtOTA0NTJhMGM0YzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEnJT1jc0XesRzzk97WLgz6T6/7BDwc/MZMOGXRhhGT2HMxn6AZuJMxeNsPlc\nQn34ElM7U4HxbgAHQw7rTzNShaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIP3LEKxMOGkPF0yuVT1f1l3goKkwHwYDVR0j\nBBgwFoAUNcKX8HZ9CHDYMTUM00bYsGzcZkUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgacl3lrOiLMJ9\nTazKUlJJen0+4539eCU3R8p/uFPHBJYCIHsub3xeOrIWMH9LKtO4jxi2tXgbuZgc\nA0nrWG/hMHGa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQspoLSNB4WVboWPon93mtGzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTRkZDA4MC1hNDE5LTRlOTUtYTdhOS1jZjQ0MmYwMTAzZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStm8Ns+j+lzv+FVjwDvi8doFknC8EUUigQfEwMFqSMLyiE\nW8zasQM8ri+r3+E1VM3TxoKUI0dWZSYxb0IBGsDto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNcKX8HZ9CHDYMTUM00bYsGzc\nZkUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIeHHJ0rX48qhwmIfrB0xQlNDi2uEPEk+sIrKMdF2cZoAiACc5egL9xa\naIoUHtJAgfxkA3+RK7V0LBD3oeIZixUx0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZWWKbDp333i5qIP8HDkZXHpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM0MmE2MTMtNzdjMi00MDZkLWFiMTgtOTA0NTJhMGM0YzU5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NTcxMjM5\nZi1lZGNjLTRlODktODc4Yy1mNWM2YWYxYmUzYmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR97i6qrgv7l4YeH+Xtg8W7ku4mTHUC+PRCWbmVHt0bS9WHZIP/NLvx\nUAjp9wCCHCradafkLg9OBZ0J+iSFK4foo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQg/csQ\nrEw4aQ8XTK5VPV/WXeCgqTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAP14jf5ReBmMAEGKyY3xvbHc+ngEFTsrfU9JvgHxNq4e\nAiEAo+SGoa2xYl2P61soP1caQ9rlKb5yXcJmu3nYF7v+Gdo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1972", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1972` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYPzbwPrRDHtG7QEhWvIidJyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NjRiNzJkLWI1OWEtNDMyYi1iZWRiLWMwZDg4ZDkyNDViYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRiNGQ2ZTctNTc3\nMC00OTFjLWIzODktZWQ0Mzg3NTExOTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECdYwav9Iwu5DDcGmgozS2GU6FCh7gEjVlkg5wDgi0cZ1MjjA9/Q+8GHtB9Do\n0W/RknyqBJzNc2eq1YaDUBxee6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOwL/APqv7TcxD4fcBRpIVV1Qo48wHwYDVR0j\nBBgwFoAU/ZMNfC1jQUSWQSYG5EdlIyVxXskwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDE87lkeMNI\n+MbEmFHIZQqWDBWyTnCSm5wMCFDl2nkWSAIhALiwr8vW0gkz860lpqKLRseIP8ox\nfFCtpGedUeXQZDFN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX9sJOqEQr/YAGhAOIWZL6JjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzY0YjcyZC1iNTlhLTQzMmItYmVkYi1jMGQ4OGQ5MjQ1YmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsuZo9gBTpL5Icicbqwzy4tI+Okl01pT5GOL1EkbwNKX37\nRA1IHTwmc0EYbg5GggMAvNB3y1PXVTAryhiPv0k6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/ZMNfC1jQUSWQSYG5EdlIyVx\nXskwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMRdU/q6No8iJGcvQBu/44U0lSkuygQpW4yCksowHixECIQC5MsyM/ifH\nKvd98jzcpdFHn9BngcJbLX5snrNiO352KQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISATGACr6v4557CZklNxfeBBkcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRiNGQ2ZTctNTc3MC00OTFjLWIzODktZWQ0Mzg3NTExOTE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyODRkMmQw\nNS1jOWZmLTQ0NjMtOTJiYS02ZGJmNzMyMTFiMDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASoZiWhfphmpDzA8ACALi+inx5IQpLl9X0DphMhbxRq01bcmHwn7AIX\nLDIXQNLADUiZnjBDXGRndm06voAbWPFGo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ7Av8A\n+q/tNzEPh9wFGkhVXVCjjzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgYRSA4UoZdCBhG0o7ZHktw0D11dNinFzulnl/gQZ39OAC\nIDpCN7BLKkFHYt82valsRxtBUZMgjLAo7QwvchWfVQ9l\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1973", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1973` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASPOvwK6LlPe7jLzAdl/CT3ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiNjk0ODhkLTJlMzUtNDZkMi04ZGY2LTA5M2FlNDNhY2M5NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDNkOTUzYTQtNDRk\nOS00ZTFmLWFjYjQtMWY1ZTUxY2UyMDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb5PSBWPinevXs/dox0WeAPnJn6n/uJqOV8T16asBWKiojpXo8Xs7HULB2yyJ\n7d6LNzy/KHMrc8AkOO4sbz9kgKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgpvNNga/tp38ECFB/tXiidQrXpYwHwYDVR0j\nBBgwFoAU1PzuucYmBNGyyAqvDl0qieNMwZswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHNp/5O4iPYqFtF3Y0VCCgk4KVbeS3YBXmrodwSvITQTAiEAidjDBkmhlff0\n1x+jHQMmyArbNK2hV5V1w0UmQiKjQOY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdb3z4Cg3OZyXElMGpITHI6zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjY5NDg4ZC0yZTM1LTQ2ZDItOGRmNi0wOTNhZTQzYWNjOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATog+kbsx72kIaBODo8gzrqp+pT3qRwbFocMNbKaN7oo0W0\n823jN8jSvhVmHCqQpCz84dzGXtkKmgXG+KBqm5Bjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1PzuucYmBNGyyAqvDl0qieNM\nwZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJindsXxpw5O0ak4TY2ResYivVCyYRqwBQdaXdcnjTioCIQDP7HzaRNpl\nbVSqshzxlS/qC2XlZq2E28rkwQJzrpQ1fw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfNDhLLKjJKZ2OPdC+xmsXclMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDNkOTUzYTQtNDRkOS00ZTFmLWFjYjQtMWY1ZTUxY2UyMDU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNTM0MGY1\nNi0wNWQyLTRjOGQtOWY2OS1lOGJmYWY2ZmU5ZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARWtYWx0nVT3S/rip6fMFO+P8y5wFW190wxA+36gHHdr7vUMMEydTSQ\nY6RDV727MkiO5hRvUrRBmy2bLOIMpjJ9o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSCm802\nBr+2nfwQIUH+1eKJ1CteljAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgK3vG6561kPwmqk5smMHwOe5PTYnmImr7DMOFrvpNcYQC\nIQCMJtRelB7yiCkmVUa3h7WQtLr7WT+p5xJ+PvA7CaosjQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1974", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1974` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfy7FjxHCgocG92EpWd8R9LWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2Y2ZkNjk4LWFhYzctNDdkNi05ZWQ3LWZiMTJlOWQwZWU3ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ5YzYyOTUtYWM4\nMy00ZGRlLWJhODAtNjVjNmQ4OWQ1OTFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbnFWDJvo64t11hxBXeJKCVYcVWDMdGQRnKCsAHg8yyNdNj2cis6Rt6IBBTxu\n7siUMWt20nurWenXgbwxYLemAaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUawHvc2JOMo6iHzLkdU9oRJRvFJYwHwYDVR0j\nBBgwFoAU+H0BBDnym4tyF2IwUEG3mrtEyNAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIE5+GZEOfwVVEXlogUDjeMTjOoqRzNwJF6jYUsj9VYG9AiEApaC7EyFi9c4H\nZjX+z9xy8S3HGx3jiOJVg1OtKHjthDg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQacGPNQr28cyZ5WZFsERyT2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNmNmZDY5OC1hYWM3LTQ3ZDYtOWVkNy1mYjEyZTlkMGVlN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2X1XXTTM5zNwfgN3A1Mfi8hJG/rQH1JVKXiB0UCfuSZH2\nurZJmNzeECCpQDJLtDYdPDDQxfj/pfRc2eJtadcno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+H0BBDnym4tyF2IwUEG3mrtE\nyNAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMcU/ya1aIXMXDOo/RGqjR7oPTEp8hNA4kyd7ilzNL+hAiEAr2IeC4r6\nUHE303o2lncszR11B1M+2IJuAo4S5SxemOE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAW7YFkfi9NQY1NlNv3IiqaKXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ5YzYyOTUtYWM4My00ZGRlLWJhODAtNjVjNmQ4OWQ1OTFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1M2UwY2I0\nNS0zZjk3LTQ0NmQtOWQzYy03MWUzZTY2ZGZhZDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARg2JFCW3UTeTpIOn9DBxmKP0Wdql6Ap0L/RjZ+6fuZb60bQh34Z7g/\n41oKEXtn4EbISFESWv8lS/a9ntAasAQ8o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRrAe9z\nYk4yjqIfMuR1T2hElG8UljAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhANChBnITCMaWpAL+XsLB9/vErlzkvswHvshJg1OCU4ct\nAiEA4nZgPWvX0OJ9MYTUWiMPivsjJINxLGPfOl9Yd3/q9aM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1975", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1975` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAbAqxf1xvM2nxe8vPr+BMhaLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNzVlOWVhLTQ0MWEtNDdmYS04YWU5LThhZGNhMDU0MDdhYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFlODBiMmYtOTM5\nOC00MTA3LWI4ZWQtZTU5OTQyMDRmMWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ1xBG9sVNDLuMmiYkAPY+c32ec/Vv5RKl7EoLxdsb9zKU27x7QhtAu/Favlq\n3nO57+WT5nTwV5t6J/8EBAPRwKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD17owXDa9HBvybB1depgipQOVF4wHwYDVR0j\nBBgwFoAUcxvNV4pgmONN5KS7uoRYPDK2qXUwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIB6l\n03RB/sd02qDjPA8VOThFhVfOSQ9HchAwTlfruwXMAiEA9phwN3pAe1rZgegY7/l1\nk6iMAcg3BCBAHWNvsD+1B+8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZYhkk20pF0kpZojpW/wnqnlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTc1ZTllYS00NDFhLTQ3ZmEtOGFlOS04YWRjYTA1NDA3YWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEH2RCvDoFsmCtVhidfMrjF78DxzSnDD2rwHDUqPuq5McG\n8LvIbT2SSibJwbpgZBJO6WaQulStoOo/WLtshBHfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcxvNV4pgmONN5KS7uoRYPDK2\nqXUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK2/MebEUMW9vsK+0Ic1huImVkGXocLdf3nOtE1k+eFoAiEA155aDX23\nsj2aPUoWmbgWdrrXC3y2/UovMSVfjbfc9gk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZvQLDLeC/48AwZMTVsUmyVnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFlODBiMmYtOTM5OC00MTA3LWI4ZWQtZTU5OTQyMDRmMWFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NGJiNWIz\nNy0yYmIzLTQ0YjgtYTkyMy05Y2Q2NWU5NThlNzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATuiungoKTVuhp4uPArZEJ33OzFfdzbOTcU1ev5e1SBPjB4b9zsW+sf\n1lXh/lB3vi23naoWrNQ8KZ+vVj2oULoqo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPXujB\ncNr0cG/JsHV16mCKlA5UXjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgb7nehROEj/NJj3eZ6T9QYFKEIlA1hxq3FJ7Aqqi+lbgC\nIQCO3qeumbPZd1Ipmv6F20ZumY9cS1kyB1rZYQnSuvZ1TQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1976", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1976` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAV665Gs0J+xufYMEDwqhDJBxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmODQ0Yzc0LWRmY2QtNGQ5Mi05NmNiLTAwOTY1OWQ5ZmFkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgwZDFhNTAtMjli\nOS00ZmMzLThmYTEtMDNmMDNjZWUzZWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw4QoVs4di9/AVgLCbDUcsnwwsp4SSkyvxZZSsX9QmuPxqDGyBWIgLlMvP55T\nbIPPdxafKdGBiYDjqUf1fRXqkqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+9nE+dDpz0kSYfREmMMOlwdkyYwHwYDVR0j\nBBgwFoAU++VNUuNiHg3M1g8Rj69KNjZ0zKgwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDoO3ytDNByfwgJ++obqUkRBJYezQVz8TjAxev3430VtAIhAKQW\n+P1QsBgur+2tqzNe3VcgEqrRZgC/MBopFjPjOhEx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaQyIdgYlywwg9mg38Ipj2Y+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjg0NGM3NC1kZmNkLTRkOTItOTZjYi0wMDk2NTlkOWZhZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5KUnyHmiixMQC17xRcUHegPlCWGlrasDlUJjBMyVqIA6Z\nPsxOW/x7EEsx+CTH08FxeJz6BBkef7HRcFDNdv1Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU++VNUuNiHg3M1g8Rj69KNjZ0\nzKgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOZYh4s4Ba+cL2skdt0JnS3VSzizEJrDYHyk+rTKY1leAiBr1Tf/Eyj6\nUe2kDGiqEsoT4ldBvw8wcxx3VkC4fHWg5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAW7NfgcmH8h2O1pyQWm8A3u1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgwZDFhNTAtMjliOS00ZmMzLThmYTEtMDNmMDNjZWUzZWE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5Y2ZmMmEz\nZi1mYzlkLTRhMjctYmE3YS1kYTdjMzM1ZWViMDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARRoF3ImTCSDP4i1MrFQfFdmaFsMbkuCG5N61JowGez3cElwa8vMVCQ\nRH75MkSxarggMpVkoWDqvpk+hTGDyUpio3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSX72cT\n50OnPSRJh9ESYww6XB2TJjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAKfM0EELr9+88dW3rRV3cMKpQbOwhppw0AJ0zlJh6X5Y\nAiA02hcpAQLyrdZ/EqJO2XlR5F3dgnUFpNep8eIJMw80Zw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1977", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1977` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQdkT/ANsFt3wPQd6C8EQE7EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4MjZiNWI2LTExY2MtNDA4ZS1iN2U5LTkxMTUxM2E2MDljYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDgxZWUxZDQtMTlh\nNC00MWM2LTlhYjUtZjJhZDMzYWNjMzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpNtgeS90yDlOh0QSo/9hg1JeS1l6js4mZU99MkXhZJCIJvvE5IRw9n/nsrIk\n51JB3lEvyCR46lP+GlKu7iDkhKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgtNTsvEhFi2X8Bt0cxBHARWyap8wHwYDVR0j\nBBgwFoAUR9d346l8k1P85q7A5kT8KHV1WIIwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIEshTHkbSMcC2tQtxzNigvmK12YEVjVoO6c5s/ziSnEmAiEAjRWo\nTlDpD4jJVoVFHbef7iY9e+o5ymYjwa5Ne//pKe4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbp+Yr0chWQ2LlJfxj5UugZSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODI2YjViNi0xMWNjLTQwOGUtYjdlOS05MTE1MTNhNjA5Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6LTbvSEfBapGi2rw9DCdOqdH2WXdRKa37F5WuCHBvldhR\n6kcQq4vW84drv1xK3OISA6oHpkvTZEMDq8boydE4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR9d346l8k1P85q7A5kT8KHV1\nWIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSzATwGnLOHbFEDfyyO7agzYdm9LjMEkcUW6zmOr7g18CIE8JAg9uyH22\n95ea7PRIqqdVZgum2sXK4GAIeImDRA4I\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAWSaiCY10VHfyfA4r0jH8qznMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDgxZWUxZDQtMTlhNC00MWM2LTlhYjUtZjJhZDMzYWNjMzJiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZTUyNGU5\nMS1hMDA4LTQyYjYtOGMyMS0yZjAwNGU2MDM0N2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATnVXc/pTJwNTIaPGAB+NsYUVpDjiDXEMFjPzWwsNTOCheKuRrOVwqx\nlL/RxEje3enSq9MzWZyWm3szEzpu/XzMo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSC01Oy\n8SEWLZfwG3RzEEcBFbJqnzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIge5Ywjlc+pltEgSqVqct0SAiINIHRulboornfi7iGbFMC\nIFeQrKirJpzYlM28fAaorlPusHZiQw/iw21Acz24Ab1Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1978", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1978` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQRprlcX2CKvobKHmuo3xY2oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmZWRiYzUyLTExMjgtNGUxYS04NGM2LWYxNDQ0YTdjNGJmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZjMjA4ZjEtNGFi\nMi00MzMxLWFhNjktZGNhNWEzN2Y0NjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE7zMR/jqzDmUgIzeH/wKlx17cmTDVwQ1ZS8GtC5FvevvDHoUP1BcxkvVd0xH\nH2fEbOK0Mswkr6k1Zc8R8vEKcKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSLX8bIBmtdFNgpjEKizBtUNvci+DAfBgNVHSME\nGDAWgBTjO91Cdki3YrbPjzhwNrvslntkATAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICVNvqPdpP6mdT+hm0UNDgFHiPvRR3wM\nKLygRQwYzFwAAiEA6fa6DQYjLFWra+n7ihHFzGcU8Gt3fV0MSZbqo/Sd4N8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVUtojv6kpWNmcL0XyfQFipnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmVkYmM1Mi0xMTI4LTRlMWEtODRjNi1mMTQ0NGE3YzRiZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzIj/fhuYd+8/QN9BsZ2++mVHhSzzML3ZRiHExC0jojFJg\n4CpgsROfuCKPXcEoNCCoQ5nAb3yjmfZYGXTZoLq/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4zvdQnZIt2K2z484cDa77JZ7\nZAEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKYmqxXT4x4mS9slJdVgbqsNWprhcmjrdnBZOo166wi7AiAWvmwhxnEO\nENQpNuTgM+UsS0sF2AWJJL1gVCfxJop13A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAQlq6SwiZC6HSok/dFYAyj4LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZjMjA4ZjEtNGFiMi00MzMxLWFhNjktZGNhNWEzN2Y0NjQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMGYzNTRh\nMi04ZjAzLTRhMDctYTU0OS0xNGQ0OWVjNTdjYjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQQZRudm0sSH+Y9VnvKgKtjdfCc/axoiaUq04wfbktTmjVaB14SHlIW\nPqonT/0f6gxI196RxiBtLkMykQ04fqLHo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLX8bI\nBmtdFNgpjEKizBtUNvci+DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgbsOLeauhg3I/WmgsLbRv64jiynts740kV6hR6dTMS+4C\nIFJIo14HoUn9VntfdhUMKkQg2muyfUTfouME4EIr5MS9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1979", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1979` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQpuARc0LZe9evZJD+gCE7D5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljZDMzNGNmLTVjZGYtNDQ5Ni05OTZhLWJkNjYyOGU3YjIyMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU1YWIxYTctMDlh\nNC00NjcwLTk2YTQtNGE0N2UyOGI3ZDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn5mRQcVWsmVR/a1mL4tkT+A31yKlU7bYSRLiLdQAo5YTDjdcFnyXtx4XbQ+k\nVxkf8+g0YZlecxaX3+W6AK73UqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuFmvWVxOBNUawVZQJyFppsqLr3QwHwYDVR0j\nBBgwFoAUJ5C8CggjRc2hApZ23RroXbzPE0cwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEhKe6wuplWF\nU+8hYLI+8AWpj0iQusXyGFGz/8TUTSOdAiEA4Oxj8STOlnnOo5W0X7/QP5UTAJWu\neVDXmpg+rUpGOQE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUUqUj6nfNCvcaKTodAgTNaEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nY2QzMzRjZi01Y2RmLTQ0OTYtOTk2YS1iZDY2MjhlN2IyMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4NO30a5hlq4txf3cYpDqKzWGgC+qIYi9YKLDnTzWEW1Zm\nJbcYCKxPV3oFhhpz0otGNhOYzXrFxzfAKkyqJFs6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ5C8CggjRc2hApZ23RroXbzP\nE0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANCSX2sF2lxYiWIze0kyrKSGGCPhuR+CFGqf3zTW92E2AiEAm0DhSyjK\ntA0doXj0v6wrE1iXd7iLKhJtfHPlUYQ0GWs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUH/bV7BoC++WEvWl+GGkl3uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU1YWIxYTctMDlhNC00NjcwLTk2YTQtNGE0N2UyOGI3ZDgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYjE2YzVk\nMy05MzkzLTQ2YjEtODA2Mi0zN2Q3ZjlmMTA0YWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARlG+/B95yATXZioU0lrH3bUU/zTMm3gmtWdVnqLZBLV1923Zp2uqbB\naOdqV7/rVd68a6rjBcduEUdXegExjz+ro3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS4Wa9Z\nXE4E1RrBVlAnIWmmyouvdDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgfE/LzwkEUPoQ7Gq6YVNP5OFknTNLRJJfgOVAQ4reIugC\nIQCfBkxzGSZG/xBMODp8p2inv+AYSDHr1NzMi42IusM/Cw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1980", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1980` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAW4UlAQDvhQsMWJyFDT6iOKSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiOTVlNjJlLTYxNWItNGE1Zi04MjBjLTg0ZTM0N2RmZTIyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTEzZjlmMWItNzAy\nOC00ZWMwLTkwZTMtODYzYTRlYmY4YTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjGDITxJURZ/NUSI8oSr42cCBHcZylcwOF+mdUIpRzYz8XUSmtb5oUuiEUlXD\nciH0DrWGFPz5MDJ34ZmeNA57RqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKmrOzZVHDZUPaNSTf3HzdDCIOtEwHwYDVR0j\nBBgwFoAU03btwVas72M5dJig0JgZJt/rc9cwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIH0Pc/j+DNgg\noBBQo50BSWJw50qD851T2/E0YffZ5i//AiA222qQGyLn+jI0uuzHTm1N226Mjvb+\n8/cZIvoZ0tuY7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY2QbYmGp/3J+HNpZi+j6ql3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjk1ZTYyZS02MTViLTRhNWYtODIwYy04NGUzNDdkZmUyMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8n9/QJrn1Vr+XS/ZFFvhgQRLJjSN2BLNlHEVQTLn5c7X9\n6QZqTuyetWO3a+pNPo4fNjvvyi2xxiW7tW7/gkO5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU03btwVas72M5dJig0JgZJt/r\nc9cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH+o3y+mWY1J+fONPMf0NF2m2h5L8FcDGpnoYltQC86ECIAVD3sbiPXLY\ndQoqEKbv+CcjsQIXNcXmeSTzsnPWf1NS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfCwCb/6LcO+TBnydNKIE82mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTEzZjlmMWItNzAyOC00ZWMwLTkwZTMtODYzYTRlYmY4YTYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ODIwZDli\nZC05NjIwLTQ4YjAtYTFiNi1hNTc2NWM2NDA1NDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQzLFHT3zDDBwcCjgviWM9bcelVL5jRAgC5+A0Xd0X09nv9aW929llY\ny7j666YZayf9aB6z/+Xy92QaPaBhgjV+o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQqas7N\nlUcNlQ9o1JN/cfN0MIg60TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgJ4mBtGOcTlHsjKBrVDF8DJDJQ1P/Rl+E6/b+TLEvxeMC\nIQCCkjM2uDFFdjW8/rAIbEUzHvpVBE/ywAEewdixn2+I1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1981", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1981` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAV+d7nIPShgAohPHkXtUz4xCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjOWE5Y2NjLWIzMDMtNDk4My04MzZkLTI3NWViNWJmODAxNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVhNjMwMDEtZThi\nNy00MzYxLWJkODYtODQ0Yjc3ODlmZWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5wdEI37txZjQ3NdOY/ydnF26odBKv6mWp/0CpHo2mVn1gSreAS2t6Oe0rkiJ\n4+hOKAeCIAwl+D8FvfK5pvLFr6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmNXL2OPwai3fPP33Qdnb6zcDw/8wHwYDVR0j\nBBgwFoAUN9priC5kM7qzQIma8UrylEijnfIwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAoX6N6lda\nuPtZvshtKzKvJh8aIFeZTbHXc/7ONMrRbD0CIHPwxRA22jb52ryzVzvkukaRV0vN\n+QtyFLF+4iqDiFpi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAflq7P1cF7WShvBnMoEFLSyFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzlhOWNjYy1iMzAzLTQ5ODMtODM2ZC0yNzVlYjViZjgwMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV/MZOugzshcnHFbHPQbklB3PTyG0tRAvjRxizLFrzGHCA\n3Wt6IfsfgK0+SJSKNFPmy8qEnYYo+sZlcPrewGTko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN9priC5kM7qzQIma8UrylEij\nnfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOyOR1TSgaVvMrBV1ns+1Xy4+4BVis4ZyggcWH9Mu7bcAiEA2l36SXAP\nuf/RkAMYamTPCt8rFtJ5wZR8QZqsWLe/VpM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATBvdE58fLCB2icWXIn+CAYyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVhNjMwMDEtZThiNy00MzYxLWJkODYtODQ0Yjc3ODlmZWE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMjBjMmM2\nZS00MmRkLTQ4NWYtYTJiOS05OTdjNzhmZGZkMzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATw4arjm2FH4NVJwhxsMQMuWG8hixrRbbIoW5VSWR1V+z1/3pne2sec\ndVA2WT/ao4xyX861Y5QSc+pbOK3DY7/go3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSY1cvY\n4/BqLd88/fdB2dvrNwPD/zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgOVbtWsU/3Di6UElmPvuvGujcSdkXwFEIK2ClaIyMUI8C\nIQDSPydKp7p9Y5wWZ9UNoUd1unJoUX+agGyaTx2TfN0b6A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1982", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1982` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAeGhMJNMgIktOQEjw39CafDiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlODZmMTU3LThhNDAtNDc4MS04ODk3LTI0ZTgyMGNjNWRmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY4ZGZiN2EtMWUy\nZi00YjdmLTlhOWMtOTgzOTI4MWNjZGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2UzG3cwLb/RMcinrK1iQ6flrLeQUkt/ElfchVu/zkWamfzkjqq7/ci0STx7a\nIYASAIfN32pBZvPH5thtXByfFaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXog23vr+UPEuzupZHELLq3nFD6AwHwYDVR0j\nBBgwFoAUH3pY9FoZanU3ddPWxQC9AAeir0cwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiBrDM7KVtC9YfODAwFF2zSrl/eZwB5lA20oehVnQInEMwIhALWa0kxZHdrk\nf/+j82pWzMm8IHk0qwriVPr7BmEEfgqj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUVO9fJMlKix8TBU8j9bECeAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTg2ZjE1Ny04YTQwLTQ3ODEtODg5Ny0yNGU4MjBjYzVkZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqDnCpCeWciENPVnom4/SUaBVtcDp7SUmWlj49CO6FBe5t\nDp8cZwvj1J7DuzxZMQv6YViYPhT5+SXYxtfcsUAko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH3pY9FoZanU3ddPWxQC9AAei\nr0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMiCO8VnsHJ3tH2FwBKJ9Z/xbTSLajzckYgwjACEzAW9AiEAjf5WJPYY\nqbfqteDvhZdKloLRwECnv40nN+84NNQN34I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAU0vrjKTVvRDCYrZLM9cnnn/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY4ZGZiN2EtMWUyZi00YjdmLTlhOWMtOTgzOTI4MWNjZGUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NGMxMGQy\nMC1kMjcwLTRiMzAtOTdjYi1mMWQyYWI2Zjk5NGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASGlKyfGi/SUcrsNKwT0OZ/DZKhnAbXaVS+AA+1Y0CAuy+a848SHmaF\n+HoNFLGRrqPd0ki4HUSS+wujwS/NJ6zTo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBReiDbe\n+v5Q8S7O6lkcQsurecUPoDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAKBOzgfQOQSC9++GtYy8tNtN6maM82ah0ikJhfEsaFhF\nAiBCUi1phUE/rC1Mb/lc8fvYJgtlPG1MsM6HNNaDUhL6cw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1983", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1983` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISARpCYpODPQOGOFn3BxJt9BQwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4MTIzMDFmLTlmMTctNDM2Yy1hOWEzLTU3ODg0YzAzZGUyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhmZDNmYzUtZjM1\nOS00MDVmLTk4NzMtZTJlZDhhMjg3NTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETu8oaGBU/2u6zIC8pOfzTxW1bVz5XuDnw77QPowj5rKHz+Bk6PGrNuxm4GsV\n7Tr9Lw9I9fltsKF45WIlVTkMs6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj9/zKMCmntMFS1hL32NAgEAcT3owHwYDVR0j\nBBgwFoAU+2BLcJGZA1EbjGadSMEFxlY3Vy0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAnnTwPNF6vJpLTTo9EyhNeQEF2wVYkQk6Y4UxtKG/b6AIhAKYzhngKIfCQ\n0LI+4UhJXbu2a2VYqTUibcWrfbZ+eMsU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZAnH2XSiRAjFbYD2Ii9XAeRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODEyMzAxZi05ZjE3LTQzNmMtYTlhMy01Nzg4NGMwM2RlMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASojh1lhR7xAhdibgd93dr7mN3Xf8XcCLPBaW/RzOd+8EID\nYSuxJXCD8JtneS09/Rb1N0dTkDbpQMyIO/phj5eBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+2BLcJGZA1EbjGadSMEFxlY3\nVy0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIc5PZXWIzkrt3qDrrPeO8QCfK6ZwzeXkfGtplBSAXkkAiEAhlt64RXA\nIXfAqJX6C8gF6DJFiuFJrrmEaXMa/v9X+t8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAfuaaB2bIx9eEsUnpWrkHbapMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhmZDNmYzUtZjM1OS00MDVmLTk4NzMtZTJlZDhhMjg3NTRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OTZmZWMx\nNy1jODlkLTQ5MDItODRhZi01ZTkxY2JkMTIyZTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ62exiVCgbnER9NNOdxwv50N2l8Ypze54IQXWxFqKy79vzh7aMHFhd\nRfRw0C+aXp1ZVGeXD0NmjeT5lqQ92uGso3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSP3/Mo\nwKae0wVLWEvfY0CAQBxPejAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgQ2kIWX/y07RNECXbmawzNS8/0uk35pb6wqk2Q4o92RAC\nIFZeSKSJwaUooQJyTfswAgnSO3U8fz9LGCgaJseODEos\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1984", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1984` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAQOBjr2do/GTsdU80FBCOU2cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2ZTI2NmFiLTk3ZGEtNDMxNS04ZWE3LWRiYmE3MTQ0NGU5OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThmZDNhMTItNTk1\nYS00MTFmLTg0M2EtNzJkNjZjMzljZWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3CI8PWg1zJU23R1IhfrOo5skGCxORkhzW3IUN9v66xz3pTLGyBXA/4bfn3k9\nWB8faj6SQRSwdBaKFHXRmVJIpqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCo678a7YpzlhcOjTTzY6qkOA3bcwHwYDVR0j\nBBgwFoAUbbbgwACM/GnQjQDsoO0rE90JtDQwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\nhQmyLh7D8tIaNwZzVkjtQFWbBjsCmAfqRhTcW+EtlPYCIA4J+1vvZUhPm3Aj6Pxv\nqm+d7BJdurdG0T/HvTcJGIa+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYfMVGm/Tq0PAzyuwWSlTTpRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmUyNjZhYi05N2RhLTQzMTUtOGVhNy1kYmJhNzE0NDRlOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwgxjtHa9NwJpE6n/iCwuhQdvu1f3NY6mczlyN8y7PqKAx\nCJU1fJz8HLv8g4BvZNciS2Re43L2JMDQC0iu5hMro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbbbgwACM/GnQjQDsoO0rE90J\ntDQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK2MWbyawC6ZQCPSH1zCgrk5UpWX9UO4hd7vReuCNPwLAiAayAjU3dfi\nB0TmLFKIxhZKqWZN4vsmzDByWW+QHbGUqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAbVPWia4fNz6w05JnHP1V/7LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThmZDNhMTItNTk1YS00MTFmLTg0M2EtNzJkNjZjMzljZWIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNDYwOWNh\nOS1mOTYzLTQ4OGItYjJmNy1lYzQxNTJlYmRlMGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR7xK6UwuXZ8XrZDtbPELBMD9GmtQ4NWl9oHigqJJ7xuQkgWhwN9erD\nmtuhOGuu7uBEow2jpFSg7ZFfW6kkUjOAo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQKjrvx\nrtinOWFw6NNPNjqqQ4DdtzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAO8+HUO7Nsx/8MiquOH0H4oL3dfxn73ZpXzKt9V9LWEH\nAiEAz0ASZIGL8fWJatJKjCrfM7UIWCY5t3vWO7ak9h8xTus=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1985", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1985` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAaKL0JkGEW0EOoVKry7lyzVFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZWFjYmI4LTQ1M2MtNDVjOC1iZjE3LTFlZmVhYWNhMWYwMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE2YjdjNGUtODFh\nNy00MWE0LWI4ZmUtMjA4ZGJmNmFmNDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/OnS4PzTXMUQVtsz826Fqx384t3b/jSt4i7isQh1Gn7s9Dn2sOd/byijxYY0\ngNq6mLtb4lhYDkLwxiISPtPNx6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJa/UtnB5VimtHTUXHlxPdof24fkwHwYDVR0j\nBBgwFoAUdMUhLz/K+nBrcNyF0n54JZ/uR/owPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAkwQ6SH1yfD7njbJEX0UQLO40rj84BSEIxPP50V4Fh3QCIQDt\nhVjjEo0iIYsKMqbj3JK54zFg4hHQm2KL7vY/qxA+0g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe+6Q08EAAh8KH7RHpLgJcXiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmVhY2JiOC00NTNjLTQ1YzgtYmYxNy0xZWZlYWFjYTFmMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlQQc8o61FccEFtsK17noT9q5djtdiADiTdRuxzlPtWRWS\n8m85PcrE9IvpIxeBdlvD/tgSW7dk8Ht6J9Fw9bKto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdMUhLz/K+nBrcNyF0n54JZ/u\nR/owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc5QBNk+FzHzSM3SGxdZ2gvuNd/HIQjgAipdXk4Y9LbYCIQCobCou8zjF\neYeMMloUQpQgfn3Lmsx81jXVl7L32Msa/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAehdqq1W4FfDDLNDAay35qNcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE2YjdjNGUtODFhNy00MWE0LWI4ZmUtMjA4ZGJmNmFmNDg2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZWFkMDAw\nNy04ZWZhLTQ2MGMtODcyYS0wYjI5NmFkN2RhMWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+40K++mTBo0ru8ywIjkrxqvLQ/xDQFQq49eT7Dko7oIxtzR7guSIE\n1lOKF53A3dOTMilNiRvkiEDJNaiTEG3Oo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQlr9S2\ncHlWKa0dNRceXE92h/bh+TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAPqf6tBiqvm6PvA7pf5BOG3vq5lYpTt53yFS0WnQsEVF\nAiEAr02UMUKQnbkGti7wOfoyriFP8R/lJ0pDcO8M420VNmM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1986", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1986` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAW4vDawYSB3GsAwMgnMjXq/3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5NzZkYTgyLTU4ZjEtNGE1Mi1hZTVkLWQxOWU4OGRhNmU5MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I4MTIyM2EtZTY5\nNC00YTNkLTk0ZGItMzMyNTBiY2VmMDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4hPD8F1eRvDJjXJb7YCmoc9qjT9Nzaf8GXns8IhX+U/FPx8qlLPoGsyT1Puf\n5whhNqW41iuhPVugD7SZHhbubqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXbMWkZ2FDXlLu1o5oVMyTJK9fckwHwYDVR0j\nBBgwFoAUlQOIl90l0IOjoGYUEKPWv4G6lhowPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAmUpFVIxY5EHxxSz2tfbL9snDLU9ZaFHYYSQykJzNvJECICji\nkqUm84BhEnxHAwEi/lPH4v/DOm0xuZaNb+xf2iuF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVnytXFalc19CYb3UnEFM9CzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTc2ZGE4Mi01OGYxLTRhNTItYWU1ZC1kMTllODhkYTZlOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3oyunmbPp6XRRht0riAqG+/fT9MWotfput9OL5zLCxVnr\n+oK22PXAJboQRCSsxq1OKMjMhDQFGzqUDPdQXwH+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlQOIl90l0IOjoGYUEKPWv4G6\nlhowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMbwFlt1u/Wgghmo6AsSD5XBDLwXJErGQkTPMhqfHNH+AiBnA5P1CicS\nvba6AoBt4Zr1pFVTXAjUEw9dELo9/vet5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbAGUBVWFa7mNoFJSuXAc/IVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I4MTIyM2EtZTY5NC00YTNkLTk0ZGItMzMyNTBiY2VmMDA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZTM5NzJh\nMC1jNzk2LTQxNWMtYjkwMy03Y2U5YjgzOWMxMjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATbZSDQvsR32ZmozPfG4u6WDDTOO7Vnb1miNGp06Cwh99PEC/56Wq0a\nzjqb/7FBNMonoGsD7ES2GyOglaFcaC/Eo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdsxaR\nnYUNeUu7WjmhUzJMkr19yTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAKkKUDmiJH/RwVNm2YonUPRWmhuH9fmnOeERm5pj0HJg\nAiBVIsR/yBzdfB1uUcfE6wlWUwzcAbCP/GWylFuCQIBG/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1987", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1987` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAfn9cm/ZoGOZgvSV6/qfDv3EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlODdlNTQ3LTJiYmEtNDFjMy05NDliLTg4NjdkZTRiNzdkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDlhMGJlZjYtZTMw\nZi00ODExLWEzZDEtMDc0Zjc4ZmI0NzI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExSJmH+IH5CuKldszXm/YAI1mWBpycqsnamYPWNkWRU/Kb28kvwVEg4Rjt0Yy\nC0yTcq5QR3Tz//qb/Fv2NSvXnaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ1K0nyOootfNpafeiL5bbPymDGkwHwYDVR0j\nBBgwFoAUbfHxZZ6HuJoPWuHHw6MM1dm8OuowJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAyc8COSuVSOX8R\nUyTfP+HY4lDU7siGnft87npmHimrNQIgAkJurq4LRr9dnJRwqyAihtQ47BTS3TjA\nBcXM7pbbhcE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf5UA664EngXWEMYJkDkPb71MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTg3ZTU0Ny0yYmJhLTQxYzMtOTQ5Yi04ODY3ZGU0Yjc3ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQj9sJwbeP5/ISsOQweYV8JIXpjsTLwvhbVI8q2C4+rsOhw\n/6sqbby+08CDt9VNa1e+iSnlwQgygTDp7aSfhrvUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbfHxZZ6HuJoPWuHHw6MM1dm8\nOuowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK0tK0vLefDMDshNyOWMTZHmOatYN3rvrPZW3EIUYjJ5AiEAk/uVUY9p\n5w2yKGggWkls+1r8aDYcdY1h3dmbsf4+Tbc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZxcTaQbTi2ogZvDv2WACOMOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDlhMGJlZjYtZTMwZi00ODExLWEzZDEtMDc0Zjc4ZmI0NzI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZjFjMmYw\nOC01N2FkLTRlZTMtYTZkNy0zNzNiNzYzYTk4ZWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQRjoptRINu+ggtr0NpIZWLySHljojFnQ9HJvDYJyacKjjJLvC469Pd\n7VHZeR5X7v7TN42sfCVgouinEEkngZLZo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQnUrSf\nI6ii182lp96Ivlts/KYMaTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAIz7rbW/yYzdV5XEzZzVws21fNoPd5dFZIHwTlHJUR8r\nAiEA7iFbHxtWZwQIleQZPolztNHxBV4/BazxQxxbw2bWpQ0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1988", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1988` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASC8EephmoeV8nD7OI2RzKJKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2YTExZTAyLWY3MGItNGVmMC1hY2RkLTgyM2ZiZTUwOWI4NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNhMzNlN2QtOGI1\nMy00YjRlLTk0NWEtOGE2NGQzZWExY2RlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcyQEe3p6VQwd7Sds/RextTME1mU0Gqge9o+nkRDluLMkOq4cYLTRtXwFW3/C\nXVabHoC6CB64T9EEg7m9rr/HfqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWZGL79htxQxRZnjHYQhzSaY4QpwwHwYDVR0j\nBBgwFoAUJgEWi412GvLI0hJnnDuMts9q2VYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCeHJLz4apWsfseX1MF35cH//SWUzRL4jEjCuLWhODbDQIgAU6X/cNRXx0y\ntEsOsZbEfBBQ4sKDL52GKHL5iAzm7tc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcbeHbuAQ+J6OK2dHdc7pGqUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmExMWUwMi1mNzBiLTRlZjAtYWNkZC04MjNmYmU1MDliODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATayd+ZEgEg9JkbyoKipYordKvYgDflSktT3lrz1Uy0l/cW\niP7wzladGZ0YAG7sLavpOw7Hm/a7SlpxtCdacIUso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJgEWi412GvLI0hJnnDuMts9q\n2VYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYI7otqvKfrVzbJ5JRFMbIN0Sf2R1jtRzydr8n5uIvEECIEYc6dFslcVo\n6movicwoEXrj3rpmoqLS8EP6pEh+uKBf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAezMT+/y+aULYX4GdDpjfC1LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNhMzNlN2QtOGI1My00YjRlLTk0NWEtOGE2NGQzZWExY2RlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMDJmM2Rj\nOS1iMGQ4LTRiZjctOGY5My0zY2ExYjhlM2NjMzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQXLxfYWmeEnocjop1L8MNlSiY2DjIDgt7IHkldyfiMgkZiFWtM5YzP\nL9Zz+hUxWlemKAyMa0JpmuYPUAF/Xlq7o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZkYvv\n2G3FDFFmeMdhCHNJpjhCnDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhANdMlC8Esf0304qfhO70IC3EN+NX/t0xETWaIvFJATo4\nAiEA4qdyJxvOpJ4fksKCSDgPqygKcziHkvR2xTwEP0bWMTw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1989", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1989` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdyyjuVtKr5iA+BhjC7RlF6vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNGFlYjFlLTQzNWQtNDBhZS1iMTRiLWMwN2U2MGYzMmE0OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA5OGVkMzQtZGYw\nMC00NmE0LTlhOWQtNWJjZDJkNWRjMTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG6twlxX0/7S3n6GJ2+WNNToMzH9rAh+OFOQiSDmhbwXcEfmoJs80QJRsx7+3\nikkKdHdb7aWapEZD8ai8/TM3i6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwh+xGomdP5yK3t4JC3hboL9SjugwHwYDVR0j\nBBgwFoAUsno6GzBDJoxKTJYfi5alH3KF8BQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIE4/OES/sfYJ7IzRcdN7eeZqU+0MOmE/NBgmpgIZnZ2aAiARaDiXZdwWBivd\nM0Ip+C3yijkmlr44w0ic3oesqAO47A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV0Ak4FiIZPnosXgnk+EHuzTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTRhZWIxZS00MzVkLTQwYWUtYjE0Yi1jMDdlNjBmMzJhNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIPrrzwu5HjJqxReEknw5ItKuFevK4nJCFlHs9PDOH++Sf\nLDshydce8cRo3sbuH60XkPNiLjGUVmVqagllxYbMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsno6GzBDJoxKTJYfi5alH3KF\n8BQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKgRdTInp9xGdxoujIxutL7VpL2Ts59v7lDMQSILDncMCIQCuMGM/HyXZ\nTqxKXoM8GVqDWSweNZ4otZaWdU/toOOKKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbHC0dPl4OsoZ9qR4p/wdAekMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA5OGVkMzQtZGYwMC00NmE0LTlhOWQtNWJjZDJkNWRjMTVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNmE5YzJk\nYi1hOWMwLTQ4MzgtODRjNS1hNGFmMzExNWYyMDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATfLmDCMyEHTjBayT7G10W8hloO7r2weMCDGANU55+TKdcXHq2u0+zF\n7IFQN7J2bS9QtnOowSFdH3eXFEyVCo1Qo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTCH7Ea\niZ0/nIre3gkLeFugv1KO6DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAKpIhwA7GnYwLB7fxePAmWGVmDAgppD7mL4U0u7wctrU\nAiAKIigqGgrMkuFPuN+R3stBp0MeMcCClphoUHp+vonPgA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1990", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1990` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVh1ZyOVGijoBwXbd9e8TOvsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlYmI5NWNhLTExNTItNGY2Yy1hODU5LWI4N2U1YjI4ZGI2MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjlhMWZkM2UtNjc1\nYi00NWZlLThmZmItOGJjYTliYjVhYTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErc/NabdnJhTcJJHt5NICfOMhZ+hOFYK2EY04R5AH0K+ccJOqsZPsim+D5Wd+\nIMWDZW2gdMr8aBKPD3c2XbzXZaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjO4yNeO+XKWcflbEp940gfLGRcIwHwYDVR0j\nBBgwFoAUlz7iTG6rlpEiRrIQXl9OFj2T+rwwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBXMVORwzkVb7xioP67HuAA2JRP+W0dWPU83RgHDFWOXwIhAJ7JMRGqlHLP\nal9xFioMDRxAg08c7JZWRf1aGqIT1Pja\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASJeSlx6Q1HGIBGd1b1pszh5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZWJiOTVjYS0xMTUyLTRmNmMtYTg1OS1iODdlNWIyOGRiNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0OOQbF9DHy12SNvVcCxb3UgqKqars7KRkPs4MMhTr9new\n+0okw0rH4aFxUc67J2scNqsb+pjFOlKQeXA64RYuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlz7iTG6rlpEiRrIQXl9OFj2T\n+rwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALruqS0xSUmhONxs0SaF33eSkcwx62ecEjsnKOFNfLG4AiAa4QZ2hv8M\nm9Bmb9YDVklZxSjjli2NfbqdH2tY9GuCig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAev3CRQwF1xRtNrimyD/VcrWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjlhMWZkM2UtNjc1Yi00NWZlLThmZmItOGJjYTliYjVhYTI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNGJjZGQ1\nNy00OTg5LTQ3NDktODMzMy0yODcyYTRlMjE4OTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+Sqnc2H/MoEzUdkCXZwGDDHp0zxOq9ddpFwitpa0/DqKtqOogQgRR\nossJUyAl/mw7Ze+2G4toGxYES7/fKEx7o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSM7jI1\n475cpZx+VsSn3jSB8sZFwjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAJ/4k2I1Sa3NxB7z3QeoYeqXyEiqTm4Eguc7o1Jc0kjL\nAiEA7x0BVVqCS51JXKzhFv618ER3bCikbsKxYw8IM9ULM80=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1991", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1991` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUY/MxhymM04+aXCix48G/09MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjZDIzNDMzLTgzMzQtNGFhMi1iY2IxLTA0MmI0OTUxNjYzYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE5YjgwODMtNTAy\nNS00NDVhLWFiYTgtNTgzNjgyZTU1ZTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvp5+mhFm5NW9Z2IELdmsGY2PGqMtajUKjFudm9ZXQdSQyiEIhalm5D6aZ3to\nC2MC/UfWv/BzoaTKiZCROf3VmqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUznaX1OgmGZK1OqOO6IuN9d2dCyMwHwYDVR0j\nBBgwFoAUK5rNlSDHZgnmbcL6/UFdJpCNpyIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAi+JeCZ0d3EFNik4lX8+372cRykSQqCPc/LA1iDjl\nmpUCIC409IzBdx0x1BRKhtJ6XVwvjLHPPr82yOrl11BefYiV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeoXqAgIpoqY8eRZZTNZ64h7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2QyMzQzMy04MzM0LTRhYTItYmNiMS0wNDJiNDk1MTY2M2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZe6zPAGYi4hsAKb4RXu5M3AocfqHQYp9ppOlAPVCNzLET\npNfMiYTYrIqARAgFlHi/aA+3UAYFlD8AX3DzW00qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK5rNlSDHZgnmbcL6/UFdJpCN\npyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDUPCvATRGKI0ccWeJnDdBYtlZzfSkxSpr0vhLI5WPC4CIACDjdim7e2F\n1nSRZU6Agyn0qCcU6PDxVFQ17IVhkS1X\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfno68asrQxnu05t2EfzMnH3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE5YjgwODMtNTAyNS00NDVhLWFiYTgtNTgzNjgyZTU1ZTUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZDllZTk5\nOC03YTdlLTRkYmUtYmVmNy1lM2FiZGFlM2Q0MWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARDrJRIZdfJ97fNkqtMU1J2uFzBteF68i3beaAldJmbojHmNlcd4NfF\nxiT4yog6IrhdhevoymuPGSJscQMtMCoxo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOdpfU\n6CYZkrU6o47oi4313Z0LIzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgBiZQuQWhV5q6Tk4AZBnyl2mru/+Tz3Pj8XK7uRhrv14C\nIQCdSOu/Mo75A7dDfV33WVyHvgHbm3fzZJZipJwzcwBH2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1992", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1992` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcZntZhdDb/kq1dZZxjmPMm3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhYmQyMGNiLTJkYWQtNGYzNi1hNDNhLTAwNzEwODUwOTdkYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWExYjU0ZDctNTll\nMS00MWFiLWIzOWItMDdiOWI5MjE0YWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC4M6ieHej1ltJhK8DrGCv+nIB7YwWxvxK7CWssbt1unu4W5yrFasRSYtTa2V\nVmVv4Kb7BGf6LzK1VNez1Ri08aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc48ukXbhVmGvatVmRHhm1LMnLTwwHwYDVR0j\nBBgwFoAUhmBzWK1TiILhIoLNMd29nBjwfu8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAXgUtvWchFuZMZ0pA2RUy86yL+DM/Pp9/G/5YTXa+6\nEQIhAL9qvObNV6bB3B1b/xPiUDTZi9I8D9uu6/fh091bAUXR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUZn0iYsBm7ZEWRzumE84icnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWJkMjBjYi0yZGFkLTRmMzYtYTQzYS0wMDcxMDg1MDk3ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnkxATYEkK6nk02og+bKdOeWX/bpzrL2BVU3dMxybkMMzM\nrJnuSfv1Cb6tXOHlzZGdAhoMN4a28+zz9ZpnqMSIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmBzWK1TiILhIoLNMd29nBjw\nfu8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM3YeTi8YvHK2P1aPE2CAzBK/c05msLyO9D+CQxYsD/vAiBKOq02z9PU\nHdMyNDhBXzFO+AJ4k3t6M2lD3HsdOJtHBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXFS6bbTPS3kKbKcNFqdXMrlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWExYjU0ZDctNTllMS00MWFiLWIzOWItMDdiOWI5MjE0YWFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NzhkNmFj\nMC1jYzFlLTQ0OWQtOWNlYS0xYmZlNDdjMGUyODEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASF5pI2RU794P+o8EZ6xDEMmCoX9KTr/t3xLZEPOZ2aqKtj4u7B8TSV\n9fDIulin/Hj6svn/T1kNHpljNGu2iyPPo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzjy6R\nduFWYa9q1WZEeGbUsyctPDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAPgh/Jz/gyA4U7xjlFJ6qN6LH4FPVzBBAuLXgE3TmEdK\nAiB3mybzFTsM0YUWMkTvl++Uhzt5cbFXqkwEpslaSM2bRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1993", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1993` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAaR26uuLrX0yLCZA654V3M/7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NWQyYzAzLTI1NjYtNGZkZS04OWRlLWY5ZjYyZGJhYzlhZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM4ZWNiYWMtNGEz\nMi00NzAyLWI2ZGUtNmFmZTQ1ZjM5MzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpzOFCLT/lGJ0mBDK82WDjICJQYoiOh4RUSazU6Y1Ma0IGO/btUofbQPxlK3Z\njeyIqNtnoUsnm15x99GIucJBkqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd+AfcXPrve84oxpGB1OnlEEVl9YwHwYDVR0j\nBBgwFoAU0AhLHpSBXyP/5+Pm+NMI6bGvwTkwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAtTjLwx7z8OC/u8V79lzaVYE5klknBkukC8uMn+FogGwCIQC2\n9NUl18wVujAefXlyblak5MfmIgdLiQBh/DNVCs5pqw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYb9f4m7aqFb8IUTUNvicOzcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjVkMmMwMy0yNTY2LTRmZGUtODlkZS1mOWY2MmRiYWM5YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4ILgM5Dsdu+7ZxBpSL/KRJOfvdyPbN9Ixvt+3O1HlGms8\ns4trWDh8TiJ/YQYYacT9ehpILe4AWYsgVSX24b5Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0AhLHpSBXyP/5+Pm+NMI6bGv\nwTkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPluLzzXWVVpQsKqMGrB0i6ZK3ncmw2iWVJzZi9DAnhACICtY5sh/apjp\ndOmyN2gEcMTuGTvodKElCnr4p6VWiUYI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATxK6swRz7bmMeptkuN4UUyhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM4ZWNiYWMtNGEzMi00NzAyLWI2ZGUtNmFmZTQ1ZjM5MzdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ODJjOGQ5\nYS02Zjc3LTQwNzAtYmQzYy1jMTJjMGFiZGM1YTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQKjKAAjLpPU8oWw3GMHFiTH7ebw++OuSIVDLwsizJ8JMXElCh73/Py\nOwBDw4XtxRFdaslDni+puRClF1V4j8c8o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR34B9x\nc+u97zijGkYHU6eUQRWX1jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAKUQlW7H5Aypws2rzSXwXF667IkJsM5dKILP3AD6oZA+\nAiAZyzXZqdOjlezsJ3vT7jJ3c3NwCbQxqj+pxKoeCGK5Qg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1994", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1994` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAdwY5sqeE3qFtZTHWHEj0dxTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMDYzZTYzLWQ3YjEtNDVhMC04YWQ4LTFjNDJhMzRkMDFhYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM2MTEwMDMtZWQw\nNy00MjU2LWI3MmQtMWIwMDdmYTk0YWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgL60l1cNFHevh5+T1F4DXvWb+FBKM7pDqjjThN+EuUdbnuKwdn4eTv2SqgJD\nYvgCBpDh/fdlsAcWtqxzUMunU6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUub2SkcA2AL4QmxvHqornh/dCsOwwHwYDVR0j\nBBgwFoAUfYmlFvmINKnV9Vv0hxf08zHI72YwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvTV2fp+zav+zX/c7hC3tITesDpPCN63w\nOpR6N4aITR8CIQCK14wYNH7RsEilGIbQL6nFaBwRzD7LDPoGScW2PqjBog==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU7nr6L0retFDQ48v6R2WCRfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTA2M2U2My1kN2IxLTQ1YTAtOGFkOC0xYzQyYTM0ZDAxYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4xdyit81B666suwupM5BHucOFKlf89syjC4Ur4i1cx8yG\nLtZaizv//6rWUkS4xrrUEUWmt0l2qUoZA9IEIlKho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfYmlFvmINKnV9Vv0hxf08zHI\n72YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMvqb1u68M7nT4Tz/q9JhQdisj4I9Ss3kVRsHGURglAJAiEAoywaKfSt\nIxblvAk3DpNkIAZ3EYUwCXDx0BLSAsxWy0E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAY/iMy1CKEh0YiTnUq/fomJoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM2MTEwMDMtZWQwNy00MjU2LWI3MmQtMWIwMDdmYTk0YWFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YzA4OTNj\nOC0zMTBmLTQ1ODctOGQ0OS1lM2ZjZDg3OTZlYjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT7sFyppbaleiJ5RUJ72HoH3p0ysB+lM/r84rwU4bnnnJ3OatEC2ZbH\n3fSZT5Vf/5gEwmN7T2D3BPeFgkpPlQ7Go3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5vZKR\nwDYAvhCbG8eqiueH90Kw7DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhALNIRzAteRn6AV7aLNioedkqnBrbrDXHP8ZeQkh8mefj\nAiBUfCwbaOnTU+2oCPxAqxw7k63mmHZFDB1S5JaoJ3HMoA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1995", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1995` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAZMHKzhWoGI9KEqc+96YdBKhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZGQzOWM4LWZiMjAtNDUzYy05Y2FjLWU3MWJiYjEzZWY4YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzYxYzZkOWEtNDAy\nNS00OWM5LWJhY2QtNjcyM2UwZGJiMmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiFrpgXjW8kLbm90nezxGsuls2KhVWiuvvW5uuzISqFY27H7FjoaiuH9vEbkr\noHh/Y05axDpNjD7emk+1pkpqEqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/ebZlIgEWK9PW50kSd/c5t2y0h4wHwYDVR0j\nBBgwFoAUQ9si2JGD2Xj/Bgn9f7M2dT71TnAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA4stpK8l7XbBT1Z1RotsY7kTScW9CZqYK3\nb7elLZ6ougIgU7eqDeEoKaSF826Vxjklx2cT0MaenH5LVBhIJlfjaDY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW8wnFGtsnugFM2G4jl7va7BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGRkMzljOC1mYjIwLTQ1M2MtOWNhYy1lNzFiYmIxM2VmOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzQffGWt8tPwvSobnscXeP1mxp5dXiiGkZKWE7ky3MDK7i\nZx09rp2THSgGWh4D9IPuG0STHoLN9HrwS/BVikvGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ9si2JGD2Xj/Bgn9f7M2dT71\nTnAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKRpGMiK5UnVRHGtIFX3fP0wuvyMNi0fjRpGACVXv9B1AiEAvBKDLWXl\nSlhQJEL1+BIBk9r4vNqw2Dk3z+Q5juHxIjA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARgVGqzlCtKGlFpX4pRBVCRcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzYxYzZkOWEtNDAyNS00OWM5LWJhY2QtNjcyM2UwZGJiMmY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNzI0YWM5\nYS01YWU2LTQ4OWItOTdiZC03YTc0Mzg4Zjk5NTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASvXuxwowTwHokcsO6i+CCO0dbrgEccgBbEk7Q3uianrV8fL5SmjGRt\naRQGBktKzyVnC0W/2iyY4p0G42p6hVMzo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT95tmU\niARYr09bnSRJ39zm3bLSHjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAM5SZnbwsGEI2ODt23aocqLTbOJWNLz2bzDDcDqfeU9w\nAiA3fJ1Z4XEcn+nMc8sWYjSCUUKR3ss/qhneWW9TqtPSFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1996", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1996` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAVhY5SI6GXp3c8H8Jn4oYx8SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkZDhhMzE1LTk1YzMtNGY1Ny1iY2I5LTIzYWVjZmYzNGJmZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE4NTdjYTQtMWYw\nYi00MTRkLWE5ODMtNzIyODhiMjk4ODhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGEb6ZpfnTViURzRlEBK8oBlz0HTPh2zPr78Gzmc725J7A3ZsqNsoWwmojqOa\ndrdZi7xWqqfIsgquyYLfXjuloqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTjRTgjkKW2Sfh2HbHjvfZkJ6D8EwHwYDVR0j\nBBgwFoAUkRIV2zkU48cLEsE+gCXmIjOyut8wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA0UzXinEy0Ufcv\ngi9zu7L0klijbOmpjlfeeKHYFTH6TQIgLY/M1MHNtTIyTlfwMVUiaBh40ElaDagY\nnsBGNHI7uZI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAblThKjimK+z5SN5o6IzQzo9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGQ4YTMxNS05NWMzLTRmNTctYmNiOS0yM2FlY2ZmMzRiZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATn4pWe8AhDWSVM9CCO0pkt+KZ7w78P/0t6BPoUwmao96EO\nqY92olJppJk1L8PvXkxOqBFNhmEzqy3ccUyVxprmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkRIV2zkU48cLEsE+gCXmIjOy\nut8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAfXusp1CKwE9o285xpQK4K7ABNJ/65+eVbOdgXmabysCIQC4HXoeGvhj\nA05P8kJrpZF80uO7i4dOjBebafklG2Dy0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAa5QsI5CAmTTh7uZ6fwkptLxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE4NTdjYTQtMWYwYi00MTRkLWE5ODMtNzIyODhiMjk4ODhiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZjcxOWM4\nMi1hMTBjLTQyOWQtOWIzMi1iNTU4ZWJiODliM2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASPuA58OclXURfrYYtW83GfgjTE25K/ulNI8Kg7pAYM+VavvASwzaWQ\nvUEfA6Yj6toOrTflvewW6CFp9BLBimVuo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRONFOC\nOQpbZJ+HYdseO99mQnoPwTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAJNDiQM41FNgw+KA8gBJS2lFD/0j6lJyzb+n3DWmEm93\nAiEA4SBqroPzPLLZe/LYoz6vt1n8wFGAFs1DdyqxGxy9/w0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1997", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1997` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATdNFk7J3LGhNyQlyHZ7WN9vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMzQ5NDgxLTNjZGQtNGQxMS05YmUxLTNmMDU3YTNiODhmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIzYTcyN2MtYjM3\nMy00ZmM0LWFkZTUtMWZkNTdkZTllY2E0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBg8mjyL/2HoRNAkGOzz6BSk5rkGPalWBsSXIfaMa1bkeEFaVLzJbobR0Hxp1\nlG05v0Q5YIyqSZU3ns5pK9Glj6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFwKyvlhenIxZl+0PWU3SFEYDkEIwHwYDVR0j\nBBgwFoAUojIXScPKhh/JgBxAWt5608dAS9QwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDF6kmkLkDXlOJvfMN6EBACwgKttNqksYJr0TCWk5OZdgIgQzDctIPdbRhF\n7eHoypUYGWNbguQxhy3nGLQn6UNV2tY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfzBicwRU2CKaaChvVW8AHp8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjM0OTQ4MS0zY2RkLTRkMTEtOWJlMS0zZjA1N2EzYjg4ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARj4zjzgAboqri4L2x06a8G3VWNNg//lwzkKsG1Dn9g1sST\nyj3x1Q+XZGy4/855OfYUv5/WFwVj7XEpCmqzobpvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUojIXScPKhh/JgBxAWt5608dA\nS9QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMo0GDggMVxo7ImwsLMD0l1jXMXlSYL12YJhmPZLsbIQCIQC9ODfkEl2H\nuj28rXHplKkYM3qxn1QEIR7fTN4U6e/MzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAUmTLRY0blr+LE9o9vkwo1TxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIzYTcyN2MtYjM3My00ZmM0LWFkZTUtMWZkNTdkZTllY2E0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NWE3MzQx\nMi0yODczLTRkNjItOGQyYi0xYmU2NDZiZTc4MTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ/eLS7QsxHZZcEC78PaIkhXABblIWeagJWSd44iZ50jadO/cRjyuoo\n/VCGLQLJYPeVpQDWFVqAgcWHfSVDaNKdo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXArK+\nWF6cjFmX7Q9ZTdIURgOQQjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhALTUICekYeRlGJNuj7ctzw+5MqkrViKDGQ6Tn5OLyJMa\nAiEA4sd3TsAWNX+29LG71Y6MZzUY6E/wDyrxqryEUecIiPo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1998", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1998` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAT1/lNaoj/rfTzqczbSP1GNFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMGI0ODBmLWZjOTktNGJmMi1hZTM2LThjNjNkZGVjOGIxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM4OGZlNDYtZGU2\nNy00NzhlLTg4M2UtZjRlNmQ2MTU0Y2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhY4A7M4wuDkQOyaq60VtDJQpWIcMw5dH7ZkzCXVbSFFTLh4NfOt7VgxfK/Xq\neAwN27n4giVvkDjiMK9HnhY3gKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpJiThZ88fB50+cPe3sK/BfWqp+MwHwYDVR0j\nBBgwFoAUcfMJoqRVEimHjaDfL9TlfAC+UsAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDnSfjTO5Uurpbhp4oKm+ZBuHXCZ+LkZ3n57NSt+4+P2gIhAMyZljILvZjX\nwsKUAManLbxtPNs9ODg3KyG8LmP+JWbh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATJpu0vNjdg7oGoR78lJiuGKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzBiNDgwZi1mYzk5LTRiZjItYWUzNi04YzYzZGRlYzhiMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYAWLzNT57e2tEdQ4m0IKMjZpE5M/pkn1yOCY+XUbT3CKw\nyvsER/HfWhRF5PkyP483/8MYqDlqwiJai8X0CUdko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcfMJoqRVEimHjaDfL9TlfAC+\nUsAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLbunuCVDa8otydE2kZw6RZ64o1rbKxbE3t9oMvsHHUwCIQDKFakiRUa/\n+xTFabhxMqmB6Vkk6HS2nfCEamvl2F7nWA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAWDmXF9IS/HpKM+6F4k/RiEaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM4OGZlNDYtZGU2Ny00NzhlLTg4M2UtZjRlNmQ2MTU0Y2E4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMWExYmIy\nNi02N2YwLTRjODctOWRmZS1hZjM4MDZhZGY0ZTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATHECTeZapKjvBiHp+N3+7nRPdrLllCSUdKQ9BKRN71wNXEhHbEdPr1\nYNTMZddqdeIUpVH/F+lPhc4LtBOKczLno3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSkmJOF\nnzx8HnT5w97ewr8F9aqn4zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgLpAFB85+C3I4k87JmZPSCodixY1rrvOJIrGl1Poqhn4C\nIQDl4hNlxUeybp1OYiDKx/OWS6Qak3dbpqDTGwOq/05NFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc1999", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1999` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAQZbfqjN1K7P6JaBdNA6k14BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxYWJiYzZjLThjMWQtNGQ5OS1hMTRiLTg4MDJhZDJiZTk0YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg4ZTJhMmYtOTEz\nNS00NDRkLTllNmQtNWEyM2ZkOTMzNmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx4oTYFRO1mX9iEYkwXwuNGRjXql10DSshfZMgztcQZ0s2uG4yT9TE89lVA8Q\nXR3T2Ydw+aFTI7c7z7RgKJIbhqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMfjmkpBCd3ixBLj3U4pOuxhdjtIwHwYDVR0j\nBBgwFoAUHG7RdWnj/3mfJZLFy4Ee6cQoaEEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBPg3y17MViyGT2TZTHgQ0HHU/PYq81O9eFxucSauPbBgIgX2d9Exl356mL\n8s4uVmSZQqFsA60vZl6HS4PPVxvz7fE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXW2MpLakilOyst3arAI2l3/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWFiYmM2Yy04YzFkLTRkOTktYTE0Yi04ODAyYWQyYmU5NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzSk87nUe1fah3Kj/+heTq10spzqZDGHjXWu0kk0kz/DBQ\nSusS4lY1ofhqhHxHX9PYyv6Cocj8Pkzen/WzJFDgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHG7RdWnj/3mfJZLFy4Ee6cQo\naEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIEcoScazAQLGBMYKtdR4MhqQo+RSq7C1HHsYNZBwz44CIQCx8nZAFEQK\ndu+KwbYx5hj6esZ5J1QXR7T79I+3j/JFkg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAdAUB4wvFT6Ab0hMI21bXwQIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg4ZTJhMmYtOTEzNS00NDRkLTllNmQtNWEyM2ZkOTMzNmEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMjEzMTY1\nYy1iOWUxLTQ2YTAtOTNjYi0wODcyZDA5NWYzYmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASQI0ARgNSh/ZErW8gcWAqwwB6ea1AtT6LVWASnA6vdeuPyfaiIJzyd\nScr/hqiz5x5XInw1UTg4ez3q9SDRDDUFo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQx+OaS\nkEJ3eLEEuPdTik67GF2O0jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgWG8fDLqVxcm686kZVWoyxKAKlBMtJ0ZPcxP29BhC0SIC\nIBa0pvWDIF8jMV2W/VPmkHojvJl3IjhkWlOQhiDrSb0U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2000", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2000` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAUCpAxCDZtx8oErGZ3gZJ+uvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzZDBmZjdhLTMyZTgtNGY0Yi05M2ViLTMwYTNjY2RmNGUzMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJhMWJkMDAtZGZj\nNy00Y2VhLTkxZjQtZDliZjNlZmE0NmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjWP+9RwN0x1sXXyx+7Bbdhfm0dm5Mrbvh2J+5M17/RbPvRUmgvPOJWv37h8+\noK3lgFZ2nprUyJ3mMAhQ4hwZLKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/sFpkba740juGdcHvc+Pbezj+4UwHwYDVR0j\nBBgwFoAUnCqQGu15dklyeKGa2F5swdFu21owQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEApQDP/J/chb+QsUfBWGKb0VkPnpKUsPUd16PwFYW/\nhG8CIQDFVlGzxi0M1GRwhQoNUrEaR3V0+OhAkrKF4+9YZADO7Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQOz9fSkP/c276nMPMrcXHuiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2QwZmY3YS0zMmU4LTRmNGItOTNlYi0zMGEzY2NkZjRlMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqPbdQPkAqRN1iAS13fOdL1ibMBMhbqU/mgNXMtnrxU40a\nXBKBKvkpCpK4p4YIaPgix2WuAuYKZdRvpkk7qnMKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnCqQGu15dklyeKGa2F5swdFu\n21owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANlktxe9MGQ5UbsJGi6Q9ome/KxqY7ownkrfKYWIlxH0AiEA5hLZQE15\nqZc60+IRBoh90u1t2IPtBMjSRLoyrqpGxwo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAWEvRuYg28D2JqkFjU75XRzyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJhMWJkMDAtZGZjNy00Y2VhLTkxZjQtZDliZjNlZmE0NmMxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5M2NlZDBm\nNi1lNjdiLTQxODAtODg5Yi01NjI2ZWUwN2IyZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATti+C8BOhxoEGXTlsR0JC+eZuybDW3ADoLR1wY4xg9QdGeUdC78MrA\nvvh/oKDma+zmGFJJXJBIdjk4NG6Usz99o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+wWmR\ntrvjSO4Z1we9z49t7OP7hTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAOKmn5KyASv3dKvOUpe/C41UICXxvZIeO2JXFdeLTSni\nAiEA9lhr1+LZrsIBScwQNhpH9a8MFwBc2uN/yAjjeAIpc/U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2001", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2001` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISARVKkLN7LHgN0Sa3CUeWOrhXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MzE5MjU3LTZkNGYtNGFiMi1iNTQ1LTNlNDAyMmM1Mzk5ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI5YjQxYzUtN2Y4\nNy00YTg1LWI3ZTgtYmY0YzFhODFlZTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXgIcsL8xSGI63sR9tc+5X0/BArbpHtPggClGdeKj7bUNW8E4AfvTdx3BkFOD\n2g7Lf4PlJI6jYt4oe1LWSoSjC6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsylxraWUdW8xDyZdOxFdWUgGCXswHwYDVR0j\nBBgwFoAUHPO9Srugtm6O59C4YotVl1EVqrAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA40x0y+osqBH9u2Du/43IH6Wam6olxbFaGjIxJBpG\nNmUCIQDXCiAhy6A2GTJprEDxHv5qFk1zI2fVrbGJOcMxHem/HA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeEq7HbTEvVd/ItxLYQjU/KvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjMxOTI1Ny02ZDRmLTRhYjItYjU0NS0zZTQwMjJjNTM5OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATj8jihVEoK2wgBepoW0KrhiNIPeTb4hIV1MoKdf55nd1le\n9q+/WzvuQdoXypmJeFuysUVF+Qn3jQ/EAdfZ2SkDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHPO9Srugtm6O59C4YotVl1EV\nqrAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSt8QsHXOfUOW/seNj693pYOCkHSDQWApb/Nri6r+flACIBzdlIMvbG/9\n5aO7xctqIyuAEZ8gE3CIIH8b791wSQ5y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARIuOyIKsyD9SZZSE+3brYr4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI5YjQxYzUtN2Y4Ny00YTg1LWI3ZTgtYmY0YzFhODFlZTc4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZjFiNTgw\nZS04ZjBkLTQwNjQtOWUxNC1kNzc5MWZjY2M2OTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ13iPgAPOW8eJVmVAw8V08BchnYyRm00uSn3lAB0rACabZaMN0469C\nfp0BHnbHXlmPWCY0lXI1dnlwkLOUp3uDo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSzKXGt\npZR1bzEPJl07EV1ZSAYJezAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgB/iaAG6tzu9NxWVykOZOgqVD+5Yk4robgTpzBYEMDQMC\nIQDkyiCyllHJ3aB3ol0CZBfMwST171OJNy6GMTgjId4J0w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2002", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2002` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAcvL3ivM+fSkZ0wlnJWMMmSIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4N2EyMGQxLThlN2UtNDZkZC05MzAwLTBhNjhmZDMyMzg0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIwYWI1NmMtMWI4\nMi00YTU1LTk0NzQtYzFmNTYxMmFiNmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaHTuAKCWKVkl4ToNmw5sZ0sKype9ehy64jqCUT54Ub9GtI2lRPIUOA7Y8hrb\nrJlp/SLbDaUROVbnR5YZwS/c56OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEc1Kufj7S2uH6HXn+QAqruBcdacwHwYDVR0j\nBBgwFoAUh0qDfkeldFB09S7rahf89F5CRJcwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA37bIsRhgvbCBo6aM7UwtoMFwHSom8UvurlpDTPxTqEQCIQDg\nannXp7oq7cLzwv5GWW7T/v60mHseF/JWppsmeHkN0g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXsMZr3GZYmRdlfMzAwQaUVyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODdhMjBkMS04ZTdlLTQ2ZGQtOTMwMC0wYTY4ZmQzMjM4NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0IP/Odqevx6K9x3mUz3U3l6x2jh8m1XxnCIvpoOuuWktF\n1ltJf/Ab4YNp/NYqb8V4pHvy1skiW5XLQH9tBAoMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh0qDfkeldFB09S7rahf89F5C\nRJcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL5V59mfzkiejr3ALS7+YCGrVOA8YOHvtnX2Op0mC8VrAiEAm7fyZSpV\nH6voRvoP3D0LATMbN6E9Qdm3TmQTvlOiHeI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISASGv0CpQSBRsdvO/P+oTauILMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIwYWI1NmMtMWI4Mi00YTU1LTk0NzQtYzFmNTYxMmFiNmE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzODlkMTJm\nMi1lNWM0LTQ5OWItYTBmYS0zNzVhYTUwZjJlZjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARTRrMyDZ9h+KTlh1VXqWajcW1MLlC3UnzQ7e0sAXuGcLlWuds9etwL\nsymNWpc4XON33JEsjF0Sv4TpfhrGQFDKo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQRzUq5\n+PtLa4fodef5ACqu4Fx1pzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgClKhe/zm1ci7+S4E3S+tu6td35ZpDH9cxCA7IGyH7XUC\nIBkvmpgmaN5kQY5YAxAzA9a++e/X8ggM4SbR2vnc4u8+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2003", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2003` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAYUlIzm74sw2lAH6AYPC7KruMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzOGNkMzEwLTFkYjEtNDhjZS1hMjcyLWRjYmQ0ZmZlMDE2NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk1ZDg5NWEtMTk4\nNi00NWM0LTgzYWItYWQxYjczODAzOTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE6DgoKu7bPMGbwS5WGRVe6GfPS5tQiX2/ed4UfAxiGzeLAoGfb7BIaHV28ft\nnnmCoSv9T6JCaoeM8LKDfiUWxaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULvjT9ti74Ka7pplbd0BxWAu0fIYwHwYDVR0j\nBBgwFoAUZH++Fd9f1fKF/KGZPhUmXwdi6NMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAivt92DozcZgZk20ztoXQSidXTWgC3P/A\n6/A+dW/OVXsCIQCUsJ5VC3uTYP4sa1H8R+lqtumzgeafnp5Y+eOKgg9JBg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcSKmyoaI8S3NWjCK01i0sWaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzhjZDMxMC0xZGIxLTQ4Y2UtYTI3Mi1kY2JkNGZmZTAxNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDXNq6ELg8l+YYNJ5P8Ih8rlh5rJ8x5F0kqg9NK46/ohKJ\nTOGkA+S3AvQ8kjcnMibdipbxpe6FbURRUF2GaxLoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZH++Fd9f1fKF/KGZPhUmXwdi\n6NMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN0m8c62BidYxxX/7oniHRhU4tSEtz4XPsVdeWyIEXJ0CIDBO+PBcZVqq\nKj3xYhtIQ5+tiM/J+7eC5pHqNLL2ELHF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISARUKqgjOH0fCv5lI87gCHWsdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk1ZDg5NWEtMTk4Ni00NWM0LTgzYWItYWQxYjczODAzOTVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhY2FmODY2\nZC0wNDJhLTRmNTgtYmIxZC0yNmE1NmU0ZGQ3N2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARA2y/NxggelXeXpXWmsFR+TcSUgDXJjJLeSy42qU7drYlqsAfJeN6r\niNXbInaNAh6cQV6OqxfmOqKgGamvlSApo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQu+NP2\n2LvgprummVt3QHFYC7R8hjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgVyn7QdAMBUIfU5aEYQx35aWegYrsqAPFQXXCs9uEA3oC\nIBus5YbaROZTTUJqobUyqqUJsY6y1hfb2HC+edQJqxKd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2004", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2004` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAcF0wITvjEB1IkdRaifhKnBiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMjdhNWVlLWNmZTYtNDVlMy1iZjE2LTBjZTVlOTgzNWVhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM4ZDgzNDktNGZi\nNC00NDQ2LWIzNzktZjI0Y2ZjOTBlNTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElMaezyp5mMeDAn+gNYzXwdEd1BlojzFyekxsRz4RWzws4QO7VGzcfVHTXTec\nVVjuh6CdZ3JIlhDteny45L+VfKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Id6U6atiEwRDEyDRNF5/Ldnyu8wHwYDVR0j\nBBgwFoAUjzo2S/82YjiPdkRSUBYAmsjbPdIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB/5yay30iKMvX4bQIhjkCGdtdzA7QD6q1i\n/nuOqQr8wwIgThqn0REJj/nx/B6PtZfc/geT7pv0UqQVmxQhPCD0NWk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATNEhGu71CFOztiH80edkfg+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDI3YTVlZS1jZmU2LTQ1ZTMtYmYxNi0wY2U1ZTk4MzVlYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4iI/OOhY3/YtcaeGLh1OcOpz3ETV89RHEm8ORhCF5ppvm\nF+GjM8toEQQ8xLb7pFAL0bSVAdpsFu325P5fhO1Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjzo2S/82YjiPdkRSUBYAmsjb\nPdIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGLAwOZ/Rd4VCp0L/Us3PFNq9+a5PtBYjqcvjFUHhVksCIB4C4TKEKTAt\n8G6wbE2BjrRIg2rjmrLfUFLD1aYqgayS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAcNAe/+/AfPgwCz/tJy/NmC7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM4ZDgzNDktNGZiNC00NDQ2LWIzNzktZjI0Y2ZjOTBlNTAxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNDA0OGY3\nMS0zOTA2LTRkMGMtOGRmNy1kYWNiMWI2NDg4NDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ2peGMmBvwaTsd5wfaBfrG1DYDSGmczsaSDFxOMuD9XHikZMqoDfcM\nAheTxwCxGqw2IYDIomxgcEZpwN2oAICro3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4h3pT\npq2ITBEMTINE0Xn8t2fK7zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgVqU9wbD9ATWIly/rABuOYR0wHTU875W5Noj+9gpwecoC\nIDxiJnddxSRsamazXs75RTtf9/wIW40WGmzQJj7xQrF+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2005", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2005` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISARDIq0CDMTWR5q/+JsJ71EO0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1OTQ5Yzc4LTY1ZTAtNDBjOC1hYTFjLWE0ZDAzNzYyZGU2NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdlYmU0ZDgtOTQ5\nNS00NTE0LThhZDEtOGE5ODQ0MDVkNzZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFom0tL5Y9gjLPK7dNK7QtYz8mr24tLUsrwSs2TvzKaZlT2TegmvYj/yfN4R6\nZD3kDWMGhVtu0/kEQLX4+1OtmaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcDhPjj2EJK1Gmlr+5V1/4Ffmg+8wHwYDVR0j\nBBgwFoAUcF1DNW6V/fYuo+8ROMELPdIaeHIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDSYcgECOeA7OKIO1Jf4tKMNzo8\nJ8EQPWaT5F/TDZJggQIhAOG01aG1qYU/3sEHbl45jBpkk1iBGD+5mQ96J9AudOkh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZdHYSYlb8NjEQFld4XDXS0CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTk0OWM3OC02NWUwLTQwYzgtYWExYy1hNGQwMzc2MmRlNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVrPIqsJ8y6q8wbTv11Tt4BbQ/IJSyNRJoBsTriZSXgsr/\nDuitf2xLaIxiRlxPLN5spK5qdmvwlWmjhifUFwopo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcF1DNW6V/fYuo+8ROMELPdIa\neHIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANcnfk5nK7sqSDdTkLZSr7w7US8yN9aEfYrTYjpDW6j0AiBNz68MUhob\nVqDmnYROCgsXk574m1m7QGq22WTZWt28kw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAd21hgA4cUm3vHHFL+6gFn7mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdlYmU0ZDgtOTQ5NS00NTE0LThhZDEtOGE5ODQ0MDVkNzZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NTUzZDA3\nZS1hMTBiLTQ4MDktYTUwNi1iZWE2MzUwODc1YjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASCot0MUz1rDgyAfYOyJTaFoqdUY9lbDyUyAsUsZuWjQxunsFB1OiGL\nBT+154OstuyrBLyqHuCvZ4RNR/mL+m5Ro3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwOE+O\nPYQkrUaaWv7lXX/gV+aD7zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgExtS/1ZTEa5RU45eok03cBpL/P2xjSL02GacNHIH9FoC\nIQDccAyAyXc84+luUm55n/nJGuLl+/rx5+wJqPzWKC+E5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2006", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2006` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAT4Hnbay9GwL4ZsFAQtfLCkhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwMmUyNjcwLTJiMzYtNDg4Yi1hNWIxLWI1MzEyNTIzMGUxNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJiMDM3YjQtNzNj\nYy00MGM0LWIxNTUtNTgwNDllY2NlYWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb0lk05HOnnMY96+u/ZZ2xeHb3ve1PjwMNedezRjp+v6xlFqkDAQh/lSzUREI\nCv7JQE+lxlz6xitMWC9Gi/fVLaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzTOZfILHRqh6Su825RMYqVC53L0wHwYDVR0j\nBBgwFoAUoAdKxyXZ1Jfa0UuA/7BBtMiRnjkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAOqlJd2h\nekVhCMcSGnciz3tsdreDZmjiUyAxJq9XCODMAiEA7BoWCpHBu1KJVQ55K1iX45th\nrf4eUBZGS7az/mWaK0M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbjwq153t4i/Gpxibvc0Kn+8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDJlMjY3MC0yYjM2LTQ4OGItYTViMS1iNTMxMjUyMzBlMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQR2qDekbtO7Xosd9XqDBkjC8mPluqdIWgJrB8D8zEKt8QR\nn9EE2X1YNHXmqZzMmjScrDyHHxTfJ4dUpNKgozBXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoAdKxyXZ1Jfa0UuA/7BBtMiR\nnjkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCUi7VjQWOUCb8wrV2mmgJcHmePeYkhs4kHI2n3zFHtACIQCqn7+DFRC5\n7mG09KEjqibRn57FRH2/QkhLhy7DpK+vzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAXJp5IXiMOtuZDNOLzTl4TYWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJiMDM3YjQtNzNjYy00MGM0LWIxNTUtNTgwNDllY2NlYWU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNzViNTJk\nZi0xZGVhLTRiNGMtYTc3My02NjI1MDE3ZmIzYTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQG1CRKW7ulOTerbWgHA7tYf1Lv6GgONZ5BI96JkCLKcYx3YzLKr3//\nExvH+LSUpoS8MAd6F0vKSLUdNfpbYxXao3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTNM5l8\ngsdGqHpK7zblExipULncvTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAK91g+VVY4C6XkQnlTSqQUcH/LhIMa9Ne6xkzaHInXec\nAiEAmKZwneRAV6E3KRMeTDUHKuoODSCVg2ayUN26I32Clt0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2007", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2007` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAcYxr83/wKmEXVGw+Ud/9yDSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZDc3ZjA3LTRjY2MtNDI3Yi04N2I1LTk1YTFlZmMxNDJjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2IwZjFjNjMtYzY1\nNy00NTA1LWI1NTItNzkzMzE3MWUyY2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWWJw/09zPIGZ7LpMtDnT0dQyhzQIPdBuATPH3I8hbmE0C37n0mRgPx754AWB\nGsUrpVc18riPlc2Zs1CB4LYfxqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdP72YsmH6p0IP0gOXz4QdnOXcrkwHwYDVR0j\nBBgwFoAUlAKdXZfp3HouuC597jcjJhvcA2wwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMLYGsGw\nCzSWPIUI0S5YQMJyLWfVAxRC31H0X5eopVTYAiBcol3ceeAG1z7nI9A/gEogKLtL\nfS7bkAzqPrPYSw4ATA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcn2pbXaQIgcGGxJPVCwnAb4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGQ3N2YwNy00Y2NjLTQyN2ItODdiNS05NWExZWZjMTQyYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUxNH4tWIpw2bEvBFmq9PoglLg1SB9Qqp2UjtQjptbqv79\ng8ehx5ABthv/x9DZBn81xvi6/ASOyRvi4pWRSvZco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlAKdXZfp3HouuC597jcjJhvc\nA2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNRXM7Ym0jiyXUf/TezpaaOUxTlouiqgQt0eD5Bur0jMCIQCrW2OPIGEY\nKtiLmipOXt5Vsv9tmr+sZQ+YAaj4Tv8wZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYSTtdqajy6/zeEnLVhATI9TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2IwZjFjNjMtYzY1Ny00NTA1LWI1NTItNzkzMzE3MWUyY2NlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZDNlM2Fk\nMi1jN2JjLTRkMGYtYTc2ZS00ZDdjM2M1NGMxNWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT4EcXuTc4MDZLqXoS3160yswtToW/8gbrwtJ5EkCTwKToqZKkNmF7L\neRr8VA8ll/AZF6NXSmIFzw9FyI7oivlXo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0/vZi\nyYfqnQg/SA5fPhB2c5dyuTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhALfxNnCF1tesR7yoxc+CeZxyHt4UMW7511pLJrCraMIt\nAiBKZbPv9wuZ5ikM7L3B/nQOZ4/b2BmVoM4RGaFNA/Lh4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2008", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2008` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAaO3JT49DF9th2r7W6HmjyLkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjMzE1YjM3LWNiNjUtNDlkZS05YWM4LWI3MjY5NmU0M2M2ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkwNDU1YWYtZGVh\nNy00Zjk5LTgxNDUtNmJlNWJiZWJlMTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGst6wRlDVqfphYA0bGeMCLQ6stMYAaiGRgtHR+BC3yzwndJ8Ysk2CFZl2J/p\nzaebwU3X/atY6vAqpAKT91dzw6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdJ6BnDS14vnawe64defQqiYhyoQwHwYDVR0j\nBBgwFoAUaE8JsEVKaHzkRFC/S5k9PqtYlOUwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC8VuMC\neZQiJVhlZmK1l6gN7udhwhms+T7exIfijydPfAIhAI+hEbTdXHG3S4/QwdL7l8WV\n8bs9De+LkBh2D/dhYOv3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW20q0DX5FfdQumcglJlLmDNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzMxNWIzNy1jYjY1LTQ5ZGUtOWFjOC1iNzI2OTZlNDNjNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNLKGj07Ofrsn2uWr9rBhCpyJ/AXuf1YyzbmjGkDNWz7CO\n7tHUzysGZfuccXHoZFCFeHxLofXSVf3nsh8mJNyoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaE8JsEVKaHzkRFC/S5k9PqtY\nlOUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZfHxcJ/Kg8SvD7Y6RjtjxnLU2Ke3FHLqCmQjTcVscisCIHk1fxilzwnV\nMSfdoGeguOvy+Y9MX6gxX96m1Vs3hrYy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQCX1CSFiFOBqhng0sKfxhBCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkwNDU1YWYtZGVhNy00Zjk5LTgxNDUtNmJlNWJiZWJlMTU5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMzUyNjAx\nMC1jODM5LTQzOTYtOTU1ZC05YjhkODFkMWNiYzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS1LCD61N3kUS47DW8WcOfEXlDmVV0ghQ2UpvXiZrFlc1eLK1EwaCk9\nTCQMwL3MfOO7Jgch3gBWWiSI1NtuUDCUo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0noGc\nNLXi+drB7rh159CqJiHKhDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAIkKGxq9EAcmcqYq84QwTXpzgWC/S2XC4vJuN8YevRc6\nAiAKfZ3F4AES8mC6Ox37EFWk6uxEldwak6nY5a3+27t9Yw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2009", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2009` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISATBWKlsLI/4j7oc+0OMRD0ovMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMjk0YTc2LTgwOWYtNDIwMS05OTE2LWZlZDVkYThkY2E5NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDEyNzgwYjUtNDJk\nYi00YjkxLTlmMDYtOGZhNTBkYTdhZjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELZYNIbBxaw0CJ5upgoLNg79V9dS8sVzUAuyZc1G32eiKbrabumxMAiUJJcwx\nBn5eg2vo83BBFDrK9rcZLStgY6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGs+OJskUxxLsMkFMBCrqq2N8BeYwHwYDVR0j\nBBgwFoAUvucJEeBoE57epdf54C+kFfSs3G4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCNecQENYQ07S1di/aRBvURwtPQLj3vY1CGTyOhCA7m5QIhAP6k2ENz\ndVOCExmWybXrXjaqce2Gph+oD1WQxNenTx4M\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVCpEnys49hXcIoxHVM2WvDiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDI5NGE3Ni04MDlmLTQyMDEtOTkxNi1mZWQ1ZGE4ZGNhOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3EOmc7ejFhoGuUNH5lctfc8CCZikOsSd9fHAfuBYkQLWQ\nAEZ6/sg602e+U2cGaUVjXaWlj+mXV35j9VxlA6lDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvucJEeBoE57epdf54C+kFfSs\n3G4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANZjOhLAyqla6bbQ3/CnYaFZ9M6KLrwfq/JSMMJFs/TCAiA1HGIpWaqf\nfAv/Y5+a8m2nkxNy4NFlVxdbxLgekUyjow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARzh8qkgCM5jFUXMGNeBFpuMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDEyNzgwYjUtNDJkYi00YjkxLTlmMDYtOGZhNTBkYTdhZjkyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZjBiNTUx\nYS1mOTU2LTQzYTgtYmVlNS1mNmU1ZTEyNTQ0MjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASph4b3y22Jj976OWSUOGya59furGdPuNMLoZVHz27V7VyCB7UZWbSM\nzad4IkgO1oCdvpLICNoHEnC7CJvd/TZfo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQaz44m\nyRTHEuwyQUwEKuqrY3wF5jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAMPzshjP1+dVNEODftD+rOi0lsrMjQOk5Tcn/D3S0Ta3\nAiAkhtQ8zoVZv1dPxnmxqmSBym006ri1y61ahL0eHQrZvA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2010", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2010` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAQF0VjwJ7VeACYQHsraqTPYAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4OTkzMjQyLWQzZTUtNDQ2MS05MTFiLWJhYjA1Yzg5OTZkMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTcwOTJmZGEtODg4\nYS00NjBjLWI3OTEtZjQ1NGQ3Mzc3NDc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe8zmtmTNJG0PbVc5S5Ex+WDo4BCNcC0CIgJZXkkxcw3yK2/HDYRuMe2ZHTyV\nQt9+TdLdUa9TiWeKrBR4BEOK5qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Y1D13qzzHFSWSQW/lXHoCb2nUMwHwYDVR0j\nBBgwFoAUJJL1n3L6jUVPuHy3w6NACjgEkM8wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCtVhYHXnXsFXhXoSeFUvt0hvo10TkCicU/dy7D88718AIhAKpoHmTh\nqA6XOACcrmjZsu/3WeUzEFsqAPVqqPHcnfdf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASp9u4Z50da7APmVqGdzuGHpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODk5MzI0Mi1kM2U1LTQ0NjEtOTExYi1iYWIwNWM4OTk2ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNmi0Y/KB1H0jnGqszgTqVzLcQkbWiulTNYUJbUGER/eLf\nHlFG807zPeLD/6G4o6Sz7samdtW71pr+PN+zxQ9to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJJL1n3L6jUVPuHy3w6NACjgE\nkM8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRt2zjrHWxfEQm+avVza104D2LqlIcvXEc9jqxnXZRRkCIF16CEDbRGEF\nWF7DYYIDRheSl6b20Ks3w/E4yu/xeNQ3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAeF4Wh+JFNOmsHu67KQeTCCVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTcwOTJmZGEtODg4YS00NjBjLWI3OTEtZjQ1NGQ3Mzc3NDc1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNjdjZTgx\nNC1iOGM3LTQ1YzktOTcxYy0zZDIxYjkwYTY5MjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARtUGHpVFNhI8RW7DSXAup3IJqfoVsGXs6ZTHqMUVMnr0wF/MX01+th\nP6OLLR5cBJI9y4LJn9Ih4wlm3UDDvd2Ao3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVjUPX\nerPMcVJZJBb+VcegJvadQzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAJGgXcGZo4otqeelpZX4N4nuTWj7NlTMl3rIsNKdtoZW\nAiBSWaxE4wMPGlRRvQxNM3y7HNGqxtSdvKYqbyspPUgMTg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2011", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2011` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAZY38zzpqjJ3AexIcaOnwCEqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzMzE4MzI3LWY0ZDAtNDc1OS05NTNiLTI5MDgwMmFjOGM3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M4MjZhYjQtZTk1\nNi00YmJiLWEzNWMtODFkYTdjMGJjMjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzt9rWcKNWnKUBcAgYIrNy+YWhM6d23JOvKBk/WFKpqAlRkX6xqpwdEHGippC\nh3NHVgyI/aMlBObTHzXDg6YZwKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO5TGM2eFwnfxECfT9TVV/SivDqEwHwYDVR0j\nBBgwFoAUSKtenhaYtjCfV/KtQzuX4zSbBVMwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQCmAClBS1dQx2/3ujdFBN+x83ERKQ184NjbFmVjz9FHwgIgI661BqTPHMagvkjA\np6yM9wws1Oc2+RB+Fi8MMAWge/4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfv7LqGTOZAPkX9hO2rgyJgeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzMxODMyNy1mNGQwLTQ3NTktOTUzYi0yOTA4MDJhYzhjNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6zr46pEG1PQd6fjWFrDlCSKR7iO5RkIJHMgkJaRkTOJXk\nlQz+G6I0LD4kUfIZeHn8XF101LkxB8juOCmz06ORo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSKtenhaYtjCfV/KtQzuX4zSb\nBVMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPilPBupERCsHmdrGuJi/qSPkFGCJCKmncgabK/1OS9PAiEAyEnp1ku4\npF8/s61O+TFEVtqRgpeIwe1s8JK/TQWN9BQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbkPEGsJnc18kEiX3tTkM+LAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M4MjZhYjQtZTk1Ni00YmJiLWEzNWMtODFkYTdjMGJjMjU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZjBhMDc0\nNS0xNmI4LTQwMTEtODc4Mi0zMmEyZTlhNTA2MmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATFyy2lRltZazNAaNw7g0lcjAOccHiggMYWIDIAlujBn3x2YIery61x\n2tADm1mcaDtJV911ynU+lvy+h+Q2tYg4o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ7lMYz\nZ4XCd/EQJ9P1NVX9KK8OoTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgcTjOPy5KdD8iWoNvXFPq8v1mw3cB5LamaqTfVuzNDmkC\nIQCY12UFveP59eeF7JK+po+YR846o7Z3inpS26A7idlAAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2012", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2012` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYcGMK4diHFODXu3xKxwLgGOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlYWFiNzkxLWMzZDAtNDI4Ni1hOWJjLTEzZTU1ZDFkMGJkZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc4OGYyOGMtY2M2\nZi00ZTIwLWFkODUtYTdhMjgyZDU5YzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPDUI1ON+Pj/ZKe1oQnxbUonxMt3arU0HpPAPE6VI7lOP205FCXDNdfzQB4Jj\ndjDROZVASTPZSN+i97H2yQ+qQaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCMa99FGuJK4m8gRBnhKUHh07I0kwHwYDVR0j\nBBgwFoAUIaj06PUkPKyDTUDxiILOWYa8xlYwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDi9PLe933R2EGkyQ2hSUm64R/u5cbULrOeBx9KBrulkQIg\nbxsmSyF4c5lBvFmR2AbosO3/B/4QEISHa2TLaW70mPU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfKum5BOWI+APs7DkJgvhWf6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWFhYjc5MS1jM2QwLTQyODYtYTliYy0xM2U1NWQxZDBiZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoR67SGFNq6TSbm/P9SGYohADMARMCAiQMWfXV/vpCna3a\nN9kWiDO6NgMVZ/oxX1aK3luzziskHnt3/sIERiaWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIaj06PUkPKyDTUDxiILOWYa8\nxlYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMcOgJEZfHujqKIs2Vhy6hHRb8PYHlcTuCFwzMIjZD3uAiEAmfbNnRqG\ncQcVh4Dq64p66VNuZvwLH9MAnjyOnd5u/Oo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAWQjbRPBxsj0i09mtIWRgkxZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc4OGYyOGMtY2M2Zi00ZTIwLWFkODUtYTdhMjgyZDU5YzkxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYmY0YTcy\nNS1lNTU5LTRjZTQtODYxOS0yNWM3ZjFlNzFmNjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQlfr4hYC9vgVu1JyyAIlTlQSe33JC5aOti6q91MPam3Gy6IFrL/6nT\n/z0nwKWuQm7Z+JkQabCnVHiNYdkYpeR3o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQIxr30\nUa4kribyBEGeEpQeHTsjSTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAI3DIoR9AsFvzAXW6PTKoEDmMbW8PCiUPhoEipkqDE6+\nAiB8PeRzriqRaonImaZGbu47MAQhURohYAu2k7UYUkER0w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2013", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2013` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZkQ9+kwdgjEm6C1xFrFaECFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0MDJmZmM5LWEyMDQtNGZhNi04MTZiLTM2ZTM5YjY3YTM1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJmYTQ1ZjQtZWJl\nZS00YWRjLThjMjktYjJjZDljYzE1ZDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHIIMRkeLRevAsunOeXgenu2RsCeTYXEMriL97r5uh6tqptHQrDRZu41GRRs7\nAxck/Q36cHh14b3iQAI45Ft8/KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj9a9arzaqV98qpCYStZE4K3qhRUwHwYDVR0j\nBBgwFoAUa2Yr+asMbY2e4I0mUlGY+o2aXeAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCUTQxHQaHYZl2FH2O3vdM1RzvmFNkw94sKZBmWhDmzCgIg\nD4BPY9/RMCpgJfRk5itHhfyG3Dr0oV8AEwLrrkiLEe4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe/25mFD862k4ywXx6PaMu7MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDAyZmZjOS1hMjA0LTRmYTYtODE2Yi0zNmUzOWI2N2EzNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZZp+JQuia7MlOSJqVzXYLDMz9Fjmia5Ytib/+dC0UdHfi\ndxxatACa6Pj1ILV26QSjVub88As/2iJ5JYwSb56wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa2Yr+asMbY2e4I0mUlGY+o2a\nXeAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJT6vD1OJ7VaW2o+bt7E/SAsZm6vYsDndTnEQ+MegILfAiEAxhlVBx3F\nN2cQqxvmo0Na70hLyYRmtiSSB8j02EpdpQU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZIPda7+fWfUbm39sHiaHLDNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJmYTQ1ZjQtZWJlZS00YWRjLThjMjktYjJjZDljYzE1ZDI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZmQ2NDhm\nNi1mNGZiLTRjNGEtOGI5Yy03ZTliNTJlYjZkMmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARTYNhFM562eZuYN+QDJb75QuTR3DPbg05Xe10BGAwwc0v08cdFwGBX\nscFfMEDR29x7y7EtTAdA2a0ScqhLl0S1o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSP1r1q\nvNqpX3yqkJhK1kTgreqFFTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgVZh/KExKMlyFbrRKhqoQQJ4esrRy57EIUCdSpr4JGP8C\nIQD4QH5wIGlg8Lka7OGJ2tr6+HomdsYuhb95G9mTnrMW4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2014", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2014` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAV1lu1vRfw1ahicZYgiMcW5dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzOTg1NmE0LTc2YzctNGZjNC1hMGQ0LWYxODFmNGE0NmQ4YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2YyYzhhMmMtZGNm\nMS00ZDViLWFmNGMtNzNmNGJjNzNlMDEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEte03POmeEMZvEyBNIoN+4zT6J6TPOnAR0olr5XdgeMZUfFwsUv+nMse91DsM\n0K7yXKGnXiLdNLSIPMr3eiYj6KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEXZeaxX0yfVhSR+H5Rb7BfOQLVswHwYDVR0j\nBBgwFoAUIw9EffhKgnk1+EkASNOJMzT2BVgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDzaSTbsOj/\nWwQ5YPClIVEltOtiDxSakhL1k74wahbI0wIgEsjlao3ootcIdWAlTvK2INksrPcp\nDMTIYH0Sqdeu1/Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd+nNeGDcqm7xMx5A4whOw4LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzk4NTZhNC03NmM3LTRmYzQtYTBkNC1mMTgxZjRhNDZkOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASK1B5he9VHhC/lcVZg+5tSsDHhnZoTUvRhsM4QTMJSg1Ew\nHVC4PFfqjtnogGSmrKAI85GAChHfDqyf4+10K3Y4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIw9EffhKgnk1+EkASNOJMzT2\nBVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUYX/qSYRguuI1M8UuT6s4qDtKn6zZZEixY/ooYMf3W8CIDK3QJZANh9a\ni/1I+UgHnE5RMAt+S0dhVRoSKZYMcwup\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAW7/j2/wO3Bqom5k5vPTZUDgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2YyYzhhMmMtZGNmMS00ZDViLWFmNGMtNzNmNGJjNzNlMDEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NWUzMzUw\nZi1lMzQxLTRlYjctOGJmMS0wOGExYzZiNjVlNTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQPOXXQkO/9V4N4WiziCtafJy3u8nsXtEssKBbhXBw4ZNRLY4bJ9UXa\n8DQEXAUyudpuaiG1douJzGNNsorY3fb8o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQRdl5r\nFfTJ9WFJH4flFvsF85AtWzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhALYPXk30bL8idmeOr1M7z+i4+DuK/8UAVObLi38eNKpz\nAiBsOzhbcq55d6DNGMqYwdP+/WQrpGUsIIYRVyWzBZ+mEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2015", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2015` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAaBYWlTRoRwOQiy99GkoBWmQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzZDMzZDc2LWMzMzEtNGM1OC05ZDVmLTA3OGFlMTRiZDE5YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFjMTAxYmEtNTY5\nMS00MDAwLTk1M2EtYWIxNzEwYWI1NGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwWKC/IT8QCqIh17NfA5g3bRjAJCYT9CJgDEKI/StfbwTtmxFtyNHAYE43Yt4\nIM483ewXzaO/eUvlnZIb+2QZaqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkTqM0NXVuEvlYZLALeIClPb1kUwwHwYDVR0j\nBBgwFoAUNA4fahNMHdaM6KMdgsYY4jiZnPkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPYDTtI6J4sPKYgZBsUhmISsFii2NeCgzB9u+9Dt1fu1AiEA2zpnyLUC\nj88FxSNtFKP299XgH0DwNwHACOaSFcEp788=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaTiyu9yx1CHh70csG6jQYhBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nM2QzM2Q3Ni1jMzMxLTRjNTgtOWQ1Zi0wNzhhZTE0YmQxOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUHUknvgw5hUEWL8cL90GnQiG3l/qqhKcG1awS1NB4/zjp\nBFmXaOwqa1DTfGuPWF7pYzMQON3zwA9xUjgGs7iHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNA4fahNMHdaM6KMdgsYY4jiZ\nnPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUrCE9mM1Zl3Q43DbAuxnJGVKavjXIX+bEhWp1fwW0AUCIQD+TwLiWb5E\nhCAOlmsxpSCv/jWZacPstvxRzOd4bwNmYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARyz9Qh9Fa4eecUgbHMuEaBgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFjMTAxYmEtNTY5MS00MDAwLTk1M2EtYWIxNzEwYWI1NGIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NGJkOTU2\nOS1iYmZhLTQyMmEtYWVhNC01MmU2ZjdiZTUyMWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASPqgJZrfIVNmTr7HGPkPXoJ5wen2lyHRyG+IvxFkrkBwH7xTnhlaj+\ngkJp7CArIq/71ga4FpQ8QMfje8D3DtyWo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSROozQ\n1dW4S+VhksAt4gKU9vWRTDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAKiAohX9fZdu+t3RLdEa0jwEJ1rwtAFKBRcdj+FVe9wJ\nAiB6wqL3+yS0Yr+N2FRfQJoOLdcupQIT8/Awopj5AnsGYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2016", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2016` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAVdj0S1oI1oEQ4fDpax8EJXFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmZjg3YTQ3LTVhNzItNGM1MS05ZTgxLWRiMmUzMWI0Y2YzOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWVhOGFiNzUtMzlm\nYy00NzQwLThlNTctNjNiZjc0OWFhNjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcCSDf8lR5uH3JTlgx18lubQHmoKozDHhTwhydXsUmlKPpLD0sWuO+cdaR+Nf\n3HXiIPsbWqTTaqn6ngF9iOd0haOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN069PzVAcbCejaNz+bFs6NbrVyIwHwYDVR0j\nBBgwFoAUV5pTESct0r9C2bb0dIVfak9in78wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgFO/JxC7nXJmGUFI5hAVm0lBdQQU25bFdE/xf73YC6VACIA4Zxvx4y/2u\nUI252AhChFwPVvrDaULZlRClhRfVPfS1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVZs7yDpVAZt/Y42WDNlBcRoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmY4N2E0Ny01YTcyLTRjNTEtOWU4MS1kYjJlMzFiNGNmMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8alO9PL6Ykht7e+3FYOSL7Wxw+dBylRunw0y4e+OmftPG\n3TOAN9XZdiAtcjbglpVHLlhwgykB8hvWZxm/XRNgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV5pTESct0r9C2bb0dIVfak9i\nn78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMRcoiDcgyb3ji68QUq9Qc8sqJ8lvcRAjWh+JQTe6aNoCIQC0grz/ARO0\nHpMOWm/4D6y4QCDYWnDjUNHIYx3fdyXdCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAfEUuqODuRAARbquRjiTHNerMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWVhOGFiNzUtMzlmYy00NzQwLThlNTctNjNiZjc0OWFhNjk3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YWJiMDE3\nNS1mNmUyLTQyZDctYjMzYi0xMjAxOWM0MzNmMDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ0hjJF42qkUrXLRdb8l0bjxhkF3O4Bks0rDbX8YLMnbvsuvGvYe0u1\nQaCtNqIMzngs99nN5y14T6wnKySri8Axo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3Tr0/\nNUBxsJ6No3P5sWzo1utXIjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgIirr3ArJ+0aiYEAYgTreQPgb1P19shaCiIs+qZVkI1kC\nIDn+ctlNSOhhWhISaF2IJHjiln5dwwkQATUXP7ugySzT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2017", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2017` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISATiueSycVgbgtx+Mirya68qXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlNWNjMjBiLTAyYmEtNDk3MS04YTlkLTgzNWI5YzIyNjZhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjU4Mzk3ZTItMmUx\nMy00NThmLWJhNDItMzgyYWYyZWM0MGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDs1ca6OsKlhPmpxU7zFc3PrlntOl9QrQay00uZsfYQum/eo3RRtLm64MnaVc\n9YhDXT6abTICBE9Ia/A/+gaQt6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIeJ1lqQMFgwWiJST7UGYuew/zUcwHwYDVR0j\nBBgwFoAU5D/WRpi2E9t4uTej8hOkUm7CFVUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIEzcG2OIvRWyqfp4jewaIxUaQLTO/3b4uRU1OHZaV0m7AiAwP/5o8ym6\nZQrgPPFJe6gIEvXW3K6CiLCG42ZUtZ6pBg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATfOTNuU+GMYtrouZgHmy57zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTVjYzIwYi0wMmJhLTQ5NzEtOGE5ZC04MzViOWMyMjY2YWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqHnO/7u7YzB0S8l8cXn9NbM18jV5zOfESQHhaft5BNPkH\nVwI1pHj5TtkUcgwX31Bynv2PcUKCeyoEm85UFAYTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5D/WRpi2E9t4uTej8hOkUm7C\nFVUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeOSdMIJXHMQib+1HwAyRrziNz0hqoPqi71Eu9iMr4/YCIGRstnavzDZq\n+JOAEDyFRf3oeRkTnwe67xH+72mrrfHq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAcB1AaYztxfea/IR0+NpM3d7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjU4Mzk3ZTItMmUxMy00NThmLWJhNDItMzgyYWYyZWM0MGIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkOTA4ZmJi\nMy0zYWQ2LTQ5YjMtYTk4Zi1hMTU5NDNlODhhMzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASgVU32bJrv9ccZhsId5Jut3uJAmCl4+IBxT0K/BacoFl/bTLp2T3Ap\npn4luAEnH6g1v2DknArlMeYvaycZh4+wo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQh4nWW\npAwWDBaIlJPtQZi57D/NRzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgOBifvfWFUhYfy4IGt6uAKKBwTwlKDg7Csdt6cdOzdPsC\nIBUmsV853ykdfzNAIlAlsAcB89K6SD8eBczDIJMvuWsH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2018", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2018` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAbLL5cqEJ1g+9RlPX48gMqKTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyNjJhM2E1LTJjMDItNDZhMS04NzcwLTMyNjJmNjgxMWU0NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmI2Zjc5YTgtNWFj\nNC00ODFmLTkxOTQtNjdkMmY0YTZlNDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdGquxrBW9b8KSGekQ2ZX1sTdp6VZ9EzzXr+BUGX7hxj9DKQvoY6RtxLYWYIQ\n/8xF4OK1t8wghijwp6yG8/4cR6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUESgrfS8O5h7tR6hxHFkQtFcLWN4wHwYDVR0j\nBBgwFoAUNJ15M94BU1sI7TLjyWCrpV/W2kwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCgjMZElNZPoZ/WapxNzWoGI/I/iMne7XioYeFg\nd+s4UwIhAMzMD8i/VdKhg0H3eBop5MVkMbMyhdQ81qqkGgOzdHyq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAazMgkpFWKC/k1rIfh43B+DUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjYyYTNhNS0yYzAyLTQ2YTEtODc3MC0zMjYyZjY4MTFlNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJ7ZYQxbobpq7z2jqakI5HlkqnfbZHgqH3DVmPHVsLun6f\nmd1xbRkSXDZBJkZXMFllDOa7qDNhZn22FEImwI+zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNJ15M94BU1sI7TLjyWCrpV/W\n2kwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOKH4lKsl3n+QYj+MrFUdUtBISThUOheC8Kb0IDQT8QaAiAI7qRUkQvA\nQgXKzuXqJwxKqs4iBj5f11tXFjO3BAkl3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAbyChIbnf2tqM7cYduXTNrdvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmI2Zjc5YTgtNWFjNC00ODFmLTkxOTQtNjdkMmY0YTZlNDI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZDhlNTRh\nYy0wNDdjLTQwN2ItOGI2ZC1iNDQ1ZmQzOWM1YmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATCAx0ik/YLuR1S4EZpwY3ragilKVscfoV7GtcNRVqR7vlE6l2S0Lfv\nWBfQ/5DcpU6TSnZCy36HapnEV8YR1MSto3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQRKCt9\nLw7mHu1HqHEcWRC0VwtY3jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgerNc1ysiF0dXU7p1aStgUe50PYhnzYa7tC115uM8kR4C\nIF5FjSdXirZg0lO5QfWcUwV6GcuOlfzsu25Kritpm9+J\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2019", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2019` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAeAU8BPO3HOaFx0cjUhDKqTPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhNDY3MzZkLTFjMTAtNDE2MS05NTU2LWIxOGNhMTI0ZWI2NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFiYmMzZGMtYWFl\nMi00MTUzLWJkZGYtOTRjNzc1YTk1OGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB+lcFsky/ntW1UiZVGLoxm+999/sMyWMdE4Ds072JsLtK0VwIJD9lRP+9Beu\nH3O62viV/n71VICSqJ1JIFhvT6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULh/Sp14Gplq17rsHU1s7veIwIAgwHwYDVR0j\nBBgwFoAUuqTbVgTiv1cbelw3Bt7ETSXqUZgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC+kuL8bgXQDZnas3woLFWfMI8dNBO+Sz4bXotc\nkidujQIgXNf/jDud7GSXYE4mNpH7E+610f0tSSZU0XDSq9iilxY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVjA8XfUB8eVtRiL4FhsNa5oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTQ2NzM2ZC0xYzEwLTQxNjEtOTU1Ni1iMThjYTEyNGViNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbZWm5aC215tDtGu3YyLZ+9COmaSqE+TIzk7Hmy+XGMJG3\npz5q8pSOLoZ/nJCqc50ippjmrlEPiu/5Cnqv5RBgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuqTbVgTiv1cbelw3Bt7ETSXq\nUZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRBy94n7MfROF9U3PuJkWNUlrNPcL5vzozZJuHAbxC4gCIDd7g1+WxRM4\nXEz7I85Q0Mt3vhLCRmYqm63+jAaWnYlg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAQ0tnL+JtcOTzx8vw3ARs+dDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFiYmMzZGMtYWFlMi00MTUzLWJkZGYtOTRjNzc1YTk1OGVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZWUxODg3\nOC0wODBhLTRiMWUtOTE5My1kMmU5ZTliYTU4OTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARliLesPPuOMgAXYDywCX1ZjAcnr3lDBII5B2xPMQBbm2rHGB7PVHsx\nB2GVA73kAVyAzzwWq2vSqTXBNFNWfkImo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQuH9Kn\nXgamWrXuuwdTWzu94jAgCDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgW4YoOdY8MgFbmywOjUd7Hq3bXGSdt5Xz1w1UA/2+h3gC\nIFXtddH4DrIw5ZQRvEnA4FU9DZ11USxAFmxG4JgbEEva\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2020", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2020` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAfQsi/+BsWCsv5pJX3OIP6zRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiOWQzNjJmLTlhMGItNDYzMi1iMWZjLWU5NmUzNDU1MTNjZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODExMDllNmItYzNh\nOS00NDMwLWE3NmUtNzI1ZDZkMzMxNDBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETz43BvAJJQi4aggCd5kFk6JOAUWQ7/+TMVaHIZQuT1W1WwWDj9qypAk9zNB0\n26Rs/oIxWQsKj+1oMBtuetFU4qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSeNXAla74622ryETqCLxyIuOIVwwHwYDVR0j\nBBgwFoAUAXBAhzD58hn1LGGN2CNJ6AkEJ5MwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIHUusLcft9EDvc2uSxE7hha++DUzN4SJmO1aEp8jtvjVAiBr\nuoZlRRx8mQCWMSheN33vAhMFuNmkK0qoSK8fpkeTXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ0ky4KFNHEa6LJL2sECtFvhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjlkMzYyZi05YTBiLTQ2MzItYjFmYy1lOTZlMzQ1NTEzY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkSys0QwEBdi979V/vmwHCxabUSVo6LpnR1HF1SS9+avC5\nW62wZbz6sm6EFrZ1pdu8JoibqLqruPZmQn0phr5Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAXBAhzD58hn1LGGN2CNJ6AkE\nJ5MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKlCtIXsXaNTSDpdhYWjfa//Hz08KsJCpXxE7DPde9/ZAiEAgJOD0Hiw\ni9ya8ncnnqD5Zik3xPKzY/D5y0BpOvAz3PI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAS0uLMLVHUucK2DCu0+PM2reMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODExMDllNmItYzNhOS00NDMwLWE3NmUtNzI1ZDZkMzMxNDBiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMGIxMWJi\nYS1mY2Y0LTQwYTUtYjM2YS0wNWE4Yjc3N2Y2YzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7bec+G9u6J+5SG3+cFi3/MshyTfDVYxKjVPBaNg6QqzK6aEC2K+Po\nmrA/6QYLSkSurLab8O4coxorvvRKFX1Po3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJ41cC\nVrvjrbavIROoIvHIi44hXDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgeYBcI6/wwGPrZINzsfZfhAYaDoVrdKewucMsc+TVeloC\nIGC8ayy5r00EO0UnkrnqPIBL3WXbXmBpIxyzB43BqJBK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2021", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2021` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAew0CATG+NkhFe0yIzwBPowkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxZGYwM2VjLWU5N2MtNGMwNi04MDM5LTNmNzIzZjVlMmNjYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmIwODAxMTItZGZh\nZS00YjMyLTk4YTEtYjZiOTViNjZlNzcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+AuVfJ4wq8y3ZNmSbumAdfQE+6g8LZXS0r2Y8UEIdJonktW0N7yIKtW1uiRZ\nBG2YxGwet8L70OkYvMAMRjHbnqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6MUdCb42FtFUofI1yCZtrrBiax0wHwYDVR0j\nBBgwFoAUTV6LaV4bEY1bBXwoPYlPJiXB6IwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHCuU1VgrD328+TSo1eDIRWlCfR+DAp8\nC90+dcu5sEj0AiEAwYMoIPCnNs2QSJm25Q7IykCEmrQacJh3OepjV2D1p/I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASL/ATkR4Uem11WoBpDTnQIYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWRmMDNlYy1lOTdjLTRjMDYtODAzOS0zZjcyM2Y1ZTJjY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPResq8KatZ4hLEHMvMIVs3Z/GnyWe9w5hLbIL5iDM0Hxl\nJygtCGFM7Wf7AmWy3LMNq8DLSTjzXaHzCk6IaQ7Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTV6LaV4bEY1bBXwoPYlPJiXB\n6IwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANgeez4eveD/EnfZACq3s4SqyhEJ4ewN0rki0/kfdSUCAiBSdBTtYEre\nVyoTwurKkWlCnwTVpCz4jBOkIvQi2zVfQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAV6r1b+lhqbYsi5abPzdo7ecMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmIwODAxMTItZGZhZS00YjMyLTk4YTEtYjZiOTViNjZlNzcxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZmFkMzEw\nOC01NzBjLTQ4ODctOTE4Yy00N2U4YzYzMmM3MGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATjShbQupfX04Zy98XVW/hKihKLHbJWbAd3QZeu9Sdnb7uYupaZGkoy\nPKfPPYtwcsfUsYYjXcXH1lqfy0O6tYIzo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToxR0J\nvjYW0VSh8jXIJm2usGJrHTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgWyM4Fp1Qxb2hXvAsYWudwi9UgIv2pwlB90YRayD4VFkC\nIDCXazer7LAyEAfCaOFNTFNjp54iQzFa++PMyB+3GWtq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2022", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2022` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASzMEF8jInfRvufdR6diCuW2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5ZDhhN2RhLTk3OTktNDc1OS1hMzkyLTBjMDllZjI3NGY3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU0NDhhOWYtNzRl\nZC00ZDJjLTg0M2UtMTY1M2UwMDI5NjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExAcyVd8lfSd1+UlITTXxOk/o0158By/JcCPr1siu7/QyPVgt80PhrQ/CvdMF\npuWU8WT+iOLA5CtOFcPhzTa786OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYVv5ZfodxqgHNobf0Xo+vOeqD0wwHwYDVR0j\nBBgwFoAU0PQ0G4x3VP5kc2klvJWAoxCutxAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC4Ge5DAIlgbxRP5iSWN+dVTXWfs+/U\nauBpx5AtGSsSTAIgfiODrNFoQGpZ0O1EVsokBoPRQtdDd+UJhBgCwUk00Qg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUFHGl9R5SCZtAGTfYsqM2FQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWQ4YTdkYS05Nzk5LTQ3NTktYTM5Mi0wYzA5ZWYyNzRmNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDsLFCTxpaa4jdRU7gLmz9g9K7IFGqCJlyFxPxSU4G4qah\nmCett7HVtPFGMGKvPDyhROqhuARjtBanrAk+fhqzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0PQ0G4x3VP5kc2klvJWAoxCu\ntxAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOlh3QQsiUhvfHHF6/Mi2GGhxA/lVMPOtRT0MDZk7f6kCIQDlA79FoTcH\n8EaXn11iY/A/VqwqJW32KUn1pDSEFHp6Yg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfXRI+qQ4aqlCxBzVZnEbLalMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU0NDhhOWYtNzRlZC00ZDJjLTg0M2UtMTY1M2UwMDI5NjAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNWVmNDU3\nNC00NGUxLTQ5MzctOTBiYS0xZDY0Yjg2NWRlNTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQfLA/7BVwSLX9ae6PJ/pXxCFDRf0fZfy/OIQWTLX8fj2v7JM6ISrSC\n9NEc6OWLpGhGZlr8Gpf64yAXQCVPpeVoo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRhW/ll\n+h3GqAc2ht/Rej6856oPTDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgflyFJ6m5IbN/haGhBHlUBypHtyaUgY43xRTreEGwcUgC\nIQCPuhhjNazunISWRgt3BvE0lLC6RdboI9zSZqGPVFEVXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2023", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2023` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAfedvWr9yBsFS/JWQjFRVmVNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwMGNmMGIyLTg5ZjYtNGQzZC1iZTA1LTViZDZkOTA2MWU2MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFjNmY0NWYtYmM3\nOC00MDYyLWFjZDEtOTNhNDgyZDYwMDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdQiao+yl4QjyF4acw/y2WNPLlC6EHgx8Hv4Ve8OrUT/MntW0XuI11D529rLo\nQqX0IOjFb6M03R9eZxtZT+5PiqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSmECcG9osYxVrF+BHiuW1PaOAmswHwYDVR0j\nBBgwFoAU8XVAjPMqbKNBaiNjOSKmES+NtaowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDVbWnzuqaN\nUz3TaD8Gp0CJSeUMMOJ9VDEKX1/vlGpW/gIhAPDA7hHNBjeSOn3+TGk/MxV9SVXr\nmqoVneJWwM26ZuoL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaT3Vkj81ZuUwbOiQleO1ToQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMDBjZjBiMi04OWY2LTRkM2QtYmUwNS01YmQ2ZDkwNjFlNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMT1aD2/GtYNkuOWd7zHFf+S/dSMs4M7v42CWRdS9ATeQw\nKVcs1/fUnHkU4SC2RvttwP2QXr1/KVIv0Gv503Jko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8XVAjPMqbKNBaiNjOSKmES+N\ntaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLVMavcHBkLRf+au0V5tb0/LtCoOOYDIrF4EFaa0f6mICIQC6GRu60mGH\ntCjvP/cZgHuy1ya3cs4HBgSvcpAZ6JI9GA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAXscj5YAHumsZa7XxVJEO20wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFjNmY0NWYtYmM3OC00MDYyLWFjZDEtOTNhNDgyZDYwMDViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNGRjMGJh\nMS1lMmQxLTQzN2ItODFhMS0zMWUwNDA2MTc1MDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQE8y5eBGS1NDSzWftbHtqlQlxEdktIouM05xa4V9U2oLwZ/+oa1vUA\n6nbQkd3vkU97w2T/wjsMfRsc/rbtIngto3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKYQJw\nb2ixjFWsX4EeK5bU9o4CazAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhALpHFIUgij8HYTPHRP4eKdCSRV/L6wIqrUrfdgrZNg9J\nAiEAoW7S+VTGiLimgKxTMjhy7YYjmi1MQF2ZPYxnAsNIxCg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2024", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2024` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAbM6YoLdhhkPRxZ5ZK7llN4PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhYTVkM2NjLTY1MGEtNGNjMi1hODYxLTUzNDhlYTFjMWI5NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAzNjQ1YzgtY2Iy\nNy00Yzc1LWJhNzEtYWI5YWVkODA2Zjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeRkAEUxc0ka4MI/5mAzSLdeFAyKkZwQwVxhz/im5SzJ/u7AUOy++ZIWaeujJ\nG4SMPH3VVg9uoBlVCnY3+eEAh6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUkBNt1KyU81ldXygw1dDcqX0zRwwHwYDVR0j\nBBgwFoAUKkjjwhYR6vNji8Kxwkx9rPdH4TQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAMozVKEcFPuSdM59EV1zT7r8aa6CcOMug/5Njom8jSFzAiEAsqbGMMRh\nUe8a1br6Jl0SLdW8oqaNIDN93oh0ErlATzI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVMqAGm0h+FVyX3nnYrnGa2IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWE1ZDNjYy02NTBhLTRjYzItYTg2MS01MzQ4ZWExYzFiOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8fiC+QmwM7972sBjw0Dodj1jtFZ6fwUjTNDCCSb6mlFBH\n2eHjfgwqc6QffknBxg8F5CcI4id3ccCub3UjEEv7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKkjjwhYR6vNji8Kxwkx9rPdH\n4TQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUiaJ784PINvYihaH8Bp0f14yftb4czSYZT0YCfT6LRsCIQCNIHgH+8k0\nxkeGnoC731K1exzfZ5+Fjk9//5u97+qHuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAa63lEriOJZWRJVhLNuIYSGcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAzNjQ1YzgtY2IyNy00Yzc1LWJhNzEtYWI5YWVkODA2Zjc3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYWUyNzli\nMS1hYTZhLTQzMmItYmFhNS00NWQ1YmY2YWI1ZDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQCuPyAkfWUV/cjEFdgoZ10wkHtHivj3PJh09lQi4lrjJghM/yD/lxD\nlLuIOyN8m/moyogaj+nRFfxZDTlVeDgio3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSQE23\nUrJTzWV1fKDDV0NypfTNHDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAMrp3kYXtv4657MmXXnkRM5TG9GQKtSvNWKcaXsHBKeR\nAiEApYwOAAmxKYuty9e8p99211sBVXWWmBlGvYwMJSQ3htI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2025", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2025` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAe5rqwlmrKz25C/d+261wF4fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiMGUyN2YzLWIxZDctNGM1YS1hZTViLWE1MDQ1MjM3MmNiODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc2NDY0ODAtOTZm\nMS00ZGRkLTk3MDQtNjA5ZjZkZjA2YjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoFX+EJIImiQ/VKJxK/jgktjOBqKNNAsysq7nqnBtvCJVlOlXZLbShetNyl2/\n7bleqq2mLTnC2BFLix+N/MvMSaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8g9PybSaweAF2E2Nh1+nybayhScwHwYDVR0j\nBBgwFoAUzGiO1EG/hMirFNrHSzF6nfuvtuowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgET7cop+EX5L5P2IQUo81KH96vfEM3RJ8jQ9ebtf+ofsCIHWEc4UTiWcT\nfcQQeD58MChqOw0zm9O3CV840vtiGPMR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS/0AtES3ln+XUDXPIKEAdL7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjBlMjdmMy1iMWQ3LTRjNWEtYWU1Yi1hNTA0NTIzNzJjYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmGi/YdlB23ZSTwtm+Dm1GjxwPX55sDPlMTMCyavzpgKQk\nhML7CVfOF3DllP5GMIKh064oGJxbB0B/LPpsxfzVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzGiO1EG/hMirFNrHSzF6nfuv\ntuowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYwHAL62tzL3dsqYt7X7DHios9m8yiVNFPBj17KABuP0CIQCd2obKz1ei\nw3yo1v3alQ6f0AIg2WMa3XL4KEy4Mxa3dQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAcMJLpG/u5DRFEsrgUS7OMu1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc2NDY0ODAtOTZmMS00ZGRkLTk3MDQtNjA5ZjZkZjA2YjE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NGU5OTdk\nNi1mNzBmLTQxNjQtYTMwNi03YjYwOGFkNTAzZDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQZq/Jp8GwVM5KzK2iiDBy//heK58wn0v9dDP+Id9xYBwLR/gayjV++\nm9Vep5IFqqhC8Yj3lyh8RV+V9AEiv3IJo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyD0/J\ntJrB4AXYTY2HX6fJtrKFJzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgA9S5RoM8rrYb+qVfHMNN2yKlLNOSdT7fx8NqDi3SjXUC\nIQCnrbD43wOQe06lNuIJJ1b6ndF6FukMG2KqnvdRA+W+1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2026", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2026` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAYE7/S5XbYKyh4XnQ45x7shcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmM2Q4MTU4LWU0NDctNDNhMS05NjczLWZiYWY5OWNjZDRkMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJkODQ3ZGMtMDUy\nZi00YzhhLWIxMjctZjczNjRkMjdjMDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0sp4yLoXY+r8aCLdkz3uT2nUTuLU70Oz5Fff5hlKSJh179Rfk8YwM1qCONQj\n2y+YOIBjzi2CmVW8R0mD8mFsiqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuE9RLUFDyGWMgrrJgsGHjIEW8cwwHwYDVR0j\nBBgwFoAU93a8kuAUprTnzoHpD6covTrxyqgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDSyhRkjwvJ5PvajpJbG4Qqf0EcDgGIlDddjjjuQgnI6AIhAIJw7XUH\nBptA+MaBArwwpvluNKyI8yW1E5bzpe0qKPIH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcaIv8CuYgADsv1gISOzb1JmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjNkODE1OC1lNDQ3LTQzYTEtOTY3My1mYmFmOTljY2Q0ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9mphY9erE9CU4dnpUOEiRCqeqIAts8/qEN7FGHx0pmnLP\nvR8WcDZt6QuC1ErOPwt+AHf+U1SmmNy9rcNIuLAvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU93a8kuAUprTnzoHpD6covTrx\nyqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIn5+EubqC6Bd9p32AqEVbwKUcLVjP4tI/pJ1hN5xg7LAiBM2yer4BCK\nG4bqz70CynXgSusrNhrISrt+hSgEAWweng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYRm/9rrwfnELN+tsSGkPF/FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJkODQ3ZGMtMDUyZi00YzhhLWIxMjctZjczNjRkMjdjMDljMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MTQ4ODM2\nNi0xYTAyLTQ2OTEtYjk4MC0wMmUyZDYyMmFkNjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQGgk/u9dvPWHLbYWss/iKNG8tZC6cZmUWlRr7cl4ZmtYodbwYiQxct\nqNaHFlgEERaUrI934OZHQ7QPz96+lezYo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS4T1Et\nQUPIZYyCusmCwYeMgRbxzDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgaGkz/Dl2qKWfSny0zcnT71hPF/CHVJuZjxUQusKcQ9gC\nIQCrl0yK2gPloBq/oM1FISR+cOfOgTpqL7OP9km3iELcTg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2027", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2027` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAVTHyLCnDkBbHPxnqvgHWXh3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhYzkxYjY4LTdhMjUtNDI4Ni05M2NhLTg1MGNiOTA3MzlkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA1MWE3ZTEtZWVl\nMy00YzY1LTlhOTctNTdiYmUyM2RmNjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEigABo/IqBLrML8KbGVsQ7kkZIfw+kTAqkQ88ZpuIk+MNNWse3SNRxlNYOoYH\nWRe7bpS0PRUDtxSB9lqgMFYlWqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMvX7c/5Ms0PJIs3vrm29JOUjfZswHwYDVR0j\nBBgwFoAUW1YUr/juMXBH3T20qc+wmPKTot8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDrcqZsXzwhXpaSsRToJZO9oAhHJbEl37srgzdQ\nUDajdgIhANt90tLnnhaVcPrNBV/GiSDQuFIRXZJ0FtKYVtVfcbn9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUaz+Mk3UoTXnidASGBqcTKmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWM5MWI2OC03YTI1LTQyODYtOTNjYS04NTBjYjkwNzM5ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKI5CaDvAtA8dUIUwt9aCF4Urz3zoIfzl+C5YZtHk1Meck\n2srPt30iMvI0U/ep4ayncXRUK/gRBJP5Z0mXBZ+Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW1YUr/juMXBH3T20qc+wmPKT\not8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJhTsvAeSyAwDpcDocsDyKBhFpC9rKRgYJvVnGCDg2/MAiEAtcjf+4KV\nMODUce1XJfkxiiloSW0JS2ukj7OkvgLMRVA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAZA9H3yNfigBVxmF/uFkap6cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA1MWE3ZTEtZWVlMy00YzY1LTlhOTctNTdiYmUyM2RmNjAxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YzRiZmY4\nOS1mOGIyLTQ4ZGItYWJmYy1jMzIyMDRjNTMwMzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQHWv/jv3Wf5etf36472wjchS7qak/398EcI1icPJPvduNCzZqzZP/b\n28cnZt/BkOwCTvYhnJdlOaN3o+QNHfEso3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQy9ftz\n/kyzQ8kize+ubb0k5SN9mzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgUTb9j8NUOotdM0u2vVa8PYpgr1CnDFgbDgUOi+KymJIC\nIBJbOYuO3nN8GApf8HCkxsXICY5IttHJ3U5kMuhVkaA+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2028", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2028` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAZ83whfuYiHLG3ZcRsLQbUXJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiNjVmMTY0LThhOGEtNDBlYi04NWU0LTAwMTU0ODBmMzYzYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE3MGIwNjEtNjQ5\nZC00MjI0LWI5ZjUtOTcyNDZhY2QxZWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEloVIvcqdOCCPpbkpO/JJ85g0Y1adb+FHPX2NDciwZ2DmCJ4NvVDvwgcoIsc4\nZyLUPLqEt1ZllSpKVVf+Rp+LYqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMH767mk0fUoi6tR/M9BrqcJ8W9QwHwYDVR0j\nBBgwFoAUN7grRISNGkucB/Dt71nhil+6lL8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIB3xX/usycfvRLtMcPCJC0xpXs35QlEcdRSJizEV\nPjSwAiBsSWPlaQm8IzNQ/qTtRSehyBiOk86fvQTTxeTw1ecY8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW/TLvirOjamNMRlAWmQ4s6VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjY1ZjE2NC04YThhLTQwZWItODVlNC0wMDE1NDgwZjM2M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQB+lI1bOuZ6qGGuG0h+3CsR81sSjV1TW4XwA1IfWPcTx8\nxsFd6TVoNUlSIMUl6TTkEs1lT3pYQHnqzGkpLe+ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN7grRISNGkucB/Dt71nhil+6\nlL8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALtdJrCpdin2NdJlCt97ZEYmFxqqbzR3hgZnzKYroKNQAiBzqJjED6sr\nDBwzV8kyLZaeQxSP7YS9wGz+DjGAfFyxFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfvQ3FGwmB6NHYbK18FhPBdkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE3MGIwNjEtNjQ5ZC00MjI0LWI5ZjUtOTcyNDZhY2QxZWI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MmI1NDE4\nYy1hNzQyLTQzOTUtODQ1Ny05M2I1NzhlZDQ1NDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATPpQ08LIpejNqpRSx3Qrsr6NycZ4TRtItnL57Du7X0LURLJyl6BJwM\nn8OPhZXgzKtadcG38VFVwBApCavwjfJLo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQwfvru\naTR9SiLq1H8z0Gupwnxb1DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgbT6bLqvt4jC6bPn/XgmG8WSYDF1jd/Fp3IszZwjxFpoC\nIQCDsJisdvfrueJA+nck56NqA4XOHnW9ABwjbCAhmSsbLg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2029", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2029` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAZXTbVg1STbgesTTZNv6Ht/nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4YjMwMzAxLWI2NzQtNGYyNS05NjhlLWUxZTliYzg3NDU1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY3YzAwZmUtYzRh\nMS00OTI5LTlmYzktMmQ0ZmIxZTE1OGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELIdde9pwN3R5/f3EAfYFbavAeHTDKkwCGUe88kgWFcZQJB7Z+LVVHYIpLy9m\nxX+CYh5UlExH0jg0G5ydaUWRnaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAq8BTdWXu3HuGEEtw8k1ZMKq1LUwHwYDVR0j\nBBgwFoAUSrP4UZj1a9Nivy+fFu0eXjGBwlEwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQD6E8myw5Q6Hg7ngEX2zPfHijdErBMa3i+jBzeHXdD23AIh\nAK1KMIHUCS9RJOoAYPFzDzwJo9pI/bbMB7Ypc1mege95\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZWUv0gpmaaQ/UbhpEpdscirMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGIzMDMwMS1iNjc0LTRmMjUtOTY4ZS1lMWU5YmM4NzQ1NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQThNXPU0hkIz7BGqYXjPyISzUz3HvtAxque4PzEkufCwS5\njAN3MHsdZLNNm3wnqw7MQ20KuK2iGk9meRw65P6Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSrP4UZj1a9Nivy+fFu0eXjGB\nwlEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGvxKO7XFNFfpVWKFXTMfsbvgADT4aEQtATnO1b5rHh0CIGzBCbOHwIqK\n7oK+3APVd23OYdJN7N8fA3vf8M1FvDK+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAc08tKXIFC7fCRSK9+BA05wRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY3YzAwZmUtYzRhMS00OTI5LTlmYzktMmQ0ZmIxZTE1OGI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYTY5MmFk\nNy0yZjE5LTQxMzMtODFiZi1iOGE1NjcwOGJmYjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS9gpIjILJP0rfobjk463eTeAdM+LKI+cCVNML5xG4gMaxSgvfAFHjf\ncsy+Zgx6niDxMVO08XIP0vD63zXiNBTOo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQCrwFN\n1Ze7ce4YQS3DyTVkwqrUtTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgOxT/nQECgPWOWEBVKvwYmSt1Ky0nDP34fUdyb0UwRjkC\nIQCq9KsDXQHzwtTmGRHSQipJYTp/0jjRfrNCX4svcteV6g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2030", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2030` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAY3YH9EMZJj/yrBxsXRDkOjUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMzU5ODU1LTIyNjQtNGVlMC1hMzZjLTI1MjA1MjRmOTFiMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQzNjIzMGYtMTlj\nZi00NzYyLTkwOTMtMzE1MWQ4MTE1Mjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENXf5byrcIfd3iscMWuEsodk3PHUGJhHpNx5+ZijD3PLr+LHz9E4mBi6j3U4g\npvQtxNzBNkkFHb7wT83DLoplPqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFO5KipL+7BatGiQ8BMBxhgjrx1QwHwYDVR0j\nBBgwFoAUaVQRHvyrc5aGnVTnjf7EjJHOTcgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCvK0OuwB4kbLLdYXKrFOlQOeCbImMR\nb6xGeZ0MBlyEPwIhAJy3lzO1WlKgRL0gYzFSCPThnxE0VL2FHH5lDoXzOATn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ4qUj5mkX+5u+cxuOIWBLehMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDM1OTg1NS0yMjY0LTRlZTAtYTM2Yy0yNTIwNTI0ZjkxYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNKi6tm+wgwr9N7OVGvGzMM42OdCNhwNWnrWaOjTgHXkGQ\nGCZvktziU+asS6GZRqAUOso6W1ZKv91Nj3wIsN/Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaVQRHvyrc5aGnVTnjf7EjJHO\nTcgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHxD2WdIndJQvqPAjOgnwA1DIY1Ig68ZRDp9P0L+BDysCICxO5dUsYfvO\nPfk71ugjsI3ZxC4EqxK4295fWyked3eY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAR6EMRvFlNqe6Hb8knOFOrAvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQzNjIzMGYtMTljZi00NzYyLTkwOTMtMzE1MWQ4MTE1Mjk5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MjIzNTM1\nZS0yNWI5LTQwNTUtYjI5ZS1hNGZlNzBjNzRiNDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARHdbqkka70HkUxnZkU9p1wx9flCeIZbXqIrYXR5nLjd6lldcEgxNyp\nquj7bOuZOKvQIJzz6IUH/XFZdD8VBYWXo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQU7kqK\nkv7sFq0aJDwEwHGGCOvHVDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAM/GB5MYAOxnxIqO7GTDNc+r/wjOU+XkZ8ujQnuOoQUx\nAiEAzfXbaydmmaQE7IAtQZLpKzcSy9jh/DKfdBGFnblIcbk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2031", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2031` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfYGorS1nqoGbXxwSY6dU6edMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNWZmYWFiLTc2NTMtNDdiMC05Mzk0LTc0OGY1ZjFhYTZjNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVkYjFhZjUtMDM5\nZS00YjdiLWI1NjItNjk5OTU4YzdlMDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFeEyCllnHrtkN6bvz1hXCNME+TOCvb2N7FDLdhBEunqn2zphRufgpmaOSY5b\noiGKULUd0kklcmrnApK1A7zHRqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYJhreRNJLd4ybonA9Z81/Ase/98wHwYDVR0j\nBBgwFoAU1CKTSYjG3wmueCNHF6owPou8Z+IwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIAfPLsf0gaf61DHGRuOOVW+5m5t0Zg/A\nJkDCc3D6ms9AAiEA1O+woChk2Zk2tv0UU2dY7mgjMYIyqbacySjbrY9JxA8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU8Z0bqvkNhV+z+CjJPpwRzSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjVmZmFhYi03NjUzLTQ3YjAtOTM5NC03NDhmNWYxYWE2YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/ODH81JDgxIkLVZzDll07fIxYt13fLy2nugTW7Z7IzzmQ\nKkPD2ThcLFajNUmJ5Z2irivSCQydBkYGQzY3hgMCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1CKTSYjG3wmueCNHF6owPou8\nZ+IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFLmuN7uaEuLSVBzib1Q2UBLJHPToe5mlR/pVEbcscTgCIQCk59mtiR1p\nmzCNKbgWEqCCn2d8RtSj23/SF3TW3BpLYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAXibGcE1dRBKnMk3Ev3XM0OfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVkYjFhZjUtMDM5ZS00YjdiLWI1NjItNjk5OTU4YzdlMDBkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNzM0ZTdi\nMC0wMWZmLTQ2MGQtODQ3OS1iNzU3OTI5YjFlMDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR3y9BQLzw4OaNohW64lNWKuiSIjHgt2eE8+2Pmk8gdOO27oy28JUgX\ni1l71qAaWB5p6GrryM4k+jK0wGkO1uX1o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRgmGt5\nE0kt3jJuicD1nzX8Cx7/3zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgfX/+CZfjQwdkWB8cYl7h63V3klY7C/ojPvMocH+ZpmYC\nIERXezgx42G8H94NJTK0sUvhu5hU8T489oiw92OIAjWO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2032", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2032` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAY5p2xsqJz+jVpKjaHbjqFT+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkZDlkYzJhLWM5NjAtNDBmZS05NzUxLWEzODMxZjZmYmFjZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDNkMjUzNjEtMGNm\nOC00MDM5LTkxMWUtNTk5MjY4NzA2NDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN77SHyCKf6R4RcKbgKUPwOY0Z2QbljxUnNEJ8spwA1UYMzsihU9Va2tzs1cd\nzevD2GYBNoQ4W1DuBOoxwOyQWKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNqddTFHci0xJ1KVpRE3vVRAUNNaMB8GA1UdIwQY\nMBaAFJpkvmBI3l960MVoWQ8b5HIB6XKXMAoGCCqGSM49BAMCA0cAMEQCIGPHh6QI\ne0RGYIsky7m4P9N8aXYYj2Pf1sO8ZQgdzdCEAiAcGVTPMatsyuFkmH28146wfVGs\nIqwc8l0hEakxGP2KpQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASMAznNI+0+iaAnB8xL+vGxlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGQ5ZGMyYS1jOTYwLTQwZmUtOTc1MS1hMzgzMWY2ZmJhY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNfQBOiGrtDzs7TiEBxN54Rox5BWJdNy3SJyrQ3fEicOpZ\nB/vMoH43uzoRa+5ONJkdVNx75qtOdvZQ+2Gqgrflo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmmS+YEjeX3rQxWhZDxvkcgHp\ncpcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANKjy2AW4ah0SdKinVgLdivtPSy5nB1HW3YeGpiHu9+9AiEAmWFdmO/L\nBXpk1ObQfzxffOC7SyllBTtcQL9rhfrc+dk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAZcwlSP4rZTiZvxAS8nUkO2IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDNkMjUzNjEtMGNmOC00MDM5LTkxMWUtNTk5MjY4NzA2NDI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NTQ0YWI3\nMy03ZmE4LTQ0Y2EtYTJhNC0xYjE1NzhjNWExNTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS8ECL5kA2+cmaVJ568Wjr68E71aK2PAb5BxXIE3+pU81sSmL7hHoKO\napu/4goJnRIm93wAzmNFCT2qm64//5uFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTanXUx\nR3ItMSdSlaURN71UQFDTWjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAN3nIXiGipAm0YBRZ0FSj9czBxcMdfipbwLe\nMzOCRA5UAiEAhYmtN4U17R44sRSKal9wF+xAiPOj+xxyQOKlgoxcH6c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2033", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2033` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAQgiwQf3KKS1lYvgVe6N96OhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NjQ5Yzk4LTVlYmYtNDI4My1iMWY1LWEzMzNkZTc2MmE0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZjZDE4MTUtOGJm\nNi00ZWZkLThjNjgtZmM4ZGQ4NjcyMjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkcGnI6zf0DpxfK/fvCeYDYZTSx7rASjRQSb8iVAp2v9SKHIpwIjNFflQTXoX\n53FA9glBtrSEO1f6j38K5TKdsaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNEd1qNz0DGsBN6T71dsS97zYiaOMB8GA1UdIwQY\nMBaAFKJL+iJPFTApFJ/ztC+MXUXIOICUMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAj9cw2QhAGVx5RG2TWFplnfL9wpG9ksly\nkEbl9nn87uYCIQCAisS6byigLqHtu25+ghrWyyMpowl3DTBMCYInA0Qz8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe1Th+ucdCdqaqcif+hBt1VnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTY0OWM5OC01ZWJmLTQyODMtYjFmNS1hMzMzZGU3NjJhNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAST31E7AK7xdjwdOrs/Y9igUkbYa5YK8KHbIk/QCI0vQ3nS\nQSCnBkqJdqK3BGk07gI53woY6gU1rK6D1UjrAwnjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUokv6Ik8VMCkUn/O0L4xdRcg4\ngJQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALkk/bknxGOW8sAFfI+v+GuftNCmcJR6gzDDMyxlK3KsAiBVoCvPPJne\n0EaEwsmr19fa87XhERo6ljhI9Iafk73egA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAam5GE5GIdBvp5r1BoUzjiumMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZjZDE4MTUtOGJmNi00ZWZkLThjNjgtZmM4ZGQ4NjcyMjBkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMDM2ZmUy\nNC0wNjExLTQ5ZDQtOTU2My1hY2FhMjNjNzI1ZmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQoVUaslf+xZopLFUo0NK78HnWNZAdf7vtFkaT0+XUFbl4NlGkcvS5w\ndoALfArKvhwOC3l6/NYnykUPeMtEVjvso3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTRHdaj\nc9AxrATek+9XbEve82ImjjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAPZYDR05/uSn472/DO6gWAfXfXbDZ3ky69b/\n9HhWsC00AiEAhyh6GJmWtvuXSTRfr6liOupw+7P0t5ixNx11n0/GbEA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2034", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2034` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdrZ6myGHfOIm6Q0HQDT4qVbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkODYzMWQ1LTE2NmMtNGIzZi1hMDMxLWViOWM1ZGRiYTI2NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBkMDE0MWYtMmZk\nNy00MTI5LWJlZTQtOGU5NTUxOTA4MDc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8qAsy0jlCenFQW6t6kKgc/omJtSet0fkBgOF+1H4ED9c9E1fWqkb2GDY54j8\nROO0Y1AWT5IGagE+kAn645FnbqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKZfuBwvd6UTsNljjGyLxnQTYjd/MB8GA1UdIwQY\nMBaAFCWUOHm2dD7MqoVyiUvKWpwrgnDwMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA09PFQvIXDT+WwR3bwfYTKLnZZPuq1Ygt\nzuFmDuA7h8MCIHBKRihk6qaPQp0J0suV7OmJTx0V7b69/SbDECGClocW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcc/qHwIswz0qvoDq42ZynFEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDg2MzFkNS0xNjZjLTRiM2YtYTAzMS1lYjljNWRkYmEyNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0mwjYMew7/VWTzRF45dQQqUn6gbgiBLLwLkctd8P8/D1F\nscnKP+wAbDvHNhk8OWi/eoRm4GhLb/LzgXVf+Wqho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJZQ4ebZ0PsyqhXKJS8panCuC\ncPAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMkVdZobtadCkilTIDghyy4Uzi0G7GPCAWihOmJNVjDQAiBKNXZ5pPzS\n10JDDzCodcabjYam7MhlOvGwfoKvk9KWhg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAQh/1317DsySlc4Xtd9Oh4/5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBkMDE0MWYtMmZkNy00MTI5LWJlZTQtOGU5NTUxOTA4MDc2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NTMyMWJj\nMy01NTU4LTRlMzItOWFhZS0wYzU3NjkyNzcwODYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQFr45SdvsPaeVjqTY8+OY7TNyRJPCm4FxDJlhztlIBTBaJCi/dP9hA\nNhUXcrQZhzfQAWBUKxholgnE00yU2c3Ko3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmX7gc\nL3elE7DZY4xsi8Z0E2I3fzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKNhwJ/NL0GycOXTVpf1IrwQYmwBmNSEosdj\ngKjZUVZmAiEAnMmTZtiUrZ3W9J+fHFT2uFYwJ9fPZBYXy/f7x4K5Bwo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2035", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2035` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISARb0XIEM3UDj34w0v6fJHd3rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5YzAyNTY3LTU1Y2QtNDNhYy04ZGMzLWRlZjVhZWVlOGUyNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdiYWIyNDEtOWUz\nYS00MDIxLThlNWItMmU2Mjg0Y2Q2N2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE72CZcAeIM8j0uzdfFI2cVKvOZBMq6tN/T8ws215tgfZPHmdcel14eB3QmDMj\nOBiapYDkKJXB8a98QUX2qofwsKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSVzPEkVOHlTJk8WqcsnxtznB7J9DAfBgNVHSME\nGDAWgBSQepF9BQG97Qrw61PAhmt/rBykdDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCn3e5mzcxOMLzyQp3ieIIY8hZvK4VO\negrFpepUBEAQAgIhAKZBYjyBlYuxUxLo9HszaSGaWzU4U5PAFj9J3yoXUNB5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaTXeogd5q7r+IP251vu+cS5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOWMwMjU2Ny01NWNkLTQzYWMtOGRjMy1kZWY1YWVlZThlMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6AipET7Cf/jsQGsHJl9hvSngJCysS0f4K8HEHyTuH0XgE\nzxNHthaYzxUqWiMEtpOJsd+AFMNbkNYAhq8loORVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkHqRfQUBve0K8OtTwIZrf6wc\npHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYj7Yiv0h5LFHOIyOoX6QSNAV1mGX0/zkRPHxu3W2bqICIQDTSdR5Foec\nHHOyg7jWQ3OIB69lzwCmXP6rqJYQJUcgbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAUdVac4fn4/08GeMuBJZuyLcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdiYWIyNDEtOWUzYS00MDIxLThlNWItMmU2Mjg0Y2Q2N2QyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MjJiOGUz\nYS0yZTkyLTQ1ZjktYjkzOS0yYTE1MjlmYWZjZGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASt9ild3Nd2gH+qTx6IX2LIyDRNuTSFpEtGCFqpanV/rupO4lY4Xae2\nl1qmUKxBueU0Ohdo9PZPCPCCrZhqVPe9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVzPEk\nVOHlTJk8WqcsnxtznB7J9DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhALYY6rny3xDZw4mWPtla+J6Y9hxcqsPyKcTA\nsBZ+huR8AiB5BMlHOEsnw7NlMeI1VGFZcKVRWsVNncir3brfW22K/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2036", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2036` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQH5rK2dw55zzjTFP+mrtVToMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlZGI1ZWQwLTYxODItNGZmZS04ZjAzLWNiNWFhZjgwZTk0MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQzNTA3YjItMGVm\nZi00MjAwLTg1YzgtNjEwZGQwYjg0OTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm0OM6yRcAqaFld2SgEgjuAVSK1nGi7y/6NcwR2JX0Py7/MCw0LvZSs/f0moQ\nNNPLuFT0yDs2aSo9Lbs6AfIG2KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB968Xx525n5s9/1m+iGxSRHUCEkwHwYDVR0j\nBBgwFoAUeW3DdwRiwDKYnOqKXb4pIMzERxAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAogg2Ovi6djcmZ\nffwaqM/x0iWUmGk7Wl6xWqZg9VzDUAIhAI/QC2rJ+r6p/NB3z20qKII+8WUhOlR4\newLur160E8qo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY59sTySbZmHeg1e1a+qMiDdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWRiNWVkMC02MTgyLTRmZmUtOGYwMy1jYjVhYWY4MGU5NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjwlPi+Ht8UiknipOUzMvveL+Newww8roML7vW7JVQuZt/\npNgnEvxMK1+TVM9uPKnCKtcjjBxFjVCIL4+TMROHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeW3DdwRiwDKYnOqKXb4pIMzE\nRxAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUswpL5miZ109MWiM1bVxy78kTIEAyLp1SFAjTbvZhfgCIF6NXKzfN+ah\n9yLL1Xu1sSYXZ/6gJKal85QTBs1kHlVL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZmKryeVAai2V2hCSnhc1lpPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQzNTA3YjItMGVmZi00MjAwLTg1YzgtNjEwZGQwYjg0OTI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNDVjMWZk\nMy0wZWE3LTQ1YWQtYmVhOS1mNDYwOTM0MTdjNTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQs3yihvkWY8FByr+fc/FpMOIxyZ47OvZQGf1t+Po+Yysyp6y33t1km\nw6AIWU9jUn81UYa+/4Ib2WU6SUhSWOpTo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQH3rxf\nHnbmfmz3/Wb6IbFJEdQISTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJMm9XsTReDKK7ev18tKLs8WzFIc6JV8mQKu\nEYJ8yq3PAiBcb1psbJLx8AD/ebcPlAGDKIspZoW9ehcju9+6we0xFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2037", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2037` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAZTgPqmUw3L5y6LRA1xE/lYpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzN2EzZGQ5LTVmYTYtNDE0Mi1hOWI0LTA4MjFhZWM3MThlYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY2YzM4MDktOGQz\nNy00NDVjLTgyZDUtNjM5YTEwODRmYzdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOZb1LxjMU7bK6egf9u3Aq3ASerYWmea0taJy3/oYIfLr0dNm28Ccrmnu0kM6\n9VR4gaRSiUEamuKFj9oCNLmACaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU71ajqZ2WtpN4NrdRCKMs00mQZyswHwYDVR0j\nBBgwFoAUq+KJo281yFrXb74eegoOiS/tnA8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA9pC+H6z6zrKX\n77z8aefsQU0ZFlV2lz8Dq9ouFI7EywoCIQCjjqYy99UocXdwy9ktjZuGofnqyGp9\nYoLjxh+doVBtug==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa8YcgrIrdewiqWHL3dcERiAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzdhM2RkOS01ZmE2LTQxNDItYTliNC0wODIxYWVjNzE4ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyCQky+mH+ylu2mT5c2fs9kOlsiKQBpeHoaxxl+/zO+/s6\ntoZuphQjEImpAEqtbt02FRehKXPgl+ABHICW8UIho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq+KJo281yFrXb74eegoOiS/t\nnA8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMH5+QZbpwXErbT6tpWiVejnjyuzU7Hq9NIlGDSrER2QCIFoH1I8Wo5Kf\nh2uPrJNitqvMS0c6awauvhXa38TYnVG+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAcEYuOVUuXqIE1BnA4eiYfVDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY2YzM4MDktOGQzNy00NDVjLTgyZDUtNjM5YTEwODRmYzdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZGJlM2Nj\nNS0zNDI0LTRjYWYtODk2OC0zZWUyMTY1YWRiNjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATHOgSmhmh05Kyv9FFTCbpGoPDtMBLZqF1M2h3+BBjrZyPOaOlG08Eo\nEEbwqgscSYx05FVIeHfkY/17AASHBxdNo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvVqOp\nnZa2k3g2t1EIoyzTSZBnKzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAP2apj2hyRyVi91djR1SopCniWCLN37v8Fnn\nlmfjixfrAiAIDNmhXTctMpnEEtAltPmR5QmgMtGKxMD1O8KV1D+lBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2038", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2038` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAaENV92qw8NySbV+nt0WzhqKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhMjNlODE4LWE5MTMtNGNkYy04MjU1LTllY2Q2MzEwMGIwNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzkzY2QyMTEtNWVl\nMS00Yjg1LTk0NDAtYzkzM2IwZWQ0MDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6cvkkGrTV3XgOSYffzbrPrViRcY3CUJqs5qAvAX9oNATqR1rUeJmZSPIrPrb\n25h46Q92kzR0Cv7hTvzoZ3wJHaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUv1nRhhIzPNjcYPGSCyboJhRZJgwHwYDVR0j\nBBgwFoAUvOI5WKeaduRcaE02fmsw8jCyg0EwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBWuXiWrrhgVvSpPxcYLBmv\nKT5I66/6O3DfV0oZ8qPReAIhANxOa4GpdpFrZf+LCGAIH3dn3SJ+hxktTtBQcnjB\nkoKx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAentnUHQGZsLK3NdWTihvQHUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTIzZTgxOC1hOTEzLTRjZGMtODI1NS05ZWNkNjMxMDBiMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/LPcJKoDEOXM8YiFSE86u5ncXR2145bMvATvG8jY+/JHd\npKdVTqG6ZLnwNXoqgH/e8kyQb9r9QAuSqF+yY7/Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvOI5WKeaduRcaE02fmsw8jCy\ng0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIi9tDilGugsUa4xwA8lizzTm/oFHCOptEAmSEcCEeJnAiBb+1+5uzSh\nnCM5lftrEIdoIoVoAZXke3TYPqtPGBVhNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAaHBXlqX8yXuFWIG7JeqXuf8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzkzY2QyMTEtNWVlMS00Yjg1LTk0NDAtYzkzM2IwZWQ0MDliMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NDBjZTIz\nMC01N2I3LTRjNTMtYmVmZi0zZDEwNGNjNzUwNTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR3pIY1XORo8DuOypOaQEs6xy92SlrqIt0Ip0+tMVVEw3GmiWh8kUwc\njr1Xo/7olWuE5lobbhEaz5mWJ9eN4mSwo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRS/WdG\nGEjM82Nxg8ZILJugmFFkmDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgHoRoysVH+CliaoW0HRhY5jeGICB9egGZrppj\nq4PRimYCIEs7Az5dsYnZOSWCHxhT77zu+Hh18ltLBcoo5dPHFY+y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2039", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2039` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAZ794v74JOEfYnxGybylnwEUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ODc0ODBmLTgwZjctNDYxYy1hZTU2LTM2MTk4YzM1N2FkZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdkYWY0NWItZWMz\nMS00ODcxLThjMjQtM2E5YmU3ZTEwYTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkOrxTL0v2iC90JHj9w9fjgbxm9rdHGg/wQcCsfRaE179fRJ4yPJMF/5xRyJY\nPQoi4CfNehB1qYeFldIWUZY506OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjc4BQwzso86eSWxaG6aKNwxvD9EwHwYDVR0j\nBBgwFoAUfYJA9WWywrQnOUD0wA5R27YQmDIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA/U+j\nLbWBrJncsynYAtUP8TQTblYK9BZGF1LTwPUt8q8CIQD0GvY4lvynrRV+mDmgYLDJ\n86XMhweAL9Rgyn4rtwsOig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcwuXhEPTmrTg4PO1h63z1Y8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDg3NDgwZi04MGY3LTQ2MWMtYWU1Ni0zNjE5OGMzNTdhZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/G5EGlJkRBhE9Qg+cZb4gxxFdF6FQW+bdYALr7svv08X4\nVUhehFjDYklPcwaS8b0HEiNAlHxTC3KFnwHJKOpqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfYJA9WWywrQnOUD0wA5R27YQ\nmDIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALMoPGyPUVwJFcinrwxgiQHh5FPJIMbItyNaCNjsjx2gAiBapurielBd\noGngQzZjjbyIQq7qsbW+4s4rLIwQZM78tA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAcxh2uobe2Jb2soBi0A0nh8NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdkYWY0NWItZWMzMS00ODcxLThjMjQtM2E5YmU3ZTEwYTU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5YWQ5ZmEy\nYi00ZTRiLTRmMGEtYTI0NS03ZWExZDkxYTg3NzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARij6ze4aXLLKNULC0BoTu5KVxePS43jdBEQAtABI8003TJKA7l6jfF\nOmjiIYVO2jWKpErGi0TFbUBzII20X727o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSNzgFD\nDOyjzp5JbFobpoo3DG8P0TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOTfNeC7COu4X+imB9WNNSUgtz7os/QOeFxk\nhN2R+dWXAiAI95Wtuv+TJPCjW18F4oEJRQs/BcFFUla81wQwF0QJ1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2040", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2040` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAczHvE82geNSpEEqAR+pc7YRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2ZDE1M2M4LTc4ZmUtNDE5YS1hNTFkLWJlNDllODQyZDBiOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE2YjgxZDgtOTgx\nMi00OWViLWI4Y2UtMGJlODNlYmI3ZGY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtSKoYZ+1gxhRtOOsD3rVZIWXMehoxV0UEOx28BZlmSxtR3pQqjFx0pBt85kB\n2PWwyKA0TG4LK5wi7KjbmU0edqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXSz6gMrgzhPH8ysH7p7OeBJPt9EwHwYDVR0j\nBBgwFoAUpYGRjSRDQC5eYUG/jQSJB9YPqrQwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiA3Ncm+\nkB/uRsrsPLdovq3IeXzlieFw0soriosmbCQ18gIhANa5lqgimXi5g6OSFpnKk8Ag\nU+EmmAp1nO4beySQmn9P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZHTVLwziutv36Q5HDmWLI+vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmQxNTNjOC03OGZlLTQxOWEtYTUxZC1iZTQ5ZTg0MmQwYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASX6oG6Aabhqb8HDsorHxxLdrtCNzeX4dNDpXFQ+uhuiOBt\nYXAZULlJfg00CSL+0XGRtZbVHcQAkreGyXKVK+Mno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpYGRjSRDQC5eYUG/jQSJB9YP\nqrQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAPbK26p0TGkuEPa9xzJbCvDYruSI+J5dNJpbCWyH9on4Ah8hvZ7OB6T4\nde1Xq6NhLM+b6vW5kvczP9mcQn6eie2X\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISASIBdxXLOonjsZEXEf4LkobbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE2YjgxZDgtOTgxMi00OWViLWI4Y2UtMGJlODNlYmI3ZGY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OGRiYmEx\nYi01NTE0LTQ1ZDQtYWQwMi1mODUxNmI1NTJjMTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQF0MmlY3fyRfMk/iIFxRfY1H6k3QUqNArKxVyar359W1/zEeJzMMDR\nCWwTY9Attn/usN0ywsQSGUhe6k1XsjeLo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdLPqA\nyuDOE8fzKwfuns54Ek+30TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgYngTqxWHT04lxpLl4CL4fW58Tub9YGA2H5kC\niJuIej4CIFcarKH823LSvtWkXrj5SBGNZqWz/49lZxKpPI+sml/P\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2041", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2041` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISATQkt3HAdHHg0pu7y0+ZJdeLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3NzBmYmViLTRjNzEtNDcyNS05MWUxLTE0MDc3YWNmMDg3ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NiNGFlNmItNzVl\nZi00NjUzLThlM2ItY2Q3ZmU3ZTMwZGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELRSM/LLJj2M+j9ewzbi+T8/NPbh3btLz5zZY66u2QetyoQ0d2XJb+L+4Kvta\nqqqmbciWP00lIG+vEdnty5fwe6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBLg5GJt/EWfIapgDyGbi9jHCt5GMB8GA1UdIwQY\nMBaAFBosalk9ClaAoq/m0H0eYOLNIxEiMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAx087ObSVAMWIMGFbblB1ZEu2yLew6kcn\nHbh6PD9bHXcCIQDHZvcK1YaVncwNVILpgZJBnQVqmxHnEmBj+6Blw944xw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdW+iReIrTtsnxQ+xJ6CkVt6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzcwZmJlYi00YzcxLTQ3MjUtOTFlMS0xNDA3N2FjZjA4N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMU+dmBzjhKup6ww1KSKFIvfqr2JXLcWcjEIL4YtEISqhy\nsDgoMpe2+KO8rFVWQIzUs+uG5kOo5mlPHeZYhuHlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGixqWT0KVoCir+bQfR5g4s0j\nESIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJmbjjUqzT9f4tpPFnpfFj88MrfAYNgy81vCRd189oaIAiA4MPnmi1wP\n9jCgu2sLEUrdrNqXBC6Au/EC7k/ooTpdhg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAelP9sk70j5+m03reLzPB9eSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NiNGFlNmItNzVlZi00NjUzLThlM2ItY2Q3ZmU3ZTMwZGY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ZDZiMDdi\nMC1kNTY4LTRkNDItYjhkYy0xOTc5NDhlOTQwNTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATtXScZVKwNtxkAVenrgr4dcjzBRHL1c+Ae+QN21lkpa2fHDRtuwHHB\nzekwvjJWvRtVVzux7iDsj+qtlNiaJiF8o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQS4ORi\nbfxFnyGqYA8hm4vYxwreRjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAPO9x6V/AUToGZ7lyLu2fUms6Lu/12HJjft7\n1VDnUFpmAiEAuKGMAX5kTa3QQx9pzhjnRzNlVPKRpoXbOv8B4qVeRnw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2042", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2042` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISASzrKz/GqnZyjZK+hBpT6q6zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlMmJkMDE4LWUwYTEtNGIxMy1iNmM2LWJlZWVjOWU4NzI0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGViZTE2MjktYzQ3\nMS00MWIyLWIxNGUtYWUwZDVmNjc3YzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtjphsGYgsZADGPcwUvLJkSab0VZcaeCHlR/vCiUsF3d2u7kR88AIERw/6Vo5\nV42atfPdk5B3bpavQO2wMrjkRKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwyjWeW3sHdQzzYSarPEutHwSbVIwHwYDVR0j\nBBgwFoAU8J4jHmclvsIQRO/q1943JDX9OjMwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgTCMEb9YCVeeX\n5F8gwdbAaB+CG+7RXYywRIsLUrDPhtYCIB3bdNyzbQ6GJTgVDG3aHqRA8gbuqp5r\nDV/S8MnQiIsu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfywMOUP7+uHa/ntGwhPqzowMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTJiZDAxOC1lMGExLTRiMTMtYjZjNi1iZWVlYzllODcyNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQLRE0b3ytFr71v9aPXkCZ30gJXPlUmzIzHWtGyMIl2wAp\nCy0N3Yh5k+//13DknySUlIkzyzw0ERX6rkCJWs1Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8J4jHmclvsIQRO/q1943JDX9\nOjMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPUnOzXbuvKFMqJFdJlJL/eKmDEtJT300v50dbWOS7/gAiAJONkX69Uk\nIBLdUZh4lLPC23EH2lBkjjFkZKRfLyG48A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAZuWfolrBSo6bRQiXrW7i2yLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGViZTE2MjktYzQ3MS00MWIyLWIxNGUtYWUwZDVmNjc3YzliMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZTJhNmMw\nNi0yYjY5LTQ1YjctYTMxMi1mNDJmMTQ4NWY2YTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASajSc5fPtTf2OfdCQ0eAunsjcLnUA2UA/fD4gaYLftOFOGvHk5Rr9C\n6B5MgzXIc3YUS3em+7KsOc7p13OUgB2Do3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDKNZ5\nbewd1DPNhJqs8S60fBJtUjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgWcvVl9LKAb9j5HVqslQaQ/vdVmdc4whSBQT1\nGQzdZmgCIDr1JwchobJaniWrADhfm9WmB01Nw2hrC5dAiqWk1yBh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2043", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2043` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAfyFiwWFzGgRnGFRxsfpfLvEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MjkxMWEzLTVjYjEtNDJhZS05ZTBkLWU5MGNiY2QyZDFjODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU1YzFjNjctYWI5\nNy00ZmZlLWExN2MtM2QzYzZiYzhmNjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh6nUJbLd+s1/J11d9B16k6xgbemnJCvIogIwTXZ2NX1FsoQ/IzmTWtONxIkB\n6Gf9aP8K3rLbLwI3vnFuS1EUWKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcKGsBz+oxXa8MkIJjaj/fXuv1nswHwYDVR0j\nBBgwFoAU93TWILBWglEaj5YtebvD/+6C33gwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAM2oGoepI1HD\n0YrrRyQozFVNMfc6slrLMD6pivv9sSnhAiBcYSIS4o51bYK3C6iI9NA8b7Wci1Dx\nuxovtSh3ptu/1Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX/Pxb4BSFiZxQaUZi1IgAzUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODI5MTFhMy01Y2IxLTQyYWUtOWUwZC1lOTBjYmNkMmQxYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQK4g4aTOBPz+Ulk1rCF7hhTx5dADjdvIDL+SYitx/WNRLM\nvMSskhUBqnZC+D33gMw4E2GaUgCUNviGldNCoRDZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU93TWILBWglEaj5YtebvD/+6C\n33gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEXuu8WUgwjajK9DGaRpNQ0MCH6dNhHLQCuuyMn9N1qECIQDyuevqDc6G\nwWlPR623eNknb1txpB6srTr1IvzU/mGM8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAY0/b40LOY0XJT4fwZyLXbVDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU1YzFjNjctYWI5Ny00ZmZlLWExN2MtM2QzYzZiYzhmNjU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMDE0Mjgx\nZC1kN2M3LTRmNjMtODIxNS0xNGY0ZTc3NzM0ZmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQWt4E+3ROP8Oexvxl5mSiraMd9hL1uAC48keTW2qaQmKWwRBNDJ8vS\ng/tzOTXJQqabE2efNw1X1u+ja6oelztko3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwoawH\nP6jFdrwyQgmNqP99e6/WezAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAK6uZmEY2SdOc4WuvRuD1v+FnOfLPBQ0MZwi\naC5N1x3YAiEA8rAdB05P94z/fLf9YxYfY3vpC9SSQooM8jzf1u/NQCA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2044", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2044` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcxtc3EviKMAElmw1sAFIm6CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxNjA1NGY1LTI3MGQtNDMzOC04MDFmLTIzZmZiZjI3MDU5MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNjYjAyOGYtODEx\nMC00OGU0LTkyODMtOTE2NTdiMjgwNGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnbZdKoWG3J2ul3ZuGNysfmK6Tea+fMHnR7j1FL2hnMIKZ77+Zeq3QZtPur7y\nag/vTazt2Xujgw3u/BW6Nu/DQqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU310d7bhsK8S9aQNvvfzsdoPw5FQwHwYDVR0j\nBBgwFoAU52axaxabp0HMyJq2GqbAkGkmGTMwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCWQ2wfJFgQ\nMGEoEeVSqEglm8ir/GUEVxowF16eZOmyWwIgDhA9xGhYR/GbesO3oDqiEeKBh8DT\nkBtUoSek5mSFr1c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARn0v6p+/2tMLWRtY8Ji21+NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTYwNTRmNS0yNzBkLTQzMzgtODAxZi0yM2ZmYmYyNzA1OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+mSISdR5Xn4j2qtI1kCZte7fOrBUUDCP3gybGU8vjclKn\nhpWHUiwhU+/pNcH545GAFo8aRIpknznQUc+A5T7xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU52axaxabp0HMyJq2GqbAkGkm\nGTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYM2dsMnGwemJEZLQf+aO7QAQmxHWqZt48ZVEVSsijSMCICfvGam/FrzI\nMmJQUtnejL9xNENuw9FoFNlhMJo6N/QH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAS6fsHMmn2dZwqoWaIWXCZGCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNjYjAyOGYtODExMC00OGU0LTkyODMtOTE2NTdiMjgwNGFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NmZmMmJm\nOC1iZWE3LTQ2NGUtYjJkMC04NmUzODAyNGE3MTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQu4DbvDyNXhqVDApOudFSBcHeW6dixnWz8s/w96EE0Ezww1j80m3dI\nZnDunlpbtMAGX1lXAaGN8NL2fahUhpf9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfXR3t\nuGwrxL1pA2+9/Ox2g/DkVDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOqw97SXuiX0yEzciju+7AFEvVZjxngbt691\notFLBKxpAiB2BLA9hCJFHffqhOajEB3oSODt1WkUhO7rN5NogyRZQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2045", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2045` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZ0UR4b2UaqMjdbfTom5v9LhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZTVlZWFlLTQwYTEtNDdhYy05ZmJkLWJkMTUyYjhhZjAwZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk0YTUzM2UtOThi\nZS00NDhiLWFhNWItMWYzNDQ4MzRmOWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIfLyc/4+wBgJfu32/o4gxE9Qux0j7Ey+FY6cS4lAb6/hZCkh8sqFV5IONpQZ\nTeKWVc2NitiyKV42dJmOJ/6OJqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuvVxADuj+mf3D1sCpf3XSEQ5xfcwHwYDVR0j\nBBgwFoAUSoHWjYr857mApUj9buJ0MDudO34wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIG3CLc1Xf4L9mJBDNPUrjreU3RWgV+863NZtlBL1x5f8AiBHse0fV6KQegND\nSYm+asGk9C11SVjFR2yj3kWnyaP2xw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX1bCarMKLTvzfatPA7yxmsLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWU1ZWVhZS00MGExLTQ3YWMtOWZiZC1iZDE1MmI4YWYwMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnVZIRo9zRCZQo1GnlB4uCDD851CbVH8Ih+/oglcEEEt/4\nRnpxuaSdMKyrOULKI8UeWvE3d+jpdww+uF67WU9Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSoHWjYr857mApUj9buJ0MDud\nO34wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJzi/Fo8uCm0pOwy8SMoalqRpphRYvxZ9WpBOXNjtzn9AiEAsRtuztfM\nIJ+MYvkqe5PQYiKRk30eWAXsYYwGUTvSjnU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISATm9roM5+7DkXRj82tuquD36MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk0YTUzM2UtOThiZS00NDhiLWFhNWItMWYzNDQ4MzRmOWUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNjBmMzk3\nYS02ZjhhLTQ5YTItODI3YS05NjNjNDk5NTRlZGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASvvygZ9/ccufVN/y8+lszpLw/1GiqqQU43ClVHKUVRN4Ky1Ipm0EE2\n1L134A7EPjP14MzPoPsVgNihjz8drbU/o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS69XEA\nO6P6Z/cPWwKl/ddIRDnF9zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgHjT9zvOeXWY0Q9e5dm15M4GAWUg0HTXS+jro\nbjklqhICIB36sB1Xga5Ea3pIpGWu4XD5IBleuM4NyJfPKkb6+EY4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2046", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2046` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeWdJHzrU2AxIIOeEk65EODdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxOGZkNTE1LTFjZjYtNDhhNS1hMWFlLWNkNWEzMjZiZjdkMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRhZjcyNTctYWEw\nNy00MzgzLWFiZTctZjA1ODFhNTRlYjQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsPdrXgabmVhDc6A04y5iu/+1mTag8PGnLJqf7hii4o6QObfrjbeyK5NpJj1o\ni106h9f1Fp0dUgWxqX3KIMasmKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGMnizUTUdYMQ5Ni+Xcewd2RssQcwHwYDVR0j\nBBgwFoAUa5ta+BiBhBAcRECcxIg4PgtPK7kwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFxktuHMFseFxm23e9Ft+0MWo43W6XLzraYG247QmPP0AiApk8qXX/BQj8sZ\ntuh1CGmBAFriT5QisXoadnoR3yLxyw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb/xVNmfuuYSokBmw4ogREdWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMThmZDUxNS0xY2Y2LTQ4YTUtYTFhZS1jZDVhMzI2YmY3ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIdkw5KK79WSjRWOEJ4UroZDBURaTZLda/JJS/stDM31AS\nAlZ7vS0fyYHfQRtm4LFi6SWGhSvdIKLl4Cfp3iVlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa5ta+BiBhBAcRECcxIg4PgtP\nK7kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAjaeaKZggbMjYsCrXC+W1eoSn+qJIiKOk6Fp2S/Ff60CIQDI1Ze3QUWv\n57zzSUpXqEqZB0DkE6iNbOwMug8yw24uOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAdgK86UoCwuBlwBpqDaUYbs+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRhZjcyNTctYWEwNy00MzgzLWFiZTctZjA1ODFhNTRlYjQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMmRmYTBl\nYy0wMmE1LTQ1YTctYWNjYi03ZWFiYmI5NGVkYTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQTacpHY9+uQENR5eZFn1Un6yzqcBdsgLtRd1RoycHcbr1Zq6p0N7Ma\nxwfjqcYoM+j7OlPJFv0EWMT1HboSm5zIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQYyeLN\nRNR1gxDk2L5dx7B3ZGyxBzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPa5UDlpb85g9p4NcLmMwk5E+Ch3lN/mcAv9\nBq3gPninAiBv0iAhR2rMVz7W6ZZyt0SJMmLaDDLdwcZltG7VASMDQw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2047", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2047` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAWS5F+OkWzhHLqSDpl5vzjRbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjZmEwNTg3LWJlNmQtNGQ1Yi1iZTlkLWJmN2U1MGZkODRkYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjczMDRkM2MtMDVk\nNC00YWYxLTliZDktNzQwYzA5ODA0NTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs0kZ1KHAvdKusJeRAh4w2teknXXg+ddmfoq614YL7Prg8TcHxb2zZhCAugmM\nOHPX7li2QQtp7NH0WfPvXldOYKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/ohKLnkQDSPeUwT4srAgsFHyAKIwHwYDVR0j\nBBgwFoAUadpFj1IJl+0P0XUPE6Ew7BaDnvEwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDX\nnVE+b50HUvdfFVr9tQ1W34HiPoa3LPLjhFTgXyDVFgIgUU/UMqKxWfpoec6HLGKh\nDeM63ZIv/gKBtNxO7oI14Fs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZEW5F6lBEYkpv+hAx7RiX7VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2ZhMDU4Ny1iZTZkLTRkNWItYmU5ZC1iZjdlNTBmZDg0ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5kWjHyMgJN8gnlkvaB/aJYFuctU7+bFNxGHO29lxeo34G\njLDakJcuVqHoIuct7nWeuZ3WpvCHJ9o50RC9Jp4uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUadpFj1IJl+0P0XUPE6Ew7BaD\nnvEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJHE0cEYWprk4AQnGsGI+hvgTV9owOoBwkoEqDEIhjvKAiEAj3nCm8Bb\n+ExRIgaQ25Y30or0Psk16ZzXS2TQR3a653U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAUljRS53jvXsMUSBhN+4mScVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjczMDRkM2MtMDVkNC00YWYxLTliZDktNzQwYzA5ODA0NTc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MzMwM2Zm\nMy00M2E4LTRjZTktOGMyZi05NGE1NzI0ZGU2MzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAScJfqxQmC78YZEhb11ue8mbIu4TS4Xi7hr1mR5bIMxVhye9bHeZOA/\nksbTUGhDKaSm6TR3RMP1SRBwlfGj1kOGo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+iEou\neRANI95TBPiysCCwUfIAojAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIPg4y7pQZK86tSN90U+vSdkfsLI/TADlzo+\nSzjGGD6UAiB5zl4PRsAl9wJSHBUwznUlzYzb5+Ey1PO8P4s3T4HE/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2048", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2048` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAdzX1xL46J8UVmeknE3+4CAOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkYTI4M2Q4LTJkNTUtNDc5My04Y2Q5LWU5Y2RlYjIzYzhhZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjYyMWY2MDAtNGUx\nZi00Y2I2LWFmNTMtNjY3ZjlmMmE2NTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmF2d4EAwQ1zYtgHg9jzEB4VCSWXoBXx12SrfOGgmzYpe//hNU03jIINYayqz\n4KVctiu0bml4gbcevwhlzpEXVKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBsOGUq276y22i3yir7Vw8/H9ricwHwYDVR0j\nBBgwFoAUjVUD/0cSC4LD2H13dFeLDdBnK9kwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDHNmhQgy5dgeI2OgH6oWo2BN0qpc2mjF++gME/j2jZBAIhAIDu\n6TevC17eDMeB4n2UTZAcU7e4+RcVTOqR5uCu0oS4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQFErllMCBxJsRkZhLiQMfbtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZGEyODNkOC0yZDU1LTQ3OTMtOGNkOS1lOWNkZWIyM2M4YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzgBPYmowRPZ+QHSA9KHDhiJphioJiXJ0N1bf10tpfDKeE\ncyldNW6wY5LSrQvzcsQKe6LzJSTNR0LSHYQIBK1co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjVUD/0cSC4LD2H13dFeLDdBn\nK9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMiAn/0++RgztHkNON5NULhdIXITxEQnaNUtHQWZGzMoCICJ6SW7e21Rz\nAtPJwk7HyPkCR0Ta6/AFeLG8wUQRWH/O\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQQhNQdiEXMxsRC2Zkc2yeJSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjYyMWY2MDAtNGUxZi00Y2I2LWFmNTMtNjY3ZjlmMmE2NTZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMjBhZGRj\nZS1hYmFlLTRlYWItYTc5Ny05M2EzNTZmY2M4ZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQj50Q09VoQHa3ahMB/tr5bSYT2ho7iwCHpibQtHY/cr7BNjA76RaPi\npC1p+avtVhNJRoCqhYSBnsPW7Ep7e7jyo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQGw4ZS\nrbvrLbaLfKKvtXDz8f2uJzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOH53NosYTg+l70Xugwih6ZmlrknrnynwsIN\nQeK8KrikAiAj75s+nUdZ/hZ7t+dSMLqR55Hfqc6DFAQfCkziNAwZ4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2049", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2049` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAT24nUz5kYh27b5WAkXCDfxeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzODY3YjYzLWNmMzYtNGZjZC1hY2MxLWIyNjkxOTY4ZTU4NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA4ZWVlNmItYjYw\nZS00YTEzLTkwZTQtZDc0YTU5ZTcxNDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3ugUOhnURVyntgmG2ojrvYCTDZBnDNI3igyB0Ay7bfujArtmiDUGG6nNyO57\n3EUvqHZju34+XY2/ea9nS4xStaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQIImVPCR/AHwHQf7CodTbRVQDwcwHwYDVR0j\nBBgwFoAU85cY+f0NIUNjML2hyAPjbkuIk98wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFmmoQZMXUgjbQ7a5E9dJ4Vk7KWxKWM2yesKRLg7yDajAiAQ75z3\n5jbj9LXcwmIJY0ox7OB0f9FKx7xLDLFG4ZnAiA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVcIMMZlzgLmILzn1rhoznnPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzg2N2I2My1jZjM2LTRmY2QtYWNjMS1iMjY5MTk2OGU1ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJsV0B5hzwB2SKxYL5mjc2GIycqeYAKhOrJki05/cUHqWo\nWNaaBGf6nGCapQIvBoRPLTLg1Dnnjw54PEQA8glTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU85cY+f0NIUNjML2hyAPjbkuI\nk98wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ6xyqnjZIsN2aGpDx1hIDoaRMse2AGhv5esEPFxKdeoCIFM4//FfSM34\nn+8CRqebIfBe98o5JY78JV+bBCeZNt0e\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAdINfJhsiH/veYdQCnl7wH8wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA4ZWVlNmItYjYwZS00YTEzLTkwZTQtZDc0YTU5ZTcxNDg5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZTFjZWMy\nOC0xM2UwLTRmOTctYTZiYS0wYjljZmNlNTUwNTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARqaHPWWAX7N0WNAZoibCT0805jcH7jyCIVQekuBdxKBt9KI4qT7nDG\njUm8XmZnhdIqfwMUny/IIPL7Pi7D/eYVo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRAgiZU\n8JH8AfAdB/sKh1NtFVAPBzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgEzwIsBiLCDfDabraHz6NPLCO2zBMDvjhEav5\nCUhvSLQCIFjmMnrMSIhRe21VwAAnltChL+/ESnO1twzHd7IztzGP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2050", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2050` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXtkwkhGIoiUkKK93mw41tCbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmYWZmNDgxLTk0NzgtNDcxNS1iMDFjLWFmYzQ4ZTc0ZWRiODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmJmMjIxMmYtYzIz\nMy00YTc4LWIxNjQtZjhlOGIxZjUzZjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKdaFoyxCXDCpXZbvK6olzXMW74FZzSAGvX/yqCDJwHsno/kLZ8ghZi5NzEdN\nNEH4v1MzPNq7ZltSR/OXtej05KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBAzcUpDuUVrXXswIoDL9f3FGBynMB8GA1UdIwQY\nMBaAFPEkXh3DXO/BDgIUVjlwPZabgWoBMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAyqlpbFjxNbI+5ocM6BZ6LeTWsfvWee1z\nNModkh9pAqUCIG5i8neXQb94H+pvQC2izHHerxNgx/2vQHTMUleOiJsA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf84YqIU8q30lKfxal0LiH/VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmFmZjQ4MS05NDc4LTQ3MTUtYjAxYy1hZmM0OGU3NGVkYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQn+YZsPJSe5mriRLfNaurUsYnPBKfu8rnJwyb6dU3P2U6l\nDOIEdalTdgzqj2PiKqBvobHhoqDMr5L5VdvCqBFfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8SReHcNc78EOAhRWOXA9lpuB\nagEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfwYFcJ5EUcr2TLYZPmiasPzJfT/BXw9gaLcClmfc/LQCIQCmLBathL0K\nXxZiVVWYlGOwXNLHN3ws4iYYXqGO/kNMcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAQiRTinWBQbVJ11KGkXdYKydMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmJmMjIxMmYtYzIzMy00YTc4LWIxNjQtZjhlOGIxZjUzZjE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YzRlN2Yw\nOC1kZDZmLTRlYTctYWQ1Yi0yZjJlZjM2MzJjZjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ2Ru+L9UpfB0Iu4j6EiUW0dY5itL4xdO81nC3Gp93a6YOusK2lT5Hk\nNi9oCvjOH1U7t2eMap8nxdPw0MnSE6Reo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQQM3FK\nQ7lFa117MCKAy/X9xRgcpzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhALcLhy27FoRXMZNwwYoBl9lyh+X/5kyIPui4\nepNBKo81AiEAlpY9ZJ1tn5Lj63mX1DFuFSqbJiVlm4EyWOH99jVTx9o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2051", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2051` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbUBNBkyNHz57ol6DKYiN4CMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmNGNjZDMxLWY1MzQtNDJjYS04ZTJkLWQ2ODg2MDFjZjIyYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg1YWU1NmMtZThk\nYS00MzAwLThkNDctNDU3NjZjYjUwNjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+PUGE9OrPVvJ41a8pNr+APVTXWHJirU+aDoJoYTlzO8wIhhC53DoYpWsWMYb\nTwnM8KKDxRh/FjfA9Lq2Px224KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTt/UppKZ/jxopDrVgJZY6lDfFzYwHwYDVR0j\nBBgwFoAUYCsHsviaJqB62HskIBAJXDFEZJkwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJLIKhVvtmMC\niN9w3g/6cd4ilis9libKyUBdsA6DP4JRAiBALFqPzWxAxo7CDuzlwZJ/kFcETW41\nnRU3AIhdmiN9pg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZu6DQqwreovTh/EJSgbeMhnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjRjY2QzMS1mNTM0LTQyY2EtOGUyZC1kNjg4NjAxY2YyMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTfFrKbAAC+Hvg89elHaLhWyCtFRwBbR9K5aDRUp9wJtis\nlF4EdtZagC1MdHbGkfReE2/QC/zROTyggH0RHp0Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYCsHsviaJqB62HskIBAJXDFE\nZJkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIveq2E41jnN7Uuu7qqZdSIwBfmf+NEdOVKbeYl1P7sFAiBBsuv3TYZq\ndr+vor8OOct6OY/joN5OOJfDKzXf+hO2YA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAdrzjSH0MSLekDaDy5pcVHY/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg1YWU1NmMtZThkYS00MzAwLThkNDctNDU3NjZjYjUwNjViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NzJmZDNh\nNC02ODc2LTRiNGQtYjMzMi00NGYyZWJkMmE0MjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQt2Rp1lfO5GpMufqHYWzi08c+f05oXDX3CbfhGpoMWAECCGyfHxQwn\nXO3BXxkJBToCHPzyNGLNFdTMoX0qBNeQo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRO39Sm\nkpn+PGikOtWAlljqUN8XNjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgDgpEraAJZABC5pNIf7qR3y+80UouML5iHibk\nzPaW+LICIQD2y7Kue5FKiz3U4ATSB/z7CsPqKcGkO/8oDeNvqJmymw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2052", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2052` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARXLB3eWXY5qHJo/wjX1CPMeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkNjgzNTBhLTcyYzMtNDE0NS04ZGZlLWExYmI0NmMyMjNlMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVjYmQ1ZTYtM2Zj\nZS00MDhlLWE2MGMtYTYyMTNkYTI5YWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvmidzTkGHB10dq1NdEVKY09de14NHEiju1QTevQEPDGQ3QFPqs2eFL4jRi7B\nT5nRTNMpebzmy9vMeoaYO2Vrq6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKF1eS+OISrVHalR+4zQwEJwLRHwwHwYDVR0j\nBBgwFoAUNDPP1vPxz+kBcQ0GVyzsm5eixWMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgX9y2LPyYwOHi\nZ473lz8A6eYcKFgHOw0QOtuAoJQEm98CIQCyY1AYkRG6JrfAwM/7PqDTe0RaZVNp\nAhDv2asnFLXXeg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATOBxjZLExG0koCFs6j+KQUyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDY4MzUwYS03MmMzLTQxNDUtOGRmZS1hMWJiNDZjMjIzZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFZgZ99leaALfMMNIzPdNkGNht/ewaUKldEVL9BlzHOVL/\nBVzQqfbjyVzkz4fVyIGFlrtYylhOxSoPohjCOIQ0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNDPP1vPxz+kBcQ0GVyzsm5ei\nxWMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYwYAi9dwf7fERnPL/OsGi0kI6FGxxjG/BRPxAaqG2uwCIQDHSw+0HNON\nwMv4TdDln8ZrqeaOtTUxIl2ACmdOf+Us/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAfinB7+M3I9dTZ03pg0+lSg7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVjYmQ1ZTYtM2ZjZS00MDhlLWE2MGMtYTYyMTNkYTI5YWUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYzYyYjgz\nYS0zZGE2LTQzNzItYTQ3OC1kOWI2MzFkODEwMDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS1ONVGdKT9lgHgRZyNMLlUVesmh81cBWwdGZrNfMEqXvZmnBl4iyMH\ncy0zdUlpYwAAOhhhHSlU+k6xLZlW1Nbyo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQoXV5L\n44hKtUdqVH7jNDAQnAtEfDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgBqegR9LIMg7d703CuIFxaHdozmRIXBY2OmVy\n7N4XGlwCIQCDIGvzkBZXKYV51gYeqSuKRclO3Ja+sINRyTkpLUW5aQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2053", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2053` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQ8SFxqpmhz5dLhjXsoVrms4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhYzZjMjAwLTEzZGEtNDIyOS1iNjljLWYyYzdjODQwZGVjOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFmZTMzNmEtZmQ4\nZS00OGFiLThiMzEtZWQ1MDU5NjE3ODI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv1hboiIFa0s0jcwxEveissfrlqEEFccauEPMMmrSxKrASbarbzoi8nQv7zDf\neG4DAbizy0Z9g/H1rhSEHNI/QKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ5E0cwH5la30QOTMCfsg9W4StDQwHwYDVR0j\nBBgwFoAUN/CDTdS/drd0C3QNRhPn+j7EU9EwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDRB+PjP0pg\nRKihBgwZjJmEhSEMQo0IuvpP7AVO0DbT3gIgIr6dEm2vFFs0EF3Hjf5wRdCPR8Cy\nKwVujr9y2WzXMh0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVDKlzsnVG9cWLwXlcDQG3RNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWM2YzIwMC0xM2RhLTQyMjktYjY5Yy1mMmM3Yzg0MGRlYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFSHb1gX9O1ClaL7vYW35x4ET1oFejaLaOe5d1gHvRawkz\n0hAvFXqncKWncAtgJfzMz6OK2w581n+yd7nzE18Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN/CDTdS/drd0C3QNRhPn+j7E\nU9EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB9qwhoo2n9u95Uaf7pzgZyc0E1QLJ+xpJ5Y5RNa9c+MCIQDbzOyE3ypQ\nTyWpNHIesnsswh7X1fsRJX/ce8mLLFLY7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAQ80Kf4GIyBzYB3Y40G7yVmtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFmZTMzNmEtZmQ4ZS00OGFiLThiMzEtZWQ1MDU5NjE3ODI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZTBhYmE1\nYi02ZDBhLTRkZWQtOGNlOS0zMTgxZjhjMmYwMTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS80n8biNOLjcccKVJ5IGBA4/PAhdXDPlw7/63QmBM+jt8uQHbT3AnI\nonXYFDyZ5vUnc401IPN5sVXzGAcIb1NFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRnkTRz\nAfmVrfRA5MwJ+yD1bhK0NDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhALTLFZtJNwypYPV9pqhmf2JrKWgZZfSDPolu\nxYOsG+45AiEA5HStZfay0UiC5Rh+eVOEXrS0SJdkc0sds2gEnFjne2M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2054", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2054` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZniuhzypTJYjWVRmATcZojKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyOWQ3NjExLThhMmQtNDc4Ny1iODcxLWVhN2M1OGI4YjQwNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQyY2UyYjMtNTg5\nOC00MTZkLTk5NTMtZTM1Mjk4YjZjODlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEChdqRd0AwW5jX5ffzus6PnSOz+GIfxaHOK7aWywElFA41VjALmw5kcClIVUb\nLIxt8INvOAOmTjzRAVzOSbpDk6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPLgxuTFlwwXlHizuwcxp1j3drqAwHwYDVR0j\nBBgwFoAUACpN/RmC33Egx+Sp+v6fGBY6l4AwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIE6xCJMylvPJ35xXcY30CqjC+ozjmM9eQkqUWPSPj0cOAiEAtz4z3SLk8oxi\nVXM7PbC9Eon0zm8xvsuw59e0lVE3X7U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfrGvrXkoV1KZBmYK77zDvwzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjlkNzYxMS04YTJkLTQ3ODctYjg3MS1lYTdjNThiOGI0MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqyMnQYI156YIZVD3m7B9ps4aFgDcLwdwlHwHAfzgTvNXc\nWCmFkuKeVVjroZ23PMEofVR4bz9h6kWRM5Am4sRjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUACpN/RmC33Egx+Sp+v6fGBY6\nl4AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaKy7QfOBhG6+tAJGKD+9jOJ99vYwlg1iLFfkAglDtHICIFQ+9stYtIBS\nx5xelHEut2TSb1FHMAlCCJlN+4gstxvD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAYVPpTfqn28T08GGTsg606LtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQyY2UyYjMtNTg5OC00MTZkLTk5NTMtZTM1Mjk4YjZjODlmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwOTFkNjcy\nMy0yMGU1LTQ4YjktOTY5ZC01OTdiMmMwMDA0ZmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASbShZAZnehEcFTvg0XXyJXrxHgBN9yfIFIMMWh/foDJ/Giw/uWZUXc\nK/TrIrmV1frdVn5MxlAY3sr5WI7aAxqIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ8uDG5\nMWXDBeUeLO7BzGnWPd2uoDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPrRbXOjunnJs5wQwXcrqJQMkushhewA6JEI\nZvxHfcKlAiBVroNX5ojJwaHL1ZENTcQNZ24ulXK2sdrC5O8rY5o33w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2055", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2055` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAa81mwDPYMtDY4z/Bcn/hR64MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NzMxZjBmLTliYWQtNDgzZC1hMjBkLTRiZTk5YzI5YjU5MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjkwYmJkYWQtNTNj\nOC00YzI2LThiYzYtMjI3ZDU1NDI4OTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYX58F7LXC2J/5foVsYxxbsDWN2fAY6Vu7DkQU14TirQsWmR8XCxjm1n1r1Xi\nwyGGwrvbdsRM2UCbOP8f1aB+E6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOzGAOtvY4KQCpqdD1HkgquvZe7swHwYDVR0j\nBBgwFoAUSP8yGZyfx6NSR+rH/Ukh9dTIALEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICxHlh6hp3sGG3P2dQDcbGg0i581uOPiPd/WVy8QkQ6uAiBXgX4+7Y4fZR70\nYbPaGICAGPCXBpVQcue0pYjlO8UgNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYl3SSKFkVGSJ4QaK1mDctwMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjczMWYwZi05YmFkLTQ4M2QtYTIwZC00YmU5OWMyOWI1OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXUDPe4tocbQutCJDiQzwcyMGdIpG9ppl7k/dFaQ9nkuLP\nbxs4CkQTWGtyQb2aBtkaHMrBItd/mMbvd5kKyeoZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSP8yGZyfx6NSR+rH/Ukh9dTI\nALEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKyp+MLjIUW6irfuyeX+qG5VdZAYfO+md9WPiQzYop3cAiAW30Ztq4FG\nN3w+O/t2oWkOeyfUY+oY4v9Cv/1yxNy9NQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAfj2cNnar1Iu6UqaGnuuuDT9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjkwYmJkYWQtNTNjOC00YzI2LThiYzYtMjI3ZDU1NDI4OTRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMjdjYjM4\nYy0yZWRkLTQxOTQtYWFiZC00YmM3ZDlhNDZmZjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQXc6oPTsMG9COLi7Cxy2fI4UaXMW2cnBkYCMnkra8PXLcYVBIpXM9n\nELYDK0G1cC/yQwEPCmqFFyzkfuTY5M5Jo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ7MYA6\n29jgpAKmp0PUeSCq69l7uzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAP4LaamSg8M6DYcDm/wouU85QebC4ryN1QSN\ngR59JEscAiEAvdVgG6GB37wFYxkWB6t/QTJirsEWljg0PPy9QNzzWg0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2056", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2056` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAfeO6LO1JfESMHGFlsXyu3DpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MWI5MTIzLTAwYTctNDNjOS04MzQxLTdlMWYwYzEyYjkxZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI4MTUwMzEtYzEx\nYS00MDI1LWI4NTAtMWM1NTRkZjg4ZjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqUx/veUVwulYoDAhT/zT33W2HB3uOWUn1Ecx18e6LuhjKVYERVeH4tjRH3Fu\nRngISsQ4wybj2mAmBDZI3o3R/KOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwLNbu6dgRwnPxpoxSSuGmI5ei1swHwYDVR0j\nBBgwFoAUQoQHxkhpFyrVQ8yS2amAk2En9HAwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDq\nHdLGUJBc/KlhzdHU9+0FEbaUwlgOR9W+2fO/0hrgygIhANRGiON7djAGtuIouo0E\n59VpCcsOD/eu95qOvbDS/qWl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb0bZxto4udWRilmSydG6mwXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODFiOTEyMy0wMGE3LTQzYzktODM0MS03ZTFmMGMxMmI5MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATP7I6jLsrSy2B3ky75uAPOIyW4Nrx6kMgbmOjqE+5SDBrL\nfuZE4Y7dGMYNc7bnJJNGGehV6o9lnHls7wGUEmgoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQoQHxkhpFyrVQ8yS2amAk2En\n9HAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM/6b6haFSM5TjHvCSZQmieS8fiGRL+0KTdCXpPF1GSdAiBv8A7SKToW\nYw6E+aTNq5xYDNNkLm9kje2d+KFLIoVh7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAePJAgdYds9PHtaaKOxUEvkEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI4MTUwMzEtYzExYS00MDI1LWI4NTAtMWM1NTRkZjg4ZjExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjY2JkN2Jk\nZi05MTY4LTRiNWItOWY1OS1mNGEzNjJmZTI4YmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQc3pHwRKGuZlDEUDtWe33xPNq3b3OohzLX8QxK5MEr0Yj3UjAwrY/p\ni+V01Q4av8Yt/N6n5CWXNOkbcrzTVJK4o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAs1u7\np2BHCc/GmjFJK4aYjl6LWzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAN+sh3icJ3q30phQ/xbcmxoqQcupkFz5Ofws\nvX3Dfyn1AiAhqVWQ5JKwQ82fnYgU4OfUw+d7uPiLReDhQ8Cmr2LyiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2057", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2057` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAd2pJ6MSq310Tj2CljdYqAu8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNGEyODhkLWRmMWYtNGRhYy1hZjQ2LTZmNWMxOWRmYjdhNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBiMjQzOTgtOTNk\nNC00ZjFmLTg1OGQtOGJmZGQ4ZGE4NDIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7qnhuugLtYJDvhj9lIMEJaTZjVD7fTuaKZuMbv9z/ksPbPt5FrqocKcNZSja\n0MkUQGmDnwj496M84B3WGEq2C6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVgSqKC9N++OeDSWDDQ6l1DJOD2QwHwYDVR0j\nBBgwFoAUIBGjxP23MGcD56VSFqdD/HHbAT4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBZ02j/COUA4racUvgHCkqzEp+HKDwW92LxRic/MNv8jAiEAmUs+\nZx8a/dstyOmkxINAvbwBhCSdyEml0Ggo7CN9/P8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbyCPWLGPaJoWNd8CRD14smpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzRhMjg4ZC1kZjFmLTRkYWMtYWY0Ni02ZjVjMTlkZmI3YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzLc5vy621+St6UDyEKgwXZXD1jYxotY39n57tN1prBigb\niNc0pivQp3FAiIYf49yWqZZ+PgGvr0g9/Ackt2T6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIBGjxP23MGcD56VSFqdD/HHb\nAT4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOxnd0F16EYoXFpXmY/zVIgIvTTg0/eSu9y6sJc6TSdrAiEAiNZDep1E\ntzXoXqONLRnXL6N56KCSswlIRVnnRfqyJes=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAfHoAUOl/AdnJrsBPZnqcclQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBiMjQzOTgtOTNkNC00ZjFmLTg1OGQtOGJmZGQ4ZGE4NDIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZTc1MzFj\nYS04YzcwLTQzODItYjRjMy03ZjVhNDYwYzE1YTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS5gT0+9DVS6AylXvL53ewklboTUKNY8+nQzZc3QgyAECRHdkUK0zAb\n4SdI97yLeMudx0S03Iw7Z2X/O3wDqHKAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWBKoo\nL037454NJYMNDqXUMk4PZDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhALQ/vFfNWevMVtZ+yIu4IKnv6qnWst2smnlW\noc1n+aL3AiARezOnw3mOTDRE6TwiUhZ9emR9Dgq4ezP7KeTUrysQuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2058", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2058` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYfNDtqA1vzrF4nUb3wOnyVpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhZDJhZjVlLThlNTktNDU0Yi05ZmY3LTkwODc0ZGI1YzQ1NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc5YmViNGMtZmI0\nZi00MWRiLWIwM2ItZDlkY2U3MDllNmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhXQ8fyJNawa0Dw69QLdTz2AAc6zx4IN3YYbfmapIl5WH+0lWdEkNS2upO47q\n6eCof6ZWpjjFBaUqYLyKOtc2+6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmxoP3YHZvfhRLVgQ8kQmIDvK6kAwHwYDVR0j\nBBgwFoAUp6a5+HKEcMSgJQwNfQp4pu8ExtkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCF54PQDTHq7tDzGHpw185KNFpweYEz+RJG8QBnPUfwVwIgdcmR\nNdxERbEzO2GoS2+7a3Tplw6iWH93/atG+Vb3N4g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYqrY5RZBtiGq7EMn0tq7IcFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWQyYWY1ZS04ZTU5LTQ1NGItOWZmNy05MDg3NGRiNWM0NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASS0LQtk+B6ll5/N8I/b2kWHnjoJWqBJaLdWV51XuzhWtWR\nWh16AoKw5ILCYliZuXBX2fcKMfARm15yJc1b7HXuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp6a5+HKEcMSgJQwNfQp4pu8E\nxtkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJsMNM1t3zPVYKKckKuHoBeDU1QMRqKpfbDkveCjFoYnAiEA9lgynoAO\nVdbNKH3SoCiwLtCvCL8yU4Pr+18sehHFE7A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAfpzWAPg6xQ1C0i/rAtGmWfJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc5YmViNGMtZmI0Zi00MWRiLWIwM2ItZDlkY2U3MDllNmY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NjFjMmY1\nYS02NzQ5LTRlMmMtODg4MC0xZjFiMTY5NzgyZWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR+/ktoTBVyMn5TLxA2F0n6kmOxnBMuQhuwvj4rJ2AVXV+EQiokXbcS\n1gkn1ahqGnBs2jJ31pJ3EMLDvMbBSlYfo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSbGg/d\ngdm9+FEtWBDyRCYgO8rqQDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIx75PBo9a6i4VQQYn+FItORtVwqCyeUvP6U\n2ji+kflXAiEAuxTKwllDp11Bn2R5BtyUKv1tlNW9X9p4alwP607WohU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2059", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2059` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYBPD0q1GeHfG3dk6ocL9ie4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZGZlMGQzLThiN2YtNGJhMC1iMTNjLTU2N2UwNjg1Mzk3ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNiNWExZjYtNGY0\nZi00YTZkLTg0ZTMtNmEyMGYyNWM3ZmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETnUApJgXeYKsmFqL90iOatjXc6Xt+EyC3dF+bcdi/RfVbhBKNZdp/yfNwWgD\nrDsxFHFK1MPPD6B3WZTMiW/b/KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTtv54XzB4tvLSpai66zvitoznvOzAfBgNVHSME\nGDAWgBQn/ZDbNw3dp582zKOWJ4IdSEOtADAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDPJF6hdnGWeqPo5oeotYpTIdbsouaZA\nNU2Xpj1i0DgrAiAP+zMttY8WXB1XYOMZUuV3yNbQCv2cPmc1VExL/2ythw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaCNvrQ4KSuKZ+hWpViRPF0vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWRmZTBkMy04YjdmLTRiYTAtYjEzYy01NjdlMDY4NTM5N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATymTBWbEcms/th++fRJgMpCyJH/wc3HPfVcdGJZXJQ6NLD\nNRaxDZ9B3QtTIprsa4tsU2peRfgkXXfvvSq0xeR4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ/2Q2zcN3aefNsyjlieCHUhD\nrQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRF3OBxRyc2+VxPb9nKVlxhff0AYMSYANf4BmiVdK0GQCIQC/I8SOUikt\nTj4bMsI6Lx8/FLOOxjrFIVMWN5aQjVoojw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAVZMLAgZ6alP8L7zftZip2olMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNiNWExZjYtNGY0Zi00YTZkLTg0ZTMtNmEyMGYyNWM3ZmQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NmRmMzg2\nMS04OTlhLTQ0MTYtYjFlZi0wMzYzMGZlNDhmMzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQC+/eyMol5YsexF3CP8FrIahe+rCqR9D8yMJk19AzZvK9hagvCB+8+\nVTGjHj1cp7XTIRdtb3Q10W0C3QaIBzf1o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTtv54X\nzB4tvLSpai66zvitoznvOzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgaz02PWa3fN7YfdGdW6yFBfbuKqiy1c0CrCj8\nqbnEgVoCIQDsXyf9XtD4si+RBtUUMsWIjwuogFGIL4yFbCF01jiliQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2060", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2060` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISActsDbdmbtlXHkUrW8HPdzgzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZTdiZjk5LWNlNDUtNGRkMS1iZDlhLTc4YTE3NGQyNDc5YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGVjMDJjNGMtOWY4\nNy00ZGQyLWJmMjYtM2Y4NjNiN2E2Y2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEikk+lanFYv6AmTZBSyVUnVwVbcnYr840FmVTKTztlDa00MVu2U0XdkPqCzCf\ny3W73Ic4PxgHBIaePSrpFb4WeqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyiuXPD0XJfBK5fySkuyagmnAeyMwHwYDVR0j\nBBgwFoAUcX4WqzaSTOdg0QSA7ClyFd4PfxgwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDWKOrfwWIv\nBK4lTvnJiEH7iVR/rryAQHhlkMW41CLK0QIhAOv2ASo1ecVW1P0l9hxklmeSEq2P\nwDTp6prVbLUN8A9w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVPC7Xg5gjh8o5kr6c3Vm2ffMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmU3YmY5OS1jZTQ1LTRkZDEtYmQ5YS03OGExNzRkMjQ3OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxHg6RL6nctvgPSN6Z37CeoOT936dG3d5DJ3Dr6t49uB7E\ng+8jO6I+cuAgQr9i8gU3j/qr2bv9Xk5t04J6BNqpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcX4WqzaSTOdg0QSA7ClyFd4P\nfxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEYPwvZRpknnmiytDm6csvQ3YI0/Jt4hhovojF+QlrbYCIHFGJnd6cA1M\nr47sCdYJW3/hUN3dPBMusMmluJBydSAq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAUakC3N7r60vOrkF7Fy7B5sxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGVjMDJjNGMtOWY4Ny00ZGQyLWJmMjYtM2Y4NjNiN2E2Y2NkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MmU4Y2Ux\nNy02ZDM3LTQxYzEtODQ0YS03MDczNmM4OWFhMzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATITFhHJnf+dcBaOmjYQ0ZPxyuQ0FMO6njetnba7Krqw14E2GcAaRv+\nLarKbnZORWxSE7XZDMqf+dEyXoIbJEd1o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKK5c8\nPRcl8Erl/JKS7JqCacB7IzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgfvMBTix+5Ut1wwCG2P+6Q5mm2o2ls/YcZ4Bk\nMgB97uMCIQC0xxCYQN0rNtkKZYYDvMjj2z8F0L62UB3fBA7hMr8MxQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2061", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2061` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYKHbP+8Ty07Ylpvm6ZH+hKnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwOTIyYWNmLWY2ZjctNDM3Yy04YzQ5LTY2NmFhM2QyODhmMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNlZTkxM2ItMjMy\nYS00MWI0LThhOTctMWM0NjExNmQ0NTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjMN27YWwmYLHMWAr9/9clx0m2aLhIeBfhHC7YznSZCL4Z3NuKV+Ad+BZpa0Z\nsZ/KTeKjgoe2OuVRnMqGC9C83KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL7I1vrnzfiN+afog3gJAVhr/DJMwHwYDVR0j\nBBgwFoAUdpLSB6aRnTGmEEfJQHaiXmOu7rkwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDr5i0lT4/s\ncf7EeOdT6Z3ntEQFTyXB4R7UaGewL8XFYAIgRIepHAstGK2a8fM+GyRECJmdboCR\npIxh0llcu3ObpYE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZzSUE4Rl/eUba/smLOqnX2mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDkyMmFjZi1mNmY3LTQzN2MtOGM0OS02NjZhYTNkMjg4ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYGr5rV1AYmPaaVb2CBoBxR0XbxFY0dFhuwJIWndC/iWr7\nUlZB1sKw/My8947Lo6fymhP332VzM5GNt0Y31Bh3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdpLSB6aRnTGmEEfJQHaiXmOu\n7rkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSVYr0a4Q2ywl73wxAOeOavYjsacbr03+eV7Wf9JqQtoCIHPIqWtB0i+j\n+z8dc3yNkh4/Qz8a9dcesZAP5KIdZFdf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAUuTr2E8Slxy7AWudKB28JQLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNlZTkxM2ItMjMyYS00MWI0LThhOTctMWM0NjExNmQ0NTYzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNzc1NDRh\nNS1hZDU1LTQxMmEtODY3ZS0xOTcwMjcwMmEwZWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATBcGemVQimaQMsnt27XQtfZw8zn6Jp6vkc/B84ez58gUtVlIQ2orm7\nQAMi1KpeCWTENfxIEyOYTrkxDgxGaLpRo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQvsjW+\nufN+I35p+iDeAkBWGv8MkzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhANbQRwsuLmZoRqSBiDSsIx4kPxnMS9MDEbuw\nkyt4STESAiEA1qReByt+FYLcIYCFjyzzX+awYpTkHHACtNeO9ZA0Iu4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2062", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2062` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAac4BZtVD1lKaCRNbk7p/aT+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmYzE2ZmVkLTNkZjUtNGY4NS1hMjY3LWI1ZjMxNWNhMmIxZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM2NzNjZGYtNTA4\nNi00YjMzLWE4N2MtMjNkODk5ZjZjNDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXKKuwztYKes4Ax0WH+l77SkdAdjP3En8HD9wEeUFwTRKvLGuFWdyBphwqN7i\n4stR+imC7AC0n69wZJWrXdLqOqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpim3FblAOvZ0uuxa0hue649yhaowHwYDVR0j\nBBgwFoAUII9UHpV1oX/7ZxW7hIUCGWyqt4owKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEA+01A2YqW\nbmtQgbDHii0lsDXLZOiuWpR6/gOaFzWjXXMCIQD1UppVsowsSB4cup3AMPoGv6IF\nEAXaxkkNitT7XEhzDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfLe1VthOjZwMkojKkTZYvtBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZmMxNmZlZC0zZGY1LTRmODUtYTI2Ny1iNWYzMTVjYTJiMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsL5i5Ubx1V5KXI8CBWui4O2rKyAQjuwl/tB/iXeL5yBrq\n+JOt2I0LurkMWkdFfzwMRerbejjNkq8GuCcd9T+/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUII9UHpV1oX/7ZxW7hIUCGWyq\nt4owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTiLJJLrDIGJsnRdREgmGyzJKMnImwRFEv67sveUL2dYCIQCwPGFY3ms+\ndLUXGKYreUhhq8wfQxOSavqC14AqxEyxQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAR29IEYZXWIv05d0QS6TsgJ6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM2NzNjZGYtNTA4Ni00YjMzLWE4N2MtMjNkODk5ZjZjNDZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5YjcyZjQ2\nNS1kN2E2LTRkMjktODYzOS0xOWUyNzFkYzc0MGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASsbx3heow/gzg9yduXcJUZhUpjEFurUg6qeZnuKgffNzZAqgWK7H9b\nf2vmjsjJ28f1wHE668w+jnna1lkKwFxWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmKbcV\nuUA69nS67FrSG57rj3KFqjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgZwqoWQeOvxf6yncdtViKbCnzg3kJYvSACzzi\nZECAJkcCIDZuwJwSztOk+sHrhj7j+uTDCuKsJzOd52D2Qf8aXB02\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2063", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2063` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAe6lRSbzQISJtIbtIAeggyW6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0MzEzZjk5LWI3YmQtNDgwNS05OTM2LWM3NTY2YjMwZDg1YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVkZTE0MWUtMmE0\nNy00YTNjLTgwYzItYjVjYjk2NGVkNzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiEwwlFMdVxvWXLcdtusSQd6itXWrKTlzoGcuELeePMsSbvOCxpFO2gvrqdZS\nMKv84w3xMAjFmh8OJ/HaiIszcaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiWkwPwi4N0ecRi+nN0TBHZsCE1swHwYDVR0j\nBBgwFoAUcgUWQfhrCJqWfjNu1xWL6JHr0CswNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiAq3fTaG6PzNNOpnh7ES1w4Jgm9aU67ubQKfOaxkdrKCwIhANnIh3pGCuo9\n1DysgbF3vPmcr8BqueKEhPSTzFmZ0MI4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYZDCGNKEMsfsK12UF5hmozGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDMxM2Y5OS1iN2JkLTQ4MDUtOTkzNi1jNzU2NmIzMGQ4NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkMsn/Y0pAJNi16m4crLFKLa2CyXFMRLiLFeazKX9aU57O\nz+K9jNQQjq9bSRHdeTuYXyi+4mZKn2cSawx/3UEKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcgUWQfhrCJqWfjNu1xWL6JHr\n0CswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcGl2e/3On7PTZQ/jTIxPNXkBdtetGJr2O4Jcee0NMj4CIDBesJiioVZH\noZKZlI8p8t6so5CmGUVXPIpGdHtmVTfV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAf2Xn9PnS8c316rGVQr3l/x3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVkZTE0MWUtMmE0Ny00YTNjLTgwYzItYjVjYjk2NGVkNzBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYTMyOGEz\nMC0xODhjLTQ2NzMtYmJmYS00ZGNkNzZmYTBhNDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9OYSdl+v2TUpnT91GqNBzdHcF5QMDddUgOjpD2HaIG28KexNz8kNO\n1TYVn/MjbpQqgP+XRB/brPR3yfZWtTyEo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSJaTA/\nCLg3R5xGL6c3RMEdmwITWzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgTTK0UCLryLuKZjXL+hMcdJ8UjE+vFmlpQJtc\nqAMJdS0CIQCJsJiuobG+2cZXlF5U6NfSFftuHU+Oab25/NuJL5Tyag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2064", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2064` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAaIHxSrsGuhtC757eaWlQnxAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiNTVjNDIyLWVjNzgtNGIyZi05ZTlmLWQxZGQ5MjI2ZWIwYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmIyZWU0ODUtMjIy\nOC00YWExLThlNWYtNWZjOGVlNzdhYzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHWKtpYyRdtmuDTsrq2987O+7ArRBA43tox1sq1oxCrPffUqGSF4na0EIsr9f\nlt/ea5DGYoNs9UOBs+A4ObUki6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPNEAe3JbOfwZFrbRjEI7DvhaoK4wHwYDVR0j\nBBgwFoAU2rAL6zi32dq9HlbWdExo/SSsfQEwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAxf/K716ZluEa1xkoZTYVQp2qdurbl/cS6RU5XIM5tJQIgUpav2fBhMz71\n1jWBXoiWBKYACLK0LTyYVo1qU80zGfU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR9qHnWgEpei1C/NX1w3IBb5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjU1YzQyMi1lYzc4LTRiMmYtOWU5Zi1kMWRkOTIyNmViMGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHFUIR4S8L+5kxiKfOUSEUt8O1rz77qwwLMM2vqGvzjmJV\nJHGKDp5P+KqIk5ceen8E5z6eksl/TPszyK9/5Ea+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2rAL6zi32dq9HlbWdExo/SSs\nfQEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPpzL80roS3BpSMGhwMvULVp37fXrPtNnN8UqU+FlvehAiEAn8HkPtDD\nDCK4iVGhwQpDd9mwKOD/swuZcmwStt/12OM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISASqbYu1BdqKrfeMYXvKJ/vA1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmIyZWU0ODUtMjIyOC00YWExLThlNWYtNWZjOGVlNzdhYzE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMjc5NmI2\nYi01YTdkLTRjOTgtYjlhMC1iZmJiZmY2YjhhZGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATZ5LqQ3wtEqKBEpC75n7XD48FYCNLKwui8nCSjej+GfBx+H7DfpTNf\nnu37hviPHZ/H3YuGIgI4/3we4NbibTrlo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ80QB7\ncls5/BkWttGMQjsO+FqgrjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhALkEhHGaNL1jnXQgaJp4vzRCXMFIPGHmWxXc\nQ/k8GIiZAiA655pZHzGGwrOmKe2MxmfPit3HwfmALYU0JHvS0I1opQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2065", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2065` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAX3OPm2stzb74LmrUa0y6gi/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2Nzc3MTBlLWY2YTQtNDJjMy05YjFiLWU3ZDNiNmJiZTBkNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWE3YTUwMmEtMDcy\nZC00NDBkLTg4NjctMzdiZThmYzdmYjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX9Y+4c5GFQW00D6IWXPx/FH1nxAJXb2m4VnS4K9O6kVoVIi0Ztod1VjwrHBR\nRvxZpmlmJDxEL0nfZ4OEZLLtg6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMblev6krqN9NSTrDr33vaDoBBNUwHwYDVR0j\nBBgwFoAUTFSpwazf04+5CCJCkahGPt7QlikwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBq\nbtZaUgkZOxgIntEvLahV6UZ++FTG/3ZK50rlYBH/swIhAJZV4NsjLuwk5gwPAyhP\nK1AuFkL79ZTzzHmn6Xn5hscm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYejU74nT0UUspDyr+qpaBb3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjc3NzEwZS1mNmE0LTQyYzMtOWIxYi1lN2QzYjZiYmUwZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCzlOj0AUi9/fLW3Y9yyrLSiOVxY96XS7+yPGws6n0w7Mq\no/LLegiNX4ZB97eY1IAGOvBSEYb8ldgXhHDEQuJLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTFSpwazf04+5CCJCkahGPt7Q\nlikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgO1OjKorlL7/SXL7t69g5fm+4E1pIzH2XAjjW7OlvuCQCIDAtEyrUn57V\ns5V0mb8mWLJoell1u9WcPZHfnWSHpefh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAcoTKGHmoI3g+kn1sbSlDOP3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWE3YTUwMmEtMDcyZC00NDBkLTg4NjctMzdiZThmYzdmYjJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YWM1ODUy\nMC1mMTA2LTQyZjctOTdiZC0zYjViZjNlNDQyZTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQlV2P02UZy6+7Ueb3xPkEx41nyVoFakZRIZfEPviLHcb6OhI5U41WH\ngl3Gpv4MICJSylFpLWwNxcGMncI2oJ7io3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQxuV6/\nqSuo301JOsOvfe9oOgEE1TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPkI/iPckn7Q1TRptidx/RtyMj7Lj5tPTWue\nmc+KBnZEAiBOXS2SacViU3EkEMdhvSM2hJbzCy+hgYK2osEYLUH6aA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2066", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2066` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAUBpskFkETdZw87dKJgIwBV+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2ZTZiMzZlLTgwMWQtNDU1My1iYjMyLTU5ZjQ3MWFhOTc1ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRkYjk1MWEtODYw\nZC00Y2FkLWEzMWMtMzczZDk0ZGJiNjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi3VI/GRdZd/o1Smw34USlOd+doj9JlD4NKIQvdXmMg85+HhsAX4kAlZVfLlA\n1kAPXbvHhBu8SQJH9jV+Bbn0aKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqamK+O5MPYOSvGqATRnp5h/fZSYwHwYDVR0j\nBBgwFoAUG7agSQ2k281sM9Nxm0BNDzgliwIwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAVv7+jx94Y58Z0ix45EYR7UnPw0qUQjN4GbZ5fCXxuCwIgCmN+\nQzbrzzgqz+S5KkiDj3sENl2LG+oN9w8d8Ov1oNs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZimoF1d7At3DyKOyHtR8vqaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNmU2YjM2ZS04MDFkLTQ1NTMtYmIzMi01OWY0NzFhYTk3NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPuGCUKpJNWfpBLan48skhwybeVwugWXFNs++er06k0RYl\n0y5Ygt3xnw5S/TNLeh7mrQAKNwrrUM20E+FJ2AtJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG7agSQ2k281sM9Nxm0BNDzgl\niwIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMsq7jUZi6cjUNnIxYnWxtSqerC8gHsbI1eHoCpSZSrBAiEA8T64e7sl\nFnkgxAHYHQrnfeWvdSf+ZRnNzobFSGPrM80=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAbg7VoEmn8/xq5dtwfHpDztHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRkYjk1MWEtODYwZC00Y2FkLWEzMWMtMzczZDk0ZGJiNjJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMjlmMTRj\nNi1lMjZjLTQ0NmEtOWI5Ni0yNzBhZDJhZjgzMDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS2iBjX0fmZDiZ+R54hGWdMwItJgvOXqwQ/TI14/DmD6mHirMQn0ZAe\npVQ0EgvJxG5Bf6Pw+Pcvy4MGaGI6KIUqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSpqYr4\n7kw9g5K8aoBNGenmH99lJjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAMpGAUWAAXQXn2FXwrs+dwoL8OJlKTZObXGK\np87iv+jTAiEAsAMRBd834PhFMn06ta6WbNd0ohyRgsz8wPKsDIaeRSo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2067", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2067` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAY3oyl/W05SudBtoM9k7aK+ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2YzM2MGNiLWQ2ZmQtNDY1MC05NDVkLTg3YTVkMDVhMWJmMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY2MzllYjYtYTM1\nOS00ODI1LTk4YmQtYWYwYjg5OGUyMjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfVrXleG76BRPbmTwhw3w0Y9/WtbcL8pCRRfTjY1oWaPnC6QOl4NzDyjs3Vx4\n9IvWgV+6GEuN67PGDhG9mTHABqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlieGWWw9Ts7dqmRaXUHEfUMBjiswHwYDVR0j\nBBgwFoAUZhOH+/PJLjwDr/zb7adEcB6sVEEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiAiRGwdPBzgtzHUadMzSE8BmexsYUnt34yIJbKOTrZJ2AIgbWTN\n+WKhs02aBoUIdmvlWXj/w+oFxRRaAYFnckZ4rEQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeEZG2booKjLj0lRJfFmDglIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmMzNjBjYi1kNmZkLTQ2NTAtOTQ1ZC04N2E1ZDA1YTFiZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOt4kSYhhJ3ssHgmvzH90I6lp8a7B91Cy3eIBCmz2R3U65\nFIOxPBqDhA7c6Yvi9E57Av6R/SxA4yWyYS+h3wmpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZhOH+/PJLjwDr/zb7adEcB6s\nVEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKKEef944zMDF6wi8oqVddgZicVLo3L6paQ9WDeRi2TiAiAbEMlcDI0f\nfUILLQcOT0sroqcMKqDd+k3mLBZKNOmZew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAU8Ajo1ZmqEDqSNzVKo3kJMvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY2MzllYjYtYTM1OS00ODI1LTk4YmQtYWYwYjg5OGUyMjAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YmU1OWNh\nZC0wOGFlLTQ2ZTItODA3Yy1lMmYzNzI4YmQ5ZTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARCnNJQULUdf8ywE/71dz7DB9CJCs/bERQ+X9IutComt3NA+PH8LH5C\nIRWAtEkmkqIWp2k8idHajlpa/YR4PXOjo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSWJ4ZZ\nbD1Ozt2qZFpdQcR9QwGOKzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgA15Kc0e/8qKd6v3InheqHxoB/gC4BoOxsmb+\n80mcaoQCIHEuXGj/UTvhOob0j8Y2lZsVcQjLX5/ot+Od2+W0qN8W\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2068", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2068` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAXdaqSCUxFn+1q+qHYzjDMDhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxMDE4Zjg2LTliODQtNDdhNS1iYzYxLWNhOWFmNTdmYThiMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFiNzQ1NTgtY2Nj\nMy00MzlmLWFmMzAtODUwYWIyMmMzNDUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9uvw+KBUVCuGZ35KeKzleYAWfEOvneTgWAYRtzJ/7l+A5mRPP1P0wu7GYBgG\ny+egS9Fj6cd+y3mYRKwi3XIB76OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx8qsYBbQKW7HSFM4nJipIFF56+4wHwYDVR0j\nBBgwFoAUz18qteBPcSxiSuG0jjmZXRiMsBgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAlkdOzJceUHvWl\nFHVE8Q/VYdtGHlDPzySxz2G7ogcEOgIgSYaRH8q53Am3dltjlnszmEmgxUStSz9l\nk5ez9RwFzxA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfvoy92gcGKOYREA95FyFTtpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTAxOGY4Ni05Yjg0LTQ3YTUtYmM2MS1jYTlhZjU3ZmE4YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAvBfK3RH3c82GvITcW5xcpXQPF5YAaOllVGDQkOiv7Fhp\nxe8ut9o2bse3z8i1VAYM8o3Tyfskr32RJIv5Byx6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz18qteBPcSxiSuG0jjmZXRiM\nsBgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgL3zDK/+iR1UqYM0ZMBO4OlU0RRVh0lessM/OsAGiL9cCIQCRqQyugpIh\nc/um4i4C974l8Oxlj4SnKBhMUhd9AKRzFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAfz3fIkuQLRbV+CdieIJfEnTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFiNzQ1NTgtY2NjMy00MzlmLWFmMzAtODUwYWIyMmMzNDUwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhM2Y2ZWY0\nMC1kNWI2LTQwZGMtYWU5Ny03ZDcyNTY5ODQ4NDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATpNfi2bnS0ieNlEx+6y69Mmh9520dHh7L6RguVrqNy3ENNOKFKlYEc\nJwqxos9yhNvbKOXnbiEjAlPMfo1go6sto3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTHyqxg\nFtApbsdIUzicmKkgUXnr7jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgXOK03DJYUfEpir8hkmpI4pgu+gpmUC7g0Jaw\nq3JOqfUCIHJ2UgbgFL3Ns/wgPvFP8o8yqP4D7ezxOIQTKVClOkwy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2069", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2069` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASLNYfYYeg9T03nHXbXvkllVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NzUwNWU4LTg1OWYtNDc3Zi1hMDBmLTI2OGIwYTY3Y2Y2ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNiMmExODMtNDY4\nMS00MGZlLWEzOTktMzY1MDRmNWM0ZmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKvwP1VIchYT8SmEOeg4MvOqOoj4SZ7ASOzaeMbjOEPWJzW5koaNMEl18BCSa\nYY3JLpurVyvWxMd/Rdst+mpkTKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4dQA4BUmsajZKla1UwVraCbAlQkwHwYDVR0j\nBBgwFoAU48hIbC+F3Ka66nk9ohHaS9uuWBIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAWf9VloZ4xakhdMCKfrMgvS6QBAteUz706mGA5hSrc1AiATV+Xyov/fMB0u\nAseZ8D/PG66xdPGsGNl7UPzpuO8hiA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATsc/0ZPeGrRF9+cqhDjUYHWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTc1MDVlOC04NTlmLTQ3N2YtYTAwZi0yNjhiMGE2N2NmNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPZKgGSQlBfRFnAqBke/Q5VSxJeMXDaPoc9UvDYIgs0Goz\nea6qZ9PIeqEFc3lrcvhoJ+1Quk5flToa9OkqtRC0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU48hIbC+F3Ka66nk9ohHaS9uu\nWBIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOWOAbppPYRskCuQfKYj3X6G+4Hmyd/9iwJJXQj6zmHMAiEAg823PtAd\ny1fUwzJo2M4GQg2NUiztAPJYhxU68hcVh14=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAcZ/T3NxGkTkLtHbaHmAw5MUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNiMmExODMtNDY4MS00MGZlLWEzOTktMzY1MDRmNWM0ZmU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZGYxZWFk\nMy1kMzI1LTQyOGUtYjgwMy1mYzZjZTE4NTE5NTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQBh3dSuXk+MmGG2NyV70WXNXDxnR7cqDgBIVG6nM4UERevBJ55txL+\nFhVgoG5fbXhM0fVW9b+Ls33pJwwFWZY9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTh1ADg\nFSaxqNkqVrVTBWtoJsCVCTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgTGuASLNHlI/Zbhd8iMiBqdybp73siC8G+3GB\noAkMFi4CIC8Dq0J1QRztmj5rRxWNZEEjG7TV5EsVw83Gyn0m9THO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2070", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2070` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAd5sxmB0d3cE75qWd5yEaXk0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjNjQ0Y2NiLTY1YWEtNGJlMC1iYmY5LWY4YjIyMDM1M2UwNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk5YTk4ZGMtNGI3\nMS00MTQ0LWIyYmMtZWMzMzFlNzA4OTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWhwd71AnAFn/ernjssDqV7zaFKgwCWEahLfsfRubRo3dOOj5LUqpSIS5AuDb\n3LialPPkvZjPNRF7BUkpP9kgwqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjslDjBO5pL8Qainamr6hOWkxhdswHwYDVR0j\nBBgwFoAUwBryQ8nZlUJO8f3K9oGCbr1W7PEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBwvIw3860zJH27sijN+lONEKi/IweZBo+iMXO3SFqsTAiEA579JKS387oDd\nTAqKpLUQdplgtxdufQZWiPMo5kKD0DM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVf2N4GHu7j/N1gLUHwUIJRQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzY0NGNjYi02NWFhLTRiZTAtYmJmOS1mOGIyMjAzNTNlMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5b+ZCIOQoXmAWwwt6AFjUG/hUBjmF4gz6o12mTEJEFaww\nfrsOBc7IfMNbxOQtnIA0A/4+yzSdYTZPMl6RQ39jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwBryQ8nZlUJO8f3K9oGCbr1W\n7PEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVPrORM1D9RobWdI5F4sNzoQgZ5c09W7eKbHC//a2qIgCIQCbPPhoxIHa\nYvakM9W+Q13dH5+DnmBktz60NLbQnwkTyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISATt/2+olkpb6gdwJ9pZJI0jcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk5YTk4ZGMtNGI3MS00MTQ0LWIyYmMtZWMzMzFlNzA4OTIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZDJlNzdl\nYi1hMzRkLTQwZmQtYTExNS02NTJjOTk4M2RkMzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQHqyJXrD4fn2WmA4fGMQER6siec1alWLonWsp5ySs+6YQ7RSPMiNrl\n7LrkKaRmIVzMIg34h0EOWAq6QwA4renHo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSOyUOM\nE7mkvxBqKdqavqE5aTGF2zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPdSsr/Cs0GeWUbA0/KC6sqMMRJ7/zjJEfqy\nDZYFhITiAiANfkLw9SzTBNnY5bkTgPP//ZOro8HEI4KIWMalaZmlkw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2071", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2071` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAVby5DgEiImBdrDX3020shF1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwYzNiNDYwLTU0NzgtNGE3NC1iZTNkLWUxMmYxZjUxYjMwNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDIzOGM0NjQtZDcy\nNC00ZGRmLTk4YjMtMGI5MjM4YmZhNzJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZVN9d5f4BUQVAvbI27uiI8TyimyL5RF/Gs8ZEFrML3tXI8z9cQwrs9f5yIh1\nrVBGVCZkCLWwyxIGrTW47Dq7vKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrK+MbdLoNm8vawCx1WcyJmkVQxYwHwYDVR0j\nBBgwFoAU+oOdFZzqj35nh4ub1LwtFf1ALDswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA049rryVfefnDP2ZboUN9XPFf8D72c21z22tv1N8/u/MCIQCfXG4GnXyw\nXHDxtJxlT1xchFOqVtGX/WcfYVf49DoggQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASzvVk8WmYGoUFnPArU38yf9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGMzYjQ2MC01NDc4LTRhNzQtYmUzZC1lMTJmMWY1MWIzMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzOBD4Jdzb/jNR/Qdp8rE3PCNl7uVcoJqbFEls/T2nD9Zq\nBQ3ua90a/H+XaSE5d0diA5KlL7iNbBdefwEOkGLPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+oOdFZzqj35nh4ub1LwtFf1A\nLDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJV1b+kqOviHEXGdA0fI7AARqZHTuQ4kSVgoLOFN8p3XAiEA/iDEZ2hI\nuEPvdT94dpW8lJXem5B/dgRBJhk+9E36elU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAV0c8AvcNK8ubzyePrIW6F9/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDIzOGM0NjQtZDcyNC00ZGRmLTk4YjMtMGI5MjM4YmZhNzJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMzc2NDI5\nMS1lY2U3LTQ1YjYtYTRjOS1kNWFjMDFlNDhiZGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATapMjRISAkRBbYQ6AwKimX1gmRzTNN3XfLSXo2o46BGbaoI8irkr0D\nS2O+VeprxQ5zj1yb+D3jYi/1JgDzNMAbo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSsr4xt\n0ug2by9rALHVZzImaRVDFjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAO3jjdhYS4r5IrSJ5uxxv3ZE+RHlwMx1RV3a\nXaiHtLXwAiBguZmAPZjAqe2xl5SLysRX3Oj0Mpi+bG1ILfhyTAykDQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2072", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2072` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZwLOHpXMtUINKcbLTTZ0TQOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ZTFjNWEzLTJmZGEtNDJhYy05YTM3LTE2MTFhNDcyYTcyMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA5M2YzMzYtMWI4\nYi00Y2E3LWJkNmEtODkxMmQxNmVkYzU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU2rb2nXZtGTnFaN7+RdJFtP6k3fyFE+LlJFWJZvxRpcn1EMhA0T1ZgEAhQXo\ncZvu9n9E1rMt5ch+dlg+pmXNh6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN8053/ecqe5vC7hgCgbe16zIm+YwHwYDVR0j\nBBgwFoAUiiH97zEvW9mQylYPu03q/sG0TMowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA/jl8Z5sp7MEBGfiOsh1SoP5AUxhcVYGm7U/1y/9N\nM+wCIFsB9H7dlJEhQKycBgCE4Su1z3PQki5SXDTnWiaR2VPl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXteDrwkmr1o/gs6TL0jGzq+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGUxYzVhMy0yZmRhLTQyYWMtOWEzNy0xNjExYTQ3MmE3MjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4Lt/lHjBzSCoBPqry8nzhzn6gS58BTq9SydiiXejodO6v\nGDUrKK/twQqcOcBRX0brpa+K4WHCCLY/+X4yuoFco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiiH97zEvW9mQylYPu03q/sG0\nTMowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKgzzq9bjCRIv7/rbG8ITuU5JuYeUZbWbxH0oZQmQjgnAiEAvCLdSVb6\npdOgz6TlYI5lgQ+nNO9PogqgiZJtX2GtWsk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAYcCZxjj9V6Z8XfnfXrs6cABMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA5M2YzMzYtMWI4Yi00Y2E3LWJkNmEtODkxMmQxNmVkYzU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZmU1Yjgw\nOC05YmZiLTRjMDMtYjE2NS1jZDY4ZjIyOGMwMGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQncW/LKdVoZ9VnsA5tOKdx8ysHiTyT3MTbkgB0+/Wt9QlRmTpT2F1P\nP/xutOYuGuhvzhv84Vtisy2CWRdthdtMo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3zTnf\n95yp7m8LuGAKBt7XrMib5jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgbrY9Lp76Pdmz1a1Dr5EWT/gi7UvCWct6xedr\nBWXng0sCIC440TdsIiNkEuNLds/5/PU5kKww3DFuu8pcOVND16Qh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2073", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2073` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAaQKeWWQUAopiQS3A3iRTVaOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4YjQ5NmQwLTEwZjEtNDhkOS04ZmJkLTEwYWY0ZGViMjU2ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2QzOWE5MTctNGYy\nMi00NmFkLWE2NjUtNmVhZDgxM2JmMzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2r4jvlq/UZROGnUb0QTxezTQNohV11hDY5TRyTRqkpDz2rlx/Tk2RBKBqhi1\nU1Br4MnCM3ffKeQkP5jalEtU6KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH7zr5bbonkZSr11OzdG6bxxKGKIwHwYDVR0j\nBBgwFoAU0AKv3iTGXU2fM5+dxbcCJKkM5HgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA04tqRtnlCOmJA7n/Trb3XFUmHM2Zr5d0xXGCEV0o\nn6UCIE4YX0EN1q2SIdMpRyic3eEz3FTo8pgFGxsVkNeAWZMH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASuiF7b30gtNt+yw2uiMJIGWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOGI0OTZkMC0xMGYxLTQ4ZDktOGZiZC0xMGFmNGRlYjI1NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtu0zB+t4a6/0/qRZwwu0n4wm7U43LmN/FEyMD3rRoCtnY\nLN3kI8CRldaIwLmmYTrz27cf64T5xF7Z7WZvGTE6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0AKv3iTGXU2fM5+dxbcCJKkM\n5HgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgID5DkynY4oXvNvv/GiaSjc5S+RnTC0pgPu/ohyVBXFcCIFkJF1v1oNhU\nf8PiPh2M5Des7AWW2qpJer0McV06Y+fE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAVSq0znMI5OE4V8UnCkTAxwfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2QzOWE5MTctNGYyMi00NmFkLWE2NjUtNmVhZDgxM2JmMzNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZjdhZDRh\nYy0wMDljLTQ5MTMtODkzOC03MzI0NTk4ZDA4MzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR+jwSNKzw6w4PLaTaZFEmmx7qS+eQCQhtmQCg8nMaSOT2vJA0rUKdR\nnatF8WV8A9NpFxSg23Q+AoYX50HHBGIko3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQfvOvl\ntuieRlKvXU7N0bpvHEoYojAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgTkOVjvuElbv4qowtcvH5jkcD1U3ZUr/h/5gm\n6xj5gt4CIAStV11lNYb3gVJRJQgM/u6HZqK51CBuVBV/omrK/C0t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2074", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2074` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAfsbJ22aY4UrXwHfXem3mQQ9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjZDk1NDcxLWZjNmUtNGYyZC05NTg2LTM3MjZlODk2ODAwYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGUwMjQ1ZWYtNTI3\nYi00ZDdjLTlkNzMtOWVhZTg0YjY3NjE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn3bZWS2ePC/cTRVIzrvFeGL0KbQFTCvR/vRKGzMh1E5e/rmbLAjRMf1lnI3z\ndv7fb/PBH0HgyDEfBEy+fRBgcaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo8dVmEAutFPuAxQiKN2uHdqRCsowHwYDVR0j\nBBgwFoAUFndZVsszDglU5WWCbqPksZAdCTEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA6WXm4zM0xrrXfw9FFp0H10kgZaQtrSieIW9iaH/kHyECID04\n3rj4clxDK8dWgYPixCja82SPDYx9jKsGEDuQ0IHk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZZJSyyNjRu2Zk7iEKCgQK64MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2Q5NTQ3MS1mYzZlLTRmMmQtOTU4Ni0zNzI2ZTg5NjgwMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPlHdf8xotUEnEIRE/uM9/2koScM9PjTgx3A6BJgS/GHjF\n28nMq0Hd9OTeZTnvLWbrpuCUBb8AjxCc5+1Sn8mNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFndZVsszDglU5WWCbqPksZAd\nCTEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDZb+o3QNuPcn5bEerjw2zmHp9zB/KXxSPu8K9amde5UCIQDxdMpgOyfo\nm9hgw5DfRG+geNcDFaY9mJ/7IvLfedantQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAangAXCcPfdKhwgE5UUDiJhwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGUwMjQ1ZWYtNTI3Yi00ZDdjLTlkNzMtOWVhZTg0YjY3NjE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNzg1YWNi\nZS0xYThmLTQ2YjQtYmI2OS1hZGUwMmZhMzJmY2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQp4G8pFySIYfZm5TEEqNPfPr+mXJMtTdd1tXKrG0Ef1eurDm0kWVZ8\nBP5BRPnbI0km1U2ARwZtmQHIX4eBxdwno3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSjx1WY\nQC60U+4DFCIo3a4d2pEKyjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOvW5kDm/AYid8I30fVU/K513/yyN/FcLRyT\nm1dT6z5WAiBBgJY6UbAjgu3OpAjIla07jaLdENBaAT8JZE435JckzQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2075", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2075` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASgFK45SD+GtAsk2uCCzAcAkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxNWFmYzBjLWNmYjMtNGM1Yy1hMzJmLThkM2FmNzlmMDNkYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzYwYWNlMmMtNDRh\nOC00NGE1LTk4YTEtMWRlYjg2MzJjYjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELxqFdiNbq37F/5XITCikNyhLv0nJlaSfnsDVlttUD8eVUDO6i1MgdAisoXQ2\nkxVgevTgW/vZOMYwoiualpzQE6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdyLwmYPuw+Xqflfho8ZFoYim+74wHwYDVR0j\nBBgwFoAUL3vZYoFxd6bmaNF3dmc7hYQSLqgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAzHfUScnS3y4OKB9aqdCt+E37ykJDZg6b\nYJ10OGErOQQCIAkkbl4pESEwm7AS99HP6iCK0ytnuSrP/CaNIXbSCl0y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdbJ/vGSvSjMsJ9A3imukUOiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTVhZmMwYy1jZmIzLTRjNWMtYTMyZi04ZDNhZjc5ZjAzZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0Oozz6bNuiPSlcRPCASjKI5hXN86z2PkbvRr71yx1pvIl\n7HmMdvI2IHbcUl2j4IeW5xPs5seT2ty5LppPJG3qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL3vZYoFxd6bmaNF3dmc7hYQS\nLqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDfd8Oc07LnFQH3Wd9VZ+7NkB8B/EirYhkkRKV0bEKC4CIGUsi9JPuNsG\nbQ/UIOxGzk4FjdunA2VDcUeuQ+ztTgl9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAbb2ugp+fonNOUH0UjxGhiA2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzYwYWNlMmMtNDRhOC00NGE1LTk4YTEtMWRlYjg2MzJjYjNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZjMxOTJk\nYy01OWEzLTRjMjEtOGYyOS01NGIyY2Q3ZDU4ZGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAShFPtEcuWcKAUv0lWvX/Z0IP+NxJbW3yH8RDT3UObLpJy1N1Yk+D3D\n0NXbGvtITmA9JVb6t+GI6nvRKQu6jzyPo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR3IvCZ\ng+7D5ep+V+GjxkWhiKb7vjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgJoPr2pIuXJ46sauLRGKZ9jbFB2ROp8EiFKJ+\nm8J8iswCIF0aU0zPsV5MTujVp9YgsH7PFjRHNn1iAPdqHhUF6T0n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2076", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2076` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAR+4ejGxv43x4SIq+s7p+oEMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5MDRjZjQ4LTViZDktNDY2Zi1hMTQ5LWU1NDdlMjgyOWIwMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRhYjc3ZTMtNjRm\nYi00ZTQ0LWJhMjYtNWQyYmNmNmYzZWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/ggsQbb/N9eEeGH0BmzQlxxtZtQGrMycVubxiG/NPtcF9GKf3PGVKqHXaT4m\niJmZYutNvBXaPtREEuTMgRrlHKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPgsrZDYDGLxtDzRZikKPR3k1UBQwHwYDVR0j\nBBgwFoAUfFVGSX49FotPKBGQKPQY5LQQRvEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAod8f5sh8oEj4L9y9z7uuB6vfiL0RqMI7\nrvVjGIf5UJECIQC58KUNqzRobjJ+gmY2bUkapaB4WBUAbXfGNbA6u9l1AA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZbY/G8afkJjte0TlMGKhMvVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTA0Y2Y0OC01YmQ5LTQ2NmYtYTE0OS1lNTQ3ZTI4MjliMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdOAMPJM1KzV048ptoyiyh/WKDouG9Toyrww1vU26A4kNM\nKEIX9Zd2MdYbAyKPRd3dqIckRyF94UVsgY1Xt+53o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfFVGSX49FotPKBGQKPQY5LQQ\nRvEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI+rUXIBc4RfLzNNrL7sEWtuMgT8FTNqgFFWIsUEhlMxAiB63D6JBs8a\nndrlT9tM33sxUvMv9M1BYrEMVmBDBZ8ENw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAR/KdcTrHkFWY6sBS6DuPq8uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRhYjc3ZTMtNjRmYi00ZTQ0LWJhMjYtNWQyYmNmNmYzZWNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmN2NiYjE1\nZS1kNDExLTQ2MjYtOTA0NC1iNzhiNzc2ZDE0NmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQgabRfyhaPVSoJDriVpDcL0O9gU6XBG42DlRB7ykZXVqJg0YCdscL0\nvDplY475V51uBUBaOhhNRMxltVhokdE4o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ+Cytk\nNgMYvG0PNFmKQo9HeTVQFDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOa4IhqS+1OQ8Q51c1NfCiMijVcdPjrdjri5\nz/s5c7QgAiEAurhgWe/cf6i/adYzVzjAVZcLgtvHKM8daDgpgnP6XKg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2077", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2077` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAc4qH958L+dsqtp7zcg0TgSQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyN2FlYWYxLWIwODUtNDk2My04MzgzLTYwNjdiZTgyZTY1YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZjYWZmNzgtMTI5\nYy00ZWNlLWE5OGMtZjRiN2JkOWQzMGMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDVqIn+cPd8IvBVuyDQXVDgQ6HuQW65R+hXFdFMeAXoZvMjI8aErqBuj7RFC7\n3gdvnjdDDvNvs6iZmZyjcVyshaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPxXxP4bXwiW7xZaJOvoahWpAvzgwHwYDVR0j\nBBgwFoAULK3jjG+QKbGXWyVDDIJSSjmRlJgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAiVSTU7sadOFDI\ngACKR0JNLpL/Myk3+FGWiygOZHTu7AIhAKw3pa9r35hB7GMfu9dxJhEXGHgJmfjQ\nOzHFoMeDRkd1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR2DaTABpNQ97MfGGtNW7+x2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjdhZWFmMS1iMDg1LTQ5NjMtODM4My02MDY3YmU4MmU2NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHn9i5/QN99w28YSpIrdfNz2tbki6xMZJk2Bbdwdp+ccAT\nFyC9VRsgDGUdmJMmTmxlYIsH+hh3aMnD8oavJIFno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULK3jjG+QKbGXWyVDDIJSSjmR\nlJgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHBakbePmHLVmc5UxxlpjpeSrYqkByye5r8+Jk6B9GgoCIQDCegMUVmEn\nLR1qmWPMcUoES6L1amucrU4LapGvufQ0GQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAX8tJtjVMv0IJ15gpRpDO6afMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZjYWZmNzgtMTI5Yy00ZWNlLWE5OGMtZjRiN2JkOWQzMGMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYTM5MWM4\nMi01MDViLTQyZTgtYWZjNC0zYjE4YmY0MTI1ZmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARu6/BWnyxTZreIp7oect+a2cXwkAcPEn/37ArI5Ufnq9JjWmRTap8o\ncbXEQ6BVmWNiSqCZMlEEzqqN5QcMDIQBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ/FfE/\nhtfCJbvFlok6+hqFakC/ODAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgUs/Zq/4XMje7gsykC4ej1F6+oIDsFRT1BZiH\nhQg9dEcCIQC2LDxTpofXuou+Ppgk/YjcY/XkG61tovL6UK/fE1GLdg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2078", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2078` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAW3NWFguNQs8X46M1PUl7PrJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0OGJjNjg1LWU2YTYtNGFiMS05ZmNmLWMzNGJiNmM2ZWM5ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRlMzQxMzYtNmE5\nYy00YTZiLTg5MjQtNTQ0YWJkOWU2NTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiEHri6QhLtEASXJDQo0k8zNG6/gPyuw9v5ZEa6jNDJJ89hg/w0tpFogSKUrh\nC9M/JRzKbGim81IDHRQu5QfRUqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY/LVvQ/gyG/7esddc1ySTuy/dJAwHwYDVR0j\nBBgwFoAUUo1aRqwwzfEs420Ce8ZQE1kt96QwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDUHYZn1o139ZzNH2KFQ7aHPFQbVPvLvGlImCQa+RdipAiEAmMX0TMelhBB0\noIHTkOs9iVoxyWtjYRq8CugovXJ3REQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQVYV9RvvavKe8AIwRy+uRkCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDhiYzY4NS1lNmE2LTRhYjEtOWZjZi1jMzRiYjZjNmVjOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxrP5gob1kfvbavnoxApFsbdzA73rNVdVxXHNIukgQ/nCj\n5t6MYEWhr+qKildS/TT/pzGbi3KzHM7LEHOMAjH6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUo1aRqwwzfEs420Ce8ZQE1kt\n96QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP+cCVlZqojib5MkZWeg8LzgcTKkErQZEslml1mNd+GkAiEA9nsL7T48\nQUD1PBUA3kS1urMS703mDzbbBU7+BzVfgjs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAdMfuqmKpMmYFYoQWajeXDetMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRlMzQxMzYtNmE5Yy00YTZiLTg5MjQtNTQ0YWJkOWU2NTRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYzU3MzUw\nOC1lMzA2LTRiMWItYWEzYi0wOGRhNTRmYmIwYmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASmj3AacmxQJ6ptH1oNoYIj2bKWA2MdKJqKnGJ3J7Gf89rE1IVEugSr\ntym9l6N3kL2MYRfep9jHQSjIAKM3Tesuo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRj8tW9\nD+DIb/t6x11zXJJO7L90kDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJLpnLdC33X07hX32OQxDmtkJ6QeTJvsYzvW\nnx/NsVcaAiEAgB2za4pZ7JEXE4yqcUqbEmeiqxoJNllZinZbN30OJRM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2079", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2079` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAU2OXi0yM+DtgHwmTH5qb8UdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxMDkyMzQxLTg4ODQtNDQ5ZC1hYWYzLWZjNjdmZjAxYTM0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTE0ZjFiNGItMzVm\nOS00NDBkLWFmYWUtMWVmYWFiZmYwZTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOihYIEYn6/2X9Fx48xLTrJz4W7GYVMpkTgWQ8sSCACdeua2ZxXV8clAFDsf8\nbaDRv/Hey8tuFDBhyB5vEhikoKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsa2/jztiVHbGawuW7e/Hwc+hifEwHwYDVR0j\nBBgwFoAU/KYM7s/2SIhIhHINKLDDrfMNY9kwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDqVxXBQeRVQgWA49mi8NFj96OSo49cVzPxhF2dIf/80AIhAK0EVqnKhcld\ncu3pSBBL9o5Hrno7qAsrpUTRoXDon6zo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcmReyCgWOg95GaXpDG7z+MnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTA5MjM0MS04ODg0LTQ0OWQtYWFmMy1mYzY3ZmYwMWEzNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbMS+F32jByAWtBCjZ8PvEeONi+TRj6llN31AQjjUwp8j8\nLN880AYpl9amm5V9TF6pBLbsdLGLVcAwshzLWQr8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/KYM7s/2SIhIhHINKLDDrfMN\nY9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcsoXt3WoFx9j/i5TxSm3g0/18xJKEJGVla1Amg50E/kCIQCaVEmdydB/\nj5g+rLnPXpoNND632IjnosYeKXHz2o4nBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISARp9vcv/NkehETU1lwAkPOZWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTE0ZjFiNGItMzVmOS00NDBkLWFmYWUtMWVmYWFiZmYwZTgyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ZTMxMDI3\nMi00ZjQ2LTQ0YWYtODhjNi0zOTMxMTA3NjJkOTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9Is3yQQJGXlBpJgcchHLemtmyNUy8b4soJt4Ejz0p33/abDQHPL1M\nLmqVrS/VGep5gNsDt7JHhSlXlq7+C0/1o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSxrb+P\nO2JUdsZrC5bt78fBz6GJ8TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgIt2h6aMdkHUZp1iMABjIQ41Jwz244E7QmDeu\nJf1qb+QCIQDSzcPuTRtxad/d0wVlPR6dqQrvqUQ0mXjcUCDsDfm+JA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2080", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2080` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfqgAwIBAgISAQvLOvdQ5y9CB1I6mhVkURlZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxZTBjOGU2LTI1MzktNGJhNS1hNDcyLTBjMWEwNTc1NDUxNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRiOWM4ZjEtZmM0\nZi00MzJkLThmZWYtNjU3YzIwZTNhZGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoKj8SHWKhqGhb9SUgVFZDN0b+uUulY+NIWW4VXv3swKszkP+j/eIyOBzbCTO\nLMXSs+rmFEwMY7ixRe/DyR9OoKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURsTyX4P4fkXgd/dpaL3xt5vuh74wHwYDVR0j\nBBgwFoAUNNAPJeCZ40UzmQRmU+wvnO3BEN8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNG\nADBDAiADpjN91mv09qzC562XgG5Hp6eBS/HzZj6yarybUuDnDAIfaX5GOWML8lmV\nSPlMsrA0seytmsuOKMlAHwHo2PC6tA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWj62ucXUZIvrr+6EmxkvZ3/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWUwYzhlNi0yNTM5LTRiYTUtYTQ3Mi0wYzFhMDU3NTQ1MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgU5olz9xtHKY+RPyWXoVaTG+KVD9K9CCk926i1Z1abv8x\n+gr+pRNSNBYIZ9K8fWqOnMIObsv/eLW/1NOgF1iHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNNAPJeCZ40UzmQRmU+wvnO3B\nEN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOZPAt7tRinBTyq1ro/TadgjrtGREGur5qt5cQe0yMVyAiEApwgp631l\nAw3ZzPKYadLPXbaa/XeVwAq5g/MOybSFG+c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAcgPCqibzVv96YBo3+1bjeJnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRiOWM4ZjEtZmM0Zi00MzJkLThmZWYtNjU3YzIwZTNhZGMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZjRjMWM5\nOC02MjYzLTRjNTgtOGU1ZS1hYTM2YjlmZDA0YjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARjR19PRyIrSRIp5gVJT3SEMcVmIhn7CNNF3cHoGCV/JF0WR7dYiGrv\n6Legu/pQYlXfs4CEAXENdsGO2AjrI9Hko3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGxPJf\ng/h+ReB392lovfG3m+6HvjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgGWuWww3il+tj4rvLbfRxrvApMqTbNQBp0P94\nuVkwU0ACIGg4NvUWHbN9AtoxkH6D71JoYQ8ML4Qzbz7e8zkYt6PW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2081", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2081` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAesKRbpm12CqdonAHCFlw93+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4OTk4YjExLTMxZmUtNGE5ZS1hOTE3LTM1M2Y0ZDIzOTllMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQzMWU4YWEtNzRi\nNy00ZjBlLWJkMTUtZTA1MzgzNWE0YWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwAGAa/gj2wLfwjxpPy0N6tiQoorjAM0yOq946Ri29bbsUel2UFQ8cVIVinte\nLY96OJE8TcVASsHxsb/fYWNA0aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8cn0OFC6iZLdJbx2eO4JwKfdMhgwHwYDVR0j\nBBgwFoAUpICneJldpZNZWOh/bCBdQQffylwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEApTrNV8oQjkqs1RZ4iBhvFiz2kz0r7vZ8fIQYCJD1\ntZICIBY1bfG0JcULuFsBr4rikeAqwc16NujUA3daaYllnG4m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYp2WYFrXiD5H6AcV6ljCUZfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODk5OGIxMS0zMWZlLTRhOWUtYTkxNy0zNTNmNGQyMzk5ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8pQnPK5lQDc8+D0F64mm0yBRMKB/5urqeLJV0GbKopKYD\nxyvAlMS3zEBiwEfpj7YKD7/7Tt1627LaVISe2UmYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpICneJldpZNZWOh/bCBdQQff\nylwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCGbyCNqBwMeLQ1ElTLhbqsRu9/9zvToQeX7mp9vi74ACIQDsLZPKTWlH\nx4FHNrZxWdQYJ64wL2wEICPI7ZSce5dkyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISATyl0UH8NfL2+C1FK2so2365MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQzMWU4YWEtNzRiNy00ZjBlLWJkMTUtZTA1MzgzNWE0YWFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZTBlYzU3\nYy0yZTc5LTQyZTAtYjk2Yy1jZGM4Y2I1Y2YzNmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASkoNz5vtM3l1FooqirmchmTrVMAc20IqqpeObtO87U7qVA73ES0WQ3\nFJ1Pnl+1vJ2l6Z6MId0Tz8ouzeMt2pg4o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTxyfQ4\nULqJkt0lvHZ47gnAp90yGDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKbjVujx9Py5WfiyrHHiWMM3MaEXYZJ2aEZI\nylYlTXziAiEA3Dl60Y8sESTXl/EQl8EF1IRvoLTeioY48l++1tamjPk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2082", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2082` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISActAHnp+xVKvb0qAds9xmD6wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MjgxZWExLTM5MjUtNDMzYS1hMGQ5LWNjODliNTE2NTM4MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRlYzQ4OTQtYTYw\nZi00ODg2LThiZDItOGI1NDliNzYxZjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2qOJgnsMwtaUbmNf8TlU2M3m2ta/HXJb5AVB/qcpX+swCYccTtBsxoL4qeHr\nGnKsI6lgL1f5NH1sIyvdrZWzUqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEl/sxz1ibRKyJQXky/I5em9Z6nEwHwYDVR0j\nBBgwFoAUgVuNSDAG0jJiy5mYRCmHjBS+DtIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiA3lNlexen8FiKm0l5YjNafEzPI/YJ6k1EBb5NB5qSD\n0QIhAOxTXlMTmbReEKH0qwxB6Ap6wfM6+TWlsx/3EuMteLV6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb4wu6MlHzNHIJAxz195IvR6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTI4MWVhMS0zOTI1LTQzM2EtYTBkOS1jYzg5YjUxNjUzODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATheg4Vi8l2wYTfR5s0thkft6PZ78KT2d+MD9lXaUl7/1sG\n7QUj67x69ip5pbz8aY/bZ2xVv4TUfR5UEahMFizLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgVuNSDAG0jJiy5mYRCmHjBS+\nDtIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO4ED6OCbATIIZbfwpp52d2T3rThB7Xd3CWPvbhHlsTmAiEAyJyEAtKp\nUXTs3fYF+VaYglnCOssea20ljO4+cWLrqII=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISASbdcxQmyj5MNHUWJ3jEBjHWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRlYzQ4OTQtYTYwZi00ODg2LThiZDItOGI1NDliNzYxZjU5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYmI0ZDYy\nNi00OGVmLTRjYTctYTdjMS1lY2QwMGRmNGQxZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQQGUrdo8JsOVcCRzDbGiJdR0alwwrw6ojCGMQKd4nnmN5upccvunuS\niabAgKNnRUc8Y3/HHXFG7qMhwlc2fXj3o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQSX+zH\nPWJtErIlBeTL8jl6b1nqcTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOEmrtZkwlzpyOZkvMZj/qLTKqmzRSQFk6z6\nQkcb3mHEAiACGV8iZiTy5SCCPCpCqFm2PWA742RbfOeLP4nhuLMLgA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2083", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2083` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAZnDd4islVLxHcfFhHAqmZFnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzZGMzYTY5LTg0MTktNDk2OC1iNjk5LWZkZjRkM2U0MjdkZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IyZTkxYTgtYWY4\nNy00MmQ2LWE1NTItOWI1MmM1YThhNGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX9Ogfspv3B8pLApMmClyU3oCXbq1ZwbvogJFZzkMbhngp4v47Ubvea2W3yXc\nin0rgbby8FaM9vOQIYN3QI5mL6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvlNHoHyQda3jTU4SZ65c+Nfu+j8wHwYDVR0j\nBBgwFoAUNTMIoYihc3S79ZZyeKm3Ufa9QZYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBiQz6FRx/6Xha5qmZG+eCWnHAzIsi8uHh0Ogjaaz5/SgIgWzYC\nUTuB8mmhlt/AtaL+i1FUOGFE37PPXvmfmhYPg4s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWHGo09AWJUFHRuhRWH4lu24MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2RjM2E2OS04NDE5LTQ5NjgtYjY5OS1mZGY0ZDNlNDI3ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAwW9VHMbMpuHrFFzGkjxMN3vTroFB8DlXThufkPHz+mCZ\nrmxSyb8l9PN7q5bMzbiL3V38VkYFY49UaOwDfw2lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNTMIoYihc3S79ZZyeKm3Ufa9\nQZYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD5xKZBPdDB0e0Ta/G4W6xRzN5QxkZIJggprDwh3Tob4CIHPBpvY47URE\nTfvlPCQZpCVaMR5i21nIC01CFqC/SORk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAeHnrrQ6JnuJp11n0f7lCFHtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IyZTkxYTgtYWY4Ny00MmQ2LWE1NTItOWI1MmM1YThhNGI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YmUwODVh\nNy03YjhhLTRhZjgtYmU5OS04MDZjY2ZjOTM2ZmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS60cwwF0aLmTRipCOl8vU7oB/Ch30h28QTZ55gaw2sx/lr+xW0Ne1e\ngplaiDAyD0XfDmycVilZoGCxbY63ksfWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+U0eg\nfJB1reNNThJnrlz41+76PzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAMoWMEJ7m37W7aHsMs5vWtFCMxeZcrwlfrHg\nhO++VbfvAiEA2Q/aduvvIBjNSDu3YKSY8D1u6hkAbBa8LW7j0ii3Emo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2084", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2084` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISARHHlwgd9QMu/9VOCQrK5mvjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5ZjM3OWEwLTIwMmEtNGIwMi04N2FhLTExNGEwZDNhMWQwOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk0N2RhYTgtNDhj\nMC00OTM2LTg3OTAtNGNiNjYyOTkwNDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsZCF6oC6dO9mlZ8Np2VnAiizzoYxOm/pyM4MXLNRB3TeaShIo6n5XcqnuMx5\nqGuJ6o/bk+6LUQjjlJR2nvxakqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjsFtle2yNnACkXN9UPt/RiCz9AswHwYDVR0j\nBBgwFoAUhAPLrkXN2PqxnY5PuFdGg8tGTOAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAxwtEEarOHIbf86tW5kWpljNLcX8GZNFP\n28H0k4TviDECIQCnOWbfX3UOcOTRAVdK92JBVzxlocwgGP/m033dikKHBg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZr3CDT7X8HD+2k2LBflatC1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWYzNzlhMC0yMDJhLTRiMDItODdhYS0xMTRhMGQzYTFkMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7pkQ0RYm5B9glYErsTzTqekclBTU87kJm1te7dnBjEAtQ\nV3qTXf25WhavaS5YabJXs0hRTO3dWjsQ+XmmmwGwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhAPLrkXN2PqxnY5PuFdGg8tG\nTOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANWKQsqhQ33OP6oUo5nKjY0IvGdB7zz5gqkQRRZYFnDPAiEAtws4Ty/k\n/RdDWQaaLJUdUExr4koggMzG6XP3fqyYwHQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISASQV42/mptp4AWSjAvI7Vi1cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk0N2RhYTgtNDhjMC00OTM2LTg3OTAtNGNiNjYyOTkwNDk0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYzU3MzA4\nNi00ZDc5LTQwYWUtOGQ4ZC1lNmEzNDljMzY0ZTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS2OG/Q82gSAL9pLiaTxXGzM/9VUtmdhRP5Hf+Ryp0ZzAdo+XrLrjXY\nLliGV742P8OTm1TBqR7L9fCisy3bnPero3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSOwW2V\n7bI2cAKRc31Q+39GILP0CzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgRUgw5ioJWRPINuEGDTWBx8AD6pQ5QylAsv19\nP4bMTsACIQCdMXD9rc7Mau0M1uIgvktmPvfFRm0Gq5bnVYotwKYR2A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2085", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2085` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXE5JFBWKl+iLzXZoWxH/BYoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0YTVmNTYwLWE0OTYtNDkwMy1hOTdmLTRhZjkyY2UzNDc2YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGM1MTY0MjMtOWVi\nOS00ZTExLTg2ZWEtYWE2NTc2ZjUzYWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKmWpzX6V2QK8MsB8YjFW5fe5wR2fVzxsvGj/9n5avNBIVUZzQi5lvrfm++37\n+oz8J6qp+yuKJDv15WV66/7tUKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5SuwAtnaL3fWnouLHvB0HBGg0pwwHwYDVR0j\nBBgwFoAUc15eTJCd0Uirv5/M0sFHUEP4bPMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA9mwxcYF7I2fiZF5KqPYx+deRjc5FJV5c\nj9Rx1SIg9b0CIHimo+NeUR56mKkE3z9nS826G4zl/jSaNR8SgdTZvuc1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATCWIeRhjW/P+EEryS1672nLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGE1ZjU2MC1hNDk2LTQ5MDMtYTk3Zi00YWY5MmNlMzQ3NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjMaezJ74xICr6SkdwNL4eyOYkt6GO6JyY4UBK/OKKxjD+\niuXf+cGH4FGPG3MjctSipF6t+C9dzcxg70XttHQlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc15eTJCd0Uirv5/M0sFHUEP4\nbPMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhxm6Z0+HamkeYjOElLOecI5zapHP5pgeBPna3VeVakAiEAnkB+AoKx\ntHOdbBMIyJizxUlnDUaAdE7uLKfx+u8zTN4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAXkEfG+3AAZ+5gPUX5HP2Z8IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGM1MTY0MjMtOWViOS00ZTExLTg2ZWEtYWE2NTc2ZjUzYWFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNTY2Mzdm\nMy04NTA4LTRhYmUtYjFhZC1kZjRjYjhiZTQxZDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARs4bGGRT3POTq7zC990q9XGKHtnwLtf8iXRqnQ2l14UUEjcwCnrifi\n2Mxz6CX/+571qvV8oDGuWzjogKhmNdWoo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTlK7AC\n2dovd9aei4se8HQcEaDSnDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgOAdQqUzS6KV41nrezZrAIsbQunmYiPjm46rk\nFkdtl6oCIQCtSW4uZ+ixvn5EHy5/P+xCJaLsc1xPcjmuqnMVwcwpEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2086", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2086` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASY1IjEoeiA5SSa0rqEpT6aBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkZDFlNTk0LTQ3NGUtNGZlZS04OWY2LWI3Mjk0MTJjNTRjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJhYzlkZTItMmEy\nNS00YTMxLWExMDEtOTM3MmJiOTc4MDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwd5eWVhrdwtNVAGwh4zw5fVMJmSjaQEtTFaxOCDYbgnhuTFdotAb+HAiJ5Bw\n7hWPWfyckgkhlz+O+83oV5tgGaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMYQSsK0v9OkKi82JxSdtq7maE/AwHwYDVR0j\nBBgwFoAUL7QXuoNUVGPP7YUBUH/TSliubU8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBVNlAyu7/l7QbUIWR00Zf62978e\nRVVLtwXh4dbEPFZlAiEAvULMpQ7Z7WOdN1kGvVsr/v1R8duR08m13sDdB227AV0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZECJpjtGF6m4T4GD5RTB+yOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZGQxZTU5NC00NzRlLTRmZWUtODlmNi1iNzI5NDEyYzU0YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwWUul8p3Wh+b97nGDzmCSa+sHi5NDr3Omu1SFt1eoKb+5\nFiYTeCGDrUTwgyevCNiSDYJnUhx4OYD26unc7XgBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL7QXuoNUVGPP7YUBUH/TSliu\nbU8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUPfGljHwCVC7UxpEoXMEjcXeskp3UuOs2iO/E+UdyL4CIQChjJSECZbg\n/y4aPVzUoXYGcomnf8HG3l27GbiBL3gb2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWS1i2cmNxuwkjVD69XojGGRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJhYzlkZTItMmEyNS00YTMxLWExMDEtOTM3MmJiOTc4MDdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMjIzNzU0\nMy00ZDkyLTRhZjgtYmEwNS1iYmFlODk5Y2Q2NzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ3gx8pJ6KujPVOyyJRVdXnD5kZe+QzG0VOhAGgzoHtPHcHQj33Om3v\nAVFStkKktBu2cIBylDlNdY6FTbpy4v81o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQxhBKw\nrS/06QqLzYnFJ22ruZoT8DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOdIWdWQ7PCzLQiZXld0e/ADt2hkeMGqltR+\n/c0zFrhGAiBZQyB+elPuJjftBs1kHTNFKj56A/ao6mOmvSe0POgsPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2087", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2087` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAVlZs6qCM1SqHJ7ctPSrZRgwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxYTRlZTZjLTUxMTItNGIxOC05OWI0LTg1MGY3OGJjNTkzMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk2ZWQyMmMtODcz\nNy00NWJhLWEyOGYtZGRiZmQxNWQyMWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKzWwGZxXkfmBfwCUIVDHJWt+d7m/i8799ULICmO2unpyQj2JPutfHvj/anWw\nUuClYQSH0WcsI5l7VxkpZLYqxqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURsnps23eycM6SbIykg2WXLnCIZgwHwYDVR0j\nBBgwFoAUvYxEnHBu9DgFoHrnGIbPKz7kLiswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJPaT/ht\nf49ekWAY4EAYA8fnkz6+f1ZhqNhkI/5gRWnKAiEApcENgbW0vDEqmdS+OBcpb4S0\nX7cCXpXSQ669Ha8ei4c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARpH1Kx7u7qcvZSPnTL9RoQPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWE0ZWU2Yy01MTEyLTRiMTgtOTliNC04NTBmNzhiYzU5MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2p5oSshsP8i+2+3A+DHQgNoaXmzF2BMymtSQDanxFsJQO\nAXGcXqvnfXgo+gLiXyYC4xz4D+l8d3MZZiy8zDzAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvYxEnHBu9DgFoHrnGIbPKz7k\nLiswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK7qLDabXAo0WZ5tclEoj7x0OtxnQfkAkwxwDswvaKtVAiAOmkhTXuNw\nUdHxCNsNvkcBRsvYcBPpp14aIdBrfnJZAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAfsWxTE9ziOIi5k6WtOASMkcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk2ZWQyMmMtODczNy00NWJhLWEyOGYtZGRiZmQxNWQyMWE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MWQ1NTFl\nMS05NDI1LTQ5ZDgtYTMzYS1lMjdmYzhkNWM3YmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASql/uZCdLtITClBQMggC9vEDarn2tpQJV86GprEwF8S50Zqq9SpLcJ\nKqF167wD5rUxp+3Ny3eU6ur5wl+/qC/Lo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGyemz\nbd7JwzpJsjKSDZZcucIhmDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhANs+ztLUz1UZuso0DtQtGC8Sg1XyP89E19/q\n46AOeaDdAiBZNNMoF9FL5w7RjPaOEo7iegT8h9TUpBhJILWVCRuX8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2088", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2088` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAZ8rKgs4p9UFa+i3JI3/gYeeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiNzkyMmM4LWVlOWItNDU1MC04OTg2LTc2NDVkZjVlMWJjODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjIyZmIwYTMtODM2\nNC00NjVmLWI5MjQtMWQ5NDMyNjk1NTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdQlNMWv5OnltI2fnpd8K9/tRDf3apxoWYxucXdn6qvQY0jE8ol7Aj+GvMhtM\nF+F/jPyrWx/9QJyJxKtRM4/j+qOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGaOL6vGDjFan49KRJQQHyLpZhxYwHwYDVR0j\nBBgwFoAUTvjbbq4dxL8QRtPuy70GriR9O1gwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKn18nJN\n59/Tk092RcKB9/oemGBWd2PAF/0n7/taXF2WAiABpNp14QwaSk8ldbP7+AiZ9lxd\nJcLvONW71yTe4QyD+w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARTgllpxecZfk+gD2EVTeG4HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjc5MjJjOC1lZTliLTQ1NTAtODk4Ni03NjQ1ZGY1ZTFiYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3/UWgeVBGAm4k6btHpscPkDJNwNeRsYVBy+BAc0iL2zC4\nbmQ9ZfvYVV+hh7iRJwfQHhbYAAEak8DOiHNUOPfOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTvjbbq4dxL8QRtPuy70GriR9\nO1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDjwALsCZXAdajn4F9bSE8cl6amcnj89IF0v1byUV3/UCIQDHm27aJMn8\noN9swJc4gcM06jaWk2/kzeAoQTXOxnYKfA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWFHGdZNDAm2VL+E0HiHT0YpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjIyZmIwYTMtODM2NC00NjVmLWI5MjQtMWQ5NDMyNjk1NTQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhM2IxYTlh\nOS03ZWM5LTQ2MjMtODc4MS0xYTBjMDQ2MzBkZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASJgIvnwCfnMy5be3P/nBnz5xpvAybdmjWDKZ6N4oJzEsPkxSyTPKFV\nLqimMGZsCq6RGhRM2qPhsTJQSTxaqsoho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZo4vq\n8YOMVqfj0pElBAfIulmHFjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgAP7EYZ6dGVdy+Gw1oqEWLPYAi08KUgIYVSYM\n9q1/sy0CIQChYsJpCvwLJXstPniGOEJXV+q/skxSBKmiv4zraZa02A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2089", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2089` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAVOPpVBSBxHBn4Kq+KIl8AOBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlYjZjNzhhLWQyOTctNDVmOS1hNjM5LTA0N2YxNGY1NzM3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ3ZDMyN2EtODE4\nNS00NDJlLWI4NjQtODEyN2IyMjBjNmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG4VLnM532P4YjM0NriSoVB6YD1q2XrnhW+bLP5DkVytrAiSDPzebPzZ2gKi7\nNhUGebxzhT+OYOdKn1YoD29yB6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZdgFIP69s360TQUtx3uy5pFMbNEwHwYDVR0j\nBBgwFoAU1rFFZrWTC/mbcPiCNU080LGJkWAwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFdmAT7f\njv8VIOus60UtdGBsYlNV4f9Arcf8UuOdIOXpAiBAZEY+P4JVYj7JXIklgsuBpL8G\nn18SA0yA4PU1pPs5uw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbDTYcPqywm40pqNQwmZ/njuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWI2Yzc4YS1kMjk3LTQ1ZjktYTYzOS0wNDdmMTRmNTczNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEQhc8s9sk0rfX2vq+o1xxV40VYTJoXcl59iItvvcnmudp\nkUSgBBpZ9KKAwWH4sTbIX2XaWRg4dHE0WlI5In5Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1rFFZrWTC/mbcPiCNU080LGJ\nkWAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaIb//iYHAuhIxATLrYf1e/28DhVpFksUB58DLs/6vtUCIA9/cwLX/wf7\nQna0NEiLcJ7KnlzQIcRbv8vnO7LEY8eZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAX+M34T55v7yACUZM7Suygn9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ3ZDMyN2EtODE4NS00NDJlLWI4NjQtODEyN2IyMjBjNmUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjY2EyMjcx\nZS1iYzMyLTRmZjQtOTkyYS1lOTg4ZThkMmRkYjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQNiye0aZvnJ8OHHGjJY3veg1qeL1UgbSjq+/RFAoABO+D8akQH1jzD\nwTOm2KQUsSOP+AcZzKpqH5OK+js2sGLto3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRl2AUg\n/r2zfrRNBS3He7LmkUxs0TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOSeQ5Bls/O/ICC37waoIjRZHwX/JjrdO1ZW\nHQIY7xOOAiACdo+9/rv4a0cBS5M6wPkoSpdBr8SZEY9dqYR2Vt/sJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2090", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2090` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAS3VN2mOmuqc5WaqrDCKE6BYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkZWZlOGNiLTQ1ZGEtNGU0My1hYzAxLTQ4NjI2MjZiMmI3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThiZGU5Y2UtZDE2\nNC00OTIwLWFlMzctZDA1NmNlOGQzNTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwIQ1XtwX2/+uFqm6+LYfAxFUWkTEarUgvBeEXpujvcAaAF4i4kgtXmiajVjX\n1l4BDgYsaecJ8j19CuaK1NZ5+6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1m80KPrUnjuLRxwtTgp/r69fVx8wHwYDVR0j\nBBgwFoAUWAxmrVsdSF8wdohbS/GhLmgKk4QwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCAvNcHTCdzRg6+iHCt+Sm94D+oUsf6pEc+EGMU/I3X0wIhALCRaFVA\nuQV+dR6CokA35GJAQ3Lbp6rk2DlIM1aY+hk6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAStNQiMeRXU4i84z5hWlfwSmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGVmZThjYi00NWRhLTRlNDMtYWMwMS00ODYyNjI2YjJiN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk1OdEu/7p/tlAPJoRyoZPpHpyNTDy9t7TLFUg4niqaVR+\nixw/W6nue+nERwNwIdf9z8+XL52p7W8zifHE/xUfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWAxmrVsdSF8wdohbS/GhLmgK\nk4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYIOD8Z4yZ5lTn9m0nEXcYxCRFai/D/5UQYV70ejUsVYCIH2WNLSm4x3k\npjfJJVF8/6RUPTcTassOfP9oe2iGtFci\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAUOt1fqdckm9PHGsG9ld3wjUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThiZGU5Y2UtZDE2NC00OTIwLWFlMzctZDA1NmNlOGQzNTUwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMTcyZGEy\nMi03MzZiLTQzMmUtODllZC0xNDA3YWE2ZTJkMjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQBwJOAd87EdknLF85ElDxBlFZzfmAWRglT4aCxu2ixvl+ja53D4AFD\nIRnt9lrN9tosYts4hst0ApzqTpQnRaBgo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWbzQo\n+tSeO4tHHC1OCn+vr19XHzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgbI+oJA0ggcdICbFdB54w83LW+p4qNdBYi2nj\nwaWXWPoCIAZL2XkudwZDJDGiM1p21y6J9p10NOr+j3FMzl+lRGZX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2091", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2091` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAXX+2BslsPIs0CRnqYvB7t60MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NGM3MDQxLTRmNzUtNGJiNC05YmQ1LTNhYjYzODAzMDkyYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDM0YjM3NWYtZGY2\nMS00MWZkLWExY2MtMWRkNjM4Y2ZiYjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIEy6DngmVAhFLcVn6r08kLHf2Mav8SP7V/goudayBbNrqmX647uyzZQ0jmnU\nyOuvPpjogZWBzSfiWMulxZFX76OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtvxSRpSJ/NkXdfxLhLb5najX35kwHwYDVR0j\nBBgwFoAUzndUEfOLG8YQPaGSB4ER1I+Z+wEwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCICma9HvXwAvAuIHU1GRhCoEgluPHuHz01Zo+jjNYwtFrAiBBGtKRusdv\nGWiItYeM3Ij5wkntie/DR4ijxUj8qND/LA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcNvH6jX1FtIPYbqJg89iwfOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDRjNzA0MS00Zjc1LTRiYjQtOWJkNS0zYWI2MzgwMzA5MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4ufOMlZ3179NlyzHrO7AztB1SnJlGSduskGGqKlFs7GPr\n0UG26wA2JvrKbh5MTpt0TBYXfSa8vKEOgyRh+/2Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzndUEfOLG8YQPaGSB4ER1I+Z\n+wEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMU/80qmoxhQyfb66aRz24WP6PKsL9lrYLrIeXlvqjPQAiAOex3ox3V9\nZcy8HZ0KwXi478igZMZKHFPWBPwFi3QNqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAR3cSXOIyv4wGgsAybAPvUhEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDM0YjM3NWYtZGY2MS00MWZkLWExY2MtMWRkNjM4Y2ZiYjJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyOTg2ZDRl\nYy05ZjE5LTQzMGItOTU3Ny0xMzVkMjFiNmNjMDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASny4iVD1Fs6b7iua4cq2n3+M+I8aKFOQRVCQoL5yCsXQDS0akv7Psr\noAV0y7UY3FLSzjxAvp5N0WQQr4unt8Ggo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS2/FJG\nlIn82Rd1/EuEtvmdqNffmTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAO406lo3bn7+yLMVlKPt4XmYgwfVjP8OIsja\nbiTy65WBAiEAmg+bL5DzHh2yTzqBlXlsp+CAGXJNHT/GKCYhIkXGbQc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2092", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2092` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAdvP65aNRjHyfP/5dxEuG3rIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NDg2NGFlLTc2ZWMtNDY0NC04YzFhLWI5Mjg1MzZlOTUzZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYxZWVhOTYtYzEy\nNS00YjM0LTg1ZGQtODU1Nzg3NmM0NDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcZV8kQRQpLuzx8SMctgc9xkfwEyWAm/PTRmNqXHir1DTTFAC0zMsykHn2tGk\ngV7xfGqIrEC4BkKBsqG71jRitKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOobX7Vq1qeTed9YbN14Rgc+jHUowHwYDVR0j\nBBgwFoAUJSeQTTFA8t+SgVEYZbvYrpb2JzAwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDSVTd9puTimfah3xhcnSqz7dwKF27DErHJyKjahiLZTQIgGL9PfelkcwSlCQDG\nunH+IVDJ8xn0+fF93Y+BcRl9nGU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAep/BGQ8Qg4PSM5ZF0gQYX+oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzQ4NjRhZS03NmVjLTQ2NDQtOGMxYS1iOTI4NTM2ZTk1M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKUt7bcGxTSlZKSlAjcZ4uHAuLHEYcsE2ECAUDkDnPPLpC\nkpdeqp0sxfzi+BbHJ35edEqYleH+JnpoyH55jy4Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJSeQTTFA8t+SgVEYZbvYrpb2\nJzAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVbagsY435ORfyOeiJejNexqYlGPqSSrAr6yRDYXC2DECIQC4/R7BXShf\nVbvbE5T2YsHvrSVM39m/vKvYSvEkZKItEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAWFLtmAYgOPcytLpc19etIxkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYxZWVhOTYtYzEyNS00YjM0LTg1ZGQtODU1Nzg3NmM0NDcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZmZmY2Mw\nNS01YWJhLTRmN2ItOTQ2OC1kOGYzNWNjNWMwOTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASwN8klTklbB9nRRvcRzMzsVRCo4hZClFCciaLWWQcL+X1dlcOP3eX0\n2y3cj4d6sIAj0b4uyM778Jo+yJp0//pOo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ6htft\nWrWp5N531hs3XhGBz6MdSjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhALmgNbKygqXWgqMG25fPUwUMiOB2t8PWKWmI\n7oy94pKYAiEAkLq1dsOsz9aXACpV8h+aWGXXs4vcqsTJuKs36fsQ5r8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2093", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2093` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAZTSzrnR8NDFBdMSHUU4LFrnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMGNlYjM2LTQyZTUtNDVmNC1iOWM2LTUwODgyZTJlZWM3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQzNmU4ZjktYjc2\nMi00MWJkLWFmMTktNjRjZGQ4ZjdiYWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4im7f4euGw9JWohu58KntmA61hShbwvi60A7PVFVzF1sb4vX7Llemp4jdi26\nNRadaCTBT7XKZqtvChvJw6WlX6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK0huNYK2+ov5PdHabdBotRM0FS0wHwYDVR0j\nBBgwFoAUwwpAdbk+gSYRod3BKmYAzhlU3mQwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDgw/cwi3DM/QTBRJ0IDvns61EqFbYnWtIfr/CG2nUkjAIh\nAMYoYTDarcOHrByU96lxxZPCRo3j1/mDAGFA5x5hu29W\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARYp3LAy9/MPcNOMjyV2pNKZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjBjZWIzNi00MmU1LTQ1ZjQtYjljNi01MDg4MmUyZWVjNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZwOCZHUIY2AKkjJwn/3crN/LgbPuPZ4amJ+OLqTUhS5Zb\nsYQ8xZHpzAuZYh4lbNuMWcS66XvUwUGpgPocwr6Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwwpAdbk+gSYRod3BKmYAzhlU\n3mQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOqOxOmBNHG3x2SGVCVaejK6t3nVySGTqyx2VNusx11sCIBhoHtl7NMKs\nssF6CHgsqTO8hTMK+mLccsM1awyR2oC6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAbz1qy8UADmPbDWC6mur/GFoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQzNmU4ZjktYjc2Mi00MWJkLWFmMTktNjRjZGQ4ZjdiYWQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZmIzNWE2\nNy1iNzAzLTRjOWEtODc1NS04MDRjMTBjNzU4NjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARraJXG5+9d5QlLxnZjb0RVmlolsV34GwHzIdiOsjPU17zataE8U7RY\ngsj993njHz3sQp0MY3xh221kiU+GGklYo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrSG41\ngrb6i/k90dpt0Gi1EzQVLTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOS/IABxVZCVflHC3PZ1hJjdZAzFNL/g2IF/\nDJazxxkzAiB9b493tYNsv0Vg+yj4y1VKOO3l8tKGV6VfZU6Jmwn0Fw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2094", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2094` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAaonYRiHUwF61B6Uk+xVqylYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlNTU2NzYxLTA1YzMtNGM1NC04MDA1LTY5ZjI2OThjNzEzMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdmNGYwMzItNDFk\nZC00MzQ3LTk1ODAtNWI2Mjc1NGYxY2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/IixT4a1iWLm8YqNkIQS2nEODgNF9AlBHYt94b3IfM0RKIthujrBdqpJwqiw\nCorm1eaDM930i5i9t6GQ9Rh1bKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCQai1wNhVC6qjNBOKSiec/5Pi2UwHwYDVR0j\nBBgwFoAUssfLtkEF9chcRYTmruiXNIaIjXswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQC7Fs8wypX5+BEFqUeGMNgKf2iyYFtDHpg4kJPgmXn2RwIh\nAPeawUFnKg8iuk8T6Q03BsZMXdElzc6Ll72q9IvIKgKW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf8T+yOAeok4N0P2BegCxXyLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTU1Njc2MS0wNWMzLTRjNTQtODAwNS02OWYyNjk4YzcxMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3MoDoN2tnleiSW0U7dZzslhBk6maUyE/C+wC8c7BL1cv9\n5CkfjPyOtwI/aeV6qCj5+cWdfOeSGlnQxS8TazMro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUssfLtkEF9chcRYTmruiXNIaI\njXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcmJOQBz2hCj3m2+LVHDFzbJCe1NUMqRTg42hue8ZGOcCIQDhHYNYpYad\nhjw7EDkYiE+Yi5NRQoCTPHmaLoGplgGirQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAbWJIWYWTwxm3RlHdtqpuHv3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdmNGYwMzItNDFkZC00MzQ3LTk1ODAtNWI2Mjc1NGYxY2E3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYmJiMWFk\nMy1hYjc1LTRjOWItODhhNy1iZGQxOTM3NGY2NzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQQ2nTX1Ei67xWc8TXTHKZSE9K66A6FGLzhlh4tjzlmVXXKK0XgGV6L\n8mEb0jdMmvQCLrVGXnemi+GT1xGUq26Lo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJBqLX\nA2FULqqM0E4pKJ5z/k+LZTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgDkeoJj7OC0DlTJEQpb7gVvglyjst9xVPQ7C4\nFm4HRT0CID62rBFcDJHkwyMioF6VFgblrOt5uAvlMEZWiiYveFLB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2095", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2095` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAXlcgAXsOae1odGRVblPwofUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1Mzk4MDUyLTMzODItNGExMi04OWYwLWRiODc0NzMwYjFiMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA5ZDJmYjUtZDU0\nZC00NjFhLWFiN2UtYjdhZTM4Y2I0MmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcdkcsGS/FVBxZE6TZ57ymLHZBgkVVAlJ+NyoJYPaJ4tfnwAw5BFqfwijwhfk\nA0JpKJZ5nXT+olM/8+3AJ+ro36OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUogDVzOskQmQNzCgCqsknEUpH1zQwHwYDVR0j\nBBgwFoAU5e0O0rc7C9uGNUznDZJ4HwFGjL4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIA0opZpaHJP4\n4djxakKiL79On3eoC9LoFaMO14dT3M4pAiBgQibollc4fyZCa1/ufo8lnA3YXpvd\ndvaQQFfsS+xBiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATquUcLGbCxJQ9lOhWperazfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTM5ODA1Mi0zMzgyLTRhMTItODlmMC1kYjg3NDczMGIxYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfSrnPesXK8hKCqcFLOq8ONe+rvbE2xFIkuh92VQnKx1uA\nbTJFXousiUAyyG9t2+Af9/LYjPHJwGTczdndSnajo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5e0O0rc7C9uGNUznDZJ4HwFG\njL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM+GblaCk8P58zir4hNCjAWOZKqHftsum3Ur9A4OVDl9AiEAjQeSjwHI\nFWGAJ94g49NRXXxEiewmNKi9VsrTINp+Ja0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAc5QvR9SYczhmhU3XjG25RmiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA5ZDJmYjUtZDU0ZC00NjFhLWFiN2UtYjdhZTM4Y2I0MmUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0YmJiODM4\nZC1hM2YwLTRkYjMtYTgzMi1kNTEzMjBmYzMyNWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQl2ZeXq8uZAqws3mvhwGoYrmgBJD342KrcT9Cp6jou6R8WJyL9KU3Y\njDGzfg+95ftLtoCK8dKSoCFbM0P8q1rIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiANXM\n6yRCZA3MKAKqyScRSkfXNDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgRtxRoX5SUqturTgurIy2Q/tj/CEAKmpGg3xq\nJH+Mi24CICGSQP4m13Ka6I1Jwx2Qht9qKCOiyd2F4/Wkc6jxdstl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2096", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2096` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXeKTmOhlSK6yqIJAUcwlVHPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwNThkMzAzLWQ2YjktNDUzNi1hOTUyLTEyMzI1MDQxMDI0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmEwNzNiZmEtN2Nl\nMi00MzkyLTk1ZGItMGMyMmM0YjA0NDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE75gQrOpMKerwHVxcKgIom4usuSTebcYvbQXlwfB6yiocaNDMsrjutXcU+2St\nItugPbN/7CcSdit2GZCiyzNmBqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTjMDgytuJyQz3WkCZnqB3Kx1maEwHwYDVR0j\nBBgwFoAUjlwMyos+PX8ofi6LB5jRxBT9tZQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKFXHUkROaxWpO8Z5myDEiOuE0gF9RamkHTFHPlN8691AiBH+Caw5urA\nNyWKgtaTtkRsTmeRREeclFqtWjS7GSeF7g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASh3f6EItSqulUpyEyjXFg4/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDU4ZDMwMy1kNmI5LTQ1MzYtYTk1Mi0xMjMyNTA0MTAyNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASO6hHp76FjiyIuQhTfLBguWVkZsoFd3yCroVcF/Qjq6UXn\nQNhvh3zmEL89/B4EYP89ia823rWpDd1PE0r+1ecNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjlwMyos+PX8ofi6LB5jRxBT9\ntZQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKrda4XnFZhSIHDwoydgj7kYKC4JFLfGb4hRpu7V4OGyAiAI1f0fDlCl\nbhdJhnOYuEMt6cnFkYMXO0xx9FJgQEg83g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAToLfkU2CHztc3xvoKJu7sc+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmEwNzNiZmEtN2NlMi00MzkyLTk1ZGItMGMyMmM0YjA0NDk0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZGNjNWQy\nMy0wYWE2LTQ4NzUtOGNlNC02YjU5MmQxM2IyZDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASLQgnmnNBwIDbrm4Zbzs+dwGMwFnDLRh+X10UPgvAnB7RTdrjQqXHE\nDLwuIvPJqvlD8GDqStMsGxFmcl2BFsd9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBROMwOD\nK24nJDPdaQJmeoHcrHWZoTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgcb4mdYA+ioKb4NMASpUA8DnmzxFM68zkz7Hd\nfvO3u/cCIQCOJRxg7t0Iz3yRkAcIl2Pf8OBi/UQjYq37puwa7/TxoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2097", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2097` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAcm4odHbbVeOJLPEAPUWRuxoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2ZGQ3OWNkLWUxNDYtNGMzMC1hYTZmLTk1NmZkODg3N2Y4ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY2ZGViZmQtYzM1\nNC00YzE1LTgyZGEtZjBhNGY2ZmVhOGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZusPCIv41TbGo+jzMp6UFRis2eE0zGoStuIGYcuavvyRfS9wZIPAezymOCjg\nFIIZTw+R0AmlyMPiaR/9y2xmFaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXJHEg/IlGoNb1xrjy2ow4LdLWnIwHwYDVR0j\nBBgwFoAU96zZq6uGko4IiY/avN+bXKHBulYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgNx+9vZK36v8ZMeso3Et3t41Ob7+PYo+oQJDSVbLRdVcCIAlLi4NJI0VH\nX6m36bGVN4g4h83HFy7H2JJdI+ZtOvFX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXU9tszX7/EfTS8uXeDYjeCrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmRkNzljZC1lMTQ2LTRjMzAtYWE2Zi05NTZmZDg4NzdmODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv50IyWVUmd+Xj5bKSfuOf00JER+yKnBDtRf79weASmbtO\nhMGoluOkClG4f4Q4EyYEgpJKfNWJd1StAI+NiWmko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU96zZq6uGko4IiY/avN+bXKHB\nulYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgX3j2DcWDZRrl89x3E09PzqhU/F8VK4rh7DztZ9T+UL4CIHdr9LJghWZj\nQzCim3V0KWdzAIDD6g+uMy6hJ0fpqnK0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAYE3ds6YJ6AO/lxznW/xwcj3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY2ZGViZmQtYzM1NC00YzE1LTgyZGEtZjBhNGY2ZmVhOGY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YWNjZWMz\nZC1mNzY4LTRjNDEtOTg0My1kNjdkMmNiZmQ2NWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ+mzNeB7BNRuHrySOaotMq+t1uUC9+2ZRjuOasiH4eSiLbTXqC3ra3\nGDyciOWTTgXPKA94Z8P+A6jmgjc+dbnIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRckcSD\n8iUag1vXGuPLajDgt0tacjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgfLjh+WLjV+5xGmSi5+U+eIiuSogvvoCG0t0Y\nSGCOjzICIQDfWcfIUwvJqWRWPzKrTxSR614zlQ2P/5UEmZ0HXTYuqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2098", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2098` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUHZpY4KKfdZcGPXIl21RsuiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjOWMxYWYwLTE1NjYtNGY3Zi1iYmViLTc3OWVkY2IwNTcxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNiZGYzMTgtZjlk\nNC00YzdhLWExNzgtNGUxOGM0Y2NhYjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGmQA5yKvfha9qMd2NnIfC3eZB4cO0rxaSy7DKS2C9e175mQt8EIONIgvpuzY\nMixmNz9bRmVMAp3B14VPkLu5J6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVRM/RDXCngucdqqtxMT4TZPsbUMwHwYDVR0j\nBBgwFoAU0R7qLebh8mf1/t/dWP25/6y83VMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIHp1IUnWNj/ziwjiHwKceJZoocVf1oYmotxSF5wqMjLSAiEA2QU/4LRc\nr4NSXAjI/1L2rWdfD5fqi/kbawXbCs4KMN0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbwPK5KMhdncK7B+Yf/2vs0sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzljMWFmMC0xNTY2LTRmN2YtYmJlYi03NzllZGNiMDU3MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgvCVrRvSEFaZndRXiARJo0ZNtcd9XQxG1rJsfwubSNVZF\n/BB+IQHdTxj7MpFNClSIkcloZDFtiCocw6CmXaz3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0R7qLebh8mf1/t/dWP25/6y8\n3VMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPbgnck8U2nOuv7UMfHjHqwdvNVYTyMOTgsPlsjPjIcRAiEAvSfoHP+r\ncfsZjeFOcpTLMD7AhXrXrDtjI2sKLdumOEk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAR677t5ckKNCzKA3/9X448w6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNiZGYzMTgtZjlkNC00YzdhLWExNzgtNGUxOGM0Y2NhYjNkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwM2Y3MmY1\nMy1mYjhjLTQ0ODgtYjE5NC01ZjlhZjEyYjQ1ZDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATRc96nt2ADdmymSgopPypFTTBfjPwX4lytaUzrdP3csMo1ZyiYOUnI\nz6+TxUON0Yl+el436K3vm89gwXsDvSKoo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVEz9E\nNcKeC5x2qq3ExPhNk+xtQzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKe+LMkRF/v9oMxJGoNJ3lj9VeRqW/1cuuez\nlT42PWK4AiBT9+4Np9TusyGHutHmpDCRnTseFeZHnXGRt7jiREo5hQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2099", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2099` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAfz22Q1/ppsJETdWyK1Gm1knMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1ODRhZWJlLTdjODItNGIwOC1hODdkLTA0NDVmZmJiYWU3YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTM5ZTU4ZTItNDA0\nNC00Y2U2LWEyNmYtMzBjYTJkNTU0OTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoM7H1uQXsuGOPJH5CZ2Ztm9MlUu9BDkX/HipmDlLdi7W2U1DD4XJzh4hKc32\ngeajYN3rML83+4KRyabUezzZW6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7yUmdkZqLpXTu/70MhUwnFTiu/UwHwYDVR0j\nBBgwFoAUu+EdsIiaO2rWZ02AS5NOzgkIqBowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQComZ2gNjvsnoIrdmXmKUvRyTWVmtCMitpYbW03\nWLQyGQIhAMaAxEh0Aw7O88S18M0d2/ry7M3DJ0txVaVI/FeHvxT+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVz7b7qd9pWpf+8I9G03J2DTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTg0YWViZS03YzgyLTRiMDgtYTg3ZC0wNDQ1ZmZiYmFlN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQo9f2pFv67P2qV7exW8UR+9k5bEWWNPQnAK3fMlCu7JuhP\nV+2kK7YLViah9dfixBSwRziXjWeHr9kBOo2K9hAdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+EdsIiaO2rWZ02AS5NOzgkI\nqBowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALNY4+5Sw7qVwFCf6gY1Vpbtp92M9Vfb6uNPw6giKlEDAiAO5Sj8MZQd\na/BJKqIZP6yGnr1nmmstc79hQNT+7XUo7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAabvEreDn2DLPilwU+6Ok4B7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTM5ZTU4ZTItNDA0NC00Y2U2LWEyNmYtMzBjYTJkNTU0OTRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZTEwZmMy\nZC0yMmFkLTRiZTQtYjNlOS04OTMyMzkzOTExMTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARN30c470dvbj1HV74PKTuH3kN/OmXsREzfyF2RDWxDQrifn3KGzgdk\nekHav5ctm1sCua2+pr0AQaSZkcWovSS3o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvJSZ2\nRmouldO7/vQyFTCcVOK79TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPo7jyFNRYeaFqmAjDbT1zZjINlA8eK7aBQx\nOmFGvmPyAiAJfhbORtBUgraKLOw8kkZ833ezgJNMr/mIzdCyIS9SMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2100", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2100` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZf/kgcPAnKFVVNdvwIjYA8IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NGQ4NWQ3LTBjMWQtNGUyOS1iNzdjLTQ3ZWI1ZDBhMmI1NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTMzNzg2NmItOGIx\nNy00ODM2LWJiYzctMzg3ZjBmZWM5ODQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEstKF9+zmaA55RNJQo/OYkVHLbho7HBpKREnlY7aktV7ztWto31gArtAcXHmd\nHQaQ3TkpBMptejBTsk8q56e3m6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9mNBKZmrEzFUuhkOSVya9/G4nO4wHwYDVR0j\nBBgwFoAUGEK2r8XT2bCsSBFA02EZU2NdV5MwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDCPe+WWFhFnuCKoFidUyrC22v99v9IEPEQhzRb\nrNcAEAIgHwzHc1UA+9rUz6wx+s4osgJmuo51W1PZ5vE6r7trcPU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdoe3piHZbwS6sFG5cY2GBOFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTRkODVkNy0wYzFkLTRlMjktYjc3Yy00N2ViNWQwYTJiNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjRKxwe4ORC2D3+XRjyGjim9uJpR7vIKfIzSMgH8/SVPN/\nUCoUda0O6URAMLMcOSlWJZ7yYZIyF50qD/wP6HEEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGEK2r8XT2bCsSBFA02EZU2Nd\nV5MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOy1eza4vRvcJmkNn3WMbPwdjDuxPLwVmHfpfeneF3qCAiB6osfxYfxh\npN75QsP/wlBzavBMYCrOlzZ+1GGIsRaRKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAdx1DypWe4HD2Pw/DptK3sUYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTMzNzg2NmItOGIxNy00ODM2LWJiYzctMzg3ZjBmZWM5ODQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNDMzMWZh\nYy0yMTVhLTQyMmUtYTc0Yy0yMzc0MmQwMDgwMDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASIhC825wXP9UKjN7piY4gkGYtZugSh4KT+mkym8nee7P3Z8RikeN8u\nI05JNwSuaDVhXCtLHDRpMF1Jv4LCLSspo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT2Y0Ep\nmasTMVS6GQ5JXJr38bic7jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgde+OuJbFPf4DZ4qhukggKpMwZ7mj5EQFE7H9\n8KnZ+lUCIFfThebe8uWf7q+yJJ5zfTkfl4oZ+O4hn8MPI7911j1k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2101", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2101` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAZXP3xZ5mpIVoqoYzULF1McVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1NGUxNjRhLWExZWQtNDZlYS04ZWZhLTA0OTUzMDIxNjQ4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYzNjE4NjAtMGNm\nMC00N2Q2LTlmNmItYWQ4ZmY1Y2I1ZjZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeZkY+M2Q4uptdsOOqa065Ji5iOnxIlS3FWiX4dQD0502TjJO1O/8vFdcDZ1g\nvGXODCFkx6kU0GqTzhVLTv3GeKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBDvwthRs3yZ2xr99fz14wMuygbQwHwYDVR0j\nBBgwFoAUHpZWp735cmBUyqockD3B/lGafXkwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIEwZU6BXFzgJqbLuQdR5p1xIwwpbicE7sd5EtdG3MqUeAiBa\nJ7cVf4YK7vH0n8M+gs+8Y6GJEccw/0/p4E0lXV7GnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQyCQyZTc1ykENtcrOPYUB4EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTRlMTY0YS1hMWVkLTQ2ZWEtOGVmYS0wNDk1MzAyMTY0OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKFKhBrBdOMR17if3uAdNulzsTicNW6tD/soEiQmnJ6b6W\nFB7sSk1gr44X5AdQNkphdyksvPxoACErdOsu0H9/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHpZWp735cmBUyqockD3B/lGa\nfXkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALfeyjfugvgDUXaH3azdS70ezWsoCiuiKTewfVo5s44eAiEAx1mkzOik\nbG0sY0is3RkJ6Z17NrU5GRdTPmqyRvhlm5U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAYQqNKzfxSG5ElwPO7SnuhB4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYzNjE4NjAtMGNmMC00N2Q2LTlmNmItYWQ4ZmY1Y2I1ZjZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5YTNlMTRl\nNC01MGI4LTQzZmQtYWE2OC03ZjBkNWMyMjJhZjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARODUo3HX65wlxhQW21w4cUCK/RqGriw2WU+ORT6rOetGZL4boQxaV9\naPuHuClJFtE5NkqXO4Sd6yIcELLX3SZXo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQEO/C2\nFGzfJnbGv31/PXjAy7KBtDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgBma2HChyUdX+dGVFT26H8A4gmxfVIIn7YKN+\nVJII8WwCIQC2+gTCSS9bCzFQshi92REX2X4xz7UpjstsxTYbOT72gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2102", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2102` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAeah2E3DcGQNlwBTiw2auDcgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5N2Y2NzM1LWFjNTAtNGUyZS1iZTM3LTQzZjJmMGUxNDM2YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YxNWFhZTctMjA2\nYi00ZjY5LWEzOWUtNTY0MzE2MzgxY2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERYRakXVjBYQX7sCb4qxfcnqUqb3ztdL/KW6djB1YxVojg75KbBeDi0TU6bLi\nsO6zddhXjwJMMCHgisuUzk2WjqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiYKTwW2GcS5o6v3zWeIoyuTz/94wHwYDVR0j\nBBgwFoAUBrVua6Tp7NVy99s1rHhQ51vLatQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIA20GXOE1vx0hHHFg2/24sxMADK6hCjS\ngxc5kfhURSF1AiEAuQ6E7/hxSXTLNvUaHrS1Wfu0sFmZipqsDLSBTKnkpWY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAepS5z3kXsG7w/SWYyagGHeqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTdmNjczNS1hYzUwLTRlMmUtYmUzNy00M2YyZjBlMTQzNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzq6GDHGfJFW3bS7am7BnrZRu1I5PCEHX0G7Z6XWKGCVWj\nLIxtxlrpKeujgLIC+uW5esgy4SURUqJMlE82r/aTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBrVua6Tp7NVy99s1rHhQ51vL\natQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAplv/g6ij0SlaYl1zt6KQipUNnvA5IaseJ0IVGm8ERsCIFcB03lpNT7Y\nrY5hxIxnuNi72Fw6q7v7afiWdyh7zPUw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAb/SSf3NW95BwP97LyVMPachMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YxNWFhZTctMjA2Yi00ZjY5LWEzOWUtNTY0MzE2MzgxY2FkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYjRmNDE5\nZC00NGU5LTRiNGItYWQ2MS1kMTg4YjFiYWJhM2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARtmjeV3hG0oLiBnXmKfp++cW1IcbLP+UP7bCeXQDQyXVSuO+u998Bc\n3wF59nvOri6VLZ0C7VUZ5R5i5jWq5iXSo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSJgpPB\nbYZxLmjq/fNZ4ijK5PP/3jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPfiYa/OWYIL7F/xpSXUuapla1VS5L8G7YbV\nlaqnu/zWAiBUOaCtT5QzB7xHJVgEWB+symEGAS6fIhTGWoJr9nCR2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2103", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2103` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAST62F9QFh6OCwB03R6QYc26MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3YWJjZmQwLTY1MTItNDM5Yi1iMGZjLTc4MWNhNjUzODMzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI4MWJkYTEtNWZk\nNC00NzNhLWJmYTAtMGQ1NGU0YjVlODY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWnTJvqedDE6ve+7Iv4aO1FGsUlBCCNhEO474BTRJ7eEqL1EMMHeFp3/3HIqH\ndzMplMso+SSbYnmgdXLUr7X8IqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeh2TKr1eq0zHAUE8gVAVc/KN+uswHwYDVR0j\nBBgwFoAUPwN3YfIkCEiEO2t9oSgTnCei6D0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIAxuVHfYeHFJTXQMjRnYQP7LCTPJNw6I\nejJ46bfLKUgHAiEAiPTXoF5Sf71rqgpB0p2VCy34jEDR7QgE0dcV9e3i0Q0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcCAK6Nct1HyuRRxLJv8jlhtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2FiY2ZkMC02NTEyLTQzOWItYjBmYy03ODFjYTY1MzgzM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYzFQXzeJlj3vBR6L1rBld188G/N3kGNOPnx8MoXUa/D3H\nTXDXEeN/MaoCa+wHQ9KKvhQTUlGg8y58MULT7R+6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPwN3YfIkCEiEO2t9oSgTnCei\n6D0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKoZ/ijh9M+Z6LIubYkZV9/AmyA/uJeN1ykEnHlqqUcsCIHVCjwwPjqA8\ny7Q0+k7jtDEP2NxqrvbD8u1Ey+k6Q6sw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISATElFl4O9JJeIYcE5i806Es/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI4MWJkYTEtNWZkNC00NzNhLWJmYTAtMGQ1NGU0YjVlODY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZGFiODFl\nMy1hYTZiLTRmNmUtYmZhOC0xNWY3YWQ0YzcwOWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQGldM4QY4LHWxeLChl5tRGOh3+5BpA98/X0xLN680O2KHef9V3LD8Y\nrsx6w3ZmGw/SUbpUTaFgk0LCJFJIyi0Lo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6HZMq\nvV6rTMcBQTyBUBVz8o366zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIEhQvKqxCKneaYPkB4PqF9yOXCAYa9RoZvj\nU3x9qwbwAiAImm2qcmtNe960F2lE7aZ0pr0ax2d4Dtu7QZF5GgTUZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2104", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2104` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAaKaCxb81cUwY7VkSlug3FR8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzOGQxNWFiLTlkNDUtNDhiMS04NzIxLWU4NzhkMWU4YmVhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIyMTQzNGMtZjNm\nYS00OTE3LTg1MDMtZDJjZTU2NjZkMDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5XGDsYyrkp7kZpLavwRUYuRwVGNymfZIOuUCSAU35F3+fl/94VySboDy8CuD\n7S6AjY2nK/ksjxrQR9z1J5Fw6qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9zDIlL3huV0QpR15Lyf/3Gu+CQwwHwYDVR0j\nBBgwFoAUV9KIe3O7C+V/ok+RxffttA5fdtgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIBOn83CbxHdv\njvbqhDaVkri1lDyOC9h/IJE58E4RxLGuAiB3fyjEbm4s1qRWr+cIoGwZkfzaYNJs\nKg8xEeXxJZTQWQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdcDouP/jEF+Ju/ZDXRHxAGaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzhkMTVhYi05ZDQ1LTQ4YjEtODcyMS1lODc4ZDFlOGJlYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATY5ec1O1E8dU0FjOngRQJD3JjO2Kti3ioVEzUF7Hf+ah4X\n5YPZ6+3Qg2Y2A8YgqDdXZtYqPhDHhigrdawdcDVGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV9KIe3O7C+V/ok+RxffttA5f\ndtgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQu9PG8md7lIb+DF5vaR5kEDgU+ILf5tcwhcvYb+2yVcCIC9NuzYNovdz\nEJZysh8pMtBNdVH5QbajbUfxe2XhvQ5O\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQ/l9iIPb4c8tikmnw55viadMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIyMTQzNGMtZjNmYS00OTE3LTg1MDMtZDJjZTU2NjZkMDRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNzAwZjFj\nZi1lMTE4LTQyZWEtODZhNS04ZTg5YzA4MGUxOTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT5oLPIEbe0olYzZ5m/hXGuvoHFlHBpztzWNl8kHHJYdzVy/v0ZzQq+\nUeNiW4IDfF4zWIYLsOgUc6IfdSfpNDCqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3MMiU\nveG5XRClHXkvJ//ca74JDDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAK905JC7LVlUOEco+n3oCicyLvF+EJbArtF2\nLAWpsb3DAiAktayVqW9l/ecFV3iN+qqUnQjA6LlHLMbZaJ8sv3E3dw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2105", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2105` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAVlRLHtgW3C7NxzdP1FzG5cNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YjMzMzdiLTMwODEtNDM0Yi1iYWI4LThhZDNlYjdkZjliYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcxNTIyMTctYTI3\nMi00YjlkLWIyYTAtNzI0ZGMwMWMyMTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjJGtAWy4gEQhecdpqEeU14Q1WCI/KtwtgTmTlRlzyeoCpq0xoP0TRltCkfpK\n1NsLzPHpJxuW7Ea8mUNWwYinEaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0OYE650Np7jfKaZd5uzvDDputpgwHwYDVR0j\nBBgwFoAUuYw3kJofisO5Rj19eeVIWo3+ZncwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgcJ8Wo2N0sSccJLZ9DqIpSN3Of9bXUwyM+kE45rc4UnMCIQCQzOIOVnDp\nDX3GwSBf6zvsozBto6Mpj/Y0DsnLHJSCYA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZrnOCFnC8yoiQcXgKD3YgDdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2IzMzM3Yi0zMDgxLTQzNGItYmFiOC04YWQzZWI3ZGY5YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/w+JFU+QogPBdTwjIhQkFzxWAVCbsq8TE4bWbNxsCKlAy\n8sgJxel+RMf40hghP7sfIPgvvMozHxqEdlDkhiPFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuYw3kJofisO5Rj19eeVIWo3+\nZncwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFm+kgMTFqQ6WjJ4OBUGnZUh5J2RjeJi8TzOz2qss8v8CIHgY34+YSwNn\nZyuns4HA6QxBN74YtTxiV3w2wqVah51Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAf5EmqZf2L+cGgxXN5qugQO+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcxNTIyMTctYTI3Mi00YjlkLWIyYTAtNzI0ZGMwMWMyMTM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNjZhOTcx\nZC04YWFjLTQ2MTEtOWQ4Yy1jN2RmYzY1MGNkMTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQGcn/+LIKlrDExgQum+aTaGdGvUcEkYNd/wxGEkJu6HiJ55pDF16ut\nasTZ1teG3Fzh6V/PU53hEQC2Ua/eH5zGo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQ5gTr\nnQ2nuN8ppl3m7O8MOm62mDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgCfhDbDP7yfQUeZcNsP8jXbfwpwYOodVnrUXz\nSmXWhEECIHoI83TYmenGsgWFptOZWIqYMneJl79T1HLefP2mDemq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2106", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2106` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAZB+9GjJ4ETkmPlB1RLhq8H+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3MmNmNjU5LTQ3NGItNGIzMS1hZGIwLTU0OWI2NDllYThkNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVmYWQ2NGUtNDA1\nMy00MGFlLWFkYTItOTMwZThlZTEzOGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkKSiwg4CETfb36e4ym45D5Xq8UGuEmXsnal3wPYQV1kQpI7UVOl/01sxF/Q2\nVnhZb9dc6SpPn9EJ3Zrux+4aqaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ZapGwkCYT7OGiCbYVDs02bj/RUwHwYDVR0j\nBBgwFoAUl2r3lKaPefjr/Yrc8ukpfUcQ8f4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALl0ijdeaJVT+wizQZEqK8OZS/1hKmi2yQOfs3XACBgbAiEAnpVcpV2L\nZLu0ol2wFAOR+SI7f8VV1uOZxmV2PlaiMpw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXRgx3VJDqZ1RfWSxNix6aW4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzJjZjY1OS00NzRiLTRiMzEtYWRiMC01NDliNjQ5ZWE4ZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5v0DIhd+396Z5s97FFiBEydsVi2e8dqS8MKWBKNt2OSHJ\nCeD47J/nCnXpLzDPOjb1+PqWw1I+DW5+UiWDAgpwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl2r3lKaPefjr/Yrc8ukpfUcQ\n8f4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPSwj1dCNBGn3zmil/DTmFxtkcjj5rOgJqD1NLsxrET8CIQCThYSrf6xw\niXI4d78uNIEwR+G5csBD5MRH/AdkB/1Alw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAdbvjvoHFQBgbxxDNJP4jY3iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVmYWQ2NGUtNDA1My00MGFlLWFkYTItOTMwZThlZTEzOGIwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MDI4NWEx\nMi0yM2Q1LTRhOWEtYWJlOS0yZjRjNmRlOTA2OTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQdoUpMzk5bTuG0MjgQ5z++8LRPUtunfCnRXKNiM0aj3f4E/BIDtJzd\nRd/c0tEWXoyOZZfCksdp5Lg7JMdJ+U3Ho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTplqkb\nCQJhPs4aIJthUOzTZuP9FTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgY9/nZhxirm0uaBj87vQ0Sth6AWGoGToNVGxO\nBtCrEsMCIHilv8NrjGd6OW/ZUr0b8lOwJuqZwzKNPmyqO2JP9USz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2107", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2107` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAVwRYrh4+vDEfJl046gDpG6AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExMWJiZWMyLTQ1YjMtNDhhOS04YzM1LWM1NDc1MDBhYWQzNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU0YzAzMzItMjJl\nOC00NzJlLTkxOTUtMWI4MTQ4ZTRjZjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElC2TqBPCLVK/m+IiRNZWVwrC5/DANjyCRBOJqgLYE3CePVSGrSDQWacBFZOt\n8IwPs5gwZJ+n8628R97l9yJXS6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNPrvOV9vjK0/2uxmLCCoffOPCL4wHwYDVR0j\nBBgwFoAUVrUlcsSziEC/EqsJsmK8zQsplgQwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIHzuNgJAIoJB9rwi2AwZifkAS4bs84kmeoe3ZTUvIvBcAiEApcJfbizG\nXSMMd4HYtGYApQgycoD3dsWLbrz7lyQLDFk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAceaYENDR5W6WDWmmR0ySqQTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTFiYmVjMi00NWIzLTQ4YTktOGMzNS1jNTQ3NTAwYWFkMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATR3rSRWo0Ilyoce1i3jYxz4eg6j8U8LRVRZKVBr/IfwaRB\n5bLgQhIdE+X3p2XpKmF5GPOOv5UoAUyeZOBs2J4Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVrUlcsSziEC/EqsJsmK8zQsp\nlgQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNcdsMK37VFgisntlg4AziYRfin2pKAd1jKuuYprpZH8CIQDscHswyVoU\ngBy9AkeYHrb0zkMwkVj/o8nyacTtxPsiLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZWR9GSepYt3IY0hzO6Ic9rYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU0YzAzMzItMjJlOC00NzJlLTkxOTUtMWI4MTQ4ZTRjZjE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNTA5Yjc0\nMi0wZTZlLTRkZTktODBkYS05M2M4NTNiOGQxZTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASk9vwbASVR8bs/8kai4rJxZU8/9MAiOErChj/hlG56nTQEV3T4b8if\n44Ug9JG48OxXXrJQFWk0zWNJCI0rU02ho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ0+u85\nX2+MrT/a7GYsIKh9848IvjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKl3IDLua5WFIw9gSwYEsjG4U+ZtzhrTSWiD\nj1ia5Hb4AiAdFFP06tUl6tzi/NjtxNSGDoz/nCx5QlRgaLo0Q0dpIA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2108", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2108` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAaMTgYnjXu7zybwxrDZzwu28MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwZTM2M2E5LTNkNGMtNDFhYi1iMmJhLTJhZjMxYjJiZjI1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjIyOTlkYmItYjQ0\nNi00YjlmLWEzYWEtMzAzZWM1M2QxZjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE23a7SKbzeSRUvxbuyNb6x0zrqHo3h2iYzsPOc+2SEToR0b9I3+UB8YVBI1Vt\nLhatGq1MMhqhvc8ozZEMcSJvaKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5pzG1DISi2cmPGKKarl5xyGaFG8wHwYDVR0j\nBBgwFoAUlvWFaTZb1AxWFymkKLyyeI532hMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIB87AAmmZS60Nmrrj8aYEJpxOrr0wODD56P6sEwi\nTbDvAiAEPjxZr7q19oTXv0kMxVcl3qXmKDn77YerHvpSrKIBdA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASQ4a7OPZWFPqfTxm6N4q/VgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMGUzNjNhOS0zZDRjLTQxYWItYjJiYS0yYWYzMWIyYmYyNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMqvB9QPsNYuJ8TW2h3HLh2HBEy/P7MW7GFvhCt6Oq+3XK\nI/pTT4pRMid4A770Z9HuIVnAWCphSD+zEn5mePEDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlvWFaTZb1AxWFymkKLyyeI53\n2hMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMQ70ksYeKwiy5K/ZfeEpjkVKzRMJ3Ddpw4Dh7QAn7c7AiEAtLFNEaa+\nO3kM/EQ8gRb+bJBVUBilNnB6r4BBwEQf4Po=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISATToyfZbVtY2TEuMYI4ANg9PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjIyOTlkYmItYjQ0Ni00YjlmLWEzYWEtMzAzZWM1M2QxZjBkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MWQ2ZjM1\nZS05NzFiLTQ4OGQtOWFkZi03MDM5ZTg4MzYyNDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS5DOztAegb+W7a13aiuzsjW01XBS4JKMomOJ2eGBSXzxVWy6wtarlC\n+7lFr01IURux/SvgeuvwOB5xKUwir8aUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTmnMbU\nMhKLZyY8YopquXnHIZoUbzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgezfyNNIPqnqR/xpcsgUEeMpfxbceKJ0xgJLJ\nwaivUOICIQCtbpaXKdIshzWYpqTQGdHi0+OemF4AyX6PMlGQ0yLi0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2109", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2109` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAXoDhjZ97rY6jzA27MkQZbgRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2YzlhYjMzLWZjZTItNGVhNS05OGUwLTllNmQwNDk1MzVkZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI5MDg4NTEtODgw\nZC00ODY5LTliYTUtMTU3NDlhZjRlNTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3sj/xdk8t7/lY6N8AnFe2iMnvY8XtfDYbSGV9+y9Jie3gzPszZVQltD+Ai10\n5br30aMvsXGIo0zCjQQZMC3l06OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcHe2WaLL+hPl2WDS501+iPtk584wHwYDVR0j\nBBgwFoAUQ1i+bJ1HRwv9hMRdvSy/kyPEUN0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDtlqZTT2nkDTZT5l84KTutXPMo6rA4ONEph4oL\nd+ga+QIhAPuIxs4N92nuwl9sdKlByhwg2OphtEhHCZu4Gtq0pYyp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQXkv2a/iU3+Gk7v//E1DKI3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmM5YWIzMy1mY2UyLTRlYTUtOThlMC05ZTZkMDQ5NTM1ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3C9/8W7pILhvINAmGMuyET5RX1eD7Z/kAbljNvMZBRK+k\nzXlPKiLWKBBh0j0NufmZgaIGRW0vXMCjwQF1uInPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ1i+bJ1HRwv9hMRdvSy/kyPE\nUN0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFdIjQNBAjOWdFvboL5vwQoVH/OVJbuWgJpMmvUXUf9UCIQCt+rEGUISc\nVYvco0r33fsJbfLpcfrK3/YkSNtbCfVlvw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAd6XNSLbBHXCjyXV7z2kACuaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI5MDg4NTEtODgwZC00ODY5LTliYTUtMTU3NDlhZjRlNTE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MWI1MWJl\nZC1kMWUyLTRhMjctODdhNS05Njc4NjA4YjhhZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASPimZPcSSOmhjWWd85rxzM3AyeoohQZWF4KVQTfop9UDhPk0mxI2/m\nuYXHas2v6+mdNKXDpuIYhV52GDaP5Wrgo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwd7ZZ\nosv6E+XZYNLnTX6I+2TnzjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgeg4pUFkcTs6x9g4QnuXTmu36Ar0Zrv3Jck9p\nnI5DHpACIQCupb/3S3FD21Gvg/3RP4GgDV03OKWs053A9H8+mmOoZw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2110", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2110` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAQt0OC+X0P29yCt6vYwTUdC/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjOGY4OTIyLWQ3NWEtNDIzMS1iNTY3LWRjZDM1NTNjMzliYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY0NGVhOTktMTY1\nOS00MjZlLWIyNGQtNzI2NjgwNmM1MzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOVgDbvjbC2q467sIguUo7W/wuAIX7My+M3w4212Pwk4XYstZnY3V/BRm7XXV\nzEyJ2Igv4ngLljwv4NbuUZSuj6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmPsp+hLre0fiMTs0B7GmniKDnfQwHwYDVR0j\nBBgwFoAUAbAWQnnkjlvGjNSrF5kV39OZ1d0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIB9kjhMS1yUHfgVD04P+oeVvXPkBaC2UyoI6a+EO6/rbAiEA\n+JoQw6VkhETCgy1kB7n7KQHcZG3zKhDwv+qV6A1ZtQQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfOzfovAn4DLgL38iVzH3GgzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzhmODkyMi1kNzVhLTQyMzEtYjU2Ny1kY2QzNTUzYzM5YmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0SXTe+UOFNTVPQudr52mdWjaPxoH4RHyIfXRSozPMdXSJ\nnOmXu+h+dKRnKNSzRYiV6xtrdxy/vlzIjPqIUpapo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAbAWQnnkjlvGjNSrF5kV39OZ\n1d0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK72SOtqk2+40yCGn9CpLRG4bpULayo0SXVmbQZLV9rtAiAKdZl7WJ8+\nhEl19PStFFN0qfZ8bmx4TDRUebwwBBhLEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAY8CUwh+daSmzFAxcBoTBviaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY0NGVhOTktMTY1OS00MjZlLWIyNGQtNzI2NjgwNmM1MzgwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NGM3YmRm\nOC1lNzYyLTQzZTEtYTYwMi03ODkwMzQ0MmZmYTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASMzZy+Xh+MF1De7rQFBwDmyFjX114dUCJSoI4fbJbuSippfTmfXy6x\nCsr4w/vWA4RjPSxj1rAhOeICOIip84lJo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSY+yn6\nEut7R+IxOzQHsaaeIoOd9DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgBPaxb5l3AjmkaSabrA2L3QGnwuLQq6weTRRR\nKWz7wV4CIQCAn0Oe3/++GyWm1ivw7GSvk+LLVeOQnuhXqCIVCD7+XA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2111", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2111` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAcfU8b8ZB6E+fPBou8PVuLzaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlODcxZGY2LWJlMTYtNGUzNS1hYjc0LWIyNmUxZWYxYTgyZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDVmYmJlY2MtYjIx\nZS00N2RhLWE0MWMtNTJmMzJlZTM5NjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEye8xp5o16s+HwpniSqGf+mDCGAf3gtMJki/Gp98VlYLzkGEA3pxiN3f2wBsR\nmDSlC3cfjage03s5Cb1sYffi5qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFe13WKjdnqDkNoIf/XOPEtjvWpYwHwYDVR0j\nBBgwFoAUNZZVpyLEPxxEt9dptncsOo6viF0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDZiBwiti+IcI4Cz0Ze1dLcVjzMwi33\n+tVf00JAXipQ9QIgex47Ve2uPHKNcy+/TJ7IsfGY9UIKwF/wnSeSVxNAdp8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYwmrNG4Y1e5Wd0bNA3rrRuoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTg3MWRmNi1iZTE2LTRlMzUtYWI3NC1iMjZlMWVmMWE4MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyz6Vd6eIUkZC9Ay7/lNfuPKN7lAZ6RenWPIaQRry1D6+e\nP3vOZticUkvqaWPdaUlGvHmQxiaueeQJFUjMXDmko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNZZVpyLEPxxEt9dptncsOo6v\niF0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSpo5+RRqt2/+jdFpvArxhuLfZe1WD/BqPsguvoTOv50CIQDreMFjvOyQ\nd/JDS6+BNmucUym+wcK5IOD5NPqJ11SpCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAcyXKw4haYwCLEcJQGgv+3Z6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDVmYmJlY2MtYjIxZS00N2RhLWE0MWMtNTJmMzJlZTM5NjdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NzNhMmYy\nMy05OWNlLTRjMTgtOTM0Mi03NDhlY2NiZGFjMmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATEvhCGMa9fkVLh2yhGDjok/PN9Al9Lof3pTHtkKrZ9PDMwh9yMtK07\nrBrtzoRWTghdYJAHvHXjY7alxFNK24Rco3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQV7XdY\nqN2eoOQ2gh/9c48S2O9aljAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgQXgJk9gQKQ322JkElp3bLaceQ83DqO6/mwHc\n/cHRjf0CIQCZUwELB3Kc0bNOKrs2Axb2+iof10FsYbdGGx/tkoJKfQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2112", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2112` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISARB0onZEf7TY6EoHWLD6SvUaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjZDMwNTEyLWU5ZGUtNGY5Yy05MDljLTI0OGM2NzJjNDVmMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmYxMjgzODgtMjEx\nMi00ZDg4LTgzZGItZjBkMDc0ODA0NDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3C5eaxm3qQHxqFJjx8fxRiJx19HM6NKrE15A2+e+EjqtXWsQnnSDaT29pHan\nvWv4oJ+v4BZ5sNQSD2EWIs1axqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtKMDiHN4bwXX4nF5lrdvlnc9FS4wHwYDVR0j\nBBgwFoAUL/2RBbQLND5MA2CJ09YaFJWGbpAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIC9K5S5Gpm9jH1Tslztscuoht3VWjDN3\nXi8AouUoc3ptAiAJBwnK+smFjfMPTB5FnLVgMLUjbfU3YqTIOQcCmytx2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfj3YONctXVbrUQzi8ZhUDWtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2QzMDUxMi1lOWRlLTRmOWMtOTA5Yy0yNDhjNjcyYzQ1ZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm9G0CFqyLhTowXdp6VFG4ROmGVFtyD/a4j9oN1BfANGCg\nJe8KKteLGsy2CUG0jeNBo1bRVXzq+it9Ww8sQZrNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL/2RBbQLND5MA2CJ09YaFJWG\nbpAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIAQ96dkYJ6gGZaqsfjWZd1F3RcCP5hPMVQIgKrhoe4LAiEA12BmTXVX\nY0ZcZp5jZxzs4XCjI+Wp0nQ45DRk1nNkwWU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZiraQX4O0WTowMgHLjfAjPzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmYxMjgzODgtMjExMi00ZDg4LTgzZGItZjBkMDc0ODA0NDI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMTU2OGM5\nYS0yNjNkLTRhZGMtYmI2Zi01YjViMDE3MGVhMzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR5RcL7s5XHAlZC/s5CPREEPcIqldDkcaQiGvh86O2SYQkZZZqt/yeQ\nf6O8KLDB3bncg261JDLI/Uksam4+Uw5mo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0owOI\nc3hvBdficXmWt2+Wdz0VLjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgWy53yJ2blks9osRUeFeTYM13ePNA2wR1qDpU\n71j9jTMCIQClUk2/1vtUJdvYOWWQHelhuuGt5jkCi4HPIKMmwOviWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2113", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2113` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQLH1gwqsPD+ZXBhtjiymoJ9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjNDA3ZmRmLTE5NTItNDIzZC05ODIzLThhMWIyN2FiNzVlZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUxMTExZGItYTlk\nNS00NWRjLWI5ZjEtNDE2ODU1MzA5MjA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc6arZbAvI4Xd7HOCNzCs/eQfAfHMiVoWwwEtXHOXJGWV6OByobHRSA8xMm8D\nnePeelnSLk91ozcQJE8AqOkfdaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIHlDxAjUsG+nVcHaVhGzqLhb4u2MB8GA1UdIwQY\nMBaAFI9Sl/eisI1R36mpL45FM2PDwx8BMAoGCCqGSM49BAMCA0gAMEUCIQCghcOS\nfRMv/8DGaJ2o0peSZHOFOruMp68mgehvF0Qc+gIgVBYAfwulAMsL89IW2hqOC7z7\n0Lxw0jhghVP61j12H8M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeDCZODITcbpSjjdo8wJHvGVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzQwN2ZkZi0xOTUyLTQyM2QtOTgyMy04YTFiMjdhYjc1ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfLVFRc5fDLfxMwuyLMRNwqqcFWPvVh7CkpbGjIWQyGJBR\nAzl3EfPQIqUR/vr0k1IB/+XEgvz+kx/S3b6kHqGSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj1KX96KwjVHfqakvjkUzY8PD\nHwEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKqFZGrVtM5xQ8Ss25nbSzyTVDbDnfjWnJo0H+vvq5hTAiBK9xGqB9bK\nDVFhFyUVDlgBuBIBgjcws+6rTR4HI2BoOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAV6+mJGhNT/G+smR/nHkc1VNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUxMTExZGItYTlkNS00NWRjLWI5ZjEtNDE2ODU1MzA5MjA1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNzZmMjdm\nMC03NGNjLTQ0ZGYtOTAyZi04OWY2ZjEzNmFkNjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQlLFoXJmDoRJ+1uyZ+SkClj3+z2VjraA1kovu1KCGqCqY9nlPbQxS0\nHMZjLJyEQInj0Z29M4drQ429LIaWbm9Wo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSB5Q8Q\nI1LBvp1XB2lYRs6i4W+LtjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPywlXyyLjVpwvHWXAw/P/bvT1gDgdXnj5qp\nS+Z1Nl7JAiEAs9cwJdwQl5h+DZzPr7rQYEDNBXPNZNzUkXBpGp/hRMQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2114", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2114` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISATL0wtRBuXQijOkhF0tKB7/1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzODBhZWQ1LWU2MjMtNDIxOC05Mjg2LWI4ZGRkNTQ2MmI3YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ2OWE5ODItZWYz\nZS00MTJiLThmM2QtZGUxMjkxYTFmMWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExb1MFHV2kfRkz/bLR5Hhh141Y4xN/oIJhcmnyWUvHe//P8KlMlrZPok8JAQy\ncfEArX+7upFlUorg0WXic9Hfp6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFILZ7rAs7dtGrj0cwSlbmPL91JhPMB8GA1UdIwQY\nMBaAFFHkZFkQ8yk3g35kyxurN4kFZdcNMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBQnU9+DOKVF6NjGgBU/lxfts9qHUojV7xi\neaAHhcBTxwIgFolsSirqY/F5T4vB/R2hzm3Tsnq1WaR4PmM2t1AJpNE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYBgq+yLm9WwVccE0bUyWaGgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzgwYWVkNS1lNjIzLTQyMTgtOTI4Ni1iOGRkZDU0NjJiN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2XsDDSXxXHaAoYpwnclZyHVbSZJt4KSzvopEqJFI7b+AY\nYW0ivK7jqQJUOYgZn+8YcwLzYMvUZdYm2+wrbMEpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUeRkWRDzKTeDfmTLG6s3iQVl\n1w0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB5bfR3uwYJ8/iPO3SrG6quXv+58nm/UFZPacmMhCimcCIC25nSOklle4\nymPoepMUUP42otgWvKjhVwR88InMLgPL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAcaHdZFlUhisnAxqSMHXArvRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ2OWE5ODItZWYzZS00MTJiLThmM2QtZGUxMjkxYTFmMWI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjOWM1YTk5\nNy0xNDMzLTQ1YzUtYmJhNi1lZWM4NmRkNTE3ZmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQqbp0STF3vSzlZ30RCFOqSH1bx7WXKmZeWK7/JH8+m9Ub3O/ssdZGZ\nDJfZYB+1E1PQw3GfJu5La7KlBMeFwNjRo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSC2e6w\nLO3bRq49HMEpW5jy/dSYTzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgBmj9mQB5IXk8IsktNw8D/w3CNS7P2C5yuRgQ\nF+7l4xUCIQDNKQ0+MQg15EldadpxUyaBCLiKvqf6XbfWE+PHkZTfvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2115", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2115` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZeAPZRB7xFs4GgNlZQxKOExMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MGNmZjFkLWEwNjktNGYwMi1hMGEwLWJhOThjZDVlYWNjYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI2ZWQ5YTQtYTQ3\nNy00NGJhLWFjNzItNjlmMmQyNzVmNWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt+SqqqI4TwYHU5dsB5LhSTxNXNKbxGb2YlE4hsqQEmFRYOBK/1zeionARk6J\n8ejvaw1995FugLuvb246PmogiKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEaVUkvnFpL6VXM/24D7/WY0IjMAMB8GA1UdIwQY\nMBaAFEZmlYet7LtJGwu7GSHV64+H2tuOMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiABpXFyo38ELxQYmqc6F4vF7gm8+xU0G0d6\np7lAFA9jtwIgOQbqjTYMOJcpungw2vLmaWihM7fN6aYI43/lLKYvj8A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAffkF9PrYt6xmbkatgPQWKRHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjBjZmYxZC1hMDY5LTRmMDItYTBhMC1iYTk4Y2Q1ZWFjY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1OZzXcO6lKnUlOr5TjIpH7vkfcwUMN9fyv6aCnq8BLuNu\nFylP5goxYS9aoyyIem0B94D/ZyojW41aPnbZwvsbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURmaVh63su0kbC7sZIdXrj4fa\n244wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO7zNBE/CE5dCNBnhF4cNkRlUCaYLnkL7k/+Vkf++AgHAiEA2sXHH8py\nrNEzMlLa9u7qxVcGbL6rfKe6jHgfKqdYqfs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAdBcKPK3PvSK4L3h93lGLzjiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI2ZWQ5YTQtYTQ3Ny00NGJhLWFjNzItNjlmMmQyNzVmNWM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYzI0NWQ1\nYi1iMzdhLTQwMzYtYWVlMS0yYjdkMDUwNTliYjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQHypHTY4t9v7KE7uLrZtc0a7z6gKmUycDftXANODA4N1IuC6Ld9cyt\nCa4rRvtKCM4v14UmFC8NWLue+N//QVf9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGlVJL\n5xaS+lVzP9uA+/1mNCIzADAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgZbB0bGlHW8Ac10qLW7zX2tCnHzp7M4zn0v0u\nmrFfQUECIQCWuUWQn5toWD5eYSy0ndd9U+UecsT8qiS90NprKNh5Fg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2116", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2116` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAR7mt8IOaGuKU1/MznBG/4eEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2OGVkZDNiLTUxN2ItNDE4Mi1hMGVhLTMyOGU3MDEwZGYyMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEzNGJiNTctNmFi\nZi00YzQwLThmYmEtY2ZhYmVmZGI1MTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5JmTU+seHLXZfU9zvVUDRLIlmuG4kNAbxwAIglnb7aM/J1+HpHUJTjjCmIbX\nvWWw1840biYc+oFpHmGEsmfLiqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQK+M25xR9SpOcVfviQdzaLDGMd1DAfBgNVHSME\nGDAWgBS2fjdqUJYFkDyhoub0599kZHztojAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCavzdEDrHyCqLGAuQ4qKmgXwB3ZU50\nBRO2LbXI6/9YLwIhAL5wPfg1BY2GOmNWRVJy68nWt4Qx9cbaLkNd58dTSNlZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa0VpWjFzeFqWosDMuwPMEsCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjhlZGQzYi01MTdiLTQxODItYTBlYS0zMjhlNzAxMGRmMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASf5408CzJE2IUHXi7lKAk7f/oO+fuhiWlZIjuRHfhyYyQn\nggEzXOc8E2zMUiqopcVhBaKIHbDRQXEwD2ZvAQT4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtn43alCWBZA8oaLm9OffZGR8\n7aIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALt2evS2dWULf/2ggrMYAbHS7+fXPcYGTpHBL7DAVg7RAiAZDIUDnRDr\nJCX6/74/guUQTEtomLP6iRInbZGh69Fiaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAcofbyTzv2wnOJRgvsJeGq2LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEzNGJiNTctNmFiZi00YzQwLThmYmEtY2ZhYmVmZGI1MTlkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYjRmY2I3\nOC0yOTg3LTRkNjItYmE0ZC00YjhkZjkxMjM5MDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR2Vy/SkomLXgj5kkBoGt0KplOQawf6BI8MlWEzOGuDpcQcIbL9sp1C\nBMczdKWHdjv54kM27qFUhfT5gyWfHyYAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQK+M25\nxR9SpOcVfviQdzaLDGMd1DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPKTECwV52rUe6qJTBj4Y+gk/i1pwruyXacM\nwqmRn3mvAiBbSLHMx5lkN5+XJxqwBZrnfqnjINMK40bQmtsoTy/Eow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2117", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2117` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISActWzM6WsWGa1PQibBqf2uU0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0YTZjZTM2LWJkZTMtNDQwNC1hYTUxLTk3YTg1NjA0ODY3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBmYTZjMmItZTA3\nZC00NjIwLWJhNmYtNzNhMGQwM2U1NmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu2rgN6r/+4AGhRouuvQLQVTsnfVy7pczpo36GXi1fBX6mD3hB88td8zE81la\nFK1O5Z3RmKVUae925qyK0A9eqKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiVZciDyQGzI74swfiqAvXSw68pUwHwYDVR0j\nBBgwFoAUgYxWUhwJL8OgKBBABQv9bvrGOPgwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA6RA4mpqsmnbj\n9aK0HzcLobyqiSDyFJKONlHul69awcgCIC8S87AsAc4Ki8xBh3uNdWBgh/CVlTzY\nCzwrfEoo08+2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASuXniybgGb5ohvYNELu9TgZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGE2Y2UzNi1iZGUzLTQ0MDQtYWE1MS05N2E4NTYwNDg2NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv6Qan5OQANf3181FYwAsnGuNm98GbvHIeTsMmjAwXk6YI\nyGfhwtVRs+KCo3XWe1Pq8XBiTgpEqlOhgd7cJbxno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgYxWUhwJL8OgKBBABQv9bvrG\nOPgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbLYqN277Sf2cgpqGx6NfdydoUNvrUkjlPR9P6xLji6MCIGBX2xF+dBFo\nGun8g5Cps5Js4JM9xhESqVszaHSemITC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAT05iW5ZnvPWAxydb0smPSrqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBmYTZjMmItZTA3ZC00NjIwLWJhNmYtNzNhMGQwM2U1NmRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxOGZmYmU5\nYi0wMzVmLTRhZTMtYjk2Zi1lNDFkYzc4NDU3N2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATiy6pxokJ2BZMwAEXBAxluPI3ZihOb1McUuPrk+U0pC1CAem7Hg6Qc\nmVG13I4aCtPK0tlunYzHMcAIxeqNmY2Vo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSJVlyI\nPJAbMjvizB+KoC9dLDrylTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJ/BnvdwhGHmWpqJPFTXSdDIdmvzd4LwBf7F\n9B9DWieWAiBdxUEIdPcITwITYPWNFdOcxMhj5uEn+6Vuq2XVABRnuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2118", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2118` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAceOtVAkiH16J9dnGPyw2AEWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1ZTIzNTg3LTI1OGUtNGEzZC05Mjg5LTliNTAyOGI5MjEyNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU4MGU4ZjUtNWE0\nZS00YzM0LTgyMjYtNzNjMjE0N2U5YzllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBgovMPZcexaKRRl0p4/DRDCnEmBQywqmyx0ZwzFu8vXmcArSaHdahwDfRB6h\npkxqOVB3tb00UhrFYfJC9A+hVKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFtGQQIFJOQu+o25LKQWcT6pHJp8wHwYDVR0j\nBBgwFoAUQPQpne3DIEnPLLWQ1nHNGqlsiUYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiB2diCITqSA40Uf\nSC9JqrU4VyRSsKzqcwHncpytTVhgcgIgRmBDk26MOQ6DmZgUhVARqs8dmzRsmh0t\nptQkTYg62TU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf23BoyEFydEd4L6HXOZobMtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWUyMzU4Ny0yNThlLTRhM2QtOTI4OS05YjUwMjhiOTIxMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgV9KyobCCUi5x2Au2QujJLQ9uBX+ktcaUTJZEwH7X0pXP\nAKNAOVWBBfJQ8o/Hnfrk78m48ssl+hGp97USyLUyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQPQpne3DIEnPLLWQ1nHNGqls\niUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKOWldSBG9E484nLcxhfINqPAmFuL5jVOQE+nlLK8+S1AiEA9R2K2WFV\n7IvTlNMX1fxDJU449zM4ckr/NWQBbCxVNZU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAU4RMs4PcFExQdYHFcU/4NyWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU4MGU4ZjUtNWE0ZS00YzM0LTgyMjYtNzNjMjE0N2U5YzllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNTg2MGE0\nZC0zZDM3LTRiZDQtODFmMS1kMGU5Mjc4NDRkZTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASTk+SX64U2VrSRBUnSMWqfQKjBBUnIRY0jlUNM0kBvOcqgT2rH/nA3\nrJE3MElffDQ/cfuadoua6vO4Kzpq70pso3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQW0ZBA\ngUk5C76jbkspBZxPqkcmnzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgcR/GoJiFOrrY/QajQlQdDgakPBTw4sS6By3C\njM3fm+gCICtcthVaBCyadFFmAOajK0od3yampYlDKOOBoLe0UKTS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2119", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2119` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAUcvcxDmAov6+FXUAVeInt+iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMjhjM2Q1LTIyYTYtNDNiZC1iZTU1LWE2ZDI0MDJlNzEyZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM4ZWU2MGUtM2Ex\nNC00ZWI1LWJmOTItMjg0NmMxNTczZjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELCOxm8W/AwUiLqseNDZPAlEroGQ9emDkSnNNosZjNhSE6gsm0sPWedX5zPo2\nLG/KVu9ALnXRcz621pMU9iI3Q6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOQQwed6Z0A5xNAbP9/lFK3b6k3gwHwYDVR0j\nBBgwFoAUboArw3vuoSCGQKn4JSPhXB46xuUwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAsYGD2p786J+NWyJYnmSn\nzbEtHoImlLuqcJr2DN5+7VoCIQDZLGR0Wa4QwZK6WfVlJPEL/1SbiFRueyYj6nMW\ntrLMmA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARC9KCK1Mp/Ur7yjvtNtM/OZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjI4YzNkNS0yMmE2LTQzYmQtYmU1NS1hNmQyNDAyZTcxMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQC3Sp8ypFINR8BR/ynWg67tNbKSdLVnw+K8H3urHu5w4f1\nxSEy5ZxZeXRF8iZmcAfwQWPtffg0tN4qT8F7TdHXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUboArw3vuoSCGQKn4JSPhXB46\nxuUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGiAvh1TVMZZAvRES+6lZBpAUjAhnUQ3f6/FH1NN+uc4CIQCF0XlOf6Ws\n4/2JmAwt6C8ZlOAimnUDiDnp6leKH4TqyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAdcbHPWeIFgjt3xyy/FOEs2cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM4ZWU2MGUtM2ExNC00ZWI1LWJmOTItMjg0NmMxNTczZjRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYmQ3NDUz\nMi04NDBhLTQ0YzctOTY4YS1hZDk2ZjJhZTM5N2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASAInDOGpyLpePqJI4UnRzjEcWuzWLN/ROG82cRID+qQ4j7Dt3xssqf\nLby0A+5dS6BNymdW83YZyzUsNmUOUTWpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5BDB5\n3pnQDnE0Bs/3+UUrdvqTeDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgMMW6xl8ecG5aM/St9yH8GT9KT0MzfKgoeQ4U\nywrPhuECIQD4OTFLQUXIAOI9iWisk2BkteQ9khFTgI8PcuL7HtItnw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2120", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2120` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAYWOxZCckhPYSSHTPuGbB3PvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzMGIwYzBjLThiZDAtNDBlMS1iOGI5LTJkOWIyNTQ0NTAzZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhkMWEwODQtNWU3\nOC00YmY4LTliZTQtNjI3NjEyY2ExOTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp/r+zRlfwNEB8Cn0qXC2Ly2B9RiMmUvddD7HmH+ENzWdZucjUBPOE0vT1QJG\nGeUMyqM3x+dPVPJLnKcWMovnHKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6tMvmJ49NaE2BHTwMr/qm3CJbI8wHwYDVR0j\nBBgwFoAU01UJkEBrHsD31JtMoWe4XA0VXoUwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA5Aac\nHv+Bd/GYxs9yPOSfOfQLjOZQ5JK4rxa0FoW0pmYCIFPKwkGQr23B2EYFCNMAA+MR\n2yCoE9zoqgUz6UWfmPf4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUzbJkh/rtTVy3uv7gqPrQIkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzBiMGMwYy04YmQwLTQwZTEtYjhiOS0yZDliMjU0NDUwM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZPKqs5+hr6aBcZiPEJBiZWPPqs6507+0irnw3susgMPxv\naQrjvg4pVTo7EFvS9ajq6bbt5BJwcDVo/EixavFKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU01UJkEBrHsD31JtMoWe4XA0V\nXoUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJRpNGkcmN6OHH9/e387pNGImlzekoOj0Ftj+KW0PQgpAiBE2T9U7qQV\nDZAFwgrAaAZrwCglnu+aPRFHWxbOYFlSMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISATjpcxCP2CzCc8dJ0yMAq3LCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhkMWEwODQtNWU3OC00YmY4LTliZTQtNjI3NjEyY2ExOTk4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiODcxODlh\nNS1kYzc2LTQ0NjktODJlZC0yOTUxMTdkNTY2YTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATQmOJlMVF/5q5Cht2fxkT14EbBdvXhmqFNahbPm2eJB3zGVIZcjAw8\nZQ2MPdqSG7OC1pQuYHog2byiSwnH7bquo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTq0y+Y\nnj01oTYEdPAyv+qbcIlsjzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPhv3KGstem0CbHpqKJS2JlT9pWImQjKz3tM\nwUyN3I1kAiAltOD1BYEsnywpG/8NruZrW9VIem07Dye/BQC+7vbtIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2121", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2121` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAdiWiSMMVaxn+oxOjvMXLjD6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1YzlhZDI2LTJjMzctNDcwMS04MWM5LWVlMDI4OGY1MWI1YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlkYzNlMDQtNWJi\nYy00YThlLTg2NzEtMzI3OThiNTdiMjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErrr8waZTvzUxEgkwFVWYzRoA7DmrC52XQLmtgUgvCD789T+ZRyMtsGp0WN/G\nhBFB0+XEKm8DkPk624cJ/J7CkKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs6ArXElQ6wiUl+AO8Q+evx0lVgcwHwYDVR0j\nBBgwFoAUbD4H3bTgx8xBqkCsksJY/KpyDCIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBnsBc2\nhZqtgbc+hkSGmRr/nALuD4Lmhq2r4IZDaC5bswIhAM5h4/sBMSXlLLyTG07vH7pm\nqedm9LdjI8RNW5tmgVes\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW82EhikxBBPcRDFiU6OuIERMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWM5YWQyNi0yYzM3LTQ3MDEtODFjOS1lZTAyODhmNTFiNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgCRjLRFD9ucJuyL0qB8vgOI1LtrMDvrBlcUqtyuKJAOlc\nt7D4KIArLWMBRPk4vdrPP9yReH3mknwDiijHq+9So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbD4H3bTgx8xBqkCsksJY/Kpy\nDCIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEGnGH0r9dU0CYja01bc1Vy/uPtiGzjH2gyYRip4W1nUCIQCeh0YNxvkF\nYN0ooCk3TUuHG58/WV8G+ehhNVBTGAfj/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAZmXmlh80OlK8CYkmQEvLQjRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlkYzNlMDQtNWJiYy00YThlLTg2NzEtMzI3OThiNTdiMjA4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZDQ3N2I1\nYi1jNDg5LTRlNmYtOGJmNy1mMTdhN2FkOTc4ZGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQBFctOv9yjxBLAWAnxbX+Mk/MJX0u09T0iwS3P8HjYMginYnWr0OcL\ngB/4oFzlrO+KZk9qiVypvpAuXw+JJCKFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSzoCtc\nSVDrCJSX4A7xD56/HSVWBzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgHOGOkEhACm02aGDq6vKwG1/T04wvTz7Lrzq4\nXmJ5pIACIHhPqrz/7WG+uoxEVKOgx9D7XRYUZKNA10tUgPmm+WuW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2122", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2122` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAey3ZRp7Q/NDzzPRuC8m7hHUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjNTNiOWE2LTgyMTItNDRkNS1hMTQ1LWVjYmRhYzM4NzQ3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWVhNGEzOTYtNmY3\nZS00NDc0LTk2MmYtZTVlZTNkYjZjMjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH1oi5ryrXE7H5odRQ7So/VoEBRsv2kx8ESS29moIXGTdpn1MWAxduhMxf5OM\nXz/R31C4yKGGSlnx5w2iGlnxSKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNZj4Vm8OJBCHdTYiSgkmBhTg6F1MB8GA1UdIwQY\nMBaAFGgqEQikX9SEhrW1VvXSnlL2UsZNMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBWujMVDrKfpHvvpBFOJITG68zjVg56erI5\nTcV3Jy1nSwIhAIriPjzqHQqmTi+GCtZwuIuRvU/1c9EJuw5KQGpi2KCE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR4hVHvADoUcaksvLb6rtljeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzUzYjlhNi04MjEyLTQ0ZDUtYTE0NS1lY2JkYWMzODc0NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRTW7TSnTfupt7sDNsvAXNcMDbMLFtQLGUuratSXYMYMNK\n4o2i3pzJGrLWbxU4SVzSxaNQA5n3G+n0U75yEGapo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaCoRCKRf1ISGtbVW9dKeUvZS\nxk0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMljQYSO1F3IbixjgMDMU0FJyCMeJeslxjF7nSvH/swDAiBXXZK9JX5G\nO7CaFs0JxPZOxXx/yLLpk0qhghTD350h/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWVGYEhLgga1fZZf43xN/DqnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWVhNGEzOTYtNmY3ZS00NDc0LTk2MmYtZTVlZTNkYjZjMjFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNzM2ZTdl\nNC0xYWEyLTQ0MDUtOGMzYS00MGRkN2MyZDdkZTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATJ9IWmE1GpnkroIkAeW2H9nzTd4RSXdnLFcUiPJ/V1vYyFMszwUIl1\n3itsSxG4MVw6gfZusuhRnDClqBys7kgxo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWY+FZ\nvDiQQh3U2IkoJJgYU4OhdTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgeMzFECXPlyw1cfGdEsfvGIXyNW2RJYsNhjUn\nVZkSEz0CIQC1wI1MQSQpme0wlKf7i/kwMXXnjiHcqVgTFPcj7iD3gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2123", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2123` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAfTobGkmlNEaHm5xj+mnsA2UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhMTRjYWQxLWIzMTctNDU0MS1hMmNiLTgyMDJkYjkyMDg1NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVjYjdjZWYtNWQz\nOS00YzdhLWEwNjYtMzBkNDE2OTMyZTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdJsNlOjb/gX/vj3RZeySVDohB/JQUeWNXlsjiblTD2m5bkBdCVC1Ld7cm+nW\nJ0BMxThz6MfrBo2qYq5jfJGT96OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDnT/erb0ajKxpjFGH/gfwQsIEiwwHwYDVR0j\nBBgwFoAUq0NvPo2rjg81iic4ss05Om3SkKswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAI6RK+oTVO3j\nP2+tRsBLHDKzgOlOCzSSuQ3M2nF/ubsNAiApG/NIAQZQxnwZ4OQRMssL/TjiA80S\nheWoZDCtnMgVGA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXQMryqSEkHP/KdPBntRXFkhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTE0Y2FkMS1iMzE3LTQ1NDEtYTJjYi04MjAyZGI5MjA4NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdOs7Ry0IUbr+HBt5khSjdsvF3hqV4e4QZQ2Dw2QeZtUF5\n3ydMP7HscqxItImxfeHlcF09MQQXmvJ+L6a6x/Zjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq0NvPo2rjg81iic4ss05Om3S\nkKswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKct5GY4dB8txrUvjCDjJYRuBNxsrHvD9ULOf+heog7wAiEA3fIG0N28\ntaRItQB9o19qsHF2NB631zXLRRKLBM4faFc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAd5RuqNT3cC4V47bclDUgFHFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVjYjdjZWYtNWQzOS00YzdhLWEwNjYtMzBkNDE2OTMyZTllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYTcwNmVk\nOC1hZGMwLTQ2NjAtOWU3ZS02N2M4YTM4ZTY5ODUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAROURbl1vW1Aq+ZagE1kVh2vbyjH06yLNLhXEJjfs4o0oh8vzOar8VC\nUujUwo91rtOKeaN+rxk/32UtoLnNZBTxo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQOdP96\ntvRqMrGmMUYf+B/BCwgSLDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgeZy2zjimsw8/o4uw4ofBwb1bvUamfrkDdxKK\nxLEo/SECIQDz6zrufXCgBaZwBdz5wE7HkK1IEZzMe7u3h5DeWhtH7g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2124", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2124` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAc9TEHDh0UBbbPLKTwvSonawMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1MWEwNzQ2LTlhNzUtNGFmZS1hOWQyLWUwNTRjYjBmMTk3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUzYzljMjgtNTY5\nZi00ZGZjLTgyZWMtMzgyMTdjMDkxMTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn43DRBSatBRSRvfadrkh4e/Te3sUFkHjdXrtzFouqWomnQbhcBL1lkN56Tnb\nAeBPcLlphAHHo6WRYzAl1Avz4qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUvcejBAGL5yoa6jgNJ5GgwbRKWAwHwYDVR0j\nBBgwFoAUD99Kft4Ch7LtsrKqt2N08fnSntQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAM3570VNn4bu\n2m5/6opeu4vPD4aTQIxPOHzQvFo6/SWDAiAoWZVpRTjFqFBLEzISWIUw3OhXnwXR\n1Q6fh+RsRSwe2A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ4o1zUOWoyPc9dS+sGiRfZpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTFhMDc0Ni05YTc1LTRhZmUtYTlkMi1lMDU0Y2IwZjE5N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfcSWA52aprmK3hHbiSH51wZwbTPtwVV8IFXnvgm8d/6fT\nCEMnpZddIUKGgp91tbl0bzjxV0zC2bpQ/dmA+Rdho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD99Kft4Ch7LtsrKqt2N08fnS\nntQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC79rLLgGSDrrY0L+Cvbbefj/J87Xc66Ird9Vg2/tiEACID9Trj6tPGO4\nB8Xlh+N12YL8x2WCeV6EV8/uT1xMPvbB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAZDpoRe22ZM2RmqAH2sEekjiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUzYzljMjgtNTY5Zi00ZGZjLTgyZWMtMzgyMTdjMDkxMTM1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YmQyNjA5\nMi1kNDUzLTQxYjUtYmM2ZS0wNDg2MDY4ZTFhMmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATe3+05L39OOS0JP7gnlasW7ubMsXHG3wmQBRBZ/E+6+Yfb83VufU/K\nVwlpLPAv7/y98U1nHdriV7RrwdoDqNeKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRS9x6M\nEAYvnKhrqOA0nkaDBtEpYDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgCBE+MAAWYcWgKdrEUK4NnMlIYgFhcOQ2H/Fn\nZJdsvGECIAZPLREJjRY9I7wQWcXD925hkAoFiJIyl8GvwenXvRVA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2125", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2125` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZeHM8xeMb/DBmOQKFYYLi64MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4YjllYzRjLTQyMTUtNGFkYi1iNmM3LTQ2YWM3YTIyMjQyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRkY2QxZWItZjEx\nMy00NWYyLThiMDgtN2VhNjYyMjUyZTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/gf6+wkybbJnMktuxu+FOfQlOImnJ9ChxjV7EQn5vCSeJEK2R1hMsk/imLT6\nBK2mpwTM1H1RcT5dup5jaPT4yaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvGTh8zp57v/JU7/F+5y9nGW8GwQwHwYDVR0j\nBBgwFoAUyGEFriT2pMLC3mIqa+4IU8WfHAYwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEX+Rm3yuDH2\n88FiPJfzt6DntrGafT+lz/esQXMr3USdAiEAkHYXdPAZ4+RscKNteXCJz8vg5Q2z\nOI46jLonHgulhaU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXx9lrY8DFgCJZkgmrY41AUcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGI5ZWM0Yy00MjE1LTRhZGItYjZjNy00NmFjN2EyMjI0MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmTmFTAwY+W9vF4t5avLGm35L/+02AzMhlZGRYfNhQr0/m\n0LS27jJkco5AGApCL+NJeMxVZzmju6gvoS1ziQOno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyGEFriT2pMLC3mIqa+4IU8Wf\nHAYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL2iTpfaCowHSyyjrG7+RHuiThWJrQLI3l+RjOUSJedLAiEA8bhpuz7G\nRVxkJQijP8f45TT2Nl4M2Cg0E4dcdGTVW+M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISARLXAoqN3XXdKCtSpeEODSs7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRkY2QxZWItZjExMy00NWYyLThiMDgtN2VhNjYyMjUyZTRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNDhiOWEz\nZC03ZjVlLTRhOGMtYjA5NS1hOWRjNDAxOGRjNzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR56hvdYD+4BjCoiA2JiE2aXwjUIgZSVXfmIPJO9ESkcpJ8piAkoAXQ\nPoHFioU4qCq3j4d3W/YSYXgofw9zL116o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8ZOHz\nOnnu/8lTv8X7nL2cZbwbBDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJCK315MP2zLhx/8Y/X5sue99C1PidqxJMsW\ndTgQGtNBAiA54GJmbU8bPP+21SdjpLyQ4THZKP+BXTk6lUAIQ2u6+Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2126", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2126` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAYG0RY+imnCnYVWCVP5pXDikMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3MjQ5NjkxLTBjMGItNGNiYi04ODU3LWUxMjY4OThhMWM3MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDc4MjgyZjgtYzFj\nNS00N2I0LWFlMGItMzRhZDQ2YmQ1MGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBaFqIEPu/RNVFJ9ODV+wK++AklpIrU+FbxWeRBlSZFzVyBHspg4uCJb8Uc0W\nvHr4MUFh4G3TBaLaVpd42BN+l6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjppzKBtqHTzsmhENBz/4YDG9z0wwHwYDVR0j\nBBgwFoAUjgH+NV3Gxn+rVGE654S6vLy3ikwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCx4OuIUQ59hn8WQnRAPF/q9Y3DUEP0txRZnSkoEDnGGwIhANLycEFuv7Ke\nblIlO2uZHPlTkCeIq+riCjWpEcs+eKtH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUihjeJcIp9M9VG/Ob1MIx+kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzI0OTY5MS0wYzBiLTRjYmItODg1Ny1lMTI2ODk4YTFjNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqjflvsNyJ+L65MRhsySp+Gxcwiq7n7bgaltwdpi8NIqH6\nW55wTRQblVNwzbtmYREUTFEhZte+rTcSComopudio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjgH+NV3Gxn+rVGE654S6vLy3\nikwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKdAFPCsRuU5BK8g9r8B/o0JBfig34qX/kkz5PzBtodOAiEA4Cb3TAqg\nqfp5J2enf+ogMsH53+qTn2y4rOx4kAKo8r4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAaa/vwHGpbgRmGdX8Ga3ZEcuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDc4MjgyZjgtYzFjNS00N2I0LWFlMGItMzRhZDQ2YmQ1MGVmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMmU0NjQz\nMy1kNDkwLTRkNjEtODhhYi03ZjI3MjVjOWJjNWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQXMaFr3hTcywS5g5GtHFq6buaUAQV6EqnfK1AvCg7t04ltHxmHSub1\nH5jdk72mBADXuWhMtjqKVtBuDZ6HhP/go3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSOmnMo\nG2odPOyaEQ0HP/hgMb3PTDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgEesieIeixgkY+WVXPQsSt/EePLBHigsu2n4p\ntPWJnVkCIQDVeCgagOSdlOKcAAruxs0cCmXB2qxWYIecqQs/mjCuMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2127", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2127` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUEg39UHgSQfTEy5MTqL0R91MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4MmM3Mzc0LTVmYmEtNGJjZi04NzgyLWVlZTJlMmVhNmQxMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNkNTkxYWUtNmQ0\nMC00N2VjLWEwZjAtNGNiNDI4OTY0ZWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQJOJHiPBwCAnfMNKSs12WhlnZwq41EjnPUG/Dsk//CVFHIYSyF/+oZTvc4CJ\nnujBbh5QBJOAYffpVjy9IT0uoKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhML6bvmxU+yGHAPoqf674ohFWbcwHwYDVR0j\nBBgwFoAUDtjVzwPBjG7+BTxZzcXiJXGcBW0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCa4WwmBJHh4PL1zyjrENLyQJdx1glLejeYGC7s+kcX7AIhANKid9Yv89gs\neqEW4v1DrTKCAshGikuXYwLwphIjnU0R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW7Ltj+BkIDYC6DWRYwHXdVjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODJjNzM3NC01ZmJhLTRiY2YtODc4Mi1lZWUyZTJlYTZkMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3C2nWnHUXSzM7qIJpnANddYIcocMgIBB/XI/3GCJMcvXh\nmZZbDSkQ8BAXkPN+gFmI+G2xrSaTypErJORix7gto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDtjVzwPBjG7+BTxZzcXiJXGc\nBW0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCZ7zec0j5aKe/AKoHzO8dmuzSFXbQH4tSo13YZ5UfJICIEcuGARs7ucv\naRp3b8DwNXtL7xf/uUgGPzVfWNdI1hxG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAb85VKjjXN99DW/R3kWigkXbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNkNTkxYWUtNmQ0MC00N2VjLWEwZjAtNGNiNDI4OTY0ZWM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYzI3NWRl\nYy1jMzEwLTQwY2QtOTJlZi1kNzdkYjNkOWFlNTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQROZbh9vNlpLKBzRhutcThDDsXnvOVEhR7HKe/f87cw5AobEUEULSM\no6FBD7BqKwzm3jBadNXpCu8AFxOPi15go3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSEwvpu\n+bFT7IYcA+ip/rviiEVZtzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgKbhXjo3/v8bxhBY8RwfLG2+5i8N34phTl2X6\no+clEtwCIF9yS7/0+St4KzjvjdZX5tj714OyiTCbmYUTv+9pFCfu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2128", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2128` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAXLImCiFNnq8zV79VzV4g6yBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmNjRjM2NiLTRiZDMtNDA1My1iODEyLTYzYzU2YTliNTc1NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA1ZDA4M2ItYjY1\nYS00OTQxLTkyMGItNWNlYmI4NWIwMmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg6WngMltPniMyD1UNWun9/EwOUp5ee+pCwl7cwsUka2w5AOI7uK1kSqOJCKz\n08RJtrrXBi/xCOrMsN9GuD5+1qOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO/XB1vlsAoTg/RdHvKoJCPgR6gcwHwYDVR0j\nBBgwFoAUesx/Ftw6taIFMCZV7SfbOVcoOiowLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDMK\nz48qGbHsDlnuni0g4iMh3rB3NwNkUKXV+l5ny2vjAiBgqqPqsf/BXWgEoMjvp2Yf\n0q14j2C7dR1oXagFOnxoBQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfPuXk6v8/Xn15rtjVRqbwVyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjY0YzNjYi00YmQzLTQwNTMtYjgxMi02M2M1NmE5YjU3NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5gY94q7TxUsu+oBciV8ii+ji8Oc2Bpt7MLj9e8c+ao0y6\np5ehCbhYVU1KlzLlgp7HqavX5vlTtRVDpHAntb2ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUesx/Ftw6taIFMCZV7SfbOVco\nOiowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSRFn1ZOIPUkd2lFlbGm42ekAn3Lk8pOiwdQ9NZvDSwkCICae5sk+LS6z\n3iMoubd6ijjqYLg9yz8rq9x0BX8tR1cc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAdBPx7bfMlDYG41kjqWUsOq2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA1ZDA4M2ItYjY1YS00OTQxLTkyMGItNWNlYmI4NWIwMmY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ODVmOWNk\nYy05NDg1LTQxNWYtOTRhZS00OTFjNTYxZTgyM2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQjh2K8PK/ZQGDaZhEoItnm/fai1B3niI0vVlvs1uHl0Z5W87gBrQXY\nml8ZtYl46NcXX+OrsjxfJ19Tk7+oYFkfo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ79cHW\n+WwChOD9F0e8qgkI+BHqBzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgaTiUlWjuc1pYcUWEPVsv+LLtpvqb//t+J9gD\nkT2LFi4CIDEBzKneiIU0ApnlI1LjbPEXfrf2PnH8qMTGNRZN7ZWW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2129", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2129` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAaxnOCE1xOAzP5OdcQe+2TMmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3Y2E1MjEwLWJjZGQtNGE1YS04NTc3LTNhMjc2NDE4ZjNmMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU0MDMzMTMtNzBm\nYS00MzhjLTkyMGEtNzVlYzk5ZjQ2MDIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtNDXURbuvLxt9d8md4/IqaiWRKWHqmUE5WNbJpRMLpR1SDXESkZeuUiUaCd6\nMDaU1iJJbXUAkauaBEBzExO5fKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAYSrsDhi5ju3LhdPBLHvksr0DQwwHwYDVR0j\nBBgwFoAUNpaahVJClP44ledqDl9XZHf8TsMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDtUk3KU2PpK/T4m4w/gUqcVD0mtaOkkMDDeFUeiszgOwIhAIa9\nGablLHTAl7g3o+WhocCzhGBuZO/K9DiUTbh3OSqM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATmXU402dDuQ0drq+UU//9HDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2NhNTIxMC1iY2RkLTRhNWEtODU3Ny0zYTI3NjQxOGYzZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4YZobmQ/FmR1OZKw9+5L+6xkurV9HTbYTJ5esZTqsaMmI\nGvMrWJP5X739W4kr7Jv00qp4PngT2C0zG+KR0aPbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNpaahVJClP44ledqDl9XZHf8\nTsMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSzSiOgVtGocqq/lwCWzE92I6i4C0lWa+u2zMS+DjoLkCIQCNhDmcKm7h\naDGVe6Nyc+FMAsdFHvUgA8FXii49JCcomA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAfqZx47BrzYSZXS82SR8IHHnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU0MDMzMTMtNzBmYS00MzhjLTkyMGEtNzVlYzk5ZjQ2MDIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZTE0ODlm\nMi0wYjRlLTQyODgtYmM5ZC0xY2IzYzYyZTA4MjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATMrYQaMwyEblfy6Ubudg6ejeqLNR5YisrdRIc3rnET/CZms3R1KEJZ\ngNygipmTYc5WyD3e2dLwez3tFQJ5VM/2o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQBhKuw\nOGLmO7cuF08Ese+SyvQNDDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKDULKE7DPIQG6hfTRr1jHRxGcmRUfa1gISD\nFZeQ5O7fAiBU40UYy+GYiXrSQ/eKVCTQLxw7HnYnCW4GeS/WhxpZHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2130", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2130` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAXFPSRXSfyjVJR8+IP4XopUQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViZTgzZmQ4LTQ3MjctNGRhYi05OTNkLTkwNWQ3NGU4ZDU3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUxNzNkOTAtYzBh\nOC00OTc4LTgxMTctNzJmZTVmNTRiODE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECJCUKJF5Nq3gzuoiWeL9ysSbdgkkJm6jfxrrEV9QjJmS/ZO27LRtPhlSbWlE\nrEZ0K617B38KNh8CzliG0aDguqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt+C289KXOyiCKrQg2qRrCy7VnowwHwYDVR0j\nBBgwFoAUCfI0yl+Pe4cleVoXnpQLHrEj5JowOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCnxgWGGvyHG+UFVlQwyqnicFcO3KZ+ypgfNxd8RhiV6gIgS8Bu\npXG05n+Z0tGfIuq3P9KVbbOmJtN5exxmkbwmC8A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcmlwn0E7vn9OVdffEsCK6OmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmU4M2ZkOC00NzI3LTRkYWItOTkzZC05MDVkNzRlOGQ1N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuzabIZ2MWeU30RF6FP3SV5R9HTGVYHl3t8juc/4fp8ujd\nS4/xSrTAGeBmXAmvk6yjOfoCYESycY2Uu8SFiRNzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCfI0yl+Pe4cleVoXnpQLHrEj\n5JowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTuSSukUIoCYZsnaZHhPfVGF5PzweXxvcwwNRfV+pCb0CIH6Wj2vQ+DqK\nMb3dELsTFmtUwPKdD8MpibuO/aQhk3O1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAe3+zoQDVyN9bBXHYno711jSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUxNzNkOTAtYzBhOC00OTc4LTgxMTctNzJmZTVmNTRiODE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYzJjOGUx\nMS1jMDJiLTQxNWMtOWRlYi1iNTFmOTUwZjM2MTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATOyTDAh4Ib1zYB7Uf9H5+HGkTr5D66lVUlUnYLgx8SKrav1UjMerqm\n2PZWL0I1ZBaVCzHA3MKe2jLqT8CQ/Jiao3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS34Lbz\n0pc7KIIqtCDapGsLLtWejDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJww5QQc0Avh4LCLiVB2ILKb1OF+hflgg9qt\n/Y914AHvAiBHZQ6MxhsOj9TjgtP7Lv03nU+rHzq+sHi/78kQMAMz1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2131", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2131` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAY/aYdqDMU6qbVHaGBrsJ4m+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MmEwNDdjLTM4MTQtNDJmYi1hZGY5LTc3YjAzOTE5Yzg2YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU3MDk4MTItM2Yx\nZi00YzFmLWI2ZjMtMmQ2N2U0NTg3NGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZRoxaLMwHM5fAlw2ggyWQLU5iQRhIO6ydrIZqFsauPywzjLFasXSrAH3qE25\nvR8Xonn32H5oOtKRUm3JwPUNs6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAetekq9Qp3A0JaF329oqr40BEEdMB8GA1UdIwQY\nMBaAFGE7FOeHBuqi7vwIRZOIz2I8C6skMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAlh9/SkrGUbxH3fGejJWhx1NYgin0X9y2\nQpme19XnoaQCIFza29yB8pe9JLEKviVl46CJEFV5FmjkkmheMAC/ATpP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdLrDR5yH6ukouPUoOZrVomdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzJhMDQ3Yy0zODE0LTQyZmItYWRmOS03N2IwMzkxOWM4NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQocdU6HxfWYTeI1TdTKxH3hpkxpLWpioYRCq5+2ybMfXMy\nLJSANo/WYRSp1ypCYHywbhz+os7I27308ZWsjKmgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYTsU54cG6qLu/AhFk4jPYjwL\nqyQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE9hmU1tTjhgsYfaEgiCoynHmPKo7Gt2dJTC+/1c/ftwCIEp9pIBoviAx\niMO0PKdVf7jnf4dykmzwhN+32bUUWn72\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAbigBhIOwdE5eoQri/q9TCWUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU3MDk4MTItM2YxZi00YzFmLWI2ZjMtMmQ2N2U0NTg3NGFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZGJjZDBl\nNS1lZDBkLTRmYTItYTk2OC04OTg3NTU2NjQ1YWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ1pxYb1FP4CxLdwBZDjmO4gQdfOh6ls81Dy5bgn9YBe2k7Ex85DTgV\nfa22qAdVohE07pVTM2VNa0o9s8zFMac1o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQHrXpK\nvUKdwNCWhd9vaKq+NARBHTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgf+FDt2Oyi4WtrpL8t0vnfv/BRF/4dZxkGqBf\n1rJwxiUCIQDehlkRi+uF0dtsSMZhnpNOTULHiLJQQl3uSPIPrUTwFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2132", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2132` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARD9kXAUn1iUVICqt9WjOL8sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5NjZjOGYxLTIwZmEtNGYwYi05Yjc3LWYxOGNlMGY1OGVhMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE5NjkwZTQtMjU5\nZi00NzE0LTljZDctYmRmMTA0ZWRiMDI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFpMrWZeT0hZHPbGXY3PViHs4FIEUYlFjE/D+kU7oLWwjI3i/GfuPdqO+Zofc\nQjXkXGcb84uv9NPoRP4sKJ+VlKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULs6SRgLkoGzya/HuR99xT7LCquswHwYDVR0j\nBBgwFoAUF/35KJXQizo1/dLKudeFZLyL/D8wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKJA49S0vR+f\nwQ0hFvTagVNqwoA7JarZtirE/X+u0UC0AiBmipWC4US9vj4dS2Km5OCTOFJuOwZr\nLONn04vZ1Io4Bg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYJ9Mhf/rhD1E98dGUSamOEVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTY2YzhmMS0yMGZhLTRmMGItOWI3Ny1mMThjZTBmNThlYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARn0n4tcbHsfkLmaSleTs/uMVxBk5MWcd4FfJaR/45RAQoZ\nnLyqdFXnem8tEkyFnwUxybasHOppjChe42sR3vZwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF/35KJXQizo1/dLKudeFZLyL\n/D8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXVkhO5YFQWTRzZKW6An+YFKa3u67puSaGFYDwNi6mWYCIFZcPL0kYedZ\n9rb7YgXGxlFTLk2YmzcvW/HEumVlN+n4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAUw8XJHdl5f2ihDZyQcMXv9OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE5NjkwZTQtMjU5Zi00NzE0LTljZDctYmRmMTA0ZWRiMDI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjOWQ2Yzll\nOS00YzU5LTQzMDAtYmRiOS05OWFlNTY0NzkxYWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQk61P3i99ohR8PP6dk1SRGA5UK2ZwGXp6LqhLR8IRAaUzOAu/FSATi\nxaKjvZNJntQYKCg/EMUTo3J+HDD7icVTo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQuzpJG\nAuSgbPJr8e5H33FPssKq6zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJUrEJmmm6rpV1Eyolcn3nmJRz7jItkC4chO\nbkywPNIjAiAynaWlWqi09M+k5AA7TJ8KCwb2pYBcyzXaVHvhk3f4aQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2133", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2133` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAc1nEsKxYWr3CpzjBUyfem9AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhOWM1OGYzLTNkNzMtNDk1Yi04MTkyLTI4ZjFhY2ZjNjI3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc0NmMxYjctNDAz\nZS00NzAxLThhOWQtNDYzODRkNzFhZDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPGMBj1I8gjtTH8FYX8ahgPVnXEG55BYClAHD7Fd/1xhP+Ni6Szu0+0RymwW8\n5ElgElSYO4RVzPCjEkl3PNk6D6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXkzZq3rgZs6XXudITwc4xX5Zu/owHwYDVR0j\nBBgwFoAUODostRTYKdYUyh/XZJWUY9hNusQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPUrrf5xm5eL\naDJ9K1+XxmjRt8OrkwhhhifjEeM/xUV1AiEAr53PQv3i1DhmdP5ujuyBzPQPGMP5\nS6t1Q3X1BKNdgck=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe/4Vbxctn9nHWA+IV0Jbo6NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTljNThmMy0zZDczLTQ5NWItODE5Mi0yOGYxYWNmYzYyNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsJ6kND4qQBxog9zr758AT/KA29K+qAfYb1XkrJ9mXV8h9\nN0bMAWHuEDPp1tYhxIgx+x33IOwAadSOjbHTOGUDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUODostRTYKdYUyh/XZJWUY9hN\nusQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK8e16m0euqiSU9IjE3IwNI5ZkE1h0OW7eH3VJL8/5OGAiEAqVYEeZkr\n59JqH4K7+ONMRqLgMo/mjB25UpA7a6VsInU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAWOZMcGxRGm+5e5ZzDpDK2CEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc0NmMxYjctNDAzZS00NzAxLThhOWQtNDYzODRkNzFhZDY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZmE0YzBh\nZS01NTFjLTQ5YzItOGY2MC00MzM3OGNjNmVjOGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQdC5hT/JTQM5Z5z+2KRLfwM81goQmJ60+HyyR6S3h+Cm80S55HS+1k\nhg8kWb56RFipj1sr3xxIODngL9drL8K9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBReTNmr\neuBmzpde50hPBzjFflm7+jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgaCkmJ7Eax/qPnBqpeObe4QHzPp4gxD7ekgHe\nH3xHkGUCIAOHLU+v9G+H1k21ztRjqRe6NpxldP3U7a2OtAwb76dh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2134", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2134` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAR4vGnri/X4BjWmEzhZGRuTZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjN2E0NDk0LTZjNzAtNDBjYy1iYjkwLTYxZjcxOTJhNGZjYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTkzZWVkZWQtNjFi\nNi00N2I1LTgwMzYtMjM0YTU4ODZjNTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyywEIHm2iI1vBU6ksTDe+oYaHg1TYeSU+Ukumo1MN6trbAn2jHQHVNSz8JQV\nP4bjnc6Qbbqcz8JtifzPWEnNUKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIy7OjlLzfMHV/dc7WYpOTDLLQ8wHwYDVR0j\nBBgwFoAUNktjdGU1mMW7cb653eheU8gd91kwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDaogt/mG3X\nO1my5udvL3e7Nq4oTHMrafKIyGUHlesTtgIgBihhrLnUsmlXpoWkxw5qCYbtgktE\nVDKi1O/LfleHVNg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU1FHFa1Kq6kUgpB4NOb7ik0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzdhNDQ5NC02YzcwLTQwY2MtYmI5MC02MWY3MTkyYTRmY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATj95Q2cAYkxmt5YHPBwt6qd3CKVSYWa/0sE1D/Or5MdTL4\nc++fepxinvb2J3CUmiTgBIv395PiGjDOmTYji+2Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNktjdGU1mMW7cb653eheU8gd\n91kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJRj4EJMHSkE3btqullwmlIrG3GXf5sGvof7uA8yHircAiB6qOWspruP\nGD1JFANZ2nTCIlGU+XM9VXny6CuXRpEM+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAX1elJwqkWowcpUcU63XqiteMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTkzZWVkZWQtNjFiNi00N2I1LTgwMzYtMjM0YTU4ODZjNTFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OGJjMjlh\nMi1mZDMwLTQ1MzgtOTFkNC03NTEzNDdiN2YzZDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQLkHs3P+48bnqNFEMnjpjlRadqOsFmZeOSmwKlWdnJrj2FSMGQLEVc\ndpOYy3F3RPikuhwdMkbLhQ0mr3abtTIGo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRIjLs6\nOUvN8wdX91ztZik5MMstDzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKD4kj8pYIMhEp67k3Hzr4ujwwsbHBf119g6\nIMcAex2MAiEA7zbX7pgGrsNWOI7ar5qyPV6N1vAPu4w+OuLaIwEEebE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2135", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2135` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYIE1mJ4/nyOP82hlUC1B60NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5MWJhMTlmLTliMTQtNDFjYy05YWRhLWI3Y2E4MDUxZTgxYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjY1ZjU2MGEtZDcw\nYi00ZDVhLWI5NzAtMWVhNjkwYTBiNTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIBu48TJwXcBK4msCrku9JP2CzZ1KA/5JFJEKhOuAMAY7hhqioJwaxI31UwdT\nfZp1LLQoIOfrQE7ZIVVH3lY/IKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCHSCHwQ2vk4P9D45UQ4Dm+vX5powHwYDVR0j\nBBgwFoAU14pXNxRTyobkvaVBfLWmE7XSbUAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC0jyEPpViFl9QgeFMwggQ86spohbwOauRPSdQHNSuDugIgU9+XnSBfsDjM\nZTMSwAKYw23AE1wC2ENeuFkG6sSfzU0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAURyWXysiePwPUbkMo1MZWXoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTFiYTE5Zi05YjE0LTQxY2MtOWFkYS1iN2NhODA1MWU4MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOJXtbV4zDnfXVJyslxxNyXEetgvYvSLHyH5PkQLzU+85u\nwKTfJcWUwfb7qwnQYJCObe8qQZd7xO/P/MI65UMmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU14pXNxRTyobkvaVBfLWmE7XS\nbUAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMW77VBRI/A7O0vXfTwonxzvTQk8rezfnGjaY5YNUuWKAiBzjt8lTV6P\nClIHWjE9dlg2ssosyEl/pkJ4yY1cIyJb6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAURLUU3SPjGK7uzT3IgOI7QeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjY1ZjU2MGEtZDcwYi00ZDVhLWI5NzAtMWVhNjkwYTBiNTg2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NDQ3NmFj\nNi05MDJhLTRmZWUtYmFhOS0wMWQ0YmFlOGZmNjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQnvJyWN45Kl9pvwSPV7mkON+V6x2B/6dXx7ZFUgt8jpkAqROFgIkPg\n6otfMoyfUtTjCbLtduvRDcH89x35CNNDo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQIdIIf\nBDa+Tg/0PjlRDgOb69fmmjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhANdij2uwJq8d5E7n1NDtBeHPoNEKNpIK/2Yk\nvcMpFA8lAiBafScdz7ynxUF3/Nr/qWqfiUhjDiaSVU88cP/BlWKmBQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2136", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2136` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaQbVDapb7rj+I3S5LvsmoPeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExYjdkNTkwLThhYmQtNDA2YS05YzRmLTZiYzAwMjk3NDdiODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmExZTA3OTAtMjE1\nYi00NWFiLThjNDMtNmY5YTEyNmI2ZTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESp/npTBMhP0BDQ9ZDIQPYaZSSX5o1q3/PETAN4DISyEZz6LIkanzAPebbhFT\nWHu6tKSwKYTeCwdyhZXoSgpBw6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFU9iGagB/T0QCvoelqHLuXGzQU4wHwYDVR0j\nBBgwFoAUL+qjTi7aSXoccc5n7wd0KVx6yggwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICdSpPkFtIh0hgjlGf4a43u0FSpdFEpG9uGzo4YQF4WQAiEAvkxJuWl4x9zP\nU7pF/X3eSGJq9jlHXt43Hq345GjDzp8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWnigLmzRO9DqOm62ucWdNc6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWI3ZDU5MC04YWJkLTQwNmEtOWM0Zi02YmMwMDI5NzQ3YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqgv4dHY7vNRNUuJhSf6JnXoceutZ68kXS3kkRaEnDVRUA\np4Qa8d8rK9yUOo+2PV2v1LA8+/lssPSG3l3c+T5Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL+qjTi7aSXoccc5n7wd0KVx6\nyggwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMgL0DwEToS5n/pvBrJTgljFVLdnra1SY1NW/mx16Zy9AiEA1HZqL8Af\nEJm1LTWCG2E52j8CJu/Be/U+Osc7pdVlLkw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAScmG2r9Vb3GE4ZN12/TypGJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmExZTA3OTAtMjE1Yi00NWFiLThjNDMtNmY5YTEyNmI2ZTU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZjdlOTM2\nYi1lNDAxLTQ1MGMtOTk2Ny00MDM1ZDc2NjdlOTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASe/kcC8/CIed7PNLURMEsW5lYu0p20W3IPpnNnlXQu2ldGrtmozgxN\nwhy1kgekGVUcsbOPTNIwVbO1rXWn3695o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVT2IZ\nqAH9PRAK+h6Wocu5cbNBTjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgbuazQH9NbjE/zIYiFYldgsEpLr7DYrwC6b1g\n8G8WoH0CIA+ZF21PO1Xdd77UXtnV9lhsiEXGLSnGVxPp3o3Mmuto\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2137", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2137` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAe4/Xi++F+BcY3siX6NjG3kaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkOTBiZWJlLTZiOWItNDZhMS1hZDE2LWU3MTVlYzNhNDJhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ1ZGNjY2UtZjkw\nMi00Y2U3LThlYmYtZDBjMWZlODYwYzdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ94SOeRO+oRMXMRhy4TguCtpalmN1LO9F/OvHkw0oLPAt7Ih+5fzhMr50QB8\nXKCqMRT9Xru0hNzmEZCrrJcgpaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7W1Huu6bWkjj2o9gg/MJexDLtKEwHwYDVR0j\nBBgwFoAU/fVN6CtGXiQJdCbuAxf8xnjwe0owLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCt\nhz5rwWhou42FHKLPhkPembJKPTGMxRuj7xLXbJMC0AIgWEHTDxPJRO9wqabwq+Zh\nz8zRSPSR8lU7hVyGNZHZSmw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZk3fW2yiuxBYNZbl928kMFRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDkwYmViZS02YjliLTQ2YTEtYWQxNi1lNzE1ZWMzYTQyYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyxLhNN1NbZK+MLp73tNVve9xnWy1T+RqbFw2MrFoS4M37\nqLWRzynNDPQl3eCWZkuVKaD8AUVKVzm79hrpZ4uKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/fVN6CtGXiQJdCbuAxf8xnjw\ne0owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIDGo8TjbqemL0ZrP/g6knO4NjUZJqJjxjxEseWRNUclAiEAkrZiSTuS\nQHoSdVuFV0TWv9ujFb2E2Hl2TJE1X9IqanQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAewYehcQ+Lhz2e9LS6FceJZuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ1ZGNjY2UtZjkwMi00Y2U3LThlYmYtZDBjMWZlODYwYzdmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZTJkZGNl\nMi0yNGFiLTRhOWYtODRkOS1jNWI1ZTIxMzg0ODEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATK2XgA1sxkJXiSVdcthPDSHGva+4KI5/oWzqu3eI9a64z1mGtgVU5C\n3xlWP5OgJNkvHpWIomMAiIck8v3csL1bo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTtbUe6\n7ptaSOPaj2CD8wl7EMu0oTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhANOyFIgkvcmuWPCUrJmYcV6vW8gt8MDNGIxV\n5lXpSROUAiEAvj8uEcbqBAkJ+5tVPWW1xJypKqVCDkWOiBP9IcLslIw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2138", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2138` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISASP9KX1kduqIGbNDcA386MhHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmOGVjNzhhLTZmZTQtNDU0ZS1iZDQ4LWIzNWM2OGZlZDY0ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTczMzZiMjEtZTEw\nZS00MGI5LTgwOTgtNDIxZWUyZWIyYmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmKsm/PcPPP1wHiznRmy+C9sgz/669g2xx3Gs8ql+kuqpHD9A+g7EowDFEGYb\ntWZ3bISVd6cwVZ4dzxiZ7DjKGKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwVloqitHFMvWvLRGvmVEjXD/0QQwHwYDVR0j\nBBgwFoAUUs7gK9t2kCnRLSCeAtQovRYclyQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCQzKykTzO/B7TvUMTm+aL+ylhYHJcz26wNIYhgc2DMpgIhANIn\nov5HhjPRpe1y+bOfhaEtnKN5K6QY8LNYkbyvRZlk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAalBNW9K40vgWr1ohqzrE8B4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjhlYzc4YS02ZmU0LTQ1NGUtYmQ0OC1iMzVjNjhmZWQ2NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/2JeKxm23JEgO5ZnRzy3vmlnr2y44k45qxB9JW47kxsB+\ncw7NDVDUqzzAL4fO1Kwv8Yja6rV8nBSQUf6BsITAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUs7gK9t2kCnRLSCeAtQovRYc\nlyQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJfCyTII/w4/nOLU7Fi0fQVdcEkELzlezhpo/Lvp7bM6AiEAmKLcPlmf\nQWMPO9zD8aDsTQLRJi08cwRquArvrBfw3Ow=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISASKevZqJQS43fgWQgFDHXrasMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTczMzZiMjEtZTEwZS00MGI5LTgwOTgtNDIxZWUyZWIyYmMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNjNiMzFk\nMC0yMzY5LTQ4Y2EtOWU0ZS1kY2MyMTE1MmVhYTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASjYUcd1fau0AmwHw980tYn/DBEt83WfyW9lqSTJwpBaajmgMMDGOuP\n+IeITya0ahkxEgAYHEM9d9/yhRemQPUDo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTBWWiq\nK0cUy9a8tEa+ZUSNcP/RBDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKURakBam7bNoW3h1bfTMRx24lWYpPrS5t+N\nkre49FnAAiEA5KYWZtuy/YLFZCB/f27YEbZjkKLxPNxvdB95UJFGG2c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2139", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2139` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAQoRhEiwFBnNkzChbZxG9TRCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlOWE3ZmU3LWU0MjItNDZjNi05Y2U3LTY0ODI3NGI4OTIzMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNjOTgzNjItNDg2\nMC00YzZkLTk4YzYtNDY0MjBiNWZiNzg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Z9ylLWcYKPkYHPjlCqf3XRNEsS08LC8w1K32BWvSkLc1aB1tE3jXgGBQcaG\n9afw0euuW+mxufwu6HvZSPgjE6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU799GddO7qMuTCMAzndfF//g353YwHwYDVR0j\nBBgwFoAUjIAm98DZoW0itI4LYajC6fxh/T0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIDbbMqdNF/fIOIwZ08FOGl8bmsAGI80NuVOk5cv6eMVRAiABbJ5K\niemEEnRFGAd/6jOf21mcLmlNjFuIo9gM2iOniw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAal+f7FZEnMr2UxEqqjGbMwrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTlhN2ZlNy1lNDIyLTQ2YzYtOWNlNy02NDgyNzRiODkyMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdEHk4ql2jezNZqeYp6viZ0ll8uonxaEqOigPZxioessy/\nKskVpi90faRrGN17INyPFp7K3vGvZ71oQNL7RdiWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjIAm98DZoW0itI4LYajC6fxh\n/T0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO4DHblud/wthFbWGVEtCHrgj0ovfKZwAbhrz4Zvfvc9AiBL68ZFLPy7\n2KvGyCFEE+dsQfyIWFuI/aGYxGzo5e1O6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAYTNELaWi0lUXKpvyBDK5yvmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNjOTgzNjItNDg2MC00YzZkLTk4YzYtNDY0MjBiNWZiNzg1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMDJjNjcy\nNS01MjU2LTQwMWMtOTMxMC1iOTEwY2ZkNzhjNzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR/vRivcPgcjpi37UihADjv5Km9EQXGvqbIQ+u2vpPpk98qzCQf3AZn\nXnL/QPla71Ntx8A52UCiAR2t3CbjtvXQo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTv30Z1\n07uoy5MIwDOd18X/+DfndjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJD3j2mcF/WpU8cDRlJO/LkKJ+K+KtE4tDv0\n7A/jyQgDAiEAvHSYiU2Fo41OqxxizGernYGg2/szdb41u735G+5qMio=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2140", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2140` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISATvNGC3NmPWzoELVZxzYKSd2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNDZlYTA0LTUyODEtNDQ5My1iNGNhLWEyNGQ1NzBkOTEzNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk2NTFiOWQtNDIy\nNS00OTAxLTg2MzEtMGZjYWI3YTJmNDc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6+FzogFa4VFkFvcYYQaA/3XLEA0XqDXaZJC1JUX2VUySEcaX0W5lr01AuFju\n/d5BH2ft1y3+Y9Gg3OXglZKG/aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSMLX8J5to5qRwbUmRFKpmVjFXhwTAfBgNVHSME\nGDAWgBS9r1/97pTpvEnkA8rjrLbvtQnUFTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDd/IT7MWotIMYFERrORhe80DvKc7oA\nr2EaoITZ3rK//wIhAPMmc3DFg703E5Dk8Z+na5qLQzRefR4/20VjfyQ9E13B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ0sgvT3jh3z0zLBKgXZjFhrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzQ2ZWEwNC01MjgxLTQ0OTMtYjRjYS1hMjRkNTcwZDkxMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5g+lLN/2T8umkT+bYP10NQmZ8eq+MGytMFSWhQxyOrWZX\ngzr/FW8lui9dQSTHWdG/Jyad72f7kwQcOLpV3vNso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUva9f/e6U6bxJ5APK46y277UJ\n1BUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAONmsF5VMDnDHUApGQpgiZtxPWAEIZ/9WkR6VwdyQsVrAiB8DE77xYMk\nkvDA1YHzD9BmDu/mpHZvfNCyV0OZrGtgLQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAQa628LWOQOKI447H1d71I2qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk2NTFiOWQtNDIyNS00OTAxLTg2MzEtMGZjYWI3YTJmNDc1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNTM1MTA4\nNS01YjEzLTQ1ZmQtYmYwZS1lZWU3N2E5Y2Y2MWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASrteU7jxx3f3ulLOX8pBCW71qoTqN4CTLV8Wsa/HZ7LA3e65SS4+GZ\nNj9mlWohhryRHpFGds2kVsOWzr+gWyAdo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMLX8J\n5to5qRwbUmRFKpmVjFXhwTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAN6G9enVXDyKhWAjHbeJw5L+HIw9vWlm8Yxz\nsV/JkleXAiEA8yvy25qlZqaRqIJam9vGyaoHkmEuz2+5cgOU0GKJVZA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2141", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2141` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdUwuoivzy8QHSyBKyI6+q7IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyNWZjYzBkLTE2NjUtNDYxYi1hY2RmLTRkMzEzYWZkZDhiMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U3MjE4MTEtNTg1\nYy00ZjE5LTg5NjgtYjcwMzQ5Yjg3MDdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZA5WfyQCiqP70ktFoX87uIe+aCOwa2C6yekS51EgwO9s7Gnp/s3bjnXkXMz6\nG3EEKjtd/4nNv+Z/aQF5QVZzJ6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjiGWh+QD1azhH3Mk+GjrsooTPT4wHwYDVR0j\nBBgwFoAUslNZteLFoRo29evXntrNvqCdhUIwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDo/qb6UnAS\nbEY3ri63cKMKIlnlzlbntTRZPNainpD43wIgB6SxoeAV7ACHL537O/yyB4p0aeE+\nazsnknhKgsJm1mU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX5Yknefi7qKkGC4egD4G/6LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjVmY2MwZC0xNjY1LTQ2MWItYWNkZi00ZDMxM2FmZGQ4YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATL0opYfr6sOoG+MNSek6QqITzCyeii14m1oJbmQy6WJM2l\n8TJvSTvlo9jPyy9pr2VMYZTknOy+iU9x5UcydzmTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUslNZteLFoRo29evXntrNvqCd\nhUIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALPvWQHOUJ7rILxIFAakPtvybohCEawIzZHq77YYQ24oAiEAuHRWScDT\n5jtz1BQyWyneC/vtDWpu6Lt7x32f3IMO69I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAW4jYqKRyTIOMiP+h3oHhi54MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U3MjE4MTEtNTg1Yy00ZjE5LTg5NjgtYjcwMzQ5Yjg3MDdmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZDU0NGVl\nNS05ZmNlLTRhYjctOTUwNi05NjlkNDkzNWNlODAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATLsh4taWpcA9aC2VKTXBDlnShr66zPITLahiHXx9wQvjJaqtzULPAy\nld03mO23SuwtercsQgQkOBnyROxvZnNzo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSOIZaH\n5APVrOEfcyT4aOuyihM9PjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgaZn3NINkO7mBEFtgdoJ6LpOxglJ2aAKbLl2Y\niF+HhN8CIQDWHuU3D4ZL75SLTUJoCO29eixVgdua+PjhGGowik2W6w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2142", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2142` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYH54ZnjMGcDiu/hxZlag5zUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3YTUxYjg5LWNmNjgtNDY4Ny05Y2FkLTMxYzRhNDFhYmI5ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjIxYmE5OTQtYmE1\nNC00Zjc4LWI3OTAtM2NhNjRkM2E2ZTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEywUypRS35DI+fBTNM8dj+Q6a5v3I6rgLhbfNYg2sgrqVWPsYC9pjfW+JJb8a\nFqFhkZasTP1Ks/kZ3+ov0Ju8/KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa0IqaK/Z7HP099A5+yX+kUXvQKEwHwYDVR0j\nBBgwFoAURD5OuFwTZJLeF3KCf9P5FhlbGP8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIG8WeOA5G2WV\nJi0NgN7Cp7NVOekZVuF/yS8kY2gXn4O/AiEA6W82QaYkUftEenUxNjWUgMCgTSKE\n6smRmZt8fbtVNQo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY0VxJFe84QYz55UFj0yKRYDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2E1MWI4OS1jZjY4LTQ2ODctOWNhZC0zMWM0YTQxYWJiOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0y4CLZl64XCltZ2XIT6MiuH/7KXds70igA4QV4jmHkm31\naU2C1ndCd8hOXbEE+Vemy1pEM50H32WTVYN4rMh+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURD5OuFwTZJLeF3KCf9P5Fhlb\nGP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOBRmXiXvE4Jb2LlKyrbNai2WgBHRDJYu6JrxrSfle3rAiEAyHLjJPtO\nYMkIzwjA2zqZCYWScbNjgSYmNMRCaX4ZG2s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAUYQHJG1VkzZFp8lkDa9DixIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjIxYmE5OTQtYmE1NC00Zjc4LWI3OTAtM2NhNjRkM2E2ZTdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNGJiOWY2\nMy1lZGViLTQxODctYTFmMi1lMTk2Nzk5MjgyNDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATBs6KU8WPs7cpM0tv0zSaEu2RRdDsvGZpNsa0iT5K3fjQXMC6iDJPu\nfNERhnJQg7ei86++ZxcHBJjubICYLs49o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRrQipo\nr9nsc/T30Dn7Jf6RRe9AoTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgMuqVEMOH9x363S9vLewQYnQgT5SAbewYRaGR\n81go2Z8CIB+f4u+cOcBUQduA64NMDqrRAlNJQFK7nhgy1lzhiRcb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2143", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2143` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAcUeSe+q+1TuvY3n0TJHCUpVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2MzdiZjY0LTNmYzQtNGM0Yy05NjI2LTFkNjE1NDI3MzkxOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNlN2M4YzEtMmRj\nYy00YWU2LWJhYWItMTU4MDJmNTdhNzAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnfgyd154tQsCqcJ7q6CdRX397MWyJDGxNiR9Sw+2KGggsbDaLYEy9dMot6yp\ncQe0HiQDErxExUVdk/hngKvRMaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoKaHMwnJbH0nPv2dXpqlBJmAcW0wHwYDVR0j\nBBgwFoAULlqPWpPcsAFizU5Bj1tJIzzlECswKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAqu6TtCDG\n8AG3gDeFCw/+b754v0fBc9bHqpvvaYBdYT0CIBBHd/EsTnO4UcEucwC4p4Nvjrv8\nzBkHw+5aAq0Wc2dE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbtU5evGiSmNcghWay0WZekzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjM3YmY2NC0zZmM0LTRjNGMtOTYyNi0xZDYxNTQyNzM5MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvycsCIMXw32fYmH5PfJGG3fnIdNnBSaMdwJvNDKaqflHf\nK7kSUJezQGbpZiATk0GVoie4XW4gxoYcFBKO39z0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULlqPWpPcsAFizU5Bj1tJIzzl\nECswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFg3P6MdLyi979/OGh7ElyAef8Z+plWGb7avh3oBgec4CIQDnnHRo3Kk6\nr9a/QN16uBpHOn3Q7uNPu9C5AaCH3wlXYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAYhmJ0KcucWY6OISUQC42KxeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNlN2M4YzEtMmRjYy00YWU2LWJhYWItMTU4MDJmNTdhNzAyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZjgyMGQy\nYS02Y2Q0LTRiMTUtOTQ2Ni1lYmMwMTE1ZTE4YTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARQWSYRADgtmel5zvEqGMIvQe60M/5r4CWALi4/Ln8Lzs74wQnjFnwk\nbRgdetaw7C5GmlM+/iPgfoXDZuZkNnmGo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgpocz\nCclsfSc+/Z1emqUEmYBxbTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJdzy9Z7UsZFbsrIx99O9MuPdLmN8jMA6tAg\n6BO21z3CAiEAurNiUxFuoPOQQ54pGO8+jb21ybEtO/XkkOSftP+kid0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2144", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2144` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISATP0syuQLIBdvq6cqSxAiLLaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhNWNiZmJhLWY5NGEtNDVhMS05ZWFhLTE3MjgyMGE4YjkyOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdmMjBlZjYtOTYy\nZi00YzgxLWJlOTUtM2I4ODMxN2FkOTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9HQlBo6sM8yAm64EdWOkqnqSBzvOFJIAj7EY0F5f7taxAE4SF6O9yCgNXXa+\nunu4xbvGJdMphJ4Sq10GBn0UlaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGC43/qe9+qmD+dh2FMxGrvxqtecwHwYDVR0j\nBBgwFoAUEPy5EdWZVN+ppkD57r9fFTT01XMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiBQv9+03nk9wUJHZ9KCSFcVVVVE9wHizW/cZESNOa/KkQIhAPFdprNVQ4gv\nRK5CP0z75xsZmnppJUuVmblDdD6ZTXH0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASD+93S5WU3Ukp+pBf5MQgmNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTVjYmZiYS1mOTRhLTQ1YTEtOWVhYS0xNzI4MjBhOGI5MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjw4/eISPJp4uwejkzL/awpRQz7KDgz06Bo5T8TIop8lBR\nWMTZdVa2LZQw4Z2otydPFeZZZQbjixGhkMAr5njao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEPy5EdWZVN+ppkD57r9fFTT0\n1XMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbtJtv4HchH7uAb4hK2GUTPenC/NTUousc7kr33qf/M8CIHUc3uHKCMoy\nhArr14YR/tXmtRr8/k9DF6NtQHklBHqJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAUnJOMa2wCWCb45vER3+fP3dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdmMjBlZjYtOTYyZi00YzgxLWJlOTUtM2I4ODMxN2FkOTliMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YjZmOWE5\nNS01NjA0LTQ1N2ItYTY5ZS1kMTBmNmJjNDFmNTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQBZ31LXfkuqiDR1J24oKEwJlrKEzRMCIB0J2EVaAk01v/8VfVOJ3O7\ntc6lnXfrM9NTS8QViTvUO1HypzB5kZJPo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQYLjf+\np736qYP52HYUzEau/Gq15zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJ7NB7AdYdS/USd+PRDN5bPOdaBQ0+apXV9Q\nvzuMMvKqAiEA5f8I31frAsQG4WCUrNYTYPQBWt1bvjKt3pPkfk+8KwE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2145", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2145` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAf/rHndmCDawUiW+2Z8ME84mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNTdlMjY0LWMyZGItNDhmNC04NjQ4LWE0MWU2MjdhZDMyODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmMyY2M2YjgtYjFj\nZC00YTdkLTg5YTYtMDBkYThiM2UwZGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWerOVx4/sPeMJmIjKuZkDaEeM2OLoIjKjsSCiXTyBW4Xts5ZgI6LdCfRnnCB\nBbz580khI0RP+/FS6wUN02YgJKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURIP3Cvgqavp3A+ys/+6LEyHrEcswHwYDVR0j\nBBgwFoAUak22My3hNgUgaC5nRcCD29Hp9S4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiB/YH4nOyC+eveB75CwjWbbmP0uxGMISXRrdgIhCWCQxAIgUJeFoKtP/sd1\n6AodO3HP+olkeWo8KlCiwd+Mc4stxK0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQF0LpRRTjRMUYfhsxSkPCSsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzU3ZTI2NC1jMmRiLTQ4ZjQtODY0OC1hNDFlNjI3YWQzMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQgJhS+YLMFZ9DOP6aA6PS0H+k+CxPWybO5SP/n//x6uKk\nHuajK0TmyX8wB928bhVKi0Z3vO5nxJjn93h8Ctero2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUak22My3hNgUgaC5nRcCD29Hp\n9S4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJpT0s5ZG2xEPKNWZBvapO8J6OTPAb+smRmX5VTrMXAqAiBV9fbqOp3m\n+7fNyZgHYt50+YmBQeiXMFPRT8jEfMIgag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZ0AWTPmhZ/7rMGL7NwhxXlHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmMyY2M2YjgtYjFjZC00YTdkLTg5YTYtMDBkYThiM2UwZGY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZDY4Mzc4\nYy00NTdiLTRhNWQtODgzNy05MzJjMGUyNWMzNDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATA7/cvyXrrgYbXXL5ItFwv/Cc9hMHi1xTfzcpocaPpxTA0AWJeNZwT\nWhRBysXS5fYqi0h8iqh4uMmwMPEeexPZo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBREg/cK\n+Cpq+ncD7Kz/7osTIesRyzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgftbKYRskARInFSZqmVuRau7xC44709B+Kl9b\n30TFxSoCIQDHcq6hBbFk7utSDq7mbCb8DjjtMJLfFchKtqNVwUoLmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2146", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2146` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAea6JC145K6bTm0H1Ir5wPgdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkNWY1ZWMwLThhNWYtNDFkMy1hMzdjLWIxODg5MGQ3NDdiMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRhN2U4ZmQtYmVi\nOS00ZGQyLWFhYjgtOTg5N2Q4ZDJmNzFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjzF0U2hwcnL0FlVcq4SfqyIJioEe+xRV+IqmImGsCutwDJoJ40EgpuI6i631\nRA/bGVbYZ7FNTsu0D3TWrYJu7KOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6vk8jiTJa6JnrmAsJQKhDu4bTLAwHwYDVR0j\nBBgwFoAUzLSA+N+vyOOiqsMJwAfB2GbMtpswMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n/05rt6YeJNdv5WxBFciy3dtGY+TCTWshmtslcGnjS0ICIDVHmkzoaTXSpdAM0Aab\n3Cih8DcogoViyiKY5PUgIxxx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaXQTIbwN9njYwhVhsSQdj6eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDVmNWVjMC04YTVmLTQxZDMtYTM3Yy1iMTg4OTBkNzQ3YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnMxiz14cRvudDLCMh5bjmk5KVDkFAUwIb6ZPaZiY28kWK\nPXupCKKVurCSxyNsga56m6UiU/E7Sipv/hLVuKo4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzLSA+N+vyOOiqsMJwAfB2GbM\ntpswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPYa6a+0Z//oH9NlTD7wnuxv6W8p8rUtUiIu+zhDr0cWAiA8Aeer5i5t\ntq+5ZsASvbvarSoU5MyV2KmtD6nv8C8l4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQccEmB9TfRmWpuWosVZiXFAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRhN2U4ZmQtYmViOS00ZGQyLWFhYjgtOTg5N2Q4ZDJmNzFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NTcwN2I3\nNS02MjI4LTRkMjgtOTQxZS1lMzE4MTlmNWYyYzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQGX+J0+z6TjgPPzQKOX7cRhFO7am72li8J1fZIeXIY6ZcKH2A8EkZ2\neqsq+F8406OrBvgpuiruYhQYtZ8CxelKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTq+TyO\nJMlromeuYCwlAqEO7htMsDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMgAT8HFJDudzI38oYEZ+ormUjjNUuKQ1z1u\nWNDOtF0yAiB5QPEC/QLZRjbD8X9thHk6h1/9H0oHu7RVE3EtwuI5SA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2147", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2147` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARG+9IgWQDaXSzvBGQI79WI+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkMzI2Mzk4LTNhNTQtNDVlZS05NGExLTJhZjhjY2M3OTJmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTJjNzkxYmItNDUz\nOS00NGZiLThhY2ItODljMjc5YjhjYmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBUlpsB8g2BOgF6ZSTYZZ3UwVisuykYr+Tpu/Sr6KHaqWaSuA8yhNv63lnZOb\n1Zn0zSGED9W2AAfGdM5iEpb5hKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUixzyP4r6qxoyHjtP6mruMuthoJ8wHwYDVR0j\nBBgwFoAU3FpkUuWqG8wuQ8PJOy0D9UNPWTkwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA/KYUDxiZsUJgEYYLchm0/f1muiGUWaS3fhoCGfH7TfACIFR7\nVhV+w17xE36CwsAuhPTvErLKEP0yHWqOuJe+iZkI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATsan0cIplRmoZ6iQpasj5LPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDMyNjM5OC0zYTU0LTQ1ZWUtOTRhMS0yYWY4Y2NjNzkyZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZGeE+Mhhr+FEIxioYatt8VEGjypdXZeDhyvdu2fZXDnsz\n4SYWasdxNw9ez65Wjk+cqVKm+YTD3b2AOeS3U8Yzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3FpkUuWqG8wuQ8PJOy0D9UNP\nWTkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIDBEZ1v9mR7GSanWgNtE1i7TcOUUusMGmkCuBJhGSygCIQDdm5LVp3Pu\nsNf4ARMX/EDGa8+mo5QFOVCaJQeMyc9YtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAV5uhZV3r3RmdOYaqmgUZz0oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTJjNzkxYmItNDUzOS00NGZiLThhY2ItODljMjc5YjhjYmNmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZTI5MWY4\nOC02MjA3LTQxZmItYmY2Yi0xMzlkNTdmY2RiYTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASaAuX9MenI5Oq4YcL4tM/XId8RgKbjpsbx7D8qPoVplDfkAeDlzuuv\nWNzh3Kb3RH7lW0SM2N7h61PvEW6p11mTo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLHPI/\nivqrGjIeO0/qau4y62GgnzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAP7yCaGpVvt9Z2dj7NpTHqyIGLpDs42bGPC1\n28u5CFhsAiBkCWuQgjL4obyVBPkb4pQvKRrME60SDmiy0ZKmkKDaJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2148", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2148` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAf6vKvfSR/EGERKV8FP6Yv25MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjOGJkMGNmLWU4M2YtNDdjNS04ZTc2LTMwOTk1ZGQwNDJmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2IwMDNhZDctODE3\nNS00ZGM5LWE1NWUtZTdhYTBiMGEwMjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBumHcIsc1wn6Aoc7oghpoLW9CsVb+nPl0vyYG3I0FMWmIa8JFPTl7U1PtffW\nDMZhSioR7T6P0KSEAd3ubo3J3KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF94XW6AJMZQ2FN9FCEXqe2+faiswHwYDVR0j\nBBgwFoAU7W3eF/DsXswcytfaZFqjrdRl5oEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiAt3dJKv7NOknmsQyXdC1g5uuhWuf6Aq5Pz3AttI+mo7gIhAPTM\nfJADhOuO9gg/UeTfwQGCrkTsGfkgv8wwkkwWOD5z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUE86wyrsXhtg7J05vDxh3GRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzhiZDBjZi1lODNmLTQ3YzUtOGU3Ni0zMDk5NWRkMDQyZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpirZ4sGg0x6QhMbL2UeSR+jEDKuoXEVNBWqdI4V/A9AJT\nOOllMTj3z27YWSEgeV/UElnuZc6FXIpxoFPDmQnCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7W3eF/DsXswcytfaZFqjrdRl\n5oEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKFWzSj1i3wxgAJLaoZoEgXzzYubnh6TjxGHtvQ/UVE2AiBu4iDU4T6E\nUKoswKZ4scTIWUftKZWeN6LEL2/5pDmJCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISARFkfNoZQz9CHgk7Js/dqhRKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2IwMDNhZDctODE3NS00ZGM5LWE1NWUtZTdhYTBiMGEwMjQ2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZmY3MjM1\nNS04N2E5LTRmMzMtOWNhNi1hZjNkNjRhMzhlNzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS8QDnpxoX2wp2B+dPzgz3rDtCq8eeBdauaKHL9zH+O661Tkr1mKoUD\nfKW1j+bnmM2467dPWXd5+AT52b6CPa9oo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQX3hdb\noAkxlDYU30UIRep7b59qKzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAOsZIOxpovsioonWh90g55fexNgaxLKkZSAv\nY2F9h2OTAiArVba2BUBuAZ1RHUFE6Z49jIBkYHVFUtL4ICto8B1LWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2149", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2149` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISATPd85c8ybV4AJRiaaDfFPY1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxYTc1MzI3LWQ0NDQtNGQ0Ni05MjZlLTA5Yjg1ZjU0ZTIzODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFiZWUzYjAtODk1\nYS00YzBhLWJjN2UtZTcyNjkwZmZiZWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/LXUR9a67XQE9GRCWhGVUzmMX13Uk8dHDHNvg9zgK6ZDB/fTPuLNiVGrX/pw\n36/aQVJwpAdQIXcAAzsuXxFKq6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQKNZIOrQliu9B3/p3JDbhHpOYwUwHwYDVR0j\nBBgwFoAUyi9l260lEqPClagpcb6FeG1qFJMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBKzJYkcu0YwDqY\nJPq69qK/tQudWk0S0Xijj92AujL3fAIgNJ+16k26rgcbCYuhflZ/ECNiVaV1/PYH\nhPC5csO9iRE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATqW2qEuwRbGsUU4dARca1hzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMWE3NTMyNy1kNDQ0LTRkNDYtOTI2ZS0wOWI4NWY1NGUyMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMgH2EKEr9vC52BSoEt5pA5xWnnr6bkf5Heu9dVBsFmgvt\nrM/nQsUoJ0PaNmb1cao0ziUfFOspcnbId6MBlgUto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyi9l260lEqPClagpcb6FeG1q\nFJMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOJg0H/i3vgReBunaxLjncw5E7om5w4NQFP4RXlgnGk3AiB7PQi0Eb+S\n7arC8AfMZ56UYi7oLHxVBWmvMFC4YOvYGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAW0PAZTKP31Bpsl5nTpiey3OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFiZWUzYjAtODk1YS00YzBhLWJjN2UtZTcyNjkwZmZiZWNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMjJhZTQ4\nNy04ODI0LTQ0MzItYThhMi02ZjYwNjdiZGM3M2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATcFCORAglVZxMg2PvNRnyauI1I9k9OZTkAf/WrVVCC254APN2qs6gK\nAShSPGCUjt2WY8New5Mz0U2C2tmaLEvWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRAo1kg\n6tCWK70Hf+nckNuEek5jBTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAP0iCWaxsAB8cc9qGClXnd/Z1xFhT/JzxVvp\n9NfVf4izAiEAv/q2rPAj8vTpTn3Upg8K7mjia7HrI/wi/BwhnnheHgA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2150", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2150` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAf9D1owdwT0ptcgpxGoC0ZDmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwZGFkYzkyLWU5ZjQtNDU1OS1iODFkLTY2OWZiM2YyMGUzYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYwODJlZmUtYzQx\nMC00OWNiLTkzYmYtZDU5MDE4NTZiYTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7SkNeZEheYWhQ8el44GENtEF1w/FJn0aKTV22vA2jP0zknSf3ZoF1CFwbgWk\ng2wDl+xS5Vfsqvv9bz2ofpMBBqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWTO7HPw7oZtl/lohTBI4unUdqDQwHwYDVR0j\nBBgwFoAU3PIVkAlUEvUY8DmFQHSWKLLC+7cwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDbTUl6G359Wysh13GmKYxqeYs5Xhlrj8vhx02KnAkRgQIgJUYfSun7wgiW\n72PrSmhW23zeyNsZ3YkV3+/vK8uhGMk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfUyChmxFWPkOYceQ2SGNqUWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGRhZGM5Mi1lOWY0LTQ1NTktYjgxZC02NjlmYjNmMjBlM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgnFkV/Mh09MUSxelnBv+WUCQDvldB4hByLzhcIggOQBdw\ns1TzlH743e+Yik17YyOFoRAFSa4oAXpIxfE4a14zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3PIVkAlUEvUY8DmFQHSWKLLC\n+7cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPdiDZSsKu8fiXO8g3BTz590APXQSPTTMmwLcY7cjatiAiAQLUSOH6oq\ncRc6G7oh2hvxBeq8HR8XCWHpOi15SSRlZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAToSh+10wl6xd2KtiObjDbntMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYwODJlZmUtYzQxMC00OWNiLTkzYmYtZDU5MDE4NTZiYTA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NGM2ODY5\nZi0zNWZjLTRjNjItYjhhZC1jYzQwYzQzMTQxNDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQgnuuA+YILV9y2A8E3gTbuEZWJZN7QsC+tEhDYb9j5FDDYRrz64LZ+\nIhWU08CckbIYsWDTMMOWDD7/OivyU/PJo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZM7sc\n/Duhm2X+WiFMEji6dR2oNDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPVaTJdyYUdudseCGxgS/3NrIZvui+DAWWej\nZ+ZTg6e2AiABm/ufzOC9m92FNPnMLb5uZl0KTVr9SSdSokQ3VCjdWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2151", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2151` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYedajs16poF2qa0Pv7qIBEBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhMGRkM2EyLTU4NTMtNDA1ZS04NDNmLTIzMTk0YmVhMTVkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY2NzFmMWMtNjE3\nMy00YzA2LWIyNjktZGZkZmJjNDY3N2RlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbAhqsdgHpE0B/Nj+nFJoXlaO2WfLN19zTNEz/lxmsv928v2Gq5EAUXEQyQ0s\nn2kObzbDdikXcpHW2pZq+5EKFaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH2i7307fMx2D3K/eOBvclHE3BC0wHwYDVR0j\nBBgwFoAU2TH/bBtZidC2n0a3ya/ihiXMKsowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDMFEm7QeTSUEAINhr+qYLYfVlfOQbNmya+GUiGsodZtAIgS2Km6UfLq7lW\nJXKaaNX0NLgCtie/9x/ZLyRPD44UrO0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYVNdGwDT/XgOaeZ49HCQbrdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTBkZDNhMi01ODUzLTQwNWUtODQzZi0yMzE5NGJlYTE1ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQn68oIRGuHa/slt/c9mEYcIuFeb1mgglbWj2MhuwMqo22v\nEBIRR9pQcOWJllGDbEFlmH5ZwUMLftGRH5Dw7G6To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2TH/bBtZidC2n0a3ya/ihiXM\nKsowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS2bAScKAuyzFqjetv9zhusCsmpbX+OyZJL4Ed0GiaxcCIQDEruaTuS8u\nHDkL+3dsbM+33RX99hMKLuf2HUztAynPjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWvrorlUX6HaWHKTxBGZXxyqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY2NzFmMWMtNjE3My00YzA2LWIyNjktZGZkZmJjNDY3N2RlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNWU4NzQx\nZC0wYmQ2LTRhNTctYjQ3NC03MzBiNzJkMzUxNzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT1GHB48fROJa4ojitesfDiUBWEJJN5flhVWh8tgteM7YUIOTdHvAew\nXLTX6rcPbiKcfyc4TA6eokExRs/nA1r/o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQfaLvf\nTt8zHYPcr944G9yUcTcELTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgBuumGxT7Ow7oXlc2rQqWEIX/bWWDjbRS4Jox\nIz16iJICIQCgdcJ0vJxaif1Vk+96B5MpPRI0HU/qKmEfq3Hyu+9O0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2152", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2152` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAT7tchv4lFF9ZgT4jj5Ua1J8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NjEyNDBmLTE3OTYtNDVmYi05MTUxLTIyZjIxN2IxNGVmMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUyNzlhOGYtNDhi\nNy00ZjkxLWFhMTAtYmEwNzIwM2Q5NTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWMtW8GBKwEZIpVk4LCkQnwJbHmXmmfWkc+saOzAeZg5U8IXYofUCeIQEiwTM\npWA8b02UQTpAictSz6V03fadOaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY928PLBzh2pLBTl0xQWuYE3p0eYwHwYDVR0j\nBBgwFoAUJHvzbCjvOyZkwL6w1YHjKUUeFVEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAtqkRW685GUmN2t2OYS8ZzwYVm97d/oZflVtN2L6i5LoCIA2JS2QkyoXT\nWb7thk3IOeGft4H21v7X4paB+RFs6L1/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcJyB2xD7Ex7/BtflhjUiLZbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTYxMjQwZi0xNzk2LTQ1ZmItOTE1MS0yMmYyMTdiMTRlZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASW+LrF9eYFiImVvSKispK7n9heL10fB/pDHdPlt8eSe/ML\ng1B/BUjsxjwfG6oXh1JMR3n/NaS69Ps/tZKa268Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJHvzbCjvOyZkwL6w1YHjKUUe\nFVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALsOv7JBxr5etOlwSpcbqijSHjntGqIhe7gKyb1EnvywAiEAinTvHE3A\nfc1M33mnkuasMbkPIRhNON5AOCdDEhoGvMc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAYrgtTG/Jqvb9sQHBTI0p29YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUyNzlhOGYtNDhiNy00ZjkxLWFhMTAtYmEwNzIwM2Q5NTZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMmE5ZTlm\nMS0zMWJiLTQwYzAtOTkzMC1mOGRkYmZjZThlYzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARlGtnMzCk2h8cYy+yAPvEui5KTei0VEjHs4W9zlUCASNZEe5mtC4nB\nbZ8le2Tb+HC8v9sT1IEzcS7IVd/moJazo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRj3bw8\nsHOHaksFOXTFBa5gTenR5jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgOZPML39YVw6ifubf3sc7QT5XiPTv60PjmPaH\nn1eiOa0CIHCIuvPYO7+4WeGbhoMntonAwyOW8dD5PLBw9zLfCAMM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2153", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2153` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAe6k6Mp7mOkBb+5oOuMR3GnUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczOTg5NmU0LWNlNjItNGRhYi1hNDg1LWMxMjg3ZDQ5Yzk3OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzljMDE2ZjEtMGRl\nOC00ODVjLWIzZmUtYTAyNDhhNmNmZmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeuYqy3cUEV42sqP7D2MNMPKNVdAXReZEWDZim5Ts0Dhgu/47iWjct3Y+ZyMv\nE2GqK3JssVzOPx/Eg2YUn6oQdqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHYg9RXO3nY4kgNEF13m+8UXsVzswHwYDVR0j\nBBgwFoAUuvicBmNYNzAv/5N4COmz8vk3LHUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBCanoz4glN8M4Mpyhar2xqmnG2hP5ThOOcyDVzbt3r\n8AIgLtJqppmQcYmXf74SXMD95FmL+w8MCTcCZSfd4QlyyKg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf+HN48+lDKXh9n8rD2zlofZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzk4OTZlNC1jZTYyLTRkYWItYTQ4NS1jMTI4N2Q0OWM5NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+jIILyi05O1peiYZmOx0d6YRYanRMyf/aT+KWl/WBPOok\nR2SW/+RsXdguJ77o69y+EAlp93+8dUJ4jnwmOwpIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuvicBmNYNzAv/5N4COmz8vk3\nLHUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIs5vzTO6MTFm9QBqluz7eJ+HEDQaf4G43rhpfsMN0imAiEAqbdFAyor\nMJrOnX4G7DRIUsfdqAYNWPm5NzvwCMwRV+c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAe8yoqaPovDLf/vmuu+YlAe2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzljMDE2ZjEtMGRlOC00ODVjLWIzZmUtYTAyNDhhNmNmZmUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMDg2ZTI2\nNi03ZjI3LTQyZjQtYWUyMC0xMGU3M2QwNDk4OWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARjER26EWtuRAMS7RF3noSwri1I6pUTvk13B/yjJyKjWMzU7mGPYssS\nWq+0V0r8FUMU3eLBvjy0g1gFDl9wyDJKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQdiD1F\nc7edjiSA0QXXeb7xRexXOzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgchNgXINQleWbNYefOrdlpuS8GT0Y1UjI9g62\nLt8sHzkCIQCFi2mgja9yKw4cdGStcS9zJh8NcTuyxJwm5oA181++SQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2154", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2154` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXPMmNgc0MU2+mSfrD2wtPZ+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMTdjODY0LThhNDEtNDE3NS1iNWM4LTdkYTAyYjJjNmMwODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDljNTE1YjYtMWU2\nZC00OGI4LTkwY2MtNTY5Mzk2NTc3ZDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjuhvsZ9yB4n3hkZ5hPsRJ2j+iExSMk3JzQdEvMGu/SxLrSCesBWOeEdyVT3i\nwiUiZoSQMuduZXulAB32/ZwbVKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQklEJIz3habsoRFlj5l39QWLH8MwHwYDVR0j\nBBgwFoAUyzSqXzjUut6f5lLSEMFAoL0QlbwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAel15HHzJx/caOGAZQyuMg9/PVapAnLOFdKRlLwY5G\nAQIhAO43QeG+9GJVVFjcus+GMd4qsou83319mfs5daynrBg+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdGypQcrw0B0GS+EMQzLvITXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzE3Yzg2NC04YTQxLTQxNzUtYjVjOC03ZGEwMmIyYzZjMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjxAgrGfIUA5q2v7T16RriTGgTWpobiGLPN8A6K3Jjcyfq\nRr+TGUCvbas+4l4lBhiFdswlRSg0xJOWAmQYBX53o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyzSqXzjUut6f5lLSEMFAoL0Q\nlbwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANkYGUz7hYN6BYPnrol6KF/YtevaQWMWBfm1rqt0XLgtAiEA+xYWITpg\ne7TNN7SBo3PBt7i0vq7a6WSbHE2X15+E4uY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZRJZxIxoZfwDNsyahp1NjNTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDljNTE1YjYtMWU2ZC00OGI4LTkwY2MtNTY5Mzk2NTc3ZDg5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MzM0NmYx\nOC01ZDljLTQ1ZjItYjcxOS1iZDBkY2Y0YzNjNDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATLm9CUz4nHzwF7yUKN3AlL+FueqwC0ad3d6En/J+M8Zaj6IHfpyNPy\nSTVKp77hHZ3i9ROfk860fARQEaJVGd/Do3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRCSUQk\njPeFpuyhEWWPmXf1BYsfwzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhALsKa5t5rWU00Fi7IDojt06eFhgNCKE3WFH2\nGKm0li1bAiAtmmE6iTcgkwcntOXRBIs4g7BHm1Ut7Z6GXRYzjPfIRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2155", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2155` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAS1IYf2lU/4q1xL3f8encR/oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NDg5YWY3LTliOTItNDYxMC1iZjFkLTVlZGZkZjI0ZjUzMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhkNGRkZWYtZGM1\nNy00NTNkLTk3ODItYjViNDIwYjc2YjBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJRn/4lpiqMnjGue7J3BBmLO7hWkE//WnOGR0EjIbXcOlNxBZoOwpz1wEQzwR\nyUIdlooxmuoigetFJFKVEefzuqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3rfbAIKkTUkEUs0rj+VxQp8TtJEwHwYDVR0j\nBBgwFoAU7dMJN7RIaOMpDApOimZ6+GivDo4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAmcy0YboZr8r1HhyP7xCf9a+vzpPmUFrI1BNTzgXLSJQIgJp6A\nZA+OTu6jooCV7IHJEW/Bl72mgrJUy4vG2h8+S8M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXHHUOO/++8Wi+0wayyr5dIpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDQ4OWFmNy05YjkyLTQ2MTAtYmYxZC01ZWRmZGYyNGY1MzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZili1mQlAz3mz/2KRtdfmtHHiN/MZY7RR/U9gcVBI1Uxz\nL+K2IHnfe6kQAtT/5e5aVzze9c0NvyNxgXMNc4C+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7dMJN7RIaOMpDApOimZ6+Giv\nDo4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE7H3aY5EsyArboVIQ7LyECGcVW2JYKtW/nPej5+lmMgCIQCiTF4R6zWa\nCjFeoSuQjszDlBGgrEGN8JavW1Fqd5gQzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAdmbk5XTBDeNLS5RC2x5XPjGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhkNGRkZWYtZGM1Ny00NTNkLTk3ODItYjViNDIwYjc2YjBhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YTU2YmZi\nNS1kMGNkLTRlM2UtYjNjNy01NDNiYTYwNDBhZWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARevRiOJwhqUsYkCi9lkX2INO4e8jWKqWrb0u2zMQWpE8uv4bgEqIEq\nqeZox8+0usJl83xcr9w7qrVFZUfrEsD6o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTet9sA\ngqRNSQRSzSuP5XFCnxO0kTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgNOCa5uHVBoQ5RI9fC81CIU2Ef8p6pC0VpP2o\nNf63MnUCIQCBllmAM/eFt0KgsU2AioQZDKR+j7AgmCPklHqB/k5IBQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2156", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2156` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAbmolXc0jwDt65KKvf/e939wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3MDY0ZjY1LWU5ZWYtNDQ1MC1iZmNmLWI1MzQ1NjE4MTU4MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk2M2Y0NTItZDgx\nZi00OTMxLTgyYmMtYWQxMjE4OTQwYjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP3lWg9BqMA+XGLhUoWM79NB5qCs7dJwe8XL0XADdjxhfd0ee4t+aIf1LwyN2\nsFOCyF0Cp8wzdZ913EHLFVj6tKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdiVl+89te4BWNYeZYPFu+UtWtZUwHwYDVR0j\nBBgwFoAUq7F2qd8IJxPzAtX2rHTSvos9IN0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAqkSr65fNl2D1oURiPiHhRuYO51wdYS6B\nfAr7MDhg4mACIQDKnZ4sQpmUyPLz3bQW1ddx9+H3Usyt4nYecIhwEs7bZg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQcUN/yYptcDjoQaKLDcpuMEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzA2NGY2NS1lOWVmLTQ0NTAtYmZjZi1iNTM0NTYxODE1ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfNpT5yCDojykAsJWx6fa5i1kV1UtqYBk9FRFT8LKkp0z/\nvTFkMHnmHMyGSBq5kvTrf1BUL/HGae/C1AsKVnimo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq7F2qd8IJxPzAtX2rHTSvos9\nIN0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP4jqpTH2oTJO98mkrmA5h74YYUNHFLGOHx4Sw5zIaBzAiApkXLQJocM\nip1wl2g5+icZC9M5ufkfipv9AVfj8WF4Ng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAStg6Nx9dhfTlBxggs+snXmLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk2M2Y0NTItZDgxZi00OTMxLTgyYmMtYWQxMjE4OTQwYjI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMmU5OTQw\nMC01YTZhLTRjNjMtYWQ1NS03NDJiODVkNzllNzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATc3o9ry09rAvD9LI8UUu9DEC+7H6WM9chNvUv1elooEb3KLuZfdQOb\nr9uN2Y9T8SaZTed0c4b2by/GM7K5SiYpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2JWX7\nz217gFY1h5lg8W75S1a1lTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIPLc5FMjK57r5dDiVv+CxiafMDIwLMBoDs/\nLxwWEhFDAiEAqMvUa8wWwnWt1gwNTfyLNvQ86L3VCNewmnKUvdV63cA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2157", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2157` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASkHexyhDfQbsl1JejN2h+3MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyMDczNzBlLWUxODQtNDg0Mi05ODJmLTMyY2Y0NDQ4NGJjZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgzODUyZjItZDRm\nNS00OTdiLThkYTEtZGE4NDU4NjNjMjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfOmIoTaUl+i3u0HOLLt6GcXOSDvXIv5gRlFfHnyPdO39l/zo90uZlf8v9fH3\nnCpxX9GCy24pEhBJPliJghj7e6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXAleVpG9t5+rgCObWPty6bc3apQwHwYDVR0j\nBBgwFoAUHKgKbfjc06VEOv9vabafAkn2NyQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAmG1qkJYQDFvq3/UgsD+Evco9fRcyg8vu\nynwWn/DTmscCIGPEFLEp6VZVzdjESAqEHVBWnUMuPde842G45SSZZI45\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWsJ4LmHyEB/kz8/LfaMXx4yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjA3MzcwZS1lMTg0LTQ4NDItOTgyZi0zMmNmNDQ0ODRiY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrU2QfCV7MfuNcSD80z4Izn0+KmDWZLPobvTnmGPjCaHPl\nio85/yVKrYv1RRG26QhV6sll0OEv8UX8Cces7hzuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHKgKbfjc06VEOv9vabafAkn2\nNyQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgULv4Gemj0LRSKEbgChBrEQ2EFdCS2RVpf6fBumfhQ6gCIGoZ4nJxHhkb\nphqMdFuZRI5cQpLhG2rUiURcLvWKKU10\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAbQoVdTuT1x2u+9CY64viwYeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgzODUyZjItZDRmNS00OTdiLThkYTEtZGE4NDU4NjNjMjlhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZWRkZWQ0\nMi1jY2FmLTQ5ZmMtOWQyMC0yM2IxMDg0Nzg3NGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATb+aw90FHU4Sfi6/Niv+m6dkJnfE3wjFJST+xkhzAErco558CV5L5+\n5ICNXQTsWZra4ofO1Jc55wtr9McdiIlgo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRcCV5W\nkb23n6uAI5tY+3LptzdqlDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgE1a32HJo13PVHzNuHrHwA2etHfesAS+X4+Ls\n7ceA8HQCIQDmGtaAR7UC2/q4Ix8nOnngPtA4Mwygog8Jaoukq7gU4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2158", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2158` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAekm45tMLLDEWfmAPnBz+ybCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1ZjRkZjEwLWU0MmMtNDgyOS04Y2M0LTk5YTIzN2ZiY2ZlYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQwNzEyNzMtM2Q5\nMC00MmJmLWJiYzEtMzk5MjUyMTFjNmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyOsz6+T7nIqWcHCz6DErzSjXQ44Qgu1h6tYKyVcCAcRyTjSpzw8nQUKCp9xh\noWq2dqlEF/EYudNt9sur1GXYh6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpJ+VsH53AtG7lphNL3uWrZibsqcwHwYDVR0j\nBBgwFoAUe9E7O6CsbndSgSTq7dQrbvRnHbwwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA9sxO1kZASgxj\n7Op6R0+InmOFhhnUQpdyye/oIVsWXUICIQDbyemo0XKjY1Ma9r3FZhFan5Ss4cSa\na8J2KD6ItOnOtw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUTATWCqXfep5gufJmMhdO0/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNWY0ZGYxMC1lNDJjLTQ4MjktOGNjNC05OWEyMzdmYmNmZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEbXek3mvBXQ9N9vMUgo6fT4pVP/HFEkk+pPXo7BJrSGQO\nKAJG3g68DYJ/sz6TBFU+j0wQPTtV+R24YPO5DDH6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe9E7O6CsbndSgSTq7dQrbvRn\nHbwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALk7n7ihm4aKiiEYfbXJhe0qPNvd1y1yb7j7c3Fx3JgFAiBz7wKlYWge\nT/GdqhH6sfxemzsQIxg1EnTz9fC4IGUVgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAdxaQ32hGKu+CVXuikEsQ0FcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQwNzEyNzMtM2Q5MC00MmJmLWJiYzEtMzk5MjUyMTFjNmY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYmMwMjg5\nMC1lMDcyLTQyODQtYWQwYy03ODU4MGVmNTg0NDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAREXsc3juEwL842vsC2hyizKrYFB1XKUlBGw6yeltPgyjBUYuLOr9m8\nh6LLnx8JPq5al4K/rhzTZ2/QM7+RqLNOo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSkn5Ww\nfncC0buWmE0ve5atmJuypzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhANAnmO5ex13+aj2NYrc+na0OSgG32yGY0Xyf\nKdiiNmq+AiEA64FTngFNPU8XFuP2eF5odD5xkBG52PJi3A4+86sF58o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2159", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2159` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVxtMNYtEVhcvIbuf20n3mLbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZjJjMzBkLTc1MWUtNDBjMy04YWJjLThmZWM5Y2FhNDhmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzM1YzcxZjMtOWRi\nZC00NWE0LWJlNWQtOWQ5MTkzMGFmMDJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEe7XUS2MxyD1/8MVOuiLcs77hb73hPdLgzqsNOuVYybMCjFM1mBhAauQ0qmc\n4Gvqjcl26TXwR5pAM0CL+9h8X6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUer/PntppUeWUQdKlPzDdNORvIT0wHwYDVR0j\nBBgwFoAU83bID083FKFRPTicO1TbtIn56g4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIH6AOWltsIi+oFHMSekSL1Nu9kNIcVD2bG/mhmM2rMh2AiEArCzqvr0ekpNu\nv/XfEJf/C1d8hm3Jr2O5z5P6db/z++c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfIxkXY7EedeYMtEpOjw2f0dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2YyYzMwZC03NTFlLTQwYzMtOGFiYy04ZmVjOWNhYTQ4ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmfolco0g05NSZQsoora+vsfOMCoVElV00jGgUjS60lKJX\n5+r3m0enIyoUWRdaWA+VYGFWoH3TW8B/4mxaST3ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU83bID083FKFRPTicO1TbtIn5\n6g4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGUVP/ca9tzwfyiOdoS2mX4HVAI+4ZXu3HcHw5qVBwjcCIQCo8Q7QiVMA\nzoUPD22gnjj5x49K83ab0NQ5XF8ZCy7asw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAcP4+kRKVOTCDmul3AHHeAL+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzM1YzcxZjMtOWRiZC00NWE0LWJlNWQtOWQ5MTkzMGFmMDJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZWQ3YTEw\nMy1mNDQ1LTQ4MDgtYmYzZC1hZWFiMmQ1MzcxNGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASVi5nUSbrfUTw1TYUuBp+tPtrRvCdHZYxICB2qCq3jbrb7jCXIKMtA\nqe7xGK9zWczMe90SjE9NQjsJoJD4lpIIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6v8+e\n2mlR5ZRB0qU/MN005G8hPTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgCKQIiM38JOzoS2PBsB9/tgLmADCvvLLxYVnA\nOZ2khDACIF1e10Fk8cu8K4M8aZfGLOoXCSWi13Mktzc6fwOeY0gB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2160", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2160` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATdSWEBhgusNc2zFIe5gDgUnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NGM2NmEwLWZjNzktNDllZS1iMDlmLWQwNDg1MTRjN2ZlMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ5ZjlkNDEtY2Ni\nMy00MmJiLWEwYTctZDg5ZDczNjY0OWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnTxls8wIJJ+3i/5qwVcZhK6k9gpKVRapFJ9ObEQDxLpMMEj1A2uyGDvqawfY\n3J6kJOUott6VEX+tO9pCFypEm6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj1gC8ffPKwQMAj9PwqjLi1+Vu+MwHwYDVR0j\nBBgwFoAUcPC3wNhHCZtqIHSOQfPhMWGg4BswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDhmYbx4lm90nYi77a4RlzaGx+I4rsWlhmti9zAkQKH9AiBGez3TxS6VcG8N\ns/6WSYq8p28zgbgVziFidnVzfaKEIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd8P7skA4KydElIGsnooi45UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODRjNjZhMC1mYzc5LTQ5ZWUtYjA5Zi1kMDQ4NTE0YzdmZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiaMOg9A5cdeIvBcYXvMtXoms7DZe7h6GeY9WqSqoB3FCZ\nEj1k0rG+BexeXKywU5QTDeiXcB6axmpRGcxfdagBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcPC3wNhHCZtqIHSOQfPhMWGg\n4BswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeoLxtLGGhypAG3XoZAJ50XEUkEz0xwu7GmMQqMFJUgMCIQCbWgHuQ+Yh\nyp3ZIrlTA5fa5/VJyPLUQlHfVwW3AWGmYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAZeJjb0bmxQyz8XIYmJi0VGUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ5ZjlkNDEtY2NiMy00MmJiLWEwYTctZDg5ZDczNjY0OWQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0M2ZiYWJl\nYS0xNjYxLTQ0YTctYmFlYi02MmZmNDdlYjA3ODEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATNJq/1wm5Hndb/Bu9R66oP5L1x154Tw06G5Amlu9HEj457Ls8MKMye\nc8oopWGw7FN6bPsZZvSluJnCaMySr9kio3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPWALx\n988rBAwCP0/CqMuLX5W74zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgXwIGksLJDuBMuhMJLaPhD0rgY8i8sTlTM1k2\njhi76xUCIHtiZAQrCdKa6xcJWO8TZx2jle29xRaRzp22rV+jeDeK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2161", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2161` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAbQuyIBCAnYA75TesTn7PijNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyNWIwYTc1LWE5NGEtNGEwMC1hNjQ5LWVjODZmNjVkNjdhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQwMmE4ZjUtNWMw\nMi00ZTg0LTlhMjItYTgyMGRmNzM3YmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA6X10x1qHfKBkZjLTzDVc00Y3qdqJsjLYZip6S+TSb9SC2MDL8w1DnVCJ/v+\nMbmg+GDN6oaGCTUjO7+Pb9uH3aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqqTyr9k92G7G7xgzfY8PEj7c4howHwYDVR0j\nBBgwFoAUjMB1gJhdoKn3blep+mEdph/CEWEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAkD6bIcHUFssSFjKsX2/R4ihn5L7o3sV69GJMS06ZmfkCIQDOenuYm4rp\nx6AbjC30R1AFb73iAnL2HpIMgllM0zKQ0A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcJPw2Gu+KkDL0yjlgL7hEXqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjViMGE3NS1hOTRhLTRhMDAtYTY0OS1lYzg2ZjY1ZDY3YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATITRwjJ6oRh8Nmw45XE9O5jnln42pWktunTT/hqUZuSwoq\nJ0nwJ/zPmASVvYn3txb6hseTN8H5YwgdBl6UauBpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjMB1gJhdoKn3blep+mEdph/C\nEWEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgal7rWXnEhuS92wcCH5CbaUumPV+6wKu+4z0TJ9sF2E4CIBxmH8dDlpTr\ntsc4Q0mYvFHClWo1D7Q+VFGx941ZAY0U\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAV0O4sDUNXNDkrX1loYv5CY5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQwMmE4ZjUtNWMwMi00ZTg0LTlhMjItYTgyMGRmNzM3YmUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNTI1N2Ew\nZC03NDdjLTQwZGUtYTRjNS1mYzRmZDRmZmY3YWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQEaQKU7CRGVx24q7jpIMaArKo7ikYn3RjWNECp+hV2jI4B0WIQedTn\nR8sQI1yJXxux8X1aq3t8kWv/4LWrY31So3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSqpPKv\n2T3YbsbvGDN9jw8SPtziGjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhALVlMtPyFIdKAf+NV7qxL83Exl8LfX9iEykb\nqJYZPI+HAiEA7dHsVp6eYpNuOQdMNI2TPMhvRNVhQNUSO0seJ+7hMcA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2162", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2162` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASKXWUUE6o3QfruB50nj2XJyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmY2MzZDdmLTk2NjEtNDVhNy05ZmUyLTA3N2RmYjE3MDM5ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIwMzI1NTktNTVl\nYy00MjAzLWI4YzktNGI3MTJlMzE5OGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAMuQCyrJgH+Iv5T0bEmk49vDrxq2znABoQmWegxG3s4/pjeRZ+yxeHkS/tZy\nOka0D57I1YLOHhrm48riqzdsPaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJZZHD88d38j6QYhYY+hNFy1sE34wHwYDVR0j\nBBgwFoAUSSV15u06Rm+264KROrwESeRlWl8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAuNpbefTJwTP2M8rw6YhulDHoqPfsLDTEi69UemmY\nJrMCIApVT8zvr7C4ZcSC1upNTnzVETj5Z3xzGciDVuRfoFtl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU7mbgfUbA0S6jAgsPgl7mS7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmNjM2Q3Zi05NjYxLTQ1YTctOWZlMi0wNzdkZmIxNzAzOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsGlHTVhfKO8IS4uH77saG2+ABi+NxrImoYm4CW7ad+DKE\nGzCvPSB/8VRjqKquZ2DX9g2yoSEMI6X6I/5clQsWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSSV15u06Rm+264KROrwESeRl\nWl8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALuFyzG0T/OQjmbxr1TF+wCNudD6hzAniYRLxW5RR+TtAiBYB552pShp\nu4+B9qd7YcXGjGOao5tPSs4KRrA3SfJ/yw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAWTf0sTybplrajAkMZyIvn36MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIwMzI1NTktNTVlYy00MjAzLWI4YzktNGI3MTJlMzE5OGI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MTMwNDk0\nOC0xMWYxLTQ3OTctOGU4ZC04NDc5ZjMxYzE0ZGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASaMsHJjldzvVw4b8qdME8BrIHJ7G1371LVvI08mFUkD/Fpne11/ZKq\n9s+bQQ8c4s8WeHvzauv1QmtSyJHy6KfUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQllkcP\nzx3fyPpBiFhj6E0XLWwTfjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAM/tU5ljWeL49ioJ0Q67CpZytsdzTcUiNl9S\n+nK0TETBAiEA6UzEq6UR1nGVkcJeEr0JfHjud2RJcaHKKTaIhjd6a4k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2163", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2163` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWZKtUz1Il24KyZvrRPFE0sRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlNGIyMzc3LTlkNTctNDhlOC1iNTg2LWJlY2E1MGU1Y2U4MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlhMzNjMjgtM2Qw\nMS00ODgwLThjNTgtYTVlZWE5NTk1NzBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDE7JDutEKaMr5IiQfYdxwLYWQHSLVoyt21MBsaFjD9Ml2UK/YGxFCMW08is1\njo7cthavHYEe5YL26i3psVHLSaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDX1sVbJ9MsCcomyrximEwRYDlvgwHwYDVR0j\nBBgwFoAU7bm2yHUA1la2QqfmKBS3TTbb9hIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBgKSIPC+43ma5+m+Ps+UVX2RbDgRXT/vgH5nNaZvqS\ntwIhAJbuW0TLDCNydf50HmU4+UyDLMe3THwWys/Yi6AjrzlI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfefDiEILUUxE9/ELxw3KP03MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTRiMjM3Ny05ZDU3LTQ4ZTgtYjU4Ni1iZWNhNTBlNWNlODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkhaRNAWjliKYhNUoT5DSfNtg9aZEABq+sZGDRS0LMFIG+\n+E3XcwwkFgUQHIYcJRVO9NUQwSOaq5TV657RhdpIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7bm2yHUA1la2QqfmKBS3TTbb\n9hIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANqpruZiruSNTUYRXZOO7lGU1buv62zArX7kRfyMb2hCAiEAlSSniWHn\nP+VGIf6BYwUJmGrHtT2wcHkV4ozPaQGDA3c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAUS+J50fvtzb9Phmq1m9ncLpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlhMzNjMjgtM2QwMS00ODgwLThjNTgtYTVlZWE5NTk1NzBiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNzE4Mjlm\nYy00OWY0LTQzYWEtODljZC1lMzNhZmRmZTk0YTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATfmB+L6kQRTKJbt6nr3ArdXmPjvafCisLx26+gI63MgAVAmWqJzLhr\nc6l86+1Qj+jYOXYpJ8HCcW/sQvm1pm+9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQNfWxV\nsn0ywJyibKvGKYTBFgOW+DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPXXXYkzAueBswEue4Dga/lzy9YeCUYnUG8q\nyVXfXPFyAiAtar7NQWd7iM/qNLRTQmyKt1zgL0BauDR+rWgukrqLIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2164", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2164` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISASpZ8DcUgnNWzVb/5nyNv/FtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNDI1ZTM5LTlkYTctNDk0Yi1hOTM2LTIyYjU1ZGY1YzkzOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IxYWViOWItOWE4\nNC00NDI0LThiMGUtMmQ0YjM1ZTVkZmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtKll78ejNtmSlm/tqSJlPYKwgVmZ9OI6JsxeQ31X02+myBiW5fASFUuNwh4M\nnQklolcWlbcHa5g9vMtG7cjxzqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd9rlbvNf2zv+fHCXzsJy5v86Q8owHwYDVR0j\nBBgwFoAUJxF48nh5JPZXeDCcpUs1/VcgeRMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBUQewmNGx/lkHCxijFmJXin7xg+lKuciwHzMOzv6uEYgIgH+Ye\naLHzjqLD/MV/szU7+J5N4MaapO+BqTTmf3BbkTQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa7FQCKmRyU4EM5feiF9I9zOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTQyNWUzOS05ZGE3LTQ5NGItYTkzNi0yMmI1NWRmNWM5MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTSKUJ1D0U+hHWX+NHLjl1cxBauxaPYKVi62BcRE9lSssa\nblSGbufT3mbLBEBY2xh2xZ/NH5NgqwyfnTk+3PXAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJxF48nh5JPZXeDCcpUs1/Vcg\neRMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIOjgEWDzXCUBhgx0ILJn0ELWIFYMwmTMmam5W88pJFzAiEAg2XraWFy\nkJenlFyKX7ieHScVHrJ5cfya6hIHEl2DquY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAcwrIFW8oX2Cdwzc+efH6LGxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IxYWViOWItOWE4NC00NDI0LThiMGUtMmQ0YjM1ZTVkZmI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZDQzZjA1\nMy03NTc3LTRlYWItOTYxYS02Y2M4ZDM3OTQyYmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARYmOi2n1c3OmxdORQclfF6xh/zbSNxWqRTr5z4EP3za8nJfH0vINWB\nkR7tjhTp3V8+HgzYyWYSt0ZSrse1JHGto3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR32uVu\n81/bO/58cJfOwnLm/zpDyjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPN/FoJSbqizOrpo/Ajc/J1BKjlgIBMcloq0\nEOuWdrLxAiEAkmgH6YcplaYQRQ1hVTK8pqzDiWiZbH9VKu+KsZKztT4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2165", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2165` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARCbTLWJWi83NSMZkQZQXGLPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhYmNlZmRiLTdlNjAtNDk1MS04YjdhLWRlOGQzZTNlN2VkZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBjYzYyZjEtNGVm\nOC00NzZlLWIxNmEtY2MzNWE4YTgxNWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkdt+3jW05RD7qKvuiw2L7NW+fXI4kaN8+RxqRe4NZsdT5DtQlxSlzzOWPH54\n/qJfC+kbb4L1fvelkl7bAxJzMaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg8GTYQSA8XllQCLJ4gs5DgRkMBcwHwYDVR0j\nBBgwFoAUm1zbIIFGt6E75llh2Og3yt0udRYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAycgNdkOedNrwOgd4G6rP/2ZKlm8KQdFQ\n0cp9zZLydQsCIEE4SPNMdpfl6ilxmSj/O4hfy1nAyBUgw3o1/e3FWahG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQxXtUenbHwE1tk6D5JoXWZmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWJjZWZkYi03ZTYwLTQ5NTEtOGI3YS1kZThkM2UzZTdlZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIoz1UjH5L6UZbkJWSCdUOwyIDefu4QwZx2pQ75aM60E9j\nYX305JFTUM7Lc3Y3EIPaGsdUaqaC9Hwo5Wd1Vldio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm1zbIIFGt6E75llh2Og3yt0u\ndRYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMglu2auNf5LWPZ6/Az7DMxtNdD7ZvXNFN/Bk98RKfZrAiEA5bXcA0YN\nIw5chiasFqJERcadYxMqf2NZX6HGuQrrYTs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAeAqhYiMPC6Smml3QK4ITHlOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBjYzYyZjEtNGVmOC00NzZlLWIxNmEtY2MzNWE4YTgxNWFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ZTdjMjBi\nNS03YjNiLTRiNDYtYjYwYS01ZGVjM2E5ZDIzZjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ2HNFn7JL5QPlh+C/McbjuhhKzxNktXUAvuvLUsGZAQiKj4X+eiFSR\ngUr66akB4S+AEBoia8kfJRBdEIPYd488o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSDwZNh\nBIDxeWVAIsniCzkOBGQwFzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhANPHv6ma/N/f4CJ8iifEqKEymELPgoor0sdU\nUIQIbfwPAiAUWRMH+H+xol48xoZN92bPQs1MRPWju5UqqVBVuf8SSQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2166", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2166` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAUboB42Hfdugm7ccC4OgyRuXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YzA1NTgzLWZiYWItNGIyYi05ZTM4LThlZDljYTg4NWQwZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk1MGUzMWQtMzJm\nNS00YzE0LTk1OGUtNjFmZWVhZGQzYTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbYs1Ple58aFitEupGX9jJm0f8a+Gc+BH/Ovoiao4c4AvUsdFeWQU1PVvyS4s\nBg8+5lLy75xFj9vuT/4PrPNlZKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Gpdw77jgWEGyIS7oBck2dvRoT0wHwYDVR0j\nBBgwFoAUUps7BAdR2PzvlaHp6nQaHnH38wcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAs/IA4Jwvmvw9lDBEp08bO3BM1pgA77Bb\nV8sfQgtpBqQCIQD5YO041YUQa3cqP7iprs8Yss9J5DcLmUyZ5N/3S7erEA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUa3vM9ggEWZlxZ+p2cwOIwuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWMwNTU4My1mYmFiLTRiMmItOWUzOC04ZWQ5Y2E4ODVkMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToSXZKtPkFrCSQ/9xXSwJCtRcAjTIdocFVEcd6DwG8p3zM\n246QW6xGxPe88ofLn2JBM1KjueOSc9nerg4WU4zYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUps7BAdR2PzvlaHp6nQaHnH3\n8wcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFccXj+8ZTi/ejrcSnHPdyRvcs2ZBfuoSfSxJWseIFUECIQDbwOCSQPXl\nZLFmawDsMNl8oCTDD99zOd4HXTz3MqXaQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAUqHA0WwmnRpdTWMjVqKi7nrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk1MGUzMWQtMzJmNS00YzE0LTk1OGUtNjFmZWVhZGQzYTA2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZWJiMDEx\nZC02OGRmLTRjYTUtYWY4Ny0wNTc1NzNmYTMzNmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARZH6tb6Tc/WnT6jy/RZa3E/bLJHd2GAqxoEVrvCm11cA4fGg623Vu3\n8/Sn1N0ie+lpWURmwm/NDASV4sR1vypzo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTwal3D\nvuOBYQbIhLugFyTZ29GhPTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPtNZjLNAKBzDhGIY6TYFCy5DmERIDGN0Bav\n65C6Roc3AiEAtNB9CoCINPBDqe6C96dsCi4hf9cxCfwtMANAfmHBjZo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2167", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2167` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAXiFTbMuSEI+Sx7isBInDDO+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5YjQ2ZDBiLTI3NTktNDViZC1iZWE0LTljNWU4NTRlMGU1MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg3NTMxZGYtMjMx\nMy00Y2JhLWI2ODMtZDFiYjQzMTRjY2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1A+mLzX/blTIDfCO1VCr0QSPnAgkz9hNtEhPWCmNBP+AiKXYGo0m5opdhHs5\nn/E3xDo3IiQtRjt2mmoRfZ2LE6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUINzUV2SybJB+UpF4+upJEu2zsmgwHwYDVR0j\nBBgwFoAUayaUA+Vg+yA6vlUwfCVHQgmEAP0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCavhSiSiJTw3Qbogx3/O40ZKK1\na4GjrsYO3+zjFv6tmwIhAJrydHppeOmqjzUoQzsplptoVI2Gu6lcKX0UIGG2nqb9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaeQ8q85cuwemj0NRrrEQci4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWI0NmQwYi0yNzU5LTQ1YmQtYmVhNC05YzVlODU0ZTBlNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcrSHct3x78PnYdgSFd/zU8eqfZI5M8e3JFY6aDMlFGmlW\nNGuzCTahFLzt8JUemf5NiqDd9anG55L1TECdAK3Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUayaUA+Vg+yA6vlUwfCVHQgmE\nAP0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI34BCYt2VZgrlR5QYcf8GZInV8L4KwvWi2zm/gy7XsFAiEAg4Jg3HvW\nUwPNzf7xYYBbxA6hGo9B9zfBurzFLwaTTJ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWP8J9EdJpne+ZD8q0rpRP+sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg3NTMxZGYtMjMxMy00Y2JhLWI2ODMtZDFiYjQzMTRjY2E2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNDdiOThj\nYS1iZGVmLTQ5NmYtYjhhNC1kYTc2YzYyNjAxN2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATFQeHkfPL/iyHnRR+jAQJ/Wg9MbbrO8OkIV5zCKaTOREAuqJysV7lS\nptaJsBH0xV0URO8YJUcat9F+f5olupxlo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQg3NRX\nZLJskH5SkXj66kkS7bOyaDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgIV9wHDqb4L/cc4gy6iZ3ALpVa0BLBipzi++8\nDB1/oZ4CIQD/6mCFnN7m9BBRZdbCCD4Jvy4cszeTPJHUYB8RHqggOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2168", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2168` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAS+NTb/OAaT6R6rJsNNju46oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmNzU0YzBjLTA5OGEtNDhiNi1iYjVlLWY1NTQxZTZiN2U2YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI3OTVhNjItMDJk\nMC00MWJhLWFmNjUtMWFmMTU5ODcwMWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXM8qVFlFqS4WsvLWaspZ1IKuNUulG6UuS6bJ1WGzEC/9F8VK6MoObVGjw5F5\nFMQb7UbHJEbYOx+uL9dGDrs/8aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU86DIVWzVtgJTwtyJhbqyWCrkHQgwHwYDVR0j\nBBgwFoAUGs8R/+pQI7Cp79AT3RJTFLpITh8wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgY1dwq31p\nG3fkSHg6U+AlMiNqzkCMRiURrg9dTV1jeZ0CIQDicEG33ZVnlxx9Y5dIZSbVhdO8\nZ3JshJMSqkS9Co8MUg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdP/I1aCW0bNT7lruvdFYfmNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjc1NGMwYy0wOThhLTQ4YjYtYmI1ZS1mNTU0MWU2YjdlNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4HNKQeWYSkfLN3OGCGTfbxoE5VknclcMyyWZ2dE7ACZnr\nxi3QB6B010J8KvHqAATF1IUdGbI871AlPqa2+gZio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGs8R/+pQI7Cp79AT3RJTFLpI\nTh8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgddFj+qQ5ImEDDEEIZjSTQj2YWs0wAdlAKLGF4+R8yS8CIEwLCtXdUzGN\n/XmLm6CfmL15Cv0XcC4n95IY8ao1Y9Ji\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISASv+sF11Xof1gyYb5Qe53HHvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI3OTVhNjItMDJkMC00MWJhLWFmNjUtMWFmMTU5ODcwMWJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NDVhM2Ni\nMi1lZTAwLTQ2YjYtODMyYi1hMjg0NDlkZjY2NTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATpgrPv7xYkDeVjbSPJoRf1rqaIL4Ql0GmES7nH9WM5sRvb+lPnNy3p\nKFj6W93sdatFqigYtpkWE2NpB6wbhkNAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTzoMhV\nbNW2AlPC3ImFurJYKuQdCDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAK2Hq+6v6/CCa0qcD9ZzN0moSWQ3HaCPwDQO\nRZ0HGgOeAiBjIBKFsSQUmU9Isj5I+Vzz6bPZk9vlUuEZvHXrQAFgCQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2169", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2169` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAc6tadrOoO7/sarX7nZvAU+2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViZjFlM2RmLWIzZjktNGI0YS04N2ViLTQ0NTZlNTcxNjI0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI1YTdmMjYtNGU5\nYy00OTUwLTg1YjYtMjQwZTI0NjM5MTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERoCxJgTrENkzYpY79wYoQ7WuOc/UDkhl0q0fE+q3V1TTdc2rbY0a8uK9i/U/\ng+3jA+ZYgd02k164JaywilZ71aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWC2DqpJHy9821REnPsrggYG2T8owHwYDVR0j\nBBgwFoAUFjensWja4WG7AGbyEFp/3WwQ8o0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANJCF1fP\nCjCeqAwoBwVjyvd3iXdvhPKpudh5M40XOFKHAiAOb6GygXcNx1dTGngscCHUG8Db\nwYWcipba3zYspbSarA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASbtHd/VEj5iYjBWw6xxSF5DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmYxZTNkZi1iM2Y5LTRiNGEtODdlYi00NDU2ZTU3MTYyNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2ikdWL6KeMy/zDT14nFR4/t65PYc/X06X5bR+54f4PWDk\nJofUG8UNIuF9tpLlb6UFQ7/+8kOnCCOJcVVbgV6co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFjensWja4WG7AGbyEFp/3WwQ\n8o0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU+TtCw5OQuJghFo1LRaIp3GIUo8EZYNgM/b/x9H5wR8CIQCYWkTAjkUI\nMz8E4tviT+Sf8AHzCXvxe1VUmsa+ADWbgw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAa1ZGbwe7754+xVOQXqHBK2PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI1YTdmMjYtNGU5Yy00OTUwLTg1YjYtMjQwZTI0NjM5MTc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMzY0YjFj\nNy1iNWVkLTQ2MWMtOGEzOS1iMTkyNzY3NTU2NDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQqoRlsRQgqs/lemlnhFM2XXDVJnRUvn66GeNwFedHI+Go2RjvgJ37o\nV/E+Yz08wyXHUMSDOTCbezY/58pVPLIFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRYLYOq\nkkfL3zbVESc+yuCBgbZPyjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAOdrju9xB5Ov4ypO2TAbzd2VRNdybaEkS5gu\nVWJfKhwAAiB5dDRk0wgFlhE8cKNCtJEe0+4VXzAF8VC3V8kcA6vJpw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2170", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2170` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAV5gi1Zb8QdX9MySJ1z6R/MvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxYjc4NDhmLWFjZjAtNDI3Zi04NTZiLTI3MTFmN2Y0NTE0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdhMjYwZDgtYWY4\nZS00NjUwLWFmMjEtMjNjOGU5NDlkMWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeWHxN1u2teax3R33UkI5GgT6dv2mHObB57sDrKUldXAhQVr6FdxnnDJm3sfq\nmEff3iGqYB8gueflYTwKDDhFgaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOk14jiv41oOkq8ybmRyxV3wgS9swHwYDVR0j\nBBgwFoAUA149JHtzKb9nNk4clJa+tD8utXswLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDlQCmS\nCCNJui1OpjuMWRQK2j5gKY/Ekr5CPwmJHzxUvQIhAJ0YLqifTjvzYg9L7BQdZPKJ\n90PIizBhXJPi8laHHWBB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZUzlUfEIzTd5OAlOWiNE1UpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMWI3ODQ4Zi1hY2YwLTQyN2YtODU2Yi0yNzExZjdmNDUxNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqFUMa8xdCp83SyyvWUTE+F/hhcyB3RWqZNWF25V6bjRBy\nD4XDMJks2WP32a/qrb62OtLqXBI7rSpJuvpP9D6Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA149JHtzKb9nNk4clJa+tD8u\ntXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfg11jQQ4le4dkprntuJ1qRx+acl4jn0d8RrOdLqDXpICIQCituLLuLBk\nfNOra4xHiwRMzYI7O77pthPIp6sLae0xXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISATpVRSpiqNHkUQ+YBC+WdfKyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdhMjYwZDgtYWY4ZS00NjUwLWFmMjEtMjNjOGU5NDlkMWM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMjc1M2E5\nZC02N2Y1LTRhMDMtYWNiMi1mN2NmYzMzNTJmMGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQCJpcNKP52QRLUlXj8Qarxl+MTSaoN6pyklmHMrFZ04T3LBDKSHCAm\npCyoxD80Qv1uX+fjVcYToBIaP06XIPMIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ6TXiO\nK/jWg6SrzJuZHLFXfCBL2zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgR2lzchW1OfZMCON4jcnCPky22HpqnFmMlAvs\n+9DcE5wCIQCLywfc3fZLrTIA6HFno6q6sym6y3watrP15akv3gss5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2171", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2171` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQd6Rz3KkN3YMyzZgJXQ+7xcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5MTNhYmFiLTg0OTYtNGQwYi1iMjQ2LWE4ZTQzZmJhMDMyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjliNmYwMjgtNTM4\nNi00MDE2LWExZTktODY3MzEwNmVkN2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Ngoz1F3NzmZ94k40lsm9V3LOI6Jvcz9AQIU2JQBk8qgIz/WCoi00jmcxlYy\nY+mhJsqWS1WdmjFGWDHsD/dQwaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+7H50D+MCCwNWaCMhyQdS9lMlYIwHwYDVR0j\nBBgwFoAUz3sycoJ8k338FNWJTcB1H5z3XpcwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDOkUeQu+Xl32xnLWS4wCWSQgA0BvdWIZSgjDiOScE8OgIgYIUieIJQ\n1MnjQykzbgLymfXi0oQtrUcDXBnNBBeuQN0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW4IErWmY0kxSwHtEw7s0SGWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTEzYWJhYi04NDk2LTRkMGItYjI0Ni1hOGU0M2ZiYTAzMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROtMFiiBSItNcQ4nX4Z4+6JcMnd1Dmeb0kNdtk6FxaNHg7\nLEKCzwkNDME5j99boWkO6KFFjqBya5yitNAlJy78o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz3sycoJ8k338FNWJTcB1H5z3\nXpcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW/IxONf7SU6qmQMNgVH8/AOyxVy0SBtRFH78aAdvedcCIAjuPgzEhSqs\nDaDBtanlM/dw87aJsR4pG03nQJbz2Iwi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAXhIVERpJc6AUxVvAYtlqm2nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjliNmYwMjgtNTM4Ni00MDE2LWExZTktODY3MzEwNmVkN2Q2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YWRmMzk1\nNi00YjBiLTRjYjQtOTM1NC05Zjg1YWFhYTkzMDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQp6s3nuW4eWkq2KW6aSSDSV4NO0PwTR2OSFURqbl1LQTqVd62jS44J\n2qc2oXOfo/bRL8S87Kt6Kg5jLjqovyX/o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT7sfnQ\nP4wILA1ZoIyHJB1L2UyVgjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgH4+jIhwokf7V1AFgETvGZk9uBaaN4s0UgRtZ\ndkRDXLICIENuDJnKjzio7k48YjVyGjc0rgdmh+ECCxNXUPjkPp+K\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2172", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2172` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAURAVSlNZmqFoqJtAu92kDnHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2OTg2YzQ0LTJhNjktNGEwOS1iZmFmLTM2NWEyOGZlYmMyMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzkzZTBhYTItZjkz\nNS00ZTYyLWIyNDEtYWQyYzgxOWRmNmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdacWLdFtSdrQL9jluhctjn/+p+n7/aeAWBg7z87K0RFIgci7aBVSNEg1VCTu\n3u2J+kVVdz13cPVsB/bjcixJPKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC+Qk//UU3JtXrQc18Zwcj2BsgLQwHwYDVR0j\nBBgwFoAUDAkoUuKFdnhL+2LL0xYOL7PpNhswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQClqebD8I+cn3hsqLQX6PBPemr/QFkn0xBf5SP03uoR4AIhAJ3Saw+H\n2Jtt5ySHPUX2SEsZfrvsTphRGcXQmjGhV1Df\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeOH8f1SByms9e6hIp/A7n93MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjk4NmM0NC0yYTY5LTRhMDktYmZhZi0zNjVhMjhmZWJjMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKMToZRVxFTuFHwEdaCDIm/WL+3oLS0JWzBurDlbLtxmV6\natbbVbvM0u0KXARegNJ6IvPwOU53ZyU+D5A/kk0fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDAkoUuKFdnhL+2LL0xYOL7Pp\nNhswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIVKTVPe1WSxHoTcEkeXkdSomr5WCKp9B3K+UP3mBVy4CIQD7i56OfrwM\nbIOWwN3EcUah+JYGhmehE8x0co1tdpcekw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISASc4DEuXjGYZn+aeXXm01ao0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzkzZTBhYTItZjkzNS00ZTYyLWIyNDEtYWQyYzgxOWRmNmExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYzg1NmQx\nNC04Y2NlLTQ0YWYtYTNhNC04NDk4NGNiMDNmNjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARaJziiPUFKxaepCC5ayrb67r6O7KmnQKZ17eCoZ7N4nE3+3NsDpnAS\n2e3OPEBO67AQPE5PdG8zhEGmRbyugPtUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQL5CT/\n9RTcm1etBzXxnByPYGyAtDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgaXe+GQUYYjnJ+Y5S1b6ZPp1bh6loMbI0rdHY\n9cnZ1hACIQD0Sijt+vO59OwdawPhiEPG6/c7qwpBuiGm5UuWD//kMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2173", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2173` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAb0zTh9ZIAt9Cv2SyF/v4loWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkN2M0ODcxLTFhMmUtNGUyZS05NTFmLThkZDhjOTg5MzdkZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI3MGM5YmYtMzUx\nYy00MTRmLWE5ODMtN2RiMzllNjhkYjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETRW1bHqx3qijkJH8TCeHNoFMNaAfopSDyuOuikYjuEXodSOkoG5LVb6B8rmP\n0OkbZJA7ekwqdt9bh6vyJ40UVKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9N1g/r1bzu0Dlq6lSZ2kylr7uvMwHwYDVR0j\nBBgwFoAUOU12AhxLIE+pJXDXD7HRs8o1j6wwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQCNNtOfHVoIEedQZlfcEKkciwbmAPQgpNQLzkVFQCE3bgIhANUP5k/QwNccnCtg\nUZGKQEBXTFhygBRmA4/F7V92MUAY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUHuCJtTrPQZa3z+wp8YdVVfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDdjNDg3MS0xYTJlLTRlMmUtOTUxZi04ZGQ4Yzk4OTM3ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBdsbeZN8wKL8KxOARwcPu03rSYtoX/1+CG0EdQS1LMItW\nmC6C7qhI6kztkMms4THpxLnhKvU9tHEQbvK/mC6zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOU12AhxLIE+pJXDXD7HRs8o1\nj6wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALoDXqfgOFdjsXuJW8KtU8xbxd90C+p5ycssSHSCo6MjAiBZUGR+LeQg\nyzlrnlwtBGKt6V9stAKrF2hsudCo1/B0OQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAeMjqdLDuSJfF4ayf6+ayL65MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI3MGM5YmYtMzUxYy00MTRmLWE5ODMtN2RiMzllNjhkYjI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNGY1OWQ0\nMC04MDJiLTQ1NTMtODU4ZS1lYzAyZTRkN2NlODMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATl7B6N5mdlaz5+tsRmwFhR1b5by5Gfw6iTBIP0iXBEgi61fHK9FEbt\nC9EBJuuoCmapxed3ow28vyB+b29JlUmFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT03WD+\nvVvO7QOWrqVJnaTKWvu68zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgDZG2PoqsjyI7gpVM5O8xdAJ4GGLlO9AJmxy8\no+glfHkCIG0hqG4S+OXH3k3YDnFn6BK2YrdsX8K5XsuWuO32kMlU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2174", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2174` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISARhX1wGkB/maxOQthMLCZXXyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhNWUzYTQ3LTdlMzUtNDQ1NC05MGE2LTEzZWMyY2JiZWYyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBkMGUyNGMtYmY0\nNy00MDgyLWI3NjItNGIzZDEyNWE5NzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPXBkfylNBKcYlU41qSDhw8rG9p8m1vGxjltNW8qo1QSMqtQ6M4soPA/OdXFW\n3DBa4dS2FiluAZb8uMdUD+aBlKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBsVGRo5adup4C0lDR7OVu2xHNKUwHwYDVR0j\nBBgwFoAUq0pFQDrmYZHmpT1Wv6fh5wxehAIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIBpoc4+F41mSQ2rpEtAj9W9yXNEEZFxnOzPBnwf8Ys13AiEA\n5ZPBH36qwYG/nuidfGPUvBXRk3tFORELyTokKq/Qr4E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdAXnCM+0ETiS5PNWdB5gzxyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTVlM2E0Ny03ZTM1LTQ0NTQtOTBhNi0xM2VjMmNiYmVmMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsFRD0qfWUK0vJ36aXxUd6hnnbJllv4xTbmEVOGqzaT8M3\neqjavDqnepc30IKslhc+X7p6kU1yi5GtkkHSh/WQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq0pFQDrmYZHmpT1Wv6fh5wxe\nhAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO62/C8JaqMHSb9jFUGJ4R6L977voG2wYuc9vN9GuRffAiBskcv1Cesj\nEDO80k5KybORjkOA+oR2MG5uxB11GWf1Ow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAY2ElcoVSssmSj8WldisdFQnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBkMGUyNGMtYmY0Ny00MDgyLWI3NjItNGIzZDEyNWE5NzI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMjhhNDk5\nZi1lNjQyLTRjNWYtOTI0ZC1jZGM2NjA0OWI5OGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATT23wLchLYuE3Ht0ru0A/NSIs9ooxgJUSwPYr5uU6gHSCKj+tk68N4\npwmKmVaA+fXq5tEg0Qna3DxMuiSkKyA8o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQGxUZG\njlp26ngLSUNHs5W7bEc0pTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAINrjcWTNIAooclRpQ1hPETN1gWn/8XmlJ+P\nlAvr+quPAiEArs9LKzv/yC7eQr/won9JduNn+UNgoD82Tceu+V6uF5k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2175", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2175` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAdtMnv27JieG7b6sSez+3exKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxNDVkNjUyLTUxNzYtNDM2Yy05MjcxLTgyMTA0YWM0NmJmZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIxNTJhNzktYjZk\nZi00YzY5LTlkMjgtOGIzMGI3YmZmZGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEomRXbVknEnn/ZKdEw0xZgPqIkU1aSHwE6TYLgdfc2LbcOO1qAUnV5O9RoBF6\nVWunmJLK6M5pb8bstKSR8muY7qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdWrzpQmjx54w7JLaF1L3Rs0Mf/UwHwYDVR0j\nBBgwFoAU6SMH+vqillM+ttRJVF2pbslOq5YwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIBDNnmezzT6JanYa5p04AsjcSiORk3ME+HgjlHcWKLphAiBa\nYwNEwPruLw95eMZaTkEI0yYQfzY18NXnONvcV1x/og==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAck90SoPa/BiDcnBN7MmwWnrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTQ1ZDY1Mi01MTc2LTQzNmMtOTI3MS04MjEwNGFjNDZiZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSUVq4R8zXi72I+euZXg66YLKTiTQKrWVARqvyJaCGCilC\nJMAEayGlY/jIllPVGfdwTpLTW1sGWxw51FVyD5moo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6SMH+vqillM+ttRJVF2pbslO\nq5YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQU8Obt4spOxgbO30YC+pM9c5JptkQxiWARqwM2tYH34CIA6mXVB12UK5\nQ/GbZ+3n0e9vJzkw13L5xOeAqCBrTFxG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAefvgh0UWdgpErXbcro8IkFGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIxNTJhNzktYjZkZi00YzY5LTlkMjgtOGIzMGI3YmZmZGZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NGYwMzE0\nNi01YWI0LTQxNjgtODFiZC1hNDM4NzI5ZWJiNzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASOzyxxtH6RniOunWTJHtyd2AeNR9G5Lmc6QQKeHjTcodDfmMvpL+tF\nNO5J5LXCQq0UDOsCXayq3pQ8iJPRZNFxo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1avOl\nCaPHnjDsktoXUvdGzQx/9TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIge9pcSUEq9ha+Qc9JtqCw4Vg0O4hVeFsyeEN7\nv+Qk9k0CIGNtdNDPVTNWkVPFmTGPIHjySYTvYTfBxwsDvHozqrG+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2176", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2176` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAaBU0WbwS8U+bgFaGC97TUvBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3MDY4YzRmLTJhMTAtNDIwOS04NmE1LTBjNDU4ZWNhMTY4NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFmNWM4YzMtNDI2\nMy00NzE3LWJkYjQtM2U0MTFhNzQxNWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ7zyJ3zD4bwV9ODR3rO2GjeTpnaOSUL2PnShxMfcM3OEur3FUgsOaKZ75wuN\nA3S9U9bUUZ9wB8kwIPdCiHijTKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwPyANGVvhoF9w79HRxylNrEfhgMwHwYDVR0j\nBBgwFoAUcYvvMQKjNI3kx1dsNQhX3bqNJDswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIE/Kl4tJ1PlU\nLfzm0XoykPN3wf0fyOMEeeZ/kQHTjAdoAiBfH62AUDQl5LIRUGsGkrR3Nyui7Cjl\n+dKopiXw39Iv/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb0E/IgnwN7gLlDXl+whurFmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzA2OGM0Zi0yYTEwLTQyMDktODZhNS0wYzQ1OGVjYTE2ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDtYPMKjMhguGd9Qxl/mZooJI0kY1P30LZXOpGkfQtUU46\n67bUZSh661R7tkjXbTeV8CKInqyHYpWOa/9Ec53no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcYvvMQKjNI3kx1dsNQhX3bqN\nJDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALdwp1EiDwTcVOQj+jTjy/1F64z9pXEUZ5jzHxa8RsN4AiEAxUft8l9L\ny3oQIg3DFFM4EPaLXHU4GilVrQEh08emco4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISATVsnXJZMNUfF402NkzyR9O+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFmNWM4YzMtNDI2My00NzE3LWJkYjQtM2U0MTFhNzQxNWIwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MWYyNTMy\nZi00ZGQwLTRiZjktYjQ0Ni03N2NjZjQwYWQyMTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQTtmFJa3BvtDBNE7n5Xd99Yp6CJYu9fjHRnhChpstJIRqp7CNUl7PB\ngcTXc8oBwSTKh0jhhsrQfTzTSSYa+VQ0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTA/IA0\nZW+GgX3Dv0dHHKU2sR+GAzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJ8QBFVdwvu9+U0nke/Bfh6Qu4WtqN5K4/Cw\nleR7y4zlAiEAzsyVPUfjqwuYMWRMCa1FsiAAhF2TDWsOpiK0RkgVeP8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2177", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2177` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAUJaOo14MwmDGv0g04YKe6ctMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyOGYwOTc4LTY2YmUtNDA2Zi05NDRmLTI0ODBhOTA3OWZiNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWIyYmE4MTYtNmQ5\nNi00NTVlLTgxODItZjk4MGI1YzJmOTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGXGrKGC5+FkZxM+KYqb1GdH7epuFCqh9FiwNmpDhnSPcHZIHQ2VfeUE2fiO/\n//u5XJ2FLy3VFWFb0o6Yz/KIFKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcgVIWrAYRE8JAFSzZNBWK4/BxDgwHwYDVR0j\nBBgwFoAUSVmPn1jjQ/+p+8A9I9Re42QjlvQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAPEWlhc4PccqNV2n8yj3z+cOcRhaVtG3iBI87ypyDSE8AiAv3tj9d44e\nzw/F77DbvUS8hS4IFNQM291X23UZbvDq4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVkvaToS5ZLaNzIXV43ERKyOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjhmMDk3OC02NmJlLTQwNmYtOTQ0Zi0yNDgwYTkwNzlmYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7PRMme84+mXcM3wKPnQdd+ApvRo37FVOkAPBLRcf+W+TM\nD8xaQXNnwo8JlIFfcD1DUy4Mk63q1SFESB0Uj5/4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSVmPn1jjQ/+p+8A9I9Re42Qj\nlvQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY9K2MHbofje6qjm0FcawlhI/RRak5N7oj9/TxiG9CwACICJgr2V9Gd2H\no2wkJM1FggvKSgfikVfX5O0f2Bd1dd7k\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAR9xWF8QeGrA9l/DSVsA9eUKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWIyYmE4MTYtNmQ5Ni00NTVlLTgxODItZjk4MGI1YzJmOTc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhOGEwY2My\nNy0xMWZiLTQyMWItYWE3NS03ZTQwYzQ3YWJmYzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARcEYmHgm2szs1e30Um/BV0Rsjt3TAumnjX+nugZoBoO/GACJ1SG73y\nurs+cKoablfMcYL1trS1RKfdd9Mg4xqYo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRyBUha\nsBhETwkAVLNk0FYrj8HEODAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOFytjmi8+r7rqN1EfYmGIupkQIPvyVcEUY6\nkjdZlqiVAiEAzUEtNrE1pEjRygdJX3p4SkB9OZscjl9eTCVIcc0Yl4c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2178", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2178` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAdLczjLxQlb5X8HjJvju/Yk/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMzY1ODc0LWE4MzItNGM2Ny05MGM1LTg4Yzg2N2QyNTg3NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk3OWQ4ZmMtZTg2\nNy00ZTE0LTk4OTMtZTdkNTI1Zjg0ODM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECMrLFvihBRjOop93w4K5DkR0CUJNKRoaFzs1c9VOhCyWuREf2nx91ul0Rl45\nfuj8Xtv+noprymsSuavyazTIrKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5aY/ZbcguQjhyz+O1573yfyvIDYwHwYDVR0j\nBBgwFoAUPdvNSSMa2upJt+ZxOcr4uCYm6fUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgYa2ozHnp3A1SodNMn8sFggrAg8E56NAqUnHT15AAgx4CIHHWAOiH3JcT\n2I12Esy1wDkJy2GvffLKGAfotov+WtDB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXdGLbLTXKiHvjJrOPHqZ0F0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDM2NTg3NC1hODMyLTRjNjctOTBjNS04OGM4NjdkMjU4NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLnSUw1Qanzph6wgE5VYzsfbO0Yynej/QwjwEyG0CccvWM\nxR318xfDlxeE7AWYj1lNMdzOBdIpQitpCUSTmGHxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPdvNSSMa2upJt+ZxOcr4uCYm\n6fUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF/RCzZDmu9AENveqdexjym8roje9wZGkOzlk0ccPN5wCIQDay89NKyTL\nq1xsQ6y/edH9mj/yZrNU0VdDS9p4XhPPAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAYDbmWKM+XCCWOUmNl+NzkFdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk3OWQ4ZmMtZTg2Ny00ZTE0LTk4OTMtZTdkNTI1Zjg0ODM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZTVjZWI5\nNS00Njk4LTRjNmQtYTMxOS01M2JkYmMyODFmYzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATvALp7gx/OZ2NcoN76kPcMtz4LEdRVY87O/d1Xq84/w17W58Fop8B6\nGIT3G7aWw7ENh+EKiygWMUFuZXdLO44eo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTlpj9l\ntyC5COHLP47XnvfJ/K8gNjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOdYbBBlL7DKGaE9nAeRV5eMzc7bb5X50ORt\nCY0YbGQeAiEA7w47+ShI46J/Lblzv9zYRVoM/lmUiaeYiwQJE1Q43ak=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2179", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2179` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAWuXjd+CdNVmdFbJ8lEYHXyoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjYzRmNThlLTI0N2YtNGRkYS1iNjk4LWNkMGFmMWFjMDkxMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjlhYTI5NmEtYjM1\nOS00YTc4LTkzZDgtOGM0YzBiNTQ5OTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcRyQzeOo5EK5fRO31Z0J4h8WlXCeQTvnTdL9ZdeR8hiUnxZoLe2y+ZQkWgUM\nRI31NetTNit2W/9Vs9+P8vzGTqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ+qUAZuqwellbXi+wHbzDL/PRj8wHwYDVR0j\nBBgwFoAUkoUj+aF1AXP2M53lZ9FC8sGaATMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDFnatKUXzuwfop9Nc8/b7hSHDnnS/3pl5c8R4Hvzdd1AIgLzp9O9gT\nKBt+tx8289KN8u4jQ87oO3AJR1Hh0zgQclw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYapz/eshJYLyFMckw1cve5CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2M0ZjU4ZS0yNDdmLTRkZGEtYjY5OC1jZDBhZjFhYzA5MTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOoPHJaNcXKqkIvlURM/QJdUb+GG/+T+/GgZjRNbguR2pB\nTZziemNNINMoHzI9RyKm4a7PjXB1/aVuG4adHCaJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkoUj+aF1AXP2M53lZ9FC8sGa\nATMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALAu0ghV99qYiBgW1rjDM3eRA+Ja5xIZ9sp4f6GS9hTMAiEAikXeBLFV\ndlRrQ4PukOkYlHZRgqPKdbaHNyjxi3hpM4w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAUyxZG6MhVaW/PBaIGvla/I3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjlhYTI5NmEtYjM1OS00YTc4LTkzZDgtOGM0YzBiNTQ5OTFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MzExOTkx\nOS00MGFmLTQxYTQtYTBkMy1mMmE1YjNkMWU5ZjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7agIQVQv+R+BPiN2jBdgrhuVxIAk4pp4GL6OklXmHB9rGpjFhR0rT\nPpEUrCSJWvS4SlfeAQcKQF3OqK1cqbFxo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQn6pQB\nm6rB6WVteL7AdvMMv89GPzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAO8VZ77K+3s2StMEaZiMPV/SBQzkmkvSP1wE\n52EPT+ISAiBX/qEEowVe5VYk1f6tdOIkShbud7/umH/DKCGtJTg/KA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2180", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2180` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAT4/XCQfIQ7yoIsUqpizW4nLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmZjY5MDk0LWNlZDAtNGQyOS04YTE5LWEwYjI4MDFmZDQ5ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNmOTc3ZjctYzJk\nMC00ZDUxLThkOTUtYjhjMTgxZWMzZTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmzFOpQWmW1WDX/HreCBAvmeQpC7AI0EVg+TJ+RvYbPckPB6JYuAW5NW8+j4T\n91J8YwLOEG+70rBSeTq5oXhjR6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ7gLzWd/4jRfdu03jpiRjxwuMwUwHwYDVR0j\nBBgwFoAUrZGiTf3vJOyg8z1BJTxiQAKXKvcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCICayrf6QszATjtqV0RZ5i/CSczv9+alpDgSc8hN0\nGjJJAiEA1xIXFqN9pXmQLqg1dxp56wihgEY9ucbF8nDUO9NZ9Fk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARkT1MwZaQTACy928DUWiS6RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmY2OTA5NC1jZWQwLTRkMjktOGExOS1hMGIyODAxZmQ0OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQd07gcg9zhs3rTQsH2z9wTpr2E+xOabtmxDvacUhBhLJt\nUQVkkKjjdYviaQT4QNzbTycvCpBsT+pnh9pkRrkgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrZGiTf3vJOyg8z1BJTxiQAKX\nKvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD8S6nPFyfcMlfYaMDyJVckwNvpnmI1mkiDu6Eq/m53oCICXxEG7kmiPR\nvCxqAuCOTdWCK9Dh1fDodoZfERXPZezC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAe9zTn9KuqNlnOB1nqSd1AAMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNmOTc3ZjctYzJkMC00ZDUxLThkOTUtYjhjMTgxZWMzZTMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkN2UzOTRj\nOS00ZmFkLTRhOGYtOTAxMS1kZDQyMzMwYmZlNmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS35piv4F+5L2nEvBhdX6KudmzgWj+DgjGpAQUe6Ilpr05yguAuVxYI\nkQzLAPRA0WbvgNJxpgXFH68JfafjcVajo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQnuAvN\nZ3/iNF927TeOmJGPHC4zBTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgXf+AiUIiFHCVr1JTPvJ7X9K7lArAF75tcoRs\nXQNQTlMCIBgijjkV6YzTZagrKt0EZaNhkf9RI6C3D4fvCTNgynq5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2181", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2181` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAfT0oizCe5SRnRXxFXcAePmdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzZmU4ZTI5LWM0M2EtNDg2MS1hZWQxLWJlNWUzMzQ3YzEzYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk5OTEyOTQtZTQz\nYi00ODM0LWEzYjgtNjdkODkwZGFjYmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIA200E6T/GWcxyHROOrCi3SX96VZW0hf4GyHNbc+wXFWko4fR7iHnwmlSOGI\nz72BItlPUXC2P3CTv9IkXC/q4qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUinWZbg2EcuhaqBs9MhfLXnVb3p4wHwYDVR0j\nBBgwFoAUcTxSli8eoqejuqx0wK6RCnKQgbcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIA06cOiP45eVu5yKcZ/obr1eQ2ITc2RExgJTU5zU\nwPFGAiBQ4jHD5KfwEDNOqhOFfXrH2OWrDc9KmanKnFQEQt1+Dg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQbpTMob3+NO4riqiJOvVSJMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2ZlOGUyOS1jNDNhLTQ4NjEtYWVkMS1iZTVlMzM0N2MxM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvx/nxRQPAg7KiF41Kt3ecCTm/bpPR0wc+6BtyuezYPGpz\nzA1iUzbEp4UzQXM/zN9G6xeH1QVcdWt7fgxG7KoRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcTxSli8eoqejuqx0wK6RCnKQ\ngbcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbyOgrs9uaU9SBHCmAQN1D9DH7rqw+Ud/kcF+qqnSfhECIQCmB1/Xv/ZR\n1LZPxOy4kHfXaZO0fTjzhn2g0wdn/ZM5Eg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAeunIeDXpowGHS7WY3eQf1tUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk5OTEyOTQtZTQzYi00ODM0LWEzYjgtNjdkODkwZGFjYmNkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNTc0OGIx\nZi1kZmNhLTQ1YTMtYjhjMS1jYTAyYzJiMmRjNDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS2OGYPf/zer+rLjeaNHjb327HosEuPRmOxfLg8TAM8Zsn1Cyxlyh4l\nQhZOw/nkH72dcodl7i+yep/JfD2iFAJho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSKdZlu\nDYRy6FqoGz0yF8tedVvenjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhALo+5QMij770SRasgyCljVD4Er5zWszN60Ep\nBaC3N2nfAiEAqTUP16McmMjZKk9g82151liGounI+M5oSD9CEKe0lbY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2182", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2182` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAXXLdJcsFikMqCK/Xd3CLrEJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxYzJlNDUzLWJhYTgtNDVmMy05NTM5LWZlYmMwNDE0YzM0MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ5MTMzMzQtZDZl\nMi00ZGRmLTg1YjgtMjVlNmJiZWE5NjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOPjvlrjuNs65Gxmh6Xe48gZv+Fd/iw1dsVNKZQrOiMxMJ4REmokNzFEV5myS\nEkMVZM+08KjkvF7Lse2C9eViYKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfRVxb3dRM667+n25mOU2jWEZaZswHwYDVR0j\nBBgwFoAUIXrBMlMNUdnNYPUYfT1R6wwyTzIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIDRT7GSlJpmdriyL1/kTTVm1buOZ4X25jlZshr5OsG8JAiBa\n/h5TQ5Kp+LfWdKeuCl7uDVqnjpJCdAVQgSuPC/I5tQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaxUiLiRdoSVDdGtb15Hm8GSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWMyZTQ1My1iYWE4LTQ1ZjMtOTUzOS1mZWJjMDQxNGMzNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdPfPYZ0D0fNH3iHdAbCT7xjrf8JiyJrmp33D6+SrRx45A\nwTa6XXkRrFbclFgRsr2S++Sv7mRKkmKVah+FhY28o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIXrBMlMNUdnNYPUYfT1R6wwy\nTzIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLaf7hwXqGkKTySzzyb+VybJ/3kGy+vm9Dwa9XqWFmSECIQDDMV0auNRC\nU9PtsBV0XaIxNWG4S+ccqbMKQwgEmmypXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAQ8EQk67QERVIQGt5yp/q76XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ5MTMzMzQtZDZlMi00ZGRmLTg1YjgtMjVlNmJiZWE5NjNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmOGM2YTUw\nZS05ZjE2LTRhNzQtOTI5Yy0wYTU5NTVkMWZlMGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR9fytn85OuP9OAct+3wA6u0IQRZJnuESAyOxkTySSDT+CK7gEZgXto\nx9oIh7Ux5XHyjbDtC41bDpMqXkbTWdoSo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9FXFv\nd1Ezrrv6fbmY5TaNYRlpmzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgSsKgGGpAzUPUIKYnUHO638mZxtobbqhlrx1o\ncyD+3eoCIBJ3q1J8dANJxds5wBWCNabzsNBV1t6JXhrqikIQn8BT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2183", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2183` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVLoGgeXL45OdFYepSKFs9GKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4ZGZiNjMzLTQ3MTgtNDNmNC04ZjQ0LWMzZDI3YzlkMGM1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE4ZjdiZDYtMjk1\nYS00N2Y1LWJjOTktMTExYmMxZDUxMjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBXaYZXlAKPqrJtVAH37Zf9vXO1L2LOs2gugVzO/eDYXc+NTbinFoKyLr58hu\nkplPdjCFMIZF7bwUz2hsMlahXaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSTjIJurOZ1QQiIMe/r9n1wZQ1scwHwYDVR0j\nBBgwFoAUtlBdijrpMLuFbTqbaICD7w02iyQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEjw2cNsqPJ8B+Mv1jDTf0HekwCNHlTs\niDVs8dUYm5PVAiEAutPFntAIyz10NGUdrbK8duytRw4Tjw78mLuy28wlbkE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV1q8/aZQfNGgHnxfJWde68/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGRmYjYzMy00NzE4LTQzZjQtOGY0NC1jM2QyN2M5ZDBjNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARr7URrXcsZCIDz1kOmF2E5bkxyckMGQCd7gk5+jOVe5T6E\nSIK2FffW8a714mAm2iPxRyqbA6jPTfNRvV0DUWOEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtlBdijrpMLuFbTqbaICD7w02\niyQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRaWj35sHT9eVi1qT4aBe2Cd9KsxF5luZm9RYb9H+JEICIEvY7fAQloqk\nQMgpyt/uEWCZ0BpnSA9ivRztE28ytLve\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISARb42AfaQsDD7MrsAjW7g5CRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE4ZjdiZDYtMjk1YS00N2Y1LWJjOTktMTExYmMxZDUxMjYzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MDM5OWZk\nNS1hZTc0LTQ5MjctYjUzZS1hNDJiMmI2MjAyOGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT23Zfx6D9h7egP5LAuRuR3Jec0nwX7C9yOZjNItqnjeSWNhEjJAHJ4\nIY93CXdAMsDiLyUBotMElzYI5vqRvJkUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJOMgm\n6s5nVBCIgx7+v2fXBlDWxzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMe3s9xuN78l+kcz3A984bb9GX788EFxi12w\ndAs8b9a3AiEA0v6VTPCPTFb0k5oXgcq8ZntuWO5sjUGsJyoZtotFcHI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2184", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2184` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAayJWfsdZScG34KXqV/H89lAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2N2E4ZjUyLTU0NDAtNGVjNC05NWU1LTE0ODdjZmQ4OWJiZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWVmNDMzNGEtYjE3\nOS00Y2RhLThkZmEtN2IyMzFhYzY0NzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERtILh6kJRbbUkFZzEoS5P7gH0rUBM6NH6jqtaYZuxgXh3OzTdNYaxO1QP2rq\nC32dMrMZIP7YkvFiYnSf02ekz6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUldWM+SGx5C65kplpLNtB+pVGRikwHwYDVR0j\nBBgwFoAUP+pR9fPF2rbOB83TkW5WdoVhmT0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIBh10ptdECCRge9G3yIV7FTeDYaW/yoO\nq6iKMH93ilIMAiAEPtouiuA5ojeJrHj3yURFo8SwslNmC6RVTtx6J56euQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYAfUbmTna0LJYZSaJegKetbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjdhOGY1Mi01NDQwLTRlYzQtOTVlNS0xNDg3Y2ZkODliYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1BR0MWh45GACqdHvBLOUMy8DlQa1IUrxHISDRi4eLUTaF\nkytumNF+TCjsqbl6k/bFhqQsg0tTURaImQFMhKAfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP+pR9fPF2rbOB83TkW5WdoVh\nmT0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBy2zyQWUCA3VDvwsG8eoHfq2919FlF1Wlz9F5sIzXXwCIAJt3mqXdZAU\nNBKVqYugpAPu1jsWF6yjRGAX9J1Tv7tZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISASH5WV3AGCi1rJJf/seXkIW0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWVmNDMzNGEtYjE3OS00Y2RhLThkZmEtN2IyMzFhYzY0NzZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYzFlMmZi\nYS1kOTJhLTQ0ZTktYmExNy1kODFmODYxYTkzZDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQrLkae9wtqZwt9T+pIGA9NBaukOxdA7fJ78yYhf+GDriDeSzW0fubc\n69B8VcbK9wSQs1ti3pFfA9XlDntA0wT3o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSV1Yz5\nIbHkLrmSmWks20H6lUZGKTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgOMlG/6+4EtT5UZD4unP/kWmhGBmBdT05jAel\nSWhTSVwCIQDzNXduGebOsbNiQTXZL7dBVhGcZonq+Ov5Bfi576zbYQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2185", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2185` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWY1j9MZM8seQBnTimDDq8GqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4OTA3MDI5LWRmNWYtNDZkZS04MjY1LWMxZjEwNjhjZDU2MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IxNGM0NjAtOWM0\nZS00MTU5LThkNzYtMGEyOTJkNGRiNzYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe85p8ExpDQ6JluRVawSe3vXScMMV4Q6K5u/qapgBg4zwv06mvghTkWKpRuDF\nb8C6WbjrsG7Z7Dpw+BwLJP9kgKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEGPg+2fMf4CH/7IM8wupdrW42O4wHwYDVR0j\nBBgwFoAUhJfFpd46QtYuATPcsJLqb1+olxgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBUvepJl1pie\nIZ+10Ah+E02lQfUqAzB3BGE0M6eaa+uRAiEA/o9pE1LoRDoI5fEoUan0CEOnDlfO\nle4YGcH6mobKLfw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAShX/6cBkDmiJrG8IDFZ1IarMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODkwNzAyOS1kZjVmLTQ2ZGUtODI2NS1jMWYxMDY4Y2Q1NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9EltpMz6pYNZN3l1cE4u2M2QJvTGPrrsWKFtL8ze0+SCI\nVUJutz4SF7rWsOC5CEN9A2eySOlLF3A18WwXj+zuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhJfFpd46QtYuATPcsJLqb1+o\nlxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALmgKDKv4S+9Y9vMw7ZQy1SEFDXorHVWDPek90kH072LAiEAqX7H2MqD\nRo7aLNOC/ingJjXcmp+m/9MEOUAudXApuIk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAW1LDzXAVZExKexRT0UN2GH3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IxNGM0NjAtOWM0ZS00MTU5LThkNzYtMGEyOTJkNGRiNzYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZDI1ZmE5\nYi04OThmLTQ5Y2MtODFkZi03NGExNTQ3OWEyNTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQA6iIM8zAdz6AIZeGER8oj/jyAbDCP2/YWIUN4JlZrQO55v1Iza6IP\n4BBJINsBYBLTdrr4PM1Tjn4bnLZgTBuFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQQY+D7\nZ8x/gIf/sgzzC6l2tbjY7jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgBXf02Xr6NINoM/088e5jAQnelAzm4NrfJV/h\njy+wQO8CIHh31ji8uS57ff1AbWb+8KR+xnQFIGFurPB/F+0kuHQF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2186", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2186` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAdJF3MjkFvRUBYzIHisgYCl1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyZjdlMTBjLTUyNWMtNGUzNy05ODZlLTJhN2FmZDAzNjkwYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk2MzA4YzItM2Qz\nMS00NmEwLTlhNGUtNzQwY2U4NzY5MDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED9b3KGnLLYrVM8Fc8IPnZstbEtGlo6WNNKzYd0KQDf6VDDPXa21BiQxXU4GR\nFQQ8fIvu3oajedezq/aEvc0tIaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTVHYOGjdUX4AgdhvCg2i9WpnwpcwHwYDVR0j\nBBgwFoAUeIzAz2iIKSEsPKgta9iwdVSo1qowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPjhUE9KgnX8L15xwOij9MdKmPgAgN1MEx0GTU4Ktk99AiEA09DeqFOP\nChjkj0CGhUhRM1qJq20zkp5DUi6rlNBCJVE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeWq/lqE1EmaOISFQR3d1dtjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmY3ZTEwYy01MjVjLTRlMzctOTg2ZS0yYTdhZmQwMzY5MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6Kzo/cJ3Piiywqd1lXstzP29kP8tsgYD0QtQkBOZ18WY5\nbZ/5Gc+Yrn/tH9llZpLJmzgWwm5Je5It5y2WdYRNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeIzAz2iIKSEsPKgta9iwdVSo\n1qowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJr05Feab+6lb45CPySGOX/4B8rz/z1SUghgklh4zW/PAiEA27Pdh9Al\n3jsXqT6o6kiJYZLBGhhN70o1L/6cK8dDmGY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISARRh4fgJ62nK9S1TUoucP4G6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk2MzA4YzItM2QzMS00NmEwLTlhNGUtNzQwY2U4NzY5MDdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZTgwODdm\nMy02OTdlLTRiZDItOGNlNC1jN2U5MmY0OTE0MmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQix26T3IN/lnu5lj63TXlV15LaDUkejXC/TspLGvCrcazg4gNbPBor\nka7ALUTeLqZMSStiT8MCr4CKrobgV/jRo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNUdg4\naN1RfgCB2G8KDaL1amfClzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMD90FaBjc3sfveaUZKLYUC+gWyIMvpwNvzd\nZKeJGzUMAiEAuX5EA4m77C92k7UTWu55JpM3lIUTCab+vR/WB6MQqgE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2187", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2187` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZLhst4oZo1ZsWBpu1lbhtluMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4NDhjNmZmLTQyNWUtNDcwNS1hYTAxLWQ4NzVhMWY0MzUyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmMwNTQ0ZDAtNThi\nYi00NmJhLTkzOTktOGNiMTg1MGJmZTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk3OKYAUhADEYkckVdvE6nP3aTuTzpiyMGBKlDrwgH88m1uOU7itOYMNEelKs\njt5gOfblLf+5zqopkg1mibhCdKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxu6PiqLgOUCB0a3W+CU2mDLTgokwHwYDVR0j\nBBgwFoAU/RxKhSoYimv4PVbdoFQDlU81890wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgC0SW6wjESjsM0189b+sv/zzwnKdcQcS0Rf/3sPapsjECIQCI5pWU6biY\nj7PCpzoV3qI8F+CO+mqApqE4aAwa0NJBfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYbrddEztwqqhiTjx/X8jmPhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODQ4YzZmZi00MjVlLTQ3MDUtYWEwMS1kODc1YTFmNDM1MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtMBYuMkSCEJ7vNWP0SPRLw7dNbYSgFJJTR/i4uIw5LH6N\n22pmg5f4jcUgJZ2Y6rWXnLAJpKlm4eTBwgtlpo7Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/RxKhSoYimv4PVbdoFQDlU81\n890wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKcMgd1v5isXSMaosvtFQIyYmdausH5IAHraggV5OlsZAiEA04p2SvFI\n0/CUHHbEcyNzvg3jWdlMl3qRsqXQmtGqqnU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAbtxHHvjRbZRjoqNSnFvaClFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmMwNTQ0ZDAtNThiYi00NmJhLTkzOTktOGNiMTg1MGJmZTdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMzk5ZThm\nZS1mN2RkLTQ5NjAtYWRmNy1lNzc3NGU2ZGI1MWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQmNRSVBkbhMD7i6ucIpvU8F1qCHqcGH4H8Mx/X03FvAlkRsCF5Vzj5\npdGKhvFO1KsfY88Hom1ac9sf71rHxSdpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTG7o+K\nouA5QIHRrdb4JTaYMtOCiTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKCX/YxdMsQeEIqNGYO3Rifx3gBuPDKZNhr6\n5cfMJk5IAiB8GcDOQRThGPKbfba9TdSCw923kFFXWYT2I0iBHA6q+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2188", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2188` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAR8F0iXzN8Hk6NjhcBZk+ffqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiMmRjZGNhLWY0MDYtNDYzNi1hMThhLTVlNTAyNWMzNWY3NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZiYmE4MWUtOWVl\nYS00MDkyLWIzZjMtODgwZWUzNTRiYjY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkoC1X/tcmQvxP2+X/k69kBtmI4b/Iwpw1g6E9rFMImIafzV+smSo+N/+0q+k\nP3D4EiYjRNOvfBwZ2IAbsv7o46OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtBR3ZvCMG20lL0pcatv/dgwbfUwwHwYDVR0j\nBBgwFoAUjHGzx88mLoQFzOxL+gXv2izSIrkwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIGd3E2YE5Xt7fKABvZe6GW5GPjroSUaxPGRuBaFmqGGPAiEAqJZCRAJc\nZ96pAtRq+qXAyW+pCewkyyFXsndlCqfr8dU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV+KkoDnYUMhaeR9EloMmvHaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjJkY2RjYS1mNDA2LTQ2MzYtYTE4YS01ZTUwMjVjMzVmNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARufT58M1nRSDckj651UwV6SB/PMgBriXF+ky+l/Ik7CNn2\n2NQD2oy4PDg2F890EOqC5qvkV5u7DMc0YPK01EW0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjHGzx88mLoQFzOxL+gXv2izS\nIrkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUoZ5PHP3w/G7wVwzTRYABNPVn9yPIIfjBK//1KfknxcCIQCtXI5ugPut\nQUhcmxEsCkl+sCZez1m3wakn7tavZ2nqoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAaM5GDjMbSc74CdKa3uTG3UqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZiYmE4MWUtOWVlYS00MDkyLWIzZjMtODgwZWUzNTRiYjY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYTFjNzIw\nMC1jN2ZmLTRiZWEtOWQ2My1mNGJiNzgwNTU1ZTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARRQtwYN1z/eEw4xdBbCH8+n/n5ZxLzdvoulw/mg7jRK9/74ZiZC86Q\ne4uVk0H56bML9zP5vsvxjQSYvkCI1a4Vo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0FHdm\n8IwbbSUvSlxq2/92DBt9TDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhANUjtF9AjYxqafaYUwWF1ZLeJTjXafwLE7C4\nTeW6eGIWAiBoDcG+PTJ/lHjVlOvEvrRAB8CZBEpC6bR4a24SpRiFMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2189", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2189` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAaLNs8DgPB33l4R9JwtsBmXvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxYTAyMmUyLTQ5NDMtNDFlZC1hOTkzLTA3ZmE2ZWNhYzg3YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM3MDY5NmItYzQz\nNi00OGFlLWFhOTUtZjAxNWJhNmUwM2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYW+KghW6SeTMmgwXymJYL9LM+Nbwq1p6NcA8q048C/R2SHFnfC5D9AixlexU\nh6Oy9N8YIzimf0aqBMTYQV5tgqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2DkrtqisBj0t1YRvRLzgmen/V0IwHwYDVR0j\nBBgwFoAUYbhOtblLZHbMpY3m0op4dwCV4D4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCGikxgVRGlHGC+RFrHmIXVSWTkFGbKUjyqMP6F\nDiim2wIgLC/ed8ArlAS3KgvqW3crNkYJih+DUQLAAgD7tLXzaU8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfCPfluoQ1KeOf+LnVUP8/3tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWEwMjJlMi00OTQzLTQxZWQtYTk5My0wN2ZhNmVjYWM4N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQL20lv0qdZUrRaNB+4sY+mqx8FbKCcOSTKxsbO4UwX14G\nJ83ghy7Pg7FAIshJNHZ571dp4Cs6ZIYKoE4e8gJwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYbhOtblLZHbMpY3m0op4dwCV\n4D4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF7jLch+hHtSfQ5VXIY6y5BniwHRWUvc6bI5NOqQM99wCIFfgjZ64JsHG\nIcpMFjhJOdv53ktGKjnG14mUEy7vwiYZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAcrzvBtA7EGEySgetSzKHRFaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM3MDY5NmItYzQzNi00OGFlLWFhOTUtZjAxNWJhNmUwM2Y1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MGFiMmZl\nZC02MmQ0LTQ1YzQtYTk4Yy0xOTcxYzFhMGE1Y2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR7pZwMfMpcGSZCbprg8EAY+LZHvEORSF1TnEYxpXjp36e7rmQLVees\nNzhgt3TkJ/dAeJyfmw9v2lKP4iLeEpdyo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYOSu2\nqKwGPS3VhG9EvOCZ6f9XQjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgX9YFxbl97jQAkwwsVkiT1AZlDf/HjjWXAea1\n3wh2Q9oCIEtZN852S89IIUokV7wbs+nunFnWqmExykBRytQnzEA5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2190", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2190` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAUfmn2RrOlZKCCEFVXWxEgr5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmNTBkMTUwLWQ2NDgtNDgyNy1iNDkxLWFiNzFiNjYwZTI0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIwZTIwYjAtNGM4\nMi00MGE4LThlMmQtN2NjOGYwNWRkMWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGs2mqR+F1d8N71MK/CszzJ59e+TXVeQbqEAHcLzF3Ko21OmANsxfHIOe+mvt\nPEXAauzYSsxKW2+6vntIn5mZnqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwFON8Yy9CrmYaaxyZgFNO/F2JWswHwYDVR0j\nBBgwFoAUG+eI8tkPeyF5zr1lbWS4cN4UWxkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFq1Lbxj9TKro5qXSyFnSUomP7TqO3R2vxoKRa+Z\nKNLdAiAS2cLaMknLdchE86oercCzkvxGMT0GqZis4zvkJdNJ5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaUOFHO5m+iqeVzQbdOtmjMsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjUwZDE1MC1kNjQ4LTQ4MjctYjQ5MS1hYjcxYjY2MGUyNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjcaanQ2IvVQVU8hnhFGRFTJmrGMoh5kQDoeDuf5R0X2bQ\nNve+rn6JGqQRBVMDl/iGi/6gh2O/Q0cq2dARaifEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG+eI8tkPeyF5zr1lbWS4cN4U\nWxkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMMMFuD4uc/HV9odD1aJqmMFia0Nk7gAbzWlQ871CycAAiBV6FlryzgE\nzvmWQcpldaevNxin1TTapJcX2qPNESmR/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAfCc+u4ukvXcgLmylHZcQs46MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIwZTIwYjAtNGM4Mi00MGE4LThlMmQtN2NjOGYwNWRkMWMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YjFhMTNh\nZC1mZTNmLTRjZmItOTE5MS1iYzVhNTRlMDAxMzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAREmM09on09hji1WIsqrK0NLKP5QmO6/+1dzmuD/Cgk64A1sKWvQ3cr\nFAgxgJuG9xHrrfe0tx9dWon6dkO5Nvd6o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAU43x\njL0KuZhprHJmAU078XYlazAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgVSP145YZManKJL+xqB1j2D9CuOwQDfn6XNZO\nyqwb4lICIEaUEljH2V8G0JmqGBG/suI0Q+zmKmijgMaW4coz05ps\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2191", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2191` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYV8nV2OePcil7LJcno8yjm5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3MjQxYTNiLTY0MDYtNDI1Ny05ODg1LTFhMzNlMjBlM2NiNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNlYzM5MjctZDM5\nMi00ZGU0LWJjZGUtZGY0YjNkOTJmOTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVVdpRRzI5INu/fIp2+v3kHRUdnpe/px3KeyI3au/yp4C2Ls7P/qfK8emR1fh\nVA7iFCquwkFvo2U1mHSqfsMZj6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdPb3MMCuuK/a3NcJ+fgkD2Z7+y8wHwYDVR0j\nBBgwFoAUdReMbw6cqp0OeG8ETZH2LUH9lLQwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQD2wAKaZFDvF3kD79wLQA+X8yFoVjoxDnvPEm4K349wWQIg\nG6YY1g6zx24X+yGrP6qlPR6xwSQLzDCltZ6YjKfDroo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXpQTvqkGkXvcgwHN2qbNVYrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzI0MWEzYi02NDA2LTQyNTctOTg4NS0xYTMzZTIwZTNjYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSHpFn0/oMXZpAKsFTDQtotF/13KRuYR0FbZzhSPGYU9wi\nVVT69gZzufpOZNEe55OVpZZmgFvVW/WQ+D14jROoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdReMbw6cqp0OeG8ETZH2LUH9\nlLQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKHIjNRjY+BbTHldvSLWMoKrG9+sXT+yz1tZIlHSHL0mAiEA1ebHGd73\nYvZPCAfa0IkbkEhXBPRoHUGraswIw1YXkVA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAVA99eOQNTmE4dKfElJUHtB/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNlYzM5MjctZDM5Mi00ZGU0LWJjZGUtZGY0YjNkOTJmOTE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMjIyMWEz\nOS02ZTBkLTQwN2EtODFkNC00NDNiNTgxM2E4NDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASVOlnWzzSxope4ktRhAqen8tWhA+7aaw4qj5iY2t7mN0bPPF6buJpc\nib7JRqynQayW/y0d4G/rXwPMjWF7ArEOo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR09vcw\nwK64r9rc1wn5+CQPZnv7LzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOIpsUcehCH/icCUlGrgdqrogs1/BoqwXS0w\nVU4cyPwXAiEAsqs2bvmVK9x3GLUw8BqvHgBrMfTfnIuwL4z1bxGmNdU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2192", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2192` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAaQ+WceVOP1Y7+2/3xB5Yy0vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkNzRkODJiLTAwMzEtNGMyMi1iNmEzLWY4ODhkMWFlMzZiOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q5YzM1ZjItNzg2\nZC00MmQ5LTllM2QtNTlmOGZkYmFjNGE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+HJobf8Y5E5pK0/Kxwj+HpXUuwBzBtOUUqGh+cwFYYINziNZWRv8vn5UVbY4\ntgoFFjtCXsNT6l/31OzqMYOpwKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnRwI78bsb7w3HpKlat5twXgRyxUwHwYDVR0j\nBBgwFoAUkJ2hWbESZzrm7RGWl/Ocax6QcgkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAs5oLY1oeH8jQYV6IZeFdYX6dmFH0+Q\nIDUcZKKcJyuMAiEA2gbXQwHs8KcCg5E7V/H9WCMg7GXzEQCYwf2MpCBaZDQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARQMTbbGCYqvdYamsCiFisQjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDc0ZDgyYi0wMDMxLTRjMjItYjZhMy1mODg4ZDFhZTM2YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeIAL/GhnFMi//fjGIiRwjodAbU2mPH416c1w7/CPBZ9Tv\n3dMzoYVkNZeoqUMvv5z03PQHuRbloXmWyLcRKQXto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkJ2hWbESZzrm7RGWl/Ocax6Q\ncgkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgelkV1slJ+3/6tNcgYv1oSRcbzsrv88YFtG2o1m0ILHQCIFspRpaPqqlm\n10v/67ElIPd6O378QyyJNUudqOf2HALV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAVOyQh3okcnFZ2F7TMyA7yGnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q5YzM1ZjItNzg2ZC00MmQ5LTllM2QtNTlmOGZkYmFjNGE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NjgxM2Q2\nNi0yNTkzLTQ3OTEtYWZlMC1jMTJmNzMxYzRjOTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT9DwR/kRmIzYJ76oZSZWkyM8DW3ZixoTCoV47opQR7c1sC97sIK+Zy\nS7h+fWboCThjq3N0YHeSsD8/xs+l+vRgo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSdHAjv\nxuxvvDcekqVq3m3BeBHLFTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAICSQXK/T4oVWRU8v8VsM/hIfa/vPS3CXq8/\nErUnAopnAiEAqk2XXK9zzPf/0z3caOzOqOnm/zRuvrNUE5S4NjVwUiY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2193", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2193` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfu1RKHZmDx8pghXolmTh5gpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NzA4ZDk4LThiZDYtNDljZi1iMTc2LWI5MmMwYTVmZjg3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRmNzJlNTYtNjU1\nMC00MzJjLTkyZjctZGVlYjkxNzhiZGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAgY/patSH8/WQo1OHDmnG0Twe/vVdFTgayjJK8U6288mXjoYTxm8lbFA7EMt\nhq6ijB/YUZ9PFT4e2jV+JbM42aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULEud+wAAF4N/9NdiDaSD38Qs56EwHwYDVR0j\nBBgwFoAU67gsv+CcCcQ73+bDlspP/53Gr9YwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEFR6SLdrOTyLNIEEdCUv9NotDeH5kRi\nBe3Ub2m9UEsmAiEA+Sos1SK22YueLaXlagx/MI9bJKS69H/5/3LhYpj499Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb7HfPF8EfSPvyhfoP6KiIeHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTcwOGQ5OC04YmQ2LTQ5Y2YtYjE3Ni1iOTJjMGE1ZmY4NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm291FmgdcSb5Ekfir+EgJyJ1vrl4LhWN2VlMCezAOJbe/\nWIVx3QgONMflKRhfAcdd5Hq01iNTL1P+kchuo4Bfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU67gsv+CcCcQ73+bDlspP/53G\nr9YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN1Xg33jsd2XhtA/tSOAinMv5yy/taWkQddREZDarHpTAiEAl8whOGHp\nVCHLoJb9BkPb5N1foxn8DDSlegSCfCne/ug=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQHM76vfyetCFPURlBaYjTCjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRmNzJlNTYtNjU1MC00MzJjLTkyZjctZGVlYjkxNzhiZGFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYWVmZWVj\nNS05OWFlLTRkODktOGM5Zi05YzVkNzg2OTQwNjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS9W4iNV5T57Hjl5h9VQh2tUFv85tbE9u0Nba73MPg7tP1rVLNSVXBV\n5s4ZQUD/tcixxUqJJySWPHtx7mWufqyUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQsS537\nAAAXg3/012INpIPfxCznoTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMS5ncxKvR48J21AXEC8OnHotaoTXLP3kTXY\noFpIfl2yAiBK0ICXGjjImA7lIj5ly5TNfys85nbenacVzekRl4cwmQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2194", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2194` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUndgliZOMBWOtpMLX38sfDcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkOWMxOWNkLWY2ZjctNDM3OS1iZmE0LTcwODkzNGExNTYxNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2EyMzNhNjUtMTAw\nZC00ZTI1LWFkYjgtODhhYzgyODQxZTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX7EbDRPHN3c59pWkBe3ONvAXpcfSrpwROecLX+d0+zfuVWKlfdFjt13gB2IX\nwYxZ8yZH3EZRtnJwir2BHtNfRaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMTkYH3BNj9q2l/Iyw6p2FEHEOHvMB8GA1UdIwQY\nMBaAFMSiV68nqkd05uCpIz03ImXRT563MAoGCCqGSM49BAMCA0gAMEUCIQCKCEiF\naMA5mU3GFDmg1R8IhXPK9OnOo+APjHhLgGnOAwIgbQwNBh+e/W/+A1iVqyBtoxPz\nv1ElX290oLW2TnvaBfs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeOHn6vRmdMcty2+eliauLWIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDljMTljZC1mNmY3LTQzNzktYmZhNC03MDg5MzRhMTU2MTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYX7Ft+JdDjWCBSo1Tz0Iro1bRLlvj/uP5DqKw4410qRWS\nkmGz1Cubm9llGKSBdPYyK2rZhhZAKqK22DaTaut4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxKJXryeqR3Tm4KkjPTciZdFP\nnrcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL4cJ90mRNad1EjklPjOtYaVO3anad+ASt+pgfgOiHPeAiEA97xgtljT\nYC4olpFkDA87lFnWEgr3ndjXpqJ4caQTwfE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAbzqEwis7POuKdpqcZV8vPZoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2EyMzNhNjUtMTAwZC00ZTI1LWFkYjgtODhhYzgyODQxZTY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGIzMmE0YzMtNjgyYS00NTZmLTgxZTMtN2M3ZTExZDVh\nM2NjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzILR7IToWgyb2yu6FlR6Xa8G\nB/t1BDwfcL/Jw7EpRuP6SulU6iI6WfB3tVWAaF4jI0BHnNaiexB4t5iWBg19gqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxORgfcE2P2raX8jLDqnYUQcQ4e8wCgYIKoZIzj0E\nAwIDRwAwRAIgWFyUVBGlPFuFaVXG9Nyicj07RUDtL96CkUq/MPGRIkgCIClW4+wu\nQb6k9hjSA7+6yCX0msYN59an/3zgwNQA5oTu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2195", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2195` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATcyyYKgc/en4IlUyyJNbxeAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMmU2ZTk5LWE3MzMtNDZkZi1iY2RlLTkxNTBiOTFkNjhiZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGIwMDhiZTAtZWEx\nNi00YWE3LTllNDctMWYyNjdjZTA5MTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETxFl2YhjewD6ZK1AjXUKA7MG018Tp7myHvNJce63ByEKjWCuA1pvOnjexmso\n1Qfo4nEtVazzCuoQ6PgAjcilrqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNcxJUsdzyd9nflspOUErCSmEDRkMB8GA1UdIwQY\nMBaAFJa5giqhBHpOpgVUbfEXrOhCazXyMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAYHzPJl3/3NbZgostbM8gUUNdcpwcn13WM\nT8JBMBGAtAIhAK2J5gt2QumIluUrr1TQcbaEHfm91qYPBOrs7hfAcBmc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc4THyiJ+e8rjGZSzaTQAFdmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzJlNmU5OS1hNzMzLTQ2ZGYtYmNkZS05MTUwYjkxZDY4YmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvKLOqYEmvLn6fuj4+NcrYILJu/fjPduN0p4WTRsDMeNL7\nYXVY6t6DkfUOxr1k8l/zoBFQzqfgn44eOY/0GPYjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlrmCKqEEek6mBVRt8Res6EJr\nNfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaBm3e7Sa+4LK120Qy8zukvejgMamSo+fouwPJ6f4+j8CIQDUnbyZ82Ib\n5NtFO3DkqwBAPyZNC8N7CixQaXQOwAVQ+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISARdExVpZKlgy9aU1HM4GDNKRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGIwMDhiZTAtZWExNi00YWE3LTllNDctMWYyNjdjZTA5MTc3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2Q1YzUyMDYtMTNjNi00ODRiLWEwODItZGZiZTJjNThm\nMWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYhiQQKwCUrh4cmdkwIu+JYf+\nB6FgvJTgKv7Ioa/su9Q7+9AYEtdbIv2WNffy+c2ik/qcKNM0E8SEAhjAvN+GdaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1zElSx3PJ32d+Wyk5QSsJKYQNGQwCgYIKoZIzj0E\nAwIDSQAwRgIhALba3glCwlNCbVMqD82GWd5b8mbQQI+FuhUs1ZKNnj8GAiEAtb8G\n4Yr2nSPRNRCZwyHcrpXGk+VV+cJ29Ei1b1/ZTtM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2196", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2196` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaEvN6KxEms1+Lwy9YUUH+HZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyMjhhYjJmLTMwMjEtNDg4ZC04Mzg2LTI4ZDI4NGM3MjRiZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkxYjEwNWItYzMx\nNS00OTdhLWI3NGItZjliNzRlOTVlY2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp9I21XzUUyiOynUvf+gkPHud899TxlTRMXh0QzIurkgHFNTplijVQuJx7WZp\n6kJVC0+w+osPQp8+d0731Mw/PKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIHOnAOdkN9NUBQNL9EZxajvsYL1MB8GA1UdIwQY\nMBaAFKl8ANHSzHjwm65UXhuOnHAEPKFFMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiATBOeX9K/fn6+AeJtRJvfzTE1qZ4prkcL4\nJ0NFCkpAmwIhAKuvInXMDLUNvALTGV+z91B2DbV9LQ5JFX9GX3/lPRQ9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe/VdEcBzvZZea40MFTC9KVPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjI4YWIyZi0zMDIxLTQ4OGQtODM4Ni0yOGQyODRjNzI0YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARE9sbiXmCkFySX/KQiLa47BOU04H7NikQvL97QxZ100HlC\nzF3j+lpcgP+5xUOcuChGwrcHg3mxHSvI1Vm8fEajo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqXwA0dLMePCbrlReG46ccAQ8\noUUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXARb+1wowOtCB4IY3vcEeGb8Y4dBhU0r60gOrFMwJVwCIQD6J44U2Dm4\nB81pJGZyj/1d3qbjt4I+Gn+AvMMbDtP3YA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISASis/CUro5sQj9GdQmuG8PKwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkxYjEwNWItYzMxNS00OTdhLWI3NGItZjliNzRlOTVlY2EyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjg3OTNhYWMtNzUxMy00MTdmLWFmZTUtNzdkNzliMmE3\nN2MwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8QB5LYkShlCKAv786nr8jyHq\nWiB56s6s6xTl9JdSVylQHsEhUxtvKfWcTHxO7ZeN7hiWgGqBMteP0hYLwu4lx6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgc6cA52Q301QFA0v0RnFqO+xgvUwCgYIKoZIzj0E\nAwIDSQAwRgIhAKn+puHkWzv7MQQGbK3yLMb8zGdkQfzxC2r+htMIsUJkAiEA4U20\ncZH2u4KoCBglZ+LPr78V3aLmH4Zb03NHHG5dL9w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2197", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2197` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWC69LLo7ASx6vxlPpr8b/lIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjMWI2MDZiLTg1ZDAtNDJmMS04ZjQyLTJmY2U3NGM4MzIwYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE2ZTkzODItODQx\nZS00MGE1LWFjYWEtMGRiYTkwN2Y3ZmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+fmUkNWVkfoX2H7V/610HY3CkCSUhWfdsaf8lYFa1wTsqx3QKEsXGYTPcpIs\n8EqHlzFdqqiNhv9yOtNJmCOcq6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRZzMA7fdosznt2Bu01SpFgP0yCAzAfBgNVHSME\nGDAWgBTqte5EVde11Hegk/eM1SwrmOXbRzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCkEZHLC17mVooMjlIsz7de+/Uu6B5T\n4LyX3W+H035gfAIgd7sp2yfMUtewY1cM+PtZFjTwLy7/BnHjRRz6u3OCq3Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbTm1/bMHxnX0fhji4Q4M3ANMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzFiNjA2Yi04NWQwLTQyZjEtOGY0Mi0yZmNlNzRjODMyMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToWkuK1ch8UY0NZPz+waa26P7VCgcPv7froeE025liK72Z\nVXCmMVca2LWVhodnRST21LyxRxNDRISCdVug2b2bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6rXuRFXXtdR3oJP3jNUsK5jl\n20cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgL5yQvnGtWHPGosFaGX7psd9QleKnrRSf6v14TvXJF0QCIQCppV09UDa+\n00wlqSWYCwy8BeW6eNh85v37utNvtWz+mA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9jCCAZ6gAwIBAgISAV3PZ95Hw70hye30mrRkawsjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE2ZTkzODItODQxZS00MGE1LWFjYWEtMGRiYTkwN2Y3ZmU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDkxZDhiMzMtMGZhZS00ZjYyLThiNWMtZGIxMGVhYmMx\nZjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdShHpF9YJAzXWJMFAMLPitBW\nd3KO0UTMEKkAvwtsYMfbiQFF8dvwpxpHSmDWedUXFXZWc8NXzVaJQZ60yklObqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWczAO33aLM57dgbtNUqRYD9MggMwCgYIKoZIzj0E\nAwIDRgAwQwIgHrh0wejvwvY1zlRs7ULd7HkFl9d34DQCmSe/tDItXMcCHyDhQ4FD\n95edqhzVUHQYwWqsMmMI9c+59ji7kdUn4+Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2198", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2198` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASIsKYJjF+DRIiAE0ZAUVn5kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1MTM3MmVjLWE0MmEtNDcwNS1iYmI2LTg2ZDA2NTkwMDVlMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUzMjhlNDItYjRm\nMi00OTY3LThiNzUtOWExMzI1NGViOGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ok8TbZn0OkCBPrjerCRk3Og3dogTU68Bjt6/GQWZrNOT5NHN80w2bBq21E1\n3qtLwwXORoJkTz6jxiYw4qhjFKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUINvUQwnNos2g1pSdmJG+AngKfqAwHwYDVR0j\nBBgwFoAUrPJIbQQ/PG8syxJflzbzs63U3ZswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA+7/K/mmAayY1\nDKQkuV3TjAi68Q4Rj8yzcaDkbklwv7wCIBp6w37CtWJITIlRimy/z9UJF9j5h08m\nAJ2kug0sGySO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVWLVSxdPtFY/CUXkWyuA4PJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTEzNzJlYy1hNDJhLTQ3MDUtYmJiNi04NmQwNjU5MDA1ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpycN86pkx1APc5gxJ9JJ+uwqKEU0qMrue9afMq7VIF9Tm\nMBbtTG0WcLnLcYQGFMhDYr+ZqG4hFxhH/9aiAHiUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrPJIbQQ/PG8syxJflzbzs63U\n3ZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO1NefYR/ieb1XgYEjZ/AzzHPC8Wvb2JPWXfS9uud+g3AiEA3gu77bGL\ntnLUrSn/NVB+hZIGx70qllnNN/YhAOLS7N0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAeL22rl62NkZk6llPPaI6hxsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUzMjhlNDItYjRmMi00OTY3LThiNzUtOWExMzI1NGViOGFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTE2ZGIwNmItYTQwYi00MTQ4LWIxZmItYmFjNzEyNGUx\nYTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjKkcR2sJE/NB1kphbfrXSZdj\n/36XNEkLdE56mak30TKhkh447KxmDlixcrXJpVOumZ+HJzyEYTVE0WNBQg0JNaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUINvUQwnNos2g1pSdmJG+AngKfqAwCgYIKoZIzj0E\nAwIDSAAwRQIgaUhCfc2gjZu7/PCwdKiLA5vE20ahJ7scNffxfYODuukCIQCxJ2Te\nZXi/+jt/UOxUG26zMMFhL4Com6v9pH/ggsYBRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2199", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2199` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAd8SQZDGAPYvd3N/S6BMnS/oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5NjBhOWU4LWM4OGUtNDY3OC1hOWI2LWM1N2ExNGYyMmU0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhhZGE1ZDUtZGYw\nYy00YWQ0LTgyNTktYTEwMzY3ZjhiNGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQUB33ZpcvjYKz9TJfYiWxQLqLeWf2AVJDozKSLQi1yGdSTOXcDdHIX4GUa9A\nKtHpOiThTzeXqyu8YA9zo5GFs6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFZGVbAw1qi5GHS9ZBJ+yNXJB72EwHwYDVR0j\nBBgwFoAUoGk5EVCwkdLWZQGGbJdePr5PUucwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAluhbRajkWbt4\nlxqv5PUMQyZoQ5LStPghDqWlUvqg88kCIC7AOY8VcEF9OX7vjSVQgt+UwziHOF/w\nni+T5/Y1MIjs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ2kju0xkPWLJa+e+KAXBw2vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTYwYTllOC1jODhlLTQ2NzgtYTliNi1jNTdhMTRmMjJlNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLpztnQAxcnOAMqk2i2O5aeYxYD5J/YfQcNnrl7ETxGYXP\n4wnyawFNjjhbMj43Vv2mvicUI3oiIIMNOYOhCDpto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoGk5EVCwkdLWZQGGbJdePr5P\nUucwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANCMA/7Hj9p/tL1xLiKPWmxom8NJdYilpmCRMUyWo7tHAiAEdS3zypCS\nutw7poc4YJsEeuR9gLGDSdzNsNiAI5mCvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAVIDvZgP7v4+Hl+GCxvD4ug6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhhZGE1ZDUtZGYwYy00YWQ0LTgyNTktYTEwMzY3ZjhiNGE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQxNTYxYjktOWNmOS00YTE2LTgwYzctZjFmYmY4ZjQ5\nYzk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECisMQJiIowh2rzvL8QSxe585\nJtkIw/ZM1gYf5/WhuflK8sA9qRft8elCkYlPxT//oZMgyvZER2oi8sjIjiS9eaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFZGVbAw1qi5GHS9ZBJ+yNXJB72EwCgYIKoZIzj0E\nAwIDSAAwRQIgJfbhC8YjFAfAt8rIRBRlHIIoZKTsmBfmS3xq4HWCizkCIQC4zCXn\nnw8gtUw2uaQ2HL6TZb+qxcFW7LnS52760xVS4Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2200", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2200` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAekwRDb8XyfNLjtboPsh0sQoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3NDQ2NjViLWI4NzUtNGFkZS04YWVkLTJmNWUyZGY3Y2FlNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdlYmJlNTAtNzdl\nMS00YTAwLWFkNjAtODIxZWUwYzU3MTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKOH2bgrgvVnb7nf2/gbKQOP/UW7mOj9hRjjD2i6S3//ZMWv2eBeQAZO1KHf7\nkgR1XJYnEijOIn974Ptq8HcnTqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWPsin/QxNPBz0gKiA0mqjpXRP98wHwYDVR0j\nBBgwFoAUc6rvfV5HKV9dy514BJ3Xhp5WIKYwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiA++srupL09aQFjbHhGG7rt\n7uF9xbuGXc/94BOwHdsj9QIgBYBwR0Sv2HhjlS8d+xQmK2tCA8L/kSIEJpxX5a2R\n0NI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYqu0Ym/5ynmTsGbJeTRqfFrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzQ0NjY1Yi1iODc1LTRhZGUtOGFlZC0yZjVlMmRmN2NhZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0cL54IG25eCvqyZ3ws73DckQOZ1J4gcN1QmiiR5dl+qtE\n3qhoqFuGHdPFOWtUKMfIJwn2ELMWrgKb4HuC0GEJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc6rvfV5HKV9dy514BJ3Xhp5W\nIKYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLcn0BoukeOzWgDNoIhhMFkXlePYepsj9BMCMUcWTEOoCIQCQ2MZbWi7C\nLsyh7m42RahVr4rJgFOcGP7qVi04ErDrKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAV4wKnwfLXDZz94SHbnBNSHPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdlYmJlNTAtNzdlMS00YTAwLWFkNjAtODIxZWUwYzU3MTc2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzc1NWJmMjItZDRlMS00YmY4LWIzYzItNmI0ZjI4ZjUy\nMzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERuaYDC1GguG8RSBo5ZtV7Jum\n1FjzmwJQsSfcc6cmWdyYjJx2T245TRkNV3XUwGvzZktn+sOtRvyTYKpu4lcYL6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWPsin/QxNPBz0gKiA0mqjpXRP98wCgYIKoZIzj0E\nAwIDSAAwRQIgTizGM6/lHfV/K7dA6aDpiWQRlpYQo+rYEY/Spoybl5ECIQDC9uGz\nOb4StCXnYjtAHZ5IOAmxqiyuHQ0CMP78NHLV5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2201", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2201` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAeq32zf1GmjxKm5PKYHoE1AEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyNmNmNGZiLTZjOTktNGFlNS1hNjk5LTlkNDRiMmNlMjM5MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJhODI2MTAtNmFj\nOS00MjE3LTgwMzktNzE2NjU1OWM5NzUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWepwugtZPWFAXyEgo3SrPtulz29CdzJ69NrtUMA+fFJT40eyEOk3TLwqJn/S\nGR/9nPENfaF1rPcGkNpPmNtXS6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0u6Dm2Pkoo590RNic/MTieA8PCgwHwYDVR0j\nBBgwFoAU0Z/IDgsIHBXnFg5pADt/9jcR3M8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA90ID\nXYKzkUnjkTCFHCv0HUO84zlYg7Va0dVJZStDHnACIQCcQ8G4ovaBCvAMnc/hXr2X\nmAZ42JM26Y3ghUoZQuPE/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVXEueCL7toNd6eWsB/tFfv0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjZjZjRmYi02Yzk5LTRhZTUtYTY5OS05ZDQ0YjJjZTIzOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ42YJwlO12VM89M5mwAC3jrL1g0DA0QO3grFJxDpvHfw2V\nQ4Yj7O+vv80twCJx0TE/J9lI+ZYwbAxShcxvMUhNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Z/IDgsIHBXnFg5pADt/9jcR\n3M8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL3JQavzg/h+qGXarBXP5xlXJAi3Qk/FVb7GaWTiDDf+AiEAk0iFXmo1\nyrCYqOuKUvbNIeqx+RxXfopOjuG9EL+EEAk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAV0KYhU7tm7Z1mVOtD9qh9HZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJhODI2MTAtNmFjOS00MjE3LTgwMzktNzE2NjU1OWM5NzUwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWVmY2VhZjktYTkzNi00ODQ0LWEyYWMtMGYyNTdiNjYx\nMDMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQKTHGUBcUk5YIBUclWCyE0HY\nATkkcwN4XE92C3YUJ8r5z+vuxAtmMVbHH3EAF4mWUcWSnZpXcThzsEsSrCyi0qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0u6Dm2Pkoo590RNic/MTieA8PCgwCgYIKoZIzj0E\nAwIDRwAwRAIgf/g83Se+ZS60AvY8nNqe8ewfTb6TpOD+ukXruBcKZ4wCIFF+AAIF\ngNXAPns7pwU1ysnyTyKtf2OIzC+uhzwRXdrv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2202", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2202` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISARczBBjSTe5xARst6cEathtWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlNDA1ODM0LWEyMmItNDVmMy1iODg0LTE3NDM2Mjk0YWVhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQwMzYyZmEtNmQw\nMS00MGMwLWJiYWQtYWU3ZGY5NmRjY2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoQ5FULvPQFGBVEsSt0uIYMTqOoaGv0eiWHa7H3Zd0bgEwDP7ycLGUK28YPWD\n3UXFly18ojSqp2Egm+ffk+TRpaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa8L3zxlO2dOmqYEoTvyFgqBrdaEwHwYDVR0j\nBBgwFoAUfxpX5o4YpEr8HZQhlud7AL3DoB0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA+VLq\nzjRF0HjBIsLOJGrSvqDI6SE4skQJLmqdweWaBv0CIDtRf7JlX+M3c+EI8u+bnvJ0\nOFy/I0D449YsJDN7S5L2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUyDp1KPgTtlErZhbOxvFbUVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTQwNTgzNC1hMjJiLTQ1ZjMtYjg4NC0xNzQzNjI5NGFlYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZHz6RPvhbUV9QvJ4cMtCy0gydx6gERfZo5nuC24tRgDTi\niMTbsjWtFBdZ1EhrARTI+LiJgo20AdshSH8RitGNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfxpX5o4YpEr8HZQhlud7AL3D\noB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS/+D0lZc/yleAoVieWMYzaeojsYl2jmcyoorOrun4KYCIQCUl5uwavan\nfyHFt5AL6fwqfwmwzLqVHw0pws/dT+bbPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAdaHL1hodyMtt87MrhMqNZqqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQwMzYyZmEtNmQwMS00MGMwLWJiYWQtYWU3ZGY5NmRjY2EyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjdlZmQ0NjctMTRiZS00OTZmLWE3YmUtYTI1OWFiOGQ1\nZTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIq/iaZDSB+JDU9mE0lOlos0i\ny2uubV42zS32jGbeiEVBO/j9ZlXZnZuRYA/j2yUq4o+DQAe7ZbYMrnrAGObtyqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUa8L3zxlO2dOmqYEoTvyFgqBrdaEwCgYIKoZIzj0E\nAwIDSQAwRgIhAPHljqQqHR24kW6xjALbbkpYISehpOgasZe/uM6kNhZxAiEAsZ0F\nDNMBQMiYiOVFMgZYUfw9FsthWeNXGNfq3RLyQLw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2203", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2203` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISARrv569PxaKUsVTt1FXX0LzXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0YjE5Njc2LTEwY2QtNDE0Yi1hNDY1LWFhMThkYmZlZDkxYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU4OGM0YmQtMjI4\nYi00MWRjLTg2NTQtYTMzOTNiOTkwN2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6i0oC1Z/CLbGrj5Hjinqzm+PAgVdRoQdDZq9UOJ/KucEMjDNl9cbao66ScRG\na01wBaGWukeVd79zpN0RnQTA16N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMSan7ORm2E/9yw+tT4cZaSx1LNnMB8GA1UdIwQY\nMBaAFOC+TfR/QKjFXVWl+E0fk1m6lFR2MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEArbtD6jY3Sszk+1UGFDfUCqm55zjzmwwk\nU7I5+dz3q8UCIDBPKvCO6kvdiBiqEiX50o1IuuQIXqoAsDOwbcqBYuoG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdCoiJTlWXd0SUiWjf+fRT9QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGIxOTY3Ni0xMGNkLTQxNGItYTQ2NS1hYTE4ZGJmZWQ5MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCueDXLoVBXaSGyAazEPyjyw24K4OzfzRxP6Wb5TcIJ+vq\noxuQFgIGRx4urbHR6zhQ79dCIZzRj8nY60fbDpmZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4L5N9H9AqMVdVaX4TR+TWbqU\nVHYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK34L1b5T4/DoFA1vi9Fy40Oq/3P32Zp6gnOs5xjUNf/AiEA4xZ/N1Qi\nwkbJi3j2HSi//zdAbHbCIIaBvOqRjlfw/lc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAcnFpARYZviI0vMR149XlFZjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU4OGM0YmQtMjI4Yi00MWRjLTg2NTQtYTMzOTNiOTkwN2UxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzVmOWEzOTMtYmM0ZS00ZDgzLTliMjctNzlhNjRhNzU4\nNTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEMeiovZXdZ2ePQyVQRGP8KiC\nOtltZaQe3v3BwYKS5wgqwkbE5yT9dEXj33bZSJQtOrI/xunjY4AfCzNSPEkG86NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxJqfs5GbYT/3LD61PhxlpLHUs2cwCgYIKoZIzj0E\nAwIDRwAwRAIgDmldaLFb/LW7DEjDeDmFptbHLQHT8lN4MSzIoSrDAwUCIAoVCGlK\nAvKGwHDkcQqdxyldrM0IKt2LDQFfmz7x2F5B\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2204", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2204` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISATXNsaNcPXng6Aaz9lqXtNeWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwMjJhNDA3LTM4MmMtNDIwMy05MmJjLTE0ZTlkMWRlMTY4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjIxZDdiNDctMTQ0\nMi00OTdhLWJhMDItMjMwNzkwOTUzZDBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErFcgF9kdNTzjkbdA3cTDG5sZQsbILc5IN7f0FYWyHTZhJvyDU5gw+Zc9poeR\nyZ67RR7XMu5Uj9Q0iH5FRSbOHaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/e7y/GEfsPMJIO8Hx5IFiczK3fUwHwYDVR0j\nBBgwFoAU26iSfxV/shdYvd841fL0FTYJ35swKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgaFvWOycnK24i\n/s6zraUrs/Cj4GOme/nxR37fB64ZJ2ACIChnnod9IFDZH+64oiea7is+9Uyi+JK8\nFjV2n+LK/lNV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa+PYxwEX8CS2ilLdaoSkoB8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDIyYTQwNy0zODJjLTQyMDMtOTJiYy0xNGU5ZDFkZTE2ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfJ4gBI1gWntIkS90bhgUbizrMFx4J2+koE2ti97UwaeDT\nfhRctb0FowpHaOATvvqGlEbFdtcnxh1uCoI+N0bzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU26iSfxV/shdYvd841fL0FTYJ\n35swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALWQ8ppA6iLegVZh6vr0lPKtszdApK7fHh4SelmrRnN9AiEAlwERbeQt\nt8dcZaSqCMFT32jHKpW/AmepWfhQlkak8I4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAbw4LXb5f4/daGNz98w5I37QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjIxZDdiNDctMTQ0Mi00OTdhLWJhMDItMjMwNzkwOTUzZDBlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDg1NzYxN2MtOTZlOS00YTNmLWI2ZjAtZDlmZjFlZmEx\nZGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkkktSWJR1rdWI0I6Lcrq565t\nBnOp5MbBrHItpLJPetsmqGCXIbgnMuWLwMPhNJ1yvfK4SykHOO7scirrzNp+3qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/e7y/GEfsPMJIO8Hx5IFiczK3fUwCgYIKoZIzj0E\nAwIDRwAwRAIgWkUD+Cj29/RT8Nd0y8W1eIa+XgkLOXCmgW9WynL9kAMCIDlkPIpc\nac/AxQej2e9XON/WAI7OunPBojPN7ZGPh7EQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2205", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2205` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARZFojDNrnw079CwhxYhFrLBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZGJkZjZkLTU3NzMtNDIxYy04NTAyLWM0YWZjZGZjZjNhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDNjZDI4YmItYmQ4\nOC00N2QwLWI1ZWItYTdkZmQ4MjI0ZTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkQB8v1TXQCm9YQOftgARge7t9XEa16pPT1kPSCCn5iCmvkUvPM3GuiLWPpfR\nFiY4AjhUTlJDKitULWm7pdiFKaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2dWQnhUW3nLzRfcdUuPwmCKrYOUwHwYDVR0j\nBBgwFoAUEVIfpjrkWg4OoRKvn1hXXoy6Nb8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJKXBlKHgNQm\npWXhtT3SntjvM4vWnDsNJV6/Tr4eoKZGAiB6abzdGiy2GWmNAZMu3+9RNrl8WnHJ\nLhWwsmUNw9G45w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQe9BC50Q9br/qx+qHKcD/AeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWRiZGY2ZC01NzczLTQyMWMtODUwMi1jNGFmY2RmY2YzYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASakzQzrp7zY/KBf/oM9KaR+9iOK0p5Ywi2OUybJi65GA45\nJT9qEbhn80+ZSw/ztO0DHXS1ounqHm+pZApfVtiVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEVIfpjrkWg4OoRKvn1hXXoy6\nNb8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIEp/fTK6LzoJOr4cN6+nQdBvlLd/W67dXn4+Ny4TBlPAiApxWJm2k49\nvngqNehRwjRYwYDC63/Il9PmLlQa1uOFpg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAa3TGhwUJ2wc2RXW4460MuoNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDNjZDI4YmItYmQ4OC00N2QwLWI1ZWItYTdkZmQ4MjI0ZTM1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTRlNWZkNTAtNTJjNS00MGFmLWI0MjEtNzg5NGU4MDlm\nOTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw3jTkPmgW2mYlotQHGegGywb\ncBI10yh4LAKNkABRI3mVwLsbmxWxV8NUzqV3K6iIOxiY1hnS8BTbEtD+ESi9s6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2dWQnhUW3nLzRfcdUuPwmCKrYOUwCgYIKoZIzj0E\nAwIDRwAwRAIge/QKOtleHu6SQ7McTIcG9EprPD6RgrlP0XuVIKmYJqkCIEo72oAC\njBm0CvqtwchIDHj2w/F19SqYsOWM7OQ4fiuk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2206", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2206` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAXbklT9ZsA6y1v4JXD26sbD3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiZWVlMmQ4LWVhNTAtNGFmMy05ZTlhLWU1MTllZmExZTE2MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRjMzEzNTgtZjg1\nNy00MWMxLThiYzYtNzQzZDhjNmFhNWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgTYg6KOsGpjWxa7xRRKuQLblYuWWkj0rmlqSGGxg3XebWqucB7KjFxCmYk10\nelnn7BFz4AhMCi5WdfzpQ0FuOKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0P+EmtSH9SlFtoK+qixzI/6845AwHwYDVR0j\nBBgwFoAUJyZFsA/u9gUWmgzpR8YLhKzqZ7cwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDDgXNXfEcSq\nLKBrF1T8TRkDy3wTadN7zUC/zSyUrpq/AiAd4fyjdMWmEYQ1TtTtBVTpRRXaH4T5\n6Ke0b65wxC74Dg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUEpPVS+NNET9OBb3ol17XGKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmVlZTJkOC1lYTUwLTRhZjMtOWU5YS1lNTE5ZWZhMWUxNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3qTlaAcdNEVJiZFRvc+8GenYUNuAx73epldp6d98dGOwC\nfinNC3i497LuOYtaRAEpZKM+8PJVcV1GFdT2QdTqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJyZFsA/u9gUWmgzpR8YLhKzq\nZ7cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ54MPnNR3M60wly7kKwr2aGumJC1OoA/AwtSX3WbXiwCIFK63+8bhGpT\n+I//xMyI5lSJ/9OLtQLCduFZEqSMu6OM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAeKk4jrTNLltewtyNKepmK+cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRjMzEzNTgtZjg1Ny00MWMxLThiYzYtNzQzZDhjNmFhNWQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjFjYzcyYjAtYWU2ZS00ZDE4LWI5OGUtNDkxNDEzNTZj\nZGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOLmJWeplzd1dbXrE3qDZU386\nbX1Ud5V/RbZwQh87U492qx/lL664W/iCei8d8s7EyZoOE/9d6Z+ExOgZQCLo+6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0P+EmtSH9SlFtoK+qixzI/6845AwCgYIKoZIzj0E\nAwIDSAAwRQIhAI5vzbba+UVs7yjTvatxY54Xwx4UMMkrvKmKRKekWtvCAiAypYS2\nVQn0MfpI79atcXHr45gFqCyBtAAqL3DfSmIioQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2207", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2207` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUhcbzSgzpjJF5OIYnzbzOd+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzY2VmMjBkLWRlNWMtNGJmMi05OWM1LTNiZTFhMDUwNTRlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg3YzU5ODUtYmMx\nZi00OTU3LTk3YmUtY2MyYzRkNWI5NGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDi08ubtSgx/gjSoMcywo3oO3ggG8KurIMPxQNzlDYls1JMSP1Immj3NzkJ9G\neoyZVXKqPuqvg6Lwnd/OMOW2+6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBCHN1Zbi+wDxdyklr4lve/0nQagwHwYDVR0j\nBBgwFoAUV+4LDMlBIGQWATzwWbRgtzZbBvEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHbJrU0m4DXut+zvfn2anhMMXil8UcJIssa1EMt/tkWrAiEAngl8G+NPB1ef\nPHV48Ejf3bMpXCDToKqmDmIw4/42q5A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYMNE2SVpDrJ7AZBZNgcyV9iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2NlZjIwZC1kZTVjLTRiZjItOTljNS0zYmUxYTA1MDU0ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXmPahM+5dvm/DfVc2Hh2o28GtAShrbFwCqBWzfnLwzanY\nx6fQVZ37p95OcLdmiKEpBOWA8I6Oj3CUaI3jkVCJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV+4LDMlBIGQWATzwWbRgtzZb\nBvEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIVZ4Atwvr1EdU+rNGhO/fomNA55uQf8OktDJqY/XXK/AiEAmohBXtka\nV6gXKWesJ2c/HwRu+yj7bqLMV1I6hJ1eMmY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAWJW4bZBDOzyJ39itDBpSJ9hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg3YzU5ODUtYmMxZi00OTU3LTk3YmUtY2MyYzRkNWI5NGQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjYyMDBhNjYtMzYyYS00OGUzLTk4ZDAtZTI0ZTA0ZDYx\nM2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzVDdjxrv6XL2tOO72uU4DFaR\nyTB7dU/ETstOttV1zntpLjZ24BplIKvlPol9GOeeUHypjXWqGU2I8XJxSPBvYqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBCHN1Zbi+wDxdyklr4lve/0nQagwCgYIKoZIzj0E\nAwIDRwAwRAIgQqJKs7IXbQ16lpuu5ruFRoJ9IwJQ0o/4EqjIfTW81a0CIAraxQz0\nuOxm3D45oNyhEsExcMfi4bk+uLQRpFW9XXrR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2208", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2208` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVUBGKn9KvFvmqxqy0clCtYqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4YWMwNjM3LWI1M2MtNDk4OS05ZTY5LWY3ODk0ZWI0NGMwYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTYyMmNhNDUtOWYz\nMC00ZjA3LWI4MGItODllYTc5ODhiNzgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6s5UaYj3K118I5JpFBAF4kAorA1darD9IUStGKzmLhvGcjmv7PbwmXjnafIr\nWpP6XP/oXfCGyIGYIAbTxrCphKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVlWhxAJ+SUReVx7ihf3/KF8p70kwHwYDVR0j\nBBgwFoAUzTX07Ql1098NgOesRP2XS1zR9ekwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCaI2+xzL/zFibyT/OpckX8E7m70gSnx692rMI2ZaWWmgIgDfrBzZqwAQcD\n7uyInGe/84i7z89cxd7NDbtIZERfCx4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbbEcbLpXpOtuixen7yRdYo1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGFjMDYzNy1iNTNjLTQ5ODktOWU2OS1mNzg5NGViNDRjMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATx1JMOrsoPo2ZZqlbPKCRWGfztZJimXPemGWyC1r5YiVOq\nMWnh2U0vl2HCA8NteCJoALyk+2k7diI+a+nwOxrYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzTX07Ql1098NgOesRP2XS1zR\n9ekwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPZg5yG2WXy7zjhMQ60A5Zh2nngekWibb+jq439NyTt6AiAJHRNAEn2P\nSUba9n6mvFuMv6gRcOc0+a//p73KbdsPGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISATc4WqzbJ8gzVo0LtppK0enkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTYyMmNhNDUtOWYzMC00ZjA3LWI4MGItODllYTc5ODhiNzgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTVjOTQ2ZjgtNDFmNC00NTEwLWE2NzMtZmU2ZjBkZTc0\nZTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhJomCBCKwayL/W23eGcLROqL\n4s8eUEqntAJEYDgmIpscQm0DrWNb1J71WHcSGeSDdqa9ox9VT5apxQkuIsjq96NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVlWhxAJ+SUReVx7ihf3/KF8p70kwCgYIKoZIzj0E\nAwIDSQAwRgIhAOncCMVMGucJBugvEW2P5tKZwTA3tad8PjCsl86U+YEbAiEAvjJp\nPUiQxfBV1bfIYhYoQp0MvPiL88tjxvClNNJfT0Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2209", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2209` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAbEf6RygnHeM6cA02sFdnBp6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1NTFmZmY4LWRmN2YtNGMxMS1iNzhiLTU3NWYxOTBiNjQ2NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWEwZTg4N2MtOTM2\nMS00OTk2LWE3Y2YtOGZmZjNjM2E5ZGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERkF7Y6aNQbrjDxHrxfDw0aTMIlO6rxq2/6iuf9s40T+ECd9Jjit/s5KexKJQ\n0t3e8n/NqvPYMG8DZww/FrL9caOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZA4BOzn3npEX4/0gsAtUCmFblQ0wHwYDVR0j\nBBgwFoAUWM98lROtoJkCF9DdjmNzbT1eU/wwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDU\nja+sddhSOGcSaB3g8dNaMuGLPQj/rZTGtvuUNxE1iAIgbmJ7q2FtLgpCtyC1FdZY\nCfUtttPTuJ55WKwr9waxQe0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY/MFcH5NwxhjWZHlameDFx2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTUxZmZmOC1kZjdmLTRjMTEtYjc4Yi01NzVmMTkwYjY0NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcbc/Urdifs5xpFkiypY8j3nhkOSOGcAifV5VGjy8Ah2mF\nMJ8tRSEUb+Ix07RKpBvX0icFWuFd0CQxA4FtuH2Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWM98lROtoJkCF9DdjmNzbT1e\nU/wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN2XBDvpLs40NzIy7llcsDgFbpaZjc1Lwu/DLn4c/8BrAiAwqwYoOOee\nvmpOpafcOcZcAiLyED9B/RiZN/rNV1dZPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAZfKVi+7xhevVjgL9w/dQ+O1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWEwZTg4N2MtOTM2MS00OTk2LWE3Y2YtOGZmZjNjM2E5ZGEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGE3MjVkODYtZTJhMS00Y2JkLWE5MmMtZGI0NzJjOWZm\nOWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENvLD4B1Hg1lNZ6KQZXW2LJ1j\nkCL6rOWSqa0SGaQDeGntuVOQ7i344Z/Wg9XzfLoACGH3k3ONZKEWyUqag/zeN6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZA4BOzn3npEX4/0gsAtUCmFblQ0wCgYIKoZIzj0E\nAwIDSQAwRgIhAKCh+jden+a2fBl5weHZAaDBER/5X4NBmFcbH4wY1pwLAiEAllTI\n96b+7GAILrrXYqVaQN2b4CP+7OvPrcnWUe9ejfo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2210", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2210` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAUwTI7QxJKv6R+hCRHUsg4xnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ZGRmZTBjLTc0NjEtNDMxYS04Y2NiLTZkZjc1NjgyYmFlYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDUwZDkwZmMtNjk2\nYS00MTk0LWJhYmQtNTM1MTJjNmU3YWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKaf8+hW2NWRpXCaiCzXKmeVDfZFs0mv0qVmh3miBiWHI0wd1USF2ZqZ50QQD\nWb2NZypoVN3az/yY6Kpbz0wluqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3OiznB8s57kJ59sfQJAuZxwjGkkwHwYDVR0j\nBBgwFoAUJX2jtlip8vpad6SPn+ohZzUTGmkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIA1N1kOtX3s8PYEbS5xKsq81tOFGgyKsJOFezhVglYLuAiEAyH1K\nGfeWLo8l4FGS6uhbCRdV+2+q/O/e3tLSiGtkWf0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXy1A+SZUxvKyvGwtUJXdvG0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGRkZmUwYy03NDYxLTQzMWEtOGNjYi02ZGY3NTY4MmJhZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMrBop+NNJoUpT/Oj1dFTp+h4Bd7d/J82eTlY8FHWRoCPD\nWHHyYoqioqmWTAPZlgQnH7gk7PTejDufvyaJFhuZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJX2jtlip8vpad6SPn+ohZzUT\nGmkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBvl0CawOn7BjPjQaHCsMLdh+Jqrtg/2DgIgRmQ7RVcwCIBn1ceKvFAlx\nT02agtbt4yDbl33kfs3qnMa6hjn1TZfD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAY3J/bfgvwRSpDJYq2fW2223MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDUwZDkwZmMtNjk2YS00MTk0LWJhYmQtNTM1MTJjNmU3YWEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTk2Y2FmNzEtNzZmNy00NGQ5LTk5N2MtZTE2ZTY5NWNj\nZDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkIufK/srlgPZCpXYBubyc4SX\nrayuIoC4KHR4/nER+4UwE99OQBAFxsvbosIOeqxMK3aQB9Cao9TyD61+GxCopaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3OiznB8s57kJ59sfQJAuZxwjGkkwCgYIKoZIzj0E\nAwIDSQAwRgIhAK2kuj9uWDlzKtQ/7WvMWKxmhPyTW6KwSHQoAEAS2400AiEA2bMH\nZemAawCdTPPmKdE4bDgCAiSr9/FQFJQG1vyAX74=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2211", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2211` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATw/nnbvQ/DlBPyFDYkQL0wEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5OTA0NGVmLTNlNGYtNGQ5Mi1hNGQ0LTU4YTRkMTVkMjI1MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUxNDZiMDctZWI3\nOC00MzljLWE4MTAtM2U4ODM4MWQzOTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Bt/UQYavV+O8X4lUBXq8Dbjykd4Kza7R0gKTrJh7xrIZsqlOOg3++9H928c\nO+ViXmdlZ/MM/6Qk5JUMCqBwm6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjLiW27kQvfffg9bRJUNY1/cBR9EwHwYDVR0j\nBBgwFoAURZEM6tF6RVoBhBNrRxDFqPFG1CIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCZzBS5vGdcFuRjLooXr9+3tyFp/0RYq+PCqfsVc8zMYgIgIerN\n623Finm0o7bYuicpf/4yBSRdePjj5xLUKo34gLI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcWt+AoWzC3BdBRWQfGey6h9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTkwNDRlZi0zZTRmLTRkOTItYTRkNC01OGE0ZDE1ZDIyNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKiOmQHGNA3QP8yyi15ufMhmaHRbC1P/AnRv/AJJuZHdI8\naB1lp8grx/x3Bf78rJ+pqhQzxm4pv37M0HvLaDuHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURZEM6tF6RVoBhBNrRxDFqPFG\n1CIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI7SKUPBmjJjRW6Mf+38fcfGpmFZeGbk5InC7QJq42MjAiEAvSxws6e2\nu8irMlzjZHhFzALC6G8l71BKaeh19CEP69I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATTfSulr8LY3Iqm8N/o6qfaEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUxNDZiMDctZWI3OC00MzljLWE4MTAtM2U4ODM4MWQzOTVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDdhNjkxMDUtYjdkYS00ODk2LTg2MzgtYjRlNTg0YzQ4\nMjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEU44fa+FSN62OxYHtSKz+7JHI\nt2Hccn1NIrsq2JrdHwMIYLK0zQAFQDV0c5UWLeM6HbQPNHG78+py/6Vzjrp8OaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjLiW27kQvfffg9bRJUNY1/cBR9EwCgYIKoZIzj0E\nAwIDSAAwRQIgXOu1Dlb+mdC+hNeoWrBFuM6Hn7jvZCLhoYj6clp14x4CIQC/cJCO\nq0dHZcR3j7jYNYRcF/JLjwiS6nP8PIokGgYFXg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2212", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2212` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAajQ08a8KrYYEaC6I65hU1+CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZTQ1ZTFlLTlkMDEtNDZiZi04NTFmLTI1Y2ZmN2FlZDQ0MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThiYWQzMWUtYTU3\nYi00OGJiLThmNGMtYWE5ZTY4MjA3OGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa5hWe0dt4oJclsgjEdz9yWYTph5+JD+/nM2z7Px3Ox3Z8RxzZfjMSWmuHzfr\nlV+RJBTZQenTV5lVEo6juUh6NqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFP26puPWz+XQKGJgWf39qy30nm5YMB8GA1UdIwQY\nMBaAFKzox5IuSEi2dy4ql3ZzFR8G/uTCMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBTnYETpFuw0V1wMdxN3TFXIUGSbhRvvyMg\n9cYjBYFWMQIhAMeKPl2v5tJqb8VC0hC3wTfxl0Y2kgZbNYsL/11No4Tm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZt6sEfTf3BK4jim6vABDrNcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGU0NWUxZS05ZDAxLTQ2YmYtODUxZi0yNWNmZjdhZWQ0NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZP6k5zKPhFFU/9tZH5yMtmn0yLe7rXA0ymTQsOOvmIpqp\nHwDSBbZ1AUB2xqnRhmFWvCSBNOSuB1B9nwcM96RGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrOjHki5ISLZ3LiqXdnMVHwb+\n5MIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgae9s7AQbnawJFEzRkLfhryaPLmClNZcq/FyyxdrPIs8CIQDpncoLyaxc\njM3Se7Z06nmHHNFRF1PtBsIXL4/aFbu+ww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAQaOSk8Lgu0uA9mh2SnsfKFSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThiYWQzMWUtYTU3Yi00OGJiLThmNGMtYWE5ZTY4MjA3OGM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmViY2NmOGYtZmEzYy00NWMzLTgxYmMtNmY3ZTJmYWY3\nNThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETp6EGgWOnpviCq50pLhCk8gK\nqafsW+93MCZ14oUXISi/Nenrlt5DzP9KN2iGwM9cg+inDsU/ADwyA5PtcG2JUaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/bqm49bP5dAoYmBZ/f2rLfSeblgwCgYIKoZIzj0E\nAwIDSAAwRQIhANRFgDBybozesV0MmGUIj4RpZiOnTPOr8LpbmZ8SOHUiAiA6UAwi\nyNTaXR0yiUPMnLQzI0P+68byPPN3E5i1C3OxdQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2213", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2213` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISATzgsBDEBeeWjFNpcYjDgbgRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2OWU0YzAxLTExNGMtNDJkOC1hNjJiLWUyYWM5ODIwNTUwODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDEzMzQ2MmQtZmVl\nOS00ZjFhLTg0OWYtMWFiMmE1YWFkMzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoju/89fQfA8sO+PBrMkajEge2BQ/MybZxS7MSzoygK46q1KaUaCgbKJRDGZr\npE+KuFO3R3Tpy3r7uB4XtVGyMKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvLS6pvru6ptnqL0OYSiH5ml6fjYwHwYDVR0j\nBBgwFoAUbphUoOs58N8B83Hpq1un9551YmAwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgU+fQJjsdA+of\nszDbrfqsh/CGEnqqimHnERirVxZHVb4CIDBIcoouOORq2xyGEbiHS4qt5GIoTxiq\nnKMuq9uUsZth\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa6IGvTNM1NnHRuEDCXmh2NJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjllNGMwMS0xMTRjLTQyZDgtYTYyYi1lMmFjOTgyMDU1MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRYXghpl9dHFet3buxtPeSIwHV9eItMNjAr+VH9YCC7XHP\nzfQEweeCUHOg5BDMRu+vMxyMziK5LidsVMmOd94qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbphUoOs58N8B83Hpq1un9551\nYmAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNPvsAqQvSMX5SVnA5JCtXOuvUlXvrWKalbBKMne4+7gCIDw7pXnZRh1l\ney9MVHc0J7nwTa/OJUfnHAsmbgzYuwc+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAVAP9eG2jqRkcOWq0fwtU5loMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDEzMzQ2MmQtZmVlOS00ZjFhLTg0OWYtMWFiMmE1YWFkMzIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjI1MDY0YjItNjFjOC00NGEzLTg0Y2UtZDg5OGFkYTUz\nNmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6DrFPsSrbsJgBF5oZhkemVyI\n5Y86569Y+6Bm1Nq5RqAPfImlqVmGXzbT+sNQv888SfK5kh6MFw8/Izaf78QnIaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvLS6pvru6ptnqL0OYSiH5ml6fjYwCgYIKoZIzj0E\nAwIDSQAwRgIhAPPt6y3bYDZCKciAfL6eket/CNTgQrxMp0YcbrrP8Sn8AiEAyQSM\n4PH2ik15sGdaDC0A4exj0Mp3xnzRK/Zh6z0IzH4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2214", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2214` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATlz/bqkkTRhm6OXcj42gYhmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ZTQ2MmE3LTJhM2YtNGEwYi04Nzg0LWM0NmQwMjE2NDNhMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVjOWJkMzItNmM1\nNi00M2MyLTg4ZDMtNDU2NTBhZWIwYTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUBoPzrqbX4p975SyI9man9ytHXouIw9umWO01HeQOI1atIVcZ7uE0jpC95WK\nuwHIC/J2HUSeL/QbX2r2rDr+nqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmD76BZfXD3Mrnh4r7V7/6B8zAK8wHwYDVR0j\nBBgwFoAUkNsAvjf/CNeqm7I3zmSuk0DhjyEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgLRbEex29nlaL\ngDEYhH6Bj0YG5kYBcQKyFXCmwjnDlBICIQDT2GTKUSU0WG5ZIUTnarEInDIk8itS\nJ4Q8WZ1lkjBTDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdBxmNdZVrssJBc9tzP9Bs+bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2U0NjJhNy0yYTNmLTRhMGItODc4NC1jNDZkMDIxNjQzYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAwSInpGcGMw5Z1ghPcqGAdpYQBjCgGrnJ/Oo3Azh2sOlx\n40NPX8Kt9wWRWkW5iFSLhQacdwLPO48r5B/XEvjZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkNsAvjf/CNeqm7I3zmSuk0Dh\njyEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK8+txpSIBuF/AibRqUTM6vjwVHMyK9aLmXmD0SyzdMfAiEA79dtDhji\nLQ4kzupYx5XusLNzgcC73Yd3gBRfXWXiNig=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISASd4SG1W48VOcsZ2CwpFxAoeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVjOWJkMzItNmM1Ni00M2MyLTg4ZDMtNDU2NTBhZWIwYTc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTNkOTJlMDYtZDRiYy00N2VlLWJmNTgtZGM5OTg1N2Ex\nMjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdFON7PFqD3v+KHWF1XFV0/D0\n5FAh/dsDvx1SSSueJXr48HzJpFeXUnNUgmHCnjM2IjOsUm33KANMVKuDUF/3MqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmD76BZfXD3Mrnh4r7V7/6B8zAK8wCgYIKoZIzj0E\nAwIDRwAwRAIgLFCukkVjxW4Nxyb0fZzE+O2rq90vsD4qSRtIIWzNNNICICyb9lQT\nYXKuCZwWsq+APohWPC/il8NChb9ulUWFjoiQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2215", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2215` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdvozFzg3FALrAPfY4kEN8geMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0YjAxOTA2LTc3YWQtNDcxNC04YzU1LWZhMDllMTU5ZjNiNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhjZjBjY2QtY2Yx\nOS00N2QzLWJiMjMtMDRiY2M2OTlhYmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElmTBvoXj3DaA8xC2UdD6F/daeuEmJiRzR7loTUzT9u4GKHlK1U5e946K2jf3\n3cdMb8vNMeP1C4T+iUV9EuyiPqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr5hfTTbrSKLYJxsmnf7FaZb9PbswHwYDVR0j\nBBgwFoAUtolB1W+uiVc7+vg63qnHPL5vyO4wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHRo8Oj7HA4q\nz0R18vMq6EOsb3FQue+rFlGNn4zCPqbTAiEA1LJWbtZ7hkCUNRkMaoBoLhrWHteR\ncEQASBzW39SZDB0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS6AcUc1QSYsKyMleQwyhu2rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGIwMTkwNi03N2FkLTQ3MTQtOGM1NS1mYTA5ZTE1OWYzYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmaMx1817+u1tANpckPW5v+916IzhGu3xKBQ6Kl7iPYc0Q\n2EPxsBDm3PC7z8/KjD18ppsSLefJUAXgzUDTJAGEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtolB1W+uiVc7+vg63qnHPL5v\nyO4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMLKnXnedASyclNZFhviHktxj6XecUqt7XctdRyk8WOICIQDtlvk0yb+r\nMob/GSISd4Atv1CL5pUE/swxHYVkXHhcyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAV84CcdRSxRkoDuaZv+NPpXDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhjZjBjY2QtY2YxOS00N2QzLWJiMjMtMDRiY2M2OTlhYmVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWMxMzU0ZmUtYTBlYi00MTFkLTk3OGEtZmQ5MjdlYThl\nNDRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdHv39c9/1Yr43VQnZxPcWes2\nEYRAdqK7s+/o/sUeXDU9MN5sumgQdbxnP6p1DBRtc2/jPi/i/4pekIJGlvv+g6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUr5hfTTbrSKLYJxsmnf7FaZb9PbswCgYIKoZIzj0E\nAwIDRwAwRAIgV9dwf6CBaP+3mzNAkDmacAeNujj2n7hh9bwLeJ4GsqECIG/uM0ya\nCPn/PIi/pxSHmQnIElUltkDSgYAWcLBlN42e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2216", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2216` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATSjlEwC1Y1AVWodmGeHDi3SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0Njk5YjhmLTZjM2EtNDIyZS1hZDc5LTBkODEyOWQ3NzFjMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTAwODJlNTItNjE2\nZC00YWJjLWIzODgtOGUyMzQ0NTZlOWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0VxnQN8hzYX1fGqa8f9Si6HDvffnyd5n3GA4HJfis535/6TM/ijrkuv5vE6u\n5qlAwdX/WMu9dpLwotk5buWr/aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNcOeJaspXaS53B7HYoyRMisGQxwwHwYDVR0j\nBBgwFoAUYx2Se3+MvSkHdfRQEZ3xlh7kn3swNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDHVUBkdribBSQQcDo9AEztQWBW38WKDXFUU0CIIOFmPAIhANKduOnzCSCr\n9soQ7arhf6QA7k25X5Wo+VGNrdS/s2MG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZf7ryr9WgjfJ9yiSD+E2vmhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDY5OWI4Zi02YzNhLTQyMmUtYWQ3OS0wZDgxMjlkNzcxYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATK2IjMbPhUTYgCYqFieMMqSXa3xDHQ00+0IKe4SJPQxSGa\nt8jHrfAHEvxh+6VYFG4S5Lo20aWwTDLTQsTIUA8xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYx2Se3+MvSkHdfRQEZ3xlh7k\nn3swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJpkp/WOoEWGbgZhC/QVhGKL2Vn79GpImoIclpPHQ0+tAiBkc/l1gosr\n08clz25uDbyqCeS5/sRj4FU/5KTc5Io0pw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAUmL9E9fhbRpCiZ9NDhAsGydMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTAwODJlNTItNjE2ZC00YWJjLWIzODgtOGUyMzQ0NTZlOWE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDg1NWQzNTQtOTJiZS00Y2EwLWI2MWUtMmYwZWUxNjY0\nMjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyep8hzd0qhxi1c07sez6b6tb\nD9LwbZAvcpqU0/XTgOHCmAGiMuNK55yHLgbxOlM7769ofoyCKDKpuKLJ3pxq86NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNcOeJaspXaS53B7HYoyRMisGQxwwCgYIKoZIzj0E\nAwIDSAAwRQIgIqP4UBtlh4Zx5IJC6t5+BkCKh60j6gS+2pjjOJlCM9oCIQD3MgTL\ndyR2b1sDL9N4f+e3uQlsJ55UXs0Stoku0LSFYQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2217", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2217` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXD1Th0VXlIzSMrV3NmTtMnrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMmNiOWZiLTE2YjItNGU3Mi04NDYwLTc3NTIyYTBjMjk4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJiZjA0MTYtYWVj\nNi00OTg0LWE1YzktYzIyMWM4YjFjN2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPuBQ2hN53yejPoI+Xyhs2PRSpAKFylQ2aH/B8sjjPJerXlMOD/5qFkFvV2xX\nWoTiylQzIHRlm4VQydEVUlh0aaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU86MdokZk5ey9pvErrH1amNbOtPUwHwYDVR0j\nBBgwFoAU39ldE7J/pN7XWnvOfiT+7CNJP4QwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC9WRu74HtPrBnsOgSvWLweFTm0BC21TQj1vmhCnPCopQIhAKt5mhBwQShn\nTS1yoDQviPwULFI8oKI+lk+9yF/+OOJ4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVx8TNCTHINJtNSASVLVRbEbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjJjYjlmYi0xNmIyLTRlNzItODQ2MC03NzUyMmEwYzI5ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/hN7Ygw0kNNZRkrSLpoLGtW7WBWEgLaMlVecGGiAR2oDb\nzl+FwGqtZ38XIaW7G53yUbTHGMtp0aCqceN4z8zvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU39ldE7J/pN7XWnvOfiT+7CNJ\nP4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ4EDLbBzzLIwDNxWqDBGrG1o3WcxOWv1YeRF4dz+cOmAiBvNQaezDpq\nqV9RMeJwN2t6V3otrSrJmEEdsJ53Bi+Wrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAQwYvCVBzDIKinYylTJTQlEwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJiZjA0MTYtYWVjNi00OTg0LWE1YzktYzIyMWM4YjFjN2E3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWJhMWMxMGQtZDM1Yy00NGEwLTg4Y2QtZGZjZDdiZDQ2\nOTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIIQPAi83i3Uli7/GCkD9r4Dw\njVZ8tXqTiNdLA+FkihGsbyx7opeFkUL0au71FL4cH1cbCRHdzF0xXHg34PHZE6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU86MdokZk5ey9pvErrH1amNbOtPUwCgYIKoZIzj0E\nAwIDSQAwRgIhAJ56aLzHvPOUQYF2TkPpWOEo15Tn9VMjA6/4EVlw01rEAiEAxo/O\nybpHY3PqHP4skWodBb7jSzddmNI1F61UptW2wTg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2218", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2218` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAaSObKDHiC6F6QJo5MpIYGwDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzOWM1MGE4LWNiODAtNGMzYS1hNzUyLTVmMDIxMmZkMGViYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRmYjAwY2YtNjA3\nZi00Mzc0LTk1NzAtNDgyNDRmY2Y3ZjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEntrM+yjr6/twuOyplYfYo1WU6kf3w4jpF7spk4T06Jvem3UicTL+mk3/aXid\n+GRzrcxq/TG6sv08io3Gf3cI0KOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgllH0JlpVl1fdoph+yoxrG/ut7EwHwYDVR0j\nBBgwFoAUxSmqdNO63PLIIACk24OtJZV1VQ4wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBPu\nkKjyNS3mfE1o/uUISfvyOhulrs2W0pSLp7Ucc9BhAiEAvVEdxhbb6KFa34s76PvY\nTPS7iUHXhNiRzq/tK1PR1/M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWhxElPTWybAmjYKLcjaUeEfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzljNTBhOC1jYjgwLTRjM2EtYTc1Mi01ZjAyMTJmZDBlYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk7OpoXTJvDd5afwAcQcr0Xes4Ko04bJnjKPxDF1wNF1BN\nJPuq9wgRYsVGh8jcOAbBhp3T5QnySPIeSsMPA7CWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxSmqdNO63PLIIACk24OtJZV1\nVQ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNBXpK7gBZg1hR2fS2+orLGh2ororHOdl6VAwXwsLF6UCIDlHe8jCpjm8\ngd3HzNMLe/ujblf55knpvu3py3fmBNRl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAf/NFqoehyUBA+1uioX64LyYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRmYjAwY2YtNjA3Zi00Mzc0LTk1NzAtNDgyNDRmY2Y3ZjRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzExYWM0NjktNjlmYy00YjAxLWExNWQtMjQ0NGQ2N2Fk\nNmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGkGdL4gJWQ1xvqdabn8KkBr1\nT7SIzAj9s9xA+6voTkXrCqHaWeDT1dZpTtQUYA3sLHLEmJVvGmcVTxN6VFyW7qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgllH0JlpVl1fdoph+yoxrG/ut7EwCgYIKoZIzj0E\nAwIDSAAwRQIhAOL4ELTES2bQkgAIOe6Oo5W/NwM6zD5YFLUZtovaqZXLAiAeu+Hd\ncaXvChPyzvaCsiwepBJeLKS4HWNCgScBZbJAOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2219", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2219` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZz0R/7Ha042kx3W7wp5fozAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwMzlmNDBiLTI0MWUtNDc5ZC05YjZmLWI3YzhkMzI1YzdhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWRmMWRhNmItMTM0\nMi00MDM4LWI1MjItYjRhZGE2NTgwMGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEffuhXq1HCixJDC/A+EqFIcxmSv5xHkhjDsPhA0zhgALSh6i+MQMHICh1U1/F\nLTlyfaSvlQYpIen3FW+52+jSp6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUytkUXvl/g76toexG+oM3gZ9v4aIwHwYDVR0j\nBBgwFoAUC7QGN36vRKckMnA3H/gMCaLczUQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCID/XBEANyjgSPZayJ142eeHrbZX9rYiyS+8xOrzsKx+OAiEA+mKO\ndtj2OWM3tT8CwL2fZjU/mdJbtxtDzyVVc2QuoUw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZUATdNu/zyvLFXqcHkE/xZzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDM5ZjQwYi0yNDFlLTQ3OWQtOWI2Zi1iN2M4ZDMyNWM3YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQykegb7rsMtKXxQg5jJtS3Or1j1O4HOs60b97qGKVGoyUB\nEm9WRMFS2AM0LQK92aRjE/0iy7MWhGxWEGTpFeDAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC7QGN36vRKckMnA3H/gMCaLc\nzUQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANmX02mPzaRYFDeoqmkadPmhpq2ZpcTOH/yPPQGhPnKjAiAMHqDnEsdi\nU+YrpDkqxVpwbDonuvVPr8VsF/W3FAxeTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAdCqCzcMiaTP18oSsQ1DlpKHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWRmMWRhNmItMTM0Mi00MDM4LWI1MjItYjRhZGE2NTgwMGFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmRhMTM0MjEtNzA3Yy00ZTUzLWJhNDctZjBmOTlhOTE0\nOGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwMe9U8PIKP/vrzaXyZ9Yu6+a\nB9PtVeYSD7JRoaUf1MTQblMqFGVXiC54PL3/ukZCcPMK/P+W6OOkj28JaCMeJ6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUytkUXvl/g76toexG+oM3gZ9v4aIwCgYIKoZIzj0E\nAwIDSAAwRQIhAIoFxjmVhhb/Vy4lklMLB5I3ghHmkorBWprBVYRAb4SmAiAeoc4w\nNCV22PpaeDf0vYp8257IaKOa0vY37Ve+cRICUQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2220", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2220` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAfsN4i6LiJOJUs+hIq4lWWWaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3NjcwMjAzLWIyYTMtNGJlNi1hNzI4LTIxYjNkMDRlY2QyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRhM2RjZmYtZDk1\nNC00NjNmLWFkNTctODU2YmYyYjJlOWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfiNsLMMXmca2s899NMUGpoV7gM2Tp4Bs++OptR7bsRYCH3sqHTJscSNU/Ipi\n8FxL1fkbS68zTUg2FNZhzfKpPKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULyyP7svnINmivUW7QJuuaLh8bBMwHwYDVR0j\nBBgwFoAU1CJmEt2CDyW+xLpfAQN4YkSfk68wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCXQUPuvy07U+cY35XMyNX0+ckbJLztcOo2DmlgPVGS1wIhAKhN\nTpkHZ+TAxokmlQ9ZG7wrF6QBOssITAkIc5KFKK9D\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXDKqRv+oTsPu2+OgP5PvvkwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzY3MDIwMy1iMmEzLTRiZTYtYTcyOC0yMWIzZDA0ZWNkMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPhITY1+CodT5/obvfvSaiVf2AaO4eUDh+5p85PDypeHEs\nRRpptwtQNsduPDoww2CJW0EMwodS70BNwMBl+Ifpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1CJmEt2CDyW+xLpfAQN4YkSf\nk68wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHcHYN597WzqKAEHhNb7SyQvVvtptqzyDrPoZAlv87UUCIQCkg5XgSmRe\ncSK6XxC3qqKb2vUhPrMAKA4WazMpcafOpA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISARC3wGNg/sOH4R7HLYvNKNkcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRhM2RjZmYtZDk1NC00NjNmLWFkNTctODU2YmYyYjJlOWQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzIxZTQ2N2UtNzBjYy00MjY0LWE3NmEtYWY2NGY2Y2U1\nMGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzdK/kRJ741kr2sd6ITTGBVxJ\nTZZCpAd1Ua8Sffk7xKoOKGYqfi/jcEk7XjhNlgOfclgq90j8G1HfF6EMRtAgQKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULyyP7svnINmivUW7QJuuaLh8bBMwCgYIKoZIzj0E\nAwIDRwAwRAIgKWxxxe8vYR/TBsoFKCTyY/D99gWHkg4MW/44jXrDIHoCIAlQD73y\nr35E4Qas2fK93dSWfgeq/rKC0DHUpqchf1LN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2221", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2221` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAacbjxnnawC770B1GCSlkhBPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1MTY4MDZiLTU2NjUtNDlkNS04NzZjLWE3NGFlYjhjMjgyZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg0ZTBlNDQtZWE5\nNi00NDE2LTkxYjUtNzRjMzNmYTY4MmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8Ui9yCzP4N6LuJ8JrGKiNaZNb/bddCuDFkBINIa8W0dwgg3xl61626xnnklT\n5c9h6ucZV5SX18wiAFhyFYDpTaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRuHnStQNZxaC5rq3qIsIEQsUwbPzAfBgNVHSME\nGDAWgBSNl9fp0nIP+8XaLrhj1WCc86PszTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCcFg8Celr+7inEAcZDvdmvA0OeilhA\nYy0fZsCg7c1npAIhAKjf+OikUnwF4auvgQpdIYUT9x+ixsA84GCRY6mLfR4n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXt9ZO4rAnxEq8MdlWvNqOcRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTE2ODA2Yi01NjY1LTQ5ZDUtODc2Yy1hNzRhZWI4YzI4MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhJBqBcshceuVtQAd6TJBcfYeEq82T21qYPkpkX7DGA2Fe\nRXWPgmgfaldVLoreB4wLkNsTy7yVtRD0APM5ZEGjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjZfX6dJyD/vF2i64Y9VgnPOj\n7M0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMCa0v98l74PDRlebC2up1r1R+j+jq6+A4+Z8G4nmW2HAiEAzsCGda/u\nowFErhjiMmXtVIjzJ4Fcs6JF5LyBPfE1Krc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAYUrDtlD1UBeKPJE6vcKO5/3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg0ZTBlNDQtZWE5Ni00NDE2LTkxYjUtNzRjMzNmYTY4MmQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWZjZWQ0MWMtMzk0Mi00MGE4LTljYjYtNDVjMTg5ZGY2\nNjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ/tpJLjPFcP6vAwb18gEOq/y\n/va9She4SOD48s/hG9wu/dobH6uHecUKVTGM4wB9Zos6jltbGyIbbCpgb0jO26NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbh50rUDWcWgua6t6iLCBELFMGz8wCgYIKoZIzj0E\nAwIDRwAwRAIgdw2M6GNTE8W3YYDtirmKp1erpeosVh/GZFCCVNrW6aACIH+uq8jj\nog6tVx7UP4+TK0GXQazPQVVFUPKOFCFEk+S2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2222", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2222` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAeOLW1+hzZ+lFE0VWbfxkZsBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyNjYxNzA3LTY0NTgtNGI0MS05NzYwLWNjOWM2MTk0MmYwZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAxOTEwYjAtNWYw\nNS00OWQ3LTg1OTgtMTBjYzMxNGY3MGMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQsZMrYzHduaNlj73ucaCDXSnqvaqaSqliyui447IZV0q5XTVP15pne4Li40G\nsa46yZGgkZD1j51sJjLXwBnExKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH9BtUZQ1QjLIlEGH6o6l6Iw9+dUwHwYDVR0j\nBBgwFoAU6z0lk06YLuk8q0Se6L1T8ZPGuQswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGTshE+6pBDe\n/jRKVy3/UC2z1e5RVWb5o9joDnAv3fTKAiA6CxRGum8dr0ON4Tfs20hPgDZkqCNh\nJBe60b8TH7k9cA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaQDFSkI3n9xRw2AQnrJuojJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjY2MTcwNy02NDU4LTRiNDEtOTc2MC1jYzljNjE5NDJmMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHpyM8LVwFSA79ltp+u9eBhojhz++ep0Yc1Ci08ZBIQFg2\nnYSUFz6nBSlzf8hULbw1hOwhH3eLUQJ1Y8FKiMzUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6z0lk06YLuk8q0Se6L1T8ZPG\nuQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge4RsUisQAs1eWXTNxOLu8L5c7LoxNi+T1h6X4Q8m3rgCIF0DFe6IVbXi\n9KeglOuCSw17IPFMdfNJwG+cZ1w9/YRE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISATU3AeXjY9viR+FweB1gf953MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAxOTEwYjAtNWYwNS00OWQ3LTg1OTgtMTBjYzMxNGY3MGMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjNhNmU4ZjYtNDFjMC00ZTA4LThkMDgtY2I5YTQ4ZmE0\nMGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPZaO7gJn5PtQlMYQvjbnVkRR\nlkoJDLajPke+mlo35dw6KLdLqTiuCIXLFwMtDhe3Cmcq+jl5loqqdVu+x15SwaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH9BtUZQ1QjLIlEGH6o6l6Iw9+dUwCgYIKoZIzj0E\nAwIDSQAwRgIhAPYiGMWxKb8xLIUeP2pMuz+t8fKn1loN9o86d9/zqiqLAiEA4BT0\nh6Hp5AgzLap40WjG5SUNFIcRZefoy/eZnrMyqvU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2223", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2223` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAeV6PgrtrtH+ZJnaZpPtj7fmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjNmM5NDVmLTg1YjktNDkyNi1iZjhhLTQzZWM5NGFhNTMyYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRkZmRlYjAtOWU1\nZC00MGYwLTk3NmEtODlkNzM1M2FhMDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHC0uGOOo0e1XdtiJaw4VGodjc987bnUgsAb4rXfWbdahTpzjL/IJ7YaUgvP9\ngpHR9tfaA2JW0rhDiWf4ovBGuqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCN9j/G1M3zYF41QqWS3Iy4IhyuwwHwYDVR0j\nBBgwFoAUM7eYOT7ewCJqwJtsV1oeWGcjjZ4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCJ13xJuUdX\nD3WZYJKU+gdpCaKcjxTvktvohXEmZFmdagIhAMLRFydxFNIwRJ1fDDmdDWG4TZxY\n9700fGT/Kjx1Zpnm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeK+BJvBQEXZec93h7uQNe9EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzZjOTQ1Zi04NWI5LTQ5MjYtYmY4YS00M2VjOTRhYTUzMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGgClCt63RJLiBRs4jwQmIw+GZQOEJ0k4pX7n8ENYZrOpj\nhztKXglVcKvheTNLnOFsdoFU11pkVuv+npIALYRMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM7eYOT7ewCJqwJtsV1oeWGcj\njZ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALeuNwKyUEfYqQ57Abfwb8rEzqyfYOqPFoGMHxy2Phc1AiB5OGSo8oO/\ntGbmOS5buqjJgXMaublE/uR/++8GTPf86Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAQmnBAu3hNZ7zLBMdUNwtk0gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRkZmRlYjAtOWU1ZC00MGYwLTk3NmEtODlkNzM1M2FhMDg0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNkYzAwMGMtNDdmOC00ODg3LTg0ZTAtZmYxODUwZDQ5\nOGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9Usm9yJ4CgrKazoQg8Xjgy+z\nuCu1LocgCw2jvrnmN3DFuA+2kWBpNL3pLOvPwpFO/ZAmVUDvyCvFHwv085K6naNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCN9j/G1M3zYF41QqWS3Iy4IhyuwwCgYIKoZIzj0E\nAwIDSAAwRQIgX8ojJ+PKMim63vj6bCXBz9wb309HLMovNN4yrYu7+igCIQCP+y9L\nz118pfdzx1y7rTfgkyaROdMhQgSmOfiNW0fT5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2224", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2224` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAfSW8PukBhNAG6OSEHOx/rgnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzZDZmNjIwLTI1OTUtNGYzNC05ZTYyLWZiN2ExN2RmZGYzNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk1ZTU1YTUtZDE4\nNi00OGMxLWFkNDUtZjIzZDliYzAxOTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZGA8s0fgajuvUb4UPWfChxlzZAKzs/NoNOQKHIET/A8+HgFFN4jOugWbQNbU\n3WOdFee+apvAE7VORliLumqJ8KOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3JuZVuEMeIqu2fiL40XEior00TcwHwYDVR0j\nBBgwFoAUCkhZx647kBhf77gEIA8m8k2ly3MwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiApkRoeBUpU\nmbUaCwALKcNvmuJ4MHbYnSByx2CnGFTKtQIgKAmpa2dzmo/jnT6VTzRPU3hhtvF4\nSX/lNzK9Ox6KM/A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcr2ga6WlxYirWlcpuHQKM06MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2Q2ZjYyMC0yNTk1LTRmMzQtOWU2Mi1mYjdhMTdkZmRmMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMvTcQh9urGGkcOm1MXn3vcfMwk7+9W5g3MBFWNiHMbIYp\nLNa9Ds0hQNjIFI84eW0ESB7A+BZszqUFrCPZbmzzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCkhZx647kBhf77gEIA8m8k2l\ny3MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOmiN85fh3rLP87Dd6/lp50nY5NmF5tzWXT2rdh45qerAiBFf9OmSMn9\ndGha0tHkzXwcWcHC3xB2uXBO2X+i5QEkDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISASwoX/2Uwr77MMpYs2KOoFrjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk1ZTU1YTUtZDE4Ni00OGMxLWFkNDUtZjIzZDliYzAxOTNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzczMmJkNGEtMzc2YS00NzI0LWE1ZTEtOWViNmQxYWJk\nN2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQCmaNvA3q1vqFErnQ3uda424\naGD81Tk7XXpyE26wUeZ8oMMkyQ2pYUbVBcFAkr89rloDg4OwIl7uHKncUEPInaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3JuZVuEMeIqu2fiL40XEior00TcwCgYIKoZIzj0E\nAwIDSQAwRgIhAJC0dEqcGP7NCimwUFPn7+a2bIGiqDDNxvDE6WD+Lo//AiEA0XFK\n6hBqcMtflquz7vrS4bt4KgRCECxYow8yE7LK26M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2225", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2225` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAa870eFjehw3UPv+62WTQXt3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0MDNiMTBmLWEyZWEtNDdkYi05YWQ1LTc2M2EzYzQ3MjAzNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdlZTA4MTMtZGQ1\nYi00YjI0LTgwYWYtMzhhMDVlZTFmODMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQjZuraUKbY/cHfGG/md+yUuduu0ESn9X5bJAabtXJ6v7orIrUpZtXnmxXc2i\ncWJH9Ycor2wteEW1dmS7hpiU66OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC5Zn2lg0Sua9FXrCba/vEus0mScwHwYDVR0j\nBBgwFoAUSUtTZozSqygph2zQ7SBEk6ds8ZgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAyjCUUus97dG60VokRJ2TU/+7y5CbkkTTl4pZjv323/QCIF1sQYkm2Svv\n2eQJjd2woSWGJx6RxD5tMvxV0EBTQWKe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXK/8fHelS/HVTuFRis+X+1zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDAzYjEwZi1hMmVhLTQ3ZGItOWFkNS03NjNhM2M0NzIwMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4uMAxC9ieERN0LzjIUn8jTuA54z0pg+CiXF+y1cERTwjU\n13gmHcnnkW9Ki7XcEnqFoLAlhPSIwbZD+ZXKqYm5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSUtTZozSqygph2zQ7SBEk6ds\n8ZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbb47Otu3L58x+wOPTWOvnBksyX4PdLIIaWLVuKV9k/sCIAzUi68FE0QJ\nmSVcdEa8S5ZSmLaVRqI8TrxlveX9j8He\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISASv2Wgwqx0930gwCE1/96up8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdlZTA4MTMtZGQ1Yi00YjI0LTgwYWYtMzhhMDVlZTFmODMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjZhZDM3ZjMtZWFjMi00NTFhLWIzMjktMmNhYWZiYjQ1\nZmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEccqpMXf92PMDqzan+qQQF92M\nhXhcEqA9l9c0j2sPRG/IQK8FcphEP1Xb+GvfMuNaqs2bDBqiyd/+yEp9up38l6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC5Zn2lg0Sua9FXrCba/vEus0mScwCgYIKoZIzj0E\nAwIDSQAwRgIhAN/xnng46fy3I+lio+Ywq0wM2Jq7IkIgq4s3OiOqHZG7AiEAk+Zm\nHWCXcv9Gg1sc2EfraR9E0TmKmB5UdtB+j9FcX2k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2226", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2226` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAd13/OBPg57ixqG4IDDsohaeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkNzE0M2I4LTllYTgtNDM1My04Yzc1LWM3OWI5ZmQ3Y2IwZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlhNjg3NTktNjRj\nZC00NmYxLTkzNDYtYjRmNzc0N2FiM2JjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOcF8e9i3LiRRluRtTvX+Sxh7UXV6tFWe2yD02NLcGASrOMDdKROXpqDt2o43\nwVUpIIWQfxAKaaAfwfTHI2/0SKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHgfURrLtm0q6E4E2xd/QaLtiqhEwHwYDVR0j\nBBgwFoAUAmNxl3hMgcf/HThhJAy07IQz/lYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAsAXKKZXAB+wbeV+UIPLeuXdQaCdQwMgWb+hoqU1cYV0CIBv8VaPJ1uyI\nuXk4V9b7J0E7PvoZAfoGRlV0RNJKd/YW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeFi9dB6U9muSxfO2omSuzeLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDcxNDNiOC05ZWE4LTQzNTMtOGM3NS1jNzliOWZkN2NiMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfjxEGXfENJNahlWxEXKWZuukYn7o04pWnuNHndOIevyai\nsdeQ3Pn0kmvvAiRBPccSlLD7kie050541vn6XQY+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAmNxl3hMgcf/HThhJAy07IQz\n/lYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUKtcPMsRN7aFfZbEqD3V7Dk7w0kJdW2vnkTSwPbSUE8CIGv7XiCvGAbs\nzsbuCJYM5pp6bS8gv720P4WNLiR1gQyD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAbgpMfouTOfuKXZ2sN3uMeB2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlhNjg3NTktNjRjZC00NmYxLTkzNDYtYjRmNzc0N2FiM2JjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjAwY2UyYzktMWVkNi00YzdlLWE2ZTctMjFlYzgwYjNk\nNmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeJwZAqwTK/uvJhz12uRqSwV6\nn5zK1NjXI5PIxu4YV2FdphJdjg6ZiLAmCFZ50tIJrGe2T0xPSxRlhLK0YdSrsaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHgfURrLtm0q6E4E2xd/QaLtiqhEwCgYIKoZIzj0E\nAwIDSQAwRgIhAK5jvGS7JozNFm2OW6NLb7vULMaSXDwhCYjHE2rcp2OzAiEA48Iv\nrVe7YvzZTr4E4R1zC6aCKzjy7WRF6rsD+Qt6KEo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2227", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2227` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAV8gCWp6J4my7tU8uXsxnBihMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzODVjNjliLTRhMGUtNGZjMS05OTAwLTE4ZmUxNzZkYTM1MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ0OTBmYWItZWU3\nNi00ZDAyLWI3OTEtNTA2ZDdiN2ZhM2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDsWZrI6s+0n2Iz543EGsdpXjHPTnhRvk4pM7iqYOq5Vvfs7oMTj2jEmRXPU7\n5SIq5gZ165i+SQZyduXbwaMZN6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNht6pNprxbEyX7NAKRMWeIb/TeAwHwYDVR0j\nBBgwFoAUiIxNevtwD++WTTLJUrR4p5IXH4IwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\nzwkjJW6iR7JhPevYPtv29WdLc5+sFlFy8naUYNpH/roCIQDiBpuYllazBcq4QXNH\n6oZcSQ+Bf+U7og01FFE8I26Uqw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfdHB8vhz0goh95Rrz+ObVhJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzg1YzY5Yi00YTBlLTRmYzEtOTkwMC0xOGZlMTc2ZGEzNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShAkXS0e4V6LesmtSHvhQk2aU81QA441feZuN3DokBJcBU\nVPJe+W0qQVn60Ywi01Cf6HvgLWf5fkg9PTTeMaAko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiIxNevtwD++WTTLJUrR4p5IX\nH4IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPhY/+W6fupTRijgLtZyi8NT+xBBfVPpfHRnT3SrXZ2FAiAMbxA91ppE\nSBHLh/CxaCOCGhrVUscjJ5HbrbDFbSm/Mw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAcifP9S/2YnDOc0I5wBH782RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ0OTBmYWItZWU3Ni00ZDAyLWI3OTEtNTA2ZDdiN2ZhM2U1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDZiNGZkOWQtMmNlOC00ZTFlLThmNGQtZmRmNDg1ZTlj\nMTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjuuXL8DstM0ZZFuw5GwEfLHO\nZpOsPIL1YQfRRzJQTuIBv0YtX7YFwv7rbBq3HxNwC450kFzlq/P/z5fCBCq6rqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNht6pNprxbEyX7NAKRMWeIb/TeAwCgYIKoZIzj0E\nAwIDRwAwRAIgGRz7zAxqaqXR+PlzJm15GBdfthiX/csXG0HOQ0v6bq8CID5VTimC\nZARQXWhTT9uXq7a24TIuWrolSuxXsIoYjGQI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2228", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2228` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAf3dNGcnxQw4+W2lIupgPx7MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNTkyZjdiLTgyZDctNDVjNi05MGQ0LTk5NzNkMDY1NjUwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWIwOTI2NTItZGI5\nYy00ZjNjLTllNTYtNWM4NWYzOTNmNzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc13mjLZ6MlBEK0DecOLMcrDPUKD7BAys09R3dRFtDZQXps87uQvbLxbeotqL\nxZNXNttxn8PEpIDsT97NB2qSuqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmunvzIYGQFILXNE9nl7hQi828dMwHwYDVR0j\nBBgwFoAUrvvZnEhoDZrAUVmhUnILjb347TUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAx5KzMlZXxpRA/0CqgYvjd6cuCamX/6yj5E2T/ftqe1QIgXlxx\nCIjYf5iTiir9XEEhkjjdgAwZfoEXfb+FCo9uIPo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYCGiaK3IUrM20pwcwzPUgd1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjU5MmY3Yi04MmQ3LTQ1YzYtOTBkNC05OTczZDA2NTY1MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiIMHguOvlYjRA8A6FVMnwjB1IXDD+2pI58WeHogLx9Tkj\niFtI5X0e3HA1pJZ44BsoUyZgRBk1gw9QcaaWvungo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrvvZnEhoDZrAUVmhUnILjb34\n7TUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDLkfpYjkdYJYkypAK/uqwyrBghHw2mHt0K0pIzxcnPYCIQDJl7djc0Mm\nY0UO8vnlVLLzU0e6JZIt0HoKPbjgDHxnsw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAQlJKbePbSBFgSYa7GUxs0ptMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWIwOTI2NTItZGI5Yy00ZjNjLTllNTYtNWM4NWYzOTNmNzMxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmZmZTViNGYtMmIwMC00NjI2LTk3ZTMtODRmNTgzMzJj\nYTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIw8qTJf/eztUW3JHdgETLreN\nxnewoIb/9ZY9h10xWpiQJ6IKv6CIkKhzlQwcs/TRp1cSPtWpdA/dWQbN0bRMV6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmunvzIYGQFILXNE9nl7hQi828dMwCgYIKoZIzj0E\nAwIDSAAwRQIgSIHpX6lpbgst2wYIyAjYAQJkkamJ7ojXNnXTpLd9QTgCIQC/ykiI\nNtAq7NLAR8c12HFt4+9wyrEMmnh2rHzxEYpLAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2229", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2229` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAUjeQlLR6rLQLJybC8FQyEZlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwMTliZjE3LWM2MmEtNGY3My04OGIyLWQ5NDhlYmQ3M2RlMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ1MTJlZTktZGZh\nZC00ZmMxLWI3MmItY2FhMDI3NmYxODhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEITd3HcLvxrDEuJ3V+ZG9U202jDCLsgzde5sQYJNhNYKojibOcGNVIviOVYpt\nctams4jgR31rcahqCWSW01wsZ6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU915mK7Kqli0bHPXb7wcNFuNoYJswHwYDVR0j\nBBgwFoAUn+J0gCVvA4cLdhpd1Yi44WCMp1EwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA4AKz/0jO7xZGl/JkutgoJ/ASSr486cavQNhpq0RqK54CIQDQ\nDgWG6962JKhtxHi3HRJnkpKqrSO01PG7MM9CXZYWpg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATfons9M8e39npMMSDxvJWyuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDE5YmYxNy1jNjJhLTRmNzMtODhiMi1kOTQ4ZWJkNzNkZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuLEQ98wDvSG/zByV5cf8qLJ2X1Nv8j/NidZgeK++P65h2\nxncUoDenf8CfanzSCs8huXWMi9/sbBXx89JJtyUUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn+J0gCVvA4cLdhpd1Yi44WCM\np1EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDjoeWDXWee/60G7KPtDIVjkHXvHphly4kQs2FgCpTfkCIQDVl45C3ENU\neySsL3NW+XNBt4SUhN1/2Qte9vZESZCrzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAf//7QyR2uzsJc42yOjhjqJZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ1MTJlZTktZGZhZC00ZmMxLWI3MmItY2FhMDI3NmYxODhjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjcxYTMxZGEtNjdjMS00YjZmLTljY2EtYzNkMWFkMjc0\nNTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXYlLobQYFXU1a2xC582MjRCd\nmiANfNlrrGiWFp5AIn7bTxTazBL3S4bWfeN+CXVlKAVwu6Mv8BInwsDv69djo6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU915mK7Kqli0bHPXb7wcNFuNoYJswCgYIKoZIzj0E\nAwIDSAAwRQIhAMDjUa6dlYF30xnkcms+uRCxd8/jsDluFmEFHz2nmXGRAiBJyXwN\nR0LNYK0MLX8G1VC4y0M7LRCeRlxN2DtgB91tDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2230", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2230` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfdyqktIC4KJbfWKnHIwtWcNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4NmRmNzc1LTUzOTktNGYzOS1iMTg0LWFhMTllNjllYjE2NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTcwODIxZTEtM2Zh\nYS00ZDFlLTk3ZjctNDkxOTYyOTgzZDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyMn8V7hlwsaVy920bg1t5+drlKyuGrdYrL/KL/09AIUJXTAK5BDVV5Y5+M7n\n54svyNiUq8RvYN8m+xhFXd3to6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWazROX2qJM2wMnUky8xtE4tFuPQwHwYDVR0j\nBBgwFoAU2MSew01Qr9tKPGFo60LEUltznaYwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAraK9eIZTRfYo\nJuYqWvN4romnuaNmGBw0nVTAOe1R4NUCIG72fFFBOXeb6crSsnkzly0j4fqX4byl\nHrFIs8Z/+ino\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQv9jTTHz+Q2CuQuyI65RW5bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODZkZjc3NS01Mzk5LTRmMzktYjE4NC1hYTE5ZTY5ZWIxNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAMa5tPx8iC8MqYdQ6T8QQ9sSuyh78YVuVmJ/XHYcNlmxi\nn18e1dOSJzX4PBO0fXDuk4iCSYnf0QiHmSZ36pRRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2MSew01Qr9tKPGFo60LEUltz\nnaYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN4mW3XShDcGkZXXSreOyp+BaAMzUvK+AF40GMFKEmbgCIDNjfNHwdWpD\nnkraIJw2RKQ+vKOrQUuRGcz+xcKRnF1Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAR72+o+eUxnqnYd2DaiKsIvkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTcwODIxZTEtM2ZhYS00ZDFlLTk3ZjctNDkxOTYyOTgzZDY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjIxYWFmZTAtNjU5Ny00MjE1LThhMDYtYTJkYjlmMjli\nNWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEehE3Qbo8uupKGXnrt9ej0EGF\n6PSaljsH2Y84X4Uvd4eR+hM/5MGRfSGnxva17VcpDfnJp3x7ZaaNPmdjCvj1mqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWazROX2qJM2wMnUky8xtE4tFuPQwCgYIKoZIzj0E\nAwIDSAAwRQIgMRQcO6KdZqNjGUq/yXXVDEPlWhmEcKf3DoYYbDZNhmYCIQCvjCch\nGUfnT3E+BbRjv2TKhfoWaUiiJbhzcsuM+p5gwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2231", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2231` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYrnBPZp96spASJdPm4KGSCPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxYjRmNGI3LTMwOGMtNDk0OS1hZWQyLWI3OGM5ZGEyYmQyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjViZGIyNTYtYWRk\nYi00MjdlLTlhYjItODZjZDU2NmY2ZDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+uARMsXsDcQK3zznupLTYsYU0QC+Nrxn9Hur902xxNBNimkEMpGxPzWRh+oi\nQmz7awzCIBg/w4TosVK/cGlQOaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmBV/62WCdY9q+4O6a1d6EYc8MegwHwYDVR0j\nBBgwFoAUuTod9O+H6nKuBJW7Z0X7cpeOAlMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDCvKT53LBKF5wD6TBBhX80SfNr07gEGBihBhHO+Ax5lAiA7dXwQKhyNLcM9\n9zu9/zOfb3i4QD/IQ1aKDWFtmtr6hw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQLKxIJSdd5Cm0cSarMc+VXMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWI0ZjRiNy0zMDhjLTQ5NDktYWVkMi1iNzhjOWRhMmJkMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDVrFRpmxKF+3W/5YqAZnZsCudFXfp7W1lfcvYcH2YHwfC\nO/I4zYxwBPYfVUVe8JLrGfYAEi17E2juOCWM4JDYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuTod9O+H6nKuBJW7Z0X7cpeO\nAlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKqlO4wp/7+n7OY/fbnAZNGmeMKhwn0xt+0DMdhFKTAEAiEA2UzbFW3u\nqFv0FktqOkc+YryrBHXAb5Vm5VBLrhT/+4Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAZfo0dsYff9jX9UtAVnaEVv3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjViZGIyNTYtYWRkYi00MjdlLTlhYjItODZjZDU2NmY2ZDBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk3ZjNiYjctNGFkMC00YjBiLTgxZTMtMTU5YmM4MjUz\nZTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm90G6QU0vhKkxy4DsIkLfVdP\nwkCTPsuCdWgewIqHjzZMJNoIb9222GrfoqNVWTGb7GjRQ6vT7U98nOmCLMcxbaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmBV/62WCdY9q+4O6a1d6EYc8MegwCgYIKoZIzj0E\nAwIDSQAwRgIhAM4tTjSKC4WcWLhzoqnZl0mxccBeD3wPOV5cP4blDnQvAiEA4Tvr\nr30rIa3AWqe3FH3KKEP5LT3DbQBCb6dUv4K+2xk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2232", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2232` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeqsKiNy9UFSFophy0m2lFuwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ZjYxMmY2LWYzNmItNDlhNy04OTFjLTgwZTMwOWRmMjA4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY4NWNiMWYtNGNm\nMS00Njk1LWJjM2QtNjQ2MTljYTg5M2Y0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOgX77c83BIfFgZnia0G7VbeEuk9xemYdCl226jZOWHHoCpxsrMFaBuXDXimp\njuJBTqbejLb2blbbh5CV6wygdaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAaSQXeOVjqb67jFhm8nVzCb4uMwwHwYDVR0j\nBBgwFoAU6zkPAlzTkC0IKUL8NoTr+PZVMowwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAreHqvqH9xFAg8hzcOMNwbz8BpwsWMEvNr5/5wQeWOrAiAZ19rlVt40Zp6P\nvf9wMHfmPgOMw6dK3gF7ZKf/PgjRGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYxMCJHjM4nIXhZybPMJwIPoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2Y2MTJmNi1mMzZiLTQ5YTctODkxYy04MGUzMDlkZjIwODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTsrAIFiHgtybiR1Xo3CgIYUSI4mkaouBfXyyGwDfEppfV\nS6B0bk/X/dIuNL+gwJ5Y/llHXwFZjjONVYLGO5xyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6zkPAlzTkC0IKUL8NoTr+PZV\nMowwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPA+VYd1oqe6lvDODXKyzCAbAX8MVyYDsaHCvmsciSSqAiEAyPKidN25\nC78pW0AC4o4vnhFw4fin7Ijq+iA872gz7tQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZ/T4vjZOutMjv3uOg/or6EuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY4NWNiMWYtNGNmMS00Njk1LWJjM2QtNjQ2MTljYTg5M2Y0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjkzZDdmYTgtNjdmNS00YmU4LThkNjYtMzY2MmRkMjk0\nNzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERWt1OWC9licu3HDvGoFw5UAY\nruX+F905JaLmXHVuUtbRSLUH8dbpiLXjSQRAX05eZmtNcT5Wb2tKcoIH0HqptKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAaSQXeOVjqb67jFhm8nVzCb4uMwwCgYIKoZIzj0E\nAwIDSAAwRQIhAKBVQ2Q1CJ+Ldt3JSU0lIq2aGXwqbqxFaqUsZeV++uChAiBX6hXS\nhRUesjU0hVCex9rwE0O6pbVD88VkwAoLj4Yirw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2233", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2233` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQbjlN5JHbAW8KrZYyN3WU70MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZmNlMzlhLTFiZTMtNDI2My04MWQ0LWZmMjYzZDBiN2VjNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMzOGEwY2MtMzFh\nZi00ZDQ4LTk3NTUtNDBmNzMyNTU4YWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjMkr8+QZJ3xd3rKgfMvw1NK/wJVu3KZ9iR7/vZiJk+qe3CXYvCdX2V7fN+Rj\nqY82iHTKZIOeC4l08jt2vFI7FaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT464tZK501iNfDZXmtCaokvtFaQwHwYDVR0j\nBBgwFoAUflHpDInyTMXbd2HRr6HPJKGgJtgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAqghjNnnBN2OyW+r4WCZ9kpkWYvH31QA7pa9gplgrqFICIBzBacm3rKwA\nG0Slz4swhNSJpUol9MrAuIu2+RZj6KS8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQx/fCLH/j02hW1H/PO4Bh34MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2ZjZTM5YS0xYmUzLTQyNjMtODFkNC1mZjI2M2QwYjdlYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEICUoowJDQ8cMddpdr2blNoMALMODUUjG1srZvdh0rPTH\nrzdh+VAuAqmDscsVmznfAhzB7+QLPhli3mWQsb6ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUflHpDInyTMXbd2HRr6HPJKGg\nJtgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANt2krZP5m5E75H3Uq2RTwDu3UVRMo4rMks7JZXC8ZeIAiBUPQXt0oKE\nJDa6hGSsoc82wsStx2A0Z9aMneejZL8GUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAXnUOJvGlygU1LeMLt22n/5BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMzOGEwY2MtMzFhZi00ZDQ4LTk3NTUtNDBmNzMyNTU4YWExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQ3MjM2N2ItNjFkMS00ODRkLTk2ZWQtZTU3YjhhNjQ0\nZjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE7FUKuF2JS7IKG4zVrQUPkbJ\nvmChQJGqZK2bREWEauAYbegIgGjDSc8lFO2ZgtdHFuFv1vjKfwfzzIbAFzyjjKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT464tZK501iNfDZXmtCaokvtFaQwCgYIKoZIzj0E\nAwIDRwAwRAIgI9Y9Zu47d6hvwArlWQbn+NjF2Ev+xtqc2dQoAAYd9mkCIEJX57pW\nPMMwGZrR57Wj7ms33LdEqlf3Fove/6xX23XG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2234", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2234` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAX3tHKMOXosLzWqajjTUE/JlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4MjE2ZDhjLWUwM2EtNDQ0OC04ODBhLTE4MWMyMWQyZDM1NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY1NWY0YTYtZjZi\nMC00MDVlLTk1Y2MtMGMzMGE5ZjA1YjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiUjqcrTApnzk5Q3upQnQ4BwfQsoFX1BKFvYKhsajNmojn/dFd7eG2B67Zjs/\nPQWuNaFnZ5BlBLKLkq1oTWI+PKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhLwjh7RNtGT3j799EjF3W9L+s10wHwYDVR0j\nBBgwFoAUenLgeMAUbwoN/X44Kp4l7jeESGcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAlHYlZOlwvEXPQdZR3AYaOxWJFvEQ5sSyV/gw4bsv\n0VoCIEHuWwEHrsEPpzvO80T+5JjngiFfTZO1y0q0hbw2O7yV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbIEQEOlFMqGd1X3/Zh2p42kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODIxNmQ4Yy1lMDNhLTQ0NDgtODgwYS0xODFjMjFkMmQzNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYRi+0QT+PvnZfZCCzu//T28+L33Z0+j9BNXBVQKvR+TR5\nSifAIhUpnaq9n/hol/kpTlq7x1+EPV9lL7tpJJ17o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUenLgeMAUbwoN/X44Kp4l7jeE\nSGcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPIGHh3t5NMOKXdOyGLJ0KQjs34Tz+75yvUmnpd+/va5AiEAx/PKnGJR\nD/gV2G2O99sUxy/Zrx47AKaapO5LgQf3Gys=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAcIFmCJBin4+7du/Jlh81qmDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY1NWY0YTYtZjZiMC00MDVlLTk1Y2MtMGMzMGE5ZjA1YjdiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTE0NGIyODYtYWMyZi00MDM3LThiN2QtYjkzYTg2NjAy\nMTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQxMgcIdBrvBRpoMD5NfNmXwY\nqSvLDSeTemxDbLEXIUHHhQ2dhAYYmxv7oIsDpWk80Ymq1uZkCj9gMviJaDKQOaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhLwjh7RNtGT3j799EjF3W9L+s10wCgYIKoZIzj0E\nAwIDRwAwRAIgLf7S3/06ZUV7LnKlBmnTlEuqHOjIWISk8cGH2s1PbrUCIEFBuTcc\n9DIJQQ5obgLj+ql8BgCHbe3aMy8RQihqAVHm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2235", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2235` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAamvx3cyJBj5r/G9w04tF5fuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxMjFmNDE3LWI0MGMtNDY1My04OGUzLWNjYjFiM2MxMmIyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjViY2EyN2UtNWJl\nYS00ODAzLWFiMWEtY2JiNjI5ZGExNWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5l0EVFul5fuUkkd1LfCUHEFxtL/w0cD6eDArFsfoWnK3cktdL/Py+c2QpUqd\ncwigW4lqEj+lOIQMYzOjgLodhqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt16RoX9awzL7sfihs2BIltS4sIgwHwYDVR0j\nBBgwFoAUiC7gjzBZZ2rmK3tubjwoTDnrqIQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA4xR6DJ5DIyF+Hl62tvJtKVS1M5/pHoI8xi3tNN0v\n0fYCIFm2sazuUGY8t3Z3nFYx2N32/qJg9OTXz88jpU3pKbEB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARpbDFftON03yhqTOka3vfGuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTIxZjQxNy1iNDBjLTQ2NTMtODhlMy1jY2IxYjNjMTJiMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9jkDmg3LFyaaivB9HJhV5iUHxWu3g7AuasmdsugKV50RG\nAoQWy8JNy+0sbuun2W9K1o8rBXyxqGR/outM5rDHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiC7gjzBZZ2rmK3tubjwoTDnr\nqIQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHPZKqt/1bRAcTqLnGq/OizdxIOe/dg0ldioR+6CStU4CIQCVqH8l+KmA\nQHCkdzupSxFerFZoaPZ9Wqc9YrVckg/lDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAV3d482u4+SvAFyp1YybkQCLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjViY2EyN2UtNWJlYS00ODAzLWFiMWEtY2JiNjI5ZGExNWVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmM4ZDhlYTktY2Q0NS00ZjM5LWIzM2EtYTA1ZWIxZWFm\nMGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoKTrWVOceLtdIBbraYHBtoWV\n7Yex9Clnj+0TcsaIkxKvR2/pJjxOdYixNtb5hAil4LGiHtOf96+rbeMnJk2MC6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUt16RoX9awzL7sfihs2BIltS4sIgwCgYIKoZIzj0E\nAwIDRwAwRAIgdUwt78rDYJel2d8xxlJe/4gRmlbIk2gScMqef/FTxZUCIF89zl3y\nQVrrxdiklmbBh+X0jBtkDPTErg58U2vhf2Qq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2236", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2236` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAbjGhmN5M1vqmdSOy5lp465xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMDRhOWIwLTNiMmYtNDFhNy05NjRkLTA2NmM4ZmIwOWJjMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMzNjExNWYtNjJk\nNi00NzI3LTkyZDYtYWFjZWE4MzcwM2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1p5/Nu/O3O5EeKx97nwFnW7cTt4g+9jakK0t4MEo/Waia3hFrdeyVEc04KZv\ndkOqIztUirx311DyVNTWUjr55qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiGTh7KDB/nf7PxOTymQrq4ciVF8wHwYDVR0j\nBBgwFoAU6HrJBXTdkSsUgsLgibmGMr6/Z4AwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA7pJIYIXuSSurGVZ7K7BrNt5FP66Fxblj+RKZQ2Xhem0CIQCU\n/WpkepWJ1L4gc2iYLv4noWWCXnpJ+OzSqIrQWkbyRw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUaqF0sVBksUziG08XWNAstjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzA0YTliMC0zYjJmLTQxYTctOTY0ZC0wNjZjOGZiMDliYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQS+aLoxs9KAZrqXh5KV4pYdOYL5LMNMpAGYRYT580wEMTR\nsRLFjnxFPkKTXy3qyzLzo4hQGESFV3zaqatQ96tjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6HrJBXTdkSsUgsLgibmGMr6/\nZ4AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAImku1dXlipRauFjsEIdh4YRm1w22H8Dnqh1XnAYYMiaAiEApoEPvLzl\nxTp08fNL/NSJTIU7VsG1N/4iLmje8GOwSQY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAeeVDLKjWLAlM6/doUOELdpdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMzNjExNWYtNjJkNi00NzI3LTkyZDYtYWFjZWE4MzcwM2YzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjRmYjBlMjAtYTliOS00YmNkLWEyYWMtYTA3MGEwZWY5\nNzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6+rK3zY0lyL7SlZrZRlhdMgW\n43WuQP/bvlwmL4awZacYUdw0U0iK3wZ4XvX7cmyUv0Nj/gLuGDhi28shGFvmvqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiGTh7KDB/nf7PxOTymQrq4ciVF8wCgYIKoZIzj0E\nAwIDSAAwRQIhAOFVW/JErPAUXtCRUXTO59dr03Z42jnopN2ive9pNyKNAiBJQT1x\n9+/UIUqE5l1xVziI1v2LndYKeHf+B3F8SreBbA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2237", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2237` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAat9CS6AFz/jqwu4GyududROMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkMDNjNDQ1LTYxNmMtNDFkMi1iZDFmLTIyMGUzNmFkNDNjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2JiMGI2NDItOTM3\nYi00MmE1LTk0ODctYWViOWQyOGQ5YmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdzplhIEv7BHARDbIbDG8NhSlBHp+mcmfTwZrcgREmdkRvWfNTEwTKbcnT8/h\nnZC6hAYHBUtTt25Xg/hQ9j5uAqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlBTTpNWVbkcBPb1uEcPPL9AGiNswHwYDVR0j\nBBgwFoAU8ag/j4l0N13osSbtxo9cF0cYMdQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAA1eV1rzpWX/Q8IWUG+YpAL6Z1Scaezn9P\nVmRuugDu6gIhANawtb09lomiv4LHI1ExXCzx6kiwaPXGvw5bKK47n1nX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUtOxvuvt35RlI4RHRSa4t7GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDAzYzQ0NS02MTZjLTQxZDItYmQxZi0yMjBlMzZhZDQzYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATD/hPXYPFKFjQQElYZU01nlgKDUP9h+KHPjhDi1pXhenU8\nqTkZHEw9U/lNBgJB69oE1urr7bvZh5RLWJH5q4hyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8ag/j4l0N13osSbtxo9cF0cY\nMdQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIJhoSDsJ0zODaQT1O2B4S4xtEcnAngSCCq4zxkFz63ACIQDGyfWX9dha\nJuDtDKnsmo7EJDL/7gFvnw9Hg6WK0z1xag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAVS6i/oHVkn0wu0r0CJnV72jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2JiMGI2NDItOTM3Yi00MmE1LTk0ODctYWViOWQyOGQ5YmQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzM3YTU1YzktNWM5Zi00MDNkLWI1ZDMtYWZkODYyMGRl\nM2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENJOKUtbbNMsLQJXioFi96hpF\n7LpYZVMdyscHzmqJb4rzJ+uwV8mu+BowU7XmgdKLIUIwZvOmgIEAPAZjm+DSs6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlBTTpNWVbkcBPb1uEcPPL9AGiNswCgYIKoZIzj0E\nAwIDSAAwRQIgAdL1jUbtXsR3g/gAOzCdp4sB1JrLwVRfBWz9EGa6ZQgCIQCm2Fid\nLeOh5PEiOi4lznOKMPHEpV+5Gpbnb+FlpVxPtw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2238", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2238` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISASgxdM0nQdcPfroVstQl4GSIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkNDRhZTllLWU4YWItNDE0ZS04YWI4LTkwMjU1Zjk4ZmNkYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJjMWIxZDEtOGNl\nMC00MTQzLWFlN2MtNTM0YTA3Y2Y0NTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3WTH6SNGtS3uSl+88NXqgt5j51z7lTHgNzg1mJ11N4QBy5xgO8u4HJ6BzkYE\ncaNW6Uqd+txYe5ekY84+mqCDJqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0309KW34FoQWKSaHVraHsZ7LvPowHwYDVR0j\nBBgwFoAU5fmXjNOdoCMuLQs/Jur3xUxCmekwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBTKxPMle5GzGor26jFrfB5U1TDxprOHl4J\nnKdS7bBSiQIgRq0iv3waiaGMMhCjwO3SIm44+gNTPFpFoRlsVKnI6SU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAft+Dp58E5oqW3pbXHjteGgrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDQ0YWU5ZS1lOGFiLTQxNGUtOGFiOC05MDI1NWY5OGZjZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKstSJzdk5rGBskBzcLhEiZTMWfBlVzBO3XR6xJ5iVcUhu\n1rS4xlhvhUAxgQyKXjA24alUoINdSzthAhDcBLqso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5fmXjNOdoCMuLQs/Jur3xUxC\nmekwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM0Um/5RpfBLCeQUHHSb3quxXNlZsPoiMhoBotbWwfkQCICnOEGTSXKb/\no3p9Ei5lh15lA5PD22QQsfL5r+fHSLJb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAaHxEuCmYYk+qUTSAIDwab0XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJjMWIxZDEtOGNlMC00MTQzLWFlN2MtNTM0YTA3Y2Y0NTE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzk2Y2M3ZjUtMTk1ZC00YzgyLThkMTMtMmIwNGE4Y2Qz\nY2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB04c5xjYNzJOkFF0MKNU/pHd\nvXd0emcahkO4eaBBQcokFBvQKa2ULq4D7jj6V4DnotFQcM5vcK8Onkb3fnQA9KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0309KW34FoQWKSaHVraHsZ7LvPowCgYIKoZIzj0E\nAwIDSQAwRgIhAL/eVO86yvvsejjXvfM3499KEKJq6CbDFpqv+L7LmGqAAiEA0C8i\nDzl+plXk/5SF0OOq4jBylOLkVBrd7smfeYgIqYM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2239", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2239` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAZos90v+5Cq83MDGKqCDOhFVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjZGFmNzg2LTQ2ZGEtNDQ3NC1iOWI2LTBiZmZjZWU5OTVmNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNmZjUyZjUtMjdj\nYS00YzRlLTljNTgtNDQyZTNmNjQ0YjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETlKCmUSBmNTS+GPF4LBlFV6zE3w7hJYLSEKfMujBmz09rDGXCDDKmhp1dglt\nxv0Vfw+SZkkEbht9lJdO4PEBQKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoq66mcoiDYeQUj4eQJNi+GMAPLQwHwYDVR0j\nBBgwFoAUkgsAJSwg23NY6gRLn3JVu5COglUwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiB9ETRfvHTs7umE\nQNohKo8JchSHQFKNsY6JsTy9pRjQqgIgObOwoq4zOZoHJKDOqh63WqMG3zLs2B0O\nlVRsv32Jalk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcK9HU0966CCPtOcxPEqXWu5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2RhZjc4Ni00NmRhLTQ0NzQtYjliNi0wYmZmY2VlOTk1ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyjzblAaWinkXd4kzL7cEyonoaAS5YSz/eWAgMyjS6/5Wd\ntpqjfoqqTHPCz3A9VpO4SQ9sF9eKElgxFIvk9hf8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkgsAJSwg23NY6gRLn3JVu5CO\nglUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgT4pH8IrldJnZrWmFHRpDHGOz2YtEAmBEnqKmDP1gjA8CIQCvkYnorf0i\nH86blhxQ0qb4zO8ONUCs40jU7KmPLEGJ6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAU7+TiPQqN0b1DexIe0hnIV5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNmZjUyZjUtMjdjYS00YzRlLTljNTgtNDQyZTNmNjQ0YjRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWE0M2RlZjMtMzE5Yi00MmNlLThjMTUtYjE0NzBjY2Zl\nNGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOvJx60CtGmRvsLP2vDUSy+bM\nyGzeKWm52AGEInEMwp0aDvfHR/aTBh0RiYmH45yi3nufU3b69sWVVljajXphFqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoq66mcoiDYeQUj4eQJNi+GMAPLQwCgYIKoZIzj0E\nAwIDSAAwRQIgVwS1VKuobWul08lWsuCAl2HH9vzTvEkvtd90eEOV0vYCIQD0eBHL\nHqTmcAiNBaO3S1GkUaHFT1LjjCBDKhwDzbXbhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2240", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2240` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVdjeEAPWXHuOeU42yJ/fVJ2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMzY5MWU3LTMwOGYtNDdlZi1hN2Q3LTEzNThlNGQ4NzEzMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBlMmQ4NjYtNWVh\nZi00M2Q5LWJlYjYtNWJhODI3NGZlNTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Fl4RYBUjUt0isxK2dDlouuc5lYLgCfQX3tW71jlS4I0G4Hu3LAsypbRO0Jk\ncNaCvjNTW1TI4+uwuZrV0u9StKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcQu+SildD1cm5IUEaNNlgPryA1MwHwYDVR0j\nBBgwFoAUcgkm61Qn4j4iKX9oXbCghclzyaowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHrW93tMQx63SxO6U5aUGT9oBABYKcW9idfdVF/hGggvAiAIW/xPckEYGtir\nPbjzonUCVwzkf6kCn+BKZhORbNTmGA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9MKtikmaex9fzbp6Wc2ycNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzM2OTFlNy0zMDhmLTQ3ZWYtYTdkNy0xMzU4ZTRkODcxMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW4+mqqqTPkUQZWXoQnQZk24Le9bwWaRdXVBskvYjqHjmr\ne3XgytmNN6ytGXa4teNSSj3nY8rJ1wCdHtrGCxfWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcgkm61Qn4j4iKX9oXbCghclz\nyaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKsZ3Afa4sZauCwaIFq9KwtqzxFBktDw98r/VihS89OrAiBPH+lZj5Do\nsPOY7NOHBCG7XUD4zKl3QWQQQ3QKpPuWTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAa8S65YtP5H/HDu8gmz/kj7nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBlMmQ4NjYtNWVhZi00M2Q5LWJlYjYtNWJhODI3NGZlNTdiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODg4ODg5MzQtZjNiOS00NDUxLWEzNDEtYzk2ZmI3YmNm\nNDc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYt8O++yvMUXOo9yYzoLj4im3\n8tfvaTL3cHfvjfHi1ShSKBjqnIbIjpMW1kqvb3JEqeAlu8KCYYcL1BWReq9fRKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcQu+SildD1cm5IUEaNNlgPryA1MwCgYIKoZIzj0E\nAwIDSAAwRQIgZmcsxnB+QeC6xNwg9v9GBQNF/eqdkFgKvXOSXos+XNoCIQClE3L0\nEplLvBFHlZD8Eacsg9Zc6knXqQlVqAgWWJ9Ikw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2241", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2241` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAd1G4AEvwiRf6GnaOLaOwXOuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlYzFmMGY5LWU2MjctNGMwZC1hNzJiLWI2ZWNlYTI5ZWIzNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI3YjlmYWUtOTc2\nMS00ZjU2LWEyMWUtNjY0MzJkYmQwYjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELPf4Xk3wBskMZS6XZlF0t6GT5W98gibrOMVKrMnL3QBWda+FJJxU0mmFLFyM\npxaSXmjXWowWjyIcC71v50TRzKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh9JZ3fIbzQLLIt/lLimrdktACO0wHwYDVR0j\nBBgwFoAUIuY17vKQdyLSHJ8v4ozgKRJc3BMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICUMYNUafsgE9GrbsVgu+GP8sdZR1cKwg3vtG7LlVUZEAiAx6QACOtdWBjqQ\nOMFloj1eSWI2QkXvbHfSox6WL+GfRg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfGMRCMJznQ40RXZI2nZVmiAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWMxZjBmOS1lNjI3LTRjMGQtYTcyYi1iNmVjZWEyOWViMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNdbD4dHxNB30eE4KDr8xZOG/AV9gu6zEklSi5s/bpnImp\n+YgQi/PMKkvbfRIw3bkmNoRuknYtDcMrksgdcWRro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIuY17vKQdyLSHJ8v4ozgKRJc\n3BMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALOi0HFjXv6aPlAIixJWeo8bz6gEBYwo6Q+Zn5tYhZz+AiEAtAsi2qzK\nmJi9MRPQ4tyrAeljrYQ9Qg6vZa2da6oROg4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAT1nH7yzDVsDbK6peK8/TURgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI3YjlmYWUtOTc2MS00ZjU2LWEyMWUtNjY0MzJkYmQwYjljMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWZiMmU1OWYtOWFjOC00YjBiLThiYjItMTU1MjI0MjQ0\nZTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyOUU7dnOBwR4EQ5YYtA/9OYI\nR/ezGXKflmpWsDHncK5ipgSO1G6xSale2Yihxc0GcC2FzsybwbXL69UgArMVjaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh9JZ3fIbzQLLIt/lLimrdktACO0wCgYIKoZIzj0E\nAwIDSAAwRQIgC3zmLzhbLCNItp0+S9CK8nGSlIms5T8lHCiwOBpI2YICIQCKH4U/\nSLaK02HtVSo7J1RVerYRP332nyhh51VajMaX6A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2242", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2242` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAU1QcXBqp+0tOe3uh1sfjO1jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmYjMwNzgxLWY3OTMtNDU2YS1hYThhLWYyNjEzNTc0MjYwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgwOThiODYtMzU0\nYi00MzZmLWIxYjEtM2QwODZmZmUxMjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn9S7jnMlp7oWFey+tSAJi/mwTYBQR83fPCV0bZ/aTIc5SYAp/jXKEgLFXkuc\nGtBMbJo3sxUJZc6rxTgi5N/VqqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUigAv6EvV9CbuWcT4IEsG7DqQqCAwHwYDVR0j\nBBgwFoAUm4oixlXbZNKjqlTdS6FGzpdDQ88wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAyps/tDwtCDoMr7mqk2riGIyi+2sDfwP2yT909fse9cwCIQCrefbw3pGG\n/O23MwXodMO6TWCuVDm17X5WN4GdpcqFfA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT5fkhWiabNZvDye15fP0oAsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmIzMDc4MS1mNzkzLTQ1NmEtYWE4YS1mMjYxMzU3NDI2MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmVWJXZdd7QLznuTnQ1FoXVmBUTEhF+NkoQGtaDUFg4uSi\nNOqWtpdnr8dw/Bb9X3Xy3AKQmHj6DR/rKgQ2rSrJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm4oixlXbZNKjqlTdS6FGzpdD\nQ88wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN/y9FzSSFgjFqzpnTFFde6Q/Qg2Y0KdhEi+tuFg6HK4AiEAv7YwKhka\nDuicJ8siYSUiEq0co8+2gzKWp/8wSQZ/KUQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISARXiTIl2Bvm0OJrjqDu5lGmAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgwOThiODYtMzU0Yi00MzZmLWIxYjEtM2QwODZmZmUxMjFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2NhZjRkZGItMmUyNC00M2U5LWIxYmYtOThhM2JmODJj\nZGJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmsFOAg5IU1f+jHLv+fdDHn2Y\nc6fZu6WGNcis9zq7eVgyWt6OXkowJXbfnLz23aiWxMZX2/EpAxvcrs0FfWytuKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUigAv6EvV9CbuWcT4IEsG7DqQqCAwCgYIKoZIzj0E\nAwIDSQAwRgIhANxq0mxz3h4VzeFYjrVNKBowdmSmYUwvgtZ0BxV4G48tAiEAxcLP\n/a2qd3hotwd12XeTE272IDkZaAKu/EluuVJNkpE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2243", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2243` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISATQmiPrhM94HwYDI2XA2UHDfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkZDI5MjEzLWM2ZmUtNDMwMi1iNjRkLWNkYzhiYWJhZjNhNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg0ZDg3NjYtYjc5\nYS00MWE3LWIyMzAtNTllYjU4NmFjZWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPBReyoTlpW2dBVPABsaFv2QiNFdK7ZkUJZO0eLc9S9F4YgjAYCvzok1+oL/z\n9wBFLilFvE9eJAbW6H+DWM2+5aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwZI5MU4CIgXmReWr9PFQLES50/MwHwYDVR0j\nBBgwFoAUaPvNZISIgHtWKHbIh1E/awzjpf0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAqKBhc6Ac6CjqRIuKQmL1cv3nyIikGE1w+Q722H95\nYZMCIQDrR/WiZrpGRnpZPDBEKw+yf5r4LjiaoDlluWCvV5Q7PA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASCpyfdZHlqXMmyRM5nDwHYfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGQyOTIxMy1jNmZlLTQzMDItYjY0ZC1jZGM4YmFiYWYzYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBsJDTcFGGzvNkHxIm1VTDS5TugY7v/8OLPmNluxLAWp0r\nd7E7Mw7WUYsE9wVYCbaIHT6turvKr10qbEkH2c1lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaPvNZISIgHtWKHbIh1E/awzj\npf0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAYQAQBnTMuTWuohB/pChUHMb/ejk/iL1K6xtBj/xh4MCIQC7iNQwguJC\nCLj8w1uk0tzTZ/JeXAfoWO8vOia+B7Zw/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAQUN95cYMUXZbQK0atWpfNdJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg0ZDg3NjYtYjc5YS00MWE3LWIyMzAtNTllYjU4NmFjZWJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzRlMDZlYjAtNmU1ZC00OTZlLWI3YjYtYmU5YTAwOWYz\nMmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETN2/E04V7CqOYOjw9/YTuIJp\nBvFYGIgvpYJBTLxxKV9/3xr6c81bAeTlCSLgVWSHcmFmYOlLX64YFxrEfkF/mqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwZI5MU4CIgXmReWr9PFQLES50/MwCgYIKoZIzj0E\nAwIDSAAwRQIgY/HTHDcrp9XMA6tlwyL6D3BcqfuXEbRtNrXTzUk465ICIQDkDrot\nXoL+adVIvrpCX9MjCrZ7xQujqbQiFkLddC2xqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2244", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2244` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAa2teblRb+K+GHugw36tTvzmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NWJkNDY3LTk2YzktNGVjZC1hYzg4LTE2NzMzYzI2YTYzNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU5YzdlMTUtOWE3\nNi00ZTJiLWJhMWMtNGRkYTkzOGY3NTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXcAF5J40OFb80mbwOokufD6/+3YIPWGY7bYAJEdsBkMocStKYlcw9Aith6fh\nU6xojnes6UoDiosLlXXimrEUMKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP/QbVAieeKU5lJ/hn0yJDSc/SIAwHwYDVR0j\nBBgwFoAUbOQ6sj7AV+e4oc6KMYC/Gvk6CfwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiB/eY0MNwrn/c8zPWsBvYiu2ffP7lyqygQVWhvNmi8V\nBgIhAI/CsiOmU1TaR+yBBcT9coRIuIfdxk0bhOPTo0JPNaxq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeiEnX8HpChoa1cqn7tkqAogMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjViZDQ2Ny05NmM5LTRlY2QtYWM4OC0xNjczM2MyNmE2MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIAUhMod6gxQq9KxZOuesG+4WQsrGHUXJa4c7IrdCk/UVR\n+sWme1dlEHYjjQjntPRYeuRblJdx0C4k98JM5CnYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbOQ6sj7AV+e4oc6KMYC/Gvk6\nCfwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPFiSyqZG/d695/n/Pb2kr9xDtrlyUWbioFucWekyoaxAiBiFgtYYYat\nFxMhzXRn+5Foej8uGTW+OgPn/S23uytVUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAQ19fpdmFojtJQVT1kPdJxsyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU5YzdlMTUtOWE3Ni00ZTJiLWJhMWMtNGRkYTkzOGY3NTY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjgzZmEwYWUtYzQ1NS00MGRlLWE4MDAtNDczNjA0YWQ0\nN2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoWyRkxI/VFOinAtzR8vJPgHm\nRN89iWtzr6uZo/qQngMHAezVcrbNRBPveM5oONCt6GMtw7svkuXOBahMOFLFyqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUP/QbVAieeKU5lJ/hn0yJDSc/SIAwCgYIKoZIzj0E\nAwIDSAAwRQIgMekGezTBFKjKgkCLAx3iAdj7k4Ty3xvROih2INyF1kMCIQDDVqUg\nGVXYgaiTvpg0cOXiLEa0VjD7E3kmtuBYdrKJvA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2245", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2245` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAaw3QIFvKKBxgw+F+fa+/r6/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiYWViZDBlLTc4ZDMtNDNlYy04NmM2LWJhNGY2ZjZjZWNlMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE0MzJiZTAtNzVk\nOS00YmEwLThhZTMtYWI5YTQ3YjIxYWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFXwREqW5W2yametkF/ArYvOZBeCFDFNy2TjLOsQYPJHE7qAZ+AziAIp66ZQI\nW54Y6tO8MdGiTAlrJ3Ug7GonmqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbdt98DAs1n2zekho4CWBH81hZkIwHwYDVR0j\nBBgwFoAUCeZ1Os7+BH1RoKnoDNTt+v2yq8QwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAyNSxnYIuXhoJHE4xamWdO8bOyl7TR8ycll1A+S8gfC0CIQCK\n9r8PyWTSZGyv5bVwImtoE+Fgij1tBwlyxsI+uQjfdQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfCOiSkb1KbODYoenrnDjJ+9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmFlYmQwZS03OGQzLTQzZWMtODZjNi1iYTRmNmY2Y2VjZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCwsZQgzxl451NTfFQKjDj2izaAQ1unlRluW+v+Aa13GMv\n1LbroVXFZGucsj7MmcN1M0FeFTab6xf8BZBHRA5Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCeZ1Os7+BH1RoKnoDNTt+v2y\nq8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTfd7Cq/5QqZZVpT9nxsJRe7stPwZkG5VIL36AlPE5xoCIChioM7VuvDj\n5C7THhBHXA7py6ik4Jnd52KyzrIz/fzB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAeFQGZFn4CenKUXWyb/gHihIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE0MzJiZTAtNzVkOS00YmEwLThhZTMtYWI5YTQ3YjIxYWY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjg1ZmQ0ODctNmFjZi00NWMzLTlkNGItNWU4YjFkNmRj\nYjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfIeUVVCq+YUvtU0ln6KKUR7k\n8vwN5OK5Cgi+quSlO14/9bzZ8cNFTSetVvITd1Xa0a3g+OBM4EewZtL/kjkRJ6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbdt98DAs1n2zekho4CWBH81hZkIwCgYIKoZIzj0E\nAwIDRwAwRAIgK6UaOMGqtQ+q0pUVvxHE/+8VE5Z8GDScY4pifMG2ftMCIGItePIA\nGDjovf9Uohg39tXgXsexM9llRhAP+K3/p0+5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2246", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2246` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAahmZ6TH3t0sSCwFct3HwKdKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2NDE3ZjkyLWNiMzUtNDBjNS05NTIxLWI5Yjc4ODc3OTMwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNjMWE0ODAtNTkx\nNS00Y2I4LWFiMmMtOTcyMDY4Y2VkMjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs+hMri6u9l8rwJnYjqgWB7RRVgs7SwisXH7TXItf0GEvHPKwCDn5P5UhD/6n\nxnjvEgMC3D7C6sTVzCtUDeoRD6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx98DvI7Vi0TX4qHqa38WgBWK8GswHwYDVR0j\nBBgwFoAU+iT0CuXzyuP3bo+cIm/OrecVwqQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAyceATkZpOcKQl9ie0WKfx7Ih2qwiJnC3\nkoH3P/TzrosCIQDBw24Yl2XpXKPM8XDJ7FAYik1mjTyUKPgo8zUOndL5Gw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWT3X2fi7VmEirHPZmGnCY2aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjQxN2Y5Mi1jYjM1LTQwYzUtOTUyMS1iOWI3ODg3NzkzMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWvoOtRzghl9riZQBacwC3L//KuvknqWTHkVOhLPjVXfU/\n1ufj8gfwJ7fUnNjboweeUlg1u1gPw3k9LYDDM6Zyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+iT0CuXzyuP3bo+cIm/OrecV\nwqQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd8jtv1dgrNjmeOgPrgjx74PiZ8ecxy+V9zTOlSpf6kUCIFz2yoDi75bc\nqy5+V+RtCw5YQDfTBx94f9z7NREdrlfe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAcsjCbBpUVp9O+nKqOf7JY7AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNjMWE0ODAtNTkxNS00Y2I4LWFiMmMtOTcyMDY4Y2VkMjBlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2JiYmIyMTUtMTAxMi00NWJhLThlNTctYmM5ZmYzN2Ez\nZDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEO7l3nUZht/ZfLIngV19DzjTl\nJzkzzPuMsf2Ohelz7slpnHw3Z/IEXtHfcSgcpEdMZGKDRNjJPW5/C/mWj7YGuqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUx98DvI7Vi0TX4qHqa38WgBWK8GswCgYIKoZIzj0E\nAwIDSQAwRgIhAMmTmF8pnUfN/gfcFfuQX5R8G5xuIPxUKqUP9QlZHoT5AiEApYXk\n4U3wTZqiFXU3HWUes0xuDnVz/B8DY+PDWAXPQ2k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2247", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2247` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAcl+blt40ZdSge1vz5h4Ky8pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNmVkYzM5LWYyYzEtNDQwNC1hYTkxLWI2MDA3ZmI2YjdkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE0YzNjNDItNmI1\nYS00YzkxLTllMzgtY2YxMDMzODEzMjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2FGOUOCG/Jg//+rQRyqpFTRJ7q+8V9MumDHLcpVgJIuwOXmy9//y7JI8oE9L\nrvM+JdXdZlR/+3F+OWv62u98j6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH2BHKI/PL7UdDA62QS0WvV4zE/EwHwYDVR0j\nBBgwFoAUmvztH6e+cWpkLzn5C+2yzplxzb0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA34zwEjIjGcKFJEwgQfHcagirF0SMiFgV\n+gZpIZy2zmMCIH1XWn6ZFYaFIO+Y41gJLDYvZr6e4fzOhU2CwdVDFg0q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU4rwR8Ucj0jcxMrCPuViDUeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzZlZGMzOS1mMmMxLTQ0MDQtYWE5MS1iNjAwN2ZiNmI3ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLnIAyW8nXhNMGprcb9DUIirxLsmWB3Yk0AEmE5Gw09xQt\nYQ9byWnmAMOp2SYTKyd7Kw21v1CVYzttGBCjg2hZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmvztH6e+cWpkLzn5C+2yzplx\nzb0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGBYPreBdKaia+1Ekxgan+WcQbYuIDOxK3/z3Oh/x2csCIQCdl15nC5SA\nGQ9WrTTlHRAB136yVxq81uNRAgZA9zrg8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAVLnI/UzoM9it9skLjbdIVY9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE0YzNjNDItNmI1YS00YzkxLTllMzgtY2YxMDMzODEzMjU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzM3ZGE1M2EtZWNmYi00ZDMxLTg5NzYtNTQ2MjczYmJl\nNDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE78wk9DaX3b3uBSl1lEdP0LC6\n2U9dIBErcQzAMZ3eG3S7/WLCJF2h5/RG9bsyBzzY7defphMVviNMuHah8HMGqaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH2BHKI/PL7UdDA62QS0WvV4zE/EwCgYIKoZIzj0E\nAwIDSAAwRQIgQRrtTJIb4byCHHS6aJaka/nT8h6bKLmNcTTMUnHL6eECIQDSzKKT\ncLvmtOGpSSOk4Hpbu2I9RcA4jperTNMN8E3pVA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2248", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2248` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAUXskHjsSiqR9/vZv6ZxZhGlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3MWUxM2RmLWU0MjktNDc0OS1iNTdjLTRlYjIxMTNiODY4NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU4ZWMwMTItZWM5\nMi00MWQ0LThmOWYtNTZjZmY2MDdhYjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzGj4tPnthy4oret20hxT3y9DUuZXmLVPQt84jhkvQ98KdTpiccJk5VcnB910\nZZuy+ukDJXk6+K5VGuaWhB7At6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyxcZa7sygDR/jxvnDsgQZ0+3o1kwHwYDVR0j\nBBgwFoAUy9dxRbkUkTIUD8dBemFZeLQ0afMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICbJAzbU4/rBVNkDercXIWxoR4eT\nN3UT6BdfhDi+4QwMAiAM0g6u50/wU/sv5f0zGBSWjB7By/KcWtyGcOzgRhmvLw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS2L1Ug9sZBVbcWMM95AesxgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzFlMTNkZi1lNDI5LTQ3NDktYjU3Yy00ZWIyMTEzYjg2ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATThlRjWplMwEdZBaicM5/xq3nSvAlL+vwMsbboTnr3Ls66\nyGMM9xDF6wuuWgEg4Ka3mAddNr5qJKEnS2DJIJjyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy9dxRbkUkTIUD8dBemFZeLQ0\nafMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOCeDR22mBwnXUujywwlixki3aeazdlLAzoY+vzSWBQAAiEA9UQxfdN6\niF9esRTT4ZxLWnRowCbGggsnbXzoTBw/dqM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAcw/WiMbOdFrB14yLzuOxIDfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU4ZWMwMTItZWM5Mi00MWQ0LThmOWYtNTZjZmY2MDdhYjFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQ4ODA0MzItNDQzOC00NjYyLTgwYWYtNTUzODBjMGRl\nNGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZJn78dPWmQhdssobNxrbZzX+\nhfLLGS3VYol+v/kZGlFxTt0Z849rfualfUiazxA5SJjA7E91xLZ87Txu0HklmqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyxcZa7sygDR/jxvnDsgQZ0+3o1kwCgYIKoZIzj0E\nAwIDSAAwRQIgElQ0etk8jy4TW2Z7ClXpu72VeoeQcjcsdF+nsb1BwhsCIQDMDq56\n/glRrn4FX5ktCLaJUNFCsoKOOEnfq3UzKcDEeQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2249", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2249` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAV0esSue+2rE+p0txHPWh6YeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3OThkMTdlLTk1MTgtNDIwOS04OTYzLTZhNDUxMGYxY2FhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTlkMzMyODYtNjI0\nNy00YTk3LWJkMjgtMWQ5MGFiOGM1MWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESL5QTG5L/bHfp33FohhaLPOMfF9OGE5Ro5dNnzo8OuqOR4dw9TFBUVlFWYbU\nDfMc6cQbuEbvp8cN4KFtmm/MyqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4UEDU/03JLYB8f3xIHEiuuzuqnwwHwYDVR0j\nBBgwFoAUiHpmu9auUEVGAnbBqHufRd3Z3r4wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgF7iD1deN\n7dgBZroGSiPtf1udiIRgsaWMSfIsKisZLO4CIC959Kdy3NCUzazgOtVtiDA1WNh2\n9topkPGitwumMO6E\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV68g/VU1Mi2+Qc+hS9aVElVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzk4ZDE3ZS05NTE4LTQyMDktODk2My02YTQ1MTBmMWNhYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQudTxw5TIELaYlXlSy+sUCqJX7CJN+9u/Rn5vdve8fepe9\nq3K2lFw3Do9nF42SmXYfklfAxYUEAA5Yrljuw5F0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiHpmu9auUEVGAnbBqHufRd3Z\n3r4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ7iiG8FCB7xr0fsGKuHuV2c01nAq6AGysJqD/gjA1n0CIBxKDC2xkw4H\nK3cavsJZ5MY4CVz+j/6xKrjJV+Gt1CLq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISATAI8iSGmIOkjAwdFIGgHwDKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTlkMzMyODYtNjI0Ny00YTk3LWJkMjgtMWQ5MGFiOGM1MWYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTIyMWM3OGUtNTBkNy00MTQzLTliZGEtMmVhM2NiMWEx\nN2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP8ygFwg8apxMXlSC3yllPMkv\n4lfL2Fnki2Uebum+b8bdOHmPkBXkwO1C1qT9d0ROAI0/e1TUkISWEDI7zXEHKqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4UEDU/03JLYB8f3xIHEiuuzuqnwwCgYIKoZIzj0E\nAwIDRwAwRAIgbgL2XZz5krj16YjiPopbLFT2QTXpW79UvDSzNTjRIIoCIF6Jte8L\nPmk7jNr81d9bNE0crKSFxKBFS3zRBmUsSG7i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2250", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2250` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISATnTf5nJYdLOASTkAKR4Rx0xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjODUwNDhiLWQwZjMtNGIxMi05ZGM0LWZkNmMyMDY3ZmIxYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTg5ZTlkOTItMjdk\nZi00NTk1LWEwODQtMTJiYjYyMjgxY2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOsj9jGq1sLWa4Fr14ggtmS9EMd5BbWqs5I9dCnN8J8PsosntQZQ5MkTBV2Ho\nwkxzkDOVSFLu2PocIGT8gd6xZKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjAks09nffJnFJcF3YGJC2YhmxUUwHwYDVR0j\nBBgwFoAUzVrCFcWYOEfOhkHPTUQ9gvMqrBwwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAN56KL63\nQs3Wr8TFMbdnN9jT4EaoHOlEVDQorZJACAH5AiEAyc6YZMkmFre96JTt7mxKR72m\n9BXdfckke7kQnJ6B038=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaEMLrueMOYH38ku2px03n+fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzg1MDQ4Yi1kMGYzLTRiMTItOWRjNC1mZDZjMjA2N2ZiMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkThrkq1FHT0+n9xoarGgOsVyoQHxb7i05yXIPc1NBWt9/\n/2cTRCWtLkA1PHiF6Svoi+ZBJQAoGKzpsI5xb2Tno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzVrCFcWYOEfOhkHPTUQ9gvMq\nrBwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFRF36s+AcyqGsUOSjwt4GCvXER2N8QxTYwJyxnQ2LhQCIQCLyjTd8okO\nItAfSMEEXP4wTmjZhJsk3NSEJbY2Ib/GXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfMRx5pvPMd8DASCJNhzOrJnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTg5ZTlkOTItMjdkZi00NTk1LWEwODQtMTJiYjYyMjgxY2VmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTc1N2M2NDctYjZjNy00ZWIwLWFhMzItZjdhOGVjMmI3\nZmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0AfucUGlq976sP4vMIvXhlBF\nBb8MY+iBLkGbKfjYxfh8u8u8O6id0QfMRF505ntmghwCOTE4TH2O5OyWoNtt96NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjAks09nffJnFJcF3YGJC2YhmxUUwCgYIKoZIzj0E\nAwIDSAAwRQIhANUvu0wJ8Xgb8aJj4YpXYIqf1II5tFZsiwmqM9ArXCRxAiAOUfh7\nS4YarwcsMd4ueEu7gyFeeQUFo227o/twnCYvdQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2251", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2251` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAfL/xlQt1BheS9cNPLich69uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0YmI5ZGIzLTM1ZTMtNDBiMC05OWI4LTQ1MDNhZGYzMTVjYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg5ZTBjMjAtN2Q2\nNS00MDkzLWExNzMtOWZmMjNkNzhkMDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKWd4KoNY0+2mvrb5UZeS3SxBzYb60Hf7BYLmumhQX+UpXA/8HYcep6MersTv\nVIW0stDFJRiSB8T1MFIj/WgrCqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBSYTrKhx6u00RdLzCuFx2iKoDrQwHwYDVR0j\nBBgwFoAUyv1HFQGMRjVD0DkK6qFh+bB4FUgwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDDrcu8\nGKTT44riBXWKcpt1UxSj4UkKyYywZkbdi9dFQgIhAOm3Wbm8SmnB8wiirU1jB7ry\nup6UpkmtVchJJJZsmQSG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVJj6WM3hCexd80AK9oAqUb1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGJiOWRiMy0zNWUzLTQwYjAtOTliOC00NTAzYWRmMzE1Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRxdmwNiAAH1yIG3n7NuRfUM3sWRuxsxszjd9nriQsrd5r\nlGe3JvsuWfwLw/+a531NryTT5xumPW509kUYN74Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyv1HFQGMRjVD0DkK6qFh+bB4\nFUgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJOhIv4zLZEZb4MduZbXzMUR/IdODYP4tY6pZb6KWLZQCIQCj63aVwiFW\nCPqhOXxQFfTLSeCgvh0wbHmKNxLDCGITwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZvtm4E+Hd6ANzZQgy1PJUdnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg5ZTBjMjAtN2Q2NS00MDkzLWExNzMtOWZmMjNkNzhkMDQ1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDUxMDNkODgtZTI4Mi00MDUyLWFhYzItMDBmNGNjYjc1\nZTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpnNkmPRU2gxqSlOObsqiyT/M\nJNccRXPU1Wm256aRvOy6cyN9RurPCHRg17blM5bspnVMA40wG+ZhhARvyoc6q6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBSYTrKhx6u00RdLzCuFx2iKoDrQwCgYIKoZIzj0E\nAwIDSAAwRQIgHlmRrCKsu9a7y+GGqT2XwXLM4ZDw4x1J2TVSWIzGwIECIQCJUZFR\n6iE2XoSm56pMBVi3puUThBW/1C54Pn4O6+OK3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2252", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2252` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAZt0RKuibAWHYckXnyKBdzYUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ODNlYzhhLTFiOWMtNGZiNS1hOGJjLTE3OGM2NTRiNjQ1MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2EwZjIyZTEtZTQy\nYi00ZDVmLTlhMWItYTJmMWQxZTliMGQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmDs8NvyXEobm9apKZUQTDTCC3jW0GyLwubMdZLkwbsgljlQNHBQ5ulLoH8h2\n+odv+rgU8gL5IGg9B0iiSQEaGaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbattAXc5tmlVtq5rejzXbHsY7dIwHwYDVR0j\nBBgwFoAU3CnXoPwAYwR/CSEkoMdrsE+vvlMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIAYOtVadfdoqcJ1A6+VhHiJw3bxEye+HiNKivnMEmWXxAiArX+i+CGnm\nRHqW1beCWy1WI2oaaMKhnxYBgTymtjB2iQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZHjo/zBs3pCPCdVvW2Zsc5pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTgzZWM4YS0xYjljLTRmYjUtYThiYy0xNzhjNjU0YjY0NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkuD2bA5o68x8WLgpbRQOQNZPV4hkfDUFx/nUC6oYHpoP4\n21tkGBiV4iJSfFlPIqMFW3FCB1Kgg44KZZZDhJPWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3CnXoPwAYwR/CSEkoMdrsE+v\nvlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPMfGDaQzm8fMJFRzzzaeEn5BHDVN1rvFd8VGzhoyfn/AiEA7ReCB74h\nvnXoksm2r5uMAadOEKqBzmVuukLNGK24dqo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAYRX9V3mHownzChx4TjEf9qQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2EwZjIyZTEtZTQyYi00ZDVmLTlhMWItYTJmMWQxZTliMGQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDA0YmRkMjktNjBjZC00OGYzLThlMGYtM2Q3ODdlNGU3\nMTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEF6k4GNCJqv+D1ALxEWHBj6kW\nQLTTBugo89IEMxTB7G3eo0SNL7e6p+D/08QAHXfq5d28TDqSkh5PhaYc86PWWKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbattAXc5tmlVtq5rejzXbHsY7dIwCgYIKoZIzj0E\nAwIDSQAwRgIhALPfdOAcWRQXe9vbpcLFKV+94k4mHUnalSQSH+W1KsRYAiEA63nW\ncTsVFhdUOiK2DUjrKU5HrBznOabw7hDNBc4C4fI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2253", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2253` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAZ6ljxO4XAsTB7f9lw/sUMOzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1ZmZjOWY3LWM4NDgtNDM1NC05ZDhiLTk3NDNlZjA3NDhkMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFlZTdjYmEtNDU2\nNC00YjJkLTk0M2YtZDc1ZWQwZGM0NDI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF0RXEY/j+q7y9UEvuL6FgUYA0ntc/CuQOCZNgCtBV8VgL5KmlF4CtxHzn2nz\nSrK/UFAXk/x07yAPjlw6tFqDCqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi2Zmn5tDqQpfXCPfK42Oih91JbIwHwYDVR0j\nBBgwFoAUgP36sH1x21svcMBajBgFlbYWvkEwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQD3vs4VDA8IPZgr6Jrk/W6u5BKnCh+Ed/nDFaJ2Y9hm7QIgFwLFo5g4\nEpV7c3IDk2vz3LXPkUrapQ8P3utp250QCg0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdtyeLlSOx507cvpxy6ZrbVWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNWZmYzlmNy1jODQ4LTQzNTQtOWQ4Yi05NzQzZWYwNzQ4ZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPugUiV7Ct4R4vGOGlgyJ1OT9B6ibMrEIIJ5lxs/F3D9Sf\nnKkfMloMz1lBL8WxLn9ra6agPZxYQDLB1AP1O7Gto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgP36sH1x21svcMBajBgFlbYW\nvkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM3JoqP6jqErn08kgaviTKpP0rLAJ3ZFN0B1ojs18OMxAiEAuTbCOQe9\n4OgrmSnGYdXVw6fhEu/BZJuezPm2RqSWVhY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAXNNurZb2gVhZxpLSOe73FFEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFlZTdjYmEtNDU2NC00YjJkLTk0M2YtZDc1ZWQwZGM0NDI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWJmODMxZmItYTdkMC00OTA3LTkzYjktM2FjZmY5MmY0\nZTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpul5oSnXanjhoBMBWoSU+AnF\nFhevu7nkxYY9zO9qKg4uqsQRa1DqqqUAuse55LhIC6rrS2adxyoJBj6LllIXr6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUi2Zmn5tDqQpfXCPfK42Oih91JbIwCgYIKoZIzj0E\nAwIDSQAwRgIhAN7ojJhBMCdaNwPHk0Zq1Qe558xd4HVOnRXU8ITMtd4fAiEA3u9d\nXpwYnGwFrhmGZtV7S7kjMjtJGpBmFzv9djx6GHE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2254", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2254` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAbJb2GmJwhWh/0IqlTFgTTvMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MjJiYTgwLTI1ZjYtNDIxMy05N2VmLTQzYWRiNjY3NWY2YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmEzOGZjNGItMDY2\nNi00NzFiLTg5ODctYjQ1MzJkOGVjYTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqKAfQ3XQWXoA13HqkRtBYWsf4vcEPOQTHO869PtNOYC9z2kcqMUwJo7SUHrh\nYZp7eXatDUL8QB8ZQWaue5jfm6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlNAlI2HlWvN8zvTTxk6J5BqbORwwHwYDVR0j\nBBgwFoAU0fF/gVCkpffIaX02RLxzOULiyvMwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQCgwvKE3vdnfhmNrZct1fezlgijkOkR3x3gKf/hS58Y3QIhANv5rjs9KZWn8Nqq\nEb3RQityXtPYUMt2n6wAxqZd8OJ1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXSZqwFy83CwIrC6j0C+G/N9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTIyYmE4MC0yNWY2LTQyMTMtOTdlZi00M2FkYjY2NzVmNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgGGQaEC3i/vTF3lXER7RCxytaM8PX9ir8L6aSpVLCsRbD\nI/6pVWyFDioCdY/NxQDkx1xLJoU5iUC4cJSPVH02o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0fF/gVCkpffIaX02RLxzOULi\nyvMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgL0qm9ABH4t+s94GjZLxkybSw8KTKgnocdjDXeDlBrBsCIQCVh/1ZFyAP\nPv8kH4QIGjKJBWDLau0VrMReP2Po/dfQIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAeZgz/KkgU/T8CHIfScsy67qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmEzOGZjNGItMDY2Ni00NzFiLTg5ODctYjQ1MzJkOGVjYTEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzAwOWE0MDYtOTk2MS00MDVjLWEyMmYtNzkwODVkZTUy\nZjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL8WaNMCoBDy/i3g1kww32PLt\nWPJ/PWTA/fNmkXt0gFEYjCDk/Bl/LYa8/LV/00zmBfYBpxI/ZsiEwEibPUWzQ6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlNAlI2HlWvN8zvTTxk6J5BqbORwwCgYIKoZIzj0E\nAwIDSAAwRQIhALlRhcK64BU/uPA4h+dEpTj33mAJvOfUDgYl4MO8lYNmAiAePnVG\nlzN/jn31aQ8Fa3DRfcZyuogIXcdIEXjpZBbbwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2255", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2255` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAUtTL1V0YCjR5xBW7bgcCYpNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzOGVlMmU1LTk3YjgtNDkwZC05MzI4LWUzYmNlNGZlNmE3OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA5ZDIxZWYtZDll\nYi00MGJlLWIxMzYtMzU2ZjQxYTJkNTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+Pjd9pUzQFKx8XVV7ltnVs8+m0BZZ26itKovQrZD7ndD4p8TPOFJJkArB6Bu\nLfoGaFNyGFMalPgq0GdPz2Dbo6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5eyTN1buo7NwRCY1X5Fje3MdGzUwHwYDVR0j\nBBgwFoAU/ivBGV+M2YGqCdkrZhymUBTrwkEwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIG+3FjJ7XwZ4MCkkjm5++nYJFUahKkOWxcWwj0xaawxkAiAz\nHnURa4/TBBVfyUPMznVySt44kmsVdTaaYyIVSlX9eg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUBubHvMU7F78wInfutLmZTPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzhlZTJlNS05N2I4LTQ5MGQtOTMyOC1lM2JjZTRmZTZhNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVAfr+ymDTK+WYuk+HQYVopJgPQ8q8GWAnfj3gJUR+c1aq\nDcLpkukkrm4Y6RR+5W0la2sOHVqx2g83NijbiNMho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/ivBGV+M2YGqCdkrZhymUBTr\nwkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIJtI7cbQcz1nAA6JCd5jwqjtHWM8YUie75VlePIBqNQAiAnh5yrve2/\n8Wut6L+QPUB7ljo6lkT9kndIDMMH59w1Fg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAWN5fTwxKZDsvoW2NBNg6BbQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA5ZDIxZWYtZDllYi00MGJlLWIxMzYtMzU2ZjQxYTJkNTQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDk2MTc1Y2UtOTFjNy00ZTljLTg4MzQtYjVjNWVhMjVi\nZWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUTVYhvGlKFlVpsFDJ2Fs3zRA\nLoo/uKnShOEwa0h/vljyG+r3LmVEkpBXdZk6twnoWe1ioQrEEHgJI5OpmSW92KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5eyTN1buo7NwRCY1X5Fje3MdGzUwCgYIKoZIzj0E\nAwIDSQAwRgIhAPTxpIqSb1x3eLrLthDqaJoXHaDdp+azk4CN3ArlaHmcAiEA/V3/\nkL7yLh+06mQvqKGHJDfv1SqZcuUqTI0/sQxHJRg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2256", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2256` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYaxhA4Sdl+CPsP9iam/9U6hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNGI1NDcyLTI4MmMtNDczMy04YmRhLTBkMGRjYzc5NWMyMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE4ZWFiM2ItY2Yx\nOS00MDE4LWI1YWQtNTcxNjE3NTMyNzY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbG0mAG9Nqmf4/vAggsGraXhmvAKSt/lSjefs+dbZQjGM+QkmmeBQPt+y9QjG\nsuWA/CtI2HExUlZlvezixrnuT6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyyc/DJ23ccsemupF7AldUIiUhYkwHwYDVR0j\nBBgwFoAUyPfDfRXXzgqUHPXRbad04RZrBR8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQChqpDrRd6J2NH1BLli8ug0r8J0aDMyNqUOj/0sr+XjdwIg\na7rNLRtCfoldXXR/tKxOlSz+hrdaw6i+7Tk1z4F3lu4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAStJezOg7c9ignxiPKT9XgsOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjRiNTQ3Mi0yODJjLTQ3MzMtOGJkYS0wZDBkY2M3OTVjMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvavc/wQsCBL6a3EWYddA5Q+KkhLXdgqyfJLtMgswD9nst\n/rFQGN+aCRdWPLNiVJMLrxzw7sC6nF14Y4zN6P3lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyPfDfRXXzgqUHPXRbad04RZr\nBR8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJQmvucA4YFOlD3KPpxBPNvN8OMO/c1gbu1wN96loXOyAiEAv4SX89MX\ni3a3YCO9FU21uKbkZAZMSfPKskUXTrhsua8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAZ4bQSnRdLBWskJ1Ax6O1+ZDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE4ZWFiM2ItY2YxOS00MDE4LWI1YWQtNTcxNjE3NTMyNzY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzcwNzA4ZTktZTIzNi00MzQ4LWFlOWEtZmRkMzU3Y2Mz\nZDFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUuzgwvYc0DIh4Hwth0x4Nvu8\n6N2ddWgMy1psun8ucvXEmGm2neJedmbYKJLrfGl+2x5uy1qUPReFSbDHdVCXrKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyyc/DJ23ccsemupF7AldUIiUhYkwCgYIKoZIzj0E\nAwIDRwAwRAIgBns6qLml58xftCyXyh/7JB88Kg7i4EQ43nUhfeqIh8ACIAoL0OGZ\nbtsizWa7lrf7ujwpYCxAQ9PZEcMduCDDDpvn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2257", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2257` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcXMPquZgNHWTv7xpFsc3z1nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0ODgxYmVjLTlkYzctNDA4Zi04ZjM0LTRkZDk0MjYwNzZjMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY0YjQxYTItZGVl\nOC00YzZlLTk0YmEtMGExMDM3YzdjZGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH06pVFI5qTn2/8gYQv3gasbWj40uoLyN0PEYs/5keUU4V1MmegF1O/WZaNpG\noNyQ61rQ2F3UmX0GZs8+u69Nz6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHlN9nyRI20GrO75hIQ7X2dr37zQwHwYDVR0j\nBBgwFoAUkFUpptILE0WhkQ6su6VdgO2BsNcwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDMmu1ycjAk1\nj4wJLjqazvglfOqtTieYwjUwJ5Uaai5CAiEArc+kKLIJkNvzdYYAxX2hgi1OIWWA\nDNtkhpffwoA/I7E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATMYmgO5hLpp/5YrJo1uPI1lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDg4MWJlYy05ZGM3LTQwOGYtOGYzNC00ZGQ5NDI2MDc2YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnNlESktzasTdujwJeOr7M4OgmHSMqQOI/DznEi1Nn/3Xg\nJV9XeTNhBE5KCvBsC+mEhtlTcXzG94ub46Dcg3wQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkFUpptILE0WhkQ6su6VdgO2B\nsNcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPa2Y/N0QNkvV6clAn3LMr5KJnVjR0zG9MpiAnsvFaLAAiARosIsjOoV\nplKjOHWvuxENnSrInj38N1dRMrAkoxsDgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAQQxw2P2yw2KllFwpGZgsz5SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY0YjQxYTItZGVlOC00YzZlLTk0YmEtMGExMDM3YzdjZGIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDk5MzM4ZTktMDJiNS00NjMzLTg4ZDctZTJjMzY0M2Ix\nMzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqM+RkHwPXbqpY7M6jpnaE5Ku\nynmW0oBsEdSgOSJoSCGWeU6wXcw/RBQa0syBw16LoqmreJfT6BsTMsEpMKgVfqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHlN9nyRI20GrO75hIQ7X2dr37zQwCgYIKoZIzj0E\nAwIDSAAwRQIhAMr5ij1Ml/GGoutzHE8kn+edB6j6EJlLozjuQIvcJbtNAiBQaqjF\nhk6kjydbteK+GxjVlOMUXYz/dc2bOrChxIkaPg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2258", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2258` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAWdh10mCt1FoG1rHTdsRlo+SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5YjA0NzBlLWE5MTUtNDdiNS04OWMxLThmZWNlNTNkMTQ0NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGIxN2YwODQtNTVh\nMS00ZmNiLWJmMTUtM2I3MGQyYjQ1YmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZKm4dl7whKVPwU1ljD/kH4V5ceH1lD0IChbgfqQO7q9d3vZzK4Lnvatrqc3c\nd5TwDdD/jes40hk8uWMGMESVqaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG7c/l9tqKWsVcu541aKZmnPH0B0wHwYDVR0j\nBBgwFoAUlslJQPI7J3uCrXOZvriBoMOZPSgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgLaMyBdJKFVDpn7++rGjVh1jYk/m+E88C0siTbTNGnq8CIQCghsrsPcRl\no5Wau2/6N7daP3gvOizVobKJCpMVyj6qJw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASET76P2GhNu/L1Vsr6d/uLmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWIwNDcwZS1hOTE1LTQ3YjUtODljMS04ZmVjZTUzZDE0NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNBcf0mXVMn/li3dr07DliqeTHzKw8Wgh75kLFJqJmyK51\nBGf+lLEnnIxoZ22+d6MVOBNECAD1hv0U909Xw/T9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlslJQPI7J3uCrXOZvriBoMOZ\nPSgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfyyLh4sdiBJFRhieaWiXflLenynUkdzMEO/WMFHRUHACIQCjP86FdRfb\nv8dQ/iWgCiZSWO/M4abidlr58T809O8oDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAaB5SiZtLrOewpHMImcP+44HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGIxN2YwODQtNTVhMS00ZmNiLWJmMTUtM2I3MGQyYjQ1YmQ1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQ2ZjFlYzAtYTYyZC00ZmNiLTk2NDUtODNkZmY1OGM3\nMTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXXhSaoHHTUP2g7zEACZE6pkd\ndVKJ/bKaoYtgvJyyzTvyQ1U7FIn7IJZVktq1OojZBMaaxHLUnReUfpuh12FvxqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUG7c/l9tqKWsVcu541aKZmnPH0B0wCgYIKoZIzj0E\nAwIDSAAwRQIgaFsNRUD8DXFSvdxFxRyiYh6uXdG2lMPuG4NFf5QFEv4CIQC2rIi4\nuA5Tqdo9ndqYsR3cvKg7A9uytlWf/8COU/FrIA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2259", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2259` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAf+y6D+eXe7TaqRNkS11UTEfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NDYwYTQxLWZhOWMtNDQ4My1hYmFkLTA0MDQ4YjQyYWQ0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ4NDBhNzktNmFl\nNC00YzdlLTk4YTYtODViNjFlOTI4ODQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3hoQBfbJi97FJ0t1VLHoK/GC2guRSL99bsSdUaXcnw5eWsBQHY1b1Hevz6W/\ncdA82tZdSQGDP57J9tZxkstG7KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/yUVUNzO3kUglee/SbLnfllDoB0wHwYDVR0j\nBBgwFoAUrdKTiIkEzg5zfn1VBEWwa9lGN3MwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAI3YSUfF+8LQwD7qv9A8ocyu4zra1FiUIVQA9doOKEMbAiEAnpBqjZWf\neypzsZibl8b2TriH62+zQMxS5Vu0y2Y3xwU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARe5GFulVNZNEsuSelt5SusFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTQ2MGE0MS1mYTljLTQ0ODMtYWJhZC0wNDA0OGI0MmFkNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATY42qkx9PjLG3TSWUfT/LKBvMfr37rDJVE5lyN4ML9afiP\n4bZXt47w/fyUVkPX17Tv9vUFHaCCs6HlJTTZEu28o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrdKTiIkEzg5zfn1VBEWwa9lG\nN3MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOXZa6FtFt0a3sQ+zMZFhNSHXFJHMMjb7npkgqS1LgMUAiBRcqUNzv4k\n9rixsZvMwOIfgTL2Z48SqYS7FHX/gR3Cfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAbDvbwHgVZCp2LSoff8MfXhUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ4NDBhNzktNmFlNC00YzdlLTk4YTYtODViNjFlOTI4ODQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2E2ZThlM2MtZWNlYS00MmU3LWE1ZWMtMWRjN2ZlOTVh\nNThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECldKvkxri/Z1esKOBySVuCzr\nTA1utQVb6S4YtQC2CMWnnN7MrQjj+o3VOWKpRfI2hi2ikqpYEb7NxmCrsei556NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/yUVUNzO3kUglee/SbLnfllDoB0wCgYIKoZIzj0E\nAwIDSQAwRgIhAL5CkXKEB86bgXyuKSJMrXe23iRqJPKSMG62RZXZX5msAiEAnN9T\naSV8/+q0v9LX0XUErI1bqiIMz30LftqR1uz5kRw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2260", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2260` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAZ2b+zv3VAqMW7KeZOf8LmW7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkMzRjZjE4LWFjODktNDk3ZS1hNWY1LTdlZWZlYjllYjQ4ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdiM2YzZDktYmRk\nNS00YjI4LWE1OGMtZGE1Njk3N2IxNzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkYRGd/jbogFNEai+1XO2520muSloqsnAcdlU41YU0yT/wnPrt7siVaPB9hY7\nSsfG9K+0O3IeiPvJurbdgogcm6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuEa10CBXR0iY6tIAlcDIaWOH5N4wHwYDVR0j\nBBgwFoAU7yoJG5b1u6fv1LfQwThBCiTchiUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCwuQkUq93pj+XP/UH2RD4TPMHT8s/KxAm6+ChPpzY44wIgP9p1Eukp\n8IUYrM4vsBdYUodMhR7a8YlekJFlY7TABzU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASwXkNVecJtdJp63hKzdKMCCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDM0Y2YxOC1hYzg5LTQ5N2UtYTVmNS03ZWVmZWI5ZWI0OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSUQ1G3GgMXGO+nhsI/neDx84BCXLsDF9MRa9iiZfqP50O\na8MaFMChY4hVqGyPsj7yXK+o/G6TwBthjRE+MS7uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7yoJG5b1u6fv1LfQwThBCiTc\nhiUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMsFPul4PDJefAdRlK81nSz4F0YxZADzVmnmSgyxaHnDAiAvPk9ygjTG\n+ezgeZjtLd9Xph4/4yeGA77uKDCA3zShOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAV8zFNQp1D/OKu4/V+VBSGYnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdiM2YzZDktYmRkNS00YjI4LWE1OGMtZGE1Njk3N2IxNzA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjI4MzE1NzYtYjU2Mi00NzI5LWE2NDctMWNhYWFkYWJi\nNjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETOlUtms3pbKzhNaubVvYmfer\nmmjZugJnimRtREBy6sKKGKk6+nwuFDLa66YHbffrjVx4jXkrXina0ObIqhnEeqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuEa10CBXR0iY6tIAlcDIaWOH5N4wCgYIKoZIzj0E\nAwIDSAAwRQIgYDgUvdwSOlmsIIYVQx1uVwWbdDHHIpNzHWVFW/uWtVACIQCdPJt4\nB3/TVxb4pxmpnhI2RTC+LWKX02ruByRzauOESA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2261", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2261` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAamWXxKsZk78J/iBP28lxcjuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjZDI2ZjBhLTVkNWUtNDkwOC1hMDdlLWFjM2M1Njc0NDU5MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZmZWM3MDQtYTlj\nYy00OWI0LWI1NTUtMDBiOTA5ZjliNTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwYdRjl9qMT1OW7S5FAg4k4DnRuVR6lSWbQadD0BX5p3V4s5z/SLNd8sH0WOt\nPznI/ztpqVd7iX3Lf5jNBgZ5aaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULLUwDYpmRJKBAZJQF2tuVqE6WPwwHwYDVR0j\nBBgwFoAUvs4jA9C48Djlr3tqQwQ9zGCGFoUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCGtp1W1OApPQlH76VT7b5aiP5KRZQ2nKO89qb1\nKbomwgIhAK9+8KG4HSZbhS/ARjGUIiuxXl5EC5FOsOuGNIqdmr42\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAawxVWv3qImWcHcEEjM+lQgcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2QyNmYwYS01ZDVlLTQ5MDgtYTA3ZS1hYzNjNTY3NDQ1OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7T7iYEvRMSoGQ+ac8LyuvYf+K0KFsfqV/mvqv9mIcS6mU\nW5yakMHGbq95jd513rT2ITJzB7/P8PhFI8QygqMXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvs4jA9C48Djlr3tqQwQ9zGCG\nFoUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf6O8wflaK7V4h2xk0hDFpFvi0yFbzSCTPpzwzV0h8AQCIFzOo+ZV9m4y\nTwFw2weC+Jp4/MSnqkqOvtR1jiBG54r8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAX85h3H3QhZBaLEXU6XT4LgtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZmZWM3MDQtYTljYy00OWI0LWI1NTUtMDBiOTA5ZjliNTUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODM5YmY3NjctNjY1My00ODZkLWJjMjUtOGY4ZWMxMThk\nMzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEICe6zn8J3GLVYKVs3X2iWK8G\nLupPxSqzXDJXr9P97nrMQRksK0bBH4FpiZAUG37ieivROPxc6EqEMDNnAFUQ56NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULLUwDYpmRJKBAZJQF2tuVqE6WPwwCgYIKoZIzj0E\nAwIDSAAwRQIgcFlINRUOxOVfMHh7RPcJ+QAXyX03epF4b+T2c0KURncCIQCtkGCN\nVudjvynIWe+NU2K7r3ogIOw4LT8xn49jaR+aGQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2262", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2262` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISASaAc4TNz+HrUQzf5CMGy69RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczZWIwNGE2LTlmYTktNDE1OC04MzRmLWNmZjM2ZTc4ZTk0MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQyMDE3OGEtYzYy\nNC00NDNmLThhOTItM2VhNGE2MGYwODVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ3n61qHdhGnVa36WCRKOMh+Cccv7HUxiFVVfpVfnNmmQi99nCwltiBQ8jlT1\n6fsD3qJrUx+E9nLoYdqy5nRgp6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9xu9TlAJWCE8VoNQvXe99Y2SNtMwHwYDVR0j\nBBgwFoAUGRTUKjoQ02sFnzopejH8sGvULVEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDQGFmJeBawvHSU+0XLQyXHFvtZYSVoNf5m+LQZ\n1eQmegIhAIlbG84LPRWA9myfvMFNU7OkZWareMH8Vd76bYaUv9e1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaNTu7p34b5ZTKbn14wzqApWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2ViMDRhNi05ZmE5LTQxNTgtODM0Zi1jZmYzNmU3OGU5NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwN11QLiFJTg7lMOi58NX82wpN/tcNvPASMKQMKnqZgO/U\n/J4Z7ZheiJ8PYBZI7j1hcE+G9+skQmqbmWTPMm4eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGRTUKjoQ02sFnzopejH8sGvU\nLVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXp2YH2hJNFY35beSXKU2BOpJWCMh3gphVvUD2mc1C+sCIQC9dJ44a/v6\noq4/1ZshbHnov5ansdTjIISPUBi0fmOaMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAQW0NuIU+o6xukAuyA+iIcPpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQyMDE3OGEtYzYyNC00NDNmLThhOTItM2VhNGE2MGYwODVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjg0ZWQ4ZGUtNzc2YS00ZjI2LTgzMTYtMjgyZGU5ZGQ1\nZDI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAi5OOFhj89sTZxcKURNf20IT\nhdm0MUOn29I4Ys8zogCemj/Jr7eIngmoMNkK38OheAfJRHXSP6KhXAFh1yf29KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9xu9TlAJWCE8VoNQvXe99Y2SNtMwCgYIKoZIzj0E\nAwIDSQAwRgIhAPtbejKmhNCNUi157KZuI6obGTpc7njZH72Uq639ito+AiEAyFpw\nw0ojXZidETFF6nf55gX5N9mHlpYRrBGAWucJf5k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2263", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2263` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAfpSRY3m8lMDi8I/RlpEzQexMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwZTA5OWI3LWZkZjEtNGYzYy05OGM1LWZlZGU2MjgxOWE2MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2E1YjgyMGUtYTU3\nNS00MTc4LWEwMmEtNmM2NzIxOWEzZDQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo6Bb/c4eDNVN6lpcy1P1rG+iU4HKhvdixAUxuTmg8hUt4C+eVbbX8wRc6fW5\ni3cSMa0no9Gzqi97Mmj34r1OK6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUulr4V2CJv9UIAtMU5PM491puLu0wHwYDVR0j\nBBgwFoAU9ohArtZeQbIjkWVdx7lcsDb1y6swPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCv4825JXaChHtqbDg5WJYnye130lUkBwULKe0S32pCNAIh\nAPIOiukV6blLvJhddWfzXYvuucohzVtAACDl5sbiBVBn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ685Ehv/N23sivdXnGRn29DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGUwOTliNy1mZGYxLTRmM2MtOThjNS1mZWRlNjI4MTlhNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKh7J8CI/feHLH8sLhPUyAGDX8nT/Wmj3J8DO1iy1rg5WJ\n08zT6S9Ue8yE4IrrjG3/Ei0Yk1vXdzXfokaJeOFXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ohArtZeQbIjkWVdx7lcsDb1\ny6swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgb/fF/PuUYk/0K0cvHLdjVkD06GxzyuxVXvpa1V+PkQoCIQDI/Z5o9apk\nHu9/WxHn64kaYWZUEJGhqMNCD7Ds/s7tkA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAeIq1G1DrveyDoERhI/5M5ryMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2E1YjgyMGUtYTU3NS00MTc4LWEwMmEtNmM2NzIxOWEzZDQyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTExN2E1YWUtNjNmNS00ODY2LWIxOTEtZGExMjVjMTQw\nY2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMaeWIleYkiDoKHSgdk9oxRhh\nDqmnWzOhShnYdlGIfbzIFdWHg/kpqDAxykNDwjkeRfI7QwbhqoTSrFujAwKtC6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUulr4V2CJv9UIAtMU5PM491puLu0wCgYIKoZIzj0E\nAwIDRwAwRAIgFzaUARAZjoFUMyUfI0WieOsUrdK25X7+cpn3GfLYamQCIFVN6dmN\nphIPh2ZyIC2DHQXVxC1tO4/UONzGeEyuXrIG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2264", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2264` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAa3bVHAWZLfXp7+1cPZM1wnYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYjA4YTAxLTEyY2UtNDIwNC05MDlhLWI0MDM3Nzg2NDE4MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZkOGQ0MDUtNjhj\nNy00NmU4LWIxNTAtZGI0NTE5ZjUxNDc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp3qt0vBZ6u7JaVyboGfB/jhD6lnkXJg/9JSs2AAbiG4IaBPKwYbowoJVvhmT\noM9j9P9BEXcIbBE4UoN3IwKpkqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNRkKhHnWhtVBILUJ7ZnDt0ep3uMwHwYDVR0j\nBBgwFoAUarGl0G7/a+mHVajGsyO5xgfUo4QwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDw7XgKhSQsCYYSzVyhazHgbwuWmLHb\n8QWdXuu8To3c6QIhAONWSXlmBnpXp76m3PDGjmIqtpp7zjxVKrJf124BDAAS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfp1pU//R3xa/V/McoGDpTHoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmIwOGEwMS0xMmNlLTQyMDQtOTA5YS1iNDAzNzc4NjQxODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuElTzlllKYOjxnnsFLDdUQ8+17HWNjU/XUblZYF3GoLkp\nAlmOU5lkokFSHgEdNWVaZoohWcAoPl7StGAkqBzMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUarGl0G7/a+mHVajGsyO5xgfU\no4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJWQAcDZ4oFZqT039W/w2mDWZ0h55DdJ5wu2JoELjYWvAiAsVrmDyGCs\nU9uQLWKRquMfjR0Xrw5tyuV+ngyGLjPCjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAWmh+5hSdkfY6NNjQHG2yBE/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZkOGQ0MDUtNjhjNy00NmU4LWIxNTAtZGI0NTE5ZjUxNDc2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDUxZGZiYjgtYWEwMS00YjQ5LTg4YmYtNDI2ZTIxOGYx\nZmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEc+xfE80/w2n14KBbqoqRlhmy\n1ewavLC2xew1xlg9jAv/wdXS+u3aAtRhLHfaQNKnLeXZdNceu5p7P9PxfPyKJ6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNRkKhHnWhtVBILUJ7ZnDt0ep3uMwCgYIKoZIzj0E\nAwIDSAAwRQIhAIhEJNCMIBQ+LLXefHd8yidYiAAWN/vmx8mn5LEGRAQpAiBfYy9/\n6+x/i/GRSX5110lGhWfSyVgmdfbEcWN1fac2sQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2265", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2265` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATnPzxhXnrT4LHPZ9rhp1aRVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmY2JjODRjLTk2MmUtNDQzMi1hZjM3LWFmZjljZGY5ZjMwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE3ZmY1N2EtM2Fk\nZS00YmRiLTgyZjYtMzg3MjIyMDA0NTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEymx45EWE/ruqbdoqQE8kv6HZ3SbT1wu5oRkmsFei2Zq0eZh19qVq3IbwmK1q\nd9Oqu/LLaM/e1HYIi6mRPC+YhqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl2bTQA6wUXIv1zNMT94dInK4Oc4wHwYDVR0j\nBBgwFoAUO2aOgggTvhosq7A4V0rPDcydwTUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIB+k0QhJ73Hsl8kJ8Civz/yfC4uKb7Cz\nVbFxDqx0RTQrAiEA/adD6pvUrpSNmjVDXhMBdpPwc/B7u+vYwgM4Kt0QSlU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaB2n/to/Z8icdYOLiyB/zjpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmNiYzg0Yy05NjJlLTQ0MzItYWYzNy1hZmY5Y2RmOWYzMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSkCS6hzkPzulgpgSAXTN0vm8baePre/lNM6TsR8RZrspr\nOmBATr8A8itj921dsbAiJbcxytuqrmrDhxs38hJBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO2aOgggTvhosq7A4V0rPDcyd\nwTUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQxbUR6bCMVSUNhKZmexlQKUz5l4LHwrk4u/32KqNLFACICHvxvkIAqdc\nWc1S/MIHeVtHtwTivs3k5CY6GROmAfTu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAV/uj5kI4JzXhUV0V7bXsyZgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE3ZmY1N2EtM2FkZS00YmRiLTgyZjYtMzg3MjIyMDA0NTE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTMwODJkMWMtMjVkYy00N2JkLWFmYTYtNzQxMTg1MDJh\nYTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEApjQlBv69tgl1WoOt1pYEOVx\n6at2EQaIH4jqRqpttKU5ADGFDx9bOgf4vADh7z0mbXj1Waj/27U4BD3CsoX2eqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUl2bTQA6wUXIv1zNMT94dInK4Oc4wCgYIKoZIzj0E\nAwIDRwAwRAIgMhSpSELvp4AWgEoDwpmM0TyBHVwd1OyH5GWVwCK+E5UCIAasGWx3\nM8ZJ1f7lOhJBuXOM41NZZlaN+0HwMkB3AB5V\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2266", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2266` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAWFZUL6rLpHF6/Mu+OTZCG2pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNWNhZTIyLWMwMjMtNGY2Yi04MjEyLWVjMDY4NGIxMWQwNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQyZDQ3MzUtZDQw\nOS00MTNlLTkxYjItYzY3MGViYjBmZDQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUYLeMvwNoOdukXW+a2vuD74k2GCHy52x8OhrHc5ngmNDBj6XOWTToFayVmA4\nq1e03eBF4KsfkTPTbmsQsmYMcKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFg1GYgfnItK/aWAZfaVawt9zeXcwHwYDVR0j\nBBgwFoAU83FdgIwjdaV4/+4tL/P1jVOw9UUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD72Cj+lCKH\nzNdzM4dLamwQ5MrEQBC+HVePnE1etVK+CwIhANb4XsOVsgy0vFFam6bcWV/lyddf\nBRaXyUfTYHhUZJ0s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcd2FZclZidIi4p8N3UPpzYYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzVjYWUyMi1jMDIzLTRmNmItODIxMi1lYzA2ODRiMTFkMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzKek4g/HtqMXb4ob57mKE34TTgV9KUCTDNBDkA1RbvhXQ\nOrypi9AYC0UgrA7WCQaMO3b+YAHDfTbgg9nIH+Ugo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU83FdgIwjdaV4/+4tL/P1jVOw\n9UUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPgORfyy8KTNnKgQtO3yzX/CtabnFY9jMMaVGQtP93HGAiEA/jJNMEGA\nnVQJyQ6E7Vk0LP6zg3CRS39wv/GmKh5SUB8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAYY+Fvv/AtJ4GFK+xrzYIvyHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQyZDQ3MzUtZDQwOS00MTNlLTkxYjItYzY3MGViYjBmZDQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmQwMDgyOGYtYzU5Ny00YmQ2LWE3NjctMjI4Njk0OWI3\nYjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN/ndvpDk1oscxdBIbdf22fgt\nxBNct5/KiLvjQlS+M8amkZkCb1HHZf4sD2GXpSBASXqATAVRG1CyMfe9CdrCUqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFg1GYgfnItK/aWAZfaVawt9zeXcwCgYIKoZIzj0E\nAwIDRwAwRAIgO0hKM/mK/DWBQzXJMilTkvYv/s+ZUt+5xFnO7syLF1cCIErGTvof\ncpgEuim60NSCuinnDag2vm/4Y5MyP4XQt82C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2267", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2267` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAX+m+LYwXpBVqLjukMcmk8wjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0MTVmNGZlLTlhMWEtNGVjNS1iZTQ4LTU4MDBmMDNmZmUzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY2OGQ2MzYtMjVj\nNC00Zjc4LWI2ZDQtZWQyZWY5YWExNjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgtr5a6BQ+Gie7pJGTNf5CPO9yuPR9lQXIB1kIOkKPhqdnScFeFLNAig+9ueH\nJB+ujrKsQ6s70xHBzEi9Y8AMG6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDcd1LtXCzOpDlUYsXLRDBvNcpsswHwYDVR0j\nBBgwFoAU1HHg3cDqA9AIySb31WMDp1/v5j4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgbs2T7FjnvBfb7tzNlKlO3An5c9WnNs0sDiMH5MghmzECIQCXOz7mph2z\npypF5e4bqmGh9Dj121RXeb6NNXhf6sy+/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeo++K4l+o60MBvzAzOgTY8nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDE1ZjRmZS05YTFhLTRlYzUtYmU0OC01ODAwZjAzZmZlM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuDjTW2mnM/Oq9BWRRiEXvAbJd0wff2nY3JLBarorsQ82A\n2wqiXcuyPXK6RmIj7R3YF6CTZlyDlMaHqZ/5atVyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1HHg3cDqA9AIySb31WMDp1/v\n5j4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKeDIkhKQK87OrUi+Zv+8RHVTWGrwKU4hLbuxAXypGfnAiAKtGVVU4EW\nRTI0FQzuskQmZiVC89dHmEGWvw6bJPNmIA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISASU26AzKJLM/PDAxvT9FsHwSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY2OGQ2MzYtMjVjNC00Zjc4LWI2ZDQtZWQyZWY5YWExNjg0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjA2YzU5MTYtMjI1My00MDI1LThmZmItNjJjOGVkMTdk\nMDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZUBi6ju22x5BnSrAp0GcnZMY\n15bKzCtQaLifIOAVuLKY4wZ0YDL+HVEqQQ+ijRcz+2p0QE35AWR5VaRL9CzwIKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDcd1LtXCzOpDlUYsXLRDBvNcpsswCgYIKoZIzj0E\nAwIDSAAwRQIgYEG3WJUw5mBqMIwryOmJqqfW7XRzv01Oh/cthpPRdBICIQDTWQgG\nrpwfrq1TOMJxtvpr/RjE5JP4+i0a8/HRgdWwNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2268", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2268` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAXh+WfQVIhKROttdBiXBKK/nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViMTczODE5LWZiOTMtNGNkOS1hM2IxLThjZTkxMWNkNDhhMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc2MTAwMWItZGY4\nMC00ZDg4LWFmOWUtNWViYTBmOGJhZDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq4q2qMxPvPPorX+EbfQODt9TbK3RbwwltELJEVHD9LQlpqhAUFzZzNkxl5bX\nVaNwxYOeA+C80hEIXycXEMYX9KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsIz2rWX+3OgdZXn+nvJbaw6ouqYwHwYDVR0j\nBBgwFoAUzNp95rw0HN5z50zqh//gmqR6j5cwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgKgKMb6Cs8z+b250JYPcaTVqDrZ3BvjHhukF+28mXReYCICtJ/PkPXXSO\npUwQVFlCVKI+wXdu5rvqizwfHhowvG1m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV6pjIwNr66uXxquVtJM9/6vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjE3MzgxOS1mYjkzLTRjZDktYTNiMS04Y2U5MTFjZDQ4YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATY/OX90DrobyqLNobxPSciRsqhMhUr6e2bIhwo/EVUbjUP\nPNWrEIEYibh2+5LEbEVz6JjEpbHpXZq670kvOCjco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzNp95rw0HN5z50zqh//gmqR6\nj5cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOdAz3OvNokIeJDq6iMDG2MYWQzh27873aykPYSrk60WAiBzrOkRYv76\n5eAr3DzpzEzw2j2yMsRzbMeiGDf+mlFIKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAZP6fVRtODM8KAa7+9zm/fjOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc2MTAwMWItZGY4MC00ZDg4LWFmOWUtNWViYTBmOGJhZDU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmVjZTViMjAtMDVkNC00NGVmLTkxY2MtM2VlMzdjNTcx\nYjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnEFbDZeHxOK+oOkghlW5PYzk\nrOEZO0HV/mIqMhYATkXJwWDEMWzlLk8I+ZEmYYeAiEhd3i9DJQOC3WwMBTqlK6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsIz2rWX+3OgdZXn+nvJbaw6ouqYwCgYIKoZIzj0E\nAwIDSQAwRgIhAPMHiKVGBv9oE/wQBR4s5EC96t80zcAnDAXYwmds4QxwAiEA8VFk\nhe6nK0uUG8jvxrN/agfafTpJXCpOxgfEJ51kkEg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2269", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2269` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAe/v6JnYeqJcUSkiQw/30jEaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwZWQyZTM0LTk5NmUtNDg5ZC04ZjYxLTk0MDczZjZiYzFiYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjY1OTM4ZTAtMTM3\nMi00MjJlLWFiYTMtYjNmODlmZTdmZGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw0KU/yt4sPXY+Cmq+UmbdUx1luztzKjW3advZGdmXr/5db3oqTtAXCsh2Tjr\ntLywPSfTDjkHhD8y5QzChDf9U6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsaP+/tcz/6OAfCo8deZ47yU1gocwHwYDVR0j\nBBgwFoAUz1/zxGM6OoxA4qK8y0LSFqbnZaMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDG5zucONIcKGn1DDB7uAg19LEJHQppVDNKgAQLOaB1mAIhAMnTSAdT\nMyr4SRi7zxU1BwvvpKCSE0PA1DZOYWgNc0qc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZgun4MZgrkGR4IWTZPuiskWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGVkMmUzNC05OTZlLTQ4OWQtOGY2MS05NDA3M2Y2YmMxYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbwNruRZ82G7GEcwaIAhUwYUlfCm2UYJFsYnE8bd4UA1VW\n/N69NTd/3lFsb/joNOkn6bF7gI2P+KG6CltaGT5Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz1/zxGM6OoxA4qK8y0LSFqbn\nZaMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEyz4Wlkhhh42+m5+V84VoNg98anCa7Qrx7iS8UNI4GkCIQDYocZ/Z9T3\nj+aeUOgohRZSP1BaKPhdVc44got0hprcig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISATyUJv4ri5UtvTP8YO+DbX7pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjY1OTM4ZTAtMTM3Mi00MjJlLWFiYTMtYjNmODlmZTdmZGViMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjMyYmI5MmEtNDhlNi00MGUyLWFlMTAtMmI3NmYyODUz\nY2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBlzA/muHww99XwUi/3ZmL6Pi\nJncRhhg6SS6lwBLiTtmpiT3lpJv0wEIQiAfepV0kmkqS/PVDB5jnT5QFjUp3SKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsaP+/tcz/6OAfCo8deZ47yU1gocwCgYIKoZIzj0E\nAwIDRwAwRAIgIZrfKBWOwASU4qEK4xzBIZRvdIBQ1WyVI6/458voE0gCIG7E/eCQ\niFRqxw9bH0aL0BiPgo3RmbyZEkM0C2mwQR9e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2270", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2270` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAdIWlpPoqHXpxvNNmTuwYOs4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5ODRmNTFjLWFmOGMtNDlmOS1hNTBkLTM4NzgxZmY3ZTNhNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWVlZWFlYWYtYzkz\nZC00MzI2LTk3ZjUtMTNhNTBhYjI2NjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEtNTGgKjARUUymKlhyXd+DVxWtDC5M0BLVQf4Bu78L9sKbG49tyiUIZHvGty\noyyrMznTLtrXT3eivUNPy/jYjaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUerEgkWW9K+9dz8/kQ85cnObXqU0wHwYDVR0j\nBBgwFoAU7tta6NTiBTQj8D1hC3fciWAxJeowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD2UagEZxQK9Ry152TbLcO4kWr2vRsmwYNkuNq4\ntCeAHwIgNGHuvcQPHitw6CzVFcj/jnVA5q+ysErdPipe46mCoaM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcJP8pN3t2IyOXXujn8qHkn2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTg0ZjUxYy1hZjhjLTQ5ZjktYTUwZC0zODc4MWZmN2UzYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAuRuj+bd9lI+DzYDBHsEkQ4zh8B82Zyq1OaY/L9ZrLDZf\nYPhyj0ccSTTaA9hf5g2o8n9hRogO/BhIPnvp/MfXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7tta6NTiBTQj8D1hC3fciWAx\nJeowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGV8dQksU1GUe2Gq8w15lfJ8FhJFgq8Nj+/USvBmxlq8CIQDJaT1aabdD\nDoXikVdt/7mW7nK79ZABZa9eH/gtqGWLPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAeto4aJC5CqPjN5bdlMP/SKiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWVlZWFlYWYtYzkzZC00MzI2LTk3ZjUtMTNhNTBhYjI2NjFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNlMGRiNTEtOTY0MC00MTJiLWJkMGYtYWJhMWRlMDZl\nYWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfh8WpwXJyJoEcKjCjFp0FTzg\nFt+ZJaTQ0wVuQQrFNPYZrWTXDaFhI/Jn6ATBjk5/MiJUzDk9TSHR2LetkOf5XKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUerEgkWW9K+9dz8/kQ85cnObXqU0wCgYIKoZIzj0E\nAwIDSAAwRQIhAMrCi2ST39qkNBQa2++zD+3E/7bS6rxRaouXRfsqr71YAiAomJ2V\nJACIz4rFX7hLbkXcxm8NcbT9Yw7BFECkQR++PA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2271", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2271` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISASmOfJz8hDVem61ODamCJaHwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmMzc5MDVjLWQzOTgtNDIzNC04OWU4LTM0NzZlYjBlYmEyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDUxYTlkMGQtMTcw\nNy00ODJjLWFiODUtN2Y3NTEyMWZkYTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWWiSRyWk2/yOjBeOlFIeiUR+IJb0zNOgC937B+S0+KNnCP+guvxX2TYqdmaO\nVzqRFKD31XuRQue50f/Pm0khr6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+yHDhOdGGrE2AATIUk/HrBIKcE8wHwYDVR0j\nBBgwFoAUE2vLG7yrIy1Zr4gunVg3eNVW7zEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIBUkFTITmpezG5HS+KxR9UCWyk5gJ0dHXz1/9gx6\nnsgpAiEAo8KSsyBITcS1jE58pTXguhKqTGRr8er/AmYxAs+z/eM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeTOdXyVt/bfA33ATuDgy7qkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjM3OTA1Yy1kMzk4LTQyMzQtODllOC0zNDc2ZWIwZWJhMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmmj5yqLKP/z4WGoK3g2eJWo//T/u5lbpgWjg5tnJHn2Gi\n9ZWdeWycCn5ObDF4Cvt5KGhdbZ5PLtNES+/ikrO2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE2vLG7yrIy1Zr4gunVg3eNVW\n7zEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaq2AfOxS7sdVQYDIlz6jSXwfE83bDsrVHhOUHPi8RlsCIEP3jdxzehIi\n0WflLcWZJ+vP0GG1Yjh1wHXrSFaj14Fu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATHgnVI4Ducu3X2eThr+Q0QcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDUxYTlkMGQtMTcwNy00ODJjLWFiODUtN2Y3NTEyMWZkYTBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJlNjFkNGItOTc3ZS00ODJkLWI5N2UtODU2YzcxOTc4\nMzRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHt1PCreIMdFjNAAVEWyElrnL\nU0ayGH956K6iAODPTXCDbX93g/O7YfgoKc3g2cG3rdcbHk0N0OaHG1gQ77PW7KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+yHDhOdGGrE2AATIUk/HrBIKcE8wCgYIKoZIzj0E\nAwIDSAAwRQIgQY3Dmo5DDRfN99OBf/aS8RFqsWtz8W/tn/90jh2g+IoCIQDw3Mwj\nBSX6453kAX44/3ZYWae/yokstebMZhrk2hSKag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2272", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2272` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISASd6kLz/DXCfo2L3x/f9fRf7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjNDFhZmFiLTkyNWQtNDcyYy1hNDRiLWZhN2ZlZDNhMjgzYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I5NzY2NjYtMmU3\nYy00ZDk4LWI4NjEtOTJiNjJjMDI5ZTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOxT3wj5YRwocGdehoeBf/2av2glyp7BZkGlUJN4n0korRdphnA+vjJxVvwgy\ndMu8bS3hWADcHybZMTUGXb8e9qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+JH+ZsYwxmd0dK/8krA7I9UKQjkwHwYDVR0j\nBBgwFoAUHyaFg9iHqqsMoaf8+dIUAILt/SIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQD2n9RdIZODfCKxzZHklopbILTLCnRG2WiMxgJU5tyNuAIh\nAMtFhMZKdU6YDpyF58J7fvOyGoxTnoNiIOLj6dyJsW+U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVANnfqF0K/zCGysf9iDhpKVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzQxYWZhYi05MjVkLTQ3MmMtYTQ0Yi1mYTdmZWQzYTI4M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATszfzGThtqJ1M+pw/yO7oVjOTPZwZt00MKFSZWSQtVCuM/\nqZUwz8yfsQPORLzLT4Q45eFWSs1ahhiJxu6Y23/ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHyaFg9iHqqsMoaf8+dIUAILt\n/SIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPB+LvV4IacfI5n3QPkedXBxa1YfufgMolM5pAsY/VcLAiEA4ayGNGgl\nNeoMFudEOQZI3mV7Yw9f27dvJIOHfGedbRE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAZlYcYYctRJ7WW3KVlZPdi1JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I5NzY2NjYtMmU3Yy00ZDk4LWI4NjEtOTJiNjJjMDI5ZTk4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ZmOTE2NTEtZmZiNC00NTBiLWJkYWMtYWM2MzI5Mzk3\nZDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpUfNAxvfPlR7l01qa405Oc9I\nD2jS11EUzuMu2zCN760Dc+Wxvp5h9+Rfy/iYUktbyO9NneatULicCRdaTsDaJKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+JH+ZsYwxmd0dK/8krA7I9UKQjkwCgYIKoZIzj0E\nAwIDSQAwRgIhAIXqPBzRyjDFgRgOrEnf72OiJb+AXHeVlBUwlhXop2scAiEA3ITg\nNHNzIi+XnBFyeMw2gHwYAbVz5VcZWnBP4xaR+bA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2273", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2273` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQ6wo8kkSXIauOwMqv+JiKaDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyMzQ1NjFmLTM5YzktNDVhOC05OWE4LWUwNzI1M2RmMDEzYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc4NDBmMjEtMDhm\nMC00ZDEwLTk4Y2QtZDU3OTgzZTc1ZDMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx156QuUygDCPjMlWA30xnQT2QO90+QcmpxvKWN+dYoq8r6mfAu45fjzILFyY\nZM97DsWsvdfIlseFqKAEPsvTwqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfHz1lD8L4dI3ZAykdF0PZYgZ2dIwHwYDVR0j\nBBgwFoAUnEB4mFfFx/Vp8VVR+KkM2qIgo2YwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGbhG9VWkfktF8RFHSvO7Lr8K+XdtEqY\nN6oZ8T5hbEunAiBT8XeDtXS9k7F5uWcfud9A+QzPKBYNH48FXywsuxmdgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfJF5rBTLVWM3WH9ytL+sH2wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjM0NTYxZi0zOWM5LTQ1YTgtOTlhOC1lMDcyNTNkZjAxM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfOHmonRztmzMxh0vjIA2I9dvWRZay6flvtVC8lZ4lpOXs\nYH9hsaoMcIyhwvpTlqWSbzNGI1ZZ4j6MeMr3sM8zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnEB4mFfFx/Vp8VVR+KkM2qIg\no2YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALvPhVeBzceu8n2Wt+nUtgrl43iIuxM458LK2UDhFTrMAiEAkQOEx8r4\nignOIdll3rJpxjDJfidijuCTnTQ2ZAaG7rE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAT0pS4ywX0n/x2PTXMPbZ+XXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc4NDBmMjEtMDhmMC00ZDEwLTk4Y2QtZDU3OTgzZTc1ZDMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWMzN2ViMTAtODJhYi00NjI3LWJiNjItZDQzMDc5MGQy\nMjg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETUCyWYNGJlc3y5/ZFe2L6ojl\nQWZGsdNmGfodFB3Tgk3cpSqa3+tZmBxfF/CTzbnUju6AmA9EuZ010DHnIFVTQ6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfHz1lD8L4dI3ZAykdF0PZYgZ2dIwCgYIKoZIzj0E\nAwIDSAAwRQIgLEPtM4nN6JDtAFQAbSij4qviy3x2C1m2TId/CreA/rcCIQCvsD4v\nGeUjEzPbvNB+HzadyNIafOyz24cqCArgnyl9WA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2274", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2274` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAbg9aaMBZLv/t9V1t65Kw4osMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiNDAzYmE3LWNiOTItNGRiOC05YWI1LTE4NzIyYjI4YmI5OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBmMDRiYWYtNDFh\nMy00MDAxLWJiMzUtYjY3MDMzN2U4ZjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8ncNjhZcLpeCpMR3d6GeOjZrUAiz4WNuf8Xe0ynPBy58SbSn3e4gvRq5P2Fq\nNdDhsmPO6rQYcx2x2/m+H9XfjKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVARmns+GIfZKilwxF+zjunac/QIwHwYDVR0j\nBBgwFoAUjO2UjXaNV3qIN9GWZny2amV4gp8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCICxGzeOdMPKPuOGTVl6VkkNlaIAVgmJ5\n6pHdLAiwTmNLAiABUuFh/lHvhL+tvHUgH3pi0uY6e0wVpib4vRYSfVVFSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWLH9iv6mIZYv/+vkHFJs45TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjQwM2JhNy1jYjkyLTRkYjgtOWFiNS0xODcyMmIyOGJiOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxPLsy3ghqLlWoPKd2hifPHhH6dqHAz8FHD+YT2/MYitrY\nfUHhWrTJJFObWedi3ktSrrtcNbuN/F2MAIGAVe2go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjO2UjXaNV3qIN9GWZny2amV4\ngp8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANtG6lc+EHn1WU+6dKiOREDIFpmSNNu00NCDD/x+L6XQAiAktDvzHxgY\nSvfY/Yvz3EYvZELBpnwR826+1niGZp1DMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAeAek01MVE2rRrggF/vArJ0CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBmMDRiYWYtNDFhMy00MDAxLWJiMzUtYjY3MDMzN2U4ZjA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWRjM2I0ZDgtM2M4Yy00NDkxLThjODAtYmE2M2U3ODg0\nNGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPCgi+8+B/P+BYuSioatRYjbb\nMZ5db5Ke21OHCAHRh+xrsY/3tYPHzlB+kWMQutxCYi/45fotTW7O9a00YndAn6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVARmns+GIfZKilwxF+zjunac/QIwCgYIKoZIzj0E\nAwIDRwAwRAIgFubOlYt7H7YuYvCoYxeQLeLOtw1QlW1aER/W12hKBAsCIC1zLQKW\naxoWj1iCHVzdTqfZlzBWq1+JJO/asd7ACLrA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2275", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2275` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAfF8d03MsQx2Lu+gXMxY5bL1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5ZjhmNGIzLTg1ODEtNDk2MS1hNWE5LWJmNDZkM2QzNDcyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg3MjYzYTEtOTcy\nNy00NDM2LThlNDUtNjkxOWE5OTk2NmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk/63DyAtA+plAzAt9JK9PaelojIqlZesftgiLLuJA0xz+ZQhM5lBjdnfGBU2\nt0B6++PJM+ndVEX1N1gdFetdeKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFI1WR+gQ1LygIO3f4iN8Les4m5+lMB8GA1UdIwQY\nMBaAFK+O4d/yvV4XHfqDGOaJ00EhqvYGMAoGCCqGSM49BAMCA0kAMEYCIQCP62/V\nEN6hebEurBVioPosPG5D314xEQuydUY+g8WYyAIhANZ6ASVSQMImZ7jCsn4vNGnT\nyNODSGk8UWH6xJOvk5Qu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWpfsUrQ2knTmzP1Ld8RghQ/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOWY4ZjRiMy04NTgxLTQ5NjEtYTVhOS1iZjQ2ZDNkMzQ3MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHlPmOs0S+dgRNJyzLcCvSAe651UO4ePoepbDhbsOQF0Wz\nzYjYJFyF1kK7ctGinZg1WgM7L8Kg/aqJrrnG0tx2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr47h3/K9Xhcd+oMY5onTQSGq\n9gYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgePMst54vegpvcqHDwy33XL86XxXBdButtLIVgZ440ggCIQCzqAyFsMLt\nz/1wG3K5qYUBFoJ2Z0xIQsNWVF0FEfnLKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAd51Kh/aBC5KPHB632hXM8XXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg3MjYzYTEtOTcyNy00NDM2LThlNDUtNjkxOWE5OTk2NmZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjI3ZTJhZWYtYzlkZC00YTlmLWFlYjctYzJjYjI4MTQ3\nMDk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuUBhCyYezrn7Et10PSuh+TDO\nQenHGCaSJ4F2XH+qEj4qU51jB03Z3b3V8fkga+mIsgUf8YmUjEBVV1XNToZGuqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjVZH6BDUvKAg7d/iI3wt6zibn6UwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAtRYmvD+PzFgG15+Q7uMxIuQ9qOTn\n6jurSJZUFXQ0nXoCIQC8i9fLyzKUGYcuhVa2qyqSO1s3p958tl0TJcyeni/mYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2276", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2276` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXAqlERtruiWriNeG2QR/kmYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyNTI2ODAxLTcwZWItNDJiMi1hMzdlLWQyN2IxNWNkOTg1NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTExMDEwNmEtOTYy\nZi00N2Y4LTk4MzgtNDE5M2E5N2ZiNDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPj0UykimxeUM4EX2FHjTX9Xj652VG9h9BqvUv0Uxph9vHvmi+ATTvRBaPxIb\n6ChBPqK/QZh6oDyE4WHkKhGFlqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFO+CiCYnfrZn9CGkG1ma5f/XIo2CMB8GA1UdIwQY\nMBaAFCqnSQEZoJWAcjbiZouvOMARTZUJMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAvVLLAtZY3mEGW82hegGWVhtsyJZIgrMZ\nV18NPD+lDSwCIBzTKd/z56LYM+fPLT/J47/lsgvrnXHnHZp9gv+auduK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS3sT2FvEJfvMezfikuaYYebMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjUyNjgwMS03MGViLTQyYjItYTM3ZS1kMjdiMTVjZDk4NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTo5criA+z9VRNnDbX4K9/rP0GougfkY1RBmThS7UcenJA\nZpF2dT2x3vFWBogOBg7CNskSDUAJwrNVwt4jRxWEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKqdJARmglYByNuJmi684wBFN\nlQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG014sVeQmTXt/HcJlwqhNgMnFw8x/2OT66h9+FSwZpYCIDPRUNrUcd6A\nsQrKXUv1nXd6KkCP/BWVXrQmAsWZ5NoL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYEbROQJfunzYppCfMRXaVDWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTExMDEwNmEtOTYyZi00N2Y4LTk4MzgtNDE5M2E5N2ZiNDk3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY5NmJjNDMtYTViOS00ODYxLWI4ODEtZTQxNjEzMWI3\nYTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+Tw4oktx82/qMIlykxCZ3SSX\na+hDbDL8J24s1c+QO2uLZuShmky3XGIIzZSmT5N1wreRzBRejtTwdvOyUz4ItaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU74KIJid+tmf0IaQbWZrl/9cijYIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAmblKMY7535yfdH/3GzRJ2bWZyYVu\nJUDAkq2b3aSuG4ACIEH8EY9vtVckjjwr/y0pvddAAABSptgicoLHeLYH3X6b\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2277", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2277` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAb/efgRtLulBjqDLwIEhz/W1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwZjQxZTYxLWY2MzQtNDhkYi05MGRiLWY4M2I1MjQ0NmQ3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE0NDc1ZTctYzhm\nNi00ZjM4LWIwMjctNTgyOWUwZWVlNGY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEthGas3siQrqSodCX5ep5u2VTifqwc+5mYqy2Ejj6h+MDv7QzBM+x2PTqsQfj\nLhUa36aKEH0VMtq60dIFl1SFyaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNhq06RhExxnyU6OkQVBcgx0BlfwMB8GA1UdIwQY\nMBaAFDDPsZ6lFLIwaI7e86DtrEW5z5BwMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiB3gBH6uCLOyXfp1wc6jPOAKedUXZsKsceH\npNGKZjVmPQIhAPAITQ6PLfo4aOYEko4RhxPiZMiVwpBY4MDDf2EqBaKK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQmVsaG9fe6KxfetFsrXwPxsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGY0MWU2MS1mNjM0LTQ4ZGItOTBkYi1mODNiNTI0NDZkNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFqH0OFIk8hUnhWIFua51zfwd+QvZ8aCPVXcNYgADUxCwK\n8hnCviiclpheuv7d9HkDOUH6VZa4b/w+DrVD7slyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMM+xnqUUsjBojt7zoO2sRbnP\nkHAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPoEBvUG/9oY3XrJXwUeZ9vA8Y/yIOXdGJ7+b1bVsQOAAiEAutV8Bqbo\n4G9af/uj0ZgrYUCASQH+wqKBZe1p/KKsHfU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASJcvsmc34zqwrVutXjIi/FpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE0NDc1ZTctYzhmNi00ZjM4LWIwMjctNTgyOWUwZWVlNGY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMThkZjY4YzUtYTk0Ny00NTkyLWJlNWItNmI2YjA3MGRi\nMDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgrFi96R4rZQ+DJ5yCD0Y1soC\nFRptGeiuWvu4jWABasoxtMSSsXFcRECE9gQbeYcc+6dC/MGPi+qSWIplUwX6TaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2GrTpGETHGfJTo6RBUFyDHQGV/AwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA3XVzKmz6uw2Dkybb2/V/8dz2BLQm\nhIk+0YHtlUOs01gCIHzYH8FXCUShjcF86JLLW7dssFv1yTYDL7QhotUiE42m\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2278", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2278` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISARdZc605wx/GcYbRSSIhFypdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4MDFlOTc0LTUxNDgtNDEyNC1iZWZkLWYxOWVhZDMwNTcxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNmNjY3ZjUtMmFj\nOC00ZTA4LTkzMTMtYTZjYmMxZDJmN2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnQcrZQ9P5SCpBiC26AvT8Rm4pA+XGIUJmrqgbwVVbR7i6vACWVIfCRSgtDNx\nFekW6kvkNXQ1Z6zjD9WoZluMmaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSSuekJfEE7KvgqfRCilusO045rJzAfBgNVHSME\nGDAWgBTRSOnOBh+gWDfIOGUtyQbCUKAH0zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCEFnrG/OwUca+OWvV++Tby5z2brCYI\nD2bXrtmHXLbcMQIgPCZ8ujamcuLPohphSMAae6IwteHc1y09kjx+CmUiKDc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYzrIg2qU4ftxMw5GvDjRTBDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODAxZTk3NC01MTQ4LTQxMjQtYmVmZC1mMTllYWQzMDU3MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1qoyYGxhUfV4tty20JQtAQErTgPhZrlMga8SrDrZoRh1g\nX/Nm+uWYo7nlYkQklj0vhNwGmt+QyaEHV7JobjaKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0UjpzgYfoFg3yDhlLckGwlCg\nB9MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJiVDJtOQmA9aQsvcKA1WBV2KrptsG/AD2JB5W6j2delAiBFJCHOZEpn\noDegsJiX3hoIiMW+PJdoi4U4r1Dn/cSIWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAak0gx0XK3rp9SXU/pZ59qrtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNmNjY3ZjUtMmFjOC00ZTA4LTkzMTMtYTZjYmMxZDJmN2I3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFjYzA2ZGMtZDFmOS00ZjQ4LTllNWQtOWUyYzBlMWU4\nM2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbkIA/DEwb+LRSWX+YTvbOgag\nJ8gSbtQ/MOiLa5ygD1QLCRjgysShKEIcuHVSLUnkxnSS+x157jCrjKAt6sfXmqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkrnpCXxBOyr4Kn0QopbrDtOOaycwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBXSfOw6APbCVufpWF/4ERxKqQ5r5xN\no0T97Gkqp3kIvwIgFcpYx/8yiTufIncVDMLxuVRL5h4ksNYxBRYvOjbPKR4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2279", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2279` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWsyidKIHSDbsR48elAgOYw+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiMTMyY2Q0LTgwY2QtNGZkOC1iZDQzLWQxOWNhZmZmNTEwZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDkyOThhNGQtNzg1\nZC00MjA3LWExYTMtMzhjYmQzOGU3MDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9F0EX3WjZSlGMNO96T1NvaAxbiaBNdKl6BXwkTa0eXPMMheWKh3LCaR6jEAy\nRnwK0pU0PwkZX/9+46gykSpCGKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsonC6GqWgcDku2gWQbsOzDBkHDQwHwYDVR0j\nBBgwFoAU7lMUIB/ZlJgz8yjGu7ESOGB0WvMwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBVTiQQoUuOCiY/\nyQNJNbqUOyrejZSnLcpYV3paw9XALwIhAKtq+sHypMGnRCAJ9t9hJ/mkZTyfkfhD\nyfd95SDtJx7s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeO5+e5wjYe6kloYSK0xway5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjEzMmNkNC04MGNkLTRmZDgtYmQ0My1kMTljYWZmZjUxMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhzHqIlbhEt37XMpFc4SY9RkAJeTjAO5WngHGWcpvQ1/eY\nQLBLbAkPdtf48jaK0SuLap2fvdHVBCsu0yXrftjgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7lMUIB/ZlJgz8yjGu7ESOGB0\nWvMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUoQdJ6MaE6gny9CTG2NLGOGTk+qVEz7amPXw2f5fiQACIGZzDN+mtXX0\ncz4wEBfBOVsCsaAh6W0xXZtMAeUgr5z1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAaerQQmy7nYEykbFP/6T/4OEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDkyOThhNGQtNzg1ZC00MjA3LWExYTMtMzhjYmQzOGU3MDYzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWEyN2IxMTktYTNiNS00NjNkLThjNzQtNDJhNGQzMzQz\nNDBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUWvpxi7hXhxEkWKe4a6jYZVa\n2e3NFGV2B1ZCxIUUIhgZx4MG4wN9KciiK65lcPw+bXzzLvmklNnow63qCa+PPqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsonC6GqWgcDku2gWQbsOzDBkHDQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAj5HcoTaJoT0BjXqxDJfYvfFtcLjz\ns+bafax0O4ymNMwCIQC/hDPHG30xKMHwFCRreM6++3XBlXY3Qq7hjVJiYrymQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2280", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2280` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAdmExSzW4ZhG0XchXaB/d45zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkOWZiOTNiLTY5MjItNGJlYy05YzE0LWI5ZGM2ODhkYWM0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDcwYmU4NTAtNmI5\nMS00MjZkLWIwYzAtOTdiZmU2ODNhMzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfFY1KPk+VMR9GHYCx9SaIhMmVXCaSRpnDYW8y/KBfMBClW9zGjKylzMVMi1P\nD5gDstO197tpjedEg//++r3AhqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8vZGOdDbCiccYWFC8t7k4kGplOgwHwYDVR0j\nBBgwFoAU4pBZdPwxXQtixhqSYUtpIW/fITAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAxKUohwKBnuWF\nETlstaGmJu0SmEj6Oej7IZPtkd3ByGUCIDeCY2B9AKDsXiflUFqg61fDI/IO+LAB\n0QBnhLNgxoRU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfy2dxCEGfj0fih+200f4g7TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDlmYjkzYi02OTIyLTRiZWMtOWMxNC1iOWRjNjg4ZGFjNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaE6pgEJCJyruTCwk6l6kC+z7x+B5EO2lma/qFMQEAXexq\n2z7H3Er8VCffrn8GEW0CKjP+0aWhoHz3prvIJaS3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4pBZdPwxXQtixhqSYUtpIW/f\nITAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK7jdtxCtOWUL3uF6vM6oSOjt0O5GbT8o5oiJvoZxGICAiEApF1zHol6\nYyWE4qOY5jzkahxA8gKAS3qpBVGqJd5JiH0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaiL3K22ZkxTJDLwM29C2oAcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDcwYmU4NTAtNmI5MS00MjZkLWIwYzAtOTdiZmU2ODNhMzhmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDMwZTFhN2MtZjJkOC00ZmRjLTlmMTMtMGE4ZWEyNGQ5\nZjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWw6R2fEfbVGWHqXmWWhnfuEj\nU0cDQbds2CB6W3aLB6sctdwQt3ARCGH1wN3UT2T5dlxeYQJ3EZKGmY2illE86aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8vZGOdDbCiccYWFC8t7k4kGplOgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAqA+nEUywNwAS7BIJPVS6t9tyPjvS\n05tn8bNDFcHRc1ICIH2H4IWLqEjbVNHx/NqMMJATEqEvXkzWLAbKW/DIEpDO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2281", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2281` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAXgje3xyyG8h/yCK5Hy2pWOgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2MDQ3ZmZhLTIxNDUtNDdlMy1iOGJjLWZhYWExMTJiMjc5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBkNGNkYjgtZWU1\nYS00ZDU3LTlmYjYtNWI1NmQwZTAzOGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmB3MlFz333abKZ3GaAoMZFuL/K5VvJWTYvb+Sh0OfmOBZdvfWpGopb4uUyQO\nKbC0R+glaog0FYo8AQpm58is2KOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0nVSVOB1zEhrnzDIHXnA5hSU/L4wHwYDVR0j\nBBgwFoAUZOjmPrxh42bBDjFvrUKTLPEviTUwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA1h0L+Dj9xRjYNpWY3mKf\nN0i1piFRlgalfOsjpWxUkbICIHO7TVXeZF4OJrMBrwfOWqWfDigS91IFuvXxjK2r\nrrxf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAehwp4lcnP0cBJhh3sJ47VbHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjA0N2ZmYS0yMTQ1LTQ3ZTMtYjhiYy1mYWFhMTEyYjI3OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARf/RfiPU2Xufg4O9KHHqWKd6xSSFSzhdXXU3VvAIwcKn/G\nPH3QqIwuK7jyk49ys4py7Wa2zhYuunotsSnmFCo8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZOjmPrxh42bBDjFvrUKTLPEv\niTUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc3pLoQjXffhdxVutZMYR5E6tteZE68DuwfMLhTnl0TMCIFOK7yXdYiNF\nGnZ1D2O4FRYQdLewVNqHKv2J+nBTIoWt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAaBVVEq1sxZu+p7mhImCYcrCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBkNGNkYjgtZWU1YS00ZDU3LTlmYjYtNWI1NmQwZTAzOGIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGRmZmZmMTgtYmUzNi00ZWNhLWI2NTctN2I4YmVmMTBh\nZWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPFh9s0AN+58TSsqaByT8OjZB\nNkUyQ/eodRhqEncG5Hfojy9pbFmy7fP4UYJlOjY5qqsPJmaTMe2dhBeXKgOk86Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0nVSVOB1zEhrnzDIHXnA5hSU/L4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBc/ag8k9TAtivxisa4B77/Vzsr5hNI\nRscenc5ehBkSvQIgO/w6khge3T7MLBIncWqPJ2UaO82PrZZBNy2MA9k+u1Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2282", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2282` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAUJ6hS+UkyKJ7J9uGkkroUfpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4MzE0MjEwLTUxN2MtNDI1Ny1iZWVjLTE3Mjg0YWU0NzNlNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE1YjBlZDEtMGIy\nMC00NDI3LTgxNTAtNmFhNzdlNWQ0NmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqQmkV9HIMwebb5O/JerGjyqfHz5T5n4XvlNULQeM9ZJdwwZZZmA8S0JGnei4\n2my4lElt2lE178hYeioP2Mx9OaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Wu2XiK92Wonlr9QtTkcgEuCvrMwHwYDVR0j\nBBgwFoAUMf9BPPwHqTOoU3hBWBd2ebIsA5owLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAL4jdt\n649QYyk+FEwb2LR9fwbPiOUbrrQNjmicTAOqoAIhAMfJNEiNNMHQ39g+n0Kyr4qJ\nqfpTFqmWhOpEXDecSDh8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAROGe//UV1X2fSAeM9NwWOMlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODMxNDIxMC01MTdjLTQyNTctYmVlYy0xNzI4NGFlNDczZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2R/srb+JUgeQvmmWDAeV5NP+7KJE/Lte//RZDLnq/w4Qy\nr20H4+VGsd7IL3k8jLjQe8lHnzrFh6nRqqfF0IJso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMf9BPPwHqTOoU3hBWBd2ebIs\nA5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO9AzBCJ4wcyoSpEMYLzXaBTAcqVoMqicvHzp3hfGzB5AiEA/CHnjJco\nbmMNujGZyWeUFU9+SmcVfJailPoZzOCxgNU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXbK7ijx7RQEuRpv1jT5h9iXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE1YjBlZDEtMGIyMC00NDI3LTgxNTAtNmFhNzdlNWQ0NmY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjZhOWM5ZTMtYTI4OS00ZjY5LWFlMzAtNmI0OTM2Mjli\nZWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx4t6KNI7lvQ/8BBfTZuQPAPc\nWA4aJIFADfZ6vpsUKTP+qqF0To3WrmvF3gd1+9X/37RPY3TQlCipmD5u/xrSBKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+Wu2XiK92Wonlr9QtTkcgEuCvrMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA0HvQ7dZRCN6nguOGTo/epZYwxW5m\nAjsZOTyO+gW96R0CICPSsLcs3SYM89m7uCka2wgYcbUpRBHTO/C/V4E7cHOC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2283", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2283` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISASgXERgRhh2qf88eGmsqttzBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViOWU5YTA4LThiOTgtNDllMi1hOGNlLWUxNjNhNGNjZTZkZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWViZTYwZGMtNmEx\nZS00N2Y2LTg2YTctNTk1ZTllMmIyM2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhlwMjgQWTQ1OLUOBtVZAELHi4QFeNbga6Q0S1CkrDUkl2+oo7ghZzWoJxCmU\nsRV+rKGtRCzTqKF1o2OCnwvJYaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqAVW/VuqiEYs40v9myjby99Y8e4wHwYDVR0j\nBBgwFoAUto3yST335qmhGtx18qK7JSZUWKwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBgPGEe\nQfvTOUwOinC4hgxyAebbxemXNsQfQpv5zHGzQgIgNBxnSgSQkLC4TAftGND6w/Pw\nauhXYPxT03jdEjzELjA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcGQxuEiizFaU8rBsgJsxQ/JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjllOWEwOC04Yjk4LTQ5ZTItYThjZS1lMTYzYTRjY2U2ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3u/CQbXs4EiCy5v0IwwAPkol20hP+ELsYVwIHuA6gGaGo\nV2xUL/6Qe520eJTB16wOKvvNozjYdbblYtYzgDPMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUto3yST335qmhGtx18qK7JSZU\nWKwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPGLt0yf8aQfjQoOllhw/vV2BFKjKOFkWWjS9+qoYBDACIQCVYUEzKjiY\nY7/JSB8uxp2P2SSleScPzSEZYh8T7uSX9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcTnBjUJD97yQCFc+Icc//bGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWViZTYwZGMtNmExZS00N2Y2LTg2YTctNTk1ZTllMmIyM2U5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGExYjY1ZTgtOTJhZS00OWJjLTk2NTktMWUyM2M4YjRk\nYWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoKqspd8APim3vFht/GIDr93L\nHtm4tQsRbmfp43F/Cj6cEIdVF4tRBBRhjtWDqZB1q+BHI+aUy4BjzYDKeEZB3qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqAVW/VuqiEYs40v9myjby99Y8e4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA96VCvisudCJFgw3VcCvpn3zcAggm\nz+fTpBfVo5A4RiECIDBQn4O5Stt9pgSJLBVZTOceNO4edwvsVO3kRTYPpV90\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2284", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2284` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATS8bYpJetEeqrI9xZdcTRptMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxNWZkYTk4LTQ1YjUtNGM5MS05YmJhLWMxYjc3MGM3MDAzMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdhYzNmOTktZGI1\nNS00N2U4LTk5YWMtYjQyN2YxYzg2YmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+RHwsRnbuOnRFDUZ986vAMWSgdSAfdsMgn1oFrc/W7U8aK/mg8Y65OXOemTF\nJrCkZy3m+yw8c8EJSXaOUKD+36N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDW3ziUnUMdQYmoDAe8FPZeiSl60MB8GA1UdIwQY\nMBaAFKqUXMoOVqksOzvLjeWBuGhyi16cMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiADNZlqMN20pfejjyffo5cEuKzYyABQgrsi\nCgCI3CsIuQIhALPkaagQPSD6TuOJHwgPK5gPjMkKRqLuYXm/tWlRVgmE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR7zfJhXdtq0oUmXPvpAlHOTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTVmZGE5OC00NWI1LTRjOTEtOWJiYS1jMWI3NzBjNzAwMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+dsirapjzpeCnWzMG76TZ2DhLkfDl6pprsg92dP6G546h\n1a+4ON98XCI7TnFKctd7FrdTyw9ZTFLjcZHy9jC4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqpRcyg5WqSw7O8uN5YG4aHKL\nXpwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXeJMAnQvAiVcq0TJeRH2oHGIsnQ2zr8x+3uJ/RuLU/oCIQD4bHAujvXW\nH7/AFfCj0HLWOfktG2RQw/dkDf17057Zwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAaeteZ8WxOWyfOMLoRZ/sMEsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdhYzNmOTktZGI1NS00N2U4LTk5YWMtYjQyN2YxYzg2YmM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjBkMzg5NTktYmRjNi00M2VmLTk1MWYtYzk1YjE1ZDkz\nMDQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVkRoPB/a+M2jrd9injvfD9p+\nyo8Y1cuW/R/ryQUis9r5yzP9WfOU12S5bKo6YkNfLzLFnWZlYPq5yfdNwd0wdaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNbfOJSdQx1BiagMB7wU9l6JKXrQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAmkVJThx/px61AEavpIfu3gn7zrPv\nCoQ5RpuQoUZj1DQCIQCQoeOlUF/hx6C1KPSwOY1RNctqXL2kOr7IPFBMYRw5FA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2285", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2285` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAZN3atwTQvggjm0K4PxeDWb1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2ZTEyNzEzLTdkOGItNDcyOC05MmU4LTNjYmVhYWY2OTE4OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFlM2IyOTAtNjQ0\nZS00M2M5LWE0ZmQtMTc2MWRiMjlhZDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKGVKf5Ceq+fkh9U9Ud8OoqsY0fRRUm1DHhsR6a1Yh9UkzD90T7y5W7LQ1SJJ\nUcdhoEG37Xar0Ox7CuTXdlCxPqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzB9vPjsxoTrpJWkrDlDd/ur5kCwwHwYDVR0j\nBBgwFoAUMgJkbpdo9eOOq68QoDxG8OojsIIwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgde88f2WvEVYK\nqxSEjXm2ZTSVqDUlrJeSWotLODuj5YACIAKm8/MwKMBBx47ABEkKXo7NaUuaQ0h7\nj7BDL95wWLFf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdiCcl/hNJtcyE+NAx7hgxmQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNmUxMjcxMy03ZDhiLTQ3MjgtOTJlOC0zY2JlYWFmNjkxODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQty97PfgbkB9OyIdK0m2TqjfaeuDheywAIYPjsdzhc5eLV\nDKinkKhBFHyrK99FFEpYG1qRQtUsmRMycf7DLIh6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMgJkbpdo9eOOq68QoDxG8Ooj\nsIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbNevdn0TtyWT2AVaiC6QW1Pa4UUxCkmCiDRWKQ7uDTsCIHafLIgIMncE\nEWlqiQFkC9hiwbRuP5bqxj0kf2KJBvZJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARNPa1LPuB475Rq0MPtX5FzBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFlM2IyOTAtNjQ0ZS00M2M5LWE0ZmQtMTc2MWRiMjlhZDRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGYwNDY0MDMtYjVjYi00YTU2LWJkMGUtMWFlYTYwMzc3\nNTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEc//tz8dzlv7IAyO0aCZgrBNO\nkS16FsXwpjFOH+KBYyXEbsy+6PboRsuYIDJTIQ6397tltknl++2zzEVM/tJNCKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzB9vPjsxoTrpJWkrDlDd/ur5kCwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEApcJoyrEqaAbelA20t+uvy5JFUnth\nyABoE4uPxit67wsCIGDfLfzwtaDFOJ7JgNOo5F+QBPewrbXaPZ7CRcsKGxu6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2286", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2286` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARnuKF/LDF96pxwPJGdKFc3zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNGQ3NGNhLTc0YjktNGNhYi05ZjkxLTJkMzFhMmZiMjIwYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U5YjM1MDYtYThi\nOS00MDI1LTllYTktNDViNjhmMjI1NmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElJx0kEv9oMnucxoiqll+4JpEHnUE93T1XhEKLNBjjhVbDcI7CaxZxpwm4Zy9\nqeNPj3ChxO3GUuJnKuG+Jl1U7KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnlxUVyLluEFN8wpfGRidduQfc3UwHwYDVR0j\nBBgwFoAUEbaCfVjQwDCBPsrU5g54IGe7prAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOfUG5XR+XXw\nTtvosk4WVC8bFqkjiGeF0jYMX7qff4QuAiBjO9GDH5cdll3tyU4KuYBj4KHC8PTg\nebJwmthM1DGMbQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASI1mfnHUeAMkg5sD/TzF2EsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTRkNzRjYS03NGI5LTRjYWItOWY5MS0yZDMxYTJmYjIyMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATunqY3xOV9uX19VIP5e1qtFjFQ+qDz1v86ikCWUq8p/ApG\noN3WMulgjEFYnsW3Xt6M/tXunfv4u8HL3qMs5r/Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEbaCfVjQwDCBPsrU5g54IGe7\nprAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUqxqGaRkMos4E7Bh1T0vCnc65j+M2XsZFmEJSNWfeZMCIDSudKBPaZD8\nCwA3zKoJZ+YxqP0V8WqxAJBVFcHBZlVM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZ3FTRVteSDerD2lZ94oVsQeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U5YjM1MDYtYThiOS00MDI1LTllYTktNDViNjhmMjI1NmFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTRkMzRlMTgtMTEwNy00MjU1LWIwODYtNmVmNDRlMmRj\nYTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiVh8yxWfpNkF6VGK8Tf0Zn6B\nYwpcfz/k6UaTUYFzbh83AcMB4czCwNc1foOYP/Cexah6DxOmNz4yvK75DGoaKaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnlxUVyLluEFN8wpfGRidduQfc3UwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBTwVda9wgvt6VXqTkPj8SnzZe7rTnB\nsp4tIW1+dNc/mQIgHuWAuqXMNSw8LR/uGj8vYRs9cZrG9RYmtjo+3N5coyQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2287", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2287` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASJlepVbb6pgaG+rO2ah8XcaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2ZDM1Mzc4LTZiNTctNDdhZi05ZWQ5LTNiMWI0OTZlNWM3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNjNjkyN2QtZWY3\nNi00ZmUxLWJkYTAtMzExZWM2YmFlMjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDMCY5EfviIqPYWeDC6PUnSkBjiOOpa8nE5lIkaTG+WcJy2qs3wcAotzphcBt\nDTLl+i3/r0MbWIyFm5DDzuwvBqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6xI7loKQzBB2zjcsoALXHnbIr48wHwYDVR0j\nBBgwFoAUY3bQxpwRv6HXEzGqwA/XHg/z1GowKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCEl4wbaTpM\nNbHnqjuHud1qBhGqEfpecqFYFzfcWXq2jgIhAPWYDvNMZtEIlsEjeh6jl4dG+JWM\n4ryDIP87HbzL9D2E\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARx6t/ATzmzrrN5hgF445JJCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmQzNTM3OC02YjU3LTQ3YWYtOWVkOS0zYjFiNDk2ZTVjNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGbuv4OF0DLJ+m7OHpZqTJNBlUGhoNnGKdTEzvTOuwagEh\nP20grjqJVrMDIQxiLSnWCyZGrL7EM/Juls5anuE2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY3bQxpwRv6HXEzGqwA/XHg/z\n1GowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJlxZEXfgRUF/5nD2skJAox65G1SWA0ccu/ZLotNuAyQCIB8bSGWv1KK8\nISSvFjfdR7tkEEH+rY8xyd2QvAkG4Gz5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISASMGwn1WdHsbCCc9nja91OGvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNjNjkyN2QtZWY3Ni00ZmUxLWJkYTAtMzExZWM2YmFlMjNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmViNDZhOWUtYjViOC00Y2M1LTk0ZWItMWQ4YTU4NjZj\nYmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV37i8uSuuZB3ajfG8CywJLBZ\nVq4ylqkdfqkiErfklye5iQ6TQut4s22lI9FJqUGEW+lBGQvnM2WhhTy1W35QwaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6xI7loKQzBB2zjcsoALXHnbIr48wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA4xTxzacmpUVzLVFu0SAbX2Accwu6\n/ZGQ/QYXMpQshkoCIQCFixublB2DLo1GhNr+XBUaNDFWswm17o5TThAv8bUxaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2288", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2288` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARvFh0yjZEAxkk66JE08dbd3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzODZiZWMzLTU4NjctNDRmYS1hNDFiLTI1ZjRmMDZiYmU5MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmM5ZWRiYzItZmM0\nMi00ZjFkLTg5MDQtYTg0M2UyZTMwYzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYI2Q78YbJc+T49eGD9r4bYPC+6oRs3R8ABAPO8Riw0dxo/4dPsnFlQPFOuaB\nCeyl/6KwG4LCiYHB7XdEBp59haOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnMGQ4lq9xizvlfiBkk5T+I8GbJIwHwYDVR0j\nBBgwFoAUCoKCXCdKX7AFwnlsZeaUxO7dbC8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAk38HEkQEfRQn2s+SNwbEmmb5N6Xoil4Ii6ByVa/ljrAiEAlyg67lExDZvJ\nLUBBtth9rKOqAYaROoBc6Xg+zrVKpJY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAciiShzL+HqcAtC8cZQOYOq1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzg2YmVjMy01ODY3LTQ0ZmEtYTQxYi0yNWY0ZjA2YmJlOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFfOxvAc+3Fc7Pk3uQzOEQIlMvTSHdK3hGvx714Brn5MQt\npDOnDUcnXWx9ggDirf613hO3zcFkGnIgwSavOzNwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCoKCXCdKX7AFwnlsZeaUxO7d\nbC8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGns7tUPjqADDVJGzrnQTDrwjuZ8rOvMfZFBGqDpmTcwCIH8IMMWR/2iz\nkIfZEkS1f05TYHV6CfoOsuwRUqSMDN/Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXBDGih6BwKLW1KoeaHcJOptMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmM5ZWRiYzItZmM0Mi00ZjFkLTg5MDQtYTg0M2UyZTMwYzJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmFmMWM2ODUtNjFkMi00MzhlLThkYmEtYjkyMmU1N2Vm\nMjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvMiur9AGyXlQpOJ7vL5Ed9tE\nMMLHwNOo8zV9ZLx3Ay3Eug6Cis40edaWnGHqCoECA+XZchMQ0je44b0WN0qL76Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnMGQ4lq9xizvlfiBkk5T+I8GbJIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAoX+Xv/H5g4IdWBO0tZRlyLHTb+H0\nrLLb4M9qeZgexZICIDpYoPw38W/8iVQeuQJS1kVTBWQQmFr9G9JTjr1BtikY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2289", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2289` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUwGpOFu/6mN0s4pjFKl5PNrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5Yzc5YzAzLTI5ODctNDI1Yi05MWVhLWE2OGI1Mzk3NjNlNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDJhMGRiZDUtNmEy\nYy00NDYwLWJiNTItZTBkMTU3ZGNmM2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzq+UV6G3LF4B5fBFKfNjQ4GrxI8UHYJZXcgUR8kO48u43SNj+taD6Ue1VDDG\n/MzVMaU2M2imjjWrKQ9TMMiE4KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB62naw/AA8GjtbZY99279ZGEQYQwHwYDVR0j\nBBgwFoAUDhir1rlWiNF5WIf5cs1ttR5GOnUwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBv1+95CCwbhfOFCon/X+r8zTFH75eIZLpLYtMfCJAzfAiEA8dQZAa75EJeK\n1S2dDB1p0YtYu5RqWf1PXj1KX8q/edk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARD51gmSppSaXzk6bGhgvh9nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWM3OWMwMy0yOTg3LTQyNWItOTFlYS1hNjhiNTM5NzYzZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXU6FDPSTwtJ+1uD6sZ3Jr2vQKCpII/fzBciAcAHt4+KXs\nvRjy0XGUvL/YRYb4g7uwe0uOD107G6/wrQmLNHkXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDhir1rlWiNF5WIf5cs1ttR5G\nOnUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPxcmFO5lHYomZ2mkUdq2GBfTOlno9ZFzoG69yGOcVq0CIQCDW5vrjgLp\n1qZaao2LCU6kzVlD/ROQQB8SCRKxU3Eolw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVOfztzb7mlEEfq84MFtg3EWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDJhMGRiZDUtNmEyYy00NDYwLWJiNTItZTBkMTU3ZGNmM2QyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjNhYWYxY2YtNDFmYi00MTY3LTk4YzgtNmMxNmE4NTA2\nY2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzRyh3RDXJH1RMB4sDHSH1jJb\nXs5A4boTov3zYdP5KJy40jpiyd28SWx5YbU0guRO9eYNlVI5kKfF+RpKoFuLoaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUB62naw/AA8GjtbZY99279ZGEQYQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAh1zuM3hdcTVkga3oJrOzWi+I29eu\ndnMhI3acQNAYo7YCIAQAEG3fRwaf4RA3mDsSnRChlpqfHXbcGKpdAmkSQkID\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2290", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2290` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAcpOKbw7H1Mfu/1kd8swtqrWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwNWMzODQzLTE4ODAtNGJiMi05ZjI2LWIzMGRmODQ4MDI1NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJlZDhjZDYtYjVm\nMS00ZGRlLTg5OWYtZGVkOTMwOTM1ZDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1pSmpaZMcunjcdwbLDiEBGrGRc2iln8mJ8TOMtq9GbTBZHD2LcHyhxaJh78h\n2tX5KheYUeVveygepm3WbYDD16OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSeOK0nY7Cd7nQzaCMxNRZGTIvOAwHwYDVR0j\nBBgwFoAULi0tJJbOMdW/ghddTKSfGgzyJegwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIB75\nfkNb3h8w8f4zlWfqyXq9p+lvMAlnmxL8vlycnAwEAiBE2v7G6OEMoSv396mUVAca\nPT6uFe/sPtWRKUfLL/8CVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU7ZOYkE8NqJgQQVIAiQ+ekQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDVjMzg0My0xODgwLTRiYjItOWYyNi1iMzBkZjg0ODAyNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBO8CDCGU4P8NpWB911eUGIQ31yOIKS+wMpyyXC0aID/+L\nQUNZDG3RqHzN1vvCVGH+6ynVNSlE8AfTGXobdTPAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULi0tJJbOMdW/ghddTKSfGgzy\nJegwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJS0xiMcb4qnJnyKQN1Ti8gl8vB63FMQWHBBNbY14qjcAiEA0vXlhXhe\nxxzlKKZ7Yuwi98MGnR0LDvciEK8nO9oJYxw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWlqPR16BquhBUKxehsFnSwPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJlZDhjZDYtYjVmMS00ZGRlLTg5OWYtZGVkOTMwOTM1ZDBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWUxYWY2MDMtYTAzZS00MzdhLTliMDUtOTk4ZDhhN2I1\nNzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuhr7LsbdMZZWtEQA8gcYYZld\nU2pc0HsuAsQDID3z7JREWy8X458hqtCS9a3JI38kkE0MROD7/P5ZilhhGkhctqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSeOK0nY7Cd7nQzaCMxNRZGTIvOAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA8i+YFnySokJtdpcgEo7j15TjpkT7\nEk8UZ0xIKKnQfSsCIEkp1ZK63BkHBL9Fkn7BmlvHNd97StG+j4JQC4ugNkkw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2291", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2291` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAcdLnGijqZVk20Or6Tk2vgrQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4M2E2YWNhLTRhZDgtNDkwNS1iOGRjLWZmZDhjYzg1OTgyOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjVmMGNkODAtZjNk\nNC00YjlmLTk5YTMtYzdmMGU2OWM5NGE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0YKbwNJoAyvPFTqRANNuJBz7hiFUsHuNoQnag5DoQ90m/3lNsLfOaMx466FS\nuuRmbMQa6cZYKQGPw4TXpoOhIaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAr9k4r6Kb3opReowXxhbNhXCETEwHwYDVR0j\nBBgwFoAU2KlSSVmcP22J4HVG5DgY9O4XzGcwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEyigF/vZevu/tlCJ2Lbq1Id5wwYV0oo/+4/4PKzTtWpAiAt7gZ4\nJhQxY0UWuQFJeCHCOo5Frrti2UYKRYnwtPKqMg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfyUjRO1XzX3OBBkSzMfMcopMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODNhNmFjYS00YWQ4LTQ5MDUtYjhkYy1mZmQ4Y2M4NTk4MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxJOybkrdS2euuFd3+v/KEPjTVV0zF6tFgC910/YSQbxXY\ngYHtJaQsexYBWRFsW2cSEMlnWAGU3Y/mm5zKC1INo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2KlSSVmcP22J4HVG5DgY9O4X\nzGcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQF2iEvjzB2AbRV6Q/JxzxgoCP9k74+Bbg7DTsMsP6oICIFyBojxFa+LY\nKa4jrqKqJblsr+eOiaQG+Q1lIUDOX6kX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAb2547OhpvfXyvJ7H7SstO+8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjVmMGNkODAtZjNkNC00YjlmLTk5YTMtYzdmMGU2OWM5NGE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGIwYTk2MGEtOGUwNy00N2VhLWFlYjgtZDNjZTRjMjcw\nNTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqrJtU41X08PxOj39P3sMY1df\nzMM/xlfVIUJijapUpJ9hN75WzFGgjDctvxC2++6zN2rDmNG6O+M6WOQm8p4lUaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAr9k4r6Kb3opReowXxhbNhXCETEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB/Jwyn9ZwZeGxy5T3XfMjnevHZk3fa\n6qpx6lBpr7YIUwIgUX5I33+MohD/M5rrwbUrghYnhOCoIVobaFIgvlUwqeU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2292", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2292` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZd/86jnWFaMZTb2B3DEQYJoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViOTJjMTQ1LTcyMjItNDM5ZS04ODI3LTE3Mjk1YjY4YTRmMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDMyODhlMDYtNTVk\nZS00MTViLWFmNDktNDNjYmU4Njg1YmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0JkPp4aSi5pdvK40kNjCodGvv6Tuhg9qABdR7qwrjeBRQeZMhxsinwItXFZK\n7NHUvLDXsAYp8PNBYkdqeJWb7qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKyegl5XyCx4ggkUTbtWsaTpauLkwHwYDVR0j\nBBgwFoAULfD+YVFVtnZWu61Zh6Vdouo+uFQwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCh/9XpOCe3X4vl5G2EsnAEhtrU49LiWzG+at/WcWcizwIgBlBO\nIEy+L8Z0C2afx14eshRiJTQ2fAHm73ufFTDwuKs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd8KA2AgzzC+OUqqiDJ6He9UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjkyYzE0NS03MjIyLTQzOWUtODgyNy0xNzI5NWI2OGE0ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMU4YG7BOHpS2V2RON09dCpeG8qtysrIHvm0FZiQOdizpf\nuA4VazE3UnkLJOEttKMWrAwKl+toH845NeNfIpYUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULfD+YVFVtnZWu61Zh6Vdouo+\nuFQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVc6Wc9R5Lswf9A23x1kYU7TnVfScC9jYQXlcWKIrrpMCIQCAGzeLpx0Y\n60EoowVsYGJEIHq8M4iX54XfX35G1BRMtA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAerwzQr6krw/cqHdjk+vKrquMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDMyODhlMDYtNTVkZS00MTViLWFmNDktNDNjYmU4Njg1YmZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWVkOTIxNGMtYTQxYy00M2I5LThmYWQtNjRjNjQzMTRj\nMmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGj/Qm+MU0Q19RTUuQi3w6S1Z\nq/dIoJ834jCDBLyHAEA4X6flAwWzxqX5F/NudoyLD2JA4ktcXMUobBcuaQwhlqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKyegl5XyCx4ggkUTbtWsaTpauLkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA9r/jCp0JGYnGVW2vKK5MdBzXovEM\nRd7JZKsAWJ1clmgCIQC/kMhpztC34XzdcTIplcqRR/6hId2N0yOu69w4nT1/zw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2293", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2293` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAVJXb0/hHb57cqDQE65ozjazMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1ZDlmYTFlLTNhYzctNDY3NS1iZmJmLWFjMzBjMzBlNTQ5NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q5MmM1ZjktZmU0\nMC00MjUyLWFjMDktM2VhYmUyODhjNWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7ix7VxOvtd4xJadEqwWXJ5Gd6A3YWtvQ+oqSc4vCI1K4VhnJKU6O3uC23uvI\njzM4Q1Ab+HZLcoj1mY1Q3sJVuqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKrLjIKfvsm868jTR5wIZg7koJWMMB8GA1UdIwQY\nMBaAFFAAn+Rvc5SWVkQNaUCyxvtQTwBlMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAt+B5wsEeLtRP15CLywuCcAtVzD5EuCRc\nce8erFLqPdcCIQCRux7RLzmjMpwli6bEtsedNHZAhlk+BAYFZgU0PB4vvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdoQaUX0VXzixQee9TQUDQB2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWQ5ZmExZS0zYWM3LTQ2NzUtYmZiZi1hYzMwYzMwZTU0OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6PP4+WJiujAOI1dDeaHIft2itESY+YxZAJgnGLx8oiu1i\n/g8ybgLr4AImpTS0BsNcnkwj2aqoCb5OPeAbGw2po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUACf5G9zlJZWRA1pQLLG+1BP\nAGUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcCwBSZHnxo8my1JgxPVstqmgA+cFufdUQBBLmLFMecgCIQDBG3V64NJu\nGIIPYFYvjFZEBbA8upqOdXiOuYSbdjpEdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXhVDBOm55Px2fHnef74nZTNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q5MmM1ZjktZmU0MC00MjUyLWFjMDktM2VhYmUyODhjNWZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWUzZjRlYjQtZjQ4MC00NThiLTg4NWYtNTFlODBhNDc3\nZWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN2tr/nGyz3mumBCL9VGPobLT\nRqUIaElcjDrQ4O4aoGfb5EW+SY6fl37s8eyeDb1P4rmzDJ70JylUUwmY9DiNCKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqsuMgp++ybzryNNHnAhmDuSglYwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAzodZO+2+z5riBzy5Hi53E2OjZR04\ns6n95zPRtHs4R58CIQDJUWz1LP+rxV9Nv8CRDtDsTUTE4ePXHySkQN1LbMBROQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2294", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2294` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASjw0GpnW0THv7cI0Rs6N0ptMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MTFkYzJhLTU2ODQtNDFiMy1hOWUyLTI4YTBiNTlkMDkyYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOThhZjc3YTYtYTZi\nYy00ZjA0LThjMmMtMTMzNzUwYzY5NWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQM6F0UCrT2iesvfzUwlKbUG/1tNQBcYlmPhmC1SWn6/gXn/qtV3srJ3QhSo3\nQmyxdI29mGPe/GoOjZc+R434n6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAiYnHKIIuSOyRAdWr7cbrs+UcCAwHwYDVR0j\nBBgwFoAUIu0sYdj4ocPJ3Wig3YDldlOGduYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgFGOAn30GKE53\nxbI/3kpTMztbeQEeBhnbouRCNKQ4c5kCIQDSyGNyLtjVn2on+N8mxOqvgCSYrY19\ngMFa5/9FsU/QOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb8Ol4WjDWejUU/1FhuDbNx4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODExZGMyYS01Njg0LTQxYjMtYTllMi0yOGEwYjU5ZDA5MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShMkiM3dSkzY1ZQ18ex+A7W4UbSohQmwrZyYaml7yZO+X6\nv7k9Jd8mznnZ2VpuLQNbLdo2OYroAhi2pfNtMuH6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIu0sYdj4ocPJ3Wig3YDldlOG\nduYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOtAXs/OAKK5h35fb4Nup0VfNR+2GBm/kwfBfNQgMu37AiBsxIcp7Ltb\nOe3Dt1SXrkiTzYjAt+/1FnyCwPX4PeTjCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVgRwY7zT2SCURHLp0m0ImT2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOThhZjc3YTYtYTZiYy00ZjA0LThjMmMtMTMzNzUwYzY5NWY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTU2MmRmZGUtYmI2Zi00NzE4LTg0MDYtOTljMmFjZDhl\nMjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwTkoxTPMsvCbPc5cgYtbO/Uv\nmbgJKGO+Cnfmmie8H9H9tGWaZU0jqUxm5Mps2RoeiSghM1QghTiI70IqVd6CYaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAiYnHKIIuSOyRAdWr7cbrs+UcCAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAde5mchrs0v+TMPYwO3+OMX4HJ9alJ\n615hibw0V9Bx3QIgWW1x2n2xF24pjOtY+jDDE+cxokoqf3FsIUrx9GO5m7I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2295", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2295` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISARH18b52ukk/4h8/LoNePiTQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyOTcyM2UwLTVjMmUtNDYzNS05OThhLTc1MmQ0YzJmYTc0MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgxMmVmODktZDA5\nNi00ZDFmLTgxYzAtZTU2NDgyNTJlOWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELxprwnYRwUizYYD0wtstcC5QU/sfZ3b5kzNl8t5WY9voT/LrWxmVBowfRCzI\n4NeOsc8ZkEyqSi/UQzOONTJQGaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO5FRHYGZWIp73IZ0gZ5vDrMRTbUwHwYDVR0j\nBBgwFoAUw5n4ieOI/S26+1rbunUwEOJIth4wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgH+Iq4KvbpYyQ\nzWZoMDuh9ET0JM6amTauJBn8Bjvg2igCIFkOiNjWG1rQWlAaboLSHv18e+FDK4/l\n2h/EeKoN3eds\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWa/TUTFsA6PnmaHLJv0vZf3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjk3MjNlMC01YzJlLTQ2MzUtOTk4YS03NTJkNGMyZmE3NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAUCiki7OV/sS9I+DPBa6Lzaq/l+chuG/Uxl0cKkidodyk\nRtAvD+XUOqN3eBHvsru/kdlOH/JL+rp+Zv8ebalDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw5n4ieOI/S26+1rbunUwEOJI\nth4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOa6GzhCrnlXrm7FLlKx2+urIv9P9K93rL1vYAczVgzYCIFjZTBNWJ8P0\nKB1/UikIJaaon7eForRFdaFSd9xBWkJe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfjsMu4pnGm8ena06NQk6PSWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgxMmVmODktZDA5Ni00ZDFmLTgxYzAtZTU2NDgyNTJlOWRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTcwM2RiMTctZDEzMC00YjUyLTgwNDAtYjdkOTZhMzJm\nMGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEirBfSL42JEdTg3ni67P+T2ad\nxFUHWqVb2S51WV62YxyteTbPydKPg5OhtMrMoro0GqPk0PNOC7YN40HBu2RP+qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO5FRHYGZWIp73IZ0gZ5vDrMRTbUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBbnCOihyWanMIS9VgJBzyxPtFqDDNT\n3IAUzKNCEYf00QIhALARljKEH+cO7v5VfG1fv3WI78ISG3cN7B1XCa7jZTZt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2296", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2296` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQtTWP5SstsNJtRtmdbjHp7jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZDkwZDE3LTI0NTAtNDQyNy1iNzQ1LTczMjRkNWYzY2I5YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjgzNWQxNWItNzM3\nMC00ZGYyLTg4ZDItYTVjZTBkM2MxMjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv42gubjrfC4M1Gtygm8oBrqgFOmEgUxp1ll+5TniEJC8G0QD2YF0FmuNFAGS\nf810DNWEqPeWgT9p6PXQh/rwbaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZU2O4esKlmSswqyU5oZ4QBqQUo4wHwYDVR0j\nBBgwFoAULWgjIZJVgfMyt7LE5bsfJ4QHyegwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAvsKhqmsK8h\nzrinl5uZv7GDTCduiAxnEJPp5Dg7yK/MAiEA0PW9a04v8e1iHW47KXfjkfojT5yC\npcucHbkJLGlgfs0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY3E/TNImxqdpJ866Kw7XVsZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWQ5MGQxNy0yNDUwLTQ0MjctYjc0NS03MzI0ZDVmM2NiOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASn+RvpqInCDqN6PNe7Lo9GzhywIfv0nvwL2VhGQHEaxmcA\n4Ryo65r6GsyYcMroN/FmgVodB0OLap2yeXuUUHQAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULWgjIZJVgfMyt7LE5bsfJ4QH\nyegwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfBYxu3xPY9Pdd+ionCU9MbC92t4dUUQunBvNaUjM/LkCIEY45Fj6Ihey\nADptM7WSrX3pYxShGBYgqfzqsDlqhmeF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAW3Ty6NF6qP6NCSbtaaD9dYVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjgzNWQxNWItNzM3MC00ZGYyLTg4ZDItYTVjZTBkM2MxMjA3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDhlN2E0YWQtNDVjZS00Yjc5LWEwODUtNTkyZGFjYzQ3\nYzA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElWTuhUpZpyy+d2dR7f1wpH8N\nYTHJtPWyEsyubb0FwU7rH+QGdkNxdWUqIAja/FQQUq1cbZMfA3fV0cjRnZyIl6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZU2O4esKlmSswqyU5oZ4QBqQUo4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB0p4Da/fET6D8wuklE+cMBwAkSAMbK\nxNKK8pCcoPyeWQIgTRAq9e21wwKUntHoCN+6uAbWxunX4SUpZadtbCgldIg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2297", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2297` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARXY2x2vfk2YwkwxdMy1gUHRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiOGY1ZWU3LWNmOTUtNDE5Mi1hNjg1LTA0ZjA2YjU5MDhiMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgyZmE2OTYtNmFh\nNi00NDQ1LWI5NjktOTU0OTQ0ZWRkMDY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdEHaE56pPTfoECJOzhFoD8ZiVXd6ldT9ePv65rhy8qMTEVSQJ2xI3V1mrlhE\nhmZXaNrbb9OC3rvE2RR6SARJbKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURVhXV+iNDPl0BXSr7oViugHV5ocwHwYDVR0j\nBBgwFoAUZgqig3WCGFPuuF4qiclizmPrgLgwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCQ2GyCin3TsDftjjsgKkhec94V3Z3wDmn6VY8garFZQgIhAOEQqFgcyEK0\nRKnWboIFIO4dEn4C4Wlmpz9RJScD5mTs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUqPXoYkqqSELn9xET1xkJTPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjhmNWVlNy1jZjk1LTQxOTItYTY4NS0wNGYwNmI1OTA4YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmlUDf9LmPJoF9X/wRcXP3yRtmHagIdz0xe+1TEP6EOA5p\n1PScpCSowLE/cbb3cuU+uGhMfJfm6RAiZKl9Mflfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZgqig3WCGFPuuF4qiclizmPr\ngLgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIEwQUufVN5CxKaL+yvgLrX9GM2cCUwz8s5pkMTEqtwnAiBuyKAQmNMC\nN1WI3YzXeSfbKsXrz9uvh6i+RF2TjYRR9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAR2o5dv/MCzfc32S0MSUHVeKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgyZmE2OTYtNmFhNi00NDQ1LWI5NjktOTU0OTQ0ZWRkMDY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGY4Y2M2NDAtYTdhNC00MzEwLWFlZjgtNTJiMWNmMTRk\nMWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkgK3J22iE+gIsONLhrv914fz\nhJ7/Vf3P6lbauLxK4dyogmezz9yii2NN4vz7a3ukFwJCrfhno2SG1Gz8sHgmKaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURVhXV+iNDPl0BXSr7oViugHV5ocwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAvdZXSEWP6+lIftHIqS3gxq9+b6Qh\n2WswdLxY9dDpzIwCIQCmIhW5pfmSfiBzhClkYH65GFULVZM1aSM0CqNtoAq5QA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2298", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2298` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAf/SkCI6kxn3QDjS+0NBwLPWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViNzc3OGVlLTVkN2UtNDI2NS1hN2QwLTVlODMwZGQ0ZTBkMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFjNDI3ZTUtODFl\nZi00NWYxLTgzNmItNTA2NDRmY2QzYWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZkMqK63XzazD/twjcWtKnuj2IIhxLk8PrCmoXNLemXATWJvHg1cGYF17WZwG\nAowm/DsXIP/QiqHi1VWUTCuE86OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNtpAESHKEzEhPcAClvFrvEWF5rwwHwYDVR0j\nBBgwFoAULey9o+H5t/IQGUNqCdzfGUROHDswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCdljfCtuBnI2ImqzOl2y+g2pwq9Pjpt2AtKx0+RD8XvgIhAIhG8SCHGM9I\nDxRzfUuX0BSEJZtKwSR0AYSvzfwf5j/g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVFcmG9lruj5UlgkCLD0MoyZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjc3NzhlZS01ZDdlLTQyNjUtYTdkMC01ZTgzMGRkNGUwZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBTLetd9mdpgqsBV8VoUN+xF08Na6FqArAgK7VVQiY2cO/\nQ22CmJl4PjifaTQij7ZUvnaFHRixxON/uJSbFq6to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULey9o+H5t/IQGUNqCdzfGURO\nHDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK4tWcksZqazALEea4s4UIhCS2bCysrP1EhkhTcWowjIAiEA2S3kowPR\nFLma5OvhvxFaZTZBCVtBvTSDz96JqJrAWJs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUVetyYSfTf0uOQlUhNNDph1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFjNDI3ZTUtODFlZi00NWYxLTgzNmItNTA2NDRmY2QzYWM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTc2MWZkYjYtZGQzZS00MmIyLTlkY2UtYjZlZjExYTE1\nNGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8ma+mteD7vHnAoQ0OLBXie2v\nzUiC2l/rnvJipU+5ukwxbOmlX2ejS+miCf1Rr3MDoF4f7L7xqh0NtVzZhdJOu6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNtpAESHKEzEhPcAClvFrvEWF5rwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAkCFY4pyb9/ELecV2xgx6znr/FKwA\ngOYumLIN9M/YiU8CIQDUsYVekVOuw7BfUiXp/bFLmtZiCeguZmascHiqOzkr5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2299", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2299` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAfMiOu0oK3VXJYvjSMAz9UYbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2YTMyZTEwLTdhZjAtNGNiNC04ODA0LTlhMThjMjZlYmUwYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJlMDU5ZmItMzE2\nNC00ZmI5LThjNzItMjgyZmE3NjAwNWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8B0kUY72W4054bwVwifbVmlpIsT48lFI6ZORaz7fMikDNThyWfCaH2mJKCF+\ndJ+3wduqwU0/4OiUymbzab5lP6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQbNpbAg2IQIhkHpytbqoweNppNAwHwYDVR0j\nBBgwFoAUpkx96+N5sn3d88NE58ZSc09+xrEwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHOe\nAhT+EQIlw6Xa+qs3cc52VfWQgUR+KYb18Ynqppb6AiEAhoUqVKq+SDN7zdvklYz/\ny0u1WNCWmGUOTePCSTFBcMM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATQFzvebvwGIgdd82deqz9EGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmEzMmUxMC03YWYwLTRjYjQtODgwNC05YTE4YzI2ZWJlMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqOBQj4h9zvwo9z+WZMu82yTrBdukdx5Uv0FrD8ZDBrjWa\nyMkOW4rjx8OBA8JGE1DeApKU85/I+OSYIRfMHSHDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpkx96+N5sn3d88NE58ZSc09+\nxrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKjMxg5GN+wyuMapnUC/k3v8PhxrOg7RSW2PXsWFt7BFAiEA+J8WIadV\n+bOj4EVzHIS2/RCUAFin+dBmkTqgL7LpkZI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXtx2eWZ3Ma9A90EiPPoTPyIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJlMDU5ZmItMzE2NC00ZmI5LThjNzItMjgyZmE3NjAwNWFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWJiMTJhODQtMGUyNS00YjJiLWJmZWUtMDUwNzIwNmZm\nYjc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM5Giei50W+xfj+qmqD4Ng+5m\nCKTEIw3/xpBkJQAbyX02dneKgocGZXzSQMw+YYCuv9p5UuBH6CIDSSGt10AOFKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQbNpbAg2IQIhkHpytbqoweNppNAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBS3yvQdUTfIdm7Dv09jNGHP86UwQ+S\nJmQ8fpQtKqezXAIhAIqt23dPli8HJOSRzGcMLDjO+m4nzYk9ayOjDXm8pIA3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2300", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2300` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAXlb5lnrIKN7KJuhWoSsUkInMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyNzFlYTI4LTlhOTUtNDRmMy1iNTZlLWVmYWUwODBkNDliMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjMzOWY5YzEtYjgz\nOC00MTgzLTljN2UtYTY4ZTZiYWQ3MjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErOyl0Hf3dwVK4cJL1JnZI21z9ChoxTEkCqWUSG+92xSbBD9pjtnI19au8Nrs\nAicbf9fw7wfVjQXzDArkiPWV+qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8oP8myyp0U5wNVS2PEAVvDkiVcwwHwYDVR0j\nBBgwFoAUEzRoiCFGaUZOH/VDxvrXd8Q3wbwwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIH0GL61zVgY/e6BP9UQKK/Db+78Fu4rFeGOep8k1WLutAiBELHvs\nv7gRWjuKLhyljOUaXFQOXBp6Nqm2So+xqVGYNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdG20J3jCrfFF601wQ8X6R4QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjcxZWEyOC05YTk1LTQ0ZjMtYjU2ZS1lZmFlMDgwZDQ5YjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrOmS7PSH457eW9QKfI4wo0oNStd0LBWKjitNE3Bx4imK0\nbBgJULtjHpj4+Bz1EaUt2aLSXddJ3fd0Hz9ypJBAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEzRoiCFGaUZOH/VDxvrXd8Q3\nwbwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALhoTpRKwXZbUUmdDLsr9iFuuCpGBi6VfstN9T2ea/E0AiBG1zGehlsb\n670fQ6fPLvJyBL2arsI4B5YPzEn1D13EsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZHaPe0PHTXZ5B+uSzS+hu2eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjMzOWY5YzEtYjgzOC00MTgzLTljN2UtYTY4ZTZiYWQ3MjY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjA0ODM3YjQtNDUwYy00YzczLWFiNWQtNmM3Nzk1ZDEy\nZDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyDffZO7Amp3gRnkjYXQEcO/b\nGU3P1xzu3qHbNcSLBhcxD7B0Y1BBhT5dMwUi3Jhjn1jQi7+SKpArybG7jicyuqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8oP8myyp0U5wNVS2PEAVvDkiVcwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAUZonQm7SbIig0ZKRsprGfeukS+iPM\nVPYHTJ4my2JnXwIgfP9UkJfXch1tCXBURhUp+maMhAr6ZqEFGCjFKxtLuGA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2301", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2301` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAajORHS/04DWZ7zp4+OxDBgGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2NmIwNDhiLWIyNDAtNDAyZi04YjhhLTJlYTI2NjQxOGM3YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzU1ZTE3YTQtNzZl\nNi00Nzg0LTgzYTEtOGZhZWM4Y2Q0MGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1Ac/Ad79kf4bvOF821KdXGmkERSrSCYKWf22nwyG1ghWe8jso6dj44n3DTb5\nL1ulxlRmqEF2vi1LrFjTyUGx4KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmfcFceEpihg/2hikETifyawPLjkwHwYDVR0j\nBBgwFoAUXwDwGEdGlUCf3c+L/rzuLesaRXIwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIAMgNB2XBAfecC9z1trI+z9h1v1xH1PCiAjJK5SPFNYvAiEA8Kcx\nMafyXLh5wqTgzX/xBGDddQgF+QV17Qe501tJLe0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXAcztHZ15TdNG30z1oQvU5BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjZiMDQ4Yi1iMjQwLTQwMmYtOGI4YS0yZWEyNjY0MThjN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkM1g7cWjfw3Ramh4LPeIZg0FBRHWYbo4SkKv+RbGuvgoU\n8rDjpoUsMKXt2FktJjLX39WHvIh9QQvkBBd4P+hno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXwDwGEdGlUCf3c+L/rzuLesa\nRXIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL1tBzxnBn8Na58GRE57g/7Esb3dDoGWxWooiErcr1Z0AiA8rO/CWK10\ns4a7QBI9O/5+yzjWkj9ouUxMgD9YDfgDFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbGeH10S5RwsM1pCJnvf9JlkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzU1ZTE3YTQtNzZlNi00Nzg0LTgzYTEtOGZhZWM4Y2Q0MGM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTM2YzZlYWMtZDcxYS00YjI3LThjOTUtYzMyM2UxMTQy\nNTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG4JNqlm17ahMyzFlA6MObTI7\nu5i/6H2ZWuUHfG6j4+9I3LwbYIjPTqlgBdhkRcZJzhzMlcbUg5yJQ2O2+Mfkw6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmfcFceEpihg/2hikETifyawPLjkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEApI+PgK7ZmLyjJ/wA3hwukSQNhx3L\np9R3oIDR0wNoJUoCIH6hlDvqcOyniGRLkCQiSEbKr3PW4ju8OJk9/ynXOTyE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2302", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2302` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAQmxp6zJx4VQEp9Jfd3dqPWWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MzRjOWRmLTgxZjktNGU3ZS04ZDMzLTkyZDRlYmNhN2NlYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzliODcwYjAtMmIz\nNy00ZGNhLTk5MTAtNzk0NmUxMjQwMjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7j/3CKB6JceTDZ+BmT9a+uSnJmrlhoWVhR2xLuEEhthmxIHKCLlO1SmfYsDf\nQpAi45wKZ9QxkEIl/YBmZo6XYqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTYkoNqNLyq9CTmRZ0fDNrcIhauHjAfBgNVHSME\nGDAWgBT0YuLlLP+PEIP4cuS6ikszIG85AzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHRcBLuiETMtGOF/cTOV4F071PXHw5zS\nT9aW07wtWEMCAiBTJAsjpTSuIfIeFiSuEqD5K6gvrdwuKnlyOvzwEVk/2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQXB1MJsIGmX2KZDo1FMek7XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzM0YzlkZi04MWY5LTRlN2UtOGQzMy05MmQ0ZWJjYTdjZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpIA1TTpR4EZBTrjgbSHUXGkmhtGXsrHheJderFkcZMkMs\nTVhnz423mRvci7c9pPowwXkPb5Dzp+YiATNhTd62o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9GLi5Sz/jxCD+HLkuopLMyBv\nOQMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbcwP1dixWoREcMsqM5e1VxIcNmxNGVBRzAxbKBEjA3cCIHArmMpUJkWj\n1rUwP2YDsbnEj1qfnjLRww3tMm8ChZaE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeY5edXI2cNf39EMF+u/l1IZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzliODcwYjAtMmIzNy00ZGNhLTk5MTAtNzk0NmUxMjQwMjJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTU3YWY0YjQtNGYzMy00YmYzLWE2OWItZmVkYWYyZGJl\nZWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeAYqBed3haTKDK+a5hm1Sy4A\nha1v8hC+1pXOchC25WzECgKGnyJXWa7C+ipJS0eGW+ltxvNZLOc9z9XDVnyrhaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2JKDajS8qvQk5kWdHwza3CIWrh4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiALvkV7pCEVjQmp/3R8+k7eRc52C60y\nDdcyOjQytRSnBAIhAMesPUUWA0ahc1zbND2LNMoARNly64PkHjuZBoJ4q+aB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2303", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2303` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXa6noAQWvtvhyHfxoQpn9F2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwZGQ2YTEwLWE0YjYtNDhlNC04YTE2LTNjMzlhZDkyNmQyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ2OGI5MzItZGRi\nNC00ZGI0LTliOTAtNjVlM2ZjY2I4ZmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENz3+lSNsjE3jUZs0ETUdV/NoaOzjFoZG1+eZ32Fn5QmPJXecJRV4LacPybL4\nMhtIiqcu0bG7hfAzZgu5N2vHYaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhXddEHA5mFPKw268npdF3svWP3QwHwYDVR0j\nBBgwFoAUGD7Qo4VOuSRy+K+0n+77bwyWPyswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCICZhXAZdHwat\n95yOxF3UtBSvug69MEboigNWrZMZMG7JAiEA8y3EPxavXgpOJL89bU+NksIyv6kd\neqoKMoF8W3ZTH9s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcz7Km5YgLkn6kV6fmapNd7oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGRkNmExMC1hNGI2LTQ4ZTQtOGExNi0zYzM5YWQ5MjZkMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQr53HDHr+6sFW/7nEU2Fw6LKHVKHiT3aapkWOBgJdQgSyX\nDg+wP5IdmVrFHQwHtjYwQjhtrL/MnX64wtIOHyejo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGD7Qo4VOuSRy+K+0n+77bwyW\nPyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALnlLAEMdfYPhJW0BC2FbukK+HgodYGQxszkEVG1Ys7+AiAy9xnjPAM7\nMNJ1B0XCSFbPvCAuaXWO8DN4qBl3ViV76A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAT7f0wz6fmSuvTzQ0cfpdlFOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ2OGI5MzItZGRiNC00ZGI0LTliOTAtNjVlM2ZjY2I4ZmRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTEzNTA1MzMtYmQwZC00YTZiLWExZWMtODI3ZTk5MGRm\nMDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK8phgMQF+7M/gwSbBq3GZjA1\nr5GFPs59lrLGJazifkB8MxDB9Dy19eOmJgQu3vrUR1S1UExqoToSUpemz13D0qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhXddEHA5mFPKw268npdF3svWP3QwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAlBkmpMqnZ6qbu4CWsXWPUgfgVNsM\nrGoBXZPdcW0JSWsCIQCxOMXVSQNkHFkD6n8oCM328MPJAQU/bSkrCMLtmd4AAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2304", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2304` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAaygmtintfqO77FwOUO4gjEeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhODFmYTg3LWY0YTItNDg1Yi1hYzdmLWIwNGMyMWRhOTExMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY3OTllMTItN2I5\nZC00ZGZkLWE1M2YtZWY2NjEwYjc3Y2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa7rCcthnnrupc7n/i3oRubOCx6a4UR+wlbgZh0pMYlm/ILgcMNyPpSVYXavD\nxw93BOnb29Mn7TQi5j1c9g6rnKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyVjgHGFedlHX6yk18uLMS4754l8wHwYDVR0j\nBBgwFoAUigWI3MMQnYNF2XoVzBg6YbfANrAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD83poJexzO\numnqEhzgc6NcGLscUpKc9DD/RIvOF/zKaQIgRH1u4ubl2jVQk/fNI60fEGG/5iqA\nZfY3FrM5iVW33o4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWtuW8pNPLlo4pERdZU9uviHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTgxZmE4Ny1mNGEyLTQ4NWItYWM3Zi1iMDRjMjFkYTkxMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpK02D3aQj1RyI/gBcLmswp6mfhElg8mvY+KXAmzY4Skkt\nWXN7lkqNmQ36jZf2cnuDaz+Y5icPL4CPXLrCohUno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUigWI3MMQnYNF2XoVzBg6YbfA\nNrAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMgA+sQUGzF6e1SaxDiyNSBX7f2IDDE9kdZBknmKBH2CAiEAqVOSeE33\nCITpPAfeM7CQ54jvPhh3swDWuVMiumBrOFs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZYOnO5e/PgyGqXWUX//E9i+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY3OTllMTItN2I5ZC00ZGZkLWE1M2YtZWY2NjEwYjc3Y2M4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmFhYzk1ZDYtNzEzMi00Yzg3LWIxZDMtYjJmMmRkYjUy\nZTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3XraXmc/QGupsKLC6UHPw2DK\n4yzpyijbwwZ5RU72ZuIzl50HvSQaT2sh+xm/2/v6kvMEISVwfJGbgBj5GuVq7aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyVjgHGFedlHX6yk18uLMS4754l8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAmNsY454mhvM80eXkob2wOfJJHvL+4\n9LUWKqxZPN2lTgIgdzlvEzj2yG+0QnxhpHqialH0GNXB9+kvnBFFTHCqcVY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2305", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2305` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAb3h1IA6uobpOZ4+yi7VQSNEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1MzJjYjEyLTI0NGEtNDNjYi1iZjM1LTliYTZmZTk3MDUzYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y5ZjFiOTMtNGVk\nOC00MDIyLWE2MzQtNTUxYjZhMTY5YzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7ExgPVOlQ223n2i/6VqvoU3g6lXUlqOCsgkU9Wc+O+9ZF8bK4+tkgix/kEeG\nq7JPTgXNv81IN+KWSwdNF/SehaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpRRAJUXENeiYaZExV3JvQNjCbE0wHwYDVR0j\nBBgwFoAUsQXRlgf/yBqngpl7HNuSh1ykIkowKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEA0MZ9VnR0\nR5I3Iz7Zi2FSo74R0DzwxLLEmj1qsWrUWT8CIQC2UK9eNJ2PZCVYaB2ztTygCqaP\nJTn80WIq2Q2BJoa6AA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZINMdKD6pK70BlPaJYkSSO4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTMyY2IxMi0yNDRhLTQzY2ItYmYzNS05YmE2ZmU5NzA1M2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGw3KXMeFTU1O30Pb0HdMGIFWVTb6WTmzZ1TN8D5dZO9Xf\naM0J/5REh1SaFheAR+LPHem/W4tp8g1d1BK0fG+to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsQXRlgf/yBqngpl7HNuSh1yk\nIkowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMRsLrBGhs90YjtprQGqq7Tpr0t3iJ6Kx0lrRNEZOpIyAiEAkdUSvcOv\nut7oD1W0P2RVoyLbtmOL7artwWpWzOCyH1w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbv3T0l6Ixx1s4PeP26u3a71MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y5ZjFiOTMtNGVkOC00MDIyLWE2MzQtNTUxYjZhMTY5YzU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjYwMWQyZTMtMzIyOS00MDYyLTgxZTItMzdmZDBhYzVi\nMmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtFbVMdm6NfXMhQhK937vmvXL\nEhdWy85NGStPl54IaCegLYImLsZiWjLKd6YkDSj3vb87x64cURhmV0tyF4EkcaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpRRAJUXENeiYaZExV3JvQNjCbE0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAvVJzJcGf2CLlyabos1p473LVROKY\noPjhTNbMz9R2yEgCIF2LdSt94cnQMAm0FV2aOWJftcB3Dj9Vxrvn8+raQpON\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2306", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2306` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQ6MCTxharsCQCe4AECZMQPvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkMWM2Mzc0LTU5YTktNGJhYS1hZGIxLThiMzllZjc2OTNlMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJiMThhMDAtZDUw\nZC00NmNjLWE4ZjItMTIzZDhjZmZkOWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo0+j/k3MbbahU94E5PSa3dCxH6SeEnhvmUHThN+cHCt8zx5q2cvhl+utMkro\najIzFykFXFmmGavPo7a9r6kdaqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR1st4x0W9SrfPvrNIRDbPBS1KCcwHwYDVR0j\nBBgwFoAUZVM6IRU6KsqtJbmuFyvLKdHTAIowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAlhvMc+cWjeX7YWzXTsMGCJjPbg8scsMzJ9WTXISYL28CIAMzAvcSr4jO\nBdJeZ4jUVsxKPRYc0r1/PaCkF9VPXsLy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdBSA7IaAE7eVtxs4vFrJxUEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDFjNjM3NC01OWE5LTRiYWEtYWRiMS04YjM5ZWY3NjkzZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMgWIbFBKz9RZiE1dhewU3Jc0HtdEml5x17Rr0SRowNsDP\ns1SG/CYv+JoaoBD+4zQRQuPIfXPIlPvRh8Xp78aao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZVM6IRU6KsqtJbmuFyvLKdHT\nAIowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYzJZn9Puf+R8u4cc4A5i6ZHIZhcOvQGL+cgMYooxmAoCICP/b2r/aVX4\n1jkCjOTUIuABMkn5AEMoBtFsW7TAH463\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbSN8cFWQkolMG7+F5RR9cKSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJiMThhMDAtZDUwZC00NmNjLWE4ZjItMTIzZDhjZmZkOWZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTc3YTlhODItMDQ5OS00NDU2LTkxMTYtN2ZlOGUyZjMy\nYjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvP9EKzj9Oygqa2zCkHDGghbL\ny5IJbEeJ/XT4LyVolQw3pOs/mBSPHPwGIXVwAz9LtAt5FEZEsBEi5MPjG5Zb36Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUR1st4x0W9SrfPvrNIRDbPBS1KCcwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAzDbw6JUUrlpxe5yGGQMaww6Ta/XXx\nEMOFTCP59FojTAIhAI0cKtU+Sdn9jO1wgfF53Bs6b37HzQe41MSS3zVKr3Lm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2307", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2307` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdm4dqK0wdi8tOm+NNtPTnEJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlOTAzNDA3LWQ0NWQtNDNkMi1hZTZkLTIxMWM4ZWQ5MTgyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRkNWUwYTQtYTEx\nNi00MjI5LTk4NjEtOGQ0ZjcyNjg5ZjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaZ4mEiesR1mcLOueBPJEx94QWnePlODw0R3puZFjdSXFHZqrJCyZXbn1Vrcy\n/GsUzo6BWwKX/d/a+Tni/hJyLKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9BV6TZHA8FNxgfM7LTsm+cTG9YowHwYDVR0j\nBBgwFoAUALPnmOuktqWmxLAwQN1BaiEDJxowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBb5gpTeHhux20hEyF9MJ6xKCmDYgXdkdAcSbBT2vWBHAIhAIAeKtZUGiDh\nRNYMPzDsVKZNFpfInCH33qG8rcVxi6HY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWQpjT9QvTAAx9B95e4u/vf2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTkwMzQwNy1kNDVkLTQzZDItYWU2ZC0yMTFjOGVkOTE4MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQj605vBcTFyXeK7UjSvDiX/wZ+r37Yz32XZczcayfjJIaA\nzTPGKPKbn6xfiKUR+PqhmX1u97y5abUGi0Cr/fQ9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUALPnmOuktqWmxLAwQN1BaiED\nJxowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS24D4mSp5L+5Fqx+UmvNMB8r2E+QzW3fv6iv1//eQwACIQCfV+UHmmli\nUKiL74Azj8B0ArMlTv/T3dCMKMxlzjYdbQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbHpggUa06NebC8lSNyGeptZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRkNWUwYTQtYTExNi00MjI5LTk4NjEtOGQ0ZjcyNjg5ZjllMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjEwZDE0YTMtNjkzOS00M2NjLThhM2MtMWM0MDYxMTU5\nMjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG01YImpotqNBBZEPyDVMJ0W2\nIRoUKJcS31nAvHGGHjKySl44NwVT2ekXX/NrT6q0E9YKlDjyw9HA1re3QQCoH6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9BV6TZHA8FNxgfM7LTsm+cTG9YowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBofuAmofJRlltNSn94pFL47j0OnhLh\n+mTG4L6dePgijgIgKsqo1Ulohvy6gGEHTq08vBgfI+2BLvZgGaZX24EGgLs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2308", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2308` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAcyzg8RlRNVnAlBC88hIhSI2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExNTA1Y2E4LWU0NTItNGY2ZC05MTViLTRlN2U1YTkyYjJiMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThjNjlmNGMtZTkz\nNy00YjVkLWE5OTMtMGRmZTdkZTkxY2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElnAG+rc40T0o4847HPpisTMEX3MTpp3rfC16MSxW5QKccy4w7t6RWgVMe38h\njuYS2p7I25BMsLn55tt+5ADfjKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrxSCk3FudZxoUMrPFnDii+obdVYwHwYDVR0j\nBBgwFoAU4dKgwKcDt3gSBYdTRrzqWK7HlS0wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAV\n7XbElOSdd7h3ArT+ZLp/dEQ+dW+BobEEGsBcZDmE6gIhAN15ZE80oDMASlcnWzE9\nlR1VX7dZ/bs6VSYjW1TjodJO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZUyOs+O1oRJl2vcDQQdHnFpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTUwNWNhOC1lNDUyLTRmNmQtOTE1Yi00ZTdlNWE5MmIyYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARE3Y1CMg9PGCQnT+uZSI9t/IoEFPV0hbgmMJNBDjEXy5fb\nAFQmM28zZWDinWIfxHtkdRvL4iOG4TUthZ4RR3rEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4dKgwKcDt3gSBYdTRrzqWK7H\nlS0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIaa5O2FssAdvemPDZa/4uAX6ZHFwSPlJOXvlB84o4teAiEAh24x+Bti\nGi8Z9l0eT6dhjFKWlQTRaE4uRzXhxWDvOJg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAU2XpHccW7zIsGgd98hhxylHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThjNjlmNGMtZTkzNy00YjVkLWE5OTMtMGRmZTdkZTkxY2Y3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzQ4Yjk5MTYtNjU3OC00NWI0LThjMzUtYmM4NTk2OWQ5\nY2VlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcStJplU6BBDtFRuYy4giM81m\nOPk2r272vGL1qZ2aG32AJEE7ILE7PSbDWuxP3Lp0FfX7+ItmI0QhIs8ail+jCaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrxSCk3FudZxoUMrPFnDii+obdVYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA+dbUzpTQ0XgvmZXDy2JHLdrAqOe7\nWJFXjNh0NFzjZWcCIQCbHSRo0Pjd+50nPRtVw/abx2KQYPWa1cgRirdY5At84g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2309", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2309` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAcNU1otflMc1L+zgk8oGZkftMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2ZGI3OTFjLWRmZmYtNDJkNS1hNzc1LWU1NjQwYTNjNzQ0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY4YjkxNjctMDc2\nOS00YTU0LTlmOGQtNDhhMzBiYjhhMzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7+LpFwjrK8mQPzNT1z4LCjyRFbQJyHnWqTDZq2h0BbYM9VMnNPaflAJh56bJ\nPEhseewpIX0fWTLu3l0TRW0DUqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKsK5+smpO5ht533uwxJeVnNeW4wwHwYDVR0j\nBBgwFoAUdPpQsdVA2t+8m9CjdawZKsv6uFMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA1MBtrVlEBJtDUUYyf7vlqgcaphYboFU21PvdcM9Dv04CIQCb\nkbF92/tSHGVgxEJT4jbjsxtfdWMQtGYJ0pLA1Ht8/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX6tmCtpfdzzQWVyDVKrOhDKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmRiNzkxYy1kZmZmLTQyZDUtYTc3NS1lNTY0MGEzYzc0NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFxoj81mTXTCSnuPVB51f1hfO0uZ6B61YDICdyzdaxI0qN\nAAVZRPBxbvIRtFWNrZLPfauL+VcQhOwGIQdZ37yIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdPpQsdVA2t+8m9CjdawZKsv6\nuFMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKMrhcWEeQ7LawaGVjDEYzVmRX6kf/lIBvvWfIhWr7qaAiEA/Rc29pWJ\nZ/e2+ORzCLJbgZ1/twGYXo8q2loIRwN/6Nw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdx8cmwMJTjWb6fPH93BNK4lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY4YjkxNjctMDc2OS00YTU0LTlmOGQtNDhhMzBiYjhhMzczMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzY0ZGVhYzAtNWYyNS00ZmEzLWEwYjMtNmYxZmU3ODc4\nZDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETDqCpDgIasJGkhFeTcXNtWEb\nqxaNTgFB9VfSuL+P/1FE0Befnck8rAm13/0Yc/jEQZfEXFXt9rqW6hUyf+67qaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKsK5+smpO5ht533uwxJeVnNeW4wwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA1+g4CHcNF4+C3vfyUgHDGes0rKWaY\nppPvbVYf+LPjXgIhAKhhykI7Jz0L58bo+T0dJTj/HQUm2jVRhla9GpK7+ZtU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2310", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2310` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAdApL5EHlRU+iv8jIwzBVsoMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5NzViZmU3LWM3ZTctNDllNC04NWQ3LWM3YjI2MTY1NzZlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZhMmFhNTktOTQ5\nNS00ZTVkLTkxMWMtMGU5OTU3ZDJhOGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Izlg4FIwlRxZDq2ZNG5PzZqgRQ7gqIi1OMrJtkOzGVnJSdsUoNo3b1RzE1h\nfIdx6KMrU1foCCCKi2GjKBBdNKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmTwKZuLj2uuqn9CfXjhmt0eQ/RswHwYDVR0j\nBBgwFoAUctmnjYRrN464pkFXF5c3GpqoLiswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAmqOIECs2ALOxaoE761mzPBuC2vdd+LINbz2DF1kVjQwCIEBu\nrrlRZjv5RTklntdbbxFzFycDADt/ugQ/YQzOMOVL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcybpgaToOjYlndFco9Z/mngMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTc1YmZlNy1jN2U3LTQ5ZTQtODVkNy1jN2IyNjE2NTc2ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARp5x/ij/Xidblh7xr3bUGnltVqWBzY7SyVIbPdrjqjYJiv\nHeppmPqYDqF8BBImRTk9kq/YSeadH7By+ZkqbVlyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUctmnjYRrN464pkFXF5c3Gpqo\nLiswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPQm9V3/Jzag0ceNIVkh0lPccooEXJ5Xh09VGojoK7CtAiEA6SGclqYn\nA19LkXRVOq1Q0+oA/v02SVrOYYaMli9kz2k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeLsWvzMnsadjab9I8JGZPteMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZhMmFhNTktOTQ5NS00ZTVkLTkxMWMtMGU5OTU3ZDJhOGFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmU3MDI4OWItM2ExZi00YjdjLTkzOTktZjcxZjk1NTlh\nMGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYRGvnL45qi4RdVT32NmB786w\nKjtgpwrjXsQD7Tjq6ifawkKi5lwZTv/KcNhUZmyPKtunonuT9IqolXxQlnLTlqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmTwKZuLj2uuqn9CfXjhmt0eQ/RswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA8zi/0SvH4FDf5x7GIOt57KiXww4C\nsY2RxbD9Sq6mfEICIQCFGVcgNKkLUyXP1t09gClMBM518qHJX1if/GMk4Oa/kg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2311", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2311` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAUZPRYuqbENIglDX5ox6OMMbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNzAwYmUwLTkyNmYtNGI5NS04MGNiLTZmMTM0ZTg3ZGU0MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBlZmI1OWQtYjFm\nOS00ZmE1LThlMjItZTk5NDBmZmE2YzNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj5bYMofNw7HCqIyhUzX5/nU+mYnpY9EllOJxKFxkRhJ76PwhtgoL11raZyXG\n9uAhaGCNMzlazr5jKzcsnptu9aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpZeq15ENWeV7+R3LZAB96xc2EA8wHwYDVR0j\nBBgwFoAUQ3iIhg3xpwOG4v/RA5ErQV5EUhEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAgIoMWliKfbWK\nPN8DlDhd9Xtifkno//1uFAL/Oyd/orkCIHI9RzImhTjcL5uPJ5oYjPHGRumyrzH1\nPRG/ED08FfVg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUTPmsBJGGt50bEusYhoodsjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTcwMGJlMC05MjZmLTRiOTUtODBjYi02ZjEzNGU4N2RlNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTmcLuntwrSLlz+c8w02oYLL4tK8IM6OiMl8v1/Vr4SzJ6\nYiIG8OfWHoizj/2qNGNWm+n17oQPI1+OQERz7esdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ3iIhg3xpwOG4v/RA5ErQV5E\nUhEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOnrK7+5lKwJI099Y6JlFg7WDRQHupeqgGqQaau3rBseAiABpDuFJHzc\nJGSFddSPqi8dZRYo3sqJCS6Rb0oNeMvpNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARNZZhOuZb6lfSW8Nh6qJMosMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBlZmI1OWQtYjFmOS00ZmE1LThlMjItZTk5NDBmZmE2YzNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzkxODNkZTItMWU1ZS00MGJhLThkMGQtMTY2YTNmM2Ri\nZmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEswdNkJ3YRjacgyn6z5sPGdcZ\nTGAI96T4ugKx4xPvVcBnJeUR2S6V+NR1AEWfLrrvsOiScU6hReWLQ+BJil8TbKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpZeq15ENWeV7+R3LZAB96xc2EA8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiANTWUVZQFhdmJ/f1dVAynpLE5tqXDA\nvuG0ODNBb669lwIgK/xY7g553QYaKYsVMa3NT6R1c0bC8xKU8aZFQaxymns=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2312", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2312` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARySgitOOa+AwfaQbhkw8waWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlNGE3ZTY4LTEzZDMtNDYwYi1hOTZiLTY1MWMwNjI4ODhiMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdhOWQ0ZTAtYjEx\nOS00ODJjLWFiMTctYjllYWQzY2JkMGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzStpuNO9bpMmSz7ruf0vQlOWFxnq9zWqUfJZIaFlLlKqv7mbZAdeTrWTmXFh\n9X0FtB7jompvw0O5IxN+er96CKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHMYiKFb83wILS6ABzpQhpPtMBIowHwYDVR0j\nBBgwFoAU7vEXyQKEQRw7A/I4Oy6navvByQAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDAf+3a2jqRgiJJYs55KXRqvyzrprEkFiFmXFYYQq7/mgIhAMcrEisJHlP9\njTDdeRa4AVwkkMjJ/Wc5cB6dcxN57HJg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYy/TX7Lq2gTTlIaySS7Vfm1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTRhN2U2OC0xM2QzLTQ2MGItYTk2Yi02NTFjMDYyODg4YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKcmmUBDBWUGT47ZaRFfLNXVx91ShX+XuacXqLePqiayv7\nSZdsXRC3vJFXc/3w/kf6TLzXA6tXIWBV8ed+sWVpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7vEXyQKEQRw7A/I4Oy6navvB\nyQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL0Zz40j07RL3SMHZq9lF0ZhG1WdYLS/bAVPUuSg0auuAiEA0xfzgS1a\nMBK7lrh9I1j7s6vZM80JwaTGm11ScOL89Kg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQzp1kiiqnaiuTGLxFaKaa2KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdhOWQ0ZTAtYjExOS00ODJjLWFiMTctYjllYWQzY2JkMGRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTYzNmZiMDctODc1ZS00NzZjLWJlYWUtMjEzNWZlYzMw\nNWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQtrwkXeT+Rl6SfLHCLiCpW5T\n5bIe/rnka7E5fG7W+2pmJoiWhK2AYZHhJHdct13Pqgxn6thKhrp0LNQV2kNF5qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHMYiKFb83wILS6ABzpQhpPtMBIowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAmmAgUChRSvsv6Iz9o91kOYpyEmtBv\n1I/vjjdZoE7iJgIhAIqgvgndaGvY14SPj4kscgNQjMimV4662o3XRBUksEYp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2313", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2313` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUnxR7PycH+m9pLvc8f3zjhKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyZjZjZTY2LTk5MjktNGVjMS1iYWU3LTU3YTk2OTc3MTM3MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUxZjI0NGYtMzdm\nZi00MGUyLWJmNGItZWNhZTk1NTlhMmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1lcUua3PIarqghtnvBuFthqOhlJ1xK0YbWTrlCR72uSvLJ6oRZJe5wySvL4A\nYjk1MYvxlY/HL4jz34z0zYiWDKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcXG25m8zFCyhNw6cQnk1kR4dHuAwHwYDVR0j\nBBgwFoAUqvT+ioUjI4eE+NoGamDxfO9djVEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDM/cmJjW03+AeR1/uSzdyc+EO8e1CYAqgYfN9+H1bE7QIgSp1LQuQJvpRd\nsemR8VpRLOPJz74LRC1vBwdAhdClQFc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARLXgjc+T6yrXlWSDQFb06gJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmY2Y2U2Ni05OTI5LTRlYzEtYmFlNy01N2E5Njk3NzEzNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStQoP0uoi0fTwDM91Yrz/3mxFmcP9GofmHV4K6Jod5zeW6\nrpxzs55pBIzEtG7qTytMlYFnNXqAhUFmF6rJ/x/+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqvT+ioUjI4eE+NoGamDxfO9d\njVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIga1maeBDMHnar4qw6dE0rZcxVfTES52LJivquu58onKYCIQCo4cC+SFbh\nsYulh7gATkXNkhSRIz3IEp/BnG1a94iIdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbavZWDPQyOk13ejU1Gwmxq4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUxZjI0NGYtMzdmZi00MGUyLWJmNGItZWNhZTk1NTlhMmJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDljZWNjNWItZmQ4Yi00MzBlLWFhODgtNWQ3NThlMmZk\nMzRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi7dH8X9XZa2ISkwRsC+n2rZ5\nXXT2Qg+0bUtUvZCYHUOCPo4FOs7KAPzDPHe39XQqXK0qtZWkUP6Tvp3KOgM0N6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcXG25m8zFCyhNw6cQnk1kR4dHuAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA4xowvb+4x+qCJkwLwjbIPeU+bxuQ\nUHO+NcGgeu0YMoECIDskTrOV/k5U7klUxCByPjD/MShQS93xz5/gRKUJca86\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2314", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2314` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISATwyjXRmaHxzFzq0bVEjRZQxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyOWY3NjA4LTNmYzgtNDRjNi05NDUzLTRhZThmODA4NTQwMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NkZWQ2N2MtYmFi\nYy00Y2UxLWJjZDQtMGRjOWJkNGNjZWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDcspB87u53DV8xx/QFe60JCkrfvz3u4Hx2O0coVGqi08Z6wEvNKKLFVI+i4n\nYl984oOsQnlgKOMhEb+dA/RwXaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKQYjbt+La7U2voKDsh7OCVl4TLwwHwYDVR0j\nBBgwFoAUyyBue4Juj9w9hp1jTwnxyBSoH/EwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEApy0pbOG5Pq3K29ByRLkzRFTVteYLqdbl+XUOZFJPtzICIDriE74jKdIM\njIvCBtHVQdIs04boUkTqO5Hu8iHzprBw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZZ4hUM5rtkyCRavsEmgoRCQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjlmNzYwOC0zZmM4LTQ0YzYtOTQ1My00YWU4ZjgwODU0MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVzoOig14NXQMjCYxlD7bf6N9rMJb9HGVFKMhm8uJNcwJo\ndEKxSIaWbBl+DAl7m7qnZpBPMnmMwmSSkySaL7n1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyyBue4Juj9w9hp1jTwnxyBSo\nH/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJvqRHy880OPbFiFDYz62Cfd7JwSXH4cOTqjzdAtg7HIAiEA/ED1A3kH\nPFRraV2bdfWNeow/q/pYOo126MzIwvLXyz4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcfrE6QZ7/vMVQnWUijFL2/kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NkZWQ2N2MtYmFiYy00Y2UxLWJjZDQtMGRjOWJkNGNjZWQyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWQzYzg1MTctY2E2Ni00ZjMzLWJlMDUtMmM1NzAwOGMz\nNDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEt1dDLx4QC0MMb5VuJmAc3W9Q\n48GKmUa3L+xzGM3PctkCTzms8G69Zduh2/fAE8Cg1HtKyLNb1HswnQpwrGdux6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKQYjbt+La7U2voKDsh7OCVl4TLwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBg8lSEfnkvfF0PFuYycEbHeNqgAbzK\nezjzmwBdr9GGsQIgILAOGJQ+m3fQ6ZuXel0uiSxPrG5QJDkFnOgsho3JMZ0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2315", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2315` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAX9jo7rHRtDVeS/956ETyd99MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4OTdlZGIwLThhNTEtNDA0Yy1iNjE1LTRjOWNhMTcyYTM2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRjN2QxZWItOGM1\nMi00NWQ4LWE1ZjEtOGUxNTZmM2UxNTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQr/RLfIaiOdTYhcAR3a2ZpBd/FMvDX9nUwxntf6xGhJFRGVH+Q1ZmeBxDDN9\nTT56RkQ4ynd1dKlkPHXaDcaN1qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxwcNXDz+fep/I0GXFhoowEipWYgwHwYDVR0j\nBBgwFoAUuWlZtDEjVpve9fiI+VcsJ9HpvlMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA3a7yRPz6KqFqbOjjWGCUuXv1fNyOAQe6kdUv5rhS\nNXICIAQC0C80Mh3ISdVLod95gQ5IoHjd+UYc89Wf6Qp5gDSk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdVBt+7OMiyNwTDBSAIKATeJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODk3ZWRiMC04YTUxLTQwNGMtYjYxNS00YzljYTE3MmEzNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWuvPQFjsYQwqp2GY27djeqiYr137ciyIWIPMjGnLvPOKJ\nNmObAxuLZOg209GEPtQHD+Z5lS9AFiYzHs59D4fco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuWlZtDEjVpve9fiI+VcsJ9Hp\nvlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK/mTo57ZvOjvirJIO/GeSnmaU4bsJARqY9LgkfvsylBAiBfKUxKNeGS\nFBrYefPtYKlDDYlHAxXEWKEO/b/lqT92aQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYu2Df9mi1JDb6ntSZbQR0pGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRjN2QxZWItOGM1Mi00NWQ4LWE1ZjEtOGUxNTZmM2UxNTQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWQ1YTk2NGUtMjJlNi00MGJkLWJmYzEtYTc4OTMxYmFh\nY2FmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwEGRiDnVKaFSq1JeZ2hcNwdo\noNN2+NUsMEMBYGwOsoVe/GoDLlL0ivlsgGcSRYGSn+c0xDnxc40J3HuzsTmccqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxwcNXDz+fep/I0GXFhoowEipWYgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA92MhP7J8mHHq1yWOuFaSuKzbtvOY\nayO2tu/dxLx4hfACIGDq0d+s4fuCIPcnuC5MAbvgSiiWF3UTeLcODc5NIaZm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2316", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2316` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAXu0UDKyfjIFrTSQM0aW6f/HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NzE0MzU2LTAxNmItNDZlZi04N2RjLTI1NTdmN2U1NmEwYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjEwNGVmNTAtZmE4\nNy00NTdlLTk1NzYtYjdlNDg2OGVlMDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL1Uf2Z8tTvEkQzotoseaER3zPz0GPaD2MoNDXydntIvSXkx2VXEs3AD2yt8/\npKAc2871qlpu3UswvenwZE0OS6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtmTlr7ROe/grlzQ2Ga9UvDTnEugwHwYDVR0j\nBBgwFoAUqmlTENZQix40y9sokgwTirmb9YMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAWMAoMvVRk/kbRjWzZ9QnoaslXFMn29Ks6bd5BdLn/\nnwIgbl8C+Y18xQlBkCF7bSEOLonKWhsLOHvn+AxHvCz4Z28=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbBs2L3OhWj2pipojcSarhLTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTcxNDM1Ni0wMTZiLTQ2ZWYtODdkYy0yNTU3ZjdlNTZhMGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+r+qfy0NByXPxotyB223HydoBTGJflj5OMfMw4MsRC5x5\n1jfSXHTAc09Jpm/UFm+/Fuoo+9fRU0vJgHEOn+Wxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqmlTENZQix40y9sokgwTirmb\n9YMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCSVGsnGoyPQISusprfGRHifItoZouG+wbXG8NhuTZiUCIQDmKFRd4C2N\ncXFlTsX6u5MQIIqTFrM5zR109ty3IaxRtw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXTZx4m0e3agrj9AY8WBzuzZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjEwNGVmNTAtZmE4Ny00NTdlLTk1NzYtYjdlNDg2OGVlMDhhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzRiZjE1ZDUtMDgyNC00NTU0LWEyODctM2MwZjVmY2Fm\nODgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOXEw8U0b1mcZt76i6jSl6u6q\n4A/Twrqv64shBV/84/CmMB1tJNgr7nb9zvQTLhO9FzXkgLZT2GJeTVtt9B4JgKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtmTlr7ROe/grlzQ2Ga9UvDTnEugwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAutf4y57E+O/E98sAPmBCzCkDrgY5\nw7Y7r0Iyl1ychc0CIQD1f6Ds0VnZyWnXa+34awWuYb187ZwkEKzDtOR/rBFidg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2317", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2317` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAfRqsuxdB77mfxcft/Qnn8ZxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMDk1NTZmLTlmYTgtNDc1My05MmQyLWJmMmU1NzFiZDQwNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk2MWQ5YTQtNTdl\nNC00OGRkLWJmODYtZDczZWJkMWQwMDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeuTFUoEbEe6r8by/dCXO6CqXOYySPacmUleWhCHhcixMbVWhFG1IcvNSIKmX\n/0WFchfpIwL+fg8w+/Bor7+1PaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0W/eee2yHMaIAjByPiL2y3RI9jgwHwYDVR0j\nBBgwFoAUWQeLz4FON4SHgnIW15h1b9fAjdswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAnB5FopiXkD/OIjSVuKef7Kd7ZvNzkbJqedXiR0Y3Gx0CIF/J\nqVa9xRX2VjufPFTOhmFiVnizYuSgMo2hp0c7agNT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbLhEKj5o+yDTMSlL4He5Q3/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDA5NTU2Zi05ZmE4LTQ3NTMtOTJkMi1iZjJlNTcxYmQ0MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnR/7Ubl8bTO/HF90PjS3guqhQ7DlIzdpapanSKCfoRQVy\n4/nKMcyXQLp2bNO32G6t0O2aEKtSdUVLEiZqDEauo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWQeLz4FON4SHgnIW15h1b9fA\njdswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBetiG41SIsNXm18+KJByY/vG915aMdhgpPEdQhGyo+MCIQDT/g5YIdQc\n/sixc+81zwbX8OuparA4EPsWE06l0aYQ+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXfWQO4TJEgX5RaVfkYeTfhsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk2MWQ5YTQtNTdlNC00OGRkLWJmODYtZDczZWJkMWQwMDNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTRkMTM5Y2UtYzUzOC00NjY1LWFmNmMtOTc2YWY2YmUx\nZTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN0Pl/K11g8aElK+v7BAQVzCr\np4nLC2/YESQuEDK4UBgR6iIcHFJDJKxjXLuc6Qpv3O0u0SRae73W716fBw6YZqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0W/eee2yHMaIAjByPiL2y3RI9jgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBtbLHBZagujf2SQuscJWpZ52WqNzM7\nrxm2IAvVn85JHwIhALwQDllxyt/IUz9xqbFYir4ZCucFC/TwijqBYX3T535d\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2318", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2318` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdGxjHEpU93BhxTCIayaDwYrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjN2Q2ZGQ1LTJiZDEtNDc4Zi04YmJlLTE3NjYxYzdlNGU5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIzYmFiMWQtZTg1\nNS00YjA4LWIxZWYtYjdlYWI2N2JkM2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYUh4WfYkVRuPsuPEfSMei/WDOuBj7sNae3SmX5xtAqQOZYMAKal1FCFzEWoD\nFHJ94JJ5Sza++g5tzNEfdOs3MqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUauBAWKHpEAPpAD9HPPJ7VwC3Qn8wHwYDVR0j\nBBgwFoAUDbFDLHfqs/SCBugs9Q1PJheMgxQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAI1eS32lggN2oOrRjpDF9SswgH1PB6tCvY\nupz4qCnARwIhAPJ7aDrnmxty+ucCZ3gbfxWcAKORwEjHsL7McXFUN0jc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY4a6hZkxvwvQfNDxTCLOkk+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzdkNmRkNS0yYmQxLTQ3OGYtOGJiZS0xNzY2MWM3ZTRlOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJgkBTLXnlyIEx7IygM9CUgt8m21IfWN15f0XR5Np5AyRm\nxw4FjoyR4oj0JfAcmg+gPI92km5LASIOyWjj8qvmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDbFDLHfqs/SCBugs9Q1PJheM\ngxQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXUnvLqhNYEuA90rXShCP7Ak2pyQ0BErOxpiDTt1koHoCICKhyB5+nlPx\n/5Y/Dd79y1ArdadxdSViR9jR8vCA4/im\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASWa41RQu7R+xJiivMIP0R76MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIzYmFiMWQtZTg1NS00YjA4LWIxZWYtYjdlYWI2N2JkM2MxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTU2OTFiZDItMjUyNi00ZWJiLTg3ZTEtM2RkMWYzYzU3\nMDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIpwml59JE8dYY/2qon/9zbTD\ncyXCnBCSomSLIv1yx18EWK/o7c7OAdGfIfXcMP9uPaLQ1LZubmkbH5FuEntIraNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUauBAWKHpEAPpAD9HPPJ7VwC3Qn8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAtk+ozqMQyr1oBQO/d0ZnFC7TJqDv\nhb4UNj5hRQILFkECID7G7xtT3uDs+vvFooLZ+fpHiBe6Db3MwZGm+kzL6vf8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2319", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2319` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZQbJZ92cJ+qqdQbYSxe3uh4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlNDI0YzY2LWI3ZWQtNDdlNi05Njk0LTkwZDMwZjAxYTEwYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmIyNzdmOTYtNjg4\nOS00NTJiLWFjMTYtNzM1ZDljZjI4MmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9dFsi/1MrBearlzOp3JEZ3Amr6SHnQFz3Ue2lNGnSkDIRqKH5TPCg20FM9oH\nbUvVSgapxVjWgNkoZ5gFSB9DkqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIDlyGAofMdnHjkxFzfdsk6VBJtQwHwYDVR0j\nBBgwFoAUin2uy2+G/6GvVxSxK7XUAhTC+oYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAhre+DqZCZT+7FcLk+oBj61DJulPQDW3r\nqVWabHIbSB4CIAuqd3M8vzbkvVnZurovJHcaplbuSuRVnCl6sFjRg7bX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUUqsirVxxPcV72lud+juAGIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTQyNGM2Ni1iN2VkLTQ3ZTYtOTY5NC05MGQzMGYwMWExMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbpGhgzQxI6DzDhVsat8BPYhI7Q8aGDyBUeWWxFoqvwCCQ\noh5suA+T6rykz61A9FNo+jM68rDenZaejEKI9QO6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUin2uy2+G/6GvVxSxK7XUAhTC\n+oYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPH7SuZGA8kLgfxrzhFYxRTdL6tVmiOFMq5G/6N4o2hfAiA6hz0RLbJ8\nx8YCED0FD9OHypx31zkXpMEf1hm2vFm0Vg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAc3nxtMXmAYEk9ibIIq99wWDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmIyNzdmOTYtNjg4OS00NTJiLWFjMTYtNzM1ZDljZjI4MmVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjQ0MjQ2ZDEtNTQyZC00NGU5LWFmMTgtYzNjODQxMjU5\nMjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeeBvonBuYX+wDdRHHx2uHcR+\n0Tn6HlWTJYOluxtwWIFG4sqqPrIOrgAZ/5RF35soddqOofvqbwB5A1T3/F+TdqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIDlyGAofMdnHjkxFzfdsk6VBJtQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBCu2niYYffIu/bUw9RekIf72yq/yr1\nrQwUQY0GFzAtuwIhAPj7FCCFpLaHLhZFgwa7DNkHjLp4qGUNa3gOWTT8BWv9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2320", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2320` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZYBgHYSHAzDggMukcQW0z9UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3MDFhNjU4LTg5NGMtNGVlYy1iMzFlLTc3ZmQ5ZmRhZGE2MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ2NTEyNzQtODNi\nOC00OWQ3LWI3N2QtZmFiYmEwMzQxYWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY5R/pFgunt2iBzzEZ8UoTaNENsuRuBTfiqlPsBRRSymqUKnKklXvylBhSdLl\nX2BcDogen2TWkAi3TYTaklVVtqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAmii951sTpvYdDJc0CBsruZjBIAwHwYDVR0j\nBBgwFoAU9nBHqQVj0+aW7JG/e2J+UFl6NeMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAQJBxPhwHLoJl9\nE1jWL3IykJxcn5dPOeeKyzw6iga3DwIhAILmuERGRZmTokONVJ+nNayaZm99QMyR\n9Cw4eLUOfFaD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQbIbLCA3BKlDnBLzj9tYAoGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzAxYTY1OC04OTRjLTRlZWMtYjMxZS03N2ZkOWZkYWRhNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzZKMInJxEvZM/fptNSJjTI+v0h6OuSCUFORziIbOEQ+0Q\n2ZPNQngEwuo1CSDJi355LmMgFNfKhCjSLrZzHPB8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9nBHqQVj0+aW7JG/e2J+UFl6\nNeMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgexQdCfN13t36eP28jp1YBA/PQXP6OsTlFdvwOP8odZwCIQClBymuomf4\npyF0nmjAaBS8fZ5Fg/mq00yc7CgUpDwjrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcyWEdu3wJiTfPSgUOrMVjyVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ2NTEyNzQtODNiOC00OWQ3LWI3N2QtZmFiYmEwMzQxYWM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODBjOGMwMDktMzZkZC00NTc4LTgwOGYtZjFiNjc5ZTg2\nOGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE9sN8UEGBBpgRU5nGwzKUyBR\n3DT/z1rnicJ7QS2OjCAeweyScg0D7knLu/nWvthbhBD+WJciCZxlb58bJE81B6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAmii951sTpvYdDJc0CBsruZjBIAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAgmZbjUVrqq7C93ABcUa9Fs9fq5+e\nL+qVfqDumVPQ4pcCIQCJzotvN0OIgQmk1YLWHC0pzogO9l+Cr3h7eQLfi5y8Aw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2321", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2321` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcIL2hefBYnXFG2cUY0buKNrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhNWZlNGIyLWNkYTMtNGZlOS1hMjFkLWZjZDk1NTEyYWVkYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRhYzc5YTQtZTE1\nNS00MDQyLWE3MDQtZjZhNzUzODVjZDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJPs5PMopOZTBiN1YMJYhwMXlUMdCacqGhHcs0KL9pOkkodnCsDMM4aCPEWR/\nQslGj7IFjWjxTTtCLJCb1jhA6qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIYOVBRWheE1InDCqaKNlsqYT0SQwHwYDVR0j\nBBgwFoAU956qw06hnEoE0YRP6Tkuw6xE9ZQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCDQ1HwTY0z3TRDimTVtcd8zf+ZKKWW0km39/dtwkGFswIhAJHKDwrCxdkZ\nH2/W219Cz1tGJk5xNiBhumG9MNLl5iNu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARylp8HWDYhrc9WGVBQ7g6iXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTVmZTRiMi1jZGEzLTRmZTktYTIxZC1mY2Q5NTUxMmFlZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRCRy8JqgxFQGdLJk2avuL+ZJdYNO/T4nmUZ8GRYzRU88j\n7U1p65JM5ElpTmJFSV2kgIGLcHl0I4tbVEeebN43o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU956qw06hnEoE0YRP6Tkuw6xE\n9ZQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeuGFo1eMNWQhkQA81S0oOE5xOodhVg/yJaA9cDqOUFUCIFwMgV4q2egm\nFc9cdpZlWmygv301iSB9R0rfiozj07T7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUbosLVnWsOC710M1Qyqtn6XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRhYzc5YTQtZTE1NS00MDQyLWE3MDQtZjZhNzUzODVjZDdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTQ5OGNlZWMtOTA4Ni00MjU2LWEzYzktZTEyZmRmZGU4\nZDZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs4Mk3fKawEx9dsxY8y2ZllRy\nAPvtLtqzuSrHVDSTCyv8eZ2KDTi1kK0DQtEEyTtzNMLLYVlJ1DnwBeeuV/as4KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIYOVBRWheE1InDCqaKNlsqYT0SQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBthOGMY1fwyVCXyx7sCa0qt3hx3TNk\n5JxhMUfDDy5EPAIhAOTvibj3NjnsBh7Ii8mTD3i2iqkcvXtn4YT6oANbUD4L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2322", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2322` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQwM+Nh5HpFGeAjYUzWonXGdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2ZjgwZmU4LWNlMTUtNDhiNy05NzY4LWNhMjQxODI5ZGY0NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIzNmJkYzEtMDA3\nNS00ZmVhLTlhZmEtNzdkMGZlMTUzODA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvt9MiCoIT91e4Un7pYZ9XlYX0KLeJ8e05iwRBLevnSozzsFxZ0GNZjBJx371\nFkN7xL6IGJ2wWv+Kmbv4NhpD76OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU18hAk7/hNkepXg/n9C6rEGOJKgowHwYDVR0j\nBBgwFoAUzvGNi4pH7E9zHda97B2Z6Ziv2zQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIH/KbeK9iyye4xRieIJMLJnmYqF0N8oK5XZZn57dmMFTAiEAmjcSxw/YV03O\ndffGC2lTT2Boa9bsEFfnD4JpFR+LXmY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYx8FwSxi7+q1cExVgiCcn/wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNmY4MGZlOC1jZTE1LTQ4YjctOTc2OC1jYTI0MTgyOWRmNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6XWQVgitssJ+U4BIdXbsUxz2845PFkbDGIs9OgaWnETwA\nrryfegQEXbb9MqUtDx+llOqJPL/JvMth2SqlFbhco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzvGNi4pH7E9zHda97B2Z6Ziv\n2zQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhrP/7Ekczv5Lp4Ku20qqRTCAQBOvzroJ72zciAMn92AiEA0glPSLQs\nc/OIvUOvNrYSnLG/M9OBW6u1LWVpE4pBszA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQJM1YxjWHQ9Ifz53kzertHDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIzNmJkYzEtMDA3NS00ZmVhLTlhZmEtNzdkMGZlMTUzODA1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzU5N2I1MmMtMzdhYy00ZjIxLTg4MDUtZmYxYzJkMzRj\nZmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOSSnZVjgy62kV4kShDYigqjT\nt3H89fJRe4h2BRb/+kYHrzEi4X30tMPjUbeIdpWSUKg2CgEAMs4w6CNsUixKI6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU18hAk7/hNkepXg/n9C6rEGOJKgowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAsRXWMXtLgLOXFS2q5ZGqDctr4XmlY\nZwprYyM6Z9BB0QIhAIeGun9sFvQF5T5zek5nMs54yrfsalTxK8fkqTDNY/IB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2323", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2323` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVwENM0coubaRKySb/jFVKP9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2MzUyMGIzLTQ4MGItNGI1NS1iOWFmLTk0OTE2MzYyYzg3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YzN2YwNTctYjNm\nOC00MmM2LThlMDAtY2UyZTgxNGI3ZjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMX+aF+QLKozrmVd5OfPV5J7DhvqCUUL9vk+oxBZ7WeJ3EjSxRteT+AyVn4Ui\nRidRIytbHF8j93KG09k2PXWm2aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNfuorIKciMaU+4WboYPNEREBnCUwHwYDVR0j\nBBgwFoAUPlfW4uOi/YGtTTCVezg82SiemOIwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAys9VNHTA4Ih6csh2bz74yogLfxj9Qmy9cwgM+FZGxuQCIA4NVGoax4YR\nBJwi8qx2y56ubi3DItJlXiDPoA0kOJ6T\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb/qgpMwsUfoWR0zSppc9i9JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjM1MjBiMy00ODBiLTRiNTUtYjlhZi05NDkxNjM2MmM4NzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKnxIMHZD5mn/4WMIEYlgUB6IHvqGKtFH6hn6tF7pDkx/f\nbS5HdUOQDCoKkIgisTw75M9Yg+tK4yPvoBepngBmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPlfW4uOi/YGtTTCVezg82Sie\nmOIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANuuZ65KRPMehexiyQFKPs7gqAX6dRhCyyyGPoE6sRuWAiEA+x9tFWf3\nQr5D72903L93PR+UBaFKb0QrIe8A09fq2oI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbKnUkiOWSrLEtWj/JMlM86mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YzN2YwNTctYjNmOC00MmM2LThlMDAtY2UyZTgxNGI3ZjExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTY1NzAyMmUtN2EzNi00MTQ5LTkyYmItMjhlODMzMzgz\nMTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMFiMDWyoqwvxdSyhWnsC5GkR\nrykubyq4Mr8OGaWRRAoTkAgWRTJ8oUn7gRbhKhaz/A89NFr0Mtt5A6g0l9oqwqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNfuorIKciMaU+4WboYPNEREBnCUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBprOB9LSWxUI3e8DInAXveVOal08wb\n8Z9wg9YAJ3NfkQIhAJuzgbhhk0G26qSgcHj8m2YQb6mZ95fkhFcneyr+zSTI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2324", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2324` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAYD6NZepAYsiq6YtiHe53oIaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiZWVmN2QyLTZiOGMtNGU3YS04MWFmLWI1ZjYyZDNjNjkyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmEwODc0ODItNTA4\nZi00ZGQ0LTg5OTYtMzkyMTc2MGRkYmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC7ERaWAtIr2AvA/VFkEL0Qi3Na+/Kb1g1vaNb4rCFKeidATtRKndgKYA1Hn0\nqnXLczIBFN5ZJmoImfYl3UC0SqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgHmXO+8c7foxGMP9El8w4IZIe8AwHwYDVR0j\nBBgwFoAUBShIvyLZDjIdVJT6/kDLd3Tcd20wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAdjJ17Ep9yuAoll87Bbdp7cGRbpzdjUwRrZyEq3a1o\nnAIgNjIa5GW7H+VOxjZcvQJHmYwmK+GW2Ll9Xek60Nc94XA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYuSXbsjc3FnOC12qwcnmYFdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmVlZjdkMi02YjhjLTRlN2EtODFhZi1iNWY2MmQzYzY5MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEUC/VUSo0vlvuo2ZStfITv+UedC6f8/sFN/wIzcMCWyVL\nj4cJ3zIgsUeVgnABC1UdBgtMJzyJCUMN1Dno1ErEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBShIvyLZDjIdVJT6/kDLd3Tc\nd20wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPxwQe8P93By6EhiE313O8l1wMWgxpJg/Wp/taZFNw3cCIQDGeYij6TTW\nM+7pM8ZmThujquv4ZZHz2sPqWH7/Op8v/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAd0GmhECwD7tgO13lzNN4J8pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmEwODc0ODItNTA4Zi00ZGQ0LTg5OTYtMzkyMTc2MGRkYmNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzcxNTdjNmYtYTA5ZC00NDQ1LTliZWItYmVmYzdlODQ2\nZmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErBI8DG0EslvMsBxIV3q9cj9f\nxcI/UqMtMYiX7OiA/REkrIAv3ZZ3ugeUM9/70ad5CnCpjv9A/UjerWetmIB4zqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgHmXO+8c7foxGMP9El8w4IZIe8AwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBDiQy8UV3oD6QJ0Knx2kOBW/ZDV7as\n5mnlieSBD0ZlygIhAITNCuTazS9lTdQQYF2KlqULkJlMCZC+bvC6vrAIcgow\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2325", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2325` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUTisQOt63GT/GAbUcjL1XImMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkMzExN2ZlLTkwZmMtNDZlZi1iNTE4LWYyZjg1NTE4OTQyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODEzOTM5ZjctNGQ1\nZS00NDYwLWEzOTYtNThiZTU0NWYwMjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKDnmnrp5FkBP5qgVWiDKitr7CPcSVnBOBJlZm/0B3w5b0Hdd8C7gB9i1vfpV\n7Kxmybu4o++tNiuUfNXCdyHZC6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmvLViufa+AVV/zfCtGk8tvvwNzkwHwYDVR0j\nBBgwFoAU68bBbAqlAMVqRTFeylgRjZFKhzowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBZpJEVELpAF+9+WPTT3OOiKP36F2n9RgWQ46uXvgU4\ndQIhALOiuqXLIqTW+FU4EbxiGfXLM3qtlFn9mhkF6b00jF7P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ1c7fPJ/rYkGn6NQ7Zk8V6wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDMxMTdmZS05MGZjLTQ2ZWYtYjUxOC1mMmY4NTUxODk0MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVvx/j8SelOHeNOHx9oC/YIn1uUBPTGG0j84/2IgOAmvAv\nVWpKj4/kQCwe0YdQD0x/XY+gemd54s1YiV/jLft+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU68bBbAqlAMVqRTFeylgRjZFK\nhzowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANQytETnGmNrGYdHnqekrhgYQsI+ZKmsAjQzBxx0mdb0AiB55ihxCKcX\nhjWLGk+2Gfd6CRmkfHIxUjy+t8h9pE+yOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdephxZvUq8nzMTbkCB8QRMeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODEzOTM5ZjctNGQ1ZS00NDYwLWEzOTYtNThiZTU0NWYwMjUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWZjZmQ0ZWQtMzFiNi00NThkLWIwNjgtMTlkZGMwMzBm\nZWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV3kkLW2xlMo2nS9F9gnJrddL\njo6gVenu2tmbheUFHv2fKednEZPulr6PkuEY4rAGeNsagq5GgpUplbZ+80OTXaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmvLViufa+AVV/zfCtGk8tvvwNzkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBFQhkmALjOKTaGCeM5Tvd2kesQ0p5g\nJ6FG5X2EDplQ2QIhAMN9FdR/W7hAmAmu10TCYYP5gdV1ZIo1QIj5axxUdhg6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2326", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2326` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISARZU3uQKmhRoWGOec5Nm00q1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhNDliYjgxLWZkYWQtNGQyYy1hYzQ5LTE4NjBhNThjNzEyNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWEzY2Y1NWItYWJh\nNC00YWY1LThlMGMtY2Q4YzMzZjU4Yjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl8psBlWm0lxfBx0F4muB6UGBliNohHkU6tcINOL+xcZFh7OyZ5xEgCoa1C3G\nKGUTKnE6ikUab1Vitthl5hpJoaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaxRCCdizXRxbEv1VzeyGyS4tRG4wHwYDVR0j\nBBgwFoAUClQ7pJ75G5VOUGckCPVxdgPpzr8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA06kOeIzyM7CqOey9jJN8EYe+Kcp48nzMhCO1PviNdg8CIQCy\nAkjfhzaCoUrLBvtA9+FeaNzenKAZhkwfp3UhncDcWA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQlEdwnc3UQf3jq4KfbORe0kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTQ5YmI4MS1mZGFkLTRkMmMtYWM0OS0xODYwYTU4YzcxMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHSodInBkOtH9ltPQx7QCWr7aMwXgHH0sbqoMiMjTCyj1n\nE7EwJMDdfJDFudxPDqmNkYPB4SyvS+adB/lEP72/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUClQ7pJ75G5VOUGckCPVxdgPp\nzr8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPixWm6xHklO2QRcNUJa118rJ0xBMMlWcmDyR/Fecck4CIQCvFtKxXheT\nEfboscw6mdD8jX+VaafIdKWH7TqtNMdfsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAU2TDKPiOpf0Yfg+tWz3YxtnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWEzY2Y1NWItYWJhNC00YWY1LThlMGMtY2Q4YzMzZjU4Yjg2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTVmN2FkY2ItNmRiYy00NTVmLWExZDgtZTU0MTZkYjQx\nNzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElhFpZRygIGyl1LsKGQXjA11M\nRKEVtrPB6M5LOeq//+7IvSX33i6DWclx2apkKVYMAR5VUXbFNKvnBQVfjoPZ6KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaxRCCdizXRxbEv1VzeyGyS4tRG4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAqKvmcpuWktM7gLMiQf2JogPm6znL\nYU644tcOpPPIx/gCIDE9K1gIvVWloPZRkGsSIPyaMdP7VT+22mzO7yM7akuB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2327", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2327` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdFTzECcWC/V8NJdway7XXb3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5YTQ3ZTNiLWE2YzgtNDMyZi04Y2YzLTMyYTQxOTk4MDYyMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUyM2EyZjAtMjA3\nNS00ZTk3LTkzM2MtZDRhOTQzNTU4ZDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElDScMNH9PPefwGownrR3mAFxkLZ9PJTxhW/kPQm2C5dsfMfAWFCmiFQq+pYK\nNQyNlPHLgwc+C79Ut9UHD7uK7qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Gg2ZTmu+YH8vYQ4ECuPVCOgU0MwHwYDVR0j\nBBgwFoAU1VMX+8AzbF4RmchQc0tlwx1w2BIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAs6z/am+HurpKcUYW6/gQodJLN1iBwErf\n2nCiT21EwEkCIGuWVXypsaF7dPXNUxs4TQ3r2/V6xUflBESU73GFNpYV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc9B/UZq7MoBQ4Tzs/AWmZLNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWE0N2UzYi1hNmM4LTQzMmYtOGNmMy0zMmE0MTk5ODA2MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+W4X2VcKCc35wFLnBiLjdrmX/ydDbMK4E+0TUktvHsurb\nTWZnFfMwq1xlRK/ohWdgW5f86kyzilJW6wXOTGzZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1VMX+8AzbF4RmchQc0tlwx1w\n2BIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAzWBded3+iBBnpEFMqpr2pXB8GKcImwwtwpUH7P9EycCIQDiBTPHN+t/\ndb8xeDTdEuirzzgfqFranOVE6qQbucFu+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAc8kVpaYrmr8vTYqcx+t9TCOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUyM2EyZjAtMjA3NS00ZTk3LTkzM2MtZDRhOTQzNTU4ZDA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTQzYWVlNDktODJhMi00YTg4LWE1MTYtNWIxYzM0MTRh\nNDUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsPXpPJgAw4P9pdnvZfd6depo\nFwuJUz+AImW4t4npRFwJ4aifUZ94ICBvZQ8MFDhUGLjTwglPVcPfCOwRzgLvOKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2Gg2ZTmu+YH8vYQ4ECuPVCOgU0MwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBjA3EpXitcT+ukYxbO2wnzPjd/Re6j\naccvjWAr8eWRJwIhAPy25uo6KU+vQxi/vKSim3BLcCSKdX0I3Zd6g+e7xiUa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2328", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2328` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAWXiGhl5ppGSppNjQTIJY3P6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkY2ZjMmQyLTdjYzQtNGZjNi1iMmRhLTY1NjFlMzAyMGU3ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVmODg0M2YtOTkz\nNC00ZGJkLWEwNzctMTE1NTQyNzMzMjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmHQcVLv9/IcA0poSjgk8RuoYS6sbUGIXLfTqJIEZ5UyBsBnIraPC73z5KcZy\nVDv4k/fxG2ImoJpl8+wRW10cA6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWdhWatRFBUWCCgFeMLklMkin/NEwHwYDVR0j\nBBgwFoAUg+wmzQC40HRpFY2fC9csTDit8O4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiARyqQBlPhfKyUF66ShUsxk0wt+tnciABtV\na9LJj6M3/wIgPI/NYpiPo9wfCoWODQCNiNELrTHaXjLGRWivz+htYAo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATu+kGz8oDDQNu+F8SG1cQ2fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZGNmYzJkMi03Y2M0LTRmYzYtYjJkYS02NTYxZTMwMjBlN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRJeZPGz6mG/vKV+K8qrT5ZIulqhVbtSzF9DWEObYmGM5A\nE/IllabI64KvSVQLgBm1bAV8kVPhz/5pa9yvcPDco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg+wmzQC40HRpFY2fC9csTDit\n8O4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUitCRzzD/Xr0/HDpKIo9+2DUtZMTCovlDy9CYHrOAowCIQCKw6ptwpqh\ncFj3lWPDr3e4BUKeoaUBe7gYRjb7r2Vo2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaehwkOysairZVKw4+fX2seYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVmODg0M2YtOTkzNC00ZGJkLWEwNzctMTE1NTQyNzMzMjFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTg4YjczZTgtNzM3Yy00MmQzLWJmYTgtNzFlY2Q2M2Rh\nZDllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqBAz8o26T+Ipb59Dtfe5SM0C\nLUCM/ANz0lOC3s0w7sRqSWn9cDIGMc+M9vAKy/7eZLzsjmDB8el1/6EdYKYUGqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWdhWatRFBUWCCgFeMLklMkin/NEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAEjfElrt1vfVT694BaKsih0aRsiEVJ\nF1JKV2zJX0M3MwIhAN2Z1Pi1ttdIOR2DXQbdKV5Cd8vEFRnH4jnZEdB27apy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2329", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2329` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAR9j+L6oaA0zN3H9mhTtVMc8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2ODI1Y2RhLTg4NzktNGVkMy1hMGQyLWQ1NTUyZjY5NTA0NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTlhYWE4NGEtYzhk\nMi00MzdmLWE5YzgtOWNiM2JkMzNmMjBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU74JsZWK/UA0jromXU7F2ELBp9hLKs7JmUKpAe3iOC93O/GaBWmd1hbEoZf4\n+aGBn7/vwHsst9NjmAVw9VyXa6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBan1AVC36MtQaVxoaK02O2Sr/W4wHwYDVR0j\nBBgwFoAUQXUhrLNRMgHry2jmE6Yk/zqmct4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCq8E5Gpp65XkCqrhzewVT1hE67\nuE7zFLv2RRJKbjfIswIhAMnr1tQNQEgqvgz1Q9bu+pAYd7T8G5siqJKxEPc/puuF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXA0fUiWhrYAZL1rRTj+6FZOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjgyNWNkYS04ODc5LTRlZDMtYTBkMi1kNTU1MmY2OTUwNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbtGHT39jMZREW7ttQaNzxl41L+pcLpkIWr0rQWdpUV6P1\ndRctTQ/9JsTGx1g1Yk+HHvj4MEyQDHI1dwRkN4weo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQXUhrLNRMgHry2jmE6Yk/zqm\nct4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKc2zSMJbNgTqj2aCbpRskgIiQMvjIyLSFJ9PQqsXst5AiBG3bPdRPY0\n+mqCzqVFjiyvZyigONNd8IFw0LqQgfJaGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATAKMEx22tLGSucYZxZbjrovMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTlhYWE4NGEtYzhkMi00MzdmLWE5YzgtOWNiM2JkMzNmMjBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWJlMTk2ZTgtZDU5Yi00Njc0LTkyN2UtZTEyYTU5YTU0\nNmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4VctTNQpUthYyil0W+wEVPJX\n5GKuv2wSlFYgyneYwu5sq/ZBJ5EqOYTHl725JSK2paEgK7mB7HEWP9xxK5JqyKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBan1AVC36MtQaVxoaK02O2Sr/W4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA5q486n3lWlMRErnsrdoQN/KgJ5S1V\nlklCZX0zVAigPQIhAOPQhz5qa4fCuzB71xg/0vVMGWTcRDpQbPVE0Bbhb7SC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2330", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2330` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAb7Bl0P90Qso/yr8iMVGzrUbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiMmJlMzI5LTA4ODQtNDc4MS1iOTAwLWYxYmU0ZmFhNGVlMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY5ZTQ0MGYtZTU2\nZS00MjkwLWE2ZDMtODhiOWVjNmMxYzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQDaftMgHdSS5JEfqGcagxLDfkQx004YPcMT4/eabK68uVO+CtouPM088Q4dm\nvb5L6MCh9E/WBVLZSxrxLrxVtaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9NZguO1nLbOKcOZhp8GhSRU+79gwHwYDVR0j\nBBgwFoAUtGioG28n29seJ/V7AANP45E+p60wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJjWu/b1\nckRjBMSt22StKlMu/LlddDj6h/ut4TlznbAHAiAdqt7LD30diy6nPTe8d82+8CcT\nplVCPkqr0xNzC/Ac+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcYg/Jzr4kUBHkXyjE2/yDQ6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjJiZTMyOS0wODg0LTQ3ODEtYjkwMC1mMWJlNGZhYTRlZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScX5F3f541wtT4E0RypV9ARdp/464B48ilgfIf4VoCwzU/\n9RC1/7KwEov4GFN0oQ60feZ19ER/+JMd6YTzcDDao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtGioG28n29seJ/V7AANP45E+\np60wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOHikPsKVTqKMm6u6Vd/PNv6t8PRnpBevaJ5ZcPkyubRAiBvVyhpWPN7\nQQSEyAubwuXhYezd65HLy/EZ0XGMCC2naA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdB2d6jpa/moBepBEzFnfEXTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY5ZTQ0MGYtZTU2ZS00MjkwLWE2ZDMtODhiOWVjNmMxYzU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ2ZmY0NjktYzk3MC00Y2EzLTg1ZjItYmE4MjZiNGRj\nYjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUIObpgeCuogR7EHNGlIcfr4y\nJ3YNxYOuEn7dRzIYFCP6jaD4pCJkK/H/yuz5mZXFnqqsJDi3USAJ9nAdWFRFQKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9NZguO1nLbOKcOZhp8GhSRU+79gwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBBXe6KshjOmbzHcT9qKwOS/x1ORdM5\nF6ILpFKPCKkX+wIhAJueTqJ/pshNYCAocscKqJJVLa6QYi8Upo4U/BacLaxj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2331", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2331` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAXXO8JCmc4gos8wFA+8c5zZEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3MjUxMzgxLTdmZWQtNDgzMS05ZjY2LTRlZTdmYWU3YTlkYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzNlZWY3NDEtZDc1\nOC00YmE2LTlkNzMtMmE2YmRkZDI1N2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE+GlbR+HX4XKus6ZsFihAbNm0RIhlHG5i6jZdZ3Zb/YJDhr2slCtKc70uva3\nLTAIBp3CtPd5kQFeZ92ejBguBKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNf2a2zdiVslv2vo3y/3ND4FPIfkwHwYDVR0j\nBBgwFoAULxEi4HWFKwQCBF1FFtmkbGnmrOAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAN7h7X91\nk9nW1TZk85ZwXIGuSOFZ4DhwRZyeJWzIU4FBAiEA4R98iq393lr1S9AOHdn5zZ4J\nl6QCUB1wxpmWd8K2fYk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbBcedgZuNRbcLHSITHFtPmDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzI1MTM4MS03ZmVkLTQ4MzEtOWY2Ni00ZWU3ZmFlN2E5ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1BvS5BDpVIMRyleUx4v+HOHabu0ZRZ2/T3m8P/Szts0TK\nS8jku3/kl0n1BU2PBID97Qwpr07MgndcWww7HHg1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULxEi4HWFKwQCBF1FFtmkbGnm\nrOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA7sTTBaGmzgXOnHxXYr4E3jhGSxKlznABmwJmK5NmIACIQDxSuo5Xi3C\n2QXbGKKyQ3Yepf8mSQKNmr/IAsxlKpSZdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWze3C6muqP8ybCnHGhJjZ1pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzNlZWY3NDEtZDc1OC00YmE2LTlkNzMtMmE2YmRkZDI1N2M5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTllZTdiNjMtZWJjZC00MGU0LTg5MzQtMWQ3ZWMyZjhi\nOTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOkIy9SVJQtH34tDCHvQcw+Uk\nuFTogbBHxt3JlQMfD+8YFKsX8kPKK5qStGq/eo3LblhBrVQfSTUbvnGNj2eojqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNf2a2zdiVslv2vo3y/3ND4FPIfkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA9SgYukXNEYr+RcxydiaVKeqRNWDZ\neP711UWLGmIwnrQCIQC5/zkn0cPFOKKeqRnEc7VvnPO97sWsCh4UWYnMGlL8xA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2332", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2332` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAWNjfv+7aM0nC7xbNW4TKFt+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyNmExNTZjLTgxZTgtNDFmMi1iZDI2LWVkOTg5ZjkwNzE4YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRiZjcwZDMtYWU2\nYS00NTIyLWIwMDgtODA3NjUwNWQ1NzE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVmopY+50SUHeHR2lYTUEEyk8Sbw03YIZlJCRIes39S4gG7BiLdPbTGPAIJwx\nwRYkpqEqtw3FVs/xNTlf5ZoJPaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxKCfyFXTxaHL0s/IXEgejRaHjiswHwYDVR0j\nBBgwFoAUXR3yWu3gL6x8GGZJ21m+PVZchUIwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEZLbf4/\n8XaVJeCYlG+bUzJJGEI69gFROudfFjihE2/SAiEA/JE7u88m+0Qf1/d+py5/vxUs\nWjCoshwlSnwaw++Zrrw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb1824y2VmkoqalYwAnlgqkUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjZhMTU2Yy04MWU4LTQxZjItYmQyNi1lZDk4OWY5MDcxOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARj1Sjwa3O8yAYiIXyvu1rMEnEaZYMLLzwNWhiiII1Pl8NY\nYyuYeWO5H6duoynMHvAzPN1/w4+SxFUjUtoZvc9go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXR3yWu3gL6x8GGZJ21m+PVZc\nhUIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdHQLCInxWmm0xy2QTUKGkaaR97sFsiWVkBKwb/thmu0CIHcK9haFMNsk\nlJ50uMS14Qov8UCYq6s61yVKERluuEmm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAV2jkz+u51m51sFTDmBZzh7oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRiZjcwZDMtYWU2YS00NTIyLWIwMDgtODA3NjUwNWQ1NzE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGE5YmMxOWYtNTAxYi00M2I5LWIwNjQtNmNiNGYwZDk5\nNDQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExifzypxRUoeMV6D5GlUNYeeI\ng5rcgGteMUJV1x8/y3C0nhNnNAYbwNeRWZNBYRS2LRLPs0ggSiOU5n52sn0i8KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxKCfyFXTxaHL0s/IXEgejRaHjiswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA9KTx9tN8bvpBeZVsHs8M+TLiBtog\nIaRMjS4PQ2LCl6cCIQCTCSTJByA342oQXD17FLm/7+jhuPqq47VpzOxpWa2lkg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2333", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2333` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAfrltAMqD1OWy8zBKH+ztLQXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlODIzOTA2LTljYmEtNGRiYi05Y2U5LWVlYWM1NWMzYzNjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjYxZjUxMzctZjNk\nNy00YWJlLTllZDItMTdlZGE5NmVhMzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEspxFlhsK43XjNIHGB4auR3EAfEfR5CVMgLFyWOYRSIqfXMy7oTWQchPgFTZ1\nF2OjEEvj+IGE4jIGvM5JrCXbkqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqiPG8ovkF+WanEdwitAra5HDGGwwHwYDVR0j\nBBgwFoAUFjExiNJihYrGvSmX9yRcxS5QY78wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCVx459Sm2Ie3ltXb2Bn/IX7ij8ho1iWPcereP3KEha7gIgAkaDVHEO\nB8bP5cUNUmjFcVnBUy39bepPeSQDCPLVUqs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbj0lm+ynKcsWCevRl6H9olwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTgyMzkwNi05Y2JhLTRkYmItOWNlOS1lZWFjNTVjM2MzYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5t7sViuUh944h9XrcXjbgtaS8OuKTtF4GyEfR4T0pO57R\nRmwMd/UJfgHUW381uT5f//PgFxbH7FjVmieA/RVyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFjExiNJihYrGvSmX9yRcxS5Q\nY78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPpmCGWL8GiXxnaFRPTK+LiOphA/c5kY9eLJlC0g4lnmAiEA04iMTK7b\ngpNxLaKU5dP31oeGw3MAigfzGj6EIVbus2Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeQCQTkb+NH7Qt+NsmYALjulMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjYxZjUxMzctZjNkNy00YWJlLTllZDItMTdlZGE5NmVhMzE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDUxYjUxNGEtNzgxYS00ZTA3LTlkNWEtNDVhNGMyM2Q1\nMTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELQOCLKSFfoLBNKLeRsptNlgq\nWNyFZu9jD3whzxkYVRV9tnx7NSnMF6rXPE5gqoL34vNBpKiM158h3NTPiZr0GKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqiPG8ovkF+WanEdwitAra5HDGGwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA40Y+x4IFN3KRxUZr15VnJZmmX9j6\n/MiRvjIgIRiBvvkCIESVcmhatuLxLEREU4vkFOyaeTZrwr1PVNesTfnqEYtM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2334", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2334` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQPOA6AgPCl1m8XXoWHwpbazMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlM2FkNGU3LTAzNTEtNGI0Ni1hMGU3LTQ5NmFiNjY0YzRmZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFiMmZmMTQtN2U2\nYy00MmQ4LThiOWMtYmMxOTU5YmI3ZThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG9YYHnjBZXR5uEUT+rZKXAJe9f2cs56P877WGsS6+GCQ9I7NhLEpH2owJBWX\n7qaRn+q5BXxJSt1dcMHXRXelz6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi62SSOtgAP5O2mpEQH6WDtH9EpgwHwYDVR0j\nBBgwFoAU48uSANdwWcTFx5E1oHyMs2zNaqswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCICovgBP+Ew/2Oh4Gcr3cFEXVSJotzXZ+JAoGmHUhI1vrAiEAqBfqS3z5\nLXsnxdRwN/CKWq0g0l7ugjuYIu+AJH9uCco=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU5zpWZD0wa2o8xxEJb9GtRxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTNhZDRlNy0wMzUxLTRiNDYtYTBlNy00OTZhYjY2NGM0ZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9qh3vZe443Rr2ITCQFfE+U6QzVuQhv2FzR3Ozt3WLqLM7\npi9764ACqSorWM5B6q1D17hQIENzexe1n6APxrOVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU48uSANdwWcTFx5E1oHyMs2zN\naqswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSMtARIohC/Q3+FvodAQB6Ns4WSd4U8YTTEV3jaSIbdQCIQD0nReWGoIG\nmM5UNaA6nTdlUj5/xmWnN5mt+1XD7g1LKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAREPwMNl302Y1cm7nVkzettFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFiMmZmMTQtN2U2Yy00MmQ4LThiOWMtYmMxOTU5YmI3ZThiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjg0OGM3NWItZTRjZS00Y2ViLWExODktZGY4NmI1YzU0\nNWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEctr3n/rcwzW5Fk+H/aAc8667\nAvape6Gpw1n+0l/RiQUqkUFsL0ivJnCssehmHlj8ftlx3ykDtOU7LlEvCp6d86Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUi62SSOtgAP5O2mpEQH6WDtH9EpgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAh/VrN2/QzLYieHm+LFlU/7bmtYDb\n5We1vGv3aWYBIlkCIBTTFkRTBqArBVGzUYPGapOFQIBp0G7U3fmbdqwNXDH9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2335", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2335` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAcbIyLvierw6cMDblzg5zG9mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNTcxNTExLTg3MTAtNDQ4MC04MDBiLTc4ZTFmYjI4YjU3ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDlhOWU0MzEtN2Zi\nZC00MDg0LWE2NWYtNTUwNzUxN2Q2OWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp25DeExVmN+f+a7K1vW12azdC3OqWrBhKL2RvCZQcNzeXCHxDxngNH5Zk1AP\n3UY/NR0GJ1pZVOrX9dq2DQdskaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU28XpNjS6ITvAFQQOMU4zSMvRVFQwHwYDVR0j\nBBgwFoAUx4MT+CqD16gGj60J0Bik7acRPlswMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIG3c6cQduVVsImweiSfgUlx5jhXnt9vfwecxPEyFBJ0kAiEAnBe7S0uV8zLk77Ws\nUoDv9ofQZ8kg1PaN/iAPeYEMJQg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX3IL0Sk/WgC8BCQWO6lS79NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzU3MTUxMS04NzEwLTQ0ODAtODAwYi03OGUxZmIyOGI1N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8Tjkg7/X63jB5tp01C1l5ALKjVAH8+e4G0ts269FgmHzJ\ngmMvPJLGBFXdXLeV5vdtYdEvSozEcTFwl2suYScfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx4MT+CqD16gGj60J0Bik7acR\nPlswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRExULWwFyJaphzBIsVaIlzQsWWN5LIRbzNcVEVbACBYCIDHZXQ3Zf+qk\nMvd5I7ER/VPO+VLQfGoWzIewxClwGMmQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcXN+7+JCJ6yOimXiPHUoSefMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDlhOWU0MzEtN2ZiZC00MDg0LWE2NWYtNTUwNzUxN2Q2OWQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWYwYTQ1YmQtMDBkMC00NjE3LTk5NjMtOTQ2ODFlOTU0\nNjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER1eu6tczwOd8H91iiYhlguLi\nzGBZkk3QW64lZEPScKXSnaxH1tbCA+TUs3BnBCX8yeDQ7Armya5z3IZGiZ9Vf6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU28XpNjS6ITvAFQQOMU4zSMvRVFQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAu6WIoxELiBjIpHtNZZY+Ej5NqJ7I\nQWS5xckspZ1RxSoCIEcfmFAPIJFM4DW9uOPEI9EF/qelkRN0ossVWXeSMgIw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2336", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2336` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVWM+HNrI7Y3xpJMv1grU/o3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiZTg5M2RlLWJiMjMtNDM3MC05MjExLTEwNzg4YjE2YWY2ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWIwMzdhZTUtNTMy\nOS00NjcwLTg4MzMtMWYxODVlYTE4OTk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVNa93Ago571mA6a78ZwIwiKnZFHRPaghjHG+Y1X6Pkb34TUoQh/MAWnFz8YR\nTkZx8N2xMaDqRB6qozk1Fwrc1qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG83c/WTJoOyZpn/hM9oSLYrpGiIwHwYDVR0j\nBBgwFoAUIaTyjcUxqDhVXtwjNBeF2h/ljogwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIFzkDnYWtlpZsDjYiHW430IewlHWkMtBTw4vrfdGbeWlAiEA\ngA8ECJ41r4uZ6zs4/wLUYhvOjpOgeHMSxe10iYfp2FI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYzHwiwe6/JLaaAnRg1ydCf5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmU4OTNkZS1iYjIzLTQzNzAtOTIxMS0xMDc4OGIxNmFmNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBXsM6zRzpltyQZNKoHoRCTEDrpsfpJu3qX2k/JL+v+m1Z\ndryq9wjCe/6QIDx/ewzlX+irHFqsrphEgYRQmXBro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIaTyjcUxqDhVXtwjNBeF2h/l\njogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeRw5K/DtB22dqYlGdRsmxEvjmBUrdZUc7Pz/Yte30vcCICX9LQWBtfNZ\ndq5qpd4qXgeWdTQcaTZt1OLePxG9YFfB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa7upr4KNVkKd8YQ/KhQeIphMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWIwMzdhZTUtNTMyOS00NjcwLTg4MzMtMWYxODVlYTE4OTk5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjYzNjI0ODgtYzM1My00NGRhLThmYTUtMDViOGRhMTMx\nMmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoG0xBspa6d6ITDi2a+fyeUdK\nsw37Jcix6efgxVactkIz1sepS2lYiE/yYuRdHw55lRSet6HHKoOV3a7fkDRmS6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUG83c/WTJoOyZpn/hM9oSLYrpGiIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA8fR96y2WQ4/LecF1yRQLJF6SX8RX\nSdY6BxoDjp68JpQCIDypee4GrXTA66vhq1mEMbYFAcocgf4RnKIG6TEctdWw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2337", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2337` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAfbO4mkLzlSN8BnALPSLn1SVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1ZGVhNzJmLTlkNGItNDMyMC1hMzNkLTIyNGExMDcxNGMzYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI5OGQ3ZmQtNjFk\nMy00NWI0LWE2ZDYtYjExYTdmMzMyOTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtYFH10nsnG54cBp+6PNz3xgfJiujQp2NXnI2ttHexSbxhYU8mGqZ45elLo6R\nvjYrylLaZDZtpSDB3trknGjhdqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0m2oW/qKwb9kxK/DPWj8796Y57MwHwYDVR0j\nBBgwFoAUkrks2RzlnHwjfPg1jeXFvZGDf5wwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCqmlMAEUf1J7MG/boFpdtbiV2TnJ4ETYzHaKpPv0f07AIh\nAJEKf5FG4zfwZp5Q/L0xD64sWDFAqft7YrEeBWpjoFn8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXAcyKB4Xtmep78BUH5NDMJSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNWRlYTcyZi05ZDRiLTQzMjAtYTMzZC0yMjRhMTA3MTRjM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqvhKq/1iFSPzNz8O+QZgCyOw/OUas0YCsgHPkebiY3/L8\nlPa4n/g+k9X1CnyvkN/ZYnvA8gu5URT/raCkuq84o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkrks2RzlnHwjfPg1jeXFvZGD\nf5wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHRya8/GrRWFYs0TRyiwQr3JdH75LcaH3oY0zMhg9aIACIQC76kCl2ure\nQDW3ba+TNG49lxRXXXpg8mSKGvtoXJ3O/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdS3XESyuJP/AB8c/GQpvoDaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI5OGQ3ZmQtNjFkMy00NWI0LWE2ZDYtYjExYTdmMzMyOTIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDUzYjM2MzktZjYwNi00OWFiLTkyM2EtZTgyNzE0NmQw\nZDlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwDyksG+gehMNyJCh+wKo7K/W\nByjPuLY88BSIvKFqDkwYedrvVtNekfFQw31amBreEoDl+blA34sLnqGW32PmM6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0m2oW/qKwb9kxK/DPWj8796Y57MwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA/fJrimYMQrBGmKEjYwXfB/rJ0EVu\nGk8M4ROAf9ewIHkCIByr1rA/qrZqVnngbn+72WNPALDcp0LXFhk1q8oHpmmp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2338", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2338` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAS492tX5jBHzJN0DqDDpHMtsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllYTNlMDUzLWZhYzctNDQxNy05YzZlLThkYjJmMzlhYTczYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI1YzkyZTQtOWMy\nYy00MDRmLTg3NGMtNTIwN2JmODNiZWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3slt2DYfS5LdMRq5+n/7HJ4fKMkbhf44uZAU3mrQ624vHRJECjOLOUqoIEdz\nUxCxdKoutZs8GA9AhTg2200RNKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2cbXPLvtBybe9iQNGsCblz7pRD0wHwYDVR0j\nBBgwFoAU2KDPo6mW6LupwYT+SRJTUUkkIU0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCUv7nadjnt\n+cjCyNEooX2GekNjJJ2xL+cQj6NHWnSjdQIgamioncnhNcdWFAdnFUzDHdWxcCY4\nf+I34WU5wFC/HU4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYaXMoPR6WswLX+2Ur+uA88kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWEzZTA1My1mYWM3LTQ0MTctOWM2ZS04ZGIyZjM5YWE3M2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQacu6LprMOSvDX8LEMY/VqDs0JfUmle8hN8mtYbc+dctNr\n4flEHsGJqCx8Xl4+s7T6gEBsmUnt2dMAVa1Pn9RHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2KDPo6mW6LupwYT+SRJTUUkk\nIU0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANVQoXVXxpFEoHPMIJc3HnaOLiKTa6dL2MWX7Gi3IJmaAiEAmIxPTSZH\n1igVxL8U+PIQXRVE7ZIBho8B8bZ/xcWAaig=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYlqIRbM0kGgVoK9c4hZMbe/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI1YzkyZTQtOWMyYy00MDRmLTg3NGMtNTIwN2JmODNiZWE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWUxOTBhY2ItNzQ1Zi00NDYxLTgzZmYtNTllOTNjZTI5\nYWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3CsX195cCwC7NL3e0mS45FKX\n2tlEGdbRnA/7aR/5tyTKqMK4HJDpSJ75kL12LiMlhYQ+la6Efw4il9CN0kZLIaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2cbXPLvtBybe9iQNGsCblz7pRD0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAs7hkhq7guyQnfi7ZQnGHIzOpdde/\ne1TdhsG40/qUWfQCIQCa7ooa0dBtm4N8kFFfFmNoTb7ucgFm667SE9GGYdnPbw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2339", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2339` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAUcicEc2x9dsR5ivjfCw0oc2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyMWIwM2E5LTg2MzctNGZlYy04NDc3LTQzMDdjMGRlOTZkNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjcxM2NiYzktY2Ri\nZC00NzVkLWFiMDQtNzQ0YmI2YmM2M2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0SjvhLmrfGtAA22dsBvCHl85MrX+OCUlmLNmBfLnR5gX/2jw6DnOrFjOvQjI\nEjCsvFkHc6Y3BowONytGyx1pO6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw4XujJL9Aj4rbfqjz9f51bvOygswHwYDVR0j\nBBgwFoAUMuY5+U4qVooYNyEuCzhzsGvy2T8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAIV+zEEPGiXwwq45uFt79CaCn1+1NJUVmafnUoW6fbmmAiBsC4IEO3Y1\nIZBoYw/ra7y6Tb7v7OiyKQVV1JQJGHNtbA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeCUgeARG7VEE3YE54EIS3V3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjFiMDNhOS04NjM3LTRmZWMtODQ3Ny00MzA3YzBkZTk2ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmz6tqwrnI/vmO271hpx2BK7rwHawVnYvapcpkILU8/pLv\n9yqTzalTlBw24VpHd4i3KVYNFxsc2UHefuUyij94o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMuY5+U4qVooYNyEuCzhzsGvy\n2T8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYtPBBDooD0VdrbowwTyJ4moaGMkqeGsXpCfgFqjezsMCIQDc2d+aqE1o\nlxsNlro6DJvEWexfh/Glpc6HZTKd8x8g0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVc1Ijx7+aPtkl2OIXkcdMtuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjcxM2NiYzktY2RiZC00NzVkLWFiMDQtNzQ0YmI2YmM2M2U4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWFkOGJiNzEtNmRiYi00OGZjLTliN2EtYWFkYjZiZDAw\nYzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY25jVI6alNClTXV/X5TGuy5+\nWVQ2n0pnhA0ciRLcP0IkPdNiqJUKj6yfIB1ZgY2f0cb5EbmtS/Dgv/QylDdaWaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUw4XujJL9Aj4rbfqjz9f51bvOygswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBSLQbV11+9S4NP+R4n4AzGGvkgG4XH\nH2qE17eOkAgN6AIhAJ919ERbuuLEOF69Jt7WQSdaXGMaIeTvrdPsOE0y5vc2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2340", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2340` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXz8k6SmqQP3uKPVwzxb7hKKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ZTM0ZjVkLWMzZWQtNDRjNC05YjAyLWYzMDI4OTkxMjQ2NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg5ZmY2MWMtMDQy\nNi00NmUxLTlmMDQtZjA2NjJkOGZlNTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmd/isos3vlNudr9psVXQ7Ez5Ca2aU4aZRPL3QorakgS6ij60P1HVw1WUkilW\nwZuwaiHKEy9Vz1Mi+6Zrrhdt8aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwIKacfq+7tbnWxBESVcSOYBuaGEwHwYDVR0j\nBBgwFoAU8pRPEwm8Z2kv63VxhIzd/6vjX18wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJ+BjVEAu0Mps8BBp+c9ltz6pivEyCQYzQYYNvQlv8hTAiB5aTQw8NYD\nh9PB4+8f97ph+YU9TwLFiCtj6uBC9qNddw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASRqcHVj8atmS/0YNs5ohcLyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGUzNGY1ZC1jM2VkLTQ0YzQtOWIwMi1mMzAyODk5MTI0NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSmXz3uAbN6XxSI6ZWOVVArdOM/9g63YCSzZXSwonoDiGs\nCKui1eutnV9KhD0/DhRE+Oc8m54peW4UDtWjSB4qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8pRPEwm8Z2kv63VxhIzd/6vj\nX18wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJUwCqbYmvd51XPMcTijS1OVPSzAeFDY47m42X7wirhmAiEA+ZyqLPYq\nGwkvqK9XUHXP+fMtON4tjI1WXGV9Yoehmk8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAU63LJS00Lhjk0tS7NLWrRvuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg5ZmY2MWMtMDQyNi00NmUxLTlmMDQtZjA2NjJkOGZlNTIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODNiZTRhNzgtNzExMi00YjkxLWE4ZjAtYTY4NTk4Mzkz\nN2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE15TsSTVWfjqpUhdsxcTasf+d\nDEXXEkkMJYfeqP30xIXdRzmTiz0gixBXX7xFu14w5XS3K22DNQmf42UvvThgvKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwIKacfq+7tbnWxBESVcSOYBuaGEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAiBUnhr9CdqvlULH0emZZpTPWwZPb\nPbYU1l3oo5CqUgcCIDXBxZHJN+Ks/RdTgMWE4Rs1wK9OTl2zhUZrgMM+86gR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2341", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2341` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAavbTZU/pF9FyuweE8k8z2bEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1NjU5ZTMxLWEwYjgtNDRlYy1hNmYwLWViYjU0Y2E4MmI3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhiMWY4ZTktMWMx\nMi00YTZmLWFhOTUtZTA4Y2FjYjI3MWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHD1QIg2CGsDgG7nyqCFGQRWCd7LvFhQMsbPXEpty7IG2XZTnz6k+f+ee6ku8\nuSa5+nPDR8v3+czERn4hTad8saOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+btchYmH4TUQQRAtKfqWJN3KMb4wHwYDVR0j\nBBgwFoAUHr8tL9ByCe5L9EUjKQ6/0/tzRM8wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDzkNvLm3qvjdYvh8BLVh9V9nTdqM8KvbxOmt0uqFkiEAIhAJS7l0FO\n7DcmkIIbwoBs1RQGVcQuVjutVLHzjWQOgbHN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUxFf9am9jFMPo1adlcLdcG1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTY1OWUzMS1hMGI4LTQ0ZWMtYTZmMC1lYmI1NGNhODJiNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3Mw/YLckNk3Ob7co5iezZEelp9WVhqw5+IMrZtZpX1ZtY\nIRmjiprpMpj7JsWesJwyhae85IGYaCuEN4y2yAyKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHr8tL9ByCe5L9EUjKQ6/0/tz\nRM8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP+DFT6FWCE+WgGkvKi1v5JL32sNVNBsFxG+nK+hEYFMAiBq7C8ouMPi\nHYA7R3IxBI58/98UjflQ5qgouRh0DhdcxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdkXNZoVmHDJobzIZ/JLYrKuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhiMWY4ZTktMWMxMi00YTZmLWFhOTUtZTA4Y2FjYjI3MWEyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTUyMjhiZmYtYjJkNC00ZDAyLTlkNzYtNmM2NjZmYmM4\nNzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEERdz99ImrzrUlhekR/YHrJMq\nRudi1S1gUQlRMM5SFsyQEsPiUoEb88gv7LEJuUJIiadsHNltFJuIx5Dl/NgeIqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+btchYmH4TUQQRAtKfqWJN3KMb4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAtWnT+zjxEPT7hSSGj/VZkIMJ+0uk\nCzKjE78YYBSua00CIQCUhKvnPlqONHCrUWkojeRNW0rYF81gONL/j5D+ybHCxQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2342", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2342` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAW0RXvRToxtFSTSgDYs8IMqFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3YWQyMTQwLTNjZjQtNGI3Ni1iZjk3LTI4ZTQ1NWQ5ZmQ1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VhZmU5M2UtMzFl\nMC00MGM1LWI0NTQtMzNmMzhjYzkxODNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIRayDDaS+KwL3kAofRX2Ma2fGi57smIiPHMzXgpdkcT8GlqZFLLCdsiXwVJ6\naVQ2RDnOfDb0M6birgPU/XwxzKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPW3XMvx8vaFJ8/5fa1KegK4BQYUwHwYDVR0j\nBBgwFoAUdTkbCRx4B9+m4cLP0vPkCv7ajq8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDyNwx0liowIrL/2NHyYCu40z6KmzXZK1pVLwxy\niwFeoQIhALA3N44f752Zk9BFykdblGaOWvgNF01AL0JnZYSdSM6H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQMn1FU3SqktFIPRBd/kCrpMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2FkMjE0MC0zY2Y0LTRiNzYtYmY5Ny0yOGU0NTVkOWZkNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRSUFiyAIFJmAz2d8t1FcVtfhUaRMwyVpl029SFib82QYr\nLGgcf4NGYOUfBwflIIXc3z6sWCoObF+kLAefRq/Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdTkbCRx4B9+m4cLP0vPkCv7a\njq8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKx6nX4ujVFs7Auo3T7q8k8LgLnRBXeFBUd+C3Eh/3sQCIC4+eK2gI63g\nFNl9K9Pq9LMw4D6r8zxoFDS1dTJNL2eN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAccEI2RMngfsheMQnthDNsgBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VhZmU5M2UtMzFlMC00MGM1LWI0NTQtMzNmMzhjYzkxODNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTUxZWI5YzQtMTFkZC00Y2I5LTlmYmMtMmE5YmZjNTQw\nZmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExNbLRQTioM8YU9/iJhRXFRvJ\nqGuFJ2Q+53efE7SsJ4yveuzMz9fNUwWzXYb/i38zL/NHof3SgHGaD2q3scOi46Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPW3XMvx8vaFJ8/5fa1KegK4BQYUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBifSTjhmwopCfnsPR9/aSElb+wDlJh\nu9Ap/dPhJWMjlAIgDSHiu1oy4NjL3IPdKEvwFnmajRibp1wqKve53KX1rQs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2343", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2343` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAS1o35/MMINC48mCx/aGNuN/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhYjVjOTQ0LWMwNTgtNDE2Ni05NTA5LWUxMjY3ZGYwMDJlODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM3NDcwMzMtNjUx\nMi00YWM1LTg1NDAtOTM1MjFiZGIyN2FmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9GTyiBa47h9SYjPncmMhPTHVbnHSxnt784J9yWv3ufsc6JOuf/aAkmkqNNFz\nxH5vXnRx5Xz8IZnPvLxY2Aeee6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOQ7Bk9KiMrYbAenFtndwVDeuzpcwHwYDVR0j\nBBgwFoAUjfdctqPdidn0TDHh30W+lBcQ0g0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDmN3jVc2qnnctxCRMNhzgaTR1V7AXToV2r9OMj\nzyky6wIhAO4dTGALUjxyFH8PlakWHiUuQs/q5Jbf93O/EuEdNJ3H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYROe76RaXAAP39Dj8Q06WTEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWI1Yzk0NC1jMDU4LTQxNjYtOTUwOS1lMTI2N2RmMDAyZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9YHgsc0Hr+MmE414ZKkVIY3AtvQ17j3Oi1t8FN/pnT8Tx\n1BabR8kpP/meBS0HZR8CD3rzl3731t+gPtH5IDalo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjfdctqPdidn0TDHh30W+lBcQ\n0g0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD02yrussur1/Th5WRbSMBYUYX0enooyvvRE0PIQkrlwCIDCq87su6fhm\nvS/0dKTJOpQ6h45pIr677JxGKz6X4UQI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAS9ONFNe8OZgxc4juYmDAibhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM3NDcwMzMtNjUxMi00YWM1LTg1NDAtOTM1MjFiZGIyN2FmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWYxOTUxMWEtNGMxYi00NzY1LWFjN2UtM2E1NjE4ODMx\nNzI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEItwktZ4H8Yj1K4Diz3knK2/l\nglR3wi+DWfCmvkgnWNczr1uTEzrrhLObgXqZug6RLXaggY+4MKHpjTdNbBcAUqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOQ7Bk9KiMrYbAenFtndwVDeuzpcwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA328B4Gv49MVmWO1aCjTGeXPq35M5X\nyXEQ+l1wPAyKEAIgU65oTU8fn/it0NiovYLgyv/ngD50rRT0lNlx82oPMZo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2344", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2344` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAafdwugNaCCIxAezO0P5J914MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjYjNjMzVlLWI3ZjItNDk3NS04NjQ5LWQ3YTJlZDdjNTRkOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY3NjIxN2UtODIw\nNy00ZGUzLWIyNmUtZDc2MTQ4OGY2YWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/e6S7jShZ6/kvbG4pJtUs+oa42F9qEn5F/9fGnzeLwqc6YvTQYM3PtiFuXNa\neyXTfERFGa3cZXkF0Q/iYrcHLqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXq6X0ONKjqvja+sBciIj2MzJtnQwHwYDVR0j\nBBgwFoAUi+6b7fZimwTIIsdlFWv50N2Wn6QwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCdRraXmnlaMxYHvuBpeB5v+PDprRcOGtDtXUKzbvCkOQIg\ne5hqhAfi7klQioMAvp5xvOnkMv/QYiE61ytxpNaMHq4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX4JpdIQ5BGKPvSadEY3oRvJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2IzYzM1ZS1iN2YyLTQ5NzUtODY0OS1kN2EyZWQ3YzU0ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkOybjXZn6ltjX3gnoBeaxqJArQ+Ytu048X1oYM29ZfxMJ\nDNFfScTrKnZP+Afc1PgWPRX2JmwiUdowaN/J91fDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi+6b7fZimwTIIsdlFWv50N2W\nn6QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPtDqE+RkbHXso5fG4TEqtGvgR3YJ53C9K5IcKHoVkWSAiApqKLgaei5\n3brzofX73BVzteQbD2BjzCvS274H6NMf2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAaDf3wZl29Wfe0pXVt0bvhTXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY3NjIxN2UtODIwNy00ZGUzLWIyNmUtZDc2MTQ4OGY2YWE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzNjOWVkNWUtMTY4Zi00MjdhLTg5NGMtOGRiZDY0MzJl\nNGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8RaMBPh7CPfg011479ls2D83\nzZUTfpjGnExZYp/SE3mPWhFcUgrPnlAgtiBY7A7j/bumGakpBgcnwGUNH8hx3qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXq6X0ONKjqvja+sBciIj2MzJtnQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA3e936txJsK29fjATreqaKBOyOtePf\n21J3fEGB7BJN7wIgLGWnzNNdw263eZTc9peuuzfj4LaGsRNlvmrC4j/6tEY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2345", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2345` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAdnND7GJ4KdtFCLbAaR9S0qGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNGY5NWI0LWIxMzUtNGU5Mi1iYTQyLWE5NGE0NjU3M2Q2NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM3MDdmZDktZDli\nZi00NjgwLWFlYTgtNzk5MTQxZmE1ZGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERb8MgF7BN9qNrDT18RQezMD2LZcWSfgM0QSzVP2gR6P5+OdrH6DH8NOcoufV\nZ1XiJ+heFowWIvk8RTuFLwXvMaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbTwLdfdrReZv9c8gDnYvGzL0QzYwHwYDVR0j\nBBgwFoAUsHmZbTAwwIX61XbzwDIktaj9h8QwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDQc/RVLZgmc9zRVtP9pBTKbFwNUhvh\nWLGFjMDNYvBgAQIhAKi/2LD2KavWSUQlj7LoPPCDY1FS5ryvw6RPGhC6yfvk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZy6fOdZPhDzsRIjRR7hZkWaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTRmOTViNC1iMTM1LTRlOTItYmE0Mi1hOTRhNDY1NzNkNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASevMRVXQIliemyUUHcLKnkww/2gvbzFx+RPNj/XXIBpZIa\nrlnIsx9sq7QpRUTjYealNRuCsx96howG/UtncsdKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsHmZbTAwwIX61XbzwDIktaj9\nh8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ1TqEZvpXLMN1aH4tJiy4UJQrkrmZwY/nGbN3ThoyXMAiAYfEEeNFrJ\nCp5mKNENLZqDXxTbpXI5lhhawpoLT0NcbA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVcHlKMcCXUi0RFrSVEtR7O9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM3MDdmZDktZDliZi00NjgwLWFlYTgtNzk5MTQxZmE1ZGI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTdlMWFmMmYtOGVlYy00YjA3LTg2YTYtZDFhOTg0NDY0\nNjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOg0xWmKhjTDX8llKtgPtWKHJ\nzop9vzKS+Rnm8Qn3meOIcZQhcPKNweaG+0dn8HLi3rWAJdxZagJ4tiPIt8Ck+qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbTwLdfdrReZv9c8gDnYvGzL0QzYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA3g8Yqgwma6k/6/LtuLzawscZecOL\n+i0awSQPE5shWSMCIQC0stZ8Mxbl8hW62rxqdL/vUP9wcl42gfGmiPmUo5BmMA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2346", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2346` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQlRDmzIcb2KObRROOaj4LS4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiNmE3Y2JkLWJkMGUtNDkyNC1iMzJiLWU1NjViZjhjMDY2ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA5NGI1ZTUtMmEw\nMS00YmZlLTkxMDMtNTMxOThjMjc2NWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5vN2nMXFok2US6n1mNAEvHILelmkaUz5oIpjVJwPDE+UDe3X9l/cHD8P+e6h\nfQMl+ygR22PT2RZNBdUGibn0YKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU58RhigWEUWM5nEPt/+vFw8KS59gwHwYDVR0j\nBBgwFoAUre97YHC7xvt4zcSkUwOvfw0F5KUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCICeyY5RSuV6ne4ykjTYGGJLVvfbGGYwp\nj1CkqNSe8asUAiB5++u/ZuWCQv8MM4IVJtaSNLi7GvIDeCMANAP4y6I4qg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWzgp7fGLBR2Nz3ILEb/32sYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjZhN2NiZC1iZDBlLTQ5MjQtYjMyYi1lNTY1YmY4YzA2NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARn5HZBgqYWMtKFjx9GqAnhWdthIS1RKGnv8JRdu1DoFxLW\nCG9KEu6yfegnzGxgdbE0EKa3yNWm6eaM4P4HRx9Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUre97YHC7xvt4zcSkUwOvfw0F\n5KUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMQrzw8icOI6EYYhUlh/hT98z09wEdTbmGGVpWONyOQwAiEA/dh5Ru/s\nFrowOHQIMRtJdAJZsg0X9yI+NXU6vnVtfJU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVHSRhtUAF+UwivXT5P8nm7aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA5NGI1ZTUtMmEwMS00YmZlLTkxMDMtNTMxOThjMjc2NWFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDM4NGJhMGQtZWNhMC00MDkzLTk5YzctYzczZjlkMTJj\nZGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsv9VHGB1lyB5AoDh+v4qriqb\nRNfrr6UKc8zNdI7HjN/kG4wv5X9N3FUcFQNvwAWR4k66st8hEFecCuJte4qHEKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU58RhigWEUWM5nEPt/+vFw8KS59gwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAJA7xR+0EzJp5zXnMHWTYhYSVP8yiA\nC6HH4Lhf6d5H2wIhANlAkNrq0FZ00rAYTuYHm8Hs28mI2D++j0Rdy6pRfSbL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2347", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2347` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXTgFKzzYbl5UEjM1bGXZykOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlMTMzMTkxLTc4MmYtNDM2Ny04NDc3LWQ3YWMzOTk5NzM5NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJiZDJkMDgtODUz\nYi00NzZhLWIzZGMtYjRkNTZhOGE4OWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzU3+6DmhaoVepOiL6YitTquWLgTuKR2pxIaxYooIA4mB/SgECaRuNb7JhC28\nEpgIWTg9mRPnsLWt4YMTQlUusKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMOQaag2Tnk4jRpA2IuAHvsseEwowHwYDVR0j\nBBgwFoAUBHWHSQ0r39+OuvVjHiVXkSeZJnIwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCISuLQZP42\nZzjMyV5P2KeqQKrGDCq72NvyGTwc/m2jigIgIYLksZ8eI8r75AF+9CQgLBa7AZlB\nQbaq6x0PPz5ecf8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYs3sSm2m5tX7PuvDRinob9nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTEzMzE5MS03ODJmLTQzNjctODQ3Ny1kN2FjMzk5OTczOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCsuTZjRMSfz3WNN0ZElY8+F+3+DXTmipJekUUi4jdV/yu\n2LTnpmxY5AgPOccYfcyRAC0HiZ4n7q8qhStBTtdho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBHWHSQ0r39+OuvVjHiVXkSeZ\nJnIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc7RFAQ2Y5IljJuF1yKdSFZJ3w+wwQuIY1W/JDFHHW44CIQDj0lCKgCkC\n04yAjTkpXWUFYtD/9EBPsqEhZWjItWLoGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAf6YB2BRaPT6oej3QK+QETVOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJiZDJkMDgtODUzYi00NzZhLWIzZGMtYjRkNTZhOGE4OWQ2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTViMTRjMjctMDJlMi00N2NiLWE5YTAtNDZmMDNlZDY3\nZGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuru3krTEVpLA/MS7YbSuQl3m\nmMhdM1sffRJXSxf0hoZcfHPDNvXZA0JBGTPqN/e+DU49aT6zRDwCLghO7aZEV6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMOQaag2Tnk4jRpA2IuAHvsseEwowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAqPBJZ4OUuo4tuFxPb2Ah37gDj94wt\nJ3JiQSzpgsI+TQIhAMcjjfeIrDehBeUadnWtb3rLGfo4IbQPKvceuFYPnmn0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2348", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2348` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXBxl8EYKWYjRWJcjpsYlALpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkYjJiZmMzLTJkNTItNDY4OC04MWI0LTMyN2EzZTBlNjFhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzUyZjJhOTYtMDlj\nMy00ODZmLWJlZWUtYzljNTkxMTNmMzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXU6s5HcIfl4hoDkARwkbzxf/ux/ECPcjxj+5kvLkNqk5un0HI3tD+H/Xg7lN\n4cldGtj0qMdffkljc8s7pjNUZqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+LiiaeXMEWdarPGr9XeeGkd2SSkwHwYDVR0j\nBBgwFoAUKyvB5tbuWzmfQeDbhZcz2rKsP6gwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJ1ybFTzIHQPKhjQ0k3GFFAOOZN6zkIDwVDefhDLkFaGAiBzdxPZupxd\ntqJep6I4cAW/k2Xyf19eQZ0RcrKehGZK8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc0SOgkSqSRf06kbTgVmdoYqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGIyYmZjMy0yZDUyLTQ2ODgtODFiNC0zMjdhM2UwZTYxYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASy78u/0JBGzcdkPWBF5dgEvm7fP2/KGo+uFx9RfJzPnMVm\nxMOTb9lRIWO7qUqNbyTkcDuu/ADm14FxpWzCn3Pro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKyvB5tbuWzmfQeDbhZcz2rKs\nP6gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANxAlvs90hG5d9Ys3nt8a4HsR09toKIxsS1S9Af60JuFAiEAkqGZXdMp\nuhZfCiUce/JGB9EozZA8w3cLoOqUG2l64Pg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeHcPShVJvT4R219eRRW92IeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzUyZjJhOTYtMDljMy00ODZmLWJlZWUtYzljNTkxMTNmMzkxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTNhYjFkZDEtN2ExZi00NDY3LThjNWMtYWRhM2FlNjU3\nMzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjZLnRZ8VHG++BNs7W+OHwxX0\n1YZhMgODwDUVsTjuYUZBLUarFyQt+j2M7LdEkB8U33P1zTRZJvOZq/MG2x+UpKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+LiiaeXMEWdarPGr9XeeGkd2SSkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAoN9FichuYtLZYpneLxHI8TDGTu+g\np+6R9kCGdOLDd/gCIQDy4GZDFsYCbx9gY9dsdueCKxkDpvFwapxK0mRhRFxiZg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2349", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2349` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAcRP0nSXc/lxHbj7fxcxjzrlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1Y2NkZTYwLTdiM2ItNDM1Yy1hOTM1LTMwMGFmZTgxMmNlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGRkNWFjOTUtMWFm\nYS00YWY5LWE1YjUtNTJhM2Q4MzM1Njg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn5k0trlVV7ih9yUYjCEQsw9eGSLqO1L8BgOybcR8+7t46v7g2AF88DMdgBLq\nXndtLeMmaSJQ7/tUXtjsZyswbKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsz+btvR6bfJR43FToHCjTIoyC9UwHwYDVR0j\nBBgwFoAUW6vUPtgGjyqFDCb4HY395DJd+5gwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgFOpjBfLstc3n5KISaEDawvKcdM11XeuaJHQXKXIjfIoCIQCP1zatHzwn\nnjeZWsrXQFYSUX8Nj6W9CnYOcRpDe6bviw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS5+iPP4bzxzWBI4GOYANjd+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWNjZGU2MC03YjNiLTQzNWMtYTkzNS0zMDBhZmU4MTJjZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATs1QQ15S6fT1HQwQp29Wl4Qy4yV7p89F30euA8cFjZ1awb\nYvHXBMCfexIjkOvegi5g8WqB+nWvbSOqRZQw1hN8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW6vUPtgGjyqFDCb4HY395DJd\n+5gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeKlTZZXGfTdRNeML956BDDnkHVDpUZvUBOotnK/dwUcCIQDXRptBXl5A\nKTEkoQuIobfhC+EV0lAGgwoxyYMVh1YhPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZpV+OzUVpIzrVfbKN0kjTXqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGRkNWFjOTUtMWFmYS00YWY5LWE1YjUtNTJhM2Q4MzM1Njg5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGIzNTEzMmQtMmQyMC00NDY5LWI3Y2UtMWZlZmZjOTJl\nZTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtvpcfzjE+Q2mVcTwB/Tgjct2\nZWMOCgDmSq1TPfn3VpTFecrbnVuYVlHKeqU616DKqJRwCLGNgGpzLyvzoETLIqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsz+btvR6bfJR43FToHCjTIoyC9UwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAXvf/12VLNrcaqF3bZywuzKCKBRWKA\n1eohCayJVTeFZgIgGTjozVw6ApiVDEdDJmxEd6TPv5Hl4qow/6lcakjRQVQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2350", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2350` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAXlbLHr5s5kjOwSSCce8w9r2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0OGMyYzFkLTA1NWUtNGI5MS1iMTdkLTUyYjNiNGQ4MDYwNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I5M2IwMGUtOWNi\nZS00ZWU5LWFhODItMDkwMDNlMDFiNzIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXWo7GhyU4QBhEiTOb/B5iOKYj0Ll7g333c+z0hqWXZzQPwlQNbnYJxrAQiTC\nocrzJvziiRrHyLYffuiNWCMlBKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDRymzqqs/coYXzst4MjgUx8dc5gwHwYDVR0j\nBBgwFoAUo3/GQEXIAWGMl/6WXZ5jfiDdRJAwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIAgqubUg7L40/fv+eTeQK0KR2ymoKGdn1Mo1AtA0Ila6AiA3sYTEQPMV\nlVkRBWOS7tK2nfSm1o+YDtUtrKSTAOil3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQJjHC3+yngkt14QFwmRkxdlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDhjMmMxZC0wNTVlLTRiOTEtYjE3ZC01MmIzYjRkODA2MDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEF/d7H4yJ7U3y++P+iMux7v006If91X5AroByex98jihV\nw40s8Tlk98iM1ZprrIYRMHq2NajHDqdt2Zq3V9NMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo3/GQEXIAWGMl/6WXZ5jfiDd\nRJAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI4POWd99z4jYrdb/tfMNphAuGRvIwISPHcNSjdV6J61AiEAzIbNOPNz\nhIu9VEnnAzSzAxPXLr0CFoVRzRBmJbJbpeI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWK7+ED2iELxmOnp4r1rxtJ3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I5M2IwMGUtOWNiZS00ZWU5LWFhODItMDkwMDNlMDFiNzIzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDhmZmU0NDgtOWUwYS00YTY3LWI3NmItMzNlYWQzOWFm\nNzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZHv9BEsg8ZdlmxhETIFZIeui\nYFfPKiGg0FjXsbw98HuX6MT2Eav7EIpKMT3+Jte35oyTCZf5xTCprpj2aHhERKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDRymzqqs/coYXzst4MjgUx8dc5gwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBLBIxWYS2WO3d1ahNrYEmWuLR7wpxI\nHtgrzKfCl+kVIwIhANxinQilF2Rsp/r9+BWfH/LQwIkLSEsd7AtxVqBwNOx4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2351", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2351` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISASmL74xWXtMNynD/PVuaUX3NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkNzg1YjBkLTIzZDctNGY0MS05Yjk5LTZjZDljM2VjZmE3NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ2NWQwODUtMWRj\nMS00MmYxLTk5MzItZDc0OGU4Mzk0ZDI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAF9kDHIsIIf3Z2+zDlgtTtLJcHbfaAc5CNKnP25SsHqMQZj7RXLF8FqBKBnD\n5ycKv+gvR7/p2A1b07yxSNLYzqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU43v5S4LLF97XhrP+9HvEh9GQUKAwHwYDVR0j\nBBgwFoAUzHQJW3GotV3Ynv8tXj02jJRc32EwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQChe26BVJePhKmtDKCYKzHOUM69NWwoDoRKglgE\n22pKCwIhAPhCaLVq+yfQUh0K5T0nyaT6QgZ+C1TDTpg6hPkfiZiA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV3HvaegR04cv+BoJD5Iz6OhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDc4NWIwZC0yM2Q3LTRmNDEtOWI5OS02Y2Q5YzNlY2ZhNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFsDoS8q/xicPCBbq/WF9RqurCnHky6xlynCJ5tLYoLJlR\nhJReNh8BuIuBPzY57NrW6OkgCiTtzKDsD0R7Fd1Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzHQJW3GotV3Ynv8tXj02jJRc\n32EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdBxL+qgYc8WXs/kdcUYxx+lXoSa3h3Cpirn56mIR1OACIEmXkQmYCLL6\nju92c3/vdToEItNR0SXIASTbxvif/m9P\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdB2Rre9cYTjuMzAgXI/Dss7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ2NWQwODUtMWRjMS00MmYxLTk5MzItZDc0OGU4Mzk0ZDI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTVmMDY0MzYtNmRmZS00OWVmLTk1YWUtZTkxOGRhYWU0\nYjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEswN1zZGyOUCWrlpsGvA/7jO\nRhkyKzi4n0Y5kXr7px8czWxMp9nrFMXrcSe09aCyNnqqIVwrLPVWoOscfWVEDqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU43v5S4LLF97XhrP+9HvEh9GQUKAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAkVR3+4hZm5xezYgYu5Snlk+JtObO\nZU4DlerNR9oa9jsCIG/Z42r9EfCJb9Qi1TZi/ipf8q9Y1lHoO2LzxmhIa2A7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2352", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2352` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISASSrGWXK+wLCy9q6N2LDhTNfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4YmNkNzM0LWI1ZTEtNGNjYy1hYmJiLTEzODcyNTcxMGMzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVlZDQ1YzUtMmE1\nNy00MDgzLTk1ODktOTA5YWEyMTZhMWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvJZEO8DMuMn/XAIuVPznfsBmPUlsernAWsVvWh22os7L2oCJoBaaBG7Z/JLb\n3dsOO1rneY18FqPish5dHoktpaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU78z32ulHfeJLxJxEn/2yi0oT08IwHwYDVR0j\nBBgwFoAU3aqNVQxCij6cAW96NvEBcoTiPIswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIHBHAwVS/r6s8wkQjxgg9Hy61cvoJEY/JZ/MRs+T\n+7e7AiBDMqOALd/Mh/z2dj/EjEOuKwgZ3zTps/deaWDD8YKE0A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbYCTf8uDBIT9G84PZ0kVC8yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGJjZDczNC1iNWUxLTRjY2MtYWJiYi0xMzg3MjU3MTBjM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVXm/xMiDEqn2BSjRsfcaPRCt6PjVDbySCcCtLm3Q7icSA\nqH6sNQi5PKFNBctqhZOaVVoDY/EFm+J3xQGhhE/Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3aqNVQxCij6cAW96NvEBcoTi\nPIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQOJmJhkw1eKNIPt71Qpe0VLFX7Xtre2JTJ8thSXtwBgCIDela4aitdaA\nFQV5llbtDB7F9blPH4onpatm0m6mB3/X\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZMqMO0ZYRP32UHBpCo6TJGnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVlZDQ1YzUtMmE1Ny00MDgzLTk1ODktOTA5YWEyMTZhMWMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWFkODEwY2QtMTE2Zi00YTM0LWE2NWYtM2Q1ODM1MTcz\nZTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEffhnNmAoAe2J+LA66kQETfuS\ncNL1myIwMS0T1GjZETINx99tKH4cVPk7zutRZFV7swIbJ67yZDkJoF5lPfM3VqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU78z32ulHfeJLxJxEn/2yi0oT08IwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA8R7iHxGpe4RRd16qj/3kz8stk9Kk\nsMcnWrLObI8jD9sCIQC/VOZR7QRkN05BaM9oA5wMeRMKiG63Zfwmmiw1oV1Qtg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2353", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2353` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAR0OLcJdYKiSaTIVxZf7prkrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlYjk0ZjVmLWU2MjMtNDNmNy05YzkxLTQ0ZmVhYTgzMmY4MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBlN2I3OWEtNjYy\nNi00MWZmLWFmMmItMDhkMDI2ZDBmZmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA3DThXzRRYfGBOZ09b5mXl44y4FOxZy0IZo9UovLNZ6OgkJ1j3Ft2lKo4+t1\ncmoMtaf1XD88L3PlAVqZZxiVfqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+jP36pv85IrhEE9K+FhcHnnr770wHwYDVR0j\nBBgwFoAUhrOj/PRhDPSt7KdQjT1ad5N0UUowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDj6iTwOdGGNTgBy7l/dYc7hk+CgXIeXRhoPFbkzY+2+wIh\nAIRMzprmad8JGpPbaPNhR/ylR9OVBuQSFW0elES4uEMR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ24IqYRic9YN1qxyEKR69pFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZWI5NGY1Zi1lNjIzLTQzZjctOWM5MS00NGZlYWE4MzJmODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdR92XnUK8809pNmHstZULXbR+2tabbikip2R3qJeinp2I\n7/ofG1R439zVn8fpc3Gu94D7wkyBu1Om/yPfoX/7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhrOj/PRhDPSt7KdQjT1ad5N0\nUUowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfTomRa6HOBKwkSJmJORnS2zyUNGnVSKbgl28rj9A15ECIQDpDjfKRnyj\nZG9WsnWEhNIzNMAF9iMtcj79KwvcEk8+3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVXposif5MlPcHqRMn1o+AQxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBlN2I3OWEtNjYyNi00MWZmLWFmMmItMDhkMDI2ZDBmZmY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmQwNzMwMWQtY2MzZC00MDYwLWIxNGQtMWYzZjI4Mzcy\nNTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELUXbSAUF6OErTl6kQ5Z/04lE\nJ/dxZghN7WGFo+WTr8dL4Mn5FxtN6BJD6vnsGi86zVcyKnOPdfmwt+MvNxaE+qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+jP36pv85IrhEE9K+FhcHnnr770wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA079njtu1lcr55KIcTw5KkhK7BhxY\nWDyKbWZMsGjq1hECIH1bMgKqSIwdsBqwwH2raLbVN8Sv0ua+S+m8vPw+gtEb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2354", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2354` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQHtq7m75qPSwjmtep+b8XXdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzY2VmMWVkLWE0NmQtNDNmYi05ODg1LTBmZGM0ZWY3ODk4YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmJkOTI1OTItM2U4\nMy00MTVlLWFiYjAtY2VkNTVmNjViYjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4uEPE/AoHAfdeHmU+QxJvF9q8PIty+H1qu4va0j6jbCAI0rAHAP9OtzHDyhw\nQap7c1MLvmUSKY6IBHkY49am8KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6w5Nn14kZ7J+jSENdNrGXKjo+1IwHwYDVR0j\nBBgwFoAUqS/R86J6GnSMZbvsMHcbiN24gT8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDABypHxqp3CJTv6UM0H8iAMSC9+aCwg\n9cqHmL3ZeQTGAiEAhzJJkcpl/sZiooBUJPk0qq8XGnoXF9fkU6LIVRRnyxQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYkSZiGoZSU+75menbipjdSVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2NlZjFlZC1hNDZkLTQzZmItOTg4NS0wZmRjNGVmNzg5OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjrm4ZcStPqJV/DupRtS+FLZexR9hZucmFn/Q+QIcOM5GM\nVySz0wGeghcYW+z8HqbHs918i5mK5LkUQYHadAP/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqS/R86J6GnSMZbvsMHcbiN24\ngT8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK/aa4X29k07MUzlFk7w65yU/uEdh3Gp94C9t5/fCgT/AiEArlzYyht3\nK5IEZhY6FXqhzWwhdrzFbHCQL0nJakcY8Zw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUJWojwM5R37Kh1ieDsOCf0mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmJkOTI1OTItM2U4My00MTVlLWFiYjAtY2VkNTVmNjViYjZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzRmYmE0YjctM2Q4Yy00NmYwLThmYWQtZjY2NDVjNzhl\nNGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgqsHUOM89/HPTdat0+S4bMzZ\nBnewUUbikepm2mgmW6lQRSgodWkwn3+ptx0rw5m8eTJOailD3BYYJX123ArVraNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6w5Nn14kZ7J+jSENdNrGXKjo+1IwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAtz0YjSisIRSINYTle1YRsP/o9H00\nesDpWxF6Ne4cFJUCIQC56W4Ah/zrJDIR+Nn6aE6OcQ85qo/WaxNuzt8bKipjow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2355", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2355` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAXiKG+QW0+Hg+q4hY5wrWknCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYTFlNWE3LTI0ODMtNDg0MS1iOTMzLTRkYjU3NDg2N2ZjZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc1ZDA2ZDMtZmM4\nOS00YWIyLWE3OWUtNDBhOWZiYzkyZDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaQH9l+kP8DvIa0IS4gP+SICMM5bGPxAdO1dkK+JSXQheOWZ6p2QWnFRP3Ea6\nu5a0Cw7wpJMKS3uR1BdNR9xKv6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4XRSx6pV8UxmAm/ZeJJaz5mIKaUwHwYDVR0j\nBBgwFoAUSfl+mW7a9feyqbw1yQlEj+G2zOIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCICMKNHeMCtFmemss0SBmHe7N8olf12gK\nQyoR1+fWRToCAiAwyTdECXuf3lAb75Xy+nLnf5Bwe2pyKoXsqDi20QRNzg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQjG7e99MJ16U/i2MxTsAxCcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2ExZTVhNy0yNDgzLTQ4NDEtYjkzMy00ZGI1NzQ4NjdmY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtQe2CvTc92UwljouVv5k+wUdMJ9qBuQkGWArgd0b5DmES\nWzpWn21ydC5HamF2Da0PVzCHTCl+xRZeMuBcCmAio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSfl+mW7a9feyqbw1yQlEj+G2\nzOIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKzClu7cTXbtqtI73qz6DQHaf4VDF9Lk2mIg2umrttCcAiEAgm+QZlVC\nNuh+wf9mxthRgPH5PJYptlqqhpRtkSaDjGQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYClgEirLaJeR7ZeBj4Rv250MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc1ZDA2ZDMtZmM4OS00YWIyLWE3OWUtNDBhOWZiYzkyZDFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjllNjAzYjItOTk3NC00YzQ2LWJlMjUtOTE0YjU5ODU5\nNWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0JVWVQlAFhHbFZuew76N1Rro\ng4zpQTgQbbM6AYfytJM4mjZ9as8L264HigWS37wHfdi3URgQg1fn2I2FWIqdx6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4XRSx6pV8UxmAm/ZeJJaz5mIKaUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAtCN/ch+NaDA/QdqaJohdLbvPm66/\ngUqZH6xAG8g+q9wCIQD4ZNBXvNereeaweEU4Z+8G+d2H6xZK3QHiT+7on4B6+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2356", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2356` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWdOwMEVn0ozbP3B7a9XeOl0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2ZjVkZjFhLTljNjAtNDIyYi04MjE5LWE5ZTlhMjc2ZmY0ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNhNGI1MzgtMTMx\nMi00ZDE1LWFlNDQtMzc0YjI5YmMzMmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWYlm5urdJ1wv+zVGRjSm7L1QdaZy1bvkoWNKVEH/zSH41Adt05XIJqf16Ru4\nl0oL1Bm+mrsZNkTBBZGe4W96N6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOegIPGHFIV0mfVnXtoJ/vNHk1zRMB8GA1UdIwQY\nMBaAFDmYCmh8NBk41l2aDvxUU2ShjDofMAoGCCqGSM49BAMCA0cAMEQCIHRQ4Kmb\npb7Le3HR0uc0a74dGMSKY0E1/uudLzUMOCRcAiBlTytEj1CU4NCVVcDqSfllwCpa\nZwUKDtyYIRQdsQidHA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATXdjS74n9J5rzg0b6ONyHYPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmY1ZGYxYS05YzYwLTQyMmItODIxOS1hOWU5YTI3NmZmNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0w+ieOYhOZceQVbpgjBHDPiGmS1RaFhznQ8OrYlY7E8ma\n8NmpCdZY7Ab3LHq87jJ0qPFSk9z7/yJF1aSb8iDHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOZgKaHw0GTjWXZoO/FRTZKGM\nOh8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEzu2K+hU3wXph8WJAlu0T3Pogl/N3Au2NWLSPxtcdAYCIDZpCTb4cUBH\nI2LCpUs4NTzM/txQhkDAeaPe3J6kss2K\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWV8D4nZyd7kSouoDw6S41XqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNhNGI1MzgtMTMxMi00ZDE1LWFlNDQtMzc0YjI5YmMzMmI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmUxYmE5NzAtMDhlZS00NGUxLThkM2YtNjg5OWJhZDBh\nNzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfQlA/gUQZMvHNgA4l6uDfPi8\n88EaKgMX5ipft27eGOgnLM5W8WLgxdcwwS5nrFAgVkClb+gF3M5WM3ZAjs+KJaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU56Ag8YcUhXSZ9Wde2gn+80eTXNEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAnsE5sp+grIsYcZWedhc+xNIA8GxM\n4P9y0y1JQOHSh7sCIBwQ1d5unuH85SSbh3H3OgJ3gGRopdoc6GWD45zH2Iq6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2357", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2357` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaDfDDUHua4Awhfy6HiCTDsCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlMTg1OTY2LTdkYWQtNDk2ZS05MWNlLWYwNjE1MDgyOGNkYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JlM2NmYTEtOGU5\nMC00ZDdiLWEwODQtN2Y5NGQwMWNiYjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsGYYMuZ0E0UZIXf7Udil4W+2TVuuw9qrDV0kMmBUpzPHICIJKhwv600KtgBf\nCO1Kl53HRglJZBeYHyeDEKOjLqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFO2Ox+0N1UnimH1UZLKdUTBO2ykpMB8GA1UdIwQY\nMBaAFGwXkAKBpdRMIyuIVNvuuIDjjLC3MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiB0H3rpcg/JltSsAbHX4rdUcEgYNiL3leh/\np1q+hdcX9QIhAL+eiveUofH4NCzxXTnrOV5rQ1EM6VDhbSfU9opOdNvw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW/bB9KjN3s+Tz9MinhgomTzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTE4NTk2Ni03ZGFkLTQ5NmUtOTFjZS1mMDYxNTA4MjhjZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhbRcBj2EZ7ThPyBSgT4+HqoEecHSYUmv8ds993lrDDJ62\nxSwwLlNsl1z4ROo7mWxgDyhd5Koo/PGFUH04CTXOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbBeQAoGl1EwjK4hU2+64gOOM\nsLcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfXdZoMhW52xaWhT+CaeHyDH1gsKCT0v99UMuQvMdEj0CIQDdNtW71p4F\nC/k4JCgo3dVnS0QfYiO6uUb01ZCHgF+YgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAR7Bl343pUA7P3YYsoomMJnuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JlM2NmYTEtOGU5MC00ZDdiLWEwODQtN2Y5NGQwMWNiYjYyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzE5ZjYwNDMtYzNiNS00ZGJkLTllZmYtM2Y1YzI5ZjJm\nOWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErZqTB/4WTYE0iu3zbIgKUMqt\n3aDY+p9Q7JzDOWZnLFbxTrM1h9hsp0ZIWDgtTBiHY3pUYUMPwPdpllBj7FIk0aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7Y7H7Q3VSeKYfVRksp1RME7bKSkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAodI4A88EW2IVVCqqXU+gGymAGyXE\nY8Rdms99B4Z5VGMCIQDu99dHOw+xHY9iYd9Zu/IZTacgb1QU9D2U5Z61EnrgXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2358", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2358` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAezWGOqipF5PG7b0JYwJsP3JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyYmE5NjJiLTBlMjYtNDgxMC04NDg2LTFhNTMzZGNkMzJiYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBhOTA4MDAtNzZi\nOC00ZmE0LTkyNWEtNDFiMDY4OTMwY2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEujHTi6IiVh4pfQcu7xiD+bi7zmYkyenmBzl66dS1+ms9wQZQJWyak3UTiLdn\nUpltmzvTIKW5th76oUtrctLbq6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFP1otIE/b6dkG3IFqV8zUCOsd/KMMB8GA1UdIwQY\nMBaAFIHU9K7lMnJbK2eT/5v8FpT/6uSJMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA26RC/EJejIKUCd0wYTzTGZqHtV+2WtSm\nrEmO4zQ15MoCIC3D/YG3C6Q5SxgjgH09WNt8u/kbTDQ+fg7pF9N/jLec\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeJSFl1bdsF5PfpGdw658Oe0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmJhOTYyYi0wZTI2LTQ4MTAtODQ4Ni0xYTUzM2RjZDMyYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4srGoHhLJFzQSHHgy53sqscVWB0TwbPu7YPIpJErW5giy\nmYwaZD+J8A6w0nQWhF3UVM+fwNTRcC0ZH9piUOZ/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgdT0ruUyclsrZ5P/m/wWlP/q\n5IkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJOIWNlw0qjRnch7Nxk5Bl3z8hgF/220/m6Fa74uBZJACIQD/7K4Y0Oy+\nPA8pNYZrjVpJ2l3hc1x7aboaKoAwD+TQzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATyaHcOjpH9Ky0MkPcRGURhTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBhOTA4MDAtNzZiOC00ZmE0LTkyNWEtNDFiMDY4OTMwY2RhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDMxZGNhMDUtYThkZS00ZWQzLWI3NmItOGFmN2ZmMDhj\nNGMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB0z8t15zQH/UTBcscpPCAIYl\n0FRodqZtfhH01FGoperG57foVb0RMhKmipzmpdeA7h3EW/FENGdv8jTATt422aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/Wi0gT9vp2QbcgWpXzNQI6x38owwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAwEjkYUFvmmEw/+wR3+fCTLMt0VS7\nkLuWHoSYfCXswHICICsAmbkD9Sh/tzdYBG/pnAYsehgrqWkzF2yCQtZJdnAc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2359", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2359` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAX9Y6+WLUUI5StoJ0M3Ck6wSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2ZTE1ZTFhLTdmMjQtNDFiZi04NjM2LWNjZTI3MmIwM2VhZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQ0ZDk2NGUtYzMy\nNC00ZmMyLWE4YTQtZGRiMzUwMzdlNGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPxZaK9sgbtCbX+LMv/5oloaa6boPj7X5ICSkGDw4FX7FgiVfaLA2UhCzKxlO\nYt6D1KBSiu/9hcncMmsxM9UysKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS2LZ23YYGQ2QD5a88Epteo6Ywe2TAfBgNVHSME\nGDAWgBQ8UsHoIUBAtpG0ab/iLzThC9EBszAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEjk2R2OqHWmhwSF+5wEQiAz8DKhiC5F\nl5iahOCq9DJ5AiBslCn8hmTgQIjpTSsXiHTXsLk0IpeYiheOTIR2jCLwYA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdQ5PnnSXyGoQo7X9wo37NQgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmUxNWUxYS03ZjI0LTQxYmYtODYzNi1jY2UyNzJiMDNlYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARutNxFR2AsKfu1NlJgjUmQGu1gXrZxH46eAxAbCCnHOVzB\nu57dJIMTc2yoEusaeK+OQOA3pCym3FtB4QWHto8Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPFLB6CFAQLaRtGm/4i804QvR\nAbMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF5kWXpiZNW9fCKbjwp6/1R9NtE6zJ3Lq3EXfvjp7s5YCIQDW/K3gYt1q\nrtarKR6yCUDZwHOC9UHXHSGU8aWeqzRD0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARuEQHFBLSujkl5/v8ixQvcOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQ0ZDk2NGUtYzMyNC00ZmMyLWE4YTQtZGRiMzUwMzdlNGE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2ZjOWM5NDctZDdjNC00YWJhLTgxNjItZWJiYTdiMWVk\nN2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFMRydy81zolLTDZI/kvrcdgA\nqJ0xwibcyS9baOnoMztaEq4CevzyZD2f/sDUMlDhY22Hu5vW9YhjXDv7z+f3C6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUti2dt2GBkNkA+WvPBKbXqOmMHtkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA16Ijr3HVJ6Y4vd7Rd34f2s0CpND4\n3eiPWghfl91Qkz8CIQDVYIfdO2iM4V/xvFhF11iZjPHcMCTIaHIjqnYzYSEbeQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2360", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2360` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQgfxIjPY86RJtWruNxGyIhKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4N2Q2MWJlLWJlYWYtNDE5My04NTU3LTRjYzZmZDZlZjY1YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDU5MTg0YTgtZmNm\nZC00MWRhLTg3N2UtZjE3NjUxNWU2Y2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECOPWGFbiX56BjpD//mj3VFbHZIJGjb61JVQOXIv1CFnx1ePYSbOYKnjQjHBP\nUcau+Yi6kEac5JvvQDT9cLaq0aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJbpVRBvaLvLgy3z/RKqRThAwov4wHwYDVR0j\nBBgwFoAUm1j1n9hb6qW5fjMHssDAeHHTMMIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAuCBL+GMTq+OU\n8uEEGgEo9251shzOj4JmB5VemMMlYQYCIFeyp8zjYFBtVXN/uKoovhN9dfqbKWVI\nPB5Tgj/RJp5q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQrKbJdzqI5qRy6QO9o+GS+lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODdkNjFiZS1iZWFmLTQxOTMtODU1Ny00Y2M2ZmQ2ZWY2NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgqEFyxEXsoirKLK14lAlZ12tyRghfYDfg/yQ+PLAU2EzU\nJ/dFiwOblCfeWKyHcBdmHTIxmJ8Ro5gVuwwWdR7yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm1j1n9hb6qW5fjMHssDAeHHT\nMMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRpRCt5I0sJbQYzEMIM22POdE0i0wguWOVO9eHOVQmE0CICAYbErJnfdc\nCcW6PWZdlgYfgMCSyoGZnJM58U8ZZjYv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAd+5urgLUJ/YuQWOMp+/E4wwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDU5MTg0YTgtZmNmZC00MWRhLTg3N2UtZjE3NjUxNWU2Y2UxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZThlNGFmOWYtYmU1NC00YjA3LWE5MzUtZjEzMzc0NGVm\nOGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpqMmBBlqOmyVB1pnKSKhxkTn\ntUZ+r8a+veZ1ufDE6BW7xfgiQYdN3C0vJ+tO6249MFUgJ56x3CXZWk5XaYzeC6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJbpVRBvaLvLgy3z/RKqRThAwov4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAQ7JNq7CvMMEU5i20uMaSGTUyVp9xH\nmM2nQiqXEZitagIhAMyXWZyeaIbw+d+ohoW+srNiRPhjC//Qb1Gzabs75nFt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2361", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2361` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAd60BekXthYBoEOgffqgqGKZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhOGFiZTdkLTY4ZWItNGVkMy1iN2FjLWY3OTkzZDkwZjFjMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFlYzQ1M2ItOTAx\nNi00YjA2LTkyMTMtMTY3NDk2ZDk5MGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAOfGtAec3hPr2WZfKBw29CAl5Cl//LZf4jxGD9D88Lv5cXSmBNg5EjS++9RU\nsLrppYZ4qjDi+3cdODeFbi8WDaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA5CSTbVoMu8IV15kuhlQT3+mg9wwHwYDVR0j\nBBgwFoAUZOib/NyHtMQozxgmrlELmY98zucwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAUo3zLW4tZPzNX\nEwW0YnTRZynuzuMlhiwyAq25sYbB0AIhAPPszPDbD03G+qca0Un7eltRRquDZW44\nN+k9DTQ2iDQk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYQdTkrRD3nZnBx58y0Dx//6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYThhYmU3ZC02OGViLTRlZDMtYjdhYy1mNzk5M2Q5MGYxYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJjC1+bKnykDmxTXUb1yl409AmJAV7q8jmUkjTsRLLvkIW\nnq0sCkOlDwSu+V0F4O7BAhpmLOXBMmhNyZ00VXi0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZOib/NyHtMQozxgmrlELmY98\nzucwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVsOS/rFbB6WZMMhSJuDTk4/fI8RtSN79iqpTn5FprQoCIA6CkC6td7Sj\n/4HyS3uCGs4AZGitixgXerhuBTcIt3gs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARHG2gZJdwQ20kmOCOxXvbydMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFlYzQ1M2ItOTAxNi00YjA2LTkyMTMtMTY3NDk2ZDk5MGQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWEwNzMyNGEtMWFhMS00OTRlLTk3ODAtZjU1MTMxNGUw\nMmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE375y2PerOTlsoCkhQj2yFVGe\n0ReqcEbxMBd6mY6EF5M+TxevN/SSq0+JP1csVaV0ZTmtJYx2gaCkHTb0HB9ABaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA5CSTbVoMu8IV15kuhlQT3+mg9wwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBaIFAPdoRohMW/7iy7clrZqGaNyQDH\nY4fWvkcB0ubwUwIgFFO9MqIe1DXZM7+sXDcH5e73Ui0kMYo3yTvzQpwY14c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2362", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2362` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAbsPcekiP0Ou7gvNv4FTYgXeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1MDdiYzYzLTQ3YmMtNDVlMC1hYzM5LWQ0ODYxMzNlOTgwYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDcwMjM0NTYtZjE5\nYi00NGM5LWFmNWMtNzY3ZDlhZWVkZjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUexn4vbQsiUB/r62WpdTH7j+H9YQ1KAF5CW+Rvgpg5iB5lglAwKhGPpQ+YZr\npwqBUkczBWJHNJUShFR1cjXXAqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoyXtr7TCi+mhs2JIPPvxmLJQ75kwHwYDVR0j\nBBgwFoAUjKk4LVdiPhin0wK7cc4leYJAy2MwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA31z5ABOz84ZhOHXlSm5z\nneGo6DRGz1SZ4/PYWlaBXkwCIGZ+3MUd4t1Owjen9O+jdJj9pdjB4DbYYbC+LDxX\nhLQB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaUDqqE3HPNlqQsbUiWTg3VmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTA3YmM2My00N2JjLTQ1ZTAtYWMzOS1kNDg2MTMzZTk4MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZxgE4i7gEyydLFJP1B9cAz7R/bhmhwvDK0n+g/DEuwCTA\niUXD64HliHy/eMVdStG7ZyARUX9MfLh+dnfw483oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjKk4LVdiPhin0wK7cc4leYJA\ny2MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBHcdE1X42jvvVir2PPVaR3GacZeCekaAr2WjYR+cq5cCIByIk8lDqvFP\nJuAJVU2ok1aPE9xXZHDhrbjmlEFjudv7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYEmetrC/yQiaGyp4MQC+VKqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDcwMjM0NTYtZjE5Yi00NGM5LWFmNWMtNzY3ZDlhZWVkZjVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTg1ZGEyNzgtZGU3MC00YmFlLWE4YzMtMzdkNmMwNzAy\nZDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYVwYpaj9ASele6T9wRdmZ785\nojV44IWa/vyqOcHDVYkt9kZ715eqkSARjH8amTOgutS9PpBX0+FD0RvslD2ltqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoyXtr7TCi+mhs2JIPPvxmLJQ75kwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAVmofjcuAcGVV+dcfdn2IAs9Vgxxm4\nU3LSHrAQbKudZwIhANMse1Ui+N5K283tb8L/34NwdDbcVBznBPK6vCH00pNa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2363", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2363` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAWwPQ0EEJukdniVf9CF5+mESMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhNThkZjc2LTExOGMtNDQ3Yy1iMGU0LTIwMTEzYmE5ZDMzNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRlNDE1OTUtODU5\nYy00NGM0LWFkMmEtNTUwOWI3ZTQ1NWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECF5w2TWp6ZP3MG8kF7OIyZK7b0M9/qqRv11shedDGMM8Wm8xH7dhHZCG6cF8\nCmpN9LPES0eCrSKN/tFYKFIJS6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpdcDc8hDyHeY/s8o5RU+nW96eqAwHwYDVR0j\nBBgwFoAUjfB7atmV/WFOb34IcT+2pRevhU0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA5pJk\nKG9qYgyZ/YXZZg/q9x9HFMphqXlonF1pZL12tawCIDXobsz0+r5wnbkXoBIHzyao\nMj2qlBuRHp6h36+8eUY+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa0lO+ClK32MN4sEjRTEML8xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTU4ZGY3Ni0xMThjLTQ0N2MtYjBlNC0yMDExM2JhOWQzMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoXqSDVKZyBT75M5WxxAAdDbh0a/qIyGdykdDWGS3Uuf7h\n/byOdp5C3NIirERfPAEOEv0HVxxOwqZhBs4P1WMLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjfB7atmV/WFOb34IcT+2pRev\nhU0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJfGV5gvSbCUbT6pWFo1tP6hf3rBTynMH/KqmIoAR5sACIQDjS9d+pmPL\nA1UBcUD+kJhW3KBkev0Tdhqk6t61J8qkog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbDeysXtxI7VDM9Dby9sGr0LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRlNDE1OTUtODU5Yy00NGM0LWFkMmEtNTUwOWI3ZTQ1NWM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTlmYmQ5ZjYtNTc0NC00OTMyLTljYzQtMzViY2IxNjdh\nOGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEif0FF7+Xtq3b9X6LeTHibu6H\nhxjEjaZj0lY/Ck/qHdpZmMSl7P0EklwL5JfaD/huDZfmACM566aP5cC2wHAgCqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpdcDc8hDyHeY/s8o5RU+nW96eqAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAi07FkAXwf8RYiDDiYBWztsYt8vTY\nriII0xcxKegb4w4CIQCi2DONa2nw56FHDoqId0BBynYERqlUET9snlqHs3sYKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2364", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2364` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAfqfMXnGl/qhaKKry9hVFO50MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NDQ2NjAyLTk2NWYtNDMzYS1iNmI1LTMzOTFlYjFhZDUxOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NjZGZmNjctYTYy\nNC00NjAyLThhZTQtNWI3NmY4MDFmNjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEanC0skfiRzQ7rV1RJHfQ3ahUErGGYYkpfj+sXRg77tIX8LdiEW0/qFbDPpDM\nUCrOC/jT+Em+LXA6cjm+aUa+QaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+/igANFGEQC/SfBPSRlR6m2W9c8wHwYDVR0j\nBBgwFoAU5wJhuLjsOGlRvNNhwYzngeGAuJIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA0GZ0\n3qOZESZa+O/Ghugr8/ysAR5JsfHmwpWjfqd0n4YCIDPsWuYL1OwsVI44yJrd1GjR\nLwV+dswBCTUvChRAW/7l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASNvo7ZTt0yfQhe3eWueTNOuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODQ0NjYwMi05NjVmLTQzM2EtYjZiNS0zMzkxZWIxYWQ1MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTh9110YjJDtyDTI8Q5j380hV2yu6HQRJ01yLzDGfYP3u+\niTci4TzJ6e5WRtaLvxIiON3fndWDBjgDTkk1o9Bao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5wJhuLjsOGlRvNNhwYzngeGA\nuJIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMbG5wdK3JZHX/tm4/3atYNMlgOq1dv5JqGF9LmZS8+CAiANELfa+np/\nWw8S0g9uP+JO90SpU5FKL6VOwPb8+n9kNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARE3BWbVYE8A+chEODlmIOkeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NjZGZmNjctYTYyNC00NjAyLThhZTQtNWI3NmY4MDFmNjQ1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDgyMzkxZWItZDg3ZS00MjI1LWIzNDgtNWFjNmY0MDEz\nNTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECmhnRJx6wIV+w2AXQISkvQZU\ni6Chl441NcQitdN3qeuuUPaQvRAXIPQLVk/VHtg6Qi4WGroKCPy/OZC2dj1E2aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+/igANFGEQC/SfBPSRlR6m2W9c8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAjYIi/BP9+3eb6X2f4lWv+H4kgg8G\njs2Oy8kniwCgpMcCIQDR4247qVxdagFoTcSn9YELNXgh2ww9l+lKFpkuTwdzTw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2365", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2365` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXO5t0FHba2NxPAZBNED3nOzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiZjJkMDhhLTcyYWYtNGI5MC1iM2Y1LWM3YzgwNmM2NTcxYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJmNTBiZWEtMzdl\nMC00OGNhLWE5OWMtMDJmYWZjZTJhZWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+0efTjHMZ85QI+OHpAiIVNNZHINWMUk7Vi6/CfOT5NkjC6X+eHKZMmuy7pg4\nnY//mbBegY37Xw5F1Au+DYJgnKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIMtenFeAYPXjyuyPcQa5xLoVYTrMB8GA1UdIwQY\nMBaAFPXhsqMr+tqtGgAoXUmMubF0mZmNMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA79OJeSFLiZg1vPVUd5gdw2NJ+PQXs4wb\ncHlhbiP9cYQCIFvb31w6o9Sh8C7HtDl5RzJqaR8Qt7Sos+CFYXEJq/dh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQV8LS3cEV6U5W9TE3/8efyyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmYyZDA4YS03MmFmLTRiOTAtYjNmNS1jN2M4MDZjNjU3MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWuH5FXbH6P/5tNUqxYxdQ8b0ofBK/dRaKbXpRfV3FtYOT\nDdljj6YfXHzC1a4SOm4/DlVOQYsn2PATAopWDkWzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9eGyoyv62q0aAChdSYy5sXSZ\nmY0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPjPr9oUHMQ6FKqP09EstrbjDCmEp1r/GLjOMtyooDOFAiEA2YLEWwYy\nNPdMJztz/L7SCxC0STf/gL1atTTpU9uGoqU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdZGFsfB0iB/ct3mqKATSXvHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJmNTBiZWEtMzdlMC00OGNhLWE5OWMtMDJmYWZjZTJhZWQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODc5N2NiODgtNGFjOC00ZmZhLTk5NmItZTQ4YjI2YTZi\nYzExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBO5gR2G7moeqB1sXIO1UhsMh\n10gJIt/VcEqEEjeAYkq+Xftlica5nynx29M+vnBPEvSfpW7beNRQ8FrQ7R473qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgy16cV4Bg9ePK7I9xBrnEuhVhOswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA7NSzQXfSBQ8k6au6Fb2xhQYBmYsDs\nGGHsCwp0XYOiJAIhAM/8l4lryrmPkgMHNdPRslX9zqN5a8T6mV9IVnAoYcCC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2366", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2366` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAUONGaMdQT4vSrYuoEBZi6g7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjMDQ5MmY2LWViMzktNGRlMy04OWRhLWU1Mzg1MWE1MDVkNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU0ZTc2NzktZmYx\nOC00ZWE1LTkzMTAtNmU5ZTk3MWUwOGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKiU5lYnu1f+l3US8+0kkj7jN292lAqZKL2TmlQSxHFr5wnExV1SD8E+aE6Lv\n7KAxRjtJGfiDoS9kwRQ/WovKIqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Vxn3iMoTuBjCbQ9DhF/7aylBnswHwYDVR0j\nBBgwFoAUkgQlY9OfGW5/2+4q2ij8s30ja0swKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIepP8ABnqvJ\nlWd6RQqHs815v7YvFPMLanBih07xXecDAiEA4iNvSi+NMJ6y/WZ1R213bxTxbBt9\nh9UWqLeDIFcqidU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeGrYXyoRlynuR+3WRm9P1eTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzA0OTJmNi1lYjM5LTRkZTMtODlkYS1lNTM4NTFhNTA1ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASz7bwMyEfjuO/Vvdr0VzT+cpjIf2oarbYZeY4lPDxnD6hE\nxn8fyecbgPMHfYbKDv7xlmH+szgjJ6Um7LQLLmTNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkgQlY9OfGW5/2+4q2ij8s30j\na0swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVnR5dSrpIJwyD5mX4MfDBXGkf7h5ikqP3UeSLfO8lhYCIDtd0WZTF+ox\ntKATyJPzZowF5uAOJukTyzZD/mHzInlb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfO/o53LxBzns0BZFBXtrA/6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU0ZTc2NzktZmYxOC00ZWE1LTkzMTAtNmU5ZTk3MWUwOGFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGIyMTk3NTAtOGRmMC00MjYwLWEyODItMTRlYWQwMzhh\nNzc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbc/H736lbNsNPhpMqiBY+IGO\noHtsUDeEcz9a/YrCYnqRswgrcIRR4cOm/pzolWqxLL787DqY7iMegqAQJ7NwCqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6Vxn3iMoTuBjCbQ9DhF/7aylBnswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiB2k9FtaKns/XmFiktzDPzeiimGWDR2\nksa8FnTrIU8DmwIgMYve08VLu+2KcecggM17O/fV7RwOU14VA1p0KMOYnW0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2367", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2367` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAaahd43D4jk425Xc5mwAppwTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0Y2E1MmYwLTI3ZTMtNDZmOC05NjdlLWY4NTNiOTIxYzE3MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzllMzFkZTQtMGY4\nMy00NmZmLWE1NzktOWY3N2Y3MWIzYzVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyaQd3Zx0kLSE0nGAXQ8K4ysnbbJujVDeavS+uLj6Nw1OXfhbPc7RzKuwlx8k\nwiLatnRuGqTaX+dgHkneQj6LCKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdlwUARSh3sDKhZOAO0QeJj74lRowHwYDVR0j\nBBgwFoAUTmSJEYYFb++1VMh9sf2dos9jZEkwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAM0QJHxB7nEJ\nKz1L9UXoZo41OsGQcVfGe17kOguijCXNAiEA5ebxRETfHyueUQsEPB6pH5Z6SqJl\nn7JFrWxSa6S5E+s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaguYFBBqHuilypyI9ZecAzRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGNhNTJmMC0yN2UzLTQ2ZjgtOTY3ZS1mODUzYjkyMWMxNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcprw3RivasClMTPUflUk6oZPqeMD45NoOzI9MQrbfB2GL\n7DVnYVEszp8hkvZQJW537gbY/DE2Murgk10VYogNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTmSJEYYFb++1VMh9sf2dos9j\nZEkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW8ldjHYUqgZvlst0mTABtdy8+nFN05EWcfJ5RBBfpcICIQDW8knPhJRm\nBd5G5S4nJaLhGjjB6pUsgrawIy6P5mKwOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcS7PvNQ8ZS9jjQ3OB/0/XtMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzllMzFkZTQtMGY4My00NmZmLWE1NzktOWY3N2Y3MWIzYzVkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk4NDg0YzUtODE1ZS00MTgyLTlkZWYtZDJlYTI2ZDM0\nMDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHabGZjBL5gyPnA3RGUhP9+YF\nZ4qLGbmu6kYnTZVnMlTw7wKCuBTtr79HZkL9H3hyr701TaIteOj6IaTKXXtgH6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdlwUARSh3sDKhZOAO0QeJj74lRowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBsVXb9Gk6O6ebIw4eirEGqqbrxuhGg\nVrFOgrzXl8h78wIgaHttw7vMHbeY811vtSRV9bfdjtPXcp6CFN2lYsc00y8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2368", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2368` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZSLNL0UDazml1bAnZClQPYpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmNGQ1MDdjLTZhMzYtNGE3Yi04MDA3LTRmYjg5ZGIyMzZjYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjMwYWM1ZTEtMzE4\nYS00Yjc2LWJhNjUtZDg3N2JjYjhiODg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIc4UAY18wnGVOCFUEZsPKEWRcZzmmXkwS6lJHi2rc6qYCvTDoY4ZY/6sKmVr\nFowWtOgSyD+oR+PVE+M+IDSwUqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3mfx0m1m2a/T4phYBrDx9WqKumAwHwYDVR0j\nBBgwFoAUzntJp67IzsbYQ7tNsw2TFJPsXd4wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHuED2iD8QEH\nNj/vYqXMw3J/DMgo9QqdkxjIL5tuZghgAiAoJuYGb8CNzx0CNH8GViIu0VZpQ5Dq\nyXerrq5V+8A1rA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYEUyyBQOZm37PO/eX3ewSyoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjRkNTA3Yy02YTM2LTRhN2ItODAwNy00ZmI4OWRiMjM2Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqxmV+rZgh7k/5GkaHd5DHHXyVNorBm4DRBAFiQ/oaLf5I\n9QogzHxU/tiiJ+eCt+0APGP1kbEggSMJL6iGZZTUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzntJp67IzsbYQ7tNsw2TFJPs\nXd4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPHK33peAUZaKYcXnD9jNp0Kp9QaU+ia7lYzGE85M3z4AiAe/yyOfnbl\nWZsOxvvoL+j/M53CHOjG4zR23SSkG1aQjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUNVbqL4o74eEgZnZdufePZyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjMwYWM1ZTEtMzE4YS00Yjc2LWJhNjUtZDg3N2JjYjhiODg4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2I2MWIxYmEtMmFmOC00Yjg5LTk0Y2EtYzRhZGM2N2Jk\nOWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOG9QqZcKO7o38sXxzB6Oeb1l\nVSnJVzsv75PAtwkMFVL6J+pJr/suBy/vGrta+pbXMMvEhN9PsEIgjjyfZgw+r6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3mfx0m1m2a/T4phYBrDx9WqKumAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA3VLN5gM4wm/R7xdd1ADwzO+e6nRI\npqgi0AaaTdhj4G4CICpMPWvh5r265c0vNTet6oIQZJhBLZadN1CoF6AW2+fz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2369", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2369` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbF5ACu6JbVg2b/kzMmwGgU+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlODJjZjIxLTE1YzgtNGU3NS1iZGQ0LWJlMjM0NTY3MDg3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdjMGQxMzEtZTU5\nNy00ODdmLTkwMTEtNTM0ZmI1MDlmOWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAJtsVhpd48Z98ofiSq4Fbd9G6F9pCIQNTw3tUke/IF0I4cjRvmclyVIX2Kb/\nTXcMUX3l11mMbaX1Fh5URS0nOKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7gUvsnygUwwjNDB87hcJOBqqUgowHwYDVR0j\nBBgwFoAUATBaoiHzV/HBLRhN4MQIHDZF4ckwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCyYBHPy8RMiOhKAqYdRwY6UU5yHZ3ztHVxTvLttUUiawIgcUJxp2p005M8\n8V340vJLac2MZm7MHjzLZv1C6lCTGKA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeBnC1PU7jj9TeoGdKN5Q8viMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTgyY2YyMS0xNWM4LTRlNzUtYmRkNC1iZTIzNDU2NzA4NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREKBtVmS0jCNzmUH3w3BEP1XvAVNDi2JCeE+u15rJXTSZw\n9FqiIcl/wR7vnleBRizcCTdpIuNSyG6KLjzYwb0Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUATBaoiHzV/HBLRhN4MQIHDZF\n4ckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKMVg5XtvokNfA8STgMXNUsbYUu4PyUT9NOVyoeQ53jYAiEA2OFGULFi\nH2LRwrV0UHkF8/dPDrEBkQ1nHLYVq3Ob8LQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAf2vJprZxXvtsZV3KMFHB065MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdjMGQxMzEtZTU5Ny00ODdmLTkwMTEtNTM0ZmI1MDlmOWNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjJlOGM0NGYtMGQ5OS00YTU5LTg0ODctY2YzMjY2YTFm\nZWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgXUrpszyrNGt1soVFM89NCyu\nmkuEYrHjED/EQLKvmC+X6f+Qz/vDICnim2g+JzM3m2KhHzHUYqsk4pSgyjox4qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7gUvsnygUwwjNDB87hcJOBqqUgowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA+cAUH/rVhQuXXuEjNqx2uHNNYWDZ\n3PEiKM/KaLpFOWcCIQDNf6Ztv/JhyuYloW5SHxwyWDC7eSv9OrPT1ZsAvrr+ow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2370", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2370` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAT2RZ3Onh/5/1pL78vKtY0/LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3ZmVkYTY3LTViNGYtNDdlMi04M2MyLTYwYWNiYTc0MzVjYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY3N2FmZWUtYmU3\nYS00ODIxLTk3ZjUtYjgyZTAzOTZiY2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7OS2r43maKOM7vGAGAmTvFIW3nEJ6SOgBdAFvCiuO8QYrN7EiAtj2/pxOKow\nkh24vty6ROww1RdWsEGuHuvUGaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+SY7EJDQhurfuKzEVbUNo0cYm6owHwYDVR0j\nBBgwFoAUderkmKif177YuS6ZXCMhi+Ra8OYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC7nqAQ7zC8jP6CDIxZrD+xBCWmz8W7/URCE1Y5eOT3ygIhAKk0RWlFf9bA\nc1LDCM6Tgb8B0AhrUZ7XpsRXCPYPRffD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeVLeMtYFZMu7Yn5kDAwgxxcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2ZlZGE2Ny01YjRmLTQ3ZTItODNjMi02MGFjYmE3NDM1Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhBaNUMSDNNWx56ocqHsSsYmBYRjoYCL19RTY0QbFdckM6\nEAxq4WZ/G5CIjDOKgkS9fHrCtjB0lZANYoWreWiPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUderkmKif177YuS6ZXCMhi+Ra\n8OYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOZRXnU6vZ4Zqr1oZ9MbcZAxicvWyZejpyj820yxhWUACIHs+AdINAx1/\nCQHia0/Y81PQn+xZYBHCLYA/FNPbBWZ1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQ06vYJIiqAPfTYAxFm6YP86MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY3N2FmZWUtYmU3YS00ODIxLTk3ZjUtYjgyZTAzOTZiY2E1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWRlNmUyMDgtNmU3Ny00ZWUxLTkwYTktZGE3NmI0Y2Yw\nYzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL9OuKbof6B4DVZuoO3R8rUgl\nAaMKOfduohdaeULK8IlJggI6tPFAUAE7Edmi8y1m8eNc3irFZ4UeHttG2eFQ/qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+SY7EJDQhurfuKzEVbUNo0cYm6owDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAyFpu7New6PbJxExgIWMCgq39Z0WI\nMJ0U+/084fv9ydoCIFbiUOpRlVpb6osFOjbQ2FvNR7H4htljflo43LkgvcNH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2371", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2371` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAavR49Ksr1UiUiNAo7PWANKpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNzVmMWI1LThkZDMtNDI5OC04ZmNkLWQ2MTAwMTcyMDAxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg4ZjVlNGQtN2Ji\nOS00OGM3LTlkMDQtNDE4YmMxNjdkMjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVji9VTC8Ls2LyyPTaT0MKuGXVKYAJQqJU97oiVjW+ZZqBea2LKWyShmuKoZN\nTKloAaKuLnBkkj7/F0P1mrNKq6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7kpVVFUxQfxWvYkRbo8iaLKcg2kwHwYDVR0j\nBBgwFoAUhbqSa4neHifibqJewjXtKqhuYv4wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD5\n3QaTwv8k989o3SR0v1SM+kt2u3dBqMSa9ckMXPlctQIgBVgBZRPItE9PYE7XAspw\nSuQ6rXa4Ihuk9up6+7rPqlk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAenVJkYD9/YB6vCpt/sIN0GbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzc1ZjFiNS04ZGQzLTQyOTgtOGZjZC1kNjEwMDE3MjAwMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQU9PHvhqqmGm+HMCCJAYzlYAolr7KMy+nxVLOAndeiiDsH\nxo1n29/qovvFBkIFTzERJsryZ9PPA3zD+0AOxxijo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhbqSa4neHifibqJewjXtKqhu\nYv4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPUhxvxu+V04neXeOqLq5EhjOIN1XFv5Cr7m352C+c3fAiBkWFyODI+Q\nikXIc/+xIfg3WT21PihDc+YgRwWQMZ9APw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAR0oQInXEsjGpiOFiD/Y9r4RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg4ZjVlNGQtN2JiOS00OGM3LTlkMDQtNDE4YmMxNjdkMjliMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGY3MGQzMzItZGU0OS00MDQzLWI1ZjQtOGI5Y2E2M2Nj\nOThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEv/Vsk8tjLb5mDZZ+m7Rw4/KU\n2umlrlgO+U8PvnGJnp2YDhGaDppnTicMUdmYPNw+WcSscW4n2Wgeu6Hvj0KGJKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7kpVVFUxQfxWvYkRbo8iaLKcg2kwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAppsPaavYRc3otjqOcQRv9BqKBw9+\nuuClUZXrTSdVSn4CIGe1jynnScUMBXU7Xa6F2VLFAyLdguNjkseAcV9igGGu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2372", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2372` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAfioJy83W8Yc5BovfIeZrvn4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlNGRlNjU5LTczMmEtNDQ5MS04NWU2LTRiYzZkNDExZjljNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZkZWU3ZmYtNzc0\nNi00OGIwLWI1YzAtMjA2ZmM3NDVjMGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2tVdkxbTXRrN1ARR3sLYH6/Y7z2+h+fr13dNhd7HbtpF7zfJDCM/AaJ3fWm7\nzF+lbOqDW5apsQV3hVLJmApdT6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu12QnSxBWYXYkSkXDGJGDOb455YwHwYDVR0j\nBBgwFoAUdUtPX+yPU2rJMOq6+AzrDpbV7I0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDpALZ3NjKUSgceadB461FE0uz0hs3leYkTmPPFtvvu1QIgM0zl\nle96Mcpx50Wzn+V8fTT7nFcjju1Y8Ux5IqjqLi0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAef8rnAhr5IdHz2AhvcNxBzRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTRkZTY1OS03MzJhLTQ0OTEtODVlNi00YmM2ZDQxMWY5YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7dW7M2wuPPEzulkniNFtx3pCDjGol/2evwdQlUJmK9/VI\nfgURTfzU78igfQIprXxzC1l1NGLZXMkyhYrmYroLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdUtPX+yPU2rJMOq6+AzrDpbV\n7I0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP59nn84SzPoTLuyBJxWc3h2XQd6vkiOaPVZ7GSwH3qwCIQCzfLdRD4iK\noBbL2LVxX/CkNcp0LsxEX+I1Kzc0rJWFUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATq4ePrYlXFYLzxyaMyt7uRoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZkZWU3ZmYtNzc0Ni00OGIwLWI1YzAtMjA2ZmM3NDVjMGI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQ5NDAxZTQtNDFhZC00ZjM1LWE3YjItNDljZmRhZWRm\nNzFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIs7ZxNVp9tS46XFz3Dkf0BUw\nkcgyD9ZX6DO/5iyBZC7z4AYUX3RuCkW+YLOT2MtUtNs2LWPzFjtPOSLI4FZ61KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUu12QnSxBWYXYkSkXDGJGDOb455YwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBPJrhcIMxJzSqWrW3pnp6uP7RXa+qj\nfccE8Ym9nlp+HgIgQWZRxESbTt2gab2rfr28MW0P44lja4kMV11MT2eP6Uk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2373", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2373` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISARDA/ZNJAf67iNp+mU664QekMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzZWZlZmE3LTcwMzQtNGM4OC1iYzdlLTljZjVkY2YxMTRlODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc0Nzk2M2ItZGJk\nYi00N2NiLWE2OTctYjgwNWQ3ZjUzNTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg2vc4wjmiX3ICU5yJammpUM+tNloxZDucmQFHOBGY1pgKu65KU+3nkNmfXIz\nRSyqPE4aI3NdC0lAtjBdyccLTKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn1ERt/zUpgWJiwtM4k1e/9PvhKowHwYDVR0j\nBBgwFoAUPMX6bW2tb3KmwHmcyVGobcawOd8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFOngqx96Ipc7dG5rJS9wZISQv3H3fhdk8yJgZ3IS+EdAiAaqcKs\nOxAY+8hU/QPuPmQVk7iQJXV600hGzlZTP5Npow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUhONe8wKZuQB3lcZr5YSAZJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2VmZWZhNy03MDM0LTRjODgtYmM3ZS05Y2Y1ZGNmMTE0ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWZPohxuDAb8JbU4BXrTOXTgQf788/lRfDYjEm6RIY7BAA\nN+Oh9s9kaSNdMBafC/AxS0fVTpfzv/Fh6H97d1jXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPMX6bW2tb3KmwHmcyVGobcaw\nOd8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKaP/3u6nt+7jGDWoE22TioMEvRfaKIUv8DPLbIzV7NtAiBWcNTHBBIc\nuuB44z2VBv8LMTi6dNdNp0MB0HBBDTOFUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcHZelHdWn+8xvnfM395yQaXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc0Nzk2M2ItZGJkYi00N2NiLWE2OTctYjgwNWQ3ZjUzNTc0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjA0NTQ2M2ItMjUyZi00MDVlLWJjMTUtN2QxZjRmZjE2\nMzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbt+E96S1BOzjGDHlM9G9vE8h\npP17wZhYYqf7Iz4umG5KxDIpBPyIcxh23lRDmrqOOU8GiOyxX5WJibq0ojVr4KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn1ERt/zUpgWJiwtM4k1e/9PvhKowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAvht/qyj78z1qHWkybKexo/RAnnMs\nAIk2WFqmrP7lBTECIQC4/Y6bbItogrr6A79vxEsDdaFyZI0wgUy4gNoXpWVuxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2374", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2374` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAVKnB9z7STSUf8Row4r4ZTtrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwY2Y3NjAwLTg1NTAtNDk2Mi1hZTM1LTkyODNjMmQ3NzhkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJjOGI0NDMtMjM4\nYy00YjUxLTkzYzMtYjdmZWNlY2I5MGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmOZbMGbpE5PJpgckG7A0JvJPnQe0U6zuESXWKoJjAFwLUs1tF/ZFixa1P/OL\nhnEmuW6k/TrrFo4c7nF06Ot+qqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHLQ1hvwcV6uE2tlKCgEmz5uFYFyMB8GA1UdIwQY\nMBaAFCtacS4rdZCVFHpMoOoAi/yekFO/MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAnRvBDh2TdXy0DNaNBSZamgGoojojEa+J\nVWPzPRTcLK4CIQDLn7AFXhMmZwpRdD6vQ7QweBGiaZAS7P7WyvAJJ3fpxA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATZIwCB31N/teBTmu5OB7XMcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGNmNzYwMC04NTUwLTQ5NjItYWUzNS05MjgzYzJkNzc4ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBGRBYMKmSe62ft6ULxl24IYbuUR4XgRjbvzmS0EmE7+QO\n4Waw2OEW3eqHPgG9w1xeq77mBGMI5QUv5y4IefPdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK1pxLit1kJUUekyg6gCL/J6Q\nU78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcnf7GuZzsTT9fSG4oZ0kEYUVd7oLR43I6HaVh8nR6f8CIBaZSFARQ1UX\n8fDRLFLQFYU3ILvmEZMhzpTG+Ibr5oCh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVuRj44LWBXrLzHMOoT8hNcwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJjOGI0NDMtMjM4Yy00YjUxLTkzYzMtYjdmZWNlY2I5MGVhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWE5NzI0NTktYjI0Zi00MmI3LWIwMDktODhkZTRiNmRh\nYWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoQJ1O0fRDsC6bYr8RM9AggKk\nq/o8tApmvEavFPpzD4h5wk6S6/e9qRo5iiRsQNFhPMlx7SSswruIs6G0coGHJ6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUctDWG/BxXq4Ta2UoKASbPm4VgXIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA1uQRaRWpkfUE5ZYHfteCotPjRMZ0\n4lF/2XeqDbXTVwACIQDSe+ApEy5yGn4g9K80k9n/6IT7QVuo3vpLaF1avRW3zA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2375", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2375` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAXRLJFUEanunY+5Gqykg88oRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzMTkwZTg1LTliYjgtNDlmZS1hYzUyLWYzZWM2NThiYzM4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUzM2QwZGEtNDFk\nYi00MDhmLWFlZmQtMDY4ZDg3NDhiMWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4h8kHzLkik22w5EoZHgBnGiuguYZY5V4OxRPrgBzf1BdHP1tHtlUdqIkioyU\nvovhpVlX5DhdqnAjN5NXtepRjaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUICWLylzXINiO819JfTqokzPxdKgwHwYDVR0j\nBBgwFoAUUAepvrWQdvbb8uW33/fr1AdzsFUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPi1VEE4SgKb\n8NHgF0GbazTmG7sF86FxdTkUXXwMDOtEAiAXha1d9ncr3AiX43YwZ+fCnoWVDD8A\nUKMFKVYW9kgTyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfP335JRyzK4aEWIlCzgtTSaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzE5MGU4NS05YmI4LTQ5ZmUtYWM1Mi1mM2VjNjU4YmMzODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTetoZIy///IxZnH4rMc6DqTa1ho7vg7oDsL1lCJMMgh+D\nhr/l6Ga8XusBDdmJvrSsv4g0FT1PDOKEAShGW6ieo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUAepvrWQdvbb8uW33/fr1Adz\nsFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI4eVqVftntp4hLayKJk1ggfXczGIO39jsFsP0SZyW3jAiAKoez+CS2K\nKkA2YiaEid7/Y4zKBRgux8VrXASLYB7ZYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQCdznmMA9YrNfK7D4/zIm2RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUzM2QwZGEtNDFkYi00MDhmLWFlZmQtMDY4ZDg3NDhiMWZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTI1M2I1ZWItZDEzMi00MGE5LWIzMzItZjBlOTcyMmI4\nNTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVJcrBP5BwlzqUDjZ26ofKNQj\n6rj24jrhnCkKP/zjWJ9BYG6UPyVr0QuUgw2F2llnkWGhCDXtAoFBTjXeDKB30qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUICWLylzXINiO819JfTqokzPxdKgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAsVpZBoszMNmWDbGo0fg+0hfGv/uJ\nDlyST1SW076HKzACIQCZBs9hUpOX/gly6aM3aasWLBSuPfwWICIWWltRff+pOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2376", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2376` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASINUsBf3da7U9QRsoI4pRqTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5YTI3MjYxLTk4OWEtNDNhNi04ZjQyLWM4ZmEyZTNkODBmYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQyMGQ5NzItODQz\nYy00YTZjLWFlNWUtMmRjOTJmZjkyMWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHu1GKiXSbtYL6/AdiYw4ErEp0mA1QkuZVyp0T4bp87DoHABEkWF9b+GYUyP1\nSgZDf4+o/lMfhjDwiZTO+mCmNaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVoj7T9E4Iz4lGy0X6s+ymBsYYPwwHwYDVR0j\nBBgwFoAU7eby9Phzc0E1KiiusYnEIu+yvU8wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgRlrh8RYcdyT6\nk3K3xCnb9LGAGjBDK40LEBMgsKGAtqwCIQCXHNXe3/1IFCUbJndXJI3D7feHafWt\nufYlvHra0Dp8Gw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASNYe68yPl/78PWGRonnjMJwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWEyNzI2MS05ODlhLTQzYTYtOGY0Mi1jOGZhMmUzZDgwZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVDnJy4KSuA1MGtC6fz93wfZlNIbJztJMGvVcxwINPU3mJ\nSfuYDZSzxCogTzlNUBvKQsVH8pfXDpKVh7VtkY1mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7eby9Phzc0E1KiiusYnEIu+y\nvU8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAImVJN+KBl1KQAhyUVMNkEGRrwGEK1XAq0ll1TZbZFndAiAHQZnK8MEj\nHQZveVnCXmrnu0Nb4YUSxffRpCqZklsEow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAV281Wc0CG+6ivPP47n0NTGEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQyMGQ5NzItODQzYy00YTZjLWFlNWUtMmRjOTJmZjkyMWZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzljNmY2ZTctYTFjNy00ODdhLTliZGMtMWM3Njk1NDNi\nMzY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUXKhBGfk2ikPi4nm2QvPDw19\nnCuuQUSFy0co8OANK4UHYUYq3icmwULvQpKLVKnel6LIzP6a65125/vZh7zO2KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVoj7T9E4Iz4lGy0X6s+ymBsYYPwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAkWoHApRP8OoMSSaLnQODY7XtHOny\n9UCg296yqHkghb4CIEPoaPCqfbfMVEsEOcwIaMJcR5dMDsZb2FYFm+32OVqC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2377", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2377` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAb4lSWHDi03dB1OvDglzSebPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwM2M2MzkxLTcyNTctNDkyZS05NDRlLWQ2ZWVhZmQyYWZhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYyZDZkNTMtZDU5\nNS00MTFmLWFhNjEtYzRiYjNlMDM2NjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjuIqxVRGpCHNJSHkmZ/OEDCAQ5afxkh/Xdi2YUkeLmSxc9lMs0qnff2O0i5J\noihWQNHuJ+EM/sX0rON7fu3M0KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT0+hVjoV089RZY6IvCNPvEkJQVAwHwYDVR0j\nBBgwFoAUONu70bs7wENIBSBXM02njAFb9eMwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGLPs8FIYhst\ndnW6UCM8i5MhgDepS5g+QNgmdpp1Kq3eAiANMCh6D8noygRERAaj0XmHWjAN7xpd\ny6WSE9dd1pnh7g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZN4buwO2YDk19X4IasXR2sBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDNjNjM5MS03MjU3LTQ5MmUtOTQ0ZS1kNmVlYWZkMmFmYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1aqWRwuTLk7GH5YkUQyWHwCAOve9Fb60rrEiiMPCtz5Uz\n+I2fq/5Ob20IT/s08wjnonhCBp0KZRcIJfWjp3gio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUONu70bs7wENIBSBXM02njAFb\n9eMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALR4AbDl9XE0hU00RlCNzXMtoZWuX8BgrScCj0eMsXttAiBup/d7VD8z\nszj4ZQwAZuczw3wpcyiNCTbBRfgYygaTNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQtIyRnN2mL429jZuDMJlaM/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYyZDZkNTMtZDU5NS00MTFmLWFhNjEtYzRiYjNlMDM2NjA2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWRkMzhlMzctOWVlZC00ODVkLTllODktOWVhMmFmNmM1\nMzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdq1B27iP8DEod03IU/Z16lj5\n4HFKOCRsbNw/0uYSq1Y3WMwGu+RjVZMldb9C0bTowPf8gVFEvsCwXZQf9cO0KqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT0+hVjoV089RZY6IvCNPvEkJQVAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAjGiBt2pwXZR6X0CHRLu4t1xzVQR3s\nVhWIHkXM02jEsgIhAICAcRTm1kz9l8DfJoUtYkvWSQtORUh6++Vd7ij6cmO5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2378", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2378` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdBKbgk6nMW0PizCl8NBr3hqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5OGU1NmMxLWE0Y2ItNGQ0OC04OWY4LTIwZGRlZGJkZjgzYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGY5MjBiYTYtOTBl\nMS00Yjk2LWIyNzItNTEyNzYyZjQxYWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENHPNLEpEOT+ppTX7lo/eGfRe0wvAOIlXu/sZzeTamr4NUxz5KDyMj9N8sVPh\nsh8Rbz4uwASRnS9JJc1DXPrZWKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBRfQkstiudq78VL9YyfZInpQWWIwHwYDVR0j\nBBgwFoAUpXz5xENs0+ehMLJ9Hpv+ZM4ePq8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGX6YUafKdV1b72jzh7WCHZ8yaMJ260ecR1C/JDzf9xuAiB1xy2vECgN9+FJ\ngwgsoxEZFDvQw9xKmyXDocQYi5xFdQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ18FfWsYn9DqNi2ixrJz2N4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOThlNTZjMS1hNGNiLTRkNDgtODlmOC0yMGRkZWRiZGY4M2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3Lkb9i6NSZY78PI4UVb13ZEtwVtz/U/nQxoOuwfxxzpUy\n5JWwtgEWs4xHfWYv24TwkbWbW1dHMwRba48YA37yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpXz5xENs0+ehMLJ9Hpv+ZM4e\nPq8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKiYGFQ/aHYE1CuxpC6EY9tgZG7woHCZKehIbwJWHb94CIQDeL/7PVCD2\nXgkgzG79ssWhpeUmiu5jnWdfXu1wyDXl9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATIRTEYVVk+cBZZQKfor/kpiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGY5MjBiYTYtOTBlMS00Yjk2LWIyNzItNTEyNzYyZjQxYWI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjc5MTkwNjMtMjEzZC00ZWYzLWEyYzEtYzJhZjhiMzJk\nZmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo0Qm1b+FMwXJNdY3t4Lf+eZn\nv6RKZAxUhLO5mCsTOIV5dZGkOTShVhxRX+jXHtyM/Z+sEnEweKUxnzGugKaJ0KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBRfQkstiudq78VL9YyfZInpQWWIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAVDNumP5w3G/3/Of6aSq5gtB6a1TEe\nQ3oBUXbLsj37LwIhALRq7y1t5Llqabcfw3VPZn2m+yFOJqlea8x98tsMiHEU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2379", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2379` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAULix9LZh2b2fo5pFFrmOX2kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3YWVhY2E1LThlMGQtNDVhYS1hOWQwLWQ0MGJiOGMxZWQ2MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWNjMWY0YTctNTNi\nYy00ODdkLTljNDMtMjM2MGJlYjM0YjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaUwefktUwLFoggxqvYQXUDKzbYbFX0jwwyG/anrgO+AzHF2DHhRcc9lvoQU7\noCGLduUgBCuluCOEk1FVxygSsaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU86ancLmDd3lJNEnucGWgkI62rsMwHwYDVR0j\nBBgwFoAUtttBm8paI1w2S6lRqfbsdvd6RoQwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIC7n9WKmyTCk6wswMPT3Ka3gPBSEx0/2QGv18Z88i0l1AiBEIoZrReX84dgv\nWm2l3Ppjsld1b+B1bax613Kf/KtCzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQyGcL+ADRf19tOw7NV66Sq2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2FlYWNhNS04ZTBkLTQ1YWEtYTlkMC1kNDBiYjhjMWVkNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmN711vhGYDDW84+YtP6SbC9xkqSEPhd9q2uLqzdHTSl1P\nbtBwxw9J3u5o1fXFHtsa3sh0kqx3otkX/IdGfhu4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtttBm8paI1w2S6lRqfbsdvd6\nRoQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP/Boqqjd39K9u1NJ8p8N8ZTRbLgdGKepPOQDmce7qNhAiEAmBp94mW0\nVNtCbEGIlgfuJyFTmWuqOLKWPsHZUXD4iIc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAe0kIYOLgXPIDl5MEjdPRFZLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWNjMWY0YTctNTNiYy00ODdkLTljNDMtMjM2MGJlYjM0YjI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDUxY2EyMTItZTUyNS00NWY2LWIyYjYtZmI1ZDFmYWNl\nZTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMISUzhHy2dXkEoZvDA4K2Xzw\nqk9NQ7GLAL6LBsBDbLbLgB/tJ4dJ5XEBeYdxma3DttkSepZL09TpAJ+6FGaiT6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU86ancLmDd3lJNEnucGWgkI62rsMwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAITjezBoopgo8jYdLVl2Q+9qyG9u9S\nRgpjwpezB2YTqAIgHYMtxUoNNQvNL5N74etmm4rjYNHyFVNW27H/vbWaZJU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2380", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2380` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISASdk8N6oD1s68tKw7aHlhT2dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0YmFkYTlmLTE2OTYtNGE0MC1iZTg5LTVhNDllNGEzNDg1NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdiN2FiYzUtN2Q3\nNC00MDY1LTgxMzctYWQ2OTAwYTQwZTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvdgxjcvYJFfS6DudsHZCSObm9ZfUo94ddCMDaKt9NlvqyX+pznBfqm2QWBuU\nqydLTALX7RJYYWqe2piDwJZIeaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJI/ged245s+YuweaLrAbj66JLaEwHwYDVR0j\nBBgwFoAUtGyU+Swj1W4PajxrLAUMuOfHrPcwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCb\n/KGk3Xu1KdqBqpZbwOQ+6g1x5BWJPv7qXzKHZypTfAIgDLi+cHIpd/iN9JFADLfr\nkVJh3ofiUfQxoLfYUY7H5mA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfAxCKiHOlKzPiURjhw12t9pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGJhZGE5Zi0xNjk2LTRhNDAtYmU4OS01YTQ5ZTRhMzQ4NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTMf4L+RKLDVo/RlEaouRdqs4tHM0CPEzkAUXZwdJmzbAO\nMJNYLH7TRc4bkD+RWKAzIJr678PnASwrJ9d2NG0so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtGyU+Swj1W4PajxrLAUMuOfH\nrPcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI8sysXVBqaRzxwYkxRthgKsgp+NJbLMJABT8SUQlY7cAiAy9yQ3wgCx\nPTMy2uoualBeMSSmhL3yIk8w+clifaVbVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAUzw1lcVkux20nlKb8nQKCHuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdiN2FiYzUtN2Q3NC00MDY1LTgxMzctYWQ2OTAwYTQwZTU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjhkNWY5MWItMmQ3MC00YWM0LWIyNjAtMjY3ODczZDZj\nMWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjmOAS/pAfhW0IvNj6ZR8qzPS\nIb3ILglMoyN1LikHOg4QUQ9kBPFflYPnLGA9GrWEZJlKUseXPyRlgFJ93tDYsqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJI/ged245s+YuweaLrAbj66JLaEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAoaE9m+GRjyrgCppgT9STJyk4Anf8W\nb4P62quilfOySwIgZXGuChDfYOjDpJxO7YpUrwo/lB3GEGlnQMQ9aHRZhAU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2381", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2381` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAeTcqV9kxq5mY/1ZGx5C157BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlMmVlOWQyLWMzM2QtNDJkOS1iNzllLThkOGE1M2I0OTNlYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQzNjZkY2YtMWQz\nZC00MjA4LWEzM2QtYzE0ZjU1OTg3NDJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvimNrtdcnAquJHWfaM6/oFBEm3JdAAPFyOVIEoRSA3iD4CgR6XNmkyE+IJbb\ni9QITByM1mGWEGlojp/FJvrFWaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg430GFj69nQGJce0mOEHN42r1pAwHwYDVR0j\nBBgwFoAUTe58cM+9OAPq+eAr9AEDLoZPFOkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIECBf8c6ZTfbHWrnU59NydAuEDdAFh467hDYXMDL0Le/AiEA9StF\nzOgaj5HrYzA1TVxdgjUy+uVm5KSYm/iqAIPecVU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcxRvru2MfhGq8Oj5twwJirTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTJlZTlkMi1jMzNkLTQyZDktYjc5ZS04ZDhhNTNiNDkzZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQibVqLKeUaLgCuzTfCAAdzozHEcg6YE9eZQHP9+dhoI9Q8\nGyUY1h0KR8YLuFHO5agZQBqNfRqQoJEwKEShx5Ggo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTe58cM+9OAPq+eAr9AEDLoZP\nFOkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcTwxZwoCaXHWw/opq5K9JianXRqfrhXdxZ15Qq6nQzYCIHQOa2yg9EJ8\nX+vsVoPdPJNK224aX3020kS8c+htDr/q\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWt6OZ6eCR7g562qNbG14IjcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQzNjZkY2YtMWQzZC00MjA4LWEzM2QtYzE0ZjU1OTg3NDJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQzNTk4YTMtYzMyMS00NDYxLTk0ZjUtYzJlNTY1NDJm\nZjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGYkRXWISU6+Iv5kySW6qqa3/\nbmuJml1utwfkA/b06FnTJB5Vhn34XzOxcVrkANO9zZZfDWnPPB0Lnf5U7t/TPaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUg430GFj69nQGJce0mOEHN42r1pAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBhM+52HOtE9mg47grsOU8mUXcQsjkk\nYINpS4YzmMNPFgIhAPAqIWcCQQ5uwSx/xZSnr7UoVyV3zDd2LOsO3d6v9EG2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2382", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2382` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAdL4Tb/rgeM3a6u3yETLyA/+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5ZDU0Zjk3LWQ1MWMtNDYxMy1iOWY5LTQ1M2UzNTRiMDEyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGIzZjNkY2YtNjY3\nMi00NGEyLWEzYzgtOWVhNjVkYjdjODRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERbgZ0NvcH613eRrD+QkXoM7ske4RgMmZWf+wwSWrt6VQc1+s86gYiu8K3D/S\nlSGDhMmR7ARIbHhBOR+gSI4HraOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+EJQMNmMnglRax2jJrLQWAJWSpgwHwYDVR0j\nBBgwFoAUeCOrla2iSFRwkYHoJR6IdsQ/S/4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQD5ny4yZgWcxeUnCW68T5hUq9MZmSzRoqWCxssuqIAYNwIhAINZ\nxsoy7uqhwFzhYYrqnPNE4UrjXxJ+si9v5MYSl2mj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY03JJQRJfJ3YkLK3fXvqGQLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWQ1NGY5Ny1kNTFjLTQ2MTMtYjlmOS00NTNlMzU0YjAxMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2uaSF4GQ2G5oRhylHmkN6KPDLY+Sb5kBVO2cNMBItSHXs\nhIkygU0g+JgjUY0BGfJfK/hW5tFlgz7DSsEeME9Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeCOrla2iSFRwkYHoJR6IdsQ/\nS/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcitrpBeM83RtULmM+4yKuZuJVWqN48VYmAmkUhiSA6UCIBUKelWeZGQt\nAXbW0HcT2jEzmzt4vWJAPpH2qEZ8Kind\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdW6lB+WXRuhas05s8l0/uTOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGIzZjNkY2YtNjY3Mi00NGEyLWEzYzgtOWVhNjVkYjdjODRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWRlNGQzNTYtNmExYS00YjMwLWJjNGMtYzc5ZDQwNjM3\nY2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnbIM+GvE1qmkXbC8ODM9zk2T\n+Vw3jTlLS77mtLB1RCxzDtZvpiH+x0Pfi52dRxntmC/ftnqlAKQpXdm3XolRY6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+EJQMNmMnglRax2jJrLQWAJWSpgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiB7f+tmNAAsWhi9G4eJeb8K5RnM2scR\n5yMLlZPOHXhTfwIhAO37LsNPTVo2nQDvfoKn9sIy+YKW71VTlTeTffyyAxpl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2383", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2383` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdQNv+dqpIelVR3ZnmuyazGAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkMGYwMTFkLWFkMmYtNDkyZC1iOWI3LTU2YmQxZDRiZTAwOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE2ZTdiNjktZDli\nMi00OTVmLWI5MmUtZDJmODIyMGQ0MjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKd3fnaZRvHwGxrGDlXFkFmdwa5z/W0v/DvF1EaaHU8f3mQ2GJvRpglGPapCb\nl+1s486faqnppQiEoxyMRapszaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRppFq+ez49c/dckxh+hSgUQbhcgDAfBgNVHSME\nGDAWgBSRMzAyTFjIPmhjVJrxmiqCnUxDxDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCSIK0Jg9ssYpuppNN/SUofheH+wtaH\n5KsEeJSU/y4/eQIgKGLZpFMbd95Z4MWRpaJFwrvF2xuuuXOp6vBwIMvydok=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYsXXizTqPKJ5ZIu19D10PfOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDBmMDExZC1hZDJmLTQ5MmQtYjliNy01NmJkMWQ0YmUwMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqrujgvYqkZ5NkStxKbVy3nhfJ3iJ3tmKCcy9v2F4BfNlE\npT5mRBcQay/LMYphmKhR0YPUCozoIQ+CPyb+BKPpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkTMwMkxYyD5oY1Sa8Zoqgp1M\nQ8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPFOZSv5O0CCWT2K7mdlN/WbUvbj3FsELWUltQd6CA0oAiBDa6PZVoKj\n+DNaoInDkzztOLj9Tgbuk4QB+kLuxpob8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWPB/dww8JdV/LbV53npO0ZCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE2ZTdiNjktZDliMi00OTVmLWI5MmUtZDJmODIyMGQ0MjZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGVkMDA3YjktYmM2Ny00NzAyLTk2M2UtNzc3MjI3Zjc4\nYWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiwV2hssyYM8cV36tjUAWCRSl\n1a5p3p6f10XA+rokQXgDlQgiauJ5edGEnsCJxpOFo8DJq1ZotQhxjgSZPt4qzqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaaRavns+PXP3XJMYfoUoFEG4XIAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAinkuC6SCEMuBVOCquS+oZE1Re8zm\nUUqldYth3r0mbqUCIAlAI96t74RHfmit7oMaha6QpqjMKC3FqCySeBEPje7N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2384", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2384` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAXRFC/8HKGGR3DUG2b6dWrK+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1YTZmYzY1LWJjYTYtNDU2Mi1iYjljLTg1ZGRjZmQyMDhhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk1MjAzNjUtNzcz\nNi00M2IyLTgwZDAtMTI1M2RmMzFkZWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3uC+RzCQljimsy49N8gr0vkld3ybSWTi8jurZXKLbHFvDTuzvLq4MQ3+b/ZN\njq84DAjubi8+JBZsr3WgoCk2ZqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlbDx0CVkc9q67lvBowXWwFOlBL4wHwYDVR0j\nBBgwFoAUSb/ivS6Aly+J4kzN5FVp3zyFzlMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCQdkT1YZDU\ngfKVAezqVEwf7tIi2RqgkHHbgK6vihQlQwIhAPIGrOwsEDKQ70rTK344nTxyQQXa\nZjr8yMb/4LtVq7SM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbzKtVrx6fcwMDDYWNisuKYsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWE2ZmM2NS1iY2E2LTQ1NjItYmI5Yy04NWRkY2ZkMjA4YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrUBlpmQSvRYvl3izAcCwW72BLC5jpturSEO9jJwfM2HAi\nRvxDYUnPUzYpkizJcseHzZ9LNEd9wSa3FyHmzRSGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSb/ivS6Aly+J4kzN5FVp3zyF\nzlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLukLF4bq+RDMj5UMsBOQYYbTTfbFqj+yN9pgHJhzamMCIFNQ0E9hZ1Gi\nBNFosN5Khg0vfsZGOdb7I8AMeF305Cgw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfhLGbbQ65ypwpE/oCgKasXSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk1MjAzNjUtNzczNi00M2IyLTgwZDAtMTI1M2RmMzFkZWM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFhYmVhYTctYTEzOC00MTJmLTkyMDgtOTQxM2IwZDM1\nODhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELI7czrVkUnI6a4SsWSREJPS1\nkJ1vjxYMY2/ZbixIS0VBHkZYN3AosGLzhCmtCoRw0zbyJdX0Ddhj48oH/W0T+6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlbDx0CVkc9q67lvBowXWwFOlBL4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiB9/IxirL5jI6zX5bIzBQ8fFPusmkxf\nASTvj/Ifa8AAZAIgIDh1MQgmNwwu2ZsZ8N+35I4aVR4wxip2LqjtwPZYQr4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2385", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2385` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZhk5yh9NYlkuikJpw7hlDU1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZjUzMDc5LWM5OWQtNDNhNC1iYzQ5LWM0NTZlMzhhOWE5OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU3ZWU4MjktNGVk\nNC00MmFjLWE2M2MtODQzMDY0YjE5MjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENAnkcUfwdJDomjdlcVHfor8dN7IZkbMhUncNdMpzXLOdJHsMagki0TLLdTSL\nP+Uo6vOBsBLEXmqPGrdEM8XHpKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuuC7suH6Tc9U4kg8iYyFz2L1qY8wHwYDVR0j\nBBgwFoAU+9vHkn/yxtkpG1XsYOvRQExkDw4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIFKgos0zGFEz\n69IbrW3/1jrz1q56nBO/n3mMT/bz0I15AiEA3I+V/LLDETzFggR9AbUBOAfkMe/2\n6qcm1X3HGPbTSGs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASPe/r1HQV8+j1UgfRzXgvbNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGY1MzA3OS1jOTlkLTQzYTQtYmM0OS1jNDU2ZTM4YTlhOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDizI9xv4FQw89SmqyXQoHq6vostsC0UgSL/eO8IhRYQZr\nmZBhsJ75NA4YOlcaA2bnOI0NRpwv3ZDqBDNr9GwMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+9vHkn/yxtkpG1XsYOvRQExk\nDw4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANJJPDMzBraesq1KMlVrX9ePUrWUBwDDh/O+mMDHduT/AiAJKJYJVCUd\nNWX88bAv+kxcrUtTqoz8kb+6yOXNaEwVPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAf/Glv/NBS4x7SyE94zmXvj/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU3ZWU4MjktNGVkNC00MmFjLWE2M2MtODQzMDY0YjE5MjdmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODhmN2M1YjMtMzhjOC00NTFkLWEwNWUtYTRjMjgwMjI0\nMzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2+Hz1RyBlXTzWgcpW4K+KmvV\nKgCKTdS+pu8qCuxoqrRj+g1srksIlwVU6l/LsJYsp2BJY5VGlvYieQBM9RLmB6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuuC7suH6Tc9U4kg8iYyFz2L1qY8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiB+77MucWg5Oz42vKdo3GarZneVjDLF\nQxzELGG033ACtQIhAMzI7UCz91eRBXphryxPc3EhJioRFNHeF3J426L5YeAM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2386", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2386` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAVKNDbMYgr7guT6rt+LAw9aEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhYmNhMDU4LTA5ZTYtNDFlYi1hZGM2LTM5MjhlZTk3YjVkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU5NTUzNjMtMjM5\nOS00NmFjLTljYzMtMDE5M2I5OTRmYWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEORUdxyyxkktann9MzrhXUEE+b733oQpFKNrTY0/qHrnRDd46GBlxPcLmw4KC\ntsUiYwaRC7ozd1gIDVgAT376E6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE2mQsUSWeoenSHdVx26j9mNtDMEwHwYDVR0j\nBBgwFoAUHl91hyI6/DpXY4zz8eNYJfU8h4gwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAewA+42Web\naPON8UFxRtpx3iPZ3JK3rLtXKGTOAZv1kgIhAM6dy5FnWcCw3LCXCAyA8x1q2ENe\nAwgjo6oNArrsjNmF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUnTC+vANQ1/Aicd/B2RsnsbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWJjYTA1OC0wOWU2LTQxZWItYWRjNi0zOTI4ZWU5N2I1ZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREqyvu+MLF4vt+wvleKZt/Tj3PUafS3y2HGmr5iVaOzlUM\ngL3SbWjkd6XE1KuyOEsW5KS4FPAbQ1YGciXnpWPho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHl91hyI6/DpXY4zz8eNYJfU8\nh4gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJX111CrRhzfd+YAPgULeLJroUFrXjZXJ5Vv0h7NykVVAiBchWqRKsf4\nL5Klv979PGY6xiJrR+CPmQN9Z8dtfrRXqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICBzCCAa+gAwIBAgISAeb5whHUtytFTq6iURI8lIyoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU5NTUzNjMtMjM5OS00NmFjLTljYzMtMDE5M2I5OTRmYWE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2IyY2NlY2EtYzg5OS00MjcxLWJjMTYtOTQ3ODM2ZTAw\nYTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8iCFmRELxyCS6G8BnJjr7BDs\nuTqzMBPjviVG/IDWwa+LW9atqtzLQ37bNLfacgUqJASnct/lC1wBVMG/SuLPqKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE2mQsUSWeoenSHdVx26j9mNtDMEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNGADBDAh8Zr5pj3mFYiCRxjB4zeNOEplG9THWc\n7STbkr/uHraSAiAkWRFtmcDQi5cU7REddMBzJJq6Adg1u0+YUIol2kIsmA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2387", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2387` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdPgn9rMF2GvxQT7nw5NyHT3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3NWVjYmIwLWU3N2QtNDU4Yy1hOGNiLTZmMWQ4NzQ5NDYyZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmI5YmMyOGItNzI5\nMC00ODM0LWIwMjUtNDBlZmQ4ODFmNDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmIaFkAFjfA8Te/wOS4EwNtNEsj86gMTicFxqV3IV1y1B5uaWEj16nMtmBg9i\nYVwpEWjgHnxWMV3mXmZrCLybOqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfHR4hm8zovPBITBRYgcHCVroCsIwHwYDVR0j\nBBgwFoAUhb7Ir+pkcV+Ac7LiJEBtXGNZolUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiAGxyntwEaD5bEZp3bpIfYkpDNYf717Ze6ZXYB9dL0xeQIhAN96Ua1jgz5s\n57v01SU9IHSUXBrD37tFv3J+X77oFWMV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATRzQqI27tOniabzj6r0GTw3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzVlY2JiMC1lNzdkLTQ1OGMtYThjYi02ZjFkODc0OTQ2MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/mx+mBxvHttlwA1gVkmM8Wc2bDEn5MHGw1ibugU4qA1fP\nQbQghka+HJFr/ovCeCeogFL/AQm8Z9sZl9e/P/Qko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhb7Ir+pkcV+Ac7LiJEBtXGNZ\nolUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIQTcYuKHDRGdhNtzKwAnQTUUZgIbuH1ta9ZihyxIlx8CIQCnUGhXqIIP\nw6oLJJJXFYKZvsJqqNLUYoQ0Ytv+ykCrqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAe03I15dJHsUbvGflDrkVOqBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmI5YmMyOGItNzI5MC00ODM0LWIwMjUtNDBlZmQ4ODFmNDhjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGI4ODM1ZDEtMjVmMy00M2IwLWFhNzEtOTVkNzg3MmYz\nMDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG3pVb1KY54LeJYHFmMHg2OT8\nane/N8vxvPxwt3Z9G/7BeATSNckXY/KuSZROCEM/Gsl/umPz11ezakSeygslhaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfHR4hm8zovPBITBRYgcHCVroCsIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAVMbfbEUyc7aP1exkFMpHfzW6ddzoF\nr6ooaewbTq/nDgIhAITeuLV0C1VSteH0SNMo2OT2DpJsYFsI3Xm9l6IH8boI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2388", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2388` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQMQGYg+ywKd+eg2fk7jU/v5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5YjY3OGYyLTgzNjUtNDNkYS04OTE2LTc3NTNmY2ZjZmUyNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA0OTE4NDAtNWM5\nMy00NTlmLWIxODktNWM5NDljZjhlODc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7enlo5p18Sp6jaYXSEJSESB8FGtvz5BMB8JQx8PWEF4vs8BWtyaLwywtmjsX\nQhs0Rifno2zoPNW4DR8UV+K9VKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkH7LIZ/7GMOe1fICtA8KFQlvkYgwHwYDVR0j\nBBgwFoAUPIsvu6wxBr4Cm/CbAgeRbMT6H+cwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAA8q9PYedT6xubQ1Xybvvb6X7mLGQUx5usI5+p6ro7TgIhAM58ZTFh16wU\ncNHYzqc5j+mdQGLyCmbIsmvidoHatS1R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQdrLxcvK4OAiWDX4E+u5F++MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWI2NzhmMi04MzY1LTQzZGEtODkxNi03NzUzZmNmY2ZlMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUn5Gx/8DYtiHEMDSiEszR4uG2RYDHsM20GJspTly6dQJs\n2PSGy0S4bBF/zz5xzCzZKftoExkeHnQ05xhiYhofo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPIsvu6wxBr4Cm/CbAgeRbMT6\nH+cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJFSLrQ/eUsXOvlt04Zw3hTqBHLjXFNBYNsCDlvBuRPYCIDziXTuHXbdd\nn1w1zCxPv26azJ6jkaL64npLGk5rSIXa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdJYcnjQ1YoIH6JTj/kNOPfvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA0OTE4NDAtNWM5My00NTlmLWIxODktNWM5NDljZjhlODc1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWE1NDRhMjMtMmY3Yi00MjkzLTllMTgtNDg5ZGE0MDQ2\nOGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGhDJ9UxU8W8uNR1Xrm3iUnMG\nmcu1Xbtc/sSIZnogQH3wbPk2XHoEDsYo1KBswjGk/z9k5YRtmhoG4sqynEGszaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkH7LIZ/7GMOe1fICtA8KFQlvkYgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAFk2mIJK0EMDTb2fjzW/d6/FWgWdGq\nAfMafArZ91JO/wIgPERb37lubqxt+Ph6xomZNA8VWzTD2XRwortNJpYP7Wo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2389", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2389` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAajpK5p5mWanEsFrpWziv+TxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3NzY3MWY3LTA5YTgtNDY0Ny1hYWU1LTgzM2Q3MTVkZjEzMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzMwMjM0OGYtZmQ2\nMS00YzYxLTk5MGUtMGMyNTQzMGE0NWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7rC0FLWEUW4Fxr17iMQBM2IGHaNCH1Ub1MT7FMT6kXkv367GLEWQ25RAbC3i\nSELO4YF/7+aw05rXCP2U2O/gUqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNqa2nRJoLXTECn/yrQs1KZh7OtowHwYDVR0j\nBBgwFoAU9iQgo1g1EECDpMLN7YqhF3wI9jowMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBz\n3rNibH7dDmhn0So9uQBZ1vZvP47XV7aKryu1o2h5RQIgOd2IDI9wR+XjI0VKsZWv\nsDXuLN2ZHSXUYhctFIdxx84=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYeDBls1iOUxssqpcDIm7lm/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzc2NzFmNy0wOWE4LTQ2NDctYWFlNS04MzNkNzE1ZGYxMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtAQ+btf1W/1ZzmvZcXbITYGE2VMr7TZKSGsk8VLBDqMWj\nL0IlmGus6KO2ok0DUrTmnmsnUn+0rrt1tfTRsZCOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9iQgo1g1EECDpMLN7YqhF3wI\n9jowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaKvB2A6/B+ROPJ0pIrdvbcdVDnpsq7lhnDdZCeipmzACIQDG+TDtO28/\nCeO6/EerEuOSsOqZc8kSQ9O5SrStXqwytg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVIeZ8gd0DxgqnZ848S6HgHMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzMwMjM0OGYtZmQ2MS00YzYxLTk5MGUtMGMyNTQzMGE0NWFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODRkMTQ4MTgtNGMyOS00Mjc2LTg1YzMtZjZlZmY1NDE3\nYWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKzR5AbrqGVvMN33KOlZ1E1hT\n+ZeGlY/yCOq1X8ZiNUnfMSR2EsTqns55IyBhnr+JG40rsm1XbDFJx9ywDjZS9KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNqa2nRJoLXTECn/yrQs1KZh7OtowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA9ZpMHQNtsgyqgYzEtiocEx8v3Fa2l\nO/f7J+FkjVoszgIhANJuxD23UkUCxlSpvWliBlK+CDlO94lqO2WHE6XC1/gu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2390", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2390` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWX2pg/cyRms+8GFV7Bmh6zGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0OWE5ZjE3LTRiMmUtNGEzZC1iZmUwLTQ3N2Q0ZmNlNTAwODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU2OTZjMTAtMzQx\nMC00Y2Q1LTkxYzQtNDcwYmZkNGQxOTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExsQvYHvx1RmeRatZtBDA044Mu4a87a2TCqEexITlt+JvGfyhzH5T9fVIMv0j\nmTOcRGFq4Uc235nLYrZ5dZ2ToaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoeHR03dJy4OWZrzl5H+pxq54FMcwHwYDVR0j\nBBgwFoAUpUB3ahHbPhVolEDOCpaAFdO/eAswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAreSd31qIlOivQ8/sVNH31YOzFn9zWAvR7010ivAwLWcCIF5z\nbJiA9R+QEdxJWMjxOfRkp4D2OivXwFzk5OLXtfA9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYbxq0bQ7vWpApiuNtIujq2sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDlhOWYxNy00YjJlLTRhM2QtYmZlMC00NzdkNGZjZTUwMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpfH+a64KiT/hTEL32rCY9LD7nKgoNtppWnFKYLN5hg6Cq\nDN3ckYlwqR0Fdi9WeKAkZHL3VLnaZ8MzgM5ivd1Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpUB3ahHbPhVolEDOCpaAFdO/\neAswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMQjRh/B5pz0BLg/uXM8anU+XbvOoTVhCUbIJJPimPVRAiEAz93t7FJ1\nXLlHbQ8UtXwwclfsZl86a/y1Pg2Vgg3hQ7c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZaXsdsWrMcxpMMZ4Zq0XrGgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU2OTZjMTAtMzQxMC00Y2Q1LTkxYzQtNDcwYmZkNGQxOTVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzMxYzc0MzEtZDQwMC00Njg1LTg5MDMtMDAzYTAxZGMz\nZjZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFfhFY9iOoSo/qOQkDoPkTi7b\n/tAwLiwPPLlhrcMigcRoeciypYOirQl1PBgbslT0kIUMPceJWBZhPrwddpN7lKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoeHR03dJy4OWZrzl5H+pxq54FMcwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAD32YyH49PmRXei9DJJ/Dg9rM7t56I\nmEnFEBe10osHRwIhAOfGqum4jzdQgF3c+P3DvhwztuPd6CKtyAHw5MVb4yh0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2391", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2391` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAeehypWCvzezS0rdyWqlcJAOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2NjY3ZTg4LWI2NmUtNDJmOC1iZGI3LWExOTZhYTcwZjJlNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM1MDBjMTUtYzQx\nMy00NmFmLTg2M2YtOTYwOTQ1NGE4NTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+i5f9/78hrQL7SCGviLYeXPuAMoXBAuZusP1aEJFSQjDEPBQqrMkw8PeIM/z\noTdMXt+a9a8jBKDCNWqHpMK8h6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv2/dNESNPcIDkcn5MVD6d7oz3HgwHwYDVR0j\nBBgwFoAU++tmlaeEplUe6DaDFAU4zMCI1kkwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAzsoLhXkJgJESQXhvX2ph51AL1uryuy1Ph7nBMrv9kbgCIDiR\nqWTZ/1OVfX5Cu+4ecnjoVCFNA00gaeGvgim1zVRS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATHetAtCYZFy969Xi1jhOOF9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjY2N2U4OC1iNjZlLTQyZjgtYmRiNy1hMTk2YWE3MGYyZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2TwVP7YYO6D5pJAYlBWt/OHegY52Qo6KcSjaRRaUd283Z\n08BroQwlKIUBFQ/IXZMkRGJUGUoqI32JKsZ0y7oko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU++tmlaeEplUe6DaDFAU4zMCI\n1kkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ2XDStUIVO1WeA+TcuQzS722zKYYd7pltlzoARAA6OPAiEAiwump/5X\noEw1PCn1ZxcnHtRzUt5OD74G8gZGbssYYsk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVgzMN34x/EnEX1nfSHKMS+nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM1MDBjMTUtYzQxMy00NmFmLTg2M2YtOTYwOTQ1NGE4NTkwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjgwNDc2MjItYmY0NC00NjcxLWI3NGItYTI2ODFmNzY2\nMzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/Lkz+zvVkn7dibrOIwkl4Q7K\n6piMRxj0xjp40JmZM/vkD39rQ7NgzSY0AQQGEn3+cP/oxfSolY9rk9yAAkeUT6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUv2/dNESNPcIDkcn5MVD6d7oz3HgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAp0O7Moy7YZubiL3P6woQx7UakRmk\nXewvT+U5bllvTxYCIQDFY9BEE5DYpzO0grfbgerimXUFXvYdgTGLFJ0zqw3evw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2392", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2392` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbuv4TfG73FKYQ9GNn1zYIGqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZWJkNTA3LTVhNTMtNDdjNy1hZDJlLTkwNjFhYjgzMTc3YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NmNGQ4Y2EtMjIx\nMS00YmUxLWI5N2YtYmU5NDkwNzgxM2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVH6Puxk1j1/vJA0tOW+Q2Hbv9/u4dFN/G8rP2InKnEFwNpNeffjLerse17lA\nIb/lzxMgXh7Fs5SxeZEkF+aBBKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIowDVdRu8CxMU6lrwu26CiQbNgQwHwYDVR0j\nBBgwFoAUZQjGQyjGuJw7jeLKLpjsztZAdykwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBuLGMDSEB+Wglv\n7kw5lFekBTXCD/PMpQaFd9XqOCnvZQIhANC6Rp0dK9cR6k1C6KO+mBnq3vRgqPdX\nnNUwlO7ZA2XR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYBIZXqRi+796d3x1oetJwx2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGViZDUwNy01YTUzLTQ3YzctYWQyZS05MDYxYWI4MzE3N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5oYutKoggzbnt9A0svQ0DGKKi/SQO3pNZrmyvt8MaFUpu\n2T+OkEIkXq6eRzCyYOLlEQ6XtLYhna0vHlFKX4xWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZQjGQyjGuJw7jeLKLpjsztZA\ndykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWtdePi1eC+ttVfq8i3J+LtYRFi5hIXbftcJdQCUTr3QCIQCpovPWvUHh\nyKIpE5kPIH+w6D/jbbCvlTKDGk3Z92gHMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUoqVRcdNccIeT5kZgAU0+ZsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NmNGQ4Y2EtMjIxMS00YmUxLWI5N2YtYmU5NDkwNzgxM2U5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTIxM2QwOWItZjM2YS00M2Y1LThjOWUtYTgxNzM3NTQ5\nN2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhtS+RNkJJ/qE/fCyP/KKlE48\nV2dNxvZ0Z2405xX1LoEkJHyQrHAjA8tiB7Xal28QG/mF8eRHTRNXFzzN0/0cJ6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIowDVdRu8CxMU6lrwu26CiQbNgQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAarnbIdCRAtk+dTMtEcTliBpXg5M9Z\nmw7dWvqc7ZtpUAIhAKnYPJJu3OTbTajnHumrCwLdEzK/+va6+KNr0ZvHmZrA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2393", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2393` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAV1T/8xz0rYQikfUDV8hqtuRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzNzQ0NjIyLTJmMTEtNGVjZi04OTliLTUyY2QyOTU3MGMxNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdkZDEyMjEtY2Mz\nOC00NzViLTgyODQtZWI4MzAzZTYyZjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjRlE86u5NXx7wTCCenYy4gReKsYAa8qs0cLazLlVZFGP5S6jo6/aX0Q28Bl2\n32o3QGIx8auVgVxkP52ALBVA9qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJTBg/9MLNmA1dEW6z5PxK7/ey+wwHwYDVR0j\nBBgwFoAUIP0P6Ejns2fcJFlO6mY5we/ub4IwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIC1Q157vyriQlTvKSohb4OF9tLcDXU89RSpZ4InNty2iAiAth0hMqr751tB9\nSg0EH0bWpH8OVAgF3RqVuVgD23I7dA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARLrTmvPLUDAahpqFxUNlWjrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzc0NDYyMi0yZjExLTRlY2YtODk5Yi01MmNkMjk1NzBjMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy9yOH697yPeyxSrNnIBvtHXGYliu30PrRtSePgAAs2ubn\ny5xdOBSjIgRwA4zGqfbR2lTATNzukbrwzmV1rhzco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIP0P6Ejns2fcJFlO6mY5we/u\nb4IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSu13z4i8bIMYE8XE+RQ6D2xI6b47omfatR7HLxUJvpYCIQC3cTjKZ2xm\n8PnbxrUBSQnYh5plE40q7WHrFeTpVzrPlQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaJ7lFBCrsNQklJ+fXw6TPa4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdkZDEyMjEtY2MzOC00NzViLTgyODQtZWI4MzAzZTYyZjBiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjk1YzZkMmItMDgxZC00ODdlLTlkNTYtYTY4NDc0Zjgw\nM2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgZSGHn/iWiOw5Idq0+ds1ELZ\nzWIHeZKW4jmgNKr1geafUyLxIX/KKFQ3CH9cFMXKNeiyrXx34ewY4PnERyl0TaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJTBg/9MLNmA1dEW6z5PxK7/ey+wwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAr/xXAD5Y7RKTPwW8HU3LdFzQWF0a\n+pUjMbFujsyDr3gCIBL72wQSFV/LQPfTZ8szZfZcL2332PeKvB8dcHJWD7Pj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2394", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2394` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfT0Fn0si7eCv4rOa7vXsgSqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5MzE1N2VkLTJhZjMtNDI5NS05N2FhLTI0NWUwNzhmMWFjMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZhNTgwZjUtMDI2\nYS00NTMyLWFjNjgtMjgxN2E3NjAxZTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvsxMNBaE0dBUTwB3j1x3jGsbZCopi5fOXHpaptKcr2yyfxQcCMY0DhOeHL4V\nMrXWQ/Ozt1BMxZ/JjjDrl4jZEKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+kJRP7laN2iXK9elXnrGsrKuPfowHwYDVR0j\nBBgwFoAU3wmBLT33tRFC4ahgsb9ZJZ3Oeb8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHA8gY/GSV25DMeck2PaCq3faufdDAFYeV4qktLa8lj7AiEA+wbslmkjoRbJ\n7w/Pj8t8FKfaQASdCqINuDPwfHw13y8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfqb0idm7N9T4frnzx5wKRrmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTMxNTdlZC0yYWYzLTQyOTUtOTdhYS0yNDVlMDc4ZjFhYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyQziTWUxKg67bVg7Bhde2rNbY7i9Dxd4hgtbMOOE66Ih4\nGwVNKJIO97WHz2jRqJcKkHtE8ZxXP1MH8shgXq9Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3wmBLT33tRFC4ahgsb9ZJZ3O\neb8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUa+ypi0rBGpWYNogF5KCQluonPmzMBhjMpK9dYSQLGcCIDvo2EGs7TDc\n2OyObkrqZ0KErv8O5QsBq3ALa/yE5Ggp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAe49bOlB08rnbxZZVyUS8/RgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZhNTgwZjUtMDI2YS00NTMyLWFjNjgtMjgxN2E3NjAxZTAxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWVmM2Q4YzItMGI1ZC00YWEzLTliMGEtODQ4ZmM0YmJh\nNTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+eQg1kiBE1VMMhYzK46pAmaE\nON07SLPSiyvykVtOzqPu0/IpRWalznVDWN3BWcyNB/DSOXfBVPL3LmT63nnk6aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+kJRP7laN2iXK9elXnrGsrKuPfowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAryTrwsU16LkGVJeFBX9rUBqOzyhT\np+MqpR+3omMlWDcCIQCZYHIHmobr0Dvuy/bjgb3lXfbYaunN773vr6gUvPS4fg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2395", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2395` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAWvuq1h99iBiz78aTinAKD0yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NTM5NjQ5LWJmZDItNDQ0ZC04MDU2LThjMmQ5OTkxNzc3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFkNWQxNWEtMmQx\nMS00YTc2LWFmOGMtZDY5YjJlNzk1YmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaKqUh1OeMicJtytd+UBjyhBQkNpKSoT9ZBtYxSbSQlXyNyZs0ViOdnKeqRcz\nrhW+fNLy70u9gwspIfJxJOZcD6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSDpVMYDkViGFU295rn7fW+PhoC0wHwYDVR0j\nBBgwFoAU25QqsY5qSsuE00eVXCf7vY6SJ5YwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAQf8RH4jGswbF7PhzqGmm41zJUq0uTZWnT9ddJ5XvLygIgN6ystArEtlFV\nf4BTEIo04db+XOhzWoAYtY7I/2/9rV0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXbHugUH60yUvULoVtz0ZdoTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODUzOTY0OS1iZmQyLTQ0NGQtODA1Ni04YzJkOTk5MTc3N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQunx+Gcdy2+tcbaQUIHznMztwS8VzoSff1ha8odRg2L/GZ\n8dtK+VflB280vCYls8UaqAEiet88JubFIWfi85Kco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU25QqsY5qSsuE00eVXCf7vY6S\nJ5YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIWITGPk8+2oJMIGwiOjUVyvUuYO8HKGpe58ZeadcbzoCIA/hSNVITK5h\nmtNijPtw3btGnCcL1VUpDpGhVmgf1OXM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWW+3d34NEl05Fnac5cea3iUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFkNWQxNWEtMmQxMS00YTc2LWFmOGMtZDY5YjJlNzk1YmZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGYxYzJiYjktODM5Yy00YzkwLWEwOTYtNzk2ZGUzZWJi\nNmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGEApqjE25eU4qHmKw68S8XKX\n2Cn37FTCIUCyIbf1NPqy57g5sUs0vUXv8a33qym0fnGBRPs70vF4PfYMY+bu7qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSDpVMYDkViGFU295rn7fW+PhoC0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEApt+BMi5IYbaqWG4npV6FST2jqnaN\nM8K4QZb3+f5CA3kCICpBht9NGVgLTXVs0Y86Xxql6+1h3fZjBkVTFdsPuai0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2396", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2396` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISARWSXXwvPgGjH2r7FzDuBJg/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyMGZlMTNkLTBhYWQtNDQ5OC04YjRlLTdjM2MwMjJmZTg1YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU1ODkwMGItMTll\nNy00N2UyLWFlODAtNmUxZDZmYzRmZmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES3n5fxClPYegE0yfKIEtPU4HOHlNwvo2nLb5T1rMAX4SxRJ3fCiITaZ0VYAr\n1jONnBOBADQ+l1BmukpjTlQk/6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2mS4Cj6TjVVrLupmvDbhzbcx5LEwHwYDVR0j\nBBgwFoAU75r5bzbCkEuf+GpnPDGIiJqi4GwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBieC/D6aXiY9xca3pDwpchx0KIP2rpU5/D4db6/EGI\nUgIhAIHNlrp9zf0TjMuZpGOlb0lL+mr+yo6IJ9JTo9V4rfp1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATJTQ4hcOSyXCNrlga74EF5MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjBmZTEzZC0wYWFkLTQ0OTgtOGI0ZS03YzNjMDIyZmU4NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWqACsmYpXXrFASsMMECu9HqySxUpLGk23m2opyL4iOi9V\n51A3HPJOd4FpqhSTap8FcX24/WhwuDbMIJzOyHV6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU75r5bzbCkEuf+GpnPDGIiJqi\n4GwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKYhYJpb/r10PO/69nWlJU4pEHxcJODu1dmiOrQmag5JAiA+x2AD/q1U\n1C/Fa+QW2HiFDs8Ly4EbyXriPHZkVpH2ug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQTEGVsFcK8Bezu0d0J+rUTjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU1ODkwMGItMTllNy00N2UyLWFlODAtNmUxZDZmYzRmZmIyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWM0YTU5NjktZjZkZS00MjVlLWFiYWEtZTc5OTM3MGE5\nYmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfclYQUuhrBLrCoHXLliq995j\niQT+6/eA01gWvSCWsTHnHNkpOvwzkz9p3Ac96xUMenQEb4UiSqG3KfFnj3GWPKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2mS4Cj6TjVVrLupmvDbhzbcx5LEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAcHXy852IIx98XIt0LycCnmnkkxNHA\nRc6VKUvP/TUewgIgKgNbudXfMY6GHEutbEf8piLDwE7QkROEhcxdVZlV5tQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2397", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2397` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISARESmzcHwQXyksyD0XGBU8yLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlNzU2YTZkLWZhNjQtNDU0Ny05NDgzLWYxZTE5NWNlZDJlYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg2ZjEwMTAtOTY4\nOC00NWY3LWIwYTItZWNiOGI3ZTM5ZjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6PEcEFJ3ClESXVi1LOoizcK3wvZQtYvdeQThQSAy4f8B4U3nlb3ku0XKY9Y8\nynCG/D87ChplvpBK4IJmQmdGzKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5F8Tp2eyQFzaew+Vwj3/qHVeA7gwHwYDVR0j\nBBgwFoAUJvAf/okCCsD6EM8bAPy64ZmdM6MwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBs9ulfeZ9izfTmfDKRyWo449kPba/9JjCBI0ROMdMY\nIgIgeilLzTeJzErdmK7to7KX1IpTlGwe6WSCyOUkB6zESNU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATdtnmrL7ofScrD906LBCnE/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTc1NmE2ZC1mYTY0LTQ1NDctOTQ4My1mMWUxOTVjZWQyZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3bIF2yrzXHXaE9VmCj6zuejtOn/i3vGX3cHMXmsYNXg5O\nKNagGU4/4xIWT1c/UsVqYf7UTA/H0l4GQ3ck23DVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJvAf/okCCsD6EM8bAPy64Zmd\nM6MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSTe+yzpYT1L24/Zx51mL5KFgOKYllWazbYJnpyMSfbwCIHSpQJoH9pd5\nqWU6LLma7JHN1fcpbxL7ARI+1QmWCx9+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUUnXHlh/CNYa/Way1JBXmHTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg2ZjEwMTAtOTY4OC00NWY3LWIwYTItZWNiOGI3ZTM5ZjI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzRhOTNiZjctMmRhNS00MWEzLWIwNTctZWJjMDA4ZTBk\nYzZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaFF1P80NCY5qT7C0G07XwD4V\nKOIeMY/+NM6ku6C8K0/PBP6cjhuQFxypw+bqshWZJ5gt9O7v6Ro8rOZ3F0FwlqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5F8Tp2eyQFzaew+Vwj3/qHVeA7gwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA/m3FtdrZVzOYyeq/ni47zj69uisU\n5MUUZETdzFFTXykCIAuuiW/V0V1IFNWTzE9qQO8S4ONMf14oC5fE9EMTJULe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2398", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2398` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAY0DqgY8zqImHQUHfXDzpQCdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxZmZhYjI5LWZlNGItNDA1ZC1hZjk5LWM4MjVkOTVmMmQzMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgyZTU3OGYtYjJk\nNy00MDUwLWE3YzQtMzk4MjE5MTlmYTJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETMFksqbON9ERTX7WDXydogTr6It2oESwAukt/zFDz1hLCPFgDmPUZBYngw++\nlqJmn+Jhi2gl4iTFGAPtxj9W9KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPf4oUXv55uRF1SlzSyr1Me3rjM0wHwYDVR0j\nBBgwFoAU+Hz+KD6/V6wa5sqFLud0Sa0OKwcwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAXycyoUDPcB6Kq5nsjh4cxnTcviyZ5aK2KK9920NG+swIhAO70\nQOq53VXNEYgcp0VETsF9TFkU4L5X+nJMe62MPji2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ1Cra+cfwkjWv+DtKvpIB20MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWZmYWIyOS1mZTRiLTQwNWQtYWY5OS1jODI1ZDk1ZjJkMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRGiajkvtDX4fq2TnduGnH05nB8fLoOsggpU/op4jNCrPI\nt280v7I3gkMW5V7A5fFRUbsFhH9xABBQkUGEQRUoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Hz+KD6/V6wa5sqFLud0Sa0O\nKwcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSSfvRUP7kaUnhE+0sclzJ79SMKsbYZ+QPTYOkmbVmjcCIDjbQPHivdpn\nFQHbz3zF8tZOpNm4OmmuZec+KCMxjhVI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbNMeQ3nk3/qqFSStQMrh5PpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgyZTU3OGYtYjJkNy00MDUwLWE3YzQtMzk4MjE5MTlmYTJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWY0YzAxNDMtMjdkMC00YmE3LWI4YmYtMTM3YzQ4YWM0\nNGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/LK8nkaI+6BvdDoGreo7xhjg\n3gDRCei0KnIaTwiHPk++jhKyVOZ+41K58urz4vRX9A7EiCd5s+1FErpVFOgXn6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPf4oUXv55uRF1SlzSyr1Me3rjM0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAnbOPG5iygpBQVO2SumFbK2b2R5vs\nbjbHTUEv04GPUh0CIQCpdXSWQav5oq4MTuAfTylJo/GRcm7iqrxyCJ4iSqihjQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2399", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2399` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARL1LlHoqZu5mE9wg9cS2IBUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5ZjUyMDA0LTQyOTktNDkwNy04YWZlLTkwYTBlYmZhYjU0YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTEwNWM3NGEtMDhl\nMS00NmVkLTk5YmUtNDM1M2I5NjA1Y2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE18qffkBBYCWUPMD22M9/xEm+a2+R3FkBDgmpVssN4rP5c3PLlaripWjKIlWK\nCZSEQMb9Tc65QdgBUZadSCqgMaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwRPc1Mhzq2Nd623PDA03ck35fsgwHwYDVR0j\nBBgwFoAUZzb8Iw7+syBWX5nvQeNAREPnPuwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBqhF2GBtTqcUeSBV9IawtvvQFFOVKWCmpe\nrae0geB7DAIhAL5NniRrSyVQEMdCfEYTfhY4fBWi+Sl2dbOf7V08kyAZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeH9RDGDxCg8mSmaG3KVShcUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWY1MjAwNC00Mjk5LTQ5MDctOGFmZS05MGEwZWJmYWI1NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+Z3/C4XbwmyAdkWwlbIGMT+lQ4qKKfvfg8AuqMoawSTiG\nGbfUE3pNHmGtZpacK8Ye7Ekse3oBQ1xlMTt/6MRJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZzb8Iw7+syBWX5nvQeNAREPn\nPuwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPyg5ExyVL1JFO1tp+dKqVECKxVr+BvwwfcLtji0hmfCAiEAxXiqMVsA\n0bNXvRgyfNGx8dKVVFYvSfinu4KD8L4qIOE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAc32oNB5xCGdAHPxx3g7QH7EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTEwNWM3NGEtMDhlMS00NmVkLTk5YmUtNDM1M2I5NjA1Y2FkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQ1ZjE1NGEtYTk3My00OGVmLWJhYTQtOGJiMDg5NjI2\nZDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESmvLPlyN6tmiC0PA5VXvS8jt\nxgyCitlkgFNJMpCZqJpPsV9vDgupKxvxWNilOvXNXRmpjx87cP1lBT5oyKNKAqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwRPc1Mhzq2Nd623PDA03ck35fsgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAuTYHpxbyVaW7Q24qy2k251GmyVY9\nX7PO/fW3EXJ/S2sCIQCStz45KTLGIjtCPcIswFQgszmxBV0+wCbHVYC+v3qw3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2400", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2400` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAR9tqOe0DBQ8bZv9RpScxorOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1ZGU3Y2Y2LTkxY2ItNGJmYy05MmYyLWNkNDYxYTg5MzgxZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhmMmVkMTctMDdi\nYi00MWI4LTg2ZDAtYjgxYmVjNjZiNmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETziqdcb/w1fn/uYNYCgrqpki/4TdQ155h7rNwNK75vEv0NDx/5Juz8tN5pNc\ntcLZRG6KbWebnWC3bjl4scaecKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURct2n8jz6J2eJVnPtBprtYGcQhMwHwYDVR0j\nBBgwFoAUWhg00KPOzKkr5gzvz10w5D5o8zUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA+zPGeTUu1xVJnoz2s+03vZPjlBAS6kOi\ne5dgLVBlKPECIQDX4xNSg4608pMzZnv3ygeZqnQIxrQHmVo0gguBM0g7lA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW9qVXLYfQ2DbaxyOqD+i5KxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWRlN2NmNi05MWNiLTRiZmMtOTJmMi1jZDQ2MWE4OTM4MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxWgZqzKYG+icXvHtSAK5dLV5TecjNY/0/E701CL4SXlvY\noRwMp74jcdeRlwAvuJ1AyzIZNdFDxIsUdPJuKKdLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWhg00KPOzKkr5gzvz10w5D5o\n8zUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMVIWMbip0c/FuCUSC0H3BeEtaGrfT33dZO+ImVasPOoCIQDJ9cKU0moD\nzB7Gvs4kskPt0lGso5htDFHpbeBV0R2eDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUc12XyQAW8Z715s0uTaJ6ZhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhmMmVkMTctMDdiYi00MWI4LTg2ZDAtYjgxYmVjNjZiNmRmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY5N2VjZTgtZWJiYy00MmUzLWJjMjctYWE0NDYwMjIw\nZmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl66cJaMe8KIHP/WqdmhHZskx\n+ZOK4UTNy4XfCsGzb+a9cwALUgdSp7VJVpKmy02kgh7y9dB3GyDbe/db4GcMNaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURct2n8jz6J2eJVnPtBprtYGcQhMwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiALzJrTANsDQbIhFxD1VTOrTxdpaF9C\nfsQkNmQHym78jgIhALyMiVou1TJ4u9Bi23XnYivgTykTrTWE0XbxYGxFnxig\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2401", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2401` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAWMo/BZjdFS6Q0MJHASxyO4qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwN2M3Yjc5LTExY2MtNDc4Mi1iNjYxLTVhNjhlM2Q5MGJjYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVjNGU1NzAtMWFm\nYy00ODdiLWI1MTMtMjU4ZGVhODlmYTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECXpHDvqijil50so0zsq3HxtS76XbC2hlpfqU1m+Ztuh+nSdQV8yBQjE04lgv\nMhY8qIUQh4uCYWt87+uHYy46IKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9iKxU9rv8GPKzzK3PEDMb0K4Z5QwHwYDVR0j\nBBgwFoAUJe8DOdyLMvwH0BHEnG+01Llyz90wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiALWKbIEZJTGtbg\nBQoVBqzu7HZJxyc38+jYGeIdZylbIAIgOxM4ajqYrSNCYDGZTSTCK7uvhIONQfN2\nRKz1rOsV5EA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUlycyaiI6m9ryswHBZllI9eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDdjN2I3OS0xMWNjLTQ3ODItYjY2MS01YTY4ZTNkOTBiY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS258+YKlfOhu/YW5l3khDKikd9xwSdvdRrOmtnmuxLbp3G\n5osvjpauA+tGFtDaP3ypscJSj6BtD16CUvBskuBFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJe8DOdyLMvwH0BHEnG+01Lly\nz90wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIibuTnU1uWqvy8a8HxlhAYcmRXpfZut1az8PvoOF/EACIQD5hwiMv6/3\nQOtZNeOXDOL2HkH4WYeoHHzcf+yNom2YZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaC/BPn6OXOBL4JgkZfk0kW8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVjNGU1NzAtMWFmYy00ODdiLWI1MTMtMjU4ZGVhODlmYTczMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTFiMDViOGEtZDE1ZC00NjczLWIxZDgtNWU5NTE5MzAw\nZTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAET2evFpBPUEaHSawDcSIrH3+o\nxjbEjtgZ0lxrjEo06vpjr5g0RUuLdW+yVU7Qb5m9Iij5dShXlciPKercUCKcYqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9iKxU9rv8GPKzzK3PEDMb0K4Z5QwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBGhVUG5LFvUJQlqOh/ZrhhhWtaULms\nuAr1t+cKYPpVqAIhAPxDKbYkUPwR6LvA6RFI/54xiNZGNSFi+KLHq4stHDJv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2402", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2402` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAR/qG/DfOtUAPeIWZNZ696baMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxMzA1YjNhLWQ2ODAtNDZlNi04NzY2LWM4Nzc3YTY0MWE5ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFkOThlY2EtZDVi\nMC00Y2M4LThiMjctM2EwYTZhZTMwOTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVRmxzdittYbM24uSxEHOjaFwfBtz/P+9MhT8kIge39ZoGXlb0qd+D0afpU0P\nGoseravuScTgqGBKzrYTtvbwIaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Vdx1cGSmOwsY8+B4xbt08xzDvMwHwYDVR0j\nBBgwFoAUmia+1XQuA1HmhyXuKhTl3FeuvPIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD4qKK6ZbmZkp/+rY0xm72nYH/iwCayyN549vYhimMmTwIhALPryUlxdpQl\nZD1D924/DglskNOsLRmaKy4Z3S6XggRm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQklI/iYX7BJubKxYneGgjIZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTMwNWIzYS1kNjgwLTQ2ZTYtODc2Ni1jODc3N2E2NDFhOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAuVZn+J6u646tFrBDoIZ5NjfycqAAuUb0w27+6IA3eoxv\naiMO26mv7NK/z+/cqZlqRQ76h8uqxkwR1BoOxqqvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmia+1XQuA1HmhyXuKhTl3Feu\nvPIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP/7x9XV86iSnvOsg1V95F9ZRCbL3ipiy6g/vFTQkQY+AiEAg2dK7tZg\nSDGJBtB4GeVQ7QG4h5tXoXQgEWP8q2rABKE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbym8q1fpNY6hWD69+iF66DJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFkOThlY2EtZDViMC00Y2M4LThiMjctM2EwYTZhZTMwOTE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmU0N2UzNmItOWU4ZS00ZjA2LTkzNzUtYjAyZGQzYmMz\nNWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcNXqNBDTD8hlFITzksqzIGgD\nagSUuCMqieacnWPVJr/RBWzYt7b1mMr2/psPu3IM+eQqLSs4N5f8BMy0LbiT06Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3Vdx1cGSmOwsY8+B4xbt08xzDvMwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAzuXW9sIioeYs0pIdE5RFFQT19Y2kP\nx69g0wTky51T2gIhANv1NgxnB8pnLBWBmj+uCsQjUZJs5OZjr67MPJ7KH4c9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2403", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2403` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQXIy9OlfNKF61QkjrrBs3zeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5MzY2ZDhkLTA1Y2YtNDM4Zi05NTVjLTVjODY4ZWZkZTkzZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU3YWFkNTQtYTBl\nMy00YjI0LWFiNTUtYWM1ZTkxOGFhY2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7p6dyz4dreoVi63isaA+YsSUoUETDLQTbNSIIEKgfYiRyIXOUSNZFVC+3OmO\n7XAA/aqFdIbwX+2dvy9lS6V1EqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfjtFL/aeXWogBg/HoDncPnYtQfgwHwYDVR0j\nBBgwFoAUhGXrKysW9JpgfrpoeWA2mDRbN6MwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIE8SAMxk2lJlmJ0YFSK4rQFF3uqL3VbTUOaSD8hlVdJMAiEAqi8Dv6VuYHQz\naAThde7zQlQyoP214mSEzBuXWALAEKk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARJhK9c9AcpY3iUbNhPrrxftMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTM2NmQ4ZC0wNWNmLTQzOGYtOTU1Yy01Yzg2OGVmZGU5M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9AIHcSHBhbYLPK9zSkCAumZ/OSxX2J0Uke2B2CaZToU1c\nfivgLj/KLAp+iMzsZTuL7CdrHdvCX2J8CsvAuVWQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhGXrKysW9JpgfrpoeWA2mDRb\nN6MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD5ESSgiJRJF9bvbKnRpoZUw+QX60oQzSVxSSOTl7lQICIQDriRmBITEQ\nIGzBdWWdNAVqtmGOeCQv4WwVI+rwSLs5ew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbuOHhLuEBQEr59udXQkJbQzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU3YWFkNTQtYTBlMy00YjI0LWFiNTUtYWM1ZTkxOGFhY2Q3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmEyMWM2NmItMjFlZi00NWU3LTlkODEtYzdhMjNhY2U3\nZDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEq/IVeAEHPeoBWLWLOY+SBdW7\naL9cxBTt5QgefDfUVTyhwnshd4wP0VNYd/TJjfNvNXXipOAPjHnC4hKFD8cul6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfjtFL/aeXWogBg/HoDncPnYtQfgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAxL+1thMd8DiinhlL2PI2YcInKJH49\nCLXnUkNcys+iuwIgZrAKy41rBPPwFOS1ETBEDITYY0NldNKvq+fa1A0ck5s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2404", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2404` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAb8BqbxFTRwsJ3Cu049Ufn3eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhZDE3YzI4LTc0MzUtNDExZi1hYWY2LTk5Y2VjYWQ0ZmY0MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I0ZmFiNDUtMDRl\nOS00YTZmLWE3NjktZDZkNTcxZWU0N2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKrKsvVrDDKhEFknh5d1PgQ5z1lYvmzl8RqyoDZSMkmfHwYBZF+N/lnE1rG3B\nVRbSMkVooTSbItjSbX+8vYeqEqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFEC8rcoB9ZO72LN4arKGuyCpDrYwHwYDVR0j\nBBgwFoAUe+zBy2Kl3fVvZvQ/An0RhdD1BrAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBRE/TFGn9C/mSchKze9/p8lcqyz0IE/+DfZDNCErVSQAIhAO6OcqEKNI+t\ny7Uh3i7+us2xg1i0iOUVnmo6ZAtUtaua\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV7npx70KBZVewF7R145rOJlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWQxN2MyOC03NDM1LTQxMWYtYWFmNi05OWNlY2FkNGZmNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzeZeY7WxLPTl2Mrvh/SRpbgmwWUiwYDU13nDRyL5qGXbG\nSW/fV2z2r7Uos58zTsU5dX7gCML2LLe3J+v2a7Spo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe+zBy2Kl3fVvZvQ/An0RhdD1\nBrAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPHr1u3Yxf1Wn+ogzTuX/DQmPk62J5qdPsYrrLlKI+oJAiEA6u2NUq9p\n6OvWqovnU4g/HBkMjs+fgYvIb92RYorrqkQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZMaFEeMjzIbOTYx6I3i9kfTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I0ZmFiNDUtMDRlOS00YTZmLWE3NjktZDZkNTcxZWU0N2NmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2JjOTRlYTktNGI1Zi00NGQzLWE4MjQtYTIxZWEzYTRk\nNWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdu355Iroelx71Qbifkkf+gER\nw+C+L4ITeJS9VkMFJfkT6rYgHxGwDykrKHhNP/UnTX0NtsAkPWxwdIyMq5B4zqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFEC8rcoB9ZO72LN4arKGuyCpDrYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA8xEnZH5Y7y/9GJC+hmN7oS0sSgDZ\nLdso/qoVkYtSZWICIGDcTAhr+ntwRfJ3CFqi3ctCx8WFUDtG4yPCIW6qtlSM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2405", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2405` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAWt6GMmlz7bSrKfr7QF5o4vTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0ZmMzNjJlLWZjMDktNDU0Zi1iYTcwLWU2Nzk1ZWFlOTUyNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQxNmM3MGYtMTc4\nYy00N2JmLTgzZmItZDJlM2FkOGYzZWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqF0gzZllXMqPQXcggo2+9w5cJHR0zDdgX3jihSfnFfwohzFFu64iZz2+ktgh\nkE62p1zxVcHSasDT2sgxdvcLL6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEawRMtMorneWc7/oMK+BgiJ7VdEwHwYDVR0j\nBBgwFoAUV5sETxItePjY67ZnCa/8jpzjFbUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAszCAR9kHmrdAnWYySxItzsYF6lK8AI76tKlmHGh0\n+McCIQDf9+PpyC/7cuXpqQ45HAElAdqcHyDjL6HbeLJLRNdumw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQhXO+QXQlF4PzWUkmAD6PArMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGZjMzYyZS1mYzA5LTQ1NGYtYmE3MC1lNjc5NWVhZTk1MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSFcJyT/uNAY1VKPP7fCA65mVC4O1RAimgWuYInKro7PaS\nE98vVmn2ZjTbpYh5+I36K9wSZKn1jI4OpR+prn3Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV5sETxItePjY67ZnCa/8jpzj\nFbUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK/UQ+tQyO8fZx2WQVvlL5YZV3eoJo18/5JvYsrJM47cCIFzK+Fbm35b1\nUu0wFpeR77S+ng6PW/bMYMXpJVKBHXuH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVcb4QA8AL9/OInPRBwL9DBqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQxNmM3MGYtMTc4Yy00N2JmLTgzZmItZDJlM2FkOGYzZWJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjZmZGZiZGMtMjc5ZS00ZTRhLWE5MGQtZGQ4OGVkYjIy\nZDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL/ZFKAs+t8P1Pe5IQ621pCr9\nHAP9Zv5TVzj9o17DQ8OOHSf8pGKGf9z8HYQuMg9FdbZjBWyPyc7vB1pYcFkjGKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEawRMtMorneWc7/oMK+BgiJ7VdEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAh8Z1QeyTBsh1QRadIDHgdqnkRZ90R4X\nLGUq5jvpT3uxAiEAnDidSrtVPBIQMCL7s+GfdNBmeyeiujTBbZtm+ZBnXRA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2406", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2406` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAe6FghOZbmStAbSbeoGezHvXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzYjJjNmU4LTMzOWEtNDkxZi04MzJiLTg4NGJlMTgwYzhjOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlkNTU2ODctMGFi\nNy00ZDgxLTg1MmMtNmJlYmViYTJmOGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo3ZT6apvtY0NNaphgHoblSmsxs7Vd/0SIbgDRAEvhpG1ok7+qSBjCN4QPhF2\nNVCMIg3VJHPrKFp1gKS813XuCKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm3c7rz7vBfuzYv4Y8m7XZzcWh0EwHwYDVR0j\nBBgwFoAUHw0HMLVWSVCvmiGeOfdtkqlTLkIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAo1CBWMZ5zpXnFNs/k9hvQFxGB5+L4qfyEh3iCgmu\nTbUCIQD8KRAfMyPwXN387W5Lx9ebRS4rn0UrQCbSGM0PLrgr2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZgW15H09CO1Ghdc5+Zd9EmEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2IyYzZlOC0zMzlhLTQ5MWYtODMyYi04ODRiZTE4MGM4YzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+J10iuweClvEkpKsP2bqds5IzP1reNe8R6ZwdgCc2aZl/\nkz1nxQMpXUsz2v67O76yv8F7boSNyFEcZzjrc102o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHw0HMLVWSVCvmiGeOfdtkqlT\nLkIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNV2VSjnvUihp6XTQ/GXp4nzyxk6TfcYVOPi2HPUT8awCIHJoEFDL7c/T\nqK/UzSV6m91PiTRAUkTNnAMuK/pXuC8w\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAS3mYw4hp3nMjB/TiGHCedt9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlkNTU2ODctMGFiNy00ZDgxLTg1MmMtNmJlYmViYTJmOGNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQ2OTcxNWEtMTQ1YS00YWE4LTliYWMtMjdlMjRkZTQy\nMTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHY43lloeMcbrjhyNR/cDuFA+\nhlpngOJEquSwmbcRSuHGts3vKnqMwtSp66vy2LILRayjFmr1C+krCyMtuZCLAqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm3c7rz7vBfuzYv4Y8m7XZzcWh0EwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA1mMZ96b4yFx/Q1pKqzqqpwJbsyQB\nF/CRg56JpcbkoKECIDICSpN+RbfQFnKM5PFFAVhxOpe7+wp+FmSgpgd/f+ED\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2407", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2407` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAa52kFAAhXI5igxf+f34MwLQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzYWEyNzM0LWE2ZWMtNGFjMC1hYzVkLWY4ZWI4ZmM5M2Y0ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzcyMzQ3MGUtOGQy\nMS00ZjFhLTlmZWEtY2IzYTA1MGQ1ZjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEobXkO3lcRrC+FeFyBWNTCeDL66i6SticcpgF0jO4uMd8eoG714GWCul7Idzd\neDC9ykTCuTXWJcaXO+ayZs9TsKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoo7IFv5lRswrOCLJr5Ss2TRsSUkwHwYDVR0j\nBBgwFoAUZaUnsHKCmDsmykQRI7Pug7ehMpIwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBUOHi2TvuLXG0UuyGsdKdqUdqtcrpUVQIRizTbhmvijgIgS1V3\nAL+pCDBG8xwbllPNgrPOdSVpV2wb3PHMrtHIKAk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdkMx+ahDyIvKWcWkply9pnnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2FhMjczNC1hNmVjLTRhYzAtYWM1ZC1mOGViOGZjOTNmNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsKenmH0wYlrrfROEwfSpzDrnxpmhm8FS5ZRVOjxhOshOW\nPXYYr+CgaZMbIyhk0LBxOE9oYRqmKPMeHglRaQn8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZaUnsHKCmDsmykQRI7Pug7eh\nMpIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIpGyWebrUYWFENO9DveI35LdJ3SjPfeN8RJfQoVPLRoCIQCtdidKA2pg\nJed5SQ4e1J8lwzRd0jeGzPyCzeFQHH1+XQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAT6jt51kEpfXyoRNP2J3OFUvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzcyMzQ3MGUtOGQyMS00ZjFhLTlmZWEtY2IzYTA1MGQ1ZjNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQzYWZiZmEtZmMxMi00ZjY5LTgwYzYtYzU1N2MxNGEy\nOWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi4MITSfw82SBiKnDZOg+80ww\nWd76nbk/2UxDoDrlHZkfAH7JaNKVx0nP0sDHoXJvRTQdB8BajwB2BJuFccyma6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoo7IFv5lRswrOCLJr5Ss2TRsSUkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA4WJEguxA7uHa4qoY2X3j0sKvH8lB\nc/kdoTp8TRwuDNACIHfsv+G/bIqKBBu/3IfdqJU4xva+3A2UCLWZrb7/n8/m\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2408", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2408` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAe4pDcFvMveRBW8GKa+e0J5lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMDVhMDZhLWU5MDQtNGJmNy05YmJjLWJjNDQ1NDkwNjViNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmMwNWZhY2EtZWY0\nZC00ODM1LWE3N2MtMjRlYjNlNTUwMTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkdJUVXzrNkqYHvZT+xLjyFVv9NfOQX0uGezk1Hr0UhK4ziezEWxXRqQ+hYMR\n0HfpWxeVLTvBR5oSByU8xq1rqaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULbln+RrTrawcaUwihjxjIcPec2gwHwYDVR0j\nBBgwFoAUeMrn1b+GrJmzN9t1cu4U/TdkHRgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA4AcPBjP6Ulqb+mWMK7cL9yT7kaGevFkM\nWeHojNQNNjACIQCAke1rmhFlu0c5yCOEBUHsahpjgNP9ylYmJDW6XmCeKA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaGpNvCeZQPaYYnMuPS2SFAiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTA1YTA2YS1lOTA0LTRiZjctOWJiYy1iYzQ0NTQ5MDY1YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2ATGNMzEF92It4czAF276gWNqPRQAc2Bk1JxqTzs7bt0z\njYbxN9OK8OQ1HBZlavaEhqI8AhYWkcFROJc2sxr9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeMrn1b+GrJmzN9t1cu4U/Tdk\nHRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMC6serTSrDCoYzfUFwQj7Bu9mlafq0+GbRSYm/Yb832AiBFXkb9paGi\n5mJbC8dPurhiUCs4OGQBLy0IoGBJPanKPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbRwqFMmogMcQyyuRKzhWjtVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmMwNWZhY2EtZWY0ZC00ODM1LWE3N2MtMjRlYjNlNTUwMTQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTNkZDYzODYtNWE1OS00NzYwLWIwYWItZTExNDYxY2Fm\nMTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoQnTvi/30cbXxD1Prz8IJvcO\nPYqEC3P10lqCXIjH3te2eq2uQuY2mIxlijR0OQ9cuJQhXU+fiAg0PTOayVuYbKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULbln+RrTrawcaUwihjxjIcPec2gwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiB11DpuRcJuLpurGwPILS1x07bKVEfI\nU3hCDb6gLozjXgIgAdljRYUSCiLmUN1E9/WaOwrSRoooea790kespMkasio=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2409", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2409` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdFi3P88PxYqvZcLraEFlonCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwYjg3ZDcwLWI1ZmEtNDE1OS05NDQzLTU1MmNkOGM0MmYwMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQ5ZjIxZDItMDZk\nNC00MGRkLTkxOGQtODRkYWUwZmI2MzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpi9+dYTuprpVOYKtIhsScqz3qVe/X4hxuSW4bf2xV/LGCsGtnb9s3/tDJuEN\naqSIDaOHoleibhu5xE1su6BhDqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZYfy8Lh7BejzzUzaZCXTMdy3qnowHwYDVR0j\nBBgwFoAUPTK4m6g9wrj5qeBEO4WscFdMgGgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAjfxp+v3K4R/Xs9eFiY2sd8yartNQaz/7\nF/K8l/U0UbwCIEkNu5EQdBp07nwzIXo+OtiWy1MLz+fnxDLX8DwYYzsQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfFCg3TBHhjvoEO3laOPyxhOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGI4N2Q3MC1iNWZhLTQxNTktOTQ0My01NTJjZDhjNDJmMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsn+kOvKIquRpwPYNDXLbHlOa1yy15e9vWyfLVVfJFavXA\nxSqtlbI4VyFx7N4kibHAXPI+Is98dg8YM1k+e4ZWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPTK4m6g9wrj5qeBEO4WscFdM\ngGgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCnAR5kwlKj9aXx5lYhKo6fyuZF4Egmr/Q32686xV1uECIQCEYEUaFxk5\n4KBL1DA0b8fu2S7EjYcxqPOtLZQSkzpqwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAaM9aGQ8yy4lk0Qu9b38YjjjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQ5ZjIxZDItMDZkNC00MGRkLTkxOGQtODRkYWUwZmI2MzI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGJmZDZkZWItMzdjNS00MDExLTgxN2MtNzY0ZjA2ZTAw\nZTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkFuYEWR7jSaXfBg5qY9laTNk\n2HWbjpbfAv+nSwD0Ij3Gn7e6nVXBs4pOqHdiiq0rVW3Jfa+ZrWIZb9XUBJoPvaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZYfy8Lh7BejzzUzaZCXTMdy3qnowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA1PqLp2De65o5F3K40y+WqRtpINSKI\nr5uEhoILyNwFoQIgPnutWcI9t/WsljupP/y6gGeQ0nmYZdSF6bNa3I/bCQA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2410", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2410` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAe8NVG0/ZHywf+KrKxSTuTL0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzZGMwZGVlLWM0NGItNDVhMi1iMjMxLTBkMTQ2MmMwMGYyODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZhN2Q1ZGQtNDY3\nNC00ODIwLTk3YWYtM2EzN2I1MDI4MzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmuMhXUxUxJjOyz+wgldvFptQdcdtvVo2GGmS+x7g0LjbXlL4IPZeccSWWM91\n6j5pclfHXqTtM2tGmiLA0F/ncKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvpSr/6FiTdLSKrS7ZK/UmvIBJEUwHwYDVR0j\nBBgwFoAUrRcq++q8xS+HgrfkK71FuT3gDGAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDIvoBHbCzh5spnpvZcmlAPRaxL\niDa5E0U8zJ3AqHXYWgIgLaz799v6zbR92A+6mxtXL+zX7ngbX6E3RqhgP7qbLUQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAacJXV6yb5bl4/ts0dHWMittMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2RjMGRlZS1jNDRiLTQ1YTItYjIzMS0wZDE0NjJjMDBmMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQv9JMuNJ6tCiIjA9DeTsgJaw1+EfYA7DO+BKhc9/a0z6G9\n6w/SV3B4xeHRzy/raKELC//dzarYYVNngyHuAae+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrRcq++q8xS+HgrfkK71FuT3g\nDGAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBolgEbPvSD4q4qIHz6XaMqnOeRYpBJT/+3j2TFtmc84CIQCFSFjjjkzq\nwnPSp/+3z/aBMwogR/eKO79PM/pW52BoEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQhuuYaUPKpnAiNNRlNQWynwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZhN2Q1ZGQtNDY3NC00ODIwLTk3YWYtM2EzN2I1MDI4MzczMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODZiMGUyYzgtMmJiMy00MWMyLWE3OGMtYjRhMDliMGE1\nNTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtQ7uSfckf1EJCkqI15ZbCKau\np/wzK/oowbbkrytQaJAyYgZLitulojqLX7yXgHR0rHd47tiDJWU+EQXvOVry8aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvpSr/6FiTdLSKrS7ZK/UmvIBJEUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBDUJxXN5oZugDKIsa1ljkv/AXSTEZ1\nKpEbMSARI6a65AIhANNz+qVjLiCDGAPLJiaeVuAgylJ4fOPDkC+4RagOzT4Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2411", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2411` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAZPTeQkvw5V8r0k3lnE5hcfZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhMmE5NWIzLTliYzUtNDkxYi1iZGVmLWUzMDM2MzBhYTdjMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWMyOWM2ODItNTY0\nZC00NzM4LThkMjctNGI1YTU5MmVmZWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqcqN1fMXR6kcAPH9YnQRH7u2cCNSrTyBlZzik7AJ2nsbfHwRSGJ0SOnX/avW\nnkFI1VJtEzjXk4GkkxiyLSyuIaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOXMqofnA8+8X8FE47imKcQWDSEwHwYDVR0j\nBBgwFoAUfXf/zUFERfcoLOCLPP0Gu8OG0SYwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgefZeGm87\nqW2fS84aPWCsNPxqGnvV2k4kH3fZS4sh5eQCICBRWhY5paGNx74BVxrt5UN+Ni2z\nTZYdM6cQFbkjJap/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQgRfQ8J11IlmHJyD3oCVL1NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTJhOTViMy05YmM1LTQ5MWItYmRlZi1lMzAzNjMwYWE3YzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReexhiAH03UR1IwGPTOspki/+IGFm8CLK7rInZ5L8iS/WC\nigkea/I0axqkeVVpG4LzrvSiWJ2uYfakAxoIVO4/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfXf/zUFERfcoLOCLPP0Gu8OG\n0SYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR5JaiQzk7w8MnhGq8ibwhCLLOTUKEgv0Nv9XnpC1eMwCIARIiXy0oBEc\nnfNFCub5LWPRLXERCwGrPRgbJLMsKeO1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAb2OdwRLYNqZUm/Hf6UchzcPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWMyOWM2ODItNTY0ZC00NzM4LThkMjctNGI1YTU5MmVmZWNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2IzMGY3NzktYmMzYi00YTNjLWJlMTgtNDU4M2QyMmRh\nODk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEh2c7pbC8UlmTmRn1364r98A7\nNBP7TpnPMupnO6FvReFaJTGDdyiaO5BLD9TmNOHAT09CfRjfF+p6O6PvQWNvv6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpOXMqofnA8+8X8FE47imKcQWDSEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBMUWnF9OVoDlbuzeEpgkr7uDTUYJzX\nmQlNKlfWOYnPHgIge/ykdmpbLhq93WhG7uKR1PrNtMNaowFzicD5nK+NyPA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2412", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2412` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAYt+Sa85Q0pVa6/k4qyLGLcmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1YjIzMzgxLWM3NDctNGFkYi05OTkxLTMyNGQ3NjdiOTViZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFjYjMxYWYtMzQ0\nNC00NWU2LWFmNmYtNmZhMmVmMGEwZDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYdOp5xNGFfjTei0R/fwE4XaVbriZW0ulZCX41dHywkq7aE1vCBtVwlGNwp9G\naDhsfWl83phN4LSthl4q861zrqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyZACOk2sqPT1c5fr8hW4sJ5WolgwHwYDVR0j\nBBgwFoAUaWF/OqLHmtBfhp6RaV/j4gKlxsYwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANu/pN04\ny9fGic+46oZlkoJp7XS6OMFjAzSEPAuZY05eAiEAwbtCqGWY5ZyQ4Tm5dbkH0IEV\nsgW3VLy4TCHLmAT6BDQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdxhCkRAxZKbKz8V76MgDoe4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNWIyMzM4MS1jNzQ3LTRhZGItOTk5MS0zMjRkNzY3Yjk1YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQu4oBUz569Gqyo1pV5EGfg/Ob1+mpmhWx6eG3nzO7las22\na8iWmuyKx+B6OPhYt4zaClgsWrL5/AqCemXDHQA2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaWF/OqLHmtBfhp6RaV/j4gKl\nxsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANLzcCeZpxMfggXrfqCOG96fewhf9lRdyvZ5xt55ZI1zAiEAwcrFPRx1\nDM0dvOAZvUhKheauSzyDwQyOz18M186G/zM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATMIbKU8PBjJHlauVesBfwFHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFjYjMxYWYtMzQ0NC00NWU2LWFmNmYtNmZhMmVmMGEwZDBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTBhMWEwZDAtOTk3OC00ODYwLWI2NDItOGI5YzZkNjIz\nYjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjbHaW4aG221Oh3Tb4lbW8w0T\nI1gMfp1yWGMbaztsc232psnm/IjB+8QSOx7ra7E7IEkr0giOZgY/Q31UQ3uoVaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyZACOk2sqPT1c5fr8hW4sJ5WolgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAkP0bRzhLlWmKwKpZYAg3zaOWtKNu\n3w8F1Vck0Vwav8gCIF83AGehzZ347dUbEcpAlTZ/jSQPSdO4djyWbbWrRcJa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2413", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2413` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAWO8dIJ+KRkRhxngJu/EVg+cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxM2Y0OTkwLTYzYjMtNDkyYS1hZTdmLWFiMGQwZTQ0YzljNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTM2ZDdkNjEtZDg3\nMC00M2IxLTk3ZjUtZTg2M2FmMWRmMzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErvY5VrHJWcqa7mzINTXRd95xiCKRXkf5CUmKxMZJ6AxUcMX5NOJ236lGo0T2\n0ImOHIcyOxyqEQLGeXLLQtKKcKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUToZIeN5n0Qw7sp4IfPVYT6LpgZkwHwYDVR0j\nBBgwFoAUhv5Lt4HqL1vlXNiOW57+99Oz9ywwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDmsPZy+\ngliNTDGrOJb06+W5lbNoNGpzq++iigtZBjOaAiASGgfkpZC8cdRSzX9UkVDVLyEE\nLpaHsQsZ3PHCcUFyLw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATczPCQutNSWQ/CfGmCgtxLEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTNmNDk5MC02M2IzLTQ5MmEtYWU3Zi1hYjBkMGU0NGM5YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6V+B6hzBShsJvTfy0z1I8iRmFQoJzVhyGddXHt5umDPvQ\ni5rOYGIqSPjEPrzvqMGIkHbrJTql+ZA8bZIeoUhho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhv5Lt4HqL1vlXNiOW57+99Oz\n9ywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTxFQmIXn7iXn7JhiGoo9knY56KKZQeOr0rom0476s60CIQDTCrikzICZ\nV+ZgLFJcOGatzOfBzL4O8VnI7KyqpeUl0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQKoPltxZBuDGij0fmBI6h1gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTM2ZDdkNjEtZDg3MC00M2IxLTk3ZjUtZTg2M2FmMWRmMzdjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODBmOGNhNTAtOThhMC00ZmQ2LTljOTYtNjllYzIwYzYz\nYjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZl0cm77cG2VYvdw503jFb40K\nYz0+Xuk3yhxEtA7gItnxFfBV2Lui7BOsh8KqYDAIpdGzkhrfThC5Ifld4ZXR3aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUToZIeN5n0Qw7sp4IfPVYT6LpgZkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAiUkapDxlOHeqfk9gooyJAOT963N3\ns+8mxTiK1PQ1WAACIAvEpiv3XXgInZD70Yp0fzB3zMxmnjxVrvAKIW8DOv8F\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2414", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2414` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAXW9TnKZvDYsENzuklvineLTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0NWY2MDRhLWEyYmItNDI5Yy1hZjg4LTg4OTliYmFkZWUzNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzllY2Q4NGQtMjEw\nMC00NGM4LWExOWEtN2ZmMWNkOGFhYTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvmRO8ZGXPjT87mh1dkbGDxNwD70HVqSnlpkYgV7E3bI9ylRTtPF8E++Ve4TM\nwE4J9yox4MZLg/kZJlXtVGZIAaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULm4hWAzHYC+p2gbG0+AiwMOq73gwHwYDVR0j\nBBgwFoAUzV5RV1ozrV2qAZ5T8wWTAFHhOEowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIGSp52MsMzOvzgzkuG/JRwKi6TvDZH40AykAHmXrIjvHAiAUeuOYfb0z\nQYzZGr4xlmbTBc+fc9XHvmXWSAcSRIvFFw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXe1axk1K8K6e5meB3b/DPT2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDVmNjA0YS1hMmJiLTQyOWMtYWY4OC04ODk5YmJhZGVlMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2LTwCd1UkddaBk8d3lDsFupjxsEpqbY9IE9VCIQzaKcKs\nJ55An5674iyQ374Op30Ekwle5GGesWFne+C+165to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzV5RV1ozrV2qAZ5T8wWTAFHh\nOEowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSWkaGVW8tRSwyeWtJ/xw/yBHsyKP6Qe+O3UlLRMYEZQCICMGOIQVJYTI\nTmGB4Ls2wWKfQqbWKlqf/l/GLxnZzWR4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAebg20CL3mVwIFFKwCqxeRZXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzllY2Q4NGQtMjEwMC00NGM4LWExOWEtN2ZmMWNkOGFhYTQ2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGYyMTE2ZWItNjU4YS00NDlmLTg0NzktZDIyY2U2YmM0\nNjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiJZgW0LnQ4ny9OUyTG/RIU5q\n4Wva4GlL8dhrghpgpHcBv4tWaWC84+fkWSRfjt2ywsbT9xswFQyzE2IfzqvPTaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULm4hWAzHYC+p2gbG0+AiwMOq73gwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAlRoRBD9PPTfXkJzxB//xNj5o+cU1\ncTZ/p97iRisNwMgCIFUThRdgrbvv0mPj3swh7mlcbl9P31WeSNLZEVeH3wbb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2415", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2415` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAR9QmTSLzUlH4dtmT3fwxBHcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZTg0NDc0LTdiY2MtNGU5Yy1iODg4LWZjYmM2NTllMWJiMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ0ZTEyMmEtZmZh\nMi00ZjNkLWFlNmYtZmU5ZGM0OTU2ODZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpE2P2MhKx4xIqtu8pAhyd6FX/3V5PKVFKWYZZHf7+euidNOujFYNVcf15bfr\nszpUZLE4VMPEomsN7W3q705TAqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUruVq+4tcT8uvjgmbUHIPX0lctlkwHwYDVR0j\nBBgwFoAUKB4tEflOYSfMsRu1wfsxpCpA8R8wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIA77xuDnXDZq0vYR/0kabAMVubxTElGCnKxO/r2ZGbUiAiEAzAAcoQf8\n2cTk5duKYNahZbn4niYMaZj1j+O7aDSYSOM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATzEbSDiIXjgXdOIWwD2Kn+tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWU4NDQ3NC03YmNjLTRlOWMtYjg4OC1mY2JjNjU5ZTFiYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXE7/fXM34qPJBEPfFdtKW/lJZh52TZFFlpDclSoTLbjdH\nuyOPZpVUzE4zxw4p7rRGYTSD6NJqxkiIhjrKGIgMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKB4tEflOYSfMsRu1wfsxpCpA\n8R8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAiVj7+TJrEGt4LOHQRI5Xo5sWv0wj72GVNSBcw9cwEkCIQDh2GhpLf//\nu3DekGMFcDyT9kqSNL8uVywedkzO4RCy7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARVeZcIKbUjMkC06sk0oRdaCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ0ZTEyMmEtZmZhMi00ZjNkLWFlNmYtZmU5ZGM0OTU2ODZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTE0NDUyZjUtMWM4Ny00NWUxLWI3MTctNzExN2FhOTY5\nOTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG+U3elXsZGRUnt5a6BuPqZc9\ngM1Z+Bo/h/fNIftv1gq8qSU/COetFvy4R+bGtiDxDsxqT+KG/BydimYfUH6teqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUruVq+4tcT8uvjgmbUHIPX0lctlkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAq1BwAL1Ol3ArjXFAhlGRpRiKBDifB\nV7hr+ORHXUprSAIgaz/MRy29gl2VpwU3Svu1BQR0WNECOzJBE/Qsxk0vfXs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2416", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2416` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAfEhVzueqqDBgGwr/MrhfpTaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3ZDc4ZmNhLTVmNjMtNDcxYi1hNzUyLTEzYWFlZWI2ZjcwNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI1YjE3ODMtNTFh\nMy00ZTI4LTg0YmItM2E4NGYyZmRhZGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEewqOMHoqjKqndua2NqixiJl2thZqic+8q3WgVGBnjxdgcB6v9WFWHkNB2SsC\nUTLnfbbMQOSRD+nj42spx1Q/d6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5eVRfssn8V6CJ42s/6pQPAyk0S0wHwYDVR0j\nBBgwFoAUvcJTydRsZWcpMGcKg5Re98R5qRQwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQCMuEWfxp5REj1aGDvaLTZR7OrO5TDAQEm5enLqZhNxQwIgcEasThzlVYZQv3DR\nJK22IUVseLPg66syd6BprKbSr8s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb8rV7zXBou/49pvt4uxwyvQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2Q3OGZjYS01ZjYzLTQ3MWItYTc1Mi0xM2FhZWViNmY3MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPIpATtfQBWI9FCUQFfIvhFVx5T/hIsh1J84vFz8D7H5ac\nxt5MmaZVFBX2QF5xxyanbmG7mLy9E5vcAFyZPGNEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvcJTydRsZWcpMGcKg5Re98R5\nqRQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI297zGN4k8fGIQk3hIg+arSiFMbcWUjzQOiEVUmXdukCID8POCsHitjI\nRQ40rmyThIHE/soGRYdeX2UyFztWVaPY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeHvaiA+n19Y4lZBuM5J0b0+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI1YjE3ODMtNTFhMy00ZTI4LTg0YmItM2E4NGYyZmRhZGI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTlkOTk2NjMtNDM4Ni00YjA4LWExNDctODlhYTI0YTA2\nNjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIbz1KIQcQHIB+IOT+swMi3wE\nqB4fDC7W+bx6gXPcDZatKhhE6BPp5zZhYwJax8pMIRXwLREsY8NT03/S4J/o6KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5eVRfssn8V6CJ42s/6pQPAyk0S0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAtFcsUrSC7wx+8aoV7ub8bhp5qPCt\nYV3eqrz2mARdFG0CIHcFDD1BoewYUSJhT6G+EwZaitWCA2RqLf1y4uSy358v\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2417", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2417` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAagzp+wPBsjlZHPwgoESMq/oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmZTRmMDBjLTY3MzMtNDJlZS05OGZjLWRhOWJkM2RiMTYzMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY2MTYxMDQtM2Uw\nYS00ZTEzLWFjYTEtNDZmN2UzMTIzZmJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsNVDkjbuceWvYtHRMeeeWbjRTz2b9JUDIrrGUlJhvcZ+qqkTTnxkTzm6yAPh\npzT3g82ldKCA4Hcizy+6BC+hJ6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb/x4fvRJuvwaPpbalUdHAY9mmWAwHwYDVR0j\nBBgwFoAUfaWL5jtf2xSoJwtg57tLgcPlNr8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIFBn8GUAsa6MLxAgoFwqKdNVFNvuC1Jp8kEUnFA+oMH6AiAp\nJvbfwjC8U0p0/zpWVSsOSl+WNTCcsTwLp6Kl8x2nKw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe2/TZF31sFZ3LtzmxveRWRRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZmU0ZjAwYy02NzMzLTQyZWUtOThmYy1kYTliZDNkYjE2MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnvBdO+j2fmPRB6bjm3IIc0QiatFwlJv2cBvTowN79+AjQ\ntHv7tbmndQIgJZNTZaYftkBT9dMuxb3Xv6UsuXLho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfaWL5jtf2xSoJwtg57tLgcPl\nNr8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN9IUH40G1weDrrABefbxEUq9/gwr65fQ21Ya+J97KJOAiB77xWlneit\nlIvjgCAuXB0v+x3e4N5yiVmUdqUYQgLu0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWRWLaFikdQ08zOCPdJOCXVXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY2MTYxMDQtM2UwYS00ZTEzLWFjYTEtNDZmN2UzMTIzZmJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDhhYmVkZmYtNTFjNi00MTRlLWE0ODYtNDc1NzgwYzFm\nMDI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEI39Jhus6jYihN7k/6+Ic8AZt\nmfHo0NjLe256zADCkxj3es6ggAkuZLufi+gxaNKdeGgtUt7bJRFgU4m2y70QzqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUb/x4fvRJuvwaPpbalUdHAY9mmWAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBU/iBpZ71IpECe6wCUYGHyfXrsyMvz\nljJMgKxjrLszOAIgXSdErUi8+cTArovaFM7uwkutr0/LKz3Wf7DetgLvI08=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2418", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2418` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVeyrP6OYwyhtfbOooOCjImCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1MDU2YmY1LTkxMTQtNGNkMi04YTI5LWYzYjBmZmE2YjgwNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIxODkxZjEtNjIx\nNS00NzY1LWI0NmUtOTJmMjk0Mzg0MGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExwyX+GSXBLfTRhajtTZShR9vA+I9UF2fLSY5DaVQCzqdYXN0iDJPdPyBHirx\nYNHtdgXgmYsOQaVaYFcL/sUepqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg6QmyE2g2t8VH2tD17BLGN9vg10wHwYDVR0j\nBBgwFoAUKP+uisDq62HW85JXt4I2Rs43wKkwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDedVoMFO4d64E6KG9pCOv+1c/iOe9TC+wxqGP3lAV3yAIg\nUgC8IXR5j+X0hJTTGSYhdsudXmeL03+8hFM/i1+V0GY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVgk0PsAgQrWyArIKw5Bfs/UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTA1NmJmNS05MTE0LTRjZDItOGEyOS1mM2IwZmZhNmI4MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+852Qb4P5qAu7CN3TU4XFK6oNGVrIQmRuceOb2UQpUJ74\nS87JD8VO5Xq5ajkBZ1Z+1diieRa7uQntjzjU0/+ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKP+uisDq62HW85JXt4I2Rs43\nwKkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYd6m3Sawuu8Gg1VCAhd3XDKmAwPBOEs0BRxAE5S+du8CIHOVDR8ub7NE\nGzVuJAF+/Zemp7ccZ3/JwNrWtPcyoz0H\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQUVnfbWfuLmDiRenbcwVLXCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIxODkxZjEtNjIxNS00NzY1LWI0NmUtOTJmMjk0Mzg0MGFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2U2NWM0MmYtMDk4Zi00OGQ2LWFlMzgtNzg3NDdiYzY1\nMmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa88KsuxFMkZk3Nvhb9HUnfVs\n+Rw5XYjSY8khYU1YDL2Hki2aYKwxP3SzRxoZXJ0ftuEFi+dZj10+nLRNTUxk46Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUg6QmyE2g2t8VH2tD17BLGN9vg10wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiADh9/1zMcz2m9lsRbcIxNJoyOTvJUp\nx8r7VELvH9NZkQIhAI0peHmFbnwuJ/0hkR8NfNiXdp4uXM4cFnHDRO/9hvuc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2419", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2419` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAaz8DNyMFVx9nmT8B10oHDQmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0NzM5ZmY5LTA1ZDAtNDJiMi05MGI0LTY2MDRlNjBkNzdlODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk3ZTg2MWMtZjli\nMy00MDE1LWI0YjMtNTRlMzhkYjU5ZDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb5JG2vN6EWwKZIF9FKa0eEfW0BNj2kApO+PnG3ekXbUu/QnHbO4tZWE0c+ud\nAiqTXAbi8q2ffvU7FtP86jicmKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyQkvS9LmVVOhjLEaPf1l3F+hNBgwHwYDVR0j\nBBgwFoAUbGv7RGA4Br9Roh0UewvzbS/Q4/0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCtCcVphtaa\n5VPOJPKa7TLNbtdKZ7QwYX9LfNQjpz8qrwIgXjFVWnDiBLzAl3thy1SSLcQOffB6\nDLV+ceP2EkNZJIk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASzfiq8FmHOxMWC3OhWeEcs/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDczOWZmOS0wNWQwLTQyYjItOTBiNC02NjA0ZTYwZDc3ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASI+Peg0uRI3s5HKeYD1VXtFrBOQe2cNjoYBXv4wSB9zeon\nvDWkUA9iNIZYWCK+U/NxlH2+VE7nqHSAD2L+nZMyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbGv7RGA4Br9Roh0UewvzbS/Q\n4/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCtecNG9j/JnfFhOAwCVpXPW2sbzAzf1w/qFyddXb0W4CICHosDz94PPZ\n392jAIUH4Pdkwvr1dbxMn7Ijewn68oXi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZsykrBz47NLip/8XVXxHLvxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk3ZTg2MWMtZjliMy00MDE1LWI0YjMtNTRlMzhkYjU5ZDc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjhhYTUwMDQtY2I3YS00MjljLTgxNjktYjBmYjEzZjVl\nZGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExID3MqVJwduLQKMWXpD12H/F\nWG3HbqrTP+DtlQjkw6glwfce39Pjz0nJ4ignR+GitSLLbPrEpXp+fJK15VCCwqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyQkvS9LmVVOhjLEaPf1l3F+hNBgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAy6NLf/Vm1RhPRPmtl/bshvuFHPbY\nj21nJ5/UV8QtfA0CIQCAJ7QjzZVlXuaF6MHJoFk4msTmmhcy83O6mDtwlAZurg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2420", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2420` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXBNdGTSmhRvio6EJ0XjEHZVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2YTZkNDI4LTk0YmItNDcxOC1hZDZmLTdiZWEyYWJiZjkzMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVkMTcyOWUtYWNi\nNC00NDRkLThhZTEtMmJjNDk2ZWU1M2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIqLfhY4oVlOJoYHxc27RRiJFSxqWewDKMtK1dKSxCv1sKVh/jqf6sEqrHNWZ\nFgB6kDbzDD+2omZjQoeI/cDOnKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZB/P5GbZMKMDrSTGqbPVtBDTLvowHwYDVR0j\nBBgwFoAUwOA4aGR+yVVBvNDRU5q6UiEa/UMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANWunYky+pheXntMTStrQFhttmaywsILzdWCSUu8hMMBAiBYoOKa6mxu\ndzPRvJNCF35qVxjf9BTGw7TAnz+Ahn+Tfw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbeIGLyjRsTPIt8KwMpa/NtnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmE2ZDQyOC05NGJiLTQ3MTgtYWQ2Zi03YmVhMmFiYmY5MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnVXrZ6FS+MV+YnWVVFbRKs01YIsUdL8uz3nOwm6R0AZqq\n8/S/XH2q+ezew5sIyMREO2gyH/+6z6JJfnNBC8kYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwOA4aGR+yVVBvNDRU5q6UiEa\n/UMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPcAuBtX0sXYGHooo2k93iCayfSPZOZDZKWw48DHCOwrAiBbYgR81RI+\nKL/wVqDNn1qDUsAr+nJCMrcCUqO3osEaSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARh/BzGF/OR8kyGV16z1+6LjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVkMTcyOWUtYWNiNC00NDRkLThhZTEtMmJjNDk2ZWU1M2Y5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWFjNDgzN2UtMzA4OS00NjVhLWFiNjItODUwZWM2Nzgw\nN2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmOb8z8ZhmwTmqvsiVNVmA1CE\nBHhvzTgitjktz17OiXlRzyerjJzZa6nTdkb1Rno6ifYRVgCQXavFNJedVzC9baNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZB/P5GbZMKMDrSTGqbPVtBDTLvowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAr9FrsOtxBNwRzT3SJhOM1J17STK0\nUOVlMoxd6FnSL6kCIQD5Y3N5mHkzqRkxlszUZ9OTrHN2PYcbwZz/4YNkveqYzg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2421", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2421` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZuWZc900OqhAfohOHXs+p01MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4MDU0ODQ1LTVkODAtNDQwNi1hOWU1LTI2MzVmMzYyYTcwOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJiMTRkNjEtN2Rk\nNS00MjM3LWExYjEtMzNkZmQwYTNiN2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEndfvgfoKsMFSQStQS0UuVX5yiNHWULk2WxHWGoXm6LFBvnv9qQPr3Y76cJJu\nNqP9kWkG/Wb3p31Gro0ThdJvbKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG9bbAlaJLL9Y6gnjXX0/b/SJAHwwHwYDVR0j\nBBgwFoAUnhaciaM6mBd5/tkp/y3cx2pySo0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAPZLy1LXOXfXemUVDc9P1MgsWRnVLXLNDsKOwqz26uAtAiAq5r2tXZf9\npzgeqISvZqpEtQ/fP+1jom/grx8P+vD+1A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb+1/FtVsS0G16347VM9LokPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODA1NDg0NS01ZDgwLTQ0MDYtYTllNS0yNjM1ZjM2MmE3MDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARd9CmLEwdCJEVcxKfoYNsp+YAR8FWDJ0kRZma5zfEhT9Is\nEdvL2WKG83e2KMG/agT2nkLb4Yga2FUjVxvMsiiVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnhaciaM6mBd5/tkp/y3cx2py\nSo0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSVGhiGasDOEctW3W6ltjco3wlEes6hqdIuysDOCXVuECIQDx2h2PMe6H\nS7ENqIFwQtWFC806Hjl0wwlsoYQO4FG8qA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYtmDwrYIK6XCpc5WFvMDtYPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJiMTRkNjEtN2RkNS00MjM3LWExYjEtMzNkZmQwYTNiN2I3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTdhYzE2MWYtZDI1ZS00ZTcwLTgxMTUtNTJmNWNiMDMw\nZTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwwmyyuprHoJGOT+S7iX6/3to\nTA9b2vQh0ASiiVaiBuRT6RoPPZoEHZ4IsP+LG04wJQntlPGBqQz8iNfG26sUzKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUG9bbAlaJLL9Y6gnjXX0/b/SJAHwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAlVdeNHwIK73mYsbweig1hRx8wnkT\ns5qi4VwLjjfReA0CIBKHTTEu+4yTvYZsrnMzXKJdjhSzf/JAn8FQLp2afft/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2422", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2422` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAXXvykQYJOCmhahVE32FqGkaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMGEwYTY4LWViY2MtNDhhNi1hZWEzLWEzN2RhN2Q4NDNlNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA3OWIzMDMtNDQ4\nYi00YjI1LTgzMWMtOGI5YjJkZTliODg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+NTIl3XjnVK+AneB32nqp+/eCdlYQaZW1Na/uD4S5/ykIrkrx/SFAPsY17nN\nK5tbbxvaEIBDDWygM787Sl3aZKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHlmDz1/T6vu2AOPCSFzyWtlBRFUwHwYDVR0j\nBBgwFoAUlRvetSbG6VNKx105vEfBo50+n6wwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQD4hvhBfBrG2tq5cM1DDGRSZp0sGR3H0azfvzPPJ/2B+AIhAKa/o6Jm\niii0EyIpdIBllENfdw50VwtaLv8PGeC6uRgF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXPdSl8V1Z21alkLYSF+POMkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTBhMGE2OC1lYmNjLTQ4YTYtYWVhMy1hMzdkYTdkODQzZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqJAfXgsuwlbHdlGq4KNLNvFDBQkMS//vw0uQxTzwXRRE8\nJJbWg2ZaFuWJHGuiZ75LBX3sAGFtjxdp6ePE9t9yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlRvetSbG6VNKx105vEfBo50+\nn6wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaIOPsSZl2c5nFnKcZ+I94tFvw/4Y6yfjU4suypfH2eECIGLrfrV16jAT\ntje+wmICd6nnRmNVDtLfO9u2HVfkwZ9p\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAX7M909WHRkLtVrmoyFUwpxCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA3OWIzMDMtNDQ4Yi00YjI1LTgzMWMtOGI5YjJkZTliODg5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTIyMmI3NGYtYzU4Zi00MjJmLTgwNDctZjk5NGY1NTIx\nOTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQAgs26Y6VO44LumIqj4kFSU6\n7PGUt59jwYu09gEH10sygCRxHBUtxkb2XG4YN5aCKggTlVbGEkdAY28lKd7c1KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHlmDz1/T6vu2AOPCSFzyWtlBRFUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAqs0hoziMwh1uMfi3TKWFZZOFCIAPo\nWljWiNv5Lx1ZgwIhAPDTGdc69XHMf2QcF0zOIZrGX+5KMiwjrE36JiCftxWZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2423", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2423` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAcZaktb1zgR4e7xzgVNnkgoVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1YWZmOWJhLTY4NzEtNDVmMi1iNzRiLTY4M2M0NmM4MjljNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTEzYjMxMDUtMjYx\nMS00OWZlLTg4ZTUtMGNhMzAzNWZjNmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb50ijFvttiussCNpDlPeRbn6W1jTJbSQ2yz4UzUQCaOd8tfIL2hvSZWXTNx0\nXz0ZOdRXHNOeYJmBXPyZfIDCXaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh6+PzTq2FCEpfvEqsW32rKg8rbgwHwYDVR0j\nBBgwFoAUIFZj7Q2ERmwE8boComVkx9XRfbYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCRnXGOKxjqHzEDMJXegrX77zp7sdMsGby5Z0Qv\nGWMA0gIgcbghEDI4KAwpHP5DsWssvMv/MnC9i/a6/DGizchZbKE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARxT5NrVSW/Kch3wLeNZYtWOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWFmZjliYS02ODcxLTQ1ZjItYjc0Yi02ODNjNDZjODI5YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQ1l5Dk0ZA+8jz0J6yOwIBU8quG0nivvI3kfnmRGLI0tB3\nqfpszyBUvEzXIKhAHenWBi7F8qnAX/Kbq+FMpIJxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIFZj7Q2ERmwE8boComVkx9XR\nfbYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK1LNC32kkz+jfWy/851d1ZEUPnY+IzJa7NGHeJAikgOAiEAsfYpFldU\nAJ497xpE64SPdfGUfSqhF2kTagq4jdzcQ7o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUjynDthWMYI6nk7nXePUKvNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTEzYjMxMDUtMjYxMS00OWZlLTg4ZTUtMGNhMzAzNWZjNmZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzYzOGUyMzEtOThlMS00MDAzLWI2YjQtM2Q0N2FmN2I1\nMzgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUTPKO6Z/Go0RUcpBQkstnfg2\nnLh20u5DSfimBZIwL6j9nD4ReeKkTlYF+ARIuLegbla49IUHteLP9D8G6pWjMKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh6+PzTq2FCEpfvEqsW32rKg8rbgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAvWFV9TruYUYmw9wwL67Q5bAi29T9\nDeIGwtJT34snLR8CIBDounXGiq8g15Y70k2eXC193cUN2R0SFrH/Ni4aev10\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2424", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2424` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISARQh+TEuuQnubuGHnBc5K++yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4Y2ZjMWI3LTBmMjgtNDMzMC04YmE3LWRkMTMwNzI0Nzg5NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDliYTczNTgtMTU3\nNy00NDM0LWI4OTQtZDI0MGE3M2JlNjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ4yMt4ul4V2SNV5TMRgUmQCfF3auUymge6Om+Za1PNthJq7aMJ3kUnRp46Yb\nFZBgybpArq2NPVDZMF+OupzsGKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUclifzbswc0Hol0g+yXQ8x0+Fo+IwHwYDVR0j\nBBgwFoAUlOkpZkrwqxCq6JlddvUTi7YW5mowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIDQsvB4l9hDW8q0dwJt0AxlD0tIFzZfGqsWyjGoe\nsh/lAiBmlFpxj4Mcqefy4AliTIXmHFlcoY4sLNjF43ailzLhSQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAet15VG/m+TuNAbSwjhl5bAFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGNmYzFiNy0wZjI4LTQzMzAtOGJhNy1kZDEzMDcyNDc4OTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASexJOngE732n18AfXda3Ec01txhEnQ1e19jDNmeye1PUoq\nJC6z9ePlfCBddSt7GIFt2MlYPh0UVypcKnqlK0kBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlOkpZkrwqxCq6JlddvUTi7YW\n5mowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI3QDyxlWdy2wrWluVJwNSfjV7PpSlE+AC3AN0TDY57nAiBLiqF1y1Ll\nr17QMtT2nt1bAVzQBFNets1WP5Swwn2haA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAduMPEwtR7WcRRkwl4ee8qahMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDliYTczNTgtMTU3Ny00NDM0LWI4OTQtZDI0MGE3M2JlNjhmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjE0Y2YwMzctMzQ3YS00MGJkLTkyMGMtMTczZTk0YjY2\nYjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYR5fV0Z80sXJOs8/aeV7rB9v\nIMZf9HDkFJJk2Wxz60I0y9u9QWt01MjS5k8aSuQr53gOlI8H6yzeIgoNphjoEKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUclifzbswc0Hol0g+yXQ8x0+Fo+IwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEArrGWxh3v1V3mTNo/ujgC8PmG//aa\nAEcM3/CXky+KSpUCIEZFesFOM6QTcl+Cm73iNE7dhfdfj2/lq/kY4FMh24a9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2425", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2425` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAQ8C5KjilxzfY7K25MbLdZG/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0YzBmM2JkLTNkZTEtNDljYy1hYTI0LTU5YTdiZThlYTE4YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAxYzZiMjctMWFk\nMC00MTBiLWE3OTgtNzZlN2Q0MjUzYjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5xFkm6s6qBdJcqggpA6PqFyyvTxY1CKSzCVxf8MgXtlPw+5T9o5sTGYLScoW\nEE5KkOPOuFpfAoT8FJmZWq05Y6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQA9Eifo25K3wnBp/qr9t0jhDClEwHwYDVR0j\nBBgwFoAUwd76Es7TaQ1+pNLzpDrxVn3vukEwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIBh/sYMbddCcBg7a0hqJcM76PnBCVXy9U1Ro1rMySZd1AiAQ\nt7XcbC8psFHY9iBaPNVwQGf3JVKqiDQnFCwb8xEwxw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU8teRD7Rr0hE9QrGS0qYiWwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGMwZjNiZC0zZGUxLTQ5Y2MtYWEyNC01OWE3YmU4ZWExOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/11Y82RSwWI0fTOlKfvdcNSOcX/vTAzWLLy9g039ESzEu\njrAT7wq8DQb/ZpB8n34P4FiNgOSDFwmRBQ6aB8kJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwd76Es7TaQ1+pNLzpDrxVn3v\nukEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTGTgraMy4VON4STjwRsVHyMisama8xs+3S6xeGgQX1ECIQDuilliLT29\nWIzJ37B/R8qhpJ5F7M0uUZdW+WTKow0ZQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARqXxHVaXklBAbSqzt2WqmvEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAxYzZiMjctMWFkMC00MTBiLWE3OTgtNzZlN2Q0MjUzYjc3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmQxMzczZjItYjMwZi00NTFlLWJiZWItMGYxOWU3NjE4\nNDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVoUXLsN1AXuy5HoRGAfwVFWS\nEMeR16EwxH3VYT7wiVJ1tnzCXs13AbiS3QKgrJgkVv9Bd1kszJpgcy2xFB/skaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQA9Eifo25K3wnBp/qr9t0jhDClEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEApE/fWl8BtAe9fZFu4YrhsiXkNqC6\nZmLIuwu9rZxYtg0CICLchVfSi1ECNnzVqVQFxIOw8vOnGTxtlgKczdy2SkLt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2426", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2426` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAYyjka6hfNT8tETJ0lqTc2LMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2NzYxYzhlLWNjMmMtNDZhNy1iMTFiLWRiNjA4MmFlMTZiODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNhZTFmMDYtY2Rl\nOS00NjQ4LWIyYzUtMTg1Mjk2MjRiODEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbYmkAR3zpihmpv5pUlaAuLVprEKvOqxsCK3qghQ3RWGUPFxu4cENHgv2+pFm\nHGfA/Vi6hXHw1GqO0Whq0ePpuKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrrU4xdNOiii763oMECxCs3g69jswHwYDVR0j\nBBgwFoAUFn3GESikMaO1O0YZY3X9tciV8dkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCMOahSl/u68KlqHJ/t81DAko1baTzY\ncYYQxowzXs1sXQIhAOpkxU2MwseESFdSN8hMN+c/4K5lqQG/Mh5NzlxiHPiD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYa/A+h5r9DEKMSpL/Odj5XzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjc2MWM4ZS1jYzJjLTQ2YTctYjExYi1kYjYwODJhZTE2YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATr2ZxiDpIZKRBLOdygtiSWvDRT1PQNQRCwugjO9qE+dscm\n6pvXXZN3xRR9z0SEvNrmNQGaIV9CENfx6V8uOC2Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFn3GESikMaO1O0YZY3X9tciV\n8dkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOuyALJDYc7INRY6VAf8UVXQUC+h2bceNINoDefLtHfeAiBir0Z8L458\n5G//PzAT9R7y3etKesx59/0GzwFd2Dq2HA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAX6T6US8LzzlgKPAOVNDuLs3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNhZTFmMDYtY2RlOS00NjQ4LWIyYzUtMTg1Mjk2MjRiODEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjVmMjk2NTQtYjdiMy00MThhLThlNTYtMzYzYmUyZTZh\nNTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE87rRiwnE/v+mBSnpG4g/JTN/\nM+jOurAyTq5LBZaRTlmkAvyIDBy6w84KJ4z1gJl8Y9kU3XpyKTc8aD9W9cRrE6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrrU4xdNOiii763oMECxCs3g69jswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBbLWtnMe8N5QNzHoqXv1cIEJH9J5Hz\n9PL5QuYBxaPu5wIhAKdyrXDIkOlqf6cX5p48v8R3PWlx+4CG8u8Cb2t9ni72\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2427", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2427` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAcXC3F+8rqLaeHw6tqkbLhroMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4M2MzMGEzLWJiZWUtNDU5Yi1hMWQzLTc4YzhkZWYzYzU4YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGY3MTQzN2UtMzNm\nMS00YTFiLTk4NWEtOTVkNjEwNjBmYjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbGocYRaphzcIoNqk/nKfk/dB5Q9gKW2NgHQMYjDPgu5XxoiOvIX9B0YBCv7M\nQmrlrimbszmtNzq0j5OZb3n4vaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL3AqBSgCGAGrgCgV0ZYXSTMIDqEwHwYDVR0j\nBBgwFoAUyEIGi4+d+lVXGYORSGSdVj75i2MwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCqeIaH9M2xUYCTXyN+nujbpK5HajTW\n5ughh3VOZngn0gIhAOKqrLDRzz3ms9d4mlijC/MuypRDrohjVzR+lkcqvQ17\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe89teLvixjxbda6qrl7OsH/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODNjMzBhMy1iYmVlLTQ1OWItYTFkMy03OGM4ZGVmM2M1OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpTUAu5xzt5DeX25BPjDPmVOLkkiNLj4DXTabBt0LTmiE0\n7Fd9RwURlc/egVk1gh6vLbzVyGVCPq/SP9CamkV1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyEIGi4+d+lVXGYORSGSdVj75\ni2MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ93DxlCdowUSw71kmaubmnW0+z6AwwmLxaTpGOh4OGcCIQDlPHmQE2bi\nQbJVaO6I+KwwZv7QmGer2K2OJeEB2maPyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQT4ft6wDjLgE/irrt0RpyJEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGY3MTQzN2UtMzNmMS00YTFiLTk4NWEtOTVkNjEwNjBmYjI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ1MjI0NWEtOTUzNC00NTY1LTlhNWMtYjQ4NWUyMDNl\nNDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwewDGahgIxk5AGaXpDVx0426\ntagD1XWddUTOhqtRezfoO6T/PqHk3IoGTjOULgOpZ2jrHE4Q9HNMAS0WiV4e5qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUL3AqBSgCGAGrgCgV0ZYXSTMIDqEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBwtyoSRUa/OIm0kY11TtfNFvIGsmMR\ni/pd6cvWM4oLkgIgTaFsAEt985wbDzufs6mVTttO/4P6T+oWfTvbPcGV9vs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2428", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2428` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAV8eMgi3J5svk5aopLBkjjXoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2ODQwMWI3LWYxNzMtNDBlNC1iNGNlLTIxZGJhZTk1NjRmZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY0MTk5ZTQtMmI1\nYi00YWNhLTk2NDEtNWY2MWNmMGExNGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcxGT4z1u2ShPymM1hQKsvnxKInWY6fUs+FXKdeD7VbVyuWM9ALFIodCqgaIh\nPmrqYX1duyv6ajfL9A3ChQmEuaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYJBdFW5n0KrcP/essiK2qKgMBBwwHwYDVR0j\nBBgwFoAUglBUAug4YTq1AR2Ko7peqx9wofUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDH5bYZ6Ntb\nczei2ZfQSF0F82VaBATA069oR+GH9x+jAAIgYn5A+Nu/2FICtKrBOPXEhLf2PQ68\nQEwh/95llI8N5ss=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYVWfTJUTP5EhE53AxXeRtcgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjg0MDFiNy1mMTczLTQwZTQtYjRjZS0yMWRiYWU5NTY0ZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYcYDru2mbleSDF6ohAwkm0dlm6laGf/3bPlxqyWWlHEAf\nPCU/ax1lKrFulAU6o9J7noKK0/1Zcv8vC2KyVr8ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUglBUAug4YTq1AR2Ko7peqx9w\nofUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJgR4hIEoMUSr7YnIFxEVTDf6FO16KG9rZRfaxUMpTgPAiEA9r8Rqa8G\nw1NMZbrqkgAE30AnzRLGtg7JXeeeW8/laXo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcT/B26ipEQO7A4oaBLiRczbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY0MTk5ZTQtMmI1Yi00YWNhLTk2NDEtNWY2MWNmMGExNGMxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWM0ZjgyYjAtYTY5MC00ZGRlLTg4YzQtYjNkNGIzMjJh\nYWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEluQrPJg5vr87f4/8KNX/libe\n5xCrEYnjWIp1ybZ6Qv20b1VkgHA9Xz6Pu6HwivOEK2oQYZ46ZOCHNLC/OEuECKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYJBdFW5n0KrcP/essiK2qKgMBBwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA9YhTgkmsO1xgbUIN1AkgLJnYa5+d\nT2HPtL6beiipbpUCIQC73mQqmHMLwjpuYl+pVQ25vOIz+UIfoRiK331mwBX+5Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2429", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2429` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAep4pOS49qEpfPFbXi/5/kMSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZGIyYjFjLTRjMTYtNDhkZC1iNGNmLWM2NjBlZjkxZDdlZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBjZjYwZmYtNWUw\nYS00MzliLTlmY2MtYjQwN2M0YjVhYjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs8JshOKBUbpUUpbkJTe6AYF13aks9IP0UWe4GCcsQQR9evL43SkVT8kev8oN\nskYIE7Zonwt09WQg64nkNS9AdKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhXm+ue2n9HqkN8tseZP/FrkaaHEwHwYDVR0j\nBBgwFoAUthHitX7Zsrf33qayf6dAdZWX44UwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJcxcEbtQ7khDdcCmEdxhojynogPmX9WveUbtuyFbaveAiB47aXggznW\nmMZV0DbUpERiCQZaX+6DLO3lVXI3fGuziQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaptb8PIFRRklsL6kxVfHRYEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmRiMmIxYy00YzE2LTQ4ZGQtYjRjZi1jNjYwZWY5MWQ3ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFGdYvPI1rUw2Kr2dO6FjkwXs4K6XuR0meMUltAhdgxPHv\nFB4W0ZkPCT++pApGXvHT3lm025fRkoPgOxUJanuxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUthHitX7Zsrf33qayf6dAdZWX\n44UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ15yzT8wUSLX5KWHRXYy1V/Ebt6olYNZaRfzexhucL/AiEAmwgEmupu\nRZ3fj30lX8woMQLSmdyl1mkyylG9noR9Jfo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXvxIWY+b4qi3LrM0wcgYQulMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBjZjYwZmYtNWUwYS00MzliLTlmY2MtYjQwN2M0YjVhYjc4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzA0ZmJjNmQtZDExMy00ZTI1LTk0MjUtZDc5MDA2YmJi\nZjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK/v2MOY52YbT7ClDflHH33Kx\nZQI2GF6u9yFqOn0xjprvy7ggbqhK7ubQeoNuBOrKDbJ19Br7reJ3O+c6qdJ0haNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhXm+ue2n9HqkN8tseZP/FrkaaHEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA9hv0MsMIzs7iBK9+Gd0Dj+rue1kf\nVd4x8wtNCjMbH5ECIQCsjBZLXOTshFR8NLjf5povi2ZXjph4DsEPDRyOQJvgLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2430", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2430` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAfwQyoLYsXEru0adcFfeSfwyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZDg0NzRjLTAwMDQtNDg2Yi05YjQzLTJkZGQ4NWU1MTU3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IzYTA4NDItNmVk\nZS00Y2M1LWFiMTAtZjc4ZjRhMjYwYmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpvan3rNXbRimeaJCGBLKHWw9kxTX35kA3qB6tNYh9k2YnkzTV0CL8bNBHNd5\n1Y83y3raayior1lRA9gg1Hc5dqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdglLyavoks9EhdTXumBs5mCVrG4wHwYDVR0j\nBBgwFoAUcT1mKgn5Sm9Jb3fumSoOubTpyIYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANO46GM5thKVHHUV2NXzOgTKCRA1JHi294K/mv3b7C1vAiEA16YUbYFv\n27RYigkn7wv3VFA8eKEPwQwqabWfgd8PnbI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf9CHtLzwj1UAJCzaIFW522GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmQ4NDc0Yy0wMDA0LTQ4NmItOWI0My0yZGRkODVlNTE1N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1n58CFdsHVzjQseOE8g5k+Rw+dBLQk5CQc2IN3RiIEuO2\nLwU9jaqc8J8EdheEt5BhQWQj/8NW1dbPDWnQLdwzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcT1mKgn5Sm9Jb3fumSoOubTp\nyIYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRcze0uhgvZ2kqcqoswwgQt9ZvIKOrSqAE9PC3fFK1NMCIDkHyOzZU/Nd\nM/O7Y+Fqt5dojA7RS/JdqkqQ0lSf5pzE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATFHh3p1IxwfZ1XFAqO5XdVkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IzYTA4NDItNmVkZS00Y2M1LWFiMTAtZjc4ZjRhMjYwYmRkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjliZTY2NjgtNmI5Mi00NTA3LTg3MmYtOTQ4NGE2NzQ1\nZjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfYXLC4doNdYMjHua7Jyf3hsW\nk9Fl/KysBSL9jL1j+cE6484ss3DOinV5VSSIfXiEVAuq7qcwPYPL//lYuuqFKqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdglLyavoks9EhdTXumBs5mCVrG4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBZlApCsAhybuNCyNgIGo118k4WrQkk\nBZaH9BCawdLkfAIhAJSXHWg0KVtIjnphCkjuS+pjuiqlKRW6gnLyJXKtHIye\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2431", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2431` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAQsjflX5GS8AmyEUSuVEhtmMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyOGEwMWVkLTQ3ODAtNGI1Yi04MWYyLWNmNTYwMjc0M2I4ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFhN2YxZTUtYWYx\nOS00N2YyLWE0MmMtYjcyNjM2N2YwMTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXCl1J6REsX/w/xAGfbMlf8viT2NNe9T6dqBrbvMODF2VQN585lpglnQWO/yG\nalZ3QIeF4v0llg0iYfSiZQVThqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPGh79b9sdigokWeL4La11yCDTJQwHwYDVR0j\nBBgwFoAU+MJGl9wYxMkuCW4oaTel8wfWP0YwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIFrgleFZrIc+K+bowrxjoVtf6a5td7+og1RI91Gl6bInAiBBtKAEsGcz\nyHXrjyg0ZgB9HBK8D+VAr3I8ptmqJPhwhg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW5Di96MNTYyVdBoYbvDWbM2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjhhMDFlZC00NzgwLTRiNWItODFmMi1jZjU2MDI3NDNiOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnO99oSkOBfDrhzTgpWx8+qYgY580RfXEJZdXMfXG76dO9\nCYPBVZEvJtNidyux4nuAUexFp2rmmN1z6LXpSob9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+MJGl9wYxMkuCW4oaTel8wfW\nP0YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIG6gHQex7aElqispeOKOPG+VTI8GylfLc0kxnM5wv5MCIAQF0TajsUpX\nwCFH+mRHUwFrwWJ5ZjdQmJ4YquviMobH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQ0ZgTtJwZoypQ8nUCQtZNrLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFhN2YxZTUtYWYxOS00N2YyLWE0MmMtYjcyNjM2N2YwMTYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDgwYTZmZTAtNjIwMi00Nzg3LTk1ZjctM2JmNjFjMDZj\nMjVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENH8/Ou2N1uJP4DxrXoIjyNyj\n0/sdqrW1O7hi/xkIBA+Fenm8A3LiuY35xz16vX10XUiCv53hTyHsGfXalVcz2aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPGh79b9sdigokWeL4La11yCDTJQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA/B2wY7ImAITvoqwcFXvzpEVYME80\nhQiVFAM19jMht3YCIGOgtGGPdnAy24Ta4BfuKBTvi6BmTRkAseQyHeOVF4q6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2432", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2432` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAXswZSfgZh0H06bfWkf93y3lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5NjUzODI2LTRiMTMtNDA0OC05MmQxLWI3ZjQyMGI1OWU3MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFmMjhlNmItMDUz\nZi00OTI0LTgyMTYtYmZjMGE0MmUwZDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvBM1iJSgNaZqArOsItJ3OfH4ALjZy+sLYMPs7oJWmCHR5afy4RkGcEeRbKQO\nTsIe0iMQimXeOHZ6boBT0Zpm/qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Ta5lVZhwAG6fnBIaNFbIDnSY9gwHwYDVR0j\nBBgwFoAU9hNYR0YDauhWTKIIVK5rPp2rEVowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCPluEDybsFAgYhcWPdg3+Q03LJC2mCRRBlCh4G\n5WWAyQIhAKVRmqpK+uN1ZR8l30UL8cOjKrcnpHTecj/AhVCHakal\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATYaBYiGxEFQFkLt8TQawEIeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTY1MzgyNi00YjEzLTQwNDgtOTJkMS1iN2Y0MjBiNTllNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmp/1zC52ICizyu4U29jHm1Ms+C6vO2zDcA51giy4oMtCx\nfoXgsSXUnYZDGUOsO4YaQn8M8teeGTz7lTtBIrqbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9hNYR0YDauhWTKIIVK5rPp2r\nEVowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVupPCnlNIeJMx6gm6ZSbdlFCTjLoByCf+k9IBkcdSQICIQDMS3EMPYXV\nGkEILhoODtte2W7HHxqYK/vzV2448OOnpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeWNNNHMRH2r2zDFV/xOqk55MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFmMjhlNmItMDUzZi00OTI0LTgyMTYtYmZjMGE0MmUwZDE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWI0MGFlYjktNWQ0YS00N2RlLThmNDQtYzVmM2U5Y2Ri\nY2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZKK4sW5cJtHg/6axNnKzFkbP\nzOQTWDKtqaM+OeR7hdQisOcM2oFhd460znWqlgrR8FePzSz7Sf6rTNpDySUyTaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2Ta5lVZhwAG6fnBIaNFbIDnSY9gwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAlm7Xxc8VbTJt9MXaAsgz7UuKtU5w\n03Fyo6SoqTAWVFkCIF5AOwUspjHdfYxMNtyvuKzQB83oIhllg2JuPBeuI6QO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2433", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2433` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAVAYqAjSUftpiUu0hcI4tuhaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MmRhNTE0LWRjNWItNDZhMi1hNWJiLWY1ZjllYmI0MzFmNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdjODM0OGEtMTRi\nMS00MWI0LWEyODktMzg4M2M0ZTViYTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwjt3aUg8/Ci2cht7uXvbi2lyhwKeVK4dA16kQDCiEKKDb3KBKlJp3JCo2SH5\nPQhicPiMRD7hHm/+fkd4gXL+4KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgkO2zV7bZmlXAJwxdVsiP12L/2gwHwYDVR0j\nBBgwFoAU+xtPfpFGO7hTW99YHuDUnevGk+UwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIGc6qChdBzKyA1cCkBwb1FxNDvoeewD51PZqVjjh\n3v5JAiB5Ow0tIfVLQlxRvWnFSzgqMbPq9puVUQXCXtqQdXAmiQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUOElgxWywE2zf9Sv4PHsyQPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDJkYTUxNC1kYzViLTQ2YTItYTViYi1mNWY5ZWJiNDMxZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8pIASMpwr4qlOeACBEBdjdkMbfsDS/zIgkLXoGC6AcG+Q\n1Njnf5uY557Wyd/lAn2E+EGtlhdRaqSOll0uyVvuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+xtPfpFGO7hTW99YHuDUnevG\nk+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIX05DLdKAp+nCK/JVtv4o2uJt7JYr7VUJWrsKqnbnA3AiBCEjqq5Kv/\nm/NqY8qC/8keQuoWabkWcHnUzwy4ghnsBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAX4MQ0l2QZNreTCusmXhUE3rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdjODM0OGEtMTRiMS00MWI0LWEyODktMzg4M2M0ZTViYTQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTZjMWUyYmItNzg4Zi00MmIyLTg2ZjktM2MzOGNmMjY3\nYTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELw2XNWimqDpa8gyix+Olo2ou\nd2mQdN7Em6QtRu3euesb2BEtnq11hKI8mICKKmJSd0mMzZqGbDeceS4TbiUAiKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgkO2zV7bZmlXAJwxdVsiP12L/2gwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiB6KyTtoAX3/DWI/0ovdiRs/ANgAlzS\nCRZT39bIEcK+DwIhALt7PCB2OhG1WPo7+8atBX1UkXJdVGGKFhLFQcAtdaMT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2434", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2434` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAXfoE1cknZBz33zUIpwz1qt4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3NTc3OTg2LTM5ZDEtNGEzYS1iMzEzLTVhNjQwMTEyOWU1NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVjZTI0OTItYjY5\nMy00YzU1LWEwODQtMzE4ZTAzMjNlZWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEytHr60+NDXP7yKEdpnJB1j/xoAm1O9HrkVdvYx4LvaZiU4NtrNrNfcWd+/Oc\nSyXeI68ICh/1Z6uWRz95fBY3JKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/cqy0v5mDaKtJ7EtNruJLRAqm8cwHwYDVR0j\nBBgwFoAULpFEAYMsdtNwf/Mc1RBLFOwzVWcwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCICYZpzgYbBMndb+FU357ai6HfgR7ydghHHUkrKh1TIxPAiEA\nrs/teyI6xdlN+nyoGYip4GyXyLYVcoQxbylx7gMYZnU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfdEW0pzHNthmFzJW/XAdjGvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzU3Nzk4Ni0zOWQxLTRhM2EtYjMxMy01YTY0MDExMjllNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpdGHzIosThE1r1HDfT1nNR1air+9cg/cIynS+9EcE5Pqy\nfXD9ZhtLibhRa+z7fIkhdn5Wss6Yt0lBu4b3Obbqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULpFEAYMsdtNwf/Mc1RBLFOwz\nVWcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMz8L1h55GR9+dZGOvwL/L/v2KhBWTsWU93aQdOyPvkPAiEAgw0yXDeZ\nyAWCfgHydH/dp9EoVh5C4kL4iru2r+yZ2WU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAb7s2RQPtIT4mg1SdfxhAbEPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVjZTI0OTItYjY5My00YzU1LWEwODQtMzE4ZTAzMjNlZWFkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWI1MjZmMDUtNTM1OC00NWE0LWJmOGQtNmYxMGI2ODQ0\nMjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQpMj4wQ4sDtdRzs22jwRgU/c\nzZa3+kqvnDxdilqzH11W+m5j9ByEBLY3glPSmhWdfv6QRxuDjFA8Kh7XiZUAmqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/cqy0v5mDaKtJ7EtNruJLRAqm8cwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA/oLPtlsC/gxU9BLfHrEra52GqwxyW\nJPFvAKLXaQvqpAIgDKaqMDMMIC1X+KpDRwBPAZAnsHAqN6cW0tQw5oU51Zg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2435", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2435` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAXY4Nik8Ux99aOMlhG+Kre/vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjNzczM2VhLTdiYTQtNGEwZC1iYzgxLTM3Yzk4ZGEzNjQyNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFiNjljOTEtYjhk\nMS00YWMxLTg2ODEtMjI4YjRiNTVjZDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmKN2DkUMGX7XEkT6SYOUPwQs2q1bLeJFoPjGjnDjkA0R2LscKJCwFlFWKK55\ne63fc7LCTDQcx0woBd/vs6gq4aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4vRPrwaORAcPHpM/4kqs2JHL0KswHwYDVR0j\nBBgwFoAU6zSYwFGZHrVTIv58u46rbOaM8P0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDB9w9yXOdUnYXV0PO7M4wSk6NYfORS\nN06kK00Yokfo8AIgN4DJ7A5Ol2NgJQiMLzKp65c0YZ7/xA/lmxnO/f716BI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ9v77ID8nw/j88VL21k7UNGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzc3MzNlYS03YmE0LTRhMGQtYmM4MS0zN2M5OGRhMzY0MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRMq7Mp6b7wlAzo8sQjBt9yHgOGa8Btfn6mP61YFcSA27F\nf6VRQwq6FhJpe1Ehm5tb3D3fVYSaCKjUEhzJvSDgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6zSYwFGZHrVTIv58u46rbOaM\n8P0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK2HYeNdWfZlXGocS5k71Hk7kX/mv0dAGOr22OFoQh2uAiEAr1TiHYZx\nEckS76hZkQ1O9P8zVBBCo3Bb60e+KRIJ70Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbue9vOasjlD9SBtY6OCj04WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFiNjljOTEtYjhkMS00YWMxLTg2ODEtMjI4YjRiNTVjZDk4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNiMGI3M2QtMmRkYS00YjQ1LTlhZDUtNDhjMDI0YWU4\nZDFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3B4r9mYrA2bFd781LIcZsmIN\nHBDA2rXStKbuAy2hYfKXhF7fJoaKoxe5ychYq785SPhCubQfA4p/UPEnX2cEJ6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4vRPrwaORAcPHpM/4kqs2JHL0KswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBYqrYRE1c4zFCMf4hLYsUpjhqIJa5b\naHOLpVNoKLmz0QIhAJRZSlUbPHVxAkmZigb9kpeS+Z8U6kD+UzFR7gnaA1nV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2436", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2436` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUWSAVCZM8HkpOcySJ28VjVAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzMzZlYmFiLTBmZTktNDk3My05MzU4LTBlMzMwNGI2Y2RiMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDdmZjBlNTYtYWFh\nOC00ZTMzLWFmNmUtYTQ0MzdlYjE5NGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWnBDG5NpErgKpe3Ww1pCJa9o4p++R1m6PgQBYK7i1oE6n8KH12dbyKTv1evB\nWBWruzWo8gYzq0uLJQKWhdeQFKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyZRS+ODdjfd36QcF8zh3bNy0awwHwYDVR0j\nBBgwFoAULifkn/WCQU6PabMtSX6W4zWSf2UwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDwU0Vr/7WC8r/Fyl3uRcNwIf72gxw2\ngiTC7B2c0d2/jgIgbYLFYPebI0CUOnMt63EwybFo/uXl1lMwVK/wEfx2wDU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZXRS4oJVTX//HXceVnuDp2gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzM2ZWJhYi0wZmU5LTQ5NzMtOTM1OC0wZTMzMDRiNmNkYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATr1qabusJ/a2+PyltdCRmiw+IqN7WHUuD12bCNq9GLlVr4\ngg6nPuQYKJHR9LAYaIA2jz+pLuq0/N/zYEJSLaWco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULifkn/WCQU6PabMtSX6W4zWS\nf2UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJqSkfKekA9WhgCXxp3Dtq6kZXYgReAI16YcuV7YcDW4AiEA5EAxcP/H\ndBbRBnO+5jk0VRWutTLS3ewOv04rBg8bluY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQ6t/xZUGjr809QWnEowlz7vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDdmZjBlNTYtYWFhOC00ZTMzLWFmNmUtYTQ0MzdlYjE5NGZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmM3OGQ2YjgtZmIyMC00ZGM4LThmM2UtMjFmYzRiYmM2\nZDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUCLzN6wjifQHBNxdQcUgRUqi\ng1Pxrl583LGA8FDbbT3Y6lbSJNteW578mGVwZ8rN3j5mXLdl1+XDZsLSFGD+aKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWyZRS+ODdjfd36QcF8zh3bNy0awwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAibTLyhPTXL6ddTEsZDuPaUqFoE0RD\nPCffDie3pTiimwIhAOF/C22I/VX5pGw/3orKFdFGwTWKxbTMrwWyR1vK8bzj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2437", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2437` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXRFeBzHg5ABgzYNGggpoeRhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmNTEwMzg3LTY2ZTgtNDhjOC05OTJhLTcwZTk5MTQ3ZTE1MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODkxMWYzZDUtNTk1\nMC00N2FiLTgzNjUtMjAyNjYzNjgyMWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET7MgkYOeQN4m+qJHWf1AK38ADW3kluA0XSxWzltG6+QQk9zp4aS1zvZdSrl7\nvCabjJkavAs/Ix6wu3nSRuqcq6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMB6MAoyhfdfk2FkMKciZHs0kjYPMB8GA1UdIwQY\nMBaAFPWeqgb1lLY4qo7vp8EToyxtKb8OMAoGCCqGSM49BAMCA0gAMEUCIQDUYNam\nhIVoqu5McHCzT8VX/I86LfPxxmv811QXIf54EAIgIm3x3xRxtaXzclxQMYRN6su8\nEULa6aHY3VGPIutTmcg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATIWX8nNRvI2gFLiXvpJdkTJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjUxMDM4Ny02NmU4LTQ4YzgtOTkyYS03MGU5OTE0N2UxNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXQzAZ/Axz284zYd3F4B1X7vl+0FJKfXnSimdoL7Ya/9Wv\nyhmWEQHENj/tPcB9JEwVxtA0bg+Ke/6EKgB6jIrXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Z6qBvWUtjiqju+nwROjLG0p\nvw4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL/CxHRyf5OENKmY9HjI9xdyBZG3n+co/70WcXS+IkDlAiAIqFTawLk1\n2PXoIjPfYFDRbcoQ+EjwHf7Puijx2wMlyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAWcUTrFXVWOYWl/W8T/ZR2DaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODkxMWYzZDUtNTk1MC00N2FiLTgzNjUtMjAyNjYzNjgyMWE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGE0OGVkYmMtNzMyYS00OGZhLTliNjgtMmU5Y2Y1Njgz\nZDc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7GHTEP4FkBEy3YAUSP1s3gZo\nXdqMfD3PZsjvYXWRDZlwvWJ+L0Jr0x3MpHGU25kMruffv+ZugOr5oHKKjPcb7qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwHowCjKF91+TYWQwpyJkezSSNg8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJsA0EdTmvDgr0dI\ngGDU5ny/9Syvg/F8vT/ZS4bXgps3AiEAyVt8RfZGBJMmNiWJn1vBq6SNkD2cx1Ev\nUs56MIAwnE8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2438", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2438` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAc0WAPu4YumI+UGWksXMJLT7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmZGM2NmRkLWI1OTktNDQ1Ni1iZTkwLTYyMWIwNDBkNjY1NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVmMDdjNTktYjJl\nNi00NzI0LWEyNDctOTMyYjJiZWI0ZDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh+VhgfsQ8D2f/7rM1NCzlbWr0o4fGGSCWGITHJnYcUDK+Mnm9X5dgDKjknx6\n8OoqU8AHeOS6Bkjm/AjTbDJM5aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMUNhxRDs0AhPRGaUX8Rg98zxDkVMB8GA1UdIwQY\nMBaAFIfSlC4+R5YJa3qFTLL36FrDbOqSMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAsgau2Pb3YcG1uj3hAfZwjMSvQTk2LpJzY\naprKvsp+cAIhAKbpeTyr2olRnB/w2qEZu7voFKqIb26WkhuZ0kMILaDk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASQiYHsdbomxUmajg+ikrjN1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmRjNjZkZC1iNTk5LTQ0NTYtYmU5MC02MjFiMDQwZDY2NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASg2sgB8Vm074jrALWGcCxX+dTYtD+cPsfo3VpMnXa9evxX\ngB9sXleJPPPciY1CjiWGiwqKbsscwrn8F7NysILeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh9KULj5HlglreoVMsvfoWsNs\n6pIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRAEecUGmjEU1UE7GZdVNX/taos0cWgYfbJ8n6+3L7ngCID0ar215x6G4\nCrifTDADP5PYect9Xx82DoJENKZdIKwH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAc9MmDe2yDosRRPTfugpStv5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVmMDdjNTktYjJlNi00NzI0LWEyNDctOTMyYjJiZWI0ZDI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjFiNjdiZTQtMDljMy00MjA5LTk5YmUtZDI3NWNlMDhm\nMzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMDu7a2UiuHKjNfbwYS9NUpqh\n7dXL+JJ5NlNzaGLD/+OjXWvgbPDznBraXEFeTS5E0ljDZAcowVUHKL5eEG22CqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxQ2HFEOzQCE9EZpRfxGD3zPEORUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgN5h1D2ln4RV0pppV\nzZIMzUKRnKDUq7XJVin9hgp+kEsCIQD2IEz9tHkk3U7I8iUWVLLrbp0OZMT6CySP\nDGTTR91MwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2439", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2439` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVUFFkD9temJrAyXaEPuJRoFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3MGI4MDg5LTcwZGItNGUxMi1iZTEwLWU2ZDlmNmNiZmNhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUxMDYwMjctYzdh\nNi00Y2E1LTg4MDQtYjQyMWUxZjgzMmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7SxGB4/3eUnrOjMFdVxNpeFePNJ0aj38RbqqxlxD9o1Ug2oRMvFKzis68BJm\nvYyqT9Al+vKIxL6u7Khy5uN17qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAl2Rd29F1qZbNa6MWAfWYYOx4s7MB8GA1UdIwQY\nMBaAFO25kgFjGJVbxYFDXnw3lo5cSCVwMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBJu+YVuYt53NHM5bloLg0r+24anHunVCuL\n1Hue7tvkYgIgWMKBKvdh5IJV3AzL69+LMDlBHE2b99vDprVtjSELh8Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfSB98Zz/h6lbbEgJfWSo2ItMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzBiODA4OS03MGRiLTRlMTItYmUxMC1lNmQ5ZjZjYmZjYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASP5dGBx9GnVmx3jFNZg+bXxscCrZZ1UOCSKh4va+OLbdTT\nKzb6VuD0JKuVOLFdHbkU7lC2lCtrBNrLW9G1V6WTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7bmSAWMYlVvFgUNefDeWjlxI\nJXAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS4t/RhUHXjykdwUGF+cl+AYFn+yXaSDVtYHRLV0T0z4CIQD8eTQqf7BD\n4rrV7u1FMtMMlyuZ6bmTE3sGnp2lm32Hwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAS53gnEDkRbNK/KF0aelppXzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUxMDYwMjctYzdhNi00Y2E1LTg4MDQtYjQyMWUxZjgzMmUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjIwZDQ2ZGUtYmQwNi00NjZiLWJiOTAtMDMyNGNiZjhh\nNWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEf8xB6p0fRE+TGnSxtUcSudGa\nHcI7oRMQmlIe/xpQkPSfaAmDot2lNjuI4UVY2gCJoBDfE3fcru4B43Jft4bUQ6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCXZF3b0XWpls1roxYB9Zhg7HizswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPXbvHJnlJ76XNjP\nXuTi1gxphZGmDbhScXk+xjchb/vVAiBOvasAFC2lSZnf2ZXa+cw0gg2YeWtW0JUO\n4l842IaEFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2440", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2440` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISARqrmtilfRxNPdXXBgZo1CfEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5MzMwM2RlLTk0OTctNDdkNi04ZWIyLTk4MTVjZWU5ZDA4MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDYzYTI5NTktM2E2\nNC00YWY3LWJiZjMtMjAzNTVlNWI4YzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP30nd4NrxGFIVdCJtQMY059TtXehr0SNk7grBEZbDU7+kAvqCjdJbBFATXwC\n4IzJvZ6C4DTKzj0kQ67vnv33DaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTZqKFsjo6ZIOM+k/QckwHN0MMAtDAfBgNVHSME\nGDAWgBTcRQ3eU3+uB/nui5VwFcKTBoTumDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDxxkilvoTk7CqQYxJVZIhTVHaUzZSS\n/55GnzXWSaxwugIhAMO1C7L9E9HZ+ornpSDwhEMrhkOl9nVf1VWlfKFN/0Uu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeSwj2ZXLBH9r2qAlrMsCRQUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTMzMDNkZS05NDk3LTQ3ZDYtOGViMi05ODE1Y2VlOWQwODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvoPBzn4EIFReULrMAjRlYS26gkidFgrKVq/M/YH3w83IK\nsFva1t4mh77xyzz740bsX/NoGWRSzd0CpacYosdro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3EUN3lN/rgf57ouVcBXCkwaE\n7pgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVg0CwIxAznAxdyXO7IIAu9vOyoeeJa2t95EBCAT/paMCIGtvmmr35Xj8\nZROs38Jjg+ck6i0xPeyxyL1G1c+wNlji\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAeKT/TVvAMVYBXakpZvlFl04MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDYzYTI5NTktM2E2NC00YWY3LWJiZjMtMjAzNTVlNWI4YzZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjk0Y2NiOWItNmQ2ZC00ODkzLWFlZjUtMjAwMzIzMTQw\nOTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJNtfdhau5u17OWpspJQpFUIH\nRY1i1iD8jXwxhgExId+vB84yuZz1o02ShwxA4Kxwwk4N5te612mUrSAKwH+n3qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2aihbI6OmSDjPpP0HJMBzdDDALQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPe99EJxwM5WBLjx\n1PmakA833cVebjIors8Zr5vvu3FsAiAM7iFkJUUY3b18CcDC/+S/YB+t5yM2FZ7i\nhhCl7uQ4kQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2441", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2441` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAY40CEZ6kATh9n8DH5E+BrjDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiYzI3YTU4LTdjOGEtNDg3YS05ZDAxLTJkZDNjYTFmMjBmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRlZjY4ZDAtMmEz\nOS00NDFkLWExMjEtMTIyNjE3NmExNzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET6TCQdY3iKtNA/zpJFJwQBi46VTUz6jVV/uz2SvDa/PiWqkdmA344eEj02S2\nd/9wxO3T7c3uQfKroAUDLySVGaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqg9enuZaUdTE1U3ULG6WdNBnCFYwHwYDVR0j\nBBgwFoAUwccf72lBj0qrl7GsPpiultkI2IUwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAhVh8vLk9+ia9\nFV9ord7g07evHCxWOgZIJWfZe741gP0CICjrKAsKfJWEnxA+NuixrAW8w664V0f9\nLCYABsZfx8Sf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATPutCJ1hTtNVD8VOUVirNlGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmMyN2E1OC03YzhhLTQ4N2EtOWQwMS0yZGQzY2ExZjIwZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwKjUhOPdNamGM8xaxwyJCOK694+NRP2TEWIOysaobc/yi\ng6zYIkilmGmF0J+LZefPft+xAsqRAekFt/C+GhPmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwccf72lBj0qrl7GsPpiultkI\n2IUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc4A74IUqa/ua07mI+cVgxsZsmBtCHL2HUu0cprIPyzoCIQD0TyqvH9JR\nni/h3VltM7Iwfmj3gJfILdfX6M8sO6XtIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAceGx+/ADZpRm0jw3ONYwxQ3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRlZjY4ZDAtMmEzOS00NDFkLWExMjEtMTIyNjE3NmExNzJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjE1Y2FkYmEtNjU0Ni00ZjU0LTg5ZDQtYTBmZjk2MzZk\nODU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6gOSbpUx/RgJw3Zw5MfD0SbR\nArYPGP0KQjO0+SfVB3SbV/d33r5JGCWD14JzsO0WgZc99qwaLkAGAitW1cbr2KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqg9enuZaUdTE1U3ULG6WdNBnCFYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgfPcRzMgFpk7LN0fa\nS6ju0M0mXE5x5ZqdwWpTs352uRgCIHdVUAnv1xC+vxhlDioy+lVzaOIz13KupI5P\nhsma97zs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2442", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2442` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAQIhk/wvy4Bcr93PFBo2PbyIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjZDgzMWExLWFhNTItNDJmMi04Y2E1LTRmNmRmMTAzNDViODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY5MTUyYmUtZjUz\nNC00YzEwLWI1M2ItMWU4MjZjODZjNzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESqVLc1LXW3Glsf8yzW+kPtPUIAfWqcLm6Ar/f2bEMn/Abaedzfs0Wph0DOLK\n+d9keZ9tvR17e4GKPgzRp+HbUqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMxmbIo+9lZbsajq/yLtkrOcdN2YwHwYDVR0j\nBBgwFoAU0l0q+VsGVMf27tl7WJQYkPcUI5swJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAXNw+39cyKtz3H\nlmYUKwp0cJTD9BkKIOLAL8V/btG+dQIgfudXdfwkkfSyrlPIbhzeJQunD+yK/URz\nl1qCqe3aG7M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWyJFiBRv8DKGHsgJ8bti/rdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nY2Q4MzFhMS1hYTUyLTQyZjItOGNhNS00ZjZkZjEwMzQ1YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+b3hmFWbAlz8KH6XYmHPQy26l0cmcD3l2f6ENNeaP8gm6\nEPrGnVYx8wGdzJ0k2AlpGh0Dl/bxKzjnfRV4IFPLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0l0q+VsGVMf27tl7WJQYkPcU\nI5swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWKmVd3Mm20yUasXU4RpLnzfR2XkKb5rU+Lm3jiUT6bgCIHqIn/FTH080\nYwllepdZD75dSPOzUYn4ivCvLYGHvRao\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAWV9JkpxvykTxxKD51BPhE2aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY5MTUyYmUtZjUzNC00YzEwLWI1M2ItMWU4MjZjODZjNzkwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODdiNDhhM2EtMGFmMC00ZWQ5LWIzMjItN2U1MmQ5Mzk2\nNTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/lcS7HhJ1rwATBRY6VjHdOL0\n8Z/3w15MgMtshuHlZ5TbDe0S7Wl4llORpy2DlA/Y6ruV5J2dpf4+yQ5HKoHwb6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMxmbIo+9lZbsajq/yLtkrOcdN2YwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgJWv8uHVM56dR1UjR\n7mlbn+AnmQOxbHomNPedki9yh4oCIQCCpCr2vN/0voMpLnJFcKVD9M+uDN17ZVva\ndX6ElhDPVQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2443", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2443` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAdjcN1w51mba+Fd+4yEWZ3ZAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjZWMxNmVjLTVlNzktNDczYS1iN2U5LTM0NmFkMGUwMDNjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJhNzg3ZjAtOWE4\nMy00NTQ1LWE0MDItODY0YzM1OTNmZTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnIBfxTaOjrSxMIA+rmfbJbVYD+n+IWssYLZtgcsloNh+4b1lgIvONDNjQ572\nF4//6wqBmlp319IgbDX/86vcNqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3tzD8GKKI9+d8O9mI1nY2XRaAqwwHwYDVR0j\nBBgwFoAUIUR5kxTbn9tXigjcimSgPU+Jh74wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAfokgtRqv5DWp/EP3cPMA4\nCPFggF5b0OYDu2SrskCxdgIhALfqtcLSXmEwWq6TsBLNy0c460bdHX2Tb+PDr+Iq\nxav+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQfRKNGLx0UvMF9lLQi95u27MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2VjMTZlYy01ZTc5LTQ3M2EtYjdlOS0zNDZhZDBlMDAzYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATba8VHrpjKkuoksegp9RnOQtbA6tKbTKBhGa2ndIJ7m5Z9\n+W9iFHFsLcfB6P3iMHiobJmyontSx/H/sY7mZMpZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIUR5kxTbn9tXigjcimSgPU+J\nh74wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIXMvUq0AsrqRKwTnu0PrS2/i/BbA3pC2FotTNkOlBzwAiEArfkJbeHb\nemnQOcvPI8YqMOlRrjqtckECvtfG8Bl9SKU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAflpE46a8oIWoEV2DffepKL/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJhNzg3ZjAtOWE4My00NTQ1LWE0MDItODY0YzM1OTNmZTA1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODg5ZjgwYWItODQ3OC00YWU2LTg2MTAtNjQ0ZmY3ZGRh\nOTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEF6S6ISoehCtfGJUqjESpHnVW\nfhLu2GEPppluDmrS8hPK5/MdguJKsQpruQHKvqS4Ivkmp0Zw2PgoGzlGHRD0CqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3tzD8GKKI9+d8O9mI1nY2XRaAqwwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJLdZlHCI63kfAxF\nDFhitMziQPiEO+uJvUcJBJ1hQsTTAiA16CmfWdmvsi5S4dgHwIEz/LQK9MoarYOV\ndhMMfnFlgQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2444", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2444` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAVh1uJsGjlXY97r0J2T98TpjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZmFjMjk4LTQwMjQtNDUyMS05YzU1LWM5MDQzMjRhYzEwYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY5Njk2YmYtZTVj\nNS00MDFiLThjZDEtMzQ5NmE3OWY5MTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfeT4TYi4NwJq/malr87axsqCUaxr1AnwSPpTxIdmOBIc7FbFeXnNXAFSlCWc\nKpvjq8Fa5SnF+LFzJS8KCT4jPqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtnV4VZVQ7zCDXvvO5YFXQihYMQMwHwYDVR0j\nBBgwFoAUjWus3SNoah/yIXO3BTA9dFzlr8EwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAiNZp\nGoAPGAQZjUvVWceRCA4H0iIGP/SUZPVENZP8t1ACIDix6Oq5HuxdA/Z7kNnrsjnl\nSxCCeLY4wE0Kkng7gh3L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARG4HT8EwBQn+tCy9nKbVQW/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWZhYzI5OC00MDI0LTQ1MjEtOWM1NS1jOTA0MzI0YWMxMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDr6MuWfFrIL6VlONOr11jsSb9Js8PyRu28+gSnL8gj98J\n/oq0DNDilartpxT/79TqhjacAJWW8TY0M4Ceq2zfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjWus3SNoah/yIXO3BTA9dFzl\nr8EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAInpSUdERTkBSsi+XhsLHZn2EmkEJZmUE5YKLOlsr2hcAiEAzB84e8Sr\nCLAjeW35f6O4bRnj+EGhn6fmCDpJTYMrD/A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAeiooMrA1w0JoBIFLxX6cWAnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY5Njk2YmYtZTVjNS00MDFiLThjZDEtMzQ5NmE3OWY5MTQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGM5N2UzMjAtOTBjMy00MDljLTkxNWItYjdmMTUwODRl\nNGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECq4ZNUIRJI9TLyAdCJeB7R2s\nZfD2e3MTveeMfs8FkXuW0WEX1d794zwmA3qpC7crUwtXCxqnZfLISOpFHagAMaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtnV4VZVQ7zCDXvvO5YFXQihYMQMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKYT2wa/s7txD7zg\num3YRpeWOX4+cKCzgLZqv5lcEUbrAiEA2hjSyUS/64aDu/g9XDRslawQSGlktIfY\nL7+WS+eYJD8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2445", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2445` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISASZ9+qKvsBE2wIIjcRUQmuX3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmOTBlYTRkLTA4Y2MtNGM2My1iZDE3LThlY2NlZjVlZjRhMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA1ZTM0YzctZDZm\nYi00MjYyLTk2OTUtMjFiZWNlMjU1OTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEopnhDjixJSoJBPGT9hn+ko2Yl3r7B8uBgA07f5sdygBCdXjOVgXpJmc6fFN\nKu7i0Pf7lrOq9gvhnju025+OZ6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsDI2ufT6Cv9HDV6SKoBVSC3KzwcwHwYDVR0j\nBBgwFoAUcgDH6yQjRZOXqARJZGx1kEYBB/UwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBl5Gwf\nZwcdCyaS+eqpITkmDQC+TlHKomCMlGtTaZFezQIgAzvcBoHKmOt/CLsGWF6LJbwt\nlTtdtrM26bUbOtt9lts=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWynXwK/yPUU21oIR8BjkiidMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjkwZWE0ZC0wOGNjLTRjNjMtYmQxNy04ZWNjZWY1ZWY0YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKuklZ+lwS6gNbKftMsveOG5uCo7kHRffPJpbMTK+5N28X\nEkeuNFTWy6I5VfPhJriCXYTjOzOPkY+Bb/aYnvkbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcgDH6yQjRZOXqARJZGx1kEYB\nB/UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOIcPO48vDzBqtY6swtbpjmyukiIBkFsimq5sNAQg4iUCIDDMZQh1bJf7\n8G81gPHc+BThj7DmBPOCi2Ho7Anztfm0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAbXseMA+TkBKXjSvcBG7ZDIXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA1ZTM0YzctZDZmYi00MjYyLTk2OTUtMjFiZWNlMjU1OTg2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWEwZTNkMTUtNzEyMC00ZjFmLTkzZmUtYzZiMzg3MDk5\nOGNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhWbZIegzLUW7Ogb0pKQLKZNE\nxasUZZjHBV7+Hai978eOEA5YM74ZQX2nk/SENoLxek4lq/u8Vf/CJeGdy8JgyqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsDI2ufT6Cv9HDV6SKoBVSC3KzwcwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAP962oB0rtkzILio\nfimAHgIeQSAdli1OroSILIgSWxK1AiEA1ICTTyqknoKNZsNi0ezMfxX46h325xKO\nOKHMLngZD/o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2446", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2446` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVgNh0cVk2hBjPPqiAJUpilnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5MDFmYTI2LWRjMzEtNDkwZi1iZWUyLTgxZDkxZThkNGJkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDYyZjc1MGEtMjIy\nMi00MGY5LTk3ZGQtMzhmMDAzZDJiZWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZWvG7WGaw/WB9weZmjMHK3dTWMh1gvJyt7HUbmOm4sKhErWG0zWz9T3WbsSV\nnL+svthbtywqcmvloBYyKQ8uV6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFH7TIJ1Z1fV9347rQY9BC8O9sElDMB8GA1UdIwQY\nMBaAFM15ApCn8s27JuC6JBccDXfBzw7uMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA9W09CtluNmbdZurUrcoT3Q9VHi/X4iwh\neyLQsv23fCACIBZnrxiZlA88HrwxLK6D5Kb350GHZdPTewDJEdzVFSxD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXunhJZQNPOlqUNEiNCF/SZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTAxZmEyNi1kYzMxLTQ5MGYtYmVlMi04MWQ5MWU4ZDRiZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGaR+4XXu9oAXCOVipibJYGH6p63a9CJZcObJsqJ1J3fOE\nAfbbuVg71V+tZr+o3MVj3zQEjeOkIQcPaU0Wpqrmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzXkCkKfyzbsm4LokFxwNd8HP\nDu4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANbPeC8vNrwOUSkNr8ucs+WGgd5qz5mFk436LNMMyvWbAiBT+J8yizJ/\nP9pWrcEnOI/Y49CX2VLIOp8OITmIwHo9iw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAetCME87G9MzXqc4dM1uMo5fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDYyZjc1MGEtMjIyMi00MGY5LTk3ZGQtMzhmMDAzZDJiZWJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWM4Y2IxYWItODY0ZC00NGUwLWJhOGUtOTc5YjY4MWU0\nNDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIII/2/Cff3KX1WPwChOfLWpI\nH5T6d8aJtWilR8BEcJ6KDsdIP3qjussNiyNkJ9uWr20zA63WxLKuTiYCA4XG9aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUftMgnVnV9X3fjutBj0ELw72wSUMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgdull/lMZDLIZQ8rM\nq/dRDiTnSxAsKwp0n3sOY0uKIcsCIQCVH9wVNG3kbTAfVRgC9MTJdZw7zvIjoj4G\nTQNU3sI16w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2447", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2447` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISATHG8JKkPA6ILzxg3nQqmXgaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmOTA4YWNlLWM3ZjQtNGI5Ni1hYTEyLTIyOWQwMzI5ODc0NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVlMDUwZGUtYzNm\nYy00OGVjLWE4ODgtMThmZDQ3ODBkNjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEouWTRxM01QQ+Y/KDXSwxZI5dlboDrxcxX6mprDlcpdGj57pURCW7km5E+HcU\nSvrkq+EEamYjwIFl9tJKYr+aeaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy9FOJdFWUwIaM6vC7IPU+lsI004wHwYDVR0j\nBBgwFoAUsz4uJ2V6DVdQlM4EBg57CnrvzW4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAOvDvHILX7ku\nLCvHUdz1cM06A6X0mXTTkm+Vf5ufLe4HAiEAooSag9TYzdGIqT1PQn/WjjfD1+pN\nIoaNaa0XqeA0HiE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc6XZt7I7zinXo1q5BtyXiXlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjkwOGFjZS1jN2Y0LTRiOTYtYWExMi0yMjlkMDMyOTg3NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARraTFc3tF8GM+8kHsQo3KXV08f3MHrY4neGTOTnA76PaTS\nNodDtc3tszozb4aBiMEUG1U3iITvGEdWERkLwXN5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsz4uJ2V6DVdQlM4EBg57Cnrv\nzW4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSQh6W0v2bvlggSKNMeYNF7T8sd0T1TtMMJakNfjRopQCIGTIk4lpSFM2\nFDp4GzoVM9+92cp9yGQfDJuIbeP2zrmp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAYPSDWDbcmuQn9zTuqn996wKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVlMDUwZGUtYzNmYy00OGVjLWE4ODgtMThmZDQ3ODBkNjRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTA1MDc0NGItOThkMS00Njk1LWI1MmQtMGE2ZTFlYmEz\nOTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/JLQRsgBqq7FqxnPKTMf1KqG\nziGsuaHF9ZVCuUjxERV9k2x7UWsy96pCJA5KkKFX5dgqalqQySyW9j/qT5p7MqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy9FOJdFWUwIaM6vC7IPU+lsI004wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgLMoPr/YDGuanzgDV\nU0wt6AiPIo+wGp7kQ/JkkOep7r4CIAJlOAYs4ITWD/RsWBKg7AQml666wuvba6CS\nPzQdDxXp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2448", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2448` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQNbeGEY3wSY4aDPIqUsieufMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlYTY3OWY3LTAzYTEtNGY0NS1iODRjLTAyMjhhYWNiNjAzZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE0NDI4ODItNDg4\nNi00MzA4LWFlNTItZTc5ODNhNmYxMDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfEs7L/+hLUt/Ll2SppIsHjsOQxw7VKHDnISRmGFSQVETXLvktooD8XRU63Xq\nrRKL+W6arjBpnZ8Or30BoftL8qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4cdmCxml9nuRgHQ7kWfvNOt5UYQwHwYDVR0j\nBBgwFoAU4dl6A7WTMKegkF+hKJE1LnsClS4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgQJIYiRRd4aG9\nn9WH6bCYWa6Ocz6adeYYaEfIg/+9TQECIQDqmXAnDqJFn8o3LdXOpTViAW8I/4Jw\nDOIR+sZAgSgOxQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWwAVllvP9x/+cwdDaos3KJ6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWE2NzlmNy0wM2ExLTRmNDUtYjg0Yy0wMjI4YWFjYjYwM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyxnZosXbfz5pA6fEg5QkwtK9CiYWWJ7ngSwp1zd4j0xcX\nuWg9WcyWYGLcSalNlTp2zD4Elw2tYdOkNz3PnYlCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4dl6A7WTMKegkF+hKJE1LnsC\nlS4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO/h8GUD7xljTbHqI06yuU2Z1uDAoAxhTdgYFxIXYim3AiAufZlvUyuA\nGv9qctljh8umnOguz+RlB2Z2hhBnX6cNDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISARc/JH5SdFkaOobonD4LrZzNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE0NDI4ODItNDg4Ni00MzA4LWFlNTItZTc5ODNhNmYxMDgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODYyMjA0ZTMtMTRkZi00ZDg1LTgyYTMtZDIxYzdhN2U3\nNjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErWu9sLmFe0TSsCiMwNwU1DOg\nMDlTq2e2VvUBHsVZ0CBL77rE9B3ZPy0PrO0GaQ+2MDijnFZzkDKhK3Fyv4heR6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4cdmCxml9nuRgHQ7kWfvNOt5UYQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgeedcFS3YXT/IihdG\nc+i19klgtSZujM4+JrTzYkAuVaICIQC3CSgrvOfIiVOj5vIulZMtIId7oQLOpVMg\nXtqLLKjZEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2449", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2449` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAS/KAp+CYh8WaWBt8WERbcy/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyMTkxNTIxLWY5MWEtNGRlYS04YmZlLWIxODdmYzgxYTU4MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg2MzNjY2EtYjEw\nMy00MDU3LTgyMTgtODcwNzQxYjBkYmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERFTCU6iFzK9cHIlzKTuxNkEufNPjRPbqgFRW14NURbeCP8lk+wNQP2Wg/GWj\nOfmQG3wWDooFwc1me4XtBWqzAaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU8ec67esU9tqmCvsslEvqbDTYp8wHwYDVR0j\nBBgwFoAUrQOfEeaRov+rXPU5gaUyX39SlrkwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDyDUo4xeUh\nDUdt3a+Tgi1nY+Ty4H/1X2uni7o6KzRp+wIhAJCp1to0lLgOdwTbEae2VZt6nA6r\naJi0TkEAulvoulWd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATl11wfbTFloBvNQB5H7QeiCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjE5MTUyMS1mOTFhLTRkZWEtOGJmZS1iMTg3ZmM4MWE1ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATr1V2Gx+pPgvuYdjJ+ULKPyEixPuK1jCvwdcFv91RdgD6T\nO77xIuDv3VpblnDLtX6gy6I1cfPjVl2WW/Qmn05Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrQOfEeaRov+rXPU5gaUyX39S\nlrkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMCbXazV24ul6zPy4QtVel1S7x/ZgDbQCKcTbjMu25osAiEA9ZZcI18m\nFlsPMbicFRkPjETQ14tPgU2dmOcKS6hwMqI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZSW1ZU5INtj2qe0/1g/ilmEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg2MzNjY2EtYjEwMy00MDU3LTgyMTgtODcwNzQxYjBkYmFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjlmMzdhNmEtODc5OS00MzUwLTgyYWQtMWVkYzYxOWIx\nZTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEND0DQVAz+xLRmYUjfh9XOXLL\nODLGNmUJtdQVrPEQ+XLfZvqUSQeuP8Xm7mwjXmjqJ5T/kPWIIxtNzVn6BzSzjqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU8ec67esU9tqmCvsslEvqbDTYp8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKi2qZcNXOlqxn4N\nVDuLZhW8ud1Q1630dq6F4BTIMGuaAiAzNPpyZ2IjNwTIOqpMQAE22/548Y0fjVKW\nx9Sqedzg5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2450", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2450` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASwWL1QDg5zFSKvNwwUML5IzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzNzc0YTMzLTkzNzMtNGE0YS04OTMyLTliMjI1NWQ1ZGQ1OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FiOTg3MGUtMjU1\nNi00ZDQwLThkMzMtOWUwMDVkOGZiMDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQX93DUB6MhnhwUvlb2slqwDfUm44+ec/IXzuo63mSjddMvFSiQhLCKerMs0Y\nIwHj0fRKwxSw11eKzRJdT13JMqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyZ8A7CQkXxtJ2Av47fSPKGdY4egwHwYDVR0j\nBBgwFoAUTfV8hg53j4WogoaHRjtDn9FftXswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD30EoTWKin3PB3WQgzcaFYbuGqKrOM1PT9x5UYMh5KGgIhAN/ZcDxSqF/T\nRXN3rMsuEc09Z0HkE2tb1vdptrPXj+1n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbSmepyv0+Q5xibaTJPVXbj1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzc3NGEzMy05MzczLTRhNGEtODkzMi05YjIyNTVkNWRkNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkfzc7+2J8NS2x/uMLg8I2C4qR3xhYquvAuHxgIjHP79ls\ncrXXwy0/f1vxfCaR+CY4iw0m5V7iWEOuO6zxUEKHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTfV8hg53j4WogoaHRjtDn9Ff\ntXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ/tJcf9O6dtdXLOMVzBDVuzCFxXY0QASYYE79KrPZVhAiBJA5qhPmXi\nQEFJ5Jz0Y1YvDwfYOWOl/3k+uuH4HIlm1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAU+pwkozhPe7yAC0V4vbQu/vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FiOTg3MGUtMjU1Ni00ZDQwLThkMzMtOWUwMDVkOGZiMDQ1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzNkMTMzYTctNWU0ZS00ZTc5LTk4NWUtNzdiYWRjZjZk\nMDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIfxshcord/0//BUNb8hmllXf\nUWzFwVfXBtHbSSk/VUgNSUXawohWCYMeXrO1Jo4bIL2pYhgGq+hXLe/eHnWWW6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyZ8A7CQkXxtJ2Av47fSPKGdY4egwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgWfKRbHf06Ai4JwxP\ngsX710VPcr51/lybG0/Khz/aBmECIQD6pa1UkWEK44E3U6yMa2xasYC/hrbDn7IZ\ns4IN1iwkzw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2451", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2451` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXF4X+coCrrGyrhAe62XVD1HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlOTU3NmE1LTFiODMtNDgwMi1hMmRlLWVlNTI0ZTNiNGMyNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgwZGMyNTktMjY2\nYi00OThmLThhNTctOGU5OTlmODQyZTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE59niOVSWUGBpMQ1xIHSKqz85olAjhc4J38Vh8L/9NSCIfI1T0MmNYgOFE2i\nwO0k7vsfOfNKQ5SHEn0VhSMmp6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdGaZrYb5PwvXDYK3GsQYgHjBQXEwHwYDVR0j\nBBgwFoAU4a2ielU/30Cd6ql4W+WeRQ+n7A4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGTlw+RS1yDRpUwen3v6ovRhTWsE7FQWH/I5je98eOWrAiEAw7ksU4OcDhtf\nWiDy+EMFCJ0gPLhV2Y5olNAEi7KA+vs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVmNHWZ2619agVcDgdY2U+oZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTk1NzZhNS0xYjgzLTQ4MDItYTJkZS1lZTUyNGUzYjRjMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASY9U88/hksGPOd6YR+8KanEpvawQC3/8ymKU/TrUYQqBb9\nwoTHeYBQTAiCEhUW/4LwvaHkwypQQKF4GPnNEp24o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4a2ielU/30Cd6ql4W+WeRQ+n\n7A4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgawTkj0M+It7SR8NIFlO/cc1H1yzZADcC2YvunV0r2FgCIG0I4ULbzMt9\nxMlrxB+EMsz4uYDjT1836IQuGmfb7XJ1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZIcH+/KIAHqKZnnk13COYYfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgwZGMyNTktMjY2Yi00OThmLThhNTctOGU5OTlmODQyZTlmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzhkY2U2YmYtODFjZC00M2E0LWE0NDYtNDliMDAxNDg2\nNTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErulBj4qCE7g+//LCOTt0BezG\nsypF4atxMZEGh0TJoebIzWuHpmnvYTyuIjrN4mYKkvKJT2CioSmNIzp9sMo8uqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdGaZrYb5PwvXDYK3GsQYgHjBQXEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgXyOLS4IbyHY3aRHt\n262t1VYgHRFUgdjNQRCWh2Tvz7sCIQDkvhGHSwJt3cTKQ5ljNIUTLYKTmrttJGA4\n6JVCNCtcXg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2452", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2452` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAYssQ471hR4190QpVnSmtPEGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1NDI5OWQ1LTJmNTAtNDFkZC04OTJkLWQwMjE5NjRkMzBhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzgxNDNmZWMtYjI3\nYi00MmI3LTk2MTMtZWJmNTVmNDA0ZGJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdv/9czRxu3IIQWeKrMxWtXnJKIueDU76KBHyP8SWgcqBhtrbcbubFZV5D4rD\nX2WywG5m96QIIVmUpPK22Da8NqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxLjeRdDS2IKdX4AFColT5oWenpcwHwYDVR0j\nBBgwFoAUbslPht5pFVREYQVkTs9dKV5RcxkwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICUl\nFNsS5jcvql98ypYbXuxUbTyo1E+3R+WOLtONoUFeAiA2GYjgcOmms+TBtFLQeLVR\nZbCWjFa/i5EjdfQNKFY2fg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeAoVn5ShdyY3lEydBV3PDIBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTQyOTlkNS0yZjUwLTQxZGQtODkyZC1kMDIxOTY0ZDMwYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLJGSthb27cBw5S1WXmXE+BrVy1uSC0CbaMjQUTHGPvwTq\nEBFNmpGk8mtRdOqP/y6k3yMT8ZBvtegV1qdtl/ufo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbslPht5pFVREYQVkTs9dKV5R\ncxkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP2ewzXVGAKe774WHoLZlVF5Vk1VWScAJSR4rHOr74zUCIQChhOY1hNHw\nLSpdkg9uzlotbflgRwvdgkqfXTWdknB2Lw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAUfINjkCHi486Pk04I5wvtY8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzgxNDNmZWMtYjI3Yi00MmI3LTk2MTMtZWJmNTVmNDA0ZGJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGY5MGU3NmUtYzAxOS00NmYyLTgwNDktNzJkOTcxYmIy\nNWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5VbOBJmmf6/qXrNTmbwhsAge\ngVwxQ4MCxFZthhVdmRuOmgJz++9PkllHpSuhTuiYj0jmGZF1ZTtSOr9LgAkZl6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxLjeRdDS2IKdX4AFColT5oWenpcwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgHIN/H5g3FLtTsgZs\n/b1p4+6tax80UoURAbIr+5xsEUECICEjrjv5DKH4PFJVSfW4Pc1c29cG76pXgA03\nD5i2BhI9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2453", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2453` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAXFSfR0slho40VW8sscPhPckMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxMDg2NjkyLTgwYWEtNDZjMC1iZjY2LWMzNmE3NzM4OTcyOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIxNDRlNmEtNGQ0\nMy00Yzc4LTljMzctYTM1MTI4OTExZmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE83urPvXa6e0Tp5c53AiVX+rrMwj2FP2vTS/vZbnH/zkc9Uu5cd/pXF+xLVuc\naT//Yo+j1sy13flTVjNu8CC4bqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuLVKsTt5iLAFGdPcKEEJyvslNGowHwYDVR0j\nBBgwFoAUrds26lshzO829odLbQ1HzECkkDgwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGA3bV4RLrS5Eh6nQurTh1oipvJ/Fnp3bLn3S3+MuESvAiBeLZh0\nJwK8jk98Ntb+hGBEcC3s3pmxOjTkbfGnCyF2NQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXD25P1zRsuq/Mw+2RzGqM8mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTA4NjY5Mi04MGFhLTQ2YzAtYmY2Ni1jMzZhNzczODk3MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHBofR0Cs8fz27aMR7Cd99pZd1vugHdBSPWifVi+P/CU20\nS4Z4oKBebgSxGgb5bTKn196KRFRW1NrXPWZawyOno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrds26lshzO829odLbQ1HzECk\nkDgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSE44I1hm1DXdPR26rtbDrrPCoJvDycQ0uqW94CfCb8sCIQC0aBq0YxeV\nwJcdcVKKbhSe/3DPaCd7E3lllIrAAZqBdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAcFe66bhMVObbHtwehIQSRznMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIxNDRlNmEtNGQ0My00Yzc4LTljMzctYTM1MTI4OTExZmI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzEzYTI1OWItMjRkNi00YzU5LTlmOWEtNGE4ZWU4NjUx\nNmMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaG6TsLdGKsaeZTQuviUITtmP\nXOb6Dk4e4cb8NC/SDZ/edcC6I1nvkFD2k6hPxkfatnebxlAZ4O/s6p6MpReCUKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuLVKsTt5iLAFGdPcKEEJyvslNGowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPNxVe+MDKT2sars\nWt/fM2DtdWke9PNSDBpxCWq+1gP6AiEA3w0Uvmi5yCsqPywKryhQ6cbELdZHL3Jq\nhwzAV/hT3lQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2454", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2454` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZUgccFnR+y7NgFX+BF8UpM9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhMWNmNTBkLTRhNWMtNDQwMC05ZjMzLTc2MTQwNjBiMzljNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDkyYjdiOTgtMTlm\nOS00MzMwLWExMWUtMmUwODc2OWI0MTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETFsKentOAEY6CICtFMLQ+l8+WQPZdKh6hyQs/54r7NDsAKhUZUOcHPi08XUe\ncIf9xuEt/NRCTH8MCMOyiWldLKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1SYQGIAIiFm2ssSKrw1j7f0+bokwHwYDVR0j\nBBgwFoAUFe8GS21oQN6gA+mF6dDGDmaJVmIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCICKkTSHAaNydDixFqV9xerNNRorB3NQ2u/EjcT5caFHxAiEA2Tis\nmzZZK9/1QJQvfWDvCS369t1vWCQQs7NuKf33x0Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAac3WKAna4OQoRNaP+PA9BJMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTFjZjUwZC00YTVjLTQ0MDAtOWYzMy03NjE0MDYwYjM5YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIVeOwzPD13pN6jbGM3D/hBHxdjlj1yauSRfygMCJ7nBZD\n3NRbIWwMbjGlXSTZ80R7Rpn9koIMaMbCz+gEb2Jqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFe8GS21oQN6gA+mF6dDGDmaJ\nVmIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOJZcXrY0xh6dQCMFUz6OmXY9ZZsoQpgXAUfH/1NvgRhAiEAzSHHcWM3\nyuEU0an8STHrqTr74aW5ZaLTpTdTzd3UtSg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZ0Dq2JmpaO1DPFy5/p6YDrTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDkyYjdiOTgtMTlmOS00MzMwLWExMWUtMmUwODc2OWI0MTgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTBjNjAzMjUtZTVjNC00MTU4LTk2M2ItMDczMDIwYmFj\nZTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQO3YaBMCdN+rTlVemaaBde/Z\nNmwD6gU3la5W3+BspZEwTH8bYMV9Ji4SRrG2SOZkvjNwpr7Fpm2Zrka4ChpP1aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1SYQGIAIiFm2ssSKrw1j7f0+bokwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKeZHFCHKS+UfCEW\n8jzPhqgXp8w2xy97MqDBqJXeOV+pAiBdA6VN0qnNw9vwisSE6xCNNGezMnotkqkv\nAHgTlWXJPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2455", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2455` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQujf0I0F2RMWiZWF/p9WWEmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkMmM5NjZkLWZiOGQtNGFjNy1iY2IyLTJjNmY3YWFmMjEyZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI0NTgxZGUtNzBi\nOS00OTUyLTliMjAtZDllMDMwZWNkYjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpHVRseid4PHxBQdhiiH1rkDo27pogf7DKqAPR4vEVs90PKaiDBiYjMwwakpW\ni0rfybxblFpMWOcxTLoNAZ2zYaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC5tAv4RWnU2BQjlk0gWkRFLMXaUMB8GA1UdIwQY\nMBaAFOGryPr9hFMHD1Hzhzcyxlyo9ARjMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEApAw28Wwz7RAjNMtZcgky/OPhpuhntkHZ\na4pNN9cgoeQCIGEJ7PKYkHRiRkn1pBWvY3YLrSrKteejCBc/hwPQiR6o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaV6kiMZV5tshPthtRZVCEiVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDJjOTY2ZC1mYjhkLTRhYzctYmNiMi0yYzZmN2FhZjIxMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2a7RSHDeuUaNaViXe3BgpSYm2jIVXbzGTKxe5e3MFVhyg\ns4vukdXC2HneEVZbAr/bqV5GEcZQWqQwtHNGtQ+qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4avI+v2EUwcPUfOHNzLGXKj0\nBGMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKOQNg71jWwRKMtU2AurCrnCDLZXMNJaoVzGkOdCPQRgAiEAiRAGz/xo\nTcCyLhOha/zlIbwQo7DN1RtyvX7a+ggfcUc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbRcc6Lea+iMTUL3IvgDoOmcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI0NTgxZGUtNzBiOS00OTUyLTliMjAtZDllMDMwZWNkYjE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTdhOWJhMTYtNDQ0NC00NTE1LThhYjEtMjczZjRmOGZm\nNGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6HNMvaYmhDkvvC+NBnXTp+y+\nrbPXOYMdyfdfLhYVCYi8U5N/l/pS53l425wes5TWPmhf0wTXL7pFXre0ijlhaaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULm0C/hFadTYFCOWTSBaREUsxdpQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgEzJ5ahDDaN/emija\nrMq9qvX/+5W7X4u8dSP6RFnpKuMCIQClkPNWHE2LDdokwG8GBXrShg8eUoCOjB68\nov1WJVMXTg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2456", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2456` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAeEH2waBeVIDYuYciEfyjx46MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NzIyOTk1LTUxNDQtNGIzMS1hNmJlLWZkYzAwMTRmMTUzYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBmM2RlNjYtM2Rh\nNy00YzQxLWI4Y2MtMzZmMjU3YTEwY2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE15bJv8jhT/vTBgZFmNqmUkf2zTRYNB2aiBHVurbtMvJs7kBwJx6w37TgrPIr\nus98xyKRYC3s1GhoBNOEwyXDYaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIXbTmv0l5U/Up95UJWaszo+BIGIwHwYDVR0j\nBBgwFoAUDE8Vsaot3Ciglq5nbWPu0ZLgowowKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgcx7S+J46g5bg\nOvyRNH8T5KJih6apAtqnGZqrcQEh9zMCIDlcJEdfgugIn/ugpKjEyQjp/gvF/TSe\nJU0ffKdPrC9D\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATvHSWmwm+5z4cPczw7sBijwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTcyMjk5NS01MTQ0LTRiMzEtYTZiZS1mZGMwMDE0ZjE1M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZPMSGno+hhaurA1OMiJvmZu6tLmFHgOhox9Q1CBrb3pkb\nXtTb6ISyqWrQkjuLHkq0dv54ZD/YKlwFw1VZK4tmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDE8Vsaot3Ciglq5nbWPu0ZLg\nowowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMubN8JfkzvQmRTSESO+UOMg2hv2xjdykf4atd4/nOSxAiEAt/fl1xEq\nuXUW7hGqdI33aJcOfEUCBfIU0HIGAMKp1Wo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAVUFYUWLC5gcXIk8kpioOEp7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBmM2RlNjYtM2RhNy00YzQxLWI4Y2MtMzZmMjU3YTEwY2ZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzNhMDJiZjItNzI3NC00ZjVjLWJiYjktMzJlNjdkMmY2\nYzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4twch1pQVSttKRUPIGpT65sn\n/y6ieRc4lHwWt478aY82iMU067/M+hkU7YmjlI69MgWyOVqNwfulEjUxwinPI6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIXbTmv0l5U/Up95UJWaszo+BIGIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANivBRjCOir0l9Bv\nJvTqCuJqL8BCJJEaujlMmMDg4i7wAiEAqBjRt5I4TiAP4IEgg8j80lTo8BB89UIH\nWtV8+wYZ7PA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2457", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2457` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAc1CGhhuzpYyVYzRqHgzjr0uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MmFjODAzLWY4MGMtNDljOC04ODNiLTU5ZGE5MjMwYTg3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y4YjUyNGEtYTQ0\nZC00YjE4LWJmZTAtN2E3ZWY2MGFjMWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw0VhKa9cSgWtCrWRFBt2Ly5HEsDwLP6CP5DHeCCI2QfJbfMGGBhJrTghY8iH\nz18u2P0fURt6oXoViQnVnmPXpaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlp3uF42WdyE/rofrG7IQwGzl80AwHwYDVR0j\nBBgwFoAUJ4iZHzho9AEcpOWj5EkZmvPn+yUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIgUBxivoM0s\n9Sp2zhZXZkuhscBu83aEVqunDfDk9kxeAiAgOVua84Fp7nX5NxrYR12igj5lGrIn\nVgVx3P1iWGDv7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWSQ4uukR/uyKJ739wel/OczMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjJhYzgwMy1mODBjLTQ5YzgtODgzYi01OWRhOTIzMGE4N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/yueegWLKB4k6OP+3SxIgfzZITtrlRmXEy0kPAJIHMg/H\ndtPxIk4dj2V+ydPLggxLdW5Qny46l0v73JNj8XeFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ4iZHzho9AEcpOWj5EkZmvPn\n+yUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJmsdaK6pWujN9qjLHk2pIf2X/Catf1kQvSM+2anMP3QAiEA24DOpWLg\npkk+gNFtYfxz1kWM44/6DS1su0+clUvYVOI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISATAi3dnamYFvXEhlud9fowuBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y4YjUyNGEtYTQ0ZC00YjE4LWJmZTAtN2E3ZWY2MGFjMWI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjVjM2Q5NzktNzgyNS00YmY1LWI2ZjItZWI2Y2U4ZWE0\nMjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmTQCrJFryJI667kEMffIq6Se\nF6tRbdzyJge4Bo08Mthf11LzQW/bnFU2yDEICECy0Q32EgADvtV2FkzLU/xVF6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlp3uF42WdyE/rofrG7IQwGzl80AwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgT+cxs59DiboGJ9eR\nwwRAkAVyhV2npdTDr7bLjVbCsIcCIBuSD+X56LxUM62gbujV95qLIwykcwTNsmHv\ntXskaMKC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2458", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2458` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAcbPkSEdqw7bIewJmNOUWeqIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MDhhZmIwLTI5NTctNDJhYS05NWE4LTk0MjQ0Njc5MTc3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzkyNzg2OGItY2Yx\nOC00OWE3LWI4MzgtYWU1MzVhOGFkN2FjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/HBVB7egydVNT2TxJHG9XUxg7NWRugifcT0CFGbmcV1b0CUAt0AZ+pg48M7D\nshsmJw8C0ko+RZMvl9B8js/hraOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaTgyUW61VgkkkV1FZtyMoNB/yXQwHwYDVR0j\nBBgwFoAUrKtszEL3ZovXeCNFsMU1diAzCzQwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFzD+cS17Z/M\nV2ZjEwvzZuHonjvcr82IZf0mNau5Z2JAAiBsS7GLwCu8e8yRQGW8cElvH1EZ4h5n\n90HKKk2mB7uJgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR1aqrFHD0U9BFJj+8KsYLxRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDA4YWZiMC0yOTU3LTQyYWEtOTVhOC05NDI0NDY3OTE3NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9jcZ1ZecppExGMIp1jSYOuQtdzj/jCtbnpXJUbL0pMXsT\nxapQ8eCa3vbJJ2aI01HbALFGSvjLr4f1F2rI7leho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrKtszEL3ZovXeCNFsMU1diAz\nCzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKuGlELycdsy8qk0FhiaHrNnu0Yr5r6SsChDzwYVlXFwAiEAkDUDTgvl\nOFqLjyLUV0SrTQxyT4pQRosIz0UIV/RPPJg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISASd8yXlamfAGUjeHL6IUS7wQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzkyNzg2OGItY2YxOC00OWE3LWI4MzgtYWU1MzVhOGFkN2FjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmY2OWQ2MzItNzQyMy00ZDk2LWFiODMtMTk4NjUzMzM4\nNjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEINtK+P+M1y+8aDQfN/6K3lba\nJDz6TEDx4e5yM4/9CSPE3VZ2w3o+kly1vvEzFhRu/Pe7RDDRAPfGqhPfkw5P5qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaTgyUW61VgkkkV1FZtyMoNB/yXQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgDtrB9Ta11hktTiAW\nybNjkrKvAYzJyNn1hJ1oncx5GOQCIEUKDCpcloncZ81tybKQccItNqA8ZXJEq8Ky\nL5VFbkZw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2459", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2459` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdEd/pvyDTuBmegvK7LvsgF1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkMmFhN2Q3LTViYzYtNDA4Yi04ZmM4LTQwZDcwMDc4NGQxMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ3ZTFjY2ItMDAw\nNS00MTQ3LWI0N2EtMmUyZGNkOTA2NjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcrugpEtUR8r4JYZObJZ9CIBK5bG/wQJq0bENqSYfbXxW8VWfEsWLPMXLB5+E\nQU6rIklrkDvkgtjgzU+4le8qdaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3/YTxcXpp8tnFlcC5IKCX/9gr4YwHwYDVR0j\nBBgwFoAUeJ2ExlBn4UlR90mFh28mMrEmftIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHjLkRZA/EeO10a0xEtzuBbZoSUVIPIT+qXiJWUUg7lRAiEAnCSvFfSkK5OV\nUhYif8L7Zc5MlAKKgjt3HeuD75NNpp8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa0fsrCqILEtllcVMUOUCdY3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDJhYTdkNy01YmM2LTQwOGItOGZjOC00MGQ3MDA3ODRkMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThTYmMr38jzBaj26Uk+r+ENNALNTDjMw9qFHlcu1gg6Oxa\nkYaivq3U9xnpJq2OS9xoVk6q0gDf/xxNovLh/ixyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeJ2ExlBn4UlR90mFh28mMrEm\nftIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIwzLbVhJ327whMzH+pFj1iouJHb9tB6l/EUAT9ewfY9AiAbKhDe0A05\nQGW/twX7Om0qeo5L0Q9qm3yzVgMya/Fztw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAfvJlc1yalzVbx4S/ukb12utMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ3ZTFjY2ItMDAwNS00MTQ3LWI0N2EtMmUyZGNkOTA2NjIwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWNkODMwYzEtNjYyNS00NTU0LTkyZDctYjYxZmE2MGFh\nZTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERRc7FQfKidIWTQrF2BJyF1s2\nGfKhCgO32hFliwS1y3/H+U/6taHveeDjidfXsb3um2MmciZCr+uHG6wkcMlORaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3/YTxcXpp8tnFlcC5IKCX/9gr4YwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAM+X1otzy4WYofZz\nQ3SzUgPX1w3kXwAEzNPtRuXiKHkmAiAk8x9AEyyxFKoa2l8sHxKoKR+JsaqnvmYZ\nZomR8qupJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2460", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2460` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQ6erOEVeYPDsDMtyjJyli06MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkNjA0YjAyLWRhZjQtNDcyMi1hZTZiLTE2Y2Q0NmRjZWU3YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FmNjUwZDItMmM3\nYy00OTI2LWExMzktNGY0MDkzNDE1YmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfMFZ+MnaPahPbD045i+KPpIChJGyr6+ZpDxu8sTWrINPxw2FGPLd5aq448gi\nAleLzQAbx+AsV1VolxCwvHcK5qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTQxrmEaaROps/xFok3fxCRyXabMwHwYDVR0j\nBBgwFoAUrHtdnOQ3/Nmq+qb7mWDNwbZA+n8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDlyDTbdId/hbk+jsMUw7J7izOzgZ98NqD8JVvWq5srFAiEAnASm63QIzMRx\nln427p1FGNo1fhLY4gtWcqaB69hYHAY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATeiO4JX05zazeG1ysk7/96LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDYwNGIwMi1kYWY0LTQ3MjItYWU2Yi0xNmNkNDZkY2VlN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcX6f6kOsxRXc6cJGh6Bf8+F1Bi55n2BCFsTH0XC/0mTCz\nIH+W8OzccnEXs5aL3hYo+bJp+MhhBDaJ9HZLI0JLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrHtdnOQ3/Nmq+qb7mWDNwbZA\n+n8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB+sVCPcTdAjLzNVT4El3We7dFQtec7skhX+Ccf30lzMCIQCp+vAT9SvW\nJxOUIzDqSfWfMjw7fpDlxXhhH9DgPfcBXQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbGWo4XlV9ZWLfC7PyT5yJuNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FmNjUwZDItMmM3Yy00OTI2LWExMzktNGY0MDkzNDE1YmQ2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTdkYTMwMGUtNTJlZS00YTk3LTlhZWMtNzU4ZmI4NGZm\nZTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOOWdNyb05z7K7HFMYxWimUb9\n6mmotFx2I64V7fj2QuhHTUbNA36ylF6q558WnYktj2Al0Qb79vMoZMSzWcVrxqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTQxrmEaaROps/xFok3fxCRyXabMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAM7OALF0kLnOSauJ\nsBVyxW8qFL3UUb/rdlbfIFXpTJGIAiBs9p19spbycZ4bXDZmBA/W4BFCFVihlKAr\n833kA5aALQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2461", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2461` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAXuBEfMkQ/Drc6IDSoplXBwGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4YmFmOTFiLTFiOTctNGQwNi1hZmI5LTU4YWNhZmRhMWJkYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJiNTUwOTgtYWJk\nMC00ZDMzLWE0ODMtYTZlNDk2ODIzMDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENjDU9rprywlD8oBYWNP3suqoHReHxnsrhDVZFgLTVKpbLyFMpOEqLjPxzMnu\nGJllj0BGZmr/Zjv/ijACNZrKq6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHwDzn+YggRuNyGOW5gpkJJb3gHYwHwYDVR0j\nBBgwFoAUCU5sdjtWVVSl5tZGGT0eX3q7T9MwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCO\nNy15ODUxGEXTh4JGKYTsU9yohIomb2ICK2pJkOGQtAIge1vdJUhO6ppIudi9KLtI\n3CuaqsIDZZTlynpSYOZ/jhE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdUVzmhHVpyaeiOvQLYuG1qVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGJhZjkxYi0xYjk3LTRkMDYtYWZiOS01OGFjYWZkYTFiZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATARrr8ouKaG5YHsqQFq90bxfM09C8I1iHj+LnKrD69dBOh\n5oMSNXM+Fs3J/AIhVhqbqWBP/KDvF0uTbrX/Jfi1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCU5sdjtWVVSl5tZGGT0eX3q7\nT9MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIFetEgV5wrPBFLVVtdOIsac7QyqXftP3VeN9acp7iytAiEAjUPTFKVn\n/u4zNanTbGgYPhyxS3nWtCtl8+4NGPCoyWg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAWLGgDcoYPBjaEplEyR32OwQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJiNTUwOTgtYWJkMC00ZDMzLWE0ODMtYTZlNDk2ODIzMDMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWFkZjEwZTUtN2FlOS00ZDAzLTk4YmUtYjEyMWI2YzIy\nY2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvb/TfoXOrcWkV2duryhukjXK\nPQE9HkWFC7pfii59X/kHxjXgKT5PJvfVHdyTrqQCYX0hA5isUeWUPKl97FKByqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHwDzn+YggRuNyGOW5gpkJJb3gHYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJHvWp9a991Z7wHx\nOwuZUOygGcsoROeY92d5QhqjHj2vAiAfcedtNQuHgqLHUDTIcG+4Mkpwp/KyAtcM\ntOaTBfS7jQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2462", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2462` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAQ9RmNgcnEdwKrhDNPoH9DLUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMDZiMjY1LTgwNDctNDMzMi04NzE3LTgzOWMyZjY1MzcxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmMwNTVlYjUtZDk2\nZS00ZDY2LTlkMTktMjVhYmYzN2NiZmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKxCkJLC+OruUkUsIUhQwDVPCN8wtCB3Q+oYWGPL15GB6HO940YdIeJVwTeoy\n4NfAaCEPcGwsfnUaMzlu5cTH0aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUazfjE7H8fhPBRpEaVw2yWaX5DsIwHwYDVR0j\nBBgwFoAUBMlp5eiLYogH0I3DgV9wmxilA3kwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIDAf7pEpLUp4ixXZT9Q3uR7hUiX/Z23xCf2m7est8W0hAiA6cXdo\nRDqCfbjMnilSxi0923I7wBl15Y2h64+nbS4I5g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAegKwYL0j1YXamVZ4ud1zFq5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDA2YjI2NS04MDQ3LTQzMzItODcxNy04MzljMmY2NTM3MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATESK5+DjBF2jGZ/ogLe4HRBRr5uCaNjHO89tMfZxmGLmeh\nCsLfLsyafaKgFQFVuqzVE8bmJVOLkLDHiLSUWGDwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBMlp5eiLYogH0I3DgV9wmxil\nA3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJXgO/VOZwZWiuJdF3xNNkD84PFhEZ+04gPyqUr9mVLIAiB2p0Nzndwj\nkoQeRxfr1w+3kkNgQaT1IHCcscSIiBUvFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASBzgB1XetnLfaUgwK1SEnYdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmMwNTVlYjUtZDk2ZS00ZDY2LTlkMTktMjVhYmYzN2NiZmFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2Q4NTdiNWItNWUxNC00MDljLThhOWYtZjY2MzQ1MjU3\nMDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5KN3hLcQxSXMhGysJeNaF7gF\nndIxrIBNDDREQOn8WFGU26strqu3Dh5wbCyIvKAKnyvfiSZzyj/jC/KMd+IQ16Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUazfjE7H8fhPBRpEaVw2yWaX5DsIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIej0dj1xYFIkKt5\nPdQ4fl+88N+Kes4Q0dEgFpI0NkcsAiB7JdXUFWRgo2bIni1mmjIpmN+/o4Yorz3T\nePx98A6E6A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2463", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2463` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAX0T7UFAZ7dVizyta0Hodw+KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiYmJjMTJlLTcyYzUtNDc2Ny1hODIxLTM5MTUwOTE0N2ZkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU0Y2U0MTUtODlm\nMS00ZWU0LWI3YTAtNzMxOWRiOTZkOGMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdYgvV1VVHSTZNzuXvPOIVav8d9UWVb593XXeCT8CdLVRNv7UZ80PfdRpa+Qy\nuAb0dJqCWr/BaWOAk/e1MojzDaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZC31gRIIDRHX9/Gbq3Ar0bq1Dk0wHwYDVR0j\nBBgwFoAUvb3uKex4GyYEOeFyYuMOimrBowMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCtfaxlMGOT3p+jzTPqEVSPLkHZRUbIDhLjJhvBHaOuzQIgXNha\np2jpbvPFqVIO+yInMlRv1GgHDUl0YX/Vg15zi9U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ9XlvmTavLP6os/+7QcVJSSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmJiYzEyZS03MmM1LTQ3NjctYTgyMS0zOTE1MDkxNDdmZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmwQJY3i+SJ4KaBI9ridjyzdFQmx2MfrNDRfYmcdIVJOWN\npxhZacHYsJRcZ1trY2ZIlyIdo7y9v8KawsrXc0l8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvb3uKex4GyYEOeFyYuMOimrB\nowMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO012g6vwj3n4Pp/m0D7iTDlLKjjGg7ajYMxDByizTpJAiAcODO7mk+i\np/naYkQ0gUDkL+5zwv4+HT6QMoRMA07S3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAea7eEj+zeWj0Tgn2WsV94iNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU0Y2U0MTUtODlmMS00ZWU0LWI3YTAtNzMxOWRiOTZkOGMzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjEyMTVlY2QtNTllZi00YmYwLTg4ZGItMWNkOWY3Yjhj\nMDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdCeNNQz9JidPJChciO4cpImy\niYbYBqQDcfmRZY+LnOnC90cpIpBJz8clpouc7265AnOJTrh7MmX1F3Tfjy5O86Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZC31gRIIDRHX9/Gbq3Ar0bq1Dk0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgYCEkSRx2tKq22EpN\na1XL58X2rBnzoXnWJQ2tanPDEX4CIA758rh6VOMiS9XVcnaULUfgk2F5NeIwgGm2\nZ1StQ40q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2464", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2464` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATM/2p6xgOmBJFC+HIdfbiGwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMDgwYTY5LTEwZDQtNDI3NC1iMWRmLTQ5OWM3MDQwMTk1NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVjYWIzNjctYTc3\nZC00YjkzLTg0NzgtNDRhNmVkMGJmYThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpEQZljepeYiWqAhF2wQOU2eeWf5PDaeqKOQ/SUW1buHUO0nvDIrQaC24pmiC\ncyRdf6Z7Ubx8B/daiUPgv7N7i6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQOsph4cj9DnTtRLECuqMGa7EOulTAfBgNVHSME\nGDAWgBR+mg10LL4765Qw6HdQGfXKXOgqdzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIG2UgE3RMbyn3skTHZ0GQ1pyJVzV99DU\nSHdR7otaV6BTAiEAhNwXraB+jI7rYP0o/VPssr2KF9pnAUiF/E2lGK6fL4s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAShLLpOufDN9gxdO24kJZdPuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTA4MGE2OS0xMGQ0LTQyNzQtYjFkZi00OTljNzA0MDE5NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+ApEx1VY7Ka5/znoeeRLYaKTBEOrNHa98fd4D20JGlGfA\nhbiOpo5kOYvhRU7mh+6MMdN9bv+oLaNuAasIIEbao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfpoNdCy+O+uUMOh3UBn1ylzo\nKncwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTwvxCowfnAy6Izl7dgAHAkaqptQLWKe6wOurSsEi0YACIAehaDIUEGU0\n661qPIqgICJL6Tfu8/EtzPpZ2qC2QQ5b\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAXSVKEbJaW3LO8RI4hb9t739MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVjYWIzNjctYTc3ZC00YjkzLTg0NzgtNDRhNmVkMGJmYThkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjFhODM2ZWUtNWU2OS00NTM3LWJjODEtY2NmNDM2NDNk\nNTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwhlPaEsu5sjYHvcumP68ws2a\npPeg9yZi5X1bD7M6DY/uJNVaBhd77r1cCbgfbGiQc57v2MBuW2695FeEkMpSNKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDrKYeHI/Q507USxArqjBmuxDrpUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgQMkGtzdxVY3a4/xt\nAG2Y0qnTYBnKGWYsIxFu9nlO154CIG0ZWSbdcex924KYW31wXk4k0zKi75pb2E4I\nm7M6TBAW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2465", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2465` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATXhDR93qqs4vLCe4xNvtNRjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4YzQyYTQwLWU3OGItNDJjOC04YjJlLWYzZDEzZWU0M2Q2NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ4NWQ0NjYtYjcy\nYy00ZmUyLTg0ZTEtNzhmZTRmN2EwYWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcCIPtSyo9eckkXUPhzraRKGbiMk/1LvqSZPtp6JtWawsWvgztvtFpPsRCPt+\nYgdVvQyShy93IwovuH9GnYG7nKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVsv/fJ6gf3zqGtrdOjk5RmF7yLkwHwYDVR0j\nBBgwFoAUYL/eHDvNNzdy5eYZ33oKIbqkOOYwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC6x0rgYo8w\n0pUeY9mYbRQ8OL6qSufPgIyKQoLs8tL4kgIhAJu/qm2JohJGCbijPhc/Vbu4r/5+\n6jafmG2+WuoB5KoN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfwxlbcMCh/qMJhZgzlcNZX6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOGM0MmE0MC1lNzhiLTQyYzgtOGIyZS1mM2QxM2VlNDNkNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmBwn5U69F/bdSgu9ctbKXUb0u9c4V3UMBzusHVKz92/Av\nQv4B76FgvLixjiX+plMZi6RQzMmFn5fI2tXm7dato2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYL/eHDvNNzdy5eYZ33oKIbqk\nOOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMMhcwQQKqXeCxDsB7r9xj9zoIqyfIfj93mG43H091WnAiEA2xSroSEv\nCGbM9YKZNW37MOwZIS8yIewgpLsZLB/+zrA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAXCXIl59FOQMvBRe3KfR/h0TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ4NWQ0NjYtYjcyYy00ZmUyLTg0ZTEtNzhmZTRmN2EwYWFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWYwZjUzZDItYThkZi00ZTYyLWIzOWUtNGM5MzFjN2Qx\nY2RjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC8OpbHH6TxDNoKKNoeoOwWf6\noZBclJpVNptU4tsdWV8GZjKHX8s1OEcPyGWDU1WzdU9Akix75JcbaPsr9pPNO6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVsv/fJ6gf3zqGtrdOjk5RmF7yLkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgMLuzIVqe9xPYeF+b\noI/2wT+j/wCUPptHWWmKH80pHqwCIDJAglVHlZZqf7shFzqeCnnCtZkEf9A+mpen\nEJcipy9A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2466", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2466` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAalxhHP352CmTevRO6aiJ8YqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0OGJiOGNmLWZlOTQtNDRlYi05ZDIxLWVjYmU2ZDEwZmNiZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NiZmNhOGMtNDc4\nOC00ZGRjLTlhZjUtZThmMTczMzEzYmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEPjAb/NR29RYgwXk5sd1D/YcyZAI5zKgCejtLH169ryOcWcli0tPgs/SkZbU\n6UtsdKfHyq2fINRNIGTO6MZT56OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF8grhOh+6UhwnbvikobUm3v3hRkwHwYDVR0j\nBBgwFoAUe0SLbK7xvblAB97pBDWVMZ3eux0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDAlCbdSGeD\nStVWM+q5G4xLiJuA9TG5thwQF02zOjL6HgIgEhEtbcLCcCw1gz067Nr9UjeI3KHI\n5BeSiNxQXz6B9ak=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdmj+kJDXi9S7zaqRel4MvMAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDhiYjhjZi1mZTk0LTQ0ZWItOWQyMS1lY2JlNmQxMGZjYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStb/G51L2JRI9VmgG7WaUtI5aJn2Vv6jjcxlZckFGnyp+l\nYiGbLjD8ZBA5kmMNr72dfmecGbN3t04EW+e13Wjvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe0SLbK7xvblAB97pBDWVMZ3e\nux0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKaRJyl3TQcO0SSod2+MY7A5ojRu82NfkhdMw9OjiGeZAiEAkAunkH9k\nlDDMzeg8X+PZM3GBu3Dhc73yYHcv/15U2g0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAZmVGgOX05pIVvA8SUx7iktrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NiZmNhOGMtNDc4OC00ZGRjLTlhZjUtZThmMTczMzEzYmM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQ1ZmZkZjgtZjMwOS00YWQwLTg2OTMtZTRjODk0NzFj\nNjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkuju0ENYXkte/dCmiXwilqbd\nCpFOzNYLoOUtVBhqNwbxEiLojQgTg+aJV2xtJWgUOZIE67Vc7Wg/htnSBZDs+qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUF8grhOh+6UhwnbvikobUm3v3hRkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgAk5ND5Fx6F12TdNL\n5SCLHYZd6FaTa37NJ8xdMxeeNoECID851AplDEtbgVhQHluxr2DmDpdJgH14CBi2\nsMJkxanO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2467", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2467` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAezc/x0qignqEnPjWQoz9q1oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzZDgxZjJkLTVjNDQtNDkzZi1hMjAwLTg2NzE2Mjc0OTNkYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODAxOGM1NTAtYzk0\nNC00OTk5LTg3NjItYzI5ZTNmZDc4NTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE59y7lEq7t2DMOJpisRmFt4NDJuObpgw75SfpAW6bwPVjzQNk6KXjLUOHNK+X\nn/l/F1iApoIPbfQj/5CTe7nllqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPmebok2u+o4bleFdDFcBF3sBc+0wHwYDVR0j\nBBgwFoAUxVzHSVES81NGVvPyrQTATytcg2MwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAyK82yUFp4\nDjZbyUBKMk7mXWWsuEfFiiTgJVGUUySntAIgcxDGbdA5HFEsuLKlUJTEKigqcBuy\niLkBfgBLsTTi8fc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdNYWg/LFbL1D2cLouDe4EsGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2Q4MWYyZC01YzQ0LTQ5M2YtYTIwMC04NjcxNjI3NDkzZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx0/pOC/qv3ogKMCFy7RpR7Rt4l8YBBhR1lKFujwn2bshd\ny8EFQDBgZjgA4MnVSZeWaMtA7BuqXbkTN5B+pUDeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxVzHSVES81NGVvPyrQTATytc\ng2MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf5nps/yDfnHCgiDPSE8Bg4aUoNTeBkl06zBQZO95PokCICQ7QOIo0Ehc\nJncNmqGNzmFR2WSj0g+L34d8AKKVtde4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAakMzCypmIs0aFnBFUhCyg44MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODAxOGM1NTAtYzk0NC00OTk5LTg3NjItYzI5ZTNmZDc4NTk3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNThkMzM4MjctODUyZS00ZmY3LTkzOTgtYzE2ZTY3MDM0\nY2QzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVHUMUAFZrrxlUXcNbg8I4xuc\njm2Tuxnpu/cYkW1ao8m2DaseJ5fY5m1WlZxIyHYvSGQBcXphJ2W3HWQiaHDBVaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPmebok2u+o4bleFdDFcBF3sBc+0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgcjqyr3PQuJx63n3d\nCdj4OzhPPGrW145984vXvD2sRUQCIQDHmGv/U5OdoN39Hd0TDBToeXNXCTXzS6vA\ngbG1SoNBZw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2468", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2468` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASBplFCzpCSQFGBAxzg9SXHiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMTFhZjc4LTMyNzAtNGY3Zi04ODJjLTcxMWJiOTU1OGJlZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QwNmU4MzQtOWFi\nNS00NDM0LWEwZjktOGNkNGE2MGIwZDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES54e8WSUXIM5oiyH9N0kIndC6ovaYhHR5sB2HtT1G2IOl1kr4BbiLWKWZGq9\nsu9EUoTS37+LFKMVkfZRQx19I6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULhsbdVN6Ta8FXhAlSrJ05pzZLa0wHwYDVR0j\nBBgwFoAU6+t2ERkezRrKfcMm6nQnRjyoPOowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiA8+7/GvTAEBH/A1spqlINZtv3Y//F9Cgdlb1ERN+1E8QIhAODtGILZfDEt\n9U7fuOYKsj8dt+W1R76Pbx+s8DwoBu4K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAViLTbX+AtqwpcpWJ4FiDAYaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDExYWY3OC0zMjcwLTRmN2YtODgyYy03MTFiYjk1NThiZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvo+IyH/Rp+cOgWedur5b8POoqLZEZY7tcBFfGFByNeH8C\n7i84HDYM55tkUb/Jsm5XeYEbturkde6OPc01oB+oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6+t2ERkezRrKfcMm6nQnRjyo\nPOowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf8F7wwfqZj2i91HdbfJnLpS6/6rDmr+icZoxN1ZZwesCIH2FkAHBYpa7\nfzAh8+8IiDIyNUGNj+FpiDgxe3rSwbyh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAYclsDpobT9jm3w+++DKqDsbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QwNmU4MzQtOWFiNS00NDM0LWEwZjktOGNkNGE2MGIwZDdiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmFhMzUwMmItOTNlNC00MGVlLTg1NjAtNjQzMTA2MzE2\nNzc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUjkhP3WbYqCEQWcxORnURnoa\nG0+WOIB9EV5b0dQiqrY27maxqclzP62zlskiVf0VIcGqKM+CDjb+KxYWITtNvqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULhsbdVN6Ta8FXhAlSrJ05pzZLa0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgLCUI6f/ay3gqCJ7u\nKYuH8Bm2cDPEbAA2q3Sw+L5iaT0CIDL+nGcz4iH5AEtjP0D9XyQf0qSwjlZIKPCb\ncwGHDiMw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2469", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2469` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAaYC2E1EMevz+cVIE1T9iDhnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NzUxZmJlLThjOWQtNDZmYy1iN2Q0LTFkMDYxOWY3OTI2ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFlMDI5NzctMTEw\nMC00ODU3LTk3NWMtYzI1ZDAxNTU2NTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBMSO90rTO/QQa+ojGhm/saXMxxX1tjCM7DBQxYA/aWzPe0r4dUsoccNgS3xT\nKXWtZJPliRF4srJW9EHUfzX5VKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXsBu1C1+JtXlH+KhzYpbf2y1iGMwHwYDVR0j\nBBgwFoAUaBLvboHjLJm0x+dt2/D8Iw9bQ28wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAp4I86DACT6yKsUZyR3GfYmnKN2vP4MxnfYhGXrXc9hwIhAIqmf4CXk1dz\nRzi5MMtH6ysmZWX6P+qLVlMWNrjyFIXK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUf8Ao+8JWnXOEPoeHZB9n2BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTc1MWZiZS04YzlkLTQ2ZmMtYjdkNC0xZDA2MTlmNzkyNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIa/mkG6/dUrz775dAXYQuENJkr7/ABvWEPqfxXcicWIYf\nD96u4oDjUTH4a/xjkZNT68cGtP3m63Gbjrd7AJtjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaBLvboHjLJm0x+dt2/D8Iw9b\nQ28wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWAcWw40JgJqMRP+4/B1ELYaIUMdVkr0ELIZ4C4tawC4CIQCbpo9h91zp\nIRTPloThA9/5Ea2nl0iNnzkbdEmyo1aUWA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAVIuzeq/DmfsY0f/5c2Orbq+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFlMDI5NzctMTEwMC00ODU3LTk3NWMtYzI1ZDAxNTU2NTMyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDYxODY2NmQtYzllNi00MWFiLThkMmQtY2NhY2IzNmMx\nZGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZb1TZ1hNBOO9H6QhYoDw/ods\n5/PNTjgSdLOo3n0JfZ8IbJjxIz/YhfQtYg7iUEnQ5X6x6X++ER+rm07Mi2BFJqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXsBu1C1+JtXlH+KhzYpbf2y1iGMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMV7/4TQ3yhF+cII\nUoB7oAAzELG/oQtGIp3ClPHshveMAiBzfOlqHCzZTRRTTej4mD+EZOIszTKoi02P\nN32YJqvk0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2470", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2470` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAe3lza7Km4DZ7TOJumy/apI+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwYWIwNjEyLThjZTctNDQ1OS04NzM3LWJjOTA0NjE2MDAwZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTEwM2QzNDEtNWVl\nZS00OTdmLWI3MTYtYzcxNjI3NTZmYjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2dkL2hkY0mfWv8rRA8reosE/PWQnPwvvtdUvAGoheT56D7HDsDLgHw6cVo2f\ncS6AT6iRyYERHADXCtoBe0EsnaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdo1KqcLzCFxpHc7diQ6sNZxlpnIwHwYDVR0j\nBBgwFoAUQ07m/unE6janTsVEiUdzhgBbFFswMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\nltN77rxa/g3tWCH00jTDtntCVpFoiJlJ4y+5s9fg1g8CIGsv9WkySFQIpVPduoK7\n5RZxsMsO26yQ/jC/v1PxH8Aj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa3/1Q+Mqs8h7BpIU4UZpilRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGFiMDYxMi04Y2U3LTQ0NTktODczNy1iYzkwNDYxNjAwMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHLMz5/tzSzU0o9uLF/JnPwV29FZlDMFJoLoZUnIhGu5xz\nVNGTDr3yijm98fW/TR0fM8QnZV5xLhGxsCvd9Niyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ07m/unE6janTsVEiUdzhgBb\nFFswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK/B7Wg1/r87bHMOkhy3v4pPpeoSo57XoFmeczHwUPbTAiBXqeUsGWAW\n1oNOySyxTjjDG4iKBqk5VH3L6p05h5X2uA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbckuECiDoUy1y57xOxYX6CHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTEwM2QzNDEtNWVlZS00OTdmLWI3MTYtYzcxNjI3NTZmYjQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTc5MTA4ZTItMTBiZi00Y2ExLTliNDctNjcwYzk3OTI1\nYjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqIFJnAI+HD6evASL1NDZ+L/M\nJmMphBPCS6QGAbyfMTwvnGPvulPkZSrE9MWPGsQfKh18uZLeKe5ap6isz69S+KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdo1KqcLzCFxpHc7diQ6sNZxlpnIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAI/XLxzZJs7WBoIR\ncIl6agMjsuNA0vHmY74oHnREapU+AiARTR87q9+P6ntxf0iKHo+aac6ToSVI/IrV\neNWeL3h2Xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2471", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2471` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAUrxrl67wAAix73F/67sB8KoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5MjI5YjYzLTFkZDMtNDZlMC05MDk0LWExMTMwOTE0OTExODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhjMmZhMjQtNzM3\nYy00NjQzLWFmYTEtZjUyZWM0NDg1MTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMk8rLAJuiuwm6DghzDRp2kNHIytOrVpBXB8qdYq+vy9R09KDjPtAbsQE98YG\nT53rfIc0SpFZtFo/z/U1brnw5qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUbmdpJRVRrxA6HW9src51uFgn24wHwYDVR0j\nBBgwFoAUWiPLKRy5fx1knk+oOKou5D63KlMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiANgYrMGqrKGFCcjTe4u3R8IMus/nRJZqle3aEpcgMJ8wIhAJvv\nBeR03hDvy1ihRY99FvHFqRsXpzYc+Upgpry7J6mW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVNi+VzDyFzAvXcUmiDc2dbsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTIyOWI2My0xZGQzLTQ2ZTAtOTA5NC1hMTEzMDkxNDkxMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOVAsm/V7c1uyTnNpiq6JQLJcJ0hGodrvOk/uqB0K5twLy\nEIaLj5Vlkk78ASFVCHsezRCLxosV9wyUSkhLQTXJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWiPLKRy5fx1knk+oOKou5D63\nKlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUDeq2foYchgZLNJ03jXFXYbaI3J7kNy3WeqdqYbzL8YCIBHmQjFG9XUe\nOm6WIkcchfhaRMR0Sf3QcjaJ2fWfvXW9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAecJtJnKXEyxr2ssKMJRl+Y4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhjMmZhMjQtNzM3Yy00NjQzLWFmYTEtZjUyZWM0NDg1MTMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2M2MzQ4YmMtNDJhMS00OTFkLThmYmEtNDc3NTczNjhk\nZjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmws2JF87344o8oM/1jiikIf3\nBuhVjZDDq7um8Xi1kWUxNgE1dq1+HhfmKd91VjFaHPnXLpINMGafj4VdzaUWwaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUbmdpJRVRrxA6HW9src51uFgn24wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIKaVoh9A+AwyELg\nVM4vFwklEP8xU1nda1FesbxwpBvJAiAmp1WXasbJp1mnr9IFtuN4obGLdZN4ugjT\nyFg5BuJqJw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2472", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2472` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAUNpxq4kPz8ck26ZRo1/jIIVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllN2NhMmI5LTRmYWQtNGNiOS1hZDZiLWM2NzNiYTllMmY0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNhMWYyN2QtNDY0\nZS00Yjk3LWFkYjgtZTI5ZjVjN2Y0YzNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8Mmugz1aahZXs1ZnMjJIigoX0/lrCwH79cvpq7fZMTeqvgogZ4BQ0i1HbQj9\nNt14GuM8G4ZC+g80xrgTsKidT6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnGSrPUNSxBAXbYrrdPtFjX0CvuIwHwYDVR0j\nBBgwFoAUpbiZdEejO0xclFXaNIP2pBBk24gwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAx5gdsDQSkskw4Nj/1BEnqm/tBvKwE4eYDDFMpx08GW8CIAfz\npvDinYvqQlRqFG6Ryl1TyqClwKziXFPs46g/JuSB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR1R2eJUXA+jAm3zBoEy0NQOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTdjYTJiOS00ZmFkLTRjYjktYWQ2Yi1jNjczYmE5ZTJmNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0mGf/olU+Z31+4Y2I5Z0a1R0vdKu7fW5B6Cb6D4+d2Gsh\n3AC/0/LclD3o+7Lpm2Hhv83Xplgvjdi1PGGOvCiNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpbiZdEejO0xclFXaNIP2pBBk\n24gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbq2PorjNe9ndMu+IYPqOqQE5qvCvTUoF5XzQ2ZP+FbYCIDp7NrPzOWAI\nMYwMZvsnKpoZjAA9unm7losOUPHB4k3h\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAXn16koJmkDVouB6eLRUGWdnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNhMWYyN2QtNDY0ZS00Yjk3LWFkYjgtZTI5ZjVjN2Y0YzNmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzYzNjM2ZTUtMmQ0MC00ZTBkLWE1ZjAtZTBhZTI4M2Nk\nMDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERySYfhr9zCykqy1SoPRdI7MV\n7BmBtF3k1cSJOeZnY22O6cCY1NuyOl1RF8Tp6W4ooc1Qj1FoBF97Vrt94bZwj6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnGSrPUNSxBAXbYrrdPtFjX0CvuIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKa3Ba1LCKf/yfYn\nZs7Ok6DP5/EC0ouhODm/hLS5HDiQAiBtVguXJ5sPoPLR9b8bJj2tNB5IZWGJeds1\npjbNSpg6Mg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2473", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2473` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAZ20xEeXagP/Woklo8PwqLkDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4NDhlNWU5LTViOWEtNDFlNC04ZjQxLTM0OThmNmM0OTg4YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE1YWM4NTAtNGE1\nMS00MmUzLWFkNzctMWFkMTYxZTA0Y2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX2EnO/yEXCpiUpkHvqNsIATPqN2+AltUZf5Gf2WjEuhblWwdpYrwxitu6pCk\nmhTTDOMd89SKRJNVDfS8wYQEK6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm6GxROJC5zJewnl9ydHXUSY/2h4wHwYDVR0j\nBBgwFoAUUZsW01Faw5Zca2DS4+gdEpFCx2UwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBq020Vz1/neS8Z\n5hK23KV+1lG1yv2CfU4C9ly4CF5kPgIgcJeObSx71w8dRW16m02VmavlA1a2OReT\nXol0m60YcKk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASfoyUIheNcI5RyodnaJZvnmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODQ4ZTVlOS01YjlhLTQxZTQtOGY0MS0zNDk4ZjZjNDk4OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjlZg8bZ6Axh/sLqPsay6EeSKBaXBITMA5oE7kuLEIo9Ki\n1tPdaJPe2dwIdrVPfYVFVObK//YAecz2MJAYtBgco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUZsW01Faw5Zca2DS4+gdEpFC\nx2UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJcK9xHWIcG8HQFCQbIwvEJGfwXRynXJ7+B8XobSctv5AiA+6O1nlvqm\ndm4n586AP2BzysS5OOcCeTITmXC6OYwqZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAUYe7G5umVXstyRH68nxNY4pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE1YWM4NTAtNGE1MS00MmUzLWFkNzctMWFkMTYxZTA0Y2Q2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGMxMjQ5NmMtOGYyMi00ODFhLWIyNzUtNmNiMDViZWI3\nMjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaMlJ2GzizuX9lN75GTfhllQE\nTGw28AFos0uk++hxULtcO698cs6tOeq0+6V2xFT3MC52xNAOtjS/Tz2wIrOwGKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm6GxROJC5zJewnl9ydHXUSY/2h4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgd43pNXdltw+h68Db\nPGXVuF74hjfpWNQpeHgKUEkYLBkCIQDZEDOoj3nnXxYjrJO6k+C27gv+PrIeXliI\nkDTI6+S+Fw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2474", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2474` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXKOQvVS69L2jDEVapjXS8QMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzNGQyMTcxLWVlZGYtNDNkNS1iOGZiLTcwM2Q2ODA0ZDYwNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBhMWIzYjgtNjBl\nYi00OTNiLThlZmEtNTNjM2NlMjZmZTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7XYpSRu7fIL5jmCi2NVzufq1R/9JONGpAT3jWvxxQC5cUf7PIfEcPAKgvVsd\nC2NwzPXqgyMeNqtjBkzYd5iWR6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOLnJIxaNDL3WgdqxbriAJVoHqtwwHwYDVR0j\nBBgwFoAUXqVmqD3VNIhDUybjx56T4meSBfwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIB5A/+74nbR9jB3CU0srw0V1whI+wdnyAnsbXjgLDjC5AiEAjsc6djzRKgI7\nPfjfFjl1WBiIrGEOHSfOT68NAgy+6MY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR7FvnHqMHplm9JeWQIBcKYNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzRkMjE3MS1lZWRmLTQzZDUtYjhmYi03MDNkNjgwNGQ2MDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATclvDAOpLFE7HbHwNsfMsGvJLUWAaIv807trVyQW5Sf67l\nGt99jjypXgoYAYPdmxLOnuSZQswZyNmOlUAK4c8No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXqVmqD3VNIhDUybjx56T4meS\nBfwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKc+XWNROI90F+4Uk0aEC+1YoTB6nZS+k2N8mlFyOoRsAiEAhHFa7p0H\nu1jdM+vLnTxHCYh5tbgJ+V7VBFhSEEbHhKg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAS1JMmMP/NaMswEgYC1zl6KXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBhMWIzYjgtNjBlYi00OTNiLThlZmEtNTNjM2NlMjZmZTdkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjdmMjA2N2MtYTdhMy00ZjMxLTlkYjUtNGJjNjg4NDUx\nYjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyw3jI5585S02mAxhVOFthTGZ\nXRJlRckNDWs1gux+pa2w8TZz2+9gRIrXqxly6oX0aaqxj61WWr/b0CLmEtT7vKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOLnJIxaNDL3WgdqxbriAJVoHqtwwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgcQhlGJrgi7rXaUCQ\n/49MNQyzd1NXrpndbZvhdhzirrkCIE2CYebc072RUpZJl6GH3YcI26F7on3dBGas\np47sn65U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2475", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2475` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVa10LyrdAhrIe6Hf1C6a2W5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwZjQxNTQ2LWM3YWQtNGRlZC1hMTBjLTJkNzY3M2I2ODA3NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIzMTQ0ZTMtMWNi\nNC00NDcyLTgyZGUtYTg4MzM3NjMzYmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBbbkRcx5biyxxaAqAcw3CJWbyWylkYYH7A5lAYOhX/A+x1+dWu7/ff2AV4Cf\nn4jlLYuNDW0uhVjoyDqReJy+WaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhMW7hnYCNyBQ5UYkMWzP/pGBwYowHwYDVR0j\nBBgwFoAUgm8CZodQKyE6CHxurgwFgYMEkJYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCr6BxaWVeJvhgBlZeSlS/hGb0aGaqeDD6DeIYyjnBD6AIhAJ9LkWe5HS0P\nRAl0t1xfO0AsxJdHEu2GEnJnCZAuiOIv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXlQH+QQcxC4grraLLPZFIpzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGY0MTU0Ni1jN2FkLTRkZWQtYTEwYy0yZDc2NzNiNjgwNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKSrVQ0gR2w7q/PRappaRooyJPjKp++picQBtJOVH6xAYt\nRPS+cFZgDKI+UyCv1fkiVcoGazIZTDt+8uqUO7nEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgm8CZodQKyE6CHxurgwFgYME\nkJYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPsBrm3JYjV1WuWvdOPbSIDSxJMUeH5Xfw7tQ78KAsYsAiB+jjiExebi\nspJC3haaFl0fY/9trz/Fu3TSAfP5B1oXKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAWe7drvXDX6mrABPTh8r4FRlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIzMTQ0ZTMtMWNiNC00NDcyLTgyZGUtYTg4MzM3NjMzYmNkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJiMzc0NjctMDZhMi00NWEzLTliY2QtM2VlMmNiMzRl\nZjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElzectAhxuxYzEMjKZjMTenqK\noTqdTeFZnhr9m1dRlIHq9kNRgmlKP6n9raKnwYDmRGEWG3GpyyoCt1VCgxeBNKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhMW7hnYCNyBQ5UYkMWzP/pGBwYowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALQBuuU4QZGxzJt9\n+XFwDZ1ptEhGaC9R+z6rNMVCn+eoAiAaZHT4h1OOL0gUw5S5Zjl+kDm080BDfgrW\nw9IgajF/8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2476", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2476` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAWOIvZ1HtJXtBHoFMU+UnJt9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4MjhiNDlmLTcxOGQtNDQ0YS05ODk2LWI3ODViYTA5YzY2ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM0MDMxNTctNDlk\nNC00NjA5LTg2NWYtNWJlMmU2ZDU2YWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/HnT03kRUGLCxJkK30WPIuPdtilUy29drbf6HrgMS7XfqVUMt9XqyPNmGz9S\nci5RBS4d1HNZOTJqswWSh1Cv7KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzxw8V/2K9XOFgOe+wXQFkBdB4mMwHwYDVR0j\nBBgwFoAU6w+eLAkiTEfFuLpOYl8pvYRo6xQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAvYiq1I5//T/2whIX/qeBnNWsSfFH5lm3VcExoyjLNjMCIBZRrvuEn63h\nhwiMKXds88yu5fVDVO8UcqPaeFnZrKa/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb99gHiigKG//MtYi3a9kFNnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODI4YjQ5Zi03MThkLTQ0NGEtOTg5Ni1iNzg1YmEwOWM2NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgqkKmGzaRpdDoZuHNjuO95p66bGCRcGvQG18IGAqHK4Bo\nZVdnmIN1zW6O+71+xxKb9fRrlciW9jFt9cssfYcBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6w+eLAkiTEfFuLpOYl8pvYRo\n6xQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHsW7hlAJllNBdGGCdlwuplb4EUXU5662JAClS1t8Ie0CIFuiIORVlUNk\nyUXzG+b96k5VH4Wy3le1KL7O0AP+8Uam\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISARhFY/AkO9l6L/06Io89VF4XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM0MDMxNTctNDlkNC00NjA5LTg2NWYtNWJlMmU2ZDU2YWY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWM3NDc2ZTctOTdmMy00NmY2LTk2OTQtMjFmNjVmMTBk\nNjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPo5Sd71nofdBEAOqKsuuV3dm\njG6s0ODcDSWJU+o2vdAiIoPuhgN6XCwyUlUq9XSGLD/FS5zoGl0wUrtGASbD/qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzxw8V/2K9XOFgOe+wXQFkBdB4mMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgZVVSVF7SNg3ujs0f\noZQoPeiShvoikSNm+00qfp7mptECICjHqLrExM7XUDlPEqY6DSj6vOjAIm4O7ZpR\nTMGZXcTW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2477", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2477` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAchcMek5giZx65uQaY3k8gfwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzYTRmMzI4LWZjMTktNDBjZC05ODk0LWI5MWI4NzBjZWFmMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODViNmI3ZDYtODc0\nZi00NWM2LTgzZWUtNDNmYjA2MWJhNjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQXw/hYME28dEa93P7pduS+oRZOYJLm+bYfsvvJ89hKu0B49xNyRWPcbXXP2j\n+5NICF74anMSQM94fHVPpFCeD6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvnKTKmLHKywIIZ2IDa34/cl9NZ8wHwYDVR0j\nBBgwFoAU3S/0tXOuiUjt/mK+WIbHbwPHxsQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAx53uE20WsFExYZmuWD0wzc7Ja/yVAbQfpHGoVTHlz\nLQIgKjNS41bLP7yFgbE0xa619UFOLmYqAAwUFUIoi7z85iA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU7Cep5WrZzkN0He/1IhPVNGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nM2E0ZjMyOC1mYzE5LTQwY2QtOTg5NC1iOTFiODcwY2VhZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqigehiEwD3K08tm4/y6A+6AuVGYQ3z0Yahnino0yZDhXd\nDiq87vRPcbpUFJI9Prbo4FtGQFw/+duscnzLu0ano2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3S/0tXOuiUjt/mK+WIbHbwPH\nxsQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO+B2bvXFY9WvfP9XnVzVX0JevEzLaVha287jLk6kRdqAiEAkxEDCa+y\nZp7oYMiOkvK+9X2QAhYoByBEEXdUEoJTKN4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAY+xxfgjojtv6tOeNDFoltBPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODViNmI3ZDYtODc0Zi00NWM2LTgzZWUtNDNmYjA2MWJhNjkyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjE5ZDUzZTctMjgyMC00MzUzLWFiODEtMWZlMzFmNDJk\nMjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVZyFgF9vuxgrP0vni7Ue3nDz\nM/Nm0pP14rYp66tHlq52qAMeGAXTtuDys6oPXVsyL3HxvZgMdp/O8pa9vs6hHaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvnKTKmLHKywIIZ2IDa34/cl9NZ8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJ/X/545vzGPtA/t\nzkADVI72aJR+g6DSB0/lxfOhTrm5AiA3mscS+8k/WA0BfH7OXG/qJgbRRHpneC46\nJGP4LxTrqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2478", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2478` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASmN3dkouXi3fZmJVX2WLwUTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzZGZlOTE3LTA4YWYtNDIwMi04ZDBmLWQ1MzUzYTBhNzFmZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk3YTM1NDEtNTVh\nNS00NDA2LWI4ZmMtZmRhMmNiZTk0ZmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9r7+7JNbAKfwMJdQgLx5kacVi5elBsf27VODf5CLQmbzvkA4r3jgS5hFfCax\n9y4GKbyYboop5mILrU+SWAp4sKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVUKsshjSP/Af4IWXB78vgjK3UXQwHwYDVR0j\nBBgwFoAUHgDqUu63ql1zUCHEyoLN6s6NhxEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiA4VpfP283XmfU6Igq59NNteIRRwiQJ701MIqYpVo7/\nLwIhALQvZtRvPpxvYMGWd8bKwzH5ANbtb7u55dy9JQNOHeos\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVX7ceKPIXqjNWRLV8E3+x1nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2RmZTkxNy0wOGFmLTQyMDItOGQwZi1kNTM1M2EwYTcxZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASskehHJV6mirdgrklJrFI+g+E6PPZFCn2acUb2hokb5tMN\nzvjz+HtS1NU0n0jEM21XewG0SpFZNSeAxzNsCkl5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHgDqUu63ql1zUCHEyoLN6s6N\nhxEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALYdfHEZG7bEOahd5Owdt2WNi9q8jydRXz0xqYp1WWRmAiA+KsB9hdeM\nJOLH0aKu86A0N4TN1YUAbaU75KeU1e1TKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAS/7WAadU5MLvdaxHW/UEDJuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk3YTM1NDEtNTVhNS00NDA2LWI4ZmMtZmRhMmNiZTk0ZmQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmNlMTk3YzItNzdlNS00ODI4LWJjMWQtM2I0ZmZiYmI3\nNWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdJ+ItA3dWEzM0I3v6yDEVEz1\n4Ar+MN/OfMp7KbfK13JVtOK4eDhK3LrMjloqpklthvcboVLNWQlFq1qV/e6aYqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVUKsshjSP/Af4IWXB78vgjK3UXQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAP0ZGom4kcS1G0i8\ndKbcWiXVjK0aXBhIdpCUgD7Zu4xYAiEAgbxIsl3tzZFeg3wIWVV5H7MjeTvHNf8F\nnRXMvtKRguQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2479", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2479` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAdbZPDUig5gbKwGYRuvLH6seMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhNGM5NWE2LWNiYmQtNGE2MS05YTk5LTljNjBlNmZkY2FiNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ1OGZmZjUtMGQ4\nYS00MDE3LTk5YTgtNDNlZmExMTk1MDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3l2dbKSAiKyoaPqBuW+u+o/cJeFG6nVxx0jPxOUXOYmtaG94K86X3rlj5FYE\nPGii8CGh/V9wJLqR36YsBucm2aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU06HmOhL8FZwdvUl0Q90L5I21jbkwHwYDVR0j\nBBgwFoAUNMSexmRgmOOXxMD/XzrUdiUGDjUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBE68zoXo7jdOylPPftKASZDJqE6fO3PxfPgpY0OloGNwIhAMj4\nU+Rw6Y1ZLUC/hvVdeXVGCeN4gUWTCzdHZc3/WAxr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUQKTdX5Pw+q8iAvgDRJF/RmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTRjOTVhNi1jYmJkLTRhNjEtOWE5OS05YzYwZTZmZGNhYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm7IHF2IUjJh3zY0Kb3uC50HUsYf1xEicEWDoprAfbzyai\ne3wu8ptNRLKB8RVlFWF/uyHAVQDT3dbZAaBAEl17o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNMSexmRgmOOXxMD/XzrUdiUG\nDjUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVyW07zzFsr+BYHLG28bHWwdSRNJLv3M+P5wbIoaixjUCIFwcUYbzygOJ\ns1WXuegeZdsPPzLVdVl2izXiRuJcX5CZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAVpsTEnQbarm+hvBwXCtNMXOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ1OGZmZjUtMGQ4YS00MDE3LTk5YTgtNDNlZmExMTk1MDg2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGRiYzY1ZmYtYTA5Yy00NDgwLTljYzctOGQ5MTFjZGZi\nNzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbiKGGzW1L0qWpUsRE+W1B8Cm\nTIVnQWJr+1sB0xa40UrN8M5aTTaGdhS4hT5ZFRXnBEkgYCBWOWaMJQ4E+cty0KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU06HmOhL8FZwdvUl0Q90L5I21jbkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgFYdZobkzLedsl3Sw\n2c2o893xqaEdCmJwhKedVfGZu6UCIBq2WSeuz61McUJwq8GEZ4dALX8IwupMkpR+\n5zgnI5YC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2480", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2480` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdkX8ImPbflEdbvlPiN+yw3CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMTRiMGZjLWZjMDMtNGIyOC1hMjk0LTUxYTU0NWMxNGE0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZiMDAwYTQtMWIz\nMC00NmMzLWJjNTUtYmYzYzVlZmJlYTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy6E9Q7YYm/OCL6O5jRMo9vu2eCn8HMJQw9BrTWHQ9AN4bwP8ObUj6wV2uT21\n6VVoACXvdsgE6qthLhkAUKfKiaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFMutmBIeFPn/60IYO3zkVF0Tmp0wHwYDVR0j\nBBgwFoAUbDp5IBppPP3sm5kUdwmY83g7a3AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA00HXZsCvuAIOAL39ZUPtjV5rrPkRS4t1\n8Zo+EDUpsuoCIGYKIIy7UKIO8nGcj9MXs3ZLT1tf01J8UDzR9CVEyli8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASdCC8ojMkoUF8AJxuDwMucVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjE0YjBmYy1mYzAzLTRiMjgtYTI5NC01MWE1NDVjMTRhNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXof9kvRQm+Grj07qpoRISuFesvTqGcgoVDuMM6TRSOz0f\nHpY8Ay3aZZyF0v/n4feGYaHFzdeqSp3iibQD7899o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbDp5IBppPP3sm5kUdwmY83g7\na3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAImFTCy/wgNtOTLHGPAPqAIAURhvu8wJJouOhuEZEu2UAiEAw35PrnwR\nSKCG8wFwKdGrNFCQSxnJA6nmPGgg498qYp4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAQLAgt5Dw5zr8/NlarbtivwMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZiMDAwYTQtMWIzMC00NmMzLWJjNTUtYmYzYzVlZmJlYTc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDU1ZjVlNDEtOThmZi00NGU4LWExZjQtZDc4MzYyMTYw\nMTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHWynShbdCBEb/FtguxKPqoNB\nK+SElPVsYAJaths1one3oVOd1rVLhpNzvx+sHqvgS6gZXYLZTkmI7Cv8PqJoa6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFMutmBIeFPn/60IYO3zkVF0Tmp0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALZz4YyMSicZhjc7\nTY/7HhxmwyXdiUdSSjazhjhJtpZUAiEAnu/x25q2yH8+wFcvK3Qej8N6vCMat2si\n10f+Vtm38U0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2481", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2481` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISActnwL2HqaMzF2tojhZl86UeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxOTExOTNmLTdiY2MtNDdjZC04OTIyLTQ4OTVjOTFkYTQ3ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJmZTI4ZjktODIw\nNC00NjFiLWIyMWMtMDg2OTI1Njc2ZDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4o/ELQK6IBXsXjEQUH2HjRyzGdt/NPpiUWVJqvk4ju5NS/Itwh0OOAfK9H4B\nuAtnf0fr2SkeeD9I9Jgpq8d8tKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqOBOEps61+YwMbJHXj5od8fPmnEwHwYDVR0j\nBBgwFoAUCZeDahHvj+hn80i3M65TT7n3eeUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBLdcAJmHJtGcNyw7x2gHIXg7w8xZOPICfi\n40CL1JvYxQIgDJaX5VA4hV8MJiBGwMX2UUy4+jm4avzGWYzAgE2zOdg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcJ0Xh70eVseULsu/kcdfpK7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTkxMTkzZi03YmNjLTQ3Y2QtODkyMi00ODk1YzkxZGE0NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDXKGtb2ncSn6/5JcgaHXvY6OwYfVWdJ7tZ2Hl+yNJ74Tr\nO1/FtlIL8cqphI6ylOpw1GmeM0rr0fZaY2pZ6pjEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCZeDahHvj+hn80i3M65TT7n3\neeUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKFFSOJEMyTrBD2pCtTRPaP8scx9iUYZGiwP9ZtDH4sHAiBK+kZ4OHob\n7TkBpf33EtnZ1tDcKXj013Fv6YHylcCEfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbdFUxh4RTAutbBOcsfHjbTtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJmZTI4ZjktODIwNC00NjFiLWIyMWMtMDg2OTI1Njc2ZDJjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjlhNWU2MGMtMzI1Mi00ODVhLWFiYjEtMjhlNzczYzkx\nNTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9hsYiEfi6nmms4NFpo6nfHHD\n4ffUq37pqtMAhOKOoqbjMRm60JgFEulFMusg7RY7lQvTfQrNNxeWy3kq+WxXeqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqOBOEps61+YwMbJHXj5od8fPmnEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgbdLUXwNcDmTyfns7\nLWwhLIz66bshIUr1jsTdlIUJ1mgCIQDrbYi7Ng4aANIDOmcclQSCv93XgEChAph/\nYzNktZ1DcQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2482", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2482` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAZFq8jp/zQRRT9cvUf+2ErBCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YjUzNTlhLTdjZTctNGI3Mi1hZTQwLTYwNjMxYjU1YTlmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFmN2E1YjMtMTQ1\nZi00NTA0LWE2ZDEtNzU4MzJhNDBlZjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVQmNKTYDtfxt4J5wgIwpfP5r9CNvm71GiW4VPZa+QzPdPoybyogmRByEugsq\nFfImePVf7pRnmQ8v6+p/12Tv6aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUslcd/Nh+bW+sXCHh5VSXSuTqkWgwHwYDVR0j\nBBgwFoAUC2OIxNEMyEu1G+Dalx7cNFpmxl4wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAibrZONM71kKZ\nDs+z2jAOcMcl3Au/jPSA4OY97L0fBv8CIQDrhIkvxfKiwY7TjqVEGvM9PsABd6BQ\n+lfXMyLk7F5Mvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWd3jO+luHi5B8fawY+mPpqPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGI1MzU5YS03Y2U3LTRiNzItYWU0MC02MDYzMWI1NWE5ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATH9khcOU6j5BUHwWyCmGW2AW9fB0Q302g0qm2uwELhrlU5\nWUcw/bZfUCW8O+0LwtrLEFb/UaRJhSjjaCHluDqRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC2OIxNEMyEu1G+Dalx7cNFpm\nxl4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTBaGLIgdHroRmy5VnW4KIhPHeg0gT9ddMXsPlHO8W1UCIAcvObksElHS\n4cbLsy1KKeaha2dCtVqGjovBhySvQibR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAR1Jt08gsMCy7BhmcpSaY2xeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFmN2E1YjMtMTQ1Zi00NTA0LWE2ZDEtNzU4MzJhNDBlZjU3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmYwMmRiZmItYzVhMy00ZjJhLTljMGItODk0N2I1ODYx\nNjE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOJyLbCMlsL01xJ/NkHGnhVxm\n3V++Xg2HeF54JjmxfU4hB/ie5I5NIYGU/ydbUYGYyiAFp+8c8i0/1dkwLMeVlqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUslcd/Nh+bW+sXCHh5VSXSuTqkWgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALKhGyCwxMLMj3jP\nMeVbTyYx0ie8byitj/HFW9q7liMYAiAJM2HML1DsYePg+OeP0fMeb6HJgi7C+7bG\nPRHgrLGC3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2483", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2483` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWiFXo/kgbwNZ1kDTonuWnjiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyYTc3YmRiLTlmMzktNGU1My1hMDAxLWNmYjI0NWYyNTI0MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA3NTMwODgtMDVk\nNS00MDdiLTk5Y2YtNWU1YTY0M2I3NmJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgCB0y05VzPoOo7jn10fH0mCmqk5oXlQPjiuCNUU2J2MFf1vv4ZfuVnU3LhQb\nXQiEbJXRaVMNEjCVUVqPToH45KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg3GitxqOF1aKOuSrYGAx8VxAkcEwHwYDVR0j\nBBgwFoAUDyU+m2FQDM4GWF4l3FqBMRQNxZYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD/cO6r0365NYoMORMNytSJH1N7LqlQsr1I+t+xqIJXwgIgQ6gDD9wYRcN8\nTb306Nzo4ytjo3yYXTOlCXctxHf3+Us=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW4zbUKo13vEB3AHRhzrEBklMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmE3N2JkYi05ZjM5LTRlNTMtYTAwMS1jZmIyNDVmMjUyNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlfGnPLNckSwDwlr4EJCTo5umGkfIVKWfteGO9cbs+5N4P\n2P4rFXXozjUvLUqmT0hWX/a6XMl5q59gyfi4IouEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDyU+m2FQDM4GWF4l3FqBMRQN\nxZYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMMLsG2UJmmHde8GPvL3FPckVpIAarlppewKks9A6F5cCIQCyasLAZqtq\nPOBCRn4nP0fuI3+l3LBfLUISO/JGd8WBPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAQVIdAK++NS58y9oH4OZ+AjrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA3NTMwODgtMDVkNS00MDdiLTk5Y2YtNWU1YTY0M2I3NmJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODkxYzcyM2ItNjI2Yy00YjVkLWJlYzctMjExZmUwYmI3\nOGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGq9DhEJU9ZCr8rPWKrKNmvks\nks/ppiaWP3UWhKK5H/zWJTkBtrlbf05UG02Z+PsBxDqKbFiyBlClYWHWE8hz16Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUg3GitxqOF1aKOuSrYGAx8VxAkcEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAN/qMH/2qYlzILP1\n7wcHL+I6Qt/HPG5ecQous594Rzw+AiEAxVFwM40oygx9WT49RqvBx0T3DxSREGys\nzkmm5Pe0p/c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2484", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2484` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQzTHPLvkxlIUnYhc7UCMsysMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YzI3OGQzLWE3YTMtNGMxMi05ZmI2LWZkY2Q1ZWI1MWFmMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI5MjNhNTUtZDA2\nNS00NmRmLWI2OWUtZTI1ZmJlMTQ0NTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECvqUeuT08nGTu08EGIsa7xxNk24As4lHQU3WR94fC194eQcdWPS94ZTJWDpy\ntGferrVonhSmNx6NR5GXgo+gS6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuqQMFkL315VpaXXrgg4O9OmZ1zwwHwYDVR0j\nBBgwFoAUg8QIT+VQH4T1yUrZL+d1iR1N2+gwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCID4Igmv8ubLmf3lUQY/LOIke9BeUVj/tBYdMzyruMEWNAiAs5tGVtim0L0YQ\nnCbh8YeUhbAN5cXJeyl/98CHPPQzHg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcjsO3dKmFljGYaHZrqP6ktJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGMyNzhkMy1hN2EzLTRjMTItOWZiNi1mZGNkNWViNTFhZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMnfwqjnWlR4j4cOw0HBv1rZ+G+8FMBnc+nqYJV4KyXzqN\nvyCGlDvHaH6mCj9xTCGtkIzXXyC5ns0p9NWi1n7yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg8QIT+VQH4T1yUrZL+d1iR1N\n2+gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMhDZALRG1/XDmIbM3G5I8PsVlTDcocVE82l3QqsZMNhAiEAz5qrtYNb\nsbM7xLsfsbEnRjPUVo6QlqaFw8t9M5QWXAc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAcGDBkiPVHzLMJpNZAUuNU0xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI5MjNhNTUtZDA2NS00NmRmLWI2OWUtZTI1ZmJlMTQ0NTQwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmNhNTNiNzAtMWFjNy00NjQ4LWEyY2EtYjMyNTg3MWQ2\nNjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESo7Ct7jbtzIGPAc2QoF1CNzB\nlOv4x8Z8hoK0I5czMsMwHs/81d4oyiFUSI7CeQ+R1RiMxUDaOAlYxziMc7/RzKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuqQMFkL315VpaXXrgg4O9OmZ1zwwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALZnJAtJam485qoa\nfOWhVB8DA8SBHZeQD3LShoCi3CI6AiEA5lJujjoquPpFxVFmrUl7O/OCwSpyd7Xb\neIsj9TN0Q8w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2485", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2485` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQY79N/Sz9qbVS1lKY0e4Hs0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNTYyODk0LTY0MzYtNDc0YS1iOWEzLTRhZDdiNjNkYmFiNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNjNTY5YzgtOTZl\nNi00MjE0LWJmNDUtMTAzNDU2YzQ3MzI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH/zByE/VhQ/6YWSMr1ki7YMu9gOEj85dOtL1asYsqZ5zq5FMtHyR06ZFD0fB\nN/xD6nHKDr0amFfxp4+am01igaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjFTT/I9LUezpeMncu1tcUZN+pP4wHwYDVR0j\nBBgwFoAU964U1cRCq+ubpuZzpJ2HZRFB6scwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBp/uxUYPB0j95YlsKIg4WCp4R0PvzKxNp38IYY5Wo0ZgIhAKW52PsOJOoD\nmZD/Q5/Q69B1PAPjp3ZTGDGgKoi/Jq94\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYbWkfaPIsMcgvExCAV1vTIrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTU2Mjg5NC02NDM2LTQ3NGEtYjlhMy00YWQ3YjYzZGJhYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQymvfljUPnEs1TAW/q+g/gDvWbQgxw7R93HTmBL5/2tqN2\nPBMawbt+e/DDeD866RZVNUpQ3v7dL7uMYtrpOukio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU964U1cRCq+ubpuZzpJ2HZRFB\n6scwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGpg6m3uOaFvUhuizxsdukXXKsp6TH8iD+sK4XGpULxMCIQDL+czLNr2U\nygZJ+JPKnL4DTP9eGiZUjzEbBbHM6Bm5Ow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAUGSvYFEnsCmbMDwXWQ+IDghMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNjNTY5YzgtOTZlNi00MjE0LWJmNDUtMTAzNDU2YzQ3MzI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWFhY2E3YzMtOTYyMy00YmJjLWFlY2EtMDA2NzUyOGU2\nN2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECNNfIJt2h7UibeoleubiHyTh\nLiacZQFrAyLJnKfA/UpGZXDBqlmOo3ljjPjfwkC/0Lk0KHAlhVdWUMpnBO9zYKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjFTT/I9LUezpeMncu1tcUZN+pP4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgbrG8tmnAAQFtM7c/\nWtOGlKEfQ8tnbqAUEhiWjIl1jxYCIQCAHxWxbqw1meAMkdpGKr8pm9z38hGYT6UK\nRuJAz3jDkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2486", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2486` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAWZ5lbXtdAklDqsFg5ga56nfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5MzFlMzc4LWY1YzEtNDQ5OC1hM2QyLWM3ZjAxODE2ZjRhMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ0NzFhMzUtOGJj\nZC00YmQ1LTk2ZTAtZGY4NTY5ZDhjMWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/rblGG5NP2bc6R2H51XUcuwfkQtih9AnYETclOaEsZi77T9fTMwvfEKUwm3B\n9daOl5xWN7tUz5FpP7MY+z3+EKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNOJqBgh9FowqWRWPyX7LKMIvheswHwYDVR0j\nBBgwFoAUN+/fXnf4jTgBQOVPyp/fLWoZBiYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAsOy24W200XDmgH3EwQXstFPzN9rP6iCCAQMGSaQz\n9SgCIQCT+21nD89h2RB3iUeUEcfkm5uPIa6P/DToUR9O/xAefQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVcMJGxLAVhXkKynOpZFdh0OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTMxZTM3OC1mNWMxLTQ0OTgtYTNkMi1jN2YwMTgxNmY0YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtzCR8ZEeVVJiE4PCDrTj2QjmUz+Tu8hEde2OpdFXnAzEH\n2ETx5Ur7wSHFA8EkyiAxCmjIEquxuJyxK4Q5PMtKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN+/fXnf4jTgBQOVPyp/fLWoZ\nBiYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMiv8JfXjurWsN0hs0sfDm5icl2qBKw7Eb0+O4N27ej/AiEA64XqVqoJ\nhEuL4tZlZdZEYATdKPDud1mNgeAYxULBgk8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAYRByPlVEumq/ifPTrEzotrwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ0NzFhMzUtOGJjZC00YmQ1LTk2ZTAtZGY4NTY5ZDhjMWE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODc1ZDgxZWMtOTNiZS00NTY5LTk3NDYtNTNkZjk2NWEw\nNzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOafR8E6RcRm6SMMnALLMyEjv\n8r1hfOKw/4tYL4IVuxKvqfU0nZ7ootUv3m/Z3zCzIaTNXRs/dUXGjlGF5YgM2KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNOJqBgh9FowqWRWPyX7LKMIvheswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgdMihzmD7nD/OvUfC\n/qp8olkG1NkJR9HmEi+jksa/dMcCIQCGKapsiuS4DOumI3jZ6TSAsXQhiNrLwwhU\nBCz/sy7BhQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2487", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2487` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISATWsCqaGxuH/ZCVrqDjuKsZ3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwZWE2MmVhLTViYTMtNDQyYS04YWUzLTdjYTYwMDlkYTE1ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA0NzQ2OGItZmM2\nZi00OWQ2LTg3OTgtNDE2OTk0YTAwNThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkplUHdpG+KU9kF0ruwePnQSF3Hv7KpMyI/tRH8Wjds3ZsJWY2ZZgIpyLvrra\nq3fba4hv5IbtIgHk/tUjsWr4H6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfErpPWo7TO37FjsZXmpw/nC7TsgwHwYDVR0j\nBBgwFoAUPi6kwBAorgM/9I8tHODFvB6zcmQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAnBHn+g9kc0vTpJEl2Cg8NVMiq4PUOl6FGuPxvl7h\n+RMCIQCyA9BBtGGN3pExtvnqpnJ06IiOZRLhHq2g6dQCDpCLXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVFdsFJjSOqP8954hX3jroDaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMGVhNjJlYS01YmEzLTQ0MmEtOGFlMy03Y2E2MDA5ZGExNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI5yAatvkabQGwn//NZ5zxH7kZLEosEoHNbRQPJkjej0rF\nEvJmg7yfijOTegjpQyddd6KZg6UNxlkcgIpnA4qUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPi6kwBAorgM/9I8tHODFvB6z\ncmQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALZ68mVx68pxdwR1NfjI/Vl7AIhvF8lmG4YLs5N4nghkAiEA5K4FjuZ/\nVQJusPaZ9DikL2dArRNdmacakkvcmxX86lU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAZF4JJLD1ukstiSHjnzMkxg3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA0NzQ2OGItZmM2Zi00OWQ2LTg3OTgtNDE2OTk0YTAwNThiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzNlZDQ2MDktYjJkYy00MGY0LTlkYzctNzZhM2UwNDBh\nMjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8/sDBy3RMWIvHbAkJdj78CIp\nlIvSK/HZP/H/Xru0yEaZabnP/j3NkODe/hHZP5+LKz90lqQtI9FFuI+5KZIzR6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfErpPWo7TO37FjsZXmpw/nC7TsgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgPtduMuHsMs85OiTa\n+Bg6rmO2T4Am2dMBDXlcp8xIBB4CIFKwwou7EXTL4dd3sEX+5ZTr5+CAwNiTYuKT\nMtEfZ653\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2488", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2488` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAaUknd8+oBOkqoFSP7cea0zdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiYTFlNjZlLWMyOGUtNDhhYi05OTNkLTJkNWM5NWE2YjhlYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzAyM2I1ZjAtZDU4\nMi00Y2NiLWE1MmItYmRhODBhZjg4MDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERgoUcEfZpFmREJmT3aCS+eVuTEQ0KR8GzyS7twybuc1u44Ftc5Df/A/7VBYn\nUnrSMSZUqrump5LTMWUhBpNaEaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxVHU76X4Z42pl4WDCkvHwJQs38YwHwYDVR0j\nBBgwFoAUlNDinLvBlluLPLIiIQ8vdmv394gwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA9bxZs030Y/7SFIJIFFBkmtj6PTYh/J27zme6831XuSQIhAKxM\nEI72U/LzDVJiaEPEE9WABLrOHj52B79aUlligmRO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeRFugpd/Y/H2z5yG7YLOfO9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmExZTY2ZS1jMjhlLTQ4YWItOTkzZC0yZDVjOTVhNmI4ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4pvXpFOdoUs32n2e63K3LHoEkXNvla712AoxPxfOGj9yR\nKUcd3G5nb0fvoj+rod4vo07JsncXYSvv14+RvY/ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlNDinLvBlluLPLIiIQ8vdmv3\n94gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMZHw4CerbvLo+PNS4T3C2JzNAEGU8BY9tkO1DWFBnjgCIQDpZbGYuR/J\nLl9OR0W/b1RrnkcNXgYIPbDiUfI/Vh2/Jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAYExvhwDdjRE0RFUUZIsAHadMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzAyM2I1ZjAtZDU4Mi00Y2NiLWE1MmItYmRhODBhZjg4MDAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNThhNTIyMmYtNmFmNS00MjhjLWE4MDItNjFhYmVlNmUw\nZTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEt7H0pPJtBtS57tLjuLiynT0C\nDjOs5IXTijuVXxjiJhX9CPHG87BQD3cEO/YGyyHzza/FG7LogQhy6cBM5DQgnKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxVHU76X4Z42pl4WDCkvHwJQs38YwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAI10BPzkp0MukAY+\n9sebMTGU40myKzNgzUUqBovvUjvSAiBQMSK5zRH7Jgj2T8Ox5LEE3PUrXzlogTi8\nA77hvEYMSQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2489", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2489` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAa939ux+bBpT8P0EuLKpCAnVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlNDg2ZDhiLWE0ZGQtNGQ0YS05ZDNmLTI2N2ZkODE5ZWRmZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTE1MTA2NDEtZmY4\nNS00MTY3LTg1MDYtYWZiMzhlY2U1ZTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV55QOf/imzebaIwtGHCNNzXPso17M03Yy6jo/LKMadUjKPxeKyWOfWPd9d8l\nhQLBRziTdPAy0Rf+2Y9dhIeSUKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJVoMpLYgXDRwucrst0WPzifOOJAwHwYDVR0j\nBBgwFoAUgMjWt6KvlLYEYMoiLzkdix5GbicwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAx74bXS2tZsOU4750q2oPCP44R+jQu3Pr\nQLLbJltrJr8CIEc2YG/tw5rJ5sBqLCc8RXPR8d70tUMuRes9BmcI/q/e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAahrpkZyz7E6/O59jEIlQfGeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTQ4NmQ4Yi1hNGRkLTRkNGEtOWQzZi0yNjdmZDgxOWVkZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATU8UN+dF5HoyF6DTtDixEqelpuiy+GDgQa47mX9jRDlVfd\n6Nk/8zhe8kwHxtZ1fzHu2nlzb/+HQ/SjnAg28lw3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgMjWt6KvlLYEYMoiLzkdix5G\nbicwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVP/s2bP5ycXSC050a0buhILVHbHjQBsSrceKkkRmpCECIBnBzJG7ktNq\n9OG7XsCBjpR3SpXqJOAtWS3lQ/kU5Y+w\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAY7raDpAu09Yo9jFCYhXhO9hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTE1MTA2NDEtZmY4NS00MTY3LTg1MDYtYWZiMzhlY2U1ZTEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQ2YWIxMTctNjZhZC00OTRiLTg2NzctN2Q1YjRjNGQ1\nMGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELXH5WwTYXV/muAP6VUYnHstG\nq3Sd0B15FybPeuAkw2HqpPF8zYjJBQ2NkVifxO+7EhXZWJ7zB2lic7KxDzgCpKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJVoMpLYgXDRwucrst0WPzifOOJAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANvnM5xAy1yv7F2F\nb98P9fjC6uQMCswPpDChJO/K0HFLAiAJl+ZTZwn6vMklqSaZlzoCw6gjraYfGvOk\nZ3VLSP2KAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2490", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2490` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAQnVJ7JlXe82+kNMUMmNZjIMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwOWI2YWUyLWZhMGMtNDZlMi1hYTU2LWJlM2QwMTZkMDA3NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVhNDc0NzItNTVi\nMS00MWY1LWExYzItMTk3Yjg2MjI4MjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfhIAxwJ+ik9nyuWrNcvpnk+5cULjXafIUb5f6arhPRyRFXKn2+G+iutaBTPc\nIuabgoLfTj16Ba1q7vWIZIw1HaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrVfsi1EGkMUbs08RZ4OV532eInYwHwYDVR0j\nBBgwFoAUwHi0/cyfeYcVpsMSz0C1epBUCYIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBbyRyzX4CGIXtVzrvNti3QIAF06vojsSRd\nqR/4ofQYoAIgUnUcFkyM5mG7/alu2+ov7wvr4rw+xspWit7cZjZpecM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZaHKWFMEwuHAAEAB7AMcUV0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDliNmFlMi1mYTBjLTQ2ZTItYWE1Ni1iZTNkMDE2ZDAwNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQI6pggO2ESX2jaed79oSjk2qLYIKQKKXy7V2oS1QfnXUgl\n4RPwJMv44K+T83sf0+t3ZO+SedBzEOU7let1ZBmeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwHi0/cyfeYcVpsMSz0C1epBU\nCYIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXPaSYZ5dbPRDyFfnjd0OLOFClC/6oYCsNvdYN7I1GSsCIHOHFiGC1yAS\nc9RSFRDm5uhmrIoxUVRZi+aEBYhv3jFO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAbLxC7DTiUGzTxnNtzaSPpLnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVhNDc0NzItNTViMS00MWY1LWExYzItMTk3Yjg2MjI4MjA2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDRiM2Y5NDctZmQxMy00OWE3LWIyMmUtYmU0ZWYyODgz\nNDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfUaovzuC1fDXqhWgiHQSQWiC\ng1LpPG91GYBtzSUwBeeGlk/zyXjru3ZegnKVTts8pGV7wQgMNFv280Hi4voXmqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrVfsi1EGkMUbs08RZ4OV532eInYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAO1FVr4vbPdhBTWj\nJg6r3aaVuwQebhhF+4v2e4w7eK0aAiEA5IPjfVxwWqLVUzl26YDO2uMvVKXp2h/j\niWrFrtJdgX4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2491", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2491` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISASmSshrtj+NUIAq6/KrveG+DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwYzBjM2ViLWI3YmMtNGZjYS1iYWJjLTA4NmNlMzA2YmRmZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFlMThkYzgtMzE0\nOC00M2Q3LWI4OTAtOWQ3Yjk2MTBkNGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEefA7u/du2lCmc2KKujuRfEhWic8F2pF13eoerpnyL2/GS2z+6UssCWwuNOYv\nUQ95HOX4DF7ZB4FnIJYTj7GW+6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE4xivWZg1RjIHQW7g5xzAAK+1QowHwYDVR0j\nBBgwFoAUBb2Jf4C766mUoC1m/vUttHAkYKQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCTAtZ//5xZxSvf7UpBn3R7Q4JI\nZgtzyjbWNAo2jIFrNQIhAPh0ixz/9cUpj5LePvf8OauAF5GdK8K6ivQTe85UlKz5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVtbT2HIiXbEh7RgGYiNkK+HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGMwYzNlYi1iN2JjLTRmY2EtYmFiYy0wODZjZTMwNmJkZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARunqWRa4swGoc2rghTfXjax5Ayb5/RKS1SpvTGFDNGCey0\nSeHQMmHt+Pmo3j+zZ14gsUVh3/4eB8+4YHHQdfwwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBb2Jf4C766mUoC1m/vUttHAk\nYKQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKCjHxjyXsiWXv/6PT15IznMPNjc4krI265l86CQyvpWAiEApk79YPZM\nm0TZau1vta1I+zCBVqNDSncpJOUYNa9S9zQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAeJuqYCGrz9hlcDIIquBlrO0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFlMThkYzgtMzE0OC00M2Q3LWI4OTAtOWQ3Yjk2MTBkNGU1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGJmOGIzZGUtYmZiNS00MGRlLTgyZDktMDRhN2I5YmM4\nNzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBha4P4LkFxNYq6ISylrTU4yz\nffHPigNm7zI6N1qxgTcbSNX0kYFMDONTY9LtwoVYnpOWrSNIus+UKv4I2lKgfqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE4xivWZg1RjIHQW7g5xzAAK+1QowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMUyKnaUm62z+9c1\npJU0CvA6qUcANSpCdrIz9TPTjKVaAiEA1YZLBgHVj6zn2ZNU+77Hmmhw5spjlicM\nGcWZlownbfM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2492", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2492` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISARe1I3RHzSFaTLv13syEFfeVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2MTEyZTU1LWQxNTgtNGRhMC1hYjBkLWVlNzUyODdjNjEyNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhlNjg3OTktMzQx\nNC00NDc5LThiYzItYmM1MWJkYzZjN2M3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMpFPe+HHoOFmKsKRl7cEk+YJ2LrwShq5pE121dHL/2M32tfMS9sWGVBtNNld\n3BX5qJf985cUBxpJ+IRJ4dQ2n6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSWHLMA7Iyx8K5Tagx6KuQQGtLiYwHwYDVR0j\nBBgwFoAUpj3W5gIsS87YJjOQAv43Br7CQ+MwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMGgAfUE\nScJzjdRpRU8muoUah2+onCZZO0quyhDMC6q9AiB+lHVOohZgVF6GzEjbJAOykzIb\nK31NP1V+DI+ouFVS4Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAerj9nI0KiYajN8KvX37am/mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjExMmU1NS1kMTU4LTRkYTAtYWIwZC1lZTc1Mjg3YzYxMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLjCyso5YYiEkxowLHbmUV7fGrbVpCyJhRzSSsncfBhIc7\ni3DW0WXc9+Hz2eyT0gWY/A3anZzfxz5cgTNPaLQ6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpj3W5gIsS87YJjOQAv43Br7C\nQ+MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRRduRGvbRPzId8vFRHD3451Ztx6+XirOu8dLc6ypfMoCIEPAta5OawuS\nZRKrwxzBngzwZCObD6mAgs/dNRuyDelq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAfCj6110flKW5DWW5t9SbXcfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhlNjg3OTktMzQxNC00NDc5LThiYzItYmM1MWJkYzZjN2M3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2MyZGU2NjgtNjVkNS00NDc0LWE2NjAtZTA2ZDc3MzNj\nZDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUEF9czeGrQXc0P7TwdXRYH6X\n9QmsKzwXJbCZhrpctzwMX8ZVMjxJVFIoJNkjEU0UkyA+yVrMCiVCsqCrabKEYqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSWHLMA7Iyx8K5Tagx6KuQQGtLiYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgf2qWdw3vPRRPDsCh\nSJp77IHr5UNKSY/QApmvcIBz0xYCIQDI8rcMKnoXheEWQ0DpUsMAM1gyKo63aJjG\nto8ubsFIJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2493", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2493` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAQ4qPy/uyCZY7yknC8HzVnlRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkM2JmOTljLTFjNjItNDc2OS05NWQ2LTZmYjlmYWM3NTBmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThiN2MzYTAtZjVi\nNS00YjY1LTljZTAtM2EwNjExNGJjMDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzUO4IITaHSOq8qZVoVVST9HDTeBleazAPUBxhfW1KJYuTrrRPj4VFvMutVbv\nWyepkBh/8raWb/P1d+Ep7BUADaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJodrmw4WYYBz0e3TtUNp/hSucI4wHwYDVR0j\nBBgwFoAUSF9p7sdr+/WhRRN4FzWC3JCMkEYwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJL1amJt\nmn8bV/k393CUua89teGRpPX3w6gLwSoPyqUwAiEA/X0Z1vYXiXnMlDWDBCYeAsXR\nIH+H42t8keufFszGIpI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeR8tQQjtTUom4p25glfTsb8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDNiZjk5Yy0xYzYyLTQ3NjktOTVkNi02ZmI5ZmFjNzUwZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkL/+TtBzVaZ+bfucEMggHvspk4ijNxQDPgtIALadiM4GB\nfGM+9mdRJnz/ugEP4CqHa0UYL6H8CMMXW5S7pFADo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSF9p7sdr+/WhRRN4FzWC3JCM\nkEYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJMf/Ju5aQ+KgrNpi7H0QtL4pRuZbG/ExT3C3qrqU20VAiAiNtBrhcQ7\nk5ALVaervxGoGJ9cV98NnQ1ok5FWy50lYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAYxRyROwBRYOGKn3QbdAyv8iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThiN2MzYTAtZjViNS00YjY1LTljZTAtM2EwNjExNGJjMDBhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWMzYTlhZjAtMzJmYi00ZTI4LTk2ZWQtZGQ2N2YxYTE4\nMjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAkXtaNPUw4uNQEAEu+KwKgN+\nM9Z5Fyq0YGybrsmiEZ7wu48DPl7kT9zGkAstbfgcHHL9/xBG7FuYoOnneQ+YA6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJodrmw4WYYBz0e3TtUNp/hSucI4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANwGphF4FvRjL9J7\nmIHndMKAm0Y+oOPcVJHCuFJBXxlKAiEAsIeFF7NhbwJtgQufVpcsh+IK+W1B4Hed\nAi2R1Wp4IWM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2494", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2494` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAbD7+2NiwWOvEh5AUYfbJsUSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlNWUzNDI1LTc3OGItNDU1ZS04YjExLTFiMzI2ZGYxZDM4ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I2NGM3ZDQtZGUy\nMi00NTJkLWE1ZjAtYjI3ZjJkOWVjMjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl00WGEQSnF+cnfnZFzfTBa4dc58VOSYZAAv5hOjyt1YNeUpqMV18CjpqeXNr\nij2Wm30tdjwEOQs6gwPF8ZARhqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNleYTjJ8xgv72l3ssPnztZJmxjgwHwYDVR0j\nBBgwFoAUCICpUpG9T98wSvuhlM832RK7cE0wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCPj3QW\n4WuxQ0IJxBIn/5gWiuVBIpjx4rsfDGPjCvNPYgIhAKsaz57LSgZfQPjd3g9GD1Nx\nWsBSbGUQC7lPfVxuGlqO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWI8n+e4+RW4++BerytLIl0NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTVlMzQyNS03NzhiLTQ1NWUtOGIxMS0xYjMyNmRmMWQzOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGV7TyZF22K4CRXmwqg1L8cYlPnsxw4hFRBWSw8cuXVB9T\nur3mgdp8gjlDu5AtLfwCzes6Fy0qFunSPbTG0TMYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCICpUpG9T98wSvuhlM832RK7\ncE0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMLlrplylde18kIoSWvPURJwIFZBJw3Ib2snjHCQkiAMCIQCaQLGHbXcc\ntGoVNxo7rhH0HzHfFimHB0dhXcdbl3TyTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZpSV7phgiu4BEAIqVQYPahzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I2NGM3ZDQtZGUyMi00NTJkLWE1ZjAtYjI3ZjJkOWVjMjVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTQ0NTVhYTEtZTRiZS00YjQwLWJlMjItODQzNTYyNjhm\nNjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/TzoLwUG58YkvZF99xaKLoIF\nAjyYhuMT5vk7iyr3+UCl0z2fPPVNUA084GsQkiYs51H2IScKpfWANfAP9Awep6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNleYTjJ8xgv72l3ssPnztZJmxjgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOlQE6ZFXWNAbGSB\nea0LG2EYfr6PxSgtB7uaF0V4d6YKAiBvGOhd+qiKkunNi3I1cB9dbl9ImjQrJTXI\n1AREHzb3jw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2495", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2495` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAXT6GloDYoN77kcJT5kr1BRIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MmRiNmFiLTIyZTItNDM2Ni1hYTM4LTcyODZkYjc3YmRkOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlkNzEzZjEtMzli\nMy00MTg1LTk2NjgtNGE2ZDVlNDRkOGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkEdez4MrGUx9BBCajfEZygR4rYGoC3REao2MqApMDb+DwBMnLxvK0jRA7Bzw\nyVg3nO74jYzqvAezbZQLSvXyYKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd/AmeRzGspWE8/Q/kYCsWVMT7cQwHwYDVR0j\nBBgwFoAUdfYBzev0iKtPeoA1Rnen+VTCPBgwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDGk0R+MHhMUZRIUlUD8lcOVfqHns+Hl0KJuZWhENggJwIhAJL7hMsL\n4UmVT+h0S7P+kaxCb0GB+jz/G4euTiwNwWH7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVYWTR6HWhgnqIti8merDItPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTJkYjZhYi0yMmUyLTQzNjYtYWEzOC03Mjg2ZGI3N2JkZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjFZcrJ3vnCDg59OBQMvDRDFY7CuU1S++UyIV/7LkFCTON\nXPU1kVBeS7q5GloToUPg3ham8NNe7ozNS7FHtZpAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdfYBzev0iKtPeoA1Rnen+VTC\nPBgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKkQo74167Ae/gR3c2+k0gTa6efJSxylia6FXeh27hSuAiEAknJXXHJA\nr9TDEqE6i1VYyVENAuGDha/yC7ORtDJlI7s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAf6mk2Du6xz4hnn5w0cwwJWoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlkNzEzZjEtMzliMy00MTg1LTk2NjgtNGE2ZDVlNDRkOGI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTJiNGQ2ZDYtNzg1Mi00OGJlLWFmZjMtNzIxNGFmZWY2\nZDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMCLvN6vSAZDHmYtkoGWtNGeB\nbdBRoqQv/RmWAWRmCfMonBbcPITET4IsmSX14RYRnFWyU+GvSvhENLjRk+3mqqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUd/AmeRzGspWE8/Q/kYCsWVMT7cQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPh7K2g1s36MEt7s\noj8sKPKrMDr96tJWjiI2rJ5BY+0IAiEAt8dMzq55FKrV4MeI7m0xVr+XMGTA47v1\nklSdXiIGNy0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2496", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2496` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAfK047FH7rY5l4i6oPNNMrC8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjYzlkZDJkLWRiNGUtNGMyMy1hMTQ5LWQyNDM0NGE0YWVhYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdmOGM5OWEtNTZk\nYy00YzQ5LWIwNTYtMWRkZmEzNTIyOTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEIs5k7oRnKVjhy0ThmRUVI25TPdFru8uWsIWJa+LXuG9pqm53RE2qKjyDLYf\npV+DXfHp50rjdshPRKPU11GwYqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIiysFKAfXqUFfz269vPI9g84mncwHwYDVR0j\nBBgwFoAURy2TA92HV4hD+HPzAtWSF7wb1dQwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIBo1EtnnLTn9qUw2EGOe3cATy3lRgwgm4CUTYMe+HdkEAiBgQ3IR5MTu\nKF+1Dp+wr04It0AfgIaecoZTbCCPJWJe/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUOojrHZmF529LgPoMur8l+tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2M5ZGQyZC1kYjRlLTRjMjMtYTE0OS1kMjQzNDRhNGFlYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgLFe0GT+tf9fc08dl3SMz2sqIQtMP5JvLwtbhFKO5Lqm8\nHvn306sWRtqHxQc8PKeNOBGJsJNDyg2mbure60S7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURy2TA92HV4hD+HPzAtWSF7wb\n1dQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTwQRoE7wET01DQfJqJQpg1GhhZK1l+HynTBaxoKQkzcCIDakorszZhdq\nG/sfIhOIfPVl88BhUE9Y2e30GzDzFJPC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISASjQlOPCu29qm1VRdxMaEuAHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdmOGM5OWEtNTZkYy00YzQ5LWIwNTYtMWRkZmEzNTIyOTg0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGIxZGI2MDItYzAxNy00MDI0LTg0MWYtNTUzZDc3MTAz\nZmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5eBf2Tw89dfRI06G76XXkfxP\nY01zOMS3mUJoXZkHjYUcUJWfg0tVqutwWyfO1jsahdJA4WKNKodL3Xikyf0u7qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIiysFKAfXqUFfz269vPI9g84mncwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgYLM8jtK6wseTIINm\nrUto0WqbACZVoH/UzRCvn/bsXTQCIDctrEL+ZTCSBMMOZ+WtoLYNjjKOVXShoGWi\nPaoyvkTi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2497", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2497` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAcBTAJ1w2WR9GqAUe+BIbxcJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0OGQxN2I4LWIwMjYtNDdjYy1iYmE4LWNiODdmNjYyODY3NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNlM2ZhYjUtNjRi\nNi00ZjQ2LTg4ZWQtYWFhOWVkNmY1ZTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERW7pdYnaMPSIvITFxNWAcIjCRRoNk8fM5uoZ0ZjqI0WRaVyb6cZGdvP2HQkL\nxnLCP4Mq5jJQTKRD2kMmlFWGJqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuKQaPshTwwN3x0kwkKOkZs3XmM8wHwYDVR0j\nBBgwFoAULs+npvdY2VJ8YaT1h2FBOEArbNUwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIBFtuEfuBmxwnmTnUq5Nj+Nq1YjEy387+OetcKwBllxHAiAXeP32iCwiR/YC1E9A\nFTzdoXtnkW48aGVNij3UlpSeUw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUrJIqd/OjX3J+IlZrL9VaIsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDhkMTdiOC1iMDI2LTQ3Y2MtYmJhOC1jYjg3ZjY2Mjg2NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsQOY1NWWOl4xmwhTqenPk+0EixfNSNGKLuhkXtuePwo6k\nGUPjNfDde7J+f1nBEYoNtyCmLiFLKGJEO0Q+C34Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULs+npvdY2VJ8YaT1h2FBOEAr\nbNUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdaDoovqlOd6wdHTSnR7dMQbMrfISaFqPo0AabiTcSbACIEbv6mvTkSip\npL2WzgeniHSKier1c6UrB/hFCZmC3ejF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISARsgSf8KIGT9rJ8Y/vOSD7+pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNlM2ZhYjUtNjRiNi00ZjQ2LTg4ZWQtYWFhOWVkNmY1ZTBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTliYjFkZTAtNGZiOS00YTJiLTg2NWQtNDc2YTc2OTQ5\nMzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp/8Le8aqwRyJWhHNodu2LWt5\nhkKhd64XIebx93oYbp0h+tOEIQWdazhiZQu9PkOFhXK488X5Fr9bXIvatC3nL6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuKQaPshTwwN3x0kwkKOkZs3XmM8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIYWhvenYFx/8EvH\nJGZ4nxZDZlO7jG5wq6TGS18rBJE4AiEApecdxixfMC6xmj9WIlKks04LZ5AGERiX\n8tY+QKQceGw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2498", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2498` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAW76iUakDWAzC4jYjlh1atU2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhNmRmMDY3LTI2OTEtNGRhMS1iZmE5LTc1YmM1YjAwNTA0OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU4NDJhMDUtYTc5\nOS00OTAxLThiODMtMjJkMWY4YmQ3OTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUqoFnhXW5uAKEQW6KFqyF0/jVIs/crNVtR+g7+AQXsQV1PBJJXtvk2ZRLVfI\nNAKAmwSZvZW88/VUGDQSIdN7u6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOk+Yq7P9mHxHPsWKURl46LN8LEwHwYDVR0j\nBBgwFoAUJBw+QOl0ezu0f01csapxlYclenAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCICckYJ+9HYL+6URTBukU/mglmZvcbOTNyEjOnqbWaJ0gAiEA\nzwGdkT3cRIJg7eQGNEODWLklp9mQeRnt6/iza9LpVjo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATwoUpYq+q1v5ezOwK8iOQHBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTZkZjA2Ny0yNjkxLTRkYTEtYmZhOS03NWJjNWIwMDUwNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6PR1Kw7wVdLSwhD6AWaozuZ3amSnHBwVc/5u2OcYe2IqG\nSvq0JiLo4pzy1GfYKhpW56pVZj7bvbqs8EAao5Dwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJBw+QOl0ezu0f01csapxlYcl\nenAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMvdOaq4LLc2BZ+SySwl+d/RJsfdFy9ycH6AUcIE3jg4CIQDI6CBSxAg3\nypOqCGf3a3Rxz5zb2mJxcxjZmHIbDMzbjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAScXmhVC4tYqsFgrsBJqoEFLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU4NDJhMDUtYTc5OS00OTAxLThiODMtMjJkMWY4YmQ3OTY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTM0MjY4MGMtNDdiMy00ZjUxLWI0ODQtZjk4ZjkwZWUw\nOWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEenbpown1o4VENK2c6jLwJr3O\nLH7lbBMXt1GstZ6SBWcUW4dhkySnf+e93BejIEwWP4v+V9xTabEGaFwPi3iuy6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpOk+Yq7P9mHxHPsWKURl46LN8LEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgGjZAT0FLkDjA0doe\n/tTKCZVzJBuUoY3tMRJavL989iICIQCmjsMkjUTnWNvrihV6nPzFuykuGUhusGn6\nfZhgMu3Xvg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2499", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2499` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAV/WN3w5sdhm6xAv6Jn9AdrMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1YTE2ZDdiLTljMjAtNDEzNS1iOWY4LWRiNjNhNWU5ZGNkNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGEwNDkxNjItMjIx\nYi00NTNkLWI1MzItYWZkYThiYTA0YjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECmbMeAux/tYp6OmfH9zUNfdxpVlqC9vfe7mrd8HBYGidTasaZs1WSp7rCz6H\nMboiPw9TaQfnnND44QqIyBX34qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUndndrwYvc8Q0JuvZMDKFNBfGYZ0wHwYDVR0j\nBBgwFoAUm7INuKs/fFnDdvTgq4SR991JPwYwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQD3l6DPr1ffoIvKzmM38tVHUH5H8NSJVFzfbdhi69qW+wIg\nfM8/IMt2Vcmqs39cZ3s1FF4jTXFDJzhdG0mEQJrctT4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa0Vxj+GVAWOJgS0NxE1WY7MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWExNmQ3Yi05YzIwLTQxMzUtYjlmOC1kYjYzYTVlOWRjZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS79u+gdZXi1wf97MDKILGX3JEtvGmL2B8fu+2W+g5oslxt\nB90K8lAIIYoBGItxzgd9QtaUmgslXYPx1XMdxqBxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm7INuKs/fFnDdvTgq4SR991J\nPwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOxC+rrM48crw5bU2Jz1trOSPVvLDnYNLlcbUQ9y6x0fAiAi3o9HKGFQ\nyskxIBZm02QDxgvZQgRE0stVPqO8io/agw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAeMl5xnN7bOO3h+aTXaIrLstMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGEwNDkxNjItMjIxYi00NTNkLWI1MzItYWZkYThiYTA0YjZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjUxMmYxOWYtZjlhYy00YjBlLTk1YzktNzliNzdmODlk\nYmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB3idxcVY3OWaFlVm6QJsHbR1\nfVD3RYT9UJi9R7N60vBBtSnWLxpOMi6wnFZiPDTm4ad9ZrvmLJlr6EHCruHaxqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUndndrwYvc8Q0JuvZMDKFNBfGYZ0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAP01TPdYsel3VxPE\nJnS3tN5Xj+31fI29fCO9apxf+06eAiBvxx9taQ9Nes/w3exdLBcNAyE9uJMVmiF5\ngiabs0jyyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2500", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2500` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAXNIvDKOcCoROerTewBHUHUEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMTNhYWJjLWUwZjUtNDkxMS05YTlmLWQ0MGYwMjIxZDFkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAyNzUwYWEtMTky\nNS00NjVkLWE0NDItNjgyMDI4ZDY4NmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDotAvVLvIU+KbQq8mKmlw9Cr8/ZT7ULp2SEF71uKkvCQEibP1ANy2bec2Cpj\nxBGgcJ5Q8JY8sN4HRtGjjc3yPqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaAvg1gSYxXAEhS6ZmbReIcbxphUwHwYDVR0j\nBBgwFoAU0xuvK0D4AzZdWKloLrop3rxu9tcwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIFyKfIq9wN1F\niRTUFwKv9qO8AqvYu75m4AzNoe+4QO57AiAq5HigOd58gXFwkm3GwW+AjUqjhVQY\nakXYNXN25M+yfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATC15N4AOQVNI+aHULj/2RWYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDEzYWFiYy1lMGY1LTQ5MTEtOWE5Zi1kNDBmMDIyMWQxZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsIuwixHacTu0ryVtsY3TCdrHTnJnGlTnMDxCFXob9YOPd\nRgpgobyacQ2vJHZKKHr4396gLfMCxv21oJKS4i24o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0xuvK0D4AzZdWKloLrop3rxu\n9tcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNYZHHQYA8p/2GiHG6w88y0GYCVS6VKvcy4A4SjmEe20CIG3nMBxF3zTq\ne2WAjyxbXs6MPDs8lXPj4kYz+MjtNQQx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAaZKr6C9shN1J9gE6zEveLfAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAyNzUwYWEtMTkyNS00NjVkLWE0NDItNjgyMDI4ZDY4NmE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2FmODQxOWUtMjYxMC00Yzc5LTkzNDktYjA4YTdlNDA2\nNTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyxBH32jhHcdVriYo8VKwtnSO\nTzkQWEMqDZvYyid3Epv79G90/kDNZoc28duq1OQ7H9eGwILbp8YDlfzBAW5il6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaAvg1gSYxXAEhS6ZmbReIcbxphUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgFsIyubUh1Z4DWwfP\nK23YZ4a/rYx9T4yaERfqYDYljlMCIFmUX4lHDOTUIW5zJBQvO73Ls9M74XCeS7ae\nQSAh/QG6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2501", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2501` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAcjTFtRo9LAj7YkKZDFN4EdWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmYzdhODNjLTcxNTMtNGQ1Mi1iNjNkLTdlMzNkNmNlYWM0OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM0NTA0MTktZTkz\nMS00NTRhLTg3M2EtNjNkMDA5YjJjZjJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX/Wcc3YsZ2FY6fzSKAg24W1hsrGXDf/qeoIGPogiIYjf5xkfl84sojk7Guuq\ndZmuHPXwCAZXlJfkYQKfwGNde6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXabUrz4xW5tbBJJWrVNh/Hsv8iMwHwYDVR0j\nBBgwFoAUWVO9uLAPteFQp/b3RPDVmyfmSJcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAP71I2BjRVxG4dukOve4EqJE3gRMN4od7E6hWh2HVc1LAiEA/F9b/LWu\nkkajzqUaZ0dkmdDmDtDZ38P1b1IVnHpIlJo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfiw1g8JbywttdaEgaqlTKBBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmM3YTgzYy03MTUzLTRkNTItYjYzZC03ZTMzZDZjZWFjNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt4pTvyoeFRFcVRviumlFe5H1uY3/ecMSg6tp48SvE3gjh\nPgq/4ePfX29Fhyx+JGSA//jKsKEPlUFtgla2NHfho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWVO9uLAPteFQp/b3RPDVmyfm\nSJcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcesKdezvVyXMacAeF4JvzHTS1tNEIBijdx1/lVKYh3sCIQCCjL0GnM+q\nFnME1XZnwJlzQjApSeZMb2VQ33VO1hse0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZLbI3y806VSvl9T7oYhr4dNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM0NTA0MTktZTkzMS00NTRhLTg3M2EtNjNkMDA5YjJjZjJiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNiZDE3MmQtYzI2NS00ODFjLTliY2UtYTMxMDVjZjNj\nM2JiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE425uo/zbu0VWwON0E9nhjaz1\nJOscN0oxZEPCO4BJD93Z1SIwBOrf8Xj6aoDHO6JJF8h7l/D2/cM1GyKXfrq5saNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXabUrz4xW5tbBJJWrVNh/Hsv8iMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIQiGJHgRtLL2G7d\nk37JOlVRmQU2f8mdpSCV7wc9LK2iAiBBoIfOasrVDED8VcVotuZR7WI+aGXZ2bgk\nMhfBdWo3TQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2502", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2502` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATZ6w8FO2fHG4zu9Rz8A9RvpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwMzdiZGY0LTUwODAtNDgzOC04ZWU3LTFhZjdmYzMyNGM4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjczODJjYmUtZDdh\nMC00MmFiLWEzMWEtYmQyNmU1NzRlMzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI3eGOSrwrZbG4HqzbhqO7Nxx4Et3LayzMKmQiC2lKUjzEmzpV3GQT/v5xwx+\nWwO/eQHFbK7I/tRO6/Ub7pP2UKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlLx5icZUIanutBzRfEzBxsFnlUAwHwYDVR0j\nBBgwFoAUbOszP+w07mZZjs2mmtvIfitumYcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgEY9mEexIMibil4kzPv1Z0Pbiw8oRN5dGnl9S+djVZEYCIQDaLOc19IHw\nPrHwI7hNa2GF1Ajhqg8BjohogzayFMuKYA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATW1lzMcfbwRwdj28tG3JGQFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDM3YmRmNC01MDgwLTQ4MzgtOGVlNy0xYWY3ZmMzMjRjODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUj1CoDZ380/Qr1nNdKSmrzT/oUC4UhZ9+BdFF7UzUNNgA\n1eUeHtUpoKGahDDFCw2xdQXh1B32WUH+JoMVurceo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbOszP+w07mZZjs2mmtvIfitu\nmYcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLD93rVQlwUL/8QVGu+BNQoDhsH4WSKo5PQ7c2tjEpFACIQCh+3NnMDc7\n/RWmxxmsZWXihnVDFO3qlbTArr7brcfsYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAViCRIQHBSGeklV88ixKCLnTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjczODJjYmUtZDdhMC00MmFiLWEzMWEtYmQyNmU1NzRlMzQ4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjRlODZjNzItYjA4OS00MDY3LWIzZWEtNThmYjJhYjY3\nZjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZrXQc81BGUh+kLs3XHliyu+z\nmLGX4lQUqRs/eM7p8yLE+jQ90ew2d899YmjJOdq+qdJHc7uw5Hr/ejuI/5RbSaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlLx5icZUIanutBzRfEzBxsFnlUAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJbNlFfyTmRGEdTk\nL6EfK9qFCiVdfqSjRuK8uUloDrlGAiEAoIJACiVUfFmt9Sb+ujHjyhsSsTwXY+61\nSjvnGeu/+x0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2503", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2503` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAaTaGOEwBnsDnIkZ2eLIMxa6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0OTExNDVmLTczMmEtNDM2Ni1iN2Q4LWUyNDYwMTIxZDZjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU3NzE4MjUtZGZj\nOS00MjliLTg2ZjItZDFkNjdiYmFkZDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENY5M5cBDtR0MqXcq9m8xBAReQQ2s8OWIqOraHee8SCL/L7OifwMS6VI17QnW\nnYFuTBdfP/kCiFnFf2+Najwmm6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDJ1aaXeS0oikzSdBHGJtIMd5qLMwHwYDVR0j\nBBgwFoAUiFu1T1RURgs1Hf67dvdKWlLX/hcwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIHilaccVXnGUQ0DwThXGVIOE8F41Qw4eZ2Cbxh36Fui9AiAJe/P/u8Wq\njxs/zwunY5ry2UJOKwh0M/obJSI/MJMd2g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYeSnFSAmMGdT0dU8atFuZ0zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDkxMTQ1Zi03MzJhLTQzNjYtYjdkOC1lMjQ2MDEyMWQ2YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoPZvgilUkbHC1/wscvqpEICNPDVJtZYFzvgmDxDsYnjKO\nw8xX1PrlsEZIC41TMrkzlgoDvjMqf/ca+NBouJI7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiFu1T1RURgs1Hf67dvdKWlLX\n/hcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdkNtbI/f7puLH6plBOqz3wWk4UU6+Eooe8R6jqMbcKkCIQCqJMSIuKl0\nGK0KXLwxdGKjoSbSncq2xYiCtaTOHl5QuQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZQVGbb3RzJmhe2U71gOXEMfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU3NzE4MjUtZGZjOS00MjliLTg2ZjItZDFkNjdiYmFkZDY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjQ3NjQwYjYtNjliMy00MjE1LWE5NmItZDBlMjIxMDg5\nNzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfzqTZhHOjZkqRMigY1gkzKn1\nSP7dQoDENf+b1Ls2cOIwAc82sT9nyOPDkt35rV2DyrqlfdU9jjrwOgveAhf4kqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDJ1aaXeS0oikzSdBHGJtIMd5qLMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKPLaVOEnleus9KR\neFpcvKfHAjhGHTbct5ICrkcEG4DLAiAzikQMEPqfPnW/mT9rw/JoN0oZh1NvDLWK\nSH/70Xh8Yg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2504", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2504` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAQvDKGhmUm/OpYv3/OCNyC4/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNjI5YmEyLTVkOTEtNDI5NS05ODE1LTBhZDE4ZWZjOWYxZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZlZWFmYTgtNmU4\nNC00OTZhLThkMTctZWFhZWEyNzA0Y2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMKMfFAZnYZ/64MKs87bLVCGFgyuobFSgVQAxNA2ErbyFXCAnnL8yGC/9AKhp\noxm9l/nNCNTyonJG/PjHVRne6KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxQA6EQFAjLH/og4irCJHmLvwY9QwHwYDVR0j\nBBgwFoAU22/a+5bP4d7SKtNLawcsrjalEDkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCID9YJNfEzuPCijHegejbMWYMEGT1JuPG3Wm15z8d\ngkztAiBebdfHAkDDh+aqXgUdbkogKCd5bz/BornB/f76fSPGVw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfW9eZ3C9w4Zrgu0Ihpl+3raMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzYyOWJhMi01ZDkxLTQyOTUtOTgxNS0wYWQxOGVmYzlmMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATU+uCNe3KoD2SWZxxmM+NGYuj21/7ZqxP1zogvl7ENtRDh\nZkdA95bvu4IV/5OOzVjTl/jIKcrK8w4NwTt+5BS0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU22/a+5bP4d7SKtNLawcsrjal\nEDkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANM/PZu3JCqfxUcdszhoT1HUhkM3KMb4G/x2dGdNDiB7AiEAiD3TBcD5\nHEnVX8UKx8pyKLq8r7576UWZwmn7eL8DLyQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQiRvmdkTI89PjfaO4WCJJrDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZlZWFmYTgtNmU4NC00OTZhLThkMTctZWFhZWEyNzA0Y2Q1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2RlM2E4YjEtMjVhOC00NmVlLThmODQtMDJkMWNhZjg2\nYzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa9XkCnp940Njt2eNGy7dT5xM\n6LH9vzsEQnZDgAryE2Hz+/RpsxpNVK5oHTxIOkAeBW6xZSDWe3a/JOCHSjWBeqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxQA6EQFAjLH/og4irCJHmLvwY9QwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgK9RcHL7O5BkFGEh8\nqRW5+h2vR1sL7FOGqDINv7ApJm4CIQDQneFWC2pciSMRm/OkubBighn1ZBHDczSD\nN5CaUhi5HA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2505", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2505` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAeZsNCXBzk4C8+dzHV5P+8AZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczYjQ1ZjZlLTc0MWQtNGYzMS05Y2UxLWM0NWI5MGM5YzgxYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg1YjNhNjUtZmU1\nOC00YWVhLWFiOGUtODkzNmMzMjI5MjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/DLdz1cmvRccxPJK6skEcOhY6JWD4u7FS+pngz0SQyk8x+eNe0WNCxfoKWCw\nTJqqkNvjqezhdjbpeQ+GH45h1aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI+/JHAPjwfXfrywQ5wcdON5GBXowHwYDVR0j\nBBgwFoAUI/VNGn8nIvbApyr2u6R+ujzF4KIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDWINUkrr343Ef+LJ/fETmjnhkFX5cUEwD91XYx\n57uVeQIhAMDcskai3K12uwub5butHsTLRovCbjnTSXjqMB1TA6eW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaib0R8hgF/uUUu/rFSW3PWeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2I0NWY2ZS03NDFkLTRmMzEtOWNlMS1jNDViOTBjOWM4MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQN4rAX6/8quy/q7gI9ULvJwMjaZ/XBwvO/sHGk9JMNryvY\ntyp/9GxGw+GVk92t8a+SNrMvg3MmY1GbEkoC8fiRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI/VNGn8nIvbApyr2u6R+ujzF\n4KIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP0alRUIEJcfGCqvLpy9sao6mD3GqEbqoQmJsvR1yZBvAiAvYJWcXEsm\nyi4TW93jUgrTPpe6rI4M8vOKFrGgQkuH6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAXDmXcapFgNsJL0l5XWGkP6mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg1YjNhNjUtZmU1OC00YWVhLWFiOGUtODkzNmMzMjI5MjJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWVlZWEwNjEtZTA0YS00YzU5LTkxOTUtMzMzYTRlZDQz\nYWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ9407AmWiq/emWyU71iFVDzJ\nz0HcveTw9SqSlcKnJZZbzOW9hLaxhdDJ/v2OQU7ex0iEUgdWpMkXUER5/GJ2ZKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUI+/JHAPjwfXfrywQ5wcdON5GBXowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgdrOORaBdxJ7omoPJ\nqzVRQDU0aYhOZ+7MAVOwXICmK1cCIEAHY1WMa/RwBJjMNcJ7epim55q353WbXcAC\nVcbaRZB4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2506", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2506` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcvFX8oOSAa0rU1E+vTGlYxdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhMmI1MDJjLTJkNDMtNDg4YS1iODUyLWQxZDU0YzM1ZDc4YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWIwZTRlMmItNTBh\nMS00Y2U1LWE3ZWQtODIzOTEwZWJhMjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0wJO6qyHkvxVCRTaF1N8kqPzzTJ9QqfCs91kbAF4k2MBc2lLfzq4TjRfPsJW\nWEwPsS3GFXledw5c6v5obEELDaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg2DooU2OnTqHXcKm8cFKPrbxqAswHwYDVR0j\nBBgwFoAUnwpO/ov1fqXY1qPnaawbimdtZAwwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIHdiH2e8IcADY8HBadna6SLonGFIoRaWBqe8ZaP8JVhGAiEA\nzXisMpOc+nXVjrdIpC64x4m7dJ6HvLIHGjP7J5Kz6po=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWzTmda6LGbVe9Utl0UxCsZ7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTJiNTAyYy0yZDQzLTQ4OGEtYjg1Mi1kMWQ1NGMzNWQ3OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARs1Irtd9NPszKZEF/Y2xdss729Kl/k+dx0/JLWE09N3rm4\nGCWWsmgBavxfBm99S3BzLwYw785u7HyWll5JX+LQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnwpO/ov1fqXY1qPnaawbimdt\nZAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUgL4o4Jgz8XyjyFsHYpGpKMT6RodY0/lkFxyLB+GP3cCIQC3SjEIjQ9A\nWOewJybfJrCibyrmLQci+54JmDxOJgFO9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAVh/V4oCPN5iB8xceSztfGt5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWIwZTRlMmItNTBhMS00Y2U1LWE3ZWQtODIzOTEwZWJhMjhhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTlhY2RmYTYtNmExYy00MDlkLTk5YzEtNGZkMzc0NDgy\nNTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHIEN9IPYBq14sBV+NiKuPYgP\nH093MqFVAJHZ3PmbC3NrFk/RHXicXky6QjQ9Ag4l6/+mymVz0ACUPD/Uyepgd6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUg2DooU2OnTqHXcKm8cFKPrbxqAswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKErASfVOaWH1srA\nQ+XLpvyDhYCPku42VqYScK5I/4GsAiEAz567JGslynB15KDZEQymRZMDiXA73GCt\ngMacTe+v9ss=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2507", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2507` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAYvcFGNMppxCB9x2c7Utrx5BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxZDZhZTA3LTI5ZDQtNDQ4Yi05MDQ3LWQ1MjViMjQ3YmMxZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg4NGNjZmUtOGM2\nYi00YTg2LTg3NTQtNDA0ZmUyZjZkOTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYfLrWSJP2miG2nyP+3VOXgV4g8Gmd+nL+PJyQTpAHAJ3zaxTfX6tmYPW8m0a\nZr8dzRtS1/er13rtQ5hWN0yt2aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrHepaEr9zlur3N0mPJzXTtyHV9YwHwYDVR0j\nBBgwFoAU+HiMgwv/BBx/hTl+G0SPILXEzfIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCpjGhBDft5a0BpK86PpFGOIBMnpzha\nzohDbZ2QsmyAxgIhAJrkQcHOcgNcH8tOSSl3LS76tZizzDtu9bRtm+LZAziJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZcNiJa6pbz1Q6SVgNfciJnSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWQ2YWUwNy0yOWQ0LTQ0OGItOTA0Ny1kNTI1YjI0N2JjMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOXrUqNAx2uN8TQfVqYTDXd3D4ddjAuZMRhg6PbsyebkDg\nWbA0Rms2wwBCOo6+kmVSQe0Bs+i4MkzmsfhdAg5Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+HiMgwv/BBx/hTl+G0SPILXE\nzfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMAbVcsejScCxOj4PM9OALlZq0PttQJS4xvSGFi6ARmdAiBu5q59SaKh\nTc9l6Bq1F3l3r/Lyd/KVhM9M/O1oVm9VTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAcq2y2FMmNdw+ht4bwc3E7lbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg4NGNjZmUtOGM2Yi00YTg2LTg3NTQtNDA0ZmUyZjZkOTk4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQxYzVkZGEtYzM5OS00YWY1LTkzNzMtNzg2MDMwMDgx\nNzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEauhq2sonAxKKxQdsccC4WHTi\nkX42bUqrxU77I7A3r0v86IGRjkAGASODkNr/4Nix9n4us0caz1HU8Am0PUwMrKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrHepaEr9zlur3N0mPJzXTtyHV9YwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOZXdc2bNSp+/kr4\nDdedysbfWDbyJBwMEqyyRBGIzT69AiB8mjHmpBLaHQYgMp9otSuQylWJgyyNBlPn\nckWLMwI5pA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2508", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2508` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAeggjj/H99fr0MmDFKFMUNBXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZTRmMzcwLTY1MTMtNDU4Zi1iNWNhLWJhNDE0ZDY3MWUyZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYzMDQwZDQtY2Vi\nYS00ZmQwLWIyMjctNTg4MGJhNjgwY2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuNtOm4nXMa76Joqygf3xQyo5CX9l4uIV0XF+i4Wbp+x4xY2TyFaIHMBwiaOb\nvlsFxFBUpr4vxWfdUa/e002tb6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUseXEulBkwyBpu/ca24rO9oxTA/EwHwYDVR0j\nBBgwFoAUjEPW5tJvAbyryR9Ubv9ndecoPaYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDqiTK4WBRRGBXfvdgEaGLM4FKYVOSM\nwYJcgnyOTAT2aAIgct0N/A6o3igFHFx/WUFSDCm1FnRiKqNkA3Bp5H4BiP8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYKTgI3zfTjrqT2+96fC5yx/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmU0ZjM3MC02NTEzLTQ1OGYtYjVjYS1iYTQxNGQ2NzFlMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASg+LgGz0VD+E8WTlyxzz3tqUuumsh2Sgdt64rOFnzHRL+z\nq+01Z+ensk25uyaWju+moMxb/Q9NjmldmvdcnGpCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjEPW5tJvAbyryR9Ubv9ndeco\nPaYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgclxZ82d3hmkCHpfBxao9Fph1NAUR3ZN1Ou3lECtLWtECIFfAu7mX6pCY\nqkk1BfRMKAx/pdKeR6dp7b/6lXTKRrn8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZtTLfgiF1UlCVCLgOiNo0VvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYzMDQwZDQtY2ViYS00ZmQwLWIyMjctNTg4MGJhNjgwY2U4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmMxNTEyYWUtOTgxZC00YTNjLTg0YWUtY2ExNmE3YjFl\nNWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELazNQbYq9AcF1UzQQUq703Ws\nzKs4KA5pAKmfv8LyrEZH/ocrzTxacfMoPY4Ke2yGvPJ3lJiSsk6n1gMXvHMEVKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUseXEulBkwyBpu/ca24rO9oxTA/EwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgNc9GZpA3EbQr0JxA\n5X5c+380tVjS9b+gMd0j8K3cYdQCIQCYskM9vafVUPvuVxAqh0Ox5W3tsrjztsjp\nCPLJKsNaEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2509", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2509` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcgCWgtnXAQSfdtMvAbvx5GoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4YmE3MThhLTFkNGQtNDgzNS1hOTJmLTliODA0ZGI1Mjk2ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZlZDg3MmItZDkz\nMS00ZDlmLWE0NmQtOWI3ZmZlOTg2ZjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6s3WWpiP8TiDrDN6s7Hif7z6NihV6+BiCxthjnVBnMXyuwJzRSs/t5MAg+LD\nGjpZzB/nShRAGjjpc+idv1A7PKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8mIH0OmcMuXcIXKMv6vakyfHH24wHwYDVR0j\nBBgwFoAUI3pPj+117Cc0nQIpf27dXMyeS3EwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDymfmNh3OH\nBRT5bmRoJJoB0glMp8IfooUNSY/9U3mKgAIgH5K22b5050p96WDy1gHMBuA/i+0y\nUovGacuOF7dHnDo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWW46hGeEBkgySpKJ8YaXnBaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGJhNzE4YS0xZDRkLTQ4MzUtYTkyZi05YjgwNGRiNTI5NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb2dWgCIYapLTWNnPV1j3Rimg46QQben2MVn9FPeGMkslu\n7c6n8hcyVYWxql3PF/d8BTVAF33BhXvMSQwPLkYxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI3pPj+117Cc0nQIpf27dXMye\nS3EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGvFmTp9wp/6VcpDfTVjCdK920vyNaoGkK81t8Q3+FkECIBJU2JKBPI7z\nj+QMeSCgMfWcYcbZwiEdUmO5uhBHDQnf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAd6SCFAvKYNLe2jt60BL+BF5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZlZDg3MmItZDkzMS00ZDlmLWE0NmQtOWI3ZmZlOTg2ZjE3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWZiZDk3MzYtZmM0Yy00ZmI4LWEwNjQtMWE2OGI1ZTBi\nNDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/7ODJuZgjMnW3ZWaaGyqpZhf\niepYgNzFQDdSSKS1gjEOLVgThfvtcN+CwAR7ydbQEmIy5egNEZ8Xjnjxbkh3sqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8mIH0OmcMuXcIXKMv6vakyfHH24wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOlIMazOAyMytiBm\nf7egwzhE+hvB7Hovb3c5FPMvYRpnAiAo0IBWzlpuVMH1zkTq3aMQR4YLOGYFQD7q\nLQBSQkW3xQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2510", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2510` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAS4lsk1wYtZNACT5qLkKIhK7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZTU1YjAwLWU2ODEtNDNlMS1iNjc1LWI3MmJhZTY0ZjNiYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc3MzljOGMtZjAx\nYy00N2VjLTkwZjYtZGEwNDY4MDYyMDQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYYad2V/xlMI40auYZzuIiYIvhM/Jy9lIv8Az4HYNL+HtIZu1x0MyK+S0O29n\nRs/whl+fNKFH/5d0aqw9QkhVEqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQNyKh9sTGn8Bg6HQKrCX/5bioQUwHwYDVR0j\nBBgwFoAUjLC2uu/AayXN8PIgaAOlqsCSd00wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJ33zpIR5DDBMPqctvRWTIEorcuLuUm0mmtRg4HY4GJ0AiEArgc7zPx/\nQc3sA8XQBN7utfVXDpkWcZSHNsxuf3kDwSE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaH7dlVwSEb3aKC7yQCc2tWCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2U1NWIwMC1lNjgxLTQzZTEtYjY3NS1iNzJiYWU2NGYzYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpFjuEMAZ9NvFggq1ahRGc7irXXwsnuPFGEJvrc7WtaXr+\nVp9U7o6ESRMdE3SO3egkJdZx6DlTFV4TmA08PW39o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjLC2uu/AayXN8PIgaAOlqsCS\nd00wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM7YGcgOqJQ1QJv5xbbL90whrOhijGmHk0BG5QllOV6lAiEAj8H9CEXV\n1r5Ue+CxbB7ynlvRcHuiCGoOrmpAD1QxG6A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAcXmBMbnOEa4hXseO5uXfw1ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc3MzljOGMtZjAxYy00N2VjLTkwZjYtZGEwNDY4MDYyMDQxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjcyODdjZjEtYjgwNS00NDQzLTk5NzQtMDBkNWU0MTBj\nOTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPKGseVllmMu8sIavuto10k0K\n8lQ3jzkr8A7LCOTilx7tbrAb1vuV2X5oklHONKOEjtE0/ytHU9vyzhOAxZRY0qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQNyKh9sTGn8Bg6HQKrCX/5bioQUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgVR7kzYJgt83iCjmb\noebs89iSMukHq7YKNOFHQqIJ1HQCIEZE7n2wQWCpC1YjPptIXE9P3YJgH9pPg8mp\nnaqfuEKQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2511", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2511` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfL6o0ojzl6AMIYkhzH6dPc7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlYjFlY2EyLTdhMTktNGRlNS1iMGQxLTUzYWY1YTkzOGVhZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ExYmE2N2YtZTdj\nZi00NzAzLWEzMGUtNmIxMWU1ZmUwN2Y0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6kF4NG2f4hbyFKbHn8JmeUA/MU61D2Fa1FR+LZ1NiyUblbduJdVKhnZ2Hyh5\n6wFTfQUPw23uPY9T0oshPjKbCqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkIoQS89toBeIomlXHSA3DL5MhuAwHwYDVR0j\nBBgwFoAU8PicuZJkyFEakS5OSfwWVnQuvp4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhALAWAfI5GqhEiFejgPkNAVwT8uuwgkK431H56n6omdIIAiBC8Y0wTzJw\nL4C5bzYHSQT/FfOx2NitI/tOYRZoO3i8SQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARoIiN+N2S3YM6Xsuh+c8vwHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZWIxZWNhMi03YTE5LTRkZTUtYjBkMS01M2FmNWE5MzhlYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6jBINMOPFy8wGishOvdXXTVsvclFzRXr+GT74k7S80kWV\nj/HBQ3mS8UFRljnCANRghrxOS/nwLuhORyFn16sRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8PicuZJkyFEakS5OSfwWVnQu\nvp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMaZ32JnWRh7KQB22/cvSf6g4mvUGjGSzlds57odt5JrAiEAzcnvTZvG\n5jZika8JyWevrbezrcP+HCLHB1Aqpc4orRw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAYAdiDDOao8kA1vxPfOGWQ3YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ExYmE2N2YtZTdjZi00NzAzLWEzMGUtNmIxMWU1ZmUwN2Y0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDMzZDVmOGItM2Q3ZS00NjJlLThkMWYtODZkZGYzZDIz\nOWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfek9pkQVayWfEtvX43i9pmn3\n3Rmsy5zuc56AKJsnUTzgyXZaAZOe+ovFGXvaQsakkKqaU/HWCZvOc1A/NPZRBKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkIoQS89toBeIomlXHSA3DL5MhuAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgfOSmCOG/9bVlTBRd\npedG4xE6o6RqI8nnXKdPAIdci70CIDYpNY35rxXuNKBrNfQ2iDmsGc18ia42dfPG\nhOhUjmVP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2512", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2512` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAcZj2VXX4smhFcTTIJtolVuLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlZGI2MDI0LWFlMWEtNDI4NS1iZjMwLWIwMzcwZDlmNzJjMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2MxNGYxYTctM2Rh\nZi00OTQ1LTg0NWUtYzRkYWNkNzRiNGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECQz3x51/OyBo9dHly+yFNnIRr2SeW03PAsd1dO4lr78ysOCMIwrJ9ib2njYe\nD1oVit4aSSZ+j0AxM6aRrZTkXKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcT1Qz0POVdjXwKN5nxxPJ1ON5RwwHwYDVR0j\nBBgwFoAUf61nUd1J4tNoa/Z17RsVWwQw/5kwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDI5d3/iC49VBbgE5uSrWnSFVQeyriJx5t5TTMe25OqRQIhAPFA282z\nWPIO5gssFAFiZFmNdCpFi5juM5LG9kuXqjqP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZxei2xaBsk7fyOkHrsUGJdOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWRiNjAyNC1hZTFhLTQyODUtYmYzMC1iMDM3MGQ5ZjcyYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0X0XvCFld1d4GXKCwego0ovez0M2W+GcRd1KtEJyrn0u5\nzWps7lzy5ZF26U6qn8dogpR+CWEFixYPQd2wtAfyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf61nUd1J4tNoa/Z17RsVWwQw\n/5kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJQ5nCRdErLXe/5JHYhyVnQF2/FNStlAa488y8VVI30ICIQDIhOhZAC3B\nfH2X7mMsHIK2LSf2uY7BSkDBENjBQpmu6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZfvEsqXcSO/XLW15droSSYoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2MxNGYxYTctM2RhZi00OTQ1LTg0NWUtYzRkYWNkNzRiNGM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2M1OGIzZmItZTk1ZC00ZTMwLWFhYWItNmZhYTIzY2Zj\nOGY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAxNlzsWLpqBQWFHK+Bc0iCr3\nc3uAqVuWaWkMYL53PnzW3xLVVZhnZTQA5Y7+91ahJidgVhBVa2axrueFmiVU36Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcT1Qz0POVdjXwKN5nxxPJ1ON5RwwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgf+2ZEDuZwti0Vmvm\nx1sjsTaGIcqzliOH3EMQa7NbR/UCIQC5etEGhGaXIa3LDllYWDo1EEM7P/lIEaMB\nflPS/EMUBw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2513", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2513` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAVypBXIq7tAhEQX9dNNZTF9tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2MTAwOWNkLTQyNWYtNDlmYi1hNmEwLTE1MjU3NmY3OGY3NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVlY2FhODUtZDVk\nZS00MDE3LWFiNzYtYzFhMzFkM2FhYzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYTNDk77j3k0VF2IlN56OxbRVM2e9PH6d/I+KB3LRxJSgZimy6Q8FVAfEhMlY\ng5d70/sz/Lt+Xc9z0U1Lj0xvuqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8YitRkkO7V5NN+LFrH9RuT4MB8swHwYDVR0j\nBBgwFoAU9OhkvyZgDJxqP3RuscBEyFf/1wswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIAzgemv3QS73dUtCRhjciTfTQe/ZydaUZroI5HtB\nrh7gAiBpYPkvK9hdvLrE0WBTu4touY8e1p9QhI6XV+GgYvkWuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdm8izFl8j6B38lS8gMrPbaYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjEwMDljZC00MjVmLTQ5ZmItYTZhMC0xNTI1NzZmNzhmNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQL7pntoJT7zxh97k3rrmsT/j98drw4v7VmKs0qn7H7Cv4E\nLijqo77Ou7C+Mo7REGUq7jWP1/ip9AYFOs99qVJuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9OhkvyZgDJxqP3RuscBEyFf/\n1wswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIzqsdyQtJFK1QmFsHV2PdPM/ItLENAlSY3wX++Q0w29AiBoJqkGE9L5\nmRUi3LXkLk7nORzGSU2DY5Yh4+iRHZq+kg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISARNnCb5nSayBHybfYG84gCw2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVlY2FhODUtZDVkZS00MDE3LWFiNzYtYzFhMzFkM2FhYzU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDU5MTY3OTMtZmYyYy00NjkyLTliYjQtNjgyMjBmNWRm\nY2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi6wOtUySn0RtUgF0EPiYRBuD\nhEFFqW3uKA8tHfvsnHNgEziMwO9PZ1/FC0IRS5XnNSjmMVDAdkLxVStwooI+MqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8YitRkkO7V5NN+LFrH9RuT4MB8swGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgH7j+w3fNqjmyTe/k\nkqzWoiqlA8g2NZDr+EW8qSyEtHECIAhx12JvJDz6B897vtTOFUDc8Sco3ZCzyvMu\ngx0uSIcC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2514", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2514` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAaMqBaL4CYix3MflYeYSwswGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwODc5ZGQyLTY3ZDMtNGEyMC1hNWY5LTg5MWExMGM3ZmQwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGUwOWUwYzAtNTMw\nZS00NWJkLTkwMTMtZjBlYWI0OTI1NTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESpfxvpL8YX9QwnxjhjoJVFwegWXzhF1GCsHYAbZUojkbLez2+v1rMY1MBtcY\ndjqAoD9ZgG0mYDKuliLA/YuKLqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHY4Y/pbusakm4GyWWVKnly5/qFYwHwYDVR0j\nBBgwFoAU13CHZ9NKLbjXn70HarEuOFYyD5QwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIFrcwOqSB71cTgEDo+vKOctl+FwnEsrOy61aZT2b\nq+D9AiEAsx21ElIAVOUuFSdQpRECV/4Mt+cRImUjXnp6Bh9UdpA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeU57qYEtRQLnQiPu+Zo7q26MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDg3OWRkMi02N2QzLTRhMjAtYTVmOS04OTFhMTBjN2ZkMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjSvSWyW25v0fzUSH1E331xRnMF/Z4Sia05CZbAtxMSxnd\nRzys4rEEYAku8UeRAHbNNccuarp0nhQGzz95+vO7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU13CHZ9NKLbjXn70HarEuOFYy\nD5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgffMuRP/WWG0bzbX6bTSOU6l3TwUV73yzvNRDBmCH9awCIQCWqIJvltp0\n4JXDM5i42lIiILHW+kuxCgdqQQEtnKV3fw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAS+Nyguv5IAu+qbPkEZ22NOkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGUwOWUwYzAtNTMwZS00NWJkLTkwMTMtZjBlYWI0OTI1NTRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGU1NDIzMzktMTE5ZS00ZmIzLWE1ZjMtODU5NmIxN2E5\nNmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7qr+XwwgRxAI9sKdDN8An9Bm\nN0PmShSuzxQPQWS8jFIrWUHQyNgQPpqiDwSz18L0/z+rrHrqRpAPBFajaN+hIKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHY4Y/pbusakm4GyWWVKnly5/qFYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPc0VdTaIKA2beYX\n5sFubuvZqyidlkb1Babejvf/XUnUAiA2/AVKTZ4cVnsstfQQM233g8cRx42Tlkt5\nQQMuFMJ5Lg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2515", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2515` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcU/zYVyE/UgtotC6bd3kDiBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkZmNiOWZhLWVlN2MtNGYwYS05MmU5LTMyOThlMTBhMmY0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYwNTdmMmItYjU2\nMy00OTMxLTg0NDctY2FiMWQ5NTQxZGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4rKfqsGMUsH1AwTBl1apjz3l40mL5h/ySe4p6+p+m0VH5+3+MEA/NYwSuXhh\nPmw968H0Op9ExZbD6SGh/LkDG6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoTp2C9TolXwp2fkXqOe/t+P6bj8wHwYDVR0j\nBBgwFoAULeRwleMohp7eR8LYW7vM4VsUXz4wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIBUJXLuamO35QHO0EiGNw4o2STDFCIJFewiaJheUF7xqAiEA\nyk2WFs/xva2i8t/ujZNFoS7seqxpSZpptuH0AZPu41w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXpHdBVEg1mFr+slQlXgzEAyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGZjYjlmYS1lZTdjLTRmMGEtOTJlOS0zMjk4ZTEwYTJmNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIzC4q1jANGLX8lx8nMKK/i1mxNHFpMSDU7mqpI9ztfHZs\nwnh+0zFqIL5bZLogp2k/UBL6E5VPrpiw9rvSwlTuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULeRwleMohp7eR8LYW7vM4VsU\nXz4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIAdweArNsLH2oD98dY5iK/ibxQ+Adi1321U0Cb2RkZXAiBCH9bvsWLF\nRTZUE9tM0WgVQ2v5CHC2BOLOfMO/i5OEwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAS8YPpF56X/lTr6VAEIEpWzBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYwNTdmMmItYjU2My00OTMxLTg0NDctY2FiMWQ5NTQxZGQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTVkZmY3NjQtY2JjZi00YzhlLTg3ZTAtZGFjOWQ5M2Q5\nZDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFuaPn44/zmsMwZw6oYoMqJse\n0lb/YhxEDZM73CsKjxQUG4EFc9bPRi659hDV9v0i0MEcH4AHDk9jFWgb+yq15qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoTp2C9TolXwp2fkXqOe/t+P6bj8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgJPzbqGaoLMnhWW5R\nZlFvX2YWNT+yWJrLzRsRdPiUD5ICIQCEGhufHVIMIh2rPfwiyX3JaZ8Z/5EcfPb2\nswKRxBaXHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2516", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2516` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAb553ydXFdGnXh7h38CBIdpkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlYmRhNWM0LWRhOWEtNGMwZi1hN2MwLTViNmZhMmQwYTY3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDc3ZWMwZjMtNTM1\nNS00NWRkLTk0ZGEtMGUxYmJiZGE1ZjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1s8NfI96q4dXGv9P4AN6DcQ+O3xxLuY73aYuTIOObEEUhTTBnxAbvk3exbgT\n80EvV/OIUnaOBaPegEnrQL8P4qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJd6fDSvBSOQU+UKZZfDqYf32rSgwHwYDVR0j\nBBgwFoAUvLLX2p3sqK+doN4KCYGAsVp3pQwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDRHdeL5hK9d2SdMqJgS3OfoyaKJijVQ\nVq5UceBHQfkyAiEAy+0TCgzi4fSx81g/Qmn8l2KRUrRkr9VTPKP87zG6IeI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASLOOA8ttd7NBtkGtXlCwkgKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZWJkYTVjNC1kYTlhLTRjMGYtYTdjMC01YjZmYTJkMGE2NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYsDcM4CXoBEFF0bEN67p69ds1eqhaSK4gdOwUfr4MJxB5\n2s+fhIpoQK6wuENS602JE6lTqXSR2B+9TpUslfKKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvLLX2p3sqK+doN4KCYGAsVp3\npQwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOwWS+r9se76mon/PQcVsIcPHiu8gQc6x9cL1hzkq/AHAiEAyT+UDyWj\niAHSnyYYKSok1C37kToW8/0+nwBsNIm++/I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISASapCcyFpCMnKrk6TulqbGOwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDc3ZWMwZjMtNTM1NS00NWRkLTk0ZGEtMGUxYmJiZGE1ZjJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGM3Y2ZkZWQtZTVmNC00YWVlLTgwNWItODZjNGExYWE2\nOGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV+8EecADSo24eRLykejzJ7Jn\nKhBHUdDXBi7OqjfSxczEVlDp6wkjUIyaiEshwVfey1Dsmj/MAw7Ij1u3mmE9p6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJd6fDSvBSOQU+UKZZfDqYf32rSgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgWtHeZsP4wyKB7lhO\nEynlns9bcmgVSwOa3/a9zwdod50CIH3tc2L6F+GUFR2Ld0jVeLnrPZz1g7syPD/7\nBSv3w1cl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2517", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2517` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAbVq/CvmgCxHn4vKPy2fhyClMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwOGZhNTQxLTI3ZGEtNGVlYi1iYjg1LTYxNjYxMzY4ZmMwMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGZhZTYxNjYtMmQ2\nNS00MjZiLWE5NTQtMmQzM2ZkNjE2YTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHxHcwRDkb3ZFgjy6uB4d5uVQD8XXOaoAa4xBEfhNbmQ+7NxTurn5mHS0RjLN\nGbERyOPh3geQ3uIa7k6e5rEWYaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUevpkPlgVATMr5WE9vrycVODCwDEwHwYDVR0j\nBBgwFoAU3Reb5rNanFtFbJ6FBX56kJcz9v8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCXDeF16FaLpi7TpMrYMYUOSJ2RfuJc\n0FXmUTJQzOPQTgIhAKXD2pMlPDn29YIPeNhM835R7+RM/BCgN/gzc5rZphnP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUFSQKmF7H/DclRUOowQWLD0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDhmYTU0MS0yN2RhLTRlZWItYmI4NS02MTY2MTM2OGZjMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmGbSvXwHyHWBsM8FOO+GUxvo2NYad1argFMWg0idFs4iN\nMYWqQV8idLeDOJcJlZht9oDRRnW3FEqc3Ut9Z9ddo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Reb5rNanFtFbJ6FBX56kJcz\n9v8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKQvoYjOWlIZ/bZUtsM+rECbXW4FGfupxCJrk3NaGbO2AiBgWQ96Wugb\nj7396WI87LV7mQWY6BaFxpT3zQslWanpfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAdSTv8KTwLhkjahJo+a2e6RpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGZhZTYxNjYtMmQ2NS00MjZiLWE5NTQtMmQzM2ZkNjE2YTI5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjBhNzNhN2EtOWZiNy00ZTFjLWFjZmUtNTAzNzNhMTM5\nODk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6lBq5Trj7aCpuqXPcQEgTGx7\n8BIA8ljCirr5BRlv00TvmDM6V01TvfjmQ8gNmQqs79VgQ1AlQpYMLQxwALTBfKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUevpkPlgVATMr5WE9vrycVODCwDEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANNJgi7yypcdSmSW\nd4F2gXxholJ9FFy7WWagk7IlckLiAiAzQT5t0anWm7s7EiXsyUPusyzlStozWyGL\n0iSrHU1ohA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2518", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2518` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAba2L4UGpa1oSbJz3xahd1YTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkZGM5NjIzLTRjODMtNDk2NS04ZjY2LTU3YmI0OTAxOTI3ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlkZjI4MGMtZWUw\nZS00MTYxLWE1YmUtZmFjNzliMzU2NzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESfIoj6c512LkfeXdnP07aoYWJdBpwhH80hQXSOUVpEEp4vHV4CN2tunxOHKI\nlMlOSV89EOHGqKRw7Yk5po9Qr6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLZDztAO4TTZ76T4S+A8GXE8YVVOMB8GA1UdIwQY\nMBaAFFDnCyxZA3JnEsciREDbut9LQZWNMAoGCCqGSM49BAMCA0gAMEUCIQCCdOfB\nKh4R9sSykWLjnaW3mn/SmLtzFXnM0Gd0zMo71AIgfl7R3ngAkJp63Wf73lc/Xjfy\nbV6iSEHOn7gk5u1RD+I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXlXMaVk3XhFvD70OclRo4tAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGRjOTYyMy00YzgzLTQ5NjUtOGY2Ni01N2JiNDkwMTkyN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9VRrZMG8fIlwucU87Znqu7tTDAKxbeUFdPRxP3C+ArSum\nWHsY1Yy5kWM2ftfrm2/M9gQRLkF5J4ZSCa38iQjMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUOcLLFkDcmcSxyJEQNu630tB\nlY0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ/SjsNX3lSdJYQPSpvhO1Ml6SqiRXuh8/2B3+BpTFIcCIQDfegIA7xM6\nPt9DbI3aNmQcLCxuOUvYmxZbXFv7nzDVQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQz7bjdB4YoW2T1TBUS5SPKaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlkZjI4MGMtZWUwZS00MTYxLWE1YmUtZmFjNzliMzU2NzZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQ5YjhmMDctZjdjYi00MDlmLTgxNzYtZWMxMzA2OTE1\nMWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENPqWuA9m1OEloPTQKpJek4kS\nd8Y3BvRiVz/hXysMEnKGbnEqbSbGzaU8UVEpJsoZ6ygJQVLYRBw+niRZMA7gzaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtkPO0A7hNNnvpPhL4DwZcTxhVU4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhANbyVgN9\n9JVITsg57achKjOAaqO+FRpYJdIVNdNneLhzAiAlAajYRez23LPNO23k2fg9htCo\nFYXVfH/Juph/8J3G8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2519", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2519` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZQo5N+aJEjU1sEr3XsS8LmMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmOWJmYzA4LTM1NzgtNGFmNS05NGVlLTIzOGJlMTQ3Y2U1MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ4ZWYxNGMtNzdh\nNC00ZDMyLTk4MTAtMDFmMGRkOTMyZjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEySykBAVSsTl7iV2qbJfmnfuxWqU5Y6wiFBoJHIYwiLSHiCLHHB2EG4RxtaOu\n/Q3i6jAV2OeNDB5WKS/0E3eO4aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLDIYb4iwi34qpKMTP+DIokPO04LMB8GA1UdIwQY\nMBaAFHArHsc/fNMRbHEupg5PRbU2HarAMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBc/c8D0T+cNZ4jFelkccS5E9jqGTrHvWAD\n3iudUCHA0AIhAN77tx85d55I02tTj81mCLdNgJRqNyaIf8KAqVvTe6G3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWoSuweSEJO+Tb84LFHvTg+EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjliZmMwOC0zNTc4LTRhZjUtOTRlZS0yMzhiZTE0N2NlNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1aPHsZdBGlYVKSF1zKamJjYUvY37n2SwXQk49pC0JvhwT\n5Avabw7KgR2o/wnWSu99aO8fOfozw/DDoExx8os4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcCsexz980xFscS6mDk9FtTYd\nqsAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ++FmRvhCPipinxaehc1KNXwDwCUuocBxeShMwCDa10CIQCv2bS70p8Q\nqXtBWs3S/XO1HMz/Gm6cXHj3LvRI7vhKdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVhWYZ+beSOnpTqVxaAm068rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ4ZWYxNGMtNzdhNC00ZDMyLTk4MTAtMDFmMGRkOTMyZjYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmI5MWU1NTItYmI1MS00NzIwLWFkNjgtOWY2MWIzODAz\nMzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8zwNiOJtY2xXzAHZhtotIPEH\nkXYufFd9WJwMpmQDDOnwazEWxoBdugDvkjMJMBWbcqQy8/4x96Jpy4tRqcGh9qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsMhhviLCLfiqkoxM/4MiiQ87TgswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgBZVVSgyl\nX8nez5SxF/O/gE/vVaYAzB8PXIvKbFmxxnsCIQCFU6GpW50yvEsXV7q+yv3Qzjvw\nnzjzJ3ci+N50eG56Ng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2520", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2520` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZ/IyuJR37tp2J3smCR93j9jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxYjE0YTRiLTA5MGUtNDAzYi1iOTIyLWFiNDQ1ZTc5MWNkOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFiMTY0ZTctZDk2\nZi00MWUxLWE1MzctNGE4NWZhNTY3MGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAY6UWEjTNAHxWV78ZbC6zVP38QhDXmKjqSgiYK/IKnPF8w/yGP6BEHIUhED7\ndbWMaZqUSK5szywG0diDcew4IKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKyQpVNhBBfc0IEPeOxxFhfAM413MB8GA1UdIwQY\nMBaAFGvQVxg7rCiudTsT2ImhjDUNTv1YMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBXM5pudYENPRTv6UvUzVqwJyGH/n6UEuVq\nXA/mRG75sgIgBndInKB+PaY2n2EHoYFDOoc8s8cYqrWpz92AU0FZ2kk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT/9GrsqR4mZHrDZRlFNdzjtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWIxNGE0Yi0wOTBlLTQwM2ItYjkyMi1hYjQ0NWU3OTFjZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwoovR7AIBDcePv3YeG+MYeXFfmxuGcaOaLd/zECifZRw6\nv+JRi5/Ac+8w6DSq5ysVGNfuQWQQSWCgkXz19h0bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa9BXGDusKK51OxPYiaGMNQ1O\n/VgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgel8XMUzzQ8I+PqCfqHnEdezGhNKKhCy74Bqa+0nG9s0CIQC15ZmlOwaH\nzB3dD+pozlUuAo82cB6KXUMPy+JMGQQQKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAdZsFX6H4p1id9iXOmyvja8LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFiMTY0ZTctZDk2Zi00MWUxLWE1MzctNGE4NWZhNTY3MGM1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzU3NjI3ZGItZGE0ZS00ZWI4LTk5MjctZGY3NzJlMjg2\nMDMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYgUaY1RPW5oPC94gsJWt1uO9\nhBZVDk8hiL5JKu+II9lyivxkfp6tHhYlhI0M4gqamMtY2b5GjSnoTr8lM7W0laN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrJClU2EEF9zQgQ947HEWF8AzjXcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJhDjE+z\nkkT4sSKl2jFfLi4ZkeJowm8naeM5gnS1ezjYAiEA0bmfoeHD6C4Ss4u3ReWRfd7r\ntTeFZPG4gB4tsSKMVys=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2521", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2521` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAXEBViuTdSs0oTVQB6ZaLRsVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwOTQxNGExLTA0OTktNDdjZC05MWEzLTQxODA0MDg1ODhjODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VhNzU1NWQtZTA4\nNy00OGY2LWE3MTAtNmM4NWE2YTU4MGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGL1I+KT1ELbpgwTnEFWrAeCdjA5A95ZLfq/gIMt/UruGaxW7wHQQcB2fZUdO\nVTXc0U9JZ83257UeEASP6DZ1H6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRVsxAKPxibZhJaFo+QlWv7JEEIfzAfBgNVHSME\nGDAWgBS4T0/ggBZpqI1TP3LaJEBlz9V1WDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFeTkZClLFDBml68qGy4A42ikSv5nu/K\nWYNuGBOqkqodAiBS5uC2UPdhwF93CWeJEhKkz5PVlQPEG7ahtXNVRyggkQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcBB6RjMhGq+/5Kd00ZfL0/TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDk0MTRhMS0wNDk5LTQ3Y2QtOTFhMy00MTgwNDA4NTg4YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARogdcReY6u0yTH58eXZ5pz5S06o0Ap7tmavhb0AFU4/77r\n+upkwRkaZjKCshNDNVMc3YlLlQRkS5iUr+SkS5EVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuE9P4IAWaaiNUz9y2iRAZc/V\ndVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge3rS9wcO3enTkgNURsS28PKX+0SAZCgpyuB1LLgq26MCIAkzRkOkb6/m\n0life/N/R02IflodRjGHqyaQVyH1yNBG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISATYsO2Njntzk6OpR2P3bNAq4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VhNzU1NWQtZTA4Ny00OGY2LWE3MTAtNmM4NWE2YTU4MGVmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDk0MmYzODUtMGQwZS00ZTEzLThlNDUtMTU2ODc2OGFk\nNDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvu8SyXCytTdiKKg/+dG/CI6E\n9fqv3UEdDSxHKPiD/tAiLiqwLerdF6100OORpjrTR3/otXRlS7v+e0hAhIYtaqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVbMQCj8Ym2YSWhaPkJVr+yRBCH8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAPn8FDKp\nbaYmC9zj00/GZvAJ2GWZ/Dv/4K4LYz3i0Q8yAiEAjRIzcoT08h+6RkTq5rFSwfJP\nAvB0cTvgvgyBYzoU0cw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2522", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2522` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAQqtOF4r3vLx4j9wJkYrsYBNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkZGZhMGNlLTIwNTktNDA0Ni1iMTI0LTZiOTZjYTJmYmQ5ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM0OWY1YmItYjBi\nMi00ZDQ3LWI0NDQtOTE2MzBmYjJhMjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr2xPNDXkeQi7Ijv9ssHIpINdk43o4kOt4xOY0DlzNgPB+33IOKNrKyKzsP+q\nmbyXZJSyf3f1fyxS1I7SQ7GzlKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIlC2iWBfBj4S7wmaqpKJp+BnS2AwHwYDVR0j\nBBgwFoAUUxpw8+fnz9zNGOPzLxtyiPhXIxMwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBbvCe5wlFUIcV4\nPeN/kwpmjvF3KcZ12SV+Km6VxAu3pgIgJqKEYxZXH+ZtZZ5jqrKowoYyvywwRfKo\n6mVTLpfGkv0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbRadGsDc9wS8HNssMshspHQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZGRmYTBjZS0yMDU5LTQwNDYtYjEyNC02Yjk2Y2EyZmJkOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZvkIU8suEDfRirNmve7LOn6pC75g7HZ4QgVWTQ96hsAn9\nxW5kmt6xfivp+np2bVKz3/j7WJ+nSUFXoIasgtzro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUxpw8+fnz9zNGOPzLxtyiPhX\nIxMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANPw+A7ftS1lO4S13fbv58RDTYWGOKCS96YePdXpBonRAiEA5mSBYVzP\nfmTELzfwspM6ogsmaNBKwOwGvgJeZGAyG/I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAWWTQOvUMZ5rewkraLVUXkbAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM0OWY1YmItYjBiMi00ZDQ3LWI0NDQtOTE2MzBmYjJhMjk4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGMxOGU5MzMtMGQ4My00ZjA1LWE2OTQtM2Y5MzI5Y2E2\nN2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKcfQY5nKwohvohUIropeeEx3\nvSclkyYI+gl3rjif1MoUi6I6vidGHf8E69ztPkgtwZnFSxuevr/Bv6JQqV5QdKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIlC2iWBfBj4S7wmaqpKJp+BnS2AwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgAVboT2OQ\nvS59zV2q9x6BMuzz0Fr++7hH1kwyvhCVbxMCIEpoVCJR7P//BgsS3jx7QdWzbiwI\nNyTl6rLldejXjXNf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2523", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2523` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISASIl4tYHaMVwYZJ9G3nDucF0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2MjlhNTBmLTY3MTMtNGY4ZS1iNWYwLWU0NWQ1OTZhN2NjYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZkYjQ4ZTMtZjg3\nYy00NzQ5LTg5NzEtOTA5ODZlNDM1NmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhIKSoxjhvpvtZv+Nl6JoH1KbWfY8hVjdqIEGIV16Xh17VmMq3WPC96BbkBSf\n/5qecas0dHvPUhmg5VWdvJw7SqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSPgs5zOuJ6aPyQaI9T1Sz54PW+MwHwYDVR0j\nBBgwFoAUl09o/hkko2VJqhbvfBbmlfSYcd8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA1/2vjZOWSyS52\nmpuHBGwaYheWUinHHz6uOTRkrwSERgIgCa9NdfW8xmSSOF4dDSs3lyCfaimbAPst\nRF2bevcpXTk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZlbdbWcnkBIrhE6kF1HE0RmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjI5YTUwZi02NzEzLTRmOGUtYjVmMC1lNDVkNTk2YTdjY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkAaZCiB/latJ5MVefR7IPq/LY933aMZhSbI7u/lBmS1nn\n29bs0K3RpTcf4iEF1vHjTJvsShumCWSGyqmRsy3Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl09o/hkko2VJqhbvfBbmlfSY\ncd8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL0z3xZLLYkoaz1WKMEyuy4fzTpDxjwvQTHht4du2+uOAiEAxZOV2gby\nAgFAgC3vifuW5Hth0ZoIVKIv13A5XgwBBsU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAVAbh+WHqRWF847occFPklMdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZkYjQ4ZTMtZjg3Yy00NzQ5LTg5NzEtOTA5ODZlNDM1NmFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmFhODM0MjUtMjYzOC00M2M5LWJkYmEtYjFhN2UxZDkx\nYTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQEpXldAdEn3AA9xLf6JkBg30\njMyHxI2JwSyuYYU+T6fX4UIbzpxQkvcPAsoO6dLXAwFs9ZLO8tQvJUVfSmRDQaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSPgs5zOuJ6aPyQaI9T1Sz54PW+MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAO+SYAOB\nUQFrHRQfmuUVA9VqHJsOVvhip9SRCof77FZ6AiEAl701SzE68qxmrGpXBguGGgqO\nS136CYho1PeXwslEVHg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2524", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2524` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAfTAFEhR2jOI27HJGk9IPQt7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0NTk4ZDhmLThmOTYtNGU3Mi04NjY1LWY0ZDNlYzc1NGVlMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNmYzViNDYtMTI3\nNy00YjA2LTg3NTQtNTRmNmZkNzk0ZGNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET1McBXZ977OsXkfou2A5aRaob4KK92nbkArxUgIpSwT5Lg4t20sy74pi8anO\nMNBaB2ZWN2Qw63VxjpFygffGLKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrCZREKk6BYVeAyg9glf0vduvbtwwHwYDVR0j\nBBgwFoAUtg4hBBfI2NIskc8XeN+5x6rXhygwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBgzfevzxxUQBBj0zQM6eq1\n5UZOgom5cA6xzg0Nm0DXzwIgRVW52qgg0DChS9+PHy/IrKzt89ICjEXgqc4cRFZv\nMBc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaas+Ts+z/f4D+OZjjlU78FzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDU5OGQ4Zi04Zjk2LTRlNzItODY2NS1mNGQzZWM3NTRlZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnL8yrsqAeI4/onQLdIEm8hfRetL/KIpt16q1yUpQ4tTbF\nWZUYWx5J+z/xzCe8Jox6cgT58IgZ64ZTus1oylk4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtg4hBBfI2NIskc8XeN+5x6rX\nhygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDNj4rYLddAjeiXQMMpVP8whZcT23Sp6lLdGSp7y8weUCIFYSuV99J5lJ\ny/ZKvxe4e2n/LthXvX/rMh/j4fEynMI3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUatrKJx1ILDzie8toEw0ptLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNmYzViNDYtMTI3Ny00YjA2LTg3NTQtNTRmNmZkNzk0ZGNlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmRiNDBmOTUtNjI4OS00NDZmLThhMGQtM2Q5NmEzZWVl\nNWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE5zYrvuTjpUqHEgSBayKoSRi\nKVUR8M+16oSyVCZ5cQct9GZFuktH+ejvkLmwaGsTAw0Ydxu7/yKnZYi6ITJQn6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrCZREKk6BYVeAyg9glf0vduvbtwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgcH878XI+\n7uqde7YjPxZOUzSz0TlabthQycSiGhAdjTYCIQCeip2NTfmycMTBzwqEXDHMVL0o\n3xwKx3xxoiHqtejEMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2525", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2525` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAcg2IStN2PHfBHK+I4KvV4p9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlNzI0M2M3LWI3NWUtNDk0NC04MmQ2LTgyNDkyOGY4YjIzNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZlZjhiOGItN2Q3\nMC00MjVkLWExM2ItZmNhNzE5ZmQwYTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsZsEunO/xP3KxOByjpKTNqD6gv8I3Li5eNrxUiHYVHjPpVw184sjZ8as6Kp4\nFnKmUeiVgfL2oP5tAB8yhWChd6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUooDDmMM2GkiOD/YyJpMlAbe5QAowHwYDVR0j\nBBgwFoAULdmWHSCHfXqizrHPWBtR9nFNprEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBT374Q\nxzvBONVrnmdDLDd6S6qagJUAljqCr1gsfngZvQIhANUj3cpmDadKNyvkGfs+4Ref\n1QRYUJjjJ/uFUeh+fFfd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYg4+P1z3yIAjaKRIk7cuMYUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTcyNDNjNy1iNzVlLTQ5NDQtODJkNi04MjQ5MjhmOGIyMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARljPrdO2LX9Egi1DRVd/9XyXsQjuTAlCALerQgRT4NVSst\nJpdLvGBmYRf+F5oaZUyUqxZvtj3EanQUaSr933c4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULdmWHSCHfXqizrHPWBtR9nFN\nprEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbYCwmvchi2X8dgmuBlZ0S4p9TT5poj8DCi/khh3NUAgCIGPEFQqlYWZK\nwG0kFn4qCYgZ2UnM49mPmfsSWOkR+ylV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARTUddHSyktRuU2Ie7XV90ZmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZlZjhiOGItN2Q3MC00MjVkLWExM2ItZmNhNzE5ZmQwYTM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmI3NjY0YjEtNDAyZC00MzZlLWI2Y2MtM2EzODFkNmVk\nNjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3TeO0gVSt3+Q2D3M4GONNgUK\n6moR1hlIsLhcjP8zgUSN3cXVaP6DiYorfFEyGa33wOc1+LaLWT0eRIYwl2ILW6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUooDDmMM2GkiOD/YyJpMlAbe5QAowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgCSZkpY5+\njH2++PUgd5INbBWDlSrSzqGDKxlXG4QJ3d8CIQCoVDOzdABHj2JXMPyNDlSruZVf\nx9oitntBoogUrmGSfw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2526", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2526` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAUksssKF+EHCv6mv1JDSFAQgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0MmRhYTZlLWZiZTItNDVkYS1hZGY5LTA2NDljMTU0MmJjNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBkYmZiMWUtNGJj\nMi00M2UyLWE3ODUtNDEzMzYyZGExNmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDk/NjBCRx63WfrhuZGL9O2zw6LJiL15asIPNkQvJ2df/jOz8GAvcYW4qPfM/\n1DcUyzKlTbXwPFuNF0OKrXgbkqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSeNb9FHoSTAgjlp6jUBACf55sWwwHwYDVR0j\nBBgwFoAUNxu0hGNsC+CFIs5/mzzgFzX4PGQwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAgYZk\nyis1/Xqp9fLN4nyMkTHqT6fICRHQ36q6JjRe+0oCIFPCmW81kYCCVyFSizlamZt4\nh8JNXn7H9kNIl1nDRLTy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXdcylOXfJS0ZDtnjmpU7g5MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDJkYWE2ZS1mYmUyLTQ1ZGEtYWRmOS0wNjQ5YzE1NDJiYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPDUwEyrp7IGXITdYLwG9j4fEPBKwKQUtXc+2kRLPCLBAY\nSlwrnez6ZFrEdNWKyTTazyMO5QdY/8EZNAYJYWSHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNxu0hGNsC+CFIs5/mzzgFzX4\nPGQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIinLENdSJ58s/ibwTitW/kTBP1JvT1+znSzwx6OQb/pAiEAjyPb9Xtw\nIhQjN5y282mJujWa9Eg7QU7a0kRwnSifa64=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAa39MYnk4cdBNRcZaidOkqXwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBkYmZiMWUtNGJjMi00M2UyLWE3ODUtNDEzMzYyZGExNmFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjc1MzZhMTUtMjUyMi00ZmJhLWJjYTAtODJkNDdkYzk5\nMTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFtOgY/3Fwcuwt9cNSzJyHbZx\nxaJShVtBiTi3N3fg2ncjz5oAIWV97CRLNHdHCgpdF1/V5zz5v03Ru8y3u5qAXqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSeNb9FHoSTAgjlp6jUBACf55sWwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJycqffn\n1ABKFkR22YNMgsEG47Lgyd9dWhdyZvXpNAi4AiAYVLyVvGg4spgUHDF8EzAfdZJ7\nvduvBUWUveTsfJbTcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2527", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2527` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAb77PALjq90STcmbP6CLL1K6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZmVkNjYzLTliMGEtNDI5ZC04YTExLTQ3MGVmYWQ2MGM5NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGUwNjM1OGQtNjE4\nNS00NzFmLWE4YTctYzA4NGE3NGU4ZmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG+j7c46dSLurhHQE23qNsMgg+onQRHmqhi9hkznzF1KZ4/HgZriPbTM+qGQc\nBZw/P3WJtoOpw833f8/QthokUaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNTHE6zLXPqRiZ9mEjgQxTcjFjXoMB8GA1UdIwQY\nMBaAFEsKKNR2HCTWrJJ57RGNyHQ5OPFYMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA1MVPVuEbzDM/ojmrB8FByF/nP3z4AAL9\nhXRG6SI+UQkCIBXA/22t4cwMRPAnWKmG+5rxtvfyzAPPwwD9+zlqERnj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAabmi0BcmVWR7RX27je9VWRqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGZlZDY2My05YjBhLTQyOWQtOGExMS00NzBlZmFkNjBjOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/p8SFGJ4Kj7gXQMD/xWH+XQz4mfRZ5mv7L3cdRreQlVXV\n2T9QMbT5k1TnJPREkywLeuOO/YBjCeEUyMT+KI0Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSwoo1HYcJNasknntEY3IdDk4\n8VgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKVjY32L1sB9dhuDZEJzaCYNNapaMxe7cJuzvnNJ/7JOAiEAkJyxyxqA\nfbTDenhAlaY+LfuxBmDr5tMBOoDgdKzgExA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARqxCekGUhm6U2MeNztgvSV3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGUwNjM1OGQtNjE4NS00NzFmLWE4YTctYzA4NGE3NGU4ZmZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTdhNzk0MTEtOTc1My00NDhhLWE2OTUtMzM4Mzk5MDcw\nMDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEppwseXDOLwOWatpSR1rreTvp\nw9iSlV2GXpM2E+vyKF6eV+ZRAuW1U9+9YJ01PeI2Wjnf4Q747pceSZVDktMw4qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1McTrMtc+pGJn2YSOBDFNyMWNegwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAM6a5d8/\nfu/09/8cryh2YAteIp0QQRptDCueOcmbWfr1AiA0s1auacl17sh9xjTovIfeMeq7\nJCilDRiaH8rkxa2enQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2528", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2528` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAc8jTU6jzYS9qvyqNYE4SJ2jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwYzNmYmVmLTIxNDEtNDQ5OC04Zjg0LWE3Y2FmOWZlMDc2OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ0ZTZmYWEtMWFk\nZS00N2RlLTlmNTktMzE4MTVmNzc1OGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqGimW3K1aIvDNDctHseqqU4ClYF9Iz+kE7EHeTzva+PASj8JgikYK3cTYOaG\nZSqUzZw/b3jNhKiApmSfA9RrxaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlM7hFBVrUZpu0dAYVAilW+UNLKswHwYDVR0j\nBBgwFoAUjOh4MB2PfUjzaGzDw1f1WAAQpe0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPToN6M0ioQw\n+ggRRNwbfKDbShl5lyZ0boC0D0MqU/fZAiEAnQphxIwk3EPlxVIFdTgiS05MqFEa\nkzORJwhGrMkVP2s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUqirVYUiay2wT0pwoz6Sg+zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMGMzZmJlZi0yMTQxLTQ0OTgtOGY4NC1hN2NhZjlmZTA3NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpm8bHH04YJZTcRRtv2Vrub3OavEpUzGAhrvb0GddHzrYI\nqdR4n7qIgyspAdO52RHPpgAYtN0J3ox5Iq2B82hDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjOh4MB2PfUjzaGzDw1f1WAAQ\npe0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPLH/60Yhp+upAnigkhxoqSij1qiXCAMSeRWMKH7UcwMCIQCTlVRXXv3j\n7zTLF7HMUvL/5Bze3aqsU/PFXlDTTMgeCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASAcYRYMMdz6cFGL0M+9nhFzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ0ZTZmYWEtMWFkZS00N2RlLTlmNTktMzE4MTVmNzc1OGFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTlhZjE1NTUtYjhiNi00NzFlLWIxZmUtNjYyM2RmY2Fm\nNTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPW85DEOI3NOblHQClVbqCvUN\n4sYpbAKAgrUWhHGa+AG+9bd+pgctNsVbgrls3COoU+/4AYk6YnsL9/rsvE/pzKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlM7hFBVrUZpu0dAYVAilW+UNLKswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgNrnldLMx\nM6HkZ5WT+v/toWj96FW03ASRp+d0JvtS5FsCIQDdaiuSS8bLDU4YDHtAMca592pV\nk0FTePLgiQv/il7L0A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2529", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2529` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAa0CkLtyHVJN67x2nkBzZNKqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmY2FlYTZmLWExNDEtNDEwMC05Y2JmLTM0YzJjMDk1YmFmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZkMjdhNmMtYmUy\nOS00ZGYxLWJkYTAtNWQ5NWRjNzFhNzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESNKuGEkELL7yn0gGRQDHkGiXpkjkMzTjPfwvDk6LVBNckzK/YDMCpCRnncbw\n3Zk7bJZ1WwMuqZsTc4B9ttukw6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmJ6bLQtL18GExswuIsLOEMqZVWcwHwYDVR0j\nBBgwFoAUgBjuVHPLYqE+AGLAB1RC1bEa9BwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgHsFajeB3JXpB\n8LT8eybxNsfiQxDmT/y2jQ7HltPEQyMCIF1karYXsxjVaPjAzpNj/+pmBS9lDT9k\nFTiCVHNZTbMY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa+7i7/0j+N6ZEKbJriIxKY8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmNhZWE2Zi1hMTQxLTQxMDAtOWNiZi0zNGMyYzA5NWJhZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWnftjSGroANNLUVndWVDgz0A/dN/v3TGpmrUIHYJuiD8E\nMy63pPt8IZjIy0+Uf4UzHxgsnUGMVeOq/B44hHslo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgBjuVHPLYqE+AGLAB1RC1bEa\n9BwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCIpQvpUSD0rn/3UYGeleJCqwI3IKAb5tuscjm2CNMiYCIQCgAnrPKv3a\nrz8EhgPllor4jYNPFRCcutS6KRt5klHYRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAbgagyr6fiKKrleEsiRnR2o5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZkMjdhNmMtYmUyOS00ZGYxLWJkYTAtNWQ5NWRjNzFhNzM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWMwNTZmMmUtNzA0MS00MGMxLWFjYjYtNWZmODcyOTM5\nYWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKHx+pSmIzOASYTc2lg/imzSI\nheWrXL/AOYbGsav827xtW4R6jv6MdZEgzP8khN2+56hRYncUfNtlavbF8VPh06N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmJ6bLQtL18GExswuIsLOEMqZVWcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgOCzTYZFx\n7fJ5diLpWxSfLARWa5o6rIrdpKiPo3DaeM4CIFu2yQN8OHy7u9bs5/kP4PWHiBYD\nMZMrf5qZXeCuiWQw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2530", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2530` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdvr8LfAJ+9TzejJX7Pmgi90MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzYWUxY2M0LWE0MjQtNDIxNy1hYjE2LTRkYjA2YThhNjM1YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDliZWQzMTItMmRk\nZi00NjZkLWIyNDUtMWI3ZDc5NGJkZDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIVFuEoaJ2ZC01Bz3ciKtH8Na6y9xPLfxrKbxdWJBhPSiFHfX3fKSRcOVzHwC\nVn0jH+49dA0/qTmyOW9Are/2ZqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBjekGzf8qdZPiNBPnF6Ad531EIkwHwYDVR0j\nBBgwFoAUsIyb9Fqb/LcVDfHeKv+6y/I3RlEwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEGcVoTFQPdA\nTueIfKDb+XMCtWrqxKQQF8u0X2KYAFeKAiEAxmGPzpZ10jsbmRZ7bjHO5B7aqgPm\nl3IG9KQHTM/ci4A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWEwmtEM8JJ7xRvM5EetE23eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2FlMWNjNC1hNDI0LTQyMTctYWIxNi00ZGIwNmE4YTYzNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcvRbc9P9EvJpEXJktTOczm0TpDrByWXIGnLvuxL8OuJRm\nEGgkKS6eqwchFPEdzm/VPJ5hoi6FEy4IyHVq6FMwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsIyb9Fqb/LcVDfHeKv+6y/I3\nRlEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT9Sn7HlTmZNUTsr6PRVp4cAzqyAMV5EJbuFoxYCj9CgCIHOC2spEYDyu\n5LNy8GZwvi9pEZCGICukeo6jCXB5XLLG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAcTbM0mwfNjeTAgmYW+cqDNqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDliZWQzMTItMmRkZi00NjZkLWIyNDUtMWI3ZDc5NGJkZDY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGJiZDIxMjItZThmZC00ZTkwLTgxYTktZDlhY2Q1ZmQ3\nNDI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/3jOD8MvNANzZ7fijYj/j9IX\nKRprMhOOxCieDZuKAE44taMv7607aDevwXKdxnJwkLZsiyULdeSZVsXIOwQScKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBjekGzf8qdZPiNBPnF6Ad531EIkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMoa/jtG\n0tpXLmWcIVGGD4fcU910PpqnW+G1B0XyN0kIAiAttttZSs/VSMzyIU9ZCbodLG+A\nPQSm1FepHhYE5EA1pA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2531", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2531` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUR7r2PoknYZP8KKbNIozkufMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyMTIzMTJhLTJjYTktNGVjZC04ZDY3LTgyNmQ4OTkzZmMwMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzI4NjM2YmItNDRk\nYi00ZmJmLWJiNzktNzUxYmYwODQyOTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ6EaMxSzEnh8qmHsYJyxuJZqglJ6MzdHAwLtReu0efNnj33J2FQ1518/l27S\nmnxwCUnhv/8EHFayiJSlAQrXqKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVcHxz62RdscnAe2xFyHGX3qSQBQwHwYDVR0j\nBBgwFoAU82KxSFpq/1/3c4Ikz8bCbVYCKbUwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDfGQwXCUHCweuOtcq2zzBfVhO+9W2fkqf+52db/A2nogIgMMljBz1hYk+m\nonBx05NW9h4MbyML9hBASxhSfZ1gvfw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ8N2c9IqUTDHMr2bkBEVFGnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjEyMzEyYS0yY2E5LTRlY2QtOGQ2Ny04MjZkODk5M2ZjMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATehU1Eg5hMeGsq8FRYBqScKTfrxFJm7sif0yNW6tbVdhM+\n3x3CNCw/AQQHDUROBURkk7AAVvYcknWgKRSx3jVIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU82KxSFpq/1/3c4Ikz8bCbVYC\nKbUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfAka1ffJ2jgw17J9NisMuUaAVpKj9Vai4ePQGuysxpcCIAjFm+4tkin5\n3o3PeK1OtuTBtvFT5hzWxhn1LYHQd5nJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAakyflTo9MJzkeqR1+Gkg0BTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzI4NjM2YmItNDRkYi00ZmJmLWJiNzktNzUxYmYwODQyOTE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTFiODdjODEtMTAyZS00ODQxLTg1NWEtYjI1NTBiMGVj\nOGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAZQRVNvGcGEl3ZmzeR2Y8Yrd\nXoLl9qGp63o5TTAEduR8yGwbvtAh8Wj+RWrIC3F0NmH2vnG1XCtPHE7sEi/leKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVcHxz62RdscnAe2xFyHGX3qSQBQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgZszx7uiR\npiPRfeaEQzNSa8ILPG4Y+ruOAMFH65mcknACIQCa5kFYgUk+Hlbh4s4jiYj5NEyF\nM/vRhinfIUjJx/MLvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2532", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2532` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXLIcf6fes9UhMHXVLIHOpepMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyOTZlNDQ2LTFjZTAtNDVhMC1hYmU2LTJlNmQ0ZTQ5ODVkYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU1NDFiMDEtODBl\nZC00YWZjLTk0NWMtMzM2NTJhNjQxYzI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQBIyeYBZG9Tz5KJxl4qxVAg+v2baF1Cn2QWPl5VQSFSn/EncWJzFTiQPnZD6\nErFBw7lMbRpJZMXuYuAaqbPCu6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA/UrnSN+7TM2twRGzgeUqGzhqu8wHwYDVR0j\nBBgwFoAU9Ix5gaxR1xNnVYiv49Vrrx8HFfcwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC3zkwzjUf7tFQLmwCB07FU46OU3BXfirxhLgn4nbD2/wIgR6fn6VlhivOc\n3u6TSKNhP8n/zeDbFEd4/SszvXkln9c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASWJBglx0KJE0L/9QUNUyDsaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjk2ZTQ0Ni0xY2UwLTQ1YTAtYWJlNi0yZTZkNGU0OTg1ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARB8P0xphZHHuLvFzDD9mZeCukgSU4akXG1/gGGac9m0NQk\n6ov40wEKaF0Ri96ba19FbqXb8/M8x/oFXJ6wCNKNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Ix5gaxR1xNnVYiv49Vrrx8H\nFfcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMZjivsBlHOriR8T2pFJ4Po/DHvYmevfDn4U5hSt20C7AiAmgBJs3ntj\nd9G/cwGuGxffz5XXb7Ht+1nPfRVUcRLQXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAetO3q5kQU/BeHa4AP/iA/dYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU1NDFiMDEtODBlZC00YWZjLTk0NWMtMzM2NTJhNjQxYzI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2NjN2QxYjItNDc2Mi00YWU0LWIxYzItMjQ2YzNiNjEz\nOGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHcwwd81hPXhHkU2eOH1xHD+q\n8kVlwnEyzo6ZVmbC9ObbhC8rFcqJYqanG2DlrG5oI9PvTVZieKUm4pa6L3gXHaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA/UrnSN+7TM2twRGzgeUqGzhqu8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIECuY9H\nfFTwEQI6jmHdWGDgCTO/OX6fOpuWHkOfq6ENAiEA203kcJoE69KWpe2QCBYv6MgM\n2vLpm4l4xIs+EtIIrlU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2533", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2533` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAZE+S1u2U2lIiojkVa39mKNNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0Mjk1MGExLWY0ZWYtNGNkNS05YzRlLTRkZjMzYTQ3NjgyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIwZDlhZWEtZjhk\nNy00OTU2LWI2NWYtNzkyZjk1ZGIwODFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEC5waFNMUFzYhP0j14nhOj0joneuieXbUTrx6AVNC6TgPSpMvjSU/lkZKcwf\n7IJAmT2a+ZtY5c2czQoTBJMBXqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFyxBE75U8nuOk/XPWybWlCNbMWMwHwYDVR0j\nBBgwFoAUT65cXDtFixzwBJb7Dd27qtrClZIwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDV\ncrnZ3H4cX8eM10lGspIQqSlP0djF5NZA1FK+zNfvdQIgKsaJhxbmyHhia98cBSYx\nNtaO05jyThcAanBIBqO/KPY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYiw6AEJ/8BNZC4zs4FnnTIdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDI5NTBhMS1mNGVmLTRjZDUtOWM0ZS00ZGYzM2E0NzY4MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcurZJDr4DsmTZOBLjk2CwyOaUH+Xcj3B15L6YZM+mBWZK\n5Sgq3VQKMbNBwqPJHIiTmw9N5s7zRel/gZcxajY/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT65cXDtFixzwBJb7Dd27qtrC\nlZIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM3oBrVgIjD7vOyXFiJ/0nl36RFl0FnjUt5G42SFhce5AiAsVwam5JT0\ncnObzk6BgF6L1VoMRl5BZgiNd9jylNsGWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAULqm0LwldNM9+xgX+IS/LkxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIwZDlhZWEtZjhkNy00OTU2LWI2NWYtNzkyZjk1ZGIwODFlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQ5MjliOWUtOThjYy00MGRhLWFhZjktODdhMDhlMjkw\nM2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUkBCL9cr9D1uu724q5iVPSu+\nrOP/zUfZFnkT7AZPWedsJwlQdXiu/oYgIsmgYmOTFzIa0IVviVgdEG5lZxEY9aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFyxBE75U8nuOk/XPWybWlCNbMWMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgFlKyssIK\n2pWjY10Rap0z2ln+AL76moFHYORVyKXo8FsCIBAqUkZPZVhtYpYqusoOjiKfCBWe\nBjOfY5akgkD3qxo7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2534", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2534` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAWjWtAocNggA86Q3r4RAZXTvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzMGVkMDhkLWNjZGItNGQ4Yy05YWNhLWY2M2RkZjM4ODI2OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWNhYmNjYzAtYjk0\nOC00MGVlLWFiZjUtNTE2MDBkODk1NTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELLu8UM1X7QlmgSYsDmA83/zAwaIunTzSEE+KXT16q2DtQWPT/XqFyV2hhdta\nId2ZmCBxlz3FHWDD2yNesBBwW6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw0LMOI3jNbP528f4HxSya06q65kwHwYDVR0j\nBBgwFoAUCYn2igRgVqB4asBsFESp2zulUAowOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQD6TQD1AiR7tAi0ZcXq92WRsfVjNPVbZJfTaYsvasO/MgIhAOv7\n6b+122YMRuvLazKuP6QTigqUrGue0T1tn+yKwdJQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcKJjr54uD/IO1EHYkILJZc+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzBlZDA4ZC1jY2RiLTRkOGMtOWFjYS1mNjNkZGYzODgyNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQsrySLG8/NtsD+M6x+Ovh7QRFa6LJL+1Yjy3htzjQeXGx\n20mjr/jgDKFhyhK0mJHTGc2PZHfEH3rPl/paKTc4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCYn2igRgVqB4asBsFESp2zul\nUAowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgblgXk2LNOT7YfRaL2nAAQH/EjB2XEAofyt0XrI7kk7ICID0xnrylB1Ig\nTOJjrahFWYl+BkGtzaIoZpAcelY2O3Hx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASOs/1BugQfQZYOKgDJaqcWoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWNhYmNjYzAtYjk0OC00MGVlLWFiZjUtNTE2MDBkODk1NTM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzJhNWM2YTctYTIzYy00NGMxLTljYzgtNjVlNGIzMGVm\nZTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyUvG6H+z/1cY/Teau5Yk0+bm\nPngScvNFYqzM8DhGyvukXtMFNswQEhQQlfO3AjHNmS89nQiUePAi7w09AEhzKKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUw0LMOI3jNbP528f4HxSya06q65kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAK6uPyK0\nKB8jdsTZwFStCv95q3c6zFPZjKWCdMqrUtTqAiBizhKxHB2PmRKCEVS+QMb0BSad\n88pBBqe0Qnbpan3tXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2535", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2535` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAW6nOu8ZDTyFjAgwYPKwGPcfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmZWQ3ZTIwLTI2NjUtNDFkOS1iZGZmLTMxMDVjMjNkYjRjYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RiZWQzZjgtZGVk\nNi00OWRjLWIxMWItNWZiNDc5ZWM2MzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx9SsPpmsALXxtp7vxT61sO0/dK4TAyyqsCgSw3tuGrXMgA8LaBmvOGUuiI8O\nzce6OAj2Xu8hjJUCozQC/rRSh6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUViKVlQRsUV4OnW5unswD0EGkOdIwHwYDVR0j\nBBgwFoAUdeGJE2y50B2cd4ZOG1s9Lry7ik4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDLcErz72bv1dDIXP8tms4Z1F2Ov8phj/hx/45MzWDt5gIgY8+6\naHoSS9tvULNH/p5Exab0tC9Qa3k2SrQwETafqWU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQZK3fex2LCIbCYJI/Xdz9AbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZmVkN2UyMC0yNjY1LTQxZDktYmRmZi0zMTA1YzIzZGI0Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShQvvESDvUTbhOgTPG3sFwo3cXuDMGldMLqoE1w0+YWb4d\nq05d3HFEb0D0K6bJscE/IB5Hgji6bZrA1Dkmyvako2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdeGJE2y50B2cd4ZOG1s9Lry7\nik4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPZQfGsc78nqyLStu26TLbqzugBO7OOKCQ0FD5hBiCbTAiBjlvY4y2zi\ny6Ulo8POoX647NoOAO+5JgGKh4E8w5NuWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAV65flriNlKh75+vi3EjYsDFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RiZWQzZjgtZGVkNi00OWRjLWIxMWItNWZiNDc5ZWM2MzVjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDE3YTI4MTgtYWQ2OS00N2ZkLTgxZjctYjc3OTk4NTg0\nM2MzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhtx+WuwUkHxvk9ZSqvk3hNKc\nqYhdzmOY3I2ZhT6AO0Zk0MGUyf7rZzjhrOAKTSbDF/M+5m+jYV+JYx1NyaSA7qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUViKVlQRsUV4OnW5unswD0EGkOdIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIJ52YCZ\nQV0vkQbbwr7/3LeFeTZebFWM15DpuumwhBHXAiEA180eZK00lLhLfckRj80vEthv\nlg9gQDW7NwAb22kwJIk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2536", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2536` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZIVZf1Ui3vt5e2TGxGOvce8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmMDdjNGFkLTcxNGQtNDM3Mi1iOTdlLTIyZGM3ZmI4ODAzMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJlMzRjOTItZDJm\nNi00MGRjLWFhNjEtZGNkMzAxZjZiNDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExdiyT9OehlLq3VE/Dho6cjGj1zo8PMwhtCJMPxMzo6z9qKP28V0VUOxGLVAu\nAFU8BsTGrmSYYRpcbGhc+THAgKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEm6H4gsvbXroGWuaFp+hKwhJiiHMB8GA1UdIwQY\nMBaAFFbCDzNYres3RZfcKQi82ckD5/FVMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBAYIo0UgRYrKHmYQHYXK5C+ypTaVg5QK88\nLQ/VpKhSiAIhAIAOgxiC/pdBeYuVc5tm4dn5OKacT8/l0T4gqTMtuK8R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZOAnSQlWnfkNcg1c36g24PaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjA3YzRhZC03MTRkLTQzNzItYjk3ZS0yMmRjN2ZiODgwMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7OBXNT2i1jr0Joi56S7pVfYgvREBagvWETiIPFoaFL0Q1\nnGInlWAB5GY75xPtXH3y791qavNe17Jc/U7diASto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVsIPM1it6zdFl9wpCLzZyQPn\n8VUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKamAqnDP8gHR3HQkdu40lEyh9G3sYpotiWc9wInlqyGAiA4/xtVXjCo\nCwL1PBEgsJ/R7meqHQqxxrBY7+2MfsZUBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZfR3j/t/g5Dwo9/+dFN0pKjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJlMzRjOTItZDJmNi00MGRjLWFhNjEtZGNkMzAxZjZiNDBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGVhNGYyMGMtMGJlMi00NGFkLTg0ZTgtOTdlM2M4YjVj\nOTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERPdcW3xjMb29ARtroR81p9gn\n+NA7EuNr+Ix1lgeKWpz4vzNS4O9RmBCRvTeLBsElfSEOjRirlxYCENDSBJRtqaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSbofiCy9teugZa5oWn6ErCEmKIcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgO+WYkOh8\nVHx5mMwAui71wRFyIQwigHmIC0AEn8f1mIwCICgTZ+Lf/YI6/kSdCSqzKV/Bhwpn\ntnajz1EMWu1rAZqp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2537", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2537` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAe0EiaA3eR/8hShVqAc/VQntMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2ZjkxNTAwLTAzNWEtNGVkYS05MWNlLWZiZGZkMmMwYmNhMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc1YzcyZGUtZjRl\nZS00YWNiLWE1MmEtYzdmZmFlOTVhMWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhjni/xLAtslfG5lSPFYgXYD1VoGwr1ybKEHCpy9IUkU3+zL6EHqtqqtuXlyR\nNkiJLJyMRjgrN7LQqefPvjUJGaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU01Fzk6/OmPoUIi8Rl921ofxZ1zswHwYDVR0j\nBBgwFoAU584VVjizbvZ6MX0RvI5lxEvM/RUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJTgUs8BEqC2\nZszF2Uitqq98EmqRlVWKvQyO+g9gFCSRAiEA1ehcss2xiN/+TM39b34FAn7zPqeF\nMBW+pFUFdQmevvM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZK7cGXCiqaNGkiEIxO7+dgJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNmY5MTUwMC0wMzVhLTRlZGEtOTFjZS1mYmRmZDJjMGJjYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARn3TyVdtDdoDQz323SvtiRJ3fWtzjFjxKrfS9SIeug1jue\neGZPZsmo+PjH0kFzaE/CPVf2v7xX09aG0OqJ84AQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU584VVjizbvZ6MX0RvI5lxEvM\n/RUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSyDmqpuX6JfsksadxnAZsMPeIJ3eJGAd4YBsJbesdDICIQCmF5LKvmh2\nl1lNIOft6GsysarrYDbFl8BI0diEr6txtA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAX00A/iMKGvyAm7GhapUuGJpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc1YzcyZGUtZjRlZS00YWNiLWE1MmEtYzdmZmFlOTVhMWY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk4Y2NiZDAtNTM2Ny00MDA2LTkyYWEtMDIyNGE4MjRk\nMTk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ1WQs3JVGPuDhK+KPccXXqnD\nJLG0pmYXNT92V9ZKAz0IjNSgmGC7fHYcRXxrc0YBX2z9nzjVn4X24KN/ZOAzyqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU01Fzk6/OmPoUIi8Rl921ofxZ1zswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgIRDskvim\nZfIRMkF3Az72hWWMWAMpTosnCK/iSSDdKawCICCA2hNiQcf+DTvMOYm6kvdp0xxi\nYsSwFbj6TAq5owMu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2538", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2538` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAdEAXSGDzVPGazlLreR51i6xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5NDk1NTE3LWY3MTAtNGZiZC1iOTZjLTI1MTE1OTM1ZGVjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUzNjExNmMtNjc2\nMy00ZjFhLWJmZDctZDM5NTY4NjZiNGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ8wEYzVUqhS8dHYsHO3fxq9q7Y5+ihTt8aORfzvALpYv96Jy5VuhposIRdzY\n/wb6Arzf5WvY8/RxFabVRByGJKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/fiIIgVAYaqid9CmOyaDm8rj4q4wHwYDVR0j\nBBgwFoAUZNmx3AB9Q69QjH8ELnFwx+TXz2wwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAL84FRXzBm1k\n6JdGaPsIyPX0TKqLh/nx8wjzGRtwDYNEAiEA6GKCVamuPIOJFVGd+4B9RgDe+NjO\nOxzP4bUM2jK66/4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWen02DT2N/RvdB3D97c7DmkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTQ5NTUxNy1mNzEwLTRmYmQtYjk2Yy0yNTExNTkzNWRlY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2eYscB792JQijcQEhpWuFkhrkx9IAQCMRnVQfhBVQl06/\nf37W7d/qqMQ70TL4KqYAnPPC+J2266KJsnPw9omVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZNmx3AB9Q69QjH8ELnFwx+TX\nz2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPJiHhvU+s8Xe3RiGornfcaVG1jMfElTCe2JvNOfygiAAiEAwEI48jRa\nw6W7/h92CfdKfnfoCkkMsXT7qZx0btKJ92o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAT+n+ZD2Yx/cRG75YbRWtjsiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUzNjExNmMtNjc2My00ZjFhLWJmZDctZDM5NTY4NjZiNGJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODAwNGU2OTAtMjIxNi00ZjY2LTgzN2UtZGUyMTBiMDkx\nYTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEizBCSZrZwP7p+DAxudJ/9ppP\nOqlSTtg0M2tI6IC7ub0A/MIL9HU0RoJCFkKYB3EmCQ5q4EhZbdwdHjigM+K6ZqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/fiIIgVAYaqid9CmOyaDm8rj4q4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKno0ldk\nbj44yWutr26K3+HzEeucNDYp7bSI+vmYIMYjAiEAxEfOIrhWavXFR49CJYEBfvAj\nf7/EhVTtwjrgcRbrMZg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2539", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2539` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZ07GOGRucqK82R1oweF9E26MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1NGRjZmExLWZhN2ItNGM3Ny1iNjI3LTkzYWMyYTg5NTQyNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdhNjZlZWUtMzY2\nOC00MjI2LTlhZjYtNzNiYzU3ODY0OWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENUVOnz+NLgRSgdc/lSPVJoMBrQBRIfVIvv8eL0qjxFTyXq/9zLIuySjHd+Fh\nEldNdT/3KvEMH1Hkp0LZzQ+cd6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWjIldassCUuZC6G9kFDeukxIxD8wHwYDVR0j\nBBgwFoAU1fbSHSs7bYi2LtNkkIGaq9ADLBcwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHnFFNvXNAwS\nz9sdR9us3RIXQq9lSWmtXaj5azLbO03qAiB9niRhnKaxtP1K99boPDSH9iegGJVp\nUeAiDAXG7eyqIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUTZo8S6ZNHVocnThpTsLVFcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTRkY2ZhMS1mYTdiLTRjNzctYjYyNy05M2FjMmE4OTU0MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0GpiJ1i4Cy8ouvaH6Q2a2YfXh5raPcvB9ZmqP9qhOJuvZ\n0buaq3Gl53Cj+bScygMlhbKnp5Wgji0E26llN6ISo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1fbSHSs7bYi2LtNkkIGaq9AD\nLBcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAY0G9ABhTw/HFubqS0ENxtOGmjTtt/fohRgKthHoiMkCIQCyz7FMLBDL\n6H1JtEVgIauePbYycMKsH4ZwXPpg7xqRnA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISASozV4Ewy/zv5dpzrIQ6WFqRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdhNjZlZWUtMzY2OC00MjI2LTlhZjYtNzNiYzU3ODY0OWVmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDZhOGM3N2UtMGIwNi00NjQyLTkwMWEtNzc3ZGY4ZmFh\nMDFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMogPHWMUQFrUaz/IzBemvOpl\nfKiAdcWsL94GU7wA2vcVkU0OoC6rtR77kwx6gAeFtrM4hGSPAHGRB4y60PMzNKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWjIldassCUuZC6G9kFDeukxIxD8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAI6E6CFt\nZXEkYS6McMGCee6NCdw4GAKOER6Kmdc1VUkjAiEAldGIk19bVz95fPMS9g1tcGLR\npeX6E9cg/8W8m3i5NNg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2540", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2540` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAd+moVz9fZ5AF33Qwvz738uCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MjU1MTIzLWE1NTItNDk2Yi05NDYwLWViZGIyMWZlMmNlZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFkMTFkMWMtOTE3\nOS00MjZkLTk4MDItNTFjZGIwZmExZjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsL+QQwu/CT512lwfXzf5MHL5cmwEZmYqpMhqFan1oSdvrqAMpDpCzvKTSYsg\njgeR0uaeJjPuf8JX65lWYFXyuaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBATcr76SIWxeu0T9P0kiNRodcg8wHwYDVR0j\nBBgwFoAUy5MVIZZ+Z3l7ujqs87bBIZXPNzowNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGcE8ac3kGL9blPpc4WF0Dd4AG6nmtdvAa6hgnuUEVajAiEA2TPBAxx8cSJa\nHZfKBdhesvze08mryLwIGMREW9OJR1Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQd+3C5Uh+tHFOL20+yTUtfZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjI1NTEyMy1hNTUyLTQ5NmItOTQ2MC1lYmRiMjFmZTJjZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASg4jsIxtl+H/me9MOQMcP3em8kJwa1M3fThvxglI+0e/Au\nrGof08kKr75+N4UlZnR5pDQVKhB346syTDLcQ9MEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy5MVIZZ+Z3l7ujqs87bBIZXP\nNzowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZaJdppquW5BNru9FSnIPpy6+wkjviieazC6FyAak4kACIQD1C5GWI52T\nmBSb+NlvKOt9mUF/UC0Z9PK7dJIAnU74PA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAVSsteVBNMT6zO56GJsqtz+sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFkMTFkMWMtOTE3OS00MjZkLTk4MDItNTFjZGIwZmExZjgzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGI0M2UxMTgtMmNhNS00NDhiLTllZWItMDQ2NzE3ZGYw\nMTJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKBrkj1yHask6dqD2NUhY+6ku\n9mG+JRRq/5GT1C3cEC9LVA5xSGN1FAPob6dV8jQmG7dIXCyZnf1WgKoz61GznqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBATcr76SIWxeu0T9P0kiNRodcg8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhANKrvd/V\nSwSAYEMd1vpjGT/A0OaIRnF9ij1akKKNch6PAiEArOKz4p6yaBN0r/FYcxPXwg2p\nTCfGhcfstRLG82PjAD0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2541", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2541` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfg7yQdDqKDPdNh1B5FsKcFfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1ZDBlZGFkLWFjM2MtNDI4MC05NTc3LTU3MTcyMWY5YTY0ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThmZGRjMzUtNTBk\nOS00Y2U2LWI0MjgtNTIwMmNkM2IwNjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEil3JFsLZ7XVMj3w36pZ/JpRl5U9qQ2XNHbMRj2OA40JIyQm+bWBXMskAVYPG\ny2/M3lfe3HIWEeBJbl9Tv5J6tKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdm2PPbehA9A0YtzgqB56bAj4JMMwHwYDVR0j\nBBgwFoAU6Sa5Y8C9lexmOFx0+Xr2aoSHN2IwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGjhyJWF6pKdPiGiHOgP0JEXwF44c78GVueAbhAINHwfAiBlMw8XVAgNPite\nimuW+DuKsoEJFKpQMb1V18ML/UO/yg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZj7s0xV8Q98om5fRtwoKsaKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNWQwZWRhZC1hYzNjLTQyODAtOTU3Ny01NzE3MjFmOWE2NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTt9fJGxpY75bZioLc7883G2P2sOHCSU/10Pq3ITjH2FZO\nS0/WW7g81AX0LrU0u93jb449FSZYzrEMTH8iky0uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Sa5Y8C9lexmOFx0+Xr2aoSH\nN2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJknONlDJlbbIQ6oaLCaaQYp76TVM4ChFyYfn4c4N2HHAiBYjo5c5nPW\nteeajwYki/t+p2eBh87NDuFh+Iyi+0YEMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAU5sLVZjSrVJhaezpOQXCzOJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThmZGRjMzUtNTBkOS00Y2U2LWI0MjgtNTIwMmNkM2IwNjExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTE3ZjZhNWEtYmU1NC00MmM1LTk2ZDAtNWRiOTMyZGQx\nNWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZJjEqXSd0K5gO9oKVyj9zDeU\nP0OL6IcpJA3N3Fb65gJgeHHGiwBOWl9V6L1YbzaW9qB2v77y517nrupVWimKMaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdm2PPbehA9A0YtzgqB56bAj4JMMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKjv3oyn\nCz1d3xMJ3KtxoWilrOqj10muTq2BLh7LZkQCAiEAns4SwB9NH8ilzfumGJlAHqWw\nVaQ8Qcl1+Kb9JTFzj84=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2542", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2542` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAWrM7BQhUa1jRE80/jwofwluMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxYzQ4NDFiLWJlY2QtNDQ0ZS1iNWJiLTk1YjVjMjAwZDE0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ2NzMyYmQtYjc5\nNi00NDdjLWEzYmQtNGEyZTg4NDgyZGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsJmuTKSYS+cCf2E1mObKfKxLh8MTn/3HnswO6a+LITLcEIbGuONE4/plttAv\nS2JjjcwnS5Ku2ECAwMgfMWK4MKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS2E+NO5dhoAHXCT3sN94ZaDmG+0wHwYDVR0j\nBBgwFoAU892gtOd6NH/ZlKDIin1CwDMnHEwwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGNE\niflg6P7BASEmx9R61Iq/5inok5okzTPO9xVtLrdlAiBrwH7Fl74iGCvaDLSqkNkY\nreBfZ5s4e2JeP6e4Uvdk1A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQtUYdt0HdS1xej14DeY89MCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWM0ODQxYi1iZWNkLTQ0NGUtYjViYi05NWI1YzIwMGQxNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASD0/GzidoIb1vWKs4JZznIapf/9w/sZh/Bj3uLLw+y9vH1\nvduSEc3LnXTxFXYdu/WcEeXS64Sh0z4FdtrTsZGXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU892gtOd6NH/ZlKDIin1CwDMn\nHEwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPqqkj03/JyxpoXdD2WEFfQsf3iysF51pJLNKKJpkfN5AiEAmIL4H58D\nOiXI3K3624riialsSg4VNxu51oJ9iM9YBQo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXWrxg4DnTfNd9JzpsEvq5hOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ2NzMyYmQtYjc5Ni00NDdjLWEzYmQtNGEyZTg4NDgyZGY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDQ5ODJmMmMtNjViMy00YWZlLWIyOTYtZjE3ZDJiNDE0\nOWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcdpaZfc+kctSD49V2+cy7nTa\nwXjc9qX3Tr4nhjZH3XyIO2l3ccy+TRdVWLvoVuMPXG3pdx9xtjYx+IMY8znFVaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUS2E+NO5dhoAHXCT3sN94ZaDmG+0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgO75Wuh6r\nltBjaR/m+DrRiyZYnd2M+U31blczmZ7y694CIA6R0yLGiWBkZmMtHx74Buoq80td\ntfiwD7EP/YibWcpk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2543", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2543` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATLFrZRfK2M8zqyZ8zyDeO7hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxMjQwZDRlLWJkMzItNDEyYS1iZDk0LTg5NjNhZjg5MjVjZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA3ZmI1NzktNGMy\nYS00NWRhLWJlMzMtNzc1ODZkNTU2N2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2IVVfj9mMbRakogY5RKLevV6Sept3FokPYmCapylYzFpFtMq3hKvNqGe7zZh\nhLxsDr6x7MYCVY1BBJTudw22GKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTPd8WodTjYULNhlKB6K/o/spz9UwHwYDVR0j\nBBgwFoAUFrOW2Nelq0xjG550tG/P1VFXYyIwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIHN9vI+JR6gZPaQhcxBJ5xlexLGKnEzZfB6nD8rX0bVXAiEApfJM\n+HxRGu2icQW6dOmoxP7gTTUhhSav4mWitLNkRkA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbkHqg+Bul7NH8QuY6BCDuJLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTI0MGQ0ZS1iZDMyLTQxMmEtYmQ5NC04OTYzYWY4OTI1Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfsw1PLGYVNLUQw0o0uWT7ZQUvhtVRevJduBGlh/IRN7Nk\nLFGE1pALsOJK53u/oQUDKX53zrHdakcVFXmI01Cko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFrOW2Nelq0xjG550tG/P1VFX\nYyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgASHssJ+QevqNInoY7ZsjHTpGm1W+kheOFxKoYcCYQGMCIQCBTrAEoH0O\njnfG6QxeavPR/7SWwmKOF5FYm6vp4oEBEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASbpRBJI+GZh/9PKb2gTuSfIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA3ZmI1NzktNGMyYS00NWRhLWJlMzMtNzc1ODZkNTU2N2M4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDEzNTg5OWQtY2VmYy00NDFlLWI2ZjAtYWM5N2EyMDZk\nMzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESkcqKieZ3Jw2+lZsftifdY+5\nPyzfO2RFiWfZqx2/6mKQJFNcexKoP8+RUO7Z5YbVsy/1Fh7qRNkaw7PMl5DXk6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTPd8WodTjYULNhlKB6K/o/spz9UwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgArV0fBeM\nZYHyP/JUCv8ZkPb0FS80D7RDyAh2oCJJ2psCIQD+KZuWbgBqwUmPQiT0mezcljn1\ncYQ6RZpYGkCNGn59ow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2544", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2544` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAd80dXPWRZRulMKde8Qg9z4zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2YjhjYzdjLTg1ODEtNGNjNi1iNmYyLTRkNjY5MzhlMjZiYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRjYWEwMjgtNzM0\nOC00YWI4LWJlZDEtNzcwNmFkZTZiOGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYHey/Dq+6slYrh6PxUMzSZc4XJtpuxophqokggv4l6EwK3cJfHsL7MtQDiZl\no59/k0ekEw32e2SDu8A208QXaaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKqpBfpkwAIhTqHjYTCA1F/VXB9kwHwYDVR0j\nBBgwFoAUZU7Zbw83HVP8hphXCRvk9ifox+gwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIDdsUm+1/HAjBZXVNYoUekkIJrNGwNhiBIDUbJQ+1PvuAiBnDGki\nAWpY65ylvkC+SMFeKVg+Vu8YMcaS/QSIYmL+lQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAflvXC7xvKFSbFntDkjdMEadMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmI4Y2M3Yy04NTgxLTRjYzYtYjZmMi00ZDY2OTM4ZTI2YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/c9fGfuvvoLr+1er8/No6tdlThZKSuDBqe3Q3wFSp2wdc\nW3z98J4Amp348amBWs3RjC0rZ9uFcIDMGtLi9g3+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZU7Zbw83HVP8hphXCRvk9ifo\nx+gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJZWddVEzJUKQxd8oNEh0koYbiT+JY644/jkM7NuwWsLAiAJwPKQUnsm\n/RMX9NK72M2YF8EHakEe+S30xzoLQFuNmw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYIZhG9iKZQT92BAj3fua6i8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRjYWEwMjgtNzM0OC00YWI4LWJlZDEtNzcwNmFkZTZiOGNiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY1ZmFjYzgtOTVkNC00MzY4LTllZWQtMzRmN2M4OThl\nNGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAET01bP5fKWt8hmUSyBKinrXiS\nSzJHD2vkZFcHtcbDI1ZJp4vAUmpsnQQuJkkYIWa/+82DOoUraStjy5aI+wVNDqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKqpBfpkwAIhTqHjYTCA1F/VXB9kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgIxGdPOOh\n6Mjd1BHJi29DTkQsb3xipG4h+8hYpuqKV24CIQD7FhaGgIKubFY9fZaWs2itIEix\nAFGpttGT9AE5ps8uqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2545", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2545` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUtIIkuxRnJIskOm+LKhUFm+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzNmU5ZWI3LTliNTItNDg2NS1iYmJmLTY0NTNlYjg4ZmIzNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVhZWY0OTYtZThk\nNS00ZjI2LWIyOTctZWUyODc2MTY2NjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElBEx2VScjtIBueUDncisFEanhHG423TBhJVTCCy8ZGnYcsTe5F2/NdFKP1JT\nLM27rbp4SuLCYx/4bnp1DgPQxaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ9nB1rpNl8IgrXkyY7D39j/1/9fDAfBgNVHSME\nGDAWgBQ8NbmzIXEdESIM4TrbTLxcVw8C9jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEHFTaWA7JWh4PnS/cLhw80RMhFovT0s\n/2zwf7fskeHjAiEA7QJwdDkUJIEfqpL+ZfabBhD7iGGj+76+6lgSdwdJA54=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT/PmJ1nRxLG0smidJEOEAv/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzZlOWViNy05YjUyLTQ4NjUtYmJiZi02NDUzZWI4OGZiMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsYTLeJwX3sjaFO8FhpFd8VaJTmFkSRxii04yCiuYmL3TY\noYIJaOMl46svLuLycyYdVfTCKx/r5FvKzsQY26jqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPDW5syFxHREiDOE620y8XFcP\nAvYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGngLWpQVfSYi1Gx2mSz98883Le7Y67MgcKnO+n/Zt8cCIQD27VwZ4Hhr\nDI4NgdVgdjj1PUh3JPYzMbAFUIDCcyQC7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWz1VA27FnW75mW4L32e3VVzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVhZWY0OTYtZThkNS00ZjI2LWIyOTctZWUyODc2MTY2NjA0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTI5MzE5YjQtYjQ0MS00MmMyLWIxNTItYWFmNmUwNTRk\nZmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKXdCSLUDNFPEXKFJcKEA+Az1\nhxwrN1LtGRCp4uMRam/8eLS4q2liEcMJvj6TTM+zme+NZnypyAg1FLQXMDd2q6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPZwda6TZfCIK15MmOw9/Y/9f/XwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgFJFO6tcd\ncD5sdMnXE5ZTlS/hv0V08BI6LakLh3gShikCIQDQrFvuKCs+EVbgGDOnD4JAzZsh\n4d69SNF5iCUOS0JNHg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2546", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2546` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISATup1g6y1Jn5+uTwLMzZhedmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiZjdjZjRlLWQ5ZTItNDA0Ni05ZWM5LWUwOTk0NWM1YzY2YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRmYzhiMDItYjc2\nNC00YmM2LWFkOGEtZTEyNTJhYWIzNTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7dqzM89dHQxysnl/lXTp9oSEVdCJaWnPVfcWD3sJ7Mum/O8NLRFGYTrVKq55\nsplHIKMS+hUyRIBeWIT2o5dxV6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUXHEtv7slMxQuTxWeCQzPdxwlywwHwYDVR0j\nBBgwFoAUuMi9yq4sr5tZVMRl4cLUQVjIAfAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICZ4gnW/QhQm\nKiq17C+9FXablhvbbaUDwhTZe3sxgOb/AiBB/orsRFuo7vaGNnKOxwKGB3/1gC+x\n9aSvY8A6sGCOsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAehKN4tYVkQv3eQyiFKNvzUOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmY3Y2Y0ZS1kOWUyLTQwNDYtOWVjOS1lMDk5NDVjNWM2NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASt0cTDIJuk6oWYyXSOhvI7W7mTuz+GMhaY7C+61xanEEsA\nsajwUbvlujQ5M09Hc1EC08wA7vUnQ8epjQ9cIby1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuMi9yq4sr5tZVMRl4cLUQVjI\nAfAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPvhZlb8zh97N0/diJ0L6x9J7VLbjzO1fNbXBK5P0RQ8CIFQhA/fxFC5G\naFx/RpPkR3VS46jBCnreWcL0b2XtE9NQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQqDEF7oE7a9PZfQi334B+N6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRmYzhiMDItYjc2NC00YmM2LWFkOGEtZTEyNTJhYWIzNTY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDg2Nzk2ZjktMmMwZS00NDQ4LWI1MGUtM2ZiNzBhNjk1\nNjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExBCIFJr6HDR08bk6yyhGZaD8\n9YjkzUfzabRLMFaMBSFXiRJFfgYlV/yF+KvTdEc9cjSu9BGqOOmRL1x18QtD1qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUXHEtv7slMxQuTxWeCQzPdxwlywwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgW1RJ2G+c\noH0E0R1w6oXjA0/7yapgUhkrPs9FjRZspqoCIDdpkE8VVDvAv15KtdFL8YhJM7ey\nAsMNEhmRvmMcixk6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2547", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2547` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAXQz0cQRAoPYps+gOOK3318GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmOTNlNTc4LThhYmYtNGNlZC1iYjA3LTY5MzViNWY1YThmNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM0NzRhYmMtMTBh\nMi00ZTdhLTlhMTctMWVjYzU4MDRjYzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ3e7fH8DavP7SCLeQcBhpP9jxaaJy2m4DsMctO7TCET2gsMVncmtJeWNyw9t\nsTRQXKDPJKHtpmrSc1ErlQOiGKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfT+GCGxkEnwYEm57A5KKPo9YTx4wHwYDVR0j\nBBgwFoAUln+loZZb446FJnEzG3WQVX9LtGYwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDsdanSXFu4\n5qDfAlfpr2/yQTmRDSf7TDMhZd8+FOfr1AIhAMThGJiC5KFhYyRRbvnnMHiYnbKL\n8XUy04M9dseHoq73\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZHqBx9a7gBvk9SJj0D1Q53JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjkzZTU3OC04YWJmLTRjZWQtYmIwNy02OTM1YjVmNWE4ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuOJupBiJo/sKur4AvRLA/0b/jBAoG42HnTlUQC/kQrmSw\n3b0mLW6hn54790t0ejFW1tuflRNj86N5KrGjr2Bvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUln+loZZb446FJnEzG3WQVX9L\ntGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT/3mky5K1Tj4r6cPXXTwvICVDd8aerQW14H1MNopFoECIA0InPEx7SMK\n5ZvFWdH/yP2HQwU5MPHtXgbiQTg1EdkA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISASJXV1g2NizufXWHfABwbEpmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM0NzRhYmMtMTBhMi00ZTdhLTlhMTctMWVjYzU4MDRjYzE1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQyMGViMzAtZjViZS00NjY1LWExZGEtZGI3Mjk5MDZh\nOGM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0NDS+dtsuFeCUfi3bDiLGq5x\nIr1XIwZGuGGdC3eqmJNdMWCJxVEZK/yfrX7oPISmXi45SSqZsor9J/KQwFERkKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfT+GCGxkEnwYEm57A5KKPo9YTx4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhALr/4avi\naIoxrdhDbyQS8Svsh8NprMY54FMbQ+9o1WNxAiEA/seE9sIqDvgtWkrc9gvg9T5w\n9jCmESXe7lPJVwj2uFw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2548", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2548` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAbmpBuUi2LYEY7S/rg0eDTd0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjZGY5MTI3LWM3MjgtNGEwNS1iYWFmLWVmNGE3MzFhZjUzOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQwMWY5NDEtZDM0\nOS00ZGYwLWI4OTEtMGE0MDdkMTgxZmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPWj/khq1SbJXCVr6WBLgRs1aSb+b4jp1s2H0vFncWwjD1Okyd2vep0Pp6cep\nm9jHbbnEqwo//Hn9x3hdBz9w5qOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTBIBb7pP7hw+lPz/w8QunXPBnaAwHwYDVR0j\nBBgwFoAUN3mh9R8lDYkf7xx243Mr7jhHw/swKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBfd8bouuvw\nHbBrWfA5rZCzg9IbQ3RdsoQ3b6oSeGPX3gIgYAP2ar4boosfujc+1vPm3c4KcLbD\nDiL9A8g7OIBfkcI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZgSvqV7N8raH0cVxcXCNfvWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2RmOTEyNy1jNzI4LTRhMDUtYmFhZi1lZjRhNzMxYWY1MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNrYJ2+SJtAz3kf934E3IyBrVyGCAyFEaLQTR1mSF09Ghv\n5Bo4Srq9bUPbhvtPeLJ+8QuWi2Ot8ayFg5ULeFsao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN3mh9R8lDYkf7xx243Mr7jhH\nw/swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFAOwHzn/iX5mWCOdTCQQq3kz0snV2FlElR4C+BFnwZwCIBBfb980BgFN\nlHZPxhehxwZfiP46BTU5bUr4FIrBzMLd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAc6uVxcAUSgcWAcfihEsMogQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQwMWY5NDEtZDM0OS00ZGYwLWI4OTEtMGE0MDdkMTgxZmU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmE4NmQ2NTQtMzg5OC00YTdjLWJhMzctZDc3NWEyODQ4\nN2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw8ZCUWZc47Kim+KUamNjwlL9\nwZxvgDtR4iA8Nmp7Uiqgb1ZnnoTQUoDjQjJN23BT8gjf/xOP8x5aPwIc1q6fNaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTBIBb7pP7hw+lPz/w8QunXPBnaAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAP6Ewbb2\nbOu0zuKQSH4LCc0qZvteuriQVLrKbC+k0eEAAiEAqvX+TZCC+mp2lhPazNWNoI7d\nusTmKyF+UkLpZq91WZA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2549", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2549` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAdOmXZ+HzCISATK+tP2r2P4+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMzM2MmYzLTg3MzQtNDM1My1hOWVkLTYxZTg2ZmI0YTRmODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVkM2E0MTctNGY0\nMS00ZWQwLThhZjMtMGQ4N2FkNzc1YWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5CkBuyu5pdClz/p+f0iTgMpxtd4JWFConX8Njoxp38z+7vmLQmLhy13xe/RI\nvOmzNaUQNa1DB6im+/pF+IfGy6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylFJe61PRFn8O4PVqfo0q5MviEwwHwYDVR0j\nBBgwFoAUPiKbnfTJ0l9tt/r8aqZC05zY1bgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAw+BvMxALTkM1pSCIkUNK3MVPodVRvtmcV7t6/hcKUA8CIQClKtnVgiCb\n2BUC5SA0GJTXxXrEIvbpcXHCY17/cAS0kQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeZhybUas/82hh3OpNiDnK3QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTMzNjJmMy04NzM0LTQzNTMtYTllZC02MWU4NmZiNGE0ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoR+QaTtObi7yi8huKP6KrSUfrBYoedNmwvxbR4uipaLQj\nUIZlL2vRVq52+zoRtQ9rpjeVznvdF6qHOT5IlJtRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPiKbnfTJ0l9tt/r8aqZC05zY\n1bgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOMzgBdOZ9SEJVC5ZPpRN6/I/f6vluDj+hzb+DXBPSRLAiA1btbifIpJ\nvAdF3VQwVspihrYSGxeB6q9VfyPWptw/hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXEklFL2qt31FSU084LFk8stMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVkM2E0MTctNGY0MS00ZWQwLThhZjMtMGQ4N2FkNzc1YWI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmM2Nzk1NjUtNzY0My00YTk2LWEyODctNjY0NzRiMGIz\nZTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtLUhnHnajybKeqtZMkIgqb8T\n7eUax6zK7NTGHfoXLvzPXULwiEnwJ8jU2+me74EA1RitofQqGGWFy3duuaq2TKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUylFJe61PRFn8O4PVqfo0q5MviEwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgYPWcunw2\nuz9zYA5A4A9ZKjsO9rfauG7Q/DdFMd+Bl+cCIQCRacJxNphU7RpcViSqu4xDv48E\nDSg+2H6lyvm1teMkvA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2550", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2550` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVoXkYACbls4rESTBgkIFOClMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5OWY5ZmNiLTk0YmQtNDg2OS1hNTUwLWQ4M2VlNzIxYmI0YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI0N2QzMDMtMWZj\nNi00MGNjLThhZjAtM2NhOTQ4MzA4MmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6AAIAsbPdC4DVWuufzSN1sOwulBAg2pBHXxF3qYWCq1AcGGrgQnppJGlN+of\na4O6uLc0vT0lZFsc2Og0oFIcuKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYRvq8RAbeiELMitu3CKxEnk9C9EwHwYDVR0j\nBBgwFoAUOhyvr4rVWxu/LxAEdGBQnrNiv/wwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA2ENPdRPq19f6DJvp0AGqgd+N+va2gq+0gHhAkjWFYFACICbNl9WjB14E\nDShWRh6p+goJtU09pk2MH7QBYNoYhR2L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAawPNv5fKmutTZC6gc/x/LhNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTlmOWZjYi05NGJkLTQ4NjktYTU1MC1kODNlZTcyMWJiNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARj0SBy7U8K4njwNHNtAGBWsoI1s+UCXZhttcCY/w/zztKH\n1LFNNpPOQwTSso2A8EfvlcAAUVRe3/b/Wrhw8WU8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOhyvr4rVWxu/LxAEdGBQnrNi\nv/wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHiO8r1NAi6GckbR1PXWbH0Vkfmy/yR7Vxn7qNCKC4Y8CIQC2xBSvltf9\ngseKYdxwDt5SgC9qMPYQHO4wpiLh+UwG0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAebeN1iPsOgz5cstqHdYW6pCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI0N2QzMDMtMWZjNi00MGNjLThhZjAtM2NhOTQ4MzA4MmIxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTliODk5NjEtMzlhYS00YTNhLWI3OGQtY2ZkZDIzNDc4\nNDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEele0Xb6hrhk0c/wY7a9foLGI\ne2BJsHkryxl2+5fabR9eiQs53sYfm2yjxNVCzRWbglGL82tlvvCBuy3JPrhMzaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYRvq8RAbeiELMitu3CKxEnk9C9EwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKZHLViB\nfRoaNOC/slQJCpQL/YBOKqgI6Bbp/ETEJSyHAiASFzFTm9VQEsq63FzhraHEeuPz\nChp40nW7nVL8yjLRWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2551", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2551` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAd95V6v4qlE37kLD2nDBsElmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhYzNkNDY0LWE1M2YtNDI4NC04OWJiLTZiMTRjMGYxOGMyMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc4NWIyODgtYTE1\nNS00NjgzLTlmNDEtMjg1MzU0YWIxMzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETw8YIkIMIqS3g8lET6uCGZIyHNOEhoMNjbTS7DqxvVIRpo2sON4rG2Rn1NPm\nNqiUGCse9poRwB2M5n6jcVl6gaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYqOSfESkcGfaaHCRz9bXTGpwhS0wHwYDVR0j\nBBgwFoAUrOTT5WUtBc4MBceeMG8VtadGtLwwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n2w/n/8UtvMjZwRJq97Yk69CYlwv7yHRSy76lmJmGQZQCICregDQC1tiIt4rzQpdn\n5YR7QjnOCv4yFp5cHcPk7ga5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVeHF88Z/Hjc4r6vD2z7H0HGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWMzZDQ2NC1hNTNmLTQyODQtODliYi02YjE0YzBmMThjMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQME7hIrCGoCU7OzOejvBb1m6/P3KIwXZlIXHqMRkGmxNkI\ns27vN/s4bz2ZCWdUsTno/GZq8N+YF13MCe9H7+f0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrOTT5WUtBc4MBceeMG8VtadG\ntLwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSVdxt5lNpa+c1WCoFQf23OH82LSPT0DYy44KcNSKMosCIDvMsjwHLBis\nTw4tKGdAz07zbFYrxzhYfaOOLTQIL6HT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZ7TA0uovF9xSiQpfZtIuSuMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc4NWIyODgtYTE1NS00NjgzLTlmNDEtMjg1MzU0YWIxMzAzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjkzODg1YTAtOGViYi00MzA2LWIyZTEtNTMzYjVmYmEy\nOTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESALqFSLIxdBu/GI4d25W7MEU\nrVfEB8fjS6NbHb980EcSKlYbfVqzJQZWEfF04xDS4UnGrGsfejntmlGTlgJ+aaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYqOSfESkcGfaaHCRz9bXTGpwhS0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgTtzRp4y2\nZBV9mzR16Wdb58VqsRpOE2eEZX9N0BNhj8ICIQDSyCb7JnH2S6OE8LY/KQTib0LH\nSTvmxMsH7FUuMXqMjw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2552", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2552` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAYQzsXlVGxE9o9YsoYBCtTAZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZDcxN2JkLTFjYTktNGZhOC1iZmU1LWU3ODgxNzc0NWY1YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ1YTQ5ZTAtN2Ez\nYy00YjhlLTlhNzQtNmI5OTVhZDVmMTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeHo9CRLt0rRRG0RcYJA+hKeCnqkLLqkgftMwUOHnTc8CPktNCNebazUeiSWM\nVnWYhta438SZrl+uABNJuLQQIKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxeHPfbyixpSbRM1wHNk1GjfHv28wHwYDVR0j\nBBgwFoAUkqUPvjwaU7H5KzCzfzb4VwxaFpEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAjD16CzW/XxCy3+YprpX3qtGGyWAcIvx06Kn/zXvpkAQIgKP7i\n3WCz1uIRVXG32a5KI8VsQKOjKNbr5GivFEravzI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXcyB0OxkfLNJWlgMs2tBGzSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmQ3MTdiZC0xY2E5LTRmYTgtYmZlNS1lNzg4MTc3NDVmNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtJnlH+tGzBbdANrX+7fkFxvXEpukj7TTWPq4Vt/8T2P5O\nIlSrgqTzH3eI3ESm/cX6T6aJQm9qMu4trYhLu4GFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkqUPvjwaU7H5KzCzfzb4Vwxa\nFpEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXU2Qwo96+kd1RlzHM7nnB1A2Os7Esz5cOENkgjJ2DjcCIDKK2sftoHOk\n4szx5jonGE3/UTpN6hslKaumzRixnnp/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAUZkUqLyzlOoOqbg18Y9U4IHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ1YTQ5ZTAtN2EzYy00YjhlLTlhNzQtNmI5OTVhZDVmMTk2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDBlZGE3NDUtMjg1YS00YTMxLTgwNWItOTkwODcwMDFl\nZTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmDqcdfGXlN1u7ftTf5Kp59nR\nLhmtG0xP4DvzJLHqVGNTsydlNUpKwLGDSN0iqReygAkzjwy16wPwAfSp4o8eTKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxeHPfbyixpSbRM1wHNk1GjfHv28wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgcCzQ9nds\nCjmyeeoSAH/rcq/chXpl+usRb+rkIG3WFikCIFNJBW47ubcwFBb5eiQuuYmPmdZj\npNPJdXNkbLe27Urg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2553", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2553` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAVg4TSKEhy+Y26i4v9b1NDwkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4ZDgzZmU2LTY4YzEtNDRiNy04OTM1LTBmM2QxMTNlOGVkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZmNmQ4NGYtNzJm\nZC00YTYyLWJkYTUtMThiNDhhYzc3YmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdK4mc44guTx++xJhcTt2GY0JKdaT3XoxobUit78zisdAvucX4mNBKRIViiEM\n3e3ocOV36aqkh+U8y8HcLa8uRKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKzzDceumFjW1iqi0YOA5WHbtcDswHwYDVR0j\nBBgwFoAUWmEWMWWsQO5i143mAfrDZXNtSl0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBgbXms8xNCIHLyAT3jUunD+gfnqJKAZ5ZEEOGyJddFiAIgBLZx\nGyyMebTiykPUsMBBKahTqUtStrVwVknxwl9Ggg8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUZdZBqIPuYz84w2CUQKdb8HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGQ4M2ZlNi02OGMxLTQ0YjctODkzNS0wZjNkMTEzZThlZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPqpPrskrdlirsclseVRWL4gIQzxXj+8ouqKj1fp22MHlt\nvMZJds1BC0hJZIUe+SZTqX9Dwu/w9zh06MP/vNt6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWmEWMWWsQO5i143mAfrDZXNt\nSl0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALesKZiA2mcvG4ikd0eqVMmkH3yM6G9xMmnbizhOq3lLAiAu1KNava8U\nkhejW79gXT0vQmozf1Ei4CpNJjOKFrA4IQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAS2bzR2x5kybHRinw7TxdooOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZmNmQ4NGYtNzJmZC00YTYyLWJkYTUtMThiNDhhYzc3YmY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGM4NGRkMWEtN2ZiMi00OTQ3LWFlNDctMDBiZDY2NzI0\nMzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH1o5XxktZhPlIUrxm3uSQoyg\nhYOiIDxOr5CzyQxwzbuK8YNriSBWn8sZC9D1bPBRyQh4U5mvzdDqWLk8GXzv2aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKzzDceumFjW1iqi0YOA5WHbtcDswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAPc8dUKK\nYW3Jr1LHQvGNPd2ohxs5T/WEmrEh2cJiTFd5AiEArf/G7EIDzJKrgR8oyWqdeb8q\nfp/1VlrLjXprKsLZl1s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2554", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2554` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAcPf63x2Mi53U/TzWtZTUmyYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyYTgzYWM4LTFjYmMtNGFlMS05MmI3LTZkNzQ3ZjgxMTg3ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmVlYTI1NzctODBk\nNy00ZjJmLTlmNjQtYjM2MWQwMTlkMTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKCXxc/7UtiH0npQeIw5jS1ot0AfffWVugMV1I4xUYonDfa4C8e/8OVodVRsb\nvdmF58/ipCV2926zed4jwYc4kaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKbSYoQMI/mHNJySEtu25/anLRBMwHwYDVR0j\nBBgwFoAUk6c3pHg9riVQYyO5Uu0iSmU7XTAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAim+1TXqXOdcX\n4X0MyKo9VZTYQaTxGpHAansIzvxmL2sCIQCA7/r4qRT/ueBvgmhyShAASwMM6UEh\nEysIheqvnDRxxQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc2i7GtG5CApGB+Rp6FdDgcCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmE4M2FjOC0xY2JjLTRhZTEtOTJiNy02ZDc0N2Y4MTE4NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVMXG+D6Xn613HUz6vwVejkTE+ugvOgtvwpzoHkzxSSKQP\nTn9rRaDVNuUH/PpSDu5l7XzYdUdhu5GmOdI6Venno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk6c3pHg9riVQYyO5Uu0iSmU7\nXTAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLy+1oZMExG59Ak0nZLTiY3MXIwRo9Q49caNOlMhkuLECIHGdByRU+jav\n1ETcXlinvuqYpsHpm6blL+XHgz0cyQG8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfiS3mVHA/wdL4ORiNvyyy7xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmVlYTI1NzctODBkNy00ZjJmLTlmNjQtYjM2MWQwMTlkMTAxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDUwMDQ4NTUtNTM1NC00ZmM1LWExZGYtZjM2MGNjMGQ4\nZDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7qfHhB4BcEcEzelX2oa7Nlm8\nAQbQN2S7Y+7KRgqk/gF1s2o5qXsta2ijMRPbgH+jRK4YELVM0UyLFIdC4S1NoKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKbSYoQMI/mHNJySEtu25/anLRBMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKBQJHv2\nZhsOZ77+6vwXx1a5/kSY6e9UaxjrDYoQMLsvAiBA7cV7/c2QKLAUEfpiGpB23PGp\nZ0QazRSfXpBOfORBMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2555", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2555` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYilSdVb50kWYNpov3rGT3c9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0MjYwYTdiLWYwZTUtNDEwZi1iOTYwLTBlNzFlMzIzY2MxYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmMzZjQwM2YtM2U2\nOS00YTA2LWE3ZWItNTQ3ZWI0YTY0ZTFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf56MTYY9K5u59bJaACZNGrpv9RN+tWHinO/CKSgHWRI4xACS5T+Qc0xRZyI/\nKTWxBQ4ALNXG4pLzp2om3twOB6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1qibaWsBYwQjm9cUg0q1TjRX7XcwHwYDVR0j\nBBgwFoAUHqB9lvZjpLYdUbVMzxiEeTGjfn4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIG1q3zEuy/CujRPzyZQoTINvaKeZHTBdcUB2YhEnM1/3AiEA+P5j3ARkp+mY\nJpJL1wW+iQr3cCSsui/3TCi16Lu7qLI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe+zlLuN093Lgyk7brdyGqzuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDI2MGE3Yi1mMGU1LTQxMGYtYjk2MC0wZTcxZTMyM2NjMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShb9fKhHKUCdWa7fhvgpbYqOmMoUsd+sX2CgO2cplS9a9x\nll+MlZwUNPiDEZg8OCv52pexJwybLWKM0tVHRswqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHqB9lvZjpLYdUbVMzxiEeTGj\nfn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL6mOlJqEejwZduwtjndfHW+qRp32OLhh7V4sqEFljh/AiEAju0E48BO\nRAQxA07X4IfynY+vLEwVU3MbAn9JEH5f7XA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYpqmud34PTRAhjE44+2Cr+oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmMzZjQwM2YtM2U2OS00YTA2LWE3ZWItNTQ3ZWI0YTY0ZTFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzE2NGU1NGQtNWQ0OS00NjJjLTg4YzktMTk0M2EzYTA5\nNDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVXUB7behJIFCNkdh806jDwde\niEqgzsaYHYo6PzFWKYplrl0BJYDVnclPv9xyBNA6Mj3xobF1grxMAT9YrWLoq6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1qibaWsBYwQjm9cUg0q1TjRX7XcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgD33uzWRw\n7H74sQ+9tGzr8SjIE2NiBf/Cs4z08hH+J1oCIQDihwa2gACQkCbUsDej8LklBmu6\nlJ+ByeZS1HJFgzJeug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2556", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2556` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZRek8wp6HiOCtes1EpuvUD4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MTRiNTI5LTBhOGUtNGY0NC1iZGIyLTdjZGIzYzhjNWE1ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJkYmQzMmMtNDBi\nNi00MGI2LTllOTgtYWZkMzgyYWEwMDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiz/ddvfSyVhofixXbPWpTI7ePBJ6o5mvQT0BBcLLst/xjgoWFGzwkJX7YodZ\nja+5u0RGVBUWcSMCG3TXbUBHFaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhoxwg+KqLK4b2TovZdHu2wykvwIwHwYDVR0j\nBBgwFoAUjBe02JJKcer01KubPerwHG4aVsYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCL2vQMn2q7ySRaDS/a48O+jJyKk9em/lg6mc8DBSjSZwIhAK61RnaydbLh\nBOE/N9qH6e9c6v/9688s9sxLVP3iK0L0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARYUdCJ9FqTI8Bk6gtgNgyUUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTE0YjUyOS0wYThlLTRmNDQtYmRiMi03Y2RiM2M4YzVhNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNzajSq5QBHIXai0LFK2mKHJT7uqQG08VaAYyRWua1u399\n2zt3XPfBdA9UvrRkKiBNg0wtoDg73MNK8ejPpTUPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjBe02JJKcer01KubPerwHG4a\nVsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOU7p+c2ioWl3/ygW81cY+NX3PuTYAnK1UEdJs8F/kQbAiEAxgwFcjXU\n5MoXLXxkSDPZQk6niqpZfd14eH6A0oLpzMM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZAGio91hcR3pSS2QBohmjUQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJkYmQzMmMtNDBiNi00MGI2LTllOTgtYWZkMzgyYWEwMDc3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmM1ZTNhYWEtZTIwYi00YTU2LWI1NzYtOGUzMzcyMTZj\nMmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQ7tj3mDqqxufIAnpn75oLxOl\nKZS4GWD500ytlAsrZQRWSN5RD2mwrmABV9N92w12u8fpqFq6EjolIlDEGwjdPqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhoxwg+KqLK4b2TovZdHu2wykvwIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgcs6vQqk9\nkGcLg6uE6A2J2RQhVJQvkwdFTYbbbIPUZY4CIQDCrWYR3IFSuK+qKfk9UvgRCCAY\nX7u4X0PEHYwboSnTTw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2557", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2557` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZoaekK0kNqZ2VUHhGdqx8ZaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2ZWZkZWFhLWNmYWYtNGU1Yi1hNmVmLThjNzZiM2FkOGU0YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTEzODZhODktNGVm\nMS00MzQ4LWE3NGMtOWM4ZGE0ZTM1MzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt76H183WMWeStVfIi9b3Bwiw5Mg8qpQ8aTpySL5m7xHfq/nTIusbQnAqe+bX\n6eNl7/N2zLnozHAcMloVmZWm/qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0V9Gdc7IJo3ejT49vsIb9Kd5gcEwHwYDVR0j\nBBgwFoAUneRsIR5QQ1QfVdLlZl/y6jLiPtMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBu8xiUeQI+w9Y+P7FcVAaI7C8JdqZcuJ1V7d9KFk8t4AIhAI4QA9v/oPtZ\nHAXrNaYAppURwPgxLnUAl0jJNTAPxkhM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU2GJScxefZSUgIK0q/1Ee1GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmVmZGVhYS1jZmFmLTRlNWItYTZlZi04Yzc2YjNhZDhlNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiC6yVQeUTnSYRna9A9wyTqan61KHoBafPWI1PKAmB/BLO\nEstz4wdWF2XCjnMoSUUZbZW4zU3uumGKbuA0wglEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUneRsIR5QQ1QfVdLlZl/y6jLi\nPtMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKQlg5+Pa8ttedNWHOm//D02hh/uZCKtweZOcFM+expZAiBlvgwrSpZn\nsw3hC7yxi1CpphtN/4mDNnP2uhLzhNgk2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISARae//yixptIuPPv1aysjhpsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTEzODZhODktNGVmMS00MzQ4LWE3NGMtOWM4ZGE0ZTM1MzY3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTEwMzg3MGYtY2U1NC00ODc5LWJjOWItZmIyNmVjMWI2\nODJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWj2qX6I7zdhVohcUpRgtucd+\n41Sa+QNTnOxC+5hhs1pNEdBuysn2zdpffZCUBsBNd8gKxBrzJVNWhVWsKzBO/6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0V9Gdc7IJo3ejT49vsIb9Kd5gcEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIM4cpQ5\nKiZ5igPI6QyY8cP4Ls0y5hlq5tNS/fzmHvluAiEAjJ6wP5K7FetCilittHGpHcF9\nzm1xrMu1HOFLC34blo0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2558", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2558` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAalRpH36MCMpPkxt97AnnZswMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2ZmM3NTJhLTlhZGMtNGEzNy1iZGRmLTAyZDMwNjRhNzAxODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRmYmJkNjctMjY4\nMC00MGVmLTkxNjQtNGVlZGE0NjAwZGM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpQ2y+HsCbmwVtfwlwJ7gRJvPKtevZ3BVd8gzAgqKzUNZqrG+AnEgyMr8DJ1X\n7ymv0xEcFRo5Jw3xNrkcRjqDGqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqCr1u/ZZ5apI5nPhGW+QjBZ6POkwHwYDVR0j\nBBgwFoAUALJcfOqfqziJwaRfGdxSVjQWxKEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAkIbinEDIJZ4/DLTJS3p6go0q0FVH8XxRMB0x3Ufos\n7wIgUbfvgSdWYGtoLak4NHmuxdc9u4jjwETdfXi3iKeENcI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfvInm3Y9uCqt9ckZDJ1QpcmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmZjNzUyYS05YWRjLTRhMzctYmRkZi0wMmQzMDY0YTcwMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8r6TpwTB2ypiQpMCy2/dFETyqde4rTNUMVXSqRrawylhX\n0DnvXji8shJKvep4qvtMah54X1b6ZKt9CRQJJ+WGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUALJcfOqfqziJwaRfGdxSVjQW\nxKEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJV38Rw4/KbQ8EG5xsb4srSw4tbhV4NXJA837QFUFIKRAiEAnR+Icoc2\nVimgEhPP89GmcY97pcnAy88F3yWYCn9Lp9Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAceLf58RKAbXpMuTJFBwGULUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRmYmJkNjctMjY4MC00MGVmLTkxNjQtNGVlZGE0NjAwZGM2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2FkNWNhYWItMmNmNy00YTllLWIyNjUtMjcxMzE3Mjg4\nZGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENBQZuKceFv9X7oqUvpw/t1eD\nEh5ihy8/MxembxRqvJvEafpVf41a93lYu4aHCELk81tEaC/Pw/VFJmY0ETfguqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqCr1u/ZZ5apI5nPhGW+QjBZ6POkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgSRhhFPQB\nqDo0tYEd5MacQeNrcH6h7aHtsDYU53SGXNcCIBHnOM5I65eFMCTHqpiM4vKtqhpT\nkLKRgLZ0Wp1ggW+V\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2559", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2559` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZfBhjWdifGW75BMBTL4nZKVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlYzcwODZhLWY3YjgtNGI0NC04NzY4LWNhMjdlNjlmNjI5ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjUyM2NlZDAtZjc5\nNC00NTVkLTkwZTgtNTZjZDNiNWVlNjJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvjkW3Yc0/IIYHidrP4XSakBAAdMTbqPB6DNAWzAyUcoRznuvOa3yhK+LP2AF\n5yIneUuEr7zUuiQ8m4iTdOR7qKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuEIgXcNaOvkoqSFpeHFgI7+sI28wHwYDVR0j\nBBgwFoAU5bVxu3uVS28O0IrK7iMFHEuTmVMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAp1MOagndKHhVwz50Bpj/4TTVzM5VcecPUc/ObyCN\nAMQCIGje+YSRyad0bjmsA80n1Wal7n/XiHctsh00V8MohfqO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU73u24ZCJk+cqr/p7JPoAvAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWM3MDg2YS1mN2I4LTRiNDQtODc2OC1jYTI3ZTY5ZjYyOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrLrmgdNiMwPtJBZJJCUnO41TsJ2OY1C69fM2qqr7lrCTW\n4Jw10qLVPWZSi8uGXN/S3UmKcyrNIIhFyIXnR5x8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5bVxu3uVS28O0IrK7iMFHEuT\nmVMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAItaiS85aPiGdbP34a5o/gO2warSwPxuy16eYp1yj+70AiEAgEmFDdbT\nG6xhH6XV8npKTt5KL7gGmm4dBXKBWmblaqw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQ2ulZmExchYTRXQtU2iGDvSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjUyM2NlZDAtZjc5NC00NTVkLTkwZTgtNTZjZDNiNWVlNjJiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTc3MjhhZjYtYzlkYS00MWMxLWE0NmMtZGMyODhjOGJl\nODc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeKmocJdoYc75NboSm9YymJiI\nAKvnW0pY/9ch3IcdT3oxXBgFVg8kVP3LtWVwr9dAF239XGXQpUjyNyKtzuiwUaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuEIgXcNaOvkoqSFpeHFgI7+sI28wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhANYfvFpn\nGxAt/k5HQgUZE4aF1A7uOV2E0WuFo7ePde5NAiEAwSVNHMx3FLkYjo3jUU/rpqGN\nejHuRby0VsWpUzZdfoE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2560", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2560` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAXpoAOCipFH8PLuXmQBoREVrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2NTg4NTI2LWMxNTctNDM2NC1hODViLWY4OGEyY2M5NjY3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTljN2U1NWItMzQw\nMy00NDJlLWIxMGQtODliZDNhYjg5OTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa7/2RLCJdSYPXDR4AkWiJBcMxgLfPA/GD2ug1957l+jIYLW71yB/U3neTAIB\nWBCKkyY5bh8szb5gfD11afJBrqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI4JAtu6gm2ZjL+bBtNTq06gUiKgwHwYDVR0j\nBBgwFoAUY6Dx2mJKA3UAQgbBjcIzv2y8PJ4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiB1i2yids5JAIx/MDZy6Wk1Zgcrs6ZgbokNP+LpA9hZCAIgJ5MT\n01cuqtB0UwSgAoiQBZsENH05CpgfnpF4bd1l01E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeoKQufyRjjzV2BCTOFf33B5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjU4ODUyNi1jMTU3LTQzNjQtYTg1Yi1mODhhMmNjOTY2NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvmaIR918502sMC8ATreUbcUe5recTXn6OE5R4UkOT84RW\nvOzU+cO9ADLRa+FVZ7fKwNtY5UZBKAkvM5EIdj/uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY6Dx2mJKA3UAQgbBjcIzv2y8\nPJ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOnhomvSNg2Cy8Wy3uFqjXKFQevDB/4Ws7zErdWXFRxgAiAHCyWUE86J\nk1kzFUWkUUwi1c43pV1oP9bdwfOkFhSmtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAeHqV1xJhJo6UrNYF9RSG76FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTljN2U1NWItMzQwMy00NDJlLWIxMGQtODliZDNhYjg5OTc1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGJkMWNmODEtZjJiNS00YjBlLWFjYWItN2RhNDEwMjRl\nOTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG0uBqKieyYP7knLnuEFv2lYq\niCyBKUxcOjr9NquHS7knOZLJtUdZld4s1kP7rBk+SGFRKHStOGvVGD2r2cSx3aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUI4JAtu6gm2ZjL+bBtNTq06gUiKgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgIbJhZbK0\nWmVLDYVO/joWaIYNjjQ/dmqayDp5Rkd/LgsCIQD1jxpVP3+dcANn8gBAnfXaeGMw\ncEMab+ANOkfMrXBP9g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2561", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2561` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISARWME430zsktrYl0FOhFRG7JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4YTM4NTdhLTVmNTgtNDYzOC04NmI4LTNmYTUzYmQ2OWY2OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ2OGY1Y2QtNDE5\nMi00ZjQ4LWFhNmItOWVjYzk5OGYzZmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg/8sdDNQj+V1g9Wly3Kypx5n6xSZR7TGFJNueKXnhXjAnex0W559JAYQP2/4\nUGKCdga1wjMBtGXb+kNOWKDQd6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwyMNmFAohurP0MmsMhdMblSg17MwHwYDVR0j\nBBgwFoAU7vOL1qGkYjw1Mc5Uxfae/9k6amUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA8jiRHC/5XhrTE5xYzpQ61tEsF2vkni5Q\nwT1w99ecqd8CIQCdkwhSKAo1mJ6ys727g83JMJ18N5qbic7W+vFeYVXp3Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUjRD6NeAOAXvXhSs/jZtUpvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGEzODU3YS01ZjU4LTQ2MzgtODZiOC0zZmE1M2JkNjlmNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtC19NuXZw0pIqmsM7TrvL7lTfTsaCgCTO/YOeOYEklvPS\ngJUKYW1R48D7QUZYYDTHObj1pwOBwXdreyRmQZu0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7vOL1qGkYjw1Mc5Uxfae/9k6\namUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANz/78YOnncqArrK8sNbxQDuSbWHl4315fCv+5YxddTuAiBG/YxrxwJM\nXPX1JyAk8s/rTQI7bfhOzaZ/61b7epvjJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAWYCSFnVFPHtWc4zgCMXkZehMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ2OGY1Y2QtNDE5Mi00ZjQ4LWFhNmItOWVjYzk5OGYzZmQ1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDdiZjkzZWItZDE1NS00ODI1LWI1NDYtN2E1MzkzNTRi\nYzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExXZj90NfdEl+F00lAKzRsdq6\n5Y9+Tfmc8tqVPKT508aFeUEZbf76+aq3EaW+CV2ikSCAxLE25EX5M9LfeLv9h6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwyMNmFAohurP0MmsMhdMblSg17MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAM1GzVCB\nmFCAQ6NppUfNGPuF5z0KMMPebg5U96visPiIAiEAvRMrIG2BxkvHIyMa7XR36K/Z\nEKlwS3hHTYYeihoZUfk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2562", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2562` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAUgiDN+W7lLlQqq/P6XflNVDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZjI1ODJjLThlNTYtNDdkMy1iMmFhLThjOTNkM2IzNWQ2NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJiMDZlMTgtYTQ3\nMi00MzBjLTljNGItZjdiOGZkYWM5MjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnriiXe71/WE6m+tI+vqvbzVYmkbZk0UKwLrTaBD7aPIldOQJQ2984caltJJk\nWCxvpWsOLpmlrcwBW3yYP7mta6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNhaqG1yPn7j8DDwgWEfL8bUdESowHwYDVR0j\nBBgwFoAUiXeCzcVFMZu7lnZYC+z4qnJAT44wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAvANfdBMh8rVWYMuK13EfbTopVvRAOZtZh\nu5G0lixhIQIhAKp/2PcKKmnTjNFU98Gvpvu01iI58QBX8D3IvaxSenEv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeu1AUbgFvIZ3I586IdkG/M6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWYyNTgyYy04ZTU2LTQ3ZDMtYjJhYS04YzkzZDNiMzVkNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRbgV02ec138YyTZ1t9ecE2lF03lt5dE/gOYvPvX1U3j74\nw7UjGYU5bFXVdEgpx3N73pxyJSCSUmsSVLvwTjMHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiXeCzcVFMZu7lnZYC+z4qnJA\nT44wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgb50la6cU7e0aavFVtRsbIz9tdcbu+WETwnte9091YgECIQC1C0TObHLw\n+VVXFej2Gxeg+Ab0f7yLHhICTk8hfPfntA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQLWptP/t2hJjju6OrYa/ZtFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJiMDZlMTgtYTQ3Mi00MzBjLTljNGItZjdiOGZkYWM5MjFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTA1YjUzYmYtNDgzMy00OTk0LWIxM2ItYjg2ZjA0YjA2\nYWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZgAy7MhmDIHeUYyruDYvIrFe\nz/WkJrj1gJGEvzAs2VvOPOMhi1N6O5Grumj2r2U6jqy7JGMJ6UBDmDFwDjzk26N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNhaqG1yPn7j8DDwgWEfL8bUdESowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIZjarRO\nDo4TLF4KWMYVKCXZh+9Ldgu3o/5weg7y0dYfAiBDl8y2l72qp7S8JBhOk8VZRcBg\ntt7rY2iQ+KEGVwQFiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2563", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2563` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISARXBOPVeae4yoewSD9QK9G+wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZjM4ZTViLWY2NWQtNDg5Mi05NjUzLTRlMjE2YWYxNGQ0YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNkMmQ3YmItYjdl\nZS00ZTBjLWI2YmQtNWE3YmI5YTNjMTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfwvU8fUaaw7Owr1kHDCHtrVIroaJ36q9Oj2e8UVKpAM2DeSPn0JolQj1iNP7\nsR82A4JCn7dwT3FVt2lSPf5b0aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhlgZHBZbhywrBuxUMEX0DAU1DXowHwYDVR0j\nBBgwFoAU792jq5DM5ctIXv7rmXGQKkficEwwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiACohQy6bwwhZPg\nozXGPc7Nuvi1m9qQak+BP4H3qx+xCAIgaSlq97t4Ww+pOcF7017lO8+jaPJxIvBb\nfPUYxHyQrsc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbNBIyJicUh3gXq/TptAOg3SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWYzOGU1Yi1mNjVkLTQ4OTItOTY1My00ZTIxNmFmMTRkNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVgdSzmT0S5Fqm6Jj7jiPKC48mwAJgbdcA3yakcon+epbO\nRa9tJdhTofqvX3eDxnQ8G+poMVLaPk58c6ZtXYvto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU792jq5DM5ctIXv7rmXGQKkfi\ncEwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFOGWALDJBLWP1/WkyfSJoGA8NRwvRVcG3O9NjioC2bwCIBNzCcxCrQb6\nDFGAyS/up6oCvwMQUWYuECws/WMSMKt/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAVMIKDstvuQjKRI5mdh4hQ3mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNkMmQ3YmItYjdlZS00ZTBjLWI2YmQtNWE3YmI5YTNjMTkyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTZmYWRjNTUtMTQ2Ny00MGE0LTllMTctMjM0ZGQwNzlm\nNWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk9EKVCgh/vbVJTYS92xjmSWu\nG4kRKfXMbniqfYv2OqbZDg9fTw0PIk6Vmx5KsUB56jLc221tDzZBZeljmmiwnKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhlgZHBZbhywrBuxUMEX0DAU1DXowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKShaZml\nfoRD2Y0v0fcSPB0bW+di4Bz5gGtZxF/EqzUMAiEA208XJuEgJdThCez15nVsNODD\nnmavcRrLhuipKO5Tx8k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2564", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2564` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeLz5Ua7hSQvtLwuV8/Baj7eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ODMyMWVlLTY2ODktNDQ3NC05MjlmLTJkMWQ3MjAwZGEzZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2MzZjRkMTAtNWI3\nZC00MzVlLThhNWEtMDNiNzM5ZTU4N2JmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER0x7vqrg8q+UoJzuL4eSxYEWNVebxvfXvsaWLa/Lk4zN9fpHHdVgqu4klBN0\nTDZimkgX4t3gXK8O28xptwO/GqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtNaxQS+mmzqgpn47iitENlZO4m4wHwYDVR0j\nBBgwFoAUJU+P1Kqez38XGfkN47GGKJBLbo8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFTYpZG1MgxTk57YBopm0UCJePo+a+E+HKSPmZ6rCYO6AiEArW9PZG8vZvfX\nG3xaUDP0Wd34+cUKG8r5VhuJXbTCj80=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa02G2CGXzR8pJgQbkV3K+fOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzgzMjFlZS02Njg5LTQ0NzQtOTI5Zi0yZDFkNzIwMGRhM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvZwG6GLgLZz3n4/eNYjkbL5bXoBkvn6/xkMagN5eEmqYi\nh8JpnHmGwzoHsf0FMf6Uq8JSQt6+szm3lpfS68Ypo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJU+P1Kqez38XGfkN47GGKJBL\nbo8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPvX6urxglA3Vsl2wg8PIY5CRWbwVsR9dAJS8nfBu16iAiBCzIKNGorq\nKY+JJ44kIJcHFyVs6iAlQeVqLzGqvGOI7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdF5uNC5dn8EfE/Hv0yKMWiAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2MzZjRkMTAtNWI3ZC00MzVlLThhNWEtMDNiNzM5ZTU4N2JmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmIwZWQ1NDUtMmY1ZS00OTUxLWJjZWQtNzg4NWI0OGRi\nMDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8rl4VjV7cz7t6zgW24A9St8g\nV8ZbgU8xc9WYWXuCWcO/P8vKU0frJn5fxTx3zRXXGXwai2COwtHyXT+R/DbeH6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtNaxQS+mmzqgpn47iitENlZO4m4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAI4vAZY7\nXoEElSIfDpt7Q2FLmVDor6AvBCsNWd7J01eRAiALtj1hrJxdgT/u9KTBkBvt2IKb\nNdwcYwEmla/9e2VNuw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2565", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2565` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASxPRT03WMx+9hFRoZwZEBToMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzMGMwMDg4LTc1NzQtNDU3Ny05NGU1LTkxNGZlMzNhMjFkMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQzZjc2YTgtYTJk\nYS00NjFhLWJlMzEtOWQ5MzgyM2E0ZTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1rlYbHyb1uOXXFivCn2/9Rd5/FJztcCGXT8WRTFiGeFlj4Dfkmz5yKcaClRy\nAkuSWV8FUISJOMYQ8Dd/bT6lf6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjRTemit9Yr0U1czLzh1e6/MDqUcwHwYDVR0j\nBBgwFoAUuQ/3Agx5uuAEZX+OM465/jghdrIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD18eH9uUJ3toX694ZxHuO59NNFW7j89zltJD9abikTmAIhAM+KSL3iLLzI\nqLS8u/+7ZBKjB8/QWgiKRhwJR7sJlROn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdZlyP3/6pVV6943LgEyBmvvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzBjMDA4OC03NTc0LTQ1NzctOTRlNS05MTRmZTMzYTIxZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+QMduPwrkDkv7BmhCHdKg+JPkFQUSN8Ej6SOSaIKXtYEK\n5OCoqwYc9zzxN3AytZOaWbGuoxSFbKNeAmfIlbR7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuQ/3Agx5uuAEZX+OM465/jgh\ndrIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJolkVP7fB+xjvqjfLJSyL+Rvv4Dz4kx5jFvzbSAh3xaAiBoqw+qZRQt\nukspA5nlFUqKOJ6Hzi2J0de0Vqb8c24C9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVVf/vb0NMd2NLZ70PTUVAt1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQzZjc2YTgtYTJkYS00NjFhLWJlMzEtOWQ5MzgyM2E0ZTJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmI4ZGRhY2QtMGIzZi00MjUyLWE4NDQtMDk2OWVlNjMz\nOTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEggM1MvyhB6wpuO5brYXMzwj4\n0mnDRS8GCT/oDUxBgQaBFgscTFFPXpU/pdK7uzUllzAtP/PPzU4k1Ut3oq2q0KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjRTemit9Yr0U1czLzh1e6/MDqUcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgGjEwZ1vG\nz+eez5HNxuf6zAQdgBcET/iTTrNXKg9T2FACIGqJKGoz7jP1+cPer93qYxgS+/0z\nzrBrJa5sJECKWWc1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2566", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2566` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISARsXLNyFYNXZhK2SMyglRH3bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiMGQ3YTkyLTI2YmYtNGI5Yi05OTQxLTYxMTI5NDZhOWM2ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RkYjA3NWItYzA1\nYi00OGU3LWJjM2QtM2M0ZGUwMTQ4YTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElzSJLihIgrgo2SqNchm4yl1w2phiXRCRHAZh420bkROLn/4/Qb0k3QCpSDW/\noLykYX+R9GKLwynQody9yW0ey6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhfHiqssK886BQs5ehgXdhFoGBwgwHwYDVR0j\nBBgwFoAU8Bb/zijVmrZMVfEu37iiNOd+KqowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAhH7J1FUsTQWPpCKdWcNFSRWVjw2VyZ1hNHbx/1WY7HoCIFTrAAZeNSiC\n6haGxX9e+YXRHLD45tyuCbQxBh4kAlU5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASyqJwb7JVim5Lfus9bZlPGWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjBkN2E5Mi0yNmJmLTRiOWItOTk0MS02MTEyOTQ2YTljNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQY9Tf3MoYtz0i/qZQFqVQiloLHBjnqnJauTI5PE5E6dlW5\nXk15GXcISHj8IVIckB6sCKzu3vceYsNZAwiouLhGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Bb/zijVmrZMVfEu37iiNOd+\nKqowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV8nDZipYKY+81m44HjNbWNMsgXHL4kRqxU9T3LbsBbkCIBoYyR8EEWDT\nX3K4gx0yOEtkx0EbO6OuGjjtI5/Z8f23\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbX7Fmj95ASXaoucC6fi9dMKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RkYjA3NWItYzA1Yi00OGU3LWJjM2QtM2M0ZGUwMTQ4YTdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2JlMmQ4YTYtODU4Ni00ZDg5LWI4M2UtZDU2NzgwZmM1\nMDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmbSKCfLGNhJOmSLql02HkpG2\na03BoEYD4jNFdU8YSJX7RM0TpquZ0uTMv/ESvkeGTNfOmmXoALWZPfcfGGc18KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhfHiqssK886BQs5ehgXdhFoGBwgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAItsbJBD\n/PViNCcErgYhe4uX1pz4o0apsU1Q4fgUOvTZAiAYDz8hafe3cQut5vfc2J/8erOi\ns+Nx1HYxg95ijDhTiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2567", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2567` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISASPVsocm0aUwtPYqZlYrfFgnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1ZTFhMWIyLWZiNDktNGIwZS05Yjg0LTg1YTAyZDUyOWRkMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQzYjA5MGMtODg1\nMC00NDBiLTlkZmEtMzA5ODJlZTE4YThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWwT178JujY2dU7li03yjqXS7CShCNPw9U9eiWkRVVQr6T7F2S4tKco6pd8Cl\nJ8HGnxvOuhe5Cv30RZ2qrT+q0aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCkxXJbGqzNeQLgkJsCIQJv1gFAMwHwYDVR0j\nBBgwFoAU4X6WLSbX/TwhP2huyBBgtmp3yikwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAyowwTWWD/YVGmhU+nFRVh4RSHGzlI//vED8LMAW16\nsAIgVGq+qo9Ds5PVolvLMs1zTGTzWupRpvnWYHswvLXM1Sc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUEbyBTLkOP+ZHBwQz+IZHCGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWUxYTFiMi1mYjQ5LTRiMGUtOWI4NC04NWEwMmQ1MjlkZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIWIQ4G7UqTFRi5dxf82YpSdnbk5uCQcCNy9eu2bAGtvl0\ngNVMjTMmIOy5YrHlRQBH6jUa3Dd/PGP2PY7/M3mqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4X6WLSbX/TwhP2huyBBgtmp3\nyikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYNSpIcwdVdwtATwqjBfvldga+dZHGPLtHHCx1VMtEnMCIAsdap2FlzQ7\nCU+fwPylI5ph0zwafcZvgzOqgFDz8jGQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZCLkV3QEs4uLLBq8lNDqeVNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQzYjA5MGMtODg1MC00NDBiLTlkZmEtMzA5ODJlZTE4YThlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGNmMjA0OWMtYjZlNy00MWMzLTliNWMtNmNiNTYyMzg5\nMmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4rteQwsq71y0P8S+E2B3kKxs\n/4CDiC6eNwcQasEPkYfPjgxo+vU05+IZ603r6cV+2CBsLwPcyLf/uDZyT+WuVKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCkxXJbGqzNeQLgkJsCIQJv1gFAMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgJg5irefb\nGr8wBLp9jNADZi598nu2Eh/xvAVqU1Kj7NgCIAj7K6eEaoYUbSB7V2UKJtI6FBV6\npyFZkPe7csaXePCv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2568", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2568` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAY1o1K608uu4cmevwMtKTTBCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiODUwOGVkLTZmOGQtNDU2MS05ZmVjLTZmNDFiYTVmMmE4MTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFlYjgzNTgtZDAx\nZC00NmM3LWIwMzEtOTdjY2EwNmJmNmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwtfVknaCfy1WNDwHWg6sRbfAGS8PWAm/1682j3VP7mFow5V35Kwti9olrk0I\nYtdYNjr86e5gzBmpAPg/ikbY5qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoPjbRyyv/gBa6/ZlSiQrGyi2yw4wHwYDVR0j\nBBgwFoAUHFgeVJltFK4pkyTtj3ud+EOIqFwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAkCg5M4nEaBTWeEjZFkPzR2db3TiryMmBs3We5y5x8\nswIhANlYLDhNtgpvYS5MJVF/Pm/cGU61ahUkY1WQu2J4x5Ky\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWpns7ugx0XzmduX4uZ2FY4MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjg1MDhlZC02ZjhkLTQ1NjEtOWZlYy02ZjQxYmE1ZjJhODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAiNlAfo8++uiJAhFSVb+wXgovSIvQPfLalXcHEQIBSYLh\nE5jwXNWjTjl0KmrPm+ocnNn+fBC/TkTzcPeXtKiHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHFgeVJltFK4pkyTtj3ud+EOI\nqFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIliF5xG5l4cbNbDXL9xJisHe2dj+ZHyOj5oxWFuTzHOAiEAsc+N7kck\nAH4bOmaNTTZnSWbyODYnfnYvLCPe6GLIrS8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAdinh1X0ffjgPAuOLIMf9KlUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFlYjgzNTgtZDAxZC00NmM3LWIwMzEtOTdjY2EwNmJmNmZkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDEwYjFkYjUtYTRkOC00ODc5LWIzODgtZGEyMmU0YzRh\nOTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9pDPjvHvFZ34SkJOVx+fjy2n\nhS8rENHTMgJjaZMuMQ78cGxiQVGIC4KT4CXourMIRKaHhrFQx2Ho4gXCiuWb+6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoPjbRyyv/gBa6/ZlSiQrGyi2yw4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgc6y478FV\nbWhHqTQdpCpr1umr426MSqVteVksmdbpXNwCIDiA68b63ufBfC+Z1CovG+Xb8prd\nsOuAvGv7jSgTUR/u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2569", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2569` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAR9EUF2njn1EAq/FGWBGstmWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3OWZmZmU5LTBhZTItNGEzYS05M2Q4LWU0YTk3MjViOWZkMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY5Yzk2NTgtYjZk\nOS00MmU4LTkwMmYtMTllNTE2YjBkYTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECJNjy8Z2unNvbkauKOsH/FOq+lUuscKrdPMNNQuzpjpEJqgvMfcbLYH5FWMk\nxUk1rYZJvmrfkAt2siHjkd9ckKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj/4D6kBud/QcQ80sMCckS7WAcWkwHwYDVR0j\nBBgwFoAUXF+8Ip9M3W0CFUKKkOVBkGBV2GMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBuo/W8V01+7KOjKEcwtot8vvzxHhsV2252a5zZboopSAIhAPKe\naEXThhLBHTZFq5jC61OPlsmRmiSSyez5IRhkvMOj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf+2b0ksvXD1SuRDEawLLW92MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzlmZmZlOS0wYWUyLTRhM2EtOTNkOC1lNGE5NzI1YjlmZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBV9SOdR+OWQekMtBgN/2w0yW0shlpUcUSGkSIMxmC359a\n3qsDOfVnmK9NabfXsVzlzKYhtmFVeRQg8dwjPpV4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXF+8Ip9M3W0CFUKKkOVBkGBV\n2GMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK8fgEFQzMpYeJSwca4VFVLl5GLgvmSWHlQwFMrPYv2gCIDW1nINNP06L\nmorpF1FFqHNvqQiTzOZSbl5vPBnZwFqI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVlhctOe4IWgYP5eMci+qunVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY5Yzk2NTgtYjZkOS00MmU4LTkwMmYtMTllNTE2YjBkYTg4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQxMTNiNzUtMmZiNy00ODEwLTliYjItNGY0NTU2ZDk1\nNjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEulNRaGVjO0q3CPAPH6e0KIfn\nBYzk5QfndxH/lweDiBVgExArQ//l+25/X2DXGALvUgwRdJkAI0ehX4O/JdI9L6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUj/4D6kBud/QcQ80sMCckS7WAcWkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAINww36T\nuN23OmZrLwkbzcLvZexYrs2clSjzQh7hFnIGAiA1LYxUKsf8h3HLIRDlvJ7ID8SV\nLB/F3SQxLNzK1hYAiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2570", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2570` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISARdN+LWcTK7PWH3WAbKF52uyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1MGViOTRmLWY4ZDEtNGZjNC1iNjBiLTY1ZjdlOTdmNWYwMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTczMzg2NjMtODkz\nYy00YzMyLThjMzUtNDRhMTM1NGJlYjdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEansPNh4Dhe6FVwc+cCfRT67urhWXBkeZ0iowryW0tIHHfBqSnQkgdsGJSA94\nx+7WZxVxeLKx2ELhRcQDbcnvwKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrkRmL8kTHhJ2bp4JB4U7g8AAZ7owHwYDVR0j\nBBgwFoAUoFqlf4edvPHW/w1y3cQSuKOq3MEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBczWyoJTjSLFcYgY47cZ8PoY1iis9tberi\nOMYA0e5XeAIgcT6aoFwzczpjVT5neOUqWr+iW1GtjbDYZdbPi9T2C1Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZp5GohUpfj4rSPyomuicI3QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTBlYjk0Zi1mOGQxLTRmYzQtYjYwYi02NWY3ZTk3ZjVmMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaZxQgLpi6Ygl5JxixJmaez7064vBjF74a5peuIrGahPsS\nTflsbMkagBhvizzMRyLMyvuxqNDmcMDWtHaG6LzWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoFqlf4edvPHW/w1y3cQSuKOq\n3MEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgExm9sYYKTSnO29+4Wrw+AhoApjWpuMnDpdqYM4u5nKUCIFooHryGorxk\n1QfinMVZyRRoyyaCEUMdkB1Hq300pkDa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAatBjzvMZNqMCMkJLy51XPKQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTczMzg2NjMtODkzYy00YzMyLThjMzUtNDRhMTM1NGJlYjdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWVlZjEwMDUtYzc5NS00MDQ4LTllYWItZTU1YTdhZTU5\nNTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgo5bZwQw8xLMWftBXQLYy1ob\nfdrulFUp6HdJd3NYm54Xbh5262zyIC/CfwWdprgf/+hlpJlMVrZRWtxpzy+TuKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrkRmL8kTHhJ2bp4JB4U7g8AAZ7owHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgYiRh8Kvp\nnf55rfP0S10vd7UGAA8yMhw6sXv3Jusv+IMCID2PCskjowJuFO02q9ivYvyaEMwI\nr5rEPaDYvFmRUQZS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2571", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2571` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISASfvNaXW8mA8an+0lwrQV+/RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5Zjk3NmE3LTA2MGYtNGIyZS05OWEyLWExZTNmNTEzN2EyMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE3ZGFlYzUtMTE1\nMi00YTdkLTlkZmYtZmYzNjQyOTVhMGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqdH0AB0AAtjO57/BsyqnGzNOqa5qyzdL8WaF+ATM72MEA9oE73InoOWC60GA\nkIOH62uiuYkj2IpOOVpuAhVFjqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3WVU9EZ6ek2rgAkGDD3RYy0xxo8wHwYDVR0j\nBBgwFoAUC6YelE9II27C1pm82Nir9d4iJIIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAMPuvy4Ik0qoYvhDtOJ7MW67ClNxo22Xpa\nTaNSTcYE3gIgSFr3Ga1YgcWVgu4PAI/DU5ML4kF9FZS018flahUN7iA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZcGSuXkXaQO06Ey9rcPQId6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWY5NzZhNy0wNjBmLTRiMmUtOTlhMi1hMWUzZjUxMzdhMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOYM0V/BEcQmDq6n4C9lQ9iVzjbmY5sW+D868qCPOtk03u\nI2VA3hj1pJY4Qxylc78Kt7dxRl3ErqL50xAENI3Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC6YelE9II27C1pm82Nir9d4i\nJIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaAG1zaUeGl8KxJV9f6mpJE8BsEDjla+8r9ehgP2nTa8CIErIxcEsm4Mi\n57fnp2mWWLQQibmMD7dRGPid15xcd6gf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAY88ViIQ9aeMY/rfSSQpNJipMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE3ZGFlYzUtMTE1Mi00YTdkLTlkZmYtZmYzNjQyOTVhMGY4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGEwYWZlYTgtOThiOC00YmY1LTk3MDUtOGQzMjA0MTc2\nMThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYvk8KunJdxKMLGuU+1DwajE9\nwx+qaDHc1dj3mFrqamUH+oFfjSf0krhhLS8iS9/45ns1fBFoU5xGj2GefR3YXaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3WVU9EZ6ek2rgAkGDD3RYy0xxo8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgA05opwyP\ndnUgQBL/Nz/iW1q+vjMSADGYSjdQ7OOoC+wCIEj+EfCkf3tzRFrXqmqfGkCE3oY8\nzxKjsX+4Xv1bVq1k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2572", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2572` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISARkYVA9E9KZK50BhLJOJ6/AcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZWUyNmZmLTgxZDEtNDJiYi1iZTU2LTUxMmY4MmZhYTg3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2VlNGVhZGItMjAx\nZS00MGMwLWE1OTctZTI0YTliNThjZjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7H8fHAi7Kco4iaM8XKhzwpShx5QaOFMngoLWdpt9fmJzudfe5jU057JiZlKH\nPEI1xInkJ1aQhXZuq/h84RpTdaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS41r/+jIlF8Amc73qd0mLnz0ekYwHwYDVR0j\nBBgwFoAUmKsQl4OgTjnXgvkO5kCaFSurwwgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCG+OfqNj/g0l1lPJ6fpl8rNQXO\nJpNkw6VzS5RcQrUhbAIhAOqRjA1NC0mheJHWb+Q36uojCoN8ARjlcJcKCHe9WQ4q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeegldJOWNBmbRyNOjE3qQW7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmVlMjZmZi04MWQxLTQyYmItYmU1Ni01MTJmODJmYWE4NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQoMVEoY18znS+Feku8yXf+HzjG7uRHJmLt4vaFUrL0mL3\ntn6rr3fzTcR0AbvCG5O7202No7t8oYNqakHLFSKSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmKsQl4OgTjnXgvkO5kCaFSur\nwwgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgItF8dP72MyrWPtrwZ3C66m/cSaV5hdBvsNXjidJDpqsCIH/SH56+PRK3\nJxzI1eC0GkpUGLNTmbr3tHeGHkeTE4cr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAeIZOcC0Ktd45SAjCil0KQE7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2VlNGVhZGItMjAxZS00MGMwLWE1OTctZTI0YTliNThjZjJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzdiMGM0YjAtMWM0OS00MTdkLTgxZWUtOWZhYmFhNjQ4\nMGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9W8q28OwZxVM7v5Nf3fNlWTb\no23WDAdf1VGgxrjF7D32/kHHNdArm+pRrkBdfdWuwZYiyacs4H7Xhp1/1/rQ56N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUS41r/+jIlF8Amc73qd0mLnz0ekYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgHAi/56wp\nwzLED/SMuizua8/YdCYRMntqsPnXYdE9l7ICIQDJRt31qjYDk9VH8Jai3vXgkiw4\nLwA4YMCl8LG4c69XwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2573", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2573` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAcqOzUq89yiSUSlFSFFPb9SKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYzQ4YTI4LTdlMWItNDQ1YS05MDU5LTI3MTJhMWVhYjhjZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNkYjc1NDktM2Iy\nOS00MzA2LWIwOWEtZmFlZTNiMTU2OGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB1DYLEVs7qyThnddv+vL0+FK7XhTfrHoBoGIjGRFtZy4A/Q4fFdJpi04Uznp\nHGG+Igs5GUmx4hJAQlj3HvMcZaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJlRAW5i5qhtfEL5M81SHs04J6lgwHwYDVR0j\nBBgwFoAUBtLRSk23sZWsUjVlLd0doa1/yOgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANcj+H0f\nGCIi7SWmyvTe/M8e/6H/49pgIq0cDuA0YLUcAiA5U1QyFh4rvyz82v9W4XjySDIu\n7ZsUnTWkp6da38c60Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeuhKbuA3SMllB1Lr+hrw+hsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2M0OGEyOC03ZTFiLTQ0NWEtOTA1OS0yNzEyYTFlYWI4Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyBv9+BIOu6mW9U7XmeSFK7GwVXgKYjeKvQl4Qc82smnV6\nk0ZNgAC6CTtjpQI2pismzLrdyFzrk8g2ES2xjzSlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBtLRSk23sZWsUjVlLd0doa1/\nyOgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANujAoLX4nu0Q+rVnAo39a/70/0+AHren6wQAaUrC81WAiAPaIRoowjO\ngCqszutiZj9+8bwEqfPUkWZO9ut0Vwz87g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQzsB7aG6eyWjD+J/XXHqiebMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNkYjc1NDktM2IyOS00MzA2LWIwOWEtZmFlZTNiMTU2OGYxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODVlNzk4YzYtMjc4OC00NWU1LTgyMDQtZWVhZDlkYjM3\nMWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjxsyfQsxJ/LjoEvawN6HW6PC\nZPPdUbTyjLFna4Uy3+wK2V8RuywiWr3rPeI4T/2YElfTBPNfNd5ppJqKzo0hS6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJlRAW5i5qhtfEL5M81SHs04J6lgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgXNuz/B+X\npxOqEnb98P0ycdjx7kTZnPow0zIFPYFV05sCIFw09mRUjLKq3u32BcBHgPe4E4P5\nR/57l6UxCyuru5AY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2574", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2574` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAdDDkPOIDb0Kf7RAY4fpOsVCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlMWMxNTlmLWU2OWQtNGMyNC1iNjFjLWFiNDYwOTI3Y2Y4YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RlNzc3ZjYtYmU0\nOC00MmVhLWIzNTEtZTc3ZmJlOTBlMGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX0IDw1Sbb6Gr08WVaBCC4C/UdQDMYasFBmX3GiMga5labCUFXjZBzwFvENKU\nPi4/gVC3/g8SoNqk2PRJNVhb+KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUldo5xWxEKxr8U03dXRAQ7AktyE8wHwYDVR0j\nBBgwFoAUizxGj5PYFjueZEj1ocAkoGhTPzQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMklngYr\nmLsz+eetgO0iRG1g6rBi968Lo8mGaIv3hcGWAiBhrmnIp/YxGoLPkuBxykuTsjn+\nAfbiCYxiXwAXD4hHeg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcYXFunPasLDFW1NaNIAELheMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTFjMTU5Zi1lNjlkLTRjMjQtYjYxYy1hYjQ2MDkyN2NmOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIhvjihoR9GuMERX8NV4Ywtuf6jIO2wwvx942RbuiazhKD\nRcZ/jyv7TEgmP8EGHlY1faxKSoQ7AlWm2eBf3txyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUizxGj5PYFjueZEj1ocAkoGhT\nPzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfK6wft10BH6XL7rwjYAYMPCckLprQK8+HyiJFZnAJDECIAoMZ7IbDpML\nYAFxz0InckCkeNJtzoQLV61a28qU5fMt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAR48U4zPRcOUXigs0gi9UXSCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RlNzc3ZjYtYmU0OC00MmVhLWIzNTEtZTc3ZmJlOTBlMGMxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTQzZjcxNTEtOTY4OS00M2YzLTk0YjYtZTBkMTcyNTJl\nZTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp48xGV9A9TM+y7uCg0k569bp\neZkjxvHgCGqOGJQg2ya1iaZAQQX7BhrY+gqXDPDnzz3hg+8vq+cOh2SPCLi37KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUldo5xWxEKxr8U03dXRAQ7AktyE8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKUJ7Ej2\nosFwtrGi4H07V980zuMzXY2BYAf1YV4F0zZIAiBbKJtJWPjsw4VBjVS/cuLIsCFW\nafq/FJaWtG0Ldy7ofw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2575", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2575` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAX0t/QS/I8D8umNtMFvkX4dxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZDZjMzgwLWI4ZmEtNGE3MC04M2Q3LTVhZmZjNGFkNDhiNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ0ZjM1Y2YtMDhi\nYy00NTAyLWIzNzUtMDI1OGJlMjM2MzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEssbWr5g5uMhG4jFg7qnTD7cvmLd7to/j6KMz8FtzhQ5aRM1XAeY2IDeL0b6O\n34ucIgK5fF1Ghdjt4Y1o0LBrAaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNv9CDJyKdGpaujemiAvLFzP3XFwwHwYDVR0j\nBBgwFoAU3BMkTdDqW18Nag+acUNEG46AFeswLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCeodP0\ntXacjyH+P25hQkii0mEXNG0t/hFlRsfPCcQhnAIgDJCo6GtiVWYuFooAbO71YrYR\nbdnIT+xqJ4LcKK50nT4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAat4nr6P4Z4lO+Y5OD5j/fOPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGQ2YzM4MC1iOGZhLTRhNzAtODNkNy01YWZmYzRhZDQ4YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI+9JCudzHdBau23G6kFkSM9hcrE0VGZcWnpWhemakpkUC\nWnqTv++LXiSmFLfgka+VSU+6MBSC9v/+Mi1Am0qRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3BMkTdDqW18Nag+acUNEG46A\nFeswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN2kXnsuQFvF/DYMh+6gECfMl0tFKuVZ4pw3SRXclpMtAiEA5A05gdfg\n87jC3h+upBYlC/2JyEnEhrxOcfV47Bq0CFM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQvY9w44g03a2Ngs0KRTpvOqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ0ZjM1Y2YtMDhiYy00NTAyLWIzNzUtMDI1OGJlMjM2MzE5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTdiYzE2NTQtM2M4NC00OTA0LWE0YTUtMGU0MGI3NDE4\nMDY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs8vD5IBJzheggqAjJlGDtM/6\nX36Mmhn9PGDlUXgxALQV19AKaBQikO5lrt/tq7hrwRfmrfF4yb+d5YaoBi6Dm6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNv9CDJyKdGpaujemiAvLFzP3XFwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhANSFfRo8\nqDt9K5agifZU3dvCxi018ZPUWOgpQMT5SV2XAiEA6QnYwci1kweqxSqM07UDPAu0\nkzomEvtrjQlcj8zvpJM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2576", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2576` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUVxaay7DyNBpPJrFQSjUn2AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlOWZiOWE3LWZkZDktNGEwMi04ZGIyLTRhMTJkMzM1ZDU4ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZiZDAwOGQtMjk4\nZS00ZTFhLWJlZWUtZWRiZWU3NzE2NzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqN+Z1xCP6Ca+9xoZke1cLygnxNh3h/GAuEA/bgnbqCLg9+1Nbw5tLvieDuEE\ne99viEMPhfitwnV03OvQWoXmGaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxAi0FJdV9jfUFbbJn0lXZ36SqJ8wHwYDVR0j\nBBgwFoAUvEdIlGSgOgX/VR0zTUU2YezUjU4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCCel1pcrlYZDrzQtUs5AeRnA+8JfewZl6BKQx1EJt0JAIgahk/ZlFM\nyAeqoMIiQnO96pXgEpmUb1oaaP+ok6qFwmE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbW8BagtV5lMtGLB7HSPUOxMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTlmYjlhNy1mZGQ5LTRhMDItOGRiMi00YTEyZDMzNWQ1OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEL/jc+2zjxi/1SiwJYJldKhp8ewHYPDHqoPUAngO6LpTs\nc5maGvDhzRIeb/t9NNfp5lzw+TXVo3kBttTkcJXZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvEdIlGSgOgX/VR0zTUU2YezU\njU4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI3XBF6ZMRKAkb6gRpeArAx09WGiWYtmdx+osAelvlIbAiBh4iZ49URQ\n8n4KIIvG+YzlCy1UOajKyvvI9LweUoykVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAWDxRurlXKa9nrw9J5Fz/BfDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZiZDAwOGQtMjk4ZS00ZTFhLWJlZWUtZWRiZWU3NzE2NzY2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQ5YzhjNDEtZjdmOC00Y2JmLTkzMDgtM2Q4MWU4NTk0\nZmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEykFQItqFqWeQ4+LPEnYHGUWc\nGPCsJGIUBwNpCkSedhJo5ZAms/UJMtpADwdPPHsyFMdJmEyutdcFmy2jt7jzAqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxAi0FJdV9jfUFbbJn0lXZ36SqJ8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhANhFpqPC\n38D3+VaODeKtwqNlx+rOvV2ndXGP9U5n7duuAiEAyt1Px3sc34TeZvOlD26ji5hU\n6d2iqJb/LMX7ta6OrLg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2577", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2577` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAaknUWa26sNlWkfXwY4Nn+R5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzMGY2ZDBhLThhOGItNGJjYy1iYjBjLWNmZDNmMDFjMjY1ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM3NDY4NDQtOTVj\nNi00NWZmLTg4NTAtYzc2MDY0YTVhYzg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnRcAU1mIM4qlofXkroI7/QX+4ZTNH0dVm6N7oDjabQ0pVFSDzGZxtIZJI8Gm\nB5eMAEzjiMiGJcGuUxBRSk6P2aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH5mCBg1/rPplgTGnHhDbqx/r1dwwHwYDVR0j\nBBgwFoAUuMtXvNhM9wJv/sQT70WBRT2y3IIwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIBE8v3gfV+6ExkmD3e7vqA5Q/p1VvJxlMBilB59mQAMOAiAP4Y+AyhQ8\nqV5RLBkm++5WMe/11sPwx8w9J0gihplFhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATiMYVTCxjTT9/M8sFNIlyRHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzBmNmQwYS04YThiLTRiY2MtYmIwYy1jZmQzZjAxYzI2NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARM4hMR05b8ygwzM6TDwYPJGChU6czOj0/zOSWMvMIZY4ip\npogFo0vw6K4XCjiA2fyXZwpz59xqD7eURWYid+C4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuMtXvNhM9wJv/sQT70WBRT2y\n3IIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSW1WHFFtjcQqwRYrWBQvPzgInADkSX3bYCbEIxRr+U8CIQD1lzabfj0U\nMkrxLDXcvlx36rZA9p24MnDqroA1T7GBCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUW0tibfm/5TeLcCpq42P+B2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM3NDY4NDQtOTVjNi00NWZmLTg4NTAtYzc2MDY0YTVhYzg3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjUxYmU5ZTMtNGMwZi00ZDQ2LWI2OTMtZmM4NjliMWQx\nZWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+5H3GxDwR89LPwfflGUY98NF\n+AFmmaB637T+oxcjVxfJaLcx/RXVbYiysGEATJI0t8VFIQvLC6aegKYLC+PX/6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH5mCBg1/rPplgTGnHhDbqx/r1dwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhANIBNhI7\nYKvNZTtk43mP4GrA4fkREZxPbZsAp2pQiwQ4AiBsVa/gno0udI6jeIPiuBjZpexC\nfts09jxO0EmycF72Zw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2578", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2578` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAV6RKxpjaTELKJmZveSeidGEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMTE3ZjA1LTBhM2ItNGJhZS1iMGY5LTM4NjhlNDc5NzRkODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk5M2FlMWMtY2Nj\nZC00ZDViLWEwMjQtYThjNDgwMDU3ZTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBNL43aNxpVm2R/Un8fkvUvMrSDQN1tqoya5GE3V5VfWE/kP3VKFWMokO93aT\nxG/gn9RI10nY8ubgfyQ2gHpccKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPDYjIcuCn1yEV2tAK/N91HEXnGEwHwYDVR0j\nBBgwFoAUHWL7hbq0XGsiKDsPDRUNrMs3TGkwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIHeVQsg/bW2N7aC5fmfRtv/2rQAqYzYpblpqKcLutoNVAiBNVAUxa24jikets8BU\nKBgxfj+5FOyi+PKXUmQwkA7v+w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdyJ1ImG+6Ufh2LfjkoIG1pvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTExN2YwNS0wYTNiLTRiYWUtYjBmOS0zODY4ZTQ3OTc0ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpvK1YAc/YZWi57MiWaymGBnq1LAbfOSunO1K9wWMBUp4Z\nLZDHsL8fl0FC9oWrWI3wAAgwmFtljok82LfgbFFOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHWL7hbq0XGsiKDsPDRUNrMs3\nTGkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM7qEWy4Gql0/9HP83nMyJ68aJFW3EohHdm3HXp96V04CIQCMYm/n9uRz\nVykbQL7KyRh7kFdRDRdyN8ljvG8nbCq3cQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAe0Kq0LAB/OZmjOWPybOXIyaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk5M2FlMWMtY2NjZC00ZDViLWEwMjQtYThjNDgwMDU3ZTlmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDZkOGFmOWEtNjRkZi00ZDU4LWI4NDMtODM4ZDY3NDk1\nMTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE19OZtOmkcrNTZ5d1pzEEEgQk\nN36/k6Qa9oRMQSWNlBwaeHaRTM9bvxtJzWwhqW9NIT/BagqCKpIqH06by1ZzOaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPDYjIcuCn1yEV2tAK/N91HEXnGEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgD2Gy1dOl\n3NlNqreuPltyzwX7ERXMjoZ5miGRJyZndSQCIQDs4DXbSszHodYKiusVvApcVvUo\nGr0h7AfPnXEvmj43ZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2579", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2579` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAUFwvplBW/9gB4iQPhUTf8C0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NWQwNDdhLTI4MjItNDk2OS1hMDBiLTA2MTJiODE0MDcwYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY1ODQyNjMtZWIy\nOC00YmVlLWE1MmQtZTZkMTM5ZTM0N2NjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECECGCGkWYZnqreAPSR4qdW8ZkSfT3/WEJgGP3smZBuPiaQNwYfvWymwEjfMb\nL6XTmVHJrSQveQHfHq1+o3gtWKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBqiqewbwTP8BD5zRpg3WTYFnP24wHwYDVR0j\nBBgwFoAURcUAr7y48SzPmAPekmBmPVRyUK0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCSWQPQZV+aL4CghCXSK9ynG4DphXCCyrnw2mcFJMtvJgIh\nAN4gLb87ToVKEDl6zFULybFtAkcRxpUJwfM0+7SEksm/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZKHLSaHgUZ+tlp1GaF6TsEdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDVkMDQ3YS0yODIyLTQ5NjktYTAwYi0wNjEyYjgxNDA3MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPssAmVBkSjsAs1H0LofaZe9cdApQ7eP0Do6dKCZdmUlyK\n2xGBT2DfwXAL+BnarDAfHINODnungoySIv+07aCdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURcUAr7y48SzPmAPekmBmPVRy\nUK0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgefPgtqzwWicHauASyA9iA6zzDQBC6G3mFzs2w/HCguICIQDEECyVlXlF\nu/REkfHrp4VgXk94Zr5BhwnU/QVbwnNpDQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZ1Op8VsfKIQle2rp9Dl49MsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY1ODQyNjMtZWIyOC00YmVlLWE1MmQtZTZkMTM5ZTM0N2NjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNThjOTdkOTYtZDdiYy00MTkyLTk0MGYtY2U5MDkxYmRi\nMGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0uHTKB7Xq4ceOGhAQYFD23/o\nGI8oimLkB88qWLnbLHfrbXRykg0YeXVT6U/lQyu1oCm/G5pM/jeHhylp6NMxgqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBqiqewbwTP8BD5zRpg3WTYFnP24wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIw1s0cE\nQdns2t556EGwCiBPvHd6Q2JnJ/kUy9CszusoAiBWWvYM3MTddHRKiO+KMtaWvxw1\nOlJ/tiYQ+cdFOD4bFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2580", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2580` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAT3dsChan2JkMZG8II3V/szUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2ODhmMjZlLThkNzMtNDM2OS05MjYxLTY1ZThhYmQyMGM4MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUyNGIxMGItNjFi\nYi00YzEyLTk2NDktMWI1NjVjOTg0YzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGmW1eX1uWO957edWoeijm4+eBXTLgZpRz6CBLyDvb5p1wgHITBnqEqVrpKL9\n5rII2DQdOf8k9iBaiGdwCElV1aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU06nsEhwqcJLXJELVZTJt1dWwOp8wHwYDVR0j\nBBgwFoAUiKQG24Q3yPoxM8DYN4NsY9YgD08wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQD2AGkXRO+FATXIOYkCxEfQkQeDtsRYt5qG3EsCSrdXYwIg\nbepyAW/EB5H9atXtbHq3ZiRgZz+sOJCTJpY8AqZnN2c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS/Onk8pE5fuL9xAwapllae1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjg4ZjI2ZS04ZDczLTQzNjktOTI2MS02NWU4YWJkMjBjODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv1+m/JdB/A+XTX54DyRL5Ra9wUyXLsRF7sUmUnC+RA0U2\nE2mOSwwnEJNuDHRMv3ZLq6WZXP0lzFMPwG94syrmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiKQG24Q3yPoxM8DYN4NsY9Yg\nD08wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALo8os4IJRmtKDa8GlWH4q1Yp6Ssu5YBdLgUtKDmwDCoAiAnkEhsr7dx\nBiOFu+zcjXLxceLZxOnFp9ZHke7voZzh/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAf7/4JQxDMgM3RYWHbLJus4dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUyNGIxMGItNjFiYi00YzEyLTk2NDktMWI1NjVjOTg0YzkzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWIyMGNhZTYtMDExOS00YTJlLWJlZGYtMmQzOGM0Mjkz\nZjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYCaJJABxKBOvm+duwBncJnAw\nIG7Fxa6uhjhxJxvpBSqUrcWODuceDMsJsyqA31VoMe/LdwU12V2Z63za8/zraKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU06nsEhwqcJLXJELVZTJt1dWwOp8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAI7/vAUe\nbgWh/+8oxxGMe+1KMTH1fOm2+lMxejji28x3AiBZrQWiHi4n7z22wuJ8AkjQGJwn\no15jY3lLZA19s/cglQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2581", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2581` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAUHJ3yBYo/G4/zBa2eKSLvl5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1MTdkMTIzLWQwMmQtNDQxNy1hOTcyLWZjMjdiYzQ1MDBiOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA2MzdkODEtNzli\nNC00OTBmLTlkMTMtZDVlZDQ3NWU4ZTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETn/OjM9vRMhIr191NAR/6M7rRYBL0aADw8/h+472N0gYL9KHikELLTq4MP1z\nzIbVb76x/tJsy7a5P2LHvELLB6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfiqeBiBlVFLbKMEH9dwFI9I2bbUwHwYDVR0j\nBBgwFoAU08jVrp2yLh9oIi5KImOz/P8mDskwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIDC681Ksj85Y\nGQJylmyq263bIBGacyAOYP+KOJ+Vi4GDAiBGgapyTXoAge+hE8Qib3HrQkPj3Wpa\nkIlBb2rTkwu5EQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXV8cu63k01YYP0T537M4SRqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTE3ZDEyMy1kMDJkLTQ0MTctYTk3Mi1mYzI3YmM0NTAwYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq7Djr16f41yWsSidTDt0gEKoK4HVLIZW7Cbau3kkDN4h5\nIHgkrC1jljKuYx9453fdBY0m2GfXrui7OmZYGuEio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU08jVrp2yLh9oIi5KImOz/P8m\nDskwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRHMoHcj6dj52Znv1ZnQqwr2R/c8RsUWAAEv4bXI+7UECIQDfFxQj/wa4\nVIO/jjenGaYDM5gglMTza6ASri/CqwIPlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAW8ho3tS32GJX8ir0iNqq8mZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA2MzdkODEtNzliNC00OTBmLTlkMTMtZDVlZDQ3NWU4ZTQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTM4YzE4MjMtMTNlMy00ODM0LWFlNzItZDhkZWFjYjQz\nM2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg96tMXLNaHFOX4nyponHdvSe\nSV6KeN3HsmRUOfNnShs/NkXFHlrUxzDODPDxoFiNUxgDxOm1U1lhQJhmUYEhL6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfiqeBiBlVFLbKMEH9dwFI9I2bbUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgcBnHOIjs\nObRH3xP5q6B3US6obrgmc1PJPsDjHE2cFaQCICNVlffHCYvI1w9HdQQvSIzbiBgX\n6oBX8CuBulpeSP/C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2582", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2582` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISARJZO3T7Qre0UwG5bdXWGqMPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjNmM0MDJhLTg3ZDMtNDA2Yy05YTRlLWNjOTVmYmFhOWFhMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWU2YWYzNDctYTdl\nMS00NmQ5LWE2YzItYzBhYTQ0NDQ2MjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEhzUOUs8hP/G7XeF4kwwcbbB+KR74WabiY6VCbLK6vfFniLhXvFfGsvw3J7K\n2dL36GWNUQOyJBsgffAntVk3LaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJSYXkW1uo3ym2C3NRU1uFAkbS0wHwYDVR0j\nBBgwFoAUTIdzwccbVnvfWprctXkMfcYD7PowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgVeFhNwKb/D6sMv/7NjzkhIKZN+pk04WIY7XDX0+cA60CIGajvp+PR2Qj\nkJM1gUABNLANix5ooaG+IaJU08YoUMl0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQgkA1pjMgF1JxQg4vhCPy3iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzZjNDAyYS04N2QzLTQwNmMtOWE0ZS1jYzk1ZmJhYTlhYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKbj/SAf84GUc0v9Enog84HmJfoYQ722ZXOQrkw7rRLAdp\njIShHJ1XaIW3d2POwPi77Q3bFs3RM0oK99VGh51Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTIdzwccbVnvfWprctXkMfcYD\n7PowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM6V9nxENs6qeRQA2igweZrTypz+1uppehHWoF1rCVYVAiAB63priwEQ\nWoMFfQ2zRRpVinAt/1tEoAioLMwOtTkJCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdqbmyBQ7IZDjB+B5RfzrN37MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWU2YWYzNDctYTdlMS00NmQ5LWE2YzItYzBhYTQ0NDQ2MjgzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjg5NjRlNWUtZDYzNi00YzFlLTkzOGEtYzhiMmI4YjIw\nYTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzf1VBnYP64MKfuSCAJixu+3C\nakhnX5VYjs8KBBfS636bVgtx454NsiEk42+A6BrYd1d7t1uLVqj/3AtXBcrkz6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnJSYXkW1uo3ym2C3NRU1uFAkbS0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAN4K4ERw\nyBCzAXSbCetbiLArKxBT3kkm1f3WRuv4GecHAiBkTxNC97l3XXEjHY/Czko7dPbo\nKVluLV68EnlEqs+GBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2583", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2583` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAUCq3lr4m0rY17vasm7HU/vNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1NmE1MWE2LWE5MDktNGUyMy04ZmRiLWM5NzAzYTk0NTE1MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NhYmYzYjQtZGRm\nNy00MDgzLWJhYmEtMWVmMDVkNWVhN2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3kRvk7sPmIyuvNiXluLjWAM7gsnLT5PlbuC4PErPICKchdnSHTrFhazS+qhI\nx2Tj+8Ur5bAsCRYiC3s5eYGIe6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGqDjH2jS4fnFBxq5WRo+6xKxHg8wHwYDVR0j\nBBgwFoAUYbkO47rEg25kJFgSn2WB76MrP7IwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgTkWhxROm2pr0MaLM2mr8J5QWM/0DdvxLgbwHBlOeuOkCIBSu6mg+xDVD\nWR/BmqzAnvgpcvII4Cd4tuIwmq38KAfQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdQfYWLkAbXwGZSziZXukfbSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTZhNTFhNi1hOTA5LTRlMjMtOGZkYi1jOTcwM2E5NDUxNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYyfcjA1VzruQuyNET9PkMq73YMfXCiLDH13GyV7Bl6A5m\nQ/lknsb600LycPXZhf9ccxUqf+hoI+eZRS+cwTjlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYbkO47rEg25kJFgSn2WB76Mr\nP7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJrkp0HGXzgde6QI1/yRPB6cMHKF5M5qrvx1kbtmxPxsCIEV/ch0dvwMv\n3qnsFj8RxQW4iOLXC+YLVqvLQH4LBi6/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAVUlF1LKc6yXFuLsEzhQ9ZQeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NhYmYzYjQtZGRmNy00MDgzLWJhYmEtMWVmMDVkNWVhN2YzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmFjY2FiNzQtMWNiZi00NDA1LTkzMDgtOGU3OWJlYTQ0\nMTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG7oxbKjft4oI2lDxFlG9x+s8\ncXl5/LQEJoFYiHIWpPiVg4mvTJDdWCOWysUo/Xw0bC4nhfB0M6rJuidUvmUxYKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGqDjH2jS4fnFBxq5WRo+6xKxHg8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhANKHfX0z\nlC77UrI2Q0f+vKlioyjbwd3uzPLbNxmVljXEAiEAgsBchDzU3K66322KyZn1FG9P\nYMRCYuE6d0DBiwbLyjc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2584", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2584` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAcGIkOsqNGST068njaAPr/BWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhYWQzYjQzLWRjYWYtNDM2YS1hNDljLTA4MjU3ZGM4YTQ4ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZlYjRjNTctYmE2\nYy00MzA3LWExMDAtNGFlNjliYmJiNGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE75XLVLRxoqPchmv8m2abRvcFdHq7NDlhfvy3D5c9G3FuV/7iLNHigD99bWu0\nN0UeHtAZVs1REGBcRa0U082kBqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxPwvriwBhZgW1Fg/teyuk6yeXIIwHwYDVR0j\nBBgwFoAU2YNAzM6rFiHuwFMbGXmWkAUkN2QwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDLEomold/WeIy8Nk7jgv5nN/4cqdcgNJU+LMukfv7IewIgUCrpTN03\nWYXFBY9+0mw7yV58I5njCuHzwvaR96aRQMY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT2fI7HpRL1Y3lwRPDtIc/imMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWFkM2I0My1kY2FmLTQzNmEtYTQ5Yy0wODI1N2RjOGE0OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaAQPBDM4mZn+Rx582OW+XAZsXAUhLAx1fZ7lHf35FSEkn\nCSSTkuiMXdGEUmjF4s/IiU9FDozVGWFgx0zqxgTgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2YNAzM6rFiHuwFMbGXmWkAUk\nN2QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFoUKiQdNEyuZRUG2JtXln4fW/1lal8ugCul7rFyFI4ECIQCM7wA6pc3M\nawm9y8CtOgWXh9wLWCZlshafdXwUkhB6Yw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAR1wVLd2mFCKE5/t8IsNS4qQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZlYjRjNTctYmE2Yy00MzA3LWExMDAtNGFlNjliYmJiNGEwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzViMmUyOTItMGE0Yi00YTA3LWJmMTItMDUzY2RhZDk3\nZmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWFp0KFvK+GPj/Y43+vQrZy5/\nmFVdMBa9YYSRaNdO2hU5Jt7h4hYeIngE9v3jlj0blDYb4qSOjp1Wg91laHfI8aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxPwvriwBhZgW1Fg/teyuk6yeXIIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgO7+HSQ79\nKLkwniZpDv1DvSGjIufpMDYlSEyVEs+jlp4CIQCq/bCtwfSRaVDxFN4Ql1neCFSJ\n1KrJ0H2F2r5tQJ3O3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2585", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2585` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISARvKeRxTJq7CW9zFNzlvWvnsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNDljNDM4LTgwZGItNGMzYy1iNDhlLTgzZThhNjMxNzNhNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU4ZjZkM2UtMjMx\nZS00NTE5LWE2NWEtYTA2ODY0ZTZhM2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Sg/M1kxJUG1vsWGljUR0S9I9oPyubWq8HfxAY964YIIw0PdXi/ugDGi3Tn2\noSoTnU+6plVQH5MJOXANDafRbqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+qqwlzjh4BUxZJKNaW1Q8W9nStAwHwYDVR0j\nBBgwFoAUOrYigogDWh4g5Wa1oFAOkM7lsQIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCr+QW6hGNaLCTdAUDVv0ecMi6/UUBx/wmRUaP/\nTRqThgIgDNHgc33BVrvH3DihSuzTmg/c8/slHg1bTsB6s/G0U9Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfEbaIUKpJk079lkzAYOquHMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzQ5YzQzOC04MGRiLTRjM2MtYjQ4ZS04M2U4YTYzMTczYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQx9yV9RMNpWsERuzOPgwGwi2Tb3e/83GirsgzfKwjUe4BO\nkf3ADjishYFXKvl2HXPu9M/qE/oHcnCvLjedhV3Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOrYigogDWh4g5Wa1oFAOkM7l\nsQIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdhOB3ulM0u01RSqUavlNwUBWxyQJgFUUSkOrpY2QkgwCIQD3YKpYrMB1\nSaKRbG98ZUeaFmv/Ga/ebCReJPyxnog+zA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXoWahlwZVJ2281lVD8rRowyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU4ZjZkM2UtMjMxZS00NTE5LWE2NWEtYTA2ODY0ZTZhM2QyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTgzZDFkZTUtYzdlMy00OTQ0LThjMGEtYmU3NjZlNzY0\nYzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErEpuuwgPxp878frxGrMsGrZt\nq5yG5elNESjcCSoVEefdBwR8L260hMCGFFL57NX8mSg3HJK3gWFQL/inxT8gaKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+qqwlzjh4BUxZJKNaW1Q8W9nStAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgdSjW1Ou3\ncvC+gqdpRaNWONVTiVaEzMoqS+NhVDlj4ysCIChesYZT6pZ6QZz6XdVlhwB1OIcc\nMlpF/X0n0l5ufyy7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2586", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2586` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISARlqWhKoHza8pxHWAa3oIgXcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNzU0ZGQ1LTc2NjUtNGE4OC04NzMxLTk4NGFkYTI4YTc4MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWI2NDQ2OWYtMmFk\nZS00YzBhLThjZTMtODExMWE2YzgwZWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0zUciuTeSAC690XQPmM8yt3DB2RYXDfHjhoPj+PLTxMtoEJ5W1QyOCDUpGka\niU/kbQj102nPq6NtY18Gae3sPKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKO+O0ka0d1PU4Glm7m6WwW47ylUwHwYDVR0j\nBBgwFoAUL0Wo38NjGaCzqbFG6xnHVSEbjTEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCzMAWZVNvKJAPfPEt3543K1TCUNH2X3WqDo8Io\nF9OQAgIhAJZ8JGgYfWqRsnRR1bvVidsyg6WPgCwOsAaU5KuYf2Ad\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVF9bHGOGdF094/03aZe4C7pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTc1NGRkNS03NjY1LTRhODgtODczMS05ODRhZGEyOGE3ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2zxYp6jiee9Lui0Krr38jDCmsFcvRd7keOYW9IbKkSHUL\nt/cVBnd139ttdugeQDZvf3BswXzqsOuR29cyNt6Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL0Wo38NjGaCzqbFG6xnHVSEb\njTEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG1TH5dNpSLSstcDQEOMlUdGvYRPB0eMTOzeqfX+5XzQCIQD5oHZpuK39\nl5I7m1Pc3mCUZGjyd0qTqqxkKwL4/Qazyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWhHE8OrHEj0HSQC3Rtpl3Y5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWI2NDQ2OWYtMmFkZS00YzBhLThjZTMtODExMWE2YzgwZWM4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjI1MjkzOGUtNzBlMy00MWY3LTllMTEtN2ZkMWI4YjA2\nY2RjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEimLwgYHheKIorZMFABRmrrqW\nGHAJWo4Kh3bnWbe7QIjaTj/yjMra6KYBtDAGuKwZO/56BZQLznW6Teih/mRCIqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKO+O0ka0d1PU4Glm7m6WwW47ylUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKG+v0FU\n0uRGlynZExcKqaJnXvx1pfmnuy84GfxhiWAAAiAqbGwJbhswyFLbe5Y9c6FipoyW\nueCZtdnLygxyY+pSsA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2587", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2587` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISARnrips9iCoNkc+dNBp7hWF4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzYjQ4ZmI0LTgyNmItNDk5MS05NmZhLWU3N2RlNmRiMjc3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc1ZWZmZTItZDQ4\nYi00MDY2LWEzOTUtYWU2NGZhZTc3YzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Da/rSC9nC/UjmgZv9Zb7N4DjushX0/N1uFCQapFBmxx5JYX6bxccwvK1Myr\ntwSJKcLWgx+DUy+0V8NixfLM3aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoH6Ej9iqxZPb9Q1XuEE5NOsuBgMwHwYDVR0j\nBBgwFoAUQEEWGHHWb9l/HALI8csy5hqdr48wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIDl5S1s6XsNcFsCa4D/EJAwPfE2vqtEgJX0nxKORgq+NAiEA\n+Q+BYpd6YCNkOhkOCUltUhocxjNwGaoAimL1MzftEko=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVsIrTFdB9pjI13Lbpp0nb5eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2I0OGZiNC04MjZiLTQ5OTEtOTZmYS1lNzdkZTZkYjI3NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQg/DSQ5OHVdYtPHCsHd8+wJk3M0nFmyfFgu+V8dIrqoSC4\n/JxVMSrIWWoSXP6Y9zrpPRqRB7JXS5W87GQhf5epo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQEEWGHHWb9l/HALI8csy5hqd\nr48wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL7oGj43dD76OL5I1iQloQsPA9gdLi3vK/N1IyK4FsYHAiBwv2OII/yj\n36XNX0JzUsvTWm0uO17aqVvsufbm7633Kw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAR/D89/pFBAYqO9igfEUc2ZOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc1ZWZmZTItZDQ4Yi00MDY2LWEzOTUtYWU2NGZhZTc3YzY0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjEwYjljZjQtNGU1MC00OTg4LWI1M2EtMzA5YjY4ZjA1\nYWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZa7IxRhRNPaVgGLdwOtLIwX\n86JeyVMvHWwQkm/8DktnkfW9dwmnbpWDg6YygMtPhA9OVvD7EXsZsEjycJ69zaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoH6Ej9iqxZPb9Q1XuEE5NOsuBgMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgCDvwrYHM\nr1/d7+pXzPko1tVTKeoN2jc/PZubDz7HBpoCIHGDU3faqJ94TVpUk3YMb7POm+Zm\nRH/PBJT+G5CxwfMY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2588", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2588` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAb3Xxywdq00fHmVY1ZUIruI6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNWUyZjY5LWI1ZWEtNDU3Ni1hNjBmLTRkM2RiOTQ5NzIyOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM3YmQxYjMtNWYx\nYi00MWI0LTlmZWUtOGJjMTQ3NzU5Mjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXYkZ1Kp5IRSPUQu/oPE5EMydfK+2ZY94gqX2v0iIb2r43liQvoCaAEphWDcj\n9LQNxx1LfEaO+F20Li85CtyanKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5iUjZiSUgXau/83OehkPLLu89T0wHwYDVR0j\nBBgwFoAUTeMVfljdIep2vmLdmR9jFIr4LZ0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAj8uSlkIfeUoNmx2SD696xka8VMO+Zs\nRxohOV9+ZBy7AiEArgiAe+uZi8gSebyzgGtKdtF1y1wXywuqjWX0ToV1GJ8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYWiOTeI7kUWuvtLMWvls7BuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTVlMmY2OS1iNWVhLTQ1NzYtYTYwZi00ZDNkYjk0OTcyMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASE3Ep8CmUBe3Ot4Gt+PT4oLOq0dvX8D4aE4haXbrzDN5iP\nDjEyur9q8KvELp0dcRQQs9mDIeIsOUipMbFaeVHwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTeMVfljdIep2vmLdmR9jFIr4\nLZ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO06i2sIPUQfqyOGsE7AG0FQoF5YdGAmRzUFd2K7txccCIQCxYVLnDcFL\nwr8bJfh8c3m62vfYBr1nVxtcOvjQheUosA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATxwXQi8gEp6jQDvwXckGhF/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM3YmQxYjMtNWYxYi00MWI0LTlmZWUtOGJjMTQ3NzU5Mjk3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDFiZTAxYTMtZTBjOC00OTMyLTkwZmYtNjdiNTk3MjU4\nOGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdCGwYgOVA55bmEPjQ6rMDQgf\n5hAL8pvrnkpZ+YafwssJKOXGbnElYubIYZ+9qJlVs2FilVpIhSa4Lfw/q6pSOaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5iUjZiSUgXau/83OehkPLLu89T0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOHSxEP9\nx0b7RB1R1w0yG6ircwbbJvmw2ooupCBuXMPZAiALz+r5kH24OBPXXK38pa+LpVEi\nGR3/ol9+XjhpfFsOfQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2589", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2589` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZZsFviCjAjTvXT4MKNqkpT+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2ZGIxYWIwLWQ5ZTUtNDYzZi04NTBlLTM4YjVjOGQ1MDVjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNmZmFiYmUtMjlk\nMi00NWNiLThkNmMtNDI3YWQ5Y2I1YmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEddRBp9VqhkFt2x6d2sp0HeH7QniUwhJxu63loZbTQ2XD8nt5fphivTXlOvT0\n48nAApo6r9xiq7O0uxyZZHwihqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXeU9IOxFW/gzUbpAUTxVJlZpq3cwHwYDVR0j\nBBgwFoAUCaA+7nxTdj5k/H8wbTLMqVsZhmswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDiUZrV2ITJPy3QuF2dT3ZjZQQq7VeC\nSa/EUt8ynKfKowIgXUZyiHcjgtTCBTW+28wrCt2PZ46NFc6kxiJAZO///n0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcXlW/agwDWmske4T3ENeUkwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNmRiMWFiMC1kOWU1LTQ2M2YtODUwZS0zOGI1YzhkNTA1Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARr2GTAiGLMhgI8suNLaUx4T7OgiyE8Yx1FJvB6p6R7bk6B\nFsuGOWnOWfhvEJ5iCMhc6JO0N84rZsJIjIi8Vy9io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCaA+7nxTdj5k/H8wbTLMqVsZ\nhmswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOdQENPjYl+5LzNOZgoH5R8X53tfIhv8JRTYVfg1zL2HAiB+fjGb5oiE\nMM74kGHyTIV8Ylo7Bltm8TakqKcw6Bv/6g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXpbzEy/+LWkQy+ITB/b1QfkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNmZmFiYmUtMjlkMi00NWNiLThkNmMtNDI3YWQ5Y2I1YmQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGY5YmNmOTItNjYyYS00ZDZlLTkxM2ItNjUyNjEyZmQ1\nMWQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHXOqVAaWlyOnDnz2M/dKEcCU\nilphWYAcGZ4zdwc5UORoujmf7T5Dmidk//R+0U+aP+Dx2C52Kdy0rJlXIKCAJqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXeU9IOxFW/gzUbpAUTxVJlZpq3cwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJMo9S6/\nkoFwmh9jj0Sc1RrrTakt8aA7jx2dZBwqvUnGAiBmr429c95fj2h6DcsClhZ7Fpt6\nrYnatrkiuOkes70DCA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2590", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2590` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAe1CAAPUQ+/tDWpWg5Sv95f4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyZjJmODdjLTY2NTItNGYxYS05MWNkLWY0ZTFjY2YwZmNjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzllMDViYTQtMzcw\nOS00MzU4LTgyNzYtMzdhZGIwOTcyMDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiy2AHUiO1kT6qckEvJY5s4nZZAjD9qUKpDC9KxWWW3oUeiIU7PGsVN0wtxvB\nzzVGILHzVi3VbazXQOL772do5qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkJyFqPLfnvbRUlrSI/GMYPDyRmcwHwYDVR0j\nBBgwFoAUsH/B4PMa7HikUF0Hhlsm3Kv9EpAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIENz2nMsy9A2\nWsiNyubfHhjpkqHzrnBOHr2cp7b7MnsPAiEA5qii7BFFO658YZSn8K0r39/JF3HD\nf9ecKHi4ySwMsRU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeT4rIY4wJZGNcCuO0xjF1ZhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmYyZjg3Yy02NjUyLTRmMWEtOTFjZC1mNGUxY2NmMGZjY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQ5PTpSkvk1wtYfZw63IqapmKiIvxwO6ywpoH7Hn31nE62\nxCrJV1aiMnZdXutvxqcnoysDehQQZ7KYr5ouwGGdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsH/B4PMa7HikUF0Hhlsm3Kv9\nEpAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVjcefc2I4v6ji5FhH6ppD9lYCMczrvTHhyySV9YChPoCIQDIHvlChAps\nI8ucYI4Z9YwMFTGzASqUQrmzWA89YSXrBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAf95qm+dL7Oq38YgqinB83ziMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzllMDViYTQtMzcwOS00MzU4LTgyNzYtMzdhZGIwOTcyMDljMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjQ5ODhjNmMtZGFlZi00ZTIzLWI4NGUtZTg5YmQzMGYx\nYTJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhbXds7bMvNddt2TRv7jLHkhh\nMjr1XPZ1sdlSsUnb4BdRuB2Ci4RO4j2xHBIVRdZ1N8ED92Nw90ZK6aW90iqg6KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkJyFqPLfnvbRUlrSI/GMYPDyRmcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOhiVLGt\nTME4N8M7B6IchjjUXCPotybdlakvqUOvJ1pnAiEA+oYt7bbIAh+q1ep4xR3gvpJu\nO2gSV9mLoFVkI2wgJJE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2591", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2591` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAf8okmdHJ/1pdzt6uZCh1ar8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhOTBlZGFhLWE1NzMtNGI5Zi1iZDRlLTRkZDNiNGE5ZDBiZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y2NDEyNWQtNDNm\nNy00MTY1LTkxZDMtMjg4NzdkNDNhZWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELVx0meijVupkpSeuJ9oJyKE48MUIIyTsYaGyoRQQ4GNpubguBhcJUEQEPwTK\nlVYUtep9WTzTqjdapMh/Kvbs56OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx1k7DqUr849ySzoFKcpgbKXT3ocwHwYDVR0j\nBBgwFoAU5jGQ7lyncvcnhEN6qYiETFO+zZAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAOraECCR76Nhe4Zon69dGX4gM/W90n13KrK2xr7cF19HAiA9yzMRGPij\nHEXsD2e07Ls5EWq06eziIWP+lnr8itLgYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXf8s3o5czYMpd3jxa12wPDIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTkwZWRhYS1hNTczLTRiOWYtYmQ0ZS00ZGQzYjRhOWQwYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuMdr6P6mQVSfnJmLw5BrdmobwB3UwMKF+/QYE5bHfWCVC\nZ10do0Zw369cdkSUEN4av4sPNAHym7dHuL48yIeGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5jGQ7lyncvcnhEN6qYiETFO+\nzZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbtqnWS4YTqoRRcmGIHdFbcI89xLIKujVCifQ0ApLOGACIQCXQLSXQAoB\nGRaDwuAIrQc6wIqIzDzBSzPdxYTN/9P9cQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYrnaTscbp5Ac/24VZmOhLOoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y2NDEyNWQtNDNmNy00MTY1LTkxZDMtMjg4NzdkNDNhZWRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk1YTk2ZGItY2VhNi00NjQzLWJmZDEtOGFiZjUwMGE2\nNmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERq/3RlqveANyREbzjCJyxyGG\npcyMs8UfYZp/PG8SnYnmt+i5/8fn5+hPpCq52Upyy1VxqP59NhQz5RYmJ1OjRqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUx1k7DqUr849ySzoFKcpgbKXT3ocwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgVnRNTtvU\nFsUxc+BE7zWPIn1U+TlFSokCxUDeSoiFrEUCIQCEcYA5H7sH8nMsc2d/04RImZEQ\nj2BaljR7JQBY8yOPzg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2592", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2592` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAU7LkeAFkK2AMUQuMD1Inw+bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmNjBjMDFjLTdhOTItNDI0MS04ZTA4LTgxMzZiODJiMjg1ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdkNjMzNDgtN2Ix\nYS00MzZjLTk4YjQtODBiMjFhOWY1MTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKwFZqlc78B+rjpuBUQt5vUpodkHJt/VFvZlSg4/KUa/12EUsgMF0fFxsx7Cu\nacFr/rSZpcNab3txXNW0aFcJU6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDxehAkWMu/MSjMy6ZcxaWmaJ8BowHwYDVR0j\nBBgwFoAUylCCEANE5Eo7DjhKGdBQgT37dokwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANAbDLB0DHwYmfiuLsERcZDUfhLhOcwp09H74eRxWQTjAiEAobYumbpy\nKh/j64a/rWzayZEA4gN5HuMVeFPhmEij0XI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc6d4k48z+6Qq9v48gKR8X7+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjYwYzAxYy03YTkyLTQyNDEtOGUwOC04MTM2YjgyYjI4NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHi6zLUrHLFNdyNMdrZ9BLCSP+l4A5AJQOdZjox24hYq8n\noR/HV1OEoNAtwyrxwHX1M7z431hmT0bu+3/ouFzuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylCCEANE5Eo7DjhKGdBQgT37\ndokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJkBuj+lWO8QMFhFvKSa15I0yY2a0anEy6LBC7v11WRWAiAjYTWbVRkL\n3qWHuJXZKOWjnYWe0YPdOqat+2KCv6YCUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAehJmjIzVCAotCNcNekzCxAPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdkNjMzNDgtN2IxYS00MzZjLTk4YjQtODBiMjFhOWY1MTcwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTMwZTI2N2QtYWEyYi00M2QxLTkzMDgtMWQ0ZTQ1YzU2\nOWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgNIsVLyJ+8Ajafcd+N4P+il1\nNCfbgHeq2FCnpl+Q2G3qC/dlFieknOdoMAItbUMC1zy7QbNm23mY8+YcqNnM/6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDxehAkWMu/MSjMy6ZcxaWmaJ8BowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhALkjiOa5\nnXFrS3j7+Z2KIiAixgTkKCOPjes18lD16Xu+AiEA/hWWqdbM+NPFWn8m9toBYSKN\nP0WVj1nh6rhP6QHnDrw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2593", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2593` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUVRMEHRe9tVHhLuTvOcNK5QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljN2U4M2RjLTFkMWQtNGQ5ZC04NmViLTg3MmIyNDM5ZjRlYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU5MDI5NmUtYWVi\nYS00NjQ4LTlhOTQtMDg1OWEwYjc1NjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt4Eg/RiApMWCA8Qw1vEGvlcOYJ3bL6EmCb+5iR+5JvsL42bHWZ9M9IFDixno\naVaWMLfIoPtLs1QYhL4ZIV8K9KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXBRDjgdebXqVnbrblQZ+Qc9Jz/kwHwYDVR0j\nBBgwFoAUycWzsv9mrKLM7F/xAsCOCc7HpP8wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCwll/FZrTJiJjSs1lQ38tvGODgKY+xXZB9DG32ciriTwIgB2aRP6Z9\nJqKJ9jyvpSvX7xz+GCzKtHca2xAjIW5YQeY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXBDdcleOBgLA3yC6uT7dZcpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzdlODNkYy0xZDFkLTRkOWQtODZlYi04NzJiMjQzOWY0ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQ2n5BW3xQYwEcrO9nOsjL+jtZESapmzLd9ov0aH3hLVl1\n0TfImP6Rq2aE+qWMCpmHuT9kjM0V9Ujkaw807OGQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUycWzsv9mrKLM7F/xAsCOCc7H\npP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPpqfySbX0/QBCw+/YLTkAAsiUXFKLxKd4bZwuql5ZtfAiEA1cM+dxr5\ntdrg/VwsmAxNnLDysTN51cXhBFhyNJH66yg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdjxOvU4zC7eVt4ECsordJUNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU5MDI5NmUtYWViYS00NjQ4LTlhOTQtMDg1OWEwYjc1NjkyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDMwMmU2NWUtNzZhYi00Mjg4LWE4N2MtZWVlNzg5NTEy\nMTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERb4mvPxG39r8EgEOJBOS09c6\n9594Xp0509bOvuwn1ckTRDj4Q2uJM+8jO5O3/UBS50vBIRlWPeP6gfC7Qyh6eaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXBRDjgdebXqVnbrblQZ+Qc9Jz/kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgUMsTDEbE\n4pfQDvJNtOxXafuGB0kmM9owct1UBCvbUnACIQC0O3A0h8+upSOS/Hf151mqfwfT\njTeV7CTvPlDiOywPuw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2594", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2594` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAQXlgYhm5/bUEWtR9Elpe1ALMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhZTI0OGU5LTdmNDUtNDE3Mi1hZjg5LWE0NzMwZWFkNjY0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2YxYTdhZTktNmRh\nNy00ODIwLWJjNjMtNDhjMzUxZjFlMDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtkqzrgMLK9TkBCTsiW98XAtQ6VfMnWYMEv3lUYPj+JFWE0qY3q51pfQTZJZA\npAcZYHx4VOBvZqUgF+BdkBllEaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo1HlXE/zGJU2dEl85hxn4JI7TwYwHwYDVR0j\nBBgwFoAUKzob5pOQsrVfrFdgW4oBEg1zOXwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIHyyrvYbfOjN+58zRx7vY7Tgi7a2b4fezj1pox2M\nA8YmAiAKgSiYvN+Mvq6cKILOmI/1lOhHrrPyZwWEDJoX/MT4Bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd1VDC+pksVK01gs+UKCP3jHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWUyNDhlOS03ZjQ1LTQxNzItYWY4OS1hNDczMGVhZDY2NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGhDCs3eq0/AGRe4O+VY6hWIKUWDT6w1X6T3ITKsLPpVLN\nJUpR2UPDzIBxYcZCPjXB9XVAHYGkwZPy+BuTodMxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKzob5pOQsrVfrFdgW4oBEg1z\nOXwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGhuRHQoLRKC0TGJ9X1idFczMNYwrN0mYz1JEvumzGjgCIQDqNWWq2OaX\nQ7c3ILgP3eLusQq4qiAA7crXJzsZM04PYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAUAKR9QaEygRhawq0LZmlAhaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2YxYTdhZTktNmRhNy00ODIwLWJjNjMtNDhjMzUxZjFlMDY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDMxNDQ2OTgtYmQ3Ni00MGU0LThmYzAtNGU3MWNjNmY5\nMjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESPz6rgfpJoOJZtHJatR3cBfi\nXqj056RMyNWncD3Rh1vmynuNjBEL5tnXmIrTyw5VNleC2gXWiR58OVoTbn+JkqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUo1HlXE/zGJU2dEl85hxn4JI7TwYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgDshVuS9v\n9S+yUt5uOX3PARA30O9ygAxxrbwJaMIi+SICIArImRMzFjsjQBaXRSRbzTH2sEQK\nyJ+l2U8jHQezFs7p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2595", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2595` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISATPVhJQWLCSxdT5ZPjWJVfDpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlMmEyMmE4LWFlZjMtNDY1MC04YzAwLTgxZDBiYzNmMDc3ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAwZjRkZGYtMDAz\nMC00NTU2LTljYTctMzYzODEwNGJhNWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJq3m4ugC6NHYIrhnE3eyzyeBdlJ2N5n8HACv7qltw1Pe28yj1UinPUjlAPkk\nGHkgSi/b8ZBWgksufKTE58eRfKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrBDDFKI11HcNalWR0ngUQWAIBVAwHwYDVR0j\nBBgwFoAUW7JEfevxbw6pBKPAmG/yTK9T+3UwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICbPV3/wstGvGKE2HxRBzcs57TFcZMYr4dgVA0TA\nTOwFAiBco7V7CCLaGSO1TXDamkA7JDkYBR0SxhlTiVxRj74yVQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATIHT+L2e5LQy8IJna8CtJ1oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTJhMjJhOC1hZWYzLTQ2NTAtOGMwMC04MWQwYmMzZjA3NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsPxKpNX3SeGyjtwszsGuM66owvGJx6HWc49YbxH8IDwIX\nHCpXsz1BR6AM3cAfuB8c0Ues5ZrJaS+6V1MgrmXNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW7JEfevxbw6pBKPAmG/yTK9T\n+3UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbiDFvOwyj2SQAVp9Cus2s4M/H1ZoX5O0DK7wlXVyi8YCIHlHK6crDtMb\nZS7BFdWok8PCkJH871T12btMIBj/1zy/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQR81i/M1EYq+GLcRKgihkzVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAwZjRkZGYtMDAzMC00NTU2LTljYTctMzYzODEwNGJhNWMwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGMyM2YyMjMtMTBhOC00MmU3LWE3ZTMtYTFhZjczNTBj\nMjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiJ/x+Y14OjOdbUQt8TEnlRtF\nfsUP88s+HDXVKxWFr8q2HajQFeeQDDMYbKNonomhrIKPvqbTbgG5SonXDefB/6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrBDDFKI11HcNalWR0ngUQWAIBVAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOwbO8XR\nYvoZhGxY8oaojDch+K2UbkahZ0RtpMBg8GeLAiEA3vO4pC/fdEdnHPmhwy4VauGY\n5leGS1MkGMxRH//M3c0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2596", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2596` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAayBfEMYrqsT1smjEInNZhN1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlZmJkOWM5LTY2MzMtNDMwZS04YTQyLTY5ZjBmMDY5ODI4ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ4NGRiMGYtN2Zm\nYi00NTg1LWFmMDYtNjY5ZThiNTVmYmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+EVlFwudrAybqWDw3ypBxxoiUNwcN8hXCGmnZz0zrRIZ2BaiEOiCc0OPqxe2\nSR+gf0+omihh4XsDqM1uoV7Yp6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT1Pgo6yzqHLsOTmf0fxkbxFYOswwHwYDVR0j\nBBgwFoAUTC4m5UegF9K87GuXEwZUM9MMHHgwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCnrUU3aS/ZKqs9eIoPZxb94c0ZUHmFC/TLQ9YuPRmzkAIh\nAIhUj4XHy8pz5fJLKF8zqk/JLony6hfUQYr23WArhHCl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASXvh5Uuwd7dFbhPfrSt7vl3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWZiZDljOS02NjMzLTQzMGUtOGE0Mi02OWYwZjA2OTgyOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQu84UUdn8RYRDMwfM+O7PJSwsuxRpXVxYhtqbkm8i9PY/P\nA7dfZ0pANLjhx6lzooF8gUQ2hNVQS89QLYRth26Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTC4m5UegF9K87GuXEwZUM9MM\nHHgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN7aHuRdfK5EfYId9edIBQ6PsTS5K0dx8pQAT7LgtZf0AiEA4Tu2WVVD\n9HmuLFqwX+rBZje68sBmFN9YCRwxRLH5acs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISATuHxLW9kvM2gLwyFQJmEfZ7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ4NGRiMGYtN2ZmYi00NTg1LWFmMDYtNjY5ZThiNTVmYmI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWIyODgzZGYtZTIzYS00M2RhLWIxOGYtMjg1YzcxMWE2\nNTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHF/gKwLHlu1sDiExpYCMeciD\nlLACSFFUOm4+flB5AUl2LMAdN+P2MIofp20TyVehbI7zP6CM3axzVgJ7HY6bw6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT1Pgo6yzqHLsOTmf0fxkbxFYOswwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAN3+Ao2c\nBz3/iBd5Ek9FeTiW0hKaXz8yHfFU2KHsb1dKAiEAs6KFKRhVjMAuhNIPNUWSd+ub\n13PK8mKC6tTQwZQ6ZkE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2597", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2597` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfOQ9hkxQpeiu6RL4p1oSc4hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1MTM5YjNlLTIzYmItNDJkOS05NTA1LWE2OWUwOTMzMjA0MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc2NjI3NTQtMWM0\nMS00M2EwLTkyMzgtYTk2ZDBmMWIzMGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfir3yirUxdBmK4xdV/sDwVp+KAyCdsE7erL9iK1V8qTX0kfkkXcqA4DSXomA\nBRqETqaKzxL5sHqNVjtBqqZuTaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwmmtvgv8NZ1i3SvPetEb+KOY+E0wHwYDVR0j\nBBgwFoAU7QmSZS14KGGatRPak6YdWxZoaR0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDf1NmBTdi/Myj6DVEf+Oo+rO1JE8Nw\nbb47Qd61GCqfIQIgHtkz4baj1w6FNfnhDISvXUSvVhZHZoSBlrQpWGElEmU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfB1OTq4KAUbQ7UQvi8CKGDCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTEzOWIzZS0yM2JiLTQyZDktOTUwNS1hNjllMDkzMzIwNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQPnXirDVxwbJUMHNbCoqpQPnMgv+mrEmpqsHsAG8j7EBX\nR01l7l7Hpuq6asllNnbR5o5xbyaGOm2R/VtXte1Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7QmSZS14KGGatRPak6YdWxZo\naR0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALYJy5dlFvysCwpO9FDcLG0NC7ARGs83C5A7DgUU1FhjAiBk+loVjd5d\n2sP6MVMKy+ATnJY62nWwHDj1UTMJBc1cCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISATvB9z7j6HBx+dN9Z4xLfg3SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc2NjI3NTQtMWM0MS00M2EwLTkyMzgtYTk2ZDBmMWIzMGZiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY5ZmI4YjgtNDViMi00MmU2LThlZmQtYjliYTRkMDAz\nM2JiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqtgXzirD56F45Fl960bJyuAB\nOL6r191g87JMcFGgYErNpH66x+ZjyquF+HBXhbYeGvPCeQTe0aWQlGZBraFay6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwmmtvgv8NZ1i3SvPetEb+KOY+E0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJs7RXN2\n2/Ea02eb/vvGeeC8pOQ2mCPpzwkY5ukIXELzAiEA2q47ETBI9iMeaqiNO66UZPno\nRsVPAuNRi7dz6x7NKaI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2598", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2598` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAR9tDKslfz5L6uAm36+OgFExMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4YmQxMDc3LTQwMTYtNDQyYy1iMTNlLWM5OWU1Yjk2ZDNiNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQxZjMwODMtYWE5\nOS00ODc5LWJjOGEtMGVkMzRkY2M1NWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElK3pKCxLlDWG+A9WaqiPKK1wy3eAFOCyVMP8jNJhAvM+Cfxb1ztMxCgnSzD9\nfh1P51bcRnX84gmwyUodfG0LA6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYGv7I2Rvf+cE1vNN525R+OX7ylwwHwYDVR0j\nBBgwFoAUIHPLaNs/EtNhCtRs/URmtoKPFUkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDl04JTuaFQ08Jn6vqTiX3Ei5wxVW1B\nRqmmHF4hzv78/QIhAMmEcbdE0Lp5JLRBzFebY+06VAdLsjjEKCXhCTcq/glE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf2Zmxjo8oQESgw6phMlYp8yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGJkMTA3Ny00MDE2LTQ0MmMtYjEzZS1jOTllNWI5NmQzYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6agOBObfxz74F0oQBV+mudkmP9ZDa30t5JAXVD2SvnV5n\ne1b9ljtYVaSOxwhJlnT6mxRBFbiamgBbX0Gi9JV7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIHPLaNs/EtNhCtRs/URmtoKP\nFUkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdP1CCcUxfLCdfyAFOREt+QqTC97cwb2hxMJ6w5QRDBECIQDKQVoyVnsN\n2/2pd3z2wz352feadp2l7/YavcVR+7KZog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYIKHILKCPl3Ph0AIN44exDlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQxZjMwODMtYWE5OS00ODc5LWJjOGEtMGVkMzRkY2M1NWY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjY3Y2MzNGMtY2NmOS00ZTI1LTliMWMtNzJmYjI2ZjRm\nNjc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqSO5SdK9rAfLh2seRDqhEs8E\nmQeMPOr9XEH2hOzuXbjfeI9wvOjJ+qeco45aKBzB6IYzReqDZ7GBat/S38KrxKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYGv7I2Rvf+cE1vNN525R+OX7ylwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhANs2gtAJ\nZB+p3SkaTHJB8O7KSkco5mZuBnBF348mXmXyAiBPzT9fNMlBPbRvL4qfx28sCrVR\nwoP2zWtGf3C7i48I4Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2599", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2599` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVRRgxfnMpaJ1TK+9Vs3jEfjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMmFkMDQ3LTBjN2EtNDllOS04YjEwLTE0MzIzNzBiOTkzZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJiNzA3M2UtY2Zj\nNC00M2Q1LTk2Y2QtMWIxNjYxZTFhZGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE96wiMvjhhoskAsdnbHBnWW613/CO6d1POixx3iuu3UY6N7IE+QhnhZkSI2Wi\nrDFTzQbrINdu5IVndFGtSk6oGKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOYxedXadnYFhUsLAq1f2PVQsf+dMB8GA1UdIwQY\nMBaAFOQukewqYLPjx18wpNifdfuyRZQMMAoGCCqGSM49BAMCA0kAMEYCIQCGmoX4\nxV0yI3nU9FZyGcd14ZRSCdNBh6P9tFmCvGKuVwIhAMVf4p4jZ+9G+aVOKhS5rAB5\nVRzS00bzxavPrxzptuwF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT0FiXfK4waHLslMIZWVW4RlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDJhZDA0Ny0wYzdhLTQ5ZTktOGIxMC0xNDMyMzcwYjk5M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpFb+D1OXuoVIyr5mqoR9UFTwBljqTEydmqZu3/FTOxWtO\nHMqUWiJx9VPx+WABKckOgZH+epiMoY4ZjRG/NO69o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5C6R7Cpgs+PHXzCk2J91+7JF\nlAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLIrNaScmr9oHflv6f94mUs3BYvfoaXQ4TYvXXNnVgUcCIE84fEe/dVMb\nregM6A8B+FOITKNqQETo0V+9TpY7ErBh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdSO6cHktUVmbMEjnifs6wyUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJiNzA3M2UtY2ZjNC00M2Q1LTk2Y2QtMWIxNjYxZTFhZGYwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWE3ZDBmZjctMTI4OS00MzE3LTg5MmMtYzM2MDhmNzAx\nNjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoh/W89ZwYOzUid5J8ij3y/bt\nB61Emr3fkYBh52ZnV61eI81CLVjYKQEv7ZESxN3g6Co6Swbh269somCV8YcyvaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5jF51dp2dgWFSwsCrV/Y9VCx/50wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgQUag7FLc\nDvAaYpDGna0KalsOTR1hO0E/4bSZKR0E5JUCIQDY8a3sj+yLNcx8xFmR0vTT0n1q\nDnvGQRiM2ZcrGcmfBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2600", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2600` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQ1M3nHb83uXpb9h5djz2uDaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMjgyZTBhLTgxOTItNDY0NC05OTA5LTgwNmZmMWIwNGU5OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI4OWJjN2QtYjhm\nZS00OWU4LWI0NzUtNGRmM2Y5MzNkMDgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq/Y7K+cdJG/G7v6MUxnWlRMjEJ/PhE1OymSCZ89S2qNRuLQtF0f8OyitkkR2\nbnFOHxRF7eOkj0yX4hyV9zxorKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLxGV2+plkjRow9uwK+Y7S63sxkSMB8GA1UdIwQY\nMBaAFD6T1tw5KumJCyqiBlgPkV1l+UbVMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA6UBsWtKEfubv09bReezVj9KEBFRzok3H\npN020TtoJYECIEa3gIIgMESVtfnBRv9XzMfXFe+bcW95i37avUOWi99C\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUaVelOqOdhzIxsz5PC0ogowMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTI4MmUwYS04MTkyLTQ2NDQtOTkwOS04MDZmZjFiMDRlOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdpqNhqOqWCMuu/LZsxQagw3veiK5LMt2ft4Vesgc9hdFU\nqwFfcXRfUzcNyuIF1LgpCdHmfv87SXTMiSPgQYXno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPpPW3Dkq6YkLKqIGWA+RXWX5\nRtUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALr8F0l2Fr+2otSB2uemXeBo1an0w/fT6dCsFwIgUopbAiEA3lk6rqMI\nQ/AQPtF7gAxYejKF/RXeYwV6UxSMfVFrKzE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARxmmcDVNy7SlJQE1ttmBI/cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI4OWJjN2QtYjhmZS00OWU4LWI0NzUtNGRmM2Y5MzNkMDgzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNThhY2ZhOTgtMjVlNS00M2Y1LWI3ZTItMzg0YzM4OGNl\nMTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwPKDGPoqfcnAxKVqvYohterf\nit088cVb3HlnzQag1esZ2dIBiseqg/2k63JEgisCCsJejxEP/2QQQpCBcjMZN6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvEZXb6mWSNGjD27Ar5jtLrezGRIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgEvUWU+0Z\nfGc6/BFoYR8+Sl9Y+zt1zzJyfBk6cZx9bmoCIQDgvi7J+JvcHpYpK8vQEhlxIB3O\nEFZxnJgGQh9j8Jt8kw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2601", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2601` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbumhWLdtMpdebatwc9MXpyNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwN2ZiYjM1LTlkMzctNGUxMy1iY2FkLTg4ZGUzMThiNGM3NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRkMTJjMzYtMTU3\nYy00OWRlLTg2OTUtMTljNTU0YmUwN2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+Y5YtfWK9/tIjL9mZ/9DKob9LcbT1o7364MvnGrqRvwM9HSPS/ZQhHDRghYG\n0oMa1JAmSQHL4jIwj0yNbiQGFKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLaxsYCw9/+ENj7JWUuo52Ve121WMB8GA1UdIwQY\nMBaAFJelwhhiwu/wUSpTvxRL9rIMXOkGMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA97z5kIuw2h06/8zicJwOyh3HWjL60m/B\n0rzrR4EXrO8CIG+hF7TzUteREPek0LNFafntgJsgRzeIMhE1ZfncXsqq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY8qAlXMAdI6AYy36yx9z69WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDdmYmIzNS05ZDM3LTRlMTMtYmNhZC04OGRlMzE4YjRjNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZvmcGXYRsiP5preL2NG4zrjnyFpKQcPiDdKo3TiJHu/vm\nmEPgK8954m+dcKBPnqk4qtE+A9lzXXuqK2RjSb+Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl6XCGGLC7/BRKlO/FEv2sgxc\n6QYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIwgeS/0NtASKYrwH8bOEDvBUsx0QHu3c4HdfUI/hv5LAiA3eFcONAE4\nJ+zTmqxeTM1DKDsMHUNJbZ6iCaO7uzbAmg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAebzCD2T181ZKp5q/SwirhpOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRkMTJjMzYtMTU3Yy00OWRlLTg2OTUtMTljNTU0YmUwN2JlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2M3YjYxODgtMjdlNy00YWZhLTg4YjYtNDBkZTc1MWUw\nZjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV8l6SLicQxjvdQMR+65VNUOr\n2lrp7E7s9z+OXyYVd7aU3UU9wagKbXGlxYQZuVgMxjI1fZIX1htgA1XSdH4ELKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtrGxgLD3/4Q2PslZS6jnZV7XbVYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgCEOMiZ8L\nj+4wXuWjO7Uph07/FTJjAj5B02BbRDZ/TyQCIG61w1yC1688rHxz9b3qX9E7M0oM\nEBpPnW7Xqs56J50e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2602", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2602` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWSgg7OYJ2kF/Omk0H9T8acWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzYmE3MzBlLWYwYmMtNDdjZi05ZGViLTJjOTdjNTRlNGVjNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNlZTY1NWQtMGU3\nNi00ZGNhLThhNDctODY1MzZmYTUzODJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETr5OtbHtXKKqJGmXtApEl0DRMKf+qduAfnjDoM3/GZ5Lz5zjMR0XLuHl4ReC\nqmqc4Kje+mHnx1kP3kkPk8at1qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSx3yQRT6YsSbbVXwCIFRChK9VrTTAfBgNVHSME\nGDAWgBQQlvQHNcwQ3nGegEYKR9fu9unFrzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFH7XlaAjoCpFc7DIWibQ6xYvdzozPSN\n6QChWztpfkYtAiEAwL0YEyVAbW75psdTXfHH66GClritzpRkLBeT5jN9qVo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQiSSWAac4zaOXwddiu0JsliMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2JhNzMwZS1mMGJjLTQ3Y2YtOWRlYi0yYzk3YzU0ZTRlYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHXFKVn2L2uyvP2TU0gm9HPaY9+aG11Jwl/KjKgorEiQvy\nXt4SmbzmP2wbEBZRQ3tzpMyScqC7Wql7/iUzwDcgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEJb0BzXMEN5xnoBGCkfX7vbp\nxa8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX2GmopMpONqe12YPt7zU6K5KBDGSs8P3baFHdmTR5aUCIQD7U3MP1r1j\nrqPnxFoeuPdeT6S5fg8srMhz2jWmWJwFQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVvzt3KN8ZS/bHZ/4ylpVGYMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNlZTY1NWQtMGU3Ni00ZGNhLThhNDctODY1MzZmYTUzODJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTAwZWE0MTktZTVkZS00YjgxLTg2NjQtY2NiYzRiMjZk\nYWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpKMq1+33EUy7Q9V4/r/GrLAc\nOGemIYdt5Bv7iUr5sKrI5Zqn7I3y9PFvpxEPmVepD14nrBGChiVw85nXKHDWA6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsd8kEU+mLEm21V8AiBUQoSvVa00wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJuzLcYh\n/MW8X/p8G5abkg8WK/SRUv3+xdcdBoYstOslAiAwPg9k06eqXTRii4VG8a20Uruf\nFPgMZtAh0mYY5HSX8A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2603", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2603` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAURnbACvOb+BVQLlBrZZxtpLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwOWVlMGRlLTViYWYtNDEwYi05OTBjLWNmMmM3YmQwOTRhODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTVlN2M5ZjItMzQz\nZS00MTdjLWExNDQtMDRiMDdlZTI3ZDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELyvkJudv5OYUS0ewF3LT6YLXMzzNMPqH9jcuffVSra6IDrH5AJYJtqWUX4Tk\ndoqw0sUsm44wf9zQVAAtcQ1SZaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYr1u/Lsd2fmkpUKHr4jxKODz5dMwHwYDVR0j\nBBgwFoAUAxXj5+xi5gL+12eZhrk486E5o2cwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiARua4esKatLMm5\nEVXN0i6mqzMiIIEo6ABwHKhdEfXYtAIhAK6L4FEayTYNmwqj59RGpx/F3JJ0RTpO\nfA2HEvqBbj7h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV7axPCZJKF/GfRWWvegC4/8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDllZTBkZS01YmFmLTQxMGItOTkwYy1jZjJjN2JkMDk0YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxPtv9Fi6a+3ZvnHDhtbi9VuoQ4+ksJrKflijkTUUrMaGt\nnpGeP3gyA6pgl1zr2spRQaHjObqrI4bFDd4Y2jwwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAxXj5+xi5gL+12eZhrk486E5\no2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVqxHgHH8ZPANrsZdRP+MXRCvKXl2qkaJiOWeKQlADbECIB9ExbQUSc5c\nCFBVqwYsEqDBLCwfAA220uOu4bUSsnX4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZd1Be0JVpZF7USL1ewpr01mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTVlN2M5ZjItMzQzZS00MTdjLWExNDQtMDRiMDdlZTI3ZDNjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2I5MjVlNzUtZjc3Ny00NmEwLTg2YjYtMjk0N2IwN2Yz\nZWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKOIBF2PWUjUNLi0uIDrP0snj\nnNsHUJaJhXxw0GvhDSdQiv/acFagEYQRSfjzfEo9KFckvssTFvzKkHiq560F+qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYr1u/Lsd2fmkpUKHr4jxKODz5dMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgfvZmccQc\nFImeAEDywug5PXKoB6bYj3BeYn+LrS/dQFMCIQC9DBjgPJaqNtM7eoGQEH8lwj0b\n2crx48oSRhj6a8/ZTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2604", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2604` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAUcZHWYUmZH/K1l3x0r2Bv66MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzYjcyNGM3LTg3ZGUtNGM1Yi1iYzYzLWVkN2ZkNzJiZmFlZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlkMDViYmEtMWI0\nMy00ZGExLTgwMDktYzEyNjMzMDQ4ZGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErKKkLURanBgm13uIAX+DqsfAM8Y9jrpOHTpknTKwhXnD6aCQq1VZ3fMAdYaI\nZOsDJmsS1gQDVW42NP7BZiCTuaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxpFy+mTDMkW+2Jg1POr6Hon+vMwwHwYDVR0j\nBBgwFoAUS4gdY769m8J5zae0WMVS80xEi2cwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA1Ctg2dEouE+a\nHYY88BGQt+CbgX22m7uFc+gBF3VGzq4CIC/0oKQS2hnYbxBDlO+bT2GBXDPu+fgx\nv6Ke2BZiQpL5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXzuzooQLZs9aQk2bdKtMVs8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2I3MjRjNy04N2RlLTRjNWItYmM2My1lZDdmZDcyYmZhZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyF4KF4eG1fUmbB6duFFehm7vxfZPmYwXpDyqW8lFJUg4P\nkKMOqyFQW0gSWayCvY4pQ3CgqSFANodS7FIYExQuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS4gdY769m8J5zae0WMVS80xE\ni2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIKmiySS8+ZfPDKB/EFgdL3yTC+StkRl8v2N9y2aEEW0CIGp+6BXy2W4e\nl2AsH926cpP7miNyc6Xa1nGK9I4M+3SP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAViyysUnfiX2NFj850m580llMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlkMDViYmEtMWI0My00ZGExLTgwMDktYzEyNjMzMDQ4ZGJlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjY1YzliZTItMzgxNS00ZjBjLTg2YmEtZGU5NjE5MWI0\nNWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX06JBfNY8ZqhXN27Q9mEKx7I\npKY/EPV1EhLKo85Q+zyrb7TI53kodIl3oA0a07866vaO4Qk9y1znAwg7T8j/eqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxpFy+mTDMkW+2Jg1POr6Hon+vMwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhANG4DaAE\nwvCyYT5MglRcrsv0XekXCazDtZAbiXNXWuuBAiEAg0a1opFjxM0ZsmsEWbAk9+6c\nOH5KDzvfmTWrxyV7nQQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2605", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2605` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISATqo3Lava6Tlyde44qVJ0VXaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwOTMyYWFmLTFmZDAtNGEyZS04MGRlLWNmMmNiMWRhNjQxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNlYzg1MTQtNjM4\nOC00NjM1LWI0YWQtMDFkZjc0ZWQxZTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtgUgDGh1Yk0LgdPcfHsOZmr6P7iHym5isQTOl9D+v6yNGtdk768WPJwSbiwt\nEWQVqtovvqFUX66ze2XT5sJGvaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSREczdw0oZXT524ZFlwQVvVyYFIwHwYDVR0j\nBBgwFoAU7espF0tpHEIAlq5yGpHuCrvL2Q0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAxxAdrNB0vZIAAm11jx4Z\nzShJWXGxAXisla+YCuQXpewCIETvE0M9eAg4lRUv0v0hZdMGCWoGfFlY1jlREbFe\nTMz9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY56bhpMey/yXAoV6vGUvisEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDkzMmFhZi0xZmQwLTRhMmUtODBkZS1jZjJjYjFkYTY0MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCnLH6hBci1aFcsvBGBarI9PZHaVXsSJSKUyA31cIdzllw\np8EJBm0NUuxhfvNBwsa5U0RR2S622TsbG2zNPtZPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7espF0tpHEIAlq5yGpHuCrvL\n2Q0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMzXBYf3Kd8alaK0Q8fwiMuiwwMri4tnBV1ayDPG3+VXAiA0OZOicRcu\nEsN8VDcPChBsb27qGllpnbvKnNw+D9Mpjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAYOb9c/XGDlEFnfc7QmMdJNeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNlYzg1MTQtNjM4OC00NjM1LWI0YWQtMDFkZjc0ZWQxZTM3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmMwNzc3NzktOWQ1Yi00MWQyLWFjNmMtY2U3YjgzOTQ0\nYTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7niyq89dm25Bse9do0ISKSiX\nnHeS0V98bKeqKr+SzuO2BvYM+WJUl6sAb0ALDrIS7iWIxbUbmZMOTylG8Kp8cKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSREczdw0oZXT524ZFlwQVvVyYFIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgdjUFBKTe\nS2HyKHh3ZZ5SOGlcQvdWrZ1fL0NAcAx15pYCIBUjWgNN6h73wYxyVUm/ZNFMgHAh\nGG3vx1t8h1Owq+Gc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2606", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2606` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAdhRQbQVErxmrex7nlure1nlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjMWZlMmM5LTcwODItNDc2OC05Zjk0LTM0MjdjOTMwNmU3YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJkMjg4ZWYtODk0\nMy00ZDc3LWI4MTAtNGQxYmRiNDFjNzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMlRlz7IhKk1IivKj7tRzXdytfhPahffxmxuS306FFO789pFz3G2ViBWMtquX\nbvPrQXgShZCTOt1zc/REo5yfnqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhuZ9d9Hi2VNhhXzREE8bqiBCm/swHwYDVR0j\nBBgwFoAU95Dm4NRVPNHyUemsHw5ah2dx3OIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAstVV\n6l8sv4ZPqjZ9sZPdxnjlhOb8qPvgE50qu1jofocCIQDdhBEwDsM8+vwuXqx4E+wv\nlZ4+J/+n7IpBQpKlHsrT7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaSUQ3EWp31xF81xJXID2Q2/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzFmZTJjOS03MDgyLTQ3NjgtOWY5NC0zNDI3YzkzMDZlN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpf+6OakVS2eOSYo3XpjuFBvEigBKT1HuXITIrqF/pIjdb\nQan2Yw/zcii6taaP2qFQU1FMx8J1fgD8Hb1lkK+po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU95Dm4NRVPNHyUemsHw5ah2dx\n3OIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLikBOnWzzY9gduvvt/U0pv7wA9XmZrqbocxghv0WIH8CIQDhnTjmMSCi\nuQn958LtJgenNZoQ9kjdwJ/FqYwAv2Ly1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAYcS4F8+y2DNRhEf7qvzD1LQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJkMjg4ZWYtODk0My00ZDc3LWI4MTAtNGQxYmRiNDFjNzkwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTIzZDRhM2ItMzQ3Mi00Y2EwLTk2NjYtNGUyODJmMjBm\nMDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGS+bVmRSztJ4zWx2UnJCP37l\nIqeneys3JNtlkMRMuv7T52JI1eaCNN762GKj6n+hLGIsEbYJZCCUg/TdsCOODqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhuZ9d9Hi2VNhhXzREE8bqiBCm/swHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgKjsTLs7T\nM70BxSwg+ZXmXJ+fJojU298mPOiKl/sS4wQCIGwy0hZnjMB4vgh3RI3iscs/OuGN\nWVsykLuY4VI56BMl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2607", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2607` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAeLlRj8+lvgejSklxFgbLyXsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlYzFkZWRlLTcwNzAtNDJjYS05OTBkLThlMTY2NWQ5NTBiOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QxYWY0OTEtMzA1\nMi00YmRjLTk1NWMtNWJhZGMwMDQ5ZjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEju+0V6nC9tFBb6Vz9ahmkNjkqkjdSKUNMI5Dz1bjsRICck5QwKA/wpmWQYCW\nOTZQISpQHXnfsf9yTZc87FDxlaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmsMgVPqbeKwhbjtY4Tb7i5VaZYwHwYDVR0j\nBBgwFoAU+9C+KAvmnprFAqYoEybIpTtcW1MwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA4FSd\nU6myJxhXjwf2+kfYGKQPzHorAAxKe5PwvgFfSiwCIQCm44P3qVxd2hvf/WO2HpVI\ntlQ00dcwJrTI6ckLkMrLjw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISARQ3NQwwvOW7tuHvfQ+U+z+VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWMxZGVkZS03MDcwLTQyY2EtOTkwZC04ZTE2NjVkOTUwYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcbzxOUvKAbd3Avb0vihKy04ExYYyhKa50uCF+gqXoNwXn\nKHg1TLWeLfICvVlCsNRCRbd/pacsSgenM3pBuD0mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+9C+KAvmnprFAqYoEybIpTtc\nW1MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIfOwWnXuSAaxALEdWzIfvfeYqu2BPC9pr1yK1wVL3AEAIgDKx2mZV3kFnS\nwyice7+afFAOy+QQ6CjdBF3WPJumYEE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASo4QWb6x967zs0RDk8SO1dRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QxYWY0OTEtMzA1Mi00YmRjLTk1NWMtNWJhZGMwMDQ5ZjY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQ2MGIxNzMtNGVmZi00ZmVmLWE0ZTctMWQ3MDMyMmU4\nMGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMTNsLWbgPy9JluotDJx6wE1P\n38G4dS9NssJkzERRglv8ruRAcll/cmHAwzl4ithiau/paAHSXvV4J43hR8mcQaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhmsMgVPqbeKwhbjtY4Tb7i5VaZYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgOluiQplA\n3fCqxPlI6AwsTlnNZU8VOLOh2MhozjCtRp0CIDoOKa/T3fzO73xMTCN2laVc88ap\nBPrL+i8hEEa8IdFz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2608", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2608` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYkyJ7hEWpxeQ7Qgz8A2/48wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlOGUwNzE3LWVjMzEtNGY0ZS1hN2ZjLTBhZjM3ZjY1M2E0ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdmYzQ5ZjYtNDBk\nNy00OWJkLWFmNDctZDE0ZTcxNDQwNjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuCTl8WYfOGGq2m/J0N2DTyMkrvvcNqcLFwb6iTbAnAvahqaqrWXYL+Zk6wro\nE6WK+LXBzVt4HIBfAVctfFh1jaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDtRF3B4RwG221KzZTV3u6g+dc2CMB8GA1UdIwQY\nMBaAFOywskituktsIzc1sZNqlNSt/GtAMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA2AlR0rTdpQ4no0la16GAqfA9L5VSotg+\n/1Rcf5E2ZasCIB7RwapYFbI41G5qWkgRIc4R9JV+Y48AAa79k3ZXghXH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVKFcKFOu8tw0SVirYXSEnmTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZThlMDcxNy1lYzMxLTRmNGUtYTdmYy0wYWYzN2Y2NTNhNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATm+XdpHypnICwBGwP/tHbAT07lMiZ65j7iodYvfJ1EOdcW\n1dio8R6CpZUmMaemisjdCfL+HqXXvsi+vuJMPdeco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7LCySK26S2wjNzWxk2qU1K38\na0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBmUxYJfI9+UqGyAM68Bw2JKHyLsUBDp+74xBS2eq9IcCIQCOZOlWrCya\n+4KThKyBrkYTo9KGaDqgy27mjiDMb0rLIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAV4q0s4DX3pm80p+d+OLrd7UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdmYzQ5ZjYtNDBkNy00OWJkLWFmNDctZDE0ZTcxNDQwNjI3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk5ZjJlMGEtODE2NC00OWFmLWFmN2UtYzhhMDQ3MmJi\nODIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETe55x9x1v6hOpvIQDnCmlsFx\n38AQw6vUze1CelUe5E7cChTkqiJl31FuPiQcHzX48Ge4rM5gJgxLN37LoxzCiaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO1EXcHhHAbbbUrNlNXe7qD51zYIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAI6bR0Ue\niI+nRsmEJjotDCg9w71JxhDbzP5HKqfyrQsjAiB3kMPkXve7DoOKPjtVamsJHoCn\nznzQzLRzRYFhcehzwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2609", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2609` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARSkIzHWC07Law7b2o81GXgIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5ZGM2ZTg3LWJiNzktNDE4ZS04ZGRlLTJhYWQwMmZhYWUzZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ0ZWZkZjQtZjVi\nYy00ZTc3LWJmNjItM2Y0NmI0YWE2NWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgbExP7+EF5Gt5FPUnTmYt7IFk+koaVZAY1wrGdywng1OhUoGLX5QJjOr3pPa\ncDSERLRgkx477biwI/rGCCOrNaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF9J3UFNnYXDr1BhQZfJbAAyMXpEwHwYDVR0j\nBBgwFoAUJAoRF5KpvxErY+MLxFZzp0Xut6cwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAM9qb/uWyASP\nqnmPwN/nkceSZGwjIlwQeOiiltZarn1VAiBY0jtR6blKHd8nKReGTkF3hEDeQmqk\nF/VVyDw94TiGkQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATEtqHMFaQZa/tLAsvTB7W6tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWRjNmU4Ny1iYjc5LTQxOGUtOGRkZS0yYWFkMDJmYWFlM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAfG5QvmDBKv+qopQCEfcAyNQ+NPNoq5p/0hkhWjXkqzBK\nY8jmBPn9i+EeCofeSAqGudNIdVr9liiT0BWZDnfqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJAoRF5KpvxErY+MLxFZzp0Xu\nt6cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLqN9eRvqkGs2/ss3U7LUnpsB/vRFxigKGY8fPPo+YcsCIC19WWFQAGME\nZG/Y7eRWZ9F6uOcoAqaOY7ALmNX1YHD1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYBa6F74RJ6Jqmyt6iY+62kFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ0ZWZkZjQtZjViYy00ZTc3LWJmNjItM2Y0NmI0YWE2NWJkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmU3MDg5YjMtZGRiOS00NzgwLTkzZGItZTdmNDMxZDlk\nNzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmFhpY4dT9Xt7VoiTzaOp89uo\nPStv+ZzQpKbIzgfSnAexv1rR4AQ4nVaI78FDgMY5Bdf2JHRL4PX469qj/pw8SqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUF9J3UFNnYXDr1BhQZfJbAAyMXpEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMZvqevM\n+yvYzi8jxkco//wcVUI6gHEJeHdy6BGvZ4L5AiAEW64f1ywuRDa8wAtdByrlKLpo\nWrrB+lhNWcNMYOjsMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2610", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2610` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAchDMgdVcdDtnhDX4FGSYhLtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmM2JlNDg3LTM5OTEtNDg3MC1hOTJlLWVhNDIwYTQ5NGU3NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ5MmNiOGEtYzVi\nNi00ZjlhLTkwODYtYzhiMTdjNjlmZThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoPOk6GSBliQaHoaN73JCb2nUSGbdBF4tq/RxV3dhFnCaJTfdunSkSxMvTpVC\nkqFJQl4Bswrb7u+846nI3CC3VaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ8AC0rElgSPWWF0AswMA6yqTwzowHwYDVR0j\nBBgwFoAUUera50ZcwWd0B+hcjpVZh+8SSgUwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhALNqWg8x2sBo\nEsqggKVsdpQQUImZVFEvYPZzlaOX9pcBAiEAhDfSZWUm0+4Q6jbkX2V+1iSqWyai\nFnE8eqEGg7kAXq0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQOtMxnNaa5kXbdK3P/qmlm1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjNiZTQ4Ny0zOTkxLTQ4NzAtYTkyZS1lYTQyMGE0OTRlNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQv1bmxmJaQSth9yaACE07pk0aR8mh6SZksAVaFYJxUCw3H\nCqiwjK8r5P7/Q41Smo9iyxkgAavEgBxD/Fi7qe6oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUera50ZcwWd0B+hcjpVZh+8S\nSgUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM3r/688bzj3F0Wo6++JikCYcRj8O09gp9B5rp3heAtwCIB8Qx62aO/3K\nxtrEFcsrFjxxS34zxWxETWRLcQxnvgC6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcCok3Cyq5lxczfYYJky1YZXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ5MmNiOGEtYzViNi00ZjlhLTkwODYtYzhiMTdjNjlmZThkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDlhZmUwMDEtNGI1NC00NWE3LWE4YmUtZjg0NTcyNTU3\nN2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETAKBA3ivjFvmMQN9fqmg7IaP\nnoV+9QpTMQiYz321Sd6VUFc3FU6HPW8Paf84unoDXyQ0LTw+DXGMQZJy9vYb1KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ8AC0rElgSPWWF0AswMA6yqTwzowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIBUnUL2\nLP4KHSgl0f1Rd0Max5xka4BwYKF2JJPPYCVcAiEAqdkztXtM7vm8uULfnvLLykUQ\nAf6CEPWwT2HUcFVqEkQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2611", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2611` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcXz6CWRZplgKSQ89PSAWMUdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5OTljYTQ2LTg2NmEtNDE3Ni05NWRlLWVlMzMxMDc0MjczNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBmM2MxMjItYjE4\nMi00ODkyLWExY2ItYjg3ZDY0YTA3OTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDlK2lOItFd8JpOwhKy/TXhy9jg0LqH/FUJ+HNyhuPivGRlJ5cIQggBV0jTtg\naCh6q4ySuvv25j/DHkCkVPOggaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnoEt1XV4uip83VWTczbFCn1rd/MwHwYDVR0j\nBBgwFoAUVvFCU+wmMRfSFa5KIh6mW1RBFCMwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDwmW+A7S3f\n7FusYF5n+9EenLOMvtphv52e9jnv7VjLUAIhAMhU49Yr5Kn75z5QaoBGqmoMm5k6\nbbkLM+EdU5OjmMJa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcdvu6LysqDac44KOuIxeXiuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTk5Y2E0Ni04NjZhLTQxNzYtOTVkZS1lZTMzMTA3NDI3MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQQtdCp8nmcNrRHTpkC9e97RmB7tSzZgOZnGDJIqyr+boT\nWx6EGjEMp2ozbb0+VKdeKvankGOXUsDuIG/kqZn/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVvFCU+wmMRfSFa5KIh6mW1RB\nFCMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK31+Nett3MwPZjC3GbcKJUq1jZsHIuCNm2O7zrgPBkBAiEAlAgBcXKS\nNEZLdFC4dUSgbSkwA4w5c1b20Gm9Cil/1ww=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdZS9Ny+zAcfAHldlIrSrW7WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBmM2MxMjItYjE4Mi00ODkyLWExY2ItYjg3ZDY0YTA3OTE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGNiZmMzYzQtNDVhMC00ZjMwLTg5M2QtNTIwNTA2OWYx\nM2EzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEerm0DIXEyJ3UlY8c6BQeT5s6\nsE7c25a1bgKX0VmZdLIOxBl5HrjI+hoOdyNQ8oi+4/1Acoymo0/TY0iPb0V0bKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnoEt1XV4uip83VWTczbFCn1rd/MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAIxXZ6lW\nOtebg3VMxEYeYdSJ6LM7AMMssm8H5WOcIdLPAiBl2CTK7RmjjAk3CcA4KYHs54lS\nBBM1NsoiuITQlCTobw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2612", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2612` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAViQz/Cq9ucRiMsHog2S9oKPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwYWY2NDM4LTA3ZTQtNGZiMy1hZTA5LTBmMmQyNjFmYjc0MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc0ZmVmOWEtZWZl\nNi00NDM5LWFlMjEtNzU0N2NlNGEyMmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIw7L8ROnCJPGopy/i42jrHd+q2UbneYCZHsJxMAN0pf2IBW218QQ1CtCWSwB\nxPLOLGEvwdWDOJsGsEGnK2wQwaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6fXzKQSTzIefxP05lS5YrtQZpJkwHwYDVR0j\nBBgwFoAU/OR0bBKik0kK+JBjvx2fZpuB+8YwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDIeRNweUHKRtcvUYLvd9r3oV2ZZJMu1nF+U9gtuwwmkAIhAN1Zu0/YP3lS\ni460mufq1sCCo8UNxw+2ku6ahIQhXGe5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcG7vVP+axVe/Pe+V+mGfa34MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGFmNjQzOC0wN2U0LTRmYjMtYWUwOS0wZjJkMjYxZmI3NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrFxqtDp9S9bQ5PRUgLD7H3NkY+3hvFe6T8n610gE5EHrR\nZomY2qk3FwXxI+HYDuM4/uVoAQ3hyPG4axvbaw/no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/OR0bBKik0kK+JBjvx2fZpuB\n+8YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL/EXfIeNU2DXGTdE2Hz9z9Gx7p584gDEOq7fPjQ6/V/AiA4JFGAYZRB\nTlgGHnzi6ziK22p1P0wCMHswxw6ldVsnpg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASr3MR3/8GAQh/gq7B/mC7JVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc0ZmVmOWEtZWZlNi00NDM5LWFlMjEtNzU0N2NlNGEyMmM1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjZhMjJkMjItYTE0Yi00OWE5LTljZTUtZGQyYzg0ZjMy\nYjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBO/YPSq8VJyl2DV5sBeyGQDn\n3kzaPA0dy91CwRbJ5Wfnl97QJeMFju9PZx0Mo03DkyxPB6BjOeJeemgcJ6eSN6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6fXzKQSTzIefxP05lS5YrtQZpJkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAONb2/Sg\nARCzZnesiJtj4krx9vStkPZz5FrmM8+z7LjgAiAPmA+xYiwVbHAGCjAQou0EWRRB\n6DrPOZbMkjngcm/uGg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2613", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2613` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAQPqBKDGPR6/wgIDfWq/sa4FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiMDhkNzU5LTM0NTQtNDY3NC05ODJlLWYzMmMxYzUyNzhjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI3YWI4ODgtMWFm\nYi00MmMzLTgxMTUtYTZlNjdjM2Y5OTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQI94YaCaBuD6S4xNYcvvlPY8d3vJEpTVoQt6c32r+v8YLIHaI4rkSOBGKlLB\nU7YPfpl5J1/vf6y3Pz7SGB/J/aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9p6HUOd0WsiG5Nw4TTcvIa7NJIcwHwYDVR0j\nBBgwFoAUpTJ945a/DNm5cwb4+FdbufJaybYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC6zguoNDstHSSNIrWqF4K21WgifmdiIgKOPiJXCBSDBQIhAMUcPxQe2+lW\ns16HpoVipW5jDKTXq1Asbor9gnUWbmJd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUnGP3y7Ik6d4RZ6aIuLNLcNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjA4ZDc1OS0zNDU0LTQ2NzQtOTgyZS1mMzJjMWM1Mjc4Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASASW5a2VIQB0CYvQosufT37X4mBT7cFOW9kppelHFfuUM6\nnSdbYri/7KuwWz4OTFQ3zV5me14T3FKmtk6bJef9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpTJ945a/DNm5cwb4+FdbufJa\nybYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKpgDYuTobHHrgbZjUy6CRctGZiP2QTlmVv/CIQmTQdbAiEAxzXdN3QA\npYnRbHzPPMYW9IOtA7kGksuF3/XbeZt7EpM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAW+l4rXJG06VQQrwCWl0CElsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI3YWI4ODgtMWFmYi00MmMzLTgxMTUtYTZlNjdjM2Y5OTc5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjY3MjM1ZWEtYTM0NS00ZjVhLThlOGYtYmIzYTFkYmM1\nNmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsfEuqVhEv73fGbn1MTpgZ9+q\nZSxMbtUPu/154yAj7DDVGDK9D0vw8rBhq7EcCPCYKN8+mZ7U48gwycePJTd8S6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9p6HUOd0WsiG5Nw4TTcvIa7NJIcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgdNx0ofbS\nk6Vf47NTQhfZU2Eyatu/FtnMenViVHCk+WUCID/5uGFqLQeAxAtr/c789jQ6szS6\nRiKFM9GVs+GaaunV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2614", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2614` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISATuDQfoyDjTXFV0KsKcOJXsrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExNTVlYjcwLTAyZmYtNDcwMS1hZWNhLTBlMzlmNWI0ZGUxZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWEzNGVmNjMtZDYw\nZC00NzljLThjMTQtYTc4ODI5Njg5MWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnPwsoHcc4i8RJOf3qGU2ikl7U9alOFS6Cg3cX/877pRkXOmhdsZZ4ACjYnUN\n+7YYYjrN9Da4NT9nQ6wPkjggWaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE3zLQ5fCNcolRtQsfG1L22/6UZswHwYDVR0j\nBBgwFoAUpw3f1nppwnJ1PItfM0nY5kgVdQYwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDJ\nrDvsXxZuU/BSQyW6CLGCsn+0wU8mcrVdygZlItHb5gIhAJ6e9ET67+/ac2AfD5TX\n8wL1cVs2o1Y2X3mN+9uHOcIt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcKm35rOqG4pdvenu8iEN/zIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTU1ZWI3MC0wMmZmLTQ3MDEtYWVjYS0wZTM5ZjViNGRlMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3l5mFF+jzCYZhS1geSLN35KOH4yxcIU7KDSVgeH+AEejZ\naSzGGs7sJXnhHEvRUvfJGW8DkO1qT8veGerGXoqRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpw3f1nppwnJ1PItfM0nY5kgV\ndQYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCGWfXJdomu7iqTh3fwrulNxfww6j19QN2N3ShYvVyCQCICbRtrbKZaNR\ndldd6r9Zvx9rYHhMCYaHAzpuU51lrGVF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQcN+VdRBXRDMVyDxoAHZmPGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWEzNGVmNjMtZDYwZC00NzljLThjMTQtYTc4ODI5Njg5MWFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDc5ZTI0ZjEtNTY1YS00ZWYyLWJkNGMtY2YwYTY0YTli\nNTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyV61hEo3GE8tf5ip46FqU37i\n35Ino58B1EAmgAbh1M9HTain+cn+XTeRQ7RfHrHjgtk0ngz2QuC1XhW8n4QKB6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE3zLQ5fCNcolRtQsfG1L22/6UZswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgAYGauBGS\n2dJJmBEYz5uABR+m+YhPXnoWPq+zNPYNd8kCICxo8R5CSE84kkxQiVQXoUfY5JUO\nV13IFKRCCunW8Nmc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2615", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2615` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAeaA+QE2e7jEtzkAf3mHJCWqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhMDgyMjkzLTMxOTktNDI3Yy1hZGUwLTA1NmMzYmU5ZDAwZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODIxOTBhNGUtZTg0\nMi00Mjk0LTg3NjAtMGUyZjc3ZWFhMzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUQI5NnLcdQcBy9TDCB7bjEvZFQG0ItDWpyop+VXGCmzSN+taMM3HMKuQfgtJ\nlXBmeNH3a3rIdSXq66iPxgtUQaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzMP1U03xXhl48/tD0+1RnfB1oqcwHwYDVR0j\nBBgwFoAUvYnqJvS9YXkf0V9J2l2ub6+XqxEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIDUYCF1XwN0Ik2DOvFbSIlRxr5f7L8nLCBmm1kQje488AiEAwB4A\nK9cb6QtIXJFH04BRcH1LXuSxgDMQnvVbzw+V5Qw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZu+l153pftizaGm8Te1Pjz4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTA4MjI5My0zMTk5LTQyN2MtYWRlMC0wNTZjM2JlOWQwMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsouan9otMnvJazqOsn76oaRAsQtCPyMmBsiG3RlEQqw7X\nf6Tf4ZkiFT9zsrER+GP9Xh/OeGY0a3U+xmr8aXOXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvYnqJvS9YXkf0V9J2l2ub6+X\nqxEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgL21SPW2MMGmmstLv5X97oMuepCc9OwM5DFVqRrYzihICIQC7wUv2gMcN\n+FVUMn5Ed5f4Y2GYMitFKOJKCTG7eZGeWA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASRzFMVDXCtd6g+Z4C9lrTHSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODIxOTBhNGUtZTg0Mi00Mjk0LTg3NjAtMGUyZjc3ZWFhMzE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjM2NDNmNDEtMzZhMC00ZTlmLTlmNTYtMDIyODBhOTVl\nNjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOA28K86CrZ0cUWklKma0m13R\n7/nxl5YAMpo81QvnCxny0UReOTDhYGVGbxYOE0dDn1ihRH9TLegMyikQp79eGKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzMP1U03xXhl48/tD0+1RnfB1oqcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAI6OGKMR\nL5S1hYF4hijWU1yzl+4e8kfZMEdgMPhwSO32AiBBN4r0/+7CtRsnY7WH3xXpj4qa\nx06GciUWradFT4r8TA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2616", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2616` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISARqicSQh9uIEEc7BJcufxMa3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1MjhlNjI5LTU0NmEtNGYxMi05NTk2LWFmOThkZDFmZWY4NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ2NThjYWUtYzk1\nYi00NDdlLThjYmItNzNlNzdhMjFiZTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUOCP+RSqqdNG8sy5DGbgmui7Fj+X/nJeqtxZ/Jpj/KTfvJq6y1AqUccpNFQd\n9TPrDS3gODpOBf4pYzxDjp8O4qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn41dmtG4aoyu6FAG4CGIoDVGJmswHwYDVR0j\nBBgwFoAU1uzw9sNz45SYl7+SpuRChaxd2LcwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDNNpBB35uHK2VmNUEgKWSO7UptVmvD2cPPY0K4fDy3XAIgWsox\notMPZpzF1Cz/GtGf1XFZeDz+b/xSnRTReQ1RlzE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQA9JHciykFv5d8bDB2QsHplMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTI4ZTYyOS01NDZhLTRmMTItOTU5Ni1hZjk4ZGQxZmVmODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUXi0UPbBBvNoyCS90rg67A7LF6YIwqxj5jE6GHMjmvIYF\n8pdcgrYuUFxVZqkA89mLn99swnp/Ai6zatuiCcq2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1uzw9sNz45SYl7+SpuRChaxd\n2LcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOtNqogEj9FGaOsN6zsCT6DvDwNubg/g1Mk6Xo5xIoM8AiEAwCzCFOQs\nuNVhHNLd3+hQRF+06GY2xOyBzS2CLZ/v3nY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQ7052X+OHy6lBkRnXUKJxmZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ2NThjYWUtYzk1Yi00NDdlLThjYmItNzNlNzdhMjFiZTA5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODhmNWRjYmItYTE0YS00ZGE5LWI2YWMtNTcyYjQ3MzIw\nNTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVPhazNK4Ilqf4r8kSQlN/m58\nlnCFNczM5WsKkUSsLzcRrRc0uzoAp8bct9Ni0EkY8QsvTdMcdxdsb8Hr0QYiqqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn41dmtG4aoyu6FAG4CGIoDVGJmswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOOsJpvX\n7quiZgqMgnxNC0phSDuk+k7sqL+gtoUNEKq8AiEAmyj1JTemeCNfbx551FEZGODO\n/tW7vUHGCP4+7q7dsmU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2617", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2617` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAYOET7otJVUpFrkBuXgPdGG9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMTU1OGE4LTc5NWMtNGNiNi1iNzBjLThjY2Y4ODhmNWIxNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU1NWNkNWYtMzU3\nZi00ZThiLTk4MzAtOTNjZmEyZTU2M2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKPaa/AmD1m/eYJIR4+uFiE5oTkShI4SH3jSvfwArXU3KQ1EuPDK12Lvsbavb\n+JvamjGhAtwQsovRkmlkvOVaHqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNYfGaWsU4ym2V+t8QPFZ6+UhhH9MB8GA1UdIwQY\nMBaAFClF/AX81Q1SUn3Xpd29IV7vUTuhMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBegrxDGFC9r8bv0P5UCCZwEKE1PfAIDU9h\nuWFl8mcQDQIgGjsdUYcyWe50olI3MUabzmJhb4vFbclwS5jSk/cUyQw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZHnYg2YgCe9quRAu3htpevRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDE1NThhOC03OTVjLTRjYjYtYjcwYy04Y2NmODg4ZjViMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJtR/wgL6p4vO9dtK/vRSvI342Hlgy7dV2B2MA/FE+5ZwW\njCgEq0DJOyTm2RhT4V44glSJ/wtNG7T4PRrW8vPWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKUX8BfzVDVJSfdel3b0hXu9R\nO6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU4tPsVyNmRWhgqXJ256x1L3Wj0OAlltGMRe5Otv2FwcCIDYVlq8KMrsF\ntnyiV9pBtrq+aDx4wvMARmSyZEyrsLbo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWkkWYaAlUsjV0ry1CPFFrAwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU1NWNkNWYtMzU3Zi00ZThiLTk4MzAtOTNjZmEyZTU2M2UxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTg1ZTAyYTMtNGU3MC00YTRmLThmNWMtN2M5MDM4MjZm\nNTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAebZvXhHqsS8HR7PHWSBUQNb\n3rUaTteRpCCVcVOvqmAKRXVHvR5GCvgeZbU1E7+PnI/FDoYp/nLd1P/tMTP9R6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1h8ZpaxTjKbZX63xA8Vnr5SGEf0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAO+/ntCs\nFHFtOAZueQIdWkFIMW4oldG0BQBH0uslDfneAiBmDd04p9JYLkRueuf3vqH7z1r0\neoE49RQzBl41D5DO7Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2618", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2618` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAZ9kYvRyiU0F1w62OW9oG5GTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiN2ViOGNjLTY3OWUtNGU3Ny05OWM2LWJmYWQ5NDczN2ZkNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdjYTIyMWUtZmNk\nYS00ZjdmLTk3ZTYtODY5MmFmZjcxYjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwF2t35ntMs2f+Vo6hRZjhYsZ3sJqTJWFO30kR7uBgnNMek7AElsS2X0Sjbhi\nZ1kkutyKRyF7xNeNyqsgNr3SWKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBmt16HcoPscI31rrCAg3OyJpjDcwHwYDVR0j\nBBgwFoAUT71uAAHsaCgjEIsOgIF+KzpEKWwwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANzhaZFLQ8zn\nVu9QikxECDYIKISMCjhhODMf2YA3rSIDAiEA1uaZ75M87hKf3UzdghyGQ+jY9hJb\nyrxuur8W3nIv3+s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXh/hRxovs1S/VQJ84BHMEzFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjdlYjhjYy02NzllLTRlNzctOTljNi1iZmFkOTQ3MzdmZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkeyMrlf0zcRRWRdrghqf6hX31vvqh8bm7u5V+QGJhL3/F\n3MI5c1Y9jmUZ0P79uqcwqGapTiZ3bdSIsFRqi0Glo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT71uAAHsaCgjEIsOgIF+KzpE\nKWwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUA3+6MnG6HP8ewODwAUwLljexwm5LB3jVhR/mKUxSl0CIQDHT158uKLO\nbblKTN6V2glPXW9Ut54AU3N4tkT90viUhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAbfg98V8rOxHqIy2HuOGMUENMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdjYTIyMWUtZmNkYS00ZjdmLTk3ZTYtODY5MmFmZjcxYjVlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODFjZGFhOWItY2ZlZi00NTZiLWIzYjEtZGVlOTBjN2Uy\nNDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETZQOrFTGm9vs7Phf1rVSSmct\n014zdZh8iLMmUhKhdo3ptly0cHKnmDUV3P6GEpvl2OZdcQgo9T0oOnFFwF0VRaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBmt16HcoPscI31rrCAg3OyJpjDcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgGEY0O39M\n8aG2A9hbWMSngGFzraMk55C/OY/73ZPqF+0CICmvXlO7+g4PsLIqg2ez9JtS5LWC\nLbtZaYquMkup3X/6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2619", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2619` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVM8yAdsrluiahOvQQqCLTxkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5NGJmNWViLTdkMmEtNDg0ZS1iZTA0LWIzZDc1MjU2YjIxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZkNjlkZDktZGFj\nOS00YjhkLThjODYtZGIwMGJjM2Y1ODI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnM5XViLvzcVwTQ43At1j4zH335bzUm/YQblccU36huiHkLqI/NNnpJ7iJarE\n8PpU5h0wERcOMJLm2M1kmZYZYKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUA5j0PVnSuadLbHnzrYoaDUv8qgwHwYDVR0j\nBBgwFoAUUfkCqeoEnyLMFh8GhGG/Cyw0TPowKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMY86PUSAqQw\ndSoDFWhgrO0ItPwQ5YuH4F4f8NxafT1PAiA/TUxK2QS/XhcIjbN5g3aL5lWy2JVY\n65T6xs1BIhkM0g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATmPzcw83omx8L3faZQJ1RE/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTRiZjVlYi03ZDJhLTQ4NGUtYmUwNC1iM2Q3NTI1NmIyMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV6g+wvYTALT9MCUN2hhjiJzYjMYRmWJuHOBXsAhQ4F5nn\nQTZZ9k5p4Gb4adhiLQustn5OryuPaUXwZ8DMJVvUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUfkCqeoEnyLMFh8GhGG/Cyw0\nTPowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGU6+WVUGSY2D2AKUkIGCbNpPlCD4nDdu71OBdfAXkS0CIHf0NLltsgDd\njBB+WhFVcdkrwyOsNKBw0Alf41zuX7So\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAWyt9oXpc4jJNTe0ii649bfhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZkNjlkZDktZGFjOS00YjhkLThjODYtZGIwMGJjM2Y1ODI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmEwNGFmNzctNmY0OS00MTEyLWIzMWQtOGM1NzI3NjA2\nM2Q0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgpGpYcK1eJzuQsE54MmyFCtv\nvcWF233j7h7Go/rgikOsSzdOhbCzA5tkZC4lphCM8j5Gh+WYULyYiWjHAIwi8qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUA5j0PVnSuadLbHnzrYoaDUv8qgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMENK8C1\nt6b+J2Y2GV6nzadtfO9jXMv2w7s8o2ZytVZbAiEAiHClWPawHAwQGq2+3eBUR0JU\nLS1FEZXrlnCpweUccZA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2620", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2620` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAW9srLmUDtTjf/G63P9Wmg/aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkMzhkYWIxLTA1NDUtNDRhMy04YTdmLTgzYTM5ZjY2MDE5ODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWYxZmNiODEtOTRj\nZS00OGMzLTg0OTEtMzBjMjEwZmU5NmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2QVtXt1ooLo318wgcOn1Lo3semjGUnSL1AR3I4OpFkshJJmMErWyXbt0JsRo\nnufpZu++0q66zEakfWl3ewN/YKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCEwjAkfCwsDQger+pS8aCL1CqPswHwYDVR0j\nBBgwFoAUxcMXfuHKyT+b/IVt1Cn7Z6GQBrgwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHrHOimZC+Yq\nxsXfJpKIJwwrfGmnrD10P9eaxlJzJRgXAiBSYVHbJk2lfMQSCAO2h3gA3M4JiP20\nEbNzm5Q8CcK5ZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf+FDildQq8zz7eG8XL8uIyHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDM4ZGFiMS0wNTQ1LTQ0YTMtOGE3Zi04M2EzOWY2NjAxOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQO8kSoCnaijnA68m0fBCjhTk3ZCBfw9SA538DSVA9ohK24\nvAZ7mGFIGHW2Nl65939bvvgL3zxKZHdY97oea+yLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxcMXfuHKyT+b/IVt1Cn7Z6GQ\nBrgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJsefCF/OSzXnCF8DU0sp458c2KdJsPuP8+Gv24GmICZAiEAnlSoPqqm\nT2yHJR9pBzby1YqVDVCzQ1U9hovBd7QcDkA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdk4mqZIbGbTIYO4bjGzi0woMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWYxZmNiODEtOTRjZS00OGMzLTg0OTEtMzBjMjEwZmU5NmI1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTI5NjU5NzEtMDY1ZS00NDQ1LThmZGEtMDNiZjVlZjBm\nYmM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERyNvxcf8N8Ar/JdhCw78OO8/\nXwgusWSzEc6XX7GoWV/GheddmqOX7RhdWAYlqabu8tkPP5Oo1Y58Z1BC9HN2q6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCEwjAkfCwsDQger+pS8aCL1CqPswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgI2FZyCFb\nkEJ+OMhPAPUrucNx+9POQJRWrle4zkl0ROECIQDgbj3OmbfskCcrBtUvfe1XGJwW\no0ne764rdPewnkFy0w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2621", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2621` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfX1H5p0oZcc0q84TwIPY8adMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5ODAxYmZiLWNiMjYtNGU1Mi04ZTNhLWNhMDAwZmU0YmNhNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ2Zjk4MzYtMTE4\nMC00MDk1LTk5YTUtN2QwNmVhMTg0ZmI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/4JiZvZc0ltXutTN9qIecdREQGK0qosf3s4JA8f3i9fxP9oreRJwhhD10+l9\nc/SCLLOxrnLA2TmeXpDh86D/jaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXNlxj3kKshgjOP6T0XB3uKpfSXgwHwYDVR0j\nBBgwFoAUk0GlexanSaK0USjnu1XB5MyQo4owNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAgDDMW2wUMBawAmhX3n3JJNBGPWn8coxq4U+TzBjgRdAiARjnUtDphDt4B9\nf57cOH/a/O+P1dV16wdMcHm+oEp/bg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfFT1Bu9nS2EmqPR69ePUcvLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTgwMWJmYi1jYjI2LTRlNTItOGUzYS1jYTAwMGZlNGJjYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgr/Mr+p/1qAEYZaL7VcjQ4CniNilhIGiu0gOlNSAXvrDu\nk/3T2Y9zY2kCar60WQL/6q85uu9DaxnHEmNeL3guo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk0GlexanSaK0USjnu1XB5MyQ\no4owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHhgUGSEdTZIhtlUH0t+/a03LN7nYwAV/sBV5l0CSzQ0CIQCK50rQIKVA\nYVdMIo8CVzK1JBAMVcR5WMeoG/UKoA0KDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAaLG7ojP5pTlECNlgWWyFx9nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ2Zjk4MzYtMTE4MC00MDk1LTk5YTUtN2QwNmVhMTg0ZmI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmM1OGM2NTYtOTliMy00MTZmLWJlYmQtNTk0NWFkMmU2\nODRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE29pSd40JC2F7ufewhjPJI+T3\n6Tt7jPAIbzkYEeXsbqfxg/VDWPpf216uBhgW0iXoGMIXMRfBVsXN2uk0hRyjn6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXNlxj3kKshgjOP6T0XB3uKpfSXgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhALpvWUus\n/eMWPOA0/IBs0fgrYwCzQRqlJE0j7CrjYUWtAiEAz4j8FGFh523FNgYnxy8kkA9o\nhsPMq3CZ6zaDcSC6A94=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2622", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2622` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXK/FlwPIc8Vf7WzTE9C9ALOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxYWM1MzBmLWE0NGEtNGE5Mi1hYzU0LWFjYTJhOTcyMjQzZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y4ZWQ5MjItZTFm\nNC00MWY1LWFmNzQtNGFmNDM4ZjE1MDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Tq7OrRbRT/AX3zZdTCcNCrTU0KKiUaiUb5T5qcTHhMXFqlZV3BqPUAI1noc\nfLlKUCHahm3/t146kEwICbQYUaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlhlFULc417YmXhq8P7IV9Y3FACowHwYDVR0j\nBBgwFoAUgY9YZUJPo6rkS/5D/WzmQHdvR1kwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCxbugRHaevcUYMtPSLLUz4oHI7Te7ZlDGIqMXYnTVfHQIhAJHUPKoaD21Z\nQRB99miTedE7bI5Gh1gbqVzJTFRSJOJn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdQa+fplAD+wOUvDF83mpAgCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWFjNTMwZi1hNDRhLTRhOTItYWM1NC1hY2EyYTk3MjI0M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/ncEw08lToe4l4fYUnEipd4vV4sD/ExxiJWYK+Nku5wEM\nv/EQ7oYYRnXjOXl0U5e4ER+Oa3CW2zYj/q4NBzpro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgY9YZUJPo6rkS/5D/WzmQHdv\nR1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIQiQpfucFiPdN6CYoOOqIJAvMGoHIwKQMv0pVEyHhMFAiEAm5LH3nhF\nYMSZn3xeLVR8DfNGpBzZQUoC6ENeuum3jW0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAa1KGUBHGA00DduC8nM4KnKsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y4ZWQ5MjItZTFmNC00MWY1LWFmNzQtNGFmNDM4ZjE1MDU2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmM1MzFmNjEtNDBkYi00NGQ0LWI3NzUtYzRlMTc5ZmYw\nZjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtEhu/tSO9LtKk+Mt0+fCbBJe\n85Rbo9RVShMuJ5n8aqd/3cDf5TLQfL7B3cRgD6cNjbWMxielXMnd4sQa81YAFqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlhlFULc417YmXhq8P7IV9Y3FACowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgYyzp29YB\nW2atWa2DxIU/jqUdQk/ipQ4mHvs8hAi/v0kCIB0a3lh/GGnF7XDtHSRZfeCggtDL\nUvzxOgQ3laa+sWtg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2623", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2623` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAdTiB8R2mNHlYFNX2DDfOhVhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyYmIzYTU0LTYzNTAtNDI5OC04OGIyLTM5YmFlNWQ1NmRlNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJlN2VjYjctNTAy\nMS00NTQzLWEwYTctNjBmNmVkMDVjZDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEvfJRB7aygTJN0Hn9K/S8VtnmLObamuJO5I6FcnSIKpsEij+41HVJZNwbCOw\nUB9zqQ6/8sn/r2KXLEHNmflaiqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUl/FlyQKy93vcmCbnL0Po16OrXUwHwYDVR0j\nBBgwFoAUQLZR00cP17K7dn390Pi+/rLreegwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIH5/\nkN+r/xwGeUfRjhKGMIoc3nHLd9CFxkc+dMeMz1C4AiEAzSBMkJU4pCQ0bWlVYTXU\nk4ktxNFCWX20Zye7+bWXj8Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWWQzf9FuDkCZsTWFH8xcTs1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmJiM2E1NC02MzUwLTQyOTgtODhiMi0zOWJhZTVkNTZkZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu9/41pNhVFxEU+q1514zd5HEDcvCyjyew6IQ5NlmRiEk2\nUw3/tZ1wukoffrYu9LoQozRtms7j3RFKOxPJ5j59o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQLZR00cP17K7dn390Pi+/rLr\neegwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ+0u106iU6iJu+PdIu+JZRLfmdlxHCP5qN7v2kO/LTjAiByNgx+UQxx\n9mFioFIUd4rx7rTkZ3vTHKocxCmnMFr0Ng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYXXiehDJYcDDVSMXwG8LTa5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJlN2VjYjctNTAyMS00NTQzLWEwYTctNjBmNmVkMDVjZDBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmJhZWM5Y2EtY2JmOS00N2ZiLTllOTgtZDJiYTc5ZDM2\nNzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIjFrRwJaaeFacD2h2RX1gCrh\nfFjyy1MVLUitVQwUMlKr9OOTw12gd8jf8SWs/mQC9pzCIwj9FX7HaoTbSblhg6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUl/FlyQKy93vcmCbnL0Po16OrXUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgCEBU3Dv6\nK5ufyO2Twm1HFDMH+M8pNSncdV+HHxN/YbYCIQCH2TJcacZxP0nZR5Y/4j2SClzD\nFRWZ6Ck5SjhOs+cVYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2624", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2624` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcD4+QnPRfLYSoOa5qUd7yjWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlODRjYTBhLWUwMzctNGQ3Ny04ZjMwLWJmNDBhOGYwMWNlMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY0NGY3ZjEtNGI0\nYS00MWJiLWE1MjItNWJhMzgyNzE2M2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMSs2iX/rIG6xdjz4yDkJC3iZcH4gdEeQLCiajnPmoMLshHX2DKwzUytipPk6\n6Huc3G/M9fkDlvX1VSDZzhUOzaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnnT+vyraJuERobLa469WvIMZ2KMwHwYDVR0j\nBBgwFoAU40L9tqEbAG1icHHsmq8SqkWn3xgwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFIGHXn72s/EGDext/r2Fxcy9hKfe/19BCKIhefdaOlSAiEAqpaX\nIpTWjmVCG4sYD76J76DbQymOsWb+hmUK2m1pl+g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcMYE/DdFo1X0bAEEbS2UEtyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTg0Y2EwYS1lMDM3LTRkNzctOGYzMC1iZjQwYThmMDFjZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5/ENW7FMj5T5gk9hc5YgqAFWw39WRatVtBDrF9VnjG2hn\nbD4Zvns1GXNDUs8vxjecTBnrYRYFAVaKI/ogkbfOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU40L9tqEbAG1icHHsmq8SqkWn\n3xgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIPZxb6RdBm4Hrht7Np5wnkEswXuthdOSN2HZUbWuRmJAiEAwu+c95OO\n9jG98wzR5ctvOrRR3BxOg6KO6pTaY4uF3Ps=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAaRRkg/ATaS3BEW15ESaTYfgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY0NGY3ZjEtNGI0YS00MWJiLWE1MjItNWJhMzgyNzE2M2RhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjdiYTlkNGMtYzM3NS00MDgyLTgxYjctZTEzYjRlNTM1\nYmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm3Lv9ZU+XTzqcBpp8yql0qmU\nqHBbTHDTal3n/28jSqlR+reZK6In4oNVxuCkGC+BKrIWY3SKEYiFu5TpfE0AkKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnnT+vyraJuERobLa469WvIMZ2KMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgLlD0Kk2s\ni+TkSfyi7TW3QqGI3wbuAhqz/9vIAVoybw0CIAIZf8pCX64TXg3tKnSuH7qizvwP\n6vVeOgc4PE8uVDgz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2625", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2625` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAUX3tnI/rfxQqBkgN+ld9oZ7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNGQwN2IwLWM4YzYtNGEwZC04MGY2LTNkNzg2N2E2OTgwZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRhMDE5OGEtOTE1\nYS00NTE0LWJhNTEtMDJiZGVjMWE4OTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvYeXAqHEta6xKRXgvX7OJ5BSeNc5gfBvC03m9RFljRdvBY+5klq6wKqKwEh2\ndQsV3Kwwho47wTnChM+FWlecG6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/FbOMJZKu3S40bOvqOf3zefaEwgwHwYDVR0j\nBBgwFoAULDUWiskIF4nchbX1zLIRsCMoloEwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIF80B+UPTF3C8bJI/CZHSKTTwklI/V7mKzS0F0gY9ndrAiEAozdh\noKF26uTgOYnGC8CilKND3KJYxaF8sRYP85iwsmE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQTCzfpZ/H/tnFastv77yTx5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzRkMDdiMC1jOGM2LTRhMGQtODBmNi0zZDc4NjdhNjk4MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnnf0NXFcSQZKpSJ/nmR3Aim2uhoSFPQ9YTHKGBdKLTCM+\nceZoxKHVGoPZ5j00wyrOmnDPq4lth4bZvJ/zWtwpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULDUWiskIF4nchbX1zLIRsCMo\nloEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM20NP4NPMNc4rSF6aZv7SaqwB0MhEXndovhux3FPRRdAiBCSdzSm9Db\nDxNfF3l8E1HApRq5vBZ78AD+CnhzMXn61A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXGyviUxkcgqTfjPWI0U7QVpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRhMDE5OGEtOTE1YS00NTE0LWJhNTEtMDJiZGVjMWE4OTU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2RiNTBkYTItNDM1Ny00ZThkLThjZDAtYjEwOTYyMzFl\nYjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1OiK8jKXI3hwZmt8ROiWngUX\nIRHkKriUT11zhQK3Du0h0+Kg+Mw3Qrm8OThkI6/jNYvm+vswMc1vul5dr3bII6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/FbOMJZKu3S40bOvqOf3zefaEwgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgRJw/LyFc\nkg/RCZWzCjqp9idW4RLjyuNTbuKkuGexTvQCIQCOKspe3Ec7/U62lZ6RtequV/Cb\nJZTBpRFx1g43BiJPGQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2626", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2626` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAX24BrGxBzb4te6ChDo2DLZiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1YTRhZTIxLTQ1N2EtNDUyYy05NWM3LWQzMDU1OTY5NWJmMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRiMWRiYmYtOThk\nNy00MjI5LTk4YzAtZTQzNTQ4NGU2MmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER3HuAyyNDcqZZzQrVDHpmVko1flQLaDdi9LiVWQhR0zvXrKE1DotDlaNpXS8\n70FjiiX4L21Z9FFnRoXhJt1MeKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRU7h3cqsQykCyKd6qlQ0TRTe3SVDAfBgNVHSME\nGDAWgBQoxP64yMI8k0iSswhDsJkhjhD8LzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC+c+KPDU+c05DZFf657hFTO8hDnFMv\n4Gb1U4FGeDEy8gIhAJJImykE+GCbISpIUTmbPU6XBKmOl3Be6mBig+HzVU6x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbsyHuZc8N9EUboO3CujGl4gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWE0YWUyMS00NTdhLTQ1MmMtOTVjNy1kMzA1NTk2OTViZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROEQaTeGpQRk1SOdQ2CnuiaEAoQAKxthiyB6GOFpebJz6m\navK6qUh8TNh8oLYHgZJ0rSTSRUoy5XFr9Mr4AtB0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKMT+uMjCPJNIkrMIQ7CZIY4Q\n/C8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPX/bYRajuN7FuFTcLzC0zaJ+DHtc5tlgeFlpWdbs2PsCIQCl+idtXwWU\nxu4jIWT35W7xGOoH938O0WxxAo5Gw2rS/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASIzNLa3qWP9uhcVHoKRbCdqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRiMWRiYmYtOThkNy00MjI5LTk4YzAtZTQzNTQ4NGU2MmNhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzk2OWNhZjAtZDcxOC00ZGEzLWFjMzQtYWVhMDA2OWQ2\nNzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyhhil90jISk9Oi+EABbv0jYo\nuCaTQwU74d35f0iNPRxpa8VdAYnsew4iF8/GdX7Dz8newTajjETqqojY30mZAqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVO4d3KrEMpAsineqpUNE0U3t0lQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAK3/y7rD\nuXgQHWPmKxGSZDvqHty2hqfqyjyQ5dgayQJQAiAB3Cm+rk2MiAtm97djJpFt0jpz\nmFFKrIMSNz05cdJqZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2627", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2627` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYHZJq4AYJ/YVaBFWTgH5HBAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNzY0NTU4LTVlMTMtNDI0MC1hOWYwLTI0NTU3NmUwZDNlODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y2YmVhMDktNjlh\nNC00YzViLThmYjYtMjgzMmViNjkyMWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx0TWLE727f/mdpQVvR1itaINobaWudpCYacBgmhCb0CDad19mHzDY3hY1W2U\nIADktPu8k6bI7K2fMTw54sah6aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0hDhcP0ykdmpjh+wygp4xZ03h8gwHwYDVR0j\nBBgwFoAUvoplvqj+/sLuoUDo2ch6N+cLy+0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBJgxUbDnUju\n6zI93hYvX+cZMPt6vG9Fw8Es8ql5LPQwAiEA3R1dtT6Kpj/7CAiSv3doeLeFoPYB\naCpV39BW1nxObz8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAabmauq3Pt5hn4AdP8ep7kEuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDc2NDU1OC01ZTEzLTQyNDAtYTlmMC0yNDU1NzZlMGQzZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuDtatMtCGwr9GAC4bXQMWQ0d06+HiNG8vTEyYaJQiI7P7\nfFcJq5YU3yZnEYZF9agZA8Eg+9/w4LkRlOpsOhUmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvoplvqj+/sLuoUDo2ch6N+cL\ny+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJFYJwsFELXdf6f68LFjvBzrGWFFuCTjdIpVXvzTQFO4AiEApd+2cctB\nTPlXzcj6AwkMgS942KeGfXqRPtq4Oh5Z75g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZAmrByjGwUgNC57VWFaGmhQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y2YmVhMDktNjlhNC00YzViLThmYjYtMjgzMmViNjkyMWQ1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTJhNTRhNzUtYjAyMS00ZGVmLWIzMDMtMDdiNzcyYjdm\nZjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcqcyWNyPo77hETNygcIZ7Ked\nbOKRZE/3DgIpTmyypAGkMBO//fMq6JY0V5qc76uCwvj0DMa8gf6LlxhM3pcg3qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0hDhcP0ykdmpjh+wygp4xZ03h8gwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAI+feD9g\n2G0NCpfnCqtttkCRni9MEMhDLdyo8gEsBUjEAiArG2CGBlEGRjD612wqMG83j/dE\ncEO0ZniSXAeR5n/8Gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2628", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2628` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZokT6z2PEqXn+/89QU9uCl1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExZjk0MGY5LWMzNzEtNDk3NS1hOTUzLTM5Y2FhZWZiNGRjZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYxYmNkNmQtM2Uw\nMy00ZWU0LThmZDUtYjdkZDMyNDExMzNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyFvsuLQeOWYiiA6dCnPqXW8ZM5ja5j9dOhngg51EmeJWEcUlzfOWnhwOPoCY\nLI3JPE/5oI5I6IppoOmQ8C8isaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb4R0JPHbGayGE3bHncfIwDzVY2gwHwYDVR0j\nBBgwFoAUlnn6tucXrCMFdZH2lSY+dvhzfU0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCID/mNUGRPQ5b\ne1JqeXMtX+pimAUdQz8msxMelXzbZ2AMAiEAurse7IimY+WDspdppsY11ni/1P6H\nZ0Czd84yLzZ1ZAk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbeCcTA46LFhVi+uRKj9UqVeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMWY5NDBmOS1jMzcxLTQ5NzUtYTk1My0zOWNhYWVmYjRkY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMc/yHT37Ypy12JTIjzaJCyEOWd4aH08mVoruMo7DchSDN\n7E/QT4KJRyPXRTO/U9jroA5zKA0g6G2IMRdoND92o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlnn6tucXrCMFdZH2lSY+dvhz\nfU0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDSF+Aqe5Xzw/cXmYNes++5+K6Ng6XtrzoOafMicccI4CIEI7XkipdU7X\n9oFaUdRC66tTPJZNeRj4KMSD6GJ1kx0K\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQnjmX4zPC51BBgRc/pC0LoGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYxYmNkNmQtM2UwMy00ZWU0LThmZDUtYjdkZDMyNDExMzNmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTc2YTRkNGQtMGEwZC00OTJiLWE3MzctMzIyMmRmNWRl\nMWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5fwnaUq09OT6o7EQffq1frvC\nBPHs+yIXIYXcPHgwq3Hbp4jlV0MJy9+Xcfd5ATfXUjUqzyL/cCefQMfhGUi546N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUb4R0JPHbGayGE3bHncfIwDzVY2gwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgUOuf3/94\n+CSKULdc2mioBQKKTsdnrZj5Nanoabc4KFMCIDlI+YhJP5GLJOb8p9rsDH1rmrsp\nfjGTpNDa4i3etfV3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2629", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2629` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAVv7o+2FQynjJfY4YtMn20K3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NzdhNmE4LWM2YzMtNDVjNy1iMmQzLTFkOTFhMGRmYTdlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI4MDdmZGEtODlk\nNC00NGQxLTk1YWQtNjllOWNlOTJhYTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/zFQ4/nTdPhMUwg0bfP29OF3qUmoBArdykMf8t7y3ukFazQ8eps9a1LEWJGT\n9+42zeMBe19jOpcwR261xhgWsqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Y0Dj60aQBiyx/Ja/3ZKpSmM2DkwHwYDVR0j\nBBgwFoAUlzyVCMHH9g6PqXLzx+O6ViyED1AwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAhvHpw3Ix\nY3EU18rdc0uRLw33WKhzE18yTKU1JG6lvG4CIEpiOvVyeN2SVgLkR173HOQfGj5o\nNcF/TrknVnCeOuvA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb/xaVy5fo+7OnIizgbzrNm9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDc3YTZhOC1jNmMzLTQ1YzctYjJkMy0xZDkxYTBkZmE3ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFzgfxHWtF4jAxxsOesMfByTKXa2o9U+eeTFATPvYt69ij\nDB50cKYuy0vb+WedXK9x9lQaNcMB62hhIVezCd7xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlzyVCMHH9g6PqXLzx+O6ViyE\nD1AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfn8gngztlSPdTi9B2sY16VUhYyGB+xI4D9XgX5eZXRgCIQDYXY/0rrEm\nhIDyC1Ybx9NwseWNlLcUrrGzWMKamj1c+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZdmMMT3+wJMtsjGCNLbL5ifMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI4MDdmZGEtODlkNC00NGQxLTk1YWQtNjllOWNlOTJhYTEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2I4NWY3YjAtYjhkZS00Njg3LWEzZjYtYjVjMGFhYWRm\nNmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOfVg6actADW6HXThDnsl7jdj\nMzjYtsnuVAS8LnYSz/IL5k7w/wzUIrBQFlpmrCIDchUwfzPZIKzSnEMpxz3aSqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/Y0Dj60aQBiyx/Ja/3ZKpSmM2DkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJeoqV7V\nTlSt9rLWe6gq048U6yte6ouoLqmqQzXdYkxMAiEA/cg3K9bM4v1tAec7hqzz22OJ\nIwPuqU+Bg1ieKJ84EZU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2630", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2630` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfTvv/M6q8r94OY14IbpFXkwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlZDRmNmNlLWMzYmUtNDFhZS1iMzg1LWZiMDRiNTg0YTU5ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjcyYWVmMDMtOGM2\nMi00YTMwLTk4YmUtYTFmNzVhN2RiMjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/ycjLBPeR6tx0CRWsQ8enpvSCoo806dehNdnH67GCmXMq5DNxxdJXGvAK4FA\nbEW6APg8QRz3isFXovmX6ba3XqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOI1E2pNo2MieftWmDYFHzIWKuwwwHwYDVR0j\nBBgwFoAUkqDNLh6G/FXl1RzQsxjXHmmBiDUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiBAMLdG82KTMMdmqN+zqUhzMI4LgBP92bmt8dYtUvfB7wIhAO5ZJnuIfXDK\naeQIJjX0YmEWqXF6CcwWUa3z63iVWrUJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbR7i/iPvNQlqXsnXz1VINRFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWQ0ZjZjZS1jM2JlLTQxYWUtYjM4NS1mYjA0YjU4NGE1OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxyjH3dctTUn2H90wM2wGGv61XGmtix/aMxyjo3AzMwbbN\ntar2PGAE0rnva5vZbH8QBq/bkEKCL0y7kbsm1j0fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkqDNLh6G/FXl1RzQsxjXHmmB\niDUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOL8qTuPN15CQu+aQufLjIn0+6AyumM7XG9MsQz/RHUCAiEA6dmsdp/N\nk3tHdhcS5d0aJDFTsImWSL5cZWqMO4W+X1c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdHhgrs3i/KF3iZ4gcOHpz3KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjcyYWVmMDMtOGM2Mi00YTMwLTk4YmUtYTFmNzVhN2RiMjZhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTI5NGY2OTctNWQ2Zi00M2ZmLTllYTAtM2M3ZWQ2ZWY0\nNmM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMwLn7/Ckgd4BB9CsaxoBCE1/\nMkQ0INqX5ZLUqqiqzRPbyNeSau4AtveKRVrRfkY82MiQh97XC70hrRsaDv23zKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOI1E2pNo2MieftWmDYFHzIWKuwwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKh3/bC9\nkadgQs3Sty98eiYDLz/6nyWXss++4AWbnYo1AiB5qWTsQvvYiz13ve6qbqxvCxqf\n4jqt+1rAlr+Npizf0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2631", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2631` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfHQ6Z6ZrMHC0M10zCu7fdddMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzYzZlOGExLTFkNDQtNGY1OC1iNzQ0LWFiYmRjMWM0MWNkYTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjkxNjcxYWEtNGQ3\nNC00ZThiLWEyMjMtOWEwMTllNzY5ZjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6KfXqCGIY3xFaqNsD8mzx6FGOntpjKGZ5/UIC0uyQ96CxVZ9QyXKj7sUUBaM\nt3B9crSPsEh7Gty5DezDH3SYnKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy8pczBmqK/Ai04Ew2NE9aqPynm8wHwYDVR0j\nBBgwFoAUCcupIPn6eCWfdXZjwgEDide97/cwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBd5RALO72gEw/tIfILvT+6MDL5MHAz0nTf1aLAQ8xDrAIhAIB/33mQUa5P\nTEMpiapFrzfDAL+UJPTdvMMZ7HyZKmPD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVmM/EQmiKy9qLRBwGnfW1B7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2M2ZThhMS0xZDQ0LTRmNTgtYjc0NC1hYmJkYzFjNDFjZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2i8k4L2kRHcyomMkC5Tnqq0Ja/AzbLXCw/TWpjU0JDkmh\nMMeDO9+hpLbHn9+o1lJ5dyM7RxBS3XeJqRIdzVK+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCcupIPn6eCWfdXZjwgEDide9\n7/cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWBPkvruJ10fwh4/6KT/GqMemhKkISHBvwkox+R/BUa0CIQCuTZ1ee95S\nNUCM/pKuJhy3icAZ0qAivp1k8oix5ckI0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAWNTDG56ZZ0eLM1P+jNEwn2vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjkxNjcxYWEtNGQ3NC00ZThiLWEyMjMtOWEwMTllNzY5ZjM1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzZjZGFhY2YtMTY3Mi00NTc5LWE3NGItNzRmMmYyMzdl\nY2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQvhynwWq7V2QQjraBzHlA1/H\nk7Rw2NizXQbSbsOyQSgXWdybDUNgdnFbfRaZTF3iCTsZO5OiTtMFijA1VcHPA6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy8pczBmqK/Ai04Ew2NE9aqPynm8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhALf2ay2H\nxWMICw4EiZemt7m7kiIqSc9tNt23CvOqcDooAiEA/Co/Af+rV7dJV1oMraa9Pscw\n9NKmHZ5kq6LnVDXQYdI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2632", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2632` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAUbPv55CVqTt+j1VQigMpbcOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0MjdmMDk4LTI2MWItNGE1MC05Zjk2LTM5Y2E2NzAxZDU5NDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNlZTEyMWUtYTAw\nZS00ZTE0LTg0ZWYtMWFhMGY4YTM4YzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBi10gpOQdeOf5G/VKpVCynz7HMKrDTzyuqSyQcbhAMqlwZV3/fSqgDkpbTrM\nS6m9fo9BsOt1E/md8EoJoiYgV6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Pomfa7cfB6IMTERvUull0jUf1wwHwYDVR0j\nBBgwFoAUNtSoakGWymDbSzB9DlIz8h/BrAswMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n5DHOtUlZ9SfK3BfZDY21mU2HrmV7vsp8g3t/BSfAfUICIQCL7W15bSHiB764s7Qs\nXLMp8vmlA1s5oYvuZxZmLuekgw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaryOnpL4XX7G0dttifxfxH8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDI3ZjA5OC0yNjFiLTRhNTAtOWY5Ni0zOWNhNjcwMWQ1OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqjE2y2sUjbUEzX3VdDtbqG9ZIZ3Us5O4jcEP/UxSUSSts\naF+xDiR36NONp2JXvBL0bpIc/7J0lMxW1ooeZNvso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNtSoakGWymDbSzB9DlIz8h/B\nrAswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHU1abhwWTq4P5CVL54ZRTbhbskDAC7mKtlA/moYu7L0CIBjmQZedc/nK\nrq+a6U3uAf8u9G42WRI1VSO16FR5z0hR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAa87yU3k7WbOgHfwjkHzqdGvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNlZTEyMWUtYTAwZS00ZTE0LTg0ZWYtMWFhMGY4YTM4YzAwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGMxNjQyZjYtMzczNS00YzY4LWJkNGQtZTczOGI2M2Uw\nYmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyG4EtZSWG9wdI/rilzZu8e9F\nYXOuB1K+iFfj1r5AyWABv3lwV1d0Z0GdJhZD5b1Y/lZ/vvByHTCSmEMQdaG6W6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0Pomfa7cfB6IMTERvUull0jUf1wwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJMflIlc\nQuIQ1sIIGWMxjJwNxaUMW2SlJ5L8+ak9UuI8AiAFl8ZkEyN9nATLdpM7XJjpVN8f\nZeLljtW9Ix8B/CJBpw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2633", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2633` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZSUlRIEJaN126E8+oTStpb0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxZmIwZTQzLTdmYjEtNDQwYS04NTdmLWQ2ZDZhN2UyM2JjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBjNWZmNTktZmJk\nNi00ZGFiLWJiMzYtM2NlMWRlOTVhMTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIyw1ybU1fxosGxtCoCZSpc3f2emsMt1Hpqzi379ybAZU62tXCGh0ItZKoTuz\nlMtJE4iq9bTqOsB0JLDeOz4O+KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3X+Zd6HXIc7u3DmbX4MXht1aqsYwHwYDVR0j\nBBgwFoAUeiur68Iai9q/jsGKaI5nNQGXNQQwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAsKMYLaXSas9pNuHhIcEP5JoTbDmgBteVGNh1l5AS3mICIHc6\nA/MQ4A7p6MXdusTIiCoKAC3FoxSqMtbMJN52k5g7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASxPldy+7TsfggC+9B9YLv7PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWZiMGU0My03ZmIxLTQ0MGEtODU3Zi1kNmQ2YTdlMjNiYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIQfPPgTymXxRaBngkTGdDBNm3juaYG7DThvt9nGEvzTnj\n/0JkYOYxP9/mrjVo8f/TCNZ26wAv6k23a+XOUH4Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeiur68Iai9q/jsGKaI5nNQGX\nNQQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKC+9C5dZzrg66xt648H0g8Ixn4E5QA7sJQSTszilZw8CIQDXY6giLUnB\noJTyM1X8mAUtQtryS4QWBa73gQ3qenCm2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVMRkHEqKBFNpm3hWTBzhOBkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBjNWZmNTktZmJkNi00ZGFiLWJiMzYtM2NlMWRlOTVhMTQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmVmODc5YjYtNTljNy00Mzg1LTgyYjQtZjZiOWY1YzA1\nNGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyAfHcCD4uGa89faFypncHJJr\nalLtU1G3lEefizNfr967N2IzDd9dt/lOtHGWij3KbAxunEtadGZkKnSXzAjcW6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3X+Zd6HXIc7u3DmbX4MXht1aqsYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAOCUNeKQ\nkn7eIoJg3gM0vnhZweti5hgnf7Bqch1HSrtBAiA7GWB+FkbqBpCAl+y+hUPiSIU8\npQ12I4PWvHwM5A4JFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2634", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2634` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAXfcEuuPqi1X+sIgLHmVCJKaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzYWIxZjE3LTBlYjAtNGMyZS05NzM4LTZhN2U2NDdjMTFjMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhhM2FhYmItNmIw\nMC00MjVlLTkyNjAtYzZhZTI1OTNmMWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn85kRT7BQTUqiWRx82ZO2NtDGDeKoYjXSXBGZnsutJJCmY6v1aRJq0BN9ql2\nEYeTk2q5GbHLBDr/Sh7k19mjTqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDdybpsvCcsapgkBJjYrGitbwNZwwHwYDVR0j\nBBgwFoAUnZQ4IkNj78Aq2fTpWU7Ls2JA8mgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAsq6ZObY+Y297DH/nrWmCPKo29jJAjIAlXiJvJls97vYCIBGf\nQsJcpUJyDQixNfy3jb19a7IyDPiAl5eIxGwfgJLJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYNN788kG8rXMZdvFiScUbkuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2FiMWYxNy0wZWIwLTRjMmUtOTczOC02YTdlNjQ3YzExYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfMdtMR3y1H43YGP+mO3I+MepOXD9mvKQPESW9d5TR/JGB\n4ElnX1x449ttz5QV5D6fG60EyDmTVDZg/cynQ6OXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnZQ4IkNj78Aq2fTpWU7Ls2JA\n8mgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYrnFd6DjM28EgfmJmCbOJZMlw9PP9tpGU/oiCzsDhMwCIQCrcxTyPw/3\n62M1ZYQ4YttgLjHJi8NITAzuy12eBJL83Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUpIuUgpWFysPVryKAgzSvW2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhhM2FhYmItNmIwMC00MjVlLTkyNjAtYzZhZTI1OTNmMWFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzRiMWU5NDMtNjdiMy00NmFkLWI5YzYtY2I1YmE0OTVl\nZDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExe6vG6ZeZoz2rpcxWPtyFUDV\nYW0nq86CmhOVe0TSYQ4R1v/ifANoUXDtsZqkErr0HYIZaj04oPhGUmQQk+N8UKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDdybpsvCcsapgkBJjYrGitbwNZwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgc78Vzwo0\nQsaGBWRJ9MpmKkqMEdKgrlq9Z2bXn0Gm+oICIQD8zI8ITYBGwJ0lmwdy7D4X+7oc\nbo7vKZFVIlp+YW1b2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2635", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2635` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAUmH3lUHJn/t3MqdOkKCEL8IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ZDc0NWI2LTM1NGMtNGY2Ni04YWFiLTgxNjk3NzQ5YTBmYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFkM2FjMDctNzAw\nNy00NmE2LThjNGItMDQxYjhiNWE5MzcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4nXrbkZTCmfdCZGwccbcg4McQ6BijSfy5XvzB4tHc8M2SgLbIk3UHAaECWJV\ns0cGmuJ13Zu/JnMR/iSBPVhHNaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURX4V34bIiOiyHWPOJCYHGu6rFGEwHwYDVR0j\nBBgwFoAUxLUtIBN/2txGcf4ONLqP4cU71JkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAYkKMD2FJ63lDh\n4GvvOL6zc4Gy6lbDXToOH4KhQpDOPAIgBA9wh3TGgIZJtM6ykqSohlVlljRZOUA0\nJVE0gG11h+E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcGad+B+ha7ka0hVumbtlUFKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWQ3NDViNi0zNTRjLTRmNjYtOGFhYi04MTY5Nzc0OWEwZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxeBcFJmuIg7ViQpM19Fiiz30HzRtsAnaas9h+aY7YUT5E\n3LUy1O/YDqhtqAx4wJ/ShI08tEqyjHhuH8a9Z1/Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxLUtIBN/2txGcf4ONLqP4cU7\n1JkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIp7XH5fO+dM2ehQ5PWdRkp21RbdzAoKmZgQL1pVQAJwCID/J+Q9nDtvn\nflmjAQztHv1itp4iANO7j1wKPwQIuZ/Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAeN0Rft2qszj5iv/QoU46pALMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFkM2FjMDctNzAwNy00NmE2LThjNGItMDQxYjhiNWE5MzcyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDFmZDdiMWMtOGMyOC00YzNmLTkyMzUtOWIzMmYxODEx\nZDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQZyHmbrUp/Z5BAyBf96wrAQp\nAiTA45J9llR9yLQwzZT3S/DGryT3+3QupQqrkNc1tZtPayY6bDtnzEAhI04q16N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURX4V34bIiOiyHWPOJCYHGu6rFGEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgGXZ7kQvp\n49PcUkK2qKgjr+wFZy9N0IMhjX1ormKylZICIEE785FhOHlrt4vOSHHJBUnsPDHb\nLRbsRQml4xAkUbne\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2636", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2636` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfU7cNJrJ3VQfNLT8wabvIheMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5N2FhYjBhLTg2ZTUtNDMwNC1iYzM3LTUwNzQyOWVmZWRkYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQyNTM2NTktMGMy\nZC00NmY4LTljYmYtZjg2OTEyYjVkYmJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgpYirOJbuD8Eti28v49qIa66FeIJmYTvsqUi5M1iwZmhMtMlNwis7ngE0wAa\nKQBfNvw6HjVO8JkrevWBPLXmyqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2NyBEdTHFPXwJAzugzS0UeqoDigwHwYDVR0j\nBBgwFoAUH2l9P4UE1pvMJ4NNc8MA/EQBdRwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD/ysBQZDgNR8lo8K+qLGgM4p6k951CGt/g8wq3qw2gagIgGDfvZN97Ex/n\nqIZ96c62AV2gp1epJhAQ6TfU0si6flA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUX+lQmyXqOWNlWBaR43YC7OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTdhYWIwYS04NmU1LTQzMDQtYmMzNy01MDc0MjllZmVkZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzCT3zysq/dem/6SoNcab/0BbVWpWd6Oq4ocgD+pgEyb/o\n4KzneoAVux9Rfny3RxX4rCwR7fB1V1WIUG4sbk2go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH2l9P4UE1pvMJ4NNc8MA/EQB\ndRwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPHTKasldX/5KFd9gxfkAvZveNjBGGxG3l9tz41dKPjICIHyb0I5YgDYD\nVkH4UZNG2G7Puq+R+WNZkuj+i8xKEtHa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISATB10xw1JX44+uklQkWpLdObMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQyNTM2NTktMGMyZC00NmY4LTljYmYtZjg2OTEyYjVkYmJmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWFkOGQwM2MtMjg5ZS00Y2ZmLTgyZTgtZTZiZTY3ZjU4\nMTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2YckH8z1UIOtr43JBxmMTYEN\n82snlNZpPyiMhrw2PjQyVOC/shNv/1oBWFVCjqEqHbIYge5sQGv+j4MW46DLgaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2NyBEdTHFPXwJAzugzS0UeqoDigwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgKDZz+kPi\nltZ/ph19+34B9njM4zfYNDvAkWlkwiAxXAMCIBih5zt2uhbCa8w7MOClfsles2bO\nbMKhmIXmPNWOR+sI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2637", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2637` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARKxCiYSOONTTB4TiMGjQp5AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlYzQzOTgxLTgwZDUtNGMxNi1hZmE3LTk0MzQ0ZDVjYjVjMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM2ZmNhMDgtN2M4\nNS00OGE2LWE1NTQtYWQ5YTE2Nzk5Zjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdyih1uqF18VJGGVajZ7r1TBNcDqtnQBeesFxrpEGeLjW9FCLlrL4Uthhoh7d\nGM1Je5MBSiA2B1kmk2aqWBjx4aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnYr7WlquPOV14H6ub/SuQC+0crMwHwYDVR0j\nBBgwFoAUm3E9AEcrdWosm8M+dsQ1ZMTL0BkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDTlz/cU/pLE8D2lYkOYpiLpwZtas3amhpPGSzYQ64ztQIhALQNF50H6d03\nZ4PGZXpoTQDXWN3tYIpvFF2q+BpgS3i0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQvlA34lwXK7JElCHCBYI2XyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWM0Mzk4MS04MGQ1LTRjMTYtYWZhNy05NDM0NGQ1Y2I1YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiGx2E1zvHmGdalvp8mxH6DMB1HamAX+gU/aGE1icaXagS\nau9z672tk9UuqKMM7H1XAIrrUbVMhsoM23kyYzMSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm3E9AEcrdWosm8M+dsQ1ZMTL\n0BkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJPHVNSLcaCwmkd/AIjvE0J7tUFjCtDRMLpWSCR/JHtzAiBB+t9Ib5vk\nQ/YHXbe1YGOIUfAeo2++cwaZ59ygAJsX3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVyaTZom/a4yz+XOItd3HWPFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM2ZmNhMDgtN2M4NS00OGE2LWE1NTQtYWQ5YTE2Nzk5Zjg2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDliNDRkZjEtMDA1NC00NGJlLTk2YTMtMTU5ODE0MTM2\nOWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+ZsCR93+2nuZEDN+Yhx1iUuV\nMmTNBjZ0hUXfSc+K9OwtRTRY1hJCuOa2YxDyo68+99ZQa0hd2GFTRxLbLtam+6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnYr7WlquPOV14H6ub/SuQC+0crMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPa3I/WO\nvn18zLhA5VlY1Z1IyApRGOaRTqpbP6nmRb/cAiBWtJ5I6VPbdRImJdxm29avkeOh\nceuNbUUEzA2RraMojQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2638", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2638` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISARUUDqkE7ZsyJfUnZahr93rsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwYmVkNDIyLWVhYzAtNDkyMS1iYjVlLTM1MDZlMDYyMTQ5MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y0YWRkMmUtNjhk\nNi00ZTdiLTk1MDAtZGRiZDdmM2IyNWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcUvi4ysCL0mkW2DFzBWoKhURsnTmLdQIaoAf7KmkF2Pej4a55MlzY78Jpxgw\nXbOU8nByFHT42MRubzwgYFckg6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlJkr4okmQ1/iHnYtjI0eeR3HNxYwHwYDVR0j\nBBgwFoAUwlS56MZ392VQ4rXwJw8UMek1CmwwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiB1IeqeSEBOphNWCPhKX+2rgzY7TRxQeKiOc+01f4OGFgIgY8FPQk/My0x/\nwkn/0It9KlPL3/ENXXdj2Jz8MShjSkc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARwRyGTN2rnuzXQ56sQ/P4LsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGJlZDQyMi1lYWMwLTQ5MjEtYmI1ZS0zNTA2ZTA2MjE0OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9JnlKG41Jc/QlGu8bHJh/ihP7oGjI/KkpARZBzoKdrd3P\n3EzlRFnhUtpHZxqFeqmSXML6jeZkCQ7+Qym0SiMGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwlS56MZ392VQ4rXwJw8UMek1\nCmwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcFN354xVY+AljZVGCQYxqfAIVOeTKGCYdOgLTRlvraYCIQC7M0+I8slZ\npweqlz6docJesxsIusGS8KGf62X6YqrVkg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAb/UNn3SGuqGiqnsg2nwcMLHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y0YWRkMmUtNjhkNi00ZTdiLTk1MDAtZGRiZDdmM2IyNWM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzcxYzczY2EtNWEwYS00MmY0LTkzYjYtNzA0YzQ2NDBi\nZjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4/Y3gE8cD7VSR6rdf049fWUQ\nhhtD5Lvvuqkyd4+IhsBcJsDs3Cft6MT3MioNkF0A6rLdI2VadryejNYka9MQ+qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlJkr4okmQ1/iHnYtjI0eeR3HNxYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJwf2bJj\nx3GgRbEBPMTDxvobbcjyrLH2p4KBOjzpfO+2AiEA4FmKaMPN8ia4mDSRzc854XNy\nVrHdc7iSnj++dEeSkQg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2639", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2639` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZwJjdfWn4r2K1fkBXjhBZUXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkMDdjNWMxLWQ1MjMtNDQ4Ni04Nzg1LWNkNDgzNTUxMGQzODAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIyNmU3MjUtODVi\nYy00NzcwLTgxZDMtOGViNGY2MzA3MWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE51FBAj/xrHo15bR5LEXD8gTdblfa2SWpTHgJKA1UzBCITGdCns8yNbSezhoj\ni/vNhmMVUI0S4LPXRmAdUQmtYaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzF9itu1biF7BfoGhUaeylPExuKcwHwYDVR0j\nBBgwFoAUe+DKdUPl+FbKqlOjUcCaAjnCab0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAOHU7DFzIgvqhpqpH8aMdYI59qPENu+SoqgVeuGpGD\nNgIhAIRpB/rgUfrFTymVNIdfJIMQysTvu1x0uwb4h+DghvA2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcoNRw8ugTsVxhA1tVlkvAHQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDA3YzVjMS1kNTIzLTQ0ODYtODc4NS1jZDQ4MzU1MTBkMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYQkrzV4OeU6T4/Yb8eC4YMeKjWZA+kQc2CX/PKpN6JRm4\nqEtIK8X+4//a/8gP3tVFMGjzKlQ+LNeeUy3Cl+NFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe+DKdUPl+FbKqlOjUcCaAjnC\nab0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCiXKkSET8LoVw9uGPlDcs8N39tVjbSWOB4Cs8dw5/xICIQDHtSKiB2oJ\n2z+JDfrew1a71HbQnpHnxFQoXWgn+HMB7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAU0j70PY6/MyVnx1nDSF71NGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIyNmU3MjUtODViYy00NzcwLTgxZDMtOGViNGY2MzA3MWRlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzFmZjlhYjItZjMxZi00MjI2LWI2NDYtMjcyMGNjN2Ni\nYjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHSg6GbSEkTgkLqAd5PxVBWIc\nT2XWjuJBRrCELKA53qePgGkNmzoELFR6bOQ4k8nc6lL0R9l4yqJV/2m4/MPS26N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzF9itu1biF7BfoGhUaeylPExuKcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMTbppuw\noxx7Hrmo/a1J9+yXlAE5oAULX1fdqOhowiJzAiAPdGjh49ck2y2BCbqVk4BQ5Ixl\n7be8qIZCzbjX2z2dJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2640", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2640` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAbKnX7xztVPd/Zt5axxg3KVLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyZTgwYzNlLTkwMTQtNGVkNS1iYzkxLTNhZmFhOWM5ZmE0MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNjNDNmZjctNjBm\nZi00MWM1LWIyYTUtZmFkYzMxMGYzYjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx89mXR7TJiRI0KvtTFXr6gCX6zwDE/XYvOHuVP5fuPOuXTQaR+q2j2zqfmTh\nX8snP3+nYYUqUJRsHWNsXfS2uKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDrnu6gNQ4ZjfiM4j3CASuQR4GhQwHwYDVR0j\nBBgwFoAUnZnBDxGl0CgfSC009WEwlZ58Q5swQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBLx5/QEVNZ7OkAfehQ9Zc4ESpb3IY1VM22/gnl5bYd\ncAIgbib7DlYmxnmJuIz+X5lbFmZZEpmhZ7WWHH+zwVM4oj4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASC7Lsdztzji2W23ZapADrsnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmU4MGMzZS05MDE0LTRlZDUtYmM5MS0zYWZhYTljOWZhNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATX8Xm1Ls46r1caiey1Ty9Rn0WyblJ/7InQstOjqTUBD0kA\n4qKtXtxEQCA5H3N4+osSK7Zl2JODafNtIJ1tB808o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnZnBDxGl0CgfSC009WEwlZ58\nQ5swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWZEFh2T1AIHH+2YKOkuQzeUPgHPzaCCGDOaixUMTQcwCIQDp6dsjHPZN\npWqRKZrmVuSEm+xMmUvhZhZ2WyMiYYLUOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZWnDeURuHHWDqbDnY6aCkweMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNjNDNmZjctNjBmZi00MWM1LWIyYTUtZmFkYzMxMGYzYjRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGFjM2I2Y2ItZjBlYi00NTc1LWIyZTYtMzk3ZDFkMzM1\nOGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOV2RU8LaML0mhy+fF3TILwMS\nJGrdL/0yFcHSR4u0til5RGpBW76FSlPG+0H1SmgXq0/ZE8TNOUWF8oDzRNiHZqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDrnu6gNQ4ZjfiM4j3CASuQR4GhQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAP53255v\nEpH1m0sFtOf0tEWPZJlJsO1bui459C+qr/wpAiEAhkI9akJmyb/LE4gqUInlorMF\niuxT+lAqrzYFq7m+I7w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2641", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2641` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQCgskVxSxRIEOqqBtJhju2eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzM2M5MGFiLWY4MDktNDY1Yy04NzFkLWNiNjU3ZjQ5NjlhYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBlMGZiYTgtNTFk\nYi00MDhlLWIzNjktY2Q2ODgzMGUyM2RiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMoiIxzKHKTBXzXY6kaWq36TwohJHxvs6KczwU/1oNpWK5N+DGWZIwFVjbGnk\nIdoWnVz4Jpmz7Bbulsfu6RyX5KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQPtqWh8Nop4pQtV6Il70x2mEGzcwHwYDVR0j\nBBgwFoAUFSDgc2VjSN9wvSP/e+wl/wEb77MwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAldjQ2Gf07BPwa72Nrm7Wl5ZQHA0kRRg/sugZB8I4H/cCIDwy\nDTmLZjJbDm0GuhA51LajfA46yEDv148VhQaXpYkV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXh5PtrmejHRhuWtwkokuNSjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzNjOTBhYi1mODA5LTQ2NWMtODcxZC1jYjY1N2Y0OTY5YWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCMZDKmJGpclNeNO29v4S/gvKF+DQKgV44g1oVXKSHxOqM\nBd5gILyqBomNX6N73VmSVd5FzUj5KFNnUVl3zuruo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFSDgc2VjSN9wvSP/e+wl/wEb\n77MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ2ekK7R+wYB/dqKwhw0U5ethf4GvVENboXVCCLQjIjsCIFOfu+MRYOZQ\nVNFZu94rPhKxNotBGxXigW5kbK8bfzym\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAbNICrz/yPzGZMNRVtmBr5bTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBlMGZiYTgtNTFkYi00MDhlLWIzNjktY2Q2ODgzMGUyM2RiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDdiZWUwYWUtOTY2NS00NDQwLTlmZGMtYjc4NWQ4ODYy\nNGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3h7n/3q4no+mnmD8Q8KD5NcM\nsJRuxVkeGpA093c9eNIuA8MlvX8/nEBNzqz+t0FvaUIewdl3zZMvSpBCH+8KSqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQPtqWh8Nop4pQtV6Il70x2mEGzcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgMzcD0glm\nIIK8+t7kTJBmnfQPPEmcZS1QMomgKbNoBqQCIDpvuuFRMqCmRNqZtwylcun2kZ5i\nt8QQ3nFqXXNKdosw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2642", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2642` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAUll8vCdDIxSE2VJnhxvxniOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ZTc1ZWZjLWNkMWMtNDRhNy1iMTEwLTRiNjU2M2U0MTVmZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdjY2MzMjYtZGM1\nNy00MjY3LWEzNTUtNDQwNzE4NDUzMWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESzci0wXmcdRZNDkV6Nst6VJta6bNaoGk9DkQ0eeMljulxXgddJM7GoJr9ADE\nUUEcvhBQzevrCYjqabW4ex3zH6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGbS2qHMzuBqe5kQtNXrNd6VJmN0wHwYDVR0j\nBBgwFoAUnboBritqge8eQDF3Uld0J+AerX0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAx0IkiubyZmWGnyEXJ5futZxI0dxToxfx\nHuQCKBsQH6UCIBBuA3o/mzkg+dKzJ4SQ1EeP5DzxwXTi2zzJb+P9ho+6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARbrUDLvnX929q7BoztuJsC1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGU3NWVmYy1jZDFjLTQ0YTctYjExMC00YjY1NjNlNDE1ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATG/qF6wA3UBBLidW2GTh7ukHp/Av4r/qoUAzHuYL5qFrXy\nKW0/qOz5/J2j3fOCfwqZ5QBpsg/qxSMNzHiJP/pAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnboBritqge8eQDF3Uld0J+Ae\nrX0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALd5N1/mf4GnMa/aWYAvFH88PJA6KmQNbpOqZIuMla+nAiEAo2QHEgj0\n0YkTOgDkwQRGQtRqtbsuRLOIUrf2/V5Y1cE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAa1gRuTZBiwbUyRNkMeQfRy9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdjY2MzMjYtZGM1Ny00MjY3LWEzNTUtNDQwNzE4NDUzMWM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjNmMmU1YmItOWZkMi00NDlkLTk2M2MtOTI1ZjI3ZWNh\nMWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEF/CqnnbtbOmINjWkKBZ0Xgww\nUYNitCNQDe4DL+R7+GiZDaoLrQfGBcmMm2b4sJvAlrvd3bBfvbKwrd+cwXaTJaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGbS2qHMzuBqe5kQtNXrNd6VJmN0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMJ9N0iy\nlSc9ptwk4aqr28cw8ucx0zk0F5E1RZsI5kXtAiAqJxhI5MtdA+9S4BiQYzhDRT8v\nXe9cM7nMZc3aHPeURw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2643", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2643` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAa520t6v7B5e7wkthurISR+8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmMzdhNjgzLWFlZjctNGZhMy04NWQ2LTgyOTVkODg4ZGU2ZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg3NmUyMzgtM2Iw\nOC00YzZlLTk0MjMtNjUwNmM3ZDNiNjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6JakC1BMJmAu7BSx8y92DydLjj5GhdcSU2D3GT/noPiV6XsUqlH3SUHbNEsK\nFCXZRKyHGXrLpy//XBLy7JsTR6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbRUbM5pCiXJVzeJV4iFhbyzIoXMwHwYDVR0j\nBBgwFoAUW5/+yvcPtJeLEXwtZ3ehbQuPcuQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAx1/BCWm3Yml4UNTTyMVI15UIO8Uy4Wv2x\nTyqpiMpX6wIgDD2JVrH2PKyvqGWjjwK1gLjWlqYq86iPa7h9Ao5lg70=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYYoK27kLGxD5s015hAJwZwTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjM3YTY4My1hZWY3LTRmYTMtODVkNi04Mjk1ZDg4OGRlNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuYhdeXKa9VW25pEr2hwoupizDB7IeYMUl+FxANn1OahFa\nl1jnH7ArYtf1tGIyaR3G4itHRezkkCarhz9f08qVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW5/+yvcPtJeLEXwtZ3ehbQuP\ncuQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALtNKAWaDMu4YoojkgaqdgntK2ADiMstLkvVEpvS7vbEAiAFYWM5nCMU\nWbJ7e2pMTB9yP/eeLzqAH+TlHzsFll/d8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYhrNJBAGvJfTKlo3lVg4FlpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg3NmUyMzgtM2IwOC00YzZlLTk0MjMtNjUwNmM3ZDNiNjI4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2MyMDg0NWYtZDNlZC00ZGYxLWJkM2QtZTRmMTk0MmUy\nNTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8fqYi984dvN+1iZCMLomHAC1\nafHO6t3CQAHEyq2S3FEGn47THRqwVSm7pU8yZC6b27iA12RWBx+Bkh8BY4jsPqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbRUbM5pCiXJVzeJV4iFhbyzIoXMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhALFrCAex\nP9x5OPOV8A9NRoQ2VvFyOkZ9JLJ/gpP/JIvrAiBIGWvcVi11NhbE7JGuz5BXQd7Z\nFoNCtu5bJFy4t+OHQw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2644", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2644` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAe6sl9IpvSnHbuSmV1JGZkYeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExNGI4ZDIyLWUxMTItNDVlMy04MWIzLTBkMmMwYmFhNjEyYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk3ODBmNmItMTMw\nOS00NjI4LWIwNmQtNTkxYzJjMzk2OWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErbv473R6LISj9Wr1E9Tzwb/mBRHmpyX/VE7oLYTOIY+Ye/0OFJY7Hod0wkx2\n/nfoytURBK71UtUQnFoCTkRX0KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiM5DduT5epLkpiuVOwjF8ubHNM4wHwYDVR0j\nBBgwFoAUHDrVPXeQw2F2y97CSr78vqe+q4EwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAgAXxalhBxnY4\n+APIQYWaDj84lHUlEQPfh3pwudTkX7cCIQCUO23NR7FSFF1lAPBIY6RHDEOk2ucB\nC7o1QXmVHkCB7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAao4DTawLWBtyTjufKjN7XjUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTRiOGQyMi1lMTEyLTQ1ZTMtODFiMy0wZDJjMGJhYTYxMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTrZ9C90k7jAPqwBtHWfyzxokgLOy3r3Z1xbsKSNehVodl\nlkdNceFvU/rDRkhv7cr41dcPQotANkEc2T448ypPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHDrVPXeQw2F2y97CSr78vqe+\nq4EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP3R87MjvCfcNJXgfAfEtr33ShcmLdh506yh7q33OSUwCIBk+fDmbZ3qH\n/eUbq1w8F4x1m5WA73vLnvE69V9kl8tO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQL5+oDo9WZlrFPRy/va/W+VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk3ODBmNmItMTMwOS00NjI4LWIwNmQtNTkxYzJjMzk2OWU0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDMwZGViNmItZTUzOC00YTg0LWIzOWUtMDU5ZjdmMGJm\nZGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjBtPY6Lhe94Bli1epJHawGUb\nidIMKasQrH6hO8pCNJpqQzA5sNt7TP5o9X+KaQAN7ChAidG4XK5vHSNYTGseiqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiM5DduT5epLkpiuVOwjF8ubHNM4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIO0i04P\naW1rFVMx75IhszhNb9seo5GN4IFOfdsDT+MdAiEAoV3WhGYuBeDOD+CFgAM25saP\n+l0OUTJWzAawZbzjjS0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2645", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2645` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVp0FZGldViK+6mE6/DcXuErMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MGQzMzhkLWZiNzMtNDkzOC1hZThiLTgwYWU0YTc2NWU4NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ5Zjg3ZWYtMmRj\nMi00ZmM4LWE3ZTAtNjIwZjM0M2ZmNTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEIrXX4j1KvmmY4rgV1uWxSLy/AdkXoL7Yqo49Rpju9iUrWSqvhYP3Fq+7oin\nbprQDTl4+in/KZZRRCNtXHwO4qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmvi2yRpqPPEH4J/a/q9h7UaWswkwHwYDVR0j\nBBgwFoAUmIzaN/1vSO59ohYtKBIxCqunroowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCID4iKg0/e1XPS4uKrq8+zhsYHJSrO7P/kFHXHhXi0xWSAiEAyz3YiBE3Wwab\nEEtNKDiwSBtHI+Qnp2ZnWlWl7TBMCYs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATutBcwF6WgfML/Be/7C4hZGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDBkMzM4ZC1mYjczLTQ5MzgtYWU4Yi04MGFlNGE3NjVlODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJP0s8Me3sx/LSa2jXaqXGRFknpCwMV1mCwA/y5s/pLp9s\n0qb4mNSf9DRSjg4yo+ilnKUvCPhgH1MGKPHdgrSWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmIzaN/1vSO59ohYtKBIxCqun\nroowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK3ibMID5v0UKafTK94bu9Ay+AQB5oyN2/SNi+xq9f4NAiBbFA/1wpcH\nakmqxB976bQph7qR1vmGJptxeRf/1GssXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAaox7SiBmoCz1p/ToJPH8MTeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ5Zjg3ZWYtMmRjMi00ZmM4LWE3ZTAtNjIwZjM0M2ZmNTFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzAwNWVmOWMtODcwMC00ZTM1LWIyZTgtMGVlNTQ1ZWFk\nMmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKpCwPDKt4lnEsi+Dmbn85PNL\npqWH4Taw5uLgzA3yjCq+M1vCAs+ihGH5+M/Cw4ZHBmYfe3QPbA/5BDTqc0aBHKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmvi2yRpqPPEH4J/a/q9h7UaWswkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJ4QAH6M\nb939n7VUyZTlrxAlTzvD452PzylgHbnhu257AiAkbA+ZFLa99vgkQ+E/nGdLAL19\n/Kggu7koGoY9aNfmfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2646", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2646` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeGqvX+O1zqisXPvqgMSBWcMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMWY2MjA3LWNjZTgtNDhiMC1iYTZjLWU5ZjFhMDk3MmU2MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA1Y2Y3YzAtY2Ez\nMS00NDI4LTgzNWEtMWNlMWZkYjI2ZGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP7ft/TCU0faH2dFGWHpMff98GGA6XQL47XMP/7d36BWDEfQtPkGjUbQIbgii\n1b72Et6UrNxa4KqB65NXLalpdqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn/iligBniCEvO9P3+rmq/eRgmacwHwYDVR0j\nBBgwFoAUt2L0bhjHdqL93j0NO1o/wTk7qTcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCkQhVDTxRSRB9uGEDE8M5ZTAIn2YT39TjNMlwZhifwRQIgJVWqDwkNXdVY\naP7U2wGt6W55fKtd+IIvLVC/buxDzYs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVl9HDGwryF1BLnVr84l9/GFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzFmNjIwNy1jY2U4LTQ4YjAtYmE2Yy1lOWYxYTA5NzJlNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlqZOd8+i2vA9hvWlCFrRcJHmvbL+pPqWCvChxuhsSY/yy\nn0luyAKcKifGtwIOI7NwB2Nnb/NxxYw4JYtJ5l2uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt2L0bhjHdqL93j0NO1o/wTk7\nqTcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOu5YacHn3iq0GINIhQfbC9VibpPiGJLCelXtk5PcGo9AiEA6lZcxkwb\nEW0guxxexyjX5h78prDn2OuKciaovnkZFyM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbZzZnpgAPhE3O2uxfdvlJEUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA1Y2Y3YzAtY2EzMS00NDI4LTgzNWEtMWNlMWZkYjI2ZGUyMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTg0MWFiOTgtMmE5NC00MGE3LWFkZjktMGZhMDNlZWZj\nNDc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVqz5MZFqWd3KNM2OR3hBplG7\ndOU8ZPAGq0lFhdSeeT4zwFhr/3TegawxjxmSjlDiLI8nv/8Eb4jKrSw19deibKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn/iligBniCEvO9P3+rmq/eRgmacwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPskw3TT\n5uHhPgk+kKe4K1u3Mrj+7vkrrp4G5sSP9qG/AiBWgqK2dtniR3jajQEhKwbmWeC/\nP62NsY+dViJuoid/sw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2647", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2647` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAWH2XAbKbynIbQhuWsNx7LuoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZDY2NWExLWZmZDMtNGJhYy1iMGFmLTNmYjU4NTRkZTIwZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYwMmRlZGMtN2M4\nYi00NzE1LThjZWMtMGU4MDc4NTBkNWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyle5Te3wdfxWqcoDtFTNAp3+wONXaEnXyBUbn/45nCEdYgcW/jFHHUazEzLv\naBiYK2TNCNxgaZjcgLbHqrotpqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUMJYZW6rBVvU8Jgh0i1lKs1eXZQwHwYDVR0j\nBBgwFoAUWjaIkXAvAjrOqZfZMPd7oWrCzCgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAl+X6SZB7BrCYkcc4xniJd69EjRN30vB3AChy+ugZZqICIQCP5C2NM73t\ntQoSRnV51yzIS83RNwWSgIxpgrIapHtnrg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUjo6w1v4aU/oWDjDGGlq0ArMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmQ2NjVhMS1mZmQzLTRiYWMtYjBhZi0zZmI1ODU0ZGUyMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoWT3+W6osfW3mbKeLusFKEUesSSTEFOu3BPh0XpxJu7IV\nIZrr56hGP1geQ4SH1pkjgqUoaOL6qm0gRUsmsitwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWjaIkXAvAjrOqZfZMPd7oWrC\nzCgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWNwGXal7fkvxrN7YURsY9+RSggtVGMtWwrgyH7HQcnUCIQCz/89NW0Mm\nKLm+Rilom1eG2PLbXGhs9f/qjcTW1Unj+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARVVpLrWe0KOEn24wf05NeR1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYwMmRlZGMtN2M4Yi00NzE1LThjZWMtMGU4MDc4NTBkNWJhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTllMmI2NWEtMTc4ZS00YjRjLWE5NDEtMzJiZjk1Yzhl\nZTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER36OLmr88fJ9x6eSBDeUMAzq\n6Ye8Xd/PW8PsornFxElAZNz69vHCOudBSjqaDMD2Lp5A84Nu0mstE/JVLYIY3aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUMJYZW6rBVvU8Jgh0i1lKs1eXZQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPUXJAeW\nF1rqdCn39egjgLHhgyf86X3ACkRATfuanU3XAiBP8f2RFu1DBdA1mlARY6IVdQ/k\ntmrDsFv7jVqHXSH3HQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2648", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2648` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVAhTMZWgaXJAtWvrhdGlDSoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2ZDMwNTg5LTc0NjMtNGJlZi1hMTlmLTM0ODU4ZjQ3Y2NhYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTYxYzJmNGYtMThk\nMy00OWZjLTgyZmUtNjBhMWNmYWU3MGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx+dHAKHLQDoOf4leNTekLI7nSqEWxHcBjjeyYCfhxUowxwax/pk01V0JzCbY\ncYiFEN5nw5LdlMVuxZ4ZaQjo26OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/H0LlWEt5ZpljBw0q5mRU5rb0ZEwHwYDVR0j\nBBgwFoAUf9zhi4BfvIQv/I/FHuVp4eer31swQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA4GPxCRD97c6ZJbCKgCNdYK/5wkku0Mj3cAprrgYs\n0XICIEqlRCxzHSqRDO+DjLkiEJ/kjfnt/RtfpUAFojWZsPli\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAela+eGgz1SNDPtMDky9CI4DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmQzMDU4OS03NDYzLTRiZWYtYTE5Zi0zNDg1OGY0N2NjYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1cqxBusEv60l2VoRVPsu9/cN50+UKqIAXwijTo+D+cbql\noaYB5zERldZACa4PqJgRCmnGkjPjDbTpg/600qZ6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf9zhi4BfvIQv/I/FHuVp4eer\n31swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVUiP7/b4r8scYV2wB8s/e+A+ZL/3f6BlG1LKUGj0KVsCIQDhmXw+NfKj\nmHkMb4iJyydQerezdxrmvFzGuCJLpEa9Ig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAffrP8SfIG239n0hCKs8mntNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTYxYzJmNGYtMThkMy00OWZjLTgyZmUtNjBhMWNmYWU3MGFjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTI2NzI4YmEtM2MxNC00MjllLWI1NWYtNWY3YTllYWE3\nODk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAN4Scl+2dVSLZYR9W7f7hUmt\n8xRmn82aU5UrWv9K7xtPPL//1OPkB4WssnBRVdy/DwLQnozzdvoBNuiILBRyoaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/H0LlWEt5ZpljBw0q5mRU5rb0ZEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgVXsRVq36\nHNVsDPc+OnS8zAap9lP9zNTl2y9bBy8fWbECIGr66X0fA/ZN43x9ytMbXFUipvmg\n0zHfDmUBuy3KpJEQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2649", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2649` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAVoNuTZL/gOxzsucraBEtu0nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhZGViZTFmLWEzYTMtNDlkOC04MzU5LTZjZGFkYTAzMjcwZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZkMmUxM2UtYmY1\nMS00ZDcxLThhNGQtODA1MWQyYzg0ZTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOjVfmac81LpVI8/Lrnlghtmpuu7XxGpWP4QzOV0Zabav5lLl8SZ9WETLah+W\nsBituAeSlTvEpYNKfISduSTDNqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdMBvYczFZu9nHk0jZZszLIgFFQIwHwYDVR0j\nBBgwFoAU1pxhdVBf61jWw8l/Uh5RTRquNh4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAHu2JI1vXfU5VITuiJwAxlvM5wZlMAxyiYfgsdWkpR\ndgIgD2JvGSuP7CmI/7qBEMya5k7D+PhkWurQZDg+7Ks4HX4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdm3QeLj6AUmW6senC2UsEhsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWRlYmUxZi1hM2EzLTQ5ZDgtODM1OS02Y2RhZGEwMzI3MGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSV4M+QJDF8EwVbjCij7qgR+dZPx3KSeI5y3F6EAVqAhxM\nmwSNDKJTh712UxoL6AydgNHdK4JRMI746Fr4+9c3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1pxhdVBf61jWw8l/Uh5RTRqu\nNh4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIL6XBB5N9pIM9tBPLojbhQdUbOpScVHeDEMsKuOp4U6AiAJVhL5XNLC\ng7YlBC2hx7/tTUJpuHdPF5BY04Oyi9ouyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARlPrRd0KYUp/FNyuRfp1AhNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZkMmUxM2UtYmY1MS00ZDcxLThhNGQtODA1MWQyYzg0ZTlmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGQ0MTY5MWUtNzBhNi00ZGM5LTk5YzctMzFlNzNiMjYz\nNzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn3VubkmItbikDXm034cklcp3\nke6GelW9dX6BbBDFKSW9pVBI8H4FYJtyUy5T5zC65QyGNZFs1AaEyTHYHhtQkaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdMBvYczFZu9nHk0jZZszLIgFFQIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgUu6NuEFY\nooTWLGOzeNlsZ/TrgW/yE3H2UbV6QgcysioCIQD8DvvSgTaCPakbnndx6UEaaGdt\nFTB50K52MY+UJTVJVw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2650", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2650` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVARKtcVR4U32n0Cdcz7u+dhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwNzlhNWFhLTMwZGUtNGQxYS05OTFlLTA4ZDg4ZmJlMmU2YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBjYTg3Y2YtNDJm\nNS00NjJkLTlkYzItMzUwYTgxODVlNzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDlu1PNU3e78wmq0zNq+Z7KWDfMWB+RoufFL7/7ut4UtJ+mPobPrhmGHaO+8g\nptrO2Wlu78WAlrlE9K4P8W7RH6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeolOUTAJs0+oMqZYxySsWLatl/YwHwYDVR0j\nBBgwFoAUJzbDcptJLtS3f5bdGofQ3bU136YwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA0d+6c+cNYXc5egP+MMp0d38rRJqz4kwJG6gCiQt0ejYCICtu\nVzs+tk2NvbN1d8XerTgNgzwJW9eqQSabOfXCOG3+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQSAXfAXDvysCYBuYvRovRs/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMDc5YTVhYS0zMGRlLTRkMWEtOTkxZS0wOGQ4OGZiZTJlNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT36kwbwWZtSVufi/cE4254l2QeHzr4XFGPAMF0fH76FW6q\nR0RnYbTLt/dOqFZoPRQuCW64UR04FumW29R5j6U+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJzbDcptJLtS3f5bdGofQ3bU1\n36YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcfIIwRzryHvmJ5kv7H90OsJ9Kxkc35cCUq23OlyEMPMCIQDVApaQcqtx\nqCRx4aJJn+svH7NlqmLS1RqLiZumHZeQUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZMOc+6pxOl6Jbsl7eRfXZR4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBjYTg3Y2YtNDJmNS00NjJkLTlkYzItMzUwYTgxODVlNzgwMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjJhNjgwN2MtYTA1Ny00Yjg0LWFiNmUtZWZmZjU1Njlh\nMGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYz8Lnt8IGRKvLcDBK37hPtrQ\n4mQfksCHGiHK+MluoI+elGgNssVdXdeWwhF/DxICwCtO04TAX4Tq75B6mz/nrKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeolOUTAJs0+oMqZYxySsWLatl/YwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgARPdxtvN\noMmRxdTkkcgjYVW6sxi9aH6DzSrTVuciJOgCIQCmbzS7gfwRSydpszu7yrvZu3Gd\nK2gUAG4aWZBOgC5Ciw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2651", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2651` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAe8nphKpgrSdUhm6pUT5HvHdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkNzA1MTllLTlmM2MtNDZiMC04MjMxLWE3OGQ0MTAwYmNjYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY1NjAyYjItMTJi\nNy00YTdhLWI2MTgtYTg4Mjc3MzRiZDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaA5e3HGiKpDdMKjmHOpZR4TnkyHvN8vatjJ7D/kdgamU+f4DEoOA4ubdxRHM\nNSc1zpTuuQbw5+HAPGMWgt5SAKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2pDBSpI3do+AlnlkpfrzkwPlUxQwHwYDVR0j\nBBgwFoAUnYv+48k8Zrk3UW4YrsKl85UvFMowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAxDAv17Mrl9I5x8GQFkR+Ymekk99v/FxV\nOAm+m6V6rW4CIQDo8aX8aTpJVofpohvOcRncs3MYWA2qImz0VfbWpmSygA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATL5SDTfgdpbo0AKtdTiQ2tQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDcwNTE5ZS05ZjNjLTQ2YjAtODIzMS1hNzhkNDEwMGJjY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRDwzQwBIau0QKC4ZBWaqq7tNV9QPCnDBmX/i1P4+vTpTv\niQGYdMSE1jdeDg5emdqH4ndzw3ykXMndKBVONt35o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnYv+48k8Zrk3UW4YrsKl85Uv\nFMowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgacgx6EffSTzIzmUB/38nz5qjEckHgPwHMPy0WxNRNxICIQCaTI+rHXeP\ngn8tNvfnrOXpb9UOPwiPctfCnC7fhaa8Vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISATAsRYJhoyAJYpgyfB1Ixaq4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY1NjAyYjItMTJiNy00YTdhLWI2MTgtYTg4Mjc3MzRiZDI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTVkNDRhYjMtMjYxZC00Yjk2LWE3ZTYtZTYyMzBmMGY4\nZDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9Bm0E0DieT4OyIhUL0+XBztG\nltPFddnwJoxpYo54M9G6R0GljZ3pq8N6ZrICqDFXJdgn0HlUMNg1R/8hCVso2aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2pDBSpI3do+AlnlkpfrzkwPlUxQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgWiQ9Xz96\nWp6hZeiGGP1ejTQ7rq7+Jo9eLUJ7i0L2J0wCIGN9OI+/n+N7rUayrjn0WaZvY7F7\nkqxkkiRNXt26KrVx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2652", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2652` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASaEfkIXD9U0VAy+tNF8EyeoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMmI5MzQ3LTUxZmEtNDFkMS05OTk0LWE2NzU0NDk3OGRhYzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMxZTA2ZjMtYzAy\nYy00OTczLTg4ODMtMTAzZjVlY2M1YWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER8nub9cjHXFQ0EznH9Kw1n9KwuNfkI/rjGsYvJl5jUlrG0y71NgaukWqpL+B\nY6jc2Vd+Nn8K67IOb3H4uvplUKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh8x2cWmR+/VizJu/ln4HHuNLK5AwHwYDVR0j\nBBgwFoAUx/Asl1bmCmlQSphEssWfdv37BxYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBpcWmjVQz6yLHbqMi5aNDK6znCJXqsFzKb\nso5WwdTpSgIhAPtqCwRBiwQmGiTIrAhzonAKvgWZT09rUcZlJMbDFrU2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUYctBAAHTelKQBn8xM7iBjiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDJiOTM0Ny01MWZhLTQxZDEtOTk5NC1hNjc1NDQ5NzhkYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAINFEH3AEWe3m3xl4+i3AZbtcT1AKasWxonlIspMM+z8R\nJJHalWnIL0gSwLQ7Vgx1VXHI/xekK7GaO0kwUKYJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx/Asl1bmCmlQSphEssWfdv37\nBxYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHfS9vto5Hd7ofG4pC3SQs4FniKoO+w1sVW/Gn3rbxS0CIHxx5Ldbyl4p\nhAoEhlob1NUqhP2KPng1TQcMRNNnHqa2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISASmtFKf41HbvWpjSY1EuOc5zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMxZTA2ZjMtYzAyYy00OTczLTg4ODMtMTAzZjVlY2M1YWExMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmEyNDU3ZjEtMzY4Yi00NzA0LThmM2MtY2EzOGRhYzg3\nZTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE70iQeIS1j/hSOGPgF+Jui5GG\nDERflA3SoqYMrpwbFg4UTUICfIY4OIrbN/XOuLzEaaXNmFvXqkAx+kN4BQIt1aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh8x2cWmR+/VizJu/ln4HHuNLK5AwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPGSpfOm\nkxGA9t7GzbCmLizCYPPCjKt6jt+a6r2dims1AiEAz80AsnnaARvoi6DX95ta8f2j\n2j+et1eHMorNMeUBtH0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2653", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2653` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAWe/jD57JEMCOVQAq8T77yZuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NTI0ODIyLTlmMjMtNDdlNS05NmI4LTAyYTRhY2UyYjc3ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDkzMzBmM2QtYTIw\nNy00NDk4LWFmOTYtYjMwZmRjYWY2YzhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc6Dgux9eH4MYFhMzI69vu2NQO2RHtoy75hgBObTlCxnxuZex139Cis6l392P\nxz0/OZ2lPJThriYgDvTb8NM7q6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUllIDMufuHsU8gA6B1tgMLh/+kf4wHwYDVR0j\nBBgwFoAUKirOKeovn9Th2ZYl72wET4HT7l8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCwLM5TqbasjSkn0y+TcYyCRWPm\nnDnylXTita+QqXfqKgIhAOUP/FquzCobPqtQ1Z1xCqdZBBuQYTNuhhEO2PKokH4k\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdOdW1EHwhtmLRjBDSSamOULMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTUyNDgyMi05ZjIzLTQ3ZTUtOTZiOC0wMmE0YWNlMmI3N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqEw/38IydRcj2QZoXF3cQ+3T9rjVe7mk0TiN4oqX7UlRK\n+spybiISHLgpC3cLwT2kqEeKCkV6gmfzz1p439f8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKirOKeovn9Th2ZYl72wET4HT\n7l8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJrW0CtZShjiYVXFx1pcvWXmiww0uWoGATh+13ErRRr8AiBU4UOYbIrA\nUqrLcDssO9UMK+un4cTCUFpNY+Mj4qzC2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfjSvYzPbZ+DRo6YYruqXyHOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDkzMzBmM2QtYTIwNy00NDk4LWFmOTYtYjMwZmRjYWY2YzhjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzQzMWVlNWEtNTJkYi00NTk1LWIwZDktOTlkZDJkODUz\nOGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeGnM6XBhKgqZlwFKLlSDeZRX\nXwh80lbdoFv0AQhqpQZnUSQ4KNXo5dt/OAE1IVf3VkahBVE/ADaFQsC98b2utqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUllIDMufuHsU8gA6B1tgMLh/+kf4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgF3wmdU+x\nOd/K0TOSAQwqiaYtQaLjiBqsjXr7vj9dLTgCIQDn4JPdRbexDsup7eeA1VW86QBG\nI1w0PBMZphnYfhgVAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2654", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2654` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAZ7eUpKFjetWM/CyZJo1U625MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiOTQ5MDdhLWZlMzYtNDQ4MC04MWEzLWZhNjkzYjM5Mjc4YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk5YTAxYWMtYWQ3\nZi00NzY3LWIwYTgtYjZlZGRiNzI3NTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUpxT7y6woKNnnVBRZP+LkfVwZKjeZcVLBYVFm/JOdxmeQSuDg1OleL87Pbrh\n0o+27jUo7MkdGxxgrdC3b1dmJaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXawG506GEkBdIauMVDn4qcOoz2swHwYDVR0j\nBBgwFoAUIYeQ8yDmhk76QLtpFCa6zZcusr0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgUOscil9O\nb7IsZweYjndVxnAtBgMORAW/HstRmHh/if8CIQD3SErfIzY7clUBp6Wsfbk3hQyA\nU7x806PsveGwidfTEA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbSXPBBSuf3OMR9MwzKVo19rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjk0OTA3YS1mZTM2LTQ0ODAtODFhMy1mYTY5M2IzOTI3OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREhB9m9FoHKIy84nOdhntyZy8qZEFS254yfCjWPAuhQilA\nbDyMY84RwznZb3M7WMB7Ew6QAZYrxSWYvCxgxcVfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIYeQ8yDmhk76QLtpFCa6zZcu\nsr0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPLCbUeCdu9iOqCyBAwRrG/0fTRob1dBf4Ajl5L4c3EJAiEA4wPN2E4U\nE34sMLr/NBie9LaXUEa+H3ysrcGkRhYmXjc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISATZZOLuXDZzC9qJP1pEJLMckMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk5YTAxYWMtYWQ3Zi00NzY3LWIwYTgtYjZlZGRiNzI3NTBlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTMzZjAwZjktZTRjZi00ZTFkLThmNzItMWFlMWM1ODY4\nOGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIAvgbTHhrRPfVe4W6gkn7kSR\ntNLYHh9qfvFfqUEFLR6tR9rAmBBTM+5GBq9sAlhRJvcoBv7z4RVUcOpFG5cPcaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXawG506GEkBdIauMVDn4qcOoz2swHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPmvq1bf\nt6OMHhUu9VX5ZcTB613b35jqa8YZxUMSRfcbAiEAiq209qz44XgrNmgfwXpTnklf\nSR4IV2cH7uQpz90Duz8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2655", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2655` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISASioT/xpBYJ8CW/mxnVjs7JJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxMmIxOTU2LTNlODMtNDgyOC05MjFiLTRiZGQ2MDYyYTdhNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTJiZjg5YmQtOTRk\nMS00ZGRiLWE2NmUtNDA3ZWU2NzJhMTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPLjhiRkbpQB1RCqbS8B4fd0r9yNgM1icocRCJV7uyA8jhdKtM9X8PkDLbTql\nRlFyHeymEBa3NdcZBhG1ch2MEKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6O7UEGgwDKbox/5OzKCNP586+lYwHwYDVR0j\nBBgwFoAUvR/NSh46kuN6MZ+jhKIYPp4oDdgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOMuCxT/\nmnhVn1PAORzsJzI6wbxvMkyYDsxbFVF+LRtWAiAq4kdY0JRHK8FC1+IFXdGPlsO9\nAzYrgEFh5PbKMcX4Xw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUzQao9KLxpVMttVHC446coVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTJiMTk1Ni0zZTgzLTQ4MjgtOTIxYi00YmRkNjA2MmE3YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKVpLdf6rkfsxStvF7c83UBFi3pBzephApjxpITZAUJsXk\n4sDwdQI8B9J2ODFup4obN4O2FtKYFbLg+68c3JSgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvR/NSh46kuN6MZ+jhKIYPp4o\nDdgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVpGwMf3Q62Kz9rkUEHkZuKQyKSwsDLeYJOKXaQjjeHcCIQD6KQszSyg0\nvoeavJTve0mq+z9bEx5o1+RUV9jIUqlGdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVVe5Mo8B72Ll0eNXeT+kpmZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTJiZjg5YmQtOTRkMS00ZGRiLWE2NmUtNDA3ZWU2NzJhMTE4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmQ3ZWViMjctNjViNy00MjhhLWEwNmQtNDJmZThiZWYz\nZTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvDZ5NrR5poOnc0tuXulSXvX8\nBU+4XbX1cnMONGmcM/MPs/zxkbDIM+L+Cl8kdKK1mPTHk51Ex0Py53d1lbXBRKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6O7UEGgwDKbox/5OzKCNP586+lYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKRVPDww\n6uj33/HL4+UIZa2/zhMicnm7o+KMSx4D1wnUAiA6UYLfnIHMUmi58KI2qpvY7a4d\n2Tr+c7M705A8p1ER7g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2656", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2656` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAcFvvmb+M47g7moRtKM6L5p4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmMjY0Yjg1LWE4ZDktNDBmYi04NzVhLWNmMTVmNzJhN2FhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA3MjcxNDAtN2Ix\nMy00MzE5LWI4YjktNDAyZDFmZjIxZWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEChB6llSum6Szo+JpmVfL8uOyPnNF+4RBo85LKeedzRVgneF2tUH42rfjzIaC\nQfWcaBT0oSEmyv9p2zjap2a9AaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdhWYlQO73zs+UIm8AVj1wg9zpawwHwYDVR0j\nBBgwFoAUFuOp0KJzvXpkh1vytUwOcZf7w/4wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCep358\nGbVIbfU/4256tJJDq1WtQitwtBejW9X3JQbM1gIhAIGWXzofj8mPO7QEpqZW6qiP\nvZtGvZ4HOfbvhu9HVCcJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQtBFUX/O6aS/9C+TGXJ3NruMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjI2NGI4NS1hOGQ5LTQwZmItODc1YS1jZjE1ZjcyYTdhYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFW3/BBsZCY32rJE9AgbiZnqczRso3HFkq6xnjVK2IE9gK\nERpKrvdvJoJ3qodmget16ZM6k8XvAzt/mQ5bWbTfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFuOp0KJzvXpkh1vytUwOcZf7\nw/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEKXVkJ0by+7YnBIXprgOKOvjeGXB7p3T+JzspGa5kN0CIG8mnTKO0P5V\nOzlGG8wdXvn6awPq5f79+cplsR58QJHS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVCcAkgjr/WtnwHIcNfpIwq7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA3MjcxNDAtN2IxMy00MzE5LWI4YjktNDAyZDFmZjIxZWFmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNhZDRkZTktMzBiOC00MzgwLTllZDgtODQwMDA0ODJl\nNGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvaOdleH33vmIkl7WTEMsfW5/\nVF+/91vyDtUzHcNPpm4ThR/kvT24uPWTOK7rbi2eKRNn9XeR9SOiGnUih41vZKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdhWYlQO73zs+UIm8AVj1wg9zpawwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAIs+xE5u\nNBRJL8wS4jD7vwZJFOE1I3CAw/YAcKqrIWSKAiB2X54WwmQouXB7RA28ABUjsL21\n5icEGlFfgRpkYZw3ew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2657", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2657` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAYdDLNm56yxxAu/rSBRkzJN+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMzU4MGNmLWE5M2MtNGE5ZC1iOTAzLWY2NDNhMzllMzA5MzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBhZjVjZmYtYTk3\nYi00ZWViLThjMTctMzI5ZjRmNmIzMTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE65Av2n31jQ4kKLxH3RxMJVxAAilXt4eqXKMjylgq/V1y7YwvKZDUTctKZJZ+\nUnFHVzqdfmrxc7h0Pca1gMqcSKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVF1SfvFsOKZwt0hKnTPWKtRwwxswHwYDVR0j\nBBgwFoAUJnJCzt5CK1oJoeJSUY9TKubEAV0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDtBJv7p/9tcWvSq7mI7g4HEuqiczd4Rp6Ijx7giABoIwIgH7MybCfT\nrkhd1cqxMmq5lp0m+vLc4DsLvYLTmyyQH94=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdOWOnLDUpkpubXlbdYH+ileMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzM1ODBjZi1hOTNjLTRhOWQtYjkwMy1mNjQzYTM5ZTMwOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQldqxJzJPN6uyhHk9jrpUvkgXlBq55nx/y0icSt3Tq41D5\nNh1a5Tajb76nJJANf/IuiUyejd1MpLGH2f1YErWKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJnJCzt5CK1oJoeJSUY9TKubE\nAV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJsxJ1KDvlxkiQTlSTfuCT2dxwGL4kg2xgCtAcaGFVJ5AiEA65Q04+w9\nUIvFg1gSuL4RznickTqCzWvR9CzuvJpoKWY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAYEYFJOXmGBnxCjI90puhsqMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBhZjVjZmYtYTk3Yi00ZWViLThjMTctMzI5ZjRmNmIzMTNkMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGJjMDIzMmUtMDAyNC00OWNhLWFiOTgtZTNjMTc4ZTc2\nMTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsRKU9AdLpYzKGmHU/2zEhgYx\nKhHnuddd9dH7nAuVzfzaSL+oAvwK7ub43Bpda7tEg77gedvBadrbL9n3qLV10KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVF1SfvFsOKZwt0hKnTPWKtRwwxswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgSJkSQwGD\n/pbVkeA1Yg4H8QC7FIQQx6V2h9PO2ALBCq4CIHt+6RCUeRczoAm9EN/Dzst86G8e\n2Ud5/vODns5kv9eO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2658", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2658` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdi/GRGRrS49wHLqILXWrr7vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMTZiMjZjLThjNzctNDEzOS1iN2FkLWVlYjllMzE1Yjk3MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNlNDYzNTUtYjVj\nNi00ZWIzLWI5YWEtYjgzN2EzNjRjNWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErl5hNXen7z70iO/DClSHCVghW4EJrkJcjAFd5Ovk+8vv9MXk63/NOr7etxMk\nO6xpAotqY511mdiBIV0IC0ZC2KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeOcsLbXBNsDjch1q1pT2JGPH6kwHwYDVR0j\nBBgwFoAUIomNuVpmOEWXzDN+SVQM1ztlU+swOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCwOQCYXFWUKs9+T//vD4aWBIHCDwUIcjoHUNnNkaYpswIgO6eA0kBo\nI+WdOtwKBAFqSwr9k8FIgmlMwuT//JmLalE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUQZ24u+RENjuSBkuMB+1PgHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjE2YjI2Yy04Yzc3LTQxMzktYjdhZC1lZWI5ZTMxNWI5NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2Q4u5PeiDjO0XZVBNmQWZadb6qNO09oQ5pweTltvFyG85\n+GSeDbMiGy8MDiSbAcKIaeAWetDf9AyjHkpm6znKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIomNuVpmOEWXzDN+SVQM1ztl\nU+swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMoREPAipfnVL79o+BdvOOgqYmh/H5RvYD+VKzsByzjvAiBRfJOxH5wV\noKeBxi5znY69DoDYYeqIIrfV+vIDpsZsFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAeMHE9K543lvcUHoixa46ttdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNlNDYzNTUtYjVjNi00ZWIzLWI5YWEtYjgzN2EzNjRjNWI2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDJiNmEzY2MtNDk5Ny00YWRlLTk1MzEtMzg5NDU3Zjcz\nNDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeUtjmRwkOTxhq0l10qUJCKJ+\nnDPFkGXMe2pYxvgsDi+tsqkN6rD/ibtAztk6wtuve6lQZlR+Pj//n9lDdlQ+PKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPeOcsLbXBNsDjch1q1pT2JGPH6kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhANfNvJUT\n4krImXA6auZ9YCfqRIfMR99UB0HMfPcbRjFbAiBZsIrHgYjKiuNYUF/qDH3IJlUZ\n0pwLIkEeXMYQbHc3PA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2659", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2659` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAZT2qQsIQ0/i2eXQPqbLHof9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxYWFmYTAzLWJmOGYtNDhjZi1hMzEyLWNiMWY0MGE2YjcxOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY3NjNkZWYtZmMx\nYy00Yjk2LWExNDItZjliZWYxY2EyMDUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELMbt/hqOpnS5GkdLhTsTJlCygron6Y8jBDy9PXj4H7sZqkQLeCz7eV7Y7znu\n9msWpvAoCYJ9up0WLpu1BOg+z6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU86D5gBFL7DJioONIa/Dh4GhdwPgwHwYDVR0j\nBBgwFoAUNczNmr8lGIf/soc7lFDgyl0CngEwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDSQflJg9yUEiVSIjNsJTWiPJ6W4+zL3DzmkkzPQtyAUQIgVN38vIEBXEaC5POz\nQo409yXxzmv69fZYczDjzwW6BJo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZblmZWkzYrwzif+VqbMIDiHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWFhZmEwMy1iZjhmLTQ4Y2YtYTMxMi1jYjFmNDBhNmI3MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrQJ2zRFRns3bdsrkx9BnQ0+e/E2Zei9PhMxHGaW90AxcR\nMnrqDyw4dFfO9hGg2FCt1BdyusRxu5g9rMdg3B69o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNczNmr8lGIf/soc7lFDgyl0C\nngEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ3Q67g7htW25lmFT2KUtyi8I0UUwI/0f5UmAoIvVMcnAiEA5z9aI/u5\nkzQiQSn+3n6qjIWszh0DZafKa5MkJLH4BhI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAV8LgCRA3am+9YWHybjyUhSuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY3NjNkZWYtZmMxYy00Yjk2LWExNDItZjliZWYxY2EyMDUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDU2MmJlN2ItNWIzNC00ZTMzLWFjYzYtNjEzM2ExODM3\nOTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOwEAY3DD7y7LDGkzpQCeEVMF\negkatvDKZTpDyKEKlcvpxo8LGDw5XL/NU17k+/lD6DLWxkHCiKt/WZ3nfh320KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU86D5gBFL7DJioONIa/Dh4GhdwPgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgMdJusK5M\nFT5bSiOThVw9wqKHLQU3CKiD5iJFS2bemBQCICjjwPj+IG+LhOqXM7+9nej6Kwfc\n2HKUrOei9TAKQqL4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2660", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2660` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAcIwT/EvohkX0QZpuvh0MdtEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmYjYyNDM5LTM4OWYtNDg4ZS1iZGYwLTRlZDVlYjVjYjljMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkzZDZkYTYtZjA2\nYi00OWIyLTgyNWItZDA1NWEyOGE0NDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESif1bun3vo8eQF6HVA9dv5MQUdZBF3gEW58qdeixX8prCuvbEG0tgxr8fx83\n5wL7nbop/pHNVc5L1PWZAO3zEqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHSHwAhdKbpPOS5XbBqZR6QbeKcswHwYDVR0j\nBBgwFoAUaIHZUmywYljZIFnjJyHN2MMP91UwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDBJZG8TC2zgM7dDDZFWmhjVeL45WshUjFcgcGe7rCFsgIh\nAISQNEgfd2ttCYcfw8TvwdfhAGtBSjEgnWLEHyjQ+RqN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXs1AH+MCPppVrgnj3z2Oh/LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmI2MjQzOS0zODlmLTQ4OGUtYmRmMC00ZWQ1ZWI1Y2I5YzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQx5P5V+2HAlAc3FYtotxASpcIuoQWGxcxC5R3gjIjxNUP\nkHLZbItIIvhKO0J2Aa6ArA1028cFpTlXVOJODzGRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaIHZUmywYljZIFnjJyHN2MMP\n91UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMQWicD73bNMPAiKJa1KVInlPdc8XJKMwonc51GGZUN8CICtKhPJHxWs+\n8WQYAnXtDxG5qvErT4Jtn0P2OsJ/ae3i\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAU4bYePg5BBelJM4EGvMwxe/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkzZDZkYTYtZjA2Yi00OWIyLTgyNWItZDA1NWEyOGE0NDljMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTljMzgyNDEtZmQ0ZS00MmYyLTk3ZDctMjJhMWYyZTVm\nMzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8nKukJrHuDe9l2KHZ7ug8HHP\nfy+zzHwF3wJvTIOz63qpKIk4dhpRM+GnZaDgPyJDIO3DkxC0dfNWsfuK/a/HHaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHSHwAhdKbpPOS5XbBqZR6QbeKcswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgJ05atbdy\nm6fiAxB/X7LbfAX8Cc6a8yJmWyDunCe/LmgCIACUpkc/B8GaOXHkQQoyPQizaEJj\nKvutiFkFW/bCOdUF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2661", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2661` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcJ+723bn1c4ru0/JPtjeXbBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmYWQ0MmRiLTIwMDMtNDllNi1iZjQxLTRjZTg1OTMwYmIzMDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVlMTQzMjUtYTA2\nOS00M2ZkLWE0MDYtOTA0ZTYxZTBiMjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEua1xQYm34dWa9c4me7wqi52L5RY8Xo6HjgCiYf7XB5Bw43vCwfgAItZDi06T\n0cDgpULPDCgtOVDCn4aMCW07EqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA0f2wBDKN7CQm+QraSZyvV19iwgwHwYDVR0j\nBBgwFoAUmIrPpsXDk4KF9P9amwIyxpDocGYwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIATLPk6xCgXvN2MvNNWVlVnrp0iGh4FgXZ8nrZh88DOvAiEA\n6IhvzMHATAiA3FMUHyOyJmLrmO2YF0uqWRQncW3Bwj0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQaCIAGap2DQIvMq0DArDZP9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZmFkNDJkYi0yMDAzLTQ5ZTYtYmY0MS00Y2U4NTkzMGJiMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmFfJhq0Guwe5x1/Lm5SV8j6PTMdRGoKFLoI3yI0UHCNYC\nFyKEFwMTlLVd1U7y/xwGAhf3izEulv5CBnE4o/fjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmIrPpsXDk4KF9P9amwIyxpDo\ncGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANz/FR8H12oCO4PxptXGIyNb55uo65gszT4JMtyIlWSfAiEAnvEQzTgJ\nEiCkBvodT9RdJT9rDO8YdsElGuORp0zo6+k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAb9R/X0ih6Q56YJ0lwvEmdJGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVlMTQzMjUtYTA2OS00M2ZkLWE0MDYtOTA0ZTYxZTBiMjRjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjAyMDI0MGItODYyNC00Mjk0LWIxMDktZTFhN2RiNmU4\nMzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEO+GzXLJDw297vBGw+v0ZY4tw\n6AeV66mD494gJS3uZd1U8WrFkWxMa2aZQu33xQLRtKQse7Kh3p4NW1sh1zZ4X6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA0f2wBDKN7CQm+QraSZyvV19iwgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIge1veABK3\n4KL9pc3ixkMziFYP888ylfyNNYUuUnw7IZICIDxES177qZEW1J2rS8qBOdWgiTn9\nz7Ly39hujIbpSkDL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2662", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2662` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXKY5eAr3fG0+c3XIZ2Os6WbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNTNiYmZjLTYyMDgtNGQzZS1iNTBhLWU0MmZlMWMxYWNhZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODExMmM0NjYtZDgx\nNy00NzgzLThkMDgtNGJiOGI2YThiMzFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+XXPHr2ILTfXO2y0RIx2b8chZ1VLa2e8VgmAwawvk7XUkI8O5RYmnlTvbA9+\nK4j72+3RAMNgRPTJqOIaZAaqvqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwiResTW31kfzfzj6lEll4xkCP9AwHwYDVR0j\nBBgwFoAUVCxS9dF7N5c5aOtb3hkNgrj/pG4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGIZ8vMjoGUi\nvssKUvzHAgPPNCET62HfBlEymuFsHhJNAiEAga2B99+s3y2rPY6K1faCEzTO0b8K\nGIxxZgItexYyRdA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAecHbJIU7DXbZJbtf1SnFpNvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDUzYmJmYy02MjA4LTRkM2UtYjUwYS1lNDJmZTFjMWFjYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoINBN1sWo8PvAj1GcNvCgzOBfXHY2bQM2y9o6AFWmKkC1\n4dQvbZrecdW0PCDYO+bZfomhG6DwCyKO8wMlwDKFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVCxS9dF7N5c5aOtb3hkNgrj/\npG4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPPPYkGqhaEJN3bcOIzWFMYYBhtWuzcGIsuBIORcAHEjAiBuq45bU1qo\n5JDzz7dw1aWED39d/EtNZ0eMUD3Tfqk1gw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZNvHFutbYxOrWgU2oi7n+r0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODExMmM0NjYtZDgxNy00NzgzLThkMDgtNGJiOGI2YThiMzFhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Q2OTU0NTUtYmMwNC00MDFkLTk5ZDYtNzYyZTJiM2Iz\nNmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYncb659OGCilyt58KYoIyfBc\n3+LIZpsQ9J678vOWjBfgO5CXL/n7P6LiI+OAfs2T9pyj3s/3/2Oqy5tw8UlPSqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwiResTW31kfzfzj6lEll4xkCP9AwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAK4+mGZG\naIwMAjPv0lO9EbAoxRqHr5PfelMmEUpISSEiAiBfhOL0+OSri113pz6MPjsx+Iln\nk0vHRD94NOC4PFqENA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2663", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2663` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAbnOCzCQE17dyTXfeITXgb0tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZjdmYTFjLTI1YzQtNDk4OS1hYWNjLWI2NmJiZTgwMTM0NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU0Zjc4NzItMTY3\nOS00ZmU1LWJjOWYtZmU5MzVkYmYwMTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjZeLvHdLapPqFaCvafv4LHsf3eeyQLksxso+ENKqNZkuYvfPcNtURASVj1qq\nGpgIIbD4KIEE13Ee0s4fMuXEA6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6IcZme3nN7id7Ey9W//HAj8tMWEwHwYDVR0j\nBBgwFoAUgvXdCJT2SI5nRnJ/zEIPNQx6+y4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJIqP2glBhPumpHLQARpbwUyh7QElrE1h7pQ/R6iZvaEAiANwaLxom9Y\nS/PoaiNJOKyGPdLD0EdCsdjOt9v52SzaPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASgx3vRWZMkZwPwbboYXLglJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmY3ZmExYy0yNWM0LTQ5ODktYWFjYy1iNjZiYmU4MDEzNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMmdnp+GyhRVzv9ru3mMlzsXKluVbkTa+0Fvgd1J7+p9n2\ncTbOEy67SFt6s47i2GlppJDaVg9XRE0RrIpvgD8xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgvXdCJT2SI5nRnJ/zEIPNQx6\n+y4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDf1ZLcgeWY54/cXA2taV1cBkJbGaQdNVqhYtHiZBLgkCIQDikFF5EEej\nkPQiSgDAuhrtBYAHJm5f7uws4ZrLQhZUbA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWcPSP05MtAqTuTglptHJgYtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU0Zjc4NzItMTY3OS00ZmU1LWJjOWYtZmU5MzVkYmYwMTlmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzE3NTYyNTctMTRlMy00YWIxLWI1YjEtODU2OWYzOWJh\nZmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERcEzKK0XdTH6rlXw6Be471fi\ns3wIurbuWfSo7GNdoXoHM4K07tyFjZlvV2J3jQeD/v0roHaVg/Olnas8lYUPM6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6IcZme3nN7id7Ey9W//HAj8tMWEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhANe6wvPT\nqZGekmLwDTtGXr5HGgYdjiCA8VT+87rCKYCUAiBqBV8JErI7u2YBH306Pm2NysZT\n2Inmz6ihSOKj8eYMKQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2664", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2664` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAbFERFty5Aut958jDnIyzVWPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MzM0YzBjLWY0MzgtNDM5ZS1hODcyLTk2MTU4ZjIxNjY1MDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQyZWM0YjktODhm\nZC00YTlhLWE1Y2MtN2NkZmJhMjliYTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEItInj0F7c2MbEyKEHYwfL1YFLF+uhLHqMSL5U56HiEWM4uVf/o48E9JVHEc/\nHdr5ffH1VkVpCBZjKeMsvZF9kKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqY02TaEfwLIfBwjc1mobRN2m9+AwHwYDVR0j\nBBgwFoAUu44Zpf4dy7Lgq8CnZfK8ziwOxCYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAMhmysV4ov+Qc0iN2GgupaiGyhRDqx+2Z1vdN7F54AnBAiEAhOE1kZXx\nQ3qeUCH7QF5xOkoSmCfGeOKCSj0TtmaRLio=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfSIcjem5ckW6U8mWgcTCVoDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzMzNGMwYy1mNDM4LTQzOWUtYTg3Mi05NjE1OGYyMTY2NTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStbGfCaUYoDQOedkAtR8lMJSw+eGqzV/W8S4fPMb0hMgTG\nc8IPeKApwRSRYLH5nz5ntzQBFoV4WufxqEUKDSb/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu44Zpf4dy7Lgq8CnZfK8ziwO\nxCYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAInMNtAjjV9JZWZD40buanvm6hkBRVJRiJxTHKHFgh2OAiAxu8Btuivh\nOfbtOMXC71hht9uDm9PbH/2lP30B8ZQEGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAc+m59MflTcaLQvCBAUCpzK9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQyZWM0YjktODhmZC00YTlhLWE1Y2MtN2NkZmJhMjliYTU5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDc3ZDk2ZTktNGIwZC00ZDE1LWI5NmYtODZiYjU0NTk3\nYjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESDNhmcS3AschbBufBfUMEWFL\npQTivT4cWAFzaGpXqfoievjXxAVSwn6nZcfWiQdiZ1V46ihtEGt11JoTCwqh9KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqY02TaEfwLIfBwjc1mobRN2m9+AwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAItf0vUn\nDY1b75mLG1c3jZ+aI+P7hJgU9pEOI/BiTQhkAiEAr2QWrSkUwxQVU1+45nIg/lTL\nR8vLNqSuyn9hJhGAggg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2665", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2665` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAeOqaOjJmr7i3El3o8HOoqPGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzZWQ3Y2UwLTczNWYtNDYzOC04MWQyLWY4ODI0ZWU4MWIzZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFlYjE2MDUtNDgy\nYS00YmEyLWFmYjYtMjM0ZjU3YmYxMmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIDCmRWm2Ja1hVKlAzcseTEJWRlXeq3uxPeI2m49jiJRTesYhklbrmc5E7nj9\n0pHkXFuHAAzNxTzIrTCA+zw6yKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUTPkEdosLPJkQPyxAEaKRm2xWmowHwYDVR0j\nBBgwFoAUygaKKHcsb4P/FZiPsAStKK8ZvPUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCACNro7pBSx2cswEWO1PTiMrTQ3y+QLPUCmBdaTRcVVAIhAKiGMaHg\nmrUF4qBKCo361PIwtfVPr1uW0NgPJe6HvDs1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU7mRnBzMRANj4GPDq5YYtPTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2VkN2NlMC03MzVmLTQ2MzgtODFkMi1mODgyNGVlODFiM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8MacPU9fcSP9JL3HosOvblFABy5QgcP6X8vWelMlDtnz8\n2hycohDbZYD9JNAjgCCCz+EVrpQhPS0LZ2d0aZyro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUygaKKHcsb4P/FZiPsAStKK8Z\nvPUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCT4zmTBL47KwT2QvLOjtKcqim36rGpwrOV7K5pkw7RECIQCByf8/a5yI\nvQPbthUGI8ws1peHsfcQihiKBOJjOHOApw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAaoiSCxXr29Pd1qRxPIdAuywMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFlYjE2MDUtNDgyYS00YmEyLWFmYjYtMjM0ZjU3YmYxMmI0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2JmNTkwMDctYzRlNS00YmU2LWFkYmUtMzRlNTA0NTUx\nZmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK+jbqtQz3SqOe1FMqmlYJI8Q\nbt7HIlkGMkLPannh3Tcz+C+CWZ6REyL3BCOKhtl3DCLdsVnK74jKIrq2G7SCP6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUTPkEdosLPJkQPyxAEaKRm2xWmowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgK/qgAuvY\ngbgweY0CiNcBn/kkrDTjZjpSnX7zPJb4360CIC8jxoMVGmqjj8w67zdoleM6fNky\nZV9mYgmwd3hgs/HP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2666", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2666` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISATBgGuWowooOpBZ4OQr/9K4yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1M2RmOWQxLWVlN2UtNGJlYy04NjAxLTU3MmQwYTc3Nzc1NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAyZGE1ODMtMzQz\nOS00YmNmLWIwMDQtMzBhMTE2MGViMWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXBZasfrjHB1trMXz6x+Q4Pl86Jl9FQCmqELkB2bPrNdF6WC6rRmckfpYtbgP\nz/BHO+NRqrGnpeyRLnEKXQDSkKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU54SuVve5FRtIvH6FCQQCTmOjgmMwHwYDVR0j\nBBgwFoAUPQcgSGHnBTy4fX0+vrBMex9PuJwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIAX9LP3pIf1N2LcwvjbgAw+Q6auWYmZLjNZpraQg\no6KGAiEAt2PcfmAR6UvFooyECEtbljs0ah5prvyVQXY31Q79aKI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa7GDhIHIl7HnoT1kXT6A/GmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTNkZjlkMS1lZTdlLTRiZWMtODYwMS01NzJkMGE3Nzc3NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXNySfRm126JFGqO6J+vRzcKeU67QM/GT2RaRSv06DV6Fc\ng0gNoOg+CXURvrbGd7biClUKixu50niX8oaaBJLjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPQcgSGHnBTy4fX0+vrBMex9P\nuJwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEsCi2sHyfPacs0PK6a9L63XhAKmSxgDjItbcLZskc5kCIQCCu0NH31r1\nFLrcwXT3blwIn/I/qeRonXw8PEmnBzRMZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZGLOS8IUS8S483V3FxdJlTaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAyZGE1ODMtMzQzOS00YmNmLWIwMDQtMzBhMTE2MGViMWUxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2I3MzQ0ZTAtYWQwZS00OTM1LWFjMzQtNTJmM2FkNzg3\nNDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdB+ppuJHC6ctoN10y8cXPuKE\nCuxP3Uf8MRA67ib2YlJfq/xLr1FoGyvhXk+orAgI3JdW0M0kfidW/NOChMlhLKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU54SuVve5FRtIvH6FCQQCTmOjgmMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgfo7A7zbb\n1n4LZD8PGGzsNuh9ok4dDjFo1tU4qi16/2UCIQDqexX9viqu729qqfPCchq0EYmN\ngM5Alz7R/a4QUoCyPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2667", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2667` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISATRX02hwgjYJev4tec0fpATsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhNTBjYzllLTI4MDktNDRlMS1iNzY3LTI1ZGUyMWQ1NWE2YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMyZDg2OWMtMWRh\nNC00NTJiLWIxYjItNDlkZjlmZDgyN2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEusV9HbJLJ3bSaRcPwWKW6aSMKGqoRVG2IWxo2jgpvSIV8t2RwXp4iXeShUEZ\nJP39psgp+4RavarFGn+Uf5W7FKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGmMxur+4961HOA13obaxDJnwH0MwHwYDVR0j\nBBgwFoAUe/WKsNpH5stq2VPEg7+HTNHv4PEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD1dm1lmStGc5clPqT2ovMc+euofxUK0/1r/TaC\nliQubwIgJIdwYiq+g9t8YbPvum9/IW0bwxEXS07GWnA1YxSj6/k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZyeAMyCiHtZw7iyvA65xP01MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTUwY2M5ZS0yODA5LTQ0ZTEtYjc2Ny0yNWRlMjFkNTVhNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEC86xpNJjjjFDuR/GQryIXbpHtnGM60Do/Z5gF01jUpuq\niNOjrCRLIq1mogPNJOjM4bsxKoE66kcwt4tdy/Geo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe/WKsNpH5stq2VPEg7+HTNHv\n4PEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL/DKfwb1UOmp5WGuLVHNJKRN23YFsWmVTeuxXT1Smr8AiEA9oepip8X\n3LmBsHhlM219oXBTOEy3NksHC4fI4cYUbbU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAVln3BKdo5Vdjcti85tHn8FBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMyZDg2OWMtMWRhNC00NTJiLWIxYjItNDlkZjlmZDgyN2E2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDY5ZTQwMjYtYmE3OS00ZDM3LWI2MzMtN2Q3N2M2YzIy\nMDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVYOm8CWS5b4AUIIenkbHy9Ti\nM3gPRTCqi2IhVkwJ4kDXFycvkB8HJMC0FvTYEtgE2RnFAm/RVDOTNJ96c8CMD6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGmMxur+4961HOA13obaxDJnwH0MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOkUNubW\nHBUgN1R+QshVXlwtvbttLYuelO5oHloEq/lBAiEAmOXtW0IaO/HYqlGskXwpQvmY\n8kG9HqD+IIvfB/YYi60=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2668", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2668` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUQLwkWUpjKeNlC+NDUOqoVOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyZWFmNTllLWJmMDktNDA4ZC1hYTBmLTIzNzM5NDU4MzJhNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZlMmFiMTMtMDI1\nOS00ZjJmLWFlMGItZjU2YzNiY2IwMmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmqk2kKKge4A6JVvzU7+s+rjWlsATupyh6AmMAYqWFbgOCEBC0+kCpfnud/Ku\nnH80U3XdOjzYchEqHfI7c2IY/6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULf5CNLmM3VNVUqOnH47UopGrapcwHwYDVR0j\nBBgwFoAULHsDIuF3Ir06pzo+kcaaX0WZK1wwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIHWVDVX7ab3NA80/x+hSOc0C43vnEBYvDn6ldf5KVdDoAiEA\nvzF3CCwQrVZ5hhueW3V7KRF3bxHoyLo3rcC4CvJ+sXo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQsI42C01WqCpYhzhS7tvrVwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmVhZjU5ZS1iZjA5LTQwOGQtYWEwZi0yMzczOTQ1ODMyYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2F8FejaxO4WikXFi5WE/TcWxRCMIv5IpDBEZfVupBynxY\nwYkobf5O29HYWSd2W8Ka0eVy6/FTQ1xc12YNxqR1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULHsDIuF3Ir06pzo+kcaaX0WZ\nK1wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRTkWW0B+K4BqC/8tg7zv3nPNqOo9ulujVwL5uuHfAuYCIQDwTTroYDkp\n9GFndDSg8x9f29109JopVBJLQmS3Ta+OZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAd3VyRxhTa58c97lzDCa9OiRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZlMmFiMTMtMDI1OS00ZjJmLWFlMGItZjU2YzNiY2IwMmY5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTQzNmFjZjAtYTExYS00NjBlLTg2YzgtZTU4NDg3NGRi\nZTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoSHiXNpnRoHXl+i2yrhNX1UA\nrkzq00455FytEn3SSPkvsdPfRTNFcoKsBHy/cPC9fZj+cahFhX2NOVMSgdBZdaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULf5CNLmM3VNVUqOnH47UopGrapcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgHuUZUoXN\nNXGRxAVqud23DWlm/5sjGN40vaaBJixBw/8CIEluAiqd+JWXKZVEOUw/ycG4cJVH\nASifkpAnUAj4dnah\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2669", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2669` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAYrY4p4jMVCblhUPBPuON3vCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhN2MwYzYzLTc5MDItNDRhOS1iNWM2LTkxNjViYTZlZDg5NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk2YmVlZDYtZDlh\nZC00OTc4LWFjMjYtNTViNWMzMGI1Nzc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2Kkv49U9ZwMT5XVjKx/njaMlwxWr7P1aVMSXlURjAQkcmB1PKp5xhGrEoo3q\nV5o0GRGtbS9QOrwXvvaNHg9KbKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyrw8ZnIKX/ICOnoJOiE+tdM3XAUwHwYDVR0j\nBBgwFoAUvzrhWFn2W2A/udb1Oc/u8PjU0VAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCZPTJvYbov1q5onxuoBF1EbOxxkydr\nKIpz668oaRd7kQIgRf/EYTjY2n5Qrlgr8CmYr9TDR/yv+KrubPYQoTDVqPw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZxK5eJCZyLBP+E+tuTe9/NlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTdjMGM2My03OTAyLTQ0YTktYjVjNi05MTY1YmE2ZWQ4OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStt3rkRMGsLN9crPwuNUi7Qc6mi2p6ASN/TowcIUGWARU0\nlBMvLopASC/VJVuHEtrkV4YtRMm6vIMyiat/rbI0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvzrhWFn2W2A/udb1Oc/u8PjU\n0VAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZSnZWx6ftVFZSg1YzLmrYKroQRtqNOx1BiYvd5S2CfkCIQD5NE0hLWiG\nDVgsEHWEj04FIjPq6TAM4l4yyxenXpV4+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAVxb30x8Ybo9KDRWjK0eAaJ6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk2YmVlZDYtZDlhZC00OTc4LWFjMjYtNTViNWMzMGI1Nzc3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTRlYzVlZTAtZTBiZS00MzY2LWFmY2YtMDM4OWU2OTMz\nOTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+0+64idPHofTeNzCSj27+Ugv\nhXRU8bOdSerhLCBKyaALy5l7N/qjyOz2K/H+EkwcDPJ/Exi5F6Vgk7a3YH0nUKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyrw8ZnIKX/ICOnoJOiE+tdM3XAUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOVk/lou\nun/iIjHMcGkqZidujDHcLyf60fW81QuC1s6tAiEAmXrZ8TdOoRCVB8526DWykJPZ\n6zwLOFBy+7GTGSGSves=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2670", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2670` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAWEl7vVpWrDP5t7DsYMEKZIVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjNzIyYzY4LTQ4NjQtNGJlZi1hOGU1LWE0ZTU2MzA1NjU5NjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTNlMGYwNTAtNmRj\nZC00ZDIzLWE1YjQtMzY4MGZiNjI4YmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZgmAckbz03sKIJevshnqDIJWXfO0/DVyRyKhsBn30reoIEiWxlxVo9gUXEDt\nq5TbfTqeJyBIri7dlMx1LD/mwKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlqx5+S5XR7+e4Q04YFBIKQtfAS0wHwYDVR0j\nBBgwFoAUXcGWrmebkPQs1cfT015jkTbnVbUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAfBYHzzutItc0s/5zK65WchxvZqfg7n\ncsOGj21ye1aTAiA9zNYe4NrAW3a+wZNM9lxZDFVKRguTfZ8OI/gQvutcwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYJkMtkVDPWaVswKwXGyQOTpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzcyMmM2OC00ODY0LTRiZWYtYThlNS1hNGU1NjMwNTY1OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6mUI0BU/UbEtRCFNndQ5zMqLSsbqU7/t+3ndIZu/XUYBW\nlNlVDZHxkI+ryX/UY/0H6TYjqjxUbQbvXGxSXgZSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXcGWrmebkPQs1cfT015jkTbn\nVbUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOAr7WzdyZissHCFbU4JNoODntQBnzL/eU8/BQV9iGwBAiEAmyUXMl+q\nObKkj9D4iLgaiGIwjf96PUfoHztR3nlPO7E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQHoNZeJIOKPP5vORMT91f/cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTNlMGYwNTAtNmRjZC00ZDIzLWE1YjQtMzY4MGZiNjI4YmQ1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQ1M2YxMmItN2ZmZi00MWZjLWE1YmMtNDliMWE4ZDYw\nMWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5Foopj1yO0cQOVqsHNghEp9b\nmmRhi0pPh/HFAy/1roSQZt2/+fhZ0zk2myGXgBPqd01i4cf5tTVLGUUDTbLvlaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlqx5+S5XR7+e4Q04YFBIKQtfAS0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMC5jJ7r\nsLvmiH9oCJ7dLABOGdjXRg7csy+/JViXJenmAiBdyer2UjxVaCpq5E8qwAKAz6IX\ncWid1dZ9k4dEjZ7ZCA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2671", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2671` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYZr5KxXQaCrKycMRH5KcMe6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MzEwNGI3LTRlMGMtNGQzMi04NTQxLTEyNjJjMzgwZmY1YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTlmYWRjNTUtMDNl\nOC00ZmUzLWE3NzctMWJkYmNmZDgwODZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE20o3xsEy3VEBvQhSq5pdkc+TRqG5QBQ6iI2xxAN6qbJC7VDuuymUyol5WKlO\n/RFomCq3l52poVpST5KR5SjGY6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg99rlV7BAsnxl/aymIPcAAv9C94wHwYDVR0j\nBBgwFoAU212ToJHpTasQ9rE+hf2x0NBqaj0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCRGScXC5ZW\nWdCgDzpt3i5nLGTmGHy8zh5LDKhT9T2ATgIgML0QQfeLa5JxxBI1+mkQOGpBmHdi\nRxYI9E+U4igDV9o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQCJW558sHIb6RtfmpNTqdgWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTMxMDRiNy00ZTBjLTRkMzItODU0MS0xMjYyYzM4MGZmNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWOy6MopdPPNzRppWkg/xzM3CYSnGbt1NwMOyLb9S6KiLX\ntfdumX2Zo4+hD3XtjPwWKqvsUbwV4gwnu87WPjIOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU212ToJHpTasQ9rE+hf2x0NBq\naj0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYtWSIDghq+qduu/DQMl9cfk7KjVFFD03S8G2xI2OR7ICIEgrSPkdzAlL\nmkGbHEtzhW3cT/THTFXVljiidsdMLvrl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfZhPIkripuN88CQi++Yu3XyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTlmYWRjNTUtMDNlOC00ZmUzLWE3NzctMWJkYmNmZDgwODZmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDBkMTk4MWUtZGRlYS00MjkzLThlZTUtMDE3NGFjZWYw\nMjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETqfTepY1Uj6vP2srRHWGHUna\nrwEYnSbpQX1A0xSLvgjYsLgFDsOGjVdKl2NiJVtkmd4KGnox4Xe7dx96Vd1OxqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUg99rlV7BAsnxl/aymIPcAAv9C94wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgVJ0BsHyB\nfrpWCk6g7G4VGWhXNutJsqovuIkZ0Y5KYXQCIQCa8AWkIpsHWhSGVsRamv8bghbK\niJt/gFJ1dJjhlwIx0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2672", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2672` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAYn73EUGnKM8YLg3ZkuyuNDnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiODExZTNkLWRlNTctNDMwOS1hYWI2LWQwY2QxOWY1MzA0YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFiYjlmMWItMjcw\nOS00NWIyLTljODktN2M0NTI2ZjIyNDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjdS8xZhQMqSE/vCZ3ThcMqHTYL1iR1BmgUvBFwUReaTFyKR1G/xVeV1lxLa5\nFCzElVAZYWlnjy2BjWIcdCL3+qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0kNyL48iv9TzOZwdozcdp+o9jjkwHwYDVR0j\nBBgwFoAUHPJHh2SXfR9HIPY0dOrMzAsFrbowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgPk19F14kvTmCFUFZX4MhrH5ykiBIl6JbAWClQET4Z34CIDqDPXlGnwE+\nVWilmJYRnghJKrQMwTU/5f5t00Ljs5wf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV89vBbHzQn2PS8/SnP1YK7cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjgxMWUzZC1kZTU3LTQzMDktYWFiNi1kMGNkMTlmNTMwNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASw9iGIxeA4DD/a0YWlpprjKHrcN/MCpDrPbPEStQstbwwe\nwEyICWuCO4XzOrAgfy9zGO0SqKbWVUgm4TWcthEHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHPJHh2SXfR9HIPY0dOrMzAsF\nrbowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAODWiD6EpUvO2XrrQeMdI6UrPI63ilG3TSOpCZ7f/kVaAiEA1eDFGo86\nyf3kkx9jjV3dgnPBWW1jPTiQ/cmfXxQFY8k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASH1YrwfF3qzyDJ0HOuokRH5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFiYjlmMWItMjcwOS00NWIyLTljODktN2M0NTI2ZjIyNDBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTU2ZGIyNWItOGE2NS00OTkwLWI4OGYtYzgyYWRjYjRj\nOGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7O8verymAH07pomJEEVNrugm\nStR0PQuS0FGHTEJtpHEVMe2LeKbt8ConszM0F/5qrd7lqMT/BxBOtyFpBiMhaaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0kNyL48iv9TzOZwdozcdp+o9jjkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgXFN/6t4f\nSW+3W/UQfNQxpFOG15+aJFwIu/muRw9YYMQCIDD78vSe8HFr6N4caYJhfBGfTNYY\nX2R6cxKUzixNiYHd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2673", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2673` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAVfMiYqlw2kcSWNWDiNYTvOcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiODc3OTQxLTNkOWItNDk2NS1hZTllLWE4ZGEzNmRhNDMyZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNiNzA2OGYtYTgx\nZi00M2UxLTlmMzYtYjU0MzEzNjA4MTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5ZiZ129ce7BwYQO74L/+xxmUnYhWck6FiKUpLSjMbAHM43iMFWmV+4obr+NQ\nsM7EK8m2lUj4Vw9+UGW8MEV7YaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFi3qITLcxYb9//9Z8ZIV4hrilKowHwYDVR0j\nBBgwFoAUhqK3fnfy6yp4ndprPlW7hx5ha00wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgcOUo8KeMXMOHyZrMANoXnN6K9bbZ0YrRrxYn2Eh+OHoCIDKXyjdjNo5o\nDWAgPXDoenS0LO7LZz+zp9qnyZLsFWeT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASwYrR1reoWjw+SoC45DlCbpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjg3Nzk0MS0zZDliLTQ5NjUtYWU5ZS1hOGRhMzZkYTQzMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQB+vwAOTKx1leDHwYUJM5EZEu7WPx6AOKc6GSMQkXuxzpw\nrAlubwP66Gg72cIeTY2w0G1nmFlt4ol+Ph6V+Ir1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhqK3fnfy6yp4ndprPlW7hx5h\na00wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYoephVIrGhV/9NrCwEJ7p9zCRT1ya983/F4wvP1IX0ICIQCNJlaUQMJx\nVMk5gcpFXr1BZdHC018LsztDriCt4ZItZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAcq4VEmagHHvfA2ec6DidJ9/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNiNzA2OGYtYTgxZi00M2UxLTlmMzYtYjU0MzEzNjA4MTE0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzJiZjNkY2ItOWYxNi00OWFhLWEzYWYtMGJiMDM3Njkx\nYjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElETWQQmdqkcUMBa/ebPLcAl5\n75A1MO35aTc97XAqURxl8cJXuHi/8kmzqeWy1KT0f/FLRx4IMK/ZwQeR9ACosqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFi3qITLcxYb9//9Z8ZIV4hrilKowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgL+P09kr9\nwM81Tf+G7J41m4/rx3FW5S89DkyiRi5YCPcCIEjO4DeLYg3g5zXYPtb5l4qO7PEG\n2fg/9JwB1Tbm8PvR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2674", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2674` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAWJfpNxcakEhuTkrARhs/nLcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwZTU0NDBjLWUxMzEtNDFjOS1iN2E1LTdmNzM1MTYxNzJjNzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY2NTYwYTYtOTNm\nOS00N2I3LWJkMjEtMDVkOGNkZDI1NmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9NicFh0zGoED6+f2ipLYxGPxeXgH9ysqlP4O/syHbmC/IGP/CZw9rOqrnxIt\nA6V1mFLAlIU9o8kMiIHwWtQd/aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw01ieqKL5I5l9VQPzucW1EgL8tAwHwYDVR0j\nBBgwFoAUudIPQ7yFbn+OKNT+ef9bed+hzMUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIGgGsfYB4LPQkNM3YDP3BJXiUmc3kd8Jwj6v5XcE3CDoAiEA6SDnK3mj\nhXUHi/lpshh2tz/vPRG+X/5F3T9lN1TmXys=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYv/bVRCz4mUpz7BMDgm6R/fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMGU1NDQwYy1lMTMxLTQxYzktYjdhNS03ZjczNTE2MTcyYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiU9yAg9mJRvSM6nI/9/y4zoEADiZSwh0rfDaXFOFAdJBp\nsXFO9QxCZuAfa0Sk2MnwN8MAa4vxD3GiNCYfcvJpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUudIPQ7yFbn+OKNT+ef9bed+h\nzMUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOceJ3c+vHZgF/1g6aelj7Z2kN+rupkI1wZJzkQ898ORAiAKy0UkLrmd\ncI9F179aEy32+70gVk6xGQqHW/3xIN7HuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQ4FMg2uOuRoKBu8bm4cauqcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY2NTYwYTYtOTNmOS00N2I3LWJkMjEtMDVkOGNkZDI1NmQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjczMmZlZjEtZmU5MS00MDI3LThjNDUtYTQ4YWRiZjdm\nMzZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENM/zamjk6P5Us2gFbXa5QhLR\nNf95Nxq2RgWiGojb5Uatku2S9OmZTt6bJxT8ej9kUNpLtOG5DbuUq4O+odtL3qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUw01ieqKL5I5l9VQPzucW1EgL8tAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMUBSSwh\nFourcLLA/trbmdJ/YtPq87GLi2IulaseboZsAiAzJ6mOJ9eadYvFqXtfQFANatAw\np+MV0SgIlK85PV+3RA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2675", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2675` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISASp5pVWlOgZ9SEB7aYKwtTcVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YjkyNDRiLWVlNWEtNGFjMS05MTNiLTJkYWFjOTAyYTQwYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFmZmJhMjctOWVk\nYy00NTA3LWIzZmUtZTA1ZTk2MGIyZjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt4b8W3oEau/BBOKEb01N1r5Z0EvFf/a4X/KH/G3TqFyn3lutRQQNyS9ecJW+\n9rpje+vZI9gItUU7/q6nGrBtTaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXZJ/3OTlpFWcuHiFfSgZH0Vflh8wHwYDVR0j\nBBgwFoAUaxr9hZ4gSQC3sa2yPvjYqyPmEHQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIBwNFQ8c4oNhiYOF1/SQNmP0fjq8Bk6Hzn5I/Bg/\nzKZDAiEAlbcU6raG4rWIAH4iGHQ2XTbl7zBR7xhkv7jUI9LWdIY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbiHLPz300+LvrmArUy2eSXlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2I5MjQ0Yi1lZTVhLTRhYzEtOTEzYi0yZGFhYzkwMmE0MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhKIqgGFbqsyBD20x7Btony3z2k8Kxr62RRG6T2YJqDP/H\nRmuskzcqpkpgN0296Me42rRgGLXKBtVQRVJRtigLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaxr9hZ4gSQC3sa2yPvjYqyPm\nEHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRkykRMKZGKyTbwli8zRQ42sjwl9xbHDe7bxbVuM0HRcCIGBNHrie0Ui8\nrzTvGvU42RqKjDbop0JK+xBPzgi/+tdG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAb2Kt0qhBkSa3mIBsQR0rEwaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFmZmJhMjctOWVkYy00NTA3LWIzZmUtZTA1ZTk2MGIyZjg4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTViNjUyZTMtZWI4MS00ZTBhLThhMzktN2FlMmY0Y2I4\nN2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEe+abojlu4+wcQGkI2wjJdHig\ncYYfdYaZZ5386p7f8uHKJgXl6ZYSz73YErFViOIUG8pJTz3Xm7Ubvplxq7+gyaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXZJ/3OTlpFWcuHiFfSgZH0Vflh8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKbBbl1d\nG4uUySzXp5UPkt/pB5pelOx/mhqkZXSAYE3vAiB67YHQ5Kc/vTKp6eyTiIbvEonU\n4OuS862PX4k48tfQ1A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2676", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2676` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQxtAaIlzmk3THGij3BqEu9wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjZjgyNzhiLWFiNWMtNDhjMi1iYWE4LTU1MTJmYmNkODkxNTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBhYTcwNjYtYjli\nMy00MDJhLTlmYjUtMDY3Y2M0YTQ2YTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwawRs0oMrf3pTJqoISAgcr5pdOm1KjmIxRfxrI+xLuMgRAdH6dN4xaQHzhf0\n02OAqtqYTQM7IqlkQPHeqWAiJqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5qYamXsfbOWFSnk0hfhhDXYCbOgwHwYDVR0j\nBBgwFoAUuRfQIJ2InsNROyUBBeGBJmAATPgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD1toLgRYolnPPbRlyaPck1l5eCZaqxGoE11U/N\nOiapdAIgGIW50RlhzE2OBVUU2DkzdoLihnSgMD5rarWVw/5rFKs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVMp/pmNCf1bYSUqrvhyAppkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2Y4Mjc4Yi1hYjVjLTQ4YzItYmFhOC01NTEyZmJjZDg5MTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJzenga+EqZms1kxrd/nlVRv5RQbHiOyvR5walPjkuU2e5\nYkcuX8lsk847EFBPQB7tRT7axJ5BdwGmfBkPJITQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuRfQIJ2InsNROyUBBeGBJmAA\nTPgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKhxKRdNIi6qfOkBaCtGGDKgNAJo7YbxxDBTcCELXgu2AiAbYHTrOoWS\nVKYvYB3hG/lYmfq0FIrCzA5kRP1mdPYvtA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfN2GFTrvBoRT4JVfF0RfZsZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBhYTcwNjYtYjliMy00MDJhLTlmYjUtMDY3Y2M0YTQ2YTgxMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2M3MDU2NTMtNDVjYi00MzNlLWEwNTctYTZkNTc0MzNk\nNDc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2TgX8hDvT23+QB1lSCK6K5af\n8i8U9IVqyH5urK11GjPxKeK+X8zDfQzaLq4v6wb5/XjVA+Rp4DIHo3t8UE7as6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5qYamXsfbOWFSnk0hfhhDXYCbOgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgaXMyXeyj\nXojyA8JSao4xOr7z/By6AVh5u+L0GedzkWYCIQDFSXFMcvTMixoqLs0F2FtyOjt6\nPdnw5ALJYA5KhTHqXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2677", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2677` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAR953n/vMKxvXJbE7Q04WRdYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzNzI5ZGFjLTRkYzAtNDdmMC05YjAyLWJjMWFmMmM0NjFlNjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBhODQzMDgtODI3\nZC00MTE0LTg0Y2QtOGE2ZTFiNGZkOWQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEidOIAI1cm7N6a/6jf7pj3/MDmGIqYp0W4bArXsB8EAXKMYbT+JMFUVdLLs1Z\nmkPNfvu2QopJV+4Bd8d0uaJn0KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH1jj7kGSbBj9OpEIgKQ+b6+A6QAwHwYDVR0j\nBBgwFoAU6qpCtmAQ3VzWbre06LVArndIu5gwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCvNL+bBz6hZIHDwlA4X4gkG5h0BBtx2laVbN7qwIyOXwIh\nANAbh9DKwDsKUC1E76aspgCw7TByr/jfzvYVO6P5LI7G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY0QsRIL2JGv7gaBNnU+eQbZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzcyOWRhYy00ZGMwLTQ3ZjAtOWIwMi1iYzFhZjJjNDYxZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4TEz2CUf3FEplsrAn+LvE12QVngy9n5H4QvNumyCytMQz\nDifZxGYWlxC+kFffbZr7uW1JF8myK0/QKND9axkwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6qpCtmAQ3VzWbre06LVArndI\nu5gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOqJ+cV/+Bry+PcX7Q+uBMwmOG2cSO8nVJTf+j9KqbYCAiEAsZrWCuGv\n6bNNSX1zXVosptE4AakEUbYswKss3+0B/ZE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAe8T7IxT9frmSEf/QNYMXAlyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBhODQzMDgtODI3ZC00MTE0LTg0Y2QtOGE2ZTFiNGZkOWQ0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2EwZWRhMDMtZWFkZi00NmEyLWFiOGMtZjYzMzY0OGI5\nNTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaYVLgtpYHAWJomS0FQnCKRjb\n1OdggcBvsWyIv19oG58wxCEZoZAddUbNwvXyw/+iDcSE3P2Bwmk0mvlrrTqjDaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH1jj7kGSbBj9OpEIgKQ+b6+A6QAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJlvWYKl\nkMYEG7GV26ib76ciZ6BOa1bQV95/0Rvmd37IAiEAt+sxw1qoGrRfwLjCxNJKQGXp\nA7q/EkL9DNBKGhq/Vhc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2678", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2678` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAUvKjXjnuXv9Ho70y30MhYykMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4ZGVkZmQ2LTBmYjAtNGZlZi1iMmI1LTM1ZDU4NTJiMmZjYjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJhNmEzNWEtNjMz\nYS00NzViLWFlMDctNDA3MTE4YjllMDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQbhpQihlIJKRpX5QovONBpAzIFW7KxcAVLMQj+il7hthhD1FNo+7aBqH5HNz\n05vOuruMohdeybneAWY84TDcFKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtMuP9wU8Fo/bWQu4fV8q4nJ3/WgwHwYDVR0j\nBBgwFoAU/iZSQhv2b9XxvaIGmQCj790vJ14wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDZw+7gQ8kgkvp305BOq0UJy0yoRUBU\nR7NKQKwPJTXH3QIhALo4FDaKau99UZxhaZEPGzsRRpi9d3u1usaRGxsPkcsG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV9G1M/jd7BxMy7mp9RNz1mGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGRlZGZkNi0wZmIwLTRmZWYtYjJiNS0zNWQ1ODUyYjJmY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrYnjGKlfgcfgSKpI4pBCqrv9k851qvR9/fyK01BCtEwZ+\nl8K9Fix6DEWv1ZL4/UisOvC7NC6ecEorpsh/xxV+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/iZSQhv2b9XxvaIGmQCj790v\nJ14wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEePH+0/xWHE22B3wRhAYk6zPSGzCWCGnre2jetSK5qcCIGkTnWbANp6K\n5gAo+NTOs2YG8eEiMmY/NKQHtpDJDLTv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAX8QLxHgWFvKjQfIEzhI2tcxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJhNmEzNWEtNjMzYS00NzViLWFlMDctNDA3MTE4YjllMDRhMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWMwOTlmMjUtNTg0Yy00MTQxLWJmNmQtNmUzMDUyM2Ri\nY2JjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeWkoPmyDyye6lgsL5JRi9myr\nKyBzGTaNPckBsh+tupMbQ6pYzzjYJaZohepSGT3IU1fpFijhTa9aonvs6JbEg6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtMuP9wU8Fo/bWQu4fV8q4nJ3/WgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgbYtT2vZR\nJ2wkaHe9qnrFstGo6Sy2Ho0w4RzQU/KmudQCIQCzHhH4KetSMGzg8+TD3pyJl//3\nFiRHK512wRTZ+SKlbQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2679", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2679` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAWuegl6L8lZ+NPzTjprzP8W1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhYTEzZGZmLWMwNWQtNDFkYy04ZDEwLTEzYWI3MDIxOGRhZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGIzZjliN2QtYTg4\nZC00MzQxLThkODktMjEyNDQxMmNhYTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIklgnsV26oXWT+Vw83SprXcRp7CaSv7qXQwA9Gvv4JLklYV5zRucDhMKBMf7\nUkuga6Rqrz4vWFG9Ff2LWmfEIqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlDC8HDQ0tbj5UlkXfi3O+/zglCAwHwYDVR0j\nBBgwFoAUWWE/5DE4ywDW7w1zzOabKaDQfNwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDoRQA006si6xKUI4ytpgL3rZ+PyeWt\n+I/hWHrtbA4IagIhAKsDH/Km3DZ3VA0OEbUXAfR4Y5WEP6HoyXV6qOwsbwxj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXnNwWto8R9weuXYBmHcCmtSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWExM2RmZi1jMDVkLTQxZGMtOGQxMC0xM2FiNzAyMThkYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUouik3Va7ZLrreDmcsDbR4b+xh37HiW7c45imn1R/5AVn\nqHyTKMOZWfUCmnB0rItQF6qzcKUGiOIOd2cFczowo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWWE/5DE4ywDW7w1zzOabKaDQ\nfNwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJt68fe7x0KRFM+YFiJvhK/QPTJle02ZUyQPCd5XjcESAiApC/hunJQh\nMqmj9ouDfICNsjFWGI0BaOGucNeqrWCz0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZhW3xQIrlSVU6aH03LTNYZqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGIzZjliN2QtYTg4ZC00MzQxLThkODktMjEyNDQxMmNhYTRiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDE3Y2Y0NTctYTM1Zi00MzJmLWExMzktZDI3YzM2MTM0\nZTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+T0Q1hSKdXllIve3JempMHDB\nZTCFefn4Dc+8cIjnlTh39mC10XFOwE7v4CrMqO78naAgNSc9lh+OGIMbpYcEgaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlDC8HDQ0tbj5UlkXfi3O+/zglCAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAM49Ygbf\nKjIm7VvxfgurkKXQJAodKAi0mH1QtcJbuMP9AiBPLbcMscDcCNFM9Vqjejxm/9kA\nwycUK74InVZN75qd3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2680", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2680` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdED2jxVozBVmOn5lYbIjlPqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjZjQ0M2U2LThiYmQtNDkyYS04ZDNlLTNlYzA4ZjU3ZmU2OTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk3NTQ4YjktYjlm\nZi00MzU2LThmNGYtOTkxNjIzY2ZlNzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmcCdThiNwSXyJ6sI+n56MDGoKzfyVUlzFlWlXYNynhs2OfxF/YZZaNRCpfZQ\nm7BOH2i8IRBBLmJaEy0DzvCM0aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLQn8lGfXaKOtpR9lboXh43N+LVOMB8GA1UdIwQY\nMBaAFLkMY2D9opej/vA4337CIztRwZagMAoGCCqGSM49BAMCA0gAMEUCIQC69YBN\nhi+Gj8+Yl1j6G/KiH6zUFbl9IgwYUZYN9KPHCAIgEFcTz/pGRoQQXr6abBrgoS3D\n24kcVZK5HlUQIzsDULI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWqKDlgYs6MuJcc9xidQyhi4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2Y0NDNlNi04YmJkLTQ5MmEtOGQzZS0zZWMwOGY1N2ZlNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqUuZWcaagsvwSoGYvPdC73LUsy2SdR/l8wtE4ytvXuxGa\nCooR+T2/zCSWcOj7pCMW3VGtZFqFDEkEeNhaJKzdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuQxjYP2il6P+8DjffsIjO1HB\nlqAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKv96PkqRKIafZtISuWINN7+NYjNNn22MhUF/G1Hs1WoCIQCOpEMmElZy\niuGGp4dE1VNwMLHqUIvcLE17Hy6LRK08Lw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAe3WQx2t790ybMa/XqlA3wM5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk3NTQ4YjktYjlmZi00MzU2LThmNGYtOTkxNjIzY2ZlNzhmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjRkM2FkMjUtMTExNy00OTlhLWE4MTgtZWJmNzA1ODY2\nMjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE610P5UdzjTbePc1+YbBrwK5b\ntRjs7svxWi4RWzT1oitcJG3V6XY1NKu8TVTyYom2TqMKGLWWI2nzpmZHv9WEJaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtCfyUZ9doo62lH2VuheHjc34tU4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD1UfqbfJWNjkZg\nhKQkJ9nLH25RybyrtvMPM+Yl03p19QIhAJXIgw8UCTZaJVvsBqK06kRIuOKCfjH2\n7MnyI5fWUFvN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2681", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2681` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAXOmFBPLxMmEAy2w5+SBOrotMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3Yzc2MzNmLWZlZDItNDhmMS1iZDBlLTI4NTg0MDMxYmUxMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTFjYzAxZTItYTE5\nOC00NmE3LWIyZDktMzkxNDk5NGY4ZjM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVybnjeYBAK/ap+vxXJzSWlmpStlMUiGrkauZSm1KTt+n8AcmXRjQybkQET0m\nTJ41QZSoz1q3RIR/qBIgrSKOh6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDLYz/ueiXuygOhE+F6q+am/fSgmMB8GA1UdIwQY\nMBaAFO68vN6VhHlKY4D/fyLDWlCiKd0pMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA+sbgi+xScoOablleXfc8FTYXsTkv3D3F\nGv22fDiGOUcCIQDS2K6imUrm0wkrw4qbU0DsVkiqA1i/jmwWyBLvaFzPWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARNZegc9Obc9GJKKWbqPQ/s2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2M3NjMzZi1mZWQyLTQ4ZjEtYmQwZS0yODU4NDAzMWJlMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLimC/pmrJ2lT3j8by2bNSjG+nSlv/jQKUniqeTuoT8N9S\nICAdW96dBSFjaOyppGGPV5i9+XPG/JYkzHhn+x0oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ry83pWEeUpjgP9/IsNaUKIp\n3SkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJyuWCz11BppLyMupSswmVqbRKz+yTaOnmF7NqzEeqcIAiB5RfDmmuUN\n4URcyclgmKIYmvazaGkFiW+Uqo66s7CLqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAeizq6RWJvpgXTupJL93CSeJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTFjYzAxZTItYTE5OC00NmE3LWIyZDktMzkxNDk5NGY4ZjM5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWZiMTdlMDctYjBmYS00Yzk2LTk0NWQtMDU4YWVlNGE1\nYTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIgQzZdDGBlKsKkCAEoPjM+SE\nckrvQLl/RHUHP2Wdd+fQaSMgCP5HG8VIFa2VDF+a9xIQVOFx67W76gEaLdPVqqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMtjP+56Je7KA6ET4Xqr5qb99KCYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFWeMoOreVOKc9lW\nnO4L3F6h9pmzMYSg5r7jmf3ItTsAAiBVVI4OCVmxJFTvxRLrH1I6zPX8WgH6cSPc\nTt6d8Z9ozw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2682", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2682` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXeRRT+xANh32IEQOOjBqbjWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0ZmQ3ZjJmLTA5ZjQtNGIzMi1hNWFiLTQyZWRhNzY0ODU2YzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I3MmExYTktMzI0\nNy00YjBkLTg2NWUtZTI1MmVhODE4OWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMz3PdRj/xGq0fEFB1vZCpNTqY0+ufBFu3vkR/wJlRYLnwsmN9PoRWSqBiqDb\nk7QSVjdtzVyUeoGmuDk6E1nwq6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMkz7qkyW0s8hkR9JKtDtHSeBdItMB8GA1UdIwQY\nMBaAFNKzScPAkKyqqevN0KGwVL8dRxZ6MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAqHkv5qexFvQLDVJZhsXLWXLjZjuRMdWh\nVOV0XkY6Vp0CICq0HSoa2xE0pmqW4//llI1Iv8oYS0bfES7n7sQDze30\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ/1gEP7lGgPgwNT344AqkMNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGZkN2YyZi0wOWY0LTRiMzItYTVhYi00MmVkYTc2NDg1NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2Lrt5EgecXqhhoEjv1/MK99yi/qM6LJOUIu9I4FeUtEKA\nrrLPPueZU+r8KuNtINj9ltq9C1vHIatnK6SfN136o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0rNJw8CQrKqp683QobBUvx1H\nFnowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALHxx2hhlGHWAsPVLi5rsl5+5+0g97jRTaSR9/SUoR3jAiEAmzv06922\ny8UWVrZgXm77qx3XFTjJ6CE/Ro/qiB9d2bY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZ4zSjD1BJKf/3VV/IUCGfvvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I3MmExYTktMzI0Ny00YjBkLTg2NWUtZTI1MmVhODE4OWZlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmRkMzE1ODUtMmZhNS00NTFlLWI1MmEtZGEwMjk5NDRm\nNDlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP5jxj1O2/UVbsIG/nkKiH+y+\n7Vkm8CZPnWdI95w3IuUWFe/E+G41lztTJ3fua0qL3TwKUuGFJzNozbKCgYD2DaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyTPuqTJbSzyGRH0kq0O0dJ4F0i0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIA0Fg2WeZPW5f+/C\njwXxywHATFw7TkV0uHQdiOqvxSbmAiEAt8+PzZ9lX7B4EPx+k+jXk8p/FvSidAZX\nOVE3lN2oyP8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2683", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2683` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUqFjK7Q+xLYovwr7tNyUQ1pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmN2U3OWU3LWI4ZjQtNGU3Ny1hZWFjLWFmNWExN2FkZGYzMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQzODE3ZGMtNGM2\nMS00M2M2LThkOTQtYjg5M2I1YTRkNTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfIzwFog3rNTDOdPVPlP4AHaeMK315IuMoIlsa3pgqhQ7cnZBZDCxYgoKkFaP\nha6JiUpE5bySSScAMIfnEaYJPqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR9gyz9cuTR5Y1DmX7KyaEII6g1WTAfBgNVHSME\nGDAWgBQhKy4sXhPJ4yZScRAojEPef1ROLTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCAYDbiBkp6frq5xbR62Ksm465VwDUm\nxAKnbgRhyEY/8AIgMz4WV5YooRbQp2+ghsromRZjphxyxVLB5lBJBWqZ6J4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXV3HKMZXLJHM7cvSw4dhvYCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjdlNzllNy1iOGY0LTRlNzctYWVhYy1hZjVhMTdhZGRmMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwFQ+fsdVXpS0GjwKaH+4WX0mc4m8YKVqHi0Wf4gkMZwzd\nAZWcAa2NiKzdGbQ9gy0EgQJ9wkCIxrz4F9o+1C2uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUISsuLF4TyeMmUnEQKIxD3n9U\nTi0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaMkrW398Ui9EJ8fg39f457ij6j0ADsVKx1UyKtO6//MCIBXGGhRS3669\nB2jG7Swe42kY/9q6iymuVBLjPlUdq0+g\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAexyizwQkrI9ob/pBTaJYYshMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQzODE3ZGMtNGM2MS00M2M2LThkOTQtYjg5M2I1YTRkNTk1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzU3ODU5MmQtNWVlOS00YTIyLWI5YmEtODVmMjc1OTA0\nMmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEnJHpwaDp4h8vTjSLWRoBCsQ\nlQ57lwQ9cuJHokxAYWdfbju3aPBSLMvuU/g9E00TzDFniRwu7DHGqMULbUeWyaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfYMs/XLk0eWNQ5l+ysmhCCOoNVkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDgOu7oPE0TOSEh\nyMl4cDOjRSBEYj6uVomq1j8P/aj9WgIhAMacfeedYs9MZnI5VuiRvmaPD6dh6lH+\ntwyMFtnZh3xN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2684", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2684` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAS4At8nmz4eh9IaQjkBC184JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5ZDczZjNhLTIwZDMtNGMwMC1iMmU0LWUwMGNkMGYwMjZjNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIyY2VjNjktZDA1\nYS00ZGFiLTk2M2QtOWVkNmFmZDM4NTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAt5vQkt8x6ddLQ6zfqVPElTnLqlGvtOms8fZpmspxHQzDmTjkL3MoXTtNqXs\nSicOF5SVc72Fr1q0dKvqjR7DD6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTzyiSE/2j7IdgmRFH5oFz/0gDr8wHwYDVR0j\nBBgwFoAUqi+3By7Sg9rWQFpOGhXS8gcWdfwwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAybQ7tucCV0Iu\nr9HubQbf7GxJGvX403xRoO4NLmDQCToCIFJUJMAM8l4HE04J8dPpf6xzI0ZPEeHe\nQl4EC8CoKRe8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATsJA8ubIos0Y5vJjoAzRRuyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWQ3M2YzYS0yMGQzLTRjMDAtYjJlNC1lMDBjZDBmMDI2YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASf4LTMfToM91psWw+JnraFr9Wfw+0HUNr42UQSnkLWikVi\nSBxOjLdtl7uyYcyZCHQ9bL4112cmLLCITswKk/kAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqi+3By7Sg9rWQFpOGhXS8gcW\ndfwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANVJUJwdxwKj1r7X0Tbyj7G24mZ1OG93+hpZibdnKKuKAiEA0OgArGQl\nf7SBVEtn4aX8/g0OmvQoowV8BktuP69cV2Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAYYYSvJhYV9L7YeZqJm2rmFIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIyY2VjNjktZDA1YS00ZGFiLTk2M2QtOWVkNmFmZDM4NTY1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2U1ODgyZjktZGE0OC00MTFkLWIzZTgtM2EwMmVmYjYz\nMzYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdlvhLY400pnumhnIAw3puhd3\np14AHQSVjRJej4nkaCmL4XnSbzNb8OZP5w2AgwcqJr8rXeHsvbTTxKfen/1yKqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTzyiSE/2j7IdgmRFH5oFz/0gDr8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCABGsYD/eOO7jM\nf99artu0VH36qnQmJjAB6k6r+1RhbAIhAJq88sUreQ5GD54P6+YnfWDEJWpoMTqY\ny6JxCeuH/61n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2685", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2685` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAdqe7z7jgebeGvTuJ9ISKHgnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxMzdkNTNjLWI2ZjEtNGZmOC1iMjdiLThiMGViZDU4YWIxMTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhmMGIxZGQtZmU3\nZS00YTBhLTlhMDctYTdiYmM5N2Y5ZWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESz7sPAKr4vxuqslZUaQb1VN5pyP/TTS+ur/pnCLgGsrksguNl9hvS5OBjAtd\nY2eDU/wMGs7L1zCTQ1WKEuo/gKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNQ8/AF6bI+26ZI8Fxbx0NCo6ilswHwYDVR0j\nBBgwFoAUfP7GXngy2W8Mcz7/ZiqyH7jNALYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAw3UBRHO9DN+HW\nWMUVL/B/WEPf1orhoYogFvO/6/HWeQIgFiBu9t2vjx+zbRyNe8IsFhgoErLCtKSA\nK/uZNcQzTY0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaKhdPq1VkYsM1qppkYwzPaNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTM3ZDUzYy1iNmYxLTRmZjgtYjI3Yi04YjBlYmQ1OGFiMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUkCj0Vy5Q5EHiO5ihxI3YTpm44QcIZJqh7xHfYH9qL/f7\neAi3V0ClzGwFzKzAf4fYpzrgt2g2CXFPpA9Bxe5go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfP7GXngy2W8Mcz7/ZiqyH7jN\nALYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKm57VQgErGarV2khezsaFy6S+nwuwhVfILgBzZb0gIMCIQDATQZybN8Q\n9Zx7aJQC0TkLaIcZKHWucZ/4+heCKuqp4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAYY/AKf/1qem/WW9ONHTTbzlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhmMGIxZGQtZmU3ZS00YTBhLTlhMDctYTdiYmM5N2Y5ZWFiMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJhZjcyYzAtZDBlNi00NThlLTk4ZjYtODkyY2FjZjk5\nMGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdhlC/FjT16wdtMBOnM5awxVi\nNmJkVJ6Zy/jcKekd5ZXQapWgNM9Q3JmMEYGuNXhMUNA9CBuewjO9AIKMnQ4iuaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNQ8/AF6bI+26ZI8Fxbx0NCo6ilswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCIERHTbrpgtI+U\nVSYoPb3sg1kWNLRL6wm+yWMEnR0u1gIhANA0eVbk8Sk1G0DTz0Y5Z/5N1lkn0ddQ\nCe4HQBZOKgmT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2686", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2686` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAb5xmGiXq+60oENvFiJx7SXdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZDI3NDI1LWQyMGUtNDY4NS05Y2ZkLWViYzEwODRiODhkMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU3YjA1ODAtNWU5\nZi00ZDY5LWIyOGItZTc1ZGI0MDhiMGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm1lHsRGAfrXLmFzU80g7gBsE4s1UsNjHc7LYxkEtV2IOmajFOUEn5uMyGl7Z\nMY5HevnkuOU5Ar12vKt//NoWe6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3UpN0Qi56UOuyHfvZOGkdet4QZswHwYDVR0j\nBBgwFoAUrKMu+QoDzDwS995Vyr41XUnYBgQwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEApyhLr5Z3ufXKEG5gR0KN\nKBKBPvBTzyl25jMcXx1JO2UCIHE0OWBkdFnmtZGIL/H8OoWRtPyRo58pWzefDShT\nqNAG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQYz2jPeiiK3J40aoINuS3FCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2QyNzQyNS1kMjBlLTQ2ODUtOWNmZC1lYmMxMDg0Yjg4ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq1is3wzNmiEahyeXtOmPjTD4BzH6Er9fAoG3Gdw9Rvnw/\nZe81L9RN4uM/ZehAeaVvKIhja1C7cVLHm3+w1imTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrKMu+QoDzDwS995Vyr41XUnY\nBgQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH5puTT+9e5tzRZYt6qB9+SQhJkYeTYGi+hiQr0W9c6wCIAtRlaBqzLZH\nPLjsWh731wCz6zwAZSb6gPeSZaKJOGPC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZm2UKLWj/Ml7S3uoeSfmGwnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU3YjA1ODAtNWU5Zi00ZDY5LWIyOGItZTc1ZGI0MDhiMGUzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYThiZmM0MjYtODA3Ny00NmFlLWFkMTctOGJlNWMwYzVj\nMWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6r3lX25f/GkqbnBjJw5r0JH6\nG5fIMAH82lwKg3FWigJvT5IbMNZU/NUiV/AVT/xw6Cx5ZdQzk0Ap97tE6vOUPqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3UpN0Qi56UOuyHfvZOGkdet4QZswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEpfCnnsSqGkplrz\ngxSmP3fLyfx4cUvbbxfAu6kriUCXAiAKEw+O0C34lbtx9Xnz4nw32r8Xr2wXLAVY\naCh+ncRD2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2687", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2687` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAd820xLb0YISnIigbb8043JRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4OWYxMjgwLWJhNTgtNGYwZC1iYThmLTFkNzg5ZTM1ZWYxMzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGIyNjA2ZGYtZjhk\nYi00MDFkLWI0M2MtZjJlM2NlNDI1YTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsnGTrEYjLcxzO2T3c0h0kUPsRQmuvKSMmHcy8mBYGSlDPbOFl3iEEyehgTXL\nEq3srrjYxQxDuElDa/nz6MZVqaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpf4c6f4JU+ku0/Dw837hOoSqBaIwHwYDVR0j\nBBgwFoAUNCwCTKzJCox3EW05rGo/EwaR1nYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAxhed\nJhzzQMjLwOEPeiI5VJyadWyeFF+9RcWEC89TOIwCICElzr8FRxPdDpREFNOtLkds\n7N6bCedQ/lZXHXVWkGxS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQdQKh0XFIbP4oHt0vMW/a2CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODlmMTI4MC1iYTU4LTRmMGQtYmE4Zi0xZDc4OWUzNWVmMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmOUh74mh4p3ZzpIs4tYAVYh4a708F2bvpHoiyEw13xX2B\nlOWo8ZiTiGcm3fze6usp8Ucp3mAkjIGU1d4emMIXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNCwCTKzJCox3EW05rGo/EwaR\n1nYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL8fnfr0l0pOCC+3nk+h+7u3QSr0Y7+UNOqxLSrzjmcaAiEApVEIVty1\n5DKzw7x6XsWzpulX9xgL8jh6qkUl1jYjeZk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAXOP0wnCwrsvmZTVinM/dHIXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGIyNjA2ZGYtZjhkYi00MDFkLWI0M2MtZjJlM2NlNDI1YTE2MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWMzNmQ0ZWYtZjRjOS00YmU3LWE5ZDktMjNjNTVmZTZh\nMjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzzTmTYKVNQqFWOLHroJSNcmL\nM8fajSNQFds7MXpgPFIKczC1tmO13jOHJkSqV1QH4XifhsfO0c9/S97w8XaipKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpf4c6f4JU+ku0/Dw837hOoSqBaIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDwrh1GDznSVJ8l\nxzoM9KMZ70aiNKqct5q3GpcIYAP9mAIhAJG6/lIcUQS4d31jN0JtyU4102wSon7W\ntuEjE71rIU/e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2688", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2688` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAfz8XJxS/oCVS8uQaibePA/lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYjhmMTZhLTk3OTktNDJjMS1iMGIzLTUzNjZmMmI2N2FjOTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZkZDJhMmItOTI4\nMy00ZmEzLThiMmEtMDE3YWRlMmJjOGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6OBDJNLr9avK+oiwl1lqKKjwndMw7qC7LhycnKhEyXQz/g+PeJ80LCfwFx/n\nPskER40bWQ1frS+yJDoSh1FIj6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZYjbik3aGBFR+0exrJ9gBF6bfwwwHwYDVR0j\nBBgwFoAUKcdA2lYBx/BDLapd51PGqF0pILAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBCc4IA\nNk1foB7KHFkBWFgIG023wAmcYLrLGN+K3dSeZAIhAIiyZ2Hxe7Po+ipBikVqNRrQ\nvJacadhjrY1oe+t8W14K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc38+xCpenFRbIwXiPOlUVyvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWI4ZjE2YS05Nzk5LTQyYzEtYjBiMy01MzY2ZjJiNjdhYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT22tsjbY4LANJZFETcvFFYD2DYPnvR4xnblKZ27ZBr31mn\naViaVPMj657SLSorvUk8BmCSqL3DqjTp3Cqtho9vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKcdA2lYBx/BDLapd51PGqF0p\nILAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL8CPFYfW60T4cPsPhlQpzDOVzg5q8ysKif0+9uTr1nkCIAxGZm8yiv82\nto1+nZ13g1Msp0AY1CdWUCL/fCMH3A2G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATkbnJ47LRAAgQjT5FfuqYHvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZkZDJhMmItOTI4My00ZmEzLThiMmEtMDE3YWRlMmJjOGEzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmNmMTZiYjEtYzc5Zi00YTg0LTg4ZDctOTNiZjc5MzIx\nNTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs/B7JAvKbP2hKAd6Am7EnZML\nuy277YB5UTe7Ifxk4J/WexS1fpm+IC1NvXgAQfKXu+O67EbOHS3hDRaKu4tdrqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZYjbik3aGBFR+0exrJ9gBF6bfwwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICr8KBCxituyXzn7\nVywKPU7/ALSFMQ0tQSYLiI81OnUbAiEApNsBPkY4CbSrQ1R+NVpu1YWZaVp9CNZp\nUcl+WvS8oLs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2689", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2689` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAYEJzdZAXW66PaszVosj4Y9kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwODMyYmYyLWM4OGMtNGVmOS04YzQ5LWVmM2ZhNmIwZjRjMjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzczN2M5MDQtN2Q0\nZC00Y2M1LWI4NGUtYWY3ZTdiZjIwMjdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl36s34CjVxtX5a89smH0T5GuGNOvPOQ+7cnipOWcUwQTAYrf8J7t1TlUzDk5\n3EWaTFJjzGS+oOB0FNsqrd5hj6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOsGte237Lcl0LniIY46er2Wxb14MB8GA1UdIwQY\nMBaAFBhQ0ueaNtvBwL/LIRhe/TZaGrAiMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA2GDaGg/omSEIG1vlSLCfBwH7nStBvfgy\nubesEjn1VdQCIQDIXLeQ+/xy11h46BdwbAP13cGWLSgj/WmLc79pmBucOQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVx1lMyQq2Tkm5y1MxH0JBp1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDgzMmJmMi1jODhjLTRlZjktOGM0OS1lZjNmYTZiMGY0YzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiINwNle5YypcComUzRQSPU9PRkI1x76rvxdgc1CCC1M4D\nU+TaBpkENG/oDs9L95GNx7MtpI8iHFQbdD63mjk5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGFDS55o228HAv8shGF79Nloa\nsCIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKCOkEiuAWovPg9Iuyz+9SkWltT8OStzh41TwSX0Wn1GAiEAgxp2eD3A\noDGu5EMmogq155QmHA+KvQ1XW9tg/v0wqKE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISASWUmD9B4B3/98e9I+xA6goSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzczN2M5MDQtN2Q0ZC00Y2M1LWI4NGUtYWY3ZTdiZjIwMjdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWZiMzYxNzItMTk4My00MmIxLTkxY2YtYzRiYWIxZTU2\nOGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcBqkKaXxufR5hjTN07o21+aZ\nh68AlLuUXt+rLNzcVIbYYZLi/idY1pXMqgirKyD0dS17jfB0zZWyB7ontqz4IaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6wa17bfstyXQueIhjjp6vZbFvXgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHSzlQlDWrcvLeJo\nyeBNjAY3GacVm2/pCkEwxAPU7PaKAiBLXP/qizBTrg7RJlocSK2jU1H3xZyw68eW\nnle9PAL7og==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2690", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2690` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAaDjQUcBshES24evfSs7AmtKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNWE3ZWEzLTE4ZTQtNDQ0ZS05YmQ4LTBjMGEyMzE3N2YwZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDAyODFiODQtNTEy\nMi00ZmQzLTg4ZTYtZGJhZjdhYjY0YjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0LRH9/WgL/8y9Q2LWY3QXMgw8cijzkUjBXily0cYB6q2n1/tOrAtZ3haMO7Y\n261FAn2zzX8vSfV/zlDbf7sMP6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb8NYqcv7jHJOKQEgvOJmMW1nrUEwHwYDVR0j\nBBgwFoAUy2Dlw9FBR6kgl24qjyuZnDdp3IgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgGy4zJqh4vxBu\nqfemfyf09nsfgCI8bJ75p/o7xL4d1AQCIF/O2CZc7xG4JqtFiBgQaDLElmv2Otst\ny+bDM2t9PzmK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcowbvt74ls7e17LDoxhswUtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTVhN2VhMy0xOGU0LTQ0NGUtOWJkOC0wYzBhMjMxNzdmMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpez0LM7P+b7Tbk1a0FG+mrXVfw3Ks25+Cph+V6uc9yKdD\nNcAh8ZHB2Prlc0uNYeIdItSndTNFS+aE2t4FmUvQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy2Dlw9FBR6kgl24qjyuZnDdp\n3IgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHiuebj0ktZ+duwRsJ7oz+eMlKxqymQo/fFFQ3UnaFDoCIQCGLgGH5y2G\nMzNrxgG3yl/H/RRCGTXtLgKm4D3LQ3zd+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISASclISlBorbGdUygNfg9eP+iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDAyODFiODQtNTEyMi00ZmQzLTg4ZTYtZGJhZjdhYjY0YjM1MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjYyZjVkMmEtMmE1Yi00NWZkLTkwYTItOTQ3NWU3Y2U2\nNjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/byMnumGimjoiMxkFjJufvoK\nCq9RAoX4QSa2fdCUfBh31Kj6T2rqMGz+iw9pEnJeupeHa69GANlr5XQq639XVaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUb8NYqcv7jHJOKQEgvOJmMW1nrUEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDoLhTrtTIHLhmT\nbj3CzzpWzekOSdp3MxY/LkNIkehIywIhALInr7/TBztFPHV0sdtR0t0UxAkNQzVx\nNceQPG1O+bhw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2691", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2691` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbjmmfKuXdOHbFHzD/CcpyIaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxMDA0YzJhLTU1YmYtNGE0YS1iZjUwLWQzZTNkODYwNjNhZTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWYwZTNlNmQtZDAy\nMi00MWQ0LThkMTUtYjY5NzY2OTQ4ZWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4EmQeAirnClZ4BEvyNcjrXLXSlXjbIIv2uThU7dnxSWpxjAypPRtjjHZFL/N\nDWmvEKbj7k2dMlZbn5iAKr7xnaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq3zKcpW/waKIjn403XjUVjPAiLEwHwYDVR0j\nBBgwFoAUOquGenFR+NqtLTAimc8VWxGZUakwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgNrmaQ0CV/mvO\nT9cElKY34+67s1TwsFajI+uFk9mJZ1YCIQCLsE5/PdQX8QrlhROkHDvO6rinda/S\ngVHIUIXC46fFcQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWH3Too7dOtgSgNJ96wQ5LiwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTAwNGMyYS01NWJmLTRhNGEtYmY1MC1kM2UzZDg2MDYzYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/deec0fQzq6vMB/VumIWtOUrU0rEsP6E+Jtzs751Fce12\ncssFWhDcOIWzAymhY7IebKY2krYVpf6ltgIUK9VYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOquGenFR+NqtLTAimc8VWxGZ\nUakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRtjLl03UelugZ+y0O8m0sU3tVcAxplGGeKKE9aRX0LYCIFavRGAzkrA6\nnZ4462nuPQ00O60uj7asZx+gc/6KBDpU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAWmhYWSBLxgQ1wtoOeGDPg/zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWYwZTNlNmQtZDAyMi00MWQ0LThkMTUtYjY5NzY2OTQ4ZWQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmMwYzc1ZDUtYTUyMi00Y2NjLThmN2ItZDA3NWI3ZGM1\nNmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExoMZKUDw/nDFspsEQX44vKfS\nrISbC9M8dRVJlBoMfT5mhZs1UPaGFaBHaj2Zc5q3nLl3CeizY1lu6lyDQgfHa6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUq3zKcpW/waKIjn403XjUVjPAiLEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIACQRZJx+PxxRb34\n6R6uQJ95S74UfGbNHlwMnulG4sNiAiBr0JERSeP7l7jFuSjD93wsRxpn52st9rHG\nrSAzzF8jOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2692", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2692` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAZD/a+U3wDWb5ksX/aky3CtbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3OTNkMDI5LWYwOTgtNGQ5Ny05Yjg0LTBhMTA5NjQ0Mzg4ZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUyZjc1OGEtYjdm\nOS00NzZiLWFlMWUtMTJiYjkzZTZjNTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk/vtH/zIwba3o6ro19hWEp7Gezh8Fixtm92ND0/FvstZbjtlOdEGvMcx0Nig\nhaQzXF7+igEhgHcnbRHT3FWIzaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrqVTxXC2HG4shM3qv4YT9CkSwqAwHwYDVR0j\nBBgwFoAU3K/QlxyVM+eKc7jOBP/oYIDdnFEwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD0DGabF5qS\nUGpHpb6/r43eIXIjmBOVmld0PG/sF8SnaAIhAKBl3YlF1PO4SOThK/koiVX65eT+\nsWB/5SuajQtWaFhG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbx3hBA2qDoVHWvxHjgLSXYfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzkzZDAyOS1mMDk4LTRkOTctOWI4NC0wYTEwOTY0NDM4OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6RrrAVlr1Azs7VvqgI+s9Bs4pVKJUCrAVF4kY0mt1EaqQ\nzmQouXINJHDTb3ercYmVuAlLmkPSr5xdFtOqGu/8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3K/QlxyVM+eKc7jOBP/oYIDd\nnFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVbGryQxpFjEiR3u9e7ms0dOxHvoz9XVcWZJfbALHulMCIQDKWE4Ynq8L\njb3aw/u7/NVwQHxu3tOPgBYz6fqn8u3mpA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISASh4yH25D120T1JkUXP2TdCrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUyZjc1OGEtYjdmOS00NzZiLWFlMWUtMTJiYjkzZTZjNTdlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODQ3Nzc3YzQtZGZmMy00YjgxLWExZDEtMzM3NGQ5ZTJl\nMDc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2MeFLpXkG9BCkvz0mMSUorrW\n8aWlwyhKF4ZIrwVRNdsOGuKZH3TiypERxkPNHrdAE7Orxmgm7DATxeiivnIXIKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrqVTxXC2HG4shM3qv4YT9CkSwqAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC46FiX0z9bgIBH\nH5E9oaWVRM7X0TPVeh2Lslpb3Nd6wQIhAK+1lKEd6gbrRQVESIypBD2kndyuv86C\nR6reXivkWuVZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2693", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2693` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATkxDxdVlAWeVIbV7Tmj0qLSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNmJiZDUwLTk0MWEtNDEyNS1iODQ0LWIwZDVjZDYxMmY1NzAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNmN2VlN2MtMDhm\nMC00MDdlLWE4MTktZjYwMjkyMzQ0M2RlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA9Dhht+NAy4Q5cyBMQ4vNEe8Mz8O9wC0i8FnXAI/sJHeN1kv8VDW1Op1AliO\noA57X3RLNsmZpU9puxvDj+OKZKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMacUbCD7IaPfVAaiX3efoHnWe94wHwYDVR0j\nBBgwFoAUn37aARVc3NXZF7fRmTT+Mt6TptMwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDXiZQkWzF1ewnoLChYyzxF6WvUFPPn40b8M5dKjfQXCgIgW8IzeF6QzW5E\nZkSXW0Q6qm3Y3AU9Ci3iq5ixOpAWNxU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASpNaXaD+puRaM9E+8wsk7ZqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjZiYmQ1MC05NDFhLTQxMjUtYjg0NC1iMGQ1Y2Q2MTJmNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPDj5TLXALxcbN6sVNUCjTPbQLbUhKSQl7KF3INvi3uRzU\nJGZCPyi1WDLahlGaoaAUjjWfUkJBgkJG2MBdYDmFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn37aARVc3NXZF7fRmTT+Mt6T\nptMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJQ95zpaiAzH3JhnZG26AnGaS9SgLkHecuGB7xPH5pwQCICu+2Gk+U79F\njuVn6in2RUxmrY1ZpS2C0Mp/3lav1Pib\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAee4OuOycs/hqvH74C/QTdYIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNmN2VlN2MtMDhmMC00MDdlLWE4MTktZjYwMjkyMzQ0M2RlMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjYzOWFiYWItYzgzYS00NDI1LWI2OTgtZTBjMjdlNWNl\nOWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHgIfSbt9jJhlEjLgJeb2k3Em\nqsKP+F3cxQXmr8ycJogoPYjaIsx7g0Yukm3ZTGfFWvDIHrmzUCK/OVm+89Eb5KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMacUbCD7IaPfVAaiX3efoHnWe94wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCtQnucYMM2fWNd\nVDwM/wxcGYsgJrDm/kf7YZDIPKOHRQIhAPt4LfzV4hajcJJy7aMpGOQIx9l90tH3\njLt0ROdIDvo6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2694", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2694` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAc2I5NbjZ1FJ65+DOrMNNJJWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllMGQ2NzJhLWQ5ZWYtNDFkNS05ZGJmLTE2NWI5NWY4ODNjZjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjgwZDg0OWYtMjU4\nNy00Y2Q2LWE5NDQtNTk1Zjc5MmM4YmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfYGeBvqjMOcLtncoyvyTuXnBZATROCMhYVLZQLr2PD6EImjuoQlPwgbd1JEi\ndco8SW2Z7+iHuBTEY9zbU5laYqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpUAYHId7gCGTyYbTMBmI4P1ldx0wHwYDVR0j\nBBgwFoAUJ/J/ajXvomw4yAbExHG3fxvcfW8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAhg3D3k3Ls35t+6A89gEl7BC3iB9ldxk3YAifq8Wac7AiBZAzAwvOt0d0Re\nVjSAItMQWFkkZ92oFtNHgPQrnoEJeg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbuSHOA36j5lT33AZXmiD1O1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTBkNjcyYS1kOWVmLTQxZDUtOWRiZi0xNjViOTVmODgzY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT14cSvPYd0lXQgNPcqxfXefZPWLHodA0obPGPErUJ29aYE\nkqxHwjeJQYSDtYQv5P0gCclM3rslDB6qOHhQ+/Odo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ/J/ajXvomw4yAbExHG3fxvc\nfW8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOzpdVcTuLxmjR4pNlTUjoGqpHgPYW27Q9SZE3dGvLzUCIGiY65XNZKjq\nCz22MO5fwdYfT9vxYb99Kt3KA+vFKp4j\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAdYKNuvbv0w2OMFHZ/Blmx4hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjgwZDg0OWYtMjU4Ny00Y2Q2LWE5NDQtNTk1Zjc5MmM4YmZjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjk3NTUxODYtMmMxNS00ODI2LWJiYmMtMmQ2ZjFlZTRj\nN2ViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElRsErnHoQi9PKq8xJsZoZVsk\nEZqdREB638Xc3fPObPq0LuSXeXW1y47SbvRldOJU040z5j9tPgm+OfMzSljiHKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpUAYHId7gCGTyYbTMBmI4P1ldx0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCjcoYeSPfI23LC\nvWvgC+EJIM2EZpcEt7G2XXjGSYGe0wIgOQUsCpeji3ueR3b4sNc+hL7xw7kNk/71\nVI6hu+TQKFU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2695", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2695` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAUp535IiFJi2BqGicjo1tmY3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhYmM4ZTQzLTllNTQtNGUwMC1hMGMzLTJkZTM3NTNhNjE5ZDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGRiOTQ1NzctMzU4\nNy00YmUxLThjNDktNzZjMWUyNGNiOTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcUj7g5fHEQP2iZDsTezpdfefi+UQe5FNysc4JYiEpxJRz97XUmVLi1NOmuNF\najKfAjItZSAyiacYdwJAVXyn4qOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvuHQHoaZGOjweaow+LnLDxlPgswwHwYDVR0j\nBBgwFoAUdLgCRpDNDqqNygDeRZ/RQLn5hYkwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIE0M\nCRVwYh1qgI5q0TpYgYs+OF9Mwh/DDxVmrmGaSlZeAiEAk4jh3WeipZdU5h86fsQ+\ngJcM/zfkoyFkE48ufS3N5Vk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVOezqIf85x6Vh2JVZJQydsVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWJjOGU0My05ZTU0LTRlMDAtYTBjMy0yZGUzNzUzYTYxOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlqaF8VOkgOUbp+N1dwuZpiD71wLR9iqCi3V/TUDWNQVsR\nB+9jc1SSStYhlenugbQCUrJIp8SwpCjyJdkYEZTlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdLgCRpDNDqqNygDeRZ/RQLn5\nhYkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTiQV1LzQzH6483kMwF01ygDKbNgUqhmnRhqFqFHpo9oCIDNB62QpX3HS\nHwXQfmF1GvpNaH0qMaiwcNs2E6N+URBg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAdS79gJ0xtbYcEB3ZuEj12ihMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGRiOTQ1NzctMzU4Ny00YmUxLThjNDktNzZjMWUyNGNiOTQ5MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTVmMjBmZTUtMTlkMy00MGEzLTljN2EtZDM3ZDUzYjM1\nODMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHDnRyb2yav+LBGxAFO+KHj0o\nfqQkS7oUU4pGfgtSyn9cSWimrzR5AFoqz0DQ7ty0zPZHIsE4ffYOQ50/catFF6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvuHQHoaZGOjweaow+LnLDxlPgswwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGCaEO5dk7HZoHCi\nNgvB4RDPb4mL//35N3cA8iXFNkzsAiEAtYUnRsvGqvQQi2xk5OqIVdmNu4HoAzbv\nZ9lThf5BTa4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2696", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2696` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAT8hK3rjdYyW2hsYHAqZBvFsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YThhN2UxLWZhNGUtNDI2OS1iZjFjLWJhMmNmMmY1NzA3MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM1NGE0ZWYtNGNm\nMC00NDYzLWE4NzMtZTIxOGI2YjlkNjBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVXqBxlPlSh70CNy0FPrDwVnLfDsAKzr4fO6Nt16RKu67b1NQe6d6fHEKEw1T\naMuT/DJ9f2AUDkC1eOP8ZWuex6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrD6G5nZm3GTaZNRoX1IHx7fIxVwwHwYDVR0j\nBBgwFoAUj4FV/M7pJm9CHyPsifaHNQgUS7IwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCmwSxfvqQVR4qRk7Vpi3jJxAB3Sh+S//BV9qvlPJV3tQIhAJfM\nqmEBcrE1zyOhgne9Zg5A9XPOxtdxQt/uNyr5iFz9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT5c+iYWC397FHbQnstLxu/HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2E4YTdlMS1mYTRlLTQyNjktYmYxYy1iYTJjZjJmNTcwNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwSjrXXMwNPeolEVjcaHO0lFBGykd513HFhJxAga4l54Si\niQr08sBNE0tiADA3Dq/QruKBZ4T95dJr9CqkV3o3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj4FV/M7pJm9CHyPsifaHNQgU\nS7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJA3JCbaF+l8u0gsk01nMu+Dmj0D2h88UYDuH0kFb0Q2AiEA8Xxo1+rW\naE3dTuybp91tInNVujcARxOYpBvl2wVs8Ys=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAfs+FcOgwiGCBddB0xbG8F5UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM1NGE0ZWYtNGNmMC00NDYzLWE4NzMtZTIxOGI2YjlkNjBjMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmFmZjQ1MTAtMTI2My00YjFmLTlhOGItMTQzNDc3Yjhk\nYTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKf7c+hkqabJIjmR9LhE+tWB3\nenlE44OIPnUeEdaWsA3qfAm29VU2zi/xuMFEbhqhtyVxAADjbLMwDhIYo7W6/KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrD6G5nZm3GTaZNRoX1IHx7fIxVwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCPo+e3yndoGifH\nbTBw3aqB9Mzk3zsj2Ip6wlhOMSQI6QIhAMDLy2oLQ0K55XO2GmRQuiHdQ50oYUIx\nik1UN30odJ82\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2697", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2697` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAfrxVIG3D5EZ1IuJBbi+AobgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1Y2ZmZjdlLWY0Y2UtNGYwNS05ZDZiLTkxMDUwNzZlN2E2YjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM0MjNjMmEtOGEz\nOC00MTIwLThhNTAtM2E0MDMxMGMxNzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETemQKpOw7Hwj/OlHqu9RuNBxSnLZixaTAf9JLLzarmsxluLMrU6CzqJ89bLQ\nM2qyhimf/vnm5A7MaW/0JPfBhKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtkvoDam871HDfb1m6nTaxvzSds0wHwYDVR0j\nBBgwFoAU8X+lHf3KaQMWCvtSWyjOV186KMUwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC/ItfUArDpv14+4XVPYpGYiI3lIblw5GSI+UP5z0Yw1QIhAKQc\ntT+R/3vRw2XIDrL+Kbd9puKxPDGDWeHhyiEI9d4k\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATyJYP2IEGGuAwajtZb3BypDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWNmZmY3ZS1mNGNlLTRmMDUtOWQ2Yi05MTA1MDc2ZTdhNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUecq+QgWCNAuAadtYz9sLrOi1fpRmZEEybiAMJbwLbTY9\n3Daz20CPydqucEsQQow4hOx+MI2ehnnvvy+Dosfqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8X+lHf3KaQMWCvtSWyjOV186\nKMUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKA9+zwGY5teBMgOFUP1V3R1MsQee5N+KJxhHQKsnkG5AiADODYLCYbC\nxCH+ltpmB4ukJ9bGu6Y7MrYhAcoS8Ym+wg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISARxOmPrDyDDynXKzVbD2cWnAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM0MjNjMmEtOGEzOC00MTIwLThhNTAtM2E0MDMxMGMxNzBmMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjY1ODM4ZGEtOTM3Mi00NGZmLTg0NmYtMjBiNzg2ZDQw\nYjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEip2SvN5Z56HFjBlkND90tw/R\nKWstqwtxongE6Zew0draYXWYDYNr6fXvR+UCtD+d14FCKYXKarnXLSdaAgKBR6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtkvoDam871HDfb1m6nTaxvzSds0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDY7LsTUM4E79AP\nlZcpZST1pQiwytgoJvzbjTpTR2gh0wIhAJgK/MxzFcIRQbVY7p5DJVpSbXRod9YU\npnEt8pL8JITa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2698", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2698` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWg2NXPc/ovqJ91uY2r4GyZoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNTUxMDlkLTFiYTItNGRhZC1iODJhLWNiMDM5YzcxNGNmNDAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmExZmVkZDMtMjZk\nYS00YzQzLTgxYzktNWVlMThiZjllMGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGd1wQz4wqXQKAkRlhAyRG+Yl9ZayIkAr5cKyWGCa5bk8taGCBTOGb82YTuZD\nHl+gQZXmmf8KLGaP5KnmMGCKwaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFG+HxUQWD5nAle1Fm/xsLdb+DrIrMB8GA1UdIwQY\nMBaAFPeAF+9pc0bper9oHu8IN3/U0RLeMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiARjHTR1G2HTIqvSaMRyjaV9Szrfq+GJe3s\nQes9B2QeSAIhAKFmXHZBmZfg0FPEl1WXnjgZ1+BrMlepRyRYWNU0XlgI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW/kvWSd+7MawRZMKYT624GXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTU1MTA5ZC0xYmEyLTRkYWQtYjgyYS1jYjAzOWM3MTRjZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEDA2N6YuVONiU8xiqXctmHGJUgyDBXa63rVtZ//YZOVwG\nbq6XdWHz6inFr8k6On1Gby/s4cuCCQpPhgncFHb9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU94AX72lzRul6v2ge7wg3f9TR\nEt4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPUqnzdBP9O5yLvnWInZTKc74FbCtvHpnPZ4UQjeL3HUCIDk21T1RyWeN\nqAzfsveawqPvrh3ZNmo6In3uoWLsB86H\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAagXLOg8NtRpHiBnTyV6+qilMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmExZmVkZDMtMjZkYS00YzQzLTgxYzktNWVlMThiZjllMGQzMB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTAzOTk0ZjEtNjg4Yi00MjhiLWIxZWYtY2ZhYzgxOTBk\nNGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPfsdAt3909xWxyD6MbetEHwJ\nc9lKfOX7DarGk3RMXPlBuxmt/GWZNCAQqrwV93BpJxCv6iZSqBkuy1FPxM36L6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUb4fFRBYPmcCV7UWb/Gwt1v4OsiswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCPxnlt9zoiC49T\nM7cIC1iAECaViVW60qCI/Z9jRkodNgIhAMGu8O6Nen80rTYnjMr/Kb6yDy5jeo2l\n29sgCB7FplpE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2699", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2699` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAWwB/YhkSVelfQm9FPVKwVY3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyOTViZmZmLTQzNTgtNGFmMi04Mzc5LTA4M2ZjYTJjODQ1NTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDFkYjQ1ODMtMzll\nOC00MTgzLWEyMzktOTBjNzIxMGRjMzQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGzz8pghf++zNgvLKVrf5pcuWMPXwqeqKCsyGwlryFp14/N6V6K1IfFbFdK9e\nAz2QwrTuZvEufTCKTeXqt2vWGKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd9lrRyHgCom/YsNlMSP2h1gZfh4wHwYDVR0j\nBBgwFoAUH66MA0MqkOBNLF/fivJsGnzuE98wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgKPJYq+YnsX1N\nV2Ck1q9+sFnX1+4s+at2z6Ib0JMeJpYCIH0TT+TJt6M4KHBpvCtwPhENXsBn3Q5F\nm6iTwzSTeRoN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUt+Da3ADBog9szWpR2CpuO0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjk1YmZmZi00MzU4LTRhZjItODM3OS0wODNmY2EyYzg0NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcooPp3HT0nnUiuZVgdexw5rpewteLatCWhn6NuBDP0Sw2\ntd62h8MnLxH/+NxINWQidadE1YBkiwmi4zRN5D+/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH66MA0MqkOBNLF/fivJsGnzu\nE98wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWP36ECAQ72JIOgyTXBm/fB78X1B1sRcVHviLVSmAl4kCIHIO/aadrlY3\naQrM23oe7hhLvhv6yHwY94J2fri4YO/l\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASEMkMaNIKQrSmq/NQPKUgdqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDFkYjQ1ODMtMzllOC00MTgzLWEyMzktOTBjNzIxMGRjMzQ3MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGIxOTM5MzctZmUwOC00YWZmLWJkODQtNmY5NTEyN2Y3\nNzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEau6R9SvlwmnfvyIBaJbnx9uR\nZJ95XYT3oUsF/lUawdnJF9bsUTs4T5i4b5qCMoVz8Y/BAvdGMfQzG/CRiyA56qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUd9lrRyHgCom/YsNlMSP2h1gZfh4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEJQu6/hVEh7SS3y\nWA/d966ZQiMe7xXkykO9jVgKQTncAiEA5Dzk44hrisQGCBQYAoedjorlwu4xFsLR\nCrl9TUzkU4o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2700", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2700` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAV7UT2fIm37bONITYBswAE0jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlMGIzYjA3LTdlZDMtNGJmYi05YTEzLWIyMDRhOGVjMzc0MjAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjczMWViYjMtODAx\nNS00ZWMwLWFlZjItNDdhZTgwMjdlYWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdzE6OUyEiWftEgYTF9jpvx3Er122Fc/yXfojKZ8Y0yltFGXzrTEheqqRuoXO\nrSEqQVTGdP2uGEsv9mUSuY61CaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdokm4HbKrFjfOFsDxc9nlsOC684wHwYDVR0j\nBBgwFoAUYWOIsHxY3LHEG0IN8KT8xp32mWYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAI44mnO4fS3z\nBmFWsZJsoFS+nn5KTbh5ZXaZ9seZdCJgAiAFrV+ER7QOC1aIChaiCnm13p+u8CLh\nvIwvxihTacKdsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc3teTL+py/9gKAQTm9ZOrX6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTBiM2IwNy03ZWQzLTRiZmItOWExMy1iMjA0YThlYzM3NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT90pv6ov2Hqpwt5aHR+bQ4EmUpZ4xpDa26itczEiCcKZnI\npnIDKU1Q7vg9SQdIkV3DBJObYhqWXfbIXdWZTODho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYWOIsHxY3LHEG0IN8KT8xp32\nmWYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANPn3g9/uAqTYmMNjsPhjA1XlLvTisAvgs3fJmFZlhcWAiEAzQyuzGTo\nMUHgvutOwBZE4ZZ7EA3emzuVheEU1+1A074=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAaGOdGQCmjmwabQtzMZdTmVRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjczMWViYjMtODAxNS00ZWMwLWFlZjItNDdhZTgwMjdlYWU4MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTgwYjc5NjktYjMxMS00MGUwLTg0NmUtY2MyMWE3NzQ4\nMzNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/bjaay4R237WgOBD9ZEaOShv\nXN+/n0qqlnwFcwyhBuI2jpJcT3leVV+jQER9WMbKCq4A0MTOoA9nRNFO4hY5mqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdokm4HbKrFjfOFsDxc9nlsOC684wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC1DbTUHM7Bvxg5\nq7YerlOc+nV1VEfrVNXRJet3f339YQIhAKAz7uy7etu4crFQ08zGshA/CAWCR8vi\nPTenHYufnJQV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2701", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2701` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAU+KVPgTzq3Bui+OPtUQtNySMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwODgzNmYwLWJkZjQtNDVhZS1hNjc4LWQ5YWI4MzI2ZDc4YTAeFw0y\nNjAxMTkxNzI1NTBaFw0yNzAxMjExNzI1NTBaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ4YzE1MGMtNWIw\nMC00MTZmLWI1NDctYjk4NzA1ZGQzMTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVK8JX29OnVAK5Vu8D+z1KsMoGj8dDNF8BTkCzQ0x5Uv8qIuFhP92ucGcGLOB\n4Q4cHRsv9+Zb8ELJPJE5BH46MaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBw2vYU8Ahxh4AF8BJAhT2qBziVYwHwYDVR0j\nBBgwFoAU6EqfRT74yaXGAOxEIuS5AhIFT5wwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCDFU8TTguu\nTAncL3BPrlB0TY4WXNzdWKIBeOzl/Y9DSgIgEkaDdG4VT95oa+PD+OBrhGPmJdpo\nfezu4AXJPnT8kgA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWuSLmtQzY24W170hfmH19ISMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUwWhcNMjcwMTIxMTcyNTUwWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDg4MzZmMC1iZGY0LTQ1YWUtYTY3OC1kOWFiODMyNmQ3OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR58cggQ/bYbQiGL+n/40bK9NKesb1BNL9hNSAPQ8WOuMLD\ngs3JhnTvoVBUMhAQVo1DCJ0c8JqcjDQmwG1z/DeEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6EqfRT74yaXGAOxEIuS5AhIF\nT5wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR0E/BxOnmAwSifThr3iXY1d+5UahsyIJLF81biYdi1ICIGhntPmVld8Q\nwPEIxN/vDtA2FzM7Z0PPWYSGGF5Wf8w/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISASpFowYzG+T8pLc6nubwA0BYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ4YzE1MGMtNWIwMC00MTZmLWI1NDctYjk4NzA1ZGQzMTM0MB4XDTI2\nMDExOTE3MjU1MFoXDTI3MDEyMTE3MjU1MFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQyMzc0ODgtNjUyZS00NTA2LTk2ZDMtZGUyNjM3M2Y4\nNzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjQFfCACQ8KvlM5d5CNe3owUO\nXp5L/jRzF5+pbBMtlniv5Eb9PHt+aeqIrgDOLNNhiApx8ldT6hbH9d9RxTEjx6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBw2vYU8Ahxh4AF8BJAhT2qBziVYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBFLQ+m3EDHHGNLX\nHAoFeXlCeMY4nTn+XP2yc8ZztavTAiB568i0dg/Ggp3RJFTXx6uYWCkTElyeR6zo\nIYJf7S00kA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:51+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2702", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2702` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbcmHTvqHz/SPgeKkdm+D5U8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhZDNlOGJjLTFkMjItNDIzNi1hZjhlLWJmZWI0OTZiMTg1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM3YjlhYjQtNzk2\nMi00MTQzLWJmMGItOTk0NzU5ZWE3MjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+z+YzbWU+7snf0Jbk2kA/hLSPfOK3msBsMZ8G+HIgwCfGT+52k2ZU1xpnL/4\n9fQwfKeba2YNMSF4i3ai0EPvc6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSB3MsrWA4UyI9BPyfQbk8ZhQXMYwHwYDVR0j\nBBgwFoAUJfZCjdG8fpjhU3M4ql6qfo9G0AcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD7vTKCAM/IWkWc30gT5WTveS/qwLgoL+YGyHwy/4OzVgIgEeTd3zW0lirl\n0B2z7HRdf2bSovxV9Bhemr7eKIxdvY8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcNVP+1Reb/zMAOozoQw7dbxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWQzZThiYy0xZDIyLTQyMzYtYWY4ZS1iZmViNDk2YjE4NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOVbUPph1bKCcC0cqf1aHQnVa6kh+JtzctKdIPJDXnteAe\njje2k4DUT0FRFIJPRjJ27b3dWNMWT7bAGNRaJ7S9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJfZCjdG8fpjhU3M4ql6qfo9G\n0AcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANnil3FoSNaaM2xoz6K+JkNXoR3B2nLj/xi+QYLyhfyoAiEAlNdbZWhA\nos82yKcOZJuJz42nHgCKtxbs1Jo0+U88efo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXdRGOPxwT4Ua1yqWw4T/gGcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM3YjlhYjQtNzk2Mi00MTQzLWJmMGItOTk0NzU5ZWE3MjlkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTRmYzE5OWEtYTI0Yy00MDcwLTk2MWYtNmU0NzU1MTk3\nNGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENDHDxm7s870pniV/nDKN8ljJ\nfWsH6eGEAk9wAMIWugEv+MDva7c47TR9o9zkhm8u2LVvocGBwrxZpMMAdu6jgaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSB3MsrWA4UyI9BPyfQbk8ZhQXMYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAQdF0axhKeiK7Jx\n0cHqeL7OcjcyGQsFCLBj6KtpE40hAiEA/24nNWBW5qY9OQhiI0KGbQHcnqZsxCPx\nLOh/Cp6Hw8Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2703", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2703` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcxf6x3hBxK6E99X0WySxeqmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkZGRhYzA2LTk0YjAtNDdjNi05ZjlkLThjN2UyNmU4MjFhNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU3NzIxOTYtNjNh\nMy00N2UwLWFlZTgtMTk0NDFjN2EyODYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJnTkHOuqotT2zbwak8+7ODGn0nJC7FIWu5+mMu/+2nJ7f781DJDXTnkGn5ed\nsdUeWT5xqellqAllpVlXftPzLKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnnE0Hz0xvlBzKAgCOPGRRxgluO8wHwYDVR0j\nBBgwFoAU8S6JE2g0et+4/IKv0ATbod71HgcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHStvHhcLEJ3LobMgLdeYz5uEEw/732SC0O1abobRVtGAiEAtOYd3v22NX0s\nM0uhPFEIg8s/3gSr6JuzbTZHMB9mLJQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVTLBjPe3Q+WrC3pS2SLMNuUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGRkYWMwNi05NGIwLTQ3YzYtOWY5ZC04YzdlMjZlODIxYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStPALp+GX3X0F9unZ+Ao21v1RlcpTzdzyPvSSVSN/n3Ral\no5WihVzqGUom6h/GhW/8a5ApHq599iFlu1J+wvHVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8S6JE2g0et+4/IKv0ATbod71\nHgcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbcvfsZtUfr8r7YP4IJBvWSs+EAsTcOmGdrl6f4cPjfgCIQCW3UpCr+M5\nH8s9wAXxtdgT6dSxAWwPZMLw1PALplmnTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAbXPv5+vDKfSBQMQObv48YABMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU3NzIxOTYtNjNhMy00N2UwLWFlZTgtMTk0NDFjN2EyODYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzJjMjllYzYtM2RlZC00ZGQ5LTkzNTMtMDlkYWFjMWU2\nMGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl0ioi5oz++zqJjJoE/AHtmXp\nzPu01GouTobYftS2yEtmYRaugFpvcjttnVEksVlDRmgjn0PxBfjjZQFCVvGbiKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnnE0Hz0xvlBzKAgCOPGRRxgluO8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD1tctUAj0CN6sJ\nQJLKpL702xfGyb1tn4w5suvJKwJMYQIhALdr3GdMPu61EnWHkjFStq6cIHq4w+EO\nDwTBUYt/1fML\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2704", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2704` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAdDj8lH6n7FJxKjA6t33fR/cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwMWQ2ZTcxLWMyODMtNDUwNy1iNWQ0LWFkZGQ1MGY5NmRmYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJjNmQ0YmUtOGU2\nNy00ODA3LWI5NzItNTI3MzkzMTc3NjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEITWYr3QGZq+lb+6msTyuuBPIX6NDVZaqbYqqDKVBD94r2E0T1McudF3TomwE\nRrn0Z7RWuhLUhS0zfELhqwmvFaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaXeHg/RhQ006NNLwvj47zcM2yRgwHwYDVR0j\nBBgwFoAUzS3MX1orUqnC2099n1PtPp0j2DIwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEOq\nG66djB+qRpvFeU/v47OzGnb7b3Z3hXAXbmsJkEC6AiAyzpu3Vz//HAcffIDgHmAL\neO0mTD8siposbTnXuK75lg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAderO7OYrPOTE6QHIxBEoPNmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDFkNmU3MS1jMjgzLTQ1MDctYjVkNC1hZGRkNTBmOTZkZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGLEC+x3xpND+ifBAa0CMub+YHTWjHAp3I326nBbjbDcO9\naZvrKEut3W5TY8SzvHPdNBXhZjY45QDsufNACcTuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzS3MX1orUqnC2099n1PtPp0j\n2DIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIqkJ/dcQrmFueSmYSiG9McBWXp/l0+ddriI37lidIZ5AiEAikPmN/pa\nT1VnxSxGdXU6o1PQDxkhhIi05qIPJzm/Xf4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAVWF/WdVakYeKyncuLCD8b2PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJjNmQ0YmUtOGU2Ny00ODA3LWI5NzItNTI3MzkzMTc3NjllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDE2OTgzZTUtMTcwNi00Y2QwLTk5ODYtYTU0OTNmNmUz\nZWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBmBWuCBzNqTILght5pReNhTZ\nhsnt0ZlxyFmakb5ydlcWDBvJz1Mb86b1cDMfXAiFLOvNJ22OGPU6wBw+vvsijqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaXeHg/RhQ006NNLwvj47zcM2yRgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFh2xdPMTRHnDooj\nbS+B5FMCseqIo6fbNaB5nrevctblAiBC0hhdvhAM5nim0usHdpqvE+PkUahtb/uy\njVVqFyTpPg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2705", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2705` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAfingCyfZqqpUl25ns6R1USNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2YjRmYmQ4LTFjZmMtNGU1Ni04NjNhLTQ3N2E4NmU1NmU3ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RiNzg3NDEtOTQy\nMi00ZWVjLWFkMWItMGJjMDQ4NGI2ZWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtYfmnfCkqeL0rJqSjY0FeaSfBNC0VpkjIphsiDi8SF/Esgn3EJlQM0zC2d4l\nDsBZQehFIcSxjerPuQaqVlJLnaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYsikZ2fAnzXqh5MUkL2/1Bpx7CQwHwYDVR0j\nBBgwFoAUqE8GPK3z8J/lji8HWvNv3jlkJ60wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDZQOuIoy3vA+0ucMWyNG6uZ+/qfaRC/ejljLu/yd7RNQIhAKdh\ngd6IrbMwyOGyn0fFur1uTmOhBesptSIidm0mOmh7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdgyFIIJQRi5SfOjDS43xJ1jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmI0ZmJkOC0xY2ZjLTRlNTYtODYzYS00NzdhODZlNTZlNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLNQCdX46ZrvQsm6D1X52ajHT7+Y0nqS0kfBBLpf0U8vS7\n5qSlXXXiq/P05qA5q/ehHgPT98sAfQnb9gd5izN5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqE8GPK3z8J/lji8HWvNv3jlk\nJ60wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJsAwm+ARLmZ1w1Mf/KCENXtv/83j99TlnMINpUV11WAAiEAtyfTPVs2\neQ6rTKcOL4KfbNR/pvpmujc3mxmujG2zMgA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAa8noKi+kEZKQZkSCJmoU+rvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RiNzg3NDEtOTQyMi00ZWVjLWFkMWItMGJjMDQ4NGI2ZWJkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjM4OTliMGItNDAyNy00NGUxLThhY2EtZTM2MGMzZTA0\nODlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm0/Ki7C8fURZSiAjLpICGWh4\n8e3IoRTdwrNa/RI97EIURBd7dmRbOZtCGVxFy/h9dSedRoJhJoTZ2f1Eu4KOxaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYsikZ2fAnzXqh5MUkL2/1Bpx7CQwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDzIyWXkbnnK+Au\nm1IJfPu9E0styhfieIKrwE4Ba76bEQIhANPlb89FXL3sabQ8mWhWrRG08sjtFIdB\nN4yE6oQC7rIZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2706", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2706` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISATmeaQas2pyY3WXp+6dMV8TcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZmE2ODhlLTY3M2ItNGExZi1iYzdhLWE5YWU4MzE2NDFjMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU5ZDhmNDAtZTY5\nZS00OTRiLWJmMzQtMDMwZjgwNjZmY2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm1895fe1Fq6ImPYgSzDp96x+qz5dzikMtpdhWFdK342a6K/fOeV7mQYcKgWx\nE3raSt+T7cbTO7X2KX0auhkQOKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH8U4BXbFIAQzV4Sb5yPLg30RRZ8wHwYDVR0j\nBBgwFoAUddpEO42/vPzTBN0ihk9+my2+ZyYwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEgA9MyqWiOkmOd4Pk4dd0e0xMcKMKU9cujczDls/8WPAiB+ekRz\nequw1//k4cqexSCxjw8UedXdMRqwLa8ePm0Vhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATog/xSOubrbRaV7fhjROjdSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWZhNjg4ZS02NzNiLTRhMWYtYmM3YS1hOWFlODMxNjQxYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQB/izmf4XTZIJTxn8/xnibTkzfLMWeU/N4AkQRYw2YYb4P\nuywgQ61707UeE7Fi7V38THL2etDxPDHF4b1K1LRMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUddpEO42/vPzTBN0ihk9+my2+\nZyYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNDKULFm1W2gValbinMu1UuqoK+8UBgocPgrU9oC+pZoCIQDoCgu4g3U3\n9SYPtuqfujpkVey5G+YmOmv5HwLPQXBkWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASq9wjI6CJMiUyYFnw0mREC9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU5ZDhmNDAtZTY5ZS00OTRiLWJmMzQtMDMwZjgwNjZmY2VmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDU3ZDUyY2EtNWFjNC00OGYxLWJjYzUtYTNjMDFhYzM5\nZGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE62KcIioztvX9ET+g2y+NXeup\nfJ9mUZiAngOtyB/p3+6Fd8NV/y/oFVqOSE7smRgRpuke1LiLMNGfShlZF5/mIaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH8U4BXbFIAQzV4Sb5yPLg30RRZ8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFhY6kwhy+8FTlCD\nWik6b8Z1H0aUmJRuF+GwljrgeMdrAiEA7z0482vWrSj7O1JTfbXQ1aenKeHbHjPX\n96yRt0HbEh8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2707", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2707` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcbcrk2rZoSUh/6Bkr5i5hGDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2MjY1OWY2LTE4ZjAtNGFjYy05NDkzLThmODljMTI0M2ZhOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQyYTkzOGMtNDAw\nZC00NDgzLTgzMDItMDg2OGJlNGQ0NDI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5KW/HHYs0hi2rvpmHcN7eY7kV0UWCirhQLaE3OXUvlqslx35aYBiwSkkDMQv\nnvd3uXcPSLHM8r/lvqaqZx9/FqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRc23XuTaCCi+O28V3aKb5nMnRzWTAfBgNVHSME\nGDAWgBT3ujvLOOmugEESx2J+H7SPr7a+PTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIArrD9Y2UVm4adf33tSnJmBIVZA/Mhg9\nt4Zozjzq0T9qAiEAmib15bNuU5D06EMR0clyitAJcex/kjOFu1kG04zvb0Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATYwuiRnnTNVKF9BqPviL6PVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjI2NTlmNi0xOGYwLTRhY2MtOTQ5My04Zjg5YzEyNDNmYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToe/2atHuO/AbwxfAK5iH7blDWcPd+SE7K7vEDQQIgfDRp\nHYsHPZ+V+/NWzrtEx4FoqKeefc7iI/FZpf/Ok6ygo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU97o7yzjproBBEsdifh+0j6+2\nvj0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOzp4Wls74qbZVehHeLHNROfb97ex9mEFiTIXHb+4l87AiEAj65zXbf4\n871+d1UpQqKqgqg/4Mlz0gV6f4fb+JIkzho=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAeZlkwGcElFODRjzDhCZk6bBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQyYTkzOGMtNDAwZC00NDgzLTgzMDItMDg2OGJlNGQ0NDI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTdkMDFkM2MtMzIwYy00NTQyLTlhZmUtY2YyMDVjMGI2\nNWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErG02PQVcQueQvn+5Z4OwWO+b\nUNOTvLSMVND3uUQjdAD9ebevDkQ9CnrS11nJ7D1lM4GRulK9Zm85sKBZPBsW0qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXNt17k2ggovjtvFd2im+ZzJ0c1kwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDjyaLM/YR8Z3Nul\nqoeX4KV30kpJ9ms5VH6GhDNc8n4AAiEA5t75Gnkcuk5i1ziHCvDjIpHZHdLijW0k\nMZKh2Tedw0w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2708", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2708` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASj2Tr7AIga4XZIJwGPJ6+x/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMzIyNTUyLTE1YzgtNDZiZS05YzJjLTMwOWM4OWQ2YTJlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY2ZTc2YzgtMGUw\nZS00ZTc0LWFhMTMtYzY0YTA0YmZhN2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC46ccKDUPmut0/a6aEikkCtEPkiwkZ1VokW60BkBsI5t/Bc4MqoYCB8o8BQQ\nrGfVjVqhs2FciK538nO5EfdAHqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdm74rzbt3cCDtf9WpJGy49G7blkwHwYDVR0j\nBBgwFoAUSAwz4YUGWtrjMNVOK5gUyD9FWPEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCJZ63jzPE9\nwtd6ZTgEo33mGYNEQKLdrL7wobdVHX3F5AIhALp2B2BAOs/SYVCwrnUZ+DrqWsaY\nQpaTyM4qihTAhm4h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZtsKGUKIc1aK9Y3l5TEZkHAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjMyMjU1Mi0xNWM4LTQ2YmUtOWMyYy0zMDljODlkNmEyZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk/lgbaJkQB9IK+KZ82Gxy7AiEbki5j2/oqcULmF9xIUoI\nX/dnfm5iIlMn845OvtVG+K2PbOnoignXggswndeWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSAwz4YUGWtrjMNVOK5gUyD9F\nWPEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPcCg6awREYYZw2jGY6e4SD41oiuCVvs6ZnXmgFUCDg1AiAe1CJDlHKU\nek1OzuMqAwRYq9NZWZUCot2xp+R489ruQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYj9nMXqs+oDtVBHF/gM89QXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY2ZTc2YzgtMGUwZS00ZTc0LWFhMTMtYzY0YTA0YmZhN2UzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQ3ZWI1MDctZmExYS00NzhmLWEwMGEtZGUyOGNmNDg2\nYTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7ErjujsjNAMMxiWgm95NpmoU\nPX1UwtmCK0Cq84abl6kQSYIi/4qvNa/wRmHUvfZgHPBtMclMO2qJh7DyiGkiPKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdm74rzbt3cCDtf9WpJGy49G7blkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCzlHOjNSmEGy84\nzhgAejB8eEqOHI6BiyUJYBTBvL7Z+QIgD40KQqll7ZpLUfrZsux2c0Dhva23E5gs\nU+caL5WIaXY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2709", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2709` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAe/QSgjKxhrdq57VKjbaocKxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZGJjZGY1LTBmZGQtNDE3ZC04ZTVlLTFjNjcxOWEwYjE4NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDAyODliMTUtMmY5\nMy00M2VjLWIwZGUtODFmMzVkMjFjYTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELbJ4oRovGYQ7+6ba7TJdhmGpRJ274G1oK57MAuXtAAJwU9DLIWo4fLMtY6+l\nYc4ZPdi4WQ87YZydAniU2dSFYqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM/OLm5in3c5PNlXLYHRAbVoOCfAwHwYDVR0j\nBBgwFoAUsqKMPrcmBK2GLs753Nk9U6HMiDUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCr5L2zcCKT\nVCtppyUEwPiY9j/GI+px3vdoc9nrl/GrJAIhAOR0rvzqnXm9qj41EnC984lWTUPe\n4My4f+28cBBqFzre\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAduyJZs65KI8k+f8IT3TluJBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWRiY2RmNS0wZmRkLTQxN2QtOGU1ZS0xYzY3MTlhMGIxODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJDzh2ATpYkRT5W+bBih9fURoQhap9QEuG8DLVUWq6JT62\no15R0fi/GjPv8CYcS5ao9AAOiP4EefaDdxIgC0T6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsqKMPrcmBK2GLs753Nk9U6HM\niDUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKPpNX5WQKhWU5Q6MCy6rVVXZy0EYmw2LJQEq84yipmICID4S+UjtX5XO\n4rujTWBka4EI1KY6ieANh0BZFR8HSeww\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQqxVWiCZyy4K0uUZUyuBifTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDAyODliMTUtMmY5My00M2VjLWIwZGUtODFmMzVkMjFjYTI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGE4MDg3ZTQtZDc1MS00MWM5LWIwZjktMjY5MDNhNzdh\nM2MwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9g0dZXR+cM6UifvA2F+SOPkr\nyHiwJEY8NU4VE8XDh7EQLMR/YG/gOl4WmUIflZLH613WEhZSTIewc71O5Z3tsqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUM/OLm5in3c5PNlXLYHRAbVoOCfAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICOzLK1VcvPLwPJ2\nFALJkBBRGSMwc4rZe1LsUT7JnJKCAiEA1off5KNZsLE4ft4DCbk1XQtoEmU0UMaD\nn4xKbqyFLwo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2710", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2710` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISATng7txUAgb5ehohEbZSqlDgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYmNhNTU1LTRjMjQtNDU3ZC05ZTgzLTRhODk2NWQ5NzkxODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg2ZWM1Y2YtNjJk\nMS00ODQxLWJkN2ItNjAxNWQ0Y2YwMTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET7wJj/m5P+wWWf1EPj6ynN2e7PbB3iC717U1fIMIN6PT7ne7IVivCy4qGhVc\nN2pNONRgE3DpPVKnHR8r0T/rCqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK9TsFzgBtC/ikEN8vJ0WfsBZFFIwHwYDVR0j\nBBgwFoAUHsRBEursj7OE/Oga0wXXaqen2C0wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBbXz98U67H\n4qpmsN+TRmaU7JFYdn2OgHk9tzV1mNDmcgIhANVNDx9wDDWF+SdztZHKplKFvEnF\njjYr1JLZFP+hl8B6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeYjQ1KgoedSEN1+HD7OED1SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2JjYTU1NS00YzI0LTQ1N2QtOWU4My00YTg5NjVkOTc5MTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyGFDApgGjWqXU5icbe5qVQbfQDWil9eiFBvmkEB9T4qeP\nK8eS9gCVQMKsClAfogNhDESxVnn+l6t6r9GOpFt1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHsRBEursj7OE/Oga0wXXaqen\n2C0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOvfevG3LR3PKpVnUNyA2G84/Flx9Ai2sYg8lCg0scgpAiEAva/QGnVh\nolw+zwFIfDffH49zPr5wXb0YEUUlXf9o5HA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAcoUV0bDFWH6J84743nr+yoTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg2ZWM1Y2YtNjJkMS00ODQxLWJkN2ItNjAxNWQ0Y2YwMTQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTBiZmE2NWMtMmVhNS00OTA2LTlkOTEtNDkwODg2MGE2\nNjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDWa4hCV4WjAKvuYPOLuzKyzO\nKSpjnk0D3jpUT0/3ESck3n43l3XGTHewi9mu3FPXO1KiqlA9oG55TGAbbFD1TqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUK9TsFzgBtC/ikEN8vJ0WfsBZFFIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGN7ivZ3Teotugtk\nUdx89qY/ctlngEZH2amSkAK9wGaXAiA3aO+8ucYmGNWlgiVTV7JlSRnoJcASd+r7\nQBRkh2CuuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2711", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2711` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAf/hds6n2QA3wCKDeLsIP4RAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkYjdmZTAyLWY4MWEtNDE4OC04MDNhLTU2NGRhMTIzY2IxMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZlOTNhYzYtNTEx\nMi00NjgyLWI0YzEtZTY4NjUxOGY4ZGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET8kj4JlC6TGv5AOZbhZqEIXkx7w2H0NLvwgOjCZI/iygO8EWTJ75t0yqU+5O\nWX0i/WWYelmnk6cbze+qlhku86OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw66TCrCDa5pDsJae87tjKLOgcQUwHwYDVR0j\nBBgwFoAUhrPQGynA50piWtj8LkUi3f2b8ekwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA4WBGpeDSfHs6IGgPvyoXnn2gU70WFLS1sSX5G99SJ4wCIQCUBmHgwcCc\nKXD9zH+LvR/klNKFlUvKqplcNEsVs9ZwsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVNTg5gE/Ple0LtNNvmjasqqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGI3ZmUwMi1mODFhLTQxODgtODAzYS01NjRkYTEyM2NiMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjeWy6G3Jj9WT6ggRkYN/jj/oXrvCghbMCiQrnan6fdizL\nj6FayB8yUz0iRlcJpzky5CpPxtJfOeJFsq+RCyJno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhrPQGynA50piWtj8LkUi3f2b\n8ekwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI22d1NBLuqczJmhn/GgZWTHbl4ygAtJUxsXnvTWez2dAiAY9jGLMavM\n4Jfhuijl3vUuucVQlMQDn5/k7iF0oLsX7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfANzZu4qadYxjyHZv//enJEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZlOTNhYzYtNTExMi00NjgyLWI0YzEtZTY4NjUxOGY4ZGQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjM3ODE3YTUtYTJmNC00OGE0LWEzYTAtNDA3ODNkZTQ0\nMmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGUtr8Wim8a6hH50+oisiIQi1\nwrzqSqrLLgawlYCsGQOFfP3f+mQLTVZ6lANbHFsBxr4aBsLysJ1oQ3E+CDUOkqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUw66TCrCDa5pDsJae87tjKLOgcQUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBzX230v0z0EF9Dn\nd5BhqhIEiFOCgF4CKzQKyW1GVnnNAiEAlNFammSGZHg437pgOU/GUexweqfS87C2\n3z+YAOVK5Rs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2712", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2712` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISARvje3pu1evHv3wwH2Ica7rKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MzEwMzJkLWViM2UtNDg0MS05ZjAwLWI5ODM1ZjUzNmQ1ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNjM2Y4NGQtMDQ5\nZC00Mjg1LTk2NWEtN2VmZDhmMGZmNWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzJoK4/jWWzL+fiyhSRgfI7/jac+YybUuWNdZ3fttzZH8XkSwnNJSdCB7g4y2\nq9xxg+HOmq1X+iuqjaCp3eH9eaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjgQ7DXqA66S9WlGOi6l8+wpct1MwHwYDVR0j\nBBgwFoAUjReeDp1fG7OqLSKzCXeBr683CzMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiBioqM2/cJIrE0xHljBlTV4qqH53gCJlilaYzpmsZmtGAIgYRNLsC+suwY9\ns+5O0hjJMgwhP80krsXss+BAAQeOvFc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQgUI6zV41N9E5Xt2TN02MjbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTMxMDMyZC1lYjNlLTQ4NDEtOWYwMC1iOTgzNWY1MzZkNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyDS50I6zB9PHv+bpUozV7LOSRaPeN1RIHkFPh+R/Xveee\nTWVqUOkPH55uXmpozbrGTNLbk3rp0dDLzL9hcb1ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjReeDp1fG7OqLSKzCXeBr683\nCzMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM4TMhtAXUmriDb7XgPV6DZmObsjQ9I12khmP1tRvVAqAiEA8qayo9j6\nP5qTy8dWKZXgvCkdcFWyhMixKDAgkDntsYg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISATGJ1ePSUGfXVzOZhxeffN3UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNjM2Y4NGQtMDQ5ZC00Mjg1LTk2NWEtN2VmZDhmMGZmNWE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTY1NDBjNzAtOTRjMy00YTBmLTkwNWUtMDMzMTFkMWJh\nOTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESgF9/JDMnwR3xJy4dzA3GdCX\niVDByRaoQKE4R6tRipWDyFvXi76MFMg9Hua99MVQRskVlP7qL0tB46LRBdD5HaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjgQ7DXqA66S9WlGOi6l8+wpct1MwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAitO8311ghuFDpx\n81MnslU1MTw52tWejaJmFdDf5azdAiAbxgTxirlKDBCqR2YsZc4aeIgPq1HFdpl0\nNXoRw5n90A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2713", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2713` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAVbLocVgQa8W6u9pXHn3iCBUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3MDIxNjRhLTAwMDctNDM4ZC1hYjBjLWExYWI4YjZmNjIwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWEyNjFjNWEtY2Iz\nMi00YTAyLWEyNzctMDAzZmYwMWM1ZjQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz7wwq00yqA6XtoaCvT5KnayahE/PGCntQYi6vaAySUazB5L1W5xLTyZ+YOuA\n5JaatJnvruVrIpjrUcBr+wAUW6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE9E59eHHi2CUpiCwgqYFk7ePqeUwHwYDVR0j\nBBgwFoAU7k/BVqF07EFv4I4QDj/iXgGn/WEwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\nkw/J1Ocl3XoH13jM+rkjTbYGWSSz6ZV0rHZKJPtHNkgCIQCM5tJftiiMenR3dljg\nlIW+KLHCTYqpOMqM2e7yo1/Y5A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAckVItsZZXJBTaxzAcF/MtBNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzAyMTY0YS0wMDA3LTQzOGQtYWIwYy1hMWFiOGI2ZjYyMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARazM2bMHopP061aPb5wmJK5o1r3MWvTrXKUYWY5QegnNqU\nxN+O/aInUVpvlpv7YDd5JQkHeNFjH9uV8ltRGAtuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7k/BVqF07EFv4I4QDj/iXgGn\n/WEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMQehgkjsaZXI/q5HCH7TqEy+d4rxQ5y5C3u5KzrOI9ACIAH0vVeABy9K\n9j04mMuGoDghdbnndI9RstovBsD9zMta\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISARIf7cguZrHPWekTdvtS3H+SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWEyNjFjNWEtY2IzMi00YTAyLWEyNzctMDAzZmYwMWM1ZjQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDdkNTVmZjAtZGNiNy00OGM2LTgwNmUtZDYzMmI5MzM4\nOGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZZXT8nSokUn+guY1NHEm47mV\nBM9AYnaYcQ9TI1Asp1fxZtTBdrwDPeCPtfIDwIhsbVlksWoiSvddiFOerVFGWKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE9E59eHHi2CUpiCwgqYFk7ePqeUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDI2T4u5wWMfBLS\nlme7vdOHc/NUUqp4Rj3hh2gT48xEkAIhANmTVmWsTZCOhlfo0ikUuOaC1+RKAHUX\nhjksfYEvTJED\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2714", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2714` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVQkZJtRh/K/D22oDd8J+/b2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1N2I1N2EyLTllM2UtNDc1Ni1iZmUxLTJiZGIyZmEzNzhjZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUyZjIxOGEtMThh\nMi00ODVlLWI4ZTEtZTdiM2M5OWY5MGJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVUHJF65zAb5MxJKnqIBDB2VeF3ANKtyswC51OFiLcAVRXhbY9DkYqRxMEpoM\n1XOlNJs3+8QKCvTIetexkD6OYqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU242lI6/zZcy16td/4JgQoehgAZ0wHwYDVR0j\nBBgwFoAUsgDA4c9NRzV/Mlp/KuaTLPuGuOAwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEArTcwDttrDu4JB5g5FnUnOna8nkfMgUnv0H17kOlUQS0CIGiT\np4I/zx3z+rBRtRulFyQNdyy09s+x3TfE7UQp+59D\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYKsX8+ZNxKyKNwVW+R0EcLNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTdiNTdhMi05ZTNlLTQ3NTYtYmZlMS0yYmRiMmZhMzc4Y2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZwUSmpIFqnDOJW9GMUVBdxyMeQhUgwNjbfpd1BJXBrGkK\nypIn7eURsk32l54oWNFu0fk5P0aFrlS612cSF/lXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsgDA4c9NRzV/Mlp/KuaTLPuG\nuOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJr9dlK66evn3vax1B8c8ysGNilWxu8WbJCD3hTgALDsCIQCQuA3/CLnL\nCfDWT+Uw1EvojlTYfq/a/9I3Vdjkz8Lczw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZwiRTFESD9i8XwZblc5p37VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUyZjIxOGEtMThhMi00ODVlLWI4ZTEtZTdiM2M5OWY5MGJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWIxMjNhNzktYTI4ZS00NDViLTliZWItMWMxNTYzZmMx\nZDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEe9Mi76ZCiO/jxLjYhv/qdfjw\n90P/XADv5Rz+Bns2Kvs3ArGkKoKiP8fzOFMBdgIYcoRM6etalBiDEkPvzI1eJKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU242lI6/zZcy16td/4JgQoehgAZ0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGgafdRY1ca6KlHt\n9X0iNsWCQPkRLJnZ3sB6dW/fO4DtAiEA+KY80dP5QNChfj9fOfuUAdzME7p9mntp\nsfxdJ9jSLTs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2715", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2715` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAatRRA6TqZsF2w4l82q2t7PRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhYjM1NTcxLTljZTMtNGYzNS05ZTA0LWY5ZWI4MTk5NjQ5ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDcyZjFkY2ItNWYy\nNi00Y2U5LTlmMDgtNWViZjhiY2EzMjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP14EU9/joqI5SFK9gEdDGCuNl46/5dh/mqX0CJk4nGTCYpZFUqDYZXBknWwQ\nJjqauvv6yffgE9NGmCOigI+nUaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ateRstfttxx9jaJvuGPJ6/LGscwHwYDVR0j\nBBgwFoAUL4mFIfHPC3TFi4Q7yLFoyRBrlsgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBjJ6/EAgjqM8PcWdg/9+MZ8o7nVzPhzpQZ0s9CruN5rQIgNATi\nPGdYkWW4FeMu3a8BMzHCrhhbT1Nk3/FxWBdXNSI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAce19ZRbn3PB2mz4kbFvTaL6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWIzNTU3MS05Y2UzLTRmMzUtOWUwNC1mOWViODE5OTY0OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATf8wyFEfSG8Tc+AymSUiSLKhePUCStK1lgdQ9juR44KWT+\n2a7okpZcgiqQlaDy2knI8a5hHXsxTXC981Pc3U3vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL4mFIfHPC3TFi4Q7yLFoyRBr\nlsgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL2F4DdtQB7dEsaPIh81n/hAMNKSAf1DbIQz33f37VsGAiBX09qIstsm\n5KQsVnk3WG4+uMpytiWqRFMi29UEFy+3mA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAd7tZ3p5+4vILE+wz4tu0X/AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDcyZjFkY2ItNWYyNi00Y2U5LTlmMDgtNWViZjhiY2EzMjY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjUwNzE4NjItZmM1NS00ZDU2LTg1NjUtNmU3OGU5YzFk\nNzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0L4g9ENBQQnqzVxmulSvPbSG\n47XF1kOgh7PzjduqhABdMKmtLpuRwchmP3tOOKJVUYZyHoQ7Zq3C63uQ/VZ/H6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7ateRstfttxx9jaJvuGPJ6/LGscwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDh8lIve5Zxomj8\nCGPn/gUdUw+3pzla/E1llJJ1tMpwUgIgPLwvM+VVJxyTl837sGfdOxcnbaZwG0uO\np7TlNd0TlCg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2716", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2716` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISATSQCWj7TP+F+8PtUo5Cj5bzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliMTU2MWIwLWM4ZTItNGUzNy1hZGJhLTI3ZjlmMWYxNTRlNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFkM2ZkN2ItZGQ3\nNC00OWFiLWE0M2UtZTBjZjFlNTE2NDY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOVEXWK5ODFXlsRGwa4PTbiL6MRQif79ZKiNIdCN4T04+AseH2k55O5NvdjL0\ncE9foenlOR4R13h1TUnzoUgO2qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrw2vosi9V09sPxKZGWjNnHevnFcwHwYDVR0j\nBBgwFoAUs5J9kX/hvYU+nUxDMn/pMQsLIdgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiANZYumASc4unvc\n9Mf+INwDznfNn7GMwj0xfKRdVZ7scAIgOquQ+AzalSqWx0WtWJxZyd3cV2mjiaxm\n8tLTO4ZL53Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUqTgCoircJK3rdij1lYXb5nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjE1NjFiMC1jOGUyLTRlMzctYWRiYS0yN2Y5ZjFmMTU0ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQU3iSTumcTuUK1zP0vydK2ekQiRSWtBgklxqM0GvDXiEr7\n6iOcyKAYO+4W2QZo9EicjXdITUsAUpRQyNVyYPcio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs5J9kX/hvYU+nUxDMn/pMQsL\nIdgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMJzDplZOEN3s3wvsqZq3e3ql82ZflzGFuXxn1eRHkusAiEA4b2B6n75\noMr4G5BifuJUbRQegrf7bpjUH9MiX9hskFs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZdskpZz7yA4CH43MJuEoQfvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFkM2ZkN2ItZGQ3NC00OWFiLWE0M2UtZTBjZjFlNTE2NDY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTgzOGYzOTQtYjdkYy00ZjlkLWIzNjctMmI1MjFiZTRl\nNDBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtEgnho0i0LHpj8Hp+H/i7ZlC\nPokCO+8z1XDSDEpIu17CqUoybX8lZku6f+CNSzJkEHoZeK3+ARBDaGAITzNdzaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrw2vosi9V09sPxKZGWjNnHevnFcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC2Nu7pjWvn2yvD\n6HFuZ4L0szhOGTC026mGxwjZBnCabAIgHDjZMjX3HmNH31oGT38heGYKwVxSOGmw\n4sYx7MYPJx0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2717", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2717` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAQ+mtiEbwSIDaiW2LESqefw0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwMGM1Y2UyLWJlYmMtNDc2Ni05OTA1LTRlNDUzNDI1Yjg5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNmOTdlNTctMzU2\nNi00MjgyLTlmNTUtYmRiOTYyZmU4OWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6EfYprjczkwci2gF/17fJTI4BMe8h5mx3eUDljEyZDlCV9Rf73Q8yiv70dDl\n/T0iQ2rtApGxfyWxpK3JPeCwOKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ysD6OYh4fsUYLb7kJ+8jSzRXjQwHwYDVR0j\nBBgwFoAUQ6HprMN68grNfINwfDFZwxhVGZwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCmRgfDVQruozH6T5Vd4YctkocJkYkrrqZPeyedM+OwlQIhAJA3skCznCy2\npLDKiydWCbx7MyYWpGgPeexKKltVlaCz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATDqKxyt+vxNgZiUckSHug5TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDBjNWNlMi1iZWJjLTQ3NjYtOTkwNS00ZTQ1MzQyNWI4OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEXHVE45HaMJI+cqY1CmEeDxaQWPn7M9mgtl150Yf+hCss\nUTyft3gBNMIoow5E5cnmv1ShCVAV9n4ujc8EjqZdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ6HprMN68grNfINwfDFZwxhV\nGZwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANPaCmBux/O9hwJa8ohUyncUrwduZIIa5VJQ8THWHABaAiBJl81XUUTh\n8UsOdzEkOYqZNbFEhNs+4+gkvucWfaw50Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXSP450bnezYf0nj+/LLGr6TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNmOTdlNTctMzU2Ni00MjgyLTlmNTUtYmRiOTYyZmU4OWU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDRkZmE2Y2EtODc2OS00ZDBkLTkyOTYtYTNmMzJmMzVh\nYmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE355IxfR8bA4ahSHNXcDrcl6t\nyH6k4hyQqrez/nIE2ky3SdG0DkpAFU03sMZkjegb6e2DBlAUq1FaIGKp9lONxKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4ysD6OYh4fsUYLb7kJ+8jSzRXjQwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDNB2/a8GvH20mb\nCacm6EUGqPYTPdOhUDqb6NeEgX7ixgIgOv5PXq+ja8Za7ReY/5PWSaq3pS3p8bio\n6nJkcd5DuiI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2718", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2718` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAW1RkEw7GAblYjdMVQMFVJQtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwMDI2M2MzLTRjMmMtNGE0YS1hMTk4LWI4YmIwYWI3MDRhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFmNzE0YTItMWRm\nYS00ZGU5LThjOGEtMjg1YTg2Y2YyNDIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3mZCc4AvhBAJx5dizi+wj8ptO7iAgLwcgqnIpWV1HA/xVfM/ZawMHN4VejSV\nCE7q9josAKKvFPyqDovS+odIJKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9PZjOYnW8Y21POtNptW4q5b8YPQwHwYDVR0j\nBBgwFoAUPOfQ58VdEYNUyoC1Z+UN4x+0Yg0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFnKP6hudsW/tc4uKsIdmNaLvQ8qADEDkp2r2i6LqttSAiEA9wsDxSjLzQ4Y\nXE4VlSnARvmlV+tKfS1KDqlAgObcSjQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATWQpD/T0LqDLblTmTL2yhBFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDAyNjNjMy00YzJjLTRhNGEtYTE5OC1iOGJiMGFiNzA0YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQql6iPN+qYjV74HuNEII7nDe7Te3vvrnmnEHrXoW1bRGNL\nK8ogO1eCHeqt8xPWTZg9eSK0PE5I3FeC2Pw0WYQ8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPOfQ58VdEYNUyoC1Z+UN4x+0\nYg0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEVdtZYwDz2xeHYX8Frm9wLy+jiVX0MOFLeJ7IgZPGysCIQDloJfXIMrT\nuQkEHo3TnE3ccVDCyelKfRqRqR1oBPhdNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAXld839kz31m7OQ4AtDaEgNrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFmNzE0YTItMWRmYS00ZGU5LThjOGEtMjg1YTg2Y2YyNDIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjNkYTkzNDEtNTZlZi00YTg5LWFiODMtMTZlYWQ5ZGE0\nYTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVVh8bJ2dBaDTsbE5cvcCIQwM\nqCjRpk80mLDN6Cz/z7fSWVJRBXLB8mGa1XerWNkmbxFE/UO5I6ZTUAfYdLiRtaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9PZjOYnW8Y21POtNptW4q5b8YPQwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEvWq9377sInLRD2\nvjxrjE9v7xzG/UZoHgpPD3ALKSGWAiBzKxoaO/ZRzvxT9mKqO1R69UTV91w/Yaep\ntRM1sWXVbA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2719", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2719` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAfe4afMUnPdf/kRUTfmdWJudMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiZDhiMWYxLWUzOTEtNDhjYi05OWNmLWIwMWNkYzc1N2UwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E3NTNmNmQtZTIy\nZi00MTQ1LWI4NjgtY2EzNTBjNTBjY2M3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/RdQC+Zcg59Ev0AMmM7ua6IzrVkgbfYxmO5zHAyu4uHuIvQO5Fv6KwqxKsB+\njWJ2eSxKdlvR6TFAH+yRhzmrIqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAS9AMLJgmCD0np6AE/0II8sPYVwwHwYDVR0j\nBBgwFoAUioXowK1bj9e4k4FWixTTRbgTlhkwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAi6d6Bv5AgrPRI5vA9mfUc+azMgjFpKYCqrF/EqEo4IwCIQCfyUgC4ktF\n0OMHOlBV9fkkkP6HNdQkAGzwyPv70wI96g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQXh03mgZwubuwNjd4A3xM0KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmQ4YjFmMS1lMzkxLTQ4Y2ItOTljZi1iMDFjZGM3NTdlMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCgOiH/HVogomE9rBf6VMHnYIad4mGgO1zzv8AU3G78Uyt\nihCqXs5JVMg0JxSITqQ2nh4LrCiCTnj3THdBqYW0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUioXowK1bj9e4k4FWixTTRbgT\nlhkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALSFy/0/m/hZRbi3peKKCFM4EcCs9VaJD8lA7sy+aIEVAiEAhC3UPhpm\nS38YVq7bIIhUBg/PU/FxE4LNaNFg+UgiayY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQi7OotLBlPWSkK8wofJV3ymMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E3NTNmNmQtZTIyZi00MTQ1LWI4NjgtY2EzNTBjNTBjY2M3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWYxY2UxOTUtM2NkMC00MWExLTg1NTUtNDQ2ODcwZTcx\nMzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK3VB9r5d4t6nBCLMrn1N+ydQ\n5lF+8EjOBgW4DAIXxONrIZXJa/AfiWGlECBYO5yZR8GkoJPvsa6nUknKEYPvJ6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAS9AMLJgmCD0np6AE/0II8sPYVwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHFsUF9591oAP1mv\nXJXePSuu/wHH9/i0DKWbJuhtQ33eAiEA9jGy5U/Q3jBFa832A/2wgAbKG6WlSSK3\nlOFSQw8NbEE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2720", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2720` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVYhlqnAPwuGwY3uFH20EvK7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMTM0YzVjLWM3OTYtNGVhZC1iNzg5LTc0YmQzNGRiMjFkYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJhYTE5YWItNDUy\nNS00YjQ3LWI4M2ItY2ExNjI3NWMwODU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIA8wULW4IiVrbCys7tfEvddLhhLsY2FqYkDO7Ct81scGZRTR+chrPGqHJ75D\nh2Xtg+nV6h21YCKiQQdrtN9RAaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBSCEEsy2JV/yaiR1PKOqz8DcVFAwHwYDVR0j\nBBgwFoAU8po9nOE3TLs7FTI/Z5sieSeesS4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA1DgvmA/Ny5xzLx7sSlT+0ilrmopFvDXw9mDEDzut\nAtICID0lweM0vUFyHHW41xbpSY9zbHMOuASEcc2+O6tGdsFr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZKekmWs46L6j6Uju2XhlYqFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzEzNGM1Yy1jNzk2LTRlYWQtYjc4OS03NGJkMzRkYjIxZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrfRKlVIX8Oum7UmAqrUGt4A9XLUOC5YMGy2s92axn4I6o\nHyAIzr78Fq+Vvv0xIBSP9CH65dLFolGMyC8DMcGko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8po9nOE3TLs7FTI/Z5sieSee\nsS4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLIav344SlD9Ro4sc7T46SFBpheBM5UyreQb+TGHXh8cCIQDiqKEMnxwa\nlrloCmViBq7lnsGI4juNCQEBzKOGDoWrgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASbZ+2uWlReXApIzcSO1Zy2lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJhYTE5YWItNDUyNS00YjQ3LWI4M2ItY2ExNjI3NWMwODU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGFjMjc2OTctMWRkYS00NDMzLTlmNDQtNmY0MDdlN2Fi\nYTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH0oG1HCzEQS8xTPMA4R8aURZ\nOjSDMgvJaIvF1E9qtuW7axMAs+G4jFTry6ZCD08ZbhuudOWY3rlkjxNRTFiniqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBSCEEsy2JV/yaiR1PKOqz8DcVFAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEv77gVOB/bkrpcm\nUKfIBTs6uId2TITvsSYzAPLhfA1XAiEA21OKvcxQdes5PURFTrqeAMO9QhS+0wL2\nwY+WylSnao4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2721", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2721` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZeZrROE3rD44eBsRQTjWyQ3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxNWVjMjgyLWFkMGMtNDRjNC05NjMwLTIxMTI3ZGViMGVhNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA1NmNkNGMtOThj\nZS00NWQ1LWFiZjItZmY3OTM5YTI5OTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9SnGbWh9u2t23jBfHz9/sxfBM9cAIRpdVayBx90q1YzcNYWwVjl4aEjQWwUF\nedqKX0eY+AObUE7FcQC4iT02EqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDBVjd9cB5cMj1AaV37tE96lfBTEwHwYDVR0j\nBBgwFoAUy668EWl43y4ERmWCC5kICCBGbl0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiA4AOcXfgsaWFQ7DbV4/LsLoXWNpOcFfKhNbdXkxW3v\newIhAITcCETjUyzXzbu+d+R9nDU+CZ6L4lCWyRtfY0gEshY0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWyXShZ+vwLBoxqD4TqM+yJOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTVlYzI4Mi1hZDBjLTQ0YzQtOTYzMC0yMTEyN2RlYjBlYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1pjIwPnWHKeebDjJMDJJDzuzNiO9Lc4iEZSruvhYETcbA\n6LSQxE55ZDbI5MOSwDCsmJCPyEbyt1p0W3MDq5Jgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy668EWl43y4ERmWCC5kICCBG\nbl0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLr+n3WeqWuYeEJUqL3Tq54v0s6bSbxI3w1cFxTaGqvECID0qI9nnSd7x\nS9G+idSsAnAml4N77ZD2GS2VEHciNId+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXfzbG3GWEEC413NZo7LsZrmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA1NmNkNGMtOThjZS00NWQ1LWFiZjItZmY3OTM5YTI5OTM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTczM2Y5M2EtZjA2NC00NjhlLTlhZWEtMzUzNGMwZDAz\nNGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1VgfOprKPZJW5kw7RMXrFoye\nEvTqXFnzxbgDjqcud+1pvfQJbCuHNCcnszmh9cTu/Ah+rRb3nQYOYZ/4vdTLFKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDBVjd9cB5cMj1AaV37tE96lfBTEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBQPWdZxULt/b95N\nIlJtz04WsPXyZ9jVHQ41TPdt7lulAiEAk1eMKzUdjEHy1lytrDfivr+1wKh88TXE\nR1Vp/fRG9f8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2722", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2722` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISATIolY3JIGIhKpTeTBYKWWRAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2ZjA0YTIzLThiYmYtNDAyNC1hNDY3LTMwNjY2MDcxZTdiOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThkZDhhMmQtMTVm\nMS00MjQ2LThlYzgtNTkwNDMwZTJlOTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqIvOD1dAvyu0K+6bXU69B4HUXC2yk/YiMmbv/7X8MRjydq3O5nKYvIGpM818\nAB16vWkyglL+5NDOvY617cXpTaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3idW2AkMUSTg4BSer1K2uBZQhH8wHwYDVR0j\nBBgwFoAUWpozf7PYSsb2wWfPfchcQbmgkYcwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAz1UYHbEgwpOfWtKlA7Nwdav4yCqKbpM/ZxIBYMUZMAACIQDa\nVWpEtV3KIoBZ2wRl1CGkQ6H58c5D4ID79qFNsmlHmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZKZZ5TCXqWy1o2SKq1JgakgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmYwNGEyMy04YmJmLTQwMjQtYTQ2Ny0zMDY2NjA3MWU3YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaxEeafWOdiec0VSTnDmV8jcdwazs5kyvuwFtKwRvBCWzY\nFXl6AYcCFKTmQ1EdjkBrK3LQ9qTa4MkT2As3dP3qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWpozf7PYSsb2wWfPfchcQbmg\nkYcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPnhTKdg7krsBQXKr55J2fkN6kXDN68ZHl7/zb/kNtxwCIQC+fYQQdleC\n/sJvMtT1ZPqx8dgJTS9iso6P1OSPmmr18Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAXpk/W0Z84jG/2kaEqntqZz0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThkZDhhMmQtMTVmMS00MjQ2LThlYzgtNTkwNDMwZTJlOTM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWU4YzhjZTctNjRkYi00ZDQ3LTkxMGUtYWU2MWMyNDIx\nNzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzsMcWNjid4CsdyqMCKa3evOL\npicgrxr5IWDMRHH3kan0Ib+TfDRJ90LSO7eUCsIQVx2EgDGRNrK2DBSKNVWlJqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3idW2AkMUSTg4BSer1K2uBZQhH8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCObRXcBZ2xIJEM\nEMfNd1DfzeQ3Ep6l/HS5D074OwuMXAIhAJppvW/rB3pfDqWeMsowvMwZxeg6ldB+\nh97nK5B+MnQK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2723", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2723` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAb13Jn5Qto8doWUE7J0axGq2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiZjc0NGQyLTNlOTktNDkyNC1hNTUyLTRlYzdiZDBhMDMwOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU3MDA2MGYtNmZk\nZi00YzRmLWIxNDktMDMyODI4MmE5YTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7P4Ze1BHdJFk2melb3Fmx0qWzckLPnYmG3FljT4jB3C0QEkARJm8UMHL0POh\nt5hrtxa0VJsyPRdeeWlAucsbraOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8+lzw7nPp2/fdHDzzWaVC+7FYdswHwYDVR0j\nBBgwFoAU0jD5TpqGj5D8p+r/S/O4sOVXbccwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAqGuRUdtXadnp1zTP7R9UXptSKtdIfGUH7\nu68hHHoKeQIgQfNOeN64QMJl6MYnRzpJBy33FrzmYfXGPudlBGjCPik=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYyye8UZtDaMJ6K1MjIl/42QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmY3NDRkMi0zZTk5LTQ5MjQtYTU1Mi00ZWM3YmQwYTAzMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQX0MFnSq8ea8MkO+aUCTxU24FhrqjQNGeiaooQcqWdhg/5\nsEWbbGPZ2V7tABM2gVMXbq7G3Smh107BuDR8JSUho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0jD5TpqGj5D8p+r/S/O4sOVX\nbccwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN0SqvTlArTVBMWF/KK4cXVZVWSwzpdQtvTKfHXzcElyAiB/t9sPdzrz\nFz6DodCryx+4MlrOFdeTZOiVWiTnF7ZqWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAaDZD1QPX8Dlj8Dgd6YQabhmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU3MDA2MGYtNmZkZi00YzRmLWIxNDktMDMyODI4MmE5YTllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTgzNWEzMWMtOWJjNi00NmE1LTkyMDYtYTMzYTNhOWRh\nYTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXCffY8QIIvZ/6P//9dmiEd/Z\nda4fjOTgHO9XwzfRupLbtkCCfLRPuT9QfQmTX8GYGOEKXpB8TeVaogyp2nVc56Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8+lzw7nPp2/fdHDzzWaVC+7FYdswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDoISR4DRGAY0xt\nJl8j9Y0qrup8Yn60Jz4OjxoLGYBtygIgUhhIGmKP3WejXhHbFthlA/hJU1EY+AR8\nTHqAaTjs/A4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2724", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2724` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAX8q1H3LZ0ex0YPhQBKvfbGXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYzVjODAwLTEzNmYtNDBjNi05ZDVlLTEwZDM3MGI2ZGNhYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTcyNDY3MWItNWZl\nOC00YzQ5LTgwZTktMDIzNzBmZjYzNzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOv2VYENk2iFEwFUaXaHURW0qZu0ofQrubHMwsU4v2U0M5Ygj9bw7ddEI/B3P\nX9lwDCIybLoZ1xmbuEHZfk4HzaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8vmscsCmyzj15LY+mPnQnAQxLUkwHwYDVR0j\nBBgwFoAU/xmI6TFjMf0liVwecI1yxv2hYz8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAz3j3FXncuR+6OeYsS4HlerlvU1Oph14J\nA49SvFUo1HsCID9klcAk7HJAjZcyli2KohtJWPQ+1Gl0UjgaxZpcReSS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdWENbcL2cNdskrePqtBFtvxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2M1YzgwMC0xMzZmLTQwYzYtOWQ1ZS0xMGQzNzBiNmRjYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsO2oI34+fUje4CYiM6wlizyNcvXCZFcTkpkhPMutBGmly\nNEw/93t+MdbQAnYHU0S21vVDBMwd2u7jzyDTCzeoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/xmI6TFjMf0liVwecI1yxv2h\nYz8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWBUQQVwbSl2YPDzhXSnl8DeoaXofiOzOB/3ZwApL0SgCIQDRQFVg+k6l\ngARWAbMz24FTHWiEnaRzIj8bicRqFYHSzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAQK/fY6pZN2S1wKvdslOTFRWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTcyNDY3MWItNWZlOC00YzQ5LTgwZTktMDIzNzBmZjYzNzFkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGM0MGFhMDctZTA1NS00YmMwLTk0NDQtODNiMzZiYzMz\nNThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErUNdTFdxBax+2lO1//ikNt96\nirXm3OvlkwrY7M1hIYqRXgQCUXav1lOHOfyEtRhuFrl0VPodhAYAaBjfJ3bcvKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8vmscsCmyzj15LY+mPnQnAQxLUkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCi/HhP83XhVfoH\nkzkg3CgqgwjSrpSxYmJRrnjRBOZwsgIhAKsspZRjl3TCF46ZWZPK3qwQEMXPT0CD\nUe6zilVUow/z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2725", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2725` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAaRGHReRO1rPyl0/pjSzEmrFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmZmVhYjg5LTg3ZDctNDRjNy1hOThmLTkyZWY1ODUxM2MzMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWU3OTdkMmYtODFh\nNy00YmRlLTg1ZjEtZDlkNzdlZTZmY2IwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMzg8z1NWIj69y+4QeV3Ropzlit/sNENZUiTSnDKruZvZsQmhDURLp92cu8jz\nBNAQO4tVMQdabgf2QQPmGZvrCqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNZeD0y2LEZz1Vtrpg911r1CweVEwHwYDVR0j\nBBgwFoAU8rPlunx0tUKZ5roXtSavF5LzQAcwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA/TtfGstJM8Q9x\nPQW6s3HpIWOvmWhY4D20UfEgsguqtgIgXz79iCRFP4nd7qUl8+ORoEYOuqgMTV0Z\nVMNX7fpSW44=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbKjvqMQiJ24AjESfevSt6+uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmZlYWI4OS04N2Q3LTQ0YzctYTk4Zi05MmVmNTg1MTNjMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASR8csqOfG7FwxmAYVUYJ+KOF9xzDWrioWeO4EXrnQLwbfF\ngv+YNdJBfK11EoYbcvxNMxTVtjWRgBnPHscXDIvIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8rPlunx0tUKZ5roXtSavF5Lz\nQAcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMS2/qvvStQMH1rPUYmJCvWJfSOyzY6DuWRZzrBk6mSICICyZEM6KcnZw\nFOEauM7x3918jiy7pgrZUmQqPtEm33eg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAaNFB9MgU+J48twBiGfLkTRPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWU3OTdkMmYtODFhNy00YmRlLTg1ZjEtZDlkNzdlZTZmY2IwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzc0OTVkMzMtZjcwMi00YjQ2LWEzYmQtOWE1Yzc1Zjg1\nYWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6/04ABw56NOj3u7H9NqE8eXY\nGuwTG5RFsWkk9vGZGIHqSj2COdpjrSVuJBCeFNf+1Q6CxpMiDswysjIITxhJ1qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNZeD0y2LEZz1Vtrpg911r1CweVEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDiEQjDFRKZyqn9\nU1zlW7JLEQKNlyVrbt+mrql6a+UiKQIgK8CUYAhSX2G3uzXmqFSUCELl7RAwwzH+\nOH6U8Qn/uK0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2726", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2726` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYpfJJKRo8WPgi07A1CG6MfjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3NmVmNjIyLTQzNDUtNDUxYy1iOTAxLTkyZmU4ZDNlYmE3NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTFhMzFmN2ItYTU5\nZi00YzllLWIwOGUtN2UyNzEyMzUxNDQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVp4wKQkFdicJownEKzpcdWDSFrGAJuNHSe3DUehFm2JSB3EAaLu3nq5pQ7N5\nKTZS5lUuNBASsdrdF2UKIFJ/RKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPwlsVeI1alONjVKbzakWx3qodF4wHwYDVR0j\nBBgwFoAUZu9yB1hZbKP+is90a+IU4/lh+gEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAzsKINbkuf3zwQslcE0pHgXO4SfDfgv8SltYMI60eBwAiEArmFXd7jMcZNZ\n9w1GrUf20GDQ02hJcq61vOW6OgHD56w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAatQGSB3BJsA1WTrd569hvGEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzZlZjYyMi00MzQ1LTQ1MWMtYjkwMS05MmZlOGQzZWJhNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmwsa/IB/F3I4LYYpaXA+ah48Y8L3E1vekOJlIQSJVi89e\ns8cqNrS9aMoXIafxqs9szMDQHIUSeRVwg23I8sELo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZu9yB1hZbKP+is90a+IU4/lh\n+gEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJuX4+8AFAEGtuX7h1GKM50Vr9D5SKqbJtecZmXhYsSYCIAGWeC9/CtpS\nYltlygeHcy27bKJVlvbLm+MSv1NTsHfU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAVPBEj1WxkU8uCfN4uNjdeN5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTFhMzFmN2ItYTU5Zi00YzllLWIwOGUtN2UyNzEyMzUxNDQ4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWI3NmE4YTAtNTJjYS00YmI0LWFiN2ItZmIwNmQzMDdi\nZTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFzUbmzOCFy/nnweVpjCY+CqY\ndsxg9LkCWjQae31pi5qzP4GADGLIkB+FgVA8Un86E13KzOjMMVjocREPdLzTkqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPwlsVeI1alONjVKbzakWx3qodF4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCkvtMxnP1r2LW4\nV5Sh4CW9IfHtKIbNav883LhRQwF2xwIhAOSQoBPq++bO0uxaZdq2TwXeIIrIZk7+\nFk2vqOVVDYmx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2727", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2727` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAR54cNqoqZTzLtlQm03OHGysMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViNWVhYzk5LWIyMjItNDVkOC05MmQ3LTVmYTM1ZTQyMmYwNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjllOTY5YzktMDg3\nOS00OTVmLTg1MDQtZWM5MDEyOTI0Zjc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwoH+N8SsOcIf0a7/LSFjC5xG1krW/wSnvK7kNOynGoBgzPFY+1wxjIU8j8DL\n7SnQZYSXYxR1oT6pY1Q8wf8aSKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEywDnRm7nfTkbi6G5LttHVVWy7swHwYDVR0j\nBBgwFoAUFhiXocDdSzJRO/Moa0ipg+6Fm0wwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDHzUVvNDWlxhKZzL3EuSZDDTk+riV8prhHm3eaYUg2lAiEAmL9RAODWqQ3F\nDe+scNefYixsETYdCZ+00x8sFdRPdd4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZbSqjUbF8gxTkOXiyk9ci/UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjVlYWM5OS1iMjIyLTQ1ZDgtOTJkNy01ZmEzNWU0MjJmMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfglUNQlxxYSprQ2n639LZLLhb5xSrvL5eoAbS5T6t3Uud\nNFFcPEmGutT2NCr1rM3qJ8uI7/AFkU7ceU2Y52cJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFhiXocDdSzJRO/Moa0ipg+6F\nm0wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMO8o+ZN4NLfGNZTrh/XU1453akrv9yM6It1YqkurHV7AiABl53P1IZ7\nkZirERZ/hGLEDXUeb/hDdJPfIuwglSRfkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISASmKH2zh1IvQEGstAJPQm82SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjllOTY5YzktMDg3OS00OTVmLTg1MDQtZWM5MDEyOTI0Zjc0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzYxNjYwOTctZmZjYy00NGIxLTlkNDMtOGEyOGEwOTY0\nY2MwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4/B26KBNBDbivcNnIm5udOGn\nd5FK8MuAWq1shsjP8PmvqHpa9gsXfYJ04SLQJY+3KmPOzDjOeno0m8QnlmSb+aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEywDnRm7nfTkbi6G5LttHVVWy7swGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDJvD94kxMA6RdQZ\nnQxPaRzhrXsgPq1Ss4Sh51kUgSm9AiBXEq7Kqf88e+Lb9T9XLoVKic9t4yPW/FhG\nP4v3ndiw5Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2728", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2728` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAaCuOjXnCF13kix7QbYuWb7GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1Zjk1ZTM1LTZhMTUtNDM0Mi1hYmExLTk2NzZiNDRlYjgzMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM0N2NmODctZWMz\nNC00MTdmLTg3NmEtYWIxOTVhZDIwMDRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyYDeljlZovzZqTC06cYQs/iwDjgQ4ysMIjS/KmuM8SxUQcOcxVpwKsC4FvAu\nJfhB45NQalJL0e5MyPAKynZ3d6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2H4Hq5hr/ujXlW3K+lpLzUofXmMwHwYDVR0j\nBBgwFoAUts1k6jrskzUkE9Ag3iWy/FhF/AgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAvDoGoxuol6i3C0IQWJaa0V/TKF0GaB3orlUq/CRms54CIQCljnB74GFr\ne0fssjBUIdbUF0qixx2ZU9Eb/aq7hQtYew==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQmc2ikpY9JB/3ntV8NyHuA0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWY5NWUzNS02YTE1LTQzNDItYWJhMS05Njc2YjQ0ZWI4MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnpdSbu4bUKopYjs4113Jvk+BibYfDGRRjT9KWgSojhsMt\nV5AAw0aRSi+VuFox//A171ocUSz2NvxKEliAVdMBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUts1k6jrskzUkE9Ag3iWy/FhF\n/AgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc5KMAehFgFeHg6PoE6mKGMg1co7C8SUvROFDxSs22VACIQDEBpk7OU0l\ng080BGu6vUrm6k16T7rpcm5RKhLk4dcFAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAQJBJoRZJf7kIdSNKlzlO89fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM0N2NmODctZWMzNC00MTdmLTg3NmEtYWIxOTVhZDIwMDRmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDRiNDYzMDAtMTU5OC00NTVkLWIyNDQtNGI4MWIxZmQ2\nNTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZ3qWHE9i/+CC88cXGsu38w+b\n8+emNyIJNFy1uwlHeAb0GEH9FzY/b+ETqcPtl2obPy50rOKLHqAYOSHFU/aAGaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2H4Hq5hr/ujXlW3K+lpLzUofXmMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDm4bJRJ8sgPuvJ\nN2ORQbBcQRG94Fctl4VGWscBE81lcAIhAIUy5rqfAR3lv/YDvdWpl2zgHivtX1PS\neEBkvlqk04I2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2729", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2729` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAbMAOz+T3SkKDGruqpEkr+e6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxZjA5ZjJjLWUyMTUtNDc0OC04ZDYwLTUyNGZmNzZmZTFhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU1MTRlNzItNTNl\nZS00M2RmLThjMTYtYzcwYjdhZjM0NGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF9xruntMQlfrNJq30uuYqMooLaiNRybj/uQNOo/OD7769f9yk5WLOMtVN+/W\nlpXukwrh9tMmgeVbRT1JX8g5VaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzgFGiMKKrEyWwLBQWowOtlRgN2YwHwYDVR0j\nBBgwFoAUvc8Bh22Y3uFhMNZ/5TSilmKLrakwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiB1qkyEPQvM5j1HQL6mqkzKuMVJ4k0MI4gYt7+9It0v\nwQIgJeVZiki30M0ScVyhREW9+ZQxrKgbMTwgrIgjRBljjng=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbPQPWCtlJHwpAhhNTIe+HlhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWYwOWYyYy1lMjE1LTQ3NDgtOGQ2MC01MjRmZjc2ZmUxYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+A+YwT4NDwAu/JD2bDAtyDIBMEGiF6nLHXSNjn7yIA145\nSaXSe92PAtGijseA4u5kIfXmaI54GoYSCYAwKzbzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvc8Bh22Y3uFhMNZ/5TSilmKL\nrakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLawyyP1o6YL3KqtK2wV+oM1iEqv1tAAuvijwnTNJ6usCIQDR8BQjpkmW\nmIJKPERpujmovfdxlve8rHF45xEIryMUkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAbOjzwGJi+YQ5SRvkS5O8jWzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU1MTRlNzItNTNlZS00M2RmLThjMTYtYzcwYjdhZjM0NGI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzY3MDMwYTYtMWMyYS00MGUyLWE4MTYtN2Q4NjJiN2E0\nOTI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm38pgxKmXM/38ljvcMgDFb2a\nUPdoJKwZ0dOB9NAYCUFEDnrCFU4YNEj7bK/itksCrOxW9v53tin4xSSClNcilqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzgFGiMKKrEyWwLBQWowOtlRgN2YwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGCjqABXzJplouIK\nX8v6CaYxQKrcx0+fFjhxfl5FHKknAiA6B3+ee+6/qkhL/KTa2vaXMG5nxWiXt0jB\nvBl4po31pQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2730", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2730` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcSI/7nUsS3FdSP0tr5l0PhwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMTYwZGYyLTYzMGMtNGQxYS1hYWIyLWI1ZTRhNTY5OGZhMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQyMTI3ZTItZDNj\nMC00YWZmLWI2ZGUtMDg2OGE1MTFlMGNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEURKVO3ikCc9ZOxgGzaR3G9PjkASWziHpoXgNMzBgscEJPxh/rdwPmOlZvgFw\n2HY3O9HTKsfmji3twR7oxvjptaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc0Iws4xbKO+FmM+3AYSqvoJGN9swHwYDVR0j\nBBgwFoAUjroCd19U/yiRn5QHb5ncOI10y90wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAwWAsHmSnXY6Fe1sDTx35/uAuUqPgIOzgv0h4xRfd\nE4ACIENWlMs1V8GR7+XnUjMSYi8qoM0Jpiuujh7X/hI+719u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAToXWAV9pYVw5fA0f2VBAhszMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTE2MGRmMi02MzBjLTRkMWEtYWFiMi1iNWU0YTU2OThmYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbq5QpG2Ak+TDFY8ofZEoglyuGnHVTGjF4NQszl5/arrJq\nJgVhGhW6fVKbD0QxVy1/NHUatEAiF2YkIC8mVBv2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjroCd19U/yiRn5QHb5ncOI10\ny90wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPt8TqvMrvCjhvCwB/UFX7w2SRMvGMAk47P3JhEapQDRAiEAuxey3CcE\nVi5TZ0+J1YlyP8X6oUeP+zeHYX02KjxgwG0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYONgRZoAbKTA6wok64e3k1LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQyMTI3ZTItZDNjMC00YWZmLWI2ZGUtMDg2OGE1MTFlMGNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2M0NjY1OTgtODY4Ni00OWIwLTk0MTMtOTBiMTgxYTkz\nODUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELQP2S9IKn2Zlk6MsNemhnEbm\nS/Lb9H5kNJwOI13Q7kE8ox2oEUavmLBKMa1LU6gH3AjH7Z6PfdSETgBqt5YU0KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUc0Iws4xbKO+FmM+3AYSqvoJGN9swGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGE0ktMGP6gkGCp7\ncqC7tB160ga36Ew6VEryKz/69rovAiAKLTs062h1fktYN3SP4c/iZVRToicB34rW\ndQ4SdLKrvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2731", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2731` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAZ2aC74avqK7Ya6Ob/25KRvrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhODIyMTkxLWZmOTYtNGY4MS1hNjAwLTJmM2I4YmEzNmI0MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA2NmFkZGUtMGVk\nOS00MDlmLWFhNDUtM2U0OTVhMDA4MjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErl6HKK5Uf9U/JgEEcTYoTyUF2PT7RbZASsqgVVaZMenrrVvf94KBMxCdU6bW\nCYUl4/qnON3JtCz7Ui5eaoAiQ6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUKIgpIss0Ca1ak1gHoCge51HKRswHwYDVR0j\nBBgwFoAU1qOXWL+WYbCYKRnn/RT9XrIKg2MwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAsMMg/gJ5wgeMqRTUviSrnl5tlWuuDw6nOb5AfR7okm4CIQC3\nhv9+i4KqTXF58JYak76OwEsooPvM98Ho26f654+Yvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATDpHZJM5wcGQbM8iFuNDVTBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTgyMjE5MS1mZjk2LTRmODEtYTYwMC0yZjNiOGJhMzZiNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5DF+aQgyXNCY4jaeGPzTmSSzHxqkns1svyziBYosZndgS\noIb7MoYh5Y9aEj5pYsmfVNtIoWAqd9tivs80Hv0xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1qOXWL+WYbCYKRnn/RT9XrIK\ng2MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJbL70K4+RTIH6acIMIh4GJiptLWE5atQFkav9JDwSqkAiEAjdQfxgtd\nAA9ypoTqA8bUwf1jdnZU2VYQmwmF/juOT2w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVtaM6VF0AqcAkAibwF38h/qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA2NmFkZGUtMGVkOS00MDlmLWFhNDUtM2U0OTVhMDA4MjY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmJiMDNjY2EtMDRjMS00MDM2LWFiNTItOTk4Y2I5Yjhl\nYWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXNIlSyWNF4WDIZ30tfis3oI8\nFmA2f95OfNq0u1nofiK83NyZHpIN8ADhVj6r31xxQohBiuKcLclk8mEvh8uOraNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUKIgpIss0Ca1ak1gHoCge51HKRswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCtEpflh+irFOx/\nefU7sebs/7auWw8Zo75XtClh1r+7bAIgS8yfNoNlNS+/q31ptTYBuy1ZGRJ/QDgX\nxy7Qhy5EL4k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2732", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2732` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAV19zjE8sSv8CisAuhlWYJi3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjNWU4NjUyLTNhZWEtNDhjZS04NWY3LWVmOGVjNWUxZGFlOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhmN2I3ZGEtYjQ4\nNy00YWExLTg2NTYtZjQwODIxNWNkMzYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkMx/v27UKDYQBqXgR10gIsLfYcguwiIwVsbL1JXetfR+FAjw7nTXuyyMIbHb\nEC3fy0HU83VO6ITEFVPsd2tj56OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1IRht6ehOWOyxWBq/VGVBu45rM4wHwYDVR0j\nBBgwFoAU5mn4KgyhaXNfbYMf4e0SIRSjRm8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBBya1TLoFk/Op+9jdXuctD3Arm4Dt3vhw+\n8Dl+jzGULgIhAOCJtVWGdF7dZSFBOndbUEkTcNLv5iBPgJvC4Bh2M7L5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeksk64YuzPpQP4mdzMJx/JaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzVlODY1Mi0zYWVhLTQ4Y2UtODVmNy1lZjhlYzVlMWRhZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeI3m/ei2mj6rjJJZLEXygCIn7rfKwiwcJ6WopplXAlvO9\ndclLIGLpEEJV2iOzg4lDPkbI/vJlBNDO1ofiS3vCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5mn4KgyhaXNfbYMf4e0SIRSj\nRm8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM4jmEqL/SU1KOCOisCDgZi138GfBnxMqgKGEBtLg5HmAiEA9jJ+4ssN\nmwJmRf8SzX9r+09Tzk8VTPsF5t7P3NaJufc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAaNTpNPEeuCBB69iWPLzikiVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhmN2I3ZGEtYjQ4Ny00YWExLTg2NTYtZjQwODIxNWNkMzYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2U2YTA5NGEtM2IxYi00YTk3LWE2NmMtNjMyZWIyN2Ux\nYmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKVvvVOmaRrtCPlbFpu0th7dB\nUCzNl7yxV0WOVu2BmaOUn84z8RWkupDV80MxAfdkIC+PAuR1G3Ist5nc9+vEYqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1IRht6ehOWOyxWBq/VGVBu45rM4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCH1htEkocuNfKA\n22/MEtXcE1fi+qHQCgtuzXYoiBW+vAIgSxOumjuq9DBcq9NMFbwNeTUBXk7P3X7I\nDbrwelqLoy8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2733", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2733` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXM4o3VWM7e7+IbvERKIrheGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2MWFiMTU1LTgzYmEtNDBiNi1iN2YzLWY4M2RjNGNlN2Y4MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ0ZGU1M2YtM2Mw\nOS00NTBiLTk2OTctZDJlNDViNDE1ZWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJcQLmeGUmZYoGnIdPScZbZCBe0/Fo8uM8wzzgsobFaVQJX/z5d/rL+1nXH/b\neKE9UIKkdUqaHPL0g6Rr8/maC6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiAis9HWZ+jgdpl+yBsmR5NAFJ3gwHwYDVR0j\nBBgwFoAUw8nid61dwEjhfIsagBMsUyYssQQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3Vy4TaT297yzH+7krY5NwbgAV/KikZ+k\nKKOKb6BRfW4CIBNi0w1/gqmhElcx1Ic1aY9srZ2Cp7fXqDjUPtb1iFb4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXC38cm08NFcqsK3uft5GottMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjFhYjE1NS04M2JhLTQwYjYtYjdmMy1mODNkYzRjZTdmODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNCXbqlOi/CSb3JB6ZTuxXuHlflHjk77f8U1zSs7F1hp+r\ngjZSupDSE4dL/RfNW1B8IIRqueuIuLPhafdY3jTTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw8nid61dwEjhfIsagBMsUyYs\nsQQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWLgvu5/LtRvofbKNKCkzXLBbNS2OsYiN5W9dvh/0Mw8CIQD97vneaIFt\nX9rHLZaQB7U698isZwjKwVecR+YSWjC1kA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZsR8evcRmdXk3wRKbArM5xuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ0ZGU1M2YtM2MwOS00NTBiLTk2OTctZDJlNDViNDE1ZWE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmZlMzRkZGItOTA2Zi00MmQyLTljNTAtZWVmYTcxZTI4\nZGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvIf/dvDjlx89VqW/G3X9ht78\nVr971didiV87zOkUlN/VJCbJ6LvSIqK2Q6uXtjVvU3lbqVSwM8oLexHAC6eVyKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiAis9HWZ+jgdpl+yBsmR5NAFJ3gwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIARmfzSZXbasMRul\nCoKEA8rxrYlkC19zeu45rhKuCQhaAiBg9a6KxsZLqFP9yeIMoBWAJnjE2iWPqbz+\nSkyF9kdpew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2734", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2734` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAUHcncehCVIch4VSyvS+olH1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1ODM1ZTZlLTE0ZjUtNDkyMC1hOTcyLTI1ZjRlYmIwZjk4ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ0NTNjOGUtYTVj\nZS00NTM5LWE5ZTAtMDhiMmVjZjY2MDllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuGRhuTOds4nJ4YHYy77WeRHxPfrZCKO+lHUB0If2LW0Wn741GYvyqZlbGBYm\nAxWuroUxy4ZPXKe3bOB1R2JvDKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/YC3199+tmchtXo372QUmZ1KYFUwHwYDVR0j\nBBgwFoAUNETYjw4woqDy2onQv4kBeW5M34kwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDG22vz07RqNuSI9s5Hmp8zoZJv\nBMmRkQDpmWqlMVenmAIgPeyuMtifoLC/Tdi3LLecNnpZbh2B/QRD4Z45LoE1uIQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZsZRUVoKCQwfgX/LREX14qbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTgzNWU2ZS0xNGY1LTQ5MjAtYTk3Mi0yNWY0ZWJiMGY5OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROymsVIM0/Ux070Kwr9jVRaSvjcwSYYUMe4JPOcflKnfKd\nhhU2wPwzXlzdmckCLQ4ylKZkCjY8xVFmu0bpPkpko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNETYjw4woqDy2onQv4kBeW5M\n34kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOs4e3UoNZZ7PvMJzmf4gPXjM8sQtIdPPeLdr2D7FT8oAiEA3/6W14c1\nsJebxqQGJTLoP56fJLaLbljLo9pSJMgafbc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAT2P5tYtgmlFc9F/u6YRtgteMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ0NTNjOGUtYTVjZS00NTM5LWE5ZTAtMDhiMmVjZjY2MDllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzY4MWY5ZjItNDMzYS00YWIwLWI1ODItMjVhN2MxZmQ4\nY2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2iE0allrzA/V2QVzmAc2uX7z\nksrhzHv7/MS73et5byHcru3+8Kp4UdL7v044nC3PA8P3JiCDXCfdg7I0PLCk3aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/YC3199+tmchtXo372QUmZ1KYFUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG5UW16EkcBUmjNo\nmaaeHbZ6IZo5+ijZaCdDC3cQOxmSAiEA0qT5f2t1lXDL3UcbY/vnajxTfLKW45pv\n+Txcjs9XqpY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2735", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2735` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISASAWMRarV+tGtj1Req5gfFVoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwZmM0ODA0LWIzNWQtNDU4Ny1hOTliLWVlZWI4YjQ2MDM2ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNlMzc2OWQtMWUw\nOC00YzQyLTg1MGItNjhjZjU5ZmUzZDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVX0OvkZtHbWaiGdI1zdltO7c/ecQ7gnqhfejAVYtSJWppcMXc4gnmhRRFPCQ\n07qmcJUzwnoumuV4us7J1dSnfKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMrLJDPX+Wf2p2U+VxY53tL9gD7kwHwYDVR0j\nBBgwFoAUm7ku8Ql5rNbuttFOSX9uSMmv9VYwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPD9yfV6\nLaZfxzH5R0cSixalL0jQGUWolZYDEdov3OYkAiB4zx75NxWEMuMovwOUcA/2RMyd\nAf2lj/6oo2j4f8fC7Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY3vxLjiqAP8BWDF+KbtlhcdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGZjNDgwNC1iMzVkLTQ1ODctYTk5Yi1lZWViOGI0NjAzNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm2FEdkXsKJARVKr0gEqvfunMrNkWQKJnVWsGc8D7UdEWi\nX72HZUbG0ShFwLO66JRiRMrQvp4WzeUt7jgLepVMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm7ku8Ql5rNbuttFOSX9uSMmv\n9VYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKx3lXzdjRtJp88aI9sAt51nOnRqB/aqPl+231BL0napAiEA/VADS1x1\nvdJRnhVIcWQVgW9BRTOm6MWWlMd0NArW4dg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfwfDO1cD6vggRYydtdILZK0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNlMzc2OWQtMWUwOC00YzQyLTg1MGItNjhjZjU5ZmUzZDNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjRmNjIwYWQtZjU2OC00NDA5LTg5MzUtYjk3ZWI4ZmNj\nMTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoXrOYgVUzT99TsZfcl9UCx/E\nBgQjikb4lGtAuYSh8PLrkDsQY7V1ffq0oEGtyEsZtkQxZddAmDXvyqwED1QXsKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMrLJDPX+Wf2p2U+VxY53tL9gD7kwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC5C5oGhzhNUHkH\nB78v3Cn2Yt6FyEa+dwxikFQPxc5ukAIgBMQyMk0IjlEE4a7cf0GNpjluly1j1utZ\neJJ/XmFjDQU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2736", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2736` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISATQ/mgiCCrRxbAmrqc5UAqnwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzM2FkMGU3LWU1YjAtNDczNC04ZjBiLTBkOTY4MTg4OWMyYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzUxYmQ3M2MtZmI2\nYS00ZDk3LTk3MWMtNDFjMTFhZjZlMDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElt+7YPLipdBofDQMsFpWCEy11lBvfRdUHFeJBpzqng8DwtajXhFQ1KFgEs01\nlUpzpZb3xFN3DWq0mkshfXni1aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVnOonqvK1hqCW1zj9c7TWBCap6gwHwYDVR0j\nBBgwFoAUda/IOaImuQdwia+97dXMUTrKZOEwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANlHj1Rj\nFQjuJ6/WJNwq7d9JnozFLG2d9FcWWKNU8nQ2AiEA196ok+wxBNtBQJ5+KjDap8Mt\nfcCYN1fmwoe7gs9QPEE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd4rKnISdBxq7IBD7OPO9bAyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzNhZDBlNy1lNWIwLTQ3MzQtOGYwYi0wZDk2ODE4ODljMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuidUG6LOp65ci69IOGOh2elMWPG8vW2uxkGl6IiCjOnKn\nabRqsMzhAeF2mY1SEv1NK2dgVO/DdifuzJEeqDbYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUda/IOaImuQdwia+97dXMUTrK\nZOEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL5UvMMJXIrl0oBUh5j/lf5eHiqbBFri1cVF1T3+r4mGAiBnuP6c1Vtz\nD0mQDTeiSDT/Zxs166TDAvNf71vjdCi5vQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAdIcm+CRN7bZhzXJRVSrtqgZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzUxYmQ3M2MtZmI2YS00ZDk3LTk3MWMtNDFjMTFhZjZlMDg0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2M3YzQxM2YtY2JiOC00NzZmLTg0MjItMzFmMWM3NGQ1\nMmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuAo+klwg2G3KbeWTKWxAcEm3\ntzuX4/qKurqafA96t5n9NyoLLF2QvzjWu3dLrR08ejXRg1Oh29nXeXHXws/q56Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVnOonqvK1hqCW1zj9c7TWBCap6gwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDotPiPOOJmmtQL\nFsar2WKGXeDdRp+qsBv76I6khR1CvgIhAJIx80WTyTPEkUfWGymFvJMcrMmOrIRS\n9yWQSoc0QHuy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2737", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2737` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAbxmPDn52VsRabMZr0jlosFXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxYWE0NWMwLTFhMjQtNDI5MC1hYTc4LTMxZTBiMDI0YzdmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE3ZDM5NzYtNjBl\nOS00YjdiLWJiMTgtZmM1NzhhOTg1NjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0gp6bTvlwOfI/sCDLCffbXyuaze+E+6Lg9Vkyv/pQufXFzYYmp/M7InQGA0K\nzNpFeH/C3nRje3RbLow5JpBNFqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ3i8olCBZug6bbBKUQP3Q4HGoncwHwYDVR0j\nBBgwFoAUSQnCfYx+iCkj8ue/1XPtXmwQTUwwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCxgDDg\n2hT4esuibE/U19Eg8CmsSTKb77MjUoYAO9bg8AIgJwPgfNCy9LUe0PLqc6G89HYD\nPZw1S7GeXCOf1XAPM7M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWN/Lm91OSFyMUjaSbrSpQzMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWFhNDVjMC0xYTI0LTQyOTAtYWE3OC0zMWUwYjAyNGM3ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARo/vhTGFFcekoCbdm3nMA4Vrodk0fNrHXn/vWxlyOr9gNz\nxYCIF23rrzrNO1O34Vdz28aj68v1P5smgtUemmCko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSQnCfYx+iCkj8ue/1XPtXmwQ\nTUwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZoodUx9KA/bS+AaNaf1wToOKUO1ux81ilGj+o41PXvwCIB7/aYsH8OCP\nOgzRcLtvdAkvMwEj3nkrowZRsn06GGrE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAWfUJFC8coSY9mC1maoODPHRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE3ZDM5NzYtNjBlOS00YjdiLWJiMTgtZmM1NzhhOTg1NjliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzgwZGZhZWUtZjkwMi00MWVkLTk2MTMtMzViMGMyYmY5\nMjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwfoAWaqU1IZWSiJ86SiiBC43\nF4OJ2TIjloGKzesLUGHKCH5F/z9ico9gtLkfYQN+YJB+UYBQPmhe5XRHA3/KZKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ3i8olCBZug6bbBKUQP3Q4HGoncwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCga+gBqSoBjyfs\naNHEZGzNUOeYwvX2FUuLCcwSXV/FJAIhAO54FpIXd837Q2nxBtf3896xRC4rl3ww\n1KFgcM0POIFR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2738", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2738` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAVamUF4eWSm8G3DruuDn2iInMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmM2ZlODk5LTdiYTAtNDYzZC05MGNmLTY1OWU1OWViYmY2MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc0MzU2M2UtOWQx\nNi00ZDI3LTlmMzktY2E0MjFmY2MzM2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6KZ58xe6cj/brXqvKQc60oXCly3Q1Mk2zZnhla6HNrHUK9RCuCcjdcnYyLLz\nLxbUnjfiIB+3dvq5rPwwADmaAaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuI35D7DZeJcXC0Pm9kT1eJaAAkUwHwYDVR0j\nBBgwFoAUv4hQMDIS2sovYqzFyp4FYSXW05QwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDTBtkiD/Nfi3QoE5Xiljeineb83811IKi7VCT9RRBfIgIhAOD/K1pK\n9uqgE7RFtnL0vgVrvfiSjfOckU0oZE1qkQo1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXKX2X9T1NejB3U69aTQeahwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjNmZTg5OS03YmEwLTQ2M2QtOTBjZi02NTllNTllYmJmNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATigzdvTjbs/RUzmc9vaNmEjFQXnq0sta8KZSQ1aGDsg9mW\nVfe1Zq2vkK8QvsEUpT4aU5TElH6WZMI/0peX8gc1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv4hQMDIS2sovYqzFyp4FYSXW\n05QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIJ34WupYk/gpwUuKLTOWz2YAsm60CGkiRNswohKgj4YAiACA79G2J/5\n4kkiFfLRADkO814yDY02TQW6OVop0jdp7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAVHXUkg5bCMdWLncYBQSCh0rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc0MzU2M2UtOWQxNi00ZDI3LTlmMzktY2E0MjFmY2MzM2E4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjBmZWI1OTQtODc2Yi00YzdhLWJjNGItMDBmODBiYWM5\nODJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOLg4b7xhJbO72pSXOIs7tiDU\nZ2ok/oGiVy2cGZOF1kTTBKh/ld9vmLQl5FoQw0Wr0I+QkfDIWWNemD29iyk5V6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuI35D7DZeJcXC0Pm9kT1eJaAAkUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBCxoQFIqozvExZv\nbJTHg5OPpkFLg5BHNKHISU/oNUWkAiBWgmIQ1x748XmYhGHKA+2ualLU16sO13q3\n++02CKhgMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2739", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2739` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQy0C4Flt52GM9San2EwUCzWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5OGFlMmU3LWU1Y2UtNDQ0OS05YzU3LWRhOGNjZGExZTg5MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY1ZDQzYzgtNDMx\nYy00MmE1LTliMzEtOTMwZGNiOTg2MWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqoShj65ThvLkhxD0PolDxeHBUOohMvm/kAdhIMtBmJYG03hn8z7+GrkZXYpD\nsq9R+jiKjsqCMuQHv7w4K8pIn6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU44MP6MVRj67bFrGsxDos2lGNSD0wHwYDVR0j\nBBgwFoAU7qMofZi2gKXUokxP0rA2+yfo948wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQChpVMwL+cAlVvu9y/n9jCTEJz3hkFG+4XKZ6++uyVFIQIgDq1CUDLT\n/t4sURYrLDSkoQxUcwqf5NIlUFbKpcAK8/8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASi9qo1ZBt/HeLf1Hou51d8VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOThhZTJlNy1lNWNlLTQ0NDktOWM1Ny1kYThjY2RhMWU4OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARN2QhNbAkupMrbWsD+TEp2qcs9W72ya1zFkvyi0fuI0Y7A\nKuob9OLdv7LqXhR8L+LxKR5s0vA+8JiIym+MPw/Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7qMofZi2gKXUokxP0rA2+yfo\n948wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPMt/mCIlKcTgOI8giicFhrCldTnKPQDT0s00mV8GKmICIQC9s2GejTcd\nN3Rp2oOcpHL+Ag++IOTX1/XlUEAIS4foSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAYi1CEy2PUnnCW7Iy9yEwbUgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY1ZDQzYzgtNDMxYy00MmE1LTliMzEtOTMwZGNiOTg2MWMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWI5ZjQ4NTEtZDg2OS00NzJlLTkyNTYtOTM1OTg2ZmRj\nZjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE855rsYqUegXZWLz+95+aJXq6\nX0rJ0H1Nx+v5dwHXem2nQglUyMGMqioAms8ETdEgQyFo9DSFZzhRhVIrwUUn06Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU44MP6MVRj67bFrGsxDos2lGNSD0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCQ5UUY6sCPGrJj\nPUeRJP7PduD7u30IOgL4EhbVtqH4lAIhAOYecpi76uvKA3THcv1WJJYIINyfArBZ\n1v0iHOwjbU8l\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2740", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2740` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISARiM39NOdu5yawlfwDliiUkNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhMGNiZWM4LWVlMWItNDRkMi1hNTBiLThjMDk5MGRiYWVhYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk5NWRkMTMtMzEz\nZi00NTYyLWE5ODktMTJhNGFkYmE2NWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE09zpd2Cw3dMjpKU+ugr1FCTnD9f5hGFQDA9Y7IWTqgrELMnhXA8sCd5d3U4j\nx9aH3a5To37KpgsXvAlOsc/lGqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrGyHojeobGV+VXQWns/uZELqNegwHwYDVR0j\nBBgwFoAUl7m4TvMUECrli+do0S2qfI7sCY4wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIH9rywNcsyvPAtakecEz7tK9T53CTZMozsfgNAQgGOi1AiEAxLB60zQH/dF+jrEW\n/ZF/4uGGnnDQPZ1oZHaCLMsRvm4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXjPhfz4bF7LKe4IgwZpWji6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTBjYmVjOC1lZTFiLTQ0ZDItYTUwYi04YzA5OTBkYmFlYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ18WNOizEKihChFZULcEUGc9jmJ3sFdEezhEzxpGFfHK3G\n3NpWocoArAZTb8gO+HcLQdobjzsJ9bKFYufXvJdeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl7m4TvMUECrli+do0S2qfI7s\nCY4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgISRahQh54w3OCGFPpD4/hmab7dBH+QqfTMwzoXQCUaMCIHCNcyjvtvbs\nffBE2/VYgZF56k+AiU13SqsbkgqB/L0d\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAc9gFcoPyowAGYMytvkHrWQyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk5NWRkMTMtMzEzZi00NTYyLWE5ODktMTJhNGFkYmE2NWU2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjczODJiODEtNGI3Yi00N2Y1LTg4N2UtZWFiNWQ5N2Uw\nOGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpYcqWc3dMZjJaM9n1wI2Criq\nz+va4tKHIfpEOP6NUgohPbyzm6XwYA/LoRJIkYCVvCcqPvn3DGy4tXDoEPXUlqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrGyHojeobGV+VXQWns/uZELqNegwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDmd8p15c/m66/S\n9IyTfJ5LHP0gCeshusJ8dTmI3GJLJQIhAISAtNihi0LATQoi45Gcw23Al9OiARoS\nBT8jwVE3iEHB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2741", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2741` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAc1qpYiv67+SaLNYY1/K+59vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5YTY0ZDIzLWNmZTItNGRlYi1hZDYyLWZlZjk3MzgwNTMzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM4Mjk2NzYtODg4\nNi00ZTJkLWFkNDMtZjI0NzM4MmNmY2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0wmzp+W5SAIvqcG035Qleje4OgB31qKa+/S/kUheQooRYeIsPeURHHJ0UOMg\npTQMyyXYIEG9IXCLynyy5Q33DKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvdJZWIAQIKY/M/1T09Fg6kZCQ9IwHwYDVR0j\nBBgwFoAUyrTxRj8yBSrW5gLK3PzlhoVe9gMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIHjwFc4JcaHOboR0ng5rg8iySWLyzapozsXYgcrF7on9AiAA\n6XxSyl+QXyWMI+sZSrYJN9tuyMPNspzA4qDDRMbozg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVttdKP+cSafFIJcNbVE/K9kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWE2NGQyMy1jZmUyLTRkZWItYWQ2Mi1mZWY5NzM4MDUzMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJTxXiwQKcNXRx1lugEH43qBTq2alvqTo1J/40C//74Ibc\n6CPTwqaXGmNGmR1T+yid7vMV/SMTbdQzvm3Cyw/do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyrTxRj8yBSrW5gLK3PzlhoVe\n9gMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANxrCD7rLXZS6ZMtFqesSq0XpoUD9ws49tFvzWQHig2DAiADagq443Zr\nWIO79fyLO0XRiNurFSZ5pghGcvRcwzMYIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAWwY+Rhb4x3zde72ISsAH4o2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM4Mjk2NzYtODg4Ni00ZTJkLWFkNDMtZjI0NzM4MmNmY2UxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjE0ZTlkYjYtMmMwNi00YjRjLWEwNjctNmNlZGE3NTcw\nMzM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZdqCwhZGzUdKUBOc4j9Xfj7K\nR/V3q7XT7lVvOWqHy1z4ZLs7EsUSXzA901wgij1OywgfFj3bSNNicFdtqPg3NqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvdJZWIAQIKY/M/1T09Fg6kZCQ9IwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFI92y+hJ40U5DL3\nzP1DNibuQzaHqFhzClMcZg8FVWxCAiAjVbMAzJ3Mn8V7ik1nYSCJzZQ06+wJ8Np8\nCt+p1BIq8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2742", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2742` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISATLdbjhSqJBM/6wpyRiHOH1+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2ODZkYmM3LWU4NDgtNDQwNy04NTYyLTAwOWUxMDE1OGZjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU3MjYzMTItM2Ey\nYS00YWU5LWIyZDctYjViZmY4YzBlMzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/T30xdimeKpVBZ3LI3WANhX6RuVwWBmPF+yAj1+19L2yu6+8i+czCyXs6PeO\nSd0n500uzWhHpKnC4ImWFiZyTqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkrpbIJPN5jydilB8MwG1gzkHrfAwHwYDVR0j\nBBgwFoAUcNK4eatMQXp7AtwW30B3PPcT/DcwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDE4NOcoiJI4hAvMLq8iY1KN3YInIe3cQZX2J73wKXfOgIg\ndaGbePH2r4Vtjerlwu4vnjcjdiiy+gHIAjs53ZBQjxc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZJBNL41dn0yW66IOXiq7WXVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjg2ZGJjNy1lODQ4LTQ0MDctODU2Mi0wMDllMTAxNThmYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlHBaZWPg/TrzsG1B02+Gjyh14X+44JJbVYnVbRKdXYDri\nEUkYPJ9VBK0Wy5rUj+Oyikuwoqpr+6WudO+66XqGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcNK4eatMQXp7AtwW30B3PPcT\n/DcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMru9317faLcnCEThtgS9IxwHI1u6V0Ps/iprs4zgK/8AiA5Q2033vmu\n7SHySeLFQvgbB+VD8WULNJmqIpI8Lg0NiA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAf2K3VhdI0LUhCoRK6bnk6pdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU3MjYzMTItM2EyYS00YWU5LWIyZDctYjViZmY4YzBlMzJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzY5NmZlYjYtMDdhOC00M2Q0LTk5OTItNjU4OWRjMmMx\nN2UyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXZ1jqyKHlZdq0Hk9N7FLqAcI\n1ghc18NKucrtJhAW8eX5Oqk7rjDjc2syJxQAaPX7CZWfRIV1s+LNRMw3ZEukE6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkrpbIJPN5jydilB8MwG1gzkHrfAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCaNnkotozH7s8b\nCUPMKRlqW1PKc9kIBja8A7/Fg7Qx8AIhAKmJ02cqU+PUkBHyMcKGxtwvDcQcy7I8\npkrz6p96ve6S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2743", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2743` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZoAiWS/jm+Q2YQPlj1XxcFbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhNDRjMDRkLWRjNzctNDAzZi04YTExLTUxMDRmZGVhYmZjODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc1Y2FlMDQtNGM2\nMi00NmM3LTg0NDktZTI3MmRiY2I2ZmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEow0u6myaPTUvjFGweW0Xwe1fhVgFnp/2Om0CIagNwhp7gY2K+mK824K9bOqi\ncsG7s9BHC0kvJQbf4wtDOXLXaKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxlv3BHyKGErA2nbT9Ofjc2g9q9QwHwYDVR0j\nBBgwFoAUYIQ0BLjZuNNqieTUxnQbLebN9ykwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD5mJGpb3zl\nmeusfu8fVmF+Rnu9aECLctE4dg1vI8EoRAIgI1LQPR/b3znbshWmdsWsQ+KTlKyG\nQp9gBjZw7L6A/Ew=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaFgGRxl+JoCQnDwy7JbXwzwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTQ0YzA0ZC1kYzc3LTQwM2YtOGExMS01MTA0ZmRlYWJmYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAST4rc8No05a2qo/EdCu4v4/WAP5N7LSW2BZRjYKwn4WDvk\nMJ3M3sNr4B/KQf+poRYLuTCa+Bt4afcE2CaRxRnmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYIQ0BLjZuNNqieTUxnQbLebN\n9ykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN3h10KLijgswbtfg8fpttQ6bW1DEk4KbrTqx9x7IKyYCIQCd78j/2HWU\nNLC4e+GXMeclM3rlM4H4DEB86At7a+q3rA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXJASIzV2yuyCCAehRWxT9nDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc1Y2FlMDQtNGM2Mi00NmM3LTg0NDktZTI3MmRiY2I2ZmYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDgxOGRlM2QtNTQ1Yy00MjY5LWI4MmQtNWIyZWE3NmFl\nYWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV7fa31wMAuN4gsdpFFzPr0Kd\naX2O9tJvsGoltIUdp4kWvNaBB9/eLVyySyVY6r8Ej9EwzZ4VA13eSxC72G8rBqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxlv3BHyKGErA2nbT9Ofjc2g9q9QwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCE+cJN/u+Suk+z\nq6bI6BXqhX1ykXhoueSpA0Vxd7gBwgIgK/7kPZ9VKg/ICokdCd5vx2gXPdlWNmnB\nl4lueh8K0Ac=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2744", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2744` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAdtrmL5iUq1n8mhq+2krIVD3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlY2RjM2RlLTZmZDEtNDFjNC1iM2RhLWQ2NGY0MGY0OTRjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGMzMTNmMGQtM2Y1\nNS00MDkwLTk2OGEtYTUyNmY5ZmMwOTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw8uJVVYbYFdEQ98SkF7HlIVVghjlvkW9IC/gRwc3k/cZRmBGYlPj1ndvqRRy\nWpfhsDtZQXqul/48104mmHERiaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCfGDHUWrKo0aFwMHs87KNkL0BjEwHwYDVR0j\nBBgwFoAUP0XiC/fxbrGFTzgdelVKBC8mXJYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgApcAeQ4BCYszU/MDqf26Cpy90S6DB+G1FgPpb+tesUECIAD0aWy2Tt3C\nrcNPod60zbP/zbAZHho23YthAJrkipsq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVt+s0lFt3cGTqrVv7N8lVpZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWNkYzNkZS02ZmQxLTQxYzQtYjNkYS1kNjRmNDBmNDk0Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4Y53NBPTM+DZE5OLo+D6pC9FeCzNWL+y0ZaX1H6s9F/Sy\nZDHAb/cBLwKcE0kKR2rAVMlaN5g9FSfhf6c6e7R2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP0XiC/fxbrGFTzgdelVKBC8m\nXJYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMBUs9R+4azEjSX7vf6pQJGeXM5SBdALBBicbavJjVkkCICo9DBI3+4eA\nj/1ee73lClfzcbo9OxLyYbU6BqN2o74i\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAc+EGrjHUr/urjnBe9tn2Bt1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGMzMTNmMGQtM2Y1NS00MDkwLTk2OGEtYTUyNmY5ZmMwOTU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWY2Yjc2YjItZjdmYS00N2E3LTk5Y2YtZDY4ZmRlMDI1\nYTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVtHXogJJSD09mheuj+dmzZOB\nBEddsXZ3r/k72l2zPFCj6CTqrdtyM6PoyDq8WYzNuYVNGWMRG3WEDQ/g16F1QqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCfGDHUWrKo0aFwMHs87KNkL0BjEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDb7rYZQIFC78Vy\ntpk97VriULXt5Rjldm1S/kpBxCiAeQIgZwg6XzwJ8aJnamdc5xzAU2yLBJxT8rCF\nAIh+iwwN2js=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2745", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2745` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAcUDA8T89poFBEaChnnguyXHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYWJmODBmLTViYTItNDJmYS1hY2YzLWFhYzBkZWI1ZGI1ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODEzNzc3MDUtMzQx\nZC00ZGQ3LThmYjMtNjFhYWNjOThkZThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJtRkqxkwneB7V/zIPAjcL4Nu0mxU12x5jTEuXTo8ELezRCm92cVjce3ELHa8\n0TTvCS3rRD4rB/mrMCkUTbWu/qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfq/2gvxZjbq86IqGzkKtuytnevswHwYDVR0j\nBBgwFoAUD/lyUrhnf6yAhyl6jPbyYHFqD/8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANwMOztcKCrkemMg7Xg6vH/bCrit6hKBVGfyQJu3b9cgAiAUrPtIoiYy\nMcgBFgoXlQ6GND8FT++MhqOzn4hxPMrmWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATjavHSwepcVQJ7B3WGwNgMMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmFiZjgwZi01YmEyLTQyZmEtYWNmMy1hYWMwZGViNWRiNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnd3tcouQUS4qCzfycv0N075XOQ3R0Pl0UO8j1UV7ZBwz5\nxAT6gnZDGenHmCeuPE53gw8f9ZEYsoEstUMz5WALo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD/lyUrhnf6yAhyl6jPbyYHFq\nD/8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMZ1T8Uy27wtdxRsnyYSPyxA9VB0amk1UsNuKeJl0ctWAiEA0nYpet46\nFqLgh88cuOr9nB7lue8uqU71na42QYHmOkc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISASNNiG9ayhIzSGUWtA4TVp+CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODEzNzc3MDUtMzQxZC00ZGQ3LThmYjMtNjFhYWNjOThkZThjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWFiMWNmN2MtODBiYy00Yzg0LWFiZjctYThiMDAwMWY1\nYTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC9dYDpbPKaKzK84iHZzK/1AA\nlHqMTXimWPSJtz+20iUFyCq/v4bvPKbTQeP1faZY+BpAZ6AkkbYvZU0RS1nmdqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfq/2gvxZjbq86IqGzkKtuytnevswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDRztVsc9itYt6q\nFd6OcOf8B63OGHh5cLwJTdOEHY33FQIhAKualNvsUynvxvhSWV/EJWxpAP1wa9xm\nfUVNjWycYQnm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2746", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2746` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAcWNx420/RvITmHQJt8uarI8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlODhmN2MwLTExYmMtNGVhMi1hNjFhLTQ2YjVjNzQ2YmQ4OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGY2YWZjY2MtZTBk\nMS00OTlhLWEwNWEtMjYzMmIxNjRhYzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP3RF6bs5mOQfTAmSIMmJ05o+7Q6y70TwBmIGvif5+3Kw2GAACWVaR9P9YsW5\n7G5o57s66qMiLJ5jMM0BB84YaqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIsZ65f6GxgV2ihLnjCNH96/kng8wHwYDVR0j\nBBgwFoAUU9nI4iC5ynHQcXMKyTtAJMWOJdQwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIF7pqCVD4lhwP3bs/Zczml8AJs6p4tdZRIxd3/Z0RSgJAiEAn3zQeYJY\n2+m4k35vh95XbFzVfs7Mtt8N0cAo0fRDtHs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbt0QzBRferwjox0DmIKCPiyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTg4ZjdjMC0xMWJjLTRlYTItYTYxYS00NmI1Yzc0NmJkODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQx/8YPvp4dfTL6ZYzAGbhlBA4agWnxmfB/LMGmjQGGBBl\ncbW4ZcG/uf1is/VWpInYaF2Sym8Qm3IT2D6gwVVmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU9nI4iC5ynHQcXMKyTtAJMWO\nJdQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMGRAhNKbJXLiM/95Holl45L6A48T/DbAMqNxUsR4TrkCIDkwNzXQThSl\n90SbjPh/4kSr9wysegspzc5xVEr6oqMg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAaWKOywyQbt3qITEvrmwxcBRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGY2YWZjY2MtZTBkMS00OTlhLWEwNWEtMjYzMmIxNjRhYzA5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmM0ZmY5YWEtZmQ5Yi00YjdjLTk5M2QtODY0ZWYzYjky\nODM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAMSE0elW3YMMRK+g71AhVPae\nfS+MGfP7oExaAb3li01vzH6R59BXMFDfUu2b2C12r104kJPiFOxc+O9LeC09s6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIsZ65f6GxgV2ihLnjCNH96/kng8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCF1feACOumRCfE\n+q15SXvbyvz1cPt1R3oSIqFF8DE1zgIhAILwqR18t5U5PxzgohRbdXjO+L7yEf50\nFdfKMDxJWpr7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2747", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2747` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAR1FLU1LhP3JiQ3BffLnT712MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiYTRkZTc5LTQyMzktNDVjMy05MjdiLTEzZjZjMTM1MGRjNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY2Mjc3ZDEtN2M0\nMi00MzRhLTg0NmYtMzhiMTU3MWZjOGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Wxsu0xReDBrh6H4T3DIsE1aK3GruBCri1YTc9ubWIPHcjvccbo9xstB/5r/\nf4uWGWPHoBiTpp7lI//D0kFyNKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmnmtP7CXqVrJZ98aQrHZgux6xlcwHwYDVR0j\nBBgwFoAU1RqgLxsSYZ87Ugl9m/nxIAtmUYkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDk+jVYbso1/C+eEmhzn26nE5UDY1Nc5k/CyG8G\n0fpCfgIhAPLF/IpXZV55ul9ORyynGOlHDHSOxPIxL9tlas1i5ER/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbSO+AzhC38QocVjrm+aYtA8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmE0ZGU3OS00MjM5LTQ1YzMtOTI3Yi0xM2Y2YzEzNTBkYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhJGZIdC/4YaWe8zcixJpgcE8WYprfoO++FCc3iFatQhnA\nj1gPP50CbLb3ZxXWSq3nmbMLaj7ltrLxg8733TG2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1RqgLxsSYZ87Ugl9m/nxIAtm\nUYkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgenvZP2NkOES1a7101EP+z205giSw+eRQfPwDSQSTe6ECIF21uRYrwrkZ\nkRAjjFSpgbeQaDjbD2ZdNuQYN/J01z9K\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAUmNoQbLIXHsKxNOT73rqOmYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY2Mjc3ZDEtN2M0Mi00MzRhLTg0NmYtMzhiMTU3MWZjOGUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmQyMWE5YmQtNjcxYi00NzYzLTg0ZGMtMzc2MDNiZDlm\nMjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErS7SmygOFDyx9FIlAbMqiQFQ\n6izKybhgcCqTIx59VslBckVcBEex7VLzIWA2MCL67MTQPfsd4KGGEgfmoLb5n6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmnmtP7CXqVrJZ98aQrHZgux6xlcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAT9l7h85CtrJIId\npmhR+gSLmDx0VUaXcCoHhbxVx2rJAiEA8j4bttoTQIft7X6Qn0H8Or8QqHtFV7TA\n/4wpYU8jJpA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2748", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2748` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUxMuEw06qga3YQpATOXOFzNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmYzI2ZjJlLTRhY2YtNDViZi1hZDlmLWY0M2RhMjY1ODI4NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjY3MjhhMjAtMWE4\nNS00YmNhLWEyNjgtZGY4ZmNjZDY5MTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE0vF8n8Iugm8KO4CVjNfagsLiDQAvSyRnXePAeSBKqS0UFNjLsdBwK/j44SJ\nOV+M9iSAeozV7B3bqGH0JXwdH6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURvtm19Ah+URla7pT68DJEmiabxMwHwYDVR0j\nBBgwFoAUixgaJc8tbXFlQ+i1aGaWLVekYLUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCNK6z0w/Chcl5WNp9qD3Iu93Kjj7b/6rme3H0o\nBJ3PZwIgIg912UNhrDhQEroTNZTWu0gq3OB9xYSZGDlWWPvg/oo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeTveME9Hx5fPqmqyoQkmFFmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZmMyNmYyZS00YWNmLTQ1YmYtYWQ5Zi1mNDNkYTI2NTgyODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmNl+Yixl22tzjnIeUtyPO3HFX8YSD+UxL9PlRS0n9GB8B\nNJdBuSfY8KVOsEaxXObAOqlDF4CrIm8/Czm7UuP/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUixgaJc8tbXFlQ+i1aGaWLVek\nYLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALPWskrjOKQtAfhjn4UPxtcl8/RO95LTLcXYyUVrrdAtAiAxpmQNolwJ\n7NBHOdD/dj2nhPGc4X9Ou5UQXVXqYUPD/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAa6IM0k94ovj8JgdhtX83f94MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjY3MjhhMjAtMWE4NS00YmNhLWEyNjgtZGY4ZmNjZDY5MTY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDk5ZDM2NmYtYjBhOS00OWZhLThhY2QtNDk2YzEyZTRm\nNDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVZl3hHRRlLtSLFhMWiwjlv5o\namyg6Ncz8AbPvtLR3RHkI893651YZZmFdCn9tqnRcFnKV3sRdVgirXf6PEZIK6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURvtm19Ah+URla7pT68DJEmiabxMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGUeX8oOLvNSS4tm\nNse0bm3LkLNJDQgsNondEIo9mrnLAiEA8WscU56wMWLllgrz+v3yqXCTc3rX5xo2\nW2lQANQK9/c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2749", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2749` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISARxBsf7+nBVgeTjvO6o9q7WHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZTgyZTcwLWRmMzQtNDQwYi1hNDJhLTRlNzE5MmMzMzU2YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYzNjI3ZGEtMGVm\nNy00ODc2LWJhN2EtNjhmYWU2YmY2MGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3sKYON+wofXw2hUYL+/s4udCJmPQjtsLvnxy9pm03v+LxfCCKfSy6wVYr+KJ\n+rjeIjqorOiLO/jxHnT0+J9s9KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrxZvTP7+XxeqXwByG4K7BHJwcnEwHwYDVR0j\nBBgwFoAUa/iqpKomqCyGAnOZQggvvG/fG8AwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIDSM3+p2G92MSxbqEbF9vxtpjnEa5ymfJybnww/C5IsVAiAl\nRnIriPf5XmbRjDO2tv7f9IJJBPi5LrdYSLhbdJNkYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ8Y+I1EwugHesmwZAcr0FmuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmU4MmU3MC1kZjM0LTQ0MGItYTQyYS00ZTcxOTJjMzM1NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8WJXf4W1M2AjR2lRonT1APfVgF2l7NhbylGcPKvJ0l2VC\n5YB1Pwcu0JZrmLx1wlQkUprE5K1/4gDbuuaO4UrWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa/iqpKomqCyGAnOZQggvvG/f\nG8AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALVUq7ZGNLxuVsZnNigVny1KkkWJ6evgWRi5VPJ0+ggWAiEAnL7Us7kK\ntsTqj+JSwGL1INMD97DjDIK5ssuWgf0Yews=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbPFKNg2tWsvyC7ztRTKxxEWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYzNjI3ZGEtMGVmNy00ODc2LWJhN2EtNjhmYWU2YmY2MGY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWU0Mjc1NWEtNGE5MS00NjVmLTg4ODctNmE5Nzg2ZWZl\nMjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtohDvdHWGEcUhUYgRv+R6g9U\nDE2T0MXKAfX121V6AjXkssw2Jg9yU4IJqC/BJ9ogFbkGzrsiUnJ0ZQHyy353OKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrxZvTP7+XxeqXwByG4K7BHJwcnEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDly3FYvjtiuIz5\nnFBjni6xJAv4wvC8vZd770chWHtntgIgENruWFBKZWxI40GgQVtwyWV0E8s6KElq\nSto+g0eU3/c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2750", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2750` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISATeROvZ6JkBqBVgdJ/eMDfGxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyMGI2OWNjLWYwNzgtNDU2Yy04Y2VjLTJhNTJlYzcxY2JkZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RlNjdjYTctNDE4\nMi00NTQzLWJlMWYtN2Q5ZmY0OTgwYWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFFQWehC5TPgf+Qi8Z4k8S7cigxeizULJyIfBOhCTsKt88BLp3HzYpmN1Pz+A\nuFW5HM2I2GGyxwhp1z2Qu8XZMKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGU7ERvknTg7LwX5lVQQyuwu6BswwHwYDVR0j\nBBgwFoAU4T4eDsAbuJdJUA/uQeY7L7nek7IwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDhDN8QtmIHf1zJZlqw9QSh3fIHZwzc\nlDD+InQWMxHusQIhAJpHU5TwWItciBH6q1bqWKu0GYBAJGC9oIrHXUuwQPmI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVT52YgjiaVi/IcxLkJcAxF8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjBiNjljYy1mMDc4LTQ1NmMtOGNlYy0yYTUyZWM3MWNiZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0kSP/ilHR8BMaOU3HnR3srQwEHTvFKq5mSMteUu2bAAMt\nHzQLBmU3vj1c3WU00pf/+iDEb0yHbVg3Onqrp2bVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4T4eDsAbuJdJUA/uQeY7L7ne\nk7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANg854cfvomVHLNtKpn9LgOEsdUuAOQMcdCj8kbRuuKaAiBZdPwgnzCj\neWV+W8bA876uM7+bTPfH6EV/8GsXbF8ICQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAUXgdLwf3W0AjWC2kVCb3v2PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RlNjdjYTctNDE4Mi00NTQzLWJlMWYtN2Q5ZmY0OTgwYWM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTcyYzcwNDEtMDkxMS00MGJmLWI1MTgtNjBjNDRiYzVk\nYjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs910rwH9AzShXCv28udqrV5V\noqFyMSjf/ObJHTsk30d8WntqC94cgVEp3QgHwKtGcXxvIjyiv8GiJ4muefM3+KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGU7ERvknTg7LwX5lVQQyuwu6BswwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIARkjIrHuyr+rJNO\nWCb8vlhKHTlQTqa448O3QWysogLsAiBmqptqje/6eyXyxw8LOZwv0Lza40RGvjQR\nuYoxF/1u0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2751", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2751` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAb/ET4miEVi0N4ppSR5QQlXxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3OTdhZjE0LWI1OTctNDIwNC1hZDljLTg4YzYxZTljNzdkODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk5NzRiNjgtMzdm\nYi00YTYyLTkxZDYtNDc3ODhjM2UwNDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIo8c0LYtIlOh+KD3ZgHZbvmMP3ceJL+B9/04DLpdwDjmX0grYgTImJ231kSa\nyWS4R+dkhMdM5mYjFTAxNVXB6aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvNLdRzXbYwRCJSCvVRXegnrQPw4wHwYDVR0j\nBBgwFoAUaFGmepjpw8hDzeSfUH9WFyQvB0IwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD27QApDUdRZd9HGsyczkY573EhsRPa\nEI2TeYdlrD4x5AIgChut5IlviER6mqws1qv0W6lW6eCW9g72h3FmvM+wKmU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZezQ1rJabSsuN6phMLcPaODMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzk3YWYxNC1iNTk3LTQyMDQtYWQ5Yy04OGM2MWU5Yzc3ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASL1GC13ARIlj1HseOWIgzzMO9+X3vVsZ04TMTJibcMnrek\n4fsJa+ZvPCch2yoOJEXilDLps1XVOJ3rlng3Q3uBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaFGmepjpw8hDzeSfUH9WFyQv\nB0IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM7c/Z0FENpTORkfbL+XqKExOM3Jv7oUj6nJ4kFbxTDkCIQCQHHvw3e2u\n7Pn+c3RGL7Vrb5/pfLKrYBnj7sct3ZTPzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVnjMwLZWdiIFa0UD1s2wgbCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk5NzRiNjgtMzdmYi00YTYyLTkxZDYtNDc3ODhjM2UwNDY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDllOTQ3YTUtYjAyZi00ZTNjLWJiNjgtZDY0NGVhZGE5\nNzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExxACK9hKX9pwAPg9U2fNMAth\nExZ66UR87S+yw6YJ/KPuXX9m1eewveM7RlUYF9DCDpwDFL1R1gcxXVn2AsZmaaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvNLdRzXbYwRCJSCvVRXegnrQPw4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFUeLGN0F2jxoXlr\ngmgFQNOw5Hq5P79bJ8V2PKh5b/CQAiEArHlgv/cz8QRkApCs+yCcCUYcHHhc2DI2\nLGfVNDw9FOY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2752", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2752` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAawPLojJ6M8KaaBrBdCeZKf5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhZTQ1ZmY0LTIxYTQtNGZmOS05YWIzLTQ0YTMzYjQwZjMyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ2MGZkYjctY2M4\nYi00NDY5LWEwOWMtYjUzYjkzYzA0ZmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEuJ8++zksRvie6ngJLq9oY4F3hlSaJpKApTceCkpe45Q7r5/mNEXAcBNjBkX\nz1+9//DxKbPdfkv3eX4lbk6vjaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5FyDv88tZjQ6fPInp7kG49rqdbEwHwYDVR0j\nBBgwFoAUOiBYdGZgf0zrqWMAksXCnL7BgrEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCmasVG65ag\nxgx2Xb+NpWPUPVuKGTSD/M0QiwFzjsAdRgIhAP0x+rB9EiFeQOkjXeBhgJJlNMEN\n9c0L+wHZ9o8U7ous\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaGVVdUzwIJT64LY8p4iM7Q+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWU0NWZmNC0yMWE0LTRmZjktOWFiMy00NGEzM2I0MGYzMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHLBsCG0QqkqY14vDSwDOweJKMZlPIOR0lhxRLY4hXHk+1\nwsOWD6JGCIqHHSYf2tP136CPGafb6MA/E6UStUCVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOiBYdGZgf0zrqWMAksXCnL7B\ngrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAWN8T1oPoJgUaS9y5xB/r7cArDQzMTA3O+BDoPl8XK8CIQDZMK4grEUb\nc9bYbOf0r/Rg/FAaq68tvGcX4OhuIXBuEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAeOaT/rGJX55c96wmRDwOcIhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ2MGZkYjctY2M4Yi00NDY5LWEwOWMtYjUzYjkzYzA0ZmFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTM2OGQyOWQtZjliYS00ZTViLTk0ZDgtNTY1MTgxOTEx\nNWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5SfZqmVfMaLmJUg5bXq1S8QD\nudlY/+vhIbDnbxs4/yNkZcw4hWIG+eR0EwXBLNrohMqc1xB8PeJoAkgJ1+VxkqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5FyDv88tZjQ6fPInp7kG49rqdbEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGfKZonSSy4MR5p4\nipiD3pjwFWj9HE/dRm89rVZ8WwblAiBSH67mVexZstqokyUhH7l1Z5JJ2VQMJy2L\n6j13IRvCng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2753", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2753` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARPs4FCEbldThrz6tAnJ/vA8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlYjY3OGVjLWM3OWQtNDgzMS05MjRhLWE0ODRiNTU0YjRmNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZmMjgzNTUtYTg2\nOC00MmRmLWFjNzUtMTRhMWZkNmI4NWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/TN190ugZhEgUbJDM1Imi32RSQfEQ5uQYYiM1nFbX86aSihBSMRmJBk4DcDk\nIvZVX6FXQTqydM+97ly6915xyaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTcLOte7Z6kWIhYN4nBNINfK1VoUwHwYDVR0j\nBBgwFoAUs4oXmQ8uPItY5u+x3c6kkBfVYeYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgMhefZDNEm0a47hjdsOPvPFW6S31IZABAqdmHQjGtR6QCIQCORG8N/ac6\n/AWfgX76omPumkvDtjB7Wf1VwzkL7GaFfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfZKGuijwrpbi4naXcPwNYFIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWI2NzhlYy1jNzlkLTQ4MzEtOTI0YS1hNDg0YjU1NGI0ZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATENmBNpIa3zK83/WKeHtvtHDmJgj4iEmtsWq8etH1iI5IC\nguOt06Cm44V1HIi4hkxknR7f6NeTE9FoUNiAAHmKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs4oXmQ8uPItY5u+x3c6kkBfV\nYeYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANVXEPEIJZMPZFVWlhQnbp3E1MMX5Z+t4/7P9UCsUEUTAiEAkD9MuJ7V\nVfFbjaeSjdzjS5EKTIAGimjO7yGwOFvAZFI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAfF/eayFx2VQd0CUnduTxVbeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZmMjgzNTUtYTg2OC00MmRmLWFjNzUtMTRhMWZkNmI4NWYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmI1MWMxNmYtMjhkOC00NmQwLWE1YTQtZmQ0ZjFhY2Qz\nNDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER/ZxxCuuE5TwKkbhiCvIVBQA\n+sJs02pNRGYJ+6Jc1WtoJho+YSlLvyGibLLXwyJ9p5N9ju9jKLNrxQwehp3196Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTcLOte7Z6kWIhYN4nBNINfK1VoUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCID4E4OJirLeGd93b\nv27wnw4rQxHy+XrpNXUyNQLXIug4AiB4SlQQsn+VyHiPOotHwhp5Nz5cXRUzGsjx\n0ZqGFW0bng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2754", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2754` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAbV1TEvvAUwgdM5J8CeEu1nLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjYzdlY2YwLTY3ZTYtNGFlYy05YzQ3LTQyZWQ1NzEwN2IxNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYyMDZmNzctZGZi\nNy00NjdkLWE5NDYtMjAzMWJmYzk4MDk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYKpHGPJoHvgkFO/EJ2QwBpzeWs2mU0oZ//B6y+tvPCGIlICf3wHaWi43BaaD\noDY0ywuYsErJnHXy1dbMMDeSlqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3znsbuPOqnFfy7oJXmic/cX2rlswHwYDVR0j\nBBgwFoAUeM8ZDNoWcMGuOzyTtjM4OVH1PU4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJLwE6kTfouXmwQ5EbA1QAiJDYlt87DtaWNB7jBqigozAiBIgLlZ0qvS\nhIo/i42m3LaG473jn2WLALWuuSKgEw4sVg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ1OU7TejrCYBOEuVDw5fxwtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2M3ZWNmMC02N2U2LTRhZWMtOWM0Ny00MmVkNTcxMDdiMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQgHTnKJW7qOF7VtJtW2+iY6h2XwQDqovzjW28vO2C7cdY\ntuW3/PJx2QzemonfkQAqpUmT4rt9SkCfKg999BLmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeM8ZDNoWcMGuOzyTtjM4OVH1\nPU4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRu58syZX5zlbGNQ/r5Dj77qZnaTtvwPXzDKEJa9UO0oCIQD9lYv7gMaO\nbqg6yDrdV3SxxId8Qpi8i7drT+E6vNfq+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAZYwfdnfSoVcNy/SrnKcjtpMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYyMDZmNzctZGZiNy00NjdkLWE5NDYtMjAzMWJmYzk4MDk1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ2OWVhODQtZjJlMS00ODk2LThjNjgtMzQ3ZjMzNjBk\nOWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH+9dlXjPyaNTWKhpcQeDvTFm\nTKNOe4FBWYfe1WhjBgGzJOgPok7MPFPlqVIfRCVPs1esz6psNU5iRWSWKMCNfqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3znsbuPOqnFfy7oJXmic/cX2rlswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDjpMuYW12eZGN4\nD7FEK4z3kMLZLxJjHG8UX7ijyRs68QIhAIwTNh9O6SfeFZ5w+iYhi1L57kYQ/Mxk\ncbV/i7TBYXkZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2755", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2755` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAcVBm8XcWgOwYUf5v4lOOnNKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljMTAwM2E2LTlkZTUtNGQ1Ni1iNTFkLTY1ZTRiNzBmMjVlZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk4NjQwMTktODUy\nYi00ZTU1LWIyOTUtYmRiNzlhNGM4ZDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE82O5fnkf88XaH6iXl/t/ICIVnmxlLP+0iSpDh6ym/4JntYNI1pU0x95YGno0\nA8qE4xOJ+viChHdRkgPtCgtg0qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq3hRtCXUSi3OTjwrsI6LAbDBEdIwHwYDVR0j\nBBgwFoAUgGSofb9fGah96Qlqwc1EwkDLLNYwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDzR8t5N5ZSU/QZccGHZWmesN/A967SzgvrLEfugaGe7gIhAO0CtM3N\nCRhYtan7fmtEcD3rB8oOYEdGnkQGELl8zlly\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAav/fgLqKLld+jKxsM541V/IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzEwMDNhNi05ZGU1LTRkNTYtYjUxZC02NWU0YjcwZjI1ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfOVf1rHAswWZ+FlF0U51iXuwadaxv5kTrdGT3/yudfenq\nxdLAZX7KrZnKxzgC0+pyerk4vJwGgauf97AZBQj0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgGSofb9fGah96Qlqwc1EwkDL\nLNYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTamBWIgJBI1KyarxUXFA+ayLzUyFKnfldhbnNKVzVtsCIEwIo+hQjXgr\nkJ1QPEqXMiariJRV09r26aPvkokhjebW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAS8HAyNLL0w9nQTF7GgUB8nyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk4NjQwMTktODUyYi00ZTU1LWIyOTUtYmRiNzlhNGM4ZDBmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWJmMTk5MDMtZmVjYy00MzMwLTk2NTQtZjkzMTY1M2I4\nZGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDCeeJffmKdA0xg8t+u7/vZLx\nxqpqp08xt0Qe0IS3q+y+imYwjlrdMzQQfphpqQgg0CL3v6sZhcOyskiLRVf/xqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUq3hRtCXUSi3OTjwrsI6LAbDBEdIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDeDgfmfZkqlU6v\n1A3/W0VWYdINlRzgeWkEoODG4H4JFgIhANPT2eAxOUViAszhHEgEwRN3I/AO69JG\nv8r6ZRYN8PiZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2756", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2756` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAXjUNt1bOMvgongBU3qUd9i6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2MDcxZjhjLTUzZTUtNDQ0MC05NmE3LTRmMzUzYWUyMjE2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFjM2JkZDItMjUy\nMC00MGJiLWIxMTktZjIyNDc5YTNmOGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0bJ5ShaK0dwLwzQoPaXlV5VdxM1P+8a9gVORk5emaW9i4oqdn+V9yAmwIxh1\naxawYjPaxnYfqiq8BmD3eCBhLqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFU8eLhZcaeuh5a9AMFcUD7ZTWmAwHwYDVR0j\nBBgwFoAURCxDt0V0aNDLRaddppXz+0wsOs4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC/Q5AcTiP3n4OU+xl96Wi5ZyOmyBmZhxwl0kpk\nQqCh4QIhAOA3kol+r/3sQ0lYQbHsDl3KIxW+/WzZFrrPyLAPeGQ/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbdoOQ1Nu2OEON+ZabHc5VBLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjA3MWY4Yy01M2U1LTQ0NDAtOTZhNy00ZjM1M2FlMjIxNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCVm5ptkm1HApzabdf44rAtdhb6eqJ2hfzy2NGflPmffqP\nteuZ0SYoDpo8Bo2Bs/7fRhRSTAjMFX34uoKZHUtOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURCxDt0V0aNDLRaddppXz+0ws\nOs4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbdUbGVS+4euy9SLy78ZgFtKAEIrTEN5baXYKcPl/slwCIEgoDwnwInzh\n4m2jIfgWUyGUiMbQ5P+oK1tivjF8gAnO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATvlmjQHFgMBsLuShOHt+fwaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFjM2JkZDItMjUyMC00MGJiLWIxMTktZjIyNDc5YTNmOGUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTg0NTdiZTktNDBlMS00MTE2LThmM2QtNWY1NDJjNTIy\nOGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0fmLI+dkKkcjbBEjrAXCryrO\n27ySaI8foasF0j52reH5Oj8p1x7wQd7fZfqK2t21LC1rBpQDlylurUdBOal2EKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFU8eLhZcaeuh5a9AMFcUD7ZTWmAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEbdcFl7p/GxPLSi\nZ06+NrfP0z8TOTHTlah9xUJ/Q2O5AiEAiatSIfkKvAeaXK7u6xXDeDzWHupJVXfq\n0XKgc5P8WO8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2757", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2757` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQ/W4JB36dTFJdemHjFwVHZpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0NDljMDkxLTJiOTUtNDlkZS1iMTlmLTFlZTRiNDJlOTFjMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFhYmQzNDYtNzk5\nMy00MjE0LWFmMjUtZWNhODZlYmYwMGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcPjHfb7z0pWWGCZdL+IAV5ihBKwFs0uLKceIpoE3LTwpkKArzqNsEQfloivi\nO0V/KnVKIqoQ/0LJXeOE37ccFKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAElhEauJdiwx27GLhw4E4ftYikcwHwYDVR0j\nBBgwFoAUxGOvnKbXQDnfOBP0g9b5WkWzuxgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC9npbIVVYiLi6ZVjB3wYPlMLWgPMUuw8umw5S1\nGk/EnAIgHLgGi9VHjfEPjuhHJvzyEBI9Bn5g4eLLny90lH1MvZk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUqmL1Xk05254OTt7LpDDjBNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDQ5YzA5MS0yYjk1LTQ5ZGUtYjE5Zi0xZWU0YjQyZTkxYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/pwCcxeFb3oxS0g2HT1tg6AJ/4RPXwZzbEa6zDNUl7tiI\nsGE+ktxGbgtbTiahvUt58IlvrFRAw5uSvmYlwLB8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxGOvnKbXQDnfOBP0g9b5WkWz\nuxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJVkPy6jxOZVgd0bC2nPNIPW1+QVgBmTlQb4gV0h/ymlAiA1kWicU5Ny\n9IYQFwxsUFddEgF1djQZECdLJrRj5/2w4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAUqWYyuuUqeys75tE9WI/f5wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFhYmQzNDYtNzk5My00MjE0LWFmMjUtZWNhODZlYmYwMGVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWRmZWI2NjktODU5Mi00NDFiLWFlODItZGM4OWRiYmFj\nZGNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2YhqASUMdFk2ash0BRI5sJXb\nSw1EgUwFJLav32I9CHEJOOaw+8Dgev7XbaDxbeV0KhDlJUiOPXxNYSk8EbzzaKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAElhEauJdiwx27GLhw4E4ftYikcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGXg6DByUeyWakcU\ntJM8xcYlwdryDrX/j6wTsTQd9ss5AiAGVquAQrPrbjRrBSpVHbgnMBwXGsse5um/\nLMN+ZLSxsA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2758", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2758` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAd5Fd1KrjEhcI2UzB6WcRuKaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2OGUyMGEyLTg2NDMtNGE4OC1iMmE5LTRjNDU3ZWNhNzJiNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY2MmM4MWQtY2Zk\nNC00MmZiLWI5NGYtNDY4OGRhNDM5YWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK3qJL9TwuH0zUJTZB76J4Y6YfkLu62LYxWVK8ml1fYRSoYL8DGsb6VSdr1Ix\ntRF6YHKYSfC+sGSAsvgBevLLLKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Z5HTYC1H0AQyQxP3EEw6fyDEj4wHwYDVR0j\nBBgwFoAUiInH1v4fk1a1/8i6CsnoKRNamTkwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIGQpe4HcexGer2a2qYHro8hBsqTfGzXAQdH1+d0Geb0jAiEA\n2RtDfQaeTodzUgzuWtQy6eJmC40eq5VvLUdnLRqJS04=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe6sJVDf3mwl2modPNPvyEu/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjhlMjBhMi04NjQzLTRhODgtYjJhOS00YzQ1N2VjYTcyYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcjU/A+d1kCMCq5A0/X8Pb+KPAG2Py0HbFeQw4dmlHv+je\nfw5YDWwQWyFhV8MODKtWMoK+3S08V3WHfa2eydj/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiInH1v4fk1a1/8i6CsnoKRNa\nmTkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOw/EXz66p58sulfJMdbWN2oh8ZyTS0AG8A4tGYftuZRAiEAjMN9qofz\nyf/LqxfDuUpsots82hGxiOn+CQOpYGLSsO0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAb7qGeX5Mf2LoFN43awWd4DfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY2MmM4MWQtY2ZkNC00MmZiLWI5NGYtNDY4OGRhNDM5YWRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODMyOWJmNTYtYzE1Mi00MDNkLTliNDktZmMyZDllMGQy\nMzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy5MjdUWe4/ek2JOWoF3FB1IS\npvcwgbDrfx/SGCpHFThEtjr1AVbvMP4NjQJ3U5rVKhj2ngohElQKSSt4B0M8E6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3Z5HTYC1H0AQyQxP3EEw6fyDEj4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCjskoA5n5T22Bv\nBurVgIiMhrx/Dww4Ti2AFzcqBkuD7gIgMRpkCAbSLJNiWzBfB395rLn/PNethvAp\nnkMPyBUZJ1U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2759", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2759` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAdM0oPzOp5ga4cjPyYb77mFhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0YzgxMGFkLWZlOWMtNDJkYi1iYTAwLWY0ZWIxZjgyNGYyYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YyMjZhODgtNDkx\nOS00MGFjLTliZTktNTlhZWRhODJlMGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDoXMVw3baPhZGrSCaRusgUI7OU9cqfyb0CZrLnQfinXZvwLScTs8uoOJ7uwu\nuLQQVrTkSBA+KFTbR2nWksFGTaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCAEHrx+z42NAqsae7QFsFPLAbYAwHwYDVR0j\nBBgwFoAUjObk8UCUY542Kdty+do+l8F7iBIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCU6CqgJJxiHg/8LHRk9VR7cVhgLdlR\n4vc4Bdd7LpmsZgIhAJvpggyndPvvxNAAIsTdAEhSjLkn4tv16dvwiDjFbT3T\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfj1pNNLX0izF9oq0jsA5P55MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGM4MTBhZC1mZTljLTQyZGItYmEwMC1mNGViMWY4MjRmMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7V1oG89Lq3MBZUODSZ2gEnycS0IdAzSpg8mrg/FO0bi/z\ngX60Cz8Lr879MFaM4zE/U7C1UkXh1pjt1HqLkQGko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjObk8UCUY542Kdty+do+l8F7\niBIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWkkiNe38mGgcvT6O9GeaV/+XeavpmbPX7jJ4Qo5iHqMCIBtifdj5Gkqp\nYqqRHrq46zCzaW1exf9NPgnndQem4RjZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYf7W7Uj6fEIxxWsaK3TXyUZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YyMjZhODgtNDkxOS00MGFjLTliZTktNTlhZWRhODJlMGZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjVkNjFkZWUtNGVkNi00YTcxLTkwZGEtOGRlZjdmNDlk\nY2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEye0eG1HE6m7TxCb4aFzdaKtK\nUAm75nV8YzYPwOSmLpWftDMQY3ibBjY3c6iSszYO+dL+YgKvNJi1bE50YFXbqKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCAEHrx+z42NAqsae7QFsFPLAbYAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFgEd0UnSv64iqD0\nn9UHEVrGNFeNc/jA9clly5JsuLkvAiAModXZKrUcMSWvk/euGMWAv5vVxq1gMKBh\nVQ6VQsucJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2760", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2760` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAXFJiqhDmJFViIaH6VVnWKkIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlZTVkYzBiLWRmNzYtNDQ4My1iYzg3LWM3ODZiZGJkNjkyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJiMjFmOTUtNDU3\nNi00MmY5LTk0OTctOTE1MjdlNjllM2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE83O8A9SjL2cZ40MKYKGkxJgRFBMZFw80rS/Q7++Ea7TdrPBRAtFOiQBczoYe\nKERvr7i3agmA1bh7DmvNNBtvR6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULeU1/fC01c73ZQE5BtTVP5pc3UcwHwYDVR0j\nBBgwFoAUqAZjXF9KEXRXA/lJ2355sMyi4EowSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIFLWadYtlczm0f0CAmRFdj2NzH2aN3X8\ngmI91Zio06eUAiAViKMGnbfRzq34o0rCUKa61j8oV7U5nmelKw73ExpRMg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfFfMJFSJ+wD6KeaiAmnQtRwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWU1ZGMwYi1kZjc2LTQ0ODMtYmM4Ny1jNzg2YmRiZDY5MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcXWg6r6u0HBm/gERf++akKKDFIBFWWBuIoQBvlBQdqouC\n+LMDEsL2fONIunBN+WgnQQzs1cyQXiA9EO8GAwiLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqAZjXF9KEXRXA/lJ2355sMyi\n4EowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP6IIjbFUQN/PQSQHZC9DWTpFqEw4vmEE0BSbX6z034FAiEAyeNU4ne8\nb5seL8mMfEHEVotxV9mXyjSTppPArICymB8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISASaJReVvDqpsGgUsmBY3p7b6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJiMjFmOTUtNDU3Ni00MmY5LTk0OTctOTE1MjdlNjllM2E4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjVkZjhkNDQtYmQ1Yi00NjYyLWI2ZTktZjVhNDAyZWZi\nZTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8PNoqCTu8YjVVFVDiOCbv5xb\n00BQDXi5hol8v3ow4HMwHU0GQ72gc/vzqE2DHKwrtBZuEAGwTIKss6saYSjcqaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULeU1/fC01c73ZQE5BtTVP5pc3UcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCn7uniwYAPq2Lk\nuC0UXNMOkxCjGNVc1HwrOhRJSWDn+AIhAOHDiPI2LmH8gRVCtfMVy2rpFwjokvFT\nMnLeZ2SrstX9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2761", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2761` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZOQDt+cPWTYzabc6/dNoT2KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxMjRlYWRhLTA4OWUtNDkyMS04NDc3LWU2YTJjNmRjOWYzNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGM5MjAwOTQtYWUz\nZS00NTg3LTlmYzgtZjVjZDk4ZDNhNjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFBIZ2zMxyWpgxTd0uOEkt65MRnVkBmoJ5yBw/vgawRGiRH5LROAhrGnBwYVl\nvVUGq59sn6H9YzlXGTQ0wFtEaqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDpB/uog/fzsHh1B9v9NPxXbGJkZMB8GA1UdIwQY\nMBaAFOJ6GL70xfk4YM/QtDA8CrJ3sgmgMAoGCCqGSM49BAMCA0gAMEUCIQCd94oe\nth09O5dJLuvu7jAihuCHNfpyvRQ6XmhZeSM4/wIgMOBuesVXqi+FscffIyar8kWg\nmViLQSOPtRhEIyKtWZM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAct7UNYABR4B52wobjoPj5HhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTI0ZWFkYS0wODllLTQ5MjEtODQ3Ny1lNmEyYzZkYzlmMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATttQIRXjNJFj45lEVpISb4a8K/aDzDE0Vkv93i1amW0uDh\nX25LD0DDIYWJo6KADrdVbm2JrIt0Miy+Sbg6goJ9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4noYvvTF+Thgz9C0MDwKsney\nCaAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKTfY/k7lZxshbkrI07Hffoi9yuKqIOD1eHmpeZDq2b5AiEAkr0uXlbP\nH2t9eGMILjS8y9Jv+J2K5ZEED1zxlbZfwPI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUbJz951f2w+iATEaw+PfkxzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGM5MjAwOTQtYWUzZS00NTg3LTlmYzgtZjVjZDk4ZDNhNjNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGU2YmY0MDAtNTdkYy00MzU5LTg0MjMtMmE3ZmY0NmIw\nMDgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE+vF8JxK+gNaChQrS9L5Y7Og\nnkFuwYLXbdMRW1I+TL4p9LYP1Tl0L2p7xVo5REH1gT7FgTZe/BXmqP2iATe6XqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOkH+6iD9/OweHUH2/00/FdsYmRkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQClNmkF\nQ78OcMU7d99EOwXBOzUvNDWbVfSHtvRAQeZnogIgbgWQrQXjUtIBVuUOgbglXt6z\n7cFsYP4BFGe8oSra9Gs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2762", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2762` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAbnHaFVoSNvLVH5AwpWge93lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjMmQ0ZDFiLWU4M2ItNDllNS05NTk4LTRjMGUxNmY0NGMyYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDc2NzZjNDMtYWY2\nOC00YjA2LTg3ZGYtYTBhYjViYjNkODAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzn9sYyUw/Gv8YepQJje3mCqTZ6d6OyXg6kY+SVuAfzow8KOU+TJGB10DFvdp\nUpNBNl/Llb9Gy5tqa2rVJaSRkqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOIELIHhUjB9DhKOyxyla/DCziAzMB8GA1UdIwQY\nMBaAFKfOsjWIkseSOLwmJjC4CkuLxvLlMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAoOVop9nFYRyv2T4wPOtf1rXbcvpncC0p\nrTKNCtu+VLYCIQDZ1vnbjz9zjmr8B8e+NWt8cF9k8L0hRw7Wovmj9JkqtQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT4FjMOhKxp+SsWTDqtJwYiwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzJkNGQxYi1lODNiLTQ5ZTUtOTU5OC00YzBlMTZmNDRjMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm/BPS8hL3VkPdLIi2BAjouH19uRaUMojlFL9JC6x2gIbw\nrV07YQiZmKa4V4IDOSII6d4A8RhXKAjgrTnc4nPTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp86yNYiSx5I4vCYmMLgKS4vG\n8uUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRuClFkt/5lF2z73cWZEuSOp1RowiCEpqkBGTQ6lpT5wCIF2W03PGxRTy\nFnrszU/+sM85cfss+O/jQ9uZISv7t9zw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAZqL5gk6S6QgtFlR8RrHJnoPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDc2NzZjNDMtYWY2OC00YjA2LTg3ZGYtYTBhYjViYjNkODAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjM5YjVlMDMtY2E4MS00Mjg5LWE2ZGEtNWY5NDZkYjFj\nODQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuYMUpFPZTShk9xf361l3f8ml\nHKQ/C/LTRcfiN8TWAPRKWqrUIt00ETqZMjS/XoN4lWh4ZPn6N5oXK8+IvZrE4aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4gQsgeFSMH0OEo7LHKVr8MLOIDMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBVrYQfD\n8WKSqElZyQ77mobzqYtLaKPiPy5vcVPDqk1oAiBfmDwc+w+d4l9SXXLai98binEE\nrWnPM6h5Rkvsn8mIig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2763", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2763` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAd4YRFSSyX1wV5ewbmEnOhTUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjMjQzMzQ1LTJmZGMtNGU3YS1iMzdhLTBlY2Q5MzBiNzRiNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU3ZmE0ZWQtNzFl\nMi00MDFhLTk2NWItYmQ4Y2JlZTVhN2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4OsQ2v72rrHNIiHxaciLSxaNqNToY+SKEHFDoxgoCJxJmuqstcRVgZsXt7H7\n8MyAtjQN9MI+YSFcSOaGMTN1EqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMQhh0DZWL6WLqRxQ6pnFvq/p9WIMB8GA1UdIwQY\nMBaAFAvAagGXQWfhVGWS9JC+yQ8ZazZyMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAU6coRAaZMIcPSN5q0ng2OQ+jf64m+v9qa\nAU4KzS3/KgIgVRB1cZcS5t0m6yQMdmtU3/+RNBOjELy/6IYmB82Gd5c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ9HWduHMZPVOk83L9olGYhqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzI0MzM0NS0yZmRjLTRlN2EtYjM3YS0wZWNkOTMwYjc0YjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQyIOMEuKEM34sxoe/1WevbqDh/oO0FlzX4v4NHrxxF3rA\na9wh0iVRO6Dz+W9L1scOVfg6fWKE8wZZpZPxmw7Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC8BqAZdBZ+FUZZL0kL7JDxlr\nNnIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALZ+v5QYK0PN8tCEyUe8ZTqlnii397rT+Qh6pD0W2wc2AiEApkDXVcbS\nXsTmQAAMRDfTT1DrMWsifZdhYg7UTAHW5kU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUe3J3iq4j5kZhw1WZ2nkZ2UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU3ZmE0ZWQtNzFlMi00MDFhLTk2NWItYmQ4Y2JlZTVhN2YxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzNjYzUyOTQtYjNkNi00NmVmLTgyYjQtYTM4NDEzNjdm\nOGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6iUcwebinrQhAsxJbfPOtjCz\ntC/oAkh3fMntcEjmOsQTLHad56T/hXbwolEXqLoBrH576b0RSBKw+raJvSmVBqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxCGHQNlYvpYupHFDqmcW+r+n1YgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCnoB7o\nwaTVU7aohFke/A1+akUJFv7v6d1pKxLB0kjjxgIgU5g5Uwp62bFam1LrfUg/EFky\nuiC5y7wsmQc3lIM5XAc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2764", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2764` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAfPRZGRRhGY80f+ERU6d/rtBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3Y2Q4MGFmLTJjODctNDM2OS04NjMzLTMyMjYwNzdhZjQxODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM2MmYyMzYtYTYw\nOC00Zjc1LWE2NzgtOWNhYWI0MmE5NmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQpGmTQX92Ty3dRUF362Oo9SASKZ60u1FO2yKnzOxGKowJshDOkZONSWehlJN\nCfTOuzJmZzSmK/ecxN8QzBR/M6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRaBr3v+krk08IofmbHCRyZC2x5wjAfBgNVHSME\nGDAWgBSNtWAfvPTo/COvWlG19qvT0NQvIDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD3pMK0cdfSxIzs1ChufH4q0maqXCo1\nxHL34UoQNKmuxAIhAK+U4OWt/xEBxjwtPlQNUiJorQufvS//JhxBQFLDjPT4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARXTLEH4tYgS4a6VVG/xbxuuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2NkODBhZi0yYzg3LTQzNjktODYzMy0zMjI2MDc3YWY0MTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxx2XiQn5bAV64UGp6WnDeWZbGnQraO6U4H2RKHgSNJE70\n1llM6A96YHfJL07AFD7bGaN0A+19VcjsASY88OkPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjbVgH7z06Pwjr1pRtfar09DU\nLyAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIbujfeSSdFKktiX70fzHHmD9BVJW/o+U9jbuU8eSXUPAiASbNDrFO4e\nTnBdHlo1mz7rFUvTwqpkE2he6RhUXk4Tqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAR40nw6lvv6y6P2XrfPeOU8fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM2MmYyMzYtYTYwOC00Zjc1LWE2NzgtOWNhYWI0MmE5NmYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTY1NzJkN2MtYTA4ZS00NjA2LTg0ZjMtYzkxMDY1M2Ji\nZTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4Bxw/tOKpEIb/Pl1P4Wt1cp+\nwmE2G0ff7/Su4YURPCTyH80waca4IWree2gO35pB8YByuGUEgJFdWT42NytojqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWga97/pK5NPCKH5mxwkcmQtsecIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFZNK6w2\nbW8iuVr34ExfWhenvnqOkRvXtGdTvj3YhGg1AiAUYHaowiWHXAeXFJvLYW6pnJ99\n8cO2TojTHfI6t0T7Ug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2765", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2765` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAabkiOES45BwxImWB4Md9hxDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliYjZkMGM2LTRjNmMtNDlhMi1hYzQxLTM1NTRkNWZjYjlmYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUzMzNiOWItZTE5\nZS00ODYzLWJhYmYtNTg2OTY4ZTA0MmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKoYzJM4O80X155HRuQgpIRlI+CmeQFrRpsSljG3dwg7B3mRo33F4ZzJPwb6O\nqN2ixd78/KO43NmWpyTbdw9EFKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrgv2Mjdfp9mNILzneoeadYCAzOEwHwYDVR0j\nBBgwFoAUEMwP4nnwSta50+jMCbYXP+K8+IYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBz5mdznmDLPY0D\n+Sa8Gi23ShzGQumBHYvCHlKi07QzCwIhAJVWldv5dGijG+KBIEVhi991HoYRO3g5\nH3iIBjouaEUU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW5Owf7FwOnUbetz9VVPU7coMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmI2ZDBjNi00YzZjLTQ5YTItYWM0MS0zNTU0ZDVmY2I5ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATh+bEiLviL84m8IMQAWoTmYsQCnh2Aivk9RNUkXANNhPBj\ndi9WadbGHhUw/KmI6oUGoBXxtxPV+NbvwmRagACBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEMwP4nnwSta50+jMCbYXP+K8\n+IYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeizRlHQTezDP+3YHPkQZzKVoxo8OFtKqyWP2i4kOWYICIQCUhoFVlusi\n1xE3KCVa5Y8/YLGS951p8Unm3Dgb0mhUoQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQ525kkgiZQYJtFM1eEfdFVYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUzMzNiOWItZTE5ZS00ODYzLWJhYmYtNTg2OTY4ZTA0MmI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjdjYTBiZmYtNzAwYy00ZWRlLWExMzktMzI4NjhjYmI4\nMjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQSG4iR+Un7aVOPLMks45m9Cz\niUQHowVIH90Nh4vvleh5HhGuqJofphjT7TzrGxwR+Us7GMTej0ZjJlEQa67UgKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrgv2Mjdfp9mNILzneoeadYCAzOEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDQsGKj\n9j9Bk5UZ59DryzEx6fPQfEuruFsnWss7y1k11gIhAMmZeEjnJe05dquGwXJfd42d\n02KvAwxZEBJ5Lp4aj6OC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2766", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2766` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARo25+F7zOVEupgJwyekm3jiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1MGZkMTIyLWM3YjMtNDhjYi04MThhLWJmOWZiNzQyZjc0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZjYTM0NTItZWI2\nNC00ZmQyLTlkZWItZTNkZmZiY2ZlNjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/RahXQPB+VeaS8i4ean0qzhuAQVYUxukoENIyPwGWBJEmjlSzCtv25wexWf+\nW1ipfoi3stoV60+p3jHeCLN4LaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN9cXZ4KqpkaGCVpQ2wmZ+JRNADwwHwYDVR0j\nBBgwFoAUn1YnKsj20xKGLOUNuFfSeriKtp0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAm9xqnEowZnGn\nr58k1ZoqlkAAJ9Dof0otasDaVVl7Ir0CIHoqdskEiZzbfag76cJO6kayfZxF26hY\nYHtzN1c/EGU+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdAe6UZxB5baD3om2Byc/r6nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTBmZDEyMi1jN2IzLTQ4Y2ItODE4YS1iZjlmYjc0MmY3NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvV8E0OQEXhVBaiuOaovGkpuvFQw1BKxKrmRjyaQvVW8eT\nojwOZTZOZ5YoaT0jyE5RRFxWLFquWKcpWnE0Mpa3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn1YnKsj20xKGLOUNuFfSeriK\ntp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN1xgKN0LoMBSsRnfeVYQuTzNLoVSB+gM/i+K+acrneMCIAuO+ZCqQJhI\nDHuBK6LlNcZFLjWr58oaVQzop9s7sUc3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAadSgMG3usWK2cMxkv0V7/koMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZjYTM0NTItZWI2NC00ZmQyLTlkZWItZTNkZmZiY2ZlNjJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTZmNTExM2YtMzRhNS00NTVmLThmOWQtYTA1ZTc5ZGQ3\nNjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtXpBiNNWreHNn2WRdYQeWInk\nMp453Z6AibBUisqSFl3YElt5tJlutC6rPbD1ma/SUzvinW/rvwDrk+hY8Gnb9KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUN9cXZ4KqpkaGCVpQ2wmZ+JRNADwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCID5t01pU\n4eiIzKD0SASKJ5sP+3fCMxK4LNmmKMpBYeV7AiEA/qBEslIlU7HQ/BMUElRCtrd8\n1kXHyhVfHskB5PVk7gk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2767", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2767` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAWP/JsSyMbICSGruKO+xb+WmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYjBjYmFmLTljNjAtNDJiNy1iYzBhLTljZTQ3MzRmODM0MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTFiMTlkMDctYTQ2\nMC00YTFlLWIxYjctZjM2Y2ZmNjc3NDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmZAYaEApkHGCo45T+yBwpBX3d2GLpVfGFSr6LUMQlugrWEFunaW6RAt35iPP\nnKlSXne8OvxDQ1rfjKuQK1NBtqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnB4+aZk+T/0s/QqTovlodzGV7SkwHwYDVR0j\nBBgwFoAUK7y48J9gQsabn1rDiE5gergEvZ0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAnq76hVzHi2tZIIFCUfVr\nyYEQx52L2IXJzMHqAtga+dUCIF5U0si0FvJA53V70LitgQ6t+phg7rEoXbLrp9J4\ntumP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdFjJ7vQPJ5qqIGQx1m+S2RkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWIwY2JhZi05YzYwLTQyYjctYmMwYS05Y2U0NzM0ZjgzNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYFLHL00id3FVKJ5ArEb5H2gM1500zARJXmtJCF3ZTadq1\nUC/nFIIw2a+Fx99bFbh7AS9ieI7FLpRFbNSxT2XJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK7y48J9gQsabn1rDiE5gergE\nvZ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEWHA+LiyLPYMftq13vkMUYnoL9k8O8k0fwYPbPJusDECIAI2QoNKU0EK\nWCmQB8QJREbxmx8XBCsFiWM8bzUdvnV2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaoJjpVdqhZzaTr/A0Mst1n/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTFiMTlkMDctYTQ2MC00YTFlLWIxYjctZjM2Y2ZmNjc3NDA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTFkMWI0MjYtNzdiNC00ZjM1LWI3NGEtMjRlNmM1OWY1\nNzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZGVkC+HHXdqii5pqnRKQz5XI\nyu3xpnbr78yxL0XWw/EpMKW1EdwvRFnUFwAs9w71ZV2kjVD/h9gxWHiMdg5+faN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnB4+aZk+T/0s/QqTovlodzGV7SkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDpDq9P\n36HJ5SvsqxhgdzloYNdFI2Z0U+Ol2xJ0RgQ/0gIgEOUxwGw1CDhuqOByaz386x/2\nqTb7hoehF+LR3HH/WJQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2768", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2768` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAXGh3d5MqfHEZM9heb5cYwgbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjZDIzMjRlLTRkNzQtNDVmZi1iNzlkLTdmZDgyYjZiY2ZlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdiOTgyZGEtNzQx\nYi00Y2ZiLThiNWMtYWQ3ZTY2YzNlMDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJRYW8FBZrJIPuVRLrJ8YdHSrf8U/Hz+OePlCCdj6NozGQeWnWNqLlhG0sFHP\nL/XeSAdakft9UW89q4gETz7CDqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr45f5qWlw3mkG2MCUFWMpSL4+m0wHwYDVR0j\nBBgwFoAUL8UUKxW/jCvE0FvxfF+/hlCUncYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAnNvv\nBiOpHr+3n/v6902niiC6r+X4H+bAZsb+Sn+Pcx8CICuaZZ6G1tqPHA/u/lvji55y\nqFRXgZF44zBkL4MUSoIT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZe4WRtCtEWpua0Co3NPhVm/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2QyMzI0ZS00ZDc0LTQ1ZmYtYjc5ZC03ZmQ4MmI2YmNmZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMbLcoNqy6VlWLvg9nGeMW4VMkqIGSDckSI9Q83OpRpVip\nqUdqaVfwBPvSdMOy3+8OW3Vri/7y80fX8FXhreG1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL8UUKxW/jCvE0FvxfF+/hlCU\nncYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN3H7jfjDKZIS1A0deY60nHBCyb2IsQReCO1nw3JifmgAiEA8WN0wCdS\nihfk6Syamw1VcHFZLEN/Gglfh88C8quAf1I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAX9i1c0Jx7vftTN5pCByw5SnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdiOTgyZGEtNzQxYi00Y2ZiLThiNWMtYWQ3ZTY2YzNlMDc3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzNkZjdkMDAtOThmOS00Njc3LTg0MmEtMzRiYzQ5MTg3\nNWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmwjRPOIkdRm08UgniVmhfglM\nvjvv9+WZ2q83+X3OLSM+uFEyc5knVuzGunxl1Tbm0xtBiptG60AqNTYAu7pJn6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUr45f5qWlw3mkG2MCUFWMpSL4+m0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICSCtHMX\nxlsPy+V/+xcCTuCNnSiIjpIsgSTjOQBwwFxsAiBBwBHh3mejEKdV6gsDRl7m7urN\n3Bc5+bwgA7rjUKJ6fA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2769", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2769` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAS+xuLtojegQtIADLm4YHqhRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3ZDNiYjkxLTczYjYtNDczNy05MWU0LWZiYzNlMzVhYThmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc4NmU0NTMtMDli\nMy00MGMzLTlmMmEtNDhkZTIwNjk5MzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe/m0QQCsAin21+ghEW1pv94c1MWQAMhL1lyHo9TlXqovhVNI1SMRAyKK/qo9\nDgtmIKiERlLGanUn5q0CSK/aSKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF2qV/1PCKyNV2UmXEdvcAA7Ex2swHwYDVR0j\nBBgwFoAUfjkOyo2X6HP26iEYfokOrPGnAVUwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBz8eyC\n0YmiCSpSEale4Tw7E1gHA3gPhig/1piZu/FVRgIgcQ2e4NqnAlY6c9Dzq5aYKxyi\nb5Q57AQZKXbUtSNIQq8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAayraNpR7lFVKIhnhTmbrKv0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2QzYmI5MS03M2I2LTQ3MzctOTFlNC1mYmMzZTM1YWE4ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvIbItLoE26AcUJEZfjrkD8T1enljFBg3a9IZ3f1LLMIIp\n6rapQCjIZrTQ2jq7YhFgmvxrywd55hFDQLdiU0cco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfjkOyo2X6HP26iEYfokOrPGn\nAVUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKVnfVEBqZrtmHL8dpbaUo9dSE4WR7UNPEjg3JJ1geVsCIE/SswX3xDJl\nrTEI/gNaUhOiXtJOgneGoTh8FsXaF6Ua\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISARB99aOBYgo1PyS94OfVVzMTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc4NmU0NTMtMDliMy00MGMzLTlmMmEtNDhkZTIwNjk5MzI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGVkNWJhOWQtMjk1OS00ZDA0LWJkM2YtZDZjOGE0ZTMz\nNzNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOoFiGqPIU6pJ4/rX+UD/gL4k\nxWyN72dzrTldEqgTkjRJvtTEvYS8V+7fXqyY3vQiFZxqw/YxeVsmhT+Dm63Aq6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUF2qV/1PCKyNV2UmXEdvcAA7Ex2swIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDh8GqV9\nnuVsDx8LMdg2cKCoPE5loIQ25K6QjBuJW4E1AiBmsUFnYCCRAJrTrRiKXDsU6JA9\npQiz4Tt+KJ8SlVLVPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2770", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2770` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaxdiYAXPal2UlDOCUJjRwP+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzOWJmYzg4LTUzYWQtNGIyOS1hZmZmLTQzZjYyZDAyNmQ5OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDAyNmVjM2YtMTJm\nNi00NDVlLTlkZDEtZTAwODdlZmU5MGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGrHwwkB+AH8+Yz/v1e5186hlNlvFjsulPu5LApdx1dbR85mr7huMkxHZMYFF\nT5O5qTM7+iJBkO5BzUxbSKjUcqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKtUntuRUpZ5/hEt49i5GXeApMOLMB8GA1UdIwQY\nMBaAFFGo1xQvSTQDLcvJ0elAYuxLV820MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiARlSDJntdR13F9xgkh9g9OXgdatUv9vnOR\nkj7brYm8QQIhAM8RP2c8pcnFMc0G/3mbxHZg5R75fmVx8OH3eL4NeULZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUWi01kJK8fA08Mp8EhjhCwwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzliZmM4OC01M2FkLTRiMjktYWZmZi00M2Y2MmQwMjZkOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDq8xZbLMGabZSkvGHul6ZVfejg8r939eM3xzUCr94fW9P\nFve2Y6fcNGf0xed6F3G03UyCj9lxE/blwUO4iUcro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUajXFC9JNAMty8nR6UBi7EtX\nzbQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO2wlis1pwfX/NjZAWiHPvsVf6R9NCFTzxd50Hr5guDgAiEArrkZv0OF\nI8lH0zgMe4/NYuGFOqW9ExCkpOeiLK4Vcpg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAcfZbKZiO/RC1c9BVqIia5JhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDAyNmVjM2YtMTJmNi00NDVlLTlkZDEtZTAwODdlZmU5MGIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWUzOWU0MmUtNWZlOC00MDdhLThmMzUtZTJiOTgzMDgz\nNmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYZql3gKxq7VXmBD5E6zKEaDG\nIDZXCVQgei/7YBrGLH5ema+YM7cc2wy3Ce4+HM/0vWPJz2WgAWHsNGg6Psdcq6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUq1Se25FSlnn+ES3j2LkZd4Ckw4swIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBu78Nj9\n5nnisAtdO6lfYwcMUHAQ1hKU20oskBzWb8UNAiBUqMrWNfeX9xyt8GDOOA7Iq+iu\nASGaMIeF1ZF2GXuawA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2771", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2771` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAXnOgfkPasGbpYrYyB+mm2kpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0OWQ2NGQ3LWZmZTEtNDlhOC1iMGRhLTJhNzBmZjk5NDhjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M0NTkyNzUtNGMz\nZi00OWUyLTg1NWEtMDUyMmMzZjAxNmI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERgLTQ/ULvwAkzb5AWZWAzwqGaH5EbGu8SPXmObIx9jOb0qKlN3aUUBQuSn7K\n6bf3uYUyBLxInYQajF1QOPpfkKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe4Z9m5HEss9AGEqcYLaHorAw5egwHwYDVR0j\nBBgwFoAUemkAz6f0iH2ifkMZZS+wmnUO6E4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOTXBCJJ4Fcq\nQAuO7teH5OFSRgoSUrCfeDELPLEhkTN6AiAH+f70I3pgTyZVK7SrhR6XwYtsgQld\n/rzLbE4en4n0Jw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVg92wbb6wFXC+VsGd890r3YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDlkNjRkNy1mZmUxLTQ5YTgtYjBkYS0yYTcwZmY5OTQ4Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQVqbScEBPT3hbkHIZeJH1z4f2CemNQDXLh9+2e+CCQMZg\n4PXjAZNfARvvtAXyV0+raWa8brd+DdMVhQk7kZrbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUemkAz6f0iH2ifkMZZS+wmnUO\n6E4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGx2DmCz1cFo16NhG/YSLgnqYJZBqHvMjoHV6OoWs0ikCIDkn5Uz8Nv/R\nSngCbN5uKpNjr6vzzhPasy7SNoyJaOfk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAT+otfqANuvcZXqolmjgdTr1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M0NTkyNzUtNGMzZi00OWUyLTg1NWEtMDUyMmMzZjAxNmI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODFhNDViNzItMzZiYS00YTk0LWI1MGMtNGNmZTk4Y2Zj\nYWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtk/Rkxv/cq63R/GGbdlolkD3\nT3vU+sbSIa1mvPeovdU55rtlG1niDPU5wvvXJNplLuxNblPZgFNdaDGJK0OugaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUe4Z9m5HEss9AGEqcYLaHorAw5egwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCCFVHm\nieMVbKX4dqS9uHj6JyqEz3chtHbHNz0iUzRjfAIgbVpPe8mK6Uxe5vkymFfl/UN2\nfBjMiXSB2dk9Zkpii9Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2772", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2772` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAZKn3H0gcp0la0Ps06GtCLHkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2NWU0ODZlLTZiOTItNGQ0My1iOGQyLTA0MWJhMzU4NjIxYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzliMjFkNWEtZmI3\nZS00NGUwLWJmMGUtZTZhNmEzMzkyM2MzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVpsUfCLt969/J6/IdppcFWeULfd/O8edpKdVXHEonEVPX2t4i0CoN6Oe142R\n7AAVvD51cMa5rUD/YkJzdRK2TKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm6gVpBOMS03+L6p3rlQTZLCDiYcwHwYDVR0j\nBBgwFoAUG/aJM2FMYFG/vj8SR3WmjZ6IZt8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIKwtqHzD1os\nzLPEiWNcdC9pzbWCsPyio2Hi3Cxu//AzAiBxpwyMPwYO7EdwTQtAObrtkuoGA1jE\nxU2NoaIXkiktnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASXVqg4eB0PeHIdXqPvnW827MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjVlNDg2ZS02YjkyLTRkNDMtYjhkMi0wNDFiYTM1ODYyMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqN8zwCurooQH4ABHLs1xcd1O3Z/7JO9nJDgdnmhmKRsiC\n/RKm9Ur+wc+vYYNQ8sf5EksYw58cYEDCAWbayHJwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG/aJM2FMYFG/vj8SR3WmjZ6I\nZt8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXo8hWkr6xLsa3H8RtqJQDfhiSFHDS0aqpKty8sp2GXsCIAXSBRF9dD9Y\n7cQWdaT3NLySEk40vSRuZ5K/6hmCFq84\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISATu4PY3VoA5jr8KCdSp6wptGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzliMjFkNWEtZmI3ZS00NGUwLWJmMGUtZTZhNmEzMzkyM2MzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjkwNWJlYzAtN2UzYi00ZjJiLWJlMDktYWMwN2I3YTA5\nNmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/a38817KRhjkAE28If/TjwdA\nb/HQI621TSZlfGPphTTLIh2N+usQkk+xEBhL4H8nwyNaP0OHU4yG2i0HGyhUZ6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm6gVpBOMS03+L6p3rlQTZLCDiYcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGLyrwMI\nKmQbJNUPeA7OgFtKljYSTqYml5lse2hj80WsAiAjEke0piRrZx8Hg6naIYoLWIH7\nRHJx0w/HIVcKif0/yA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2773", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2773` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAfY1umKFnDQ/umM3Rjx+prSlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkMjdiMDk0LTE5MDMtNDZiNS1hNjhkLTc5YmNiMzE4ODY2MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThkMWE2NTctNDc2\nNS00ZGNmLWJhNjYtYjBmYjA0MzQ5OGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3inMJfx21cgCToUG9rmF++xq8DX5jCHhvKGCD65Ucx8xlEGgKEpCDC8bLwiW\nv1LjaxSHAw81PISXBy8yrWGZ1KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq0Ctcrwi5KdNtb6cEpcqHZLsvMgwHwYDVR0j\nBBgwFoAUVUrErNAJk0TmMLgLktVTYG+w/vIwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCSGdjLDccb\nUsefxYBkUsz6bZ5UvM9H7I89y3DuQj0YvAIhAKW2Wz20PVCagd7xFQFWFEvCp+FV\nJkMvEsXhNLLhF4Y3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATH9y1fse3b5kr2mRWEBsppBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDI3YjA5NC0xOTAzLTQ2YjUtYTY4ZC03OWJjYjMxODg2NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJeHGjDSPNG5LSoYal69QnLgKiqQZw7k0xg3n+iqcTM8sS\n7A/xFRCJNKsjz/ugbIHJx2k5y6m2v22mwrAXSeifo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVUrErNAJk0TmMLgLktVTYG+w\n/vIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf2ch9CToa5Pr9N+hf8Nm8B5EMdO3posv1DJQKWhMPloCIAx4D2w31PE+\nt/QuLy13XYS4DWogukQVfLprEqkm4k/V\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQ9smtd2KhXqdWUTnayoxJNkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThkMWE2NTctNDc2NS00ZGNmLWJhNjYtYjBmYjA0MzQ5OGRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTkwMWRhNDEtNTIyNS00NzcyLTkwZjctY2Y0OWQ4NWZl\nNGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP5RJrI5NetKtFXczlFbllkM7\neVxXYHpU/TmreLtdZeHSTPiXFm5lhowLGNLhCZlbKajUCIJUltfy8LZYu4kDfaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUq0Ctcrwi5KdNtb6cEpcqHZLsvMgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIE/W2NaA\nN+y00fdj2H65T+eG8Up8v7/RCTdiGw4MjI6BAiBAiNVlyds0hZxTaAMGZuSP4qvm\n1iE/iPRVp973zXVyUA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2774", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2774` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVZZVw+TtaU5wqmpfJQVYNK6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0YzI4MTE4LTIwNTItNDAxNC1iNGMyLTM5NzhmOGE4ZTYzOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUwMTE5NGUtNDNl\nMC00YTk2LTg2ZGUtMjZjMzIwN2UxMWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMNKDU8U+fGuJIXY4ic+pO4K6ydEoeNmwyqBMLEjT+qxPNqDF7/RDyiA3ht97\nqpIHMRpljKRSFL/HWXdBqUP3HqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSXuLCl7bpi0bu//xqjtQLEVbuLQwHwYDVR0j\nBBgwFoAUg+tWyHXvkm5xOzNUs+/QEWIgZ0owNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHM6KzuSxTRmCXDox+Hm9JO0r/3YygVSnIBm4KMvQoUwAiEAxH2hiIvSfmeM\nm2DNLh2qwUJOm/GePtXuCedzvWIVrTo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAegaYjWs3mK9nfxZpGsKAOtcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGMyODExOC0yMDUyLTQwMTQtYjRjMi0zOTc4ZjhhOGU2MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwJ7ECHNU4Lm8QYgw3kXLnbv+SXmAohciL5JIiDc6h45ww\nO4gM9hKtDE3pYqxTnWI0DM4NEomAtOdgYWCcEKR9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg+tWyHXvkm5xOzNUs+/QEWIg\nZ0owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJsrQsdLW2Bxo4keKm3MTdTfX4FBQ/qE4WgLSBwdMg2EAiACf5lwR+Og\nH4rSKk3W6GXBtEuk+BudxY/+oT4sQ55fAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVHX++ROfu7NrpQ24Y9zVaXzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUwMTE5NGUtNDNlMC00YTk2LTg2ZGUtMjZjMzIwN2UxMWJkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjBiODViNjItYzgyOS00NDA3LWJhOTUtOGRlZjNlN2Y1\nMzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELNXMz2TxNRye+JxWjlIbButr\nPtW2lgW1eymwmA/ktzkSol1g+t+giB2/eapaM0PW9Yo7adJwUa1eSFb8VZwd5qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSXuLCl7bpi0bu//xqjtQLEVbuLQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCrQ2wB\n6wI2m9+diwaIoEYsyJ+xnJ1ItZYAzdFhaMgKJgIhAIAeOhyfdlMv/uASFi59Thnp\nG4vtXxgOIpvbkfPODOGu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2775", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2775` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATWixPM0f1QZOLROzRdQWi2kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlMWMwYjE3LWRjZjktNGE0MC04NDkxLWUzZjQzNWU5NDA2YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYzMmJlMGMtMjJi\nNy00MzRiLTgwMGYtOTA2MjIzMzBiZTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWsfSfCCh623Dtno2oCQCDjlmsJ7PDsxf/NYWbNP9ctXnSzgGp3HKg+JsSYyW\n8qilLgOEeoXA51XojfPvdK/Q9qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxrbyiwWkw0Udb7xcUXqpt1WTeNcwHwYDVR0j\nBBgwFoAUiUHBhyhrI1t/QxWVbNwrU5eq3YowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCkaZsRnfcOr7P7Mq8Enu0JVnF3wVc7ivbW8qTlzhyoFQIhAI+Y5yZ8kizi\nHwANLg7VIIYJ3wLEkrgBZJZe5zc2F0AB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZc6iwx8wQjmZXrscXYvcQRoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTFjMGIxNy1kY2Y5LTRhNDAtODQ5MS1lM2Y0MzVlOTQwNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQImKvxxWxDgg7jXK+n5vxVSoV36095P0G4B9X1MjBdtAUN\nr1agtNrtuyy69bPQBDJHRZefJ/xYJ/CA4ON0N4sXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiUHBhyhrI1t/QxWVbNwrU5eq\n3YowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgASRyQbSY2XrNMGzO/R6aYuczN/IP+TEFcXNlYSoP2HsCIQCsVVFySQ9n\nxWu0Anj+ejgnXlAox/gr7ry4RRUQOJjgkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAa2UapiVyWpBlgxtEInD9JlWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYzMmJlMGMtMjJiNy00MzRiLTgwMGYtOTA2MjIzMzBiZTk3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2E4MTQzMzQtYTRlZC00MDQ3LWFmMmYtZmNlMmQ3NDI3\nYWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsq/lXb3e+6e26ilNPLhrmg1X\ngsvR8Wdi36FKcIRz7OOWG/nHjUskti6JpJrMR/VjDLZv49hUhMpVp1wnr4MTE6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxrbyiwWkw0Udb7xcUXqpt1WTeNcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCICpTpmjC\nII8yrtrQlRFSu1o5PY3w4SrB1pIP5tWlSVg+AiEA53nr9dJMrKO32Obc3oOwJ/8O\nChjUf9AUh30GBQNqDAc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2776", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2776` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAdTRKBtx0hKMTQrS4dtRuWpuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlODJjODk2LWRjNzYtNDE1Zi04ZWZmLTQ3MWQ2NTNmY2U1NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZhMmNlMDEtM2Iw\nZC00N2QwLWJmYjctODg5ZDdiZjg5YTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+p85OMpf9t5QUFOqiccWIWtrqb2Q+uUGT7E9oRJ+VHFRrUsQMmM/cY2ZcTHc\nFNkeFRnbXSH5yrd5eE3OxV/NoqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUo74ovpe7r/lXlHDmSyn+WvfZ3EwHwYDVR0j\nBBgwFoAUoYl0WKDo2yTEAqCc5yP377TzkqMwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC0\npN1SEhyt8zryW0UCAKW+ONaP6csr0dvQwAaggEx5qQIgOBUhk1+xK7ko8UZBF8+s\nmbPyOMp50MVRNpIhYL10+6s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAffd5L8TWAPLBNfMXMEg0n5HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTgyYzg5Ni1kYzc2LTQxNWYtOGVmZi00NzFkNjUzZmNlNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnUUIk11by5l6h4ZKuYOXd07Zfpj5BLokYw1k/VP7dvdj1\nFz7RwxVlOQMB18q+Pww+8bELcGNeFCLOLkrIiZdgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoYl0WKDo2yTEAqCc5yP377Tz\nkqMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKPaAlWxxJSatTRRgi7bWMjW0VpUerfTsKI1xrB8zMWtAiB1ieYcDlWX\nUEdhafGQt/L3H3ZyELZJ6VdXwPJTA8EwmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXZuKDzDofe/a2n2KIq7PrqnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZhMmNlMDEtM2IwZC00N2QwLWJmYjctODg5ZDdiZjg5YTM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2Y4NjJlMTMtZjAyMC00ZTBjLWE0YTItZDBiNDg0MjEz\nMDVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaIZmr+f0M9dzPk0RSnOKZ411\n0Y/IbR6AU2n+VPk55KKT4G9TpY/C7sRASfpEsCP+MRQcxQi63hbzX7AFLz4NAKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUo74ovpe7r/lXlHDmSyn+WvfZ3EwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDIvtMY\n8TO0odN7wMgPsPGnUQt5YGEycn44j6e6as+UGwIges+VQxg/QHn/E53gSCE8cWqB\nB7jqrN+E0aVQ+U0zOcc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2777", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2777` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWsO334FXytbmwu+Xcb5RWUdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZGI5NTZkLWFiMTUtNDU3My1hYjE1LTY5YjFlZmMyOTg0ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RkM2YxYjktNTY1\nZi00ZWNjLTk1NjgtYjgzN2IxZjQxMjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Qestnpz0Gg9ThuXapB6UOer1NVDNXBx2drNsnG1mSGNHGvGRoSbEslCROw5\n5I24DFNsfI030d2uyG6MnFG7oaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUIQ6+w8unE7e5Egipe4rh9FL/pcwHwYDVR0j\nBBgwFoAUEAMHC72363O6QHoq9d5yXNkLuYAwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBI+Tqq/KYgu9o1OokZRp5U7KiDVahnCZ/qXCmBLLaagAiEAg+42\n80+Y5VyNz0b4Kdwd+b/jRM9StBsZukx/AC6/wJo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVlj6LHBzrGBwkGXw349TjFTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWRiOTU2ZC1hYjE1LTQ1NzMtYWIxNS02OWIxZWZjMjk4NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSEOU5IHC4/zeF2/6MmgO2tDSviv/5FnNrmYgxtdZThxXx\nO5lkeZGCbk8ElpJZ9xN4c/mkAnK+sn7fMG4gJOC0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEAMHC72363O6QHoq9d5yXNkL\nuYAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMpmeRrOf69Lffh4bHbttFP5RXFdyOejaVppQ+gQJb+oAiBsSWlqogoj\n7+X4Ij9yezKdwkQZCoM59DfmPOtH2yBfjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUyoOz9jmpFdCl5N06ijhK4sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RkM2YxYjktNTY1Zi00ZWNjLTk1NjgtYjgzN2IxZjQxMjFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODcyNWNkMzAtNmY0NC00NjhmLWJlMmEtYmRjY2UxYTIz\nYjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0bPCh+7GViVaHh5xlYxfAzGm\nPpYrAaoheWVdUSAauN0P5lQpJxdBXezF2zh4531cD8GUnoQ2S1OSr92SqkmnXKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUIQ6+w8unE7e5Egipe4rh9FL/pcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDrmHDB\nHw8+gZD62E+I+xPiMiIenVUBw1RgfVrc/9J0BQIgfLDOEyV20YHQ2L/qhbf6xXam\nk5KgC0paAGvN/s2CYew=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2778", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2778` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAUSYS9RvC2l0ox7Cph++L2c6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MWNhNjMzLWQxYjAtNDA0My05NDEzLWJiNTc0NDIwNDE1ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODhjZjA0YTgtMWJj\nMC00ZmVlLTg2YTctYzc0NWQ4ZjdmNDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+lFwTsuMnz7OEyDUNjmTLAj92fhvgCcm5ZXM1GK/gcpsRPpSdhTjtJBidY1I\nqiaOGoWPQOkxEGUcD1MN4jkOsqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1x0rsFipYmI+PMb0xsEgRW2w5L8wHwYDVR0j\nBBgwFoAUfSlTnTTuouyb6EJ3v7VxPoXSjjEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHW8JGpnYcKZWYAG+wDT/xPEb1/6JdMRcrZWyxgoq24EAiAOD0dI\n7a4RFKf3Kga2X0jtHjMLW12SPVF7nZQ2Pvb8lw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcfmMe+x0P8Qm6+2wHdEWJNiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzFjYTYzMy1kMWIwLTQwNDMtOTQxMy1iYjU3NDQyMDQxNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8WGSSVQ0xNqlik6zQyaKCsxl7pghB7InOHFJnJTN3CxCW\nsvuF6afhe1o4nn3m/9IToVbQNQuSjqY0lzfoCyExo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfSlTnTTuouyb6EJ3v7VxPoXS\njjEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKzShixTb363CPMDfvZQNjbwaSHZU507EtnV5CAiaPXGAiEAu+JMJmdz\nPxpm/2Wl6tnomFOmQHsnxDjz86GgajUBqwY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfm7WRQ8pJI9IKPKJJA7solPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODhjZjA0YTgtMWJjMC00ZmVlLTg2YTctYzc0NWQ4ZjdmNDAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjJkODFlYjMtYTEyMi00YjEyLWFjOTMtZWQ2ZjYxNDEy\nOGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEq/7/LkIuLO9an45sJNU8V/td\nVcWvW/b/qTlDfiVXH34vxStFE63XbulxH2A6nEroHMFhOcRn5o6BApQxoojJCqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1x0rsFipYmI+PMb0xsEgRW2w5L8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIEcUNYZG\nQq8zlbaR6t9rmivR413uzJH8H9xs8gL7XtHjAiBXSabndre+42F0jiTVHcrknX71\no9IAsamssiuOlX/Bhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2779", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2779` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcxCCyZ5TaxUPngQiutRl6VgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4Mjk0NDcyLWM3ZWEtNDdhYi05MTU1LTg4YzIyZDVkMDU2OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM4ODc1ZGEtZTI1\nZC00NGY5LWE2MzAtNDVlMjUxNzc4ODQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmGOMtcb8qCnyTukPHTh5HXN1tRUbBpDMYQE7/EdFfBGEC9/KnkXUPZcO97Za\nobEHW3nLlSz9UgXLRt/LKZ1FpqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFELBrReEz4GfJPzGy+44qCXyNcsGMB8GA1UdIwQY\nMBaAFPO7OQleDqwt/BOqPhyaOoFh67mzMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA6o+asSuVKyy3h6MyzcYOQc9Ac5IHRApGo\nC2Bmx51awwIhAK+cOLnnhLYiHfrR66XHaXTJfvzIMYg+wBF7PwnMFydm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASNh1EK6ZITTrymHnoRXPqg9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODI5NDQ3Mi1jN2VhLTQ3YWItOTE1NS04OGMyMmQ1ZDA1NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/OcvQVSuVTk/77qLODVO4G8WWL+VuV/LOVqCEw5s7riXK\nixduyBgFByMzUlwxIsrFQa8Ab6+hHBu40/sA5DgYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU87s5CV4OrC38E6o+HJo6gWHr\nubMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIoUz8jnhkLTeBFqqIx0k7e1xpRpADipZLDninYJ85iMAiEA4pzGK15G\n4apqFErzPSYVgS5o3YYNWGrprP++1bcmzAU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAdcFfhLUw84ztBCZpVpkARAmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM4ODc1ZGEtZTI1ZC00NGY5LWE2MzAtNDVlMjUxNzc4ODQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDQ5ZjZlZDItMjc2NS00NjhiLWEzNDMtMGMxZjZlN2E4\nMGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExfrrSaN+D/ZTg5bKK2Ily925\nsqZHMpQmk7NC/DLTKFyq+GdxuKUuGn/sewtW8cADGs5WSqjAQScVQCxKU7iD7KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQsGtF4TPgZ8k/MbL7jioJfI1ywYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIG6mWqQd\nQgsow1px/EimjtrB35n+a/9tbf1ZJJ0jx3ItAiBLiqqUQYkbvbKy6KegbUvUylMC\nfyZiRGm6PrTLJgNgUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2780", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2780` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAY62LdN/lb193NAs9Ee35c+UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhNjY5OWMwLTkwYTAtNDViOC1hNGZmLTc1NGFkOGJlNDhhNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNkNjMzYjAtNTFj\nZi00M2Y3LTg4ODAtMWU3Nzk2ZjQ4NzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEADX9hgAfUN+fjwTldAx7kPJopLXeh15ZYtxoriqleOEhncN5tjkIk76V+XKi\nefULMUmAnT+OrjnXZaN+LBa5JKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlbeMHBsvaWbdTaV8shO0IQcBVScwHwYDVR0j\nBBgwFoAUjL0ByvH3RX3ozL2mUOFV6XMnoPAwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJ/J+Q+3IKyO\nIxnAkw/ELwD3ed8Bl9Ij2LzoM5Xip/TmAiEAlNVEweNXQl4rQ2Fm8Ux8WQ1NnTKC\nLepSmLsS3dNsnVs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdRan2UeUIx4Ml1QCzjaxhakMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTY2OTljMC05MGEwLTQ1YjgtYTRmZi03NTRhZDhiZTQ4YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROpfRYr6N7drwlg8up8NqRmqg9MGqQ2RHaBbMZVLhGsxig\nkrdFpySw4qcF1Bz0j5ObYRS0KwtxJ9Tf5sYo7DaGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjL0ByvH3RX3ozL2mUOFV6XMn\noPAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWvEmVBnlGZkBfyiJMHnR0SO/nBaqxizT5eSdyX4RKvMCICfAOVYLoGWW\nnQuOFO4jrlsV5jVseZMon2zQbkRAbjvE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAacsQ7PCEfNiaf29gmWPxk9SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNkNjMzYjAtNTFjZi00M2Y3LTg4ODAtMWU3Nzk2ZjQ4NzUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODE1MGY1M2YtNTY3OC00NzRjLWJhNjEtODljZTk2YmY2\nODhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjs9/YKNs8GxspC2t2c8oq+TF\nNi+ut29J1qkoUZzvbKDjwR/TEBM1YPC5HLM0+i1jiWOJxHNT2kpo4aC5r9gjx6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlbeMHBsvaWbdTaV8shO0IQcBVScwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIF6psNcX\n1n55N8Ah9mqPo68G3Ky1XO1czwhsAWStExeFAiEApFxj729EOyizDSu4zp/sS2Yq\nH5RR7wtavcEPVtQdxvc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2781", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2781` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAS3qXXNcDIhbUOss4P6adui8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiODc3ZDYzLTI1ZDctNDFhNC04NzM4LTkyYTE1OGFjOGI4MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM3NTJmYTYtMTdh\nZS00MmRjLTk5NmMtMzllOGVjYzM1OTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtwUGZuCZmMrf1OVHTtr+H+2srSupBrz668KpzmYWXU2zV1XDbTcjzvVqzO6V\n1BVsELlNOeI3wJyun6Ll+gpIzKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuY2JE/OWVauTuKfFGn92gwqPzzUwHwYDVR0j\nBBgwFoAUiu4gGPrZpgTLxuYly9UXiE3QSFEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgYi9tVvjw8gUT\nt/Nz8ZEHD6UcL62xy0tVXQpxl++nFuoCIQCjYh2UtL95OQbV/IlhJAxjx/+jYIUd\n/FNXZ3bd0ePpfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATrBYnTdpUF+8AL8obbKkQ9oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjg3N2Q2My0yNWQ3LTQxYTQtODczOC05MmExNThhYzhiODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkNMvBQf8fWoe4NZipfu/8crCXucG3tK6cihkkt7pkJiq/\nzB7nOlkMUJ28BwqgN4APuCpw63rBvHT+xhCo1JNjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiu4gGPrZpgTLxuYly9UXiE3Q\nSFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLhOgOUunmxfP/mvKChd4meJ3zNhRCdNyYMsTRM0ahxcCIAiI0KVXe5P/\nWe/XeQeBMcY6FX8m8Zh5nu5DIAa903WB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQR75xCIaknWPI5Sscbj++O5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM3NTJmYTYtMTdhZS00MmRjLTk5NmMtMzllOGVjYzM1OTc4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGU5ODcwNmQtNDliZC00MDhjLTg2YWUtMDczZTExNDkz\nMTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7bO0rDenXC8YZKI1q4620wA2\nzv19/zL4NF3YvB5uKz5jfJNS7+e9TKhe5x6gRIkOUYLGl1SFbus2NTp0rZ5ew6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuY2JE/OWVauTuKfFGn92gwqPzzUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCh6HFf\neQDQM//cP993g0uVB24pABFe3zqk1od79IgWowIgHnwhaII4Rb0Cer5Fc7Vb8wsM\ncccT8mcIJiOlHOTeUbE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2782", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2782` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAZslyV3UhA5BL6f/qI9AGTvVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwN2JhNTkyLTNlNTEtNGFkZi04ODJlLTM0M2E1ODVlYTM0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZlNTUzOTMtMzg4\nZC00MjcyLWE5MWYtN2ZkMDNiNDMwMTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeWTyOo57XhW8vvdHqqzJdu9AfEM7aZsErizOsuzn1yh8NIEv/BPBvLicLgwq\nSv3Soz20w45y//zlyUeKq8jxdqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8K0Qqu4gFANxZWiPy9NlCrAPX1QwHwYDVR0j\nBBgwFoAUSa222eUIKmvZCDCKiEeZWjnSfYUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD/pUoLM1iH\n8tYP/AMl/60AEudw983vnCA5yRt5U82pOAIhAKvTNtHkYGv/lINjzdfEk0DrjQi2\nHNc7B5/D1MTjt4yp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXkM194dnUg5ky9tKDRmTSujMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDdiYTU5Mi0zZTUxLTRhZGYtODgyZS0zNDNhNTg1ZWEzNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT118bY6g99Y6fB8BxYz8FwPPuPrwkQm2ftcXVUu4+jy+6u\nsvTNzw4aDAYWJGErFP5NVlF6LEvRg+3eaVU8kKyqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSa222eUIKmvZCDCKiEeZWjnS\nfYUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM27KOLNbopUjOxBUi5LG9r/lzgaX7REFjQobkenNVfxAiEAjGHwdhOS\n/qayzG11OFckE8uh8vmV7Rrw1CiFirYR1p4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbyHmYCvELy+Fb0iGRyr+vvQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZlNTUzOTMtMzg4ZC00MjcyLWE5MWYtN2ZkMDNiNDMwMTY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjk2ZmUyZDgtNmEyYS00OWY2LWFhMDktMjI3ZjZmMDY0\nOTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMEshA29OTwtCDRjj0oLbu3x8\nOqRfa01gE5hULzqviWX3XQZaQigyLYdfe6DZp8jNXO3P9BRaYhT39szCIV8CbqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8K0Qqu4gFANxZWiPy9NlCrAPX1QwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBFwX79X\nzrGaGWjg4WBErPpzYeXmBrOhgOlIVDvgbuLBAiEAxJi6nFggQhswKNjgZBHZE8mP\nNtgpDWMEVWhfBl7x6IY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2783", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2783` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZ0+OQ/WpY7hwPl0BXlMo1GRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhYjYzZmU3LTdlNzMtNDkwOC04MjNiLTg3ZTFmODdmMzJhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2MxODM1MTAtYzVk\nNi00ZWNjLTgzZmYtMTJkOTM0N2NjMjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcmwqVV6rgj8ZYFvBQVq+1lX1vEqvrzLx+M1QIPeFMxuvTNnKCmY9o7KS4qlf\nHo2MCGzsyJr0+a4dihkvLoCv76OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE5nUzo8XaHhVKww5B53RT0N28D4wHwYDVR0j\nBBgwFoAUHd2LoT8FCK+R51RyOge7qIDLsGIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDLbFPDkvqS7NRjxcq4PhxvP4/oRpzsAQBmu1ItbRc38wIhAP4QzciNenAC\nxUxYaF0AGegvFEn3vZP91LD7mrV+JGcf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR7iWGNOAhkIKcwqGrmGsuXkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWI2M2ZlNy03ZTczLTQ5MDgtODIzYi04N2UxZjg3ZjMyYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdrWOTumtLUBTGi4hm1GahKOUr7CtMkB/vujlfxUPqduFi\n6GmmchUp1r+sL8net4eYla5M6rgvKoGatKo3yIUto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHd2LoT8FCK+R51RyOge7qIDL\nsGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKr8H1lugdGOorl5s1crBoZczopN2OHcCI9TZDsSNOjtAiEApgIEAn6+\n0pDRpfI1NaFiudHGQxP1WliNjwHuBSdSuT8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdywTl90sS0Tds0nM+MGzIjeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2MxODM1MTAtYzVkNi00ZWNjLTgzZmYtMTJkOTM0N2NjMjczMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjEzYTZiNzgtY2JiZS00NjcxLTlkNDYtYmRhODM3ZmUw\nZDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX4oFRJY9PLOPTN7TxDNNEbR5\nHj0ghvaDmj+jcNHogacruPq1+zZePAaxvtn9uqyZVAP+xRmeD+lDtV9iUaCoqKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE5nUzo8XaHhVKww5B53RT0N28D4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHoNI+jI\nt3yX0zUf41t8/ZL30ik67cRVOS5q+CXQLhSHAiEAnZ3kzC567HXEYNxbfsa9rcuS\ntAWR5HiiCvrQPNAWPTo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2784", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2784` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISARwZ7/fJ5/zzB087URcECvEnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjM2VkYjcwLTFmODctNDVhNS05OTcwLTA2YjlmYjE5MzE2MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjlkZmFiZDctYTZk\nMi00NmUzLWE5NmUtYzczYjIxYWIyMTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbKFBtQVP1oJW5CQAUxjrfmaDcQQKqBBrYE/xO1EiLu5A8TwjucqPfhf66NHG\nRRToOQVbrIHDZGluMdbklVp0uqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPZx+RZbTJiL5dt0d0ImkuGyW+8owHwYDVR0j\nBBgwFoAUrQHhUcTPWWNNAor8iDftvLxjaYkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGKunv7ESZl6Rdturw3bwz815DLRatJIYfYcINQIaCqRAiAD4qZ9OVCL4iVh\nPr9iwTzBYrPb5D7O4QnZsN6LXzfGzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQV0vLT5XkRcyYfAS4usNSeLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzNlZGI3MC0xZjg3LTQ1YTUtOTk3MC0wNmI5ZmIxOTMxNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdG31KX8pnMMDNkbwiuJwO90/TpDqnOp0nJhY9cLxlG0ur\nUktvq9iCOoDQNdSasdwdnXURvwJWfipLnQ14KD5Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrQHhUcTPWWNNAor8iDftvLxj\naYkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIqr4PCpujpsz/9+dI3kRzWCgtfKAmpOi8t7qp62CbHiAiEAvoE8j+Ly\nTpdKIq18mqFeUtG91WIoXEFwLhWaAu1sXY4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAe85r1D5GrONtQxuwUf27MKYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjlkZmFiZDctYTZkMi00NmUzLWE5NmUtYzczYjIxYWIyMTljMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGUwMTU4OTUtOGU1NS00OWJjLTgzYjgtMTMwZDA5NTA0\nMzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3V5ADhVfL5dri0W2U08Er4WT\nQQgalPjQN83yX9J24QB4ig1WiOz3xe4lsw4bPeLqQPIL3dPUSLVmDlcVg1wMRqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPZx+RZbTJiL5dt0d0ImkuGyW+8owIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC5/bR6\n46zBV3UbrluhA43UbNlz4pv47yP6BjV9G4JVCAIgT7RMmbF3rebkk8VDqxu8OFJN\nygCjN8ZwChJhVbYL9O8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2785", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2785` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAUUoYg4s0QDXam3A4Z1+BrKuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1OTI3YTc2LWFlMmQtNDgzZC05YTBhLWMzNTFiNTY1NjczMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzExNGI3MGItOTg3\nYy00ZjU4LTlkOTItNmYwMTliMmEyMDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiYHHFKFVjorYyJ3O1Iu6zUnviKgWsA8MTpRb1LUMmQOZkuBrd3Dtd2bnMjn1\nHZrnYgCb7bEYbUJWUtTcwsqHs6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQCj5yWz11O29d/VkGQywSbfqsDQwHwYDVR0j\nBBgwFoAUhwBMUp+lR/uwvQVmhCweOvRLdgEwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCE\nyP0LY87FbkfxTIxq8dPi/uBu82MMyCiWrZT2XF0QuAIgSJew/z7hD5JZeKqY1TtQ\nuNhIBCBSmpzCZdjEAPthTpA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaGj87Vv8C8H1epM463KOLdNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTkyN2E3Ni1hZTJkLTQ4M2QtOWEwYS1jMzUxYjU2NTY3MzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwdDhDfHLY3g3PHIZjUvVZXvmRK+/CJq1Z4Z6p5pEN6bOQ\niiLQfuU5DYG0dVzQCc3ZQIy4roVEJJp+1zcpM9y4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhwBMUp+lR/uwvQVmhCweOvRL\ndgEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI+EymNkfAERBJHDWAp/5XuYxBSfVUIhPDVyXEdfN4bHAiEApdlC5tC6\nGS1rZX7qr8K/BWTsvgKP7LYEHTtWHDh1WUg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATeg1q4X8Mx3JVU9+CyiSj6jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzExNGI3MGItOTg3Yy00ZjU4LTlkOTItNmYwMTliMmEyMDcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTA0YmM1OGQtZGE2NS00ZTJmLWJlYWYtM2RlOTdkZmE1\nZmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGteafXXJKkXP5ZG3/hu5CrJK\n9lsssqzTuYPXLtc9fwEWHnUWGpz0pdpyoTk8pfKs46+PwEh82FxlOkMO1M0bLKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQCj5yWz11O29d/VkGQywSbfqsDQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCv0f/H\nur6gAZbbsZc0hnlGus+DI0Q8U1pW+vCehQleigIgFjLD8fMFhlZ8zW5FjFjD3q9L\nGxIYAjYoLaLRRdl7020=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2786", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2786` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAeJSsakY3OgSUrlq67EmoHdXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzZGZiOTJhLTdmNTAtNGU1YS05ZTVjLWQ5MWUzYzc1OWFhYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhiOTRmYmItZDM3\nNS00MWM5LTg5MjctNDY2ZmRjYmQ1ZjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjr52fvhtl5MeSAdQCnSVdxB/r8Fg9nve9njciqcS298kb2jEdP5MZ70C6l9y\nl48+2BEg1DFPidzGpHRESYUgYaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtj/AK57Cfr44nsHA3COnajLD3HIwHwYDVR0j\nBBgwFoAU/m5BuGUmiQVZ7PDtRjSi+xtJaoUwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDltlDCK8EzlQ8j2XqwJKPkTpFIZdBjF27ZKD5H8WPlgwIgdc9X\nl8xADZEEqI0/ymzAkLqWpddbRd2uC/+xZyExWPw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARzEjL61/HkvCmOY4IvVuXHvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2RmYjkyYS03ZjUwLTRlNWEtOWU1Yy1kOTFlM2M3NTlhYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJIFc4HAdt4BZpB6fzQJvdGbhfGcakwr0NQbUOmySsycCG\nZtGAry36nzgBt9fkwRntXfA5fVV3Y2E0qCdKGa04o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/m5BuGUmiQVZ7PDtRjSi+xtJ\naoUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDUtHirZ73P3eXxjiftTU4T8LyOql6gyvyj9+2OGpmiQCIH0qM7zfqrut\ngt4aQ2Y2zMHWLc8KkH9gi1GWfPN5yBKj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYFQma1Qs/VwRTAuWZUYKvETMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhiOTRmYmItZDM3NS00MWM5LTg5MjctNDY2ZmRjYmQ1ZjQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODc1MDFiOTAtMGE0Zi00OTMzLTkxNjYtMjFjMzFiYTQ0\nN2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQIQkD5D47EEDzs5G/j7E2vbF\nUUSeG6aCJwLru9jCfZ7a0DTwAD+2NYxmcuYHVew3svUXF0qvgjMDWn24rWOrDaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtj/AK57Cfr44nsHA3COnajLD3HIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC/+HsJ\nUYC1V36p8Pu6C+Ml25EBzFrjGy0TLEf32BbCVQIgPJzgibC+yAgYpQIvpZdDRr6Z\nlCDjR1ma0goB2iOw1mY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2787", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2787` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAbrz9wzKq8OQkCbJ1Cfbf22FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3ZGJlOWNiLWI4MmMtNGM3Zi1hMTUyLTQyZWUyMjc0YmZmNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRkNzE1MTYtMjg5\nZi00YTNjLWIwYWItZDk5MDdhN2ZiMTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ7P4884I1ZH5+cHY6jdgupVdPrw1npagtlsBvKMsCKWS8rSl/1bQMkD77mPa\nGkd/WDpTc8wMrBWra2sW6laCOaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOuFqt0psF5RhGh0GwPeZFjv9tXowHwYDVR0j\nBBgwFoAUUPWAb/opBikPjM3o5xiX8RGRwcIwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCWwhbpoCZ67eL2UVpcWyMZUsE1Y9tX0KiKDSsQsxpU4AIgF2Qa\nZCyIfSIu+JSpbVBmLp6G8N5YN6R18Afqh+cqs0k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYKGP1bQymfMU/0F33/q/Q+iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2RiZTljYi1iODJjLTRjN2YtYTE1Mi00MmVlMjI3NGJmZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwhwBQP99bwJZF1oFtUJVgL5kMG0tUkS9iyYufcjZfBF6E\nI8TBJwQ5+vMvz3KLwCGhVy9zvJD4vvLv2n58dZSio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUPWAb/opBikPjM3o5xiX8RGR\nwcIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALpkdY9LJKP2VVRBY0XU3BktXs0YmwuAq2oKVqLoUzODAiBeGqySIiiP\ny+AtMl0YDDpR0avZyZKis7GB9KVDlBqg3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAda/A+IWmPE330854SDMPhGwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRkNzE1MTYtMjg5Zi00YTNjLWIwYWItZDk5MDdhN2ZiMTQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDViZGJlNzgtYjNiYi00ZGQ1LWI1ODMtZTVhZDdhOTYz\nOTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5TGSkhRbHC7JMrXvsx/UOfzK\no6CBsc/LE2nioBHaAQYkMy9oswreieBOei7GWe3d8NvA64HE8GW1Q/PykFjg3qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOuFqt0psF5RhGh0GwPeZFjv9tXowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDHX97N\nHEzYN7XgwbZTUSpa/2scUMVaukUnyCROrHSTzQIhAISLxhwj3K3cRhEx4CD+oUlt\ngTlaRBqRVuRXog6uSIVC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2788", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2788` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAeTtYmxwcSyv0f2Mnw5AfvC7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhMGVkYWVkLTVkNWQtNDFlZi1iYzdlLTQ1YTgwMWY0ZmFiYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNiYzkwMGMtNGZj\nMy00YWIzLThjY2EtZjI0NGFhMWYyNDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFsJJ37ZlhGXlDlz3H7kcEMYxDFoKT5gAd772UES2lgbt808remrPRKsWXEpJ\nwH68UpunFR7zdYadHKx6UacbzqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRBdQrHDFiScrTsBBuXEJkCrDSLGjAfBgNVHSME\nGDAWgBQmnV4RYtXJ6sF/NXSiiAD36qyltzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIClL3aoSDYvqCdD8ViDPfgfLTlfO3sZZ\n40uRW0/+3G1jAiEA03A8rh0qHbjgnf/pnfY1yVdMoAICtQcm4fet9xkCkrU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbPcF1iL5GcGBLUq+NX2Htq9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTBlZGFlZC01ZDVkLTQxZWYtYmM3ZS00NWE4MDFmNGZhYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYp00rOGA8xAYov9UZ07eeyWYHOWnSNtB7AWt6/diLXtiL\nOtu2tT6f6+VmD5AcCAvR4pWUK993g8ARLejelT5Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJp1eEWLVyerBfzV0oogA9+qs\npbcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPNB0JtwY/shu7zcXwwbn+452a6GqDOJkx3SC1kR3nZHAiA0IxXoT9ta\nxiyS2OwuiaJp1wxN2TCxy2Ha3HAoaj4idQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASzz8CnFfSzuQglGu0ets+XZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNiYzkwMGMtNGZjMy00YWIzLThjY2EtZjI0NGFhMWYyNDA1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzQwNzJmNmEtYTNiMi00NDc4LTkwOTUtN2FlMGQ2MWQ3\nZTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgWXlaeOT5r+hwlpYwFH4FRMD\nAvLNTu0ifO4hgxCLv2S9EJfCLaa5+d6woarzg+5Ptqlktz60v+lfeq58q4vmjKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQXUKxwxYknK07AQblxCZAqw0ixowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDCq3TJ\nZy4Aq7KYDU+cC+smSDL/4ibhYlR8kK+dqMTvTwIhANzLseYYcKgnfwjfXz+m7UDL\nMx5fwlv9UCik4UZA7xGE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2789", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2789` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZWUgYoz/mQDtoSTvpoDXM4UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzNzY4OWFlLThmMDQtNDVmMy04MDhhLWM4NTFhMmM1YmIxMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzgyMWM5NjEtMWFl\nZC00ZGJkLWI1ZGMtMTkzOWZjMjgwZGNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEigAovwVSlXa39nOUfihhLA/1QYi+3loI5cutxuUp1Sq8h6s/f+jyj9/DsfZT\nnK53Yjep4URjYmDiEDYIZc7Vu6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyogFvEz4b/49XgOMwpMsWJOvBfUwHwYDVR0j\nBBgwFoAUgRBCZjXONrcKWCfEkyzXeZ1UGh0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDBAbYL2Vsc\nEBo63DNEuNh7W5RKJpVBmXACjFYJMpGEVgIga55hl4vBcV0TBcFuWOzwz+l74J9j\nu30tIqaZ+cJFSiQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ1pMqEBZqfptz5b8ia9BBUZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzc2ODlhZS04ZjA0LTQ1ZjMtODA4YS1jODUxYTJjNWJiMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdvMtqi6kc0GSjFywxCVn7TSLHcZJKz0OKVMsvuXrwGAdY\nFvpFV9ihQwIfhM4Wu7kgx6AsjpZPvaG4hQKc79i3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgRBCZjXONrcKWCfEkyzXeZ1U\nGh0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJha+th/nrwWNFmD1Nx8meM6VIjeE/AQx/i2LtvcO5gGAiA1c6355tcu\nn/qiAKDZGjHEeUvrhGzFgQK+bcrGGieNhw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASLyOvV1TMjHQ50Fj910tT7XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzgyMWM5NjEtMWFlZC00ZGJkLWI1ZGMtMTkzOWZjMjgwZGNmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWE1YWNjMTMtYzk5My00MmYzLTkzNWMtZmVkODNlOTU0\nOWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2gCP+1JR3Cul2HTaPBPfZGFk\norA8kaPBZsjZWxo/kWSOXNtVetOXgkiH0YiJEhDz2F/8F82kewQE2gGWeDE89aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyogFvEz4b/49XgOMwpMsWJOvBfUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD1Uh27\nDTvlooOoAyDT55+ZIDf55Uxd8C0oq4aJk81e7AIhANR+JyOalPBUW2RwAqRvlDUV\n4krbL4hzEF8eX57xR7se\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2790", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2790` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWZxP7E4nzM8jAJ3bU44+O4qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczZGU2ODVkLTEyZWItNGFlNS04MDdmLTMxYmNmNzUxY2Y5NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZkNzFhZjUtNDJk\nOC00YmZhLWExOTUtZGFkZjc5YWFiYjJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERMLIEl4fuZZpfwIYKl3jTUA+EMbtowm3qU0kYoJKDoj9XvBQZuUtXjhKxy/v\nOZ0aZS2CTviVKYfMhS9tSxGnIaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7p+vv2DzctTEsQcO+UBoM6zNhCowHwYDVR0j\nBBgwFoAUvGoSC3d+2p725kqnFGGFVx/wNbgwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBpeRLZhog8h\n4j5HurRwaBRGkc6bsyZ7pepNci1ERxiZAiEA7+X4D1hkldZnhY16CSx55qvMzw74\n+ymVNRXG/Zn8160=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd01JlH9eaYTLFoj0R08Bj3rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2RlNjg1ZC0xMmViLTRhZTUtODA3Zi0zMWJjZjc1MWNmOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3l7b0dYRa5XBjBaZRdbA/7JPzzm89Mlc87OZJRre2UQqa\nRo1EolsWHBQd25lXlSQc8as/13fZc+dG+fmqHqLDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvGoSC3d+2p725kqnFGGFVx/w\nNbgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgALH6O77D1Q2pSUcwM3ILJcR/gPpdG4nHpGo14ZAcO0wCIQC0p0AvzPoh\njP1b1H6jyHqYHNyGZTtnA5BcvrjBy53mbQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAYBcRVAnN58VC5X+shqqACWzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZkNzFhZjUtNDJkOC00YmZhLWExOTUtZGFkZjc5YWFiYjJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2NkZTMzM2EtMmExZC00MTQ1LWFlNWMtZDQ2OTBiYjg3\nZTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx98W+HqTlEx1AyKyBX40/Mf9\nT40WPT8HrM7JAYr8dBEQSQHifO05xs2Zjc4BvG9vL8s1JRRjzMHQqMsjMVvFX6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7p+vv2DzctTEsQcO+UBoM6zNhCowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGTw1idy\nbtNEKwySoG5hemK2RxvZ0jGCOqDeBnlrPecCAiAX9NyBTIXFUtdfbZGitmhsrkaj\n2pSNv3HaH1cpbvf3Sw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2791", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2791` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAZB+argL2poIl9sKQfhEjQayMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiNTY1Mzg2LTk1ODEtNGYzMS04YzdmLTM5ODkyYTUzODc3ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU2ODVhMWQtYTZl\nOS00Y2ZkLWE3MmQtM2U5ZGJmMjM0ZGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjMMzXJSkE9kmgrZHOLaxX9dnx6kgvvnBBBRxRasYa6BUf7krWVXajBc+H8ci\nCICGxDTzXbr+Z9qAem0tnz1Bo6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXZ7wMMrk5xv+8orADxoL7IYgIywwHwYDVR0j\nBBgwFoAUsPxSQWIst+ZElzAHnsLmp7NmEq4wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiABd2yQFudn\nTjvPR415+VEyAKDnA+cfxzYBgoX0i1S7EgIgPAWm0aUVuboxFjuGwFoFEi3PE6+N\nNBAK6ffmLgzhFl8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQt4bya7jHPeE0LqElZ78917MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjU2NTM4Ni05NTgxLTRmMzEtOGM3Zi0zOTg5MmE1Mzg3N2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQD1+lnpsw6VWpnyR1NInUlwv9tewowsT0/ESJ3xsuSN3hw\nxSWw/G412gwnroq6oRs7iTbcGa42SgOZvJFkLNZVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsPxSQWIst+ZElzAHnsLmp7Nm\nEq4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMrF9gEYJs2m8LJw6dx3RLy9aofE54IlL1ftUjuTKqM0CIG5ltMoBLIiu\nEH1EDKNwhw2B1wEBCtXr+Ts744yKo2Hr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASTj+neJOaPw/tx5saGjckkPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU2ODVhMWQtYTZlOS00Y2ZkLWE3MmQtM2U5ZGJmMjM0ZGJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTU5YjZlYTEtYjY2My00MjZhLTlmZjAtNDNkOWYwOTcx\nOGE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIkrM+wGFwq1IjWWE2/IDT41e\nuylaxoRfEnPOlWNzX0yp5PIXOsNSZINm9OXKzvCmlubFBnpjK7Xn4WKqIMJz9KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXZ7wMMrk5xv+8orADxoL7IYgIywwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHszHnyL\nhRqJrT9FTfw7sD508+X+J2G1K18suUbJtCETAiEA/+FpDT4E52IwoI6Y8We/Eynk\n/8PsefzIkG/Qm5i+t9w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2792", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2792` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAWfGPYeeneL01ShrX5My4zfgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmMjYzMWUzLWMyNzQtNDlhYS05YmU4LWJkOTlhOWNkZjI5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZmYzE3MDktYjg5\nMy00MTliLThjOGQtNGZjOTQxOTBkMjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9X0wiHAU/waq3597ncPd9oIkCJ95PW8pE+EvgN1NIu3rYvUQnVaTZPzSyPmz\nsCzHovmnQoLb/tecMPJ9yGd1GKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuCG0tHCYkTOVgf7eyaq3gl1bPBYwHwYDVR0j\nBBgwFoAUXgcTYynD/eO3NuyRBBDfNLmBwVswNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAmEDyK0ASUi7ud6Qwws4V0aeD9ISLnIu+ye2Y7xlPIkACIFUtoQgAhYD3\nAgTbHs9Po6A/kycnufDEgZxNXfilMLRd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaEi0J2scU8VF2wOYnbKqb+HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjI2MzFlMy1jMjc0LTQ5YWEtOWJlOC1iZDk5YTljZGYyOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaBKRfar9wpe4hs/MN/TGQneQJA2N5G0ibNXxzmx6hRS2C\nQQsNVDg/NaSd0C/997UWE3rkiRuTFnimo2srFEmEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXgcTYynD/eO3NuyRBBDfNLmB\nwVswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcQbl/KvQ090ZFCLVZ1Hh4/OuEbq/q/tBss/31wCFnwQCIEYpy4sVHmpc\nrUN3TgjyUx1uLcpSt7Gi6uYSc2zMPh35\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAUnqrJGgYNC+PshhM2Rgfa+NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZmYzE3MDktYjg5My00MTliLThjOGQtNGZjOTQxOTBkMjEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWVkZTllN2UtOWExMS00NTljLTkxZjEtZmQxYTAwMGFm\nYmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8UE7HOUKRq7kcOSf+ekXe6W3\nxZ2xqQONz9Kg+P02D7RypbakMwAxvS93UG6UX/K5x3iYCOze+pDz+X0cD7W5raN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuCG0tHCYkTOVgf7eyaq3gl1bPBYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFto42Mb\nNmhkauarALjb5ZamRStgklS25Al/Fi8ZT6krAiBJsWLmUOKOtk0q2UeGS5VrBgkQ\nlt001ZriUVCmF5iCbg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2793", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2793` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAWMGOcwIWZawlUWGTSAn9FRtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxM2U2YjE5LTFiMTItNDVlZS1hYmYzLTM2ZTAyYTUxZWI2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdjYjU1MDktMTUx\nYy00ZWIyLTlkMzUtYTJiZjc3ODMxY2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExNFBd6g2DNTL09GXfbGiOZn2LKSZ9xnM0JvKhk+sy4t7PdE/z2F48JX4z2yL\n+0vyTMxKgAu/N7SZ962OvV/z4qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYGnEmrO3uB35N7wNDuSfVqApEtMwHwYDVR0j\nBBgwFoAU5rMRiug19Rs7eVbKhxWeYmTvcJMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA6h+ft7Q3faf32DqPDebjDYc7pe/HMC7jbU8XikJzLsQCIBkJtkclyYC8\nBcGOttKfICimGAAduoWwrMWHanur/gLT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaRMTUTw4bVVbPOpaTbgaj55MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTNlNmIxOS0xYjEyLTQ1ZWUtYWJmMy0zNmUwMmE1MWViNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlbVi3IfDtXX5ymD3+2Y9dLnim3PrWmtYzUupB3x2jf6aD\n/IlNANe0sDc6hDYDaAIsKmJ1ezgByNWp6V7p55EBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5rMRiug19Rs7eVbKhxWeYmTv\ncJMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeWPDcKOfod+DDR/y168xdvS5YDA4RtK7XU0TBqCS8hECIQCuL8bRDYvR\nCLvk/bCO4CiqIVxnL6avx8ufS1C9X2AqfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAR6BcXghvNS8hSWc+d3eZBGoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdjYjU1MDktMTUxYy00ZWIyLTlkMzUtYTJiZjc3ODMxY2JkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjE4NDc4NzUtMDYyOC00OGIxLWExNDItMzQ1YzM4OWRi\nMWYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAytjk3oaMcx8BjIX3Nr4f3So\nDx2QkL4yXepeKl4yz8IEoapeRHRDSuQvb+XxyyWQqqB5EuuzJI8CEDjUm/otnqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYGnEmrO3uB35N7wNDuSfVqApEtMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD89FYQ\nLotO6hL6WCeedlWucgFF+kCrpEYqfQih2hFnBAIhAIFrRrzh7w8jwyO0+CSHLClS\nX2jdEQdC+Ag+hULf8a30\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2794", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2794` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAc5Y1RfFzgloUvAOfvmoD90PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4NjFmNDY2LTdlNzUtNDMwYi04ODRkLWYzZTMyYzVmOTQzMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQzMDM5YzktYzU3\nYi00MjE5LWJlNTUtZjJhNTYzYWZmNzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELJLuRQ5DdtjBvc3eZiKp4x+LQpt4uiMvmJA8aInqN/Ii9B5Efh72VecmMhmX\niF6FkipxTEVnqXISEYa9tWkslKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuOLWv9t9KfXDJi27tSTUe2cq6QswHwYDVR0j\nBBgwFoAUfd0fmIjaO62xXOE+JmfIA4rpjCQwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\nk0YpvmxpCMxAqIjfOAwNYNLfIols9Oq/1fA+A8k40NoCIFEA28GifE23LBvADKIt\nTS8wY5Tp7PtrlwmLbyrZEh64\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbRbsCYw0M9CpbigViH5BJwKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODYxZjQ2Ni03ZTc1LTQzMGItODg0ZC1mM2UzMmM1Zjk0MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbxcVrqJcc949HAEPucPIKPYIalE4eF+OYAjpBfHDxJqzf\nfokKyxvjaNejqiJD3vXx2dAdf7X3Qw9snZijh0SJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfd0fmIjaO62xXOE+JmfIA4rp\njCQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALGF0cDrTQzORzZ5DKA3Iw9uv8SDC4KHUo9Cd+NgCfCbAiEAtHybW0wT\nKccYP/OxQaocdG7o8DT5uzta7wDhQtPp7gQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAaEe/qMTNC9lfy3u3+o0acQkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQzMDM5YzktYzU3Yi00MjE5LWJlNTUtZjJhNTYzYWZmNzhiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODZjNzRjNmEtN2ZkNC00ZTNmLTg2ODEtNDgxM2RiZDlk\nZjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbigGndgAiZL5vPk2mvJyig2N\nmUhXciMQJZndhvCwLCOO48+nm08yIsXO8HA+aLRdTcWbco4O8z9cAs2x7fdiFaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuOLWv9t9KfXDJi27tSTUe2cq6QswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFy/tqXr\nPlBU84n1W1VGcYJ9rKX/sYk9Fz7Ukh4Dff+fAiAeY8vy5VOSNZtpOGbfdDQrf4A1\nVgdn/aj2UzaFh1WAyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2795", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2795` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAVfLmEPqDz45Ro+4RXUNNJbgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxY2I1OWNiLTQ4YjctNGFkZS04MDIzLTRiZjFhNTE2NTIzOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU3MmRhZjYtZGVk\nOS00Nzc4LWE1YjQtMzVlYjdiYjUxNmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk6lv+XPVxkCCy56MtfrWQlHpuSzwLA6qBOIMu7M0MTHsKnD/Yvy3aTKG0xij\nzGYqfpXlzwpMPikAz7NAe5KEeqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvqDmiLZIIAoVLD18pdR3+/VmEn4wHwYDVR0j\nBBgwFoAUvh2oGuGYZfoOI8AZDHp6l/eoJPMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAsmyuJRx70FlZWV8LxWr1hqophG0LEMiQqJON2n0LHtgIgQ0YH\nxbAm6aK2+NnnJVAHtYekyTbN/XG5wtnkiwrHSfw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYACNfzW+nPhJufwgpEg+IUxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWNiNTljYi00OGI3LTRhZGUtODAyMy00YmYxYTUxNjUyMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzDEfvE0LwnP3KIfVi01x0AaRq6wgThVfOqul2AMqs77YM\ndt4PrMJ8C+VuK8HCpGRcNa1hR1wMRF73W3gvSgX3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvh2oGuGYZfoOI8AZDHp6l/eo\nJPMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKn0/ASbJFNOYYBt1oxbsgEfKuHz2UfkfvRNAxHSYmUcAiAZsspciyxw\nF7Tac03jQY5Cxq9W0Qlmq/axeDwx6e02lQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQUMvYxfeBObZxUBANX8aFS7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU3MmRhZjYtZGVkOS00Nzc4LWE1YjQtMzVlYjdiYjUxNmFmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2EzM2VjNDEtZTZlMS00MGI1LTlkNzAtMTM5MmNmNjJl\nYmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+NEbY9QcbVyr4gN5LKXDusgn\nkmR1u5X5g/IxPBx0zxw8baKXP5z4wBZgygehY666ks2t00RwzGOC06jUx3x/UKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvqDmiLZIIAoVLD18pdR3+/VmEn4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIA/JcWnu\neE2N7JirQgFJVpqjnp+QD63h2xXAORnugf6sAiBPFpQVs7Qicof4iOjnEVpIxWy4\nFesiUpf+VgBIQO/umA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2796", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2796` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAcisnJT3RkQ5OaUz4f4u1LJoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkNWRhMDM2LTc3ZmQtNDEwNC04ODVmLTkxNmJjYWJkNWI1ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc5Zjc5MWEtNGMw\nZi00MzAwLWIwNWUtMTFmMmNjMTFiYTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE30SrHskda01CAK9d632lM5LGwMoflCjK+JTldN3gpqK/41x/xRJ1Rp0mPcR6\nZfHb1iwev9m3ny2OXkVZftOrRKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUILuKgk9BBRB0PMrwVfd2pa75NJIwHwYDVR0j\nBBgwFoAUkDTYbsWGDcaDOBiSApWMStGC9XAwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAmGHklmq0HgzYC+xcA+ZmYJ5tTKqr1hY/AhLAW36WN2ECIQDK\nfthU/T4g0LdhOuZnz6f3jLUblDqKz+wDFn2I8nWoRA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVJT0YM0Rk5CCuXz8Z6hRJuoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDVkYTAzNi03N2ZkLTQxMDQtODg1Zi05MTZiY2FiZDViNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKZlQLMHpvq1wdyYr1oUSNVOLLiqlrwPW4pU/Lbl1w4SwU\nvxgarKgN6cGhwUaIhOzazCuO0C46/Z1Qx2ELwK46o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkDTYbsWGDcaDOBiSApWMStGC\n9XAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdRrHRRf5j1+e7rGdWoJcApTCD0mdM9V8ZNOkpw2v66MCIA4vqb0KCCAc\niqjDC7XIvQ0Gn6Mcu1XNabRRVTz0uaCW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdM0ZZjuniFr8e78cm+zz/3CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc5Zjc5MWEtNGMwZi00MzAwLWIwNWUtMTFmMmNjMTFiYTBjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTRhZThkNDctMmNlMi00NWM2LWFkNTctNjkyNzJjZWIx\nNjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaXVS1GBdblaqZD9qT/42tsFq\ngAB5AeY/VBdOCTMtKDKS5wJoTP2Ycoh4EiES9N+iZbq74tDBJ0g85bjNDkPYsqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUILuKgk9BBRB0PMrwVfd2pa75NJIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCs8Te+\nKa6/JfS6U4t+K+GGqu70OUcRHavneeDwZm+ncgIgTRLEEUYtfsR6rE1Yed53K60h\nNfAavdS4FdFTiIDI8MQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2797", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2797` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAZOZQ/T72W+NKVRnw6dAH/R9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5MThjOWUyLTFkZjgtNDU0OC1iMTk3LThjM2M5YmI5NjVhNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNkZGY2N2YtZWIy\nNS00ZjA2LWJmMTgtNzZjYWJhYWNjZmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWBnzSqZFt3Sjh4VQAy1ltsJIh0xkxDQwJNJFNPtSyuT+tyCpuuOKAhmewL2w\nZk9pxMBM/AAYbZRoHNOfJN9GyaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDqsCBPn/7oWSvhywByQYTha2EtAwHwYDVR0j\nBBgwFoAU7VpY67vBQ34AcaneyBMWaVORfHQwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA4pfZcYJ+envn\ncIdLqm+UBKw52gKDNbdQlI4zwqrwkVkCIQDwYUwpBQtfm1c3M9qWFK8atlJx0s+e\nv82Am5hiqUUT2Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATR2vnO/RC6yk+bnYsmxXzusMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTE4YzllMi0xZGY4LTQ1NDgtYjE5Ny04YzNjOWJiOTY1YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZw56r2cPEJtThMgXIfC63WpEXltrbSEE52DRzXOT33KpQ\niauQEgaYIVph3nA70/Vmy0R48RAuYx3RvZCZ3PG/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7VpY67vBQ34AcaneyBMWaVOR\nfHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeUHUwzsOkVKOMoayjLinffdkzUXppO2ws2Kz50DpsxQCIQDFVH7pPJrC\ndF9uHSiy511G830oZSxHhK/7Di+02o55Zw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUUFWJbQo6XTUXrCyFffDJ0nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNkZGY2N2YtZWIyNS00ZjA2LWJmMTgtNzZjYWJhYWNjZmQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGM2NzU1NGEtZGJjOS00ZGU2LWI1OTItZjFlZTJhYTUw\nMDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmM3SRPxGBt7tgqy+rP+cWcei\nxTmA4OcETAOLX3A/9cKBjWUIwH/G3PaRWqsSG9SKqAEaadiyqYup8zLNcelGEqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDqsCBPn/7oWSvhywByQYTha2EtAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCvQtto\nDnkeyc5mcM2okXka+FAgjwQ3bWPnHO3Ppd/GKAIhAPij0NsZvbEuMwd5uMFHHdKl\nof4hVseL45sAmNuZD3Eq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2798", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2798` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWHu+hCLV4aoPSdug08tX+dhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4ZGFjODY3LTVjYzYtNGFlNy04NTI1LTAwMTQxNGM2ZmU3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E3ZjAzNDMtMDc1\nNC00YTMxLTg2NGYtY2M3YzljYjJmNzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX5csIpCflnJvS2rEIyiuh6yfS+Wi1xFSn0ik0CjZXLxfvNL5PugR87UKNpFt\nHDAPHlNqNqlvDSrGdl4mIJkek6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi8WFMd0yYRftpJzmjFAMcSOEyZYwHwYDVR0j\nBBgwFoAUHx/x0fjH6FwCW5plGLqrtzQK6/wwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEm2qEEWpyLKQR/Llt7eUy9S42i74cpTLhenPaf/xmyDAiEAkLpJwjmY3w8q\nSNA5IfIjH550PJK5zP3vckjXh5PjOBI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATEkKmn97/bb7Scabhf15J2yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGRhYzg2Ny01Y2M2LTRhZTctODUyNS0wMDE0MTRjNmZlNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBZDSC0ZHZTiZB91Q9e4qN+ZSVEr6IqIEtQi59qM8cYw43\n4tX3NfEJDZDWEm3uQbRyqyXCmYruSzja1EH3e2LEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHx/x0fjH6FwCW5plGLqrtzQK\n6/wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALtmuAhFyx+t47nZOElYxlYShOwsawFVjxqrnot2bgylAiAFS+GEwsdC\ntJgsXDvE5wSWP7gzvxNjs+b6eutB0g3Vnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXsD1lBPzik+4LsmBhLvwhQ4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E3ZjAzNDMtMDc1NC00YTMxLTg2NGYtY2M3YzljYjJmNzlmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODcwMzU3NzktNjllYi00NzA4LThlZTYtMjJiN2I5NWYz\nMTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsoXN03H3U1y8jnMTNQpToqGh\nts8pIOrFp5uHDTJ36aZbns6soDuEb/Qp/viWJdkkHZu7hFZogXyLdmqUU8cHOaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUi8WFMd0yYRftpJzmjFAMcSOEyZYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD8Emvk\nuyyX3SGZpUDk/SiF8cNmIMSnvr0pAl+Bcy90sgIgGeCDqG0+RrPilalm60yCJXoO\nWcFC4oo4hr7+6IVEuUc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2799", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2799` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATpSbavDSU7lbYOHMOIzeTLiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3YzkxYTM4LTFmMzEtNDRjNi05OTcxLWVkZGRmNDJjYTdmNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI2ZWEyYjQtYzJl\nMi00NWJkLTk0NDAtN2VkNjQ3OWQ1NGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECKrgoPFO4SKkNm2nKD+bRHBK/47vLpjiD0i7ThzpxJOTVMOwpUwcxUvHz6XJ\n08lCD7yrbNMaUVyAIhq0e5ARm6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Y/iempIzX4ZZ8XWSSUwPEvCwzAwHwYDVR0j\nBBgwFoAU6mc3bBhj3a30liRaB1hbHI6Ify4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIB2zXwdF8r1KzgyZYw3nFAhxhKFliKtJfpjT+/UtClhvAiBqVwIOEH3FSyiX\n9r8didUp8/uvATBz4HsQ6LXOcRSPew==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc8tE6g9zZpvOb3itYuk32bVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2M5MWEzOC0xZjMxLTQ0YzYtOTk3MS1lZGRkZjQyY2E3ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwK5/ZnRtGdP80hcTy1HE5NfdV5i01nVvuJGfzNFS93ehJ\n0lgU79GF7H/XkdxrCJKqnV4S5gw8qmuj5hPBh2iNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6mc3bBhj3a30liRaB1hbHI6I\nfy4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM3m7iXarqJQpnrcWcNCnIJD2+0/BwnbAUev1rJFLmalAiEA9tW5jNGZ\nH+P2j27arIXjf0xrRickUWM8XcZ7MYgN51A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAeotPZADJrryGadKAzb0AzavMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI2ZWEyYjQtYzJlMi00NWJkLTk0NDAtN2VkNjQ3OWQ1NGIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzAwZDE3ZWEtOTA1ZS00MzE5LTliYjgtMDU0ZDQwYTMy\nNzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEpR1Soww+n7tTtxivXuWG124\n3rG9NCDYizY1hoX8CvgnsKA8tcP2iuG8iBCdnt7BzSg7Drl22ocgblWCrdXKiaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2Y/iempIzX4ZZ8XWSSUwPEvCwzAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCgi400\nQKEDRMiQk59rY5YBmGRsw+phMpvpl9tOqf9NiwIhAJ7gNVOA7MEOVGlLMpQ1rcMX\nuE7BwwWGepnHCXb7xDzA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2800", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2800` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISATd9iAypLzquUj6a7bInV8ldMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1MjNhMmYyLTU0ZjUtNDQ2OC1iYjUzLTUxYjAwOWI4NGIyZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZjNDAxMDYtODJk\nYi00N2Y3LWEzOTQtOTk3NzA1ZTZkZmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZFcXNfJf5eegAdFEcH6G2sr4fYmAZaMY6M0cuJ2U9L3w+QcONUu7km8aci5G\nktX68XXPnQZF4HGn/xvnliaOjqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWbxt+1FKHXev5gCZthRtxwTWP4kwHwYDVR0j\nBBgwFoAUeH6MU5LKsUF2npSys+ZxYBEsGA8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAX8CKt1XRfmQPj4RKMqNqxNybNv8E3IOD7DuEHjuSiegIhAL3sHpFXIt5P\nwOKI8U6/sfSjhIOpiLXTE3jev0h7I1JR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV2rlbu2gKODoGzT1Nb6iiseMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTIzYTJmMi01NGY1LTQ0NjgtYmI1My01MWIwMDliODRiMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQphBdJgNM9A3iDr0IN0Ge4X0KkrqO/V8WIDRU5ajsuctNZ\n/498nCK1g63NjQqGo5ZD/Ft2LTEwepX4XV5o5GAro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeH6MU5LKsUF2npSys+ZxYBEs\nGA8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANflzWnHokelfTRJTvfggdEAvL6sJ01MZRxcSalKxGhgAiEAiy9tBlmF\nu7UnU+k/LL/xCucPdOBmvrbCJqlEEFUlyEs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAbwjnAb85nRr/iLTBQTQAddDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZjNDAxMDYtODJkYi00N2Y3LWEzOTQtOTk3NzA1ZTZkZmE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTc1ZDFjY2ItOGFlMC00MDc3LWIzZDEtMmQ0MzMwZWUz\nNzFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtEtOYODITR0dXqOmPz8O3KnF\nAj37pidTq30nlnRVVNMSm7AlMyugkUD9qBf9XvGX2OCpfBbUPseId4D0C383A6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWbxt+1FKHXev5gCZthRtxwTWP4kwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBkXUjdy\nKRYQqWlx0JhdaUx6aoxJYmPendEgdRRN1aguAiBeTAhZpP2mcHLH08Z7O7wnP9bE\nN2tE6OLPgMhccWlPkw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2801", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2801` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISATJvpVu4an8nrfL3F/hiukjRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NjFkMjgzLThhMGMtNGUwNC05ZDllLTgxNGE1ZTBmYzJhMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGExYjI3MGUtYjgw\nZC00MWFhLTk4NjgtM2MzNjZjNTE4MWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzed0aJJmTTt/FF8x1iKeuFIXA8uobI4Wf3Jqt0MuDbNa8fwe0BNkaleJyfPu\n3ovdeE/aRhH4K+d5JrNKkrqPgaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqYemoqx0DDyNO0WoyI9NNADtDRswHwYDVR0j\nBBgwFoAUwd1XhQHD5v1xqQiXZH7dUch7Vm4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAsyB9qEg50H9dxKEzV1zmP0m8N9AKflYSAgS2RmQo\ngRYCIH+6NjUWp6D/jsYmOSd26ggMLIVSwjUVoZlNIloGQ+Qt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb7ZrRC5Kj04p4QNgj3ISr0UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODYxZDI4My04YTBjLTRlMDQtOWQ5ZS04MTRhNWUwZmMyYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQE6aMmEiv24dfKc5cxE67HYRsxE0iVlS3ndXfNUOCptTTB\niF3kscu+M2eY+MyONJFw2C6bWEF3kqBxrtqr7EBPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwd1XhQHD5v1xqQiXZH7dUch7\nVm4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfOETjjCrpoUTyleVaap+EC9NrS1SQSNh3CKnxYWQST0CIHF+ZB9D1pLs\nydfZhcX0BOTvPk65j9ALLAaGwVML5vRN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASRLmZJsgDaAFX8dcvFqPGsUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGExYjI3MGUtYjgwZC00MWFhLTk4NjgtM2MzNjZjNTE4MWI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDcxYTdhOTctM2M5Zi00Y2VmLWJiMGMtYzkyMGI4YjNj\nMGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3sFu4/rfqGS7RDRKHzt2lQFQ\n5IRz1uRDTFupw9y5h+9GG+HaGmcFp1KEt9NJTA+XNmLyp64JVySEV8WbK+bl1KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqYemoqx0DDyNO0WoyI9NNADtDRswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD9mDqG\nubby5C51DDaSY6yR12wc+jGqjyVrOqRwp5OyHQIgZt/lCst3OWaNjPbxIb5v5OYv\nV34qRgOmLNEAedfNbmM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2802", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2802` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAa/O3WO7UREzhK/SuaV0Fle7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwOWRiY2QwLTViMWMtNDE3Yi05YzYwLWQ4NzExNGYxNjZiZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDcwY2M2YTYtYmIw\nZC00OTRmLWIzMjktYTI5MDg5YjdhMzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMpF4tCkn1FLVX7Inmx7a1Q7SC2iDR23Al7bxhg0gasKAx1qsEsHU02VHZxxZ\nSRSlmQaDyyCKngWobHjy/mLZa6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYE4MtqOxdpp8FSmVxP5oZ8tg79MwHwYDVR0j\nBBgwFoAU/MU4PACMfemvOR09VliNoijnUEAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBFxynZ5tcChKwhCMRwMma/elKJbj7G0Y1+F0s2uBiD\n1gIgWEFXYkn7lBDY5CvEoJ1ob9aMGbRbbt6d1fNs1vCCsxY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcC07mbqxw5e33kJ2caRYgTuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDlkYmNkMC01YjFjLTQxN2ItOWM2MC1kODcxMTRmMTY2YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGFWgNkj5jT0P/jmeRxzJFlJqwzgL5hjg95IWhfQrljAXR\nUFNHvV9Kdqg/NGrbFHer6cKxzgIg3RwQoMfd4JVgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/MU4PACMfemvOR09VliNoijn\nUEAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHTsyzY0iy2ZSZHNbQUT0raIFRQjfeZBKv3j7GkgviQUCIQDXLSrhUQ5X\nIJ4/HZf1hHC8SXRLsWv4RvuIBiAb4STZew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQCb5FIEBTh3GuRmtWrxezhBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDcwY2M2YTYtYmIwZC00OTRmLWIzMjktYTI5MDg5YjdhMzY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQ0YTU2MzctMDc2MC00OTM3LWIwNmMtMmFmYjBjNjhk\nYTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfkgOtILhy0st63dClXMq9QWT\nHVy7Vcsdj/Yq93bVU+j9Jmkl76sGVS24XmjboBejAxKOQHTNlPDMSeIkamcPfqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYE4MtqOxdpp8FSmVxP5oZ8tg79MwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC1uHIb\niWa3EfWBWh2EK0Blf7MG4OOk+mx78+INUKnHngIhAOEcg2FcgNF+wWoAbcmzR05d\nwryQtzWBcg3wFOGIYKQ9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2803", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2803` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAeinW8t6NVfSw9mFoJgmuWTvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkYTA4YjNjLTYzMDItNDIxNC1hOTZlLTk5M2I5OWFlMzVkYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU1OTZhMmMtNTRj\nNC00MGJmLWI0ZDYtMDU0NDcxMmJlZDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpR3eJ9+HjEsgA7JCZSjQDz9Q9ER76oqVXsUT18HBDoq4V6Lk2dBsYcNKWkZo\nJaIZ9QsVCMPWKeaezc5Wkh3bzaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR7OXcB4DE/s3Q0cKq0klnaN7eYswHwYDVR0j\nBBgwFoAUN/cZ8LPeAMlN7Ly5dnR+wRf+Uv8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAlqAtOGDnjTSo3NJ5jLz28EnDINs0RCbjl0d/ZLUBRywIgMFOA\nkgJHymx2g0FzluMR73EcRKShLhBFdyNTaZUGTf8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfW9PqpKDQLQRTh5JQZI9WRQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGEwOGIzYy02MzAyLTQyMTQtYTk2ZS05OTNiOTlhZTM1ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwPiQU7BCbuZh/WeCVcM32Jo3c8njmmBtoPV3ipeSG1Aiq\noq//xycgtumR7vXE0xwglpDYclLTCGLANCuOWg/Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN/cZ8LPeAMlN7Ly5dnR+wRf+\nUv8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJM/EqkmmV9oZ9bOlvjvRtnvB26Trxo84UuVVRCEKzj+AiBZ4q+yXwgz\nZnomXpwjpPmJhvBJ+l35owpCYJJie8RQrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZFOwmv6VWkSBMZcM73/CXAtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU1OTZhMmMtNTRjNC00MGJmLWI0ZDYtMDU0NDcxMmJlZDU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmIzZTZkYzYtZGQ0YS00MjI2LTljZGQtM2E3MWNhM2Q3\nYzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKwBH4yfDYlFN+R1TNa7fzH5L\ndoSZdX9a/NnEhqsQiktCFFCUTcbc6HAXMM5zUyceVYPwmvX+vXYlhUUGi8AANKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUR7OXcB4DE/s3Q0cKq0klnaN7eYswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIAJbGiM2\nhuDgcurpdSlgKl1cwo2+NgZg89Tzkz65ATX9AiEAtLJS6nC0sF30CRDpRp/bFp7x\nG4D4W3hZgaYcPZGLGoo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2804", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2804` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAc2yCi9owA+uo3oPmDRdrALLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0ZmQ5YmM3LWM1MjktNDMyOC04MGE2LTU0YzZiM2I0NzZiNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQ0ZjJlYTktMzJk\nNC00NTAzLWI5ZTgtMDJkNDM3M2I4YzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhapPOtBnud+wqs3gF53kPGppNK5e2N+EKm8XgaPhFjxknAkavpY/X37Dd2Jg\nf47cTGI33E6whwG/vd5DyJJ8Z6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn7RufioItLxZWbZ0QmB1umL7wFQwHwYDVR0j\nBBgwFoAUkEM7kGBhcR8c4wZ763BbhmaMiLAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAk8BPSWCru312Syl4h5TZ9gIfLkYth6k3\ncL9fNEq9Wq0CID3v4opIdfV/Y/nvdTzJgQbSWV6SmNr9v5AwqK15Zcvh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb05yS6g2Vpbtz+Yo8MeHTBgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGZkOWJjNy1jNTI5LTQzMjgtODBhNi01NGM2YjNiNDc2YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuyC2ILI5Q1fUGo+jyZNIzQ/QawWf1jpSWcIcZwonsRs9a\ngZO+Z1bv6CsFksgBc+vnA3NorDTOl0oiDPvyrT6fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkEM7kGBhcR8c4wZ763BbhmaM\niLAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIrbSfuQ5usSjg3922OYuVXHXjX6ZABngxTxsxHAYL6iAiEAxPASNozl\nJFz3mlcEts9Xn/xb3tol4EH6PXPs4rTVE+4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVHSXUl1G5LglavFxhexir7XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQ0ZjJlYTktMzJkNC00NTAzLWI5ZTgtMDJkNDM3M2I4YzVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjZiMjlkYmMtODlkZS00MTUyLWE3MTctMmQ1NmZmZjU2\nOTk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEowEycSVATREY7ekrHkfAbG8l\nMVKG92kdFSc3KwKfi9PkvYjKCLzJsT2tDgptHbAyfxW1UrtwXJ2ZFayTMC1kjaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn7RufioItLxZWbZ0QmB1umL7wFQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFIGcMr1\nmr3p7sOmMgq6yB0DgDCG1NiTAS5NATLO1MajAiBWKHD8M/e/Wzp0UgJD3/QW98tK\nLL6MEVZoKfdK5gpP1A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2805", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2805` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAbj3ngJZteSeHl0PKR9gCdz3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiMzhmZjFjLWE1ZWItNDY3My1iMjgwLWM3NTUzMTM4ZjVkOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFmNTRiNTMtYWVi\nZC00MTI4LTk2NjItMzI3NzI3MGFjN2Q0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDcXjG84JL+F6W7PSJCK7HMOSwgE4qPcIWACZoGQPph112XdnDa+QI4JBZAN+\nHuxlj6uPIs55T5AoBJ9aT6t/kqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGg5D1MWVs+yeR9VZABW/UcEW8wkwHwYDVR0j\nBBgwFoAUfC+JQkHkRrCRA9W1nrQc4cDvWjYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBm/FLMtWw8nRwRQ8qsrOhGJhI/ul8a1Phl\nO588cYs4ogIgJ7Oe41Z/1iC/0aU8RBKcuxLACVS3+K2zithgP9HWV/s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa543rDT13lMwDQN/dZSkNmpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjM4ZmYxYy1hNWViLTQ2NzMtYjI4MC1jNzU1MzEzOGY1ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5YHFNb+3KoXYSATxVIQdcFFBydVIAb5N5s1cffH2AI1xs\nJT1Fa692LT+8Msa6rzTQ8AE4pSTI2bImwsLJQHOzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfC+JQkHkRrCRA9W1nrQc4cDv\nWjYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOALILz+pDBvI9QDdb1mNwBwVyR6V9ci5WBcSKRyc2fWAiAXW9KOVxXN\nAO+TWJPnBNqCZ1oa81YhP+YFZBKmGwpnug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAb6uBeUQWM1+PpIlDGQRisDNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFmNTRiNTMtYWViZC00MTI4LTk2NjItMzI3NzI3MGFjN2Q0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGI3OWE2NWQtNDlmMi00MTYzLWFkNDUtOTQ0NTYxYjMx\nOTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA9MSNyJarWX7oDJeacHiKbS0\nk0rfi4EZsixvwa8+Z5Ynckk/bJrXA3Zisbeb8ch+/mn9AoV4k069xEJLyJXsZKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGg5D1MWVs+yeR9VZABW/UcEW8wkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIH5ijmIW\nycFwNx4FXW0E8Kin1K6R51889mG3WvBaViNJAiAu4IwyUXQ2a/xwhv8yYLrj/GYO\nHKm3RVvxVUhJUUeZ5Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2806", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2806` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASeQ6nENqXsPUTnfEz4f/ACvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5NTMyNWIxLWQ0Y2ItNDFlYi04Mzc4LTBjMmVlM2Q1YzgzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk4ZmJjODctNWZi\nYy00YjI3LWE4ZTQtMzdmMDcyMzQ1ODczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGmSLW4TZZEAfj4Q5rgwtJEMq40kWfH6QJfT9ZNsWg5Fk3HMxGuvxE61V/IqF\nk9uJrlcxZ6N6pshxoob/cqQO1aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Kdcw2Lwe5XEZRqfRWGhG6xIsk8wHwYDVR0j\nBBgwFoAUAvqVmQ38qgU/cxjp+n43yPHeYTgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAmfKRCOE6rrma\ns/1LIQOk+IdFUntu/GfGIellUF+CtF8CIEv/6FZHpDNnzncGx/sqRDoLxm13OTxw\nrszOJ6sDCKRz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWKVY5+39U7Z48j2QmaHmIYxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTUzMjViMS1kNGNiLTQxZWItODM3OC0wYzJlZTNkNWM4MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWWzpYnHYADS7y6UGZyr212Rtg6sFUG4pnVxgu6PxpkPN6\n9lShhoKmE9ijc0en/VOjSIEGLXbAmZja6RFfa+ARo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAvqVmQ38qgU/cxjp+n43yPHe\nYTgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZb7YVQmSfpHNiImJvoEna+YGGXf1ulzs8sgFU3j6qtcCIBpA/qMh7OVF\ndqpnifJeaRPpVJyu4XqI4QiTQqGhGJOW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQJHrzpaJwOsnNzgaUWhaQKGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk4ZmJjODctNWZiYy00YjI3LWE4ZTQtMzdmMDcyMzQ1ODczMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDZjZWRkZTctYzFiMy00OGFlLThhMjQtM2YyMTliNjVk\nMTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERNjMmDvFGUPFOghNNFF8qxN9\nrbjfGtqCyMe+zoU9VIFjKCD8/VqqY9bkLc9C2whjLAAJWS3F395i16ZqKbFIRqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+Kdcw2Lwe5XEZRqfRWGhG6xIsk8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCTUTjl\n2MqGcirRtmTUx/LQED5DpKfCOcu2ECKgOh/ZqQIgTHOP8lgSHMAL7yABPQS0MD0W\nwf3PDQBQrKMy7oCY5SM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2807", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2807` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbWdoTejZviShpXfVcVVYichMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjYzExN2M1LTBjNWUtNDBhYi04OGIzLTQ1N2E2Mzc5NmZmNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjRkZmZkYWEtNDU5\nZi00MjM4LTk2NzAtMDZlZWE3OGI3NzE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Ja/yKQ3sXwWycGgNOSojdhCRUM4IDT7bJgzmba5k0MlPThV63UY/H22sfWn\nhq6+Caq1s7QYVhW0mFkgihuhqqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO/Rvl+fglgiufFO6BZ9JCicl2LkwHwYDVR0j\nBBgwFoAUPJKVoT9gj7xdggkXCm6Azt77gsUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBSgtfn3gf/ydudBmcWyVSVvsQhdourOhPVOQCQEoH1PAiAsRtgj4XGbSsPe\njvZw78REgXrOpEDGvko4gAhxF4DCrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfTnNP0siO7KgAb83SRZD2EqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2MxMTdjNS0wYzVlLTQwYWItODhiMy00NTdhNjM3OTZmZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDdbjDm9Ap5NI8ebETZ4b/n6ehAe1Tv6uFPfk9ZaFTQkB1\nb58v5y4IECv42wOF77xS0Q1YMX2y5rFd6aMhmNpNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPJKVoT9gj7xdggkXCm6Azt77\ngsUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANoUncP79SR/SMXRXznVNPO9SsdQHwilwGiClNKpPZfOAiAdvvUr6UPx\nRxR2ue//TTksoJHiv8veman+NUMkMsmzBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAR+/cA73Wegk+pfnrvOF+uFqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjRkZmZkYWEtNDU5Zi00MjM4LTk2NzAtMDZlZWE3OGI3NzE3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2E5ZDkxMTUtNzZmNi00YjBiLWE5OTMtMDM2NGM1YzFk\nMGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEz988zlIH1ZNB7caMMlBwxAh7\nlDEOy7Suxs8UjUWQ5y+88H7kfnj4zWlp7UK0oJ9zDorElTUsGklU3i6zTDTALqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO/Rvl+fglgiufFO6BZ9JCicl2LkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDDCzrNH\n781c6Xoq3RsQrkWCo59nMNw/SAnfM1Q0x15sAiEA1nnvnINiRleoGnFj3Dyl/Ilg\naC5FemZRnJT5B/H7EdM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2808", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2808` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWBVbeIcVYIzctilYDyKw4E2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxMzZmYTc1LTNlOTEtNGMzNy04NzkyLWRkYzEyNTI0MjA0MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgxYTIwNzYtZTc3\nMC00MGIwLWI0MzUtNjk5OGQ5ODc1NTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnhu9lHax5aIusiYEUo0wU6UxByw//eX8uqh09cSUHhfle5/A4dowSbcFqfPl\nU0/CNpUWBbzUiF+SFRlJ7Z9TMqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU39uUb3f9XmresmuBgVj6aXRitv8wHwYDVR0j\nBBgwFoAUTYjRAT9g8rCstikUlyPs0rsOdnkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBg16LZDoflU4iv/SZXp92JRwjMo2RcLC1kKkU+tA749AiAEFqwNmr1/xEXh\nP/743Sv4HL0qctVGHfNt7IcbbNFBOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZOWoKMFyFhPNSGTAyG9Ao3yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTM2ZmE3NS0zZTkxLTRjMzctODc5Mi1kZGMxMjUyNDIwNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHBnaCMcYPtqlRzlHeLgrgqxdhbnMNSNddyUYt1YmnQO4F\nQyHNjgLiAEsUWSJUeG6zvFwHa2tPe+44YEOFEdcwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTYjRAT9g8rCstikUlyPs0rsO\ndnkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeZv4qvKmVvBgBQyfuIC5qM9DJx1lVw2zA8pcw5R1ewsCIQD9SNGEFB2r\nlgyAJO9MBTSVPmhgyHK/wbjz4XQpUvE0hA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAff//8MEMn2QP/pfouzMyFxjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgxYTIwNzYtZTc3MC00MGIwLWI0MzUtNjk5OGQ5ODc1NTZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTVjNjM2MDctZjdiOC00YWMwLTllNmQtYWUxNmQ1MDBh\nMDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0l2Ry19wcvV14DAQpGJjByDr\nzoikGodX76uHM5rgCDi89cqHk7zSjvUsyRNuvDQx7Hvw2aGJPyL2OSaz4wewq6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU39uUb3f9XmresmuBgVj6aXRitv8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGexZpIO\nuncA1IHGcB0+dC5mu9gdfCX2Ifu4lLRC4HP6AiB4d4Qnntd2BUnJX2b1846OxTf8\nf699aiPa8bF9ymXRkw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2809", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2809` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAR6wNvzww9dN0cG5B1zQEKJYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ZDgzNDExLTg2YmUtNDI2OS04YWU1LWJjZTc3OTgzMjk2NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYzYTI4OTctMWRj\nZi00OGNjLThhZTUtOTQ4ZGI3ZTRmNjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERaSJelBNRWyvTtIm6oiAhiXKgN+vhiq8+Xd8UuSnpmU0rKJ5SOtK5UEoEclL\n2E8aMZE67w5YjjpTg4Z1Aj7956OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFwlJ4QKOxgyCC4EjPA/RtcXKHskwHwYDVR0j\nBBgwFoAUGTld35zynU+sBucF5/QscvoJusAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAyrIskUh6YYzNn1TMVlNueJ9rLqwjs2XbE09bdUM1hRUCIBNlNd2Rd4Pw\nS9JlH1hZ3ggnjCfyMmcJATpWLfYJ4je3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe4t5v0loX+b7Pqemj/+r4LUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWQ4MzQxMS04NmJlLTQyNjktOGFlNS1iY2U3Nzk4MzI5NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQShkIa3s4N5U4yzNTft+VvnJW6p2yNX9pAKcgwplwtP8+A\nvP6rGY0SYLH8orAG4qY3YF3ZT4bwVbdqM0sqqol+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGTld35zynU+sBucF5/QscvoJ\nusAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM/l1XBoO6jlNuJPpLffgz+JiAcoGmTTUd8hPbFS2QlNAiEAqI06RNug\n+cYsvZJboVwU9YvqtdXvjxuadQjeCo9Q4ek=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASB4PL0/ZGV//pIsWfjoymrqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYzYTI4OTctMWRjZi00OGNjLThhZTUtOTQ4ZGI3ZTRmNjM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGFiYWEzYjItZDE5Yi00NjY4LThlNDgtMmViYjY4MTgy\nOTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJVNcYCdRPA5wddrHJBk8QXH0\nFLtP2jRhQEeaWVuUrA307ZsxTvyUVbMqt96vOeZ2nTXbqAegzyJc9AMmZKKvbaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFwlJ4QKOxgyCC4EjPA/RtcXKHskwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDF5/E+\nwrphks11yDm/izQ6/nFJJg6dgHcSfe0rJ1q4nwIhAKeFbNXrdov8zmQB9lkYuUcX\nztfDZFca1hN+FAiGWO0u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2810", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2810` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAesLSbsT4QuQ7YlhhSnAk2TZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiNzlmMDIwLWI4Y2QtNGVlNi1iYzc1LTAxYWFjODg2Njg4OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDgxY2IyNjctNmZj\nZS00OTBhLTg4NDQtYjQ4NTdmODE4Yzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE8L2iDsExLhrm8/h4dZ0msIkIFNfTgHf98XlP/TDwgUN0gJHEIXDrAcLJ5pH\nLHJsvD/IorZZCvjkBHZEyV0VvKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHw9Vn/01LB0pFUCttfMDE/d00ZQwHwYDVR0j\nBBgwFoAUIfikBcs/SmzTJi/vDEB3/sh868kwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAyYTS/W1708AvXNPDWvb8vwp4b6McRQm+x4wnToxt\nqCcCIQCR6mmbRQt0ZRHlok5m2iwTEYx5cm4L+3bbAtsj45N0GQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQzHYXG0gZ1NKCZCxIqI2VbTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjc5ZjAyMC1iOGNkLTRlZTYtYmM3NS0wMWFhYzg4NjY4ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfQtvW2s6DFAAkZEAzcZF1FcvHGeyXD8Bl7mKVVoJkuK1c\nb7xhzLmsTI9xc8BZ6019d+1ID9ri/U+9Y3YyqZVbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIfikBcs/SmzTJi/vDEB3/sh8\n68kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBNeEEeo7pxASONv3COWa5tDdMqB2f66xE1MJlHGJFbcCIACpfqBC0VB3\nvLyldu4yKtaR/HoKlwngnqFZfXDi4KWg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZo8JQzkPnLF6HMgGT+dZLTLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDgxY2IyNjctNmZjZS00OTBhLTg4NDQtYjQ4NTdmODE4Yzc4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmZmNmE4MDEtN2FlNS00ZWUxLWIxNmEtOGRkM2MyNjdi\nMDIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiqT2gL6cqNn9JclVJj6J06zp\nEE64WZ62YcrJjeswFZAEtyXD0PG0w28lH1RDK0QJ8HOKFpHkNx8YcUpkxdZDsKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHw9Vn/01LB0pFUCttfMDE/d00ZQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIADZHOlx\n7yxOffiNhKV5pcRGV+C98eVD/7CvqnYyfdy8AiEA76FDX1DGUqbWmWoLd5nX3mrx\nUnEWr4NUSAg2s4JmcLk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2811", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2811` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcK1jO0P4d09vUI22V60OnnOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlNTI1OTA1LTE0ODYtNDZjMi1hMzhhLWUyYTY5Mzg2NWY2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYxNzc1NzQtZjFi\nNS00YThmLTkxOTUtMTIwNDJjNzgxMWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElil2Kpl0i5Pmb5SmDBExj767C3MVi177zYKD7xcYe/EaNRJg3YqB+d+Nwl9T\npvII1+npGtC4eXMOZCMqTbPh+qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGB1i7nZoYpBDAS8V6hA9x0QvWRYwHwYDVR0j\nBBgwFoAUwZEI/SAvR9Cu4OI3IU9isKeuOt4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAEOOrqeOA7zmymiqdBGNfbACMf9IEEMhnThJ/adb+3\nSAIhAOMvM7cPN6NGnK08TXnIg0dzeMAy8to7P/mHFPp0Gs96\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWPFRi9zvt74vFqWkJkVdJhQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTUyNTkwNS0xNDg2LTQ2YzItYTM4YS1lMmE2OTM4NjVmNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9KFDdSm5SExEjyiy3DumcSgk1NNEAnXU/d75syboHyn8+\n7a4DylBQ4QQhtT/cF7QYzay2QCfK4pYsT0MtKhb6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwZEI/SAvR9Cu4OI3IU9isKeu\nOt4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI7RW7dHff4MNnpQS2XLuzF+Pqwth1ZLFrJOU9j+d38bAiBUPX7GKEKs\n5LFSs2Vk+UkY+EPsoxpc9NT2D/76VgPTHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVV+KvbQsxd84kZQZ2ePqxjeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYxNzc1NzQtZjFiNS00YThmLTkxOTUtMTIwNDJjNzgxMWJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOThlY2QwMzktNzNkNS00YTU2LWFiMzAtMmVlNGIyNTA1\nNDc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE564gH0wWUk3LNcxUPYXHjwrF\n9hmH5Rm+/UaJlN6DeSQ3bydnYl713zUaPV61q0js4bua+5K3e7jX37nqp+lV2KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGB1i7nZoYpBDAS8V6hA9x0QvWRYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIB6y51L9\ntbQ8U4n7PdCoKSE/tQ+TP8YG3yICmej6230zAiBpga9tvzqfY1XFSuWCZ+ak0oYQ\nKVqNvdURbywimWYHGQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2812", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2812` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAUQHqnCazmPRnQvbx3q1Rax6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4Y2NjNTQyLWFkZDItNDRmOC1iYzNhLWFjZWE1YWViZjM5ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI3NzA1NTEtNjIy\nOC00YzFjLWEzMDQtYTQyOTI2MmI4OGE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE91Mn9nmzRz06D0NNDAXsYGrKWlFWwoAxn8sBI2dN9ryMBOJvP37aebOX88Sd\nj77Th3KjI8fmvSbYfpXZd4esz6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtL3mpmXngp0RsX3kyql00o6NrrEwHwYDVR0j\nBBgwFoAU89yY9mwxWEaZYgoSvlNV4pnJ1J4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAmxNabvECxFt2ZPyY3/ob57eW4iIzR/GDF/pNBCt9Vt8CIQCJ\nixX9lxmVfVKAMg/k3dcVl41/+oIdV/USXOHDfWM66A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV4DNddDnJLAyzm/ctRyDnyPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGNjYzU0Mi1hZGQyLTQ0ZjgtYmMzYS1hY2VhNWFlYmYzOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARi4rj2PgrrM/1f+iCh1thULDfCzSjayTZZwZGlUfKPKe4O\nXA5gYY93m5bMYcKDODyRr8vwMu9k0h4uVfyEXlqro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU89yY9mwxWEaZYgoSvlNV4pnJ\n1J4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVaWVliB3CsJKVIpLuCNl/cd+OPR77BSvcjYkYv+COf0CIAIklL/A/I6I\nT4JwHtA4iPeERznJiIXiJvYrmu9nmCZC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISATvvxPMguGx73vQEZGrde2XwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI3NzA1NTEtNjIyOC00YzFjLWEzMDQtYTQyOTI2MmI4OGE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWY3YTMxODQtM2I1ZS00NWY5LWI1Y2MtNzBkNzJmMmNm\nYjZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM4OJc46n4KlcxexySaxV9l8j\nTB7DsMnMYmXCnU0gLYOrDnHi8zYU/MQEQCVKHTJqonOGVF9DTGvxTmlcRIINhqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtL3mpmXngp0RsX3kyql00o6NrrEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC1TxTC\nXW3lLAFpaa967exJnj+Fs1wlfixbplnTNi5RXQIhAKr5+Q9D+NfNLN99qIZP4gqc\nkpm/065VHVjpECFxcPvq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2813", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2813` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAR+a2CkJhIczcUrHOJeNA75HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyZjhhNTdiLWIyZTktNGQwNC04MjU2LTQyZjQ5ZWM5YjFmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDIwYzkxNWMtZWE4\nMC00ZTliLWIxYWEtZDg3MDY2OTkzNmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExCeh2trO63JKcMxucEC6biyJqLxDANHPOy0t82dzV+n2EshD1LnxUfZtTc7U\nvCWgi0MNjm64ajRC3buRpAZJgKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGoR1yRjtnTKetYk4TIKs7vsUcGkwHwYDVR0j\nBBgwFoAUbCkEJRvpsM8tvC5wY8mN/LVuyIUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA39O1hhuZ2s8xMdEWZDJBXjVuXe74Mdma\nJoP05Esl0eQCIDcPKCul0/67tXPKktJ7vxqYNVqYM9+YbzVOUZYQOMy1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATupjJ+xzXFdFnumRXU0cFl5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmY4YTU3Yi1iMmU5LTRkMDQtODI1Ni00MmY0OWVjOWIxZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgTXE8sA8bK7cWLw80MsatXnIu/HzzbwC+rFS/3Dkw1cwP\n7JNDiOicdd94fm0lYz/QYgYaTjaU38+DbJA8QZtno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbCkEJRvpsM8tvC5wY8mN/LVu\nyIUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOpS6iIV490C82imH2Fk+Kg4QfAgJCja2+RLZWZFDYHzAiAo5ox5KbC+\nPzLEIIRRWcrlZyhcEhNXnAz0ikWniFjRNQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQ5fVzmYUadClN7YWaQwmzQfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDIwYzkxNWMtZWE4MC00ZTliLWIxYWEtZDg3MDY2OTkzNmYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWY0ZDM2OTMtNTczNi00NGJhLWJmOWYtODc0MTMxNjcz\nZGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDLy04rU9VqRCXWwakaZgciqY\nMYIClf0L0ecMBpwvY6O1gJtMVWGyKgJK7x5SlrBXTPiVYIlJ48j6M5rpSXpFOaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGoR1yRjtnTKetYk4TIKs7vsUcGkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCnUQKH\nf2CfvAl6QCAI67s/cP9otW77HwQsJafvePzGjgIhAJ9N08YXi8mfFlKJTH8uVPiR\n2P6niM6X70HvASPEzd/0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2814", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2814` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAaVWyX6w0/tOUxj+DjjJm/ZxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1NjBjN2JhLTc0YjItNDhjYi1hMjZiLTRjYjg3MDJmOGQ2NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI3NjY5YWEtMzQ3\nYS00Njk5LWFlMjgtNmQ3OTdhNzFlMjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPFtFTGg7ZD/XwxKjTeSuaYEUp7kIfMEgM5ZbLmpwVvAuGQK5hcPJSAnQYkEZ\nwmv3OSK9eS72t6PLfqQkOb2sf6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4TuTWogVb3NZIHLinJU2RWMtFiUwHwYDVR0j\nBBgwFoAUFHUhZY+ONzrGFXP3CfwsPFJJmawwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAhjDN6vosYq6a0UawgbkZmMm4kwzSwDjm\n0IUs2nwwfOsCIQDZWFlNH9Rdok6Ju8uF/+GJLyVcOSU9Mf4Up7LuDGc81g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASockqhAvv9LJJGDUbysmLlvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTYwYzdiYS03NGIyLTQ4Y2ItYTI2Yi00Y2I4NzAyZjhkNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLb9CMFzbmqkUF1zzAJSwBxD875H4UIHGZmiq8p2W9ERDE\nCqzAP8zEAz0JLEKyeSv2FoYTheCv31YERyd0GvUwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFHUhZY+ONzrGFXP3CfwsPFJJ\nmawwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKYQKtpZP3NuqVPejOpktxcGt3vplWGiNhDa57ZRSbT3AiA3a0uMXYbX\nrKUijPE2tiAlBSzlfxvGRDVTmMHsx8JmFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATmH70jkuzjnOIC46FhZwoZVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI3NjY5YWEtMzQ3YS00Njk5LWFlMjgtNmQ3OTdhNzFlMjEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2Q4OGE5OWYtNWJkMC00OTNkLWJhNmMtOWY1MTgyNmU2\nMmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3zz50djGoV0okMT/95Ve4oLX\nuCs9yXWOSZl489xhYZJW/rGkn5ckeBK2XGRMHoB67JQKfEUzyQmnGLwyqh0rv6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4TuTWogVb3NZIHLinJU2RWMtFiUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHAdciaO\nRVgnf12xI0pti+v8NNfcvCoRgENwy+ZoSBvUAiEAyA6euCD9T62XdINWxxFpuNqf\nXhc2xBHSDjpvrVbbPbc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2815", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2815` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAaZf5iK/Z6kgeV66fstd45QfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1ZDdhOTFlLTZiOTctNGZiYS1iNDhkLThkYWM5Yzk4MzliMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA3Yzg4MDQtZGJi\nOC00ZmI0LWIxMWQtOGRlNjBmYmE4NzNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6qNphNlk0YnlbD6XkPRlrDoiVkAhitprvO5PzYzxhLrtdRhWOJj/Xx5mP3Sl\nOeybNMP5vDjXPewFKgXu8sjkpqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU967jHIreTKffzHKYynqhNz2unD8wHwYDVR0j\nBBgwFoAULVQbQKjZPWEF2lroVQm8/NLVda8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFFPC6kqEvN5l51/JDWy/NVJRp9m\np5RGYkDlv1VQIkctAiA3fqCDfv2nuez591PdyKd/6GTomcu7H4TAkZsZH/7YCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW7CRev+H9dwGKJy3s5kra6AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWQ3YTkxZS02Yjk3LTRmYmEtYjQ4ZC04ZGFjOWM5ODM5YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrmT9Mo/54XBVVWe2YG6dMg55WimTzK72WVmzV0I/rd9lb\n9N57yCZ2IdFC+lw6cAocuFNPSx9/csXVSrC11HFeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULVQbQKjZPWEF2lroVQm8/NLV\nda8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMvfi/LqxP2dgNbosKU3cDhZLQvc+X9ED5xH1BargXpVAiBbSwhfIvu3\n9vUQG1PmD1RuQ9gxK+m/hE/1D44cACpPYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZ0Rb4WjReiE4cDq5dYGDTZsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA3Yzg4MDQtZGJiOC00ZmI0LWIxMWQtOGRlNjBmYmE4NzNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmVlYjBkZDktNDNmMi00MjNkLWJiYjgtZWZmZmY3NmJi\nMDFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGjc14/AYOjuDrtR3DLwFexc5\n4/A1WFGz4kJ+YTE6OA1HKDn2WW1JKpw4YwiuqfisA1UB/lvu3CER/JH0NpYP0aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU967jHIreTKffzHKYynqhNz2unD8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHcyjDn6\ngOjedVYlGTFlVHjjR8QUpHXcsz49xbG8qfsiAiEA59/unXC4tj1RiWbL3y06Jjnp\nP7WtI6/6ZGCyUDW6Sho=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2816", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2816` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAT1NSrAA1z2TKAQyuB7jCCkOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2NWE4NDhjLTA3MmEtNGRhNy05NTlkLWU0MWIzNTA2MjQ5ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTljYzFjMGQtMWMz\nYy00ZjI2LTk1ODQtYjc2MGQ3ZWI2ODM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWTe0LdeyJV0Unaej2CBmzTY5HW2kHbRhrtFhEUrK4bzTQbTCfDLF8Cc38HQ+\nAspzQDPSD/vVhl41AkkhR+rA1KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/vEh/+fjSlwgsYUUeKOtgAG3yicwHwYDVR0j\nBBgwFoAUdEJyQKHeNqgIOlVBxH3Dy4duYFswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJzyMmFV\nyRLkGjGhppS3pFCJEflcdzp8yaanJkyCfzvxAiB5apdYYA9rguk+HoTKNP7RGBWa\nkjiniDIRADsqk0PrfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYOOuXtN4B2KPWWjq0oEBb+LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjVhODQ4Yy0wNzJhLTRkYTctOTU5ZC1lNDFiMzUwNjI0OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ29321lh7bFkhr70WoOTT8YK7fhwQPGal925QwKBjWoKDJ\n4j8/oXzBK8ivpHDtIW9js/4tUd612/ViaWYbKsd9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdEJyQKHeNqgIOlVBxH3Dy4du\nYFswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP2/jgr13CSY1ZDrqUsB+nDcf9bt2oo+gJ9wzeRubdY4AiA3tJKf9DB1\no4CGJxos9t5M1TOXzoczOQ0gnlsEx8+ySw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYjBFRJOkKjYw4k26jRhm6d8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTljYzFjMGQtMWMzYy00ZjI2LTk1ODQtYjc2MGQ3ZWI2ODM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTgwMjYwZTctMGFiOC00MGQ3LTg0ZDMtZmNjYmI0ZmVj\nMGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeilNhu3LGfEvULV9LwXvCAVO\nhUj7/BHm/l4z9Z39MJ0pNFI3H6NdoSy4UrMhlkaepPtSj9jHNBlTWQaQjoufeKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/vEh/+fjSlwgsYUUeKOtgAG3yicwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCz949a\nwzAV05TtH0W/sZPXawcLaZica1A3oVJqNkjOgwIgXIeERYhxNcZ0AmuAFhvmNYNC\n1Uprdx2W2IuMCoyg7V0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2817", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2817` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAXcgBvy9tb0qLnsSX/KCg3iGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1YmQ3YTExLTYyYTctNGZiNi1hZTA5LWRjYTU2YmVjMzFiYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk3NzI3MjQtMTYz\nNS00ZWMxLWEzYWMtN2FkNzZhNGI1OTI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWOY3hOdZeC2ZWsbeEd5bYvsvqlh9lQgH4A9JhDsNuAo1lQTKFSGjzhqznJWy\nmqa3KNM1M8LFChAzSmK0MXcZMaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEi8HA+CaGyyc5TA5EWetlsQPd1MwHwYDVR0j\nBBgwFoAUgnDWe1KYfBMrCXH+9sJ3EAfECAgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALHgQT4N\nBLqWxQ+VbI7GVs0TfApEd+oEyAJRcaNRNcK9AiBAfH2QrQFllzBGXBvQM1OjUOj1\noqETZHPy5wexGxSipg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU+VLEg/jNRNyk21nnn8rnGkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWJkN2ExMS02MmE3LTRmYjYtYWUwOS1kY2E1NmJlYzMxYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATM7wbF6ozbr9Q+VE5PhbPs0Ku0eLoU5SZ30Og5WzLBoyHh\nHyvkO+SujMW36mQJsvp1RCpjk7qfWG3x8c0t+W0Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgnDWe1KYfBMrCXH+9sJ3EAfE\nCAgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIndO/K+Z9cVh7nOYPBakRL6DmU4obPiSUdecD5AXl1cCIGwAi+QkN3W7\nsZ+ufeFzrwnRhaFlqHOtfE+19bBOW3OX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAf6ltbTk80KSe/bsQmtCrU+4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk3NzI3MjQtMTYzNS00ZWMxLWEzYWMtN2FkNzZhNGI1OTI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2EwNTU0ZDQtMDk3NC00NDhlLWJlZjgtODA5Nzc2ZThl\nYTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH3A9LguaKiUW4jnB6tjc1YWW\nqnJws28jKSjJ6HvzppX+TyHdRQSFvGalvXrwhU7H/dfcEoGTMRmDWdmX2vCG0qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEi8HA+CaGyyc5TA5EWetlsQPd1MwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCTacjr\nOExNQGTfWPVdT4DrDSLkOs/WHNzbHpItKaz1vQIhAMNu0ZwcX1C27WH2n5ob4WTS\nitBBx1bO+EmRvTWI2IAA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2818", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2818` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAcrrdsQiSntSW/JoHjdyn42GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmNjBjYWI3LTM3ZWEtNGFjOS1iZThiLTkxYzA2NDhiY2M2NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI4ZmY3MmQtZTI2\nNS00MTc5LTk2Y2YtMzcxZGRhYTdjMTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOXPBwwRYRvQ4ak7MQPM4czAmxz8o0zCfA6RDnt1AdST2b7AOJUw8GC/aCWgz\ndx7ifo4nlt5BARH7EBhd6A71iKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQMRhgYuZRYU5Jl9tCW+D/SI0kRUwHwYDVR0j\nBBgwFoAUlsM9az3i5XuQc7oITilGZ+zqNgswLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDEThp+\nZC5PfYc3Wol4hHNUdOf1/0WIBs1sFGQe2YhGBAIgAuBD3trgYzbK+wyZtL70LAc9\nDoqaB9BOiot6VvDlOqg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaqCYqKVumjbk3ou5H0FAFYBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjYwY2FiNy0zN2VhLTRhYzktYmU4Yi05MWMwNjQ4YmNjNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9a37P6vWoxvg/leb8qyLRGHTLaY1W4eKnzmvwXrOFXDbr\nquh89OrjmEQtOiF+dzNGClqfdTu5LPg35y0cWNsmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlsM9az3i5XuQc7oITilGZ+zq\nNgswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJRadUl9n16m9MHu3CWvWITyCaVvp+XKMfKshfm2QIsICIQD5XTS+z436\negoB4YQOs6yXM5fAi0f3Q/stenhGYI+Lww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISASSf9AKCDrH7MUSl9m+VILSsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI4ZmY3MmQtZTI2NS00MTc5LTk2Y2YtMzcxZGRhYTdjMTY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDJiNGY4YTctN2QwZS00YmRkLWIzYWEtYTM1YWZhYWI2\nMjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUrdaGHjDjspdxxCEWOrNoCDu\nHdUtjm5dJmuZv9Qqo1ERpmsJSx7qkoULOQv2OfdYWVFjLWwoD31Y5bKYgIi+q6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQMRhgYuZRYU5Jl9tCW+D/SI0kRUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICxB3eWF\nhlNVZHXCXQDDK+yZAj6NR/MGbNwPPJcLUdMfAiA4EkSovSlTLrtxTkRE8b2r8DTA\nrjHKIEgE3ygrhPgmrw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2819", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2819` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAWI9+2rPIpIry2DwalDsRxhmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YzFjNTFjLTRhMDItNDkyYy1iN2FlLWU3MGJmMmFmODI5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdiNDAyMzMtMjJl\nMC00Y2E1LTkyZWUtZjMyMmE1ZDZmOWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaiSuLGqC6AVrLlr/6hH8bEJ/+gLc8QcuYxQwZFIEa/HHgUjegrz9qkD0X481\nEMKmFLcdYkoPrxCvE3c2WvIBe6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjhaBNwSwy8kQ7TqaxjiZNC2DVRowHwYDVR0j\nBBgwFoAUYDNz63y6icUkT/0DEwuMxJAwjUwwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCI7RuJG79y58TMrxzRwb+SD7ztdjN5P5N3132wrQWWlQIgQXDsfyZ6\nrrU7JTmseci7OvT94fvWrOghCxvdNMDTI+k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQwxH+JrqIrcuOwqSnn+Um86MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGMxYzUxYy00YTAyLTQ5MmMtYjdhZS1lNzBiZjJhZjgyOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbyW3WulAwQxIUk5MWGJiBdASe9iNbpbgZTqjvk4tRel8r\nLNkVnDFxw24nfowPh6/i6oOGXa1Od/Bz9YwdNf8Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYDNz63y6icUkT/0DEwuMxJAw\njUwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMqpKhCmDcfAzHeeybmSyF/zP1I6yp6mXjhz38ap5aFkCIDZiuARl+o2b\nzPNHv2jrLy4j2h/B7SnwTjMXnhEjLdCT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAX214w0j+YjYstzomVgrrkvsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdiNDAyMzMtMjJlMC00Y2E1LTkyZWUtZjMyMmE1ZDZmOWNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmVhYmYyZDMtOTYwNy00NzMxLTg2YTUtM2NlZThlYzE1\nN2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP3L7owxRswzcAMZvPpF6spCB\nd8HkFaFZxB0uuq8gOLQhL0fu+IMUwVWntc9/YdSz0DBxOFiN3M67VGaJ9Ig6yKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjhaBNwSwy8kQ7TqaxjiZNC2DVRowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD4ktOG\nadD1fNzu+s1KS6nP5SAQFdDFKd+xRHrcdFGAeAIgOri8fBJ7QkvVtr9RTOBQ+kH9\nktcpIHSDbREopkAvIqo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2820", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2820` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISATK0etRe06/hMVpGxWiR3fZUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3YTFiOWFiLTQ4ZWItNDAzZC04MzM0LWIzY2QwOTRiMTgzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RhNzA1NGUtNDg0\nYi00YjY4LTljODAtMTEwM2VlNWNjYTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOsQkDRvc7bLalpATl3qk2EukOvJwKB24jsPUwaxoakGYNA/oLk845Ld2gFMV\nJOu8CBEZxwFojf+soYjz5SEOGaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgU77bXfnxYvItnS70TcW+dtuVw0wHwYDVR0j\nBBgwFoAUlYU90kuVBcjSRxbwm7EatBrhox4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIB1vYOtejnSNT6OwfGQCve3guY26XZvkgAfiULrRl/GuAiEAmddH9SoW\nJI68X1IzGDC7NU2ZEl+lF/XyOkSOWyxYs4o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASmpRAvOkYg8S4o4rAFAbNOlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2ExYjlhYi00OGViLTQwM2QtODMzNC1iM2NkMDk0YjE4MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPt89LRbdUf20bCCoyV8+fG5bQtstZOGWomu3p8nOXubLJ\nXoRukZJMJIKM+Q8HRktUn+pCEiW049mk8treI1Dlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlYU90kuVBcjSRxbwm7EatBrh\nox4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMFMLVVQIn/XpLke4PnWmpWaBD0ZIktBNf8CV0ICRaUiAiEAzrh/+a8v\ngYQXQMT3R6ftT3RdJ22tVtMP29dU/oZMahU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAd+P0nlVRcNmSp1yg6eoOu8gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RhNzA1NGUtNDg0Yi00YjY4LTljODAtMTEwM2VlNWNjYTUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDg5NTY1MzgtZTRiNC00MTg3LTliZDMtNDgyNjgxNzdi\nZmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESfwA5F4Wq44ImnTlluuvp4zk\nJhHP02DpwnCnJGqOO/VjSH7pO2HS/XFvkvvV1q7Pjr6ApUgdwMkPk2AP60S7qKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgU77bXfnxYvItnS70TcW+dtuVw0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC9SsXw\n9aWU3W0PsBLHq/3y7uaeTI75SBTbBDg+mY1tUQIgR/ED4qLCenGj4eWJOthLbYWx\naqvmq5eHx7pfyY+6a/A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2821", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2821` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAcYo7wQ3YvShEh60MeVd1stnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzNWZmZjBhLTU4Y2ItNGM0Yi1iZDYzLTkzMDJmY2M0MjQxZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAwOWUxNzItZTRi\nMS00MGQ1LTllNjktODQzOTRhOWI2NjY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE2jN1ush9ek37wDV8cKlNjKeTX11oAbyjhFi1FfC8AC/+lWoj8ptcdrNlw1C\n0o1do4+WvpTH62/IK/PaeQXqeqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpndtEqQFKOXjm0mldrA4q216rtQwHwYDVR0j\nBBgwFoAUEFoC2V5BzfXV3WnT2ja/qE+4dL4wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQCbGKjIZjW30eNq1W43gaaC6pG0wGx76EiABvlLzRC3DAIgcnFG52vcNp/gzk9R\nt8nfCi2rqet+iwAVbFqao2ltY34=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcjfik4xrxnsBvd+5Yt/lEuXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzVmZmYwYS01OGNiLTRjNGItYmQ2My05MzAyZmNjNDI0MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVFi4f6KOAFUB24WPKdyVwiXDepGymZmjPg7Y+8Q3+Dr6U\nHmURA5FHw9stz0pItLKBs3G3GfFhzoRMwDTe4IOTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEFoC2V5BzfXV3WnT2ja/qE+4\ndL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKQPE/J9yfwXv7Dv9vFeQkk1XbgTgclX2chuxoXt5/elAiEAqYhoh58q\nc2ShVQT6nwy7LQcZzQvLtQXvQ9wrViPI4XU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXkMJl4iUlhK6dxCtHU6hviXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAwOWUxNzItZTRiMS00MGQ1LTllNjktODQzOTRhOWI2NjY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQzOTk3NTEtNTM1My00Y2Q5LTg5NDgtNDJiYmVhOGI1\nYjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEskbfifIxBSIoOB5Y4ls6iw9W\nvQWr9tQYxQKQaojR3HH10ZOqXVDijywsRPq+Ave10pzhibb/1hRYFXWzl4HkeKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpndtEqQFKOXjm0mldrA4q216rtQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCrHu64\nlYuy5gBrorAE4sSQbdMvOAflIGQj1baaC2NnMwIgZQLoVnjqdJbrO24GzArJsjMj\npOh13xsx3XT/Te5czoM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2822", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2822` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYhtLo83Vp3FA+FLcQEZA6jhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiYWU1MmY3LTkxODktNDZkMy04OWIwLTcwZWVmODcxMjQ0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY3ZWI0ZTEtN2Nk\nYy00ZWY5LWIwZjAtMjZlNDljNTEzYjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsAvDiQWxsKGcdYFD8+zSye5Q9/3OiijmgzSOt01uNFxD4MXP+D5CBD9piYKG\nj6dsCRvTl52AvS247i4c6hYRgaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2CF2pgxTY+eilOBgMseWGv8r+XYwHwYDVR0j\nBBgwFoAUN5vykRN/54YC2yuo6QeKh/qb9PkwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDvfH9QHwYCBPSXR3v7rhCeZfEIlY2V48VNsFd4hpUgcAIg\nEAu9yPj6dCsWW2ErCeNbaoJJAVudMnRr2TRk8QsPcuQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdv4KakdP3jnO8AFzzt5cFRnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmFlNTJmNy05MTg5LTQ2ZDMtODliMC03MGVlZjg3MTI0NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZ30QoJDRbwEO0Trk4i4JG/6ediW05PLJlyGBqsVOsim50\ngYLWC8+cDJz+DMh49t+4AxgQxXBzgxmoqtIRn89Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN5vykRN/54YC2yuo6QeKh/qb\n9PkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMRBA8Dgbckm02DpBZwzXBP2HWJPEVfwbf4K8RiTXQULAiEA5Y3aX+GO\nTn+HM2a+Kqm2KlzLESBRcvGPveSr55EA7pU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXhRiZhpFPvHt/kP98SfY2VxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY3ZWI0ZTEtN2NkYy00ZWY5LWIwZjAtMjZlNDljNTEzYjM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDA2YzllNjMtNGRkMi00NjVlLWE2M2UtNzAyMjRiOTE0\nYWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETs09S6M/I7yM3IeBM9Ql0Ui9\ng6bN6pKhpqRFTl1gAZ9Zm0bskTxypt1OTkXkYPxB5epyVw7ZaJZlNknftWnW1aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2CF2pgxTY+eilOBgMseWGv8r+XYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDEZTgC5\n853tz79FXYMdkKWus+iqcBmfCLMRlIeK+EGgAiAuez8/bg+VBZT3m+kFNtOayUNS\nyxV2a9xcsA3/ainrxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2823", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2823` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAciOw002TzyIttZHUC4KDdKZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkN2I0YTYwLWJkYTQtNGI2My04ZWVjLTEyZDUwZTBiMDM5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTIzY2NhMzQtM2Rh\nMS00YjA3LTkwMjItNDA5NTU5MDdkZDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4QlI5tJt7uUhmLGWZdgquDf8uL4PwN14uNmiuBL416vazXzPK75JkmpAkSF+\nTuvL9Ine3dGQ1CVf+GdJOtZ1HaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT+sWtvJ+0LxsEJuM/XqwQ5ARh+wwHwYDVR0j\nBBgwFoAUqSa5V26UmTomI76mc8t7nPR2KHowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIG4XUzFmKKJ90fh4zvuLXyqECqycMXs34FQG/j7eEAMVAiEA\nw+sXLxnqnSvDHZmhQtimlyPqFMyHk7m1FrpCYWiqhW8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbKYU5vVsANNW96uH6Bv6RH6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDdiNGE2MC1iZGE0LTRiNjMtOGVlYy0xMmQ1MGUwYjAzOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQQdNd+s5+srlzNPrAi3oDRtYVl8G/Pv9aAe8EEECc6fZm\nLpiXPKY+KB4zfDh3vdFNP3cNanB0H4F0P6dMMnlSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqSa5V26UmTomI76mc8t7nPR2\nKHowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOPCebPDIEataO57EA60VVc6132oA54VZfVBFaOVaTgYAiEArTyeXYsY\n9kwwmB9qR04L0RS8x7UmBsux061SsX9e/lA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARS2CMBPyj8WafBqU2//ulYDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTIzY2NhMzQtM2RhMS00YjA3LTkwMjItNDA5NTU5MDdkZDBkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDY4ZTIyMjUtMWIxMy00MWU2LTkxNzMtNDA2NDk2NWY1\nMzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0du+nz1yd8OhMQWs7+53EHc8\nklN8Abjmu/0in+XblXYZfYZwSL6dWg34WopPg1WADSPvab/9/e9RO4QVcmoxyKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT+sWtvJ+0LxsEJuM/XqwQ5ARh+wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCvsXKy\nUkDW72u+4288kFKHkfYoh6G4mG/L6nh60imZeAIgawQ+uHaTf62BN2mLPrAauftT\n+wEEAxdRjeOVFtaxwqQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2824", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2824` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASLwxpip4WmZwFfcDdPTAITRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NGRkN2IyLTExYjgtNDE4OC1iZDRlLWM1ZGVhOTgzOTMzYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg3ZTkxNGQtZGRi\nYS00NGZjLTliMjAtNWFmODgzZTY5ZTA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5TlEB5VUZJokos1i3Cc42nXlKWVJi7QK1ayJGEVbhjJAqzy9Ql8VaTp314HX\nz7ARo11+D4MAnZQr/kxjlWSW3aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFemEObfvD8Cb9M30wkOF734MPeIwHwYDVR0j\nBBgwFoAUKCmkMRZpDsUaGlH64b/TxB94dGowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCoJx90u23j\nzVObAcJ9Ds0gcoQgfCZgK9oOP/J+6cESuwIgQ1NdpreGa6jIY0Lp7VFEmLKCBuJs\nvYZBfka7/N5SjYE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZoxGxUvHiVJwiUJVFFZ2hR0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTRkZDdiMi0xMWI4LTQxODgtYmQ0ZS1jNWRlYTk4MzkzM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeglIR4UO1Su1a2eMXDZoICoKSW1bsvPaHf6y5wOevthMV\nliP2+ZTJ8lia+3Dk08IPtLgRXb2+4b++SA8U1PVYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKCmkMRZpDsUaGlH64b/TxB94\ndGowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKFuB2LzbSHDLzbgjzP5MG8Dgi6G9AlPeArYlgoUAWOMCIFacFITbW/HQ\noYoWGrL2f42G+WNCEFBIpdGQSoPNxLtH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQj7Vz3s9k3y33da9aAPj6fgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg3ZTkxNGQtZGRiYS00NGZjLTliMjAtNWFmODgzZTY5ZTA4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzY4MWYwZjgtNzZmNC00OTllLTk3MWEtNDYzOTVmNTg1\nNzgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESXbVwXcxiBV+w9iDtkTqrfMo\nTmZCbjVx1D7SRjdYeabmUrmvKw5wx8Lg4pJp+UtL4W8/neIM2gVvJcaJBFNDy6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFemEObfvD8Cb9M30wkOF734MPeIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCv8Rs5\nY3SM+Uimk7gS+ZOjECseMW+gQhPppRBslJjaowIgBaMuiRoU/DXTvGlI5T/fH7AV\ncKCMTm3fh1Ch3CU7s1g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2825", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2825` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAe3y6ejhGdIxU9wciVbeBTybMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMjhiOTU5LWEyMTYtNGU5OS04ZGEzLWMyNmY4ZjQ2OWRmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA4ZGYyOGYtY2Iw\nMy00NGZhLTk5NDgtY2ZhMTJiMjJiZjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM5WhF0m8NS9V8WqqkkbwoeVXR/L4TYO2YfCtkYUwEJ7yFDANBKbmZ3YO9NYc\nbroNJlBArD7M9gXhi88WXKim9KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsZEAwhDivaJCFQBh7hAxPOUeUGYwHwYDVR0j\nBBgwFoAUbg5CO2MktD1Y9+CO8z2JDib263QwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgKcWX0sMauDn8CfqP4r4ZtmK8XEYZwO5BVtRtTbZ+0G4CIAY6wZOaURJD\nttFqBC5I5nV+U6/D83MGWdklQpt4OuTB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR6V1OgjazeWkypSNyPir2MXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzI4Yjk1OS1hMjE2LTRlOTktOGRhMy1jMjZmOGY0NjlkZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8w1Js5Hf43kApyTui2ZJBmW1NsKm6QV8OspLm4b3fn9oy\n3LdFC1GIo8jYfNw8bwUbLehQyt1B/1B25UbvD1gjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbg5CO2MktD1Y9+CO8z2JDib2\n63QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJFtL7B8rHJDcM24OxlsQIendHnhWnGAzfA+VxDF+/CcAiEAhJ0tTG2s\nJP2gXs5tYTwHCRViKHioxaxVykOP4NnPxVc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVdqv0vkkmwdIxqHADxBVSjfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA4ZGYyOGYtY2IwMy00NGZhLTk5NDgtY2ZhMTJiMjJiZjUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmJlNjEzZWQtZjEwOS00M2FkLWE5ZDgtNDcyMTFiY2Uz\nY2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1GMy+23JfcCVq6UFWW+dT8uH\n/x4eXfTTv7y08dfXsSeEsSkKm6hlnrabsrCtEVblYDLaUJ5qKy4AD4Ua5Lx0wqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsZEAwhDivaJCFQBh7hAxPOUeUGYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBSwT0bC\n4rcYk90qC0+DsoGJNvycTmn8pU+KncqVxgRwAiAUvPiqAOZ3UFC5bMjMWJx5xp6c\ncDgCIS2DvmtWucMjRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2826", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2826` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISARADLU+9qGxuvDv5u+HVOvlnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MDI2OTMwLWY4ZjItNDAwNS04MWJjLTIyYmIzMWNkYTY0YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZiY2EwNmQtMTZh\nZi00MGNlLWFlNWYtNjUwMDJjZmViMWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpmY9/1IrnU2P77ywmGYJKWgc4l22yox50wDDFsseZv0BAILuSea9Sacdqbpd\nUQRyZzamAki869E9C94951eWJKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXNLzOlfYFTbHYDNS8jTMbl/GkdYwHwYDVR0j\nBBgwFoAUrHMve11Z/F3vJNQpz+Cs5rkvZaAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgZuZasxlzzq2Ks00bjPV6j0SblgYXZT6V9QiuvmbIPtMCIBXrhZ3u7dch\nofgKPJ2gdftFXzI2bi8/msqTJiNnSsvE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcTaPkEiDyIvaxJ9bh40zXnlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODAyNjkzMC1mOGYyLTQwMDUtODFiYy0yMmJiMzFjZGE2NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqnvmzhSlQuoa1p1UkgbOFxin4zd/Tz7dFuOOF4LxIeSyv\n17n9E5Gr+3SG5g+TJOCEth4B2YEUAZIFn/Inz2hMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrHMve11Z/F3vJNQpz+Cs5rkv\nZaAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJNTy6Hqw1P1ILWt4BMXyjZhgK/DppDVBxCIqxLsqtbOAiEAiugdqnWG\nP4c+Q32QHeUsMm9iHn4telmYjZqTDdzkQeo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASN8p+z+5KmbayZdHgDSdgCoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZiY2EwNmQtMTZhZi00MGNlLWFlNWYtNjUwMDJjZmViMWQ4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjRiNTk1MGItMzY0MC00MzY4LTkwYjUtZDU5NTYzMzFk\nNzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETmvAErZ0u+yhW7yeRh85LNX/\nCRJFRZCGBXaAMck2Yd4cmMFBYgxiAP/dMStqhOgHwYyeJI62DHzBo6kDFZlMIaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXNLzOlfYFTbHYDNS8jTMbl/GkdYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD9QVBP\ntVdCIbm5lIN7Eo3MqdXGdkpj/zm+lrKsUcO4AAIhANhAjtOvMwNE2Dmgunoc9fed\nCUwa79jlBAurrvHeDgud\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2827", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2827` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAUAUukWe2XoaRMh2qJF/2ui+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyNmM1ZDUyLWU1MzktNDc0ZC1iYjY2LWE1OTA3NTIzYWQwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmMyNjhjODAtODhm\nNS00NGNjLTgwMTMtNDY1YTUwM2YxNzMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiLqT6UL/UTgYy18Ro87U345ZFbzt40aPNYwrnNKl3MWaj6kYO+aYM/zbNtur\nrpfi7I2SPPalxwsOxUOyhAzxTqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+Su2khX9aVZ6Ka9HvszvwOTeu4wHwYDVR0j\nBBgwFoAUwWAwjd0nl5CG5boNi+AtbF1vfTAwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBShijecwiNFAESRJgoAepgKLpY7peA6CmChnMC2kVbaAiBIPkf+sb55\nINJ6P8sxLNDd1KebtVcTgTiqbw2dXzqCRg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARMNcGAuTm5jEa/RNqnmfuogMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjZjNWQ1Mi1lNTM5LTQ3NGQtYmI2Ni1hNTkwNzUyM2FkMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2sAaxQ7I33fQJJS7cgskznCk2U1f7qgF00iTCE+oLOq0y\nEFD/WoToWjEHe1bKGoHfeGiyjlkcGw7pZ7behcm5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwWAwjd0nl5CG5boNi+AtbF1v\nfTAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC09dhDBNI3tBvLITbtMfjZUq02Ewj7v9hCom2jW5gQ8CIDo0frLzhVKs\ny2znES2nX2kbJAHTcvrfID7m+Pn/wlNm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdfw/n0zCGIXnLFiXgZHJ8z9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmMyNjhjODAtODhmNS00NGNjLTgwMTMtNDY1YTUwM2YxNzMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmUxZTlmNWMtZTcyZi00MzU0LWFiNTAtMjFiMTZkYzEw\nM2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECW1zS1Y8PU3/1BLeFP41p6Li\n02JHvAj28J5NydH1JYrdfYJgICRIz23StKnz3TkaOG4bQzFcT+YdXZzd7MfJK6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUl+Su2khX9aVZ6Ka9HvszvwOTeu4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCINXph\nXZY8NzBrnMp+CCyi6geG/t3Qj/hRzuU3QTHwLAIgBtYwhDjY3uEP/NSiKzhoS3/i\nSW2OU2UggLCuw4A3pOs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2828", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2828` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAd64UWYTfmjQaauK4hriqmkzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiZjRmMTQ5LTQxY2QtNDdlNy1hNTI0LTFlYTIwZDMzMWM2MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMzZWYyMTktMDli\nZi00MDBhLTgxODAtNjQxMDlhODBkYTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzOJilakeII46/uHykAfrn6bhIXvIjJEwHL6OIbo5oCaPLPnY1km2oTV/1tzj\nalJ8OgZtPy16quejAJev93YmEKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNOJNOtQuduiaSzXzI/nlfB3lW2IwHwYDVR0j\nBBgwFoAU8lVNcVhgBgQzz7T/wFSg1JLFlPowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIAa4ixDTbdLivhahZvuzK7aqDfpEfSiKu4pikrMj\nul/HAiEAi6Pi/JKDO2jERHsxU1wvWCO5DyivPMkUB+WFtNI3C28=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcxpz2Yjth08bKz3eZNlkqzGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmY0ZjE0OS00MWNkLTQ3ZTctYTUyNC0xZWEyMGQzMzFjNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQN83ebXAQfBSmlRkMYhLt9nQ+q9DACATJHAjIk8EQ2pcWC\n6rMy4Qs2dYL3HdmuZaCJ/23DYmq2WFp/+38ddbC/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8lVNcVhgBgQzz7T/wFSg1JLF\nlPowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMjlRSjOUSqehF7eyW2tNGr2kDbhGyhqhRF7iu82LOuaAiEA9bmNDXcr\n6hiyn9LMkIyZnHLSjYAkz7pT7vK0M5Di4cU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXnEKY47v0n0zvX7IPtrQ6D+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMzZWYyMTktMDliZi00MDBhLTgxODAtNjQxMDlhODBkYTQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQyYWFiMjQtZmFlMi00ZjdkLWEwMGItZjE2ZmY3YjYz\nMGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcO89BL4Ew9PVkp6Wrz968B0V\nVgGSkbMnQkjZR4sY4Nn62JKaFt6hvtyTR+ZBUx+b3Wiqv8I6ZMi7gg4rbjuneqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNOJNOtQuduiaSzXzI/nlfB3lW2IwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBNbpCgl\npXstfraFSsXXiahu7Kq4JKRMGWBNvQiv1Du0AiEAlCKGl+sa+FyUc++fxziW6yf1\n1PBssVTm0tnCFfz+2Ag=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2829", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2829` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAb9F8o7Uw3ZipKCTfyS9cIleMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5ZjRlYjI4LWM0NGMtNDZiZC1hNDEwLTVmZmI1NGQyM2VhMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzU3YWVmNzEtZDIz\nOC00NjkxLWE5ZDAtMjcxNDU1NTlkY2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE74t8PU1qU4+wx5yoTEReaBiSK0BRksGIZqcHtYOm9Yn6BHN6ZD2vvQvbJmNP\nBdbNPNLR9FUxBb7F+RTFU4Wg5qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvEmMvGci3fUpc/b5cf6zW1IRLoAwHwYDVR0j\nBBgwFoAUWwjybyYnYt254rm5MZ6TEAeHIj4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDckPNEI/l7sXPyxDbWeQb6dfIU5iq1Cinj7vS9\nSCACCAIhAOXVopHZZVbvT+gc8N2+AF+xwHsCFLTXnbbiJ4MHyZ9F\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaNbgs/lX8Mq4nJ65ECTbYsPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWY0ZWIyOC1jNDRjLTQ2YmQtYTQxMC01ZmZiNTRkMjNlYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6Cv5lU0DqLZNgQg+5ZQZReQQoxeV2XbkqDJL5ZPDA3c1F\nHkZyrgI/qw9ovJ0eBRMkR9bob0m9mylIuAfe2ymJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWwjybyYnYt254rm5MZ6TEAeH\nIj4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKHGFr3Pq5g+cinQLnQowR9aZrPrLFJuYk59E9UfdQecCIQCorW4FkLxR\nktGa5XaUf/ZXmnZvgOfx6SwpMRKx7aqsLQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXfWVieHStc+4GicjL9o9COBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzU3YWVmNzEtZDIzOC00NjkxLWE5ZDAtMjcxNDU1NTlkY2ZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ4NWIwZjctNmVlYy00YTYxLTg3YWItNTVmOGMzYzBh\nYWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZYz14MjeJ4ZVphnL2jcBFDsd\n+W8rpMf6clE9VEqNyxINhfAcfJ8BzekxZ4dZWE1J0w4+jGp4nwZWUeNSE0fA6aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvEmMvGci3fUpc/b5cf6zW1IRLoAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCID671tKk\nzblBx5GpvK4r91PMYLt5GzCIZS97qPi714GEAiBDV4LuYCLHrViKclg8hOEoVCjU\n5bJZ5nEO/rH3WnIK0A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2830", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2830` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISASThDvgKbKG+CmYkpBAkeA5CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjYjQ0MWRmLWY4OWEtNDMyZS05YjA4LWJiMDYwODBhZWY3ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U5NDMzYjUtNjhi\nYi00YjViLWFmYzAtMGZiOTRlZWNiMmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKarPRL8XbLhiO+NjvMkhQqQcbL2g+NKZTAZMmBEtv/PpL2+g7Kdk2KRx0pxW\nrJqz67pq5arYZXFaiIUTODAA5KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUti2zodZctO2m3OX58+Ql0WzTZOEwHwYDVR0j\nBBgwFoAUIgsy8xTlKPPuydDRneqGtIPomCUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIDxqc+4j//J+T4lSpBQ6ZKF5bHWNeuWiOr1c6kogCm0nAiAX\nsq8K/XnUugS9y829cu8b66E8CIhw+fQUru8nh1S9cg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWI6Km2drpTNqeZDR3xsT+hUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2I0NDFkZi1mODlhLTQzMmUtOWIwOC1iYjA2MDgwYWVmN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHznxz5Ez8j5lD2O0EunygWBrm/LLQPaF70umIMycr1OtQ\nTVqg2K1R7hFUI2pQmrWndmOV5bKrNOBEdafLcg2Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIgsy8xTlKPPuydDRneqGtIPo\nmCUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANPFs0s1bfsKgss3aB4kcJoeDJS2XwLxMnLKPcE4bMmoAiEAjbZElfAf\nZnqjs+1073KhT3WWNEntHnLCIkLgyUW/DXA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVYVfogMLQokw8UllHRA/DbyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U5NDMzYjUtNjhiYi00YjViLWFmYzAtMGZiOTRlZWNiMmEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDVjNjQ5ODgtNzBhNC00YWU0LThhYjctMTcxMDhiMDQ0\nOWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFRp8s1VQhU3RN9WVIzo8+rfZ\nwdal9UjvY3mNdEsTovOxdg6zzIGikAw1CqI3kXEYyty+4Zg+GWnPsWAbvnBUpKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUti2zodZctO2m3OX58+Ql0WzTZOEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDG2JY/\nP9bHW+kYGn7HAda1Oved+Bbz5DyIHg/sdEK/qwIgS2Ip4LgEoyxaYR1b3Nd9Uii4\nprRhu3/2T1pHfL3SjHE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2831", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2831` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAV+l9A2E+lmCt5HtStb/6HHGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3YmQ2NGQ5LTIzZTctNGZkMC04NmU1LWFiYjE0NzhmZDA0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY0NGRmMzYtZjdi\nYy00ZTdiLTgyZTMtOGI1ZTgzNmJlYzRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGVZpmPkRtJQtWPA3FlXoD8210I1I0sLHX4iPSqJQbFMJdGSFxZ1OdtOXkCd5\nzrqYUwbjMu6MNnpS6T8Wj3WLYqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrhsAkKz9dI3Z41TVNltSo0gEKqcwHwYDVR0j\nBBgwFoAUZO+LuFlE/Q76LEsGFmKAK+7EtD0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBgVF0FHi/fxRJQ3B3Ua8XGQNQtfgxZ8\nM6VlB+2BzriEAiA+aqb0+OyQVD6ZML9R9J498DmhKkQtdoPBINsag7pV0w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX1K/sSNGX5doyvqId5i9rCfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2JkNjRkOS0yM2U3LTRmZDAtODZlNS1hYmIxNDc4ZmQwNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3cbk9oxZ4iTduMBNwoxZpopGPHcQ92WMQMwYmWWE9JNfv\nt38iphhtzKLD4LFEnVoOdEIRUKzeanJpTYzoszd+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZO+LuFlE/Q76LEsGFmKAK+7E\ntD0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG61JB3FCeLnS1HYOyMo2xCOZASjgabk93iB7dx+vyW4CIGI+w3/GxQOR\nrZpzwhjHLN/u0ZZ7idzzU8QMhSrXQjIb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAb15VD0Eu6nNXHo4J0Jy6T2tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY0NGRmMzYtZjdiYy00ZTdiLTgyZTMtOGI1ZTgzNmJlYzRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWM4NWY0ZDEtMWFmYS00NWI5LThjZWMtOTg4YzQxMWQ0\nYzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4YTkc4fg3JQXUvHpaujSrTyf\n3A386sQsxBPXvG97cwHpRe31ldu9oK9VHeYkjPH+7xj0CvuAgutq74a2g5/bEqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrhsAkKz9dI3Z41TVNltSo0gEKqcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDVMDV9\nepz8SAdzJgvFjrmtXzq+rWOfcpgVG0LWeOjNuQIhAJH8HbKfMTPQaG3PD7cc/7w8\nvoDD9ZAa5UaLCDN1nK9p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2832", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2832` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISARzWhWe8m3AWqGYG1thfva5GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0ODk4MDBkLWIxNzUtNDliYy05OGRkLTQyMGUxNGNhMGI4MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM0YmFjNTItYzEw\nNS00OTUyLWIwMjgtNmYyZDlmM2RkYzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERBkbozjbW+BchwsTF3+05JSxez3TjpfcR862E6MtMSE1OnSQLqUkdDp9PSYQ\nki6j3eAmFSy7MWVd4bQnQ4RbAqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFcyElJMTOzQKsLjgnNw9LMgQ4R4wHwYDVR0j\nBBgwFoAUG+SNofVFcbBuaBO4Yi74vM5jkUYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCv3zkdtolvaV2Dr+jYYHtS/AH76H1G\nRNCXSanbDAnf4wIgNJ7QgkhYq6fsNhK5Lch1d1H5XaVqvcPTbZTdw+DSarc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARRVlz5wKuIWL2NhccyKASqmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDg5ODAwZC1iMTc1LTQ5YmMtOThkZC00MjBlMTRjYTBiODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShGsHHgP5JFIfUSzByMqlhHJkyHaXEtp2iLASpeSaqjQzV\nqZC/tZUQb0AWaxh21HNNNovKtb2HUq5kvmP0r4kJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG+SNofVFcbBuaBO4Yi74vM5j\nkUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE1719wf6vTwFOHbNFy1X/YnZfh4KSAtQfRboYg7Fd0wCIQDOONjuhdI9\n0LvepnaLPI04P9djxK1KUjUwG4seC9IZ4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISATQsM418JzXHct4f1yNTez4XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM0YmFjNTItYzEwNS00OTUyLWIwMjgtNmYyZDlmM2RkYzVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjI1NzljOTUtY2M1Ny00ODFiLTk4NWYtMjRhYmQ3NmNh\nYWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcHEsjn9PS9j/pfQUQ5kayV9K\nAsX7nRkbMk3+G0yLDSC4bBVkjJh9CcSqWJlYDzRCe1LpSJvdR7T6UWqg3boZL6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFcyElJMTOzQKsLjgnNw9LMgQ4R4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDlEbQB\nkivLW5WmShlTDoMKwBmd/5eDWwM4eg0ysI9ySQIhAKqfD0D3X+ptFoOuOCBx0jr7\nWElDNip8bDZy1GC8qkML\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2833", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2833` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZwXm/xwlBPIhyC7UbWN3bUfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1M2Y3MTI4LTdhM2EtNDMyZi1hYjYzLTMyYWQ4YmYyYTA1YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY4OGVmODktODE1\nOC00YjhhLTgzNGMtNWIzZDQzNmI4Yzc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN+Kf+Ff+ajuLTiFpOmjEMMhGaFCedvPpzdvnC1G4z+VdeidTEZg/x41saHpo\npzyYGOaK7EYposyrDctKsv65SKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcecB8IwpUX26Tw8QBfvnvdtlc2wwHwYDVR0j\nBBgwFoAUzq06s7Skv0mst1tk1UHyRd/+KPYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGLsLVzSUQDf\nXpo4aDqLl35/1xk0nOaqFihvshdcya5NAiBhjcYO2xbxh3okEDGYrSDads+OAXqq\ng7h5pte+9ohvYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ30iMXkY/MbqJxvPpk+HRfDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTNmNzEyOC03YTNhLTQzMmYtYWI2My0zMmFkOGJmMmEwNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQg7p8ctf/z91zjeTQalXwG/6VrUkgeVvNEMkrAFH/JTn6h\no6D3e06XJYZO+jts8Z9Q+89KdtGIhsHvtSgHd7Ufo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzq06s7Skv0mst1tk1UHyRd/+\nKPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCrE314mS1I0Gz5Em6OQWNLpMMtwN245l01iX9GUwtLACIHd2NTPGGeZb\n+ILkxlIJB2My+T3ltumYaLgIrNsUZkcu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUhE8GeUB4x6+vM7vC0SEOlmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY4OGVmODktODE1OC00YjhhLTgzNGMtNWIzZDQzNmI4Yzc1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGM2MGFlYjEtMWIyNS00ZDcwLTgwMTAtYWNjZGM2OTEy\nYWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdB8wclyHcTBj/yZ3a90Dp5eR\nyuz4SX2qGra+4+ZjkeABSB+a3QJ30hDVKQMyVlpnqpC3ygn9xOPmPoKwKahdCqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcecB8IwpUX26Tw8QBfvnvdtlc2wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFdxNyoi\ni2ajntjb8HlObWjX6EWyJHe67+UxkLibgpQIAiEAoBRpWz5KLr/lX4l1uOSCM6+M\nBvNdVPUHE20Z0XVi4AE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2834", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2834` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQsVC4Fe7jLyj4rfb/98r6CNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2ZGVhNmM5LWYzYTgtNGQ0MS1hOWZjLWJiOWIxZTQ5NTE2NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTAyMDVhZmItODEx\nMy00MjQwLWFjOWMtMzM1YWQ2NmRiMGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJje/fMZdTqV+1V9djkAlqkGXL/HqWnsyRI5zjwQcTJDzZLMlTcex3MRT5aQi\nsu0b+FZNzUbAKn02MgLI8k4IvqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD9iThrA9/36pPQtGfnek8ySK+L4wHwYDVR0j\nBBgwFoAUVpEcQ+BCCtCoh0+36pnFEwRAxo0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJB0sS7HF28e1oIzsr9XDUqZp/5eC4pg1vCBunTpghmxAiEAp2QU94q+\nJTtzO0ZUQr30GFvkeQrzHWWwOSW56fO+4n4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd9AeAe+olbGqW30PAZVRN+uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNmRlYTZjOS1mM2E4LTRkNDEtYTlmYy1iYjliMWU0OTUxNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1aSdqrP7qXEUYHGPatVqQhcSlsLxYVcNSavMY4J+68mHs\nTa325L0v0RrO10QDt7yS9lSo+j9nrnsx8oJyFruUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVpEcQ+BCCtCoh0+36pnFEwRA\nxo0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLGMjRyQL7lMEfYPTQdVjDexLFvMi1Fa9aQY/CNjTCLwCIQCgTq8iCtI3\n9dl0+8aL9hUAnYC3FK4SVlIb577LbaOf+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdBgkVb+CM/+JQTUNRWd6GDFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTAyMDVhZmItODExMy00MjQwLWFjOWMtMzM1YWQ2NmRiMGIyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjk4ZmJhYmItMzM5MC00NGNlLThmNTMtODk0ZTMyOWEz\nOWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFS13dSYlD6L1EC+aLsjTZhKU\nSLUARopmF8b91o+BOB9sPinog837Jsg8UNV6m5BnPYVmIbvwbhDHwkArP+cyBqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUD9iThrA9/36pPQtGfnek8ySK+L4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDn9Zon\ndQ56a87vg/ileYfiU7N3R41oJIpreKRX3aMUCQIgc8EbFGBd+6/9oa2Bed7AYB/Y\nN4/ZuDeHhhK1GuWSe3I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2835", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2835` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATp9zuIaCZYFfXarDS2eleofMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0YzExNTEyLTUxYzMtNDEwYi1iYzFmLTBiOTEwNmIxYjEyNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA1N2YxMjctNzQx\nYS00ZmIyLWJkNmYtN2U2ODE1N2FhMjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYhc2S0oape0Fk9bUpaGVvroZEeVSKdzmm2gzKR0PrSfepgpSN5c6m9x+WlkO\nc7qEhxKurE3o/ugrl3zRc0evX6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4xvuzfr6ma6G3X+oMM/fAmArsawwHwYDVR0j\nBBgwFoAUcT/2n0DsIbJfn9n4ESwa5hhB3q4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJVV2fFezDCjz0LfFMErt3R4jmpradVnZ0+YcwARPhUyAiArCZZyptm2\nVFQZ+c0iVtvSChd/e/IsTK6XDqFlaJ+iOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcsejI/v9Ykcru0nPH775KwiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGMxMTUxMi01MWMzLTQxMGItYmMxZi0wYjkxMDZiMWIxMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNRRgBY+DsuEm+fcBarLMVJruRYbY/YSpbgONBcRjc0y+T\nHsHV7G1Zz1WMVur+UGlAQtGLb93lbzZbKd3G7qXSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcT/2n0DsIbJfn9n4ESwa5hhB\n3q4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTkT0fECNsx5nJdAZ0hefI6hd0AH3yA9g0f8EwrkY3HwCIQC5KaWoGANx\nNByQUXJRZmmlgeAgzDB6+WylG+mKnSTcVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATKiu/c+2Ovm9WfdLKZcU+AFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA1N2YxMjctNzQxYS00ZmIyLWJkNmYtN2U2ODE1N2FhMjBlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGU4YTkyODktYzFiMS00YTRmLWI5MzEtOWViOTcwMjRl\nMmU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPYJkCQjgvnZfSdOOdcI1/xw/\ndsUfXxLPg1zn2cB1rzHJnZgevi3VbqcwpWm3uO7aU8K/eGHe6FxJdLeDqLclF6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4xvuzfr6ma6G3X+oMM/fAmArsawwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD9O9rg\nt7Agfo/ft+MpQ2oktZWQNP9cI0J/CA2pA6zg4wIgXM1SL/uuIYGYMkla0ED9lyxE\ndFQ3vyqx/okrOG+oPbY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2836", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2836` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAZeuRdYKUQF1qq5isM2Ncjh3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkNjY1ZWQ2LWY3MDktNGUyMi04NzMxLTg1ZjFhNjQzZWNlZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGEyMjAzNmMtOTgy\nZi00NjIxLTlhYjEtYzEzNGY3ZjRhM2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi3cYe9I+yjmMiEm2LzYdVRnUU+qoh1hQQ7dB7TNLA1Bjsh2NCaflZIPH9zos\nbiX15j5D2LL7VE1+Fn8YenyeVaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFkPnwAFJZslxsn7eyV2+W9pUPxwwHwYDVR0j\nBBgwFoAUfOXyaqu4JnfFlev9xQjEKO31y1EwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBzBCWVv/hPYNP0QeiH58HnPPUydjvlur9JFZt0wfhQqAiBAxwTgAPdH\na465fr66BQ3SxDHqi1fN2CHbgKcDDtp8VQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQlos42lc75PDIVGj69Mu8FAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDY2NWVkNi1mNzA5LTRlMjItODczMS04NWYxYTY0M2VjZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgzxRh6MwDZa69qBrG5XgcJwV8JMp0WBUF4x6nA+MJAfht\ntvwJUezlbdO+eKN6IIWhKJyKEHTKQZu3vR8KTQ7Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfOXyaqu4JnfFlev9xQjEKO31\ny1EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQb1CU/06+jHz35b3L/AANBPApHNFVUJxYr4SaJXxCZoCIHws02Dsvt5f\nkhH/T+5eYP2hCfb5ulkAqytr/CEiiMrl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXfzVfJ3c+Qdk6Uph2nnYTAiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGEyMjAzNmMtOTgyZi00NjIxLTlhYjEtYzEzNGY3ZjRhM2E5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjMxNTY1MTUtYWUwYy00YWE3LTllMjctNjU4YjRhNDhk\nNjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkGmlMXqQYrhbBrx8UMKOMsVS\nnwHWlrjnbK3c1JjE9uuGNZjkVpj4HsmSjARJ8VC70+2GjHUaXSfvZ2lA+mZn5KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFkPnwAFJZslxsn7eyV2+W9pUPxwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIExZ0u59\n84QAJbd3GgkDVABZfn12fKiQNWXzsqIJtvo+AiBqdY08o3KgOGY1h547bVmveE3b\nte6Yj0oXZkpJ0GtsrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2837", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2837` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISATcccjP8CkFTXH/l/8HNdOB0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNDc1MjMyLTIwYjktNDQyMi04ODUxLTE1MTczZjMzZjE2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjIzYzc5Y2ItODUy\nYy00NzVmLWFjZGMtNjY0Y2I1NzQ1ZjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7ay5JfJ+Gj+mFbEmJsa5nyDn0bP4RHbqhtmF+REYy0XvH+GK1WiMSVr0dmVv\nMjCEAkrwkgCJJetaxzudLPXvT6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD2nlFutWx/fh1Htlo5LcCXeU334wHwYDVR0j\nBBgwFoAUpt/fShVs/Lkieel5GNbCyFitCnkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICydt023o3WLJ0d3hlzmgZelVL39kf/oK79NXl5g\nnqt4AiAzLQcmRms1GkqbjmjYjhiFjNjxopK3+5KKU+39sxpHUg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeo0KHqEPNZ1p9dq5Q8cSICSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzQ3NTIzMi0yMGI5LTQ0MjItODg1MS0xNTE3M2YzM2YxNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnEtpDgCT2VYBi3H/+H+ttoH42NWIBddxGNY4rqWax7Ozx\naRoY1AAhX9S9+3s8XHqDTJrV2+1ykZjqcjgnFR2xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpt/fShVs/Lkieel5GNbCyFit\nCnkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZDCoeuQwFmDhIGrc0RoI+qTqIKUHnkdi4MO0jNo3Zo0CIQDxL1WoJbXJ\nqwloHvJB38oL2QiDbvh9uwaQduKOIgh77A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAcuVmORduERJNRaTElkzDWGiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjIzYzc5Y2ItODUyYy00NzVmLWFjZGMtNjY0Y2I1NzQ1ZjI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzBkMjAzZjYtMTVjNy00ZTg3LWEyYzAtZmM5Y2Q4MjJi\nMWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgZFzEeoNGD9LMn+B/kojzycS\noZ4ONLz597QIbJZDWSraot48bz1cw+YIjK2FU5TJb+Tw2KBLMo2htmkZsU8B5aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUD2nlFutWx/fh1Htlo5LcCXeU334wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDa7oPL\nFtzVGatLwIqy6newppVkRahSMe52fs5ePlJiyQIhAOb8colZ4Ty3cbl75tPZ4maF\nwkDISvFkcaspnObHIp8Z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2838", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2838` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUqfU0iq/eRQDWHil36s877VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0ZDg1MDU0LWQzNDYtNDNlNi05YzUyLTdiNDEwZmUwZjBkOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE3MTBkMTgtNmYw\nYi00MzY5LWE5ZGMtY2ZhMjI1ZjEyMDJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1Yo1DJxrghgtsMzn17nskHi7M9BwFa2ppFvbO//eywBVYXiMeEAIF24LuIdp\neg1tgQbo1SykTMVsie607DlgX6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3w3uNYvmIa8g4fewSfdmTg5Bi6gwHwYDVR0j\nBBgwFoAUyznoddKwWd7SmFwu3pjhCn0m650wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHBtfsjcmw18KYTTe2VMjA9VTKBkTwl8RG5pBETG\nnZMlAiEAv/JPhGkV7FeoSuFUhr+PId4aH/Lqx0+OvPHBtjhzS64=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV4aC65W7O7h9YyDAegP4Rf0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGQ4NTA1NC1kMzQ2LTQzZTYtOWM1Mi03YjQxMGZlMGYwZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQX7M03nnPEVsCgqtXGPqgVKrVtzQaKLS6EMHdMV22gElZi\ndHyVBnbH/HTT+FRPWaifl5pbc0tSunJfcsZdszdNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyznoddKwWd7SmFwu3pjhCn0m\n650wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANWeN9ZFePdzpkQJDXk+HgF2GQxNvmRxYQwtp9WF12GLAiEAyUBiEaDI\nPyC9a8cfAA/wOn0KyNJCDdQ1ZhM9+wGw6Z8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQtT67j8f7xuJe+SwIkR2H2hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE3MTBkMTgtNmYwYi00MzY5LWE5ZGMtY2ZhMjI1ZjEyMDJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjkwNzYxOGEtMzczZS00Mjc0LWI2MjEtMjA1NWRmNDk4\nY2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBs3NYLtMlKWlFc2ywzKaenwn\njPvdrUo7WFLr5Yt6N2nFZL/XsMu2zAnuIMNiPlFAx50EWJP75GIbo8BiCYef7qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3w3uNYvmIa8g4fewSfdmTg5Bi6gwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAEMe9hu\ng9HjaPVIkk5CyX0NcM4p0kBLJGzim87bVwHtAiAKPM8TLfOlyZ2YRPT29YtQHEte\nLTiruVsp7Ti00SvtoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2839", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2839` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAQDxoUmfLx29+1Ee8aUKZK5rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0OTFiYzAwLWZkYTUtNGIwOS1iNzYzLWEyZjkxZDkyMTFlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY1ODliZTQtYjY0\nOC00NWY3LThlOGYtZjljOTk3YTBhODg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd2sQvt8wL8O+8oVB9jQBvk+PTQ68J8SKhb2DfXQkaEQWdHAjuqE1696/DAnw\n9dj7KY8sPqocd7MpmZGEsqMyWaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjiCHIbp4AbqK7ZEHnXy6VWcYcBswHwYDVR0j\nBBgwFoAUAFpQt+ua7k2HQMiDlMlT/5pZ+ZMwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIBvu4e1M6uUc0srlW845OWL8GHffNssITAlZV7pI1vXDAiEA\n3/rDdJERNoL7DPiYG5QhDh3ExxCu/v1eRNvH9moCen4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeCnywspfw+vpvUS941u4bTIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDkxYmMwMC1mZGE1LTRiMDktYjc2My1hMmY5MWQ5MjExZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzywpmB4tZEWF9b5d5hKfZAG4hzXm5cVCLGDXR7zo/4e1R\no/hB4UxaaJLpjN8f7CupwPWG0rutfALaFlG6hzgLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAFpQt+ua7k2HQMiDlMlT/5pZ\n+ZMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMGySSgaqWkDM6ecckC2Sk1J9YqcX6x1EBnsBaeJtK9gCIDfXSMBod5ga\nOc+ecAs46i9vrWvWbHckhKyU2ynKLcSc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXBDC+od18d+eG4WBVK9MVLwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY1ODliZTQtYjY0OC00NWY3LThlOGYtZjljOTk3YTBhODg3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTk2MzI2ZjMtMmJjNi00ZWVkLThmNmQtODliNDk0NWZh\nYTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYtiWu+WT7q6Mb9AqR3M+CNJ0\nQv5EOW159GDrkNhBop75aNUxSuggSxSLbGiyXAJPTkp6fwS9iNCH9hkmHo8qyaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjiCHIbp4AbqK7ZEHnXy6VWcYcBswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCID/prI7j\n2/GYVigRYqj85Zlm6xELYuQ9klfawmJBiWZsAiBCKyYSdffNuoihO/MQIieu8jif\njpUs1IBf/Ak/86c2sg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2840", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2840` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAaZrqluKBi7uJgbErE7sEDO1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NDJjMWU5LTBlYjctNDcyMS1hNGNmLWJmNWM4ZGU3OWRhYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc3M2MyZTItM2U4\nMS00ZGY2LTg5NTMtNTZhYTg5MTg0MWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFTVpaO8XErI8UBWeHd/RVBLq8icwgjnTVabW1Wzj58fXLIJimtSPg77wDF7r\nYQSJS/MQHtI8Eqoxb9fyjLSgBaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwSonYrlBoMgjphG/kcVmptPGo5EwHwYDVR0j\nBBgwFoAUttXOl9vjHeE+lK3jrSFouhOZpp4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCRRYJW1lTmtU8UYCpUvUMEzVOGwf16\nec5VOjzVIBUJGAIhANODTa86JwXwgkGuRUSaz8H7oaSc7wlaanumUxCEW4uf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbv8Vhpk/u9LgPLYHyDxR26nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTQyYzFlOS0wZWI3LTQ3MjEtYTRjZi1iZjVjOGRlNzlkYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIuItOBt2CiVOZLzDdDrFxkWJ99/W/SaAny2KN0EFbjVdP\norH+fAirzxo1VzAqgXjCeHuYTILu2upFFbCidj3Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUttXOl9vjHeE+lK3jrSFouhOZ\npp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhaOZKjYjsg5CTCmqb7OcYYA3l+eV249CBLn0EyBoa8AiEA7Q0Oz6z3\n+4XG69dCvgJXHVF1km7S1xbLc316VmYexv0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUOhFM10TFfQ9Llf+WBjeoD+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc3M2MyZTItM2U4MS00ZGY2LTg5NTMtNTZhYTg5MTg0MWZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTU5ZTlkYmUtY2I1Yi00Y2NkLThjMTUtM2ZkOGI2NmYw\nOTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER35JXvDmCvIV6QKf4Ow4YSpP\nOcRoIgh9OAUX0pIu83LSRknmh6jQ4HgQSzzSYhepWvFfqkv5+ap9FkXeBRpVh6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwSonYrlBoMgjphG/kcVmptPGo5EwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGnULMH3\nukdl0EB/R1uRznLmnmCWH/tFEzRRY+dySlbqAiEAjyBKN6V+DiYOnTWugJdh74KJ\nPstGQ9yXMZ8/7d5RzPE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2841", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2841` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQXrfrxPEAAPBafjXPZgxbmYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1ZDdmMzE1LWQ2MmYtNGM4Yi05OWQ0LTYwY2ZiNmJiYzllZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY3MDc4YzYtNzM1\nYS00NGU2LWI3ZTEtMzNlMzdiODZkNDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECyNqu0yfYBZ80CirSf8khX39uO0vNRJN80h25VenVTAQCSQSLFsf65WE6pLw\n+fF2wNs3pSuFD+bjxY+aiwycIKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfpjnfmj3YMahPr5jmyx23IpaNKAwHwYDVR0j\nBBgwFoAUyhm1YmYqo94A19FUGmca4STff50wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDDf4qJqfR1k33L9zya84tuaIKtIBWN\nYfSoUyeh2EuboAIgTafaOkEJ1RuPC4U6qX4ZrNcOW8LqlC8N2YZ6XJxKPIc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaR0XrQCUuUnLfvuZVoXcuLwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNWQ3ZjMxNS1kNjJmLTRjOGItOTlkNC02MGNmYjZiYmM5ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBPbnziialtZIdeTwllU+m009hBGZWITmD7U2rGa0PCNvC\n1wwIoPUpFpp6A18kFE1s1C8nYOjtTp+D4qF+dtR0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyhm1YmYqo94A19FUGmca4STf\nf50wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMXIIxEhL+3i0W7ehKXYbG/leCBZkTVxwMOrbL9BTNoVAiEAk/n4vzRx\n/U2LSI6fDvATiJuFC2MtaVI1QobqyFAbciU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVZctFHdy4U+lTy6zj+TbIrtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY3MDc4YzYtNzM1YS00NGU2LWI3ZTEtMzNlMzdiODZkNDU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDBiMjg3YTAtYWU3NC00Y2UxLTg2MGYtNWE1NDkzMThk\nOTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+me+OMh4ZSs0oXEuFzq215wJ\nyWVzs9RipeHLqDXCASGVS6mFO1TevPBAHs8hobAtOV7s44qwVEGlMmLb4VyW6qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfpjnfmj3YMahPr5jmyx23IpaNKAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICkdpx35\nP3jL0vjhzQFB9Fqra7N31buwp0mfqV0pFUG6AiAu/aXmOvqoF+ADFvb7mq5zc/Ia\nWkkdxBp5vXqZS9ALuQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2842", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2842` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQeND9s9PczY56Hz2X+K+IYFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyOTQ3NDAwLWJjNGMtNGM1Ni1hOWRhLTI3NmI0MzY3ZWM0MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTViOGE0NGItMGMx\nZi00ZDZhLWE4NGMtYjRkNDNmM2RmNjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEULqLy4xoG9FBzoEYsG8fk8pA1nzXb3xe18iN7QFf5EfBXbC4OgBQ7uUTYutC\nc18i+ENuhSnf+Q09+Yl+dR6mj6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNkdBKxoOeNkxPiej0KgqJg1RQrLMB8GA1UdIwQY\nMBaAFJ76G2ijNHzfV4zDjCAf9jC3flwFMAoGCCqGSM49BAMCA0kAMEYCIQDp8GSN\nV5u0l0JWxCLJ1DW4BI4XuInLY36YnZ5R4i31qQIhAMvXNKahtNGX2sDV3mS8D4dZ\nxL1vNojR8q4la29r/dG2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATSd49HsHZNKcvhusrKHPOlPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjk0NzQwMC1iYzRjLTRjNTYtYTlkYS0yNzZiNDM2N2VjNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4FAaZe6T5c2G8Bw/n8ScSLmdWK9rUcxmoOVAVsrPkjKsZ\nuEbeCrOeKjnfmGQMbID48c9U90R6in3G/nYslRkjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnvobaKM0fN9XjMOMIB/2MLd+\nXAUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANAMKFgvsBtU5fGy19VJudsxGclhpOLtFHnLSfEbneE3AiEA+hoB/FwL\nS19wkAF67k27yrZJbO6Nx3YAqFVHh2ZoRcE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAS/m85V9k0IEnjw9As5vXXtCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTViOGE0NGItMGMxZi00ZDZhLWE4NGMtYjRkNDNmM2RmNjE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjk3ZDc0MzctZmU0ZC00NzlmLWJkNzktN2QzY2IzODU4\nNWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBzjJnHbhyCfPLUUoxDzNPjEQ\ne3uMB3yx9gSw0uPD9FmcshBUkK7NYYWlXDw/QLvYGc1K2wXrE5udFzJK1Ow6PqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2R0ErGg542TE+J6PQqComDVFCsswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICdmRLJy\nNQpimO4EHYNym3rFImh9PLRzTqDpKY3lyttVAiAjkNkrSGnLSEnSzrxd2c0oNax1\nJEaTCcgDGzTjJirWww==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2843", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2843` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASt6lSJV7rA6k/2G39ZqAMJvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NDBmODAzLTU2NGQtNDQ1ZS1hNWFmLTE5ZTM0MzJlMmZhNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I4MWZjNDMtNzg2\nMi00NjU4LWE2YmYtODJhNTE2ZWMyYTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUI3p9IcmkeCGz3aIbtei1gqQLSBv/zmsQFmKwWG1uWbboMZPcuZdcHd+rNoY\nwWYGVaKTxrMQ7vJ6AXptAPWWyqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCPOHfLp50R/KOEXcNdmzgAXaeR+MB8GA1UdIwQY\nMBaAFId0Hu7ZDtBIJg9syvJthWDBzCLHMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA4aDTRS6123l24Nc7wcf/gLjwfC+IuhUc\nqqg3gq9s9tsCIAY1Bx+Qqi3FySsGxFHKyeYZhFy91+tZmufPtM7x5Cw4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASopQpfbk/0eIOI47DrbS6fXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzQwZjgwMy01NjRkLTQ0NWUtYTVhZi0xOWUzNDMyZTJmYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzUyP6rIDt+oyCOTzPSYaLJcZd2tIO57jzfTdelzHvxWHT\nTJqWkz9gjKKN9afTp77Fo4REFjKC08mqiD7kaJPRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh3Qe7tkO0EgmD2zK8m2FYMHM\nIscwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV1SOqkuppprZcGZ1/8+m0VLENPE5xPq+34RiUBxJpuUCIQDpE6DMp7a+\n0wcYsLQF4oDIdWrADt1xOHw1iYBFnaqSrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAR7MkyEmIU9o7W6K0WSlXQBQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I4MWZjNDMtNzg2Mi00NjU4LWE2YmYtODJhNTE2ZWMyYTAxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTZmODdlNTQtYTJmNC00NjcyLWE0ODgtZTVlNzJjZGRm\nMmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEU2KYxw5SCdIZYLP0Nh0svNCj\ne2HpRfSLLT7yeoYu3BfcT/hrTLXx5V68WrWPwxCw0mo4VSil923fCaqBdMsroKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUI84d8unnRH8o4Rdw12bOABdp5H4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIEu3DYIm\nH3c7yBP2lqBTvByFHsD7D7HfE0rUNakIj/mgAiBppYBnhv4Tayx8DBfHrEu+Z474\nCxwx5nhARePCWJCvfg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2844", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2844` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAeO48NZEOfXF98GxhTbndyQrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkZDNkZGRkLTU3NWItNGIwYy04ZTE3LTI4OTBlMDI1ZTNjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2EyNTE0NjQtOTJi\nMS00NjU2LThlYWQtNGJlZDQ3MWJmN2EzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFQjdWAsp8yDx3pVnaJ5Rn5QwJoSj9CwoFTRdGlqHfup6pJNPdpcEWAL/xS9w\n9hL3ZTsSGeP1H4VWOQSSds4rfKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJJg20Ynm+WejYFyzdLtjX1Lc+3OMB8GA1UdIwQY\nMBaAFEs6zw/cX96BkhQVWFY1cNB4AZuvMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA2pvJDoDBAcT+SLDCW5Rj4wjAla0m+ha1h\nTcR8BE+1ZQIhAMAhPP0nX5Mk30fi39UmSTQ4xu3N6hhqiNu7ztvBPXiX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARI61HsWm2uNAGOP+ViJF8mmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGQzZGRkZC01NzViLTRiMGMtOGUxNy0yODkwZTAyNWUzY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQedunZDR0rEYzHXXCJnfWbP4Jfou352zIU/Rucl2nCNAaW\nRRZbPXv66jRN7MdIQYMrcGd4YIOhY9x7ShOdXscHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSzrPD9xf3oGSFBVYVjVw0HgB\nm68wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGLYAC4jIKWBDOC6nhxcKltXE62U7FTTpZS/Ovk0UR4gCIQC4cixG3AWg\nai0Jv4pytNWSL67DZuQV1EYPcfFLm+cJIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAfQW54V50FQMIXpKp6yLi4IKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2EyNTE0NjQtOTJiMS00NjU2LThlYWQtNGJlZDQ3MWJmN2EzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzE5ZmVhNmItMWI3Mi00ODkxLThiMjAtNzc2ZDk2ZDQ5\nZWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYpsUf/LNXEstglAEGKe4tYp5\njTfd6OBdwvLBep2N6h0nSAhZXs9lfsciYzz6QowZZJVhZzmVvspKztfv5M68a6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkmDbRieb5Z6NgXLN0u2NfUtz7c4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDq7/02\nn2VLtixfFKsG1U25n8cOzJ/yXFgCCl/mmbK2WwIhAO0kDmIfZ6RHKqSKQDK8q+OH\njJZZcV4OLYR/qrxIsLfQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2845", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2845` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWrNg1N4KCECiBqaiBiRUCYGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5M2Q0ZjExLTEzNmEtNGY0OC05NDUxLWUzMzk1OWJkNGQ0YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM3NDZhZGEtY2My\nZi00MWVjLWI3MGUtOTZiNmEwOWE0ZmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5hJMolX5ct3VwO4ClwfYrw3EhpvSY+w3fBIAdJy6Z6JtXtVnmT6emLH4B2T2\nfyqAiLUfP1YnuYcdyXQY93TmFaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRXmUc1/ykhs3tvD/yvkv05vY4oCzAfBgNVHSME\nGDAWgBSNdlnpwtCBPWHdc9gDzG+w885B8jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC/WrHurjafCKW6FGfMqK1tz1qxczvX\ntMOE57bR94h66gIgdd+I8wSWNAKW0YCiqmAnMoIckHaBUZQBlZ6br5TceC4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVl4dZKeGu8hgzqZCemLgWc1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTNkNGYxMS0xMzZhLTRmNDgtOTQ1MS1lMzM5NTliZDRkNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATusQeKOPrc3poUaUYzzMuNf6h9O3wz6zXt6YzBe3S7bG04\n6qBF5UDidU+FMOHn7TYhILsjm4HXpe5r1tFq5av5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjXZZ6cLQgT1h3XPYA8xvsPPO\nQfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALt82wvUzB+MuUh92crCooKgerNSyjJT272XlxjFd9nPAiEAknorNA+P\nt1Po9wq0nX5i0ASHhTkeI0IbzJzM5tu93fw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAeP/7YwwHYovBkYu0xwkehJMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM3NDZhZGEtY2MyZi00MWVjLWI3MGUtOTZiNmEwOWE0ZmNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzcwYTAwYjEtMThiMS00NTgzLTkyOTItMmI3NDEzZmJj\nYmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYecNh7M2YTkOgxBtGewLXNeI\nTT4NriUJSNApuxQ6hv0P7BbZfx3zteQeRMtWi4tA53nt+BExV3CieH57APwrLaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV5lHNf8pIbN7bw/8r5L9Ob2OKAswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIH+yRx8n\n9mrPCHOrTauA1S+5ELF8Y7Q7idbZ3WOOY87aAiAfuYrMVCw70FpapgN/01a5IaQ3\nqHp4HccM/1QcQvlSpw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2846", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2846` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAcUGelG49dGzulHlu8re3X7mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhYjk0YzZmLTFiODEtNGMwZS1hMzdmLTIyOGJiMWUwNjVlMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg5NmJiZjQtZjM1\nMi00NzczLThlYzQtNzYwYzJlZTFlYzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwiFu4SoOb2w6SJCD3s8jPDNr0FWT0KfuR73KXCMYbgZwy0x1JEOyzjtlIaSB\nlv3Z2ShUEpgB8OnJyfgtK2hVNKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR9YgybpBZYea40rjjnu69IThVY0wHwYDVR0j\nBBgwFoAU8oLqqmiXpTk5ZyuMr1YbW0BaDX8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiA0k1aNngZUeHkU\nCshZMcIdU5q5sSVgncqKMjDkFymSJAIgJ+lnq1jwagsZwdKfUnwm8nNza93DqWQH\nHA23YL0zUso=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX7XxSIwFdqJhl74yU/wBc4IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWI5NGM2Zi0xYjgxLTRjMGUtYTM3Zi0yMjhiYjFlMDY1ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9ZzMI8JbgjRzSTABAFnf8j4RCDG9ARjYnH4vR4v1OWlh9\nPur8L+A2NyKbJn7lSWs0ugrISfxqQGNH3lTz7H8fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8oLqqmiXpTk5ZyuMr1YbW0Ba\nDX8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIUVc2xWTOY13aO7DfozeX0wZlgbWJJIp9EOy0vAZcFsCIQD9jh5yIlDL\norC4QIrLJC7fkY5qjjkRaeuveYNrM6FVJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAV3hSzqVkW+xWSN9shSpCAXSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg5NmJiZjQtZjM1Mi00NzczLThlYzQtNzYwYzJlZTFlYzIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDE1MDI2MDUtYTg1OC00NjJjLWJlZGEtYWFlYWFiNjRh\nOTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVa4SAJVFnIq0CF5E8LvvXE3f\nm4RwX1nzZSamrqbefTiZgjVvNW1FPQuCcj1KELyDD/Fk0bvyGve0+gJ6cxcJgaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUR9YgybpBZYea40rjjnu69IThVY0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDxUvOT\nx99z9IEAf1JM/ZqK5TLgFZFxRQHi5O4d2MfLEAIgEOuD+llm0kSJ0lTjbR0rWDk0\nOVgbpQzOxBirw0dQH9I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2847", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2847` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAX5cvQt4v4SagMRROD7K3su+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0YWViZDE3LWY2N2MtNDUyOC04MzAyLWQ2NWRiNTdiOTNmNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ4N2E3M2EtMmQy\nMy00ZGViLThhOGMtODg5NzY3MWIwMTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAj8MXEktz8o94skmyybLF3ho+ezBKojwwhwjr75zQ04fu6sdkjad7VAkrmbF\n9/koXtUH5flTc/HKOzQo0shbHqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9a0p3YiMFv9pu5vsDEYbi/NeldkwHwYDVR0j\nBBgwFoAUe+Lq7Riz2q3TvKoYQhBEtWUHjBIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAsK4/3RDj3Z2S\nkWyL2u0+BTGGGWy9RW7Vfy10VzhRSxcCIQDnuSKkDDlQtYXbK2rlEM/OAYXeSXsv\n0RxCbMX9uoTf9A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd/14Rp3ORdNPTB9wl4DaGVnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGFlYmQxNy1mNjdjLTQ1MjgtODMwMi1kNjVkYjU3YjkzZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATy3swpeg/PRR9tqkOTqVnKmscPcIVp9qOoJR++sk1uIqtI\nzOLZ4wXvDRcEnyH4DEUSfuKXtLS/uxA2JcvEVOtTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe+Lq7Riz2q3TvKoYQhBEtWUH\njBIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO3pw3lfS4o56OAjwAgMUkYfIZGObDdqvXbvYg2L3NyzAiEAlLXhgQW1\nFLZNWiRqake8RhSH7qsNm9CsnXrtHZLiq1o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfhPhmYSk661aIL/wKVrbTrxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ4N2E3M2EtMmQyMy00ZGViLThhOGMtODg5NzY3MWIwMTc0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTI4OWU1NmYtMDhmMy00ZDNlLWJmNDEtZDI4M2ViODk2\nMDMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdy11VQ/aeEH2NyJmxuTgCUOc\nvO8b3dHyobaqWQB3CfstRb3DDKp1JTcDpkQ3s9JubnWkx+/Ar/9NGHF6Ml2xs6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9a0p3YiMFv9pu5vsDEYbi/NeldkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIA2VD4Tt\n6TuVCMfD2zU1GcvxW57j5d5/1RxDS+46JN3FAiBvCFINpEcgz5IXDUwC8/LEE4SU\n17h/l1znkWn3mmm8nQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2848", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2848` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISASJWuImHZ/VLk29KtdCHXcyQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MzYyNTVkLTM4MTctNDI1YS1iZjc5LTJjY2U1MjUwMzQ1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE0MmYwMWYtZjBj\nNi00MzcyLTk5NjgtNzdjOWI4M2MwNmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERTX01VWmhPjPmN5G/Gkbr5tkur0PZZKU9elIoiaMsEQF1hVQ4P97DoedfYfu\npLsTrJ709wJEifHT6EbDPBdjZKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCg2+Tsxb0v5iurq8abE3FAloeQswHwYDVR0j\nBBgwFoAUjyKukwmjmRJ4AMV2g0dbPmq0RZgwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiB7lyE0UyNcYPkZ3P1UTuVm\ndVmnZR9j1v8rZMO8goAZwQIhAKF3uqM7/tTw3FIUMypf6phdbdyjpeqCtKWN1W+S\nopkn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARPdEFnyursjgMsdZEa6O/jWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzM2MjU1ZC0zODE3LTQyNWEtYmY3OS0yY2NlNTI1MDM0NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMMRySyKyAw9gMuOzAxYYxcMbv9nWKjD26tch2wi1tjwkX\njJTZzR5CqdJgiwlLnZldRvQHc8LM3soprKAx6sM8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjyKukwmjmRJ4AMV2g0dbPmq0\nRZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALy+D4tkoq8ntF8qJg2vpB8X4MP989MYNdEw0SjQiHILAiEAyBYivX/7\nJgyWZae+4H1roEJWq8rcIfqSPjqNUYUs//A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWTUxFIhBot6lC+qKeX2lyixMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE0MmYwMWYtZjBjNi00MzcyLTk5NjgtNzdjOWI4M2MwNmQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTNhMzAxOGEtMGNhMi00MGY4LWFkMjAtMTQ0NjA5ODhl\nZjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEARCiMu8bzCH/J2XuVEKlsxiv\nbIklQhZ+PrWJ0NqZunzvE0a/ZrAIpIpXsXI8jo0BHZgc+lPTQbeZjDKDnlhp0KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCg2+Tsxb0v5iurq8abE3FAloeQswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCI+n4T\nrKMBf42H8DAucwokyUbvB6yCskyzz6c1EwXwOgIga3BSyXWUAimOmuqINhb6qcEm\nIB74l25EUuTZxalhS+c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2849", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2849` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAaoYokUTsSr3N1GPpPOpQVWGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzYzAxZWFhLTBmNmEtNGQxZC04ZTNmLTM0MTRiZTI1YmYxNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZjYjllM2MtMzAw\nYy00OThhLTliNDEtMDE0NDYzYzc1OGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWEPwixmMew4t1MB7sPUSC4hPbqziiU1nfe0kzz/qtKCA2kEpdAa6N/4GNLEU\n+qzxfFtF5JBJMqyaZOuW87nYyKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE38HC3j4jxE8SV0LDjSdYQHKQJkwHwYDVR0j\nBBgwFoAUENvLXriHCr9obskKuBX7dHQ7RlMwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiA92K7c\n+zj708xwKs/wCD05u1kEghTgNij2E9csyY5HxAIgTLj7x6FbeBq9LypLzw/E8Z5e\nGddkbWFLmMk5Fl2rOOg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY3fybzvE+y4OyqxmBWaj6SfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2MwMWVhYS0wZjZhLTRkMWQtOGUzZi0zNDE0YmUyNWJmMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/W5bOz3sqe9787dvXW5x6vasH67V8qDc+0zpE8sGt1k1G\n5Wmm+X7B5pfw4/Ou+W+YQO9uhT1qhQXVeTeAeDXHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUENvLXriHCr9obskKuBX7dHQ7\nRlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNjeAsLqYbEWYOLV5k+rssJz+GLoyam9vtG0z9VX4fTACIF2Cn9kz20Pu\nJUMQarLB7KBeLnjXoKiHCh7TFg2ycMnp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXji/2X/DjwzpinE2II+sVdjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZjYjllM2MtMzAwYy00OThhLTliNDEtMDE0NDYzYzc1OGE3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjEwZjQ4Y2EtMjRiMi00NmZiLWEyYzItY2ZmNGE0MGEz\nYzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESYol3N4ZhRaIU4geXHH+wZuG\n6DdceWYXzPU4IebMJndHv73/i5y0Z6CR0TSt9Ff6czmT/WOQiAZWN6Wtmn78QKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE38HC3j4jxE8SV0LDjSdYQHKQJkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAakgVcF\nlp/hoqXzeFPcatVNc0NkxwIewETC29otfCpKAiEA6z3wkEOlL93Z4XhOC0YUJXPd\nhHQH8s6EV2CaN7wWu2k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2850", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2850` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAY/wY0/8xcDv3WCqrxPn04zUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzN2NlZjYyLTM0ZWMtNDkyNi04M2I3LTFhNDg1NzMyYTAyNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk0ZGZmMTEtNTZm\nYi00MTI1LWIwMWEtOTI5NjE4M2RjZDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENt2JRPmT0kSQHSWYMRxvE1vMD85BV+AoAuX2fJVTlQUnF/w/Df0cHhF1eGyr\no7AN36jDuzZHXGcIKJwIFXuDZqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuI2MJiPcH8uRu4ksUaXXFMj/0EAwHwYDVR0j\nBBgwFoAU4CXFb3LsHvYJvhwe7SmMwRU12WEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAP/YeE\nqMmpEj3MOxxs475XrG6vRzvhw/9l9gme2MNALgIhAMBRJhSzw90WWrvm0gNXbRoA\nj7sy9D9E8J3q009POY3F\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaSD+AoUakT6cAZf9PxJP67WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzdjZWY2Mi0zNGVjLTQ5MjYtODNiNy0xYTQ4NTczMmEwMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARF/GAy7nO2+FXSDuHZ7sf6LSMBA1k8gMQcAlxZJZRlOhei\nYJjhWwcj3iQ6m/vPPaICIWiVdgqGVIgS/jnMUju9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4CXFb3LsHvYJvhwe7SmMwRU1\n2WEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANEZGvqGmfmPViBGfiMzTwJRqn7BQvHoeGCFIHfTz6jJAiEAxFMqgU35\nJ3WKC17jE/J+MiG4INLL4daEpzf3vktxDak=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbe6NR3h0M+jsoN7qFfADVDSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk0ZGZmMTEtNTZmYi00MTI1LWIwMWEtOTI5NjE4M2RjZDA5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmY2OGFkZDItMzhkZi00NWM0LTkzM2EtMzRhMTY1Nzg1\nZGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtd4LG+pRKoGi4O5UXw5AeKAy\nSzhjgZk0MA5eL4S7leHUT+nwAQDuokwQwW+5KmjegNQziYBjW2zP/CWBQLiIaaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuI2MJiPcH8uRu4ksUaXXFMj/0EAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQC/Gkmc\ni5t7ZA0tMTnhoDbegCHPxaJzJcJGWq21QllqIgIgTLrewrWNvNXxdUIvr3AQ6cYV\nBar+hxSh0JC/R19ssaI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2851", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2851` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAV6qB6N0Mtw/7rBEjWP/PRBXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3MGY2NGVkLTM3M2ItNDRmNC05OWNlLTJjMWRmM2FlMWJkMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdlZjJjZjAtYzYz\nZi00ODBlLWIxYTEtYmQxM2MyMmExYzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES68ACAt3Fwm6aMcbaFJFBcRkVFUHGBKhTdiYmj28yyc2+yVTmz7h2NM1PAHi\niZ541b+1fTAHOSL89kw/TCLZV6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAv85rY42LZzVevYV+oKvslAXqtiMB8GA1UdIwQY\nMBaAFCOX23sW3l89pNLtGfEY9IyxIORpMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAmmJmhDBHMJT0lyLX0M8NGo7L9gbr5Shkg\n3yNXJ7KHggIhAKk0ZynUMF8wpL9DweeKrTEyQTslGXLUa40INxtLCbmv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARR/kfAHtUqC58WlF79ZzPgsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzBmNjRlZC0zNzNiLTQ0ZjQtOTljZS0yYzFkZjNhZTFiZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBe0g1yvA7VDVcb74wfqoXArOwcdxovFqmx/YVvx4DERkv\nqgqmWI05IJDPO02zw/IhnXhTZRE7h7h7fM3wBx0Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI5fbexbeXz2k0u0Z8Rj0jLEg\n5GkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAILk4Yk2ro43p+9pwE+rVnooUKj2ZNhZhrgBZAdLxxHXAiEAoVXXYJdO\n7DaIjwAePwalNwCtiLHVlpWIMMD7EGAdXuM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASIl+GW69KULEtdWSLoYP6WlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdlZjJjZjAtYzYzZi00ODBlLWIxYTEtYmQxM2MyMmExYzEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmIwMGMzMDYtZDMxOC00NTE5LWI3YjgtMjZkYmNhZGNl\nNjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjVYnA4hhZhsN4wIK+GQPnm0s\nrgpjrfWha7qIEM54doTOY1NUxbcbbZoa6HBLhA7dWpN5UenX8QMLkpWUwhYJTKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC/zmtjjYtnNV69hX6gq+yUBeq2IwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCID5L8iXg\n38JoF3LjGOWIXXy/Q+b4MN65GjQZY6l76DwiAiEAjs9c1CXJEMjK2O/R6l+MzntF\nl1a/0O5TOGnwYQd4Y1o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2852", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2852` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATuYMIz4wqktXQjyKC6zHjZZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjZTI5MmQwLTNhODgtNGY3NS05M2IwLTYwNTliODA3ZjRhNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU5Zjc5YWEtOGE4\nYS00Nzk3LThjNGItODUyNWEzZDc0ZDE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyj5d1h3pxAf99nOMATf3ggmfb++kQFx9j5fPPOJ5G+TIBmI63P/EYPunFAgM\nKgNSkVSJ9+/hoY+CsnI8ohO4NqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrID8cCUQeDL6pAGZ5ZsOhOoDzPkwHwYDVR0j\nBBgwFoAUvh/lklhXBJWL+upmprDhoUvnbW0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgS4STmxGxxzM0\nyTJ6+Qfi76VEjIhuLxXE4B4X5sziM9QCIQDawud9ZoSQIn5mPlUoXuYFAXagr/7c\npEnAKEJCZZnssA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW680Xaob8EwbMEGtjr7pf9PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2UyOTJkMC0zYTg4LTRmNzUtOTNiMC02MDU5YjgwN2Y0YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASImmyHjOnlt1liqGPhA4nw0MD9l8xpMtzH7g9sXFy1p1fh\n51QrtK05K6FMiCeOt/V3DzkA4EhGv+5WsOnRhpSvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvh/lklhXBJWL+upmprDhoUvn\nbW0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcUzU5V2u1NEaQXn55zoQwi7HZgbETUOmAcJOmYeaRSUCIANhD926KP5O\nBeJ4IziyHssecamC3E74pqCoxsKPBb2v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAbDJdNnBvwK5JDRxFpCnIoCcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU5Zjc5YWEtOGE4YS00Nzk3LThjNGItODUyNWEzZDc0ZDE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODNkNjYyNWUtZTc0MS00ZmY3LTlmOGUtODg1OTMxNDdj\nMWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuiCgy8kWWdig07Nn6u/X2jOu\nIyhOCiFGQBZs8g8COvdSSOTdIyfLhrAuNgqqMYMOHIHIbm+B8+znYM0hvtGGK6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrID8cCUQeDL6pAGZ5ZsOhOoDzPkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDpFX/e\nCwcBdcqy5VNA++htHKhht74RB2bH1Be27p3UowIhAK1diLUuCra0Poo0HhqIZxWD\ng39B4RGJF4xZuekpOnX2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2853", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2853` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeygAwIBAgISAbJaegRMa4HIIlxtZvW9TmZFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlZWQ5N2Y1LWRkMTgtNDllYy1hMTllLTU5OTRmN2UzYjMzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFiZmI1NzYtZTRj\nNy00NzQ2LWE4OTItNDNjMDIxYmE3MjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEETu1erbOCa8Sh0EKo73ySCcCI/YwLJa4ltD7CbBexMtPkt9lmAEX56t2f6DS\naisY39wSUkWDudNG2KXbaGT3EaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+cOGvWD4HE/r5Q2jMQc+8uziKUswHwYDVR0j\nBBgwFoAU7xbuQ4NKjvsYSu4zf2cK3UXudXIwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRgAwQwIfOMt04mCaF6eE\nGUQAbmRZwCwcP5/4JL5w5X9ej8Hb4AIgU8gR1m8dbO1kG7hiSD0sS9LN/vt4zsj1\npahJ+S9Nhqo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQh3jY93cJWjc3pJ0tnB6uVNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWVkOTdmNS1kZDE4LTQ5ZWMtYTE5ZS01OTk0ZjdlM2IzMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqis698kl/xn2KTNE7uWh8lLtSJTxPl+dNHOOubE7A8YDP\nJGtoYW8ElLrI0RaVDLzJ4xHLAwKav06pP5ayDLHto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7xbuQ4NKjvsYSu4zf2cK3UXu\ndXIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ1Lm3v2uUcBiT8Awst/ueE1hEHSRo8C1hjxtII8i2sgAiB3j9MNz3ec\nbI59OtbFGAnbvgkAlq4ibNzz9hj+egwpeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATgeVhAWbh2DZeO6ETJKMlAQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFiZmI1NzYtZTRjNy00NzQ2LWE4OTItNDNjMDIxYmE3MjdiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQ4MzkyN2EtMzUyYy00MDJhLTlmZmUtYzQyOTNiMjZl\nOTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElD3HFRjmt86FsuXF6vTJX/Yl\nsJ+7XHJ/IXWUBtKcRSEXdoi4fbm9ak+ZS0ub69Q/PXSWr5nVb7vWjt6w7bzcBqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+cOGvWD4HE/r5Q2jMQc+8uziKUswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCICO/5Frg\n47vBUZ1TQkDPrGtsk709/KNlzt9vomfN/jbwAiEAyHBI8swo4BVRQULDNYjFpf4Q\nWkSMACYVYBM4pNuCk4c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2854", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2854` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATi69sx37Dn/yortYw2F+er4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhZTk4MDdhLTUzYmMtNDViNS1hNzYwLWFhMzFmZmM2ZjAzMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM2ZGFhZTUtY2Vj\nZi00MWFkLTllYzQtMTFkZDI3Zjk1NDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwyM95AW0uJOiTRAD7/VPuGXkcCP8ts7gvvR8tCQ4CM1oA6K+jocOb6ECAj+g\nRgc16HTD/lkrAHH9py4cQyx2M6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm1jDTu4B1/15AUqeJ+3gGuuhnMYwHwYDVR0j\nBBgwFoAUtbm7YtayRIbBmdDSq/Jnn/YTFPYwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHEL4WqneBF7\n2z8NzMG9pD84CXiDomIshaZKRA7kxWtlAiEA/I9xcOr05tqOZcmwJwzZeJ3SD5ih\n6m/bQ4Fiw9b0gys=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWczO+aFfVvhUnDmca5COB2VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWU5ODA3YS01M2JjLTQ1YjUtYTc2MC1hYTMxZmZjNmYwMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4QhMya2dQzT0OI9bSqSdZ3YEd0i7dA2HywgT8WYGjpg+P\nc4wMMlkuNTnoRa4moQy8qjMSCRCjSroW7VoAzfbvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtbm7YtayRIbBmdDSq/Jnn/YT\nFPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHMzPAgfvDSHq8nMb2LvxOg390kMkldj7YioSffZfTwQCIASLVGcf3N72\nusGLNwVX5TfojnP1qgIoPpFP5rRpTqfo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAUDLyyOMgYRFLAllO0Cx3xqlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM2ZGFhZTUtY2VjZi00MWFkLTllYzQtMTFkZDI3Zjk1NDU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTlmMTM2MjEtZTI4Yi00MzU3LWJkNjUtYTU2MDA3ZGVm\nY2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEANDpZfrB1cNpnZC4J8SqV6ve\nwz27e45IlrAicFRy4R4+NCVqIoJs2faysu9cJ4L/LeJMXtpnkxzPV6QfUlPX9qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm1jDTu4B1/15AUqeJ+3gGuuhnMYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAzSvpMU\nabanshjqLSYJfYa1dMPnLfwSvpcfefCh9OiAAiAkMGiUwCy9wAurNv+WMXKwb3Vm\nlBoUo90swsB+2lu2DA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2855", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2855` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdVGroHE+zzdT8SEh6yzOhnhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhOTZkNDc4LWI2MzgtNDllNS05ZDk3LThiZTVhYWJjN2RkNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWEwZGU2MzYtNzQx\nZi00OTg1LWFkYjItYmFjM2ZjMjZiZjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPJJuvA80JnHwp1q1kKAT033jlZBznypHWuH1MoZNl9poAvj9RtG0VgcH1gvD\nheWeFB3Od4rUPNgHuG5xFs0sGKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpxpdtwJg4Ep8RyAtTriYOkN3fXowHwYDVR0j\nBBgwFoAUcPMcB/BmhX5hITlZXXvNDvWtGuUwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDAV19XXnnMZT+zoEDsqM9Y917sumdBWUen6yOZPkSEzAIhAParRmUTy+3d\nU495eb4N/XPwhO0P+M0OgTq/bvNizkXS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaqOFh07NdQNmW0gGWup2rZJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTk2ZDQ3OC1iNjM4LTQ5ZTUtOWQ5Ny04YmU1YWFiYzdkZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVOF5Q8WFdbXzSr3Qip5KPA/fkKuEEkMZYAtFujtnLCiHj\nKp9CjoStSlnatb1Ql0Atqn2M1USgM074Qu0J7srzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcPMcB/BmhX5hITlZXXvNDvWt\nGuUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAIKeYOBnYYk/VyGtZtASbMNt6ehN9KH7BqiF99VCJzyDAh93k4mcSMyA\nzwIQ1dn0wRch2befIGL8KMSRozGX01aL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAS5pgzut3zH8WJgQBaQzcnH0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWEwZGU2MzYtNzQxZi00OTg1LWFkYjItYmFjM2ZjMjZiZjRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGM5NTc3NTAtNTU1Zi00MDk0LWIwZGItNzE4ZDQ3NTZj\nNGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjl1IGxjgvL5ip7iaFDiljT88\nkI6GhD4G4GdL7+Ze7ZKOj2W1OwMgsONFk5vkyobLBvGR0A3yfZ70AGK2lIvhIKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpxpdtwJg4Ep8RyAtTriYOkN3fXowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAJ6DXS7\n1bzgRh29pWdIrzqnnsUetLL9UtrHFBVf0DzYAiB7r77UherYbWs/jxTjZiW+ldmx\nMKdS016dE6PxS3vDCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2856", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2856` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAfK7dncFc/PzV4v7mhqP8z/rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0M2Y5ZGQzLWVlNjQtNGIxYy1iMzdmLTZjMDM0ZDAxOWM2ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU1YmU3YTEtN2I0\nNS00MDFhLTljMmMtOWU4YmVkNzhkZjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5cT7I6aAiDXK4O75+Cq4tkWtUcN4y4/G2x/VtK+QXeRbM9RJY3e0okAT0nUC\ncE8RZu1syh45AKbg7wBCmI+0iqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/+/HH5S8mpxKb3rg0QFzeQwMb3swHwYDVR0j\nBBgwFoAUOqpvvsSdc1dKZUYKuPczqC7MJmIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDmvd3kfdk2+062B5brcWC05U/x4VFN0hUc5QriRTtawgIhANDZgk4Uss+e\nsG77bfIdx+4phCFs11fAy6/NynyGWiXn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXnKBwbhqI4qZz1LnYczDwOHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDNmOWRkMy1lZTY0LTRiMWMtYjM3Zi02YzAzNGQwMTljNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUHXQDVc1UFZX1Cf0nsYveR5lal+03S+8w1ry2F07oaP+w\naMu1mXUKJf8GObAWPaHOHFhy7FXdwY9nnfv+X1uWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOqpvvsSdc1dKZUYKuPczqC7M\nJmIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMFUGVFGmuXJCuCLfncMBUzIBGgD88FqHlTZFncGcjzlAiEA7cx/e68u\n6KF7cAQ5a7RaaGz4lJLgZ6qezKnm5ZOzszI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcSk/l6p7qF/6I+3Ygpfs0umMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU1YmU3YTEtN2I0NS00MDFhLTljMmMtOWU4YmVkNzhkZjg0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ZhOWI4YzAtZTQ1NS00ZDA0LTk4NDgtM2JiYTQ4ODA3\nZGQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoplpPYoRVGeHV4qOW2Oam/Ef\n7u0/AXmsV59v5j3zEBIin7mOZGQH/9O6VWRRmJR1x32LTLn8YKYEwxza+bpK6qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/+/HH5S8mpxKb3rg0QFzeQwMb3swIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDHSUEem\nLPuIFLhZKlflJNRmMRaA/9DjnIRlQTLgLBq+AiEA/Z41k0DUcf90HwjJ4ZuKE1lV\nqMjQwK7UdSBVLXs5v34=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2857", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2857` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAeWG9LbS1kC2OPGSHf+iWamGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3YzVmYjMxLWRhYjMtNDc3Ny04ZTQ1LTllNjI4YzhjOTYxZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjlkZDU5MGItNTVm\nNS00Y2FiLTg5NTUtNmE3YzdhYWZjMDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1kIC7l37gr5lOCd+7aNJGJyqVtRy0+1nrp9OOfaqzK5p8YQ3o8XgYhRlXH8f\nJc4ni5XE4UvICW2pFP1qoM9sXaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmsaJNMe6R4L2QBVmVwwJxMbQ0s8wHwYDVR0j\nBBgwFoAUa1dIBZ1aYSRnrM44RGC8+Iq3D3AwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICAx\np1MMHMB+1QEVnb2Ycgr0GB4G9COMl91uSPAt2g9qAiEA3DvJ/99Yx7gP7tFisVjN\nkac1Hnxr5Gy4PEJ4+iiL0ls=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV3XF6CXdY/Z4BDdLHlws1OwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2M1ZmIzMS1kYWIzLTQ3NzctOGU0NS05ZTYyOGM4Yzk2MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATD/OqhMSMY6ahmkceCooTJmZ8nC+xzk6v+rkPT3TU+pYoG\nZtCIORIIsIkjjjGEAAnCs39Y/UniqAJKkjEclg/0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa1dIBZ1aYSRnrM44RGC8+Iq3\nD3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcRJJNt7/Lzr71nAdtAQzMz16e71CH6dXJb+QSuX9orgCIB1HwhmZy4aa\nyxtKMigVglVDM3fEiQZ03TUty+QxQQDd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfX9V4EJKl3RWjk+GY3QrLruMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjlkZDU5MGItNTVmNS00Y2FiLTg5NTUtNmE3YzdhYWZjMDBjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjA3Y2VhYzItNGViZC00ZWM4LWI3MzYtOThiNzJmZjc1\nMDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgIMAvDLqQ+/rkpagLdymd/vs\nQQg+8Xi5el2aWpdSp/hsdUiXTTJy8+SyS8+NlFMQeNpc/SPBNShfeJ775sktY6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmsaJNMe6R4L2QBVmVwwJxMbQ0s8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDhC+SL\nF9ZJYgKUS3ch7kuBWy0emiLiCtA8Ew3ObnFV5QIgXsyHSl7NRiURup5I5DXSXwmg\n4Sr2HuYlUD0L83IPf6I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2858", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2858` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAaGPNSq6GG5lcqjEAx5cBxXNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2YmU0NTNjLWNlOWQtNDhkMi1iYWZlLWYwY2RmZGM2NDQ3MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjRkYWE1NjktYzc2\nNy00OGYzLTlhMmUtZDY4MmVmNGQ1MWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEigkLdV43JxYCux7fSmabZ0fpJD7ALsD39atEMjhPTCxES/KaLz5HdJsQA6w3\nOaAZXZ8LyO2NWuebm8pKv4YmU6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQSZvzyHv7A5HLakXQ3yYA3CVhxAwHwYDVR0j\nBBgwFoAU30DzSP7M/UC4iWBBNXusUVxTOS0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDm5XbyP/WKIG3EZ7LRsTpURs6nNrjQhX8h8CjgoZaWkQIga5W/\nMIwKndC4J/WYciTcjFPZqLPvBn3NlNFESGO87Kw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaq/rVhzi+WD81Vj2SMHqSjkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmJlNDUzYy1jZTlkLTQ4ZDItYmFmZS1mMGNkZmRjNjQ0NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgnYHLygQFkrACvfeJDGL6fQooyu+8vrBcyIC9sTlVF1Wc\nhs/eNGadYkdwJHMoRcFB6cZeszLYWx8TU31r9B8Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU30DzSP7M/UC4iWBBNXusUVxT\nOS0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOQ9Q6jKJC6wxzpK0NtHk60pBGzYac04SEJWY5EJy9F/AiBGlgPvseE2\nwUtLQSWhXYRyy/LHHGAN/f7h+v8IlEfndw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbN6WZdmS99EDpMpUcmKQJ6EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjRkYWE1NjktYzc2Ny00OGYzLTlhMmUtZDY4MmVmNGQ1MWE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzc1NjY1M2QtNDE4MC00NmNiLWEwY2UtZTQyYWQ5ODcy\nN2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBtMmaLae0kiTNzoWzR4qK2cr\nfEwZXeP7JSMTLUXNUnaMV5UNroJqy2n0BEIxgVmfAlLeFV+4yPUtxM510jqscaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQSZvzyHv7A5HLakXQ3yYA3CVhxAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAumkpwO\ninTsyFoycaOIhc6oaUIWQUz7LZScMEY73xzOAiEAyMWQOF282pp4AlsPlPPGW6dt\nOGdhGdXftsh+q5FZBz8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2859", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2859` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISASgFJxACgSi7gTIF1q3WUxuTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNDNjMzAwLWUxODMtNGJjNC1iOGQ4LWE4ZmQyMDZkZjczYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTE1NDk2MTctNmY4\nMy00NTM4LWJjNTEtZGMyMTg1ZDQyMmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ/LISwILu07EUfKrXzH1AevMNyFPBbhLFyZYTWsVJU8s8iWPx0nmQfXSjuEq\n+6LnZgPGBrCxW20iqFQ5a3pfsKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU76/5T9bF7CfMlRt40dWsXjjl6UAwHwYDVR0j\nBBgwFoAUpI9LrziY8e5MsQEC/4oiGlt2sHwwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCBYbSZLxZvDrMdq2XsQ71RCRIQeLJUbJ5amqjlrh3sBQIgOSBI\nMwAcV3z1jXkWkWjKkfMEjvofYlTIrAThYnPxeCU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdNpgAB/3g3LuZv93YzgdXbnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTQzYzMwMC1lMTgzLTRiYzQtYjhkOC1hOGZkMjA2ZGY3M2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2o8BQxBmI9cQNJ7DAmvr9Dx2avgi8CVXyiaslfTc3IfYz\ncbJD/ARsDs/ezLCIvDlnKJezIpQlcYEH+1gZlL1Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpI9LrziY8e5MsQEC/4oiGlt2\nsHwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALsvEafAJxO24F0J2TyGaEUxfSxdoC4VjIO4M0dH7ABNAiEA1Tga5mVy\n6/4bPUvZIFTLmSuBGvAw29Kxl4lA0w4fkXE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAexKSRqP+km7qbhy/XvhS6eMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTE1NDk2MTctNmY4My00NTM4LWJjNTEtZGMyMTg1ZDQyMmY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDAzYzUwMjMtNjc3OC00NDkyLTg4NDgtZmJlNjIzNzEw\nNjEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9zOe4qQr0SU0SDCTemPNxCel\nbaHQaumBnoDxZf9lqUWGhk1WNGVpXwuwHPevhzr6j7L1uA9S1n3URhJugeHdDaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU76/5T9bF7CfMlRt40dWsXjjl6UAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDV0lLk\nfMZM2W5R8kTv2u7qTWHMcigoVCCwtPY5Lvi0ygIhAIfc2cfwtAu/7j/xY+1DHt42\nkMVW2+8EcZmXyIE21QK1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2860", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2860` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAV1tCdIck7QdPPH5siDtq3OdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NjA2ZDQ2LTM4OGYtNGJmYy1iNmY0LTc2MGM3YWYwNWFhODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNmOTIxZTYtZTJj\nOS00OTljLWE2OTQtZDBjNTE1ZDQ0ODIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoNYtbCKK5HM333b1XJwgYZr4u82fE0PSYToXXzC2eUzJ2+Ws0zHxF+30Wnkl\nwZfU46qX1uSlZnFlp27c7AxbFqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPnEFmHhKBEFzNjjR1XjeOb+squeMB8GA1UdIwQY\nMBaAFA9pBrkSjNWn/5RLeYpLx2IEpEXIMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAuQjxULYW7ZlZk6746KSeqJqFhm18ehSs\nYfnKCl3SNbgCIHAV+eR0QpdFfUv8SfSFHemd6V9woW1ttLE0KjXrUWZq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe0+NNVnhZrlNAhK3cMzq+OYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjYwNmQ0Ni0zODhmLTRiZmMtYjZmNC03NjBjN2FmMDVhYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzGVRdynwEn9TXDumxVNhsYLy+7reULsB0gZpJJ5kzM5d/\n9vKHAzmvaS0NBPVt3rHcs2Bw0YNPWaVzKBFX/Xjro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD2kGuRKM1af/lEt5ikvHYgSk\nRcgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdUUChEf4vmpcBS/V3RcLTqsgRKkjfgdAqTu1noaViLMCIQDNs/D/gnnZ\nm//f1gdirYUENKHAUipN+L+/0wEail0/Tg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAUlEP838eouVKn8FwQkhn+6DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNmOTIxZTYtZTJjOS00OTljLWE2OTQtZDBjNTE1ZDQ0ODIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzQ1MjgzNjgtMDZkZS00MjdlLTgwMTgtYWUwMGY4NjQ0\nMjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk/CReHbPBJhE0UHmAGJ3mv7D\ns9cDTFjXGv6k8aL8J5AfhU8vcWq9tC++rZsY3BK4NfX6xFscQVbQfOndoLcZ4KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+cQWYeEoEQXM2ONHVeN45v6yq54wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICATgjfD\nVFVHfxH/jU6REYUBLda0XJtpR0NuUISWy87VAiA9u5khRBRhhphMehhs3/X/qs06\nE+9GeEyoSmoMtnub1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2861", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2861` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAe+EfE0TZTuheU0QGbe7LQxGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ODg1MDlhLTc4OTUtNDdkNS1hNTRjLTMyMzU3YTVmZDQ3ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU0MTBhMDEtMGI2\nZC00MjU1LTkzYzctMWM1OWQyMDI5OTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKGZH+OuMAeCqWXBAdNOjIb0ZcmvfJR77yfAePtwcJnriLngq16Ysy780th+k\nbAF5hZAqiRlFN0bzYoQX4LTIMqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUXbl9BtOu+91AmFONfm1yp073EUwHwYDVR0j\nBBgwFoAUS4ez+c3ZjPYCfQwv+QRFbvRqImAwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAK31yMuLFCZF\nsjBXOnazPNzAB45v/QB1FvtbFCzaIEjOAiBo3iVJB0UM0KRHGB2sQacbj23lx7zS\nyRe+2sulAJi5aw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATHI2UOwLUH8XRSMH9DDIZEuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDg4NTA5YS03ODk1LTQ3ZDUtYTU0Yy0zMjM1N2E1ZmQ0N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6HcJMXTztpqh1RWsMYdU5oq340f3L+lplF7JjJaaA8tLJ\nJTrYkHJ9cLxyAg2XQHmkF97eVS9B/6quDOpslfbso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS4ez+c3ZjPYCfQwv+QRFbvRq\nImAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLChgPxO/ia8sTYUP+cImXy4kpXbxZLMZJmlgwCYnY78CIC9xnoZF/k7l\n/hrZBteH41QObK++27uP0NItSMpXsAEE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAeUF/nyBphglUqU+BNUarDSJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU0MTBhMDEtMGI2ZC00MjU1LTkzYzctMWM1OWQyMDI5OTAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2FjOTllN2EtY2M3MC00YWExLTg1OWItMjEyMTc4Zjg0\nZGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESHXQW5hF7ysXD/5Yb1s6234W\nnkeh0qqG+op67GktXfci4ecb+oUuZQRmoE4vtxzm4iRJVDoLYKSM74VgSIq48qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUXbl9BtOu+91AmFONfm1yp073EUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDQ2XW2\npphUiLQeT14muiAB4lAuLSXv6lrLyCyg3mcMrwIhAL+KHB8I2v+YWJl8gLjcQev/\ntWorZx7EuLhlgHuNGfEM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2862", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2862` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISATBr4dsLMYWuClxD1Ti5w06rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZTUyNGExLWJjYTAtNGRlNy1hY2UzLWUyNGMzZGY1ZDdlOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE4YjBjMmYtNTgx\nOS00NDQzLThkYmYtNGE5YjMzZDhlMzk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETmBS5T2BPBeQRWNiC5b8mu13OAPFVi09WglUEokAVqTDP5fVOeNDks7s93ak\nA3uZvqrBnTgxFY3GBco5phnjdaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX09weUdI/3+xzCkUphXGwagZBtMwHwYDVR0j\nBBgwFoAUEqL2RltWACmnJixAdgCoPd/jtUQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgVp6AMXFVy9S4\nn+eKsiy9U7Dq1cyY1wvshQAVyJzw2+QCIFi9qhpEFsZU8G5gdMKBDv9huDWzWlnA\ncQli9u1kNADw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW7isn9f5ne2rmp+dFWZ5FkZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWU1MjRhMS1iY2EwLTRkZTctYWNlMy1lMjRjM2RmNWQ3ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6n9itoOOjvF88Oj3a6a1ZrkMUpjbqYT84pUTUnyWEFSUp\ni/fmT2MZ+nuFkoXQEfYU4tzRcygr3N2wTMkBOpIQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEqL2RltWACmnJixAdgCoPd/j\ntUQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIEQCmvRs7jkoEWGrRlJ7bz8R1nSd0BQ8j/0ce5/7vBPAiAzYA6XgejA\n/87IPG/+0hyRbARXCYXNQsIdJjhFRmuBSA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbk8DTmh9tm85hnQc9syG+kCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE4YjBjMmYtNTgxOS00NDQzLThkYmYtNGE5YjMzZDhlMzk2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDVmNmJjYmEtMGE2NC00ZjY3LWIzYmUtMzJkMzk0YjM0\nMWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgtKDu/vqYmd9cDcfCDuGUKyn\npyzi8HdFGPvamAWlqu95XzWBz1ODzi4Rn4gIRHcOUNNqWnEFMLRHSHts6qR7t6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUX09weUdI/3+xzCkUphXGwagZBtMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHVyOCxN\nyzN8z++1UvE7i1LCZwRK99g4h4oDD85vffEuAiEA3zGpheod8ig41SENwXdvzGfd\nzgNnxJD3XMF3s0JWSg8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2863", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2863` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZEkIiRAstC/8q4cVfTS6bpKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjODcyMmI4LWQxNTAtNGQ4Yi04YjIyLTM1YTU5ODFmODQ4NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ3NzAzNDAtN2E4\nMy00MTA5LThjZDUtOTkyY2RmOWZlODMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWJQ4UmC7XX6lf6RCFduhd02idJrBoo+bFR1OkGLzmx77oFIAv+8oFwg/b0ul\nh4+Bbd4Y7p13/yDKEq+0CdbnvaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGEgbWv5SAxTh5FOOa7cAU3n10e4wHwYDVR0j\nBBgwFoAUOyxjNLblmO13fRdpK+pAze175qUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBVayVjxi0Gn\ncpzEVnKJ70+CHjeGVxNE9X3OvseVmRJCAiEAxDWWfTFV2776cNQqRNywooq9HBuY\nVhGgJwfUjDuHZjk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd/FE62zcf7B4M1gtMPuTeD5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzg3MjJiOC1kMTUwLTRkOGItOGIyMi0zNWE1OTgxZjg0ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUInRH0zw4qJOMh7AllzyGwfJJUyp+76Z3pi3+yJZFWL4D\ntccOLWhIYTd/9RLw+qkyy7d5o3Ztl/7sMNYfLCj9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOyxjNLblmO13fRdpK+pAze17\n5qUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJGWwZZLT7sBfb6pWWB7eeZIYw26lwO2EINOVNC06zRnAiBV8oLPXEcB\nhVqXnI9K7QFWgXXHPZzPsnYQmAMNtSXknQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZgPzXt1R/9Tbef1+vTpJE4pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ3NzAzNDAtN2E4My00MTA5LThjZDUtOTkyY2RmOWZlODMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzFjYjliY2YtN2NjZC00ZGQ4LThiNGUtMDU5YmIyMmNh\nOGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8gzvwokN3gDGlEUHG0x4xSfp\nls+gNJY9D84BldY3wMI/hkkNzdiY+CBEhhtDcbItSFvh97faRCoiBiE4/Er/aqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGEgbWv5SAxTh5FOOa7cAU3n10e4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCP+BUt\nu0dq3qIQ0GcaM6zKH9rMbkDA+I9JG6rh3oJ3lQIgNnCZNzD+DjkoU2EQMJmYYCbD\nrZzEDwOLwlycxGsSa3k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2864", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2864` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWLLzd8Yg14U22yS3dvGVilVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiYzBlZjdiLTg3NzgtNGE5MS1iZGY0LWNhMDg2MTU2ZWI5MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQyOWI1MWUtYzQ4\nNC00ODBkLWIxYWEtYzRmMmQ0Y2NmYjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/43Dhvdz4J0d1/wM+OGqReZuD6L1LfIZw4Gc22F+e6vNMTCuQaLwrPZSP7e2\nAfiMQNFD+J5PUHLJJ2EvHlh/9aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU436rsg99roFBJaAUC9mgtKUoXOkwHwYDVR0j\nBBgwFoAUH1RG9bir6VBuZCmmnMrOwjH0KcowNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD58NGrljrQSfmMUf7O7w2S4/uJX7zQt+KxAzb88+/zyQIgNgu1IZWT5MZ3\noEkV1Ps7HKk//XpK9wAq67fgGWwjr+I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQx3/ztG6ZZTo/9WRC0t7UetMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmMwZWY3Yi04Nzc4LTRhOTEtYmRmNC1jYTA4NjE1NmViOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaOzOkkuCTw3JKu3gD1HPjBsbQoTKplKDC+TY0brkwLc1x\nQg54EzCmxV/mLWT4Tv3H0hf1BFvZ705qYngawpSDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH1RG9bir6VBuZCmmnMrOwjH0\nKcowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdkhqhOD8/ja4Dw/agMk/OCgK4y9HLP7J67t4ORySqO4CIQDlwk5A4A35\nokx1IfRWpNOCXCY1uodRpCo6ICLogo8TzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAa69sirdURDcFEBdGkoa96o/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQyOWI1MWUtYzQ4NC00ODBkLWIxYWEtYzRmMmQ0Y2NmYjVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWQwNmE3NGQtNDVkNi00N2UyLWFjMDgtMWUwNzg3NDBh\nMmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1wYyCqIJxrB3j2am3+Wn2PlC\nKorEKU8/+PG/b9RA0oZzYPiwpEXBKqWemNQa8thy1p/Zx4EpLIXAKU5Ju+yC8qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU436rsg99roFBJaAUC9mgtKUoXOkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQD7HXQx\nX7NynAXsSHjFbLnOXN6F/VyKNhyM/DSGaH5wmAIhALCrVFMGQdHmrMjgX15e1aE4\nuai5J4GIgDsGWwxCzacN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2865", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2865` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXE7XrzCyVkhMGXkz9g7UQklMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MGFiZWExLTkxNWItNGIyMC1hNDRmLWNlYzNiZDFhMTFjNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTYyYjcwZjMtZTU3\nMi00NDk4LTkwYWMtOWE5NmNkZmI4ZGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvQlNdfsVGNopyZDveCl7Rs0kkimKEhrpWTO5lxfsXQJ9tpcBKFbBqGaZgic2\nYnbHXi9aF+fDmP9V6KcFmvn536OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcfAlpdP3r/kUsQQRaXASMUJvrGMwHwYDVR0j\nBBgwFoAUZ4awDMTejNSAHxb8f8uX6mGrJuAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGLea+fjo/UOB6bfBCxC/NrMUe0AePT95nxuotletlyXAiEA4HazAMO4WXx9\n8uZUaONZ0r9VtUufWzyI3oDquYcwd3Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW86ePBIKcspucN1hIU3iONJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTBhYmVhMS05MTViLTRiMjAtYTQ0Zi1jZWMzYmQxYTExYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT53eYghSTI5gbGihU+r2pPu0z5feZb+t0pztMt2ShiZi0G\nizdX7EvtlBcu1qcJX9nOIPSoKPzsv+dHeLxvGF0ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ4awDMTejNSAHxb8f8uX6mGr\nJuAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNE9uaCV73DTJ8LMOibnxsXXM79WDavHOzbGKD1kDiMoCIH9dorsSrEwL\nKerrYObIeWFSMaOEAdM5TbHlVBXYVkDz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAd1RNceheUuw3eJJS3IVTSgwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTYyYjcwZjMtZTU3Mi00NDk4LTkwYWMtOWE5NmNkZmI4ZGJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTU0ZTBiYmItZTMwZC00OWFmLTgyMzMtMzNiMzk5ZjVi\nZTk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4yYNARalrSLEmuQ2E5f+2srm\neQr8ULfGyHTQGjmLyp5q3mirItZZbiNUV6M3GuTgFd4Gmzoaw+0mWTDXISscE6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcfAlpdP3r/kUsQQRaXASMUJvrGMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDi0XMC\nXjyrtbkdcDQ8CZrVmChIEARj2oatJ4/cNd0gyQIhAMG1HtZKsZmjoYGVMxQ32hVb\ncMh5AEXEdTox/mYluWbs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2866", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2866` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAX5J3Lf5t94w5AK6FM5bLYmxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwZWNlODVlLTEzYTktNGMwZi1hYWU0LWEyNjE2NjQ5MmM0YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTRlYzY3NjItMmM2\nOS00ZWFjLTgyNGItMjJmODY3OTEzOWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOAQPy9+W8MLhMN+fCxGuu2fCFFoUJ9wLn7P1q39E09ydg4rZLaC29JKo1mw4\nORzpVb0oBS2lQ9f8vcwwUIsC1qOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4osJ9njbBmt5uYgxXyLVC/MNajwwHwYDVR0j\nBBgwFoAUaLE0CHe2OUCuhg1W35yPNqdthcEwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDz\nRzBrVKoS/UjLblgz0MC4xr/M4EmdKw6pZ9APERuDcAIgWDPCD3psmuPnfMbk2vDI\nh+TQErm3OwPjEJtEVIbWi4A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZvdNJUUBVO4wdf9w1wqhtpzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGVjZTg1ZS0xM2E5LTRjMGYtYWFlNC1hMjYxNjY0OTJjNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQSolqTioWuWBo22gwJvFrYkMNfwo/4wd6qUyZ3bQn6Xxy\nOE131iJs6/KqnsXmMEvyv453u3y7E8MsFW45OAHko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaLE0CHe2OUCuhg1W35yPNqdt\nhcEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZuxwIUiO8fQTmrnLCt+WzR50Xqf35oLh2I8L5s95AgwCIQCK0b5BGByv\nSR7QEiM1e1EUT2jnmUzgGHLUYKoaT0Dz9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARmcGSQRptwdpj5f88oOa/n6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTRlYzY3NjItMmM2OS00ZWFjLTgyNGItMjJmODY3OTEzOWY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjhkNTY3OGUtZDZjNS00OGM1LWEwMTEtZjk2YjU5NWMx\nNGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDezEh62czbzeiguuZCYwasiB\n41wnG52rmtBuWCpfAbzm8ZyekaG7OYJSjqyeL5Zj7VYufchBE4fKe/tM4issj6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4osJ9njbBmt5uYgxXyLVC/MNajwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBzjvVGJ\nJQfl0Dr0pf5OFu5cknZcXJxW0YjTO49ztE9lAiEA5aKNXsWnsE3rYkhXCIZC67JJ\nH4rLdqmEfoX2eqoOfL4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2867", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2867` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAXdSPHNu9XbuxqkV2QNVFTd3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MDJlNTliLTRjYzUtNGM2My1iMTlkLWNjY2UxZTgwZDQ5YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JhNjk5MzUtMGZh\nNy00YmI2LWE0MDQtMzhlNDEzZWNkMGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELHAx+RvVR3XAOWidMATamUwRPFihaCBXRDczsk01Vbfd1hR2z/7k8zDNt5mi\nx6P3Xc9EosepcAGx35VOfmEJR6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNM20bBIPLGFMam2nmrrsKaFciFEwHwYDVR0j\nBBgwFoAUOR0kpmQmq7IbPfbh3rNa4XQvrOAwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCoMRYE9AjoI7jSt3GmdDwfjQfvDUKoTq8iyXOGeu9AVAIgfDeN\n0Y6CcxPAB5CpLnfCxsX7sEVdi1EBv6rs8KaPxUw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdhmn/h5C3TBepoB9cIcJMACMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDAyZTU5Yi00Y2M1LTRjNjMtYjE5ZC1jY2NlMWU4MGQ0OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ21VS4BLtrU8kEan4BndnofxHvuwcIf70C7Tz0eswlf2C4\nD0/ldqd5x6P0GA53Kb/G8/++lNaUKZMHHN9R2n1So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOR0kpmQmq7IbPfbh3rNa4XQv\nrOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALM9wrX43M6gvoIzK8hnnhMFU4ugM9eIRDFDdEi1hSrhAiAp1Ilj/rC4\noCwktWBWi8dinMS/XVtZ+zMiBYhAtTAIhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATBcs5oEXqq/xu5A6RVWc7WlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JhNjk5MzUtMGZhNy00YmI2LWE0MDQtMzhlNDEzZWNkMGRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDhjYWFhNGYtYWY5MS00NzY0LWIxYzYtZDQzNjA4Mzg1\nOTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK48NuySuQOM/n64+Ugh2CEFf\nj9FvZj353/G2BryC7DyvwGVI7vYE38cHOzBHd/aKZxcTE0YajsElpgRW29XdyKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNM20bBIPLGFMam2nmrrsKaFciFEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIB46p5pS\n1NLD5lvU1eqgCZzI7hT0uitv8vICdJvvz9nMAiEA2nef38Zlg6Svzsc0Yu2A78Le\nEBuP2snJtZFc4HRmpe4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2868", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2868` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAY1wLbx+C75NrmsOxDAcIQcGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjNTY0ZDc3LWIwYjktNDkzOC1iY2VjLTE4YTRiMzEzZTg4MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFiNzU2NDctOTM2\nOC00OWU4LWJlMmUtZGYxOTI1YWZkYzFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpyQHQYGrJE1ZO+A9NPD5LkWosyCZbvOv/TLLVtunO3Lz7ifla1X1xG9p5Vjk\nOjxbAWpfeXxpo1vTfQg68hqYaqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkKWHnKJmCgYMXAy0egmzpnxIg5AwHwYDVR0j\nBBgwFoAU8GsDfxeYFHbTy0rIbP5X2kxm/jkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBn+YZM6cfZQ09arnnxD+Z/MIERFtFcwJQ2ezyWRCWe3AiEAk44c\nG+UIq3P7CvSnEfpZftXuPClSl5RsowOkZgHKTyw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV/HBDl/RUjipp/wAzM1gL1/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzU2NGQ3Ny1iMGI5LTQ5MzgtYmNlYy0xOGE0YjMxM2U4ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPOo+t2ZOoGc9FiFaSIC/PDqmVF/nt+tmuY2btLs0J/OG/\nS3/H0/nbAXRmxcZF1xnH0ab1DT9LH1eUZCArHWNJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8GsDfxeYFHbTy0rIbP5X2kxm\n/jkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPm8OocC6rP36GXPWajXFQO8aLvMtu5Uvo4fb0S4cBpFAiATReeAP5ix\nCxixpKkhOH6iPHA/UqMczf02jQljd8SAuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWsqBbCvm38BeCLSBIOKAiqrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFiNzU2NDctOTM2OC00OWU4LWJlMmUtZGYxOTI1YWZkYzFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWRiNTM2MzEtMzg5Zi00MGUxLWFiNWItZmY3NjQxNTA0\nNjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECtGwuF2kQ8JH5f78avTtlUGo\nm2GGBPUxWxfRxe3MYQSg4rU5Sc12j+6CRpaFq0dnHkQsBXCAYJQYvkiZMMfEkaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkKWHnKJmCgYMXAy0egmzpnxIg5AwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCICJszjJg\nTVDd5YYbO148jkrW+E2UCvYpbdxmGFQYXWWSAiEA2SpkVlZ81b2Tb4hvpd+BhceI\nrvHiB5VyxrDl7hXJnZs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2869", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2869` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUMvcnykDfP25C2h/qICqFUPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmNjdiZWE5LWVjZWYtNGMzZS1iNWIzLWExMzYxZDc0NDg5NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc1MGFjZWUtYTM4\nNi00MmFhLWI1NDAtMjk1Nzc4MTlkMzMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgC1UitFHvHh6Twv9z2gQbHlnm4l3DTAFFxteozRyMGpN+C1ZdEKMt9Xw5FqI\nHzEwTSVB1T/4HhwkI0zJxvig8KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTnC0CpOEqIAAhqQU6M+Hl/6Gdd2jAfBgNVHSME\nGDAWgBSnocdvq72x3Qm+p5bTKSSd3Hr+AjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCkDjTszCWxV0Y/PXTZfG2Gm7BFinrU\nHNJym1ZHlXCfeAIgWvqCG70oj8MW16Sx5ijfOQGlzIx0l/SJJK49IBjVFwE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQIaNe2ndFFDDjv+tDqvgnu9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjY3YmVhOS1lY2VmLTRjM2UtYjViMy1hMTM2MWQ3NDQ4OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSBII+lq4U4KHTAGsPbLtD4VriokBE21cipiYngtrADlul\nXz6ub3oaIEGXtMhqgI12Kdn6rTA3dn4qw/I77KROo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp6HHb6u9sd0JvqeW0ykkndx6\n/gIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALl9CjZhTAAaRPODVrFCIADVmE6bCdT/cX0mVAQ/Pdx5AiEArb1YsqCk\ntBb7gqHHbG5hUtD2aPCN+XLc1rSbdTFSLSo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaqJJowSnsx0Oc0dmdkgPfYnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc1MGFjZWUtYTM4Ni00MmFhLWI1NDAtMjk1Nzc4MTlkMzMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTAwYWMwYWItYmI5NS00ZjZmLWJjMTItMmJhYTkyNWFi\nMTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErPskj0rtNhe159G1e1YOrJ9/\nAZMx2i9Ewo4n9Sp3EfXan8qj/6HamwAqa9R5ZFlzPRCkTqCptlU2agYUpHIsLaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5wtAqThKiAAIakFOjPh5f+hnXdowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIE70dTgM\nqzfUjnmp7ov+erzliLeRIW4DBTAWOmxVdymkAiEApK4yTgqvrHdxJnSveBHEV0Zb\nQDcn6M5Ekl3eKsrb4W0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2870", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2870` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAZknmopzOG650hR9XTrPJ7G1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxYTRiMTQzLWI5NzItNDViZS1hNDU1LTQ5NDRmNjAxYWU4ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNlNzg3OGQtNzE4\nMi00OTUyLWFiZTQtZGIzNWE4NjIwZTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECrzPyc2M/T462pvMoC9TOctDLVZRfEFVnDYLyLhy/TMSMTa1gFAnS+GBSadP\nmCwVtMLp9fOARMXwAcaSwLPGsqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZxggj+DF2CtaTmSISPQ6tCea2FkwHwYDVR0j\nBBgwFoAU9QnYVBOEIAdOJpVOe+kUWfZCkD4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDbP2EK/RnR\nc0hXjYSTZua0UT7jkUbTEsuGFSj4a7rV1QIhAJBOzpCDuAqrJtP+H3Nd39rhqCeX\n0qz747K/pYTU6z31\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbOuqjJWnHt24TvAIfcZqki4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWE0YjE0My1iOTcyLTQ1YmUtYTQ1NS00OTQ0ZjYwMWFlOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaSeHyFQ4sO7vPiA8mgf+/o7mxuAHjRKXcKvs/RBTV9p+e\nZgglW5j2TCW3t7I5o7pHGQ8IVcEOlrgvlkSExCp/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9QnYVBOEIAdOJpVOe+kUWfZC\nkD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYzvqrUTb7i7og5H8N1x1fhr8WU9E1fSYrDdJyzYy+McCIQCITiDpn881\nGEIU25cZ+mWYHuywUXsitnij2yXKjDUX6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARlUCMgNkDLagbW7Iz+QXkAAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNlNzg3OGQtNzE4Mi00OTUyLWFiZTQtZGIzNWE4NjIwZTA1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjc3NGNlMDUtNGRhNi00OTkzLWIyNmEtNTYzODQ4ZmRl\nN2QxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErKAon1dw2amVZm2Tf9CNUk1J\nb2qHrJcly6bpo86Hq3M0C+r76EDRehKgBBEr5Q+11xLDfT9sBuvwzxr/WwkTxqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZxggj+DF2CtaTmSISPQ6tCea2FkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFSYGGV2\nSb1/OmxRaLGm7hV6zcWR0iggyAKijSsdxMiVAiEA8qRKtzmRqQoiuxWGlhuoOy7b\nXxW9s7U6HB8bboXXBVM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2871", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2871` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWX/SMtv40O4YXUNKMI8d/5CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5M2Y4ZDAxLTI5ODUtNGJiMi04ZjRlLTEwN2E1MzZjZTRlODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFmNGE1MGUtOGY5\nYy00NzRhLWI1N2YtNDY2ODUxOTUzMzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE5xN3vjzcULE6boV5YT3DRMn1RJXjmqcZn1D4otfU5gP07Fm4Vvbqxhp54M8\nh7ET8oWFoRjBWsNV3ns7WqVg86OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU01QdXwKl1sF/hwYAn0r+bkzNuFowHwYDVR0j\nBBgwFoAUQ7PUPNXXDXGN6V2l/nffsalquCMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGiVvMeU4FDo\nUmzS8zzvMRXr4XovGcAqGCui/vkvVvRoAiB51ZHXXeA/YbaBBBPhkLgAFxN0eEEH\neUrJAefdDVbFIw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ6/KmqdrKhn74sa1L+lTjrGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTNmOGQwMS0yOTg1LTRiYjItOGY0ZS0xMDdhNTM2Y2U0ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyJPYiUvEQyeDOBJccy06tTxmS/D99NiapKlVe6k5fuHgM\nIxZS/BzW6QCBw5iBBU88Yv2UOR2cwHqWQMNsgwXYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ7PUPNXXDXGN6V2l/nffsalq\nuCMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM18A07zV86sDz5cHqwf66fRqHp7JVuJfjLFykXZQOygAiBJHl1zCAcz\nUW/3wvlSbQI/IuciRSAFMwtCPMf9XUdXCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAWyTtD6LjcQzhQ5YD9N/phj+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFmNGE1MGUtOGY5Yy00NzRhLWI1N2YtNDY2ODUxOTUzMzFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYThjNDg3NjUtNTk3Ny00YzJjLWE5OWYtZmEwYzYyZjBj\nY2M3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+Yza0DqkBgGuvhj+XABDIvfz\nohGmTWQov/ZOY74v/qgMGjr6NnwRMB1DUWVEvGLOMykVqae+LflOOSqAq3rikKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU01QdXwKl1sF/hwYAn0r+bkzNuFowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDlxgzb\n+5V5BtDF3o0XrR+2QyS33k9dT4qSwLy69iq80gIhALSnO8+NCMENKAwE8oleGl0k\n4cMIW0H4D80rmoW8n2+K\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2872", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2872` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAYOKSiXHHMU8qiAL4MXVfTKaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmNzA5MzhjLWQ0NzgtNGRhNy1iN2MyLTYyYmYxOTZmMmNiZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA4MWUzNjMtMDBh\nNi00NDE4LWEwYmQtNDczMGU1YjUxNTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8x+V1iv3MIZurK+v6XexWEi23GAleuYTsdaYFA7hnJJKwK+yYGH9o5A6l6Dg\nmbBeScTdWUsmv6w9kN/7rgw0dqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjc1iEHAFbXkoDE7yRuJy4sg4ReowHwYDVR0j\nBBgwFoAU9EBgC5jgCEGNPzg+i716eW2ieRswKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiB2RJHWE2sk\n+y7ZT6gbvLVEHEL3rcrvtdUTccIPf1KoqQIhAPqpf0NHXqDLK4MAUnkyeDxaLUAg\nsQJtsUAMcz+huFhN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR1DihbHEscpQO9woNsgR87xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjcwOTM4Yy1kNDc4LTRkYTctYjdjMi02MmJmMTk2ZjJjYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4eGhkgWmBRPT7qF8ePrX7QBA9IJllHnVuhtlKShcoZxug\ngmIQPiJIfkIdHgAqqP/juvkzaMF+rgvDnf+T3MY/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9EBgC5jgCEGNPzg+i716eW2i\neRswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM3C/k+xEdqp+qtMqJO4ZiutYdYpOckm3Jw+4D4iIN91AiEA5iMwBg/O\nLrF/l6ML2hvRdBn/iraNgifogv/rQeUw4Aw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAa9Fb3ylemy9fIJKX57f78U0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA4MWUzNjMtMDBhNi00NDE4LWEwYmQtNDczMGU1YjUxNTFkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzVlY2MyOTItYjhiYi00ZTc2LTg0NzItNmMzN2M3ZDI3\nZjEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMTB2TDQJt7RwcaxCMWPEDAJD\nXEfKrghLbVuPvqd0PsqtZQ/EOymHra/DbGmylam0XIo4eKv/zLIKGdKwogFmHaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjc1iEHAFbXkoDE7yRuJy4sg4ReowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFyvInV2\na+Kd/fDdkrwujtrCvGQ8PD0HZUFYfCKIUTc/AiEApa40cMOioW31joy927Uoqt9t\noSzAB4VqdLT1wBstmIo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2873", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2873` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAXaPARgE9zv2d3irHjnwyMIQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4OGM1YzFlLTkzOWQtNDQ2Ny1iZmJjLTFiZTY1MGRiYjRmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFlNDg1NzEtNjlm\nMS00NTM0LTkxZjgtOGYyYTRiZDdmNWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEThrr39YnByX8LY4H5EGhIJ39g8YFgcPWRNrNnrZ83KrXWgrVOvVhge80qxuq\nOdJyyQVkY14hvVp3gwRdw5Iz2qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJi5pWeGs7GrIZmGoWso4m/cNSW8wHwYDVR0j\nBBgwFoAUrV4+rg/b9e2wN2cisGa+nKp25BkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAww+yHhw37n9KydRwtgi5cZq191r6LAakAmojGCSr2TICIQD1F7xCKFE0\n0z0j0FVk0UWRYtm8vqnIz67+5ECShm3zzg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUB6MWj4uloe8UKjn/XcBfzuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODhjNWMxZS05MzlkLTQ0NjctYmZiYy0xYmU2NTBkYmI0ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZuY3BRIsb1BVwIWZfBLN3eqJt/LFo8hyBRd9ibMJp5ycL\n0VE67GzDdiCAzMKbVDUYGzeZ3J01paxVJs8Qj4K9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrV4+rg/b9e2wN2cisGa+nKp2\n5BkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOS5i3Zrpds3o7pukbwIZvfExj05BrXiXfT1XU3hHv4/AiEAyCI5kErS\nsBIZBcT+gT5bFN1YCzyIAlVZZfz/KIBVw0s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcDsl9F4p8KJdVoUU5u30+BhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFlNDg1NzEtNjlmMS00NTM0LTkxZjgtOGYyYTRiZDdmNWVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWVlYjIyNmEtOWM0NS00YzhmLWFmZDYtOTA1ZmQ0Y2M4\nNDQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3JIi8Y7kOyi+3M+fIq7z9PJR\n0eO+3hwMfYZne7KK5/Lz5mq4OKxBC6nX/wJ4bVpYUM7YNvLpUENAMfLH5abJNaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJi5pWeGs7GrIZmGoWso4m/cNSW8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCirUPF\ncLZCCJkfACUQxCNyyYD+8tmnw5COgsb8xypN0wIgYtjfxvvpavrTwefaSImcxE/y\nne+TT9jaSmGdt5blpi4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2874", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2874` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAU58qRHn/tYXOcqVbUwipherMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZGQ1OTE3LWU2NWItNDRhNC05NGQ3LWQ3NjdmZmMwYmY1YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2MyZGFkMDUtNTI1\nNS00N2IyLTg1M2YtM2RjM2YzNTUxMjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg+jwOFobGNfmWyrpRFfdF+tkgqYAdnge5AIk4NAwymFhQwFLvYZe0+0SGEPg\nzeiJNUNPzcU52atAXH/NitdL6KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6XRaOaGwkFK0/dod8NUy/JmskoYwHwYDVR0j\nBBgwFoAUOYy1r/ddiVaFWDsk+bJ05mcaDeAwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAbUTvFEKkUQWsxG06Hw0rPJM7YdTNccf28hQdR/bNdLAIhANPp2P3EymHg\n52IL5I8JYkmlmx1UAFexAZXI83a0kAOs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcmNwdv7Yh4GAZbjBoWbHP6nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGRkNTkxNy1lNjViLTQ0YTQtOTRkNy1kNzY3ZmZjMGJmNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQegoBsY9trEodgXIy9ZwxPyMp5GcBlQrZHBjX1nOPGM3+7\npHVE6IJC8SBTf6AgVXbIcWz27aYWlTyO7WJ/g8oQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOYy1r/ddiVaFWDsk+bJ05mca\nDeAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANnCa7RTLKZnxH4D4/RPwgcgV1WRNXtGgj+u+baQsMu7AiEA6uNfStHW\nb+alzPP55y28p4QYAz5M8rlNwcbOXljyfU4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISASCEE/uZUWyT/ANbcdf/BXZBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2MyZGFkMDUtNTI1NS00N2IyLTg1M2YtM2RjM2YzNTUxMjI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDAzMTkyOWMtY2U4OS00YjRmLWE0YTgtY2I5NGI4MDkz\nOGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErlhrZVYIP4UlFEgT8rXsiKmX\nWzX+N+SE94Sl0FZuEi8mQUgy+F5A3XoSFAojfx2+FS9LP9O5cA40lzSFYFNxpqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6XRaOaGwkFK0/dod8NUy/JmskoYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBBDaFom\nU4E6YDjSCtpjPr8FuWeQcL/GTYae5oY7RKyQAiAzgxr74EPXAK9wKk7EZYGcBuAF\nKtBmfhOqZTGYS8w77A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2875", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2875` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAf4uIB/0wSOU3J3BFSo/6QttMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3ZmZjMjAwLWQ1ZjMtNGMxMC05YjdjLTE2ODAzN2QxZjgyNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRkMzUyMzYtMDBj\nMS00YjQ5LTgzMjItYWUyYTMwNWQ2NjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1scLN761jFErutEWLLiqbTer1JSjuvqCWyvTLcZzBDh9xKrvEedVYDbQ1aFy\nGoymT5FM0iX8HiavpJAWOWQhiKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4kcnOimW00ezR3ARt1atJFqvrgUwHwYDVR0j\nBBgwFoAURiZvenP1BE8XoKR6W0RNLM4AuaswMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\ntIF8xCwVl1/bAVhKj6rNTukqQR9w1qsS4q4S+pqKpbACIQD8+4ZRyn+dtBHoPS9v\nQx2CDtjzgVsBc+AoLbOwdfZevQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQL9CriW279k5sdAHL1fbu7sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2ZmYzIwMC1kNWYzLTRjMTAtOWI3Yy0xNjgwMzdkMWY4MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6R9erdgIQy5p6XkOQ5ol88N2A6N0biB9H31ty3bXriwmA\nCZXbGcgRQK8AKswQPoMXsSNMccci4twsMwbHAeN0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURiZvenP1BE8XoKR6W0RNLM4A\nuaswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfLn2p/05WXR2YwX/5RQXfO1G8XC7S1+9Xra06r321+4CIQDEpfou+cPm\nXDSpgYPxs8ggFye3BTcBCI+Fsd8VjeiWQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUHFNBwxz5Lh3zjyFK2GRQctMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRkMzUyMzYtMDBjMS00YjQ5LTgzMjItYWUyYTMwNWQ2NjAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmVkODU2MjEtYmFkNS00NWZhLWJjZGMtYmY3MjkxMTg5\nMmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJVd264GiYCFeGkMiwyah4PQ1\n+jwDvhKXEiqlSO+Oa0qzjEz8kOMWo7/XvGtPigtSlH4u9nZFIci9IPI3O5/MBaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4kcnOimW00ezR3ARt1atJFqvrgUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCmxj0p\n/EkDbTf1MB0I45luDyD+sQpEaj0cqBMlbTk13wIgPHRjfniXa7KzozA7Yus7y675\ncixhQ79uZy/UjwZddo8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2876", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2876` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAf3O+TQhd82tElnnNMWVmDfRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5MWZkNzQwLTMwZDktNGRlZC1iZTFkLTE5YTUyZDJiM2I0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M2YmI2OTMtNWNm\nMy00Njc5LTkzZTUtMTQxM2YxZmRiZjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUR0cgm7Db1JQZuhPVNiPYBa6vC0yOIehkh2D82VOYLQUSC2dVdYuhCTFLpMc\nF2K8qnnKfzkEEp8dLxZPK3bGJqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTHxhdl/jEtppDCOr6JwRDULZPxcwHwYDVR0j\nBBgwFoAUgTOdUfPVuqCBZheKPtvT9TLLcu8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAg/+0p1mWWJoiZWiOGPjJ01RSFAD3hK30CT6WrT1F090CIEQF\nSZzx2Z9tqGNfEzDtxffoQ4FbEqAI+4azsxgWB3QC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWA4FXAdYWYJpgvQt95h71YrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTFmZDc0MC0zMGQ5LTRkZWQtYmUxZC0xOWE1MmQyYjNiNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFMwttf4oyYNAR8D5grrCx8EJVjbKMaQYdRqfBrK91AhlR\na2EAog7RGYaazy+0YMU0gggJZCO3vb/iZbkxSuv4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgTOdUfPVuqCBZheKPtvT9TLL\ncu8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfi6xAYRw1ZgMN+d/5CY1x1Y1ErXk33z7L/PuHrXpYAwCIQDU3uypa/Q0\nAzzVIid9LKUSGJPpUqa3elm2+jpt/9MmmA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQkGPtNScoxsh+pcvbTfqfH/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M2YmI2OTMtNWNmMy00Njc5LTkzZTUtMTQxM2YxZmRiZjMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2U1NmRiZDEtZTA4OS00ZjlkLThkYWYtNjdkMDk1MDky\nMDE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEv0zmhmBczMEN9+YamCpn44xc\nLqPAC52mreA6ydM+AChAPixlnF4niZGoEaju9NIWxI3PaDZDjE3tI/ee/O1k86N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTHxhdl/jEtppDCOr6JwRDULZPxcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDvZXJu\nuh39QqipDr2+jNpK6bBd7KpXLNWGhx53OTcArQIgZlfJzMdxT7cJMppZNkKw0wUt\nQZ0kbhSGhztpka4vHbQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2877", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2877` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAZ+GRnttXgbKA4wd5AuAidMgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxOTA3Y2JlLTQ3YjYtNDZjNy04M2MxLTA3NWU4MzExNGI1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJmZTk1MzktYWFj\nNy00OTMwLThhMmQtOTQ2YWQ4ODI5NGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEApgDTait5Cd6KRSMgHt7pT1Xj0KttdmQEdrsZgnoKxafjeKWXwI4aSEkrG4b\ngG5zMFhj9JZwU8CckJhHnkVvWqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlmYHt5R9CFrsizBM0VxnPDu986owHwYDVR0j\nBBgwFoAU4jQ1y4Hr+rncByuamCHhRQLOD4IwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBTegsroCSWEhyWEhVv4vu+0YR7eFbnLaXqqEr4lrvO/AIgWddy\nD6/ezkHEacCyGKnFxFGyN97ZNvF2cdMC4sVd8KQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa9oTg2bOfQvcEKHCx5XdUniMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTkwN2NiZS00N2I2LTQ2YzctODNjMS0wNzVlODMxMTRiNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3IdfTEmDiaSTehjWqV68qQ9iITHMgQqj0jR4x8mA5SZ9x\n25QtZblRXdnbx5Nh55AUDUTz5X1WZOXkwUNxf3nyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4jQ1y4Hr+rncByuamCHhRQLO\nD4IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUcFNvNybVBhXomgiysSCez8BSdWXG7y0Pi9nmcwbEzkCIQCCcDeNDrQC\ntBSf0/A4lfy80BrV9I766mlwhM2HqUqgMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAePk32NhuYBtvFwhQncwLTePMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJmZTk1MzktYWFjNy00OTMwLThhMmQtOTQ2YWQ4ODI5NGZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzk1NjkyNmMtMzcwOS00YjAzLWE1NzgtYzg4ZDVkMmQ0\nNzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEA1pbCoEE2ZCK0aVcSr5pmNa\nlbWafzMeTMclYoSlJXpzsAyC/sCVSEksA+EXYmASuGvgWzgpwCKeKg9Gl1uiQKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlmYHt5R9CFrsizBM0VxnPDu986owIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCp0+iX\nOCfL/LSB60HKofZAp3hviGmYfc+W/Exc+gNS1wIgdb50Q+9xeAppX9iooHANMzEM\nCgzxNVd4miqTFUT2oro=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2878", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2878` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAai1wt2xXa12xC98LiYYdvAwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmMDdhNTBkLTkxMDItNDlmMy1iZTAxLTMzMDdlY2M3ZGFmOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRiOGM0ZjQtNDNh\nMC00MmIzLTllOTYtNDA2Yzc2MGRhNGY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMkC4eFuw9MYh75iUDrhgHopPsFztcnfNoWVvNYjr1BnDL08EwdvxDA2O6CGH\nDsJBzq6HloMz+2SV2yqEZMijNaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUya1uezQ3q9OTihyje6kEmgWAANQwHwYDVR0j\nBBgwFoAU2KEWQ4JgVuyuY4jTIXiNgN5jRhEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBMjbqdHFO3W5XX\nFOD8vBzBgAhvr7E46Q1N+kOt7Iu3uwIhAJ7PSmWnuqhScKTV36fGoxZx7aMGWYT+\nbLl950BA6Jzu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcQj/vRrGTJba9bS5+LCrNiHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjA3YTUwZC05MTAyLTQ5ZjMtYmUwMS0zMzA3ZWNjN2RhZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvzIX2K9aCG/BJTzGV7LASXTZaQ8FqRrUoa+DpQzjOiCQt\n0KOGTgOOVgXSHnGbJz90XJLgaV5M6kmxRg7fQq5ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2KEWQ4JgVuyuY4jTIXiNgN5j\nRhEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIAqpl5r/l56eo+WXR+6I+ueDBFvMHWx1unHjmw+JrrkCIDZlJfC9T+N9\npVnn8Wfmk0/Jc/ppQDMR1kQUAbV79jDG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWgjwtLLAdvmNS4FwxAyiwDhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRiOGM0ZjQtNDNhMC00MmIzLTllOTYtNDA2Yzc2MGRhNGY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzc0ODUyNzYtNzZlZi00NzFmLTkyZjEtZjM5NDM5NTBm\nNjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkvMqAuArJFJ7JeGSW+CjwUsH\nz+VIDJiE22MqtkUUh8YP0A01K7KgJHFGHDLU02MZmvuBm4Wxoy2mOao/BKip8aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUya1uezQ3q9OTihyje6kEmgWAANQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGTKkp16\nuKmwNpjkglDwFn4FjTpH6qm374T/o95dWFDcAiAWrCIDwHrL13+t1dOHsW2CMe65\naU9P0CiAOnWev+eWtQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2879", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2879` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASP3IcmDqDoRLWHREHSfrdnxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0MGEzM2UyLWVkNjMtNDMwMC1hOWY3LTI1NzM2NTI4Y2Y2ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmEwMWM4ZjItYTQw\nOS00M2IxLWEwOTctMDcxYmVmMWViYTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsAyM4YWTgNKKZbF2Ea9+K8vj4Bz4nAWei7/Exi9qLajELfRV6IRNvJTrIioI\n9dFJ7ULB3Xj5mNam4UtZQZK1M6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMj4hFXOlYXDBY2fYaeL+PkA1ZKowHwYDVR0j\nBBgwFoAUcXwD6dYNF4PgNI/Sau+Kz6ZchFMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCFqpyCiAxWzLcBKTiutH4yjkivnGuQikbJsLrpPkmLLwIhAIMJvpaE5KKL\npQ6WeaF5PFPAuUVmB4PA+zeZ+2rH6kPf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARYGdnpcDanpYXZjim/Qcz0TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDBhMzNlMi1lZDYzLTQzMDAtYTlmNy0yNTczNjUyOGNmNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThdQNqP5FNbePHDr0Azhke0HVegxNLlKBdvk+vx4e/qYrM\nAOpDtDWWNWbn1E0XCJpp9kMcM3cF2dw2jvsg78Z7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcXwD6dYNF4PgNI/Sau+Kz6Zc\nhFMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKrlqnBVcTz2LeaVala4wPJjD1sRHeFaViQQLQH6bORUCIGnuimsKcKAS\nf8RvsmsuuMRgw3e/O8A9DPVFVaFv1EYN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAazZumPV8If01Sihzt+5tetDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmEwMWM4ZjItYTQwOS00M2IxLWEwOTctMDcxYmVmMWViYTJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTQ3NzMwYTktNDdjOS00MDg2LTk2ZjAtMjNmNTc5OGFi\nMWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2P6tUVsYVWvRB9iij2z+vRhz\nnHzrnCDbmnt1Kr1gJtU/6jZyx9FMLrL8i0x1pgsoZDGY4+sIc/I3x9gQDtwkNKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMj4hFXOlYXDBY2fYaeL+PkA1ZKowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIQCWOk+o\nSLCI6E3vwQsXbxnC0vxyU9uYdIf5lDmLnHjNWgIfNmIlV/TCiVlOmNf9IS971MK9\n8u8uWecRtLyRLfb/qQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2880", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2880` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUdU50dlsGC9/25Jwe8lixy6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiYzJlNDdjLTc1MGMtNGE1OC1iMGY2LTc3Yzc3YTViODU1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI5ZWUwNGQtNGY1\nOC00NGY2LWJkMGUtYTFmOTI3ZGQ4ZmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEahKCG2z3d1bUmXCE+X9BqWKJ/BGT1bE1CdbnfPZyp2GmRM26M8hgIbVG5uPU\nBPiIoKvNm+5UgbZHTu2+07onRKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUChQ/QurnKK30JZDI/4DKy/wpI8EwHwYDVR0j\nBBgwFoAUOy0zd8GxpQrMdbcP+/zbk7G2QMEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCa9mIICfuylQQln1k+qd2KvazYDlUAlgKhBTtoeRQsIwIhAI/lpquOKnli\nXeVGlZ0AVDJpuiWcd/pDr3z/W/6+52vJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVk594VNucg/X0HxBCAGbg4bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmMyZTQ3Yy03NTBjLTRhNTgtYjBmNi03N2M3N2E1Yjg1NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAqxUKjO3RjdWAAv/mcrRj9aS0msrLEnV2T1lKpadpIqJZ\nb4THG/jEcluk2mW9i4ErFJsOooBYEcflCRGeuYbPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOy0zd8GxpQrMdbcP+/zbk7G2\nQMEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO5G8y5MqVehaH3d/XTcKB7jXj8pFQ/rmsFqz4hRFxZ4AiAOwUUgW5mq\nl/XMfQn8aXAs+UvEKCkjwgdvim2O9zqUSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARYCOxOkjZ4eXlZXgYKPhm40MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI5ZWUwNGQtNGY1OC00NGY2LWJkMGUtYTFmOTI3ZGQ4ZmI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmZkM2JlYjAtODZmMy00YzI3LTk2ZmUtODcyNDgxZDU3\nYzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExhrR69bWyZISQDfhL9vmL6z+\nxijPStlpRI4FNDEJHSnQ10BTqkc+AIqNdlVrBAgl1YWRtRJE8gZg8JtHTCXIJKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUChQ/QurnKK30JZDI/4DKy/wpI8EwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFD7DAKH\nLODGbbm9gpD37zKGbXqYxwYBqyq0DGVPrZXgAiEAg1YDSW6JGU9o0R/mFRlXkzEn\nijLfWMp91Sdp6j57sLs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2881", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2881` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZNSyBJYNLqDHo1oZrEOCi2HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiOGY5NzJmLTg3OGMtNDNiZi04NTNmLTUyMDYzNDUyY2IxYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGUzNjJhOGEtMDI2\nYS00MDg0LTkyNDItODgyZmJiMDEzMDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEwJk4hickCRN6EkIv0dRKpGec7C29B7b/fGf3cVBbdIQhvf61Pq6X2vAt2Qr\ntPkaO6OG0FLiIOmT9nORtv+c/KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8TawmcovN0MIwI4h1uJ/KqE5OcAwHwYDVR0j\nBBgwFoAU0ZdQpYuza6rmS0sVyqMdSGqoBOcwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAGgbC0v0yJm7Noozj6mas/lYk9m/52FeaPdT2ZpGZ/QQIgbLbL4m3kvKC1\nmIZIUKDEXNMRxb5kSUEy6HTylZIqzsA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYstSTTI6jL+MTFhKPA9XDYZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjhmOTcyZi04NzhjLTQzYmYtODUzZi01MjA2MzQ1MmNiMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGhiJHcg057y8SpUFcHmtPSc8/CNudsv0cRqDzsskPyN61\n1JaDte0i5W1jNJQPwelzh6JOasd+qMfEg9COnvM1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0ZdQpYuza6rmS0sVyqMdSGqo\nBOcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANy3juKBgpiVnpNVBYRmazzTBzp4d6vVGkZRsR++xIDnAiBlFttqR22Y\nAXbkKtveGxodc/huNy8taEJIAT6WRB7FVw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAdAmB+6vEcbHB9NKrAD9d0BJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGUzNjJhOGEtMDI2YS00MDg0LTkyNDItODgyZmJiMDEzMDU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzA4YWZmOWItMjEyNy00YmNkLWIyZmUtOGNlMmRmNWYy\nYmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEBtxEN+SE2+1dEqZ37OgRnSg\nP+mKiCgA1i4BZ2QUpEwlZaIA1caBvaG+syfqY/SLGuzAnHbB2YHHOVeDaH2MZKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8TawmcovN0MIwI4h1uJ/KqE5OcAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIEK1NanL\n4asoMc8XNdUgNp/l35gUP1daTVVQUO5Roh5iAiAWA2AyVtjuHUY/nbfkg8akJUwG\nLoFl4myqbH4EF9LWuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2882", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2882` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAQsxqflzmG13NpremHgHU9U2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlN2FlNGJhLTE1NzktNGQ4My1hYmYwLTJiMzMwMWI4YmQ1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZlNWJhZWYtZjhm\nOC00YWNjLWJmMDktODlkYjhhMDk1NTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP+L+T9hCxibdj12UJpS5o/xJ2yVJ7qWm2P8FAHU7RDDJ/tNFm0xSA+p8/icF\n775hHbEaQ6b61968rm587LupN6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULqFtb14Wm4ovZ6RhBvQIthqCxr0wHwYDVR0j\nBBgwFoAUE3RS5g8ha5FkEG0WEMc+qCmqz04wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAt1CjckANhzYIlv6DB4e5A7OXvMmWi4b9ku42VnfJ\nXOcCIQCGr6lEPjoaOoqbrer+QOyC9Jr377s8nqaiU9xgUGrh1w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATahvYEf+g9IGdhco4kZt1ZYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTdhZTRiYS0xNTc5LTRkODMtYWJmMC0yYjMzMDFiOGJkNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJ1VX2PyzWgH3IYSpSdJWE9gJFYTt7jv/O6fmqsOWkVgUV\nRERv4ZRObT9f1++Bx8ySXpgXOZDDYa4An6LQXg56o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE3RS5g8ha5FkEG0WEMc+qCmq\nz04wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANqVLzDUyVDaNstwFRF5ovs1hAYV3Mx+k+h3sufSuyHpAiA0dFZs0kMB\nFdTTAk5eEF9zrvek+tn7I7hnskUq2uycdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXQLpoYp8lo58P+uA5FB13iqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZlNWJhZWYtZjhmOC00YWNjLWJmMDktODlkYjhhMDk1NTExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGI0OTBlNGItZDViZC00Mjg1LTk1NWUtODFmNzgwODBj\nYzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvlMbxlwkMtjFtTsOhv64Aah4\noZGAqSV0DeCSDml5UB9eX+tzO/mCcQ/MbCKdFeZbjXFFtpchwoLcBb6GvACisaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULqFtb14Wm4ovZ6RhBvQIthqCxr0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCwc2gi\nuMnzONBm5EwjhnpHtJgKrElEZk+1tmv6VX2lwAIgZiw35deRPJcCx5VhFgBFojUP\nxD/aVE4xO85/87nwcSg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2883", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2883` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISARpb2jfdMZKR2+nnh+o0SEl2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MDkzY2I2LWIxNDEtNDMxZC05OTEwLWE5ODQ0YjhkZWI1ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdiZWM1ZDEtMjZi\nYy00OGQwLThmNDgtMjQyM2NlYTAzMTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQl26J48VZ+GgvLNibqjPeS8ay2IONHxRfZa/O0dCIyYZZAVoDbdcxcVapwRd\n3gRVj03QcLUCEimzxQTb95X0u6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURdaXxgHpTR2oS1Y1AJiaauFUuLkwHwYDVR0j\nBBgwFoAUhc2OaiuLoKwERj4c94/lBsnjoPQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBwbvmKKJAYgJEnn3URBzkYMtBrQ28w+2OqgXNNDo86\n6QIgbjSR5HNF5ZE58w9LAiYc0+5ivwqqAl3EagHrX1XPORA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaJ7E77vfN1+j3sQWI3/UKSdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzA5M2NiNi1iMTQxLTQzMWQtOTkxMC1hOTg0NGI4ZGViNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlW+eAl4vq7MVUQ+Pn+I1IzmRWy8WOEn3nsxIirgQLwrHK\nZLApNrALvZ8RoEX0puXEwMmlsxIJ7ia5dGlG5eyjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhc2OaiuLoKwERj4c94/lBsnj\noPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFi3wGhM07LkAzZmingaddJQwb7nYsjS5+9ICynoZhvMCID+8KXSZscYV\n6HelywcjIc6IoXC3Nt2RhYUJzknZvV2w\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAdWeMZi8xeYI6Za9naIE2ifhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdiZWM1ZDEtMjZiYy00OGQwLThmNDgtMjQyM2NlYTAzMTZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTEwZDM5MjQtYzUzNy00ZjNiLTk0MGUtMzVmNWQwZmQ4\nMzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIEeAWyOrEmrym79teSbMuN4h\nwBitDcit7+2ijs759Nz634gSVYvV6VjEoIaVsCmRp7gsjABWPq9y0jhYxJykYaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURdaXxgHpTR2oS1Y1AJiaauFUuLkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGzUB6HS\nTokaUoCRDj7y7HSm+hydbkO+JIolL6VfMelgAiAOeZ/hcLSy1X0lApdIjLXvO82f\nD5z+Ge3S4p0JEI2p4w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2884", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2884` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAVwjLpB8pPBzZGKCXOqjrvTKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjMTE0M2VmLWI1MjUtNDQzYS04YjBjLTdhNjRjZjRlNjlmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY5MWI5MmItYmYw\nNC00OTZjLWEwNDUtNmRlZmZiZGQ3ZmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEVJ5iKRVoehUCXtoXRWBoiCE0DRGv8lDyXw5Y5V63ex5Kzi6CGHAj4f11JE2\nGvtH80mdy8Hka7fQPKJvYWBDw6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5xAUtY2pOx627DxwtQe8XiNYMXEwHwYDVR0j\nBBgwFoAU4DCZw1eg6jRVHuzL+1o5bjQnaJAwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAzprgFzIQJ+lC9ad5qH8aiETy3npLcuRvx/r+AFU2f5sCIQCg\nW/uhk0A6svAlhUeqt83CxG8e7vU4iX7ofo+qRn6Xlg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATCuK9cS6NTJNHhVcX47MC/fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzExNDNlZi1iNTI1LTQ0M2EtOGIwYy03YTY0Y2Y0ZTY5ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/FlX1rptrlR7wpVcOLwk20lpzfi/EGPPEWjSc/ZBpjQme\nVQGyunWIROBBehogzaGr46rGljyUS0+R1Xe0sE6do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4DCZw1eg6jRVHuzL+1o5bjQn\naJAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOSrPUBPQ9A/N1adF4tvtrPQwh7CiCcLd+8MEhNMFqlMCIGNsuf7hMxWE\neVh10v/kl2Uocxkmk28bxQkDZf52Z1xR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATZNLL6uRIFMZwTPvoRcEyStMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY5MWI5MmItYmYwNC00OTZjLWEwNDUtNmRlZmZiZGQ3ZmY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWUyY2RmNmYtZmVmNi00ZjliLWJiMzEtZjE3MDExNzhk\nYmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqCqFYC2M0THbKJatV1GjYUkQ\nBjqOu1xU0RwySfeSbr6re/Fn3WYA0XfEKG6roEN8eYdGBIV52lUcH4MCs7qAGqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5xAUtY2pOx627DxwtQe8XiNYMXEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDfZaSb\n2E9BvO+1C/fgSbycMhWdkcD2UgYJP3yflHQ06gIgSal0Xd5S4uQaPQl8HNi6RE2x\noeGs+2+aTgGkqdxgzkA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2885", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2885` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAZf3PqxRvoBJkGSeEw4tlIdyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2ZjM4Y2Y2LWQ3OGEtNGUxOS1hYmEwLWIxNWVlNzU1ZjQxYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU1ZmJiNmQtZTM4\nMy00OTg0LTljYTgtM2ExZWJmMTIxNTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoZ1bSXouyvjnuW5vFg2/kK5MnC+swxCO/xKSaWpbGe4O6PIgMuu7CxRfxs8n\nzNqYr0KgjKYqM5Qy7S4+eC9WL6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPcr53F4upyZGPQyxeQiifYuEjHkwHwYDVR0j\nBBgwFoAU+NjjmKW9H7tYXK007XfIuHeVmVMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBS4hyMdeS3QWmVuSiOgh60LlpbTvGz9Esz\nhE2pIo0jRQIgNraOD+oifpVM5ayCGc3OnRtVBi6U9lInFVaAILoyo20=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcRS8bQ3RsBuGI9O57VQi5JdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNmYzOGNmNi1kNzhhLTRlMTktYWJhMC1iMTVlZTc1NWY0MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATX+Abf6Y7bF7sga0jyTMvIH10KkB1uvQTlNc+lgdT8aOXq\ngd/qwVv6JNLZCqaUJQgUYBMNEo5sVgUjkelB2LmWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+NjjmKW9H7tYXK007XfIuHeV\nmVMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK/zCpKoRkNQG/3LNZ9E4UBvfKSPdQTA8QxUJxUjlNdUCIB7gtk2938wZ\nsyd23lzDfiGQk84RFIjT5oFrG6mJ6Wkg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAed7pX5XHrEnKiIXkvMN9jmsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU1ZmJiNmQtZTM4My00OTg0LTljYTgtM2ExZWJmMTIxNTNiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWZiMjEzYTEtNzZhMi00ZmU1LWE2OGYtYmQwY2U4ZmM5\nNmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXAPlU827qr3hiBzwtlmP0RJG\nZT+tkKv0/t5HzDjX1ohbKF9U+yjXiAZXKrTlwGEitMD6dpl3ZQpqXBRM57F3C6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPcr53F4upyZGPQyxeQiifYuEjHkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBmqxZp5\nXBHcBfAtasbRIsO76BDGdV7zUYBjgIxaWOciAiEA6WLtJNJYnzk6fazuLCvBrWdN\nmoTz2XrUaa75+dB54oc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2886", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2886` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAawsy+LtPxpOX5A3QjhPD5r1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMTMxOTc2LWI1YTAtNGFkNi1hYTAzLWRjN2VjNjc1MjQxMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2IyMzlkYTEtOGFh\nMi00ZThhLWI1NGYtMTA3OWRlMGVlNWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzJv8/W+wuFddP5qvyjlZ6/N5+5hzUS/TLPZ1a6Df/rrWiDA2UM4tFT1sRU/x\nqE++MMiLKr2vcM9bHIp4A34HHaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvQRITpY2B2G+XkExURT4OFVRAS4wHwYDVR0j\nBBgwFoAUeq1MbN78PmKYK1bZUOvcPAEX/QswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAy7MffN5o0lrLLdbt3vWqMTFCue/jmVFp\nHWIybjoze4wCIEsDhcK2LgQNIG18gzCxdXWpMPtegqXosqLrTBCKuDYx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARqNA9hxh+LqQy5o+DSob7gTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjEzMTk3Ni1iNWEwLTRhZDYtYWEwMy1kYzdlYzY3NTI0MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXwtmYrn7ZOp/3lZN74696TLee3GE2R4jW+cdrCGi4O729\niKVHpSfEyMH5Rz3ZSOk7c3xGzmJ+++u7l+0IWiD9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeq1MbN78PmKYK1bZUOvcPAEX\n/QswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJEbLn/QyXYOwDKfuh5k04KgScbjv8LuBZsSsAJLY6jhAiB0x3VDL7Nj\nwsohtfZtmpu9XutpVZHQsE7S1BN1ASJTJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUjUaYPxA7rz5/Pn0SUbj0JxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2IyMzlkYTEtOGFhMi00ZThhLWI1NGYtMTA3OWRlMGVlNWIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODcyMTFkODUtYTBiNi00ZTU2LTgwMzktNzQzZWYwYjE3\nMzhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzk34TYROv91yrikfr+MHFJkE\nNTXR3sjgk8Je4TF/eysdc4W4HM+NQTXlbMjqDx+QV9UzjGytliqkpUBXF9UhjKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvQRITpY2B2G+XkExURT4OFVRAS4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQC41hdZ\nAb53MxRyplOUnzdbLKylD2qft04GOnBVjScYTAIgOYze/ngTcPCy/+COX1+8YuaY\nKif4v/U6bdfvTiOCT7k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2887", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2887` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAd3/YHNJLzOvt5VqoSqjDZaTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2ZDc3YTAzLWYzYzItNGMwMC1hMWU4LWY2NjEzMTk0MjFhZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE1OWNjZTEtNWVh\nNy00NmY1LWE1MTgtM2ExYmM4ZGI3NzZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Nqsn81Q9FqqEK5JAgHDexJ6YvQHbJwFZB0iTjfPmHZiZhV0KwW+Q7e6UjVz\nzZP1yWziC1pQAxpDMAECPzuHt6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULviW7ak1eiT1b5ZJjqSRHw0kDEswHwYDVR0j\nBBgwFoAUZHzoT0LjVRjBSD6n0QEqLQKhaQIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAzHu587uV8hvp\nevcJ4jtp+OW6RK5y1Q1FJ/uTQS2uaRQCIBgE5qzfGzwMha3lPOJkMIxKNTCxXdp8\nAqlhCUS298qx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARW+IBlqGV6cB7dBqCbrW30GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmQ3N2EwMy1mM2MyLTRjMDAtYTFlOC1mNjYxMzE5NDIxYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXYuB/Fv7cm4+WK5TiymLqTtkYjN/r2WQMti0tfxuZUEIk\n4XZ3zdJWFNfNizGsyj87dCnu1aFIeSbY2FFeJDRJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZHzoT0LjVRjBSD6n0QEqLQKh\naQIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNAVf6IIG9Gs5kguaS0vP58f/0FM0u/gmgdsqxh0Gf+wCIQDYkmQ+Vn0x\njb8wX1kl2uhC065T3buq3CTKa/VSPHjsOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARkmrsNVEo2b7Pxghh4+ZoSDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE1OWNjZTEtNWVhNy00NmY1LWE1MTgtM2ExYmM4ZGI3NzZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQ1NDgxOTQtMWIxZi00ZWFiLTljY2QtNjFiYzc3ZDU4\nOTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVuxynr9GMBgGDPMmwu0HTW+m\ncRTcG7BdR7m+aetEoi9YVNBSr0ntRW+ju2rw9B8oo+GQPwhwOzWP954gGdmHLKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULviW7ak1eiT1b5ZJjqSRHw0kDEswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBi5Srv1\nGPmrT7K794rw6CFeWFyGiXzTvadod1piICu0AiEApyva4ow/KQDbssYNwgw7y4qm\nVMzdSeHVYZ/an2z0dJ0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2888", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2888` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdnnG+1k/axya+C2E2Zp/Mo0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MjVlNzVmLTk2YzgtNGMwMi05MmY1LTJhZmYyYjVkODU4MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FiZWJiNTMtNzVk\nNS00ODgzLWIzZTAtZTAyNDNmOThhYWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf3CD8UlOknbkcpEKZ81OPceraNzAOVQs0rQag6kyy/Ne4KqWfEfJ3Ym6Z30E\n0e3tKHSxBIiD2TGUxVhTs1VpVaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9+0V2+siTdswgzA2La1vYvYY1dEwHwYDVR0j\nBBgwFoAUohENhrw+zJQry0yRfJFD8DW0cTswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGYfR+0Zh6F4LtOaoDFq45XB9WcPdqVM+ApVCO5qw0XQAiEAsk2ymfxHsqSm\n+vhPp29Xwn+fLtUv74o4KUXAcwBCHrE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATE7DBUc3AZIhQmYnIe9WWnvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDI1ZTc1Zi05NmM4LTRjMDItOTJmNS0yYWZmMmI1ZDg1ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrtCJIY0BT/LC0uF9gALHHuaMEpHIqZiDFe4Ka015+x8r4\nMsQavkqnE3/hqJGmyz5AQk8X37H2aHNACUHZ9GwOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUohENhrw+zJQry0yRfJFD8DW0\ncTswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ+2I1qjw9w0ic86eR9Q04TlDxSMIdpurAp/in6jolyvAiAjpXFO/+Mu\nqrs4KAsBLeiUL3KHsk8nS6MXTjyrAz2QCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWeUuSV/+M6TbSmVa66BenhaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FiZWJiNTMtNzVkNS00ODgzLWIzZTAtZTAyNDNmOThhYWZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjk0OWVjZjItMTlhOC00YWFkLWI2ODItYmEzYTNiMmVl\nYTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEU5Qj2TchhUX2+j9hr9mf2MkX\n2AA9IvP+5w1fmzdOScIkVlNQNcgV/vb4iIGIJqUh8Lbg0rkGEqyU4uFZnlEUpaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9+0V2+siTdswgzA2La1vYvYY1dEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDjAcpc\n3vTJUUh6Mo+neMcfcYc6ps3W1V42lzq4G3KZeAIgOc4dTssxs5cObgAbNSIuBJl2\nu5mmfhxsBHQ+/HmKOP4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2889", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2889` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAShDx2wbIifRgZL8A30Gtt7HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5NWQ3MTQzLWJhYmYtNDQyYS1iYTZiLTk0ZjBjNmNkNmNjYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGY4OGI0YTQtMTNk\nNi00YzgyLThmYWQtYzQ2YmY4OTM0MjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeG6AYGAG9bYR7T2ys84Yrrd1SQU9/kBA6fQch+RONGp9XkcdSCU420jqgHb7\n5ITcOCvUWLdtZrj+1gmiUvPaWqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbfkPnl2iv7O40gknH0wmaXdFeGUwHwYDVR0j\nBBgwFoAUWAiVa9WPPaY51QE1gJ2xhu/s7YUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEcpOL1XD4iLiLJ3SyVnocjAFe1d0h2+ecDYd0+DtoMcAiBIHAjI2l9Azp2Q\ngi8fZpZoJIVCJgaIF6QlArf3BPZZBQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVGhNTHKf8ePzZjooSni9yQpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTVkNzE0My1iYWJmLTQ0MmEtYmE2Yi05NGYwYzZjZDZjY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxpEIdzfgO8bppK3foJ4kABDelvalBJj4cIncy+6mwqYMr\nZT/Yn9Wyd39D4ddU4xL9E4yBQP7cWUNRmCgHcMTvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWAiVa9WPPaY51QE1gJ2xhu/s\n7YUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPFMV7paAFoFXQHbx+BJ5WpJgwzwjt7jrx626PZx9jxlAiEA/LX/c8R1\nahL+2il4ff4OGzmi3JsU6TmQLshVR/9ez14=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAelyVqejy2dq4eUU0yd9ItlbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGY4OGI0YTQtMTNkNi00YzgyLThmYWQtYzQ2YmY4OTM0MjQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWI3NjAxZjMtY2MwZi00NzYwLTljMGUtZGNjNDQ4ZTAz\nMmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQNpGYKlo9UpXMCvZkZmr9Hot\nl6uMWwXIrcberV1xEuTjV+dJ9PEQB85aITLBycIR+QecrawZWJbgZzfBkxO6HaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbfkPnl2iv7O40gknH0wmaXdFeGUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCdshDQ\nmJlEa8byO3QMo6kxyJ7AY2gMKt8XfO0gHeDOSAIhAJNO5IviqZ5mqwkIM3Gr7hT8\n1+iTt+eTuBdHno603adE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2890", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2890` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAddUPB3zN8HpkvNwe59p9XWXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmNDlkNzJjLTNmZWItNDhmMS04YTQ4LTY5ZWUyNjU2ZGM3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM3YzZiYzEtY2Ux\nOS00NDZlLTg4ODUtMDRjZWJjZWY1YjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3lDb+W1R2Lg/iNgZuUfqirMjPaoe43cHYpsruiq+2wS3QgYZUy9KZ9xBhZKM\nkSjoqZpn0NNUYVYz+agcv7gEzKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX5ygB77acBh/S5mCzBhFudE592QwHwYDVR0j\nBBgwFoAUWW65NjgaV/tP/sCNZ9s9nSYg+CQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBGZeqYXzQI4iHrx66ZZCMAg1vLukfIvSQZxlPw+BNzqwIhAOwggQuamB3D\n5UPc+yi9bqbfO4845+lBrjbPGFnf5cfw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYiAkiugDe6/t3ju8CTP2TSyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjQ5ZDcyYy0zZmViLTQ4ZjEtOGE0OC02OWVlMjY1NmRjN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZomh8ISQDPOxV7QHalndIEiSTa5/z72YSuCJFFOZ4C0P2\nyr8dRFHsFKNCnrwegqH+9CLhalQZane/oMzRE8KIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWW65NjgaV/tP/sCNZ9s9nSYg\n+CQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIl0E0xC0lNyVm7yjlHJGMqmd2yEr33VYIepn+CpHlVEAiBfdT+rvWtl\nfs9jNTzAO+ux1/NJKuJUbXfXxs8zLicnrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVJQy4/U7bjnsUyvwCTRJUwIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM3YzZiYzEtY2UxOS00NDZlLTg4ODUtMDRjZWJjZWY1YjZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODdkNTMwNzEtYWJjOS00ZGZlLTg2M2QtNGQ1YTNlNGVm\nMTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERUc8uJNWZYeh63BdlgTihgLZ\n877AL2MxRiOTrlJkCLpgSLS0mIt17z/QoB3yM7FNN0YDrq6Q+6uQJBqlQKfN56N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUX5ygB77acBh/S5mCzBhFudE592QwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDuFmMD\nvH0bfBs8YyzmIe1K5WvxauPUBBl6umFEufolQQIhAONI0xZio+CuOmZrtP7Xbv0M\nUHsaUR7x1emAuM5rlKYT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2891", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2891` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVxl1BOJlgDITW2Egq5G25oGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjMTU0OTY0LWJiNjUtNDU1YS04MGU1LTc5ZDliNDcyNTUyYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYzMDkzZGEtMDE4\nZS00ZGZjLWE3YTYtYmFiMTAzODY2NDU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4D+x1J3fFqMjclAqv14Y5zYu+imYm6XQN+TcSn0cQcGYSU56o+Yn2PwG3Zd2\nhqr2jOglLG33b4ikQBlKa5jCvKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXNAV6QM/OYKigCkkdoqeIJ/JMk0wHwYDVR0j\nBBgwFoAU33T7x6A7626TpX04Gw5ssrdwVyowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiARitIplF2g35bAKV65pNCPecL9OoSZMw9/Z/H2bWYQ\nxQIhALerTaGPmdP5RItn9ototZeDRcDBnoIqhqjIX8bsFb/R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfSOdtMhT/O15usl6qDIqR5xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzE1NDk2NC1iYjY1LTQ1NWEtODBlNS03OWQ5YjQ3MjU1MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZi1pXJBeg1+kgWk7FDKvcQBOsGvjgF+kJOPqC63+ONZfO\nuxgh/0eDQPd16YJaQJMAr7jA6JNak7QjOUv8Ig1ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU33T7x6A7626TpX04Gw5ssrdw\nVyowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMigWi6/kWKl32Fr+KucEmWj6OIuir/pN6dcHCmNrQfcAiEA2szxtb7I\n7zdLOCQIckj1MzCAj8Am9vGQZZsJ05j2mk4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWG/6824Pj+983WixWqty3VOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYzMDkzZGEtMDE4ZS00ZGZjLWE3YTYtYmFiMTAzODY2NDU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTBkNDZlZmMtZmJjYS00NzNmLWJjODktZDBmMTg4ZmI2\nNjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiqwiSd7ajGdOM2EwNoefPk8M\ndrnZxW9fLCc8MGpq2IO1RMdU4qe2eyKm2HJjuQpCQ/3/lUBlfkrqXozj525DraN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXNAV6QM/OYKigCkkdoqeIJ/JMk0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIF8nd36g\nRY8unvRD3l7ZXDAcKV4+Kqy/RjGUItdupyP/AiEA9RLptgVE3DcZ60s8p1WwfCv8\nTsr7W664NJ8BvLEWQ3Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2892", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2892` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISARG2vqKUq24JpIzsFH0SdcQ+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlYjQ2MGE4LTNhYmMtNGJmMC05NzE1LWNhODNhNjI1ZWYzYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU2YjU5NWUtODM5\nMi00M2JjLWFjZWUtNzQ5YmRiZjBhYzFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0CgfMrpiL90H00Kg6ilSZqeVHaWrDwlcVnZljifgeZaOAMGuR4OFju5HATrs\nlX2Fo02At+LW1x6yB5hE5kHxRaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4lS6AzKI8hIZapgwjPS0opKQU7kwHwYDVR0j\nBBgwFoAUMmYk1oWUkBMFuyBlMIFjmBZ7eYEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAk90EIhv2d/bkSYAUVNOezJG/4UKUSZ2KiEoxo81ft\nvgIgXw1578YUQh21PMatQIuZt+pN0mb/m20W+s0FpnP7xm8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAauJo4Wwg6a7JdXrrASWx157MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWI0NjBhOC0zYWJjLTRiZjAtOTcxNS1jYTgzYTYyNWVmM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxRuU8noWyPcvHAJ1WTIMyZx0E8UV5nZ8hRKmJzTIElb7e\nK8a6TZeGgLU6smZaF3xxtXRPvdh/ywYH7AUlvQ/uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMmYk1oWUkBMFuyBlMIFjmBZ7\neYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN2RHN/eVM1e3epgYJH/OiiRyCm1lC8UGbuxhK1ePbmFAiEA7Uxa9TFI\nIbLIcFO/apoRmoepkL7S/ubrjofV10ca36Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARlcyasPS/oyJT04U9XPNP8aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU2YjU5NWUtODM5Mi00M2JjLWFjZWUtNzQ5YmRiZjBhYzFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODM5ODZiY2QtZWNhMy00NzVlLWI1MTctYTgyZGExNzhm\nMjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPkuUIpukmVNydmW4kRB2Bw2y\nMEVj+igaIVdswNURQdIw+nhf2TjiO3sZqOUkZoSVP9PXCE9LQfNS59czx3vl36N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4lS6AzKI8hIZapgwjPS0opKQU7kwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAVBTsO5\nKu8kumMwsH4SPeW20gGscIAVyhUeJ4fJ0fMqAiEAxL+StA9dTPwMtY4x1m76qFql\n1kqtufOvlkGB3kH5YBQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2893", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2893` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISARTFkpciJMYzZ4jMz1sKLAWGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkOGIxZjdmLTUzOTEtNDY5OS05OTFhLTQ3NzY0YTcyODY0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDcwNTAxMmEtZmEw\nYy00M2VlLTlhN2EtYWFhNDRiM2RiZmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+BAhrRlnF4nXpZco96uN7xMhw9mJRtiprJd1dvdJNMPWMtsCz1WDIgFt2orq\nUmBsmfyNcGSk1Ynbyz06usDAbKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5rN8CHM/TXILZr9WwbgoJrn0PL0wHwYDVR0j\nBBgwFoAUTFTxWAo5PaAn/U4z7wXM8ViYMQAwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiB3M9/dNb9t8zAKNMVGCkSEfeHkr+rI5Wk5KzKOtlQnSgIgVAPl\nTEkxQD6nIHwTDZsIWor9xYtd8Pr2iJpKc/9ldLY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ9bYCjqsWSVNRX555Ga5oURMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDhiMWY3Zi01MzkxLTQ2OTktOTkxYS00Nzc2NGE3Mjg2NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjU8wtYTRU71c4o6q3xqCBv8BSTqTTCdsztexyFrXkhzEG\nglN+uRRnkD2tq2Y9vqpHG/Y3SQrXT3rJwOO+D90wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTFTxWAo5PaAn/U4z7wXM8ViY\nMQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOMXJq7qNcyF+YXR6+vKu5kDf+keDS0ydkw5tkNoj650AiEAqyqAuBfs\nibIF4Peov1XHWQeHRTj000C65xI/eulVN9Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAatBtfGxvEkk7KbX8pkkFEoyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDcwNTAxMmEtZmEwYy00M2VlLTlhN2EtYWFhNDRiM2RiZmQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2RiMmJiYmMtMDFjZC00Mzg3LWFiNzItNzVmNzMzNzFi\nMWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErTGgdWIO25BLFerPs7dYN7dK\nbNh57omB1QHRNTwDwZt/nZFFwjIYlH+r4w0B3rB+0B9YWHf2f+1HZ1hslrjTeqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5rN8CHM/TXILZr9WwbgoJrn0PL0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAh8DBtm\n0ZE7ZggU358pmJyz8vtrm2yVSCdyxX+rYEXjAiBVcwz9DU9J0Lhh0Vag17UuEdP9\nLB9LRT4UMEFx2wjYSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2894", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2894` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAe1bTEG571CaGx2bsmp9nPIwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwMTE5OWYzLTE4YjAtNDcyYi1iMTBkLTJiYjRiOWJmZTMwZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFlOTA3YjktM2Fk\nZi00NTQ5LWEzMTktNDA4MTVmOWZmMjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEipJS1T59PWIOL1V34myQSSUmSldiSgc61B2HUjutuRpoNttWmDFW4T/4hOVr\nVw1wM+G0qYN6GuFv1e9MF7UYg6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7NAzTMMTmeqN6BCF0Vs4FtcpJC0wHwYDVR0j\nBBgwFoAUaqztSo5XhyTeHccbJ4heptIQMLMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB++nYuR9r42YnYnqdydTEaRZaZq87/38e4\nryZzXEKGjAIgbVtXjt98QK9miiIf86dsJwSBGQ5uI/9rLrMZ7NH8qPU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcZlaA3j8f/NE21NwlzIajGLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDExOTlmMy0xOGIwLTQ3MmItYjEwZC0yYmI0YjliZmUzMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASD78ucvlliycSvc9JGW3BX81W1nidxVtZH8KSp3u1Dw84a\nSlROnbCZzSB4YFG/5mVH1JaTnj71QcS0sVnzS374o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaqztSo5XhyTeHccbJ4heptIQ\nMLMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY1x4AYC127zThfGiyJPlcToxvOiwbzmXMicdmLuAzIYCIQDZn+GuxjtR\n+G68TunFIq9QDLAO+Vmp7KwKuNf2Jw6L9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdvT2NPgZLz16s26cl9zzLUFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFlOTA3YjktM2FkZi00NTQ5LWEzMTktNDA4MTVmOWZmMjBkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODhmZjViNDEtZjhhOS00NjdlLTk5NDgtNzI5MDM1OGZk\nNGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDqAD4eOZSNaQOmLbcNBTfyil\n2MHK1CVOqiymz7Nt0o3ji8f4UvCWeoOLWCcZnLpTJ8h7AWuhz7d0R1ugwyx3pqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7NAzTMMTmeqN6BCF0Vs4FtcpJC0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIEFAnaiZ\nBmKc/frqGwMZV9iEFuWdiqiEHTqgiEHzpficAiEAhWj/vY8O3BPkzL2lSs/5vcfj\nWdk/u782it7s96E8MLc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2895", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2895` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAYnD8wjjTpkUVmdnwp9sOxbsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzYzg1MWVmLTBmZmMtNDU4NS1iNjdhLTFlYTQzNGYyZDczZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRiZjEzODMtNzJm\nYS00MWQ3LWJhYjQtYmMxZjE2MzRjZmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfFQu6fi8nQQJmFH3KCeIjAG4zYPbyO42w3w69ZogV/AgHRTvPnYlTNeZKkZT\n5+fZ4EmwOHlQS2v319mcly+9WaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+O2hIAozjFDPOv+ukdtkhYab+/wwHwYDVR0j\nBBgwFoAUZfnxUB5TR4sCBw5LE8eYsvoRUcYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAhJ7LQ6B9HCEQljuzV+mrUsMXh2G4qWWn\niP6QW0+wC4oCIDRNoJbIVH9Kx2BUcXUos/2dYmwVCTGykNZBBA3gq04V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdAchxlvE6NomlEJKY89cbgcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2M4NTFlZi0wZmZjLTQ1ODUtYjY3YS0xZWE0MzRmMmQ3M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATA3ndFR5UFdoY4eW5bwkNhTTAzkQq1qjoSk6odP8LyFldM\nMthLqbm5mgv7/wBvZD8wTwYjeoycqEmylCk7LjVVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZfnxUB5TR4sCBw5LE8eYsvoR\nUcYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOVd0TjQHfhWdUtcWy88T3L6OD2juvugnPX9YdcDptUUCIA5eUemzokEE\n5VaCpX1AO946caIC5AeYreuaSlu86zjL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdaHOiYtRoQ2DzZkAUdTFCLjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRiZjEzODMtNzJmYS00MWQ3LWJhYjQtYmMxZjE2MzRjZmU2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWQxMWQxMTEtNTU1NC00NWQ2LTg5YTktMzE0YWRhNmM3\nY2Q0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEscbXMb5FV6Fr8p85Uqul4MTQ\nH9yBJ2GHrnroNVowgTBuAFGgXAt+m+W/Z+aIClvRA5YRjeYLeeQ57oaYfhp/rKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+O2hIAozjFDPOv+ukdtkhYab+/wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIA9HQyDu\nbJK6i5JqzLpH8RqYxtIdypmGGoNquP1JEoDUAiEA00UY5Ki6jfpHSdwpaI9QxP83\nhPYShscnVtTyJ8i+Nn8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2896", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2896` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAcpLnDTt/2l5PyTkt0rGyEQzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzOWRjOGZiLTdlY2EtNGM4OC1hNjQ4LTcyOGRiNTJlOWQ2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU4ZWVkYTAtYTdl\nYi00NGJhLTk4ZDAtYjhkNzZkNWIyYTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYO2unYsvWA2HxsRfM3Rfd/Ope474kUImqm5sRVPoFPscEK2NylGrBjJ8s9rp\n4yAyUJpSSs96M4sMhFRzaYQppaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWaH6Iqk3XAsuYkvmYRmvtYXDyvowHwYDVR0j\nBBgwFoAUD+CYgQe43jOHpJlM5CHv1pqClS8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDX0TaDtTxWpoqwL14wXQJEYP/2\ntwbIHNXKngtD+22ORQIhAK1tZX5+ARQvzphy7TwqWIjzMG0D1FT5ZfPFXkIeSXn3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYKvbD2nbWd9IbnQE5cQJMhFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzlkYzhmYi03ZWNhLTRjODgtYTY0OC03MjhkYjUyZTlkNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATU/IIkJO7g5lsZfrXzuS8d4QxT0v/AcAB3T6MCkL7a3dVg\nMaL4KUFc6qenHj11FIvjacySdHOxpIyWd6hjR1y1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD+CYgQe43jOHpJlM5CHv1pqC\nlS8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKARBeII1H71CVhZ4poAgm+btSzeTMAV14/xBboWS54HAiAsjzdR2ugo\nGZk4psmEijv7cJ/U2wGjkbepS9jd0m36qg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAT32SDUrMxlRD9aqBiZ3Rs3eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU4ZWVkYTAtYTdlYi00NGJhLTk4ZDAtYjhkNzZkNWIyYTVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDZmZGM5ZTgtYzA4MC00ZDQzLTg2NDktMzM4NTI3YzJj\nMDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExAA0A3c3Y9qaMCJ22FixesDj\nFi6eMO0fnzq0dxnMIxLbwKHK0xwrgtdLRwoA0Tlz1479vhvWN6vJphhrs3o2x6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWaH6Iqk3XAsuYkvmYRmvtYXDyvowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHA4uwdw\ntnV9c3FPnftQniR5OMN/t3Tnix77zbiuRUUCAiEA7jYGMuEw0CZ49JCILLwfQ5n6\n3UnqSlsrdreoEwBRrEE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2897", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2897` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAVH9hKJE4qG5FfTmjUcMUAaUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlMDI3ZjQ1LWU3YTItNGQ5OC05Njg2LTFlZjQzMTFjM2NjYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjlmZWZiODgtYzU4\nNy00ODk3LTk0YTktNDM2NjI4ZDkwN2I2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjlBcRMMWHeutD4vn9o8pMfNpHnbz5YhCuza7SPA14ggaB2KtHUNcFa6gh/GV\nDjB0pjFTRrLNSKZobMMp1MV6B6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpwnF65TKbY7W7Uijco7cdym/MAwwHwYDVR0j\nBBgwFoAUNj1q5bIbq3JSAXhcyGlbZwGEap0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgH8fNozde\n+0l3DfHqyszg9mvW/FPmMUrEtzyPbrj5D/ECIDQjpqiahBUh4EaglzgErlcDo9tq\nRnIcRIQoKywJEYPB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARIzOlopeHTEpAmrltRVv4x9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTAyN2Y0NS1lN2EyLTRkOTgtOTY4Ni0xZWY0MzExYzNjY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAJRVtXl/v0sZ1tqkM+ieqcJwfeVxYnzOnRaRbXEU0uDnT\n9LGZw6C9yPd2RyhT5jhf09rf9vfKZvpWUYmqcHTpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNj1q5bIbq3JSAXhcyGlbZwGE\nap0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM6B9tCPphPxQVVPO7Q1x3Gy1iA493i8WsISr2Sa85eUAiBJbYRCVmqS\n22M3qs6WRTg5DWOV7oLzfmeFwWd38OAHQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAcz8/+hEOcNtzyVmtWygI3L+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjlmZWZiODgtYzU4Ny00ODk3LTk0YTktNDM2NjI4ZDkwN2I2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDE3NjkzOWEtZDFhYS00YWNlLWE1MWQtMmRlZjNiYWFh\nYjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKX4gDRqI9eRxApOnHz6MkHM3\n/ITS/VCyqUiZ7S0e0mNwahZBekJ0xwJPMu+HL/bEcY1QZW3P/Fz0hAcSZt8GdqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpwnF65TKbY7W7Uijco7cdym/MAwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDe7KVv\n5QA0XEEMC+gHoQTWdO/8y1hMZuOHOaPDreRrDgIhAO8LsKtINKwJYTuo7MBM+tAw\nFGYl2xWJ/1MZiXtWc0+S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2898", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2898` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAb0VvBVoFMzfEgW3LBElj1yMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0YzE0NzM5LTQwYjAtNGM0Ny1iNTIwLTNkYWVjMDliM2Q2YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc0YTIxMTctNDBh\nNy00NjgyLWI4YjktMzA0MWNmY2RjY2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUAcg9XO2gXBZGTNC5UDZm6C60zTaQBS6UJ9lepC00P21aXirgpLF7YjcWfWB\n1fX2qv+XIvKkTUKojhMMTLqZ86OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI/Dwh7DgrfalMctW/fxRDPO8Mm0wHwYDVR0j\nBBgwFoAUGLGifk/qEMTAi7YvgFxdO2L/EywwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgGKWemirZ\nIaN/rywC+x7d+Q8ZodG/WeyNCv+MaIZQ25sCIQDtR4d6vRgVWqjMfJUqpv3tULZh\n9i0F3XxZ5vShU+6i2g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXx0nN/r5vFRNn4Q0UpA900lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGMxNDczOS00MGIwLTRjNDctYjUyMC0zZGFlYzA5YjNkNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT694diYCBCQyAmXHb4TNQzyrdb1dy9QfwLgIkWdPgRLbBK\nMKEe/TU33ED61TQReoRaGEg8IzEaGmXYo1eMGX0Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGLGifk/qEMTAi7YvgFxdO2L/\nEywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOP/J4w/pQ3tIT8t37BLdT8BsFr0k+BU2ENMaLuhobmzAiEArzHSAzSw\nn31M7Al21dcROMKuA9UFzrX3RJydIU7/+zU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZLhQW1iwkcjT2qI6hNaC4LmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc0YTIxMTctNDBhNy00NjgyLWI4YjktMzA0MWNmY2RjY2IzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDM5MGU1Y2UtNmI3Zi00NjVmLThiYzYtYTI4OGRjZGIy\nZjgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcFKpmnyHRdVOyyVgablcfonf\ndhcCDxlM42dU4QyajP41w6zTjWbEO+TqnrvFi+7B6rIPw3RwMyjcJEk7w1bCkqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUI/Dwh7DgrfalMctW/fxRDPO8Mm0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFtQylfv\nJQW9r9u3y/a1PVr15jw2TIwadZ3jNZXBoNv1AiEA7/BHgWsc/AkFSo/DSQRKWze5\nLVoqfn6Ltppq/pfq+zw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2899", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2899` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISARgec/Gd58AvMcQ/o+lCg+w5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhNGNkMDYyLTMwN2EtNDcxNC1hYWNmLWE4NDFjZjYxYjEzMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdjZGZhM2YtMzdh\nMi00OWNkLWE5ZTMtNjIyZmU5NmRkNmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwBybgNiIH16ZLRcYqdcyZYiuAkR9MqZwo8+tkfU/XqxUhIbPFbZJ5Z4qX5GV\ntG/gFDBJC1md/dlr+Zwg4XT1VaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeZSLUPUPllSDVmq7+UhTbYP+4yQwHwYDVR0j\nBBgwFoAU5cc+gJKQbJr+Fgq0lvaZTQRjPFEwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGLtlaJJ\nXI4A+NNVN2MgZlI0Y4gY+xRMQitbIgPh6cR9AiEArNMfFoQIqb2FBClW+CSeOlp6\nheD7TBKX9MiYp4wnKcg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATeoNFldLSHXikfOTHwJC8PwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTRjZDA2Mi0zMDdhLTQ3MTQtYWFjZi1hODQxY2Y2MWIxMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5otQTjboHP/5qVAZZ75dtJ7sFrcjReKF8o3IwghH1jJqL\nTG4ngnED7PGaTn9hP+zJuvDrFEUEcn5kNkjsyssho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5cc+gJKQbJr+Fgq0lvaZTQRj\nPFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOY0A7dNa+QTbFl1bx/Z8Mn366YOvpdzYtIom/QpcY6eAiApwNVu/ZJu\n8nIlfu8rCL9MtdsTkCD/7RLL6NMyxqVnPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAa/CLXdx9VcZ3lMWo4C4mxkrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdjZGZhM2YtMzdhMi00OWNkLWE5ZTMtNjIyZmU5NmRkNmNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzVmMjYzZmQtYmU5Yy00NjhkLTg0YjItMDVmYTA0NmIy\nOTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYafI468xTIG4jnfFDixNUtPB\n8DyrqyPP/+5ZwUQm82z2PttDH2AfY6bUCyQs2T0JCiCNfQDthK5HogAHMxLcwqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeZSLUPUPllSDVmq7+UhTbYP+4yQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCsMNJn\ndrYMxbTMFWODASTEBs/b+FRXTheQLmHtfWgz/QIgHZCWgAeZfDAIdu0I5+96EuNj\ny3ob4ag0elXoYgB21sw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2900", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2900` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAUrh/Y8GZr93c5ova/SKypoFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzODQ3ZThmLTMxNmMtNDBhYi1hMWU4LTkxNzNhMGFmYmE3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZlMmNiODYtYjdl\nNS00OTVhLTgyZGQtMTdiZDMzOTFjNzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQLUh/GRV9mQHRpKdUmHboYrUgwjqL9RAiWc0Hje+HQot9t66E8wwCuvod7Ym\nfPZSLbPazWbTCXNZSl/JgynuyKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzWACc+RLixrw/sPVAi38ZUdVZH8wHwYDVR0j\nBBgwFoAULKXNfwXTyoTIfLFh8DxVeva7sKMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDpPx2gZFpdjkQbp9ooESGKBkwxZWtufp0bmRshJ8jYDwIhAJA8vr+T\nzr5A/wogWrEqUBGUrPYsyJ/sGjTPIKCFYFie\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQsSwRD5RCeCD4o/eQr3BKhEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzg0N2U4Zi0zMTZjLTQwYWItYTFlOC05MTczYTBhZmJhNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbBX0MeR8+LnduaUQV/Om9fE+b6+6K1ID/Li1kwJnqQ1ky\nLCr19nMtUeuB8x8PlJGEii0uVVr82uLonFKXaBtqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULKXNfwXTyoTIfLFh8DxVeva7\nsKMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIkF7N4Haf9x7sykUjApfgESy1foOwbEfWkS5SSL86I0CIQCKXDHZSix4\nP2vDH/90EMjKM4xY8bhXq2VEsco+gSwk5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQvr3XN5ek/aDw2QPaOymCe1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZlMmNiODYtYjdlNS00OTVhLTgyZGQtMTdiZDMzOTFjNzNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmMwZWU5ZWMtNmNjNy00YzFjLTk2NWMtOGUyMTI5MWQ1\nNWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmSoBOujDtE8Kt5pQTWOyThLU\nL08piL8Rz1EsRkYHIwSC++UEFa9BBOsrhVlCSTSMpnZdvV6JGiPQWX34uHuhhqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzWACc+RLixrw/sPVAi38ZUdVZH8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDHMNC6\nJDEbygh4My6LCMahvj5smElh4IJF7TGHPW+E+QIgIah0d7H16ISsjHL7IB5NJjKx\n4NJ+Flq5wQlvk6TNhUI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2901", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2901` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAS9JEHAnlKYt2Ud+NaKpD4f3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4OTVlYTg4LTc0MTYtNDRmYS05YzA5LTg5NTMzODNiYmU3MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRlYzMyYjktMTQ3\nNC00M2JiLThiZGEtOWVjZDU0ODQ2ODdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELjkN0pzi3LS1km0kS0DdzUEbgXAFjWNKCsvFZvtEsQLGO11i3ZdekLlygtgW\n4r1m9UodHX/VRexHc+lmZJCLf6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU12hKFgeQWeBEQbk27tILmxM8LEMwHwYDVR0j\nBBgwFoAUC/2qWNfQb0AN0qaVxOZ0pxztM7wwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQC7rBCOfaQ5RNXF9hI7nCAAODZ+ZS/t5F36qE/dwlu90gIhAMtpr1Vc\njVKaEIAozXBs0/VY8/plxwG/Xh/Rba0ov5Yz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcNqx2qeYSk2N+UJwmk9/d5fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODk1ZWE4OC03NDE2LTQ0ZmEtOWMwOS04OTUzMzgzYmJlNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6DHjSHRD1vmwaWJLtR9A25os1JzB83y7RtfQLkKxLmmQf\nNfh4EYR0ge+f2UInT71xNN1W5WpD23/Nb7dcimxUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC/2qWNfQb0AN0qaVxOZ0pxzt\nM7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOV0oTDqg3HW5hIxRIR3+ZJ2/5s0QXckY1OqZfbNWDKrAiBFf2UQt1DK\nukxXA2fJF/lkb+PdGt7r4NUK6YIVZaqmSQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISATAyC9jLIbXON6YDc499yMsUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRlYzMyYjktMTQ3NC00M2JiLThiZGEtOWVjZDU0ODQ2ODdhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzhiMzA4NGMtZDVhMS00NjU5LTk5MWUtZjY4NTQ2MWQ1\nNTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEam96SgD9vbv4ng+Jp8bWZP8H\n3f8gu24CjrcGpkTNpjuc/EBBBbQ6oTZStK3nZ1lwn5DMF1hyMNo05PGF40bOtqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU12hKFgeQWeBEQbk27tILmxM8LEMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIA6SMQjg\npr2vhBG/GhP/c5d/+jHOGbjnOCShU0/h5a64AiBOtdt6h5aKmHiYlz3BlwPZVHTf\nUCXCE4q1byc6Ni6lgw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2902", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2902` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAe+7MeOhhYMa7wnSBPQa6ZXfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxZmUzNTVjLTkxOTItNDA3My1hNTRiLTkyOTA4YzU2OWE4OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTlkZGIxZjktZjY1\nMi00NDIzLWI2YzMtNzkwMmZlM2E4MzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV+0boTBnUouzKC1Ux0/ub+10LI95KU2pJg2hVLfe0Wu7AWEJoTTngNkNLx/J\n8Y3RT+AupEczoyUQ/m29dfDjnKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUUzbD2ytdNjAGyWq0nzcoUGGp7wwHwYDVR0j\nBBgwFoAUeM6VKOvoqNzc6ZFDuFOcpOQfmIswMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDoJNvltreMCQay5QHJYQieSTTzSowd9b9fSOdv24LODwIgHa0UpgW+L4kTFn3I\nTzaAg2Y8ROXYuJyKVbuPzpnn83s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAef7NitSZJ1Vqi82/Uv2btIrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWZlMzU1Yy05MTkyLTQwNzMtYTU0Yi05MjkwOGM1NjlhODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbEDtlfS6etv0+WH6rNHJelW5Ookeb4AldiMgC0GccfM4C\nuhCUK8Qg0+1mmELPrjj32tviCtGVOxb9+qR38+Avo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeM6VKOvoqNzc6ZFDuFOcpOQf\nmIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgb9fIx3+l1ADVGGMh+m5kojR2JIWHfD7FPxkkTpGQ2VQCIF6VAI1Uj6D5\n57EHbuF9nJSycH30mkGprXOu9zSbyYex\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAYd7iK9ed45G5Wfb4Q3napjzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTlkZGIxZjktZjY1Mi00NDIzLWI2YzMtNzkwMmZlM2E4MzU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmIyZTE1OGMtMDg5OS00YWQ3LWEyYTgtMWEzZGI2ZTk3\nMjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX82QgvI74pfcy9/8a2zU+4YG\nFVwWqSmBuXy830SxxZ2EAnRG+7JSDqkG4n2UF7/1ArsVKEZac4DbTg0ESnGmYaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUUzbD2ytdNjAGyWq0nzcoUGGp7wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCRbL3V\n0fDH63fcc/Cc5LDvb4iXU8uz5Jw4cIaPBX/XNQIhAN/hh7Jf0dJH4NbeYgNwkYao\nCfFd+zEVjbb3Dhmei0Fx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2903", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2903` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAbOe/1elkd44IXysWhehQN5tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxMjgzOWEyLTI5YmQtNGZhZC1hMTQ2LTRmMjA3NTE2ZWM1OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFmODA5N2UtMzQ1\nOC00M2I2LWExYmEtODQyYTFmMWMxYTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMoOlGd97RkmzInIzGsrKkdYRih1AI9N2pu7XxRt20r511aqr/0xgvVTHlu/T\n6njValpS65nJxTRA/qmd/Xo3J6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDEJnOoYlsCyT8jsIkY5SOdm70lgwHwYDVR0j\nBBgwFoAUBUxnVh23Zb/z1hTa2bkNsh0t02kwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIHvVIlIHcelKQYAcdk+e/Hl4FBg2QaGf9wPgyZipiXKvAiBa\nCGDZYZUDoty52j1EGjnfNua41+HLLJ3fZIdJ53xZ6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe06JCFZLU80sNRrOGOK0Te3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTI4MzlhMi0yOWJkLTRmYWQtYTE0Ni00ZjIwNzUxNmVjNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRzB0UmnHlGALC/0leE2AoGmm/wwdLbtt7BrQYGTIKXHyR\n5Wzblu3P6FclcPTn2oyFGyt7X4rFk7NkluLNbve9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBUxnVh23Zb/z1hTa2bkNsh0t\n02kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNA/T8GVbqYRK0diySJx265r+56D+6fA7FXi5mtL10fsCIQDytkfD8wOx\nyYKbrehUyfRe1XUGBgkGIUsZR/85RqZnwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATjeobtcpT5bSAzcc+8IWUk6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFmODA5N2UtMzQ1OC00M2I2LWExYmEtODQyYTFmMWMxYTcxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2I5Y2VjMjgtMTNlOS00OTEyLWI1YTItZDQ2MjYwMWJj\nYWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIuXr1agZ+7lxgsZPdCsyld9C\nASUtuUfklInP9qPoE/ftCTdRz+1TliUgind6YU0PI5vXlZIGt6pT0QEHo+758qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDEJnOoYlsCyT8jsIkY5SOdm70lgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAwU31aA\n84Mg5LYDhy1u+IMtNtjIlr6ktiBVZsGR82kXAiEAkKRwkFwpErHBhTOYgv/yEWoL\nwAkQe0v4tLq7nQiXBk8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2904", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2904` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUGhGsme3JpGdoa8oszXcyNrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0ZGRiMDdiLTM4MzctNGY4Yy1hNjkzLTM1ZWFhNTg5ZDVhYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjExMjJjNDYtMTBl\nYi00ZjU1LWFmOGEtMzkwNmM1YTQ1ZjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8VYnS9yOWi89nX1iq174/zHHn1G6lLvocMdDWt+HNuQ4umf4Dhd0bT+u49o2\ni2eTvLVjRSLFlGrG7pIjtB/2FaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmrusS/Y8dlqg4INa3oB8SNLNCPowHwYDVR0j\nBBgwFoAUtw5OCABa64+xlM0MGDhb5H3I5p8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDvxyWaLOx0qtCl6kXM1syXiEvVXGUFyL1bFUpmIywpnAIg\naQLTbE86u+9QvH8DqUBpcQf5Bkf59debz92o0O/YFJ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYzLYMqPLd8aPVj1kAD7RMKDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGRkYjA3Yi0zODM3LTRmOGMtYTY5My0zNWVhYTU4OWQ1YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUUuSraHdno0vBoaRkm7s33VOffn+1QEkIs3nE7Yrb1Ph9\n7XeognWg6LMhGpfXj0F534jH1RQnzNEUhEPHdknwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtw5OCABa64+xlM0MGDhb5H3I\n5p8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI2E0FagoiTZO+fefx/XC4J8Zn8Oyzoc2GGU4L5UoVknAiBxCX7ys1to\n88hcUsKgaLZeyT5EdBoHY5F31uZ1OccPPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAdOhY+PHf1KAoSRE0IKyZGjpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjExMjJjNDYtMTBlYi00ZjU1LWFmOGEtMzkwNmM1YTQ1ZjYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjBiYjI5NmUtNWVhYy00MTBiLWFjMmYtNDhlMzIyOTAy\nOWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHXZBior/caDRoTcDI1rhZ7FG\nlFK0E/+Z3rj+avnvfES6EjiznYTWJqnB826R/XweC/NETo4dX76i76SFLDgoCKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmrusS/Y8dlqg4INa3oB8SNLNCPowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBcPJu4t\nyvIaVIc04VJOCTpwTSVF+iqIqe/8EocxGValAiASgAwkbE8Nt08bCA0E6xe7eUPE\nSY0iiwBeb3uaMG8yfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2905", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2905` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQbDGq+aBstSdqrEynqcHNpxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiNjBiYTU5LWIwMWQtNGMyMS05NmVlLTE5ODI4ODRkNmI2MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJjNDUyY2UtNjRk\nZC00ZTZiLWEyM2MtOWE1NjliMjlkNjQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERNRuZ1FM/5mdXHTLOrsF77ANgDmu/zEaABIkwwbVSaTAUOr7Gv7k2zSsB5tM\n4fMH6hpiUkVDKNq5jEeryK1pm6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEkMu+NalzlITKVu1o65KFXN+hU4wHwYDVR0j\nBBgwFoAU5H01Uh0OGp8HNjfjBmVD6YF/Y9AwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHoptGNN4L2s\njC54UsYGma+DVEP/g9yTPzm6pmeiK456AiEAuaRZ72IgSsn01615iHr0ugBD4Sbk\n3dlRBKrqS+Ei8Y8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYGmAnjmh871KxmAg0FVzywfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjYwYmE1OS1iMDFkLTRjMjEtOTZlZS0xOTgyODg0ZDZiNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8jDJL+cNuX3mYMrwaxCwKsZU+64lLEFAO0Ky3lWPykZKm\nPArhCPFrdRfpGSHdfAtDNh+2LbRvob9XspZlBpzOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5H01Uh0OGp8HNjfjBmVD6YF/\nY9AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMmecddpBJWFiGdFupTwo5slXm3rLErGgmRls2qvG/7sAiEA4SoZdtdu\n2e9qD0LRQIx/7rZ3RO7Xub6uGCvWnrkUdws=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVhMZu5Ya+Ml++G7UiPnC3t1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJjNDUyY2UtNjRkZC00ZTZiLWEyM2MtOWE1NjliMjlkNjQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjcyMDQ1ZWUtMGRkOC00MjZiLTk0M2QtYTU4OWRmZTc1\nMTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVYSY/LiTq4YT4WuzBh1ZTVt6\nlUN+GtZGdCB+c7dC0/vfNgvgW06DxlxqvlAguq4llNloTVL3ASZeIdCp0aaIlqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEkMu+NalzlITKVu1o65KFXN+hU4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIERLNPf0\nDHSFwhPHoaL53gFMAPJ7Md9R+C2MAbX5EWgJAiEAp6imVqG6R1J17pLSjg+57+SU\n/JP42QyNAfTsBBQDxzM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2906", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2906` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAaEeQ4ZsCMTTVJpMAZOOJj8cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2YzBkMTFkLTM0YWQtNGY1YS1iNTlmLTRlYjcyZmQ1N2E0ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJkMTg3OGUtNGU2\nMy00N2ZlLWE2NzUtNzA1MjM2ZjdjZjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcU7scpD4l1z7c0upEuYI6Aogr+hd3vXT8woxeR/lEjwGcAWQoKzGDCgqOAuQ\nqc9Hz78CpDJV0GtdFs/hNWCn26OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyqK3MGNwCt3SpS5Rp7sVwCwmfPwwHwYDVR0j\nBBgwFoAUbQZdFSAzv1aA14sZ3mMNy5jFUCQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIffrhTRrL6daHTGvD1DKDiUV9hQAqsgOfbUvNFo2ypSAIhAOXKEizRrRlC\nzjEmqzR+WdWaj1DWvaejofLUcZyJ25QH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS0wbnRZbcn/9FykSwE1QRAsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmMwZDExZC0zNGFkLTRmNWEtYjU5Zi00ZWI3MmZkNTdhNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFPcspDNoUCnd6FwCWn0UAyi/zVkVw6a5P+1FrV+rMFMLw\nCA5QXWwMnGTlnivV94NbcPltQnAd5WtdZXrrupKso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbQZdFSAzv1aA14sZ3mMNy5jF\nUCQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJyXHPVLDfIakivKlnA3g3H+xU1e3ibQaQut+cLa1+QeAiEA7J6Kpayw\nF2T6P89oM2nUAxqFuAE5CqzXtq7YFGdXaYU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUJYX/ZJTLA/MtAk6z0Oj/MrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJkMTg3OGUtNGU2My00N2ZlLWE2NzUtNzA1MjM2ZjdjZjkwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzNlZTk1YTYtODIxNC00N2JmLThiMDgtMDk3MDU5YTA4\nM2RlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzg0ERcTZniCvhBx6EEuS4pbf\nd3QWF2G67c8uX7S8zg+0XOQrMj7QPE3LsCLac/FCkUK4tlJQQXafbrx22N0WcKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyqK3MGNwCt3SpS5Rp7sVwCwmfPwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIEQ+nlDe\nFsnknzfzBbLs0WMDD6ylEtaxlVFWkyeD5FqkAiEAm6euwc1R6G8+aO/iCg5y6r3C\nxYn5AfY/j4iqFDhb8UM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2907", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2907` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISASJze3G0U2J++dX5mDb165jRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5OWM5MWY0LTI4ODUtNGM1Ny04ZDYxLTIzMWMyY2IyZDI3MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE1ZjNiOGItYTA0\nNi00MmY5LThjOTQtNGM1ZGYzZmQzOGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp8NvtYWa5czrSDt0SGvCCEW/8UyVZfDYC0hx81CvbZ18QnkHsehbuaKluE8g\nXkzsgNMfWovLAvvjvK57Oln4+aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAfO6X9pGbNTxhG0p714ucD1C5hkwHwYDVR0j\nBBgwFoAUtektRG08IjuJtdeyGJF4ZOx3Lr4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgKcLpT0PQj1Xr6yloTWGzFndtBMQFvWnJC5ZEwES9qb8CIBEx3NMSqnU4\n8QxzG0+bhyb47snE1KGY5garzt40nKq1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYB3dMt1wJ4krx4tm/VGYE3YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTljOTFmNC0yODg1LTRjNTctOGQ2MS0yMzFjMmNiMmQyNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+R6w3LfBoPYjCMvdOe0fiwasO47DI9ELS2+rB4KMHhij9\nvtiwWp6inDSTT7uXUD8+R4zzApau163Ac8vq/1v7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtektRG08IjuJtdeyGJF4ZOx3\nLr4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOBDbNan24UEQN/kTxhaOhadIFrSCIUMrUvhqlIG5ScjAiEAriqB12Jg\nsw4vIqhBgpuBDFN6LghJuybz2aY0d1rpwsc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAdGhE+T2Ba4eoobiq5et3Wk4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE1ZjNiOGItYTA0Ni00MmY5LThjOTQtNGM1ZGYzZmQzOGIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWRmYjVkMmEtNDdjMy00ZmE4LTk5NTEtNDYxZjQ2M2My\nYjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFfNXG5T4GvftRISzKXdxX8UH\nY/We+nySKuyyNCWe3eVY2X7EKrDENn+pcwmIS/aKHalZ8TXQzWTIYD35UKnMHqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAfO6X9pGbNTxhG0p714ucD1C5hkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCQFKXc\nP7aMb58pAwEXpoHTmRaRlRk0fQ7IhPa1H6vxBQIhAN3jNPd5F19zlebYm0YxleJU\nVwJVKjdq2kWIqsbYUTlo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2908", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2908` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARZ2YtM5GZ9/Qh/Lgg8cYRxjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ZGMwNGUzLTAxN2ItNDY2NC1hMjVhLWY0NWM0MTcwODMzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlmZDMzYjYtNTNl\nNy00YTdkLThhNzYtN2MxN2Q1NzU1ZTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3mouneoIQzN8CCmvt8NYoWyK2J0/vWa7pu5RFytfIbdg7fEKY6Gw9KDvquTy\nwNFfYEU0YSkPhR4j0g5waVrzWaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOBupJjg9/kc5/wWGEjBItoJj2ZcwHwYDVR0j\nBBgwFoAUVVVo25iudfLqHOfudIOautEh3jMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCeT4AdQIjyXEB1Nks+qRZWMD9gpZF4xTe+YuFPIdrp2QIgdBU5MLOf\nsSY1psz29cZxSmaOr1NRhuilVLvu+dv9muc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASwNLxHwhJW5SL73FSiPmALGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGRjMDRlMy0wMTdiLTQ2NjQtYTI1YS1mNDVjNDE3MDgzM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzbnyQv11DSEIWc/E/u3U0SrT9Se62xi1PsuaBbx3k5lcu\nWSrVoEh6szNBbsWbSPe1OLDJqRIYXOrYHcFGZKmNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVVVo25iudfLqHOfudIOautEh\n3jMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJMUiYXAk/ReEJXV3Ta0YtJZt+/w0aQCh+6R2nAUKyQACIEjpDmOXkY/s\nxFWJzElsIncEi77mUR0zZoW7C3TWxhXu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAejLRJRe5O36ftFIRDOtAqHeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlmZDMzYjYtNTNlNy00YTdkLThhNzYtN2MxN2Q1NzU1ZTg5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWRmMjUxOTktMjg1Mi00N2YxLWFlODMtMDI5ZWFhMzdj\nZWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWITRhBIMqHhma8DBEosZT9Pi\n3BMKDH2H/ROQI/G7EV5F34YG7ZTnkMicEOIyDHwmH8MnTM2zu9ZgAHVkFeWZ2qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOBupJjg9/kc5/wWGEjBItoJj2ZcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCBuk+c\n+tXqDL7nHC3zrSlTibAxglApyH+ktGgrOLJMPAIgZBpdN6frETnqDsILkGgDYKen\n6Kdz8Q0QFAWOSy2G45o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2909", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2909` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAXdZBNlSRMCaCHoyr10i2PwLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4ZWMxMjI4LTQwN2ItNDRmOS05YzY3LWRmMWUyYzU0ZjdjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNjNmE4NjctM2Ri\nMy00NjVjLWE1OWItMWZlY2M2N2RmMzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESgjVon3xQV/+HmhYIYlCl5t1/6PoG2dD6nqJy1xVC6rW4Q2MJR2UrMCxBYbI\nRTjBrfBb0ascBHXgtNe07SU1DaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf16nsSEzjOUUdDWs26BpskQXLPswHwYDVR0j\nBBgwFoAUUOFozf+pZM8g2QVjrDmVE4pVG2AwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC8oOrb4cxzcLbF374jT+3mFJ4KGHZ9TG2vViQn\n7URdrAIgS5ISwqIhB/3BAhJGJJgkBvRyqqb/Vhq+z4TU02fGejc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcYdUSZySXsSaZ6t/mYiJaebMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGVjMTIyOC00MDdiLTQ0ZjktOWM2Ny1kZjFlMmM1NGY3Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRbReYFdr5DWGLq1Si1Cl/x+vAgGORXRz//uIutG1BEQIs\nG4gqkEQyZJ9QXKHMSobPFpPBwCNQXnRW/54+oywIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUOFozf+pZM8g2QVjrDmVE4pV\nG2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSw1V5ivTfnpU7cl2DLULGbEkM2ESD2/fk1XOJRwxirsCIDL8psArnCvG\ncAt2x8ZT2vKgwoJFaPKcEVabzxH6zK2v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWUwyjZeLd0xreLGi1gQMkjyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNjNmE4NjctM2RiMy00NjVjLWE1OWItMWZlY2M2N2RmMzFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTYzYzYwYTUtODQyNy00YmY1LWE2ZDAtM2ExNDkyY2Nm\nNTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESLlXluLP31gEjXXnjQpNZwLE\nhC6+U/Xnp6eGCDf/kXBahKhEdLBfJtLfo0QgsxfTOSDh8zVZc80Im9COe1wD0aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUf16nsSEzjOUUdDWs26BpskQXLPswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAIjzv3a\n2e3610ECvmpkzGHH4rYYOqjdi3rImNSmFIY1AiEAorgvMYiNcwQaGNqFCM0hELFu\n5btJLpVTvhmKHEUDOCQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2910", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2910` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAen23kK//VmZl4jse+/8jSgrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMDgwNDMxLThkYjktNDVlNC04N2ZlLTFiMTNlNjhlZWY1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkzZmZkMDUtYjFm\nNC00ZDVlLWFiZWUtYmI0NTczMzY4NzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM2zqYqZ0FIiayuEDjZNGUxS5SO7TtYNQafw9Wedy+fl87l5TWURzx/94T6wM\n8EHk4HGcSu2cAoAPY7ad2mLIjaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp5bsxguVoMTnXG0mbphCAHmrXnEwHwYDVR0j\nBBgwFoAUBhASiH1fYU7tShQZ7cyQ0/f88WkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDwjwNvi5Ldv2xfuAOzXmoqSkIkT2tqeBj4evdp\n9uxfbAIhAJNKCmvi7mAGzbEp+o5xDH9t4F2cJuAIUL6zca7+jhJ8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV1YH4QlQGkg1wacTIKlZj5sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjA4MDQzMS04ZGI5LTQ1ZTQtODdmZS0xYjEzZTY4ZWVmNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfzhThnCZioIE5i4RQU6LWEnJ0biv7G30j2IPipLKKpHyE\nv040ceOnC0lMg/tUHCmPB7kaQEFPKrHPUQfQe2AHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBhASiH1fYU7tShQZ7cyQ0/f8\n8WkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIOLDlS3hRlcu9qYue9a8Tndk4kM/6wguaZkJnEwnvApAiBBtcvg82SA\nzRtFbpTZvY2kjid83HKKOJ5qtCWs190dPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAV99mf30GGAeaHsJywnphLqPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkzZmZkMDUtYjFmNC00ZDVlLWFiZWUtYmI0NTczMzY4NzAzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTJhYzFiMWYtNDNiNi00MWE0LThiNGQtOWU3NGVmYzBk\nN2NjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESBbyahZM/XSnbaFqP9RWhLlv\nq5yyB1DeNm5/CgMkc/hF5jdh+Ox6tgO94VIQqkqUb829Kjwqi0E1PUuY9DvIb6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUp5bsxguVoMTnXG0mbphCAHmrXnEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCbJjmX\ntYiJ3A7gQR97KpEH3DjefeKwiYfIv0nli4jTcQIhAMrMmHdaSq2+TRHEnFprpXVq\nQebN8fzq72OP11vBSWF9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2911", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2911` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAfShzgR1IkeCcIzGCcERGN9jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhZjY2YzRiLTFlZWYtNDYxMy1iZjVhLTEzNTU1YTYzMGQ4MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ2NWZmZGUtMGMy\nZS00YzY4LWI0NWEtMjFhOTY1OTJkZGE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9egpvpAjEuzflytibtk1ryzkXbONcm2llrYhaSe+d9AMRCFm3R9prLBE5t8C\nBHZUqPaohHd+lporfwzGdo9rJKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Lnx5MM+qyn7KdrZH4N4IQqGZ7wwHwYDVR0j\nBBgwFoAUl+nksLGCuxy4B9fzEBp4gwr3fEowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCKlXLmcFoomIslCGAz1k451Yb5gey77fCTWhfk0K0U1QIg\ncwcqIy56febd60EdN/UBuHcZDGQg6NqVQ8P+I8Hc0TE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcDhN2Yiy71T0/LCQu+whL+GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWY2NmM0Yi0xZWVmLTQ2MTMtYmY1YS0xMzU1NWE2MzBkODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARb+ity31bW0AGyddJMIHzBAHEAfS+PS+9MOXkh2g+JNm36\n/H+OQuA+0EHghNYN7oisGsHtObJbx3FAqBIkr0Hwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+nksLGCuxy4B9fzEBp4gwr3\nfEowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZPW5XhZy4hMxQhHvJw5mEA8ga/lTBAKcP5SmXgpLVIACIQDEJXYE0nLY\nmtELngkSmPYpRF1drC+jbiOqs1mKWDCrsw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVZPpHNYO3wjabYHDNge3m0xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ2NWZmZGUtMGMyZS00YzY4LWI0NWEtMjFhOTY1OTJkZGE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTQzYTFmYjYtOWZmOS00MTc4LTgwZmQtMTE1Mjk2ZjMz\nZmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzrPbe0K8nhbc6mq6yHfrvhRe\nj695ikj9Wg4IatOpYmdVPI9rPE2Yav/8AWnxpo/tywgYLc9wLLbjOtWZUga6JqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/Lnx5MM+qyn7KdrZH4N4IQqGZ7wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCwNZ6H\nO6lzq+sscfIWyuMMPvDfryd2iycL9nTVnFT6cwIgenNPfsgUIMuxUzxuEyGI2phx\n74ljOZSSxexo96BwRXs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2912", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2912` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAYlxue/hxoyIM/e6JmNjVeSuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0NzJiNWY1LTFhODgtNDc0Ni1iMjAyLTM4YzRlNzU1YjliNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU0YmNiM2MtYWNh\nMi00YjA5LTg0ZmItNzc3NTNiNGVhZDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAE05VxwVxd0QOHeQ5v1n74Zu1zuSMb9O8AYc855tCFm8ATIu9wxUZ2Idw9zq\ncrlmDeLkkYQ7YuT7IkXYhuxpzaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUIbhqjMOV3cctj1K1/Fp+2cyBl0wHwYDVR0j\nBBgwFoAUsNF/qy6UUWxX0ygvS09ZsZopUn4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDTfpsydAAdDxyfQBtsqNFs/PbWzJvi\n11f2cgZ0lSdtQAIgUkKX0YgYqA3VoM/dAnOHXglTf0FcprmyP/+9qxH/o6k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARXlvd9SI7wGFIoCCrhmhNe2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDcyYjVmNS0xYTg4LTQ3NDYtYjIwMi0zOGM0ZTc1NWI5YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxaEII/I/QwfMQ7ZWQEWT6smOl5yJYb1Kg0aKtFnGZBKE9\nuXQb88eRvgiQg1LMcyz6yM5qTFmWFV1AGaXZHYino2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsNF/qy6UUWxX0ygvS09ZsZop\nUn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPxRaa227pjSaE9eBcfUJPSmV48BO4IetN6w/OQfsxN5AiEAnXazYt9i\n5gebvZ+ObgU77gnDpr9wKqMjFBeUnQa3Bng=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAejMPSZdCve6zHfxaimkeQ5lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU0YmNiM2MtYWNhMi00YjA5LTg0ZmItNzc3NTNiNGVhZDU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmMwZjQwNDktYzI4Ny00YmU5LWFjMjktYTBhMzVhYjRi\nOTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERF9NV6Ijr/imagxZC9o+bzhi\nCOf1BxQ2YSDWIHKSryAZPNpI+37iWudXMbDzvXcWwAX8lI2gSsllTWLBdaXXb6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUIbhqjMOV3cctj1K1/Fp+2cyBl0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCID4cRjIy\n3GHWRmm6tXEEuYBHgprxnk/0zrS6wqmSTVoIAiEArY3vmNdOOgfwfiBIb1jr8UMP\n36bA3EJFQRoAcuAQEWQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2913", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2913` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAewFtw2zkb0oNLwiMBcCfXJhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0ODdiY2VjLWE3NmEtNDJmNi1iY2FmLWUzZWYzODNhNGIxZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBlOGE3MGYtYmU0\nOC00NTE2LWJmZGItYWUwZTAyMzZlMDFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqPCiJPPbVR90P/BfRBGtyda3qIR+9ouCPNpk534uQz8IzdgyHtPJUYLZpedd\nqjjjM1e9xGqnnqeUnKDuKz8cp6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2+dYZPugvobG0O69jCh+wSZ5/0cwHwYDVR0j\nBBgwFoAU7KCHj9khtKK/FtSsc2LKqBJdUUEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD0nkUfC+6eqZOzhhltD3FKT2wuZCwo\n+dmRr0ccBN/6SwIhAMoJwAm7Up/SO4/25XNcjKSnRHHt17e+6jDSssn7CIzT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfRMTmXdFZt+uPmrB1WMQVuBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDg3YmNlYy1hNzZhLTQyZjYtYmNhZi1lM2VmMzgzYTRiMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAa6p7VCUCcwD6O+OJOqPWQ4SaEf9fUsdEPR8DRxSqj3Qu\nSxf5tny6Hp9HHcTypZmMBcmd5xzk8OtKMYJVaivTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7KCHj9khtKK/FtSsc2LKqBJd\nUUEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANQJXPOFfCTQ86cOmcsVrDKgl4vboFTmN3SgMV+BQNWyAiEAzSC7/F7a\n0wFoAMQDP/621DvbLcEq2o/M+Ciyg7qSnbw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAU5T7p+zRzQU95l4QFp8WQMRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBlOGE3MGYtYmU0OC00NTE2LWJmZGItYWUwZTAyMzZlMDFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGUzMjQ1MWItNTQxMC00N2UzLWFmYzktYjQzODk1NGVk\nZmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo6buwmq1OMyV0dTbclwckcUD\nX+ffmrKXWjz/oAwbND/T03gM117utxbGknA3vIha9Rkvo5ft6iMgrc81X2XXhqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2+dYZPugvobG0O69jCh+wSZ5/0cwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQD/NYmW\nG6Y7dsdpQR8Otz/kyMyAl+LF/vHQw8fBZjd4UQIgAPu5EiT/DLMYW2Kpk6+HRk0g\nyp2gykS7gEnd0P4mjaI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2914", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2914` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfRGk34R0gvYnll+uGPlGFQSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5ZGMxMWNkLWZhNWEtNDk2NC05NjI5LThiMjYyNWFlZjliMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZlYmVmZDAtOGRm\nMy00YmViLTg4NjQtZGYyYjI4MDUxNjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEprgMbQ3mMOa4sMTxqdwlT/f/QuzixpyfuVD8krsPq9ygTwxi07ogeNHNPrjH\n9chckq9u3k/ImIXd/R6rZ/wUiKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULw7SMEc4fQ9ABgGIzY/nbEgWCZswHwYDVR0j\nBBgwFoAU6nZfAKWt7qZamd72wU/KhAmcfk4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAiTd/JRgyhI\n9TAjlGBfYTvbzWwlMLSyfvISXsSyua3TAiB4Andqmdxukn9hmZ3GQQVUSVXKqOQX\nitIc47JMVvqCzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZruwMdFvKynyV68Juc7S+YLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWRjMTFjZC1mYTVhLTQ5NjQtOTYyOS04YjI2MjVhZWY5YjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5m9BK0EW8NxNNDUSrzaskgAnunQL1601j9tRlH6UhjK8l\n64MsLh2EG5qn6RuzoatwQwvu7Nl1ZJ+ouNYm70SOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6nZfAKWt7qZamd72wU/KhAmc\nfk4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEuIXJSj8YqUeT9zoWI1HjQ7hhRuc4fZBEdif+t7jOtkCIF/hcZVeIKnL\nGw6k/Mw811ENn6ZB3km8ZJIsumWXGJAt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQiM4Iyt8Zw1qhqvuPiMm84yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZlYmVmZDAtOGRmMy00YmViLTg4NjQtZGYyYjI4MDUxNjNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWVlOWFlMTItYzgzMy00MzBiLWJiNTYtMmIxNjMzODkx\nNDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6N70f+675DM+MyoxqKJwjNrf\nCrayhC0XIl1uVlh4F3802yHeeD+WmN+G746aYrBKRe8IhkHkHDIiB7igD6XPDqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULw7SMEc4fQ9ABgGIzY/nbEgWCZswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIErBGN1d\ne8tqcfbbOUS1qyHoImPG9GoU6ruzzgEJNsh6AiEAzGoLytx1/jJoZuzys8UNlcPg\na6JmEMTJPxH2w1EkLyc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2915", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2915` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfq6PNEUhxp9stdt00kHZRJwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMjlkZGZhLWZjYzUtNDFhMi05ZjRiLWY1MzYxOWI0OGEwYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU1NWY4YmUtN2E5\nZS00ZjgxLWJhMDItNWNmZmQ2Yzk1ZTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpEs4VoHsX3NUWREUUv9fccNBAU502xH2AJ93zlUHhx8mdgZKhJVAnW8kFNLT\nafnruXiUcrLKWe3z4fVBbfmh26OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1tp6d54Js+xMDYVBejLw1P3qq4wwHwYDVR0j\nBBgwFoAU4jQRnq6Z5mbqioCteOEDJZQGrGYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgVj3IKZACj+GcPQ4N138bc+2VnUzl9YXWY95jOkG4mb0CIQCGUCEMyMnX\nYjOnnmETCdRML9MIQkP5xWLq1tcciyb0VA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAafcaomZ9U1JZPEomMf90X7jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDI5ZGRmYS1mY2M1LTQxYTItOWY0Yi1mNTM2MTliNDhhMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCKIxph6fa/pb8HV2RJb8cT+i14bGqV6WtWqXTjnAC8KIT\np/OtAIAtgXlaFZY8MXtNO2q10XjalaFC9nVM7Skvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4jQRnq6Z5mbqioCteOEDJZQG\nrGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOm9A9C7f0I/eesCsypsCgDHD32LtvazKYbEsVQ/bUiEAiEA+OnRva18\nWYSx9VmOj80pr64t5psVf5hmi6U5NmwAiFI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASZ0ZdgUmOy8gc98sG4OM6rYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU1NWY4YmUtN2E5ZS00ZjgxLWJhMDItNWNmZmQ2Yzk1ZTZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDIxNGE3ODMtYzNlYi00OGM4LThmNDgtZWMzZTE0M2Vi\nMjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb1THJCNpfRpzxd3i1oHMuVoi\nlmAQs6bylyXfjDHRobgqr+o6EQ8e+OkYEKDAHDWo64WrseVRKZZG4DLbedkP9qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1tp6d54Js+xMDYVBejLw1P3qq4wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCZdeDd\nXCXD82XWGAgN2LTUI/pTPBC6ICmT1y35zGxnQwIhANUB0UhD8W/MRfEV9YjAYzjx\n2P7LH+5pePxbgaPB9oE9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2916", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2916` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISASbdoBL6Gz2Ak07Ujuci2SymMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmNGQ4NGQzLTdiMzctNDY1Yi1hYWMyLTYzOWE0MTk0ODFmNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjEzMWQwN2MtMjE0\nOC00MmRlLTkxYTQtODVmMTE0MTY1MmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzk2WXePWoguIgIj4YXsEE78fWbCtuC5KWjYHpV7L+8zFgULlQrUSl67Er0XG\n64jPl4F5N7v5jUuSoUBxN4ArmKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoeQ6xyrJBTtIl5BvdZFSGyHs58AwHwYDVR0j\nBBgwFoAUjW1qIWs1Daw2oaV8Okjt12aK0SgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgGIE1US+Ik0wuUR32l+m0P/DnFJTIIdsABAorBQMxoiECIQDOn6nZNOFy\n/+WqDsIfRbGPoijqt2VLl3gSlrn4dpBdpw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe8QKPORNescLbgmRIsaAkSSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjRkODRkMy03YjM3LTQ2NWItYWFjMi02MzlhNDE5NDgxZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARg7YHiBQVULp48oig36rOYazrMqqjYNOKi5Ccy98GCxsdL\nl0DPnFmCtEe8AeXedLfAc9J+nVB5g5deXgC02Vnto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjW1qIWs1Daw2oaV8Okjt12aK\n0SgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOGWHetHtP5F1K2i3ynRBp2dsLQ/4i7ojf2Iruz7kmXNAiBmhgIhx6rJ\nFyB3Yu9dhnShZkIoyzLTeFfqfT9e3OBooA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWDAjUoDkQeVx9T/T5KE7hDRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjEzMWQwN2MtMjE0OC00MmRlLTkxYTQtODVmMTE0MTY1MmNmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjU2Y2UyZDYtMWEzZC00M2VlLWJkYWEtMmIxNjY2ZjZm\nMTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBYcR73MvCHw5UKy+OlVIzu2X\ndmYKs5WQ5I5HrFvpDhUw3iZ+JOyjSBFkwI/VQ6gEHT4RZmlbAypwWzNZ5q2DOaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoeQ6xyrJBTtIl5BvdZFSGyHs58AwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGPu68y9\nCeOJHRZXC37/a/0K6ZYQvTW003+gAvBpaEBeAiBaPcJNvrrj1LAeXzgOdYw0SPMT\nVj6aezZZqay9vRJ7oQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2917", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2917` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAbVIsMQ+SwKTRaplTPG+YC73MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZDYxNWMzLWI5YjItNDQyYy05ZjE0LTcwNGU0OWQ5NjcwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzYyMjJlNmUtMDA0\nNS00N2RiLWFmZjItMTlmNzc1N2M0NDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeYk2oXgvq6EdIUV4oT7rEF/5t1Vys4xa95/uOQzzZuTJ3+QhpbTmTbCjdMf8\nF16XF/CM/buYkpUaxj9n9cSBJ6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDZ8HtmAoRtAmVviRpafThUv9+DowHwYDVR0j\nBBgwFoAUyjWbo/Khm0OiaBdQiXYNtETxkpowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCC9UlvgS3X5gNql2CYl9IOLv2+vMgvmie1s+VnBzx+TgIhAIdyDtsx\nXd3ylDzm6IjGahi0RJV/UC2oEQk66gaMVd2r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT5h0/WgrlNynXJa0CHkGl52MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmQ2MTVjMy1iOWIyLTQ0MmMtOWYxNC03MDRlNDlkOTY3MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGtyrhPf6F5UDhtKUpDQ1/vLduQkHH7VS+zxUagVMdfOd0\nia4i1qRL4UzkpzcSutAt1HBY6W0pVtmebHKbt4jdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyjWbo/Khm0OiaBdQiXYNtETx\nkpowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI/B/3S0NGBVqJAwTk+b2ceKvf3zqfCtVn4WEwffqlOmAiEA8vuruN2X\nSJRysr+DO+lSAYLBT7pc81kxglh8Acoron8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVm5HvjMfhNgKqlzmhBRmY8OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzYyMjJlNmUtMDA0NS00N2RiLWFmZjItMTlmNzc1N2M0NDA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmVkYTA5MTAtMTg2OC00NzIzLWJlMTYtYmQ1YmQ5Yjdj\nNWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsmUk4fCUbip2qiTMGpJV5R1A\nA/ABSDam0ite338IRaATXASDUFBaRRvQOXmhnmFFNN+UJe9ptl7QyeteCoV/YaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDZ8HtmAoRtAmVviRpafThUv9+DowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICOK0npE\n6Jinbmbk/K7c6t6wt6PlgI6Qh5sk+9g9+uNnAiAUOqu3wLf9jfkOiia5WSu2uRAo\ngBJm/tBfk/MlPTo/Kg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2918", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2918` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAdc0YH4LMQWSSIg5kXZRxmwDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhYmMyYjVlLTE1NDctNDIzYi04NTA5LThkZGM5NDExZDhkODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc5ZGM0YTUtY2Rh\nZC00YzcwLWJjNDMtMTkwMzQwNGFlMTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmt/wYMboacsGS0VISJ75xgo2gqdKQQINh1iBRTdZPdntbIKz3BsrPECCSRYf\nGEDFImsNvVSH7bodPPyXOrmalqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTudj3RMUe4UB10ILw1vGt6UzC24wHwYDVR0j\nBBgwFoAUpH4dIaKOH4+DvJQmi2JM/z3Q844wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIEq1QNTFNzmCYKzwV/hOz9aYT1kZKOLK4ugQwyFh\nURngAiEAghbTsvOp8ZXXQQM2CIWu6KRl18IgyeD7+9RJJUFBlmY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYCreCQF2ugOwPkqvjshhXOGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWJjMmI1ZS0xNTQ3LTQyM2ItODUwOS04ZGRjOTQxMWQ4ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScrP3T095GQRq6xIp09UkSydx5dCD8igXsQ3vGx3Fa6m1I\nPheb8pvvNxcKqhcDDK5lR5Iy2AqDkxGlcPu8NHm/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpH4dIaKOH4+DvJQmi2JM/z3Q\n844wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGBH9rIofgXBM10tOw/mnt/w2/nafusMkUcQja6dUho4CIBEnnw8Gd2Xw\nGVfdySXBfaLctjNNf3b+kkJD+2I+dNn+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARcZOntNejeDoYANrhqruWrwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc5ZGM0YTUtY2RhZC00YzcwLWJjNDMtMTkwMzQwNGFlMTgxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzRmY2RiZTEtNzhiYy00ZmJmLTkyMTUtNWUxMTBjZDQ2\nODgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeLJM1bJA+p6noAaMygYw+JEA\nRK0KiwTFrQCvBRlX1ctdpAdnQLRDrhn6arqLJtK/ciODWQXRmN/vebb62Y/xQKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTudj3RMUe4UB10ILw1vGt6UzC24wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDzQ2nM\n8Vn7+/5jK9WzUskFCAaTGPv6m5opE1UsIbhbaAIgDjYidcbpbN8pec/6AKV+8aTF\n4zaRpfw0f0Uklx6fG5Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2919", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2919` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAcP6hXWQTH9DsxsqsBNrzeWoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyYjY4NmNlLTMwNTQtNDQ5NC1iZGQxLWVhMmU2MzlkYzA5NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdkMDI0MGItNDQ3\nMC00OGUwLWI4NmMtYzQwM2ZjM2Y5ZTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmbzYFoIrzVLUEUdQZYKi5YEkdBhPdPC1xedJ3sUuyrkRPKSllFrlzjLcX0G1\nO2ccb0K+p8CM2kI0oq3qXnAArqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5BILHECMq4gcvEyIQ+6LMYrwwvwwHwYDVR0j\nBBgwFoAUXmxCYXEUmz/iAfRoLBCCExiWCiUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCICf6FxJVyDBQ9Cgc++FTc2y9QwPrnN+gu7uRuRJW\nHlTkAiEA0PXA834y2eSBj3HQZ+fg7AX0Fep4tGtAf9cWDbjijzA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWNAKU/uHoq7qFHYsWYU+hbRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmI2ODZjZS0zMDU0LTQ0OTQtYmRkMS1lYTJlNjM5ZGMwOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASogHQMMxGIfLy3jmzdFvZ1VslZot1IpXqv/IcWkntCT9iN\nT+6mAW2G45TC12V35mB6w8W+J3BFXyKj/+0i1q0no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXmxCYXEUmz/iAfRoLBCCExiW\nCiUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUIEhxQTq1RHsqpv7UAYLsUDrvm5PJYJXtjWwR7/n7rUCIQCXjiXMKYwL\nID0FZ39pfAEHDfNRhbDrBlvfsThiQzTb7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAXZhiygh6FMbsl1WLRs8NSbhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdkMDI0MGItNDQ3MC00OGUwLWI4NmMtYzQwM2ZjM2Y5ZTkwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTJhNzQwMjAtMjcyMy00NGM0LWJiN2EtODViMTYwZDYy\nNWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENrLqZpV12jR1Nt1xNkD9MFf1\nJPsJPGy1OhvBTMf8o1g3+2da6uUaKCOBhaOhQ4ansukkyAKkfsb7Py4mtXVhiaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5BILHECMq4gcvEyIQ+6LMYrwwvwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDLu9pc\nNWIrRREXy/AERSbghCWMuZZlS5EOsugw1iLO+QIhAN84SETgaP+3wFkftHqCBNAU\nb4O1JI4+eHljkrkceN8+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2920", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2920` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAZ1/uUoD1hkBy8zSKqRgmMR7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4YjI5YjQyLWIzMmItNGY3OC1iYTk3LWNlMTAxYTIxOGU0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmEwZTVhOGYtOTIx\nZC00MzE4LTk3YTUtMzNhYjY3M2Q0YTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm037dFk582sO5uGA58UmsDrAA8+S++N55nQz09YFwY2wADOiCBV/LAivYwWf\nUOlOYtfE4D1LdBv586T4CcMt0qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFv9U8KEr0veE8B1ewEEV71LZ4XcwHwYDVR0j\nBBgwFoAUK1vPCfSthzWIR8iGGlBIu1xFyTMwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQD4OHvYP3I+6nCWSttLesA+gExfQLkSYTo4MhyTFHKIRAIh\nAJEZttFn2/tCVsux7bBVlYwxgt/VUb5MPQjsZDjXUbnQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYakW2/OwoaYl7B46HJPH0RjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGIyOWI0Mi1iMzJiLTRmNzgtYmE5Ny1jZTEwMWEyMThlNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/x/VUUkLuPDqyEZs40CQ0WxVmgE3hYQ3xSYX8FR+LEkdx\niQv27OYOChuPn8cw/SFh6EtQcrpnki/r3xh3F+qJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK1vPCfSthzWIR8iGGlBIu1xF\nyTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIwHOJyiwUjChV/QtaqnUZkCuSjwMWnEaoAp99X33BMsCIQCtAZJmoZJ6\nyrzAY8jfdI0+lG1sxF3fxizYxsO4+e/1kg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUyHFgAls7D4r+isU/5neoEJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmEwZTVhOGYtOTIxZC00MzE4LTk3YTUtMzNhYjY3M2Q0YTlkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWNmMjg5YjItNjY2Zi00NGY0LWI3MTktMjE4NWZhOTg5\nY2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECWpiPQsWPoqcY9jgLauQi4eI\nhWoiDRYanWQ3XiohH/1YCQFjV6wQ7vzJexDzvUt9SUR7GrrgNwKDETmqwZ5M+6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFv9U8KEr0veE8B1ewEEV71LZ4XcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDYCNyk\nXPwLxhpjWZh76ZEGBKnObYmGBQ7pnfAepPze7gIgDn6rzEiBcvzpMBjCEjZMMVk8\nTjC5HrCPby7XMNovIg8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2921", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2921` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAfQEc8L+8GfYjihL5hW/586PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3NGY5MjQzLTg2ZjUtNDU0Yy1hNTYzLTgzNTI5ZDNjM2Y0OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjcxMzYyNDgtYTI4\nOC00MjllLWJiMTgtMDJlMjFjMjYyZjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2D5SWbTCi2fu6OYGUqOQzXwrJPZrZlY7OuIBGnLE6pFxrjnBd4K75fhiubRO\nn6iNJvWa01y0EMsNiXWal/v5uqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiYp3GkMVTzBAaXYJxmI6HpfBgWwwHwYDVR0j\nBBgwFoAUAIaJg+Ia6ckOdT/2lKEGQ7JvyrQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDs8+jt9HW+P0psKGaZCTf92oO1q2oV\nViX4cg1dPvinPgIhAJsCwOoyb2EetTtFL05CJD+MUcOn6hM1Ep/GrQ3+g04Z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfAfA6kSsbS2aCbdx9t25JNTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzRmOTI0My04NmY1LTQ1NGMtYTU2My04MzUyOWQzYzNmNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1X8BGM/TJZ2J7t1yNOAN99LK1gpDNsaXoo23c+/JMIcs4\nZAI4cOudBKokePPo2GGbjdajL9DNUY/9TFva78BEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAIaJg+Ia6ckOdT/2lKEGQ7Jv\nyrQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOd/oLrgVWrOTZGD1ke4BVVGD9GnxiwYRUGZz6hffHdACID+xzJwOqXiO\nfelEdei837izjD44jkdW3/hx+2scDaRA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZQLQBLIDqv38WhJUdfKO5GYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjcxMzYyNDgtYTI4OC00MjllLWJiMTgtMDJlMjFjMjYyZjQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTY1YTA4MjEtODdiZi00OTAyLThhYWEtODkyOGY3ZTkx\nOTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8AVetI9tkEUjHx/E1nFXOu+w\nd+C1DVyqnlTuZXYSuuJReshQS0qc+F/DaH2Q2QfSkfHtPWDSG8RVkmafkv1NJ6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiYp3GkMVTzBAaXYJxmI6HpfBgWwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDdWkw4\nhriOLz/kwdkmh5TjXNWj9FGGmTOusMUMo9xbdQIgXNzwL1zOyBETDLw5Kzqm017t\n1cARsEII98gJ0orZ1co=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2922", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2922` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASzH+0ZINE86mql1i89gs2V8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwMjQ1MzZkLTc5M2QtNDZlYS04YTRjLTk5MDRmMDkyZTIxOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZjMjE3MDctZTll\nMS00Mzg2LThjYjAtY2Y3MzAxMmM4YTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnvyDRvmm1HRY6f0IxeEZJTgNogFGSksvuRymgpw0UI+ekBsKeEq8BayL9tYu\n+rdzleM4p3w3dgpNv3ZYbIPsGKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvQXoDN9H47Fecffb7F4PIUeGTwowHwYDVR0j\nBBgwFoAUNYdGS2R9K5cYDR10ARmQBaS3eUAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGBwydguhSr4e2dugDZpIoAmMpE17VRU\ngtRJmMBARdjHAiEA2Q8YkmqoDlUXjgR8hF2IXqT6UNJBJwcSzrM59omT4vI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcyWYuvLBGCcf9J8TOE7uhwxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDI0NTM2ZC03OTNkLTQ2ZWEtOGE0Yy05OTA0ZjA5MmUyMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUYFhv4UD3Xb/WC9yzK9+TidsmiR7d1BP9y+jFJXFygavM\noI5kjVirrwGs4dLayyvTvqp4T1l6bxY/Nx9GJZzjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNYdGS2R9K5cYDR10ARmQBaS3\neUAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJHhcSKHKfvDqpstkATB6IdDPx83ENJG8+PR0F4IyAZgCIQDZ3RHgznd8\ngH+/r67cfd9nzjdAe/kuq5SoYqu/osjpxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATFfXOP8nGRm/VnaFBrz0gSRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZjMjE3MDctZTllMS00Mzg2LThjYjAtY2Y3MzAxMmM4YTZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTZmZjJlOWItMjE1YS00YjFiLWI2NTItYmFhMGVhMDZm\nYWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqzNc7yemYhc0W4ysgXTcbXOk\niebEV9ZYqEbfD1hqRWIG1e4PohcK2TDzgQuS2SDWMVEczFtSI8AgKQaq14aJsKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvQXoDN9H47Fecffb7F4PIUeGTwowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCXENPe\nzerH+JQUF2h2sIkwC7O+pfzxQW5iPOed7gFlrwIgM0fCf/ti0XrV4g38It+ZoLNv\nLEK2q3pOtw6M6ElTwpM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2923", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2923` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARmDHz+fNXoWMy1wLm3+7KhVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3MzEyYzQyLTk5MGQtNGFlNS04MTA4LTJhMmQyZGFiNmNjNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgyNWI5ZDctNGRm\nMC00OTg3LWE3YTgtNmViN2YzM2NhNWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMonLyfKjI1gZfB5kbtnb2hmxL3hfdolEDP5XhyAwmjXTVz/MtS0fnEnl9hAy\nSsM2Q7tWcCIr7Xme3UrwZhBNJ6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBobZ8hvFdKCyz/ZexciAiEt1jcpMB8GA1UdIwQY\nMBaAFCCySu1Z6USZPEB+Tc0wwUTrSvVQMAoGCCqGSM49BAMCA0gAMEUCIB3TNTs5\np3Za8GaHoNem1ekxbIUEaj1S2AGrGv+aSoJBAiEA5/GUep5lZJlpSRciqMZ2d4DR\nC/DRNRM7I2LZo1/t6oI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeRxW+mEVjyyduw1bgL9AuGJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzMxMmM0Mi05OTBkLTRhZTUtODEwOC0yYTJkMmRhYjZjYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx9dbBz3Pb1KnRPfvCDqldbZhvC5txLDHJpBepQCB5WbR7\n78JqSCrNds8KtgjXzX38KcOcZHGSCWB2ZI9Cyy9mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUILJK7VnpRJk8QH5NzTDBROtK\n9VAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANmVcKrgdhsgAv6EXhtniyoxhhRpbAs5yy5tfG8ctRrhAiBhbpAM7GSu\nPZRPQO6ipSzc79oKrUlTuo3CjK/4K/zm4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAatgr0whklCSCgXp0TpZ7XZIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgyNWI5ZDctNGRmMC00OTg3LWE3YTgtNmViN2YzM2NhNWI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YWYyOWFjMy00Nzcy\nLTQ4MjItODQ4Zi1jZDE0NjAzZDVlOGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARo/jLQbfQgBrDsvkYijncjEKwlh3f9TkyC71WlJolaszNV6yL8E2r+X5SZQOuF\niXfQK8YicVd7m0cLWoajDNhTo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQaG2fIbxXSgss/\n2XsXIgIhLdY3KTAKBggqhkjOPQQDAgNIADBFAiBGSyAd/fFJfH4DRfn3aHtUxOgZ\nA7CiDaQ6+bc0iBtSQwIhAOc4FLdPVY6Q7i978qEEfEBw9dR6NKEhvMtlfnV/ufpf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2924", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2924` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQKEJwUX0J9gzE9FmAkp3zDIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ZjA3ZDdiLTA4NjgtNDM1Zi05ZGVjLTA5OWEwN2NjOWIyNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhhYjM5NDctOWY1\nMS00ZWJjLTk0ODQtN2JkNjFiZDI1ODJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErFGH64uN+LRcp7KKdKxlZd2YJh+MxtrKmu3i0EV/yuN+y5+QC0ZFzRirSi3Z\ne16MLNLqp96RBv26O5EODX/LhqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJXpVQzVt9UkL93eSJpXSwIJUahXMB8GA1UdIwQY\nMBaAFNIwrrEDQBV/d+/ZR6ugLtjiqKWaMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiANfRHW2grKm9+2InG5cQ9A0Fq4TiAy/anS\nPeC2r+8ZiAIhAMPbSe5iiho5tot+K6DwiPwO+GLrhejk4P7OMkZspo8M\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW6O3Zg1Nppn36ruej67m4dQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGYwN2Q3Yi0wODY4LTQzNWYtOWRlYy0wOTlhMDdjYzliMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4CG+92vylH2uUffa7tlF6G5/5OStjVjjeKspLtava8rms\nhGVaDrkYWRfOLkpxehmQLjX6/kJOUeHJZa6o4qcao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0jCusQNAFX9379lHq6Au2OKo\npZowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPs0i8xQ6mljhwhpPzMY6m+JLsxkVuN5Vuq2+fZQfAKgAiEAoB15Dz18\nLJV5PWTqb7zXyp4UnelzLDYmUiB/suyF7ds=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAT6PCyjgdaHdgNU9R8ZPXHteMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhhYjM5NDctOWY1MS00ZWJjLTk0ODQtN2JkNjFiZDI1ODJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYWY5Yzk5Yi1iNGRi\nLTQ0MDEtYjBmZC0xOTIyZTM4YjE1OGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQweWHjOyUicN1X2z739+pjWI7i3joA0Dp69chSO4QsZnAlnVlSYZa3dkFa49Pn\ns4dYoQ8DlgDDYYknn7038Gfuo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSV6VUM1bfVJC/d\n3kiaV0sCCVGoVzAKBggqhkjOPQQDAgNJADBGAiEAg7gQf/inYZJNMEScp/1Pl5GW\nbAMn2Rqb0RZUOyRsH8ICIQDCPmVqOZVAcpXhpkRF+b4K2Zqoa948ZPs/1TkquElw\nwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2925", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2925` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISATn7DKWli6eJFsHqWZJXZOvHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkNDBkMjZjLThjYTQtNGI0My04Yzg2LTNhZGFlZWI3ZjY1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZhY2FhMDctNzJh\nZi00MTEyLWFkOGYtNDIyYTNiZWY4M2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOTpqfQiA0c0/rheghpGUEv7yngSSlPAZgsHJi2oo6F6swti/3mk8oZLCqpVb\n9pPdw+HSvpMZlwBBry+VZSOyv6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMLa9iozBej2OtCZZUHf3/RpGLwfMB8GA1UdIwQY\nMBaAFDJtM7j7npKe0XITdkdfBxPXlfpnMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAPskfIB60I/K22VAKw3wQSzYvHjslP/Q5F\nLlJ9a1qY8gIgRi86awhelxYOZQMFiXMj7aiepSn8ueeVKriahQuQLkE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdqX3mw7kRhTprRBSxntm8dlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDQwZDI2Yy04Y2E0LTRiNDMtOGM4Ni0zYWRhZWViN2Y2NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEVklFtoaZi+2MGCNarnQft94nT2SgT2YNGNmS9uuX0ld1\ncnlQ0dcrUZQ/Y5ZUtSm1G/AoCBzZP9VF7tUzVQzyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMm0zuPuekp7RchN2R18HE9eV\n+mcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIUZxr16F2UDVwuD+9vEg8HpAso7dQGpuiYikoQynJs7AiEAoaXHhdrc\nswnHqIZ2vz8DGe55SD1zosTiX+PGi6IbqsQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAT+vAm1wm3f96v4VaV+k7zXmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZhY2FhMDctNzJhZi00MTEyLWFkOGYtNDIyYTNiZWY4M2NiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhM2YzZGY2Yi1kZTlh\nLTRhYmEtOGU4ZS00YmI4NDdiOTBiOWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARC17tVFo5Uu0Cw1zFuMztgP1Uy+qLsWMj9siI2O1JvUzyPpt1+xEDJ54nXASPi\nH40sS/OMgCOrpXt1gNnZ6QiUo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTC2vYqMwXo9jrQ\nmWVB39/0aRi8HzAKBggqhkjOPQQDAgNIADBFAiAt9xWceKeQXsx7tlwCOs7ncT7G\nvwWDcWwPRiKzXpXAJAIhAI6N4G12Hml4eu3oLFlfF/eILjof2mpsFwKFCdKbrfM3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2926", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2926` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATScCq38cu0fYWw00iiLM80PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0NjM1Zjg4LTljY2QtNDRjZS05ZDg1LTM0OGE1ZGRlN2RhMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA4MTdjMjQtYTIz\nZi00ZTdkLWIxM2EtZjUzNzJjOWY4ZGNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg0DC+dQHLhBZBLiJbSd/yy/9WwiRMpNhUbrmXcSwL/9/Uw5Hun/YAEaU0b9v\nq6crmA3g5XIjAOGt9k//afrjIKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRZgMNpuysg/dXkSJyZsQnS5Ibs5zAfBgNVHSME\nGDAWgBSiyaPWSJohyXqBI8YXgxOPKTgXpjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDUo/QflmQC5JoD5nwyf5WPq3NUao4o\nzKN4/1qmPCbbNwIgRCOCv7tbuWKOwRuq8RlMTsqyOO8VWAx6Wmv3j9WHoo8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASVkKv3EWT6wnTST0YNE7VTkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDYzNWY4OC05Y2NkLTQ0Y2UtOWQ4NS0zNDhhNWRkZTdkYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/I6VTAedqU82HEYzFcX39vTW9UcZKrxzQdARGNeh1IBaR\nSzVQu8K+zZjZA3B+giwXLZ5arRtVicHe03rjK9beo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUosmj1kiaIcl6gSPGF4MTjyk4\nF6YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO8adYMvIgTYrwsLs02H+QC0JWze2h/0nnWmFeZeC6QEAiAU1xndlwe4\npbPdx5QIFQ47wgKMMr2ax/AgfwbP0ZQtfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAYGOUeiZiyqFLYdJurcQ+8o8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA4MTdjMjQtYTIzZi00ZTdkLWIxM2EtZjUzNzJjOWY4ZGNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzODBiNzYzYS1lOGU1\nLTQxM2UtOTdjNi1mMzQzOGRhMzMyZDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARZPgVSySdvvaE1Lnxuv86jPgdPNxFaftQ4p/4kP45TOZWMUs/lEPpoXTvV9DGs\n6OrR/JwiVhEklDTynyTowBzno1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZgMNpuysg/dXk\nSJyZsQnS5Ibs5zAKBggqhkjOPQQDAgNIADBFAiBs4GUmjIjueAc32PVInScGfRZD\nwnOEle08b2onJxOSggIhAKo/v4Y0lnnMsh/VpoWHteh5FA2OVU6vKdHgYivJV8H7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2927", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2927` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAYORfTLTkPjpXm28CHnZPVyxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YzI3ODE2LTdmYmMtNGE1Yy05OTZiLWI1NGVhOGQzMGRjNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmExMjNiZGItZWNl\nZC00ZjNkLWI5MzMtYjhlZjU1NzE4OTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZj6RIQPEdM0f1bttaQK62Z9Gt1LZOFSgcCjwR3Py6Sj0vbQ90tLjQ+kNoR3W\ngAiFt+EOdwSakv1V9ZL7LT+i+KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU30vq4PP0fdfNDqZoZuo4KKFKWjwwHwYDVR0j\nBBgwFoAUAmo9fDAL9Tr+yRRSJIIwvx32TGwwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA6UiIYeW7GXvG\nOULRA4wC33h63DGwywVMfyTqF67zNAwCIQD97C63ajpxv5aZEL6zw+hZ3v4Pfcrm\n9jQ1QMKj86RaHA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd/ld7ze3R8ZTDxdvKyF6MnkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWMyNzgxNi03ZmJjLTRhNWMtOTk2Yi1iNTRlYThkMzBkYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjr93p4jySPEJZIm2YKFwmZVO5K5e6uNc5eoYkmc+1kZ3S\nEiZ/vUjtCpbm8wV4WCB9JOrOPmPoWeu2p6Je7ASOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAmo9fDAL9Tr+yRRSJIIwvx32\nTGwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA0meUmH+Gx3cfegnIYZUAY6IXQ3XqfcbS5SQmxzntggCIQDckfMt7uBv\nYuSAIcZr7eHOWAY4M1VN57sQQXVPYInXKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAQ2G2st2VIIIfF0rpTVltqCxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmExMjNiZGItZWNlZC00ZjNkLWI5MzMtYjhlZjU1NzE4OTM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NzMyYmEyYi1hMjgz\nLTQwNzUtOWU5OS1lMjRhMDFjM2EyM2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASWjl6gYlRTUIOnHDE/PRyAxh0Mp3NA7R+uNbj8CqouhPJHCRMjPZG8kONpLUsC\nWTi9Coa26NLZ3BpOiTsUExwHo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfS+rg8/R9180O\npmhm6jgooUpaPDAKBggqhkjOPQQDAgNHADBEAiAgXgNbccbZrMDo17kVSdAgAaea\nW+P+QMC4+AmZsN47ogIgAWZQmy0cQIk8USCQjjM3XFCKZaDbF/UVoDrRrWE4heA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2928", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2928` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWWeFyTWP+tkHDH4OhIxMnZ3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2Y2JmMGNkLTNlZjgtNDYxZS04MTgzLWI5N2I4MTAzNjY3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQwZWQxZDktOTY2\nMS00MmFjLWIxMmMtNTMyNjllZDliNmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExMTA3iXvwpGEg7oYfBuFSkPjZf5dsO1p/dH1NMmnyyiOWp957PkdHOIydwh4\nlhEhTOSFfSoEe9KCZM8BsYLMk6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgbCDsEonLLzNugdpwnZvxlaJP5swHwYDVR0j\nBBgwFoAUmPY3P5VDJEdwClseba37rIq2C2IwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiA9UVlyVVBahTVz\njZFKSmhHVAb2Wqne/vI9Wdz+6PD4mAIhAP68ZlXDvHg1Hdv3wrNrNcI2s9SrF2Rd\nPBGbofgIp5M0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYGYwzgRDkmqOZSn5RiErzRUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNmNiZjBjZC0zZWY4LTQ2MWUtODE4My1iOTdiODEwMzY2NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbnq/fEItAc1/hd7rc4VRsVHPg69BSupgHlIOLLkLK+5kX\ntGoPLT8P9qwhso2Mozf/7mbC5vRioX9aAIcpQRyDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmPY3P5VDJEdwClseba37rIq2\nC2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN85SEa1ysvD1CMzJg8GT4RbQvbWB88+4z7UjY2MGVhMAiBVw0gsC0YP\n+mD4cYbOiAAvkJ/YF9wSac4tyEGYZ8tQXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAXu2l/ZIcx5zm5nbcLv6lg8sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQwZWQxZDktOTY2MS00MmFjLWIxMmMtNTMyNjllZDliNmZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYWMzYmQ4Yi04Yjll\nLTQ5MWEtOGU3YS02MGZjMmJkZjdmMjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATnH5/s0an+9VFGguTwQ0F+mNrtsMB1GPHIMcWqf+NvoVLhs1XursUaN0b3ws8B\nRlK4GzFRrYwwZwls3f9DRQy+o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSBsIOwSicsvM26\nB2nCdm/GVok/mzAKBggqhkjOPQQDAgNJADBGAiEAuIyXa2Wu9Y16txNLsuMh9234\n47B3CRq3XsJUq1Kq7SYCIQDO5Pb1ZiGfrfEm69UFDPjRbrFdWqkJ3e5jVxCgZ77V\nrw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2929", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2929` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAfmd3RETOJ80Y4bCrG/YR2wCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MzY1MGExLTViODUtNGMxNi1hYWM2LTVkNGIwZTA4NTY4NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE4OWJjZGItN2Yz\nYS00YjI0LTlkZjgtY2ZkZGJiMDA4MTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED8O82BcgIAKengxjNti/90S3ssfcgbDfGlZTGpo5+Aqf82O0+H+MlBxH3bVZ\n5C6PUaLMrrw7E+thIrKBqdcnmKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwavwZVs+mq+ACG80Mi5ToypANoMwHwYDVR0j\nBBgwFoAUn9mRiILAEzoctOX/Z18gBB224NMwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAiwLBnpV6VdECSb86DC9Q+\nGJt4dRXIjj2o5sTe9kI8bgIhAL40sYSVgl1YXvVNaYqxdZ2wiO+JWMJenV6gRf4a\nCLZ/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR+LSQrrgqrBTjHdmveH7NBMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTM2NTBhMS01Yjg1LTRjMTYtYWFjNi01ZDRiMGUwODU2ODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+Fb2HeUKkZZctD9BhvMApdRjIJo+8jeb72n6pncrRQmea\nQKWr08rug309nSs2ESN8L3NTEEf9Kho0wHQBKQAOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn9mRiILAEzoctOX/Z18gBB22\n4NMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga4szuI+5kjd1cKKSL00nBNTIAvO5vH8nokwuT52kOesCIACcp44CxiBh\nQ87DS08/KRZSqLDltNLpNKQrQRPkyAE8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAYtLPM3G2oG1EZfbz3EVCoj+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE4OWJjZGItN2YzYS00YjI0LTlkZjgtY2ZkZGJiMDA4MTkzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNWM0NzYxNS05NGEy\nLTQyNWUtYTdlOC0wZTNjZmRhMDQwYTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQoDeK0D4gbL/cPjahxR4yNtqFi9hBLZZqWhJcnU37OH2r+FWWbQuhdn30U/Gok\nCwBmZebDUa9stqPTn4oBPRLeo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTBq/BlWz6ar4AI\nbzQyLlOjKkA2gzAKBggqhkjOPQQDAgNJADBGAiEA6H9p6pm8EcV3kgRiqPbBoKM6\nLjRfeM6g0V9HKUFeQd4CIQCaGl2Q0k+0kgRIJUlFrxXQ/Ct4hQOcAQAqbv0V1jXF\n2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2930", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2930` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAYMFEBl8KfMQdjzxKbYhGdcPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3MGY1MTFlLTJlN2ItNDQ5YS04MDBkLWIzYTA2ODg2ZWFlODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg5M2JkMjMtZjMx\nNy00MWQ3LTkxYzYtZTUxMGQwNjk4MzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpLYCS1jXoq8pR5xo4CRUWjFYfTAPMIBCV297QCeqoY2jsiCv/yKw7FzAy68D\nzfo02IBSBdEvFuO9mtJFUB/QwaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkYmVPvlbewRDDacHETcupzD9vw4wHwYDVR0j\nBBgwFoAUp691b6FE9/FkMk2URLBv0iVOQb8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAnb5OT\n5gmqP4YQix6oPwyI2YLua8b2AqjtQS7foCye1AIhANhOD0i6eEyxP3Oi86JF8aJD\nw8auM2hoyWJKgg/khndX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdkBOS1Z35SFkE4TQpM0QiB/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzBmNTExZS0yZTdiLTQ0OWEtODAwZC1iM2EwNjg4NmVhZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARe28DIm9cx9fsAyiQnbRAN233ewss/Kj0QjNK5lcoA6+Vs\nXHmykZvhk9ulSVDDKlL2oDV9Bigpnh5PHgH70HIzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp691b6FE9/FkMk2URLBv0iVO\nQb8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgafsaAt+9nzn7iafcMmnnuHpqnX4GKVALLaad5ad6nMcCIQDLj4LnTM2B\nnd3gHQca2nUiFQwaKotPXBQzjLIj+SaQKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAVU0VghDLwGZ4PLpI91krGK3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg5M2JkMjMtZjMxNy00MWQ3LTkxYzYtZTUxMGQwNjk4MzVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkODVhYjMzMS04M2U2\nLTQ5OGMtODYwNy0zMWEyOTJiNWNkNjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARHH/CZlkNoTaSQ25jI7QeB27ed/gD6morUXRkii0BMHrJkOruQkgxRFA1FY5UW\nyP9G/slqszm5m4MQ91KpMVzUo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSRiZU++Vt7BEMN\npwcRNy6nMP2/DjAKBggqhkjOPQQDAgNIADBFAiAzG8a/GFEsBmctrZ4XzH+lsE/F\n9AFQKdO5VZy+RInpZAIhAIjRXqghiPflPOkEug78cFNmgwHIgVE52MJuNsHD+864\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2931", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2931` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAWOtCfh4KmK116TSrMQN+ZDrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3Yzc1ZjM2LTNiNWQtNDBkMy1hM2U3LTJiMDQ0ODcxNGFlZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFlMWQ1MzYtMDNm\nMC00ZTg4LTllNmYtNzEyNWM5NjIxYzM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXwIv845oOOS7iDreoZ+xrImUtqxEMpZl82q4nZLkTr9XYkBQOGMqaMfcW6iV\nPttbMj5Nray5Y0oxwPDREp9Tz6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1W+S0j7OnksP7Sycu9UAt8E6jiowHwYDVR0j\nBBgwFoAUn5tpKq8ZwNZQa/2N4sfR2miiVqYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA52jHK\n7+Ur7ZC2bB6HTvOIB83XdSRKbVl5rwfGK8d8cQIgFV7Xajs/7t+GH+C67X/mrj0H\n/7620h1o47IO4Bv7l28=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcJI90JRadwyJ8u4VXhwyuNNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2M3NWYzNi0zYjVkLTQwZDMtYTNlNy0yYjA0NDg3MTRhZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuvAzNAHSQpVZjLghwPhyO1QYUyDr9R4d2suKqaqqaqGj2\nrSUnF/19vNWaMDZKdjF4VjGkMU/gDStf1e+VZEQwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn5tpKq8ZwNZQa/2N4sfR2mii\nVqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGulDVa3BKDWt3LBN3UepRMH08yjw++njDSWwi/xXzjUCIQDFziMN/IzK\nuRiRyICuCL8p3AzAsLIStjgw/WGetJX21g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAa50NkLwJlc2rgJE+oy3+qrYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFlMWQ1MzYtMDNmMC00ZTg4LTllNmYtNzEyNWM5NjIxYzM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OGI5YmZjOS1mOTQ3\nLTQ4OTUtYjgwNy02MDczOTliNDZlZjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATnbpPDzvINQ/r2qthPoJDpkt6A+99RoeYXuFNjjktn2PhaFeBK33FXZU0y4aRq\n9xcV9QU1LS2OssZ/DSKMfbPYo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVb5LSPs6eSw/t\nLJy71QC3wTqOKjAKBggqhkjOPQQDAgNIADBFAiBXviSBiMJYe6h9lUlfoeH0lY1v\njcrXc739x9eQYBBhrgIhAJCMFFdp88fgC+XNs0G8yhVsa0qK0lvEohRuj9pD8m1c\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2932", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2932` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbge5B6vq8DFvYIOgYsLzfljMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMGUzZDRmLWIyYzctNGU1NC05YmY2LTk0MTdmZDIxYmExYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFjODk4OWYtM2Nj\nOS00NWY5LTk3YjQtOTZlZDJiNzIzYWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvFJAk4xN24mV3uz1W2hrSw9JpFBxdx/MFWwA6Eo2sLkJFG2th+ITOADErv87\nQUUNQrsoDI/0xHTSbp2H1/yB/aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFL38rEVy/Xk0DpjFe/mMzphowcjSMB8GA1UdIwQY\nMBaAFAx6Sg6SqCVA9iPNg2oRYBv6ROEQMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA1dcl5WV6skbt0HS/zewMSl3Go7zDUY1W\nXsE0yK7xvvMCIBYZ1mKpz1WcpDo7rOmjNgJNICNMZhG65W9fCTbh6tQj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaAAJk75xiOTz3O6RzKiqqv1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTBlM2Q0Zi1iMmM3LTRlNTQtOWJmNi05NDE3ZmQyMWJhMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMpNvX5x0YCxRvm4j+mYgXdpkIih5QBW2Jq/EIObXZ9oLC\nlUqU8GHJTq4M2NFFu9y7vykmxM4JcEQ8bwaCI3BMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDHpKDpKoJUD2I82DahFgG/pE\n4RAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJho37DyRisjdf5Q6cdFIfEeb37z2c+oyaFeMZfoX8rMAiA00pbK7yqO\nGsS4zGwnTxjuMs+zMqDn0d5s1O4mWj0pNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAePtsTK8H+WlkQ4mKScLlEy5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFjODk4OWYtM2NjOS00NWY5LTk3YjQtOTZlZDJiNzIzYWM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NjEwYjkwMS0yMjZm\nLTRjN2YtYTI4OS0xOTE3Mjk5NzBlZTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATGDVZ/DUEruSXmfkcMOxNzxnQ7WLF3ZhbXc+8MHnEQFNNwBLirPhxl2rQre0Kf\nZo+wAN/4yhXJrRMjtI0gGm/Ko1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9/KxFcv15NA6Y\nxXv5jM6YaMHI0jAKBggqhkjOPQQDAgNIADBFAiEA2VDSDK4J0a1cQUDqGcZxkVdm\nfSFnAsNRH4ByOi72EDYCIGyuyiMyoR7l0KnlOcZvOaRUT18lcfw3ooRlrG0Vnrd7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2933", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2933` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAfFOs/yPrnL1RcPTrYimHJ8vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3NjUzNmZmLWQ1NDctNDBlYS05YzU4LWVhMGM4NjgzZDIyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE0ZGI1N2ItZDRi\nNC00MDk5LTg0YzQtMDE0OGZiMWU5ZTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESEr8QKuWoVv1yYdv6TqXSDKGXjsDx+GrbHKKzRSumHybz5VoFOUDNpDRPZP/\nNhdn5fPFrz4/NDgs5LSRjOWwdKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ0X18NlFR5Uk8KyNCv3x5ZDSfkMwHwYDVR0j\nBBgwFoAU2n49LXFJzXi0cq81aT1ZOad+Ww0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgVWmXhJug8TSY\nT8Q6/T8yC80/YXDhDW8CI4PHmY6uYFICIQDpffG415C6oAoi+yT0ZnNHTNmL8G3E\ntzMo5bVAQGND3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYGnbappLTqd3BKQ/tMncNLDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzY1MzZmZi1kNTQ3LTQwZWEtOWM1OC1lYTBjODY4M2QyMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlu0CYGnNsWlMojpLhC3FlgZphLp4dg3pMUHWxMVmoYsKo\nLjeD+H34hGyYfZNVf2LCaR0mjMg00FbKO56cZWN6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2n49LXFJzXi0cq81aT1ZOad+\nWw0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgELRxtL9tv9jheEb3gosyBWxc6etWSHvkYLnk5vf01vACIHH6AGNACW+E\nruZj+v8L+dixNsRtoha/t2OxMbBHAamj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAV+STbUgTij7cDOfAy5ms3rSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE0ZGI1N2ItZDRiNC00MDk5LTg0YzQtMDE0OGZiMWU5ZTcxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlOTE1NzY4NS00ZmU2\nLTQ5ZTctYjM0OS1iODc2ZjFhZGVjMjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATGl/5BTuALK80Q8xRHJ4R8Hz6U3YmncdNHQVuQhYSO7x8hVusIXHsjJv6z3KtE\nQaz4fDZaVGH+t0r7hKzbXMdCo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRnRfXw2UVHlSTw\nrI0K/fHlkNJ+QzAKBggqhkjOPQQDAgNIADBFAiEA9U8lL75INnK0i4nI5fZD4uZK\nfGkVkhXOcUl3L2aN9zsCICq/GpxSwDwKgLJX84JFY2hMEgUN2mEBJFIan+YTjnWr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2934", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2934` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISARXRwUkCIJKTkV6LAKlibLc9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3MmUzMzRiLWUxYmItNDdhZC04ZGZhLWY5NWYyZGYwZTIzYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZlNzU3YjEtYzk3\nYy00ZDlmLTgwYzUtYmQ0ZDRhOWRhYWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWwXaYeWcOJZkxg7EiKL7W/9x1viWX2hVPv8+puX/Tbfz8MPepKxSxwhdcbM9\ni28CmAApD7a/FYqNoDchULfDIqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvAwk/AcltC72AYcxMkNq1TrNiFwwHwYDVR0j\nBBgwFoAUIenS7BGq3iU+YLJi86G4EAfaUoMwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANPcIu0upd7h\n6y6KikbDnbUR4CXXdct/p6M2jlaUOCUTAiEA3QyRo9EKq7v1dVkv/Yw3EN8XgQOk\npILXuyoQ0NUg+qc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdx1TSXzHgl6ljmqa/ZNSMr2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzJlMzM0Yi1lMWJiLTQ3YWQtOGRmYS1mOTVmMmRmMGUyM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/WEQuYwemZjTTb+0MQedP/epRUYtHJUo6w6SV/55BnSRf\ndzD3r+HRPVGwg03TvDjtUpwjKO2Rm4gomM6kqA/1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIenS7BGq3iU+YLJi86G4EAfa\nUoMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYI5VovgrHaFUwxOcSyiN+c6ISozYNfbP4sUQQWKpJFQCIH7zZORNJKjZ\n1n1VuOhe2SFUYWdvTW+J9a6COPJdlEpZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAcapeTInw39FkMKU/VMRgmVfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZlNzU3YjEtYzk3Yy00ZDlmLTgwYzUtYmQ0ZDRhOWRhYWJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MTkyYzVjNS03NmZh\nLTRlYzItYTllNi1mYThkYzcxYzI5MTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASuZMpw5U66ruu6VO0XKFDNEEW//IQlU8lMCXZ3F3RcvBl0zspLFjlk2PniFTt5\nm99GJ5cI0r/jAq+fV5uy5QYno1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8DCT8ByW0LvYB\nhzEyQ2rVOs2IXDAKBggqhkjOPQQDAgNIADBFAiEA6qtAOTgOZeAglaoY4Q+NbJUi\nH9JoNmuT3/heW93mAzsCIDukoBC6GL5VUxuI+AgFXuMZ+HKpJw+F2AH+FZw5wvSa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2935", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2935` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAd5aVBLf0gokhvR1z40XpqiTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MDI5ZjMyLWVhNjUtNGJmNy1hZTc0LTNjNDEyNzYzYzVhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE3YmZlODQtNGZk\nNS00Yzc1LWFmODMtZDE4YjU5Y2Q1ZjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0TvvuNP5vL9V++/F5NnJWvMIAC0kA8RzFIIm/ljaNIs8Y7ZNg3+7cjdbDZu0\nTY5Kuwx+EoULx3O6qXaBAyhB0qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3cvBXweYeYRzxtOW4hGvhIqUcLYwHwYDVR0j\nBBgwFoAUYwHSyZeKNgAV/LGlE5WaAlsUIpMwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIExfqxxIcTXf\nx9ZE25ALp/1AWdG00CgVvGB65/sVVWKvAiEAq0UNY3a6glS7FLcZVnzC7p5TnsIH\nMzpNphdsKAK1vUI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYRbBSbNjDvzC9BI52jGMFBPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTAyOWYzMi1lYTY1LTRiZjctYWU3NC0zYzQxMjc2M2M1YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfB5RGorPX9wmamBU4YGum/a435XNvOZhmpU0bCHVeNypb\nwVg4XVsQDn91CtkpVfAB7JewQkidnBa8+DpauRXqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYwHSyZeKNgAV/LGlE5WaAlsU\nIpMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJS0FKjOuBKZK/eT4t92cO5AV0YhOu0XuBmiM2/BHR+eAiBt8M0CKJjJ\nqLvfeTbnwUJe4U8ooB+z0NSJydf4VfSyRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAU6fIB6f9VxlQeFM80PCE+rGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE3YmZlODQtNGZkNS00Yzc1LWFmODMtZDE4YjU5Y2Q1ZjA5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYjI3OTVkYS1hYzg2\nLTQ4ODItYTZiMy04Nzc4OWI4ZmQ5MTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASI7vMSrXZ9rVZ90P5/SoK3ako8jJYltodA5Qh42Dkc0TApHeBLRluljZWmD2B4\nwR8AHRXMu8llqCBDOYB1ytPbo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTdy8FfB5h5hHPG\n05biEa+EipRwtjAKBggqhkjOPQQDAgNJADBGAiEA2NXn3Gcn/zoyzZJqZpvn+smQ\nTUnYVQvOUvlFpdlw1UsCIQDe4yue5brtl6/pVDfWA1/3IlANBXBTgKSsv1OrPisx\nzg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2936", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2936` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAai61LyaR4j8aL3/6jEnF2rDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmODI2ZDM4LTU5YWUtNGUzMC1iMjk2LTFiMDU0YTZhZWVlZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhlZDRjMDgtZjQ0\nYS00OGNjLThjN2YtM2I5OTA0MzQwYzk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdP/m2mbUbGNg+WsNzsbkjdQ8DmKYbBCSHFenY4R+hIew83X4BTA3JoMlmVCL\n+nAnj3LGjYEPK1rurEAnzCiOoKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmbGYOAZpIXg5sniNlYO8Xgl6El4wHwYDVR0j\nBBgwFoAU0XdC42KYOPVsyY3z+YNRa+EHrxswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDyDSNTxo2MA3CiocSm+qPNcV2Q5sPOL/c2/9pgOerLCAiEA+UwurMmZod4K\nvuYzZPfCzqxxjEAkS24kLAv6GeYedGM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaqBNRFvDPbp1iFgs2/nS7qbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjgyNmQzOC01OWFlLTRlMzAtYjI5Ni0xYjA1NGE2YWVlZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8mMw3yrsIXw5VKpa3dhZZfqu1DVpxYa0XcOkEaXcM/yf1\nWfus3E+ydO0j8oBRyTtUaUeZg8NTY/Qz9s1BNkF0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0XdC42KYOPVsyY3z+YNRa+EH\nrxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMWCHyscxOADR++o6MAvuWMNQoICqQqtnDVdFEAdxkJ6AiEAxJTtpYpb\nxKJaczuyC31rC8XBSuutWb9rIYrXsAAYDf4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAd098rtqN0im/CM26mEW0xPAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhlZDRjMDgtZjQ0YS00OGNjLThjN2YtM2I5OTA0MzQwYzk5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYmY2YzczYi0zYzA2\nLTQyMWItOTFlNC03MTYyM2IxYjlmMjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS9S+QJSPsT+jLPlkPy603GVkdL9k4LYqOL33KZ2xFf9PmOsyy+4RMjN8+wfJAY\n2uLEb4IDkwx0FfvUtcEHXt7So1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZsZg4BmkheDmy\neI2Vg7xeCXoSXjAKBggqhkjOPQQDAgNJADBGAiEAwBoIAO1iz1/3TUL/s4sx/jH4\nA1lE7u4lIx355zxPtjUCIQD72GbaXKKMvI3ByLqpfa/B1YMAW1vIsEsnQDtZNRry\n8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2937", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2937` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAefsaUx5uIuiY+k0L4KhCvSoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3YmJiZjBkLWFkOGItNDM1Yy1iYWIxLTRmNmU3ODE2MDIxYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZkZmUyMjktN2Yy\nNy00Yzg4LTlhOTctZGFlYmJmZmY5ZWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEURE22Y7mDCpmKiPaFuPR/+pw0xzuvELQ6YT4oPq9Fwx6V38KsGO0ssTm6gDX\nbso3vKEReWqH9iiEFwq8HVs29KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtgtllXRp9TJoB9GxZKnMR1ZUvwkwHwYDVR0j\nBBgwFoAUUSUTGhIfrmorJv06u6R6WgdhQoMwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCkWOerX3jlqW6zd7qxx2blTaiKNW+jaBVHbQybQdrkRAIhAI9vrhQ+ZzSc\nq/6dzGAdu8XgtIMIsl3ZXBl/C0HFp/4/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWeDuqc5By7CqhvBDxJBpWwLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2JiYmYwZC1hZDhiLTQzNWMtYmFiMS00ZjZlNzgxNjAyMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjmMvnMXqcaA1NG2B3LoyL62+01wcmpYTlaV4N6nwshxIm\nliKw2qBNrFb4OtopzJ8kyv4Ur5QWU2RiJy5z8mt3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUSUTGhIfrmorJv06u6R6Wgdh\nQoMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQBPtSyh0BQUMktXuQ/CMm4peZ1YFy5crhaioJgyiv2ICIQCf9m8eEIZg\nrhPPbmh+5VbIhsnmBv2AfOfB1HWf4uBD4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAQRuh6XLJQ0sUhf+oYzn9ljRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZkZmUyMjktN2YyNy00Yzg4LTlhOTctZGFlYmJmZmY5ZWEyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YmQ0YTgxYi04YTlk\nLTQ3N2YtYTlhMi0yOWQ3NGM0ZTYyNDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT+XYWG1fSwd48Xd/nW9pUYhIeCNNImRmoHtVKgEk6r12fpjT2DSFJhWbmKaH4w\nwm+qlbKKysSQLnjTE6ZECQAyo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS2C2WVdGn1MmgH\n0bFkqcxHVlS/CTAKBggqhkjOPQQDAgNIADBFAiEAmC3tYJD132oRrL7Ms21QFTxe\nbkhRyWgYYBa/SKh9ZKkCIDW+quxDuGTA8hSAF8SLg4nuFHEeXNFeBjD2uHHWCN1U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2938", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2938` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAaIHzzZgc5yIXEkk8zsJJSTjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlN2RhZTBkLWMzNWItNDVmNS04NGY2LWFiMjMyNTA1ZjJjNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQ5MGJlODgtNTFh\nNy00MTA0LTgxYzgtYjIzNmEzNmUzYTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDrYbVoDiBX9mhTc823Y7ScAN1Kgck1iQUoemhhqx32KpimJXPpPct0SJW1Jc\nrt6LeVUpTTnmi0yaPwgAgFjcBKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxNAdUdxoyNe3IbKJ3YUggmQXLNIwHwYDVR0j\nBBgwFoAU87ap4iQTmZzeF9rgmqbnzOnZcpkwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDs\nKiJv1wg02F3Sj+PvjOry98kupLcAKfnj36oxYn4ZPgIgWjhp0s4Db7HvHJ6yXDrg\n0fqarG3Jc5v3j1eCHyCP+9Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd4jI2dy1TuwNPNiL/1UHMBbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTdkYWUwZC1jMzViLTQ1ZjUtODRmNi1hYjIzMjUwNWYyYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTxReZrn+dptR7Gd3g/E3t34CGIhWVjDdfS0AizGXUrwLA\n+9E1gSvsiGf0OStl37zYamq8EOfianu/gUdP0nPuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU87ap4iQTmZzeF9rgmqbnzOnZ\ncpkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAINXUba4FB9VCbOM04sI7LUv9A8M3VmCzD1mhziSMlwtAiAPZdX1haPd\nxvj2DJua/mnLswWUvKKofeeUimEnTMsfUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAaK8s0w7EkZPQjgHBaM1B72yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQ5MGJlODgtNTFhNy00MTA0LTgxYzgtYjIzNmEzNmUzYTFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmZWQ4NDMzZS1jMmM4\nLTQxZWMtOTZhZi1hMWMxODA3NzI4ZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASgIaPvUWoz+uQiTi0RyplzG43KIp+ZYFekxrYVLLOHQnqlr8iJc93Lfww6rAJ/\na8Yywt4OupyNJiAUb/KP5HjGo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTE0B1R3GjI17ch\nsondhSCCZBcs0jAKBggqhkjOPQQDAgNIADBFAiEAnnywjl1biQICXqz7tnOHK4KB\nyDuedIzISPQcnNjhJCcCIEf8PQ3QTJRCQYG57z0eCrZ35IIwlSjYGPuXwtPxnF0U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2939", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2939` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISARvxML3XijefrA3TukDt7wzaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNDVhZDg3LTI3YmEtNDhkOS04NzBhLTdmNDk2MmI1MTY2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc1N2YwNDgtOTBj\nMi00ZjEzLTkyNDAtYmQ1Yjk1ZmMyYTJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEngsC9qi7q0bIfq8qAB6Vi2SvtOs42+yCVwfzmBr4qSg07vjToRE94nezTcAn\nJJJ3cUm8aQjMTzvYaPCEgPpMPaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE9l2nUKehI4jYbGGdVoTr3TBL6MwHwYDVR0j\nBBgwFoAU518MMJStASWZbyAgi+z5EShU3lMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC2bOzA9PBCdk8zeuZPZ/5y4nzyI71gLLwcejQLy2GGWwIhAK0B\n04zYmEN1CG91ymE0cB7f7+xBoIiHFydwDHcasBBL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAebjliGNecSoZ2NusTVUZA/2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTQ1YWQ4Ny0yN2JhLTQ4ZDktODcwYS03ZjQ5NjJiNTE2NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTK2KKRDNFan3mYfRSjyY/LO3yzGioKIPo/GCplzog8paH\nyFHn5HvTQP7Q7JS02zp/4tGZDUa7slCCQ9rjOB2Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU518MMJStASWZbyAgi+z5EShU\n3lMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAkA49R2VIHUqU/U5l0N8vL/trADjyqq3hWWgqs1dC/4CIQC7IenLJOVW\nqa3rD11YmD0Jdwy6CWoiqYLyuR6/ENGPFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISARjrmCVBHK8dJKtorYLkbEmaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc1N2YwNDgtOTBjMi00ZjEzLTkyNDAtYmQ1Yjk1ZmMyYTJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZTFjYzc0ZC0wMGUz\nLTRlZjUtOWMwMy05ZTcxYTcxMzkyZjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQL1YLixxDdQE6r8vpLDbgw08gdqOp6T55JwQtzEIrMN5n4zi4KeF9qrF69GUmK\nGMEEdV35ZRvhW0Y8kq+2YoIJo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQT2XadQp6EjiNh\nsYZ1WhOvdMEvozAKBggqhkjOPQQDAgNIADBFAiEAkLCyx2JRO7NOzLMBBnjgBa0e\nNR8FCmcgdRXfIG+LNHkCIHuros5Kpt2SvyQwCcCHZAlmTq6+ped0FtU9Zx6BtyoA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2940", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2940` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcv8F1NTqjPSX3Iaw+HQiWIgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5NTBhMWExLTdhMWEtNDg3MS04OTE1LWY3Y2MwYzAxODlkNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM3NTU5NzUtOGJh\nOS00NWU0LWJlMjItYTNhZTQ0YjAyYmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMiVQbhsal14fD3mL5alpKV3zRZenXLy2IZn188yXslaxRiOqNkInNJFHwDNq\n1+OAcTzuymRqygYQ823AwD8C1qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXtaJ+Y0aURvaIWn4m6+jsx33PrUwHwYDVR0j\nBBgwFoAUTSCsxnrGKn8gKjdlhJA2LlqA5PQwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIH+0Q8e84KJxsjtrQslcQfdBggKs6larxQuPCYsAWJE+AiEA6PkT\nyMmXkOxP2FATUK1qkhaN8VlGQpz3dA+U3cWdXdM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZBn5cHhMe3/abfbDi9pjAN2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTUwYTFhMS03YTFhLTQ4NzEtODkxNS1mN2NjMGMwMTg5ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwB1FKFq6rE2lQyFBsg/0+oR/sQLstoGFzCRPfX/Zvgh1f\nFRrZHioj2c0JBbtangkFQ7W+O0ykUE4L9NvPGWObo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTSCsxnrGKn8gKjdlhJA2LlqA\n5PQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANqOIgbctQ8NDGbhjW3jdVBVCzQnzmMfq+BBNomPIvBCAiAVSNaJ7CtC\nD8UATWkoNawSO4nty4Pac34XNciTzbOZ+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAWlyP+3Cu39yNE95i6bJMvM1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM3NTU5NzUtOGJhOS00NWU0LWJlMjItYTNhZTQ0YjAyYmQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZjYwZDEzNS1jNmMx\nLTRkMjQtOWVhZi03NTY2NDAzMmU0YmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASGJ5uKq8V1tCA+FpGUrfbDTT/8eXH3FWDKFTZRNvuknZysLHfRjI7qXZljVbBv\ng5EeOBdfnoXD8HX7szaE6xqao1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRe1on5jRpRG9oh\nafibr6OzHfc+tTAKBggqhkjOPQQDAgNHADBEAiAoJl2PXQDP7IYs28RU/i6Uwxpe\nROp8P/ho5wJuizeycAIgVHPcBCyMBu0tIdE7384ZCb2/MqG8/jyFGwusrlQpKbs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2941", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2941` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAV6GpROq76WDlAZxwAXekBWlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2N2E2YWMyLWI1OGYtNDU4MC04YWViLTMzNGZiMjg0NDcxYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RlMzI0NzktZjMx\nZS00MzQ0LWI4NWItZWMyYTRiZmMzNTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElPBWaYP0++yjnILfRcd0EcExFp3I05kzRFkyvXofKBmMaeDla2hplzI2zQ50\nWMUWM30qOO1dLPDQeWsBE+4IjKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOlUb/OP/loBRjVcr8O/iyQP/3geMB8GA1UdIwQY\nMBaAFMOVoL5yBWVjXNPbZp7JUOjUfHjHMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBiL1bypVhjRKYw6OqJ5HM3Ws78iwGjBa7i\njgCaF9LNXwIhAIJ3EVvCfFXQYWU9QER8VoYlnQEjP4LFY3emv+pZJWRa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVCj+iquikIvsjZjiulV9PpWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjdhNmFjMi1iNThmLTQ1ODAtOGFlYi0zMzRmYjI4NDQ3MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi0ncFSLBO/X1ewLpMHuVXVeoGPwgiKH6920nsGBGFLcIw\nvwI9Df10HhZ+xx51wbYx/ibMsqxJicokamy2TtFqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw5WgvnIFZWNc09tmnslQ6NR8\neMcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKhigU9NugSI6mx5igL/9TwQFW+L+9jD8yWDEh1+ByEUCIQCtIBh95qPT\nnYj9QxWM57TDPyqwtpcrwdHMugP1srq5wA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAW+yf6/exCxdGifm+Ttx2bb7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RlMzI0NzktZjMxZS00MzQ0LWI4NWItZWMyYTRiZmMzNTQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YzMzOWZiYy1jZmQ1\nLTRhYzItYWI5OC01NDdlMWMyMTljZmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASAZc53c5BnR3FhiCYdydOB3VyhM4Ayp2uPniboxt7MP+4FKYCcDkuQv3Y3178N\no3HsttzwPxa+DLRoViHHKdi5o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTpVG/zj/5aAUY1\nXK/Dv4skD/94HjAKBggqhkjOPQQDAgNIADBFAiBG/k+bSMRXSEYEOXmiXsNSTfm7\nkNdfQfqcLsy80Haz6gIhAKVYLIA/nrMjeeB8rxc8qedw+Bb435cmAtHsdc/zDy6J\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2942", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2942` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAd2rFX9aMmWKvmsvKMEvn/hJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZWZlNjYwLTg5YjEtNDc0OC04YzIyLTAwMTIzYTA4ZmQ1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjAwNmI2YWMtZWUy\nZS00MzE2LWI1Y2EtY2E0ZjYyMmRkYWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpv4n0M/RrB5f7jCJvyLUQUqP4mulhlsUQctzQvI6xnmxebz7HZv0HhszRnX+\nsiUnlsJhEanyG0OV3cAv0oPQMqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNyYUpA12/SXDASEWfMg9FdKyYTYwHwYDVR0j\nBBgwFoAUWDueg0YsdyxBrukvn9vxverg/pAwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgBMnhBvfDlKYG\nEzzoHw3FeTuaXVmT+um++1SWRmxyDu4CIGKa9nDGXKiNkespvjNH0XXOaoLHDKp5\n9tWQToIce2+f\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT5RyF9L8U0/4AJ9qmVTxMJgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmVmZTY2MC04OWIxLTQ3NDgtOGMyMi0wMDEyM2EwOGZkNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqfhh8j3g0HoiQkfCWcdfHpwspFyFH18JwDQnguBHeIZrL\nL943qz+UGXWysFuowcAEHbzbmfTBzvBDqzURLXLWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWDueg0YsdyxBrukvn9vxverg\n/pAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHE/RgRkXDYXMcru1V1a+kQGh50n1My5C1hm71gktLjACIBuYQOLx/5nY\nZXr2mId3bUXRy6RvlhMGpJQe3gGfweWZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAQ8DcruzbFd61fVHAZt3/FVQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjAwNmI2YWMtZWUyZS00MzE2LWI1Y2EtY2E0ZjYyMmRkYWQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmOWM4MmYxMy02NGYw\nLTQwYzEtOGY2NS1mOGExY2U1MmFiMDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASKj6iOy/Cgi9Dav1WjZlSr0Np4smwUK9aPOxu6fkqf99QdI0R6paCumsIfJHxn\nAmB1afBtDzJIbmIzcywkIMHmo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3JhSkDXb9JcMB\nIRZ8yD0V0rJhNjAKBggqhkjOPQQDAgNHADBEAiAUUk3xlM+A4vhLZoMk+Cnl66PH\n+hpqBU96PxjO8fkTnwIgeI42EUakD0vtR65FFgCxzoZVvMdP+7P7e02+qR81KL0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2943", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2943` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAalyK98Tz7GiSjV8TbYTIHR1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxYzgyNzFhLTQ0OTAtNDc0YS04OWYxLTZlNjc4Y2NmN2UwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWU5MTFjMmMtZTIy\nOS00MDVjLWIzMzktZGQxMDM5OTM1MzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB0dhP6sYj13aGLSp17upEh78ZmmkZ4idhgR5BwtRc5oo5B1fj9jMO7p/Cqsq\nTU+6OK4Id/3Q3zOFbApVN1XfkKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMM+GTpR/8UPCKeYfgPFRrIeQMncwHwYDVR0j\nBBgwFoAUjLDR50AhsMNf781xwGNmVnqJCBowKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJmJGQbcpmX1\nXzmMXO4P72KaUxXWpwPYLOz3Y8Q89prEAiAm2Z3FSdpiYX/a+EQ3wVCEZNmiceEd\nwKsMH3VGDhMpjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATx2kemtZLKcaEsV+H1iF5kpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWM4MjcxYS00NDkwLTQ3NGEtODlmMS02ZTY3OGNjZjdlMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbRhIrKZn1b6ZUO1aVtSWP9Vx+CAP7yQWOpd9V+FrFSHDx\nG6IQVGeDtnAn7YwoPWNFT/JtE3kCDFk3fRpFWYpfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjLDR50AhsMNf781xwGNmVnqJ\nCBowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANuLCyRgFdJguRHF8dcDjwenqPKKGzaNPKlpWbZoJ405AiEAx/xc9nSN\ng1Zl3LcGNB9wqsrEFDDcX/1BP8d0Qh9xPn4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAdtjsU+yBeR8kGpLvH0+w0orMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWU5MTFjMmMtZTIyOS00MDVjLWIzMzktZGQxMDM5OTM1MzY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MDk0YzA2My05MzY0\nLTQ4NjMtYWUzYS05ZTg5MGFmODA3OTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARqo14Q3ua4dydSaKqvN1TKsV223Q6zsB+gldBoWxb4TnoWBcEi7Dq0807q8KPK\nSbwrkXE5BgndmfQYU6huepR7o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQwz4ZOlH/xQ8Ip\n5h+A8VGsh5AydzAKBggqhkjOPQQDAgNJADBGAiEA5XbrYAEBQ6Qivjt5AG+n9S8w\nwhRdtfWSS/cMWHNaPMACIQDN1suhiB+zpc8aSGIaLTJUhtJQw8oKR8IS1EvCN51v\n3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2944", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2944` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbHbIC5zd53j4o750OdRSfRsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyODJhYzRlLTExNTgtNDMwNS05MGYyLTkzMjY3NmJmMjY0ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZiYjk2OWItOTc3\nMS00MTI5LWExZjktMzQ2NzgyNzAzN2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPkxG17Bt9EkQB45yUxV0paJQKbvHMxLP/Hl+1n8mx/wz0UxXdDPWatKcbfnN\nxonnpgoxR95xfMRiayzBiNq616OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVAWaACS3PgjZEbsQb40fQq8dyfcwHwYDVR0j\nBBgwFoAUq5Lt9AcUoBhVMr4603XPPKUYOBwwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCOtnswgjoL\nyxwJMiiuDo9F3U1ocy3MdCugIqEBGgAYlQIgXf7e6N60xW2WWmpGiKmpPDvyp+Fq\nC9NIsm7Bcx4tXKM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUGpxSbxmnNxAAf1G4DvcugJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjgyYWM0ZS0xMTU4LTQzMDUtOTBmMi05MzI2NzZiZjI2NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlxWnAP6QoPtNyhCgPcmqeP6BH6TVVtq1AJVZfZqanJCco\norbClWARHXVTffAXAjTec60Lv57eTfRKf5WK7O+Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq5Lt9AcUoBhVMr4603XPPKUY\nOBwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgL0ijNeKO3I6VXeQ9XbFtynA4Ukege2q7J2qIDe+zv78CIQC90Eedz87Y\nkNXJ0R+hEf5dootU+kk3yyEv+5KMY2ZxPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAWtyI28e4YIUYvLaDwODueNRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZiYjk2OWItOTc3MS00MTI5LWExZjktMzQ2NzgyNzAzN2M4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MTQ5MmFmOS1jNTlj\nLTQxMzMtYjhlOS04MDZhNGEzNzQ3YjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR53k/52k+3AqpQ9HF+AFoOds47XIYg7BIQa3NJKJaA0QCDYLhG00onoBNFJdHM\nYlnpzTJQrAcvyRyXMoVFRztyo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUBZoAJLc+CNkR\nuxBvjR9Crx3J9zAKBggqhkjOPQQDAgNIADBFAiB3xA1PKpXT/ShPuuJvbumpvvr8\nDaqiARSjqMwzNYi18QIhALjPFhaNc8f/Iz2UAvi+15qS9YvjsUb4hhi9On5zvAB5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2945", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2945` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXqavtgwM48qkEgq0SntUPQbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZTcyMjY0LWFlMTgtNDQ4MC04ZmJhLTEwOGZiYzYyNWVhMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEyM2NmOWQtYmY3\nMS00MjE3LWIzZDgtYzA3OTYwNjlmNDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp8H4+nD+QlZOlwH6EDUyIgiW+3D4UQX/uit0QR2RyqHO8cbRXff7kTPzfZ9f\nyi8XWrvXJtDm+p7pL2QeskjC76OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbQZ3MVJAQH+rijrU0Z9wxT3pgo4wHwYDVR0j\nBBgwFoAU2Jzgd7XRCelviW2eqy2I3a8KqmUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGn16Iubob6UAsYTgF6wy0HgQ8kdXCjTXlNzUmrIND+dAiEAsYdoLZlMGiY0\ngjXX8tRcz+fZnL1hv75p5f2gwykwh28=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX4MbkKy2RyjK4mBxvk20pZ5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmU3MjI2NC1hZTE4LTQ0ODAtOGZiYS0xMDhmYmM2MjVlYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/uxI7pnO0G4Q4I0GKTwpL6MJOsKMOYscuXjdp83D+O6RV\nnexYg6bIKWMLwE8L+wGWjbTwYng2k2sNizQfOAowo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Jzgd7XRCelviW2eqy2I3a8K\nqmUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWXQwyFgGFvB4GMdZnQ8N+yoRzpL8JOVY05JOIBVNanYCID3ZPST2oJzP\nYCyj/4voV/ci1DKjhBnbdj30hWj3MQeD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAdHNao+ScQhxL5dJiZVtvQiJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEyM2NmOWQtYmY3MS00MjE3LWIzZDgtYzA3OTYwNjlmNDYzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiN2YwODg5Ni0zMGQz\nLTQ0ZTAtOTA2Ny0zOTYzY2ZiNTEwZTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARmMmD+oQj8zE+Ync81WXOGEe7RA2PfnTXhJsP/9pheX+/3dqTdQETn0zm5vLAL\nOPHaFA4UjgUQ9V4TM0GICaMOo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRtBncxUkBAf6uK\nOtTRn3DFPemCjjAKBggqhkjOPQQDAgNJADBGAiEAnLg4uNrSPxkyGyzsjGv0uZ2M\nJI+MUZ5ziV0IngXSshsCIQDrEKAUpDtNVqDwtred/+ahWFgPKlY05bJXnSZ+Rj1Z\nGQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2946", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2946` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbrG+qngrlNIJZiMjrD6DC1bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YTFiYmYyLTg2ZWUtNGMzMy05OWM1LTIyYWYxOWYzNjFlMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ3MTM2MmUtYzQx\nOC00M2RkLTg4NDgtNzBhNTRlNDZhZDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERGIjRDSVKDIwBRNsmuEClUE4D4Be1Wwjew0+8G+SQlUtzNkm7u1224hwZhmv\nepn6NvDGPV5oWShr2TjrW7n8FaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsjSU89KB7IIoWwfZaKKjgIZVGNUwHwYDVR0j\nBBgwFoAUVz5ilBKSOFJqmmXJk19DmkrfQR0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCFMtFmJXDT7sd/O34fBAAJ9lFE7SdXJDDIaSRK6NTeuAIgHsmG8KvPmmbK\nd0n1PA2tD8mbHTeiVcTB+51cGN9vAlk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASK+UQBQ2X1t0UdsqyRkDIDRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWExYmJmMi04NmVlLTRjMzMtOTljNS0yMmFmMTlmMzYxZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQpK96BuptNjU5pJchpLYeZofHBk+bVUhVG+ZKgH6jjHzB\npH7s9cGc2tas3iBHpOBI6TWCoNEiSBiTM0ZRpazho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVz5ilBKSOFJqmmXJk19Dmkrf\nQR0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSuMkMt6GFhTpmgKvza2DAgyw7HoblTo4/5jCMC04USQCIE1pe2h3vkYN\nQ9KL/QK8hKNN7sTbWoKgSpSTd/5wYuQt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfuBbilfFHUG/UStqCg7eShPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ3MTM2MmUtYzQxOC00M2RkLTg4NDgtNzBhNTRlNDZhZDkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZmYwNTdkNy1lMmRh\nLTQ1ZjQtYjNhMy02OTBiZjE2NDZlNjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASqMh8vC4zSmOHGqVyKDpMCsIYpbRwFgECFyxwyhYOFoSEsvfdpRs26d8AfPyZC\n0oMxUzwCu8LPYootyUTYJlEQo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSyNJTz0oHsgihb\nB9looqOAhlUY1TAKBggqhkjOPQQDAgNIADBFAiEAwysAEHFDCVOSv/htT3I0StyB\nYCSFNCwL5KyxgusHPQgCIE3+BXbuoqpCFn7M04FVgEvGQZGCPfh/FYI2EHVGLLFt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2947", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2947` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAVHySnw9tmFZ68Vehhr9dHwFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4ODgwNmJmLTc3NjAtNDIxNS1iN2RiLTk3MThmNWQ1NDQyYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQzZjEyZjAtMjIx\nZC00ZGMzLThlMWItZjgyNGY2MWI4MDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgRWtpR9MiBBqp8oPZuOrMx/4kMuiqBLn0kVPeZ8ZH53FBwy+rLVRyLAJVSwW\nlCARYrYMv3+QRQVSFhVY0up1qqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOYpNLnLZZhC74utKKSJqBkGgRBUwHwYDVR0j\nBBgwFoAUM7WaEItbRYFfs4SqnhQP/EFyFHcwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAaw\nWD+toRgx2ZgOVo2bkOiAFMV3hfuHN2ynrx8ds4y3AiAJbBjzD9hcUvEZveLkHUKf\nE/pBPOwTfc/0kjcAA8ZSXA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU+A8rpJqw+tMBtVjGelWi2tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODg4MDZiZi03NzYwLTQyMTUtYjdkYi05NzE4ZjVkNTQ0MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7furOf1VVV/Xtz+IdOCD3MkimtvwH9528nmAsXfEwrrHj\n7CseaxD4Y4+Qv40Er1fiSCBZ8vI5sKXWPyTDUFtWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM7WaEItbRYFfs4SqnhQP/EFy\nFHcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP4cV4tGUYgxRZZ0FP1xWr5RWxGTw0jqxGf2A82OZjdrAiEAxp2RWXIK\nx6VZ64hgzmYLVqNx1eeIZNmc6FmyPJVlpcY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAaTfTy0N+RuwWyRhq3+MLN3+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQzZjEyZjAtMjIxZC00ZGMzLThlMWItZjgyNGY2MWI4MDI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NGVmOTk3OC0wZTI1\nLTQ5MDQtYjBlOC0zNWE4OTgzNTM1OTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATAPs2brBmdPSiavBfYu1HzYJhgo+UodQdCLR2IuqxPqZ2vGXQw/5Of0C4tibLY\nEazT/txQHqojZt+SGcjSt8i+o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5ik0uctlmELvi\n60opImoGQaBEFTAKBggqhkjOPQQDAgNHADBEAiAQ4/nrXv3xRF22vqoVMEKm/VZt\nVeOZnhaY/pS4eowNbQIgeZ10wF1BYkKUTmveiXLZZf8ZhjCJrB1Hg11zKCTmxTk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2948", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2948` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAadJJEMd4aFn6Nfv4pMuplycMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1MDVmNGIzLTM0OWYtNDUwYy1iM2QwLWIzMTY2MWMyODM0ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJmZTk5ODMtMDU4\nYi00ZTY2LThiODAtZjI5MTRhM2FlZjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkYY34KD6yAoGvl+6yLL127mz0fDBeGw70TYxsp/+mRIru3CRJaUs6iwr/dsA\nlTdV/UxPZVffUI01923PBdI54qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF765FGGYiBJCCsiQumuKYWUqsZswHwYDVR0j\nBBgwFoAUCZD1ZHj7zWsBoNz+7nKzoPjcqd4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIA8QonwqqmoxlDN+nYYN6GlcPcCkwoDY3VZH4YCRerX9AiEA6Rio\n/CjgVyjY82aF9UDRNMJXwnjxMqDZVydp0c1SJiw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXxKJxHxDcZDQ5XYQKGHW1YYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTA1ZjRiMy0zNDlmLTQ1MGMtYjNkMC1iMzE2NjFjMjgzNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLitXhS7q9qD/jMM+g5zvh8hTHh2t59MxvTwwFz1C0JkC3\nCkS08umtp0dSf2dDMG1i0zm96F6fKIM1Y/JAJlUCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCZD1ZHj7zWsBoNz+7nKzoPjc\nqd4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIHsqv/WbmlHQVGd1JRWUVWIIcZtUFL6vZkHop97Mk/qAiEAn4Sa8QeA\n/KlD83CZVBr3C7IuiaGefx8EGifn+v7G+6s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAXRJetqCtfWVgu1Mh7CNdNhPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJmZTk5ODMtMDU4Yi00ZTY2LThiODAtZjI5MTRhM2FlZjZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NjQ3NGEyZi05NTIy\nLTQ1MTAtODIxYy1mYjZlYzlhNjNiNDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARebKAxd97pJ12Ifsi6UPoWyOMqZlbtt4EChowoGjWX4uPMa23DcYi6dFfoznzv\nBLq+gfN0AIfHWmZEpUjlCIWDo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXvrkUYZiIEkIK\nyJC6a4phZSqxmzAKBggqhkjOPQQDAgNJADBGAiEAgpEh2CoyslONwe+lGqOPao72\n8OpfnKpg9n037h91sU4CIQCtMY//SncRFK6oJmUB7+fqSLHs2w/2k6AvfrRNqcyb\nhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2949", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2949` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAQBjCV4rZwhBDqibVxgv6SqmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1YjdhZDMxLWZiYjgtNGFlZi05N2QwLWEyNmYyOTlkNzczZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZlMGQ3ZTYtZmJl\nOS00MGIyLWE1MDgtOGU5ODgzNWJjZGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkrAKDzhBW+anh1YJsIIHIyHzHFGMAiQUl5gDI4gqynqfTJy0UT8vVvRhAQ6I\nnrIc7e/OOmdaBlAFj18mBQN+U6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4OeONcn2nyzDMXexDiecGG51Hp4wHwYDVR0j\nBBgwFoAUGmZcnPjH4KxR37VTvNDew7xJJmkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFvXM6HDoElx9UBN2UUKE6fL1p6dbyqm0aUZvY+UtyzOAiASjaX8\noJdLEgUUUy0S6s7fAHgzmXBZeH3l4GVAobmTAA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ46MR8QGARIDsOpLvXbFu3bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNWI3YWQzMS1mYmI4LTRhZWYtOTdkMC1hMjZmMjk5ZDc3M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ76KgKzxyEgbgqOdpz1ucIbo3aGIrySNzCb6l7aybUfoiz\n5F3lkpybYb3VXjNwCBuUGjsCKmUeJH12ngPByjFso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGmZcnPjH4KxR37VTvNDew7xJ\nJmkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPSt6YxxLL8fwFctJ/Lno/au/WhZ7YuTX7SWGJejEBZJAiABnvn5DUzu\nLmDQNUZQ83gYr26rcYOV5RGu09n5n3yBTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISATG9sGAMhm0mOEBKnLNcKWSwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZlMGQ3ZTYtZmJlOS00MGIyLWE1MDgtOGU5ODgzNWJjZGNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNDA2YzEzZi0wZDQ1\nLTQ4MjctYmU5Ni1mZjVhMzZkZDExNzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARsQxBnhQB4hT2VbCfCPz2Tw1GcbxDXE51xHHcnWNFKHEHLBud6QnBv8qcmmeQL\nJZ46XurmAG8X+RGJ1CjBsC2co1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTg5441yfafLMMx\nd7EOJ5wYbnUenjAKBggqhkjOPQQDAgNJADBGAiEAvL39sm4RSWjIXQCKY/CviE4m\n1GIcuUonW+3l8AJi01gCIQDKXeb1P6j0kd3Nz5DVSD8JSMhZicyzirPztpGRnAV5\nXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2950", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2950` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVYL86PgrUSumiWffcQMXmpAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmZDIxNGVmLTc2MTItNDhmYi04OGM2LTU4ZjU3ZTZjNzRhZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzU0OWJiMTctOTdk\nMC00ZGMwLTk1NWYtNWY1OWFkMTBkZmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC2UvONR3TfKeGAmMIiBwJDq6CmcgdPLE/ZvK+iw1g6it7kCENI1XcC8QpUKL\nunUYSRsrXFMXBgKrHB9gm1yiZqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTBNqEUj6z+bSbBsFQ1aSjRCPG3aDAfBgNVHSME\nGDAWgBQEzx8luuYQCfASMN/dVhA/Eo1I/DAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDjQYbhb/DrpGH+4FwqlyTAGIQLNfR5\nFEKeU2DhH/DDDAIgLSSTGfAX7xoaN5P1GGkaZa6f2tge3S2/u2ukGxVilZU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfVQt/s6EWiXDHn2RqeULpLMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZmQyMTRlZi03NjEyLTQ4ZmItODhjNi01OGY1N2U2Yzc0YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAJSqOHoMc6oRUCMy2yIiEohb8jfu4wugGqeE2Sh797nlk\nVUdQa8HAqMPSKxXLNH8xIlB+HcB7UBXGxhcRRH3so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBM8fJbrmEAnwEjDf3VYQPxKN\nSPwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCU4qAOj5pnye0FV65hoG1ncXsP/dtm3jwvo2auIO7r0CIFAXzMur/6oN\nMcLbRDEtdbgqa284K8EsS1D3L1okUeb+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAaQg9d+xY8Gx8MUcw/pYE/GwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzU0OWJiMTctOTdkMC00ZGMwLTk1NWYtNWY1OWFkMTBkZmNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZTc5YjkzMS1hZGJi\nLTQxNGYtYWZhOS1jNDFmOWNjMjFkOGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3/1fqejOkOoMOVuZlodGByYIhbLBjjAwQmp5mjrjrb6roiuBEWk1bD5QX0c0W\nP7jM4p+ds9i+JbkmUlyAshPKo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTBNqEUj6z+bSbB\nsFQ1aSjRCPG3aDAKBggqhkjOPQQDAgNHADBEAiABRWVFRpMUTxa1AZGEyMWEDqmk\nxmS92JyMQrrWB/EhpQIgZjs7puOHkz2Nf0KoEBnifPorRqwEoN2USGSkEbQFR+4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2951", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2951` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARukmlwrUxxsaxeV88b8KfwsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMDg5MTY1LWIyMmEtNGQ1NC04NGE1LWE2ZGJkZjdjZDg0ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFhMTM1ZjgtOWZl\nNy00YThmLWIwM2UtOGZiOWMyODg3MmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr02gBGqZ2OV70z5qj3FQSICEP0W10X9/EIuL9C7158+BPKAial1BKrFP+nFW\n0gh6MnsnPQcMScYuHGOypts/vKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn/utE5BJMpV/E8wCrJPdFn3fwmcwHwYDVR0j\nBBgwFoAUDTsGw578HZU0h/75xAYfKNOtw0gwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD3gBQcU1PT\n34dFzVKmgXwsCiBD2s9YyhzjRHAjt7DWGQIgeLs2C8luXz9TFIa9j8awt2dqOiDe\nTkI9G06O5R4vWrY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXU9UiBBzyYlOeF5fyy6KTCRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjA4OTE2NS1iMjJhLTRkNTQtODRhNS1hNmRiZGY3Y2Q4NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT63JCFg1TuVWoijJJfLrQUdMqldG09OtbJMekfkzNv5Vut\n+Agj4Wh6V9Mb8ZdfhIWEs6SuHGJPj/oO4+y+fMsSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDTsGw578HZU0h/75xAYfKNOt\nw0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMUSIP/PZTBnh1rZxvZVLaAnV+PHwBkirS39pjEN1GxQCIQD+mmGU1eBF\nXc+umhu+VEXUSkF9ZQCpvSUKAubVEv70zg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAWvmkKqZW/k4PZbut2Rqj/kZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFhMTM1ZjgtOWZlNy00YThmLWIwM2UtOGZiOWMyODg3MmVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YmQ4NjY5Yy00MTQx\nLTQ0MjQtOTkyNy01NDJiMTc5MzIyYzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQY+k7S707YeEhHkUbU/7+wc21Pi3MpEN1RRd+FX9ndpxDsS1AelrzW95L0hSq9\nntCAC0bgFBxp7j0Qn235OHw6o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSf+60TkEkylX8T\nzAKsk90Wfd/CZzAKBggqhkjOPQQDAgNIADBFAiEAsw9ZHiDKS8X93p6fOakJHQto\nGcJlSdfv7aIvgTxaEWQCIGXQVZpvS3ty5DzrhqY+yc1pQ144V6sajul5NDxtaSEI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2952", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2952` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWdrb45xGwSgN/+e4pLoXlhxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3ZmQ5YjhmLWM0ZTMtNGM5OC1iNDg3LTc2OTQ4ZGUxYWEzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBiNTM1OWYtM2U0\nOS00MjI1LWIxYTktMDgwNDI4ZGJlZmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDjDCiCXoIj7zeCqFUerBAqdcSu/mNFLRtXFRyNJqos+46n0SquVua03SIlpM\noUzjrjFQHCICWowszy73/NTDlaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9cSQG9MlQOxwcfMWbOnYlbjBhlYwHwYDVR0j\nBBgwFoAU1TuU0TeUPwLM2iR5zs2x7kW81bswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIApdeii0ly8w\n7Y7Z6Vbz6X2U+N82oBCOGsCpY1sFYmEiAiBagI3wYICXm/HYdj8KFPFnIxe9XrZv\nqCtoeuFT0BUBqQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfvPwT8Mmxng8Im+oCqvdCR8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2ZkOWI4Zi1jNGUzLTRjOTgtYjQ4Ny03Njk0OGRlMWFhMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJmyj/uWoHULM8OdUPFBVVgiJ1at3tsn65dLqIpLHRRZPo\nlNs+aglsvxXlIA9yCF4sTXqWfBwuYYjo/owZ2OvJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1TuU0TeUPwLM2iR5zs2x7kW8\n1bswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDfEvlwVVoz8J33xue7iMz/hU09iBos0NEY+3+p2M3o0CIQDkOA9/zqNf\n5m04siN3n7EcevY/RUwSV4yn7Fc21DFciw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISASuvPLSJeek63tRfBllUb9RhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBiNTM1OWYtM2U0OS00MjI1LWIxYTktMDgwNDI4ZGJlZmE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YTg1OWI1OC1lNTE5\nLTRkNzYtYThiYy1jMmI5ZDUxNDgzZWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQutlAuEhu0QQSda6vZtA/QatieMA7spwz492BB9CFaS6cyzjD3PBUeugoI4XAO\nOIueFpy3ggld+xb0haRQaJZWo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1xJAb0yVA7HBx\n8xZs6diVuMGGVjAKBggqhkjOPQQDAgNIADBFAiBVLYd8UaDbnjleAEdJ5T0eC3au\nUQJzOCW09yc2IVUr2gIhALBpgxMVOa0TMGGQ0kweJv72QuQPbscRtYL8bkGtmT9s\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2953", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2953` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAWNUuYUiZnwij6avsNhj5eplMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4OWU0NjU3LWY3ZDktNDZmNS05OGIwLTk4ZGIxZDk3MmJjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc3NTVlZjEtMDIw\nZS00M2U0LTgxZjQtYWY1MzE2ZWQwM2RiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnmSJXk7GzfblzsHtDjKP9G41DKL343gw0aYr49Fp0uL/Oeptlgeo/dSmbxyG\nYLc5yvJhJGaLU2N7ud+olYeEWqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT+PMPAtjsnibVCuKDLProSNDDU0wHwYDVR0j\nBBgwFoAULi+QRIuSCpVcDvwaEhh2sNtVHOEwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiArXJmuJH9i\nKACVX2uhuhTFz1qozdcTLhkHgMk59jM03gIhALeET4hPNIwIvM0Kd9WU2iBm0ppF\neZ5jh88qsRMgyeXL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeAdWQ/TQ6hwlp6e6Es16DXRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODllNDY1Ny1mN2Q5LTQ2ZjUtOThiMC05OGRiMWQ5NzJiY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPNccLou8W5u0+7cD5+LRHluGmpHo8QBnV78DCEzMIKQUe\nMSUnxbCNBOSxNs+a6CygE2aaTMr9zachYSkICNMto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULi+QRIuSCpVcDvwaEhh2sNtV\nHOEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOJTE+WpwCQICl9cQAnya+jz/ILtygq1QgK4HD5DYCjkAiEA7OvgqHu1\n0tV2NGnykeWxUGc/7B7MleRUEODT1Fo4Uk8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAT1HkoulalJxJLQ7SK0FULvJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc3NTVlZjEtMDIwZS00M2U0LTgxZjQtYWY1MzE2ZWQwM2RiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMjkxNDVmNi0wM2Fi\nLTRiZGMtYjFiYy05MmY1MDQxN2FhYWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQjWtEy+FtQe4KYyc//VLuiXAFmzqPiYaOLWkAWI93wkqUaHIWIYL6vDCUsJfmS\nbxASBmLHczYxHNKhU+hPQ6OAo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRP48w8C2OyeJtU\nK4oMs+uhI0MNTTAKBggqhkjOPQQDAgNIADBFAiBoWu0a/V9NREsd8zcY3KGlfwLJ\nGszC4TnFUbWpf5kLYgIhAMBt2meZi+F213Zu0WPQU+aYLvecF9wrJyG7H4cm6CVx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2954", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2954` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAReQz+lcpAUbjMOCDZu3qMzrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkOTBlNGRiLTZiMmEtNGUzYS04Y2Y1LTgzODRkMjI3ODQ1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmEyYmRkYTQtZGVi\nYy00YjA3LTg0NDgtNDU2NTJhNjgxYWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo1UEpIsckzv/bg4gngvxMMtC7vVtOnSNZfaPS92l7QzRsBSLb855IQd5V1Em\nUjEbgLofC8g6QKx1lP4ap89E/aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU83YFCBxCnv8oCDj/Ylo6CgpQWzcwHwYDVR0j\nBBgwFoAU0pWP34/EcRKMLCArCm1IcH1pJPwwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA6LP363mWA95yIPli+kV65YolT0bJA5BELIvPyVGM/ecCIBX2/WUENAkk\n4dkPKXQ3a5/DNVzkQWaEszAnONM2kbKi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXD35f9YXU+BZaruJXd+F6REMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDkwZTRkYi02YjJhLTRlM2EtOGNmNS04Mzg0ZDIyNzg0NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPaqBPkHLVta2TDGSAVzb+G24Je27IoBakdphxAiR8rWKy\ngDFg87kbdFm7VImHVa2SoDwDyoELTVrU+XxI8whMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0pWP34/EcRKMLCArCm1IcH1p\nJPwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJw7ZrP7RkLdKpInCI4Kk6ncUrAJf08z5nhJimN67CoQAiEAqzoac03G\nlRKYI1Uj2r76jDjfF5U9ZdpOKor2cfWlnUg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAR4f3R4vgmH9kYsOC/bwX/+hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmEyYmRkYTQtZGViYy00YjA3LTg0NDgtNDU2NTJhNjgxYWRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OWEyYzM1Mi1jYjEy\nLTRlZDMtYTllMy01NzM2MzA5MGI0NDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASZdV4tZZKE21CWblVv+S2I8z4dOwbdPskZtKtxCWEwqujJ/C8CazjHUel1dlXD\nFXz9j9DGtsSgo6GHCUm6OMFvo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTzdgUIHEKe/ygI\nOP9iWjoKClBbNzAKBggqhkjOPQQDAgNIADBFAiAfZyUW2jF5c5mxBZhnEDxvO8Lu\nkCJHmf+tPffKhUGNKwIhAMIiVDVm4ooSTrQ/Jja6go4OPpwaW5TuXyKHfDfY4sEr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2955", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2955` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISARrzlDSTfJxh0NpvmuF9YUXQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzZDAwYjAwLTNhZWYtNDk2MS1hNmZjLWExMDA3ZjU3NTdhMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FjZDZjMmItMzQ3\nZC00MjdhLTk5YjctOTc0MGQ1Y2VkODQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3OhrBDNBKLYNRvncKy8fOhn5dnG0KhZaPUUM3B8bG2khqyaH2wzUAXgTsSx7\nP1PnINtUYkuhNQ61qV7VPJeCkKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDlWf88FdZZMkFHcOV/UI453glPowHwYDVR0j\nBBgwFoAUTXhSBrjOW18Pw8K3vY5QEr4bP/IwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAhH45ZnAyUI/Uzw1df+vYRAg13fkZfOU/eEz8e11grJQCIBYGFvEiZt3h\nm8TlMAr/M/YZnh0RUlyMkjW52UkCUS6q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYbdG/cpNL4t5D9+TULIwjTXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2QwMGIwMC0zYWVmLTQ5NjEtYTZmYy1hMTAwN2Y1NzU3YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScu7YHst/79QCesd6OU/VLmJeBNhLhRvsn+De98wEWb2FL\nudDpyJ6B5FzRUJVrPrCT98UweEDMaY2HViEKfPJ2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTXhSBrjOW18Pw8K3vY5QEr4b\nP/IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEwW35ealOt+3gMOzzEPYuORyycyonnYuNXnJtYOT/SsCIQCGezFcA4e8\ngE1++/10/uc/jvs8rGoR58uWW0UtM5EhKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISATDmdnInC+L7IT0IVEZj8TY5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FjZDZjMmItMzQ3ZC00MjdhLTk5YjctOTc0MGQ1Y2VkODQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNjkwM2VkMy1kYjY5\nLTQyZTUtOTc5OC0yYTNjZTljNjg3Y2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASPN9OT1L5g39gC4zvlRUXo07mgEly8wKDMsFEmDyk1xuMMqnvos7IXYB9EtRmO\nZ8Cl5vSbd4FpLMgN/VW9+tWLo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQOVZ/zwV1lkyQU\ndw5X9QjjneCU+jAKBggqhkjOPQQDAgNJADBGAiEA8TM9auN9967Dx7kV08ejvmA3\nMY4JY7dQx2dJExka1zgCIQDrer9MNh+kcXrIkrqE42ov2EjlsV+MVdzbpBMg1KT1\nDQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2956", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2956` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAbXVYGL+oJmf44fST08TFtspMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwOGQxYmEyLTE2YTctNGY3Ni05MDc2LWNlMDU3M2U5MGEwZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FlYWJhMWMtYThj\nYy00OWU0LWE5YzktM2QyZmYzYmJkMGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsmmjsRIktdfKho5xlDko4iSI16aX0Lbpsq9mWMI31cxPvn7wA4+xOXEf2qdj\n0G9agRVSOjGHlDkH1HRjBJ9J1aOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoGDeRAiji6F3Sm62jBGHEzckEzAwHwYDVR0j\nBBgwFoAUbEFGkwe59iU1xjStcv3RXvA2qnYwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAq\nMEHQqIFQlQGuXerRASx1SWrOA/VfTTlFOAmPbL7aQAIhAN1rmJ+n/J+t9J5nF7sT\n/sEULiwNGJnlveDEz6GKEUwG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQwv6C3pUVgkIbi+HUirxIlzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDhkMWJhMi0xNmE3LTRmNzYtOTA3Ni1jZTA1NzNlOTBhMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdazbVExgpoGiZTZm2qmchd7PuT5eKUDm2VKOX7M93BAji\n0WrJ6BGpy7H8ApBDyI214cTbA+idlGsUHIKXHnvxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbEFGkwe59iU1xjStcv3RXvA2\nqnYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDy13KyZXfi0OVs/MlNnTi9zzLAq0SnhYaO39UqOfMpMCIFk0j+K14J6/\nBj+X2IXWRMVy28KMRv+tDQSUnLYhNWdq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAcR4dzsdnYTSTT3IyU/PPVtVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FlYWJhMWMtYThjYy00OWU0LWE5YzktM2QyZmYzYmJkMGFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMWIwZTJkMi1mNjU2\nLTQ1OWUtOWJiYy0wZTE2YjU4MjkwMWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQztqoUBpK6ci4yzgFb+kdBmxWVbeHzCSkP+WlD694a0tUu9H1obg1R8meSSn7/\n4WRHS8l1dmTrnSO0YEQ5AyULo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgYN5ECKOLoXdK\nbraMEYcTNyQTMDAKBggqhkjOPQQDAgNIADBFAiEA9TJlfat4MYCp8yKv4TaW7tjW\nQ0uZNjuxznUBEYkD33ACIGc02t7caQBaeJcth8lN7dykK4w2D4fY4kwS5UetWuKj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2957", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2957` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASwMfc6YDAofv6KeocJw/r5DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzZGJiNjU3LTA4N2MtNGI4Ny05YTZjLWM3MjVhMWYwY2M5YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWE4N2MyMDctOGVl\nOC00NzhhLThmNDQtN2NhM2Y5NmIzOTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaFghhN9h/Bf1dwZsWzvTBFnFm2YmrTF9VglMpxi+w9g9Ew2Is4quBOFJg9Ok\n9EclBvT6Q4lqiCAJodsA4U5EbKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuaE1q7EYwZ0vKY5FMcJ22rJ/X+QwHwYDVR0j\nBBgwFoAUoy5Eb8kClmFsdPEFrJkhLs4cH9wwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiB/H5WMvMrYVIsh2WIs26Ptw7fEs1raNgvwLLeYWSIIhAIhAL6m\n6ahfjEvFLdMT8gpwkgvaRqtdkobi0RN5v8WJXFg0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW75ttvacw1PfjGEDE1k44OlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2RiYjY1Ny0wODdjLTRiODctOWE2Yy1jNzI1YTFmMGNjOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASC7Sj/T6BryhTNJKXUzVSRXT6uPNAapdIlJ55SQUz2Ldh7\nRBlEyGvAdZRFKJNCFr4sRDkpqV4/PtVbtDpeGGZ9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoy5Eb8kClmFsdPEFrJkhLs4c\nH9wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ5aJn8P7Y2fqVy9LO68pALmH5fR8KvJ17QORnojjVfcAiEAsRC2u6iZ\nsqPnSF/Nl+BKIzVmDar+GGpGVQHVSNJ/L+A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAYtPdbMPb8E400M5YlBwqlW1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWE4N2MyMDctOGVlOC00NzhhLThmNDQtN2NhM2Y5NmIzOTkwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMWNmYmUxYy0wY2U4\nLTQ1MTItYjhhZS1hMzIzNTE0OGJmNGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATfKX143fnAD9h+WnewXvmhEtizOoJURStW6B00jC0OiDQDtiQbBdsk4GjP3p8j\n1U6fOZHlYBFdbRvpKktmezyRo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5oTWrsRjBnS8p\njkUxwnbasn9f5DAKBggqhkjOPQQDAgNJADBGAiEAhXTN4vb74KWq1Vbp0j+/wEwC\ncepYy1RfyjvWiz+z6UwCIQDohPMf79RlJGVHQaSRZcihXaqKJM2tZXQVR2jP2gi5\nXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2958", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2958` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAUu9jRfPB2kUZAjiPWVnqJXjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyMGUyNDY3LTY5MDgtNGNjNC1iNzk4LTgyYjcwZGFjOGRhMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdlYTg0YjctN2Jj\nNS00YTFlLWE3ODUtNjIyZDFhOGNiN2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcbC8/cN2EP9NgMqmAwJj4404YyVBkG1m8iJd5h23ce3SLT4siOGyqpnB1A64\nNBu/SLPGhqhHEXEuy1zhBTA01KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj2fOqgXLww3z3UBNF+a9zq/5cR4wHwYDVR0j\nBBgwFoAUUEMowhddHwzc+Tlls9vXHUvOSDwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiB11PgqGc0FNQdIHMFpdXNti85L6b4pJvvRxRiDwTvYRwIhAIiC\ndn8fNww5LNBjwXvGpVh45evVaEsBkiz24xHSt7qq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYFVngWil8eCfP92DmeJtgQZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjBlMjQ2Ny02OTA4LTRjYzQtYjc5OC04MmI3MGRhYzhkYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7/NhawV7kI3FPRhbMgmlmWrgP3sBKb85ohuf7n9P70clX\nqxDSMHMk0W+CBjCydEPKLRaAh6VGQcGOi1FPS3m4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUEMowhddHwzc+Tlls9vXHUvO\nSDwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMNXByAJfEjBIVq8wNFcdBzHKPSUjTRbXRIMWpse6XRICIAiYAjWjeNvU\neVaxiGSxqk9UTYq2IdXUc36TCDtJ967Q\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAeMCT+dq2elUYLo22FjjZNULMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdlYTg0YjctN2JjNS00YTFlLWE3ODUtNjIyZDFhOGNiN2Q1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MjY3OWZjMS0wODA2\nLTQ3NjAtOWU2Yy00YzZjYzVkNjYxNjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQrjTA/OskJYtgvqfpJuo9t7iEtP8cccti9QWXa71NWJA+gmc8B8hKP5S6EWNzn\nGKZgZB91MMILMQORM7t2F4kho1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPZ86qBcvDDfPd\nQE0X5r3Or/lxHjAKBggqhkjOPQQDAgNHADBEAiBCQuGXt9qzjqYzMF5JusfSa2xo\nbFeSDXvuQfN7lMxRsQIgGC9epryRZu8EbEopcfBpcPzfVQN2VfGSiZnB7fhi5IE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2959", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2959` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAVUc9DueDmIqZVJuuG0sTIyOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMmZkZDRhLWVhM2UtNDRiMC04NTFjLWJkNzU2NDRmODM3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkzNThhNWMtMjU0\nYy00MjE2LTk4NjEtOGE3N2I0YTA0M2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvBbgcOdMzKcw1tsKNo9IXmWITX/U27rzPHJBUw2liiu369uaFJ1uuDsBuyWi\nd5pmmR1IqsNdNZTOcCwj8Fz8xaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzA51WguE2D8yRPkBgilrsUXxcjMwHwYDVR0j\nBBgwFoAUUVOcRJCuIvqdWmjIMKgiv9NPROIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAk5RRwL68174td\nAmYmu062IE+KegrhJxFdP3UHQq2gIwIhAOHLZWqKi1Rl47F8mcyn1EXuFwtUr2Vs\nYsp+Ka1qYEpq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaAAHE1mIW1X6sbhTHXMRFkOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTJmZGQ0YS1lYTNlLTQ0YjAtODUxYy1iZDc1NjQ0ZjgzNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQb1D4GzunAENxA1lZK+Wu6kCc+swReEk5u+EWFVcUTPKw7\nfXK5Ypl3fqhJsKrao1QsQnzQeQWetv0CqWhjw2iXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUVOcRJCuIvqdWmjIMKgiv9NP\nROIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJkmUDKpIsXAAAJcAragrIVSyZBhMgnKt3LxwuJ+9B20CIB/cYNLJzdQH\nz2zm16AFxw4HD3QO23VyAmRXO5QRheHz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAUDU3hfVJ72b5ZpMnoiau7OxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkzNThhNWMtMjU0Yy00MjE2LTk4NjEtOGE3N2I0YTA0M2ZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YjZkZWMzNC05M2Y5\nLTQ0YWItYTlmYS04ODFmNzgzMTg3NzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQH+a18mRpvxUqgm48IRq8FK+e/9IPDh3YmulQchoOvrD0bMxN7HbS6l4OgR9ZH\nj/up9CUXIyh4cCePtZgk6DHTo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMDnVaC4TYPzJE\n+QGCKWuxRfFyMzAKBggqhkjOPQQDAgNHADBEAiAflUkXR0OtU2jqj6Ms9tZDDOVg\n/HNKr9ozRZcL94BCFAIgXtpMhFJVLxTXHyOFxbnSpF79tfHlp4otE/zu59iZpyQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2960", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2960` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAX27xEAZv6kCi4XNktshfYZvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1ODY4ZGYwLTkxMmItNDczMS05MDA4LWU3MTVkZWU2OTEzNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2YyY2UwMjgtZTVm\nZi00YTdiLThkMzAtNzQ3ODQ4ZDJhN2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHLUR2QW3vlVKoef70LN7B5TLABhZN9lCk2Z/dV6xPcGIPFk3UnZjRzbU8OGc\nhO+PK4g58FhyKLJWtD9LxWJOtKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcXCO3k/nq7R1Qs41dh5JxTZIZkAwHwYDVR0j\nBBgwFoAU+j/yzqT9Uc6G11g2177EjqNYUEIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDMezUqNIGU2h5bbipgBB45YHW+FuWCjUDvUlynKEmESAIhANueGWqSWh7v\nHC4053UoNnJU7JWEzhQi9HizRlP4dp2A\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATFivHQau2B2HDXFcxXPctZdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTg2OGRmMC05MTJiLTQ3MzEtOTAwOC1lNzE1ZGVlNjkxMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYcNuzkYIhYVGkUVAh9de7BuyooC5p44/UvIGYF7Q4vN3u\nZmKwsFexmWhl4g1sIAckXxzi1z5UmJu7gEAWtRjUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+j/yzqT9Uc6G11g2177EjqNY\nUEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMiVtNQ/1DvYowOlqUJzewHMD5GdKkzDa46LtlPih2UaAiBMKCdLmbzN\nZRXRnfLc/DpY3BEk+yCMSXPTYm33ggrzVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAT9f7vSnS3zy0qXZfH8WA4lZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2YyY2UwMjgtZTVmZi00YTdiLThkMzAtNzQ3ODQ4ZDJhN2U1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZjhlNmYzZi02NWJh\nLTRiNDMtYmU0Yy1jZWVjMGVjODMxNWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT4M5Zi3Jj6jp0i+gzgnlQLWaiVnU9cRO4aug660KVMgtcfsSNVleATV1bELtvJ\ni6ErE8TCVDG30AwDL5JTB/Vuo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxcI7eT+ertHVC\nzjV2HknFNkhmQDAKBggqhkjOPQQDAgNJADBGAiEA8VBJ0vbpPQbfc97mbl9hMWTV\n7yGbpLyDaXEKfToh/AkCIQCuVA/9iabbRPl4kHAQlozJukfn4S527E/51I6koxF6\nbw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2961", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2961` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaLusTd435YzHAl4nhknyPUcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlY2RjMzdjLTEyOGEtNDExNy05OWQzLTlkNTkzYzc1Y2QwNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM3ZGQ2NmItODMz\nZi00N2U4LWFmZDMtNzdhNmUzYTM4ZGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt5S0k0UsSp3ADYZPSmqof7GPmSsts8rJAWUj6AcbTKffM3o6EGLq5rXrwIrt\n3gM9C9YjGUeqvWiTHbFZoB2d46OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBMtQ2NTRjxvAprm5KCR5tChEWHgwHwYDVR0j\nBBgwFoAU8v3Zys1/LZqfKIhm4zD/PtCwAsowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGTbNjN6FDhwcnRZheS3zannRLR7rBOuCJVeuqGzO4G5AiEAtxFJVNrnOlVH\nR/H7jJ5n+AOqNcN6Gwi69VPtsRryWbs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYk6bqmcqzip5FmuxQaDx6QdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWNkYzM3Yy0xMjhhLTQxMTctOTlkMy05ZDU5M2M3NWNkMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATACvLgjvyJhO4R/B0Q5SaFRgpsx8ovoJbJq9LfvpvBY/sy\nk4hzQ/rXaQgmn7jhBXNEa9xNSYfGIdm3Ne/w3p3Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8v3Zys1/LZqfKIhm4zD/PtCw\nAsowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFgjy9PZU18lTfFFxFDihFUYDjY38Z9p7lxRqnPZBtO8CIQD6wc102wnA\nLnF8kJ98DZplI5ix7Gaebv28BwkrBzy8eg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfssNKeBsEL+Uu7fU2ydRc+jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM3ZGQ2NmItODMzZi00N2U4LWFmZDMtNzdhNmUzYTM4ZGQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZjliNmM1Yi0yNGUy\nLTQ5YzYtYTU2MS0yYjg0NDI1YzYxNjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQKz5tOG/2FaV8EII8fdKe3V6/YL0X5eypQIyGYBbHirz4EOzBx5ZAgbpAVrqny\nur+9EPa/uvAwOfB5vbQOrif7o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQEy1DY1NGPG8Cm\nubkoJHm0KERYeDAKBggqhkjOPQQDAgNIADBFAiBMTWQ7+5uDdbHl2s/CGuMfTTfN\nukIQzn1HH2JwYdQpHQIhAJdDcQutcJA/ZA1Pvq/MqvQ/nKQMqxQ+WyyornG/V4vP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2962", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2962` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVB7lYad+E5jAD6juJM2nUlJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5ZGFlNDk4LWNjN2UtNDk0Ny04ZWRjLWUwMmNiYmVjOWFmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZhMzBmZGQtMDQy\nYS00ZGNhLTlmNGMtNzAzYTE4NTg5MGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6LDeZAm4frGgCIlO0VZQm38ltij4555VA4K4SmJAXEa4hV54qac1zomU/8bj\niw7d626zSm+pmRg3o2nfMFB/faOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeai/rMCQdAxTxUaNMOo6kTd7jdswHwYDVR0j\nBBgwFoAU+ipsEuoEu2IWOgVyk9RBrKLUX/IwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAjHXI3w0IUdh+1M3Al2q5GOQJ2dWSI9r2ZX06+eZfqB4CIH8Mwavpkie8\nY61XlSH5AlDKwoHBDS9VubcfUoSYntfA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVRah2ua6R+e/0IpbQnuokS4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOWRhZTQ5OC1jYzdlLTQ5NDctOGVkYy1lMDJjYmJlYzlhZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAST4Wz3U6dOaYlt1Tw5BYD0j8YQ4aLZjBtpfT7QmHZHFZII\nsHZyScMmbtSbdGPF+Pdzl5tkBi8WxFVuypiXPsU0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+ipsEuoEu2IWOgVyk9RBrKLU\nX/IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKA3LjzQH194iuL6pWqgrlcRBXcfApa/tIUQin5xeTlHAiEAg4rJMIvr\nocKEMC8YmO2cdw5Gv1aoKAxZ146htoNI4GQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAXzJhJFwqWz/ZuTidNqlkfCbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZhMzBmZGQtMDQyYS00ZGNhLTlmNGMtNzAzYTE4NTg5MGFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZDI0ZjRkYi05ZTEy\nLTQ2ZGEtOWYzNy1mMDZkY2ExZGFkNzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARf/8vXgjhmtVGy1j3S5/VV1v6feq/lAXdnzPZ4sTofIjRv1lWaMRtckJ213QmO\nJ5/YYQqt7JFyDu6bQxIhxKuBo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5qL+swJB0DFPF\nRo0w6jqRN3uN2zAKBggqhkjOPQQDAgNHADBEAiB9wUTmNsaQXFAPfhXcpglBv8Jp\nSWBFy0lHUOSK/+AGxQIga32Y+y4eDz4lsqwfkDhPVQ3U0kCGNbKDDbBGQ3Vuh0g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2963", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2963` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAebzSwBi7dH8bjHf4Mt831zqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjZmZlZTgxLWMyZmUtNDNkOS04ZDQwLThkMjAzNzAyYTFiZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNjNTdlYmItY2Fl\nNC00NjNhLWE5NmQtNDIyZjU3NjRjYTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqrcp3yf7g6WZn/EWoXuS5NRtrn72Z9uIYqzVvFRe5ZEfPt0hEQQh4UFODxEo\nzu6ykWeWdT7H1wLV7d3fXWBaxqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0IxcQS6J9aR4T+RO7Ql4XOE8jxYwHwYDVR0j\nBBgwFoAUtR0Sv0kz2kPg5zynbWZQx0muk1cwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAnpUPckrEbD4mmSTLql6wLaU3IkNlkMfXfo3AmsYt9\nbgIgZV74xRYJRJ86/+xowFTe5C6w2qsvCOIkB8UZLWnlBsU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdY4XzzW7bVp/g5mQmIpWP+TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2ZmZWU4MS1jMmZlLTQzZDktOGQ0MC04ZDIwMzcwMmExYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARK1DtI0jupxnuweleV8yY3N1NKRCAgP5FVoS6neTVSAHPW\nCBpp3GyRsWBLQ9rylDKW/bhoFvwu66DE2a7aNBuJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtR0Sv0kz2kPg5zynbWZQx0mu\nk1cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcrK2/1ITAn8tWpE1sXcuox1406t/LLRlA0X8JUUCgZYCIQD/gY5rd8Rq\nzsU2GBtgYepPf8NMDo0GH9De3uQ979C4sw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAaJExKRPqgyWRCCEea97SV3oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNjNTdlYmItY2FlNC00NjNhLWE5NmQtNDIyZjU3NjRjYTY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2Y2UwZGNiNi1mMTBk\nLTRlYTAtOGRkZi01NGE4Yjk1OWZkZTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQINfj+TNmK4oW+osMLtqBkFf3V15CXxvXjJZwTtx9eGrekrXeXab0h1ci+QJd3\n//F1hwWX0tfgZjfGiGYpEZUno1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQjFxBLon1pHhP\n5E7tCXhc4TyPFjAKBggqhkjOPQQDAgNIADBFAiBZT/PbAJrqkUy9oET20ECQUcC7\ntjQaRfwHRxsLA4CQMAIhALqfQIW2Nad3thLv0NfuP4r568Pbz7852a/IE+VPPWOS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2964", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2964` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISATYvhcWYlJ9fPD7G2Kf0pQoBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0NGE5NzYwLWM5MTItNGJkOS04MzAxLWY0ZWQ3ZjQ3NTc2NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhiMDdkMjgtYmE0\nOS00ZmUxLWI1NGItODNlYjk5ODE3Y2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3RWLbpoNWOQWGfmXh5F2nk4J3lBTijtcncFi/waOeMCN13wbBa56zmBZ4gv9\ncUS55ZZ3wjr17yKlJx0s6YKR3KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfeMkja9U/GIc20HSHG8L0feL0q4wHwYDVR0j\nBBgwFoAU8fepbTG4OKoV4eR/P82hvb0SjtQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAr1Xvg2fxNXTQa9RIVeeOPSMAPkY5HER732wLMLME\n2PUCIQDx6YvSP4ZpI43bp7X7b4eFqB4FmqNQwseJj1UUBDIlVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbCTxeHsS8EUsrneUrD1ZswJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDRhOTc2MC1jOTEyLTRiZDktODMwMS1mNGVkN2Y0NzU3NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRmUWcVnWnQNWYfwO7t8F9ikDUkzYFmEWgeRQNo14jpSMk\nTXgL3aSqXaIffd5YAYls9falx/lMdfx73Jhp31EWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8fepbTG4OKoV4eR/P82hvb0S\njtQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPvvtp+fVgF32/PXdKteoNf9frXRnQ9Dt+DX2G+AxChsCIQDLcoz6zicT\nrdpBLlBeFjV/xQWnVRhL36SvelbHrelUig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAUft+qzSK3PM0fxX+kQT6vhXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhiMDdkMjgtYmE0OS00ZmUxLWI1NGItODNlYjk5ODE3Y2MyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiY2M5MWFjOC1kODQ3\nLTQ3MWMtYjRmYi00ZTI3OWI3MWVkOGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARUBuOU6zow9wroW6G+DKEj38nqrPSodsE3NJjGrRzwQ5Bp5nsmOHQYkW0yLA84\nkOVuc1FY/AZjrZHvmAe8PX/Go1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR94ySNr1T8Yhzb\nQdIcbwvR94vSrjAKBggqhkjOPQQDAgNIADBFAiEAqZUI76SCw5Ww0bVs4K3ZPnMJ\nr4YLwQHXWYxSCtpv0VYCIBvnkqDJw66vnRKGaUU/XvkSvrBg+mVJbakvyDv39doN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2965", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2965` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARDMdBxvj/eI2kKCHnY84hvoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2Mzk5Nzc1LWRiMzktNGE0OC1hN2RmLWEyZDEzYWZmMzk0ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE5ZDI5MWQtOWJm\nYS00Y2NhLThlYmYtZjBlMjdiNWFlZDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3re1lfl837FuFpJ2GEqHqFWovj6XOry7JR3/0lJ4rN9xV9y/nYjSd8QQMYRx\nUQn9ofJwHVaTt2AtmXnX+49NGKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOhn7J0ZCpOTJLR4/2aDZYAsqpfQwHwYDVR0j\nBBgwFoAUAXIszmj5k9RC3c8k6EyyIZxvO6gwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiB1wrxT6IJpduC78CQKrXbp6tNQOgswuj9BzaWVNnBgWgIhAOOe\n4Jzecs2/3qkwqBn9gmnE9FgFpenDZkQUOjSCPN2a\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZuePATJ5Ib9lmrcbFv8WPXMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjM5OTc3NS1kYjM5LTRhNDgtYTdkZi1hMmQxM2FmZjM5NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfYbYfNM9wihjlU8eiFKo+nLQae3mqcz38KKcZU/525gsI\nU3NPfghcPO4H0qkCOXXOKpot3VxIdK6EVrNJpFRbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAXIszmj5k9RC3c8k6EyyIZxv\nO6gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKa8RWeACbYPWk10S3Q+6/tXy8K9v/oZ82DRNKNGjWzvAiEA8zK1CII0\n3d/M2D5EZymKnEmZ0h4iUKUUFO/n3iiavak=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAb8ObaOYtJ/du77GxYilxa3rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE5ZDI5MWQtOWJmYS00Y2NhLThlYmYtZjBlMjdiNWFlZDhlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMWYyYjhhMC0zYWFl\nLTQyMjMtOTUzYy0zNDI3NmMwNTc3YjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQAtT0rVEHsmbVjTZediJFxKekZ3gKayDlKWHIbKrKj+s436gEL1McXeM/FGFhD\nQ6EAhwyHOArlvkNajYRWjzo9o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ6GfsnRkKk5Mkt\nHj/ZoNlgCyql9DAKBggqhkjOPQQDAgNIADBFAiEAoCVKQmqRvHol+2dMpDEIMK1u\nsdgnIud0AmEOKzh5LCoCIF35tYEXxBtZxZAaMe6bN9bdGzS+nxeph2TxzP99icr9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2966", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2966` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAWhc68S6ZpI7MobRlFGpKlVoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3NDJkNjIxLTYwMDYtNDZiMy1iY2U5LTI2NzdlNThiZTM2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU3ZDQ5OTgtMTcx\nOS00NmFjLTkyNTgtZTMyM2I4NzhjMzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjnMw3L/oUmFZR4DG+d4px8BKQfeZouWYNquviMLvHeHIUCXVhb9Uxhmh+HGg\nb96RyZgmqOPIdaiVbIzq9clnkKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaa3BJZpxa3ah2ujfhA8V6Xw3800wHwYDVR0j\nBBgwFoAU9F6SxVhJlTV3UZMKUVakTDFfTHowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAssEKR5bHcWulVNJ3ere3oHUleQT7cx0J\nVe+5KoCrl/cCICMN1j47yg0kf/qW/QX3pFJmGcGJHlrKMsFlDmpplZ2k\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUwlqMVwn7gp0SjN8zKGc6EAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzQyZDYyMS02MDA2LTQ2YjMtYmNlOS0yNjc3ZTU4YmUzNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATF5CfxDCxHFZqAoFd2OlPXGDqlfyv0P3Vp9X7Dc7lEIDtb\nHilrMPDe5Cnp4822RFnp6dk/LWueR9HZ+WeJvyXZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9F6SxVhJlTV3UZMKUVakTDFf\nTHowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgASBk/EmzzUgzMtDfRXypBo785+t0TNdLRWiFDzvX94ECIQCBslIl/3EB\nRz9AY+iUZpb1C/GNpQpi7kg/ZiC9BkeK7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAQGHPyO9b7S1CNqqWzkB+R8VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU3ZDQ5OTgtMTcxOS00NmFjLTkyNTgtZTMyM2I4NzhjMzA5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZTU0YjdmMC0yNjlh\nLTRlMjQtOWVjZS1mOWMxOWEyNDc4NDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATYyVkUyb5oSF12PClBLbSf3xzbrwywWj3IdWm7YyUQCmxPWp9B3oVElo4hVMI2\nce36ui8Ug7D4c0G+cLeolckdo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRprcElmnFrdqHa\n6N+EDxXpfDfzTTAKBggqhkjOPQQDAgNHADBEAiA+ZCnM8JZewOT0VQX7rN21/ch5\nvnp81kWvbatQrVemSwIgZFROtlsVxx3vwp6k2MHM7jFqDDhj6TLM2LN0bqbwWWQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2967", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2967` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISARiPY5j0INkZVLHqE3udxuxPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2ZGIxNzBlLTZlZmQtNGEwOS04OTRkLTFkMjYwZjFhN2FhODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQzNTczOGEtZDM2\nNi00YjUyLWJiYzQtYTAwZDViNWU3NzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELcchTTM3LM6tBP1CaYEd7s+elw0SjlACWje/ujwJa8uLTkOisHktQqDqfURU\nEcePzfF2j/OScqZTNnnZVDKmO6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyvb9Mj2ZZyYJykNxQOzKzDn/+MIwHwYDVR0j\nBBgwFoAU6YOzC8GTGwgPRz0xhErigbbZfkEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAtUNR5nr2/7229WQ4zR4gjQ409utntPcY\nI19BVemN8NQCIQD/DMVaDuZCGZ+ZdVa1YX/SmDm9qdATGrFMgbRRuHsr7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUHQS8OoaZ+AlvHLoC9aLRPjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmRiMTcwZS02ZWZkLTRhMDktODk0ZC0xZDI2MGYxYTdhYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRtymkAhBDIGrlNaxPxdkx1PdD2CpRUj47gKfZjBdbo1cU\n5aDeHSTAo9AM2i41XrGoFkVF6x4NatavB0ZymXnYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6YOzC8GTGwgPRz0xhErigbbZ\nfkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFcs6gYKWW+irSTu/8nelxSZdjW74vMdEZxTYQRwVvvsCIQChsoNEXNIS\nx4ukEQJ6CQFOU3m+EG6fd21EDDwTjpwYFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISASES/bHzzUgSvnVU8/+3xEbVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQzNTczOGEtZDM2Ni00YjUyLWJiYzQtYTAwZDViNWU3NzljMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MTE1NTVmOC04MmVl\nLTRkZDktOTBmNS04ZWM0MWQyMDQ0ZmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATEKgM0MGmgCBuFVhSRshC7/pMQoS3DRwnTZMiCQ/0a4TNXWO2feh8BXf0ZzknN\n4JpUC0Cojz4Uu8nC6dQfNlEko1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTK9v0yPZlnJgnK\nQ3FA7MrMOf/4wjAKBggqhkjOPQQDAgNJADBGAiEAqQWnqxb0hJxUxOWZWJnPz/Og\nwkQe+WsKSbqVTmPVQ58CIQCdAiDtlVjwCfLZUC1ZcewDi6Gi4x/WpvbO3GXrIhgm\nPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2968", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2968` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAVONaHMyf1OsNnY1Sw2f2paxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2MDQ0ZmYwLTRiOTctNDRhYi04YTJkLWI5YmM2ZDI2NDBjMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNkMDAyNDUtZTQ2\nMy00ODM0LWI0OGYtYjc5YTkzM2Y4M2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc+qR5prA48ef69zxSCn5fh6THSiCNm6ZDHHmGwhK/usNOaOdh1Jww5Locp8u\npclA9iv49/pOuz1NTcQWXpYozqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzqLbQ9lD5ilHh65tLho1E2p9ppcwHwYDVR0j\nBBgwFoAUgEMifLlffLWF/rWuHlGKN4feUYAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBhs3iBs1b5OTbE\n1gkKQIp21+kI9xHSaQfmMX3tcyTx2wIhALA5kpX4CHuZ/pfHIlGrEZIEERPL5YsX\nBuVV+RaQ3K6r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbrLHjmoFmrxGcWj5EzHFdyQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjA0NGZmMC00Yjk3LTQ0YWItOGEyZC1iOWJjNmQyNjQwYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+4edlwajmT58LZAoPGZ6PSCqbE0LYbgpJC20rlY01veDj\nYRx86fUW7YVFKbHaPGG7AsxJR3C/QEjObu1RgC0to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgEMifLlffLWF/rWuHlGKN4fe\nUYAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLcYlD0msFA7b3lf3IsrXRzUaO4hXNRd6069uFJeM7E0CIBykodIVqi9n\nuDeIV8RqG1yYXyz1pJUX2VoBNjEBSelR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZJx2qSpeTk05HlU1tRTqRL8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNkMDAyNDUtZTQ2My00ODM0LWI0OGYtYjc5YTkzM2Y4M2U4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MjE3M2U0My0yZjEw\nLTRlNjgtYWY0OC1kMjQzYzZlZDViZDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQk4VZpH/hekZCkoP3DCg3qx3faS5OcLcGohSy55dlNuQBikND182bb8eAu1Rui\nKloaINUeoG/B1TV7awkyeHZro1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOottD2UPmKUeH\nrm0uGjUTan2mlzAKBggqhkjOPQQDAgNIADBFAiBSAyMncfOcM6B2UKP9RSB3aDcD\nA2LpZl8hb6vaavLcyAIhAMChfL3DN2USTmxuGtHm2YbEEmYNORQO3is0bV8fvsJr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2969", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2969` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAaA7lqnv0aoBS5TyBAQQj1GlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkYWQzMDYyLTc5MzgtNDU1ZC1iNzVmLTU3ZDI0NzUwYmM1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc3NjI2MWItNGRi\nYS00Zjg5LWE5MjMtMzhmMmRkMjY1NWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERMNEfjRn3Km9xcIXGbW2KHx3Ko5uLMFSBAhyzGPxzdlzePmylsSSxYuS71tr\nJJ2h1g3+OzSsBxhG1TikAahNWqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5SEVXUZ9BnmJrOIpnKGnc/sRqf4wHwYDVR0j\nBBgwFoAUyaU+EMMe1/jAHQfrKCJFxsZycmgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDKcb9crc4B926i/kMpBF3NgIC4X1GfgqHRmN6QzovNaAIhANSxhG8275De\nJGJ4OJQh0+Xs0DHXdCzyj7bh65787fpB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATLagmJsBHUr7WepkuUgSF0NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGFkMzA2Mi03OTM4LTQ1NWQtYjc1Zi01N2QyNDc1MGJjNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy5Kx4MM3Rciiox+VYTzd+QKs0u0ubdCNwOGcinWmbkxdS\nreAoAw526ZG04Hq3PO2IssoMAzNrP77v8avMu3nUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyaU+EMMe1/jAHQfrKCJFxsZy\ncmgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGVvP3x3Mx3LtnuzO6QNLC+LFiLZqTnO1qZPee4F60asCIDNBw68qinCT\nVQ3h+is+b1czI87epsb1Tybm9PSdDG+B\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAXIzYBFPR2ZU+0hTHTRcYn1SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc3NjI2MWItNGRiYS00Zjg5LWE5MjMtMzhmMmRkMjY1NWY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNWNhYzc0YS1hZTZh\nLTRlOTYtYjdiYi1hNjQyZWIwMjUyNTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATzHA4zQ1WNuE8le6ZzH3o3gYfqJnpoWaTG7r+aoRBs8PRR7YPjD9/yAlLcAdbq\n5flSdszHkJ/XcH2PF+IATvQio1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTlIRVdRn0GeYms\n4imcoadz+xGp/jAKBggqhkjOPQQDAgNIADBFAiBF0lWfjM/hwIoZ6erp+G7WnHMM\nUQMqR5/yhgG4AYMUHQIhALzcJLbdLS+7OlcIdKAxmkUbZXL7kpahzyrwHOnOhV2Z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2970", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2970` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZVxv/VqVDHbgg/Ybi3vz3D6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3OWQxNzE4LTFmZjItNDk2OS05OTBjLTk4ZmMzNGM1NDliZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGZmN2Y3NWQtYmQx\nYi00MDJmLTgwZTItNTM1MWIxZWUyZjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8PNh1oIfoeyRh4u39rMCJ7zTSioMQbSkU9L6lhJAEkjoIkD1TE5fKlYQ/gnJ\nA5dR1oAne2whRm4fLULOVoiY+aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7YqiPQs2hK0ldLLEjkYfiGSUacIwHwYDVR0j\nBBgwFoAUxSwMPqQU8s1f+X+XYEucxCqFAH4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFa6KgD/xf6blOu6UBQvcOvQqlnKBHM8hN+oPJvl6nAQAiBE0SLtqJTBtbx9\nxqQm0g/93P1irikCSaYev1rXiqugjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXXLhSJBsC1SAKRghY+qgPZYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzlkMTcxOC0xZmYyLTQ5NjktOTkwYy05OGZjMzRjNTQ5YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfBrbmdVOImgZQFzOcOTushgC2vHmSgGhU2onK3q0yNGKV\ndR0rMndC9vGiMiR0j/9MhipC8oCmHxiKxHveEa1To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxSwMPqQU8s1f+X+XYEucxCqF\nAH4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJKQBIwBLvQnJZOYHfpYAMmPEOn6OwVyC0rokodFU3d0CIQCFdk3abhI5\n7V8rdOS5RXHqN8XKLhFcKcEnhSUGyWSQCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZ8fC9+gk9gVylq7Z6eSPMxjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGZmN2Y3NWQtYmQxYi00MDJmLTgwZTItNTM1MWIxZWUyZjk2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4MDY0Zjk0YS00YzIy\nLTRlOGItOWY2OC0zMjZiZDlkZmQ2Y2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR0YqK8iCeAuKMTcu7aWgiplltBQBQ1L/XHVzFflJ6Q17cFIHbRn0qMyenpPx4K\nWFbWb/OCmUZbkGksTisqDAU9o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTtiqI9CzaErSV0\nssSORh+IZJRpwjAKBggqhkjOPQQDAgNIADBFAiEAyovMwGZOoxuNv5iPuvSwbRld\naYhJgwFP4iD0VUaBdaYCIGpHdJ1zbw7BQJb0iUc0cd+w1AuYWexZnNXfekLqBClT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2971", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2971` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAe71O/PrKFLkbwFeFgZukrZkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjMDQ1NjFjLWY3MTItNDI1NS1hNjA2LTZkZTQ1NGQxNDY3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRiYTIxMjktOTdl\nNS00MjE5LTkzMTgtMWU5YTRiODRkNzI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZFdZMMcxQ4MJO6gPjT6TvH/18A7lmVVgD/VOfRuiOPcdGRZOqlawynA15siM\naKUznlGlNu7yPBcqdteuYkCisaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwBZNwcFyHmaTMfr4C4HXKqzgJ5kwHwYDVR0j\nBBgwFoAUXvf3ITSf808/PGrHxq4LR+nFTykwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAwhfAncBuJjjxxAnVxKUll63giZ5p2TbPwSSwsEKIrfkCIQDgIiEBGaTj\n3KmveCjJ91pQ0MMraZ/Cl8GbinjfflspNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcFdPe5ltee+wbC6PJsNyeD2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzA0NTYxYy1mNzEyLTQyNTUtYTYwNi02ZGU0NTRkMTQ2N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUzcRGYYNTjjug8WohFRuEEGjmZDggqc1KEbKYDifHvTK5\nKPA5fRwwFG7v69LA3EwmjTIm+zMh/AKxv1FNboCFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXvf3ITSf808/PGrHxq4LR+nF\nTykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYn9m4hLxY+BsPrPtNOalqfYKeeyTFQSb96Bc19KDfeYCICFe/pVA1cwc\nb34/6LiHPgntGH1UQzeI5mj80TkQOr4Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAUQGvbCk/9ltkP9s50TXPlk9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRiYTIxMjktOTdlNS00MjE5LTkzMTgtMWU5YTRiODRkNzI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YjI5OTE1Yi0wODZh\nLTQ5YzktYjZhMC0zZGI2NTczZDc1ODIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATOsPH8v4N+iT2pWJbn8OWBVTuJ2VmPn83b3+kmG3gqbTYuDpuje1fbmJ7ZEXvx\nPXPm05gXVmrcH5VhZlSlpT5Ro1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAFk3BwXIeZpMx\n+vgLgdcqrOAnmTAKBggqhkjOPQQDAgNIADBFAiBCmMyk8ysGB/B8IbtliCuGIuPI\nOp97hYnizPvuuD9UtAIhANijGqyV7xa8xgeEtxoR3KExzpa/BkaqNXn2BdOBDPKe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2972", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2972` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQKheSlOgaBR9HpD+kCHJ3htMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMmYzMDIxLWMzNTEtNDE5MC1hNDY3LTBjOTRiNmYyOGMxODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNlZDU2M2MtMDAx\nOC00ZWI1LTkzNDAtNTEwZmI4YTRlZjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESrCzlwISV5xgw1jIZ2PZz1SSEJ1Mz+4DmoWTp7+s4pS8hMZKzJHqBQ3GC/b3\ntW1KW5KjnXHu68sixdueulUuC6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFZkD5OzQGtWKHcOt3nCdI4beNPAwHwYDVR0j\nBBgwFoAUPdHK6rK8slWKEEzoBP7IWBwms/wwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA38jXHFILES83TbYfhWXcHAF5lOFuDv3WAcqBk5+r\nb9QCIC7rhuyoMMOsMevyL+VvI0+3MPGvH8ekrogVg9wAxL3B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcMUV+dZviBf9hu4weD0IbzRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzJmMzAyMS1jMzUxLTQxOTAtYTQ2Ny0wYzk0YjZmMjhjMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZ3QCsy/ORo7hYPFLTPbW7boHaFkTXHSRJ1J7qnpjTZe7T\nOnQsTLsppFo67sHxcKbPf7z2WxhT8MPn2I/llXOVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPdHK6rK8slWKEEzoBP7IWBwm\ns/wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW5IBPT+CRt2ksJlf7beE7ovdVpFPukLODweGRApEzn0CICrlv75D7nct\nlVKEZT8OFZDKhbhAHk3c69YOpYQ18ATe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAXJNLJckz4JEZ64UL+7nStZyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNlZDU2M2MtMDAxOC00ZWI1LTkzNDAtNTEwZmI4YTRlZjA2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NmY0YmZiYy01OTc0\nLTRjZTYtOTEyYi1mYmYzNjIxYTc3YmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASNBDXkxHv9NA9O3XtxYN7nx2HUYZtCim3d6RHuy92e7rAPrwBBByO/VkJ8S8gz\nTB9o7HWEOs2mFfVq8Y3U0jBSo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVmQPk7NAa1Yod\nw63ecJ0jht408DAKBggqhkjOPQQDAgNJADBGAiEAzcCJav4SAaL2rxLyRkLKAnxU\ncYmIy6kI0IqUdu/7aMQCIQCEFjYh7YdQ8m5r3sFKSIZsd8Og0STU2b6bRg77g7LB\now==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2973", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2973` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISASU66PPlMNlvX09lQXwULcwlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MjJhZmE1LTNjNTktNDk3Ny1iYzI2LTI0OTQ0ZjI4ZjMwYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJiMTQ0NzQtMzNh\nYi00ZGU4LWFmOWMtYzJiM2UxZDEwNTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDNSbQvb9leB1koPsIXqZdoEa8B2jsKSnBIDO98r5V6iE3l1UjB821WsY12p2\nwSFxyenMZVgj+SewetK/n6cS7KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVOP9F5yzrv2Bxsgt+eXyZVKiX5YwHwYDVR0j\nBBgwFoAUZOqhkCv5Ezjk8YqnzM1zkfDl5gUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAlTrdzxhdE9ZuUgHw1f0bljLiUMUnwp1PxY4uRlD/e\nsQIge+ePwhdhWFfrJD73jyMTTg9ok8rWDkcWJCppG8Pq7/I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYJq5GuVkuiYnChSShU2qqHYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDIyYWZhNS0zYzU5LTQ5NzctYmMyNi0yNDk0NGYyOGYzMGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0BIjFKijw6o5/3cEdnrTMtqoMiOUxhvVjGZCEvILZWkTj\nDZNrUgOEa5tJmHa/5BNmCGA2mZozZLXoz5aPcQE+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZOqhkCv5Ezjk8YqnzM1zkfDl\n5gUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI5XGFASuv95deRvwwC3N5va9y1d3VJLHPNxGbBff6ghAiAzGKgblRu0\na57dVf9JEOPQzeZxmqNSjD5mi+rwwGWheA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAWefFSVR64T8jgexdQedn/GPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJiMTQ0NzQtMzNhYi00ZGU4LWFmOWMtYzJiM2UxZDEwNTUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5N2FjODQ5NC1kZDQ0\nLTRhZTItYmY5Yi1mMTE1OTZiZjI2OGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARP5YrSXkrhgy4eSk+lz28Rhb5J0mAjhyXp9dvHnN1o6GGrOxdXF5Zj6VPgZSFc\nCa8CAAbkhjnty7BFbXhsraVJo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRU4/0XnLOu/YHG\nyC355fJlUqJfljAKBggqhkjOPQQDAgNIADBFAiEAsgbVneq83o9Kdq4GoeztjdPj\nfE1p5qBVwakKi0Ffz7MCIF0T+LjPy+tXnBGECYEWuXKZ9DmRJkcc7AyOqtYm0Pbt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2974", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2974` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISATpydy1U27PM9Doc2reusWhpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkM2JiNDQwLTQ3MWUtNGNiMC1iYzY0LWNiMDZlMWI5ZTc1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ2ZjE2NzYtOTBh\nMy00MTA4LTgyYzQtZWEyZjU4Y2MxODM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErgRWNjkxRfIw9ziWII9ZuFVBkufNEqh5WpgzitNpqmI60pGQCKSuCAVDcsbp\nKiyRMmvvpBa3WarV1DlMc56a6aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWW2TZE+Dc+V3fpQd4mK7JkEbasAwHwYDVR0j\nBBgwFoAU70vdNxKkmHs5H5c6uWxqwfvvk6AwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAmJLLfhhWLQm1x2UgasVi0nh4I0lIqLJNGH5a8zp5YLgCIQCt\nKMp4HYDQdy4QCZi/wurXKijqx8DAMvFchSfHAKIwBQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZj9ThbarzyO02SKw7XkY3EwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDNiYjQ0MC00NzFlLTRjYjAtYmM2NC1jYjA2ZTFiOWU3NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSEe78thT8nRvOONh45L1Ud/YdMJAeCMXbbLXX4fULnHG5\nQLINGWV0zN1I9OlLtaIOrWx/BYZUEKfwKrigpzDho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU70vdNxKkmHs5H5c6uWxqwfvv\nk6AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeUmA/caQkTTcmoGxA2ktw1RFq8iDTfUvmeXomKejeagCIQDE8jDcd/Rh\nuP/ijB0t0yaZPRu8FSUgxGzpapSjIq7hPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAbjrQGJHU7ja6jhunuwQsf9LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ2ZjE2NzYtOTBhMy00MTA4LTgyYzQtZWEyZjU4Y2MxODM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NjgxMGU4Ni01MzMw\nLTRkZmItOGI1MS1hNGRiNTkxOTc4YzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATWCM/pmgyhdvsoB77Y2zA/2klXtG9LXKkVb2g1GzjeA13+qAbXLkVrnvCiEoTc\nCvlCKMVKYGp/rfQ81JnR6Kbyo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZbZNkT4Nz5Xd+\nlB3iYrsmQRtqwDAKBggqhkjOPQQDAgNIADBFAiEAoWAeFtfbkFRz3UOpg8oyIS3J\n4AibpCnTghKXOO6V1FcCID1mb12uiFcIT019fnucwBpRmhCtj1IBzCJDKJGurhFI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2975", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2975` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAbcpYSBuyyRItm3YO7p/980pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4NzI4YTBmLTUwMzItNDdlZS04MGJlLThmNmNiZmQyMDU5MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJiYTJiYTgtN2Qz\nOS00MWE1LThkOWItMjdhNmE4ZmYxYzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBkNKVBBOI6kJVQcOLE2YRZN9TUvSTdl+oBpkCsJmpsJ83wW7asPimE5Fp8QP\nlmpTHmhIssGjJiwkqPk/rcYNVqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBaE92c1+kmpVBi6fzYvImmzZFqMwHwYDVR0j\nBBgwFoAU++4UFJJtWisx2xVuxTi+pWjozJwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAhMjuk5gz2sCpGffuWYiB2IAup8pKf/fGW\naKCvimnSeQIgTwCoSF4oWwFTsmXQTJjsf3im6IvwSH0aukhQkkmlwOg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVmXnNAf8j96ZA/qXpVPwwmkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODcyOGEwZi01MDMyLTQ3ZWUtODBiZS04ZjZjYmZkMjA1OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT60wCFbG7YIGHfxDEnFiYogt8kFTGzUMrPiSJbIF7sJ6Gt\n9zfyfpC1MPucl9bAm/TVyLlNNeMfgpASrHIzdgyDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU++4UFJJtWisx2xVuxTi+pWjo\nzJwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOf2GXk8anPqXh3EFqpSjVoDBD7eP2PObcYzR2FcXsGgCIQD7EtpMihg5\n6/f+UgovCg+1yVlUyLwKLPzVjZfR8XBhpg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAXc5CnrvI9J0cehKX4Q0awfRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJiYTJiYTgtN2QzOS00MWE1LThkOWItMjdhNmE4ZmYxYzMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZTZkZWEzMC1iNjUw\nLTQzNzgtOGIzYS0yNWZiMjVkODYxZmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT008sP4EMFM57nDryuZDVWSA4Bl9znW8W8AilppV1E1NpZO+vh9IQghhVSQdxU\n7clg9MUKm4AexbYbgYHQTzlwo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQFoT3ZzX6SalUG\nLp/Ni8iabNkWozAKBggqhkjOPQQDAgNIADBFAiA76EjmmSpCNqXo1Ffg2iw0GAFq\ndrkJ45lp3xSeW9RYWgIhAOg9AGLtXJChsFiWiDVTDQ8qxcE0P+y5a2qwCcgkyM/U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2976", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2976` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZjywa6aRIspt6Wua1vs2y4pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2ZDEyODkxLTc3ZDgtNGEzYS04MGZhLTBmYzk0ZDkxZDVmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTkzYzBiY2YtMTgz\nYS00NTdjLTllNmItNTRiOTBlMTg4MWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE13YL6Yr7LwCymmUoFDz7XlQxycsnJV0OEHtK4TqWwAXtjZ8+NK2WPGVC/P+n\nv+9tcu5ApqRW8At9KlRIEX22GaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3m3QL03blqt4r8SD7WeMUGpi7xswHwYDVR0j\nBBgwFoAUy/SPQpRnxaZy4yrDFGJVERRo8WIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAlTA8ytDQmGTtACFFWmI9V6/dB87n7fQ9\n6zi5s56qYWUCIAcZY7kQP134wHA3Quj8q3YuJ+QnID91U0fA5gk41fLn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWTenuvfSM7OQMK9Eadba40LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNmQxMjg5MS03N2Q4LTRhM2EtODBmYS0wZmM5NGQ5MWQ1ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLs3U2Q/6YLJtVZakxwK+ec+fF8YxTOpdV8J3QMQt26nFb\nbE1RZiNQrG1xj3CtkR1dLiFOqxgMGRqZk90aiHlBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy/SPQpRnxaZy4yrDFGJVERRo\n8WIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgagN1LrkaYKZXLA/2VkovKYh8FUPrHFIAerr4UN8L8cACIQDBbWy/Pp2a\nlhA+gPoHIRUnHtvTOkhJOKqSVsBSeznUGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAbGVkYaSkGVIvFgMIPF9/caGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTkzYzBiY2YtMTgzYS00NTdjLTllNmItNTRiOTBlMTg4MWVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiZThkMjhhMC1jY2Y5\nLTRkMTUtYjllOS0yYjVkZTMxM2IwZWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATndes+4mRiT+PJAkf8xJvzafz2n/Bt3+XfN+lQRd5O7k6flxk484/zsw7BBW5p\nYea8B8S/Sjun5Xk3k1fUK8Iso1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTebdAvTduWq3iv\nxIPtZ4xQamLvGzAKBggqhkjOPQQDAgNHADBEAiA1mC6YEriH45y4GsTmrxsMcUXH\nn+6unF4ILg+D7IX2JwIgfUs800foLggIm/+efNv3yVjm3PxAWsWIqiF9QuZZiV0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2977", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2977` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAQ6/1XfizYVGzDAgbAER8H87MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjYzUyOGM2LTZkMGUtNGZmNi1hMTIzLTI4NjgzNTBmZjEyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2UyZjhkZDctZGU3\nNS00ODhkLWExNWUtNDFhMWU3NDUzOTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVJv5XpETBOjl6EoGI+LmtCOJUKM30Nv/7LEflaVSf/o3MQtosTXhf+sInJ5u\n/arZsYE0aHXlsTNVufdqA8SFPqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/+X4PxPaimnydxb5z8jVGJEZ+B4wHwYDVR0j\nBBgwFoAUKaVj11BSo0tiJnXpNbuVT1WD8gEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEiARg0kOUj+2F3IWhFSs4LxQ8hW\nv1cCcE/CT8DiAT60AiApRVYAnRjxYleGLXnXYvVpy/vaabFEekPDk0/OqsjaXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbsrlE8Ou4Z/l3+MvttozV4zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2M1MjhjNi02ZDBlLTRmZjYtYTEyMy0yODY4MzUwZmYxMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBfoNzsBH/sceAvRWrfZxBynPbKoSjIHvqWHFrumrxohPh\ngv5xXgCImhnOn0khuqNvlGnVzzy3gtZfUoKh/yzpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKaVj11BSo0tiJnXpNbuVT1WD\n8gEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHk75old/KO5AFXUAxukbE/oAxWi2bTP+4fAa1Me/UMwCIQDhdMB7lyqE\nYzRY20ViDGdUpB0c2hG8gs4nJqu04rHI4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISARFWefUJ4LhJtZS6tY1QFpRrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2UyZjhkZDctZGU3NS00ODhkLWExNWUtNDFhMWU3NDUzOTIyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNzk4ZTk1My0yZTEy\nLTRmNWUtODZjNC05NjlkMjk4OGYwYzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR+1g1309iO9jU2F91vC8xZMV9HskISke248ByDEGzdLDQaGleKpQlkS1f4Cs9f\nVzcRH55n7Qh0ycMq4XuwA/wto1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT/5fg/E9qKafJ3\nFvnPyNUYkRn4HjAKBggqhkjOPQQDAgNIADBFAiEAkuP6B/Z2uzB79ijRygCA3ZI9\naZ2ROIkxIOU06XEDV1oCIHwI6xqr4OHNr/Hv1sgfHp7wrkEgyY7eDOmGmglPd71x\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2978", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2978` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISARAsmFlh0zlIGT8bBFuASTvEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4YTRlODI4LWJjNzctNDA0Ni05Nzc5LWRjZGUyYTEwZGVkODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ5YjY4NDAtNzg2\nZC00N2Y0LWJhNTUtOTYzMTgwZjAzMTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe4+Mg/kSfQJHyofcA6/1RiWck40uLTCz48ZQAQJaJ7a/6tpoLrqKb73KmU+X\nI0IIXdDtKtPZVTCaWZpuc/En16OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNZv0a/KuAqLiy0ZCeon4p6/ZbXMwHwYDVR0j\nBBgwFoAUhxZ1DNniWajeIP8t403tcFmMVHYwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgVQ3yzuMM\n5XU351dDXMdnYYWNgqQfNiXVx1TsihxijO0CIQCwWDZXHrrePpqodFLo7jXAAWbI\n8qa0fzL6ZC7tBa2MMA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYmLc2hPwwY0iO9TamTAyE+EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGE0ZTgyOC1iYzc3LTQwNDYtOTc3OS1kY2RlMmExMGRlZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgY2k2RL/Y37lpmOup7zvRYqPhQGMBbSogWfTTIoCIY6wK\n18OPDhP+EZS1S74R8Xfg3y6pj3GzSlrkdNGWSMkio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxZ1DNniWajeIP8t403tcFmM\nVHYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL4xY8uSmJP9vxv+guDgLKV0lZv9bCi2heNpel7ibn1iAiEAzD2NW+h4\nf3vjv84296TERBEW/ijxfnIGWKNAgTWiqwg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISASlrTcOK7rwdeXq+AXdQ4pp0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ5YjY4NDAtNzg2ZC00N2Y0LWJhNTUtOTYzMTgwZjAzMTFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZDk1ZDkyNC1mNDE3\nLTQzY2ItYjBmYi1iYmEwMzNjYTRlZDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQgi8OFFRUFN8tdLd0+NYZ12wjXEAzHyHhEc8IpOamDq4PHqEpWmJSfZOp9oVs0\not+BNq7zQHUhQpOnsDk17EZho1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ1m/Rr8q4CouLL\nRkJ6ifinr9ltczAKBggqhkjOPQQDAgNHADBEAiAT1ZqTaaAIjsi/CMZ9s0i3IrUZ\n0cGc82/cs3lEEE3NogIgA00Z1FJt4RF86j/xPHkKtHRPRLncOcXVFwDvAFNfjac=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2979", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2979` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISASkZNyLMz0s029GSMN6BgyQbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiODAyMDllLWViOTEtNDU3MS1hYzIxLTkxZWZlMThkZmY3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThjNjQ1YmMtNjcx\nYi00NjA3LWIzMmYtOGQ3ZGMyNjhkN2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiQNiUJsZMaDBwziy9819PRuDSBvS0rTWAGWK95kvy51zOsPQh5Ioww5/XECF\nI4yWWbEv91GshqhIgZ8rOi67laOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOTGDGkhu/WCwbw9mEvgvchoUBcwHwYDVR0j\nBBgwFoAUUVNoTsx9BV5jqgayFTDteQlFCAIwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgCDol8USL\n8HHarEkEFn0rmz+ysz8i+6JwJ3HI4gexUKsCICGQMr2GpkaJeHz1uC+T0gOkH7pS\n9lUegYno7rDqVjdH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARVsLLN5Mjy/oQtaAKKXbDiNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjgwMjA5ZS1lYjkxLTQ1NzEtYWMyMS05MWVmZTE4ZGZmN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCgFIsk9TrG7VVPDCUVhdhPJv/+qmDenbRjk//Oge7EbpK\nzL8stRpoiiUDQl1RBA86za5G5f32bk3Q7HZ5Q8BZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUVNoTsx9BV5jqgayFTDteQlF\nCAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ4yob/kxM8CJsaO3p0GDk1K5o+UnfjPD8IR+ig3Dw3lAiEAo1Gj9cGr\navilUi1lHPDKuXabg2j8wzDnm+zvbI21M28=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISARVhKBO8gNCpQmjPUyHNwsDuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThjNjQ1YmMtNjcxYi00NjA3LWIzMmYtOGQ3ZGMyNjhkN2QyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYjk4MGM1Mi04OTY4\nLTQ3NGItOGU5ZC0wMTBlMDFlY2ZiN2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQrwOQY3R7cy8ibWZrBTgDXE4tvdMWyqhDlkNRSJcVG0kEVmJXHRmzOZR8FvZkx\n6GX62EhV5m3A5G2F7ffUKlfDo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSk5MYMaSG79YLB\nvD2YS+C9yGhQFzAKBggqhkjOPQQDAgNJADBGAiEAtvv7XLhUKffZ28yGrSOQwBB7\n0l+5i/KCyMXNlJQ49rACIQDU+waTbhdzfFn3rDBzQ4G/skNqbpI+zsMIBGdYgj22\ntw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2980", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2980` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAegL0ROHhB62OzkutvEhUlPIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2MjA2MTJlLTQzMGItNDFiMC1iZTZiLTQ4NzgzNDliYmY5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGI1ZTk2MTUtZWU1\nNC00YmY3LWExNzAtOTAzZWU0ODVkOWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaLeib6kbzjIJJjU0FuamyrdPc4uJ3KSknnWLGJbtd7FyPuB8U8Q96eb5Ejlg\nldyuj6Ach+L9neydE5SseWmSbKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkYWGU7zplwvtYjYPjEhUa3ltviowHwYDVR0j\nBBgwFoAU7Uz3B1ff1bOQ5kZuQXy8uVRV0HEwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBl/PNsZ\nzIQskzwaMWVDUAt5XRjVBHJWBx3+++YZbAwIAiEAh4G1r4BcrWLs7FBjJDQEuDxB\npwtKbbywi7W4Y9Y43PI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARPNECdEE9oy8XsGpP/6xueqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjIwNjEyZS00MzBiLTQxYjAtYmU2Yi00ODc4MzQ5YmJmOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASghDEEE2MKqsMl8ddIK4N8X+cbi43Z3QsJvI5IkADuMh1k\nRxJ6fi/+jG5OXRr+xCWLtp/3t+pnc7Mldzjb0X2io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Uz3B1ff1bOQ5kZuQXy8uVRV\n0HEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO/wvtO3SJbz3DZM1qlz5s+jQaDcKmXeaviYHZuDlV+0AiBIxDNYK1gp\npKVTOldepXypqSj/7clLb1S+Na30+mg/7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAQ4ePHEmkMmhRxJMjMvlZKw6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGI1ZTk2MTUtZWU1NC00YmY3LWExNzAtOTAzZWU0ODVkOWY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OGJhYjI5Yi1iYzQ5\nLTRlOWMtOTNiZi1hNDllMDI0MDI4NDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS85kx5h/nweDI07oKDijU3ZqC//9T/GTLs8Oklz7H6kFm+Cuue/8XkIA0GB7pk\n+NaTFuFq2h0Oft+TsG8QRHQso1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSRhYZTvOmXC+1i\nNg+MSFRreW2+KjAKBggqhkjOPQQDAgNIADBFAiAIOB1tmQxPS7aBAEHQdkLnWmaj\nDkKle7Aohzzo9uxDnAIhALFofCy9jLn/cqe99bbIr/2PgZOxtDXKQQecrpFFesU9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2981", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2981` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAdOQfAN0YcuKNfmQnWxy1IavMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyZjljOTg4LTNkNmItNDExNC05NmExLTkwYzgyMmFiYzdiMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY1OTZiNTctMGM0\nNC00NWYzLWEwZDktMDIzY2I0ZDg4N2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE06/OpTT82V28zDWPG+XVnmwtMZdb5n1ZFQ4pzZisWI/CPOfmzy28FlGNNg1o\ntRvVUrLwtWuvbiVLQGl13ZK/PqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPU5qnqOpzIZxqG/rGcmRxE1BD+MwHwYDVR0j\nBBgwFoAUO25fJzQJxT1iUM7dSr0x2dcIDqYwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDew0O8KALS+adiN2Vn3iRl3KKZ8beqen3RiUhHwmchpwIhAIfZwzdO\nTtLDSNSbeboQhhZB8NAxdcal8tqesIg48Pc4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAak1I1g2yNqQxia1JUYXCnr7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmY5Yzk4OC0zZDZiLTQxMTQtOTZhMS05MGM4MjJhYmM3YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIRalP5axG4UHJOeH6jRfpb9y1T7KJk8GxWgoASfRRxW3G\nJJ2gIOmr6py5CM1MbyPUw7dJS5X4tHEHSzpGZAqjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO25fJzQJxT1iUM7dSr0x2dcI\nDqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK+++Pm6rRObEykxanxqWjJ5914yygcoOaCrE6OPr0tnAiEAxTX78V/t\nm3CeNzzBOfjDLH50JchVE3cv1+X6/BaSiGY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAamTH5mFBcC8hpSwZQkzL7QZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY1OTZiNTctMGM0NC00NWYzLWEwZDktMDIzY2I0ZDg4N2ZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NzE0M2QwMi04NDk5\nLTRlMDktOGNlMC01Y2YxZTg5ZjJiYzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATioaCJNuyGe3Gk4Bi1zKHSleVmm86NHVszbYpwgCMMsdjAWgN09jeU1SVVR4nb\nVrKvyRBXFp//8ZIyRUJHTRzao1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9Tmqeo6nMhnGo\nb+sZyZHETUEP4zAKBggqhkjOPQQDAgNHADBEAiBCy8fNZOYmnI18osrSFLdx+GSW\n5ghqsVzO3592baZkrQIgWQA614t+Bvh6TPDi4fXswX6kbNF2cYxb+pyirq/VvTo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2982", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2982` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAXs6kjb+0kNh8Ly0XxPwA/f6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExM2M1YzRhLWU5NjktNDA3NC05MDY1LWVhZGNlYWMxODQyZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjljNTgwYzYtMzI1\nZC00YWI0LWFiZDItZWQyMzAzZTdmY2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO5razRTYN5xexMTuNDhy4kypG46XnlB51krnhXpS2TNzBVQueqip+REAeudj\nTH8pmo32fvpfkGc29De6REMx1aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaFmRM9jz5vNPp4u8c2RoGA4XjFIwHwYDVR0j\nBBgwFoAUieY+8XWjaG1ZVk6sTTmERU1wjeQwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIDyK5JYAsALolwqpk7dIsAtEUlGWisUolDETLXWNI+6VAiEA3egK1BU0\nBOECFdPG6UTWJ9uzDJBqyfa5a2JJ4fqZ/eA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATWHvbgf0UKZsfKpesrQrPnXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTNjNWM0YS1lOTY5LTQwNzQtOTA2NS1lYWRjZWFjMTg0MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxylT4QtDXYzGd3hk5w6cwzixl9L9SjL5fFvHoSnIjZz21\nVR0IhnuzDdGBjHzbgPjgEcND7Mf74172VkYk0ir8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUieY+8XWjaG1ZVk6sTTmERU1w\njeQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJzH6ftjokWrezJa85rlQsc9yZVvpUmMsVRAEoSCoiXBAiBghhVklAgL\nNHAOY2OD9fqCh/djb7ECvD9GW7B01EMIlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAUF8JrM3Qfu56IavoePvantcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjljNTgwYzYtMzI1ZC00YWI0LWFiZDItZWQyMzAzZTdmY2MxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzODRkOTNkOC01ZTdj\nLTQ4N2YtYmE3MC03NzA1ZDJkZWNjYzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATrhiJyCzhY2/Nr7oleVdh3zq07X64OAF6LJK9XkyNVa0vjcmeD3qWaWiBCJF9W\nHL16wieG+W829lWLuQwD9BB/o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRoWZEz2PPm80+n\ni7xzZGgYDheMUjAKBggqhkjOPQQDAgNIADBFAiEAkzZkmCytW5O/htBmhzA1/EGF\n0nnmtpnC7wOT6MdMx2cCIFvLdW7S9iiWMpwKxIw8GsUsw6/p0LCicTG9VUNkrows\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2983", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2983` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAW7h15LAtwGJN0fK69krt2D+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1NWM1OTdmLTM2ZTAtNGZiYi1iZjM2LWExZDA4ZWY0ZDk5MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZjZjI5ZjktNzI1\nMC00MjYyLWFjZGMtYjZlZTYzZmE5NGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMmaxRU0zEi8TVo6n+vJ5r+SFGG6icvcuceDNYx271d9OzC0NqGkwrstJtG83\nNJ05juHXzGcjWITG374z0/h/W6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzhVhYUncL3OjvPHDkhG0e27TNZYwHwYDVR0j\nBBgwFoAUJMHOndHPtUZtF75mNccwbEZxWtgwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIHg36uH068FR3eBw7mxJ1LvJMiqoqaO/Lwb+L+PTihKgAiEAuGfJZmG6aG6qq9cD\ni38k2x+RAdDZrowVHQaW0Hjh9Pk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcWBe8mNnfxwcwdBjcI9Ayf3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTVjNTk3Zi0zNmUwLTRmYmItYmYzNi1hMWQwOGVmNGQ5OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATL+2dIC+WpqQuXrbpQlM1rBIRPucbNpJYy9875kY1Uiim9\n5o8lQ/Z1nuYGggYPOd4GnMwTxJfKmQHwe3wZKEcRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJMHOndHPtUZtF75mNccwbEZx\nWtgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKo/D3rf7sm8NUYby8nKm1BCfgafe7v/jBMyV6g78aNUAiApJoHiu+vF\nFq/stWq23RZV47CtjtyB7zT5lKcFuI3oEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAT6eB2HM4BGbUSB11rwiTgU+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZjZjI5ZjktNzI1MC00MjYyLWFjZGMtYjZlZTYzZmE5NGZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZjY0MmM2MC1mZGUw\nLTQzMjItYjI5YS02MjM0NzI1MDNlNjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARYRaILovPFYrqBE0zycBi+deXofFv6nY/Ay6UMLqPP69gb6VumRb/YezXiW4b8\n/uknPPRjiZT1wkjYLSq5O7Wvo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOFWFhSdwvc6O8\n8cOSEbR7btM1ljAKBggqhkjOPQQDAgNIADBFAiEAose2q5eUJvXZtVe9EXK3ZQQC\nZroR4zXwzmMcxZqz47wCIHNvGv/jnuHlC7zkHr8J7lHTnn9+yiyTXXoD+JG54Fh7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2984", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2984` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAbivPY84SN0p8xMDX67rjVLbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmOTBmN2FhLTAzZmYtNDljYy1hMmZlLTI4MmViZTA4ZmY0YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA1MWU4ODAtYzgx\nYS00YzAwLWIxNDMtNTA1YjQ5N2UxZjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8VLTQjfRk3FKxhNf+9RDklSA0Fzb2+KfhluQzxsCekj5hyaZ/wN8jceaFJR5\n6emwY+7HdZMSI2RnE2drggamAKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi1nhkJpmVlKbiA9mFR67Kxf3dSswHwYDVR0j\nBBgwFoAU8XFK9WrxbG/XM9vNytD+eoLw20swPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIE6bEl/QrE3xHyt3UT7g7SgDxcae8D2XeTY2G1z0pLazAiEA\n2zuxDRX7m4akB6DzzpX/4sUfzWKNh9WTJHKALaYFs0M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWvn7MTccjwlNjTkhHsdBF7VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjkwZjdhYS0wM2ZmLTQ5Y2MtYTJmZS0yODJlYmUwOGZmNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGoO5L2/tFs29grTknp4cJLEt1mbdMbHFowxKH1rJkJgTS\nuMGwfeVVQGfLgASmvi7u0/fBO2zz62rLM9MbgjO7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8XFK9WrxbG/XM9vNytD+eoLw\n20swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLkZ+05C8YkbX8WLQQb+V8pXh8fywVy2+63vmq79C5pwCIFDaExGGSUJt\nkN4L5lLylozRAFe1JBS1PQXm8lwkZV9V\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISATO0DmCXpwBCN0OkAaFjzC4pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA1MWU4ODAtYzgxYS00YzAwLWIxNDMtNTA1YjQ5N2UxZjQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjOGRiYWFjMS1hMDNh\nLTRiMjMtYjAzZC05NTRiNzU4MGE2OTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASbhT4R99sV+p/dyTsc5o+YEZJfaTUfkFDP/adtOeuZDGebl5OEegPwFsoR/xJ+\n2K64xKAQQtyN4Ubs+qWeAnQqo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLWeGQmmZWUpuI\nD2YVHrsrF/d1KzAKBggqhkjOPQQDAgNIADBFAiEAjnGRUu82GlCxFSSw/Sfta+BF\nOdTgkET9ke27f7gClEoCIAuimFznWRqdRWXpERETaz8SvlnQSHvbE83lR8N50rFH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2985", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2985` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAdB42+nRVsXmfd/EkZRCm+cEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwZWMwOTI1LTZlZDMtNDhkMi1hMmEzLTg5NTA5NDE4YzM1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJmMjg4MDUtMzU5\nYS00NmY0LWJjYzEtYzFhYmJlYzFhZjc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKQcgiJMhRTQ1Si1H0vi+ESY5Zn6Ck6JAD4Zwli8LKmVTdiY7k3+nuv+pkoDP\nSBT5T7Q9ka+5y6ztwn91gjusm6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT4KDISItii1C3B6lctQwFWD+0L8wHwYDVR0j\nBBgwFoAURGkh0Qh8dAvnFbyEOZPDk+wRPjAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCf3LuvqIUYNr8mf5QK0B9frDe9siFRPt2ziJpo82AI6AIg\nW3fc4AdkMvlVjHv2QCSNysm/LtGToPHyxym4p3U1AdY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZQf3a66Jli+gr5s9XWV4EUxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGVjMDkyNS02ZWQzLTQ4ZDItYTJhMy04OTUwOTQxOGMzNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR99VTgV7nGsW7ombUnZcIVVd01K/nbxtdvt2zmxsP6XW19\n99m+edgk7vg6yk4jt+DqXlbwkAHDH1Oa6VO0zazCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURGkh0Qh8dAvnFbyEOZPDk+wR\nPjAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOKd4F3TdNcan68zIkOQ2dSmTZYuudDCcLE9E4Eww6e5AiASJo/P6K35\ntnPgch1P56X4VD3Pfxk3Dh1V6qs04tYbNQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAU+vfCoQoKW5gGudbuxOHeCAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJmMjg4MDUtMzU5YS00NmY0LWJjYzEtYzFhYmJlYzFhZjc1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MTdjMGFhZS0zYWYz\nLTRmNDItOGUzMi03YWI1OGE2ZWUzZTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASfFK/VsJ4T0Gg4gdJo+sre+5Z7i6IYUaprm5zMoctcI3/noTMgsH7SPpU6HZ57\nZ+2hoUA/maSjoD9FMpGaOZ80o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRPgoMhIi2KLULc\nHqVy1DAVYP7QvzAKBggqhkjOPQQDAgNJADBGAiEAnKX0DKHYT5C7n8CAUdgEbG+c\n0U3LTDyerwEi/2PERbcCIQD9cUt8Q06QlZGI5uGk8HsHNQdpxblyEt2im98K+j8z\nnA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2986", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2986` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISATxkjWo61X/1YfqaF2OZO04gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MzAwZmEyLWQzOTAtNGViZC05NTE3LWJjMzNmYmZkYWVmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU2YWFjN2MtNTZm\nZi00NTBhLTkzMGUtMWVhYjBiZjU0MWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG6/v6EHF10UA/kRUQyO2Du0O0U6X6reue4mE957U+Jv0etI+LAe6xYYYtnmL\neNNdQw6PjqK6jnLdTZsqReWEIaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlky6B0HagqswfN/UrH1TH2VZRM0wHwYDVR0j\nBBgwFoAU8xF8xndZL4VzVTXrbfXZN4DDp9gwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIApYqraamyPz\nw8yRZ4AvNBJVboK9DsIEvCRuFPKZlRz2AiAEk1n+uK8zlXDLR1XvQeRs4qAhcb6b\nsD0vFbWCdb7o8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASHqIZFVY4kPPOH8SGISa2A9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjMwMGZhMi1kMzkwLTRlYmQtOTUxNy1iYzMzZmJmZGFlZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR64xYTQJSXFNc/eXE2vOheiJSHFBTxx+VUqqoOoFKDrk2L\nUybZiBFkyreABVV6dsEghzoCR3lP+xMzl/s3TYaHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8xF8xndZL4VzVTXrbfXZN4DD\np9gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI50W/xX1UBfXf3nYiBCEyEA6FjiPfBMUuLmmGx3aOydAiEAtirnH1S3\ngV3rfjqfrki0NpFOqiMq9UmWWEfa4U5yVpo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAWyTV+V0FygrQXtJ1TftBFxXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU2YWFjN2MtNTZmZi00NTBhLTkzMGUtMWVhYjBiZjU0MWM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MTE0Y2YwOS01ODIw\nLTQwZTMtOWQyYy05NTgxOGJiNGMzNzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASW3FIyx4IRqBMEfV7cghyk9m6ql8wzNbKskF7V8SgBgosVv0pY7RSurJYaFeVS\n56SsMjPPwYDUoTvO1w4mL76Mo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSWTLoHQdqCqzB8\n39SsfVMfZVlEzTAKBggqhkjOPQQDAgNIADBFAiEAk1VibBqK9kdhBHhVI4AnYV9H\nFgHClkAj9No6mfNzaSYCIGvzQ7frkt3F/g1pNgE5xwzlHSWKgHpbxWYg+xgt5ry1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2987", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2987` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAZPwHTILg20OQOFubBugP9SXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkMDBlYzI3LTY4OGUtNGEwMi05YjEyLWYwNzhjMDMyYzk5YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjUxZmZmNjctZjNk\nZC00ZDhiLWJjNjEtNjMwZWYyOTc5NDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGsgLBIYrVIEh6EIHjUQt7/w2SVpRU2MP0DTxsi6uIhfqGiPnmiXgfL5oOdX5\np/HTye58/cycMLr6CDZR9hhbx6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsR5v0C8c7k9sRSCD64c0XViRvvkwHwYDVR0j\nBBgwFoAU8fXFJlKkYjz2706Ah99BGlDHXKIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALuPCTO3cJaKbwCPcFq4qxX1r7KKrQV+Isv62UgKuckPAiEAmyUz91kX\nGcErIW4NHXUq1zcjYgUWcz81r0sYQP9lD1g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeBY43BPecIhT67HyjVqwr0AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDAwZWMyNy02ODhlLTRhMDItOWIxMi1mMDc4YzAzMmM5OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnnSDRwMhI9j8R6zvO2B108n2uX6scJutbZGnCZhqUFnr5\nsOtef7/QRsVZAt/fElzI3WA2B+Vs47arIy5EAydRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8fXFJlKkYjz2706Ah99BGlDH\nXKIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM00LAG4h0XRJnVaFSlzbPUxDk6MPGUaL56ZV22bJ6SKAiEAi+HK8RP3\njHf/rZSWWHFU+LvyAji97t4CSmo+4xRRpsI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAR5bfOwegH0AgYXhwcfGvcqZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjUxZmZmNjctZjNkZC00ZDhiLWJjNjEtNjMwZWYyOTc5NDgyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYWU0ZDUzOS0yMGI0\nLTQwOTctYWUyYi1lNWFhNjBlYmYzOGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQtYD8lI3KSAHpBllvjvzh+e8r3KzoRXSSNfTpbfel3inoAQ1D0Py3ibPuxjHKM\nijFDH+9StlkFtztT4I/Cv+4Lo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSxHm/QLxzuT2xF\nIIPrhzRdWJG++TAKBggqhkjOPQQDAgNJADBGAiEA0/DdHygjR3Xc7xRdod06kA9R\n3ogQHvaIH+n4VFAZ9eACIQCNncdaIa+0t2F5pBbSqNBjegHqQe4QWZuBIjpIfEil\nQA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2988", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2988` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAcSF2XNXc+hPnidumvEFgXO8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxZThmNjhlLWM3MTUtNDlkYy05OGUxLWVmZGNmYWZiNjY4YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU2MDBmNDMtNzNk\nOC00MTQ1LThhMzgtYjliOWRjNjZmOTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK+tuq7a2s1vtyeN55uW7lgurLF/cgQ17O0BB9w+AzOqEFPFk79EInC+W8I8V\ndaNcdn402l8qAavh1IeBztejr6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6W3+VIN8Xe0NvbepOyZrTWsp8yMwHwYDVR0j\nBBgwFoAUeBmsrTTFGxl2qgTL3jkEVY66C4YwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANNVVOhMpvTrafz4mKnFfhUvqPIYb5ORoV9ZjRVYj/EPAiEAxToeKrpC\n0hgDz6752GgCwHt9UWmb+9YTV+Q0V0tgtsg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfNc6F7CQYlLlR0WVAUdS8vzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWU4ZjY4ZS1jNzE1LTQ5ZGMtOThlMS1lZmRjZmFmYjY2OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJVBw1uG12Ay4dp2U5tT4a4cCVrmVWy2Or5HSPmAmP1aMB\ndsL9Ue+jg9WiHUbAQ/w9un51VTbWLqudPxDaBjBmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBmsrTTFGxl2qgTL3jkEVY66\nC4YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOc7DnjBMivA6pug+V7P5QrBtAL2Q36Bi8VB1lcQ8ccCAiEA/VeZSkww\n3JfRI3vDB0Tb0SHf98EBn/Df8KN+rN5X//c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAYQTI10/kRWR0KOItvGMIU4gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU2MDBmNDMtNzNkOC00MTQ1LThhMzgtYjliOWRjNjZmOTg3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmODU5MGRlNi00ODA3\nLTQ3ZDQtOTUwNC02YmY5YWQxOWIzZTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASD8WzCnSxzePDVdK3fzhjTzMpLaalyfB9nZ37uOTXkvUROSPKZY++TDzqV0K3m\nqUcz7YVdF2ZhTSD+/QjBg0wlo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTpbf5Ug3xd7Q29\nt6k7JmtNaynzIzAKBggqhkjOPQQDAgNJADBGAiEAnoBWTNyBRW2LXfkjofaptcB0\nP+XMgZuQjA0kcGDaSKECIQC3WwxoJtaBDw3+A4OHGNVZXcHYSdPYT91HDxBnWgzK\nSQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2989", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2989` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAXN2w9tLDOHR3CyneMXvEOVuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMThlYzg0LTZjOWEtNGQyMy04NmNkLTlhNGY0M2Q4NDUzNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQzN2Q3OTAtYWMx\nMi00M2I2LWFiOTgtMGI3NmM0Mjg3NTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvASUHxzj8RxOnJrGd7LUIcucKOykYuHyRWdu959CQoN/SZg06dWD/U4PMG81\nvFy8ftU9hBKcHY/+kpPzhmRdUKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/jTs+0ikMaNDY6bvTl6zUOE0bcMwHwYDVR0j\nBBgwFoAUUgBNyepx/eaTYOSjUBEeXpNm6SkwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIDSvtZxIZ8BDNgfFAwdERZBbzSKFN3Bqo11IkSm64zhKAiB72bj9mLP+\nukebcrffCq6i22bHb1KJJ9kTj2U3F6Pxsw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbD1AbyLZcMYCSnXwa3ctQ0JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjE4ZWM4NC02YzlhLTRkMjMtODZjZC05YTRmNDNkODQ1MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARg3aXPNb7eJ1BE7QiXn/2zDraGSLCzMYBH1OTp9wZ3fuER\n83gK1vuo70d3WpCFWZFr5oDevL08nesTprZfWOcGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUgBNyepx/eaTYOSjUBEeXpNm\n6SkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVfLn8wDMlvtb5qDTLxul2ADEBTvMGPbz/T/qyuRlb8ACIQD6Igvq2bqj\n+1BI7kkOfvyElKGy7K73MYPleLg+indlDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAXwUP5LGAKXWhGdSLK2qcx45MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQzN2Q3OTAtYWMxMi00M2I2LWFiOTgtMGI3NmM0Mjg3NTEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2Njc3Mjk0Ny1iOGRl\nLTRiYWMtOGI2YS0wYjAxODQ0NzQ0OTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATRx1fsoEloNES75jAAGgZq10qCjlHRVYE1xe7CJKbwc2CEAxyhD6fxqtgq/YuM\nSi0qrfDjYW/cdDboB7Ljw+Olo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+NOz7SKQxo0Nj\npu9OXrNQ4TRtwzAKBggqhkjOPQQDAgNIADBFAiBqrfIwqEOBrSoy3a8rUExJ7osh\nkgux/mPwOGCSkc6NBwIhAOutmbyZNoYXakD6TFiNmM4gL1nElu09BJtlzWDFKKEo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2990", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2990` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAb9a9f6ed5VVz1KfzVpoEcn2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1Yzk4ZTYwLTRkYjYtNGM1OS1hZDI4LTMxODFkMTE1YjRlNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRjZjQxNTYtYWIy\nMi00ODAyLThhNGQtZjg3NGVjYTFjNjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKxy4G5CFWo5UTuoe7WjwN6SBDCgtgiF1g5yXLSJHn7POHFDBC1dwn+GzFCvV\nwcSSjAXAvpBmZTP2nEJTAHBx0aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoqmRlRekOf7HCSTNTuI3IU+9N9EwHwYDVR0j\nBBgwFoAUYzsE4dOLHSxTYVQf2IJTQ4X20wEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIAQAI1UwJtp/ywX/CPsLa4HtLwPp3WGMF6+QMFax\nb8AzAiEA/cUCe5Tz/KaEI91fZP2gWc1bpkUrT46o7Vdd74cGg8Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATVuFu7sK3TbzDHIFLsGzyjsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWM5OGU2MC00ZGI2LTRjNTktYWQyOC0zMTgxZDExNWI0ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJoD8mhqtkWVZrqrrvY+G67BeTHENPUNKllIEtoq4H1Klo\nQ+fU+A4qvmB7AcWDXYhsgeU1WBItkEjFm3LCbUa3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYzsE4dOLHSxTYVQf2IJTQ4X2\n0wEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY6gq7jFWzdobL+DCN6wxd8wp3aalAakHQEkp7TFiUXACIHzs1lkC8tpO\nMhcwVTcVSkrM/zTMUTebKu1eBPFZtvLK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAWj66469MuI49dV/oGtI+ZXhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRjZjQxNTYtYWIyMi00ODAyLThhNGQtZjg3NGVjYTFjNjk0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNDg3N2YzYy1iNjdj\nLTQzZDQtOTk3Yy1jYTc3MWQ4MDVlYzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARi3wkhNikQcCoF30x1Mw6h0I/NU1vReK7KMJX6glpHiwn53qihgIQ6H30AWXpY\nx/azNhItRYF3T/ppVjiHP6oco1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiqZGVF6Q5/scJ\nJM1O4jchT7030TAKBggqhkjOPQQDAgNHADBEAiAh7yfc9dbhF2usWBx/d0Reu6+g\npW3LZwFkxGL1ILSSeQIgXRBcel3HMkOxQSHUlvkuboDO7YESXGAjg3i/FAU4qjk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2991", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2991` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAQgm5JwVYMQhrX41fSzE7jcHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiYzJlYTJmLTAyZTktNDkzOS05Y2ZhLTE4OTZjZTAyOTIyYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY0NzliOTctNTlm\nZS00YWJlLWI0NDYtNzY2MGU0NTVlNzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPS/4crNzWINw+u/KGcS+co8gn4dkxHAxRnn3fW7nvJLKIoPGI6iATFiikpfc\nJ7hAuW7bmp95ow5UuftYk2b2W6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo71bNv4vrEsnGcnVWuiJK2V4cW8wHwYDVR0j\nBBgwFoAUxB3sHGYyIBUMjjTRptjPbfnTldowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFbfsVQunoyU+kL2ZhSO4a8wYyUofK32M++3uoZf\nPpV8AiB3aa9FU/GmiJyXQswnanZEDyWNXHtbj6KYcZq270lfPA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbQiJrd7jc8SkFxw6DXmDs8uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmMyZWEyZi0wMmU5LTQ5MzktOWNmYS0xODk2Y2UwMjkyMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4xYHQzlO2yeK7p/9YxGG73TkfF0Xxp/8QOy5gmEwlYUkY\nEP4WwAu79xhIfalkNsdjyVntH26eli99phmsH26Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxB3sHGYyIBUMjjTRptjPbfnT\nldowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX5tTjscZ83AeDbarENoq+A4M4v6Injfyr/hS2qouNrQCIQCKjhc0PoCo\nq1H6cFvh43h/WvwX2Efkgy26NJ2YryQkYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAaRutho/OZI8vzn8oN/E+SgRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY0NzliOTctNTlmZS00YWJlLWI0NDYtNzY2MGU0NTVlNzY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NGI0ZjVjZC1kMThj\nLTQ0OTUtOTU5ZC01ZTdmMGUzNTBiNjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARHJjXuywH0ZuYt4+uh6T/8xUDJAyLCqRtOE8/uezn+hli/TSXpTwYilmkwXAF6\nEnkVwk721+8xW7t9PwjcCBFSo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSjvVs2/i+sSycZ\nydVa6IkrZXhxbzAKBggqhkjOPQQDAgNIADBFAiBOruyrLcaFl7Gvf2ztlvjv+JgJ\n68skCRZY9H/4MfjVvgIhAJP9W7V3A2oKdA2NWsS2xKcSu4iL/zIm0QoZYlzZLy2L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2992", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2992` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAe3SiJv1/T3JOoXm0LZKgTpWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMDZkNTAzLTk2MGMtNDRmMi04ZWY1LTE1YWEwNzQ3Nzc5YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg1ZmUxMzAtN2Y3\nNS00NWUzLWJlMmItOTA0MDEyZDE2NDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk1P3sT5b5ZGDhsbilvdfsR1pC+a8EUXouL6cuWk7sdbFrHhEya8/clgQZDaD\neNr5vgxdvBn8MFbvPa1OsPtWQqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGdKLUakApJL1XfOVteMlgiygAMIwHwYDVR0j\nBBgwFoAUtWdmrITwiYoI5Y1VQ9gX+28SBQAwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCID0ghtL3xlSkXiqNLrZSxPqwbGaJMkyP8yxth46Oepn+AiBV\ngo6cPHOBaUR8w03QPN3x+UFLsPJTvYqiRS60/vrxIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARkqFSJUSjssHsOL0sIIf3auMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzA2ZDUwMy05NjBjLTQ0ZjItOGVmNS0xNWFhMDc0Nzc3OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhhMBcNXkAjkMq/PSC5ITdVdv0zxn9Hjs88OH/S7KnkRPY\nTgGA4O+lEjvvYbS1NQZUmAzt6cjrdpArYUViSPyFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtWdmrITwiYoI5Y1VQ9gX+28S\nBQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTS2at97E9jEGoBUJD/ZMRoWx6hKwaFnw/nZweLJC5WMCIQD2UBIWzb5K\nMPC9e/sZRS/eBqrGJql1g5uGDrqWDIL7Tw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISASWwa4XIuCDvUlTgH6tRRE+0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg1ZmUxMzAtN2Y3NS00NWUzLWJlMmItOTA0MDEyZDE2NDVkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ODQ2YzA4ZS1hZDFm\nLTQ3ZmQtYjlhOC02ZWUwM2ExMzI3ZTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT9BXhouAc1gm9+/NxBh/mng4HIzxtB3PDXm9U0fuJ6ig0Jf5uj/Dd93943tCFh\nj+qQiVps9bL7p+kgQRVjqsWuo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZ0otRqQCkkvVd\n85W14yWCLKAAwjAKBggqhkjOPQQDAgNIADBFAiEAxYB9o0bdHraJfRQrMALSbbj+\nRnrNBWLZ7i0Z2VG6+1ECIGS71jykzaUFo5IO7fVCuFlMlYwjtBge0R5rMMAT9xwu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2993", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2993` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAa4gJAg7ydSeIDLBEsQVF24JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczYzMxMTk0LTNiOGQtNGE1Ny1hMzhmLTkwODEyN2IzMDQ1NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMzMjRkMjQtMmI3\nZS00NGU0LTg0Y2UtMjcyYTZlNmZlZWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwrYPkYdJE0yI+jtn/bifKWbMqGzf+5VCqoM10omb3fu36KkfdPYORRa8DJks\noSf3eMaUvYpu8SN09YlbWP4zs6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEXxPmcye4glbSKl7sWp9A1f96AQwHwYDVR0j\nBBgwFoAUR+z9DX2D7dQBu1RncHjBLZXzbicwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD0FjhJK1n1vr8r9otB0XxUYxdSYQIF\nmZSuFc3Abg/QwwIgW7GMsUSf541ujyZ7T+NY3ReekjRHB7azp/4oqX+qgNs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR2jbwBYBFN8thxXARvKqsjBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2MzMTE5NC0zYjhkLTRhNTctYTM4Zi05MDgxMjdiMzA0NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKy5vdsi8yc00dIKZCKSOffEbTt3GX7sx3xdCRdhmCfMMT\nLk16mU6xsF0Ra/5SjLLsyUonmdAVqMxHsltc5Vtao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR+z9DX2D7dQBu1RncHjBLZXz\nbicwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE0IF750dkGvdw11ABXwzn5QnKDe5vXIs+9j0qYFKQWQCIQCy15ECoZgF\naMqqGTcTcxb1qpil4mZhJ00nY4PT4tr0Vg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAeiBR/oGzeJZjfvIe7ghypfOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMzMjRkMjQtMmI3ZS00NGU0LTg0Y2UtMjcyYTZlNmZlZWQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMjQ3ZWNmNy1kYTlh\nLTQyMzAtYmQ5NS0zNmFjNDk3NzA1MDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT4JG5Mq+KC9xjZRoEnR+aZuaI/RGc5WilQ+VYuHoBu2c8gv8QYvhjJUpltCKuZ\nO278O5/2p2mgxr4ERppTb3hqo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQRfE+ZzJ7iCVtI\nqXuxan0DV/3oBDAKBggqhkjOPQQDAgNIADBFAiEAtMhgzQ9dHxoxGjmuP4J3K3ov\niFn6ZayzOJzhF0N0fLMCIBMgeiXmZBbBcRw35KZ/GPYzRG2tYddLp4/TWdFQJ4PT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2994", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2994` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISARWNJjzO1PBncGrx49BObqWRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0YmUyMWZmLTU5NjYtNDAxZC04MzMwLTA4MzYyNjdjZWVlMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc5MWZlMTQtZmYx\nYi00NDZkLWI5MGItODcwMDllZjY3MmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYgtk0jNmf8Zydoke8tWxq58TaMJZ8pDTEGtV5qC/UdElCnglCXVt7CyGxtp3\n8euuhB6yErUG4wVRr2AZgod0NKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjXtYJWB+1qJYXfjk16IQ3R5/pg0wHwYDVR0j\nBBgwFoAU7ejxvlwSW5O2w1NMW6vBGt0ah0gwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDbXFt/rhr/mA7vS8DEP3QvSdWYcyid\nHi5BtLDj6aI35gIhAOuEFM4lfqfdhQXMBTWJFH5OZ4stTrf+rbI36mJVsV6/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVZmrTKz9kko44AhahHyniNLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGJlMjFmZi01OTY2LTQwMWQtODMzMC0wODM2MjY3Y2VlZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2AacmvOV1Aty9BXFypPdRy9EP3Ph5fE5aL3ZOlPxaKYB/\nbfT/X9qSCZurlvtJEO8fJMhQMeI3g/s74oYPOiSjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ejxvlwSW5O2w1NMW6vBGt0a\nh0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANCLYYH2UXCmeUJ0SfNLuk/fwToDelOfh/2lmM8FHAkEAiEA3wlq4dAp\nY6R2CQ+Z8cbFEo02YMk5kM3ymBm2OUUpLcc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAQ1FtoqPFB5qXbkELywGgbg6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc5MWZlMTQtZmYxYi00NDZkLWI5MGItODcwMDllZjY3MmIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNWY3NmUyNy02ZTFk\nLTQyYjMtYWFlNS04ZDNlZTEyMjY0NjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATp/BVmhMyUswok4QV4lpM3DTwu/pgo7YEfcjCC3QmiTlQ7FRu7jnKPUXHnUwuX\nXe05sbURuvW26v+xMPTRc2tlo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSNe1glYH7Wolhd\n+OTXohDdHn+mDTAKBggqhkjOPQQDAgNIADBFAiEA/lvl2nGMs1nECS+xF6DXNt6B\noRHp0t/JdIdUw46CCC8CIHGhtX+nRIFy7anLyikb7CfzHgL75KxkmFLUQTDacNcx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2995", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2995` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAaRZeR3UHvcwsFEdif2+qUvSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwNjE2ODc4LTM3NzItNDExNi05ODE2LWRkYjhmMDcyOTU5OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc4OWMxM2ItN2Rk\nNi00ZWI3LTk0ZGUtNGZhMzNkOTVmMTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEipmCEGxZKuBC0bnoaNBDDIFoP/FGMSa6LOc9grp/HYEu2M4NX4qCv59oJmci\njHcKtiObGtER5f2EyXdUyABPR6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNOnzFeo5MNTvopbClNSr0WkBL3swHwYDVR0j\nBBgwFoAUow2Z0N1UNj+dZcutXJhmcPwJlogwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCSd3db15Fd\nKJlaoyhCcrVjc/hq8Gcin98r9Q3o0QjtJQIhAISNUhnlb56pQrOnlDOV8BYMYoD0\nvZA/PqcWruKB0Aes\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAacpgURBLegdf1qFQWxUCg6zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDYxNjg3OC0zNzcyLTQxMTYtOTgxNi1kZGI4ZjA3Mjk1OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJwhuAZTis/59M6am1sbR1ZLiTr06lFEHb0BcCn4jFlAJS\nZxdr5kkPfMyyMt6art399yZyE/Lf1K9wbDwm2MuDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUow2Z0N1UNj+dZcutXJhmcPwJ\nlogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ/RaSoK2HKHK1bHLeEnESuY5Uuc4S7M1qMXIftc8BX0CIAM+99yIoJkw\nvJ90RtRjJIwPp+nTrZM/BiVLvrdkqO7T\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAeSV4SbV0+GQMmGmGCQhrDAwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc4OWMxM2ItN2RkNi00ZWI3LTk0ZGUtNGZhMzNkOTVmMTU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MmU4NWU2ZC0zMjMy\nLTRlNjctYTM3Ny1jZTZiNWY2MTk3NDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASGi9p7Pi9F7Rr+x/V6crR787OeQWzjeHH2oPlMFilW+XGO9KifLC8BykvEb+gd\nEFxLi77Ehy3ERAMEhrpWJYHwo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ06fMV6jkw1O+i\nlsKU1KvRaQEvezAKBggqhkjOPQQDAgNJADBGAiEApsKBdxcQGdi4T1KTQkFtEfBS\nA7gNUr0vEb3+LZX/vh8CIQC4RvDOmRj43NQcp9POv6GwzuMZ48AqGX6PlxJOrRnh\nAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2996", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2996` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAb9iOSn3YBQZM1SGvcK3QJxRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3YzJlZDY5LTgzYmQtNDliOS1hZTc1LTIzYmEzNWI0MTAxNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcwM2I1NDMtZThi\nOS00MDkzLTkzYzYtZmMzZWM5Nzc2MGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk7nNafv4Zi0yZR4msMqL+WDZPBDM8AqjQqZ/jlc+OIo9/J36vAfGB6VVEYmr\n+oM0LdT5jt+4SRqcdXgFD16nQ6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXzG26jCguVuLKpmLcqZ6E0shq5IwHwYDVR0j\nBBgwFoAUNTDbR1JMqKXfQUeLb+2CWrMT0DkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgcfM+AOzEkIrO2jxztwrnmmYgybWwiVqAaWG249dyCIQCIEdKOI32YE5T\npJvAP2qU02yZoULHaPOhmuQk/lArFd+N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR6IbRUGwB26Dhg4O9cnVX1XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2MyZWQ2OS04M2JkLTQ5YjktYWU3NS0yM2JhMzViNDEwMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwotBaIogD3QzP4ZtX0mDU++slqxeAA61kI51o/EEiUbP9\nN+1nYEXuKxcXbtDg12rxpoepQjwtsbAxuGd7QUwao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNTDbR1JMqKXfQUeLb+2CWrMT\n0DkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFEzk4zYsP8TjB2PMdZmmahuDMa2d4mbJzDkkf2xaTS8CIQDP2B59Fmvj\nHOQ4D6MEjuzcCg4zamEVerE5OC/1Zgqxew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAbJafQlXYRh9mtbP0RHytCkXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcwM2I1NDMtZThiOS00MDkzLTkzYzYtZmMzZWM5Nzc2MGFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzM2U0ZDc3MS0wNTc4\nLTQ0NmEtOGYwOC02NTU1NjU2YjFjZjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARFwYHTvcn4ZxjhD8qeVa+rrq6hmjTKQI+1FP9FCd23oixn6b10wSQTc8ASmf/c\noWJgJDWDyWYVKnw2jEua6RYDo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRfMbbqMKC5W4sq\nmYtypnoTSyGrkjAKBggqhkjOPQQDAgNIADBFAiEAwixHW6m8LWb0hnZ2WGkb2dKQ\nQCeUeC84pjHQsTfGxXcCID6a1sdJotb/8264vqmaglqV3n3e61Mn29AVmuDEq+pN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2997", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2997` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAREo6LVAeqyXqSFQQfxyuA+UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkZTgyYzdlLTIyNTYtNGEyNS04YjFjLWQ5YzFlNjdjNTJiYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhlMGI4NTAtNGI1\nMS00MjdhLThmMDItNzU0MTkyOTE5YjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp4FDkk17xPIBHvNxVhohWH1boIQZ3mxtc02SOLT5z1wN8To/FhYS3GTRGnMs\nT15RznpNfmNLF3sR9tNzWkKMIaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU95JTanI5ZMGKK3UJ7p9F+TmMncYwHwYDVR0j\nBBgwFoAUSk3ZBb1ZWwF/ccG4QdoM05DHxsYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgcSe2p1K1t9cyP5rpVk+5bVwVIh05SfwgZ8Z8aGNBTkACIClY5rp4yepY\ntlUchcXTTtFYiABPl4jlQEKj/AG1vRwt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWrmUkZ5+WeyNsfjzJRZm+Z+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGU4MmM3ZS0yMjU2LTRhMjUtOGIxYy1kOWMxZTY3YzUyYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFsVicudfe6pYBv9a9mHB1g1evzL6KyxgXKrEH9FemljSi\nqr9t/sc5KSClVIrNjReniba8WqEYv4SAJsPO++jdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSk3ZBb1ZWwF/ccG4QdoM05DH\nxsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL2JXmO0p/BUIqAA7PXRoh8acwn7PxxdQ18olWmJD3EMCICbsHI/7n9QK\nMWAPzPjBhlQ6zjkso9zRG/X1CTwa/vN5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZW5aYE9yD1VOjvddMtt1DjMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhlMGI4NTAtNGI1MS00MjdhLThmMDItNzU0MTkyOTE5YjBlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YjllY2JlYi1lYjU0\nLTQwYWYtOWUwZi0yZGM2ZDM2NTkzYWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARTfoAjuuDjWfFit6ZJLS6cJx+X7nGjnVLx+2DNqpnhUx3YRAV7igWvzWkcZG+A\nYuwWMIggNQzyf5DA2xAyvBPio1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3klNqcjlkwYor\ndQnun0X5OYydxjAKBggqhkjOPQQDAgNIADBFAiEA8UiG3mR413c/QMKc4+9mPAGQ\n+lHUpY9cpnejoIXnIeUCIDxcunQuXnb3sGIKZuBQcpZxWYZ0enyhmyb6bY5zP6OE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2998", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2998` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAVjK0qnMaXFul55fzEnjYGQUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5Zjc3ZTg0LTIwNWMtNDRmOS1hNTQ0LTMyYmQxYTVjZGYxYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdmNmI1N2YtMjQ1\nNS00MTcyLWJlMGUtY2I5NjBmOWNhMTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKhrIJa5YgALpdtacPaEWmgumzBtJaYDH8B4L2wCt/l1G2QZP9Be8/qmH3cnB\ntTvbFXolrUOcVp0vPmqZ/0A/yqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4sjyIpEQlpc1tiFMqRe+zEpJSfMwHwYDVR0j\nBBgwFoAUg0zS8oSaM1GLH/bxtPf23RMbmOswOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBsQI0zfppS7GE6L39Br+0GmUQWzIq6Xit1F47WEjS4SAiAA1YOuUEPG\nIdbHranYtZz/EnGZslDcEW7m2RuU4AnVvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATeJf4ujolLVU1rKO7sBrC3nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWY3N2U4NC0yMDVjLTQ0ZjktYTU0NC0zMmJkMWE1Y2RmMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDSjDnpInkPhFkQeVrInYjOKM7grLb+tdoJnSq+zLF735Q\nzFBJHpIFOim0kKY40AKKfGmfqBzdPBkSBhXorm7Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg0zS8oSaM1GLH/bxtPf23RMb\nmOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI1lJPX1ceXWrNcGKj74bGfwye9fLfpo8BLEB4nEXuXhAiBMY4LlhCwn\nwtDHjy3D89PuxOUFPKUlMbzvlTB8JVXKfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAYlLj/Z9XAFCsErx5eFYS7S+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdmNmI1N2YtMjQ1NS00MTcyLWJlMGUtY2I5NjBmOWNhMTc5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNDI5OTNkZC1hOGQw\nLTRiOTctYTNiMy0wMTIzNzIxMWU3OTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARx84x/ZMZ7mAp1ics9ChC0KHs8YS5IQt/LJ86QYF7mCvbVpF/L6pbzVKh6a05Y\nkRBFV+NZLAPqSAMZaZtleC1wo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTiyPIikRCWlzW2\nIUypF77MSklJ8zAKBggqhkjOPQQDAgNJADBGAiEAo9DU7jnGiQqTV1RWUExgIJIk\nyl1OH4GMPtj2zCd5LX0CIQCwcsSdhTSRsWu0jqz+FRI1QS948thxydmlHuiKgZSh\nJw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc2999", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2999` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAR1gBiPDyaInRUCR6TCEVUywMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4YjU5ZGQ2LWMwNWYtNDc5ZC04OTFmLWE3Yzk0ZDIxMTMxMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JhMGYyZDAtMTZh\nNC00YTc2LWJhZTQtMDNhNmRhODEzMzEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoeZuo335zgW5tYCB6z0y1fkcIMIuZ/EZCeRV8DDavlCgWs0MIeERFLspy6+7\nVWUOCDGvXNLdZu/X8KdDa70U6KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURY3/xibNfZ1Avwj/IppQUSI2SfEwHwYDVR0j\nBBgwFoAUVqb2LBIgszOYivuxxd1P0/8yk/kwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIEZ50aSM0DK7sMN5F/QVApkxf8QNnzcNkoncYc0G\nbigaAiEAzO6MZEB7Q5j2IXXo9N4DMQMq2tD4CIb2nBL63RaPyUw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfX5U9qOud0FrFnQMNT7WuxSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGI1OWRkNi1jMDVmLTQ3OWQtODkxZi1hN2M5NGQyMTEzMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu3Sem4PqdfnJyERA7SwSHEPSNuc4BYGps7qRiQIHRHuzP\nWwZup0B8QGAFgAE2IOteYf592/P3R7LZvskBU1s1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVqb2LBIgszOYivuxxd1P0/8y\nk/kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRTcF1wkNMhNJgVSUHIoB3GVxMzh75i/QoeRQGZzJ68YCIGsocb92Cz20\n4UpviP9kZHngOc5qex8wJjY4KEU4j/Kh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAQ76vFBSFZcjOyyLt4pRjXuwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JhMGYyZDAtMTZhNC00YTc2LWJhZTQtMDNhNmRhODEzMzEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZmY1NWI4Zi1kMjBh\nLTQxZWQtYTQxNy0zNDhjMDY5NmUzNTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQUzpxWkHVJiyJCF/C95Cx6tLYSuzhB+sOVRlm3mtSrPOCjWYj8LMBEiQDZsiVV\naky9x7j9vRKa/eylArN7VxvFo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFjf/GJs19nUC/\nCP8imlBRIjZJ8TAKBggqhkjOPQQDAgNJADBGAiEA1hhcRN1Zgpt+9uVLF66NAKGP\nai66Mu+GF6xH3sa9bDsCIQDO77xQSIblYt1HGkHZKYFllgvgix53AtSc65npjHNX\n2A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3000", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3000` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAeDsio9dOR2ytNyv+WPHDBNMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzMTI2MGRjLTk0ZWEtNDE3Ni1hMWMyLWIxMjI0ZjY1MmVkZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVlZDMyNmEtNDgw\nYi00YzU3LWI5OWItMGE4YWNhNzNlZDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAvPjyl/UdRvGCTpkaeEB5R5qFIClm7JXnfwlFxtlJgKdx7fB8YZRb0CJAw0x\nZVVr9cxYiGHOpii2VZzzkSdmRaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQEXUISO7eC35E6vURKqw5a2/8FkwHwYDVR0j\nBBgwFoAUuQ/miYR6J0M81nIgEXQyhtI1Fi4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGCTgBgLB9S1JefUhKRlBPvUmic3F06coCalsw25\nj6D/AiEApqkO0ZNosqsdyZVT8+4Ro2BoM5Svg5ycQf18EpeAEq8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaYvW1VX29/5RW0xyXbCb1RtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzEyNjBkYy05NGVhLTQxNzYtYTFjMi1iMTIyNGY2NTJlZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdrIpILL82OrvXMjJwTaWJkNb7phDLYTVYqO8fqK9FJ8Zd\nE9Uv2Edvs0FxoP0lTxQLNDfq63s1ZKRr76TWE290o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuQ/miYR6J0M81nIgEXQyhtI1\nFi4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPeMDkbxuI54wOiD66ImN8RjrnpuDwCrEf4OADPSPu6fAiEA8YUFMOiG\ndnU62DsspBLyzlvNb3di5eTn10jbAMagKNw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAekSifc3zpGaE9pdHuYfYPa+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVlZDMyNmEtNDgwYi00YzU3LWI5OWItMGE4YWNhNzNlZDYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NTAzYTg5YS05ZjQx\nLTQ0NWMtOTgzNi0xZTZhMmYwNjM1NDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ1vCN9Oop7CN5l2nXrahFfm6tSyKf4NcqyRynikVLwN+y5gqwRuW7Rawgs6ZAJ\nbHhitx2d65TMVpbD86qilNheo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRARdQhI7t4LfkT\nq9REqrDlrb/wWTAKBggqhkjOPQQDAgNIADBFAiA1z08muGjD5kZEINZF/xgZvlC3\n7iKKkXaQ1B1EanH26AIhAMm1BgAhV8OwL+j4d0TI5fVwa1JuWwAs6u4FIMYv3nr+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3001", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3001` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgKgAwIBAgISAYGqsW+U0+PMyb8010VHKJtWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3Mzk0YjVjLWQ2ZGYtNGFmOS04NGQyLWExZGNlZGQ3M2RhYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM3YzBkOTAtYWVj\nNS00NTA0LTg4NjgtYmQ3NjI4NmRmMDU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdProue++MIVsbShzDDuFhcYSqWdsxwcnV3HWoGk5LNtRbsDSOYbld+LiRKbq\nxhW1aLNZXS7+/HpH7tIrFru7x6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc8iIxT0LZU9PtnkianC1T5i74/0wHwYDVR0j\nBBgwFoAUdMba6XnoW5UB2vSTLYgcwauqc18wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0YAMEMCH1Izce2O5TBZmNP8PzDkLxd3r1HqSeN5wTuTeQ46uPQCIHpi\nFH2zPtIE1tMCJDSNa1E11gdE0r1+h2kR6+k+1Pv6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa9AXIJrSxtYxtKtli3lKANDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzM5NGI1Yy1kNmRmLTRhZjktODRkMi1hMWRjZWRkNzNkYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjXBP3RFMeVs6fCdnYIaY1PBW3tlv/ca2Ym67i27lMVL4a\niPfojm+IwOo1a45SeMiq1oJoytd5Z+UlHqVn2dqJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdMba6XnoW5UB2vSTLYgcwauq\nc18wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANOh8Imzg6ZA3iQG1F8sW7hKfWd+0bHWtBqGGJOd4NS/AiBJvs7Z/6Sv\nImqA4C2a6rWm0YONyzKEpPTIEk1OHOImmw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAThq6xzthASwZurckE5Ul1pzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM3YzBkOTAtYWVjNS00NTA0LTg4NjgtYmQ3NjI4NmRmMDU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0M2Q1ODkwNi1jYTIy\nLTQ3YzEtODY4Ny01M2ZmMjk0MjAyZTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAROH7rskh+oIfqOzkGFPmFvpo+n1622wsErTlJCCTG/MO0EB1w6cM1g1xy8pBJc\nJF+n89hJQdy7KinwQ9VDwI32o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzyIjFPQtlT0+2\neSJqcLVPmLvj/TAKBggqhkjOPQQDAgNIADBFAiB6liNW87fodfsTXEd9oGYErfSR\nqxiHQVAFkl8ZVkZGaAIhAPxPTjErQe0fQOjRLJOxkAu94CiXCEhwAJ6u6rvU4gbd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3002", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3002` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVGTWQKJqtSwquCx2WwN1MntMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzZWFiMDcxLWRlOTYtNGE5YS1iMWFiLTQyZTJlNTY1YjcyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY0N2NiNjctMGY0\nZS00MTI2LTk3YmUtY2U1ZmEzZDczMDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6z9z5d6Rrc3aTZlonxgiosvaDH8iFLGm5M80E1HGk6BFAi5vXiXOpLCgW15z\nqW6VTaSksde6KneUpUmqQnoU76OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0KJSyLpu1qZj5pXVu9rX1Q+Vg3swHwYDVR0j\nBBgwFoAU0Y62TtUKKPm0+6rrVrcT88gRzAgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIG+a84BSSlRUHfeOwXF48vc33sPZrK69\nqdRLNhq/QYhoAiEAyg6NFGM/QPCO6NFdiB5HQEDy3HPBDZ3qS1yGeegYdIA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXWNevTTdWWbZEZfO6WYrwEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2VhYjA3MS1kZTk2LTRhOWEtYjFhYi00MmUyZTU2NWI3MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGUacD5rQld1OmYhvxX2g6hfvI/kwiunMTBQHQ515kmHTR\npaTvZtAgKq6+tfVRBA+25Z9ROB1r+dlSOLZh1yFOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Y62TtUKKPm0+6rrVrcT88gR\nzAgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFBLJgi7tn8VKx1UzHUMHlaNDkdYOSaVkV2OEwZOjR0ICIQDVBk4wYJow\nH5wtOpCZqktdvyxb/ppTEw86Ssv0fuuw+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAYCv1ev7l++zMJY66ED4H5deMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY0N2NiNjctMGY0ZS00MTI2LTk3YmUtY2U1ZmEzZDczMDdkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNGY3ZDE0NC1lNTZi\nLTQyOTctODRmMC02OTAyMjZjODdkODAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASvIhSXItvWvcBL7xPkRnRThNxa3qhQ49/JPfGfhPLLCekA+SC9fj0yvmkvdzM3\nWQ1sXesFAqL3QOCek3YeEvs9o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQolLIum7WpmPm\nldW72tfVD5WDezAKBggqhkjOPQQDAgNIADBFAiAuv6Ak5esT91bK5qFdkX2Ig3FW\nxv8Fbaxyp0LnH/YHkQIhAPq0V59XpwjiQTG4uUpuQ47JdZzf3bCMejii/X1P8rsA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3003", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3003` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAftM/uD8r9ACh3MO6qjDqnCoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2MzUxYzViLTQ0OTYtNGY3Mi04YmRmLWYxNjUxZTdjMmMwNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJhNDEzODYtODk3\nNC00NGVjLWJjMzAtOTEyMWM3ZWRiN2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0GxfuSx9QXkjoSy4+UT/46KtTCu1aCkMeg6sJsmSipksGyFh9NAQWJwSpH5M\nubscaoxEk2YZ1ugvWQCOkMTHvKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX/Hy+VBFCp5XkHBiSwNJE2tidQowHwYDVR0j\nBBgwFoAUSCv2wJqCWmjB2I+/9Ur/ugLiDEkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEPx1hZ6nqXaTTvqSZJ82x3jcDJ8pI/3\nZabTG+XRRioeAiEApDh/EVkAxmAw3vB89bo4BkbTeoTV5khOySKpzwDLqZ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYNa7j/5I2c49XLhWVGM3zByMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjM1MWM1Yi00NDk2LTRmNzItOGJkZi1mMTY1MWU3YzJjMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDeo1kyiT75YcNFxxC5xsPHxp1GXXNyJWmRPegcQSYdlws\nLPLlqs0ncxr1L3tMtIrXDGIUhDStlYgo3eQgMHnHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSCv2wJqCWmjB2I+/9Ur/ugLi\nDEkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI/jRyMyzJolvnhRglrEgZSF4Y0WrOSs1LU7Ke04qsIWAiB3WgejIvd9\nnHYk5of8dVhlP5F2nybC0lY7PErmY/lE2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAaEJJgucf0c3SeLsp52kfBJiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJhNDEzODYtODk3NC00NGVjLWJjMzAtOTEyMWM3ZWRiN2M1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5OGY3YmM0OC1mMjMx\nLTRiMjItYTRiYS04ZDgyNmI4MTkxY2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQht1H6vbY8/e36IuHUpKRvM7aWMyAAuBAqlH0dBABiMJ8imwcyN9DuCvfZ8Uf9\n316fqWQACerwbvuoOmIOMF6mo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRf8fL5UEUKnleQ\ncGJLA0kTa2J1CjAKBggqhkjOPQQDAgNIADBFAiEA4T65sJbnG9AQ2j54afEmbFbQ\nYH1cDJewNtQv8JkQE6sCIB6QL9omTZ6TsQZ/63hOGHfiFu+P2uhX4wYeonIjNgyy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3004", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3004` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAebe9LNAX7kO4guQM0rX6RvdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxYTUxNjM1LTYxYmYtNDRlMi05ZDVkLTI1NGI3NDhjMTNlNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFmMDFlMDMtMWM4\nMi00OWRjLThiNDQtZGFiZDM1MDAwMWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmAiVv7wufTRIz7juJP6pwI0HSe7mGiErQsldm0A4wWouli3jA+HAscfsTz+2\nnyHZFQILepfUrBgRDwLqkOXPQKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC6ekjRXBvSXUt3DVEMa/xXy5a01MB8GA1UdIwQY\nMBaAFN9veQOGB6rb1wgwg9ms2juzCWKzMAoGCCqGSM49BAMCA0cAMEQCIBJCwXGZ\nawe/YB5LnTBZNAHZdiiZIUYhAQcjkFz4yZEaAiAZv9z5VI+UbxOUmGYRUowbFxd1\n0Nt1AieVbDjmrV46JQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYP+VJTXbGdOC++WlbBF4w9cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWE1MTYzNS02MWJmLTQ0ZTItOWQ1ZC0yNTRiNzQ4YzEzZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScXev82mVYcUzvvZqLk895SgHERdAfbtLS1KBiOwTdCSTF\nFECPbIP0EYnshO84ijfA/gQMkv25otqBf3kxttfOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3295A4YHqtvXCDCD2azaO7MJ\nYrMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJkFH2vNqZ2YmILgXOm7rZQWv+nFTb/wCktFoHG7O7BMAiEAuTSFCGSH\ngEZ4w6UdTq3nfvzlmys6jucK9yc0s+iJyLY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISATa1W/kVfRRZVHv+/Ux3PL1bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFmMDFlMDMtMWM4Mi00OWRjLThiNDQtZGFiZDM1MDAwMWQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMzAxOWRmNC1hNDI4\nLTQ5NzUtYjRjMy1mZDAzYTA4MDc5YzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARnqHWf+CTxjSxIFChzNkNW1oc9RWlHMNODAnlcTKtZU9SDikitusJrR+cqZ9lF\n8HvCQFytAKJIMIkLglAB55/qo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQunpI0Vwb0l1Ld\nw1RDGv8V8uWtNTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGIc\nrIwBoKRMKP8ncPbx3HMPzNZZon7V9fm2B/dXppR+AiAAqUkCa7XLdNckKAhsZEAS\n98o6KcL5rpvPpfyjz0EQ5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3005", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3005` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcK/xASXljn5g3ouoatz/U7MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyY2I0NWJjLTVlMTMtNDgzNy04OTVmLTc0ZjY1OGZiMGJlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzk0MjA1MTktNzcy\nNC00ZjYyLWEzMDAtYmUzNGZkZDliYjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE087pLHPztIEV+iEu+MvFcBNkiMxQJyx/YWCNLYTfLLURkENH9vjqXJnsqZII\n6E8qwmIOFBx6nfF0nZTpS71rC6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPNH/szFmakboKJ7rnUc5nWfzAH6MB8GA1UdIwQY\nMBaAFDsb4/xL+H82OfA8Fnkf/I6RtHh7MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBEGNc2wHOWkBmYj8txIJFEKVWb5nkuuVYW\nXoWFg/o+VgIhAJZ7JxFajyCAXQ9mjuMZW3fM29cQDGFG/h16LJVGbFga\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQWIQ9JI+3fe3t/2fmNvJqAeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmNiNDViYy01ZTEzLTQ4MzctODk1Zi03NGY2NThmYjBiZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRRCcEYFn0Y2li/Jl1li5fvcZS9Z32phVfLHOzPZGKQbrQ\nV19WHCgHjAXIIpGINvagKO3TFbkJKzNxwkXPHtGmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOxvj/Ev4fzY58DwWeR/8jpG0\neHswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQYfGFCUgy1uGpDrZ3HZDPc09p9pdLwxFz9o9gZ0ajpkCIQDapSqTfnnL\nDq+B69rj4YmpH/Xj63j82raObmItl2Iu6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAdC9II/5TK3mjnC2uiBdKl6eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzk0MjA1MTktNzcyNC00ZjYyLWEzMDAtYmUzNGZkZDliYjI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4MzkxYzFmZi1iYTg3\nLTRhMWYtYjUwNy03YzM1NzIyODBhOTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATjYOIFaVADh8YUcK+O8sJuW8MsB8J4wdKggJUwKwB8g3KTwHy9mlVkp/9Vt1g6\n161QWYAbcJ18uxR3gwDYRDqeo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTzR/7MxZmpG6Ci\ne651HOZ1n8wB+jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDX\nfVsokhJCL+z3/G75FXBDBxGiSqqAaofeu4T6nZ31OQIgaXkI9ORySMWLhvNzBniz\nBUcdmFfzSCTQ9XEcKUvqfBU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3006", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3006` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbMjw2m76G7QbJtAWI0zXe8fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlZjZmNGE4LWE5ODgtNGFlNS1iNzAwLTJiYjdjYTI0ZDI2ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzE5MDM5MzAtNTEw\nNC00NGI3LThmYjktNWI1MDQ3ZDQ5OGExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJqhl4BCjAvgsWCqQTcuIzgDo68gdzLIaa3eKVGBMPbmlyRQl75NGBT/2tkcn\n34SUDGiveENX5NKLJu29tIY6A6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPNyZqXwnU1MUkUxhsLCXTioSc/+MB8GA1UdIwQY\nMBaAFF3g8P+QZyL2WXNGRGtqjDknU9xGMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAgPRxtTYg8z3LEVAo+51lnVV0NrvLIEFT\naiHrSyH1n94CIA3rKGUvenGlq/XbIRW8ImpmAyEIuQGZXSwkDNLRjnwh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaT/tMKB8h/lLTz6rJon+/VKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWY2ZjRhOC1hOTg4LTRhZTUtYjcwMC0yYmI3Y2EyNGQyNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStvA88vHWq5+ygRbZV8CWu/UBIUHdsdEhldZ4Nb9Ni3d0W\nxcU9V8cW5jyqhtplS37SeDxD5YE1q8ruhtGoJxG0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXeDw/5BnIvZZc0ZEa2qMOSdT\n3EYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTTXgu9iXF/kus1BpEjR8JH/CCE13W8+4/CdNPgUUrMsCIEy73zv1lZXX\nGNYhyXeZF6R3ik/CXvKyyt95bcXKhlOC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAeY4CUdHmq0J5Jh0rFdjdUHUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzE5MDM5MzAtNTEwNC00NGI3LThmYjktNWI1MDQ3ZDQ5OGExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNGU4MDA5OC1jOTY3\nLTQzMjctOWU5MC02NjM1N2FiOGIyN2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATyjx01EpgXLeb5yBchGYTTTaHanc9E7bsxmDHb5qJCVcnCuFm8srP4aGtpHM1p\nulHmY84A8Suo8xE53I6+/x66o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTzcmal8J1NTFJF\nMYbCwl04qEnP/jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCC\nDJ89ss7UkS89wg6Mb7WSzZ+N8GmlyNF/Pofl4cuD2QIhAPn7UfXCfCeXTfA47ezK\n5B+o0HZid2j0qMh7MUqjzWyr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3007", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3007` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbdXVCcqVfzbHE/Dh+47gQEbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2OWY0OTY5LWIxODMtNGE0ZS1hZGE2LWNkNzRlYTM0Mjk4OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM1YWU0NDEtNDJh\nOS00Y2IwLWEzNzEtNWRhZjA3MTYwMmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIV5XteEbEuYHAuGvOS5BrnSkyy/oxAXAeP5Tn/IT2fJqwmDeGhZHC8wbcXha\nPRECAKbxKlquuI3w/SyjO9zw06OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRhyA1tFogeMEQMg1MXVi8YjnGD+zAfBgNVHSME\nGDAWgBRV0Vx1H17YH3ITaVxPi8Ay1Lc+izAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIE0O7srOFGrIbBV3YwhLdzlHu3J0RXTT\n5UPQlt2huCLCAiEAy8XfNArHHMatqhOFr1b31Tf1zTFL3WKDkmdF6OsW7TI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXEMKYnSQkYCspCzaFhBJ5W5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjlmNDk2OS1iMTgzLTRhNGUtYWRhNi1jZDc0ZWEzNDI5ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8rBWl0Y4EEiOJjFpO8q+c0YOhj0NOxf8g4/n1zM5awTQk\nclgclMWlmTxROGpdw3OTznrYoEbd//DOrs48Lt9Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVdFcdR9e2B9yE2lcT4vAMtS3\nPoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgekVD2Usdjqv5LH37QXsAGmC0YfVEr8u/IksCIHhoTI4CIEk/IvKCNNI8\nNS3G1HVrF1Ck85e2aCYUUOeuQpqHrg/D\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAaIeIZ6/dd09Ygn9HF6Vl4TPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM1YWU0NDEtNDJhOS00Y2IwLWEzNzEtNWRhZjA3MTYwMmM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMGUwZDI3Ni05NjEy\nLTQxNDUtYTA1Ny1mN2UyNDcxYmUxNzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT4enLxVwElZ5mS745PLX0WGnttTyqMfXcFr9uNUrmyW0ylL+29tZ3XV/lh5afH\nqWL6MWMWQUzTNiNDO7PlKozNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRhyA1tFogeMEQM\ng1MXVi8YjnGD+zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAFs\nkse7I7qKNyYSe+KO/3rJgRrXF2GjRrsEk7Rt36SyAiBYnUvkS7xsmRcmxZNSaSwt\nbi549zwiWYOE6wwsyptlJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3008", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3008` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQpd2WDrMpOoDTREvIvj5IGGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2YmE4NTMzLThlNzItNGU4NS04MTYxLWFkZDE0YzIxNmYzMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JlZTEwNGQtMTI4\nYy00ODczLWE5OWQtNDQzYjhlNGZhMTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb3fVAokqCG7Gwaz0M5mpiNS7aIs9wCgTsTG147LbBKjJCq+jQPdn2xMTiTOc\nIDg0E1KNnMa5TQxKCe3Y6hxlUaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIsKEZAEBgT/IMKIPOX2TS0XKPZcwHwYDVR0j\nBBgwFoAUPlXLOchk8v2BOmhpOkYT+bW1fr8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBOW+OHLChdxIy8\nX6RTxkWEw+tQ15hiiTFJPmq5f4yfjgIhAO0R3qNkrPuhPeQcgGnGm3nX4EHo5Bop\nh1xgFyvtwvHO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXNqRZdtjZ4pYBRwS6s/nWEZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmJhODUzMy04ZTcyLTRlODUtODE2MS1hZGQxNGMyMTZmMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3kP2oYp2NMOoafHj1KDxo8q+rgSAcvFb3KvQvdZOukAVx\nZEx2qPTY2AEnFXMoIauOo1YC8rzGb+5sAVky2krPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPlXLOchk8v2BOmhpOkYT+bW1\nfr8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ3g6amVW8KW4a1FkPZApMa8MvNBh6GknpwnXzG1Ec9ACIQCBXzqhRBpD\ntOokGnyAzoM/xfCkZ9evp25Zdh30IMnQJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAYLbKvjuriyQt8solAtlRi93MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JlZTEwNGQtMTI4Yy00ODczLWE5OWQtNDQzYjhlNGZhMTgyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YThiYzg2Yi04OWQ0\nLTQxZjEtOGE0MS0yZDNhMzQxY2ZhZDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ8Zt0Jy/M4FpruVK8ab6eYE6sgdcD2A2q9L170NFcYzyrjIjt+v4SMCZSv4xNT\nE5sRClIwimfTt8V2Zsxi9hf7o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQiwoRkAQGBP8gw\nog85fZNLRco9lzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGIF\nyFEJm+1/VC4JFh+99ZhAxsBk85Xq6SDsUc82C4aOAiBdDwbSh9wSezq8unl4i4Ay\nj6psQuTd+pPIH7NqBQGqrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3009", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3009` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAWofVgyCgExo1p6ABdizmO6HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1YWViN2I4LTkxMDItNDkzMC1iM2EyLTZlYjRjODNmMTM4ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU5NjNhYjYtY2Mz\nMy00ZjU0LWE1YWQtZmJkNGY0NDEyOWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnWqP8Xfayns3zFXgNUS6cKdE3VEWbci8A5bR/fB+CWPYoTgMnCW2g2kHSQX7\n262ZnVGbTd9anoPGU7daIBHR+6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMiyau3i3jvxuwENwTT1MoftZ5fIwHwYDVR0j\nBBgwFoAUgPN4Wlk3YnjKwGktvDgvB8JlHzwwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA03AX+m63l68gq\nMi7k1cL+xkneF8UWfPLp5htJuunwnAIgdRZ+YiFbCb0KJs0yOBu5CwovHxhiNywO\nu8jSYoaUFfk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf7f5N+cirXQMixfHoB0rm7oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWFlYjdiOC05MTAyLTQ5MzAtYjNhMi02ZWI0YzgzZjEzOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzbWMqLzid0elmZTFXWlCX1JuOn1rrTmcq9cvFL8iQycei\nMCGXpvrY4+1tgNgmS//6Q7EgrMXH81Pk+X/PaYfso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgPN4Wlk3YnjKwGktvDgvB8Jl\nHzwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL3YQIQg7xBB1y+Xv8Uw8fhrKAiCl3qs2esjG1HEqLn7AiEAj3tFo6/X\nPs1aSaTvJEuLKORwwEDxZCba3di+eF3lNf0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAaoYx3gjNhKd8P9uNDiLFv4/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU5NjNhYjYtY2MzMy00ZjU0LWE1YWQtZmJkNGY0NDEyOWZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNGM3YzZiYS00ZGZi\nLTRmZTctYmQ4MS1hMTdhOTdkODE2NWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASybBq5GEzXaJI4AVJxJRN9hTJMJ90mehW7SMqArFngLzb+BsTc4SQzNqqWiP/q\nYNSAaE01sgumFBu5FTqp5Eq9o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQyLJq7eLeO/G7A\nQ3BNPUyh+1nl8jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFXY\nmINC9gZPHJXIUKtHqIISrizZYdsbz1cfFGIL8Ok8AiAnFrNQ23x2bAIHTgWj35n9\nIdusRb8XCxcWzzKGWiWR8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3010", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3010` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAZ8AwCqzE1pbpSFbue59NueVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZDYwMGI4LTNjZjQtNGFiYi05ZjU2LTgyYzBjYzBlODY1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI0OGRiZWItNDQy\nNC00MTBjLTgxMWEtYjEzYTMzZjkxOGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5a7y08+xvPJ8GL0lvpTHkDHBRa/hGOMtThQ0PA5vU8Jd1MQ4eiCz6Oq2ahbs\nPOCFaBGICXTo1lIBu+PLEQ6jgKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJOZExSX6dWB3EcPfIeqh3icrBqgwHwYDVR0j\nBBgwFoAUwar8bzbirvPSOQP0MJyPHJh8b6swIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiB3Jtdt4tfqXYAsTz7noRin\nTYgq8g8lxG0QlmBoQ4/wegIhAOVJnuixRjkMtv3Hb14NIyZp0RlhBtWMIl4u9p3f\nSlJF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcuxO230SoWwJCVALsakn5xGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmQ2MDBiOC0zY2Y0LTRhYmItOWY1Ni04MmMwY2MwZTg2NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS69nE6TfdkhivgUJLfxcTvLJ672y966Vrb06JlrmoyXerM\nztAaAwzEU1x7Rs78C//K83Zuq2ol6OTX/Mqv0aQOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwar8bzbirvPSOQP0MJyPHJh8\nb6swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOdwxF/JsWhA1Zp/vXO+xaiINt70s/zzuFj2Hh5x599oAiAXnGqdhkX1\ndtVfUNAoaNC7yX+mb7y7PuluuSL7EwahzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAYUzNpWHHaMPhf/w+KoCQ8jpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI0OGRiZWItNDQyNC00MTBjLTgxMWEtYjEzYTMzZjkxOGUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYzA1YzJlNy0zZTcw\nLTQ0YjMtYmM3YS1jNTI3MzI5OGJmMTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARID59JEYL72x+lkeQZX2YjvzIFEiYYjToK2ExbdV4qNUyp5UN1UfWGaNdx11Tc\ny39brf2fzE88E5y8UBiSTdQ/o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQk5kTFJfp1YHcR\nw98h6qHeJysGqDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAzv\ntgDWg4l31QDmD5k5O/EYOo3WwfZLQhjkwIR1YxYKAiABnCa7vV/Z24w+grxz7mHi\nKgM4e9KlAlyZEhrf/auTOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3011", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3011` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISARwQH9MFRQcWGXm959W+PV6vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3YjUwZTRmLWNiNWQtNGIyYi04N2QwLWFlY2NmMTUyN2ZiNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE0MzlkZTYtOTU5\nNy00NWY5LWE3ZDItZjczODEwOWQxNjM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuFlqZpo4A+7hLbPvSanbMmX6cWwHL3Xf2dX7Dr+JRJHGbaKLy/zOo4X05vdS\n3Rga0xzaBU4VS5hp+avM9CkbAKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtS8FVWK+gvF5/SsggjgafH3Cd1swHwYDVR0j\nBBgwFoAUzaZzTwC9T7000wyGn4y3m9INw+MwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAlapn\nLiuCR5Ye8ufoBoDImcmxRc75g86XkFkXcvTemkcCIQDmfy435zl8r4kUCjrvSxJe\nlx/0oBGUxMT/TF1NkVF1eQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS6yB3FZ6L8ryn1KIXqT5ZwqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2I1MGU0Zi1jYjVkLTRiMmItODdkMC1hZWNjZjE1MjdmYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIZf73D8+tmgVS7EaQWjItQN1MRCUU6g5oK+pJ8Bp0b4bM\nGuPeou7+5l96YwYnybxD691baCQkJHfarcXg7HcIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzaZzTwC9T7000wyGn4y3m9IN\nw+MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIAl67ckVTgUiUdSMQw71EbQ5j9Dc1cCgxlHjPDRJvjRAiBVFOjQfeLC\nh7I6ayMC8nzpWs6mIZPbAwcZ/95TTYDBHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAY45/MwgAgKk6GBNRSgVblsUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE0MzlkZTYtOTU5Ny00NWY5LWE3ZDItZjczODEwOWQxNjM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZjY1NjQ4Yy0yNThh\nLTQ5YjItOTIxOC0xYjE0ZWFlYmViMWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARAnTYMVle3DdrhJWURsQPM+t1SEPYEIH2OZN/wOvuV3c9S6OjTZYJERlC4bsuU\nUz58ZOywDCbilwBI2OEW9Jyoo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS1LwVVYr6C8Xn9\nKyCCOBp8fcJ3WzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIEP4\ncD47TZsFH5GWKSTko/eAHkIlSgzIXvAt3JadjXF6AiANjx7ie/MhEUfxYLOjpyTK\nh0LX2iwhIVWc9zBdPkprwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3012", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3012` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAbUmdQYG89q4OhaJyYXybXd6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlYzQ4NWNjLWQyNDgtNGE5Yy1iYTUyLTNmNTVjYzY1YWI3NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIwYjc1YzctOTE2\nYy00NzQ1LTk2ZTYtODZjMWExNTRkODZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPILiE0C31QsWEwG3KaaIAZowkVhQ9O4vqS4ah6TgGsUgqg4qQia6Mey3ljva\nl8gQA0G1lG3FEpxM4XS/vkWpKKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUScpry0oL+LVPf1JdBX3YRrRp1tAwHwYDVR0j\nBBgwFoAUHj+1AcbEwa4Hwawte6Vb4MVnfTIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAsZNXI\ntmBqegrw+rm8ZHNwVgmRaNY7wss/V3oyTK9kxQIhAJBoSL/6elUz+FfgtleDj1Y6\nRxhq6d11HgJgKhpI+RtH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX6Apt+XnI08yG67TmCJtKkKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWM0ODVjYy1kMjQ4LTRhOWMtYmE1Mi0zZjU1Y2M2NWFiNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQa7VOWLlmbmffhqWNncRtx38mze5ZaeTUUChSDrHkQIdE\nKhb/p9wmI5iJ+bTFNtzMnzFXNk9OdPJDXARbrkCvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHj+1AcbEwa4Hwawte6Vb4MVn\nfTIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP6C4TXlP0+qosLqhi3TftoHA0f9j9UMobLBDPan/SbYCIFmNYsUTcZzW\nPx15ura+fXdR/OQMuis6qci3c/C4F9Ke\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAYp8qehoe2PGBSwNPPDCTK5zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIwYjc1YzctOTE2Yy00NzQ1LTk2ZTYtODZjMWExNTRkODZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYTgzY2Q2ZC1hN2Vh\nLTQ3MWItOThlMy1iMDI4ODk1YmVhYTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR6KpDpqPqWA/XYTP0iS06/LiVKCsNeVRi7jnLPacn/78gBrQ0ZQogri6CxUGvJ\ncwi2z3dXCcEhY9mkxDhqCHM/o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJymvLSgv4tU9/\nUl0FfdhGtGnW0DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDe\nhMC3cAcp1l27o6tWrA4JrNyqOWj5zv52iiXqnhaxFwIhANv5WMjGgnMaJVD38Wj5\n6gGyaS2h/pjhevr6tXWLpCa1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3013", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3013` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAUFIHnuPzW1966IDneiyj5jFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlMzI5N2MwLWNlZDEtNGM3Mi1iMGM5LTdiNTRhNTRmYmViMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZjNmM5MGEtZDBj\nMS00NzBmLTk5NmYtZTM2MzUwOGEyOTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2WrDnEvEW7R1LzucNR0Y24LMV93QcQHHuvgMV9Jk3CSL4T/dem+HR/qpvCep\nRPVTrJLcliXMBvmlPUT94NWACqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFD72IhygngCn5aEgtNSXy3TSf6XMB8GA1UdIwQY\nMBaAFDDXSfnSY2b8SaHuRI+Jwqrkgrp4MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA6sq0gp7u0GmhDJ6PTuBr+n7pUG+vl8Az\n+u7DIkocna8CIQDY5wERlA59HZanflnWTGt90OqL/6qdzc2Rs5LRYsRs9A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWfQiBzp7BuvRl3lAhDMvyy4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTMyOTdjMC1jZWQxLTRjNzItYjBjOS03YjU0YTU0ZmJlYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATP9CH9spRVfCklOMGfOiH6xbmI9ttSlQ5VObhRXd6sc8Aw\ngwiYc1yXlLsf4t9WMWspJBK70cbKqvIzo3vi1Ddjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMNdJ+dJjZvxJoe5Ej4nCquSC\nungwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH5i94cZCylyKfN/5FexZJWBoh5lhY4jl/z6V8Hr8xnICIEadYfUGd7X3\nVFPki/4NTn4JKUvoVzrhdMvS3RSPKVcb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAT4C4oJ5av1GvzhiB7JM651sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZjNmM5MGEtZDBjMS00NzBmLTk5NmYtZTM2MzUwOGEyOTQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyOTVjNGEyZS0xMWYw\nLTRiY2QtYWE0MS02YWU5ZjM0ODJhNDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATx75jtq/b5rs/9ePwRdNv3CIo57p3GiKgn+4vnVEVoXxe4NxY4FKQIug9N3OIc\nuwFfGY1lz0o92g+h5HnJk9Pno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQ+9iIcoJ4Ap+W\nhILTUl8t00n+lzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD2\nh0kkEGRAW+GOK2zddWOCgJ30Z6pTlfS75U9x3v0WCQIgBvrBkJ1eJZVDAWUA8ZOj\njH9Dc9KAcyWGTMdPmsFgTtk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3014", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3014` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAfvMyn2/8LzpOf9i886fZuPsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyYzk5YjQ3LTM0NDMtNDBkYi04MDJkLWI5NGE1MWE4NWJiNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMyOWMyZWUtMDM1\nZi00NTY2LTgxZjItYzk3ZDQwZjQzNWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw3n8IEbijjpYFZA7p85otGYn4QBuUqP6ntNQXxYcIqlVIWKwVy2A+j1GFar2\nKxviNtAJjLS+9cFHaY8uJpyBt6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwk0I/FjOwVbq4MeuXrHLm7pAgfQwHwYDVR0j\nBBgwFoAUnLG35X7pyiRJucIwqrkuSWSmYOwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgQ7eb1/k0Gi8g\ncT6/HnCMwEC4Y++nlF6wYGNfCn6nVOMCIFKAGUYr/ut6cRC0rYmG3x9x9JP5tZC4\nOl29l38BKcCb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXXHjjCidc2Ta3AbfTdb7VIOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmM5OWI0Ny0zNDQzLTQwZGItODAyZC1iOTRhNTFhODViYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIbNOuC1aMMC8AFddfcHfBYzhPOlTviQIcn4ne6p2ZKeZK\nGvh/wIoAyGtsFKfpa86lAMD/ObQPbEbKsuVVr5Lho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnLG35X7pyiRJucIwqrkuSWSm\nYOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV3gLu6CZ++/b+MV8cIwyxFfTxyx1EvXcHAqgNspyaKMCIEcDtGWFT+T6\n8+hJ1A8fCEhM2X+iKqvnLCDiGsXJwFV4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAch2LyX1lIqqSjTGTwHsD8TEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMyOWMyZWUtMDM1Zi00NTY2LTgxZjItYzk3ZDQwZjQzNWM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2Zjk0ODBkYy0yNWJh\nLTQyOGQtODk4YS04MzFhMDhiMjBkOTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQg5bf84MCVVcofyqk21BRgtRMMsT9fqYa9qj5yeEU9peyOF5Qzw6hSjw5b+pNC\nsfpWC6O2/H2MmYeroKP+0qDwo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTCTQj8WM7BVurg\nx65escubukCB9DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDh\n/7KRYDBgOszHNJWnufni20s7TeS14mf/9tgAXhnQFwIga/v2fKURhz82eVz/2NKU\nzDxV15JcOrisFwJ4hZZSHmc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3015", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3015` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAQj2fTuw7YZVfhQIt86+8CjtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5ZmJjZjA5LWIxY2MtNGFiZC05ZTQwLTRiYzhjY2Y4YzIzNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk5MzU0MjAtYzUw\nYi00MTAzLTk4YWUtYzY4ZjA2ZGI5YTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElfrqCFyuXDjd43mTsC0DdvtIr8bpWX4ElsmH5h3V2kOZjJPlKWelw3/P8U0Q\ndKKDjqGW/pZZH/f1VsgPTRQe7aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpxI83LNhsvU2U/SNHH7w3TkYJRAwHwYDVR0j\nBBgwFoAUfuQHuPVd8LjewJO9LhwDV6oOxigwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgeZgdTdQ9xix+\n8o10qycMvUrUf3VcvIUeIigXqo5XxNgCIHj9ngmJ341wWepIum7MqLA0zlefqpYC\nkAEpBpaalCiy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeJVQPzoi5rLZ+xaBmsoNuk5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWZiY2YwOS1iMWNjLTRhYmQtOWU0MC00YmM4Y2NmOGMyMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZkXPGp1XUu+DKt0lIlIdpJPQerhzpbEYZMdPUymi0Levj\nVZCOcV2LVoGqE2OoYcpOsHfaLc1zxnGJYbvMZpVEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfuQHuPVd8LjewJO9LhwDV6oO\nxigwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKH59ONEZdOvXosijpB2tgKDo9BqIxphmj78xHjTwXhzAiBJPiEvCaMK\n8Jt0x6cplG6RVhxLJoivL079oWXNSw34Vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAf4a6ctlOGsnos0oZZgKxii+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk5MzU0MjAtYzUwYi00MTAzLTk4YWUtYzY4ZjA2ZGI5YTYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkOTYwYjY5My04YmRl\nLTQyZmMtYjFlOS05MDUxMDk4MGVlYzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATNEAYRZ4NweNp3296lqBSzS67wXlb9HZqawvD+sU3W+Z6j0IsXpyC/hT9X+YeM\ncLI9XqqqI663XIEMRmkFsBLXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnEjzcs2Gy9TZT\n9I0cfvDdORglEDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGJK\niTA2Wn9XnSxEZgNo1/6zixajfBc0PKS/gCVqR/7yAiEAjrybeIfmtzeySutKNEEU\n4HpnS/ffYCm3xrljqCPBhq4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3016", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3016` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbC7NF1uMYrMpF1RMoGyjNysMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhOWUxYmJkLTBkNjUtNGVlOS04ZmUxLTc1NzZjMDIyNjk4NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdmYTNlOWYtNjcz\nNS00ZjExLWE0ZWEtNDdlYmNjYjMzMzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGJVvQrUnYpFFWnaXRhj9yWDRNXHWrhVuuMaf5DIccT2X4ksb+z5NPVZ6V4WD\n++oxJWYuSi59v4EdL/fzR7OIkKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpLRbjEkvQB3J6GBL0it+ITefR/UwHwYDVR0j\nBBgwFoAU07qdBBnhCkZLRe4mTMId+aMAgmcwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBJFL+dRjTe7\nJp4FUipY8fU2TwSYHebfW83Uj611eeSpAiEA64LwwCilfeSRHpLZZGkUaVvC8fTa\nmNQkNg6xo+BhY0w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQwa95s3CWQ+GNcn/1xkC0zWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTllMWJiZC0wZDY1LTRlZTktOGZlMS03NTc2YzAyMjY5ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASllY9+lZm66WggWSL0G1nxMo1LdUJrWNBYnJ3nUvpVoDwJ\nlB0JWYwBwYGMNMTVFfdIyFxc71TdUJnwYJXWvtkUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU07qdBBnhCkZLRe4mTMId+aMA\ngmcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIURqx0v5yDuGCJUIgzfyVa77BpJ1KjlP+ZBGQYvTKj2AiAdWtbzD067\nS46Tx5L4rj2pQu8IZKa4TEo9lXVIk7bz/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYxVkv3mL0oERB5leTNO28p3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdmYTNlOWYtNjczNS00ZjExLWE0ZWEtNDdlYmNjYjMzMzhlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YzI5ZTcxYy01YTA5\nLTQ2NzktOGViMi1hN2QwNjJjZTczOTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASvZbrfFgL2EUzqNLCc10DYuZQ6+p++ZvsQLFtF4dwQ84dzPOKfE4LUdHnt/ouH\n04DoKik7z05KlDedQ5WQKe5Zo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSktFuMSS9AHcno\nYEvSK34hN59H9TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD/\nKIWmoZgCoufjRSvVyS/PCqWhRVvLRTfzCpWCcEnCCAIgT0A6YWGoJ6IPFuQRlNRx\n5I2njtrkabYigaoDv0LMKOs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3017", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3017` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdb8jzyWrw5lXclyPfg9KOVVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMjRiMTcyLTczNDMtNDlmZC04MTljLWQ1MjM0OTI1NGY2ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI1ZGE2NTQtYzNm\nYi00ZjBhLTlhMDQtOWQ5NTA2OGRiYmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnvjgUXNadxGWjhnO9wYgF+helzj30UxWYCVvSyYU9X+kDObF8g269hgMBGSu\nI5/6ZzUY/sv1n7rlPmVJ9lbhjKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpWHXemqEW/l5nEwPyMx+WmcWPZEwHwYDVR0j\nBBgwFoAU4STJzIann3UEA9/uwb8SrkDU8AowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQClulcc+w1m1KPP6wTdy0lai5QpuYxCv4Lw+s74PV3UtAIhALak1n8Y5G1f\njW62rklCzj0igHnNqIGim8qK7Ud6BWre\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQKHaHG12LqjhLCBnmalg/EsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTI0YjE3Mi03MzQzLTQ5ZmQtODE5Yy1kNTIzNDkyNTRmNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwbiEiq+8UKUHKYhKor0R6zUm/+aSeNPgJ3AmviCC1Zt7T\nMyr49GtBwQpgIc1gNp1HiFvZ5f85c+W4whxmatWOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4STJzIann3UEA9/uwb8SrkDU\n8AowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAoOFH4QRwDnTijCkicVvUZI7RMhijcgCIsEkqBXmP1sCIQDUfztVHxMN\nr+QJPLPsgk2IB/cU72Mao8uO6HhX89J0Wg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAbygKfUtDA5d+D1kowoy9LjXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI1ZGE2NTQtYzNmYi00ZjBhLTlhMDQtOWQ5NTA2OGRiYmY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3M2NhMjhiNy1kNTE3\nLTQwYzMtODc0Zi1iZWM1NGZhNzI3NzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT3LtXtPTQAg9/XKQiUSSAHejULYcflfhUYUt/W2liz5TqheI6vDP1YId4w0sqT\n75SyynAshl+/TJ0igHxHahR6o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSlYdd6aoRb+Xmc\nTA/IzH5aZxY9kTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDe\nx8xI2C+FZBJFMcYk2/JbKI1yJmAi4Y8VIEcywDF6QgIhAJDzqdDJyKRAyJFuQ6ZW\nzplZjRxaR64xEahJWOmdv8FQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3018", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3018` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAcxWpGdC6aCJSEmPEJo3D3GxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwZTlhYTgzLWE4NTItNDA5OC1hOTE4LWZiZDhkOGU2NjEwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDU2ZWEyZDMtYTgz\nNi00YTcwLWE1MDktMDVjZGU2Yzg3NmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeRBEzHjpnr6pQpz8dG/LlEaAlfWDCCMWDgx8h8liLB6piZOUhf06A7buVFR+\nZulzW5fzGc3jRArSsYAXAUyxoaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4g0yoFdWrK8XowtJyDNWCgdDOk4wHwYDVR0j\nBBgwFoAUXTknHEOClV6fMAg+xVLSqc+YzSYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGaH/JgMCQI8U3LqnN4YeTM9cNdv1r0M5Bw5AC1LfEpzAiBXxnklHqdoHSkg\nLo9kQnSgDwahIF4coq7i7eB12ZBH5g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQcm8PLVxY+lZLoYAagZSk1VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGU5YWE4My1hODUyLTQwOTgtYTkxOC1mYmQ4ZDhlNjYxMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlUWObYjhJ8o+pp7A7BH9l79q/C3sy4Lbm+ZGifyVUHF3R\nL6deXrA6B2hGpXB6cWB4Bs2dlKPut0UrP9JSinkvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXTknHEOClV6fMAg+xVLSqc+Y\nzSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIoJGV8ZRG68qJNRm90m/7FkBIo0HkQNcwA2jqdIfIAxAiA7Fj7Rd9XO\njwBNbgmbOt0KDKO0RW3m636tyeRBNdYluQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAWGZBQ9DfhIaS/h2v/fTwCVEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDU2ZWEyZDMtYTgzNi00YTcwLWE1MDktMDVjZGU2Yzg3NmU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0NTA5Njc0Ny1hMjQy\nLTQxMzQtYTE5Yi1jNDcwY2RkMzM5NTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS32y2dqEF61rDRjhCKACIExtQmiG/sjkWPHTnQFTQvRv5AdbL0v9lVjYz5P5K4\ng0UVyRVUKm7xGHRbrjRvhVs6o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTiDTKgV1asrxej\nC0nIM1YKB0M6TjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD5\nWBVzyImbQxMTM1NBQVPsdYhHHUM4HHAyTctvQj54dQIgNnkJezja96bLfbbFU8rc\nlSfgWPHNc9HJEwjVdaZTZOU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3019", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3019` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAUV1CpvWdf69eMYqSDfN7ESsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmMzNjODJjLTkzZWQtNDg4MC1hYzQ4LWU4N2Y1ZWVlOTdmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRmOTk3MWItNzIz\nMy00NmQzLThjYjQtNDdhNzUwYzcyZmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET1WMkboSN6ljcXwGDarprsLF0wKWbDX0uL5xkwayNg+9ukLSXpUAORAwQDkJ\nhdDFO6LwKmwGTnRrKY/i0nnliaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdUyVqfvJz4ziOea9oXvY9p8S+PIwHwYDVR0j\nBBgwFoAUcxDjTNt4zmSQ21nd2eB6tf6OxQUwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBvh\nt4eYPtcH9o8f2sCiOe6xWyKyGG/+X7B8ROYlg30DAiA/h8zNBGYj10bVNq6pcFMN\n8fCq113eznNwvQU++mjb+g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfK4RELJk/6uk2rGl1cZcJT+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjMzYzgyYy05M2VkLTQ4ODAtYWM0OC1lODdmNWVlZTk3ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASL9vTy479N2T8l1FigxDwIX1yPLK6RYPXzvdJ9dZYcmi+s\nH0UUzipw//hJQcvcLqbQ6YOF9HImJzGpu4WvVjbmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcxDjTNt4zmSQ21nd2eB6tf6O\nxQUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM0OvmyRoHZpvyE6wva3aLwwA+iEJq08TWh5ytK4M05OAiEAgK6Zm+P4\nwrMTDzGV9bR5G+pTIkuBUrj/dp5NWlDwVu0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAXZNiP4WZZSBzSUotT3wKmBbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRmOTk3MWItNzIzMy00NmQzLThjYjQtNDdhNzUwYzcyZmE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYzYwZWMzNS02ZDdk\nLTQ1MWItYjU1Mi01YWI2YTM3ZjljOGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARUOW3MWYKq0lldzYPYfTo3emcSzuxR5NsMi7cA2YSnWHo3CjKOrlGafRk+sNP1\nV6rFy8Zu5bfm9nw3m64A7Vx3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1TJWp+8nPjOI5\n5r2he9j2nxL48jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFMM\n4H7Bf4UAaC7k1S0M4xkGPIeV9PStog95iJGa3xwIAiEA6PvAwbXtakEUquLXODhc\nu7no202z3VUYnwKeAhZSd4s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3020", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3020` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAbvAdc4iYUy4NsaAnNN0esCSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiMWMyN2NhLWVkZTktNGYyOS1iZTc1LTZkMmM3MmY1YjFkOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmZmN2M3ZjQtYmMz\nZS00NWZjLTk1OGMtMTNiMjVlZDQyYjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFciiqJixzB5zFUda4uKuF44TpnhbXWRaxx7KW5V6gfymWTkrDWeNY1+BIEZp\nKa6/lKRpqfU2bPgwHeVhN2TRYKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwL+2bu4mqspUq5Ei3apNvzaPcqswHwYDVR0j\nBBgwFoAUbE2v2FBeNSnPF9Rpn/YA7VsC8k8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDvPlwtttq68y4QO6otDdBUcz2Endv9kg1BSAxx27lWeQIgFfcc\neWexrqjnK4ZkNV1P1iGst2s0OygJwdUkergKVRE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcd60e9Okrhc2EVYJ5KiYom2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjFjMjdjYS1lZGU5LTRmMjktYmU3NS02ZDJjNzJmNWIxZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwov/Mqk2S2kF+C4SWuK0fI2dCF3/W0r/rY2YXWe4vMLPd\nebCE1YSiiV3gH9T3lFXNb9OWnSEh0ylYbSOAqD5Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbE2v2FBeNSnPF9Rpn/YA7VsC\n8k8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWMmQKSb+GsV+i8SJDE0DlfYR1TVKVX1HiTC7S7b8BAICIQDwiWPFB2/s\nHlENtnT1o55x6QyfEGgknJz05kfsS2S6nQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAa7EjdlfaBdBp+QvaWLbQwT/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmZmN2M3ZjQtYmMzZS00NWZjLTk1OGMtMTNiMjVlZDQyYjA2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YmFmN2ZjMS0zZjZi\nLTQwZTgtOGE2Yi1jZWExYmMyYzA5NjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT81t8Ml2wrOY0V5Up/M2UGTsto0asj2b+kcLTaxMd+OxcR0qqH75Jki2lFqCZ3\nzp9XWJJDzUd3ojpdlklmT29Lo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAv7Zu7iaqylSr\nkSLdqk2/No9yqzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICwp\nNlmObQ53RTmqK+AezmZlNqC8NY48A+tp4nm10viwAiAzwN+BaCkJmhGiqgAobre5\nhBiKdJtGp8h1/O+eXTboug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3021", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3021` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATjN9L/9FExEvdhfuCR66TqvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZTM5YjZjLWZjYzktNDMwYS1iNjQ4LTVjYTE1ZjdmMzZjNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdiOTkyMGYtOGM5\nMC00ZTk2LTllMzYtN2MxNzFhYjIzNzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErZamKaSGfvTK59YdwseMQYq0d7HW3+gpW2U/gfO0yIuIe3b9R0KM8A4RifW1\ncVHN+6DPfM1nydPDpKNpp2vr+qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzghogj7ykFQcCgYFXbZKlYwGq0EwHwYDVR0j\nBBgwFoAUISgipwlOJS+7ChsIEAEfD+YG8ZYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFvgH/AVtXYdEi/tgpmBcoS72fbJYZLF6rRijzNcyDrQAiEAvGOl\nRrwWtnLPqgx3mQ1pi+jLfvgsY4ZV/dQm6hg1NQw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUx59aoKGOtyFTC3EDwoOEvtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWUzOWI2Yy1mY2M5LTQzMGEtYjY0OC01Y2ExNWY3ZjM2YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpdr3981kkHaSFdVV/IAF/YjYHeM2ZEDmQFyC6tgJlFz40\nZUEeUp0EQuaPXi4Occe07Tz0QOVMfi/XX5s3uGYMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUISgipwlOJS+7ChsIEAEfD+YG\n8ZYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPkOC8pAtJoH5uloceXFoIW7z75F81gOIMbmPJ0qJO/JAiEA54ADMp4T\npM/YxZ+1ZK4Anehb8tzCI/PtCOiyjKaHEfU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAWDuSEmmnQNqHwa9AdnyYQkfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdiOTkyMGYtOGM5MC00ZTk2LTllMzYtN2MxNzFhYjIzNzJiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZDZlNDNhMy1lMjJi\nLTRlYTgtOTkzMy04OGE2YzBkYzU2ZWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAROEWiwy940ZfXimqL8JS0m/G1wU3aCZ0wZTSvJgjTYyeY4UL+7I03fflx6BJ8/\n7QeXAOntDcV+tULRYigm3vgXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOCGiCPvKQVBwK\nBgVdtkqVjAarQTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDy\n/2CYwIcCQOzyD2Zoj/1K6wNWjBPAivhu2ezLLHBTcAIgWriUQ8LMY+vE+56qJGbi\nvhpluLzvCWzlMK0mENncXig=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3022", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3022` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZyPt144THNDFX/UqEj79A5BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwZDE2NTA1LWUyM2UtNDg3OC04NTY1LTgxYjlkOTE4MDY4MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgzYWU0YTQtM2I3\nOC00NGYwLTlmODctMTI2NDUwMjRlMjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm9Tprvw3LdZYDQ3XBImu1v860Cfl8gf+uQEuAozsQpENVVxMq6Bp5rHGrYzq\njI+vqS+2/EykOJTAae9B71zAQKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFK2vBgY2SGxUxIABsyGgKA7wqA2+MB8GA1UdIwQY\nMBaAFJ+PTHa9ZZz7Oce0+uvSi6MJyKLuMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAw1KWYrj+IFPmf3TC6YCVdhOlAy1uBCj07\nZQovR9gH4AIgDHsKZtgV1qVgU2eBC3hCsA4Hqg7oi72718jr9TXyvMk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdlSsEj7q3+ytJFu1KmOx7/VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGQxNjUwNS1lMjNlLTQ4NzgtODU2NS04MWI5ZDkxODA2ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7xftCMarNWDcDv0CxaSvgPmO5yHnvCxyJrYfeTjilP4BT\nHqcCKVMUP5VwmOyOd/smJEhX85MVLqFoahWPe4Lpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn49Mdr1lnPs5x7T669KLownI\nou4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBGcpIRLP+EO7IJ/aDeXEAlyGEjMNEc/3ox49APwnseECIFOIL8xgTcpR\nZvwSDh248li3oWHWS4BDa3+NxpXUnFen\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAZ41VEfB87BiA49Dy84OMd2DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgzYWU0YTQtM2I3OC00NGYwLTlmODctMTI2NDUwMjRlMjRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZjMxODQ4NC05OWNi\nLTQ3MjAtOWMwMC1mYzVkOTE1MWZlNGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATwpmBB7USciQgjJ2wYdefn+jlZHrtFNunU6mFn81ttzPE9E65uqORzZyFUTDg0\nYGe3jJKhc4tBybO0t6s6YI+Oo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBStrwYGNkhsVMSA\nAbMhoCgO8KgNvjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD2\nmTyQDyfsQ32D+QlsC+QwrtUZC5nBRpHZXlnNlcutdAIhAJleX5wyUk+OWT7e/USB\nygLGYyfnp4ir8TquW5CRpNAV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3023", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3023` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAcWnsf36zEHk4kh9BtmnoVzFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5OTUwYWE2LTdkYzUtNDYzMi1hODU4LTI1ODc3NTliNzc5NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ2NGE0NWItNTc5\nNi00NmJmLTlhNzktMDdlODRhMjYxMTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+SJTMFY1zb2Ifgrhy85rhF37feWQz2Tgh+z0a95n2UBwVoMVbakrRIi87GqV\noDwfi22XUah/kbhl0MGvG98UUKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUil5dk+qZ3nTTlTX6xQjsh5s8j/EwHwYDVR0j\nBBgwFoAUozlqRAMFFZkpoKwnr5Sq0dtiL9UwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgVvvt4z7HKxH8\nmmcMvuyfa6W28gsGklYLMm4euupIN7oCIQD7F5WLL+loQQmcA5jO4nlSW9S1KXPI\nAN03muzhrqRWrw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASnPKhct6PMF9fzVYYDqgTnOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTk1MGFhNi03ZGM1LTQ2MzItYTg1OC0yNTg3NzU5Yjc3OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3jOLIGnPEKDbpxsf1otrBDVsDE7z7gziKKnPdnY3aMDXR\nt5cjz6WhyQClKJpdYLp6ssz53hAmbclw7gVqOiHIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUozlqRAMFFZkpoKwnr5Sq0dti\nL9UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMgCe58cQgCy5MDTleGrWepBoGBaiOsPO+CKXCa+1CtXAiEAmsh/PHnd\n7XZsnpWUQUNuxt1pSaV/1b6iUwR01C4d3y8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAevNDmmc71dAfdF5UmXDSFQDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ2NGE0NWItNTc5Ni00NmJmLTlhNzktMDdlODRhMjYxMTI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZTIwOTJhZC0yZTlj\nLTQ0NWQtYWNiZS01MWNhZThmMWMwNDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASPXDbIifbb3QvL9tJSPZA+XZmMxT+AHPDE9TueqCWRgtoeT3Hx+YQuOTBNdYSN\nS1UVUHbM/UViWhExlp3bln3yo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSKXl2T6pnedNOV\nNfrFCOyHmzyP8TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDw\neXs27SfTFKk6n0toeI/Dy+BQziRB6XOzlRI//zXpDgIgMNNjw8LZJ006ztqe89Mh\nqqZdRF9tQXaC7BAp8JQlpC8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3024", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3024` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAe27GZhTNLRnGVoYhwLdaXoOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3ZDdhZGI2LTc2YTYtNGYxNi05Yjg1LWJiNTgzOGQzMTk1ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc5YmE2MWItYjQy\nMy00Yjg4LWExMTMtZTNiOWZmZjFmNjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqbMN68UhzMXbhkENFBnAKC3v3ODGusE/71QL4Rfh/UoM4+aIO2Ybe0wiK8XP\nSjI65dr4I6BkLG8TfqzLLo/Y96OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4pPbSPL1KVHEU0YBrCnyshosRtgwHwYDVR0j\nBBgwFoAURBenPoiZ767JFgMS2Kllq9FduD4wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgWpvsYXNHbzoN\nT563leU2Ebdf3aj2OXVze+87516qg68CIGQVoXW7S6RMORVFQiXrnjCRGNZRqR7Q\nvAMYAEUcNoow\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfWXCxk9+BB56MIqfIOKZTlfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2Q3YWRiNi03NmE2LTRmMTYtOWI4NS1iYjU4MzhkMzE5NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDZD+Ne0Q7y/zJhLktcvr3SrKTOs02U+5RdD9SScyIumfz\nmS/zvdM7JLu+fAO5YpsctxBnSn/A9vBK6rJqhzEKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURBenPoiZ767JFgMS2Kllq9Fd\nuD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV+6FhRJ2ixMi+ErBuD2uwxGgqzofA0bG9g2jBlv3dLcCIEZE8Xje0iOr\nwLZkXb6c1KP9W2uoq+CuPGppf4HaoQdB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAaE4ybqYxG6akknAmGCPESOAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc5YmE2MWItYjQyMy00Yjg4LWExMTMtZTNiOWZmZjFmNjJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYjllM2E1OC1jMDRk\nLTQ1OTAtYWNkMS01OWZkNDEyMjc0OWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT324UMlOp+dfIJzWgPb54k6aOermevM68dv6HkIq2n5+69t29lnVA8mZT7s2Z8\nAL5vQFKBo2rPzXrnBQGWy5Nzo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTik9tI8vUpUcRT\nRgGsKfKyGixG2DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIEWW\nn4wfMC3lrwDgv2UBb41hgnoZd75PwdS4Paky9ykuAiEAk8XgL0BBQRcZl3OZ0lOV\nlzejjLaGKppeKMWUkGxna+c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3025", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3025` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAejHz6t+ABibc6Dr1R8y9hFDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjNWNlZDM4LWJmZWMtNGViMi05ZWUzLWYwZDZlMzI2OGM3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBhMzczNjktMWQ2\nYy00MzQ4LWJmYzItZmNkYzNhNzkwMjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPkYpISwoZ7wkFwfTaI7XQR2eNzgPUxETcsXAtw10M6KjDJ8NKy5ouRznRt0R\nzeHndD2dDnScL5VWvUIzo7lVdqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWZmTvKEXSSwqv0RzKnmFpkukWfowHwYDVR0j\nBBgwFoAUOOoWjB8tAckmUVGbLruWr+K0+eUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCQyC1BXEqx\n1w6rohAPvKY6+SYNm/nk0xUB1wZ/+V+LcwIhAMXXlBwGnRrB79wuJ6Xm6BTD2hqx\nXGU30iG5+x40O4eG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATbvX+ewPr5pUHRBM1dkxnH4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzVjZWQzOC1iZmVjLTRlYjItOWVlMy1mMGQ2ZTMyNjhjN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCadlNofqhFJFHdaSgzc7yEEQ2ZiA+5clsaxP1bCshqwd3\nlk4uZChC/LhfiTWd5BVtYszN4aJT0WMeDuw0rny7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOOoWjB8tAckmUVGbLruWr+K0\n+eUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc2F0N5JkE1tyHVxfVYNBSKJyWM0HDMxD7saqyocL99cCIGcZHeLOmgh/\nHAP1gogI/hqCABuwul+/X+KBqmDMXyhy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAXx1IxNelmUr1cisF7wEF2zlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBhMzczNjktMWQ2Yy00MzQ4LWJmYzItZmNkYzNhNzkwMjFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NmQ4YjMwMS0xMTRm\nLTQ3Y2UtOWQ2NS1mZTJkZjViOWE4NTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATB8rZSm9TH/U38eFjkQq1HOZN9/lkZgcpzQe4Xd/SaaUkXGEqVK4hLzxoH7cgz\nqzCXrtGcc8IpEhBuMjZ8EMYgo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZmZO8oRdJLCq/\nRHMqeYWmS6RZ+jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIB06\n3WDxnBnBV0QhN5ashvI8BbpYxhzcZx08E3C8Y4RwAiEAxGeP71lHuoZg874ahouu\ntv8CBcjWoywKCtiMC3O/BVM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3026", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3026` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASEm56sE5oSa4uRLWGjNvmahMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5YjhhZDhhLTAyNjItNGYzNC1iNWRhLWYzYjE0NmM2MTUwNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA0YjcyYjQtYWM0\nYi00NzE2LWE4ODMtZjdlZjI0YjBjYmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0yXi/7BJtusyDKDKh28xlK3BXYjsSo2JqE0c/P8ZPg5mdZU7Zas7s2ZYpCJg\nnNIbRa+N55+P7YqalqQsnqa9laOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6IJtCdaMOAkLetc/KHaSnNeYn+cwHwYDVR0j\nBBgwFoAU6CX0/i9/NUvz4vYs24lcWw2/4PQwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDP5ZzTSWzFysK2IJPXwV27o8z5oyMvtSrrbiA7t48VnQIgQl6AV98Ba1dC\nLsBkScnBermbYpPzr+YCFugYuTdh0no=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVAF+EQGDMgkW27q+qLoZumYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWI4YWQ4YS0wMjYyLTRmMzQtYjVkYS1mM2IxNDZjNjE1MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPRzpCoB1w1v3KS2nMP8wPV/kvzeHF5tUOgtmtfZaIlyK7\n6AnopRU0gALiLTh8ksaoLNipuE3J9tlu16qtKYkUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6CX0/i9/NUvz4vYs24lcWw2/\n4PQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMu7lmJO0TceUyiUHdgp+hU1ys+G52ema7sUW17LEOJ1AiEAtP1PEQBS\nfkckjNQDHj5zitJVOzgjXMCCood5NVrDOaE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAfGvqOUhLrSGLASJyQ+3PfOSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA0YjcyYjQtYWM0Yi00NzE2LWE4ODMtZjdlZjI0YjBjYmU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMTc5M2IwNy1kY2Ni\nLTRjZmYtYmE1Ny02ZDYxYWVjMGQzZTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQhXBW6DXHtYrp2jWdZG0RwQic84/nRl0/yhHF23B6VkVre24oTaDVpvMxECbmI\nrXKImbOH0uhQWd0j6/kx9TXvo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTogm0J1ow4CQt6\n1z8odpKc15if5zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC2\nBZPZ3ReQFdP8zpAO0ySvY55umXtJKt5//g9mNDKq+gIgZwescYWtSx0lNREHanf6\nDwz8iIAYegZN5JE7ojYYntI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3027", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3027` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAch03rNFHJZXqGkr6Pg+zTYNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZGQ5NTc4LWIwYmQtNDViZS1hYzllLTE3ZWZhNjM0OGNjZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjAwY2IyOGQtOWU1\nMi00ZGFjLTk0MGEtN2MwOWY0NWY5YzViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE+blp9c4/DXeDfta0Ypjno0YZqVHzuDWM07OBylURS2aplmNCSDA3NR3Q9Km\nTRxhYS0NajIzR1v2rAtUXfdAyKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxtn3YOqh+HJ1Q2rhT8juMBWccpMwHwYDVR0j\nBBgwFoAUenyo5ja23HubXoKmiXtk7NqWaUYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGgE4jEfLxZ03DhRya0oiULDo7rtdcdpkWn8izc3PyhOAiEA5DA03RiL+pO7\nkp/sfers816gAon7cTI0OYlzsTAQrkA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZCVXPSexTRINMMcq3zyItOjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGRkOTU3OC1iMGJkLTQ1YmUtYWM5ZS0xN2VmYTYzNDhjY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMir08csviSYTdWgVCO9isBznaxVrERLO+jXcDD7jTy+/5\nTiBkU16A1KDA13BTK93deKdqtTZwAmlJ1hhOs70Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUenyo5ja23HubXoKmiXtk7NqW\naUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPU9hgq5qCy6tuTa2eew8jFurJXwuSkxvm2Cz/yHsyhkCIACkFxt4wWHk\nVenvJC3CM+VqWKULu2Z9ToCIaOnRrLcP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAcT7mu1yVPKwc2rMDNfpmjYsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjAwY2IyOGQtOWU1Mi00ZGFjLTk0MGEtN2MwOWY0NWY5YzViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMmM5YzRmZC00NDQ0\nLTRlZTQtOGQwOS1jZWJjMTczMWNjNTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASVYNZtKVCOxwRDZ6CsnYJJu3aMoimET3EBuTwR9ZFJIzcUsFMkKb5AB6AYIS5o\n4zTA9rv5UUAMDZoqMcfyIJmto2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTG2fdg6qH4cnVD\nauFPyO4wFZxykzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFQ/\noWH8LyQlszhztqwAhT2DEUrv6RkDYY8WHEIxXte8AiBbzDo6DdsK1ag0vuyIR72q\nS5pKxTyZzBthXdKl1wLcLA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3028", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3028` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAXV6EY2iEAM1Nmy+u/w/cRa1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3Yjc1OTM3LWE0MDAtNDVlZi05ZDZkLTUwZjA5NTBhZmJmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhkMmMwOTYtYjY4\nNC00YjliLTljODgtMTBhNWRmNGY3OWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs9Zmdb8ZTJGw186C4UnTHzRa3EnVdUHxo0UGkfivwHfgPI/QZODWBFrARmjH\n0K3xTNquo+usnIutp6+U7ye7G6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUftnlfOoOqE89eOiEcRGZ81pk7gwHwYDVR0j\nBBgwFoAUz7ongxia2zsMGXh/lYU/n9TkBv0wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG5t\n4fR/08YfJ0CyYsvXEJbRa+yFruby4N9yCc8h7RsaAiEAsOispor8BbepxTOsyY4u\n1SUNPYniBSiOM2LttyyDG0A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAafVdorBMP0sopEmMyLGyqRnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2I3NTkzNy1hNDAwLTQ1ZWYtOWQ2ZC01MGYwOTUwYWZiZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0BdLSgp56Q9pPp4i2DR+EtK2GRbpVbJIQFk/thxHAAbgF\nlK79oaNcf5He7z+emZRQ0DsQ8hsNUIaB3wIVoRVvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz7ongxia2zsMGXh/lYU/n9Tk\nBv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMoz9SaTUz2DKXDb8VWrJI8D4/R/6ZUh8c3bUa4q4TL5AiEAhxXgWb/x\nyRqLoVA7Vqwprr0qJ179SccveFP1kuuYkN0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAeiP5vcPFG0UPDGAl1TMYPfIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhkMmMwOTYtYjY4NC00YjliLTljODgtMTBhNWRmNGY3OWQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZmY4OGQyMC1hMDU0\nLTQ4NWMtOTI3Yy00NWRiZWU1OGJlZDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATHUoJ7fe5z2zXeCN+UmTNGeYdu2QJpAO4PD17EupmHtkz2p2kHh0j7mzSjPfX3\nExCb965KWT48pN97bIzw3PbGo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRR+2eV86g6oTz1\n46IRxEZnzWmTuDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCN\nYEWoID9ONyqvWUvXpaLEpG037yJhQeXX4w/ZNR6S8AIhANL+tvIUAdvhW9OsHBv7\nRLfoaJ4Y26I8puwrJ+on/8CI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3029", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3029` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcMf7O7RhMwLl5K+/+i8kCVFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwNzFhY2I1LTE2MTUtNDdjNC1hOTM1LWI5Y2VlYjRjOGRiODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA5MTdmYTEtOGM1\nMS00YWZjLWEyMGUtMDVhZmVmNTZhYWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4NatgCMaxKCTu4Jl8PvD9Zl/sEiDxqhABSODiC4AKjfvu6X//FICcWQWyun2\nAO/ipxXKUOlFp5okWvrWM5TTmaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8r22rYetYu0oEJ0afYABUe5qyFgwHwYDVR0j\nBBgwFoAU7FPNXTzwmJDPT1/WKdB4PCFyNGAwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDQnDok/+OIdDK0arFucGNlSTtkx0nKNLh5EBWf+HZhngIgM17i\nxt5n7yxW67EmhUcs7n8Gg/Jb4T/sRLUEB6bV24w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARhNAdf7xsWicvO+SRxrXsglMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDcxYWNiNS0xNjE1LTQ3YzQtYTkzNS1iOWNlZWI0YzhkYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSMfDRb3NLHuwUB4WKtsPUqaoLk9N7ZtYJ75UPmc2YTlsE\nPV9ioB6pI/vJ1yvmIZaT+35i5xco1Z1gziecLnGjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7FPNXTzwmJDPT1/WKdB4PCFy\nNGAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPKYEu8xhnXnNgsR7LJjeHToiFIisYeDn26IYKO+IfX5AiA5NN/Mav35\nhLiIoFo3TRHX81wBehqkglQjnUXzS5vGxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAayVZhPenvN0O0EFacGmMfI/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA5MTdmYTEtOGM1MS00YWZjLWEyMGUtMDVhZmVmNTZhYWI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYjU1Y2UxNy1iYWVj\nLTQ2YjEtYjMxNC1lYmE3YzVkNTJkMzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR69SOxwWkl+JFx1zxGyeTc4qyqGK0CMmF19awBnCVHhMOeXT61HVgAWNO1oqUP\nH6tkRgs95LxlmUSscNaDwztXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyvbath61i7SgQ\nnRp9gAFR7mrIWDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCc\nxcDcyHaVSFOkJ8EqazD7u6tY5NQfWs5wCPhLj1LmfQIhAI42euQ5lEISmwbBIgxi\n/gNxlUhm4h+KIbAN1j0HmYtN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3030", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3030` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAal0uS1ymP46B/psvCW5NyIkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViNzdlYzBlLTdmODgtNDA2Ny05Zjk3LWE1ZGZjYTVmZTk4MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQxZDMwMzYtMzE2\nYi00MGYyLTk2YWEtNDExODhkZGEyMjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExDH7MzlQ7NrVYK243+dCI/Vj+lmu+zYkOJwgKzETAbknkWCQ11LeKemjaQ+7\niMkS/HvGamKWVpB+z1BqVabcKKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI6rl/pZdg8wyGUBhgfODWEBsmq4wHwYDVR0j\nBBgwFoAUnXb+A6dRZQ+Rt/5ysEQrYxxw4F4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDMdffEQymxKORFUnl8bNRCHunqNLSIS0WZnAR4KzViyAIgC8ii\nxxsaNY3G/fUADQ+bwfSGg99GGqYQom8BOyYYQQ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU0zH6Hu0n6p4qFeucpSxtzfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjc3ZWMwZS03Zjg4LTQwNjctOWY5Ny1hNWRmY2E1ZmU5ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgSZa/KwbZQATectQlRlBkNnB4OkbQAayvZA+EPN4EQGov\nHCkK4eHUwC3CNPGybUGLzeeV+eHMDdElTazb+8hso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnXb+A6dRZQ+Rt/5ysEQrYxxw\n4F4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKNEhRzi565tQnM8913TohYmvTVlL/OuVMgQgNm6oBArAiEAjwUu3lRs\nv4Bajk1isIOiifN5kqdl/FxRBxRGEnoeoMw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISASi3fT+2I5GgZhFTjwzaL00NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQxZDMwMzYtMzE2Yi00MGYyLTk2YWEtNDExODhkZGEyMjllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NzY5YzU5MC0xY2Vj\nLTQ0NTQtYjZlMS01M2MwMmIwNzk2YTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASwd/z/L+WLPwTJ8rU7kskdhTM9lel03WJig83s0d9kw4L51/DFXe41Y6ZADDnb\nDojeNCyOhPh6FW3vekISjJvLo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQjquX+ll2DzDIZ\nQGGB84NYQGyarjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGO2\nuisd2Nj8oFl5D3wckCWknQiwSyByEaIGPZletOUrAiEA5JALQUQS+nT1iQVdSoKA\nCZxQsW4y88aqnBn5Er2A2n0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3031", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3031` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISARqUry9kJi/8G0ubTv+6wy87MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5YzRkYjZkLWRhNTYtNGQzYy05YjUyLTI4Yjk4YzE5NDMwNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q2Y2ZlNDktYzBk\nNC00Nzg1LTgxZWEtMTgxZWIyZjUxNzMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy/TsLVC9IwePBZIdkqW39mv8kIpb6e8oH0djpP0XX9BGmM33UG1962UvfIpC\nG3LjCGl2clsVbjz4jbCNLYPbBqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQMd595gHFtt1XbI8UU70L9a+GroDAfBgNVHSME\nGDAWgBSPDCB/7OCDMbCegIPqeHUQZVGuNDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICMPxtct8TJgaI66ry4iH4sGXJEXHh3K\nH7Q6B+BHtIhMAiAj+qaMrbkv9aoYQpKiJsM3+kz6JV/ZFNENBl+wgzRqZw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf34Z2q6OqEa8WPKyjTySYwpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWM0ZGI2ZC1kYTU2LTRkM2MtOWI1Mi0yOGI5OGMxOTQzMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASW2UqfHqo/20rwu8RiYT3zvVtXX7lXjllwJ3XWBwYsUAj9\ncEQuYe9zTjuucKOqOssDijo4rn9zVh688EaXzaJho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjwwgf+zggzGwnoCD6nh1EGVR\nrjQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPFN/5kMEpuAQQCjdBcqO+lzeAAESRPoDg4bcct6mKz0CIHwxfjceSQ9O\nvVfa4+Pg8cqJu2m1FTUJNPFUAX0j3C89\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcOgAwIBAgISAfxOYFd8sfHsVm5fmYjVq6lHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q2Y2ZlNDktYzBkNC00Nzg1LTgxZWEtMTgxZWIyZjUxNzMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMzI4YWMwNC00MDQx\nLTQ1N2QtYWU4Mi1kMzk2YmZiNWFmZGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARqh1hbL51mnnRB8V+zvy0JWIyxwMSMw+/Lv2WOO2ZtitnjT/IM0aGkp8VdyW6m\npIzPhbsm92H84XLR2NxuCjqEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQMd595gHFtt1Xb\nI8UU70L9a+GroDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0YAMEMCHxXE\n2gL2jnIOdrm+oHxU9qPwNr3Q8J8Jj3Ax8PuFETACIAN9alKeMMWiHXeNWT7UfGLt\nzWLYIoGhC9MYMj5xMSFg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3032", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3032` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARE5q/okmOh0LzScbYVB0RlFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxNmMwNzM3LTU4Y2MtNGRlOC1iN2Q1LWQwOTYzMGQ1Y2ZmYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmIxMjk2MzYtYzVj\nZi00OGIzLTg2NmItZTgzYjU0NDVlNzg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsKF98aEMI5t1zqQELRD896+J345Dwz+ffvZFaC4aXACIRe/pOqu9KQwaSuc8\nl3/pVHGpOBxfIg45eqGLsTQEV6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwgwFeI2wI71XXB6G2Sn8oHYiWx8wHwYDVR0j\nBBgwFoAU1Wx3T5nwDhhg696wtb1vunwW3DEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDyHDqWY5EY\nbaoMUS+YLEm2TUWn7RXErnV4rRGsinPpkgIgZQVCtxbfL0maZbTuRIySOjYhqUIU\nEzcBhlyQw0u5PQQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeQWQ6WwlBUy3VkVQ9j3AlHWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTZjMDczNy01OGNjLTRkZTgtYjdkNS1kMDk2MzBkNWNmZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxJ8BYb90ljaAyOgN6Mv0Ixof5ICDppufKG9k0gSi3XKnJ\nmqFmOA+ejdUWqey+Ub3bghR5gwe66za4EevWxWNAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Wx3T5nwDhhg696wtb1vunwW\n3DEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOg/ifjCNWV5Tk613RiPb8ginBpa7fQQqhg+VITDidTMAiEA5ZnAlxPz\n6I1pnUAafgMvnVrCUjFXnyvjP0oKlAkqpU4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAeFnCX1LMXBFIe9P06dM7NJ8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmIxMjk2MzYtYzVjZi00OGIzLTg2NmItZTgzYjU0NDVlNzg1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NWM1YmQ0MS05OTUw\nLTQxYzItOWVlMS0xMzU1ZDM1NTM1YjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQSN17FTUh9R5+4IWwt0kPdPpGjv0EQj6KSKLZm67yogSvEFoAaWNxfm7n9h8JG\nYglBdvSJtE1BXyTx8R3fxM9Ho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTCDAV4jbAjvVdc\nHobZKfygdiJbHzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFNK\njVRtxcYUNoZSC92lK9tWoC7Dyrc03ZERluXvV12/AiBBjodxb189QfTF6c+qiETs\nHxKTfRziti+jkwVtJ4cHWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3033", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3033` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXQlWbWMu2j9fNSOjeawE0cmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjYTFmMzc2LWVkNDAtNDcyNi04MTI4LTVhNDdmZTE1MWU5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNiZGNjOWUtODc1\nMi00YTg2LWIyMjktOGM4ZTJhNDFhYzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcSijpqm3/kTTVEtIxohMadQwcIHfbkWKq+Wc68+gqFoD8UdN8BhTexBCkpZv\nUa8KH3/vh5qbJ+3B6IWeMMg8b6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJSBRXSNWWwwVLTFNBNwbVF7JSKEwHwYDVR0j\nBBgwFoAU6AMttP+sSAhCHJ+lOnHICosWFbUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEOcVamzwWpw\nbMihQ0soYar03mHyY5gfKuDmg+jW4x9yAiEA/q9cORPlkX8ePhLJl/wgtPk883Pm\nXlDs1odhFBw9LeI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWihRQTF9KeI7kXY4gGaNBXsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2ExZjM3Ni1lZDQwLTQ3MjYtODEyOC01YTQ3ZmUxNTFlOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARu+/or5OnzT8GuFLsPrSWFGUNoaC/Qhe+ynhoR4+8qH0XW\nHgAR/MI8XwQ8hH3uiFRjEdTgsLuhStOR4ZW8cFsOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6AMttP+sSAhCHJ+lOnHICosW\nFbUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXP1aCzDI6e7u2J5tQEYxCEG1rx2YcgxBky1O929pRgwCIQCoHwPQw72N\nRZ2EC5z/G9BGEOupog9fTwnVq1zUX+vvPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISARLODyh3Pxzuk4I1K6s8n954MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNiZGNjOWUtODc1Mi00YTg2LWIyMjktOGM4ZTJhNDFhYzQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNjRkMWU2MS1lNDE3\nLTRlNTktOGFiNy0yMjVlYjk0M2FmZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASkfqYerxIfAhsNy76A6dUcDX/sYksUtn7rStU6/FIyHZZi39W4IlBKysIpqbZT\n+odwapJvkySrdw/XoOvo8USeo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQlIFFdI1ZbDBUt\nMU0E3BtUXslIoTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICEL\njuF3RQCB9cqsqnae9jmQcwj+8CqkwmHGgSYbMUyCAiAUjlGX96f2TsYQJaasJgUM\n54V6eSZfd/hzyMZVXYX5mA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3034", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3034` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAQs7wW2xIkkQi2gXeOAypd+7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjOGI2YTNlLTBlNWQtNGNmMy04MDUyLTVhYzRlOGU5YmY1NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE3YmVkOWQtNDQ4\nZC00ODEzLThmMjctZGJhMGUzNDUyMTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaxhHzgJ6Rfi1EX0AbkTj5sKcy1pB0xp8eRbwzAxM5QIFuSPlvwEtIuwp3K4q\np2vqW8r2bugjmET7EH7fE3YbMaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP9Lk3Kyia7b15laStYQ8Js9b9sEwHwYDVR0j\nBBgwFoAUU2ooNRBDIGaNdhupl4agkrT+oAwwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiA0jKLbcO/R\nW/S+dfUFt28JqQXKbRa3AarpQ+8WremQQwIgHoeC7GaW9WxdihGA9J3zomxLhSAi\nVAHLReBw7xHrpXg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeOpdrL1PAat9AcZ49DJkB5kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzhiNmEzZS0wZTVkLTRjZjMtODA1Mi01YWM0ZThlOWJmNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGKy6ghTCQi08I1JtBhQLrXICohTnf2UVQMXqfU+Y0WuU1\nZaIM5eXB+APue3b/rrFQJbYz7XtMbc6A0LZ3V6Guo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU2ooNRBDIGaNdhupl4agkrT+\noAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOlCSzmzTvpxPEnHdxeGNx4AOsqM4CSFdH7qxoxs5FUmAiEA0Zv1MF1N\nJdb2SOIGxJc8JYRVqMZs/h12+b7Jz2EQtqA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZ/uI3k6leXRTjgMH8SqUOIJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE3YmVkOWQtNDQ4ZC00ODEzLThmMjctZGJhMGUzNDUyMTMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMWRhMDlhNy1hOWRk\nLTQ3NGItYmZiZC05NjNmNGM5NTE0ZmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQBRqafG1kp3yKSsr2Vvdt09gDgceePFWuQus/i9t6dg4cEwYhjzWXcyBZnOX9c\nefvlKGpg7VDCniqucJx5on1Po2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ/0uTcrKJrtvXm\nVpK1hDwmz1v2wTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDj\nOaskBdD1k/DIBq4P5HYJWL4N4jwnZMNQ/iNZL8Z2kAIgYhFRoBCdqGjod/2BVm+a\nj1yYV5zm8YzLRb5RHr2jLuc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3035", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3035` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAcSalNVgDGhs99OB5wydnHsqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0MWQ2NjBlLTM1YzAtNDQ1NS1hOTg0LWVlZjUyNGFlM2Y4MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUxZmQ1NWEtYjBi\nZC00ZmQwLWFhZDAtYjY1MmVmNmFlNzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4iE4r6YtM2s6Tz12+C2N44OkhzA5pd54hW9EWpy4g3MxyflQ/1ojvMJjZbab\niKRREBg8fG1foSbB0EIq7EVDyKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTBi9qJrNWJmBHUR3yEaqx68lH9UwHwYDVR0j\nBBgwFoAUHuhplnYn1TW58zm3O8Z0o2v13oMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAjN4qKsrf8oAKzGXOyUzXRXGpRo6Rn57jhfjeIU3u84wCIQCCtfIAFMqq\nAzUEeVmsCKN1wVmfozYywVQvwdYCd/xhOg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdyPWRrLMIVImOWJZfoywk4MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDFkNjYwZS0zNWMwLTQ0NTUtYTk4NC1lZWY1MjRhZTNmODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSgwcvVL+102rDSSolEZc9pKu6g2lr6qC62GdRvrIjidub\n5O4w4c2RFODa23B1GtK66N3zO7BU0DXk5+qf4w1/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHuhplnYn1TW58zm3O8Z0o2v1\n3oMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPHVY+ISel78z2HY6cYbpcvgpgz0r3R6kf+oJofoUatLAiAy1cd8cQfd\nMaYfjCHLE+gma1Mrrv7E6frppZc7HNAV3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAdXfHcOdv1u1EolM6p++4brXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUxZmQ1NWEtYjBiZC00ZmQwLWFhZDAtYjY1MmVmNmFlNzJiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMzk0YzRmNS1mOTdl\nLTQ5MTctYWNhMy1jNmVmYzA1YjQ3NDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASZxJXObqZL1YBG3u+oMymLGbOxzVp9dlfDu8KYX8MD3PA+OQlRNFMD4iSDeB2Q\neN1vPtdByAnEKA3YvUMho5Tko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRMGL2oms1YmYEd\nRHfIRqrHryUf1TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD3\nw+r7tuM24rOq1+gAczJmPq7sWny+MvHwmfQlUWX/RwIhAI5q8IzaEvxY2az4fDwa\nWqTjpkaobw9Fydhd2fDJl2Db\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3036", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3036` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAY2joQ4cOoWGGuqN4nfx2Um7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3ODA4ZWU0LTIyMzgtNDY0Mi1hZGE5LTNjOTc5ZjQ3ZGQ2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVlMWE1YzMtZDg3\nNS00OTY5LWJjMDAtNWQ1OTM5MGJjNjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7INgSDD8fIUmNcOXaobUo2TTVQuxGV9z0uQIF2acT7KL34kj//MBKKM+cmmq\n2slPWrKck3FA5dDijB2yYacghKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBXMsds+QrXgyrBSw+lEskrRJSCMwHwYDVR0j\nBBgwFoAUlS+v9QyHtU2IlpHr4iQd5seTKmMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiB2lBHN7WPI31znNQPyLiYe5SY33jqtT4LqUzgyatC36QIhAJH4IQmxtYQ9\nLHfVTtfAxKwCM4HoUF2HIwMllOVqTf6b\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATDL0qfbBBS3y2lZpU/eVyMXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzgwOGVlNC0yMjM4LTQ2NDItYWRhOS0zYzk3OWY0N2RkNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARec+jJCHCFeaTmjX7MtNjbaZZ7aaqPucHJENn1vqt5D4Ni\ncqOJEKjJc7DsE/apwhVegRUVyE/Lz9KehIlS9Sy6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlS+v9QyHtU2IlpHr4iQd5seT\nKmMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOY45zdDqbCsR6AUiJzzKTB3cmh2wySLfBlIn7tCil00CIGde4/mtpWbu\njVF3bsg76yryvsggU9o7lkyO5AkkrrMh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAaxu389JiWk3T53vPuMf4uSlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVlMWE1YzMtZDg3NS00OTY5LWJjMDAtNWQ1OTM5MGJjNjYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMDFhZDVhMy0wZWMy\nLTQwZGEtOWI2Mi1jMTY1Mzc5OGM2OGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATzcXUTksWP/Z37FhNW86o7vwcpMUSBeU75ZNDeoK9htN0zX3SBkVvG95erlUpk\nOo45d8PgfxSvwcfdPW5Jlxd5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQFcyx2z5CteDKs\nFLD6USyStElIIzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIH9W\n6zwiLeRLbfonCOQF2fezjjWIfehmc+VC0KuVYp/0AiASbLElKE19LykSu7dCLYhn\nWDv/5g4B6eQ9OzLQ2nDCEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3037", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3037` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAehSdSGAELKujw6UDXHm9xb+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlMzJlNDVmLTI1NjEtNDlkOC05OWJmLWFmNTExNzZhZThkMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJjOTM3YjAtNThh\nZi00MGE3LWIzNjktMzc1NTJmOWU2OTIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMKmepZ9L/cvjW36g0pGmYVZTJBzYUygWSGjMK4Mbp9+WZhqeKT4x3DfA1Zpp\n8SmK5E9RNFQIo3ftQZbz4rcc36OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3tfcZkNP9icE8VbluTJQSGAo3AowHwYDVR0j\nBBgwFoAULuNxcbgLWoGsG8NrKi7IcZViEE4wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\ngIZGuqnHfr2fdabuc51nhTQ0zA1JhQrfC2KL2cPY3+wCIH02cwQ1fcRRHKU7CfQb\nDc8B/95GVqxH1ZEIABAyo7JJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdLl/vDL0koD9aZL6EflNAnHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTMyZTQ1Zi0yNTYxLTQ5ZDgtOTliZi1hZjUxMTc2YWU4ZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjE1yLzJTbJopoQBhh0f1XyjdPQ+VxMtVdnXHFPQWe3Kgq\nvEX2yFMNa0S8KQszTW+MD91qq17v8k+zPYQiOKcSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULuNxcbgLWoGsG8NrKi7IcZVi\nEE4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMCX2eMWkiYk5G7CWI/eEGBrZFHXWXCX1tRCia/DHsFQCIAj3EA1kEH7I\nD545WeAAoo/YONAduz6JVZvipVbohG01\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAVq9R1dWBSzO7VrXS/wF6iS3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJjOTM3YjAtNThhZi00MGE3LWIzNjktMzc1NTJmOWU2OTIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNzM3ZmY0ZS04NWU4\nLTRlYmItODJkNi0yZTdiYmYzN2NjMWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATL+o1AvB1G5IKtbhCguLHwVcIIlqWZCFjdx1UR37kxXqVgswTq91aDkyQvAlIf\nfEkWymB+WxBhU9uWpirHXcJvo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTe19xmQ0/2JwTx\nVuW5MlBIYCjcCjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCX\nING00WdtdLVK+zbZjHVBvbEYWd3YGoGk9PDqhbohLQIhAMtAUy+mSdUou1pSsUQY\nZO19DO1As8TD9S1sNLoe2tNl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3038", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3038` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAYoC60RdzhiN3b3/gbyrD8WeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjN2MwMDUxLTZhYzMtNGM3MS1iMDFjLWE4OWYzNDRjNDJlODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc3YTVjOGQtNjEy\nZi00YjE3LTgzYzAtYjcxN2ZhZDQ0MTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDp3P/+AE8uXdEkQOHQqw/AUBekPDUbHGWcS/pGeRGrqRKy7SYxBc7FZQyp8a\nf1dc1a/qwHU4EGjBg+i7/aCqz6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoO4ZDYpxkh5XCs9CPf50RRKmP6cwHwYDVR0j\nBBgwFoAUqRJwSxQ5mZIgE+7OyIGNlvW4yRowPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEArxLa/4+2BZevIWhWwv161mXU84HFnS98RQ7kOd7DRR4CIQDT\noeMkJ2Z52nrBSUHvqZlDxVxeNjbbkfcfakzT1mf+3g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdcvYQA32FQ2kwp7bjfaiMy5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzdjMDA1MS02YWMzLTRjNzEtYjAxYy1hODlmMzQ0YzQyZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBnmKgd9E61tX+O/3I/PLXBGJ3/Kn6IOyLabD0zg//Szqv\nTiiLEDrgzrLIPVq2mplnw+AWOI2Kf3heQJL5F9Vqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqRJwSxQ5mZIgE+7OyIGNlvW4\nyRowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKqr/6aj4gWhc9rmktIOhi/5Od12pg3B9ZpvLIt/EZBaAiAxaLU6YoiN\niyvW5HyOf9gXcuzvrjgzPSmgd8V+DJwG3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAY4IMD9v0zerNVLkdIeKCeEBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc3YTVjOGQtNjEyZi00YjE3LTgzYzAtYjcxN2ZhZDQ0MTdmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZTc3NjlmZS1jZGRl\nLTQ3ZWMtYWU0OC1mNGU2YjE2ZDdmMDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASFjcXVumFtZJPRz2r9vkJxNo9qlg/fCQ1Jm/2FVbvHqRXD00+bGUEbkIc6ThQQ\nWTcahw+NqBVswMDcc92lJAGBo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSg7hkNinGSHlcK\nz0I9/nRFEqY/pzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGWu\n8Na1TJ4x+r0QtqbTSjUdq1ApOgVdzDXDuZg/OQC2AiAvvyirjoQU9LFThyRYed9m\nn3J6h1d5wqNy3ta3/VJfuQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3039", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3039` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAeYe9OoMfb2C3uRFHBZBE2LWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MzRlNTZmLTViYWItNGIyYi1hNGM3LWQ5NzBhY2I1Yjk0MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDIwZTYyNzgtNjc0\nNC00MjA2LWE4MTktMDZhOTlkZmY5ZWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9VrlllbDBbneYAXJICtQ8mBDwXFrnwoo++naMjwDPjhij/vsNYvKR+Skgm+F\ndyqayo0irnNpxTps3kfGVOvATqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU38r0Nzwux7uDXe7QU0omRA9D64cwHwYDVR0j\nBBgwFoAUD5f7upyNV3AAuPlcZ33ST42qda0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiAoLO1ZIt1bdyq4HWxNNRQwrtW5pMQns09/ZFzP08w5cAIhAMar\nBMQjw/YpI/DX7rigJLB/cy5sHwhAz9MYhlBD11tA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAakC7cyohqYtaRkVtJEzeZLGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjM0ZTU2Zi01YmFiLTRiMmItYTRjNy1kOTcwYWNiNWI5NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgd+1Ju7IGiwxxFDicL31jFL/PgIhDjH1i0Bo1PcjxYdCF\nSCIIb/68Kxi1p8NNymC/X2bmrMT7bOX0n5SL5CPVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD5f7upyNV3AAuPlcZ33ST42q\nda0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJm3ZjA1xNV3cl9xmWKiPCsuQ+n/UpKYjOZ8d0HQ574bAiEA8jYWdo1d\nMTBxmNDySIRQb9PkkyVdVLdPsKsmPVkfOpQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAazesO17tzYR/AE2pRzLvs+SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDIwZTYyNzgtNjc0NC00MjA2LWE4MTktMDZhOTlkZmY5ZWM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNTEzOTIwYS02YTlm\nLTRiYjktOTE3OC0yZTRkNzExMWJkODIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASw4mfNkTOM1G4RUQDlyi91WIQiKE0vSjluVhVCjgMzY6pASF15bip99TkPTh9v\nwkDkfKGgYRrRUspd9M6pZAcvo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfyvQ3PC7Hu4Nd\n7tBTSiZED0PrhzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFQc\nOUE1nFKxlMIv0EOa1sCz7/M49cODBgQas78np8FFAiAXgdqgcE4QRuz1ihnNKrgK\njYKhGSXdJO0WpMSTOQSibA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3040", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3040` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAatLHaQDN9uBIREjLloLoDhrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2OGZkZDM4LTgwZWEtNGE4NC1hNmE1LTg5OTJiZGI3MTQ5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJmNWVhNjQtYWJm\nZi00MWVmLTg0NGMtYTFkYWJmMWEzNzJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL7TSDAcy8KxszU1DGJrIO/TFRmdHPXBoTRsAFPXfwE7cK0891GDqpUFHFvT/\npqFt+9WuxWbH4iYKCPFwq8N0waOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPybt1Fc5fOM0XMq/Mf6i3z4tWxowHwYDVR0j\nBBgwFoAU4AkJYWFQrSLODk1v6oIAcwnzGsYwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiB/D32qpQlnVuah\nzwdycOhRh8WVtZKcW9WUmSlKR/KeTQIgMMnCzHRxuwPCAiEax6kx67F8AnACEUHK\neIGHtS6iMW0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATmjAOdKSby9tGgmOo8lwVFlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjhmZGQzOC04MGVhLTRhODQtYTZhNS04OTkyYmRiNzE0OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6N2em1U7FGONIjX9XcOgZLye4q3s1g6B85kAbaYnOsmb0\n0vxZYKo8Nwvy0uChn6D6afv5c9LyBGt2HhFXXSk3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4AkJYWFQrSLODk1v6oIAcwnz\nGsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKQLC5eGsWreeCVWAclFclLCu31AKkEpy2eh2fI567oDAiEA7dYkH9wp\nIdgpuLynznnnyIWS9Yap0mrKhwFxW1JQoqc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZ4qV4Qrt5uHfQpHIYdTbV0HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJmNWVhNjQtYWJmZi00MWVmLTg0NGMtYTFkYWJmMWEzNzJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMmViZGM0NS1hZGRh\nLTQ4M2QtYWJiYy01Y2QzNmVjODExY2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARo99wR+jWEW57jS6pI6D75j3hlxxQUy15CyyDy3+iORKgIrjuYwRmT54QGx7D4\nglxi4QP2zIW2vFqKQ+tgIoE4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ/Ju3UVzl84zRc\nyr8x/qLfPi1bGjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCu\nxQ2PwpyuDlXBUuIyjBX3o+EMHttuLkoqmNgy28seIgIgbANIFlzLgyNDXwqbFPcT\n7ZS5GcpuyokcBRls7F86i4w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3041", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3041` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdFKoeqW4VkyeGA9/z91wPA+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NzcyNDg2LTY0ODAtNDUzMi1iMjRlLTRlOWM5NzNhZDBhODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI2Njc3NDYtMGNh\nMi00N2U5LTg2NTItM2U1ZjllMTQzMjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6ABQ33Z9m+2QYwRCWiKoyX4IilT1V7gx8mA2oCCoHNtXkXeeTY2srVFTuYFE\npJZdHwGVifiel32cwzC7l+X97KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFVaOsHqoZufQzRgM1tJL7cKGX0kwHwYDVR0j\nBBgwFoAUfM41Se4bDu83PUo4NuB+skhBIKMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD0+VxANsKiA94c5ZbyJOqGW4dZwKhpJr1kBF5zEhCttQIhAJbJSxe3SerK\nWFip60tiMdBmgUqrciqlthotnTSnSA7G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASk9CLXlQqnJlMhif0PNTAzWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODc3MjQ4Ni02NDgwLTQ1MzItYjI0ZS00ZTljOTczYWQwYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASa7lGpMa8NIEKyM1Qhbr+59HLn0Ix/AJAQAvyiWI/AH1uS\nX2cuKvH92bR4siWjz9KxApJ4SquIXtWsS8nAhdFxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfM41Se4bDu83PUo4NuB+skhB\nIKMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU/n1xUHjlRLnWE9M/Z71/RK0B2lxU2+eqnBIrtS2EfICIQDiY01PrIRV\n1WXv9GBFNpIvVUOpYbolINP/VsX9xMGBfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAfXQ17ynRbfqI7Jj/I+X6D3VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI2Njc3NDYtMGNhMi00N2U5LTg2NTItM2U1ZjllMTQzMjFiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZTY0MTIwYy0yYzZj\nLTQyNzItOWY2Yi02ZWI5MTA1YTkwOTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS4Nz9NtQBTL2g3/parOa4uvaHMplAV2Hoz4zrEb73hnjbaWiDhh0KeSoxvvUTL\n3XLiS5YM/iUX7VcyCY5M1u10o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVVo6weqhm59DN\nGAzW0kvtwoZfSTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFnF\nDbtBzjaS83Q+X2/ivzKpJmwxKx0uVoJCrkHTbVE+AiEAwB6OLUMGjhUDspuETy8q\neWFyTebff/99+Nh8GhtGC/Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3042", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3042` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdopa4KKVWx+ZMpga9Lcdel2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2ZmU3NDRmLTUyMDUtNGQ4My05ODAxLWRkODQ0ZjdlZWFmNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBlMTk1NjUtNjEx\nNy00NzgzLTg2MTctMjgxMjc1ODJmNDgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdaJrcuSKI76FZ/EhbimYTIuQ6y0ukin6SMdtivW62TDfMVNlCbxKx8mwi5Jv\nyMrBRR4dYp85GZQwkuecsG5QVqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmOk2/uuPbHhxx3xi15BqWmH5nGAwHwYDVR0j\nBBgwFoAUs8SRA4S8eoGtr+wLSvxeGomJkXcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCJwspRCBpo3SI0FCnKcjrfR5eqHQ4VzBB8i8B45j0elQIgNGV5jABJ0Pde\n1zlkZaqaIn4mmzjZT00dLi62qaaL/PA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdJrlNcHOYUJAnnN3gfBousaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmZlNzQ0Zi01MjA1LTRkODMtOTgwMS1kZDg0NGY3ZWVhZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQU4HJBHWMhzF9YFpforokxLb7At7rDXWaqdn96sz37sUNb\nY+NvqpSZ64Eej671F5raBH1r3QnXSz075kwm75p9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs8SRA4S8eoGtr+wLSvxeGomJ\nkXcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbnloyr8Mo13iPZ0ZRYwLrbUm6U3z/DyubXlpzug92UgCIQDY9/xRaPvV\nPm7l4NidqY+AQ1Vo8ieIi5mjFA0S33xfHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAfqPy+IbxQQ37tbtBjCDHAgjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBlMTk1NjUtNjExNy00NzgzLTg2MTctMjgxMjc1ODJmNDgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYTg2ZDMyZS1hYTk4\nLTRiODQtOTdiOS1jYmRkYmU3OTEyYjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3PVi6J2oXLaRxlw5Z53ONt8joXeaGrhRo9sHNU0liY2/NAIl7PlzrE68IJ+eH\n3Ig0zU4Jh8rTdeViAj1LNrW4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSY6Tb+649seHHH\nfGLXkGpaYfmcYDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC8\nsmSLR9UJxkcV2D25ZtQ4j9oaxQuXiaNI/m1D33z8twIhAJaBFaKvA1y+vxSOqDDO\nccX6UiJ6hNED7ETgYS9lJsKx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3043", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3043` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAbS0nvbfar6UM9cTaFU2mdVKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2YWFiYzBmLWNmNTctNGFjYi04ODBjLTFkYThhZWJmYmVmYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZmNTBmNDItMmVj\nYi00N2RmLThkZjAtZWQ1ODgxMDE1NWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzshYVRe99CJvdt5+4+zzZiK++1ANZcuXGaYTeYfIeUIq10S7TE+GJjyMbiYa\n+TuPI8ilYFIPr/39lfORtfv4v6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBcb5uM1I24FamfwqjenOJzwkfjUwHwYDVR0j\nBBgwFoAU7HnRdFoqHF1qa/jEdtj2vf1De+owNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiB+uKymWywOvLccGiPpyCJDbUu3RtkDPcacSh9K2PhkcQIgCT46sukwMIHz\nxBBkixvbXadp0EAVSKsvTP4C2A4xwTk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbiXx9+RuhaZKTlptqt3GamQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNmFhYmMwZi1jZjU3LTRhY2ItODgwYy0xZGE4YWViZmJlZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR53NLygKukXz7oFL/dpWYfVLmsICUkf5lnChJDwEth807z\n0BmC1x2sSbbyevRBAqAxcY2JTTrl4gcKwNFKzPe1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7HnRdFoqHF1qa/jEdtj2vf1D\ne+owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCsMzavTtNgf/axX1EVX3kWEaWv2qpMXHmmgudZVqTHUCIG5Pp2P15/rw\n17EwUsR5qCeTAktukmoQzQqWGhGqYPkm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAUT/eeKpnXgvtjY+n1vdVt1xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZmNTBmNDItMmVjYi00N2RmLThkZjAtZWQ1ODgxMDE1NWRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMjA1ZjE1MC1lMDEy\nLTQ0ZGMtYjgzZC1lYjI5MDk5ZmZlNWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARmBmvAcheBXNblbRmTnP7FgJh/kXriUEmTYpFQlswFDExxPwyw0NKE2AOpSRpV\nSdwCEasscWdCBW2e70WoFJixo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQFxvm4zUjbgVqZ\n/CqN6c4nPCR+NTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIHjb\nYaeCFKdn/4vRBzFi7Hal4Xi09xza/mdVahhbn4n0AiAWZm3s+imWJ85QvR7Y5wFb\n1rQcRIqzVfdm8XRjg+ieVQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3044", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3044` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXEpZmEzsofSW6MU5Z6JTFVuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwMzgxOWI0LTEzNGQtNGUzNC1hN2RiLTRjNzJiNTczYmE4MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVhNTkyYWItZTA4\nNS00YWM4LTg1ZDctODBlOTIxMzdmZGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWY6eJNFg3qAm/k7IfLqahAqwvYurh8Ep7hxXdJfQ0wD5w/g4G9NR8oXiU3zK\n9xPBHAjxPP9bCEjQaZQfeVumqaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+pNtD1kPcVRf3XuPhJJsFAQjn1owHwYDVR0j\nBBgwFoAU/RoCTnq+IPeCeuOfYmsnoI2rmk0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAqet6y//7lsIAoKK/CSBP51+EzAMn03E01DOEK8gT7\nSwIhAIt2eT2f98TaQHzROPFxdFUiGzAiaqbdSXqPZI2hcoU4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARoA1YfZ8pxy4VY9/lUNXFUWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDM4MTliNC0xMzRkLTRlMzQtYTdkYi00YzcyYjU3M2JhODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzcLwFMXOilvEo/HzAdthhG5ie7/mEjyQEb5OUmE7WqvNH\njYgGhkxugd50IlL+fxv3fRDbbAiQLSPITNZAsQiUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/RoCTnq+IPeCeuOfYmsnoI2r\nmk0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgETnbG7EoIna4gr6cD403CA5GqLNq3e+QV7zm1F7mzjACIEzn6jJA+sjt\n3VUzgYgyuiv71if7tTcXkKt5baLMB1Ds\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAYt7fWHwJrt+oPCuG1EU/LzrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVhNTkyYWItZTA4NS00YWM4LTg1ZDctODBlOTIxMzdmZGJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYzFjYzVjNi05NGQ5\nLTRiMzMtYTY2Ny02OTcwMzFlYjQ0M2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASy9uwavQgPDnZWbkMug6Kun8kQKafYNKE6cHXeddRxbE2KVWZRkoJvhsG45zwi\n/sIgIQtATtLnZN2DkUdQZpGCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT6k20PWQ9xVF/d\ne4+EkmwUBCOfWjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCa\nB1NbzmSSyleMbnn0m73XxwQQqmIAo04tEOTIktlk6QIhALFSK3uDC3lKVfmhoKRV\nGsJhQ91useWHGrBYeLJvftOW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3045", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3045` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASZEMazdb03m3sBfe0/PtgovMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MjhmZmI0LTEzOTUtNGFmZS1hNjMxLWQzZTBjZmJlNGMyNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdjNTE4ZGMtNDY4\nZi00NTI1LWE2MWYtYmFmNWRlNjg0ZWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqc8qV9L6xqzo4c6dlAAatR8TWMHmwXYyUrGybOc+397SvX7sw/4AyzEtNG2J\nEIWnHjDZ3z+36M3QR5H1owWps6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSk6pi1NYfTPGkpTVLtSHxq2K8RQwHwYDVR0j\nBBgwFoAU60Tqdnv7q90Y103LcWrG4uAbzc8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA6imaB5hOsFYBPJYaxUAEaYwrm6iSFS4sYwlUB2HW\nC9kCIAhIhIJaNWD2gPKMudBr5M1Y+UGl/5Ss9Lcl9aJMKZSx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcPz8obLDcsRp5QSay2WsNr7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTI4ZmZiNC0xMzk1LTRhZmUtYTYzMS1kM2UwY2ZiZTRjMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXJrsgNfN94Rrn4MBbzDqiHU/U79qGX8cp9kesdJbHp3YO\n0e2GWFSdqmAQIiN9oE+P9FEGpjUfkAeXnJ2dSO0ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU60Tqdnv7q90Y103LcWrG4uAb\nzc8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPoiTwEYgAJI5pgRhotbGiPvFB2yRVxfArEixoaCQVSQAiEA8wFsuVTQ\nUAnTc9xib5rFj5Y1Dq6oI5NGjw8TKC76xJE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAV1aQsVQFTPizOyMwEf6TvqEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdjNTE4ZGMtNDY4Zi00NTI1LWE2MWYtYmFmNWRlNjg0ZWI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZmE4ZDA1Mi0yMzE2\nLTQzZjMtYTk4ZS1iYzZlZGVjNjk2YTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARlHV2eT+CDFvnIL186A5erqdCFY1aixaIgeg/nmfYGp5/mR1DgN0wHL9tJHaGz\n0+o/mf1m14m10SRrF332BRDKo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKTqmLU1h9M8aS\nlNUu1IfGrYrxFDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFW5\nkF7HL5D40sjeh0NaCp6M00XOysWcis09Bqcgl7IgAiBKeHivwkKJH7Y6jm7UWmDg\naUTT839rieT32oMCTUVdCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3046", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3046` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAdGdBcVXgUswGHBTn05FuJZDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3M2IwY2M0LTVkODQtNDBiYS1hNTk1LWY4ZjFiZjY3ZjQ3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFkN2ZjYzMtNjJh\nZC00NDViLTk0NDAtNjgzZmEyYWFjODhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2h3OvNR3fxje+3EN6y+EeH64UcQDxXIXpKXJ0vHdDw3CfAOZDGf4BMPa2Hhs\n45+GJaL/TgwtcpO6Ean1C/7EpaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfU6SR8hzwJE4bflRTJg7fcBrs6cwHwYDVR0j\nBBgwFoAUiXuKPzSs+xKQNB70czM66iv4dHEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAaUDJl0yrppR5S/13McoYoLvSt09T72KfTsSYOW3vDFgIhAJP4\n8H9R63UTcmf7LZmwe6d5aVUYBvoXm4+uyVTq/Hrk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUSAcdShECfZn4JSmeBmOlApMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzNiMGNjNC01ZDg0LTQwYmEtYTU5NS1mOGYxYmY2N2Y0NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxo/y8w4d9PHeaQA/AAK8csonNZMKXnSjzEbt5ajAOlcKB\n+wgZK4oXQa4zEGkX9ceVR6tzF0tRsyynte63WDano2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiXuKPzSs+xKQNB70czM66iv4\ndHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMorxscVcL6zeieIze22sV05Ek2j6a14W6KZPJSIr+5AAiEAsebQRLgc\nnZ9pJXx2l9YP5kpT7oQGF+1yAPjFy3g1e2g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAW+Rz0w5kaqQ3FJgaNhg0GudMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFkN2ZjYzMtNjJhZC00NDViLTk0NDAtNjgzZmEyYWFjODhlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NzJhNjdjMS05M2E1\nLTQ2NGEtYTMzYy0xYmIwYWFlYzg0M2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQW1Vou6LbsFX4aHwum+Y6SHKPBJcUAPLlNbScuCqUBvdXlaAulUyA4NKQDx0Ek\nC73BCuj+CVXcRjpHpOcRe/DTo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9TpJHyHPAkTht\n+VFMmDt9wGuzpzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCj\nk18dJTNBTb1/QEvOUyhNOyx/K+9Cv0x/4eb+ocVCMAIgeTIJlC5recmYduQLkFjn\nXuKtSovjx93/G1rUwCYMktw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3047", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3047` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAaLt0vL3FQMRVROQmbNr8n5hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwYzMwOGU5LTgxZDAtNDM5Yy1hMWNlLTk1NDY2NzkzOTNkYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg0ODNlYjUtODJl\nYi00MzAzLWFiNzItYTUzMjZiMGE3YzkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoeY7KWSc4xZI/Vz4LatPDnNogaZOgrru5DyzTSMiesSoX2rwa50JOtCfWCPn\nkK4D4GpjKs+PZnIvfZkmBjrzK6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNqFZsFLfNMB/D2F7s873fRcxI64wHwYDVR0j\nBBgwFoAU2W69631IupSrBq0plH5H9lzU9FEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAxnkXkMjFkOGhf34qPNhIurzAoHr9wOdH\n5qwZ88HdGpsCIEq4NHXs8ig2GxBtUkyYP1Xz8SaTOMI0GPnLLqEGR+ls\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATjKaEqrGFbveIXQHbdk4Im4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGMzMDhlOS04MWQwLTQzOWMtYTFjZS05NTQ2Njc5MzkzZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0QR2QnsIVfq5CNrUifUvedRM8e5z8Z1BhFUmzo0Cbt+1S\nB3gDJQ8QHEmaRRlXD0JBFlSVJDd9q3lH9iXQbr5mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2W69631IupSrBq0plH5H9lzU\n9FEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRkldSrhcfiw1Xi6xAm90A+czGb4HXhFa39n4ZyfrqyQCIBeImmu6eoyv\n8Tf2xg3ByCOMfIxcIiTg4QBP6jcxsrGe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISATNWpto6TzM/WDyfszJrHd82MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg0ODNlYjUtODJlYi00MzAzLWFiNzItYTUzMjZiMGE3YzkyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MzYxMDg5ZC0xMmU5\nLTRhYTUtOGY5Ny1kMDU2MDdiZTVkMGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASdDPfcQMXlWsfs1isZyXHHxAdJVv/2FZCxAROsdPAgmR1h+R3UIvvs1yIHqixL\nDld8s46Df/uKokhMwFGuUxvVo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ2oVmwUt80wH8P\nYXuzzvd9FzEjrjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCX\nBlb4sJaGqcHiKyholkUxvGl0ESUKUmZNPsUC54s5zwIge65+f4GQNvCnrglPKwFk\n8ZxU15j6gGYd9/SLGMohMCc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3048", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3048` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdSYmN9OBgtBSuGoCHoJM4gyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjMDdlZWI1LWVhZDAtNGNmMC1iYTU1LTRmZmU4YTcxODMzMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFjNDk2NTQtOWUy\nNS00NTIzLThiYjEtZGQ4Yjc2NjdiNGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE09Z3CVawalZJ8Z5lCzPli0IWMmPSw1g1h174NTRBFKhWd+4x6x7E91bj4cNc\n7v4KZx8Tt3QUiNacuBVWjysVOKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjDkW63uTOdGfG0W80rR9MQjx7bYwHwYDVR0j\nBBgwFoAUdQbQPP5lhr3odJpHUtfADkY3Ju4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBjAR9u8aFNqya2H5EYOTh6jGNrthlObT+J\nicaIO6YXlAIhAJWJzXmR9krc2EMNmE8YiIYxZYqtwM4sOw/QUZ2kw85K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAew0SGDeFQIJ7/qetdEo4jKfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzA3ZWViNS1lYWQwLTRjZjAtYmE1NS00ZmZlOGE3MTgzMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCwz4jwpLrIkz793up8Wn/LwP9M2Knw/3W+fc1Evssqfqh\nByCMnwo3y16gjn3hHArqriJ1iW6t25emscsr2fz7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdQbQPP5lhr3odJpHUtfADkY3\nJu4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdv53AOTDXsbdxL+hS9zZoD+94535zDbQzH/HVyLTq78CIBr7nTuiHvJK\nTLUXHaTr1FwHVHJwBvMjsPUjaHwfG4QT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAcE1CjOmDynlRE10DmSwIEIqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFjNDk2NTQtOWUyNS00NTIzLThiYjEtZGQ4Yjc2NjdiNGYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZmNmMGRlMi1mN2I5\nLTQ2ZDEtYWJkMy05NmJiOWJlMTk4ZTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARTwrV3qAqs6nD3y/GmPZNfw4aX18G1Y5OL0K1q8N4v3IClBbh4CgXmORs1NOwa\nwRmX1GsKWnIVxsX1cVexqPC+o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMORbre5M50Z8b\nRbzStH0xCPHttjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCR\n+BrLvZGqPLp1bSyGbncrLFC+ZNRD1JQh0JpM2/xXUwIhAJjS7CfRqI8T7YjN/h3H\nXW2hGJ2+G0nHwcBCovSLMcBj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3049", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3049` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATGXBLXo2sVCsRwyerk+ZVScMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlYjFkODA3LTY4YTMtNDkxZS05ZTNmLWFiMDAyZTdkZGM5MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYwYWE4M2QtM2Iy\nOC00NzAwLWI4MTgtNTU3ZmZmNDRmNDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoHSCwGDNIF0t9Bd+SO3f0BFJUl10VB6pAswQYWhcTrZbkMV3z1FHcJlmwdl6\nh5IsZ198PEimqnCrxW1ofF6G8qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMmgkp0yasgyx9nnP/C1s6y15ScYwHwYDVR0j\nBBgwFoAUtakh4cFwKNot8wByqFo7TmqsBdcwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBywyF73TJuCLc3\n8Dh8GS3wgojDaeeZ8vQtFNheWIbWTQIhAPbE6WEXVY3H1ulqu8WK1AtkH1PbZWXD\nMYiTM/HZmoK4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAftvEV7EhnemPNKNNtBybXJNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWIxZDgwNy02OGEzLTQ5MWUtOWUzZi1hYjAwMmU3ZGRjOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAqUHo2N87OkngTjswjq1v0E2q/44tfYr+/F/57RR0C/xB\nGHjVl3WZ5aCLm3DfIm7DsQr6OGXQ1kFQxg+OShlTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtakh4cFwKNot8wByqFo7Tmqs\nBdcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLUCc+Wl6tHyHK5rgo/cAZIXUSXqUL+4cjvUT13cJaE0CIC5VhFJHujCv\nOnkFF2jEvSXraU0l49/lWMS4s+g2rTPN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAWNgBW3T+U+Qn51+/cYQGUS6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYwYWE4M2QtM2IyOC00NzAwLWI4MTgtNTU3ZmZmNDRmNDRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZDhhMGZhMi03NGJj\nLTQ2YzktOWNkZS01OGZmMmRlNWYxMjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQMdZsiMWQuEbpuQ/0WBlDBvfyQw33ujo4rcXwpvpFDNqeOjiQOfX+gitsuEqZs\nKPuKas5rRwty/JXP8rAD2M5Eo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQyaCSnTJqyDLH2\nec/8LWzrLXlJxjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDg\nO0wuwCfRzzJNonQ52NgzU0GWYKUWwa4ssUolvcEohAIgGWcjvZwnjxJ2ZYVGYYFF\nXRVp6FBsCeFtsCcOaiKeo2Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3050", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3050` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAb4J2E5VAAkAD9gFZWFZJW1jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkMDczOGVjLTliOTktNDA0NS05Zjg1LTdlYTIzMDA0ZDNiMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAwNjZhMDQtODJm\nNS00NmM2LWI1YjgtMTI0NjkxZDA1MzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENeCWW8nuMoQq7ifeFDQWk76Wr1gY2rUr86ABS4vhlN6/2zCCfxGmVbCCyhg5\nppSnd3NKeFE/8eKNh/enbALkHaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVDZIEtrhmdUR3CIlYrAVWLSggy8wHwYDVR0j\nBBgwFoAUt3JrCypMmMYZXKOwSPqJotHXlrcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC1tdSb6o/etSdxegLMe9YXNzY0s5vPLkBxL4Y0Cedm3wIgNUDQcs0ct7SI\nINYmnr0akuuBEhxJu6MPu3oKYlDAUJs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARf0HXoXsxolttyNYWJWS7dXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDA3MzhlYy05Yjk5LTQwNDUtOWY4NS03ZWEyMzAwNGQzYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJvUqdLBQlJCQNGDzV4MjABwQ83/KM/thoXD71jJfi7nmA\nmOfUvCh/mh3Z/L9V1N5CiiPabVSjvtLst6rD3iuHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt3JrCypMmMYZXKOwSPqJotHX\nlrcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgabAoAl2wDuxfSQmxhE7wnECDNo1uiL8uBwEsjpQDG44CIQD7UA5ACEbH\nrb4fWbktXUtXsVcoM2z5Jb6v0PG6IcfzMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYmCHce9cqXzzL1HX6Zb5iVzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAwNjZhMDQtODJmNS00NmM2LWI1YjgtMTI0NjkxZDA1MzMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YmZjNWVhYy1hODFj\nLTRkNmMtODc1Ny1hMWM4YjA5YjdmNDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASUMfeF7F0mDosAmMhwa6HVkx/b+PmC7UcpXp15smSTSpjkjPppyJchqIEOpiq+\nLztOHpSU/rBedtzZa9unJJqHo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUNkgS2uGZ1RHc\nIiVisBVYtKCDLzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCN\nELWldQHcMZZl8If1MCHUP8+ztbxhNTZC+SZK7jpTxAIgPLSvb8as6feZ1NiTAvea\nYiPI4aT5n2PlgLOVubVoDTg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3051", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3051` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaU7ArvGy//SLlskl4c25Q2eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2YjM4ZDUxLWMwMTEtNDBiNC1iY2M5LTQ1ZDc5MWIzOGMyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRmMjc3YjMtODYx\nYS00M2FhLTg2ZTAtMDc3M2MzNzk2ZDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzk6plhGuVItz9jyhWesTYofDjp7eHD7pnULWwR7WOntvQopVeTcjoZmz/w5R\nHC9PodtREt0+vIjG61nVhRdgb6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL0r+HNigimrqX4TB72JEtKi8WLEwHwYDVR0j\nBBgwFoAUYu+z6yX6XKVGtu3K9XJJv2jJcOkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCpnRp8HTlXmQJAA5veUnNMpdtE4pErD9c9iA3GdCF+pgIgf6lDCiw+7DJk\n8Cd3ViSaCfLCH0YWsCp6QCYSoxFRJv8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc80EgviMrln1Va1DMHDk6MfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmIzOGQ1MS1jMDExLTQwYjQtYmNjOS00NWQ3OTFiMzhjMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+y35qXYE0UVgwN4zJxL01op0aqcpiTtdx1tRPuh3QJIwF\nK5wtzLpVnqiiFZeqzPWQ+xD6C67tfeUcZq5Gjl7jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYu+z6yX6XKVGtu3K9XJJv2jJ\ncOkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMK5Pb/lu6qBOf/Eed9miRUxHP0OUMOC84q+E1+7CPq4AiBaCsM71mxb\nkGLm3gmtEWmRikRNzPFvXUFDc2ETiPw/kQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAS73JfNb+/QFOF1lTNYTQkTzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRmMjc3YjMtODYxYS00M2FhLTg2ZTAtMDc3M2MzNzk2ZDA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MGUyYjJjYy03NmVj\nLTQ0ZjYtYTRhMy1jZTE2ODVhNGZhZjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARPYC6680gv2wxliizLic04JJezQOkaBjqjNUHSZGhwSzS0Bc9tJcoXVfnptMnF\n8c3dkknvMp7Izg7+tr4LQPtlo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQvSv4c2KCKaupf\nhMHvYkS0qLxYsTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD9\nFxrJeiJlwzXAWlHpHU8/HzGi+Tto0AcUITZRMKsNzQIgOSQq3z7aFCVANMYoJaDz\nai+opKcASqfP9uv0FjduxI4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3052", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3052` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASMU+B6PsKhBLP1rgoOGoet+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzNTU0OTQzLWU0Y2UtNGI4Yi1iZGVlLTE0NDUwODJmNzUwNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdiMjc4MjItNjUy\nYy00YzZiLWI0NjEtNjM2NTA3YWIxMjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzDqgt6VA9Xd/JKZgA3wWt936B5AWOta5pLr2Ba2a4MjH7VFEWWEdJccRR7Mx\nR/JKCQnrERUVA/EXfcT/wdYHzKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUemigrktB+/SXb2K5fe8hA9NbEL8wHwYDVR0j\nBBgwFoAUSMNP22z2Z3smnL5CRMYon9r4licwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAFC1wbRM8iZ8PXQAClVIFyCkpVp5/XrfyOqs7jii+v3gIhAJr/VSDm3EaQ\nNS5zk1QTFZ8MFVkTbPeui+hFVIjuOIEN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATvEuENZxPJ963POfcy5YMhQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzU1NDk0My1lNGNlLTRiOGItYmRlZS0xNDQ1MDgyZjc1MDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsF9V//4KOpBIPVvqBkxdKNmTs90WlnsK0MvvZNFoNA6Lf\n+mqCQ5264OvUQ8CttL1Tbt/7KNxEk7qffiKa10/8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSMNP22z2Z3smnL5CRMYon9r4\nlicwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK+TzD7UyaXp2/azy0vBENkNNtZudGQhwMuroIwG7PJJAiEAyfBopIHD\nfPo5/zMpLTIkg73wiuSwUZ5hPd6jty1OG78=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAUOREwMdCzYWc8hQDq/kIlbfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdiMjc4MjItNjUyYy00YzZiLWI0NjEtNjM2NTA3YWIxMjc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OTQyMzUzNi1kM2Rk\nLTRiNGItYTYxMC1iY2VlMmNhNzU0ZTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATsCSKDPjTRMjwT1wh54ZWVlD0YCIuXkauVrTsfGhwSVGPFOA1COt+7avJGgdOf\nsqVWnme3+4eGSjibvTewJUSGo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6aKCuS0H79Jdv\nYrl97yED01sQvzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAKd\nmLN3ArVEKJukOUH8fiu2wbu9MMM93WNWorrWujlzAiAbdrhAIQeyEJ+Fes5ohF/U\niu7YY9u7EE9fBW5dPSSilA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3053", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3053` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAY14nREtTZ1GEKUVb7bEyx5yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2MGM3NjA3LTBkZGMtNDFhNy05ZTk3LTQ4ODBiMDY4OTkzZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODM1ODVhZTctN2Jk\nOC00YzBhLTkzY2MtYjA2ZGNkYzIxZDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyI6Y0ZFxBEM2bi1lMswTkwD4Ov3eeNExhPr1apvs845da8eTzbDVo9jc6qkh\n5G6MZvoE1A2HNvTHtpCA7D8Th6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMOaeS7/enVUooGAzz/ogz+O2hDMwHwYDVR0j\nBBgwFoAUW1QIRt/MePTHu7Xt57ZylpT+rzMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA3QpYgj46EhxLoyA9C+lblM6FYQHriRjt6Y39QB5b\nDz8CIQC4UeE65TR58+FLglsHm1vg16llq0GYkXfQmPziUddmSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb97j0KXN1UP356E6IPETG9LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjBjNzYwNy0wZGRjLTQxYTctOWU5Ny00ODgwYjA2ODk5M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKIM5DrMsv2spPCIK0zgsXnk3d4upVm6YYTUwAgYhjFkE5\n20Kn8JovI6zJPfUrXYwhETdwAnTPvk4AC7nY2F2Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW1QIRt/MePTHu7Xt57ZylpT+\nrzMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVN/DpqiR7H0x2oEy+QDOLRIQN7d3V7+xzuTKfQKWNiICIQDpts4dEA//\n3BsqbO68k5BbQWv29oMEdaZElF3081LKSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAStIm7PI1NlpyqoXaTAPYsu6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODM1ODVhZTctN2JkOC00YzBhLTkzY2MtYjA2ZGNkYzIxZDE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYzk1NjAxMy05Y2M1\nLTQ1YjUtOTY4YS01MWIxNmNjZWIwNjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATaAVn0VVC9kDVpqg+MeOE15pSxrEMj+4/Ten/BQAmHBGqRRGUqGbbjnLYqxpSH\nEUzWsTzR4kHklUaHkduaoeXqo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQw5p5Lv96dVSig\nYDPP+iDP47aEMzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAxp\nPKxmjDX+3Gkj/MWaglu/VSJDMCuQOMrgDtXbu6C+AiAPWIxXnJ9b3VccT55KHel0\nTxvaIGYmiFpZeowl8Yovjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3054", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3054` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAQphRPRdBi08FIHVziT/zggGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzNDkwZjI3LTBmOGEtNDgxMi04NWY2LTliMDg0YmQ4NTY4ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZiMjdjYzAtYmI2\nMi00MmZjLTk3MzEtZWRlMGM1NTFlZjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECx4VNSsExG6keJ3YntBv0/jjJoQLGq/g/ee2sSzH81CRyhofLZTQ5ygn0tyT\nC8+isPQmsGbLnjAEomD0BnjWcaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE11Jwh62hL/RgDVFpW0sVCzdIiIwHwYDVR0j\nBBgwFoAUzdup6ZbGbiAsoQL0+80Bf0lwOokwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAr15QwGthig7M/JvsF/vYG4R8V+644/p4oyw0csck\nMQgCIQD9aLS4saXhRXB1T+/976sElI7TpyDpCIgRM0FPUr3tcw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfp30wSM+SZkWTbLkhL8xPwZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzQ5MGYyNy0wZjhhLTQ4MTItODVmNi05YjA4NGJkODU2ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ26p9AfJO5O2qS+XFfihpAq06xm+GQSSNqQ4Y2nFJ38eeF\nlvXcIypCYXG5ExUD70VCgQnTnFbNXCKkwT731ABBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzdup6ZbGbiAsoQL0+80Bf0lw\nOokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgI39At+bML7xi+8oYVIESe/9BZMp6tFRMS+B8sx2BatQCIQDUmkThrJCs\nHxNeUDJNsJq4noDJxkmZpFvY4DZs7CnJpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAd5t9kVimeLqKXUc+GKhT8P2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZiMjdjYzAtYmI2Mi00MmZjLTk3MzEtZWRlMGM1NTFlZjRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZDEwZWQ4Ni1iYmE5\nLTQ0NTYtODgwOC1mYThhMGRkZGMwMzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQheP4E2tQsR4giuVxNJ8hqmOqK8749qBHU6pYR7rsIQ2GUrwj6i/prqMGqbs8T\nu+a55NVvrPYBge4eVorexk7Qo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQTXUnCHraEv9GA\nNUWlbSxULN0iIjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGQO\nWyh5exQi4iWXVHD1ukYCINrKfK5wCul7Ht1Qoe+eAiEAtOGgxlvERw+W1Kuj9s29\nf77+5URhBW1+GOkcy/357oQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3055", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3055` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYYe3agx9JCV7SB2YAybVFQGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3MzA3MWJjLTUwMGItNGNkMC1hZDYzLWRiYzRhZmE2MTU3ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBiNjBlYmEtMGM1\nNy00M2E3LWJhNzYtZTVjZmQzOGY4N2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/EqzhdRsS0WRTdnqiqruEY7dgJQfdqBvwEWxvGKFQmMGHRbieG1VV4JgNELE\n5iMsT8G8sVDFE1WfrTayEhevWqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZZ7vEJ5xdrZEt7LfXdWiUW8o6RgwHwYDVR0j\nBBgwFoAUU+2mxwZy4cL6jmnIK73sf+9J2gwwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAlk6th7TWMfgbG38U9swhe6f9uyiI7bmUTrNz6pkNT7UCICgS\nD2oSA2l4bHm8QKrc+tTMG/1oipelgGe4fW+lgq1p\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXTJ/dwFtnLzJBkDfQ4ZUZEjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzMwNzFiYy01MDBiLTRjZDAtYWQ2My1kYmM0YWZhNjE1N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2V+vTFXpUqyNnggmB8aqF/ZHgXwO0iff5aRfosTDzSstE\noFEVwDaR0rglKsrsbcuQgkwZS0xmxDgSc37Z/10fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU+2mxwZy4cL6jmnIK73sf+9J\n2gwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMf6A2nDGh88oYeeopOmkWsRudk0X+hcQRXVD8MoOWAvAiBGqJlOzt9R\n1saYHk8wNDSjcm+jcmNGIbRWBwNkKxqK2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAamv8P+RUbiWtTUIL6VSiCHCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBiNjBlYmEtMGM1Ny00M2E3LWJhNzYtZTVjZmQzOGY4N2Q3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OTc2ZTA4MS1lN2Uw\nLTQyMTctODg2MS0yZDE1ZWQyZjJjMGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATFSzTse2ie9bTwR3KQ69gmzIOfGvOn9sVRTO83tsZVrAz0dtsFFBEbdncGqTFp\nYFfIge8sLGjTkHA6Zms6ZLCjo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRlnu8QnnF2tkS3\nst9d1aJRbyjpGDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC3\nrku+QPgnzMvtt/byuNmmGqIMjsboHYdXlOPbZal06QIhAODFkr6Snyg/2wZ8GyEa\noYLh+0Q5et8Q6G9cMZ+gWs4Z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3056", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3056` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAfQPx+8qUe9kP3LaPAXFbJLGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5OTA0OTg1LWFiMjItNDgxMS1iZDU3LTNkNWJiYWEzZThkZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDM5YjhmM2ItNmNl\nZC00YTY0LTgxM2ItMjQwMTg1NDQzYzc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzRJzkBtPuLPWkBthqI1GVqLtP5EIVpFdRz2sNwslj4iOXbX0afDNZ5faZgGv\nFCZy/e5LWaYQdmD5mSMeXLpqjqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyBJsOZnIP8Aa5GOlhymzGIu8Ec4wHwYDVR0j\nBBgwFoAUNhtkkdqgCTDWs80+nUm/lbTXieQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAl0eH+Ko+hGAzUk57SRtne/2om/oEB1OF/\nbbSkoNKf/wIhAJq8dhoEjIZnlSnVj/MTL4s6TJLnmY/k7ImDl7ihIaBE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYCpVSrx6PgGq0LM8mKMvZRnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTkwNDk4NS1hYjIyLTQ4MTEtYmQ1Ny0zZDViYmFhM2U4ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR63LqTAOWxssIBrjsO9qXa2IRhjOfLE1Uf4xt7UvQVJEJ0\nmwecH9izi5QPVERlCK9pDVvfi4SrqB8Sj2cB0dwio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNhtkkdqgCTDWs80+nUm/lbTX\nieQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT5hNh2AaDUmPBUl8H9IrIGljUrMnK/WVcwj0UCk+u5YCIDZh1U+JO9ow\ntvVevRxEROovzPSGNWPhZpFLduGufFfB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAR5N+E0qmqeamnOyDtU0r7fDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDM5YjhmM2ItNmNlZC00YTY0LTgxM2ItMjQwMTg1NDQzYzc5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNDNmNTIxMS1iMjM2\nLTQ2MGEtYmRmOS1mOWZmZTQ4NGY5MzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR1dtVESwRnMT3wMe5gxmDwyLNmhz7UQClJLv5datgVVg+kk8T7LuOqS5ptVg/P\nA3AZShhq7M4EWdCjKSKw2Xqto2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIEmw5mcg/wBrk\nY6WHKbMYi7wRzjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC7\nzoArMXdlQ5AX9iWHoLrnvkfBVfJvYNMe2rBXLKIFoAIhAINitHTOjifDAe+ZKOcB\n5rKtoXqZ+grfUWLxb+3cdTJn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3057", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3057` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISATZNyfg410IzCmIi9fYwbi78MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2ZDhmNDc3LTBkYTUtNGEwMi1iMjQ4LTE3MTI0YjMzNmI3YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFhZDU0ODgtZTY2\nMi00NjJiLWFkNDktODg3NDgwNDJkMTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG4a43Afre43/A1jUjwRYRoLW+xy8OO+/igowGavl7RZRdcN3SkjPhSXmmvKi\nAaMek7Gzkdz4TRU7TQm6LnN7oKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSTxwBgWOr+aOijPOjENi3CzOfHMwHwYDVR0j\nBBgwFoAUWjhyOdVu7He3ZvHUtjYmOiPWNOYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAqYnR7W4i4oYJc3MD2a4sffoNdlBp2r9t\n6dYI5YVykloCIE2UIJHlcb1nyRgYfS3Cnr5+uowHxEkIr9JnKCvn+Q9U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUOxQpePXesJgKRbWcka8alfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNmQ4ZjQ3Ny0wZGE1LTRhMDItYjI0OC0xNzEyNGIzMzZiN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDXfIbq1EESpDHRyRYLWJCqIZ6R8UH73O59PnSv4VSs5SE\nRKFeMaBC+5fPjfmntoxrunEGRmta3jEPSQA6wwOFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWjhyOdVu7He3ZvHUtjYmOiPW\nNOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL3CzsmCbWNtJS3+rUHbFGvnxMR+4GL/ewBg8i0Ua7DZAiEAmhGH8MV5\nbTBPUDqElIF5saRHw5OyoHuCg8Pf1JbTc3k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAT71gMvixuDQ0pKztHD9dZABMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFhZDU0ODgtZTY2Mi00NjJiLWFkNDktODg3NDgwNDJkMTY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhOTFiMzk1Ni00NTE1\nLTQyNjktYjg4Mi1lMWE5ODc2OWU5MjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATeacTIkrTVhxq09CU1neelHBT0OOfhwp3XenfCDtaHjRnRPV1AanCp8+zTsIof\nL5fcOv9UTyZAUOUm9pCRsvgjo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJPHAGBY6v5o6K\nM86MQ2LcLM58czAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIHRh\n0OKvXHXfk546htFbbU9/wsyqqszlWspCFAnAXpXXAiAMpR1XMlU38BTWVJ0RSRrj\nw5otakq5BisxKibTx/C6rA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3058", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3058` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAZ1Pp+sApCCdcre2OzHOnUBBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1MzkzMmNlLWRlZjktNGEwNS04MTA1LWYzOTcyMjgxNGYxZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzViNDRlNTctMzU3\nMi00MTk1LTljMjYtOTZhNWNkZmY0ZDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw3a+JXvOXEWbUYeyhbTFHlbeT+5l2Iak99o7t6HByw01kIBrauVQTMtXV/kS\nb4+fLWUGlUt2DIEc/CbM1GJBIaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuz2H2Rt1/Cwezv/21D/CWgrK+K0wHwYDVR0j\nBBgwFoAUG3w4Ni9J/ZjSNu+TdglVT8a3XcQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBVpxI1tCDvH+Mhfe9PV3Z8HNVlI\nQls0M4JpTEnyfysRAiEAqxE8oMD37Z8k6eNGiTR4aXnkH4sq4vewwgYuOqMTQAY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARV7+nptCiVjapXeJoss0ggCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTM5MzJjZS1kZWY5LTRhMDUtODEwNS1mMzk3MjI4MTRmMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYAJc+WBkL6CPscSqeUqyGi/ZRwy35xxrA+d6jYku/g8a6\nJU5OMK6ILxCmK7E/ENL1vA0fIrbwDbK1S2xAWM1Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG3w4Ni9J/ZjSNu+TdglVT8a3\nXcQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdeEXMtNXJ2d7H2uWz4QokaiH78WD41bk7Ww0Lgjv7eoCIGOREmQQXzUS\n3prezl+GUw5wupDjOnZcUFd8wttPgV9S\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISARYxOCdxGBEDqcEpIcqlppmHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzViNDRlNTctMzU3Mi00MTk1LTljMjYtOTZhNWNkZmY0ZDQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMjE0NjNkNC0wYzQw\nLTQwNmQtOTg2MS0yYjRjMzJiYTdlZDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARP4FMGL4ExmbX2h9+RO2pML5DK1MwTGvAa8fGL1sUz2a9f8tF+QosALUDFLstM\n0Iigm5bAoMqsVadIhf4eo1IPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7PYfZG3X8LB7O\n//bUP8JaCsr4rTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCX\nJHnpu2ivoREpFMpZN6PwpLZna/KG/AWfIX8ftHESlAIgSP5gUfNlNsdX0hVvEdr6\nICPG7W104qn9L7yXtuQty/4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3059", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3059` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAbEnTELnWcr/3nKSnk6z3+xLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjMDk3NDA1LTQ3ZTUtNGYzNy05YjE4LTU1MTIyNjY1ZTgxMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBkOTRmMjQtMzUx\nNC00ODUzLWI4NWMtMDhjZjcyMzE1ODdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8VB70nPs7p3NF4ZrqGtKCpDE4lh/N8siuGTxlmvmUpRn8ghKoU4hxRIsf042\n8uXB01KU7NQx9m3BamJwVFVYAaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy7bJs3vjCbOksW7Jp1LD/E/VYtcwHwYDVR0j\nBBgwFoAUjXBdfF/5BLZ0aY5JRBYXLHLC9xQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAN7CrLsU\n56AmtncEye6E/sf5LSGO8kaKbzyhuRSuK9yWAiADvBe0fbFAnGOE9MF3AVdDcQn2\n7evIKaj8BhUjPUKI0Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXVuPiLcADxc1yR+A9uoHs0PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzA5NzQwNS00N2U1LTRmMzctOWIxOC01NTEyMjY2NWU4MTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHmwN02jk/LX0aPXD6IX9wygZ5Tj5LhcGEmpntnATGVNUQ\nCr9JmSjm6gc4iBVQ41zrRnUa0kgnmpphTVKB8m9co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjXBdfF/5BLZ0aY5JRBYXLHLC\n9xQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXc9rmv2kNmZkdQXFEsdUhakCs1b88hf5GHUB6jSEkGMCIHzEFECrRUk/\n4xiO3l9ICPj5ZjgYfzYisnd61P8tOwC6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAeWFVFE4UwXufLyHbz0BBNMjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBkOTRmMjQtMzUxNC00ODUzLWI4NWMtMDhjZjcyMzE1ODdmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MzliNDAzMi05ZGJk\nLTQ1NTMtOGIzNy0xMDU0NWIxOTdhMTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATnZ651B5Mz4BGgvlDOZBSf3p5OSaZr2VtNVMwC3KYd6JP/epVYoAijwcitJbNK\n9YkT/OMRJk7uooQ+IE87IyB3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTLtsmze+MJs6Sx\nbsmnUsP8T9Vi1zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCID6n\ngkxq8twDNVkCuiekScczFiH95AR2qZA/mxWF8e+4AiEAhSs89Vu4396mfBbfn7rd\nfX0Dg0zZfgtFDIi9/+EWMw8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3060", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3060` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAYU8jzgn6lb62aLhJ8Gtdi7oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkODMxZDllLWU0ZjEtNDhkOS05MjJlLWQwNmNiYmFkZTRkODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmViYzg3NjgtZmE3\nMC00YjRmLTgzYTQtYzkxNmE1MDljNzgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh2mzh2b2NVTu2f/1mh0AycZa/HwMNDwsdexIUubRpuF95jLroy+hDULB5iAB\nifcyzRYUoeedDr6ESU9QI8l3Y6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiNY0TxvWuYq9p0Bd2ecYXPnyNoUwHwYDVR0j\nBBgwFoAUoND8jqKLH/i3V+E7aXY+5xx+8O0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIx/R15F\nvsFNHLOxJNBPAn7uvQoPWoPaSKfEAtm2VaI1AiAlfl39b1jNvruFG56dml5oI6IA\npvJaaM5LhZoU+w9Rng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWSA9blWZFHOrMxNjHWflhjTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDgzMWQ5ZS1lNGYxLTQ4ZDktOTIyZS1kMDZjYmJhZGU0ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+qHpVmuBZdMCHwSksYAq3ztjiFYZBzCsd3ZO4P0igHfHY\nLNgarSZuigIQzlzjSfXI6ntTGCjBpjd/Es9VcYKvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoND8jqKLH/i3V+E7aXY+5xx+\n8O0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMgttNuNzib9O5FkEmpTG42ROS7mdu4iTfOOASg8SkXhAiAdZ/waKNTw\neN6vp4WnYaV7y/rTrl+kfegNrYXKLYCV0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAeTiAwueY4jhqJ/Hl98mND/MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmViYzg3NjgtZmE3MC00YjRmLTgzYTQtYzkxNmE1MDljNzgyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZTZjZGU2ZC1lNjAy\nLTRhNTQtOWRmOS05ODZlMTU0MTExMTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQVjrjXIsQp3MbMJw8LAUOjDXM1EhYGIC1X8eOvLdvjM5TBgf4GwHvR+ukEkv5f\nl/XwMpXufYxsVYIAT4W2IXiNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSI1jRPG9a5ir2n\nQF3Z5xhc+fI2hTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCID8K\n42NktcaQsy8rymEhUS1r4woJ5WIarSJNLn64KjlvAiEA3GIyAwtTqFuE2CLGkanz\nsrEF1+R0Atakjhcobtu0qkI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3061", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3061` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISASHd1xTFekf+CdTDcaVTXoBLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiMjEzNWM1LTA5ZDgtNDhhZS1hOWU0LWVjMTE5Y2UwODk0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU4OThiYzUtZTcz\nNC00ZTgzLTk4NWItOWVlN2M0YzYzNzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYP4yMCsMNslrxA6vuqqL6eDc9ELQ0yPXJbSCdxufCXHng6TIiooBSlq5irNY\nFGb1Na1bjBH/xveILg2bVkfGnaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOsuO6ZyUVnh+Ip0IB94KVVlhJZwwHwYDVR0j\nBBgwFoAUKi9p758Is97ZJ0ANNR/HrbrdfygwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHBKK1ND\ngyPHCeS7eXZf2IIXphfpDrCvGv0WzGXdVg+MAiBDTHYMz/QZv2EjcQxspVxQ14i+\nHwHVvq3Fx/1MC6oirA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAboabsegI1Mq9fG9NTkONZpJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjIxMzVjNS0wOWQ4LTQ4YWUtYTllNC1lYzExOWNlMDg5NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHRGkd9aA6fAx9Uqt4d/b3aLGkAFt+cFlLdrxKK66K33K9\nU+3BPy9HANa55JtjJw376u0LF5JxzgVNVVWfdCGro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKi9p758Is97ZJ0ANNR/Hrbrd\nfygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMlPvSlsd4zUfJbx0X79vK84ybqQvhmUwk5oP7cSy78ECIFmJrsowly25\nHPXCtuJqTBPOFercWMPDANp+Qm7gPSA/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAeOZgrwT1WoCIZrj84xDogrTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU4OThiYzUtZTczNC00ZTgzLTk4NWItOWVlN2M0YzYzNzQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYjkyZDUyNC1mY2Ji\nLTQyNTMtOWQ4NS00ZmExNGVjMDU4MDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARfqSU9EQHptvNRbC54ho/UXPe6UFxv5wZgh+CQp3bdmatV8qZN32kV9t0QBwo3\nFeV1ryb74dnvLNF1SpyR00Jco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ6y47pnJRWeH4i\nnQgH3gpVWWElnDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBJo\nyqUOIpBg+Sv+z9Fq2oOulFbXDYZoGSrYvk7So6muAiEA3Mb7NGsYAS/4pR8iDi+j\nCU3dDu8/vZ57LOUEJnrFplk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3062", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3062` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUIVSwhOrRgEXnMuvvFJy5AvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3Mzg1NjliLTUyYzMtNGQ2ZS04NTE2LTNhZjMxYzU1ZjY0NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM0YWE2NjQtZWU0\nMS00YzZmLWJlMWYtNTc4NmYxOGE1MTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHoL4+19GTrXnE5NHP1H6+rKirf7A6zIe1H3RZ43gS0+5aGnet33yRQPrJHdJ\nBfHlY/+hlSHsmCsHAQ+DKIn17qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVHCfaXb5tP23rc5aHRxkO3VbssIwHwYDVR0j\nBBgwFoAUS9DGhKrU7DJKuWvJiI3aw9qNndMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCZ8LjTOdP2hVnGjcDROnJ72TCtTsCnFZECYxvA+erd+gIgNKJZ7rfr\nKTKzpm3TnBNqgIcg0hk402XbxaJfV5cVnXE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR+flhIn0Fbumec2BJNic/lBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzM4NTY5Yi01MmMzLTRkNmUtODUxNi0zYWYzMWM1NWY2NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwVExajBsrVeEW51FLGPA0O+pSjEU8ihkgkaGJSt8cWnoN\nQQc2/rxnbFQlsRKfn/BLnPwXcvSvVsWw/G4hAVAfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS9DGhKrU7DJKuWvJiI3aw9qN\nndMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdlmJzsL92cx92KI/AsEGe7ySQM+Dj5gbN4FYC9QKcB8CIGGKfosCTtCg\nZEuVbGb9UCOV5GVYSIc611+h6fUOJXtA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZZhdSXu6g7RI8djtfSQ8phrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM0YWE2NjQtZWU0MS00YzZmLWJlMWYtNTc4NmYxOGE1MTM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjOGZkYWIxZi04MGNk\nLTQ4OTctODJiNC1iYmU3YjFiZjQ4ZjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQGgJ2ukck884YGJKVMr+YuK0C/8HLQbOcLN3D5hXVLm71z/wSXlw6qyWTdC8kQ\nyx1JcwoVNouWdBXZJe01a47Mo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUcJ9pdvm0/bet\nzlodHGQ7dVuywjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIH2z\n5vNE6P9hqsYTUHc/bcWXFvSH6S+sBQpXfSeA9KAmAiEAhG2NSRPvLiynrZvgHqY5\nINZdASTV4uEV1r6Le7o9eUE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3063", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3063` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAUDjW/NexDKJ54jDpR+SZWxuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwYWM2YzA2LTlkMTUtNDVkOS05MDJkLTIwZGVjZTNkNzFkMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWEwMmIzOGItODlj\nNy00OTMwLWJhMTUtMzY2ZTdkNGMzMjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa54wqfOg6hzxmd05dHyjo6ykoP+/dIXfsL9iOGh+Uw0SWapmCGJiVMsH9fdf\nl2KiBGHRBsR4XUMXz9m3/jcLd6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUebNPLrGL100PJLwvjMkseQ5dToswHwYDVR0j\nBBgwFoAUKMPSvXKoZzyCR9joVccTBPaLolQwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIHyauBs9FsAxZj2nUTd5OKoTXSsM5A/+Fw8MIU+Ow77MAiB3ji8e/IxD\nnGO6J5cklAWBwl22lbrwrMmY2Epr23SlRA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdtZMhNZaB58L5Gd4jtbJvMbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGFjNmMwNi05ZDE1LTQ1ZDktOTAyZC0yMGRlY2UzZDcxZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJgWiDHI3Y+r4bmKej4/ADTYcd3lMnqeLhGJ9zh01iOClS\n4dmmMee4JcetskLQ7A0IcIUsqxdGG9xiGkHmeS3ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKMPSvXKoZzyCR9joVccTBPaL\nolQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgciKJZQHOhTLFQ2JcWim05qkKBOJ6lWJnL3TuuF6LkPECIQC/hzxY3FrM\nuRleOAqcAGbEjXucWl3pxJEj+Kbqo4KE/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAZRyOFV46dVeIilvbZgbToBUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWEwMmIzOGItODljNy00OTMwLWJhMTUtMzY2ZTdkNGMzMjg4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YzUzY2I3Yy01ZTU0\nLTQyNTQtOTI5Yi01N2IzMmFkYmFmMWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAREdHxZEgmBpTP8bmPxbv68WUev/xK1l+WmnJ8bU1r7IgRTyP+QRVx1DIB0H56J\ncEpS9nuGhSsAGVAogwCBZGtko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5s08usYvXTQ8k\nvC+MySx5Dl1OizAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDRX\naeoRakz3zi2yw2vlSVEqKg2UC5qE/VIhTwlkfYjGAiBK9gjE7xSH/InsgGkSO+or\nPvvE2MO2xiu++xdw8/okAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3064", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3064` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAczGscBikP77oTeQl3+hxwRcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyYzgxMGY4LWM3NWQtNDc1ZC1hYThjLWFiZDdiNjQyNDExMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU3ZGM2YWItYmRm\nOC00NTgzLWFhMjctNmUxNzMwYTEzMDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELlflMKRdK+k277g0kocLzB+exFr1J1u9oIbWF6oCx0miSE0dUrcKQ75WNxO2\nPBQdF74JUaZI0rYadQTFHox7F6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVY9L3Ahc73o3bZRTGBe+m2Z9xRowHwYDVR0j\nBBgwFoAUuSLyVez+1tgyk4toXP5Ze81xrR4wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQCSvuGexn/Odb9OwNcu95bospBfGKDpambYxtLiVcdwTQIhAPy6uLx89JyaZY96\nL3s+6fwY8qwJRSkXw+Q+ffySSi2L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUa6Pj/fyTe0U+9jWoQuiTy8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmM4MTBmOC1jNzVkLTQ3NWQtYWE4Yy1hYmQ3YjY0MjQxMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQF8TfwIG2ShlBYUHNGFD/Ox96P+nzVrnAGm//zljgYwBJW\nIONNush89tzgfMXZfyRbzmS+5Uc3m3IFlf5X+pKMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuSLyVez+1tgyk4toXP5Ze81x\nrR4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdB5EFHYwJ4yFFKpfiL/0XQq0Ct4mrc8WUL6UDUunkxoCIQDy5DY5HKj6\nXe56ZYrF7Sl6slKP3OC/rkMymjA4CVwwOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISASSiB2bz2E1RLb/r44au73t1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU3ZGM2YWItYmRmOC00NTgzLWFhMjctNmUxNzMwYTEzMDAxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMDUxOGExZS1hMmI4\nLTQxZGMtYWE4Yy1iN2QwMTI0N2E3N2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR0rwMvAlj6vEgBfRiEVo5RJGw2fpsSTDZWL6+jIR3Jg3sWoh5EJycopCyBjkcQ\narjA2EvoY/bGh296V6AV+PN7o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVj0vcCFzvejdt\nlFMYF76bZn3FGjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDG\nVGgBfO2qQbmeMg4tp3he+DTd3BDm2ARyMs8OZIibswIhAM1hi8dfU6YQrWhRYsJ5\nAF2srp/R4elNDpuOB8EW8XIu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3065", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3065` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAaphLwsQ97ox7sjeAKBhflCTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxODI1ZTE4LTIyZDgtNDhlZC05YzA0LWE5YzI3OTJmNDgwOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA1YjZkODgtMWY1\nMy00YTRiLWE5NmQtYTdhYzhlN2Y4MTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9qBBw7E0WmhxR3jx2NVUweV5AZ0MQ3uAW2gmJoYOZwxyNnH1odJg+V+fqmh9\nlatMyRHy850q3POygKOjYpZvi6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0cN5bShX1gL0WtcvhpbOy3EO3aYwHwYDVR0j\nBBgwFoAUCaYuEom/z9wFd5uXJqh3fCjyRmkwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIE4IVBO9gqCavGpEg9w+/pWD/RWjB+YnJnFZT+/DzoNWAiB/\nV80l5huKcSUk5CZoK3rkHlRVhgxFEx+ZhbIMRSdZTQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbnUOownp5VHOlsWpOs6P1JMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTgyNWUxOC0yMmQ4LTQ4ZWQtOWMwNC1hOWMyNzkyZjQ4MDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTFb0k3nRF7Dt4a7iiOOIEaxUsolTlC8OyOk4HFmpgP1Pn\nSUKHzk5pEK0iZjSuwcyYEUwD2gpjh94IrXBiz5qSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCaYuEom/z9wFd5uXJqh3fCjy\nRmkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK6JD2uo/nkM2vS+M/5TIsHV2ahR7DWf0zz5MCnX+9rYAiEAuycrjpjR\nn+ugo2PZrIiYzbrDI3eIStmA4lSUTBl3EMM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISATh/JnkK8wXVaDYEbfVc1BFeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA1YjZkODgtMWY1My00YTRiLWE5NmQtYTdhYzhlN2Y4MTg4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YjVhYmIzOC1hNzMw\nLTRmZWItOWY2ZC1lNzA1NGY2ZDFlMjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS868GbQFxnpWpEozYNx7XZvR53g5a0bYspPMXDNWpl4Xm9uV4tWEiNp8p2awC1\nK/K8va1i18UOvuKXx1S5v8j2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTRw3ltKFfWAvRa\n1y+Gls7LcQ7dpjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD0\nSrO/qE2d4KXdwCLtz6RiLFNBDxnK+HqqLSWrRxiQxwIgZw0WScmdg+dzb7FLOPq9\nE2WGTwnNEDhUCvmWs+3R7y4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3066", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3066` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAfI/W55kt2Hm9FAdUtCbNCo/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjZTExYTBkLTc5OGUtNDVjYS04Y2NmLTk5NzU2MmIwODhlOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUwNTc0MjEtYTE2\nYS00NmI4LWExNTEtM2Y2MmU1NDQzOGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+MYNATLyPz/vyX9/pqzOrU6bMdqv6mnW+8BDnlDZONRd8fGZoGfcJv6TEhZ+\nWmSVF+xTGv5ClvGh8Mvq+qofeKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN6o/LfaL05mQnKe4s7Y2BCy2/LkwHwYDVR0j\nBBgwFoAUqxH9csE76YlhGvgSxNvTo+IcLfQwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIAZNGSf/idQuF5BpadOcG5GtldSWxD+SkY+uFn/Xas7LAiEA\nqzFOJ7bCsFrHvs+ATFtnJtQpI+eDgp1zcZrJM1jZSjc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc5JPLKKxx+a5S3MJlZku/6EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2UxMWEwZC03OThlLTQ1Y2EtOGNjZi05OTc1NjJiMDg4ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATG8S/10OecoLTS+RvUeLrm6kxnnsGW7XzgRCPq3bS3r0d1\nNO+C0WW8PGqfMgVC66lDZLJ5HgTBMt7FFV9Z8HfNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqxH9csE76YlhGvgSxNvTo+Ic\nLfQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKebuLZGbuxUlr65xonOEnXvNh0Dn7/HQnJ+xnbCLOwjAiEAkLfoO3dJ\njOeQswZMuH94ZFdy5KmdcaiR7KibPS3RkFU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAUjnkMRntYRnMUzaGRzj/OsIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUwNTc0MjEtYTE2YS00NmI4LWExNTEtM2Y2MmU1NDQzOGFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNmM5YjljNS1jNWVm\nLTQ5Y2QtOTBiMy05ODA1OWFiYzE4YTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ35fYgEpjd/oJuKHXoIQToOb8oJ9CIhykQUlEJCJdcr9LhdNiq5UJRYPno+WcJ\nJpcdoWDtZFvzgyH36rBiISIVo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3qj8t9ovTmZCc\np7iztjYELLb8uTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDu\nqjcanM4zPwt509ctUGxoVOZ+sIq7wGr8eREqfRNtbwIhAO7GBvKMTRVWWHbwcC3M\nMwaNf+G76U4MKxeQnuqN0Lja\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3067", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3067` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATASa/rh965oIt9thCd+NxJ0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2OGMwMTZlLTgyMzYtNGNhMS05OGIzLTczZjJiZGU0ZmIwYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWEwMjBmNTktNWUx\nMi00MDgwLTgxZjYtOWViZDdhZmU2MjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy292wv21ABlhcBQV2JZwuK4AV3zHF7OiyQcsquGd995qgG5MDvY4HMDREbqX\nLmzMKbwzFI9f4cIMMwzWsnPwCqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1IL1Nf3EED7wbIJ5+1p7Pki6VIgwHwYDVR0j\nBBgwFoAUeX5RVfGbPq15QheK/zgEuYiVjiwwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCbgTe4HUuv\nweu2jrtlAUMS0khgWUlmlsJ2HhbF9CAn6AIgP8DF7G+OK7w95B28Hy/5FywMdPOg\nuPcJaf0bRyMcG2U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbLUaXSvnFq6o6kUQLPL4XSeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjhjMDE2ZS04MjM2LTRjYTEtOThiMy03M2YyYmRlNGZiMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJrmAeNY0ue7ulaU5vhNryOjtn1HpvwH8xq9C0n5UGedW7\nW8wLKP3H5ASiWC9mxIbncf9x3vFrbbUhIzQTYZFVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeX5RVfGbPq15QheK/zgEuYiV\njiwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO25MZ+xbnccxIQs7WNTuUxS8Da/5jm5pPh+zBmCKxEfAiBIrlpbquBa\nTM0yw4XY78JGWrsUxUNnemKeKnuhlLxscw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAUYj5JPCqUUBOwVSs31bAVl4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWEwMjBmNTktNWUxMi00MDgwLTgxZjYtOWViZDdhZmU2MjRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MzVmOTI1Ni0wYzcw\nLTRmMmItYjIyMS1iMzQ5MTRiNmVjMDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT+ds+Pz+wu1ZhkTNSagIKhuY9CBJS4mMFpB1Y/GlI9UR5BjmGtRd2T8hJOhyQO\nttGEFmszg0gd7QipE5efwXAJo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTUgvU1/cQQPvBs\ngnn7Wns+SLpUiDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGPA\nyJXLGVDhQwnYOpj4WjCx9AkXjRQl4UmERHKOiIgoAiEAhMyVX3+l41ipkEUoc4Tt\n7h4UP5HWSMlTMmQhQVQe1/0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3068", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3068` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAeukPSV8T7LEpHojXnLlajh9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwNjQ1NGFmLTQ0NmYtNDNiZS05MWI3LWI3ZWU5ZjdhNjJjNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJlZjFmNDYtZjEz\nMi00YjdmLWE0N2EtODEyODY5ZjhlNjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqERrnMRrq1hlZiYBY0WE7o6M7/OdhIs+64iObCZovxz9GtKWZDB4g87bP17c\nSJu0G/06/Kn1aIy0nWh7yCCR1KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR3a1OBIgfMowZeVzen1AAOW8iaAwHwYDVR0j\nBBgwFoAUHBUugS/0Bz6eIxcFqyFJfuvHTjYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgcRUN4gHqZSMdtD4t4Yun9wXE+MXVjQeBYJ4aE/N1shYCIQDHncwGIACX\nxg7OBD5gxFOsGv+sNQi4E1qRyaePeb2W4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ2zYrswZHFaxxA+KO/yAoGNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDY0NTRhZi00NDZmLTQzYmUtOTFiNy1iN2VlOWY3YTYyYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKa1yJl6Bt7qDr2mKZac/2O1nwU+f/aKDDhUYD5zWmDA5M\nCMNkzeNdlmB6Ycu/IrctWQbjO0MSq6epocfGHSfbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHBUugS/0Bz6eIxcFqyFJfuvH\nTjYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANPT7t/vGRM/lbzyJ/NlFXbH6ktRZ0KXcOIkDNcos1xiAiAF7nfreJXz\nXIey+irVBILQfuzKHmLzfbzMpH9Rd2EDow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAW8qljhc/tRdac+VDPQq5T0OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJlZjFmNDYtZjEzMi00YjdmLWE0N2EtODEyODY5ZjhlNjUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZDE1NzdjYy05ZWJl\nLTRlZGYtOWRmZS1iMDM5Y2I4Y2M3ODcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS20+Ox9QiXUjD8ej/PlbkrWSSft7ZOj+t0wKvPsshEXfNRqMwQ02SrjQuvuS2S\n5urCnKb9owyS/EefoQr010/Go2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHdrU4EiB8yjBl\n5XN6fUAA5byJoDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIA/I\n8ptbVyVMn6yXf1SMvajHAWbpHggAi1DsxaH+8uwuAiEAsEPj40va3pKLMthLMC0B\nSAXZyHz2YubGD/gszlUipkQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3069", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3069` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfAB6pI4DJxnDo/EEx95tOBmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5YmE4MWVjLWQwYTQtNDc2ZC1iYzBmLWNjYWFhN2Y2Y2U5YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjViMDgwNTMtY2E3\nMy00Yzk2LWI0MTAtNWZkYzg0OTU2MTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmMUuHRbRema6IWVLZqyqOiCq/84CTYdRWk4wgfqfnoXP30unNaaUS/kIzl27\n0ErVYoRsxc9HBEgjYV1J0XcPkqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN0yJvTRONWGgl6SwJfCqfpPZgiMwHwYDVR0j\nBBgwFoAUNHU23++bWmHBGuF55jvsNL0Ik1QwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAPnDrBWGcN2uVBe+Atg0RSmzoHtFPNPMvxiFO8VOGTOVAiBstDReuAcr\nYJxPT5UL1mokfodWwAkj5JJLfGTxlmSaWQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAReY0PJj9EuRPXcd5BO6sgqzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWJhODFlYy1kMGE0LTQ3NmQtYmMwZi1jY2FhYTdmNmNlOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5GKMOV0rZqWwXYtb/QAs/R3Q9lf4SZyIOji2VsI3zs12F\nJUC8Vr/YsIkRFWYyu40q8P/8PC/Z+0MEFs93OxZNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNHU23++bWmHBGuF55jvsNL0I\nk1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIS9ZWSHpkjxBMlOjESl1rSphpgGQ7u0bXtyFcZRyI04AiEA2onEwkBZ\nwzaIQRt9bgrv4I3pmvrqwyI1G0fmP89BX34=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZCtZjjY0LhZ02qZyB24xwe0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjViMDgwNTMtY2E3My00Yzk2LWI0MTAtNWZkYzg0OTU2MTljMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNjk1ZGFmNS01NWYy\nLTQ3NTgtOTFhNC01MDYxNzAwYWUyNzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATCCSchgeToUiq3VWxXeQa0dTLuQxqVVhscIZteYT9S4KKILIzVzfx8zQh4yfoZ\nxNK0ZdqdgGjp+2Nn/lX1MNUmo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3TIm9NE41YaCX\npLAl8Kp+k9mCIzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCm\ny+onQRagP0XXA9OP74H5IoC1dm+DZJLse/BCyoLQ5wIgFrWodXXqUEFvmnOvhDez\npV/ebNi67SxgMpBNrKToIys=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3070", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3070` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAVqDaC0VaFIIhY5//yTRQmkpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3ZDA3YzZhLWY5MWUtNDg2NS1iYjZkLWRlMjBhZTc1ZGQ1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E2MjA1YmQtNjhm\nZC00MDJhLWJmYzYtZTYzMTc3OTViNGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECmHf8wchOx8uSjCuZ+CNGfk1XOWqLnR8KkSG8Twm7zq9pJur27MWdAV9piWW\nRVvtQFFn2Pa3mc0qopC4CDqBkaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDrcZGOdXPiSr/K9azAHth0rtAQswHwYDVR0j\nBBgwFoAUzB+BokqRZaCJgaUtNhLOWLXh4rcwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDXOqi1k7C2ujep2Y3peM46sPk+0bKBCCMOMgcRPTEGTAIgNBSTyhXu\nqkCOgHb3h/TG3a/WrvBSQwGTUfE4o5DoPQU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWfdUpBlhIlIxphqAI39C0tfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2QwN2M2YS1mOTFlLTQ4NjUtYmI2ZC1kZTIwYWU3NWRkNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmJmpa58fy41YuYCcd/1nGPdt+D1Zqq3wGRpJvZXKN06Af\nLc0HWdynceHVb92ZHAC6TsWENgvt+G2Q9iCuuVvio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzB+BokqRZaCJgaUtNhLOWLXh\n4rcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMo4wXIH9k4980+m5+ZesTyEG1D/rz2yjrPXnQi2ULwWAiEAlEdZrvwk\nvvEO77WpaOFpu5HD7jUWRLjy6mm3T4OfiPs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAaWZsLueFr+mUuA4svb9/IZVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E2MjA1YmQtNjhmZC00MDJhLWJmYzYtZTYzMTc3OTViNGM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYWJhYTE3Ny1kNzJm\nLTRmYjctODBjNC01NjBiYWU0ODAwZDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARIOeZbDFtWXnV7DGjNr3FkMY2D/QsLqC0jbg4vnMajpsHbesWHuVoUh4WPxhWU\nWr5DRv6sZh1ZB8FBL9S/JU/po2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQOtxkY51c+JKv8\nr1rMAe2HSu0BCzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC4\nQQQQFna0NOqT+b1gK9n8q1PeTfMWMiYWjOJfgmGItgIhAODgRO8zGEbCoFzVQcUy\nOBCFz1QzklCij6w+CDTg9Rk1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3071", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3071` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAQwnZMaOhj0XD4EwdRGX2TrGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlOGE3NTJhLTFhZTYtNDBlMS1hNTE5LTIyNTRlYTljZWM2ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIxOTMxZGEtNDQy\nMS00ODA2LWEzMTUtZTljMDA4MzNiNDlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQmWBFVGALtO4O1O9O0kHkW8JHyoRUVL7ZkgbuYwcnRayKSjCILqqRumdm4aY\nVhSdVXVvF9oUSi+MFftPI6KRqaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb/Y2pt0+ni3imcuX83QGYvINYuUwHwYDVR0j\nBBgwFoAUcDx5d+CiwwCNTVrlhCLa0WfvowYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIDsrdpFFrcoy+s8ctRNSywdFba7r61sDGhfQgFfy\nVmQUAiA05G4VQAtd+RSnTFBcHJasqo8uWseZfyGe6dm7ITw/5w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcDxlpVLFlVpxJRta2iRQ2jjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZThhNzUyYS0xYWU2LTQwZTEtYTUxOS0yMjU0ZWE5Y2VjNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6DBAXLNL8oyrQMIrroYNnxNw7AkqCXKzlelh5xFZeGQLR\nyK+9/r2WCs0rcyTl/xiqvt29BbX+nZjuAm8StCvHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcDx5d+CiwwCNTVrlhCLa0Wfv\nowYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJSjtYTMNklqbhkztiZFbGBhnKJfZdXfoJ8WeFl9AWcdAiBs0ST+WNCX\nH4GFoDOcKunJKPiqmgwEKs82nrdT9EfXxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAW5CqJu/e5lVyMQ31sr+QYXcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIxOTMxZGEtNDQyMS00ODA2LWEzMTUtZTljMDA4MzNiNDlhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YTE2NjRkNi1hYjgx\nLTRkYzUtYmVjZi0yYTZmMzg1YWVlOTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARvGIoKiGmhvjqN24d3td2fYMaQY9LLrKGPcpbz0lObDziBbdtoeSspu3P89w/I\nOG/wft5ukujXPoSg9c/6BVvuo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRv9jam3T6eLeKZ\ny5fzdAZi8g1i5TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIG7Y\nXF8pxOFFaEEyJgJ/U7fCdWb5wjbnR1FCqVzZKvu+AiB8zMVpcd6Up4lYAIVjlRzU\ngSkb+cQOx80IxKUtAx3KIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3072", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3072` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAS+dYkg80Ra4JRIOBGhQhi8fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNmVhMzQyLWY4YjktNDA4Ni05YmFkLWNmZTYxYmE2NmZiZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgyODJmOGUtYjdl\nOS00NjE1LWJiZWQtMDAxNjQxZWRjYWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvXYKi7Y9sZy6eLZm0DY9CdSeobwBz29KOmbWhy6JXoNLBOYUU72i4RuUetu4\nndT7tMYIjOpIofVlKqvlr5F12aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBXgJjB49hsghEVJs6XVreGyc4AwHwYDVR0j\nBBgwFoAUB+qe2Db7BLpd+BDTbZdQ8ZwjmAIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCID7hXRWbD1lV0lNU5izTyDr6vPw87O/zMH6hrWfy\ny1xuAiBvZGIQoy9tw0xCMgjuBelIgtaMs32MncP0ntTP6dIgCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZBTlj3qvwVz8FeFbsEMosRQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTZlYTM0Mi1mOGI5LTQwODYtOWJhZC1jZmU2MWJhNjZmYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7EsgeJlH0Ev/aNS8srSYpW5pXKk0V+IKR0uk9ue9MNNMG\nzWsWpwJW5u5JnTHbmOYx41RToZDUpMj5wnSvI86eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB+qe2Db7BLpd+BDTbZdQ8Zwj\nmAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZKrKmiMs3qcI2UroP3XC05Giqxokd2FZ9xzJS4IKaowCIQDI53XRqh3n\n0SqlJP35ADJTtASBDxxFhiIlfg1gUfjGQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISATP3t9Wc0DOrUBSjkImwLfFpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgyODJmOGUtYjdlOS00NjE1LWJiZWQtMDAxNjQxZWRjYWU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMzVlMDVkMC0yN2Zl\nLTQ2YWItYWZjZC1hOWRkNTU2MmM2ODcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARXL3cDbJc3TnsDf0n+TC0LbIO6tKbfoodlq/TJu5xjfi2eB3TeudLBNLhs7tPc\n5YpH0AX++nGod5VEy5toklsno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4FeAmMHj2GyCE\nRUmzpdWt4bJzgDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDt\nfMcAeAhud4fOAq0YQmY5ulwCkFaQB0iiLmhwa7EWwwIhAOVAddb/vyZZGIRd/vnk\nFTJqSUhiMzYlDDAdXNkXfoLj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3073", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3073` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAcfwh6ax0/UfgGzrjEHGrvuZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZTg4MzBlLTA5YjUtNGIwMS05N2Y3LWI5OGEzZDhlNmIxZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmYyNzVmMDUtOWQ2\nZS00OTAyLWJmNzEtOWJjN2Y5NDdlNTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgTIaLLvS08wpsctTfMa9MxVX18W/wQ/ZpYOfijgnb/qPiUkuWx0uRmw9t049\nJU26WIiDv8AF4OF5621VZepouqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUULmMgxugMt088GsIWM7j3tjrMfUwHwYDVR0j\nBBgwFoAUnZmauyKJKSvbM+TrooPpz9Hh660wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDbOCpJDoDi/Q+45hxqqhNC9NZ0fwQSJ8PDehfWlkMPJwIh\nAJc8UzQ0oVWEa4xBA9RAtgcDhLMmeO8lyLhqgd8gVA1k\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd2ZVrhMbagrWB1UK/2GbpEwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2U4ODMwZS0wOWI1LTRiMDEtOTdmNy1iOThhM2Q4ZTZiMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpYircvmy/ehwdl/OkHSsFHyas/KHe1gRWx77Z4gDZ06MK\nsnjeNNVeg836QhU2JXVLAFB8iyMdDpMMZ7+T1D7ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnZmauyKJKSvbM+TrooPpz9Hh\n660wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPLjWTywqiciGr9V/S86wnXdHsRqv9W6TrYn3e+642jqAiA5401y09Hw\nwOatqy/rfZ23KOMRVo/57AxQGCO/3C1LJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAf9UrnlG7g366QxnaHCD57/TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmYyNzVmMDUtOWQ2ZS00OTAyLWJmNzEtOWJjN2Y5NDdlNTc0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNjhmMjM0Ni05NWQ0\nLTRjY2ItYTJmNC04YmQ1YzA3OTlmZTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARdSn7eQQ5iqz+Bh0av2wEZLRfRCqfA+CZLuuZ+6M8qPKA40rIUMHJubZa/u4b5\nl2DeEGDJsvfkHE/m7dxUA1A5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQuYyDG6Ay3Tzw\nawhYzuPe2Osx9TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCF\nWO8j/PtQ89IFEtGLRxX7LNADImAR9Cf6zm+0VvYKdwIhAJIORm5JnLzRqBxDs1eo\nwqtkhGSWxlJ600QDRMiQZbMx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3074", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3074` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISARsWBkCTlcdZ28GqByg0BTZhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxZDhiYTI0LTk5MWItNGQyNy04OTI4LWQxZWRjZjg4NDk1ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA5MjcwZjgtYTU0\nMi00MDMwLWJlZjEtZmEzMDNhODAyNTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvr8zPqHdrDxXTCBZeQnr7R+uvdqUa/9acuYpmlwImZZrn72ODKl5pg4jvwNy\ngzK/Ld0/j1pqOaT5h5oACNCRiqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUivsqntO0z0AucXvvZQoCvl2XLC4wHwYDVR0j\nBBgwFoAU1/Ne0q1hkwI7AIpDoLregP4x3skwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC0FtVCjMQivtj6rt6L0EA5DqPkMei2\ngoq7RzR9ZQvetwIhAPpRxM1NbbzB1AoC9AiIpHFaxzbMVeRchLCuXN7JNVmq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb5gwn6ya9LiKK6Tzt+8ZZOyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWQ4YmEyNC05OTFiLTRkMjctODkyOC1kMWVkY2Y4ODQ5NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARC4b4nuc57vzvvtdgcT6licfsLLwWDuZUBarOxzJb/+RgI\nPPgqpQM/qKwEBO17XDsOqc7KKtpirE8gjLJqZXVko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1/Ne0q1hkwI7AIpDoLregP4x\n3skwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANj9PqTQ5YBVMN0W/dzSxaXAGhbn7NpGC6tOmeeU341tAiEAnUfR4bkM\nLH+N8QE1G/+gKUeyKLkg/J47C/g6xCpePQk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbGXZWqBKLLLAyFMlhyBtTSXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA5MjcwZjgtYTU0Mi00MDMwLWJlZjEtZmEzMDNhODAyNTRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNWI3MWQxNC02Nzhh\nLTRmODUtOWM1Ni1lYTc2M2E0NmQwOTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASrbY+nxLvhY3Enlz2LaDmL1fXew3DHhX685QUz7cpHul5QnjKnwxM1y+Qa6yjL\nxhlSy01binDcZCGcbupCspySo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSK+yqe07TPQC5x\ne+9lCgK+XZcsLjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGXz\ngsYCqcOld6AWsOVqxGKZe0rqx10Ad15qJlYKFtgPAiEAyahc4gU0qvzaNApDfZj6\nAd7HPclpkvDAycF5O20tz7U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3075", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3075` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZKVsTI5sU+uCtq219Q13/mHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmYzI2ZDVhLWY5MDQtNDU3MC1hY2NkLWYzYzVkOTBlOWIwZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWE1ODkxYWEtMjg5\nNC00NjAzLThiZGUtZDhmYzM1N2M2N2M3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEogyr9O+Quu//TSCUsXtQTfku57i3OyXXAfYWcO5ujYNDzN2BsYum4jqrkiSf\nUMEsQSpiZ6yOlTLOnOwBg7r/nKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtlHKfoRDO1+152g7HBxcGT+s8SkwHwYDVR0j\nBBgwFoAUjyadKWipZTJ8RDFpu/uwJem2P0IwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIEg/RuzzavAdVr3Fm61ZjkUA75XhrLwY\nYNPp27JhAlbwAiBVpLUVsxiOO6+p0da85PSDSaeB0UZh7EQHWYuHzI4Duw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW/z/8UYOz0P1M+YZCXQC9r/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmMyNmQ1YS1mOTA0LTQ1NzAtYWNjZC1mM2M1ZDkwZTliMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZb0uNdB4C7Szm4vwUxBDdmTL0S3koneZlNx4mteJ4A4ZK\nzJMZ3Lg+E2aSoOmz48M0VryfVh/YqfQragsbKtXho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjyadKWipZTJ8RDFpu/uwJem2\nP0IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOZ4zdCxQQ+Am/x59v5faL9hzGi4fuBEFe8K0EQFyOKQAiBUMgNo0sZX\nt+FrwuitJ8bZEjdDifEnesz+hwTiC6KJXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbV1q/dVYERvFafA/60d1jMbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWE1ODkxYWEtMjg5NC00NjAzLThiZGUtZDhmYzM1N2M2N2M3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NzkxZjQ4Yi01M2Yw\nLTQyYjgtOGZjNy0xZWFiNDUxNzJlZjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATBb1axV0xrsBK0FafuQrxpdA/t7EU+5KvWYbjrhAyjmo6kaXtp86d6IaZ7MDwh\nq2KOuQJSmTDKnwh8n6NMcTkPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS2Ucp+hEM7X7Xn\naDscHFwZP6zxKTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIEuH\ngikkM515FNBUi7NtiG1CItrn7BEG7DXMrBSeug7fAiEAoKTcjizftWokZYV+EOKO\njlcvAEWwMSSABw2JknY60TQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3076", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3076` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAaNwQh4l4nist4Zp/rJa+i2HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYjZmYjZjLWVlMzUtNDk2MS1iMTRlLWY5YjVjMjhmNmI4MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY4MmY4ZjQtMmIy\nYi00NDAzLWEwMTYtZjg2NWY1ZjM1MjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb+3SBFK3+jnt5EjibjBzNl/PdCIjFCwBax7mqE5UwDkiK2VkQbv0QNwtdv/J\nPA72hgqZVcRjZjXYmWpYQ58Xx6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXu+9FM8hE6+N320v2tK7s3UjacwwHwYDVR0j\nBBgwFoAUb+wZQKTHMl1Kh/UEqVkdXWl1kKUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIF4mtQRFcRXo\nqQpGIH8iK3s4VS2+nBu9DJpErKiFIlmIAiBRP+25WOKpPxLJMvqBEzyX/DqCwXwL\n9E9eYU7vwACEng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVpqvRFSUXz/gXkaV2HQS8d6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2I2ZmI2Yy1lZTM1LTQ5NjEtYjE0ZS1mOWI1YzI4ZjZiODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9YBdK21kh91sqntCVetvzWeq/PmFY8L0viAgzvw/qDIho\n3K8nW6rO7CBzJP10EAR52injAii8WlJY3qrDFtc1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb+wZQKTHMl1Kh/UEqVkdXWl1\nkKUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgf9rXaaplN3UveekLJ7V8N+jqv66ExeK3NjHbtH9sRIUCIQDSR+pAwNwL\n8edHZ/ZsN9ePH0x9qjdUtZh0e4HsYKnIQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAb8yYEW/my2JbKOuECG+eQSpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY4MmY4ZjQtMmIyYi00NDAzLWEwMTYtZjg2NWY1ZjM1MjNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZWM5ZjYzMy01ZGI2\nLTQwYjgtODc4OC0zYjYwYjQwOTNlNDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS67rgL6402znBSiI745/eEoLfCeiGU3OiJGHnlPFzrj/qQgaUDPysPwY7gRkev\nWdNMD27/TPTrsQ8nf3BPXWC5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRe770UzyETr43f\nbS/a0ruzdSNpzDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCG\nEJ66cz+qT22THdaUSRGLqxr5sIykJoaGI6aPDZEUQQIgVU4j3+wjiehDQlGM5zhG\nrll46Du+fQwup7vdHnXiRWw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3077", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3077` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISATiN3vkwo0ApH1akWvv6L+KwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhMjhmMzdkLTVhZWItNGRjZC1iMDE0LWZmYWJmNWUyMmRkNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTIyMzJmZTktYzdl\nNi00MmVmLWFjZDAtMzQzMTM1ZmFlNmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv52vN1exdkameKRS4HzvincQJER3lyKytK6rX52eS1Bp/ZvWBaqRe0hvUYEw\nfSnwVIB230rPwQRzoTvg4rdY+qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5PbI1ZYN03RI8VSl7YE34AGPVJswHwYDVR0j\nBBgwFoAUc1q1E3PM28Q8Z8frrfZ3hG9W+2wwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgfZhCK/QRaOJwudLEMwu4iW6kFf+6KfYYn+5YQRc05/ICIEzQmnRhOiMt\nD7+H2dOSNGq3Wt6NWocf9NNY/z1akbbb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQuDrUx6C5aQArjArFwg/q0UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTI4ZjM3ZC01YWViLTRkY2QtYjAxNC1mZmFiZjVlMjJkZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhiUwutiGu9WPb4enYZNCu3UR2JBhrTnvIn/kmZ2eZvcSk\nx6vKYKpotJd+QneRSst9XENUl2eqS/HZbco7yzy5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc1q1E3PM28Q8Z8frrfZ3hG9W\n+2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM9Nw84bObUEAKuJtaqYYNtKMsM38vXiLIdoW6bXllPGAiBaEmlvX45s\naWCfj1O4zoUWXv2zohh2Fyko78CTis83mw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbD5ewuPh8xYhq07xQ+vUUAYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTIyMzJmZTktYzdlNi00MmVmLWFjZDAtMzQzMTM1ZmFlNmE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMTkzZjdlMC0wY2Jh\nLTQxMDUtYmQ2Yy1kZWIwMjhlMzA4MjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATbx3Y+wuagyW8FK5bRJpwyHP/Sx6DMz+yFbV0LK46Mir5ZzGaEqt1g97AdRJa8\nOJY38EwemEgbU9X7bXDDuzk3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTk9sjVlg3TdEjx\nVKXtgTfgAY9UmzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDi\nYLjdAdOcPyBHVLgakf6Ebl54Y0k7HGTQWBtZG+r64QIgLPwf6FZmzZKwBD2MvWAF\nBoQtAf6J33ytWJc6I2EK5kU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3078", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3078` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISARc8Y5jm7Zwj0WzSo+aO+wmJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5N2FlMzNmLWY1MmEtNGM1My04N2M1LWE4ZTdkMjk5NzVhYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdhOTA2ZGItZWQ2\nMi00MzY3LWFmYzUtY2U4NDAzOGY5NWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe8ynIOv69f5fKqFPlktdd2TJ/v9qx5vsFGbY2MgM9a3i2oYdYEau4fUTNdA8\nV/q5RF1I/wEC0HQN176/hqROxaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCDXD64TNEy/kHnaj0jhFffksvi0wHwYDVR0j\nBBgwFoAU1fP3GK9lBDG3GfWWCN3AYV4ah04wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgWTaAV2bKo8oEdDaYiANQejipC0uY6meXP/+Ihr/516cCIHZfoZUgUxsL\nM4DMWDipjHjUgmWrTEjO+Jm2Mrx7Yo3t\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeTY145+KSmhVlyxOtNinC9KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTdhZTMzZi1mNTJhLTRjNTMtODdjNS1hOGU3ZDI5OTc1YWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyHVUGQCFGutowJtlJdk8m9D9d2m5JbrvVwgoySnTcuK/0\nyMwZ/oOyIuPGCntnHmhgMdwuiyvRKjcvGKZ4yUOko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1fP3GK9lBDG3GfWWCN3AYV4a\nh04wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPZ2DtEGZbajvQzmnj4q6eZ5A/O+TmAFwQ0qxb+0kCwgAiEAoiJgmMQF\nV1djOwuQ+FtHxmMZcgITSN4Itb92eer8eN0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAX4QZUFTYqJVteREepfS6RvaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdhOTA2ZGItZWQ2Mi00MzY3LWFmYzUtY2U4NDAzOGY5NWU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyODc1MjZmNS05ZGU2\nLTRjODctYTA2Yy03ZWZlZGZkZDlmMzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQhtOPxjXkvn59e2BsY7CbQNNX9ov1ct2AzN5D/fTypDd9gCtsMvWxixOggOQ+G\nOPebj0fqqZt/Cb09Y7OPjQUPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQINcPrhM0TL+Qe\ndqPSOEV9+Sy+LTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDs\nZ3LKZ8B2mR3FdFy/rcSqiArRnVdJ3a1fEMM9OyCYwQIhAJ0RZhfY3rHj6QgMXuL3\nt137y1Vnylujl05+n9EUtT0J\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3079", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3079` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISATTiASr+6Q1Z5ssmvDW4OXL4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NzAwYTU4LTJjMzMtNDUxZC04NWM5LWU4ZGMzMDg4ZTYzZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMxZjIwMjktMTRl\nYS00Yjc3LTlkNzgtOGE3NWZjNDUzNmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8Til3JQIhoF6aqybMqMz5qtOTCkHQeAY5l+x0qhBjzisGQMlmKpjjOPz5d69\nAEYQV/cUG5UnE5lCDU69mlJpeaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+y6DMXw9JvZBF943BbtBKgJKXPkwHwYDVR0j\nBBgwFoAU0378U4htwT7RAndj7hLXt2ZT+mowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIB1BjfvouZHDc/mCsaJdNE+Raux+2wT7Uye8vbQspE54AiEAwpnbmaJv\nTv+9CKXPZbZ86/Oz+kKtFzqFvwrqtVzmfVA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZCMEZVLB7JKIDecxaHLnW+/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDcwMGE1OC0yYzMzLTQ1MWQtODVjOS1lOGRjMzA4OGU2M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVKTL6TQUL6cch2jSLmy5NAoiCgYjI0S10vK64G6sOh4hX\njAtFq2q6mnj6XwvxA3/OVqNNtTiy/gMh6ayz6I4Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0378U4htwT7RAndj7hLXt2ZT\n+mowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOvZ0qNYa25KyajH0Jvcd6ZbuqaUV/tTKSP8b1R+HjAQAiEAynNdHomW\nq08l1th07AZ1xe5iSBLHF1ERrjpdEAXYG/E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAaFv5FjjHHqxqSRI7OGigzfsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMxZjIwMjktMTRlYS00Yjc3LTlkNzgtOGE3NWZjNDUzNmZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNGY5MDViYS1lNDlk\nLTQ3MjQtYWY0YS00ODc4NDk5YjJjYjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATq4AYkKkDqmKaQCKiHZ45P+JXrPu/lfjTTSBaBKNyC6r9Mt3Rx4izQgmy9iWlj\nPnxdRLl8lPfn7NXFAx0T8j4zo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT7LoMxfD0m9kEX\n3jcFu0EqAkpc+TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIG7w\ndZ5Dx9o1dkPx4q2i4Cf1T9aagEql6k3ePMCSOLzoAiEAhDt4NJxpiKDA//A329hY\nqtsbDqNRskDO4TA7rWpd1/8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3080", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3080` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAQPbzRWwCCAVhBsWwduk8/B/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5MjlmNzhlLTEyMjItNDRlOC05YWE0LWMyYjUzZGVkNzEzNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRhYTIwODQtMTlk\nOC00OTA4LWFjNTMtYjEyOTRmMzljODk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJokl+7/OgP320pkK6A3hGZkbEhI49vh/p396/VDpPbslR39OkNAPx5ZxZoTx\naZduGGwd+WAyy6tyTbcMOxmYB6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB1JwOqiuED58clXbsk7Zx3jA5JcwHwYDVR0j\nBBgwFoAU1chFq+MOa+mVAaBCeVwXgeRy7fAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDp7TR2j16HnhnUFNi3SLC3iUXkzNfQ569It2m/\niKFOUwIhALQjFc+s6iN+/GlLdmApZ453OwwQQvChZJDpr0RSeiAT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc9VtNuRM9HjIA95hr7AduRaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTI5Zjc4ZS0xMjIyLTQ0ZTgtOWFhNC1jMmI1M2RlZDcxMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCy25nKaVCqPvz4Ml4qhyiaGoBmkoKVTw7aN8K/TdqYriw\niUKrxL3cZLKxzQqzSW3E6mqhpiKzhNtNA1MZkfvQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1chFq+MOa+mVAaBCeVwXgeRy\n7fAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ686Fl4ljblsLL+jp1XjGckQ+ZWba1nqS5pAC8MGlTICIQDukGgQ7gbW\nNJya/7vm0AxMhYmxr1dQKJ4u7FewK/NCpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAap1KkGV1xD+OJGGoWksZoWXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRhYTIwODQtMTlkOC00OTA4LWFjNTMtYjEyOTRmMzljODk1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNjIzZWU1OC03YTZj\nLTQxMzYtOWZjMS1hMjM5NTg1YzRhYjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASx86VUUcLO7LY1swsxEWwa0bdLohXmdyGuBN87BZVABUvDQzU4t2QQtFICpwDZ\nUCuqAc7obKVq1USCg6PGn027o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQHUnA6qK4QPnxy\nVduyTtnHeMDklzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD1\nYA7F5ml05WE3jQ0lVEHmJZO8wzuFfN21NPih+EB1ggIhAMzuwIc5pcjA0ciKgCBX\nfs8MNIVAe2k8dk55fKNpjPkM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3081", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3081` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAY13ZMI3/j034Mzkv+CNTXHQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3N2FkYmJkLWJhYjgtNDQ3My1iZTMzLTgxNGViMTFjZjUwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFkYzgwZjEtZjIx\nNi00MmM2LThmMmUtM2QzMmQxZDIwYTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8w2dJsKYZ6LT2FiNFfmijfADkgIlgI8N0L+/GUW0TJmLE4yqstJErMsBnaI3\nymASwtu2BnT0WsbXeGPCL0p8mKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYdOgS9IvPDsryEoKv4KkGI3qWGUwHwYDVR0j\nBBgwFoAUqk5yoGbWOD+DKhsZtKuIwLg/KnwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIFNEEdneZkBrwjvDAu2TLjLhxL73uzAV+bEmF2h5\n9ID+AiEAkDnbq2dYH215KPfFMGigwrBK+/+7m18FrZq6iC41DFE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZD9lGQ8InxvTu1Qi/YqW3GhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzdhZGJiZC1iYWI4LTQ0NzMtYmUzMy04MTRlYjExY2Y1MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDeDFQgTszytTBgWZywIZESxo2+mLnet2Hpk/LvBZ9t1cP\nz5/IOSi9IOcfiYes82utkPCi3/9pqicRwtEPPSyto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqk5yoGbWOD+DKhsZtKuIwLg/\nKnwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKQPBDX3z0GfQYjjtpL5GJ8ZVwFGEaMrb1B8Jz50eIhLAiEAvdSisRgv\noJ13uKqKUuFjTK03Y7fbVLS8HFW28IzlVP8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISASNL3ggow90GPByo8GMdiPBcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFkYzgwZjEtZjIxNi00MmM2LThmMmUtM2QzMmQxZDIwYTcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNGQ0YTg0OC00NmIx\nLTRiYzMtYmNmZS0yYWJlNzlkMjM5ZTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQFeuyuv0w0zCmw8vhuR+iUVJ0EibISr4+TFPbCFW3RL1WRuF+B3N75Yme9MzcN\nJsVCK1LAXS09xlHiUaPfT3Fwo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRh06BL0i88OyvI\nSgq/gqQYjepYZTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC8\nUujwR2Dt6lLFuVRxog0Fa9Te58CIB0tsSj3Aub4AhQIhALs7QfJnatPJZwG+gG1U\n5c6bYXuH+pSRvjlOoWrz7N/7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3082", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3082` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAd6G8F9WCILlCaDkRdxQhADoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmNWFhYmJlLWE0NGYtNDA0OS1hMTFkLWU4NWQ0ZTNkNWNlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJjYzNhOWUtNDcz\nNy00YTYzLWJmYTgtYTNjNDFlMWEwZWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+J1eDlMxdIoExI1lKoFiv381etxBDJ7b/qVC6TSBB5nm7owIvYXCwelITuGk\n/+jUsqpLgejWqdnRzHWbdvWfP6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhYkyC4bUeJua7vTxNv30UpH4Y7AwHwYDVR0j\nBBgwFoAUknmEQPTSwynAkxSJgtN4WQD0nvgwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIFqR2AMkdnBuWR4xIuxxv4EOyHxe5Q2F0xCoK/WitarsAiBR\nCoyfFUw1Uf/6LK/SnEb8klho4OQW5aTFH1OSmnrGnQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc7bewAQuQVZjsb2IOcQP0C7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjVhYWJiZS1hNDRmLTQwNDktYTExZC1lODVkNGUzZDVjZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYTWOfdTZHNRmpy+/FbUk8s8+b+8qZVgMIITo9r1zZgE4n\njiQuYS/R+eJds2M3nTpAMVsRCVUsKljDB6Y2ayJ5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUknmEQPTSwynAkxSJgtN4WQD0\nnvgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMmEmj5l6ERb7RYtD8S8hMzry6tCgS7Mfkclt1fld/4MCIGegO6hKtRre\nHmUZ9U4DkLuh6Umyc8UrhR3N2rZoBS71\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAVhM3ASOd8uM3TSVk6CrwbIaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJjYzNhOWUtNDczNy00YTYzLWJmYTgtYTNjNDFlMWEwZWM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZTgyYjE4Mi1kMGFh\nLTQ5NGItOTQwZC0xZjc0YWE0MDE5OTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASyUiIIdpi/WecTzVuzKduUt0IUpU/0WOfeno78rWEuj7M6kwYwHwgumTf9Pd2o\nLGYwME5yUw3Pq1TY9TqDJtb4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFiTILhtR4m5ru\n9PE2/fRSkfhjsDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDI\nINTgapwwiOmEQq6aXPZy2DQPsU/5dlZLCvrgPs+ZXwIhANjLZhEP6UaRHKc8WY8h\nhGBMu4Ws6wmTVrdXz0QB009y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3083", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3083` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISATv88EvS0BbDFVjpkWpF3apWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NzQ0OTk0LTZlYzMtNDQ4OC05YjJmLTY0ZjEwZjEzNmE0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDg0MjQwMTEtNjdh\nZS00NjE2LTg5YjEtNjA2MGViNmJjNGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyHDI44bf6M+EUT3OeF+THeZvBEQvnoUfmAVfVCHdKlBX1AuY/IWwxPFtTptB\n43KmOmNNRmNJuEPDh3EENKe+t6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjHrw+1Z6DbKrYxJh4RAX9icFr9QwHwYDVR0j\nBBgwFoAUlyyPX/96r4b8oeVe7n6/i8DrC2EwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGCa7Rae4jmzNzFwIN/kcgDxwS8lXZjF\ngyNlswIIOVD/AiBAJoAsYrGJz46d+L6Q6fuvTeZuUW+EWw1Qlyz/aZhLYg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYKScancixieFPrphheUdJ0cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzc0NDk5NC02ZWMzLTQ0ODgtOWIyZi02NGYxMGYxMzZhNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTUqfuA6aoxV9iX4rSDrLM8IOIQA1Y2NrONQRKQEW4Ibky\nOVXf1O662/kv0NkSUrLG0w8NWiVrixUKvkdVOHRlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlyyPX/96r4b8oeVe7n6/i8Dr\nC2EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAND3VxYaa/QFC6G0qXsH+mwxC4cuWw3i4jGFBdS8a8cFAiBwxMmF8W77\nPa4SNkwfELQRy3OEEKl7xCHYCTu8Q/gUWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAV+U2n+CkAjWfVGAHo49OU2ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDg0MjQwMTEtNjdhZS00NjE2LTg5YjEtNjA2MGViNmJjNGJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNWI2ZjExOC1mNDYy\nLTRiMmYtODVmZC0xYmI2ZjNjODE1Y2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQK1Q/JJqqqPaZzoyby5yyvpCpw5zNu7zKEbi59a2Mg3beiUcqnxf37oWAy13Kx\nqmY2lNhCXSr2MM2db6Su1IdSo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMevD7VnoNsqtj\nEmHhEBf2JwWv1DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAS7\no+mE2LZjYOMl4rvScveL9MhHezO8C1JtHUVWESL9AiAWlCG0w8g5EcJIFXyt9Hku\nerwN4t9z2pm0itZxAsln0A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3084", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3084` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAbEhcn1aQvUlogv2Acl+v1NCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkOTc0MGI4LTdiNzMtNGFkMy04NTQyLWRhMTk4ZDI2NWU4YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU1NDc3NzYtMzY0\nNi00NjQ4LWJlOGQtY2FmM2EzMzE4YjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDrkXDN1QSIx16fNv6perkA35RdNXhms5prrXxQXp3oaFeyJyb7zXQ4IqlPvp\nO4WUB55fTPOdNwG1e/twX4oUnaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX8BR5ydv1cnt6197MNpBY4a0JakwHwYDVR0j\nBBgwFoAU5j/D7iImNRGBeFWRCb8pI4Ha9VswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIFkPY0AR7UVBV7MPZz4+dMnmaaP83zG5\nwkQghD2GgZPlAiByfspTA7stvpGOqZFVXxTevqVyhUqvgpbAHeChZh+5zg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV5lVceim5D+JU6xR9e5hUn3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDk3NDBiOC03YjczLTRhZDMtODU0Mi1kYTE5OGQyNjVlOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrYRnkp3rZXt0iYH445y9VE1i1JvoVpToi9/UB/us+WKyT\niD6CqflMqIYC2vbtR3PAlP5HmgQVE5aip6Nt7F7mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5j/D7iImNRGBeFWRCb8pI4Ha\n9VswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJf8C8s6t6a8EJB/DoWU7hMPouRFAIb2boTdUr9/wo/2AiBpjiuqL0Si\nKjP238bT8WOsRsMxPEoM9qCGihbXAzmWow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAWLD1NGhPAIa0VG8LKmzmfBqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU1NDc3NzYtMzY0Ni00NjQ4LWJlOGQtY2FmM2EzMzE4YjkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4N2Y2OGM5Yi1jNWUz\nLTQxODYtOTg1NS00YWZkM2Y3MTI5ODMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARWQCZimxxqwca+yxY6/dmAeyNXNSBavJMQNhnaoM2+lX2ZZVhpQK3mXkB2Otf+\nqHEvbp8oeolpG1UdztPUJB+Ro2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRfwFHnJ2/Vye3r\nX3sw2kFjhrQlqTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC2\nWVY1jDcS2YXTPUFvWe4K+dKBMVpMrCsNCCgQqJwK3AIhAIY/qny2ooeJbaUg/qQW\npoX+KP8NrGkB0cpNpNlSeI/m\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3085", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3085` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAYT9PAd+ZP4QvorJ6De7aLCFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkOGM5ZjViLWYwZDItNDE5NC05ZjBjLTk3NDEzMmQ2NzA1YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE2ODhjN2QtMjhl\nYy00ZTE3LThhOWMtODlhOWRhMWRiN2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5o3bjXnnDj69DGZLWDZ09tDz0mkWeew6PYPMiaR3RlGonjtIFAQxsb4BWNtP\nQcA7JpAat1HqpPGN9mw5To8RmqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLB7mpdpuQffO0GhGtVJDwz5bZU6MB8GA1UdIwQY\nMBaAFPCxCnAvpkyRHRd8viEaEUgKytn5MAoGCCqGSM49BAMCA0kAMEYCIQD2jb2f\nX0tl6yZYW6y/VkhLUy3ofUtqFrJ32+xJKP1cFAIhANOeqQeZxbS7TVExA0t+4ndA\nkk7Ox8oCPkt0fL05qbDJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQWGUWYjXKg4bh1nn80VFGyMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDhjOWY1Yi1mMGQyLTQxOTQtOWYwYy05NzQxMzJkNjcwNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIHR2nT58KwKp6a+f3dtaZOsxWA4j1lYkwy4o8S/b+Cbpy\nw+qHP7q2kAg6pnpwOhsuweeAxIatoCo+LKNEaEWZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8LEKcC+mTJEdF3y+IRoRSArK\n2fkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOl8lzIy4vnJfdv3OmVrh4jLhAN9xC/HQfxlH+hdz81EAiARqubFauqy\njjW7y6VZWgFGZTdBpCPBmvjV01ue/NEYXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAb0nsIqeoFL8ObgzxgxqvDIsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE2ODhjN2QtMjhlYy00ZTE3LThhOWMtODlhOWRhMWRiN2E1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MDM3MTMwZC1kYmJi\nLTRmMTEtOTRhOS04YTVkMzIxYTY0NzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATbwA9QGTj/pyIq4jx7gzbTKrWyDRhjtZ5xaH+3Uoxx7u9pCKrYBZXxkdUGi3zX\nSoCKiX5zVk3rE7EL3KrGXi3no2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSwe5qXabkH3ztB\noRrVSQ8M+W2VOjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIEWA\nnDGj41PxhLyuGzBynDcfKCD3S6EnLuGzFAsjWNZIAiEA6VveuQG4DfGxS84G9JiY\nb4H2h7ccqFRg2FaA9IAUBXU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3086", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3086` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQDNnbJpDr7Sf9xp9Ttxw6azMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MDg3ZTI1LWVkNzktNGU2OC04ZGQxLTk1YjRiZjUxZmQzMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVmMDk0M2QtZjQz\nNS00ZmIyLWE2OWYtNDk0Y2I5ZTQ5YjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Rq5vTKC7Di0phgC2hUrkIjxXYwCzj7qM0ePmLWFYQ76EqQPNQ08Q9k96X/N\n1QodZA3wuWpkZWKZe1wEDo5/8KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAb2Z+5NUeMmEbNgh5tqMB4L8UEbMB8GA1UdIwQY\nMBaAFMno3kSTvP1fGO+1E65le+CoyxXJMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAkGwhuobnlmzZDGcyrxgZ6DNQA2LzCBL5\nKAWVOSTMvloCIELlj2wgkMfSAF9zVd4MNM1BIGx6alFx44W/V8bu+1N5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcO7yczWhaHTzYlwyKlLUBqCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTA4N2UyNS1lZDc5LTRlNjgtOGRkMS05NWI0YmY1MWZkMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQp5WKUv48pDTvVeAB8VbCicC8EoVJZz9psRMdh5RI6gc36\npLxKMt3f92MEzg+HCHQV3MIqdJskjUyH3MK9+aqSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyejeRJO8/V8Y77UTrmV74KjL\nFckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTgtnzCRUxOjpnLCN96W7fs4CITQZgL5qUUGWXF89TD8CIQDokcZr8z7v\nxXlaJ5IPXO7b+8MB1nvBYbr/NWtjqNqaBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAZDoX/3CN0vAykg6X+bHxeGHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVmMDk0M2QtZjQzNS00ZmIyLWE2OWYtNDk0Y2I5ZTQ5YjAxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNzRkMTNlNy01ZTQ4\nLTRlMTItOTczZS01NGI4NTUyNjAwZDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASy9rq2JiTRDABIgiN6tRBsOErT6w6KYi3ttrZez9cOhYHn9f2bonbzjPn3wqlC\nNCsy34tm1zfJBCp5fhyHxjewo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQG9mfuTVHjJhGz\nYIebajAeC/FBGzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDG\nbgu5R4ENH3YvZp3NPbrlg48jHt98boCHkZ4judCmbgIhAMPb1pULd+5j2NTxsZZ5\n1x4ejFDcdqQTkDgQf2c4mcWJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3087", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3087` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYUBJ7WjWz19CW8qtkFZKtKoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlOWE1NmVlLWJjMjMtNGQ0NS1iNDQxLTYxODIzYzBmODM3ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI4OGQwMWEtZGM1\nMi00MGY0LWFjODEtMWZmMGUyN2UzOTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqXEIK7io56V7/7jVho73+Mwh/yhDekAK588JbemM33+M9L5K1o0n+xeGogfx\npxZygngVNPGQejAgYIlnQys6P6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFKyU/tyuwHxfgMO67PriKgrZ0/sMB8GA1UdIwQY\nMBaAFLXblIFY/M2sZFux6VRaEDdCCvgOMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBTlThoGHRkEpEvIBDUUHwIIb+8+tsOEGe/\nZEcV7nV08QIhANyJ2ODQiEb44G/OM7UwLIa9s/bE3aoD8rfFaVXOFHqv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS3Q2glueIBsHzs4DTiTM+NBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTlhNTZlZS1iYzIzLTRkNDUtYjQ0MS02MTgyM2MwZjgzN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgnCPpSa5w2vKAPwBJbzuXAq5DYk5x72JjEmAJfx03lvVc\n9VHPRiKODg5SE2Jg6dc+U8LVcRzsLZeAyIOzs/Tgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtduUgVj8zaxkW7HpVFoQN0IK\n+A4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdxKmUy+0FKGFi8OFkkZsQqNwXERIJbuGwdKyV/cM5P8CIQCGwVp8UCbY\n8z0LlqsKDsX8pmJiZ6r+Dj4ES0sSuUiCwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAVWBDVwXnm1gU8HRU6qLkgvxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI4OGQwMWEtZGM1Mi00MGY0LWFjODEtMWZmMGUyN2UzOTI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxY2FhMmFmNC0wOTJj\nLTQ5NmYtOGY3Mi0zOWQ3NTM3ZGNmYjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATruLjtmotcEDKlK0rhekm3Xua3omfV1ZtK/yShFcVpea5njD+lYQoQBIH1V0Cr\nqZ/TGQTob+fIRKLd/zcEjJNEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSslP7crsB8X4D\nDuuz64ioK2dP7DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQC2\nei2GxAcrlvY2nVxiPRtGrJkdxL3dIc6PGcVd/91OgQIgZ2ElXx4m7LwpE8J+VaO6\nTsO/uIrsLvEPMrvTlhiArV4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3088", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3088` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAfa5OO8035d4yxeIhlcGDKsGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyNjY1YWVjLWZlYTUtNGUzNS1hZGRlLWQ4ZTYxYjhkMWNkMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY5Yzk5MDgtN2Iy\nZi00NmQzLWE0MTAtM2E2OGM2YTU3YzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnPEbMLauGz/7mHbvI8rTU1lomXoLoViZIHvYzKhNz83bn5w+0pwsTMRU1yuq\nkmGnQISXAz4Nst/AznSkjYXBIqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRz/nufunRK0r4mTd0hDjMKgRbogjAfBgNVHSME\nGDAWgBTcZrm13NY/lOJZOq7uwFWIWMu0ezAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIACBpRVurmfHqEzqI2JVzlNSW80cdqbQ\nyrx3cw6U8GJRAiA/49DpAIYdNhJeebOUI6k8w3qjI/TJQe2HWl6BowEerw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcwQCIGhuc3imEwl+9rAcLkQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjY2NWFlYy1mZWE1LTRlMzUtYWRkZS1kOGU2MWI4ZDFjZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvddvCC+Ojf0KW9Xc8VnDbpS+ib+a7UppzpEGwr4Ya2o2s\nktD6Hy1zKFiFWTxoCqx32LiOuFgGjNfCE3pW4a0Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Ga5tdzWP5TiWTqu7sBViFjL\ntHswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRlPBhpmAOG9GVm1wz5QFAVMUp028427HnDn9oXloo00CIQDHuyLpVfbK\nzx7nL6K+eyqCdACFnzrhdN7L/a0ILU2Ixg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAYAsB1/uxIPliri2ItOS8sj2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY5Yzk5MDgtN2IyZi00NmQzLWE0MTAtM2E2OGM2YTU3YzY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNjg3MDA5NS1mNzhm\nLTQ4M2EtYWI2OS0xOGJmNTAxZjk5MTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATeGKupT/zcpVCUllXTk1iGB8gTtl6Dbeyk1DknQQs4MttaWzB5GuGgHkeL7XUB\n9aHvrUi5QbbbUQO0uCjtIhZso2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRz/nufunRK0r4m\nTd0hDjMKgRbogjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQC2\nEWQmgVB8Wkh9Tp1e33try0zTew4sZfsy4Vfgkfm5UQIhAOROtD0+/ig6p5cyYqho\n0VoqGp6inzA0XUJs5udtbSPE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3089", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3089` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWSIE2L6ER6Vy3uLFDHy/f9jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2MzJhZTM4LTgwN2UtNGExMC04ZTA4LTIxNDc0ODBiOTgwZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNlMzFmZDQtOThl\nZi00YTgzLTgzZWItMDM1NjhhZDExZGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq4VKMObtGua6eal67SpU4VIw5wrGsueqYKifjdUZ0/bYWI7WANdqFaqF15gh\n9zpDRJ/f/s0UvMXk8gOdKkJlM6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUatKv8doqBytvFrA56S3kWgziiUEwHwYDVR0j\nBBgwFoAU6WVmJg043JYmRHFTeFEVeSczaFcwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBcoi2y7glAaAZD\nwR/x/FwZEvQ5NhGNQ2iuV9mB0dThuAIhAIJ0ugJDyJbjvCcgXizvPWUReUlua+yP\nblpBNaDTssS5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa6p13r0fmz+mSlfEDMk9C4XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjMyYWUzOC04MDdlLTRhMTAtOGUwOC0yMTQ3NDgwYjk4MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfZUcEOWgkUFGTWymtfGXIKbWfnkGQsnIW/MOLiZ+PmNne\nAhe7rbuYEEeleCIXGsLoAhQOO2xr8AHqqS+SEfgTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6WVmJg043JYmRHFTeFEVeScz\naFcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD2d9uWc0GYWxd6UtTYZ+O/sNa9RkQXXYLLsrSqNNvaQCIQCRDY8qIxFL\n3juGrsR1bVBZV0gt/mcY+O1qWm4WI/dzig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAYYOpURjaBrrLl1OKjw4cQeNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNlMzFmZDQtOThlZi00YTgzLTgzZWItMDM1NjhhZDExZGUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYmU2ZTI5MC1iYjVj\nLTQyMWEtODY3NS04YmIyMTcyZDYxMGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQPjkqWD9EFbgJmTYjv+M8eCn3UynLkynLyEDMs+RcKc006KSsNyp4mV+wEYPIY\nlzdmTp3HJY1VWF693KFOkA+0o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRq0q/x2ioHK28W\nsDnpLeRaDOKJQTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCv\n2aWn8cx6kNcAAXYEAH5xnLQRUYpDKLQYhbzBmigaFQIhAPGWq2rEIYwwl2gBrctM\nNNJWDjjOS7jRrIiasbGL5lJn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3090", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3090` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAevx7RJqBgoO8qC5qjSzgPh7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4OTM2YTEyLWRjNTEtNDQ5MS1iMDdhLTY3ZmQxYmZmMmY4MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZmMDA3ZDktZTAz\nYS00ZTBjLWFmODctNjY0NjJlODQ2OGNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo/9NZlrA/WGTyTBRe7iEcAIwc2G8MgNwRXcI9ddrj0qW4vDho/m9Ko/zW+cb\nu/qTRp/qygmz2krz0RtGrJZNDKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU85jCbZp7Z2lLDez3CmaJ3gjhTJwwHwYDVR0j\nBBgwFoAUMw7JoqDOiXz8F8hnRdoAxHfDyVgwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA3G03A6tti+Zv\nm8haWQmF+tkNtzEQbcakcMtXDa5niEACIGdVxwFxGK5sPYsAPsukANCZMgu1o5/f\nf5y+pUbRlr+3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYyjMUBY8kR03vsxVDIkl/0MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODkzNmExMi1kYzUxLTQ0OTEtYjA3YS02N2ZkMWJmZjJmODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9yaCdz6L9yshmhW6ZsoIFQJuKjuemrvMJcpTULjhyWsaO\nggYiL5F6ztHvC0MIyTJeivpNXivLDqK+Qqou8v6Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMw7JoqDOiXz8F8hnRdoAxHfD\nyVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALUei1e4ZlpcyB7i5XmZ9l2y3Ns9HDl3hlLv34+YPoAsAiA0win9OlVn\n8KJ4TrUEujvV3HTDTHfPaixi0B/RMbYXWA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAUYbkr9kflQXtJXQ2qivJJiBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZmMDA3ZDktZTAzYS00ZTBjLWFmODctNjY0NjJlODQ2OGNmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZTE3YmMyMC0yY2E0\nLTQyOWYtYTNkNi0yNmY3ZGZiMzU3YmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATCvhTn0deBUhoAV/ZPhpYbKkr1R2FfcSiGPeNNwbafgwJODUaLNcCSiqWqOmMW\nLd/hPGnReROp3DG/6sX1jyOro2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTzmMJtmntnaUsN\n7PcKZoneCOFMnDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCK\nCbd5Vvik23uZxMhZcWAB7H8UDF5bV3rJO0LPeWsbPQIhAKtdOx9VxuGuCfsrL+hc\nZnsY9k5yywv/fKNBNOXI7a9V\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3091", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3091` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAbGuhAL8Kyw7g34biCs8aY8SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4Njg2OTZhLTVlNGItNGViYi1hYzZkLWZhN2Y2NTUyYzgyZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVkYjA1NjEtOWMy\nMy00MmM4LThjMWYtNzkwNGU5MGZjZjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfSGFOok+3pl9KCZGNia4NSWLwZD0gTajciY8IO74qoqC2Hol8bVdHMuAZ/tu\ntUfznpKumGZuMI7aTC0lLvHSFqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWlDYECSCjdMvW8qFKiw68iGtA60wHwYDVR0j\nBBgwFoAU1LRBEhc/UTkSvpvUSX2wHU9EsJMwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAi93spTWfjg2KzGCNlBEG\nH6yg0fteHSLF04KEJZaA3iwCIHRLmAFFM9UOKWunb2QFB/do108YOBHDQMUmfSUY\nsiDO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATy4PZOeJyBbw7lFBn7BTYfJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODY4Njk2YS01ZTRiLTRlYmItYWM2ZC1mYTdmNjU1MmM4MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQev4UG6pOFWPqBKjTmKuONmhXCULD/NLaPw68EMfZHkwkc\n/rD/M4L/gBNhgSled4xYkfk8Sf09Q6E3cks2GHpoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1LRBEhc/UTkSvpvUSX2wHU9E\nsJMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI/l50NdcCJGp4S9KvHHaodV+Mk+RbIDoYbTR8mrKFTtAiEA0oTqxXhP\n6K7gBUzhNK+7H+gV20xwCJrQpzXuHF46s94=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAbnoNv0XuXCkgfy7bTKQvb6DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVkYjA1NjEtOWMyMy00MmM4LThjMWYtNzkwNGU5MGZjZjQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyOTI2OTA1ZC1hYjM5\nLTQ0NWQtYWExMy0wYTE4Mzg4ZjU1MWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATXP6iq0iH+hpt//pRDY5D9HFhgwcdgKyh451p3OQ6XNNuIWFJj+5iaWhIUhfi2\n+IFgHoPNtZKUjh5rGpKEK/q1o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRaUNgQJIKN0y9b\nyoUqLDryIa0DrTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQD0\n8Fmrbe02GaNH8beF7BP5Z5izKmRZmxBQcSJoNBVgDwIhAJ5E2Nw2+SXYljBgo0Nc\nNYv+COnGhEeHYC2Cx5Xrd/9i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3092", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3092` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISATVUoOpElzhE77am0eWNxdjzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNmNkMGE3LWFlYmItNGMzNC04NmJlLWM0NzdlNTRmMjE1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM3OTU1ZDUtYmEy\nYy00MDhjLWFmNDItM2JjNjE0ZWIwOTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqJLa+kafLeLKgWPi/anyTKtQ6YnQqQvKZ3wer+SRhP99r+CFo0kNM7bH7Ptw\nwgF+likcbiEy4cUDNpZ7BgDxWaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkHXLxURyBL9fz/6XSqzCE2bEhWEwHwYDVR0j\nBBgwFoAUCfBmX0qQxTLjFSTFaGCrkDfwIzYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA0cwm\n3EvKkXQwpTolnPzihpWD4wo6fvcBcKEIk0/pcKQCIQCMn0Yfz7mrX/EyWscythJn\n5AC+J8RMAXsPJ6U2BF8H6w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb+HcVGCY6nE3qI9jTSiMgqtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDZjZDBhNy1hZWJiLTRjMzQtODZiZS1jNDc3ZTU0ZjIxNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVnFmwyQzVoOI+1Ob9ThHlN5drO4sM5dSyKsWIPWKUuw7N\nf5WZuBJQxV4ZO5LPsXrq2Chr3MzI9gr0Y+eE0PXfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCfBmX0qQxTLjFSTFaGCrkDfw\nIzYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd1ChVWjYbEo1NjzZiAPmiTgGSS0xpeaTkZs+FOriSYgCIEYJJLqhF7ey\nMarE+YJLtSY5IabtzeIsOp3AjecTiK9N\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZ4K45TGb1zQPhkr4SxAhnRbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM3OTU1ZDUtYmEyYy00MDhjLWFmNDItM2JjNjE0ZWIwOTIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZWVmYjg5ZC1iNGQy\nLTQ5NzEtOTBiMi03ZTQ0ZjNmYzlkMjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARN0SXyKLaohRD5481XNvES2/vhcU3NXZUCURAmC/9AgGngW5Jy2f3QzBCKmIgx\nc9P9/3lQR4iUzBDbi2Ue+NW0o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSQdcvFRHIEv1/P\n/pdKrMITZsSFYTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBcW\n+wNGYDJWSF5E0/UaepMepQvlleeKas1urHqj8BPyAiEAj1hTtQ3s5/ru1VpLTwzw\n7CIjkc+Wr3R6hKyduQw44Ak=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3093", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3093` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISASBIV6yBkAqCHkVrOFDvJy1HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyOWZjZmQxLTQzMzEtNDZmMi04ZmIyLTg4ZWRhYjk2OWUxNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg4NmRiMTEtMDE1\nZi00NTY3LTkxNGYtNjRiNjRhM2NlYzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8KiGMmKkHx9eJDpZBncy7nyX9mD2xd3pw7fwxeqJyBrQwBs1qVp4LPrqlB5+\nkI2H2nAeC1F+qkLF4h3j0m5wxKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKyqomu2jcg7DWo4RwkuGwjYkdvQwHwYDVR0j\nBBgwFoAUlJTdPoX+MGUEkmrUypd9PRrJPIQwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAqk2f\nW88p/VMM8lvDkteUm6fbcoXyJwpEVej4GCnbAwcCIE+3rgAkU/srk7f5bgPm+K3F\nJmjEwtXcQNtfFQGq9Kcs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWYZFwJFwzMLr6kWkVH5vTEeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjlmY2ZkMS00MzMxLTQ2ZjItOGZiMi04OGVkYWI5NjllMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQydOab3lIl9XZK2ff7hzhhep2Nyl36AgyfgtU/bTyjU1Hg\nxnJDgFV/grtg0E0Y8sMZqLpnY7mPdPAFGkUtvoJRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlJTdPoX+MGUEkmrUypd9PRrJ\nPIQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfOzWQVU2/c0vKg7vK8ZB3F5cbvAZVo833/Dgn7HkgNgCIQC8vIVixVwz\nUhfaFW0QQa7F4rY3FeFXyrZCKv23urysnA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYncBFZBJ4j2B8+egU/VCfCwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg4NmRiMTEtMDE1Zi00NTY3LTkxNGYtNjRiNjRhM2NlYzE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NmFlYTE1OC0xNDhi\nLTRkNjctODg2YS1mZDA5MmQxNzVjMTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARo1mAd06XVAfcuiaGfr7FjpDIboF8ccpq7M5rd6QQK2hus0lVwuIEtO5fL/l/O\n+KLq5FHiRQ/H3s9kY7aceG21o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrKqia7aNyDsNa\njhHCS4bCNiR29DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDed\n4eGugO3EuQJTWfzEr7/lQG57O9gpru1Czhu7SPodAiEA4f3pzYR8Xqm35burWtph\ndUEkLyHQpGQB+/KdqrLXKGM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3094", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3094` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAfrGfG1JuOyho75YFI/k/VyUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4NDkxYWFlLTQzZWYtNGY3ZC04NGExLWNjYWE2OTA3NGNmYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzEwMmJkMTgtNDM4\nOS00OGE1LWFhMTktN2E5ZmFiZTE0NWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH/YX6dOYR80oM+lhAvN/yyJ59nddmbXt3OmSVWQS9e7BQ8BduYV4F5geLmPg\n1PdVhPTgIQuK1d30Ym65Hq4UmqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFETxvqgEyMl1kebxrTJE4vN/Pw3YMB8GA1UdIwQY\nMBaAFFrDP3kYuksq1MLJX8VTlRmQA4DvMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAGNnnNABSryJdT0/VSGgHK1pZXCc75Z3QT\nb31QA9PIHAIgVxmepm9vxxn5T5kuyY3Hl9jcJOuSAgu6ex1ZthnXQcs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf3bs5lruUBN7IChYboz0zN5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODQ5MWFhZS00M2VmLTRmN2QtODRhMS1jY2FhNjkwNzRjZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASz/ez2GcT7SSBtXWzNWcc2sEmrazu+MK5oNne5ashp8jZB\nThQTmyUIDe33D+YHZQzllMhnoPfUIcaWsTAo9xF3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWsM/eRi6SyrUwslfxVOVGZAD\ngO8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPGkmEDK3nbsBNi+yyGtIl5WiJQP4YWOvqccbMvdgfQEAiEAhz/Ie/O0\n7oUAKxuICmlxBKuNwa0bnTuJZffTsLQtQ+o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAUscFz+9qQvIruPJYcwgSgf4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzEwMmJkMTgtNDM4OS00OGE1LWFhMTktN2E5ZmFiZTE0NWVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYjVlMzQ0Yy0wYjcx\nLTQ1ZGYtOWNlMC1kZWFmMWJlNDFiNjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATY0kIcWm+adX+njqnr5yV/T+Jkct0dObkfewG0ahsIxx4sBJbwtRb5LXbbQtok\nVPtJXLbSIloL+I3Rtyw++QYYo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRE8b6oBMjJdZHm\n8a0yROLzfz8N2DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCH1Rm\ncapoaSb9GlOw1A3wl3ZiE/blvUQATqrvsEW00hoCIQCKXO8fNsznfqzve89g7ieZ\n7f8fmHzhF4fHeZML0dZF4w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3095", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3095` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAYyBo6f1uLaNMk7/0LpF38xPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiNzQ0NjFlLTA4YzUtNDU1Yy1iNzIwLWFjMGVhYzA4NmE0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQ1NzhjYjMtNmE4\nOC00MGFmLWE0N2QtNzMwZmY2NjI5MzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERPzMBW3Pl4mcAqk352oYhzc97hHqa2UA+7bP2OM7RYhI4oWqnP7MuWEKasol\nNfm+GOYYFUYLJPGFFXrpBY1qoaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpjZ8SuiWjCbQDoS0Ytwa0OGONP8wHwYDVR0j\nBBgwFoAU/wIOPVYIjyit3kv002fVPd/6QegwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgLGVsOGGbjECR\nDdWz/n52e/XaLbqa8jTB5NFyTv4iMx8CIQCe5lu8ByR9GpLEVNggbsDA9dOEfgcn\nquEN1LZjVUJYzw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfKxIImou454CXAOo7ty0nuCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjc0NDYxZS0wOGM1LTQ1NWMtYjcyMC1hYzBlYWMwODZhNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm9ZXGj4E1wlaKqvnV8vwbuDfoj6Mk41If7msjRRp2g9Ih\nkjOJBqaqA0vsuHOCdMwvc/Ff7b6PjnAWM1VMWnq1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/wIOPVYIjyit3kv002fVPd/6\nQegwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKDarMH7AhReGz/67nBjpsKekohCEScmcxIziMegcfuoCIEVUkDq9M5Mo\nCJ4CGxvturZUbD/pGtiTML4LTw0jhROI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISATlH4MzSTkr5dZZgrg+gEzwtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQ1NzhjYjMtNmE4OC00MGFmLWE0N2QtNzMwZmY2NjI5MzgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NzBhZmEzNC1mOTIx\nLTQ4NjMtOGJhMy03ZWM4ZWRlNTA1MmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQlM5+roZc85jBoqubRBJ6dJix5EDopQSOY+Pw4EEwbSLm05Ix6BuR/lVmcTkvc\nZ62HaPB+GxU4GyYE+QuH7sROo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmNnxK6JaMJtAO\nhLRi3BrQ4Y40/zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCr\nTVYiu73p9GCeOUGfda6itkLHw3qvkqO5z9ivGVMGhAIhAImbu84i7O1EH3HSrCWD\nefYEP0letW9qMA9rXPbxfQoz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3096", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3096` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbI0tvshXj1ZktMN9+Jo8IP+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2Y2EzMTQ5LWVjYmYtNDI4YS1iMWVkLTFjZWVjNzRmNzU3NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGRkM2M5NTktZTli\nNy00YTgxLWFjMzgtZDYzZDg4YzYzN2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdGPjsbF1P4KRuzgLWf9XvmL2g9s2eqgB9CYDe1sV0bHCr2hw1L5RmCA/PKTY\nWcKKJJPoYfAeIylPQJ/RllIZKaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1UhyQtxE4+5GRXBoNUUPdeGb7bwwHwYDVR0j\nBBgwFoAUxQxpRfciDtO3ShtMQSnv53qp4NwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgHvbyzpYOcGz5\nwMokCHe4mha5yL1dkTsvYZWHxcG8mroCIQCYg+8cuNvqx5qWLlZ2gMxVFGLml1QW\nJnNxYzk2wZiSyw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfpH0RKXD0oz4jq5IItwZOf3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmNhMzE0OS1lY2JmLTQyOGEtYjFlZC0xY2VlYzc0Zjc1NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLIU5B/HtCmP9KSEKiaiIc3Oc3irAwyIt1u2miU/XD7/MM\n8omdKpWkCgU1UNaLePEHAE+m+94Cbah41TnqyWCmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxQxpRfciDtO3ShtMQSnv53qp\n4NwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdBOonIlp+LIqZ72jAwSimeTAjd1tecbU7zCFtBC56GECIQDkTDS8l3BH\nkSYmakruKvF3v0Bd+Og6ms+ZRZAcvyv7FA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYpwvcoUkOVFwXyGqYZHU6ulMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGRkM2M5NTktZTliNy00YTgxLWFjMzgtZDYzZDg4YzYzN2U5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2OTAwNWNmYy05NzJm\nLTQ2YzYtYTFkNi0wNDFiYWNmMTg1MjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASaOZlzACGN5qQ7mUUW0M+GVtl/aURKsa3diF3T0kqR873NtwpHtib3vqBKF451\nQF93J7uMVfiWMQVkMlzR+Mgno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVSHJC3ETj7kZF\ncGg1RQ914ZvtvDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQC/\nU9y7ehSZHDe9FFwEW0E4VPb5AyLR6VWkA38pzez9cwIgYEgrto5g2z8ujb76j9Wt\ndSJQ8NMF/Z5nY5gut7KDWik=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3097", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3097` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYit/FfVLSe4c26S4WZD/zrqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxZTQxNjFjLWZlYWUtNDU4NS1iZWQ2LWQ2Yjk2NDYxNmJjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzcxZDRkY2MtNzEw\nNy00OGJmLTkzNGUtMDI3NmM1MjNjMTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGAzIWUPixKlztyCZrK2jzc4vk6vFBRcp8PZf9I1tXYrWy67MJTs5gFeoORlK\nZnU95oumeGbODNsqLjDkpzlZC6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULtzS1PqpLHlovShT/l8WHJcwijkwHwYDVR0j\nBBgwFoAU4OoBkEbzSyWri7pKGRLUm2ihEPwwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIExr7lvkq2jZ\n9VozAm40AAoSJUE4otLlDYmdF9R+HA0lAiBzR7cdHDaNyPbsCUTniORaBM7bvQ1A\nTNR+paJKvxvFWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS2GLe5btj7q3sfdi9MX8U7KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWU0MTYxYy1mZWFlLTQ1ODUtYmVkNi1kNmI5NjQ2MTZiY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMc5JsTIH3ARaPFwHv2T2+a2LuzdFhvwtupDrZMBpm9AK+\n3l+Io3ZgNXEoDn5f/xZinD/cBuLmH0wG3IUN7ILSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4OoBkEbzSyWri7pKGRLUm2ih\nEPwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAqSw7XLBrW5dKiE64lGVNGKAMW1rM5/5Ju0cVbyG2kYCIQCjwzLcS4V9\nfxf1ib4JLVmSpkhYRTCq0gJUwvXneLSQ6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAW+f0OTEOTgt48WFceHrEyuXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzcxZDRkY2MtNzEwNy00OGJmLTkzNGUtMDI3NmM1MjNjMTE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhY2RlZTI0NS02OTJh\nLTQwMzAtYTRjNi1lZmZkM2Y4ZDQxNzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASEe9aVQ28jf3w6srD0cehIiSmqGmQhlAzDHktUPDVr0+PZPj3agO9nmGq8djXy\nOyNTZm3+CzRV2o5TmHFdVZLko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQu3NLU+qkseWi9\nKFP+XxYclzCKOTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCz\nmy7xLmxQgKekZ0MNMfWDklVyQFkZPX+RPFsx5ZCOPQIgBKCuy2EDeXV5mDJ3vgFf\nNS07na6s4mKyYzUuQf6fdPY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3098", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3098` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbBl/7MwdO6lHI/NaEyRnxy/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZDc5MzFhLTgwNDEtNGZlMi04MWNiLWY3Y2QyZjgwZWRiOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ3MzFiNzEtMGQ5\nNS00NGZiLWJmZjYtZDU1NzY5Nzk1YTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb6V/gx4NgMH5VqzTA45zQVuR8/5+4M+ksr/YHTNtHsrUh6D7j5tsig/8EFpq\njjrFy59DEuy62x18e7vlehkAXKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtidLbq9vmSGwnUEClkn3Ek6/CyUwHwYDVR0j\nBBgwFoAU2byLmZECAe8nhu7TGMbtLVNww0wwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCAHCAq7iADDBWEWn/KvsbZNZGSeQjD/1xVkwyFFsWvkgIhAITcvGkgdOsa\nG1gufo/W8EL003VXG30z52I/R6JWvxjj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQdjTi4cfr6F1GyAIDZEKEBYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmQ3OTMxYS04MDQxLTRmZTItODFjYi1mN2NkMmY4MGVkYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrrojW2b3NLsAaZYWJFpoH9EJWIUtLK1wvT6cKmwyJTN64\nd+f5KB19TAwLZxtWHWBMFqD9yVLok2MSxffz3MVSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2byLmZECAe8nhu7TGMbtLVNw\nw0wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFCq77lH9RvVORev9j+xdNxgnsVpr0F1hrzefkd7ObtgCICZUY4jokEsn\nr9It2ZCs5AL/4OBhA2hebAnH791gWfrD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAQEdAOP2iyRLpr48s33kO+ZoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ3MzFiNzEtMGQ5NS00NGZiLWJmZjYtZDU1NzY5Nzk1YTY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NjU2MDg0Ni01ODU0\nLTQ5NDgtYWFiNC03ZWEyMzU2ZWNhZmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARjlVlYGlzeTJxiHodScenFuPQUTkRimKaub4x7aH6gyLqU5ZI5GdDqxOnmgU5N\n34ynm9v5hqG6WIml2hrx1ZaAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS2J0tur2+ZIbCd\nQQKWSfcSTr8LJTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDr\njj63FnEyHVoEp1s5WKQTHrZJNfShkWVBlqltVW21nwIhALD+ruwUHHvcpB/m9DrO\ncEhZNcSiFwkpsKnPqpjsAg8P\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3099", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3099` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVyBn2Sguckcltr8sljTJxUrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5ODUwMTg3LTc0ZjQtNDViMC1iZTUxLTc0MjYyMDc4MjAxNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRlYWE2MzYtMjgw\nNi00NTA4LTlkMGEtZWM3Yjk5Y2UwMmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6M4tes5m3PYg+CpNAC3f1FA6ER88nAk9ou4YM7/Hr7/G+4BXoFMYnuD10jFW\nQkMHf3VhaMTjICYi5MCXAspF/aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuRD2U4Y7IiMEoBkdovG/FQbW7L0wHwYDVR0j\nBBgwFoAUpLWFSjE9xr4kNwUIWNvHNOwF0hswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDBTACPD3qsz8UFAJ7FGsDXaE0Lw65Gw2KY46ZaTe0M2gIgd0x+yAYU15kX\nWyYkpDFJ0u61O6j4wimAGrMQ/XyWbhE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVQ6BnXPZuV35qcrwDsscdRmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTg1MDE4Ny03NGY0LTQ1YjAtYmU1MS03NDI2MjA3ODIwMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHvaaTlq0vQQEpFznZEfOZbHSo6olzJ47GSjBlAB+eBDOw\nvvx91cls2hHtOYJOYm8zxXquOpieCyVf2JA5R8SLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpLWFSjE9xr4kNwUIWNvHNOwF\n0hswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAND4f3VWaDNv91hPzRM73Qd0VdiSPS919EhqBcMhIm2XAiA3A/OykJw0\nX2P+7y42zSY7bQtEfOybmT1LZ+yqDm6vQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAbem3PMU/4EygBC7za6PChlaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRlYWE2MzYtMjgwNi00NTA4LTlkMGEtZWM3Yjk5Y2UwMmNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYTFiNjk0Zi03Yjc1\nLTQ3MDEtYTc0Zi01M2UzODZjNTc4ZDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT63I6I0zRRZ+/1JwfjfmQqb+Zl0IOhzumN05zGECryNxI+MV9b/T2mRdVcCyPS\nWd9asMY9yuEr1aDhpRi+ECVXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5EPZThjsiIwSg\nGR2i8b8VBtbsvTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCID+x\nJvveooCgJDI+OZ+VEyxAQ71hObbutlyEJ9j1KPlLAiAGhG/iCmfg9+eBiYZivGjG\nP+iHhNQYQ+23zvYW80oiCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3100", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3100` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAS1z7MNatdKgvWad+RSp4GTsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhOTFkZmRkLTNkNDQtNDlmZS1iNGRjLTUyYmM1NjFlMzMxMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY4NTUxM2QtYmM2\nNC00YjNiLTgxNmUtMzVhYjJkZjI0ZDFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEArZLIoAjHEpEh9d5Ir4DfHHYz9Ta+5G/Nyy0MC3o8Wnflng8S8hydgCFedii\ngaa/epnaCGlloWEfuQcayQsti6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhdFsqVCKRINzWork1vJazgUFZnowHwYDVR0j\nBBgwFoAU6RkRTfxTErhLxptuSV/1FB5CtXswLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGeC\nCt8ZPrg8kAX8SZkTSoxUCwvRA3Rv40Cz3Jxqh8eGAiEAmv+U03TxgPGVurcGnaA2\nX707xv9KdCCBAfW6/GOW0oI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAak3fS2YrGSXjCLiFCYvp9oKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTkxZGZkZC0zZDQ0LTQ5ZmUtYjRkYy01MmJjNTYxZTMzMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtr7D+x97uGr0JpveGyX3uRRAe7qUg37fDQq4O+f2cVezT\nAU8BSbjBzug2EMs6qtpOkgaS9zSufG3F1RyyeFzyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6RkRTfxTErhLxptuSV/1FB5C\ntXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANccKNgxPjALZbcl/zj0fZktvI4wbKmMox9KwkzmaghnAiEA/ou6uTne\nSPErMFboNlunoYBxpFIHmsx/74XVknOogRk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbMlDcCXhAqiGz1CssEIBhH4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY4NTUxM2QtYmM2NC00YjNiLTgxNmUtMzVhYjJkZjI0ZDFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5OWM5ZWY2ZS1kNTgx\nLTRlMDAtODBjNi03ZmMyZWExYjQwNmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ4jHccLfjheiiiyjS0Vi0yPQNqLm8knFWTEKpRDSPyrManeplc1O/sdUR7M64M\ni+pOjVMu+dwM3Q8ryVKvI3SEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSF0WypUIpEg3Na\niuTW8lrOBQVmejAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAuG\nqP0onPeufJOkO5g/2Zs3kbEhhI61+9OIR3BUBPTZAiEAkDIePwwpX7RoTUKc71Lw\nph7ZUK5lfGMhRVJc9zG3ptQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3101", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3101` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQyuO/+/Nl+120T9m7Vq215RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMTVmMTU4LTcwZDAtNDM3OC05YWM1LWNiMzU0ZjY3OWE4MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjJhNGZkMTgtYmM4\nZS00NzZhLWJkOWYtNmI1YjIzNWZlNTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOvyijxaeGQJQTHsGc1cyo45b3KIEMUBKQuh8trIvJIv74TZ+uWD2Lb1+nNzp\nX5rU5jTJt6NuPT+v4gpGlL6XK6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW2ocNXiUckdxF1bAYON9mN+RzUMwHwYDVR0j\nBBgwFoAUItyhRlrnFZl8roGcS7i7XEPtn4wwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDqU+IQeSRQxY8nukwhNskjwXGM0sXUA45ijD0QJVtLzAIgWN9N\nHfPGy+clpwV49dKpXGNHAmrnZIE5/cuyeO3bt3k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR61ScwdquU3MLM1hEzuOZP2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDE1ZjE1OC03MGQwLTQzNzgtOWFjNS1jYjM1NGY2NzlhODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7vDHN384hwfq/b5gEgbZV5KRaizU0jj+jgplRnoiJa7yY\ne0kvE6oU3YRuC286i+AqSP2ZU2viLIrecue7weDZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUItyhRlrnFZl8roGcS7i7XEPt\nn4wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcSUAgjKb7Li864AEW5wKAnYX8KfGBdjGs6cGLmw2pYECIQDOpLTjb8nB\nY+I6Lt5/bw0T/Ug2rKDbHKoKFzyLM4XNbA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISARnscaqNBfo+VOUUnRVthL0hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjJhNGZkMTgtYmM4ZS00NzZhLWJkOWYtNmI1YjIzNWZlNTc3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMjg5MjVlYS1iNTdl\nLTRlMWUtYjQ4NC1hYzY5MDFjM2MxZWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAROHyqp+HEV8TZFOab6EM8WHFGBfOnlGVEH8mhMP0Z6v7RjMOBLvm3+CvGjsj+N\ngm7MsKQfm1cp6X8YrKNi0Roho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRbahw1eJRyR3EX\nVsBg432Y35HNQzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIH4/\nnRVTf3mdktYdq9jUxIP945gocAQrrsQLCBjJOPG7AiEA2rfbIoFgJQQd5wVISYiY\n5GmInyPG6zAzG8feJ6/3dOQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3102", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3102` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAT0acXbjMxqDvm5qQQsqZYJRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkOTUwYzI5LWE4ZDQtNDk0YS05ZjhhLTQyMTJiYTQ0MzAwOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZkMGY3ZTMtMWE5\nYS00OGEzLWIyMTItYzA2MDg1NGUyYmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhAh7xcMYccvemVRvTnRPAGf+DLmm4D7CaS3KUotaCGBgARrDFxFnC1EkuJVh\ngJemy/hexmQ99pWOwHf/2iQCNaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuWyXQ21wP8aoTmXUeCXy5V4TeTUwHwYDVR0j\nBBgwFoAU4sGOHTiQ1Aq/KdIuSWiYaG8D8lkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCuVQR+Y1VvKvxEZCCYrhdHpsjea8ATwaWdt+SODU5JxwIhAK32\nPSkjt3kER6OXNCdbas+88oaAxkQwCK/Kbj5mYTGz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc1lcHBuIVoRjStGuIjmujxbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDk1MGMyOS1hOGQ0LTQ5NGEtOWY4YS00MjEyYmE0NDMwMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoAFl2XQqDYtZZkC0lsK35VAqVNDxKf49UBXrOJWU+KqXf\nkQJhibPlpv0CGJ79IRLk3YH4x6LNe8BLEjR4XE4jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4sGOHTiQ1Aq/KdIuSWiYaG8D\n8lkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIdT0wZcxlqyq36JOYRh6ji586KkP/+ethoO8C4peuhkAiB9T1eCJyeP\ngSdCKr5jIWUZg5sbyu2iyu9jBmyH75EH6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAXTuqhl/fianiWYSOxpFf4bwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZkMGY3ZTMtMWE5YS00OGEzLWIyMTItYzA2MDg1NGUyYmI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MjJmZWFmZC1jOTcy\nLTQ1NGUtOGU3YS1jOTA0ZDczMDlmNDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAStsNZzzIHpkp/OeOuqoUkYzhCU+GvAAPy0tmIOGmRw5xQtsleHCeWpSBLWkbNe\ni4ZKRrfmZvBhWh7HEHSKohn+o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5bJdDbXA/xqhO\nZdR4JfLlXhN5NTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDuF\nbg9Qj52coOJy4pEiJvDIbNBfsjcdWAOMu3EsKxq2AiEAnfEl+9CesbUZbAHIObVa\ndBcboKWsn04xYz9rKbqGiT0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3103", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3103` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAccGqrRBCcVvdo5fTAcUsIDdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwZmFlODQ1LTI0ZmUtNGJkOC1iZDk2LWEyM2RlNjVkMGY4YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzcxN2RmYTctZmQw\nMi00OGIxLTk2ZjgtYmI4OGJlODdkNWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk1Xs6xYHd5UUeLLYNLXtvIJO3GCUK8TIJDRv8R87AAHrcoMyDPeNi/fjgfVr\nyDT/bnY1wq8MBUfmyxaqYkuz8qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFP1nkPP5kILV2B/1NApDN6xQ5Z2bMB8GA1UdIwQY\nMBaAFEx0CVPCAv+4tM2okvN94MEj5av6MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAm2xOeeBikEyv5eTv6JxpR62oMB1D/3ykt\n9+vPZGFaRwIgGpGMxcmd7XDU95COxSWeCKJIW1+OrG8hEO47nWqXghQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV3i1xjNurVEQJKotGzD3j33MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMGZhZTg0NS0yNGZlLTRiZDgtYmQ5Ni1hMjNkZTY1ZDBmOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToJcGNL5Lk6vJIM6kUJ+Tef9YDtpxOiL/2I3AQLOD6Onii\nW+sFV+hLOPqrhKGPjmjiolMa9dqIVOa+ZzX8O0Hoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTHQJU8IC/7i0zaiS833gwSPl\nq/owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHwXNDUnJyS6iCznBZD6mHB/5yaYG3ZwKx4pW2CGCgaQCIQDFSzR3c+kp\nwl5FKbBz2FsD0RqGvzOstzkEa8L4Np6dJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbYYU1EyN2UMuQppqStDWzogMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzcxN2RmYTctZmQwMi00OGIxLTk2ZjgtYmI4OGJlODdkNWVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZWU0ZTk4YS04NDkz\nLTQwZDYtYTZhYy1mNDI2NjA3MjFiMjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASCMEfbaBncObLNWEb7d+AYb3HQo+NOLq3q93p1PtYv3R+G+3r5wgjKnn+0WzUW\n2f9GN3BIVlyJwVOC6ygJ+V9Mo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT9Z5Dz+ZCC1dgf\n9TQKQzesUOWdmzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCc\n2rAnRLI/kPUNKLESn8QRDERrwrxfJlnnnvq53Qg7/gIgdbGYB3zQVvjdwcKPVP9y\nj8mDNmFx3dEC0JRYwfeZfco=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3104", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3104` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAXFBjgCSVitKaA8mbszh8cahMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmNzgwOTlkLTE3NjctNGM0OS04YzJkLTc3ZDQ3YTQ2ZjM1YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNiMjFmM2QtMGMw\nOS00Y2E4LWI4ZWEtMTQzZmZmNDllMDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgEJD2wedjTvfu/7iN36H9/RWuHzjPAQgs7FijKKlchPl3WopRdTU6cDOfv9L\nlJohqCTbXVzFw/8k1YiVgEgz+aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMywJ7FQRZ4/2ViWklTZo0qoIyb0wHwYDVR0j\nBBgwFoAUs0sBvDvQUMUErE1mlwVLLgLUbTkwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgBwCG5dfQKwoH\ntiZbE67HmVwnthKMfemRvg3k1AbRsw0CIFuPNcFSl3EwTpXDkp5BdVCtaCfvHcfY\n64Tte+wv0ysh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUzIwalAhH+5kOnYAD83lOXEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjc4MDk5ZC0xNzY3LTRjNDktOGMyZC03N2Q0N2E0NmYzNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpnDMEgg46UyRh5c4WMBe4DY/8onvmJGnnsMVSdcxOVVEq\nPy/pKVqQCV2BWG7zMIOTQkD/nd1x3szTmEHDMbyvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs0sBvDvQUMUErE1mlwVLLgLU\nbTkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNWszwq/hHsgydBSRxlCbbDULqUc1feQEI+IERNRi/xYCIDYMTU1iQyQC\nvJAHg7EDXQpYiC6XVPFoE133isQDnvIT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAVqH4wfPG+zoyk+BqGTBzAHJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNiMjFmM2QtMGMwOS00Y2E4LWI4ZWEtMTQzZmZmNDllMDU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MjZiYmY1NS05NjVm\nLTQ3ODktOWUxOC1kNjIxYjkxZGRlNDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS5zodzRBj4MW/z3MO0I5DUNRRXyYjIJ38JGvOp5nKlJGjA1PxfBresUsVvo+9O\nqY0hq0KwqO3ygEEe88xVayafo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzLAnsVBFnj/ZW\nJaSVNmjSqgjJvTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCH\nKcrTEF1AOPmnvho8oVhJs48MlRVDx6cyhvGIgLwSWgIhALiF6+eW+CTIkuttAFvL\n2eQ6XLkt+Qlfjk+lgInN76IL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3105", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3105` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAQe+NCMfkzUMjqkta8DjuY/BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzY2Y2MmYyLTkyMzMtNDBhMy1iNDAzLTc4YTNjM2Q4ZWNhZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJlNDNiYjAtY2Ey\nZS00ZjY0LTk0MjQtNjViNTY2ZTFmMDI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZpOKmY8zKR3b9YD44fe1fUOo5DuUT/GNmowM/BaBK70MMUL88436zJdib5Eh\nP7jFZDlkf46w71GxVN8EtXNwsaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBGj8tybY5pAAKxJlxSiXBd+Yj6YwHwYDVR0j\nBBgwFoAUzC8u15lUw2Q3g/vofpG+8xllheQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIMF8Bndv1F+\nBHKYRA2F5sZ4JqlLiN3b/AwhHJh+zIvNAiEAvyqV0VpvoxhQpQaz6d/Tju8XeWsu\n8xo3SdqNioBddg4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdbx0+jzn4nIT6kmEpzmbhrTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nM2NmNjJmMi05MjMzLTQwYTMtYjQwMy03OGEzYzNkOGVjYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnpgZ4hK1PBu2fuJ/y71ZONR86Q26dm0kfwDczzA+kH7Am\nTE2cuDrhwX19fXw40YewMvW4kB1dxMd7T8nQF9mVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzC8u15lUw2Q3g/vofpG+8xll\nheQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBAcr8Hi9v+4HBJcsIlW+vXtfS2KnR4H4J/lnp6cvKbICIQDlgwM3QMNa\nmGIyv4zMwbNmwsnAIgDCsle/DPejVXDXpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISATNskksYhyWja9tC/HshCq++MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJlNDNiYjAtY2EyZS00ZjY0LTk0MjQtNjViNTY2ZTFmMDI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYTNhMjI1Ni04ODBm\nLTQ0OTAtOTQyZi1hMWFiNTQ2YzJhZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ2vrdPi0DehzzBGbMlA9Ij8aPvLzy6fo8e6wBBTJ4QdOZ/iIOkrNOWoIbPxbeZ\nRWYNsetArkS4TfMUmtdwDlr3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQEaPy3JtjmkAAr\nEmXFKJcF35iPpjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGUs\nFZK7NYC8LGb7JZC6XaLMMmEdx9pBOvKz784uLWGuAiEAwiHFVCIaA5L1RNIKrfZG\nB8zgpW6iVgCjtbkJvStjWFY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3106", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3106` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQrFd81iUTAP+X4moVmdtCclMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwZDUxMDIwLTdiMGItNDdkOC04YWZkLTI2OTkwMTYyZGM2YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI0ODQ3ZjQtMTk1\nYi00MWI2LTkzNjItN2FlMGJmYWQ1Mzg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDMyihzbcefjo+DlYk4Dqb9GWKZWKDzRThR52yIbDMOh4YJ981yLGXxhj7Zlx\nmCl+J2gRZyVfRHKY6ZOGSt7Z/aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxiFrhBoHk33sVPehRKYOczG9mQcwHwYDVR0j\nBBgwFoAU6+L9PFP92rId0Hbr+WlIG3W1Xw4wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDlTcOP7fNy\nAcA1BLw9e2yWX9Crk29oqPmTG0VDkd/uLgIgA5c2rk6Badk/V2DYdoCwRGuTwqKn\njpkrj5DrMeXC2hY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa4uk0sExoRzY1SVG84RQnNIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGQ1MTAyMC03YjBiLTQ3ZDgtOGFmZC0yNjk5MDE2MmRjNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQc8q5z0gXgiszKGvuaAgNd6p8E3xUGU6RiUQOvmxX1WWle\nuh8q36fzzr3JOz+GJRItqTpOvSuJ4rVgygMX1zglo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6+L9PFP92rId0Hbr+WlIG3W1\nXw4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK5mNARivHco6tDvF0Q+MEF4oLJQ6SLj3sdKDJOo0jS6AiEA9MiK7lU+\n6jQKyPMOYdSISPE8hxqPwTeozOr19VbAWNI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYNAT/7mLUCJbByUQaolO/8TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI0ODQ3ZjQtMTk1Yi00MWI2LTkzNjItN2FlMGJmYWQ1Mzg2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYjFiZDliZi1lYTU4\nLTRhODUtODlmOS1lYTBkMGZjOGJlNDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQxwGgpgd2Zu7xH1QENgGKtmeWnY+bbYNWEYgOG0WR0flFO3Ug6ibFvK43kRKQ3\n17D6DeaBdtyohJSqs40CkY6yo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTGIWuEGgeTfexU\n96FEpg5zMb2ZBzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAJb\nU9H4OeOxE86LUevA3/WToLeTS95PLKcgcmP2uDntAiEAi+WG6WwkVbo6XY5eJxaR\nhdWs4/2eo7hJ9S4bym8KhIo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3107", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3107` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdT/IVRs90HO5f9hBufFUup+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2MmRiOTk2LWJkNTAtNDMxZC1iNmRmLTkyYzYxMDIzNmRlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY3NjBmZWMtZjAz\nMi00MjhmLWJiYjItZjVjMzNlYWIxYzM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhCAiWM52UegoGUfXOK+M3BgloiTCUR6jqd7/v+x8Kz0jiE/6Psv1xHC1EfjA\n0O1zIEyDPk7wb54AYnroh92TCaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT6BN11FbdDTgZxmOasjJxh/hZ80wHwYDVR0j\nBBgwFoAU0wSZRIIj07MlNxKCrWHBSrlrFuswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD7ChRLHfvxEuepxhdQoLw8QgBYpTfNuvuD01oL+NihQAIgQIbjp3gsw205\nzmnmJAM0odM2z4SPFeDUhQtNvQjwcgI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARICGNE197yUO+1ju/t0NZfDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjJkYjk5Ni1iZDUwLTQzMWQtYjZkZi05MmM2MTAyMzZkZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQo/KuAKWk+5GH70T1aLjHuLX5IcvTZ0enpECN0dVeY5Rkg\nsVKYxxsS+TTnKl6o1yUzO3BNUvcZ3Hkn6sj8B4Y4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0wSZRIIj07MlNxKCrWHBSrlr\nFuswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJOQcbdWAXYDa8EygjaQ8zndS6GfaKap+oSLhdtrnjeEAiEA8cqaYHYJ\n4072JF7dDbaVk2dcibVqazUJ6tji+fI/BDg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAc9E+2+hn1zcBuJuVHaInGQgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY3NjBmZWMtZjAzMi00MjhmLWJiYjItZjVjMzNlYWIxYzM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MGQ3ODBmNy0zZTE4\nLTQzY2UtOGQ4ZC05M2E3Yjg1NjI2MzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATz2G5u5TQQEvO+TPQiUAAEmpFycbH80ZcYGv646qt2nE/5dCk8Qcq7AFaWhS35\nq+X2YTc4URV+U20Yqxicw6HAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRPoE3XUVt0NOBn\nGY5qyMnGH+FnzTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDC\ng5ujBLAbwmdIrbfnxBGlNpehPHvJMcepB1ZHhBdIiQIgRkOREIvn/J58I43pLjk2\nan+LKmIjLWxLZfkjc7qrANo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3108", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3108` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAc40cljUsbZdEmTNhWzEZnw+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4NDc2Mzk3LWE1OGYtNDJhZi1iMWI2LTBlMmJkYjE0NzcwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I0MWZlNWQtMjZk\nNi00NWQ5LThiZTUtNzk1YTFlY2NiNDk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErFSldIFI3qzxIBWN3kmFySqYdUnAkyFrItWfMn3KP76kZWbCFQkVL32llTC5\n8lyFjwEEeYESMyKF0O/wRXnzu6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUje8tvtoT3AjTCxo+r2xzhVFy3MowHwYDVR0j\nBBgwFoAU/wsmpb/6djiVj9QVr5TS+fXhaZMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDB4YVcTs2WK+ldxoDe6ePRNliSpVvwYU3B1FZDa5MyugIgc7sdS8PTkFPI\nhCODQdlNX2YiZGg3mOcNeP1rF6wq5Aw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWk76xP/nLGph5R46lwfaV+GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODQ3NjM5Ny1hNThmLTQyYWYtYjFiNi0wZTJiZGIxNDc3MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVU+VytQZ0kfWp3YezMtHUS0vbSQhe0DgmzN8ECfXVzJzN\nXuD438A08Sleqgo4B010TlLXlphvW5TttNfdKe6bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/wsmpb/6djiVj9QVr5TS+fXh\naZMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIzAQY5HOt5sI0e0NwRDilDfX72IshxTo2KwAAn2mG+sAiEA1wedkyRv\nPsUzgjlgagmXSyZtWr+3lABkzUWb1sMYyAk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAWTbvrxkmEqRJBilUY0rjVQMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I0MWZlNWQtMjZkNi00NWQ5LThiZTUtNzk1YTFlY2NiNDk2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OTZjODQ3NS1mMDI3\nLTRkNjctODVjNi1mZTQ2OGY0MzIyMTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT+LP5PeWIa1lEnTeSMd5xrqyVLEnQafKZTk7DU/WI1d0EwdIJA/9tsdCDasSsQ\nri/LzzD84WFjSbKJwMBbScebo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSN7y2+2hPcCNML\nGj6vbHOFUXLcyjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBIN\nxFKgbgPJtdcb4JX44z1FvKfWaMTnMpcCAZVTe7jYAiALgfxntC/QNdBZkRX0sJtk\np64pZ/J5XqnGY92WABZ0Bg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3109", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3109` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAYxljMyaGOaUz/gyPj5IUPZXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzZmZlN2YzLTE2ZDUtNDZhMy05NDY2LTMxZmY4YWFmOWRkMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc3YTM5Y2UtYmJm\nMy00MDRiLTgzYzEtYzAyOTQ4Nzk3MGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJaUYiTy70FdibJmoatps7valJhciqHnHtdaphE0ndsm69c6YUn12zT/s6VCa\nmKc+w4dkWdDFaT0Epxxr1XD3K6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/wH9FNv5wHoWCK1DeFl/iERMSU0wHwYDVR0j\nBBgwFoAUZcpfHtNwnhxISP3uKVYR3a1B2/gwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCj\n9qUbqI3TyEsEK6pvIboOClHA4wXHuGZkF06zsQfbpAIgMjfKt2OjYi7DEbOznzO7\nEOt2YuevGKVAljPF1L5Mf6o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcbj+WlBH3tUtwhtzv+Jvtx+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2ZmZTdmMy0xNmQ1LTQ2YTMtOTQ2Ni0zMWZmOGFhZjlkZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjgpGkoSeqQ/PAwpJiNGczAXWgywiwa92z45joIPsplkzD\n6D4YoL9pkKua9nWJb7UhcW8AB3qdn7z3m0IYy3q6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZcpfHtNwnhxISP3uKVYR3a1B\n2/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJIVQKJDn3FLic0CEHAjMWkP+GvofB+2EgzmozgxfhtsAiEA7wASLJsh\nbr8QPJQxhHjYL2H99QJ4ARchUmJ+oy+LrFw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAa8G2nU9EPyD11r2a4DPJUdKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc3YTM5Y2UtYmJmMy00MDRiLTgzYzEtYzAyOTQ4Nzk3MGRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MmNhODczMC04ZThi\nLTQzNGEtYWZmMC1jZDllYzY0MzY4MTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATWerHmWbJR6a/3vnguJvIZGWv2RIznstXgj1IQm/vfldTgc1CE6qmEpRttUxma\nuLj4yYjmmQKnOUyRjDgi3IOno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT/Af0U2/nAehYI\nrUN4WX+IRExJTTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBOW\nboAXEzHVdw+Zz9HYILBrB2cB0tGbX4Ly6YWV4HKjAiEA5hUWeilvxG80WMDWSHNI\n3GvM8wceCGuPZgvixlp233Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3110", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3110` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAXVa5b/Q8dBkYsLRT0T8Lu6qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2OGUyMjBmLTRmNmEtNDMyOC1iNDgxLTVhZGQ3MjkwYmEyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc4MWE4ZTItMjA0\nMy00ODY5LWJhNzQtOTIwNjM4NWUzMTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3p8OHHKnZ+Y8Th9sVjPU25Rx50Bh0eH9WnWdd0cmlgQ0IB6zoVrQ+fS4/hFb\naYlp7Uq25UWiTZstI2uVmUA6k6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbe6bhUie83xBJEv6UiuxNUqowNYwHwYDVR0j\nBBgwFoAUxQMlX71uqgJHYc1hqsuxLkPWyq4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC707vgca3qENcMKN547Hh7qVsQ4ajMEaLl7yJMEF7e+gIhAPx0\nwVuVFW8lxTHN0ezsbSBaeTM0+i5UM38b0exAUETE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUBQ1oSjFY4UlPd9csRPx86cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjhlMjIwZi00ZjZhLTQzMjgtYjQ4MS01YWRkNzI5MGJhMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5pE7S2z91CP+cVTXisZe0nVCW6O+iLx/wwkSgkpyKzhtr\nnxUGj8E7ww1GYkhV81HBj53wrZcDKUum2WqOngrNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxQMlX71uqgJHYc1hqsuxLkPW\nyq4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgX/VKSOOBngWeKTs8OQpTeuyc38Y5tKuhbRgX4daum8oCIAMcB7GlkVNg\nX3jErPZl5vnkARTdAzsw2Xvg2Dv6Ajjt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZp5flG3s+msiUAtLXZ7zKckMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc4MWE4ZTItMjA0My00ODY5LWJhNzQtOTIwNjM4NWUzMTYzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZDE4Zjc3YS1mN2Rm\nLTQyZWItYWRiYy05YWQxMWNjOTk0OGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARTpv1vUV08C/ydh4ipU2KYMAVipoCH0K294VSgHO713oLdTBAnjVtBgZTh3prk\nKMYoDb+jh9dtZwu5U3PB37xJo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRt7puFSJ7zfEEk\nS/pSK7E1SqjA1jAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGhW\nvb0H9okeEnNXPERD2GikMuehfvGIaPK3r6QPLuvnAiEAqsKqgEMbvabNRzboXNYH\nhNp4n4F3bDFDG+Sd8ZMtjms=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3111", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3111` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAfi7vSIIgfYISAYbzz4d/cnIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmMWY2Y2E0LWMwMjItNDJiYS05ODFmLTEzNmM0NGJlZDlhYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFlZTk2NDItZTRl\nZi00ZmU1LTlmZTQtYTdhMDE2N2QzMzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/nu2QwYpRANcfC/GYmefaFlfiTg47UgPOSTAZaH01jX2PziwH9SgjdowJpg/\nQYV/tx8G2b+hFuSf140XUgiam6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKjZtISmdwwaZpHvzT2DGQytD7mMwHwYDVR0j\nBBgwFoAUoF0blJvMEe0329fSxZJdl2RPewswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQC07kbUf1csc7r1byKIc5b1Ti78sgTF4TpGv9brH/p1gwIgHolU\n0H8azXBGPvfgoYHfPTdsdleF5C0AOkyvDVQV8PI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVB+8/pOuwADMR60nqghcbweMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjFmNmNhNC1jMDIyLTQyYmEtOTgxZi0xMzZjNDRiZWQ5YWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASemuIkPd6tFuPu0acl1gcTn0olP/ah8OeZNPXWzEvs5dw5\nbqOQ8A9QW9Xm7qcJ2PaiV+WvM7e1B6hJ0aIRgnyfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoF0blJvMEe0329fSxZJdl2RP\newswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbyHorKykIjhmwn4drv44rk5DVopPpXsokJJhb9cYpxcCIHwxkgD5B0gO\nI+j/AcVtvP20L4FgaEQuXL5DDgs6AOPT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAQkXTM6FntGQBPm9w92y9CNNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFlZTk2NDItZTRlZi00ZmU1LTlmZTQtYTdhMDE2N2QzMzNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYTVkMTljNy03Nzhh\nLTRmZjItODFlOS0wMzhiNDk4Mzg1NGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT+Me55QTlQGInDy0jljj6jRVjgJgQe7NgFhN0EWiH5frJANGYhjfHNSZFag/rC\nHeUbroRMbUn4Ubl63Fobum8oo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQqNm0hKZ3DBpmk\ne/NPYMZDK0PuYzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDu\nAgaCoHBzy8jDdRg3rF6ptX0DGvuT77O/uTHZZ1TlAAIhALlCWX2ojbPngByqH+Qo\nVlEBxW/cGcFzFsYu3jKREsOQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3112", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3112` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAa78NzBqd5pHJrpzbN8860ThMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNGM0OTMxLTdhOTMtNDNkNi1iZjlkLTk5ZmFkZmQ1NDVhYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg1ZTMxNmItMTMz\nOC00MGNjLWIxNzYtMGM5N2MxMGZiZDlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBejP5eIzJ7bYuClHAUnBJnM4RUKCLnly2sK6vxxxVADUrlzzUTlcA3Zp9FfY\nOWIf62WgSVha8uivj6p/3MVPxKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR/qVfTUornVrF/I9/ch7eSeKdPMjAfBgNVHSME\nGDAWgBSHb0Dau3Ry/GyMbNbmRHv+m/qkGDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDBZyzwXwAvysTEXd0cV4zIoXL807wv\nGyIP+dg7Pe8KbwIgbC9uih+kSoMjOv99yul0sgQhJKg+Ax3uI4Wk487Dnxk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfR/IiLKEl40M7cVLwM4LqDnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTRjNDkzMS03YTkzLTQzZDYtYmY5ZC05OWZhZGZkNTQ1YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASskzoBwPBaFRCO79fieD3rGs/phtPksj09lwWWgHgyjNE5\n+8iwfDlvlpjiHw0WSCUGSdmwGbIqw8G38g0pqklvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh29A2rt0cvxsjGzW5kR7/pv6\npBgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ8TNQiToJA8ogCG6p52JOTV5Czg8QZowLJj8ekXIYflAiEAocNpeMOZ\nwg/zfucCitOTXgxoTYVvlTOjwzkLSCwJ0MM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAUZXnhFWR93erEPMtYWVDHcPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg1ZTMxNmItMTMzOC00MGNjLWIxNzYtMGM5N2MxMGZiZDlmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMzFmYmUyYy03NDA2\nLTQzNTAtODNiNC04ZWZkYTljNmMwNTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQmMbHFZo7MhebbNrY/GhWVap3xpiapzvHnxW8mUqE9dEqP0P6Kf0bs3ONJ8fsm\nBIkb34eBPwvylVmzzDAmdp4vo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/qVfTUornVrF/\nI9/ch7eSeKdPMjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIEfn\nHVG5Z6lJh/v9WKkKtrM88oyD7vO2R87IG6DuttG8AiAsGStvAG1He2/PKXVxA6Rv\nWHNXHr23x0TlnPHl8no0XQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3113", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3113` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATcsvOlPSug3LsUE+slDgyOuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1ZjQ0ZWJhLTgxYzAtNDc4Yi04Yjg3LTdhNzRiMDU1M2RiNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JkOWZiNDYtNzRl\nMC00MWQwLTlmMzYtNTExNTM1MzgxZTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELmvxI7JT9wKIULeWK0TZzH92yBw7yhpKHYkRAlK/pyeYLQqSewkO9vugtWEo\n1WRcnmMwRMdLQ+JacJmrKf8rV6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGtPrOTcOMCC4UHHV8sJhUQgm/T4wHwYDVR0j\nBBgwFoAUzkS8qj/VGylB8JpfVpmRfnlQLvMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBSa2Y1/Q44X\nNBFHtgexUpBG0ujVFGVq46LC8YvoO3heAiEAuJv/Oka+MMCALwToAmATseBux1aN\nO2rihlQ0RkS4ujs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQhupC1ZgyJSjnO5RkX1OQ4AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWY0NGViYS04MWMwLTQ3OGItOGI4Ny03YTc0YjA1NTNkYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUGdAyfmqM/udnG3P9fPLGxzadJsHN5XVGUS5fYc2qa1WQ\n1Fc5xICkYWj8zR7eqTK+0iSbCdhncaZlkvkrr51Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzkS8qj/VGylB8JpfVpmRfnlQ\nLvMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDt5R2Ui5IIwMTlL8KuGQ/N+k5sywjQCMH4oNRxm0sAwCIQChr3cu4wux\nx4FFx6+zTlU8IkGfgqo7GEcWcUFEBsQY0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZ3cqXMs2+GHQWh4A8vTp8W9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JkOWZiNDYtNzRlMC00MWQwLTlmMzYtNTExNTM1MzgxZTRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMTliYWMwZi0yZDI5\nLTQ2MTEtOGFmMy1lNzU3MzBmNjZmNDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATl+uW4mKELz7xfk2CR+3DlwbWpOvD8LUPe2kP+4Z8cfxlLTbGqWfLSzqFMlqzc\nv8PD3E5vBh3n44WU2ye06D2ao2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQa0+s5Nw4wILhQ\ncdXywmFRCCb9PjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDo\nfaRjGqwscRlzpmbjAsspj/+DHHft0/4hmPNFRyLDYwIgX4kRAkrW1L11t70piPwF\nx/7MX2i2ib+dPK6h2t/Z62w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3114", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3114` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcjif5ESFLUAHk1Y/EpaUjftMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNDE2MzNiLTU1NDYtNDkxOC05NWVkLWE3ODhlNWFhNjE0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM2OTg3ZDAtNTM5\nZi00MTkyLTlkNjItYzJmYzI5NmZhMjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl7wLmICAwIONBG+nbZ5VUgTM43k51WQhL8MI5JEFQxZQGumEs2mFreUix1Kt\nANsfygMu1dGEL2m55brF3amAj6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ7RWRX/81ppFgAsg81uH/LiwoIswHwYDVR0j\nBBgwFoAUSlTABsyGPGXuck87CLFWfeDHSm8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDi2t/OVJjt\n3TpIiTnKkhO6iu4bK2+LQZRThgODmPbf9AIhAOO3b6mctNLbPYs8sUA3nsdbB9b4\nD420rqkwk/mvjwQq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeE4wDdVPL2n1bea3qjBFBUDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzQxNjMzYi01NTQ2LTQ5MTgtOTVlZC1hNzg4ZTVhYTYxNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqoRAKwM5k05wW4SCcJKFHzZzaPeaR8ERD/xIJL6a92gFK\nxIwq7YPJs4cX8qLbg0Gc8qNO9CnykiZjNNynjluno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSlTABsyGPGXuck87CLFWfeDH\nSm8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANZDs+Gm2soTK0FmbvUQItPqA5LzPINZK3yVu0CChDR6AiBuiT445hMm\ntxjUBoZHgjhQ5/a5yg5qPYCrEEe+2t2yzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAfYms/vVhIGxjg4pRb8DJ5A6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM2OTg3ZDAtNTM5Zi00MTkyLTlkNjItYzJmYzI5NmZhMjVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ODg1MWM4Yi1mYzcx\nLTQ0NGMtODQ3Yy00MDliMWQwYjAyNzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARPSn0asjLvG7HaiEIjZtkscfUPsJeKq6s2/JsKBrsvilZ6mf1hNUulmsKOrErk\nvWS9V/mpROs9U1N9FbhtMQo4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRDtFZFf/zWmkWA\nCyDzW4f8uLCgizAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCl\ncZ/LVamzuprD/s40MZklWpEi7UQhz3DS9fDfTEr3+wIhANtB9gvhv5oWM1SNlW5n\nudI2dcAL18GWK9hXzMlbIoKR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3115", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3115` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAfn4tEz3znwNmautNkiWhyk3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzYjU2MjY2LTAwNTItNGYyOS04Y2E2LWUzM2VkOWYxNDQ4ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM2Y2QxNjUtZjA5\nYi00MGI0LWE1MDctMTlhNmI0OGFhZjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJsK1Th9lk+QP4C/jDpX/BdPD6PeQ3yik7epaOfd6LTcfWu0ykjRU05po0FWm\nv/6yit65UsWej04kMofcEDOFx6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw43nAg+e4wFLbUbgICGhkGrTU+kwHwYDVR0j\nBBgwFoAURDEiy9/eam+uqL4a6urMdQzfS+0wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAkk0YkEyr\n3VKAsKMzxcLlA7NCGZLJseRnudpG8+v0b4cCIQCQ0zemBQhbQqZuQeq1MjoalxVC\nhfr+zvQq/yfNoOEhDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV1P17iIk+bACaSLZ3ASN2CDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2I1NjI2Ni0wMDUyLTRmMjktOGNhNi1lMzNlZDlmMTQ0OGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJaPopynLpFuuPkP21kleOk87DhHy48D8E3kQEU7r2sVbZ\n3w9htbq11em8pmq0UYuYxXn/72gYoOI5oLG6nBCYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURDEiy9/eam+uqL4a6urMdQzf\nS+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfTEKiIQcvVaiQ23A4d/iUhffP8DLCrMgJaLSgNjUXwoCIQDKM336Kfci\n70jEl5xgZRlUNsa6Hzsfl0BN0fnR02T4NA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAfmuIEmYea0B1BU9SGDsIn9KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM2Y2QxNjUtZjA5Yi00MGI0LWE1MDctMTlhNmI0OGFhZjYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMDZiMzIxNC02ZTkw\nLTRiN2YtYmZiZC0xNmE0YzNjOTIyN2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQkO1JQv/hyQIr8wbnFLPungz4VZ7HBQ4vCXewleM9lMqJ+Rf2DGkoeGqYxuj75\nk8qWoW04SuN0PKUTMTR3Uj/vo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDjecCD57jAUtt\nRuAgIaGQatNT6TAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDo\nu2eNW/PCHwC58zgx/dlCLVlEUczeJW25AhZ4ah4ALwIgBYD/KvkvxNffT81L2Yz9\nV1ez1FSWMe4tlBac+Xu4lAU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3116", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3116` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAWCFdo3aqGBWvq+kpMYMtRl7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4NDQ5NzZhLWMzY2QtNDU3OC05OTBkLTVlZjAyN2RmOTFlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU3ZDMzZjctMTNh\nNy00N2EyLWJiYWItY2QyZGM1OTNlODNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsHQ0/MMg/VoqsZxuq2Q7QsKrGRTDHCcr7vNNfebSG1ZfunHco+AzzTbDh5vZ\nIZRXx5uCwpxa5qQpDExSrS/8nKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfTDZE8+pd6JtvweAQrMEN7IplrQwHwYDVR0j\nBBgwFoAUJlXaw38B/dJGJdWMlF5qYHA/itkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAjMfqFqyzOajFUMqCk5cPV0/gCIaggZIbWzJuz7GsplYCIQCbyPa3oO80\ndv6I59pRXNZjOlFUHxl5NYJ/nTiKZwTZBg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQs9qTUI4mRH/PRHCPNQBbkVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODQ0OTc2YS1jM2NkLTQ1NzgtOTkwZC01ZWYwMjdkZjkxZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsI5K4Fa/P2u+ouAfh0h+I9qCiyyWgdmL+LM5gqHLrClc9\nmMUXBxLP161U0s2M5gzKW97nslnS8xdSG8kCCF8To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJlXaw38B/dJGJdWMlF5qYHA/\nitkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIPOfpFAQQqCZLskQUdlCEkneN2tI5Ls3DdF2jXijWB5AiAndFTYUA83\ni2QYGxqP0cDj1SCJZCed987Ok7+RbTPTqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQ70t2sR1Q+FvW1n00/4biqZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU3ZDMzZjctMTNhNy00N2EyLWJiYWItY2QyZGM1OTNlODNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNzNkODYwNS0xNjQx\nLTRmYjAtYjNlMi0xNmU0NTY0NDU1NGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQisniOStQdgh9J0M8Ym6ujppTn5ODMwDY9amXmzXyJ4/sCG8cRj/ls2OqGIi07\nImaGGjQaJetjIguIMEBd+UaPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9MNkTz6l3om2/\nB4BCswQ3simWtDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDN\nsC92JthpZV/LmdSj4qk7EWavBBO+dGGHdLojuCb7yAIgS7y/TVOdaXhDKJmJU2fw\nqFf0NyIsTKl5L3AKW/c3ZcQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3117", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3117` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdiGetLlxSHC07UbdSaUAfxeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2YjQzYmExLTdlYWMtNDZiZS04Yzk2LTBmM2EwNzI0ODZkNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhmZDEyYWEtMzQw\nMy00MjEzLTgwNDktOGE5NGE4YjY4Y2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVADIKxH4y/ti3ZVX5ss1eVdeH/eG86fHEgeFFHcNP0/WQjZVUJz2RrGMAhtR\n+q8W/B6wuChmY4DktWUI24HJfKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOzstpmt4b9wuA9SWf3BDLwXCQfIwHwYDVR0j\nBBgwFoAUvJ1zUdNCJzH5vU6SgPiu0KyqSW8wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAQTygBb8SPWRSVk1rG5wzZrHzaiQiNVIkJMD93Emq3zQIhAJ+euSvYTBjD\nH5CddnfRSIIDjoFFFZaOMuvNKfbfp3Bp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaB5Sj4OdE5e8wZvXjEXsHs6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmI0M2JhMS03ZWFjLTQ2YmUtOGM5Ni0wZjNhMDcyNDg2ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUEm3yf+u7+IRWsjGH9MZ8lCFNcK/jExYaOMIv6rhhTe7L\n8Dpmn+CN7C8e473hjC8E3KoyXbvWq61CSejye7Huo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvJ1zUdNCJzH5vU6SgPiu0Kyq\nSW8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIgfE8NZI8Wl5ChK/ikxPSQNXAosFq3AocYgR05+6rZUAiAauOy+jzjw\nHYxhDVFdwBp9yY1INQJBSOIb9JLacIBXAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAce3qusy2KOydXBnLEsqTSg1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhmZDEyYWEtMzQwMy00MjEzLTgwNDktOGE5NGE4YjY4Y2NiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NjdkODc4Yy02OThm\nLTQwOTQtODQ5MS1iZDJlMTEyNzYxM2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATZyUtJD1z4gc2gZNEspQ4yxB/55d6VXtw2hTKMC2XFzaAEzb6EOlge/kVBJxh2\nvxOCP/xaMfYcWlmPrNdnpEYCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ7Oy2ma3hv3C4D\n1JZ/cEMvBcJB8jAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDy\nHLgPdQlv/xdIYXAsS/FqGunhN04vA4afrqqDrHfeWwIgQaPGE+nvgrXuCAVg9a4G\njLP8asE06QhlnLbF6G3+QMA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3118", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3118` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAeV3RanhUtlGzWnqYH5rNBE0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzOGJjMGE5LThiOGUtNDUyMi04Y2YxLTVhZDRiNTg0NGEwNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA1OWM0ODAtMDNl\nZC00MjZlLWE1YWItMzRjODgwMjIzYzZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFCWoHUcP0U972t2QEejVOPl0/NBkaXaHdo/VHPZQ/lh06uNxG8mMVIY/lRet\nclJZHAfuviySl0xl4TFU6nOaSqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnfXUEAlRC+R6oCGVPwsGg58PoFYwHwYDVR0j\nBBgwFoAUC5lNIew+GAfa1bM8XCeHiUAmHGcwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiA2\nAjb9XPlMrBHUPbAMZRe5eKlO/7uVVT3WSS5VKxCJJgIgZIuq/fwtsh1uNTzq2sUQ\n8A8QnWJNRp8w5h51x6Mmwl4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAep424bRSfeGP18hY6ot7DdbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzhiYzBhOS04YjhlLTQ1MjItOGNmMS01YWQ0YjU4NDRhMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbB40STv5MTONtdpNzTBCuq73rl10foY4VcSCPomsgrT/6\nzirHP+3py8lTkge2Ss8YZpgjIhh3ysCDXREwmoFCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC5lNIew+GAfa1bM8XCeHiUAm\nHGcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKddvv8HF3Dd+ataGZgRi8emi/v4yZWOR4LQz4HMhEigCIQCBAdFMV6GR\nvmfpLoo6rG79qP5y9+9f+asksbaC9IsFUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAT0GmzhFcrs8krp96bAzBZJgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA1OWM0ODAtMDNlZC00MjZlLWE1YWItMzRjODgwMjIzYzZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZTQxN2VjNS0zNmQw\nLTRmYjQtOTdlMS0wZTViMzllMDI4ODgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARGqw8JGgBOK5CGSRyiUrofZED4U8lGf3c1S6av/cFuBKfyUjuav3tznT35ippy\nMkeNw3uRI5Lfbi3+bltE4J/4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSd9dQQCVEL5Hqg\nIZU/CwaDnw+gVjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICrr\nE30C92ogvK6N/RPLgUGSdC3qCiN31H4rBnlJBGpmAiAr81GXpOu8cvitt6Jr0MxP\nLBTjIfzHJTYS6OeO3mTFvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3119", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3119` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAYZPuWwqBNOn3DFxiySovZSHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YzMzODc3LTljMDUtNDMwMC04NWJkLWRmMWExNzRjMDA4NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ1NTJhYzctMzkw\nMC00MmY5LWE1ZWUtZjNmMGY5NDc2OThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIV+MeMwXqqQoRgnyqlVuUvu+DyfNLAxtffdQbplnKMw5YuLS1lV7ikFQwWds\nR3u5x1Wx+VbF6w8sOVEAWrlPR6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq2TWFd4CHyViD1/as9afvFLLo7YwHwYDVR0j\nBBgwFoAUelghIRQ6g84xvREJ00lPRQzFZIMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA8Np8wxqdnlfSSX7C/WnLddXpD014jczRECLIJISjFL8CIQCw\nM4POFH7CjllNlcmqHAWV+XD1+JSZ0upyUmxrcfm4eA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAauliJk0PfvxbGod1/Krg5zbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGMzMzg3Ny05YzA1LTQzMDAtODViZC1kZjFhMTc0YzAwODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxahxs9/RkJw/XLcx1mMfR9gepQ1b3Gh4PA3ozICrffDGa\nMhNLtmsL5Y0uhU0DcmAeiUzAGqtJp8CVOlvHh2u4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUelghIRQ6g84xvREJ00lPRQzF\nZIMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAInizd9XKaSBiSojgdXTBqx0RreY/Pm2wSSeKtEockxrAiBAYz49BSyR\nuU2DFkbe65cPybgBNl1m0SdWi9P63BZumg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAe1zZJpqEkJ0tDGI1kKff0CMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ1NTJhYzctMzkwMC00MmY5LWE1ZWUtZjNmMGY5NDc2OThiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNzBlMGM2Yy1jN2Vm\nLTRjYWEtYTA2ZS03NDMxOWRkM2RlNjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASKiK4Gqi2A+Hv+bkZh4jXONjMhh9D6uNmxw0TW29EFwquvQJPF8fp48An5q3SZ\n1SqbA5D4aWs08MP0V7JJE9IGo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSrZNYV3gIfJWIP\nX9qz1p+8UsujtjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDDs\nk9oCDI2ipJJJTdhyItweeNnvddCnhIqFrmw1bRreAiEAkOYkL5Jqh7pLnTyvPglA\nDhS6Q68GMJ33l2PCQQxrhM8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3120", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3120` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAe4o07WdfmCHMrjxypl0thalMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2YWZkZGU1LWQ2ZTUtNDY5YS1iYTdiLWYzYTVhNTVlYzJjODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZlZGU4ZTctOTk0\nMC00MjIzLTk2OGUtNWNjMmE0MTg5MGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPxbZA3dCl4LyrADCgFnXafiZ+y1eJJB4sAsXQyILAGPMQkbW34gaWU4oHjHb\nMmQ49Tg/o+x5ARKaGleuAQe+m6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD4D5azIrJ/VUsMpzzcJ1qy6OPSwwHwYDVR0j\nBBgwFoAUSYcAC5tcmoGd3xd3A7C8Q6NJ01gwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA5IBT8vIpvhQPdpQiLt/U8WJlML+ONCdTRnkSqKAcQzECIFYy\nd7lZSHi0cf4oxFrZhmUcSwDMXN8E+ttoSAfwqmZO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZsLMzyUdZ5Wg7GzOBNIpmLFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmFmZGRlNS1kNmU1LTQ2OWEtYmE3Yi1mM2E1YTU1ZWMyYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEgCkI0GihYBGxsivX55VV99LkPFWIaSzS2QQUTPKp1TG4\nLD63aR6bPdf8A9ko0xxS6j5/Ue2HbfmwwSiBjZDCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSYcAC5tcmoGd3xd3A7C8Q6NJ\n01gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYXAxev31HqAwzMsZKwyq9jmqCpBJO/bCIjtxG55YSncCIFVrKjNz8/sO\nUR121SycUd6ZUcES7ZwiZSWwseC7N96M\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISARZyW/atYmOocMNnipANbk8gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZlZGU4ZTctOTk0MC00MjIzLTk2OGUtNWNjMmE0MTg5MGUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZTRlZjhhNy1jNmUy\nLTRlZmYtYTY2ZS1kNWY4ZGI0ZGQ1Y2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ+rgrDtvBEiWTIt4Jf7QuovjfiGRaAc31vNHUr7Yt8nQyYx2SQy/Bhd1UgPLvx\nDUw4p/JEy31Nl6Zm6Yhw6lv7o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPgPlrMisn9VSw\nynPNwnWrLo49LDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIF0k\nwrVHzbf/CMvy7Rq+CvEpm9vRb80cBYRhNBqmqdldAiEAoBAkGt5TkKFxHQhplDri\nWhHlz3u5T4GlxhYmLuAUJ10=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3121", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3121` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWZ+Q6efiepydIkfIEPDPXN0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxOTc2ZmUyLTQ5Y2YtNDMwZC04ODY5LWU5OGZiZmQyMmY1OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhjODgxN2ItYmVi\nOC00YTFhLThjOTgtZmJjMzFiNmEzNTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEztO/O9wW1Kc8s5wj7Aa8dhuoe1w+Pud/OiPyafulQht94LNm7q0Lc+T9d6Zu\nwdwXVLtmXh9kCKP+5w2i020nDqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFK2lWzlCLvz4thuhXdFbotuJOq4wHwYDVR0j\nBBgwFoAUV87j7ROKAbpNrG5osuhq0DB+rUgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAqhZ9M8n2qXif\nuBSRnc6IlGAWeRv2QQ9oL9w+aeyehC8CIAO4F+W1/6HutoBjkpQ/PiePUT7Dp6Xw\nhT6CUuxmAAPf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYcH/BTfrOI9weV6IoLQCSJaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTk3NmZlMi00OWNmLTQzMGQtODg2OS1lOThmYmZkMjJmNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9djz0JOTBcLyRtalBJpo0KOGRrSIeDpfupbhs3JvqD/40\nOJML9HclIZOmI0rhUeIOe82Ev+HmDzxa1D5gVvtso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV87j7ROKAbpNrG5osuhq0DB+\nrUgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT86A6mcvxrA0rUWBcHjvTHlOQiANCHfgNoxtKKp5XFoCIEK9HzLLe6A1\nJlHkY//3Xnp3UMavvY8iV32A95Vucccz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAREMzE+4lOf1Hgn5pCGHT9+BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhjODgxN2ItYmViOC00YTFhLThjOTgtZmJjMzFiNmEzNTc4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYjkzOWQ1ZS02MTZm\nLTQxMTMtYTllNS03ZDdlNTZjODk2MGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAREekBiP/Iuh5UZwwzZag+e9VCc6yUvzDyK17ek/KcgRUst43hnOiqDNDXo33X2\nUccCFfoSZABkXioJ/goAeX7do2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQUraVbOUIu/Pi2\nG6Fd0Vui24k6rjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCF\n6ZNFex5s12ODMR8pna7SyB0qULutT54tFs/91YdaPwIgOv4/HLZmaoxvcKkUkIV3\nunf24GJl4pVkc4z03b6jouQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3122", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3122` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXBWmD9ZB2PYWk8RzvS0ZwBtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlM2Q3YWI2LWY1ZjUtNDFlNi05ODRjLTYzMTFjMzIwMDY4ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdlZjc0Y2UtNmRi\nMC00MjZlLTg2ZjAtNzZjYzQzNmEyNWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiY3GdcVe5nkuoJYrj4yv3Q2/PC14eLwuenOywjCQ1xsiNj1AgdCD/9vGhJ/o\n2PXqECGOoDKIE5iJ8Gn5dtKkiqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg7jPIQMLcuSwPJS48KS12ZARY2UwHwYDVR0j\nBBgwFoAUzsqO4lVl5cXBvX5IZWSpYDeF0IgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDN0eimaHLicZd8Tswaiv86ir9YkZ+d7lACuuAw/+lskAiEAwkHGKjRklSfH\nB8HuWl71JCtreRzsW2ZfXyl/ICxooFg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc6krjzN5ST03vS5Xv87HFEEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTNkN2FiNi1mNWY1LTQxZTYtOTg0Yy02MzExYzMyMDA2OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQe4iHzDvL9YInfRW4FizWdaV/pBxTl9CsLObN1Ta+S3kdd\nnlenTvguujg+qf5WNfyCnRe/oCwnM7h7hFZw8oYAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzsqO4lVl5cXBvX5IZWSpYDeF\n0IgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOaYBDzLx6sx+APZxcXqNS4XlJJKoplAku9/dXiLTH5HAiEAxn3+tQcQ\ntPz+65EX3iTorsGZ87qV1bx1uAomoLoq9LQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAWVVN63iWy0VWxdo8ECo/4g9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdlZjc0Y2UtNmRiMC00MjZlLTg2ZjAtNzZjYzQzNmEyNWQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlOGE3YTAzMi1kNWI0\nLTQ3NDUtYTQ2Yy02NjM2ZjI1MDkxYzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT3CHQ5FBPQeG5aEF7UkQrqoLXcPOdM4FZ/CQuqy+EYmbOEYCGFbtFnC7EMvDIk\n5GZfPJn6bIbOKNV46HZ5lZ2Ro2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSDuM8hAwty5LA8\nlLjwpLXZkBFjZTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAOC\n27YogsrcPVJuk8nrfWxgVvAdQUZsQsCqDUk2fCgVAiEA2wldtu81lEPq+zx2ATUm\nxj0z4+JnsiveVrgZbYsubNs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3123", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3123` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUiE7vs9YfhEUdTthydtk+4IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNTI1ZWE4LWFiYjktNGRjYy1iNjk4LWFlYWExMzE3ODU4YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY1MGY3M2UtMzgz\nZC00ZjYwLTg5ZGQtZDYxNGY3YTAzMDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJoQzXSUmgTY9BC3s6GWVmy5Gec4Ly2I5LXpUz6tUa8Gb69AKtCiomjtl/mVq\nLvuNCYekpqIPQHELGkPPc0MW7KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbuHQ8VoRnY1I1Y/EoaguMFk9Ye8wHwYDVR0j\nBBgwFoAUYlGtbH2QRXscT3vj1ol30LNew10wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDbzsA/tsku6W2vVAJ1GGQ4Nhiaf0gX8/of9vJ6ICpwGwIgeNm9fll+sYU9\nKdC4UNUMxgbTfmuzxFZw1/Vc4st+BR8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe6LX+ngyFlFADS4gFqaKxIeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDUyNWVhOC1hYmI5LTRkY2MtYjY5OC1hZWFhMTMxNzg1OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATofekK4EI6KzCKFoCSECxMaTnwad3eKm5ewXeuZEYJxxUb\n3ZNfJiJkTBCE8DeE3j/NlK+rBViGfnpN080WJzqDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYlGtbH2QRXscT3vj1ol30LNe\nw10wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNPQ/ceL4M6OqGTtl5CkF7JWg0RL6T/yQFEsdXKyecMcCIHe+pC09jnRm\nOAXF4Hy/zpbjJrjI/6UnpvvIN3hVfbdF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAdcVg8HAO2GHmh6OkumjDh9VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY1MGY3M2UtMzgzZC00ZjYwLTg5ZGQtZDYxNGY3YTAzMDIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OWNmY2UxYy02ZWIx\nLTRhOGUtODhlYS1jOTAyY2RlYmRiZDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS5g7nJcJLXTuZ5ZuToLyOiMra5O0F2xCC89ZHO699zacp2k/VClO8Vx3JShrOD\n3vaeJKqhHAMV6L8BIHZtnkVHo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRu4dDxWhGdjUjV\nj8ShqC4wWT1h7zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCb\n8GzHiYOJLEq6pJZMc5KzBtwspRCdudpZ4X60pSAvCgIhAJanttJSyZi7hRX59y0l\neO99E35OvilExPI7cZhIUigp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3124", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3124` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAaK58+o+SBYvN6LSQa9cb0SHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliOTViYmFhLTk2MWYtNDNjMi1iZmMxLTFhNGI1MDgzNmVkNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWE2NWY1MTQtY2Vh\nMy00NjYyLWE5MTgtY2YwNmVkOTQ1N2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6eCH17I7Hfau0xVl2uf//G0ptNSVZJ2OAZUaZJDvpFlYH1Q/HNjvg9tX7sFt\nwwaziT5GqbqkbXSU7aVqV3YhZqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSOdC83HNRyhZ+uu8QsJrt5CBfbUwHwYDVR0j\nBBgwFoAUVpNxefRysJxrs8Rjq7Ki9+V+JWcwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAFh1+KCruLoPta3l26Mc9aOAe4suiB+7FPIOWi/S51cAIgP80C+uVlMq1C\nDSKQxyXx6wENNi4iWjYom+zUUXj7Wd8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUMSRIJnTlYrFnprxMIjb4NIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjk1YmJhYS05NjFmLTQzYzItYmZjMS0xYTRiNTA4MzZlZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFu5hsydf+su4+RQbd8j3O0hamClnUTVHSH5hJtPbUNsSe\npdA1JiVw90CITFBC6P1WPZLQxS831Jt+bI1Czr5Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVpNxefRysJxrs8Rjq7Ki9+V+\nJWcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVix0BVNLdmSbcM6I362DQcrZG/mwW3Kr8F7ZW1if6wwCIQC9AJ6vvBHv\naXJssu3/BEiP5mc3wowgbcoamDMiKwcEQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAYJ01SjQjh1gKrlLHvH3Kyt6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWE2NWY1MTQtY2VhMy00NjYyLWE5MTgtY2YwNmVkOTQ1N2ZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YTdkY2NiZC04MzE3\nLTQ0ZmMtYmFhZi0yZjdkOTE3MzY4NGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARXWYp3lCw2IznzWooR+42EvlwpOaL9WA2kGK3cO2Nj4dFpEF+3A/hbpi0N2NC7\nIdn00CLN+LzuLLkEJPA+oMFIo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRI50Lzcc1HKFn6\n67xCwmu3kIF9tTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCa\n0SbbMCy1k1SusSKkVcLdIE2Uz2vSMOzRmDFwRi4o2AIhAO54RlUPAossdctPK0GV\n1+uBEkl1Fh5ruCw6cHmjKFuq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3125", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3125` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAZPKTQzOZ100YRYeXswULlq1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkODc4MTk0LTUzNGMtNDI4Yi04NjM4LTYzMzEyZTFjOGUyNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWViZjdmNjYtZDc1\nYy00NzE1LWJjZjMtOGFkMWE0NDU4NWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETZrxCFR6e9+yAaUsS4AG0U/V84THTtg+udNwm0hg5szYCrhLkBEhNatwbGMC\nwSjg9SJEwRwcnz9nJzKiwUAq3KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTkUqyFg8xNotLfSPCxxz3gCEQwUwHwYDVR0j\nBBgwFoAUyw5BdWFfxnXuttCmyO1l64ltT1wwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiB29kVYBG3B97+GX6ehSyXIanIPihvlvx9NyGsAxOWy\n2gIgapy8WgwCl9rQHgvCM9FZlf/t1YYI70uAhHDjGOr4GeQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeTypIeLiEIygX6hYstjShLKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDg3ODE5NC01MzRjLTQyOGItODYzOC02MzMxMmUxYzhlMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQS4JkfmNxAqB3qo2V8GBLidtmmP63BzfmZNfYpls2cjbkb\nzHbPLMCJ7b3rDqoyoooxTVsJL5RitHAO1wbLW331o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyw5BdWFfxnXuttCmyO1l64lt\nT1wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK2zFf4nMnEhAjTMCw5w3BPwtdSEUKfxGMnWGMgEuoGTAiEApuGJPvZU\nZVyrl+rmcNtWXbOlEoPGTGW3p3uy/qDZkQ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYmpsAVD8oIdtPQRPTvuaYDqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWViZjdmNjYtZDc1Yy00NzE1LWJjZjMtOGFkMWE0NDU4NWJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMDg3Y2IwMi1kM2Fl\nLTQ1NmMtYjE5Ni1lMTRjNmM4NzNhMDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATTMA2PBERZeFJE8YAlMXt1EsCYjSgjhN++ykfRAG/p5Owbm060lNOXW8PIaAsU\n2gOoEfTdNLSuajpCv9s73Wfmo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRORSrIWDzE2i0t\n9I8LHHPeAIRDBTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIF/K\nQa4e12xwNt1B93r/1kXkD4vVyld0BXuzf4IWn0HrAiEAoIbBTML5kq+5mxzRv1nP\nym8IARzdC+pl9axz6HUfmQo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3126", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3126` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASURfk/nuCmNfgydyvrEdlV0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjOTBlZmEyLTcxMDAtNGE1OC04ZmJiLTg5ZTMyNGFhMGZjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVlMzNiMWYtY2I1\nNS00NzEyLTg2NDEtYzNhNjQ2ODI5ODQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs+QTy8gjbAHAmyjQ9kQC//PAQ7neBchNNzqyDqaE9XI8tsXThdS3DALmL6bE\n3S1FxKMkKYi3pLtw32GHlZA3BqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6/Hym2n/kNvS+Qac4iZwZ0D+pQMwHwYDVR0j\nBBgwFoAUJkayANsFLuNt8VrI7it/COJ4lJowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAv+oN3Me9RAQiEMME4rCYn7v6jB3JH3JBo4/4M2iF\nphICIAN5qQurCOqE9RzwbMGfEbwfx+vJtFcNOmvGJQ1bdIb/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfckU6ZxRDgHlOmUHYr3FduHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzkwZWZhMi03MTAwLTRhNTgtOGZiYi04OWUzMjRhYTBmYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkPw9OkzYiThWZCzuJ5SbLI+fxltN9ye3FcfWRi9hVL3qT\nkR82CuDfiDDX1G46Hd1B8ED+iY26FP3p5nwJIE75o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJkayANsFLuNt8VrI7it/COJ4\nlJowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKcwLV/PZYchWQhtEXzeIfPUcVJp6xF4n/u17eV8kNDMCIQDySUY2SEae\n63PYRDW0YyVj1HlAfMRORIsodZTUD0lFyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQ1JHgZneJ2aa3TAZfdrLFRHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVlMzNiMWYtY2I1NS00NzEyLTg2NDEtYzNhNjQ2ODI5ODQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YTA5ZmUxMy1mMTc0\nLTQ2MzYtYjE1NS0zNjg4YzRmN2E3ZDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQMYdjfrIV6ATJbaOsMVyHBzp7lB7QIdhELzxOrOaFzlpxHij5ZATOGVpuxS72m\nrP9VD6ehygxHV086OBviK+PKo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTr8fKbaf+Q29L5\nBpziJnBnQP6lAzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDR\nx4PDemgzhPtmix8lxp0HMvMHVPXSjtobxZ8bpA1qSQIgeNATUoXTLVFTzoz+rnEn\nkHweQsuxuh9oxknsmRkJMRg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3127", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3127` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISATk1czagBuMvhqF6A/xMDXbbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxMmUwYmQxLTg0ZjUtNDc4Mi04ZDE1LTQxMDZkZjM3MmFmOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE1MzdiZDMtNzZl\nMi00OGRlLTllNzMtMTIzMDlkODEyMjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEylL7yahDtqrI7twXGqeGhu4By/njJ0DXeeuR9ZXo0sX6ZY4dHWJ2DdFU/w7O\nF4PBri+Pzuo8znyycJpBLeFJS6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHd50XCOzwGJxJpHmaFojiMKy8ecwHwYDVR0j\nBBgwFoAU+2qjbnVU9DZC1i6r5imMgKVLw20wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAyiteGuO4GQ1iCC3g5UD3gqT8RjPmvgAvu+UqHX80eTICIGvb\n963FgPfR1+YH+S+O1UhvBzmjZ5/87wpmyhLN7McW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc4g171/7c8Ag7jwq9YZCapZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTJlMGJkMS04NGY1LTQ3ODItOGQxNS00MTA2ZGYzNzJhZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARb69PFKkCmOUn6ZrDzdJo0/PhpBd4vJkYUX4Uttl7OI3A1\nh5Rejid35H56GaH6nMoA4+quDepBAfiN9fvPHG5mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+2qjbnVU9DZC1i6r5imMgKVL\nw20wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANC1Bc/D9PBG8tzFZfEQRN8YC3bplPXKO9TVmgVmhsliAiEA89TXG5t8\nbSQuwBlfShQ50BPTYvvB7N31z0ievQLFlrk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAV3LqiLrii0q4DtuTbay5yK/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE1MzdiZDMtNzZlMi00OGRlLTllNzMtMTIzMDlkODEyMjI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NGZmZGFhMS1jYmZj\nLTQ0MDQtYTAzNi1jNWFlMmU3YjQyODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARb1INvEBPrKgdt2X34qLQAQ5SkwN6sytpxFN6BQwk64qhBJnmW2XEujHiCOLJr\nmjynX9bvTHJQ3R9M5iputeMXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQd3nRcI7PAYnEm\nkeZoWiOIwrLx5zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCP\nJetrFyfUlGipMePutMf3/aIAhxjIuC66pdgEfCMdOAIhAIGDW/iMSdiPaGdPxSN9\nRmYpYyqAV9teddafbxMfT8Ph\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3128", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3128` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAY+o/K5fcAzapHeLR7qAZqpGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3YzNmODRlLTBiZTItNDA5My1iY2Y2LWVhZDQ5YWRjNzZkMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ5ZDBhNDktNWU5\nMS00NTBjLTg0ZTQtMjRiZmI3YjlkYWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEku9d4UwskarYVw7HifgeHLW601zxy6JgJMeAjQ2x/u2RdZhWtdAzNn3j8Ar0\nsySzC/3WhaG/jIbKzCH1fEmNtKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyLS2/HwQGPfyw/i7T+Qp4p4HhfcwHwYDVR0j\nBBgwFoAUZ3U0L//i7RL8DKRtj6ftYvL+h3kwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAuDvCbvOQnLPdINLCOQJSWMQ+MjEvH5eF\n7YxQcN4PA5UCIQDwUCX2I/W8nOiuHo3+G/3r6z4SX9TZCte4iAUsaGEzEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWi7gZWX/cI0yKIsgOskSv06MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2MzZjg0ZS0wYmUyLTQwOTMtYmNmNi1lYWQ0OWFkYzc2ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWWu7fU+9EOiTCWujfGt2DyAEpZ+ORMNQMHeg47qcJEqD6\nbIwhJ0aRxVsZzSodHjU5XdfnVGAOfthYQrNGjw+Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ3U0L//i7RL8DKRtj6ftYvL+\nh3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLTmZ3ask5RSFrEJhitllRPXM896xtraKdKfHIyZB8vwCIHyawkETXHIE\niKDW1u8nG8y1Ej0amvAeHaOM1me+eem7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAbDTP3rkeWHl9cGcxPxMyje7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ5ZDBhNDktNWU5MS00NTBjLTg0ZTQtMjRiZmI3YjlkYWVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YTk1NmJiNi01NGJh\nLTQwMjYtOWE4MC04ZjI5N2ZlMzQ3MWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASUK5FxhY6hzRUBN1eegkPo3G3gr/MQ5sLglA8keogjpfEmnEZNfwOZjkFz802P\nf0bjgTj1WDG1FpaCeiy466jao2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTItLb8fBAY9/LD\n+LtP5CningeF9zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIE1P\nwrcAlr3MtOy9hB+ydJM0G0oHRT95voFm3QKdYzMtAiBxQqpiWHyS+hEAu6L8HMG3\nXk5y+ZN3NoJ739EuykNgfw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3129", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3129` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAbZ7uheEPB9L3Gezl49dbjKvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMjEyOTRjLTAyYjQtNDk2ZC05Njg5LThlYWU4YzM5ZWU3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJkYzRmZWMtOTk5\nOC00ZWM4LTk2MDktYWFiNjdkMjJmMjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaPmj8xmY8WF2hvBU43835+rOO73L+nTWKNvDNhyOQRZqYDbGKGXDQplYU7cU\n2i2pDGmnqozU4MemB03GOUh4q6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXa7g4p1BTKmVUFGx/s9jSpxYKZIwHwYDVR0j\nBBgwFoAUvB4u5nvJ5ROyqKKs2nDCYfAoztIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA3sJ9g5pywUGwbKLlgKP8QjQGQRbi/dPJn\nrg7oL0dDpQIgKHm5hzcJ8lHmAH8IeVXE/Bu7xffDrkG/THyIjUCOQs8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU4vN3Ix6HGnjg15Ows5CsxMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzIxMjk0Yy0wMmI0LTQ5NmQtOTY4OS04ZWFlOGMzOWVlNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwR5GzzIk6Yk0cFJoiHhPStIF/pVwTyIcmr/8IfSCnns89\n52Q09cLtY7n4SIWN7zPU35NsDoQRp1wYj1JZjJjNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvB4u5nvJ5ROyqKKs2nDCYfAo\nztIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXqUihfITAXMbC58qGO52o5d+PcHdLYywJCn7dLekORcCIHYHSAo+zPkJ\nb4i1w/vC3jmP+NU29HQAvenodfX6MOSB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAWV7EdiP4w4tY+TlG3oJuCsXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJkYzRmZWMtOTk5OC00ZWM4LTk2MDktYWFiNjdkMjJmMjcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NmIwODY2Mi04NmIw\nLTRlZjItYmUzNS01MjY3MzBmMWFlOTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARJB2YO4NyzZX0q7EfRKBRw8Xk3lb1KddBxJYeAZ7YD3NewqyHvLhOEMYLuYy7C\nIa242kz95Y1Usm22Po5DHprzo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdruDinUFMqZVQ\nUbH+z2NKnFgpkjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDh/\nBFTzXidGJA0poRG5Nm5yaMhEkaBa/koIwUjzOEzfAiEA+lwOJmdVzf/LYROb9PBo\nxICC6/L4BKFiZ6lbiezkJwk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3130", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3130` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATlgTd6StJ3N59U2ltNOEvPwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwZGFhNTlhLWQzOWUtNDNmNS04ZGI1LWM3N2FiOWMzZWNmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE3MmMzNmUtZGMz\nNS00MThkLThlMmYtM2Q1ZGVlYWRjNzI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXKapx0J9Kx0CPl1QYgsYbBB0qpJSSdEM2G7ivQ4oEUkbYocTeuxxeIu2sxu+\ni5Ppovd1cdVn0aezV6YPIIcn6qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2HjTAngYMSLB3GWXKAhQcOx8JB4wHwYDVR0j\nBBgwFoAU3gNEPwF0Hv/R+fcIEUl90KIvwokwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBRSIsREreROgJW\n6+/RzWHjM01H8EHdQlU1fOKmC7LDmgIhAI2tH4/7mmmfVSyFedoxep11J0OcfJxc\nNoOcuHF8MlWq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf+kESu+CW/IXwt4rwh1IFSOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGRhYTU5YS1kMzllLTQzZjUtOGRiNS1jNzdhYjljM2VjZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuus1TMhumgF38YSb/yxXcgg13dbvWdcsrW8iuO28qb3Bs\nndCQZf6olSgbZVk1vvNk3H1Iq3KZCHbjFNlqejI2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3gNEPwF0Hv/R+fcIEUl90KIv\nwokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDIVRmJ8vmcR4eEVEHELO3GeEwbKpPAkS9UW7QzKP9cMCIA+D1+aLeqWY\n4n3OBcTz9W1Gw/nx2HwFLc+drU3X3T/s\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAdSe1/UXzTOolmhUUSa0X+PEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE3MmMzNmUtZGMzNS00MThkLThlMmYtM2Q1ZGVlYWRjNzI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNTgzMjllZC1jNWFl\nLTQxYjUtYjQ1OC1hYmY1YjY0ZmJmNGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATYAzlnexPqEDX+4f6+11ge7vLHk26s9jqGgdwSsxOWPTdlcKQARpSwU2tX3gp8\ntn7H2G1NU/4ZsKBrEhXvw6KMo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYeNMCeBgxIsHc\nZZcoCFBw7HwkHjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGiV\nIGpWx/xV2IuaW84IcElH0iRutxglHmtOUjDCdEVPAiBCT5xpVyefASjnPCQdZIP1\n56t3N7pswxsA7BCA5ps/bg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3131", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3131` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAc0VCWQZRyu7K5ISHeRJZJvNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNGMyYzI1LTQ5MDAtNGUzMS04Yjc4LTkwMWQ3YjI0MmYxNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE0MzMyZTYtZmQz\nNy00MzlkLWI0YzItYzY5ZTRhNTUyZGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE76fDne+ou6L+Fgd/ZStKUnIwHyvIw0ZEW1vOnFgwb3sb/qg5bUuCNzq2cbDe\ntxpzsB9vc6TtNa0tWK+3Ve9IDKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1ACEpRTdVGy/AGncaG76ZMjoCQIwHwYDVR0j\nBBgwFoAUUAVa7nbYpOte2NpS6kwtOVTbtX4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFB9r4zgbU+jZSmnu1brEgvBJzbVJYKoBTbzpL0dVXolAiAMt/yxo1qIT2QN\np1ZoRpQaats+BzOu1GqqRjOypnkLqg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXaCZ3y3DoREyaxN99qYfi/YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDRjMmMyNS00OTAwLTRlMzEtOGI3OC05MDFkN2IyNDJmMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGxowZZ3DQTf6Mu5Ci74JTsMnZy/fr/mg25w2/tf0hCgcs\n48TWIH80gujKdAqxu+c0B0LG6LDbhDJikzNeriU0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUAVa7nbYpOte2NpS6kwtOVTb\ntX4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP+R12U/ZHZv1u48DZFPkLcBmEKVDyHf69+g9Ptj3+6sCIQClKFCD3VXF\nLdYpCLSlrofuS4Fwg2frb8fhzrwiO1X5mA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAVDKr6bcKsC1esTMszJ87Ff6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE0MzMyZTYtZmQzNy00MzlkLWI0YzItYzY5ZTRhNTUyZGEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5Y2Y4NDFiYi00ZjQ1\nLTRhZWMtOTQ5Zi1jOWNkMDFlMDA2NGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARw7uX9Fqdty1xtQAbHdWAQsskQr3Ym8j5mlwgNp0/6sVADtEBu0YSKIMGXFzn9\nqUmLmWY7PrGLNtBsGoTRYHU3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTUAISlFN1UbL8A\nadxobvpkyOgJAjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCID/G\nLiADPxlxkEY/lpx+f3+r3XvYHjmv4AfB3rKnDFKhAiBkPkkjQmQdpc84BO3UhxXC\nS8TGdLiaVcSI91kYNcMYTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3132", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3132` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeV7razvK19J+RF+PeCwmRD1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3NDQ3ZTBjLTc2OGEtNGIyMy05ZWZkLTg0ZTNhZWRjMDAwYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYxOWM4ODMtZWFi\nMy00Njk1LWI0NmUtOTcyNDU5MjgzNzdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdopFpgnC9E9aelLVIPqBb4geZY8Giv0KBZfwZcXwdwKjugrXYy1i7yu9T8V1\ntAEZM2djNc+34PWcI8zyEOaFOqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe5Z6bIRpldd2H4hDT00F9tR03B0wHwYDVR0j\nBBgwFoAUXdTtsTXTiS/kR0U5QTO7UGq9I1UwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDkVapm8G/qOAqZPEG1urRxCelXuvSeGy5CueVNU88Q8QIgU1xw/s4HRTVn\nenvv/tGI8LYPML23W6zgH4FtieCazSY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATLWRMWU+Q7kfRs3JWM8opCkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzQ0N2UwYy03NjhhLTRiMjMtOWVmZC04NGUzYWVkYzAwMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpHdT4SsiVKQaF9B2GDCOMS2RV6Odvpi1ZuBrFv6fXp5qB\nw1vfe7wzqHir3sxLg5gSihL3W1YtIRDxxp3+qcGTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXdTtsTXTiS/kR0U5QTO7UGq9\nI1UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDbPCxcpx9ZNI5UAJBsgOiu0jomn0SI8Y+Wwd+6bZ/SUCIC0NZI5Wf0pv\nee0bQ4P/gpepYNq4WO3hhPKFDeR3BWKS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISATmefZVRFsGLGYoe6gQszv5fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYxOWM4ODMtZWFiMy00Njk1LWI0NmUtOTcyNDU5MjgzNzdhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMDM5ZmU5MC01NGNl\nLTQzYjEtODlkZS0zYmQ3ODgyMDIzOGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS0gDiI9RqvzCLqnI7ijqQB0UlF73UPFQO9zZ4DZhcepq7EtpAuXsetItrZda0b\nfGJbw4nzSh15qtWLQMmZWujmo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR7lnpshGmV13Yf\niENPTQX21HTcHTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIG12\nrDzFcd6W72vWsRtgJ/PFmjQJD3c5qObYN8zDMXp2AiEAs2Oh/qzpxQtaDOe6wFaq\nP522/efd3Iqozgo0mAcvdIM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3133", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3133` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAbeFJDCVeC9e0krolalLperDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMjI4ODNjLTk5ZDktNDRjYy04M2E1LWM1MTUzMGU1NjRjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVhZjAyYmEtMjdi\nNC00ZmZkLWI4YTgtNjY4MTcwZTU5YzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0GvWnHIIyYx+b7sBKtNe2uXTP3vyfnBm7Pblj8alPNJI4bRrGW1Yjpk7PAxT\nPBC/17V0kBR+jnhwyY9WLmdyvqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5bb69gC15mGTlQuVi59tfexU5DgwHwYDVR0j\nBBgwFoAUo1nqx9/7+lFQmXkHOtao4emwIOswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBXpSMLwA8zowZtOq+3nnzag2JIv/Rd4Cfb54/LRqZhMQIgJ3vJ1+GNmUj5\ncen2cg0L7EbE4jYlOELbeDgo59iO+xw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd7SuPjBYnbnbqJrcqM2VOCeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTIyODgzYy05OWQ5LTQ0Y2MtODNhNS1jNTE1MzBlNTY0Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREAgOwTK8qGovfzkGGDp4p/JC5quqpu0/V3ZQwgud988Zs\n3/X/72iP4SXaHEydWNsXs9Xf+CZTKwdIvzFGTdm5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo1nqx9/7+lFQmXkHOtao4emw\nIOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMW08hrXsfJU5qINgcR/28QHe6TWFNnf+4u1jhu7Dk/YCIQCiQFZdiD34\nAMiJpvDDckMqrgwGvIvUXiDKgM1b5PM1/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAVH95Vci2kEmDbE7XkWf+GWfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVhZjAyYmEtMjdiNC00ZmZkLWI4YTgtNjY4MTcwZTU5YzI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhY2IwZmI0NS0yM2Ri\nLTRiYTYtYmEyMS1lMjM3ZTA5ZmE0M2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARA0Zeyn8yF3+ZjADGiutmq2016Y1GwU/mqRcbB0IM8HX49WKRDtPFgGMHJjxAf\nHe4PMNf7PFQW0ySviRKTMNdPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTltvr2ALXmYZOV\nC5WLn2197FTkODAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDr\nxK9laXSsQz8SYqsqS1C0kiJvivZVJZ1gkQvXUPyg8QIgGDFQ+9bGXx20Tysd6jvG\n6HQ+LtrvEGibQR+sSu/Xgc0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3134", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3134` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAe4Smaw5P/CGkEns4dJb8jaKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YzE0MzcwLTY4MzgtNDA4Ni04ZGYwLTVjM2RlMzAxZmU3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM0Mjc4YTQtMjQ5\nOS00MmM2LWE1YTYtZGFlYTE4NDc4NTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiC9nZBGRLIoBcKbyI3HUWYQyA8cGmjZCz3IH+J5YsYfU0bfqq6gQgERmH0jf\n6B2gSGZ6mMtkjVicFO90fll2qqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv/E8uVagdiikb8uV7v3zSxemj5MwHwYDVR0j\nBBgwFoAUxq1zECZZhl5Ox/ltv21MkqBLZS4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBMNbMvhFveuabSwKlgtrH13FrCNBHevo1Nh5VARn4e\nfQIhAL5EQfJrA8BgqkOS2uyNBnG4Z3mfJshTg1uOAwcnxpWK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWf7YHYIRdrAhULdcm0K9B26MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWMxNDM3MC02ODM4LTQwODYtOGRmMC01YzNkZTMwMWZlN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcTVDn8I6NEcHhsUnbPb2TRKWeBH+FVRA6nmnnGLVSmsgQ\nEYqHw19h9xskP3bhyFP1OQnLwkvVVxXb+kirVZk0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxq1zECZZhl5Ox/ltv21MkqBL\nZS4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJYBcgSllRRfdMREi851kAGnDIS9Rxds0/L/0dJoy5OxAiBlwl/Fhg99\nH/3RySeueNTyWgio6seaovQtBj/LYGZM5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAU7zbjku98Vb59RWJpP7RMLKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM0Mjc4YTQtMjQ5OS00MmM2LWE1YTYtZGFlYTE4NDc4NTYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzM2FjZDY5Ni1iOTgz\nLTQ3ZDMtYTBiZC1jMTQwZWI2MTE2ZjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATD/etJnXk/jBwTHfkCutnrfU8d2b0ZrSpRNsDM8Daq0UN0SqgcdA2V+kXpfMP3\nilSEiHspBUdmjdDygcBq7dWio2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS/8Ty5VqB2KKRv\ny5Xu/fNLF6aPkzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCR\nJMBuNhdXQa1DL1lItI16kWwQ52QWdF6hXUc1xZrb5AIgFg3CnzXEDB5+zpaF9YGD\ndjsX4LMvAvUCB6Qs8nTzjtc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3135", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3135` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWJgtvHCFLUkfrFrdiLwW7XIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4N2QwMjQ3LWVlM2MtNDA0MS1iN2I3LThjZDNlOTM1NGZiOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk1MTJkNWUtZjFk\nMC00ZDA3LWE0YmYtZDhhYjRkZGE1ZTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdSPO1IZFcktfY1GWnLzwg09HegVUkpJTRJ08w2ssSswEOeGQeku0opZ5oT75\nNTDsp4oKV+5QliBwforLwTUlAqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgrchoWhONr4pwZvcqm5iha3KOMAwHwYDVR0j\nBBgwFoAUJRxuUt4fCOl5KmurW+ZR3jHBFzAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA50yhOUMbVrJpOB0QnIELZ+uSycaOcjXBgM9x+xuO\n+ggCIFiWZS0edBjjChOVinUDaU0nq7n255WLLkEHGAM3SbtL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa+a/ERBBG/j7M8HQz51yUkIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODdkMDI0Ny1lZTNjLTQwNDEtYjdiNy04Y2QzZTkzNTRmYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHWj1IGj/Omy/rvuvdxG2hmv+OQGsYyrjsJElETQqubkPl\nazmp5GD2FTyKRAsbB7CDT5UT7vFr9WXB0oo/wK2do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJRxuUt4fCOl5KmurW+ZR3jHB\nFzAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDkMs2y7caknSBQ45w/8N8yKnrapGou7c/c40ijFBTyACIGdIWTNk0syP\ncLnPfCYeh26LC+OfDRZMLi6Q/y2BdUig\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAcBEnYr7GhLbDTZoZxOo3WKWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk1MTJkNWUtZjFkMC00ZDA3LWE0YmYtZDhhYjRkZGE1ZTU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMTgzNTkzYy0xMTgz\nLTQ1YmYtODc5Yi02MzgzOGMwZDc2ZmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQlpoTkMn8Bv5ljSQAdKCNNFbJbPvXSZASNguP9N4gX/vPW/5kLp/0rTL4nasqB\nF1kDcHvlse4fp/9IQ7nj8JbBo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSCtyGhaE42vinB\nm9yqbmKFrco4wDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCk\nPMSBJ1TRtlion++xTj5RqqcTjYLsn3ZlTor1e0VOcgIgUiJOhfbBD1yFh00xuFcY\nDL7+IILu8XE+e36d8rQT1xY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3136", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3136` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASn7t+9HyGUPw5R0qwemlCM8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyMGU3MzVjLTNiNzItNGRkNy1iMDE5LWE1OWNiMTdlMmVjNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE1OTRjYzctM2Vk\nYi00NzI2LWJlZGQtMDEwNzM1NjRiMWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXCWicBNSoDPceIBaFdtWuLaSAmFtKOF/qbVd/F/NInLNliD20rzXLvcj2gxu\nKv/VoEL/5aIxGUEIZuFXOnSpxaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyQV9Axy0NZSJUPwqwRRX+CNEz3gwHwYDVR0j\nBBgwFoAUF0dZVEg8vw4bR6XUl2uYhPAeQzUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBy971Ck09GKFgmG+N3vlkY/ch9sE7M+bEw+OYP6tmdDwIhAK/b\nnBlGimgh1Yyhd/dsy3znRj69ruoMvph0YnRhbGDh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbaSrv9D4l1ZYGhttRZQhEcnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjBlNzM1Yy0zYjcyLTRkZDctYjAxOS1hNTljYjE3ZTJlYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATp/UZ4Bji7nkCmyEGwpfcZqJeFQO8jAImnENWZ7TohUZ9a\nkazF5NZQpX+Z2g+7F63E6y0hWwCsxp0ztZvHLgpIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF0dZVEg8vw4bR6XUl2uYhPAe\nQzUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKT/l3SJhzFxkL9IMymLHPnDBxGG3ILnm/4J0rppdEZIAiA4UTYDPRwf\nzPZbueUl/4MCij22gPo0ewRtpwCGzm9nkA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAaayQHDFQ2tvxEzWlotisa9HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE1OTRjYzctM2VkYi00NzI2LWJlZGQtMDEwNzM1NjRiMWM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmOWU2N2FhZi1iOGEz\nLTQ2ZDktYjQ2OC1mMGVmMTI1NDc2ZmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATvbLj7vBeConbwKnzg4rouNxVeeWQh/O1X47iU0R8Oh32zd12M4b9i2EQshsGg\nirLblU6q2q94Sn/q8r5Fq5eso2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTJBX0DHLQ1lIlQ\n/CrBFFf4I0TPeDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCE\nJ31QEb4748+G1liZZ7QESR9qZUU/W4NmiR9T+LxzaQIhAIm/OQTD0wEy726gGsUw\nsgBLb9Pu5WoC1mhNkecIp2Gy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3137", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3137` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAVVSOx0/nB72GUDxJis/oje3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkOGJmMTk1LWY3ZmItNDU0NC04YmZkLTE3NjJhY2I5ZGZhYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ0YmJlOTUtZjgy\nMi00NTA3LTk5NmItMGFhNmI2YmM3YzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmmGUpUe04hnFtLhtOHzbyAcPqfTqiUYgF+6CeDPVOvvtsSLvShfGL22bg3PW\n0KTkesryt7SayYmQiJ6mb6ZcTqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1CixEAsPSSZjWh0SjkQNBbmIIs8wHwYDVR0j\nBBgwFoAUWgcWsTtMmYHgxWz1Gh4fGaNeuyswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB1tMBphkSTjiHGYQwjuGWliYbTpB7wpBLU\nCE7RbTunqwIgZl/ysTVFZ3fC2Ix26jQbuHyzat1hpTaWxJXSXxBofno=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb34m6Iy1mrA6kIC3hFhdzfxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDhiZjE5NS1mN2ZiLTQ1NDQtOGJmZC0xNzYyYWNiOWRmYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTDwMm6gUz3wk/aj7mQt7YqtUgLojK/aiQuqNl8LWD7lzV\nZwDZZJQmq0yCOIp2i/Qza3b5h1srzqdUO7gwKtngo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWgcWsTtMmYHgxWz1Gh4fGaNe\nuyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXWX7bW1V2J7KHb5Ajmh+cKoUB0hTYwD9knqNNPzTqe4CIQCYkfQfjnl/\nCUv9/9IljYmn6Sthk2Oj3ogoq0iUpRpFHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQ6hwumrRrZbG8rAKgpgEpK2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ0YmJlOTUtZjgyMi00NTA3LTk5NmItMGFhNmI2YmM3YzEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MDllZjE0ZS01MmEx\nLTRhMjgtODY2NS1iYzY0MTU3ZjI0ZTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASnmZM1Y5Xk+apaxoxGolwIMSnfwYua35HoZxw7fJdAiWzvHZEn8xsFPWKHWUWA\nn7biXd20+RZY0vj6R66y6fOco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTUKLEQCw9JJmNa\nHRKORA0FuYgizzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBpI\n/PPxcp3nliIS6MGl62QLXefLHYnafm98pavpvUTsAiEA8eH3d/4C9f9udWggYC2x\nkj2yu6Tnb6+IxTVk+weBBak=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3138", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3138` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAUhV2XTyeeaMyVan+63Rp4ufMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2ZDE2YTkyLTYyNDUtNGFlYy1iZTJlLThiYmQ4MWFmY2IyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZhMDZiN2QtOGNk\nYi00ZWRmLWFkYmYtYjY0YTE4ZWRkYjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+FcxP0w+X7PfNPort7t1pWCZxaCeRzvJ/I55I+Lx2DxsaZSI5vQ8o+gFIFik\n4AlmMoFWExCU38i3YTgBER919KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZsgZTPUylpqyR2enbty4Yqt3+ZMwHwYDVR0j\nBBgwFoAU9QjH1shxWd4SKugIlvrirUemW3AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBXA+wI1SF4ex5nAYrL92Qd7wucrULp/YDB\nCam/BD8YWgIgIYhEVuxqxvAtILAsOxU9DDJN/fE4hkkH6Kp1j6h0XBM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAago/wnP7TOlxpME9e6vOslRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmQxNmE5Mi02MjQ1LTRhZWMtYmUyZS04YmJkODFhZmNiMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATljfWn1uFDB62DCQmLWfPU1ao0abJdecxEDyYxqHmrTgOG\nyEMyyHG00/I18p2YYb9wDw6G6LCHvnUO0PABpcGzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9QjH1shxWd4SKugIlvrirUem\nW3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL5lWqf7CXT1bYyvaQXhb2vUTWOPmTa39zRiPeeEX4miAiEAruBvu+5f\nv/Zwe37qtkHV+YTRrvLe4geanane/lATty4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAS1b7Wsawb2uvDwj+mvktPlmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZhMDZiN2QtOGNkYi00ZWRmLWFkYmYtYjY0YTE4ZWRkYjRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNGI3Yjg5Ni00OWU3\nLTQ1ZjAtYWEwOC0wZmJhNmE1MjdiM2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASbBHrU40mQwuZp0m76LCy2YHyfXvoF3j7m7h/xuAxMrMCkoyXUII/YLgirbZV7\nk4zlkcb3oklAAsWE74HeYO1do2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmyBlM9TKWmrJH\nZ6du3Lhiq3f5kzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIALq\n6ZCynj2KlqYLagouXWKyK0U3WzQMPp3Cw9YBFSnVAiBjTM5yhcrXyiNvQri0LD7q\nxR7t+40cUOZzhDycGbQSJw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3139", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3139` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdAjACll+eo3l904J3TSF9IrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4M2UxNjc5LTNhMDMtNGI4Ny1hY2I5LTU2ZGE0N2MyNDE2YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjkwYjMwYWUtYmQ5\nZC00NjQxLTk4YTYtMjJkN2M0ZjM2ZWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuXLWglLRPaON8PUYVja1CJ3BqRmyNg94HVDSg9SNa+pa3MOZTHEIZjerMrTg\nLlBBYabuNTaiTrHJ5OAXkLeSX6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXK/2BTHIZy642xQJv9PMP0u9TlMwHwYDVR0j\nBBgwFoAUqrTTT6K5T8Oo7MSgoqBOmB4b9pEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCsJAogJj61xeRCJWkdwkVRMwvp\n105mJhpeYPM/ujgdqAIgFdMtYkI8eX7xmS/+EqypO3y7ZOYyJsegWDEsIBX7Z14=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWBuFW/jC0N2BK1FYgEdCCjEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODNlMTY3OS0zYTAzLTRiODctYWNiOS01NmRhNDdjMjQxNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ58ctYJEy/Kzm/vy4FecM49kUOkwAbEs0GG8bFivYaCffo\nsayMlPJr/X0jHJuV/F+pixZfDD0v1/xBtlJoCXNyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqrTTT6K5T8Oo7MSgoqBOmB4b\n9pEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOI6+k+OxJvFjx2cp4XyUhiviO4UXdEq0eD70wmntgglAiBPlHNGrhVO\nlHVY04dW8SGXgYxJCvc+J2o1F3phhL/HtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAXjPaGlpz260uN7bAt+O5cK1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjkwYjMwYWUtYmQ5ZC00NjQxLTk4YTYtMjJkN2M0ZjM2ZWE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MTU0N2FkNi03NmE4\nLTRhY2QtYjVkZi1iN2ExM2ZjNGZlYmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATc3PSuv029YKZr4RvUukKmjS/39vkzHKkZ6qzMPbAwrfiFXdzaHe7jWdXBK2s8\nsTrxTYXHH091xpNA5IgzVnQfo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRcr/YFMchnLrjb\nFAm/08w/S71OUzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGXs\nyly2M1vFHGgTfg33qFbtJzXxhjtkFkLtqg7V+utpAiEA+mNnK/jbm208np2qXCvz\nIH5aKAtqfiPTzw46+9o/hYc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3140", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3140` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAdzOdGsHY5ebLjb9gGCMlJhRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViYzlhNDk4LTI3MGYtNGYwNC05OGVlLTMyYmY1ZGZkMDRkZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU5NDA3NTUtZDdk\nZi00YTRhLTgyNzEtZTg2YzVjM2M0MGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbGUp31gGqwnHjL8jJo4ubqtkDc5pEWqAYdkzTK1zo7oyduqBybZBPmig1w4U\nvMMqe7h2KwfIOgoIifQCqRJ6g6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNv9c4HhXihMrMQC/HogzrD7Rc8EwHwYDVR0j\nBBgwFoAUtTUNimiOYVtYECKYifQHV6FAjowwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPTugVMf\nHex42fFTEKr0Vf8LfxIWcy2GrM2TyqoI5pbHAiEAtyRt1APzgHYTGzWQWOrFLbSd\n2zClYU/kIbAkWQ6gAow=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQO0odFXuLk2cgY8V8gcZkX5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmM5YTQ5OC0yNzBmLTRmMDQtOThlZS0zMmJmNWRmZDA0ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwbk0PQ5722rL1OnkwXncvSFMoOxFwzlUJZF8LfiCfZfOt\n9tGg5Nir8Y1iQ6V8s+UzZAdLF6J9aPJgQfckdx4mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtTUNimiOYVtYECKYifQHV6FA\njowwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVAp8rIAj0/Dgr8Fi4oqS6qthV6/ZI64+x/Ie3IbK/M0CIQCqU83syYbf\ntSGnRrokuBkgzMIhxtIzKuEysxY7LS/CFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAWzS9ZvzoxDKinNNd3wQXc8gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU5NDA3NTUtZDdkZi00YTRhLTgyNzEtZTg2YzVjM2M0MGY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMGM2ZmI0YS03MTA5\nLTQxMjQtOWIwOS1mYmQ1ODQxMThhOWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASPuK55n0cExeNXbr8ZuQAhEF6BwkE3PZ2Ejw1rv5uIrBgJ1kOuRhI+e3gMrtE7\nhrH9aXJUxAq8pjEn9ErRvfino2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ2/1zgeFeKEysx\nAL8eiDOsPtFzwTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFNS\nQFYSfcmLzypVK1Vg9ceuZ/f8JsgcmWlsJfCw9KwPAiEAtf+r51B8M8YQh4NWO2D5\nxriRmPuKWlV01FZLA2juWD4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3141", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3141` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAcvgisUn7IjSbD8ZoaAAjmK/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ZjhiZjJkLTA2MDUtNGZkMy05YTRlLTQwNDhiYTk0ZjBlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMyNGY2MzktNjYw\nMy00ZTdhLWExNTItNzg4YmMwNGEzNmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH7c+sWiUYwh5xLqzKsBCVv/woHPlO8QuQgijhznVdp1NFR5xM5BrWTXJoSVn\nmwg3YDr+v1hVkssAji0WZwQaV6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdnBTuEJLY2YaYATDt1sC3txjtWUwHwYDVR0j\nBBgwFoAUh3KP5LO8I96etIexWXK1uzBnHKUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAKHVR2YT\n01t01BhWCy2yaZt+F8ECl1ir7FatNyHNE1SrAiEA9X/PHT8eM9XrqHhl1QolBMyU\nW+SS8qb3ALDtyugjxsw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcq4ODLLqf5cI3xAvkXjVdp6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGY4YmYyZC0wNjA1LTRmZDMtOWE0ZS00MDQ4YmE5NGYwZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATX3RA6kRwFgOaGNB/5YierF+UM6mLW0yQWa5XrCXlxLShj\nUJOFe6tmQUJYM2sGR8pNHzHccjhiq9UvjbK4VVu3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh3KP5LO8I96etIexWXK1uzBn\nHKUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIbWQe0qku/SfOCkmjsSB9QC3PTWXla5dNHT7w6Yz5FYAiBReoTWBmDi\nC/Nvgem26YQ/hmz5q1GnGYoK7vN7BNAYLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISARQmdFaiiBgofqJwXdInKnjzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMyNGY2MzktNjYwMy00ZTdhLWExNTItNzg4YmMwNGEzNmMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYWE1NDMyNy00OWNk\nLTQwOWYtOTgzNy1lMmYwOGQzODA3M2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQX5ZtN/jMENBuIadlOMmQa0YBfvVgL8LTJGwRapZaAvoSWZj4PorHsujEne3/1\n1C7zLWwwuiRM3ymeKVTNEhs5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2cFO4QktjZhpg\nBMO3WwLe3GO1ZTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGA5\nLhBT+5yI5GsWsCgxHOZuLuhBLEISHU5c5T75Lg4IAiEAz99Px7ppKdWvzijmNFW3\nOLmxao3grWH+C1JgK/kuEpo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3142", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3142` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAbM+oQ9t5LuqQECeek9Z5z/xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMWE5MTdjLTQ2MTktNDAxMy1hYWU1LTBjMjI5ZWU4MTM2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmJhZjkyYmUtM2I2\nOC00ZjEwLTg5OWYtNmM2YTA2ODc5MzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExr8oUpl0ohVZvwRj9m4aF/UZ9GLEUxEO9WpjA3UpQRGYawH9DwnVSmyVJSqY\nfV03nOTg037sXvMWz2x+XtGl1qOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUtmX2o/CPiPsapT34N9aA95bH4YwHwYDVR0j\nBBgwFoAUuzB2eTgT7ZIGziMigVUvnaKZNqswLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCID1XXa7j\nRHXUlT2grJgEd967I5a7uVxTgT5AcDIU/iuvAiBmOnttUA8e2JfTWmwrY3XzB1YH\nD+0kQAvxA3/D1DZWOg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXWyx4+cTo9gL+21lxmAppWAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjFhOTE3Yy00NjE5LTQwMTMtYWFlNS0wYzIyOWVlODEzNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7N8SwDK7or+toioUJvcXT1EdZU3YwHSFYYKHAK3REJcoo\nPFq2/2cub3sNFgRtyhpL+KfE0LBhpCQ+oxgWrTQdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuzB2eTgT7ZIGziMigVUvnaKZ\nNqswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALl/Ubsl2eVsX1NqxjnG7Tjbr5uTozg/dTw2cuGYPwgsAiBunhDalHOu\nCKwaqlU4gb7MCow14DoeVD+cDd2Yebe30g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYgFCMXBKh5+N1oOZLGhhbSwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmJhZjkyYmUtM2I2OC00ZjEwLTg5OWYtNmM2YTA2ODc5MzAzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZWRkMjRiNy04N2E4\nLTRkZTItYjYyZC1jYmE2YTEyZTlmNzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASUcYXEVo2VYQJq01Jp2sfxKAbqvwkA8Y4KgV/1znLp1SHXkTgWhlfXMeEXWx4s\nrrOlJ+ZNNyq6j5j2qWwa9mljo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRS2Zfaj8I+I+xq\nlPfg31oD3lsfhjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCj\nJbnmo18z2Rg6828RHs+9edmZp3WPw4IO9ec+EvDbXQIgD4OvnqBLLo3QqtSudP5M\nP621sFlTmtS9BmQ6KLYMJSE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3143", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3143` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdY7Tzup6/4dHoAlgmQCEvp7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlYjI2NjhlLTk5NjYtNDFhOS1iNjgzLTg3MWQzYTdmODkzNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRkYzAwMjktOTNi\nNS00OTk4LTg2Y2UtYzJlOTk0ZWFkODllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgXpF0Yp0rkKm8dc1AeIOELtqaTisMBGC74RsEkyBjXhgYHla5Ac//2IBIYwO\nrvrCRjYoBoIz+sjO5/bUVY5uc6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOtwPDqqSUY2kSmmac92EDmLuMWIwHwYDVR0j\nBBgwFoAU3WaeG8X8Hw4crQoVnReya3l6yUQwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIAsOb2McQNwoBow7z64zEMW6fZqMSyirvrkAJ5TFGeCGAiEAgrG+KFnW\nCCjSpp91WNnPkYzNxPZQF/VBff2+7ntnmKc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbtVgM+62X1y7JGWAIiNJA2VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZWIyNjY4ZS05OTY2LTQxYTktYjY4My04NzFkM2E3Zjg5MzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVtgKT6T1GWatOREW0bk7GeCcHs9O+AcbAbA/PPkipXjH/\n6aZvSGqG4gGocJT3W2QzJAeB1qao2erqnIt6QNkIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3WaeG8X8Hw4crQoVnReya3l6\nyUQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKEpy8km0S+JXKVicpr2vsAxdbdy0m746OTP+/1apOnZAiAkKQYs4fLF\ngPcVMvhyoMqYzOdNblS5WV5ewD4kW+q7hg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAT9FH10j2EgzF8CCqFcwTgqUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRkYzAwMjktOTNiNS00OTk4LTg2Y2UtYzJlOTk0ZWFkODllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMjY3ZjllYi1jMTg2\nLTQ2N2YtOGExMy02ZmM1ZDhjOWIxYzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQUnOqlSIopM+aIH0gM3f38dtPBn7Qrn/z7rII7Rs8VG92Zjwt6Xu5CPPjZ3Rl1\nMQpL7Qtm44Zr/W5dfyJhAf2Po2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ63A8OqpJRjaRK\naZpz3YQOYu4xYjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDp\nMrZbRbrlHJPOl+RW02c+8iY0AnzdK/WOIBVpzeTWnQIgMyWLpdhrv37i3gNX008/\naTOz8QobOE+Wglm5pMBMAIU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3144", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3144` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAdtYGKijD4cuNY8j5vSHWrDhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4MGIyMDhlLWMyMmUtNDE4Mi1hMDBkLWEwM2E1MmM3NDhjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRlZGI4ZTAtNjE5\nNi00YWNiLTgyNmUtZmMzY2Y0YjBiZmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzr3UgUw14wsmO7hcGw2MQqw1m3HDcjMYlgbNVV/5MgGY2liM6T32eRTkKhto\n0rF2Z5H9XSB0uEa1mUUiSUWGqKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrURRXLjGLfFp56KitNRQ16rVZjUwHwYDVR0j\nBBgwFoAUZqAHxIYQt8anF7UnnlAoAQyLCsgwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIFqU+5WtrnsFQYXKL3ggI5lwc0Vk5DXlb2s6Yd+DjQ0PAiBf8FcspGlS\nUnPoqlBiGljMOfcpazVfy416uc12aO3egQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf9v6c9ctrOvJorfmSM+XP0GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODBiMjA4ZS1jMjJlLTQxODItYTAwZC1hMDNhNTJjNzQ4Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcpV8PK0uv4I7XjpMuobH1aYCeEwrvwOah28mYNi3XSw1A\n/xmmFbT6fiLNCn0ZajCco/kjjzt1c1zu4f/jS6FPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZqAHxIYQt8anF7UnnlAoAQyL\nCsgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTqk+BlEY1ZkyI0T9lKVl0/3WkVGk0TsOSfkubWt5TS0CIDIPETBinoko\nDqg78WMqE72W/9gdub8jQYY+m8SZ4gpC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYzUe4ah5kFysMF1oIZ+ecADMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRlZGI4ZTAtNjE5Ni00YWNiLTgyNmUtZmMzY2Y0YjBiZmRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMTNhNjI2ZC04Yzdk\nLTQ2YmEtYjZiMi01ZDg0ZTBmM2UxNmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS11eUfNQsTP3dUfcvsbEKd0gfNdcTmuka4bdkrYwXI0sn+b3V5IlVIBUmW3Dmy\n3Fh/XT1F/NNrCJ4+M7++EapOo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBStRFFcuMYt8Wnn\noqK01FDXqtVmNTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFkS\nta32O4BypZEs4Ic3UUP9+kafqg6lPZ4GoVWnMlEfAiEA/6FuIyAHbs3RBA3FfyDQ\nFuqppLDBWxa/3VdYIJPTD4k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3145", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3145` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAXrCJ2FVNRj102bsmECZC+9zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5NGYzNTIwLTRlOWUtNDFjOC1iY2EzLWJjNmUwYmE4YzYwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYwMjVkZjEtMjE4\nOS00MjJiLWI4NDQtZjk3NjA1OGIyYWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnf+NfUzIYLh+Saaio+VrpEP2ro4wS97zXqJuZef5N9SbuEL3FUkNU+Lm3Cn/\nX4qSa43uUFb9/JVhno2mxfNiP6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEgTsI0OWUha8RmdqrMWR+bw2mswHwYDVR0j\nBBgwFoAUcF4Z75ScFHS781qlwcukJRMZ4tYwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDYSsaiqqOA9Y+JBTQpfXlXnmuiIch5dNSUpUMuuhruoQIgXv7S5LO+agAKU+o8\n9FdBNksUXzt2OO2ZLkknfHixFr8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT5N+rwkf0SjFshV6jqKO29LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTRmMzUyMC00ZTllLTQxYzgtYmNhMy1iYzZlMGJhOGM2MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsDCiEEkxxddr8XeFqYZUbBthSHNVQOlTSy1b5s2V4ohyE\n2qjs02IZ4or/rHvY1ZW0mSssqH6ywkLHeehXvtlco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcF4Z75ScFHS781qlwcukJRMZ\n4tYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOv2kPJ/XPEtmk9n+S1iuxIDIlfvtAEaTPhV3shChbpaAiBB170aCWpc\n/dIpgUz8VA7UAj0aYnpdtAoFb/pCxFHKhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAXfspBI03D6hFltO/e0t4Vf3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYwMjVkZjEtMjE4OS00MjJiLWI4NDQtZjk3NjA1OGIyYWMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZTAxMjFlYy0wNzMw\nLTQxOGMtYjMyNC0zNTBmNjE1MzJjYjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATYDK1o8tGgzu2UyRsiUIOxVSNnBpAbmbz22HOnjdea0qXoi5uL4zYAWL4K+Bey\nDF4Alpsw1Kh8F5eguDSO7dCOo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR8SBOwjQ5ZSFrx\nGZ2qsxZH5vDaazAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIALX\nSygluUXb2KsipZgDFM3bg6jp72ol56SJUiWdwHroAiEA1iBBhkgMku0aJTfWv+M7\nQyaOAXHBiH73uqtZyU3v3Qg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3146", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3146` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISATiNt67C2nwDTfeTeJrhaiQ0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiMWEwNGNhLTQzMDQtNDIxYS05OTU2LTI4YWNiZTRlNjA5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmVhMDhhMzQtZTc2\nOC00MTgxLWE0NDgtOWU2MTE5N2Y0YWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEjZt+lvFcOugv/jHjQ0fROZCZshUx+sWQWUMBx0A9+kVQX2v/2WyIqpHnyb+\nz2AEdsc6MyDQ//TkrNN4eBKI8qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZsE/aeUri28fp14odyopV/G3AF8wHwYDVR0j\nBBgwFoAUup8jXif7oO76OaIcsdsmpUiLlmgwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIFhpeqeFcGvKxpYluqzBGn9WnC9vZr3WnCE4o/EX4VM8AiEA\nyXADBFYWPVdYhpPtmjq4Ua+fxqAhpiKII3TzGBJTvY8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYn/hfYuw5aHlzwIZQcbhJQbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjFhMDRjYS00MzA0LTQyMWEtOTk1Ni0yOGFjYmU0ZTYwOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATF2rTBzUoV9GyFvn0lyIEjlWIYgDt39CtwTkKyDlYXuFoa\nqYgvR0V/Gg5Wr6UzJdgRr8eajwBzPXjbhVbs4M0Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUup8jXif7oO76OaIcsdsmpUiL\nlmgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJbpjj7ZCiY/bBsD/dEmwGbgNkWoQTF7InAlRvwFshxaAiEA33TTrjzr\nWP+xSJpHaZBPp2i5k6cMuBuFyN3b8ZgrMJI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAQorfLwKn2QORUKh0VY0PjvKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmVhMDhhMzQtZTc2OC00MTgxLWE0NDgtOWU2MTE5N2Y0YWFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNDU0ODJhNS0xM2Zj\nLTQ2NjctYmFmYy1lN2YzODJkODcxOTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARsu7Yu5XppmZSWakpgz5UGT2bu7S34EzqiajgOQ2yzpaf7SWeNoW3AG2dLumPx\n5cgQRYfboosAVOHtUKptGhp0o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmwT9p5SuLbx+n\nXih3KilX8bcAXzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCB\n59lqke95cxDUtc6qv8wzjl0vx/aml2V53YlvJQxlrQIhANX+HRuSoxq+WQaig6Bp\nHeMaWFY/nw9GwotsUmbCI61f\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3147", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3147` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZnEQ5F9QyqdkICP27k/P1HiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNzI0ZDY3LWUwZmItNDQ1ZC05NGVmLTlmYmFjZDRlZWEzNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRiZGE1OGYtMmNk\nNi00MDA4LWE2MTAtNmIzOTg0ODU2ZmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgdyHnpv4G7YGOloWpkTCRof6gk3f/N25qdOTSr/tkuCyzxmHMQSZc87bgWcr\nSqdD01gsBxRQ/azclzoEZ7ehbqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4rpuatEPJ/Bg4yCeFgYmlEbpc/QwHwYDVR0j\nBBgwFoAUFZmp6E/j2iQHy/YRRC0abzlfOyIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQC/nm+wYHH13gvRJj+07AcN6Hn9SB1LVCg1hOpgY8JRVwIg\nC5/rfOY9V3I3DeRDUIoQw/IGMa95UBgENHdAFEsIXxs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR6XOs3VI+jACqimILVg/Zb5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDcyNGQ2Ny1lMGZiLTQ0NWQtOTRlZi05ZmJhY2Q0ZWVhMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoWXBRv39EjTlnvDM++T4MsRmY7KbqvShq/Fty3zzIaFtg\nRiIYX/ZzporkMM/JmKRTxQ3z6UwXvs/MCxS8dBixo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFZmp6E/j2iQHy/YRRC0abzlf\nOyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQk28kR6QWHqkDgsdTXKOL1xsFolYgA66TYc1ipuo+PgCIH+kcsZQZmmi\n/L7w9nc3ggIw95+P4kOCiQeKeyEJDFgk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAX9GPlKExfvAlUrT6IQt30ruMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRiZGE1OGYtMmNkNi00MDA4LWE2MTAtNmIzOTg0ODU2ZmZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYmE5ZDAwOC00NGMw\nLTQxYmYtYTc3Ni0yMzRhODdlZGQ4ZTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARyiJTr04229ajxe+1MLNMUhYDeX9VaS6HcZjv9NZTvYbyP/iKC1/9pYNbzsZQW\nQxP7axMAvCRoNzZJjQt5DIGYo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTium5q0Q8n8GDj\nIJ4WBiaURulz9DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCY\nKVne1vaHb20+OYLMO3BHtHptO3kfPKHCNf/A31626AIhAMgi0HG9H8zqu7maQ4Ix\nlPd0drQOGSOgihZzHDv0OrEE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3148", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3148` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYZYm67E6O/Bi8jo92Bic8tUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyZThmYWMyLWJkODUtNGI3MS1hYzYwLWI3YWE5NmFlMzFkNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMwZjkyNTMtZmZk\nNS00YWM0LTkwNDItYzk0NzlkNTllZGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERKKRI/1p76MYfxrJed+C5xHuMIMQbXXqxA01GT+FE5xgXDOt30y8LV364F8L\n/Nw7czvlTI8DYxJyGX15iPS+H6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM+OIqOGey88jA+ZYNtSXA3Z3ZzEwHwYDVR0j\nBBgwFoAUoI0ro8Te6LhuAH7+chrU/LS6qDowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDOuc5ee4W9\n+mUTEC8fy1nDsbbKeF77YjqwZ4joUz9zHQIhAJXRLyaxQm1PjKmC7mxmYzg2SO20\nycZxsKsbJt1Bni+v\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZvMUMnAd1+lM45YquvYbhkxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmU4ZmFjMi1iZDg1LTRiNzEtYWM2MC1iN2FhOTZhZTMxZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqn5QUl8WbzxbvBodAA7oBNbHo9AWXaO2hEY1capdFVRXY\n9CMKVVyhG5V8VzKZuqP942j1aarbIcQP28TvwhJNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoI0ro8Te6LhuAH7+chrU/LS6\nqDowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLx6aSvnFrQ5OWVsdSwrTUp9j63t2xarfzDnYRJPRhxICIQDhrcwEkZ4m\n0VCEQLjtzlTJATtMiMQTdXpj42rMfmwwNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAVE79eykUFIZtOkV/k0pU3TUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMwZjkyNTMtZmZkNS00YWM0LTkwNDItYzk0NzlkNTllZGFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyY2EzMGVkMC00NzUw\nLTRjMzEtODIwZi1iZDk0MmI2YmI1MmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASH7tEZ5MDETKhIqadOfd2QyScTqSimnj+yINI+7mdwUvrwLD4hOc05XGOvDhe7\ntmW784fDhxUiQo0C+NYzzJPzo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQz44io4Z7LzyMD\n5lg21JcDdndnMTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIEWv\nkeMzMhpMN0nWHIKupPFhvcfWEJP04hL0+NWQqnJdAiEAodUnspukIX4FE23ZvHEO\nE4wHIFP7Go+W+APfI/9goT0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3149", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3149` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISATmj9VuoyrNVIGzyQI0YhfCQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjNDVhZTljLWNkNmEtNDE0Yi1iYmNhLWUzZmZjY2FiOTdjYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA0OWJlYzktMzE0\nNS00YTRkLWFmNzgtZWIyNTQ1ODM1NDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERJ1sJVNCWLwmtjvx3YSANA75LxMpgJvyJEo3sDeu3YWnppWeWf4Emyo+TcSo\neAI0GunXIEljZidmHi++bC8YLqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCF6gVUEAXtel9g8O2WyKB4gfseAwHwYDVR0j\nBBgwFoAUeepE1ElCdgJGIr7Vgz2sFAmbhPcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANCiQdSYUXyMhdIeRoyc25rijvw51Zj7pqEyYhMmgKv8AiEA3/CgpW6p\n9sGl2nDEJFBrJ3zJWAjo78AtzafrSJyLDF0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATQ2DtjeR+Fh59v72c6rZqvNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzQ1YWU5Yy1jZDZhLTQxNGItYmJjYS1lM2ZmY2NhYjk3Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpFRr7mZhGXg9CRvtBwNE6wE0xZvD1Gnf/npuONvADOJHy\n7/MXdYMaSuX9RST+M7jTK+zuNlHSlnfQmnj5bdWfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeepE1ElCdgJGIr7Vgz2sFAmb\nhPcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ6AlM+pKF0QwG7wZNuDe7LFrA5nFBUJ7pAfnTUKe/+0CIQDu3adXGH/F\nOuInPvAtfqh7m5yukjNZ+d+x5Bk2Kkprfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAQuIAvOjEE9axPiBHq6SKyuIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA0OWJlYzktMzE0NS00YTRkLWFmNzgtZWIyNTQ1ODM1NDRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZDcyNzViYy0yNTE5\nLTQ0ZmYtOTU4Yi0zNmM1OWVjZDk3YTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQx5aou6cLNMuoC8KgK2oegwBm8hvCq2uI4sROgOJ86g2eXZx0ZckqcMESiC/qn\n0VsowWS7A7wLv1ziTfFtt6RVo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQIXqBVQQBe16X2\nDw7ZbIoHiB+x4DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIF7Z\nIGjaUTvqnQj0nTrBqDkW34qXk33hitDqqULpWch1AiAN6VacmciUJLurvwR8SO0k\ndTy1PxvXM0tIOxJccn6Pjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3150", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3150` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZp+huS5l7D33phiLtR7BX63MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYzRiNGU4LTA4OTktNGY2ZC1hNzc0LWRlOWM2MzI3OTVjYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJjOWQ0NTYtYWFh\nYy00OWZiLWFjNmUtNTIzZjU0OTllZGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9pYMsH3OtU2K+xctreZd2hA6rSQnvWR6/ATHn7Ak24roMA1RQT9v7MM/TudN\n23K1T/5Ib7lUaBZr/8ML462N66OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsvrJh9lseLmiar/7vMX6RgU7cmMwHwYDVR0j\nBBgwFoAU0870Od90XCuY4LsJP9YKnqIrWpAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgQFeAOtFPn8wZhG6p143HINR2Een9k/jZmicvahVo9iECIQCrwHSgESyO\nnLVnSTCtWWr3ORRBQP/9XKb350OEACB9lw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaSocH/CYdMr3p/79vT41ArnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWM0YjRlOC0wODk5LTRmNmQtYTc3NC1kZTljNjMyNzk1Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8rmGkQ0U/KajdDZjiF031doM5PZpPQ5SaOPa0oO6KefAg\nS+W8If6xNiuvXVdBD5i9cg+hGPnGCTFzWwNxT6x/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0870Od90XCuY4LsJP9YKnqIr\nWpAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPFtUScyfbgj0kp0c/fqGWKRvH6eGH7tsvTWH8mZIRKECIQDhOk1U6tNW\ngGBv+HANY4jDQMbyLe6DiojUtbJ1rYI+pg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAQt7Hid5ol+5wJ8/itbkRW4kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJjOWQ0NTYtYWFhYy00OWZiLWFjNmUtNTIzZjU0OTllZGJiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZjk5NTMzMy03MjI3\nLTRlYjgtODQ3Yi1jZjU0YmIzZDViMjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQSMEf4Gs2M+938KkjNHsz5DFihLqq7m098KOpN2xbVZYrIg7sYQEYtLHHT+RoY\nsktjh8ZKa8DhExLattL0vW4zo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSy+smH2Wx4uaJq\nv/u8xfpGBTtyYzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCr\nkPAoet9w28M2ym32s1Tudpu/Os5vG4oqG/2CCWFf8wIhANbbsR09393ZoF3+oban\noP+tN//hFk6iBSxmIkQBAkBP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3151", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3151` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAcM9v8pRE57YuhVCM0nEGyDHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3Y2RjMmYwLWNmYWYtNGNkYi1hODFlLTQ3NmM1ZWNlYmY0ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFlYzUwNzctMjYw\nMi00NGFiLTkwOTQtNzM1NzEzYjA4MmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkvJT/iBiwTu9b1odSVywY1naR054FzhnU21eE9wEmQDiTQjfvLMihHOO5dI9\nHOwt3NTUti/ua0lVjW7FZyKQjaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGJVuN8kShW0lJTmbpgjhHPP1h4wwHwYDVR0j\nBBgwFoAU0Xarfu7bTpHxdtMNTeo2Lpker9owOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDKLCQtL7WGwGzl/FM76bf7xNmjJkBX6k/Z/S8hpL78GQIgDtexrfUc\nYvLPGqq5CMn0Pt2R1fBmT+zwdcNGXXsLr0o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASmYsgFmyB+rwVXdqUTN1byrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2NkYzJmMC1jZmFmLTRjZGItYTgxZS00NzZjNWVjZWJmNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASACQEzdwUBHCaGcQuWEInJUjiL2e9TLVelsBwkylcZO/Lk\n1v7ZxqJ+23r7nQb1wMHMJKWRoE4r675AN464XJifo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Xarfu7bTpHxdtMNTeo2Lpke\nr9owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOnuwnqbBDYYWMJS6dp8u77eVeycOcDSJt0nn2WUQ7LjAiBB2JLuPZMa\nJCD7VaoIMHAcSdIu5dchafw1gBn5ViWrnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISARJ/i7I1Np/XfLSEjIadvk6XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFlYzUwNzctMjYwMi00NGFiLTkwOTQtNzM1NzEzYjA4MmRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNWNmMzQzNy0yMWYz\nLTQwMGYtOWYxOC1kNmMyMjRmODVhZWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASLht5D7dXJWVJAgcoyTd//Ip/JUSKJeRaPkM6KpxikLvzGoPCM491qTE0Yvv/i\n51R6gY+oSpWbLl5JZVXd55lEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQYlW43yRKFbSUl\nOZumCOEc8/WHjDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCICWK\nWgs/7ZGZjqWouACxI3IKu4wDGsPWmzIKJKqrgHBWAiEAuiVOOzEen+d3vF2EodYG\nJpBwrUxXEFmRE6dWHPvciF8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3152", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3152` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUxRXocAzzKJ0D8Vgk1Vu4gbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5OWMzZjU1LWQzYjgtNGYxMS04OTEyLTIxZGZiM2VjOWUzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk2MjYxMzAtNWU4\nOS00MDEyLThmZTEtYzhkYzJhN2VmY2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHHcNeYi3c7PrADmUgseOA1GyXLiMRYQZqR1gE0W/aC7IZriD9Sj5hUBQt8R+\nr6QEunOrOAAm7Z3qvhlDXJiheaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlHfzf47NpNXZv6HBUyFJ44n+7nAwHwYDVR0j\nBBgwFoAUtISfKMRogQdlUiK0uLkaX89wtt0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIECWgSq0Ed55ud3fqZwyPgpi+4fNdmzZrDB2qo87\n0TvjAiEA/Z0IUa76Ehkgd3lvLF/ihuYqyjGwUhAfAPGtijNIRtQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbpTqAteLg0tAd5P/ScLQ7ubMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTljM2Y1NS1kM2I4LTRmMTEtODkxMi0yMWRmYjNlYzllMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+sA6akFn98PTYDz9Pi7CTxJQS7xKImYrtt0AHEP77YKdI\nVK4wOIzuJnCZxpyP8dTx1rj4nvwyF5hgQwpL9ceUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtISfKMRogQdlUiK0uLkaX89w\ntt0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJbPJD7vaDVQ5iYSv280RwBycTFrgLPq0cOgteHiGvgxAiApPoZlvrOu\noCU+1qEgzGfqcXAI0ToC8MIEuvguWVhF4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAc8l2u//R8hiTqRdCUy7H/NkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk2MjYxMzAtNWU4OS00MDEyLThmZTEtYzhkYzJhN2VmY2EwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkN2MxZjhiYi00OWNk\nLTRhYWMtOWQwNi03OTNlNzRmYzc4Y2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARKDLINohpWYPAPuUmqGIazgcHT0a8qk9InbVI4ed6d/CQgILihLOVi2g/ESjcL\nRQq3qt/O9RY5u+J8M5ds9Wj+o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSUd/N/js2k1dm/\nocFTIUnjif7ucDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIChh\n6tDzXp3GL85RAT2JrshqRoO/KKyIf9hcFSBHvLP/AiBh6p2fy2a0wTi1jD3D7lkg\n0Ny/UfDA/rwutDlbLvEtFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3153", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3153` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZrAi1lIoYYtyqOtWKIB/OeWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ZGIxZGIzLTZlMzMtNGQ3MC04MGEwLTFkNDUxZjdjMjhkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU3MjRjM2UtY2Yx\nMi00YjRlLTllMTYtZTM2MTI1YTBlNDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE78EA4eYguo+liTgTSrcQjsCZhAqQIamXP1VCN0Ld/XwdajDhumUfRfTp+Gcv\nlLEqQAWdFUSjcWVkRYsO+A/5EaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZqr2QgwSfTAx3JiEMgPiBnEZIqgwHwYDVR0j\nBBgwFoAUJg804PqDV1n5skZ9OrLUD6qRhQYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD8LZljwedwMsc6UEGy5EwJ+g17TWg0ZfRgxGco\n8GD5igIgFHY23ADqB+fD/W0QYO280usJihmaQhlo3G5as5dpSx0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAekPyOW8+tlkUbml4F6DU3JSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2RiMWRiMy02ZTMzLTRkNzAtODBhMC0xZDQ1MWY3YzI4ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrDf4ShRszBaE4jBbyr1ap4er43odzhhnZpQtLUNuaUp9Z\nfFaoG5GvCle3k71eeXvEhPmMB+VU11jvJmPqwTCpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJg804PqDV1n5skZ9OrLUD6qR\nhQYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOdQ5zlpnNVocqKGVYLZQp4GnnbmDfK54APPXRJgrFVZAiBRcB9C14H6\n2eMwNBdZEW5eHQp8/6+1D5q8x/Yx1liIJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAS8L6SxsEor8C3qAVTeDKWc7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU3MjRjM2UtY2YxMi00YjRlLTllMTYtZTM2MTI1YTBlNDBmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NWMwMGYzNi02ZjE0\nLTQ4YzktYTY1Ni1hZjljMmEyYjBlYWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQzJ5VuUwWpAt+pYCIXsKN2zKDpAt55vU1UBz8JqoLm88Bqu+kgtFuyVmc6fqS1\nhvfdecI+AVbV3HT0WkEOuu9bo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmqvZCDBJ9MDHc\nmIQyA+IGcRkiqDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCx\nABhMuLyLVlssW/Qg+xLG/4GxyOlRDvQt3yeG59c0RQIgfhGKmYfqR7OfupkwPEyy\n0EbFT6DwLhGmzGcS3bVnRGc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3154", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3154` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAd5BUWVh0hsvm/HA3K9iSSBDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxOWZmOWU5LTk3Y2UtNGQwNS04YmU2LTQzM2NmYmMxMmUzZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE5MmIwOGItMjQ0\nYi00ZjUzLWFiODMtY2E2N2EwY2ZkMDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBaRNauZDzGL23XldglnbDkVZbqEEHMF15g7zi/xyowT5afHVWb87ug0bonhs\nnnEsnfcbZVy9nFa3BUCEh1oxGqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrCw8nwEsovT+oCZmKYtlR4+F4mIwHwYDVR0j\nBBgwFoAUrMsNn+BuzM34LRZM9KPtByHCFPAwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIBCGQw7LRSV4u0O4uUNO41alCJTLWU/aW1LMjdnAPmEiAiA/\n6AqFTHiGl7QIVnOs8yv89RdRUys5FBW2SLqkLbyUZw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYN9YY21bx8LBN2nwUMsWQwgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTlmZjllOS05N2NlLTRkMDUtOGJlNi00MzNjZmJjMTJlM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgzk3Bl743nz5fU9T8lM1nRMgs8rDu8eVcp81FBUITRPrN\nFlLlqe/W/RxfATbkPxTmivvtRe6UpV/iqZBIIHY7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrMsNn+BuzM34LRZM9KPtByHC\nFPAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSZUVBJF4fyH+t3BSGBaLWjfQekCcuUQ2KfMLrNrCq6sCIQCKXG5gI4UT\nXqRfN8TcrpHtnWcRWj06XEtyEY8YZq3sjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAfEu3m2zZARe6ERLlNeScg6yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE5MmIwOGItMjQ0Yi00ZjUzLWFiODMtY2E2N2EwY2ZkMDNmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3N2RhM2Y1ZC00NDcw\nLTQ1NmMtOThiYS1hY2M4NDZjOWJlY2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT/eQhUYFi8o/uJeJ6Kc7/1kWBi/e3rA0690lwzMR3AZS2ep5pfki7AS/DK2iHK\n0cKecIgZqJ1jDaITXU9Vl98Io2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSsLDyfASyi9P6g\nJmYpi2VHj4XiYjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICpB\nNOJa6kqVKtxm0FDSi11SZwyedu3n9EMdelS+q7JLAiBhd7krxmn2lcTp66FPYaTW\n5b5YtK8al9lVDeushbVtfg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3155", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3155` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVghgzWLddjhCjUEX/D9cNUdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMmFlMjI3LWFjNDctNDE4Yi1iZDg4LTc4MWQyMzBjZmE2NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODIyOTUyNjctNDk4\nOS00YTZkLTk5MjctZmZmZDgxMGRhNjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERRUIuWB8Qv4uiyH/PTz6NgUFyQlPw9eCJPCJXZq4mmNr9mh6irPfy9iNjLnM\nte4tG4ZanoRrdHA6+5Bj+gdKVqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEfLz9FEEmYBaZEQz+GbgQ6DxLvMwHwYDVR0j\nBBgwFoAU4lNgyf0sY7ik7zHM90bjOcRVEwUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAPxoMbCVjecsDOGhRUdTeGLAJWsoxR3\nvftcXXY2t1qKAiEA6lmkqOEyB4C2sKuC+CqEb/V/rrGkfcDtpp1aYx/0/sE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYFzE1YXIcYNbsToXNrcUSYTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjJhZTIyNy1hYzQ3LTQxOGItYmQ4OC03ODFkMjMwY2ZhNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZ04AoM3l4D2ga3GmLT/24TjkIaGjtECtQKpzbhSXFbqcF\ni2PqOnqt1YG0zGt5NtWmoM9RLJkaVcKSU26Hz6oPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4lNgyf0sY7ik7zHM90bjOcRV\nEwUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZAZ5N9zezsCQs7GHE1X9q5zNNU+0mVm6lCzEpUphcfICIQC/fbz1V7M/\n73y0xXIt+R1TuAbWqQRXpRpcwlaNhaf+rQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAeQt3E0ZBXSIFDOedbN0pIcYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODIyOTUyNjctNDk4OS00YTZkLTk5MjctZmZmZDgxMGRhNjExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxOTEyZTc5Yi1jNWVk\nLTRjMTEtODQ3Zi02Y2JmMTNmOGJmNzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQLrd2jMm41N/FfYV37hZlqApNuRngbQ+LMUCirfT4qfplV+3yPIHLSH6ulDyot\n8I/LdBau4OmgER/xMt2D6KxAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQR8vP0UQSZgFpk\nRDP4ZuBDoPEu8zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGh2\nBolKMSqRmgbbLevLI71/K2gyAltVngDQn7nUXzJBAiEAoetZJmdU8D8shHyzo248\nSu4Cn3mIOdOl7T/t4ebn04c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3156", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3156` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAcJ/Kn0+5So+mx1wlqd5dC1hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhM2RiYzk1LTY4OTgtNDhiZS1hNjlhLWUwNTQ5YTViZWVlMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQwOTNmMjEtMGJh\nNS00YzBjLTllMzYtMTJhZDkwYmVjMzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3tFoxD9mU6cxh0isq2HbLgBoR/NkZTfiMxXz+FdGpr7B/+lQ9ruCNQuuaoEJ\nOza3QqOsJoCeJgZMFuM7b7H9G6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgUKyY3GuxN67XS9h85uePvMd6kwwHwYDVR0j\nBBgwFoAUxT7625gLg8yiIi33ut/SCxo+HsEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDm1JMEAc+7pEq8osxtjgvYRZBqiOUE9\nx69q6xHj9eiNAiEArrrhHJOslO4TTJshv4SFRmdalRB1K+utQ84DX8OItlc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ3aae0pf/nm55ZtRkwAEUKgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTNkYmM5NS02ODk4LTQ4YmUtYTY5YS1lMDU0OWE1YmVlZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoEbYk2+1lwG2v28jtRj0R3BI4RDn0GyVoGh7jRu9OjZdU\nL21rZKy3G3TEZLpaI8Pwj/KoXkNmT49driss07zlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxT7625gLg8yiIi33ut/SCxo+\nHsEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPgGOwGfG8ESy4dpQ3J5jdZSUuiG/ASQw7GrP2JLmmAaAiBhn4NdrNW7\nxphsO/dlJc79xydAdMakGpkDO52iNwkYug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbujAs45DsvNtDsrn/j+TUz8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQwOTNmMjEtMGJhNS00YzBjLTllMzYtMTJhZDkwYmVjMzE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNGNjM2YxYy0wNmQ3\nLTRlMGItYjc4NS01MjQ1MDExMjlmZGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATsi/Dt4idYBw4HsnHidt+3JDiC0yOLStZZjzEO6hcoHZiEx+lsoHS842VWL6nG\nr9sCGOdoj7EmJTNsCyxQnzgQo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSBQrJjca7E3rtd\nL2Hzm54+8x3qTDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQC9\n/f32w4D99VhsDgDXzE7/4xag10SvzrzHeMezqoymygIgCdZj1Ksqyq9DG+tZpCSU\ndsdZNBatePMmMjBzsl/QNec=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3157", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3157` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbI8Kb+NkvOw9XF8aP1z/uVQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYjQxYTY0LWIzOTktNGRmMy1iNTBhLWZhZmUxNjJiYzhhODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc4MjBmZDEtN2Fm\nOC00MmM0LTk2NjItZWVkYTkxMDJjYmMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtkyMOdXFN5nflDDtQvPnWs+nVdbtggIvnuWXkw4+vORsxHSApgyj/OXLw82H\nUSOjMZajVYS6417CZcF89jG5saOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw8d9Wgo9uJxXF0yFNkTr0bmTw6wwHwYDVR0j\nBBgwFoAUrIDKyzHAtNDzMwgkwxmMJawSdb4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIF6gxClSFYwx\n8aHeoKeLG1NbbGU7DirpzJkTuQEYxgLuAiEAi1gc7pbC0kPRWqGPTTJ7Z3BVyBpV\nJRDydB5mOjN+aMM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVwos12WZaH+mVYOiCcRgvc1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWI0MWE2NC1iMzk5LTRkZjMtYjUwYS1mYWZlMTYyYmM4YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgPiYl1I7kDCSYihESNVVrQ9GXVhZB8HC6EaMPDFzshU2S\nHfVtyPHsh48sv5nLgn33FRLfTbhLsAefL8BPHvOWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrIDKyzHAtNDzMwgkwxmMJawS\ndb4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMjkdlDX/LR9Pq2KdzbdRj7TyqITuLu4epLCu5WREsTNAiEAgEZQG5Td\nHlRjNOLvP4Ph/mw2x/kN2QHpy59zDWuP7mw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAXjEtY0YCRk/alM+YGurKuVmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc4MjBmZDEtN2FmOC00MmM0LTk2NjItZWVkYTkxMDJjYmMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YTY4YzhkMS0wMjZi\nLTRkMGEtODkzMC1lMTFmZDM5YzAwNzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARHe9Je0DX9YmQiX3k5EUSEqWAHD2XfuvoG+5izsrnPIDtEO2QkNkAX1oFC2waW\nBpKxhNdlVo+xk1I4US7eoZ0bo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDx31aCj24nFcX\nTIU2ROvRuZPDrDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQD8\ngPGDeyQrJdfmvlQaSZxsrG/cu2KgRtXhgDFsGa8eWQIgMfaCQZ7mBuN1EN1jD6CO\nKBPoELQ/8Fu0yARlzRy6Zvk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3158", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3158` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISARfZ6Q+lvVllFJNHA1q/ZjrSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkNTQ5NzYyLTNiODUtNGFkNy05YmQ0LTEzODUyM2ViODU4MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRjYTdhNTMtMmIx\nMi00ZWU1LWJhYzgtMzZkNWUzMTE2ZGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElWpHHap+235bd6GVCsqlDGrCfjGrjJRxjtb2L4jIOqoAzWz/6D7FOpeLPWAt\nwb/0TNAwaKGVuFHBDl+ekD+PN6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUomqTHGhuSWTDzs0huzD3UrOdaBMwHwYDVR0j\nBBgwFoAUURxFFrmYsEL9mqSVf1UiJ/Y6VbgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALU7h2ll1pn82SIgPgnov3U6d6We5qiaUe0S8rpfFtUeAiEAl3jM1jM6\n3H4NONvDO83lo870Hgpyfxs0m897wtH1mcI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVol3cSuD6F1wVx94Cl7FIx9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDU0OTc2Mi0zYjg1LTRhZDctOWJkNC0xMzg1MjNlYjg1ODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQb6Ta4lEtSr/iHR5wQr+fJamlpaMJyA9R/2epbE7+7Ztgd\naUNQz9rbooHHxvRt9Bko8GDSVqSijWr15v+B+2/Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUURxFFrmYsEL9mqSVf1UiJ/Y6\nVbgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEhPcJ1OdI8I/9JyIer+9CLzOsHPIe4eTla/rudZGCEsCIHZ64xGbGVO9\nFA1h4X82DehOEb8c7yaRYzkdxuqoDShM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAS0wOg70fLpqTX2AeKRzxaHQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRjYTdhNTMtMmIxMi00ZWU1LWJhYzgtMzZkNWUzMTE2ZGFiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZTQ4ODBhYi1iYTkz\nLTQ0MWUtYWNiNS0zOGVlZTY2OGFiYzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARskB5hBN1DP6AUTDs2DtFntdpkVYnLY9p9A6m650KbfgW/7hDlvgQHt7ajaMVg\nc4CfMkSFaQWKMa1v4qWr97vbo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiapMcaG5JZMPO\nzSG7MPdSs51oEzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIE44\nvRh05aYIYM3B77fpmciVdH19yn2UibqUC6qN+0yUAiAlcRkuq3mypJEwg5hgNEaR\nmUQyS84oJoIDyIl8Q7M7YQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3159", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3159` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAelwCRP8WFPOVi/rNAZmRyP2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiOGNiOTc4LTMyNzctNDMxYS1hOTc4LWU4ZjU5NTU0Y2FmYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhiMDkzZmQtMjA5\nNy00MTIyLWE2M2EtMzY5ZTViZDM4M2NjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx1Kq1WcZfhReGfn2pjhIBnhKjOtt3Vc2VX1zgUeV0ACwTKk9sHHkbKVgN6Te\nRSyvlSsPOqV1jKr7oGzU+cOQL6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsbsq+bjmxX2lXpnrcP5NR/8vvD0wHwYDVR0j\nBBgwFoAUVBlbuMtYFY15R05fVxpRnFo6uuIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgY/WPhUrCUKhJKXSHcSMofEeL/mLJvGdC/HJ5LxmgIS8CIBRaWxdp5VN0\n7qk2b/rVI68oSDPKKNmAr+2E442ALRTH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAebSKX57mbykU5NHDOYPFMV3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjhjYjk3OC0zMjc3LTQzMWEtYTk3OC1lOGY1OTU1NGNhZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7VyKmN0tl93IDIK/nF/6k8FZAhyC5fCFbkVaCD8BeBpZz\nF8ssdRyjfqY1oYaoBN1mQCtNdwR8vMI78g1W/3Ako2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVBlbuMtYFY15R05fVxpRnFo6\nuuIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF82/U/LmDra6hFG0imbw62BmIWcWlyBUAdRhOy0zxdsCIQCyV1TwnVEE\nhk4wWCX+vPiYd6irb24yyo8lKqrqsL9oAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAfakJp8K5AEXZigRNaqJdCS0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhiMDkzZmQtMjA5Ny00MTIyLWE2M2EtMzY5ZTViZDM4M2NjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYTY0ZDMzZi03ZWRk\nLTQ1YzktODJiOS04YTI3ZWQ5ZjgwMDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS1y/Vlqt3avJTJ6IQg3non1hWiJqIsSNBydwPL68NPL8OLnXFFUtYDtqdtf7It\nIXULf+YCe0+unW8IuPAI9Lgyo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSxuyr5uObFfaVe\nmetw/k1H/y+8PTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCf\nfoAmWk8b9/lqUUTJVSFh7Mg4RvB4FmM1RMPjP41RBgIgGalu5bnd9z4uu/cFx2bK\nwc4XefaEpibbFV0Uv3IH4Y0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3160", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3160` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAShcujSUBK0ijkbWu1nZ3a68MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExOTE1YmQ3LWM4NTEtNGQwOC05ZGEwLThjYmIwNGY3NGE3YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjgxN2NjNmYtZjFi\nMy00NWM5LTk5ZDctY2I2ZTYzNzEyYzcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXvmhxtp7OWZ1s5HXFsampHhPIqyAPL+9K41z3DgsTx+6UgsYux7OOdnr9DIt\nNfjHkkxXDNY+FRug0Q8aWv8Iv6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPHafVXrKqMPLcc3N9/Pt1JDf3g0wHwYDVR0j\nBBgwFoAUXumJKbeIhOe2DiIW5iY+zbgVrZEwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCrR7xmk3Fpg0qzPDGygAAn4oMpCUmO56AzoPH8z9S/FwIgTcIksAgF\nNrcW58ck76v9ISiOxZ1pmpECm5dVtrTz1Xs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYfwlGnswdAjWPmi706GQ3mMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTkxNWJkNy1jODUxLTRkMDgtOWRhMC04Y2JiMDRmNzRhN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJDWDIOFkPNL+6PGxSbykjS0WmbQLXwQVV2ca2L5YNnSPk\nQW2yd8syugrxQK+66sINi8aK/DJPD94IPVaXPNOYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXumJKbeIhOe2DiIW5iY+zbgV\nrZEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVh85G4xUVfxdAWc3LfCiKGNoFOsgewZ1LJx4WvOR5EwCICPE3Dd14E4B\nvrVEP5hcW4JIoRbWWz7K/8Kw5JsgfgrD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAed8resGZPHOXu5YqK5IAqZuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjgxN2NjNmYtZjFiMy00NWM5LTk5ZDctY2I2ZTYzNzEyYzcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNjMyZjBiNy0yZmY2\nLTQ1NzQtOGEwZi0yNWE2ZTM3MDAzMzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATHHPNzjZBUF9mQiLvLMX3p44LTm8tZhOajmke3IE1f9LJ8Hlq8ZbspOaFOrz2Z\nMAKFYUr3WeMjAcD0/EbOlA5io2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ8dp9Vesqow8tx\nzc338+3UkN/eDTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIDhO\ntcLqZbFa7QHM+JhT2YKIdT88uFoFu8B4QXib8SsDAiB51yVTqKvrVJqs29dfgg+B\n+PiLTzY223Hebs2OzoNKnw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3161", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3161` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAfO0lfzjA22SOPzJwFEE3USpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2OTFjZGFhLWMzYWUtNGZmMi1hZjA5LTA5NjFiNGI2ZDRmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkzN2ZkZTctMDIy\nMC00NDk2LWI1NWQtY2NkMDdhNjg1YmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErrbw9I8Zy1oCcAU2KGykeskNk+OMt6+AQiPXLAn2i8O8oKljL6IGbndcQLxO\nhoTfa/YDAViueGoKO4FGTVEBQ6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqgPtqDaKPT2rEczA2oSRGpyeZOAwHwYDVR0j\nBBgwFoAUPP5BKN6t8KxNeEZA25brMN0MHzwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCzNa+8Woeif0on5UuQMSzFY3meXEWuJbpzfBt1\nmiMOPAIhALaiwqyQUhuOhRjCmpM+2fdc0bIEHSfRSW6EGxiSQbrE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfvYwAA0iIwnLoAkS9m7dg6gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjkxY2RhYS1jM2FlLTRmZjItYWYwOS0wOTYxYjRiNmQ0ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDP6GX+EVjBTj/iUBqrGXqtZY6DmQCTnlOBcvnrQIh+XoV\n9MFyofN5gr4AijML3xdQ8HnwJkOB3UyCJAj/A8tho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPP5BKN6t8KxNeEZA25brMN0M\nHzwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXvXMT4RZTxiwNHritMrnjDaCzSJgFDHZR2BHoBQk4T0CIQC1Oq4/CeT+\nRxUmievMeYSIsTEgFL1C/oO/hlVkj52bjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAW78Q/b+p/YZDmfBgFC9RO3PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkzN2ZkZTctMDIyMC00NDk2LWI1NWQtY2NkMDdhNjg1YmFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNzY3NjIyOC01NTFj\nLTRhMzctYjNmNy01OGRlMzFhN2QxNDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARZF0+gCRpZnBoiXHZrg0Vqx6bSkjK4dpWRzmLrZ+SUvoR49gNj1brdAdHVs5Jq\nYONxu8EmlCu5Rk0rMloixUQDo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSqA+2oNoo9PasR\nzMDahJEanJ5k4DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCm\nEe6UqRoS10vu0/OVATvnNFnQuqQXAvnWLYklx9YRrAIgXwlL0DVROju7K/DZY+19\nvjUDyrhHfubaso+KXKaihoU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3162", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3162` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQ0DbyR4/oGv5T+kTKDZ+U0iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MDExMDkzLWExN2UtNDgyYi1hYzYxLTNhNTA1NWU1NzMwZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDIzOTZmOTItZWQy\nZS00ODFjLWEwZWEtMzcyODBiMmNmYzA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl9DWO7ygu1PS14g8Jh/imfeQx5LYu98VdjaEx8kbRommqrkW2Gr4ZzRRUdOA\numFxBHdPemaq+W6+1qOuVE0hIKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVhn1GMSQ1CJ1JHYvAnl0DhALW2EwHwYDVR0j\nBBgwFoAULDnmd55S02x+v6cj3jqJMiRvA6swRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC0zMkoyuvwbY9GQUIKNVtSzO9+WpC7DVNL3Zbf\nAQNjhwIgY+d2DPnkcLV3chDNMzGic9wtyCufzGPEZ1Cv16QNql4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUCQjnFbUKCMvoNbsakP7cx5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODAxMTA5My1hMTdlLTQ4MmItYWM2MS0zYTUwNTVlNTczMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6dpQbIfq4TCrlRqDb6k8d7zpp9JuoaL1fcITKnYI4M4St\nBirh5FR7eKFFG8FlZD2GG6/G8Lai1aWf2ZCsQzVro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULDnmd55S02x+v6cj3jqJMiRv\nA6swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIgMBMXYEdrhRnsfkkT2do9gYzvO7TLxAE3XvWGpudk6AiB5olkHcVXU\nmXWN8vOOiu4iTMQR1HEWlCFhpD0x/mo38w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAWQUTBeYs09ObSj0+wyCsdtEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDIzOTZmOTItZWQyZS00ODFjLWEwZWEtMzcyODBiMmNmYzA1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMmFhMzQ0Yy01OWFk\nLTRlN2UtYTlhYy01YTBmMGE4OTM2NWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAToo48ynAOmr6tSS53QrEYkfupkRI5ptxxYY85jFZdJgO3awzXw2lPE5qQF6gTp\nJ2oJMnx+E5mE97lUTcvSZLDVo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWGfUYxJDUInUk\ndi8CeXQOEAtbYTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDZ\n+qrHbPFRBvfjrZoZJNevWLH+1e6hQ9RciQPyryuhPwIhAOagynZvvMZpsCYxy1hW\n4ML7h9IVR23RPEXaSUnkegw8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3163", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3163` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAYCl0LkYqefl5Z9L3PX70O0sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0MTg5ZjdkLTdmZTQtNGVjNS05NThjLWIzNjIzZDMwYTNmYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ5NzY4ZDctYjVl\nMS00Y2M0LWE4MzktYTc2NTU5NGRjYWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEExBjHV9rXdvocOo9ssNfBXXRA+Ns0CvV7vQbLzubFuuM7r0lBxffX4dPZsVi\nKA5xIS5nww6MGsQ7JLjwDNFaIKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDSMx3h6cadOOfkwvB6zB6UF0EbAwHwYDVR0j\nBBgwFoAUBPIodt07JB0nkQogcYQ5A9GxOjEwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQChIdMgCw0Vf5G9RXFRxe1GXOwHrBpGt4ftWIY4Br1k8gIh\nAI5Dx/fxidDISP+rKXIv+AxLkiXx+siUTv4oygTxP24h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcoIDa8IDa5FofMvSts0JBfmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNDE4OWY3ZC03ZmU0LTRlYzUtOTU4Yy1iMzYyM2QzMGEzZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7zb1w76zA7sVKxv2lIsZZOUBSzmfQHKLmx3mF0iteT49k\n8FwM3oRyah2KFPBaxqxW3XSZIwEX4CKbfqIsX+zSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBPIodt07JB0nkQogcYQ5A9Gx\nOjEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKUL9EZpCn1ql5daIzTgYiMhN4ipg3k/Rqujz25718mECIQCNXe/et5g1\nsAa1mlnKAcJ4xPfINNXYjIAiuN1uML0I0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAUELvfWM4CSFb+dMVW+rLXKVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ5NzY4ZDctYjVlMS00Y2M0LWE4MzktYTc2NTU5NGRjYWJkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MWM3NjQzYS0wYTI5\nLTRiN2QtYThkYS04M2E1OTg2ODA2MGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARiCAvuNDbGcd2XZhz79aDT8jI5iNQYddOuh2HmEOOMIqQuauW/z9mHM6SooiCj\nMzA8TswryWUdOlcJOrT8gFe3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQNIzHeHpxp045+\nTC8HrMHpQXQRsDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCs\nb2D+i6knioxn915TgW1G/qP3n+k5jRIxn/Io02aZlwIhAKfFv4M8hxxTHQBLFGTP\nz1P7jUnpHv8F2ai3xOTJWQOW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3164", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3164` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUsr3WgtimiMVfgQKN3gntszMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNzg0ZTk5LTA1ZTItNDUwYi05MDkyLTlkYWYxNmQ4OTIwZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBkNmJmNGUtYTU4\nOC00NjY2LWI4Y2ItYzJjZGZhOTJhNDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6UUsf8h6qPvUHLu7GhvcM973tnqLNY/ODi0tR0S3O/mcIyY7Ya+h9MEd4urN\nug1gF0qMUX0yIdqCf3P2CFaZ0KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvA92gUWlgA4veS7NshM6ZQq2FfwwHwYDVR0j\nBBgwFoAUCZTqMRmm2NFAFa99osmkqiRwV/YwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIFzVjlJLHmb1HsPeRlrGEd7EkbDttGtK\nyXQhqLHQdb/sAiEAgUhLMNUwINyUPrzcu62S9mTsYE/H6+TWz9rRCLdaHa0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa4AxpP+I2xlWgzvwh7qjd5tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjc4NGU5OS0wNWUyLTQ1MGItOTA5Mi05ZGFmMTZkODkyMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQg4vHf7/L8xcf+1QXbtYwu8KQAMwEDxkMBWTNrXyF/nn4/\n6ZlwFES2ta8Zlir3qPPe6dzTKn5T2zlGmLA4HYAZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCZTqMRmm2NFAFa99osmkqiRw\nV/YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIArIvehOzlKQzTVSIM+nBwmCj+vLrgFzxMcWuAeq0MaAiEAs+h5xvrG\nqI8rwjSnoE/x3MwSEJHT9EfPvnO3TAbFJQY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISATFFciXXK9c23TRyMMYkeaejMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBkNmJmNGUtYTU4OC00NjY2LWI4Y2ItYzJjZGZhOTJhNDdiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMWU1NmEzMS1hY2Zj\nLTQ5YjctYWRmYy1kY2E4YjkyMmViMWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS6XUbBbJN2/dSotcP74Afj4xAu8xIGdlIhUd8LaPR/QH/EOwVgY6Hlhsbg9eGG\nXkeRo986x25/v7Az9pTgxKH3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8D3aBRaWADi95\nLs2yEzplCrYV/DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGcd\n9NkLIGfORWU+1zmqiqxkj4+uWV5pP334xR8JtOV/AiBIuHTlZyRdMaa1PHHdkZUV\npsVSU1Bw0KWfKIFZLJFRKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3165", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3165` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAYk034wS5ywzEPhVr5QerWAtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNWVjMmVjLWY5OTgtNGNiOS1iYzkxLTY3ZjY0MGFhMDA0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ViODJiZDYtYjg0\nYi00YTZkLTg0OWUtZmUwYTg0MTNlNGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfK2kuX8D7cKs7dz1cpGWcsGxZYsYI1vu4CKw1YQPv9W0Wn9IdoLqHXAfBAr8\n4NfzO4zr8KcdMupQizGmgPvmmKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSjS+hHZN8ZOysIRpE98AoHTiHx4wHwYDVR0j\nBBgwFoAUZLkrit3dUKC+Run4GPJdweL6IDMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCx/sfGx62W21maoEMXthGdMhPY1Bje\n8HJ/3h4N4AhXZAIhAIubR3fmnQo0JTjCcwYCUreL8cTMCrVH9LEfagqg+hdE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYaYN2GPi1OKflXI+8N01ReVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTVlYzJlYy1mOTk4LTRjYjktYmM5MS02N2Y2NDBhYTAwNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyfnsiGbNNmUXHu+JZsri+4Of//dL6FbKxG6Vr5QqMAmFe\ntV371DjxJj/PuiixiwqcnqPwxA6iE5/IIuLk65pso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZLkrit3dUKC+Run4GPJdweL6\nIDMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPyTcKIAOsOMC+96HVhd6IFd33UcmhIfED/U82fczjw5AiAZBezVnOWQ\nKEMQD6EZjMZTjWopurskF1XNI7ucxU75Og==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAfeTVsUZAM4+vJNo/PxSSyKcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ViODJiZDYtYjg0Yi00YTZkLTg0OWUtZmUwYTg0MTNlNGFkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NThjY2YwMy05MGY4\nLTQxYTktYWM5ZC02ODE3MDM3MTllOTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR9EwSsvza/BLNzSPizquVR/E2f1+AbZR/o0UmtMIrIi5byrhp6Wq/N047EG2+e\ngVcJ+BANifCR7XGCXyTYqIDdo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKNL6Edk3xk7Kw\nhGkT3wCgdOIfHjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAvj\nQ/D+uN13gz2GjqCIQy3vure/bM+46EAXsA+a/ScOAiAAttXaSm5f8TXJGrcU0j9f\n1pRDFfXKBE8msS3cGynmXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3166", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3166` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAeJ+bDM/6y33+4ngAMoXepFuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4MDg2YzYyLWYyZDItNDJlMy04M2NmLWNhMDI0MmRlYTNmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY0MDEyNTUtMWE3\nMy00Yzc2LWJmN2UtNWU5OGE4MTdiYjc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESxVxTD2GzLlM02pk6EL7qGpSSO/buJFIq4X6AUQhODDMCev8TuGZLgjlvWHs\nORR8sQgGosDl45QcrKCW1PPT/qNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIXZl2gGnImTJB3fvNXv7va+7KeFMB8GA1UdIwQY\nMBaAFP3dfVBzBm4z130Rc6U/pmjMa06XMAoGCCqGSM49BAMCA0gAMEUCIAF5sDsi\nfzee2Y0gjvxseOWKS8V6nvkJNgRucEYgS9qDAiEA+PDds3JXK8F4t9kJCGwl3Bj7\njTGM1rmjIuS1DmaLbas=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcYA81wN0FWhv5gZkypPBvX/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODA4NmM2Mi1mMmQyLTQyZTMtODNjZi1jYTAyNDJkZWEzZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2ZMI3t96U0NhgdWys68qe4RbH2eUYMzy3Z+GTgeGBdzc8\n6xBDxHhpcMUCVrBpTXNoo9qOEwDubE/3X5j5YjBQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/d19UHMGbjPXfRFzpT+maMxr\nTpcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPl7DpHdZtlaJN0DadDXs86EgdNyiYR4gnoOgD1/10lUCIG3XgyBwo+1v\nvMfpl6gF57D2ZzkPPDJU/7SvUawzhNrS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAVuduoFupB7es90eV1xCCgwWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY0MDEyNTUtMWE3My00Yzc2LWJmN2UtNWU5OGE4MTdiYjc1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MGRjZWI3OS0wNDEz\nLTQ2MDctOGU1OS03YTUzYzk2NzQ5MGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASwuoN64ZS5wol1rPN103VJD8aCp46l57JjPs5+nwRULzWo4pldd40dYtwlt4yh\neXaz7WkxbpiJpUcEbDwL8TR/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSF2ZdoBpyJkyQd\n37zV7+72vuynhTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA+3Y3xnimsU7/l5fXBmSHyADihn120ffeCLTgB8BY64ICIGBXC03w\ndsN5YPkz+mXe1t1uS8U76DFlqR3DAv9FP2ZN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3167", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3167` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZtvex3s5hJDhMZf5I3MZ0MuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhYmZjNzUxLWI5NmYtNGY3ZS1iMjVlLWNjNDFiYjdiM2I3MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE5MmVkYWYtMjBh\nYi00MjNhLWFkZTItZGQ4NjliZTMwYzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYc4cciQ6DZeNdaFGydLqTXUzeM+24o/bgjDHaet+DaNh+l7PKYp64+YhLlfm\n4Ku+sFW6IZp3KNtPOoUHVK5ksaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFObjSe+XkvRjtkx9JoVZXlLrnDF5MB8GA1UdIwQY\nMBaAFO4kfIsRfpd4YZtiOQf0+A2214x/MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAB2y63TjS31zXzYd7itRNw7BVMf8WqVBjA\nsGoTNOBVaQIhAKJpBKDB3H1JBZbCGbI/4cHV7zHrXNTQodKUNqlzBQ/b\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXUWuhBZ7ak/ZnaTXBMQpeqNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWJmYzc1MS1iOTZmLTRmN2UtYjI1ZS1jYzQxYmI3YjNiNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0pg9j3GIUUtREzp0xoLLQ3vbEZjEF6G4gJFUPm8P+K33z\nPYdiQemlLPIOsNFbVL3ue33hIufs/l7HXvCFFL2fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7iR8ixF+l3hhm2I5B/T4DbbX\njH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANGZBEaJRt6GofoBptHROiLnuACI3AjpdEJpUVWgRZBjAiA0zauDbxzY\nkU3tpX7w0XlNMd+gk2xMf6rnsYlZ8QQS3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAc6SKP6pmR695STVhHITOSdjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE5MmVkYWYtMjBhYi00MjNhLWFkZTItZGQ4NjliZTMwYzM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMTkxOWJjNi1kYTM4\nLTQ3ODgtODhkZi0xYmQ3MGQzZDMxNTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASrTYEgNCWWLZ9I7W4EATyUAAQEfeX9qVaCGPkWjH2eBOtQ3blyRnrTY1QE/Z0+\ntIfxFjDxdsh8ZwSDQaB9uC8Io3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTm40nvl5L0Y7ZM\nfSaFWV5S65wxeTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiApj34xRpHBZF0yJL68iPhXf+7QXMvz+h09XOlIR1kNWAIhAICXi1fR\nyl/gYC8lLQLJoqXsli5qrd71pn+zIRjzHoGA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3168", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3168` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAeFFMoUyEPwEmKUUGfkAsO//MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhODI5ZGEzLTZhYzItNDg0Mi05MmZlLWM5OTQ0ZTk0YTNjOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDMxNWZhYjgtZmVh\nZC00NjMxLWE4MzEtODU0NmZjMjY2NWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM8Ggikr+p+DOinKJAEjbOP7ucenczuWWxufYqC4TYh0EnuZhfa8vFvz5q0Rg\n/bfT28HepjfDFmDlVjljbKcb+KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMfyLP1NVmU+ClLzNyMHHiCVVjeTMB8GA1UdIwQY\nMBaAFAfrGCTKPdYYXg+KqgcswXCiXnmpMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBRZ01FICfheosj4L9zNy6fMutrfyXfVHJY\nHfPJqpKJCwIhAObF/vdOFWD1Rh1aAxDuxm46RX54iEA7P3c+w1JR8h3n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASnm+Uia4oyKdjOKKqRa2lq2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTgyOWRhMy02YWMyLTQ4NDItOTJmZS1jOTk0NGU5NGEzYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATynm5DivivtCl+1ym1KG9LTqwbzdLasnbI+HyIRlvnSR4r\nkY/92e+GGnC7+F2lIWB0DBNY4EgL2Qzr6pJkGfi3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB+sYJMo91hheD4qqByzBcKJe\neakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHVuex+UE6GdgU/KtiBA7bf44VF8HjyypyKcE1cM/+5kCIQCaTmkN5ULQ\nBE1b+MrvqyhfkcjwiQH7tXO/kr91KRm9dQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAYVNIbtt8EpQpeFknOg9vdYhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDMxNWZhYjgtZmVhZC00NjMxLWE4MzEtODU0NmZjMjY2NWEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNjMzZmFhZS0yMmE0\nLTRiMzgtYjJkZC01NzVkYjdlYTlmOTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATAZAiT4xbiUlRdj1rX5Q+MAfxB2RcjHS52C3nfDc2+O7aW+16DE48y5moKNXxE\naFYA7YcGNRFdZO4kEr0re8Xso3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTH8iz9TVZlPgpS\n8zcjBx4glVY3kzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA7ssXe8hcJklf5uPj1oWeIjmZqCsxPABxmh3+pfVkipUCIDmlJ5eI\nZOP1xq0OZoSJ/eqVnd7/BPYl+2Ns8UxaXrNQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3169", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3169` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYsHFOEu2pcGDT8iCnYVPtnEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0MmNiMWUwLTVlNjctNGNjMC05ZjYyLTE0MTVjYmIxMmJmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjY0MmE3ZDgtOGRl\nZC00OWQzLThmOTYtNWM0ZmE4ODk5YzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExs7nU5/a000SZjCkYKWHNtgQ4RAKRrdLL7gXtpQjkq6Rt86SVKtDr2Nee5St\nygYqpORzNHQxbrvImcR8uRl75aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSevPlm+U8uCF0Mlu33gesDd4TvBzAfBgNVHSME\nGDAWgBQsxDC8Bcqq770q/r9sWO2kHhbNGDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFaHsRHVWGti8UC3rhmlVH7NFrV9thtA\nx5YJ8k7FSI0FAiEAyGeMQ8rYxBr4QnbuBi/GcVheYrEMk4WcehgrztAovMU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX9p8BSeOU1lDxkDGg7ZpRL2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDJjYjFlMC01ZTY3LTRjYzAtOWY2Mi0xNDE1Y2JiMTJiZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStzgADWjYZyF733PuK8uDWhixiri8Ub41uxatZiSMhAO4D\ndeLU/c4wcJcw61JdIhWZ+1TYyPbZNPfVd1iAIr8Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULMQwvAXKqu+9Kv6/bFjtpB4W\nzRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSJsQ9Sp2cCHBy7/edXIukNWnLIXjvg5GCjSBOCPElxICIQDID69JuSOR\nrKbnIbC/kHeiKqZoIVXNBS3jYPN93r7+KA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAQFtehUei9g+7c9QVqvfQe7MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjY0MmE3ZDgtOGRlZC00OWQzLThmOTYtNWM0ZmE4ODk5YzYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNTNmZGFhYi02MzU4\nLTRlYzUtODEzOC00MGU3N2FhOWI3ZDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS9cAUSm8xQ8/zMVWMHd7I9rGEne05I/F3ijOcwpJ37jJf1wL/tNMh73aBUlYYJ\nEwzgKHTOp7Ed5V9rkZ4agtGro3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSevPlm+U8uCF0M\nlu33gesDd4TvBzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAgo3Ph82nefUY4FT5RWJZoWaYTXEOQbBYvT3m6A8+8WECIBtMFIhh\nFx0xUrUSQ/dpxFLTvc9Rr5aDs4j8VbLS4/fK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3170", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3170` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAYJM36zsy9QsxP8sl1bv3TFdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyMDVhZjEzLWU0OTUtNGRlMC1hMzQ3LTRjMjlhMzhkMGViNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY3OWU4MjQtYWNm\nNi00ZmRiLTljYzMtZTk3YWE1M2FhNmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkKxE/dMMXM/mJVIUFn/rik9Cxv/w980RK/4KW4aWTAcd2X5DGG+DRbWqJjoM\naZDfCrIS8UwrD7B8h9hX22FDx6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHpJ7boJzZRJm5durWd2sNIehxOMwHwYDVR0j\nBBgwFoAUUlvVW4DhnMOAugLctfKXiqKkibcwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA8AT3mYm7O8Pi\nL/Dl/1rRqIMEONg5WcRsXnxKfrR/iOUCICB/0SuJHg2d1UZr2Oa2NF9EhnrvMSMA\nS+Urz2rPvqBS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWBDYOpeuIqz4nzWj3gS/8KhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjA1YWYxMy1lNDk1LTRkZTAtYTM0Ny00YzI5YTM4ZDBlYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARofx0lrxibzpxryLoDXQjfpNTKozoc0U0EoFWRcv7kusNm\nDaOw0AiF5q42Kctre/vFFMadAzkPtCOH+tLs8vxbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUlvVW4DhnMOAugLctfKXiqKk\nibcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP7hkpgwXfQKkL6M+6vgXA7LTrj5L0ufGwd5ckPY9JshAiB/xzHTRVTB\nnJb9XQz/22sQufAgKocLfIo5vP+RU1/Gdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISATQ71LzqAEOucpzWu4OFzr3bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY3OWU4MjQtYWNmNi00ZmRiLTljYzMtZTk3YWE1M2FhNmZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MjYxNWVhOS1lYTYy\nLTRjZDUtOTJhMC1mOTk2ZjJkOGE1MjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS1B8YBRb3pcrVCAoo7GkBlHj5w6HfoK/MfkXaWCwxpedb6tiII5esCcuVpCjyi\n7RNqxtyYfBGdWk4J9Obixz/Jo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQekntugnNlEmbl\n26tZ3aw0h6HE4zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiAQQ8jZccEfHrvS/UOYGaKRKaxXVtDTcklnVNGAbTDxpgIgMUZHT8iO\ni0hsYvbwmUXUzqD7z+42RjcVXuD5VJKbY4k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3171", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3171` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAWS5VdwfJ/MIdRfk+Lobz7mtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhN2I1MjQwLWEwNzUtNDIwOC1iZGRkLTVmYjNkZDEyYzhmNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFhYTE0YTAtZWJi\nYy00ZDI3LWFjZjUtOTYwMDhlNzY4ZjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/dnSadcnFyPDt5SaV8FVPOOpd1dCN86ipWQny9zQLS1Ep7k0hmTKhRHOmM/K\nO+qNjORagSf1wz5+LF2aFvexMaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Iy5tqVGSZsyCw2iPVKPRATq1CYwHwYDVR0j\nBBgwFoAUqd5LrNU1DQVBugdBPEyZVUQQL+MwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAkkGrZTINMCyE\nks4kmUmn6UCHs9FrMxs0xhyoyhahx6ACIQCDI2U+ImlM1ufsqIcVkhyFO3VA3mDp\nPHyiARaE8+ycFQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfPRS2rR2+MHEv0HfJH/uOomMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTdiNTI0MC1hMDc1LTQyMDgtYmRkZC01ZmIzZGQxMmM4ZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJvN078cn6WE2TWWUFdcCW3Mxhk/Bl3FyH0eBW1PmCRdPG\n9MNgUW6nD8S6s03XwpLiIQYGnbqDl43WtX6a+u8lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqd5LrNU1DQVBugdBPEyZVUQQ\nL+MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK73oxqgUD+jJy4WLhe04tgleFMWjgtSfHFmkIzrRrHfAiBZc5CWp9vZ\nNfTJpdIxikLfEzWpbYHcfjKe0zLRkXeybA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISATlSCU4i24WXv5CetEHSwlVAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFhYTE0YTAtZWJiYy00ZDI3LWFjZjUtOTYwMDhlNzY4ZjFiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZGM2YjVhMi1jMjdk\nLTRkNzItYTQwNi0wMDQxZmZjOGU0ZjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATlAHhtT3oP3CHVTqCloD5ndcrpTdpXDVDuS0F/NxhYF7Ko1rnWpEl5IsQ4Nf38\n++gRwKU9pge12oV0gC7oIPSco3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT0jLm2pUZJmzIL\nDaI9Uo9EBOrUJjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiA/4rirN+EEvVuc4NlQyo+EogOqNCckuZHn6VTRRKLL8QIhAMT0KTki\nxxialRGnhhl7prGxe9dxOb48eQ2EJljFDvqh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3172", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3172` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAY5bwcsqR8AkiQcom4rWOWsGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5NmM5YzE5LTVhYjctNGJiNC04YWM4LTlmNjZjOGY1MzY3ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk3MjM0OTctYmMy\nOS00NGEyLTg1NmEtYTA5Yjk1N2U5ZTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd/DO+r8pdc6nXCbdqCNLx5ylv++MqA3ggN5ilsoyrfNG8VCB8Dw36qZp6m1B\nYtDGFmU+uE+5/hi+6Ee3/KRmx6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgt5Onl85wqjtLCXCtXcmJ+6/vQQwHwYDVR0j\nBBgwFoAUb9cNfib5UPjATZVCnL1Ugm+XtuIwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA+vKSOVM8DOFSR1Xh53aT\n2ES1UJKfZff+UWj/YfeEYg0CIDCnj+jaRPgcx1WPMgiUhRExR7jqAtCpyKMldxFA\n+/oI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZdHZ69c7Yu84OTUs6RwGSfeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTZjOWMxOS01YWI3LTRiYjQtOGFjOC05ZjY2YzhmNTM2NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEdkdzvepeRlsLaIHYuokP7U0l4nD6CJaEpi4HgNJKRdgl\njQk4Yz2Qw/vzdzyC2dsWAIw5Trer+GCy6mZ0qgeao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb9cNfib5UPjATZVCnL1Ugm+X\ntuIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf9iqEyxOUJvaKioAcerra2n4xHDL8eeqHZJ4HTndSzACIDgG+gB8s7sK\ncDWefSqPR0pYfELfBixK29+2W/tRRCbN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAVBHQ0xSxcrpKYgsWoz/a5k6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk3MjM0OTctYmMyOS00NGEyLTg1NmEtYTA5Yjk1N2U5ZTFiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZDE5NDRjMy1lZjA0\nLTRjY2QtOGY3ZS1kYzNhMGJiYmYwNWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATmKJcNRIWMuwnFTIOvUzEW7bM6/kpDNtLPeO/GuuvHOej2nlQPiaVb54+7gIfD\n4m5dqGjSYbfx0uucf7LT28R+o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSC3k6eXznCqO0s\nJcK1dyYn7r+9BDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA/zE2bEsMS1aZKAn3EaRhYg94fsMeut81nrmhusUIn5gCIQDb5a7w\nOKVuaKO5PIxJMX+PsE9tKbxEsreyMSwG3AHHNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3173", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3173` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAWAJLhDnII8SoZnKJNaoEjQpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmMjZlZDMyLTYxNWQtNGMwNy1iMjEyLTgyMDE0YzU4N2ExMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY4MDY1ZjItYzQw\nOS00YmZkLTlhYmQtN2U4NTJjMGIwNWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd5L+QcLc3O2P5zyw0IoMu4wL3J9aWHT4+9khaHVaIKChkjvTbA834sEplfU7\nErH9SozMuSbr45pKFt/+nir7F6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+RaY2fe7dIN+YK9bTHWP6ldD220wHwYDVR0j\nBBgwFoAUaGRhtB6GTaHrfmBPyOo8DMoyRJUwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiB0QO2C\noS59uB/VbYQnMk6BChBI6qCSpUun9hlh01akGAIgbnGOG1jAendsy/00RRJqgPjD\nY+X8ljwRzk8etxtdqFs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAewaLMa06JD5lIR+ROSpODQfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjI2ZWQzMi02MTVkLTRjMDctYjIxMi04MjAxNGM1ODdhMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYnZsio7+LhlkCmZW7T/K+FwBWumDG0p65tu+/2KKJjNJZ\n/63rLryRQUIUiNhErIo7wrSqFmX39pUSfkihOgaGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaGRhtB6GTaHrfmBPyOo8DMoy\nRJUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMt4i9JLDbJAeQLqRkV6sz8iQzfyud95zp7zaOVRJ5coAiAsSBxnFDac\nDoCa9giRW7okRpn7ltEYlTyS1XiUvtHjCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISASWbKTxlNvsvTJ9olIUP1wGcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY4MDY1ZjItYzQwOS00YmZkLTlhYmQtN2U4NTJjMGIwNWFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MjMzZWQxNy0yZDhm\nLTQ5MWYtODEyNC03NzM5Y2RmOTY0ODYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT56fst0RBBH7T1q5Zn2bknp7Iqilhfc3Mqzx0DtfrflOxEARpiiUf6NHIhLYwu\n58TeMdM/fbVtdsA+HiSostT1o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT5FpjZ97t0g35g\nr1tMdY/qV0PbbTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAK6ICy06kRA5vLrNT0M1yXzMwPXx1UnvdV1+2fFRVRzwIhALTE4rzq\n8zjmeO6tRaGtWWwspZoeZ2+XvmegE7dy0i/f\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3174", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3174` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAXBt/B/TTPp4We/vfimreLAUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmMWY3NWE1LWI0YmQtNDRlZS05MDMyLTY2OTZmYmE0OWQ0MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQxODU4MDMtZTQ2\nYy00ZmY1LWFiZjQtYTViY2UyZTE1Yzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQoCihPkN03qN0FJ7OoSSj4K6PdnbHf58Q8iAVya2uuDnSfjCZ2cRgtzK05EH\nLw0xUyfDqvyEm0aX3XRfV5Kfe6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU6hiXDpx8ktEgAsnnXfxG8/3NYcwHwYDVR0j\nBBgwFoAU6iwyylJ/huuRtWIS8FpgzCj40GEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAq0Gc\n9pqyABBTr2Kap5IdffqHK8cwVC7inbOVoiseegYCIEkMWIOMQruppyOlMCbejkkN\n8wnVjHvQmi+Fzmmraj6t\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa3MQJtU9h5fX+KKBD08nEqcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjFmNzVhNS1iNGJkLTQ0ZWUtOTAzMi02Njk2ZmJhNDlkNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmtHBKk1zZ0/19RYEjUcP511lfUOU+QB8v9dfX2UQIZ6+9\nvDkEHUw7E8xSJ16Qd74MKesY/g7jzQ7lP/tUoR4Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6iwyylJ/huuRtWIS8FpgzCj4\n0GEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCxv+Ks85/e6N9cxP7AENde91VRQVVNZ4fnWeTaf2KqYCIHueE4zivPc7\nLQoqsDtP8EPxyk/e+A99ldEyxtJ2z3qf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAVk7pKhLjsVOuRcEzdPhuNeFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQxODU4MDMtZTQ2Yy00ZmY1LWFiZjQtYTViY2UyZTE1Yzc4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZDkxM2M1Ny0zMzA1\nLTQ3ZDUtYWU0YS1kNDY3ZTljNzQxM2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAShrnDP/q5/5temL9QMpGvoe6VHx9ADTFknqcgTflcjoOIPl8kyGiY0ZYFIV3I0\nWScQx1Xq9q7cLZSsWe1n1viyo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTqGJcOnHyS0SA\nCyedd/Ebz/c1hzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiABcPNmKDYNcrUoOUiF0BdZWd0pL6Ez6x2Az4iOUzIpMgIhAPMGP+bD\nZXyOkbaMkH/ieqonsO8iGz6xZg0ymKkzQxgq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3175", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3175` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASfFgJEES0kLZYxjX2GM/utOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZjg5YzNiLTM1ZjctNDA5Ni1iZTc1LTRjYWM1ODFmMmU0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTlhMmJjMzItZDg2\nNC00NjY1LTk4ZDAtZjk3ZWY4N2YwYzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9G3idGiuOL8q3YVfiD40qQ5hmt17ChTCLej8pwQ1i5xdElbZ0rs4WA4WJTnq\n3nusWAIYqy8jyqwWmbdvNG7CwqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFCBXDsIfC3nDVgBJj8yrq3kr2EQMB8GA1UdIwQY\nMBaAFNrRIR2fcbib3OxbHRFpNFFc41azMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAwNbgo39QgmV23wcXAuIiqwoDIPXuw/SJ\nlEtrnd8TRMkCIDYNLO0Ap7fWLzPKZ6S+F8MMdTqQpPcsqZBrSwBlEL5d\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARXa9dAldvRGmafHAnF8ktR2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGY4OWMzYi0zNWY3LTQwOTYtYmU3NS00Y2FjNTgxZjJlNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARILDCzmmzK4P8kQeyZ+1oQibzERw9B5K/QlWBsPI7vP+ku\nKyJhl6SkHc/E7dYN8c4GJBagZbfM3xfLOD9KlfKio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2tEhHZ9xuJvc7FsdEWk0UVzj\nVrMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN3jbM34kGxv/7x6XJ0WucPNQuoOM+YkwzSF43uognP8CIF8X/mP6PxfH\nLiVx5JMIlhsB2LS9nsbPSib1bbHLcokx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAcyFMRAj0aFHZsJxqKwmOcCUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTlhMmJjMzItZDg2NC00NjY1LTk4ZDAtZjk3ZWY4N2YwYzJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYTVjZGFlOC1iMjBh\nLTRmZTUtOWIzYy00NjNlYzA2MjI1ZDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQooBNuLAravhYBiZt3V9Dbdp6JXqyllyvsMVCEjpMRV2o02mVQT+lgQD/NQzjT\niiDFngNQxnsiz8q6bKbo1liHo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQgVw7CHwt5w1Y\nASY/Mq6t5K9hEDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBrjWe9P3CzOUla9bDaxkOxj1X9KA5KY2sFVXaEyOhJkAIhAPYGZsQr\nbjgNyOmNl9dEai7oKRqE/HUPYY/bg+WnOtQ8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3176", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3176` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAdB+euJ+STPCTEmFfQx4VdKvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjMzg1MWIzLTNjMDktNGM4Mi05ZTlhLTM5OGVkM2Y1MDliNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA0ZWMyZTgtZGJi\nMy00NGNiLWIyOWYtY2U0YTA1NGQ1OTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiCa5pX8zdCHu6zQFWurTs29/OO5sP+L3QtE+iKIiUpMo9gmk24AJSc7cjJ4p\nu1rmhbdNq9q+WofKh5iWVyKbAqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTdrcxgpHZ+d+5pcljZRK6dHpiwwwHwYDVR0j\nBBgwFoAUzx1lwMS4CV/Kn+ZmJI5n+OpID9QwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAO/y9nayir80\nKqlvitq5AW3HcoCCWrnApeP2d8TGQxi7AiEA2BuLDhC+zp/onvLsVW72dx3in/H4\nK0wEcv7TTTrHHMw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATEI39b7Lv6msUFNX5JUroqKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzM4NTFiMy0zYzA5LTRjODItOWU5YS0zOThlZDNmNTA5YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/zpK1zbfNhgIGo1NUGtuLVfFIR+32/7ZdaD97eT6Z/jGB\nKYmpV1ev1jy1nEUa54qhbbYzizaAC3x9gA9DKlCso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzx1lwMS4CV/Kn+ZmJI5n+OpI\nD9QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAgwj4VnWF6+JaGviXMWQ6edgY9Gp2/0627r2FnFpDtgCIQDWX1yc8/5h\nzBp1KP3Oo+voX3gJPQb2tkOC+9cuHOldZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAQ6QrS9rzO7ysuybupyXod7hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA0ZWMyZTgtZGJiMy00NGNiLWIyOWYtY2U0YTA1NGQ1OTFiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNTViYmM4OS0xMGIw\nLTQzNDgtYjAzZC00YzQyNTk4NjExNzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQaJYJigCTtEAMGVTgtowS79NpVrXtRpV4xEhMvGu7QEq3CJqLeTZ5RQ6K8JwoS\nKKdEgEdjbBtB7usSl/qyI7Jjo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRN2tzGCkdn537m\nlyWNlErp0emLDDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAw1x2G/MRc96cqjUTMtU/J4nLR3EVL1ngXtZImOZ937wCIBBqNuwi\niUC17woE7pPXdF7BfszKnrBvEc4MPchgSn4Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3177", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3177` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAZVi+4/SA4RKxg0Yx9fJYNBuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzNDg5ZjhkLWZmY2QtNGQ5MS04ZTJkLTk2MDBmZDdkNThiNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFhYzNmZmItOWFi\nNS00MGQzLTgzMGItODFiZTVhZWFiYWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/K1kcm/FU3WJXTy6fNYw6fWTn1uhhozm1owU8Qxe/Z4a4VZIjwk2UtOLIjp3\nAb87JiyldjMUA2sUnloK/NhG+aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtaz+WzCSksLGegLem96uNV8LS+IwHwYDVR0j\nBBgwFoAU0/yR3VGZehyQgX0YllRsVdkp26gwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgVpnPZmNGC07K\nl4OeBaWDXNJqkd0vUW7wTzTgmTaACSoCIBoTYbvGZCBjXzw7d3CRgsfED0Z+e3hI\nCTMp5kj0dO/z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV+ytc9qJbSfqQ5Ycct471FHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzQ4OWY4ZC1mZmNkLTRkOTEtOGUyZC05NjAwZmQ3ZDU4YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQu9AjsQPIhU/9xHPvvaKuIe90qrXH3BuXJA6Ebog0Nz1YP\nYlyL+Jh7J7fpqztN4s68wUFJQgOuH3VOVTy7+nQ9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0/yR3VGZehyQgX0YllRsVdkp\n26gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHyZrXIYZNRdt4j7FXhFn57iGAFP+P/UmHcx8WC1Y2qYCIQDWk6s3lEz8\nrGM2ePX8jqypBBPFZvZ9nhXjk0NqX7BUuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAQNg9GhDAgR/16Wl43qTQioBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFhYzNmZmItOWFiNS00MGQzLTgzMGItODFiZTVhZWFiYWIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMzM0NmM1NC01Zjcy\nLTQyNGYtYmY3MS01YWIwODY3YmE1YTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS2UAXeh3RhR9NxoQzGZ9rKdHkkCy88IPtKqNDiPUZkT9GzdKEUafj1wrIWQNIJ\nvd6OuTtfKmatMS9ZYpCu4J+Qo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS1rP5bMJKSwsZ6\nAt6b3q41XwtL4jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA0aydEs1zJsEHsQuGrCYqJFgbZIODt5TV0VbFUj/WiTACIAWDQU1f\npIZUVDyvhj1BYyy/XSSBgA3GE3kgTmAGbKF5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3178", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3178` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYh1IN/UIr3mxGPW1wiTJwKxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4YzQ0YzQ0LWVmNzQtNGQxMi1iNDVhLTk0YjBkMWVjOWEwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI3MDZjM2MtNDk5\nOS00MDI5LThiYTctNTA1ZWZjYmM0NTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgvQOBVKlZDGzg067cr+1cKPfEidDiLOsLk8KiJAmafgOeaIZl0vMZW36kqlW\n9+3tc2+wGj064+NFd2z/TmYhVKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3UyG31KblgvoPu7Ix/+RpO4WhXEwHwYDVR0j\nBBgwFoAU3eWu5ducx5o6Eh3cZbLP0pSIQ98wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCO1rHzzc8a\nXUSLyqnroqNgU4t0DJOpcgqFMlhpMYtbhgIhAO4qkJWky5XgcwJU29XbHQZY++Uz\nZ75nM7uTM9aF8E2V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWnP/N6JkqyTRrt1xzpdR8kEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGM0NGM0NC1lZjc0LTRkMTItYjQ1YS05NGIwZDFlYzlhMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMueroueDfohvCsXeohMWCSbazDyZzGBKazu+S6oNER0aU\n5FfO+HqBUBGZjznBE/DcZvBRFK8+ItKCpk8WSyLeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3eWu5ducx5o6Eh3cZbLP0pSI\nQ98wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEreTQGm1mtpXTzjrXDwXUmLSRYQp/LJJ8oVVglF/rU4CICU2FdlZLCLp\ndJaaBL7eGGd8nWId8dE1JiMj1udGglPP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISARrNEXpF1lt0ryocXFBi+4WVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI3MDZjM2MtNDk5OS00MDI5LThiYTctNTA1ZWZjYmM0NTVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NDFjMDgwNS0yMjY0\nLTRlYzItODJjNi1mMjBjNzA1OWZmMDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARSwZsfKo2YCFGnX2pHt6gjveTJDUpJgolhHYeVVvYC08o22U5AJauDbHRfMemv\nO/+iC/CqV9uxGBowg+7MbFRBo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTdTIbfUpuWC+g+\n7sjH/5Gk7haFcTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiB7UMVysg3ZzzTcG52oADw2aCvxP/s7OLcobuw+RnLIjQIgDdTVnpdA\nDRXpGODtRgz27q4/BgFfFoQ0JPU9V0Xn1iA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3179", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3179` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbbA09xHOpcB0fxvxD2bzJ0dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhN2ZiMTZjLWM5MzctNDNjMS05ZGM3LTYwNWI5ZDFiZTUwMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU2NzVkYTMtY2U3\nZS00NzhiLWJhMzctNzVkYmM5NjkyZmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE66LGuXTFYfWZ6PCYS3UTcPEoXWEvu/EjlPSjehQgkt6zYUog5PjUyjHVCxBv\n/zyWk83J+Xe6mk+sAy52f9h2YaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/OBlFxkVeUkSQ6RjWGCbD1N8CRowHwYDVR0j\nBBgwFoAUl+vP2qF+S6rJkGBGAr1D96ykbzEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD6hvrLnhxM5jImANeM1Y7V6IFhlC1wE9yXDXWfhdEFCgIhAMTtinLu3UUu\niz5pT56t/mi++s+6EIXg4sR8jtX4pFBb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVi/upr8L6D0A0el4wkHUldtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTdmYjE2Yy1jOTM3LTQzYzEtOWRjNy02MDViOWQxYmU1MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFPIeijVCSQOEvzTxaQ9ZzZV2jOqIVixwRvlOnWKK0b9rC\nTTmeE8o9MDh4TB7Ff7derd+BF9SjlNTpF4uQZ2OAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+vP2qF+S6rJkGBGAr1D96yk\nbzEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIaSW13lrWAWQciI2sgkrxGX7p+P9TCrnaLOXsnwiVMnAiEAnjBHKPQr\nsvCBcHRS0pweEYYSuQ/WrLaL+kX27okWOUA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAR9brZNZloQWeybjk/N1Zk/bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU2NzVkYTMtY2U3ZS00NzhiLWJhMzctNzVkYmM5NjkyZmQ4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MGEzN2I5Mi0wNzQ2\nLTQ5NzYtODliNy0zNjMxOWE3ZmI5NWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASZv0o8j8zCJLAvBP6BXpRzwa5T1ZkF2juzdi0bKgIPGitwMSqONuIFVQvb5Sn8\n7UpI6gGNEESdQck8o/y3UASdo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT84GUXGRV5SRJD\npGNYYJsPU3wJGjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiAWleEv2zVT4/uocpJY6HyZAQkTUR/lAzSbBUVMTFBHWwIgfn18Geat\nAdXUS+WeDx1CYUtVOhJ6fHAnu7tLyrLzdR8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3180", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3180` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZat5cVW9DrmeHtsteYmrqYNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYmZmOTVkLTkwNWQtNDJhYS05MGMwLWM3MGNkZmI2Zjk1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI2MzJlYjMtYjE3\nMS00OWM0LThhMTUtOWNiOWMxNjVlMDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsvGP4if9+ucQhSvyAqDJVpouYc/eAjmh7zcnIjqSCEVTaBfGplwZ4SQmk/mU\nwNXAgmNsexV2aGHSViKhd8kzH6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMeSfu1WWy+r6KgoQz6GavsRRWaQwHwYDVR0j\nBBgwFoAUqbp3hS39eYEU+ciJftNchKkd7cQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCP/nOT0SB7cFqHwNKyZfBdpFliyoPTyYS0jpFYP4cmjwIhANxWVUSnfKaO\nqWjldpSqEMqvJI2pT+3FZIfiZR1OnYk7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc9Imy3N4hfPf7NQOYZUJ+XCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmJmZjk1ZC05MDVkLTQyYWEtOTBjMC1jNzBjZGZiNmY5NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATe9N0YK6Mu+VSRoE77kT+SEXAzH1F0ajf08QokZUS+XnFJ\nTiISaa/rO6TVsgKvF8pdbWnUjXbQKwBXX0xEYA+Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqbp3hS39eYEU+ciJftNchKkd\n7cQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbRIXuIoCCCBW4p7NqWj8OWAT2snLKyIMJ+BGmqs6rvICIDm/1lg2haY7\nCgIRTyQVadmBG06A4cyWFtfeBFH5YUnx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAdbiESa+wVbbz25vivE/UxDHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI2MzJlYjMtYjE3MS00OWM0LThhMTUtOWNiOWMxNjVlMDYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhOWVmYWQ3MS0wZDk5\nLTQzMmUtYmFiZi1kY2EzM2I4ZjQ4MWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQto0Hmn6swO39ZtYNIRmFy/2p5QJdAvh2zNwLxZt9yeQtqPfQmc1Av9F/xPleU\naQqncerR3rRCTgMVRPDVXRAyo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQx5J+7VZbL6voq\nChDPoZq+xFFZpDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA19oPGqj2lsvbSaHkY9PxL8G9H82rFfYvRVnS9Vqw7wICIDBZNM3R\nNUUPBMBdaZb4wQvRiKpLY1fqgn7ID/+TGesB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3181", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3181` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAQEyJLKSaTdHe1ITHgsuf6+5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwYmYxZGUyLTJkYjctNDkzMS1hMmQzLTA1YmMzNDc3NGE5OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM5ZjRmNzEtZThl\nNS00MDc5LTliYTctNTkyNWZiZDg4ZjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUtOR+vxp8D0QfhB9qDyUHh9ctHzVSjuQEIBRnSAUY2ETWjl52HFzsDD6qolR\nbPttJeR/N+OF/jLSLAjl7+YO0KOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYOmE5Wn5Y3zAGa13R9sgSRyBWtEwHwYDVR0j\nBBgwFoAUtZAgrFQONMGH1BnopyJiDhULTnkwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDL\nqXGA7Kniiw3nOnzroupOLqV59ez8qGoFO0PKJTo6+wIgfUME/MfG6YrMlQk/BSPZ\n47GeWo5lWUoYixIytYrS/uU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVniB+yGBpq0AoJW+R53gWbMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGJmMWRlMi0yZGI3LTQ5MzEtYTJkMy0wNWJjMzQ3NzRhOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0F2/rcHEWRd4zrMNtnB9MHpimbC9jBkXtnIBajPr6eK3L\nqC8su0IaFsoI3IIGKiqO/+aOGXtUKRdEtGbVAId8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtZAgrFQONMGH1BnopyJiDhUL\nTnkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMhzgWfGhlD0xBgHom9LeMdAHOCeauJEgX9a1XWiygOEAiAo/Q1Mw2K3\nMhOP7zTiWu7wc1xx2fBr/KWIWWfBqMjdkg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAXBVEG9BLsCLiCxO/zKzuggfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM5ZjRmNzEtZThlNS00MDc5LTliYTctNTkyNWZiZDg4ZjFiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0NDEwNmE1OS0yZDE0\nLTRhMjYtOGM5OS03NDdmMmM5NDUzZWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASeDJvGlcM5XAsRJ+aHXhsfliBt1oQYRkMxcip0ilWehz58e17bHZ3m6wc4EO3L\nxcmkp1WMIcX/xHm+pT0uK3Afo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRg6YTlafljfMAZ\nrXdH2yBJHIFa0TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAiRdcPTbuITNVamBWvwJGrGz+ik9+NSK6quKk+j8feiACICMrFVn5\nL+EAyoeOyj8fwWArE6vXUHzMQJnVy+5PZ+/7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3182", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3182` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAUUUmbHElbWDQYdFQxxIgkoDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxYWY5YzhmLThmOWEtNGYzMS1hZjkwLTZlMWU4MTYyZWVjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNiZGZkZGMtZWM4\nMS00YzcwLTkzMGQtMzI2ZjViYmY3ZmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYRAJW77TUg4zFkqFeNgNWCTKQvZ84/ak+LVc760XQOJXa/DUl41Qaj67V2SQ\nc7KNAP31oXudelIULfjzZGrWS6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIcjUnCHSdXVA/JvOIDTlVnm/b3IwHwYDVR0j\nBBgwFoAUauEUu8+yQmyySfMUYcAuNQ47xLswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCICowdA7kp2mjTxWbwv/ZNejQ3wPTITfVn/1vaC6OFZxcAiEAr96J\n93v/pE4H9A/XwwfblygNEEZmix3f1QoQlEpYMdg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfNe/fOKCfoO2d5T4frITDVNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWFmOWM4Zi04ZjlhLTRmMzEtYWY5MC02ZTFlODE2MmVlY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSNdF4m1lCeKgOogen+d/B8WWwr3BJvhehsXlpjWvnkfJs\ne/og7YWcgMiakvLUhHtHyk2ACCduBuV2uyT/tdlHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUauEUu8+yQmyySfMUYcAuNQ47\nxLswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQlLRMiWlqhsqa23mi545CjThMNyhvOT12gEx/Fgn3t0CICLWOo+bAQZ8\n9YugSJHPyPNn2uk3fS4xAV6iVkUl/wWN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAeGLtmkfdOvDUxmPg0kx3TmqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNiZGZkZGMtZWM4MS00YzcwLTkzMGQtMzI2ZjViYmY3ZmQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMWQ0ODQ1ZS1kYmQ0\nLTQ4NDYtYmQ0MS02YTQ4ZWNlYmViNzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASlskOPk1kczRGroet21zadA/qATajJXOjGmDze9LRvZCveUqkEWTXrT1wOYojw\nJs4rct5LV2N6qppzAoLBzgu/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQhyNScIdJ1dUD8\nm84gNOVWeb9vcjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA0EIEjAkMVZQd6avVWanXXumj7C9roMF0qZ/GE9zcAGQCIGSwZ453\nUtyL2fSsbB/WbxORYvDCV6M+AY7nnTjlJJc3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3183", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3183` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWOxR+K1txyZtz7sbrU+9g64MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3NThkYWVjLTM3MzItNDc2Ni1iNDE3LTE0ZDRlMzFjOTExNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFlMjY2YTQtYzE3\nYS00MzQyLTk3NjgtMjUyZDQ3NjU0YjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkRZRS4hQRBXhYz3HcApGR1uIeMuEpcgRakLbwD8qEzrBuFMEv1dLu8/YeOgS\nKSKFtOygUjBqhvOnGDrTWY+NraOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4+lEgNEuNR6Vo0uPkLB38fQGOAowHwYDVR0j\nBBgwFoAUGyMlRJ1teBi1GjfOd4UR5CyjFEYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIDPGf6805rrzz0XHjeVqCqKRZLRHjMnhzE/uvQ6hDBI8AiEA3Mug\n9lqaNWvwev2YROCOZGWQ3q0aPRogRQzM+Ma2WfQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV+sGCv2Xy53ZhREWMmFBXT1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzU4ZGFlYy0zNzMyLTQ3NjYtYjQxNy0xNGQ0ZTMxYzkxMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT25neoqJSNoN+Emi/dUt1j08E5zpKUNW8kL513tIe9ba1j\n+iTRuw2GTO6MINo5uj60ZpSiGIq+myshPjT9NpBfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGyMlRJ1teBi1GjfOd4UR5Cyj\nFEYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDcWRUX94oBzfzeMhiGlKdUNsCb/Yw7m29/4166CC15QCIQDa/jL90uC/\nJJrmvzZtOEB47ZDOhKPim2fmziKgipPrlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAQauFlhQpCrDIaB4AEJFvwzrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFlMjY2YTQtYzE3YS00MzQyLTk3NjgtMjUyZDQ3NjU0YjQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYTM1NWU3MS1jNWFi\nLTRkYjMtOGEzOC1kYTM5ZTQ3NDM4YTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ8Cg7+P8rYOfvC2SI4rN9fQIl8TGbA+ymQCTZiqoLE5nffQ3hsmbWLSwG65TyI\noDnSg295AGREtncnZS7Lruwwo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTj6USA0S41HpWj\nS4+QsHfx9AY4CjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiAZ9oABp98oBlHkDO6BJa65Yyb/89NuU+PBSQP9NWtZXwIgdY8U2cm5\nLbtwvrmdSCe2dD6Lu+IQFfiSZCYZu0JXijo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3184", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3184` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAeNEVYn+kKOWDGEzB7ou8KwlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4MjNmZWEzLWIwMjctNGQyYi1hNGMzLWI0OTZkNDZkODkzYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU4ZjdkOTktZDU4\nMS00OTAxLThkYzAtZTFlMDEzMmEwNjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjw0L4e4Jfs2gZS0UHXzfVIYMhZkrzYiz4OZDuH7KT5+jRZfkKHxR9pFn+NTh\nRMy7DndLgcq/G2N0XBeY2G8Hd6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIKVbksvJ+ziU0vupR62cAxT9sM5MB8GA1UdIwQY\nMBaAFAFu0qeBvKDYVtSDDxT0aJTskVCMMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA/xNTRMwypnhOA54FEYr1CnmdIOrHTPok\nlQmxVEdItR4CIQCEW3Yi29BtXWRjRvCI22X3VA6NGgp2Ta5kaTrqUj19Pg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbCAitGatvAmzUKsrmR4I4sAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODIzZmVhMy1iMDI3LTRkMmItYTRjMy1iNDk2ZDQ2ZDg5M2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKzc5w3Rv6iH1piF+7sKRLMyCv4uQ4B4ZTQln1rRRh8W2Q\ntNQ8GIgAGDHrmX0Evxy3P5YbJCjJDEkt5RbmhMovo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAW7Sp4G8oNhW1IMPFPRolOyR\nUIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOPDLGHjDr2oj10wNWBokbUvK+Y4KDxtxrqP1H2K3OOCAiEAhkhxLxiu\n4vBzofviQGf9+Sf0C5EX/XwKvz7IjEakA9U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAW3Ag/PVhn0dCBiwvT0VNiXNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU4ZjdkOTktZDU4MS00OTAxLThkYzAtZTFlMDEzMmEwNjE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YjVjOGUzMS04Y2Ex\nLTQwZmItODkyYi1lYzg0Y2I0ZTQ3NzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASDM/Q6jz6N9z2ZWA6Zx6PsvFG9WfJ16sfLNPRikp9ct3GAzR7WJyaCbuhUVo1e\nSWGN8Lx00CUHMZ8JKKfyGH2Xo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSClW5LLyfs4lNL\n7qUetnAMU/bDOTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBzZPj40QJpY00+6L5mHN5OG9Odmuln8a+KHS2Me2L/eQIhAOwlrf/R\nTzskI/zrJHYc28gynL/JuqjzhVMpOAE583Tw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3185", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3185` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAW4z+GoX97J6h2OcIJYxWgfKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMTIxZjJmLWQ4YzQtNDQzNy1hMGVlLTEwZTk3YTBmZjFjNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMxYzI4MjQtY2Rl\nZS00YjFhLWFlMWYtNmI1MmFiOTk4MjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEczbwirGCLgcorNwOk5fgzVEwTTDlq3aO10zFKQhZcrxHSrZ2HBNtfD5el8o4\nXtv1dvcnEQtLW52mEgOWKeCC86OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUFT59f8QrDYztyxweLX8CxwH0s0wHwYDVR0j\nBBgwFoAUYP+/DGn/lQxJ/kuquz4vqtun4wwwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAK+8J/5c9hSb\n0nvACwcOs6ixDRBemdaZys9QQLLGDDVqAiBZV6u/Epxgsfg0X6YYkzXB598PXRvI\nmEv2HRCNdz1s6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUfQVeFBBPrnnHDG/fsDxbdUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjEyMWYyZi1kOGM0LTQ0MzctYTBlZS0xMGU5N2EwZmYxYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGyOYmBfm+SbdJNsqxQ0UqUxiTAK2YWMm38XmBT1sd3nI2\n8Fg1J4jRwgIPc6BiRvfY3LZB9VOo2hiwWBFbZgLao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYP+/DGn/lQxJ/kuquz4vqtun\n4wwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOjCziiybhMZGOQQYh9onbYfIuHlYcLLCeoY0JWoLvm4AiAHThpYkQRg\nwPLsdpQX61G8Rn8KyzSenQPr0b46MxQKTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAcl5DWSNnFqu9WAKjfQaERhqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMxYzI4MjQtY2RlZS00YjFhLWFlMWYtNmI1MmFiOTk4MjZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NmNlNjBmYi01MjU1\nLTQzZDctOWYyMy1hYWIyMTgxMzMwNWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQsnLjcCG2wKQV0iywR5uvYnWcmud6tumcUvypnkGHL8scUS7PR2EgSPjnyaXpf\ntJX1BzA+tI7mToi3zAsL2O5ro3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQVPn1/xCsNjO3\nLHB4tfwLHAfSzTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBzEYiFX+M6+hCRvQPfg8URK40osy5P9auBarTuaIGzdQIhAJoi15Hu\nhZGI8golvwToNa9InNAt2f0wxw6KNqLG+b4w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3186", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3186` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAVfPE6jUmhAilAXnzg6AKT77MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MjU5ZjBkLTY1NmYtNDJjNy04OGU4LTc2MTVjNzU2NTg0MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJhZDc3MDgtYjhi\nYi00NjZlLWJlZTMtMzVmZWEyMDg2OGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOafkp4h5xrOY2vwgkixMS1fG6hYsDwgOR+CvtAhIWljLejp+ooBP35MVVU4Y\nKMATjV55rvisJfdQXTYRWmxIsaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtrj9SPQ0UbSCfQTasr4bm71GzAwwHwYDVR0j\nBBgwFoAUzlIQGTF8ndpbqwf60q0kmscC36YwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgObIeh7ZXvkom\nGv7pR/CeGJh7PM6WdDhlqYIXjTQpN7ICIDKIKjstufi8LMH4yMijCIBNdWOFARBQ\nSAl4q4kKlt/z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfonYSmv9Ai4etfyCM8g3oRrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTI1OWYwZC02NTZmLTQyYzctODhlOC03NjE1Yzc1NjU4NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxnioFBxw+9VmQc0hQulbEMlodvKH+newnDOZkYb0aacHk\n6XfbQ0Z8Kc9+ffi3+LeLtFpN0I65VlBuCIV/5FVGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzlIQGTF8ndpbqwf60q0kmscC\n36YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGPz/g+loiZ/jn0zLsxUZxWSoDQpWq7zHmjZm40LhK5oCIQC64gfQVPVu\nVOAbmpH4/djRC13LUMoE+72UvTQQjJ2XkA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAcSpPfSs0zy6ndiX3dNugQ5EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJhZDc3MDgtYjhiYi00NjZlLWJlZTMtMzVmZWEyMDg2OGEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NDM1MTBkNi01Mjcz\nLTRkYzMtYTM4NS03NTUyYWFiMTRiMGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASJvqOJ43iFY2aqRBhkH+9JThZ0MjyYytRJ1kuZP0sKM9PkcCgTEYtBkahgHKAz\nenGf4XQPIPGE8MTl487ogDDVo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS2uP1I9DRRtIJ9\nBNqyvhubvUbMDDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiAax0DkrJF/shWhB1v3qugqMAbUixJG+m8YK2RWU8nF0wIgbc+88NmP\nGMu5WROOeFtV4rob/SEOml+j5Z+KIx9gh6E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3187", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3187` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbv+pQlcWsV7s3mKgetZP+rgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5N2Q4ZTM5LTRhMjAtNGU2OS05MGIxLTIyNzZlNDljNTBlNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk4MjM0MzMtZjMx\nNi00MGFkLTlhMjItZDI0OTNjZjVmMDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEEDVlxyyyS1AY8NNdZFwUMgbOPnJSoPIhvJsdgUm2lvob7K4vR/czzZYHA57\nqqxVC8oHAdWx4oYKLavZR4jpZ6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV+1X+iAtKD5pF5fyXh/jet7pYtQwHwYDVR0j\nBBgwFoAUR4NibvhuFsFl1AJUjOtD5OeJsskwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDNF+hMDafql\niviXxAsOyuDgfmcNOZjRyB1IZOuszzUYAiEA4n2rXMI9MqSxgkDLwgzBmldHJt5/\nCsx67odbfcKmu+I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYdSubydH5RI+MM9UNy4lQlaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTdkOGUzOS00YTIwLTRlNjktOTBiMS0yMjc2ZTQ5YzUwZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZirDOfpx0q8CsN/bQreenM1yBPhuYyReDdtkRrzAZOIbN\nRmL9vnHnJKTHfaV96JKZ1I3KGifx7kFCpPSwy7aVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR4NibvhuFsFl1AJUjOtD5OeJ\nsskwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJXq+3NzYQ/7GZgi7iTel7ksDFJTyHcHPkyG3dAL43EBAiBYMAjcTLsJ\nvKubs4p0rK/figXWBthnrAYxgDgwhPBNVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAbc6mxJ/fXvPP005NzIh7QJEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk4MjM0MzMtZjMxNi00MGFkLTlhMjItZDI0OTNjZjVmMDMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYWM5MmFlZi1mZTY3\nLTQxZjAtOWZmNy0yYTNlNmZmN2VkYWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ8mAzXRUOdD/MYjnIeUdStpStd99ExVrzuun9Oe4t8vBAMRTvfItkwGD4aQUq8\nTpNil0pkYZPkxXT9VLtRH9Rlo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRX7Vf6IC0oPmkX\nl/JeH+N63uli1DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiAxam2seGD4SNO9mEY9h6XRop1mFmu0/Ao2FjaTlWGADAIgBic8+d+b\ntDj83xsSRpjH9jpSpMTVk3jhaIa3I7NKGzU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3188", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3188` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARFERA53YTWop1Vcntztb0lwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3OGM1ODA3LWM2YzYtNDMyMi1hM2MzLTliYjc3M2JiNDBhODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDc3ZmY2YjktOGQw\nNy00M2Q5LTk0Y2QtN2FiY2I3ZjhhYjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsU//dJkkeoUWQZqlm5iWUbBpcrxaBmKtrwQfiDCDAmbwD/JOAw4Le6t69kYf\nYTHYS2GEryPu57K8T7aZ6tPL4aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDNV+xKvQHx2dxBMc242mQqM7qdkwHwYDVR0j\nBBgwFoAUJP70XT0Inz9RJh4+r24ju9GeqSAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDa8ZPuFmZNpnEiYIdtEngTPWbFh0IZ+wEODH493+ZoWAIgOUc/jsN+c9NW\n6HrZF77ECHaddkolw3P94Io9QQmQBoc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAav4GKzvR4HOIy7mah2J0b4KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzhjNTgwNy1jNmM2LTQzMjItYTNjMy05YmI3NzNiYjQwYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOQCyT9fmUXJ7BKR1laeAwNPT6CAb+fcm/mRJT/nFNM3+W\nXhe83Wwm+0UtbP+pK8sp+384xEXaqZv2XxMGRfLpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJP70XT0Inz9RJh4+r24ju9Ge\nqSAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ80bPlGznvKgDqNcjgVoWUdwhA3EovS/6XlUIvFN1OSAiEAzO7mqNis\n44s7HXhmajqh2HRS0LB5sSyCqm8+OF43ANA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAfHgyKjNk+ZIdwuMuG7Sz5k9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDc3ZmY2YjktOGQwNy00M2Q5LTk0Y2QtN2FiY2I3ZjhhYjhmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNmM3ZDk2YS00YmJm\nLTQ3NjktOWY0Mi02MjJmZjNjNDgzN2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATAqHSflgUrmW+5KC65+ZpDMGVCLE6/ScoC6dWiWOrsd8GkthGGKZBhfkssSCE+\nr+JF8qYGisVabkxt1AwJDe3Ao3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQM1X7Eq9AfHZ3E\nExzbjaZCozup2TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAY2eLHjK+vgYoKKJ8EYgIUiMb9ClpUC8oFd0iDQFVFxwIhAKWD1jLP\nknB08wEHdykvsLcaBjWjW72zHhyEVg7hrAuD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3189", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3189` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWrtrUCK60ynVt9Ia20+TzfuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NjVhOWM3LTNmNGQtNDM5ZC04OWZiLTc2M2NiMTVkMzZlNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkzOGUzN2UtZjU5\nOS00ODViLThkZjYtODVhNmM3ZWRjMDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXk/1rvZyp+znPSB5eHIXALYzDMVYXzFAfCzVOifL05UucavEgQAedvixGkrb\nktVNF1YJIfMdCn6/DUQH9RO+haOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUny0CaH6TFvqK+R0oN3zcT0GwKcwwHwYDVR0j\nBBgwFoAUrdX1vGxaKGSBi/kDlapGPp3eTUMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCBdV5Lgny0bE5NrgSLFkXrz9OYLKKJnZsSbKFZPtF/HAIgX3VLcsyX7Q3V\nv1pR1JX/wfdzz3c8tl1isTeEm0Fya7A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY+jdYrOL3ClF+9C4eymjUgLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDY1YTljNy0zZjRkLTQzOWQtODlmYi03NjNjYjE1ZDM2ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+9kz162PBRaEC9sz+Knw4feZsEzTKdPvDJ2gKGGH5XZ9l\noruXw7Y6h2EoYIY7ucdyclaKl1G4JGLoiJJgTgEBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrdX1vGxaKGSBi/kDlapGPp3e\nTUMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgd5caBbDwiwbi+2wIA7SVOYuo9t7BcRE3znE7O4oyossCIQCDz1tBS+Bv\nmms/0CAyN1T8+lrD/gGpkGtYVXsl8ik6qg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAcwTN6HWnGadWteHiJFETjKHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkzOGUzN2UtZjU5OS00ODViLThkZjYtODVhNmM3ZWRjMDkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNmFmYmFmNS1mOWYx\nLTQzYjctODQxMi03MDcxMTNiZDEwMDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAART2xtbf+bZfEs+PM5pTU4dpSNQj7wXNe+wMI0PC4oWgrdKH9YCRQCTgrwrY/h2\naLkyopgfoeLZc0UTfErZ6ByLo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSfLQJofpMW+or5\nHSg3fNxPQbApzDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBKCamZqHkyAyjnjxKyrgC7o3jTfC1Bhpgys346VI5NsAIgKw9q44Vs\nYtQjZ+9qiGcyNtEZbSn1spp6iw5mHn1WRss=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3190", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3190` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISATBKCWXknmZGG8jicUw2arqgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMGQ1M2ZmLWJmYmEtNGM2YS1hNjE5LWM0N2ZiOTc5MmYwMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY0YTE0M2MtN2I0\nZS00NzM2LWI0Y2MtZjU0ZTc4MDRlNTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPYH2gSW2dViXE1n7lJtCfC6WazfyIQGC5mPa5rwT/DUZLmYDdJw7mx4fmi5a\nmDW6/h4WgOwMqecdzCgVYmLyP6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3t2qv4+Ui4M6WkAZ4UAdemviFAAwHwYDVR0j\nBBgwFoAU4ogmV339ucLF+cUWsHfzAXEv45gwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICDr\nIBxBSOcrD0yukTiVasmgS9AIMykbwR+DfpykDcqHAiEApbWspkW612BVtgbV/lhl\nFq4cHfzKMmMIldxlMzkVeWI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW+IywYH2wtpD4Y7KOTSMflmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjBkNTNmZi1iZmJhLTRjNmEtYTYxOS1jNDdmYjk3OTJmMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZ4al90x6LkNYZMiGR6hrsG2iOjhDr5YeBA0CBDmbj/D4m\ntMTBSJcWXtpRp5OGGlmy0Ct+ky9saUFZa/ewsrG2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ogmV339ucLF+cUWsHfzAXEv\n45gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN3zaiF7yX5tE2Kvcr0R3FVw+WnkeIQVprWonA4MIVNfAiEAouSD9x8b\nzX5QsBq7XFRvu96l22uAyhz9wT5RT1whLGw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAYnC01q60QCF1mjHaI4COMjRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY0YTE0M2MtN2I0ZS00NzM2LWI0Y2MtZjU0ZTc4MDRlNTEyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMGFlNDk2Ny05NGIx\nLTRjZTItYjNiYS02MzlhMmMyZTExMTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR+8DjIEODsRtjsMYUkuAttfD3ZftoYXYjXaqfqcyORBN8N+CsSxTa4PdPrSXT/\naFGQS838Gs8UiVkntLy5GBjIo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTe3aq/j5SLgzpa\nQBnhQB16a+IUADAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiApVS92mXFTV1HQmG/evliVD34yE7cJ9YHEozlMa54+ZgIgSOtXXdpE\nDcGjvmMAg2l+e7SnnkoT6eNkIH1MtcNiDXk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3191", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3191` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISATfe+K9Duc02sqw0lKt9CHQHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiMDBiNWI3LTcwNjItNDQ4NC05YzYxLTQxYmIyNzc0YmFmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZhZTc3MzQtMGZm\nYy00ODcwLTkyNmQtMTExYTMyNDY2YTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2rL9akKcLj8F3VozMQEWGWXtJBj7gnR+4dGH9FyME3WX4DL92rPaDIyfcDoz\nvxpF7t1FxKbExD8iZ8FquI0PfKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE7ep+FFWCLazuxSh9ZDXgfNIPt0wHwYDVR0j\nBBgwFoAUubPKoUvA1GTwRh7v6EAiWisVEV0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDmg+lcbhBIeOUAwjOVA0I0EnNKRIB9nJMiqPNDxP7b4AIhAN8M\n31UGWMqDlsiqnJtMMUvu+xaCnIYDXBCKEZTgMYmN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa/zVYdEffQlKwmfGa92J2HHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjAwYjViNy03MDYyLTQ0ODQtOWM2MS00MWJiMjc3NGJhZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkQc8xrV+FMwjs/syQxqWeKbpXWJf1oVC0+Cv9sjoCM3Or\nhAJ+grjC5Hi1KFfNpUhA9WJCAQ57Mf4+16vx+qUDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUubPKoUvA1GTwRh7v6EAiWisV\nEV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIXyqh3zCpawH7h4lvqNQnoSJ333oiVAn0UNdkUIcwqhAiAbQgACdaJ4\nhdliqsU1+7JGw9q7vDeD442cWLlYUge4Ng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAS2NXSOyYer49D9SV1oGXLQxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZhZTc3MzQtMGZmYy00ODcwLTkyNmQtMTExYTMyNDY2YTgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMjk3MWZiNy1iODFj\nLTQ3YjktODE3OC01Nzk4Y2MyOGEyNmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASj+FAfub9j7U1ML9KhBNMNLWhsr1pUuilk8zvOEo1Mc/uh14wKxnIXi1ULB+OJ\nBMV49R2vrR3v/XkxsBNdGPRLo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQTt6n4UVYItrO7\nFKH1kNeB80g+3TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAr7BhLu130IvutE7TEYg5/E2i6KaLCCHWZOlvQYXoW1QCIQCQzPwF\nwpNv25PL8LSZTmIgzQbkWcXaRiIvdSitFk1zzw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3192", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3192` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAQ4S7DB+2ULKi7gOntSeabFHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZjU2M2RhLWZhZmMtNDU3MC05ZmQyLWQ1NTY4ODgyNjhmNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVlNjNjYzgtMDc1\nMy00OTA0LWI4MTItYzEwYTk0Yzg1MTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgAZy8ae5VmUwhkwlBDGp9awrY2zKIk+5KRHztdaaYOw5d2UjljFi/A0KEClA\n7ZyiGZPxgrhB8M7xpHp1IjMmzKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1//P6OeevpbYBhVsvW+VdvhSKXIwHwYDVR0j\nBBgwFoAUOWyxDNdbh9Y9DMUua4Hvw+X4SJswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCZ6XOht3aW/NoJAU1NfOxVcLNgfPNXvFMcszD8sMNLUgIhALkS\n9iB5auXAJ5HjQ8dNIbfKkFoFBKaXQzZKnSFRdD5r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZlIiH7Upo1ThnoqG7hMu4UIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2Y1NjNkYS1mYWZjLTQ1NzAtOWZkMi1kNTU2ODg4MjY4ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvmQ4j7Be8qfLi8OGQZux5Y5+uF/eUv9NTOe7y19vb0/q4\nCD/VAxxfWwSCTA49gQUdlkllvoaCE6HHIWBQOpLzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOWyxDNdbh9Y9DMUua4Hvw+X4\nSJswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANLjM8Lpmwtk0Ad8fYMBdvcHeFAzaPfdbp1ff9YsxF3DAiEA2Xr0zJRo\nZ/bVzuNKtWoa9CUC91G4TUcgXVTyW8kB/Bc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAR7RYCqEFFobbxWbyqwf0fR4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVlNjNjYzgtMDc1My00OTA0LWI4MTItYzEwYTk0Yzg1MTI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNGNkOWIxMy03ZmQ4\nLTRiMjgtOGE4MS1iZjk3MTI1MjEwYTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQrXKEHNrrA1422jCXMGWEaqxUTS4+C3ynMzOLIEDYRCqA1B7U9aq0K6vkMRAVb\nFRKmOmT0aMNIB+WtkcoQTSbro3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTX/8/o556+ltgG\nFWy9b5V2+FIpcjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAiB5EfXlBJDk1DWCR6tLUyHebFYAE5t7Lc+t4RBUcDqECIBpt/9em\nUjzld8Nz3Hq5yy6b98C52w+Q6wxpY0hE8OXN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3193", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3193` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXFBARMid436NpCcCFRDuj0+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4MzA1M2M3LWIzMDYtNDU4Ny1iYjczLTI4MjBmY2NiMjllYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRkNmVhNTAtZWE1\nMi00MDA0LWI3M2EtOWRiZmZhMDJkMzgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEjPq+MVYv9qyNY6m4yLlWgZb907sX/tPHrZ6XQHP4lXj8EeYJ8J9kc7YIzfQ\nr1/iIjJWvlDsXnSMu4ooxEh9IKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT4MjlYWp7omGNHBv8A7gq6iBlIBDAfBgNVHSME\nGDAWgBQ2I7y83pa0fSIsPR/8WgLcaXps1TAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA/Qpk3DU3ao6DKD0ysr3En1gtqym2Td\nnoyzaEGUXSFKAiEAwsVYk37SGh9n/ddezh/fklFn2UCCj0RoLmPRsdBpkvI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUvH7AWtsJorgt9QXR3nh2ZyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODMwNTNjNy1iMzA2LTQ1ODctYmI3My0yODIwZmNjYjI5ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrU10VuupXLPF969uwv+qQH/Dzk3t5GADMbutubHQfElvv\nqclKKgj7hQB70+tcyD5+d6l3lIOuQ35gDEu3sN3ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNiO8vN6WtH0iLD0f/FoC3Gl6\nbNUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWEDyAL3AuZv8rRvxnSplww0a99jeST9BAjaFLkQ/+OACIQDprfb7Dsjd\naz9Zif2cLToFMvYaRPTcjyfTmCSetOaL9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAVPrz/BJIk1Oie+TTtVR/Y0rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRkNmVhNTAtZWE1Mi00MDA0LWI3M2EtOWRiZmZhMDJkMzgyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OTA5OTZhNy02Yjg4\nLTQzMjgtOTc4OS01NmRlZjBmNDBjODIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASiKsXaBqaJlOh3fMYvY8+jN4mI1dafrll0Z0aZ8VM2IvBI9Otn3eR8rZ+ot9yr\nSHmin0WueER+hWc0osco9QqSo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4MjlYWp7omGNH\nBv8A7gq6iBlIBDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAmAo2YwaygvdUqqG0SXsWtRNH5ciG5JapX1+lSqZPjO4CIQCaF5rg\n/RVRwQaMUY39CePZMeY9vTfGMrE5cfVJ/zr6cg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3194", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3194` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYwxeLCe+UwTX7mICNxHBQKkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmZmY2MmNkLWE5ZTItNDE3ZS04NWIwLWM4MWYxYmVkYjBmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI0NTczNGItMWM3\nZS00YTQzLWJhNzctZGFlNDIzMjgxZTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2mKA5lD2wxu7ua8XFIzyj7U3JDthf3amc2CK2km+jvdFH4cCrVo3n+e1It3C\nRFxPvvyP6GFRNGcZlMyOvk0McaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi7mi92+LZRw4p975/RjBRpdjVvUwHwYDVR0j\nBBgwFoAU8NtPqzdn86pHLAuzVimBojIr5ScwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDjqmTOLwT6X\nJkWdMHkyBzYUPMJBe2Z7GFpt3GCLfCkuAiEAra7+hCcsGxO0yGORAPrw0AKEayQ3\ndtX6UI1SMNfMwuA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYLAS50PFPcZ9sQveOzBBKRbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZmZmNjJjZC1hOWUyLTQxN2UtODViMC1jODFmMWJlZGIwZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyuHRIE+Y2BJh6CYlM0XyhRuY3by6L0Q2s310WeDcSA0zw\n8ucH+z8CewF+59/wPWde3CCO5x3NZMlUy+CICy3jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8NtPqzdn86pHLAuzVimBojIr\n5ScwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHpN6V2Z1pBTF2bQ87xsKZjwzyJ+6HFRzLtVyYcuqOKQCIC076dn3qIoZ\nDqrVCywi51lGXHddUP20Yan3Up/kjDzq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISARDKNcrqbiuRLWuKN75WGWscMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI0NTczNGItMWM3ZS00YTQzLWJhNzctZGFlNDIzMjgxZTRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMWUyZmNiMC00MGVk\nLTRlNjYtODlkOS1kNDcyM2QxY2NiMjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQG4h/enZKHCQGXbVw4UGUCt611QgWPwofRf6TJVUW1JI0IwDQdIiX3xvKaAYVZ\nkHNkjOTmLSgM2mdMMpF0wE07o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLuaL3b4tlHDin\n3vn9GMFGl2NW9TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBZdVnIAqrFlUM+Hj+12TpEdOdEbNb8y1jp9hAKLDY5rwIgZQtsJDP0\nSwxRgYVDnhlaArq28p5iaC8iujkMxrrXOu4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3195", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3195` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWGlrj4RtYxFHQ9we62F/cijMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0NDVhYmMyLTkwNDItNDUyOC1hY2M2LWVhMDAwYjBmNTM3MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmVhN2VlMzctYTBm\nOS00ZTQzLWFiMDYtYmJjZjU1ZjJlOTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE18tsNxaga5Dv0HTGRhwe0D8CWRxEoNB4S69USkLlSUq7bea2MB0B36bGQyW\nL5ugLksV/LC9iyDYtPUwJJnxOaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU97xmUSlQjW+8aWpDjo2kpm0uCE0wHwYDVR0j\nBBgwFoAUQPTYL9A9TANyR67jYrvqKC/4QuUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIBCXP+BrbSrb\nch7B912xTeJp4qIca2wQkpr8lb0bJtMRAiAVxbLYqsojsWflqa3palo/T+l6dUED\n3N1t5BBXIJJd8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAew+KwUX1gvLrp71pIgzYBRiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDQ1YWJjMi05MDQyLTQ1MjgtYWNjNi1lYTAwMGIwZjUzNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT93mspg6kofzep1lZYrJG/gua8LNuTcIdjwyrqs9U3xGQZ\nhMCl7UOxWVqkHsxVcT0/OTtb5MXKAo7e2qZe6B/ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQPTYL9A9TANyR67jYrvqKC/4\nQuUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNysC/DC1lsosZQofZUX88ppE31sAhi2UEEvimxmEncICIBnH+YF2l0vZ\nf6uzNZn7YcwMSrM9PEG+ksuCKVkIwgXn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAf3VV8i5KhNjL5waXu2umpbbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmVhN2VlMzctYTBmOS00ZTQzLWFiMDYtYmJjZjU1ZjJlOTQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZjUzNzQ0YS04NDRk\nLTQ1MzUtOTRkMy04M2UwZWMzYTA0YjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASv6ZTIew3X+sc69IyU9sC+14B0QR9+OjLRDalNZsiCN8BkGk2nzl0Bo4OzNI4P\n0W9YzpUVVtIP1cZI86H3X5Z3o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3vGZRKVCNb7xp\nakOOjaSmbS4ITTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAhg5oFeYaDqhHLBpFd6dBePEvE0T38exv7jRL7Yu3k6QCIQCpFYiC\nx1/2idxg8ieTc5cYLPM/VPqg55Mfz5NK8Zrhlg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3196", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3196` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISARLDknlvGOmnKr1N1mHQvTulMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmYTY4OWM0LTQwMDAtNGFiYy04NWI3LWRhZDk4NjFiN2U2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU0YjE4YmItNGVi\nMC00NDFlLTg5YTYtZThmN2Q4N2JlNDZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAmpduAE0Gy05QLD3+t/HHwiepHFL0K3ugUmW6ZysgSbbF5cNk4RDB8e3DF13\nZTPB0m66y+Zk1KT+IcOqcEBG9KOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULrzhEFmWfDDQyGzXElllhfiqPt4wHwYDVR0j\nBBgwFoAU9zjcbV4WEDZpxSsWdjxxMC74o9gwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAowUD6yN6p\nRtnd0MseQCZK2/wQgVV1FKB8+m4CCuYw3gIgXPN59gKNCgly78ds7SVG4FgnCobe\nieT2sndF78aJlJc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf+uuKPBoWUWEaK2+hs39zrpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmE2ODljNC00MDAwLTRhYmMtODViNy1kYWQ5ODYxYjdlNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWH4rwS5lsQQ37c6Na7eua6YUNay/uSOuoEDS8yDbWNT5I\nZ9qJch5tAXmwwXsPaw6eJvJ2c5ka1WjpohsO31Heo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9zjcbV4WEDZpxSsWdjxxMC74\no9gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMSPUPRlLjW6O/J05MJLeuFCmyz+z0JwWX8hSOP50+ZkAiA+l+XT00Lu\nvbMrPR2hVKp4mvcq35uzT6wyPyAVjcvY9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAWjKjV1Mz47IPz5kpzAP4lZFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU0YjE4YmItNGViMC00NDFlLTg5YTYtZThmN2Q4N2JlNDZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZTlmMzc1Ny0yNTFi\nLTQ4ZDctOTA1Ny1mYzIwN2RlOWU0YWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQsp0m2ysKHjVUUEkZ+MO8zmZ0c/PEZJQID8goa3kGmDpo0BZBhAVDNkj45OSQQ\n5TuJd29H0PLbM+r2kIxZ+qYVo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQuvOEQWZZ8MNDI\nbNcSWWWF+Ko+3jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBxCJoBVcqwFxPFbW/7/wr49MbHS6lPF1XfNDydeNFOVQIhALL5riT+\nuD8ob9aXEBEytM2uM96cMCLSYamelzcxXV43\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3197", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3197` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAXExCEiviNdlPI26pHCqNJ7cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmYjk1ZjRjLWIxNmYtNDJmNS05YTE4LWQ2OTBhODUzMjYxNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBmMzY3YjItODYw\nNS00MmRiLThiMjktNWEyZjE2N2E0ZWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqrPhWNsflzKZq230O0/N9mR1o5HF7Pk7VUPWGi7pGx80OKzFUzeT+M6qGrg7\nwdDMWDUOCXD67RhNHyik27AxC6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9aKFfgdLADyRUmlEfmZU4dfMyIcwHwYDVR0j\nBBgwFoAUMKnZ6kN5jkfCM2enY1LMYXxDhDUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiB7DwMKcNQr+Q+wMRciN3rMoVMR9z4tK0ab2Ifh6zRtTgIgKETGhX5sf3lb\npijHuLYJ//ENYY2wA3cb/9QOUeddfis=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYgZ/S+BGj7ycWPyyNDyB0lbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmI5NWY0Yy1iMTZmLTQyZjUtOWExOC1kNjkwYTg1MzI2MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ81I9UwfSJffRUcigAbSfmc6lmmcHVR4iU7JLnNIIXF9DY\n/TYoycGeJiDKm3rsttPgYKxm8USW4Xr196CpboOBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMKnZ6kN5jkfCM2enY1LMYXxD\nhDUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMhHO5rCN/RjLsHJadoi0S80JXGy36F+k6rKJIUF9PqQCIB7PJbQmkieK\nq+aA+UI0tjtJLtgtfSkunbuMwIutAWwc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAc/7UrUIajwJorC/DTufx6SlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBmMzY3YjItODYwNS00MmRiLThiMjktNWEyZjE2N2E0ZWM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYjM5NjRjOS01MDli\nLTQ1N2ItYTM0MC1iNjliZGJjNzM4MjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARMrgFNSHuniGrM7+yKvO4xDcfsLFaEKulmQ84oZelVWtK5AjYWmlM7ydAxYZ5N\ntOdl40iknTTcVEM7Pzc3qA9fo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1ooV+B0sAPJFS\naUR+ZlTh18zIhzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAkjxaKr3/R75W+QpbsK//zI2IOeSemM2ewaAjLQ1efZYCIB8zqbhU\nhHt/0h7EyaY87tFo37HiN3TTiDj1Sf+t9wh4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3198", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3198` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAccB0V2eVNPeV0BWLklI8guyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3YzExNzU5LTA3ZjUtNGVmNy04NmIyLTg5MjQ2ZDU4MWJjZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI1NGE3ZWQtODJj\nMi00NDg1LTg1YjgtOWYzMmNjZTEwM2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJrKVmkK7K3F5trrtomWMXU8RcuKFbsEHhjSLgJ2WQcJ0XvkFwzfd23kNed33\n5r4fgSnKCIlPXiAsQjUpsDWm6aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9pHTWzsNuwt2QimAUfn/bPHrXqowHwYDVR0j\nBBgwFoAUa9d/ve+EWQToff3cN4PfHRFYk3QwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAxkwVYifcozxiSD+GJr4TbQFcuevlEDT5h2TDLcBo4ZcCIQDivrJMGtqT\ndzYoUeRdmQFgdVR17FWY0+C+cBPWd8a4Ug==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf8Pfz9OaCq73SNl3s+TvgiRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nN2MxMTc1OS0wN2Y1LTRlZjctODZiMi04OTI0NmQ1ODFiY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQR0FkF6MFdVVAWLeggv23br+aENx8cGZ4jfqu1cACCy+Y\n8O0goL9JUD8JiuLTNj76q96lpWSINbZal8G1Zg4So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa9d/ve+EWQToff3cN4PfHRFY\nk3QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMDGK61eACb2JcacVZraf/dIBfwcNlrscftqWMg3/lVZAiBDPrXdG7sp\nMwaIO36DTqTXkAnymPknRIwXLKcAvBDQDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAZeSi8TWbsaz9VLy7e8mPQ23MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI1NGE3ZWQtODJjMi00NDg1LTg1YjgtOWYzMmNjZTEwM2UzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNTE4NzUwYS1iOWE4\nLTRkNzctOWIwNy1mNWEwNTI3ZDFlYTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS12N4Spyle+2emu22XNiEcJhWNtfFemNC57GdV4vB9hbTy+lrjkxpDlj0nyyX9\nXeOyqgRdB+qhG/Aau3XEdNyyo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT2kdNbOw27C3ZC\nKYBR+f9s8eteqjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA4QfDfOUvNLt2tk4tiulWG2gFMhfNsymH/OtIx+TyW/0CID5mFP9+\njp9jytB1TgPH6IMZ/gSrNkUgtMDa24ZV8nYh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3199", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3199` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAfr9merCUgxLW29Mmo10IEAQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllYmFmOTVlLWMyMjEtNGFjYi05YTMwLTk4MWQ2MTcwNmM2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI2NmU1MGUtYzA3\nZC00MTRjLTlhYjktYTQ4ZjQzZjJhNDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEosrzuADIxJdHAUi6xpAyF+uDCXdjc5s/hvX9iNdMyplPwwAvEpF8KXGf9zmq\n+zQ+tA2tt9WQDSfVw6G+zYnkhaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwkXiRkVQB1YgXVSak4GekWJb6CEwHwYDVR0j\nBBgwFoAUrJzqnyzPyKL45f2BeekRCX4I7OAwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAU\nl/hQztXI/oEat9wvsai3nsu2RgBw7cU0P66W8HqROgIhAPsI8qEUTPfIEm1Zd8NU\nu2jlYxmuI5dv+oAAgJEYvytI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXe7A1QoE74+NluUluIR3IfwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWJhZjk1ZS1jMjIxLTRhY2ItOWEzMC05ODFkNjE3MDZjNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARC32VsPFPz0DZDpTGLZU0TDJILIWPXtbQpm9j4+Vn7HRCc\ndpAFiSpA07zV0gPGtSVSchGbVzp7l+fiuuoXV8PPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrJzqnyzPyKL45f2BeekRCX4I\n7OAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANHbClt1FVoLKTijAjrSTg32xcrtJXSmIAo4cFTpbbw+AiEAy4+Q6X6Y\nhlIsbiGeNI/rHY1RAKb1UD8P8uA+xeHhc4k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAeLGigDlMCBJJ+zB/3GDTX2IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI2NmU1MGUtYzA3ZC00MTRjLTlhYjktYTQ4ZjQzZjJhNDUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMjRhMjAzZi1jYzVj\nLTQ3MzQtOGZhOC00ZGVhZWM1MjlkMjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASjJ5iAfbbMLUN/0V5YcWpgT4rVIqi5KbrSvVtFczahdmDb/tC/24pArKAY+qSv\naVNzchFkZpdXRAnAwtcsxOD/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTCReJGRVAHViBd\nVJqTgZ6RYlvoITAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA2PWVGMLUCDfImYxTNMHsbZaKa75BkEGmz1IJzRj5DB0CIQCcActg\nUGbqaxvt/fd0opCvbB2UxbD26nsjAuFt6CrsOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3200", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3200` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAcsC/YAZ3U+7eA7swNc8/xGyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NmMxZGEwLTAzN2UtNDQ5Mi04YjUyLWRmZWJlYWYwMThiYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzIxOWQzMTktYmM4\nNC00MzllLWJlMjktNmEwYmI1YmY1OTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEceU4UtvS+yX4Ow86h509ZG4J3JPvpQxrgDEfttdGIOekLMSVOw1zGxSybwF1\nJK8kuKJci2uSxnANrffJJwYGQaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUyWvo9U9cbrvOwbZWSj3hjbeGS0wHwYDVR0j\nBBgwFoAUDOZrY/tDZy7F7WSQnCxrQzfJCyswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiB5gifbSJ+6/ow3AixPIr1NCmiNKx8IT3o+pmiQkN+grwIgM6St\nYaioWStl5FBHWgWi/XGgDsls7EQPZHbJMHNxtUs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWgr5/on6Lk12p1L3MUNJcj9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjZjMWRhMC0wMzdlLTQ0OTItOGI1Mi1kZmViZWFmMDE4YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdiAr4z0muobrPZFV5lqk9u4pc/otY+8nvezOm0AFBCAyo\nGepnhqundzkyYjERmiJOV0L0cNOF6kWg/wMslFMko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDOZrY/tDZy7F7WSQnCxrQzfJ\nCyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL98XgnmLTrJdowQYfza8QS2/6tCylIH89OHH+Hdy2pVAiAk0DOmzCHj\nNQJDACsO8hqrWxMO1hl2JnsaNfj/K/qwaQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAbNO1g7Dnr2Epa98zEdW3Y/hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzIxOWQzMTktYmM4NC00MzllLWJlMjktNmEwYmI1YmY1OTY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYTU5NzEwNi1mYjM4\nLTRmM2QtODcxOS1mY2NiZTVmYjdkYWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQAz/q9KOSB3Zuj2ba40BRgsdThRxbL3Dl29s1HsNjpaoIIK5r9SMLtwm30vtKs\ntTezZSsiyDhmYlVboqsAmGGlo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTJa+j1T1xuu87\nBtlZKPeGNt4ZLTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA7q0Bqx+dANAMQwunuWKXn7KHieI1OIijrp4Ifv0aq7ECIE95jqzE\nmbNjghu9iykwOzUFRbpfSTkwC2g9v9oGrCme\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3201", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3201` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARd/CkNVwv95TbnY3wbb/VHOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMjU1ZGQwLWMyYTMtNDExNi1hNmVkLWIxZjg3NDI1YjZhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDViZTliYmUtM2M4\nZC00ZWNhLWFiNTQtODQ0M2E5ZTkzOTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe5euxxPLLrBqATzO17oh/9nTVXYrg36VDRu91wSGcNFJlAPQuDyBKoVwV5US\nhEkdYHyOT3JHkcxSA0CUB1dIoKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNfb78/6ED3gGikeyMKQuvpgCitYwHwYDVR0j\nBBgwFoAUp/gI6VUrb0Emi0sXPIAihZSWel0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiAG3/r9DjNL/kQ/zgYEhRNsa9QD5D6pcChvQNO5ClEN2gIhAK0k\n9AQz4oC1CVazgr97gIttaZFSyx45WQpMOdCivCG3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaOPMsLZrfQYdU3lOJFPy9L5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTI1NWRkMC1jMmEzLTQxMTYtYTZlZC1iMWY4NzQyNWI2YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2Ds1oOSzxY7HcdxhoEYIwRbrPJEokyF5vPMFZSA24OeVw\nBUZVmXTaSPzLWIYQ9ncE0OA9Kk+CoS48/MtuMxKdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp/gI6VUrb0Emi0sXPIAihZSW\nel0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcPtjR6THOyffScTvxB4XfeDIcXI2njw8FDNHxxaIOOQCIGP6cmH70wTg\nCPXECoqckd+Mx0a9VcbiXkxNnM3uqUkS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAUgMnJU/gCoXLnDLKr6YckXcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDViZTliYmUtM2M4ZC00ZWNhLWFiNTQtODQ0M2E5ZTkzOTk3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYjE3ZWI0OS1mNjlm\nLTRjOWMtOWQ3ZC02YTY4MGVlMjRiZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQi88J0ZhcL1kQB2eVbSpOLGuxJdjb5OtezDtixUmvvNlEbkkDOSTSqrw2gugJC\nT4e+ZobJ7XLKnP1hfa1Go3BIo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ19vvz/oQPeAaK\nR7IwpC6+mAKK1jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiAvC+VEfbco3OgW40rZcxYNqJQfJdQUCe7UUuWL0DtQHwIgb4aAwmrk\nSxGamLp7L/FImmy7EMfjxe81EQa0xzQhXW0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3202", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3202` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfbHca46QF4GUDSAFjTsFyb6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3OTI0YmQ1LWY4ZWEtNDMxMi04YzYxLTk2OTlkZWNjYjNlOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ2OTZmNmUtYzIy\nMy00OGQ0LTkwZGItNmNiODJkOGI3MmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzgMP+yd6cDftNNlOn8yShUkdf41Lc6cmj5wEVbJm8lrbAWwllJTZpnHjF/JV\nE3xGwZI5l2rQqevHdJ2CO9bxPqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuueBsME6sMGXaFuIxSRLxf+UpDswHwYDVR0j\nBBgwFoAUNjJelrk+ttYTr5KIYVUpQ3HYcakwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAhazPb5QWgKfL\nxyPTLuqn4+H31On5I7lAh4slGoeJbokCIGEHoix5fNyZLIs8UwxagIie5GvE946e\nTOn9Iy0Pv3Le\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUp7MoH6szRu1DkLVAqIsG49MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzkyNGJkNS1mOGVhLTQzMTItOGM2MS05Njk5ZGVjY2IzZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYnbq+kgpqpI4ZYCopX+h63MnccnnE+kA8ytzmnGwQQy7f\nVCLNeQku/F4XHUIGJagam4OnVjTmnmbic0G1Q/jBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNjJelrk+ttYTr5KIYVUpQ3HY\ncakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNSVTSqYOzd85vFPvvjqrG1hcBzNpqXaHcBu1L/pU00YCIAhj/LNpvxZZ\ndiJYUDEsWU1fprIr6UX8Z2GJDKgjMWey\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISATiZRtJeZ8Vwv1uF1R8Gcb4mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ2OTZmNmUtYzIyMy00OGQ0LTkwZGItNmNiODJkOGI3MmRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNTM5NjhkYi1jMzY4\nLTQ0NGUtYTM0NC1hMTU2MTUyODY3ZTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR/4wok8CTDr3+KWLhg42MjzzTWjpNi5JFm8zKaG00GwwrepPPVFmTb43i7xMW4\nYWSi8wc0zAflBtlDo6EVJWn4o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS654GwwTqwwZdo\nW4jFJEvF/5SkOzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAj3gNazjkwEh2n2YWfNOwEN81dk4B3tYfqNUfF0T0FIgCIAz8i3SU\n38viVdmFthTppR8JQUcgETlb/t9Se6Vbsdee\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3203", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3203` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAQpNvCjPnzS5SLwnidK+a5XAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MmU5NTYzLWRkYTAtNDYxYS1iMDczLTk2MTUyYjcxYjI1NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE0NjYxYWMtYTgz\nZi00NDc1LTg3ODUtMWJkMjhhOTg4ZjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPaa/hipeELIuxkamjY2QWRryzIsYNHYClA+9y9HLSChLdnT4TUr03ggMUeff\nwOFdeusEX8vTlLosohsRJ2wqu6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0fXfQHuOZjcLeMeC58ynhm71IW0wHwYDVR0j\nBBgwFoAUvgFKHxEKz7YgI+U30l6G9+UKGl8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCCfitEp0RXiVMdpiv2DaZHZhLc5HVDCEHyZdZQvfV6dQIhAJ0EHKj0525t\njF2lzIqHjvW4iimS1bVxxrxzQihoNLb+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT4VHmQfgg0Hng9YWy+IS5bjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTJlOTU2My1kZGEwLTQ2MWEtYjA3My05NjE1MmI3MWIyNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQL8R/HO1QpKqu8oiEknehRGVPtFU1C9ApZkPPE74koSWaM\ndTTw582PUyJiPfSuE6eq0KzZR29yBhZD2SoJePVCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvgFKHxEKz7YgI+U30l6G9+UK\nGl8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDg4cmS0icgweEq6GS7PMxddPLLn355rE2PcCTKzzURkCIF3U+J9qkq8P\nVUadDfA/RHWiuPi3/MIaxKm16uU0t+LO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAWmxTk8uwCCOMjmmAeno7RAfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE0NjYxYWMtYTgzZi00NDc1LTg3ODUtMWJkMjhhOTg4ZjcyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZDdhZjdiMC0zODA0\nLTQ2NWYtYThlYi1jNWI2MzU3MjA4NzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQS+zd/nE9nFwuPhYmPBgW+NxlkZxQnqP+In+8ev9nZ3ezxbFlEmY5/osPIx1N/\na/k+BPOiuBVmpPomolPphAN5o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTR9d9Ae45mNwt4\nx4LnzKeGbvUhbTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiB07kbUOOE5LigKBD8KsS7Hwkw4LcXITHq4OdrA66pOpgIgC4meTbHh\nfe1+Z7Rlz0oa3/4fiAumY41V5D/TKiLfVfk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3204", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3204` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfAKkmhJ2e4TFi9R5OboavT3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NjYwYzJkLWI1YjEtNGU2Yy04MjJkLTNjYjQzY2FlZDc1MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgxNWVhNjctZmE0\nZS00ZjY1LWE1MDYtMjBjMTUwNzc1OTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEghK42QfOAP19+aCbxQZXaxLcPXiJk6beXJlmUj06HPQAPj4kBSMfMgvRK50h\nqk+KbaA4rdYa/Gr9kanwEywNMqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZH6zv84HJ4g12uJrgPWwcsSFLuIwHwYDVR0j\nBBgwFoAUMJedA3t3LhZTYVOkayiKsaSJsAUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIH/+mfV3Lo36cTQjoj37HwjH+kMXSbOAnhNq3cjfsuWQAiEAskQ0BIUGU5+O\nnKhoFJ5mrrDciTPPe1zI0b0EyDxBl1g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATLtfmqXYBeeg8O6lRcmhjAIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDY2MGMyZC1iNWIxLTRlNmMtODIyZC0zY2I0M2NhZWQ3NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuxVJaPb1WMZ4SKi/jMs49D9aal5ndxEjG5PG0uLCG5C9V\nx0Eqi/nG4fUpcC3U9sFnlMJo6unEmTKBQhwHV/q3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMJedA3t3LhZTYVOkayiKsaSJ\nsAUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcsEzmV13t4PUSZNIavZQejODI0s7tR679uupjn4CXDECIQCxCtMTKNo9\nXZqi6PL6Dz2HEOztp/wiuLJy4ALB9Y7aCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAeg/3ncgwTOE+ulONRC7sfs6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgxNWVhNjctZmE0ZS00ZjY1LWE1MDYtMjBjMTUwNzc1OTE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0N2U4OTRiNC04NzRm\nLTQ2ZWYtYmNkMS00YWYxNTYxNzcwZmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS5ARrP13twb69p4NXmqebCSlTzqk1R92BVCWs0oRc409gDGGRX+LQFV+TkmIVi\nbjuz+ARGucpefLhAMY+zlnwgo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRkfrO/zgcniDXa\n4muA9bByxIUu4jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBuaM09g/DR672cTqTRY2+AOYFy9ja58B2QZnzubijDEQIgXv3b7j0g\nsMrRbOEbmNxREo9tMjOz42sBN2v/y5Ty9PI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3205", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3205` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAXpoimOxeyXFQYLw9JlgoeTRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyNDc3ZjgwLWZhNjgtNGRjNC04NDY5LTdmMjliNGYwOGQ3ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFlMDA0MTQtMmYy\nZi00YmRkLWIxMDktYjEzY2JmNDk3YTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQBSYfX3EOVP+zrfAuMVpbbnVYT8mXEiu0eG3IHwv1g1d2uTFWmf7XnOwaLO5\nGUtR8YQ+6mH5NPhqiNjnbDMHZaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULO3zJqnlJUd3akfeXQEOKNrmd+8wHwYDVR0j\nBBgwFoAUCT0I1pOR8pRRssnIviVo1jOkNcYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAxFwxcz5elSVkij+HmjbEIUumJ2DsrlCgreYwzu6rQwcCIGJ7RNBeZFG8\nHQ6ICz1d78atkulmYr7h/xDq0j+r8/VL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaM9uhsJjMyPsr16CcnaLpcFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjQ3N2Y4MC1mYTY4LTRkYzQtODQ2OS03ZjI5YjRmMDhkN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYQP5M3363jSOyLVg9qMVvx8uDUwjXjeA7rnhrMIgPEn31\nYQ7h50LT808HqhRcNUhVYzb/nC7LPqpdY0GGBGOBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCT0I1pOR8pRRssnIviVo1jOk\nNcYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgewzOkLQspyWbzfngt9vZ+c8MnJOCVaySCzb+EJ+2btoCIQCn114sJDRJ\ntRSFKGcrVmtLuGTdKsj1S0ru8u1jsFaQBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAby1xFPil5/bfhTFP6WmYum8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFlMDA0MTQtMmYyZi00YmRkLWIxMDktYjEzY2JmNDk3YTE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNzAwNzdiYS0yYjQz\nLTQzMmUtYTNlNS03YTIwMDU0MTdkODEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARAtTKUDNfkmmo7/KMtmnKjaay8r9ZPMAJ8JKuYHQZ+4ZclauAwT49jopuv5HjP\nW/eLO/bKFyT0iUuLGdaTUd4Vo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQs7fMmqeUlR3dq\nR95dAQ4o2uZ37zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBnNTpaBIuXvBZldgN/aInt2ZEOvwP9sL8VgP1F2lE1DQIhAMDR769C\nZxQA0VojpaIyFf6RHQMEGRj5iNlEkIjB05ER\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3206", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3206` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAepX4PGV5qzNQz8JQYC/DrSPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0NjAwZWNkLTRiOTgtNDc2Yi05YzViLWFhMDdjMDAyYWU5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M3ODU5Y2UtODQw\nNy00MTBiLWIyMWQtY2ZmMjAwNGFjMjIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwr1AbiXSqNBioy1YYG1di5ze6JOcRTaf0Ydrrg3YTZ8MlQ14vXWdtTufMip9\nDDNeUr7FM6RgmcDurHdYQGD1AaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQqfQmI5Rv61bYAG6Qg8/QaTaMsgwHwYDVR0j\nBBgwFoAUXHrHpjDEbuhhI1z8Fz3kpLbZw0QwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiB8SnjhcV0ZdLhL3disoX4PjPpwTfHAmudU0b5H4wAr\nNwIgU6eNs+BnfPzD3Ur13rnxgYA5JRlU8WJMQFLhXicnYJo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARoLabHFRHQEfJgzGsVhdXs3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDYwMGVjZC00Yjk4LTQ3NmItOWM1Yi1hYTA3YzAwMmFlOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVO13rYDdrPejFAp72I0fZgPmG/hpRy8HZzgA2EQxppow0\nOx0Wy4W+KM8yt17tuaV7FY5irptNfL7wxxUxv2nzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXHrHpjDEbuhhI1z8Fz3kpLbZ\nw0QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFHw4IDDMMINhQV5ofDhzOAjnyLUluM+nRwshlHEn4fECIDkNvp7I2MUb\nF1dSWmEB057dDNyQUaR1LgxHfVNKUOJ1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAbq1JCQ2rZjmSJ6xhL1aXdeDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M3ODU5Y2UtODQwNy00MTBiLWIyMWQtY2ZmMjAwNGFjMjIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMzMwYWU2OS0xOThk\nLTRkYTEtOTMyNC0zNDk5YTJiZGM5YjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQk5rYxELelbX+suRCckQkYf/k06d2+qF3aV2E6MZjQnTVHkMVGAfDyn640ASka\nCJZFEt/KYpHC2K9HuqzcURjlo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRCp9CYjlG/rVtg\nAbpCDz9BpNoyyDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiArBvIJVmLEcQOWaPfT4MD79Z8rl9nvfg9Y4tcDdMT3/wIgOqoe4yre\n3/Uyaz+HxqaZKiJmA9L3fz7pe9JigX/h7Ak=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3207", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3207` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAd6D58BpFlrBGe8OCrzGD+8KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZmExODM4LWFhM2ItNDcxMC04YWQzLTM4NzE2Zjk3MTFjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJiYjI2ODEtZTY0\nYi00ZmY1LTkxYTQtMjM1ZTcyMmIwMTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKeulSSAKknkdyW20oBjkX1QPno66MRNr9XjPgaSVc01dOWN39uV4a5OM2Mnm\n/N6Fn8D7B+TM1yQcZHNO4hwPn6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxuuiEyQPFb89H9v1dAJYL0TIcncwHwYDVR0j\nBBgwFoAUviTyQEkXC6ycNEmwt/+UDHQrjhEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBr1EkNQQ2n7JqpRW9nA4CLjTMbzLpK7w3IRps5KNQf\nXQIhAJKgF7nEVsaDwOJexiYQ7W5mejboQMa7FtSabH+H0qeg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWyfxRmGoD9fbabGx+/i+6ShMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmZhMTgzOC1hYTNiLTQ3MTAtOGFkMy0zODcxNmY5NzExYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmK0J6y6B61Qpb88+lEQX7e//vcTqNgBKvPJw1OgDs9N0Q\nWX49tWXn78oVlK11VMYh0bW4497Ow5UrxoFuUzJOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUviTyQEkXC6ycNEmwt/+UDHQr\njhEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJvpXcylmj/PahCqRRCkWDNJHLMa+1+A2Yzct8h2QA8MCIHjPysDUNUaC\n9KVuK6zGJ3PrNLwqwKX+IfoNNXYvmQ/3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAdk2R2GQBGwh56Tbt6UKQW9mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJiYjI2ODEtZTY0Yi00ZmY1LTkxYTQtMjM1ZTcyMmIwMTgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMDljZDI3ZS05ZTNh\nLTQ4MjctYWE2Yy02YmRiN2RhOTAxMTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR6ond0WCs9nfcnW/94JjS5ib6m8a5aG+xNLhhFr4D55G+uXL+TD7YGya5dInuE\nV9jaEv0i0ThH/toe8GMmKVxUo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTG66ITJA8Vvz0f\n2/V0AlgvRMhydzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAxgtk4o1VMEZmjmBSZ1pr+Eu7169JCErRR+nkmAgSKfsCIQCQYC1C\n15RL72oOgk94wpoKgf1l5KiwQYPU0W2HtlPp/A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3208", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3208` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAYP3iuICPGEDIid3JU2acfBTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkM2FkYTIwLWZiMDUtNDg2My1hODQ0LTZhYzg1NzIxOWQ5MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRlZWQwY2MtYjgx\nNi00YjY3LWEzYjctZTJmM2FkYjdhM2Q5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEympSa1U1aR8Gz0BhklVncD/NgpofH+Cci0jaxNxQnW+l8mi3UKI1cx2fUFXM\n77v2SrpicPtGqucBLAxRpCTzQ6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8NdC81D68gYOhzh2/3hytQ9IMsIwHwYDVR0j\nBBgwFoAU1GVnQ1xrMFPBjbf32u+Kq2b9/DcwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAqsipjXA7e7KAkZGjXvS/jjQSrJgFkK0EYVKPsngJDCcCIQCy\nEIMfrfcg3RZ789YMD2GKybSdzplkebLotvruifyIaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS+6Bx7fMTgO2Jvlr7c7TuryMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDNhZGEyMC1mYjA1LTQ4NjMtYTg0NC02YWM4NTcyMTlkOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATc//7rNfYSzJkUwKXbZRoQ/EBQo+fB9jW7eTo8kKtkW9T8\nDSnZF7FwpkRpl3i7ky0QMN19RU+xTPKPPpO6kX9Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1GVnQ1xrMFPBjbf32u+Kq2b9\n/DcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK5xNx3NIEe4HGnEPzoA4VSjpPhdEG1+0PFUJOmf5WeFAiEAmXePy8gm\nooUx5/ssXjz/4d/gyOA3yO/4zcfbf4vPVWE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAY9i5QHeygbZNRkjXAJLSA/zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRlZWQwY2MtYjgxNi00YjY3LWEzYjctZTJmM2FkYjdhM2Q5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMzRmMzkzNC1jMmQy\nLTQ4MTAtODc0NS1mMmZmOTIxYzEzMzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQHe4ICCRV/f1YQf2ddDNbbXTn+gFMucBM1ubduYCPM+/zcZyyrSB7yOpaDjzOQ\n9LDe0pr722w1yPVWpJyRHoGMo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTw10LzUPryBg6H\nOHb/eHK1D0gywjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA5JElKw/gd0Q54nfW3KlTVAkLiEQ6T4zkAEVZ6wcK+kwCIQCLdwf1\nsb4eyi7/RWpbMElaCIcKqs4Q+bvwSU5Stee/JQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3209", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3209` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAfi4rHKD82UHllY8FuFhdJCNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjYmM1MjIxLWViZjAtNGI5Mi1hNTQ5LTYxYjY5NTY4M2JhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg4NmJmZTUtMGEw\nNS00OGJlLTk2MTAtNTY0Nzg2YmI5ZGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDbjCqsyeRPLrNsKoor3Lh5e23gYSyPYfGv5U9DZ3ndUpCaVx1VYXZtQrWOI9\n1vRJdj52mJg6bAPwJl/boDYEx6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgl+hSDjB9t5MphPH8+V3ZE3FSKUwHwYDVR0j\nBBgwFoAUL2jmCuqnPKlfJM3qP/pIjGxdO4UwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA3IcLsPn3/YR3ysx1mpbzPtcWvDzMSCHO\n3Y6A6k3xyzUCIQDKvNm0B5PSHsRvnD9mVud6o1LRgGOPAzJQABDBCGMgmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUPp2RTGR+RBBh7TqNQ/qzoUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2JjNTIyMS1lYmYwLTRiOTItYTU0OS02MWI2OTU2ODNiYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcH3H2RrXb7Fg7OiDjvm8H6zWdjzOO0B5MSY5dO3LnC1tr\nHz+Ic2bcfjEeSel5Z3MCncP1ItctQRzmXrj9igA4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL2jmCuqnPKlfJM3qP/pIjGxd\nO4UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgauWct8w6PiYPr5xwNDO+npVXGyeC2zCGuWmKkiQQ+roCIQChTWl4jckD\n+Uj2zMCZo9U0NIH2UZfAAk6ok3GBMBPnjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAXVj6nwIO8/LNQLdbLlc4+O+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg4NmJmZTUtMGEwNS00OGJlLTk2MTAtNTY0Nzg2YmI5ZGMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyODNkMjY1Ni1jYmM2\nLTRiNDAtOTVhNC00NWM4MzYxZTM5MjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQNI50buy2BjLl4ROkESLiLisuaYg1/C08vufav8aCfPmj+R8Pel/GjktFSl+sH\ncxUHHqFcbn6OpF9g7QXepqBxo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSCX6FIOMH23kym\nE8fz5XdkTcVIpTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA4qpoS25VVS67OwSl3TynTzIEkF8j2xggbQBUZRANH6wCIDlEUZMt\njZVVdV0kns1weDRuUWWYG5oHQMoDHlpIE+2a\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3210", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3210` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAS29D9MdsrbTqg+GZIRNKghLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZjYzMDViLTBkMzktNDMyMy1hZTE4LTE2YmQxOWViM2E0MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIxMWVlZDYtNTJj\nZi00MGZjLThmMTktNjY0OTRiYTVhMWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2EUeIk7N9db+ZZDIQpgoNw/n4aHKBFhV+QuptLP2u8M37TF2x4KkQRfJGRIZ\nmBL32PPhfLWzCQ9HqOglIEghd6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEfwIL+ZCayQiV9lft1IlhR/ekGAwHwYDVR0j\nBBgwFoAUvqF60UgmizEcr2n2/L2Ve9fjorkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiArK1C5TVggC1F0mdYEZtdbXsJrt/9gbz1i\nIMDJwIC3WQIhALnlrUbfSnrqwjlayIjlJRh2xHKiVYHxoFhHOdb0HJb3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAagTZm49w8Cut+IRcgkuUqODMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGY2MzA1Yi0wZDM5LTQzMjMtYWUxOC0xNmJkMTllYjNhNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbTPsDJGB7/JCpA6b5u+FSTufU9DmiqXvz2ht50OFEm1CQ\nZgj/MZI3M0GZ4ym87YeQ+NMOo6++Ui8I6KX03XOAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvqF60UgmizEcr2n2/L2Ve9fj\norkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK1GRVJA3Oip3czAg0VF0+VpsoSysaRoVc4Qum4q1cZLAiA7guDyJhEe\n5/tYx5Zmce0OrcPOpjQWubQE0qJxV8H3Jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAbiHwRT6HEry2lZerfzWJ/VnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIxMWVlZDYtNTJjZi00MGZjLThmMTktNjY0OTRiYTVhMWY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyOWEzNWQxNi04NzM4\nLTQ1ZWYtOGMwMi0zNzAwZmEzNjJjZGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQHiF+2fmfh2VgAmJ4dXA3swTQ90Ucwdi+ntpOcOdJvpOfyE1UCKvqca+RiyF37\nq07HPgKFr/9HXGhaueK9jNMCo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQR/Agv5kJrJCJX\n2V+3UiWFH96QYDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAnhLGqh4wUOnT306xnvxFjGGGSqeTmp3RFLZT4DOdEnQCICCnc+av\n+ZQanpAUafj6/Ot/Rn/O3z6937leIvVzqFZ/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3211", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3211` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAfIPe5TwgqIoy/Lz5RSrV/1PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1ZjQyOThmLTZiMDYtNDM2Mi05MDlhLTliN2VmMmJmOTE2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIzZjNhNDEtZDRi\nYy00ZjkyLTlmNzgtZjcxN2YwNGRiMTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+S3zhkAOVF6KCobCP1cN1F7gAnIUMPsp+DKfKyBO2MY7mMPjIK4f0rprPgVo\nOmXH4gl3EJMcaCwvXj6rdtfdjKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUITQHIc8GoTn/HaIU1GWgOlCBPyswHwYDVR0j\nBBgwFoAUD/EhHzCCHJVrPAnkekZDDxXty1cwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAp264/uHxfcBgn\nR64F4gY1V0wQ/df0HIAlreviT76PhgIgKWSb9rSqE8WfHXOx9bd0O2Tdbcn2vMcf\n4oWkdTbRkM4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaurKFWQaQADOVr2ORdF0eCIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNWY0Mjk4Zi02YjA2LTQzNjItOTA5YS05YjdlZjJiZjkxNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPTI4Qg2EwI+4Em62gwX3LSbQtFLLwLvabzexcJ1HxPssC\nsyAjQzPzF7/qyFqpMe3/7nX2hXdkMX5W7Bgp4HhAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD/EhHzCCHJVrPAnkekZDDxXt\ny1cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRq5+g5sCkQB2AggVarkCKmL32eQ8rxI48awSLg42YKMCIQDbPIZ41z70\n3t87ZATKhx27PnYbypZhWNKGehx7nyvQdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAfl967rmn736m3AHI7C+juYHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIzZjNhNDEtZDRiYy00ZjkyLTlmNzgtZjcxN2YwNGRiMTk3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNjE0NTE1MC1kYzJi\nLTQ0Y2YtOTBlNi0yODYxZmQyY2QzZDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQO+rx3nSq7rC2efakyhzJioaLrgDyOKmLAWmlWsCPFrFS5hF8cHjoIOE4sA3NR\nEfLarRA7ZkjUBX6NNr4+y4l7o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQhNAchzwahOf8d\nohTUZaA6UIE/KzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA/tp0xdOnJX1UxJHe7Xn5lKbD/aBJHbfRJc30yDSWCHECIQDQukTc\nbFqB4YRggtc6fhnNpXB8G/1gVriF4FN3zuFFHQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3212", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3212` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQUXEruaFWB0bvCfblRlW4MTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlYjMyMWY5LTFjNDgtNGUwNC1hZTU5LTVhYzBhNzRmNmU0NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY4YjZjODEtYzY0\nOC00Y2ZhLTk2ZTYtYjFhZTI0YTBkYzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtISivJRhuhjo/D8U3Me5BUN86iU/OmbV+HoMI0ngq+aTNAJkw9rghl9mF43Y\n8aX2hkeWOEcIzY1KnQnKbpkubqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfljyMq6VBstcOGLR/Qa3qe/9JGkwHwYDVR0j\nBBgwFoAUDqypZPGa8wqXZiMI7Ltn6tPS3gkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCZrYUSeSNGXNe3MrDN2ouufDKnI/QqxHYcdxiFjGYuwQIgThRacUiC9nHX\nxZ/AZZBt4XgHPoMGtiiqZwMhz5jmTjs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVz/nE2gfcGJbgPNKq/OZ5jUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWIzMjFmOS0xYzQ4LTRlMDQtYWU1OS01YWMwYTc0ZjZlNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQo8njdJqkzLjpYcLMi3R1xF3TfFFpQeBkbMAid4FbMbIvg\n1uQozlXp48tiJxk/x7U300KQujr3xcYQkD3MxBe7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDqypZPGa8wqXZiMI7Ltn6tPS\n3gkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANc0PU/5ZqiHCzPJgXQnQ/naUNJobV1hzPF6JScidPagAiAcfpDfL4Rf\nbG9+MpV7DIbSyISHuq1qzFWsiImQOTV0Sw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAUwhLtkdxirPlMLF9E59SlK2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY4YjZjODEtYzY0OC00Y2ZhLTk2ZTYtYjFhZTI0YTBkYzJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNTdjNWE2Yy1kMGQ4\nLTQ0YjItYTcyMC1jYzE2MzlkNGY5ZmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATILwDCCgOY9oEwkbFDGBwow0cl10QelfUAqhtgv0jLE1f6SV++73dkIrWYDKnG\n9HtGT7C+WB4ofsbxqNI57vEro3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+WPIyrpUGy1w4\nYtH9Brep7/0kaTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBU+DzYpJ3PX1colKQByKfkHtePbjEqMeupx8ebCKB/7wIgXXaSUumA\nSn9iLKoNXvKSMTImCS4/cyAJVJmdMbmQtaI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3213", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3213` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAV0QBRRQTvTwz1FAGONy7xNRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkYThmMzNjLTFhNDktNGFkZi04ZmU0LWIyY2JjZGQzMjk1YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRlYWViODAtNzky\nOC00NWMyLWE2YjgtNGMyZTU3OGI2NGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE68/3FYeYoz8PcT1e3ZwmJMxYOZ8/zE6ZlXgM3koGk/gdMkmoWGhVHyQJEct3\nISXgAxuhBnxTl5vFzd6KIHuTN6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUypcJFwPR7+cpVZx7Y8tw/5A24ukwHwYDVR0j\nBBgwFoAUtiBB6jP6Is71NFzVyYwXlKqoYWswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFE/ajY4592GQOrBwgwpvNSden3AKfqAwa02fhnwbH7KAiEA13NUGcPERewl\nX16NIL680DW2lvIKv4IQ2mmGQx4y0dU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASgObTBqQX7CFJGwrhH3KuopMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGE4ZjMzYy0xYTQ5LTRhZGYtOGZlNC1iMmNiY2RkMzI5NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZiBeyvT87NWz45mLZVWqFgITwxRwaPp/82htytuuDgtdP\nMIcwFSp8FNDPNJGgcg5/K06RadaPGCB3QdpvAXSgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtiBB6jP6Is71NFzVyYwXlKqo\nYWswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANM+VjhGHObxIShPaRs0kQLl+pFTewBMyNeH61QG1v+JAiEAgiPgi7nm\n9lTzYVR1AALbQMoXCuamH/8U6pXRY09Se50=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAYNXZO3VLuYJSFzdSlHnWPDXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRlYWViODAtNzkyOC00NWMyLWE2YjgtNGMyZTU3OGI2NGM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0NDFmMWFiZi1iMzEw\nLTRjMTUtYWJkYi04ZTlmY2Y0MjExYmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARrCrXUVyDicuTmTWybENlGRwOzFBBo1zluqrxVhOR0jIuZf/wT9S4v3n6+Z7wi\nzbg7NKY7iZOAy4Kw79knlKvWo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKlwkXA9Hv5ylV\nnHtjy3D/kDbi6TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA03jurLc8Qno+q2Lxb2YfkzS8zayM6DYg1Wnilbrl0lgCIH25uYFl\n4fZ7hBSV0S2i1fYq+tNDyyVWcLwno8kFr1B8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3214", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3214` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAcMdyMYWiSS1B2+Vegxj9lnrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0YmNlZmQ3LWExZDQtNGU5NS04NmQ5LWQyNGUyNTIzY2E4YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUwNTFiMjYtYmQ5\nYS00N2FiLTg2YzctZWI4NTYzNjIyZTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ZvhnhlwRoBfRNY7vZAunWveL6tJW6Z76fOlN1vujVLmhtYEelSdGmWv0xLK\njBiyvFpB4fxSRZw/1NsAKAjdzqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfdj90rRrG3riOeOTqpNLQJ2n3E8wHwYDVR0j\nBBgwFoAU+ySBhKqPDvnm1vh9RkJT70q6/9swNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiA/uXLn4SrvD5oba/oENrnzMNdfz1Yz9yttErKlrV5FSwIgL2t7jCR7Epyy\noJe6R5yV4Y5tidLlZ5DV73nVXKbCboA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZJLV5g5UqTdKjWNnZinzyWtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGJjZWZkNy1hMWQ0LTRlOTUtODZkOS1kMjRlMjUyM2NhOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZ/4NpsGlo21JC9g2R+8p6dkzmcAT0EFZN1BbosnLO0hub\n1bEzrL9g/+05vHQFYR+j7jUkRvWc7fm0l6xzqie1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+ySBhKqPDvnm1vh9RkJT70q6\n/9swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOTnbqEnBQ9fvMSLIBTgDdRT3vyyNAZydqt9BK1l3UmEAiEAg5plKmCJ\nYcBADVYmz3imOjwcdBlZUYNIX6djg/sYi1o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAY0IaFuPfLbiMwgIIpXVUleEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUwNTFiMjYtYmQ5YS00N2FiLTg2YzctZWI4NTYzNjIyZTFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYjQxNDMzMS02ZGUy\nLTQzMWEtOTZlYi0wZGFhOTAyMDMzNTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ6yJQVmDsMCKQH6/TuoUgY8l88YdKkBgRiLEzmIAppN8B3KdFwrKvbx5pbR1tL\nvt6YeLZnqF1iL38/nx30O+jro3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR92P3StGsbeuI5\n45Oqk0tAnafcTzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBzHYAK8PCXDstxjWJqkMpzvhrAIY3TBJD2E6RvkrEuFQIgNrDeOxjX\nDMyibCMNlPy9IlXdPf7tCUmX2zFcIlWODaE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3215", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3215` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAfabxPPxcJec2rAD7miJGkrDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzZjFjZGQ3LWY5MDAtNGFmNy04MDI1LWE3NjdjYjU2YjI2YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg0MmEyODMtZjFh\nMS00ZWQ5LTg3ZjQtYzYyNGE5ODU0MzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX3TWz24gy94nVxoTY8pm8tIMryvAplLD59lwtk0lcmT5HG/uxT7qPOzcTFR+\nNvHv9SScpkK1Ja82NqVx8NfI8qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYzGAO6vvuAz59LgBz1qYHx+/k68wHwYDVR0j\nBBgwFoAU+j+RSkc03eMMsp+YwrCXyX4hxm4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiB1m3U9ufikSBcUtW429rWKX1E+jp6YC6QCyD/Jkbwp\neAIgbFpVdBeZfoP+0cST1hQ+CoiHRpUguA88S2mj3lg2ENA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT19Cw8oUckWOBXOEbCLWDD8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2YxY2RkNy1mOTAwLTRhZjctODAyNS1hNzY3Y2I1NmIyNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdReKtR1FXIv4TxYK3RFWgURrLXfvbVUux3iYz43VZMLz4\nqY6ZYT9F8XX8nWGVyhhyAGiGjb8Y25X3vTA+lx5Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+j+RSkc03eMMsp+YwrCXyX4h\nxm4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKGxZ4mWRFSCd3jy0ScZSSAVd3hrsOR5e81nWXhMubPcCICZljImgFIv0\nufAyPoIiV5DZxVe0r4G/G39pD8pWJ+de\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAf5C3x2vEy8J5oYKw/4Kr6xgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg0MmEyODMtZjFhMS00ZWQ5LTg3ZjQtYzYyNGE5ODU0MzlkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MjljMWE5My0zODEy\nLTQ1NDQtYThlMi02ZWY1Y2NjMmIxZmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASLgiEZ37shhAOKWDYf8kHp+G47JIKu8umM3WaFe9ChB7C1mA+Hsa3lBMagDycP\n/tW3GcDmveP/K4mpFW3+3bcto3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRjMYA7q++4DPn0\nuAHPWpgfH7+TrzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBOnxsi0aqKtV54vaRPdr5wYEjNFvd2i/dcZTOEV4cMSgIgK+DwQGXw\n5MReSSDYB6LeFNAz4eo9jtYTDYxlu7Kp+yE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3216", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3216` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYz472DZk7bwBFDqpWUlYagSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0OGYxNGFkLTFiNjMtNDM0Yi04OGU5LWJjNDYzZjBiNDRkODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkzMzRjZmUtZDAy\nOS00OWU3LWI2ODAtMmQwNmFjNzZiZjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESi8ypu1WEgPRlhSZ0feUai+TDc1DSQ7BWmV2Oq9CZ9VDnRW3utNYzhJvOwS8\n5beFvlLVeqljDcq9BCcc/9HbXaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Hl+4IolbBsgt20IxkY+6fj7R/wwHwYDVR0j\nBBgwFoAU3INeM0+g1ZxPhog0fGHTvjQY1E0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBMOqD1lQvVWzZkBjblsK++nm8AGEfCZ2zhSTquwF7B\nKwIhANsfG6WukRbxBOo40uRwlzr0UkKQD/Bzy8wmdGtCgAXS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc+lCTlzOho0NHp8kwGKWELgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDhmMTRhZC0xYjYzLTQzNGItODhlOS1iYzQ2M2YwYjQ0ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKZNZfqzp1zrZbAA0MlF5jiPuTX19q09ip5Io4/Fj4RMoM\nCDzEj61SkDi78fcCJEjCx634MxXnNdbBLobU//VKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3INeM0+g1ZxPhog0fGHTvjQY\n1E0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFstZM7njCUVZbfSgTHqeclbjJu2x4co0l8egFmf91RoCIGtaJlDXbraR\nqk9s5qzoUawuNrAiIgpiT05nof9bEtAp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAc8XvzORvEmc3neu8r9emgb8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkzMzRjZmUtZDAyOS00OWU3LWI2ODAtMmQwNmFjNzZiZjU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZTQxMGQ3YS0yZjNl\nLTQzY2UtYmE4MC04OWJlMzFiYmQzMGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATRiHuR/gSM5Y4KTXWNsidstJLOSyj3Gy5bxZ4PiBui+CrDp7+rWxh53wq0Rwel\njMpbnZDqXNvLWEc9u+VX3Pp0o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT0eX7giiVsGyC3\nbQjGRj7p+PtH/DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBnRb2Ii3mRBK8N0mTjLtN3C1NyB2bPkZ2NURiNNMexjQIgLqJUw5Zh\nYjyoE0j8ypfmyXiGESHQ5AZMuWvEjl2bQzM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3217", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3217` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAUSxrm6rMF+qUWqZ5+RWO2EJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExOTIzMjU1LWE1NjUtNDZlOC05NGE3LTMxMGU5NDA5OGNkNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY1MGU0ZGMtMjc1\nYS00ZmNmLThiNzAtODQ0ZTFkNGNkYzc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE30UxGd63HAHFBYiBUKDpiUpY5cc4EawJ+y18pOX/lraru1DrePps/0dRN1n/\nLJ8t8d/1SsiOROvz8stPFgfP6qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNsYx6rOqqW0Ma8REViIdl+dWURQwHwYDVR0j\nBBgwFoAUfXuIS/ligZcE98TRIrZ1jA6YYgMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAVoLiDRJruj94146PfJ08AGe5gvBu0U0xZscyYd9CLGgIgcHuf\nyr7azAokC+2nIJcmw7T7txnDLJblSDK/sCxRqQM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdiAXk7ykrx12to6aCXU9IhRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTkyMzI1NS1hNTY1LTQ2ZTgtOTRhNy0zMTBlOTQwOThjZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrRuQik1ix/Bi09mzXxkV15gtDincU6lBZwCyLiSWAchQS\nIvzMnj+gy1qYEIvTPkVluQZVO+COlgZ2BupfIxixo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfXuIS/ligZcE98TRIrZ1jA6Y\nYgMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIUV2EcM2qlquY0TzWD8ddn8LYmzGq28jlIG+KxIF9S8CIQChDTk9Rzl8\nT/LXvk4/iuluc9Ad3eTZSISUWzj1Y+Dz4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAVo38imhha/9XiYjkdGQuyfGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY1MGU0ZGMtMjc1YS00ZmNmLThiNzAtODQ0ZTFkNGNkYzc0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyY2MyOTM1YS04ZDRl\nLTRlNWUtOGZkMy04Yzg4NGU5OTkxODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATfETgd8yAkL1bfyoXOHtv0QJJAZPTCx9VP9jvXxWS2QkjdrHpw9HhmkIAARylt\nIjuS08q0vltCvATjbNazo/A4o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ2xjHqs6qpbQxr\nxERWIh2X51ZRFDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBKF08Sv2NLpnvcPpXbRDj/KLu5jc1OjAkSrD7RT1/7HwIhAPS0jz7T\nc4oriTyl7FJMSCyopONGePbJkAFO45lKSRkS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3218", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3218` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAefbFeT0bMmv21OLJHgd14M1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2NWIzYTYyLTM5YTEtNGNlNi04NjMyLTQ2MTQzMzQ4MWM1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZhOWY0YjItMWQ2\nOS00ZWUyLWE5ZTQtY2FkOTM2MWQ0OGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh+oF/D1jNrLoUGG/o+t5e1Lk6Y6s+ZiK9bemBmF09ZBfambK0Zr4wDCe9NFS\nJL+iRZhDGl5ThvAMD3jOdS8n7qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuQLceDdu/5CbJSg50scpJja895cwHwYDVR0j\nBBgwFoAUM71VZbVmag4XpGlFLJuOttgUgrIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAp3SwBd/GynCoTv7k85MqnYF5kQPHy4UF\ndODnt9LPU8ACIQD2CEFekJWfLv5qpqQNqEUIisjaGOp3Y+QsaAXEGjq01g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW1Dkoxk91Jc1VW1jvVjK8JuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjViM2E2Mi0zOWExLTRjZTYtODYzMi00NjE0MzM0ODFjNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfQYl3vYyA7DEjdp3YdoPYILEhE7s8g1FP91JMxKE6unkk\nQTItZUzhIKZ2QpXPtGP7usx4LtwPAkwGO+x4pUpmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM71VZbVmag4XpGlFLJuOttgU\ngrIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKZ1bDLXAf4YwpTVWeFkttoX0T+NIraMvkHIC+U9MNq9AiAbps5iso06\nljjPV3leJRSsIsS8PwqY2Q2VRBTrQqkPEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAUK4Amp2hhaaB8Xp6mGWH/K1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZhOWY0YjItMWQ2OS00ZWUyLWE5ZTQtY2FkOTM2MWQ0OGQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYzVlNjQ0ZS04MzUx\nLTQxZmEtOGU4Ny0xM2U5MTJiMjQxNzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARhHWMY/JeywdGMJ+p67nKFzUoUB5eNHTeb7Wo8HfRw2BvGTfjSid2gAu/nNCHq\nKQvPLOA/p/QBAwCg/Zx+DZaOo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5Atx4N27/kJsl\nKDnSxykmNrz3lzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA7ky6xLpK1/sdM10xIRH+sbxREtLZqk3Q5FpdD9xakF8CIQCM70qV\nlqhmR6kETH4aCT5x1shLUvlwkWszS4X/4MK24g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3219", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3219` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAUqRn821h9fvuVZdn09i3+a5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzYjJiMGJhLWY4OTUtNDgzMy04ZTRjLWYyOTk1OTdjMWFjNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFmNGY3NWUtNDc1\nMi00Y2RmLWJkMTItMWNhNmVhNjZmOTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuZdmmVRKPsGmhvFG6ijniTYwk6kNVoUTGmy+48nckGK1s4K87C36X2XcmNCm\n4+ibw9Jwj8LQRmcCCi1z67U4bKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqz/wAFthQPNGp4oqKAza17bdJ3cwHwYDVR0j\nBBgwFoAUjGbZQ/NjdJmO8Q1Nst0A0SX4ZdAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAaoVvXOw9iUEqDQ/S7g08CQV1UMYmiAjr9\np3xdhtOgswIhAPXVYtRXtm+Cj4DScvQxMPwsL64+Dk3jNWFL9sM6abAi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdlL3HlRdkNzLSDCOnI54w24MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2IyYjBiYS1mODk1LTQ4MzMtOGU0Yy1mMjk5NTk3YzFhYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGWhtKxvW/OfBVf2OXQsECMHQTWQi+uyqqnl5zVbPRNFpO\nLIeRwSN2NOi3WkM7m2u7lUE67dxTnH65wYsS/iawo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjGbZQ/NjdJmO8Q1Nst0A0SX4\nZdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDLV5hZfwG1152nSNeWeQP6u3PAvTWMC591v1DIMoDSgCIBAX/qRnrKe6\nSHn6yE1RoQfkxyNe27DJN/xs+1gZwVEU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAcBMWzXYLtlEWMuqyjVp1HmNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFmNGY3NWUtNDc1Mi00Y2RmLWJkMTItMWNhNmVhNjZmOTY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YTBlODQwOS1jNGZj\nLTRjNDUtYmU1Ni1kY2FkMjc1ZjdlYTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARAieoEf5CJogigvcIj/l5Z4Wg653vfV73/Dry4VfuHZDcfv/xUhDwJx6Bnxr7Z\nK1Zlm72IaNxwwXAvza8NOZ20o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSrP/AAW2FA80an\niiooDNrXtt0ndzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAqGczQuGYOlyrUdiE667WW4Xfn2P9v+bF3wx/7e8HhacCIQCN8eW/\nYaXWkx/6YP2ebGqKyNqCG686ki16MTRYz4S1zQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3220", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3220` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdWHeSNWDK757K42sSxD1nkdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MTQ5MDc2LTkyYjctNGRmZC1hMzY1LTBmMGYxZWY2NGMwNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY0NGZkNTYtNGE3\nOS00ZDRmLWJhNjYtZDU5ZDNjYWNmZmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9VTlUcwyqA5uHEknj5myRaUqDtuaeTPeh8ee4espjCOomZ+Ap7iaM9xWWOzl\nAcTry4lmiJ1TctEh8JDQzKjER6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2hXvCcn9wGlXD6GFcZC9vO4VxfYwHwYDVR0j\nBBgwFoAU3B732nkkUhh2b8GhZR0VEBKcLJUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEvQEMc8Lgvq5I+GK+lbdZXEXVKv\n70vO7Zd2iJPnphqDAiEAvVDcJ6CJwKieV/T9DmR9AcWGHHJuyZ6hfdAG5FvT8CM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVjcEA4AilcJVnOYRU0iMjU0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDE0OTA3Ni05MmI3LTRkZmQtYTM2NS0wZjBmMWVmNjRjMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGdn+YCDKkH5BBMsI3e/Aa0RczXkjkZWPrH8vFCNKV/N1e\ncd2xF9xwzKDkLPhd4inMkcw77/XQDT4xoFp6DxRvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3B732nkkUhh2b8GhZR0VEBKc\nLJUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPszNHGFRkmydhg8W5jsEceLU4vy1lA8rXYwdnY9Th10CIGlw6TPIDO0n\nleEEnYXpvBux24xVKgypVlMY6bEsG4dM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAXLJ0OR2XRkCgrhGgG2hhEVIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY0NGZkNTYtNGE3OS00ZDRmLWJhNjYtZDU5ZDNjYWNmZmFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNzJjZjBhZC0yMTU0\nLTQ2N2YtOTU4ZC0zMzc4NTNhMDBjODkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ1PsGmva8VFkKEkH10rMk5tFU6zpBxo5AUGwVVFeXcOSuO0UajsbczFiMPXtIS\nSNeTjmmiOV8pI+TT31bhibw1o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTaFe8Jyf3AaVcP\noYVxkL287hXF9jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAW/jGjm8El7zZzZtr6dxkRGt7ALEzXcbG9NKQOMmn7+QIhAMfFrEML\nDMnEjOf4PeM9XO+3Uw+/1mU1lBErMkbunhLH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3221", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3221` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAcFZsSphU2ZIIbACY7W6i7kaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyMTY2NmVhLThhMTItNDBjOC04ZDdhLTdkNzJkNTE5Y2YyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAxZTYwZjItYTM5\nZi00MDdmLWEwMzMtMjNhMWEyYjZhMjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE38/fFSd0GrXvJHd4QIVb/SNexqBg8W9na8gcUBnyQTscxpIq71M7YT37tgeO\n8fqxQXpLuDXZd2nxXFsB7uFgsKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6BRSWe4ksCBAZePARmnTAXYtrEowHwYDVR0j\nBBgwFoAUvqtALjKtOFuSy1lWyq1j17BmjxIwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgNwtonj51\n5WA9xtHlXEk3bZHRNL/krbQARh01tm+GGaUCIGumRfLoEhP5CLBGC3Q6WSjq4mXV\ndDLGQJiBUCQlbPVB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUMPehBXmzbu2t0Auy/5SJT6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjE2NjZlYS04YTEyLTQwYzgtOGQ3YS03ZDcyZDUxOWNmMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQV/xr+KfyFXvc5sVgQZZWT9N4Hny84aWkrJaIfrO/7qCwk\nt+l2xws6PrOTnJkT7P3md42m3+qHm9ucUzDIlftfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvqtALjKtOFuSy1lWyq1j17Bm\njxIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIaU7mitFQf35tgXnYD2NP6cGhZKuropoHZkoWMSGTsnAiAWj5JlogQQ\nhuPlG7NVVumU71/5QQF3D8Kz+MpzwISwRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAWb+Sx5qZeiDhX3J38sE5QVQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAxZTYwZjItYTM5Zi00MDdmLWEwMzMtMjNhMWEyYjZhMjVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZjg2MGI1OC1lZDhl\nLTQyOTItYTNlZS05ZmNlZTc3OTlhOGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASW5vZiuPE8mTfY6MNCVmL9N6jW/JS0n5s0Rc86BqlqolBhqecqH6L7xZd6rllf\nTDaB9eCshkAD9IBMnDUwtzdTo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToFFJZ7iSwIEBl\n48BGadMBdi2sSjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiAyubzAoSH10CHLQi/hWQIEEOep6fw7ViRieSel6pr0LgIgX0qJ39AA\nIseU7m5rqW1z5QyvQgx1MO/8kTeG47B1Pew=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3222", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3222` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISASonQmF9Hir7GINj2IqvNtlzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2M2FiNDMyLWI3MDEtNDk1Yi05MDYyLTRhMTNhZDM5M2ExODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg2ZWY5NzMtYTk4\nMi00MjQzLWE1ZmMtMGMzN2IxZjk4ZGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhsfNXq64soY/ZMv3T3P7QxyAh+RCyli01pqmkamHO4gCT4k7hqyWoa7AsZL9\n2Ee3xJhRLWnnCWX72c4DbheNvqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBEhVsFrTbQAdog2OMh8a/O9vHbkwHwYDVR0j\nBBgwFoAUwugzD2tItVoS8Vg/22N4BvBFJXQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPv1JW6Z\nPNsVjB3XEmAFeVFKcssGnyLQkOHtY0SB8Ob4AiEAiKp1YVCeL1c8G5mVRF/Mry+L\na+JRdnkqxOqyVloQqJU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbzg0bflP9p03G4wiE15+SPUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjNhYjQzMi1iNzAxLTQ5NWItOTA2Mi00YTEzYWQzOTNhMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRLpnpZMmEfTLndiodpLPwr14rMN0e+/8r5pRZubDGGobh\nqzoBYLqIh/sEA6eKWvOgHCSy5dpicrkviRKXLH0Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwugzD2tItVoS8Vg/22N4BvBF\nJXQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGAnFdmKSK+4wOrX94O8IRW3XrRO07dtCuqmNDh86JJACIQC6O9ooTRJm\naEBUmS3y87HU+NVKtWmMf8yJBLWLNoecnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAb4iWevODy6TEvXGKGjs6o1wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg2ZWY5NzMtYTk4Mi00MjQzLWE1ZmMtMGMzN2IxZjk4ZGFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMTA2Y2UyNi1lZWYz\nLTQyYTEtODI0Mi1jZTkyN2QwYjdhZTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATQbWxab6Xi0ma1ptHwgMp4ZTjpUHbQ/jY8cYjVoUqZzZfgaebMVWKuhWFPm+Rd\ndlX2rlJUM27q11x7s0fIM4wTo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQESFWwWtNtAB2i\nDY4yHxr8728duTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAw0EX2hcKZEaIusHpllrya4m5Bg8O5XJ7qAM5qWAJsXACIQDaWvVE\nmeyyQXe9S5YKB/Jxz9gXPTHc4up1B0cguI66Vg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3223", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3223` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAS+EhpdkpTBe9noNKhgztEOsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlYWI2NDhkLWVkN2YtNGI3MS05ZmE3LWJmNjI4MjYxZjU4OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJlMjZjMTAtMThl\nOS00OWZlLTgxNDctYjBhZDhlZWRhMDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEejFeyFi1oPJtPkmYUz7o01NrReh77mycD1mHn8aRo5eCsV4DM+Oh1eceOQrj\nvbuJYNXkI1YojybjLCM79lrBUKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnufGncq+HhSCTatBm+PTWheGUlIwHwYDVR0j\nBBgwFoAU6rvC4akNhD6hL2+pxC8zhcmQ2SYwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCHyrxaqQY\nRnjPWjEsJErxZMir6x1BbK5I/CXox+sS330CIQC/chrZjH4aBBFnhrc+WDHeZWyp\nWg03j5CZoidYRjCwwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVl31EwZ8WMdup+ocHujm9k9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWFiNjQ4ZC1lZDdmLTRiNzEtOWZhNy1iZjYyODI2MWY1ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqXmlVSNux+maP7nenVXALr6a/7wALmZl8YwaVGxmHfohZ\nD9UKr3epPmb+/ruMJ8MCXCOHU9J6KqJRm1NZlMuko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6rvC4akNhD6hL2+pxC8zhcmQ\n2SYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPsCRpcpKn19Ig9UjmOmv0fPN3k+c0aKRgKo6cEkWahFAiEAoBjcxohK\nmiplcCPb+xofAu6EtDg2sIKWaAKhQspdkD8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAfPDVoPcjdbBaSfzjk/7JWfPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJlMjZjMTAtMThlOS00OWZlLTgxNDctYjBhZDhlZWRhMDhhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MGVmNzhhYS04MGQ4\nLTQ2MTYtOTQ1Yy1lOThiZmM4M2FiZjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARjfukI2xAuOvq8ezxm9CHK3ZE6lGAW7D0z+I87bFwm7iVzt8TH6/dqVjO5dXtl\n/16HsWwGNvxCmTV5AS4PlVZJo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSe58adyr4eFIJN\nq0Gb49NaF4ZSUjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAqpdPaJJ2E3TGeTpid2rvA1OADaxAWn5cIb/hDH7YDVgIhAIyh2jtH\njpCy/xqSBAcu5xNQEjp8/aeS0EHK5cyLyQXm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3224", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3224` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAZIhShxGDp2ssjI70xv4+qxdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MGI2NjNiLTI4ZjItNDlhMS1hNjhiLTc3NDkxZTFlMTU5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIzMzg4MmEtM2Q4\nZC00YWY1LWJjMzUtMTJmYWRlYjUyOTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERjSLT/yEDRXQfRYC2w0qb5PwlKYSwwdKOT/jeevzvmP5w9kD8fcJWe7u0BU9\nedBd8aOKq96NJznyLAKdG534faOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzJffYvOsoBBJePDppWnIHPCAseswHwYDVR0j\nBBgwFoAU9azGjpEdB77HqR27haySSLxAq2wwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDOcjOj4Gy35MvRaCXm87yP/FMy+gwS62OeI7nTyzyDYQIhAPfXy/QY\nhbsWR1fvl8TdHPNuhXrPVIziZa6D1QfBJkXZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWfHHhki7zjYOy4R3E6J8eBDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjBiNjYzYi0yOGYyLTQ5YTEtYTY4Yi03NzQ5MWUxZTE1OTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+nM7uvmQCgIII48T/LPeQqJLzL6uiimqqTF88zvNZEZbF\nfyBNj47F5r6tTn98vdta7vWwU/I+ThEWQHFtjrUSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9azGjpEdB77HqR27haySSLxA\nq2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPIR1tlFn+g4BYbZ4MQYWT7Z1FHvxvFl+ZkXLqhfjBtHAiAVX4caCKam\neioHoMQHjrGMmegaypjL67PY9gpbQMsQYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAXzIdt0yRREkZkxCtmFRH4wRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIzMzg4MmEtM2Q4ZC00YWY1LWJjMzUtMTJmYWRlYjUyOTE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlODliNTA3OC05MmI1\nLTQ4ZTAtYTM4OS0xNWM3MzRhOTYyMGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ5GkUhZyuPnovQkGO1/NsJF1Te7LpcZVd9yZi4qIhc9sebuGnnmb7qIhOHVsmu\n/nfQslpu6zLsXIb2wG6CIiNlo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMl99i86ygEEl4\n8Omlacgc8ICx6zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA+n9DISMA5KG21FrJvalIuXvmoPr6YjX6xtuDXFhtm0oCIQDaMPoU\nnA75n/Ivfz7KUZYdGu3JOY7B7HxYo6oifSu/Dg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3225", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3225` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAZ5Br6BjK8/8IrPp2s/D+kY/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4ZWJjNjllLWM4YzgtNDJhNy1iYzc4LTg2ZjE0NjBlYWUyYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzEyNTNkZWMtMzZl\nNy00NmVmLTk2N2QtZmFhNzBmOWRiNDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9XsYasuTYOOJXnXNqtSebws3KHmuwqRe49tF5pTCwn5f3o3C+s2J7t0xsi23\nm7Yp6a9litf89Ehk4Bwy/QSl16OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU63/XxEkVTu4rvgkAXRz/GbACJUgwHwYDVR0j\nBBgwFoAUJn+Gq15TAzL7kE9Kn+7Ffci72qkwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDQoyiA75mkURI8r/jX/nJhXQDRJoDzQrpBR6C7v/eomQIhAMqaO5Mp\nWPBYbMKDEj6WjNjBQU0LAxTr8LTEjZtsNTLa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfrXQak0GljD8eHTOgRw9QgTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGViYzY5ZS1jOGM4LTQyYTctYmM3OC04NmYxNDYwZWFlMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQawZKAOuiag4Ai5K8KjJVkS8HZDVT+cq6CK3soaZQ319F\n+ZVvX2RMt6GAAdRMKOE9jlAP9ubMk5oc2ax0SIfAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJn+Gq15TAzL7kE9Kn+7Ffci7\n2qkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ5uRa8Uk6KVTLZBA23TDuDd9AcXaiT2q5OAYSXf/vmECIQDGAL5qP6s8\nxK25Se9qkCW8dkpynkRKiwqmqiXQCZlQ3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAQU+NIX2KqaEl89/NEPoHmKiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzEyNTNkZWMtMzZlNy00NmVmLTk2N2QtZmFhNzBmOWRiNDY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMWI0YmZlNy1mMDIy\nLTQzMmUtOTE4My1mOWFmYmViMTNmN2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATdUnzhEHwNTD2x9qqHsUn6oWqQhSrP4GKCD3H7P7fmOOj+5Ke6GE6FAHyq+bUh\n+wd63jfq08efsqjNBbLkOxIXo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTrf9fESRVO7iu+\nCQBdHP8ZsAIlSDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiB9U8kCDvsSS+i3TmXPz7nlNWo4E9dvdJezVWbS5hEo9wIhAMX/AHR8\nTJc/vo/5k00cyeeB7QDi+GEileaWwktjlz0I\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3226", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3226` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAZQeIM/YCEmlr40uVXX8y3reMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZmE3NjlmLWU4YzEtNDVhZS1iOTNmLTlkNWMwMDZkOTIzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA1ODBiZDEtYTdl\nYy00NDY4LWFiZTUtMWYyOGQwZGVkYTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVs8qebsudLZp4qsaEJ69yEYaFBwlWFd3QoBAGo1VhuHXUIFXbY2i/IVnAVpp\nzrmH9to8TpY1m8iFSO5eUECntKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS2vn9VYs7/cuiDMPZu68NM7GW2gwHwYDVR0j\nBBgwFoAUwFlWDgE3Jc1G6zkey5M+xFYzOTAwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQDtnCp9PaP8kun+X8xXhNPtT/yFE2umWsb4h820XwvwVQIhALhgKOsQ0WxWUVVP\n0jThFBLyWSYWnoOn9zHFu7Gl0/B6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfklpSdvpxnsABS2RCZok7mJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWZhNzY5Zi1lOGMxLTQ1YWUtYjkzZi05ZDVjMDA2ZDkyMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKgu7Hnoj1tDxa830X0eFS1TdkekGOXFGpY6MKFNHJzolG\n50H9wALgVxc/63h9FF04u/Nt1SyOLfq21tVsSJZdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwFlWDgE3Jc1G6zkey5M+xFYz\nOTAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLk475MOhZ+Le8j8PfRSVaohOa6KOTcAqIA+ga3xyQOMCIQDM4lTN6kt3\n8c1MHuClz8q4NWI03+IlzpzDk6UMhN4b+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAfP1YsX7ZLE7JJ6iBsirGggYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA1ODBiZDEtYTdlYy00NDY4LWFiZTUtMWYyOGQwZGVkYTUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYjIxMzI2MC0zOWM0\nLTQ3YzMtYWM4MC0zMDcxNmY0ZGMzNzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATdirw05x8m69kkotp+IWh0AbCcP7C1xH7cyRdqbFPMonpuhy/zmnMIBEEjfXfn\n8m2EwpZ8dr+wfm5BO47o2iiFo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRLa+f1Vizv9y6I\nMw9m7rw0zsZbaDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAsB5btLqDpSJLNxPOsv8m7GGe9OsSDoDbuByuCv++7GMCIQDh8YAa\n9CBK4MLszIVDe9HvO3CY0Cp2oQC59qGRTTcR0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3227", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3227` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUcSeVo5NzTkuL4gTh+LQNI6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhMTlmNDY3LWUwOTItNGM5MS1iOTk2LTdjY2IzYjlmNzQ1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FhZWJhNzctMTkx\nNi00YzM3LTkwMjYtZTU0NGE1NmY5NzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENOLZCEk5i4IYIRTYr6mXSCqo3soVPW+kcg7WoMoDrNZDpalDICMdGEpRtYUm\nWPevO+etZx5QC5v3l3RRDZECaqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmyc20mDvnDj33F7jofFGJwiSVlowHwYDVR0j\nBBgwFoAUWkz15Wy/0HBec3sx4n3KviuffrEwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIEDnuW8ntNqQeofUyv1g9dwRWiTEGB0ocGDxG8x4UNAWAiEA\nlXH8zCG57JJxXtPsGNueIroO3x4Vxhhfcm/12MIfaoA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfbLQ66J2VcZmJKJ5LqB9je7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTE5ZjQ2Ny1lMDkyLTRjOTEtYjk5Ni03Y2NiM2I5Zjc0NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThSfKMTdOalXpUYDHq1ZWgt52zGQ+v/ozjn2FzE3e+GK7g\nC+ae0E/U8S6oVDY/8nye+3GIS4JyLCWDGV+Q9G1xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWkz15Wy/0HBec3sx4n3Kviuf\nfrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANIOIk2FhcEhXklRws35KATpC7SVvVxh91ge2p9DdxxTAiEAgl24JIaK\nMGYiOYtgtnDmKe8JI4XfTep5rsBsKOF38OI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAeej9c0zW8AFKNi9dVSyP88KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FhZWJhNzctMTkxNi00YzM3LTkwMjYtZTU0NGE1NmY5NzkzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3Y2U5MDRjYy00N2U2\nLTRjYTItODkxYy1jODQ5MzFlNzY1NTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARI069PAhmbHO7SiY+SF/7YQsgETgMo35Df17ICGbkbWvNmU1pNK9f1xDI0JSpJ\nJQsbxnZyoo4ULe9SCAb7xd1uo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSbJzbSYO+cOPfc\nXuOh8UYnCJJWWjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBsLGQyFRJ5b6TWwJJLZcYLowam0G6tSADdkHvbUNu+/QIgdAp6vkUi\nvw93Wh29LaRxipWO8WgGDkI3120J+iIJ5J8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3228", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3228` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISATqk5h5CKAMYRGzfV36Lm1XsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczN2E4OGFhLWZmNmUtNGM4Mi1hNGJhLWNjZWQ2ZTI3N2ZlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUyYjVkODEtZGY4\nOC00Y2RkLWExZjUtNzM3NTIzN2E5M2IyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi0ISwQh5SjVCvq85MdtcwcjLIkEOavsy/pqw4/9efeQPFOZL9yzoeMcPjGSk\n0YQ8vmZDPuFBVMjD1zRiBazm+6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhtwCqBZd1Y/5HnqZC4Eof2dedCUwHwYDVR0j\nBBgwFoAULa9RLOHObnybSUbgLlcwgHvRaMgwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIAkvkyb2tFxbj41FEG0MVyZF6tUBaOP08DiAcPVZdyj2AiAf\nSbZxtzWCEENcEuZWXRrELPxDfNgDf6gN9W9IffP93Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbvgw5tgwPS5Ws96Nl+nPue8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzdhODhhYS1mZjZlLTRjODItYTRiYS1jY2VkNmUyNzdmZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+b0iiejVUnHv49t0jHjuWWBgKQbf+Mf0vmxEZbPJgcn37\nWB2PLKCqdrRKMBDNC6iYe5hiNBp9Sma0FaGuP5g0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULa9RLOHObnybSUbgLlcwgHvR\naMgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPjlDRiWrXPngmirt0Gs1QQpbkTZkX957nDKv6x0C/WGAiA21DmE4/K5\nr0YIVKC0dKCdv+mMjkbEVdLo7pZedZw97Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAV4PH4PS6XyxJuTb5YcHFXMuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUyYjVkODEtZGY4OC00Y2RkLWExZjUtNzM3NTIzN2E5M2IyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NDBkYTY2Yy00ZTUz\nLTRkNzQtYjA4My00M2M1MWJjMzNmZDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASnmlp11ysNg/ELHe6EUzOEZFkEO7aJnvdkf/FkdRY3aQ6GUSxLj1TCepe+JTqx\nQSHmGIOi7LUcLW7ESnK0dhAYo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSG3AKoFl3Vj/ke\nepkLgSh/Z150JTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAzHCUWqydHItr7ZQmnrPp85W73csK94yB5FDl+azr0gwIhANzORwHK\nRivfWEUKM1y0sa17VUn/8/m8kv49AI5qaQO0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3229", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3229` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXZ4yk4l3/5kA91iaePE3v7GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlYTE3NTA3LTNhZTEtNDA2ZC1hNjRmLWRlODZjZmVhYjdkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE2NmE1NWYtYjJk\nMy00Y2ZkLWI2ZmQtNGJhYjg2ODQzMTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVTsa3C1LO3yFFF7lFJuKGEi5UkR7idi8ur9bHhfxTdULn/TAGBLxth3noODG\nAMOFUM1PyCgRXuZpBADB355xAaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Erzc7Hmxa8a+EvkHNHLuKz4HjowHwYDVR0j\nBBgwFoAUd7yJwkXtwXDhonDLkGR5Hw+UaUkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCID7irMLB8nt8\n1CZFUgqE+u/eGj1a3s3eTAgfocfx05gtAiEAqsztzhTTFmSg9Yty18RcbGvGu/CG\nlkZssrXX99IgFQQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATRfdN1dId/LqXcD6Q643kYvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWExNzUwNy0zYWUxLTQwNmQtYTY0Zi1kZTg2Y2ZlYWI3ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyJ01QLNqdGHk+MFdHOuFoM3EfpKmfnWP3hUV4QHn1iYpE\nsbOV3zNmMITSzy4bZW3GxfcJFrWVWIrK/TQLj9CCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd7yJwkXtwXDhonDLkGR5Hw+U\naUkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIYB5Yf6IF56feOnLAJtkUCQVWp6UCUGW+vP3ErZUAuXAiBNB1KcULNd\n0uZ8PJyCMBqTLONIEJcW2+ooIEYsVqIjtA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAR2aPfYYWaFUu3fvstjO18O4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE2NmE1NWYtYjJkMy00Y2ZkLWI2ZmQtNGJhYjg2ODQzMTY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YmNkOTQ0Ni03NWMy\nLTRiNzMtODIyYS05YzY2OTQxYTgwYWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARQa0KQeilylgUXM7MIWiJNkkv2SsxIgRShMXpiApv+FuqYppQQZCOIO9ZohpfE\naEK73yV79fQWpbQIRpC28Uy/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTgSvNzsebFrxr4\nS+Qc0cu4rPgeOjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiA3hGs0C3TL5XGHAck/LOiWpaai0H935Vj3vXrarhwRswIhAO4M+huh\nUyn34tZf7YgM6ESKlZ0GrOyXDt8VOWfGMOdy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3230", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3230` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAZW3zZL0PUEZPwDl0OCOwemzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZTY0Y2IyLWNmNDItNGZiNC1iNjYwLTM5OTA3ODEwZDQ5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc5OWU5MDQtNGRj\nNS00Y2JmLThjNjUtZjVlMmFmOGNhYWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENJ5oocvZqGkf3XWvBAhinbKzVqgBqZKOagXe2BjU2zKuzx2JyeXs+2Od2zkw\nr+pGyUnNB0e7F2xCIsm2lZh2/KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzvdS3+tngYY6DfljXVHwHWxaNIMwHwYDVR0j\nBBgwFoAUjAtvKg/zn8hVxGI/Mi3Ra/4Vc1EwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAINmlzL3XokmnpJmjXIF/5N4UnYuFvppii++fcb90zj5AiEAssVk6QuT\nGI7EBT7sjb3RjkSF42rIRQ+i8+bKg2+IWRc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYHcU+znb/I5esP/94i2O+f0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWU2NGNiMi1jZjQyLTRmYjQtYjY2MC0zOTkwNzgxMGQ0OTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1W684545vBa/LLNhl94AG4xbGkPSrhEaudFJCcmEbyDhG\nkyOmE/gix+74BV2piEBcwbFkiCiQUU9qnTCzJJc0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjAtvKg/zn8hVxGI/Mi3Ra/4V\nc1EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL+Lmrzc4Z98WG7jTsAlWuZEnMe2gKZ/edIXiVSb2bFBAiAB5u5jKN93\nShaxoS+f5NIFWF9CldFuaONzP4G3QoltGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISARNM4SCsbXJKF15BIjfOaeQvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc5OWU5MDQtNGRjNS00Y2JmLThjNjUtZjVlMmFmOGNhYWQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZWM1Y2VkYi00ZGNl\nLTQ3NWYtOGQxMy1iNmMzZjBhMTk2NmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATzML1EEQllPqkPb/qoGXD9ny/WMebpXPHdK998m26bR/OSCkCTIQAAUYi8WWCR\nIHITSO+OfG9Nkv7WdKeH7Wnlo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTO91Lf62eBhjoN\n+WNdUfAdbFo0gzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAoSsRL9uakEHxq79Te0je8Lkge8o0hKLeC5Y7g9E9ONsCIHyuW5FN\nmniU9K3aJcSPSZLTOaNsZI94XMLs7ElePLar\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3231", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3231` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAXLJk7ASe1lxefTFkWuvwJckMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMjUxNGI1LTU1MzAtNDY1YS1iZmNjLThkOWIyMDgxYzlkNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY0ODE4YmItMTUy\nNy00ZTJjLTlhMGYtMzYwZmJhZGVhZjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo69xvWyPwxGe20YAw8DsZVwUDdTMbH/DeOwEed89w1vc4da20ccAMJA6m6Yu\nuFO+PgCISCIWUXV2ZAbKOvljGqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHrey/2G76wcchLwMx9fhS2N4xnswHwYDVR0j\nBBgwFoAUOFm2ndLkf9+xZvIJx3+MTe73IqwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIm4J826DsfGZjyIwOuEpnGuH6K9odfmzxhz9DpSXMRkAiEA8p3YrftI\n36o2Wr4HTIdM8jUqqFv8LESgFS5VQ5vf3fY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYyhNUy7hAbNjKh8Ic3emx4+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjI1MTRiNS01NTMwLTQ2NWEtYmZjYy04ZDliMjA4MWM5ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWivAMOX/qC+F31uSqnYE61cDRLLk5oJIKQ+c+3PxJd+vO\n837yzO7y5a72i1a5DwrWBBU8ajViWr3SuJVuXh91o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOFm2ndLkf9+xZvIJx3+MTe73\nIqwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRNNVad/Tsjhyr+UfayzVv7qybFcjD2gwkS7Yubjq3SICIEUe5/cs1sZs\ntBhUdy6984qNNqH8t7cOZT8yCSn9aMSS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAfF4A52ir2d1G8PlbmngBUHmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY0ODE4YmItMTUyNy00ZTJjLTlhMGYtMzYwZmJhZGVhZjZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMWE2YjZhZi1iN2Y2\nLTQ2M2ItYThhZS1hYmNjZDQ3ZWY5NDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARZCuqT5UK+z1b0faZaaiL3xqjT5S+24+9m3JyglC7TBcVIXv4YdZ3uklKw0P3V\n03AwFdorMdLZrJMO4/F4a+qho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQet7L/YbvrBxyE\nvAzH1+FLY3jGezAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBcHPu7GBHtl1I196PMrgQcwnVKl501FISYyu7m3zUAZgIgDcT1+k1/\nUUuI3iD5rkl/8HWImuOpliE1aeNL5nzH7jY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3232", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3232` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAVtCQxHDSMysZNjPAP9ceNAXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmM2ZmOWRmLWQ5M2ItNGRjZi05ZDAxLTA0ZmJlZTFmMGQ4NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNhNmY4ODktY2I2\nZi00OGVhLWIxZWMtNmQyMTc3NTEzNzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQECOx6W+lJKgv/p0/F+g+Vfu5XZnFT3LGXB4sSQb82q6ym2MX4JtWsi1yZV+\nHUMYlRiERJw8FdTBez3AOTUNBqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFeApGMW7PfrOV3lxu3J57v7/H80wHwYDVR0j\nBBgwFoAUFsDQHvOQT4m7ym+k+fT0caawLsswOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIHoFpCnCIXUCbNviutAO2sChNU2oOfyH1acACbEYdDtlAiA3BtK5/gg/\nfwMS7f9sV/ANR1URSuTWtiwT6HYc/OgkKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbUxu16g3yAxOuuLW+HrWuc7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjNmZjlkZi1kOTNiLTRkY2YtOWQwMS0wNGZiZWUxZjBkODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2TKOh386HdEnpVDy4MYm19v5LNJNWIb1SaI5OBUUHtLUp\n9+RyBXf77mqn7jSb4c+6cj6gt+8v47JCPRn09H8Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFsDQHvOQT4m7ym+k+fT0caaw\nLsswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJz0gXIuTYtTdSnw+1vnqpkQaUYBF/9zJ1yrdH99ZfWwAiEAsfJBiA+2\nxO0w/cTCn1wcjst6OyJoo5zIpECaLWrzV80=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAWLvFaRVKr8oRbDmfFqZKom3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNhNmY4ODktY2I2Zi00OGVhLWIxZWMtNmQyMTc3NTEzNzE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NTc4NDM0OC0wZWFh\nLTQwYzMtYTYwYi00ZTk5OWM2NGI5MTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATyNUunmgXsIedF44hHYtd0ELENNNkE2bgtfJWoJFzj23O7ObBu4IHvu8arPfUo\nIvthEstN2gdCGBeH7t/M0810o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQV4CkYxbs9+s5X\neXG7cnnu/v8fzTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAt1Iy0voOYOg8rLUYq5A3Mv76tXAgdxQHcd6pg7A7uTkCIQDr+3+W\nH0AUhrnB0QjzSk00A2kWFzZREwxUuWwFHOlmXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3233", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3233` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAThhqy7GHIqzua4dPAdjBzUfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0YTE2NWRlLTRjODktNGNhMS1iNGI0LTE1YmYyOGI3MTdlNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk1ZGNlY2MtZjdh\nYi00OTNhLWFhZDEtYzdmZTBmZmQ3OWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2pclYT/qFww5PtnUp8Hr7BL/91tDeaxypWauGxZnng4AOC8NPiPwqO/8c4Pz\nlp/Lx/sghgaqM1U5vK4sppjOpaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMbLTfujSuSCQoN0L99ztrsaomXowHwYDVR0j\nBBgwFoAUMGdSNOaf4bphvKvd4cb3nPzbB/4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIC6f+Ds/xq36FnOo/8Lh1A6FSYuncGRxc07DJQ+E\ngMGdAiAMPonOcMaudvhQQjHlJJlxThWSQV/hznDXLwWo9F1Yyw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX/F8oyfNydGoEWqwNTqs3wkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGExNjVkZS00Yzg5LTRjYTEtYjRiNC0xNWJmMjhiNzE3ZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgoBqk4KmW+Vls6oDmMayVIKhgfnDnaVLMDxuztQnprXTK\neNU//8mjHwFktVIWgopPE7kdHTTxbaWqYl4AgITfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMGdSNOaf4bphvKvd4cb3nPzb\nB/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPfwamFs5MXWAHuM8bWjuMU7ZLn6bFTGv9nAkV3kCxIMCIEr6tGVTJI3R\nQZarKyS4vQ+DMAwZb8QHatFC+dlm6dlu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAf1y+wnwbxPVdHPYIoRbRiPyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk1ZGNlY2MtZjdhYi00OTNhLWFhZDEtYzdmZTBmZmQ3OWQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMzM1MTQ4OC04YzNh\nLTQ1ODktOWRlNy00ZTA1MWIxY2JlNmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASF2ecuyqxPrvCj8YqZug9FdIhJ2+K9R4JL1LxbvgN0eIJevUvYTGK7g19zoqkE\n/Afaw3VbATBMqS6e6IABrUh6o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQxstN+6NK5IJCg\n3Qv33O2uxqiZejAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBgsrR6SXfD/7GKck6+Z5fPtOY+tbd1c7pvr6oiAieR9QIhAIkxMzjT\nlChQi+N/sEilYTc2SRaV5DKRDeFlS88ugIoM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3234", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3234` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAXQ31iXcqk1y3EVk0QfVfqRnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwZTQ4NWQzLTBiZTgtNDZhOC05NDYwLTExZGUzM2JiMmI0ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDAyNWZjMTItMDY3\nMi00NTNlLTllNmUtYTI2NWI4YWMzZmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnSD+5IrkFEpsZkxkY8m+0MgnFeQSNz58ashBLDUVvEdTxOiLRE7KN0oi4qbi\netoP/fLOYgcszAJ45VnLD//JXqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnHFEWUqiU0gE7mE7hfV+cgIwJ6kwHwYDVR0j\nBBgwFoAUBa+bjsoOIoW5eA0NtN/ItYEmAeUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFAxYmkLg9Rfm9TgZOnJeArKa2xQqpVZQa7YaxKG\nNfY/AiBiUhhcLYhXiqOPG836QCDTmSxY4H0z/75bJVXs0m2+uQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVQbqCmu3HsLNx3uCPJyC4oIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGU0ODVkMy0wYmU4LTQ2YTgtOTQ2MC0xMWRlMzNiYjJiNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGo9Y0EFmUzX8CUQS5A/kJP2pGu1wFv6ZPMjuCEM6ItOet\n+9dyRjdxX5ypoF5CW2TTYYALtei3qVUcEhX1vU2go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBa+bjsoOIoW5eA0NtN/ItYEm\nAeUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCTQItUDL5cRHGFHQZjkiTJB4gleGPI8tSbOPHX4rm/kCIA8kXJNeMlbP\nHuhpJBddhXwQ4KQT7yTwcQOT7pAcn+hO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISATzoggssjfu5kpBLylSBuaNTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDAyNWZjMTItMDY3Mi00NTNlLTllNmUtYTI2NWI4YWMzZmIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNmRiODUyYS1jYzRm\nLTRlYzgtYTBmMS1lMWRiOWM1NjllOGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATczdeYCUn1893pLjtQPt9d3paG2q9yckPjkyGsQ+SMbOBaKgJw44HEFquAlGSZ\nYG1LkKJCF7DWv+QoPWE+yFS0o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSccURZSqJTSATu\nYTuF9X5yAjAnqTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAqsm9O3vclfe4DcpL5MEu5D/sTXIFFbWRbTqoOXmhuLACIGY3fXVi\nlEpMtCBdeJHOy8+dOBkcJmgI5oFT2gGP1NXz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3235", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3235` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAa2N7yqLcdFH2v90cIlmTYsLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4OWJlZDVhLTI3ZTQtNDhiOC1iM2E3LWU4NmRlZDE1MmIyNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA1ZjQxN2YtODFh\nOS00MDQ0LWJmMmEtYWIzMGFmNGU5MzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYOqfGq4KwV7j3QcK/yF4MAaiGPnTsqbVZ6O6IgIOCAlUxqZc//mcya0FqKRo\noET+Wa9lYgQE/9uWrPAA9qKo2aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpncuRJbYhzlnUo29d/gL0wJG+YYwHwYDVR0j\nBBgwFoAU2lh3OzrUTypTb2+oXBSm93bouVIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQD+filUVT/TEuSCXw+7C41hXEQRGNPZIBjMBdfecSkIBQIh\nAKFmfsxfxBhOF1SDYuyx7fQ3UNVforJbw6STnZC1vYf7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXnNEXYYw2YFm4dFXHrgTYyCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODliZWQ1YS0yN2U0LTQ4YjgtYjNhNy1lODZkZWQxNTJiMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpTDvRWPWTP4QqIU3RZOM+5wRtcH09PzEs6V0GgB6b/GTl\n3svFj08keUsKoYJyvDS4Wi1M/EuG0ZdO6wklENDHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2lh3OzrUTypTb2+oXBSm93bo\nuVIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCCPoZot3+DiXU202D2z2zTn3xd1sBLv4NPD4QD/a7zcCIB3v3ajH2bYC\nVJ5gQa+/bqKsTkKp2egv66qymNl8bIo0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAbgSG/5NXniittBxvl58YzpPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA1ZjQxN2YtODFhOS00MDQ0LWJmMmEtYWIzMGFmNGU5MzUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYWExZDMyZC04Mjkx\nLTQwOWMtYTk0Ni00NmNlNzU4NWI3YTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATzTDPiZvTUt3M/kdtpHCGgUYYmmI2Yd5pU1QWFY9kWyRiKqAqVcpls+5Hkee8o\n2bRZJ3VXrlXKyrbeMX4LDveEo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmdy5EltiHOWdS\njb13+AvTAkb5hjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAu0Bz/c+jpLwMe4ga3BdfPt6aJrhdmlfBwYCOAdTctXgCIF69M6G6\nIDwKuvjTl1tkmRd530uVqfHfczp3qYxof+Id\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3236", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3236` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAS0ceelaRoiZWhLdmpEWdvUPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiOTE0NDMxLTY4MGQtNDQ2Yy04YjQ5LWVhZWY2YTZjNDFlZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE4Zjc4YzgtMWQ4\nYi00YjZlLTg5ZGQtMWRiNWI1MzczNmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELxFhdVbCY3KH/HAWftHpCYJQQ/Jf7WqIx3vUyaHdcJVvC6v8bC1fWBiQnW5r\nVg5ETOUuzkmrM+cZvBEvK1yyfaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvuu19+IA1EZdD2dxzM8XqZBtmf0wHwYDVR0j\nBBgwFoAUC2XV87JiOUjxtC1dVBurNRykl4QwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGTcrNy+XFNx+wE51It38+1u2N8Drtzr\njzSA9wpmueHrAiAISZa7WbkE6nV3qpqcf5kidgn7Ww/g4z2+icoGUmRwDw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdrJq+UqnNQNNEH9uaSSTcbSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjkxNDQzMS02ODBkLTQ0NmMtOGI0OS1lYWVmNmE2YzQxZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9gg6GT/8sTn7Gl9mXV2wO/49ok0AoyEqw5PbIZAZcdxlN\nji4KA+hWFFa1Mnt0olKElglgk08tNMc0ut43fV9Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC2XV87JiOUjxtC1dVBurNRyk\nl4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ811Krj36fZBFkYg/IDZQJwZsyyPheIzE5W/myRfXycCIQC/lOYxDImO\n0uNO/0O6vtSRlvELz21Z+kxteFG1BlFmKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAV5kqkx4OMyEs/5GmmuGRl9vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE4Zjc4YzgtMWQ4Yi00YjZlLTg5ZGQtMWRiNWI1MzczNmU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NjBlOTc2MS04NWIy\nLTQ3YzctYjU2My0yMzA2MDhlNDRlNzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT7szrirfAi/rW7d+hycKEFKDyCNlxdbOTROk0CwU5xV616pl3k8vIDpGIIg9I0\nrGAKIAHsvWB8rWRlq7V0XFeNo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+67X34gDURl0P\nZ3HMzxepkG2Z/TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBT4BkPbR7wz3ShChlN8HzkxoUUXqziy6zEYJ7I8MKrGgIhAJG6HspA\nrcQpWJfnSgPLlNw+tV/AINTvBegbQkLv/i+Z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3237", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3237` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZC1scEItKQIN8+gsFj53AobMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYWE3NTM1LWM5M2YtNDBhMy05NWI5LTdiODcwNjg3NDFmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUyN2Q3MWEtM2Y5\nYy00ZDE4LWFhNzUtOTI1MzIwZjRkMWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgRoMqRUH2QrHS8W/qD0S/FlyjkXe2RPDdBE6mG0ShP/4KVJnYhDbE3/WMjg/\nNTeTDHfDpADUOawD9BrQsYkCh6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBhqh7URYFQubmEyHyn4mkSnZa48wHwYDVR0j\nBBgwFoAUu+wNwaJg1EuG9WJDtCKavQ8ZP+0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIH+e7HH1fUJPYX/J8JfnMtRuglIW5D1Q\nOQzXukOW2DEDAiEAq7v2XEM22Ydux5XdNAxV2sypkzfE9aG3PrzEoUF+0TI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcclN5l+EgK24yR7VMM9Tjn+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmFhNzUzNS1jOTNmLTQwYTMtOTViOS03Yjg3MDY4NzQxZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCXOhGg3bHbLk/FzmSC9X/Ghn+4vi6fi8iwF/NnkvUv4Z9\nQnnBYnkRWKYurXb6/RVL7fSOIYJHN+18JuWtI1gCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+wNwaJg1EuG9WJDtCKavQ8Z\nP+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMZKU848mChBGBmiPwbGlN5xbLGpY4BqIEiHdqQmmFryAiEA+TAwL6N7\nb7wxJSNXYiegMLo6F8FQ3YgwAb8HDh7GGHk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAS1PoldBy8BZjT1Q/zGvTOMFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUyN2Q3MWEtM2Y5Yy00ZDE4LWFhNzUtOTI1MzIwZjRkMWJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlOGVhNTc2ZC05ODcy\nLTRhNzItYmI4ZC0yMDJhMWZmNDEyMGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATxCDvfIP9IVSox8lBZyzrl27x69azkyLFTvlIjJh2E/0GGtFYPU2NCO6nUMX6M\nG4QCaYHtbNOnGyR6/mpqw4yWo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQGGqHtRFgVC5uY\nTIfKfiaRKdlrjzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEApzpgS+2LeBR6lxsBhkq0o3q03yuG4ln8+NLSsRZjd4wCIEpSUPuX\nCTxRXSwIylWoRziDIYa6mfOI7bRi7CbmBvco\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3238", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3238` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZLeU5s7RjuDxacRffBSwbkQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3Yzk5MzU2LThhMWUtNDc2Mi05NzI4LTMxMjg2NjY5ZWEyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE5ZjljZWUtNzAy\nMi00NWRlLTg0OTItZWFhZTI5ZTY2Y2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQPhe+ceyXhp16bs3RAAIp2D6WHcNl1tqmkOyXHAn1c3Lkpgr51G+Px/XICrx\nc1cM5yECbNFG8KuXf9qD634sjqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhu7IuzH2RCGQ0ZXQEcpCJs/x52wwHwYDVR0j\nBBgwFoAUNyzS4cj9LJODY9h5snE25EvcHHAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIH1gANdrU2rq\nhTGAeZxYZFCiaWN4S8xeEmSUMdf/xtSvAiEAgsK8RenjynJxGS84W7/7hUQkCCM0\nty48kPlg7gh1S0k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ5am/Ig+g2Q5jVQI456y3mKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2M5OTM1Ni04YTFlLTQ3NjItOTcyOC0zMTI4NjY2OWVhMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT23JuKygJR0wSgy70WWZnXt1WH/m6oAliEXMaG6altkBR/\nZPnPrNUz5CPArKJ1cs16twCHLcIBc9E7TOo4LHc4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNyzS4cj9LJODY9h5snE25Evc\nHHAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKCN1IQt9goSjguUSV5Qny67G2uVnRv8B4rOZY5HgunhAiEA7MPRSVwJ\nd6ABRxPPebWdUlWyBohbUXO8eSHkmydY8ho=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAdd4sLHCm+FcFiYIlbEZAUiFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE5ZjljZWUtNzAyMi00NWRlLTg0OTItZWFhZTI5ZTY2Y2VhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MGVjNzUzYy05N2Mz\nLTQ0NTktYjI4ZC1jODYxYWZhMDY5ZDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATsJXBQUBYmMqdq7CQTo5qbXdeoOW7yZJHkrE8sI83JuGB9lRAuNgZmDaHh2SYH\nwPKUauLswwFtl9LWeRWJA6Mvo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSG7si7MfZEIZDR\nldARykImz/HnbDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA8WBb/idXbkKaO+wyQWYnQ6XYcZMIKN2puEVo8H/XIr4CIGItn5Q5\nz8agMvP1+ucgNYZbDS/WxjXniw8zAv18HaQy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3239", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3239` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAYlb3l3krVh9mezBY5Ro9J6oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3NDc3NzAxLWFlNzYtNDFjMi1hOTc2LTdiZDMzZTViMDEyYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJkOWRkYzYtNDMw\nNy00MGIzLThmZDAtOGJhYzc1YTQ5NDUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgcJBCiBS1ieeDzPg3BlU9X+zw/ANh5QdqxFkTrIzuhtsDUAzYC7waLI1502t\nGf0bK4WoVsKv9yKzLyKFBsn+mqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg0qvaKBXsu6L16qA9hDBknTbQZ8wHwYDVR0j\nBBgwFoAU7fHSIWr5fp/Pmr6VOl1XuPw/gWUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgOWgAG6WJ8zZWlkRKBNtv7Snhnit0UoUZntgZXclo4yoCIGceIJwCsEtW\nCe6MhClBD+K/sBxPVwQv8fRcY04TevLQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdQmE/50cMQjF23SkfuCWrYiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzQ3NzcwMS1hZTc2LTQxYzItYTk3Ni03YmQzM2U1YjAxMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQme/cqD+qMkEgO8wqk+TCzQqhAUOR00cQP9Mh1daJ4Xt/J\nHk5+47wXwvzQvKhWDOxpo1F17WoPEaoVX+CXYfLTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7fHSIWr5fp/Pmr6VOl1XuPw/\ngWUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK1mFq/ikW2i0UFVI3SJXLcxqkco5r1klqkEuQbcTrDdAiEAhm3m7VvQ\n2vz4yYe8gBWcR7gLQIIw0rLx1E76Pd6wKG0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAdE9xc5ysyqLf/z8DaY1s6RfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJkOWRkYzYtNDMwNy00MGIzLThmZDAtOGJhYzc1YTQ5NDUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MjdmNWViZC04MmVh\nLTQ4YWEtYWU0Ny0wMGFlZWYyYmEyOGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASey7IwDFSM/TTQCMYpoW/KlmUNLjH4otdksisfK3c7LB0ZBMU7uqgR4IpDhqY+\nbxzMbUf4YdzbYVG4ASE2CEyTo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSDSq9ooFey7ovX\nqoD2EMGSdNtBnzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiArrb7tKVrIUYyhJsHGslFQ+lv6OHrHzCYyBBf7AAEpgwIgI+DgKCJy\nTtllAvgCSdaACAXSdSqTa5UFwOtQwh4z5+A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3240", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3240` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAR1djYf8mWVoaPrF0h4erw+bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MDlkZWExLTA0ZmYtNDU2Mi1iYmNjLTU2NDRhNmMxMzRlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NlOGQ3NWEtYzZj\nOC00YThiLThjZjItZDYxY2RiNTk2NGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz0sqJhzH5u/7N/mlx5RpCs3oD8R9BD8mmyBPZIPDfoK3f9BABO5By1+uKokc\nsloS5T5IT7dRXr/9bSghmSdwD6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd6x2tGRiGXSpZVeHF5mv2DaJAeQwHwYDVR0j\nBBgwFoAUGtfV9be+yJBm6p9+PEIv3YygRlMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALomFGy6oWmzhWluNHTsLq0M+HTB86fcHqKkswIg945OAiEAxXbfbzta\n80rPmN6amH6uzlUqQujU/rvj9Y0OhYuwuGw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQOk9nLs8QE/y63PBKQNVNtfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODA5ZGVhMS0wNGZmLTQ1NjItYmJjYy01NjQ0YTZjMTM0ZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu0Jh03eOptyua9mWtdPoB2iropJNjkFVHWuMHttEK9iqG\n0kt722l0aIgwyIKZ1dkDzExKyyMmBg/N2MuKhVgJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGtfV9be+yJBm6p9+PEIv3Yyg\nRlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM9yziBAYph31SkvatFyMN0xS1fnJ1B6sGlpe8DQA2N4AiAm1yHFQtXZ\nxym7dkrubKLByhjC9M3TxJZ1OBG4G//K/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAXMG6hhEY/k1Krpwz+3F8S/uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NlOGQ3NWEtYzZjOC00YThiLThjZjItZDYxY2RiNTk2NGFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZjBmNTdiZi1hODZj\nLTQ2YzQtYjMxNS0zYzUxZGM0NjQ3MTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASqovwGhbyA/WutREvIw7NsyTy+2zAejlqeGsqvVRpJwNrVerFsmzmu6F0UTlkY\ndZJ9uKbDOy8ENUmVtZbQx9edo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR3rHa0ZGIZdKll\nV4cXma/YNokB5DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiAZGKzZurS3QVHLiDbPLQNIeyBjgS+4dQJrUVckOq2/IwIgFBrOiJC2\nUtxznBry4ANeJNRDRJKp7PbnTsHXGcBb5MI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3241", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3241` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAU/EfEHGgLyVSePOkJYACYGNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzZWM0MTI4LWU5NWItNDkwZC1hMWUyLTA1NjA3NTJhMzA5MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU0ZGQwZTItNTE4\nYi00MGI2LTkyOWEtYTZkYTNlZDg1YzY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElDKioTY6GjXiQjW9pQAkacnr8iuhGlNGBPB8IE2bdexLaRu2XMrf7UVfjU0s\n9vSyjg6/5qG0iqEkcs19wQXz0qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQTSJnFdZhj1yPFjnuVlav6R3pt0wHwYDVR0j\nBBgwFoAUWwdI5QgjNcQ70tbTTpVxs/Y0UugwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIQCX8t/ouNeuGQo3i948e6QQ90bpSAfD+QmfoRATuMCTHQIfK7YWsZja\n1qcNqc1PoxxPP1wD7PfoM3I7u/8qfBJ2nQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAce1AbMqg7DNbzpBQW/AJafWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2VjNDEyOC1lOTViLTQ5MGQtYTFlMi0wNTYwNzUyYTMwOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXplwtTsiE4kFpQC42z/LWxyobvG1Tz0dmZiv+qfiPp8ao\nDpYeU+mQqNu6+Hvp1HDDAcVPkHUSpNruaCUzzRSjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWwdI5QgjNcQ70tbTTpVxs/Y0\nUugwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEqYzVM1FCh7PwooN0KUu7YJ+Ct9tS+XED6NPvKFBFywCIQCzEuSW9vTh\nfMidlKtHzDoBCOwU2wScVrrkhnxce06FJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAUwiThtY3aS8gtSM/+9U7pj6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU0ZGQwZTItNTE4Yi00MGI2LTkyOWEtYTZkYTNlZDg1YzY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NDczNzBhYi0yMTYw\nLTRhNDQtOGNkZi1mYTIxZTkwZGQ4NzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQaSZT6xkbcDkK0crb0lvg6ECLqkal0uM1aIjtaczxCOsSxMAtzgz11OYS14jIQ\nrwiGuhsQSVXD4xyebdgDEmXno3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBNImcV1mGPXI8\nWOe5WVq/pHem3TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAkIJ6akGin1mNYC7arC8YgQEF18NZRITysr/UHv0v6GMCIQDtW96c\nAM31ip2MTuWU3ZIrSciBUN/JOjDcYAlTM721iw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3242", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3242` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISATB2tMQxhFtcPet7WlL1Mj63MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhM2FkYzdhLWRhZTEtNDI0OS1hZTc1LThiMDk4Yjc1ZTQ0ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI0NTRmNDUtNDYx\nNC00MDI0LWI5YzEtYmMxZmQ0ZjA3NDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2ReggR8/gFEIl2AAClhBWQMULPgyvjJ1YQaX0Ad3JiJbAHebx35xxPJ/nzVT\nWKeCYT9bq1m0mL6B5QUqo8+nG6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYORlCdLW6+YRdibAQGYjApB5U9kwHwYDVR0j\nBBgwFoAUrS4arnGkcaH0zr7n7khnvPdi6D4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEcQeoT+cUl/ysbltFKX31DokU3Wr+wBIg+F42zw\nwuiGAiB0EoC57L1AxOkmAJKpm3iOU0qTH82vc9V+pERNxaebMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARLAYBB9mD6I9+0veDq8GE6XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTNhZGM3YS1kYWUxLTQyNDktYWU3NS04YjA5OGI3NWU0NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZ6mkegZ3BTRvDEmzBycLsf1UweQQRHo0acyLQ0FUxKC/y\nGLgrUfxNBbRWNm/zCwBbLDhuqOS4qX6uFs/BNBiZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrS4arnGkcaH0zr7n7khnvPdi\n6D4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSV6HW3JdFXozuytwTMB4TxKnKtPce0waYp0lmus+gpgCIGjo/WgJEuRt\nhesBcn32kTjViq8N7W6iz/UN3oeEhGTR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAYtu0sr8I6IV03uVIsoiiU0uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI0NTRmNDUtNDYxNC00MDI0LWI5YzEtYmMxZmQ0ZjA3NDY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YTg4MTcwOS0wOGFk\nLTRmZmYtYTY4Ny1hZjhmM2NjYmQ0NzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATkhgRPi2FAiU5GYOeHb4SSsxXSgnw0KIQ5Kdi+K9KvDObvrRDtYXQFzSIj0/Nj\na6ESY8TODtF9b123UQbvMRnIo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRg5GUJ0tbr5hF2\nJsBAZiMCkHlT2TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBd+8mAldUyqJy7V/dqqtxY+7y01G9EBYjImilKyNk0JAIhAPCFgXG9\nrHjpKVsSDtJiXLpiIJPVOGsFvDoHUrrB7QbJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3243", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3243` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAcQmB+sj1wt+2hG/wqYhlAHGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2NDg2MWUyLTk2YmUtNDM3Zi04ZGFmLWYyZDNiNzQxMWUyMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJlZGNjZTMtYmE3\nYi00NzY3LThlNDUtZDc2MDg2YzgyYzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDrwM/SiXMPKCCsVjjIq+lisS6ILVKwmzoqsJaCm/EMuN+8VppC1hYumYwbwM\naRZ+GGOagZpDsxEftbZ4JcJBmqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeDxzR8Nv6r+w441j9VQ3APhAQ+UwHwYDVR0j\nBBgwFoAU9WE365pvmL72yE8ves2icmrzJ1AwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHBta5h7Qi77kOwiHpjPKiBdrpEzXV83M2xCf6k7\nnaCaAiEA7hU9AzgsRWdW5MS/VVpMtwlhoLrrhlUqy/fi7/cjMMo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbYlsF6zyqTFiaFQa1VTC9QRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjQ4NjFlMi05NmJlLTQzN2YtOGRhZi1mMmQzYjc0MTFlMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbdV3BO7ekKkcHSoC/MuOb/iZHOrbPzEYn3iE0pOvQqaZE\nvmx6GXsialdk05zL6uJUC/cSVaMOzAt3aVJPjlCpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9WE365pvmL72yE8ves2icmrz\nJ1AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI4etsvy3ybkFwxNz6Brh1tqHcBbJ9RwDc000pNUa9DjAiBpF0ztKOZn\n25V5IZJlANqIyHQAEFf6Bumkmr1FF2/QzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISATrrpTZwYk4R6pn+CD6fkDb/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJlZGNjZTMtYmE3Yi00NzY3LThlNDUtZDc2MDg2YzgyYzAzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMTAzNzhiOS1lNWNi\nLTQ1YzAtOTBkZC0wM2E0Yjc2ZjVlNzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAReZKpUYOhE/LLnG2Y3nJ/TR2EJXH1Ubla1TD30HSrFbl9au3gGe0Aj59MapEp/\nR6FVhThMJfmqPD1NxSztNhMDo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4PHNHw2/qv7Dj\njWP1VDcA+EBD5TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAnEv649PIn5B17XA/RGBARWUPP4mkz92IHYr3rxeDWf0CIHqheMMg\nXnIfAdVnjXqurStdjNqg9HF2G/IrF6VxQvrZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3244", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3244` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAXXWcVe0ZxOyK20Zyxql8MQ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxZTg5YTEwLTE2MTMtNGNlZS1iMjc0LTY3MTRiYTZiY2M0MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTlkODAxYTYtZGJi\nZC00M2YyLWE1ZTktYzRiNGM5YmVhYzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiUHcInyZ80D7WiIp9BYqN28XD+IcauslxMVBv++g4t03BrpsB5NKpAz61Mp+\nu+1202PxfugIMX8Xe2XazqfI76OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmrvCCz3Hju8jj2ADV712Q/vlViUwHwYDVR0j\nBBgwFoAUDB2QtWZR+d+eeUiZ7gX96sEFMUUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQD5s+gsEiTsEjBFuKz2diGvB8d+4DJoRMTLELZF+2DavAIg\nDzvKNM+hUiDop8NWplmlgM5BQsc1QbZJ+m2MAgXVpb4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARUQHqCfCaI9n5Go7F+PhXb4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWU4OWExMC0xNjEzLTRjZWUtYjI3NC02NzE0YmE2YmNjNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxhqc5jGumLh75u3XhU7QSwHXHrwNuMNM7R03ha6atVPvx\nU2qv8RY6z02W50my1FnF9Kk8rNaVEbhGKYAMIu5lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDB2QtWZR+d+eeUiZ7gX96sEF\nMUUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJpbg1+sp5bOuNroen2hgdEkLZHvsE4gLXruLi62MaEFAiEA78TKwMbV\nM/03IJYXYK1kncT5gWOGFCY4fDcJl+JAM0Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAWvQGjW3OSOsvmfFkh1kwn9RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTlkODAxYTYtZGJiZC00M2YyLWE1ZTktYzRiNGM5YmVhYzA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZDdjNDkwMi03ZjEw\nLTQwZTQtYjc2Zi1kNDg5MjA3ZDE1YTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAShLhxSvj93R5/OvK2t7insRM17GPirLXLTN+DFVH9sbHKyWwkT0BTov7vjoJrU\ndoq4znYDLHqAufqsbeZwdGX/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSau8ILPceO7yOP\nYANXvXZD++VWJTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA3Wx9Vu/unLQw99EbZCXltdpxPYbtdqZKIOwgBO+3D6wCIBGf41eL\nCtQhkakkzBfeq7ZBi9rPEou8J8jhdLFCb/y6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3245", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3245` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAVbAPl8SHnAr/M3N2xGajXIKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5NTIyMTNkLTBiOWEtNGYwMS1hMjE4LWE1YzI2NzFiMWEyYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUyOTYzNmQtODIz\nYi00M2U4LWE0ZjItZGJkZTEzMjBjZWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW2islVpdAX4Y4CyJ3p6WoiqLoPEH0FzCTmdx2B7XUUPJct5bgYc/l1gYoX6S\nD/K5/VepVhViHRd4F246tYQysKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUET32st8A857riHlukCvS/ovFrvkwHwYDVR0j\nBBgwFoAUUEqDNmBdGQ08YcIhEpWJ8ZAr1KcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICKm643p9Ir/xJ2LaNH3lOv/4RZitSWT\nnA8VMwQfYYuUAiBAhtaQS2FFoZzF5d9HHUfI9f5ceqb+5tCC5ofxeVFiag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXM1bIhwA0pKlEH1/gY5JzKMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTUyMjEzZC0wYjlhLTRmMDEtYTIxOC1hNWMyNjcxYjFhMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATib/qiau60GE0qcEq96Yodd6qSSoy006756HjFVtE+Eckp\nXXmeHPaXhc23sjijUaTLDzvVg1UXw4/497Qa+b3bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUEqDNmBdGQ08YcIhEpWJ8ZAr\n1KcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXB08ID83L1VvuHAIVslkDbrUa4HRuRuYM3xlWgDp75MCIQDBoEHDSE5W\n7TFsPV+n451PbsVGmwJCy6zAhlJKp3eGDQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAU4vqHirdXznG/IySTZfe8SJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUyOTYzNmQtODIzYi00M2U4LWE0ZjItZGJkZTEzMjBjZWZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMjBhNWI3YS1kMTJl\nLTQ1YmMtYTVlYi00NWNiYzc4NmFhYzIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQLFWDROjNyXchJ2/FzoVFqcJFDSzYcDdaUOjF2dwn/BrsfvI09OvIBG6N6i2lv\nb7aAiBYjOCC6mBw0PvDt7l6Wo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQRPfay3wDznuuI\neW6QK9L+i8Wu+TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAgzOFK3kJjLBBiAimEf+EJ+bHT2wYnkeJ9rdoh0EOTZ8CIAFkozNR\n0YJEMUv4tQ4M6756OKxRYjHRM9+BDJDuP3yx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3246", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3246` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAQ1dB6YVowYc8Niy33ReCUZaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNzBkNTc3LTJhOGYtNDgyYS1hZWM1LWIzYjExNTFjNzdjZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI3OGVjZDgtMmJl\nZi00NmY5LThmZTktMjlmNTViODljMjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElU4YmA7il7Jz1Cv69A6o2Mbsy/ajNhu7HZirnv2QF7X1rh/C/2R3xhaVS/Ht\neRlfS7Nes7mBKTS3Cr4+HsmfQKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy+yi//5g/3uqsxT2A678VnW2XHwwHwYDVR0j\nBBgwFoAUvO7nXKjUI3snaITDZX0RurCw6RUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDfYWUPcN9ns9d1Pre3DXDKRLIvRhoC\nPimoGaXNg8mXpAIhAOspGM3n4n3smUj7iyMEHbT4bFvL45f+HtASyKh1TzYW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVguWVdz++ycIbl5R+JANpOMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTcwZDU3Ny0yYThmLTQ4MmEtYWVjNS1iM2IxMTUxYzc3Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIkxkoksMBF+MKPQDDAwSdRGxVCm053lErQXWzMSHLYL2N\nQ0xDFGkM63QEeHOqNBr4ZhZr8qU0I5uRgEdNkatHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvO7nXKjUI3snaITDZX0RurCw\n6RUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKgKA71Fsr2HOGUVAqrcab4G2QJemhnSP0y51kJtwBCKAiASNUK5nrbd\nwjxrLn04x/aHFZW2dv3jCpVdREhJwkYHzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAfhi1uyPjcx0h6mIt3AGba+fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI3OGVjZDgtMmJlZi00NmY5LThmZTktMjlmNTViODljMjI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMjc4OThjNi1lMjc3\nLTRjNWQtOTZjNS0zNjhmNmQ5YmMxZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT2CRKT630h194AnQTQyCbbFKe+MmyOapzc8t6kp9u+3VIiy/Xvoz0AnDBW6V3i\nc2SmyM07rxwRbZYPUKwQSDcBo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTL7KL//mD/e6qz\nFPYDrvxWdbZcfDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAMec6jP+mavIW026xx+/HBpTmTPUNOn3N1YkWUvoW+ogIhAPoSCNUS\nfV6raCviVrykYe553OgypkIqtOa2PsFz4keg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3247", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3247` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVNP/pu8q2Gue5r6N71ARX7TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhNmY3ZDU3LTFjNTMtNDI4NC04MWJkLTIzNmY5NzI4NjNjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVhYjQ4NDQtN2Rj\nNC00NzMzLWEyMDMtY2E4Mjk2NmNjMDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcYzWsRxLq+uLw3cgEMZ88eKR+7yYbm9nD+7UDvncOthXIR9FMnvOSQmIAMFj\nXmv4W9CmeQVog+YjRVzRhR5PK6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIyi5/ERMcXZXRZWjcNJc246bxtRMB8GA1UdIwQY\nMBaAFD7UNs1ja62FW3E/fPUKsZHzZp6cMAoGCCqGSM49BAMCA0gAMEUCIQCu7SIl\nV49emFREfRxXxj9U3zFANT0BV/L0pEOykbkPAAIgX/kW9uwGOA9OCI2RCxTrvo/A\n43BDgMoS+m5LPwkVDN8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARLAFw/MPyw4TcJX6ddTmpZUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTZmN2Q1Ny0xYzUzLTQyODQtODFiZC0yMzZmOTcyODYzYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDbZCfM0giYkBxqh7kSDx6IRp3Pxh0LpsTkhBVpqxdMi9S\ncsZSV9bhfQMsolHBEukM2ETVNqG+Sr5F4Yh79wfgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPtQ2zWNrrYVbcT989QqxkfNm\nnpwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE+P+50d+T748IaIGxYDcKJgCWZrRozxuVQzwJjaXNuMCIQCERNKmconx\nb0GghpkMU2l+7P7LmWL53eOMDUG8QApG2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfe/1BXrFN0Qq5QY+qkuO1pZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVhYjQ4NDQtN2RjNC00NzMzLWEyMDMtY2E4Mjk2NmNjMDZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YTg1YmM0Ni0zMTY2\nLTRmNTEtODRlOC0zZGQxNmIxNmRjZjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATFc+eVlJcmQ+ecNyAGuBWRi6X64X7qPGjPR7CdD5CwZ0SPMtmotWdLWrnV+F6G\n5E+oYSJxoyeodAtVI7z6yYRbo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMoufxETHF2V0W\nVo3DSXNuOm8bUTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBe/4Lqws9bxtDXe2mNpphsLeqfO3+qLb+M/hOqFOrdBQIg\nTfjGfmrZMcm0XugQPj4D+emaR/RWmpDLOYtxeQkBau4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3248", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3248` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaa5mq2g+Q+gvDbqyCnkvg5/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjZTUzZTAzLWJjZmItNDg4My05ZjQ5LWY5MDJkNzZiZDlkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU4ZDNlYWYtNTIx\nZi00NmM1LTkwYTAtZTVlZjRhNGJhOGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEISYeiv2hmCUKYKDkGYZFOmxdTUPt6A4rYNaTeIz6M25TQffkwj+7rdejV1AB\ngy716RE0VeS+86VQdRTjxIY8PKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFL5C06h7Unf36KI/KKwRG65JMIUZMB8GA1UdIwQY\nMBaAFCJx8CL2q0+Kf/tEx7y3ODbj6zUfMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAzOs8RhIC9p1p2czsk9PLieXTzKm2CoJ+\nGKm7znuNqP4CIBX30b1anl67GpQsJGpOOIsf6y9yCwbGd2/H1CCawk42\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX1BoWQHtKULU2lB62hrkrVFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2U1M2UwMy1iY2ZiLTQ4ODMtOWY0OS1mOTAyZDc2YmQ5ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1sfYTVGTAV/qEZah+9z0n1mKXvf2AWW4HRW3OQL8J2yQp\nFt/KfbH6j47JoCOvKF5j219vTJakA9tX4FCWHPwmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUInHwIvarT4p/+0THvLc4NuPr\nNR8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDLnaYFJeQOkufJAbs4Tn+9f2Bpgva5c3gKWRkbrGrrUCIQDQIsqaDxe9\nIkrWLphD84TbSKh01aSOATci7WRSRxnzGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAW74phw6mmxiWQMIPXd3qcYXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU4ZDNlYWYtNTIxZi00NmM1LTkwYTAtZTVlZjRhNGJhOGNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YTBiZTQyMC1kNDBh\nLTRhYjgtODRmOS1jNmYyMjY5NDFlYzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ+oABLZHbsqA9hRvIEmj1Xd/1AzH8cpxnrKigxD+ESI0MmXBSpFcjfgFoqKe4d\nEELbC2BoUzmNcljh+4IMH4Mzo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+QtOoe1J39+ii\nPyisERuuSTCFGTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAkBTRt9hrXAJHuLWc34m+QHigHq1YshRcmjKPya5IiMUC\nIQCPbqP3HeTwFVvWJdOfHP065W4GzTPchfPigIGS7b3awA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3249", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3249` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISARmHWf1GRkuWGYuoFBssLGUGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4ZGQxYjc2LTM4MWItNDY5NC1iNjUwLTY0ODhmOTE5NmZjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWViZjBhN2QtYmQ4\nYy00MWNmLWE4YTAtYTliYTBiZTQzMmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9xyIqgYbM/5jxKICllDdYe3jBiVmqv4hyCK/G9aQPzoS/+Oe3BEVR1wZrukP\n0Z1hUIRiigtNqnTFg/iq3dYnb6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMfaROP0l4e3eqYGdDnHumZ7BliCMB8GA1UdIwQY\nMBaAFKDgprUiQI37/h3zbTlQLUDf/BnCMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiACF9aOV7lRHRbmCPnwi4KpsXYTAfiC7MLq\ng435GGiu8AIgNrEaiq/+Q/ZAvWEAzVHl7b+TgiaDFluxou90fk8/tx8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWQ2P3HPFb6ypKXuyPTxe6ALMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGRkMWI3Ni0zODFiLTQ2OTQtYjY1MC02NDg4ZjkxOTZmY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScnsPv0DdMWQXn8xUmq4DJRZ1SMiDqH8VFNqro6w8XvICG\nDZibkK/NKwbfWaM7dGReHyuxVY3PsfVVK3sA6l8Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoOCmtSJAjfv+HfNtOVAtQN/8\nGcIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOlUZ8etPfuNNMKfey/z75r5W4ca8q9ZrcfAMQjiKwLEAiEA+exccNlf\nxdZNkcJ/bA8JWnsJRrjxZikf+fhs/yd+wP8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVUlT9Mwii9r0H3bBSPJsx1+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWViZjBhN2QtYmQ4Yy00MWNmLWE4YTAtYTliYTBiZTQzMmU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNDc3MTU1NC0yYmE5\nLTRkNDctODE3MC02MjNhODdiYjg1N2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATvS+P346YITyH/Jd49APbFyG8h7SE9opg707dUpdGrhew+thrA5jB34WkWzKge\n6ULQI/mIRvpRQo5Lmb9sU1Soo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTH2kTj9JeHt3qm\nBnQ5x7pmewZYgjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBuTZfbI/RPmmdrE8vU0k+XbktlxuMMl5VHgJUDPylSxQIh\nAM3LKQxdueTKv2vva2CL7xU+hiVjHZIuZegfBk8bX9n0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3250", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3250` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAc6ixbep0SoOZWFSyhzgtybQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlNzM4MmQwLTRhMmQtNGY1Mi1iMzc0LTQyZGM0NWFlYmU3YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdlNTgzNTgtZDBj\nNy00OGU0LTk0MDYtMWUwNThlYzkxODlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiZVqUJuX7PXQPU1VqNaVLf19HSSakRUIkVPtpBqJ9MGh6QhyCudjEWKP/ZCZ\ncNfFeF2C0Vq3T/kpB5HPwqYaCKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQW0elWdgEzZuIY+6zMSSLWZiQKyTAfBgNVHSME\nGDAWgBReghT1uqyNSITvt/RRv3CkB2S5LTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCaOgy6nQr7Cv6qZndIJhdr/d1QBvgj\nMsBGyfEVVOChnAIhAJCEWtVe9KFF+GFJQdG3zXy/PsrfvAhJ116ekJUT1SQJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAad/NUfFLTUr7pz5eEFY9tSwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTczODJkMC00YTJkLTRmNTItYjM3NC00MmRjNDVhZWJlN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNpYNvWe8fX9oIOzlqZaiISA9CBH/YCmUekhI8Y1pOmg42\neNshQovVd4BOlNy5L/WZMSBuoNcKcrX5mgG0PXBwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXoIU9bqsjUiE77f0Ub9wpAdk\nuS0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJm4y4PW4uo9tAGQcIiocdjO4fAHJXePhBuQxQvH3OHjAiEAp8fYe660\n6Fb4nyBG+wj322MlJe06AreF/3gkB0Su3QU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAer1jJkmXTQxRSi+QZSPBLldMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdlNTgzNTgtZDBjNy00OGU0LTk0MDYtMWUwNThlYzkxODlmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxN2VmOGI4OC1jNTk4\nLTRlZWEtYWU4My00M2ZiOWQyZmY3N2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQBz0F6+eDU1sbbw8GGd8IGXelu3fWQ5qWk0s40cIxanMsnncOyrtetrX8L1tth\nYHzYOqHVJSUv9DZhpFPS38ZZo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQW0elWdgEzZuIY\n+6zMSSLWZiQKyTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAnyssRBS5uOY+iE7faNb2dITn4JRg4kss7LM8LwLhUmcC\nIQCqY6Bvd91fhZ+zs+hjSKQbFoKH5ByYEVoLa5FcG8rAfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3251", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3251` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAdjEyw81FftH1iQ65oDY+2bYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0MjA1ZWY3LTQ2NWQtNDNkNC1iMGEzLWI5NWQ2ZmJkZjcxYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRkMGY4ZjEtZDY3\nMS00NDU5LTk2NDEtYTIyZmFiZjY2ZDc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1Tn+eoN6n5uXFBg8+F1ovWHfXB4ZNqwYMYLYSivnQuu0Swb7HVuJ9vC3lZCX\nos/6LAhhdlI4UsVgYSneiEpXlKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGgtOZ/MaWBHoiKlaBQd/ccVrogowHwYDVR0j\nBBgwFoAU84rbTU7XZAap1y6SyhHjgfRbRbAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBc4LRlkkOR2pYz\n6itGjOZ3+o5u+i2t9wXnaa3iFdgXZQIgZybZTKES7aCrnLj0kkKfSLu5Zp+zG2pH\nM+PiTeunCgo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUoP2DmwXFHvQx/geKfVkHzfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDIwNWVmNy00NjVkLTQzZDQtYjBhMy1iOTVkNmZiZGY3MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPFQtCuRrBrP2NRrdwMqanHdKaUB3QfxpociBOhQf8Sk6A\n4sRAdZfcrKuyi20vDhdKMTPDKw3ScCHOLpbcMj+8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU84rbTU7XZAap1y6SyhHjgfRb\nRbAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOWSjksn17eriMxJUbzAbeDvfEVqkY1Hj1XsS7OFfiGaAiAWmj8/ewlU\n7Vh0qBofaAz3k7KEK8DDh/70TZNy97TEZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVLK+7UXvcd1r4PCH8sMXso4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRkMGY4ZjEtZDY3MS00NDU5LTk2NDEtYTIyZmFiZjY2ZDc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMTY0Mzk2Yi1jZTA2\nLTQ3ZWYtOWM2MS02ZmNhZjhkMmIzNjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARW4Pf5ys4k3/CpWDQT/cWN7Wxz0cHKi6luQwwWuyEDOihJ1Wpju+ZiqimM0gUY\nPOV4J8uV7a/8UMnmGjNDGJlZo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQaC05n8xpYEeiI\nqVoFB39xxWuiCjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiAhLhyDvgY9cgZehbNcLVCYEHdVQONssOijve2rt+pXwQIh\nAK6ng6CTLZYaRtkOVEKizMcVU8dM31ickyUSnLTsvY4P\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3252", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3252` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfTKAHkfDeSovbISw3I4Dhn7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwY2M0ZGM1LWQzMWYtNDM4MC1iNGI1LTY4NmYwNTI0OGU5NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmEzYmM1NDUtYTFm\nNi00YjE5LWE3OGYtMmUxZWE1N2E0YWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfA03zhc8jAPw0XMBvlGvC/FyJ74RiMmZOmI/FLefDaqECqnIeBk+OaKoUB/t\nBu026YLe/Nbm+jpngecdozQFHaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeT6dX01HO68vW1jkvh1FvE+g8pUwHwYDVR0j\nBBgwFoAUp2WdKyXSoRLyz7t/YKem2hc6agQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAlq/lf0rJ2+dZ\nnYprqIQpsEm4aH2IMsgDu12ckVmLodACICteu3dpbAry4rgJfXLLMpzbfFxEE6OR\nh/Sh9fcKZw3f\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaB2HHyQHEd4HaFDhufRZYfmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGNjNGRjNS1kMzFmLTQzODAtYjRiNS02ODZmMDUyNDhlOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe/mhGCxDlnrkmS1lRuOtoa0aZ4GXlurWguEcdL8oJBqOe\nh+G3GPPHyjgyY0UDsWID0Ii7W5Y4qyYkqYi87CMEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp2WdKyXSoRLyz7t/YKem2hc6\nagQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALVMfPEx+AbdM2m7o8DyFARAn3MiHZFMz3c/+2goowrpAiBIpawYYo2J\nE/+uUMB6lZmSvW7NS8rrUfqVpncTVmHIYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATh7H8KuY9RErqArVaQ6j617MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmEzYmM1NDUtYTFmNi00YjE5LWE3OGYtMmUxZWE1N2E0YWViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMDU3ZDQzYS1kY2Rk\nLTQzZTUtYjI5NC1lMmY1OTk3OWUwYjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASfLA7vOaZYceF3Tss4OlNC5z9H820mDy3j4dGXepSn8d/fz/xsubPpnm4rd6Xg\n0SOF2uw0wEDZOIdWgL9FUOCVo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5Pp1fTUc7ry9b\nWOS+HUW8T6DylTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA2BKTVkBkZE79/5x9KlHCvEJjUqhB5E/xWaAo9+WZBvoC\nIGZ7gIQquMhDiMgY+xN3S6i37AM2n9go5fGWMNL6kwoc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3253", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3253` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAcLE2z9ajY4kra0O1JZc9VeAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlZTBjYTg4LTBmOWMtNGFmZi05NWM3LTg5ZTI1ZmFiM2Y1ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IxMzJmMTItMWJl\nYS00NzJhLTllNTItY2IxM2JjNDViYzkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYaVDPgDjLdwGK5d1YLRA/RHpEBdkSval8bXq1UuZW5BenrfoJlkjfsYVZ8lv\nah5tvvDikZcKRAGPup3JO12UMaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOX7GgHx0LWau/eyD9145zq6V1R0wHwYDVR0j\nBBgwFoAU+YWRb+5s23wFwNHyD++yHON6xB0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAvBvUYdNKhkSNJbvP0i3x\n0Z4Bj0U6lUm9DcYB1FF5ipECIQDp9/r4eEZYxvN7HhqGCVTd62PAr5Hs600YXMGL\nw/fTyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWzY5ETTC3xXgZ6zBRCPtPYIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZWUwY2E4OC0wZjljLTRhZmYtOTVjNy04OWUyNWZhYjNmNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThV7Y0nrvZmpMdNkhW2OHLbJ4J8m+I/DClbK7ZlmpMhSFz\nk13WlGqtgGelKeLcT5X1FgjwHrPIbXVXSFfa6MxPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+YWRb+5s23wFwNHyD++yHON6\nxB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMXqV16x+Jq82F4tNcrlxAedX+JuMbTPPXDKoIhsXZTSAiBADJEpVyP8\noDEJjks65FHZlKxdSXGBQnCsy429yeyOAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYSGSNd6ZSEepWRui9bitwbuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IxMzJmMTItMWJlYS00NzJhLTllNTItY2IxM2JjNDViYzkyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMzIxMDFkZS01YmYx\nLTQyYTEtYjllZC1lMTE4MDY3OGE4NDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARtAlvc16Loz2RyPUYbStRfFG9B3/daNB8qTlGLOz8C11NBc3BL3kiSoiFYZ5Va\nasmFNZSRKBUXTwkD0ni00Li1o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5fsaAfHQtZq79\n7IP3XjnOrpXVHTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiA3X6FX22TIwzxPA4hJJOTarZS/kMdDIYtc8ezdNbghYAIh\nAMUjYe+ANhFSfmbb6icFUzUjHpUjP8iMxDyNNt5Xz84u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3254", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3254` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAW4rKwOaivHqBz8tDYNdpVoRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3OGJiNWQwLTZhMGQtNGQ4MC1hYmQ1LTU2ZjIxMzdkNWNmMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM3OGFiNjEtZDc0\nOC00NzkzLTgxYTYtOTA0YjkyMjA3MGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMmY1vTSECP0Nja+XJ8XNxIrnlsofCb3YIFnrwdoLRrGPOxaJCJh+ybL2iOKZ\nlpD0pBqbuWSrYlNVsO/HBO9RRqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbZtco7koJxv0iLVNYwMOjR29zWowHwYDVR0j\nBBgwFoAU02wnQ/3eX8z9U9Iv9uul41qMIv8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiANW2Ci\nbMrW9yH4EhTIu5VxUqBizgFGF1FIbtbAb7nEjwIhAON04+VHVNdSnouPY+FxN2ak\nfqDcAkcO1kJWuHYjOxmd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARNFl8a86i+JHLX7VPh5g4HGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzhiYjVkMC02YTBkLTRkODAtYWJkNS01NmYyMTM3ZDVjZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJAsEQhbf300nrqJDNLO/qd955BOClLLo++aOsb6MHC9k5\nAVMSwlmYup+rYnYHESpmigBYZp+50dbrvXAzreNKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU02wnQ/3eX8z9U9Iv9uul41qM\nIv8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKYq/s6RfCOaIIutZhoQ/jgM57RlVgaslvDONv6I8ZAECIHRMpJu9fQSJ\nxctXgaeQgHUS5tTmX+mUJBoLGyobVMm2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAeo2jfqWX3gG24Q45Kf/gzbnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM3OGFiNjEtZDc0OC00NzkzLTgxYTYtOTA0YjkyMjA3MGUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZmY4NmRjMC0zNmY1\nLTQ1OTItOGFhNS04Y2EzZjgzMjQyODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ4d0puDnj3otSbF9XqdOQygaE1sYejSSe/5c5oTO6N0x2LyCJQ2XBbavwe9Mr4\nvkEKL3gb7AWQ1LqpHhEPxnLCo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRtm1yjuSgnG/SI\ntU1jAw6NHb3NajAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBfcG8lAGJXaLJ0CugXLBPAVgSKlawmt9MI02xVt944RAIh\nAPThocYUMThJO6nixH6guJ9Dz6TVtS9HZ4djXeAjkSNO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3255", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3255` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAXodMswRDkEPIikiYLIgAx+5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzOWVlYjM2LThiNDktNDc1NC05YTMyLWE1MDU2NTI0ZDk4ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNjOTgwZDMtYWIw\nYi00YTZmLWFlZTQtY2U0MDhjM2U4NzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEorMPwSNc39AT8QV1wfpq6UgaN4ksmfOhTvJRGqJUmHLaLlG6p8xsD02STRWN\n/3dlj7RXzckb1ga3zkOXEE0LaaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6JXVka1Sju6ykWlc+PnT+E9E6NowHwYDVR0j\nBBgwFoAU/mGFihm1cJ5Eb+OSUI86WT2wlhEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA3/PM\nCDMdP88wLWdip4f/nVQkbUYZlZo040R2bKw6cA4CIQD6MosrGGIUjv1xacxzWFp5\n3RFnl6LbFljqeVW4yPEUXQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfR7JgPU9KsK+49nmqPWfueEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzllZWIzNi04YjQ5LTQ3NTQtOWEzMi1hNTA1NjUyNGQ5OGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYu+DSqqW/JGhCrM7nl3AePkdxE8vG+Hhw0+L+vlAkRj3U\n0a0f9mcHDPPUAYxYSN5gzLiSKsERk78GqIAu87evo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/mGFihm1cJ5Eb+OSUI86WT2w\nlhEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKUWdnCqzQs/kUcgmEyI4h3mIlL4Apx+lkoOGkgrK1QyAiEA8pcd1oAx\nAfIRAi8UDL7GwcfM/wns+if24yP1tZ0YORM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATSdFKWjTBuBZGand3w1lBbtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNjOTgwZDMtYWIwYi00YTZmLWFlZTQtY2U0MDhjM2U4NzM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZDQ0NDJlYy0xMzMw\nLTRhYTgtYTI3Zi05MzFhM2E3M2RhNGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATvneFZTjzTVA8Z3K/8jvlAkb8awXJGGDWc2rcGVwF9V0N8UrZ5bTNp/F/R1x2L\ngWZjxjt/5Y9lwHLQMS9Ji9iRo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToldWRrVKO7rKR\naVz4+dP4T0To2jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiA/U+OfdF1v3pDc6kP5WaJxD5m0Z+WJIp637exxESD/UQIh\nAN7TdMT/7pXBnwd+AWZ5z7RY3SbHvVA1wowA5n9C9cKs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3256", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3256` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISATc7jDNPJYk84iIbYEZNJQqTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkMTMyOTI5LTdiNTAtNDQxZC1iMWYwLWUyMDA0ZTJlYzEzMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFkZjBiNDUtNjRh\nMy00ZmVjLWFkZjktYjIxMTY3Y2NhMTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7fiIkiVLdUoobVGMObO1+5YGPoNO0qL52jHPnG4gSmc3JbjWh8SZ6vHLbu7h\nErBLPF1imCI5VHbDNvpdg+FjdaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIwa4UEQfbO1h+aMk5AS2x1IQpXeMB8GA1UdIwQY\nMBaAFP+Jz8YGu2sKrOMF/ZNcByCaw9eDMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiA1K3Fb9aBdLl8GbfKNOMY8Nii18YMUzG3p\n7tuLmlcqawIgMtlQ6Y9HbWqtMulLFtd8jUlU7GIRH59nwpuTpTEf4Io=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQGvJcbyBNmiw+ZtaNMoIedYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDEzMjkyOS03YjUwLTQ0MWQtYjFmMC1lMjAwNGUyZWMxMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToGJZFhdWeCNIv3b5dIXCsTZN7sT5UCCmuN0wZxjuu/3X0\njR2XCTsCcRooGgs/K3UPypUBLQRq2yQvhn5QVyNvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/4nPxga7awqs4wX9k1wHIJrD\n14MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQGjYCtSW4naR1hw3a5s69YgPNPk8OMITX+j5TA226xYCIQCvYsJ1i1W+\nuRKnuG2aW6oh+YkSQbZ4Opor7VTH46BRjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAd5KkTkMNY1dk5marzUDUszdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFkZjBiNDUtNjRhMy00ZmVjLWFkZjktYjIxMTY3Y2NhMTc3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZTZjNDgwMi1kNzZi\nLTQ5ZDItYTJmMS0wMjk4ZWRmYmZmZTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS8MtTetS56HzSFW+WwXuBZxUTK4VeUUY+m94s09XlfxIk/O/oDBTvy8emsgKJo\nG3wgaGKxX/axyYgLHRolXeuQo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMGuFBEH2ztYfm\njJOQEtsdSEKV3jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBBouCjfY0XkQS7hrwStiH0MUexAVGLSkupyJfTYuWEqQIg\nJLHr4lXD+qDGocYqmsHGFS4eYpn4kSSbwDaayUpugQ8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3257", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3257` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAdEL3PR+abPiVGsD4a2nNTj3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlNzJlOGY2LTM3ZDMtNDYyNC05ODNjLWYwOTc0MTAxMmVmZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM0NGJkODYtZWY3\nOS00NjUxLWIwOGYtYmE5YmUzNGE0MjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsOCbWTDSoWcLVGESwi5y/QtUkTuVh7cfe05NDVqh26RyLsEVSszrnc/iH+MR\nYTHpj1wMa6KoVtIcTnOO22BIkaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqAQXc99wqdAfDiR4khvq8MiO9tswHwYDVR0j\nBBgwFoAUO/MJlY9ifP56fYdUC+zbMdls4N8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgFetf+vNz+gWq\n6fbcFsMc4xV/N3+SLSq6YDMsbYLlsIUCIQDlrPFdIo+4txUfGZcoiFxV4zDklVBS\nNFpHRyJahSs9SQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARsaPB8uCdCuDQmJrll6tH4NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTcyZThmNi0zN2QzLTQ2MjQtOTgzYy1mMDk3NDEwMTJlZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcHiAWIrVSzxSJrhdoRBqbpI/6TpDqARjZzzuXGYZhvmJE\n8Sy+eEFszu2gx7QrGeltU70G/VxT+ThxQAjvcOyoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO/MJlY9ifP56fYdUC+zbMdls\n4N8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPTotAG+sLc+1gKO6Dgd9WpPqGgKY6SRH3xu8QNsx7VkCIE8avVP7v1Es\nB2VZa4eJjd836/7U/rzyLpedTNH3GAPt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAb+NQJixTZ2lInG6FRWgfw+8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM0NGJkODYtZWY3OS00NjUxLWIwOGYtYmE5YmUzNGE0MjQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMjAxYmQ2Yy04YzBl\nLTQzMmUtODBjZi05OTE0MjYxNGM3ZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ2zvwu2gDOlXgEKIuYiUeUBCS8Sv/JKtn3lId9X1ZEFPuwX5i7CCurapDWa3Wq\ncmc3Xm/Kig931NwKa4ApiWwEo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSoBBdz33Cp0B8O\nJHiSG+rwyI722zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAo6JjbwNP6NPXy6wXPo3aYkHe0ZSdaSPC2iJHF10ifVsC\nIDLxhWmws0jOEnWiDA5P4uLoBxE/qx15yrenBjwTn/8s\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3258", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3258` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISATKpyw8/RIVSgpUMF8D1vrK8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4NzkzYWE2LWJlYWQtNDVjMi1iYjc4LTQ5OTVkZTU1YTBmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdjYTU1ZjUtZWI0\nYi00MDQxLWI5OGYtODlhNjJkY2NiODg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXvw/ONlUey+q8k8ufDLEZkBoPJvuaRr+Y494DNxVfLCA+SmhYRBHKXeAb1Wy\nLw/jbKGoYNuhgilqkRcLKQaR1qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhwfepK0+Q96QsmK2bPYTmHTMJs0wHwYDVR0j\nBBgwFoAUJyOHg8ajKMEix7ivZtQry56qUb8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANWcyu/0xAtO\nAgD5VZgg7REmRuq7g3XMzn2qZXdR1jcLAiEAy98m3T7G8ZajKtHZgn7+XF0G+YZI\naL6ELyDe48IjdS4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbIt1VO3R3u3fpel2GKHJqSbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODc5M2FhNi1iZWFkLTQ1YzItYmI3OC00OTk1ZGU1NWEwZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzPT3dKRGezJ1JSTPcy5KxbXDvj/d9pF5++8aJZy4oPv2+\nJcnFMGExGhLHjEx8s8i7oTbHJ2gvrw4dLKt/9cd9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJyOHg8ajKMEix7ivZtQry56q\nUb8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANEiPDmrFaYpPH/T7nK1M7PZ/ndmb9eGsfLkmv1KpJMEAiA+rqjMWuIe\nyVGsSXaARIJy+Wpbd1EpQ514YIIveUU+Mw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQDO2S6NcckpApm6Kq/wSB0XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdjYTU1ZjUtZWI0Yi00MDQxLWI5OGYtODlhNjJkY2NiODg2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNDk2MmJkZi1kMzg0\nLTQyODEtYjE0OS1iYWZlOWZjMjY5NTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQEHzAhefUlZAMUPuuVieVjcT9ic7mUQBNNm4fU2PXIx0Lbi0/7qvXQqCdPbWiC\nwfmxpBVKG2/H44CYDzL/Zvtho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSHB96krT5D3pCy\nYrZs9hOYdMwmzTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAoCYwcFqtFLHOXvX9FBCeX1+nFzIyaCJnHA5FQ86tZAQC\nIC0mzgJq/tUIP/Bp8tossjCskbq0BW85JaqIb0pVeRiV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3259", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3259` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdGeFLuIt92lUFIt8d5r/EgeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyZDNiODkwLTExYzItNDFiMi1iN2M5LWQ3NTEzMGU2OWIyYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDVjYmFkN2YtMzY1\nMC00ZmFiLWFlZDEtZjI4MDNjY2Q5NjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFP56t/ic4W+Z9eIqCoKaA2nFp8NZIBxgZaaaAH22w+mUxXApzFAFnL938hI6\ngibqULOzsdIFEmeRD4ars2W1LKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg+cUrPXLj/CsgakKiCGr34NHinYwHwYDVR0j\nBBgwFoAUNwqM+N7TXrkoR0VMlNgbhhk5mc0wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCWtP8DZzm9\n4D3n0xn5HaG+ZdzqRo5EhWeToUXcuyZtWQIgMbb42T3kIm6/4RPgZz/pNI8LgQvU\nY0tWS4xXYgCzRG4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASg+UHPWyS+Id5svvGkwVFjdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmQzYjg5MC0xMWMyLTQxYjItYjdjOS1kNzUxMzBlNjliMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6iGXQegG6eP6vnmua6/iW85nfjY/AUcOF5W291nehe7MA\nrBtUORgkwCCftu5BhriKuTKH42a2GoomikWPk/3Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNwqM+N7TXrkoR0VMlNgbhhk5\nmc0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMAc/8UVtj3O5qNjXrzNpM3LgMPa1yyIyp9YlaVTGI0yAiEAud6n+a7A\n059+NrhQu6Cnwsq5dqEs27SN0Bq+dlODt58=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdGaXVfAfzSe4mA16R7Odon3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDVjYmFkN2YtMzY1MC00ZmFiLWFlZDEtZjI4MDNjY2Q5NjhmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNDdmYTk5Yi1lNzc4\nLTRlMzMtYjc4ZS1kNDI5ODIwNzg2YzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQDRrQ+uZWrS8WZhqPrEH/nul3njXihL4OVhoQNUXXyPEXtCxQMnpwVetG/w4Ki\nfD/IAw0q1qakAjuvV4d7s/8/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSD5xSs9cuP8KyB\nqQqIIavfg0eKdjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA8nyZUTU4QfmrsD9uQXws/AIJ2Ton9WtYPVSQx4pwuuMC\nIAlMaZPrfOFtFK1KQ8JVt+Jys4oGo5pmFfNwvIU51Y6A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3260", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3260` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVjSqNN9k68ajt/3jAN/dwDvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZjNhNGI1LTI2Y2QtNDQxNy1hYTNmLWFiMjkzYWY3ZGY2OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY0YTU2NDAtNGY4\nMy00ZWZlLWIzN2EtYmQ3OGU0MzY2YzM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFmP7L/uMxXVbabc1F26zh1fQxlPIZ8Jtfx0wU0boxocMpAowGLePuF1U/Kcv\nVpqTeN5g7Z/1TIRzzoBBmJVxsKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6AaofeR3fXNK47blUgt04c3WDFwwHwYDVR0j\nBBgwFoAU/njidwP+uvEbDyzdJk067LJq898wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD3rpOwe8BbV5lneZfAYgLhqzFuFGC2UYkbMNf/L4YfbQIgegPO6BcU9x8r\nm4DcdgCNrroaHvdbv4RxHFUt+ZZEiP0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAevzh5+Ak2YTXc+LsVwZHAfJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2YzYTRiNS0yNmNkLTQ0MTctYWEzZi1hYjI5M2FmN2RmNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARa6AzL4XNdXkBXLl7mqRGGNqLo2E743wi8a+Mk6h+ozJJu\n/1ijAQnpylMxSv0a94sA/7gKKYcORf/oyMxLCLRlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/njidwP+uvEbDyzdJk067LJq\n898wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ+I2LNT7ZZC6jutBGDooMW5Z7OmM9XMZQYc+jobL6VLAiBLJhlLDsKm\nJspWqsYBN49WD9neDYNo/1LwdOPkn7RJog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUBJrGSanl2lEIibGLQgt0jhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY0YTU2NDAtNGY4My00ZWZlLWIzN2EtYmQ3OGU0MzY2YzM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYWNiZjZjNi1lMzA2\nLTQwNzgtYTllYS1hZTY0Y2FlMDY0OTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAScxMrDuQ6BbScTyLsjMZfrfl+TH4KyUz9W+Jbr95Ef3lwIrwRGFnxP8zBUnQgG\nokUxpikOfo7Jl/cU1h7rqHrGo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToBqh95Hd9c0rj\ntuVSC3ThzdYMXDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBp6QEh4pe17uF5eawYw1bB8R/41h19u55B2INjTd60WAIh\nAMAlg+hLmWOnPkhhHZTTzROuRrLxGe9Js9xvpNKV8u8B\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3261", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3261` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZMbQ45XTL/SbKKqqbK+ptpGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhZTRmZGY0LTQ4NGEtNGVkZi1iZWQ4LWJiMTBlNTU5YTZlMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU2MDM5ZWEtMTU5\nYy00ZmM2LWFkYzUtMTI1MDhlOTZiZmYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5e7DYObLzgJgtkr+kCiiloCRpXJIDLr6BuLh8EPobsSh+Zk8cMhv86xnh60c\nYPQcG50jRyCKPvE9NOTMT8i/w6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWwZHcq2iUAIOGBwik63GDYxqTpMwHwYDVR0j\nBBgwFoAUYHgKPclkuiUj2JFaZiMlGl8MSv4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDSxyUeZtfJ3akYbe1YL5mn/lmfmx/FHApINl/rKGNQoQIhALjRuZpG9HoK\nqay/f7kphM2BVQOPeh4kSigD+8DEMpQX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVGrVGxT+ujWVFNjzLp5TztGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWU0ZmRmNC00ODRhLTRlZGYtYmVkOC1iYjEwZTU1OWE2ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4/7yGKnSEtD75Tc+ktEw0DFFUUDwJUUA5IAo0p2QITjU5\nu8dtvRaYR5mDjFj4lTiojIKKhXP6T4K2ZwMZMXEho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYHgKPclkuiUj2JFaZiMlGl8M\nSv4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAONcnXnR9DiHzy1uNrw7bD6r32Ie2N33W/G4Lk3S/OJaAiEAhoE+e6gD\nwCq6PwoW02CLBMtF1a9VQd7Eo1wV+1VmXxo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAafvSbG+5U9iKDDrYeb1RAORMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU2MDM5ZWEtMTU5Yy00ZmM2LWFkYzUtMTI1MDhlOTZiZmYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNDU4MGRmZi02OGMx\nLTQ3YWUtYmI3MS1hODE1OTI4NTVhODYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR7xdjIiRvEqRic6LyzWTV7FRKpmQ9KLvXbPmWB1NvqtvEyGavvrF8FgCIBzYDI\nO7YRDDl9BBRS8OktmhMxeYxKo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRbBkdyraJQAg4Y\nHCKTrcYNjGpOkzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAPQ71kh5iKyB2g+Mpfly9QD4vz/8LWJgb0O0lUMXoVBAIg\nOQiWc7Ldt2ecsxZ8tn5ACVTKvs2qjYGVyE6kbkJo950=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3262", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3262` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAQSPOVXbduzzLzH/AunLT2ePMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3MzVlZDk4LWE4ZDctNDY2Zi1hNDEwLTgzNWE1YmIzYTExMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQyZjJkNDYtZGMw\nNS00MzY5LTgyOGEtNzJmNDNiYzU5N2M0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQE84IC/wRrElGjZAnrzNtvfn/VdTq48Mn7HtLgsGnQ0Kg/19Own4lGkE9wDu\nOW7wdVqvr5l05OIULhlZrWiZaqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrFf4dql2c+lzUdrAKwLBw564Zb0wHwYDVR0j\nBBgwFoAUgQUqDs/E47EmVXis1BepGfhnu34wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFXd\nQM5kBYlco5+uKdJRlORDOtScaUKgpsQE5Ql+iipMAiBsvLptLF/boaA130bpp2WD\nyEJxGTtJW5OIT9HuYZGeGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYV2cV2gjkR3DO/dgOBiKSFfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzM1ZWQ5OC1hOGQ3LTQ2NmYtYTQxMC04MzVhNWJiM2ExMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0NdpjSuiTMGYkoRCntQD0p35fpgQ5yB0lNa9DG7dc66lR\n6htopj/Fz0FSF36tWqYELXYOJvJ8EZS25PZ2o+Y+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgQUqDs/E47EmVXis1BepGfhn\nu34wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBbpfcfp8Pjbf6Zf2wHqPY3BwbevNQBn5Wr4LMw9vdL4CIQDuaonggq0m\nyIY9VxC2+RwV1+bSw8xOW9fBbVoBO1tr6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAeUzlwZMk1KtXDek003FYuEoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQyZjJkNDYtZGMwNS00MzY5LTgyOGEtNzJmNDNiYzU5N2M0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZDVkMjUwMC1mMjY2\nLTRmYjgtODc4NS0yMTcxOGY2NjdlZTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQHxHASXQk4GHVLNSgjXVqoVYeikwAM7hOHWbxS77ydf+T719CKxDIyrGJrsAYB\n8bth+FzS6hIa2BjNptzeTUvWo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSsV/h2qXZz6XNR\n2sArAsHDnrhlvTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAoqzGtR31KN1hahsgFzTlx02MAl7xOAmB53CHRnpxuGMC\nIQCqmeC7i8tJp6FLjjh3KpeoAcm+VsHdqJ19VZ9k/SoTow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3263", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3263` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAa0b3vQIst2lKJjFWXeFrKmdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMDc0YzY3LTk4ZDctNDhlYi1hOGQ1LTBlYTUyMjU3MmJlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzMxYTcwOWItODRj\nNC00OWUxLWJkODUtZGRmMmQ1MTdkZjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4kyKOuqSuuIg/OAns905n3+wHyHDt4xQnNCEx1oBsHHkEZHhXzVPC3srvAij\n5sDL+/1lt5egXg31ymRAejMAkKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPFLFamnj89WndG8cHFb1Fq4+d4wwHwYDVR0j\nBBgwFoAUStW3Fmte3PLlv6jMhs4ZzgTSMNIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIF/Xcs3yKGA1wrlGbZc9007wTUvdThUI7t2zn4NWVwMrAiEA6UX6\noBJ/9DJNf5BUI8zheJeBrrwMDuDf5C3ETwEgSo4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcTnzMUPHtxY9OdSsvS8XRAYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzA3NGM2Ny05OGQ3LTQ4ZWItYThkNS0wZWE1MjI1NzJiZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP8NWSXpz65IDbDmsys4TvqLsAhjcAQTiDI2ezrPA8HZnj\nMluSGWmTK1Ns1d0/0khOIZMiFvBxBbp7WKPWdcpuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUStW3Fmte3PLlv6jMhs4ZzgTS\nMNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXldJCAU+FINo1lxfYN5DPnezvjLvmjIWqDxwUSYs9qcCIQDsqlXf3QzN\nJMyLCX0weXUSqvHDTP7pMAuDzui4kK9Txw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAS+9IuyHasV90pROcg87yubVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzMxYTcwOWItODRjNC00OWUxLWJkODUtZGRmMmQ1MTdkZjQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYjlhNTA1Yi1iM2Qz\nLTQ3YTktYWE1Yi0wODdjODA3YTAxYTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASECTTuCLZggq/aitzcaeOUod/3SNvirh0APnrLB6Zs1e2E+qCk4wd8yz6Zdae8\nxEZNjb6iMSGoa9hMMmO7oIdpo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ8UsVqaePz1ad0\nbxwcVvUWrj53jDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBoqQn30/luQ2dJ15ZLR4V5kmtFjvbLLnMJJV8LGwk7zgIh\nAPzUZhAVK0+Wf4Kw1yza7ZXV9eserOyZoKPwoYR6DTsn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3264", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3264` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAZZhncsV2S/+FmGNuFf1ZEmDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5YjJkYTg5LWQ4YmEtNGU3Yi1hZjU0LWFkOGU2ZmJmYzMxZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmUzMzg2MjMtYTBk\nMy00MzI0LWIwMWQtOTNmMjlhOGY4MjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5/gXSrDn0khoAD0Lvg58vJA2nOa3sEA3OF66ZOmZUAyPIcj1cLHLMqsyQ+QF\nnNALZPcpAGdiZ5/h4AAtCkKfBqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBM2kG0ZoER1iVi5/JMjm3HTeAPkwHwYDVR0j\nBBgwFoAUKxyUU3sZe0J3yu3dA94gaHfkcqwwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHfEhj7gK421VcA0+pb3c+ZdMWvDVP0M4F1dvdNFzepLAiBu+WMJ\nNLYbnNguKSUsTWdV11xnvKemLTiE15aHP0qPlA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU3GNLz9rri0PTUmt/t1b41FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWIyZGE4OS1kOGJhLTRlN2ItYWY1NC1hZDhlNmZiZmMzMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZWM5HwLKJGVxLsYzV1fdaKq56KkH/1naDVERVU7VoUEME\nQGwTyC8aAcSkzWqMhw+OpryuaagN7Hmg5CtyPBO9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKxyUU3sZe0J3yu3dA94gaHfk\ncqwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIhrbqElJvhtABE+7jlyWPrFaW19omkcKpz+HxlZfPHeAiBnApGQ0GyP\n0bUs41i83pUQyIbUoPE4+x5h5QjmQIBMlA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbZE0UUuX0bNPXAs522TkK2oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmUzMzg2MjMtYTBkMy00MzI0LWIwMWQtOTNmMjlhOGY4MjA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwODdiMjZjZi0zMDA1\nLTQ4MzctODI3OS1hMTBhMTNmYmNjZWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQhb6Wj3tr2MJ1jPGJt3+SnwQ6+AH0UuUmFpAYfoi0uN7pvCxDgAEizju/l1ZuY\nGG71qxE6V6eEUVnTs1FiyQulo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQEzaQbRmgRHWJW\nLn8kyObcdN4A+TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBi34N4vu2l2ZIBne3gO/VJHkfDZ6BUsA+UIe8/PBpMlwIh\nAMNOWxS+xYk5sXWYqHxl5g4d1JqSshYcMdyyzJXNX/oz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3265", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3265` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATxO98F3r3AMGVTG6+0uICT5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3YWI1ZGNhLTFiNjEtNGQ2ZS1iOTU2LTNiZWY4YWRjZjY2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGVmYjJjZTEtOTY0\nMC00ZmNkLWE2MjUtODM0MDc3ZDAwNWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEL1jyDy0GIav43a1nCGYm5870Dnvz/vnlMcBrcxzXiFfwTrQgybYDprbMcvg\nItnz0lMSk8P+ROmgdhjFKQSAXqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGU5y4lvYCeZUCX1zV/v9+9gFKMIMB8GA1UdIwQY\nMBaAFKAxAKxUnI9oDwggnZLLfC74rKZqMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA7bwYn1/fkInHdqTYhKxVuVMzXScftdqt\nDmX+4Tkj/d8CID7DnVjizx/d5sif4APuTO9FBSFOhn4y8DGWB/xgjut3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVlpGCBA6Lc4zxyiehu65+DRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2FiNWRjYS0xYjYxLTRkNmUtYjk1Ni0zYmVmOGFkY2Y2NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUuSY0oapqvR4DaIJmtcNHrwumnRcCffqgIe2MaIanGjEO\nFl2rYMZAuykPlp8ofTgbwp/aYYMD4qCO7kqKizkAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoDEArFScj2gPCCCdkst8Lvis\npmowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALMVNKK9faa5sXY0CobKwe1n5IrufpdRdXUcacgCCNrwAiEA4bce0MaA\nK0Ai9lIHc3PiLWjrczz+qBnwP/mjn8ZL3YY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATiZa3csjen+Tzj+6wIMPbW+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGVmYjJjZTEtOTY0MC00ZmNkLWE2MjUtODM0MDc3ZDAwNWQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MjBkZWMyOS1hZDJi\nLTRkY2MtYmY3OS1iNTYwNDEzYjhhNTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASzlOw7MR5UB0h9fK5nu2j8Cch/3QK4yJnfAz9jKzQrv69bu3kiPFm/OQXHE3FV\nLdUk58OcGBCcGzG9GGGbyrH/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRlOcuJb2AnmVAl\n9c1f7/fvYBSjCDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA8+d8jKftkVE3i+ckcWFrLjB+E/FqhqYLi1Dxgg2YZ0YC\nIGiukD7AyDObuoB9c54Qxd5Rh5S5o2QhW5RLljnG6a7F\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3266", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3266` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISASkeN37bTSuVgNaZWwKUUBGfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyNzUxNzE1LTQ1ZDItNDQzMC05NzI3LWJlZGE2NTAxMGY3YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmMxZjlmMTgtYTVh\nYy00NjZmLTg4YjMtODQyNmY4ZWQ5OWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn78Prq3ya9lKvm/AmVTYIfKA1JewGX+gFzWlacrgQSLjpTIKJgKnAVg3gTgd\nHRnEOnzhnYRPbLEcTSnuvTmD3aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeCcy4KyR3uTaIiaFdWca9RQDLAUwHwYDVR0j\nBBgwFoAUrBxa7t7M+jvmQAIfil8+mRx+rxQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgMyHXMXZ4fuHQ\nV5K+c6L5WEep2DIy5epoOiGFNgYHcXsCIFnuScDmtDe23w6MS97xOXBtJwhNO7Fj\njA0MJ+LDRdtg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb/kGca/u4OWC/qqmlZnz9YuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjc1MTcxNS00NWQyLTQ0MzAtOTcyNy1iZWRhNjUwMTBmN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpFb5BvC2O2Tf7KuEifTPAJRATlvdBdFzFObVsaRX+mpv4\netnahi7xNJUO9OQ4oekUNeUaXhXpGhxmSpDbt2hVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrBxa7t7M+jvmQAIfil8+mRx+\nrxQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXeYtqeOAMgmJXJmC5gI0G6zjDSuDLLIS6k7u03+gb7MCIQCKVbAdBwfn\nzguV2iWsY6hCnkgRXcY5TxbYikWlXHirSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAR4LKr+gAuDik4OFHcQ/Z5mTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmMxZjlmMTgtYTVhYy00NjZmLTg4YjMtODQyNmY4ZWQ5OWY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYWQzMmI0ZC1jODE3\nLTQ2ZjQtYWUzNi0xOGFhNjEwZDJhNWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQw60+o1EwCMxgENrgHE/aaqOvOy2BHhmAEa7K4xmC7I0WBvtfd8CExCvKiAW/6\ndMhQshqWxXTVv+zV4fmnk4VGo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4JzLgrJHe5Noi\nJoV1Zxr1FAMsBTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA2TDtQNdoV8MFhMc1N1Y2DaMoCE3h/vBDaXz9PFZD3U0C\nIQCe1F9UWqxTHAkaJ/jp2TNz591v0jQbdyQCRP0GBlioag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3267", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3267` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAViVKWjE5HTbUdpHYlzB/7pqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzMjU0MTU4LWVkNjUtNGJlOC1iODVkLWJlOWQwOWJjZWQxODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I4MDIxOTYtZmY3\nZS00NDMyLWI3YWMtMTQ2NDhjYjcyNGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDR9+DRWtcO27R4levAjd12XnY7BlxmFp/DFfuvf9rMIvFFqHTtNgZcVm64Io\nnLVaxmDKCSK30303M8QFIWzKDaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhZKoJ8uMZT3GKv2Q11FpuN4LprMwHwYDVR0j\nBBgwFoAUh9YwWPD3zgOqYnK7XBBZBK03qU8wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgJM8FcJiJRZ52\nEPzIYh3WWxAKWOnFrL/E4rK/LJ6ESesCIQDkC6eaYjmbVXXN8jEmbM1nmZYSj9Nb\nTHn4USqmJO/D9w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbt3U+eho6KoGzYP8LRjPDP9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzI1NDE1OC1lZDY1LTRiZTgtYjg1ZC1iZTlkMDliY2VkMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvEOgN8+F8+wjs0iZyY7CPq3Qjo7AgVbX4yJRzvp0x3Hvy\nqq+REdGVeQrBB6VMsIN/Jiv2bxPJBmj2aVcvyMU6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh9YwWPD3zgOqYnK7XBBZBK03\nqU8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALVExNZf4d9vI4qBxoRxEdvQmYnqCrCvyuK+tm6x0CLuAiEA97kTraJt\n+dRedxLPSPC25psFgGBpN+dmzu63cdl9QPs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAV/tDb625UQQXiTVLQYFa2RrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I4MDIxOTYtZmY3ZS00NDMyLWI3YWMtMTQ2NDhjYjcyNGE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YTI3YWMyYy0wN2Uy\nLTRjNzMtODM3OS1hNTczODY3OWQyOTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR7DGeIe9ewGTbw/c0DRu2xvT3SdJ+Qy6dX0yE/HpFtPnPa7LhZiyLs5XbRbDoY\nzePTbzD+URA9Fpod0oH5w7LSo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFkqgny4xlPcYq\n/ZDXUWm43gumszAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiADj7jlvHD4DsXmAbewu0XlZWEjoFl57uo5hHPnYzGlzgIh\nAM2/0y9i4nh4V/njcqWhoRGFewE7xPDkagS/0lR0tyZ+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3268", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3268` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAV0gHJClQBjbr0WZpKXIHsv6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3OGJjY2I5LTJlZDQtNGFhNS05MTk0LWY3YTRlMjdhZTI4NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRlMzMyNDItNTAz\nZi00YjQzLWIwZmItMThiNDNiZTVjMDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2THu3woBZVOjzQjNEZPoBhwpAXY4i0MD3OeFDToNWlv3+SGuygsm3zltncYh\nrziuAwl1vpYoTZluoBudjCD5QKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSEH7Jqs7xVZyBjDryiiRAoWA0OQwHwYDVR0j\nBBgwFoAUJgDnbaXlgHvN8yL78xemS3UbRvUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICfRGmdsI+so\ncPPo/dopB1meYPrRQQn4sU4SwfwmQJ+BAiBurOjLGecgE03WO6hv7FGr13kEXusB\nOsbUWnnBMnJcOQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYADTu1GywYFztV+lEI2L/ciMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzhiY2NiOS0yZWQ0LTRhYTUtOTE5NC1mN2E0ZTI3YWUyODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkd96Cv+4dKYJt2Rry1aUx3V08MZPqyS6tGB7+rn4Crl1j\nw71N8tvW7tNddJTkizDkrMK+uTYfkp5cZWfxGuEIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJgDnbaXlgHvN8yL78xemS3Ub\nRvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPuech+Des3Qrf5SFv072XbW85P1O9eAEnIEWvpiQQZSAiEAn9ldb6nG\nJjx88Kd0n+iSx++PYNSBXz3255o7I/LiBX4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdAy4eLnn4XBWUai04JwyEk8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRlMzMyNDItNTAzZi00YjQzLWIwZmItMThiNDNiZTVjMDExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZWZmN2NkNC02OWU4\nLTQwNjMtYTQ4My1iOWE0Y2E3MGUwMTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR+fCSP0UjPcNhxHKpWV/6lq+vOQQkVBTJWGCSEyDau40hoCdcnhI223YVdBDji\n3lm+T0tQuFZ0owIj6T2kNTtEo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRIQfsmqzvFVnIG\nMOvKKJEChYDQ5DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBAVBKKYMLqRQ4hGb59xOiyKJpmIhGwuJIGFRjPK1E4FgIh\nAOTonxqMG1b7rspNDTlxGIy5dzS0OWWIvzXlu9/pHbTx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3269", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3269` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVb4bUqNnlrybP/reppsx20fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlNmY3ZDBmLTg0M2ItNDAxZi04NmUzLTUyODEzMjA1OGExZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNkMGYxNWItNzc5\nOS00ZjBhLTg5NjktZTJiNTExNDMyYWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3Ehv4vBz7tixNBIXXe3RqoqRTA8RagWK/bR+qos34LiYiBfLW8F4KOkY5eW9\nhLJMOZ8zEE8wte2GRZCbIc9NC6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzuvacvDTRvWQXkJJRIngcnm9fLMwHwYDVR0j\nBBgwFoAU+F/DFgRfrMC9QEpKcddVbMz59uQwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCFH+eBZ89rgRJPFi8KAiqoWm+LfIYFnS/mZHmYGwpKeAIhAPyLNt9uElgq\n0FyyoeEDi01OrEwTqrPnawCdyCwaGHRE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbrq8qf9F+UTp5binfqa0nsWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTZmN2QwZi04NDNiLTQwMWYtODZlMy01MjgxMzIwNThhMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNNg9R/78dVMqdiGZMNnv/4G3rc5XWiAfxatVp7Pp918PK\nk78YcB2wM8Z7jm1Y96adbmAh+u0wTjCbFf4kpMElo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+F/DFgRfrMC9QEpKcddVbMz5\n9uQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOB1lTF/0BZT+h12UbTaAXvOtBIglGBK9wqGfqVviXRMAiEAsj0njo9i\nibXzy5C4Cj6l2jpNRyrgpKOODYlASJFoDcM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATcpgFETHZg1lo/KulhxPebkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNkMGYxNWItNzc5OS00ZjBhLTg5NjktZTJiNTExNDMyYWNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkOTUyNDZhMi0yMTYw\nLTRlZjktYmU2Yi00NWQxNmI4OTE2YTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARlYSrw/hcYNuVfLppRMwCwR/38rjTkiszOBNjETjUU5czDc71LtKrL27h9Ghg+\nxm9F+zUuyd++BI7Bk4zGyQWko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTO69py8NNG9ZBe\nQklEieByeb18szAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiB0r9a16RIehFh/VV0ki3h86q4YnRSZhIYZEoDqz11++QIh\nAMZSNUIqZYk2ryUyIYN2rK916g3PLqCI1OCZIksAra4l\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3270", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3270` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASsS6Zasg9A4FvU/TwL/dPC0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMDg0MDhjLTAzN2EtNDc5OS04OTQ5LWU2MzEyODdiNjZhZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhiM2Y3MDUtOWY0\nMi00OTZmLTljMGYtYzQ0MDQxOTNhYmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcNapXYVZUt/yBF93vXEqW61dlOfiSQfOAucXcPTT0fV2AzmPzi4kmN0FktiL\nx2cEAZhTic63F/Z60ykFv2xcJqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0mceF6f15fcFic40GGiDcA5blwowHwYDVR0j\nBBgwFoAUwD6124L4PvSTwt1WnC2gtYiVly4wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAlnrxVL6p7nblimRpnpl2uuZcZkaF3vxvV3ic1ITefyAiBgSEcCc/5cBpiZ\ntEjw3LIIqQ9klXuoYUlt8Y8NWeGyuw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASo//BGWOu62/EqrOGKTj6VOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTA4NDA4Yy0wMzdhLTQ3OTktODk0OS1lNjMxMjg3YjY2YWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPE8mlX5FLnuOYJGVnxbEBpGdMeN6xqlrangRXDPaVVhgu\nothUkMx0BsXCzqx+t43fved5dJc6FScCOjlhISOSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwD6124L4PvSTwt1WnC2gtYiV\nly4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALsu4DNniu8JjIZxMoGUJP/7w5waXWDQTLvPbvaLKg9SAiBHuxZdfsYQ\nGjRmcKdO3y/LCaLmQXnWMaNaAiK0t3VFDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASOyTH5V92gr0t6D23R4IbUJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhiM2Y3MDUtOWY0Mi00OTZmLTljMGYtYzQ0MDQxOTNhYmY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmZTQ1MTJhMi0wNGZl\nLTQ3MWEtODllNi0yOTAyN2RkM2JlOTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASUeSUJ4ug3a4GQD56xDph7AvKm/jOyyMQuEUIWFjpN+Y2HRJmLeMhuHpHNnXz5\nphU5Q/CmGP/9++OR6s71V9rco3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSZx4Xp/Xl9wWJ\nzjQYaINwDluXCjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA85k/6v110Z7EM5kUCNtxs7utDb+FRLCQGJEU9LGXLuYC\nIBQRyzGnH3sov9wEKKlw72uJf+OaTGKJoNSXFOIQEHtX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3271", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3271` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAcDMBBDqJO+56cw6FCHuGXnxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMzNjZDRkLTI1MGMtNDE1NS1hYmM3LWE1MGRlZjkwMTU1MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU0NmFlOGYtMzk4\nZi00Nzk4LWI3NDYtZmYxNGJjMzY0MWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYT0z+Fd8Y514AkXNbBTi2NmCgNbMWmxrks9w6j8h/cRWDpsg6n+Rh4EydJ5w\nCGcBSClrM59eSAXhfv7oeR8DvqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7lB21L1gEEj+4VdNIY6nbzVW3B0wHwYDVR0j\nBBgwFoAUNGWl+2OTRR3JTQrh+PhneKqUO2AwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCq\nVmubwGYh60dErqVkCzdbcW/AR/syYPXmYGq+POTCvQIgfaKniYLfUnXJZACeYKK3\nK4UxCMAAXo36EzKmSugPNhE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeIlJb6zItVcmHpOsCNORbzyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzMzY2Q0ZC0yNTBjLTQxNTUtYWJjNy1hNTBkZWY5MDE1NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9B90AME5IZGiuSOjDIDY+cZHoEcEL1HVzh379ZzPEcpuc\nozD7TDKsADahPQ7JkqZ9iByRPERFnYVOZBdqaGrMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNGWl+2OTRR3JTQrh+PhneKqU\nO2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgauHDwGlgI0gPlH9gdq89KNUVbuyA0KR8HWJ8MMALEW8CID5dhrVkogEX\nNukxftH7xsPMKbUm9vaWfDgzRdj52EHF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARW6wnszM5xJswjaCUp4zKqGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU0NmFlOGYtMzk4Zi00Nzk4LWI3NDYtZmYxNGJjMzY0MWM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMWJmNDI2Yi01OGY1\nLTQwMGUtOTc0MS03ZjQ4NTU4Nzg5NTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAStNOKBZhQtUP0YW8vJbWJ+OXl9h5jCzKaBFy0xO/ZNU8jrL8SUIXtG9K/tW1lx\nMH83qudoT+86IJJUmNkpUvIQo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTuUHbUvWAQSP7h\nV00hjqdvNVbcHTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAjsXGDBfHWVVHTVfG5EnhpiGg1RVmQU3xTGXqV9OGmWoC\nIEX0da6Tyj7Rp8HZrddxnyBuyzmnsozyHDKRHVslhgGd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3272", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3272` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAbl/YyPRzdGdhmRc04txf4x2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxMjI2MTQzLWFjZGItNDk1Zi1hMTA3LTYwYTA0NWYwNDk3OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY5MWU4ZmUtMGFk\nNi00NDk2LWFhMzUtODIyY2Q1OTE4ZDUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4YaTR83bJ8nMlo4Uun327k0eWbLR5axG05yeD3nYyNGmwdHYwfNkI0hNS9t8\nUqwp2Yys2vnZTyNzVKapFrJcCqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDBobwU+aOqeQF3yWeG+mXhvFKY4wHwYDVR0j\nBBgwFoAUD2PYVb7nfFYOudWaMzcLNtw7wsUwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCgymk7kbdXMcG/s89Xxn6k4vJ43jvnzkK5/vCm8VkONwIhAKax\nwHI4LG3MEUH8l2pM+rWW0KJsXiji3oSPcojNwZHq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARAmcwzlCUvxzhGhx/5noS9cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTIyNjE0My1hY2RiLTQ5NWYtYTEwNy02MGEwNDVmMDQ5NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShLjKtuL2+FLDtBCA6UTo5acMWHg1FchJm4cTrvayX8mCq\n0pXBmupzDt7i1XNEzUbILqmRgZn2OqD71oerUemao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD2PYVb7nfFYOudWaMzcLNtw7\nwsUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI2cniokIVgNp7WA/VKfb6BYHTeplxG5NGeQH1QDv6ANAiEA4NMI4EPm\nhLIp6yzpSCPgBwTTJ4kpRPo9Z7tCvXpd56g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAe46hwWl2SL5nqF2J3dtLubAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY5MWU4ZmUtMGFkNi00NDk2LWFhMzUtODIyY2Q1OTE4ZDUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYjY4Mjk0My1hZmRm\nLTQwZmYtOGQ4ZS05MTZlOTE0MGNkMWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASo/CW5Zavof8mictfMu9yTJwfmegUr+z4nhSQ6WQXE3t11bXqCwNzjusPnfjuX\nNBr4LYLHJZ+GpkdCRPn6/adMo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQMGhvBT5o6p5AX\nfJZ4b6ZeG8UpjjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAxZYsz4a2cRhlh56J4McuJQk0yau6NbpLk1CdAKF01qoC\nIBBSdzqMnSwnacquqRkVAPBSGHt9Tq5r74Kaoyh5KjoV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3273", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3273` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAQxrjP0rg+5FnRrVC6Ia6i5mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5YTM1ZmU4LWNkNDYtNDU1Zi04YjliLTY4ODViY2I0MjYyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRiOTQ0MmYtZGM5\nZC00MzliLWI1NDMtZTM1OWExODlkZTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoo8PQOHYHOu5uRC/qVSKXzZpBLzb1LaMtNHJpSmgaYgOm5J+9B8AbLziSCsG\nsHhl9uNtv09QVVu6VTlsVNJJfKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/lb5yWFxFQnBaQF0cKmsBdre7oYwHwYDVR0j\nBBgwFoAUt1MAeJ7KTaimOjAVVIu3xt8c9+MwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHNb3B8hpXVQx9a3Vy3LZcwqhXkte2fzfsAZ1A5A6wBDAiA/Qx3c\nlJdbElEHS0aWl3fpcAV3+5yrK2vSFeVdmmXlMQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ8dgbtCLlAyl3H1UHrKAK74MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWEzNWZlOC1jZDQ2LTQ1NWYtOGI5Yi02ODg1YmNiNDI2MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgstTFOjueD2h8xvWN7QWpQsYERfI86+TYYy+6GW0DUtxG\nYjm/hsOOVzb1gCDDXwsvIio3zSmHYYcoQSLqH0GQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt1MAeJ7KTaimOjAVVIu3xt8c\n9+MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZQJvCUtS7Tp7A0+k/jzx+K3MiQg9Q5Fb3XWa5Fzkf4ECIDMQLH7hOZYq\njlmcQjkswEirUVDWOC9Tey6vZHeFHsB5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAXSRdrBPjSRx9huFlboqbaTdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRiOTQ0MmYtZGM5ZC00MzliLWI1NDMtZTM1OWExODlkZTY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNDYxZWQ1Mi05Njlk\nLTRlYzktOGQyOS04YTQzYmFhMjVlMGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATLXtqQX0DbilOIT9VH+gtMHToJ1O28W6QpdFi+sya3sRGtYwEjd6MMn8J90Rvv\nHA9AHkzsPiLaUmyHOPjGrojNo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+VvnJYXEVCcFp\nAXRwqawF2t7uhjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAwZZXbYGRObrbjxasg2Qej9+gcsBPoElY7VM24YZ3pEEC\nIQDAsdFuKmZDdTEG/h20dwrHf6fxktbCLdFqmlxmPPkY5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3274", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3274` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAaurTmGltvlcGmgz4Nqhv4KtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3ZGRmODc0LWUyZDEtNGRhMi04NzE4LWVkYzFmNjVlZDgwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ2ZjQzNDMtZTE4\nYi00YmE1LTllNzEtNjk3MTJmMWIzZDZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6iM2AI75xr+m/hMRopO2JFE0C5sK1W6XyOaU2kKDqfhUL8AgA7E2YuvOthci\nbirbOSXamrXo8Sz3Li/W606diaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQyPjg7TkHZQ+IXAm2PYvQtM3ib8zAfBgNVHSME\nGDAWgBTcn4iitXJKeoj6tUqNJvLfEJnH3zAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDVYeXWyh4yBi3hbZwUp8mJIIC/cBBY\nTAGzuTB+3UD6BQIgJTGuNFVFR3C2lLs6nj66t/NMjFRDjUmYpvKn8pC0TuQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUmNtxoSx3wg4VGuqTzWK/2fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2RkZjg3NC1lMmQxLTRkYTItODcxOC1lZGMxZjY1ZWQ4MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmtlU8vSZGlTJRUBXNYliqVe0KEUZLS/xrur1U/WZmmmZS\nzMTpPmJAHniTp4Ux4LOtxQshd7Fcs7j4IpY+FRgRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3J+IorVySnqI+rVKjSby3xCZ\nx98wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJAhlsOoJ1uOXHj4FOcnzeKeg1oKSi/9J8TVENYG8kM+AiEA11ErECJi\ndRwKrRNtpo8rmXsUeZShJrihb3oN50Kj8/U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATrdZWSeWSSntoFYZhG+YeU9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ2ZjQzNDMtZTE4Yi00YmE1LTllNzEtNjk3MTJmMWIzZDZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZGEwY2FlNi1iYzVk\nLTQyMjktYjk4Yy1lMWI0MjRlMTQwYTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQGaOfe6RWzKO3BPWxA/t8erDSpTk5vJkXBYyt/Q3xUKqVjDxntYQN0BF1xsIuf\nUG8OWaTquURkZH4zJYZbKfTto3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQyPjg7TkHZQ+IX\nAm2PYvQtM3ib8zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAtoswALfde4gemHHe2nMLBpsGqYxwhuEHD3eE9VmivkAC\nIQCLcTVpbBXnme9AqooEcLeXHKCE2oNWv+dbvbbtHxKH3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3275", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3275` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATxIIcv2EJrFTCkX+nKGmtSDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZDg3YzkyLTBkMmMtNDU1OC05ZTc1LTI2MDU3OTZlMzMyYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQwNDJhN2ItMTc3\nMy00NTQyLThjOTAtNjMwOWQzM2Q0MWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED7wwc+KP5+W2tDp7lBD3/GGtCcEXtNhBt+bkaPjJXRMlizALpKupd/lWh97K\nFYsEz2jsskKOM+U7SppM4a8YfaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYBhod1PDlQkBuPQSReaiQEYdlTkwHwYDVR0j\nBBgwFoAUUiFSGtjvxzRlFVzUVop2r9qV1fIwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCx4QCPGf+2\nJjOoJnnXtOAH7yK30GEYOfA8xtE3IElPMAIhAMTJMROX4J0obYAs+XoOCBnNKMWw\nPxeywsgaxhYP4GJn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQOLUOqLYIpNN3x7rE4uL13dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGQ4N2M5Mi0wZDJjLTQ1NTgtOWU3NS0yNjA1Nzk2ZTMzMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQp4MW8YtAg6X/IKJpqyczYqAzCH0lVveX7LNr3YeI8ozVk\nOGfPxTfZKnrtAlkWP0ptVzblSxv2LnsE6PFhyO68o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUiFSGtjvxzRlFVzUVop2r9qV\n1fIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVdpwpn+HvCOddCwLnqOoGZU9/bSnrEFjQPjBodSXMZICIGfJtDViu6Nk\noZhEGyLMY0kC6h13RrxR7Po1lGHRw6x3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASfJcs/lscQiK5heeUoPNUGdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQwNDJhN2ItMTc3My00NTQyLThjOTAtNjMwOWQzM2Q0MWE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NzBkOTk3OS0zYmIx\nLTQ5MDktYmM5My1kMzQ2OGY0NzU0MDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR2NbCx24KAExXrdzh+QgoRwSI6/W/U4X+vw+Yc1b9spculKDq+R/ww5jeOdzZU\nAml3lnIN60l7m55whjnEMy3Fo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRgGGh3U8OVCQG4\n9BJF5qJARh2VOTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAmDpswMhP1kVITJT0Rhisj6AhcZFMFcaMNrsAEXYbj/AC\nIQDRh0pjGBonQXdj3rlWkmywkTySKKTiGc87fnilx3LBxA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3276", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3276` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARakW/CwvrrLxwknDlXvf6+vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4Zjk5MjFiLWRjNWItNGM0OC1hMDM3LTU5Mjg5ZmU4YTJhYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGYxY2MzNTYtZjBm\nZC00NDg0LTkyMjUtZjAxMzg1MGRiN2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3FmwmUHRAA6jLW4ExR7E788ACd9Ksd7VPw5dwZaS7xskHthbJSQQaEz+URrm\nKZq0ncemud6mJ9hjoo/Kwwc1w6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJiR8SjV+HSTv9o6Z2KL333x6PxcwHwYDVR0j\nBBgwFoAU9Hft7DutiiZ9dMElaPGbCcY3p4swKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCVti3h7yMT\nOAJaMNIPX7XHwtyICgQgyw5DBsmwLkE0AwIgdQdRrgFEPrJ9bGvV1GCXu3UpDmI6\nLelFpADrDfxELos=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbyqTqHZj/MiZsBo+W0nYLXLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGY5OTIxYi1kYzViLTRjNDgtYTAzNy01OTI4OWZlOGEyYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJIrqti6LE1OW5bqv17kEOLLwThC6aup5cHk3y5iuCCH/P\nB7h36Tj90AjEMYi5qjpOnvZ+diXuNxphJTYdIfzYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Hft7DutiiZ9dMElaPGbCcY3\np4swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDfp8xlYoaMiTqBDhau5NpeI9ThkRS/XvOCuL6wxxKcoCIQDP10FR+rLU\nfoaF5yqvTkeKctgDh/OrHL4R10m5ZHfoHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAapwwRQZpXCEDxf79YDYKqPMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGYxY2MzNTYtZjBmZC00NDg0LTkyMjUtZjAxMzg1MGRiN2Y3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjOGI5ZTRhZS1mOTk0\nLTRkMTktYTY1ZS1mNmY3OTc1YjM3ZDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQfxbD8iW/xMFqEkTjpthjrMG1C94wWQAnWoBxW7HqtoOCkUs+blDIq+Nr0d+LO\nf7WhJLqgnfprhE7s9hz0Rs9No3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQmJHxKNX4dJO/2\njpnYovfffHo/FzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBx4OjQpHZZUO+5sNoNof8nvdOhGwWPrUy5PzR3UwtQowIh\nAMcD1bRTTOf8Z7KMwhLIDDSJQXWbmRsp+attHAYXbhVu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3277", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3277` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAUhZuMxcfFv3M0jtMFaDfnoMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzZDRiZTY1LWMwM2ItNDkxOC1hZTMwLTNjZWFiNTlhMTI4YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGVmN2IxYzMtMDg3\nYi00ZDQ0LWFmZmEtNWNiZDAyZDE1NDNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHespMsgnCDe2twHwu9OiFrg9vYU3nY/eDku/C1WDkQCAcxdbtlalMrUCkZmE\nogx2GaIYP4Hm0hmVNc4Fm3tv+aOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULsg8H33dgMMMm7JJDXIO80jA0FAwHwYDVR0j\nBBgwFoAUfY4O5UGzlCzt8aGHnaPBSwAK5U4wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEA0sk/0XDg\n+PeQzY41wDk/+TMxHXWbr15kwPbxrwtT0rACIQCo7n0qs+YF5TeyiYcHZfajnioY\n1NIW2KW9JCw18n1kFg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWrTvafpit65OLVB4jYeFzGtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2Q0YmU2NS1jMDNiLTQ5MTgtYWUzMC0zY2VhYjU5YTEyOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRo5QEZefPWy98SCzMTGUu1GuETeVCU5ovbUm+e7exHYXI\nuK3qob3DycBJXmh007UFDpCposidbB6fVNz8fKU5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfY4O5UGzlCzt8aGHnaPBSwAK\n5U4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMJ4+BfYa0rC7Nr3uM/K8rLcoRvNXZ1lDyln/ONVqWZSAiEA5t30VkTz\nml4SFqDyGmP/na3TSdCnKQDimUUc17NVCgk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAfwifpj62573EQGQw9MBR8qpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGVmN2IxYzMtMDg3Yi00ZDQ0LWFmZmEtNWNiZDAyZDE1NDNiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4MzUyYTM1Zi1lOTlk\nLTRlZDQtYjFkMi1lNjI0NjMxMzMyY2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQBSIg1XjF+LFgwN1H6ZkiWrYrpVFd/0hQqD/EAGPlGaiioF5gVCbjt8Zvp6fzU\nCFpY3ek02js3lopZE0X2mQhJo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQuyDwffd2Awwyb\nskkNcg7zSMDQUDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA+Y0GXfgiPVOtYWvPW3+eORlxxAUARtnSUOpf5Vx4tSkC\nIQC1rqmiz2wJCheXg6OSKHvgmmOoCxprK6deo5BafLJqng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3278", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3278` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfM7OSyqvJZ+GyZJ+4S3oP0XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxMjhhOWRjLWI1M2ItNGNhNi05M2Y5LTFmMDU5N2U5YTY0NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk3MTM3ZjctMTVk\nMS00MGU5LWI1OGMtN2Q4OWZkNmIwMjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3SYFtFifKsiej0aMbWUv8Q1A2nopcdyJVB5vvJvG1aZbrIa0CnddkVqrM5gz\n956t3m5zVMcVj88rT/6uxAIt+KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOLgRCr5oMg3hZEYdS6RDOx1g3N8wHwYDVR0j\nBBgwFoAUaV6NktvhhU/o/9e3hMyAeoFVk6UwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAyY0E2VW7jtkv7oh+8MSc0dB2olqBFrxTpTKibOcCnJICIAHvrxH2k4MY\nSpSWWTldKepI7ZLXkgKSw+8PPnNPnpYj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaQMNNbiUvonyKzzP8tLN4ulMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTI4YTlkYy1iNTNiLTRjYTYtOTNmOS0xZjA1OTdlOWE2NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDYlUfMzszii9KjnLwl7DJI+a7JOPjq1JlXNQ/5p9rJWIg\nqKlXFo0JSLODFdU0UxkPLHyBNXkTVCHM50ICsmkJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaV6NktvhhU/o/9e3hMyAeoFV\nk6UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPYQLyyEGqqnEux8cBnyGSJJUTuuizKDffKPhhFbSxJpAiBnY5ddzgo9\nqx2ZFbBhzyoI89h6N0uu+YDDVwMx04to6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZhmTl01eYuke3uyzdGtMYD4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk3MTM3ZjctMTVkMS00MGU5LWI1OGMtN2Q4OWZkNmIwMjNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MmE1MzM5My0yYTll\nLTQ5N2YtYjZhZS1mMDBmMmUzNTdhYzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQEWcDRcVP0ZrgEwvN/EqATVOZ8hc8X/x/lWJ6PUGAC0OyW5jPwAoTWmi7YRX71\nTdjBXBFVHHlwJH4fOSAKBsUDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4uBEKvmgyDeFk\nRh1LpEM7HWDc3zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAik0l41CzVpVs9SOKsjW30K4j/TJ9lVjk7uUG7ynFm6AC\nIQCXlT1n3njgDvKve6Zz20CAUbdl2nA1SIFpuw1ZK4oJSA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3279", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3279` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASkB6qoHClr4MFRf9Nl/9cdoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyNGEzY2JhLWIwMmUtNDllMS1iYWMyLWRkNjBlNGQ0ODRlNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q0ODJkMDQtY2Jm\nNi00YmRhLWI0YjctM2RiZmE2YWE2MDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU93SJ6tfKq6x2sVrxtRZbsMJBbMvYaYx085quZgF45o5K3NopvbKBUvaPSB2\nPAVFCJsfh3f1xT50Lg9fNRKBSKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxUJQnwOp3RHNUA0yq7R/FxMIKWkwHwYDVR0j\nBBgwFoAUQa4aNTjFodHdB4fxwAtMSI4GZAYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAVP8L/CSi2eGgt8OOMHM4mu6I/WtKq8Yrkov2ovAihFgIhANNFFfx4W8lR\nXWwK3uaRw6AUZXiTKeKAigWxAskFthU2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb6hdtKlrUZ3qsloh95FvycxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjRhM2NiYS1iMDJlLTQ5ZTEtYmFjMi1kZDYwZTRkNDg0ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDPO9RwaI5yBWzd5PrdfWQRBtP5ggGknnpX+drt1ua4wlT\njiio0lafKUYF9vPiuil3GbM6ArBlTt17hr/pGHeso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQa4aNTjFodHdB4fxwAtMSI4G\nZAYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIUUfBIgViYzFtSTixpIP08Qrk109VEm52o2L7NvChnLAiAgF753fmi+\nHGfulsEomO1qdEyUOTLZoAIbNHwJlpxUdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAYF5yDZLxBK/u8uJS4PVOzinMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q0ODJkMDQtY2JmNi00YmRhLWI0YjctM2RiZmE2YWE2MDZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNjc1NGY2Zi01YWFl\nLTQ5NmMtODVmYi04YjQ3ODFiMmExNDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR5q0J0vD7PuycL8YPk1w3p2TKZ9gg0YAIIlB3WHhUoK5nij1X6KYjkxNC9BFug\n5ZB8c0OQ1n6Sjkjl+bm8fx/Eo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTFQlCfA6ndEc1Q\nDTKrtH8XEwgpaTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiB9wrAQfu6LHqgJ7mdAXIHlLD7y6q3bVMxNwaviB+mMVwIg\nKd+7n58KxZIwOdVKIIotM/LHUPhHOj7HVj+IPcIiVdY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3280", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3280` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISATd19wOkXPuRxBpKpb1uEbYMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmNDg2ZTc0LTJiNDktNGNlZi1iZWI3LTVmNzZlNjRhOWZhNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZmYjk3OTMtMGNh\nZS00MTc3LTkxNTktOTM3YWY3OTI1MWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOKbwZUsB7FHn9dTqD9rewzPMRZw4mJ6PrrUAZvDxO0YTRQodN4Gz4Q/NVhJM\nujSHPjFZOdI/4kZ3zwzV3swUYqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgFakdvJXUu+WYDVqTDOKkXYGSEcwHwYDVR0j\nBBgwFoAUsY1s+4c+hMdHY8ubdcHSsKkwjXswMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAR\nMLq/5SwFDRmDuGxYvsfsEgeNkNvgwnILpqxe5SBhTgIgUJo4VGN5ckZZlxbDZekI\nnlIEA+193DJ3ZOzkbORJq5E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARDavtN0daR5xP7UlX4q0ETNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjQ4NmU3NC0yYjQ5LTRjZWYtYmViNy01Zjc2ZTY0YTlmYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqPwGIMbEYGuizjMEDoamEUuAHRvrLQrOjkjK8yyD2b+37\n3KpckTIcvGQMJFdPcVvqeJE3sm43pLCvRBZmFMh7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsY1s+4c+hMdHY8ubdcHSsKkw\njXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANNTGI0s+ESbgImaWTM/LT3Czi9hUr5b/GQUkRr9XhYaAiB7PxEV8a+6\nEku7s/YWygdfuqlaSI3u9SAhpKZi75EhFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYpu0w9B9laxz7Mgc0nG0+uIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZmYjk3OTMtMGNhZS00MTc3LTkxNTktOTM3YWY3OTI1MWY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZmZkMTFlZS0zYTVi\nLTRkMzQtYmExYS0xZmE2OTk4M2M4YjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQJeVDNxq5+aqqWC6hQu3bq+S9Bpi7lvClucNJNxzPi4KfuHkf4s2lj8i/QdYrk\nuvfqeCDb3ngH3V9gPSFvb//oo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSAVqR28ldS75Zg\nNWpMM4qRdgZIRzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAtmgnVGwAm3PnmfqsOVVKKCWNts8rvOr1yXJIb21c23gC\nIGWfbqyiDTWmdPYxOf7lea1X8KQTysMyNYXwTq7lj/uP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3281", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3281` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAbISVda4tif6XOmsWlDHoaxfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMzdkNDIyLWU5NDAtNDYwOC1hNzMxLWIyZDdjYWQ4MmVjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA1ZjdhZjYtMTc5\nZi00NTQzLWE3NTgtZWQ5MTYyZTVhMzExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER/LTskKd3PkC0HNU9Fm1wotRB4xIVoLj7bD6cmAX+YoUlA6IyWexrExpSyBE\nfy4rM0R4VCCsrcP2bpGE+/tj4KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjH3BNtTNrIA4EFHvuylCyb3OapcwHwYDVR0j\nBBgwFoAU2scvQcBtqfLAm3BteGLRJVoM0RcwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAmRPqdAMRLhSK+j8IHz9mL1YRu9Wm7J6Xq+zaU+MIf64CIFEV\nAkW3IR9mU1IhibyW53wYZIyLHXskTMTkgebpl337\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW+dgla5cyHLX63iD98VMX4oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzM3ZDQyMi1lOTQwLTQ2MDgtYTczMS1iMmQ3Y2FkODJlYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuENdk++cLje+NtsBVn2QTH75tdcQmlYP42lUirbK+pkpH\nG6CoqDMrmbTdquDRYjWT+6pOWGe/XK8gTXTL+/j+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2scvQcBtqfLAm3BteGLRJVoM\n0RcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUjV0NKXw3QJKa9Ii5EcdLLP6Ehiud+8Wlxsk9IxKmQECIQDUslGRHwGb\nuX3ySSzVXIgu+L7+/DylFh0+EJrBHXk46g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUf+Tr414hvCSFLTMjCqFpypMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA1ZjdhZjYtMTc5Zi00NTQzLWE3NTgtZWQ5MTYyZTVhMzExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNGZkZDU2ZS05Zjdh\nLTRjYmMtYjNjMy1lMjZmODRkMjQ3MmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ0V2UhOudJGQRkv/18JAzYsKKcKYtR7GwPaP4tX3vxj9U/lMKTuBQJ5MgPZQPo\nTd6/RBi1p/3GRL4jdKLouHFxo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMfcE21M2sgDgQ\nUe+7KULJvc5qlzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiAs+kBDpyRe9g4XyZjho/o4+gul0mPNR8qZW6/rDBQrNwIh\nAOUgYXiYkg2ijIWrB/hN54wZbMXEmplzLzyojEiuTDoE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3282", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3282` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARp5faEsbGbG9WhPT/4fE2FjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjNjRkOWFlLTg0ODItNDU2OC1hZmYwLTM2NDExZWJiMzYyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgwMTNjOTItYTU5\nMS00NGJmLTliMDMtZTFiN2Q1M2NhNTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgj3XlNpcTe8ZcTaIJo83WgCAjqA6YNr95pKMI0Tg2/H5L7q3nLhREnRRkXjm\nMh07AWlfukFo3vOxBioMpk2qeKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqaf3yXtqLhEhJmlrelSGqSkAblowHwYDVR0j\nBBgwFoAUSVexkIaL/L+WB6QEqpTy0sQQCGUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBP2bmIpbF3fo2YlnysaFaf20LCred6+baaJL23RSD4WQIhAK5Y\nOrulG5CcMQmKOtLR01MDTKyvWTi2jXhppUYqve/s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQLu3ruuLtuOT4iEK+dT6kgCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzY0ZDlhZS04NDgyLTQ1NjgtYWZmMC0zNjQxMWViYjM2MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZG3wTGLUZ05bDhsI6FQqxqBDWn9X+VlpnS8h3B3mle+U7\n452Vmdyf+dHJgntlEr+bitCD/mU6HTcIwbvaM286o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSVexkIaL/L+WB6QEqpTy0sQQ\nCGUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIZEANunCsw8Y1HeECoI5isBm3iCye9MCEhaADF0mUKkAiAmuHgnrMEK\nVr98cFuA6MoPuW0i2+B+dz48j2EvlOL7nQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAbwLoe9MzFjmUoNqRdyyZiq/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgwMTNjOTItYTU5MS00NGJmLTliMDMtZTFiN2Q1M2NhNTBlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZDYyMmMzOC0xNTBi\nLTRlYzEtYjQ5NC04ZDk0NzZkODgyYjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATbyyr6Gw2mUQ9Ohesplca/RDMWjEwMGuz1fNZCJar2Z517o6Uhdvx3EaijR9ED\nIEye3QGAYHsfo4SZ2m7w2xIPo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSpp/fJe2ouESEm\naWt6VIapKQBuWjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiA67rX1X1tXqKkkxU1cu2jncYEuwHashsmMZlvv4/E+cQIg\nFYzzxSGMOvf/I3DapaHp+3f4unkWiHOMGtVjWZqXUQc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3283", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3283` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAfbnVG8myhB59S7UmXsjBre4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5YWQyMjUzLTY0YjEtNDI1OC05MGRkLWI4N2Q4Yzg0NGQ3YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRjMjc4NmQtMTIy\nMi00OGNmLThkNDEtMzk4MzgxZGM3ZDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsGF8IvH4EmMSNMe3Iv3pV0QIM2srCDZ/L34K3vIFtC+P6UZpJiXwUHo0qUG3\nbF2ULceGAor0bsvfPx5E1Y7ogKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUypTn0in/f9xzCIIwVQe4YGwhAIUwHwYDVR0j\nBBgwFoAUX04Zor5B3+448Y8Xwn4dAs0amHkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA7fuQZYgaXbdn\nsfafQvPZoDOO+FyvUOfSwdSQo4ca2jACIQDdcPFfySw96kTeeGbzVbIGAf/Vbngo\nEhFuwhmFDhlBSQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXbzFOKmL9nGYNwWl6MxJ2WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWFkMjI1My02NGIxLTQyNTgtOTBkZC1iODdkOGM4NDRkN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKHo8dy+K+BXb0nFQOzJcvwLchjz7LhP7VVxOu6wGP2zp8\nKyENcTKvQAfRd4JUCrvMY3jth+eHxO2RxXaCHkv9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX04Zor5B3+448Y8Xwn4dAs0a\nmHkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPqfV5p8UvUQ3kvQNYe7V1kB1EvtrWOV3nLQaelkJRCICIQCe4Bzg+F66\nga4rxQJVVFkGAOnOzZR65dcPDQsqzNXeJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASebOIEq59FsPr7TmGW2gdAaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRjMjc4NmQtMTIyMi00OGNmLThkNDEtMzk4MzgxZGM3ZDkyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmOTkzNjhmMy1iMWM4\nLTRjNzAtOGIwNy1jYzM2NTJhN2NmMjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR1YWRthhWSkUa2d8L4u1rE3dMuMPgj2HM2/YoZ3FhFArkEhMoSMGnhanszngYU\nXYjB7axDaujU39RlBSuoHJCQo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKlOfSKf9/3HMI\ngjBVB7hgbCEAhTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAmAdP9DvLRd3KoIGUyfTDk1F1LfXT6lbKTgwNiynRZQQC\nIC9RNq3at6Kj68vihljTORL4UjZ4pQOUkdIlsZhr/BS3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3284", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3284` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcvLOMl/e5xrkTA08XgJ0PzSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlMjg0ZjE0LTgyMWQtNDMyMC05YjlhLTI5ZTFhYmQwMGE4ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUxNjViZmUtNDEx\nZi00Y2ZhLTk1MjktNzUyMjI2MDcxNTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Bq1dKKSLQfqSKG8m/hV3Z/g/+hBVZPZ5I2klYP+Q11T+Sk46dD22QGUDBms\n0THVRcA9FO1EmvFC4PWAhhssp6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiJUDaoDZjq8z9ENQRgPK+p/mH+gwHwYDVR0j\nBBgwFoAUt9lisc5vzXxOU++dT8F6TLe0yTUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEYOBWRnyo+pn+OcxhExk0p/nwyP3AyrdTaLUY66VpFeAiEA1OqAt6pfDMnr\nJRPosqSaZdNnXaoHX2kBf8aswKbAo0w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW2owNBXerWXvF1Eqq5EHwseMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTI4NGYxNC04MjFkLTQzMjAtOWI5YS0yOWUxYWJkMDBhOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0kMY2XjbIpQmwBSgIbAHKhxOscdqnlYSXwYlwkSsW3hrw\ntecvSfcolxv5zS5yCsG4sy1QqZ83vE9WOlyxwqO3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt9lisc5vzXxOU++dT8F6TLe0\nyTUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdzxGiDDnzVFkfDR0vC+/c8XQTDiqNBrMLyDBOnf7SiQCIBPsKtfzzRGk\ncBvNGQC4X7ljUd6DHqagmOaLQlaYfEj9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUE48LSN7bXTA4Sh36kSvs6aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUxNjViZmUtNDExZi00Y2ZhLTk1MjktNzUyMjI2MDcxNTY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMjI1MjViMi03YjFm\nLTQ4ZWUtYmEzYy05ZmVkOTYzOTAwYWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARhZ1E9OEWI/ht6Nvmx/JWuDW+JG44dwokju5nshAVccWx/DJfYB/Vzw3MdLkxM\n/kE697NJCBeBLfOPsxvEUJGYo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSIlQNqgNmOrzP0\nQ1BGA8r6n+Yf6DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiApoOOdMJo8pjnNlEqs7c/QC6dh9T/OgyHQ2U8YogutIQIh\nAJjTNwOWwkKYF96K4SHXHJUhnGTYZpYVvd9k9wotK5IP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3285", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3285` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVZR9CwlFId9Fxtn4IAV3f31MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2OGI5N2VlLWVkZTEtNGFlMS1iYmM4LTI3YmFhNmU1NzM4NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhmZGRjMTctZDlh\nOC00OTY3LWFhMTQtMjU1ZTYyNDEwYjYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo0K24kz0NgX8gbNuO7My4wta8S82A3KBlvc7+VKxOkXpN+qk+rfIA0lk0r9V\nNh34nG4rOcNF8gidVuSZKtiQE6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8WHOV/0p3430zCHWMbPEwZCbHyEwHwYDVR0j\nBBgwFoAUB7xFvWI9DJI39Rp2PMwo6EwNtL0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEA2fd7T8vcXHyC3dTwX2GgsFwkwS9rSy0hGpUkmKJrxAiEA2hfSatmK1rO6\ngToDvHT4nDqc/VlpIET48HxEz8Gq1Ck=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARvm4g/ncl0CnPxpi1K8LBDhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjhiOTdlZS1lZGUxLTRhZTEtYmJjOC0yN2JhYTZlNTczODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJa+OkQRV0cPGCC2F6K2epHXAdn1P4C3dWGRHhR/4epLsE\nOX2+KfijWsbvBx2cV9bMC5kPIhWZoHQxYm2ipYSdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB7xFvWI9DJI39Rp2PMwo6EwN\ntL0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMdbS1m8h9SvJgecCPHaIU78JgQCUEbFrRIatPyjbUYQAiAY6CuZ374y\ntAldzihlO62udZLNJ0FeJqMET86m4x2CSA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASiYKRwUCgp+B/gRclUHTPReMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhmZGRjMTctZDlhOC00OTY3LWFhMTQtMjU1ZTYyNDEwYjYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYzk4MWY5OC05YzU0\nLTRmNDktYjM2NS05YWVkZmYwM2U0NTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR5mSv4eAcHXvWE8rv7wHNjHDHxbpB2aQOK7mAsny4B/GdzKTkxFekroWld6mFv\nT2fXa3sFqTiCJdoTHC8vSEpDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTxYc5X/SnfjfTM\nIdYxs8TBkJsfITAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiAY7f+84FXRUTH6qkUQwPesgIaXtVNdZUzwrVg+9Hm4WwIh\nALZP0pteDbuzyaJuEfb3JStDsvbLzfAQuHyef1zRrnls\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3286", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3286` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAa5D2s8VOzrO7i9LSA/X5++1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMTBhNWYxLWY0YmYtNDgzMi04ZTk3LTIyM2IzM2E3ZTcwNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg5MmY4NTYtYzQ3\nYi00MGZmLTgxN2ItODNmYzI3ZWQ1ZDIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElVCWYjSuZxmD9mHGAVKGiFKYAAOifW1G5RuUOs6p88dAiW/sUQ2fTUegEOAT\nzkxf4XAGje5XufpHKCAL8EFyV6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb6J8UT21MQx8MHJbDlCuOpEpZv4wHwYDVR0j\nBBgwFoAUXHpTw4g7qlZOxiDC0IBeAGPsqz8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiA1fZCTzM4fLqfZEgYlQMzMRyZHJ3oxdijV/NdL2Jiz4gIgQAGvjQL451qU\nniOIY4K0dfHyfxhrHlfFpzlqavGVsDo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQRS7SHj+S6QuDQVK1qyGQEyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTEwYTVmMS1mNGJmLTQ4MzItOGU5Ny0yMjNiMzNhN2U3MDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWxtxBcXwOLjgSk6FkltXxd/+Lx1GvKiTfcbNIK27wd7fY\nTzj3MnQgz3BnS8VpXQcGVcDeu+pQVTNe3CsQujaQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXHpTw4g7qlZOxiDC0IBeAGPs\nqz8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNOiU21q0nPOVWtoF48EIHnZScA8cbpajkrreD+iYdL8CIAXSJ37EkjUm\nydDs3bnqcrtdSz73BLUEj0K4Fjv4caKm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAS2xInjWRdoNlGuh/khonDIsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg5MmY4NTYtYzQ3Yi00MGZmLTgxN2ItODNmYzI3ZWQ1ZDIyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0NzMxYTM2Yy0zZGVk\nLTRjY2YtYTUyNC1lMGY0MjU4YTA2NzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQP3UaBN2huRD4YAq+urw3tLO5dScWb45jIoVuMAWUs38ctAVzkUa9H1stE00Km\nmAqL3zAPWf26MgO8ZlbdXcM3o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvonxRPbUxDHww\nclsOUK46kSlm/jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBDgfIRHytVxLF+Cv+JLCyT/6F1Iz5BGerlQa7qrz/izwIg\nBmDHsRQpXrrSArqI2jHkoUexEARmF/BY/Ss9QYHoO7M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3287", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3287` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAaTpDpAcHD/t4Sv5t+z2WPsbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjNzA2NGZmLThiNTctNDgxNi1iMzgyLWZiMWUyYmFhNTNkYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDEwMjMzYTQtMDQz\nNC00MDExLWJmMDEtYWVmMzYxNmQ5OGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETe84aUYvyxikNsx0VEL3VYv/Tyi7bgX8GGdr1J8akkdmT/R9SOMK9wCc9r90\nbJChmjdMTDbqe6zkBlKqKMo6BqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1sSzduMW2dB1x25pa9XaTuhS4hMwHwYDVR0j\nBBgwFoAUKThSLfDg9YlI2BO9YV7R+RG4YjcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiALH75Yi8yUOSnXzxiaGSm5b6B9aL47Xc2E/9XcRPQp\ndwIgGJrhvziR4FNE4NZkI4xN3SMr+IrT5hEHWVPSBaV/LTM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS5w90U4J7SceAvilyfXAdicMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzcwNjRmZi04YjU3LTQ4MTYtYjM4Mi1mYjFlMmJhYTUzZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlBOTVU7w5UfEv3oqdp9rcEqRZntWuHqf11RsDgtwGcae3\no5w+qMt0dYB8RLcwIRwxTmTp7KhV8OTH0/4uURgZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKThSLfDg9YlI2BO9YV7R+RG4\nYjcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANMQgi0RREizy9iUybMY/N8Dzb+ZCkquABoF+I9QcJ5gAiEAmy2Qg33j\nwLTgYcox1MmYsiOa8hZy99/EuudVOWx+ik0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAf25Nzf5/3Mv9Gbju9NYZhhoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDEwMjMzYTQtMDQzNC00MDExLWJmMDEtYWVmMzYxNmQ5OGJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZjY1MGQ3ZS1mZTFl\nLTRiY2UtYWJlNy1hNmE3ZDM2MjEwYzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARA+h5B+K5icLOmDYNnpdEUxwjlW564wMlhi87jg+Cr6TzhAm1rdsT8bKNrwCvp\naJ8bYx/w8Am5+WgXJdeRXVTpo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWxLN24xbZ0HXH\nbmlr1dpO6FLiEzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBtb5Iwuo4QdclYLrN64xSg5eLCPyF9AS16RvdQC3E9awIh\nANNgEJwB9pQH6eUshT8vJ1D8l4VyfnXhFA4QI4ExZa+l\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3288", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3288` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAd43GN6AD2Xdk94Kdrqy4UnZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3OTMxNGZjLWEyZDktNDdiZC1iNTU4LTc1MDA3MGRmMjk4YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzMwMDkxZTItZDJl\nMy00N2RjLWI0NDQtNTViNWY1ODkyMmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgrsYo3IuMwlhrEqP0j47XRUTUBOgiFOScrPc0tin9Zr6B7OgMflqAodJ2iBF\netRVihlykfkj3S0mZwjNlQcd0aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBFMG4wiJFhvwbSQbEwZ70XjKVhgwHwYDVR0j\nBBgwFoAUY/Zb/qXIygF7c+lAdBRfIo3/wcEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiA6MCw6U+neSZS2rucqyeaYlYC5WkNftbjXFf5L1BR2\nuwIhAJZIyCNvG3JktMgijLBDxSwCyVIIY3ad/8lzmwi/YHl1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZVYk5R2imslP8up9rJkxSAkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzkzMTRmYy1hMmQ5LTQ3YmQtYjU1OC03NTAwNzBkZjI5OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjYVxcX4EgZ8CbD/o8fkwik3zqHLHEmdfQEbDFve7FMjQ5\n4Lj5U/cTuKH2758DYlIQo9Lhq3lYTBSfAu9qso1Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY/Zb/qXIygF7c+lAdBRfIo3/\nwcEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWmO112SgGf1/bv/DUXDlYpHmsdHRHXNTkdH/tuHCHQwCIBFt50SJ0aZx\n1VccP3XinlwBrN2gjVLP5uqn9NVRvuSH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWaKgOhsiUH7nVlnkqsgILhKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzMwMDkxZTItZDJlMy00N2RjLWI0NDQtNTViNWY1ODkyMmQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YzMxMzJkNy1jZDRh\nLTQwNmEtOGIzNi1lOTIzNDcyMzU2MDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASgCafwIES35LaB872RvpWehFvRHc6PhKvZYEX3BMCTOZNJkRS7kKfzEYiJt9WS\nwLVlsV4ckdghj6E3IxljugC9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQEUwbjCIkWG/Bt\nJBsTBnvReMpWGDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBESwI4i6LUOGgPaOwWEro3nDeLW6iwe69h1/uzNa4rXgIh\nAKjA+wt6WIwT4pBWZ3mE4qkx+arVkwU+9kmSqU+j2uxw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3289", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3289` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAaRGdR6YujXaViDYPdOQJTXpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjZmUxODU0LTg1ZWEtNDUxOS04NGFmLTVlNzM5ZDczZWM4YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBmMzZkOTEtMDI4\nOS00YTUyLTlmODgtNTgzZGE4MzcwNTI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETbMTRiGrAbybsSXlnfgL3qzAska2lsMUBMM8kDaiWgpw4jqORFNnJAgA+v9x\nhlS9EbqkUlIoB/HkxjGk1oPYN6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdZZNkQ8zzL2idMTMlWvAT8qiEkEwHwYDVR0j\nBBgwFoAUvc03DMFHvIIHvCU4E+MB6hfZcNYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAwzJxRkCpYxS///QtwECV5BHY36xbYGIwICtQryMQG9ICIHvL\nXJOgIlH6DMphbWxn1LgBO3cFUcyQ9IjWfJnHQiwg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ6Y2gJHrHFxPwjJti+Zq0tOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nY2ZlMTg1NC04NWVhLTQ1MTktODRhZi01ZTczOWQ3M2VjOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg8cSGXu2yWOsgK0PnbJBkbqss6WpcMd7VFGXejOO2ro7/\nm4SSt0VXLwU2kpRAN1qpSa1c22vfE5WfzbYFET2Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvc03DMFHvIIHvCU4E+MB6hfZ\ncNYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALsqvrJtMSiY00+7Axj8Gt5zAPy7CxhXYkGGZLEXFeN7AiEA1vv+HFpR\n/V+/psSv+B/2V2Wyz1NS4/nk6HYdfjh312M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAR9EJ/RX90TiBMGVO/XhPxBIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBmMzZkOTEtMDI4OS00YTUyLTlmODgtNTgzZGE4MzcwNTI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmZTA5YTNkZC0wMGJj\nLTRjNWMtOTg2OC1jOTJhZTFkOWQ0YzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQXIGBcRRqVZsxPphnBE0Fhb6RNawV8JaHYNeFhPvf3zfRcmOXbeq7jjNziUFHL\nWb0HrUWHEdv7h7cjzDfEpZv5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1lk2RDzPMvaJ0\nxMyVa8BPyqISQTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEApWYnndWd+zOBwOYo3+YcgAhvI4Q/4NGmtyvEMFB7bZ8C\nIGVv3JGUvfUKwn1qNUumk9oIc8wT+RMWspT8X11oi7ft\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3290", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3290` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQUJJkq2tVJtJO7TnzILTdzYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzNDg5ZjkzLTZiODMtNGYwYS1iYzRmLWExZjk2Y2IxNjJhMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzM0ODY1NDgtMDMw\nOS00OGUwLTkyNmItMTI1ZTVlN2JkNGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBQJo1vLJM7MhH+upAaxv6auJmgLG02HU3ds2hnOEbHaiRZPffNHoEQHhj0Qv\nqGoUAmqD8J7c3MZXormIJz0mcKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoEKW/fLJJGd4Wl/3XzPNfNmqYU8wHwYDVR0j\nBBgwFoAUEfK2jkBxjePheAseRrY+yDkeGjowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA5nUOO0Yi51gK7NBoH5a2/EkM4hyMJCdm\nZJkeU2lpPXACICEZFdigyxB4SU4+XaB4sP0+lgpDM4pj/HER28LCDRmz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARKB+6gGdmnYLIRzvGzSneB2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzQ4OWY5My02YjgzLTRmMGEtYmM0Zi1hMWY5NmNiMTYyYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeUczw45A5aamzPSFbTDW/5YzVq5cC4HkxTYbhQrCsi5q4\ncYuLPtBuHZ4iLtn4JaAuNY4qWVdzlbbhFaBbHrNqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEfK2jkBxjePheAseRrY+yDke\nGjowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK1K2SxcW4hW45ycWsd3TXmblzZpc3AE4GtrtZB8r6uUCIQDkwiNQXRVC\nl5gm6qbEwbMjUOQ8QIl1d1RI4lUovDgsZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASvePZ2tk5qH4JCNKdNacSMvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzM0ODY1NDgtMDMwOS00OGUwLTkyNmItMTI1ZTVlN2JkNGFkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMzAzODZjMy1jMWYw\nLTRlZTctYTYxZC1iNzcwYmRkZWJlNGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQVytwXIEsWtoVpuJSG00aUQITgoYe5EeRQRUSI/ltVa1Lu5hMZJYFvbxjH0Ai7\ni+fb2J+ZXhVa+2zVvwFf5Uhpo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgQpb98skkZ3ha\nX/dfM8182aphTzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAFjkjlV/wq0/r/wTisipYhvYSupBjxTCkXyxBGY6rhLAIg\nDlxBZ2zMyXSwYzlu/tT5ljS6rp+RkKwWT4Z53a68GpQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3291", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3291` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAcUgwQGsgHVgCLfP5yRjhBEMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ODEzZGI4LTQzMDgtNDRiMy1hZDBmLTgwZjFmMzM2MWQyNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUyNDE1YmQtYWM2\nMS00Yzg1LWI3ODgtYWY2MDgxMzJlM2FjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhBozGBqyfXpXXnG79wF5KqyEJXibjw8y5rJZ+xbsQoEBfRZQNinxsqKZf04B\nQVVPpQR4vS8T0yJS5GJFWc4ei6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqbWv/9nwk2ni8whNqAvXddJ+nn0wHwYDVR0j\nBBgwFoAUsm7Il7wUtPtBmwkfAn7QYh3zh0EwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBoBtaBoYLjTaGVnuOSrU5ONHN3+EEDe049\nr7L0sK9xRQIgfuE+j49HHARgaEFXSM5DDcCF+3o5jHhvGtjyp8x3O4Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVOrB7O9NkqCurz6b82homDZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODgxM2RiOC00MzA4LTQ0YjMtYWQwZi04MGYxZjMzNjFkMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+CQFvlJB1/wANeVL7GNoNUNWTzI9cZdp5z0WqlYGhuf7P\nPlKX+cYF/Z+5AMUBWnLM1ulbZl+UYufc2kdbDexWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsm7Il7wUtPtBmwkfAn7QYh3z\nh0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVIAVtD3KdJ/6YQLwVLAcZpBkInHO64eVhLQR3AuGr1sCIEmQJtE7wA7M\nU+2ZUoxgIs5QPCN2yBLWrYpkBEZTToY8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfQaxuoRhgDynh7uXlCFsh0vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUyNDE1YmQtYWM2MS00Yzg1LWI3ODgtYWY2MDgxMzJlM2FjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZGY4YjBlZi00YjQ1\nLTQ5N2UtYjQzMi02NTAyMjk1NjllZjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQLlVvdO37iQm9q9S39qW6qai+Vqvtl/5QWjt7v811+hbYgVaK8G6VVp7Z+C5A1\nvyPEwm1jhSLJlp4NXjbsFCQAo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSpta//2fCTaeLz\nCE2oC9d10n6efTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBVEW5QtGe2nK5SXmTO0wiQkToX+92xYulUh0TbP955LAIg\nCiIgvRCTUiAH8pVAu/XSO8jlz+3li99c4lPzU8w2JYY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3292", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3292` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAUmhRREN8iwbBFibgHZ8mGIYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkNmE4MGVlLWY3OGUtNDhhMy04MzdjLTFmMmE0Nzc5ZDJjYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQwYjYyYWQtNDNl\nYy00ZjY5LWJiMDctMTk4ZDFmYWU3YzZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQisqg1JQZhb7tib+gCaRn+bCX684Fl3jyJHnG4r5+XSXNzl2QFQ7hHuk+zGH\n9jIXXtgqFlGJG6LJPW6mGsRRY6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8j02DjHfIveTqCajL6NtFKooV/owHwYDVR0j\nBBgwFoAU9HfXL591YWWgemJ4fKvt4bBSKPMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA8FE+QyGJ9Dev\nve17AW5v1kLuUnXra+eu/0skIw4o8WYCIFb/AULSkbmwHDxSzL8dbS6cCVW5ya+v\nrDJ2TN3vcRmX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZUEU+xtpFgfM9F2TSEKpMtIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDZhODBlZS1mNzhlLTQ4YTMtODM3Yy0xZjJhNDc3OWQyY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhU2PTeBjtcmtQddYH4LhVMUWJQFoOPaet0EZo78siuXUl\nLCoPCgvhybrTr8lM0hPDkbyCTi+lUPlAz9KgWCfgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9HfXL591YWWgemJ4fKvt4bBS\nKPMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANyChCKnumYg0mQbtGIvL3uzWmEWYiA88AfrM3yhs9caAiEAiLvt8HJa\n1cJrbtXTfha/kMgl79NSc2OgzMvWbEdt96A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAUFAP9vSZmLqOD0F0amxZqc9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQwYjYyYWQtNDNlYy00ZjY5LWJiMDctMTk4ZDFmYWU3YzZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmODlkZmE4NS0xYzEz\nLTRlNDQtYTA4ZS1mNTJlY2RjMWUyNjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARu+PFTm7fNVUnEAp5KU1jFJtyYapZAVZlnKMEl2BMBhOOSpHKOPe6dy5OyRYRC\nS8rK9dA5L/WALFygx/iAPu/Oo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyPTYOMd8i95Oo\nJqMvo20UqihX+jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAWKipPoq3+QsxWlre0EruXMYw8NBZdvqbeAX7/MW2z4gIg\nK/5AVtF1Kyacp1qVaN8YNwmR91LA0iOwqiJWbYEjdW0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3293", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3293` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAV76NTHVd3H3ClBzNOt10I4FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlYWNhMDQ0LWVjYjgtNDhhZi05Y2MwLWJkZDExMDAzYWZlOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRmODE4NjYtMDIw\nMi00Zjk0LWFiMzUtMGRhZTVjZDFhNjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+/TtNRiIgQe+EHxo6hNQlEnCWJIL8YKOqs6ZFfAvgG70EbafzMnwPH9f6e3z\nPWiV854bmzPMQUEdihrV2czaFKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFzGlGeZa0C9fg2LyQtrKBmIjKVgwHwYDVR0j\nBBgwFoAU58NVokRkkQ2W5HeVwpdl4oJi34swNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIE8ZZiXnBeI6dMtuaTZaX5phtg+7BvLaBqF40AXslSdSAiBTAmgeochPfHi5\ngYvIKUSJm7bIGxxBDHjuURDHxciOUg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAczWl+5oj2ygAbDepYkhIoInMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZWFjYTA0NC1lY2I4LTQ4YWYtOWNjMC1iZGQxMTAwM2FmZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSoNAAfYFYMHg9QMzcvETksm+stFKxBvvniI8NVPcAeo2F\nBDy28QGgMDeds8TA9rdpzzu8gY0OCrHM4VMakAYAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU58NVokRkkQ2W5HeVwpdl4oJi\n34swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJYdVmYub7844nNR2krKC/Pmfmo04tTkh2TLrUimr23NAiBeKin2BsGD\nPwyLFaykeQAkeS8fYKRqea6SW5hTkxyT+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAeWCRIUvtEXF5wwfyzbmcVjbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRmODE4NjYtMDIwMi00Zjk0LWFiMzUtMGRhZTVjZDFhNjFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YjM4ZmM1MC1mY2Y4\nLTQ2ZTktYThlMS1jOGYwYjk1ZmEyNGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT5cUyFmjYh1Sr5ABBn/T8B/GH7y6ZrNJmiB5MbeTIECLKRdXlSILVi/B2bJIRs\nRxW/tC5NZTC2t7PtCoVRUhzIo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXMaUZ5lrQL1+D\nYvJC2soGYiMpWDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiA349WE1zoDdNyJjc6ZN2lgYWkBLWsDNOiZ9Bm/cZ39uwIg\nKscR69V3Wm+rytXvwNHXoB1x8U5Texm2tLIns8FliQU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3294", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3294` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVQu9zek3tB5S6q77aLDiNS4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViNjlkY2NkLWQxYjEtNDhlYS1hMDBhLTNkNDE2Mzg0YzZiMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg3OGIxZDAtOWVk\nYi00ODAxLWI0ZjMtNTgyZTIwYmY4NmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESSFYhoEMzBOUheTaDD/8CZpB5x9hXRh0kCJiVJUnR3ZFbzDnoXUv2A3FbFkG\nuh5MBOEbeqTxEQcxKG59T5LMTqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPoSNb3WHeUHLuQ/04K/fn170OnEwHwYDVR0j\nBBgwFoAUl2+LDx+Kkr3X4/i0K1Rc0wDFMhAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDpAC/CEbqTo0tKT5GeqiyTZ6ktRttVHw18Us4z02kTCgIhANJoYm+YyIRu\njLgseZGptFQdLcaEsWJMDhluZNUu6ZfS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa58LU8GGgvw/pVlKQ9x8AAUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjY5ZGNjZC1kMWIxLTQ4ZWEtYTAwYS0zZDQxNjM4NGM2YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt7IROtcBOHuGefgV9+rYWcdF9Qfvbz44gx8gVOlyBESWK\n/whh05L5Y+SO9Q01ycLXP2hNQE1WZWtW1SvxB8HBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl2+LDx+Kkr3X4/i0K1Rc0wDF\nMhAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOPJ/2BSCyiNV7fNkD71eRZ+ZbAJGU/+iUoNpFosDTnfAiEAwxTTV+1+\n7k8Kch1EWDgYVHeGo2NfGaLFjMx6+O4dm6E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAb/tZUu6Xut6GZpom8oB51k6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg3OGIxZDAtOWVkYi00ODAxLWI0ZjMtNTgyZTIwYmY4NmJkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMjg0MDI2MC0yZjdj\nLTRmZTItOTBlMS1mMmQ0ZDQ0OTI0ODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATNgULeBHoz1DzfBVr2hY/RQlUnFQgPaED/odRU6Gc6PkIgQu9nh62Pxp27kTrY\nNGsCwoUqem74IrukQ2GAkeWjo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ+hI1vdYd5Qcu5\nD/Tgr9+fXvQ6cTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiB5WmypqsQkp0+GhCimLp+PeeTE847I1aTYvmJ2yRxY5QIh\nALMtgJ862/e7KA1x5v9HI63mrsG0ne1L5pGzNo01sVs9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3295", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3295` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAWEKdqFqecLgw9/LSzfY195tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzODMwMDFmLTUzMTItNDk5OS05ZTgyLTJmOTMwZjliMGI5NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZiZDlkZjgtMGY5\nMi00NjRhLTlhOGUtYmNiOTIwNzRmMmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE01vXUSZH10DYnsYAr9/I1+CCoyBjGyKNfdO07kHGi6wZPl0TflAQWTBolvGv\nEqYGfq2S6b2tNAt5l/GGpFR7pKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURah810ZryS8y3lAFWyXrYCU5FDwwHwYDVR0j\nBBgwFoAU9SdQrNgcsUxfJHqVF2Wu/eflvaYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiA+bmhBqFJQduQzF/Rzvyz2OCxG1V3pylcTAo3hTVoS8AIhAMUsJnFydjdY\nCDNZZe+nJxoa9lJr8tLLOMb/MVMVE10C\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWOQ0MJVg1OgZmCus1BltApeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzgzMDAxZi01MzEyLTQ5OTktOWU4Mi0yZjkzMGY5YjBiOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSbvSUMfRAlibobSvDEWufoBsSPcZgA7sT/458gnV5mSnr\naAzwpeXKonnXpAECH2Ye1cUmymdjXTAFYf189DENo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9SdQrNgcsUxfJHqVF2Wu/efl\nvaYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY3Xuf5Dn6M6BHylWUA6NoYgVGi6Ho/hVGz/ECesS5u8CIQC+7hQilXcV\ntSP7TgZTky6YjUtiW1DS6zp14vTIxQcu2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAWq1/4A420ssS2NFYx3DTwPvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZiZDlkZjgtMGY5Mi00NjRhLTlhOGUtYmNiOTIwNzRmMmEyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNWYzNTViNS01ZDYy\nLTQ5YjktYjllNi1mNmMxODQ5YWU4ODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQefsTQxq1fuXIwMzD+eNvObSWzspbCd3rtyzP6XOyQKjTidN/oK5SLMCBJYDk5\nWzHR6Vj1TOrjtFattAGTGVhPo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFqHzXRmvJLzLe\nUAVbJetgJTkUPDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA6vHCxODDK1qsJBr+qwxdei3dR7TeJfuwYzDrjb6fDhkC\nIQCuLB0akY6PxYa6JYA3Xw5yf8KfhAc3+6iEyGIUP0NOwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3296", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3296` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAU6/EAHAlj3E6W8QQfDDIgwJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1NTk2Yzk1LTk1YTUtNDMzYi04YWViLTgzYjgwMGY2YWViYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdiMmY1YjgtMjJk\nZC00MTIxLWI3ZWMtMzNiMDJkZTJmYTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHN61h3e/kGf03x6emwdCncM1u1rnxJs1E4wO3tEUdKWKdMvYBIDpVdHtVxhk\nTybe6CzUvW4CUfrAPV8kS93he6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8yS2rTY9bHXXrsA8SAHTRh80CHQwHwYDVR0j\nBBgwFoAU9+bCKXjq2RW36tUqvkB+gXbFXtQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAnm6vO3oRVeYShq+YwD2QMtVejT9NtBGw7VB9ecYZ\nHocCIGIYNoaPqqwKlAmPy6aDusING3euA0maGhgvLXOmL8jZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfQaijj1+GgrWfJPtjFSMwipMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTU5NmM5NS05NWE1LTQzM2ItOGFlYi04M2I4MDBmNmFlYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR24myQYvKMFgeyHVN+PSXl7p6f17A2U9D0VBbs4oCYeIZD\nW3nE0HMdrmfR6MLicLlT/P7n85ujrbwvkNT76r0to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9+bCKXjq2RW36tUqvkB+gXbF\nXtQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANIJElKQmWMQ8u26rUelsbfEzmC7roTIGVSmJX20tXYBAiEA5pUdmdn5\n2Dsm9JoqrAS6R94JW6AepRAYsRHXFJxl0ds=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASk2NZA6UXj/eDl426LuHrBHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdiMmY1YjgtMjJkZC00MTIxLWI3ZWMtMzNiMDJkZTJmYTdiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYTdkNGE0YS0xMTQ3\nLTQ0YWItYjhiNi1jYTI2M2I4NDYzYTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARNiWcHdOngabJqrum0J+pgPT0+hFXs2l2mIVvjYOL4acrufLJCCjrvQkE1aUap\ne82oI9CmMHoBEA3CsPX2f0//o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTzJLatNj1sddeu\nwDxIAdNGHzQIdDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAXfMgybTkVGFJN4YxPUEtV8Wk87p1T0SY6fP+AJVGsiAIg\nXV3dzwGUZ0Y4VHBC4IRWKkN1vT9tTFLng5yvUSt18Vw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3297", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3297` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAbAz6zXiEdIVJY0yYzBMwt5dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4NjQ3OGM1LWE1ZjAtNGYzOS1hNjMwLWFjM2VjNWIxODNhMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE1M2E5MzktNDFk\nMi00ZmEwLTkwOWMtMTM4ZmQ0ZDEzNjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5PSTTe00UoMCBI5u1fHe9bGsoAUsJyscijVQKrkXXoXyAhum1WrVeOcAlXIE\nqQQhMRSzB0cF0pKQoRPXZijKu6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsOEBwHDmYuf6KCyMK8vboNtnDUUwHwYDVR0j\nBBgwFoAU6Ok9SFhTcUl/cAAh8hy1V8nLgGMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA3L2aPr+EAp2xj1yfaIZ41Es0HNA5SQrwsByCV8OL\nQLYCIQCMqECJBdFkG3QGxd+SR5IkrDO6572yVWLqt6nPqS+ukA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ86xaRWsFom5v3Ci+NjfhtuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODY0NzhjNS1hNWYwLTRmMzktYTYzMC1hYzNlYzViMTgzYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9bZ3Y2se6ATiGsqaqxrx1iQ+tHsumShIOQ2EGRDM0kTLo\nfSiHieu9IaiTiLuyDVcPnpRJGs38GxIbBcZeFQGuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Ok9SFhTcUl/cAAh8hy1V8nL\ngGMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIiFdSdGt5LXbHzYr/sng1WgANbaPsKq2afzxRK97KuJAiBbJMl7TgAx\njskQxs8cIfbgTDBUAhrqexBdjY5wXcZX+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAbfeMwxCNQr6E6ONy490HZtPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE1M2E5MzktNDFkMi00ZmEwLTkwOWMtMTM4ZmQ0ZDEzNjRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYzI3ZTA4Mi00MDRk\nLTRjMDItOTg2OS0xYTk4NGM4OGQ4NTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQq9C1biZBp6JYQbVX6+bkNAArIc3acFTwi8GXNywlZP58p22tWYFNlsIg+hxzy\nTUJRg1cExWtWXwwXTgwo+o9Lo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSw4QHAcOZi5/oo\nLIwry9ug22cNRTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAphKV9vGLvgkvy99Ojaqwbiz4uCikMS0DgnRUtzFN68gIg\nZC+MWTOmzUkPsDONBcDqjMe6+31/Sj7Id8gFN3n/Zcw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3298", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3298` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAcrVD/ulLiq4utJBz7nuc7qOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlYmYwY2I3LWUzNzUtNDU4Ny04MTVjLTg1YzBkMmFmZjgxMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVkYTBkMDYtYzBk\nMi00YWIxLWI1OGUtNDJlZTlmNGNjYTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZzGU+JMZKMIkoJUIwZzcTjOZ82W7NPPZrUDn/CCIKpYmtXpg5Zr9bbpFi+Bc\nnFat1PtWfMKE1YSPamBg2cA6P6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW/i/gB1VFXg2gmSiI+qfTYyIkoYwHwYDVR0j\nBBgwFoAU3A6CwJFgbjeGbWHZ5ZdKLCKH5UgwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAcecO6GKi6FqMyjbCgzI7yvW2DzmQEq29DrzsItWJM2gIhAPF3\nh27Bhqf0tA9ENbZNkGmT+Re2bBPSB9YZ8lFLBMno\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeIE/ubZQarK22Z80XVSWiiLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWJmMGNiNy1lMzc1LTQ1ODctODE1Yy04NWMwZDJhZmY4MTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAW3S+udnZgzhMPt9YBT3Er7hKHZKutwcNgkUanEO8AN20\niaLw/okf7fqDJ+ddY9IKp1OdKUi88R0lUHg6rdsRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3A6CwJFgbjeGbWHZ5ZdKLCKH\n5UgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJodptue7aqrkvPseDSBMFxl6nRNgZefZ44QQjXgiUiBAiApmjTDkhLu\n9R7tAReE/JuCF/r+uOqcpZBwx+kI8bGHXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAY5v55va1IHx8wIZlIiUn8puMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVkYTBkMDYtYzBkMi00YWIxLWI1OGUtNDJlZTlmNGNjYTMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNGUwYTg1MS1lNjBh\nLTRkZDMtODBhZS1kZGZmM2IwNGFiZGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQfNoqLlYaTVsIR9Whn5VVW2HCUSX3YCL0I3HS03SRwh+PUtc/49U09et9NI0ra\nwTG7hDol07nqV158ssUGA6KKo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRb+L+AHVUVeDaC\nZKIj6p9NjIiShjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAFVX4LwwaGt58ZDbpfUev7zt7jG1LwgyD97yUk9tPW9QIg\nNgIuD15m4OLa1uF5AP2+dXTYNLojcqLOrLg6nwKmInY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3299", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3299` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARboO2DrwFsVF3awJFUVXdfYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjZTM1ZjcyLTA0ODQtNGVhMy05NzhkLWY2ZGMyMjkzMjk0NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI3Njk1OTktYzVl\nMC00NjRhLWJiYzMtOWJjMDViYzAzNGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvXXrfTw2uvJ4EB2wLTaciwUefXeLgsD0yOUcpjCzFiAeA240DyJGZfolQFGX\nyLmxs8W7cCPUrY+5xZ1vCbphhqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5BkOpHPLptyVqPNj6SKv14oh/ScwHwYDVR0j\nBBgwFoAUdd1GmaxdW4sxC6UUsOoizfTgLBswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBEKfaVruxhMpGMxs8V3GPRXrTfV8Xt8+Ih\npQKFARAYEQIhAMtnUSlpfP8NQ6367wUfGypYWcj7YZFeIh1fxUyH5o6U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbqcPSdw9C48YlrF8UOGcHcJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2UzNWY3Mi0wNDg0LTRlYTMtOTc4ZC1mNmRjMjI5MzI5NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKApl0So5P3y0CSrVAbZc8Ra+fGgcHT7YX8xPlkZFY3k96\nrWEscv4K73dPR7ZwjHfwu2cRMcb4URuO8DCGDrlRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdd1GmaxdW4sxC6UUsOoizfTg\nLBswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE5hJ9Suh5TY0P2QFO4DtAWpOfny3rnyXNsIHDixRtKgCIHqVpi0nzMf0\nImDWoB0Li4LXbW3pBIOXOeXRVqUBmfdX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATcQgHY/8svXAuv895LoLx0SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI3Njk1OTktYzVlMC00NjRhLWJiYzMtOWJjMDViYzAzNGQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNGM3NGIyMi1hMGIx\nLTQ3MDMtYTJlZC02MDk4ZTRmOWU1YzIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ9cRBnmNb5PaHb4z5g3AvT8veY+I/1sxURlIdQNZTomehlj0giSV/QNZD2sedm\n9TOKFPMwV5WRqVhWhMz7WA1Wo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTkGQ6kc8um3JWo\n82PpIq/XiiH9JzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAmTVIDgeZCJLoTe63Ox6ePpYw3eSGmFe0kko2ARpxZ0AC\nIGkidwrU/0Ecg7Dll+vilBOQ3n5SyJ4u4gyrlZinHKQT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3300", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3300` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbb4P0LzyHvvyh7zKMhwPa8IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5MmE1MWQyLTMxNWUtNDI2YS04NDI2LTliZmYwY2M5OGY3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q0YWM0YWItZmYy\nMi00ZjY3LWIyM2ItNmZiZWVlMzU4NTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdDylUGMIpggUXbzpHJWzgwjawRN6tal83MevZiA28n5t0V8DmBgZOaDvP8Az\n5HpzovQakNoYK7dn6HPlwFYK/qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE2Dccv5inVk0IPeQ111a9AapbrYwHwYDVR0j\nBBgwFoAUK/LFuFvsdEqKHJmuqnN21F+MdpMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA7oItYqk35Oe7pGGE+2OJRSvCSGMpj8RP\nr1S2cECqkK4CIDYkjs2wS4sfyIxCc4ghuUv6/vckchiCal/s2rwPnACm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV5rgRPg+4+8KtRaeXEJMGL6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTJhNTFkMi0zMTVlLTQyNmEtODQyNi05YmZmMGNjOThmN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3oxT0aKXgkK3GxKLib1FR4RNkAWapo/7I9ZiArj/KcOYh\n1kBx2MPaYUOolumr1MFd9+tEhJXZMvFdEbh/TzJoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK/LFuFvsdEqKHJmuqnN21F+M\ndpMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK9sYQ+pZFUfgd1bO1aLqPMNM99s/tXv6qUTK3+AkF7kCIGaHitsuoe7c\nRW0+jQTha86U5ELvygkukDJ9lsSWdqG7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASqsDzmsdMn5jMJmi/445ckQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q0YWM0YWItZmYyMi00ZjY3LWIyM2ItNmZiZWVlMzU4NTE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYWVjMGQ0Ni1iNjdk\nLTRhMjAtYjVkMS1kZWE5NGM5NmM3YmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASlTtDqbcll6x4Y29vXwDqh2HT3/vP5xnImHb0EfWh7keueecJfv95EtuxpqyI1\n0TxOLaD8nTL5R8GpJPUxrQEPo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQTYNxy/mKdWTQg\n95DXXVr0BqlutjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiA4hj9KYJIcXEZIJ5xSYP8qT29DHZkEgtRhzZgoLkn76AIh\nAP5rtbD+uB6TtQ+Kg+ambzhIT029tFVbSeNJQlCCWtyR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3301", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3301` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAVbJgBLgHgym61EgoptSB9p+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NjY3ZWVmLWM3ZDktNDhmNi04YTcyLTMxMGRiZjNlYzYxNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAxZWVkMWYtYmI2\nYS00NzAyLWEyMGYtZTJiMjkwZDgzYzk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6KGGLWCfswFetTI/c5qkCiaDf1oq8/zf8W7mhNG5ier19OezB4nppQZKSmZb\nByVo8nfLvqtddDiopkLA8HSMxKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwLwz9mgiiLNqNbBx6mPxED/7Q64wHwYDVR0j\nBBgwFoAU/zyY4Gq7x8s+lMUeToSKS+gTjBcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQClDWOYlqaO0bo921Gqie4lpQHa\nglGz/9Jjx2cm+QeeQAIhALjYZwMNwhrR6EElnik+ls/WvHndkXIS7jUgMCyoaNca\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAegdnLVv+ccN6ymu/mHjgED+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODY2N2VlZi1jN2Q5LTQ4ZjYtOGE3Mi0zMTBkYmYzZWM2MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/bbLjLeHJ3LDeEwQA1h1bvADzjWF0xubSarFPoH8ngDSj\nyWksJRsvOFJNYtzZFhBdEG/xXYbrZUe0hmJwtiLmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/zyY4Gq7x8s+lMUeToSKS+gT\njBcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgULasQ/1HNfns2YpU2Bg4dro2Ueadx7sGGgLO/SF8oT0CIBk8AN4NKbtA\nATUgy1EgOR7JkqoPrqeQb4KEICtLl6xh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUl+GOyeFp3wNo1z/IWHCzXHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAxZWVkMWYtYmI2YS00NzAyLWEyMGYtZTJiMjkwZDgzYzk5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ODNlMmRhMy1iYTk3\nLTQ5NTUtYWFjYi1mODk4YzkxMzYwNjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARpEODtQh/r2d3Vao3kRm9/ir4iyA6FqTxMjlt8GeNZR4Dj/EIFhmGTEp4WovC+\nPBRDWSuWIp7Xw7IWg6uJWlmPo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAvDP2aCKIs2o1\nsHHqY/EQP/tDrjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAxo5uSNA+bs0+ACKb9Drg5W3eIqK9/HX5LqDs16UniaoC\nIAUemb9JF8nDNFE6ube2Qs5XFgdsAGbxU7cV9DVhVpgT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3302", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3302` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAQFnFyLa36H8C1DnK0Zj9pt2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmZDQwMjNjLWM0NGEtNGI5YS05NzYyLThiOTdhMWNhOGEwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZmYzVkYWEtNzJm\nNC00N2I1LTkyODctMzVlYzlmMTc0NTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETalrO47jT9auxtYm14T1PfosAcSP5pCEi5F3YOkw13Z1txNxd3UHsENLiehh\nA88zZvL/3Sko77OuINsxT2JRjKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsyYywIsIeDn4S9h5a1eDkWYUfwcwHwYDVR0j\nBBgwFoAUYgdF2MKvE/xpxlK7XlpEVANHeiQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKyBDDyM\nnNh970Z6eAev7Ad2dfy6yEtJ7w/eqG6DjB8bAiAb0NUd3uZ71b5p8aIY0qWLvCzg\nY0zBOELBQhmPF7fSJQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATXijzNwgvVTpv00Ys1qgNx2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmQ0MDIzYy1jNDRhLTRiOWEtOTc2Mi04Yjk3YTFjYThhMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARv5rG20LPBKbUI/3ciYluQi6Wdqq4AknFVx64fHCnLqEWI\npZ9FdCIwaGoMPP04MXFl82ym//HE6BpNG2UkAx9mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYgdF2MKvE/xpxlK7XlpEVANH\neiQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaq8ieJQ0tFapQvfcR+IvHIP5qT9G2T9Vj7zRLGtyUQgCIEtoiuTbBgdV\nhM/5PB3229P4s1ogdFNTTeSA6BC09dBz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfgy42VJRXgslR2wVuNwDp7wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZmYzVkYWEtNzJmNC00N2I1LTkyODctMzVlYzlmMTc0NTQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MDMyM2I5NS1mOTMw\nLTQ1Y2ItYmVjNi01ZmIxNTZjZmE3YmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS52oFa4D3qLAdR3dv5apnO6mqMNkpehBGofL0B1dsLyZpZDSUdqJzWLiS7dtjG\nufuknoC42q4wz6aslgykDSFPo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSzJjLAiwh4OfhL\n2HlrV4ORZhR/BzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAyym6W9uJ8j57mdVGQJrD0s/x9DGfYMhB3K8q4+wJiEAIg\nXVTX7qKqZIaqyVbZ2CATXRIbzHTsM7Bj6uYalSD4oss=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3303", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3303` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISATLUqRWkag3GXMXK5AV7jfgFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3MjlhZmEyLWJlMDAtNGYzMC05MWQxLWEyYTRmMjg1MzNkMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU4ZGQ5ODktYTQ2\nZC00ZTg1LWEyOTgtYWFjMjY0NzgyODFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExbxTPwQJAmdO8iBZRUZ8X3kAOU+w13eTXs3Ru5TkEz5rjvoA3Tbsk9rMle0N\n0m3ASqbJNic98TH/0rXeWksH+qOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKmUieVom4FS2yIxx+PYXBWmAtbgwHwYDVR0j\nBBgwFoAUH4EIwbkV8y8UKObp2Y14l9ryGdEwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgccSzNPFB\nCzOx0PQEVRtDPFJ2VF940kpYc3pCIPOxT3MCIDQL08QidFgn2eU+t977Ff1gO0ps\npbp68dcVTeWxi3pY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdRzTHVT/6j/CDjInpj7L059MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzI5YWZhMi1iZTAwLTRmMzAtOTFkMS1hMmE0ZjI4NTMzZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFoShMYYuE8jTATYhQIUH/nUIXR1AART3hoesh9E1FiUDe\n9XbmQuxKC8SJ3h8RgJUiL2Vk1nq3+XqDvtv7hzsAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH4EIwbkV8y8UKObp2Y14l9ry\nGdEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALOH9TPdwgl8lGxyFJC9XckuFGyx1580kxLr4DVy0xqWAiEAzn95+32O\nUCvuSaRTL8k+7vrJkbLUqzn/+EoSASUqv4s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAeUMAqp+otYQ/8UpBkQCFXU3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU4ZGQ5ODktYTQ2ZC00ZTg1LWEyOTgtYWFjMjY0NzgyODFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YTRiYjVkNy04Njhm\nLTQ5ZjMtYjQ1NC01NzAyZTM5MDE2YjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASrAPHQ8epp9l2usMVOMQZ2o/kKlWcZMpfCgPmRUeZuICw4awleTc60xwkkyzpP\nvaVS8VqPPwlThjUoZjtinJ4Ho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQqZSJ5WibgVLbI\njHH49hcFaYC1uDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiA9wWwv/O8vWmy5kqvV92MnaZEyZrzZCQrqaOzc1VmoswIh\nALMG6rjCTN+Wz6kdD6plTiYqln+HbAC6b0tgmsou4lFc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3304", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3304` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAUJayj8zPwh51uzHQlyavKHgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmZWQ4ZGY5LTg1MzUtNDRkOC05YjJlLTAwNDdhNmVlMmYwMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNmYjliYjEtZGI0\nMC00MTRkLWI1MDUtOTNlNzM4N2M5NTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqWBmBN6am7l7NBPDEdHCy4pZq1wUiZ6uSGDIhYy0+yiyMw91vTH7ERjVtXNg\nfeI4EkC6vqtYqZ734OXxrz8Ja6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUffTDg9ISmqnLlYJmJBYtcZkanagwHwYDVR0j\nBBgwFoAU1h0a5yusrRn8+ngetedOZX/qbQAwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDRQvUx5\nuYkYgiynWyy83opeMys6E0QlBLe8JHPTP186AiBR7MhM3Zw0rawnzYNsZJXJ7ShQ\nYhGtl9g0+HgG2v8Mgw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbG9ZKGoOkQzUTGtRLWiKMy3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmVkOGRmOS04NTM1LTQ0ZDgtOWIyZS0wMDQ3YTZlZTJmMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWRn6ZO+M3u38VoqisWMYcs8ELAJKOyVLaxoOQ6tKc3kG3\nuERHG/IjNo+P6boktSLSr14ppRlw1+elEUZUSTWxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1h0a5yusrRn8+ngetedOZX/q\nbQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKPY6iTYtWJrf8dzeGupW8VnMzwapBCY/sHCo8yC1Pm4CIFvrlCWxOwMF\niLHIEl/JjEOyJZqn5HJiZBtxGz2OxCC5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAcSpgZNpG6A/ZsegKZN8wd96MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNmYjliYjEtZGI0MC00MTRkLWI1MDUtOTNlNzM4N2M5NTRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMjVjNGQ3ZC04M2Yx\nLTRhNWMtOGQ2ZS1hYTg3ODg0MjljMTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARWCqyDE/wzn0kFLiprFYg4LB/fL+E8vc1Vjqvptd1jxbA9VbF11L7kPGrtQugV\nnYJNBC6QwlhOMTYgRy07lTTro3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR99MOD0hKaqcuV\ngmYkFi1xmRqdqDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAixZ2dJPNpnRHklIA+SLZwvFx+RZ/MpgmvsycdyDMcEQC\nIGqy/TA8ipfjOhit+72MfowrppJKcclcTKnAy0IeZTVw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3305", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3305` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISATkI/UGWAbbELs2/kZ0MqxOMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NWIyY2YwLTQ5MDMtNDhjMi04ODM2LWViNGRmNGQyYTRlZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UxMmNlODItMDY1\nMS00MWUwLTk5YzYtMzk1ZTFmOTU0MWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvDKeurjvro/LtoE839vwvU1MhKba8+GHdlS7hw/+Erh6Up8H74hNBwC3N4QC\nEJvB8stHigbmUPxjBqxXOjqrJaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5mL8DyH+8RHodTlIz4/seQqeIhEwHwYDVR0j\nBBgwFoAUOrCfwWPXglh10OqyBk3ilyL0CCEwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDztnSpcWpdo5gTucxG/yYlpdDGyTuJ1bUVpEtGbOktdQIhAONqbC8u\nkgRorgWmZQZnollstoTKMqkDYVow4aE7I6Ia\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASNvJucvCOl2yPFJweURrLVYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODViMmNmMC00OTAzLTQ4YzItODgzNi1lYjRkZjRkMmE0ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPTtHGYqH0l/Bq+j90koXKmTvGIY3NzRCQuVamEfMnnWdj\nNHhYOpP0yfOC1YxcUSt8m/jZMjnTjqX8l1ER/Vbqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOrCfwWPXglh10OqyBk3ilyL0\nCCEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI2e2ar89++dq3DuU427HjIRY3RjPtSv2nBiEfXK1/FcAiEAnFCF2ddy\nCQq7RtZqw/fVmmEhLUf/Pz/rcXG5t+107E4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfDXdHcakKH0c4F15CnTKIbcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UxMmNlODItMDY1MS00MWUwLTk5YzYtMzk1ZTFmOTU0MWU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YWZiZjAxYi04ODlm\nLTQyZjYtYWZjNC1jMTdjZGYzY2MzNmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ10qAyAMMechsuRaUXrXgImnisy5dVKwA1f3dOZe3Mry65j+ZCXxADbzZB0b2x\ndTrjVZ19HHwj3aCGhXdGkDtto3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTmYvwPIf7xEeh1\nOUjPj+x5Cp4iETAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBhWIf5+uzs8OJWBqrRiznnw1fo1J6RxozH6tkAuI9GDQIg\nYncEFJO/QDR3GnZOk6EOiMC7ZDIVwAh5xhvCrvW1pWg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3306", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3306` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAUyRswBT0PCK9cNQyXE4l+6zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhOGMzODA3LWQ0ZGEtNDI2MS1iNDU2LWJmNTRhOTdkMjgzYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgyZTlmN2UtYzVh\nNS00MWEwLTg5ZjEtODIyYTQyMDgzNDM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUwVuw1gR+JY5y/1p50h9tiT5W8pJakrtnOb5nAnyYTxQ3QzyXYeNcETSNN7G\nKSmZ6prHBh8S6ep0JThqZ4EPCaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSTClszDLb0DlIx5wwUte0OzjV6cwHwYDVR0j\nBBgwFoAUvm/24aoUpdnYnGi9fNpZV9qDp1AwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDW2FQ7gGx1+Plzh6MWD2aNw4o+L4+p0fQ0Vkn/ICqfdgIhAPpJhPUz\nGX4ROPSUzOs34Dfuuu3eF92NjVPE5yDQ8uKG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfif+fo/4ohvfKqVY9S5/WGKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYThjMzgwNy1kNGRhLTQyNjEtYjQ1Ni1iZjU0YTk3ZDI4M2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSg5aq/U+LrCTO4RPwZapBZWsayBLE40vU18mSN20hTPnA\nYI9ro1JgK79ZKvcezAgqXHFgRbwu82Ogl2rTYzpVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvm/24aoUpdnYnGi9fNpZV9qD\np1AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ7CACZRZxLnhC84p+NXyCkxDnkD+UMOZ1J+PJMhRoAiAiBuRjA6mEU7\nGrGYCMgpbyTYYYPaRUT7/DxygkyoQntW/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISARN/9bdoP3jIU9P0t348xZ5SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgyZTlmN2UtYzVhNS00MWEwLTg5ZjEtODIyYTQyMDgzNDM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OTcxOWVlMS04M2Ux\nLTQxNjUtOTc2MS00NWNkNmUyNzAzZTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASJmJhTxSbYX2JF65Ku7AOfMdPWq96Lpy3CM3GoKyBLj8TWH825CNmWWvZz7JoM\nrBfnNR9AIOGWsjJQgRsjnwoIo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJMKWzMMtvQOUj\nHnDBS17Q7ONXpzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA7yvOfi9QwwFLVr/QDSA47XGvtODa210SdZpUNN3LoOYC\nIQCigSgMm+VU+3YkjZHbn/7zzzAzeS/USNXov8FvBp/2eQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3307", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3307` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAcrAf7bSuVT5Rb//TXppssSGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkNGE0MjExLTJmZjUtNDAzNS04MTdkLTg4NWJjZDUxYWM0MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZmMmI5MDYtZjFl\nZi00ZDg1LTk2NDItMmM4N2UzN2ZhYzcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ6WcPLmnGldXflmrVkDBCZy9lGMHTAmn+C/Ir3076uzDfP6cYNul7Gn7OjzR\n9mDr8+FEZiB5RN0MDR0pi7dataOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkl2tci4zZm1NhCXLui4P9KufDGAwHwYDVR0j\nBBgwFoAUSAT0/ElQYjacML9plDeX3cqPzNkwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nID/ukgRtaIpDGTFdvcjl/hohKgz2wCO3TaiXb1z5cg93AiEAjenHKBF4ERGxARgd\nli3hXB7Y7QkztL2y3rmQpe88QAU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARmmRHoo4ItYwe1D09CXVZjZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDRhNDIxMS0yZmY1LTQwMzUtODE3ZC04ODViY2Q1MWFjNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyGEhF7KSHVvcXKadhqKsnXso7zYtdAQbmlWEG9HC0lW8o\nYq2EDoFbkdu+WjsuhLafuyEdi/gfR0mKeZJ9UxEKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSAT0/ElQYjacML9plDeX3cqP\nzNkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPmqGkDrCkdZ2TY7Si09H4zLuCWW5ZjvHRHyz1z9fBTZAiAnrvbG2hOO\nrzkdn4sgJqlEKdh7BklcL5dmwgZ8kjq7uw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASEc5v6diy83DG0Y6IIJHDFNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZmMmI5MDYtZjFlZi00ZDg1LTk2NDItMmM4N2UzN2ZhYzcyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmZTczZjJmMi1kNmVh\nLTRjYWUtYTZmOS0wZmNkODVmMTdlYWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATD7iULC5oVxmY/QOICaqv/qz1C0zLQlOQcRBYXWmKFRjj576igMENGAhf0iyES\n+W9M9vZpLYb8WxNF0KSrANXzo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSSXa1yLjNmbU2E\nJcu6Lg/0q58MYDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiB+c+686+R47AHOaqLjm6144hdFB58NgdM3HwCeBQ2EDwIg\nH/xIPgYqO7O6y/Mzl3OKmpGme4fDpfkO1a/yYQF7FEw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3308", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3308` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAYSL9Z7nkRO+1WZuzofbKZ4QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxYzkzNWQzLTQ2NWItNGJhNy04NDk2LWY2MTY2MGVjNGIzYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODAwNzJlMzktYzE1\nYy00ZmE2LWFmZmYtNTIzNmIyMTg1NzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9qg87WRCyPkeZ1nanUCEDe8o6y6p/GQccQt+aSK04VmYPrKvxa3o90R74/Id\nlXwERZwxp0kDfbpXsS2tlfDndqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzj0fse568ph5dOQYvDv9svhsREkwHwYDVR0j\nBBgwFoAUGGZQrUXkBfsxJ+4chFeT2fdsGikwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCVjpUoT2qwZvn8O2iY+SNnWah0yDzNcTdfLPjodax+HwIh\nAI8utdLfZYq8K6VMLAxlprrLaV5buCpIxr0Q8BgJLnuv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ5bfBjZObtFmMVk64KiCPrLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMWM5MzVkMy00NjViLTRiYTctODQ5Ni1mNjE2NjBlYzRiM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXlrcdqH0ZzPHzscfn0DNyDnndJ7XzSQeClj3Ci7/q+ftm\nyk3flwcnSTUSS9Y2FxyD9Fgnjp1s1gef0BYX90DHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGGZQrUXkBfsxJ+4chFeT2fds\nGikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfr+OblTbFO6tZL60Gu8fEKYqvJQRaGHDmU9sWBceVvgCIGHvAF5Awd6R\n3E5dDK9QiF2xZi2hNIhpKEFzsJnewDEi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASDzBvy4DniK8g0Xy9ajJNkvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODAwNzJlMzktYzE1Yy00ZmE2LWFmZmYtNTIzNmIyMTg1NzQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNWRjZTdjMy0yMDYx\nLTQ4ZWEtODM2MS1kMDk3MDE1N2YzNmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASzhqSULxTfKQONx+DE7AhvB6tuq9YNjNyqhI24Jx9Tn3E9YiLZagNk5wBIwNKJ\njE5yCE6B0uaCsMUNttVmgzhso3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOPR+x7nrymHl0\n5Bi8O/2y+GxESTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAk3ZWs+nj5noiDNFzUhhYJJXDPVQmWjrUnpT+B04TgQ8C\nIQCyFq/vwO0bjVxr6tSE42qkKO6lNJ9lLyOOWu2Z25sMNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3309", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3309` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAYqAKwPoIvc4klEzkaWsw/VlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4ODkyZGFhLTQ1Y2QtNDQzMS1hMDAyLTljMTJjMTQyNzE0MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM2Zjk3OWMtZDk0\nMi00OGZhLWJjOTUtNGRhZTc3MGVmZWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzpN0GAGapqhVFWWTObh6V3knx0eqkTW6w2pYk8WERTldvrhS/0EPLcF7572U\nK8qjTAMJ2ihqx0Xxe7v+BsMMOqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsJo9HCHi9WixT6B8G6RQaQWHRnswHwYDVR0j\nBBgwFoAUkK9akxzoYYiR64Qj2KIbUNrcSOwwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIGBxi5GDWsFVeOIe5fMoKN7emQ74gNztcpj7ZQ8qV858AiAA\nrtkQH812l7IK2qescMwI+3lxgpgvi/sCq+1AD4vTcg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdtykI8Ri6dfNog5Q5GX/Zp1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODg5MmRhYS00NWNkLTQ0MzEtYTAwMi05YzEyYzE0MjcxNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDnXZwqYoWcFxZXj2WjTBserJARoHcZIkKmp7xX57fDgAo\nT3k5S7fPrzU/wG60qqs/yp9nW3j3tkNxTnmjVn9ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkK9akxzoYYiR64Qj2KIbUNrc\nSOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB+zHI5T7ZKEjy7W9mrKHS59ORVa2nsgJW9ec9uyovXACIChJ2E/ILzha\njrvayEm15qFu2TTvRDTRl3ctW/5PURkn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAcsa3klRV5UCwOTmdgEWXMvJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM2Zjk3OWMtZDk0Mi00OGZhLWJjOTUtNGRhZTc3MGVmZWI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMjMxOGZhMS02ZDY1\nLTQ1MTEtOWY2Yy1iODY4ODZkYzMzNjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR5vbITZB/Pr/LxuDp/+cWFyfGUmeIVEk1UhgOSbYnx9ScQKhKRVAQhw4CPqnK5\nyOg0iGOPd7hxwOPMDsEZ02Cwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSwmj0cIeL1aLFP\noHwbpFBpBYdGezAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAQtmhgyH0tK+rs/kZDY27+Q9WOR5iiy84V7zHCDdpEgQIg\nZ5EqBoneX3KtoVh4gcGNzsoA40I55hicD+8gR9bU+9M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3310", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3310` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISARlCLiLB4ZAxJPa2v6b9SaiBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzZjk2MmE2LTVmOTQtNDE4My1hMDJkLWVkYjIwNjk4MDJmNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGZmMzZmNWEtN2Yx\nYi00MmQzLThmNzUtNzY0ZjAyMmRjZDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQU9ieNfdEHnqG0ix1z0gqGsDoScIbKDfYv2hAroTyK2Sd1Fs7jUn7ABzgMgK\nTRTHrr4SZI08e8MwTsPjCCtIyqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKn/FT720UyRi9dzNfRZ0Bf+dQoUwHwYDVR0j\nBBgwFoAUYGFnF31y2KhbETvFQSRXVP4WdxYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIHUwqHPr0fsk\n9qLoNb28EhjzuiDXVQHy95gNbcI6esZUAiA3+92Q++nKeCCaf+fPBJr2A1WTPHPt\nuVax/1xLpEe0PQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAblOzVW2n6AzIq0kn296/fTnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2Y5NjJhNi01Zjk0LTQxODMtYTAyZC1lZGIyMDY5ODAyZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6HhkAbrUtc8vLTgHbLq3ArDVQnPShit5KkGySR/b/h3Wh\n/btuRA41iqMY62vAqOVhjwCoNAF/ct/BfKO+rwUdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYGFnF31y2KhbETvFQSRXVP4W\ndxYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIZcoYveqMEqf/GRWVcM0u2ryX8MZRy8wAdaLeEABT41AiBL53YjUNhn\n8gIysOmWItmphxXxMyPZBp78YPOY8EMiAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAedA6ZSOteP9vIxfqZyR4Nj9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGZmMzZmNWEtN2YxYi00MmQzLThmNzUtNzY0ZjAyMmRjZDU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmOTgyYjFhZC01ZDcx\nLTQyOWEtYjQ2Ny0zZjY2ZmRkMDI3M2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATXDwQ6uLz8K/RbLEZ+0ZCwTqERj0BRZrcLwEPtXVdyLvwNZyEbfCwFsymERJqR\n6XiQvxtTvSmgv2ZJ4zzLst+To3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQqf8VPvbRTJGL1\n3M19FnQF/51ChTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAy9Z0zgc5IWundehT1/6uE2krFOKnwRV3K2rSeFwcTpUC\nIQDVrivtwWM4qm/i5YwNzPaeeBtx48gjeQVIEg4eGodjmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3311", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3311` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXfiwTTkI1COt+tpM6qQahfvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlNzQ1YTc0LWNkYzMtNGUzYi04MTUyLTQ4NmQ3YzY3MTYxMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODhhZmZhNWYtOThk\nMy00MGRhLWFlNmItNzE0NjljNDFkYzQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfYSfFM+rh/3ZGKeJpJ9pHOfGxDckYr2ysd+nuAXl75V2dnylPe//ogA+KfuU\nSoj8g++83O5j2SNResM8vonxyKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV9v17xgduKd0jvzkuKqiXo5jgrIwHwYDVR0j\nBBgwFoAUiG1uJkk6Ibvw6G0diA+TuYUEBuwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgIY+KKxjPgZFlhKwrdozF6Yx8EWOdv9ncVI9h4SpmdzICIQC8EcYCorHU\nrzWfqRJhukDBIu1cqR9wQ75v+MDrZLPlZg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaMz0dR/unP8ptFFAmL5RjL7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTc0NWE3NC1jZGMzLTRlM2ItODE1Mi00ODZkN2M2NzE2MTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIkkrDhSjk6x9cCchWYyevgFza4+GDUsfhva2ykx9BUE2N\nAG4R4SxLhVujyr6DBTr3BRyMzTzMZS9vISNXZDofo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiG1uJkk6Ibvw6G0diA+TuYUE\nBuwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdH9wwDvmEOwIPKW32F6mb9Elkd+G6bQs2N7RZ/Ml0WQCIQCgIdfjygyB\n4P9lXdtfx/dNm6t0qH9I6Kb+Vz3bX5SqlQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdTuKhI9kTekxVDFSqiQnNcPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODhhZmZhNWYtOThkMy00MGRhLWFlNmItNzE0NjljNDFkYzQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZDFlYzg3My00YjY5\nLTRmMTgtYTUyMy05ODA2OGNiNzNkNzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASdTGAK/fkyStHYFN3TCW5Gef4Pl+Wjaw5y1GgLiz2UlrIkdLyZdufYzExrpQg6\niMsmPa+cROl/jGQpNhChlFUuo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRX2/XvGB24p3SO\n/OS4qqJejmOCsjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBbv6XeB/9h9VzgKfBr4qCofKyvjd58U4pOWg5x1m9HJQIg\nYzGu4Bg5WjomTK/cViiY5AMBypy3q97BRhPSVG9kZd4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3312", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3312` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAcUECE13L68KRhRiMT6K4QRQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyZWM4ZGY1LTMxNTMtNGQyYS1hNjU0LTNkNDYwZTI0MDQ2NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ1MThhYTMtMjcy\nZi00NzM5LWIzYzMtYmFmYTdhZGM4MDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq3x+oa786/dO6j3TxsWWihasHbk+Vkf4cWoDcGjoZHCoKVP0QeV76Y2hkH2T\nqLDOa+UXT+aM9RXcV4zvvQmM1KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD0L2Yua7eXAWpoGQUalsSEWu2LgwHwYDVR0j\nBBgwFoAU3D0F8fJsP/ila5pdY8qjps1DUZ0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgNBkQ9b/wXbCo4v+qbnZMefcnKC5oJuJjPb9tlMBk3+YCIQC0grCJNYgl\n9bAKBftFSCS5AQInUjSDcKohC55nqWka4w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARuY8Hp8qrx2y5+kOaxtMRFSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmVjOGRmNS0zMTUzLTRkMmEtYTY1NC0zZDQ2MGUyNDA0NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoe0yHjX2j1sGgqeP7dBrMgOnJyKKYiKUAt2hXbabB3lYp\nzvp/BFXDOjzAKw4a9l/cEFbufRYfI2B685/Z0xMyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3D0F8fJsP/ila5pdY8qjps1D\nUZ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJblUPPSSLaH6mtPZAAMOxNEGtVaRxetFvzXvb1wDL4bAiEA+tydv6oD\n40DvwhqBjUfAYq8/l8G0l3hMd8nHvsj6FdY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAapcVbtsKOppHaNL6Rlen6ExMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ1MThhYTMtMjcyZi00NzM5LWIzYzMtYmFmYTdhZGM4MDNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MmQ2NzY2NC0xOTJm\nLTQ1YjgtOGUwYS05NjQxMmQ3OWRlY2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATspHrDMEWJOTBjln0NRD5QqBfyVokMl4uEA3IvPyW79NnMTKfYGQ52w4by1cLc\nLJAqJIwqVZih2CEqDBWExal7o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPQvZi5rt5cBam\ngZBRqWxIRa7YuDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAo5m0MTxiW9a54J3MOglfR5ZCnXqWNOMT0bHlDlJiyoQIg\nKdXsVG3uLR4BS3ulgL+zBC3dqDzPATFCnNW6Ih36aIE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3313", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3313` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAU9f3srWZwDToNCVL8ZP42aaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3NzdjMGY5LTNmZmQtNDlmNC04MTUwLWI1ZThjZjU2NWUzZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFkMjY1MmMtNmI4\nOC00OWIxLWIyMmQtODJlZTllNzAxNDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN+QAezxbvcmbWhAfamRHi4I4uGbkf8BQezybIjVCrjY08rg0ncfy/sE+FvdD\nARSAcJSjVbRCjTrvr/yYg2uMl6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd5wDQoKHDxaWZ8csr/0Ww1fGUq8wHwYDVR0j\nBBgwFoAUXITXX/cVNFAZ3XoeiQLSLBGB4aEwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDanRAoeUZnGGOa1/7Vahy7TH8VAMV/T9LmyYG2cccejwIgPFoRj0eT\noE1pLF3f7saKcmzIyRwpstN1XRWAX6lLGEE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASDLe4OyMiYeRN8ku0KlawEVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzc3YzBmOS0zZmZkLTQ5ZjQtODE1MC1iNWU4Y2Y1NjVlM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPwrBhXFCa5MiDNH8sNetrXq2YQn23hCMI/kN7vCgaSCt5\nHa5+T+67ATV4gqM85J7lZ+yL57yx3Zo1Aw4MDawlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXITXX/cVNFAZ3XoeiQLSLBGB\n4aEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJnDi470kap7FRDZ2tZJYfUaT9KFLjN/faCQ+ui4UaObAiByPq/DSRCE\nw966wIad75+lyQiR4/a2qXR6IiV9G7B0Ow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAULd6jFlpgKR4ProZIAUnJQzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFkMjY1MmMtNmI4OC00OWIxLWIyMmQtODJlZTllNzAxNDcyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMzU4OTBhMy03NTBl\nLTRjMDEtODNhZi1mMDZiZGFiMzhjMmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS0ZSu+N7Z7dKqmGgXFPTfhjELy2FUDKVpIRBfYhvfUH/iYoa5Ks0wUphzk21wZ\n7kYDKx8nGgB76pUATNdFLqm4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR3nANCgocPFpZn\nxyyv/RbDV8ZSrzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA+eLAJdC4ua+RROuP/YPCoh0xtjNRYIUh+PJ2MXV7mWsC\nIQCa/dGSuhOb5QAZ18WVcL43wu9xYtTRxl8OYw0oHDO8gA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3314", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3314` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAQjjssxtz+734vlaGorddkFBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZGJmZDNlLTQxZDAtNDhiYi1hOGYyLTk3MTE0MzIyMmRjODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM2M2I4NGQtMzMy\nYi00ZWNhLWFlOWYtNDdhZWQ5MDI0MWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExlORppV9Ezn4+/ifu34j+qidJNSgTz0UJvvquwuuMnel2YwbMHWmZVppRSBD\nbbt50l0gR7+OuBWumH/sg/nayKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlQ1b5UDnQr9nt0J3Door3IPoLFMwHwYDVR0j\nBBgwFoAU9Bihi4hlAOhilJNzRsWxlBoR4V4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDxAkWlGzeBV6ZGj2Ra2RmcKzAo1ELVbZIqx0gu\nbyWCiAIhAL8pIwxdi7Xw9JdsHArm/18fiD7J2ROG29FTz0GnxrkV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZrxVnPkFmiH66W7l5/bKkZOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWRiZmQzZS00MWQwLTQ4YmItYThmMi05NzExNDMyMjJkYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT44n95d7bdRURMHgtt95Br32wBzplgtaPX+vvFiIwi0ulQ\nYlDGbTUMKm+LtctOg9GCMjhN5ZYJai/IH7hGf+Wvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Bihi4hlAOhilJNzRsWxlBoR\n4V4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJwRFLLWLnvxv6HUvNS1Fqn9wlOrlf8DDq9Pb1+Y+Ub8CIQDis2vcmsrB\nn0Yi76ZE+sCzm4jYTQ5NR2yAYQ+5I3Z4Mg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVu9mbZ63mT4QyyTcO/YJtklMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM2M2I4NGQtMzMyYi00ZWNhLWFlOWYtNDdhZWQ5MDI0MWFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMGU4MTEzYi0xMzIw\nLTQ0ZjItOTQwNC1mMjE2YjIzODZmNWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASQ+XdsA45MSEyQfHfHKjRCzRAyHn0eO4O5Q16hGr0Ahjz0A1nK/ScClQycmh2P\n9RsMsxKAr3w5OVvsT6QNeG9qo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVDVvlQOdCv2e3\nQncOiivcg+gsUzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBpHhULa7rMyTa4FawK3e4nEA+CrrXreKb++L/8YLGJRQIh\nANqUSodbAMgLAHJelAKtTD1Hh0d0D8GGa218v/EOEi9s\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3315", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3315` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAYSmks8LarbJcoXy2Zm4ggQrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3YzkwMzA0LTA3YzEtNGZlYi1iNzk1LTAyYmYyZDdmMDM1OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI3MzI4YzEtZjE3\nZi00MjI4LTg3YWQtZTBmZTkwOTVhYzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkpDR2975eCBGBM+hPD1qiCSPyJRS4uo4u0PPGBB4ADtX6K9CpB/vpeAGmIpM\n8MFd/O902Ht9ISQT51lyhx90IqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUMYt/+ECm1WfPUmE8X95G/yiugEwHwYDVR0j\nBBgwFoAUJ5jFBD2cB1LV4YlGG6VaB6TEqFwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEZtJqAi1g6ks0y1NVWJNrIGwf6jibc3fhUwl/fL\nPy8zAiAFB2RhBqUsppUI2xEXNHzK3Nzope8wAWds8LFOgWH2uw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeD0YCrfkSAQH683/7un5kaMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2M5MDMwNC0wN2MxLTRmZWItYjc5NS0wMmJmMmQ3ZjAzNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUhjcadCbL8oy65xWUjLMfhFfR7K7//CLfyl3cEzFpW2AN\nsTS6ssybj82sPgAZ7fy8YrfXo2HCf2sHvPdUc/PJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ5jFBD2cB1LV4YlGG6VaB6TE\nqFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQI5nEif/UbiXLXsomY5jgX3SvJthtoDg6XkRy2AkY54CIQCgNv+Rx0Z1\nNW3yAGIY8sg+2jJ/gk2wb/+h8MDQIajThg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAf7n1WW8rVspROkHRQY1ESY1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI3MzI4YzEtZjE3Zi00MjI4LTg3YWQtZTBmZTkwOTVhYzQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYzFiYTk2OC05NDMy\nLTQwMDAtYWNjOC02YzZiYjI3M2U1ZGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASo5iA5lTRQNzuPCONP8hsGSXan1PySV3rOcw5r1zvWQtzkWVL1sm+pv95+RIvB\nLJ1P5GP0IXAKi6LvoH9Eo4txo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQxi3/4QKbVZ89\nSYTxf3kb/KK6ATAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA0rv6Rf0S/tcYT+sgnZMNm77ARv7eqBIlML98FsExSxAC\nIEIcKy/IGuIypdu/hEqJYl0blIxNPLBIdIB2O3mlIAmE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3316", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3316` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUVMXPkI96XIQ/ouGv4VAOcDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkNzZkMGNkLWUxNTQtNGU0ZC1hMmQxLWYzMDA4MzliNjViOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTczODkxODktMmVk\nMC00OTJiLWIzNmMtNGIzYWVhNjFhNGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzvXIgIpfMwJ1zE1HYGSAWWW1Fsj1a9PMxfzcxo1ZCg0FMlq9ICpAw04amk/m\nbjy8olj7lWHhSFzVadDE9hyyRaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA5YJhYnFI7rRKKZplSlNCu1xHUkwHwYDVR0j\nBBgwFoAUZIqfSrgeN9UzdNGHckFhkmL0cxgwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIFis4lUDRmsI9TpwuMAZTq0I2KH/Z09Sa1PhhqX6JTcEAiEA\nw+hfXzR86Hn9xmERiW9SQ4Jy8ptJ5C7ME+hytQIMHxs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVGzgO7LTbKzh+yv8XMwOK55MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDc2ZDBjZC1lMTU0LTRlNGQtYTJkMS1mMzAwODM5YjY1YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS52gCH3rLKdKJGa8VQ+ADy9xnbCvJu5uSW0f5L60lp31xY\nR0Jr4/WOhCzTYKAi2MouJVQdIuEKYvOI/zK4n3nVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZIqfSrgeN9UzdNGHckFhkmL0\ncxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJPLllzHDFe55LK8Xq7UuNMWj47UhS2tMvwFLo7pdGOhAiAWzL1r6zlr\nvRRxYYUF5IaebHQVJ4no4RumZc3vcpgMDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAe7T8ONpMbG5MeMc6cipFRh1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTczODkxODktMmVkMC00OTJiLWIzNmMtNGIzYWVhNjFhNGQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNmVkYmM0OC1iM2Ni\nLTQwZDMtODNhYi1iOGZlZWU4Yjc0ZTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATKvTuRA0eR5KHaBEgHjYXdysF87KzPwK7c8uv8AcVN0p2a89V+cSOG9ywNhqyN\nOoEqKqifMDQnZHdCqrjMEwXio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQDlgmFicUjutEo\npmmVKU0K7XEdSTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiAX4XFsCvUHby+Rt//y6h0W4nvvzVwZmhpN7kYZa3C1UQIh\nALira0/JRwLCLrfW/K1aBr5BEVsspVhSA8IhgnzZBKVG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3317", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3317` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATSLeJa2vSXPGIo+aPDeBsQwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiYzdmYjVjLWRiNTItNDRjMy04OGQ5LTljNTE3ZDMyNGFhOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFhMDYyNmItMzA0\nYy00YjIyLWI5N2MtYzE3ODRjMjAzNjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKzPYxtUw31Xv7gydTtbYiHV3bhj7lsVVb31Okep4DAaEOJCg5EY2jjdchvXE\nwMuFht1k80Al6og6HUSNboImMqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURxtsp/oKgGPbVuSiByu9Yh+wCE0wHwYDVR0j\nBBgwFoAU4TkRbDt8pGsPZcjFsrR4fq3XIYwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD+jS5CxCrjzg4EoqDA1QakyG+8lbuA\nAwEfOiQuF0j8XQIgPh54tak2+9pnU+yxb/gVyqCmO10PctcrauWdi4Zby/c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa4dXmF1X2/QPrjND80CVQVCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmM3ZmI1Yy1kYjUyLTQ0YzMtODhkOS05YzUxN2QzMjRhYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFfWJriF9rmM4JbmYSUPx70mPlfzR1cbU1RCL5VgarVuo/\niFaP5C8VY4u3Aw8FtEEYjAD1eTUHItmMJ1Zz9D7Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4TkRbDt8pGsPZcjFsrR4fq3X\nIYwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALYYKPGlH1PpAKD7wXtV8HjyROEEgNNDAZZKrCHdWMnlAiEAxilq3okU\n4EJQ4mTm2odK2xTdvCuG0bvCiciiDjP5+Jw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVtIGEs++BDfFPSqYcg68JqtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFhMDYyNmItMzA0Yy00YjIyLWI5N2MtYzE3ODRjMjAzNjE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMzJmMmNiNS0wZmMz\nLTQ4ZDQtOTIxNi05MjdmN2Q3ZmJjNTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ4doixisfvg5UNt80U4Lpg9jyI7L7X7eOS/MSE783IzX8RkUj/QdUtq3jr0ZD3\nxbrP1fPWIsER12wLrj6+KK/Uo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHG2yn+gqAY9tW\n5KIHK71iH7AITTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBI8FbXZgGK8yrnDvQmpuCNSwjJWvHx4dOs0UWj9zZRKAIh\nAIYwtrj/9NmEwAqEZZ8mwgADzBSVRWg7hKCBV4CqmhVj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3318", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3318` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAVuFAL01VSQVnzlIHe4oolt/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkMzUzZGMzLTlhNDItNDk4Zi1iYjdjLWQyM2M1NmYyZTM0OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzlmNjdmMGItMjU2\nZS00ZTE5LTgxNmYtMzA2MWM3ODNhY2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIsNVQ9E3qu9ygLGGhLwgCFqu+0Zkp3WK18vhpxqTHuJHUvORWVSUNkMmdiMf\nuFV0QzlYpHPYn1Jwd22hE+BwHaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvsJKRqwQ7mBfSc0tSTXL79+YqkkwHwYDVR0j\nBBgwFoAUERwgDfFSPubmj78hlM+28FunNIQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCP/EUpExeu9/1fTmCOPQJ/ma+CDfLU\n26iIkmWuy1QnqgIhAJdG1FyHcAiaVuwdfRPGIXsfbh8gNpGjsu+onojY2W58\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWiA0Yds2p0mJzXPLXlH2QWUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDM1M2RjMy05YTQyLTQ5OGYtYmI3Yy1kMjNjNTZmMmUzNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjGGwWvhTjfkmG4/Upaa7h/1aK95bqCasQgZwPSj50RMdz\n6LMsPKUvv4wTEygpYln9xE4qSVPNuvsxj2SS1eCeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUERwgDfFSPubmj78hlM+28Fun\nNIQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIN5JMdUlRauXGvKfWVKZbM/AOWwFV4fQqUTv/XqBx+KAiEAsTZ8qqGn\nnHUQHz9FdCOo1YmYtQ9aoN2lqAjncQGlWis=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARz8xDc3cRTZ4v2LC7doQrkeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzlmNjdmMGItMjU2ZS00ZTE5LTgxNmYtMzA2MWM3ODNhY2QyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNjM1NTQzMy0xZmM0\nLTQwZjctYjY1OS0xYTJmNjBhYjk3NGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT4mDwRo7ow4SoHCdv6vmEjd/pRgjXTWd6Izq2BtnQZ3yEUSkCVQRHSaVPr0ahG\nA080ud0tbem9tMDMmIsKjaGZo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+wkpGrBDuYF9J\nzS1JNcvv35iqSTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAtOPUmEy8x+P8Yw0zuaaRl2jdkknT9WmaFpOJ62soQ5YC\nIB2HmzBSlXboTSjcgIfOu8OOHIF47yLL9Qa3uiYvX0Rx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3319", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3319` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAb8OJJMZwcJyxL8bWaMUnfe7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkZWQxMWMyLWRhYjAtNDRmYi1iMTY0LTkwYmQ0ZWU2YWRlNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGY2YjUxYTgtMDEx\nZC00NTE1LWFlMGQtMWFkNTY3ODE4NmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+SlHD3X+gWM17w+jHJJU1J0RsrNtplSE/Pug+Ly1mxzN5GXZ01iLqWnjZ5hU\nY3fzyW6ba3YJLdaRx/Lva3R3qqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdnb63b6KAaQrSLNG3FHhOEEBI5wwHwYDVR0j\nBBgwFoAUSwt/1ifRsGe0o/6kKpe+GxeeSdUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBxTn4enQNwQ\nP/xNVgbnn9g5FCX1I2Ns2cHQqEiPXzQdAiEAr4aLhMyvlShI6ezV12wiH48cn/ka\n/dF7nKaoXXKoVSk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWqfQDiH3Uhao50DSZ62GcUMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGVkMTFjMi1kYWIwLTQ0ZmItYjE2NC05MGJkNGVlNmFkZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR247YbFfI95wag0UvmLYR6FyhyY3yNSg3EURPXVqyY0yca\nAdfgprNA/UQcDDDB2jOF/TU4kv2Knz3/Hge4bPnto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSwt/1ifRsGe0o/6kKpe+Gxee\nSdUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIjUzS7qVCVrlrn62r62faK93v3MSaY6mGsOhMeosAkTAiEAwSPZLn2e\nJiVMpLIPb+NJBETUHkZyE9dKIEBtjSMHHYw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWgVdyNl1O3PhszmPSfZmJjQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGY2YjUxYTgtMDExZC00NTE1LWFlMGQtMWFkNTY3ODE4NmYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZGRiZGQ4NC04NGM5\nLTRlYWUtOGZlOS00MTUxZWY4ZmM0NzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATIgv2W862B0FSwZlVMoRr3QsWiv8e2J4o4Z3eLQWAJbhGerNrl8JWzNAsV4dPd\no2sgxK2q90w47tJ1ohYogh44o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2dvrdvooBpCtI\ns0bcUeE4QQEjnDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAtL+nqfL/PpsqZSY9ZAImt0kZgK6ugQqNje7GfSWxV4IC\nIF5AOvv4FPZeAV8s9aaKvVEjk+CyCz8MZk0TK5PHXaFO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3320", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3320` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAV1tI5KcPRWurG+Fv7zBujOcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxYzc0OWIyLTg0ZTItNDI5Yy05MzIyLWFiOTY5OTc4MmEyMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBhNTk2MGYtNGYy\nMC00ZmRkLTg1NWEtMzVhNjczN2I5YTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPv3yqyJhPRDhByPsj47AYR5EAqx+aaetvPr65mesNuxAlVh+v+6JTaqZjza8\n1hUwuPaNmhUYcBaIAEs24Hgiz6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtBz2txtwd5UF9/lobqIgPiUCDnwwHwYDVR0j\nBBgwFoAUE2nrzGF3Rh6tvEexYkxtsw6NIngwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgGQGzSXfN+pP1TyXmpMfVoFKaYl3PEymRX7yaNC0RpcQCICrqRFyNOqgX\nctbGTDexz/u6KVzMzbJwm8cRfaI3afRy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUYqALcnU2dXRSJbszzhPVONMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMWM3NDliMi04NGUyLTQyOWMtOTMyMi1hYjk2OTk3ODJhMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtLmldfUTreYZ+Z6KuUlFu8MMR1jP7eRuMcSWat4D9oIxR\nNOI1H5Cg03f1R8vVf5IaHAEMZKCaBzyezu/nbE6ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE2nrzGF3Rh6tvEexYkxtsw6N\nIngwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP5PMuMDSXYMPBdEjvQdrXFGC0gDLFGxx6F4gyFEt48jAiAy78Q23jdU\ny3LQHHBPlHrixhXjM3xu0znKCpje6/Kglw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAaPQoPsm1SL1KnkUAtGpSEXVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBhNTk2MGYtNGYyMC00ZmRkLTg1NWEtMzVhNjczN2I5YTE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZDIyZmUyNS0xOTcw\nLTRhMWYtYWRjZi1hMzE4MDk2ODQ4OTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATUAiFPq5rYZvb9UoPnwuWxhx5kffbORtfTSaLoM/MQ1NLBc3RdUmyfp1s1++Ch\nQngyVopTLggst1cgVMQHq/7Ro3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0HPa3G3B3lQX3\n+WhuoiA+JQIOfDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA18ahczzoZQJi7ONfid9aviGPIZZVrrnGTCWDwkQ8g7YC\nIGyHork1x1Ie2E0dKFFj1YHCxk1MyhurJSQp/GQuaVgB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3321", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3321` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQuiN9KRGTUgJdK/cfSYLR4nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkMGNkNWQwLTkxNzMtNDNiYy1hYjJlLWViYWZiNzQyODI0OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGRlM2RlNWQtZjdk\nYi00NmZiLTllYTEtYjcwNTBhMGM4MGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5oyzrSfHkks1fjuJKYGUdAaolIrMvecdEA1eqZZGGkVlE9NdAKnv/W8u/v08\njgrxVd/Jes85oTRcKHXKb+lP06OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUrsIbp/Fop8pUPZgssVwPKjU8skwHwYDVR0j\nBBgwFoAUy/pYHiaMhFiZKGUnJ/90RTxyCGwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPSO514C35h1qGSv8/RkfJNkzMA+Kpfzlekb0npGW/z3AiEAherGq//n\n3tLQP20wHFjX/opZ54vF9NnxlFp9Kf9+Rvw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXgsqXuz9WSsKPqflNaVIFufMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDBjZDVkMC05MTczLTQzYmMtYWIyZS1lYmFmYjc0MjgyNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+xhaRXOakaymL5C1YGrrwmPOCBAJWFjhjbi9xfBsQteLN\nOQYKzIVKRcyxY3npshp2+TRXJbvMxcjSs7KAaIego2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy/pYHiaMhFiZKGUnJ/90RTxy\nCGwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ/nzI4ed2zJbTOMUAAgwM2RVGwhoLsXaGj1gd+DZypcCICxX9qdi091M\nYD2VH+M2TxquQgzH6MigvMd44iVjLWZV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQbHMORcqvPQUCr1MPQMywaJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGRlM2RlNWQtZjdkYi00NmZiLTllYTEtYjcwNTBhMGM4MGQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMDBlNjViZC1mOTli\nLTRhMTAtYjUzMC05MTNlOWQzNGYzZGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARPFSDk7aiENh7QeQdA/PagiuTUTG/z2TWx4uHPIjnHEkSSODZ0voENj2JIoeyG\nH0/afI28J6WOxvtrwJzO2sJDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSuwhun8WinylQ\n9mCyxXA8qNTyyTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA/iYhYcEyLrmhDCgbBMkgDFp5L7wg40NcqZ9tACPymGoC\nIBQd6KT6dJ9zTGeAZkdVYQUKg1rF7JxTT8TerDMPfR8G\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3322", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3322` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARRlj/V1gkkCydNnVbczMjvKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhOTEwMDIwLTVjOGEtNGNkMi04YTI5LWNlOWFjMDBjNzRmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc5MzYzMGUtMjdi\nNS00NzkzLWEzZGMtODkwOWJkNzc3YWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbanZqZ8c0Ze54a8iXAZwC0ph2Hmu2Uu7SpnHAxT6s8kvd1G4jl75cVENBPWj\nG9FRe9g5DtK3vMGUlF+AwAea86OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFibN7NC0rJ9KaJ2YWRE98G1w2L0wHwYDVR0j\nBBgwFoAUUK8nYLkngt0VeWXs3jT5X5CsGscwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCx9Na2t7KDFUbi/KH2QUE4gFRNllg4weDJ2RSYQSNIqAIgcPt+ZUQP\nCEu82hDH1hIJMTWmZayHPaveyPRSDgBLfzg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUOn/YmU3TDi3VgPrzn+u3J/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTkxMDAyMC01YzhhLTRjZDItOGEyOS1jZTlhYzAwYzc0ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGd7q08AAgRgP2w1YVXQKLHrEyOOBckkij4qxp35FCFMw0\ns39OadTh0z1ubDzVDSu4oFxriNKb9aP+ljVRKPkXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUK8nYLkngt0VeWXs3jT5X5Cs\nGscwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMlz1MJk0/iErzhOEFqPNT99IJD2OJK3mWI5/Bb9XvhzAiEA8nnlZwCz\nZWQy7KN+0NC18QgjvtviY+O4nPJaABk1cHc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATwxg0mqDb502fnaKMrgSpCuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc5MzYzMGUtMjdiNS00NzkzLWEzZGMtODkwOWJkNzc3YWM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NDY3MTc3YS1jMjQy\nLTQ0YzQtYmI4Yi00YTMwYTVmODg1MTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR8Tr8fZCHcdC1elc9Pp9Py1XN1gGwl4j/47GZ7dtSOnXeTKTyQsIOy1jS2ITaK\niXR13Y6wygcpM6B4HwyPLSS8o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQWJs3s0LSsn0po\nnZhZET3wbXDYvTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiB3ieD20mtajFkEpZttat8eCFQJa5iYycu5UVtAgt5npQIh\nAJgvpxAng9cnucMDYxLhEc5DczUHrQSlyzlX02nlRM/r\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3323", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3323` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAYHYi49wkhu/AfTVIggOYVYQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiOWJiY2ZiLWM3MWItNDRkMy04Y2UxLTI4ZTMyMzNmOGE2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzMxZWVhNDgtOWVl\nYS00Y2M2LTkxOWItMTlkZTU1NDhiYzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK7Wx+LDHYzsdKP+6JXnP91EnhUAQpHFOvZQrkvwNeRZ4MjG4BF86Y7+LIjld\nrU8EtkSCviAKs9crl+SWHqQ1WqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBlsHzyGxH4+SiLLviKto49bifEcwHwYDVR0j\nBBgwFoAUpVw+Z90JPkANTrfvdi9PLz8KCq0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDXk+fADthXbZ3+JlHT1qIA3VYQg2Rs5Qnbicog\nICzmEAIgZj+LyU3f4T1rK9LJXRk5XMvPY0myOPVGqUf3VdmiilA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc01Hj6048kfIYEl3m6fvqhjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjliYmNmYi1jNzFiLTQ0ZDMtOGNlMS0yOGUzMjMzZjhhNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATviWxwZta2SlmS3D2oeX1Z2mFe1ZHl4UES2KXUQFUTttYY\n31Pym1HYb4sNPjCPRJP6OQwuC9mlJzcnM/0MJYsso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpVw+Z90JPkANTrfvdi9PLz8K\nCq0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKp7X2rS8xAtUZCR2iu0BX78xYOLF4+A4hZtd1S9nZVGAiBo1us7cuKx\nx0A24ckjc7YQ8C3Ef98lGymG9O+KfVZ9oQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAUx4YaFQNnF7qlnJ/lbUAJJsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzMxZWVhNDgtOWVlYS00Y2M2LTkxOWItMTlkZTU1NDhiYzUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYzRiNWZhMi03Yjlj\nLTRkYWQtYWYzNy0zN2U3MTliNWQ4NTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAROnXuu31/sVlB/FdASqKz2y82XXaA6GB0B/EB4cN8RV9RhWj3BppgrKlJmjbFo\n63Vkk4mglFjVYzuppBoFqJkao3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQGWwfPIbEfj5KI\nsu+Iq2jj1uJ8RzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBoTFqd7CYP7kvWxHMHwRM0x2WEH4XTwOMXAJotRDQWpQIg\nISYTw+daFaOCeFSm/xtEN8Q2FiBfKhDbb7/jUGTtAtc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3324", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3324` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAXZcIt3BHZM6TWgPAQMAz4e8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1MTI2YjI2LWYyMjMtNGMxYi05YWQ1LTVkNjY1NjViMmY5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQxMjFhN2UtNGQx\nNS00NWZkLWE2NTEtYzZmMzMzZjEyNmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhtPQXAQqiZTXXWNIsnpLeWk1DcPSZQllf21YOYe6gWWqSUkivx0Kcje/Fmwm\nEPkxf1k1GrSTBioWhfaE2Jv7wqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi+/SqRGUjIj0QyT6yiF9y8m+Ld4wHwYDVR0j\nBBgwFoAUezITLAgr/q6SFZ0Rpx/KQ6KVY5MwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDI+maPSo/DeCJv2H8GT/lsDLV1POh8GfyV4MMP\n++up0gIhAOcbot/SjwOlE8zhhQ+68A8gwY3sa/2kpA7pIUYArmqj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfDiF+/Y4pJu1H1a5aQ3WDWkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTEyNmIyNi1mMjIzLTRjMWItOWFkNS01ZDY2NTY1YjJmOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXZ3Vj1P/IBixMcY08/+TaaidgUvTpDYFFYuYt/91MjfLT\nA0bI6P1ayPXsJXxDPUDw0hkL4w/dvvHl9POEQgklo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUezITLAgr/q6SFZ0Rpx/KQ6KV\nY5MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaWhf3b3rBYA/gibKAqveN8lm319xI60gfpFkHtqa6xcCIHYR8t+HjzHA\nzWL0jgixnL2degflkXBrc2i4xfGi4Hnw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbYOWrTnbrw0j4FUX3AkrgK4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQxMjFhN2UtNGQxNS00NWZkLWE2NTEtYzZmMzMzZjEyNmE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZDkzZWZlYi05Mzk1\nLTQxNDYtOTQ3Mi00Yzk5MzMyODQyNDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASM63UZ0AvYlrBWUu9XsLJlDkLmpN/nivJyFJj9o3aP9rNs181qIq9K3vO9v2Lf\nq9k1J3/LkmZhNcFzlk835hXko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSL79KpEZSMiPRD\nJPrKIX3Lyb4t3jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBCq9VJ480Ko2kAtSR3KHhcgK/VaQgPVJPMWnN9TLfI4gIh\nAMNMP/dFnK+PsIxFNMALLSfuk46O+CiDKet8Hiuq3H//\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3325", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3325` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAdD5JVeGAt/yJ3nKTRrkdKLwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyMTcyNWZjLWQ0NjMtNGViMC1hNGUyLTgxZjI4ZWIyODM3YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGZlYjk5YzItMmYz\nZS00YjQ3LWEwYzYtMjk2ZjJlNWNlMTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzNC46+XQSnQdXC9v48IKbj1eLBpRmuQUpZEEocHNqTUZUI7+icLhMIDVmPlj\nwl1dvkBdzCmTimLpAaGgnXsVnaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc5pfB7+r76q+VMpIs4eGC1KUrq8wHwYDVR0j\nBBgwFoAUM3519KvdIyyF2YT+1I7/x7P+VpkwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDEZt5quklxbd4oVIbiEUpMkna2/XcKa5poLrUPHnDrFAIh\nAPZCRD9BrEBZPKTk7u7ZXN/hbE5iAQ/97/ChETPvetV6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWAtkXIjAafv5xqbDh39U3lgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjE3MjVmYy1kNDYzLTRlYjAtYTRlMi04MWYyOGViMjgzN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCW7gu1Nm+CUe9eKS08nqn0bi7atrj4SPLCKdd31kFlItc\nhMKveetZACug9JMi3MhXc+sfDIQoMTeikv4xNzrMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM3519KvdIyyF2YT+1I7/x7P+\nVpkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU+62QR9r8au6QTXb5fQosUf4hUsg1mFHdU4KxuHwhBkCIFIC5awiqaAv\nR2yZOFJqXmdkNwIoGZYgjG1m7fnKOmOm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASpVu7rIdlaUw5UxyRdDc/P7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGZlYjk5YzItMmYzZS00YjQ3LWEwYzYtMjk2ZjJlNWNlMTliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMDdiMjQ1Yi1kM2U4\nLTQ2NWYtYmMwNy0xNWI2NDRjNDVjYjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATiv6bd5Arpq5TCatJynWZaLCMJ0c+5x4yFtxH7Zd8JHSc4cCiVOFuuOcrH43rX\nmENP1XQ3tO5Jdl0oleJgxpV9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzml8Hv6vvqr5U\nykizh4YLUpSurzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBh3BqYfsBRUo6TrBtBoRwIrxFD4RgLxC3XeQljxgwn4QIh\nAMPB0Cm/WcSjKJUxMdGwqwE79/sbuILmWOloOcLwVwH6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3326", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3326` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfZuuKuCIQrwMH4aofVFDKrJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkOWM0MjUxLTM3NGMtNDY1Ni04YmVmLTM1NjVmYjA0OTU5ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGUxMDkwMmEtMDRi\nYi00ZmRjLTljYzktNDJjMTA2NWQwODc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7viZOzhVzcBMXUtl8tWtra6js4kx0UwcNVUs41PWeYBHuHYwgsYpJHLDjvBg\nsRGGOkD6TffLjeaFEewdbo2a16OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR+q8hlfFDUjFSNrTb+F53qq7mdwwHwYDVR0j\nBBgwFoAUtT+hU86zbnMRC+poQKfrZQnzko8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD/aqnoKQk8v7FyMFPLNafxj2SEir9g\n6W5LOyw3VF8iqQIgM8rKXURFg/PL3VSRKOTgr4qhXz2Px+JmgW7RujkpOdo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVT91xUANCSkdWy2gcnLjZkTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDljNDI1MS0zNzRjLTQ2NTYtOGJlZi0zNTY1ZmIwNDk1OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7gEDBcZXpvvlY8v8ob4OCGrc/n4U2FyYViHXIJe4bKtwd\nKhn15gWFBlStnWxr+oh/G/Hzu3SRtyYNV4xyeU8ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtT+hU86zbnMRC+poQKfrZQnz\nko8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdhmLs5BB/biF6xO0w9/Dc7n3/Q4J4QLsJHLI0ApEiMYCIAp4Xm6aYQC0\nJGpTYpX8u7cqMjyZQ2lPsC90Q2Xk5YVR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAatpPaKXG/lt6DuMMvIHUfJGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGUxMDkwMmEtMDRiYi00ZmRjLTljYzktNDJjMTA2NWQwODc4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYTg4MzJjMi1iNGVj\nLTRlZjUtYTBiYS0xNTQ1OGU2NjU4ZTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASYGpz1BxSCV9weISRqimgJDNqQP483kPT4y4p2BL0Y9fV/UXzPiyTP4JTAGcx9\ny5Zk7M5L/4MbfcZ3dix6QP2Do3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRH6ryGV8UNSMVI\n2tNv4XneqruZ3DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA/8OWXi/11IZbhxnOS/CWTdfnz4XnpSUA9bKXaf53D+oC\nIQCU3rOe6QZ76ROC2gSSus0MLJCnlS/v8ZLoBtFSKSZBRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3327", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3327` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISATIE/HCn4HTUiDtftmFO8nSWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzMDc1NzQwLTYxMzctNDU1OC05NTM4LWRmM2U3YzYyYmI3MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZjNGM5YzMtMzBh\nZC00ZDNhLTk2OTEtMmI4YTIzNWM1OWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEclxkrdpYWE7amc//qe9AvGAmyTXLF7wCFOmetJVyYVzbVnNv9y2QcyWn0o5v\n/BUTxeOUkC39ElI2mFmazKQC9aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEXs1wwxMZsc23TW24AAMZmpCWAcwHwYDVR0j\nBBgwFoAUTyKXSia0lhPFGWDfHlEPYf0fO50wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIFfpxtV6yTR+agl8N+oz8b0VwknfJS3Z\n6PVDRa00NpufAiBV1ualVVmQuhsw845djIp6rOjA6f+Nfk4exOd+21BVTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX0bR8AiFQ4xb82GOd8j1QANMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzA3NTc0MC02MTM3LTQ1NTgtOTUzOC1kZjNlN2M2MmJiNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhviK0ea7oRzQbjs3TT2EH+sQ2DtuRLBVdZj/fhT2ePfxc\nHuFaaoiXsq9NRBKn74kc0o0UFUNnLKGyUBzCWr/bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTyKXSia0lhPFGWDfHlEPYf0f\nO50wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgboQUlLSgsHKrZphtGf2rhporyPzSEiu5aRg9kd2XDEECIAm67sDcfspu\n9Pb/aHy4s8GoOIfjTo84AibOMhi1xS0O\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARr0bXfHiIrqRtiqRgRx7LUoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZjNGM5YzMtMzBhZC00ZDNhLTk2OTEtMmI4YTIzNWM1OWUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMTc2ODVkOS02YWFk\nLTQyNzctOGJkNi05NmIwODJhYTQ1MDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATqGXOsLGR2y2OqEd5jUIavJE04f1X05h7TFNOwQnAIbGRgRFTBJEqQb7Ri7UQq\nVhYA3+crjLSzXYTw4+VaHPbPo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQRezXDDExmxzbd\nNbbgAAxmakJYBzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA3o9qtTjNlTAXlC+WhSnynztOcCse3i8zsxsNNYluWwQC\nIGxKTNXwYl8z8CRIaofP00N04dzkpHerKxvv5kPLcNTs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3328", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3328` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAURN9UbIyrdbsdTtjRJt5ntHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxMzc1Y2NmLWQwZDUtNDgyMC04MTNjLTVlYjM3MGI3ZTE1YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VkYzg5YzEtZjM5\nZS00ZDliLTgyMjQtMzI1NDUyYjY3MDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiXB6gEcuhjLNNEB1o7rObsmY8AEYr4JG/tpLhDLY8kvcWOQRXJEcVGuJkTig\nn4XLNSspU9YeIvk0LUiy/U/IDKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFG4v+rclTABLQ9TZCn9sltQAnv7vMB8GA1UdIwQY\nMBaAFFhnXS42ikRJ35quZtvfj5N4lb0zMAoGCCqGSM49BAMCA0kAMEYCIQDEsDR4\nVrR41DJjjOHIVTfdsaVgTHoZaB62LFnDeDX44AIhAPrwU+cko+IElx4nYHNt8Ags\nMCvL2UtSurxWJ7QHYR4/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa0vtpa1s8Y8JzZWlG2ha3O2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTM3NWNjZi1kMGQ1LTQ4MjAtODEzYy01ZWIzNzBiN2UxNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjIPXw5V9utabqX1J0sjbvWmxqmunUizn+4OjdHABVYzWx\nMN0NjYuOANPevps++Tm1tegoF7+lqWILm3O//vZbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWGddLjaKREnfmq5m29+Pk3iV\nvTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOOnswcrgWI8YUFye9IFt76mGbEjhMVbIyCHNmcSfD/pAiEApZ+/9tuF\n37BGKyOXSLG4mDav0mi84JvQK3E3Bf0xg5o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAVC9BUiZAUTkUBlPMx91scgHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VkYzg5YzEtZjM5ZS00ZDliLTgyMjQtMzI1NDUyYjY3MDA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5Y2I2YWU4Ny0yYTlj\nLTRhMWYtYjk0NS0wYWYzNTUwMGE4NmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATNtL3vpHkEukkO/AXZMyLx9BAL3e4OfNG9ittt1N8nNKHdZN+THS16QEEWmPsf\nJLnyr5MsK8Lh6mWMy6KWGcTVo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRuL/q3JUwAS0PU\n2Qp/bJbUAJ7+7zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAUQz/K19Z67oxV5xo5Gbc/fUUNLF1D3CTluIJK4Wg9IgIg\nG3axQm2pvyYk949HF7oqsvAcFGEg53eBXG6qN6o+j08=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3329", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3329` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXU7FXb2zYKmF2OHQAWOzyf4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3NGM0NDg2LWI2MTMtNDY5MC04MzI0LTg0NjJhOTAyYmZjODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk5N2VkYTgtMjc0\nOC00ZWU3LWI3MzQtMTRhYTFjZTFlMTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPLSatHeOxhjLrc1hdp3F8tb+0mktDq+f9pMkzk+7dUAmLm12b95q7Mql5Ymh\nF7fhV6gvlKR4mNFas8eiE2m+L6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGZiFLcSZZeuR6+MVgoP4Q0cBJTFMB8GA1UdIwQY\nMBaAFN6wZPSi+8BRrmH5Ly0JKeXqxVjMMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA4iBJ18t0Z/wWJKBxCIzyTrFTs11wSjRo\n+q5RtasuHl0CICBQ4kibRoY3LJWAo/DNNxxcEaf6vYLvcwCyYp60Pd7i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUMC/5kXwkgLKOaRjfhNrAz8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzRjNDQ4Ni1iNjEzLTQ2OTAtODMyNC04NDYyYTkwMmJmYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcwX4IL2x1NKasIy6iehXLiM+7hm/7Z0iHrSiTVwuwkFFJ\nVneKZHozKsWatyvmL5JmeRfJi38Le1wECv832Fy4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3rBk9KL7wFGuYfkvLQkp5erF\nWMwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSb2uk/n7GqSqQhdNY0dNQQbVri+1ekn/l9YFA9kv+OICIQC0nzUVfpDa\n+bekhcLy41NyCA6d4ddmz0LbzT50FpFb3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARi5HuAd/e3t178GMlzafXa0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk5N2VkYTgtMjc0OC00ZWU3LWI3MzQtMTRhYTFjZTFlMTMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZjZkODM3Yy1jZmUw\nLTQ4MzYtODQ0Yi1mZTg2ZWFiNDZkYWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASls0z5Em2aC2W749k/Sph71ydOR0kw+DwUj3fHy7awUuIMGsNlVK9foNfKw7yy\nOL+yu42X2Pc5ic3S25/Z3ky3o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmYhS3EmWXrkev\njFYKD+ENHASUxTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAjXgSMyndPc1OBN7PnjsX/23U8BpMpKTVNRqhhRXKUB4C\nIHHptEFxvxft5OADf1IrOmEmHOjS1EB7INXtWvavm5zs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3330", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3330` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAY7JLHTmgXEiXJBY5W1G7iLKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyMTk4ZTQwLTk1NTUtNGYwNS05YWRjLTFhOWZlMTBiNWZlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJhZWE2MzMtOGQ4\nZS00OWI5LTkwNDUtZjliZDRlMjY3NmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgvSQGuP44CvcKsSSKE3oAPjeEU6hmAU/8dAemb6Styzn6bdFzlj8z/oWMDLD\njyy39u2Qu8LN/Yad1LzaHRg2WaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJH5FXD0A+X8oUzfTiVlxFPWI73+MB8GA1UdIwQY\nMBaAFBTbxLuijrZhRSXT1t4jMLZ83gWJMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBNUXfZzzFQ4HnWbEY0Lqn3fcPFWK96J75Q\noElawb3iTQIhAO0E8O8W296W8mfFbIpqND4a2kJE3nOkPLF1iIhs9ZpJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWwvEGwhJFkMWUbLyQ5ciw7lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjE5OGU0MC05NTU1LTRmMDUtOWFkYy0xYTlmZTEwYjVmZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATM2+UxX4bhCV+KxO4oyHEG754RcMSJMN7RJ8WHEyvxuWeD\nGxj33vDgwXSC60jXVXR5OBLuqi2Z8jqukTJt9jbPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFNvEu6KOtmFFJdPW3iMwtnze\nBYkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMNDHvC4QxvVS68JbfHFwaRYhpzGj769ltSVg6nkZfurAiBSmGrVZBAx\nKwcOh4xx3HG6G6g9m2IKHP6fLaKVeSQbrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAejF+AFspk3qmwg6/pukOxvRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJhZWE2MzMtOGQ4ZS00OWI5LTkwNDUtZjliZDRlMjY3NmJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NjQwNWJiYi1kYjU5\nLTRlMTAtYTdmNy1mYjVkNGIzOGY4MTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR2pgbo72843XyixqbS4D6YyKrgTclgqyOdGv/hzSZZ0HiuhNxkUSwKYlaG1jar\nleqNRSt/ie6BkzW/yIWGzzy8o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSR+RVw9APl/KFM\n304lZcRT1iO9/jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiALCZS1yTZaBvRbWO4S+AnwSRoy2G4J4/X5bUiPseq5fgIh\nALwCdwQS0pH98+tysEfzORyJIa4mwy2C6IPcbgfygA4/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3331", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3331` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISARV+cJH2S2gW9YaFb09EQubHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MjI2YjNjLWE4NTgtNDM2Yy1hMTAzLWRjNjNlNGVhOTFkNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzIzNmViOGUtYzdj\nNS00NWVmLWJiN2UtNTE2ZWI0ODg2NGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjeOwrKJVxaiH0ARpCozartSoSB6Xead93PZokPdL8su2875RS0u53lOThsP+\nDOOmrkWA2/6FQEgFrcAXiM5wr6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSvmh1siPbrwwm32qbTa5JhN0+8WDAfBgNVHSME\nGDAWgBQoxC8ZPMGKsTEk2Wtjz46f39PtmzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDsVfJkD7RU8iwBZn6SASwZKJoBweNC\nE1oxKuUyr6NcowIhAPDzgs4+kGlX7uzbfXLURRPG+hNl1rmW+dibca0w2b3F\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS/95se9075d8k3quU7axIZJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTIyNmIzYy1hODU4LTQzNmMtYTEwMy1kYzYzZTRlYTkxZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9HayhBsx5GOr6mG5s4imV+hs0R9EBqyQW47Lc3FgZTl6L\naeYD8emDpSowTl3MIPe0dMpUEP7HugzwtOQp/+q0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKMQvGTzBirExJNlrY8+On9/T\n7ZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge5ZPppeUdgGJ/kGY/q/3nWzerZ2Keoq9n0gJYdWN3/8CIDeZ4Uin83Dr\nO1fat0jhntpKWClQHCsPNAgqXRqsyHnb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXI+aLV752sC2IUMK5EsrQxRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzIzNmViOGUtYzdjNS00NWVmLWJiN2UtNTE2ZWI0ODg2NGE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZjQ1YzlmMi0zMWU0\nLTQ3YTctOWY5MS05NDk0YTE2ZTE0NTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQnW6pYehc/Q6NMHYBLhbSDP3B8HsVIOcoa4pI6kGKJYSejeyQlQrIadp3bv0B+\nshPjLoD8t06nLZg6wji+wtV5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSvmh1siPbrwwm3\n2qbTa5JhN0+8WDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA6EcUd7xe1iUgku9EeCQ5Q23s8H+OmTuYq72Xy79VGqoC\nIGf5l4W4gz3Jsi9YjVpcBMCbndfI5A6wH0w3nfto6giR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3332", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3332` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAcIyjUwXAlnOrVZdBCvwSLmcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlMDliNDUzLWMyNDctNGUxOC04Zjc4LTA4ZmFjNjM0NWNiYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgyNDdlYWMtZWJl\nZS00NmRiLTllZDMtODU0NzZiNTI3NzFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdcQd32a6EU9DaeBRAdVDN4ktosqoeqvtV76Iy7/Hr+21dLPX1E0S0jW8IXsm\nEG1Hm2G5ibxldu49N4Csj7MuO6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXK3dBz4sn7wl4/bIgc2EqO5vIC0wHwYDVR0j\nBBgwFoAU7AD4cekPNx7YN/2Mc9l8uGg2zPEwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAoDnQwXi+X9xX\nqei6zY/Optl6yJaDos8tC71JtH+jorUCIQDMv9YDhruAwZy4FuTfp++vSvQ4ih6y\nVeUCp33AcsiuYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWAxENX6K6dLtke8O8TTqkEpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTA5YjQ1My1jMjQ3LTRlMTgtOGY3OC0wOGZhYzYzNDVjYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3zv4OvrVFp0VkQmN1R34mBpLBP/9Vt8ngrnwBWz6DVO/R\niRbMj1GvhentLtH183m/6ngFzFrlmRqhDTkpSUQko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7AD4cekPNx7YN/2Mc9l8uGg2\nzPEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJhMk4FDladChU3xn5mw7MDHthO7L1teWgMcGOBOEMmMAiEA6dJJjkrb\nZjiLT5LWXqG5iFX/b5H6EJ36KivOtNBZAa8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUoGN+RYyPGk4D33xM8E/CPAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgyNDdlYWMtZWJlZS00NmRiLTllZDMtODU0NzZiNTI3NzFiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NGNmMmUzYi1jM2E0\nLTRkOWEtODRjNy02YTU5ZDdlMjk1MzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATTbfY34efqn64G5vNf7vbSQE74/WPMXp7PKdHS4Ld5hvonk0XcN1K9C0RE2qLv\n4wXCpRLjB7GMspH9z4tG/r00o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRcrd0HPiyfvCXj\n9siBzYSo7m8gLTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAnXTMyV4ER5UzJ2BU5mdGuoXCG8YOqRBbQOD1VlzJqpAIh\nAIBZ6GwZo+cjEcyllEKGRjAJyWQsDfR9go37oWYqB50t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3333", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3333` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAVI9o5cgZk9ILq8emb5JaIXaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwNTBmZDFlLTUwZTgtNGJmZi1hMTNhLTE1YTU4ZDVlY2UwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNhYzVjMDQtNGU2\nNC00YmRlLWJmOWYtZTcxOWI4Y2I2Mzc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3hroB10JpNmfXz/oGSxILt7DcXTYhdS0BP94tNVJVLMocoiimhjxtYValQAW\n5NYRWChLJEmMysEbB1sGGgtccaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0TFUxG6wFncXOm2ow9gPWpgsS5gwHwYDVR0j\nBBgwFoAUTYeKJjEP9OpBAacpQ9m/FmbQAOEwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA/qCukvphsTKV\nQMtfnFUHoAlWiFh7iJI7jmXw5ZwJyj4CIQCpCKkVgR856iqlL9tr89G7lu1Zr7aW\nPsEyDoKD7vy7Ow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe+lp4nfROQLU9+4Nd0I7gBJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDUwZmQxZS01MGU4LTRiZmYtYTEzYS0xNWE1OGQ1ZWNlMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVs6eFz5EI01RLiH1WJJUWumv+Ao3eqXX0FapLpp2JJpK0\nx+7s6GTiKRWezMKzPU0DUMzDknTeVouO0YYfKbQIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTYeKJjEP9OpBAacpQ9m/FmbQ\nAOEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK2OwgytG80aVtp10PJzDADImGKvje/cmmchPOWRYxtBAiEAsTPO1MkG\nZhess9tlI3jrAlSykzX9w+ycVcWZl7TePGk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQZY/wFAc/Vy1Ex89VIYqBcBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNhYzVjMDQtNGU2NC00YmRlLWJmOWYtZTcxOWI4Y2I2Mzc3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MTdjYTZlZi0xODM1\nLTRhMTItOWMzNS1mMGY5ODIxZTc0MzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQpdYah8m/1NkL492qPSvXLvSxv51R//oU1t6KWCaWctvFl2oLV6916DoNX0ohj\n3RN+q9550XmNIbGwSC96tVRKo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTRMVTEbrAWdxc6\nbajD2A9amCxLmDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBd8Kp0u1pwVZ+06S+7Q8wiySkn6erXXrpMOdwM9B+dxAIh\nAIu4euGbG6rmiLfKKTrug3T/qEiuf10KrPlqLakZeDbA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3334", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3334` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAdR9uI12x17h3irIsfpMVi4YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyMDgzNWY2LTJmNTQtNDQ2Ni1hNDEyLTMwYzczNzc3MjIwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE4OGE2MTctNzll\nNC00ZWVlLTkxOWItZTQwOGRiYzA2YjJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQwpXHGu2Vox1D7DXHMEuo2xsPD1ypY/LQ1ZTiVg+SPNRbLKHPgoYIi+eOo15\nqGuRLv/ZrV08Ef3PLm5gVW7jF6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZtCJy2rodayYQoJAI0Pl1cjUxlswHwYDVR0j\nBBgwFoAUS/yBDujVcRPXdWUpPg+9sSaOB9MwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAocuWmA88zaB1poun76rq\nBIHD3ih9CoJBqJrY/XIFQkgCIBZ/GooYTSGulXylsbP+Y3iPUzqd9hn3mLWDxe0d\nz2zp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS2XzwRGKTFYZmX1eF8ehDENMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjA4MzVmNi0yZjU0LTQ0NjYtYTQxMi0zMGM3Mzc3NzIyMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPY7veFInxBpuaYJIvYbeQmRKZ17XSOm8dwTvc43JuuN+5\nIy0tDPTpnYBQGuuoE/Bh1du639W9jH0n+oASbQjNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS/yBDujVcRPXdWUpPg+9sSaO\nB9MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNY37+H2HZWIOeuTqESHvoICkM683i5Gp/0zqR+G6IMYCICUp1fZmhy83\nsNn/EYnr+OxQO2cmyqk0iNWUFIjaBmkj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAUmSCOVTbq5AGZIO3AFBDH9OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE4OGE2MTctNzllNC00ZWVlLTkxOWItZTQwOGRiYzA2YjJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMTZjOTNkYi0yNjA4\nLTQzNDItODliYS1hZGFkMTg1MzAzZGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR8q7jGglTDnCp/bIpVS/Sd5FTwN3FAOb/QwM4YZLVj6ahWXw5jnUvQ72qZJtmP\nRQ9p2r/clh0lShrJlwtoizQ0o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRm0InLauh1rJhC\ngkAjQ+XVyNTGWzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAzzXErWbEod5P+i39/ZrW4XM5YN6+MBPkhjtBH4CUe6QC\nIQDU+uHJSl8I6oBOMp6nKtVFpkKcNfWBj9l3aDPbdLtG0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3335", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3335` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAT1M0JW6M2/vtfOYJyEXBVtfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMWY4YWNkLWY5OGMtNDJiYy1iY2UyLWYzNTEyNTNmNmVmMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNlNjAwNjMtMGZj\nOC00ZTM2LWIxY2UtYmRhZmUyYWRmNjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMUMKvdUKdmKBbZeDVk+Xw8ZuqeY356f2Z9mU77ryHegs9jTtVQP4MmuKyZcr\nVQdNTuOTotKSk4sUtP6HMtlyeqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn7RLrdBR5S9MegK25tZUg8SRe1QwHwYDVR0j\nBBgwFoAUSM4CMmeBUYH3mBphX73XAz0v2nswLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAmCr/O\nylHvCFOTH7arMlj49cPAs3+mm4lhbra+xt53RwIhAPfMaJGMcz+vGCD4+OPSmmrs\nJqY42XQQZ0tkDdnlemAj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATVkKvufMAPYiDdN6VKapV/YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzFmOGFjZC1mOThjLTQyYmMtYmNlMi1mMzUxMjUzZjZlZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5vLU5zx9P24rAA12/EbFO6YM28rbEyhBooX6oeB6MQRxf\n534U8etaQLAq0pattdOh139qCSLbR5iBiU1mhDqno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSM4CMmeBUYH3mBphX73XAz0v\n2nswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbse+rRuWcGi09WLUhl5LMoDvOiawQiPsJYbIb4K7bm0CIQDitKtVfd7B\novA3TUt6H8Irrb15UqRrvQI5Jx4UlBhGew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAacb5gKni5DAYJcJvg91bAw2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNlNjAwNjMtMGZjOC00ZTM2LWIxY2UtYmRhZmUyYWRmNjliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZjc5ZDE1NS1hYWFk\nLTRhNjMtYjlkZC02OGE1MTY4ZjcyYzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATqEKC93SvV9g60cIRj6tDIaQRX9S9GcSErbjC773I4pQ2udAThpHpLHStYEybI\n/r8EzCeCHJkTtS0QxV2Jgpxmo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSftEut0FHlL0x6\nArbm1lSDxJF7VDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAp5fEI6Z8csY45DPWDV2lky7lNPmEbVUQs2N18E25nqwIg\nKiZ4NunqtBFhyVSBzaLdTpU5LbUDkz2rGW6YyMzAeeI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3336", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3336` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAf5bRafBRqb4pYHNEsPkfBbgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjOTQ0Yjc2LWVmNTUtNDVlYy05OTJkLTIyYjI0ZDE5NDRhYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE0ZTYyZTgtNGM3\nYi00MmU3LTg0YzgtZWYyNzgwZWRmZTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6CXc1/tVakN/4XI1FJqnrmsvDKnPRt9/sufu+6fih8Dp5bNximgbYAeFJyJH\ngEB9vtTDVf3GgzKO59Xrx8V9e6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgSVzUkw/pOBaJ3zaJQn6SS1J3d4wHwYDVR0j\nBBgwFoAUX2TtWY86t5nJcgETMyWqfJggYz0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAjkhF\nLG83drlbWLlNyzm+JG2yQN5Jv/v+WgtlK8mXi+sCIAGlaI6xLXdnwN23QzvjEVUS\nbCCecWrgfg6TKc9aJw+m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaFkKf2C93Ckm/dz3BNt1/JTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzk0NGI3Ni1lZjU1LTQ1ZWMtOTkyZC0yMmIyNGQxOTQ0YWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy9nN1bKKp+N0ES1zwj9hPCoGPf4ncc3AwEn1AtCH/o/xS\n9jXEv1kvMTEGn+bOdJKSxi0X0UyOEyt53W13MhlPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX2TtWY86t5nJcgETMyWqfJgg\nYz0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIacs6a/Hq8+saS5v45MJiYOqFQfHzcU3N2LHiHLkw5kCIQDJ4WP9z3Ai\nM0kIEtZscghcoK9xUD4T4ymZ23rh3EdV+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbCWXzRZqH120KPOKLE8IeFiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE0ZTYyZTgtNGM3Yi00MmU3LTg0YzgtZWYyNzgwZWRmZTVkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZDI3OTMxYi05OWZj\nLTQ3OWItOTRhNi0xZjgzOGY2ZjljYjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ9kAKWcAivDPV2bShJnkUCvx9uSKOeBi5nE5Tif0YZyBz9XtnGfCjkXySutWPf\nz0OTHfO/dLJvgJCCuJaBKrzno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSBJXNSTD+k4Fon\nfNolCfpJLUnd3jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA6qsHB2yPCqVBZjFuXfVVLBGpmNhi6cZnj98T54RaT5wC\nIAQ05xEsy6AT5/YQi3n81E5m5pc7yqxPkNzG2rUXszf3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3337", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3337` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAS8rMt24GmKUBVVUG9hgNzJ+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNGYyMjlkLWE3NWItNDE2Yi1hN2M2LWRhOThmMzYwNjlkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTgwNTAyNzQtNTQx\nMi00ZTZhLWI5YzMtMDgyNWQ2ZDE4MzQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvk4dipu103Ag/euMhFYHp8i1pqRsJy43BfHSHXy3Dsm3HbQcsc93IFeOG8b9\nppIG3B3WpfDPsl4J4vZptxVPFKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFO3EInmABULFzfLecpbcWQGXTU0zMB8GA1UdIwQY\nMBaAFIMOcqK+hO2g2/zCiQUWKZhIeJpmMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAsSE92bZ7X8yyylt+kTyB2Lj59SDQ+RW1/\n4Prx3hDcnAIhALEjubR3NyVvq+MCBp3/OAhctdBTGsLe21Gmqg1HVyZv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVcryvBGFbaPNpC9udlz/MuiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjRmMjI5ZC1hNzViLTQxNmItYTdjNi1kYTk4ZjM2MDY5ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCr+3fXdFOveE1MSpoJVVP3bSVYPMw9m+VyxqOQwpuNlJs\nrVlElnWzMeq30Jm59MjpRzPe3iF1vWwJIMgq2y6Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgw5yor6E7aDb/MKJBRYpmEh4\nmmYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVsLaP2ILccz6kdMd2dV66ouMo/vYCy8I+7uxCDxLFicCIAFVJrs3Rghr\nOoN614b2oOdh7F8GjsE1Uk3EtDCzDWTZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVdD4cmhoh4NsbMxcD7ZSwy8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTgwNTAyNzQtNTQxMi00ZTZhLWI5YzMtMDgyNWQ2ZDE4MzQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNDE1NWQ0OC04Y2Q1\nLTQ4MDMtYmY0MS0wZjA3ZDc3MDUyNDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASVT4/EBSlIf07J7zR0KRiMM3vov8CMrxd9J1ncotraja2tOiixdCcyL+uk6/2v\nNj59r6j+vamH1QJ2RU+83q5mo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTtxCJ5gAVCxc3y\n3nKW3FkBl01NMzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiA5XsDPyil59c+RcxipAGzoxd38nTMWCbBQyaQMKJ0e/gIh\nAPPOrdYRw7dqwnhll4JIuutrpqYziOS5SA3W12BxtiQq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3338", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3338` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVABBI5/EGXrv8zRKNatfy1eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0YWNiNzNiLTAzZWItNDE2NC05NGQ3LWViZDM1Njc3OGVmYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE5YTEzMDMtZTli\nNC00ZDFjLWI3ODItYWU2YWZjOGQxMWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8tL0HtgZ2vGJ6z/ZLBvgvttkqlXeTcV8NzVOhs/qeJARqUf7nVhNED1vv0qN\ncGqQcma6cCjC/Z8qMkzOoLJ7YKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGb5YafKUKfUqTHf2oJeeZH7+HEEwHwYDVR0j\nBBgwFoAUMsfmg18ROZe9JFCimJpImreqXFswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgD9r3UN5yaIk9\nFcLlIjLWgAQj5EzoZ8VPXT8aKn9SQgICIQC+exksgonykXi/cY3gwCsfQk/XSAfA\nRMp9wSvbe/xQ9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXx/4b8LRtBkvuFjgxFyI3g0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGFjYjczYi0wM2ViLTQxNjQtOTRkNy1lYmQzNTY3NzhlZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmIq1cvd0LXYAz95mRxZ3OU9ys3qi5EpmYFmmEg6JTuYqd\n2e0WxGuaSgQP4LtDC9svtsN6zWwv3NxFeMo4CKFso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMsfmg18ROZe9JFCimJpImreq\nXFswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYIO9Gd4xUTSUVU7RFeFqmMDqx0/f7DVejwcl8l2bPqECIAWT4Bo14JGQ\nzvDQIoA0s33UA1PBpbLMejlJw8ip6gK5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAe+0GsmluMju03+y5c2YZXtIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE5YTEzMDMtZTliNC00ZDFjLWI3ODItYWU2YWZjOGQxMWViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZDlkZmE4Yy01YzAx\nLTQ2ZTItOGVlMi05MWNhNDZhZWNhNDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARbt/hmSi6ZqbwSBoBhV5trJf/P45fGe3wOQph5jaDjiNscglyovQbWbEfToXGC\nhf7UAKF+kXcGzgGCwII1U0eho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZvlhp8pQp9SpM\nd/agl55kfv4cQTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAskG17geQcap9fVRI5fUG8+Om5MHLIiU6LmsidB4j2EwC\nICBStQY3axK6RRebFI30ltUQ1pvmOxYVE1r6MF0vERV+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3339", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3339` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISATCySZqzK/iskX/wzFPy0S81MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkMjNhOGJkLTFmZjItNDQzMS1hMzllLTdlOTNmNDllYjU1OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQ3OTNhMDEtYmI4\nMS00MDJjLWFmMWUtYWYwYWU2YThlYWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs8uxO82WKU8l0nA+GeOMhqyZxWaC48iqZmvB9b9OwWuX8vjPsXEa1IDuJICF\nRvACWmVg6LLGWt1AWxxkEBI6maOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnNHkTVI2/0Nmck4YgVc9A2gevX8wHwYDVR0j\nBBgwFoAUf1h0tqoqBH03Ym14+z9ZvmU32pwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIga1GB1em2pQB4\n5iH6+hnGgc2mORA4OUV32Ojd5AfxLlACIAecBImecg6jm4+mwjom3ExXVEuVPSH+\nt3wzIttzaA1V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT5tjHVc+oSqmXn9ULqmXQ0/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDIzYThiZC0xZmYyLTQ0MzEtYTM5ZS03ZTkzZjQ5ZWI1NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS11NIbDCZWOJmmHqxXStob6xhcXL8OgZfYTOHJUJIwZZLS\nl/iawFEt2jQ+x+5a5YMA1+pX444/Qgf8c6UNXtrpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf1h0tqoqBH03Ym14+z9ZvmU3\n2pwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP8foaL5HhqvhFZybixLOQRclvgE+tk4lrziPSEz/uu9AiAmbMDjI+gj\nESsWSl0c4ZFWZodmqVqLB7Q9YAxiRv2xtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAR3jSAa4mJQDiqOxVpHrFKp/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQ3OTNhMDEtYmI4MS00MDJjLWFmMWUtYWYwYWU2YThlYWZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNzc1NTI3ZS1kNTU1\nLTQ3YzEtYjFjNS03ZGZmOTRhZTYzNTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR/MYSkvz3lR01CKJkT1abltytMgDNGQRfCJWTvjGfKs6RQCkStCvGuanWp5kxt\nnckrnRTAyqxUaQUmdBbsNuGpo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSc0eRNUjb/Q2Zy\nThiBVz0DaB69fzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAkKNPnbDsszhzl9pvB2eIoIEbb2zl8MXQhsW1m1VjCvEC\nIGM/7xXKAKVfhEX6LlC99dytBXPu5YrKdRSe7GIUph9p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3340", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3340` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWzQlaZvc+jvSsTRJiCRAudMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllZTNlNTQyLWVhZTUtNDRiMC04NjEwLTVkMWY4MjAwNTc3NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzlmYTQ4ZDItZGQ3\nOS00ZjY5LThhMzktZTg3ZmMxODQ2NTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFPTYN534aB3Dqd2o1GHuk3BRv+W11TSDRf8mwVigsavuDpKgCe+bNtIwmMCA\njnjBru24BDhafpq6GOgtZgaaoKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmnFkxytUV8ULd5OZZ4Bf5B439U8wHwYDVR0j\nBBgwFoAUaBQ+LKz7LTPSAKAYNN5tK97R4AQwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICsaMG0SNDDc\nxw0oBGA4ZN219PLaBY4hlHFi05hSmfQ3AiBoMxGrUYiN9PcWJsAugsHpqBBYtzf+\ndI/FQwanxMoErQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe1wuB+O1eoz1WiNPk1jt0iiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWUzZTU0Mi1lYWU1LTQ0YjAtODYxMC01ZDFmODIwMDU3NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATr7z+vbRIG/N74PXuoji7tifHgp6Vyz2ZdIPOHpPjjf5hf\n/xTl7b7XoYzwLMg7wLPZlMc7Gb9D8gKtVp2RuzEZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaBQ+LKz7LTPSAKAYNN5tK97R\n4AQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPKAB2BavLAjCjTxG2jROfeKJqMyL+BDjgrQEapolINdAiEAxtTXXge9\nfmVjVdyRtk5PlKRVUV8awwxj6bUMMjGH9Kw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAXfDeM0cLHcLyj+DJJuLbrEYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzlmYTQ4ZDItZGQ3OS00ZjY5LThhMzktZTg3ZmMxODQ2NTM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZjkyNTNjNi1jMDE1\nLTRkMDItYTE1NS0xOTM1ZTBjMzEzZDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASu1V2MqgNyfujpC5nobLeay6O0zsPTnVNOpJXSmoMcIbwNQkCxcuLtP82ieFGI\n9g6U/0jWP7wR9jl3k5znQI9Jo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSacWTHK1RXxQt3\nk5lngF/kHjf1TzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEArrVtKCXW/s8Eo2WKRVe31msnciN2IMIjP/OFJnGSsyoC\nIQCZKYzWdt/602Xd2ozeqmjXSD0cb4OPWHO5ULjmXI6C3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3341", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3341` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQ6DCf7iudNal69EDLR6WjMGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxNjY5NGFlLWE3YWYtNDk3YS1hYzFmLTRjOTg3N2IyYmVmNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI3NTViNGUtMjVm\nMC00YzM0LTg5M2YtZWIxMTU5ODdkMGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyjVAqrhwiE+AYFE2R6FuotsDdsAMBnP31UraeIxivM7NN5E2WyNMmro2Va8g\n/aFi7SmZWrtqd4w8gFVI3eOsMaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlTF640tX9Dfkw9PW1XoGi9E/1ewwHwYDVR0j\nBBgwFoAUZdR8gaXTF7HKciMNUt8TcJt8tGEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEyvPYVM+6dQTu3LB+7cqbeV00HhlO7JvSg1Nx3dhcWeAiEAzZTS51NHe75e\ngH0SUbagZFd2k4StryNhmqx4qRlJj4Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVsK7mKzOVfQYR4vjosXqYQ5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTY2OTRhZS1hN2FmLTQ5N2EtYWMxZi00Yzk4NzdiMmJlZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlU+jB5ishKk94Qi8BYmeufWgn8Twkg/gxDXwV7gC+zk9u\nzcO2ST3uhEh6YcehJ4S6iufZpLqIXiHFRrE24bnho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZdR8gaXTF7HKciMNUt8TcJt8\ntGEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSwSQsGm6xJtPUY6PnDpSSS0fpKv3yX+2pHnWrY4+HuQCIQDmRPBrcAMu\nP35TBEfEl3H6SD9sLhriboVUzIG2wSr0uw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAW/Q2ZmB9xWo+xUvKI/chq0NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI3NTViNGUtMjVmMC00YzM0LTg5M2YtZWIxMTU5ODdkMGQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZTgyMzE0Mi0xMTQ1\nLTRhMDgtYWZlNS05MzQ4NTAxNzc4NzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ5BB5AH5CU4Q0hsGcVX7wZdKBFZSfT+rYiqwLWnMC8UrRfCxF1pzOgrft6MhqD\nUQyLAP07LbJtpt8Kk9f/aE86o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVMXrjS1f0N+TD\n09bVegaL0T/V7DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBgQ188ypdRS6s1x6XTDQIHF9BXLHtVQZbMxyMooYG6BQIh\nAKREE5zHLVBjnNfWm6UsEAbIBr/dFVK8rASEnrabLtUS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3342", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3342` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdFq6U0z6sBEoEvTS/yo3z8zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MjE3YzJhLWM0MTMtNDQ3MC05ZGI3LTA5YjRiY2Y1ZDlhMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmVmMmViMDAtMTU3\nMS00NDQ3LWJlNDYtODI4N2E4ZjgyZDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2P1K5A5sVzzQ/eKC8cVQJUzC0n/ungle7BZib283wfPMk9n1neB5KO5CzGdy\nv3HC4rs9132NHgXOJiv1KS0Y5KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaI0xTcm4Fl+aBtCoclhdCmTchMIwHwYDVR0j\nBBgwFoAUWoF4PWLFnlxeH1+qR+jmMbegiFEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDvQ4LKitS/Sh5r4EQ6m2AdxIxmGiCn2zII7QQ4ftsUJAiEA16IXLsTqOEwp\nEFSk18sYUbsAvavqtJ4XR+HU/Qwr7FI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaIpTPPY68BXw2M6GvqAyEpCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTIxN2MyYS1jNDEzLTQ0NzAtOWRiNy0wOWI0YmNmNWQ5YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0qYj9y4SYqmjWajKhc4HdCZi7T0OFDsEmwhm7VAuLrWME\nCzubfXNhZrx13fdog+vSr87NVNHtn9b6myFqt7fWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWoF4PWLFnlxeH1+qR+jmMbeg\niFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFfLWMG+EMA1KARyanezI6F2w16elMJ/pjVshtcph5H0CIQDCXEXVg6KX\nAkg//JFNzITJCAbHuewjkeWjF2QhEdG4pQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAa1TQDE9NJP7NECXJ4cc0WFjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmVmMmViMDAtMTU3MS00NDQ3LWJlNDYtODI4N2E4ZjgyZDk0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYTE0ZjM1ZS1mZGJk\nLTRmMjUtYjg5NS1jNTJjOTBjYmQ5NTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATuETuA4FwfDUrnnubNJNX4alqNC5BDw/znd/IWBRyAMZjTFfaPtVohyYxmZucN\nhdWkYiKEyyo9FYCiQWFOzvSao3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRojTFNybgWX5oG\n0KhyWF0KZNyEwjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBV3D3po3MDyWlKG9v61TxkulDo4tEogOiC96cJOUsyggIg\nbJyRyMclLM96RNfamaZZ9+7yBwc2kyU6N0LBIF8GUy4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3343", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3343` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAYhXYu72Jplxfx5Pu3n+YbiyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzNTcxMTlkLTVlOGItNDI4MC05ODUyLWUyMmMzMTczYTFiZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjVhNzI1ZjgtNTcx\nYS00ZTM2LWI5MjYtMTFlZWMzMmYwNWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETC6BxEiJ26j1YzOQTY0Es7pdXkwPYDA2iuFiCzh5dPW+bJR7j4K6LB5DMYaC\nx4ozMxrrqup7C5wHRxj5f6yeiKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjkbYHh6pszvfqYw4zE4CtVjhNwwwHwYDVR0j\nBBgwFoAUmxNrTGanDEVwv+1ozjJSFJgz2LgwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDt\n8E5LpiphT5SoGFcQTaCjhv3OlgQ2dbwrKkWOyI2tTAIgBU0BTbDu7uFOBD9ACNg6\nYhgtY32o92ND1OQK2AkhG+Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeTe8CbsKqdLfVa6HjjqTJ4VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzU3MTE5ZC01ZThiLTQyODAtOTg1Mi1lMjJjMzE3M2ExYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsoUkBTi+FLXfuqNSxYso33ltWRO18Z70WWiV05+Vr6bRs\neBmW9Kky3jRhUK3heUctcrJILQmDGFdTM0fzcS2uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmxNrTGanDEVwv+1ozjJSFJgz\n2LgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPWNpT1v9XRzpENWRElrRhxG8Jwi1Iu8g9OCEK1gqeS9AiEAz3XAH/3s\nwSxJ4eOcEZAa5BTG+zV5Kf8J81y/faIC/qo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAeZhGgSF12BFcbetZnfuYdh1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjVhNzI1ZjgtNTcxYS00ZTM2LWI5MjYtMTFlZWMzMmYwNWNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzOWFjYTQ5ZC1lNzQz\nLTQ0NDQtYWUxMi1jOGExMjM3OWUzZDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQrUXVA2iKe/5QQSm+ykGQ3ytqhFLx5Ttrb3+GbtRLQtZmI2H60ujKxCvxq8Uu2\nZxOme3jOgDt+LgZKrB3WWVN+o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSORtgeHqmzO9+p\njDjMTgK1WOE3DDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAstNB+T4Rt6acDY0PNFN6nTiqyJ8dd4NowqmSRUOTM6AC\nIQC5u71j4YvqRnp3ao+DuDpXeAE99UbGUwqv/izUUBpEuQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3344", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3344` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAaR5yLgKhWXMvBoxBLfQ9x+7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjOWFkODZjLTc0NDQtNGM1MC04NTZjLTE5YzYzMmU5NDgzNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk5NTZmYjEtMjc4\nZC00YmUzLWFjYjEtMWYyYjE5NWJhZGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOVCYsS60a2wKO4hKqn/QftqVWk2WE9sJPoKWo6PCB8lYz9stIUobXchn03BI\nZWyS9hcO+7wKPOJLrGFGvEXMYqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQx9PQTzWxscgfsEnRnUWSSmxFd0wHwYDVR0j\nBBgwFoAUoNvnb0336/LRyg9Ubh8d4Adi7ZkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCICPISLWXQ5l9zCfxYT1Qlmmt8J8cvtWEwPsonKKHiQK0AiEAyhwp\nGDvxSxUznbfd4WatdU1C8HmVfTxyq08IIhqcqHM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcEd/+fd6mi5HCjoIszCWTnJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzlhZDg2Yy03NDQ0LTRjNTAtODU2Yy0xOWM2MzJlOTQ4MzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1DHbClarhfFlCz9DOYatJZsJc5X2koyGWTy/VJu79mmWq\nWxmDIj5eUAOjMgJ/NPePsMjrlYP6CfHrwtRVUFeuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoNvnb0336/LRyg9Ubh8d4Adi\n7ZkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMMswGpPeczQq6xczNBZW5ldf+8sz5y5niIFOC4XLy4ECIG+/dySZa6my\nU9WRdRLauLPzkS0VjkhWzZxjjG1d0gZe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWneUBmXFy/9YhKCEYremvtLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk5NTZmYjEtMjc4ZC00YmUzLWFjYjEtMWYyYjE5NWJhZGVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYTcyYzZkZi1jNWE2\nLTRlYjktYWU0OC00YzhkYmQ0ZmMwZGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATLhwQkUaRz/VMeRMH4uRAxswaE2SkrlHswSjja+fhJhw7Oa4vYlhfQzY+q6CYw\n7YjVB0tV+JWosNZDRCkvLkWWo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRDH09BPNbGxyB+\nwSdGdRZJKbEV3TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA+IJ1QU0akxaxPhlYvPYyYPR9R109523+y/pFplVK+3kC\nIA9c5SE4U13XlvNwuyZ0ST3SEZtWQZMYFy0yawEOkeYF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3345", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3345` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAayUKnADBmucvcqE6TeS28JyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYWY3YzNhLWE1YjMtNGU2Ny04MThiLWJkZWM1ZTBkY2U2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNjYmViNzEtMThj\nNi00ZTM2LWE5NjktZDQ4YWFhOTk1MGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXeq8P+FbU9SvLmPONu90cg3n0DTnxM/za5XgYQKzCecNpIyGbvi2ss0ywQEX\nmFHRwHFhgM4zR44uG80zQi0WAaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXMnSADbxXx0xI0SZX6YGyqJVVDcwHwYDVR0j\nBBgwFoAUoOl8R5bSTw6I/Q9Qg1MIvbVnEuYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHBFgiDaeTGn0KxBSG+7niqq6/CFXc3hYNddz1jmeTxAAiAD4SIp\nZDVQ0MNEG+c3+j6CqIO19a1aFLQmLgmNAq7UDQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW34Jf47rUVDdAAqmz4QmCOsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2FmN2MzYS1hNWIzLTRlNjctODE4Yi1iZGVjNWUwZGNlNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATY4t+XvFd5pRwj+0culUb0e0oXa/rJa3kC9K2WIhF7I4pw\n7iK/F8llK6G7KiNZZkIBmVuehsVCz6LY0TCc0dgLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoOl8R5bSTw6I/Q9Qg1MIvbVn\nEuYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPvo6F26rQTYGmXuRsYeiZCfAT9Lwm8wi7WnHoszdsetAiEAgGPC9xQS\ndiGYQOy8/D2qHFbRLzaUW0jLG7RWp6jzclo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAS92/HZn8tXbjmV6mCeNscAFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNjYmViNzEtMThjNi00ZTM2LWE5NjktZDQ4YWFhOTk1MGQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5M2VkNTljMi1jN2Uz\nLTRiMzctYTg0Ni00YmRmMzk1ZWZiNzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR1KZZbxpaHsHwWVE5tbzFIcr1urrSz75SMGH7WmQqbQY4QgwSsmX4aObqWZX15\noSL0IQ/ilbGETFWsHEgGyLvlo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRcydIANvFfHTEj\nRJlfpgbKolVUNzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAsrBi17kWao4IAZm5ukajDrCKWEUTFRKRVYufyX0WFiIC\nIQCeG3dQBpm4efmspFn0e6LCNw63GBG2GeECD/N8IVvGnA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3346", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3346` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAUDZFopp59yWU4qGhEK+Fe1CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxYzdmMDgzLTkxYjEtNGRhZC1hYmRlLTEyYmRmYWU2ODI2NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA4ZDU5YmYtMjE2\nNS00YTNiLTllMjEtNjQ4MWYxNjBjYTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4byXZsf4NmnaLnjhxXbNJYHq6O+jWIKiXfUuNt7lki5lKQeLKifkwmq1COiu\nZJSEpGiAhxAVKr7oHCnOBZiZxqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCtm+e9znYKxXdD8ieGymAuyZq9NMB8GA1UdIwQY\nMBaAFNViYzZf3hQgNKk4feuOghClZufgMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBdp5qcoi6QiOPu/TeKIGpSOeBcc6vHGOOr\nT9m6x5/iogIgW2nunYKYV2id45K5+x9bs+7PtVQBasyTPQl11UqtrwQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfMXST3NTjrVAkvf9mAy2TAsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWM3ZjA4My05MWIxLTRkYWQtYWJkZS0xMmJkZmFlNjgyNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQN/2RX9Pk54x223c9D0nagXil2Zp7W/C2mIZ+Cvm/BWZBd\nDLuqryoPbvdZ++3zHS9j8HMjYmmND9eYci6sDAG1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1WJjNl/eFCA0qTh9646CEKVm\n5+AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFUWXn/0kToGiaeIUJ8KknTONgX4XGB3Za6+LhzA9NncCIHs77nvhUQPv\nMEKkBa1Y4ll8V73n8tWOA/L2aZU5TTbH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAeIdz9E+o4DrAqJr01ZDyIFDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA4ZDU5YmYtMjE2NS00YTNiLTllMjEtNjQ4MWYxNjBjYTExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmZDBjYjY2Yy0wMWRk\nLTQ0ZTgtOTljMC05MjgwNzgzYjY4MDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASetqZUFLbOBza+cARUtqfxgNF25MTrygLQr8yfpAlFIw/EfXRGUtyItCUDMsEK\nJGU0eTa6+wSZmGmkjPJfNTxIo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrZvnvc52CsV3Q\n/InhspgLsmavTTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiB9KyFpofNYgoGa1TmC7a3dzwjRH6YzovSuxv5r1YHB0wIg\nN93ZtFsXVxqoUpsKbaeBp5JmxAtiRVKNySN+rYgVatU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3347", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3347` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAaHzB+UtkfVbIFRPstnDNi9IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5NjgwYWYxLTIyYzItNDlmOS04MDMxLTFiMGMzZDIzOWVhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVkZGY1NTktYjA3\nMi00YWY0LWI2ODctZjliOGE3Nzc4NGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/3BzNENs/X5CuoP6FExUnxFqBrUKZwd63dtrHiMKuwiBvltopvipKgVT2TaM\n8O63zyKXxkFxCezW8fQCIfMAyqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnMkYUwjANiCs6OBUpeE7qv64FrcwHwYDVR0j\nBBgwFoAUq1bSY3vYOcdhcYB480tkHUaBxQIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPoSTs/LDq1m\ndad0ju+uEZd+r2tTjcZDZGRfFJoQHULxAiBFCnYv/nzfDwfxcTqd2tncUyoaiNNt\nn11jko11d5JZpQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT6cnMCrq1JhrV4wIJYdFFZWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTY4MGFmMS0yMmMyLTQ5ZjktODAzMS0xYjBjM2QyMzllYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrPXhdUEP65TUfOXrP/JuEhf+Z84AnNkDMr2K/fOyFqeHN\n0agCmToVxyGH+kqyjWOLw/Tf9/YdeE9C6O6sOSsUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq1bSY3vYOcdhcYB480tkHUaB\nxQIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc8msbK+f4c8qTqg41S2JlxTxCtKn3WrS2MxKiwGmc1cCIQCh/vSawaWu\nA5w98O7QiMXdfvhVDO678/5ZUEb4/jnVgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdyXiiL5o/jjuDqMNzEJZLDhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVkZGY1NTktYjA3Mi00YWY0LWI2ODctZjliOGE3Nzc4NGU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OTMwZGI5YS1mMzU1\nLTRlMzgtOTNiNC1kM2FkYjQ2NGM1YjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASEUb9ZzPmTmfSmChtzFYW8Pnw0wGn6QgAsSoy8NMO2ImRi3+9yEVCshw5TBVU4\nG2wT7J1t4UpG83oScDnlIs75o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBScyRhTCMA2IKzo\n4FSl4Tuq/rgWtzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA3CUBWtg97Og/p+EsR7znYNZbCeYv16bO+5yDLMYlZUsC\nIHX/jOwSXG4glSGFZlzbQyXX8w+8B8V30LsHYTlytTPw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3348", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3348` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAUoq9l85m5LMRecZrlFkoU+mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlZTA0NGI1LWE5YWEtNGEwYy04MjllLWZkOGYyNDY5NzI2NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzYyNjMyNDQtNTBk\nMi00ZThmLWFmMmItOTE5NWZmZTU3ZmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgwGPURfTDLfi5qcGlQMXqP99bK/o5Y+RpZgVgsPa0ucQGsv3m+dA6VdwoxAO\nMpiv1IEeeAEYMPLR3G38r7w5YqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtLpXU6CNY90FY7uU//OHjwbfpbcwHwYDVR0j\nBBgwFoAUa27aJUBVfNW3DCONRnCnuWL6P3EwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMrw/75HoBif\nYxSuys5NfWsclcUMh7j7gWfLTIHxJABDAiEAoNxwPHUXTAX3H3xggtdWqBwcXtRG\nx8bfL0quyiDcMvU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaxNZJRSRAgELNHyecgzZdQYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZWUwNDRiNS1hOWFhLTRhMGMtODI5ZS1mZDhmMjQ2OTcyNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQs+CJgqenfAlAjGCsFvbfDT/gywRdJuRhwW39t+veM2oaf\ncYRKfERZd78goBLSooXgDE44FfSp5JLWzGrFhSFro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa27aJUBVfNW3DCONRnCnuWL6\nP3EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALiFE5rCNtznVDU/3ch6Sffb11Xtu1jd66VQnXn/uFD+AiEA5Fs6TBl0\nE0JyHo4Sj0kP0a08m9LcQut2zR3VbS9YMkA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQiua4V6kKY9qsykI2/P0DkFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzYyNjMyNDQtNTBkMi00ZThmLWFmMmItOTE5NWZmZTU3ZmUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OGMzYTU3ZS02ZTll\nLTRlZmUtYTg1YS0wZjkxZTYzMjg4ZjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARlvxZACVjLxjGxRAvYjM/tmv4nBKDC4xLhn8vpH4+ttLaV7rd7vB/6FRUYsHrN\nbbJvuC+9xhr9m3JWhAY/v52Mo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0uldToI1j3QVj\nu5T/84ePBt+ltzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBlwmnIvto9rh6A16ZeqyM8teB7E6eTSbLBqeU3arDndgIh\nAOB7M7HEnkWdWqiU92Kwno+3W0rVIwW1mV3XQbqKRJsJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3349", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3349` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAXBN+x6IFV+VAanr7leUp0Y9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjY2Q1MDNjLWI2ZmQtNDliZC04MjZmLTY2ZTgwMWRkZjRiMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlmOGZkY2ItNWYw\nYy00NTg5LWEwZGEtYzIyMmY3YjU1MjBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhV4z5nt6OE42hQcF9LqtJshLpSQpWCA1qw44KxjepDklXcMVGUDr9+W3DCNZ\nURi7kSKhZ6Vh4WO+qxRY67DVEqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4icK0Qq2cOnBvNYiNo3BCmk9UAkwHwYDVR0j\nBBgwFoAUIEiVkERvNQyLbWt6AyH7CIoVdzwwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCf6eVhSEhc\nFEmRtv2LeFX7FvfAYjqBm059E1G7jgf6BgIhAOutYemv+ldlHqRbmx3pv1YwZg0t\nt1Xe5t82/ftJy7rl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX9Y8Il+iByM+mBFdE7Us4niMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2NkNTAzYy1iNmZkLTQ5YmQtODI2Zi02NmU4MDFkZGY0YjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb7ViaYiEEmpCP2Z8WjzhL115Tej3OK908A+tQ7crRDlMb\na8fLMYD7YSFiP5xgpoZI38HYhPHNikRG9MJFnT7Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIEiVkERvNQyLbWt6AyH7CIoV\ndzwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMPoe7hadZXssi/MDxZYQkm4p/g29zERh9bTeRcEJ1AWAiBWDXXPRSNF\nD2ar7Zk6qFsv4snN6Kp9NpxdgbfeYoRV+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAUL/cqpEgJ1dPHqqFlH4LJ0MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlmOGZkY2ItNWYwYy00NTg5LWEwZGEtYzIyMmY3YjU1MjBjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYjFiMWFkOC0wMjNk\nLTQ0Y2QtYWE3OS00MjI2MWM4NDU4Y2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATbkZfxtkw5s07Rbzy/NwX8qsYQG4pw94ssV6q+kXSP610H3a4wMtRremXkxyyI\nHBAdwSQBRfbtAFFa/rfWc5UWo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTiJwrRCrZw6cG8\n1iI2jcEKaT1QCTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA6EA1Q8sQFLvAQEjXzywJIbqf/cLkZlf6bQOfIylsAlAC\nIQDcToH/ARcu8wex0C60WBOCTOdSageoB9mqM98NVPlTuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3350", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3350` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcpQWTtMOxISA3brQ0DX77JrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiZDkyMjk4LWJhN2EtNDFiNi04Yzg2LTI4ZmFkMTU2NDU1NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIxNjcwOTYtYjU5\nYS00YjI3LTkyM2ItOTY1MTZkNWZkNzk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJvY6JsoLWTmsUsajO0/Iy1hdOrbNnZ8BqPn/uXPrmLEfkliXpM4qStfL5ehd\ncVRgKAjCphfi4wPOv9jGtFr52KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7FJvVusck6VCmlST78c92/IBpAIwHwYDVR0j\nBBgwFoAUqyeUr06wr1cw3bidtNZThXZNpH0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFrvYWlaUBHWqfdcV9o/LN7tkIBzyu7Dxk/17I+FpLaYAiEAkcSFKuHfYzH+\njGSswYB1YHvgd36N/ZZ2bZFKwu0Cyp4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATzHhA/RE62YEBU94pL8VTOEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmQ5MjI5OC1iYTdhLTQxYjYtOGM4Ni0yOGZhZDE1NjQ1NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlF6ZfuJDxCeMYnlPSwJ2vvh4v3mMbBTROx/tkn+oWFXrY\np8gGaCDnjMTCmkgHVRpxKYH7/gVQKXkLPAEJXogmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqyeUr06wr1cw3bidtNZThXZN\npH0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRiT8PiBW5UcrlgmIMG7/i8IRaxjsyckWSQTiPwqdmiMCIHwsKSdc6JXd\nawjAGM8L6qmuDFBTjr1THcv9Gkbz7lLO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATpIe77ed1p5mc2WH0ze3g4LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIxNjcwOTYtYjU5YS00YjI3LTkyM2ItOTY1MTZkNWZkNzk5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhODZmZjliZS1hZmRk\nLTQ3MjEtYTg4OC01ZmMzMzA0OTlkYTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR8nw3Q4Vq3MkP7NRkNhMjtx3IgK6cqES24sHeuco3CT2a+JKL7mElvrvSSQcby\n77YnKhJesl6INqkEPT8bc17do3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTsUm9W6xyTpUKa\nVJPvxz3b8gGkAjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAl+b2fuRWKgu0VXCoQyqqSKFtnWsro6XJiXyNvQ3jjKUC\nIQCjScTMa2GHlS79UkBTIyi6i4Hq5r1jwv3VsVeQ/lG26w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3351", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3351` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaLV3+8R+uAb/ZSPO1dA4yGOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3YWFiMjc1LTY4ZDctNDRkMy1hNGUwLWMxZGNiNTAzYzg3NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVlZWZkOWItMjc5\nOC00MDBjLTgzNjUtZmMwYmEyYzFlOThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7/YrWux7VofMhylB8xkXsLnlSthJtPK+WEXKOd/Lz6Vjb7MOmvMF9ymdEF0m\nmSkoFjRkJKTZlowIFJWCkmKOu6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmWXDfW18SA9CZ4PLauVRzsUo4IcwHwYDVR0j\nBBgwFoAUxmmzJmQe4tUkFBo5g6Mo1KjzPC8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCf4MbeKxqyhT9z1YNowRep68Tp+fTyryVDvcC7UpQObQIgR6w5vW1UeNQ1\n21OuFrsvsOjm2OEkbfOThHUbHUpT2pI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZSJX+UvCJDbEqo1EiGU6LSgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2FhYjI3NS02OGQ3LTQ0ZDMtYTRlMC1jMWRjYjUwM2M4NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZEOiQNcFaKpjVXjaN2xOMVJEzHuQ7QtWNfbpTCJuM+L+U\nY8ULaJqXhg+zp482kgntC9tyPmTrfLtfq7pmygtUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxmmzJmQe4tUkFBo5g6Mo1Kjz\nPC8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG2xl6RQqP8CAqwe7H7eeq+lWJK9TX3AD/iDd7WM9aEUCID3dp0zIVzYu\nk2iuotY8wXnW89R1KZiJBh1/TvAVxo3S\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAS8wFFD5k4cWkE60uA6wNrxxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVlZWZkOWItMjc5OC00MDBjLTgzNjUtZmMwYmEyYzFlOThmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZjBkMGUwNy0wNTZj\nLTRjMDUtODRjOC1kOGJjNmQ4ZmJkY2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQaSbnfpe/ZQ+cyputAiTRIDR8or8F6WkiwhH6I/PuUOsOsNWuswq6h8FeyRcDN\nP5VfSKFUFSgbWBqo29L9j0Lmo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZZcN9bXxID0Jn\ng8tq5VHOxSjghzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAczaw0dA2C/IBRl9GnpnRwdyEdOSRovpmdTwlWeuQI0QIg\nAcpOm+Z1DdP+CMlCz+2xmf7SnhJvrPfMDBZLkcm4JXQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3352", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3352` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAeuiuFcbJLkA60ecJ/HxnsudMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MmQ5YmRlLTc3ZDAtNDhjMy04NTFhLWE0OWZmOGY3MGYyZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRiNTExOGEtNTBm\nNi00NTY0LTgxMWQtMGUzMjYxOWVjZjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVVmOHSvqOgPwta50fVIsH0z5xh6W3Aj0hQ8oF75vCkUazboyPsWEoH42rq7g\nnxVvoV1nlI1GA/pWSb3/cQqdCqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN6upaRisvZXbcFlhEQrVOILUw/UwHwYDVR0j\nBBgwFoAUGKJ30hlhUnmlAfsu6SqTO2ds8EYwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDgT\n6aozQKrSiAyHc6p8806OnpESrHzgn5fCKtJU4sKwAiBWtQOTpyzEOvdPZ0o+Vnax\n3yPcO+seLpf0G41S+ofCuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATayq2+BqXdvOHy9OwVR59RxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTJkOWJkZS03N2QwLTQ4YzMtODUxYS1hNDlmZjhmNzBmMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV7DZRrldfdeUxqHNtzPCAdQTcJ2/pGx1fyjPVuMHgL7ex\nR6h4gn+tp/Tu6d7HrZzA7ZnqX6dcB0xlKnArjTZTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGKJ30hlhUnmlAfsu6SqTO2ds\n8EYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL2U2I8wbFLGujDSoBuuWVWqT26OdXyHf79vYF8B/M5tAiEAg6La1cFn\ncn6pp+lJh2RPXUaS8+B9I72ntCmE+RY21Z0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAdPqqNwy5KSGiGrQsuZMKsYFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRiNTExOGEtNTBmNi00NTY0LTgxMWQtMGUzMjYxOWVjZjYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYjliNjhlMi02OTE2\nLTQxMWYtYmIzZS0wOTc4YTg0M2E5ODIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARIYFRxzITkHaZMZ2vixhNQipvFnvvWivVzH+Om4KBlDdSaJldd6XXsZDXkZZ7x\nJQLF/p8Ctp3y4785rCQ6BUv9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3q6lpGKy9ldtw\nWWERCtU4gtTD9TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAy5PXJDAbtL4Q0Q5H9c7qINJswrHa46sw7hnVyjbZOPoC\nIQDlBWW92Jl0XfvzZ1vFs0NULZiPQyGfpPiAWYLhUQN5ew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3353", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3353` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAfpIjM8tevcrGeKWxKfIwDV+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0YjAxZGE1LTY3NjEtNGY2NC05YTkyLWVmOGM1MTlmOGI4MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTlhMDZiOWEtMDA0\nZC00N2JmLTgwYjctYzc4ZDI1YTFlZDM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVsVr5d8H2jfp7Fa8e2rkeEgunparvcH3Gzdbu7oB8rJYxI5E80GDOpnLnlVA\nF4B3iceaDbpKE98+i7bemVS3lqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULnH1RRcqc6vyRzaoE+OddudeUgAwHwYDVR0j\nBBgwFoAUKsjCyNwq9rCIfnAZiD1zXdP7jxMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQC0QIq9Xi93H5j+H6KCdko2zT8DuD2C7fC2Qtzn1U+nAgIgPFHd\nkSf08oHZ7mWJHJYfK6MbMfnAdquDCDHshcXtsRI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARdEZJchnOPsrqfw62uai9H6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGIwMWRhNS02NzYxLTRmNjQtOWE5Mi1lZjhjNTE5ZjhiODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNu9aGTKwITG9eHy2l7j8p1BRSycyDMTkTDTA31UXmDmR5\nw39uXgCSBn9tB0KclOhrKG63NvDURgYuNvDX0vBZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKsjCyNwq9rCIfnAZiD1zXdP7\njxMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW2n+CkUn1a5L6yXYqJ+1CQlWCAEzw0UUS0XxkMKp1ycCIQCRtRHO5VH0\ntL4ds7GFLsh1IHer511Q9oEsqrrx1E/img==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYlluGph7qIlxNUexZ8MSI16MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTlhMDZiOWEtMDA0ZC00N2JmLTgwYjctYzc4ZDI1YTFlZDM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YmUwYTgxNi0yYjcw\nLTRhNjAtOTc1My05NmZmZTRjZTFmZmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATvSkAdLVlay4a+F0cwMV9aPnF8uyeQTIu5M1SthfrIZxAkIZGhjktfwhIuNGJO\nN9uqaKEe2YzkFalUopsaEoYoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQucfVFFypzq/JH\nNqgT4512515SADAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA7pbVp7EBkEVmlLL+bDzlZt9wTn99At4Iu+k5fFN+IEIC\nIHQPxdpLWwtRfJT15VtU34IwUetVpbV05JUWdHh7lrhx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3354", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3354` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAX2d8vZdjnpGeB1B/D/my7i1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhOGFhOTBiLTViZTUtNGY3Ni04NTIyLWViNGEyMmNmMTY0NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkwMDkxMDUtMTc5\nZi00Njk2LTkxODYtNWE1YzkzZjBlZDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAC16Ov0r6dDDWOEG35cKzoaaoGk/gHnsTis3C3smN2/qm7If0eNfv45fhkD+\npmkIgA2UrIW+xBHx+nF2eFV1fqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsvGsj9n0l1CUtgY2KEy+XbxxSdQwHwYDVR0j\nBBgwFoAUYYRaapv3yvtXIa8RG9DjS+zDAz8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIC1ZpnMXAPrfqcov8dyTQ2vLoWOKqANNoEswcFYAlxx0AiEAtXBE\nb6T33HrpggvTM6V5mV9FLBZm9eMn9qTauyTLGqM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWUk5qXGRDxlhToc1Z6283t7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYThhYTkwYi01YmU1LTRmNzYtODUyMi1lYjRhMjJjZjE2NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP/Ibja5Kbutho8z/54ebwCGgILLCwiN+BQ5hbpSdVVQRa\nN9nrZ23cT9n8T5UPGWHcbtQwOl4sTvwfVZ03+0coo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYYRaapv3yvtXIa8RG9DjS+zD\nAz8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKrXYu9kUfJBuB2mChtalJUOtM+/LbT2APgoSWwE6SsICIQCBYsF7cQx+\nfln5qvBQ/YL0as/OIDyx4OK4F+7pVkkJKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfajGxdSM8IQYQI3y11E0ojrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkwMDkxMDUtMTc5Zi00Njk2LTkxODYtNWE1YzkzZjBlZDcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwOWQ0YTgyZC1hZjY2\nLTRhYTctOTg4ZS1lMzlmNDdmMzJjYzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR5G/W1oyqozaFSKW8/nkWEv+TprSvmHY2vjt/AlP1+ZhWpdhI+uEGcQQovEYSn\ndhh8Jzs/VKo6zNYOn1N2l15Ro3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSy8ayP2fSXUJS2\nBjYoTL5dvHFJ1DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA1t4QT9voMRlCHyh32zf9IALKOOFf9QFJuj/QYxjDLjkC\nIEXoJC5bGXIN5LJgQcOJlSGl0wFEWOl/ICU1U+71OHLi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3355", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3355` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbOrjrmtaqjlGTv3r9eCWO3QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMjAxNGVkLTQ5N2YtNDYwZi05MTUxLWY1MGY5NzZmOTE2ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZmYzQzNzctYTI1\nOS00NTA2LTllMDAtMDQ1Y2RkZWE0MWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbJmDZcz//scMfTLUVnJ22M3xzLwuXy06aYUge4O7I/FTonBTOHLQOK0oq3ZC\nuBp2LZk9herWCAde9RZqrqLWcKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSH9C/Qjb/wqL9ddGDMwucj+lNEezAfBgNVHSME\nGDAWgBTnMx8QbfLjAFwfHgjsVCAbA8cywTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCWUHhWodoyIWBurGDT41EDPm7kaOnP\nNKaaIqpIhgCibgIhALgq7eVuALmyRZxEP+ly5fkXrILXmsnlpSxS+5TB6Sks\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWxMA34yqJ4Vh8TbQEZFybgaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTIwMTRlZC00OTdmLTQ2MGYtOTE1MS1mNTBmOTc2ZjkxNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9xWenrF/I+EvNVG4rRDtVuPvZutj+5L2ABnoHgIBf9Y3a\nJauOP05nFtUZVEdD3+IHva7fnKSTLzNYQpAAPDL0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5zMfEG3y4wBcHx4I7FQgGwPH\nMsEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWgCZsuAduaL9tibNizXXY46H2npgUEQkR/UN34hbzm0CIAifPOYRIGVv\nnApz9zeR73VIvVDjgKbKx9yz4oc/Mljr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAb2uS761iUYKPXBJpnQAgzXKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZmYzQzNzctYTI1OS00NTA2LTllMDAtMDQ1Y2RkZWE0MWI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZTBiZTllOC0zZTQ3\nLTRkMTctYjI0ZC04NjI5ZjZhNDQ2NTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASI1d4TTxJIrYpGu7gSNniQ0ZgoEbs+NRl6IjbdexD5O9SHNgUw3Owv52lts/se\nKimXLgrcs1wR8HNCrIxUosT0o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSH9C/Qjb/wqL9d\ndGDMwucj+lNEezAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAsxxaI195vfnapfxhH8BwuyV58yk9B1jQhY03dIzZTh8C\nIQCSSw1/lqGo1tG8wfQqwPUh32W7sjKps3vKvHBYa1sHNQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3356", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3356` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAffFqhLmc8P/kFYwPmYaCUUBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MzU3NWQ4LWUwMzQtNDM0OC04Mzc3LWI3NzgxYzRhYmFjYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNiOTY5YjgtZDZh\nMi00ZmRjLWE5N2ItZGQ0MzlkY2FmNWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQxG7oDJIeS2tcMz+ZhE43V9qtf1OXhTcWoWiuD0aiP+ko4aJcL0nZE3n17oG\nxnkX7s4ksUHr8CJmuHS2a8C7JKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAuNg17tUVJsssEBfs3mNW4FC+3IwHwYDVR0j\nBBgwFoAUvA6TNMA6fqBqNxAGoHlxb8Qi0h0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBEb6kNcdq5j\npx502+5ovT6R8/M0llvUxScDF+I2Z1Z+AiBJOkCpmJziGAnRBb8VPtWdi347gW5x\n0+h6WfEjtA/+jw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVnySHR//mdBnUqL9pyyMQX3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDM1NzVkOC1lMDM0LTQzNDgtODM3Ny1iNzc4MWM0YWJhY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfjAO0a+cOL0+ozy140jNiZV26EINLi6AgmZdM/NCG/3Qp\nrFK1eMV8igfIrYghLdyi6qnxsE3VE5bN/euMs7ALo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvA6TNMA6fqBqNxAGoHlxb8Qi\n0h0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOL5bdylC0apt/qM1tiFfk2wlLYsFMbN2oq/YXrMooMMCIQCJrGwDA9Hd\nVzA3ctZpigEQMrwhfiJA/eiJNqTNjX3Hvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbECI+AijA0IiRhzCg2nKEhYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNiOTY5YjgtZDZhMi00ZmRjLWE5N2ItZGQ0MzlkY2FmNWI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYjk5Mjk1My05MmI2\nLTQ4MzctYjA0Yi01MzExYzZiM2Y5N2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATB6cXqyzhhkzVEe0Eg387Bzxn9n6p+7SKK1oFhdANXiZLJxeunIJiXb25ACVa8\nMbCG3s+Gngs7SUsZWHA0c5/0o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQC42DXu1RUmyyw\nQF+zeY1bgUL7cjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBwDaKWrk4HcCSEYjqlu9e3tF9ZzCVH1GFD+Fw27fSorAIh\nAK+q/UruYANpwGWnU1Va1AQ2ZCk2BBxcmgSKRvK0b2Te\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3357", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3357` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASf4mG44Ts4+VjcnsJ6TGKQgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMjcwNzIzLTYxZWUtNDNlMy04NjA5LWViYzYwYzM3MzY0YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA3YzJmMjUtNGVl\nZi00YzgzLTkwMDEtZTU4YWNiMmExNTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3o29pATVWWNhupIa6mlyRe169iAoD1F7eb5Eo1e+f4p3gqkfPHsqXtbHMyrB\n9FQAVQlCvyr1CC3vibsy/RmeMaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNP3CLEGfOPDkCimezxhQhtQDB6UwHwYDVR0j\nBBgwFoAUtDdU7UY2oolcUGlqDp7bpfKOsXUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCL3ubw9ydy\nEx3GlS01DS/OG5GuzH1uGiDJM2DOzKn9KgIgbvj3SeXBuLI4xMnElQxbTM6wT9IS\nQh+s0a9zdiM7HYo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdhnFdQ6WjqJyf97WlXdIQKHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzI3MDcyMy02MWVlLTQzZTMtODYwOS1lYmM2MGMzNzM2NGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6UoinmM8cX4fz+GjKwbOPua/1CuBQ6BmNYmdKFOiiPbdv\nFy6ysU8luXZLxMlOHmi/0xKvrfDUz/OhHsxEJ/hGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtDdU7UY2oolcUGlqDp7bpfKO\nsXUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNtCKjSXcWYklcx2ELiiY9Aka+6iDZ8TEPf4qJSNKSWMCIQDIm06bo7S8\nuCkTo5jleCK+Wbj8U7CbmMJ43izqCuzADw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAS6kcoR8TVNIc8fEc9uEfsdvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA3YzJmMjUtNGVlZi00YzgzLTkwMDEtZTU4YWNiMmExNTliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZGI4ZjRkYi02MjRk\nLTRkMDktYTZiOC0wMjE3OTJhNDE3YjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT/p9gWYBZzpoYVz/DZeBoIjzmF8rssPkaKDyFN+XVBGrknDAYOGbegT/PcI/sS\nYpgIy+MLA/kBy954msQIwo53o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ0/cIsQZ848OQK\nKZ7PGFCG1AMHpTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBsbn5tLGbC2rZyTda7g+otakSFURSCuUiJ48M9ALuVXQIh\nAPdqgMB/+kJ1vd7wqnIWoGz/vG3tqibdOUUZziJcrWjC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3358", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3358` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAV4hkGODhdsQeZLCvvpKkXCHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ZjQzOTQ1LTI4YjMtNGNiMS04ZjJiLWM5NTc4NzM5ZWFjYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNhOTY0NDEtNjA0\nMi00YTg5LTljMjYtNWI4MjJlYTQzYTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEakdAmV+Um3uKfMEMA7X665qgZh70I4hqovWAkgxFcUuOEuWHtbhLiNpNF6HS\njNjzVDvYwrlYj98L+uyXlV3ROKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN0JTfQgbrJNXtI0UJywEushRMsswHwYDVR0j\nBBgwFoAUMtLZYQnzltIsikTvRSoTl+IIFl8wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA+57ZweLq\nRNyZtfbwC+MXoAh/KMC2aBoJPXei0N0HmMECIB8U7RkXRyKWa01wva2whncOXB9n\nzLdDB+HoO59+OEgB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbuHxnlTkYxqBCVTWBtacoGgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWY0Mzk0NS0yOGIzLTRjYjEtOGYyYi1jOTU3ODczOWVhY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgWxBr9/fHGkK+MjW0GOakftKYCiJFHeV2yW8ZAqGMh/L6\ns8Z08cMGlEB58AP7N1YINdPwkHgo2bOKi52udn2Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMtLZYQnzltIsikTvRSoTl+II\nFl8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHfhJ9xpoMV/3qvkZX46F+vP4uZ15KQzAZWZv6kDVZlECIQDDv4QQv2rk\npl9uqfECOoHiflDrkK2g+MIqY1YVoDP36A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdC0ceCxJNA8enK24sMrU9z8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNhOTY0NDEtNjA0Mi00YTg5LTljMjYtNWI4MjJlYTQzYTM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhOTgyNTQzYi0xMTI4\nLTRkNjYtOTFkYy0zZjEyZGY1MWFlYzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARMMTWa4iwjCmk5X/MPBJeB4w0LdXAWOGl9avd/NcbchdbvGY0KD/aMnRWtFP+T\nVADEcdQaD9wUgUw6LXG2iiXho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3QlN9CBusk1e0\njRQnLAS6yFEyyzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBopXduvO3+DNw9yPaoCev9tPoZUkxVd09vUOM8PDP6JgIh\nAJUkQlNaK3l7hSo85zyFip2f+XYJnK8Iq3Nw3IOOqSiL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3359", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3359` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISASbSkbIzPJDVARve1fNGVOA1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YTdlN2IzLTNkNTQtNDM3ZC1iZDNkLTc3YWQzNGIzNTI0MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBiYzE3ZTMtYzEx\nMy00ODZlLThiZjItYjNmODk0NDc3YjgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyfNda6IoZ3pFP+zom7um2U6GYoXpaVHJxkIeWpJs/auaMHV/JAcnvQD2ofV3\nqh+4xZi6QKXDgilShSWhixCtBaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvHksnuUyP41pDch3OM0B07ZYprkwHwYDVR0j\nBBgwFoAUwcjLCQlzrw10SX9VDY8cEqwSFrwwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiALRpUyKw1tp0g2a99EYZUA/xeylnxm1p78pCQlcxdocAIgBk9CixpBMJSJ\nt5bMvAidZ4IUbxVnsOoXBCsp5Bq8Ez0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcnGZaIK7EWM8eqm+N4Z7ceAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2E3ZTdiMy0zZDU0LTQzN2QtYmQzZC03N2FkMzRiMzUyNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARu1CBdukeTtJUTMN7D1QubJDSZelHCG/XRUlL9g4mSppDY\no2EMPB05u1NwvCsDcfY+S/sUEo+dFLob3naw7wc0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwcjLCQlzrw10SX9VDY8cEqwS\nFrwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFMWf9a5xwjF0DdbvT12/N5Coso0dwkhJKGSfwrC3GvcCIHJuivzLTd1d\nh9eT7e85AIYBjudIRvYxIWUxEX2ltb/S\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQlnKfoghLjqaBhSRgniVZ8zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBiYzE3ZTMtYzExMy00ODZlLThiZjItYjNmODk0NDc3YjgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNjYwNmRmZS02Zjg2\nLTQ2ZDUtOGYxNy1lZmRjYTc1YjZmMjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARKftCbwZqpXbZ1J9LazjunHVR6ivFAaRHKRI2tC83q8cCn8BkCnH0w5DwiWNWP\nnb0DBJsT4UfHvSa5OQe4C5gxo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8eSye5TI/jWkN\nyHc4zQHTtlimuTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEApv225T4fk7ICE06aG3nSaAyT1mFB60z7IAx2pgj66YYC\nIQCo/Mz02hGxtNObHCirontB8aw0jOxURcXjJRsGi/sLOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3360", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3360` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZMhMXHYdFSTaJH2Bb4YtOu2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhZGM0MjI5LTA1NDYtNDM0Ni04ZTRlLTY0NDM0NmVjODNkNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U2MTgzNTktYTQ4\nYS00NTMyLTlmYmQtNGIyN2I5ZmY0MTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ7IqOwoot+y4bAN68ZB5zZtFH9ut1fNLRQ2Ms1OccaFtUtUQclEeyZ3pBWjH\nP3u4LE+ixS8vmargB6ZRDxcwpaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZBSnX3bHNptmBLsHk7Es05MLbsswHwYDVR0j\nBBgwFoAUyzLoWmtfV+ZUqZJpnsLjcoC2F7IwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAwSw2XElaTfy8/OMRglQ9yR9q/Ot5r2lSMjmFVnWxrbsCIEb9OY5s6472\nx9DN2IKzvklZg4mLLmNXPeHFIrShafpJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAckUrKqXOU83py5ywg0nSuZrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWRjNDIyOS0wNTQ2LTQzNDYtOGU0ZS02NDQzNDZlYzgzZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/8r+NOh+Tu841RCKVMfHDMTtSo20TZRt0EF2L8ujoGNid\nt3sKazDnB7kntQt5rIDqJ9Zbk56AkNxnhfbULDyGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyzLoWmtfV+ZUqZJpnsLjcoC2\nF7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK2t3oWWiEWSQx0uQIwDPd3VfZ7qgWUk2+dMk0wSy+f4AiApE3eIgvwm\nM4ukn2jSmg3pSMX7ODJFEegfr5JEKuNYcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASp0wBU/GXWUil2fmtGI+JvKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U2MTgzNTktYTQ4YS00NTMyLTlmYmQtNGIyN2I5ZmY0MTNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MDgxY2VmNS04Mzg2\nLTQ0ZDYtOWUwYi03NzVmNTdhZmIzYjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAST3mmrk+B0cdPvEWZTyUzubFLMNZXVL4DhNXaNe5BNccp8GOLEp3TD3kQMCiA0\nngZHFQP6Tus8QwdjMaDwIWVZo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRkFKdfdsc2m2YE\nuweTsSzTkwtuyzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiB9Zw6ggwXz/N/uu3dzYfIypBMwpqyAvqHNsPxcC9HqvgIh\nAI262nX+MRaEXJqHmGKeGKvPGZbUvpxm1ZiyCh5SXckC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3361", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3361` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAXy/i7qeAVaWBv4zK0A7R+pdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5ZTRmYjg4LTFhYmItNGMwNC1iZmE5LTRlMWNlNzgxNzc3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNlMGQxNzktN2M1\nNy00N2I3LTgwYmUtN2JmYjIwYjZkMmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAWR8EEONJciUna1l/AWoC3rtmOz59CAuVlZCRii5cycNXlTTK4sMTfN/Flu9\nyAsDoKOEJQioo64yGAR6vwz0UqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Lx1+Twg9maOcUxWX7kaC0hBUpMwHwYDVR0j\nBBgwFoAUdfLUzHrSuOC2v/Lu+ZgbtNseDTAwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAF\nrPbUVWDskdggbepb65QWdeQDU9W4Ve+VK/V5lKqGyQIhAI7k6LuIp/2PYTQVOOBA\nqoAu7L0bxNCb6geG5ck8igNp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARlMlL8KGDdJjyE+V9a0zEb8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOWU0ZmI4OC0xYWJiLTRjMDQtYmZhOS00ZTFjZTc4MTc3NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJFkXJCxhDoGP+Oyu/PGFTpe9Nz/PniPbe3DdNcBijMoKp\niDm2FumqFP5PDReP2DZPRYvIiCwTlRbCXO+3gGXYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdfLUzHrSuOC2v/Lu+ZgbtNse\nDTAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO+j7CQ4vqFhpBQfoMq0JokNCevCY+Tp+1vga5ka+UbZAiEAmqyWuqrt\nsXGhLGT+qPpbjrCdsE3B2EBK4+p9U43JxaA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASZsNs7vXSsntl/gZcPmQaGIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNlMGQxNzktN2M1Ny00N2I3LTgwYmUtN2JmYjIwYjZkMmY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZDliZDVkYi01NjBm\nLTQ0OWQtYjFlOS0zM2FkNTdhOGZiNmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQGAcZMRhb+XqGkvb/5a7fvwjFslbqdJC6sriZo3Rlga8ZfgSSb3IywclTgMOKT\nv4wKqVVWrTp2O2fJjExUCEyho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTgvHX5PCD2Zo5x\nTFZfuRoLSEFSkzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA2T5XtPKx5fz3yHmXWvy9TbTUr8G1HUgyZjNFgY1avXIC\nIB2d9cJZzM6ZiSWxlEMfCjcHD2eH7EQF3V8ZMrFSNok+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3362", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3362` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAQRQAZd6Quytcx1wgC6l9LIOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmMDRhNGNlLTQxMzAtNDYxNy1hMTY0LTE2ZGU5M2FhMWVlZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI0YTM2NmItNGU0\nZC00ZGY0LWFlZTctYzNmOWI0MWU4OGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJkF8mJS0YDMr0NsgYk8fGB1YBObRRQfHuo2C1YA3aYUTyxjE7pDam2YDnzxE\nsxLAnn4jkvRpdq8AvFC26ibclKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfytptfHYvqvu/jn4XZxQ0kUTQNUwHwYDVR0j\nBBgwFoAU7lgCO/b0o0fYzLr8UR3fDXQGJTMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEArEYwJXN/YWWheip3CYpc+T5pWuvGJZGFStXjTw9kNToCIQCd\nRrB+3abeeV1zxrijNVqv7RS/8hToJSczDTLP0kbrOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATBeoIzkru/kR7SxZoThnG0RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjA0YTRjZS00MTMwLTQ2MTctYTE2NC0xNmRlOTNhYTFlZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQa0L0u+zG4518yXwLS1w/46f7bZ7SF8yoAloYV0OhMGF3q\n+HrUpO8MkaVjIbxCLt4UF7OjmED5fzB/65s+CRYmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7lgCO/b0o0fYzLr8UR3fDXQG\nJTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCC9rbxua/mWJz6fssZ0ynpHeHOT/q3sY9VwMUZqw5fACIHe4X4J3+OGV\nXcbggMEECGRPK81NQBqrlsJi3QlHDed7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAdgpWhvuRxH9esrORw2gJTToMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI0YTM2NmItNGU0ZC00ZGY0LWFlZTctYzNmOWI0MWU4OGM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZjc2ZTFjYi0yZDEy\nLTQ4YjItOWUwMy0yZGRhODAyN2YxN2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASMb6+rme+4WkXQcKA8cEw7+qr7zbBVmFhJBZ4W3jVqoNa+pkd7CkCMQNXjIEAy\nboKJ7tEjCPLeJ6bronx2wyaao3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/K2m18di+q+7+\nOfhdnFDSRRNA1TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA94OFLL42uZzVOi1SfadIbojBAm1vuYMbX65DakjJE6cC\nIQCiHSzNr3ZZPy/YUzJnqxJIsrS9FvnkC2iPMDD/WOc/gQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3363", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3363` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZj6sIc21298dvuWyj3FOAwYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkNmZhNmQ1LTc5OTYtNDRhMC04MTYxLWE3MjMzNjllYWJjOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI1NmY1OWUtMDBm\nNi00MDVlLThjYjktNDlmYWE4ZjFhYTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ZMHrOcSIdf+lM/R6J2lOMW127kxWRigUWHf/czj4tRU7WgszNG9Ne8wXd5D\n5qEgz7xvbNzMemTAusQ/i1GP76OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhl+l7unPjZNoGmk8se0xwJTtHbkwHwYDVR0j\nBBgwFoAU5mHr5rMSLlR6o7qITyHbV85K4Y4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAn6wsNQyfWgPK3IuLj20kQVwvqc2czxuvqtyYtBG0UwMCIBO6\nlD3QzxS/pGWf4XCzUknskvIvn6MGjoWOWpiVCRsy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5y2cfgeR/wRNRyS5EJAUhJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDZmYTZkNS03OTk2LTQ0YTAtODE2MS1hNzIzMzY5ZWFiYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxhDAP7IZYoSLX/4G/1jEU+A1wjLf2xHnH/FnDIr6Orwur\n0VSYxLVmiIeycpYZADaB3mn7fzDDMwYv4/Xv3Y8Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5mHr5rMSLlR6o7qITyHbV85K\n4Y4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJAqrLuoYRlg01BAGPc8Jea8TkSmPDoffDa4KDsV7l2sAiAcTrjFKK3n\nM3EbT1jk+UBrRgu35aC5FgyIw4qPTHHx0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAW0kE32P2zYo4h/I+sex6N9QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI1NmY1OWUtMDBmNi00MDVlLThjYjktNDlmYWE4ZjFhYTkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNTYxMzU3Yi0wY2Nj\nLTQ4NDItOWIxOC05Y2Q0NWQwODk0NzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASD9oVf7tjscHAGwYdIvQ7DdfPzeZPSlsEXxtKqhex9Sj3Z3kYMGLWudEeCyzIO\n2els3gnPwudPEwhKEzwnobG6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSGX6Xu6c+Nk2ga\naTyx7THAlO0duTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA4C2IgUfdBSyhgp7u5LeTjnbR5pGvAt4vYQt0RykWyS4C\nIE6ck38YOWlJKoOGOM2IUJiiRilu/PCVmTwGuIc2gQXm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3364", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3364` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAeDGr9M4aidXkRkr95BqDWT6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhNDE3YjdmLTJmZDAtNGM5MC05MWQzLTU2MTkyZDc1MGRlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQyMWI3OTQtODNi\nYS00YmRiLWEyMzQtMzA5ODExZDk3ZTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC8Jpj3S/MDaN4A0gcNcOkT0frio36cNfZqMZkuZdLMsRxgnULhBjc3ZmngBR\niSdM4UwZhjDrixJds80M3TtrB6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUySqvOBZm7Rt/cyQNEBeFGoFQwmIwHwYDVR0j\nBBgwFoAU5HEFSYdZvY0j3Yqmc3OQc1Lbv9wwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAm1DmSjuYf+mf\ntvGswENcefId7AR9nzvjCZjx/MGlNHUCIQC3OJ5K/tbOVkvACSyRgymAqxmIoRZg\n1SsmJJ8oKVf3bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT0M7CsrUsIsZAn+4Q2pZqIcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTQxN2I3Zi0yZmQwLTRjOTAtOTFkMy01NjE5MmQ3NTBkZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpSx3pV+3LHGO5HoXnpQgx3WEy778UwUFJ2S+JifLuXa+b\nMvi+yZ2W1n9h2hXZYwe2dcH/tBxiGmnDtZcxBxbso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5HEFSYdZvY0j3Yqmc3OQc1Lb\nv9wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMnUuH1DgJLN8XP5Ff2p5u3ZhnaHH3QpvKP8WkVzaGRDAiB1NH32ZwOa\nTknv0A+kMskmg6368IPhvNR51W9f9rqX/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAevP/ZhG3PBNEv5FNXQ2PBXCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQyMWI3OTQtODNiYS00YmRiLWEyMzQtMzA5ODExZDk3ZTg4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiY2U5NDE1Zi0yMDMy\nLTQwNzYtODI3Yy0zZTdjMDcxMjBiYWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASBTHmBAc+jYV7WlehiIncS8XWJ7Lt6JiEGQZOqTHMxvcIUS2F1sD9ON3KphHYP\nMn8ukpFF3rUtcJ3bB4si96REo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTJKq84FmbtG39z\nJA0QF4UagVDCYjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBn3UwELTBb++Y35A86f9UmSHZqzLUHzewUYHNfdVLpWQIh\nAN1OTgTjSfxv8qewJof6V/Rnw504wqLCxmu4zeGwvCzr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3365", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3365` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbsd+1Pxt2dfAQHyB7UpbnzJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYWI0YTI0LWNjN2YtNDJmZC1iYTk5LTkxN2Y4YmQ0MzdmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk3ZDM0YjYtMmMw\nMy00OGU5LWE0MjgtZTNhNjFhZjYxNThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE24lHeURkRkIfwyGNIBS9WuBabo8gC3FJNU+vHidlHuy4PIDBbRW+M9VKqZom\nUU07odu2fs6DOOeCleCU5NEOT6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ajWdk3M5NMLTkbinZsdM6a175QwHwYDVR0j\nBBgwFoAU5HRb5raJ8XSnWVbSnMurk9nUf0owNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDL/DDuFFhDL/NOV2Z4Bq6DmhL9d3D3S1V4Gm+HaduHuAIhAN5o1GBHXda6\nQcKxqHm8xf6jz24G+tBmZXGCRFOYaIAu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUXGf7EzB+u/r2MaHP0LBE8GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2FiNGEyNC1jYzdmLTQyZmQtYmE5OS05MTdmOGJkNDM3ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDEInkTKZQwGH5K0pSgBC3lYksKT9VI1hOeKoZfMGfcjQF\nYr1FpFVfqlHe3OxLbxeboH84sJCK775nFfDinI5no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5HRb5raJ8XSnWVbSnMurk9nU\nf0owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPfq+bToXwnHA7hBx5cCuAWsNvJ+UBc0TYdY3uotkSR6AiEA4uXbXwNq\n2PfDCFEvqcYKOtQSiGIrdZQ7TRMQ9hWaUvU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUQQFDVyNeXWeNhFzOld9rz5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk3ZDM0YjYtMmMwMy00OGU5LWE0MjgtZTNhNjFhZjYxNThkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YTdlNGQxZC0yNDRj\nLTQzZjUtYmJjZS03ZTgxM2YyNDgxZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS8KWnsVo+D0jCqn3jl+vDFYrIeN8qu9FOjkAH1hNX7YAh8oBIFAkIzj1C7/kHc\n+CZgFQjMU5/TLDbs0pJLXoDUo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBThqNZ2Tczk0wtO\nRuKdmx0zprXvlDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAgSLG20PpGnvWBer5ob+TiA/KKbPQ6fn2E8QmaLDKQ5gC\nIFbljXnuAC+xvMf87MPd1dnSa3BeOBCmPtEVR0CMrmCv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3366", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3366` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYBZAvHEjdFFw+53UVbZxxOtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxNjQ0Y2QxLTg0YTQtNDUxMC1hYTFlLTJlMTlmMWYwMjQ4MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkyMjczNjUtMWU4\nYi00Y2ZmLWI1M2MtNDk4NjU0MzM5NWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Ey3Kx3KIX6AL8wVzjRmNsEHpxNxITpde5nR2i9s79+fPrITtxLzGSRfvo1P\nhBiz+KPvPURJwQgwjt7/M3MLXqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7tdpPf4M9gr5109UQgTzzqzlATcwHwYDVR0j\nBBgwFoAUFkiDQgUYAv/0P6fk2OBJ6BdyEr4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCZZcViBu+hKgpQsy56xBt4uvmm63uHxtj5W6tYEv1ODQIgBOMCworkE4sa\ny9JQC4jF2Ay0LFqSnns910yPrN0Kpgw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYzKSIiZRq8WzmiDCt7oM+a7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTY0NGNkMS04NGE0LTQ1MTAtYWExZS0yZTE5ZjFmMDI0ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARz0ahTSm8PhiO2w+b/hjQqUyCav0NrB03MRDhHn3Onw+6v\nIGFEPsN8fBUdVzojgJ8X9iF94ZpWXR7PbGVcpPS8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFkiDQgUYAv/0P6fk2OBJ6Bdy\nEr4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQP02rQG9SlTvaN8u7NON7MXMEEzf+Aj9zeVuEyK52nQCIA1KJt5+q2sL\nhE2+Q0fSyhuH1+hZvyWmbLnwnx+RlZJR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdQO7aO4i4Z85KI29rezFghWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkyMjczNjUtMWU4Yi00Y2ZmLWI1M2MtNDk4NjU0MzM5NWEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwODJiMmQ2Yy05ZWU4\nLTRlMTMtOTY1Mi02OTQ1MjJlMjFmM2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQof7O7MqBlRvNFau5CG3lxzaao/GZQFo1/UlJQaRWg1YP1vT0RUpjmWun2wYj5\nw/i+3onozzAuoPex0t2PMUdDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTu12k9/gz2CvnX\nT1RCBPPOrOUBNzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAqCuoqWf05H+rBCS2LUzYoU+rc6JgbLk3WGf+SbpH4SkC\nIEwGbRJDEG2S0tzrvGUHwSIFhJHqEdLOVlpY43oVCa1T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3367", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3367` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAQQe1XX+Xn5v++/CtBJBFn5HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0MGIzMDVhLTU5NGQtNDBlMy05ZWVkLTFjMzliMDVhY2JiOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWYyYTk1MGQtOTA0\nZi00NmM5LThhOWYtYTZlOGYzOGY5NDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENdKpZAvrkH+fU3p0tHFHVeu9oQ1klCJl07VPgI///3qwXbMuIVXl1bGuc5XO\nXjul+RdH0jx6JIH/x8WYQ3c1iKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSfzOPFOKMtK/UQI/DoWvJSrYhp8wHwYDVR0j\nBBgwFoAUrnZjWo9DfLtWJHhFhOKDnjxr5xMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBtdmv/5Zr72GJB5o8t1hj+AsgloaqNgw+Aqq9f0THvRQIgYstXbEP7n6Oo\nGRAPZqQtxIFiAAQInmbZZwH1RWEB5/8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfOaq3jpDh4NWZ6LTl9otCeAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDBiMzA1YS01OTRkLTQwZTMtOWVlZC0xYzM5YjA1YWNiYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzyGjqjxAnbPF8D5cbpVzUa2CKND+em5iBa9m9gkhPkgLB\nkQi2pCn1Ly3IM5omhOYdf53b70+gNJ6h99gNYpEro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrnZjWo9DfLtWJHhFhOKDnjxr\n5xMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgO4OYBMg1H+9rijPAV53SdDGbl6DGJpxzx7E3SGLmxgwCIGfmCPxxbzwW\nEPvxzOeKkzqPA7WNoI5H8/u0eIRzSNtC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAewYgCLKiWIXELGCU4O52Z8cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWYyYTk1MGQtOTA0Zi00NmM5LThhOWYtYTZlOGYzOGY5NDY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYWJkMzdlMC1lZDc2\nLTQzYzYtYWQ2Yy1mMzk5Zjc2NDlmOWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARsM0FecdN+v8EV1NqVTJL/VTm3sDutgniBJF8+3ApKJPRnZB8R9+81vqXHj19P\na+y/c0KVXAzqGK53ktCyTe48o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJ/M48U4oy0r9R\nAj8Oha8lKtiGnzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBgTYmxSxKfiqrfXSi2z+Z6aoWM4CmqN+v0wlwH4kr6rQIh\nANoY3usL/K+dn5d3c9iltcWakPggK8Xb+lsYto3cU3ho\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3368", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3368` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISATHpzsAev0SCpcWScjrEFUr8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1MWI0ZDVhLWM3M2YtNGJmZC1hMjIyLTkyYzk4Yjc5MmY5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc4ODg5ZDMtMTdh\nZi00ODIzLWFjOTgtNzA1NDM1YjNjNjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESAnuExqUQ1wzAD/cot6afNoFVeUfjqSirObflT9aHBRUtiRE4bwykM7gaxny\n1KCDmGdGYFZrI2Y9bhuqXC3FYKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSt0Z3PzhIDkO8kfpfXPze7nv00MwHwYDVR0j\nBBgwFoAU/ShciPcjsOpCmB9bVlZtpCB73B4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAR8lFodLkI/tBk9X8+ACzmzz2GAH1d58hRtzqm1uHG\nvwIhAOdITSB/T1xiwzQ5QR5S7pZX7qginz1ECmDeJKxOYseG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARdeCzeKv6WzYaYXskQcASB+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTFiNGQ1YS1jNzNmLTRiZmQtYTIyMi05MmM5OGI3OTJmOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAD9Gh90r/KTPh3nzjQNA8naDSWF1OuqrU88PBgVDroLK6\nMm45O05IIWoRq+OFYYtxp0xQY3YAXNGCoBKIVRiJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/ShciPcjsOpCmB9bVlZtpCB7\n3B4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALMmckQAL8unK23ZCVGORB3kvgfC4pq5nggOCVSdRjD+AiBw8ySBiHED\nPlb5OfoYEhJMrAO0QxIRyK8rJNdbJzZuEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAT8vsKfI17flxNK+2iULn7ALMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc4ODg5ZDMtMTdhZi00ODIzLWFjOTgtNzA1NDM1YjNjNjQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMzcxMjk0NS1hNDli\nLTRmMzgtOTlhYy1hZjA3MzQ0MmM2NGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASV1yNv67CCMfCRbbQRo9mRXWIDeHhd0uo6bhObDNxJ36GtwA3RdzrqDMj4tb2W\nSpXwUM7mf4BvOEX2WULXhWX5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRK3Rnc/OEgOQ7y\nR+l9c/N7ue/TQzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBOrb9Re4K4PUwMaV7nhrEr9FCqUrsShlZELm2tclaRyAIh\nAJp5PU+AXicTLU3cjxeWgsh5KndowCEY9iIsXpeWhNLy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3369", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3369` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAb3SqicLL/RHjqjI3ySR7a5yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlNDcxNmMxLTZlMWQtNDUzNS04MGYzLWRhYjIyM2U2NmViMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY2YTMyOTctMzA2\nYy00MDFjLWE0ZTktMGUxNjUzMjhhOTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE763/l1Wi5wiv3ysTMSI+EQvHvlDTslA/SM4+6CA+1z8kK4eHkgFpYAMryV9t\naLColcSxbxNehgVtZCdbf5FOUKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd6KA01MK8MAMp+8N7N96XEvEVwcwHwYDVR0j\nBBgwFoAUtmPDRHDF30ONpjppZwBQV//oU8AwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBQ4aPW5gOBSKm7ozR0I9/1YP5nugOkA6G9yfM19SR1\nOwIgWZrN35sjiB5mPInaz8n4ya0ArSZNmsW2AHFZPPsLPlo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZV2OpyYOz8lPa5ACwTdmI51MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTQ3MTZjMS02ZTFkLTQ1MzUtODBmMy1kYWIyMjNlNjZlYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzT8advG6smHZQhlBV8xEwfXTtzyTlACcnJLZp4tQ7ZLsr\nEUdYjFsKStVOCSOl6GgiAltk6c6atf6OtxOBQ4UVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtmPDRHDF30ONpjppZwBQV//o\nU8AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUBmLef2OqHL4BjSNqTH4W6Gfz/UsZIG/57UPkTqQaeoCIEGXI2dOA3y7\nURSXDEgA0ITbprd++cUgmEGNKLUcZ5o3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATzoJECBHHKDhy7AId47Z+F+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY2YTMyOTctMzA2Yy00MDFjLWE0ZTktMGUxNjUzMjhhOTRmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YWVhN2U1Ni1mNzEz\nLTQ4NmMtYjZiMC1mYjZkZTkwMjkyODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQKXK7i7lBAGH46BtnLyrLyLwjzGETPUVaqu17LBJUIKYGRiY+G3EvTJNXWs7ls\nMhb02kjNqrvqo6o+VCf5LH7Co3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR3ooDTUwrwwAyn\n7w3s33pcS8RXBzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBpkhvfajUSW3BiobEdjQmy9ApOSB+hXorSh0rOvHZiGwIh\nAOtJzdxo0rews82VJMk5m1cfg2NTebd3mXbeovI35ATH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3370", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3370` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAS1jMEPeLLbxJS67uR+Z2n2CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMTlhNTAyLTY0OTQtNDc3ZS04ZjYzLTNiMmVhMWE0OGQ2YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzkzNjUzNGEtYTJm\nMS00YmQ0LTg2NTktNzAyZGI2ODliNDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaH0QsO9AGv0e8TJPFAVqkDsvCzf4/0AOkFVfktJy/Q1FNZX0Yfv+boRSqz43\nfky4y4drv0ClTNAvyYvKQFBIBqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0hIjcLAMvNlM+KhLKfAIyUyyKVkwHwYDVR0j\nBBgwFoAUtncXiOAR8x1DwRpM4aEAjDvGZAUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEApcXGq7l9IZ3g6quvWBIDjbNQCKRC3g4IqRlqfAE8MasCIG0n\n04/33c0NDYXFiYcHiRdIk3D8ltK8Z2ZIyAAN5oeA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeYTZoEeZP6uir/xbrW51fRnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjE5YTUwMi02NDk0LTQ3N2UtOGY2My0zYjJlYTFhNDhkNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWbhhQe+593wXisS16azRPnwZcwXW+6UNgS2fLQqVt4kwL\nlgmt+8txOyTmUBYdKbSJZeA5mOU3yTx+ORcTz0Tmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtncXiOAR8x1DwRpM4aEAjDvG\nZAUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc6yoHaJSM0UlRSpt3/kAwqXj+K2Ux0aG11OIw5bGf1QCIQDpom+gJz5u\nkV6GGkOwhIXdZzNcgYlDtSPIpzx74Lbz5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAY+gee+PxQf8+9znlfVMLXTwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzkzNjUzNGEtYTJmMS00YmQ0LTg2NTktNzAyZGI2ODliNDU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNjFiNjNjNy02ZGQx\nLTQ5ZTItYTQyNi03NDY5MTkxYjMzYmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQrKXPG7xTCgkty5As95+8WFJAzliFF/JKqYW69vbzaa92d1KNJcNi+kOVKtY5z\nf9vu8mQ0unKMrDnn7Yy9m/HTo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSEiNwsAy82Uz4\nqEsp8AjJTLIpWTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAh+XWJ19bi55UvP0ZvofkG0/m3GV0aythnE4C02KUx/8C\nIDxiO0Mm2fXL5BM1irvfW2d0OMcDKpasm4uhQ4aap97j\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3371", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3371` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAWTCbeSRB3hM7/U0NLCJlfgwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNDk5YzNjLTQzNGQtNDgxNi05NDNkLTcxZmY4Yzk4OGEyMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM5ZTYyN2QtZDdm\nMi00ZTI5LTkyMDAtYTMyMmYxMzBhNDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEay7xrdVO2cXKzXrOI42tBiUSXcPg435b40C4Hp7Gqx5X3sXRRpGrAhDi0Usk\nXZvBgo2hqAxTj4dTiQ9MWFWWAaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSzZ5Y5myMXseVhE39aJ47Y4unPMwHwYDVR0j\nBBgwFoAU9EF0qdibMydZV+3aOG9SpIBM/mYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAyaippslv5gPck22EGa9pM9h9sTnr/8Pb\nZE8BsMF+aqACIQCyM4RvpjOtP9hyXFbeKEFqFw+uHh95JNnj/cwB337hEg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbmxhon+OfToGh1E3sc+uf9qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTQ5OWMzYy00MzRkLTQ4MTYtOTQzZC03MWZmOGM5ODhhMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDIsnXyt9fl4QCqJG91njOFC52i5Mw2cthU+7gpLVDJ98D\n/V1YONQHHJQClByVfk2hQKpdKCuCZtfnT0dwYeGXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9EF0qdibMydZV+3aOG9SpIBM\n/mYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMUOsv4eaLJQ6BMfk73FJ8u/cW1xRocmqImLD0kGl+0LAiBYYmt7++Ue\nuuvB8QedkzslWC1R4TGomQnOM+y/Fw678A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAfPwacw7PR2UKOdXDdkxxeMIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM5ZTYyN2QtZDdmMi00ZTI5LTkyMDAtYTMyMmYxMzBhNDBkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYzU2ZTYyNS01MTZk\nLTRkMTgtOThjOS01YTUwZjUxY2YzMDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATjbRieMlCJSgNQsFeKvBNfww7DTq+OYKWa4xOAcA3r+IaizmSQZLLCQTGqzqJy\nnpvF5HgbLPx9RkpiZLjm+2QEo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRLNnljmbIxex5W\nETf1onjtji6c8zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAxgcEglzrMpUZEfEtuvc2CjktUpBDV6wce6Xex++pvqsC\nIQCnaHqMIdttFT7UHqhNsl00WxYz7cw8nNkC36YQwVQUew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3372", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3372` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXYsVGqxF0aImr/PEBjR7Nx3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5NDVhOTk2LTVkNWQtNDExZC1iYjY5LWNmNjY5ZmQ3NDg2YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDliMjMxNTItM2Rk\nMC00ZTJiLWExMTYtNTU3YjhiZDA2NGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1P67fr9+1nv5l7joLqu9FMldtL5IshoBYzonNLVdRUcayG+A6ZQx/zrBFslg\nJHFsIIB9yPF0Do/PY1VR3z05/aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjHWcC1tuU13RzclPjxwcVavBFFAwHwYDVR0j\nBBgwFoAUJ6aDHQMipgNW2VavhY81veE+8H8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAsqkaQEs0turBI9rDWc2N6zhUzw74bIAC\neqbs3dbi2yACIFlzja5EBB3JU+yH9iGM3w3ouUbFHdwgXIqFor7NQDPc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbvu2T7K+uyopimlrR3bl4sNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTQ1YTk5Ni01ZDVkLTQxMWQtYmI2OS1jZjY2OWZkNzQ4NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7S3igsHtWmN9D3ytTt32rVjslMQzGB7DFeKQiuLzq+LYi\nMk5KID0w8E5DJvSaoywyXkk7/69Aj23Zkg3cixNro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ6aDHQMipgNW2VavhY81veE+\n8H8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGFLj/GyKr41kTAQZyJo4v7+MH3x2zn8JcTT9xTJiQjwCICxaZVLibYYv\nA2PkBlFkMM3siWLOcxUZLmIDiynlOmxX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASq0a5QhAOHuWbCOyM1Y3+YbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDliMjMxNTItM2RkMC00ZTJiLWExMTYtNTU3YjhiZDA2NGQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYzRlMmEyMi1iYzlk\nLTQ1MDktYTc3YS1kODJhZTc5NDVkOTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASNKbLAM3fGqId461lyFrEf18lexv2onJM+emvMgq+nvo0Je8mhvgEtiR/KrDlX\nu+PcNl1cpYnUbvoQZtxA3oxio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMdZwLW25TXdHN\nyU+PHBxVq8EUUDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAou35Q350Gay87ScrrSUAFgxphFxsGFWTxYoZydy3jQwIh\nAIxxxiyhlWqbNloyfZNarr2t5I+gjtGhsuJdJV+9w86G\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3373", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3373` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAWFLfzFmc+Gkh8UdlckEFo12MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyOGFhNThiLTg1ZTItNDljOC1hYThmLWU5Mjc1N2E2NzRlNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFlMmNhZGMtMTAz\nMS00YmQ5LWIxMWItYWJiN2Q0NjhlMGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/pOi5cDn/V3IwQwtRquF6fmRh1oHnhfEzNn7S8znQWdgE5Fn55wtc3VGK91U\n4td+mU+1f3lDQSktoOOGnrq/36OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSFGgLq1EwUwgoPWPTgbi0qZEINkwHwYDVR0j\nBBgwFoAUiBV8m2DfkqO+OcQj+3yiz16AZCswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAnnmYDQCIR+h4\nJtj7ET46guugRqWRDWfO6Sj9X5blD8YCIQCy79TBNKh703K0c6LL4QfPBV4FD1zR\nnzE2DHCbt1ArAA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUvAQoFOAeNYfu58KY9F2OxMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjhhYTU4Yi04NWUyLTQ5YzgtYWE4Zi1lOTI3NTdhNjc0ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASt+Vb+RcBHVGh7PrlsLQmUpxCDjkjmKop0VF/l5jotY1el\nkKDl0r3E8vUXF8Hh4w6YxWIPizuLXdi2qMfUK74Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiBV8m2DfkqO+OcQj+3yiz16A\nZCswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOySAtCcNJWKV8H3U5Q3xYFnvT03tMnpDtXKTnw6fpwhAiBo5nqnbGyz\n8FLzfU1cgg+nOGesqRLY8cKb2e7Rzzde1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAfGsvXoF4IAbBR17QB8g+xYNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFlMmNhZGMtMTAzMS00YmQ5LWIxMWItYWJiN2Q0NjhlMGI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNTUxODNhZi0wYjk3\nLTQzNzctYTg0OS04NjcwMDE5ZmZmODAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATgN0StlhnKdDitF41J8DCZEAUDrdGc9oZiSqQH8kYEnqrdj9H0Zs4TlViFej9k\nqClzd+Jr3JvRssG7BjR/5ILvo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRIUaAurUTBTCCg\n9Y9OBuLSpkQg2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA4H3FSMamF++IYzdG41qWDlrv1fPNz1Jh0Ad2hER+pckC\nIQC5ampO42tmVgr9aFFYMufGr1pa8rn7lcna91B0+4f5kQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3374", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3374` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfbvPfp3yPzBZs9qDRhV1BAXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0ODc1ZDY4LTllZGQtNDExOS1iZDAzLTNiMGIyZTBiMTZlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZjYjE3ZjYtOTM4\nNy00YjViLTliZTQtOWFiZjY1ZmRkOGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFP6gOTPpnn+LQNYQS5cqAdXrPo0Baph9aS34r+iXESpxsdBb6MvmUsY+UbRM\nF2tnVzXBHUmF55QG16r89yQYQ6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqgIGUV0Y5i3EQJSETBCqP+TCQJswHwYDVR0j\nBBgwFoAU7Wd6oOG+HRKyKXtofAdCd0uul58wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAkaDqzljRbdgBtf9K9SCRmLihvPqbIyaw0IuKfFiV3KAiAWvoerBHqcL2xJ\nLI2uS802oSuScT8oSJhPJy8kF9sqJw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATkRMIRKRdFL+2WetbgKIfnnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDg3NWQ2OC05ZWRkLTQxMTktYmQwMy0zYjBiMmUwYjE2ZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqiEDRMFMToq3P5pA/lX8UVFUn79Y28lJOhU7YKUVEAi/h\n6qGX/VcqjDimxR8yIrRs57laODW00/BxDVYIS4uQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Wd6oOG+HRKyKXtofAdCd0uu\nl58wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOxAGnKHKNnJLqN5xBRsgR1qNr0DLBtOLOBSQ5WziV2HAiEAn5vOjXFm\ndzxIqxI/c0hpK0f62qqI1q7LLGkRmRF0YWs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAUQ3qStYVNLGNS65aLxIsCTHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZjYjE3ZjYtOTM4Ny00YjViLTliZTQtOWFiZjY1ZmRkOGVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4Mjc4Njc2Zi01ZmY2\nLTQxNTctYjhhNC1mYTY4MzBjN2I0ODQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARQF+C2Twmsi/AhzUslUvvBfiNu0zaT7XiE1qrYIWXi808Rm77EqULPnfjBIa8i\n2oE6BYyiA0Fzht5PnNJ/oYh/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSqAgZRXRjmLcRA\nlIRMEKo/5MJAmzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAk/QRPnMlp5sk8OdQlRiGMWB5005KA4Rvel0/DbSfBUAC\nIQDm5eRqdB15TICoaHFBXP73Mi0YcAZSaxUuvhYvC4IWbA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3375", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3375` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWB5BhrqNO/tpTl15AjdjUWrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyNzBjN2U1LWE1NWUtNGRlYy1hMzgzLTYxYTllZmVkMzkyYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDJmNTFiNzctODkx\nOC00MTBhLWEwZTUtZDI1YWRlYWIzZjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnvgKPXRx+xpqZ+VQNyaVK+OQKcWr0NPW5fvlM2R9bUgpz9XuEZAcHbRQc2Ul\nzmWLY8RlyPuocUmR4QlBhj3+o6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiCVc7K5zCHUDiqXENrKC90cF8B4wHwYDVR0j\nBBgwFoAU5VrSDoyYn3OiZ1hQnxB7lXPnZpUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCPKnZp/S0V1PvadHVVffEZXKqTXlgXtWAzVY+QkXKs6wIgTwrdtB1sp+R3\n0sLEu8Da87/c2Kpi1zrGDxXFkFJwMCQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbrDMj5KUD0XpCtsDr/Yo0WSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjcwYzdlNS1hNTVlLTRkZWMtYTM4My02MWE5ZWZlZDM5MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYezj+HmUopcNuHNABsQcLTZu+5HSqMfzOdexaMHt1q3M+\nRj4ylcmyJM7N8KddDj7JeX/GXEInDvfnPyEb5b0/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5VrSDoyYn3OiZ1hQnxB7lXPn\nZpUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKmCi+uOt9EEICi0I6GKY4XsEQ7oOvD2IcVVSuvUxTAyAiAoPD53V1sW\nucC6OhVcyqZWVI+4/ZLbql6T9pPBRy/ZEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXuak7CPTQQTrjTwuvyZY6Q4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDJmNTFiNzctODkxOC00MTBhLWEwZTUtZDI1YWRlYWIzZjExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4MjkzMTMxMC0zMzI1\nLTRlMWUtOWQ3NS1hYmY0OWMwNTJlMTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARlyArtLy6kfUqOtrUhLYEFyG/GNREfNJCw/Nklki7ZwgulbM9eGSvzN2P13z1j\nJYNrcnOz58XgU+hotmSovbEDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSIJVzsrnMIdQOK\npcQ2soL3RwXwHjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAVw4sjbO5LgaKi3bvAADRPkI67pm81TWxA3SAFcY/rawIh\nAIlYzjC7GMnDcMp31h1y8YOILwCo3jdbc+yAXPt0mcw+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3376", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3376` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASd1+Uc0pcKRAWp5no+KgDdLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxN2JmZWQ1LWU1OGEtNDA2Ni05NDcxLTM0OGZjYWYzYmFiMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFhZmU1NzQtNzM3\nNy00NGVhLThiZjAtNmJlZGFlODA3OWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE01vfKpCyNJpISgN62qA7wzBgqjnsMzhorXLqK2c3ra5XahU9M7LpY8i5cxrp\nmaP51BGhDstyNEYnRwKBTqkB5aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaJD1Plzww/di1PQhVWDCXJRlAvQwHwYDVR0j\nBBgwFoAUE1/Zv2NZ8EYUV6JkypdOmoQqN9gwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA81zuto43d6BGCeqgntrLsAh8d5YnQicddcin8herSBQCIFbZH/od1kJg\nCMm6NKJR1UlPaXrGZji8Paaq4unEtJkz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARdreRvNX+3Lax8xXwwlWMXpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTdiZmVkNS1lNThhLTQwNjYtOTQ3MS0zNDhmY2FmM2JhYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAs/M79dp9ReFEck3vox0ePk6TlGmLJz0ZTJZqviVhnPi2\nfiJk1cId0PaeBED8jMM5L/CxTAcLF10d2cugiyPao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE1/Zv2NZ8EYUV6JkypdOmoQq\nN9gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL1ngGb56rZN3F5Dx20JCRdxf266dVYqU0+zkXrWBNO6AiEAxSZctYmc\nLSVvXAj29ZobljMKfni9ilPW7J91+LHuy0U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbONNvIr4lJfX5wwrd8UeLQDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFhZmU1NzQtNzM3Ny00NGVhLThiZjAtNmJlZGFlODA3OWZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNTc3NjYwYy02ODgx\nLTRjYWQtOTYxZi0zYmNmZDMyMDcwZDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASiHGjeZSX5es+x9zJgQmIahXz5aX+sBOxLwy1YbcrzEBdq1C0BJk9s+QEMgpTX\nN36y7YsGySTBOZNNqY65acEAo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRokPU+XPDD92LU\n9CFVYMJclGUC9DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAwy1mIyykt2xGK1kPkn1wnvizz2EczEZYT//mCP22+Q4C\nIDiO1XCghUk1FT5HYA8adkcC4i8/tyuaI0a5ovBLGVJ9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3377", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3377` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWpfLGc1FY7GJEhnotQ2hv5vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzYjc4MTBkLTlkYjItNDJhNi04Nzc3LWRmOGNmOWE3YWExZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBkOTlhN2ItZjcw\nZC00Yzk2LTgxNDUtMmQ5M2VmMzU2NGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB6NXEBPL49EJjXpJF+SJAUJ5QeF6m3NaGBh/lPIir5muiCYaTOpt4iu67y5j\nkWBhdMrWR8PZMhF9jVYvR0L2C6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpCR84wQsWbiyinIKAIPEHAsv7mYwHwYDVR0j\nBBgwFoAU7ujXU5wGC0VZEcHZF9M3FzqdWFIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBDQuoMciNBjFeZTdHKgyvrF6TZQ1/ALP0USPqLSWna\nMgIhAO+36OJY5VNxbV1TdAoL1nIKARaOPx4HrzBZaucjqOqp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXOW3OEfhVq+/AFSf/CIbFsqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2I3ODEwZC05ZGIyLTQyYTYtODc3Ny1kZjhjZjlhN2FhMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/cBmjx9K+epEP2ixUpVx2XF/Ss+43pRlha2w1XnTqQjn2\nshc6rnM4JLv0bL992dm+frf41W6IffKGXOY+6IqVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ujXU5wGC0VZEcHZF9M3Fzqd\nWFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO7xygDygR8CfnZ+4WAshHTGqBpjDFg7Z1gICvm/anluAiBBdmeZihjY\n9MKndeS53mkxqHkA+t8jjbgJTOXExANZdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAX7obydtDPBbfL64rxHRvJorMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBkOTlhN2ItZjcwZC00Yzk2LTgxNDUtMmQ5M2VmMzU2NGE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiZWUxNTYxYi0zMDI2\nLTQyMDAtOGU1MS05NWNjZTY1M2Y3NjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQq7NAu7HpYnwHpXA2kcU/Hma3ynReY2yYTKQ0w6aW0N2eh355QSjARO69lEfG7\nGBjBntdscHiIDtRhvIt4c59So3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSkJHzjBCxZuLKK\ncgoAg8QcCy/uZjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAuxBpG9asjiJoIplnWiSEORBsJ9nZutfaKQ0VuMplsbUC\nIQCdREUzSsixke+k4S6fBYR529CgY+COFGL/ppojT6C15Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3378", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3378` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAf8Sp0L3Mq+Z5ArpfVA6MuCoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkMDg1YjI3LTU4MTgtNGJhNC1hNmRhLTMxNDc2ZDlhZTg2ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFhZTFmZWQtYTll\nNS00MmNhLTkwZmEtYWJhNjE3ZWQxMDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKg8ziepp8fWARwxaPAFSKsZc+HDwXZIqIAS9JXsEJ16kNuBK1NcwkPNK2sBL\nvos22zhhbH0JXBc+HwTLTRM43aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURiHxNLlnEd0HswaXT9o2NIGQNCkwHwYDVR0j\nBBgwFoAUO8Lqe3ucjbZgNLg0jruL7/8wjmkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA9NuWJz0cVqaODTHWf2/ZSyHK8qmn6gnpP6cjhMgS\nJGkCIHOsPnjpc6pacEcSNItaYgxjATyP1NK4+zmL5uSfzN1f\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZjo4NzBPYMwqbP2f73bo9eAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDA4NWIyNy01ODE4LTRiYTQtYTZkYS0zMTQ3NmQ5YWU4NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpYiJS1Rll+oGwHEiJhNb0rK7pm5TIsvRSGr/N6gOiGXns\nTHp5EoTHi1SwJEAb6cC3ToJI92c8hCsVRxChSXt9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO8Lqe3ucjbZgNLg0jruL7/8w\njmkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRs2wjkyV+HinrKQV7b8zfvkrG+j2wmVs+LL3l9J4RRECIEFoZbzzDHha\nFTcevXHEU2MZ1JjkQeQX6i/Ftpqst4xa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAYK3FgDK1BwiS2L5ADvkio1mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFhZTFmZWQtYTllNS00MmNhLTkwZmEtYWJhNjE3ZWQxMDUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YzEzMzA3YS1mM2Fl\nLTQ2MDEtYjYzOC1jMGZlOWExM2Q5NDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARN4MfVDv8+fbziP4h7nooS8QoeVOu1R6y4vp7EhzX1Zpi33rNu5HZOvyPBu9yu\nRseM0o19UmkIAX5pjojxqwG/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGIfE0uWcR3Qez\nBpdP2jY0gZA0KTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAwohOS/iaTyqTcgZ6byVSC+SplhdgCUW82TKBBLC9hmEC\nIQCUnSZy6GYE9ier5yyshHWnN1RYbXk2AXzZsGAHvSg7Qw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3379", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3379` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAa0SiU9/Iep9RQ6JP8YKyVG5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3MDY4YmU3LWYzY2MtNDE3OS1iODQ0LWY3ZDdkYzFlNTYzMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYwNjExNDAtZGVl\nNy00OTg2LTg5NjctZGE4ZmVkMzQ5ZTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgutPEzZrk8bC/AcWpcKGZntUE+gc6GCp+lFXZ/AcsdV7uQ06TKqvdqdjeX0b\nDDQ2jHzhvjv09XkrJCaGjNNQP6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMH9QcVOWSjeIqSJjpaiLsTHSBBswHwYDVR0j\nBBgwFoAUpmVUZaGuhUimEdxlAvlvWoza334wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEArZ+a+gWwwy3G+DS4P5+GtoxuLtmItYTjfc8uRPUfTjoCIQDu\n8qSdtX4EKz53IDxwfWQB5V4OtOWwukg+HkNuaA2ZPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWc7ZIwTJKQyzEHM6kmFmwozMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzA2OGJlNy1mM2NjLTQxNzktYjg0NC1mN2Q3ZGMxZTU2MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyA4bogNJzOIPO0Ie/I4mg2iHbk29wAne0/ugWN7rPwwv+\npX4swdWaIJIAi52S7NvsMZyjNL46e2mgUQzyWftco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpmVUZaGuhUimEdxlAvlvWoza\n334wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPQlK079Wden73ewCiyr5OMzEzNWz0vJtYvkTzFtixBMCIQCHf3217eOF\n2k62meYGXry/U+4Sy1gMA315eWMCszEzRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQZQB/LpicYggkhY+5QZR7j4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYwNjExNDAtZGVlNy00OTg2LTg5NjctZGE4ZmVkMzQ5ZTdjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YmZhMmMzYS01ZDhh\nLTRjMmMtYmRkNS05M2QzOGYyODkxMTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARUBG7xfwTL/3A3E5vDSou0cc/WltTHh5BFmZlMeSQcFNHruw0HnxSeOZrm/fs/\n29N5Qk55OtNvoFl9OnznQQFOo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQwf1BxU5ZKN4ip\nImOlqIuxMdIEGzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAwoZmn+de+JfXSZ+GTMLBk3dJgw2iBBHGMvtgq6r2BZ0C\nIQCgTBE0N/MoQdaSVC8oUaqy7R2y4ki3kjplrOZVGVo1eQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3380", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3380` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVo6xy/v12pWRLgDsvOSdGKCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhODE3MmMwLWUzNjMtNGZiNy1hYWQ2LWJhNDBjNWQxODczZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjMwMzNkZmQtNGU4\nZi00NDYxLWEyOWItMzJlZGRkM2M3MDgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr9xQNJm6mF/0PR3APZGfCU1mrS3MIkk0QJBtSmQth2wSMpreBdPuEJ/ilXrv\naULqyCc/M7jOYS4kOid7xFGOU6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw/CSvfAdDmwVHaAJxGgutHQ7V5EwHwYDVR0j\nBBgwFoAU620wmg8/29pfn75fUiL9sNtZguowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBdzMr9vG2ys4WLUkaM2/uNYhdbd/eXHhpH\n37khhAy0XgIhAOoGTygqtgpreNLb7Ma1H8Swt7dcD2VVWLii5/gacOL8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR0OSMalI13DkBhI6nYPdGGNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTgxNzJjMC1lMzYzLTRmYjctYWFkNi1iYTQwYzVkMTg3M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYwZS1EqXbz6l8hzJGZUifVAxruXHnqbBlcHivCzEciGJT\nNIFjMDm5Nmo/BkyEw9fUT65aNLEanTAUZzNx2p1do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU620wmg8/29pfn75fUiL9sNtZ\nguowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgO9m7MlouXgKmQ7NKEZcGhGYIypkbFcV+S8KxpcP/hbUCIH0hpJS9Csdp\nXouuKsduqYwneJTqQWY7e/Sa3iieibKS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAdcgkZ3XXrXHFT3a+cbztJEwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjMwMzNkZmQtNGU4Zi00NDYxLWEyOWItMzJlZGRkM2M3MDgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YzZhYjA4NC0yNDJh\nLTQ3ZDYtYTIwYi00MjVmZTk5YzMxNTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARL7SH35BM5h4IT0zmQxHJXGsw7XAYdrj8zg/IzbkBG+Lyw4JNHtCzejjCBL2zw\nv2OvJMqnkmfsgvKWIA2jQix6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTD8JK98B0ObBUd\noAnEaC60dDtXkTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAno9P63ZvmrIURyFMefhYJL/wu/tBjieVn44WOGRAgMgC\nIQDiJkK4qCmpOpbAZ9mgMEdIirA++OlXhyBD/3pQFRqr2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3381", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3381` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAf1+H+cWZfRjd/af6ILIeUBRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNjQ0YTYyLWFlNzgtNGZjYy04MWZjLWU3Y2E4NmUwZjRjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTNlMjYzOWQtZTlh\nNS00OGQ0LThmZTMtZDk2ODdjZmRmODg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6KgFb0dZM2EGFWz47SM+RQIi2cIZlYJP6o8K+BkbflphfiaxnOy/U6e8P4xg\n/H5ZerDJ0kw700xeDQivAZ0T86OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnV8D8wc7X8uAsk85RtIaNfw0fP4wHwYDVR0j\nBBgwFoAUYmbRn1O4oyJ9xMv6r6ATxMkTSEowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBTSWaCixcibEX2bWia79MD7CbOkxiYmpEa\nheZMTnONjQIhAN+Xl2Gp+PCSSUgQ6M+1/wip8qL3zofUvx9KnTaQ2IQE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdHCNV7r6KQG2uLtg0e0SDlpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjY0NGE2Mi1hZTc4LTRmY2MtODFmYy1lN2NhODZlMGY0YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8OeBbjsLhqoZjfgn4DmK2us4TQgmY5/QCHCAYstUWUSUK\nD+fYhjX+SXml0ePNkd921CWj2ocBMjVyR24XkLNQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYmbRn1O4oyJ9xMv6r6ATxMkT\nSEowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG7EsPOWK2QXad6R+3kTwiibPe42iE8oyqzJVhRVTzfkCIQCgKH7dQwQ2\n64zibXNe5tyfwTlmWQiFJWuwxbt4VOqTbg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAeZ6/p5SSk+HLZNInfDVkEjIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTNlMjYzOWQtZTlhNS00OGQ0LThmZTMtZDk2ODdjZmRmODg2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YzE5YzMwMC03YTg0\nLTRmMWUtYjg2Yi00ODUwOWI0YTc3MmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS9V75ElRb1MZXF9xBohAe9agV7PVebDZ7kB7Lyq86gqPdtFQC5y43jjGF1xMZA\noqQfkzgucNVrMkv7hDm7P0sno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSdXwPzBztfy4Cy\nTzlG0ho1/DR8/jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAgCM9CEJQYt8YT1WI3s6Z3sgiJQ0EYYAPxyKFx+YRKLQIh\nANgxTvoFgdcmt2XvRBa2cpzeZcU0rQyfdxMvmznBDUId\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3382", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3382` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAUdcQAl7ijrfPsAI4LK74WjhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczNjFhMDQ2LWRkMmUtNDNkYy1hMzYwLTMzZTRiY2NiNjlkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ0YTY0ZjUtOGRk\nNy00NTY1LTgwMTMtZGRkYWI4ZmE1MGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO33zO2yxiwGJSlvPAeFHdlGVsn7o8j7UCz7L6TTYDe91oo2Dzrydrpd3KDhk\nSJ9dgA69RfhHiZYVJ6jYU7Qc1qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1p2XPW8w2Sq5E3fYY/hlVu68fBkwHwYDVR0j\nBBgwFoAUl5jGIaMQO8JENtY8ihitoHNdSVgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDe+2uZQMJ/KvypPdWkD3B4FCOc\n42oCKp1hCvCZu6kGCgIgBiWDffpZ0PjO55U9DPsmLu4Y7J6ETBm4AN13Pp//Kqo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZXtoUOVUaAEzRXszh8mok5oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzYxYTA0Ni1kZDJlLTQzZGMtYTM2MC0zM2U0YmNjYjY5ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7QKX4H/F72gY27ytjTCzW5MDBjD0qR+t62am06m89fCrd\nHruhU/bEglwmTWe77H38ShGa/DVbjsJhEbL9J3reo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl5jGIaMQO8JENtY8ihitoHNd\nSVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPvlwOlI99hMBqk65+1AJ/I1hyF8PEJp8sSY3/8xBgLaAiEAnrV2Yo6d\nqAhcyzSLdFpizx0y2fVfZG9d06kuq2icYx8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdjFpDlKq0hwktfDtivarYu+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ0YTY0ZjUtOGRkNy00NTY1LTgwMTMtZGRkYWI4ZmE1MGNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyM2RlZDk5Ni03YjUz\nLTRjYWUtYWZhZS02OWZmYjViN2IwNjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATCyjZjvM32dgLbRjZM6VSpslO0ZAt59fXFnh7Lo6Y+QaL049Rc6LZHMhl2FUzK\nxYjQhd0XUnHukF2RPA6xvf46o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWnZc9bzDZKrkT\nd9hj+GVW7rx8GTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAyc256/jAwhFINf/YBGAZwe8EyV1KX15kbz5FdM5azvgIg\nUIcvGqIypsSjPPWu3f4pouVmT9sk1xmncV1KmTmctJc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3383", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3383` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAXbtUzPaJrwkM+GtNNJDzREaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjZGEzNjc2LWFjNjctNDkyMC05ZmI2LWIzMjA4MjZiNjJjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU5NjZlNDYtMmY4\nMC00ZjM5LWI3YzEtMzZmMGE4YWFhMWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF7u0j48gjE6h5uQBwcvrzobPh2CQYf/LOtlDCI78UgbZpRgeTARV2Tr+q+gz\nVcWfKR4R2E2TfAcCgOcv78pgoaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiIawkDHOeqKEwq+36Qp1IXE2j8EwHwYDVR0j\nBBgwFoAUsJGlE42P0ckhL0nx7R0OPx9amjcwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgBnuToJbd\nVDXsP8TShsn8lY+CoX2blv/zYJcvgHEfPUICIAfdssaysxYbOvgaEsgEZfVVdhcu\nCPV7biOF5ivjgzup\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARhpNKsmFGbVjf0mULbsnGw4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2RhMzY3Ni1hYzY3LTQ5MjAtOWZiNi1iMzIwODI2YjYyYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGh3L93rpypiT+9tqaXn238NFQXDmcQmstsXpmpH3hVlbt\nP+ymBNRwaH9TE912fOveuqtXnQs41hXJULH+35Z3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsJGlE42P0ckhL0nx7R0OPx9a\nmjcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMBDLzFhYoKgOxYi18zkDYyHSiAPYwu9fVLbvywjJjSCAiEA4onfdPmj\n5Bo4e0Q2Nies7gzXH3OTwc94h5o9GRQSZ7A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZ/DT/xH0XjL+EMohapz1rI+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU5NjZlNDYtMmY4MC00ZjM5LWI3YzEtMzZmMGE4YWFhMWQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ODdiNzc2ZS00MzA1\nLTQwZDQtOTViYi0yNGUxYjIzNGUwNjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARmoc2hOntXIq3ET9Ps/J41EGIZeTciTIvLhQymMVEMQsw5DFmaW/JGOyVqi5Jr\nFa8USDIOH8A8cc0wz9bmmunvo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSIhrCQMc56ooTC\nr7fpCnUhcTaPwTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAiDlPydCZP9paa7UOv7MhdRi0MrN/H2TA45kuXQaO8nwIh\nAINp9UofiUTJEKAVtOVr8bH2Mz6tEEuN9Sk2lJxqP4O7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3384", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3384` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAUXt0pcnKw1P2Oq5juwgCOQMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2NDhhM2FiLTU3ODItNDE3Yy1hNThlLTIyOGQzODAwNTZiNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI5MzQ3M2QtMDU3\nZC00OTUwLTgzMWYtYzFmZTBkZjdiYjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBUYfE2mQIoTMLYr7kagZuQzMzdZvOqEF7XxzvrKTJ1Kg9PbZFwEBNXuzmfgJ\n0eOZ2neWrJbjbKQlJCzIZfvIyqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXmuvK0QhchTeaf564YbIOqYM3L4wHwYDVR0j\nBBgwFoAU0CEJV9qZJwSWattNLvV0RkqdJ7QwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhALY96yl7\ngRCCOMe+eZC8eHsugSqV94fmG8TCNvyJPSznAiEAnY2KzHsWI5RUcK+kAYTM2olH\nqdVrDSNiAkME7ryZYQc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAURRb36+/POmH6RyEb+xDU1fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjQ4YTNhYi01NzgyLTQxN2MtYTU4ZS0yMjhkMzgwMDU2YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT67r4PK/uTf4+Ht9dWmq/QxG6UXSFYgBNCjD0zh6bp0Mf1\nSY+GVhMuhnw0AqgNh5HKLgQgzUg4j+a8mnRSv0vVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0CEJV9qZJwSWattNLvV0Rkqd\nJ7QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPaCf7Ljdc3Cy/7ml05d00MiU64vrz7WKfHzVzEuZ0VXAiEAy0XeAKIR\nQARbA0PRPnpmukTIK5i4Jg7fU9fS6n1Vl68=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAb5ARz1ucETDYHwsTvYsgdLDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI5MzQ3M2QtMDU3ZC00OTUwLTgzMWYtYzFmZTBkZjdiYjY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OTllZGY4Zi0zNDI2\nLTQ4YTUtOTg0ZC00MmI0Mjc5ZDk0MTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATxJgDgv+fyv2QSC32AiPhjd2rOPkm02YEAvWhCbEhqSHf7AL7DlIvtHeGjpGhe\nbFNMGQ13DKZCeSaWucirIF0Eo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRea68rRCFyFN5p\n/nrhhsg6pgzcvjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiALpLB34nCp1dPJ7F3wwoV72rOMTwXRGRKja7umsEEMGwIg\ne6Nw86248I33FgTDF+NS3upjsuHfJYiXBMD0XTq/wRI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3385", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3385` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISARxspswNPifmMtLZwoh1JB94MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiNzQ5YjRjLTEwOGItNGY0OC1hMzhhLWJjZTM4YjkzNjcxYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ0Y2IzNDQtYzM4\nZS00YTM0LTg0YzEtOGM2NjEzZWEwZGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/q8WNcC15cCoRf6M8IxEvmpRqnaYIb1pJzIJ5fdlHTybdNmg5F0RyMnCNwCt\nWpYgx5wq8GtDT1dlg/RXMpvqc6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU++xU3Yp4dZNM1rr51GFEDxyEjlowHwYDVR0j\nBBgwFoAUMUMconbnZXq+hzlgOs/QpGEadqYwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCywyNA\nxFokXEIXxMuJIlAGqYQUxIxeRJFnlyEd34OnrwIhANuXED/o3KgzvkJh0AQ0llUq\nDbkwAn9w/hmJnJzT1w+q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUdFsZ00CGyjqxvdCH9ArTU7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjc0OWI0Yy0xMDhiLTRmNDgtYTM4YS1iY2UzOGI5MzY3MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATF6K1h3MK/cKs0X1FIqRNoCEOTFngtHtW3rbY1f6eOzD/b\nSefSUMjTB4hU3EkUhfKO9k53IeXBJVDIqWVZRAzXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMUMconbnZXq+hzlgOs/QpGEa\ndqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW3MBgqIZ9RLXutI2PxwrA3PKYIEjZbq15NJ2+4q6d00CIFRFgCZc5VKq\nnzj0AWew9pFWTXEjj4WXM6pB95/ai7Lg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdK8ZdufLdr2d51439cG3RlRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ0Y2IzNDQtYzM4ZS00YTM0LTg0YzEtOGM2NjEzZWEwZGJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZmIzZDZhMy04MDJl\nLTQwYzAtOWYxZS02ZWE1MzI4MDU4NjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS6923ip9nud93srn1GCaR69ALybh/DThsuCgr1Sk/5+DQlvBx/lUOujKuwJFmd\ndEkeo7XwSeQyOvArPR727ibOo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT77FTdinh1k0zW\nuvnUYUQPHISOWjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBjRkE0FgfFvkInHEHVoCfI+B8+TRtWbBBIyDcJjg/vVgIh\nANWOj5ylOG/g/FswZo4vuySiUejNYP8ij+zSBUoCmVgk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3386", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3386` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAdhZlBlcEf/6zyu3Qd5gTMsCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjNTg4Y2IwLWRhYTMtNDVhNC05N2VkLWMwYjhkNWZjYzhmZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIxY2ZmNmQtYWYx\nOC00ODBhLTg5ZjQtY2Q5MWVhNWFlYTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVN23fEmWy+J1Ag6qprclS1ARZvGvzWrs/ixOO1zqPrVryR7RUfrZahAymn65\nHuhJJ5IL4VJslhcTyFsg1h7scqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAGCRrfFKhVBwgY59UTbtC+DaOIQwHwYDVR0j\nBBgwFoAUhcSyfM3QizU+gTBV6BsWXKII83kwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIF4upwoQ+HQJqrgmyv/q9478bxiRy/yGkC+IzFLhlf6mAiBYGr8IVdI4\nNF3N+FaI+30dTR6rEao9kpvY8bdFQaF5Ew==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcrtFcDgdmSWrocxNf18Odf3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzU4OGNiMC1kYWEzLTQ1YTQtOTdlZC1jMGI4ZDVmY2M4ZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/NzBN08Ypire7fEnzKSPN3Oyqu4ImrWchTqIBl9GgzumZ\nSI9MMfGAjqsgfowAK/q5f9dKvmcFBarff53K/f60o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhcSyfM3QizU+gTBV6BsWXKII\n83kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAML9K6wYmp8HXR/0OJXzhZCnvLuRMR7Ea1Ztsl6ooU92AiEAxftvzQ6P\nJDEHB1gaUQi6jvu1+1su/iuOz0vMI6QO+I8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAYXeAzcARZmnWbELdSwWbFgCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIxY2ZmNmQtYWYxOC00ODBhLTg5ZjQtY2Q5MWVhNWFlYTQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZmMyODBiOC03Njgy\nLTQ2Y2EtOWY2MC1iMWViMTZlNTk0NGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARaBFM9j1jC+NDLyX6vvye1wJzKdWdfR1kv1Vt8nY5KIrLX4qUbYIeRAn7wsEy8\nofcib6WVnhibudcLMggtQMFmo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAYJGt8UqFUHCB\njn1RNu0L4No4hDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBuceXI67LPOTawKmSYpvIVUT5olHki7XvgDP9Cz18rWgIg\nJvDAQ+f81YngBxg1Q/Wu14pXWy1EMBBhLknJc6E263s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3387", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3387` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISATrqybxvyLy2Pv5/0WRs/0JfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZjFmNzQ1LTM1YWMtNGM3Mi05NmY4LWIwMDFiNTA2Yzc3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgyODZjODItMzdi\nMi00MmNiLWFhY2UtZTk1NDdjZjg3OWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzq+xr0fxF7SsNlr5MtDBKqm4rMmbcho3lLHjS4kTdfhuDGHV8GY1rJRO5m6r\nXDnuFo6cylYWAyIKYj80V8e2eaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvbLJI7E9sj7aQxI7acYbZOrGPYQwHwYDVR0j\nBBgwFoAUJw0D2Sgcq9Bw7QSZq2vmi9daZ7gwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIH7ldIsnyN0/PaHmlHy8lH1hxNW5Ox1PrlFpfWqS6PA6AiEAjnVxHxQK\nW4+ZDQL5C5pFlQNy/CwxG+ynr5XtDKjRmCY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbnjuhdIvVSPk2lVob6T4/hGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmYxZjc0NS0zNWFjLTRjNzItOTZmOC1iMDAxYjUwNmM3N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnI4cW6Ddt1JotQkNDHz2b00/IJMYevlnBxDQXGBbrA0VD\nHXpDGGV9XXSjQXWz/GZXYdzIPeDrbjPVO900z3c4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJw0D2Sgcq9Bw7QSZq2vmi9da\nZ7gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXDnLo71gbc8mQyR2Obma5jxEdZfVTWHDvrv7CoFo/QMCIQC2BY1W9w4s\nJ/FtL6pGLTi4Y1QFpA3+o5D8MfTXMwXQZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAYY3sX6HzdIMiZfshiBhYqliMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgyODZjODItMzdiMi00MmNiLWFhY2UtZTk1NDdjZjg3OWVkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZDhmYmQ0ZS01NjEw\nLTQ5MDYtOWFlOS1iYTgzNjNiOWFjYWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT3iQE70ITD361pRBcqASPLwyEhlZyXtq4ZojIIC/y8QO36OReoGGZ2/p2gHC2M\n3vzmf3e7NXNlyWkovSLN5ty7o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9sskjsT2yPtpD\nEjtpxhtk6sY9hDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEArPFsOsv1cAfxtaJ8QJP1OvzrniGaEByGB8ER9nDc6HsC\nIQCtqqalI4L7eaQs8eQRPOjSDvtnijKJnOPi4abk2I+fMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3388", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3388` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAaKZVzS+p09cpeGznh/sBYooMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhMGFjY2RkLTgxMDAtNGNjMi05NmE1LWIxOTM0OTgwMmUyMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE0YjYzOGYtZmRl\nMy00NWI0LWJhM2UtNjVkNjY5ZTZhMDc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmlDlKJs39LmdIAgcjT1b30JCmRXrmUFSOvOR9gXDDyHOg2z1/5PgyK8jFaVr\nFsowOoTaER5nYiv9ivY8vsNTnqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr7CCXyvW6bFZt21QriamfbYXcYgwHwYDVR0j\nBBgwFoAUzeqR7FfBXfXabtMZzd2ATsJNCT0wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQC/p1jvP9o4hiGonFad2hnqt4I9l6wbjmloRlof0jY4+gIgExirh3t42dYdy2V1\nb4TghNzQLDuZqRJeC7/H//yhGTM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ2jZ7Z9qzqt+fKWEnhT6XXxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTBhY2NkZC04MTAwLTRjYzItOTZhNS1iMTkzNDk4MDJlMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgsc6CjXLlulZOW8Q38wDNFYL8Qaz16gUzPvpqyKQ4DCEa\nEGyYi3j9CLDbc/jfdvvmNtF8u69Vjg4mhl5ATe/ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzeqR7FfBXfXabtMZzd2ATsJN\nCT0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANZOPrgwLZJQNt3BdNeNpP8LNHQxDchkbfQQQkZZPNWYAiA/lu0DgnDo\nW/Qapyf0YnpX1H3uJ4MLJfevvzxvCQo2sQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUpjnbIIUN2uZNWe+LeEknGBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE0YjYzOGYtZmRlMy00NWI0LWJhM2UtNjVkNjY5ZTZhMDc0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2Nzg1NGUzOC0wYTA2\nLTQwZmUtYjUzZC1mMDljM2VlYzJkNjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARAGAb0qpgtFc1J4se39X34Y+vJyX4EH0XZ8lhp0Hx50hICDZ314ISoFA5q2L2x\nGvUN+DcnKLpOKW5z2kBghVq8o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSvsIJfK9bpsVm3\nbVCuJqZ9thdxiDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBNU5S1bvvpNYV6QiZdQ6cvxKeB7e9SepDalBARt5VUKAIh\nAJeypvGZGPkZka6iTeFPCycN5YgMOMpV8rFZ5pbm3hBz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3389", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3389` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAZBWzGpu7DMINokBzWP7tk46MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0YzVjNWZlLWNmYjItNGM4Mi04ZDBhLTc3OTEwODUyM2NhMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQ5MzRiMmItNjIy\nMy00MWI5LThkZmQtMzQ1MDI1NzZiMzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2Qh+Hp6F2+ayLL5vcueaESsryUXhXQdERb0gqZ9Xw8qnxPAGY2t+jXVDlxqg\nk2ANfdI+Y4Va4Tn4k+fal/mbfKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0BZ+Q4fX3c1Eu06Ys3xvc3uBRsMwHwYDVR0j\nBBgwFoAUZmtJA5uae5iqj0E42LPgAzF0XjgwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIGFQY4Bbp6M7G13rBrptFRkcgij4H2MX6uKIxwoku2zJAiAF\nAXnLkL1B9NtFP+zS8GCXJFvhw0v/9TRtSreVnEPmEg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUCIM2LI3CKT7Vj9lVitoeGpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGM1YzVmZS1jZmIyLTRjODItOGQwYS03NzkxMDg1MjNjYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgr2TWVpDUw+ITRzcs2XoWu7Xf9hyo4tpnBbO+FWE/1dRr\nrkx/n7PCJbxva+zKmYO3Vr7o1OIRjhpiI/1KefVLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZmtJA5uae5iqj0E42LPgAzF0\nXjgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK7dg8W+9aNKeXQ2GyIyUSXcrux9bPTSTMEmqsVts24LAiAoM08VLE2n\nw8GLvPvj3yeOCANmMmvNbDdMteBaveIC5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAQwpJpgTwMssdmGXj1twJ+rjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQ5MzRiMmItNjIyMy00MWI5LThkZmQtMzQ1MDI1NzZiMzMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZGFlMmYwOS1iOTBl\nLTQ1ZDctYWExMS03YmY4MjdlYzk1MTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQIaNsFtNh2BtLkAuW0rZ5T6A2lXAbdP1rNOA4oJgeIs1z0RRZk07wlPy44WI1S\nf20rq/sn9G1ITUhZvn+oYHHDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQFn5Dh9fdzUS7\nTpizfG9ze4FGwzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBn4o7Koluvgia1RK/7NTb3khukb0VDXFV+sbGsF7W4rAIg\nYAs3fvNmB/M6GcwJx2bB8UWq66SbOHWxCY+cCoFB4lI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3390", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3390` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAdRCTa8P7dcMxW8iGsdZpIt7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNDIxY2NlLWIyOWYtNDAwOC1iMTA3LTNkMWQ5Y2E2Njc3MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc4ZTQzMDItZDM3\nYS00MzEyLWExZGQtZGNlMWQ2ZWZiNDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqRCcb9ZJItfBqYN9u74qBMiGb8PbzT1LQz3OIXGBeE2BHlZfAlWMf8BQQNKk\n6GNwMm4I6XTFfbW4eMFGIB0V2KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiCE3gI2dVElvePB3AYwY3QjAV3kwHwYDVR0j\nBBgwFoAUygNIoOAfKoxMwV76/sSERgc4FvUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCICKQVv1Bauor11s5vafz14ioB1mcCZDE1YyDyUPrfiiyAiEA\nh7UJ++dAJkYdlawQuR7H432EhXzo417w6BRdFEVXknM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASbVfWY4xVi+R/j0A2N1Kj6aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjQyMWNjZS1iMjlmLTQwMDgtYjEwNy0zZDFkOWNhNjY3NzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzD7qAKESOLl0UM5jB5f6pFDt7VGKgNfHY8/bkWAJfVBLi\nEsUuJG84oCnt08XggEfcphbvfUrIZAl6NciP01tyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUygNIoOAfKoxMwV76/sSERgc4\nFvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOTvQJfiZXOxLUvrOJD/sxcdXTDLyISOJ8K2Ilywl4sQAiBAf8nq1kVe\nUjOwNXPG2ClxCZVi6+gXjOnSBIX0sxBToQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAWTR4WpH7StmwnW8hWV4tdzpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc4ZTQzMDItZDM3YS00MzEyLWExZGQtZGNlMWQ2ZWZiNDZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNzBjYTk1Mi02NWQz\nLTRkZDEtYTdiNy03Nzk1NjljNjg0NWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATZdT7UMK9jo+bR+7WXnwMaXhVgMNz5UeQG7vxVqsOfns1lePdkvwUXkgZ+13kn\nmJdz1TfRZhRQ3r5OmkzBAPYeo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSIITeAjZ1USW94\n8HcBjBjdCMBXeTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAr5xaaQWA9b7rCboRqZB/Hxc807r9vRqi+pp8ditHUNAIg\nGKGAEznNHyTGvLR1N2gnR1cd2mXRlAn+2s2f4D6EV0U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3391", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3391` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWLIqUa1JltxETCcbRSj4ieWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3Y2NlNjBlLTUzYzQtNGQyNi1iZTU0LWM3MDY4OTY2YWRjNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQzNzA1OWQtMzZh\nMy00ODkwLTk2N2ItYWU4ZmFiZGU1OGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg5hJT8H9E8qxk5ZPPKIWdIvFkrvWYujhFizBZ+NNppGgWaofWNa5uYSWIkB3\nwqE3jJnPDuG1PYLk9Pb4vjbH36OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFbKnKAKl6JZZ+A7kG4WgYAOUYl0wHwYDVR0j\nBBgwFoAUHzOQrvKBM8SpJy9Ma6zFP+wRTL4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAogpjM10RrL\nTtgEZqA0qdKMoMA2b6ZgooH+/pt28QtPAiEAxi2IsrBOQJ3ReQAX90Nzm+ztszYW\nq7wfp1Z+zxLy5ZE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUtFfDmt+8Ullnq/HJcn92bBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nN2NjZTYwZS01M2M0LTRkMjYtYmU1NC1jNzA2ODk2NmFkYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8Y7yB3+eGch4tZF4rUHwGf5HvEPrx91KzYVhVIpxs7OyH\n8JHLsg+HG/6Bb0h/dSQfPxQEHI6stgwp84O/BV0So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHzOQrvKBM8SpJy9Ma6zFP+wR\nTL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANCSiCIROMlBMjGRBPQNWFPhH3lJmH/eYHKu926L/nlrAiEAyXTuLMmb\n7TY1MUE2hFPC42SwK57ndU3hMclvnB5NBXM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWyrnWfQ6aMWqFmKmp+Is2CjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQzNzA1OWQtMzZhMy00ODkwLTk2N2ItYWU4ZmFiZGU1OGIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhODYyNzhkOS05NjVh\nLTQ3ODMtOGIyZS05ZDNmZDUyYmJmNGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASrHsaKQi2xgGR/FmpABGDN5vsBrHlEcnXkTgCBOfUjoela1JFIUQ/WyM2ijjWu\n2BjfopJiuR1fMtIqhwbcLj0Ho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVsqcoAqXolln4\nDuQbhaBgA5RiXTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAkc6jCkKrgjapolN62Wa0hBgYHbVHKmpytofLaPhy8vQIh\nAMN1VmE9Vem/+Ferw+MUMmk7elG3rn97Ln7fytA8d7Gv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3392", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3392` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISARf0CcuehAVTvd4jaVg9k4UBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyZjliZThkLWM3ZDEtNDQ2OS05NzdlLWZkNDliY2YyNTQ1MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM1ZWQ1ZGMtNzM4\nNS00MTAzLWFjMjgtOWI2ZmRiZDQ3NjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ6sWQDQiREcreeDTob3TGMiujxm4RzZacb1zPX78sgbYpfcHDdvDw2Msnal1\ncGoqWoEx6tIS7ogi9Uwl3SO2taOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrwnAroPE1DSYeS34ZZGjOCPfQNowHwYDVR0j\nBBgwFoAUeBbW3y/SHukHssLBSgh65ifX5SwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgWuaYDvkKIcp4imPzcxhwc3MCRRF19iagmqkZADd0Gr4CIBlXvP5+JR6k\nyzJxeWbVnlFIsxAgprc9cCF2rgkib7J7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAekM7ovz3bAfKi+IGXgdgJ4iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmY5YmU4ZC1jN2QxLTQ0NjktOTc3ZS1mZDQ5YmNmMjU0NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAqsnQ3D95NKVF/2sIXXbfw33C3PK9WVHYDKKbtUrasT8G\n0xouodnYW6G7QvL/YehAfIhQRDJW5vHPXhsxF7dpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBbW3y/SHukHssLBSgh65ifX\n5SwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMsO/uc7rqZNDb7+dYNZTmBhXJ2H0+zHryL4V/gUwLymAiEAipKhql0M\nSzWwUnp9q2S/pqoTUJW2wpTkjHA0ub/YYSI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASihKilmNhRW/WQJ6tVvdLnHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM1ZWQ1ZGMtNzM4NS00MTAzLWFjMjgtOWI2ZmRiZDQ3NjZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNWU3NzhjNi0wOGJh\nLTQwMGUtOGQzZC1hNDVkZmUwN2YwYWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATX0WzH7vVDiiJVQdQIoTSMw0DqAnasjTd7CY1rtxzEPbOuQ3hF21z5hxn86RDh\nI/vwlrFS9TFr743cxLWurxAUo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSvCcCug8TUNJh5\nLfhlkaM4I99A2jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAvIqsUwEuPVGiqX6YmMlowijppwFhYCujze5ICm7esMUC\nIGwDr6xC5Cx/nvvfkf2vrC2ZIBAzjsFtfnS3M+Y9nc4s\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3393", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3393` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAWudhDmoUO5yrRvWj+IuS77SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMzg4OTg2LTdkZDgtNDgxMS1iOTE2LWVlYzNmYmRiNmQwYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNhYzkwOTYtODRh\nMC00ZjhhLTlkODQtNmZlOGJjODllNmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnYn9vhDIowPMsc4qZ1Un5pZOW36mie0ndHMkoHqalz4EYfwCjMzYhFt2VUwN\nNHsA9RHAD88sOZMWCIvyzEtyT6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOAeDSLFpm2bnOKqoIc558rwKWWQwHwYDVR0j\nBBgwFoAUzb3yIxd3YLjFTiw+Q9mcw7X4sF4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgBmhMveUm8o4lZGv7HE9Rdvip1rBhIWR6HhwKlIEIob0CIQDOxzlxgbw6\nTt4j0mnrffIydJwOxfKgMI0vPjUIjfOh5A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa9kXJ2qK+J1UOJWOVaCWImlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDM4ODk4Ni03ZGQ4LTQ4MTEtYjkxNi1lZWMzZmJkYjZkMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjgOppGMcdAiecSVRuPscbPRpAdCDDPjTknlXYAxVeHqqb\n9dACBeRioz+H5g/KAG1KiPQsqSV+eXfFcsn11+gIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzb3yIxd3YLjFTiw+Q9mcw7X4\nsF4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANnwnyhFHlPd4KZBG3gayAaMBH7xSR2PBNteHRtVC1JDAiBQdIoSA29U\n3165gIS5VbW3VpvSWhkdipCr1qocX+hymw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATtM/sokB/hgm5lWXe/34SlBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNhYzkwOTYtODRhMC00ZjhhLTlkODQtNmZlOGJjODllNmY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYjExMGQ0Zi0xMWMx\nLTRhZjgtOTdiNi1lMzA5NTY4NDI3ZDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQLI1+oBi1ttQOBQ+gSr2gvpeQR0PmAYtRT4TYGdR4VOZGTcUkaLHcZEDMNEkvO\nj/Emx5fzRb74Xy22rDffAi/To3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4B4NIsWmbZuc4\nqqghznnyvApZZDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBG0bmcBin6Jyee5zm/F3sbhAXMXGo1XTZ/lRMc33QBbwIh\nAJn1WC280tqdsrJsvyxcgoT7YTSen1CF2EI80hcxFP+p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3394", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3394` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAXLORxNvIKd23T+PjWgjWiiVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4ODQ4NzYyLTNiZDAtNDY0My1iYjU5LTUzMzFlMTBjYzRkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGEzZmExYTUtMzgz\nMy00ZGUxLWFkMGQtNjNlNTU4ZGU4ZGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUqQAF4oRv55AcubIEUHUYK2dgmZ6HbYkdgANB3xbz0f8/9TzXmBe0T4sq6Lk\nGq10e4rED2o01OAHyaHoe0a/rqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJh6l9I6lJt+o0RYxhluQRxq6iK8wHwYDVR0j\nBBgwFoAU3tcIO6MVBBcqr1rb7zmseCPhYbAwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIGxrFzAgr7XZpdTXw9NruSBR6ASLKgjc9dxaPwliDLkRAiEA19Ro4V4W\n3AlzWfol7FLGZZZyLLCI0Of4DXyelfSPCME=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf2hUXb1XoMWwnBRwjSKeeNBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODg0ODc2Mi0zYmQwLTQ2NDMtYmI1OS01MzMxZTEwY2M0ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnB2w6WDI62kezWBRwE4Ra3R+Fde7CkbM/AnBB4QBXujLZ\nugdY3GoYcl/xtuGxtal3jDsgwvnDWHvHqEtoVvsso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3tcIO6MVBBcqr1rb7zmseCPh\nYbAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgclUJ9203xyN8s9+BSR7x+vMWmYY6neWR2HolNLTYtG8CIGjCSeArqq0a\npizF+RHh4xhprCA99agTDVSkWzTJSnk/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAQc3bLMfH4X+qXdgaeRglhLjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGEzZmExYTUtMzgzMy00ZGUxLWFkMGQtNjNlNTU4ZGU4ZGM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYTA1YTQ5NS1iYWNi\nLTQyYjItYTFhOS01ZjI2ODhlNjI4Y2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASJLj+UnoNY+3hCbKgkltqKjZh5YYV5wtA+jNEW8p8CoGrB4tvWuXErEZDhBHW2\nIxbkNQmieUuSK+1C4252R3dPo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQmHqX0jqUm36jR\nFjGGW5BHGrqIrzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBoxbajvARi6mrAXSBVzA8xZazfV9GYVnrnct3jDkUu1AIg\nTE3Y00tud5+vK/vk6AezZFlrbqGtmeL10TelNq1CmBY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3395", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3395` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAaCCLTfuHJcwGg2FS9314LYjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MDYyNWE2LTY1MzctNDg2OS1iMmRkLTYzZjA2MDE5ZGFkMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmEzODg1ZGYtZWUy\nYS00NGU0LWJmYjItNDNiNjZmOGZjNDQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEthJdZMlXEIjar8rp2UWKH0Xuo9Wb1aUMBigrMqCD9tzkXGRkFB7m1cgAzJSo\n324v1yAe7ufmHWKk96t6pNjF0KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhkhZaG71fl8iNYLq8naAxJsEQZEwHwYDVR0j\nBBgwFoAU7pQfMrxM2OLNYeeOUBaJ0gjrEr0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDU2OYxqGx1CFaouO2E/ebs9Ghf/cj7XeWSSlcDj\ndNvzAiEAtlnvU5cv18mHK4HxvkytsBbJu3bjnhn/FZ9nK6tv1ZA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATyEYdB/3jVSYhO6JtB9uxvXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDA2MjVhNi02NTM3LTQ4NjktYjJkZC02M2YwNjAxOWRhZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3ztZKxgaHYUxhhT6lULitMijKs27r4QoqQ0X/pqkN5DRD\ntHrbFFe49xoK2+/f0n8GTtcozU2NsRWHsJ1/98reo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7pQfMrxM2OLNYeeOUBaJ0gjr\nEr0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALBTeJUdltkXm97N/dheKzjiwI3RMCYbZV7Zkx8XAwWiAiEAuQaD4yHE\nv6075kVqWp7fTXvMFaLBrbc88Y4gT9EZa2Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQqwGaHsQmaeTb/DG2sFa9x1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmEzODg1ZGYtZWUyYS00NGU0LWJmYjItNDNiNjZmOGZjNDQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmZDk0ZWVkZi0yMGU3\nLTRiNzktYjY1Yi0wZTk3YzAzY2I2YjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQseVGcP8O5ogkB00x54keSVW0VcO1trS2DQ9rvK7rMWdme8P/tJ5sMONCFJub1\nnT5r0nL4x41tnQvcjaAFqSOIo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSGSFlobvV+XyI1\ngurydoDEmwRBkTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAwj1WR07ePA4ULOYakcJ+U/bkBcINVwtbNiGcdpYJSV8C\nIQDl+gG/f4lI6eye7hKTlDEO+3WqEibvb+OxzDC1BefU3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3396", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3396` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAc6JJUkAdMgZbOdwUmScS8gIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxMzlmZjgwLWZlNGMtNGJkMy04ZWE4LWZiNDBmZmZkY2UzMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM5NGQ3YjAtMzg2\nNi00MTMwLWExZmMtNmUxNGI0OTNhMDdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbljxEPtPTD94nW2UbRalCO+uhlADA+pKwdIV4a7qNLUcNNIN+hltA+FuNBmg\ntPP3H5smCl9isHVWkKG/Pj2N2qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvowdUiVlQqvsuM8nuwneNFdRN40wHwYDVR0j\nBBgwFoAUCCzQml/xffUzBoiiGNXmWG8+STMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCID6lDK5C7rcEAk9bgDgME5uCTAbQD4smN3znTF5A\n1j/CAiBGmHFmPJEczcStGJk5AieOpRDUaIcaRVNR4cKbja3ppw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXm8q45IOTsBw5wexuxpO3e5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTM5ZmY4MC1mZTRjLTRiZDMtOGVhOC1mYjQwZmZmZGNlMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTgKCvpO9CjbXV6oesNgpDwUn81RdAQX3zMgQLb+vaLqTd\nU5cPeWSRPdre5QmOPDwYlBzFU1c7G7ggECmNGurao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCCzQml/xffUzBoiiGNXmWG8+\nSTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANG3Ioq5bVEXV4lpMWl6mZs2jaLQc2bHk6MnukOU+ui2AiBf1gf14uVa\n2wRjP8ozsDvXiDQ7LkhFet1nfzHbvS0XEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfW3xb3kZnwYvU0ZUk0DTqanMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM5NGQ3YjAtMzg2Ni00MTMwLWExZmMtNmUxNGI0OTNhMDdhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMWEyOWRhYS03MTk2\nLTQ0ZTctOTQ1My1lNDc3YjYzNTMzZTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQwHidJUPlDvnxHn+YHfT1QuuqLgtnf6JA6x2U0x0qzA7/cdaFI5ySG1mbGIMqr\n6JD6l3ED4jUFiOFcVM4AlvbZo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+jB1SJWVCq+y4\nzye7Cd40V1E3jTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAhnAEwzvLfEL3kf2RJZS3G0pMhbVS2eJqbyp48D6I6w8C\nICYWDNOUETkagFWirO3fFXJiwcUgDFuxBLhBeHdo/pG3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3397", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3397` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAVklU/Yp35pu2mZPdIHsb2ooMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlZWQzMGIxLTY2YjMtNGU1My05ZjQxLWUwMmUzMzhiZjIxODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdiYzFhNmQtMTlj\nMC00MjQ4LWE1MjktY2NiMmE2MmRlNTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFqYcJbTXP0M5XPe0qNRehLXoUjxt75mL/12NgbqFX/mJ0hm+wEhd2hoe1IeM\nL++PY/1HkvSaxll6JuI2YF+PI6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeH3zRP/j4/9CeSqmBOD452o0A50wHwYDVR0j\nBBgwFoAUdH7gsik0IZg/BB2OyaIEU8QlGRowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQC1p5moUrvnY1WQhxAaTx80zEqHiMr9OgrsKzBsQnLHuAIh\nAOpv8R0nSP8tKoB34V/qly29JnwKpelFQLBylVVwJS8x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX2CyBGTliaKs4hO3pGqT9AMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZWVkMzBiMS02NmIzLTRlNTMtOWY0MS1lMDJlMzM4YmYyMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4IupjZ3NQ4r8XAZpmnFNpZptVlg71UOckBrzIZAsIUwMg\naFwCmK1sSuLFKMq7GIADJv9Lcjwd4WeuWFxE9Rowo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdH7gsik0IZg/BB2OyaIEU8Ql\nGRowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD7w3zTH3ZyOXOLBOXNzvsStY3wWLZ36j1P2NQqKopyQCIDqRmqo6iJwZ\nmuTPkp2B6j0i82wJZtuawF7SUg7btMXv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVYIlbuex0DdITclKL2EA1rHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdiYzFhNmQtMTljMC00MjQ4LWE1MjktY2NiMmE2MmRlNTRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNDRmNzZlNS1mMThj\nLTQzMDEtOWY3Mi0wZjY4YjFlNTIyMTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASql2OOvISlwq/HOIFHu+fTkpBQt2nSm2itZVBNMwBO6AePo3TsXkJG3O/YB1sb\n5w4txmVraE00jv1iWLYeeiPco3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4ffNE/+Pj/0J5\nKqYE4PjnajQDnTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBu7PDjdFnFS5ZGoTzepKWmTkN5cuQAByY08xRZCOXlaAIh\nAIApaXHaSB4X89x+OlwiPdFwBgJ40/863MyA1TVUEa+R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3398", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3398` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAfExbs00hu56TEgRJThMQzrbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwZThmNGE0LTRmN2UtNGJmNi1hNTliLTliOTAzODIyYzAzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjkyODYxOGYtOTFj\nNy00ZWU2LTllZDAtZTdkMjkwNGI2YzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOWBw5pRBkzHgr70IzPDtLUQB+lu+4ieOFCHD4B09rhrFhrojy+DC2MxgVU0I\nv97F7rHorHrNjEjS9ig5qMs/OaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUps5YZr/qWsT1Z6Zv7ueFEBu769swHwYDVR0j\nBBgwFoAUz9KvbPh8kFLYNcWuCtRtQntgFrswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCFfJvHoGc1wGSE6rEUIIAL6wJFkqSX\nX9JL1H3GShZspQIhAMTd2dgRBI9HHOoD/6NZKnMevSY+0z8/3LTOdVkdfaFZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY1txo67mJBdArPhJCDHvGjqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMGU4ZjRhNC00ZjdlLTRiZjYtYTU5Yi05YjkwMzgyMmMwM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARi/bHzS5D6AVZ2w68soOZcNJtvtdiHm3bh05u4rJJg4a6S\nCGKUPWVcbp3nAyBPd0TLklGLDJS02upEIw0LzrRTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz9KvbPh8kFLYNcWuCtRtQntg\nFrswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOePQlMNrZUBZIng+NHxBxBCxGKzuOutcsetAUaIJQ+LAiEAnkUMJ0pN\nvPq/kf9u6TNQGQ8o42uhphANmhwyQg0j8OY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARaJ/ZxXIv+vonLrZvTsoGzqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjkyODYxOGYtOTFjNy00ZWU2LTllZDAtZTdkMjkwNGI2YzRmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ODYwMjQzYi0xYjA2\nLTRlNmYtODVjMy1hOWNkMDliN2UwZGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS2KAnBuFfUgwdftuRKkt7koCC8juJ0UOYaJ+igZouqJatrRLUs7gbDzjmMCxGw\nm7ubXXJeuw9AsS21wQbz/Fl1o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmzlhmv+paxPVn\npm/u54UQG7vr2zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiB4q8KpHJxj/DoNG7dEY3yllHhpCKGQIm/5Pp9jMoUdQQIh\nAKhCXGZWzNFxDq+Ml20N4/+CjO/ZKrv1uPB5DkIhhhvx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3399", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3399` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbXI5ny3NRXCAvtD9bvFJ//+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiOTQ4MzU5LWViNGItNDY4ZS1iMDgzLTZjZGUwODAyMmIxNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGI2NGE1ZmEtNTQw\nNi00ODBmLTgyZDItZGM1NTFhMTRhMDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE68ynyg0N43wZGoXpS1SF7zgltQb88h/+Y7/RpCMDQMr08Rik0DU73fIZvHow\n6YSEG5CiUN6xFW+hMgOSN2mpuKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHhI6mHBnyQYcQC/2CZwH4sa5+akwHwYDVR0j\nBBgwFoAU5jyqu9qN95Z1qfQCFTMc4xkCTRMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBibWiqe+D5L1ZjsLK03LOZBkHa0WtQX\ndifVeLxHSBSDAiEAr3okVeM1urFWSqu0CJh2AR15mqcXRpF9EIgIrE/3XNU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVUGyU4z5T/zoW//Dqc5AcxQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjk0ODM1OS1lYjRiLTQ2OGUtYjA4My02Y2RlMDgwMjJiMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQSt6TQEFsafX2Dv8AHAUbI+1rqhlrJqin9fFv2hiya7MT\npENVLIwQbIdPjiVt06g8k3JCaS1dJJAseR3uLJDeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5jyqu9qN95Z1qfQCFTMc4xkC\nTRMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALGzAwA/u1R8+LQF77mkZczhYLezELxovnzwDdSJ9DM2AiBt/5rWgDeY\nBsm1/GsXw4ziSK/oorr0iqZMEbukt16G6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAULui5OgcpgwKi2o9u9cdotHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGI2NGE1ZmEtNTQwNi00ODBmLTgyZDItZGM1NTFhMTRhMDM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYmUwZmEyYy0wMDM0\nLTRiOGEtOGNmOC0zM2IyNzkyZTkwY2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT19vAy8jvX0Rz9oluPehI7a5HMTjDXPwp8utjKzYQOL/radvblYyBTN3IVRAEA\nz8Ux6SzbbjyCIFDnX4VK/y5Zo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQeEjqYcGfJBhxA\nL/YJnAfixrn5qTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiA1kA0Vb+M/PyxuQZY6Q7IbZ6GCd7506Btkzy3YbPem7gIg\ndbrU5txTmPl5Xp2Ond1o8ZQ8Ly10StuU8KYkTfg7wAY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3400", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3400` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAQEtxNOCoLpU14WoI+ZseyERMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5NzkxMDA2LTZlYmQtNGZlYy1hMzE2LWE5M2I1YzllZjliMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc5YWM5MDUtMDcx\nMi00N2E0LWI5M2ItODM2YTg0ZTYzODJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYMffjkNFeHCYqMcje6r5NhPr1iJTFpuJ0Hq2SREo4o/LhNtuuzbj5UIIurh8\njzgVaJNlh/WLa/XuiKJz05t9uaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMFzcpgqoiNE1iXsOvuNz97I+0QAwHwYDVR0j\nBBgwFoAUNHpszM6wyPX2tswwrjjDLVkRQYYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIFiv81HjgSF3\nUq76dU4pfwUQD6SWRicD8lUHEJt0mBxPAiAfm15cPeK2pzUTPCK9XibLuztrDwr5\nb7d+TNy0IHc1JA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQDDWjMWVpCxVQo4Lukrmjk9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTc5MTAwNi02ZWJkLTRmZWMtYTMxNi1hOTNiNWM5ZWY5YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4O4IJx+ZgOW6FAD2I0FylDX0h0FDdHSVQ7sJQYiG5n85q\nZYMx0FZlAkNoBbYMNeFerQCkDy9Vq8Y+pqAO0wLPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNHpszM6wyPX2tswwrjjDLVkR\nQYYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALKCUZA5Hlly+dg89IA9KesdXgW/2j23MY8qWVnB/tORAiBZ1730YMga\ntCYJbpt7oqPJLapshH+uJmSM7uF6kvew/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdpldSFFwwcah5GPvLF5OhckMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc5YWM5MDUtMDcxMi00N2E0LWI5M2ItODM2YTg0ZTYzODJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYmNiNzFjNy0wOWI0\nLTQxNWYtYjM2Mi01ZDFlY2JmMmUyNzIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARwzchBo7guMJLNpseGIui6AxChG9qJ1926eomRU+HKzC2FTbqovoZi8GY1WbXE\n1IKOQm3AHxdC7UfuRAyRqU+jo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQwXNymCqiI0TWJ\new6+43P3sj7RADAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiASK/YnZfVbpUv/BcvxzO4MDItH3lXd67W8NMPokNr3OwIh\nAITQbwsFp04+h8Qg82Bl03eCMAb3lA7ecAIPzNusI+Y2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3401", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3401` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAWoooEQiw+2EhLeS53paDfpEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlZjdmMTZkLTY5YzItNDBiMy04YmQyLTJjYWQ1MDU4OTdjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZiNDQ0YTctOTFk\nZi00OTM5LTgwOWMtMzhiNjM5M2Y3ZTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdcfmPmyq3dLRsZQom3NJ3qOuefmEwnu1zbDazRuFPBM+05UF/mqBBKSArD1h\nr1ZaiiZNoGD+CGhQhX8/6wTE3KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURqVFCySyn1ecZDIJyYMdPQsLhxYwHwYDVR0j\nBBgwFoAU2+fJEUCDGwJ0dKHHh8tU17vs16wwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAP4O5Mk6GKItyh74o6km/HCnC8cdi9vmeOO7bXUDH1XOAiEAm86T4+gB\n8ieYWQsxFLdxAlNLdU2rEkVhhvRTx7bYXKw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaFlibtfqdemvLbg6fFM4fBuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWY3ZjE2ZC02OWMyLTQwYjMtOGJkMi0yY2FkNTA1ODk3YzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5bqAWLl04bR/4HexmKvnOobbaQfPxdlMJzHQZBVgmAJ14\nmH4dbaNidf+3X6NBbb4FQPp6txavSKxZlwFyI0Zoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2+fJEUCDGwJ0dKHHh8tU17vs\n16wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJoX/LV4a/RHMUM9A6Nybs2haHHBdqARX3Uj7AU2lZUVAiAdDm+Vhqw3\nmWgZwnoZNL179K3y879MFFO5mdtq6wNdrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAX6gZB80sFGoBJ7nx5eSdukLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZiNDQ0YTctOTFkZi00OTM5LTgwOWMtMzhiNjM5M2Y3ZTliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2OGVmMTVmNi1mOTE3\nLTQzM2MtODRkNy1lNDBlZjRlY2I4NjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATblyr1Y6rx9T1wfHmtSwGDuGQT5XlYQcmf0XuigpFOaR8WV2w89uch/390L92a\nRYVGVBHPx8tDPcZYPdDOTDqfo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGpUULJLKfV5xk\nMgnJgx09CwuHFjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAFYctDxUFGDNGM496BBIMPyh2Y6oYTcZ5oiPeRcE3j+AIg\nEBsTjK15J+rNCJYmkaslJYPxauxABYnoW2AtBo12yHg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3402", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3402` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAatzgH+5PFOX1ZyBPamQfK0XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3OTJlNGUyLTFjMTktNDM4My04MjEzLWE1NTNmNDU4ZGI1MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg1MjYyMGMtNWJl\nNi00NTljLThlZTgtYzIwNGYwMGJmMTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUbUg9C+Y4HS74P/XbTr6phoLU0WVDFLaK0uvFxtwUGWcWexmSwkOJ3GHOqIk\n3vp9aVnoSZF9e0EOP8bXYTKzbqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU42Nw8/ciprv4hw8Z/6uebmI9h34wHwYDVR0j\nBBgwFoAUCCrNEf8tA8Rn8X8IwseJ9VklfU4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAM+nGPbipf/AtDDlw/zAzgATZl3f4qLaUllMCbOgfn6qAiBz65DCgBdU\n5nUoSodAU/0F3wG12qdw4ZBH2xJrL5cURg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXQFfP2tF65tV54udaivY4m+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzkyZTRlMi0xYzE5LTQzODMtODIxMy1hNTUzZjQ1OGRiNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVsyyn49+shuR7gkjR00EKPEbnz3Rzt3z2ecvvadlMIesA\nbtaKaBIRujwCrFBcsEdMLblKi7T5CahJBonoDB6Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCCrNEf8tA8Rn8X8IwseJ9Vkl\nfU4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKHb2qTO+7Z4lEsJvNjUpL2V+nnEnDkplt3RXqY3ERDQAiAOosmi2XXX\now4HaJx16+oQAgdt1kUUTjmlZLz8fXjdmw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASJ/NJJ4MVE8uRqAznwYEEuQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg1MjYyMGMtNWJlNi00NTljLThlZTgtYzIwNGYwMGJmMTQ4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMDU2ZTBhOC03YjQy\nLTRiZGMtODk0MC03Yjg4OTAwMWEzODYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ7tOc3v1A/v9F9g3CGHqWs92SusQ9QMZkR1dLfix+ADRLIpuLMkYKkGUkjnDFz\njXTlr/UHoOK2kG3KVhq7GwJQo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjY3Dz9yKmu/iH\nDxn/q55uYj2HfjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiA92b6ahEDAwdWJH213xe2qfuJZnxD3Xin8O//Y3jRZMAIg\ncr6kmjB6bGCb+4U/AqfvCtxlz6vz64LSFRIErqF8Ui8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3403", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3403` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdInI9PIpFxGf0JCc6op89D0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliMTFiMDM5LTkyM2ItNDE1NC04ZWM4LTg5Y2FjNTY4MTI4MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRlMjA2YmMtOTk2\nZi00NTM2LTlkYTYtNDViNmJiMTVmNTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtiVCrv+GT4zBsI8qOnE8zyXPU9HhZ9kqHBte5bDjPs7VN9fH8cPKqAw4NnW7\nOjM9HgUz3+Bf1lKUfeAT70fK9KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZJBKDnxQju4/EWTraucLdYWYFh0wHwYDVR0j\nBBgwFoAUkg7DKVmJdfmxVuN3sHyCDSw5iCwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIEzxJvo7eisJ7OBSsP4l24dLZouoE85VfjNHWAsJIgr6AiEA9YJdpf3p\n+QQAGIXuTO+BpUzoImSTXeBHP7iA3aVu7zk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcdJDl5Ew+bYFqV40aK5KTGGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjExYjAzOS05MjNiLTQxNTQtOGVjOC04OWNhYzU2ODEyODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLndNpFOpwpGGPM0eQ5e96lJQgMkKJA7f9ko9HTkq/qad+\nL9RqNVDqe1xzZIaTcLOU2ywwAg8RgjQlj6IozIrvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkg7DKVmJdfmxVuN3sHyCDSw5\niCwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP788uKRV56X4PvBXBcb0zX7VNKlWwUYlMigt/2xXIH8AiAIO9meREgN\nhIwGPBCKT8eZiR53CazCSxV5ha/rbVy3wA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISARZ7/hAvZlNFJJBccMlJuL+VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRlMjA2YmMtOTk2Zi00NTM2LTlkYTYtNDViNmJiMTVmNTVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZDljZjUxNy01YzZk\nLTQ4YzMtODkwNy00YTA2OTU1MmNiY2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARNDNIaYWTHibTepciFKVh4koTqKzvJtCtnA1zhNqBQiF4T1kMF+C7DB+rD5lXS\niPr0KUhq4upEyIYpiffGSxuno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRkkEoOfFCO7j8R\nZOtq5wt1hZgWHTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA8cjjTDi/gyONW+f9OBDAOpvricpqxn9CsUsgxvDof0UC\nIQDnxUF+7nfdffjK9BoaB9wB1rQNYlXZ0nTd23L0yVCkUQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3404", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3404` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAfhhtgcjuKaazvPfjlzSFI8BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiZWQ5MzFhLTYyMjgtNGRkMy1iZGUxLTlmMzhhMDAyYjI4NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY1YTNlYWQtMjVk\nMS00MjhlLTg0OTktYTVlNzUzMzMzNjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwVxO89r/GMPQa78v9ewcAsjPTLTCY0Jfa5S9/QGSepilG071P3eQ3e1mf+LI\ngBbjrdX19uKmXQRDwgUIT1FY86OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFMHJX7qs43jfdMWCun2mLBYj6wEwHwYDVR0j\nBBgwFoAUf4vuJ2DZCHGPOg59TDBx+Mpvpw4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCIkvLanw76mEcCLUFwk3rOztNzPe9rdwM49UHe\nTuuEbgIhAOhL0TmRTafngpQivlWd7O2COGfcIRrPoRCDqjE38WXx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf2Oezt5RV9jXd7TIcUpsi4bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmVkOTMxYS02MjI4LTRkZDMtYmRlMS05ZjM4YTAwMmIyODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWTbo0aXgRq/CTZdFff7KACMjNJvEUsZi1kseWHS0Mak5C\nb8SfoFX1cJ5nqzbMy9R0yBbJcWeRuMGvqhXRWBZdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf4vuJ2DZCHGPOg59TDBx+Mpv\npw4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKFZ1k+kvM6GkfRr1RR0CkOGC6P6jZR/tAXmFlukCCGuAiEAisplo6xH\nK2jbAetXDmaIAwvCZuCsumkK10mDnNS3ZkQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZxPAwSj6l0bjBY2FE+m3hoIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY1YTNlYWQtMjVkMS00MjhlLTg0OTktYTVlNzUzMzMzNjZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNGUyYzI0YS0yODMw\nLTRhOTEtOWY3ZC0yNzI3NDhlNGY5ODIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQwF4IRee8h6UqaE93k+xRv2r5e8pIhjNejzhsnQbiJnIVllGMaHi25ky/zwhjG\nY459x6wrHgFMO4rrJwMjly3mo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQUwclfuqzjeN90\nxYK6faYsFiPrATAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAmlZlM1uc0M5SJm0sL5KMw4sfeiqeRQ4y7Dg+0bIQeCoC\nIQDQxt43QLFTddXnn/yinQnqJ1OL4YKWvbEBpLfrTWfkMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3405", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3405` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAaecLOGBoiI9HiAQrq+Phd+8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxZmJkNTc3LTg2ZDgtNGU0Yy1iNGIzLTRhYTE2ZTdiYTdiMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ2MThiOTEtMmYz\nNi00NmE3LTg5MjgtZDk2MTIwMmM3ZGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf+iCA3Lau1FX5QPPo6O96MncwE/bNPYBj5Zhfrm4hLqXlIbrj8oiqwzM9J9V\nk/2DD8f4VlBDqwJJ65WVjHXwZqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBgOeIpBg2HsU5eDym85gXMDAnJIwHwYDVR0j\nBBgwFoAUGqiNYnW6ytomh7XbEf4gJfPUQvAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDcgYBQcieotQc+z3YE/STtsfbSy5CbWXm1YQur\n3wHqGQIhAOuKo9ptuAF0o6VhJnkKjvz3Fzw1NZGRb/ydxCdk3Ebq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeVYr/0TWsx4M2NMsVrkFC30MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWZiZDU3Ny04NmQ4LTRlNGMtYjRiMy00YWExNmU3YmE3YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1cnmZm1ko7F6JJe/fK5tepOFrq0vbeYxiB2/17TjkXvKa\nCGLrTggJc/i4+jZmq38RigHW3YTXCm5Zf9/fKuToo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGqiNYnW6ytomh7XbEf4gJfPU\nQvAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPeKXRd2NaUeDvpEcpu29GaK7Iq9Ucc3EdgO9f6syku3AiA4hFd4catY\na7OcnmiuhckknpobXUoEFjKGFV5fH6f92g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARtYuvyLrmlmPojx9skRxBdiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ2MThiOTEtMmYzNi00NmE3LTg5MjgtZDk2MTIwMmM3ZGEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OTAxYTJlNC1mMzRj\nLTQ4OGItOWJkYi0wYmNiZjg2YzA0MTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARPJrap/gb6qj4Ha00xvLTZflFHlrS1+SCr/QqSoHQx4iCqCN+jkCFcKTHfXGCO\nEzgtohmazTdU4Vq2+VSQpaapo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQGA54ikGDYexTl\n4PKbzmBcwMCckjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAy1u5COffQZMOO9fNm8jEJK/UDX3Rdci66UsViUArjqAC\nIDdypEFAvGYYdo9Mz0/ru32BtwWPal3GDvg7MM/zSGwI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3406", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3406` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAf07CWCddyNoLFxS9j1EkKQUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMWQwYjJkLWIxYzQtNGZhYi05ZjRhLTU5MzY3YzQ4ZWQ1OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ2MTBiMDgtZDVh\nOC00NTNkLWI0MDctMjViODAwM2YxODg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElNA8873LoQ5HLzeClqY0WpYHL8K7nYL03SF0hLMaVWEetNoPMTpwY5JxKJCJ\nwxIVoI6eas6wKv2oB5PuRHuVYaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxG7pQfMnSAL0xCB4Xe65FwvUA3AwHwYDVR0j\nBBgwFoAUXzHXoCExBkG0fYT0KraenbiMPv0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDqETyXCk+QHU2spnJum/SlPHJ6kcWQIM3DgMlhhywkxgIh\nAKrDm3T0BNcznEt48HaTUGXslyTW5jzaQml2TjFnBhHi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfg5hcrwg+yhn2+T1+Zqey7KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDFkMGIyZC1iMWM0LTRmYWItOWY0YS01OTM2N2M0OGVkNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAufiVGyCvRBZeOt+MODUKwT1dNS8J4okEcH6uD5lZ0Qnh\nFZnWhBNU34jq99YXNC/k6kiPpKG0A/9jW0q4RlO5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXzHXoCExBkG0fYT0KraenbiM\nPv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ+jNGDWdpxVpNfV0277vKPIIeXKgVkJZcXw8bOYeqX+AiAI7XraiDLJ\nPXGsjI5ME7TE9TIBMAqsa+noDKDscGTMdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAV5B4Wg2wYegNiXtvBuTb71WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ2MTBiMDgtZDVhOC00NTNkLWI0MDctMjViODAwM2YxODg1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZTVkMDNiYi1lYmU5\nLTQ0YzItODYwZi0yMWJhZjI1OGFjMjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARtlbmc3mmFjK3N3pBuROnKxT0SgO2th7ZdCiGG8tR0opU9qeW/szhIshJa+BXB\n5FQ8BcRIRm5kvw0mqunnCrgEo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTEbulB8ydIAvTE\nIHhd7rkXC9QDcDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAyxZ8DFUcIlsI02kE+jXXQxz1KNc7+IJWLtSIWZ1iXMkC\nIE7niYHaz6VtRUCUv75LOgWu6ubobRPu3FnWdUwgDBVF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3407", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3407` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAU32X0PoJHm+sT/5oQdYgmbFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5YTM2NzZhLTVmYmQtNGRkZS1hMGJhLTA1YjI4NzVkYTNmYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ3YzEzNTAtNWQy\nOC00YThkLWFiZGItOWZmZWUxZTJmMTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM/5GzQ/gdPz5YJK3r+F+Lisr6Q1INY3iOjdNSNK/3BZXkc3p9zk51lQufd3/\nWnDxC5YPmnlBJ2dgwROnF6vIIaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSEyJYnyStpG9V83phzRu9Z4hh2EwHwYDVR0j\nBBgwFoAUKkGIzO113qySosvdAssaBdctnJkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIG3I+vVE6P/m+CvI2+ljKJrzz5MgRKnK\nZy7FqJbVGAyKAiBrbC2b6/iCRRtP0+18sGGSsnsUP2wQSTTuWWBp2oLuRw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa4NGcfZVDPdB6OW2gL8iX9DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWEzNjc2YS01ZmJkLTRkZGUtYTBiYS0wNWIyODc1ZGEzZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTkSU1ktNo3xri638aVC5q9QbxPV3FUqtaCdYkvn6EJ5QM\neFew9TFC7jGckjHSddosrg2sdLmTgzDheyaGFVfMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKkGIzO113qySosvdAssaBdct\nnJkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL4FZvpJG9588WpbSYj6n/RLZNPZFrKxYwFubtYk3tVqAiEAm25LWxEp\nfEN4OpFWalkPisoo4ou+524RD1hlLPqpQL4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAeY0284jkO4D2q0UFmymGF7RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ3YzEzNTAtNWQyOC00YThkLWFiZGItOWZmZWUxZTJmMTkzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNWIwZmJiYS0zZTJm\nLTRlZmQtYTQ3OS1jMmE5NGZiMjZlNDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT1ElLekFqHBfKJ7+SeX7Nz7MTQqO51WXfjZXp7tTPEzvJTqPuGH5Dnf8vSyvHm\n4oF3xwRDtMUIeT/YnNWbyF8do3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRITIlifJK2kb1X\nzemHNG71niGHYTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA6au0HS++TmCbZ3ah9D7+x29r9vTg0zmLcpO3tmehxhIC\nIFk5jid2So8s6iKwoszqQTseSlHzFGteDtTK3vYEZUZ5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3408", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3408` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAc/PYa7b2+GXVsLUsWpHFazGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjYzI3NzM4LTIxZDAtNGI4YS04MzQwLWU3MmVlOWVhZjQxYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFmMTdjNGYtZjk0\nMy00MmRlLWJmYTEtZDUwZGYzMTQzNGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE064ZCI0OlNtyd4mTeYtVSunEt+JSgtzj0IPgdYAuFGIw2O1bPHJ32mjB2C9V\nI0UPD2uQsL9vFb3tk4hwWpKgEqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1t9aeWvDhc6bdrgYQ++FnJv2sHIwHwYDVR0j\nBBgwFoAU2hNHE9CGgrV3F3qcASWdsWK12VIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIE1SNhIbuRDtB1bJHBreP7FWlcKoG8am\nAb7QtDDUswEMAiBg8+JFdxqOcnSOtWyew3l9dGn/sn+HiSBbLE/lh29WDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaEt+nMd0jC8sbBFqe4gStM4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2MyNzczOC0yMWQwLTRiOGEtODM0MC1lNzJlZTllYWY0MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0gRTRxNhKXWA1fCw+vA0hKBbgNL+RE4GLYMINWi9iBTUa\nePGhWiTm/Cka1kfk6gciOxL0CJbLsqT8hidBAfxYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2hNHE9CGgrV3F3qcASWdsWK1\n2VIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVixiw5YjHdHxjL5pfNAnpoFZwVlfOAhTNbVTeW0xfUwCIQCU5kTx5qRP\nVMj/s9erjxaYiis9zGrn0upFjT/Pwtwg3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAbZcyocnGpCwbdgUa3TYXLBIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFmMTdjNGYtZjk0My00MmRlLWJmYTEtZDUwZGYzMTQzNGZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYzZlZjQ1Ni00M2M0\nLTQzNzAtODliZS1jMTMxMWM5NjA4YWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3hqi69FsmkIcmWzYXukrzBgFns4n/ceGcRP+J/6xXvsSZmj5uecqWC263zT7Q\neD0H1VRnDwBug0ZCLgfo8ABZo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTW31p5a8OFzpt2\nuBhD74Wcm/awcjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAmK1YOe6Mq2tAByQCwgpzr63GKDBlUZ9zKgBhs3PLe2cC\nIQCjJaDFDUvVBJQ+7T92WKxONrhaLNg3gu2C02/aED5ZMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3409", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3409` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWxg+/5ShFFMulleIvZPf4uTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZWU3ODhiLWY4MjMtNDg1NS1iNTU4LWNiYzIwNmI0NjUyNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA0MTU1ODQtMWU5\nNS00YzJiLThjYWQtZWU4ZTk2M2FiMGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaZQFlUeEjznpl1yvzdU+NlWybddNvww44AjlkvfAT2BSH7ZuLSV4k+ZJRmeX\nT1d6ieKv7RHWofBefvHBXSfEU6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN3O4QsKMquPBpexEUqzouMBdPG8MB8GA1UdIwQY\nMBaAFBnpUdHsci21M/71HqbEereYmdH5MAoGCCqGSM49BAMCA0cAMEQCIDJpYSEj\ni6jGKIQ5sQnMkyDWxJW1PHDih8EKsuVNi7fcAiAxWl9xzoz085b2CZP0noHrZO81\nsvVD+xqZxx17cvtjpw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbkxx4mJkOFkZf/ysn8xNYirMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWVlNzg4Yi1mODIzLTQ4NTUtYjU1OC1jYmMyMDZiNDY1MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROxaG91EbNH14T4ZdbKopdno/hJpu5KqyWvPrx7Ux5Dcxx\nOIHx5F+6ZMCHcuA8sX3Cm8Jvo5uORTGHdeSDuj/qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGelR0exyLbUz/vUepsR6t5iZ\n0fkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOg9sBbGJTQLLnW6BaSKYMwePYSYAU9OORsRT8ulYcREAiB2b+5WgigK\n+E//N8EXoUvAJJ2VRybu12MB21CWOc34Hg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAcCxKIa4zN3vaBP5MNWn5EGWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA0MTU1ODQtMWU5NS00YzJiLThjYWQtZWU4ZTk2M2FiMGZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZGQzZWNkYy02YWRm\nLTQ5ZTMtYTg2Yy01YTJlYjYwNTVkNmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR2Ntc0x1gSImS9cWXDVdgIti6XjQGPNHQqDnJ7TM13F4EpvOExbaAtGaZwZPbU\n6SeKxy9vGXrZAUFizBHz6Azlo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTdzuELCjKrjwaX\nsRFKs6LjAXTxvDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgJ6lyyuX3zLPA8iCwHx9b38TmWpMKfPsZXHK2Nuq1qfgCIGttaotK\n41w9QaNxVPlNCB4TYIjZT6ZoeMQw6epZFoKD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3410", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3410` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAc32+7Yhq5jl57OxPtQz74OWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwYmNiM2ViLTE1ODQtNGJhMC1iOTc4LTk4ZmQxMDUxOWRkNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YzZWU5ZTAtYTA4\nYS00ZGE3LWJhMGYtNmQ2Y2ViNjA4OWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4XY8zLgD1f20Tmow6fmBJekoKDmiPRiTi77UoTqNjmBCViY2dVnerQO2CIvd\ni+kATdQxpOGCXAHDzBZefP48o6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKxeL5tUiZ5ZsNV3JhumWwX22MVlMB8GA1UdIwQY\nMBaAFIKWLfUDbl3nJbsPPtGS2PeKXl3+MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvht/T2pnjzs4HEGGG11fVi+cZoovLCEe\n8P5texyz9FkCIQDCK0LKd60+msgmknIJ2Z1nDX7b8OkqahhXY2bieBpnGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVH2fSJxzUkRrazl7yriA2ZfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGJjYjNlYi0xNTg0LTRiYTAtYjk3OC05OGZkMTA1MTlkZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARESrhG73+RwUgpx6/Q9N0zn3Aq/32UZq1hTd+rP51zSstL\nZnxAorq/O9vYRGd1I+us+Fzi703NKO07AEO73AOWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgpYt9QNuXecluw8+0ZLY94pe\nXf4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPAVS+Qbvu5I+MmjvVROiB4GAhn/utL0GKX5ykLmjfoIAiAfYSqqT4e2\nvIqtF0q9zWXKe418Z7WacJlPbcWSxd6L9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAb4SegbEl4y9UgDJduJllN2YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YzZWU5ZTAtYTA4YS00ZGE3LWJhMGYtNmQ2Y2ViNjA4OWNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4MzJjMjcxZS0yYjFk\nLTQzODMtYjY3My1hMGY4ODNhZThmMzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATdPuJd6b9ck+S3uHWOD+2v6py2DGXlNIU5nMVWIUMfrvUOUktSrB5tpaw6RLBE\ncj2MNSzrsKKAM+Q96Yic4WJWo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSsXi+bVImeWbDV\ndyYbplsF9tjFZTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgQ/ZJfOs4Q0VyJxcaMT/KICuAXQoY3yABo1A8IGU9yG4CIEmXZ3Jz\nUZtWj6DAaH6YN+scdyGMBHAN1WrDV6ryMEk9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3411", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3411` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWj1c7MgJ7mZLoINBQjKLV1WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyM2M3MTJiLTUxYmMtNDEwNC1hNWQ2LTdkOGIxYjUxM2U3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I1ZjJhOWMtMjM5\nMi00MDIxLWI0YTktM2UwMzRhYmRjNDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuIzfoTr30ok/GFOJW/yvy8l3y84eI0qT+DjgUkpV96/B4ENklWT2BziTYzN1\nsF2XAoKQMnYLqDhV3InXjrbND6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPQzYyRY/tzltycD6EDGD8wgpluKMB8GA1UdIwQY\nMBaAFMPJP2G3vGtRRPUKi1blJsV0qkAuMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBM+WJcX2IRuCgFNSiI/5OZf/x5oMnBpXlI\nERIudsNQSQIhAINQYGwMkNpvzuqAiKxTk+7cC1c6W1hvfksWcGgztofR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASY0xnPqU23m69F1tv/fGslRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjNjNzEyYi01MWJjLTQxMDQtYTVkNi03ZDhiMWI1MTNlNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxq5HxJ9jFjntZrmovhvYp+l8poH9pS2KIB+2NFQRcsx9P\nzWo7FwGQAXudew6aaEforg1yQLz1SD1lUTI24BFro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw8k/Ybe8a1FE9QqLVuUmxXSq\nQC4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ+JW1Sfcv4Ne0AtfUtCTCF5lKmUxIxMUW8LPQ/O23IvAiEAss9boSNx\n9SdWwsbnf51OpZ6i84ul666xzTiOfJanfPg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAXsUEgmMUassquHVcAqlOyXBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I1ZjJhOWMtMjM5Mi00MDIxLWI0YTktM2UwMzRhYmRjNDhlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNjU0YmUzZC0wMmVl\nLTQ4YTYtYmM1My01NDNkOTEzNWIzNTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASQpbjkGC8wnBjKSY/JKl1TyDE4JA5oOguLz0S8/pBHVqxAivXtdXj9j9qI5ko8\nunvZdyNXLFU7Nu37WWV/mTX6o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT0M2MkWP7c5bcn\nA+hAxg/MIKZbijAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgeRE15mPA7m1z8P1Lro8pi63qHWCbfJGqrsA0ewCq8iMCIQCemj2f\nz9fC7Nh7lUWmFNCeQ4bFKERFyGYD/GoGpEn4nw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3412", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3412` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAY7JiQ4lZNDECs7vXnCsq+81MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzZjcwOWZjLTU5M2ItNDQwMS1hZWVmLTE0MzA4MGE3MTUwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFlNTA5YjktZjRj\nYi00OWJmLWE4MDctMjY2MzM3N2QxNmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE069wFtds/+AZEougDkCDGiM30wxx8+mPopWhnti3mQEXC5leQb7X8N6c3IsG\nTqivSPTmXARFHNPYRBwsfOLhjaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS16+4Sai/79Rk+aePOeOVKInk2ezAfBgNVHSME\nGDAWgBQMDlfiLJ3JVkoG9pymWXj9dEm7PzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGIfW/kbz8IeyS80mZgQIQmxfSDDrk8K\nYTUGakzn+aBWAiBJzYe2mOiZnAMq12k4Aw3T7NoaBiZee+gSJtWaURkSTg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAffRdXz8Vm0m+q7y/gVoCC2qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2Y3MDlmYy01OTNiLTQ0MDEtYWVlZi0xNDMwODBhNzE1MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjChCZeDBTqq1Hz/NnVzb6+0oO8CUxAzsO1fo+pH+yvB+q\nN/stIyPblQTcWxB2sf1mfQH22orudqhwkA6zVHBLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDA5X4iydyVZKBvacpll4/XRJ\nuz8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTZ4q/qUqrv+7cY8zsaSufUaq0bpt9eC25KYUNgkNdtsCIHkLMzU8lOax\nvoBaGOTxvSqE8qGEY2YOOaJQCesPYMUo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISARgiXiPgKmYu6f2+OcXAPlQTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFlNTA5YjktZjRjYi00OWJmLWE4MDctMjY2MzM3N2QxNmRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZDBkMzg1NC03OTIy\nLTRlNmYtYTBmNi1kMjcyMjYyN2JlYjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQhVhdqLiZnIoVZObIz+OaCkww/5C3P0GxuqmUI7V42LKnHFWv+RPDSNmyJUbpy\nrf5eJDGJX1oPGywYZkOSYyXWo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS16+4Sai/79Rk+\naePOeOVKInk2ezAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgB9b8e7ODhcMj9Tk/2DuWvc4MSThrv9SQ4t9MoDbxOTUCICs/kv2w\nqWfe/3fH2brx4PoU6MRiBOTQJQwyrCoPI5Bu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3413", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3413` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAXCJ7bL/Lz/iwURQgbz6ZjNDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2ZWNiZDFiLTAzNjgtNGEzNS05OTc1LTgzMDE0ODI1ZDBhMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ0MmRlNTktOGU4\nYy00OTlmLWIxNjQtNjVjZGI5MzdiMWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG1rGlVuWK+G1qjJe4/8YgWva+96DHj35od5MPexNLI9GLdcnDcFdOISzwb+V\n/fRUXO0HRzYEwEe6cSEIs4U0W6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyN30Iyfa5Mz2xTE0yZ1urQrpqvgwHwYDVR0j\nBBgwFoAUyzPmaLs4vCDUW0p6coF69KqJt4MwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiB9ja9oS2kvAmgK\nNRic0UgWumHH813L5POygtsdQoYIrgIhANN1uDoJTR48TYV/Bu6ZxHi6ZE5AuK7l\ntERr4wH2upel\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARN4fUv0woFP5NwjM23wyEl5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNmVjYmQxYi0wMzY4LTRhMzUtOTk3NS04MzAxNDgyNWQwYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/ZpZYtn8w5XglzEJzhjFdq0QcsDhtkgIjKh8kbJklflUU\nIV569ALRtYnoBMRvRJv1vnkCPQSL14zNJWM4sqnio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyzPmaLs4vCDUW0p6coF69KqJ\nt4MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc3p8d5U+0vY0z8I/H6FE3YbeWMj9M9wv/NY9EZC0FkMCIAy0nqSCSsEg\nEtZQ1B+KfoJztfs62tPZY6q4rAhXjWrM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAYcvVKydqp2BVzhZc/DsHUtTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ0MmRlNTktOGU4Yy00OTlmLWIxNjQtNjVjZGI5MzdiMWZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNTdjODlhOS04NDA1\nLTRjM2YtYTViNS1kNGI0MDUyOWNlN2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARf98i5glhZPPhJP1gJIs7oAZWUqTHDEV427cAouXY6m9AkZsoCo4lENlYO2CBJ\n4vN3XxoS2vccfQYa42YvQLEHo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTI3fQjJ9rkzPbF\nMTTJnW6tCumq+DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgQMVhr7aHHkXBe0udkpwkDUiGoLOf1a6pOIrev4VfqdQCIFiad+og\nVMoY0Mk53Fp3xsAoQWP86DFcAQR0GoT5xjGl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3414", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3414` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAXpjA9rH35gj9kw9pUzMg7CQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0OTg5NGNiLTk5YWUtNDkzNC05NDIzLTM2MDI1MGEzMmIwNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2YwZTdmOGQtMTQx\nNS00ODQ1LTg1MGEtZTM0YTY4MzFiNWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe7XsPZFsy8M6sbUENrKTItuINDn8rbah80Y2QPdj2wxoczL0pQw/uqVOW1oK\nHIPH0Pnv5+kHb9yE+Z4D2uVqeaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4UAxg2SEgq53HSqXloSL9NJr188wHwYDVR0j\nBBgwFoAUdB/yDaDkkGaLOApqerh3j4Ce+AkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA4xFZLd/0NjyG\nBJqK8Bcyp1yYc7Ont3wnvT5gK7srkZICIDf4W80tvI2GLP/3thu79Uhwf9bKCIm1\nL5OWIj1B5i5R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQLyAo0Yzk28aLBqFdCaTgUpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDk4OTRjYi05OWFlLTQ5MzQtOTQyMy0zNjAyNTBhMzJiMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1tXylF6Dx+yCllmwVOBQJgRivpGPwISql4Ev+KfiC35ve\nvm7B0mQYP8puFwnPINAvLjR0K8DEPMnuYsdeCnEFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdB/yDaDkkGaLOApqerh3j4Ce\n+AkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbt38/+A4C4JiP3wR+CyBEnGx46g7naZEMzMcHwwEm4gCIDE1LUILiCVq\nmz6uiJbGskt2cVXftwyEst1A89qaO7H8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAaz/DRkKPmt74za+eyh4qbYcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2YwZTdmOGQtMTQxNS00ODQ1LTg1MGEtZTM0YTY4MzFiNWM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NzRjMTUxYi0zZmQ5\nLTRjODQtOTBhMi0xNmM2M2I0NTdhNTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATt3R3EUHLNApSgDCZiKJ7XByo91T6zvimZMI5qck2ZJk268jSL8wPDj03CBWE7\nAFqLQ8QICeT+LwwFeGtAzBxNo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBThQDGDZISCrncd\nKpeWhIv00mvXzzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAJtNl/IoyvVygs0nRfR6LreJ5yQeU/DNTka9NvkkRv4qAiA1j2Yp\nQYNwnanMuK8A9JtDkFCae2DiRHss5v3SwT4iLg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3415", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3415` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAdDFvTlXOb/DmBwpk0bIDEuhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjNTUyNjMzLWU4MjAtNGU0Ni04NzUwLTYzNzFhYWI0NjlhNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhhZGUyZDgtNTli\nOC00MDZkLWI0ODAtOWE0YThmYzgwZTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7SHbZ4C2eTrudvKUBzrwYGTVrsQuyWdhXVEXaQw+UKcr6MaDk/mdphqeaiem\nLBFLUBz4NLnc3g/BjDjb/7H51qOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMw1itXWz7IHf7UYioOYyKatwFAswHwYDVR0j\nBBgwFoAU+ZK0ap/LKM4sQJikbV9wDSiEexUwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAq1nylCZwZiUINnbtCqvl\nzFgPGwyxhrjsBRWpR9MOCvcCIQDbs6djb9qirqaGbGCTkq3PYl5Vff6jmeAgRrjr\n6l7MTw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfNFEUDiOMb5LII/fjlc18uWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzU1MjYzMy1lODIwLTRlNDYtODc1MC02MzcxYWFiNDY5YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0VFYAQF7SDNlpzGho8MOJTl2ieNZntDOPPp4Ok4lNxCgT\nA9gjJxzgER6NPuVeXoLwFigIt8psZs4ScaSboe9Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+ZK0ap/LKM4sQJikbV9wDSiE\nexUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJTIQR0v+RWPTh4+eHzrdaCTjOhoNQeTCl897jnKjws8CIQC6G/DN4S+O\nyYJi5XIenOWRPLki6BgETa+HrbLWsinmRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAUwqBXz5EenklX0WnA2iICquMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhhZGUyZDgtNTliOC00MDZkLWI0ODAtOWE0YThmYzgwZTE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZWIwZWU1YS1kNDc5\nLTRiN2QtYmY1Yy1kMjk1MmI1ODM0NTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQWgpI3MpX89SDFOt2IIu8byU3oFldV+LPns93WyoAFoBsw/6TJYsyd3uyz1JGv\n5vOSmurBPvrKfOu4XQ0zDaXno3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzDWK1dbPsgd/t\nRiKg5jIpq3AUCzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAKmGO7IucUB8xLix+OVAt5tyKOUjxLxYvrXfddohghPLAiAzIiGi\nv91BOkhH7yEgeOQpw523iV5I2jgI2wn9qEsn3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3416", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3416` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAUR7ypTzkvRpSfwBPPY54fyzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZTIzNWFlLTJkNTMtNDc1ZC04YjMxLWNmNWNlOTNlZWEyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTllMDliZGQtMjRk\nMi00NjNjLThiZDAtYWJkOTFhN2YxYjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl6Yn3YPnqKQLc8iZAnsjAGQ2+cqtHuuKEYiHyUQK4mAzV5cumupP5QpTX/GN\nbkC9gxWRFrmKP7Y/amh+r7P9NqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU25gLQXMc8x758XQnD7Gbs9gmEOgwHwYDVR0j\nBBgwFoAUljYwcIV1H0vp+62+t6fXJVCovrQwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBsvpmq\na5HGmjD5g5vtmCIcStivNzXWqkzcZXEm0gbuRwIhAJPzUvGJVFrdgryQzXl414ej\n9tRM/TpwciNMVM6A4r4B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfa50lG5y08EBts2dl6z5oa4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGUyMzVhZS0yZDUzLTQ3NWQtOGIzMS1jZjVjZTkzZWVhMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdbtrpaPhSX+8TphGxAB/OTzuUgfN2s9LnhYLTaGcocLd7\nayThXUamVZnzP1nBGrcOa8ZuHySIRvje9XO1MqKqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUljYwcIV1H0vp+62+t6fXJVCo\nvrQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBANi0PhIXyr9mDbFy3qNt/+0mpBqraVcKPmTbM3Ygp8CIAWH1Lsv8G9F\nuIgMw/MKN+jeXvGvgltK0IZQs9YIe63/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISASeQgp/eGbZliH4tRPKCqQ8hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTllMDliZGQtMjRkMi00NjNjLThiZDAtYWJkOTFhN2YxYjY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMWFlOWU0ZC05ZjFi\nLTRkYTUtYWY0Mi0wNjkxYWM4ZTUyMzIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATXn0otU4Pro9ogkYbsatrWeFKMzg/WJFZrhbRad96tRz/GjVME4jQjSp0HoAdY\napHW9uL70udu4fu0RXjkh6HHo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTbmAtBcxzzHvnx\ndCcPsZuz2CYQ6DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAPQOe1yyM+5N/iHjkprAEv3RjpmJZJGOpNEF0jsxj2T1AiBA9y+M\n3xUQE7cODyrvQ5+SVjaH4kHBnWyR0g0+Q2puTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3417", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3417` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISATK84mloa7MZbYryyYql+lfJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1NWI0OWFmLWFhNTYtNGQ5MS04NWMwLWM1ZjZlZGM2N2YwNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY4ZjMyNjEtYTJi\nYi00NjdiLWExNTgtMjI5ZTJjYzhkZDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1ez5AleRYxgGodW6xoM405YBbC3OwLFLwaXLFYz5G8NaAkoQN1KkduAb4pD5\n9gz9TymLtqIUtQmTZFQ2x9T4V6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp5L3QK166llsZfTKeGkRv9jVW3YwHwYDVR0j\nBBgwFoAUmILebAn8lgLNf0wMfJz8mgqYBNowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA7377\nUl/cMpB0HcVt/HSjJRnW8BRRTviEbI7xrs/nm2YCIQC1dkRZIAPviqXTS1yo1hcF\nsh6hRGzsZgNJ49OfK8RtYg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAalgBfDCYGGUNteh3Howw6d9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTViNDlhZi1hYTU2LTRkOTEtODVjMC1jNWY2ZWRjNjdmMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzl3puZaoklsdJdzB0PBZwdifs/atussSWUH8tERdQ/8KW\nxxIO8x5Bz/MLojBzrDbZePp+AI5X5abtqFReSrpmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmILebAn8lgLNf0wMfJz8mgqY\nBNowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANABr3XrWL2H32M4RTcfBTZ+uCAxdN+PhQoQYyi8E1unAiBwXEHEzXZU\nUgAr+j0G02qef9o59vjzY8aWxdSHKxCgsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAfWDOYfntiJNIaQ1rpvUZkTrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY4ZjMyNjEtYTJiYi00NjdiLWExNTgtMjI5ZTJjYzhkZDA4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMDIwNDhhNC1iZTM1\nLTRlY2EtYjJmYi0yMjYyOTQwYjQ5MTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARYM/bJDOn9VvHHd0eqJ0x75M5H36MTNnRNXtyV5CfxoNoTVHqt9gLneNJE8UVY\nIaktg3fPwQF0C77KL3/Fs1hgo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnkvdArXrqWWxl\n9Mp4aRG/2NVbdjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgd5iBQOzZwk6DLFG+ZC1xXbgYwxo1H91Zn4owovy6TugCIQDRI2rM\n37NLExLI/6XfOWtgeMXpjjwAj2nfexuOZGQagA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3418", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3418` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYP4fHANyu+aOydaDcWmdE57MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2Y2Y3NzBmLWM2NWQtNGVlYy1iNzVlLTBlODI2NzZiMjBjOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI3MDJjZDctOWQ4\nNS00MGMwLWEwYTItYTJmNjRlOGFkMDk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZiVRmM5Iisya0CIbHQ59DBciDCXPyYsO+VLk4iUUodBF0VIf3QwlBbhlxayH\noORBw+8ef5bhFlYbZtekIrKnE6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBlkMUquiCx/t8K67ial44nj+FdfMB8GA1UdIwQY\nMBaAFJrHAyJH5zQ/DYIX1nzyzjj1PIZ9MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAm2ncGPannRQPn3Ec6pgCCqUonpO5GvCo\nPgXRAZmjnGsCIDRpgCX925+kZmp/mOXnJpL/D2BIDJ0LmGgSess/IlRw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXPK8srKozyEjA7e62yCWi/MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNmNmNzcwZi1jNjVkLTRlZWMtYjc1ZS0wZTgyNjc2YjIwYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5kT9SKiSendiwQaIKyS+k9/1rSR7MHzZNGM6nrMANdwRv\nN+1EWs7fl1OKfrA7c822CGs5INVo6io++e0MNDDmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmscDIkfnND8NghfWfPLOOPU8\nhn0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNSdbwGxVcd1x8dqyy0c6AZvLxgZjjyyDHOszYxpHcPICIATBnnMoYM+O\nU6pIqLkFvLX1xWW0n4LLyLwlN/PbSnHE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAQiON/VZvUnBHlzWtL3px08oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI3MDJjZDctOWQ4NS00MGMwLWEwYTItYTJmNjRlOGFkMDk5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMDBlMDhmNi1iYmU1\nLTQxZGUtYWQ0ZS02ZjA1NTQxMDUwNzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARjz7Q/mTNcha8yuYs6yvgJ8xJIGaJDQxfdBS4y5Muf8q7peq+2aOirgkJPC8uD\n/55SFr7ssqWVhhmVPjoviaQDo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZZDFKrogsf7fC\nuu4mpeOJ4/hXXzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgLYUaxvFwwIxKcmlq7MlzS/sAsiLz0wE059nbf2Xsu0gCIES/2GBf\n5RBnbc2u6QJIbhQagGZETwK4aJWbASc2efuX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3419", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3419` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAfA9N3gFiBctxAvST82nXnIvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1YTM2NGE4LTIzY2QtNDIyNi1iYWY1LTY4ZGNmNmJkYjU0NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjViY2NkYzAtOTky\nOS00OGFjLWI1ZGUtMzcwOGYwODM5YjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjc7sDIFsjOiErve7MZWkcffCSwAxIbrCGzVgsu9xbkHJrdyXKYTqLhJpDRAF\np5qqQ7RT8rmx8VTvW5yZEkL6RaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7uPp+MI6zMSv5HI7rnqHejon6uUwHwYDVR0j\nBBgwFoAUrh0wLCk/RP3LH3pOXp19YyIU4oEwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANF5ZNIlE37m\nPA4GbGmJtKTjLNV02lSF5uu7rhJeLTCWAiARzKQK+nXg70RlK3KtdQAXXyoEItHR\n6sBSkkdale2ZRw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXwPhuRGUgN48gCEEPISYgRQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNWEzNjRhOC0yM2NkLTQyMjYtYmFmNS02OGRjZjZiZGI1NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzYnxHPAbM1I70y0/6yqm8AQ/+qWOZoDGR0Zr+o877eHa2\nPz12Nd0YxyV3sSjNfBkD3Yyz8AE6jVUxSbBoLt/oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrh0wLCk/RP3LH3pOXp19YyIU\n4oEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKRUT71ARvY8t1l7xVq13d5vH70W2GAfpkfviCzq3AwECIAznF5KEbbk5\n+EPz0tRPQxZpwwpTgJEKeHovyTajrgda\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAQ5ZNjrS7U6p+8fO5gt+03cbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjViY2NkYzAtOTkyOS00OGFjLWI1ZGUtMzcwOGYwODM5YjI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMDU4ZjI3ZC03Y2Ux\nLTQxM2MtYmMzMC0zNWI2ZjdhNjUwNDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAReBZ9TAuHOhgYJk8TGRukr7VETWBzNoTYTeOYXLtXgeqx1hcQ18R4LT2y+S1tW\nt/t+KiYgcN2I905rxqD1NV6To3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTu4+n4wjrMxK/k\ncjuueod6Oifq5TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgFdhrxL9G0KOAK0J/ueJ6EHorWA2kd7NBGSkshWzaIx8CIBsUZEoh\ndN1DsOXdc4DUoNRy1PlyIBe9tuKign63yCtA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3420", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3420` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASeckZY+H9DalGPBJ2Oe24h6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiNzJiYTgwLTljZmQtNGI2Mi04YzVjLWU1OWEyOTlhNjYyZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjcxYTUwZDItOWU1\nMC00ZDBhLTg1YWMtMzUzZGExYTZhNmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdN9nZGdMNU5BfY71R6H522qOL+Ox8wIaOq+e/p7Tr2w/p6vBfhMgO7D8L1gG\nKF7XZ07MHpu+oJgUTC8+EytadKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF42bUCxskltC7Gyq1eyX+I2uFaQwHwYDVR0j\nBBgwFoAUmAwd4fl3z+ax7uGFcnBtEcBqMU4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIge0pHkLbJ/iLQ\n8WHawRwmKbR02W4b9KBOaYMf9UWp2r0CIQCcRnctnvRg5MOfvavhFMQlPVy7R4VL\nCO23P1oxHH9UKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXW9vjwdu0XB+Q2Wh8d20rRKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjcyYmE4MC05Y2ZkLTRiNjItOGM1Yy1lNTlhMjk5YTY2MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpCFexy1A4v+LAIcq3jyglZr02wVErXbsrZ/WxemV2ip+w\ne+BO8myn668bLNtXHjEoYlr0yUAXZU2qmqVYBm/Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmAwd4fl3z+ax7uGFcnBtEcBq\nMU4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMuYiqYWuTYCOlpwdm5I/Di8dlAuGsnIgJ65sQ5WT1fJAiEAuBVR4Jsh\nEvIl+XWUwCWIuuplwmtmBiwxq1fXQYw/Hmk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISASedzMiYF7AOL0q5Ch0P6ky1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjcxYTUwZDItOWU1MC00ZDBhLTg1YWMtMzUzZGExYTZhNmFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyOGI3MzdhNC02MGU3\nLTRkMGMtOGY3MC1kYWI3YWUyY2UwZjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQNNQVMHfEpkIGtB49hlW+52slmaDn/Z+Z3B108s/du9/qrE28t/sHuMIsIDBCt\nyDkU7w1YYtnlnDPuua5MBKnFo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXjZtQLGySW0Ls\nbKrV7Jf4ja4VpDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAIP9YDBX2eTL7SvsHbEHTfw8B2S7y2NLGc4f/gOe46TdAiBSawx/\n5ecUyEox+pWcTzJJMUV+3kApBgFN91z20izgZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3421", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3421` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAd7Gnd9nGkIgZgimYqyEZgMmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhMDFlODNlLTM4YzItNGU0MS1iZjA2LTY5NTlhZDdlNWE0MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmExNzBmNWYtZTFj\nOC00MTk4LWFjMDUtOGQ2YTZmNGZmNmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhVXF/NUszkMROGYc/4SL6266HuqZ+4xYOc4IDTfsCG7T0aCcrmbGdsngyx5x\nC4XA8/A2UaonAvlssnhwHvDnXKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDyOOZAN2Ldn2wbNDsllE0FZat4cwHwYDVR0j\nBBgwFoAU6/t5hrilzdSGQQZmcEAbmXunyGcwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCC72BhaIm/\nr/f0yuQKge8R+SscLTj0Z6rhD7nZcYYOeAIhAJlJH6mgIF6AT32E7lVPfYOVhEfh\ngMf1RVzox/pSHo0b\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU0CKabTYaILe6nivRKjWiaDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTAxZTgzZS0zOGMyLTRlNDEtYmYwNi02OTU5YWQ3ZTVhNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/idnU2CN9bRCiOlyEV6dVrsH0L9Mz3rkNKIjUotiUoJ4a\nEV1BtXc34TMYnfSXmimgrm/+Xa0lo6dpmFmabY/do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6/t5hrilzdSGQQZmcEAbmXun\nyGcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIkhwHKJYNq+2WKD7CyBxWnYpS3v0wkdTOivglDiLK9QCIQCFMthqdMzN\nyreM9qIbWfUK0bL0cKinM/tCkJJZD7/AQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAcIqpsdgmsSvniCfy8gEsP68MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmExNzBmNWYtZTFjOC00MTk4LWFjMDUtOGQ2YTZmNGZmNmQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYWM1NzMwMi02MjRj\nLTQ5MzUtYjZiYy01ZjhlMzg4YmM1ZWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT3840CMm59PRsVbP63LoGOTRJFxoTHpo/Y0BvNCk4CFe7SuXHhzk+gHYHMXg2e\nsyinCPF64sd2eTCwsBHr//qfo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPI45kA3Yt2fbB\ns0OyWUTQVlq3hzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAMENYrLtW5YUAektwTUPFhlp+nV3ZOLG7cbwOc4Bb1jYAiBqy62+\ncmUKxQL7sd0FiqAjLRjnyTHueOYtYaKUTI3thA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3422", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3422` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAW3+JcWb5yKbiothp7KlNZ1ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2Nzc4NTY2LWE1MWEtNDZjYS05ZTlhLTQyNmMyN2UyODM0MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQzOGU5YmUtMDE2\nNS00NGI2LWExNjItM2MyOGFkYjc3MTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt30hVGo0YEmuIbiJYbebki/avUHVKXK+M/uKv+sTNDzT8VErpmHQeLfye4Nw\neyjCrDeT8g/0PS0vm3Bu0LdoQ6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGFY8HSQfiCzz791Ibwi7bRGH/3MwHwYDVR0j\nBBgwFoAU1eh/ZHit4apFQTdxPnjxPIazJ6kwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGQmG9rabxYLG1VGVW5t2Euj1FO1WPLNWRPge93KpLAwAiEA3TklC9tzqRoY\nCWEFac8yhFCCsSFttPggJu94MD79ACY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa7N0XJV/c2A/az7CoesPG9yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjc3ODU2Ni1hNTFhLTQ2Y2EtOWU5YS00MjZjMjdlMjgzNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4E9q13mA3I0ZG0ZQcgXSXsYq2qqBOone/BNW3P8kxULiL\nR2DnEr3pGC4OK94Vs8YasDvVofqJWHBIRCF7We22o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1eh/ZHit4apFQTdxPnjxPIaz\nJ6kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMvJ7QpT91JqYWeWbzwRj+GWnhH6feweaII53Cjw4BgRAiAJdG13gOMf\nQBRGup1Ug/G1EmFPsYC7OoodcyGRR8sJ7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAdLXEB99jUcGvDjnH7XpdLGvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQzOGU5YmUtMDE2NS00NGI2LWExNjItM2MyOGFkYjc3MTg3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZWYyMjk0Yy1lZDFl\nLTQxNWMtYjI3YS0yMmMwMDM3NGY3OTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATGXwBcnaaj4mKqzy5VT16FFanNShJ9sfOw/zxBFLVy0/CWSh2zeMJ3tgmtEOMq\nNBt4o2GmfhDfiwb52HRLzYc8o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQYVjwdJB+ILPPv\n3UhvCLttEYf/czAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAPS/qnXgAvrbuyoWiF3Y20D9YzEGKNypRyf6/xW6Sap0AiBtT3sD\n14fPUVfauOdShMD5qDQEH50pYHmNA13fn9goaA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3423", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3423` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZ8K81WSzZHz2SDugyXHzC1GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjYzRmYTFjLTgwNTgtNDc4Yi1iMDViLTk0NmIyODcyMDRmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWU4YTczODQtZDMy\nOC00YTk5LTg2NzEtMTUwNTFhZGFjMWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA+BM6GYewuCtif4F7+raaJ/Qy8LtvEL1ilq6IfRCe5MCz2Qlh3duQkp/PAHL\nPOWWMF9VfkBRVnaSppj6WFa0S6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSkXMzADzCLaccbZ0E+azKGriHs0wHwYDVR0j\nBBgwFoAUwk3d1zRXKjF1Iv8cfy9RTEK+UdEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAbcW0iFSbfdp1ODYkCcWp6HnKAPnABrhzp1tU8L4TIHAiEAuGgIeI/UvtIK\nh586e/I4994FuxCyUAcjVrMzYMPYjlM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW2Y2E949mkLqQKt3HVc+qg6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2M0ZmExYy04MDU4LTQ3OGItYjA1Yi05NDZiMjg3MjA0ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8YGMrxhMaszo6CMwRCesgfkIgnp/BD+lKsJDRyqfzIfTo\nxlQITjwHiCShu/6HyJHg1NnenOlQjTXChuAtpptHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwk3d1zRXKjF1Iv8cfy9RTEK+\nUdEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcIBEjNOetJRwvnPQiPLbNsCzsMFsa2vJ4dP5HuaSY3MCIQCRXvDWtzN9\nOKOgi0Zk5IesGOuywb1wO73sdE6XGNKe/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAR1OVtyA7Dfas0cvMmQq+fl2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWU4YTczODQtZDMyOC00YTk5LTg2NzEtMTUwNTFhZGFjMWFkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYTI0YmY2NC1jMzc0\nLTQ3MWYtOWRhMC1jMDFhMTFkYWMwM2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQkhzaIhV0cxSYKKHl7DB6NqPZ4MthKxQ3i3O9t/Iuhu/JbLb6pPiUW0IpGtK+n\nEAas4EZDEth+FvT28TCOKe5Do3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKRczMAPMItpxx\ntnQT5rMoauIezTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAM3WcuLRZCCYXKjiJ4tYXf7uiLSqnnNpunSnx+n7KoWEAiEAk3M+\nUGLnyz2gkKVJy0XuuHgZ+PYe8cJv8KJVw5LQvk0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3424", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3424` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAUhJE5PqMIa9dVMq+OZLkTrHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjMzIwOWRkLWZjZDktNDVlOC1hYWUzLTc0MzFiMWU3NzU5YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzUzZTU0NjctOTE1\nMy00NjMzLTg4MDQtYjE2ZDVkMmY0ZDZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO164FXPhVYe09bdki8wQm9unh1Z0I4+KqraSjR6bv5/p79k22lBn3iQX8eBQ\nriySHcIZAvidvdrutKsv63t0XaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzOX8zpj5r9PGIetYfcY/ESD/tuUwHwYDVR0j\nBBgwFoAUdv2lxM4vZWvnq2oc9209575Mx9kwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGtr\ngyg5kk0TMxK7hp0Z3p/bGuTTQjItjTL8eaTNud6WAiEAoCAjT6ISBRcDo7IrbcHG\nt6y3Zv8LAf6kEt9BozBJGtw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVD2b2b587fbc6+7QyogI84RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzMyMDlkZC1mY2Q5LTQ1ZTgtYWFlMy03NDMxYjFlNzc1OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/DO5jsQyKh/bPRL6QrxdK83oJHM7GVSKrLMDixXPW5d61\ndHFNhALb0M0s/h0uozMgSNAYEjVpV4DGLTSHlJlro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdv2lxM4vZWvnq2oc9209575M\nx9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANp6CLz9my4RRnkfV3XAn8YKSTzGLJcYEoegPdH1g26tAiEA1DaO5tyG\nAlBlIgGaNZulGeX4n45ojGuX71KHCpoXuuw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISASJLJSPQyGNeIaPK4o8KHVhjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzUzZTU0NjctOTE1My00NjMzLTg4MDQtYjE2ZDVkMmY0ZDZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZTQ1YTRiNy1hYTc2\nLTQ4ZmItYmQzYi00NmY0YTA2YzNjM2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARZeuDwlVJGuuT2RkoYP4Tq5pi6spOxFr+2PYMwpm8dMDZ4QPFiUb55pGAS3ilx\nXKxlXZuNpQNpS+HgNcuvbX7Ro3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTM5fzOmPmv08Yh\n61h9xj8RIP+25TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAJgDUtknotcidt7NUfmrrh/L3TYeprf+gYHmdvVdd1SzAiEA6Zn/\nATHt83WlOpDluxqyrbsfXu+CezCUYPHEnY4elnA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3425", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3425` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAUzUPHt4S0yOjDeAOsfsWSpyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjOGI3NWZjLTg3NWEtNDE0MS1iZTE5LTA2NmE2OTRiZjFiOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWYyZWIyZTMtNmYy\nNS00MTNlLWJjYTUtMmQ0YTdmYjgyYmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwbpdqb3L4i8JwEFa0twPQ/iY78GXU0AxJbOuqf7Ajg7cs8DET4S32xdJHDOa\nDXm0HlZ7KSstV1hgh42O/VzU8aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhgPkp3lzpLGQI1Cv31Fg93fFcHUwHwYDVR0j\nBBgwFoAUOg3/VmEVQN/Vx9RhYKbSy1dxrpkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIAEmIINZ33hOlhO0Kd2MZ2N89iUG/ZyClXhbrQUP0+HZAiAtmZAn\nzCQrIDMF0/vfsjzg2VHE8hNS57GT1KgJsze6yQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdtDOSNSUPqdGR+6+1EP/i0MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzhiNzVmYy04NzVhLTQxNDEtYmUxOS0wNjZhNjk0YmYxYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT72tEJZQMDvN6AXzlWJBEe2bKNdnhVImHPlBuolhJPdjfv\nQRcSQEiAbi8lLjZGSh7qLRGfg41fudJNg/UykYDJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOg3/VmEVQN/Vx9RhYKbSy1dx\nrpkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIV+uxJ2ZZwyVdpGiXafiSE0aJnuO6amCfQ1Mq5tq8OcAiEA+jQWJHsY\nj0jpfRCEo5zC1l/1z5Of23bZCNPbE9BogiA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAcXPHlC5kYJZb7LWd5F3RINaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWYyZWIyZTMtNmYyNS00MTNlLWJjYTUtMmQ0YTdmYjgyYmQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYTYyZDVhZC05M2Y0\nLTRiODYtYWYyOC1mYTJkZmUyNDdkNmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQgwdJNhy9fyvWYnzpweq7R/wiBqA88cei+8eicsOV1mxEtWCcikGAXWlzIp7ej\nl2liLWQ+X3sq4aqZZnq23rHwo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSGA+SneXOksZAj\nUK/fUWD3d8VwdTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgS8su4fg9KnwwG/QENvRe4O1+b6Hvm6m0kwG+rSy6G0oCIQD1bKiN\n/D9L5Yiqqr0ryPT0TgY6KTOoOn3+3zgJ8Op9jA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3426", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3426` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAb4VJCA8hrV3A1FOa1QCgpVZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkYTdlNTAxLWFhNDgtNDE3NS04MTYyLTkyOTRiODczNDUzNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ4OGRmODktZjVl\nYS00MjNjLWIxZGEtOTJiODRkYzMyYzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEefcMTz/G4TIRRz/1tNMYTE4gNxAT5iZhARvONWoiOupG6c0YBLlOvUc1pvR1\nP5JFo64v8onpk/K3EriMv3ajW6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE+Yo3kzbhs1w9A2yZypGdGgQ7YkwHwYDVR0j\nBBgwFoAUdxV7N3y1IHXs8yyv+Y8N2dgxyDswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDImW0qcGcaL5X/a2sd67rVMnDqT0q8FpFn22A0l1xUGgIgTwYi\nNtK4dZFBTvOKU+t31q7EWiYAyx1G/7DOwE7OQt8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaVLAsk4y5H2LH+XWk+zEV4HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGE3ZTUwMS1hYTQ4LTQxNzUtODE2Mi05Mjk0Yjg3MzQ1MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATc3xcTgCD17oGtnLXDpJwKXTNd8de+0O7ytv5/VM9YK8gy\nzYBf7V9yFeIJ2dREDT0T+1Uz919DEIegHwziA9xjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdxV7N3y1IHXs8yyv+Y8N2dgx\nyDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANOjmdNRC4Pem3CnafBpkGVXUcpdi2pJhu+xIQXLEDi1AiAY/koclm5s\nXx+dy5VdDXIEKcO8Gg4KCjZMeZfxOZbeQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAYWdR8W7pnoV4vAbONSwZD/oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ4OGRmODktZjVlYS00MjNjLWIxZGEtOTJiODRkYzMyYzIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZTBlZTlkYy05MDE4\nLTRhZTMtYTU4My1jYzVhZDkxZjczNDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQJxY/muL25+OF7bjKvGfO9jvuSDLmsau3gWsTI8eq7Xei3cY1/6BATVg1pXBLd\njHp52naFVTUHHc8diPPdiSb5o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQT5ijeTNuGzXD0\nDbJnKkZ0aBDtiTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAOB9VCyEhNgD/IIAbpARWiCtZNAf5b2cAwQGfyzP6/iWAiEAjozg\nY0xiE7Ug5hNLVKUg39/cVSE0SHMso2LWOEDt7hs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3427", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3427` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVOeMwUve5r/UfrpQnP3t4dNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkN2NkYmJlLTM2OGQtNGVmOC1iMGJkLTE5ZjMzNTU2NTFkMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJhMGVmMjMtZjQ0\nNi00ODA1LWIwMWQtZWRmYzg0YmJhMTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO+fZMIUmVizfDK4VxAsDayJG78TzmofRX+1KGKR1jfUaAM94nOIYkydVxQyy\nahWLisMabDEJr/cYS6XxOgu+66N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIfv8vmJdunikyWV6ylU9c1LQHcMMB8GA1UdIwQY\nMBaAFOnIHQ0KvIIdU4zixL94OGyghYtTMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA2UJccmnsufcFDpwgxc36BquE0LP0IpPhm\nBwr6NeEB1wIhAIUpcenZqh54qqVnQ2kcpfIDqUBDJBvgH024fie9tezl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcyBryVlmEO+soh2t5AuPa5ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDdjZGJiZS0zNjhkLTRlZjgtYjBiZC0xOWYzMzU1NjUxZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEzQYoumHNdce5Q/DhiOAc5QjV/63wzaeYJ0iy0XZvPixh\nMadzVAkx6696jJ8/B4GLQ6g3HqMGQFFMAVscT+z9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6cgdDQq8gh1TjOLEv3g4bKCF\ni1MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOy1+aP+NF9LsZW20Bhg57QUbFSe4jc5BatbSptCgeyRAiBC/X4NiIse\nCFIKVcx8R2o7n04uQiCwzJhYHLM+aDQXTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAUuBMXWZbBhe8xj7311+SJvWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJhMGVmMjMtZjQ0Ni00ODA1LWIwMWQtZWRmYzg0YmJhMTRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYzdlYjE2Mi0yZjdi\nLTQwMTctYmE5ZS05MzdiODhiM2IxYTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASyR5Jt1ecB2aZ8YhPth2VrBtBvNi49YU2JlQrQzpfMfS7FFScl/xLZ92Yqb+FR\nEBfX87leYCT9XmV3Yqc2musAo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSH7/L5iXbp4pMl\nlespVPXNS0B3DDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgQvYPIqnhvaW6c9MlhfHXWqivMyrjB5NqxxOE/7HJmHMCIHh5ul3m\nl7L4Fav6hvpNsCycEeMcu7iZmftRRBxcww+E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3428", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3428` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAQfHQwcLovAeld2QXEd7Zwt8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5NTFjYzI5LTg3NDctNDY3Ny05ZTQyLTAwZDg1NjNjNmUxOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhjNzgwNGUtYThl\nMi00YzBjLTkwMmItZGM1YzhmYTY3ODgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnzRzN0rKJDyht+E7pkgUrp7Xjh6AQtSvMoXVpPS48THpLhXdL/kpgqi+Xi3U\n3ri4XUC2eI57EH+Kehxx40AznaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNRAIXukiitU/xnFQNyPbwjgYZPkwHwYDVR0j\nBBgwFoAUk5h8Qsanr07eT/LG+aB/WZDw5DEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgCD5NGGOz6yWQ\ntI8Kw+q/YgzWOUDtA8HkRhz5Y5EvkJoCIATqf5KUZdPvOCn5K7Q1JsZn46LFkiNt\nvwk6byyWul+m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWLviHZSX/CRrMlfrsR+qqDuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTUxY2MyOS04NzQ3LTQ2NzctOWU0Mi0wMGQ4NTYzYzZlMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcLBjj6VC05qEjgN+vf3oJCP8inFLC6WYacR/hV4rpBkT9\nmc7FwrpH4EzI4MrDw8MT8FdDAgvsUNijXAfnkWFEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk5h8Qsanr07eT/LG+aB/WZDw\n5DEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOwVqsDjrm5uKtxOHNHszxZyloj7FOMBuqjiddWDxLSLAiBhT4clkzay\nW5FGj+IIN1es6lKX28upL1PeTDKI5ZGqIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAdTFcHZA6EcmO2iNtWLPnEZuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhjNzgwNGUtYThlMi00YzBjLTkwMmItZGM1YzhmYTY3ODgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNTQ1MzFjNy02Yzcy\nLTQ1NmUtYmU2ZC0yNDVhMmQyOGQwMGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARzdPkMoEy/rtjZrJ9gZdgy7WpQkvvWCwXpB1EOD+BN1xXPq4073eddeI7GK73z\nBKdWsHceqrAKQ14Hd4vnrQ1Jo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ1EAhe6SKK1T/G\ncVA3I9vCOBhk+TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgCzgJ6Keecw0/t7+Zy8CdPmj5yLw5O/0q9osW2Y46nVkCIBeTQPsj\nKD5/MoDsz65Sc5Jb37SQhx2lJusbvIpeX5rf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3429", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3429` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAfDL9Cbl37gOlHtZtCuxQ8mNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0NmY3OWU2LWNiMWMtNGFlNy1iMjc4LTgzYmE1YzhmZmNlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWEzNGU4NmMtMWYy\nNS00NGQ0LWJjMjctN2EyZGI0MjFlMGVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzXXGhQn2BEvqjGCJBqZ3YEkeXIfqCDixf6f67if8Rr8VGmMO9FDs81qccmmW\no8AJdQw5NASD4DdVIOx+Q2K4+KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW8bC87dKJKEYK6OQUG3brlGb9TUwHwYDVR0j\nBBgwFoAUGisSyIOvF1qQfaiVid02jVudKqYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPoZeUrvu61L\nHiDL8/2HLMX5SVWtOMlNIQWmVFQRPbVEAiEAuFlPKrYhQwserglj2VhMGgDEVekZ\n7RvdZLOpGxE/AEg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT5BWgkp78ZOSwuAIp8R9uvpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDZmNzllNi1jYjFjLTRhZTctYjI3OC04M2JhNWM4ZmZjZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgsNHivjj5uHvM9IlUyvh3GU31kbtMJcy59cwXpO+h4jJQ\n5iT6HNQti5rGwi75shhKdlj8BS24zdbkvfnoDny0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGisSyIOvF1qQfaiVid02jVud\nKqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUwcNoc7qs5E5PNjE5m9/3nQNe4qiQ8UDKvJI/P/ETkgCIQD4hv3Odmdn\na2dormjCGdd5FSgR1+dXVrpEz9IFsu7YgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAR0fr5pYCMmuLJxix/QsNSJ7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWEzNGU4NmMtMWYyNS00NGQ0LWJjMjctN2EyZGI0MjFlMGVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5OWZmNzY3OS1hNWE0\nLTRjMmItOWRjMS00MGJjOWE1NTA3ZDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS9uQnWkvPSuDf5WYjIDZew+s8wi32JTZU9pdy6y0QSpPbBT2No5voc4bBbvTAC\ncDpG/qrmh+m8TT8xDyzFwVBLo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRbxsLzt0okoRgr\no5BQbduuUZv1NTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgLWd1sSQKfJVp2fKhJXZDZmOTlVqH4t1jUtHvVefjcZkCIQDuxL87\nxnD4i3BBC+Qt5EGu4xXxQyHOH+j7i7nXD7ZK9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3430", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3430` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAXa3LVPKPiuTCCHjWkhboeECMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2MGRhMDYzLTcyYjItNGM4ZS1hNWFjLWNhYTU0MmM5NGVmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU5YjNkZmEtODJk\nOS00NTYxLWIyZDItODJlZGQwYWFlNjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbkcVh95W8kG9k7RQtK9pVcXPv+b7JnS7eXJay2uXgKX/OrN3iYRcLUHqqeaj\nFn6GT5ctPDeVBmKaMNa9KrrOoKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7t0UMlyQtzs+1lBN7Xbn0z6JSkAwHwYDVR0j\nBBgwFoAUXwspFFPvDQXXLdBEjb3kewezgicwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC+Lvl2XlZ4\nprOiN/QFw35oblheWtW34c6VsA3ChgK2cwIhAN5Cx405oR2W2NYlCqSVDoiH99np\nkOJdgJiOLHsSPj0S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX1875hBKjaxtkNXZlU7i9rWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjBkYTA2My03MmIyLTRjOGUtYTVhYy1jYWE1NDJjOTRlZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjQT49sXaM/yly1Mj3CNBMy1V4lfv9qQyHsFtGWBeNB6gE\nPKNZV2fWWeBwAcqyvd502w4eP2kH9FKbF2d6G4YPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXwspFFPvDQXXLdBEjb3kewez\ngicwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLpAFCIpcQ/gmC7ZmH2NhhyOC7L6jOqpY8BgRmLvRk70CIQDZiv6xU1m/\nyx1YHr0zMflGDvWXUHTwZ/1k4e5UsirpAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAe8CAKI73jJIbgGwoP0AfpwJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU5YjNkZmEtODJkOS00NTYxLWIyZDItODJlZGQwYWFlNjdhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmZjY3ZWE3MC1iOWVk\nLTRmOWEtYmE5Mi0zZmYzYmZlMzE0NGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATd63Vs77imPUBuh0u3tSWNa8Lo+2rzXuq5RzdH0RfeGxe0gW/ccK/E6lb0IRjI\nht26tFFmFDIuqj35NleQqPvOo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTu3RQyXJC3Oz7W\nUE3tdufTPolKQDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgUlsd8AGgQGVZvZqkizDf+kaeAfzVYDx+ZDpk31xVODwCIGXE66ve\nQ27Jj3NeCpJYm9g2i2rQziYn15YatL7uMz3N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3431", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3431` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZM35GI6uPueKLfo7RO4zzwTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1YjgwNjgwLWEyOGQtNGI4NS04MmYyLWZkNzcwZDNkZDcyYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA4ODMzZjMtY2Uy\nMS00MGZjLWE4OGQtZmY0NzZhYjVmOTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEidsaKObXsWPR2gzN85Dx9bRbU1EL6EJTtYw839TyHUDeeTSnQtJ1DLkb9mep\nR31pFZXd1zWfuRiBhPCvqRNdsqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6yYS7xnIby1aPvMk9Aq+bvMqvegwHwYDVR0j\nBBgwFoAUOGFETstTIte/YCa1uB9ZBYrTMFwwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBIykH7dQjYZZoXB5R7spucF6WxHKeYAvAG/0nDqa/ccAiEAuD7vYfrm1Wis\nlvjYgFcASwE4mwn9bEdEuvbhDWvb3sg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW/kvf9mdWxZakUi0q/K+SSfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNWI4MDY4MC1hMjhkLTRiODUtODJmMi1mZDc3MGQzZGQ3MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARL7J4j0XtooUeSl1mxDYxJ307zDhEmN7Et5vI7gsmLXYcN\nLdyuIGSsVGhX908fRMeKoLoOQE/nMzSpMBGZkgTVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOGFETstTIte/YCa1uB9ZBYrT\nMFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAk/92BsK0TWoGYw83/yi3q3S67J4pHILRAB5qF6ZXYMCIAybpDDgrRb0\nTd0Td8CE46BAbP+wik9v1H4aZ2Eqi4LQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAYLXQ6DxCmnrIUtKdJMLmkvhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA4ODMzZjMtY2UyMS00MGZjLWE4OGQtZmY0NzZhYjVmOTdjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYmQzOGIyMi01Zjdi\nLTQzMGUtOTM1Yi0wYTVjNzllN2M4ZWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARqCzzK0VLhAFNkgnivGCMFlLeMZir+j2jkr8z25WboaXq5Lj54n5bMFByQXHl4\n6XlEOX4B3oETEsVnmn7/voo7o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTrJhLvGchvLVo+\n8yT0Cr5u8yq96DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAMcvfXwZG2ejQ3AIgbefzw2KZUmgmZrARqeU5RgCVSOiAiBz6p10\nXjtuSUdVZX+B1rI/jppwSlzocU3a2nhnsXZamw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3432", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3432` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdkUR5dARaHpCeCFRb1wkFSxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkOWEyNTY1LWE1ZjItNGMzNS05MDA2LWJlNGRkYzA0OWRjNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc4MThlZTgtY2I5\nMy00YzkwLWJjZGUtMTFhZjkyNjM2YjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1CthOiUBJ/NdVzjc/ya2xPE+C5vRXUlu+SyXsO14uwQf2tIK1/gbFpFnX2Sh\n2wzM+eC8xQ6Gc/9nxhUCFbWaWKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5dKcsqmapLIY4M4nJn8/L+ETu7kwHwYDVR0j\nBBgwFoAUYDzYBAlcsyILC40ujE15rnHlPXMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD4LJz0qOKTxD/yppsQW8HMhZW82foMws57HfacAntFHgIgLm4Sf3H62pst\nw1bSVb07MPWThlpufCWYTF/O4eKv4C0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZBAvQoCx/ZergOvlySZkvAoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDlhMjU2NS1hNWYyLTRjMzUtOTAwNi1iZTRkZGMwNDlkYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/ykdV1Js6MMiOIGWVxv9H1OjUsIDKzLBWHc3D4bRHRe/x\nBJhgEQOxn97lCNAUcf82Il4I30y/26F/cI7CGTkno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYDzYBAlcsyILC40ujE15rnHl\nPXMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCmgnyZcv7sabJc8tgQoHYMYn+33v1OXEMVWIUturMUgCIFNDZAOCNtCB\n6s0BhYscpsPZHzNUDxHNf1yw5gjX0j4s\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAfAeycp+pHe+lrqQ4H/+1St9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc4MThlZTgtY2I5My00YzkwLWJjZGUtMTFhZjkyNjM2YjBkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNDYzOTZlZi1iNTkw\nLTQ4OGEtODdjYy03Yjk3ZTFkYzQ4ZjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATyKhAPpz8KBMzZuFObWrZiew7SH7l3VQvTtMK5bmLYy36RDxP0GsmQRB8jmNtz\nVt/H2dtTzuWYopJZlERHkm5Ho3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTl0pyyqZqkshjg\nzicmfz8v4RO7uTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgZ1P+Q3OGy3e8/A11CGZiyUedsHuwmF6iY3rUlZhFAW0CIBU7i/OL\nIlJ5uLFbZRarxNkjeL6hJbD9Fr00WpHZ9Fvy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3433", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3433` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISARwIIrqSNt0Yg7IlzEcMOo85MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNzFkMjM5LTBmZWQtNDc0OS1iYjRmLTAxOTkwZjkxMjhhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY5MzY2ZDYtNDgz\nNy00ZmUwLWI5ZmMtODU0OTZlZjU4NDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkupQajdsCIJEm5pXpzxr+I93WaLEV4Su0Lp6Fwsec3ceCvddaRBOdCwjMLEf\nOTw3DgAcG8+WjcIOG7ctHXA1C6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWlmN+5cRIW028COVbv1+7VL11YQwHwYDVR0j\nBBgwFoAUniE/2mslxlX33x5pX4QqC6t8h9owLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDH\nQeSkOoq8W1D++7Mm/5GXdqh0UJdPeDeFv+FvOp5JAgIgeATNyDf2KU0gN+U3RLqr\nSc5WLj/Oqigtd4v6zWL8SJY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcm7iA8djSAYiqJByNUWmfDWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzcxZDIzOS0wZmVkLTQ3NDktYmI0Zi0wMTk5MGY5MTI4YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATy/kGN8xqveFRXpIFf42KoQf2oEpHdpsdyQ4ci3NVRZqOc\nj9TGSltpVZSOz3qepuKQi2I/i8dHY49XLWOgKCjAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUniE/2mslxlX33x5pX4QqC6t8\nh9owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbqKW+qDUkQ87k0+uXUGDRuomxoh+UZs7nJLDNluWg7kCIByCNRwHCYWO\nCE7W5ojF5nY/OP0FucFcdSuyK/8LKk7L\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISATlyInAl582r8MaV+yXSnP4fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY5MzY2ZDYtNDgzNy00ZmUwLWI5ZmMtODU0OTZlZjU4NDNmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZTJlMWRkZC0yNWI0\nLTQyMTItYjlkNS04MGM3MTNhZjc5MDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATEcc1G0kq0U62fqq6J3X8DKWQK0kZ8seB9p6d964NxjMRTWR7zcx4lN5kWY9PI\ncSbDvlZQ6cj88/ILvzUFz45po3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRaWY37lxEhbTbw\nI5Vu/X7tUvXVhDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhANLlokkoa82Ji1OnW0r8iGLdfyxffgY5mwJbgIDuSyZEAiBUKguw\nDYZafaaEqEiNOyMkP3SJPRuj/rWQtwPzjCDE0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3434", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3434` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAdYKRsdOYLmgNZereyJkyY70MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4MTUxZjE2LWQ5MjItNDhmOC04NjUzLTE4N2JlZjJlMjIwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFhZDM3MzktMTg0\nOS00OTZkLTkwODctMmMxNWU5NDMwNjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfYRS5Frecfcrkcu0+dUmqKdwgzB7b0T4nPD+8uJPXsdHw4G6YPKF+q5e4yop\nSgZ6BpX7qI9YA8rLmmgcVOIGU6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIruoNtONoathpB4tH21qZr+EWVswHwYDVR0j\nBBgwFoAUQdsFwQ7OQQm3GfntsJVPDzhUNIswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCPz7SwNKL8d5CiI0hRfoLAgptEHeTgZ9Ne7XG9Bfr2KAIgDqRs\nyiDvisLx7FEA5j2tgdl1qC3uM5YxLAOSzzjOl/M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUW1LAwDg+G7MUrvZagK6yEdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODE1MWYxNi1kOTIyLTQ4ZjgtODY1My0xODdiZWYyZTIyMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPA0/wlj6N7bfRugNh8HzSrAlEjpWNfOSIg14LAGKyMfDG\nlr4miJIj0f69f5czTtiJ0GpdOSy+kMOGS+lM0vxMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQdsFwQ7OQQm3GfntsJVPDzhU\nNIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA7+w6bqR2JNZdtWnL7AqZnNOr6e6IevIhi3s3skfEtACIHUezkA+6BfU\nPfnZyv+yHfpK+BI19xVLgLScQ19zcK+U\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAe8GpiXhl7Hwh3PoY/zYXZdDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFhZDM3MzktMTg0OS00OTZkLTkwODctMmMxNWU5NDMwNjUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YjhiN2ExZS0yM2Jm\nLTRhNzItODQzZi1iMGQzMTAxMWVmZjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARizNJsj77mdoOFZOdjD1wwpGHe1FEDWaC6NwMOGv7TBliwkU+zmAH0udSXaB3G\ndYsbjzTMY4dcitbXZkbjfl+ao3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQiu6g2042hq2Gk\nHi0fbWpmv4RZWzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAK5mPkZ+MEFbsBd46KP820r4Ud2Uq4OkzwjVNql5cF5TAiAYvZ6+\nZJSeQBMOaH6Wy2pDQD/6AYtQV3cCl5d/3ggfZw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3435", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3435` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAf831u4fIIx5mtPsoOfz40a1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkY2ExODI5LWFmMjYtNDJmNy1hNGJiLWI3ZDhkMzMwMjZlOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTcyOWJiMzItNDBk\nNS00MDI3LWE5YTAtNzllNjQ3NDFkOGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoOonFAJf6yTVgc5zskphJJPtIYx9698ik5jrZdZ+AjZYNfNwo0FnHhA1WfUA\nFEQkIosOMo3OrQxe/WbzQIYWKqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8xT0HP/SlgOARBUbdEOfEcIQF8owHwYDVR0j\nBBgwFoAUgpIZco4cby33bdBj6mrmM95YTGYwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFBHzI526NMU+2ecDGzjEcsoRPsF4+PDZJuVK94S/XD4AiA3B2Sw\nLYmSjQapKkSxrbgZSuj84fE1cqnt08EOiJR56w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASJ3U48Y3d9vAH0h08mw4+7qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGNhMTgyOS1hZjI2LTQyZjctYTRiYi1iN2Q4ZDMzMDI2ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQj2S8KGPetrHfVdPyC+B7xpCnDhon9ryiVwPzxvbiSbDtR\nccnbRpfQSlm6as2VLxoLOoDqf5raGQRKMjcLuun6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgpIZco4cby33bdBj6mrmM95Y\nTGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIIg2jLI6raAWErVpHsE6wynp3R2SEN6dtnX1efD2hyyAiBLZb/XLN+1\n1lRa51Ekv8wZsmzSFdNxSUi5erXS8oHLyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAb1jREy3kpyLSUuwLArpdOw+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTcyOWJiMzItNDBkNS00MDI3LWE5YTAtNzllNjQ3NDFkOGI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNDg0ZWRlOS0zZjhj\nLTQzY2ItYTI0Yi0xYTY5M2M1NDVhNjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARPmumxBa1aa9vhfW18KqD3MQ+wJevgRH4YWR3Ld1N+V+AsIkLAfGqha3DlZpOX\nDzeJhlGxnL4kqQWenVdH7Bfuo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTzFPQc/9KWA4BE\nFRt0Q58RwhAXyjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhANhemHbrC6VsrVcF0LIC/GHqBblPY/FDIrEU1JAsw1v2AiBmhmHY\nnZViMsk775hAIzyUE6ljw/NfcY3G/+dQ/C46Vw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3436", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3436` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAegwizh3R5rmihXjGA7k+2XwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2MzUzZTU2LTljMmItNDc2Mi05ZTg3LTI4YjI4NGM5MjZmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWUyMzdiMmEtMmZl\nMS00ZjU4LTgzMDYtNmFkNzZiZTYyZmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZyxnORjIw0K9rdlcaej4LMCBeERvDq91MbUfbnV2fQKp/1xGMKP8Vcxd/9QY\njVI/xIeKZ06FVghwY+cqIaepDKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR5BM1urdrLfWfI5R717/xmm1K/0zAfBgNVHSME\nGDAWgBR7bpwa7lOWmwezXTDhmEsdSwltNzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDw/a9MKeab3xv0ohUWz1pHeY2h10ru\n6l7utChg24vgXQIhAOmGB1Vi8rgp3jYzmvk5ASbp9xZwPrPy/u23E5YJ4o2x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAehkj2EZNehrinCIiXNiwICKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjM1M2U1Ni05YzJiLTQ3NjItOWU4Ny0yOGIyODRjOTI2ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkri4O6IqjgL6qvMDmTq9pZM+6zcPub7ivYTgG4Y6rbPTZ\neYDti4YlF6RL8p8vUxaBid6GYx17sA24k3thYhD5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe26cGu5TlpsHs10w4ZhLHUsJ\nbTcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJWUzUn+3FpvttQ0mf+YyfuPN6RHd6mkj925uuGdkaQ8AiEA35QrdZqx\n1A+MId/LuXn7W8YFc9hpctKRkq0PBsm6MZo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAW+emtAoOaBXzFOFcd8P/VWiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWUyMzdiMmEtMmZlMS00ZjU4LTgzMDYtNmFkNzZiZTYyZmJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZjU1OWZlMy00M2Mz\nLTQ4OGEtYWZiMS1hZTBlMDA2NzJhMGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR5GSyszT6ZDwVhLpqT83KESP2FPvruHlGva8tfadvRgAyojnbz6F4oJGZtV0hI\nBcclaCRTJukDUKSkuNJB+nwoo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5BM1urdrLfWfI\n5R717/xmm1K/0zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAJxh2YMbZ3tZxhLSN53UVSXuLcAaTl9H8XQ9RJkCkBStAiA67XoA\nKjykvXiULdSydrBwQjuciyPtZpxPQts0l/JXoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3437", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3437` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARCaOo/9eIKRMBer05zrGxpRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjYWVhYTk0LWQ4YzMtNGU2Ni05ODk0LTQxYTYxYzBhYTUwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM0ZjBiZjYtMjEz\nMi00NmVlLWI3YTgtYmE4NDdjYTQxNzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEweE889UwKUiJj3uT50whD+R3Ghc07QIicT53SZyg0EwxCx1gI33lIYBYtOXv\nh8XP8Baetvz0KsZG+P9tSj302KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAaD63Sgz9biQ8VtRHzqfBGNe68QwHwYDVR0j\nBBgwFoAUPY6cJ6IJ3lJ7ZXh9PPVjRnAHZrgwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGqxKcOjiwxF\nWqki5dQ6rVFnUo+yXlt6IPBP6NgH3GlSAiEAioEZ6alesnrS9D4YLQVLrA8ONb1v\nz5yDipihp27ZEYo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWDZEeEW6E0hj73kBN3i+AMbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2FlYWE5NC1kOGMzLTRlNjYtOTg5NC00MWE2MWMwYWE1MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATU9q6NQ/sO96e8qXBKShCGHEo2JH/bxR39FY8FHYpcxN8d\nZY1XF1ZVtQqs2wNo5aSdCFFTCttEHSabPgIhj5s3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPY6cJ6IJ3lJ7ZXh9PPVjRnAH\nZrgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKZG88cmxTnx/XYYK7FBw8ADv7JenBSlNbuHSpLP62UyAiEAxPqRALH9\nJM5HSCg4tFoethvUIliWKRZabg6C0afg9o8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAQwRSQ6hQahOOSJY48oZap6AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM0ZjBiZjYtMjEzMi00NmVlLWI3YTgtYmE4NDdjYTQxNzMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZTJjZGE0Ni0wMGZj\nLTRjZmItYjY3NC1iZjkxYzRmYTZlM2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATAv1r1oxPuoVaqtoQ1z/uV7GrxyFTxOhfyFwrJorEjLg9+oT+3+KkW3bo2OIiT\nWLz1XroETO70j11lPTMwOyNKo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQBoPrdKDP1uJDx\nW1EfOp8EY17rxDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAI92KWe0RC+zUFc+1XNBzyTm4YpRWZonFNw7DxlrZP04AiEAuF5d\ngX+PP+UNauqgdy/X/nUjakz/1/DtfjYF2yvMRto=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3438", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3438` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAea7yMa4IgoCY8MYcAikpwZ7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyOTExMTdjLTY3MjQtNGNmMS1iZDY1LWQ0ZGY5NDUzMGNlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIyNGQwNGEtZjFl\nOC00YjAyLWE4MTQtMGQ4MDA0Yjk3N2RlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERf6gk7GsMY5prKJQ6i5VLENi5ObR17LKNa/mnK/qx5LmBRmlU3Ov80S8ddxh\n/vV3xCkGvaS3DqntXWv7fylgvKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtSjwtoqc7s8B2tpLp+m++i1oNCUwHwYDVR0j\nBBgwFoAUoq6xJkPKpuyITAEgkwi3EzLpPFowKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGdEgmPqsoZO\nBCdm5xogrK5yaGzBE6JzeoUFs2HKfu/lAiACygBq0GfPF0urb3OmZSPo2zDNpH5D\noxGLsqL0zs7Low==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZUJ58e9HyELOTsWuofAYzjOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjkxMTE3Yy02NzI0LTRjZjEtYmQ2NS1kNGRmOTQ1MzBjZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk40pWzARDPb5Ju9sfT/Z/ml7NV6FZrIhhmOHfj01aVPqA\n0c+0ruWLqdjPdD21ulNQoXcBFYLzr29ySxThInDIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoq6xJkPKpuyITAEgkwi3EzLp\nPFowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTdEwoVIwfqwLorDONGDMPq5wctBMQQNDjEkt2gX+1NUCIQDTkik1q2M7\n92srvRShHNM4kC4c2iGLdhzIfpP0wR9YQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISASjO73nTgDl2pWNgA1jp7UqzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIyNGQwNGEtZjFlOC00YjAyLWE4MTQtMGQ4MDA0Yjk3N2RlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMGI4ZTQzNC1iYzEz\nLTQzNjAtOGFkYS1lMzQ3NGI5OTgzM2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATkzWp2lYxH4qDcjEOuqkKKFIP61r3KimcFC9DW+6EMrpgL0kZMHPfxHWaH40lk\nzT5mlGXdrMfOPGcIc/xdGUJ+o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS1KPC2ipzuzwHa\n2kun6b76LWg0JTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAO2si10ahp0N4iC9Ad7mhDnQroLhhssUqx0JSePorzkYAiAgq8I+\nRMQid9HnHQD0TtMA4BzafnkKJN32nJQUv8HATg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3439", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3439` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAULUXxBXmXxsegA8wxSWS8AsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3ZmI2OGU5LTIyMDgtNDI1Yi04ZmFiLTZjMTc2NGRkYzExMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI3MjQ2OTQtODZl\nYi00OGVkLTg4ZTctYjdmNGNhODk5Y2FhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEODhZJZj7m9rfb8P4zF6m5yONv1vmBVBHOhmPcvJwgPSsmlvoThbz+QlQlbmA\ntuNrD/KOXRqSPfKYAnRt6Naa0aOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAKMx4TGzGxvur+WzGUD7Q2k0fbEwHwYDVR0j\nBBgwFoAUI8I1y57PJQ+5d/iPTYYTBZwz8sUwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEApq1d7MJD\nG6fYNL1uHJpIUDRhIScZHztyDYH9nUMW1msCIQCt7cgFEYUc3VlCvEMkinlmWmn1\nq9npHZardurwccFnOg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbtXQQXkzjduWtNVlrxXPMRKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2ZiNjhlOS0yMjA4LTQyNWItOGZhYi02YzE3NjRkZGMxMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFOpKA5MxRqmaZMBs4EZxcaHkizfqV7JZE0HuX35g8u39I\n4WNq/wAeL/0QQ5R1IEtqEMZLqPhIUisqzjtG+HhYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI8I1y57PJQ+5d/iPTYYTBZwz\n8sUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIOrGQGQOE6Vbmx2toHqbTpUqKPBvV2Z4IldRtkInvVHAiEAx/n5TC4C\niMjT0lZ2VZk64P4gH9IlxnviG5Sr7dNCaMo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAWIzNZjZOurR1u1LoJYKJTkhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI3MjQ2OTQtODZlYi00OGVkLTg4ZTctYjdmNGNhODk5Y2FhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ODJmZTQxNy0yYjI3\nLTRiMzUtYTYxMy1jOGI3YjQ3ZmJhYzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARO170FyA6DnzeN7cioGhlWW0zfw7687DG9J/eF1EBxsFUWOjz747ZWSu77a63O\ntUjk/P9IjPtxACLM7JzFljVTo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAozHhMbMbG+6v\n5bMZQPtDaTR9sTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAJz18jBij5eToWzFuNHaRQd99IwklxX8R71HEwBHcdGQAiA+nFWB\n+Xg+cCDM/VwTKIxfmwNAjMHjUeP3qNKhLB37pw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3440", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3440` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAUYxdvFjyUh55yUooQAlIQ1YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkOGRlODU2LTQwYmUtNGVmZS05MzRhLTk0OTI3ZmQwZDkyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjlhZWMzOTItMmM5\nOC00NGQwLWIzNDUtMjkyNWEzNGNkNzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdhVtMNIYbD+hf38TqMooJGcrXh4zAdxn3i6vM6rkpZrpS9l9FTBR+U8yOTsu\nApQzWnNvoym9ZpE1YpZWdHvKtqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQQ+oQlEHZz73MOoFsiI7EOulLNMwHwYDVR0j\nBBgwFoAUW+grvQPEn5rfbxVTODeLzqPGoM4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAgDC/9MgmPknnQ5g4k1anOhWSFAVlvK+ZnGQolOz7WqwCIQCI7pDZbFG1\nWtGOizH3eIfYAiwSU0ntcc2jTB01gK8Mwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYz4/jhbTMwp24iL4syt4DTjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDhkZTg1Ni00MGJlLTRlZmUtOTM0YS05NDkyN2ZkMGQ5MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRCr3efIqgcWAvdl6V1en02G8bFIsEyEnEBtqehu965MJQ\ncuRQZZwhn2Ga/qzMdwLojmOS+SIoCkZrDbfq0bM5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW+grvQPEn5rfbxVTODeLzqPG\noM4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJtoClEWV8Nml1dYvXUCJIFr2prgtoe/zeQzqTmt5g6HAiEAm5LmdK2O\nGc+k5KZFMuidKKql5OcFJISWeXT3/3cJ8pQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAb76yucExcDSbeKLif/ze7gzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjlhZWMzOTItMmM5OC00NGQwLWIzNDUtMjkyNWEzNGNkNzAzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMzM3NjQ0Yy04OWZk\nLTRlMGMtOWI0MS03MzgxMGJjMDcyMmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAToH0woytln3xR9+6N8tI58nZnfp3Pk64BgtEFu1/1q6GlhO2NDyebStF5F2iiy\nzja1QIBtdb6tDFruJQ7md8aQo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBD6hCUQdnPvcw\n6gWyIjsQ66Us0zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgSQkaxQVf78Gkqax5x2pTC2Ozf5rMv7hYzOLrubKKOqACIHmuVE/l\nR6NX7yca3G4l4kagfUNyDTd5sU5hh6AoetqP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3441", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3441` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQjKzqkyJVPpfkBi86EzuHGzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViMGQ1NDg4LWU3ODQtNGE5MS1hOTc3LTUzZjg1MDQ0ZDgzYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGY5MzQxMDAtNDAw\nNC00NDY2LWExMTEtN2M4MDBiOGEzODIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE21gxCH0ntXFQCf4eTBeYZVPyU/qsMVmYw9x0nVuswZT3y6g3YZdcB+IsyoA4\ndJ9PHE1BBHqav4cykmA46N/XFKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/J/RMRXjbMmlWMwqd+25npST3H4wHwYDVR0j\nBBgwFoAUGIhqTqtsh83DohisTrobEX5gRDUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA/0thq3IkKfr6CdhKO0j7uPENRdJghRKa9JTeDcVw2MgCIA3gRLgz/Mb6\nOLFBJTr9OXD8mjB7lx76QKfS3Mei687X\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXW/H4qw0wRhzKS7JMEj/NuvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjBkNTQ4OC1lNzg0LTRhOTEtYTk3Ny01M2Y4NTA0NGQ4M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcsHnR+QSIXq9Yp9BvjyQTwsO6faoYiBhQ0ns7/zH71D+A\nJRZoIbu6O2ErPU9UiZs3MUblLSnPpQRyTQtCWWtto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGIhqTqtsh83DohisTrobEX5g\nRDUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMoxts1isXU2sKWt1b9Lq+GFWtAosD2gddYgJu86p3QCAiAifDijTh60\nuj4pkFQQjHGkscwvn3nYEUdymPubHGMcoQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAVwaYzSu3NE5GW3Z9Jc8Lv70MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGY5MzQxMDAtNDAwNC00NDY2LWExMTEtN2M4MDBiOGEzODIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMDBjYTQxNC0yMTc2\nLTQyNzgtYTQ4Ni00NDQ0MDFjNTMwY2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQCTO2/lEXqWCCFJ34KMi1p7aXWmRmovjTN8KGbu2B2lKyO/1QIJrFJeB6GQuc/\nOVF4oGjv25fVp6jCJzmiMjeLo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT8n9ExFeNsyaVY\nzCp37bmelJPcfjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAOAA5EMgMnB+7sOF5j7XAMgCBAA4pjrSfduQwSXCtAyQAiAgcMaJ\nMd8W0ur04YLT53OoV8aGDufxpj8Jgg+n9Ndo9A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3442", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3442` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAdeDUxENisbNH9dKt+mGJ06CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyZGY0YTg0LWIxZjktNDk0MC04NGFmLWJkZjgyYjZmN2EyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBkOTIxODktYTEz\nMi00ODc3LThlNzgtMGEwYmQxMmIwNzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBVZLu6l33cioPLuY0eqxvMzcgjggKBRd9eWSu8i7z2Rl3ojuZr6t8QoYKNqz\noNRrpCVvwTygejiq3KO1AnHYSKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbWfBsErfnDlt+0qo4lD2yPXWjeUwHwYDVR0j\nBBgwFoAUq5txTbPJdAYMNc0SlCSbKCzvPCUwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiB8\nQ3Fv42Tn1k4w+OxFx5qrWHdljXa0gPcbjqbTU2ZXJwIhANCWpT85XDKVLI1Xn1/i\nyJe1mhdPK8Io/gJ+2Ckmm/p3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATCeooMHtehh+1qFyHv+zpc9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmRmNGE4NC1iMWY5LTQ5NDAtODRhZi1iZGY4MmI2ZjdhMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfksBtjc4I7VNBEq7HrdBEmeLcvj07bc9toWBrHA7pAhFw\nMAIF8WHYey8g+EgRh40gDxC3FlyjOUw0fvUbZN+/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq5txTbPJdAYMNc0SlCSbKCzv\nPCUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCVHlOV5qu4zjpcsKccTm5cI6B2thonzcmsPrMiEHGBQCID3BgmWPXYS+\nes06MoSRde9SF8VpBMawaizU8TxVqz02\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAQtSJJ/sH1ERZOM6wj5mXbAaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBkOTIxODktYTEzMi00ODc3LThlNzgtMGEwYmQxMmIwNzYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNTNmMDY0NS05MGFj\nLTQ2ODUtOWNmOC1mZDY1ZjZmMmQ3NmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQFLfjpYVwBMdP4sh+3nT/1bWDiBoti9E+JfKAkbSRaMlOAWhpkLg79Jv3d1bXG\nmbZUpshpOKswXG5nPvUieJ/Xo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRtZ8GwSt+cOW37\nSqjiUPbI9daN5TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgE19220HDnBXNU5M04UkobvfJx4+JO6PPoCgFu7CGMM4CIEUpy6Cm\nu121MK1tW/dclVYwWBBcINqqlPZMbul1HPli\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3443", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3443` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAXzNREag4iadV8j/Cd9nQXEpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2YzBhMzhiLTY0MjctNDMxOC04MzZiLTQ5ZjE0ZGEwNDMyMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RiMzM5ZTEtNjMx\nNy00ZWZlLThiYWYtOTcxYmUwOTUwNGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpM5vmJHHr9+Vq+cHUuj+OmdUNZ67ri/mxXNWxt9ZL1C4ca05tgqoQvHVAOxM\nj03YksR3Z/EpJFgEWa7Gy5AWi6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ8PkYlaP1qc3+UZXgh/kv6nH1VAwHwYDVR0j\nBBgwFoAU5s5dL5azGruVivmoKRacZ7NFlhwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiA4LMEY4bP2n4wuIAbsafxvJl/OXHnVVoB2VZZI0feOZwIgX/qK\nPFOsaoGevCnxZfqq6hOR5C0Lmj4rumjdOF2529Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYtiqbMycEfJe6Ks/vQ/YdfYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNmMwYTM4Yi02NDI3LTQzMTgtODM2Yi00OWYxNGRhMDQzMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZuEFPD/YiqoHM1NtU3KC+WMzQUsKHZt8k+LMlqqU2AWPH\nqjQUl4koXjmAyh6yaF0TzzS6aF7k+d+de3wTK5q2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5s5dL5azGruVivmoKRacZ7NF\nlhwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAj1h96HHAy2FJ1cJeFNoh9hIftYW9pTd+Cw7fzRh2McCICSxHEbavr/B\nTJ7pF7mSConO94Fj78FYI2x86dAYiJC2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAUVZYbH8mOI+kwW/cUx8ft3mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RiMzM5ZTEtNjMxNy00ZWZlLThiYWYtOTcxYmUwOTUwNGEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZDlkN2ZhNy1mZDQ1\nLTRiYjAtOTU0OS1iZTY4NDg5YWZmMjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATGZvrFXBRunBKgWpe1MHHAVoSfgB7uOmsfyNodn7nnr93/aOrNoOS5bWCMszDh\nGqfs5IgLwekkBFdnhGvpARkCo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRnw+RiVo/Wpzf5\nRleCH+S/qcfVUDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAInzywXtQXG8aS3ONBK6Fa7tw810ZDm3w/kk5HWMoHGKAiEA0meC\nQ0Fcyfip7he++RU1i7YP3fOUt8XJBq9nb0SHMTU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3444", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3444` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAU8KQR02YHSyATP53gDS8CzmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiNmM3ZWE2LWQzOTgtNGM3YS05MGQwLTcwOTdjY2JiNTRjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTMxZTY0MWUtM2Nl\nNi00ODFmLWFiNTEtZDVmNjUyNTlmMDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE95Crh/0OJhtNfAxmhOoR5atTB6vpgrQFFbpmlC4GvoLVw+qnaVk6c1v2VH9E\nckdeqqJsl6Ut/8VF/3/YtDwWSKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJO/4Yaslax8+0cfU8v0kzt+tt6QwHwYDVR0j\nBBgwFoAUdTuT9zyeWU/cfzcSx6ooQZW0esAwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA96pKhs3u/wDx5Qon2eXox2baPaiGCHBtDqxZ92NbllYCIDdf\nYgDLSh5oK5wWCU6r2946W+shshwViVYrNcrv1rSy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATIog4926vIwCPKBzwrO2sWvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjZjN2VhNi1kMzk4LTRjN2EtOTBkMC03MDk3Y2NiYjU0Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKEDybpLFy4nPjPbAnG1OQoGfW2VytyL5PC73Z5dSicnk5\nHPSyP4qjGtoQUBb8JcqijAxUcy/RLYX/bkEIQ48Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdTuT9zyeWU/cfzcSx6ooQZW0\nesAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLRT75ARTjGA4A3X7dBjUSf55AAH0UYMz1GWCmqqqNOkCIATtj5kFfXT3\n/Xaz0HRmFgkgTEoescTiSL47Js4TQnvb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAcXdJ+TkNfZFeXB66IPBS0pWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTMxZTY0MWUtM2NlNi00ODFmLWFiNTEtZDVmNjUyNTlmMDQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxOTc0Zjc2YS1jNGVl\nLTQwMWYtOTBmNi1kZmJkYjdmN2Y0ZWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARxTD8AjGjDCgCXYkyKXv4t5D0N7yADPfiR61tMcAyW1YZv0xSeo8kQfUTJks58\ns31rdGTCKgPgrFsHtB65TJ9Yo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQk7/hhqyVrHz7R\nx9Ty/STO3623pDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgBeZiS8nY2UfdcQhisBMNDRrzNJTepgkecShj/Y7b01kCIEekmIdF\nMvKaAb8ApfLo1qMMX0Djfj7OhIrTrXSp63Yh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3445", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3445` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAVHG9d65LpEtUqYYFY5zF9/YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YWQ3NTZlLTk4MjMtNGZjNC1iZjVlLTFhMThjZjJkYTllZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDcyYzk1MjUtOTJl\nYS00MjBhLWFkNTAtZGQwMDdhZTBjZDg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUhzvzc9fW6AY0fNdyhkxFg/g5RLdxQ4GtUUtcAt3Y2YxD5/9/Tdcae+mFbR2\nl7BnjWseDHbbEHCORHuTL6w8VKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtdVOfPqaV8SZmu6Bn85n1XFxyoIwHwYDVR0j\nBBgwFoAU2O0hZzxUy2wRSfzbnHc4y2ntOC0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAMNrzP3qpzTt/e\nEZbKEJ5j/UV1H8hSVV7mNfGAu1cNXQIhAPpeTtIKYFMFwZFTjtyKna6uNcfPA71U\n4EBWm5I0CGJQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARIat453tbqty0tU1pg4LM2jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2FkNzU2ZS05ODIzLTRmYzQtYmY1ZS0xYTE4Y2YyZGE5ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqX2dqkEgO7JvXJzTz7FGA1C4cMm/s+Mtm0fTjdj6BXvXB\nQOoYuk96IzFprVC7mm9JhqsmbpxewCXYkL2y04ywo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2O0hZzxUy2wRSfzbnHc4y2nt\nOC0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTZ2SCbWE8dmnAWsJvucCD74FWyUC+6OlH9PYM9HLLtsCIQCOrx21nLs4\ns8pH90dKoz17TMi6RYF5n+enYEpsZmG2iA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAdMg+Rm51+tddIj9/qAlbl6fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDcyYzk1MjUtOTJlYS00MjBhLWFkNTAtZGQwMDdhZTBjZDg4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MjA1MWZjZi1jZjhh\nLTQzOGEtOGUxNS1mOWNjNWU4OWEzYzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARY490e1SAQr+muyg8JUXHnUe8z5PVBD2OENFUrdL47dDePVTI+debU/Sdo8lJu\nrHjlGJiE0E3KV296QL6LwUooo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS11U58+ppXxJma\n7oGfzmfVcXHKgjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgRNvGEezuybwgKsTqUDRsXX0dJ0kUYj5TQWAdG5aFgOgCIQDw7rhe\ntlkZefWaAGdUqKGHXgFIPNrAyfYtgFz3smLcUQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3446", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3446` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARC7PhJMCzJoSCkneBZGJIj+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyYmUxYjdiLTkxMGUtNDJkMi04YTM3LWI3ZmE3YzdkNjI5MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I4YjkzMGMtOGRm\nOS00OGUzLTljYTQtMjEyOTg2NzQ5ZDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4+yFvny1cMl+PFd2SUuGaCr/DQ3tIQaYSufogW91TcSlq5JIjHsBy66CYS9/\numWtHPE2DPbqgI/WvIVS6qkcoKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSjOR76bGGRJWUJBFH4QMsVyazRgwHwYDVR0j\nBBgwFoAU0ADO9jEMpVP3oUNqbOtPHcoa25UwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCu9P7XgUUBear8W9JgjPwjc82avMYfZNX7ABbMiYFuHwIhALmbRFGcelpU\na9QFenEsfXD6Ah3pQSCS1+tavWH6a1pg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcjRe4i/HX65/Ecg2mMrC7SHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmJlMWI3Yi05MTBlLTQyZDItOGEzNy1iN2ZhN2M3ZDYyOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5YP+Cc9vAA+UcQmDNQ40oZJknemjSt67xPwhq/iVLN4wL\nV2trLJVSX6xX8Ies9+IT++imyi3d/+pkHIjM4eP0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0ADO9jEMpVP3oUNqbOtPHcoa\n25UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZvtO8IHgGPcDns7M/Jg/QW1pJ1I9m+Vu3S7EtqOJOjYCIHzNqJRApoYr\n/x/Fs8wT95hlACTUYTXDCPCJAYnz+F7L\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAVBEbo4Co0xTogwyobZI+ZtxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I4YjkzMGMtOGRmOS00OGUzLTljYTQtMjEyOTg2NzQ5ZDY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNzBlZjczMy00ZWZk\nLTRjM2UtOTYzMS01OTliNmMyMWQ4NzIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATo0qm6J7+KnqjCD9jzhiiEw5FYCikAoNaNrhyvYpTHpydihVyziNWqn9PjTBjX\nb7sGzhWiq0KrH0IfGK1v+Y8Wo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKM5HvpsYZElZQ\nkEUfhAyxXJrNGDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgTs2niRi8MPE6VlTO8mOEHsrix/RTBRmkUkTOmRPPjxQCIQDOpORo\n6KpccmmuuKOzdylNz32ZN2M/7k4TPXwT0mmTnA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3447", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3447` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISARwxE82fJML1+HSE0exvS3DXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjZTIzYTE5LWFjNGYtNDJiMS04ZTAzLWMzMDgyNDY0MzQwNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzU2ZjRiN2MtMTY0\nMi00ODMwLTg5NmUtOWY0NTg5ZGE1ODhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd0acpPgoM3YzFF/GyVHw7MI8PLpkOIGuMNWcWoci5xMoSpPaMUqelSqEhYyc\nIvwkEb+eaW6jejkG5seeqaiXNaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzIZadp3/95vh0gDTocfjsYenBrcwHwYDVR0j\nBBgwFoAUrgcGJXrG6Hw3sqaU5UUMxS/eqLswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAeF5kUeabtqU6DLTDky1nU8d+3+3+VY5zyYi437s5jVAiAFynqFg3OTtJhc\nxTp1VdQEfYC1ELyhrHNZTVUG3Pn/FA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAceyKvinJdJgKRh2TXKBtdfmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2UyM2ExOS1hYzRmLTQyYjEtOGUwMy1jMzA4MjQ2NDM0MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASthbZHbsbN2iSIbYWTlWyQfOoH3wDDHBNSoNTx3dwWiKM/\nsy6ktvcTVS/hQgGPVc+zgpQhyOwToM1IOzuupQWTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrgcGJXrG6Hw3sqaU5UUMxS/e\nqLswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPiniSPqq962czyQApCnm2jN52mI+D3wN9GmBjcQ9JxJAiEA2diObyAM\nTiPgk+NmWp66g8luw+TxNGbRYM85rbaVV0o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAVW7esi4J/SBDe8t4FyKDth1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzU2ZjRiN2MtMTY0Mi00ODMwLTg5NmUtOWY0NTg5ZGE1ODhjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5OTc5Yzg3My0xMGY4\nLTRkYWItYjZmMi0xMDcyNDViN2Y1MzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATLn86IN6t14JS2YeOZB5m3H1U7NZzno25ejmGNG+rRhQ4rf31oGSZzfz94ZJPj\nxVOVrKaXBaLsrVhhgphOhJUTo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMhlp2nf/3m+HS\nANOhx+Oxh6cGtzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgaH12klIGLL0m8252BcIrWptf+TXtZEtTAWlDx4GX9JkCIQCXK7UT\n3FG7wJRyKVq+SF75R0NQ5qHXNvAzI3RYwNlARQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3448", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3448` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYHvAYbwrf45fozPmeONaG54MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzYTg0ZDFhLTdmYjYtNDUyYS05MTU4LWU4ZWFiMGM4MDhkNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZlY2QyZWMtZjdm\nMS00ZGZjLWExNmQtMTExNmIxYzUwMWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfy+RStHXfr5QwG1ES+xdT6BEBKkR+m8t+JCpYVZaPk/YA9JhNzZhAbPks2tk\ne0cL2qKc8CWWXQlU2pZ+IUmYNKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY+XzFtQOhCzdnAJWAYTI2luviX8wHwYDVR0j\nBBgwFoAUnJnNofZx9ag/ORfjCZYUqkkP75AwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA/xBAQZar1OsnkvEOre+zIlOrr0SftZBIsjXwsyOztvMCIAyHFWvshx9o\neuSE/JVyzcK4tJeaKC573KTkhZtB2nrV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZaGDNkC5cespAejzldx648pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2E4NGQxYS03ZmI2LTQ1MmEtOTE1OC1lOGVhYjBjODA4ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAPivBufg4mdkk6p9KPl9tp11fGLFyYC6u7/rKdO6k65Ud\nJ+RggWZmTlPpyf4yur3og/X9D+RoVVP5s3kwq/p6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJnNofZx9ag/ORfjCZYUqkkP\n75AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIYBFGQralKk4/6TJgI4F3XUtkEaS1MJW6qk8fpH0fZiAiBnI1MecUl6\nzlGAfDBp391j0Nx1Zehazyrc+mxokGeePA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAR0Iizqt/66s0I/h7ocFddhiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZlY2QyZWMtZjdmMS00ZGZjLWExNmQtMTExNmIxYzUwMWJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMjJlNDcyZi02ZGEw\nLTQyZDMtYTYxZC03ZGJkNTg4NDUxOTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASy8/Jn25bmoBr3VzewHoYlyLZ6SDYxtriTCBzH6Ah0yB+TRi4RC8y3+AcVjUxA\n5WuSQOZWyizWGUmN9Q5opbiuo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRj5fMW1A6ELN2c\nAlYBhMjaW6+JfzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgO9NkPLkvbv4H4thCyduS1dxkIuFJpAK9OkCwYo9mqGICIQC7lEPe\nXQ1FKE7J4r0xJzwtEkX5jIrarQaS3BkKB1d8Vw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3449", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3449` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUJWFR2s7MSQvFH/u7OThv16MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzYjYwZjE4LTBiMDctNDM5NC1iZDY2LWJhNTEwZWQ4ZWRjNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI3ODZhYjYtMmZi\nOS00MGU0LWEzNWYtZmVjYjFmOGE3M2ExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsIcOhFuAeXLtgrhO3HSRITgYBiaXaTXIF9SA8iiXpgzkZD4HENm4rusmHumj\n5L9kTcABceOOWJba8QvYqNWH6KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4bcxeEIKyUXViIeU7ZmbImEM9UAwHwYDVR0j\nBBgwFoAUSgcqMueTXLlydEvVuUw4LWCpLdgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAwdcphJEW0FzKCA9RpTV3uDzt8qzxqQ8/iOq7UKZd\nYtcCIEmDJAIGhqflf1vSFrB/5iVhdmrj3BNMThmAmQblMVtT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYtSx/6YfuoPnRH4l0kKCM7EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2I2MGYxOC0wYjA3LTQzOTQtYmQ2Ni1iYTUxMGVkOGVkYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASty+WDtLwYmbaXdW3qr/XOzoyklNUm0cebA3pDGAVuwEHs\nBLcesk0TZI+x/kxDxeGL/X0Yjju67PHWKjxAZN8po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSgcqMueTXLlydEvVuUw4LWCp\nLdgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGO2F/4g45LZg61RrBaHO6EYbdKxb1DoCNxUceLFqgZgCIQCj5gyNG63+\nJ2vPN5aX0Mq9HqcktrN+5CsmgqfoYB5VzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISASMU22ZwEeTQAqIp0Fx+m9mdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI3ODZhYjYtMmZiOS00MGU0LWEzNWYtZmVjYjFmOGE3M2ExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMzRmMDAwYi03ODA1\nLTRlYmUtYjkxOS03MjY0NmQ4OTNmNGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ+gLukDYE5HNJPPVmrWdFXc8SSbpUGox/IwW4dJ+MV1sQHJDGehAKvnzOmnAoQ\nGHJej7AgSaOFJnUR4LVp6uNfo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBThtzF4QgrJRdWI\nh5TtmZsiYQz1QDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAKlZphunjt1gqLNmdi3nhqks7eYR3TwtBGPJZrfoRcAzAiA/NMbW\n4cR3nqSO1Kon1D6SNatANXbqUVWyjd7VvnTAUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3450", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3450` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAVk0CeX0F8LMJhBbo8DWpKfqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjY2RjZmFkLWZhZmItNGFmNi04YTQ5LTg2ODczYmI1ZWJjZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzMxMDE3MTMtZmJh\nZC00YTQ2LThlZDEtNGJjMjIzOTFmY2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoTYa9HohriTURajxyv4/o0aPAuw3/JBAlWADHPl/prQsDGZlUW9+c6dpnsj4\nQeFm6M0t7+LkSS8VJQdkBQNPGqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHN2RXZjhispjyYSEhgpdS7wO7h0wHwYDVR0j\nBBgwFoAU4V5nz1e0x2I8MPaWFm9l++0mHZMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAj4C2L3PPjm3EtiYWw9nkvJDawa8k/Z5Syp6fJYcpI\nKgIgHRX6G/Vvj1HLY8kMou9gF41sz+Mwwq8Q9vIisC9Ai8o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUjIF4cNrVJJAvBGFlGyIj6+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2NkY2ZhZC1mYWZiLTRhZjYtOGE0OS04Njg3M2JiNWViY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ67hv6Jm1CZVzUpznTRDA2JX4xUs8/fZWBIfrGX3LxvbQ6\nJU2NQBHB3zcdUY8PnnXKlYFMWQ8yacdLYBmgh9gZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4V5nz1e0x2I8MPaWFm9l++0m\nHZMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTtBCWAtd0kPf7L28mXH4+Mh6yhfZn7rSnavGVtvKEqICIERLCqu+IQAW\n0tl5dedHxO6Mz7+2vtBCJg1KCLNT+4Ko\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAdww/c2V+U2FZNgpeTc1liwHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzMxMDE3MTMtZmJhZC00YTQ2LThlZDEtNGJjMjIzOTFmY2I0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjY2E2NTFkNC1kZmZj\nLTRlZDAtYmFiYy1kMDc1YWM1NzAwMmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATU6oukuj022wRzoQE9UXKBv0VCM+1n5AQOAh7mjuPOGrh5q47VS0Wdhdi0Ypbe\nEcC0D4pGmKT+ECEGO9PmAN5yo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQc3ZFdmOGKymPJ\nhISGCl1LvA7uHTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgXJnPMIcO6IvdHYEv5zNxoVEqxpVsE9HsfoJfS3J1f+QCIQD0g0Du\niFn03X1JryaINYMtGQF+/DYKb0zfoUvbapwasQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3451", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3451` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASePppkIqn6E/cn/msGGCIyRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMzk3ZTUxLWM5MjAtNDViMi04NDJkLTA1NzM2YjUyNjZjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDUzNmI0MTctMTQw\nYy00ZDg5LTg4MDMtNjQ1MzFhOWU3NGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB7dyqFTuoBox+It14DW+CSfLWHfYOWTodRQOPWbBc09OlkTK1i/ngJJl+Srg\nmRGHGkeOZUbTrmqzMlT9En2ZKKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuOLk5fSRbcJi+VGKS67NJZRUkVowHwYDVR0j\nBBgwFoAU+x5oLPhf0pRdS7NK0TkX1bo8AjYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAanP3XU/Ng+t1x6e5B4+cWGU8L1yNr+7saP0fzfGKTBwIhAP6P\njW8WvuspXe43ji8GzHhNfTX9ZK1S+utTGVSOuVgd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV2cfiqS7EhsndjbrOOClGxPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzM5N2U1MS1jOTIwLTQ1YjItODQyZC0wNTczNmI1MjY2YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhlUveZSE+VkyYeE4+kyLSowLpTwzR/VaZLBo2qx9mtrPT\n94zgkvzmT+v40QZD5pDXH1FwGIvDBS/R9pMt2xjPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+x5oLPhf0pRdS7NK0TkX1bo8\nAjYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge4K7TDwrM9HSwKq/KLYZFQhMOLxyL+smOXxkhRgvYPACICb7stbVPQ0J\nmcA+orqsAYMS2ztMInaIMhZpcDFqUkb4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAWx+vjxHFfOtKVnd9tQBKKVJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDUzNmI0MTctMTQwYy00ZDg5LTg4MDMtNjQ1MzFhOWU3NGI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNWRmOGM5My0yNjkz\nLTRhYjAtYmZmNC1jM2M4ZTY3ODNmMzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAScpYk6BazcKCdKKzwMFuWUQWuWPZE9hN0w6a8rboyU3AS25cndWd1i8Tnr8zv+\nYeeze+xYpm5BUd/rvRI43GuCo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS44uTl9JFtwmL5\nUYpLrs0llFSRWjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAJKN3RyXTFw7ZLEiVFCd8r6CKJYdUbxUJdpLQkjR0UNzAiEAsWdj\nz57K65QeIFN7ycB1dRhsYbHFZ72k9Dg4YUquQTA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3452", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3452` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAZHTLG+75gHv5MQ1oRrjvAv+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMWE4Y2FiLTk3OTUtNDBkZC04Mzc2LTJjYWQzY2JkNjkxYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQ1MTBkN2QtNWIx\nOC00Yjk4LWI2YjktMDE4OGFjZmZiYWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBGGnhLcURlXOo4/lWAmljkEg5Gvls9wldN2U2N2zndhzpNUF94prd5W2XMh5\n4hGdNC011eFH5UxOr/SvfQ+rsqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMt9LnFeP8FejjTxUL5S9VlCyDnQwHwYDVR0j\nBBgwFoAUGPQnuMI8yR5g/de/rLw/qxYsy5AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiA0YSfjp+H+OOVQBYk3YFB/WqryK+fmCNTJ\nCE9m1DZ5sAIgW2aeajQbmley1qFP4MHf4L1mKwstN+6/tWDBRUomarg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATMzUlAxQAqRn/FAFUPSN8qBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjFhOGNhYi05Nzk1LTQwZGQtODM3Ni0yY2FkM2NiZDY5MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQeq5byl/suA0iK+B3aJY06EGdntBDpwdV+s2dzSwVmpKh\nNcUzVfsiiAcI13r00Re1eNFYiMHd+dGksc4yUwu7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGPQnuMI8yR5g/de/rLw/qxYs\ny5AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ43hCo3jrpAC1v9GDGtZIBupUB0TpzVE/nfVZHzzX2HAiA/aXt3qqM6\ntutjIDNpNRQR5aXUS02dfp+d2R3/czTRAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISATOAKQ6U/X0s+BL95bqioqVhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQ1MTBkN2QtNWIxOC00Yjk4LWI2YjktMDE4OGFjZmZiYWM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2OTM1NTA4Yi1jMmU0\nLTQ3YzAtODJlMC0zZjI1NDMyOWQxMTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT/jgv3FMQNXZGSVtoSVaNn0/ne1bWGYZG8cdvGVbhV9/XvuQRTpd6ZaqXRxf76\nacR8blW3SnA0FXuer317msl1o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQy30ucV4/wV6ON\nPFQvlL1WULIOdDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgKiseeo1+nXaP3dHLU0iw/YXnr0qw8YWxaDBkckNgeCkCIQD5+pyg\ncJhLwyNp4J6H/YaRbqdIL78Ak/egEYYqVsv1Vw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3453", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3453` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVabSdFOhXZ2ivUQY/4lfD0iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3Y2FkZTRmLTM0OTktNDY2ZS05NzVhLTJjYjBjNGJmOGE5ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmMzZWQ4YmQtMDIy\nNi00N2IzLWFmYjYtNGYzNDhmZjFjNWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu/HnkfV6YBHYmMuADge1IMOvyJ6eF1UJK2I2hD+moNNsuBmMYTAuYfQq46kg\nuktR8c359BYZOEXy4T9jejOXE6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFi7YyuACsQXSJlnIMRJlbta5n0gwHwYDVR0j\nBBgwFoAUpfS/vZOXcwHGr0DW/4IhkZYN2K4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAlyB2Xq5Z+fA5ka2tLBcBEx0ZnTY/Txy6\nUcmyTeD7kH0CIFi5jExpWK9s4AEQzCNzyJQMbk0+GUbRLgZ/1i8p5klE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaJds6EA+/t2mA6i4tmV7jVSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2NhZGU0Zi0zNDk5LTQ2NmUtOTc1YS0yY2IwYzRiZjhhOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTPmb9VZOz6pCpb5iy37sbn0oMZJ1ach+/2OEV9rdF6h/o\njjX2uacYNIHWZatMZP9+0wX3MQ+QkBKWY9UXZywbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpfS/vZOXcwHGr0DW/4IhkZYN\n2K4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSVExbk3leFZ/mJO9N9hkbo9764Lsh0Yf0J+NGRHQMMYCIQDewZZ6aYcm\nZCGb9ugh3vH911Dd/93IHGJxtt9CDybSJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAUx203rupcIoyML3tIMFzbqDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmMzZWQ4YmQtMDIyNi00N2IzLWFmYjYtNGYzNDhmZjFjNWRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNzBkZjdiMi1kNTY4\nLTRhYjYtYjRkNC04YTJiODdkYThjNDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATpBoqYLAfjbrBi4PtQ177SqPP5ARSs6rIpFnAsbfE7mPbVz/pW1OOVJ1LVj3bb\nAMWDF3MTthgvWg8hI8N5L25io3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQWLtjK4AKxBdIm\nWcgxEmVu1rmfSDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgRWoZ9A00OHNJbhZXyLVUFJG9zl0jISHNW/g9zJ0LvvgCIBKQhseO\n9XJljhpvLdwgLz+z1TyLR5NUrXtDXdE93HKt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3454", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3454` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAZBvkesrnOB9yaBpWuaJv+x+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2NzllZWY2LTg5OTAtNDAwNS1hMGJmLThjMGNkNzg5YzNhODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA0NDU4ZDItZGRi\nOS00ZTExLTg3ZGMtY2Q1NjBhOTUwYzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzNClWgsPDy+pdDjIqZyIqgwUCYGKxdLyZt3EdSNPJY2+uJglN7k6+Be9Pu3D\nDueHaCbN5E+73TEuPbzh8AyLs6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU21+fsefi4xSIHT50dyzNCk/VR8UwHwYDVR0j\nBBgwFoAUGjE3xJYCw02hqZ1FTjy4kmWXPW0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAQNWvqKAvVKVgC\npeuxC8cU+ez7boB0PNwJ4kzbP18BowIgVBZmgZGFjwpAqefRtFOeBla5FsQtqmJp\nO3hIKhIvVWA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQn8pXBpn6lg1Oa31L75/1UiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjc5ZWVmNi04OTkwLTQwMDUtYTBiZi04YzBjZDc4OWMzYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2W86hvF112RxR9qCgbqTzB7mqnwDVaHjOxGnjBsEP2tQK\nAuelTqsmTew95OHAQ4XxHr17CaaHM4VOfPMiOJ2+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGjE3xJYCw02hqZ1FTjy4kmWX\nPW0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALODe5ee/3wFGxtUsNusHD6nm+znwZjIaMnZCKsFVhLjAiBeLmA9fpNg\n2C2aG7+m6GRh6uDpKsFeFenUTn+ajUKVjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISASogTNsFYe8rFh8Vs6M4m+jkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA0NDU4ZDItZGRiOS00ZTExLTg3ZGMtY2Q1NjBhOTUwYzE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YjRhMmEwNy1mODNj\nLTQxODMtYTgyMi0wMGM3NjlmOGM2M2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARxsHXa3ZpBZxzlrkOihnNBtVcEIuUkMk9tI+Taqc1xoO68R6ZEtvR9rkCS6V4M\nZvlU/vBtPELCvJhM0uMfJ/F5o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTbX5+x5+LjFIgd\nPnR3LM0KT9VHxTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAMKABkPoSLi7e8A4ZKYdWOdS2Ld1LVGeMqEBM5jUPWJMAiAQ5BgL\nvnP7dOF8f5v5S5eELDxYslQmfLvBLDYg9gn3tg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3455", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3455` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcHA7zbg/CQ+/jUZEebxERf+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmMDZlMGVlLTFiNTgtNDU0MC04MWU2LTNjMTg5ZmQwZGE4NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YyZmZlZTgtZjVh\nYy00NzJjLWJlYjQtYmQ1ZTc1Y2U4OGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsis1gD9TXn9sjc0nYAkOlDfVdvfgvp8kG24BS0WsNSrLeeG4WdJvXori9tRT\nuS9BGjTZNHUgRm7qA1IMr0hx0KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9TXNosR6gaaFt772ivur6giZ/OEwHwYDVR0j\nBBgwFoAU3qed/mz8plNidOHbT/MkEFyBbLMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDC77lDKLaeuxZpCXTYwmO2WN92J10L8jAvoIqogGamfQIgdJEa3i90hVH4\nAIObrJz4Q3TGhgMJybnfaOMTrZaJ1mg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVPl+hQ5iX846a2A2t/oIh4nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjA2ZTBlZS0xYjU4LTQ1NDAtODFlNi0zYzE4OWZkMGRhODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbez5jdtu8FeXk8abbyTqir4blSOVYf+ij6X6xNdtYEGUz\noO7QMxTgO+5ceIUoAoM4dczI5piEqY/pmtF1pSffo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3qed/mz8plNidOHbT/MkEFyB\nbLMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP90bg0CkmHH6UqVCJRFewVkDETI2uPPsG6FGu3rI3yECIQC74G08dbUW\nqqiO09R7myDqMZYW5aaw2HlCOcyNzKMGTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISATDlEkdc9CLwoL7RCBUvl+ndMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YyZmZlZTgtZjVhYy00NzJjLWJlYjQtYmQ1ZTc1Y2U4OGZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMmM2ZGJmOC1mMDM4\nLTQyMzktYWQ4Ny05OWJmYmRhMTM0MmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQMCnEfxrBVPTkcomOvCYkq6UV+g+mJbmcrZHd82TN4MCtVegMsxOnqkKAFfEAi\nM6Q9Cj8y4D5ufwkEDqJuPe6Do3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1Nc2ixHqBpoW3\nvvaK+6vqCJn84TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgDnp3uA3m486Id/AIPInR5njxCGgsLyiYM1+mzlg8siQCIQCdwGgr\nei9FslWH73oUwtJBqLVc7sShSzbgBDkXvUTybw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3456", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3456` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWIr6Tyhtz7EKW4nlr12C5yeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ZGIwZGZkLTlkYzYtNDgzZS04YjQ2LTE1NWVlNGVmZjkzZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI1NmFjYjQtMWYz\nNy00NzMyLWEwYmItMjdkZjFmNTRmOGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqV9HehgVW7KxdgRY+F8DqTO+KhEprYV6uvUT2PqAOQtCUdltjLClu51Nklk+\nrGzEfiLPkW1Z7kZrMO4UGW3KwKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbcVKXbc7w5bZtsGdebKVCoipo10wHwYDVR0j\nBBgwFoAUkBOBWaIRsfywhuxIDlmxaYd3zpYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAQl4jKB0/JadOq+O2Pl4bNmJ6wzLXcRLuh8jP/baIMVAiEA0GnS7kALOk9D\nP3P8lIWLOibuJI+exN1MMUAc7uPUmao=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATJG65eMd5w0adKWZYE/cCXcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWRiMGRmZC05ZGM2LTQ4M2UtOGI0Ni0xNTVlZTRlZmY5M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9Biicgl1uZF/M7LIG9WpXrHLxfBXWGL5tJIEQ7Iw4lhtb\nwLN+at2qmojUya3A0lyFU/61S6WMRjQcF/K/6BaVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkBOBWaIRsfywhuxIDlmxaYd3\nzpYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPggFMOen78Vuhva55NtY14EtHVLvRDPJWNoF0LEQNY8AiEAyS06Bz2l\ndWh7Mmxc3vApXQTO5/zkSgWqaPIhGxOTifY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAd3hs56c5m5/2NTSX8v52ETHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI1NmFjYjQtMWYzNy00NzMyLWEwYmItMjdkZjFmNTRmOGY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZTk3NDUxNi1jNTI2\nLTQ5ZjAtYTA1MS0xMjJhZWVjMTJiNmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARydbps9k4PxPqKfTCV3zEjpfCbfj08OYB2hpPVaVaK7DcNiuyrh37ptv/sH/l7\n+se6dk3GsaVwCVZ8+5cboTwlo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRtxUpdtzvDltm2\nwZ15spUKiKmjXTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAMpDi2gJW2v96/z0RqUxL1R1k/uOBPx+HVFy3/x6jOenAiEAvp5m\nuAWhjAiSrG2SbuG513d2W702UvLTMdIWfvRSk+c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3457", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3457` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAdCENWX9qqu3rUjwORe0xip0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNzAzODMwLWQ1NDQtNGM1Zi1iMjk3LTM5MTRhYzllYWI4OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVhOGVlYjQtZWJh\nYy00M2I0LThlM2EtOTRlNzFlY2YyMGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtDohC0Q5Sp9YthPbz2x3azAvc1CssNGLApzxlSe+fiSd0L7rowSbePVlPUKO\nMxhvjkfkJrsnRKLDUE+P3D/unKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBMUiXGbT+7ywqhmMiayXIkTU8AswHwYDVR0j\nBBgwFoAUkmIWj5jb4b/W2I6gvf9I9TU9L+swNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAPvUlXyiuA54+mCYWSwLLXxXVPBcOq1/OLhPfX8M5hCgIgclHj1hQtodiY\n78yoUh92G/oR+3crwKHAZNV2dngsyG4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdN+phxg0BquwA03mJexjeK+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzcwMzgzMC1kNTQ0LTRjNWYtYjI5Ny0zOTE0YWM5ZWFiODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7cRdqdDhcYblTXUeBsaGAHM9Qv9zfG0thJFBej9DZBsuh\nrvyzu4OJAC0eiU5JfuWZncvAmkblp5MaIV7ErYD6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkmIWj5jb4b/W2I6gvf9I9TU9\nL+swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI9U4kzZw+xwCocB+05AUMYnrR4EI/0NWZAqnMeLh6q/AiEAxNfzmVKy\nAZKwI7h3qyDaDnj83Fu/CFucjRnNinEdo2M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAWF3WyQjzYCk78/dsfymCd9YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVhOGVlYjQtZWJhYy00M2I0LThlM2EtOTRlNzFlY2YyMGM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2Y2ZmMTU2Mi0yNmYx\nLTQzOGMtOWNjNC03YjllNmMzOTcwZWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASvWO74CXbXY38WncDl1QVnXOzw9N3YTke3T6OmPAQfNfC851/CrpElns30QCxf\n0mmXJ8Jx73IDj7G3f101U9z/o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQExSJcZtP7vLCq\nGYyJrJciRNTwCzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhANzYyrEHUrfD5a4vPcgngT/3CrZy4CVtcGrdrXT4SN3XAiEA/6wm\nFi48/TvaHvpco4uWljSQo+GJq2NVTOjFcXZikwY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3458", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3458` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAb9VwDpNCVAkkgjHZfkJmsHNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2ZjZkOTBjLTFkOWMtNGI4NC1iNDNlLWFlMmU3YzEzNWIzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmUwNTM4NWMtODc2\nMi00ODNlLWE3YTctMTM0ODQyMTgzNDFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeq9mGPaSnrsh7eZKZZlv1sCGYna1oVxJW1uKHIT+WIyPCAyTTYGDUcWo6sgl\nefUi2RzRgE2aFHQTbmYTQx6EXqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAinJJ00qlTOO01fHJH3XvxvLtz8wHwYDVR0j\nBBgwFoAULtRN7IpbVvzyZ1ys7pRCw/umOrcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBgTFei+jh8Nk68zMZf42fv5ExdkSafm4zddvD5No3k\nmQIgEbb951PrVflHxWem/nHGosyQWa+s9BoGNoZ71VN6SNA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXq0ChaHyWfAD4vsaq90V5RoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmY2ZDkwYy0xZDljLTRiODQtYjQzZS1hZTJlN2MxMzViMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASI7Be+ZrayQefoSQgsL9Dz1msSrCHpRe1Cjc72KKXBQcyY\nUF9iiEuLFsj6/rysK+n7R2tMbNjGKHlrrL6H0ptto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULtRN7IpbVvzyZ1ys7pRCw/um\nOrcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJkioqtjDApt3IZTb5xPnmcuuoWz0+CRUhXco0oyo6DjAiEAimftwnq9\niUXKJGSIDVUb/kiZqZE/c3wFuNpg+9XX6Ns=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAQoEDrTYrwsqMJz3rlpcE1+5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmUwNTM4NWMtODc2Mi00ODNlLWE3YTctMTM0ODQyMTgzNDFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OTNhZmFkOS05ZjU3\nLTQ4MmUtOGQwMC1jNWI3NzVkYTBmYWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASu0+sx1nLsaFh6FhEOxN8AOJ3H7N0EE+Ku8vNfvAxwamlMp9foGA9FwVKfRWzm\nkGOr88MeRDPFkseCIKrz9Zyyo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQCKcknTSqVM47T\nV8ckfde/G8u3PzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAJxSKQyPXVXgRwsFkCUCng/RO1PVfnZLRedk5JsetYaZAiApkPRa\n24a8oreGLKs6AUa7T65yoj32tvOPrjdQfi1CMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3459", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3459` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWSoTZ/oVq5lXekMUqBo6YXtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmMDAyZTAwLTRkMDgtNDU4YS1iNmJlLWUzYjkzNmQwODQ2MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFjZWM3NTUtOGY0\nMC00YjY0LWEwZWMtNjQ5YWJjZjZjN2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg9fcnEkEMuRlEPo1KweaRCHKVhfd0D9+veBcRT6cItjU+B22kVDXwalq4YE5\nryjSYr3IBhresXplqrt0TG2q6KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0pcU3DVNwTg+EPASfudVMOIUd00wHwYDVR0j\nBBgwFoAUN/AvNTD6FpDM8GVSV5OWwHcR1NcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAoDUxn0TfFUAWf+i6FUu7tkmjFAGFPDsqnAwwMRigu\n3gIhAPQGYT2qtTzMz12C8btPlE30c7D+LKRZtr/dfFM7kxCk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZl/gV5vueOZHCKF1FzMoKczMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjAwMmUwMC00ZDA4LTQ1OGEtYjZiZS1lM2I5MzZkMDg0NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQefuGIr+yr7jAMbL/AB98XKzG/A1zd0ERlEVmntYAHhG+c\nAPjRR6P5YV3K/Li6PffWl/ot+iTwHnr9lebYDASFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN/AvNTD6FpDM8GVSV5OWwHcR\n1NcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOZDwpIxulT0tmdj0mezqdi8TfYa3t7+Xp2enD4oXM2tAiEAsKEwAg5V\n2A0pkFWehDExLgxY8a9NsxWVsJ20LI4JA5c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISASyvaK4JRBacbizNH5MSIZayMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFjZWM3NTUtOGY0MC00YjY0LWEwZWMtNjQ5YWJjZjZjN2RhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZWNhMDYwNi1kMDRm\nLTRkMzQtOGFlMy1kZTVjYjUwNzMyNDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR5CbuuI7uB6n68QE8h5VNDIULzVfPNlW08cPum/iHF2+jA0mZTzwd9+EgdxtBg\n6zhcBkeO3ZkzgpQKhULAFvz5o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSlxTcNU3BOD4Q\n8BJ+51Uw4hR3TTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgIixp+RKuhHcyReluPrJxGowKIWypqxOTTIvx1GYJAN8CIQC33PfC\nlf/O7OkVGNyKoiLoI4DmO24RUr1Cy+lYWz5lSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3460", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3460` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWytzxE+LPlgeZj2LvmVrCoxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlZGM2NTdlLWFlMjEtNGUxMC1iMGU3LTljYjRiODkzYjJkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk4ZTBlOWItM2Zh\nMy00ZjlmLTk4NDgtYWQ3MmNmNDA1ZjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHF8PdNGFk1mS8ar6URR9DBXmhD+Sp4DtNe1PRSUwG2Ix/hH9Y0HE/tlxyiDZ\nbOLKaf0RCj1Utu36UfmtP+2NO6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcvZSIkrIg4d4MM4z1E3qynO17NUwHwYDVR0j\nBBgwFoAUSfn8GjzQuxXmInBvWjJOpWFSy+gwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiByU9Dc3sEp8NCi8XVcmHYkKMZwVVPQrzUi4m2QrxT/wQIhAMKK\nIni/uNMqpk1vmWe636e51NJJTfMNI637LzoOhJPF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfBzf20/RPQQIGM4s780XDdnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZWRjNjU3ZS1hZTIxLTRlMTAtYjBlNy05Y2I0Yjg5M2IyZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9AiGssq7K++lA0vQvB2t0mFIr9cgNkkz+xHyqfP782YDj\nQwfqdYDYFEXSJOnI8SOskCRhw8vBl+jjwxdBvYjEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSfn8GjzQuxXmInBvWjJOpWFS\ny+gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANaTwrW9g0xurszi99KkSBXbknfX+IHPrcjlellF0/GSAiEAukdmv6mA\nZm6Zo0JFIQXqT63R7YhpmImqab5yTcnE7+8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAbyCSMPN/UfU9V52gf+LyR2PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk4ZTBlOWItM2ZhMy00ZjlmLTk4NDgtYWQ3MmNmNDA1ZjQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZTQ3OTQ4Zi03MTY2\nLTRjOTItOGIxMi1lYjM4YjVhYzBmYjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATyF0PFkH+mqtL14s4TcEwUHBqcIqeN/EBm2Mwi9Im0dyrCZcXEsL7EozkyE0cy\nVt/KKUr95576oquJKtWMDg8Do3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRy9lIiSsiDh3gw\nzjPUTerKc7Xs1TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhALFvuvd4FgPKcjZVV6jmsrQjCGUwtuQBYQmLDFa+lFhZAiAXi+1e\nOZrpzZM79NcsoY/dYVcJnj+lbAjdR2FdHk2azA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3461", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3461` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAc9XGjhAIxurX9dkq092qAAMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMmRlYjQxLTIxZDktNDZlMi1iZWY1LTA4MjU4NzEwZjBlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDExZjk1YTYtMjM4\nOS00MzkyLWExYmYtYmMyOWUyZGI3ODU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAScT3wK/b4BGk9B1PBSSroR8pF1wrwRvrGMHD17WhMzaE43rJFSqKcneXIXe\n6HPepqNzgNRSzCZKNmEXQpHtWqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiGffQuIxO0dbsJvUbceslS6Cz/YwHwYDVR0j\nBBgwFoAUbCnjg/ZcR24ekLibh6Yk+/McF0UwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAtLTc5vGkfJYONWOMVMLVa1Kci7rwCfhp\nbTg/fOrrZVMCIQCMQgEgh8dLAYvU8TC6knQLVItIN6qZeCaNdJXGeo1I5A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQr1SK74mXB6HwVatnSD6pstMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTJkZWI0MS0yMWQ5LTQ2ZTItYmVmNS0wODI1ODcxMGYwZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRPTjQv2SR83UAtgNTu68W3bNoJZ/o5iMY/M19hN+NS3ck\nkAiFqFcNOYT9EiYTNAK3pybgZH6oguxLBk32Gfn+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbCnjg/ZcR24ekLibh6Yk+/Mc\nF0UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRL140vJpvEUuZ6lCU4zC3I+ahla5CRejzNUNbBRuG9QCIDtcwo+aLKz6\noMNZ1YLyps+jaXPGebzO+ixX7To1L424\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAZKzzM/1c33QTWW/WlNrpH7dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDExZjk1YTYtMjM4OS00MzkyLWExYmYtYmMyOWUyZGI3ODU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZDhlZTQ3Zi0zNjU0\nLTRmNWMtOWU0MS00NDRlNzU3NmNjNDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATBLrBJpGlcrq/oacU49PXhrFbDgn+zTJUna+6g2Uil0scY9XryGyuiGLXorTaS\nrpYlhUhvoFG2NCosDL6xdIcJo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSIZ99C4jE7R1uw\nm9Rtx6yVLoLP9jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgWI8oFD4LDrD7wvOBjCKNlYaKVuhUZY8etWygi93Vhw8CIQCr6oCy\n1HAxLJFMNkSk57YkEFV7RV2rlcqhus6MzliHMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3462", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3462` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbCY5KBu4bELJdgPr+Wd2S3fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4OTkxODI3LTE3NDgtNDBmMS1iNGQ4LTI3MDk1ODk1OWU0MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ1N2U2NjUtMWE2\nMi00NWY1LThlNzgtNGI4NjU2ODYzZWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExVAoEzq93UMdV4NBe8ttlsD2vQbEtY8X7Y42xdegbdIpJPXGRLiY/pdsdCw/\nJuKCb+Tos49cq3MeDbyDGHumYKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFZFOU5ovYR15X0e8IhftHSK2m2owHwYDVR0j\nBBgwFoAUF2Cgc+UAnBxbTW6mIytg5ZA6z3MwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAzhOt79QQPiPQ7mNQonABnS5pTbTP9crL\nawQX9vMxIw8CICYbfjkSGrxW3PMcrExQw3faCSAsLKvc9ZXEwmMHXq8O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARjulV1ilzj5UQfgGI03H9MIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODk5MTgyNy0xNzQ4LTQwZjEtYjRkOC0yNzA5NTg5NTllNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReoUTNIgzYAi5rjwhrXnsCBXrY6HEH71TYHpfOHuiw3Gwu\nlckrAzM4fUlY7H/msw/SvF/Ar2spNi392V3WHFBxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF2Cgc+UAnBxbTW6mIytg5ZA6\nz3MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgczvJ2Tsv5czWIGfziBJxXYD9pN8bLLHB1s5bhDtg5UUCIQCCMVOuwXGx\nonnHTUNEUmCvRLN0U0AatLDGM4AumvodXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAQ4QISuj0KbPnchFO+ZnV8vVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ1N2U2NjUtMWE2Mi00NWY1LThlNzgtNGI4NjU2ODYzZWU2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4Mzg2MzUyNC1mMmJi\nLTRlY2UtOWIwZS1kMjQxYjVmOTM3MWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS7dU9hRJa1tknQgqi+Agd/QthKMSwKi39WB5mPZWHx1rQpiQXEupEMEqS8/LF1\nECFDRpsrTD5E0Wv6Lt8oa93uo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVkU5Tmi9hHXlf\nR7wiF+0dIrabajAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgW3HHLEvxUOCAHDBWRIiDXX2U8izHqaJEPZUvJxNfxp0CIQCtsyyC\n8SnD7OvYhqUD8HNvozsffLbT/Pi70hnNi7MeXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3463", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3463` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASfOV+jNzvSpKOpR4PUIUVDeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2N2RhZjJiLTJiNDYtNGFkZS1iNWU3LTM5MWZlZmJjNjc0MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMzOWE2OTMtMmEz\nMC00Nzc3LTg5Y2MtZTFlODAxMjFmYzZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbGU4/tauJOgtbye6vIQEnLHOh91ITfKq+d2IBhOZZ498MoEYEdTwE6j5qo4y\n2iPrFLookGmOafmnd9XzZZTcCaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWXRs9w/GkHhoOGqbX4IDv3hKQbIwHwYDVR0j\nBBgwFoAUqDSxzfVgsItE3oCJUU5XbMksdoowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD+UrIfW51INn3JqEHXg74fhM6H\ne1GpCaCqjGTndy5FngIgF74IEJxBoooykbEX7vgnyfZfGWwC62A+8hGcv1kPMuU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARt4IlMGcqdu7EiAgEtdtfOiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjdkYWYyYi0yYjQ2LTRhZGUtYjVlNy0zOTFmZWZiYzY3NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8JKEo9Hj+EU/kmU8EwWJe6u7EmvMuaw6CIiYDNAXCaR4G\nZtD0U1rkWyjgNCsbIriFnSccR4XDWgkUPjPE2chXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqDSxzfVgsItE3oCJUU5XbMks\ndoowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHwIfaMsJmzIl4mu3k2aNlJ9bvhr+enWELDVNKxsK6DYCIBCGwwVBFLgN\nYE0OBPG6jhdY6MuWVrAhVRUV6vVXy/OL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAfb/1eGpEqHYYGQvaMQ1YEckMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMzOWE2OTMtMmEzMC00Nzc3LTg5Y2MtZTFlODAxMjFmYzZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMmIyZWU5YS1mZTE0\nLTQzZDUtOTU1Zi05NzY2NTA0ZjgwY2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARqZXVd1d5MJbtEHWM07YfhYC+ndHFqyD84+5xxk4741E3UUPUPLxKzShzJ3+On\nfzWrcYsW3mXYJXVzPCJKneMTo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZdGz3D8aQeGg4\naptfggO/eEpBsjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgAcs1VwiJx/rE+s7IWWv5n/6KNgSWK+B0Xf3WP/I82HUCIQCXtKgR\nUXaLY2HLK6aKXykAkeW8QXxM3RgksAbMofBDAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3464", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3464` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAUKZkOVry6gSB6Set5DbTLu7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwYjM4ZjdlLTY5ODgtNDk3NC1iNzM1LTc5OWIzYzE2MDVkMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJmZTU2NjAtZTNj\nOS00NWRiLTk1MmYtNTdlMDA0NmI4YWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE99t/+RdcIwBVwMPmWSz6vfBRMn9KG2d7Ou/cbt8NZAVv0NNIicUNK1To9ZRl\nKqxmc067Cv4JRn1BfJ4jzKgmFKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfnnqZsfGgitX2z0BGMFjh9QQaQQwHwYDVR0j\nBBgwFoAUG906QVE0kCcChmdBbDbxXB0uuMkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAKH9xW00\nrskyryQF4dDlMcYdl4lFGtOSs10dAZw+u5vpAiEA16fG3mRomIddHuQ0y6RWghX/\nEvxB+QwYKYfgJKVmxds=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW6fAztefI8gXG59C5qUGKzYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGIzOGY3ZS02OTg4LTQ5NzQtYjczNS03OTliM2MxNjA1ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR6x7tfppUKt75MrlLjXxvtXWjZRz980kqrCGeKICFrqEJ\nz8xg3PG5OHxDSlGeVWbQPpGGxrleUNA5h3eBS3Zoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG906QVE0kCcChmdBbDbxXB0u\nuMkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJjdeOAaUjTPjxpd81xv6eov6BYTpkTrzRf21U8F9jgjAiAshof9Rep+\nAwUM6DXyfsTfhOW3odqrXLo2XAQzQTsNdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAXhCEjWSZb2vv312uXVglTlsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJmZTU2NjAtZTNjOS00NWRiLTk1MmYtNTdlMDA0NmI4YWY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZjUyM2M0Mi01MTg2\nLTQyNmEtOWJiNS0zZTRlYTdlNjM3ZjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATvfZiWIPi2MT7GU3fNvapi9jLBBI0hCkfYCE/bT9stekHa9WO+LM0OnnJ5dN0B\nhwqy6Xiitt4UgsfLyyNICuaXo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+eepmx8aCK1fb\nPQEYwWOH1BBpBDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAJOZinTmvGb0COWJm37iKadTo9kiTh3wVbHRgdRCQu2oAiAsSEBi\n0doYZsgJOGSgdtC/EG9kRZSG9dZ2MnN5ImNvWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3465", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3465` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISASZCK9BcQ4DpecYYfcyinAvKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxNzczOWNiLTRhZWMtNDhkNy05NDFlLTljMWMzNTVlMTEzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYxMDdhYTktMTJl\nNi00MzQyLThjOTMtYmFiMzUzYTI5ZTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERLrOjNBbBQTHPGAtxUFlE9oGT5RT0j1TEv1JW65nGD/F5TVE1913PDu0GH6z\n311NpjEzDwvLOwpue7bLbnVgpqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqhFoXoO7bONUVhQNyOJ2jcWGbmowHwYDVR0j\nBBgwFoAUx7SUV6JMKoIDa+qpM4LByuVsugQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhALD1ui3/\n8miOmedhynVItGhjO8fhGqEYBmBvU337dq22AiEA1hXURpbLRRS0uINxg/ZU99RH\nFPoOWoE28mYHkdXhHQw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASUF3BkvW1jAklz9HIn0+FYiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTc3MzljYi00YWVjLTQ4ZDctOTQxZS05YzFjMzU1ZTExMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcLzp3+gfOV+rDime68j+S4Xoe3xdvoXxOZjuyu0qwsws8\n09DQrM2ORXYpz+42/IKB7VzAknbXvy2U+sRfbC3Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx7SUV6JMKoIDa+qpM4LByuVs\nugQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK8k1ztTUujiP30+zNiE9sZVQjldPTkR0b7tcu1ZbXg3AiEAl0A6Oyld\n0nWxISP6CkXS3UZpVT2c6sF5rt2JHAZn2Yc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAVoBf/KtYnciHimEo93fqfPGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYxMDdhYTktMTJlNi00MzQyLThjOTMtYmFiMzUzYTI5ZTFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNDcxZDYzNi0zODlh\nLTQxODMtYmE0Yy03ZDBkOGNhYTU1MDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT1lUTDuMkq99QQhN87BvERV78YJEFjJAdd2sKvSeT3btYIgMjDT8mP5XceUcNg\nL/Zb1egElQ/musQgWfsg98q/o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSqEWheg7ts41RW\nFA3I4naNxYZuajAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgVcw8FfmBPZlywbtuud9JEHgCEVeYoW3fkQpLHpB4ZBQCICToA3rw\nOdYTDtloJP7KSG7b2ihJ09GntpvJsv7qklRT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3466", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3466` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAXZzY7YKy7o5QP5KRXkrAksPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhYWE1MzVhLTg4OWQtNGNkNi1iMGQxLTMwYTMwM2JkODBmMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY4YTBiYTMtZjNl\nNi00NTczLTkwODItM2MyMWFjNGRkN2VjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIEojKSAFpHy5jAt5A1rTXtuQDTqhhD1tGygd759LZM+fXDnkENO4SaxVzlsj\nIAmu35aNzjcpRUMIt0J6FCjaeaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUehr0FJfyFLezJRn9xQga4tavaAswHwYDVR0j\nBBgwFoAUOLOP8qRxXV4mmICwEtJtMUpg6aYwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIE4ppq1V\nQ6v57w8Op5R6z+2w4eUNcAKGufmpeQkvk2atAiEA9xEVmT19JxARiEXVf3C2pde8\n5STBwPbZrjSmW3FKKSc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATkjfcFKOCOA+oaePj/BXZymMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWFhNTM1YS04ODlkLTRjZDYtYjBkMS0zMGEzMDNiZDgwZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+MVaM3vLPedpsd2RueK3ZmfN9BCuqivMsKjMRV3BB5zRI\nhipQwB/7DYBsCHWl1cdaWro49sSdbZYOEb/HY7oqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOLOP8qRxXV4mmICwEtJtMUpg\n6aYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO33K/k/lE1Qmx/Ga6AFBKqvOS9w22dXrq51tggEYx0UAiBsTc8TkT8W\nhlSc/bDxL31uaIWB5/rCKJ/ww7gYe0L2xg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAZvMMUWLeoQ6BmIZjGWidkYRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY4YTBiYTMtZjNlNi00NTczLTkwODItM2MyMWFjNGRkN2VjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OWU5YjZlNy00YTY4\nLTRlMTctODRkNi00NDllYzlmOWU0NTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARAn6wwK7hPRwghUlJpEJKo73qZNUAAikNv874/T9QZdEFrwznKECcGNXS+OWXB\nWYAc1CwojLeereykVu3A0K04o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6GvQUl/IUt7Ml\nGf3FCBri1q9oCzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAIO8IztNrzMprgaNvyxu3k+UN8npnL5ZDyCP3LD9HdGJAiB9TXxG\njQvevayFBfdp/rfDpH5NCsjUQ7BMVGDsufGmyw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3467", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3467` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARoKG2hUO3Bk0tE8o4uGGrRVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiYWVjMzc0LWZkNDgtNGM0Zi1hNzE2LTYxNGIwNDEzZDJmYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY1YjIwMDktN2M3\nOS00ZjAzLTk5ZDItNWE1MmY3NGJhYjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfrA04drCpZcYELM5Qk/ItPrjS8RF3yFgHtntzuKI5LCjYDDJrZFcwlShV0Og\nxNVTJRqt424xVZQ5v6ID4onVEqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ3ZKztzrcmUci5W+00i8YY4E/eowHwYDVR0j\nBBgwFoAULdt4z6JFUUFjJkFr1mhuAqPC48EwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCSAJGgVl6G0u79H4NDg3ykWeCHbo2aIwTIEyCesRsAmQIgeV8qGgRC\n4SjcUo0lQjy4pqQ3dzmynGIZEnipc6cLdoI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdXz+2gbQ6WvpnJ6IhFs7r+zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmFlYzM3NC1mZDQ4LTRjNGYtYTcxNi02MTRiMDQxM2QyZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATM1W3qZ5AcF3403FoCxHWIm/1fxEhwKOdmMXU6p2oZI0Bu\nSGcwlM6ptbRflbUgF6qmqbI9lvzPcXW/qRRgY+Loo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULdt4z6JFUUFjJkFr1mhuAqPC\n48EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS/a54sTuGS50K7kL6naA3pkN6MzWIzII1izIjzN+fsgCIQDbhNfsvNWk\nEDPWznf6+kkG4nknTFT0hB8s403igjnN8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAcY0nA6xQW+9y/Wz3i8tX3jwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY1YjIwMDktN2M3OS00ZjAzLTk5ZDItNWE1MmY3NGJhYjhhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4Mzc3OWJhOC0yMDhj\nLTQwMjUtODUwMy0wOTVlMGM0NjM3OWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATb9o+lpciDgc5lVJ8En4tRBF5zOskxlifjhEZrg3Q/ShbyVQXSDDRy3kRj7qJM\nMc4cRYBRJROuk/EmPbx4m2xdo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQndkrO3OtyZRyL\nlb7TSLxhjgT96jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgdIBUtDbZwgPRjI9s/n2kJetu1eYbIelBEYYQiEQ5VgACIBZU+I9O\neyuJJKgpw7yv0p2MFFQL/I4KUvx3aoQr7pQC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3468", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3468` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQ3olORshFTGPX0BtF39gPsfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjOTk4NDBlLWIyODktNDVmYy04ODM4LWIwNzlmNmZhM2RhOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMzMGU1YTEtNzRj\nYy00ZjBhLWEzNzEtMjQwZTcyZjU2ZTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP3KxOPOEGjiovZLjHgjs6ef3JClv2/qP0rOka1YY0ZeqNxvK9I3Kpxptk9Qb\nkcIGvEtAGFdIncRUTKwW0nZCuKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbX9YAIMWvdg7SQ84FEcS0QNhIIQwHwYDVR0j\nBBgwFoAUYmGY9gLoVvwK8L8bOFe1+3p/r7owOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIEY1QNUwj6dKvmxOBBk0Oe9it8qZrls4qv8wezLYeTtbAiEAprq7L5CK\nErcrh1DI0yxjr4PGdTlZJLuGuadyE5ysOiA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVglAO8sgOvuQAbqirEIL8JIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzk5ODQwZS1iMjg5LTQ1ZmMtODgzOC1iMDc5ZjZmYTNkYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8wWv2wsw322+njUNitpruk8aorHo5YsSW+PmW1TFZTakk\nEpKUUB+psXqVFQ9ZRaLXouwNnOdRV2OkhW5X3BvWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYmGY9gLoVvwK8L8bOFe1+3p/\nr7owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM3miTIyvYBJSbgV6Lfaduwu2EhQxdI0SE4RVzmz8E1gCIQDABhPUl9tK\ndLQu6evHHh95xhALN6pgNQvGozBAFcrEJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAW/1XKx0YpVaJM8eM9BBlyYOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMzMGU1YTEtNzRjYy00ZjBhLWEzNzEtMjQwZTcyZjU2ZTAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmODNlZWVhOC04YWM3\nLTQzZDYtOTZiYS00ZDBlYTNlMWM5YzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQyoI3Rn7nHLBV1XPxg+6tG4uCTtGasMIeRyzvHv3GdWP4o/eAlnKn1UfFB0tA0\nwL/qA4MFSMcC6WspXfgyZe8po3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRtf1gAgxa92DtJ\nDzgURxLRA2EghDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAKIsm7BZmDUCAkAk1gEKGgCNEbYArovgdaIfbXDmN5IKAiBJi5lH\nATHaq/qV+q/UgdLlrUbLd8u16ukcyEA9q3VwEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3469", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3469` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAfYh+cyIMvuimu72AvajK2RrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MTFkYjNkLTNhNWEtNDcyNS04MGYwLTllYTQ2ZWM5ZmYzMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc2MGY3ZDYtNTEx\nYi00Yzc1LTk5NWUtZWIwYmUyOWIyNDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4eVSyMlT1QZJH/Ch8PR3EB+agjub8vrs/+wLvpjYEKmMFlEq9qzVkXx06oRP\nrcpLWQrU7A2uD1UyMYlWaAA2hKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkr5dU7RZt/pI9529K9heURvJme8wHwYDVR0j\nBBgwFoAUdR+uZxOZ5QeY+gjAmA8xgqgeXlUwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQD0Ujz/EbcsWO18l+YtQ8mhPHwzxYrqVFLm0H2Zohzt6QIgB4m/Yj4Pn+m+PsSx\ncVNID+HNkzMo+nEEcGuNnBxzU5U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW4ZFaurHBAmySI35fX4R0YRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjExZGIzZC0zYTVhLTQ3MjUtODBmMC05ZWE0NmVjOWZmMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEKdKNMofYetjLwmRUvfY3p8XpOT/N6wstg6Jcth6ne3wa\n+r5oUogPq3ulNMgsLsSsmqx49iMrcHf0nLDDU23Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdR+uZxOZ5QeY+gjAmA8xgqge\nXlUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB49u/C+Xu5+UEQkx8RuaKy3kHcb6kPrM2GPwcAmbgUwCIDJxDjwd0vqX\nEmzMASD11TBUAaS4hzkfqQzFGFPmO75c\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAcw1I/FjQ4cW7V+BNUlKBecOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc2MGY3ZDYtNTExYi00Yzc1LTk5NWUtZWIwYmUyOWIyNDIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYmYzNzgxOS00ZTRh\nLTRlZmMtOWU0ZC1iMjRhYWM5MGI1ZDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQdvwRpgt0OWhNPbi1CjBrwBVwz5+23xkme05NhPRnmVuXveOg1vPiI4nqqWP0k\n3q3Bw6RJuk3iq6zPkH/3LtYwo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSSvl1TtFm3+kj3\nnb0r2F5RG8mZ7zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgFuD4mBAh/xuz5kfmkIiihy57dxzhLs9e1fkS04sW4l0CIQCwbS7c\npKQHCescJ4FI6u5gYBF1Opi4pYdUagsq95wNgw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3470", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3470` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAdcbnizgfRYYKrVSCgiZbJyFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiODNjMDhlLTg5YmEtNGJlNi1iMzU4LWFlMWNkODBkMTZkYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDM5YjMwOGQtYTM2\nZC00NjZjLWE5MTUtMDE5OWZjNmU0MWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEopO4P5t6vpT/Wq2pmPtnpMYezhisR1r1WobUBusFtNbS1G1afs3n4BYABExs\nVqrI9XNG4gqLQwl7n1lgmk03mKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy2pgKGC/mqsRkXdaWNO/DxXYQZAwHwYDVR0j\nBBgwFoAUjhoJVS/FHOq4jWtQbIRwCM6iN0UwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDetJuq5hFiuocCIiSFhfKT4bFRb5E8T0nL5eCd6aLVLAIg\narKK8KWYHtY+gykV/qR9nK/xUXLTpdrBiUSIr2JiepU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXM81OCY5QuHpOjA81XxjeZqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjgzYzA4ZS04OWJhLTRiZTYtYjM1OC1hZTFjZDgwZDE2ZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGcsVfAS50ZJpZgvAINX7Tbiwkj+OYq3FdBZybQJa+VdKi\nE6f7kMzPgplf8ttEoMfjMqimc6EHf5K4zIbiiUcXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjhoJVS/FHOq4jWtQbIRwCM6i\nN0UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD1lpNMQe5fWuzejRSFnp1P2lrKVjsUyEEnTqrSeImB4CIQD1yvNKG8pp\nKm4Rcef1qSjF9IxUeTOSLXWH6ENZAd3jXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAYI2DCMEwavP17erMkdh6ofNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDM5YjMwOGQtYTM2ZC00NjZjLWE5MTUtMDE5OWZjNmU0MWE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMWUzODc2MS1iNTQ5\nLTQ5MDItYjZiNC02NjUwZTFlNDI0MjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARp8vI/GqbWZFqSDMkoLlOqHAQ01zkRawwxx9CcPJY/0nvEbEHV42su37HcZK+4\nyfeOjMm/bfQg9/iOglcgZ+Uao3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTLamAoYL+aqxGR\nd1pY078PFdhBkDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgNqnwbZCH6wvmFQNPMd4KtQUFYweBrQpwE/NMha3S/1oCIQCEtqjl\nxGLLgZXGj2uIV1jrZSoUowJ9KDzumKArwTNwRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3471", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3471` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAaKUuQQ/dfs3nNcFuK3WXuRqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZTk1MTYzLTk4MDgtNDM5Yi05ZWNmLTY4YjVmMDBlYWEzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjEwNzY5ZTAtYzA5\nOS00MjRiLWE5MzItMjdmMjhhZGI3YmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo+1sM5NHOb0cXSzgOOccY1hELpsJkMbpdKUrxXfFrR1/2xmbKCvfgCGABMDe\n3d3FP3n4+8Ktmdh9ojTLfFJKzaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwXXGzaImh/d1ELVpcf4DblbwknIwHwYDVR0j\nBBgwFoAU519vpOotm3Fn/IlGQF9xNQ0JPhIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIDqjc6PcVln8qjIVP2Rinwus15B5w/kWaxKpcxSt84lzAiEA\npJm2wU1HnVGqMkgMzRKTbCWDD/bT7KhlA6anN5UN7Nk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXlHX0FWv12/E7bmLy1pFjE1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmU5NTE2My05ODA4LTQzOWItOWVjZi02OGI1ZjAwZWFhM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT60VzmqTwydgFnknmOSykGDXSb5giRLDvW55lWrSi3S7/y\nEOukpWFS8SL5+ChYcmiiq8jat1twbrhuypmRYNpzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU519vpOotm3Fn/IlGQF9xNQ0J\nPhIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQMJuQjzQeXLsbodVi8oH8+WtjIBWrkHdhzYi/S9gCekCIQCtC0MMiiXX\nla6fptsoK372apM/C1IIv3G1BRHoE293tA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAZlSAX8Ir1+ezIAYoCdYIntYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjEwNzY5ZTAtYzA5OS00MjRiLWE5MzItMjdmMjhhZGI3YmViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZmRmYTBlOS0wM2M1\nLTQ1YzgtYmFiOC1mNzBjNWRhYjU4MzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR29rGaFLHnaKJ/0nruI3qnXARhfV5Epk+je3+xmfnT8bIHBng7QSUorJvEbo4c\nEm3FMtimj2R07eL+W1U8bgBjo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTBdcbNoiaH93UQ\ntWlx/gNuVvCScjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAME4kIAjKj0irG8PLDX6/JY1xZDRKhEqB82ZMlSWDPFQAiBI8lbM\nN9w9PO885WtA93eZ8D5p9KNHJRBjJiQeJ3dFqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3472", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3472` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATHe8AQp//TuZqu6vC5YQa0lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1MDMyNDc4LTI1ZjYtNDU0Yy1hNThmLTRlY2UzNjJjMTQ0ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg4MTdkY2YtMzA3\nMC00NjcwLTgyOGYtZTg1Y2QyN2Y2NjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFGfS7Iinjobk0EX1SAzqP2kSYyT02Bs3mgUaB//5kJtFpco54Fl+uC0tAy4m\nTpE8YlTriLQGh6zbLHPkEXcAKqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx+ycmIcpzqACfy3OeosZA8tQegMwHwYDVR0j\nBBgwFoAUmZJtTX+xJSEfjLh+ePQuA6/cd70wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCICs4pw9qs392\n696BUQJkDfR2ITtUBh1TmCZJ5nAshZmxAiEAiYHlTA5HWUPPSO3NIqV6+BV1x7Y7\nF5kOHrE2vSAvbgw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYQd3Su0Pf0VCslNbAME/4tBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTAzMjQ3OC0yNWY2LTQ1NGMtYTU4Zi00ZWNlMzYyYzE0NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHK0VN9FgyQjgmLwNntxKR7UXeptZcaGI7C2vSRJNDV1vk\nQqQc2Z8JRqug/QK1rm9dwXr2ZYHeQkgYyDnp9Qpko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmZJtTX+xJSEfjLh+ePQuA6/c\nd70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDlyFoNyaoFD0U15mPOcE4ZyYEuhQerIdFr4FKPriZHECIQDd3ghdC3Qg\n2/yCluU9wrKCDCwnorfhJJFjbsJhKT4yZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAYKXiTWTxPcjImCwdgJCri/hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg4MTdkY2YtMzA3MC00NjcwLTgyOGYtZTg1Y2QyN2Y2NjI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMjIwZmNkYy0yYzNh\nLTQ4M2MtYTNmNC1jMzk5NTM5YzUyZmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASJpCto3c5JsXtHsn3+OnV1pSHejfsAvp/L2kAhp0zzYa9UlzVXA7WB5TXA+RME\nRJU/tPa7gkmW7l4vUFKA4HQQo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTH7JyYhynOoAJ/\nLc56ixkDy1B6AzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgGoK2arBOi9nAfmsZU//KJEe8Xy4Jr6dscwb9DId9NvoCIBeAQ33w\nex+vdFtDULw3ikgHsw3D0WIEXoxTmkVc1BM3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3473", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3473` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfune5pwgx40Ju2Bmfh02N5yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMzc1M2Q0LTQxMjctNDEyYi1hMmVlLTYxYzE1NTY3YTdkNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJjNjc0YmEtNzdm\nZC00MGY3LWJiMzItMzU1OGEyN2IwYjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETtqbdHXWYRVFTIWY6+P9W/lLxDreMuzwlhqzi1DL0ryPnz6AcUvr+M/Uig9D\nrGNa4yau04vu5IUvskPIOa753KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7lwxbsKfg9cktw1asgYcRPXfEMMwHwYDVR0j\nBBgwFoAUyqhkc8k+ZADVU436horbc6ZACKwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgZ7wRjRuLroXkm9sopAJnu4DkMd21VIG3Aac+utRybUUCIQDwcuWBoTMy\nXuCdKamMkkrjO7iRuzszDwo+7ahpGShsDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATIo/XVBYfxiCkk+PiAFThEFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDM3NTNkNC00MTI3LTQxMmItYTJlZS02MWMxNTU2N2E3ZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTydhhBmKYVYWO0spmrbC4ZkBkCC5GGMk7SpZARhGAjcDI\nFBfTQSxVwMGMjS9BnDbyn15a9zOSAGvsQuQiUTizo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyqhkc8k+ZADVU436horbc6ZA\nCKwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANhGwBnIuzn3lNE/KvCrqazsv/B982O1KLyR4qAauQ1QAiEA2Gy1IEXu\nv4x6N4c4Jc/19BYCjtLL7+haFmCPpj/bUVI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAVOsWnQme8H0Qdd37YDSIHGmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJjNjc0YmEtNzdmZC00MGY3LWJiMzItMzU1OGEyN2IwYjJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NDlkNjMxMy00NDVh\nLTRmMTktOTcyZi0xYjQ3ZTY2ZmQ4YWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQaGW0Ep/2UDEdYp8XHJ2iarlpf2nngZHmFWx70WnCaRFlLNfwS8G0raJG396Sg\ncB2Ng+GuNehqRHb644N5Sw1zo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTuXDFuwp+D1yS3\nDVqyBhxE9d8QwzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAN4klaS3ulzQLnxh57rmLh/SokAWWhEMGL/lx+OlKsOQAiBSyUeQ\nfYSfGqiVcAYRM+J6EIDspsKDZh3odYy45N12Lg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3474", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3474` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISARPx51/1LFiNLoMtWJ6ld8G6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3Y2JmZGUwLWU1ZDMtNGU0My04NzQ0LWVmYzUxNDEwOTYyYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZkYTIxNzMtZTM1\nYi00Y2FmLWE5NjMtM2VmOWUzNWViNzhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfk8dLu15COwZfUEmtdrQMirVCjAPVeuzmN27O8WFX16ewtKZVui+tT4LSWSU\nyNazCmFQCEdW0rX4IB3f4MNIWqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAuAzlNnSf3loq/7wuYq+lTk0CT8wHwYDVR0j\nBBgwFoAUMYwFC20S72wsNLHmt8NSZzUSIE4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgYeMD8MqbvMFLPtcqxCGksse+zTfDkz422QJREvwKyHUCIFg0eF6mkuNj\nrx+BQQ2bzOvarMNlZjJzoN0iThMtyFBe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQgAPP57q9vpFvJSP7LB1m/lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2NiZmRlMC1lNWQzLTRlNDMtODc0NC1lZmM1MTQxMDk2MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/pZ7S4ip+uwmOK1HM0Tc+EHBN3Ed3Ju8bw5jz3XZPEO2V\nrIL4hY2Megxt/t3YbArK8wjp76raNn9hSlmGLe8Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMYwFC20S72wsNLHmt8NSZzUS\nIE4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIgvFddDEMFWY0FQ+TKBZy6WBzfIp2HdRr6How1MyxWIAiEAlRdcucOG\nru9SPxlhtp67CNVsD9pWxAJL+Biz9CMSC5U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAYM7/2vm0Dy05jJszuk3HX+XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZkYTIxNzMtZTM1Yi00Y2FmLWE5NjMtM2VmOWUzNWViNzhhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwY2IwYTZiOC0wZDUz\nLTQzM2QtODg4NC04MGU1YmI2ODA4ZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARbNWXplHoBAzRAyptQgVlXmUsOUEMX7HdVJ2NbqH9yNM6QqL6EZyEVnXCs6Gzh\nuCKk9aX3lMRILXA76o8junVvo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQC4DOU2dJ/eWir\n/vC5ir6VOTQJPzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgcypAhaUNZ/HIw6xckPWjHQpo5rihljx3RD5Qk8EBr1oCIQCpumok\nCWZNy8Ab3+Ui9pNO/jVMYc4TPqTsfMkZqLHRnA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3475", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3475` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARZ3bhS28PgUCUFH0PxMf3cyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwNDE3Y2QwLTdlNDItNDc0OS04OTQ4LWNhZTg0ODc3ZmE2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYxMTllZmEtMGRj\nOS00ZDUzLTllMDctZDdjOWEwN2ExNmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKjBm4oIW4RJp7Zyax5yAz3SHCIDGnaWXbswKWNQzKQeoH/Vfpo6JY7cmOq6+\nErqtTFKuUlGhWJqi8b/jSzj2oKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkNjiQ0r7QR9T6oGEg8/BV2uJUZYwHwYDVR0j\nBBgwFoAUPhSV3waw/k0/MoaICyPf/PDIstMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDNrNTVB7LaiJ7YLDlLlFUjkCyys8q5mnkpPzOA6+rvZAIgPIkPdPUA\nugYDwtGm4bBWi65kBO8A5THVjf8bYlgIXjs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUFhh2KKPU0ReP6BdpCyS5GXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDQxN2NkMC03ZTQyLTQ3NDktODk0OC1jYWU4NDg3N2ZhNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfFBlXF/rgQZWkfWZ4UUEToyrXU4ZT3ehbyf0RXr86cHf3\ngo1bMeG1uSNXS8p41iqcMMmICUdk85kd56OnQsGfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPhSV3waw/k0/MoaICyPf/PDI\nstMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK3SIVK0CshOmOF7/MDXOzXs5+i11wwUmiICbGqhcJC5AiEAphoPZQRK\nDWOsSQNhnl+M42zmFE0HHzXCAKovJFDxgh0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAWx4jbguYnTPs+wYuL41/uB/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYxMTllZmEtMGRjOS00ZDUzLTllMDctZDdjOWEwN2ExNmE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZjhjMTIxZC02MDc3\nLTQyMjEtYmFjYy0yMzkxYjFhOTcyMmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT8auyOyFPU+NxMmshNs0bYCgoXsx2XtwQSh2T1x3sCLYpsXK5Cr2Mtt89ZcIHY\nfCWRNdD1R03ptZQ6DFsTVAsxo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSQ2OJDSvtBH1Pq\ngYSDz8FXa4lRljAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAP4YrI7P7PQEJeCgxEj5wXxcTJYGBIVcts+j6EAFV0SOAiEA5wDg\n84odI1KwMRMZ3fnSBoOlEGA3U4SmLwWZbMrTZAc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3476", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3476` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZTdm5k/ZLJbjnAhAUN+CXcTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlYTllMTBiLTM5MGEtNDAyNi1iNzI4LTQ3Y2Y4NzNmNDNmMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNiZjdiOWQtM2Ux\nNi00NjU4LWI5MGYtMTdjZjYwOWM0YjBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnWdo2Z8kgmRQejHOncm8S5P2nrYgiH5Bk+5sa/3r0ljSe9airlL0W3WgLrDJ\nWkluns9VB1jy3oMEVqT1pbcaCKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmL2fpbTSCEeKzU2Nf7dPaQyWvZ4wHwYDVR0j\nBBgwFoAUNsrJCl1NCkJMuZZTBKu6gCxXUFcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCICU2DBF451S60MB5DJ0vHOyYfvgqLvWKTc3bRdZz\nUb16AiEA6ouK1GQbPCJfYtZ/UM6L5QYoF7/CokZzvxreSUSFmjM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfv2bOnwU7Rv3kbspcJfM7MlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWE5ZTEwYi0zOTBhLTQwMjYtYjcyOC00N2NmODczZjQzZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASko5a58GHUo1YaUDzW/syFYF7Pbmn2N5tVweeMqQdRa3dd\nfen3Qmv/OERdV6j+yAiSyHXmLLzydSmGKFOOOrVno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNsrJCl1NCkJMuZZTBKu6gCxX\nUFcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdcJOQixGRJlDGKNH9P8gQF93g3ym+ebc/XfskKfKzUgCIQCTe74OgFcy\nrUqDkuoDF22IiGv3/g1ftJwlNQ+30FfzCg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAVg7adR0YNe2ywSY9MWLs52HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNiZjdiOWQtM2UxNi00NjU4LWI5MGYtMTdjZjYwOWM0YjBhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNGMyYTA4My0xOWU0\nLTQ0M2YtYjUzNi04MTU0MzY4OTBlOWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARR9UUT9KsUlOqbukkpKbqYXXmGD+tUX5H7qOIiQ5ZEPj76UYRp3MPBPMGYdtfQ\nUdbMfqFwh8rz5m8RdplfXkRuo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSYvZ+ltNIIR4rN\nTY1/t09pDJa9njAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgSaA8eORPKune1h2rOS+DY95U82Y+V6MoweTiwqCquYQCIQDM9KQ4\nfUYmocM8jsqa964nzS0mBI0Yp0MDeV1bgP7UkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3477", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3477` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISARtXsCAXliPSu4CRcHw2pLNEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlM2M4NTFjLWNhYjEtNGFiMC05ODRjLWM3Zjg1ZGFlM2RlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc2OTJjNjMtZTZl\nYi00YWQ0LWE1ZjEtMDgwYTFmZmQzNTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+DJwH4aWWuPvDdSn9+983DXb/z63KV8JNQC7uCRt10M5fGDH2WqnXJMBq7tw\np/3jt/uVCf15NU2e27ziP852bKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa8Bx2b7ddZPkWGu+wD47qB8lWHAwHwYDVR0j\nBBgwFoAUOjNxwppL1xiufvz+PUyuuPfGlakwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCf2MzjygnX+O/hcEFuqPa7oV4R208QgaRWj0OK\nZkdYFgIhAIeVuxqUJbZH10eyaLLRkQyRhIS3Jy9SpLWZcH37otzC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARuccft4/9rWF2oSuUiJAMLKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTNjODUxYy1jYWIxLTRhYjAtOTg0Yy1jN2Y4NWRhZTNkZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNbD1adXAkT/La6fYpkudSB6E3nk6WbPvxserE11izX9ES\nVfo5Pn7rPvnArnKXJxIqVyM4KdoA3uSfcsbbUTt8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOjNxwppL1xiufvz+PUyuuPfG\nlakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKAusaLOI0f5YmjuWhA6U5nocJiqNPCU5o/0Ng1+NLPYAiBCxFARa2ZV\npHtCYj/MdHyoPm/7FG/kaaCaB9s6qmLlOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAdhDcv3LkpQ7IfarGIs3eZt2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc2OTJjNjMtZTZlYi00YWQ0LWE1ZjEtMDgwYTFmZmQzNTNmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZjMzZTA0OS0wMWQ0\nLTQ5OGYtOTI1ZS05YzA2NDg4NTg1ZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASdshO1V6vfukbE2ieukuEb5Eh8RpKNofJw5IJdJN6vhAOAMGALI7sd45U2yN1y\nngtLuG1sPtIkZw9zLiZj1fKio3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRrwHHZvt11k+RY\na77APjuoHyVYcDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAPv/6xeQB2ATVR6D/+VSo2dy63Kqco5fvAGa3tfQgqv6AiAfaMWe\nNSdvYeSXOroSpdFlNYQDzQI1LuXE/xIn6LwdJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3478", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3478` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAdmIOlUwdyX6vpi7XyGYKfZ3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmY2M2MTlkLTRmZWUtNDBlNS1hY2NkLTliNGNhYjA3NGY1NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZmZmI4NmYtZDhm\nYy00ZGQ0LWE2MzUtOGVmMzQ5MjViZmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZIBhVheqniy+csVjp5PtmuSVKImSlMfqnkRZ1IxjjgELLX7WaDnqRkVvRuJe\nJvgd2CqE1jFnJLnpSz1D9VksfqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN83PmNTs+8Aa/CYXfSfx+QRlxm0wHwYDVR0j\nBBgwFoAUWuIXSjWE5s7DEa4CnOGb05ICPbcwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCEfREeB+a5tww39pyOyY8wi6/OwXSnJR2q0M8F6q6KTAIg\nNG3y1DAqwVU2i3kNRly8UBCkXYzfPM5+iVyHggDVfOQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYzAnrDsuHj+X5GE5wjUee/sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmNjNjE5ZC00ZmVlLTQwZTUtYWNjZC05YjRjYWIwNzRmNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu/SqYoTHjqIBg27j19jpGEK7LWp7Wc+IBB7aSeyjV0OJd\nlS8Agg+jFIoR5pborZpZRwlYxmabck9UIJcbYVBto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWuIXSjWE5s7DEa4CnOGb05IC\nPbcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOZKh6/bgDdJtlSMsp+59DmiHInM9TUpXd6pEyQEvSo9AiAipdGMHF6A\nA8UIpDdqP2QF/LpgbbUu9puxFKkWXkoBfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAavN9fGCf7LQeaaAqBxO6LvCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZmZmI4NmYtZDhmYy00ZGQ0LWE2MzUtOGVmMzQ5MjViZmVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYjdiYzZjMS0xMTI0\nLTQ5OWEtOTM5OS02ODVjMzBiZjhlZmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATgaIx9krUnJ3mdD9Lio/gwwHWig/PHfUGXvPuv2+CZTccs+AU03rCbG/XKlJyP\nmgFS3x9elUhA4reTtUwCPNJ5o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3zc+Y1Oz7wBr8\nJhd9J/H5BGXGbTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAPHzgbddS7Wg8e+KHw4cK8nPdrW0LVkNx9cwRS6Ls7I1AiEA3gln\nPhUepG1OrbFpqKtxhuS2tl5wpQ8oWtrxkHC9okY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3479", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3479` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAePVLrWB9ysfTRfc2TUJ6imCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhMTg5ZGUyLWIzNjYtNDFmZC1iNjg5LTI2ZmE1MDAzMDMxNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTJkN2JiYmEtYTk4\nOC00YzE0LWJjMzQtNjU3ZTQ1NmIxMmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV5HLVtHQq1O8r/Yo0eob3cV2fqG5riHwVeJAMWJHwH9uuyIzPhU/+ZW1qhrf\nSKOYW3OSttfmnWkjUjyRJ1R6h6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTRTQXxI5O7EAX3r+Q5Fg8P+hI2gwHwYDVR0j\nBBgwFoAUMu893xaXpaI9Vc4HjO9DtWgWlSgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCID5vpNduJyZqAOlbqn6LoSbythnoy922\nim3wrQdHdSdJAiBM/3p3GvM6iMf97m0TeEoDCHEu33uXd6pY+ARW0DHFgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUo6sIXmdTY31ACm74a9W+e/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTE4OWRlMi1iMzY2LTQxZmQtYjY4OS0yNmZhNTAwMzAzMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgu17j4Cnd8VtrgFbL/cuXhOjaLJ+aVjjmagiiGCtd176r\no+WnC0ROPpMdvAo/P3643B2kS0nE264oO2/W0j+ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMu893xaXpaI9Vc4HjO9DtWgW\nlSgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIxQxHGME1N0qeCsl5WoaHonR1KcO32nu/l6JRq1Ceu3AiEA1aabzSfb\n0aa74UNQUbrdaBNqtRLW9UGWMQLnf1vgqyY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAfE5jIEt0nSU7AoCgQ7qXHU4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTJkN2JiYmEtYTk4OC00YzE0LWJjMzQtNjU3ZTQ1NmIxMmZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYzIxMGQ5Mi1jYjhl\nLTRiNDYtOWFjYS04OWQwOTUyZDU5ZjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATu/UswwMBnuxfkmOepVjiA59MddRQeWEAnr9t1vBMHdUOhpWJIx/uKn0X5++B3\nrhiXsTmfimCaCcwllHSR64Cio3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNFNBfEjk7sQBf\nev5DkWDw/6EjaDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAOiNeIWVf6EqeXBowoUkqdlb/CS1LQU0kMSIZVy1pilTAiEAv+o2\nIw4hP+fNzT0SEkiNaqAhcdvkr8i1GddmFC44Ltw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3480", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3480` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAan/2+vSS/xJgahMl21EIefmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlODA0OTVhLThjZDgtNDdjYS1iNDkzLTU4Y2IyNzMxMGNhZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU1MmYyODktZjAw\nNC00N2E5LTlmNGUtYzhjNTMwMmY4ZDg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUkYPs+aNNORW8+0G4q+Xwh8iPDDQuyWRfcw8mP/NV78haImuG8LTSIMrtneU\nc6yQRZ18/ZYkjPqmVRYyAPmEL6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUbwLL8tx2fN6/JQ9DDVc0oPuUw0wHwYDVR0j\nBBgwFoAUZO9UqbjjBVIjVAjy09p3wCDcebowSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIBwWTGwsCqxnMY16pakOZGM1OvZX3RgD\nXzuajzyc4RIgAiA2Emb/NhtX6E0SH9ggJzHepY0TlqrRdtsCSof5yaOIjA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZVmhxytMhYZw0q352VQj8zdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTgwNDk1YS04Y2Q4LTQ3Y2EtYjQ5My01OGNiMjczMTBjYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYEdrrzHGtP6YyRUjtXiEAPAHK2NyG6k1rU8LbEc1mA4ab\nEHoL8xizQSk7dgrQ5memILR+a/1RvFrP23asZvHbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZO9UqbjjBVIjVAjy09p3wCDc\nebowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPxnDafbkzTt3Ot6Qzq0nQqgE4HNN20Ig5GOSlwCqPxrAiEA9uNk0oSD\nepfsRtnpcfkrtfl8gLspzV3NjbTuMHOMUOc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAXUtWAoDoAumcCBuW5wSvXqOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU1MmYyODktZjAwNC00N2E5LTlmNGUtYzhjNTMwMmY4ZDg4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZjhhNzQ3My1hYmY5\nLTQzYzUtODg0OC0xYjgzZGYwNWQxZTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR6UUznmOd8RjQo9uPl+Y0ohmT35S0+6zVAPcFKRAhLeRsjf6O6/FZWHc3c6oNl\nLi/XPzGoog7BWnLJYRblWt2Co3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRRvAsvy3HZ83r8\nlD0MNVzSg+5TDTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgcUODFW9UsWJgdj1oWIZjXZSrXV3DxabCzrWJN2d4wHoCIB9oz2rz\nLbgmzB38x82w+BkLgAEvY3qTbwtE/nqZfGOE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3481", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3481` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdeyHbhXgD/hAi4nyiF/isjxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5YjI0ZTkzLTgyNzEtNDY1My05NzUwLWM0NWU4M2E1YzZjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVmMmYzOTItZGU5\nYS00NzQ0LWE5MjYtMWQ3ODliMTUzMjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMfJEBwspa1E0gnFQYkcIF28PVQwomPf/lz/k+DwMLnSQSqhNbqh5tXe4uzTI\n7k3mGo+aLPbwju8m4rgG3Kky+6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaYZsyWJN0i2cl/MlSxSFNnFTcCMwHwYDVR0j\nBBgwFoAU/bpuDvWzZmQyPb4KyJx56gpnX8EwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIFkGQKh1AsvB\nxF43I+kuvTNTxPz/cV85Ns9eH4FwK8OrAiEAoQF36+QfT8i+1814t71DqjtW/mEE\nOd6b59WuJx4GQ/U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb5Kwl3wamy25P9k/JdjQEXjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWIyNGU5My04MjcxLTQ2NTMtOTc1MC1jNDVlODNhNWM2YzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI13WQvDU/K8G476YYI8YK4HPHn/swr8zFHxDRCyCfqR0Z\nC5eeIzZ5ccpPR6A+ghYnoKNpnB0bQuGvel9gyfdDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/bpuDvWzZmQyPb4KyJx56gpn\nX8EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTDLSExPkjMWqDOi3HByBW5A+Ag51NmPj6WZ/NKO/HLUCIALfxeRMjIOS\nvkWr1QTE9beJF3GW7CJiSAL/gbUkuVVL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISARpw8pzgqOlR5ic2EQ5T9OoxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVmMmYzOTItZGU5YS00NzQ0LWE5MjYtMWQ3ODliMTUzMjJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYjBlMjY3OS0zYWFk\nLTRkYTctOTY1Ni0xMzZjNWZjYjlkNzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATb1o9AGoX0u3tYFGWcZKjxstbRf4zytl4jSDr4Tcp8/k+jELdPnz2KRbbNm6bK\nnpe6aC/NG5b3rBcW030KTE0Eo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRphmzJYk3SLZyX\n8yVLFIU2cVNwIzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAI/4DydiCve2Gfo7K3BB88g+0e9urrLsR6EH8kojfPndAiAF0LLl\nGMZohohEY/sXxb8gvc/xpqXcwQYv5MRONXIiaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3482", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3482` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZQsdLuLwq1GBb9sqQa/Qiw1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4MjhmZmQ5LWY5ZTMtNDYwZC1hM2E1LTMwNzEyNDVmMTZhODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M5YTQ0NzctOGM1\nNi00NzFkLTkwNDEtMjEwNzkyNDExMmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERXxRr8sI/3FT3M/1vNank3fyGEFjltdpnYatGpim82QoHc8mMvAi2bMWEuHn\n7DOg2GxsDjrfa3hTppQVjxqsTKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIv0o0cdxDGbjCP6Y1jtQuAxMIl0wHwYDVR0j\nBBgwFoAUc46CicYo6co5KjbuUApCgj+OTkcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKqT5tY8lsP9MLBI7q/kx3VgR/twl9g/MUKpZ1ulALDBAiB2wG/CQ1gt\nmkRr5bjGVn+uDFzbGBxkxuEKDnXz6Z3hSw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc7zcFV5y7STRBMd5Z/ySlf5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODI4ZmZkOS1mOWUzLTQ2MGQtYTNhNS0zMDcxMjQ1ZjE2YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4fn+nCnXTMLYRUUm2n7AlQWEJgEILBzcHO091u940XTEi\nj/opwKKShH12ELG+smQvuVln4XWo/CsxX8WqPs7Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc46CicYo6co5KjbuUApCgj+O\nTkcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJhL10J3so1o4gmMlrjJbMr0Oo6mlwFwlZn/GmPZUAnlAiEA54TdNXtz\n/qZBCv+hBuwArMKywePNaPSirvjpOuKYRNg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAWCodCcavrCjEtvaWTxv4N5jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M5YTQ0NzctOGM1Ni00NzFkLTkwNDEtMjEwNzkyNDExMmEyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMDU5MGUxMC0zMGJi\nLTRlNzctYjNjNS0yY2U2OTc5ZWYwYzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQSF6Q2FNJzw2DvjlUfnt/na22yIcl0qjRUG3mSTWu1mNTBMrwwve0RG//qhCPa\neqvvrdcSyoW1TFVSwop0vUydo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQi/SjRx3EMZuMI\n/pjWO1C4DEwiXTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhALA5Bzlw10V4nI3whA48GaF05OXvDdceh4dwMAKsX7ehAiEAjv7m\nAFbwQf/+xrwihcRJg8AdNyiKOknFnvsfLQ1rlqc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3483", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3483` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAV7zvaJ2LC9rdxm3JPloASGVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0M2FjOWQ3LTdhOTUtNDgxNC1hZDg5LWE5Mjg2MWVhZGJkMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODY5OTRmN2MtZGQw\nMy00MjlmLThhMjktMTRhZGZlOTI0MDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZOe71ykGbfukg11kILBChQJwHaMJsBTQFkYgwNltdGwMGj7lhNDNXT7IGA8c\n56m6rDnOkRLgOAxgq4pQ2IuMxqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVBvOgW+GcuXIxOudWOqg1LV2R4YwHwYDVR0j\nBBgwFoAU3rhW1puMD9ArOVdnNqTPH/wnIfswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgAVVDtHYQp8OA8n3wzQ8pqlV+ayTR6P+Ey3timD8PStACIQDXxoj1/+lV\npTBlWSv6pALvCPW+JWEYFS8PN6ATPmB9bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcIYLCjD1y3afEfY5cKinTBJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDNhYzlkNy03YTk1LTQ4MTQtYWQ4OS1hOTI4NjFlYWRiZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxwcyAT78IlH4pzP2xH/Vatf5Zpke8Ofj2Y0SPCiXpC0DB\n8SVV/d6nOYdnptqBDHr2Akn9Gwo8Kq7dqb62lenno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3rhW1puMD9ArOVdnNqTPH/wn\nIfswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYm44HBZBcqOTsLFo8BcUmFZN8GMl0cOvXquhcBZxfaACIHoMJhQh4TSM\npZfuXdk01mBukYColsyVYUkH9o2ahiOk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAY/tdue1/jdwVMh/lZoqkZdWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODY5OTRmN2MtZGQwMy00MjlmLThhMjktMTRhZGZlOTI0MDE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjOTU4OTU2ZS04MWY2\nLTRmYzctODBmMi1jNzM3YjE3MjM4Y2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQBKN4UTb4SegdACQqpMO+v+i/qd7P4NVhKYsQIINKRJAfwYdZqQfffwMynO0q1\nhiHhIIZ3Rl8BN2zltIrc/Pqyo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUG86Bb4Zy5cjE\n651Y6qDUtXZHhjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgbI3XLVUasUv36AhsLbVoHSo1EkrjSb7ZinthXLm3LKQCIEWFRKnH\nNqLMg/91y2iZ3s43CQLH3UqVIVXf7192jyNS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3484", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3484` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeWg/JJ6yCBnMZOogmUNv318MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmNDliZTllLTRiZTEtNDk5Ny05MmE0LWFlOWJlZWI4YzQ5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWVlNGYxZDYtMTA3\nZi00ZTdkLWJiNGYtMDZjM2Q2OGU5YzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6NW7nDxvB4cNOm7MfBjo9dMxMqyOup+5GeuISLtnfroEF0KYnIRrjax9C2cx\n6C2ubrAbqFHi0RqhB+JuGBCgDqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl2GQAnbWv9WBg9tjI2s9Qb1heZUwHwYDVR0j\nBBgwFoAUQFLiePtpEjNBBJluVb6II2M2AV0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICJCsfc+PVptNbeiqHGZqaDsit3kMfCpbUuVbmBzLSOmAiEAy8TWz/i+\nFKPoVqKj8ENrIDaDq2IxZ0RAN5IZfSPeMRA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU2EyrLDeP8BfkDYcQFrQqmUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjQ5YmU5ZS00YmUxLTQ5OTctOTJhNC1hZTliZWViOGM0OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjE3xj/HgY1kJ5rNX+6YSHeRUsHOGPY3WRxOaow1CxPOlN\negIKaHCNXm2P3Xxo3VJ6IU/V935+oFEzrIvH35Byo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQFLiePtpEjNBBJluVb6II2M2\nAV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIVHWz+e40ypXa0BgrwiOfGyP/uTOR31eJPfiGr9LvmICIDrIBJQi1fJY\nxWIfZtJ2mpjABy6r3WZRH4/p/KbvRjtE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAQjvJ0GPVj36zb7Kc2ylUmqNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWVlNGYxZDYtMTA3Zi00ZTdkLWJiNGYtMDZjM2Q2OGU5YzU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNTY1ZTA2Zi01ODUx\nLTRmNWItYmYxNS0xNTExMmQ1ZTRiZTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARQtv1fsp8hGhDDL78y0P69Muvg0gvYo+8GPh/SM4fyp5K+1rPDb0/23DJE/SdU\ns5XrH96R13X7FwSkbFD+FqZQo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSXYZACdta/1YGD\n22Mjaz1BvWF5lTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAKPwiAYBkY6sPb9Ddj0YzcFtZQLutBgir6pSSAIxsQvDAiEA/eGH\nn3coM30YsMXeGehB6h2oWBkPOaCw/wyEVPrBcu0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3485", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3485` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAc6nh1IfSw7LYO0dfPI0U7jgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxNGZmMjUzLTFmYTUtNGZkNy05NzhiLWMwNzhkNWE2YTlkNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFlMzY2ODQtMjdk\nNS00ODY3LTk4YzktMGFjZTAxM2VmZjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpyllqVB+C8BSdu8ys0KbhVl5Hu28uiuQ9YdRktq1onKgeusiL01crss+OSQv\nc4VyZ1gBIMiuKnKS8UNzVzarG6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK58MGEbEFG9uKgy37ENBJ67XkckwHwYDVR0j\nBBgwFoAUcVqFMX86Z82UZuDK55RRN+sgrc4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDnouztc/Z1j0MxSeAc4N7mxSyGs4nwe0uOXvEG\nPVddxwIgI1PNx/3D2G5jmVY+fRDE0KSwX26EL/rKs9zhNcqOdag=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZZ1UTWzmEpUMloGsX3298THMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTRmZjI1My0xZmE1LTRmZDctOTc4Yi1jMDc4ZDVhNmE5ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJoMCJNJdLBKAk7RjquelWqRP3Ve7pishmQv4N/oBHEali\nlt+VfXjZhoK2lEhNa338bYBYykbKftng8Vznopl3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcVqFMX86Z82UZuDK55RRN+sg\nrc4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfTZWWUxrUc0fHXjU3LZllzhJjNbqBkjm8C6j9O1LKucCIBi4le/BHpYg\nYHZe8iWg5eWNmTf6vex7bTOx6euJyPq/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISATbQduxJfrstbb3jePIXnxOKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFlMzY2ODQtMjdkNS00ODY3LTk4YzktMGFjZTAxM2VmZjMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZTNiMmY0Ny1iYjdi\nLTQ3OGItYWVjNi01ODU4ZWZjZmFiOWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT91685E/8DyVKcHBUjFbs0q6qPaWrCp1xux3qqe+sUi8Px87YhgFTpOeIfVknZ\nNV9hdMePpxK/EzzmQBw2/SC5o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrnwwYRsQUb24q\nDLfsQ0EnrteRyTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgeWQNEcSEthtNS7Rw0CXXqVymnvVtWcELY572uVSX7sACIQDOycg7\nGp+uZiCTbvqA9K1c0GMLvXEoPsKdylRcGueb7g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3486", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3486` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAY80EuxDJXjiqk6tLDLyYVaTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkZmRjNmUzLWI1ZGYtNDA3MS05NmZiLTA5YjM1NGU3MzI3ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRlMzQ4ZDItM2Jm\nYi00OWFmLWEyNGYtNjIyMDBhYjZjOGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6AQYujI2mdH+NID70IdyHr9ednsso3kYRQWAIiVgcNSHdzwZkytkCjGNVUUl\nwxu57SOZ9ox3e93no8qG5Fs+4aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsuel1zCc6aVvNrmEFLfJsQQoPfYwHwYDVR0j\nBBgwFoAUHv/UKmmmRZRMIWrnhUv76BtDBmgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDV1k5635F+B04EFm7rTqdPJ6qAfvkUJSgFCpAj\nXbnt2QIhAME2n7W2ez3a1o4yveOnFG+RYC1kX0WDgsFVIDnHDPSQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASilFcoEdNd6ueLF+t2TD3uzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGZkYzZlMy1iNWRmLTQwNzEtOTZmYi0wOWIzNTRlNzMyN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTdM91Kl6MsZPliPAzlrK2FItN1NY1GT2RkNiErHM3fvDE\nVLbnxZkVDqkObH2Zm81rStUlm3XLi4WGkxPWxTheo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHv/UKmmmRZRMIWrnhUv76BtD\nBmgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUSwiG5tfoVJ/Ueg1HbhW+YWsHzc9nJJDh7pJ5w/DMCICIAPsZ2M48iOO\na+AqTqp1x0Ot7AQfqO5ivRzl3a1UH/ym\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAXQUX5n0WoDcMYwcHPb13H8cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRlMzQ4ZDItM2JmYi00OWFmLWEyNGYtNjIyMDBhYjZjOGM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZGNhNzQ5Mi02YTcy\nLTQwZjctOTFmYi1hMTI2YzNmOTE4NzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARKpyGqbTNPgwQOz6wzYMgt1zvom4bkuKFitKUS0K9TjgUOvORGrC95GvB6SiNL\n8vUM5obBVSBhnLivB7jonWnlo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSy56XXMJzppW82\nuYQUt8mxBCg99jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAIf2En0nt5gY7I3zd87l3JgbyXLuZ9J4gBYwc4NQBPmlAiEAxjRP\nQstDfrruGNe36rbBOd9LpKV9A7a1FrMx6iIMeOs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3487", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3487` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAW5c2ppvm1OGocl4nzaIrItDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhYTkzNjAxLTc4NjgtNDZlMi1iYjA3LTMzYzhkMjExMGFjYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjlkNmI2ZDktNWRl\nZS00NGFjLTgyY2QtNmYwNTZkNjNhNmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtJYL6GpDp/7/QFvOYo9WTsFRoPx8gQBLto+qxkpcaGjDs3xYfByMCIATbo2X\nSFyQpO5De0LQgrw+6m95dLZXlaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXSL/5n63U+cm1NR3uSGxOHt09icwHwYDVR0j\nBBgwFoAUK+4qL2bKs7N7qdkNBVVY9nt2JZwwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIEP2AeTaTun1iicI8aC49xzRxtA7gbFBU1YSxByA169yAiAC\nEWSZKIKKostC4jnL62tptAB4KiTzGvx8BzFvGleAHg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV2G9s9l9JFTuv1iTlv+IkMWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWE5MzYwMS03ODY4LTQ2ZTItYmIwNy0zM2M4ZDIxMTBhY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2EMpDnSW+DYqpiSsuAjluptu9de9EwM2E72eW2pmaolcF\nkFu02q+Wii/9jytauSyr61V9cIsmbBJB8l1B507Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK+4qL2bKs7N7qdkNBVVY9nt2\nJZwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWi+BbOcLPJd3zgnlm+FYpndv8RfWQcpT9PTFHQ5DWe0CIQDO3HrHAl5a\nhV3HkO4BjWabgjSq9h9fT1VvwFr3RPg9jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAXcAj6nCtSORrceqwbpt3sPNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjlkNmI2ZDktNWRlZS00NGFjLTgyY2QtNmYwNTZkNjNhNmEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MjhlZmFkZi0yMTBh\nLTQzZmEtODJiYi03ZmVmZDI4NjQ3ZGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQK4MV2Q62PvSWT9ibD73V6km6c29cH5HPe3bg1Qgo8buiGBfpVN/FOv6P16yFW\nzWUmtLAGVT59ZtoAteLy5vjYo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdIv/mfrdT5ybU\n1He5IbE4e3T2JzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhALop/bb8xuIsOgDanUgz6DeZksyRoOF53NYSNhAvAk0iAiEAgVf0\nsu62kCojjMg0wZ8kfGP1kkuStKLTw6lmChwDz1g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3488", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3488` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISARaYDJbO7cQ/bo+3/6xgsZx4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0OTk5YzU1LTE2NzctNGIzZC1iOGJiLWFiMjY0ZWU1OWQ5ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFjZTcyZDktMmU3\nYS00MTBlLTkzZDYtZjA1MzRjYWUwN2ZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEszskM8MRFTGzHWWuVHU2HIbq6XleqE4VEHc03klLn849diLQYBSaDNiP9sdG\ngdbJSAE0XcVRKhOyUR731tOQBqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTxuAG1qMIBCzSS58a+xZRuuuTskwHwYDVR0j\nBBgwFoAUj8FAWNeEaRAcaOZi3FoKhBvuMxcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICjmzFCStzDjpRlK4S1LHvd6TqtzOrHQ\nmxfGYF68kKBlAiBP/wDaKmBeiklu5ayZzcphCu69npI/uPiw84Vd8Lz0qA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXtJr3lzEPwpVq67jveKVcqjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDk5OWM1NS0xNjc3LTRiM2QtYjhiYi1hYjI2NGVlNTlkOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpgn/oNj8F2jROzlV8SWMqWq+ZGUjyr4iAjYjnR0mI5WEe\nhH3z7IrBLH8SE7XSqdgMB74yqrZ8Owh94ka3+HECo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj8FAWNeEaRAcaOZi3FoKhBvu\nMxcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPPfwentc7Z3pQUDdb2wZvNZEFGS+eHh6bazc0oUzXC1AiEAvbpVMcHR\nPWKDQQV+nNpSQeD1Ih3bTbWr/Z0oCw1Ot+w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAZN2xT0jfxVS2+u+TiNHFE0xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFjZTcyZDktMmU3YS00MTBlLTkzZDYtZjA1MzRjYWUwN2ZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NDA4ODcyMy00YmI3\nLTQxYjctOGYzMS01MTRlYjU3ODRiMWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS43t0s4WYLawuXLuklT7M4ojHJrPO7VOQNa/kj7Y8k2O+TWGTlKsPt4gHJg+oa\nBQZrw+BeT9jlNOJ85rrIDoZRo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRPG4AbWowgELNJ\nLnxr7FlG665OyTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgOMaMxV7zcCszb+kD8K4HasdD+0BzlSHzKQFnUuSgjIICIAKPu0PG\nJdgel/q4y6TSs1w0zzYiybByhTChF1ke6EZ2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3489", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3489` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAb6DCa2G7HnEKrnTjlUUUqqxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1YjhhZGEyLTU5NDctNDZjNC1hZDc4LTBiYzI3YmI4YTFjODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ3ZWU0ZDQtYTRk\nNC00ZTliLWFkZWYtNGM0NWRiZDQwMzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvSpBdfcVdFbcoEeknM63auAOxlS4O67szLQJluHRYlAaliLPaD/1uMokpWH/\nf1ad5ZIgxjC/aCErow8E3A3X16OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUwDSklghzQpGI1mjMvstp/i80OwwHwYDVR0j\nBBgwFoAUkmTJFWpzddYNsnNPzyHOj2dV53YwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD3vLd7UdJFAkigjpmVJosON2cCRFUs\nbz9hVMM+J7sWawIhANLgUL528bf9hv2X8TXOzStZtDVEPyqh37YRgLtE/foq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATzCxuX4HFJnAeqMrDQmpkBVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNWI4YWRhMi01OTQ3LTQ2YzQtYWQ3OC0wYmMyN2JiOGExYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMcdGwl7ISIHPoAMSS+/3HQYokhxK29XcANqCDK0+KpqhQ\npNL5f6MtIusZWFVxq2SXKkdH1ol8pbUiFq6fZ1Ono2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkmTJFWpzddYNsnNPzyHOj2dV\n53YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKf3+L1kuguJqBEq6nsclGzD10wG5omcVZrGr0vnvWqsCICWjpfI9HIXZ\nu+7mkctj3vUJXqojoO1l/HQCY5MtzcMn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAQQ4JtzecrdrfSIyOhyYtKz7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ3ZWU0ZDQtYTRkNC00ZTliLWFkZWYtNGM0NWRiZDQwMzAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZTNkZGY2MS02Y2U0\nLTQ4YWYtYTViNy0xZjQ0ZjUxMDVhODkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ4WjyKvrrYMEWUdh0Mthi47MbFFMCbzi4DUr/m6BRC4iCAwEaNclcMbu1tlfGC\nfxboGbfPUupul2YV2JrR47Yvo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTANKSWCHNCkYj\nWaMy+y2n+LzQ7DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgJkAg0ktEn6d6TXqefMA7fJGfM5/xOfUPu+ezQP2mHlsCIQC9Htu0\nSYFZILoulWABFL5cpzvFZAJievJed8WJsnUXvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3490", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3490` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAf/wsVcKZXZaEs3UV3Uv5WyiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5ZTdiNmUwLWEwZGYtNGQ0Ny05NDUyLWY2NDBkZTM0MTFmYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM2ZTA1OTEtZDE4\nZS00Y2Q0LTllODAtYTdjYTNmZjVlZWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKDxJTf5AASRTFG2v6fehMtvxn68cy+n6t0Lb7IgulsNEuycpVhtgMSaOkxO/\ntHl29mGS7TvJqVftebiUWNemqKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFG4X3ivzeWcIkcKQgcSG3W7eHwgPMB8GA1UdIwQY\nMBaAFJOy3dOd0MZlGIhMFwWuSkEYrOAeMAoGCCqGSM49BAMCA0cAMEQCIFrDOdOZ\nqCVNJgeBz6z+asL+BQDJGCgQ76z/6Vn4jJblAiAuBpHx3nGXa+vwqRPcfhO0rxob\nC7ERuvHODxbRBjxd8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXl+P61URSVJiwuM0I3BUMXJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWU3YjZlMC1hMGRmLTRkNDctOTQ1Mi1mNjQwZGUzNDExZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQofrpETUQPsG4l6aviZGNmF7/hQJTXiw5k6NGhY9R+mnvx\nnt92ZgJad85hl1A6Qi/DJkmuAn9BPnwkkkKBce0fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk7Ld053QxmUYiEwXBa5KQRis\n4B4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbZFznvLUXbVn8MJTr5eKLX0zeltmGyFFZViWrnC14F0CIBEiJ3f0vRhH\nSEfzfwjm8WdIXqEZVIHxmT4XJZfSgqX+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdlu1Bj7pZCiT1xJuBCDMUBmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM2ZTA1OTEtZDE4ZS00Y2Q0LTllODAtYTdjYTNmZjVlZWU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNGE4OGVmZC1kYmE1\nLTRkZTktYTNmOC0xN2U4YjAwZDBjY2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATIePuXo9pjPcrGlcINE58fZJZoaSFiAGWWe2s5ZpsqgrgPZD28tVbLXFGhEE+V\noC+CglCaKsNOlO/gawRjeezto3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRuF94r83lnCJHC\nkIHEht1u3h8IDzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMb72NGEVSB/VSbHL5nGGyjYvHOCxRueE86Vjhci2APN\nAiBiFsN227+6bpfnoAdUbe9nei4d2WPxmokXoQRgq8YQQg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3491", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3491` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQi8XjVfqgKnBsjQ+5t5tPq0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NzdhMzgyLWY1YjctNDUzNC1hNDA2LTZhMWY0NmYxNzBlMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M0ZjVmNWEtZDY0\nZS00ZmM0LWJhMjYtNzE1NjE4Yjg1MTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3L5qTRBAgSXylV/rORi1SoDTqvPg6Zix5a4/tRWOx8bowxZ/VClYDa0yBmPe\n8X/OmF2MdDCnVrjS1nXipKHfG6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOM5nOnbbr12wFEp5P1DWCM5s4+bMB8GA1UdIwQY\nMBaAFGG7J6R987VHMd41zApC/b3aaSOnMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAvjM2Vf3WDR58MvvWRzhlgydQVwUynQp4\nu8hyK79HR+8CIHnEAqTkWMjHw7/0G4IV4VRnpHe8P+3s1U2wU35RFqVY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXCMz54sPVcsZ6w/bXMknzq+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjc3YTM4Mi1mNWI3LTQ1MzQtYTQwNi02YTFmNDZmMTcwZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQV14J9bIMcW6XDPJu0yP14XyNysGkonK+j03gWtUuH/X0S\nIxbZimKofr7yFT23pJOApnsAIqfp5NSkRKFGhxv+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYbsnpH3ztUcx3jXMCkL9vdpp\nI6cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHniT9zPriG8nA8iHCfupgXrxqoRGmTdxwy6g+JJFb/4CIDz/v/CdETfl\nnxHd2mQehv47jl6bRvJaZ2+lXXGpYOnh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaRKyMtzzMomK6d+KuPK+M6oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M0ZjVmNWEtZDY0ZS00ZmM0LWJhMjYtNzE1NjE4Yjg1MTdiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYjcwMjk3MC1iZDUw\nLTQwMDAtOGM3OC1mNzU4YTYzOTdjYmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATAXhhKz2artWd7hKeJewnYW39jUyN2nvbfFOWtSP7kz1LjTtc/zfg38P2AkrE0\nMUUcXn3SrAbno0RNlHg/1m1yo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjOZzp2269dsBR\nKeT9Q1gjObOPmzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAM7ClSYbs73l9pdOnbL+ijBEVHYXZ/LXoFvUQvW2AGS7\nAiBmLgQLcA3+HgITvK7NXnFkZmDEzEAfc4K+3dpccpPBlQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3492", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3492` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISARnestiqwNLKcLRW/PDKyPg2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkYWU5MmFmLWQxZTktNDg1ZC04NDg3LTViZDdhOGE2ODBlZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk0NWExOWYtYjJm\nOS00YWM2LWFiMjQtYjAyOTJiNTM2ZmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEElcHS0FWjMnHoCY41DdZcrH3lsE5SXKWbJI7QsIrwgD0rBY5UAEOJuF2rfwI\nhXGfoKy2H+sksOjyO6oNdmAdYqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFD9MlW/6GnLIRUA8zlC8ba0UwwrcMB8GA1UdIwQY\nMBaAFAGUOARMEykkVlSRUgIWInhvkdUYMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAsvSa0P8jPq2mLxpt+3F5OdSZseta+OK4v\nbIzqXjfYdAIgD7RUKYo2vMr1xvL7QViLKj3JiNgceNlLyB1bablq0Qw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQUI1FM651c5Z1sA7z2vpbqVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGFlOTJhZi1kMWU5LTQ4NWQtODQ4Ny01YmQ3YThhNjgwZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBrcm+UOUzBPGWVNKgu+wDfdhh0hV91gdjOCYJNozeu+YQ\nwCv/JVfTK4yxW59paWthEr+pimag/6iIKGWFLd4+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAZQ4BEwTKSRWVJFSAhYieG+R\n1RgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJnBrEr3BqrpJaQ9X6fHp65cuL8Dwt3seWoTJleQoOrBAiBNaSn8QG7c\n2t2BJwINM7vQTiV5Z/naqi6uGli4I1HPeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARfSRmwjpEgrCNzLFoRE+3RZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk0NWExOWYtYjJmOS00YWM2LWFiMjQtYjAyOTJiNTM2ZmQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNjg5ZDkxMS05MWEw\nLTRhY2QtOWYxNy02YTUxMzI0OTcxMzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATAthWU7bbOTuvwuHDKJmeEg2iS+/L8o7euFvatOWVeTLCX5GOfQk06htLxFo52\nq5s74ZawzVrr4QFtEsQzUzPWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ/TJVv+hpyyEVA\nPM5QvG2tFMMK3DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgK7GGUh2qWOGX+w54JIeKVwFlEaTWCMQJ4jSE1RNGpxAC\nIQDR+HUdEh3xKl4h+DNXsJ1quwJlGL1rIFskJli9pV1oPw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3493", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3493` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAddK7dVprQJ7/vZ6G3w0eHXoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliN2ZiNDJhLWFiYWMtNGY0ZC1hZDI3LWM3OTViMTkzMTc3YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJjOTVhZWEtZDVh\nOC00NjQ2LWE1MGMtMWZhMTIzOWFkMTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWiHMJ6IRwoU2CLd/6uFPJJTojNCtOs18YEfJLz3HmJi3sUIrz/NFs7A7/Vea\nSQM3vB5HjAKxmjprFAV/bU1p+qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRSpo7gKiGN+fHbLXJR3lERaEHCYzAfBgNVHSME\nGDAWgBTX3HHBM5pDzU3hBEVrLa2vwnneKjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDWyudxRymO+76CVNK4txjwV8mRsJ1v\n+jsrkXY3bg8vhwIgeSTs4mkqE9zFnn9HD44iwyINY5lh1Bh4fkpZb6I6E4U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaJPlUw7chW1nTrId1jr5TtiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjdmYjQyYS1hYmFjLTRmNGQtYWQyNy1jNzk1YjE5MzE3N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRnuqbLMFk8PJkC2oijMsP8xXd3ybviV6s7r/UnFVl4zIc\ncWYCvi/9Z29nHnblheW5KlF2762zhPgD4V3MtNyeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU19xxwTOaQ81N4QRFay2tr8J5\n3iowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOqlZRxZzJ1cD9gxXp3KTeyA+qM0Am5nTP6HFjn/sCCzAiAi9Skzk/9r\nru9Nm8A5de0n34iAyHoXnWtj3g5OJIOXeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbRiZfEiMd4Jadd9pIUt7+waMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJjOTVhZWEtZDVhOC00NjQ2LWE1MGMtMWZhMTIzOWFkMTU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNTZlYzViOS02Yjcw\nLTQ5NWUtOTI1ZS05M2MyNzkzNjY5MDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ2Mik49bxYV1NATpQpjPgKkA5varrddFVAouk3sS+pWVHtrUyvH/o4rXabiVRP\nQAga6V0Tz9H2kbS7B/hO3TI6o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSpo7gKiGN+fHb\nLXJR3lERaEHCYzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAKOVAv+WOSpFovG4dhSqBxiV7xTZWWab/+EFX3UX7RQW\nAiBYNEF7BNLmJPlz/Hym3IQFEEw1cK9ZOI/fGrK62mKO7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3494", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3494` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAX49DTo7fWn9f9QPcYjynKtZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmYzcwYzI5LTBjZTYtNGNkYi04NzkwLTk4Mzg3ZjY5YzYwNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjNhMjYyNmYtMjhj\nZC00N2MyLTgxMjQtYzFlYWVjN2VmY2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE69kUen7zmQtCBIZSJ1RdARJVPc2g3ukusZHnk5/6pQw4FQIQhQSqPguZr1vu\n9xu0FUuwpYOZ6uefunU4UGnZYKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBw4/KIrvlltEiYodzQuBj9oSHv8wHwYDVR0j\nBBgwFoAUscFYn/CZkNr3px/uRc1KXpFUZ18wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBwihqe5nrE84hb\nO4llVFWMCKAfu3akKFth/qWdne4lGwIgIo20S+5EbS5xUDxOhE+WYRUcCJq/879M\nATTQ+oOCqFo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVyu1wEEIj+nwf2wbjDzD0SSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZmM3MGMyOS0wY2U2LTRjZGItODc5MC05ODM4N2Y2OWM2MDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYiJ2HqUfYEymeYGYMfCZvP8n6OPa5G+kx4kiHvECOWugM\n84KPng1t5FkofVxpZGbhzNqL74xm5b4tPLn3rvago2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUscFYn/CZkNr3px/uRc1KXpFU\nZ18wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga5X8fAkZVWDT9Y4rZO703fpsJrA0lqAFvfD8hfEDl4gCIEyQAtdw67Au\nPNQlprLlXh9wM09TNLUp+9UWHTcqzrdN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAdRVZ4lQbVdui4Ql0HjiwlNHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjNhMjYyNmYtMjhjZC00N2MyLTgxMjQtYzFlYWVjN2VmY2FlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNjM3ZmJmOS03MjQ1\nLTRlNzEtODNmYy1lMGZkNjBhNGM3Y2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT04mEvEjmLl2HZusxEQz90cSDNYcxCCz4AISvW6J4wtP1Yvsn4IqL+5SmHvucO\n+lUZK8xz/3pHZVW2Jv5hL2JUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQHDj8oiu+WW0SJ\nih3NC4GP2hIe/zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAOBSfHcSrKwcxXN/tOpvmosisEs8GHx7DyTsX9P4i5zw\nAiEAspOCwp4aVojlm6AvQajU85S2eb1cZaRQWaeNNaGzKEM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3495", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3495` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAeW7foxOFMY9DH5ruSKMChNxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzZmRjMjhlLTQwYWYtNGQyYi04N2M5LTQxMWNkYjgwNmNhNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc2M2NkMzEtZWIw\nZC00OTdjLWJiOTQtYTY4MTAzNmEwZDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeHITElteS6VWWQlhrk8hHxNke1dQ5/oWvTexJB4luafNhrszItdH0hkCy3bc\na7xbIg9S/QgmFyzD7sepTuRYr6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOZIdN3DwfJCBrQ4aNKcOCkOO7VowHwYDVR0j\nBBgwFoAUW6rq7+QFBgTN1MGJ8V6EvAL6JmUwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA4HUgoBxeGz/f\nUHQTsNqj7SOGxHB8OMrXvqUUnTp3aTwCIG8ZSM+pIyQzxs/Cq9eXhQuK527g9kTk\nfOlbxRrN7Zsn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUaq3OV1lkefVwVraDYSmOcOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2ZkYzI4ZS00MGFmLTRkMmItODdjOS00MTFjZGI4MDZjYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjvuC85Xw92SCylq8JAylPBWGSK6lhEIeLfqzmkmj7cT7T\nVgLuSTmsL6JNXekgyHMY0VF6uGuYyF0nOYsfbfIZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW6rq7+QFBgTN1MGJ8V6EvAL6\nJmUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOqPDh0tINbNnU0R7TbogdE8eX93JQ0s6a/7PiUDRqciAiB09n9Hv81B\nRaR3rMQpLXcUB1QDC5EAInIo6jlI8A9MIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAdbjbnQxKqAMSjY7W3V+nrUPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc2M2NkMzEtZWIwZC00OTdjLWJiOTQtYTY4MTAzNmEwZDVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYzQyYjJjMC04YTg4\nLTQ1MjEtYjk5YS04Njc2MTliZDU4NmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASrm6IOmBjo6vJ9teDVt0xvw6G6G4QPBrQw9Val1alJmjUta/JjDG8IACGy8qSv\nOQbj8aWpwtrdRGjuGZWmfk+4o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5kh03cPB8kIGt\nDho0pw4KQ47tWjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhALRLFEcdqbOHim2A4RdqzHjQjeZdezlfnU/+o2IFNiu3\nAiEAmRLiDZ8xv721RrSJTeewvxgA1DSwza+L4FnuA0TVOXw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3496", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3496` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISATAZG089WmpcM0SUWngipf1MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4MWUxMGQ5LWNlNjUtNDcyMS1hNzllLThhODVlODA0YWYyYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmViOGZlZDctYmI0\nNS00ZjA0LTkyODEtODBkYmViNTc0ZTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDsAM2nvt+xCJtUzS9fbSwJ9jbh2fAFSNI7GFwx3J5B9qMiTms9Jx/KmwSbgV\ny+y1hiYinzRwFiH3zaaOf+blsaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEHBhmCSYPpNqinpmvcB14AwI+0swHwYDVR0j\nBBgwFoAUDcPkn97SRiN9XG1Rm9/m5iVFD1kwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA8u6SH/dVKF5pAZ0MNDpv\njluQ77xi1tQpL1Gx3odej3gCIEIZaa6gWHfmIpHLq0JfyEybsN5c746oFIXBUmJy\nHZk7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQeO6OyJVuSNPkc5RzuqmMBCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODFlMTBkOS1jZTY1LTQ3MjEtYTc5ZS04YTg1ZTgwNGFmMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0EfFJeyJhFO3uIsFml1v4ZMM1RccB4TPNeqkYpiEOHvYN\nQP61OeX2jrKmiZjNJZ02O2QIxp+UJjMDptfgvt5uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDcPkn97SRiN9XG1Rm9/m5iVF\nD1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJtCgX9PCOgumxa1M+yXLcnDlxWW3YSc3WbzQF/J5G/EAiEAmf7b3ozb\nqwvNyI0vBT/6xivZXd7eJYsRX7uwgigxY0M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYgVRbpJbqIlEh1oYmjBWvaPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmViOGZlZDctYmI0NS00ZjA0LTkyODEtODBkYmViNTc0ZTYzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlY2YzMGEzZS1iZTYx\nLTQyNjgtYTUyNy1lZmRjNjgyOGU2NTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQjr78d8w7IIIphr+m/VWxdh637pMhrUaR4MVjmX38AjZFjWOLUrQXTWW73aSmG\npUD4IRwzEbzvW7mfq24JXr8po3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQQcGGYJJg+k2qK\nema9wHXgDAj7SzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAOX8ATJCdpNfcqSObE9dpbzS7H5vml2VVISr1jTOPvAR\nAiALXrJNxyKx7lqZxRwbZWV7Lp+0/woHpZxyktwsYu1yLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3497", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3497` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAf5tJnZ9kbbEok28JvqVvUkZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhM2QxNDJiLWE3N2MtNDBhZS1iMGM4LWU1ODg2MGQ0ZjkyMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA1YWYyMWItN2Jm\nYi00NjQ3LWFjMTQtYjRhNDdjYzc1MDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDnxEC6LYauQSLkMD/iztbBpX5KNXaPY9Ntp84hEqY0hxoTtK81D9HZJd6xYA\ne5/qNLJKNFiXqwNQEdpHUc46baOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeCGFGrGtnBoD9rzvtRXvGVxzCd4wHwYDVR0j\nBBgwFoAUp3QHk1ZY39d7XEWjY7EtvJAVilAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBgFYjp\n6S9uiohJJBv2n1Nm7GeQJZD6uaksb6ByxDsJrQIhAPZnwkzntGrYIQECxzvx6O3B\nWwXBTW4BRULkZRlLMFUn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY+OHsN15PwJUJya4j+ZPJodMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTNkMTQyYi1hNzdjLTQwYWUtYjBjOC1lNTg4NjBkNGY5MjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwBzsCib5qkDEtE0/3vfMDeuToAtmdKwIMNqFcH6CCINBS\ntk0odUBmUCNAR/LPNIFS0lVytVunDoQaw1j6E6tco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp3QHk1ZY39d7XEWjY7EtvJAV\nilAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDE01InIrwvRkpbo2B2XWZ/8ijmtgzJXYYBRh1maZbpQCIAscpQHSL4+V\neld5HxxzPu2Tm0F+JDI1+PISMZnvrQiF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAU301wLIN6UFL0eUd3bKictfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA1YWYyMWItN2JmYi00NjQ3LWFjMTQtYjRhNDdjYzc1MDM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZmNjMTI0Ny1mNDc4\nLTQ5MTEtYmI3Zi02MWM4MDAwYWZiYzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS6oKd7tnFXFuEbgH0StpOqqlH/NAPFaxoE/sz/xz/KJrVJ20xRlmM55h62byTn\nFtKDA1V5vqcfr5pxjVQqptI9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4IYUasa2cGgP2\nvO+1Fe8ZXHMJ3jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAIb9ql3wAkhQV3lo7DXCyZpX6dQGK7Q1DAMPhmQhaf9J\nAiEAhUK0i7dYUHzRnDK0dyV9E0aO7M/FXIMXYuUMEpUq5bA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3498", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3498` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAcKusH0VKAKwbnOo0+BVD2b3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxOTI1NzhhLWZjMjUtNDU2OC1hMjAwLWI5OTE5Y2RhMGJmZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIyOTg4Y2UtNWMx\nOC00MzlkLWJhYWUtNjJjMTliNGM4YWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGhkEpUUVJkdHcpSIjZt6gdu+wEM28sFM7yLbUsY8TXSnhmIKSeF51bB514qi\niYv1cmoS47pJiAShzp2wWCsWdKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSI89e5g40KZ+SV9JM8Rnug4/9MMwHwYDVR0j\nBBgwFoAUIBU9R+52tQhmPNy74KPtWIgvRj0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA0R2g\nOuPaKj5YD0mW3p+xTNymeHR5A0OtkgWgykfz9D0CIQCAXb2rxo+jiPFB1vPCXiPB\n6gQ1Qcr7zsQSr6Kku6IS8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUGTWx9NRnpK3bcb+o5KlfxvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTkyNTc4YS1mYzI1LTQ1NjgtYTIwMC1iOTkxOWNkYTBiZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkGoRlDVawAPQm/sylVtGLYZGHZ0Vcn8egsD9/cfH0Yw9+\nCSthc/H9J9++IFYgMVuFANHlemRY1RMkC6tcDW06o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIBU9R+52tQhmPNy74KPtWIgv\nRj0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJYxun1DErU/1EE1Nsa3yrm5figBtdUPUvJEg7emuN/MCIQCLfUDw4JYe\n1FpGHSzuP2qZOvZbOcHz0GpycyFp7IQ1Pg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXVEY2V79m/WqfNDgTRn1EsiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIyOTg4Y2UtNWMxOC00MzlkLWJhYWUtNjJjMTliNGM4YWFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMmU2M2ExZC0zMDNm\nLTQzNTktODY0NC03NTU3NzViM2EzOTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ89Zs/J8eGsy+3sgJsGKhprjkn5GVc0Zwc9iqmCRB2i04ct1Bzb8orArxjvp2Q\n1LDRkZoTKTt2pAJv9+TsFOhUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRIjz17mDjQpn5J\nX0kzxGe6Dj/0wzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgUIZFmyYAKzKN939VQ+5QfM7wTuD37u6zmxsmVPneSy4C\nIQCjxg+AXKcALAcMZQv4nCzPHCyD6sbO3+B8ZVwUPM0Srg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3499", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3499` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISATzc0nhLr2JS1tTAk0poTGlNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MjhlMGI0LWU2YzAtNDE4MC1hODZlLTJmMjU5N2JhMGQ2ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjExNDhhMTEtNDM1\nZi00OWRjLTljYzctZDA3YmVkOGU5MWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWQ2QE2gbfIqDlD9OojuXg9TxSODzr82yrVFNqLWZDm5lRYTT4SK7LNFcoUWZ\nnTWGtlPzlzK79GyNzRv7tpJowKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCSoNHib6U+Y1zz0rgVVlr+3PDElMB8GA1UdIwQY\nMBaAFIthYEVImEPeGhIsCvjgNqjON8nRMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAwBkpICkdHMwunr28y9k0nVfiRk2rDeRF\nf4fQb+Ngr0gCIQCYRPoDkfBNu0tP+ge6ztO1B2gVdIliFStdvwoegbAA8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfdeBvkltYEErPoxT461mH4iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzI4ZTBiNC1lNmMwLTQxODAtYTg2ZS0yZjI1OTdiYTBkNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyuTpwgfbWFi+AmGg+eJefac3sEoFwWBsRyN5rimeRherK\nVqv4h9c6189CPm9h91fdPBX5ppypV1nfglJJ4eaSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi2FgRUiYQ94aEiwK+OA2qM43\nydEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALGQ61YrvQzZB/BOn0J5U7mKnbdkzeS3zi3HGkabOT9GAiBdRZpSgy7V\nIR/SrlPGSAiuaXJyl1BvHCU4EO5JXUlyDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZGPxykalOuTQI58V3K21y8yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjExNDhhMTEtNDM1Zi00OWRjLTljYzctZDA3YmVkOGU5MWI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmZmM4OTZmNS05NGQ1\nLTQwOTAtOWM0NC00MDQwMjBmMjFlOTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATk2UYFm53Yc7qjCWMSHCygNeStsV0lkYVIUiKgr312vjsqkPaB4t1akFMB5qJn\nMfnXtG98/BRDqzihH3+/rvQYo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQkqDR4m+lPmNc8\n9K4FVZa/tzwxJTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgKpb+/dvKAlLcRcutNkcsmcn42HP20Uf6xcqV3a1RnGYC\nIQDarnrCICAmhoM4w4rdCEEZxJbtDs1HaeihLqHlLHXWuQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3500", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3500` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAcTfojjXN2M2cGwmBkdMzL8tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZDNhOGVhLTRhOGQtNDkzYi04MWZjLWQwYjk1ZjBjZDE5NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc3YmJkOGUtYTlj\nYS00YTc2LTk0MWEtNGEzZDAwOGM1NzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETVwWZkH82fMK9hy3Xyqu0qJdN3qzsQboI2HUkomJo838fU1MBVjvbFAeknZW\nZrwv5orgTIk/gVNyKVK2KqQnN6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0ndkZVU9r7iFjfE4XtIMLins9nIwHwYDVR0j\nBBgwFoAUOqGBeFpS/ad/I6XQq6zSIvW9h68wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAKzTjW9cTOCl\n0kDwrPd0J7wABG3f5ZGkz5GLoYM94GDlAiEA1W265l+q/Zco61ZcsGKLFdQPO5v8\n33NhtdLjs3js7R0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAczuhiS1QdJio87gYj8yBfySMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmQzYThlYS00YThkLTQ5M2ItODFmYy1kMGI5NWYwY2QxOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQg1X6P7/+sNeczKa3hv5TkNeCkloPMEzeZ00TGLyoY+bFR\n3/uemWW1Oo4QOFllAz78prurJ/Tz5cUDbdYM1SNao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOqGBeFpS/ad/I6XQq6zSIvW9\nh68wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAUKiNdggX9k7NOhODf29WyWcdsP210b/gejOWhIqY5MCIQCwBE5PyxW4\n8jeCRgw9zY8Dgv+HeVQQUbmiY97P7gLVpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAQ+Lk5gFdAiA0j9+D0usxvFnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc3YmJkOGUtYTljYS00YTc2LTk0MWEtNGEzZDAwOGM1NzQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NzAwODRlMC1iMGQy\nLTRhYzEtYTg0OS02NDg2NDFmZWM3ZTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQmJtBPO2QJSNgQiHbPDM46OE36gDK4OGMkerEOmPxkneuTg268AkfLBOS2UY9j\nwfqVLIV7XhyG4tK6o2wXy3aao3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSd2RlVT2vuIWN\n8The0gwuKez2cjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgWZmftS3PvvRnWxhK3BJ8kINBEsJWi74bZST7den04BcC\nIE5W2hXCSOAATa47LbebYBIQdwYWltp7MsPXD8cICHY6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3501", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3501` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAZvQ09XbhL0pG7vgwjSUd+bWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzYTM4ODlkLThiYTktNDUxYy1hYTg4LWI4MTJkNWFlYzJjYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVhOWFhZTctNTQ5\nNC00MTIyLWI5ZTItMjhiZDZjNWI2NzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmrhwnigWYZioQY+iYkrWjUA6pQ7G5ySBbgRrfH+F56EPSze3iul+ygr3x2RW\nt6Po3npGdJnlxPHUd9WZ5GnAraOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp23HmZ2UPtB4uH3RMuriaVpnfNIwHwYDVR0j\nBBgwFoAUJ3RjRsxzG56337li0JNdvHIKr80wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgdohe+FXihkNN\nFcdMHZxG0M7Nwr2199pMWxQr1T4F9pcCIAIyG1S5l1TS08oubgRn8dAS+rR0mdgq\n99XcG+lqrRxc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYjooOlJsNVzKSO5ozJu2tI3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2EzODg5ZC04YmE5LTQ1MWMtYWE4OC1iODEyZDVhZWMyY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtvZieVtMURA4r8clbRF51ZGfX4tRsv0QwN21CQdMn55Y5\nq+ipdtdUzwGJK43QAmrkQ6WofMYLNU6XLEvduBFdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ3RjRsxzG56337li0JNdvHIK\nr80wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEhiO+mpIkGcCcJfwwZumtbaAcJeZluQv1bgBRdu9e+cCIFFCzbea71gQ\n1fSqjyaaGeWL7A7fKicjUixxr+HjEHR9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISASHvcxZ2yjIH8qxWjmB9FfjSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVhOWFhZTctNTQ5NC00MTIyLWI5ZTItMjhiZDZjNWI2NzBmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YzA2YmNiMy1iZDY1\nLTQ3ZGUtOGFhMS04ODY2NjJmNjMzZTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARbpZNyrWGE9YrlxQmYfjxb5Wp6bzIyatC9ymdITJ39b9UReCZAhswfeWaT1M0Y\nO/f+a9l+e5vp/+UDTRGVCkPRo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnbceZnZQ+0Hi4\nfdEy6uJpWmd80jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgf2iZP/36ns+yFpBA79EiKPntPc2vwv3Vf+PjOvRP/UEC\nIAhcg90C8WZw0RbdjJUo+QvySr+v4jeHNWrb1o0+bJAw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3502", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3502` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAa3bHHrDjOMfKDmULM5QbtI4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxN2QyNzYzLTRkOWQtNDg0Yi1hYWVmLTQzMDI2MjAzMzNhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU3MmZmZDgtMzBi\nMS00ZTgxLThiNGMtYmQ4NzVhODllZjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOcWXw95glvHyQzvE2kQ2lwZ2xg+eOs3icyOnlfXk/yWa6r2LwzmE1efsZHZr\n1hrW3qctkllNn97j4CNMgMMSNaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG7KHmEb2JyyEgrs3C6OIyFVtojkwHwYDVR0j\nBBgwFoAUaanfYOnGoGyVK205RTfP+sKpa8wwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCBJEKMYgvE\nTH2dkz+PehVZjgcO2hAFIJvTRIesGuJjfwIhAOl+dXks2n4ZoY8P46pmwai0Fjcx\ndtwhuX5ut4LV/ajm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXipwuZp59g3wF2BKl6OyfmSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTdkMjc2My00ZDlkLTQ4NGItYWFlZi00MzAyNjIwMzMzYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5vkKx0JYSDB3yQYbsz0vL5/6siM1wWOSq2InVGNZ3dasd\nwR+JZ06+TeC05r+rb8AYBjzpURta1QOncjEKlQKNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaanfYOnGoGyVK205RTfP+sKp\na8wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALgdgaMibnhkkcCsA1dQp3HQ+fOj17NfY35BrRxa8LERAiEA6GlQiQ+w\nPdQM+WhadYtVQGVU9o3CR77NdfL484+Otdk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAfLPatqDh/mN1BM/TpvK5i3+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU3MmZmZDgtMzBiMS00ZTgxLThiNGMtYmQ4NzVhODllZjIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYzVmMmY0Ni1mMjdi\nLTQ0NDgtYmRjOC1kYzg2YTE2Yjk2MTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASiQwXt+20IhMP8FAvJjpkuYnc9eVNagLxw2FZcr1t9KOgIouNmquQ1Wx1R9fFl\ns4r88+ycPavB9eulQLY4qulDo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQbsoeYRvYnLISC\nuzcLo4jIVW2iOTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAIHrN4DgB3MYBWG3H745KQKcJOcRqY/ZKIynG0UbjlC1\nAiEA1PeXigvwf17v1YtAKEEMLrVLDs8LYluCx/wf6YaZWtw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3503", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3503` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAX2U7w2u+CEnJKIS4tDUWDZ3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0MzljZWRlLWNhYzYtNGY3Mi1iMjRiLWRhYzdkMjY5MGIwNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFjOWI4ZGQtYTAy\nYS00MjJkLTllNzMtMjNmMWY0Y2Q3ZGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/kiogH2X3rEqQxYiM5EJ0qYD/uiPcDQG/43PaZiCBrSqkWj/zm7JkLHyocZr\nUrsCV+ByOZgcWlJMYyvk4rQCnaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmRf3mUQ81iFdKsM1eXg+XhukMt8wHwYDVR0j\nBBgwFoAUFySaBpVEZzVIWbk8jxc8siPzW8UwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDaA1Ajpb3vBK1JUKXFNRGotxsBh8jL6Uj5+AH428jVmwIhAIw3oryiHQCZ\ntcK4Pt+kuplx6fHqvbdqNFDz4HYsWXaR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAccFJq5iAZDMoS4axleTf8TtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDM5Y2VkZS1jYWM2LTRmNzItYjI0Yi1kYWM3ZDI2OTBiMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFcyqVSbvaaMcOPSBkWsTuhKSngemG6lBZA80iu2pyunT0\njKRShtUwIV+kG2KTclmskDt+WHL9pvc6ynjLNSEfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFySaBpVEZzVIWbk8jxc8siPz\nW8UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIQryEYOlH/15P9un/g5jwX3JxKeZHhT/7CaAhgeV5iwCIBCKR42pbDvf\nk9A751t6DpMZKzY1VIYQZlxCm9pz8/tq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAT5mqdS6C3N1mZMYjXHABqFTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFjOWI4ZGQtYTAyYS00MjJkLTllNzMtMjNmMWY0Y2Q3ZGMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMTllMGM1ZC1kMDc3\nLTRlZjUtOWM1NS01ZTA3ZjI2OThiM2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ1BgfAappZ3yWl8MEA8M0/ujGkv42poKBwBeuppM2bOK70iULu0G0Q4ddB3zTZ\nf+hDBGeusxbEv2Agv2jTVfcIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZF/eZRDzWIV0q\nwzV5eD5eG6Qy3zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAIMbnvUMnpneX2ZRGxykczrOD3440zcHmRpdSclYxFNd\nAiA0Wsy0F/kc08GM0J1eUXqphGcw8K4ZtYpjmcY570cnLA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3504", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3504` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYHl2/qw9eOh3XtKhSXMubxbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NWE5NmNiLThlZmYtNDkyZS04NDZjLWUyNmVkNzJlMWUyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDEwYjlkYmUtZDEz\nYi00MTRjLTg2MGItODk4MzNiOTAyODNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEImDJlpcv/PRF+xYyzogeA4X2dKh/iIBSjenqMxZbc2Il6CGTU4QI0eaDl+qt\nVm3xVfIFlzkQXpqmymdstu/vuaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzEpDcrujzorbJqQbuRwm+aDmyDMwHwYDVR0j\nBBgwFoAUqHjxNEPloJkhTmmPTkN0hGUsQZ0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDWprOTcgWKVr/9hnouuhDTdv2ESSDUdHN5qHsOMpnPwgIgCjVHcbMD/EwT\nCUu9Y29DZD2486ZS+FMqhG629Iy+dXw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR0JQK69sUewCgloU+qfC9DkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDVhOTZjYi04ZWZmLTQ5MmUtODQ2Yy1lMjZlZDcyZTFlMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDNz9YRYWtTXbWDM7YcmxzJgxNFTtFluv54oc6+3lRJsrC\nYd7lFd193bp3ffYAlXrJMZp7Ql+J8tyP4MB4om7Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqHjxNEPloJkhTmmPTkN0hGUs\nQZ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbpj4W4XyOtlO9gMIdzNDjXdSTpmbIzPveZkMNEShPQoCIQDNkIaSYbbM\nBz/Qvu3O+R6Y25IMeB2OmIINvUxPLAJeUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAWVZAyzeTw16trTEDqVEQ9m/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDEwYjlkYmUtZDEzYi00MTRjLTg2MGItODk4MzNiOTAyODNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZTljZWViZS0xYzM2\nLTRlY2YtOTNhMi0xM2U3ODM0NDZlNjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASku6O9SjNyQHyJmJ49uj161KPV6//SCcRB09zszbyOOtnORVvW/a0R86A5R7vl\niZuAAzWqavaPf4OwZlMWjBMWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMSkNyu6POitsm\npBu5HCb5oObIMzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgJICF+6RIqZJYlxbCch7mbJa2LroBiI1QM0513hLOvUgC\nIQDDd7qrM5c8S/PxTd1XJpFfKwyDJd6uXHgVQsnA6azzHg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3505", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3505` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAQGOX8wM2j9LUpTUmWgAFmi1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzM2IxZTJhLTk2NGYtNDAyZS04MzUzLTRlZGE3ZTExYWQyNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYzNzQwYjgtNGE1\nNC00MGY3LWFjZjItZGJiYjYyMjFkN2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEecj3wH105zkP8mcqJT39H5cWv6nTejLrAzZ4KDLq4b26/9OwNGas1NU2ZgNo\n9aKv6j8Ukj0jgPBXYAHraCdmXaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKD2we+4iQ5FxLts7EjaqbaH9MDswHwYDVR0j\nBBgwFoAULTJblsbu2HBqW+8RndWEAkjYAAAwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFBV\nfmWx8z0PB9ywe7HtmUX/H0fQJw2YxIdN33vMLz6ZAiEAoKcWARDUpWg1z1bVjNb8\nPj24xWd/oodH+8aoGmp5Cns=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASOzH2eUZyryD2VmOFw5WtTKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzNiMWUyYS05NjRmLTQwMmUtODM1My00ZWRhN2UxMWFkMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdtG++m/j5Rk0kHqmnt4xcZoIqjFA4EWAMS0UR3OUNTzi8\n/P3mAdRTqpNLstpqiOyPEHRrR9C6QGG8rIxRarojo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULTJblsbu2HBqW+8RndWEAkjY\nAAAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAdziaID/5jpsDMPBVxG+Sl897p97DoE7XLMy9gpBiz8CIEE1ALf6h7fv\nbFk65gDKJQGRKi4S5xLG/XwJx+X24uhG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQDxw0zsV0ee4VeosnXKnCizMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYzNzQwYjgtNGE1NC00MGY3LWFjZjItZGJiYjYyMjFkN2MxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxM2Q1ODg3OS1hMWM5\nLTRmM2QtOWQ4ZS01ZjIxNDQ2ZGQ4MDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATyoWHdRyroSdK3xCmacgN+OC64PArbfFN+xHsU1lF+qPqXIUhHQwU8/n+ao7zK\nEtGVEpJpQNDiQ6unqbLJTyngo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQoPbB77iJDkXEu\n2zsSNqptof0wOzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgXlzxMdm8EkcRHtdKqSc1vtajo6GR9RuVP22rJY64VuYC\nIQDPOrr0g2+jOs6ev/PdTYaVi54iMtZglu43gkSDL2LjOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3506", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3506` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAbhM3GcCJY+Bchrj/gKF8OdlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhZDA4MTJhLTIxZmItNDFjNi1hOTA4LWFlOWNhYmFlNzU3YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc5MjFkYzktMjgy\nOC00M2U2LWE2MzQtNzUwYmY0MWY4YWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2WyWlIZxa20oK7DqHQYpQH73QNoyZlal3CqQjxtYE3ywaTFU5c2NpdRe1BQ4\n8oGNbjLi0G1FXhQC47sBEN2ntaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9zzv6wYXBcAfUnaJwIf+ebVE7OUwHwYDVR0j\nBBgwFoAUEQIfluo5dToYqQ8dz7FNT482tgcwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIGN/hXG5OlPF+C2fpEu3Euf7VmC5AYp8Ua7Ys0JuTo3iAiEAvp+F\ntDb/VKcdT3b6y5j/L/wB2PxVi5Q8tlaRAI6YrSM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdM+X1F3hcEhMdO+2DMsbjfiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWQwODEyYS0yMWZiLTQxYzYtYTkwOC1hZTljYWJhZTc1N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6YnSfZjdzMDo4MA0uqXjXYglmCZtu1pCJYf/MoEJhMCCG\nJH6klUpuUPrC12i1TdgZW+Z82fywSHIoPs8IEiS0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEQIfluo5dToYqQ8dz7FNT482\ntgcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKuJVy9uULgcsXzp3doOZAQIqKnt703hm5pTbzaF/8OqAiAoxiuKcLIE\nEEWvWdM8eW4kIHjNxYVxzsI3cHiiTg531w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATqaADrIVOUECAzmo73FUb/rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc5MjFkYzktMjgyOC00M2U2LWE2MzQtNzUwYmY0MWY4YWY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZDI1NzdiYy1jMTA1\nLTQ4MDItOTY4Ny05MjQ1NWM5ZWRkNjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARM7YEFl5P2twlL61tMWg2Dv44xibRmzD7qs9GnXYU8zARdDx2DiJzjqmMA2Qyo\nAPC4O/EUOpGpjW82i9mf/+Xxo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3PO/rBhcFwB9S\ndonAh/55tUTs5TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgOwzAsUc0JUCqsQ1tXjnqY8rvs/CY0oIkJ9AFYYydrHcC\nIQD3fbSGCV+UgWOqF23Oo+sJiExwv0U6S+hEw2F3zXyJRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3507", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3507` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISATGYoQlCzmLdCfGYH07sWXleMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMTQ3ZWJlLTY2ZDAtNGFhMS1hMGY3LTY0YThiYWRjMThjYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNkNWFjZGYtMThi\nZi00MDRhLTg1YzMtYWMzZjFjOGExOTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVavjsK8TXKLZezenX0IFgboHhQ8jaGuW4YR1Sch8YgMcUAEI5lLf7pQ9np2o\nxi5q551igq1uwagk+wZPfzpp5aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsmEBZpqPKz4ZkiOwsHznJUobAh8wHwYDVR0j\nBBgwFoAUm+ofKln7XLeiF8A/3XqKRiuK57QwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCJ3/Kr7+DZdxezN3IkUnLIXL3v8LGzsxQv1/RLViYT6wIhALS1\nmw/CbkaAREj1v7oMaPDZraQrAccHUx9kQWl8HgdY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcC2chgQWA/bsIX1BsXKKpYXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDE0N2ViZS02NmQwLTRhYTEtYTBmNy02NGE4YmFkYzE4Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoP0wBhgwNGltSEeiPcongLeYNFBOWlXw9VyKRgTzGla6T\nxtrW4GCiz8VCMGAKYU43mEEk30ODNb6zU6R1ZoCPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+ofKln7XLeiF8A/3XqKRiuK\n57QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKyDwZWySb7yOVmY/xwCLz9gdHEf7iPCgtMd5FfCIOckCIQDLRhijlYPC\npeyusFyHAhHSRrv/SSuNcq2z+8zKDKXITQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAS4UYzkYmERiHN2v7ACN+1G/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNkNWFjZGYtMThiZi00MDRhLTg1YzMtYWMzZjFjOGExOTlkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZTkwOWVmMC1jM2I4\nLTQ5NzgtYTBhYy1hY2I2MGNmMWNkNzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASPokY4O7viS3RpR26J2LCha6I9Xd0vRNFDIzKRZ0m0UoOOYYGpAiWo5MIeCtm3\naoVCN+Y7PHfluz8g0ixm/Lx4o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSyYQFmmo8rPhmS\nI7CwfOclShsCHzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgVF9KCXYqTKclD7zYcIwCQjWNEo6qWIcMSLne0AEfyt8C\nIADlzvXgpXZ2Ks03EUHWSj8DVqbwVQkn9O3cchVJvWSd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3508", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3508` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISARUDffyy4fEfHw859uFfV5upMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3MTlkYTkwLTZjOTctNDFjYy04NGMyLTMzOWQ2MTg2YmUxMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg0ZWUwMWItMGRk\nNC00YWY2LWJmMDctZGZkNWEyNGRiY2JiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh6ctqee5N0IiLkcqdNy7m+RQ6c5x56iMKSllCuTYeS0U4wIiNfFpTM74+kra\neaYRGg6Fq1Y8ZdGsFShxqzafLKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIb93JQS9a8KC2h47CvHu/1Jh0GOMB8GA1UdIwQY\nMBaAFBXdi/jMLsoJscTez8C6mWH8rTkNMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA9JNTFoBBB6oxDKynhuM5KtpZeXpV1GyYS\nsqAJIPwErgIhAMTOiGErPl+A8KBe8nS281fb3mB7jXt+H8PcHd4LPIFi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUpHyIO99c7QfAomKE5mciWYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzE5ZGE5MC02Yzk3LTQxY2MtODRjMi0zMzlkNjE4NmJlMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtbwUhxp7dg7h41fIhbGkw54HHGBsK1wHzXD0k3PELOY4L\nsj+HmWZXzlEbm/UibjeiadOnTzgElbDXdLjj5R1bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFd2L+MwuygmxxN7PwLqZYfyt\nOQ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK/wJFasXf7AfR1SVfyuiPMyEoDipx8Zczn+JbF1bGNJAiBlWG/vVszG\nr7FGGnKr5CSYYkBgKe18WmgtfR7iMzpoHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAf+qh97xaVNFbflgvKzWUGJIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg0ZWUwMWItMGRkNC00YWY2LWJmMDctZGZkNWEyNGRiY2JiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZjViMWIyMi0xNTRm\nLTQ5NjktOTQyYS0xMTFjODhkYWZkNTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATWSGsRERYqRwBqjFmoX559f2MEjotx8rNmEKSquNzfTuPanInS0pCFZv7fbgcv\nmGtXAcsrtGDRApHlSkpLcngCo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSG/dyUEvWvCgto\neOwrx7v9SYdBjjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgTBB/rBCnGBlNC7imnWFa20KcK1VdOjsbYdWBAKEjsBYC\nIBeRL9qIGlh1OV6T5IykChnr8NsHCZ2p1PeTCAmow4LH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3509", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3509` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAYfPva8fi0mFRrit81680d0yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1YTlkNWZjLWUzYjUtNGVjOS1hODI4LWMzZWVhODEwMTQxYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE5M2UyYmEtZTFl\nNS00Nzk0LWI4MjgtM2U1MmUzYjEwYjZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6k6k6HUL9smYF/P3WAQtpn5DGhZFWwqYnD3honPg31etI80YXdPjBiYDwFT7\nU9Aig55sUQTmZSFMYK/dJ6QX6qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI+39VvwqUhRmieoMZeIH9PrGz9AwHwYDVR0j\nBBgwFoAUhQcHQmGdGgdZKFXGtcADvo8pTzgwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMAUPZLV9vw3\nBmAed6l4z4t3RnO4d3fTZKFCBBdyiXI4AiEAjxHP155lrrQ1zx8viw+vVhRbauJP\n68HUGdlGseIF6To=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ2e1GME8Tq/2hRmiCrliBKJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWE5ZDVmYy1lM2I1LTRlYzktYTgyOC1jM2VlYTgxMDE0MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUTef2egSSGHrbjZWzPgFC7GfMs3OYe1XODRvOqRmF//gS\nylpTHuCIyNCpP5PqaQ1Mb0ArOvaAyrnzD0AbZLlyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhQcHQmGdGgdZKFXGtcADvo8p\nTzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKXrofVHBqvVqo4Vtz3cMmbpJnsJNaeu5+FMyffh+wwACIQDwbxB5WABG\nSHNi9StKjZG7UTzrRjBBOjkbaiT+z+V8iQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAeCXINDNQPWAJqnPaWkg2pV5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE5M2UyYmEtZTFlNS00Nzk0LWI4MjgtM2U1MmUzYjEwYjZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyN2RmN2NjMC1hM2Uy\nLTRiNTEtYmZlMC04MjA5MjE1NWUxM2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATCjEZDxZPPah6HjSYO9081OYOiJo/1GFyEXxHcSXJjbLWeOt4f0lWO7vt1HB4q\nBQGwwz/6nyTq/zXpxB6MR2vQo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQj7f1W/CpSFGaJ\n6gxl4gf0+sbP0DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAKtNt1eFRNW2e82d9ZMPAGNoMJGplX3Lq7M8nvdup/mc\nAiAiax9QkuRr3hDkRSlq3K5elaccT42+mrOHAsIHjHgJTw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3510", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3510` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAf6SSLNrLvDqyYyti/lsNp/RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1N2NiZTQ1LTc4NDYtNGFkNi05OWJiLWIzNDM5NzZiMzY3NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZhNTdkMWYtZmUz\nOC00NDZhLWE1MGEtNmZhMmZkNTQxZjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqTW7Nrlgl+cPoLL76ZndAcGmaQi+VA5RrhHY41tMCT2HvZ4UdLjj9RcopbUT\nF5VM01W9YdqrpdZPpplOE9ik9KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYoaVCdKoVgY3DIRRxubQ88yosFcwHwYDVR0j\nBBgwFoAU6dLEEjhm8gjWYryE0kGsfow69BwwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPrQWFmj8Yw4\ntul9qf247WbULtPzx+ejju7FaXvBtfh4AiBuxtly6E6f4bDsJPvMHP3UeUVcQmxv\nyarAEkk8c6GUuw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcKTJwpBhpO3G4KQVl7Q+Cj+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTdjYmU0NS03ODQ2LTRhZDYtOTliYi1iMzQzOTc2YjM2NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmtpCsWoard7vQp0TzevBqkxxkbL7l2C+0J4KE1L+rv/dX\nFPj4LQ7aF26BCOOt26uNeF5Uye4s/iK7ysaSvoGoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6dLEEjhm8gjWYryE0kGsfow6\n9BwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIzfu3ZrqHuvfEe3v3/V2iMdmfs2WCCpiuA8AHwT6moZAiBUaFMylc+m\nTNgZsjvPYkyQt2jXF7s+nhTnVUQ0fTo2lQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaBlYxtIN1id7Cf30cntFsmDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZhNTdkMWYtZmUzOC00NDZhLWE1MGEtNmZhMmZkNTQxZjY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YjQ0YmUzNC0zNGZj\nLTQ1MjgtYmVhNC04OTQ4M2UzYmM1NGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQKKCoCZjOFfvNU8ODVothqJeac5H+BLCDCHNaW9Am0Ih+3I4RltKnw9Yd4sl8P\nIfFHw1t1dhAI5hp4i0yRde53o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRihpUJ0qhWBjcM\nhFHG5tDzzKiwVzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAOdkS1pmzlG2CPetx/xGTwSb/6XAf7gaO0HT7M5FetCm\nAiBlraNpvE7zt+jo6IKyZFpcyTcE9agp95BM1XYtWZvooQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3511", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3511` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAa1gjEGCp/6KFFrs0MAIE5vDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkNjNlZTA2LTZmNzQtNDYzMC1iZWJjLTUyZDVlMDk0ZWYzMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjczODQ3MTgtNDRl\nNS00M2I4LWI4MmEtNWI3ZDA0MzBhYzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoFz/1bozO9GGKo6Bc/nOZLE/GSWK8sCq/8kNvLUndwdPW8/9FZRw8I8Q0G1m\nK5d3AXP8eAyUKO2UIlC3zP0wv6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsEEM9QXx7NnQV7ZfGSnsYXkY5cIwHwYDVR0j\nBBgwFoAU/L0uRSCi/LyYeNCcwFMscuVCEAcwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA/skEs2Cuy6\nnayIzRmevCpqxbO8PRndyuX12///IEHFAiEA9+zxzoNl5afSYUFYNaDTIebPDHh3\n4v6grvl2v6dnIe8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXwIv4tys47grIH7qInCl0upMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDYzZWUwNi02Zjc0LTQ2MzAtYmViYy01MmQ1ZTA5NGVmMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDh6RNYpBbtlBDuYo1Fh+HcAnwND74/pu+7gTQK7AHvs1G\nAjA/D3Imi37CwIn1Ryj095SjRLJhPLn9olrbeeRpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/L0uRSCi/LyYeNCcwFMscuVC\nEAcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMXw+oBpEYaLsX4uiUvFuGYAqlMTMCRSXqtPXY0YX857AiEAhBOaZnbt\nhgrJdk7BkiYMn0KekFRfRxIFOdG4fJwSBVI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISATRBoLc8FqOwb1n4Qbo7911/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjczODQ3MTgtNDRlNS00M2I4LWI4MmEtNWI3ZDA0MzBhYzM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0NjVjODVlOC04ODE4\nLTRkNmMtOGYwMC0wYzM0MDA4N2EyZDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASOb0SSv+FJ0w6rjSvIY0IUtHBPiQbdoz1PzfMn/Qyo24Z6d/noTEka7t6Jky2r\nQ5woKk0g94usFO/qbgCwKOLyo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSwQQz1BfHs2dBX\ntl8ZKexheRjlwjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKTv8x3D2YPuWzP0NcgLSBFBJWM2c6GPDtZ8L6aQIo69\nAiEA+1NDARLqHUe2GYYc4VWJX0bPnQfaBhEW3FWT+HsLxL0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3512", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3512` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdkd35k3g53u6wP3k3GnFS3YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNTU5ZDRjLTIyNWItNGE2Yy1hYjk2LTZjNTVkOGM3NWI3ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc2NzcyMTAtN2M0\nZi00MWZmLWE0ZmItYjViMDBhYmZhNDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0YJOO/9FJbc6u/250BJTh4/WxsN677B1pkF4CoxOd9qxLK1Zy7bHJKm30mjS\ndcnpDjLTL+M4tIh3hHG+IyW+E6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUucGkVbpNiuTOql2Ku3rkpGhY1EowHwYDVR0j\nBBgwFoAUivqy9KGB7siq7BQLSiUiIGMZeFgwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBgyEYDeoVEb3mR1K8XxK6+1X3D+V1XaFE9d4egJM8VtAiAzQbZs2BmAeilz\n7O94Y2qzP5tEXhhZPIkS8cqSVJkjhQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQW9t6IDikS18r0KaZ9jY5SrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjU1OWQ0Yy0yMjViLTRhNmMtYWI5Ni02YzU1ZDhjNzViN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5oPMGXRF8EnNlrz+D71vQ8rHeKQBh/T4UJnAONiLAf1WY\nhLelOrU0C3e7e0Bwi0T8sdgnT0/jdhYgZgiIBzb+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUivqy9KGB7siq7BQLSiUiIGMZ\neFgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIPlbHWjOVONzBj0ZmXzIpjHB3s+vfbnbyY6njos0hZjAiEA7fOB5Y4e\niNNyUTmY3JLBx/08eZxnvq2bjpOKz6JVk1c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQeb2V7KakI84KccQcwOsKZGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc2NzcyMTAtN2M0Zi00MWZmLWE0ZmItYjViMDBhYmZhNDVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNTk5Yzc5Ni1mZTBm\nLTRiYjgtOTU5Zi1kMGNiYzA4MWNlMzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATzSNq5xPI4yePvqgWLC/boo1Ju/07k//+HpjYIZxkcu//t0H+OF8CYAU7xX55/\noLjZGuvSZpVYvEQJr0wij1bAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5waRVuk2K5M6q\nXYq7euSkaFjUSjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgbl9HV+LTSem3bUDfoLacfDALjA1Oh9ZfPwWR15elCEcC\nIQD86ku2Zs3mAPMdx2xgR+K1e2YufwoA8J4ewvaXpdm1fQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3513", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3513` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeitJzweqVhWlhaZ/gLpLArBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0MTkxMzY4LTc5YjItNGFiZS05MWI5LWI3ODdmODM4MjdkZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY1MDFiNWQtNWEx\nMC00Njg1LWJkNmEtYTljOWVkYzMwZmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaBgA6V1Bkhx3Waz70vu+ui188JFWVTx30zFoW+0PLsKYlmovGaHzOu40dOp8\n3nrofHlASdRD3kJZN6jcRcqABKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfH4nnT/S8fmFoWpTbw7Kaq/T024wHwYDVR0j\nBBgwFoAUw/F/WmzjLB/t+VyLpzsnTuLVVQswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAtMGgKmXmbZa6lHOM+31DEq/TIDI9aHNIOqN4eRb2lXAiEA8ArdeN8iU8de\namEbInVwoSvzKUI6iB+C0HETyodjxOg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdK2ZIfCKQTWfimQNr2Q2r5rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDE5MTM2OC03OWIyLTRhYmUtOTFiOS1iNzg3ZjgzODI3ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARumiiNxcmwnIsNdssGbXPQPJYRy67IcG1ixJWEM6i7cCQL\njrtvIRBgU7HcK4uBiXpz9INq74ijYZNqpaTw5odDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw/F/WmzjLB/t+VyLpzsnTuLV\nVQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIy0xgEtNtI4ieZFPRVPY6CmIF1n/EcDOTIoT+nIjwcMCIQCLRUCvseYN\nwgVi7LWk2OkUDXU0xKyP5FJm6LE5vwVvgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAes/rfZ/d2NiNwGGD42NDrzVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY1MDFiNWQtNWExMC00Njg1LWJkNmEtYTljOWVkYzMwZmIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmOTQwOWFlMS0zZTUy\nLTRiZTktYTU5OS01MmFjYWZkMGI3ODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQxKDBMfTxQEL/0zIj27PAZyNyrcuCK/dUnjPQz840qG5QDOjhM1hz+YYCFw/o9\nixqR/H/qix0L3B9Zj2JCNjdgo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR8fiedP9Lx+YWh\nalNvDspqr9PTbjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgLcJcJ+OWcLGc/OCpze7pByaw8K6ZOlLdGP5ti56NURQC\nIAFQiOgC+sY1Oxw/deJ/8IIc4U1r/Y007RWM0zgDVt53\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3514", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3514` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAYIjpPhu/HnTXd2bF8sMWZ3TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1YmNiN2I0LTg3NmMtNGQ4NS04ZmVhLWQxMzEwYjVkNTQ1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJhNjgxYzAtODMx\nNy00MDUwLTlkNTgtZjQxODEwZTk1YTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvYiOGYozmpGo4KPudXmPVQM+8Sy+mOwhDCVovg9/o8tsAFX+BZ2gRsENj6Tc\nJ4GcSyQ1fI/B0uMPeZE5HjiudaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU75aZYo5LJhES18swfVsEc4O6m1MwHwYDVR0j\nBBgwFoAUsyZSUC/BRxIZmpeJNaLceYIxvd0wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCe\nnyFviLn1fMtliB2YV0vAToNv+Sb0ZThFoOFwtfDfQwIhAOxKv5+/M4R26EBTCI07\nJRHYVOPZs7BvcHuvj/7fxnpk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWuz8oV1Mb1Py+JsxtIU1IP7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWJjYjdiNC04NzZjLTRkODUtOGZlYS1kMTMxMGI1ZDU0NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQr29ZPtx/XDP0vSzGRvoWrkS1xmMaBS9EihPWiyHWgoWjn\nss39RZ6/deQkFlBUZu1rO5md7eWOJR4pwYiAAuoVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsyZSUC/BRxIZmpeJNaLceYIx\nvd0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOi1QoE8LnWLZaPG7AG5m3HEcZnYr1mQVy1ykvkZ3eIIAiEAug4X3k1k\n+VVuEj4/vDY8Lkra7WKFPAzU4epuWvT7svA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbflKsMJj0rWbYiv80M7UQQ2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJhNjgxYzAtODMxNy00MDUwLTlkNTgtZjQxODEwZTk1YTZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YmVmNGM5YS1hNzk1\nLTQ0MzYtOTJhZC1kNzkzNzFhMjlhM2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASYrGXAjeBKyiD5WUNlXZWcUxjS3C0RK5JuGyfb/zJgHUbntPN97gWgH1e1FYcI\nDTs8S05f831NqN8Va5rd/dbLo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvlplijksmERLX\nyzB9WwRzg7qbUzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgHTFVzGW++cESZ2FontdnfX5JQSwKQ8Xscm++Th49uaUC\nIQDewTvoTcj6Uy3J9NPEsXYRt6KIqyZ11iAI96QHhS7AYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3515", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3515` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAYu08Zfc0IQDtytWt9295bMdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjNzhjMGRlLTQzMWQtNDlhNi05ZWQ1LWU0YWRhZmIzMzNkMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYwNTdmZDAtZmE3\nYy00MmI0LTg3NWQtNGQzZTNlYmNiOTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZB8NPpjcg/SKPJUy+KJgg+kYxfgwEJwizPbQMnAR2PFSQmyuJxGRELrp8gmh\nTlYhrKiLtoQ9FXSFsImFoThccaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzH3qJ3ZXLz6LVSat3nEV8cgRd8MwHwYDVR0j\nBBgwFoAUq2c9vI0/dq8AVoJbS+biU64+uzswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDqyZXVG+4ejjqteEp4uPOZ53wCTd0Hvv5ooQ9PhjxlIAIhAJBk\nEhttizyCX9wXu7Fez8nS43WjGiD8Ru74TamOFV8p\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV9uOcnyBd2byaF92FSsWRh0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzc4YzBkZS00MzFkLTQ5YTYtOWVkNS1lNGFkYWZiMzMzZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrNT5ds4lfXHUDvzO1ph1M58Ufykf1Glsn3TXApbCUcfi5\n0LFfW9xlwsIqQop2iPDXdJIWuV0KxGO9zMmKoh+po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq2c9vI0/dq8AVoJbS+biU64+\nuzswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOUWvzKHRt7+N1WsBpa1DOQBy/tgOSN+JYi3FKTOFNQrAiAPEsGjzZWO\nqyaFfmcEGGXHcagHxc2LvAQYdy0ZddGQGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISASAnteKVySuWT8OMm8YdPWxvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYwNTdmZDAtZmE3Yy00MmI0LTg3NWQtNGQzZTNlYmNiOTQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YWMzMDJlMi1jNTZi\nLTQ4NjQtODI4OC1jYmRmNDQ0N2Q4YzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASmlLHv5Hj80YtagzevYHE+OirxJcwTsZm08r3k3wV2I3m86F0JUXYZvN3xQCgH\nERsWm/eLBj55uCRun8uVsrJpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMfeondlcvPotV\nJq3ecRXxyBF3wzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgaxH78qfKXQehq5B2CUmkNXj44BMrKedCRaipWX2XXb0C\nIH1IS4xBcs5c+WCWuQVUTl6ZC/f4QvsIsGrpOO8FXwcz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3516", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3516` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAdu9/bevpd8qW9EpLWITI0HFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiM2VmY2RiLWQwY2YtNGIyNC1hZWRjLTQ5MGJhNzM4NmQzZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNkNjkwNjMtNDQ2\nOS00NDM5LWE2YmEtNTQwNWNhY2YyMjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXR70wcCOfOOIiF0cyppksOAqBmmKGTIzs6NjpJto+SHfeT66lJDU1E+uN9FD\n6AIvfxJHtM6dRODaEbPY6yaE36OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlaDH8pS3VFgg+FU8fynEdds+1/gwHwYDVR0j\nBBgwFoAUgn7QnwCVlnby0jrvMw9m59Fj7ZMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCID/TB37q2IstTLtYr6ZvsSWVP1I7ZGwvNTU4cno1eQptAiA0TV6/\nVgeGDTaUpUOmdsnfORojPheCLbJMlcZ0g8uxTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdiSAMlRYosO4IZPnP8HgX/5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjNlZmNkYi1kMGNmLTRiMjQtYWVkYy00OTBiYTczODZkM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmpsQSnMkWBfBlAc0Lo3m5vR6KRP9e/jsC4xAzKhYB2fpj\nqUTFxNFNCLcJ8sYDuIqs8hHcLzDXT0EQu+Uzx++bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgn7QnwCVlnby0jrvMw9m59Fj\n7ZMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJJ2SLEepjg8M4H6bhE3wucnPFvDjw1j6qTGxZ2JijIYAiBUuFmlmZnY\n2QJT79ZVxEJ7RnmVdqz9cXu4PLUI9nMOIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaKMV1ChhUo6kk5v7l3aYmkqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNkNjkwNjMtNDQ2OS00NDM5LWE2YmEtNTQwNWNhY2YyMjA3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNGZlNzk4Mi01YTAw\nLTRlMGEtYjA1OS0xZTQ1YmIxZDcwZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATR08NbdLcqrNEf4M0tw+g+iWwIZ3Sps0zXh5Qqm0sG4b9CZwLAL9VoawlZIu94\nCKobqNADgFLbE/Ln1tLcpcWqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVoMfylLdUWCD4\nVTx/KcR12z7X+DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgUPqXQkpIHOqlb566GGjQTBpw+5qw/WV10XIMh9qrXvgC\nIQDJlAQDHEOUqAdzyfoF3U5tmJRhr9bob9xtoZ9Prh5AKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3517", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3517` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAX83pVu2AYRM7GnGxK8qs8oGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzNzUzMDgzLTgyNzktNDQzNy1hMGJiLWIwODEzNGY1ZTU1OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDEwMmU3NjMtOWFl\nZS00OGEyLTg0NzktMzY5NDI3Y2M2NDk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERKweiIAcSOSwRJc5qNGqTvOJ0pcFERjSpbvjJhnjdxYp6uizKVhDXWW/6U/U\nw1MooVxdSaq5HAPUpyIEHP4V66OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRK2hN10bAIctzQ0NHGcU5f7iew5DAfBgNVHSME\nGDAWgBQtKnUc90AUI5qio/YOpalY6w7JvDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFVQ0RvJtMr95/8LO84eDnK1WB3xYdbD\nI5EKpPLhIiFQAiEA6WJiymmRX3ecvLDIxGOxmqZsf1OtOCJfEvWkdFWS1b0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT5NABMyIQKe1U/k/cS1FdsRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzc1MzA4My04Mjc5LTQ0MzctYTBiYi1iMDgxMzRmNWU1NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYZuAMd68aAJYfTdRmBQYxeOiOfBBZNYbzlp7fzCBpYcCv\nYi24YOFxLZihbrefP0w00hFSR9vxHdJyiH0bkiiQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULSp1HPdAFCOaoqP2DqWpWOsO\nybwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMaWXViMMxPt/FHbotv5LhUV2gp2gFzYMNxjLlc7CDx0AiEApA2cfO5E\nSlDgJdk1SsQu2kSKSGLufdG+q/1k8qGxcIs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAeX2HEexdmt9duFnzdyCHBw7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDEwMmU3NjMtOWFlZS00OGEyLTg0NzktMzY5NDI3Y2M2NDk2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3N2ViODYwNS04YTM5\nLTQwYzAtODQxZC1mYzBiNDlkYzBmN2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARiSBFgJlWVMwe2TfCnVodSc5LuZmbav5OXjgJ4XnQkXXqJcBPt6fLhdm38U92y\nsJyOlEsZEcWOySYxDjS5spyfo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRK2hN10bAIctzQ\n0NHGcU5f7iew5DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAMNWMSgqDQ8jF0zEmBIiGTPpa2sSD+UAfNVWmkXWJuhu\nAiEA4X5Cfez+jIEVbSKquD+CyM/UeHyz21svlT2OSTZW2Wc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3518", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3518` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAbghf78TPLxZELvYiQ9wDXDZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyZTY0YTdjLThmOWYtNGY4MS1iMDU1LTYxNGIxYmYwZjdlOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRlZmI4NjctMDk0\nYS00MDIxLWFkYWItM2Q0NDA0NzE5YzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7/U77wwe2CA4XoVstVoSIHK5JRNx8PfDHyw8wJGyGhCJHlBuT2sH4bR0uj1x\nS55603DMnUYaNw7vw2XV3NKtiqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9qJavCgd/Oe6l9W9bSc06ATKDKYwHwYDVR0j\nBBgwFoAUp9kkQIXjseiS3IHzpeDgLj+Ab+4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBpZg0acIUAS\nAfsnM7jpGOTh0Q6UGc830yV5fHUvtGknAiAemQNNl08XgLt9H1N96zysj5ZhL4TJ\n5ghR7rvGSqvd4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUAsDxVoDGMqP5ARB5GYt2j6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmU2NGE3Yy04ZjlmLTRmODEtYjA1NS02MTRiMWJmMGY3ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRhX3Un9tBNfCymjlz8tbIq2qXxllrgHxguCgd6KD2CrmM\nRSaDGO7E7+HHsDkcA+iEEAjMVdBN5OLyrg+/Mt2Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp9kkQIXjseiS3IHzpeDgLj+A\nb+4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBHyDY53Ur89bQaEsUQiQnr6M/+15oreRpCX6DpufpJcCIEvNjCTGyADp\nvYbg8q94yJt+rTk3061LfLKVhCpC+kTk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAXq872UrZEGgVku8Zryxi77RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRlZmI4NjctMDk0YS00MDIxLWFkYWItM2Q0NDA0NzE5YzU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MTkwMGQzNS1hMmQ0\nLTQ3NjMtODI4OS1lODNmYzZkNzkxOTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT6rG/lHQy+sBryBcphRbSHAJDnkMbJDH4oEWiLBjSeM5+shKE+6LjKacqzJkx0\nbYcjWHxk5kwk0ZXIaTOkEOmWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT2olq8KB3857qX\n1b1tJzToBMoMpjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAJlfoGtDe6bmK6JLh8s930RoxHIIdpRvM5un4Eziks0H\nAiEA4avZSvNostKH8jeb+FM6rJ51c/NpbP46SphnDiFKPFo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3519", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3519` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAa8h8bE+csMwbGd7sj8oIO+NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmOGQzNmU0LWFlMjYtNDhlYi05NTA1LTVhMWQyMGE5MTY2NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTlmMTFiNzUtMmE5\nOC00MjQxLTgyYjYtMTQ2NzdhMjA0YzE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPpy71g3xPmkOHqu+2U5/3bKD4QoiH9vRIZvjYkXj7SDKJK7PvdJhPjEQY+xd\nwDN7WGkzNErMFdWbyFiqQylbWKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULRjLHiH+Sxv8xtviLfjt3RfOnVcwHwYDVR0j\nBBgwFoAUF1+mW7pdq1AWz+0UcxQBFKF90P4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIEjZRvsMzgCs\nRBRGHiRPPEn5DHyhqcooazM+t67E6Rk9AiA+6mK0j+Gfr5xOzFkKqs4efm60L8Sk\n3GTBGCPaLmiAaA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASvAcf4BSougaH0qAqzhYosrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjhkMzZlNC1hZTI2LTQ4ZWItOTUwNS01YTFkMjBhOTE2NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT83RI6uFm5cYBz94dXH3FOSQ0nOLGoeDy/tao+sPnjwxjS\n70Amo8OI1lAijfVfWVhD9JruQBidTJIHzECPvr+po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF1+mW7pdq1AWz+0UcxQBFKF9\n0P4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFrsvo+uTxeyiXq8PAA4Lb34vHb8plV2R52YCjj4m/ccCIQCd3OPyYbCH\ni29yNAa+MjO5yygd1p8cScW2JOx90lJXVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXC2M6UPVfIinRSOT6XZdOa1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTlmMTFiNzUtMmE5OC00MjQxLTgyYjYtMTQ2NzdhMjA0YzE3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNDBkYWU0ZS02YTRl\nLTQ4NjMtYTNlMC03MTk3Y2FmOGVmNTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARXxCXILcHRivHsPUk7QcKVJ+m371H48jVshVtE5/T83KvfkXK/BxMT09fAsorp\navH/5BEMv6LZfK0bHgMpM3R/o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQtGMseIf5LG/zG\n2+It+O3dF86dVzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhALWh8/TucEuWxGHzenteGen13EUajtqTulnJBFUaIZfF\nAiBLbxYAvUZqh5pM+8ikZ2QkA9+XzSsTMVIxUQaFVZbhYQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3520", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3520` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAeAAezwrFug3R33yMW+xFfjnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjZDE5ZDgwLTY3NWUtNGM4Zi04NjBlLTY3YmQ2ZjIzMDJhZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY1ZmU0MzctOTMz\nNC00MDRjLWFhMzUtZTIyZjFlMWQ2ZWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEceOVO6Fp2p7XK7t/PxT8nn/ITNXJxBQkNDkHk0Dz2+U1ePMnt58qYPd7NCR+\nr8p7X8xLAn8B1zrOI8MV67XmMqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzCoZSUesuLsXTGggN/XX1riKZ74wHwYDVR0j\nBBgwFoAU2QqKQw2Ovsz7ukKyAESpLpD9lUwwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEA1tCiFhZZ\nidvwCu6EYBZ+QsVmkXnADX/yBh5gRo24v+QCIQDmlvYyoRBXuVZOFKbrEFUR5a4d\nmZdbhgcIMDj7lOs/Fg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa3JcinuYz2EumgQsl8AJeLMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2QxOWQ4MC02NzVlLTRjOGYtODYwZS02N2JkNmYyMzAyYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyQcib6FHBtIKgiJUF6N88E4QjxRf+974idWn0ikhyoe55\nLDK7lXOpd13/z5Ye1ldb4/M9WYiOqLN7MGVrgJf9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2QqKQw2Ovsz7ukKyAESpLpD9\nlUwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMI21D75S+BI03xHyNhy9lGD5tNdLJNSsfJ/mF/ZfjgNAiAiKf2EGMlD\nl9/Z5zixUJyBlRHIQAP7A6yxy5kE0ZkYQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaRRsMbpy3fdJlZhn3QwmeEyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY1ZmU0MzctOTMzNC00MDRjLWFhMzUtZTIyZjFlMWQ2ZWMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmY2RkZGRiZC01ZjU5\nLTRmMmUtODk3Ny02ZTI4YzIzMzMyZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQDKfRBExjhSgVlBJ5RqJ8N9NlTWQ0WSRue2Zgy6CYmAkyvGHiifgV3dMP6Qmjn\n7NacXUNa7aQeTXBFB0BKB5ODo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMKhlJR6y4uxdM\naCA39dfWuIpnvjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAP6l/iENrG6OXau81AYEuMJ4JVFp3uC4/6pvh6nj4PZI\nAiA/Ay4UBEQzRkapzmrT0Y9q0v/HFkI2zNdc0kEMaJTivA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3521", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3521` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISASQlTMZFKJIjlCeRy1ROqiDjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZmZjYWY2LTA0YzMtNGFiMS1hNGM4LWQ2NmQ3MTJhMDUxYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE3ZjM4OGUtZWNk\nMC00OTA4LWIzYTUtNTQ3MzI4ZTY1YTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy8xdQ3fm1maGKTGC/4v672ABnVTk5DXJPvBNa9+IEbGxjPSbAfM6OItJCIcZ\nzGQPfYjAjF/xprZeVsvWJd6mvaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHGm8pX8hD3F38Tb+d5cwxgH949QwHwYDVR0j\nBBgwFoAUGYAlhl4fq+JSaiPi9WdzrnogoW8wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiB+4YQ9xAla8LpK++G+A4bTNgxiyUp8qmC513KmnpiQpQIgVB0EOFRGWtCG\nm9e5lQYYUqmHnBoWc/I9AcTcxoYoZwo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZq2l5S1BhaXj1pJPqQbYaPjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGZmY2FmNi0wNGMzLTRhYjEtYTRjOC1kNjZkNzEyYTA1MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJIK73yiPnUMDjCaKiphrEu1IKKbpMbr2Xnuc3wfz2unmE\nJ0UgGBdnQJ5jfSl07pqY/HFpT6mLfTOTVojo9n19o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGYAlhl4fq+JSaiPi9Wdzrnog\noW8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPFscAAxxEjaeTp57vgicLOda19r9WeokOtlByH/+5RLAiAcjLtxrBwv\n47GxgW5Jmq7zeP+ZCIJuHqIp6p2/hppmmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAU6WOAgpcQF8srgyoaW3C5CkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE3ZjM4OGUtZWNkMC00OTA4LWIzYTUtNTQ3MzI4ZTY1YTBlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MTQ4MGJiYy0xZGVj\nLTQyYzAtODQ0ZS1jMTY3ZjQzNGE1MWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARR4FHIMz+vD3zAVhFxm117BmRJAVIU5x1DPO/mKgAmwNjKs5eDn+Bvw2LJ51Az\nnpZLfxevenAMh7SZLVYdVVv2o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQcabylfyEPcXfx\nNv53lzDGAf3j1DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgXOesLD/ph8xhJXCsG1NEjnaqbtd5pldb6S9QBwlvXJgC\nIQCaetfAH3CpqIwuEfQEC8qLWL6C1ZIZ9PxsBf73GQ4bng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3522", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3522` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAe26jF+D6ff64DYn0E24YYxIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljMzQwOWU1LTY3Y2MtNGZhZC05ZTIwLWU2MzQwYTMxYmZmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBjNTU3MTYtOTk3\nZS00NWFkLThhYTktOWU1MzQ0YjlkYjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYS5BsF6+tzM7lCj6+tTpAqcLBuopXYy7aKi/8FsqJnQ3//kObe+Mdn8k4DHY\np+v6zynEne8N34TUWf+ymNwTW6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmMSoKKhcitUZwZxuiIebNdO4qbAwHwYDVR0j\nBBgwFoAU8MW8mQFUpNdlj7UE/G+1UgQ+8MkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAJtmwUJmEvA/rG/GAstoEvfFcSRO+yPBmYj/AdlSlfOwIhAJopj0PCZy81\nP5q95hU3lesf0ICy0QHH1HRK65pWpEXc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASlL0VvbjgUhoFmobhaB4colMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzM0MDllNS02N2NjLTRmYWQtOWUyMC1lNjM0MGEzMWJmZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIgDD6I9euFI0m1cA8nQ3BrtyySGKEsKMNB4sEkdjLodAT\nIsTKK04P90FOhhZl4MNSMpTC2E13ueOl7uQt9ig8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8MW8mQFUpNdlj7UE/G+1UgQ+\n8MkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJdluKI6bYE4s4hQ3gb/Lu3QzJFeUO56ptT/CIe7wbI2AiEA95cqm1CV\nDQHJcYx3Iuc5eo3rO0zrR265v2VAzKz2S3Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISASFkbguaHZMPu64dZNgdsT51MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBjNTU3MTYtOTk3ZS00NWFkLThhYTktOWU1MzQ0YjlkYjU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwY2NlOTNjOC02N2Mx\nLTRhZTEtYjk2NC1hNTZjMTFjODliOTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATKjF7F/75RHoIpIRHCCY8dG72fz45/j2VWDumuqxK7vqanOV5yF7aGzEek62Pg\na22nZsIg1hSv4KsjL60PwRHvo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSYxKgoqFyK1RnB\nnG6Ih5s107ipsDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAOdMg9P1SbmQ4r8HsnB9Ata0JbTl0KLlpB9nHfjHmWP4\nAiEApMvooTGs+gIsni4iDwT77Dj75cIi0Vsb6V9tR7x7UVk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3523", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3523` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAaovgjNzcu+YLEPXssUCv4f+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwMWYwYjlkLTE1ZmQtNDM2Yi04ZWYxLWI5MWMxZmJmYmNiZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRkZTNiYjQtZmVm\nZS00ODg0LWIxZDUtZmVkYTVlMjdmNDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Mj11TIpFqTQKONAL2K3o9tlBtLGmPRBULa46FjAkmhFQPzs+jA2qRn/FL8U\npPx7yBUOfK+8sGrs+Dq29sa0/qOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUguwqgoPEdViSRB7HB8im70kTUhEwHwYDVR0j\nBBgwFoAUsoprDb+N54txMUg5ytvpPRiFmjkwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n0mGIgjb37vFOQmxsXQHbawGP67Ct+o0sUhxD4iarPSECIAGJBupXBhIoYnIifctv\n6QfBfRywxkrUpp/ja2uZQWF4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATMHJmkn8l6o113KQSyjGiLKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDFmMGI5ZC0xNWZkLTQzNmItOGVmMS1iOTFjMWZiZmJjYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROdsJ2W6EDIi2K6wqH5a04C7yxSHRj3sk0nvPbb4m03SWO\n8zfeGEYTVNwKkOsuAFINCc19h8JZe1oCQytGS/uTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsoprDb+N54txMUg5ytvpPRiF\nmjkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMWZDwnc2SSaq+aVXgdQtSh1ViBaO8nrdQlJsxPstuVzAiBI+QLZPY+f\n++BNTLpPpxyn4Q+VPEqxFr1DeUjfyw5BtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAf+JJp/4vxgD/L/CsGj1DC8RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRkZTNiYjQtZmVmZS00ODg0LWIxZDUtZmVkYTVlMjdmNDQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkOWUzODIwYi03Yzdj\nLTQ5OWItYWVjZC03MjU2M2FhYjY0YTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASfCdkzXez/6t/07hqdn+qhERMohpf9nVnNwW90Ceo0m+/xyZCU0lrOv2Ht8yiF\nrUZgsxNTesF5h9GeL6gwnX5fo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSC7CqCg8R1WJJE\nHscHyKbvSRNSETAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAIih6YCl428R0bYxeOu7Zl8nutv2zaQDpMOV4Zl6PF5D\nAiAm2oiaG5pwbmATA1fHtv/5idjrCYLmE6XQaBP6tsUZOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3524", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3524` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAfY2M8SaPWi7RTCxVpuOdW5SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4ZDUxZDRkLTc5NDItNDY0OC05NDg3LWE4M2MwYmVmN2M3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjljYjVjZjUtZThk\nYi00YTI4LTliNTUtOGMzYWFlMzgxYzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED8m8DuYv22Umb8HT/jN6IzSQP+gwyjWwLTOBAUOBGLeLN/ddTcf2peY9AopO\nfO9hKtEW3zUq1fz4VQoyfIDy1qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhf4YB1LQXWBaAeRDvLdzisAhAfkwHwYDVR0j\nBBgwFoAUjJf5L38aJYkRjQNBCVkkgKuH9RIwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAuZ/K4l/jglQzc1Y7JD4VIufFalkgEzKGEwBEmGLVXIcCIQCe\nr/kXri6dLDkf1ni0TRj/aZlny5N/j/b7zqLEqOoTEg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZqQljCT1DL7LVxJctmncdWtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOGQ1MWQ0ZC03OTQyLTQ2NDgtOTQ4Ny1hODNjMGJlZjdjNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeKzPDibfF/wvqaEkDCmu7N0PtLnNJUd7MoEYst/Ax63oG\noafIFPwUN2FA0MFCcwVmzpvJT3bHWgmatzF7XVCOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjJf5L38aJYkRjQNBCVkkgKuH\n9RIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAONjU7GcwoT8Eym/isIq77XYVzPYYCyjJfQscC6XexKsAiEA+Hk0mdkY\ng8FcjO1srUyvl2dFsDjqMqCmr2ZZGIscD4E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZu/ZxjreV+CYe0VaKyDFK0aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjljYjVjZjUtZThkYi00YTI4LTliNTUtOGMzYWFlMzgxYzczMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNjk5MzYyMC1kNDNl\nLTRlM2QtOWUyZC1hNmQ4NDMxYTI0MmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASe3BsFd/z6wGmpp3ZpuBsucj60iFMJ9RJFbGU5lOQV/7HkGSts55J/lURoyKgU\nYFgmUugjEgq3b8Qe9xh89cjIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSF/hgHUtBdYFoB\n5EO8t3OKwCEB+TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhANod0ZnMr+KoFjdFQJasALNQE8ugH9PqJjZFmlnkLI+F\nAiEAt1+h9lvgRQ4cUT2Y0Vu7YGABjSGMdXUgluuEDgdZBY0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3525", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3525` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYQ5zFL1z+A72vnelmtb/f5KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5MjU3ZjhmLThlNzItNDBiMS1iOTA2LTg5NzMyYWRmMzY0MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM3Y2E4MmEtMGU3\nYS00NDU4LTkzODgtOTYwYWU3OWIyYjhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEttybIgPS3s79/uW4vjTs8HbCODyz1d3MgANXu3oHipLYhbqPC32kC5v5Inu7\n9/Qv7asGKXq8OxvRMYx/mwNnC6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzZ1ZkbH0DcytLd6WDu8k/WY/N5AwHwYDVR0j\nBBgwFoAUQ09qjlOQtQFa8KrjJr9+MOCqMEowPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAwgBMTqGt9s4RA427tI9kSGS2B7hLMo7wXyxJmR4JE58CIHgY\njFizm/OTaSTij03CxXk1TufDseKs6PLmaDQl1n8E\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAegw4RAY8Fww8dMpB7uOSn/zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTI1N2Y4Zi04ZTcyLTQwYjEtYjkwNi04OTczMmFkZjM2NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtIXV1wD/+AdJPAA5mMzo75RdISKWKwp8Tk2ACTCuebILV\nZmVitshEm5NAjxZgyyRbnZtcYoTH7Vol769yWHWuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ09qjlOQtQFa8KrjJr9+MOCq\nMEowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB/r5qOW6IOW8F532ViC+gc5Pyxw8klemyld1QyCj/yUCIHL2zLL2GITQ\n9lUz+18QmyRUzaBfQp84X/AELthm/JBt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAYSs+QyABDpjsbcjfgJt9lE+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM3Y2E4MmEtMGU3YS00NDU4LTkzODgtOTYwYWU3OWIyYjhkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNGE1MDBlYy04MDRm\nLTRjM2YtOWVhOS1jZThlYzNiMjUyNmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR7HjwI394AHm48alQx2VK14vZZDeNLDV+8kgdN7H9rhro4x9+KjuS/3wU2yiRd\noZF6gPSXbqQ58LtoZUx0VTLXo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTNnVmRsfQNzK0t\n3pYO7yT9Zj83kDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAM8jKfW4WDTmzYgvFxDIwtV0BxlpF4E6D6eHx0Dpcf7L\nAiEA3nj7iYe1+Sf19DNIB+tM2Jfuvjp9CqPYLjoIxi3j2lo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3526", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3526` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAWInI3MahCFYBKztDgABFpukMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0YjlmYzQ5LTcxNTEtNDY2Mi05OWM0LTRmNjcxN2Q0MGRhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA3NTU2MGMtODBi\nYS00OGEzLTg2MTctODczNWRjMTJlOGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEVrgEToD6pF4NlW4XqOceJqiiY51P35jAZLtz5U2w16ptQ4q2B8os9Tu4Kvf\n/q3DGo6P62EK5pLDc50Db/JJuKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM9IJhUcJm5subLWVMdaMJE8MtBIwHwYDVR0j\nBBgwFoAUCfY3z3kYlFqhLopvc030oiIg9P4wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiATOa/o5e22ghMH\naB4cjyR0dT+SzknyeTP/AZKH1dctZAIgKPqJhYd+ZCmatI3iaNHTZ+/k1Mm6YUAJ\nB636/g9JXvk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQe4x0O7keO5hqlmHHgWniSOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGI5ZmM0OS03MTUxLTQ2NjItOTljNC00ZjY3MTdkNDBkYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtedN0R/pINZjhVth4l+IZTOgjnSlNyVji6AFEv2Q//7Qv\nDXC70Ar/HtyzJHsV5c3bHoHn79OxJAr9Cc243MeCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCfY3z3kYlFqhLopvc030oiIg\n9P4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGDd+8+NeG8HF+U5ds3qtT2/shV4JgS6xkXamMB/2ujoCIAeR2TTwT8/f\nKnRdGbD/bW3CzujERC8jQTVPhKz/r7aK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAbyGh3QmOFgldi0cFftIyOrBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA3NTU2MGMtODBiYS00OGEzLTg2MTctODczNWRjMTJlOGUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMjRhMmIxYi0wZTdk\nLTQzMDItYjY1Ny05Njk0OTZjYTI4ZWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQDBGdkXvkC1+TE3bU8es0AVCXj4gXHMGqh192xzx5zNM0yPpR50q4Ws+49erbM\n7rLleamcz9zzIoH8wt+9DhDzo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQz0gmFRwmbmy5s\ntZUx1owkTwy0EjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgd2oyW+I5SDNddpF/ny3XkfJ4zXUDOk7YebaCDlsR/LwC\nIGX9cZSMgWvBKJHC09JBoquz6ezgBlTRsj4y/a5jVXoy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3527", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3527` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAayd1lZRt2VRfLtJ7u/9eV0HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlOWMyYzQzLWZiZjItNGZmMy05MTVhLWUxNjQ4ZjExNDVmZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQxOTlhZjctMDA2\nMC00N2Y4LTlmZTktMWUxYTE1MTFjMTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+6h0t+FWzdomWevqMkdUnD4y5gjjoWhQfFfTw+0LtCQw11yGWvOhzhD96YUb\nT/Iykti1bSQ+gRKMfXPC9AYK5KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUovzzL9a27MIPMC6Gmv4pgQ3yhYwwHwYDVR0j\nBBgwFoAU0xbIbvJu+kB6Tn1UObuIL5yDw5AwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHmNdhXCgTDeXQ1Y8RkkEVPazPcLSlZlsKA00Ap3M6kpAiBGDR7hYmTeCHJL\ndZvR2q1FSN+CQy11xS0cJ08as1tKJQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbaBj1dcYv/QZ2lgEgDqCh/UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTljMmM0My1mYmYyLTRmZjMtOTE1YS1lMTY0OGYxMTQ1ZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASscbCmOIjT65WpsWrq8/ky/LoaBC/3liRmMdez+DhNYf4A\nf/Ky/8NlW9tgwOy7VprbAW+FZFQ+loXbCddD6ygfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0xbIbvJu+kB6Tn1UObuIL5yD\nw5AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRr69k0M5a9ABlpfCoXlZearPVKDpRm7oCMiQt9VQbBICIEDu8kaMGni1\ncysGeuyoTFF9h8fmKAEJ5ZcB1E/2RApu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAe6m7g9R8zblZahaot+Y0w6sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQxOTlhZjctMDA2MC00N2Y4LTlmZTktMWUxYTE1MTFjMTI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZjYyYjkyZC1iNjIw\nLTQyN2EtODA5Ni0wODNkYjQwOWE1NGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATLa6n2ExsRwQm59u6zqHYSZUOJeJVKaFJjmR2dAJF5rwjN1PtKkOX4lKbkfNjc\nIv5cJ3gImFHxpCg/sKGYYhVwo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSi/PMv1rbswg8w\nLoaa/imBDfKFjDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgUtFsHH9rjr0FVLUvI7DU2Tt2M1CzIqPJ85y5dVpF+8UC\nIQCrXI5TyZvQUZY2drMuEtACW9E17mPQ9BBXZNs3XXNuGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3528", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3528` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATaaBqfQluf4C7J//aaFtKtrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0M2ZiZmQ1LWFjNGYtNDg0OS1hZTk5LTVkZDg5MWJmNTRhMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQwMzUzY2MtODNk\nZi00OGViLThkZDgtMmNmZTMzOWRkY2ZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9/oaGx0Ea5aOpBYNJciNBsfqqJmzh6IR0ZB6CRZOmf/1+4AsBMAagPwA9ctW\n0ZImWMEMZTVRwZ/W5DJhwh5zi6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9jIJCflWoavhXBbHXhXyuMrw8EUwHwYDVR0j\nBBgwFoAUZWZVOhwH7w+TJEUe2Cjug1mqBWkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCakwfS4+EvJsyvWczVXfWj3Nu3xf15cfpMUyJtW/h2gAIhAIqwLNDQ/g7i\nXvFPa/AqCmfsKU0zk/wF1o8SCAAE7RU5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaBid6mT0t6bYehHQeSncrwtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDNmYmZkNS1hYzRmLTQ4NDktYWU5OS01ZGQ4OTFiZjU0YTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/ftCSy0pWpacndS8G6O8t47Yilb0xGzF/B6arm4AkRJvc\n+u/IuwZBnasrJ8t64vs2m4RQG7TULDcjhSbH66h+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZWZVOhwH7w+TJEUe2Cjug1mq\nBWkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPQQfjhbp2XxnbepRcAC/Ww1U4/a2JVlfawmZWgo9nv9AiB4nsZiA/kr\nOvwTECEwLq17DKSPjJSGpqYEBLTKILEWOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAWfyEBD8j01L4jFextYFUelJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQwMzUzY2MtODNkZi00OGViLThkZDgtMmNmZTMzOWRkY2ZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YmRjYWNmMy01OTlj\nLTRmODktOWFlZi02ZWI3MTFkNjg5MDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASPs5X4vitV5cADZVxRwNh1H7XkVvB0Bc5+tzn9Ps7qXXVMjDet6DWqU6g05WRx\n+78N1BCc0MXQx0gIG2KuPd7so3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT2MgkJ+Vahq+Fc\nFsdeFfK4yvDwRTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgOQCh8XS+5U9tpwbIiBcZatZQ146F5ne41kBauwJjeVsC\nIFiDPVTWf2+1t7iVZ2Ic0YzwUEH5gkRVfa4SkYkzraHw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3529", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3529` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbnfXbEOlvtVfv8+EEHJOgUUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZGY0ODZlLWRjMDMtNDI3ZS1iNzUzLTA3ZmE2NmQzOWRmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ5N2JmMTQtY2Iw\nNy00OTY0LTg1ZjktOTc5YzYyNmUyMjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQVcmzUCzlUbnegqX1yjuraibW6kN2Y64bQPp8IUjQHHMbBkR4u/Aka+3JTTV\niZBI/BCcpBjrkAnM4NK2Tj2Dp6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp27O9/dh0e7YrnQ3Kdp5Q9Ba7E8wHwYDVR0j\nBBgwFoAUGgW/siAOl/eREITU4aHztw3xKaEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBtLXO0gTcAvk8Gxf3FzZ9xiuF7qoxf232S4FAuwJ+dhQIhAO4WYAo/pKli\n72X1Dylq2VCP1iyj1aJ7bRExPBIKjW/F\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUh+p1pSWm+NWgu9H1IqgODjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWRmNDg2ZS1kYzAzLTQyN2UtYjc1My0wN2ZhNjZkMzlkZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARocAovRYz1NVGcbUStyotzspTzyN0PgBSxu8YFUxE6IGcO\nJBj0JhEpSWltob3+0BU6ISTEedsFRTlgO6bubCx2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGgW/siAOl/eREITU4aHztw3x\nKaEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHClYC/vggG3+SFxzy0PFc/FZyfiU/LjQUlVbKzl5SrQCIDAroJhKmYrc\nt4YhtkD/eKMfMiWIZ3u2aWw592osnbWj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAdr6z5B8wFfHPWrY1joq7TzLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ5N2JmMTQtY2IwNy00OTY0LTg1ZjktOTc5YzYyNmUyMjg1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMjFlMTE2ZS0zNjI2\nLTQ1MjAtODM4Ni1iY2UyZjBhZTQ2MDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQItCOHkPeFxo/n+YQA6OPcJXwavs3dMtFKP8IcUecXMzqxEXfMbvrh08kMbeQQ\nnPBMaTa2S/ZmpxLpTgiXducfo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnbs7392HR7tiu\ndDcp2nlD0FrsTzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAIaqeYzUGo6JrwrQQUsNeu8dnQyXyY7U30dYlJ0efjKr\nAiEAy6JkLw+RliSK46HFhJV8ni5g5Qq/Pf8rQBt3M/EpeXo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3530", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3530` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAf3gmzfkQuZcqOq29MY3J0qcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMWQwN2E2LTU4ZTUtNDVhNC05ZjJlLTFlODNmMTExMWZhYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVlY2NkMjEtZTJj\nYS00NzYyLWJiMTYtY2Q1MWY0MTliZDQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDushWE6xyGYMdY2bwaecAorlbdB12HWpSb08fRhkoakc3OrSk13xOuPIgvmB\nAzB/uOBaBHG0h3puweZkP4iKsaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoxRTkfTQWGPvM6de0OzPTiHngekwHwYDVR0j\nBBgwFoAUAcREgsX+p62ypdoC5HF9+owQvnMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAyfAMKr5FAGWwjeVR+80YPgONGxpe9ydBuE9GmVCk\nFnUCIGZd3yKPvyvYQJcr0hzGXNAd9zzZnSaHughRy8DjSfMO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZpD1tlNXMQvJjJWR29l9NMDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTFkMDdhNi01OGU1LTQ1YTQtOWYyZS0xZTgzZjExMTFmYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+zLeJUsKRu/MAy8RfR6Duk4p5Hu7fTTVYekXC0ZWchNfM\naHz0UKrr+VAN7S+b6AY9SmQZHHLmLvEhFfJQ6eoMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAcREgsX+p62ypdoC5HF9+owQ\nvnMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSQ+t5c3X3s2opxGCUN7RQkUnLIz+iqK04pbNcXtQDUYCIGKHE3aTtlrM\np5Z6Kqo/ASVxDsg1UQWnHPrY7GMEAbVc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASkC0J9GQMn3/t2mT9hAoOWKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVlY2NkMjEtZTJjYS00NzYyLWJiMTYtY2Q1MWY0MTliZDQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhOTg0MWU4Yi0yYTRl\nLTQzMjItOGJhZi04ZGIxNTI1ZWM0ZDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASo9eRGtSymg2WaHN9kFDn/lSbYt5x8Poh4qEpn53BHoi/wNr7guzG6L1gDmvv/\nhHfYduft0rdFsMlQFvMnf25Ko3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSjFFOR9NBYY+8z\np17Q7M9OIeeB6TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgZMmQEZ27hiub29gmXl5sDK7NAoiL5UKjsLA1aGNdT94C\nIQDtB9p8t4757vfI+Piv63Ke4HrHIlGoxMxnICmYmuWTJw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3531", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3531` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVLi8IjfwMQQ7nkmoI1AS4RHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczNDFhYzdhLThiY2EtNGYxNS1hMmVjLTc2NWQwN2E0OGE5YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRlY2JmNjYtNzI4\nYi00MzdhLTg2YTUtMjNiYTRkYjIyY2QzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERCSE6j5ESwz4mTXVNND8k4jNvDik/TKyRORpx3YYznTIXEmWZolUzsiTQfFI\nxz7NmKZAyBUDRZAcsbjj34Kr+aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKy1hIZaanEVpJUo6tfETeyDZxuIwHwYDVR0j\nBBgwFoAUcFLwo0TsIW2rHvEEmYBbWDmqxUkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBNAs2PiEu6xn070fgOPPtqJi5eYav3TkQE8Ud00QfL\nygIhAI4HydunCUjuEFeFg4zVTvt/0dGuV3wzYliDiBhNYxOj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVN60Qq4w8MV3hRC1h1Zc8s+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzQxYWM3YS04YmNhLTRmMTUtYTJlYy03NjVkMDdhNDhhOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2Re7dHUBT3jA/eif7+mZJaBluUZkmdtt3aPyALVB44Sea\nk6rhpfNT3OlMxLUiHjnHQHF9xTI9r1SkeJQ7ltmgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcFLwo0TsIW2rHvEEmYBbWDmq\nxUkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgehJFrcEgLfVjgxWaE8DIcnfb08lIVdV5vQ9UMDDadfgCIG/xdJ8wqfje\nngwvWCS+ia4UJVZBKObKpdpQWJu1Untq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISATFZVBtFB9lh89KdNstrOCHdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRlY2JmNjYtNzI4Yi00MzdhLTg2YTUtMjNiYTRkYjIyY2QzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4N2IyNzI4OS1kYzYw\nLTQwZjMtOWVlMi05ZmE1Yjg3MmRkYTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT14/cON6gB2KW5RN1H58YigD8iY8JFepsiTps639QmjQFWdw7F8lbq6E4wROeI\nudAs9R8DnwpEBETuUKpprD7Go3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrLWEhlpqcRWkl\nSjq18RN7INnG4jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAJFpdthBi9Fboup5t3qopjPHb2dKQyJybtDiX/QQ1dUp\nAiEAnXcaZn4a8raw+kJ+rNQdRf2xhQfC1q7t0LRMsZEinpg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3532", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3532` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAcAYaHiLtpFePx7CHfnwHy/RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ZjZlY2JiLTEzMmYtNGIzYy05NjFjLTg4N2FjYTYyOTM3NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZlZGE2MDAtNDUw\nMC00NzUwLThlZTItZjA3ZTZjNzcyMGExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3vc0uHYduB/DGyYv0q9OC50pPeuB7Do5IjAqCokV7mruH+mB2BvpZDNUwhur\nWX7lxwmGC2iY+xMs1lo7Xef2K6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMkSxftqXSAwlwwZO3nr0IU7My7IwHwYDVR0j\nBBgwFoAUBJz+SxocsujFAJ04pYuLKkh2IgYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBJcEjVpTaspjg7tibGQl8K1PqUlbcuZ4CvDsC7ObwMyQIgS+KL\n0SMZjS+2AYUH+bdcP3wUFHZg/mdceBOyrno+DEY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYDzfbeoW4JH8W4lE+tnuSCBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2Y2ZWNiYi0xMzJmLTRiM2MtOTYxYy04ODdhY2E2MjkzNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQB4QKR6++aE6+yeyEDYqaQ2GsPfiPMVJX5C5tfZ8nbb2sS\n22RKsEel5s/H8ZtJVaBX6QohjmYJLb2i3S0O3smqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBJz+SxocsujFAJ04pYuLKkh2\nIgYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG1e3EXyQF5sWQyvXN8I70sXcEU9PR3kkZJCCgjFGDAUCIEeepkQ3yiQ2\nouU7NSQ+sppbv42aUVwyt99hzsrvMBx5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbECCr8wwWVEYxUQgZHkP2WzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZlZGE2MDAtNDUwMC00NzUwLThlZTItZjA3ZTZjNzcyMGExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNmYxNDEyNy00ZWYx\nLTQ0MzAtOTljYi03NDQ1YzVhMzBmMjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT26Epw5qJIbNqWmod0sv7lHWSzPifzETgQQoJxM1ctr8JJVA7Syfh9fLLTDbWl\nOXjH/HR5cYSnk07Hz6PJVmy1o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQyRLF+2pdIDCXD\nBk7eevQhTszLsjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAK0F6PEQYavCHG118EJj1KMIHtUIDk6NHo+/yisEfg5w\nAiB+04VsBcuVHVI/kNGEg1ij+vi10ZXceHbqFsNGsK3p4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3533", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3533` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAdabOowFoyZg/nXhihbWN0rDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkNjAzNGEyLTk3ZTEtNDBjYS05NDg5LTYwMTA1NTBmZjA5ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTAyMTU4YzgtMDM1\nYy00ZDFiLWEwZDQtZDRlMGMyMmI1YjBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXGeMFeEUBHXspSEQkKqGHoBclpSTUugzxcw59KS9k1KZnUonMt+2Xs03OxT6\nbZDid6gAfQgEfhLZ9BkJ05EAGaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU4LpNtlc30IASQPRY/E0kl+qqTYwHwYDVR0j\nBBgwFoAUryUMGjFnfZ2wVYOalJepdErL6bowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAOz+K6qHCqgi9iUQzdnDyTW43AdlKCPQhJ\nRVEUMmeyTgIgOi1g0+FyvwKvRpGmk/1/gdXgY+M/syAqquG2jKPwVgg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATjd4JjKoR/wARMeVe7oPTHKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDYwMzRhMi05N2UxLTQwY2EtOTQ4OS02MDEwNTUwZmYwOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7TfwrL6pKgdbkPML654KSDp4dwG1t1Vvvsy8Boxu94YLx\ny7CgWB5V28eoIed2CLQA8Y5lWPGnmhw5u+xfEi1to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUryUMGjFnfZ2wVYOalJepdErL\n6bowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeBSKKLVskMLNi5ympVyEi7gqoUZhWWrZy1ALjAo4R9wCIHoJfLd728H0\nP6tLlJgnx5+hCcLMDZJzx1Q3znpdRBfq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAXMDD8nt2FECEj/iN73sYLMYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTAyMTU4YzgtMDM1Yy00ZDFiLWEwZDQtZDRlMGMyMmI1YjBhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMTY1NzY4Mi1iNWNi\nLTRhM2EtOWRkNi1hMWVkNTY5YmI4ODYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQV2vgqfja6paDJD2JV9IgWalLE3R9TUFnLfQO6Aj6ADW48F02PvbR0QjkyXTw9\n8cfus5HtgpbyqdRjjPWp1U7ro3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTguk22VzfQgBJ\nA9Fj8TSSX6qpNjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgOBLpPati2AU6xaiEsQ3XTif3yiKHjf/+nTBP2dsktQoC\nIH7JBi7LWOO1110AQadk0cosbDBAedGYsVYMKz0tSEBW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3534", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3534` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAT3cdZuYmgPK00aNVQ4Q/dBwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyOGQ5NTNmLTM4YTktNDYzZi04YjYzLTVkMGZjNjYzYTE5NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjllYzAxODgtYWI4\nYy00ZmYyLWE2NjYtZjNjZjk0NDBmMWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpuh7+OjGXQTf+PX2+KWL3LSCmdh7jI37ipDipzgd2uXwsKpLO8rElVY4PNzT\n2rihQHcTa4BTYs2JGez8DzAdh6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB0phL5WKiDjYCDsDk4E27uL9qrUwHwYDVR0j\nBBgwFoAUmmYQcCONvMSyffSaehD8n8/4/68wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEApiZ1ouCsvt63AxVZdDLRXiAcc4q0jCLI\nJNp9D3pmzzMCIQCV4V5/xWpiSfMy1K71/stXdXFDo4LKNuM6O0FnvAIqOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYTepUwnTNn9YqYZtCm/5F8bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjhkOTUzZi0zOGE5LTQ2M2YtOGI2My01ZDBmYzY2M2ExOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNJB+furvTiI1QgLvC9DSxm0Oha9LIQ/RAizb7cC5yJtD2\nQsNIoLjzPwboPCq8BL3XROG74ogIZcGhuUOLLEGUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmmYQcCONvMSyffSaehD8n8/4\n/68wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKo0Bk7yE+BQFhXtmFYtdbakYaLSpo9E6msP1m2IcpNvAiAWfYFwZPcb\nNzhFgy91w2/ziEjpUpOLgxdZiE51579n9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAV2x9GKoy+M2rHK1TQuH92vSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjllYzAxODgtYWI4Yy00ZmYyLWE2NjYtZjNjZjk0NDBmMWRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ODMzZTkwNS1hMjFj\nLTRiZTYtYmEyYi0yODM1YjAzZWU2YzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQIQORhR/rCxSnf4uWtb49GdMv2OHvLKnGU2ARuKS5Aeutl0WWp58cNm7zujc/H\nzzLoICyPKn/lGejYvWC4jCHpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQHSmEvlYqIONgI\nOwOTgTbu4v2qtTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgYu7PPWrB/Lj0R6DZQusiXXG8MGjlQ/2STurp/IBVyuUC\nIExOUV8n4irhv3cLsfltpqf8knaWPCrC9mAwLM5mqNaS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3535", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3535` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZVKEEPd+EwKwOkf+Z5f5n+9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjMzE3YmNmLTFlNmMtNGVmNS1iOWU0LTY2ZGNjNGUwZWYwNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWFmZTgzNGEtOGM1\nYy00MWQ4LTk4MTYtMDM2OGEzMDdjOWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFLl3p0Z6Qb4z85x4pchCxcOxwOtX0W/j/fBqrJkayx4eiuULZOvHc7TYz25S\ne/23EPnOjsrNP7Cb9ZU31pVht6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEcoJFem3yLDd5THUygpudx4/KJowHwYDVR0j\nBBgwFoAUiiih81P/X/2QD9ABoJyCVEGZJ+4wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBZbSdMqs920YSu\noMh21Ni+U8X1CquDjGcnu/KY9u/6dwIhAOauFMb0eRF+fwrP2BJIye30KSXrAnJx\nKsUq6tIVtCLq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYJtqZoTnQodf7hzRD4PMlvrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzMxN2JjZi0xZTZjLTRlZjUtYjllNC02NmRjYzRlMGVmMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLbOY9NW3cxQyKScq5S56hm1VXgTwZHb0/zN8O0B48IDFj\n0r6CljLQ6RKYTQmnLyEvupf1CLDE7TightVeAqugo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiiih81P/X/2QD9ABoJyCVEGZ\nJ+4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJbEVX3yl5mjzDYA25Uko2TwhLHP+5aq1clSWnKAZIzVAiEA1WtaEPOY\n4y0wj93CZumrwT+iNxDmXTQ1dgTNhuMi1Fo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAQmujITTaX8QVXhvOUgBCjDVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWFmZTgzNGEtOGM1Yy00MWQ4LTk4MTYtMDM2OGEzMDdjOWIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiM2IzZTJjZS1jMzRl\nLTQwOTItOTc3NC1jZGZkM2MxNmExYWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQSdozTn0thwYbEMSpM4y7kmwP9ObcIRzdyoiXKMpDhAQRdFKxlTOBr1C0ax8zn\nPsGccg12FS+Zncv+M6DUFM7Io3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQRygkV6bfIsN3l\nMdTKCm53Hj8omjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAMNxTt1AE6a0yTRNgcia/Kov9y39gOMvjr3ygyr9Sv8l\nAiEA6x/BeTof4FrvWF5kNY+Tgr1hCXKQ8pj5wrDDOFmHwIk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3536", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3536` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAb79Os6iL2x1gS/tPQlBBuVxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxZjljNmI3LTNkM2UtNGMzYi04Njk0LTA1NDc0YTYwMDZhNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U5N2FlNWMtNzll\nNi00YzUxLThiNjEtNTQxOGQ5ZjczNThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfmpzr+zKi9FmwTs40sv8FycEhvoSgJW6FA9++3w7h/ZQjU9dtih5qOBttw1m\nOwF7L5hCkOwc8DMyFAlNkE72raOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqL/IbI4R5Nv8WA4zCuLgO5mIZiAwHwYDVR0j\nBBgwFoAU3a7QmGwyZlT/EXtkVGBnhodOsvEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCQdUJ914j3tUeHQcPLwAZ6P32rvqCWw+fMYRbBw1T0vAIhANOJeEPldwfs\nVH2r9QInEu6WZXxwlbZI45lQTMa6RcyI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcpKYSBrk0IgLTA6cz8IInUwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWY5YzZiNy0zZDNlLTRjM2ItODY5NC0wNTQ3NGE2MDA2YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShMFZnwQp8ffwVItIs8ymvsN+UuJYLv2DUEcf6931xOwnV\nSjt+BMrCi0wzguIMMZNBgDq3b+glRQSIfQrVH7lNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3a7QmGwyZlT/EXtkVGBnhodO\nsvEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWCskTdjq2z2GKiurmjpcrIEOhPdCiWenYwpgoCfsQTUCIF3pZTkKV8Me\nEgV38hHEA/IP+BYvhAhxxNRGIrWMVd3F\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAXkfJudbcIaRlAZ3NGKYL+loMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U5N2FlNWMtNzllNi00YzUxLThiNjEtNTQxOGQ5ZjczNThmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNmQ1ZmUxNC1hZmI2\nLTQ0OTktODdjOC0wYjc0NmE4Y2YzYjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQQFvf7tQUAG8Z3c11xT5nnyzFWFfDyJg2MXFC9nN7yN4zWGwrp9a2xih/DZzc5\nvYVuvXYhtHGX4gDLrOtC/Lfoo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSov8hsjhHk2/xY\nDjMK4uA7mYhmIDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhANB9YLucrSxoG5vZWnInDFl+0NfKa2Rt1rQL53O+K0HB\nAiEA+o7tpmoA03H6kGBGoMTCb7GS9B1M38mHgUC4G5W2+gk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3537", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3537` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARuzNgtXardO6i9oSlJDdEeKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmZmIxZjQ4LWY1NmItNDZhNi1hMTQ5LWY2ZDkzNTkxNzU1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE2MDY3MjAtNTM1\nMy00NmNmLThlMzgtZjY1YzIzMmYxZDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv8w0p8LC/cfRMO5qCBhvhM4N6gyEJNvnEusABcDNgk7Mu2EjD0fmQtqK2NKC\nqwQRTIWSchZNI3RDWxgMV96pq6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUrN8tf0CiR/reEeUioDtUS5VqiswHwYDVR0j\nBBgwFoAUfeSOK+kiYyW4eYiXhMMHYmynu8wwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDktf6eK6+riX3Z/rFA/ucBQZb6Z8Zxa24UIz369JHQ1AiEAyRPbw4hQwJio\nBHh2EGk3Izhpct9frGD1BndcwUtzRwo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARzwFzBzKG0Vebg6xIQcTAWdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZmZiMWY0OC1mNTZiLTQ2YTYtYTE0OS1mNmQ5MzU5MTc1NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVv03l/JuLJX9EYbcJUdH7GQTxEVRh2rjzUd2/OGMLqGqR\n7TeskLBTYPGT5Wgibm90PqTrNBQGXS/tX7Kyu/y9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfeSOK+kiYyW4eYiXhMMHYmyn\nu8wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM52qEVPMpR0vyAponXzUbz161zJv6tUV13yJh+FHx3bAiEApI7awYDM\nhI6hvmJXXuvS5KxGHNmi72S4oOJTOznXdjA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbsiTBUnXGlRL1BY+0QtbNYDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE2MDY3MjAtNTM1My00NmNmLThlMzgtZjY1YzIzMmYxZDdlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMGQ5MjhmNy1kYzEz\nLTQ0OGUtYTRjMC1hNTdiNzZiZWJmNGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQjOc2F3vNqJYg1o8s4+Db2QcRwtMSt/SN57Jf4PuUjgRfhr7dhWYx1ta86JzCb\nNKgZs4AmiTP2SrYfAfvVJ08Mo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSs3y1/QKJH+t4\nR5SKgO1RLlWqKzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgKahs50ZiNt5LZYrG3BiseXbI1YcLNQQR63YQwuZjFokC\nIQD7Y0HJjkPob4YvkUVkWF58HtNWw/p5UzAmYLcDtXJwsA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3538", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3538` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAXABFUqnLN/Mlf2TcRK1VlYSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhYjU2ZDkxLTU3MjktNGQ1ZS05NzQ4LWE3OWVlNDRkNWM5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJiNDVkOGMtNjU4\nMi00NDBjLWE0MTYtNjRkMDgxNDQ0YTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWUx6BMKW0MAcxyQFWaolxzRSb7PySeD/rhVB8S+bA7FyFor8dNblQ+4CUR6m\nr7S5zL3bpjqv/OkoQjNxcMEr6qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYgBE9lQFQFNyqQ/IVF0K2CnNT7MwHwYDVR0j\nBBgwFoAUhG1RNjdg3b3wncxQ1ced7bT8YiAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAh05SXPBjLFXvTpdApIteZyfULJeVNAExx51LypRNUnQIhANwpzDX5k/Hs\nltdpnfc/gFH/2UoH6AR2tveTtDZJnJDv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc2cNAR40RjbsYtsAKVxszExMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWI1NmQ5MS01NzI5LTRkNWUtOTc0OC1hNzllZTQ0ZDVjOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKL0F6SkJzz1i0ig6aFjFNGd4giiHaBpqzpQOhwHb+PssU\n0uBYonLy99962UD8FRSgkXLmoz3PgOOC3jNdGqpXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhG1RNjdg3b3wncxQ1ced7bT8\nYiAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAParUTvhtxvCf7ald7u252DhFT7dt2R53LmnRnO78Lk7AiA1dpTcRs2b\nn77LXm/fQ5Wmh3UXJ7JE45m9sUdD1B/BaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAVT8oEun4Kq14L0P9P58niFIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJiNDVkOGMtNjU4Mi00NDBjLWE0MTYtNjRkMDgxNDQ0YTc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMWEyMDRlMC0wNTQ4\nLTRiNTMtYTA3Mi0xYTRlNmVlNzliMWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQoovmb91viwj3jpdSRlsuBTZkwSpeS8Xl9D5C5tH+8GDpqVV2M/A3pSYf0Oc+B\nOvD7+mAO/xG9DhhSOAkxME1Ro3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRiAET2VAVAU3Kp\nD8hUXQrYKc1PszAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAORPUVfnHDEkWCrvmn8QwdhxNHbhy3cMAGSFYiOj9PlF\nAiEAgRjDTzfDbmG4h+utKHVGdRRjK7shH2GUTBnd7cxQ5uA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3539", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3539` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAWLCBRPVWpeltu1XFSTrKAtOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxMTdmMjRkLWQ3ZDgtNGIxYy05YWJlLWQxN2Q4YTM5Nzc2ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQyOWI0YzctZDI0\nNy00NjllLThkZTUtNGJiNmZmMjM0OTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET3VoqYno8MCrzAYnn2r85dXgWM+pUE7ND0l77+55zsTB4sujr0gmyfpFyeT6\nEDotguCV9rkwmcd9q3JQnGqUQKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl97rk5w7bRKxxyxY9VYfY7T24c0wHwYDVR0j\nBBgwFoAUzJh1Tb8DIZasj+jbT2mQuCK9JrQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBXEuVk597kMusmPqbWt1xRZuFmGg0/sNGs9FA4Rzj/\nwwIgBejxw8JQzTxJgvUC2BSNV3VKRwW3iiA/RfXMS9ZOQgk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUW80F3R685BIgaPR4eXna8cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTE3ZjI0ZC1kN2Q4LTRiMWMtOWFiZS1kMTdkOGEzOTc3NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEObTv/J+odsVib36zZHYGJh8BYsvWhMByPViMQGRHqp7B\ny+12HKEpIgUsKnL3l8KLQc5Y5M80H3DFdFYreUDfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzJh1Tb8DIZasj+jbT2mQuCK9\nJrQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTj7COd8bz0a0Z7EnEvVG3vrbufEkzUEM9EyIJsf7JvYCIQCghoj3TTcF\nTOwL7eZh8beDUneXkezPQeFpeWmczpK3kA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAQ8NH5ODNOB0tAS0jSTKv5yVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQyOWI0YzctZDI0Ny00NjllLThkZTUtNGJiNmZmMjM0OTE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NWM3ZjNlYS04NjA4\nLTRiOWEtOGM1Ni1hNTYwMjUwZmQyM2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATZjteb4wTH0wsxd6R08rW67ZdJGpVxDqu0YAAG+g6otTlD3zmFs3R2orf/y+2k\nsVMRFPJJQuzuShYvQaQIkWwHo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSX3uuTnDttErHH\nLFj1Vh9jtPbhzTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAMLzMcDK9AWrlbOu7l3OARMmv5tGjtLi6CbtvhpELNxj\nAiEA+iTeQT/z4xM5mfnRPFbe597J2eqwueCtMs8jIbj73t4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3540", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3540` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWsTKEQpDScXOmzo2zFGelpYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMTQyYzM1LTUzZWItNDYzNS1iMDczLTc1Y2E1N2I5ZDBmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDFkMzk3NDMtOGYz\nNC00ZDE2LWFlNWItYjZlODkyOTQ4YjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVvgLd56N1p94A6wzW14zv7H3+t1A2FrNKM8SdrbgEQU3ur9muz+DbscI5Y3n\nd28gDI/b75VWEfBQu/G3cJuaJaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqfCUL76PjK8rTNMHHq5HO0Xq4jMwHwYDVR0j\nBBgwFoAUF3zt6P0uPXKsgbAKNzwv9X9au10wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAlOu9Tl8EacRCdTexhTiZ3GcHtpAYdwGI70e1m6zc\nWEcCIAoBliMSGYmjWjRWXtYJEKP/orsTRw/VdUd7sULBBJme\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAamZjdIR9X5qW6e/e117iiJGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDE0MmMzNS01M2ViLTQ2MzUtYjA3My03NWNhNTdiOWQwZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZaYFAOdskQ8Cx94MAMegumdrxfvLPW0vDMdMd3iVzhdGv\ngu/3mdA3xVwo9QbyeFuuGKTMnpJo+L6Wiugj+6mmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF3zt6P0uPXKsgbAKNzwv9X9a\nu10wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMJzaPRp9YPcQ5GBOKFAefoahkyFrog3bUKh/K7yc8fFAiBPN2sKeXUl\nSDriTGjXMgggX93XMnXOLDaucZE1E1dNcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVkrv/YJUYQvAcpLUdnZHZc3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDFkMzk3NDMtOGYzNC00ZDE2LWFlNWItYjZlODkyOTQ4YjVkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YWQ1ZDNlZC1lZGZj\nLTRjM2ItYjQyMC02MDkxNDNhNjE0ZTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQg+vwXb3FQpPamJ9jMMuDNwrNajUCMkTRVzgF2RfPWieI60iHA+Q4z8QlNVL4X\nBY4viVkaDDld5w+HM/Xbn0Ryo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSp8JQvvo+MrytM\n0wcerkc7ReriMzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJ6OFWytA4GC5qfBJNxLXl2up7H46By9mi2EztHwi5Wx\nAiAo0lU1HDmHbEocKA6o7BUtCSHcMxFuuXXpeFfiJ27+tQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3541", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3541` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAbyBpj958AHiwlmtZdObr98gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2NjViMTBjLWUyYmQtNDVlYy1iZDUzLWE2MzU0ZTExMTM5MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlmYjYzNDItMTZm\nZS00NTM2LWFjNGItOGIzYjk5Njg5YWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHTfMapsklKlSHM7qZj7TBNlbJxMKTOElJhsxiz3tbAhNbIitdRgIALlHyFxJ\n/CHwZdLd1iuqoGHSzlZkiMNGfqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlJmcYcFDFyfFDh5XTnEa4Kx7LLUwHwYDVR0j\nBBgwFoAUV03w5x0VAA6wCu7vFH7Cz4albFUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAoHRooesgVRH6gdSf8SE/IHso9VZ7fKz2v5ST65pENU8CIQD1\nsu0kV4hK/0wU+MOzmLWFYPlxmK49x8QbRmjevznJjw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQhaiVkYaopOcHApmlSAi1p+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjY1YjEwYy1lMmJkLTQ1ZWMtYmQ1My1hNjM1NGUxMTEzOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMXqPaKPr2QT31qctzwqkyqUDDn+hQAQBobuqAK77lH2OI\nFG1RUmEBPbJFroxpueXWc8+iKo88X6jq8OWj4R1Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV03w5x0VAA6wCu7vFH7Cz4al\nbFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJg6vjOpSzsMjl85eY/CT0V3qMzFV1v0XJvkLCdNxMdHAiBaxs/HbuLn\nlc8jPVWjVtPHxtw1T7T/gyGwA4I35TqK/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARNaLoP2Rhr5s/GI/hV+dfVcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlmYjYzNDItMTZmZS00NTM2LWFjNGItOGIzYjk5Njg5YWE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZWFiZGJhYi05ZDBj\nLTQ5MmQtODk1Yi0xNzAyNDM3NzRiNGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASDEIlpn+9d7VeLOmzHUQC5XLN2q4lJ+T6UvNyewnhwv6HH6kU1OXk4ga7nWFEg\nJIZ89YRApcVOhQMXz2mV8VFzo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSUmZxhwUMXJ8UO\nHldOcRrgrHsstTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMQINiVr+J/l77gCaKndIe4UaU28EJ8OHEykENFVHjSA\nAiAXyZ9XWFruZMOwz+YO7+v82DxaUPUdC8WDtDl1WgEgow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3542", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3542` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXd1gtXa1BEEPbpNGTxco+aaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwYTNiYTAyLTc4MGUtNDdlZS04MTcyLTViNDg1YjkwNTQ5OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RkNjMyMzgtNTU3\nZi00MTJlLWFlZmEtNzI3MmMwZThlZmM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqJGzVOyjWTrM5QOJGt6asfoN6i2oZu8Vwm8kZDJOon6Hs5nnblJkgDL9Ncxn\nA44w3EZWY+AN86LeHw6Kn22vVqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUflQU/8xn4A5vNFXBwuIvxRnvc3IwHwYDVR0j\nBBgwFoAUaj5D4XjvtYQn/zNf6K8m+ZhqSfcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiASoJIEd5r7gM1lY/rm1BwrJbmh2M0L1ip6\nfl/u/diNVwIhALiVYGzm8mdatd049vWbrbWnDxrwql/YXYXM8kUlu53f\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASYWFdsBMfYktAAp5j9zThpNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGEzYmEwMi03ODBlLTQ3ZWUtODE3Mi01YjQ4NWI5MDU0OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPVuWlytyyHDziy7gCRsCE7T4L+HuRtyFoylZaWijM7nWW\nH8y2pEo1cbnYyVA5KisZbGljX+lxqDoHQnfkV/qMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaj5D4XjvtYQn/zNf6K8m+Zhq\nSfcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRByCNW6HVB5VfNjS7Yc86eYvdRrjyHrZ05+gRutbhyUCIQCTalDIMUQM\n/nUd4J38+wEjHOWSUkK9QJ1r9UWnDiEtJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAYD75AspcT60wF0EDJTYvi4iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RkNjMyMzgtNTU3Zi00MTJlLWFlZmEtNzI3MmMwZThlZmM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZjM5NzIxZC02MmFi\nLTQ2MTktODFkZi0xNGY5M2ZjZDRmM2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARQ1+92YuOF1IEMZtgOCHTiD2vNfr8QqMvLOvGNPWSTJkPD3DMlYdnEGcG6I2IF\nc3oHl3hOHgNr0TpJXIb457rBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+VBT/zGfgDm80\nVcHC4i/FGe9zcjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgRTqmfyF2Q/+dDYziC0IuBCceDuIb2anK6fvnFCrD7rAC\nIHScp4QzOFSxR20v+joGhABaY8WJC5DcsM5Xohv7DUpE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3543", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3543` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASpHKnbRGHUSMjwUXKFbuoDqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkODc1MmZiLWE1MGItNGMwNS04OWYxLTBkNzM0YTkzMzRiOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVkNGU2ODctYjVl\nYi00MWJhLWI5M2ItYzQwNmFjYzU1NjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAmRna6Jx6eUPaVK6pKHn/Ls5PyCcmFKq7Ij213e6wIqd55kZPoo2Al8OihcA\n6SjJwA2vTEfSGa5Rln/Doo8RI6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEJF4WYO5A/i4oFG6jPt/cwkfBmwwHwYDVR0j\nBBgwFoAU0U7pU/7VrOEV1vgY3OIpVegqiPowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA8Hxa10vCRgseb6+BELrTylbXSkoQWgbS\n3GbHzTCOo9oCIDsCuJvbdfsYL6dL1XOBK3Ic5qc4RRxFIzJVaiWXVJdz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeCkLbla8Yoe2ustgy+OWOA4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDg3NTJmYi1hNTBiLTRjMDUtODlmMS0wZDczNGE5MzM0YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGu5YrhGxqsQQwSvLEKQWP2p5RvxSDJSV/pgE8xY4rlSvU\n6Zk4lhPC0g1GuIw6FFBvF+MiB9OPnKOgUxlZ7FPNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0U7pU/7VrOEV1vgY3OIpVegq\niPowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKQTi+U3kA1Or+OD1/GZPJSzf6vbYEBx0l2l9qeXALlhAiByORd6/WGP\nxjjk4DS7iL3fmdLwJYQRQw4z2p4GoAR2HA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAeDkRK/L2xUtUzaLhEp5Pm3SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVkNGU2ODctYjVlYi00MWJhLWI5M2ItYzQwNmFjYzU1NjU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3M2JmMzkzOS02MTdl\nLTQ3NmYtYTRlMy0xNTc3MTFiNTM4NDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARRryKBGjn7BXpWb7d4EFWT5Vktyg4qqJsxeZxYoy/7bJkig5zMw9J0z4hcejEz\nL1BK3A0PtgOw/jS8ysKxF9FDo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQQkXhZg7kD+Lig\nUbqM+39zCR8GbDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgYyOTE3dmu35umeZFk5uJMzMZJAk81BCBgBsquOo5SIgC\nID6X/yHxHX94vQSdXdwn4CqKNYp3OMkDPb1NMpZpiEGZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3544", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3544` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAX3FGG17+5tpU+8y5BZKbQROMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkYTllN2I1LTkwZGMtNDgyZS05YTcxLTkyNjU1ZGMzNzY5NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg0OWYzNzUtMTZm\nMy00MDJjLTkzNTgtZjU2MzcyMWYzMjhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb+nlzY3A504hOVPUG+uoF3zpPODGfervGGm0MkCpweKdETt3t1adS09zfD/0\nKG9SW3q4PoAMRSaP96QfdTNsQqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkZV+v7BmeFb5nU/+HZrY7O8Cg/AwHwYDVR0j\nBBgwFoAUCxk9gW/0zhr9Wux2uKTjEE5GucYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDlE041K4Iad+uql9WRWRXjq4/Yp\n5+C84r6D7Ohx0Z2OAiEAqRuZqs6zyCv5TgI3qmL1NH1FjSWjAzqEXabxeg6g+rY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVgpKVOAsecL3acCbox6JcTyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGE5ZTdiNS05MGRjLTQ4MmUtOWE3MS05MjY1NWRjMzc2OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATngt5Tub03KNh4/IoMsmn8bjJXY9oQYnLkLf00VvKg6U6s\nOWrH/TIZiXbNhOr+im6lpR8GGJl7R8unNGCSh9l6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCxk9gW/0zhr9Wux2uKTjEE5G\nucYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGf9ID6YHQsbwhYINPr6uwlHAyXpzVRH8AR+iCZ7fPmUCIQDoA41uexFd\n8+bID6urtC3Ka2gwq2JV1X7q+0VR/HYXLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAeYUr99w6X67wEHozwTPy0r3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg0OWYzNzUtMTZmMy00MDJjLTkzNTgtZjU2MzcyMWYzMjhkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMDhlYjQyYy00OWE1\nLTQxMWItYjQxZC0wY2FmOTQ2ZTcyOWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQlbMw1cIBgBVa0JVyzulXqJ17RA9CH6ieDt8qZh2DuSJiAt7JJIOHsqUkE/Z3R\nbWtde9w6U5+6O3Tt6c/LcYipo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSRlX6/sGZ4Vvmd\nT/4dmtjs7wKD8DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgGJScMdvJg50H/J88PPBDeRJ5XIF3zVqAo2RG5qlcJ8MC\nIQCZMRhV0M6Cp7JN80MW1dl/S/9gZNOXu06Vz5iJR+iKTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3545", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3545` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAe3AcVWQyXi94it0XL+jYYrMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhZDE2ZmZmLWM4YzUtNGEwOC04OWM3LWJjNmY3YTAzYjI4MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZmYWIwNGYtZmY3\nYy00OTY0LWIwNWQtNGZmY2VlNDE1MWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdtRSUrvAKTGupm9sj6r+amk5HYImSdIF6UCk2qhQ7xNiCF/IUJJ+PcKb7Xw5\nHTMQpQE2AvHaj5PAXrg87aKPMqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF6HfSfc7ieOdOOF8jmu7iQ6zB2cwHwYDVR0j\nBBgwFoAUOIeR0WmcOn5wCc5jaN2+CN2IH2cwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgRhS6BRll\nLjcrfyTZ7O3OZkfHy7Vhqo6Ftbg2TN3CHhkCIQDl9ZLUm9j4leAQVadVP6VEsWcP\nStO/2arQPs6YtqZoiA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAerwhtNkTyMqDpYtZcps5txDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWQxNmZmZi1jOGM1LTRhMDgtODljNy1iYzZmN2EwM2IyODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxO9q1KwWWlrOxeX0cVpdWCru+D+jEukl3BYVIniAiqKsi\n94Vxx52V3VyJht8VJ4IfAtNy1kEW3kjObFNNJx6mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOIeR0WmcOn5wCc5jaN2+CN2I\nH2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN8+j8JzK/KiYisnOcUUK++Y42lRpfxL29/LfkBqUXD4AiBDmDllT3rj\nMmUhmTSIWeFvoNrFKgUdIV44MTYYzMKqtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbKqB1IzAqjwmLdVKEsq4scQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZmYWIwNGYtZmY3Yy00OTY0LWIwNWQtNGZmY2VlNDE1MWE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNWRmMTc5Yi00MzI0\nLTQwMWUtYmM5ZS1jN2NkM2RkOTVmYWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASDaEMI7NnU5eGZcYlSC8S4s7UNPQG9yoIrUNzP+P+Zu9lNB9q54vbR+L3WsdnR\nSE3TAiZZNyW+1AobNDsBUnafo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXod9J9zuJ4504\n4XyOa7uJDrMHZzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgXJJyBPQtL6e8vTukgUW55A4zJnBuw4pU1muxhpoQv3YC\nIQCtY+DYs7uGS1Oa/7ou0AmPV66QArKIewMqCsW8PBT53A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3546", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3546` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAQoZyOX8SJw9YgfdV16lVn5ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0Y2NlZjg4LWM3OTktNDVhNC04NzhkLTFlMTUwODkyMDVmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUyMTM4OTQtMzI2\nNS00MThjLTg2MDEtNThkMTAzZmIyZjJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv7ym7+H3BgmHCK+bIPpwhGYbQWDdn+vZctyS0OocvhfgFXLBHojEIZFnFCVl\nSHeKrZX6iW6x+J/0NJg4FEv0q6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUStR1D0SWTVwssm/Cyv3Ku7u15+8wHwYDVR0j\nBBgwFoAUSZSfsWMTUKWm7S7Zkp0XNXkB75YwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAP0kRPBn\n7QPkRlg7sC1mfZNAXCW6J9xqqzKYJEsSY84IAiBCxRUvseAjoIfl5S9TMVZtHsWw\nrug1xrIkFDY5DE/f+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbg+N8bgPWugVvn95fBGVRDOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGNjZWY4OC1jNzk5LTQ1YTQtODc4ZC0xZTE1MDg5MjA1ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEYepv2UmEfUgqhWMgPX90/VeHsAAAk+/Hk9cEDWpOXFvI\nTg2P1wfgA/0Tm58IejNxyycr8qAPihyYdUoKCrbto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSZSfsWMTUKWm7S7Zkp0XNXkB\n75YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgd3fFwMAKl4A8NR9APvzhuoy8IwdRkvBUrQ3F4+eewE8CIQDzf3xB/ntC\nSNtQ6V3lDJyo9GP/srQpIEVIHSFKwV5zuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASh79r+0xFz2+mL7Od6VDdvNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUyMTM4OTQtMzI2NS00MThjLTg2MDEtNThkMTAzZmIyZjJiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZWEwZWZlYy03MTYy\nLTQ0ZDgtODBjYy1hMDMzZWI0YTM0YmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ9JFJY0K38JafqSDykvgEt+mic/CIFqmBDETWjbmjg7EYbr0bMuAzEvuAiMb2K\nYzNWz3ZLI3g5L4rX0UTO/Ruqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRK1HUPRJZNXCyy\nb8LK/cq7u7Xn7zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgIfu7t5XTBZlRVPfWu30DfkVOoqXaWuspBR3evs1fhYIC\nIQCXdbG6kCqJHHc+TZSdEXDS2PkYstRZ/2QmlmfhuHk9Gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3547", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3547` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAQMzic0aTyUpWwOktJ4QU1qvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NDk0ZjY5LTBmYzYtNGIzZi1hZjJkLTkxYjQwMjM4ZjBjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUyNWExMTYtY2I2\nNy00MzQxLWE0ZTUtMzAwNDNiOWRkYzRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPUkvTqC2/6DZfXIFWODCNl2VzNvMblJ+aB4+8SOH533IdNkyoXapC2Hr+F/d\nhyfUygxV6676/2uHetqmHzk3HKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeapK26Moe2Sp/G7PaY7F1LvEfz0wHwYDVR0j\nBBgwFoAULVBygytO4OByr6mlqFJj+kfPqycwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIF3bd0XA\nu7woZPO0OKjjpO99zKVOWhhXsxEihw1bHPlSAiEAm3BmQRnSbLhV0it3XjDGvXf/\n6j/yT6Q17+tstYkrfko=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUFhnPexBKsAPE2vI2L4Pz1gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDQ5NGY2OS0wZmM2LTRiM2YtYWYyZC05MWI0MDIzOGYwY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV1qziZvjjSm16qau1R28xA2CTFZVKcb+y8aS+3KFWG789\n9hJ05HsbslgOOBF0wXyFLiiu++kKT3egC381q9fuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULVBygytO4OByr6mlqFJj+kfP\nqycwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMZmroGx0KS37QhbWRW3YiU6WOsp7mUSkMmmmMT/n+LpAiB5bKzJfQna\n2h2sbTslYEvJ4oq7acuJNcXZGUrM2Jy2Qw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAf3jXgLonXA4r5ZGwra4xQmOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUyNWExMTYtY2I2Ny00MzQxLWE0ZTUtMzAwNDNiOWRkYzRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MzQzNGI3Zi1hZTFl\nLTQxZDAtYmI1Yy00ZjVhNzZlNGY2MjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATHfAuy3V6b5OjT8XpFrhTO3nuGVYbCpb9t2eYDHLf4vxgVnSL5bQaJW5XQIIk2\nvlUtLHKXdyMdBtsSkg4+LUmKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5qkrboyh7ZKn8\nbs9pjsXUu8R/PTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMPla5YyD9wnV3mwStBv3sYY11cbLx2WDZboEkpwjS0F\nAiAcEZrqoI+CaA2IKYglqGcKTOrFARjiEse0Gg+Yz5rHyw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3548", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3548` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQUgkf8SG6Ha3kzadQFAvG5HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0NDRkOTRjLWFkYjgtNDE3My04M2EyLTI2NGU1MWJlMzFiYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzkzYmE2MzUtOWZm\nOC00ZTI5LWE5OTAtOTcyODVlN2MyZDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERoXJbYbg/EKx4d3kfZZjNkpjS7HOmF5eVt21MHRQmpwjkwp04YtYNW3iFZTk\npHI4jpGRImgx4+eiwAULce9j7qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK2AMfakqTn81DBO/ufHyCeHsMlEwHwYDVR0j\nBBgwFoAUcHlNMaxnhNEdmP8sqfOnef1SqQswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDN9NmA0yLXx1VetymZ3ydUoFxaNaT+iDFFBj1WxaT0LgIgd0YCheEF\nWvpV3eIfVrgsvqMvHfDDpwYJncGftPCyfzA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcIwmz+cgbuOg5Cu+OTpxG9XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDQ0ZDk0Yy1hZGI4LTQxNzMtODNhMi0yNjRlNTFiZTMxYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATki77CzFMFL/Y6GXGrVocbuYiFXMJ1pz0lsGQQk1hzAaVm\n4ldggkGR2N7tUdTEO+KnOan65KumoDdZnTE+hdbio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcHlNMaxnhNEdmP8sqfOnef1S\nqQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY1NU+ufSaEZAsB6l8l4mswQ2uSNzv8G7i2BVKuysgpgCIQDrILj8e8bs\nkHuDveoNyl4Jk9Whm2JBFhqFZ6nXMQwCfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUq09JFihdOlmYtFw3nfLXscMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzkzYmE2MzUtOWZmOC00ZTI5LWE5OTAtOTcyODVlN2MyZDljMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMDU1OGViYy00OWZl\nLTQ3N2YtOWQwMC0yNWYxNDRlZDg2YWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASp2cvQEKVniT0LzOlCZ/GuF7g0sVw2KTzp6PO/T3sAXipNkVXYMTf1vCw9TpQ1\nX/+mD7PYTapQmDWvsS+DOylso3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrYAx9qSpOfzUM\nE7+58fIJ4ewyUTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJck0jFHXBS6+IwpdybBT/HqDMjQXzaNKAL/3VmSDpxD\nAiAgEzatiIdNCb2TDyFlotUW4h7iUgEPSSv8m78X0OrKWg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3549", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3549` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAWTDG6ZO5VvOs4Lq0Ovm2NLoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExNGFkMDljLWUzYjAtNGY5Yy1iMzZmLWZiNTMyYTYxNDdiMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGZmOGIxOWItODlj\nYi00MDhhLTgyYTEtZDMzNjhhY2M1NzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/ULKygAFOtBnazRuB/eUElHJPqMZorpvvaqrNoR3Ugpv/nmnZYmkH7TlTXsz\nJxHX4PXq/S0n3A+3Qj42nWZVS6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7StDlnD/jnkKLg+/rbntSeeI1nIwHwYDVR0j\nBBgwFoAU9ozxFXoC+oIkE6L0EGPOUajFBFAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDF37Pe3yOkvP0qCj/ZZAwB8LWGLj2fsu9NakgJiaop5gIhAJWJ67B6\nvtdeUHn3rGLvMs6H0obi+yhQWtO3hr446GPM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc/7zNfcHtxTf4EWp1mSNvMFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTRhZDA5Yy1lM2IwLTRmOWMtYjM2Zi1mYjUzMmE2MTQ3YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFCQD9AtvDHG/qIOOGw9WwZK6jW9rIwjYdgHuxKF6pohV0\nbsZR249Q1cVbs2qkBRMABm12tGKgU1nTil2vJgqeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ozxFXoC+oIkE6L0EGPOUajF\nBFAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIumNu601FO3I1RQc298p2TlhIC48zxsfAMjUzrAOzdrAiB/Wv7LVa9K\nfLXyNMHrOp4IwtQfeF52pfHjr3vGsquFQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAQWRu0va328Tqlb3/H9M/Jt0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGZmOGIxOWItODljYi00MDhhLTgyYTEtZDMzNjhhY2M1NzVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MzdhNGFiYi0zMTYw\nLTQzOWMtYTE3ZC1jNTJkNTBiYzVmNGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASczIjjgeEHUtWbLoo2qxL3wDuaKp5P35sk5jU/qqlWimlbtdCixv3He0Jeshif\ndN7DxXCRVGlb4a8kJ85vhU2Wo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTtK0OWcP+OeQou\nD7+tue1J54jWcjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhANaiTCxIv60wwu9lGAkjtb/7BaKvJJlUoeDd2MQcRmeJ\nAiEAmbkTLpSzw49CLlOfvb3g7iOEw0CHyhVMcd1aP4zwYjQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3550", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3550` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAZUUtJ0/Up9nSpsHhV42CoMOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmYzhjNmVhLTM3ZjMtNGYxYS1iY2RjLTk1YjhlZDkyYmY1ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODM0ZjExODgtNGY5\nMy00MDlkLWE0OWUtY2VkYzM4ZmFmYzA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE673qfWX32zA5MtH/LTAwdQks3KfAaLFm6d3P9QazT/V+5cGiscMqoJsQX/yi\nnCIBXcdB6+jPAjoAltkFPbQ/EaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0l5ylSudDYC5+zCFF+0bCwcmnvowHwYDVR0j\nBBgwFoAUL0VC2Pn4eOHk0g22azdw4VLrtwUwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDOKvqZ93EOhoRtHiZ0sTJWE7LqahnqP72jJ9eBRtm/TwIgF+cUw0clOU7FOolu\nk8cKAc50yZsXaqFw7MjUzQkWJ5I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQSa6Chu58BG4/T+Lw4qiq9+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmM4YzZlYS0zN2YzLTRmMWEtYmNkYy05NWI4ZWQ5MmJmNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATs3FeiP/ldzl8A6ijCwj4Sh2CIIeV6tySHvs+ipzoowNmp\n0oaFE+IvDf+n4daIG6CSKk4qU9LQSRlpRLARJUD8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL0VC2Pn4eOHk0g22azdw4VLr\ntwUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPFWKPaMoAzqUEsTRLE/02S+VWeOdxKDtV6FQ2FfSc5WAiA8rRJE4jhE\nJQWJ/+dQPXPQEsgXbODIc1GBQF4mQQsKng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAV2XfAL88LqcjbaLBEME0CjqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODM0ZjExODgtNGY5My00MDlkLWE0OWUtY2VkYzM4ZmFmYzA1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNWZmNDU3ZS03NGU2\nLTQ3YjMtYWFlNS1jMWVkODJkOTAwZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATVON1MdsWUZVfLhmO+SK9t2HV00Lgj7C85MaehGHNoJ/Ez3fKa3ec62aaKHR7a\nw8oImmNua932Zq22WDO5Ka0qo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSXnKVK50NgLn7\nMIUX7RsLByae+jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgZ4hOPOqyvK39heAkEyvdUT59SxAPsdojSedeu+mPSSsC\nIGEyVcEawhpjKf/nuZxEbK4A/zNAChGs9JsJ4wXIGTLt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3551", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3551` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAa4zLtmrSdleMhwYJ1mhTJbYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiNjk3ODY4LTdmNWItNGQ3ZC05YjFlLTAxZTU3YTZkYzZkMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I5NDk4OTgtYzhm\nOS00Zjg4LTllMDktNjljZWJhYmUxOGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5wS2nqlXNqWPyX7JfbL5s2gkQP+Cozh75wqB5IQ6PgQ04ndBoMeSpoiPQtYE\n9GtsB9s71BwTg9QldEftWM9oBaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhEBFOTP+xfNAU5/M5XFa/6gTKOIwHwYDVR0j\nBBgwFoAUVzPARNRtUzarmtef5cHWmwcbx7IwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIBHp6WbcmKzQp8KdB5KULTc9hs6AICTOSnO7p16sI5Y+AiEA\n/3yfZewXMcE4nTNHpE/TaMz1kVnC96pLiDgld2K8e0I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAavDXmbv//5tXMmFBJ9vnw3CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjY5Nzg2OC03ZjViLTRkN2QtOWIxZS0wMWU1N2E2ZGM2ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUvMFAgU4GUJL6fZeH/mBiliZdu19vTdmxfLtKWBS95LKu\nEb278O6RNl3Aqff1Ms96/PIxjgUq2bpNPfgNzORbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVzPARNRtUzarmtef5cHWmwcb\nx7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPT7fngBuS7pJeD5rvCxmO4B1FbFrGHppK8xq1gl6aLhAiAxFxn4hzw1\nBaQwosmy0bxjItK/KXGrL833Y0bXGDY+jQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAW0XDWpHXngJJ8IggkDjNcZzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I5NDk4OTgtYzhmOS00Zjg4LTllMDktNjljZWJhYmUxOGIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNDE2M2IxYS1iNWEw\nLTQ0YWItODQxZS1kNzk2YjRmZjNhNzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQqpUlkwjN7ePdjBecA7/xoqD0YiLl4PTJgLPXMGrWBLrERw99W3wvFjc64YooI\nnzsW3zuMvBQRmqRLk29oVDO1o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSEQEU5M/7F80BT\nn8zlcVr/qBMo4jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJRjTfTB0USC3OrEPWn2KzMDhahVQR9r3EZkurEMGB3c\nAiBZkax4J/50JLSE+wlo4gr0wL4tIhEIQVn+I1hPeqRJSA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3552", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3552` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAfNSpk7rN9s2hYuo08uc9JXhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyNjdiY2YwLTFkZjgtNGRiOC04ZGRkLWZlMzc2NzY2MzFjYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk2MzhlNzctMWY1\nOS00NjgzLThjNzQtYjI3YjRjNTNlYzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbuRO5llZZE5giy6rmEoynnHI/rKx6lB+qP6FMYxoSnKkIwbpW+Kqkkb2MHaj\n0mogdwGUvBV6ZvwANUDYd97AJ6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUem0sc9Waa9JQ3WjoABOj17HsoGwwHwYDVR0j\nBBgwFoAUPITgmPlsR0GDe5ETdF9PEkWgpDYwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIC0qMoc2UoYRs1vJynYmb6tweUY0tTwKF6il+BAqgVVJAiEA\nqgQVUvXnzF4o7iy/oJ1ke+Z6AwQ0fPVdSgQHA9j+kBg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc6J9EVET5joufD2FnT6m7kKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjY3YmNmMC0xZGY4LTRkYjgtOGRkZC1mZTM3Njc2NjMxY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqBaGBNImHJzvFQM75ICwymO5cYC/jE07FLBtfTs02P1bT\nwR/3rUZJSAe0/KcIakgZeoi1tPpIk7psde06f96to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPITgmPlsR0GDe5ETdF9PEkWg\npDYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJrj5d0BYpQK7Y3WhCpD8x0OqTp3+YdQuW/XM+uT9dfqAiEA0Pf+O8j9\nZ4ZyOMJEohz3jeujMD2JGKAFEoVnTr5lVoo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZcWduZHQUb0QzboimYzbVMUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk2MzhlNzctMWY1OS00NjgzLThjNzQtYjI3YjRjNTNlYzJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MjI1MjcwZi1kZGY2\nLTQ4YjgtYTZmMi1lZWIyNjVkNDgwOGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASpMegJtD4UaQ5ys4co0eDMotkHy9xb+ABU6RG67T+pkPVrepM5JM34YLuxqOxZ\nC0DhbBy/5MnZ0RmYZvbPhR3ho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6bSxz1Zpr0lDd\naOgAE6PXseygbDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMfEuzkhgPpBubkofl1d68C9i1IjshT62/sWgf7/2Qvr\nAiBowEsA+z+lAwKGXYUbdCL+wSFzMZhS8c+VgYzo7fejUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3553", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3553` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASQ1dwOjj3ZBi4Wndh6Gv2FiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNzk5OTgyLTdkY2EtNGY3YS1iZTJjLTliNjU5MzM3MWQwZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQxMDc1OGUtMzk1\nNy00YjU4LTlkNjUtZDUxNjg2MDY5NGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaOhxrcCXWA0fy1OkqzQDHNtgxVZQBMOvbH+AFkXa1A3JwdAqcGuMvjLZ2ySi\nlA40WlbHJck9C3wkhRwLauW0GqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWWgqxnbtFsFY6jLV88GgdQtbQHQwHwYDVR0j\nBBgwFoAU3q9+uvtMZAQ/Z43m0DdbMrMopxcwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCAHmr5EYqE\nmFsTP7tH2wOk+77t/vk9RpW3eSyO7S86BAIhAO3+xuYKwcXdwk7AnOx/gi+chCSG\njaO8migDNfpnavUS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQgHst8+ntyYXjsFR2rk07bDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTc5OTk4Mi03ZGNhLTRmN2EtYmUyYy05YjY1OTMzNzFkMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWE7vO5M0ASJgkxGc8WT91dRA+q5MLbPi1U6LZbLsMAIN8\nt450OBcryhpHlf26nxoABpq41PwtyZNZSK9CbXeio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3q9+uvtMZAQ/Z43m0DdbMrMo\npxcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANalzwZaEZmT+6GPa/XG/swjJ0y86hfuTavqxqhPHlG4AiAVLyfoh6BL\nyFExhHZ+G+HQBx5XuNZvg6nCOYnx334COA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAT6wgdj5j5cYHe6R0Q779HPrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQxMDc1OGUtMzk1Ny00YjU4LTlkNjUtZDUxNjg2MDY5NGEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NmFmN2VmZC1mZGRh\nLTRkNDktYWVmOC04OTlmOWIzYTUyMDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATn/zlHGX9Joe18bY1ATMNF9tucjK1CaBy9jJDUWLLrPLignFC8/wumRLmvmf5Y\n9VydAVWgAS22Z+WFccynXW7qo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZaCrGdu0WwVjq\nMtXzwaB1C1tAdDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgfcvBvewHuehBWOtylRhiHbRgvPGoL94NQBMTA3JYhLsC\nIHHzqtB/He+YoZVeGBDtpZ/Csr88L4wFtyGY/7mgSS8R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3554", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3554` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISASkr0YsQPVasTEUlyFv6ncceMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlOWI5YTM1LTZlMjItNDYzZi1iYTVhLWZkYjI0YjlmODAyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk0ZTA5NWItMjg1\nMC00NmJkLWFjMjctODQyYjYxMzc0ZmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaK+mSMmzNyyTYa3rtbz2G+mFX5etXVRdbZSMnsWF93F4ZWjVn8+PhmvlYLAL\noTLKAtWaBRkZmy9yoDKOXUx/dqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0JrGlyTDM6GisFYgERQcIlgChDAwHwYDVR0j\nBBgwFoAUMYSiLX+6BKD7DfOQSPccfekiKXEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgf8phvYRE6zds5xt+HlTuCNf9yQlkMPnDkn/N8drrC/ECIQCFMOHflKh+\nOxOV4XM9DO6KcPOXMrTVrEjkGZRyoiqJyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT/IyNn1LeQjUm8KqvGvUP4oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTliOWEzNS02ZTIyLTQ2M2YtYmE1YS1mZGIyNGI5ZjgwMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHJVsGYEwoGE2eH7AD3h8XwIADU35rz4jN5KiDY4r7fLC0\nO6zVLKGGN88nyqd8CcjEd7xaOs80wtSqXxZlWYQvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMYSiLX+6BKD7DfOQSPccfeki\nKXEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOCeEfjPY0eDlGZhmYEjxuigTWS1jTAexn1dxd0pkanAAiAiSl3C3Vx5\naTn/WOLr0BVzIYaO16TqrXi8uzyUAMraGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAYXYBs37HN35YBtl91Ao1Q6JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk0ZTA5NWItMjg1MC00NmJkLWFjMjctODQyYjYxMzc0ZmZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZDI4MzRkYS0zOTY0\nLTRkZmEtYWE5Yi03NDhjYzczYWQ2YzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQJXhZYOkHkIU85FAtMu2Y+2vsOeMPEN82RSliUU4C0g3tVDlwUnGn6jFrK8g+q\nSBwR8wvsCTCkoRN0EMr8gypso3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQmsaXJMMzoaKw\nViARFBwiWAKEMDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhANJ7KOmt3cMliLr7++ahH9cjxwrI3QaFLVrfosYGuIhi\nAiEAraJue4xahSEKkSdKDAwVW6h4kURaVe11nb62FvLHgms=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3555", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3555` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISASeppQRsdjRxB6Y6ncaKmg0ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwZDcwZjQzLTJiMWEtNGJkMy1hMWRkLWNlOTA2MTRkZGQ3ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNmMDU1MTAtMzY4\nOC00MGUwLWE5ZGMtMWQwYjgyMjliZGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEooAYffRkoOKUcaXq9cZ9gGTw+yYRZkPLkay7fdGhELey0+NmeHLZedgY/MIA\nK/mXbcG3Boo8CWkBY6UQLzSrpaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoksWw/CSszZACWZk4j8s+ouMP4kwHwYDVR0j\nBBgwFoAUV/Xhr9Nwie4nldLeVRrjELHkvJMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgBYSk/7/mZ9UiFXsfc0Sjoz7/bYLw3PjwpmsQ+n9HVcwCIQCJW2oYVhvk\nGCzlJeg0vJhHl44gJfa/0+kA5EaCfCTe3Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASHkbSISkeF9QyyGmANEDgzDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGQ3MGY0My0yYjFhLTRiZDMtYTFkZC1jZTkwNjE0ZGRkN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZOA6DMeAjK3+QWW+p3Gl5T8JG90VwZbKPti89eO53/p+Z\nwa01rmKON64qO2YAEqcYhM5eswVy0IsVT02kbKkRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV/Xhr9Nwie4nldLeVRrjELHk\nvJMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIcdGbzRzbCYMuxB9E6Lmi8zl0zws+AfyW6JvcbKjp3GAiB6NyOne2fM\nMZIJRvdtJc7SD0YhkdjcvZ3+cgURueMo9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAW1a/Jkd//vegUOZjY6rFAhMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNmMDU1MTAtMzY4OC00MGUwLWE5ZGMtMWQwYjgyMjliZGM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYTIyNmEzMy03NzI1\nLTRlNWEtOWE2OS01ZGI5MmIyMzI3ZDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS466ylW69zZ0r0at8OCjgTs1ObwW/U3445hOZ7yJ2rcnA4u6Sw1mDNXA7ZxoZy\n9xTl0vgzAEF+tqIp3vl56oBno3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiSxbD8JKzNkAJ\nZmTiPyz6i4w/iTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJZ5gmG7/W/rmCUW4rY1b/pj0h2marvZMRYWhbhuRkKT\nAiBtxAdc3e9tYG47ORy8lnP91nkR/EVtnBqcyRLc601QPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3556", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3556` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAbxHremUYb9SEUCOpOvW6U4oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwMDc1ODM2LTZlZTctNGQ5NC05Y2RjLWNhMWYwMmE4Y2Q5MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU5ZTEzNDQtMWIy\nOS00MDdhLWFhOGUtMGMyOGI3NjJmYWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvdzzUNc2+Re18vV7ADMADXDSYUG0Rtdc7PWoWUQf9aHLla+PETtbz2AEP569\nJCUmzmh+DOMM+u6XZgAsDrazV6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3RCILAEDvED7TQ+h5whgY05SONEwHwYDVR0j\nBBgwFoAUhFcekqEDzmK8pWdfW/Jup9my3x4wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIGNfSDQXG3NkiAnMwPwxyCe7rzEEjhcm2sKYhWwTN1S4AiEAhxKtdc34\nEB3KDCrPJG8IRg9bWyLkgQAeL+TFYoC7PRI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVzKOLSwZIbP0O+5XYkKXOI8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDA3NTgzNi02ZWU3LTRkOTQtOWNkYy1jYTFmMDJhOGNkOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpuExI2JhTT2lSfBH0Pve9OieQ7I1Vs/ihjV2qD7qv4Osp\nhm0GDhC18m4tfZX9opGrpcNAqZlysSYXT04GaNSBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhFcekqEDzmK8pWdfW/Jup9my\n3x4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMF9cGKCrwIAdAmQcLMgZPC/Q343Q1EDMRKj8bk4v4l2AiEAp95C8SGz\nvhFp1r1tbujYr7mcTVa8kdNF8b6wHhZeGgI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZKAQy4EKJqGkVMFuv6sekhUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU5ZTEzNDQtMWIyOS00MDdhLWFhOGUtMGMyOGI3NjJmYWMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNzA3MWEyYi05NGMy\nLTQzYjQtYjJiYi1iYmYyOWE1ODUwNjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQgQtCBYccK9yaMqMC5junj+/LBfYaPBqISYvZySuoudLjAGzl+MCtbPl9HUZ7s\nAiEi6+5JGZl2yq5Azd3W55dPo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTdEIgsAQO8QPtN\nD6HnCGBjTlI40TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgSlWHHrEM38QOLbrFbmxPS9wHlEa1Bz1BBFoqAH92t/IC\nIQDzcLfMGeeS7H6EzkZAImM9YR0NuR4ACGVwIOd2eSuPEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3557", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3557` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAV73G4y8gzK5gcXAHWulzXawMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwOGZhZDMwLWJiN2ItNGM1OC1iNTI0LTc4ZWZkY2YxNGMxNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzlkODllNWUtMjcy\nZS00MWZjLThhODQtZGY5NmI0ZjZmMTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE59g+2NqKwooujv92y4L0XHGD7XIDU1jIxp3u9EX7nLbZihL6nvbabupLdQcb\n9OPG/aoGqcAOx6YP/pdzGqAxcqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcuz4BO2rphoYETEx7UJDawWcY7QwHwYDVR0j\nBBgwFoAUUX0OXFI8iJun2AB+Bwjyvz9LEgwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCf6EDubhdZuGkC4q3Ugmw/juzYlGDNhokV+5iC\nCpYt1QIhAOTg+GBFhnV/tA6GijYTFjDPu/hm1WBjzdZ2HtUz2OXK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaFbv/qhDjZicHKc3+WkgnquMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDhmYWQzMC1iYjdiLTRjNTgtYjUyNC03OGVmZGNmMTRjMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOJWsjE1RMeH00q27uq4Tsuel5ONxbvQrn5VHFxUjk7L14\nw0uoJRzDW+rZkhqyy4+d5WgzIuiXje40WdGKGqCSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUX0OXFI8iJun2AB+Bwjyvz9L\nEgwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMHiSyFkEaJ9KksdLhyq6S4DRZZ7+z0Tacp0meCf0epeAiEAmJph2t4v\nON4TzgZcCgI3cLc1NXxS0M+MoQqhOV5Qqrk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAZUr5Tn3txRCEPaGPRYYUL0BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzlkODllNWUtMjcyZS00MWZjLThhODQtZGY5NmI0ZjZmMTYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZGY5MWEyYS02YzVj\nLTQ1ZDAtOWM5Mi01MjcyNGQ4ZGEzZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATB11/CMnififDOrPMdQgczqvBDTrcSmXBM59YT67QjimC8HL2xBF32HcADitMb\nj8SGGz4a/m0I7Wzy/fd8O5cDo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRy7PgE7aumGhgR\nMTHtQkNrBZxjtDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgEHFKCE3TFCILFdZBT7wUiHbdbEi6jo0DOcFvgyQpq38C\nIAVxziUWCeAQvzLTkq0fgItT0JkLSdsZUfLFtvUbeem4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3558", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3558` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAfCRb99oY/TukAPIZNf74qelMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNWQ5OWRiLWUwNjUtNGMzOS1iNGRmLWQzYWEyNzc3Mzc2NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWEyNDliNWEtODY4\nNS00MzU4LWI0YmEtYzU4ZTUwNjEyOWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIF/4suFDEK9vAc6DoTKrI8HL3w0aYNBCS37zOgb/OOQKVW69/7s1Jk6j5fEm\nUWvir8yoIrYIvTPF6hC5LvSAv6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8DX2VmS3CNeRJSMLwqwCIzrN77gwHwYDVR0j\nBBgwFoAUbICRVT+SdZBl+s5O6DFfJZhsTd4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIDzvnwmQTuMSHRQtmZl1tzCHbFfpHX8ewyGWUUyE\nIpdAAiB8/IoYUIvFE/RpDlknmgCbsnN33gqo/gKD4l9QO86CNw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbqbfNGLtoNYE2nBkcPT+e5/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDVkOTlkYi1lMDY1LTRjMzktYjRkZi1kM2FhMjc3NzM3NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlQXQis/QOyn2++NV/vZ5yn06tw33Ceal281hOtoaMw3/h\nxp1zIbs1Nx0uMgdbk0/NUm+pjX+eFnkzR88uK04eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbICRVT+SdZBl+s5O6DFfJZhs\nTd4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCkUEoPz/XzC4T0d3rsX4mwwF/RJj0g0yVtNN6L+rk2UCIQC2zXm0y8v3\nKciSoxFKuUgAcesBdQzb24mxVJURu/3fzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAeQ4fFEHZWW5hwDErRHIOTKrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWEyNDliNWEtODY4NS00MzU4LWI0YmEtYzU4ZTUwNjEyOWYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNTM3ZWU2Mi01Mjc1\nLTQ3ZTItYjM4MC00MmRjM2NiOGNkNDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQI6zClBhq8YMwWMS9Y5mw4V8oDCr0xDBTSb9U5WHle35wxzhSbrHerUYU99AnB\nohAOiVSjfttQniLJK93jS78lo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTwNfZWZLcI15El\nIwvCrAIjOs3vuDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhANIPhEwhYg9uE4F0OkUfrr6zVY0dOKngrG0Xy5idK8RP\nAiEAmRJM1P+JeZFKpnaSovBEK2DUbsTaK4vXNn2V3aYle0M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3559", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3559` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISATzFMwxb8ACxsRgFUqDA+9AsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5YjU4YzI1LWNhNDctNDNiOC1iN2YzLTBmZTMyMGU3YTg1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY5ZTgyMjItMDhk\nNi00YzYxLTg2MTMtYzhlNjExOWQwY2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgWpgmVqxbIJ6P8yLS1F43qjlM8ninVN6n6EWCdj2m7vKyxsC8cEwLMaSNeRW\neQOuL1p4ENj9o0zM2k8PnZFclKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7729FKGTT/oFZn/95qJvF1Gtrr0wHwYDVR0j\nBBgwFoAUF9uzmbwbEWQrsQa9jwww2kxdX1gwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQD11GY2EcpYx5tJzfJh0lJXMy91D+Iig2sWCxRkMn0MUwIh\nALbAmLXZLr8pGhX/bDiGaF4iP5A76C1lb1GF7BAWiOjk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbkmzaPE7PnYzDT2hPvLMwqBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWI1OGMyNS1jYTQ3LTQzYjgtYjdmMy0wZmUzMjBlN2E4NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWVsNkMH3i45jfD9pin3Sk8uoS3CwGxwi3cSxLB8e13NYD\naSPpKVBz/VF8dnegSCCPeSoIox2PLTRKLE/JJCYNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF9uzmbwbEWQrsQa9jwww2kxd\nX1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ3947HhKMwVsDZ8m7m2HblUqhiEKfukmVwACMsX3/AACIG1+v30M3TiL\nPPYlXxc/8oRwlDgM9ddzFYd3QXLiddkJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAagGTO76O4YegQ9mvQbVDz8eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY5ZTgyMjItMDhkNi00YzYxLTg2MTMtYzhlNjExOWQwY2MxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNGRjNWVhNS1jNzQ4\nLTQzYzAtOGZmNC05Yjk2YmVhZTJkZjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARQ/eWGOnRQbTHZU4/Aw3Jg33wCv1xhAcWZLhjVPcrhbaEhH7DCscuGNPmCfLw0\n2TEW85CkuxkFD0m2F+e9XZ1Yo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvvb0UoZNP+gVm\nf/3mom8XUa2uvTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgZOLUME0iOL2HVHvO9io1/mc2adhEv1pj+cM88xvN2owC\nIBz3kyqMpOiEEM9cjWB3V2uC9pET6/hfibnxTIxmrIGP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3560", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3560` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQvKEdlLPkvIEdPhxEl/dWH+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4YTllNWFjLTkxZGUtNDQ5YS04ZmNlLWVmZmI5ZDA0NTYwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY5NDhhNzgtODY1\nNi00ZTcyLTk3OTktOWFiNThlZGExNmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGMQy9nLP5IKE3YDhqTKT9+RpZdzZ/CutnfKqzQHGosolDKfoDF5eNNfwDAbI\n5chLHnRrXL2Kp4rGPnlLmU0hN6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1b+W+imJrzy3Zg/HB1udvQ8jYOgwHwYDVR0j\nBBgwFoAUsqIEF0tCNODKtzdDBP5kCfhvnvQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICm77JxENVMwLLjQPcHfS7Dvyp6pmr5H\n5MZujGeTitMWAiAY/4cB7q/p7OIapD80nlkD+ECwtAfjpU5liQt7+DuaRw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV12TnBRtNI3USXvXdcJDR16MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOGE5ZTVhYy05MWRlLTQ0OWEtOGZjZS1lZmZiOWQwNDU2MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6gV5tbZzWBm6PNOO+rfq+eRTdu7QnJaMAUdh9OHnbDRCJ\nu2zviY0WcHRyP7TMlqH/CFljG0Zf2/44QivIoTveo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsqIEF0tCNODKtzdDBP5kCfhv\nnvQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM0fwzPysO+xrbjsVgA3+ddhHxJBSYwTmT2kHJRHpdlDAiEA+yrSAwS1\nKRsC6JlepV52hs/CiAKpNzM2Qsg9dFYCIU4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARq19zKXF0WkjArpPldRjRacMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY5NDhhNzgtODY1Ni00ZTcyLTk3OTktOWFiNThlZGExNmMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYzhiNGI4OS0yNTk2\nLTQyNTItOTM0NS1hMzA0ZTdmYjc0ZmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQeixarc5meazoQUklvJhjQ7YlpkmPs/bPm2PkKwA4wv999JdbQRQfolKhAjspQ\nX9TH8Bt9FvV2+Qr9nPOYI7OGo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVv5b6KYmvPLdm\nD8cHW529DyNg6DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgVrEDjcEfhiRqftiMUHEslKklVCWllauYfzzmSCY2UMcC\nIQDQK1DATvLXen9EXHk0G8STOyWBVbETns4F/lZwZQWgaA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3561", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3561` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISASwauFBT1OB/rmPzCMrxqLY9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NGU0ODRjLTIzZDItNGQzOS1iN2M4LTdjZmFmZDkxZTQ0YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FmNTYxNGYtZjc1\nMS00Zjc3LWIxMWItMWNhMTgwNWVlZDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc0MZBfcBkJFOGTffsus1PYUZmm6WdK+S1SNqJuJl3sc8bk4H5BHbRPteJmtC\n6/1GFjCUt4BlZ5P5jjDxsaHhTKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFcsLzgH6nFCRg40k2C6oAyalWhowHwYDVR0j\nBBgwFoAUcMGmJcOb+gh6gdI7HmxNP70HaNwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGBAkcya2b8HUJk1epFfDI6VW64nrZSL\nj37SL4uZZElhAiA7su3TIgJkOW/irOfscXz/TgflO4nCzG6wrOggFSs+ZA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcSQGojMETofhMHy7O3OI+Z5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTRlNDg0Yy0yM2QyLTRkMzktYjdjOC03Y2ZhZmQ5MWU0NGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJQuSgM3mPWA5il5GYKltcH/b4FJwf9pr2ff73sckZ6ITx\n7XowaPGKXXJ+Njp0sj3ptCEMe5RqOtCDQNZ6UC86o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcMGmJcOb+gh6gdI7HmxNP70H\naNwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPSghN+Y+IJ42xk6PHqpznj+uRliW0HswSz0k2Dy4SngCIDlCn5QsMrxC\nELRZe9aKIEvtemCe+7fvGytqIQq6N93d\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISATiEZtIaOq+rkV2tee2/PVmZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FmNTYxNGYtZjc1MS00Zjc3LWIxMWItMWNhMTgwNWVlZDA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NjZhMTZkMC02MzY2\nLTQ5YWUtYTkxYy0zZmI4NGNjMWQzMWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATSktWhAYaRISy6bpyc8DJlJ0PdsnBOoaZdRVhJLvmA4R6oIlL3Ar+hXhaHFLNt\n2SjYIpcoAaRLAYB0hGVbAaPao3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVywvOAfqcUJGD\njSTYLqgDJqVaGjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAMZ2TZGsx7hUJKdQ2j+g6t1vgPQWvQV3Mdurj5I+s5wv\nAiEAk0a/KZB02gMQnq+Ki48xQR5FIIBHiv0fOTLSOVKXOHo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3562", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3562` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfMvXtU5EmV9hkoVncqSZysSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5OWI0ZjJjLTExYTktNGQ4My04NTY5LTQ0ODViOGYwNjU3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQwZDcwYWMtMmVm\nNC00ZWFkLWJlNGItOWU3Y2M0YmIxZmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3g6C2PZbz02XuuiNNra1hfXueV+Lcf4hHUzRpISY4syuspRMHFuOxPlIxGxF\nqYM/7we0m8Tr3TkN51eizSk2F6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgk2uFD6Yf4NWil558X/4MXwdMsYwHwYDVR0j\nBBgwFoAUDehmxW4kgrx2G2/Xx0PePkN3dR8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIFuGSpsJDgdr\nnSvjwT+qMOQCK+UMLreltR7npTNyHWm3AiAH+tXPm4UNk4LCYxrIYh5DKpfIBise\nn8utir8d2+IPGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARJSzT/fZSSMVOwulp1YU2TZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTliNGYyYy0xMWE5LTRkODMtODU2OS00NDg1YjhmMDY1NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVDFSyAmU7XU45fGen8rcfOCMSnXL7vFeStrFN5qWyAz+i\nv24at3AOONWYh1PwRoORAsuoY5TqL+HqiRXgoSE1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDehmxW4kgrx2G2/Xx0PePkN3\ndR8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIMU+aYfwZKXUUDsa40Z6PqkcCSx14tB2t5Az0HMxmJkAiAsPIRc6yGX\n1tlq4B+f/Y6GGKOqcAeB/aTXIXze34/xag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAazeIdEA6UgK4v4osSpfQUIPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQwZDcwYWMtMmVmNC00ZWFkLWJlNGItOWU3Y2M0YmIxZmE3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZmExYzA1Zi00MWQz\nLTQ2YTUtYmM1Ni02YzBlNmQ0Njk4YTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASPSBpWVrGCxKgBn5J/apWj/odD5309HqBkE43h0ksRzZzCMCPyKajWxW6y0rIO\nrJXBwW/biZRSman4LRNbrkRNo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSCTa4UPph/g1aK\nXnnxf/gxfB0yxjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAK7Lsdso6WfisgRMn6YRXEc3CQIrgpd5uLkxzo2VNCer\nAiAYdp9IS99rJzuq7ieDxnIXszbBjbdXwBKMnbxkBN7WGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3563", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3563` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAUQ3H/f9JjayfuAUUJrRkvjAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyMGUzMmNjLWY3YWUtNDA2My1iN2VkLTc4ZWZiYzRkMzY4NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTRkNWZiNmItMzJj\nMS00ZTQ5LTg4OTgtMDhkMTU0MDM5YWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYsXFXQ9X5fPRqPgD++fnO3aEaWYJw0wLQIGZ3EBq9fPQ/j02Opz0o+cFaWAz\nkfVKUuJ8Idi/pUpjxxj2YAjxCqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmmYHhwlxyYqGQ0DNpYjraFRgnd8wHwYDVR0j\nBBgwFoAUBaM3gBRfTDmshLnLKfHM5OeNRyYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgCP12+GvlkXIA2keO+ij5ePWKqPmmRah4sUp6qiPDoZECIQDL67EymQty\nq9hKTq5yAGRB2odT7ki5gLNFljApM2KbVw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZMqdTD9t7aB5/96aDWcxLVrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjBlMzJjYy1mN2FlLTQwNjMtYjdlZC03OGVmYmM0ZDM2ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2tAX4ZYolfZj9TrOLrI3alJW6d9ZNF+wm6Cw4sW3retEm\n1ewdS4iPTPPSjaC/nAW3HN/4fpgxhp5g8HspggfNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBaM3gBRfTDmshLnLKfHM5OeN\nRyYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMUrECRdNtYIx6lowdLsTFOPJWnZa5dcBydD0NKIwbpxAiEAwr9C2L0V\n6BDaGbTzvLuV7eP/vw4MLtQYDlzrlqEFxB0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfJA+/fA5XcWmE8kKqsXNfiUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTRkNWZiNmItMzJjMS00ZTQ5LTg4OTgtMDhkMTU0MDM5YWI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNzRhODY4My0xYTZl\nLTRhNzctOGVmMi1jZDQzMWRmYzczYTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATj67gMcXr1KE8wiXLm9KhxQYFbjTnOg95x0OqcSyUj0sCYjwTEGIPfagRt2I9M\nd8vqwXk6XXmZjR/VECPPG9Bqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSaZgeHCXHJioZD\nQM2liOtoVGCd3zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgcHbKFs3XTXrh9dyNyt/jflsnKo9t5E7VsYaPlhsYoZoC\nIQDE4KQNErDHlAowX6E/RmfOxwmXr/QfFO78nUZ9hUsNkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3564", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3564` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAaQkMinY666q56l2Ezzwq5HAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiY2Q5NWU0LTNmYzgtNGNhYS1hODhkLWQyNDQyZmZmMmY4NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzkyZTMwZmUtNTM5\nZi00NWJiLWI5M2MtZWI3NWRjZTdjOTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKesToFjJdp1kOxRGW3dEvsRQCfKQq+opkLxk+Llqqm0C8wxyq1C2GtoRYGVb\nlR2aUw5clx01MtImDcqhU8hms6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAmsve9mvVqNApMorFwgT8kH20QcwHwYDVR0j\nBBgwFoAUEUxQ98salPQUnfLYc055ELPqXdUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPMJt5qD/dJxrUJdrrns0DPVExC81bshGWy5LPkkTcxcAiEAnMtn01HU\nLZiGHMrWHhKJvOBEDWKm6EcdExEkdUrONUw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUpZ1UqYGgdohXUz9o3PlPexMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmNkOTVlNC0zZmM4LTRjYWEtYTg4ZC1kMjQ0MmZmZjJmODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7RBwSkQs23tYVZPfShnd+/OEdB+BDpMK7Yb+7Zpr1VWqX\nrrLuRN7wh8MySZygKI4ouTK5Rm073/NGLuu/BTFAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEUxQ98salPQUnfLYc055ELPq\nXdUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgL+7Q2BRKgJOqgJiKGGNVSVM4RHykPDU2BQ979TTe/LMCIQCpq/gWp3J6\nAg0iWmX4rNcOdmB9TIxeormSJWq+uQ1gXQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASNcNt3gHI1EO2ahXXWnnCMpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzkyZTMwZmUtNTM5Zi00NWJiLWI5M2MtZWI3NWRjZTdjOTgyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZjJhOWIyYy1kNjgw\nLTRmNWYtODZmMS1lMTEyNjcwMjQyZDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASrMKv3Q0XcMOUCShcqJ3oWPPkujjGDG+03WvGtVhZDEF2+ca2QPdUwM9DZ9iUV\nGLxBak+s+rz2Vfo/VamrY0lCo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQCay972a9Wo0Ck\nyisXCBPyQfbRBzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJ8S7Uvqz48Une4m5kTRm1QMvDaom4t8oxgB7jdO3/ez\nAiBuYutA/ZOWHaQ57OBmW55qWR1Wad9gxJu3LSpx9+jdxA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3565", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3565` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeepQCMJgG5+65dXX/3o4ddaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2NDdlNGI3LTEyZDMtNDAwZC1hM2Q3LWFkOWI2MGYzYTg1YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjMwNGE4NTktOWQ3\nMC00NDhiLWIwN2MtZTY3MjEzODU2M2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETaHC+jGbVzdROfcBTWdiloaSHGQdOcgsXsvc/FDZ3GjHqr+L0ly2bIaOB7CY\n11wprSZVeG6R0DrhCbeXsko+RaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3w/IWEpoxIBiFpUqcDQY6aA/AwIwHwYDVR0j\nBBgwFoAUpTElSKdqSXRHJIWmR3RD3mjeKoIwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDBQ4Ok0lBt3uKWi+1o2vUJeBO3qkrcF+PzzkTP+EyKuwIgdZ1rIUKe\n+8h8bRcKlFXy773Ls+3qT1tmwQSWzVtaKOA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQp24uAPu9o7R43J2YKmGJscMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjQ3ZTRiNy0xMmQzLTQwMGQtYTNkNy1hZDliNjBmM2E4NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASI6sKgmy96L6e7djn2kCr5AC/EW0zDhAzGfcVzu54uX7ud\n7OGoLehAO+HK8NNmwWszt2oV4hPf2lR88HtAIma3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpTElSKdqSXRHJIWmR3RD3mje\nKoIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPKSxgby/zIBPYe9EhlEHf3p2DIJo+FBJ3LonVNyDHIOAiBS0K7r6ZDx\n3NKy/b0zIiOqGK3AayQyU64qnDyBeoauBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUZwRSXKy7nRyr14javn2K4aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjMwNGE4NTktOWQ3MC00NDhiLWIwN2MtZTY3MjEzODU2M2E3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZGJlNTkyNC0zZjIy\nLTQ4ZWQtOWQxNi00MDMyMDE3ZjZiMDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATer+pLrP5MwqUz+pT/Q541YNSfWbOa92p5kEZcLW0r9KdT1FzxvFiCKtUMg1AJ\n8SuOnIQg9zK0uAuYZ36XDotfo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfD8hYSmjEgGIW\nlSpwNBjpoD8DAjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAKGENfixatGcJOCZd03RLpllM7tpwx+/8d8Pd43/nXyV\nAiAPq7i68+mjIbYHCZ7W/jOv8qiMTSkL7axchPQBQ1cXMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3566", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3566` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAZu+/B55RNsld+LXj6gvrRKMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4NmU3NmRlLTdlOWQtNGQ3ZS04NjJjLWY2YmFjZTg5MWNjODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUwYmRlYWUtOGI0\nOC00ZjZmLTg1NmItMWVmOTI1YWJmZmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESsyjWWviWM7v7iAJzVD4CS3ulkRj+6wgd3HPcLE2W0q6e3QXUCw40GiV2Cq6\ng6BeVc4egwjVTzKW9PCnFGZWlqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaXtWTY6kZGZKdhEVh5zniZx0lDYwHwYDVR0j\nBBgwFoAU1TMWZFmYhGkaUsTSe9UQa9WJVfswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBO/z9gvFdhYCOpjbBn+Tz670O3RfAEQ8DqVa405\nJTZkAiAQfp9++ouY2MQj7NV4c5ZK5wVo4w8uB1TceGT3XmcZfA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQDc5lWky6GfSQOVjv+i+1v3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODZlNzZkZS03ZTlkLTRkN2UtODYyYy1mNmJhY2U4OTFjYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZwpfOaHeCVSxHYr+uYxxzU5/30mSC508pTfvM8r82O039\njAZeNyBd7FubGvnqdQcjBFuaXqQ/oGRnfQJ/MY4+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1TMWZFmYhGkaUsTSe9UQa9WJ\nVfswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL5dlbE8J/Dff8FojdnY534Sya4z953gzRvAKN2Qd0N8CIGb7Ut76dhyH\nt/P4A+um36xRRndUgHWsyAoNAgC32LnG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAf6Vj+PgzHZp/ZDRSbKwVFu/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUwYmRlYWUtOGI0OC00ZjZmLTg1NmItMWVmOTI1YWJmZmYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0Y2VlYjUwNy1lMzYx\nLTQ5NjYtYTE5Ni0zYjMwZTg2ZmU4ZjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT4dLR5t1Gbdi4Rp8LVhtv658vNCLBJhjkkyuI4kfFL97/py27YlDhS/AeUfIGk\ncxe9vq7XGs7Dp8T++3F4ZpmEo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRpe1ZNjqRkZkp2\nERWHnOeJnHSUNjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAOUjEaBNYtyowJY62zsXMPm+t1/SGI6ODArSAcqB1oCJ\nAiEA9DXY7mTDNMwQydcq7Enk6LKYYAvAerVxjBbcOFedVdc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3567", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3567` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQXbsa2q07heXoy1nXDGRFtwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0ZjZlODJkLWQ0Y2ItNDIyYi04YTI0LTY1NmVlOWM4OGQ1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhiNjY3YjctZmZh\nNC00MGJlLThkODEtMDViMmJlNjhmYjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/VeY3LA++aFgKsfPn5eAMxu32v68b5NBOzFvWBMXamVDTzLqh1TrXg8DSZiD\npSfNSKOkaTjkdMMWKclXVLv6kKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/0xxHqg+TVGzrVaMvQ8BgaBRDzowHwYDVR0j\nBBgwFoAU45EKLsHFAxjaaoaUU9lpUAj3EBUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIEiHJtGgd8Aut9+Hs2dts6Tl9B+A10LFjghFJOP1\n4F2oAiEAkqKOYLP05dT8rbgy/tkLFtbpGJ83w6eQZCddg46Oyzk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYW5ijwb9LKwPuGTaV9i9XC6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGY2ZTgyZC1kNGNiLTQyMmItOGEyNC02NTZlZTljODhkNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnuHNKr7/rbPRMO4HdfNg4+x4CWepmPRupzSNUrb53Dd7G\na+xCa4ZBnUm+wtUx8UG0bnCUxKFus4Tz4BtlZo/no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU45EKLsHFAxjaaoaUU9lpUAj3\nEBUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMqA2qA6fI4sU9db6AlAl3R7H3u+nDkWI2U/GfWXW9NzAiEAvEmcCIpV\nz5Ghq7sAecCUdEPk4Cu6EXEqnJfAtkPK80I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAcoVZ8QSGSzTOAAivBZ0xnKGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhiNjY3YjctZmZhNC00MGJlLThkODEtMDViMmJlNjhmYjMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNDNmNDU0Ny0wNTRl\nLTQyNTEtYTE5NS0yZGQwOWNiZGE3ZjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQxSfUURdE73WWmR7EUC4VnD9BhNER7BRvRNIAJHI0FdsHa9Gq+ohUAW9a4To5U\n9bQ0l5mkG8t7a4JjBm/0RkKuo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT/THEeqD5NUbOt\nVoy9DwGBoFEPOjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgGmcCE1fEYa6h9CLiZkJOe+w47B1APPDMsWyiJaeH8iEC\nIH1pX9RqCxyng51d4BHpYuoWTmYQxvL4AkxtxTXvitub\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3568", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3568` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISARBWQA1QxVNiGujlBGpCinv7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyODZmYjA4LTY0YjUtNGIyNy1hZTI1LWEzYzE0N2I3MjQwNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTcyY2MyM2UtOWJl\nNC00MGQ0LWE4ZmItNThhMTRhNjYyNmMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEal9UrXPGmjZoElX9X0hWGToqoI9ebBZqXagCwx2vPaTk1TgcVLQjH87funYC\nHiweyc8DfSmn3H9h2CCs5XDRwqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPP4N1ZBxcnd2BJvoc7h8U8kwNRUwHwYDVR0j\nBBgwFoAUoXzlroBTBJzC3oTmBX1tsEzTqMMwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIBIcPW6/aqdAAfgROQ7bRN5WMKL8bKIl/aa8JZRPHH/WAiEA\nrMVRMybjzEF8V3j91fJQLE/ZCtyDGVE/ZfF6TlCkw04=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcEUukJd9/MBhZUCNye79FRbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjg2ZmIwOC02NGI1LTRiMjctYWUyNS1hM2MxNDdiNzI0MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBllv+PgDoHUpUc02LnJx26Z3qIh5AcP5cy+uFo02/cFbL\nNNwAbpWMNeZEEdbB6NeMlwkGCHfGUTInNSPBAYAeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoXzlroBTBJzC3oTmBX1tsEzT\nqMMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTRuzGuFgrMru+vaYJ4q4yDbYO42Ce85aPBwSZ8pgxLsCIGgtNZp9h+OM\nXCR5ZJv8q79yBFOcxc1ivCvCrxYr7v1t\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASD8fGHZdly6sK7Le+4yASYBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTcyY2MyM2UtOWJlNC00MGQ0LWE4ZmItNThhMTRhNjYyNmMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZTdjNTkyNC01ZTI5\nLTRjZDEtOGNkZi02OTc3NDQ1MjYzYmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARhaYP4uJcQbYEeHkngOMxrAidwY24CQYpNpHVZkEuRtg/OhTfy2/dxU8hKMV1F\n2UER8URn3/M2GDW+sI9ITpY+o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ8/g3VkHFyd3YE\nm+hzuHxTyTA1FTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgIEoHCHcd9LVRkcuhwSyzdgsOi1xuI8x/HfEpb1P7g00C\nIQCJdxLwL/rTk0UlGGz9pK7e2xBgfQLSnoB96qgaTeABNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3569", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3569` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAThVEsQKDh+CW8B5BE0i64RbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MzRkYjJhLTY1NjYtNGUxOC1hMjFjLTNhNzU2NzNjNzI2OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMzZDE0NzgtNDVj\nNS00MzkzLTk0NGYtOWI4ZDZjOTRmODQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4sDYHaaD+dJrItx8Mf731rRN5R9KPrEdd2UFx6/N24eJ+VKAUxnxAASJTjxA\npm0bKupboG7Fb3AwrnlgdoPCf6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMr8qTdgtkmZnhIQ7sYHGB/2IxDMwHwYDVR0j\nBBgwFoAUUPvGrV1t1ep6Qgg6S+Ibg2VR/skwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBRjyWgSsVeK5PYNoYj6hDGtlAuaJeHO\nufHSAjub+2gBAiEA3srBVNw2W+xVnDrS/NODqTAlNcT1Qd7sb5ozoSLi6yA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVj9Lv2QmTT2alRG61VRFtqNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODM0ZGIyYS02NTY2LTRlMTgtYTIxYy0zYTc1NjczYzcyNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASr5gegSR/k8wiGY4zCaYCKcOCo9NS7O4W7adtmdfd6Kt3L\nja09H3Qk3zteKU76URP/5sr8NR3KIjK+cg4zeqiXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUPvGrV1t1ep6Qgg6S+Ibg2VR\n/skwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKh1Ki03LovPLlXWUl/1+JTZ0f+srerxdv06nmKO5/lXAiB46l3WNffA\nBXZI0El+W9Ba3AKnkIgjb5IY/+rId9hP0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYi0ek0HVgdzlb9sUhavXiR5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMzZDE0NzgtNDVjNS00MzkzLTk0NGYtOWI4ZDZjOTRmODQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYzQ1MmVmYS01ZGY1\nLTQ2ODEtODMxMi1iMTdkZjUxNGU1ZGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQrl4A0Nx8SfmiL4xbkVBiT7yzgRoZBL7K4BI8YqjpCA5a9mr89JXOcrY0NlPdr\nbj6UnwS663U0xUJ+tesqBPwFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQyvypN2C2SZmeE\nhDuxgcYH/YjEMzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgaoy8NkQnLiv7I1RnYRo27CYF4pXA//YC5Ei0Yd9NHakC\nIQCUowv04lodIRpvGoF+DeGOwl2QfGs3hyG96pBKMlq3iw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3570", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3570` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAV7i7EZ199Gv8wklvUljw00JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwNTliYzRkLTRiNzQtNDlkZi1iYjNhLWJiNDUyMDY2NzlkZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2MwMzUyMGYtMmNm\nOS00MWNjLTk4N2QtYTQzZjhiZmI0MWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJZDWtw4HxEH3Yt356wCtztlt4bhbuA4xpdM8+pWD33arUxTxjXjvfSPHwi+j\nba10NodVz7C1i97F3VfWhfNgyKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu92dHk6gr7kVTjzDVvKt+MM0OPgwHwYDVR0j\nBBgwFoAUjrpNBUaHFg1Yfv4fIRARENd6t4MwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCoeCOPxmqDOi8HntLEa5E1RJbcLNki\n9kBJ5oynBmvMFQIgBlWs/z0D1b+xveH2ayJpMf/MQNX3Cr/5nfpNNz4CNjY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe4yPjE/ZFjKf/c5B/+t4k+wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDU5YmM0ZC00Yjc0LTQ5ZGYtYmIzYS1iYjQ1MjA2Njc5ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQatRP0XAe/j/wFvaCzjGXotWDHwoc8cIHu0SZws5Nx4/9U\n3eSrs0JrDw+jLq6pK+t3HiGIcnPoXoSStn7uYgo6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjrpNBUaHFg1Yfv4fIRARENd6\nt4MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJW52887nV3iQY1PcAPFZa7e4UqmJSp55xKSInRNve8dAiEA38ubc7BW\niBiRB87JHNfHog1mDaDg2Kgr/Jz0Gd9nAqs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAZ1822/WjbVWiq+cS7h21XWiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2MwMzUyMGYtMmNmOS00MWNjLTk4N2QtYTQzZjhiZmI0MWI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MWUwMGQ1NC1hZjRm\nLTRkZmYtOTk0ZS0yN2M0NzQyZGYyNWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR2TDYO93nlF1hgYAyXWso8glw27empBXmsuyj+6Yrdqi3ysQc+wVFvFEWSKJYd\n2yXcO5AycDddUdVoigG2sxtDo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS73Z0eTqCvuRVO\nPMNW8q34wzQ4+DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgfAi+Z6dWuPrW4l5tBhEldE50HuEcqt4c45c3To1ypN4C\nIG0VzBK82Y/QOgxV8lgyjYJEh0k0K0L8y4n1q9Za3srC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3571", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3571` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAT/MSRpAXTphNNI059jEMhgsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0OGNlMDEzLWJlOWEtNDIwNi1iYmU0LTE3MjY0YzA0YjZkMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYwNTMwMDgtZDYw\nMi00NDQxLThjYWItNWFlZjczZmNhZDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBGTzCnrhQHf9fz5SnGeJ0ripiqbcTCFJvjn3qJRz1Q9xVTmfr6s72EWfcagm\njxRjSyJ9w53Cb3cuzaouVZs/uaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKYKcYOU0OQhJ4ubwURhp0yNIjlQMB8GA1UdIwQY\nMBaAFDgIGJDJ+oUF/AV6dXxi0FtZKzhHMAoGCCqGSM49BAMCA0cAMEQCIEAsMz4K\nWkJLm2mVw7ShWQeanNFkBUKnNOs68i29ybKmAiBD2a9IllP4NnhcQzJk1MvoYDF/\nBcTZMFNbs20Ep5MXsg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfEYjhDBx/TgEnyMMrut69PcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDhjZTAxMy1iZTlhLTQyMDYtYmJlNC0xNzI2NGMwNGI2ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkA6qzpp6fLTHiEDWK1NbqrdeS1zCu2/P/ezCTIgb/DW8J\nEdjYm++7MahwreYZQ9LtmbutUPAyxSlFOyhQ2X1Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOAgYkMn6hQX8BXp1fGLQW1kr\nOEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALJtSFRHaUImG9GYrnSxzOcMuP97ZCqM08nYCTXXCAI3AiBFVWvdMFUL\n1EZYQUrm1NFyQ8K7hFfwpGjuWpEUpLw/ig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdYONhi7RoCCy9+AG45MXo5OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYwNTMwMDgtZDYwMi00NDQxLThjYWItNWFlZjczZmNhZDBjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMDM5ZmNjNC1mOWQ1\nLTRmOTgtOTY1Yi03MDc1NmIwNDI4ZGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARHlRnKOa49EgqGvMZb4ULw2E9UOopHoHREn2nVspvcD+VuWddeiqDM2ik/PneP\nsXS7HDFDsAS5gK3nBQKFW2Xco3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmCnGDlNDkISeL\nm8FEYadMjSI5UDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgMazfATLUSUkctrwUd+M4Ma7WcsFDOoxN1kK5/mQlSe0C\nIQCmroGQxKwIZjgCWyiJHSimVo3wCmkHEtsf84aPRdFerQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3572", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3572` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdACiIWbg9XmMB9OhQLS9uc+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkYTY5ZTExLTZhN2EtNDIwZS1iZjk4LTMzNDcyMTNjMDkwNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZkNWIzNDItN2U3\nZC00NWQxLWFlNDYtNzFmMzE2YWI4MjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGzEJgmgssGmG36dU1znHvvaJOoea8/mq2VGmz0wnqJ6ZVC8lGxjRm+/+OGu4\nYQXvYIllTri6XkI+TZtfCuscKqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFH0x2EUBSRF48VwCwW2udJCPA4eKMB8GA1UdIwQY\nMBaAFB5s3B4WdaiM/VgHyJi53wBYSewHMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAN+aYvYwINt3FKabPdOGW8cmGmub3iZVLb\nuJmw3fTmjQIhAIVuDirsDV0XkPD5H2oCK6+KSsVep5VGnFVCUB1VhHLK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQoOjHlU6tCPMr2XCNHD8coJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGE2OWUxMS02YTdhLTQyMGUtYmY5OC0zMzQ3MjEzYzA5MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgYfJc85+kelKjLRVXkNqNHNJtJVqA5QEC8ocZ747xTNrn\nlPIOS0qWUyZFys7wVJ1H4NOMYgUf8Tlg3HbWGvBoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHmzcHhZ1qIz9WAfImLnfAFhJ\n7AcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH29V4itF8vGOYyY1lHmqVmq1/339txqAVoMRgkmDbjACIQDMW8JIavSj\nsi10wUyD+bu8vioykSVkrWRIbLLhV85FKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfXlMGcapRp7+DERaU6G6SH6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZkNWIzNDItN2U3ZC00NWQxLWFlNDYtNzFmMzE2YWI4MjQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ODU4MTI3Ni0xYzg2\nLTRmNDgtYTI2NS04YjIwYzc4YmE2MjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQoZhJbFPyyes2CkdlCF4X5SBmtuEQFsjrp9+EDbcR5Se8aVXekGXTGGjnprIGh\nGAdVsRMXDiVxlY5pBH7i9AKjo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9MdhFAUkRePFc\nAsFtrnSQjwOHijAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgXTW5+HY34/cpcstdf2eOD9cNlSzFA6HdATravEXFGWcC\nIQDdE26LItlVodlQOW5GDajiCOYrtBQtaAVuxM5xSQ865A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3573", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3573` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUSnPuF2E/jjaMTh2cADdP7JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZWM0NzZhLTFlNDItNDgyYy04MTcyLWI3YmM3YzQ5NDNhNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZiNTAzMzItMDll\nYS00ZDcxLTlkYzgtMjg1NDIzNDdmNzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5HiisRyZfYwZr8fY/kEJY0EN1whQdUbetXw3BGzI6ixqgA0Y0w4UQQCDijUZ\nqCFdlcRHC2RFGfISF9t5CB0QxqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPNRFOPAu6H9zedtKSwgjEHfmuwBMB8GA1UdIwQY\nMBaAFGVIsgsm429w7oiQXtnXxTFmUIskMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBrzaZzYO3CYUFaxEpl9gmvXx43E0OeI4Iz\n1LDbpxJk1gIhANUzSJrYu+x9M5b/RZ7hjJj4w2FzygIufr7++o78yzaY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcbxyod273I8u714A4SuND7oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWVjNDc2YS0xZTQyLTQ4MmMtODE3Mi1iN2JjN2M0OTQzYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnma7mn6/y+qUeAEVcw50Y1bEKzkw+ETZ9LwYQo/bxNfts\n3diKfxc1xeenlIOms/h0H56qcWw8ihRmbw2NGyqEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZUiyCybjb3DuiJBe2dfFMWZQ\niyQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMD/yIiilvm7kOD5G22Q/NVrVNWfGnsjpGwE6W66WeTTAiAdXQWvJNry\nzS78GaY24I7WlRLv9PcXisBZsfu0xPTrfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAS/nCGF4DYQTSpEbvxIkvCXQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZiNTAzMzItMDllYS00ZDcxLTlkYzgtMjg1NDIzNDdmNzAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MmU4NTVkMi03OWJh\nLTRiYTgtOThmMC1jOTFkNzU0OTQ4NmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATHF8HCknLXjFQcD3KxDq3Ui6xk898ftKX86GpTj0wzbjXRQ+msYDrmA5fS5az8\nIrWKfrcmUOcRFQf6SDnBeBYho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTzURTjwLuh/c3n\nbSksIIxB35rsATAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgIaLugBTUqJYSkgS9/9RjQmhY6+DeICRIHjIh2/FxM9UC\nIQDMogN91Z6iswKCVi3HiXjj746N9d3Ol5yhMKbZZyf5Dw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3574", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3574` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASIPlc3tTTcvorbJAetLsvK5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYTJjMDA4LTRjYjctNGVmNy04OWU3LWI1ZmZiNTRlNzIwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY3ZTJkNmItN2Q1\nNi00M2I5LWFlODctMDBiMDFlMjA1NmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeEGY/p22s87mrv87XDa/3KmpIl/7ZJPCDNaokM5vsiF2uYNX4J2J448hGm1G\nYNqNygPWkb0ygmb5noJKuAbm3qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRos21clpnDHMyHw9fnSUmyxAzQtDAfBgNVHSME\nGDAWgBSSZk1ekSjQubEn6scxSbnjrOFmPDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHcCMMECFLRuCfh3TvfhUXGtcq52BbV2\nYkqeHIO4LYhWAiEA4v81/eehNFSsdMT5dMFSFpzyIh0psdvS7leLW3iV8t0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQPeQorfwxlSbwSlCm2PYOuVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGEyYzAwOC00Y2I3LTRlZjctODllNy1iNWZmYjU0ZTcyMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvgl/D8NvCHbI/UVp2fBZZEU+dukIZR5S5zphvhNNUYIlv\nUonfDqk/H0Y+/NTXWHQmKfQ8GBNUkokGXdp2XKbio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkmZNXpEo0LmxJ+rHMUm546zh\nZjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEiVfi5W/cDTpqHM5Byntr2aTQT7rckjxYbrND7Hh8YwCIQDjsKUTdhEa\naSbXLdC3SiVvo/TIWloeYQWyuuSMhsUtgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaKJZdh/NewuZFcr7N73E7V5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY3ZTJkNmItN2Q1Ni00M2I5LWFlODctMDBiMDFlMjA1NmM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMjQyZjU5Yy00ZDVh\nLTQ4MDUtOTAyOC1kNDVlMDQyNjMwM2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARxq26b+fw7GDP0Op+RApLYsk4KhOwqxFr84r6KLGldIS2kPUHw4U0xMPj8MDSC\ngyNQ8BaemPBX8NbT3hOH08Dmo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRos21clpnDHMyH\nw9fnSUmyxAzQtDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJwQmJjNkiV1so6ViAJr6U0tbAGAeQRUbNoC6ecUh21J\nAiBvfl55lH4g1habWD9DoDLUOW8If2yg3NBgc7wZJ/cq1A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3575", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3575` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQ6mmhQgy+QNLdgJ8gV+nbNAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMTg0YjlhLTZmNjAtNDBkNi04Njk4LTJlM2FlZGY4OGVkMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTEyMjcxZjktNWQ2\nNi00NGQ0LWI4YjAtNTRkOTdjNDYxMjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPZpcNXsigSdfgKUgE3BJplY0cRToNGI5f45gO0pmx+S+x3k5ysxcK48p3oy/\nv2VuJmTEI3qpSpQ+IyYlrD7kcqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXbwOxHOWUfNmwlrFSRDmJ0Dwp4EwHwYDVR0j\nBBgwFoAU/y2nGUAmtumwB0dPcv4FrCVQWnowJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA8WgIcg225yds\nc45qPFqYHBFYwYjE8tVGz+/WTFYTEQsCICKkMgOvAuAyw6oeVGWtGEgjW5Y+xAPA\nKE41Hm0/yVry\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfcYajA/NdIw3zr9DXW5Q5Z6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzE4NGI5YS02ZjYwLTQwZDYtODY5OC0yZTNhZWRmODhlZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrhCRhOPYhE95yuLcjx5bri8LgPpfijNlynMhHzzjEPICN\nKaJtJ4+4mhxRHLJ4+eCM/fqpJKsHFLg8EnlHct5Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/y2nGUAmtumwB0dPcv4FrCVQ\nWnowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPa5kYXjy4OFai8EbxmoZNaXyPpblE5dpalD25Pv7sdJAiAcm4gqY5QN\nOx7uuJWZwQA/AvQOxuLqv6kZIRtXwrJ3jQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAXm3EsiUta4dcRM6takzIqUuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTEyMjcxZjktNWQ2Ni00NGQ0LWI4YjAtNTRkOTdjNDYxMjQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNTlhYzg2Mi1hZGJl\nLTQyMDEtYmJiYy1mNDNjZmE1OTU0YWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ4QDM3maEx98w0UGqMBGo55uEKSiz986SNbLoA3M2sGxbBGkSjzTHohllA3ZYm\neIhvmi9mgn6bt3QrupoR+yx9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdvA7Ec5ZR82bC\nWsVJEOYnQPCngTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgN5mOw/ml9Bly+S0HL0cNYzcz7dDc7vvLmCcZDZBuQqgC\nIAJa8LEhxt5AtlPE720OV1MJHhSFw9BxP6TX/OaR46jm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3576", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3576` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAap8cnEeqG5JsEnzLmVhJ2KPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZDQ1NWRlLWUzZGMtNDk4Zi1hMTM0LWVkNzI1ZGFjMzdlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRiNWFmNjItYTcw\nYy00OTI0LWI1OTItYmQyMmQzYzdhNjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESkRpF8zm32pW113oc5zgBNwnTTdOydDhN6Ov3tcA//sDxcCrYmRo6HzA+bKb\n3zjck0eJt5MgGSIaafZMJ+erq6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjXtVrobKkyKoHPseU+83Io48UxswHwYDVR0j\nBBgwFoAU39vSXTZRBkeLZNViVW6TgSaEvI0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAkU7NZjqG8xiP\nR6qaDBP0UAWKR+6+8lp0+DxCMgv9XhUCIQCwdC6tI+Sqf+DbcbIZovUycSk92HPC\naIOnC2mijuyE5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQuXGQDSBTguL4Pj44TEYJacMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWQ0NTVkZS1lM2RjLTQ5OGYtYTEzNC1lZDcyNWRhYzM3ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmnlNDOk5KfjNIDCXzsKaVo4v4ggoJD6P24DvGGydpaDuf\nVT55A7qYVmhya0bs4kDO2JXAQkrDnk6WIBfEOcOao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU39vSXTZRBkeLZNViVW6TgSaE\nvI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXpKcJKXtcos+CwcJdI5/F+gtFE0CWbR7yZedfCZMzgQCIA7TYDXl4+Y8\nRmNYde20BdrHDGDeZqPwT3lpYB8z/qaQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAeUFy1bBX4dyHq5Rno2IrP1KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRiNWFmNjItYTcwYy00OTI0LWI1OTItYmQyMmQzYzdhNjEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZjA2NDE0Mi01MjYx\nLTRkMjYtODI4OS1mZGE5ZDUwMmYzZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASReWLwTAY7LXnGXAB5E+tEij1J0tvQ3t4q1AZlblDVppd7VfVxsQ7Xs4YwPDTd\nnUbaSBvNw7u2q9GHgMMmTYjao3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSNe1WuhsqTIqgc\n+x5T7zcijjxTGzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgVgszPdo+El/hJPAosWRpEHAAr1RYu4Y79/LeY0GhHC8C\nIFR1eH+emR1f+jE4+jv56pbRX4fflRf0Ss/CWm4EkrOk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3577", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3577` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISARCFc6yOk1SQQdIMfN1soSW1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmYTJmN2JlLTIwYmMtNDFhNS04YjdlLTZlNjdjYWRkNzg5MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU5MjI1YzYtNjg1\nYS00NTdjLTg0M2QtM2Q4YTVhODRlODc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo4F4iRLlkEBM+38Uh8cGO07Ha1xHzbqcrEiAckRp4b+IkCijKJFKLwzHBGlG\nJlT2gUXbhCWK34r/sejkCxDOaaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYSQgDFQmeqGbbgR5Qzpdqj4hLAcwHwYDVR0j\nBBgwFoAUZWyRjyAUuFIdxGwjFXBwFivfj7UwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBCehYVcw4PuQcZsFVFbJRh\nsLemJqX60liDYRH4RExN6AIgX8vUzPlJ+4tqNgbaVhQMpPpwYe/hQxZsBCykUE+Y\nklA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbhdPz3ZzNczat/3i/sV0qRaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmEyZjdiZS0yMGJjLTQxYTUtOGI3ZS02ZTY3Y2FkZDc4OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbF5Cbx4nVGz8OoFwByIwoJqib9xFmB7WJ1Pl3eBJsE4ia\nbp4W3N1dYO5EovLKgWfrm4keXqSV60tNoYdT32PJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZWyRjyAUuFIdxGwjFXBwFivf\nj7UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKh6azXY4TsljQmzmYqc8lvV3SBK76f3duTRgFFFMetQCIH3Pfy7NR72i\n0K6tQg6bsRlnKgfhW/S/R/0VDSNm4L25\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAYd6n98//HVXJHCMIB7VKjcSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU5MjI1YzYtNjg1YS00NTdjLTg0M2QtM2Q4YTVhODRlODc3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0N2Y4MDlmOS1hZjE1\nLTQzYjktODM1OS01YmUyNjM2ZWI0MDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASwP2KjYdVd2Y9/EjO9IJCry6asylzp6M/7x+4ctEYdiRxhuB1P4+/4JoGBzZe1\nuqZlDnZmopOgRMi3CVPHtRwso3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRhJCAMVCZ6oZtu\nBHlDOl2qPiEsBzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgV7ZtXNh/aVxIx5KL1Fa28yYptNAqJzovG4XSNw3vx5sC\nIB7zczXEr9ogd8T4fI1u66+QtviFvJS47nxRpHmQRZ86\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3578", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3578` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAUCmElqRzLHHeAWlOAP2urVxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwODU3NGM5LTFkOWEtNDIzOS05MjcwLWMzMzc0MjJkY2VlYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkwYThmNTUtNTVj\nMi00MmRjLWFjODctZTYzYzBmYjc0ZTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErnhBqHqH0FjZGo1lBory/0XOHoIGBWJCYLcEZ93vy4DSUiZXlAcZRBFJ+sQK\n/OWliFxKoAgfLDjZl81DA5ADsaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNdwqlU69X6k9vZQ2OuX44/rDM5UwHwYDVR0j\nBBgwFoAUAkPyLZgRuvDcz73p2WH8ctF4c18wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBMUF6X\nK2TFtRlhIQgb8cBi0uaWe9TYrO2XyX/VHjW2uwIhAKg8NsQ71odyMCdPvQWPOf/y\npxDjlazAMHlRdQ1Zdv+4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV5SMy/sxnqaAYjMqq7UJWSsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDg1NzRjOS0xZDlhLTQyMzktOTI3MC1jMzM3NDIyZGNlZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBNQduIfauxCNzeYlihp0VdAvW2lkAjhsGq8b84pVr3eTo\nXu/F6XAoBrn9rAFraabgHPDsAswVFeKAXBDnvPv0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAkPyLZgRuvDcz73p2WH8ctF4\nc18wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI8GGneWD8dEuYj6vgyjrr2/Q+JG9HvWM6T0p7dU5wz2AiA+W8YINdAf\nA0crOl9l1+XAMoDUPf1fSfbo/W7x12VnHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAb++l5zz/Eh8V1syTHho2BteMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkwYThmNTUtNTVjMi00MmRjLWFjODctZTYzYzBmYjc0ZTc4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NjlmMDNlNi02YjUz\nLTQ3MjgtYjFmYy01MGFhZGY3MjBhZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS9xsGi2BFQHTZy1r3lVfUwLH1mhrXDCufQCWbPuRgvGE0K2DCWNDvz1YjKNfIp\nrQ5IEiQB4InyUeaZF1Fo/8dBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ13CqVTr1fqT29\nlDY65fjj+sMzlTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAPFjnly3UxBG0VrZ/FQAyx6ro/zMyGyHZi2Li+Uj70uA\nAiEA/qzDCTySa9+tVolS/H2/pBwcXT9A7zvda+BgALm4LWI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3579", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3579` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAUmXgNksy8gHtr44rUb9WumYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3Yzk3NGU4LTM0ZmMtNDM1MC05NGRmLTYzZmQ5NmJlYmEzMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDdkMGFjMjgtZTk3\nMS00NGZhLWI1YTMtOGU2MDdiOGJhM2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6mah6bLcW1r2QsKhgUl6OzEvCpioMOUgqP0BtBvGzWg4etTTvHPUSird1LWA\nmGLZrwJJdfemgmMn/YsgU6twCKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4k3CARGbhpLtvGNOthxdHjq043IwHwYDVR0j\nBBgwFoAU1qqpeVNXAkg4xOkc9J6l53rXuBAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA9yqJ\nLATLTu26aCRX5Cf0Q4Qi6S3WUGiuUZrdVAfJyR4CIGN9c6e1bi78CEjqOSVcF15v\nDyd1e2gop8C28spy+Xz3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbUChh3XHJRFN+C1hI2PM/KsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2M5NzRlOC0zNGZjLTQzNTAtOTRkZi02M2ZkOTZiZWJhMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQV1zojqdEWyYBhSQvgkfVSbnInyY2bB9o6DQ272A/ZUeqr\n+q6I0Vc1KxSr15J9jwv2y9LHuJJhmpAbsDrab2eSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1qqpeVNXAkg4xOkc9J6l53rX\nuBAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKL0oNYAaehZKqSZIzyhfOR7id+UmMT7Ryi1Bd6i3jeXAiEAhPUxpapO\nX5bUz3H/CUcSbQqso9sKjpzBr+oq2pQX9Pc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAVMsm7H63MknoPugy6fS50W6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDdkMGFjMjgtZTk3MS00NGZhLWI1YTMtOGU2MDdiOGJhM2NhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NjQ4YmYxZC0xMzRk\nLTQzOTctODlkMy0xMzU4MTdlYjM0MWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ2o2lhGlO5XPyCWKuRw36U5Fgu5TmPrvma3Sz50jrWUQs1SoSnm2ngDPOCp/i5\n3a4C8K8oIfUePZ2tREECWJ/oo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTiTcIBEZuGku28\nY062HF0eOrTjcjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgV/JJ1BOGsI8Ef5eW/H0ZsFkY2tml4LruC/nWhoxOO1AC\nIEhru7SCJ7PpaUsX6UriCUOzHmFbm9lIx+86Rp/3SlUz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3580", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3580` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISASiA6dt5Gh9ibwNVWtNE3SWyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4YjNmN2FiLTg3ZjItNDlkMC1hYTFmLTM2YmM2ZDU4MTAxYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWUyNzhmZmQtYjk4\nYy00MjRlLWExOTYtNGM1MzNjOTcxYWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpYq2xdy31V08WrmnXeZUOWIKMivEEWwA30iq44GUZEG+vfQi9J4LPmsWpBJa\nc0mKOI7vP6kLWgLl00l0Uy5M2KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKj6RU0nbuDfALnkz/YYh42DW28gMB8GA1UdIwQY\nMBaAFNFxr0E34NRGWWZcPVBUDv78Lab2MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAx4wDy0cydMvUNpSLyugDG5Vo+uXiK+vQ\nbSEW2uljLUsCIQCQ8Xud+JpPBrziV8Q5mBZaXjbjgXoC6hhGRR+aD9MpGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbsNKk0fLHXQGmau/Bv9gZ8HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGIzZjdhYi04N2YyLTQ5ZDAtYWExZi0zNmJjNmQ1ODEwMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2zCak6Uesg6OAez0UC8u3miDP94QHstnInEVUb5C2Ug+j\nT4rqbxSMlj0b5cAyqsxWDcyRqPidbvwC/HfOuJ9io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0XGvQTfg1EZZZlw9UFQO/vwt\npvYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOKW1M5GxNYLvLTQuK55r7gSYiqAkRRxYTKiA+/5qVewCIFsXpUt920Z+\n34W97dO3FlTzDqlULJGmrB3qruiO0d2h\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAcYZsrO8ppuzd1MpG1RFDfR1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWUyNzhmZmQtYjk4Yy00MjRlLWExOTYtNGM1MzNjOTcxYWEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1OWJiODE4ZC1hNWZi\nLTQyOWItOWVlZC01NDk2MjQ1ZDljNjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT+2fNYCKo7W9DDnp4G2sg0kYszTJDOLC9491J/eTQmO+8HO4u+f2gfHePCD3Ib\nN/AtxwphqyxIAsRXJ/pWB60qo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSo+kVNJ27g3wC5\n5M/2GIeNg1tvIDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgK7M4Eyb4PqNo3iEe/zPfNQjb3GaC0OFX7tAQMe67uCYC\nIDYi9Zb/Sdf3eCY00Z0nPnB8IJ8h/5mQxOrvlIsb06aA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3581", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3581` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVllxeUyB6ayVs88PSMk6MYcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZDNjMmQ1LWNhY2YtNDU3Yy1hMTc1LWE5OTkzMDFmOGM1ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY0MWU1MTMtNmY4\nMS00N2NiLThmOTQtOThmOGUzMDA1NDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXkCyGaOsXG3gjG4zovztsnip1WhBARDWXo/d2HIb2AGkGqbRb+ceDh+sfDaU\n3yZ56gBafGEMT1NRmQmdnWnG6KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv3juy+MkhGvxPJHW/YtnF/XcMF8wHwYDVR0j\nBBgwFoAUmIl40T3B1XV3/60nnvKS0sHkTEgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgMrN+UYgP241Y\nO2QYUagqNnWhUuQJvetKIODgjgTqRG8CIQDm7rwTbH8G25O+lV1rUAqoc/XDnCQw\nA/3UQNIqpTvpNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATgM/FJrBVLynDxCvD6CApNJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmQzYzJkNS1jYWNmLTQ1N2MtYTE3NS1hOTk5MzAxZjhjNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRSUOaqbV/ZG41Ay5DjaALWtuTj3Mdqg2RLSvcc+ytKzTI\nln+Xs4J8V+teELdG4vHd5syCSt7HKJ26VPyruv60o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmIl40T3B1XV3/60nnvKS0sHk\nTEgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbU7HTHZst10huAPgULF6Q7vCyzU73hrFuKwlNXnQPCMCID0oF6rYwyuL\nfLpI1is3OvV4F2CMgjeAXjahNrnkOhSO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAczI5MBcl7V3CfARfUUUmrd1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY0MWU1MTMtNmY4MS00N2NiLThmOTQtOThmOGUzMDA1NDdlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMjlkZTUwMS00YmVj\nLTQ3ZDMtODFjZS1kMDllMzVkNmRiYTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ9DtOVDllJfeKoE9P5+bxfVGVQ0G4bi1blzSGv6lLnLzRPdbiQ9T64g4QqSwZu\n53x2R8lFkVh/JDXn5VT44C0Ho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS/eO7L4ySEa/E8\nkdb9i2cX9dwwXzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAPFpgqSrVKMVZup5GlDSi767M1OOsHI4wk2M4wBqKTSU\nAiEAhmraurNiAoDayxJQmUTRG8m7/Y1DM0gZM4uVUQyt10k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3582", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3582` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISASpvmFoOmmPVufKalQ47WEdVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYzliYjMxLTQxMTktNGM5Zi1hNzE3LTk3MTFiMmVhZTE1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVkNGVlZGMtMmI1\nNi00Y2YxLWI3MjEtZjIwYjNmYmI5YTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3S9EVR6emcKMs4XoBMenw6H9/yFJLwmvRWON/m2gFcnP3FAOgbsqIBL/ufIQ\nN2u0zDb+j57bKY5+ujS/Py4+1qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrZccQ/etZT3ICaGQkglBVhKE4IQwHwYDVR0j\nBBgwFoAUuXf7T1QEo/gAK/XsTBxbEYjSIxYwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIZ9OF2nDfGE\nUWQlt/4aUDgTSRXTQOgjo2l7rHrRk5WOAiEAlIfKSIIsFz/EP4OqmEoQLpntM8VH\nM3bIORPhPOnQuPo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbc40PgX16mEI/ualn1er8ThMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2M5YmIzMS00MTE5LTRjOWYtYTcxNy05NzExYjJlYWUxNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNpk8ztqejZYkcBDtXyvuqNkD3G1i5Aeu5FCN7ICKKJlcv\nVus/su62ZZlW5elfxaG+dk+gcWw8mxQYuGi2Jy95o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuXf7T1QEo/gAK/XsTBxbEYjS\nIxYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMcMC1z/HA61BbR5xXsM+l83KFQQGUg5UDMBqVNKmtUKAiEAhIkYbzD/\nea+5yTc06pQV2KAkHK6tccrxEkmjE8muG5g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAc74nFm7YIXn4/ImCxLS/FveMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVkNGVlZGMtMmI1Ni00Y2YxLWI3MjEtZjIwYjNmYmI5YTUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MTU2ZDA4OS04ZDA5\nLTRmODUtYTJlZC00ODNhYjE4ODEyOTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASMmxPvklGtpjVlbeGRuYaH0eZ+SH3emo91qw+pa7e7xQZRoF4fIaxkwxzVRXfo\newOY1IsI0F/Qa5zsQL6fg1mno3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBStlxxD961lPcgJ\noZCSCUFWEoTghDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAM+Kq0tCjTLL5/2IfMY6pLhAqjuzFIu+keeLfyywrNI2\nAiEA4bTysfk9KrcPbqKDJ4eEVW7Zstj3iFa0P95fPqnxYzo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3583", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3583` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAV7tR+Mu1Oh6wbpC7e4Ra1nsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkYTEyMGFkLWRlYmQtNDA5Mi04ODY5LTlmODkwYjJmOWRhYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM0N2Q4YWItNzg3\nZC00MmJhLTkxZDQtNThjNjliOTMwYWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIvUZCulNfRROiRyF6T8x3sY8+Xl9v01LSw1CvVsfZTVlpDdE2lbUGtdvaXJb\nAtMUu3h9gRzIhS/6bAfY6Z2LwaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBlhly8VqaCh2CqdMBggGXVoEvXkwHwYDVR0j\nBBgwFoAUTC1Q4tLAMosdiVuNiG9KdP8MF3gwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICG+LSB7KDql\nKuNvuQtOsyOhnIjVmiRKsuZdoUWx00tmAiEAlVt3F8y3rNMPw0PqksA7Hi5Dxl6F\nFsHWR+/HdSy3MRk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfVo2xW/jYXYVrUQr8cyqe4OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGExMjBhZC1kZWJkLTQwOTItODg2OS05Zjg5MGIyZjlkYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfrRwXhtORWl+YXDOVONrcPcYNcy07huCOankjunCVEVU1\nMBjqTM+II7uZ2gMkg05S1Bcje3S0UQjhCraCA/sdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTC1Q4tLAMosdiVuNiG9KdP8M\nF3gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL+aAxNXMXJGRyH5OrymSRxqjfu4R1fSGDzUtERwQZJUAiEAitzguPQR\nTFwYOlwOiEP6/ujFjhFVstmmkq5YJqm1VQs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAR5mWT9i5aRVfUKM9h7rPXN5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM0N2Q4YWItNzg3ZC00MmJhLTkxZDQtNThjNjliOTMwYWQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MzUxYmY5OS02Mjlj\nLTRmZWItODA3ZC1hYzk5ODM4MjhkYjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASLsZbzaXFpjJ+HF2mZ15WFJJj+G9/BnmeSqLsK8rOs+/PzWLJPJunp9XpTTbzW\nVPTDYcnh3eZha9I07C47WUh+o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQGWGXLxWpoKHYK\np0wGCAZdWgS9eTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAN9P1jyIT3M1ovbw1qX2ng1LDpv6/DSUS4s6IwRKBtHD\nAiEAodbMkpr0ndR/Me0fgAFEvK/6W63xt11V4989u4ej1bE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3584", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3584` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfFY1wGZKAHH3DF+/SkwCGCaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiN2EzNGQ3LTUzYmQtNDc4MS1hYWVkLTIxYWE5ODI1NWEzNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODEyMzQ0YmEtMzQ2\nYi00MDg1LWJlYzMtN2Y5ZGRjMTgyNzRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeEWxiWCh8kEW04hANYrwodRL8ZQH5hwGRO1W8w2uKWcP9MGv7VfojrMrsbGU\nON9XzzC1+KFJUhSi6nZsy3jV1qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGRyy/D0QcvM83Wfe4bYmwhoiaOQwHwYDVR0j\nBBgwFoAUpN/SXsGePENkFaisuk/DBnbNN0wwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIH55Z3p+iLqIDLF+e9Is8iQQwrurtPCQCqYJg9ndjsIwAiADswCHPeCd2o2E\nb+pNHg/eBTYCYZsM4GXc44xEsdqDpQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUvwyekFG3uYvnqvU348tnmlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjdhMzRkNy01M2JkLTQ3ODEtYWFlZC0yMWFhOTgyNTVhMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR28F7VVYXW6rkjJ7bC8mkIZSUJwnuHuCaZFEixSWlZUmLf\nBgWKZs5EFK0bFH4+CBLU6i1d/8oRVbO5DF/Lujjuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpN/SXsGePENkFaisuk/DBnbN\nN0wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP6oFTSm446Ifmj1nYf0zX53um9nYaq5InGH8rQb2laECIQDoXBNSIr1R\nkgItMkskr7cPS39L2bf0GpUWepm6oHvF5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAd8djBxkKozOkFedineDY3U9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODEyMzQ0YmEtMzQ2Yi00MDg1LWJlYzMtN2Y5ZGRjMTgyNzRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMDY0NTJkYy1iMGZi\nLTRiYjMtOTAzNi04MDUzYzkxZjdkN2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATY127UVQ/HBpD6AAMf3AiFKsZ4YISbiT4Je6EC+GF3fWeAs97cSMRlvDIn6Diu\nPOudpu/VM8mQ1Qyzbwz9+Jcao3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZHLL8PRBy8zzd\nZ97htibCGiJo5DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgGmL6IKKT7yHhsbJnt96h/KLbIG5C+HYlqbs5plF5kSoC\nIQDlCxORemFTZq9odGDFU67CaS/aniC+MaV25ti3AbByZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3585", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3585` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARNJvRF+HVMWzTnLRV+7EBasMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4ZTgwMjhlLTJjZGQtNGZhMi05MTRmLWY3OGZlZGEwZmFjMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U5YjEyYzktZGE3\nYS00YjJkLThmMmItYjQwMDc2OTU3ZTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVkwSPl096c+xC6MUuofrBHU35oeyumqWmMgAb6MT0hlQHBHvHEciMFwF5CAv\nZ3aLNeaSLIH2aeNwmBGIk8J2eaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh0hWCuxhs22Mun/42Jtsp14jd4QwHwYDVR0j\nBBgwFoAU8bLrhGOiGBZE4Ab+LOYTby7FLr0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCVLAFn4FYoGAAspvJZYIy6n5LSi60y2pj4vP7GJCVK4QIhAKORAVdNE/Y+\n1SloqUPK+qdLMl/nl0w9wSp34iMHcVnV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAftlV5tGOvTbuStbyNJ4VKYNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGU4MDI4ZS0yY2RkLTRmYTItOTE0Zi1mNzhmZWRhMGZhYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqwvl4xm9lJrdUyxWxtD3lUiCTzAIhxIus4iwQ4jLMJIRF\nRaCBI7yLgVPb51i4Yeicga7vdeETvRqWb/yg1ZQJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8bLrhGOiGBZE4Ab+LOYTby7F\nLr0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgI8Smf0Kzn/z7PMC88pEcbcaavLwaIFUxyL01QQHGh3kCIQCJTEznvAY/\n4b5A5DucLWmE3F4WAb3O3Zt9yRMAgA0ljw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATrWVcQryxgJvaCPqLHb/oPDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U5YjEyYzktZGE3YS00YjJkLThmMmItYjQwMDc2OTU3ZTQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNWNkZGZmZi05OGRk\nLTQzNjEtYjJhMi0yMmEzNjAyZDljNGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR4ib0Jz7LkzVsJmRwq6BmZFPdatNV2uiAfi5kd/0srXM/2S1wmMsclPvSF1Cr2\nsgEcoJifvjriCkis4j5B0JNSo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSHSFYK7GGzbYy6\nf/jYm2ynXiN3hDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgL+XhDcsUT6WAzh0A06SivZTsmsAovynML1nvn+0dVo8C\nIQCtKvlvJPWDSRju/t+qhNzRtGRa5jLYzUdq+z9XKyBXJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3586", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3586` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAcowjCaPdZskBxf9wZ/YpuiwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkOTAwY2FhLTAyNGYtNDU5My1hOTJhLTY2NjBjZDJmYzMyYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNjZjA1NGEtODNk\nMy00MjE4LTgwMzAtMDVlNThkNDFiOWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx8PKxhrnS2lsfFi9yE5Dn6KdnxO7nrPiAt9DU9KPl2Zq2r6tqMVn3Z3UabrW\nBP0p7HamZNv81oLGP9XfTC3uRaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPcjBAF3KJH/jGqqlvtcsnve1JpIwHwYDVR0j\nBBgwFoAUeCumr+JS3eirTjfmXXHtYWThGIgwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD6\nTYQugrmeqJBFUGMWR6ctdXkTRFnzqJE9cab/CvOiAwIhAPOWOsEl+qKGhV9zftsJ\nF8HVzjLlRA5ep9ZWgMA89glq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWFVDykrFtMUFUrfS8dmFQxcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDkwMGNhYS0wMjRmLTQ1OTMtYTkyYS02NjYwY2QyZmMzMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUTMranGJsvjVhoiqFUWpAtVgQh/JraHJ9RoKI0P1jIdd1\n7lM+koo1foYs9ElNaMhqkjP0bCaOplFFQEhV4348o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeCumr+JS3eirTjfmXXHtYWTh\nGIgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFhE3PJ69ZvVBpxoJpa8ksxxu2TXH/5L2nJETO5QW23ICIQC8U6YaQ8x3\nMpJgCJ0h9maqaBZZ3ndJnhKegD8Rwq4XYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaOzDda4Y/Pxyjg0TbwFVKosMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNjZjA1NGEtODNkMy00MjE4LTgwMzAtMDVlNThkNDFiOWNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYjMzZTU3Ny03ZGEz\nLTQ5MmMtYjc5MC00ODhiMWJjN2U0NTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATb7x0EgD2Y01Fix1RRYoud/8lLF6Pwy45Sn5XsaVIKz1LWi08xdizUicQ4tSIW\neJH8fYcLek+sR4q4QnRQ+ph2o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9yMEAXcokf+Ma\nqqW+1yye97UmkjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhALlE0fEkyOla25sC2V70CXGDOP1lOLy4m1eHv5PnzUZf\nAiB0uL3i419BLQqAoZgv2qdyIBJ2hu54k5DL9vovkGihqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3587", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3587` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYvoTDyG5nXLYNhcDHwICum/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmOWI0ZmM0LWM1ZDMtNGYxOS1iYzU1LTdlOGJjNzViMTQ2NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2QyMmZmYWMtMmQ0\nZi00OGVhLWJjYjktMThlOTEyYzkxMmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETAKA6Di4AU76IrioH/Huxh9LlHLm5eRMLXShvRargxO9ZrVFpc+zC0da9Uio\nEa4EhgAgj29BaVQugbc5ji0sQ6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUey5rPpvUJPvtXusUH3LuKJ6iTSAwHwYDVR0j\nBBgwFoAUvE9Djf5/GZNr5/CYEcZDvmr0xXMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIAdCvuoYuKegGC/nsmzNFoBWyJco0Nn91fjcaeL85DeJAiEAhRJH\njt5oHp0xGCYp0zUPKCjXxdfV+arveSm9hFrbeoE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfADT/Bv1edyeBLdBYEJNNsvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjliNGZjNC1jNWQzLTRmMTktYmM1NS03ZThiYzc1YjE0NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR137zvhoihhnSnVoj8sP0tGk6znltkFhvh8CTNL1zJ4Rmt\nTkAWuO/J8S5LH48GUgrsmcSm7HqDlA74RtsMclFxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvE9Djf5/GZNr5/CYEcZDvmr0\nxXMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMmvdn+r7Tv1nHaEOK2tSPl3m4ySHIFrec2ASPItIeeyAiByasIH0A9D\n9AAe/hmxXDwSVsyCIXetbU9kgsVlsQdQLQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISASqxlOtLj/Q2LsdZyUTIlutwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2QyMmZmYWMtMmQ0Zi00OGVhLWJjYjktMThlOTEyYzkxMmQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNzNmZWRhNC1lYjcx\nLTRkMTgtOTYyYi03ZThjZTNkM2M3Y2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARjbLWwDuNm4pTcFEYRtj4WiJkGpdITLhHzuwC2ngIzKaFuVMQJZ1NUsNKPRbhW\nxM39WlBeKhoLMS5vxfk4ANRio3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR7Lms+m9Qk++1e\n6xQfcu4onqJNIDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAPMPuLBJokGsBIYgObLIu5L+FoYLT6vpX0aWY0+O8YyL\nAiEAp+4X05z9QX7zQGCzypvPNHaM4wEH7/xzLZjbDVCBFxk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3588", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3588` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAYEba4qMtGGfmEvkqBI/LMMzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwMjE1OGYwLWQxZGYtNDJmZC1iMWNmLTE2NWQzYjhkYmEyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWU1YWUyOWYtZmI3\nMi00M2I1LWFhNTgtMWU5OGE4ZDA4NTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhvT3KFE/eXYKXZ66x/X8t4cZbnSmvAMI+aDn3+7R3+U2GspVxD9hk6ZJjVVI\nEuq0wBwdU3N91S+zDgGYpfGWSKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTc+qINOPuB9yN6wSIhhv+AvFBFwwHwYDVR0j\nBBgwFoAUJWZ28SHlqW3t+baTPQsKWnLGJ/4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC1XfxDW4lpXCTOFJEJnP1Js9YVS5lmE+DExQ6sk94LagIhAN2r\nkQwpGriiI9/HNy6/r+0nDhAboXDyAN+cIVBCVCFz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWCauMukTX7+H6HjbMwLheQaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDIxNThmMC1kMWRmLTQyZmQtYjFjZi0xNjVkM2I4ZGJhMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQGmLLTFei7T280pXEgewCSatasi+6/Uw/WUqy8/XmDm2q\nnzK4QCromxud7vW1QW3iIvtxQodVnic/ZMzOvewfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJWZ28SHlqW3t+baTPQsKWnLG\nJ/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN7aSYGznxMrvnG97C+qCY1yYSQPk503i7RRicaaaY6/AiEAkK3FyZZE\neb8WLXVdVs6uU55Gs2jqdEmNsa0tF+jHMkU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAUDxctAsD0fGe1lnR9KuDWxsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWU1YWUyOWYtZmI3Mi00M2I1LWFhNTgtMWU5OGE4ZDA4NTIyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwODVlM2MzZC04MzQz\nLTQyYWQtYjJjYS04NTQ4NDI1YjY2NzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ8WfAe/K13YQwTkzWSCa0yEL5UnSz2+dvIEIPTLKK66Lck9qQKb1ipUgvicUcL\nkdAh8OfD0w8cOyODl+1OTbvJo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNz6og04+4H3I3\nrBIiGG/4C8UEXDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAMgBRLN5/lQ/yu6gZtbML2jvf11Ulf6r0SDdedK0p3cM\nAiEAthBosh3py0RHRE0QcWPQITTD1aE8P7CqJQg54E25j7M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3589", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3589` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAS7xnHUMPu9GFo7K4C4qtKzWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1ZGQ0OTc4LTlhZDUtNDUzNy1iMTQwLWMzZDk1NWM4OGU1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUxNTExYWItMjM0\nYi00NjFmLTg5NTAtYWMxODVlYzRhYzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5YZVFcjw4zHDv0iaW16TBahwiNjYscjvC+i7oeX8qKSySVwLTbQ4zmSsg+xC\nVscrYtQH0p4kG+cgi2KkjhzSG6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJaShEfa1OdlHtRXqYiwS16dukNUMB8GA1UdIwQY\nMBaAFMF0CPXnFGRrvNaLiinHwdzF3EE1MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA/rdzHqioCcrh9DzLvvC0FWHkhoHF4Ili\nk1juyxm1nBUCIQC50FaeOXXBq/RRm+bqBtUqO9zI70VNl+Mbo75Qv7j42A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUF7Ojn7z+q4kMVUHrCfuytbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWRkNDk3OC05YWQ1LTQ1MzctYjE0MC1jM2Q5NTVjODhlNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT96JEA+xKusthZ4SwlvzNEl8jcWW9ajYFV5nOx6Xymv/Hi\nMvfvblCyRyCcN87FOf9hg9f8RW9MjV33NNuSybQYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwXQI9ecUZGu81ouKKcfB3MXc\nQTUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKD+szsSUrbIAq+hAEQ/c/+pAwe3vwaHn1r0UBHKqPxACIQDIbcDdV/7f\nkaUMwC6XcQhV9kGeaKW9Qmjv78HQTHyNiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdKPKI6aTZyXK1kb4t7Us6hsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUxNTExYWItMjM0Yi00NjFmLTg5NTAtYWMxODVlYzRhYzI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkOGYxMzA4ZS1lMDc0\nLTQyMDUtOGJkMi0xZTQwZmMyZDQ2MGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASA7Srl39TfsHyBPS2YLwrRzcuc36QfrhaxjypSs5b9M0+Je0lQQPBxt0v8R301\ntQwyYqx/QMbyZamiCbGhXcR+o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSWkoRH2tTnZR7U\nV6mIsEtenbpDVDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMEat2dI+GDcssRFBqATr9Zsh0EJyrSNU7LCz27hIv2b\nAiAQ2jIGcpqVv1CfE2x8RfOcCMh56RSQYqsxIAZMZLrc6g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3590", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3590` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAchB+TsIUsajz9UzApvCYW9CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1MjcyOWNmLTI1MDMtNGNmYy05YTg2LTAzMWQ1MjNjZjA1MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q1MGIzY2MtNzgx\nZC00OTk0LTkxM2ItMDY2MGFhODYzMDEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkNCyGr7e/vcnEB0VAamf6Q+YSfR2t5LY7tNpVzzqktifd8MSJMLg90Sy0S6A\neOwSMMHeeJ3GhgjC2L9ngfcxxaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW8ied6nHsR6wPm1cd/0kJY5hgwAwHwYDVR0j\nBBgwFoAUiKngN66Vvn/y4RNE9BcV9ajXWC0wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgJFhLtjF0VTXb\niQv3HvcHcXbcv+/e6FEA4Q0fba99g9sCIEIwtNdl/4SuJ33ACLwTeOnLTCKO2q2P\nEprpMzjfpRkt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXDh2k7vcemnxzDVbIml3UA5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTI3MjljZi0yNTAzLTRjZmMtOWE4Ni0wMzFkNTIzY2YwNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqzxQ48G4Fc1kq5T09zFbsUsXj6N3YHUsGXwZxFDcEqXVD\nHn2TJNJkHUJ90+XbgWz9PhobXrrjRAcGqCl629JQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiKngN66Vvn/y4RNE9BcV9ajX\nWC0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN6PwzicvECUba7n3GK6tXB03tMwMi45aTxBzMcyff3/AiEAiK7CmTpt\nQmRJMOIsbn3tY8lUE2mkAVyPP6xaCav4abQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISARbdDzoDupR5q1h/lS42jUhoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q1MGIzY2MtNzgxZC00OTk0LTkxM2ItMDY2MGFhODYzMDEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYjY3ZGJhOC1jNjlk\nLTRkM2YtYWM4Yi0wMGI2Yjk5ZDNiZTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARs2HqcEbUXNYu3phVwa2lVEkFIIRjw9x8gWKM/sg6eeiNT2zGsvKmRPqg4r8/W\nf2CfvFuw8Cy3wwgcMMmVlv9po3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRbyJ53qcexHrA+\nbVx3/SQljmGDADAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAOhCG9N8Xx94yfzFb28rIfC7yEDFMZ1y/wLLjrPftmBG\nAiEA2pQMlLcQken6xW2KG5z4D9rGz6wCEnzf16ukiMPmMgY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3591", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3591` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISASPhcuhZHZ8DZ+Er3KbveKU/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNmQyMTRjLTJlMGEtNGJiOC1hZjQ1LTJlYWFjNjU0OWU0YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y0ZTY0OGYtYzU5\nMi00Mjc4LTg0Y2YtYmRmZTIxMjU0MjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYIWaabeKp+pRpvOzmhmNpaJhQE0QAW7TDYr0EaCkM0fIOIaidc8WRMEoL0VZ\nZktupMXdIFEvryzpyxR63GlGzaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7tFAqYV/gy1jMGJI/FWR+0aJgOswHwYDVR0j\nBBgwFoAUbAjr5R15284uYlhNEyr1c5HT/KUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgTdQvc37XJAJP\n+IwEwZ5d0aJReoxrNHafjFeBQvmlW2ICIASXk8/ClCWhb9TO15I1kh3252zqIbDH\nkfCdGRjvVj5B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATUeNlL7inqZmDI+csdfCwEqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTZkMjE0Yy0yZTBhLTRiYjgtYWY0NS0yZWFhYzY1NDllNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZ6zZu1HqyTCsvdMqsSXsUgOf7lUsIu0D7PoaEfEeWzldk\nGLljWUDkMyHdZorMqLwv4krucISQ0kSFS7yEy+UFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbAjr5R15284uYlhNEyr1c5HT\n/KUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL8V0dATi5tUUmUVDy/H44AzWEDO4bPLtS0eTwDI80uJAiEA5a5uowI6\nSqqaMUd3HcCq4k2UF8xWTVXTqgWRBd53ZyU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdSgAwIBAgISAZrbdHRzMqQeoJbmHoA/1BPvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y0ZTY0OGYtYzU5Mi00Mjc4LTg0Y2YtYmRmZTIxMjU0MjEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZmFmY2ZmNy0xOTIy\nLTQ4NTctYTNiZS1iNTFkNTBhZTk1YzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARn5gEsKLwd917BKhI/kpVI+dj8cnWIyS4vSvsD9D31bRXRWpu2HF244sQJT1na\n3F4ix/YaDRF+aNgeWj5D8Hnto3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTu0UCphX+DLWMw\nYkj8VZH7RomA6zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRgAwQwIfUjZ6yWw8OZp5SBv6lAKamfCTvYSgfCZu38rkQAxwvgIg\nc/lSDjSEqKgTVIS3/r08niAcWyipnGVY9jXu5WWfTrE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3592", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3592` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdEh3ScB6lJmoIFYMfliHhF5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0NDU0Y2EzLWQ1OTktNDVkMS1hNjNkLTc4ZmE4NDI1NDdkYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBlMTMxNzAtYWE2\nNS00ZmIxLTg0MmYtNDFmYjNkMDc2ZDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJFCaYq3mhOa0TCckt6oLSV+Sc7+kvcHybFI/ssxcI7wpxLMWOgaaFOx3l3u9\niTfQDWk9tq0bZaw/TgkpQ43Gz6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoh61/6615xQfrTnkNIRMr/cxwQAwHwYDVR0j\nBBgwFoAU+lmEFVU/9OQOvr6fvF8D5GccdF4wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHP5NVGKL744\nflSUssnUdOc94kf1DyRGF/VhszbbRbv9AiEAq6UZbew6HfqPywMxJZ4M6FvysfjC\ntBSQUDadtzYOvic=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe3mcCEnYvsBMpc7jbCFy/TBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDQ1NGNhMy1kNTk5LTQ1ZDEtYTYzZC03OGZhODQyNTQ3ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0CyeiXcMOxQDxuAABpw7466nR4vlarYCbg34bscsYdDwP\nLLHbu2EgQKhL9IfvIFbC00X4FDExhJ6JuOQTuLQKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+lmEFVU/9OQOvr6fvF8D5Gcc\ndF4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIc8tZfj3U0SO6r8nCctUnKwjl2eTohGcBuzz4atNBVtAiEA/Yf3RCPO\n2mZb0ZbQmuzShbBBR8PFmx05T/qGGfmq1Uk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQyqqJjWkLOvzxsmhOAka6b8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBlMTMxNzAtYWE2NS00ZmIxLTg0MmYtNDFmYjNkMDc2ZDk4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhY2ZiZTRmMi04YTY0\nLTRjZDctOWJhZS1lOTYwYzMxMDFkMDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARK/jlgh7db6DcBc7qXwVpv6wlZ9uVDpDOk8JrQ0YJXbDA1gL6zDF2S5NAwS13L\nYZwUirtLdo0ZU5fxuAwag61Io3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiHrX/rrXnFB+t\nOeQ0hEyv9zHBADAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAO4oOwtDSF8knooCPIOABbZFSmpYZvFFXz2SEFsbRU4M\nAiBq0CPqEJ2FELj7ZCDAtNqwUH+i8XIxaGIyETCsMOz/QA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3593", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3593` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfyQ4Y61O3e9VVM89Vj9MvmsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5NGI5MTU5LTQ3NDMtNDZmZS04ZDAyLTA4ZGNlMWY1MmVkZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZiYjkxY2YtZTMy\nOS00MzYwLTg0NGUtZWI5OTQzMDlmNGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK3ZH53m/m0NuCBmpKOm2mYuAahB2nH9ioTp0QRfl47WQOncKGVoWQSy37GB4\ni47hprS/x1frP+tefUcq52SpeqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUsZ7GLUx4ReFM6stCzknZUu+BHwwHwYDVR0j\nBBgwFoAUc6QzJQxhhQt25pa/LEoiEqAxGGcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIANiBdTBl3Pdw9Wk8EifnFCXb0shqoyopdbak1NE51rAAiBDzvQYWsOX2TLd\n9Dmy8raikG2alOBBa4H6sBkhRcdMmw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQmXOmqdDpNZ4VCpiR0bYvcuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTRiOTE1OS00NzQzLTQ2ZmUtOGQwMi0wOGRjZTFmNTJlZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwTghVAdGcSg/nKHPaV//H0MYDaRt/ohGKGTWlMbXWGBho\nYdLzCcVHb1gkx428fBeywEQkPuKICoroUYRiLz1Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc6QzJQxhhQt25pa/LEoiEqAx\nGGcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ/xH35zF93im6nofRLkwULpPVQBscZDY++JvbaxLHoMCIQCtj0bPf/sQ\nnDf++CrKLmoK8VDNArwpDi3oIYTIiEgCFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAeLdTS7JDwWzqok7mMK6yVuAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZiYjkxY2YtZTMyOS00MzYwLTg0NGUtZWI5OTQzMDlmNGE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZWUwMDI4NC1hNDMy\nLTQzMGUtOWE2MS1iYWQ4OGEyYzNjYTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQpWkJN3slFYhT2PXVZFnFjjqltR574FrvBgIBtAW+yMERbAlJRvUVZorZkbTvU\nl87TUDf4MRsYZpz6f6HhJGYxo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSxnsYtTHhF4Uz\nqy0LOSdlS74EfDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgQp56Clar/ZxtoSvoHPwW2ZR50MT+WbV7+01DPpeKjXgC\nIGwmCwZIvMefJA2zVe9M2DyL8pOA9CTecr9dai55xuc9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3594", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3594` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXwSFDjGMM6uhRLQgJQPPf1AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1NmQ1NmI2LWExYWEtNDIzMC1hNzQxLTJjNmIyZWY5NTUxNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc3OGQwZTYtNjFm\nMy00NmYzLTk1MDEtMTc2ZWFkYmM1ZWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu6rNRCrRaAP6waTfCUZdq0c8GmOWgdfupdWBZMu5F8iexr4Qn6r4gHrI6XeQ\nrnQVF/TAwEyTOUFStzEb4EmQBKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6PzvHVWhDu2IZ4q6gSnFPJQAKmowHwYDVR0j\nBBgwFoAUu4mQDxfmuN7jMvTfJQ24S88KQiUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCA2u27m+nXH48+hjQWqrJgCQOy+Vc4vqcX1YD1v+FLsAIhAJDj1eeAfYNw\n6mSs0VIGgyx803lSfFbjduU3Atyjbmz1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXQq68yCKSeWwa4GAef7Y3ArMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTZkNTZiNi1hMWFhLTQyMzAtYTc0MS0yYzZiMmVmOTU1MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQidEHAb5D4/LOhnZHLYiKXOBLij6hILnKB6duR13FpGGuV\nnbycmyRW9i7+LnqtE7Wz17cgUBn/JfIDthMi1iw1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu4mQDxfmuN7jMvTfJQ24S88K\nQiUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL7uOQtNbuO8H1vI4F2URIkdADJCAx12XYOlMDwfBKWLAiEAmvKmZ3ir\nsSZEXs7f5E06p5/Lj2EgsA8t6ymuMSJwrcE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAc+O0CKDF91o59QYT3I3F3xqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc3OGQwZTYtNjFmMy00NmYzLTk1MDEtMTc2ZWFkYmM1ZWIyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMGJmOTBlNS02Y2Fm\nLTRhOGItOWM1Mi05MjUzYjBhY2JmN2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASrzmZkMClOnxNGiKL7RT1tf7dXrZ0hPZPSrgnO0UJbHdtLSOUb1aDpir0X1IrS\nJ2d7cIqA2hUCLC1FidVhxVWpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTo/O8dVaEO7Yhn\nirqBKcU8lAAqajAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMVZD/U8ONdR0MWahCkwq/5JNnjTD7fAoB3blLi3gmvI\nAiA2AqvquqVaD8zZyRsP20WezmkqTPHsoFwRviBWx97mZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3595", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3595` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAcILJ77SUgN7hlX2Y69qoRklMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiZjBmMmFmLTA3NDQtNGE5Ny1hODk2LWRlMmJmMmRlZWQ5ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ2MTk2NjAtMDkw\nYi00MDBjLTljYzItODM0MDM5ZmZjOGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEteME2L6TmVMkSseUtvbtKxK3+Qha397wYisH6dS4gP840usBVQRfDdnsewLd\nYOmDLt9iSlOGD8050MAxLo+Vb6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrFs5qKVLXAW4v7yC5jf8Qu4WuScwHwYDVR0j\nBBgwFoAUElj3xqN1AZsmJUtTzglyXVsEkqEwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBe9\nrJNwxupdErORfYtrwrAunHVVjFJNdHBeXxiEOH7bAiEArMgCCzNMcB1FUP5r4d96\nJJzSEfLcv3kKlOBB+3RDpnI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdjNIYigXH5/7VN+dm/sxW/4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmYwZjJhZi0wNzQ0LTRhOTctYTg5Ni1kZTJiZjJkZWVkOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcTKCcMA51NTqcOM9KFxvmKdqw6dVWEDU/d/51g4jm5Tf7\n/mT9oSabBCfOEO9Co0oSw9FGREDKIEEDVW9nIN4xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUElj3xqN1AZsmJUtTzglyXVsE\nkqEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV7kbjj0Gl0dwrPjD8BjFPA5393m57pHwx3FRLWwwtCACIBHDDGeqBjSY\nI3/k/ApRRtxMGChyrcZLvnWiYWgG5PE7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAWg5wp87TJNO9LDBELK2RNkgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ2MTk2NjAtMDkwYi00MDBjLTljYzItODM0MDM5ZmZjOGE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YjNlMmIwNy0wNzAz\nLTQ5YzYtOGQ2OC1jYmMwMjQ1MTM4YjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARrp5VoT+EpuFrMAKi/G0VBxz97m9iHzyt+BajA8azkDgMlMJ3Vx9Cr30a2P7b7\ncS9qvboV7CLV5KsHpCly+DLho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSsWzmopUtcBbi/\nvILmN/xC7ha5JzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAK45n6sGxyzxu344DA+hRkmrscKlc4Ut7588MKgwKar5\nAiEAmgk1FuiS2P4zGcy36EaYhX4ZbswbEM9xqfqT0mGMj8A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3596", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3596` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAfTJB7esRWmuBwni6uG8eKjaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4MGZiNmRlLTkwNjItNDYwNC1iZDFkLTRlZDA2MTBmYWIzMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGY0OWQ1ZDQtNTEw\nNS00NzZmLWE2OTEtMmY3YjgyNjQxYzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP82V03w2owEgXxd4dWcKPbIT+ChflpkLZmUrerBc/1TptEUJajZyS5sNfnEF\nGb9B2WST2n8M0K2Uf3Cc3vosnKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9xw3zscIJcR4qno+SVS+9Ug5/h4wHwYDVR0j\nBBgwFoAUujrq/gJsnQFREbWYp/AT1U/Kg4cwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIGYm4K9lXxwnu2Vw1fNz/r091OpYQ1LK8jSBo1QTwvkRAiEA1TYS\nePR19+HCHMXOsY8uLkjxwWzlOSYAAxD/syOZqsE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAah1xEm/qPHTFvukd7Khf9X6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODBmYjZkZS05MDYyLTQ2MDQtYmQxZC00ZWQwNjEwZmFiMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQffJLhMxIKeZiofKAp1qcAW0+3adCNc8IU8IsZs3fho5pL\nOkwJxtY27I0HANAa5YpNx0AtBzzbTodACzEa7ajDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUujrq/gJsnQFREbWYp/AT1U/K\ng4cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM34C4Z+aNgoo53D+MSsq1DN52++ee0OfwCwmZzGlOJQCID3PlG5QGelp\n3zRFzAhY0A4JVw+I0/4zWOys1LDpdcS1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISATxvMsvzoP42iULGNAXOtpOKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGY0OWQ1ZDQtNTEwNS00NzZmLWE2OTEtMmY3YjgyNjQxYzc4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMTExMWEyYy1iYjlk\nLTQxNGMtYjIxMS1jMzRjZjg4MzlkMDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQjMEjSgZitnuCZNdKFUr3NCzv1SNLb41YL3E1nEqZuHMsH6IG6AAKa/yuz80nz\nTtX35eCe5VhJcE9k9X8wUZh0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3HDfOxwglxHiq\nej5JVL71SDn+HjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKTzEBS/OQ/VlCX/e9lfzzuR9LPqyAGOuvsDGEtWMCuW\nAiEA1olXtnrMFXYDeP4eJZZiu70tdXonav+2UEWSNiOif+Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3597", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3597` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAW892XeOCK07UkWeINPh3JPRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNDNjM2Y4LTVkZjMtNDVmYy04N2U0LWMwNDFmNTEzZjA0NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ5YzYzY2ItMTUy\nNS00ZmY0LTg2NGItOWE1ZDhkYmZhMTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECnQtQz4ZYw32oPHaB5Fmh3aKZICJaqIw3wNl9UpoA2YUQCtak0omtbsBSU41\ni+9+dQwjU8sqBdThnH803aXjSqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSzLZ0EUtHw+GcTphQZlNHyXLTNgwHwYDVR0j\nBBgwFoAUvFr/EFJ7nb67HPcAXu5cVbFoiogwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC+ryXcMvezBJPKE76CksoKoGj/ORD/jXdccHiRB/6K1QIhAI1b\nQp/OTSdjxXgYkxnJap9jGampg66A9SV9ExolVqpu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXBqBw947s8gHhGQisK4erp2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTQzYzNmOC01ZGYzLTQ1ZmMtODdlNC1jMDQxZjUxM2YwNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXMjhITQfwNPdARR21AMWRMUAnE4dz39ggSC/B0gmAGIDx\n/QKLxJJZhGinh0b29Eb4ekAokSTQ8HN8bWQ2sBxSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvFr/EFJ7nb67HPcAXu5cVbFo\niogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIJ4q9ExJXSj4QX5NuBueh08YhR32EeeWah/qiNSyXHZAiB1OgV8g8IN\nMxxnfnXetJ/GebqZoAOtzThUKvMHJbdfAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASJQkHZY5uRXyRUk0FCCiGRtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ5YzYzY2ItMTUyNS00ZmY0LTg2NGItOWE1ZDhkYmZhMTViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZjFkMDRjMC1lZWY2\nLTRiMTktODExYi1lZGY3ZjIxN2FmYzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARcOWy0jc7GNYUJjGwJ3jFuFhFr3rSWDC34rmH02rQU1rAIcZ6N99OpHMG13ixu\nGvugTCbxGwNuPJl0cfPUVYNVo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRLMtnQRS0fD4Zx\nOmFBmU0fJctM2DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAPv6XMKhhYg0wSM2IhH5i6i6UWtD8Rnp55Tq3oxh4F2c\nAiAL2Lxk/r21aa0r7vDicBU9dCVH2w/unD5I1kbzVOQ0/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3598", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3598` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAa+4VWFa4YYWuQG9vsfKz1ohMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2MGNlZjc5LWQxNWItNDJjMC1hYzYxLTM3ZTMxYTc4MDAzYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA1NGJhYjItMjhh\nNC00MWMxLWIwYmMtNDkzZWIwZmMyZTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAL5EydpGXcg/Hm8Bfbl2JIK9lg14ozDc8WkFlCz+6L5+8PLTF/XPbvpaZAmx\nWF4aCHrqXiGxDyNYvc54xA2A+qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTQC1HD72P/Xg8EICF8VguoiDShwTAfBgNVHSME\nGDAWgBSK2SGNH2ggoid69Ni3PlDxFwuLZjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC33xS/fRS3N6ggvEHlt/9NAenCgvsB\nNgqBpD2SWvn5qQIhAOC4/pf+kBtIdMMny4Y1a4WlGx8641X0/i2Ke/yRBe0o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUf3RPcpfj1i7+vSxW/NFskDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjBjZWY3OS1kMTViLTQyYzAtYWM2MS0zN2UzMWE3ODAwM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhDMaoUYeMhExxxR6MbeSfrzMmnxdtk5CYbdodINDW7R06\nsNVrSylXRn3RNyWGwIMNC8HQEycefE1RQlp7+1B/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUitkhjR9oIKInevTYtz5Q8RcL\ni2YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPWhfl2BnUS1rwdrNQWPPDaAynlnQx4s+EucboTuFPZvAiEA1tn4U88W\nvwYY+QXCMBnyitdGAcMWZrGLiic1WMlsIx4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAdb6UDnJP6xGdMXoed1T+ME7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA1NGJhYjItMjhhNC00MWMxLWIwYmMtNDkzZWIwZmMyZTUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMmIzYjI1MC1kMjJj\nLTQxOGUtOTI3Mi0yZDNlZmY0MzkzZDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARUagiErWEIXL8VUlpA88Vu0thUGb9wlWkcFCfTS4wjSN6mwPf6W9/KEqO5Dt2T\niwXCpdqwY41JPJbX1jhDxhbwo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQC1HD72P/Xg8E\nICF8VguoiDShwTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIga39N5Q1w+nKrEOCCG3WuRLRWUIPnvSQTFcovn1MOEt4C\nIGSWXOxKRPkCHPnWiDzcPKqZ/xRRphwe1nfZ/4GEycyQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3599", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3599` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATVQBYURGb3jVbUmO5GKzRTCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5ODY4YWQwLThjNjYtNDFhNC1hMjY0LTJhMDljMDk0YzcwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYwY2UxMDAtNTMz\nZi00YjE0LTkzNGItMjcxZjI2Y2Q3ZDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERJgtHrw9gziQMHAUHHEcXfyvSQvZFFo93SdeKH+0aZaFDMMvP+of+7PS/EGh\naW1Ozgpe1Ne+iRnop4TpUatuDKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOH9ExhraQA7AmHlPnC6v1C63NkQwHwYDVR0j\nBBgwFoAUcOk5XxbOrFk7E82ehpZWno9Po5YwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDct5mkZ3p0\na0cLS5ZBp2ABQxRMNSh3E5kWGMPcaVnS/gIhAMsZ+IC9h9J45GcXNfWr7BjmAC6w\n9MLn5/MTJhTAEIJw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVE5yBx1RaJBPcGl/PUnrhQzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTg2OGFkMC04YzY2LTQxYTQtYTI2NC0yYTA5YzA5NGM3MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq6ssQfrgRkkR701Iks1gfMt02/kblDvMijvR/PH51aHRc\ndJ3fMSPqB19wikBq8pBgzHGZ37bHwisSYjjPdh3fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcOk5XxbOrFk7E82ehpZWno9P\no5YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP6CyG6j/QXBv/Qz60tkvhnxbS6PFTsNmn2QzHWTs1a2AiEA+vpiKyjO\nuJS2/sLXX3R0Wj4tyYDHlMQTmmY74+jGhlQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAeo1DPmfL7an1UPbeNZmditCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYwY2UxMDAtNTMzZi00YjE0LTkzNGItMjcxZjI2Y2Q3ZDMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxY2E2ZmY5MC04NDFh\nLTQwOWEtYjNiMi1kMjE3M2VkMWUxMDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATArKGT7+XYM85F64RGHtk9olcAy59wR8jlacY4Gp2vyLyAaK51Y3M/jpPM5a8V\nigPU40GEfTZseLQMAHDawpgPo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4f0TGGtpADsCY\neU+cLq/ULrc2RDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgYVT7AoJQOlO57T4cAT4oWkEtTlhk5cfBvPhmWd8ALvQC\nIB6/PA/UgHbmEkJSnMMXGfhcBaOX+Q481tuQmpz2Qwts\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3600", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3600` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAUXbaHULa8vqxOtPYKzQt4tvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjOWI1NzdiLWI2NTQtNDY4Yi1iNDdkLTkxNWIzMWY1ZWM5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhhMzJmMDEtMTFk\nNS00NTNiLWFjNWQtZTZmMzgwYjhmMGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc+R942Z0YsA3WHB3OqFZITMI3FqezZSxUyd5Hh9QmJXB0j2v0zUBQws+/6F2\nInZC6E/vd0SUIQLEufV7akBiIKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU65Z/dDy0dH4hhkCuHfpMK5YhkrEwHwYDVR0j\nBBgwFoAUQQM3cp+OJXn7aVK7NZOs89KgjZQwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCdtsiaM+am\nqz7nCgPkDn4MAkw4B2EaVEm5FG1M84h3IgIhAJvWf2yscXn/HO6HF1WgV+8KwIGz\nar7Ix1TL18Nl/igM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQvq8oIUk8P35sD1vu1FZ8DDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzliNTc3Yi1iNjU0LTQ2OGItYjQ3ZC05MTViMzFmNWVjOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBuTz5mPtKRYkq6h7WNPiHPngjQfCSB3KeRC4PkIwMS04v\n4BsEXp1uxrEM7NgAqy4/EwwZ8mu0UY8Lheuzs2S8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQQM3cp+OJXn7aVK7NZOs89Kg\njZQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMXQnM+JHAOvPoMK9RitrfxXqNa2gD+i8yH9WpATrZt9AiEA4whxupTx\nEqfu4+1zQBKDfilhh5s57T6X3GkY/nvZ9MU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZyvmTyYFTboymVAcC57zOoAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhhMzJmMDEtMTFkNS00NTNiLWFjNWQtZTZmMzgwYjhmMGUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NjllOTI0NS1mOGMx\nLTQwMzktODYxNy1mY2RlNmE4MjFjN2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARe4gt/zceBW3IQ0hgX4KO9J7uUFrS7qq/WwPjfsTOOm+iuKoJtqWBXqZVl2NrQ\nqwgyNTYV9GFvoLwnrMvOBIggo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTrln90PLR0fiGG\nQK4d+kwrliGSsTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAMpq2kkQfRQX/k0L5krxueRxZfLqEgwXj58IK8lHS3Kl\nAiEA3F5plv6XHBIUs9+sA/yp+DDu/VxNXVqtlcz4lJK8QGY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3601", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3601` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAeCTcx6VJHKj/VU9R8B1n1qDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0NmNlNDBiLTIzYjMtNDdkNC04ZDFjLTA4M2I5NDU0MjNlZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlkMWRlOWYtYmQw\nNC00MDUwLWIwZjUtNjg0ZWE0NWY3YmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKP63yXy8StXg9VTtVUP3UyOlmtvWBDn3cBlknVNInl7L7dYwCs0GNyLYg8zo\n3xj1gV1P7MC7a0JeLiOvRcU/7qOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdfS1XOUIyG+zpa/kuFY+TASTa8MwHwYDVR0j\nBBgwFoAUkrCvY9ignpAjogl2tvLJ42cJHgowKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiB1+6UAPLZd\n2ZT6nYmoY7JrcAZEvdW5BtjXay8Z7UoxewIhAMcxr8fdMB9zhNuiWIpbaDE26sUF\nZKfBHAbQCONfTLdU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ2WfC5FVNbR8qbQmlvIm593MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDZjZTQwYi0yM2IzLTQ3ZDQtOGQxYy0wODNiOTQ1NDIzZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQT1FI1wrl1zU0lRtblJMQPjSQn7TJXOiUS0txkA14Q/cno\ngz5/frDVRgpU9A/8npuaZ+xeprj2bJxckFG7rrPWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkrCvY9ignpAjogl2tvLJ42cJ\nHgowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAmveNp4w/cgj+QbZ2omboGWVjapS1/MqLWSom6uUnywCIQCAylZ2KwNy\n+6U9IR4DuwlAWQk8iSarZ+5ZahjT5plfcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfXmKIm2xuT8lnXTePySBO2TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlkMWRlOWYtYmQwNC00MDUwLWIwZjUtNjg0ZWE0NWY3YmUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYmU4MDA4OS1mMDdl\nLTQzYTEtOTdiYy00M2Y2OWQ4OGY1N2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT0/VNZEvAUhzCPcLYGoFd5gXwdtSY+NiDGdhTkjpAUFvgYEPKC7YZY0ZgMUYER\nGCfKim7V8O8e8alHTpRdbP5Zo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR19LVc5QjIb7Ol\nr+S4Vj5MBJNrwzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgK84R+JALw5kbL8tuUO+SwwUhsj+vC+w+DKXiJMHx5pwC\nIQCMwdvVlZ7I/Bt7XB9ajYau3mL7rTvDZrsgKWixrbr4Ng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3602", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3602` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISARgqbqzh/x/hrkOL2wQIKI8HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxZjM0ZTVlLWQ3MjgtNDkyNC04ZmY5LWQ5ZWVlZGYwMzU2NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q0N2RiZmYtMTUw\nOC00ZGRmLWI2MzktYWZjMTk4NTEwMTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvR55sMBcvpvVdVY8IOwIwglBwsyXSlh73qVAGXEYdrr+qCRjiP9fykAp1mHx\nKFYFDWCrWp5fo8vp+axp+10a36OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoDnjt6X7LWJCycPIQPUWb3X4hzIwHwYDVR0j\nBBgwFoAUn7Tjt8QRkL8kTJCo/tg7httO9OUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiAXtjvuQzvhLIldI8MBptBLGeQbA2g6qJDzq4/Fs4GeFgIgX2etYSa8S+j/\nYmMw3uLzLmz+jznKFWYnZv0JOddXQCU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWcugTC/cKNBhY6weLJ0cQZqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWYzNGU1ZS1kNzI4LTQ5MjQtOGZmOS1kOWVlZWRmMDM1NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfm18GQTSP5rVnLqkTb2CwMMLfY18t8lRZd1YmrfJe0Dwm\nfyGmZQoRZEhjF/BXpGrif0j8q3jtXSItuhfHt4Zbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn7Tjt8QRkL8kTJCo/tg7httO\n9OUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAODDkTFH70G5IvdfydSMUxcJhiLu4p/Ou+Dx0zJZtXfHAiEAkms5Wq0B\njQ6asUW5zVnNbHeDjQtPVqRtgzmnqhfGyOs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAcqaEAFaQBDpnx/C479aKyZ2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q0N2RiZmYtMTUwOC00ZGRmLWI2MzktYWZjMTk4NTEwMTAzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNDhkZDY0NC0wOWQ3\nLTQxMjgtYTcxMi1iYjIzNWNjY2Y1YjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQIIAsOcaQ8ZNZQz1d4rrVE5IQmP8F33KwdkoNGCB370EASn5jpKZlU1vqlwdwu\nQfGRkTUGlitIWylj/iaXA6rzo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgOeO3pfstYkLJ\nw8hA9RZvdfiHMjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhANMCWivgWgXxq32qInhJyHbTKiCB4Nb2S9s7Y5kvPMVf\nAiBMdnCtNUvoekjKqYNm4Da2izfCKUCNA6QLYs26fJCG1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3603", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3603` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASDx/nm3mwM7AdXx8BuyWgvWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwZGU2ZThkLTk4ZGMtNGEyOC1hNzZjLTgzZWU0ZWQxZjUyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ3YmJkMTYtNWJm\nYS00ZTM0LWE1ZTItNmYzOTkxOTYxMGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX03Cr76gu5tsD1k6gHF4i6WG/Y90xbO9ebZQ0gL+TqTwff5aKLeCsEyAU29W\n5sCYr/pynUye4oHQ3UeB13dJXKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN7G9pnJVc/6NyR9psmasvo+L38wwHwYDVR0j\nBBgwFoAUTJ7aKc2gYZbDUTcTw0362IA5H7AwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAvBpnsguI1Mv5DzhIL8tXy895+iP713H8nW4J9yX8gOkCICBYsukBLfaZ\nRlmz+cP0DRkiDXrjtf3wbBlvF5nayroR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc/CWaU3yOxSj2YoNx5ccSjrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMGRlNmU4ZC05OGRjLTRhMjgtYTc2Yy04M2VlNGVkMWY1MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4M2qpuzMkVmqMTJkKJEgJepj/3XwOAQG7M3CUT9JnkuJi\n9R7i93y3c8+sk5Mnd+ZUliEQmAOdoPU0mlPzZ1l9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTJ7aKc2gYZbDUTcTw0362IA5\nH7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaaWcSvI/dkGKoD7Ei68bTnE8oakmWE5LwmEsl8eLNesCIBPCcRQn0Jl6\n0qZgKkqVFjwaCjxihTf26ezZt90XZ4iG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAaHCWmBVSEyNzVac1n4AOOIqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ3YmJkMTYtNWJmYS00ZTM0LWE1ZTItNmYzOTkxOTYxMGRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYjc2MGQwMC01MzFm\nLTRiYTEtOTg2Zi04MDU4NDVmZjhhODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARpfYMW/9wQZA4NZ+O6cYTVV7gNPVrZ1dQ4sCUH2nbwDG+Euo/Gk64cyxsEgjGn\nHg2Y7KN3AnXsDoCxtxmEXpq3o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3sb2mclVz/o3J\nH2myZqy+j4vfzDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAPynxnanDVBLf7CfctbWyeNDaawgoJMaKZKBomm1zIqE\nAiEA/bgu5D6JB69wq/SjDe8qi7qJwhm2b9SjAfiRhMUO4i8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3604", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3604` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISASruSdRkZil+xpyS5BaTiqNFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1NTk2YmRlLTExZTgtNGFiOS04NDhkLTI2OGVkY2Q3OGI4YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZkMGJlMzAtMTQy\nMy00NmNhLWE4MDUtNGU4ZGIyZjVkYzhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBSskmug33oZ0Gzsfqt1OCtW0S1ftfaI1qeUVrLiKUj8/S3mohy9titO9GgtM\nXUJuYX8GuiA9bYPTYJ2XFCfj+KOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7pJzAhrS4g34co9KauGwcjl/rI4wHwYDVR0j\nBBgwFoAU9hQqITnPpjLTcIs5E2P5ylkkRc4wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBp\nqjZdOzp/s21GblSEam7kDN5CdrzCtzCmiSK1RpQZbgIhAI+n3pfU3AZ9Rpt/7rvD\nA9IsYaiFAIb7d4uthKfDKOtA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQdwZCKIomIqhsJOQp5kvDneMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTU5NmJkZS0xMWU4LTRhYjktODQ4ZC0yNjhlZGNkNzhiOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkQGlN0IYT5pKn28j9OKvdm3vfHZbRaZZlLJEHFeoSwa9G\no0HScFmfTS9f5+3/f4V/+9dPq5eRcO9tHg7TuexEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9hQqITnPpjLTcIs5E2P5ylkk\nRc4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA/LqVHVR9Tu8lNwFMr06cB9R4ZMudwgWZ2vNFW3CTqMCIQCQ4pD12jRu\nEIvCOkiwEvQOaAvj0o2QDpUx6oP82JhPrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAQhB99eiJm0tcOshzXYhgL4XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZkMGJlMzAtMTQyMy00NmNhLWE4MDUtNGU4ZGIyZjVkYzhjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzM2Q1MjVhMS1kNjU5\nLTQ1NWUtYWJhNi02MmE4NDI3NTA2ZmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARRbohYCuF4p3KPiU1KvMKEBCy+x+BKBMrRIj5P4vHMTL7/IT02C2YByJoBONiO\n62CS4mijgtDSSnDOy0CwvoKgo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTuknMCGtLiDfhy\nj0pq4bByOX+sjjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhANpQPfHcatyHBIrHgi/Aa9Ov5XawR/pF5hFd5Xus1Dq2\nAiEAv0De/SpAS+labvsnE3LJW+d+pHQYbUVx3gVTErAOLjU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3605", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3605` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAbWrwdjA6tQHaSN6e3xPVvFRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2OGQ1Y2Q2LWQ4YjctNGU3NC1iZmNlLTc0ZWEyN2VjYTM0ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGM4ZmE5ZjItMWU2\nNi00ODVhLWEyMTctNDAwODA5NmU4MmU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE59Ow62xuQOYyOV03mZUQvmwZ7bXzxvc5/BHXXPqST+KquwtwkES/ub7noxaI\neoQF2dcLnjfxFTqkjnPvxIGulKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCLGtByv6IbAdlXnt/DEZC6KuUIUwHwYDVR0j\nBBgwFoAU0AxdyHnNKxzaE3EZ/X9Ini647vwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiBD2C+JCeUxvdud40JZ1M+qqT5gg3Od8Ineq3/koG9zywIgQF4d\nMdedqhcw0iAJKrdLX7G0UoG9HgRvNYnxl+3Q3Z8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeZ/qVivBA0B3rgLh7ELNddBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjhkNWNkNi1kOGI3LTRlNzQtYmZjZS03NGVhMjdlY2EzNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKZ02yl9NtTtpZcgH8XXwbhANfqZBXrtOibG/Y8tUHdkdJ\n5rTAKAgJmNMullTMgM78JyiPBP3ewef1krkTp3ivo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0AxdyHnNKxzaE3EZ/X9Ini64\n7vwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgb+l+0sZB2yOwGngoE36HkmZS+TICIXmjuNcp7txgip0CICLUVp7FSrUJ\nn1VMKmFpC8GK7f8ZoepmyvpXobkCQviR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYO1OVJwmIyHyo38tBFz2zJKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGM4ZmE5ZjItMWU2Ni00ODVhLWEyMTctNDAwODA5NmU4MmU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMjA3YTA1ZS1jNTg0\nLTQxMDQtOTZkMy0wMTYwNmNlMWVhNmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR2kOZp0TFiuY9nRFrEaWtIj3lDEtLRJpDrNI/9+bNExiJrj3dkNnjw3HY6OrQA\nbAkLW2HWu9UKUpZFZ9dvPIa7o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQIsa0HK/ohsB2V\nee38MRkLoq5QhTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhALs/ay17qC7nLT7SkNO1MoYsm1H3OVdBYzH+V4lKQr+d\nAiBieosj4HBEEsaA5mJO8w76D68HQW0KjJbDUN+IokBJ7g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3606", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3606` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISATtymwQhz/J6muCWnF6fFKAlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ODNiZTRiLTIwOGEtNDdhYy05MTRkLWZjMTgxNzMyMGUyNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJiYzE0ODItOWU4\nZC00NDQzLWE3YTgtMDY2Nzg2ZDI4ZGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElA6A/SG9PV0+7eNQTFGimcZfUZPo1I5EEvkJsLg7LLn7ZLund/k2PYa+5mqk\n00aZ4Bl9maEqcR8YV1OOtFNOUKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFbhoDF2rPHwRU3M94gefdAE5yO8wHwYDVR0j\nBBgwFoAUFARVpndDPFu4RWxSi6BDsR9XpP4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAh1F9V/AMhqZgO7Q0wdMJcE+UjGatlJeqKVPEXZql2sMCIDEG\nLp6IKhHT/5LrUoEL1u/UZob+LTfsth87ZBpBb1EY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATak3gn31A4mCadAu4rJBeiuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzgzYmU0Yi0yMDhhLTQ3YWMtOTE0ZC1mYzE4MTczMjBlMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfE75Jc6AO5SCSANblspPYH62S0ZWTK4OY7Zlowf6YQUcT\nb9RrB8LYgnUHwi7DQOkWHbWVoDO6F6eflcvf+9+ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFARVpndDPFu4RWxSi6BDsR9X\npP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF0Jjwd1BEtc1AxMVY7lynZ+4BqdnWJ2J0yLPx9YLyrECIQCT+JBIif2/\n8zBOZ+kWqyExkU+TqqyiVZiwMDjZDvrdXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISATSL8mTvgiBliT7hwfKVuK7DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJiYzE0ODItOWU4ZC00NDQzLWE3YTgtMDY2Nzg2ZDI4ZGQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMTVjMjRkMS0xNWNj\nLTQwMDEtYTgwMi04OWVkOGUwMGM5YTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATVJVcUZP+aKD+JFzhOPDaUL4XjAXfKoJMzp3diCvJQ58/AXCmRSdL65jEX8LsD\nlFS44SdiuAMyl30RJ+0k+t1Co3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVuGgMXas8fBFT\ncz3iB590ATnI7zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAOe/tozspRYDsuIkK7JqFTPv/ZIlpF7MZuKPSzZ6DQ2W\nAiEA9xCIeVBLlNnsDact/lWvJmVzTEL2elfE3kcLQ4HLyLM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3607", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3607` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISATfe+NIUIRxZa/QO+IRMugUCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyNDc0ZjVkLWMzYTAtNDhmMy1iNzkzLTNmMzk0NzEwZTcyNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmI4ZDI5YjQtMTZk\nNS00MzM1LTk0MTEtNTkyZGZkNmNhYzRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoM7hh/YviLivLs8peYB3NMJd5RYY8lR+CcK1IN0FhfzOfC8nZG/ugOQonxEt\n9w/j1/dgLTRgZ7rUDSlIfKOO3qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1wEMvn4R8sDlRcVbnroiJXELYwAwHwYDVR0j\nBBgwFoAUBKQyVeNz+mTGRBgsD6aWK0MEi4gwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAkrnYnG2V/7Pm\nlc1TvII4pl8u1uOodDYG3WuKZPRRl5MCIQDlgsKge5t5S8RVQRJ8XJlW0RVRIBQm\nuTdj9q4lZ0zmFA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa0zvjI5gpTPvcc3RpcjBSXyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjQ3NGY1ZC1jM2EwLTQ4ZjMtYjc5My0zZjM5NDcxMGU3MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVCz6DKXfHfgjQ1tdkh1irzwL9JfIDKaztcVs6Ib50L+tu\nFcJDYYbBM+2HyUKuQ2gIoRgG/xwCkMb4cKxN2sTko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBKQyVeNz+mTGRBgsD6aWK0ME\ni4gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJtXYjeA8DGbMgB4gF/hk7dSmk8m6kyM090CLDhwe6BrAiAKF1BUOrHi\nzRP2Zi/lItdslAJUyIXsyRyrF+U8K/ymLw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAXQ4zCmywFBpRUgniGMLbQUcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmI4ZDI5YjQtMTZkNS00MzM1LTk0MTEtNTkyZGZkNmNhYzRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OTQ3NzY1MS1iNWYx\nLTQwYTgtYjZjOS0yOTI3NGRjYzQwODkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS5NjiM2VPFylO0UnmJ027fygBMGgK3rlGZPDVelkBtD0sTCXIoV0MHG4+Gswln\n7wQCd/jyPqZ84V8ZJrcR9tt0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXAQy+fhHywOVF\nxVueuiIlcQtjADAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgUvOiKUsXxwdvaI5gariSlsZasQshL/QeB6WdBHNWNpQC\nIFu12yrTCp6i42sXalqyDbGRJ7DL/cJYkBXiZs0LwnDn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3608", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3608` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAaeu63tSs0k9MOK6R6BRRarGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwMGY5ZTBmLWQ3ZTMtNGE0ZC05MzIwLTg0YTIwYzQ4NGQzMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY5OTk3N2EtNjI5\nZC00YzI1LTkzZDYtOWNiNmVjZGU1NmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERr4x4/IeBbV8eqRF7LeSOCBMXUCPyk29teRSJJ5W33FXh4y0ARHIGP5r6mZu\n4Q2Qlw88+YvSnEAGPqLNnb8+AaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYY220DpuDUxYIgRu7zq1Jxm9fzIwHwYDVR0j\nBBgwFoAUlUKqPG2zSSDo4cRLFNX+Z51AF18wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD6xg+MIqCQLazMOjDjl4bQwY38tbQjrr+9oF68HVNDLgIhAJ8lV1IFStNU\n3Q9R3HpWhA4ueRc3Q2CgjBakMYfqXSs/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdWN8Dk79Tm9lbXFHZpjVxtWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMDBmOWUwZi1kN2UzLTRhNGQtOTMyMC04NGEyMGM0ODRkMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR80QK5L9h2+rN9VBSdW3UZVBUAQEjXxA66bWshCnLvIyYw\n31DgaiqEpNpGt87y72Np7W/LB7s4U0bos9TzHw+wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlUKqPG2zSSDo4cRLFNX+Z51A\nF18wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGXwKEuoWQp+B+zpo0HX2Yu120VpZLoy361nO5HM7DNICIGfyuBJEQJX9\nWYEtqoi6hcIFxqfsRfMaDDTSniN0lJoB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISASU6/zIiAj1qL4qHg0hZCeh1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY5OTk3N2EtNjI5ZC00YzI1LTkzZDYtOWNiNmVjZGU1NmY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMjY0YThjMy1hMmQ1\nLTRjOGYtYjQ4Zi1jNzNkNDVmOWFlMjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQJqW5K+e6J+BmpbZqzGPbjvafxx8Fj7yLQ3sWrlLja5Fxpw+SQ1tfkRVfFl4Tw\n4y7wP/v+enR3WVtFYLhJ47B4o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRhjbbQOm4NTFgi\nBG7vOrUnGb1/MjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhALFBVeX3JUMCShSo5PsoOFkIqKM5sBSDTaYv3RCTivNm\nAiEAqPhNaal0pgHnIHTXwsGp32CmNEC+0e2nrT6xxeU6Eck=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3609", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3609` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATAfxEl+Fe8Dee8KsKHe9TWvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmYzVjMGVmLTk2YWEtNDMwOS05OGRmLTIxNDcyNWM0NGI3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE2YzU2OGEtZWY4\nOS00ZWRhLTg0NmEtNDI5NzljMzNhMTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYndpUsOQ9/ovHRBeiuT/eIbEzSXEdQK+BR9XSG3JZhVwJUc5GO6VMOSeYtOZ\nKZJsMI8wp79gAcjkO5suM9EEm6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjW6hFSjT5mTXvGOrDYZXa7lFg1UwHwYDVR0j\nBBgwFoAU0G+tioxde2DiSrQRhvBNWz0EX3kwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDf7wk4WH4vZDlc+ZItsboI+gZmEfeilfX9pSAFJv+Z4wIgR+2o/YdNZJIf\ne7nwZBLG9QGubaBpM/nfwqWAWiIqiWM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAff3CH6n57z0zWgmRmighzZNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmM1YzBlZi05NmFhLTQzMDktOThkZi0yMTQ3MjVjNDRiNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfGbo5D2zahx0PrdlJcZibyLtHBBNxhZm1KRh3Tey3nd3U\nG7SNtAIu8CX5BRqoQQ7aj0MjEhJzC3Lee7H9iBY+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0G+tioxde2DiSrQRhvBNWz0E\nX3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPgsbDsX4nd4Q0veEa4JQZ9bMviN2hk1+e0QrZ9qdf/6AiEAi6SWFfE0\nqJMu5GbN53R9yT8/3yJbC+iRTXtRZiTGLdg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAbeI3+OOAKknORUvPF+r5xCSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE2YzU2OGEtZWY4OS00ZWRhLTg0NmEtNDI5NzljMzNhMTliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlOWU3ZDIzYy1mOWVm\nLTRhOGMtYmRiNC0xNjJmOGI1NzAyZjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAToM++FD7ENIlJoYGqg0NTIljbPfYRaNT9Hzn8d4XKa/vtCQrNXY6CcwU16b95Z\nKORO7HVJnPvpK+M+UF9/VqYwo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSNbqEVKNPmZNe8\nY6sNhldruUWDVTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKtWBj/zW9TfIFxsPF4jbEuav+GhfRWxeSrmmX9+p5L6\nAiEA2WdyyyWJQ19vvPw9TpUBKl5JlmTMLOTOUOgqjSwq/A4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3610", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3610` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAR6V16AVTKkx4cKiw//3G0oXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiYWViMGFlLTUzNDUtNGE2ZS1hMjcxLTgyMWE3ODUwMGRlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVkMTkwNjAtZTc5\nNS00NzQ0LWI4NDEtZjM3OTI3MjYyYzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqHCuicmDUGZrE/BWaZsCygGIHg/DEa85yOtATam50yX9nW9jfFKAE3p6Rbuh\nW5ESq5KEozifY79kmYzJVZX906OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP1B2c9Z1szQpEXtp1VQSwxquMOkwHwYDVR0j\nBBgwFoAU+UJI+z9kbPaJE5+mVvnRyp0pPVkwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBjczhBhfiDuc2e0EPfTTLcTY08V1CFuf2jao6TGiJFSAIhAIBPnpNq1eF8\nru/GeIAIrbulkIilcPqw70RudTpJXquq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ4nbU+IHnMTXhg7M2JDuZMCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmFlYjBhZS01MzQ1LTRhNmUtYTI3MS04MjFhNzg1MDBkZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBhNum4G4LTHdCgJTVxYyiouyX9rjVN5lP/FnymaETDV3R\nqPaCyhwVirfAx/X3gHjHYakiXFT/0+F7WmI/vf4xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+UJI+z9kbPaJE5+mVvnRyp0p\nPVkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANso9xIYp/tRGNeacA1Wmzinj5qZJ7abqsuNx6LYUNw1AiEAzrK/xY+4\nDfCflvFNRnMXF+iFYq1vWCvawWyRohulUMs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATWMeiV414RkujF3ze/DgX7jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVkMTkwNjAtZTc5NS00NzQ0LWI4NDEtZjM3OTI3MjYyYzBjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkY2JkYjNiYi01MGVk\nLTQ0NDgtODk4OS03YmY2NmQ4YTVhMzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASuihHhbp4AIiY9LP9vl4/jRdeFhX5Lpb22SO/OEYeqm3OXwSrD+U0afC16v7Bd\n9TpOcpramurIlpZamz4z/4dTo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ/UHZz1nWzNCkR\ne2nVVBLDGq4w6TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgO2Tb6UVvpuCSRpG/b9Oyxdxy7RfwUNmE7bcyDPxSvAgC\nIQDYHYA2rk/bL3NoggZ7r8A9kzZ6KTjEdtjQepH355XyQA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3611", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3611` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISATih3FLCFMLI+pyGSigzC99gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmOTA3YTAyLWIyNDMtNDhiYi1iMjNhLTBmNmU0YWZhNGYyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFmOWFlZTMtOTRh\nMi00NjY2LWE3YzgtYzQwMjdmNDk0YjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUyVrWTJ5xFx3nxjWLJy5GcnakXf+ndAcN8r00rz3+3zMStl6O3ksxED+t2zq\nOc9Br4+s6e+PQVJDYZil3F/cJ6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl1wsz+FalkwP3OtoCq1nfpNJZ04wHwYDVR0j\nBBgwFoAU7y7C6+EIHt7yq4cK35cdyZWRZbgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAv4Rpd/txNYDqVpeweVzT27WV0BLUv1Mqc/VKhaG8\n2ucCIQDedwK0tCT4whzaULzW96mCea8ek4gOC1LsdKE7knos9w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVnKr/OUi7A+RoIg4SBliqrKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjkwN2EwMi1iMjQzLTQ4YmItYjIzYS0wZjZlNGFmYTRmMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLPy3YRKUSqXqGPKM8n4MsgPPhpyxoztM+2UgvTuF6l0Db\n8Y2y/4ZLyGLNqhzR2YN99QKJJHIKkhVXyC/sHQB8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7y7C6+EIHt7yq4cK35cdyZWR\nZbgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOyA7wsnsjpMQerkpouo9g4cITVUfWkij0VDV8YK962UAiAqtFOURoJB\nip2117SYnBolX7ZrBGg32lDt3PzU5RLrOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYrdb9gqnqiQq1PlaXWAhT5uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFmOWFlZTMtOTRhMi00NjY2LWE3YzgtYzQwMjdmNDk0YjRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmM2FiNDhmMi1lM2M4\nLTQ0OWEtYThlNC0xYmUyNWEyNDNiMGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARTls8jjblnzSdt4rfY50ZFcrbf8iwFibFlS3YR2HuZm6bI9kKYJVSysvn1wumP\nREHrDJXYw/U7at/6FRbOLiEGo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSXXCzP4VqWTA/c\n62gKrWd+k0lnTjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgU6+6ZUU9fQByPcDJx6eT4Wv+30w+DSnz+fy1mLyyWXoC\nIQC3N8aZ+XaEIKd3GIIXQQZTMWz47q8+Pu35UbPGX+PfVA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3612", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3612` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAY1HHaWnZ0/QbI8BZNZ3foCzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyODE0ZjFmLTA4N2QtNDU5OC05NDExLTMzZWQyZDU1ZGMxZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDgxMTA0MTUtN2Y1\nZi00NTk4LWIwMWQtNGIzZTE5OWNhOTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHaM3jo9e6V8dMdNpnCk/FmDXbL01n6UGJ9lhc45QYl8oYm3XFlmmLcR4BQEr\n7js5vykm6coG+pRg+QOODsxoM6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMxYQfpqaXIYFpz05iyjGbvbjr+EwHwYDVR0j\nBBgwFoAUnfKDNBXJv40wACPhnbnabhbXduIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAgj1J6GLAn5SxJqLW4CgGFyg9aDab4bXnUdwMBn+N\njJMCIQDxhZuDCMr7sA1djrcU4ZAnj3YnU1E6Ok6ZmD1jUQHrDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcE+fvsNcqV5c8J9PdJeGRlwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjgxNGYxZi0wODdkLTQ1OTgtOTQxMS0zM2VkMmQ1NWRjMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQvBnroH2EWJmuJr+sXYB28nf8ezoJqY+yb/ZaDuz/xwZJ\ncxsXJxUDnbV9cUhWsRXaiBnmUH/fEQmcMUIdef+1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnfKDNBXJv40wACPhnbnabhbX\nduIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNlp35lDejIHTRIIP85eRoBoVQ55F/6G/MEFeF0vyRLcCIQDMUjhZeqS2\nAsOFCj6hSUEN0BBvJVLwnIUbAAg2Hr+0Rg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAesJYVprzl0imdpq4711w2lqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDgxMTA0MTUtN2Y1Zi00NTk4LWIwMWQtNGIzZTE5OWNhOTQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMTRlMDkzMi1mMjFk\nLTRlZDMtYWYzYy1hODdlYzhmMGFkNDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASnM4i1lRlwzkknciNj5WzXXttNRyCs4wRGo0P9w8MyIRbWtqOXskF+85uTDVbS\nBOBM4a93qOiKs0HfOgEhq8Tno3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzFhB+mppchgWn\nPTmLKMZu9uOv4TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgPT9JE+kmdv0y7/qcEsH+Gj/5JqnB/WFGiazetibVVcYC\nIQC0KhiTS4YoEQlN6gnZx6bg4aeMOK6a35f6EK92Wr5gog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3613", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3613` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASH0eBX5Um7xwHL/dZw72jCEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4OGJiMzMzLWVjNzktNDRkMy1iMDlmLWQ4YjM2MTliNGM3NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAyN2EzMmItYzVl\nNi00OWY4LThmOTMtOTVmMTMwNTMwOGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6dP0TC1ODEBA7Z/E1vme7MUWXyBZ+fiWj4rThcVojdC7BNKs8F9LwEjsHGSL\n7LEvUCKDLisFW7ltggkwZ5sVj6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQJR4qNErJ2haF7gzoBFK03TiOFAwHwYDVR0j\nBBgwFoAUbc11xq7Jtfa/G6NSkLIpfCLi5PQwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAxQgx2VWA8x74+P6zqrwEErnyRaSTRAsA6sYnYgAByzQIhAJop\nf7oIBScYtclENf/Y3pRjIoqlZ3/9WQQ9MAz3UEom\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQxjHNoCVc3KgkTqsKPmDEYAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODhiYjMzMy1lYzc5LTQ0ZDMtYjA5Zi1kOGIzNjE5YjRjNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNtqIojzqfts6wnfTupGQJLMF0wxMX7YCGN+1IDkYhevev\nXBxZnl51Q8JNZTnACZHHDIhVDKQg1wfh1Iv1vjmFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbc11xq7Jtfa/G6NSkLIpfCLi\n5PQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANbhT9+I62UoSLmy0zYWVtjwfgENE+howB/eAh5r4tg6AiEA64mygzGL\nvYiZTyrpAN4f49vz6AU++mp/ZET3+65TS/c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATL8aEXKCCY/DaaAQAVoxebgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAyN2EzMmItYzVlNi00OWY4LThmOTMtOTVmMTMwNTMwOGNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1OWVjYjQ5Mi1hZTM0\nLTQwNGEtYWUwOC1jMmJmYjIzNGFmYzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARavg1EJKgKEpfJSI/JOBiigHKbauTDiEyNbI7XzWHcqyJLwXVyxgdGZ8Fq4cA6\nhuNOpcS7kRaWP5+HNRyE37DXo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRAlHio0SsnaFoX\nuDOgEUrTdOI4UDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAImLUhM2l8pDhI0NwkEb8TIDDYE7N/Ww3MOuXCCsyPfv\nAiBi04ibW7c7V7JTZePg7kah/FTZRB90RkCFCqETE5gc9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3614", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3614` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAe3JU/Mj4OYu+K7+LNeQhPxNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyYTdhNzQ1LTc0NDQtNGNkYy1iM2ExLTQ3YTNmMGVhNWQwZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQxNWNlYzEtOTFj\nOC00NTIyLWI0NDUtMjhjZjU1ZTNmNWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUPwvjSOlLZFYPqgMO1qGKeDj7AE3nxNEpm6gILRLIuqfpIk8TpOUVjA7zNoA\nMi9aEYf7BXs7SeEIjpTUkL/pEqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV9u0H61om73/Rvi6OQngtHnuUjMwHwYDVR0j\nBBgwFoAUWxLGaKqedgadryCoU5FNw2hu0n0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3j92gYxMGpRKx51VXMzkdvgkCqoLmv/3\nCIHgLBaZjncCIG2dTtjptaor9yh1e6yNrragOSqszrrIz1LxrYjojKzZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZnRX+X3HGv6augSv18SsxHEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmE3YTc0NS03NDQ0LTRjZGMtYjNhMS00N2EzZjBlYTVkMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7fgOS8h4jytm2knaW5Y8E3dG9UcdETwhDfNlqAF/nqcY8\noYkjX31jJXbobs1jQOoNbqkeloEI8kLEbdGW3yIDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWxLGaKqedgadryCoU5FNw2hu\n0n0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP631PwCdeara1/8voo8ILLT4H0zxcItLOVwsHH+AwqLAiAzsiySMa8Q\nnvPnYBRXSTnhcLr7EwconXUeIjcZypVDVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAeWlqFkGae4WDfd0VwsrjJlzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQxNWNlYzEtOTFjOC00NTIyLWI0NDUtMjhjZjU1ZTNmNWVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZDc5MTVjYy0wNGU4\nLTQ3ODUtOTkyYi1kMzc3YzQ4MzkwMWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATSxm6IWtSMndUswz98JZI2eiypZSvK1ufifCPvQLI2imAF9cmcOe6peiGkj9x0\n1nAqQS9zi8ubEzwtgGCCigV/o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRX27QfrWibvf9G\n+Lo5CeC0ee5SMzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgGgSYgShbb6Uk9/pvSuoJdKSvwK1FHi0sK5s9/2Hjq0cC\nIHOPETUKUyFv/bQMTyvJAIEIl3LflmyWAsBYBrAFtH4C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3615", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3615` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQeM2M9aLT7khGlJYuPbEib+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1NDk2ODRlLTc2OWYtNGM5NC05N2JiLWM2MzMxZDdhYjMwOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI2YzZiMDMtNDE3\nMy00MjlhLWIwMzEtYTgyMDUwNDA4NGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENZR1r92FZ2Pzqb+zAvnvab5GKJakVvlU9C4VbE8nqCMrjKcAhP15niXIuDMn\n8Fciyt/vfD0KWaYEdnQ/hVb3H6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHrVQuHt6r6SdJtFOcFnhDH1ZZ6gwHwYDVR0j\nBBgwFoAU9d3YkFpDA8r3yQTKEtLgtS+UXuMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBF655IlArlG+6tL0tMhhqEEeOBcLqsOvi/\nLUnrxFfCZQIhAMuWDmP2iRNInFmdvQq7RGaAhg/wMpJpCwu8vkwiYogI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVhEbpZuTbZBZpbLV4vwaH5WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTQ5Njg0ZS03NjlmLTRjOTQtOTdiYi1jNjMzMWQ3YWIzMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATloZY6Uo/LIh9nmnsiaucbs2wtoEnCMfYVOwO+Kn2JyQSX\naVyQL/zBkcG9MgfyfNGpGvh2bAj+M+uzvT1NctXdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9d3YkFpDA8r3yQTKEtLgtS+U\nXuMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYxpTdFUI/DfrLtbKyejvFSdzrzBVFrMoGiCTJSxaYiwCIQC+eQmlCnve\nMsXwYXmPdK9ut4qtnF6Q3vFfnXzFgTLV0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVI83FlHMQTtJlGiHMaIfHInMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI2YzZiMDMtNDE3My00MjlhLWIwMzEtYTgyMDUwNDA4NGE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZmExODBmYy0zODI2\nLTRkZDYtODVlYS1lNGQyMjM3YjQ4ZGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQg9cAkgkkcdI67FgMaO3AVdhG1ei+pioB6FB2DKDthVx67od1rphbjJWYOf4H4\n5B1O0KDY8EXYzT0Ok0Kckbvfo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQetVC4e3qvpJ0m\n0U5wWeEMfVlnqDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgVDG/IU5Kr88R9kgUBZiWH2urcaV4E1ymnc6ZtB3agPgC\nIQD33fLKbkd2diLoN31KFMCOm+AeMqy50WRVChN1ktGkvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3616", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3616` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbWetOKWFmVgvt6ga6/ytxXxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NTZiMzRhLTczNGQtNGIyZC05ZDdjLWJjYjBlNmZkMTRlZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI0ZDNjMTItODMy\nZC00YzNhLTgyNzUtMzliOTYyMjMyNDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm2wp29Mb6UHlipaEa4OJgRv/TAX0Jf24BF8WIe0wQohwXnQUpLyu7sm7M6rt\nBxqAutKDX13z8ouRg11h0jH2N6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8sAufY9UKI9dFM6/0vYVLuz+xFEwHwYDVR0j\nBBgwFoAUSeb/Ve5Dt0Obx3m/AQzxLdTF0IowJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAnFhRUJ0cr5hXL\nzIrwZjCp9x0ByLGhpriHztEMyfX1rAIhANFOb7F5fe7pQYy5bzQ6olMUoKti7Hzh\nvx9YdNJL5XXg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc7PDgHPbf/GCEkeGaEk6cgZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjU2YjM0YS03MzRkLTRiMmQtOWQ3Yy1iY2IwZTZmZDE0ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBg7R1nQBK6O5nF7qiN7OmBF8Qp52BAzI/wbguFVs36AKK\nKLiME/DYhwIbYkiY8qTHAgYcPvLoVyM+e03L+chMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSeb/Ve5Dt0Obx3m/AQzxLdTF\n0IowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUDbsc7L9IzFqtVT7LVJBq1qF7UT1eHUYuN+p+d6ZA2sCIQCc53snhCyo\nHx6NsRYQovWbJJoVRSk1XRuV8hYX8jXF2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAbBBYY8pGBV9Qj4zXhvOOhhEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI0ZDNjMTItODMyZC00YzNhLTgyNzUtMzliOTYyMjMyNDYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZTUwYjA5ZS0wYWYz\nLTRmMWUtYTljNS0zYTBkN2E5OTZhMWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT6Ko909BRxu4qe2cEPoDzvgwP48d2EWb916VFLjntqMDGCO/fFObGo8qw8Xr1h\nDJDlB9YanIz0n+6WmecX/0FBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTywC59j1Qoj10U\nzr/S9hUu7P7EUTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAL1PCsRa8abU5/Ad5VT5n05IkuhjwrVyWFPrufvjlkDf\nAiEAqTrUEdQe3Yv/oedvxxuzraTsfediAR2mtu25sspJy28=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3617", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3617` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdmEdv+BGQNha4fXdbbjWlgWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkY2MxNjFlLWRiMzEtNDI4Ni04YTRhLTczYjU3ZjEzMDY3OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNmMDkyMmMtNDE0\nMS00YWQwLTlkMjMtNmViMTY1ZTU4NWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe2vLflqCuY8DpnJ2f7GBlnvcKFQm/ItyW+Qqqi/Z+aZUggFxJDVH1oZlcsh+\nT6bEAuIdH9Hhmn0QFBHdhzyGz6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU70AqiQpTsxlytfgeZyQUmcQI/88wHwYDVR0j\nBBgwFoAUrmlLe8AVsXAyrUHVJP/8J8D6iP8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICrcN0ae2tWTzjaVBGAcCl2dq3BMiYCa3ECZBYaveGHQAiEAqn4io7/PT2oI\n66hi4xMBWWohrBWB04ZmOmOPJxfCDP4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR7nuhrzCc88TAqzpHJyPZpuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGNjMTYxZS1kYjMxLTQyODYtOGE0YS03M2I1N2YxMzA2NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZ1LH4l3qbuCyDASvhDKdEq6Fch2kBQOBoZG+yrjwkTmm8\npj9UD5phrh4HJ/VadfOHZQDK/jNOQRllgSnQSRH+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrmlLe8AVsXAyrUHVJP/8J8D6\niP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDhQwJOYoDgu7M6xcNSIjiiJqtl7WGqCyKoj6fUGNL0oCIFe3lZe/dTy6\nOsBrISQ0RPkPS6mq14U0M3ACswermM0G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAXKk3f2v7IC+HtspbcirRSLzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNmMDkyMmMtNDE0MS00YWQwLTlkMjMtNmViMTY1ZTU4NWJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZWNmMzgxNy02Mjg1\nLTRkODQtOTM3Yy0yNDM1ZDU5NDE0ODYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARVvQYDErM6Zd1Q8Z7FNiP4d4WjdmqK9eEfuo/cKBUE/o/9c1z0NpOE5EprddGe\nxk/+0CaltdQATm4qu3rY9tWOo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvQCqJClOzGXK1\n+B5nJBSZxAj/zzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAN08xCR+Vtp6OUt2waGwhPETXmHdjua53mAgONbmVlnH\nAiEA7O1zjwVKdZJv6vtW6FJLoThzhJueeEoFDwHIO5eRXfM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3618", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3618` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZPHzCNUd5F4/YG2Ut4/A+5uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0OGM4NDc4LTUwMDgtNGUxNC05Y2QyLWU5MDkyODRlZDAzOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY4M2EyNTQtNTUz\nNC00OGMyLTliODUtOTcxYWZjNmFiZGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+99TbVthzQkZRM1ntbzhSEsD6dqJEze0SIg7e82T6Oq7laBMzXnC3Qnlg9qE\nmYjo2pZNs6OAtqHbz9d8ALEMBqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWe+eU7KtYh2iap+PZgZx0m6xRn8wHwYDVR0j\nBBgwFoAURp6QuXCnZvwG3Z/cRYRDQoNjQvcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIH7DYbBWu0s0B5o5TpQRtN55smHVTO3Tllg3SDJhLUIRAiEA6aLgoB3pcgvI\nnkpl5ks22o7ly4X3k4tvlaui5TzaoCI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaIx4A0hm3/ceX7bknG8nXX4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDhjODQ3OC01MDA4LTRlMTQtOWNkMi1lOTA5Mjg0ZWQwMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQb04ZmZbzmvn0GTpcevCdRoJ7BcK96JrdTJdueIvrDz85B\n1/Txbah2/9LwlkLkge8fZM7SGil8zv1YzEph+m9xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURp6QuXCnZvwG3Z/cRYRDQoNj\nQvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIYcA9ClXWjdC8OVkzrOHNRUjmfy/DtigfPoWHRQm7GiAiEAqLI/3cwb\njYNAa+HR3GmO9n8lPGgBxVSq7VQPksSvBhc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAbGtfqYJc2znRpj4iWZE5CMMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY4M2EyNTQtNTUzNC00OGMyLTliODUtOTcxYWZjNmFiZGRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNzk5YTFmNC0zNzJh\nLTRkYmYtODhjMy1jZTI3ZDkwMGE2ZDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASs88ghAtCYWTeVFIFuoKwdDc4ZGEO/dU+iaEitov9EPynpcYjHNPMfhOf1T768\n/5tQYlJ3zXPVcYBGKGJ8M2cqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZ755Tsq1iHaJq\nn49mBnHSbrFGfzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgSbVUtJk+PDTdEHyd22JY3MVm0hpZbz39CRVjThgncloC\nID2DtuvWr0CEC84vcAmiV/fUixTDW2QzOWMwUSSbHM2/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3619", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3619` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAQEIG3RG6ttgY0LjosB0IIzcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmNTk5MTEyLTRiZGYtNGU5OS1hMGEzLWQ1ZDNjNDU3Mjc5ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU0ODQ4ZDItMjc3\nNy00MjJmLWE2MDAtMjdiYjUwYTQxNmM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj06k0q6MSRJLvqXlIhhd1k8WO6TDFidJ+D4N+h4lgajU+jzn55JltUeDw/1J\nK/WTU68vt6isPFx2VFJlvInL/KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTpjaTjXlkg4fRPp2gjh1OpP9c/wwHwYDVR0j\nBBgwFoAUw0vxg7KgbeBuB5OrHQfyKWmv6UswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBjCpXEK4PoB70pENelfndLZVJxEHCjYrrimSzmi7jiggIgNoYYQJslsdfd\nevc6/9lgdn2IMBEu37OQtyqKS8NAoP4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAZlLbHM7a89M3IROdG+wurmrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjU5OTExMi00YmRmLTRlOTktYTBhMy1kNWQzYzQ1NzI3OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKhAlLo4qxp+8pjDXIy4ouHOQgD9c3jNpJ4VhNeCOnJHYJ\nlUraJNnLqTeRBA/4U7yGqLIPBj7avBd/6QikZSg7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw0vxg7KgbeBuB5OrHQfyKWmv\n6UswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIgLLXB9e10z3bpmIfeXKdib8mpy1hHLc8YAHKjvO45cYcCHwbT1IBFRPcM\ngFPTJob9VU8oWJPASciPejKVeZv3Q4A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAVTjNhSszz6V5CEw573xXrcVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU0ODQ4ZDItMjc3Ny00MjJmLWE2MDAtMjdiYjUwYTQxNmM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4MGU1NjUxMS01MmJh\nLTQ2NTYtYTkxZS1kZmI3ZjBmOTk1MjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR+Ije0lEsP5Byn33yiIJeHRrCpPUc+JAq6yDyu4oftb9X0IdmRZSf59PWfDwV+\nrVCDYyyDUzIMYAtTXqN6jcbdo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBROmNpONeWSDh9E\n+naCOHU6k/1z/DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhALI64amF71Z7fXf0gDeKVVzXMYv4tsz9OIpYiRqwMG29\nAiEAtzFfKHSGjBLC4OWxq4dUVkeQmXehRNA82BEpDHaf/bA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3620", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3620` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAUM7xDIcZuEk5KlVhOR+K5bQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmOTJiOGE3LTYyZTMtNDliZS05MmJhLWNkNWZiMTY4NzI5MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzkxODllM2UtZGZh\nYi00ZWM5LTlhMTctYjVkMTViNWY1MTBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtFz8hlNZwZ1GSrIru8jEYSmxFQ9Bz/mMAsIfGAWNGP1/KGJaLOKgQh8MHoe8\nLNnEyRUSSPRKyBC0+km/HvqzPKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVtQ23CcHxScy39MU7wbFpouRVykwHwYDVR0j\nBBgwFoAUwcgrPm3E3VrKVEvBFOWWSoxCY0YwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAd+8BfgqQuRfQVP/bpnn6hO+3QZ1J8NW52VS7myrN2\njQIgItxAlIckp8ldsP7cRjyJrqarbPYiqeWUFgtNwYeo0vM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU0jI8Z1mlj4//YV5/H/2u/9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjkyYjhhNy02MmUzLTQ5YmUtOTJiYS1jZDVmYjE2ODcyOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQUlQtK1KfWCpnks30uxSct6Q0nIbeQK1R4CkHxLvHN+da\n1Q1A5iW8XHa4a9Rqz/nR/EzgpB9C8OOyzcebnR5ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwcgrPm3E3VrKVEvBFOWWSoxC\nY0YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJG3CJcrayOkWCrrgdYlUWszB+q6dtF2eHRGmTvni9s+AiEA5yLfdVsM\nISxuas8/r3UZEiZOufRAwNLfkkrQbEJhnAg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQMVlOdxoUgPOdPnJaTZYdgYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzkxODllM2UtZGZhYi00ZWM5LTlhMTctYjVkMTViNWY1MTBkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZDRmNDA4Zi00Njgz\nLTQ4NTEtOWZmOC03ZTFjOGI2YTgzOGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASGyWLiTAkZ/NQAvmxHvQUUtdR8jXuIBm/jaRt4i/pLZ6lOziwLlSuzK7je6QKA\n6Os+hpOWGVjBNU46+vyEfyF+o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRW1DbcJwfFJzLf\n0xTvBsWmi5FXKTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAK34iO/PocIUw+CGipH5/gr5nkJzIi7BWFv5zLp+48Un\nAiB6x9iiqioL/2qLs1iSAOcMIOl0UW0Wt8VjWAMKPWP8Rg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3621", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3621` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAQBoi5tvZJHfc5SOCAsc1kh8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5MzQzOTcxLTFiNjQtNDBlZS05ZjQ4LTUxZDU3ZTg5MTUxNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIxYzMwOTctNTVh\nMC00NTE5LTk2NGMtYTI1YTJkNTk0NGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8ANwoo5dxH0XA9QGJkDCBhYZpwHzWI1TWFotlOQD5N/gcj47k/4CZ1fSWC/S\nPMb/caUxnms5GXcWugGa66/UF6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTWmzV4FwtNYoJ+Z+7KYSKVLGE1MwHwYDVR0j\nBBgwFoAUVrKz5g90ejOOLypCpeKVnK1bWukwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA5TSpXAJgUqmC5i8hSMs/DpmHY/r8p3Z+PxOQmgXN\njR4CIQDZhZLEIIXJUQ+sBlmwgEyxdmfND+8MWgLBQOiGPTotHg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATE9VSISQdG+YAVBkvf8KXlvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTM0Mzk3MS0xYjY0LTQwZWUtOWY0OC01MWQ1N2U4OTE1MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzf0+LZ8ZSF41sbnZ9zxi/ODerJ1we+J7ij4IQx8E5ac84\njmoy/OjN4hdOf5DMUTkGhFr1uc3iVNe1gmOyt3vTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVrKz5g90ejOOLypCpeKVnK1b\nWukwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIumIH08fcMKGF9e2BMdq9Vk3TRZDJ9f/AfAfg/JLpFCAiEA3HVfECza\nlG3N1kHyYjdWkbXqfKE/sAl2km3alfp0Hlg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASiZkbnudLZOKcX3Br8HYcXfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIxYzMwOTctNTVhMC00NTE5LTk2NGMtYTI1YTJkNTk0NGM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNGZjNWFjOC1mNGQ1\nLTQ1ZTMtOTdmYy1kNTljODc4YWZjNDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQCAJTd6PvY6rkwDIqRopyFN9zxeRCzXRyvO5wTD1MGbds3ERuoJiAUBavfYV4N\n74+piEajg+bHSg/bkNMcMa5Wo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNabNXgXC01ign\n5n7sphIpUsYTUzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMznmJ0b1ZfwqAu8XkNZOR3wo8RFcukyrKHhCniT5o5u\nAiAuJJGtZyIHhjtpYoye6hCT00eXAh5j5Ij06/+vCnzo2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3622", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3622` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAc7lr17IB9zRlk37BObU3uLDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjM2Y2Nzk1LWZjODMtNGE5MC1hYjJkLThjYjRmNTk5MWY4NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFjOWZhZTktNGE2\nYS00MDBjLWI2YzctMzg3MWEyM2I5OTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWEDMMx3JRCmkRLWaf+0pa/uta6IxaDzzxNZ5gOo7f5bS+u1/4cWNZpbsFJV7\nJuss2iXH3XJssGJiKntkIEvXaqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjDFztNLc/15YnM4XsBoCkX9XtTMwHwYDVR0j\nBBgwFoAU7WRKAhwQ/E3O73GH3I3rujS/7e4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBfNEAmuMbm6Sz08TrE7QXNaVDIY0XjFs+QB7/nq5joxwIhAMnU\nwBGlr2z6lo/453cw2v6KlbD3AA2D9Lr038Ah9//D\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbWzaarGPRqnmWt2dKIQo9MwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzNmNjc5NS1mYzgzLTRhOTAtYWIyZC04Y2I0ZjU5OTFmODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7uhrKqVkDI77wCaPJaDNR6hv1my+o+FA21D61RSOJapos\nza/y89SIH9/CzY/mXLKMk3oX/5xLB68gY2yGckmHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7WRKAhwQ/E3O73GH3I3rujS/\n7e4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXKigxmIMSJ66SXG24363nSrsSkbWpp7h5bDupYfEOt0CIGDt3L+Vjfft\na/Ii5G+7IcGcp9IaGE4VIXxqsbqOblKx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARnixArMR/UTF7kLYWico3wVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFjOWZhZTktNGE2YS00MDBjLWI2YzctMzg3MWEyM2I5OTYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNjA3ZWM0YS01MzU4\nLTQ5YmQtYjRlNy01NjhhMWFlMGY0ZWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQPJ/wChTEs0IGfIw48ifpYM2gPI7IihurKR++yVpbqf1IgAJCIudYXunAzDy0T\nydNCcvs/fusr9O8pu+DVgCBUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMMXO00tz/Xlic\nzhewGgKRf1e1MzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgYoHEGC9nJ7XQKoKk5rfI8DpWWu+m0IHYNyvbz84G6kkC\nIQCELqZ/hq2pFxmPNjzqGNjEY8fnfe+QRWDNqfvpCUM0TA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3623", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3623` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAcaGSSBu/Rzt70YSsY5xhd/WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjYTRjOWQ3LTNiOGItNDY1NC1iZjczLTkxNzM4Yjk4ZjVjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I1MDliYmQtZDE3\nYS00MjRkLTk2MTYtNTNhMzliNjVjYTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKZivk+l9sl8RwIcrteX8mxj0dLZ4PkdT4jK474w7bLgfmze4Bau97GkO+SFB\nC09Nl/GdefdbN/8LMI4blZ4JlqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR+Tcwsg45tgPuGMQLyDIB8HRPsEwHwYDVR0j\nBBgwFoAUzDxwrqz7kNZzguLyovnyYH0ofy4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAy+27uve7iJOjA3Ej3AjmNLfVpCo3uSPn\nLjCkns+q8EYCIQD/YRzNRB6nJHylLyi+Wsu+ibt2mp9vfTcfMLXLaD0H9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQuso/ToCmNYoosoWNOQJ9WkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2E0YzlkNy0zYjhiLTQ2NTQtYmY3My05MTczOGI5OGY1YzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaPi/rFkrGySm7SP3j0J/72fdVYoGOrywblWVDPgQzmRqc\noZzUiy8mKs5bDhal0NNACoVtFz1TN62lxQ5EzL37o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzDxwrqz7kNZzguLyovnyYH0o\nfy4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMosycasd9CVVmahwZcXvuqNCr2ov/j7c0GtujIGXoO8CIQCa+wXqQkdg\nGmw34khXMYuTVbabqHlvdXIj4B1ZviwtJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUXfATBDoJ5ROXy42ujRx+3rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I1MDliYmQtZDE3YS00MjRkLTk2MTYtNTNhMzliNjVjYTk0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MGNkZWYzZC04ZjEy\nLTRkMmMtOWRlNy1hZGI1YzNlZWQ5ZDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASIJPo4irYseI1kdAREMDGbm/O5YA1PoW3SkW3NfOXuAte5Y8oGTpVEl25/YkJZ\n+wiGlK6H6P//zvxCv3U41qL6o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRH5NzCyDjm2A+4\nYxAvIMgHwdE+wTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMV+Qt0H9sitP2/IYRnF/3Wv6Ib7HxsL9IdXIyalueXA\nAiAJityFYKzqckB0jCafSJAqypRXW/L2j3WtOwnB9i1iNQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3624", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3624` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVBO21WAvGX+QaGWFboEo3czMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyNWY0YTY1LWJhMjEtNDk0Yi1hZjU2LWMyNDkzN2FhNTc4YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMThmMTgwNDctODk2\nMS00YTNkLTgzNjYtNWMyZjIyODI3ZTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw/1BufQ2nKnksQVm5SQw5421XfFb3sUJt/AWgsIxuYNVE5NQH8STVJqGdRPJ\nNBjqGKwEYHUlq2MZwOJFF0Td/KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvEGmiRIPlgdq83HA6PGCsvofLEgwHwYDVR0j\nBBgwFoAU1RQLs9kPEprX7qPAuERhFhI9xUcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAoUbUVrqQ7ARCrr75PMc/tAzH1fbwZyrh\n45X1iSmC6AMCIBpAlm+v+9PtSblZdIN0EBOrbiYGdZHFq6UaONcJ2xMD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaboa9XCgEV0QLry/juaL3CyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjVmNGE2NS1iYTIxLTQ5NGItYWY1Ni1jMjQ5MzdhYTU3OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtplSvu8aBjlrx2K20HmtjmK6zO+90/4P8Uah5NyHL0z+5\nOg6Y2Oz2kQPHZu28+xg3qUl2cVf7eQqlD/gnEmhso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1RQLs9kPEprX7qPAuERhFhI9\nxUcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPWwTPtmnNFdJx6cRipkBRENPQuBDwxfY/Ppnn3vxqMmAiB/GdEjsn95\na4uIdyX6/sDKAVS0WcjajUymf3ASxsTwaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAVVuwNnpZiX1+SrxOdsxpSLcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMThmMTgwNDctODk2MS00YTNkLTgzNjYtNWMyZjIyODI3ZTc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YWIwYTQxNi0wYWQz\nLTQyZTgtOWZmNi03NDY4YzQ2Mjg2ODIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATHLCYHO9bOUesgs+Ag3ke+rIVBxofDqd4oVXD2ysIkopkYnbgMxMX5xoNl48nP\nEUhmODJ4XtlCLRxvm3KhUVICo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8QaaJEg+WB2rz\nccDo8YKy+h8sSDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgO7rA4YTbO9mJ0EygYJsPviuuTDmNsrtrSSDHTBh+V7gC\nIGjodCqFxRqwnPTkmqe1IBRNDi0Y2+kGRjlXpm0E5/pW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3625", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3625` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISASJUz6UtFvKjMmi6kBBZv1HnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3Y2E1NmU4LWEyMjAtNGVjZi1iOTAzLTFkOGFmNTdkNzg1ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWFhNDE3MjktMWIy\nNy00NDBjLWI4NTQtMGQwYTgyZDczMWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0XTlQRYCDkYaZzEevGMbFkdOAQwJD+hZMH5kPxFhwRvNNJNZqZ4i/yToxbzt\nClEPd+5Pu7OhO/7Zn3ZFRXLVbKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuzY3Qw0cBibdqOM4NvHZ8zT/VJYwHwYDVR0j\nBBgwFoAU3Gl9GVWq447P2rcT10u6o7xTVu0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAQ6/P3g8sTz+qOGwOaRddQQBblB\nKB4qWAmFLD6HnI9tAiBAP4qQMtVVApVvCyHyWhpdfinujjEpreqdMAJuTiGqNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbxrV35dm/47JYAyU+K/jjdDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2NhNTZlOC1hMjIwLTRlY2YtYjkwMy0xZDhhZjU3ZDc4NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQG14GNsq6g6aClypzCQntSsm08n+BmA/MXvHuGB5ow6XBf\newICqImGhaU1tRv6NNZyU/JYZyWdTED4b0k5m+w1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Gl9GVWq447P2rcT10u6o7xT\nVu0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbZQsgTJ3iCg+R3L1lM94s3Hh1LTc/+swTGmmais4864CIQCW5Ifbdc6f\n/conhaqQBowqQqk7Ld8+e2OzweIuXQCCFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAT5U5FSdSZzWyTXvnSJSQpPbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWFhNDE3MjktMWIyNy00NDBjLWI4NTQtMGQwYTgyZDczMWFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNTg4OGQzMC02MTU3\nLTRhZDMtOGNlYi01YTNhYzdkYzM2ZWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ4keI9OK7IZ8uU309UXlZyub5uVr6vjWqnHV6gWoCG1KMXrmoRI2VKMeTDDxAJ\nCbQr/p4V/jVDW0r6L26Uav2Po3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7NjdDDRwGJt2o\n4zg28dnzNP9UljAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhANochdBuuDlcfmSBA6p11eS5XEm5hEb3v/naHvSw/u4i\nAiBDCU67qt56RA+kpvL9WHTgGEyE6LtVGna/bt+YMkNY5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3626", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3626` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAW1a8HbUcgPG5BJob45N91NbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjYTNlN2EwLTBmNzYtNDc3Yi1iYjIzLTMwZWJjMGVmYmM3NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYyODNmNmItY2Jl\nZi00MWY5LTkxNjktMjUzZmFjMjgzNDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElRW6ykDIBa5r2x7YVFFdV4kY8E+JC7Jio0CKEY9o+o8V/LgWyMTZcQHsFX/h\nW+sp7/RqQTOHAM2eEp7qEJeA66OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcTsRMZPUDuEP5h8OkrI1lIbiqiQwHwYDVR0j\nBBgwFoAUJOafQWMRZc8TlldsfvsBgjxqld8wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgd+TnZO3C\n2G7qcCAYoElK7N0jesYug3upXrnarcI7ugkCIQCo8evRMc48m0t8cGpyhCtXlxdg\nRzbFSWIS+DDoACYmeA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQv8XeDGuyMTHJQma8hrFUg7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2EzZTdhMC0wZjc2LTQ3N2ItYmIyMy0zMGViYzBlZmJjNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4dnH+5vGQNE+7P3y8TJ/GZM2fJ2dgGpJbGW+Q5xWH6r1Z\ncTWOdiqvPHR2HFUE83v7z7q/7VOEtdeOUelDg58wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJOafQWMRZc8TlldsfvsBgjxq\nld8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbUtwfZxB/RBoxw+l5FUm6osEFS+Iqn9mQNd26DF44A0CIQDzIKUmp6vy\nxyCaUQ8tc2Qauj2R6DH+1aw2KgJeNDcJxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAasMwmEHlBDEOhW81kNvuhSnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYyODNmNmItY2JlZi00MWY5LTkxNjktMjUzZmFjMjgzNDBhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyOWIzYjc2NC02YTYx\nLTQ2YWUtOTM0My0zZDI3N2I1ZDkzNTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAREjJcBZmGvsZsbxAQ+uR3D6b+AI/rnOtwi+0JFFKjw0pL09s+dgwYpMz+AANbu\nMYgDpNm7abU24KADTCZJjgMqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxOxExk9QO4Q/m\nHw6SsjWUhuKqJDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAOqNsWzDte9vxsQfKjxo0XF7sYIUZwgBcpGR8cdyT1Is\nAiAzBecc9ilh9ICAHgUpb8ZQ5E8lzib294og9wMle+aSdg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3627", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3627` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAciRFS1jns4dzrPRW1UE5fjwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlOGIzZDhmLTQwNjAtNGNmYy1iOTNkLTgzYTkzNDk4OTMwZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IzMjU1OWItNzQy\nNC00NGNjLThiMmQtYTQ4ZWE5YjQ2M2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtjA7mAv0XVFh8o1vtW3auVrqdV7LjeXkdAJJ0qNEQgEYh5UgBL2ctrCt4LAe\n5tU1WNoGXr+Pzi2YGOF3M2R+VqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIJwFZ/mtsbzMW0Vu5S73enZ8X9wwHwYDVR0j\nBBgwFoAU8VRBIt+ZfwSGlZlid1KFnXpijI0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgdOMq0fNb\no+1nXIjGCey4pGBuhOuJzX8XEHectOc3Ut8CIGGWOFBxTMqkpdmcIC8/t2OXKD4J\n/iD1fsmGjfIRGOIV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdvoNpp9HM67E93jYEhJ43NrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZThiM2Q4Zi00MDYwLTRjZmMtYjkzZC04M2E5MzQ5ODkzMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkZR5Dh34s1T7bajVRno1bet1F6XBOadN+e7p92s6DMDpn\nTrRUFBa6EzhI7Vc7L/FhnZadUZZkxFCbZBGNwQFEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8VRBIt+ZfwSGlZlid1KFnXpi\njI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALtZO1+xdhtK1E1BLs0q4LrB1rUfWrlCCvDYj2T/A5BbAiByjwHpH3RP\n7ppjdPqvZe2QNOWomn0YqQAOgUy/7a83uQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATl8JkseddEqRWtMQ4/6jWyvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IzMjU1OWItNzQyNC00NGNjLThiMmQtYTQ4ZWE5YjQ2M2YyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNjIzMWViMi1lYjBk\nLTQzYWQtOTI3Ni04NDgyODFmOWI4NGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ+lPK487/wveFEPdysYmV6TMmaVJzondgE1L16SGVd1qBhngDoGWQ5KTLsRRF3\n+V13mC47JYi7FZ670M6VJbuyo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQgnAVn+a2xvMxb\nRW7lLvd6dnxf3DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJedgyly6hNxMetsm5B6g9+wV8LvPlyCfstLd33OT3HN\nAiAVzJY0jrz3HaJ+9N+tFmS+ZSUmZc3LZ1i9H9jt/NMYYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3628", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3628` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAUnE+/kX4z3Fof87lZx/wPlNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjNDE5ZDVhLTk0NWEtNDVkOS05NmI3LTUzOGI0OTJjZDQwNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NmMTkyYTQtZDA5\nNC00MjgwLTlkY2UtNDNhNzZhZDViM2UwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWAJRMDvjIXku5knVNOJy/KgQeBD8nycPiiRwoeoAQj3jZkWId6l1a6Mu3bft\nBljbw4JYp5QFdwI4+DyAanNDOqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGSjtDhlnDeQPq9u0tZQP4Acb79EwHwYDVR0j\nBBgwFoAUGHSiku/NiWJWmVlieSaarWvEiycwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCEMQc5\nRUYvkJ8h5bYeOBlULUnE14UXUiPq2oQpqO5NvAIhAKtUzTtb1iqdhBrwPWPENd9c\nsAxYN+kfKCRrHYaq27Id\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeOSJfODPtVyedQf/1hwXps1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzQxOWQ1YS05NDVhLTQ1ZDktOTZiNy01MzhiNDkyY2Q0MDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgFvz2v9mPsVwjcNcA9GEWNiNOQNPhM5ttS0RzT04mz5jM\ni+5DZFDenmW9QGItgCYsJCJoviM6zp6a+BzUKtyHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGHSiku/NiWJWmVlieSaarWvE\niycwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN/6JbVywodbVoALdAka0H9npHSzWW0KJQoArhMKBKgKAiEAqMGgtwoY\nAH+RDTgYyDEtV+sEunPABbvWIEen3OlQtE0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfzPmW36E2DYEPEVnVlYotr0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NmMTkyYTQtZDA5NC00MjgwLTlkY2UtNDNhNzZhZDViM2UwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MGYwODQ1My1mNWM2\nLTQ0MmMtYmY2Ni1lZjM0NTYyZTIzMTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASwJfg1NbF31s68bkrZumWJ6C1JUCw9U0O2eLC4FoE9KaeuuoU7cqyLDIwY6Brx\nj0ZjH5BSekq5jYR337BfmZyPo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZKO0OGWcN5A+r\n27S1lA/gBxvv0TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgUg0xTEmOWDH3Ww1D7J63y2xqKnG5Q7Vr49V2fmwU0l0C\nIQDWX39I9b425Bker/s7oPdutDiL2znUY6dfLg+aBAxg0w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3629", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3629` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAVwWSHhd1Pw2y+dJK9c2L829MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZTJiYTFiLWJkZGItNGY4Zi04MDJjLTdiNTY0ZDcxYzg3YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJmODcwODMtMzU1\nOS00NTIxLWEzNTAtZGE0NWE0MDFmNmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEna1UOLo+8IoUwxpXxSTKKhOuePXadfp6kkwPiuf0M65Of8OQKMD3OrTrUX8c\nXlbsL2n/S3s2iiW24PaGdgLUUKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6EVs7FQ4Ug7ipv8EAZssSZAr7VowHwYDVR0j\nBBgwFoAUVaS9b88Pgj+DPkJ7mqYu3xR67LswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDTPFwn4iDzZkMTsKLWuFnQPn58vjKrQ0YmECgyzkwQlgIhAMUtLtbQ\n/0J5NR54KFXLP/v+TiZzmRD1SAe+Ep0bKidJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARwYkjvQ/H0aRSaVVI9/aJtiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmUyYmExYi1iZGRiLTRmOGYtODAyYy03YjU2NGQ3MWM4N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXu2HWnHUyNCEtKHTH4qYEedyM4bSa6Cj/g757B9gaSFH5\ncDrs43gAfBWgkT2zZJ0FSt5CoBCbo8xZaRq2/g/8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVaS9b88Pgj+DPkJ7mqYu3xR6\n7LswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJryqxoWoc8QEpBaMURR9t3WmB09l5B7dWD8kFaiwNOMCIBkWt8hwRJZ5\nKUoahkssAV7Xc5VyIhFvw+GcBhHPnHqU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQSx7DiufmhVeNWxgVWP5g6AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJmODcwODMtMzU1OS00NTIxLWEzNTAtZGE0NWE0MDFmNmU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YWEzNTI5MS0zZDhl\nLTRmZDUtYTcyNy1lNjUwYTJjMDIwNTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQfh/YTN/d7VUUYg/skYY3KPNq2nGTEBbLODFvZZCg4jbo14yunQfYfxNkdCF6l\n/VQkVsUcWUOtwsFpms5/f4Gpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToRWzsVDhSDuKm\n/wQBmyxJkCvtWjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAL0v6qln+yeuPCuCK9XegOQ0pmxVvfjEdlWGXwNatjQd\nAiBPR+i4yY0B4fWjjUWYuZW1dRnTvNY2CguyhYjuckSTug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3630", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3630` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAWRfTx5csOncBjVtbQnF2jUyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzMTgxNjE4LTZiNWEtNGY1Ny1iOWExLTdlYjFmZDlmZjg0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBjN2RmMjgtNWVi\nOC00YzA5LTg4ZDYtYmFiNjZjZDk3ODUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENhVykXhEExpvSI4pBdgk1+D+SxpFiF7WZUYdouiL17riEdzxg9IO5zqgltDm\nn6A+qlMNH36CO0x7dmIbsLokvKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyhj6VTGzhWcF6Q0QblOTdf7ZJkMwHwYDVR0j\nBBgwFoAUXn4fsmV1216mWegTHSt05IO2QwwwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIASmQ7Qzhq1r4lqgxiaXenafwOlKThIDmV9r+p+OPLPvAiBead8qwccv\nl85hBhG/TjsKCtKSWN/gFBMZ/KL1FsBATw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaLKhvZB3CFyzG2rXuDAnLeJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzE4MTYxOC02YjVhLTRmNTctYjlhMS03ZWIxZmQ5ZmY4NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/CiTqYUUa4w7pa1zJuEvCP7+nQVzQ+rEQCFC9hAR0L526\navHLK2y/6KHzd8+mua9GN/0HhIRVl1vuZg43fuaRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXn4fsmV1216mWegTHSt05IO2\nQwwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTYTHaEJNOOCJhyISInVjA954yVZ9Uw1rKwopt8pPSWoCIE7x3bNrE7BS\nW7Etljxr0HmKFHMb7FQA0AyYIOUw/NJ7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVb4djVY7VVaUI3LCwC+SdmpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBjN2RmMjgtNWViOC00YzA5LTg4ZDYtYmFiNjZjZDk3ODUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1Yjk2ZjI4My1hNjA1\nLTRkNjMtYmY3Ni1lNTVlMTE1N2FkZWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARHCiVVyQe+qyv43IQgrtRXe5CZQwYl8UMc32+Kht5a4AC1L1qLFLePFLfmDBlx\n/iqYdyQms073ZmPOt2VkBUISo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKGPpVMbOFZwXp\nDRBuU5N1/tkmQzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJaioWiyA46z3u5jHk7U20HhAg1AcF0wU8fN1oAC+92e\nAiBsr1b1R2mD4a6N1RsVuhD4nYe4JYKi5eUUs1W722iqGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3631", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3631` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISASJwfSVDwpBzZv1hzF6ov8tiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1OTRkOWVkLTgwYjEtNDRhZS1hMWUxLTViMWMxNDA3NDNmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg4OWZhZmUtMjg5\nYS00ZWY2LWE0ZGEtY2E5ZWY5MzFhYmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm/jNF+aP3B+iMelZN8k4+Yv41q2dPLagY33Jxv1mmuidYZEBbg6mrHx6//+C\n8/ejC5Ue3fXyAx+9bS6kEHP/iaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmm3sDCUQ1wgTSSdGCHXg6BOEXRswHwYDVR0j\nBBgwFoAUkK1KgfYiPuyAtrf3+GJV4ZikbWMwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIDXDkKiRKaQvqXBlIpFl6BzYLJpAhoBG7SQrL4HTyWRUAiEAsrTbqvIUOgg1O3RE\n3iAqwJUedqz5z98BNcjNBqPm2BQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVmj6eL5Dq+Uu/QAxCgIIQfGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTk0ZDllZC04MGIxLTQ0YWUtYTFlMS01YjFjMTQwNzQzZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaBDtp352iyVCYnM33ui8xM9WRmBJtBZujdIyFHkbDNHHb\ntU5/6PMFywONmn84JLYcdOHSbMR8EVKnMEiUXXr1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkK1KgfYiPuyAtrf3+GJV4Zik\nbWMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP4nL/b+0nC8DGx+GC278tkDT1J3ypPruH88Fd8sigd3AiAZj623nCCj\nJwvfMG+NMvAvLp/z+OCMK7kpfFEs/cTeFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAd515IFAz4BZxrlepku/JE5sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg4OWZhZmUtMjg5YS00ZWY2LWE0ZGEtY2E5ZWY5MzFhYmRmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNTcwZTAxMi05NDY1\nLTRkNGYtYjVjMC0zYWQ3YjQ3YTI1N2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT9noygj+4HRbqWIs6TaTpC49hmllHSdGoMVCfAmf0VWXVxUr/B+m5U9GoHGgAx\nwANJjYfjhcheM79Onn1qVO6Wo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSabewMJRDXCBNJ\nJ0YIdeDoE4RdGzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgdhuNlKU8hS1xM00Z2VDdOyY8ogztccTUs0QNhSfG3SoC\nIQCt59VaOdxkt8qJYzol++OP1UF6NPEbWeyGiTnErz4JDQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3632", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3632` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAY61E4fp5qg/22QrY4hTltLlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MTJmMzMxLTE4NjAtNDJkYi05MjFiLTJlNjA4M2RkOGE1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E3MzE3ODAtNjRi\nMS00ZWJiLWFjMzctYTQyODczM2Q2NWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzAx3Bu0AtPDclb0DdQc9TL1fD+pZ5udgVmY49IUqvj8sQkfYf4Eobit13jY4\nhn4kkqZFUADmuaIv8IVgT7ArZ6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjEmtCotrjcqZ2cVFMzuzVPQG+xAwHwYDVR0j\nBBgwFoAUtQWpbvvbsZMX2NaUUevidL85dNUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIG1xkWFFVV3r/QHoxn32qJjH8XZYDSmZP33q2IXbpONIAiBh\ndGo46d8NTeqbmAH7KtVK1OeBGuDvvC95tGWWmfxx4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbYrA45jAAB35XBmFGUhkFQFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjEyZjMzMS0xODYwLTQyZGItOTIxYi0yZTYwODNkZDhhNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTn9SisM3QN8WFnXI7RUmy7nnv9RGy1qJ3oqWXhQWubDE0\nvTRO8jNk9SQj+eE5gXc+r64jsfl4SJ4HqCbgS9j7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtQWpbvvbsZMX2NaUUevidL85\ndNUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL0jLZbbFl/YdQDPoYUxFZuC5zCFknLpVNpIlMkuFCwPAiBz6QerMDdO\nLKlYTxjjb8WLVXyIDTzZylCke+lI/EtL/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQuk2lu6XgHB/I0qBGEswALBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E3MzE3ODAtNjRiMS00ZWJiLWFjMzctYTQyODczM2Q2NWUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNmI5YjJjMC00MDRj\nLTRjOGItYmUxNS00YTZjODVlNjQ2ZmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARSjif0tCe2T+gc7goYoKB4hBij5zzwgbLrr3lYCerC5oqMPj3LVgXCu+N7hRMj\naiyHiijem9M/XStHoCmn8sFGo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMSa0Ki2uNypnZ\nxUUzO7NU9Ab7EDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgbZN/Aijg3IYe12mmlBKm95pYm8b4a55EN/FtEAUi2ooC\nIQDGIRW3NnckILX7O7AJSyrIyHr39lv/fD44pa9Oh984nA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3633", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3633` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISATQ4Gt2NAbN9u2+rUBHt4/3FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1YzNmZGI2LTIzOGItNDcyNi05NzVjLTVkZjE4MmY1MDg3NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVjNDYxMmQtYzMx\nZi00NjlmLWFjNGItMDBiZDBjMzdhMjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPB7SnfsLj5mjpJP3TSI+aO+aGEsjpy7MTK4U09EkPFLKpfW688qvmQtMP7Lg\n0w7g6kJOBI8PHlsDqlgxMx5y8qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtPLlLhEJTwE/e1AqoVTSmJZUnqAwHwYDVR0j\nBBgwFoAU6poAkPXi9l54X0xzjjNmdQNh5sEwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIApqnJ2lfyE9bIL3ST6b5u+McnuvCVfNF6AmWgFe3WIVAiAk\njUTK8Hyyi9Ul4UnWBJoCBrP+70RMkZ5OVsmKqNOlNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYl+PMsDInC7eIFQtKThMWZ8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWMzZmRiNi0yMzhiLTQ3MjYtOTc1Yy01ZGYxODJmNTA4NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjWH2GIQWlKaVPtmV5ZzOfWZ8V4YntOFE/SUOjBI6h2yuH\nPzqKuRjzhD/lnSiwHxBZc/BV1Sgu3+1GmvtIaQH7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6poAkPXi9l54X0xzjjNmdQNh\n5sEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMgsSrbvp+4hkn0TTgmA+PqJxOJ+IosVP6D9wl0tHJYmAiAM0Ptz26Bh\nMS7vFejcN5k1S+OYPWDpaZALaqNCYwTRgw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISATrHXpki6oDLgbIxVwGUREeWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVjNDYxMmQtYzMxZi00NjlmLWFjNGItMDBiZDBjMzdhMjIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxM2FhY2QzMy0xZTdk\nLTQzZjEtOTM2OC03MDkyOWIwY2VlNGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARCFcT1UGL10iEmKYxEp3rAal3PhMbyp+SYpzE1VAZpBP6l6Ow1WceN8a+llY5m\n9o8cVayYztYcVE/RHqDpHkITo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS08uUuEQlPAT97\nUCqhVNKYllSeoDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgD/kDs9vy/nKMpXxuEIzN+TvZ7CHkojWGIxRYbgQxlNsC\nIDy8X+u318e2UnQGWcv79R8SmcYHXq6Na48WXPVKD8Hd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3634", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3634` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISATEKcvP/zHQ7pP9hWE2kSv8sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiMmU1NjliLTRkZDktNGQzNS1iOGU1LTAyZTllNzY0YTE4ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTJkNTQ0NDMtMmRh\nMS00NDBiLWFiYzctMWFkNDFjMjEzYTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ1nru0ANKzCFSNpuqYZEM/jpJMNQPLHKShF86M5ipXW0Xkfyb9+Tyx5/QuRT\nI0A5w9i2NorzhI39JoLnIq5VCKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURcMBCmaW+gQs5Oc4rtaFJlNT1a8wHwYDVR0j\nBBgwFoAUQAuSnF8sI4crcfzsr/FBHhtBIpQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIAP2KrzvPCa1\nesyEbsdD06xO+U4BeclcTA4Hdn0/vU9SAiBvXuYjgV00dKV572MT8rmuf97aQC/Q\ncjoy1mB5f/SzrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWtdwblsobvKQ7gCzw2AtkMDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjJlNTY5Yi00ZGQ5LTRkMzUtYjhlNS0wMmU5ZTc2NGExODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4aqVhwnezwgJB2aZrKnKMdIur9mUhzuabSGJ57H8qugud\ngdpBAALAypD3j8JrhgPufdrB7aO9wRxDx5QDxsLco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQAuSnF8sI4crcfzsr/FBHhtB\nIpQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANEGATBjcdBjpRtEOiEWK1Tgu7jahhfkkytgRcA3Mf77AiA006V94GPr\nwZmjlJRqFVZYwtHhi0hB9wvz52zqZWRHZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISARhSvH4g7ag/1htpN0gpk0JPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTJkNTQ0NDMtMmRhMS00NDBiLWFiYzctMWFkNDFjMjEzYTRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNWZiODQ2Ni1kYzll\nLTQ0NDctOWMwMi1hZTg2ODA0ZGFkODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT+Fpw6rc8BJn5udA7+Nq20KwlLlGj6W6wjXqgjn0i9zbBxNFMZPF1baSSUYwqs\n+d6evx0PPTKxUxjZSnKYkXkBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFwwEKZpb6BCzk\n5ziu1oUmU1PVrzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhANJA6Qu5o3tkhPiPGKaFsV/75v/S8T4Wi0AN91nfS4oy\nAiEA00ge/+qrIC8DXo0DT32839rHJ/QwRDy4ir6i2J12TAU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3635", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3635` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAW2E2UkpJKPeHbEydFptmfEaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMjUxZmE3LTkyMjUtNGQ2My04NWJmLWU4M2I2MTc2ZTU5OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU4NGExMDYtYTQ5\nMy00YmNkLThmMDgtMTlhZmMxOWFkOWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjdTmGhk1WWOMs8EypdALFcS5XOFVC65jzouEc1wkbb6B/kaNhZIPEepTxyqA\nYrB060+x1FCB7hwKL2FdBmPmGKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd34WlmGUtV0WvKv/0qKLjUgtBkowHwYDVR0j\nBBgwFoAU3yGqFCaJeRR6FQD7aFJ8SJiKPlMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgNLD86xfLzTU0Sf8N9ElQcFPpGfui/Ae0cAfoTwT/6isCIHZvc7UWm3IN\nxJaB16J1hjDNxXpKlLmHn9+WEm4QA7gj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXzbbArqmZephsZvG1pxxjbEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjI1MWZhNy05MjI1LTRkNjMtODViZi1lODNiNjE3NmU1OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREEgIrZZWLK5ZBqpIhwJbgEvV8QCPIGZsb1G4DPRhcIryB\n78e0KToZqircJkJCzPGRzsc1mN4MTSxtY6qVW1fLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3yGqFCaJeRR6FQD7aFJ8SJiK\nPlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTzfIYrUagB/E5g9LAGldy+mmJPI4p6wZQACl8ZAtXxYCIQDZ5bZoLriu\n6iAddXSKlRCVNlRpKon7ZzlDpt/qVsvikw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAX2mG27QTtcPaLxflWNjeFH/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU4NGExMDYtYTQ5My00YmNkLThmMDgtMTlhZmMxOWFkOWI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0N2MxNDQwYi1kOWQ4\nLTQ5YzMtODg2My0yZDRkZTEzZTA1MmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3rs6i5RwFPoB0e4G3wKBW2p/ToGkWzLGo5/gggKzYABIW1/hjEdk31WU8vsfr\nwpZKFbwm9mcwP+NelbdA5MPso3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR3fhaWYZS1XRa8\nq//SoouNSC0GSjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgaEZ28Qm2uONSNr10jY2CoWBS+s6AN/zZCUWA6oYkLeIC\nIBaZKhut2GHzReNB5XzaAXtdD2yTSW6d8AP4nfDX5W6A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3636", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3636` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISATMRwBgtdTT/J9uIdw/NeuILMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhMzQwNGUzLTM1NDUtNDZjOS04ODM1LWVjODNkN2MxMWM5NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc0MWFkOGYtNDM1\nYy00MmIwLTk3YmEtM2JiZjU3ZmJhNGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4Q+SEqF0BbCLl/aNONZJvvABfgHt4PjbL72x1/H5b4g1IAV+axB8EFH6N5jk\n3rcUB0V5O8nOxiwDynvDjmQy36OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKJmofjje5DOcVBV0NZhOlXlzbDIwHwYDVR0j\nBBgwFoAUQSWQkvjv38NmR1P5JL1bYa7eLsYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgf0ax1AEOMBDhWwuydeOOyirU3kZWjITbIwSSoPL0wY0CIAGfgeQObT33\nMZIV4fdiU441ANF9DlE4KeOqgjwTH2vV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdJsFW23kZBXsV19rCA5VY3sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTM0MDRlMy0zNTQ1LTQ2YzktODgzNS1lYzgzZDdjMTFjOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQR3eOvu/Gibb7JhHPkKyjnTecHQS8IrlNHTVgfjbIXPjrp\nxQZNQWhfEJJBRAYg0QtUe8if+AYP4ey/Cu8O7UUHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQSWQkvjv38NmR1P5JL1bYa7e\nLsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMQ/p0UcLtwYZQKZhOCk3f0/pavzafHj+4EZZivvT+xSAiEAztUWzfQH\nL7aOLRyGAmfmttJA4Tu5BrZgYzZts/ZoJmU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAR0wS9/IDdyF1qFyXJisfOjvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc0MWFkOGYtNDM1Yy00MmIwLTk3YmEtM2JiZjU3ZmJhNGE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NmFlMzU2MS1jYjI5\nLTQ4ZmYtYjk3YS1lNDY0ZTJiMzJjNDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAReJBidnaSrhZZFY/xR5eV3MhcwFO7xPsIZzHt4tTCdU2zI1TadgrT4Z7hfg8DG\nBJx/78LukjT5VUYapy0HDtIqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQomah+ON7kM5xU\nFXQ1mE6VeXNsMjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAPyF8ZBMypAcjrBu5Zc1O5gAo4pGdtG7rwPfQTQWWPWI\nAiBVgwJPXG8gM9uH8vQ73+KfZfzduci29wd9OTGK/bfS7w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3637", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3637` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAV0bWeNX8oaFsA1SlDP5MitYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjYTY4NDFlLWYzNDItNDExYy04NDI0LTYwMGE1NzA3NWUzYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTllMjUyZjItNDY3\nZS00ZGVhLWIyZjctODIxNDA0MTUwZjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHFlrJERcDxHf76B3Yjegc039wzwVvFoQDVTvBUgwzpPX1EXVrw3cFJYyZMeO\n5GlUGd2fiC7zGyjlfI+nTDyL86OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXentTij9U1awenCVFQM//DwKXVgwHwYDVR0j\nBBgwFoAUm9OvufJYTWhIZrCSZrHSwiCXJ/EwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQD/UI6Olr2DBehEraJhmmWym2CHiXTl25y7mrb2+MKZrQIhAKnInSCt\n63ebxBkclrGeY4yN6IBEvBWMPXC7IjTZ6H2H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdq7eDGpWUM/TsRyTA8zx6iOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2E2ODQxZS1mMzQyLTQxMWMtODQyNC02MDBhNTcwNzVlM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFMP/5wCCBQ42X0TwMKCxkjxcgtQC1qgcHI2RfqIrrwNj6\nK8AuQBR0NhisM19GveKr6Znbju/mogO5JzSLlWLao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm9OvufJYTWhIZrCSZrHSwiCX\nJ/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbLazgygH1f07Ajt0bZrU0jHTUgX6bMd1AlV8PnvNt+8CIDJ3dYaXj1Rl\nlrfKcL6sZGFYKfQIUkVsMDcnAeznmXLO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAap3oMiq8nUwz++wLXmk6WCWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTllMjUyZjItNDY3ZS00ZGVhLWIyZjctODIxNDA0MTUwZjAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZDYwNzk2MS0wZTY5\nLTQwMjEtYWU4Ni1mMzEyODk0ZWUwODkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASl2Hqhxxm+7bX0BOVVZdjHv1x4TwJ5SmeqbNpwLuM33dTkNjbZ4cXhvexgHbUQ\nutcrqInw0fd3cXAMDKclGskCo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRd6e1OKP1TVrB6\ncJUVAz/8PApdWDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJwvLhF5tNNqGgDGTxpShasOSIK688sQMxTMPD2OYLQI\nAiApbbLEYVfHaPQ7I1WHLQk8IKC51iG5Lz4PFDeMoyq5zA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3638", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3638` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAYELJm+TOFBUzhPQ/1cHwrQhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NGU3NzE3LWY5ODQtNDcxOS1iZmQ5LWVkYTc3ZTNkNzgyOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI5NDI2NzctZGY1\nNS00M2UwLWEwYjMtMjczMzJmNzA2ZDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErBjD/iLD1diznx4D4PcjO4dF22E/ygkbfSI7y01oODr8fwT7uX7qNgxLNcsO\n6gibJqsaqNT4U2GjD0Qc3NjpBaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL1QyzQy5ylq1TemqhrLfq7y2NFIwHwYDVR0j\nBBgwFoAUB0XbPVkCjvq8h3hlLhwBkuPVatIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIDc3Ic8IVAatDcD1EQwtZ1nI/lUiFONKizxnS2n8\nWwziAiBdg7/bj7luIdIIzsit8BgUTmuKVLEjGtNKJu9/bVdMmA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASeFRgJpsxgueSQc24gMRf2LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTRlNzcxNy1mOTg0LTQ3MTktYmZkOS1lZGE3N2UzZDc4MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvi1d70glKti46cZnIpFdtGhUBX0Lwh31SLU0v2wztd+D9\n+yjAzM04jr0HsftsYvnwccI88uLc7gBzeEy8BNyro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB0XbPVkCjvq8h3hlLhwBkuPV\natIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIganRu3TPuKBnYsKi6wOXvYUOoqRj86PjRBQTi3DfJR3ECIQDUJpdgfY9r\n+WsJdF7QaXOBI+nNH4EcnA3l9RbNPFYrFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdk2m2TzUgYGsJk0non0sfVZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI5NDI2NzctZGY1NS00M2UwLWEwYjMtMjczMzJmNzA2ZDZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZmFiMWRmYi1hMmE3\nLTQ1OTYtYTdlYy02Zjk1YzA4MTYyOTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR6fDDRDF6VVwLrRuckK6qK76DoG93PjTnd/F7FSknXoFrR+o8NB4oFuSZj9tND\nJ7E94h9NJT9wWc0GSMX3Vd6/o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQvVDLNDLnKWrVN\n6aqGst+rvLY0UjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgXzjZ7+3Fiqfac3d5DQdpVL0uGi4cI48pV/zuhlGCsqwC\nIQDUQ9TOZUKflg8nSnpkL2TWSh7mRf80nB0FtCyOBd3kzA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3639", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3639` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAetd7vfZ4biENFrIQmWITuYQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0MGIxMGZlLWI4ZmMtNGFiOS1iMWM0LWU2NzI0YmUwZDFlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTEzNjg3ZjUtN2I4\nMi00ZGRiLTg1ODAtMjM3NWJjNzM4MDZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERT86ONUV0U6tvWbKjuv3tQwpV6wosMcqiLOHpeHTo6qzGtxt8nmb8OV8WNdZ\nFFxMTyJWZ1+1/8uiH5DA+nWMAKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhYHOJ4/ipm8c9cSHK+Td/5/73BowHwYDVR0j\nBBgwFoAUA62CBL9Hw3OdmonqprLQ748IX8YwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEGcEVxmFjjec5kEejnIwTheCGIemf6skSSs6p6v\n6Lg8AiB+G1sT1iXHzPU5mNZGYxskdRWlZIkQlg1FNgn9i3dv0g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdalHFoHIKmreSaaHxXsYQk2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDBiMTBmZS1iOGZjLTRhYjktYjFjNC1lNjcyNGJlMGQxZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXmRFnAfz6sYJacRjnpbCyG2xlb1jVUn63ab/w3L8qs4MA\nO6Y46I9K35YF4NN0UpnL3KEGg3kUAxdsZL1D1DrXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA62CBL9Hw3OdmonqprLQ748I\nX8YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgakp57dJO73C6GJ6/CKBkgTDXMa6ZIhSVVskgFxiz9nECIQCJlL8ztaez\n9/0LDUFPwFAjenzv9aXgTGq66VDq+sSIVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYgFjrHaRYBOVfiQ9zoxLe2QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTEzNjg3ZjUtN2I4Mi00ZGRiLTg1ODAtMjM3NWJjNzM4MDZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwOTEzNzg0NS05YTlj\nLTQwOWUtODVhMC02ZjQ5NDc0YTkxYTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATlHMrEQSCbi4Z4vThuhS2HuTIWEvB4eVC7ZaBPljZygRunXUfg0i8wqGlb+Bft\nRtB1XbAX0iZHnoby9KSVOoyZo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFgc4nj+Kmbxz1\nxIcr5N3/n/vcGjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgDExBAGA/Nblbwc6ouC7M7Nkp+CBRPicbH1usC2fsl60C\nIQDndngodOP8pQr10z7k0RyjkZRHULDNn5bwyo92JupqVw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3640", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3640` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAXSc2Rj9riDPoSph+JBRKPjmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjOGM5NTgzLWIxYzAtNDY2OS04MWZjLTlmODkzMDkyZDMyYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc5ZjY2OGMtZjE5\nZi00MTkyLTlhNmEtNzI4NWY1NTJhYjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXr4FTXN177C+BOqeuwY1S+bMtEIRrbIScTS5Abs8sTK3TnQN6OYqdtic6ByR\npCLbuDFTpjrW001Bf3nYtPhIz6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFBCmamj3MHaN2nNe+1TcUn0lSzAwHwYDVR0j\nBBgwFoAUH7u8YzjOIj7xwsFvwmcEm9AjOFowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIC52/B+PbzoArR5LAP/PYNZFNQWhpoiktVU9Jc7LFiRwAiEA\n5xFrn6ZoJhMVDPxL9adzKtqK95IZngjy8V8zsnbChak=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbKex2SAjK8ckpQKsN2xkGEhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzhjOTU4My1iMWMwLTQ2NjktODFmYy05Zjg5MzA5MmQzMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnyWPxoD2/1X+gz+5Sw8l+qqSTEOvSH+Ej4wCdjGDYgR7Y\npaNgYcH8UEo3JXJkE9nb+BxMXTJsLX+akGPXceqJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH7u8YzjOIj7xwsFvwmcEm9Aj\nOFowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXNFCuFnq3sIawyomv+IPcUZiig1+6noSviLZq60Eo+0CIQDB87slo2KC\ndxT5L1AouwDMyzPNVgYzXawBt2B+il31EA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQtOV2kqo6pLmSvNzIMv4MTUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc5ZjY2OGMtZjE5Zi00MTkyLTlhNmEtNzI4NWY1NTJhYjVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZmFmMDNiYi1hNDhj\nLTQ1YTAtYmQ4ZS00NTg5ODRmNGUzNGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATsEVg3ph7jgi4nAChFTs/m0S5JHnjLBnOeyDWJzCeUL0/1K7ryOVyNX8sKtvwS\nWsdGfpH3koHNWX30yivfevUWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQUEKZqaPcwdo3a\nc177VNxSfSVLMDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgFkLk/66FSEffYplN59ZvDtBPkobkSiuJPG8jaS1UUp0C\nIQDn9Gy2LMSKi5mkArhyM4YSfnZclnGL74K2ux1K5C1ogA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3641", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3641` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAaotQjqqwC2oqUzGjphtSM/OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYTI2ZTA3LTRlMWYtNDIzNS04ZTY4LWFlOTI4MjdkN2M2YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFjZDJlOWItYmRj\nYi00YzhkLWIyZjktYjI5MWNlMTZlZjM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh8eMGCGZbrFNiSRSuibhFwNcaP96zuCeaH/77bPjLuYd1D/lwnC7/cDbiWsn\nTO3LMUkJSlU4++TzwgePqNpioaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+5N87sDiGNAdFgVdXu5BchfQAWkwHwYDVR0j\nBBgwFoAUUBEjruc4NzSW7exRxBzv3idB+O4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDfMnYUoJMDkz6kvnt/n6/Zvahm83Dy\n88fgbuOkBZSGtQIhAJNoK0Ny8PdZhXbRkAJomX9Lq7hFSZmEPqtvtcFuAdQL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX1f6NsxjKmkLlcLOgCGpRNYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2EyNmUwNy00ZTFmLTQyMzUtOGU2OC1hZTkyODI3ZDdjNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiQkclKbL9TsqmL4pOuL2TP8J+B/ZVr+Ea9UJpt59SDnH/\nyZcR101QDYPSzBqFkbRam0ux5Cz0hCLvpKpyUCS1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUBEjruc4NzSW7exRxBzv3idB\n+O4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALMDqwUq3KMxW+3e0iVtnYK2OQ+EH/bX9ubAMe8fvejMAiBZckEGWPLy\n35i+NMXZPHXFyuNrsDGWph0rMbib9+Q/Ww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAf3CYvEF5D6Wk5qwuBMEs9QnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFjZDJlOWItYmRjYi00YzhkLWIyZjktYjI5MWNlMTZlZjM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZTlmODI1ZS0xYTY5\nLTQ5ZTktYTBjNC1hNmYyZjI3OGE5OTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ8jliIgKlVJ6QiapZLAwSJUbtQsgwd3RXquOyRVvnLIMvk9JiOHjoJCWAI5yZT\niVGRFrOvm+BC8wODgkIkCviBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT7k3zuwOIY0B0W\nBV1e7kFyF9ABaTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgQrAi38izoxcWGjpXCKUmpNiBnwu41XFciLmiBnEisA0C\nICIxUNvOKrFZbHFEmvKMb+q6gR6iNBQz7xA5BCd1X0B+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3642", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3642` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQbtA0Jtwl9d6Yvq4rHeQzRKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2MTA1ODliLTA5YmItNDNiYS1hOWNiLThlN2M1YTNkYTcwNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJiOGU2YmEtNzgy\nYS00OGViLTgwMjItZGY1YzBkNzU0ODU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAKLMeqJDfQL9uj5u+9y5s58FN3kLKaGxW6YRkmBT7Lze0gIrtGDX0Fn1ddeS\nRRxcKMgku+WcnfW4MKavMSkPXaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuI4LVai91fg0fgTfWSnUfWECFI4wHwYDVR0j\nBBgwFoAUqbai8s6vVYYDWrALc4qtH79sNdkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIFT7fFUJDSqEetxuuha+69io6WMG74TJ\nndB3ilnyELQdAiEAh1pSy/Ou3d52gtpYMXSb+gxnRj0VPaHdlKaZtRLl4/8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATZhUAan95PMBybPCxHHH5ohMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjEwNTg5Yi0wOWJiLTQzYmEtYTljYi04ZTdjNWEzZGE3MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMAABpIXIqg/qoX4GYJvf3tXrp+uqPIJDHqGuMgUj1fFuo\nKH4DKn514y3zAB96zZpvPiqdUk3teg3YLSoVK3/Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqbai8s6vVYYDWrALc4qtH79s\nNdkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALr4JXnGcqyXmDYiM9MQfmzLeNy3CTvkuTzK7y/ltnKVAiAiej6iNYaa\nPPMTcJsOAHGrzKIgcfyvPh+He/n39JsI1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaqDEc51vLynr3D1/dycsfAzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJiOGU2YmEtNzgyYS00OGViLTgwMjItZGY1YzBkNzU0ODU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYzUzNDljMS1kMzk2\nLTQyZDQtYTc4Yi1kZjNmMzMwYWZlZWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT4nqkbfGeq6aegaVW5aHaIt1UYRAycSNV59SB//w1G4OIqpbbqXzDsYZA181RU\nc0TQo3O0ar837A4DCN2SziJEo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS4jgtVqL3V+DR+\nBN9ZKdR9YQIUjjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMr/yW5VCXWQkIMIsFOtqBjpou5jrZ6PR1ex2vzShFuc\nAiBblODugsIV5ihB1pQmo65VP1jI4+LfYftNc5m1GOlm+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3643", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3643` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcwCP6zHrP+R70wFON43eeocMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiNjNmOTc3LWVjM2MtNDgzZS1hZDMwLWFkYmQ0NGFlNjRmNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBlNTAwYTQtMDJm\nNS00MjllLTljNjItMDFkOTlmZThmZWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGApuqdLBhXldOhAycOj9MW7xRbXwbSqsid8jBw3DOXMzbNXlmJlFcDjbGyo9\nucH5doxgszeQDWs27NY9CS36GKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU152VMJugod5Uy8X7985pqH+GFaswHwYDVR0j\nBBgwFoAU2gzHa3C98bQ5q7Y/4wrM3xkTerowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCPmrg9tSkB\na9A54IjmxQvns67BElWI0WomCi48BNezUAIhAOWW0wnBt141V0dyncUG+xBk1XhS\nBaSuHsxW0OYdnutr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASidATXXSxQq3fk0dVc/MM9VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjYzZjk3Ny1lYzNjLTQ4M2UtYWQzMC1hZGJkNDRhZTY0ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASz7UoDTnaRTI/Be+q6P7tODT1YhqVukPKScstwOYvFMX1J\nju+ayiuS48aIzPSsd2QtDUeUJl+I2Wa6wQfHKHPio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2gzHa3C98bQ5q7Y/4wrM3xkT\nerowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP/Ju5kpgixzVd5N1ZUzXdqtAsiGvD5vPYVIhIDd03AnAiBc5nF/6Kke\nnBIZdbo0TrVQo8KsCI3EQu/Nrx+aajYJ5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVFL2mmUo1311nNlVluI3H7JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBlNTAwYTQtMDJmNS00MjllLTljNjItMDFkOTlmZThmZWNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMmNiMDFmYS0wZmY5\nLTQ2YTctODcxMy00NGRiZTRjZjY5Y2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARksRdssR34bq3ZlTVOJNrmrNyBDl4TUqDCoYivBwcwLK+4EaXPeObPMuAzu+kW\nERFWMs37qXhhirgep5m5L0v3o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXnZUwm6Ch3lTL\nxfv3zmmof4YVqzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgSDOHRwI2VYg8fCFYwAHOzaP3sh+gsNuICa+RKujVL0QC\nIQCC3qOx9cbrUH9eAvJGDCGR8A5I3phxbMKEszmyg/oZwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3644", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3644` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAeb2N6zXCD/vTL5UMMpFyHLpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzZGRiMTJjLTA2ODgtNDhiMS04ODA5LTIwZWVlZTE3MTFmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU5ZWVjMWItNTc5\nNC00OGUxLTlmYjAtNDM1MTIxMzQwYzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENCt66+AqLBWhzrPSHFtSkq8TtigrORh4V7lr9w5sRrwNEJOfA3v/Q2A3c4a4\nOp5EaveJlGD8wDD/UVAt/rdb3qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI03CTe9Wk40nlT/LLknLfTsfTqIwHwYDVR0j\nBBgwFoAUv9cbNwVFygsh5aVbX/FtYJbwJH0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIhAJKqhzGOMKKxKRLqSxbiVDyihB0sNECfC+uuQS71gPDuAh9ITkFIdjJ1\nW7uYr5wtZlI6huodWGSE/nxeQlv8b4mk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATIrfc0Gza+AYKxucu5W27EZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2RkYjEyYy0wNjg4LTQ4YjEtODgwOS0yMGVlZWUxNzExZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6uC7HDbMSg9SuVOtoM4b8LNkCF6hYIfPIs9UWHn0YBtdd\nwsbdEF58Thw8eJlqyTDrvAJJz4FJwI0eDKeP6Reoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv9cbNwVFygsh5aVbX/FtYJbw\nJH0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPBWvrNKJmjo4XabIVt11cj6cdgdjPGB/pVA8Ly6x9pJAiAbauP7FjUO\nLaWvfHmiORtckJ6lGgEm1wMACgih9ofgHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARV17Egk2aYh6n3zyr8ki7lpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU5ZWVjMWItNTc5NC00OGUxLTlmYjAtNDM1MTIxMzQwYzM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMzAxMjQzZC01ZDUy\nLTQ0YjItYjRkZC05Njg2ODNlYTY4YmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQcu/7Ea6tFvK4m8zxvnwCGXVCUGwKuZyYGuM41jUHeSUO7dwP0emvzSETEwZ7y\nxcosIgvr5+3nUQQTrVOp9lTho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQjTcJN71aTjSeV\nP8suSct9Ox9OojAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgAVYPVBUR0fIvYPVjm5FslulWMeMM6oM373QlVy9dGCsC\nIQCNKIwqZ+NGfe4Q6W9hKyAAYi/peSbshKUBl6b6gp/Umg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3645", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3645` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAe+6OuVXfomM6syDx/LwGHJFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1OWExYzZlLTM2OGQtNDEwNS1iNGUwLTkwN2ZlMTM4OWRkNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZkNDczZjYtYzBm\nNS00N2ZlLWI2ZTUtMTQ3ZjQyZTc2N2RmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu4SHYgUpDXQJEHX7ZW7yv5cH+tkpuBj2oKHc6H7Y2lp6+0bXjZ4+b19JkviY\nvI3poFKP0JaXr23aDLbVazBr96OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Im9ZQjefaywXfkmFq46xNoIIKAwHwYDVR0j\nBBgwFoAUh/aHpFyYG6cVf1zBXBw7v2COxFQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgRIyUTLS7DT2u0VABWSdCtVSHLUkUq6X44i0l2UTKflUCIQDIUKyRkrfW\nMfz2gH+5FjL1QnEiOM6IAatEawTyJtL5/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYtA4qiGKld/z++mQBJmbfBtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTlhMWM2ZS0zNjhkLTQxMDUtYjRlMC05MDdmZTEzODlkZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJ8LQOPHnEhcIwe4swTk+Nn8RrtycOET8tbkxFw31Nvuut\nMLJJ+W3kI7Nad4rMX4q1i/h9aGCPzhaQnOt0d7hFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh/aHpFyYG6cVf1zBXBw7v2CO\nxFQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTls7TOCbVGzdQTw6Vvajnop9Cp/7we6+w4i/5SmftKICICOQR1wuvAy4\nsjQF9vz5tK6Us+vrHcN3vBxglI8qSHwx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARplSUTdPVxHMPXDAfCijGMUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZkNDczZjYtYzBmNS00N2ZlLWI2ZTUtMTQ3ZjQyZTc2N2RmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmODVjNWYxOC1jOTU1\nLTRkZWEtYjJhMC0yNmRkNTNhMjc1OTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATojUNnN1uFK0DiPTHjEFa0x6DBBxl04EByKZDIh2DxHRcYQPOm3A2POl4SDBnt\nDJ10uRzEA4/nM3Te51cS78sLo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTcib1lCN59rLBd\n+SYWrjrE2gggoDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAN133O59iqjt9s98VVeQJXtqM6WU7lHUzQ4FcOYmEVYf\nAiATbbXFwCnxlBZAzY6xoOQRDHDw9kVjfZQlVYRG1HK74Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3646", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3646` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAfcFnJ0WapBjgkCkISjog5/9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3NjU4MzFlLWI2ZTMtNGU3Yy05NjJmLWFmOWEwZDA0NDk2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdhMmY5N2EtNWEz\nZS00Zjc5LTkzNjgtZmExMDcxNzE2MDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExi70+YQoCLmbs21TcBJWtCH+dTTChVgTurFLjJtpOAvIjlp7XW/3pqZ3taK+\n0sjzwdaFcFwNXSY/H0jj3yAPqKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU619Kq2SXbGiy3H29AhRaL7ER4WQwHwYDVR0j\nBBgwFoAUKH2xB+MwDfqTvMyPSjXYnlz64QEwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIDLRKASkL5lmJy7ZgWE+MZbwjeWTFLKzI5vCzBYhWkVIAiEA1R+rcDjw\nsqcZX7Z4JTn3RWo8adrmkJwW0m0Y6G/WPzQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXbLpvJcAXmGbbBZLVslA602MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzY1ODMxZS1iNmUzLTRlN2MtOTYyZi1hZjlhMGQwNDQ5NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATm5Q9c0hVjhcFR8AXAMnY1I+9B2O3YHINBF/VS/p9RXqJ3\nRkEgffMWciqehP763vjcH8NHuo+pMVY6U2P1eobJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKH2xB+MwDfqTvMyPSjXYnlz6\n4QEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJEpgapTB4tb9pDF/plHqX4FvrNHt7I0GVIFXoJxiBt/AiEAoNmGHoZK\nVRovwPaz3N4C+PcNLUBFkVzdYhfJD1ugBzs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAX+481a7zRBTog0iuwN68OWKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdhMmY5N2EtNWEzZS00Zjc5LTkzNjgtZmExMDcxNzE2MDIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwM2VmZjMwMC0xYjg5\nLTRkOGEtYjljOC0yYWVhZGViM2Q5NTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARMwkAU7vbvT5zvnf6gX+B3AtHOOCMnVleuntH7SR6VyT2QT/1WqxEyK9DNe1Og\nxNxgTWfqAmwyngQ/b5hcyLmeo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTrX0qrZJdsaLLc\nfb0CFFovsRHhZDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgDypuDK7xN44tc9gHpb7elBrK3n3gv91LYtg3vClSHKsC\nIBW4L/w/NgMTXmDGPwR7Uk3y7Xn1+uE3ZuTiA06xxiNr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3647", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3647` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAW+BO9c5tj1IJwuONEYdAQ7LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2MTU5NmQ1LWJiZTktNGI2Zi04ZjUyLTljMDI0MGY3ZGVlMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRjYWE3OGUtYzdk\nNi00OTljLTk2MzQtNDI4MjY3NzExOWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG2ma0lQj7qDW91XfRh/forCXiJcFyzvoIN4i7XquvIVtdi2HluBHy0cf73k4\ncKUge70E2Cwba46f/6p2qxn0GaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyaQ3zM9z11qmpaljfeU4ziHaP8swHwYDVR0j\nBBgwFoAUitUVLQ0/1XlgUsnfCgjg0dP4XYEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDa2ZnDXSxCKm3+Y0Ox3ZsWvAYTZWuwOPN+KyVc\nsHUfJAIhAOjH31ejPDUhN8+415DcoVDNdlzUEjVXO5+v0ehTtncR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVilULPOAjfnVUEykzBGln0SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjE1OTZkNS1iYmU5LTRiNmYtOGY1Mi05YzAyNDBmN2RlZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS98jmBUgHc6y1kkBvDe61LFn2idLsGBLABjsamGYU+q3E3\n2GwQBUGWsImEtsW2ISFt/tsV/jBkgzq8GmD3oJlzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUitUVLQ0/1XlgUsnfCgjg0dP4\nXYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRHbPZDJ84tPMvHSU/XkOGx2eMPMNrFoKBSU9XDt/PeQCIGCE5X+h4fH8\nK1mJ141xLLRya9F3WFnHTH0NASu2H0bu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAbIhasSpbqgpwChNw32zk1PwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRjYWE3OGUtYzdkNi00OTljLTk2MzQtNDI4MjY3NzExOWE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZTQwZTNhMC0xMWMw\nLTRmYjQtYTYwOC05YjU5OGYxZjkxZWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT51bKUP3lxhvvp7ilw3HtBvZ3+iq3Pt5zbh4ilRg24zU0gcLVdYSRTS8IVz51h\nc2Y/rENJy3O2c/ggCxpFeM1Do3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTJpDfMz3PXWqal\nqWN95TjOIdo/yzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgSANXt9DaE7gStxQFv9AyUI5kLRMtd8QhUeDZdFX1es4C\nIFDAwCARGPQaCyqaGsiF0XPY3xiIzmJAUWgouHcNWrDZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3648", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3648` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAUnV3gu/msclG1d3FVFEGAdcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExNWI0ODM0LWNmNjEtNGYwYi1iM2UxLTJmNGM0ZmRiNzM0NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVhZDUwZGYtNDNi\nMi00MDM0LWIxMzctM2U2NTRmY2QzZDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt1zmps2Imi5FRGCxR3yShRSXOowDIsao4Qutd6ziyTsU0SU8mGeVq0dQUOlU\n8m7aps4ySoQHmxBhsMnLkVs+MaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2zSuk471nxkOzCfGWmItG1U4Kr8wHwYDVR0j\nBBgwFoAU4B6IeRxv/8RU02RW8Bp/j49UXlowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEUSmAkU7+VwRss839eW56Jd62NaqTeiW7dN6eCM\nI4aaAiAx2Nb4f5mekmxG/e/a4MpCxPqsvqP/Z8PatYMcwodehQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR38wBCiHdop8lF7SHo3OgNeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTViNDgzNC1jZjYxLTRmMGItYjNlMS0yZjRjNGZkYjczNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRowbQd0UHmZvZyjxPaOJGMJzYwGfUWTU19VzlCAURyUma\n0BiF0DNOe6cEycrL0c95RKbUyGgVLHld0xOAbsbno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4B6IeRxv/8RU02RW8Bp/j49U\nXlowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALD4fahDfuP0NAZiOTNnf9ZcmXWgzdLJKK/WwIwiBd8AAiA90E3HUU9f\nU+5mhFVtUVVmLr1yGIlB/2YyaZ13ujC0OQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQBhmmPXZWd7oQUmopi9Ga+RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVhZDUwZGYtNDNiMi00MDM0LWIxMzctM2U2NTRmY2QzZDk0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNzAxODBkZi1kZWQ2\nLTQ3NDMtOWVjMC02NjMwOTlhYmNmYmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATNmwyJGnVGq4t2FooQcTbe+8BKYOuzbK3ua6eoHrxQdIFO6Am2zPYfzH5Tj3YZ\nIFMpbUBCTOPrh0zFIZIEU6TYo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTbNK6TjvWfGQ7M\nJ8ZaYi0bVTgqvzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJtfCSGmTi9nRAUQLate8kTbZabAVOdY2Ev8BynmBUpi\nAiB2LNHOH8Pf2iqag0z57NAWyErlibzCiaKAY73PQUJ4sg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3649", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3649` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISASk0h7IyCHBOmQsUmOg5CXnqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhOTkxNTA0LWU0ZWYtNDczNy04ZDVlLThlN2FiODA5OTFkZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM3ZTRiOWEtMmYw\nNC00ZjNiLTk3ZjMtNjBlOGQ1NTA5ZmMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWOHu9ubnNdQxRNlJ8geWu6L/WgLW8RXp19m93iNsn6jAG+HX3SWE7wZQJVyD\n/pSmW5KrnFHMQQktaXEkRAJXaKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU42WTKAHKlKvFuksl0jdC3EpkkZswHwYDVR0j\nBBgwFoAUso+H7d5pBHlw+hSZQtSew6eZADgwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIBFq0H6IpksoUikNPUBIzzHGe7Oj8Zopnvm7LK29Xgh7AiEA\nnqYJ5jwTaGimklPGa3lcyN5kteoQ/DUkVBJI2cxfJQQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXjFuu2ApuKyal3yM0n+Tg7SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTk5MTUwNC1lNGVmLTQ3MzctOGQ1ZS04ZTdhYjgwOTkxZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq/5n2T94sl2NC+xhoprP5dS/hJkWGqcN3nHmx+XreQNm/\ncsb6iDeLDHjDvABAiLzeQvoCPVtRgX8jIoAw3k3lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUso+H7d5pBHlw+hSZQtSew6eZ\nADgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALdMBESrL4MeDeFrsqgNLGCxPNidibFcLifoZh4gdVmXAiBSTD6Trkbx\nmSJ4uWE58ALI4qhms29yuzgI3eAiSxCmBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZrxqeXMnDDAYOM1YewTGmFcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM3ZTRiOWEtMmYwNC00ZjNiLTk3ZjMtNjBlOGQ1NTA5ZmMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMzcxNmJiNi1mN2Jl\nLTQ0YmItYTYwMi01NTlmZTU2MTFiMDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASVif6hMNf34TzFPPab3atTsft3y5llOihqBooNm6ak81BXl96FNK4tic1cwHZt\n9UN+OzXF3rJ69RuvYd61j4+/o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjZZMoAcqUq8W6\nSyXSN0LcSmSRmzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAJZdqGCC5Y4YnaAPIpFYNaQ5pRms79LDGebwSMQrh2UP\nAiEA7ZtPd4VWoCR5gGs1PrjaypERKQ1iEoTslpZuzYyBFEQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3650", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3650` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAW2F393/KFOaL1jBJMOx+f1PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5ZDlkNTNlLTcwZDItNDllNy1iNmYwLTUwYmQwY2E4ZTRlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RiMGRkNDUtNDc1\nNS00MjNkLTkyODQtOTZjYTJhZDZhNjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp20TaDWMwMtIuJVGCTFBm8wbpMNGU5p8ouLx5FTyOBWHFIrOEXj+7+k2WBt9\nJnPw1WeVQ9tgqJ5VYgBzW6tBoKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMMXhMqBcAKdt3gywq4TshSF/MH8wHwYDVR0j\nBBgwFoAUu1qJYdw5ZAZSDi0JIaqccVEHtqkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDloQENDS924n6F0TEXlxwb3/EOzUbP\nROX82wVFkpzsIgIhALShFK5DQN8W7J5IE/TPMsMz5odn5Rscxe7fECYcvPPD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfBwPPCHZT3SEX4V0zZ2tZ/DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWQ5ZDUzZS03MGQyLTQ5ZTctYjZmMC01MGJkMGNhOGU0ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMRtzkCgMCyliiCEqOgmgpW5D5JLobBHTlDtgA4FuVJzGZ\nKLZHcg3sl+IDJ+WycW1s4M/CyVtJul0pLSgm1NCIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu1qJYdw5ZAZSDi0JIaqccVEH\ntqkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOtauUD4/fQ2eGxhz9UeBhEUTg+Qv9cdIX0l9zCI0pvpAiEAuSFU4hle\nc8QxReKgHaDm9EKFUq7UOJmZwk+WTLpgSHw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAckOCuo2C9dpnuaVaDC6edWjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RiMGRkNDUtNDc1NS00MjNkLTkyODQtOTZjYTJhZDZhNjg0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMDdhMDYyNy0xNDY2\nLTRjYjctYmVlMi01MGM0NjA4MzNiMzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARfowRYEfspTD3xrSy6BHQ8yROy41wrEgJ4pIWozXDPOFPJjg40R2/8d9/qusAz\nqkOrFZVs3DCTHmpyF5FsV78no3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQwxeEyoFwAp23e\nDLCrhOyFIX8wfzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhALWeePAsWXp2EhI1Sh6+WzxMzjtSiHyayni9qBIEDC5V\nAiARll1+9X+33qSarHktP8ZWJ4wT4mbn6vXEpCnuuVmd3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3651", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3651` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAV53S08hEFGUFGNpoeoSDOk6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiOWZkY2Y5LTZkZDgtNDA4Ny1hNmUzLTEwMWRlODY5MTY4YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc3MzQ4ZTQtMzQ2\nNS00YmU1LWExM2UtY2I2NWE2ZGVhYmJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAQ82MAkd1YM3opqmS9L0WrPgYvOrZVgooeeCcskfkfHgFtt/olBdzYlPrCgu\nIZUoojatnjscRyF4VHJV1BK5/aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjeW0Akz3C+U3LkJREfdy4QsOx3YwHwYDVR0j\nBBgwFoAUxFkfSB2LPGpTkWFkxf1taZZTSlEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBqOILh3kDF/wkjFd7isuN5TOEmjGxi8\nUREn2xJi9RRnAiEA9hxIzKG0BLSrPhyHFGXaYOYxCc3ZP7sFDHa+oBD37mU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQRlXJ08gJe7hwM9U4i7xsETMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjlmZGNmOS02ZGQ4LTQwODctYTZlMy0xMDFkZTg2OTE2OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH6KBC0gmsLh4+nD+g9kIMbWDEE+qKado4/eD7yy3uk76/\naQfH7uCtr2hfq8pi09lMifTvrqH+zwxHvajmYjvZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxFkfSB2LPGpTkWFkxf1taZZT\nSlEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVerWFuJcB8g2MzMMhGUGiJF+y5MgztOC1KEsNmL8BBoCIQCrDmy2Q4mT\nIGHUqgESUiQTLTpkt8ySys1Uox8nG6bpsw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVSvJ7i7EjON1ilhIwOOlhHqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc3MzQ4ZTQtMzQ2NS00YmU1LWExM2UtY2I2NWE2ZGVhYmJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNDYyNWIzMy1mNzU3\nLTQ5Y2EtYjkzMS1hOGQwYmNjNzFhMjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARvqtVEcoUwL7L/tdmHQOoTC4c84NvE6LunKym/YtcFQYwxyCtaTLdVhEYYUNca\niWT3AARdWEIfj7ZgOW9hgvz6o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSN5bQCTPcL5Tcu\nQlER93LhCw7HdjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgNFp5+bcyF2YgO6s6YuyvEJg4L+IOJGmRngFNu8mPvMsC\nIQC1JOqftfye3LPaV+DcVjE4aFgIzF3Dn5e6+nKae0MngQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3652", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3652` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAeYQioBluvlxCzKm0MT/bYqaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNTZmNWVhLWE3ZDAtNDQ3Ni1hNmFhLTY1NDVmNmFiNjI1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ5YjljMjUtNzAz\nYi00ZjY3LWFjZmUtZWU0MTZkYjI2YTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzuUi14NNty0nl2pHD/CNGyb0MKHrhjAOmopac38xlLT8m85x5hjqsozboKvf\nhPmUYgRsMK+s1qontKrmLsei0KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEczf0YG1rChthWZBGgCnPGzOaNyMB8GA1UdIwQY\nMBaAFOJT1lzhZ9G4ProfY9DNU+BExYQhMAoGCCqGSM49BAMCA0kAMEYCIQCzP+mh\nOpZgwAr33trELSN9ODFqrzcKNYzPgyx7gtISHAIhAMwIll6ZzhPUJL8L/gCE+1yp\nQTXW0SZMvKjf2hCjNfdj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATVM0FCYqgI/BXdXJV7FkD0GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTU2ZjVlYS1hN2QwLTQ0NzYtYTZhYS02NTQ1ZjZhYjYyNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWq6CmGD2OxI9+A/m0WXk4rDoC1U+v/KYoBZV3/CzXpMYp\nCw+pmXForDsl3ODvsDNZN7Qh0rRD9zbFV2jgwbhbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4lPWXOFn0bg+uh9j0M1T4ETF\nhCEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOPYXTxcJo/tPeTNgNPi+TBE3cDk5QPVz88AjawViMwaAiEAph/mFof3\n8u+78jL+TyiOAxXnMWVgLjr7OhQOrAp12dY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAe0Y6fTJjHjpoTPkAS30NCGrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ5YjljMjUtNzAzYi00ZjY3LWFjZmUtZWU0MTZkYjI2YTljMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGQyMWJkNDctZDE0OS00\nZGQxLWE0OWItNjBkZWNmZjRiMjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFRJSWgdMQSQZ6Ubb9WCHUlbz5lRDNrL6ZnDeQ8diz3siwBRW0SKzzOp3fTCt7HJl\ncNeVuzbRdD139Ph6pscPcaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURzN/RgbWsKG2FZkE\naAKc8bM5o3IwCgYIKoZIzj0EAwIDSQAwRgIhAOZnIrifHHFDHlmNhjCysSFrQ8Fw\nzdMogFVpPL5stOlHAiEAwRcCM51KbZcxTtIlykWoGcQj4yXauHpXx+H2c8RiFy8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3653", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3653` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVomdhsdBv9Gar2rEzDtwU7+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyZDY2Y2ZmLTA4MTYtNDkzYi1iYmNhLTU1N2EyYmMxNjIzMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZhY2FkNDYtM2I4\nZC00ZmQyLTg4ODktNmYyNDAxYzEyY2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES1ARqJEwJ0f4AwpPG8J7v8Bf4AX88gzA+hbz7d/d9/pjNp8E9yVlLlEH6WBd\nLbU39/j85w5ZL+4/sBdlpiu8zaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHw5nY6ZLocpgYuLAmMbprUmzSxAMB8GA1UdIwQY\nMBaAFHg6aZAl6/1v7Ql1JzYvqvh4aUh1MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAGHuLvCDklPZm8jLFwS5TdNWHiNdlVcQGx\naMOrrjU2/wIhAOMcVo4eCJKYgBm4W///K50Ns6kJtaMdRXtLL7kqWEEZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQvuqznYmoiVvK8ZCxL7tye/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmQ2NmNmZi0wODE2LTQ5M2ItYmJjYS01NTdhMmJjMTYyMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTC9M+XpGd/pS1YqkIMlfzVFEufQ8Y7aqqb/kzqY/iKPYE\nHB5HxTOVHAT+ynBW5k6GlKAnpNOjZfEX7pad1VrHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeDppkCXr/W/tCXUnNi+q+Hhp\nSHUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN+k3Yg5Qh8Lg/D+BoM7KbgiDv8KXgnOnaUjmQFhWTzoCIHdiHvA6BgTj\nIwwGZbYNQDUo0dQO1Bt7xJmv4vowJadD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAbgF3V281Qbbv7M1PQwjec1IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZhY2FkNDYtM2I4ZC00ZmQyLTg4ODktNmYyNDAxYzEyY2Y3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTVhMDlhZTItZmYwMS00\nZGMwLTlmODYtZTc5NDE1MjZhMmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwhClphV1tl/epohakKEP2u4Ll8I11Cmf4XEQ8ov4/RRws/e3aXZbSRkpxgxmHsD1\nxfMAsnLMIXLecKxs5NmDLKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfDmdjpkuhymBi4sC\nYxumtSbNLEAwCgYIKoZIzj0EAwIDRwAwRAIgKNV9DGOHUssHC3NXu3NWliSec34l\n/WHcXmWxErqa2MMCIElTA3ERuIdVB+OWS/dywnv7XG2V1s31SefHR9Y30ste\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3654", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3654` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISARXmTscgYXes5tHxWqGJm/xxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiMDg0NjgzLTkxM2EtNDc0NC04NDRmLWEyZDMzY2ZlYzZmYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTIyNjU3ZTQtYmJh\nMi00OGQwLWIzOTEtMGI4MWEyZTdkYmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7N5F3534YnRRlwpSxq2oFw/N/gX+htYDhnevZ+Oeg9Adjazwq5otzPq4WfsL\nD41XiGJ2nKn/KJbw4SF9vFpeYaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHS+I2jHPeCS6macPdVzWeyyLs9WMB8GA1UdIwQY\nMBaAFKr2leldETujhBJX1tT61kPwWt4EMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBxRQKHxxaBO2mfbeisELeFX1TNEYifYhHa\nvhnjf2dhYwIhAKczz7SYzfnlbFJSHLcyy5OfNa1CqTggd+3+FyT56/k7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAThhssMuQwizX/Nbcf2ExqOMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjA4NDY4My05MTNhLTQ3NDQtODQ0Zi1hMmQzM2NmZWM2ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0RjqUoFTsioj8fIrqmg+itKXyXQva55AcLUBEgGxfuA8b\nleKMnH4zUUyLhXda3/194XFxTLUd7DEoeAdVIGhxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqvaV6V0RO6OEElfW1PrWQ/Ba\n3gQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOpE0sFqz6HbdOtUSA2zbN6RmvorwhG3HMxQ4PqLN1hIAiEAzRz6AcnZ\n5me5GHDgeZ15FBHv/opdGUvyH+o/1B9UPHU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAWr+71gGfsWfXSBOwhDrR9YDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTIyNjU3ZTQtYmJhMi00OGQwLWIzOTEtMGI4MWEyZTdkYmY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGZmM2NkNjAtYjE1OS00\nYTk4LWI1MDYtNTllNjY0MmIwNGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngtB69DD15J8VnAiTXRHF5yIHKRzjCHV2J7fOhkOpCAxt3EQbCZyFGhEBOapUo2g/\nKG2kiQ8FeeL+HSgDkUBroKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdL4jaMc94JLqZpw9\n1XNZ7LIuz1YwCgYIKoZIzj0EAwIDSAAwRQIgNi1uuGyKZ45CeQWkhiUGnFVjBCnA\npTMw91BNgDzkr+gCIQDplgqwcie+oQUhnTJM2CMWggiUUHZECSJ/tt00h0CbOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3655", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3655` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYIGHOWHhefiZsr+kISeH6EwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5ZGQwNTAyLTI2ZmUtNDYxNC05OTUwLTJlYmU3MGMzZDAxNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ3OGRlY2YtNWVi\nNS00MWYxLTgyMmItMWU2ZjI5M2RkYTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERlcJtPJgnl2Ml1vTmbQhLqC9N/3dHDqKu3xA/hb/kYxPGFnE0BTZzOH2CCmI\nYfjoXRCdM7mJi+7LZIuhRvUmq6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQWP6+IaSpriwI6k13MhtTpoGIahzAfBgNVHSME\nGDAWgBT/jNaa5fOkS2DNlehGlPOBU2KCEjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDoi1/Y+94gIiGMJlJO/wpUvFNtqgud\nutPt8xOEss2CVgIgAxBQ/6WK9e3ZS/OhjFkdjyQncVF+iS68lzA2w1MYQWc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASiOf0u/NZ0Md75z+f/PJwgSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWRkMDUwMi0yNmZlLTQ2MTQtOTk1MC0yZWJlNzBjM2QwMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzpJd63NO1EGOagZDpK32Z1fHGoHLY450784j9G/Yw8w/c\nO6a00aDiAQlAABkSg04n2GxI14dWHYOhxC4AukwJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/4zWmuXzpEtgzZXoRpTzgVNi\nghIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVGrSu2ii2klMJ5vw98PMndesuPcPi/P3CDT/34ypY+QCIQCPcjy6ekjs\nN4k/NRPa4LtpXlB4U9yRD8cJKzyZpS5kyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAYD1Enmz44Pj01pgvnwWtx0QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ3OGRlY2YtNWViNS00MWYxLTgyMmItMWU2ZjI5M2RkYTRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzYxOWE2YmEtZWJjZC00\nOTYyLTk4MGMtOTYzOGUzNDNmYTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndaVBDqst5vn/j80kOe1A2OIo95rDem0Tu/K5TgPlrNf3XlxpiOaWBsycLRY5+ckG\nHn8X0S0BqWvqsAo4uKuuoaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFj+viGkqa4sCOpNd\nzIbU6aBiGocwCgYIKoZIzj0EAwIDRwAwRAIgUfiGvuK8PPGcDFbjnezS86zfHf88\nPb5GZES0p7LAejECICG98DPC73pPcUSwxqtUL27VkYltSWhQZ49xe6GziKDN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3656", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3656` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISATnjIVyYmKRaDu0JqMmEOwwaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3MTQ4YTVkLTRjZTYtNGZkZC05ZDk2LWU0YWRiODg4MjhhYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzYyZWI1Y2ItNjZh\nYy00M2ZjLWI3NGEtMGYxNDc5OTkyNGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyjE3EwwpUvmoSoLoAAZgh3snxRwJhc/ZY21P7cc86ULGLW/+yrWYc2poGCbD\n3bkICpSNngMZMg1kCVaVbAkxYaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+SLvmPd/R9Yd/K9KFr6uUQPfWG4wHwYDVR0j\nBBgwFoAUVR8ys1xldXMs62oasT3G1vR/iHMwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA6Qp/XJ5SV5mS\nphwunp3HH9LT1m3aHHA/WoHLLnFIA20CIQCF2O5Masv2eROMMQIH6Y5yhVWP6fMH\nT3yKW47YkLWczg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASN5RbXPr8gGpJGT5rNBpFC9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzE0OGE1ZC00Y2U2LTRmZGQtOWQ5Ni1lNGFkYjg4ODI4YWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARB5jYhF9TvNg8RGb1dl773CKGh3P6tYr7gTzdbhw55pk8I\niKW/OGRfJW3p0JAXaF3GPZyzcjPiFnf/pDTJjopXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVR8ys1xldXMs62oasT3G1vR/\niHMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN9sJxEzKVbv246OQF/XDIXI0BLHAoT5wC3XKo8IZaLZAiEAjKS7sgyL\ncs9fQORAeCFQ6SzZuvOhA2kUvHEVlCu21sQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAcGPiBxV+NNqhrpxNdivi48QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzYyZWI1Y2ItNjZhYy00M2ZjLWI3NGEtMGYxNDc5OTkyNGEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzk4MmMyMWEtNWIxMy00\nMWIyLWIxZWUtNTI2ODg2OWFkODg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nb4NjZduJbQnbWx5HXlBvnMvHgrQ+VCRPkV5UZX+DjIJ36qiHx8O+VlC+kyPLRQw7\nuRAd6Qt2PTGMzO2++xVaQKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+SLvmPd/R9Yd/K9K\nFr6uUQPfWG4wCgYIKoZIzj0EAwIDSAAwRQIhALf7SL0JsVi1DfUbNfbvnrTlYBYK\nVtDpCAt30ABUSba5AiA+e+UomIskga4uhK0E71DACj940+VqpMzLGdyGoJb8tg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3657", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3657` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbYuTlcY0QTDA/r38UePHqFQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhNmRjMTA2LTBmN2MtNDYwZC1hMzZkLTk2NTg0ZTliMjdmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRmM2E4Y2YtNmFj\nYS00ZjAwLWI2NzYtNjY1MTk4MWViNDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt3R2OThcqyZ0jPLciCOaqhc+VaRjvrSp2uRNR5SGFYYS1zdS3NDAfuaTclBO\nM+zcGK7f9PvtrGsPxEYXL53cXqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1jEAke3EbYWJoZ4yk8szJlBMYyYwHwYDVR0j\nBBgwFoAUhZFzNfzhADquMCUT7zRipdFsJN0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAgG8HYNcrpMjG\nxTuM7N1oGm8NYFc9pIsPoutN3ZxSkMkCIGn6OiJ24ZPsaHopP7Jb8zIo8u4qoQq+\n+kQP0hbbw5Sj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYTKOGk2R3Jf2n4OtzpCGEhgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTZkYzEwNi0wZjdjLTQ2MGQtYTM2ZC05NjU4NGU5YjI3ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARp3MUoLp2WEgKXImi1cHgB2zjcMK8bEUQlrWbaQ2QI0f6X\nJ39Mj1CwV+YXGWXllff3oV+norLUN8HkQTNWnJ38o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhZFzNfzhADquMCUT7zRipdFs\nJN0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEAkVkLGJMYUs4sjCaOQgYNMsosRRjhrEic5QJq1sxvICICqNnFCdl+A7\nYCq7AmnKBNZyZEMLV+l9ERWpHv/K0Onk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISASc0iIwi2TBqcAmksk/BkqcjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRmM2E4Y2YtNmFjYS00ZjAwLWI2NzYtNjY1MTk4MWViNDcxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTYyODM2NDYtMzdlMS00\nY2IzLWJiZGMtNTY0ZDQzZmVmMGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2VtkTIA6s5SWcj1y2wfjZdcoIsACBEqPjXLt54wYL/nqmUXzjUn+oACSltBV2RZZ\nEh1K8XNFrjtw4aGk67viqqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1jEAke3EbYWJoZ4y\nk8szJlBMYyYwCgYIKoZIzj0EAwIDSAAwRQIgPRyIHbSoBWEEo25VzjWI4ay7h9a+\n6Vxd2oADla4TsjYCIQDnTzsL+Un68y8ll7IGe4pr8mrcgWwcoI/fut+CORbNjw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3658", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3658` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAfwLMLr95ikMXNWTq4ArLsQ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxODU5N2Y5LTFkYmUtNDIxNC05NTM1LWM4ZTI4OTcyOGZmOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWE3ODA0ZDQtODU1\nMi00YzM4LThjOGMtOWU3YjNiNTBhZGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHNbzu4UOpCVIU1IgK+yeR4OepNLMupzTu78k/iJlK8OlvEjgk8ISLmOcvved\nXJ98u6mapjvkyw1ZkwsWAXaYB6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsGODuFeuYam4B/3dB/w2giL1nmMwHwYDVR0j\nBBgwFoAU5iotC3k0k1Cuk7//akDxAo8iqzIwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA3LbK5ubxBAtjbd2YHETa\n7z0bR9seJxoNWJbPcUw0kuECIC7aXvrTktlubR4+tsntXyHilL3KuEJyEbhu4Oph\nsUIM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdEFTrE7QLvm25yFXepbOu3uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTg1OTdmOS0xZGJlLTQyMTQtOTUzNS1jOGUyODk3MjhmZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTVF0P6IFTYHUC+Ovknn57uYgVb7EItgiGDOkzwvWpWkco\n2GvwIor6NmKbb6C16eHEZEIJne+0br5qjnpcDhWeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5iotC3k0k1Cuk7//akDxAo8i\nqzIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdOU7HpAEI8KyUtHyyCAriP1ueoDmRZR+a4t12Fo0y5ACICEufl+aNsxc\nWGzTRiWgY+Joyi2vVz1SMFq/QoE+xSM6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAZo9DAl2Hjgv2673n7ckGtCVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWE3ODA0ZDQtODU1Mi00YzM4LThjOGMtOWU3YjNiNTBhZGViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjcyNzY0M2EtZDhjOS00\nNmRmLWIyOTAtZTkwMmFkNTNiNmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntXiB9ts0dX+V9xGcymu+LHChB+gTpiE/cJ08oNesM6aEmQOTqKY+Mctn0RsXuT+f\nvODZnLXHBlprDTCe/vCOEqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsGODuFeuYam4B/3d\nB/w2giL1nmMwCgYIKoZIzj0EAwIDRwAwRAIgLz8aG+KEU6xgzeRM1E8Hgmv4dQbg\ndcdlQ3vXaUe6ETsCICLX/zxTKzrKeNeEFDF7sgHSgv9455+YZ+B7uz+iPNYl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3659", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3659` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAUhjzS7fKV0F1c1UQ8Smx4UQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyNGYxYTdhLWM1ODgtNDZlZS1hZTQxLTdiMjViZTk3ODE1ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzUzZDM0ZjgtZGJk\nNy00ZDJkLTliOGQtYTAxNzliZWEwODJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExgeaXBij8STwR/4g9FOoUDYrUPXRAhD5q6NT/aGVuYajO5O81Ss0PSEzVlh9\nsSXE+4S1WqBKXkyRG9TAwFWIB6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA/aEJvdNtwjnqiLdqDAoHfQCxjkwHwYDVR0j\nBBgwFoAUGMhKeFVvTiiqUix5GiXYiaBvw70wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiB7Eb78\n8W+Hd9s5HMifqX5vQcUfNwyZZQ0NH4wf3LdlbwIgS7ZD6e5MCu5gpOv4/GS5zPfA\nRdRCMF9wLRgd+yEbzIU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdG0mzbptZtxkMxuufDcXH2WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjRmMWE3YS1jNTg4LTQ2ZWUtYWU0MS03YjI1YmU5NzgxNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4TqbOSytyob5MwDkUup8YI/BoZNBT/LA4DbnYf+1ch5sn\nakQJ3zG4oKus1LHm/RNsgq9EnZbkB12bn9ZGY+EZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGMhKeFVvTiiqUix5GiXYiaBv\nw70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNE7kACxfqPB/08Zb61dFO/yJ/Qp2450DbKTHo7B4c/ACIAMt4IgxCFdV\n6IzLJM7UG9yampa4zIDw3PqquWBpZyR0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAYCqorInJJNo7dpsCkMDhpHPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzUzZDM0ZjgtZGJkNy00ZDJkLTliOGQtYTAxNzliZWEwODJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTg4NWYyYzUtYTkzYS00\nZjdiLTk1OTctNzBhODY2ODgxYWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nN3+ItoiOXM1w9k6xSWOYwamiENRbDbs10apd1pmvTnMUp+E6SyXUf+L206Aesg05\n5sM6I58PyitRxixLlMm9DKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUA/aEJvdNtwjnqiLd\nqDAoHfQCxjkwCgYIKoZIzj0EAwIDSAAwRQIhAKWSyLqNRwps1hTMUDGRJYpxZw5K\nlgSWZny9efh2iHKxAiA2mPDvJ3lEBM87P5OfsOi62ihRFsdF5oOSdsnVNW+dlA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3660", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3660` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISASwjSE9wwqlnyfDighWYrvceMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2Mjk2MGNmLTRkZDAtNDhjNS04Njg4LTBjM2Q4NWViMjIwOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA0YTIyNDUtYjQ3\nOC00YzdjLWEzYWYtM2FhZjA3MTc5MjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6QUux50m2KAJPlGojdy02SYue+9z27amYih6tWkwlduyUo/YMgWYuxsRcFw3\nC9rNFPAj70nEKAwqsMLcBsQDDqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8UqERvuoT9CrgA80MQEPePKJxK0wHwYDVR0j\nBBgwFoAUBSxcfqPsauuxG0R8hLAuKq7Rm8YwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAvvR+\nnAN+WC4D6ip4u6YFVJQpTLADvQ6TBW8/xyxbntMCIHGwzWcVD2u+PxBpzj9ilape\nm1WBPRD+fenYXPD9L7Hw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfXdHlxDBtyLYvchN8e05nNGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjI5NjBjZi00ZGQwLTQ4YzUtODY4OC0wYzNkODVlYjIyMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUYebWZJQjWYLmlz59bXxd5qIHf0OrR+sxazFGKTDEO7QE\nQng3DDik9mWcPSsaaMgb/IjfKHH+yGjuk/2fO4g2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBSxcfqPsauuxG0R8hLAuKq7R\nm8YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIvu01xn7smJElqALsTF4jZMketDI6xFDuql9BdfKK/oCIC7rpFqKAG0O\nB++PQDAkvqfrI8Bavt4cpXr0HpAIVoig\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAQajTJD8Xk3U9j60xly53tMKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA0YTIyNDUtYjQ3OC00YzdjLWEzYWYtM2FhZjA3MTc5MjZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWM2YmJmOWMtNTg4Mi00\nOTQ2LTllOTMtOWYzNWRlMzM0OTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVb2iRSmOjA8VpfeOP1jVmc+pmMFRbOOD08lpF9/Kdsf1HUGDJfiVTbXHNgBpFfmt\nHKGU1NZ3cA7zLnJCCmsIv6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8UqERvuoT9CrgA80\nMQEPePKJxK0wCgYIKoZIzj0EAwIDRwAwRAIgA6ZJdMN34hTsXciME5QXi/zxiLrQ\nPx2Mw6tJfBkK5BkCIAr+vp9SSnDP7GHFxsL7AXI+bfKCPvTLK86ySn58Xgel\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3661", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3661` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATeg4EZGZQdaeSSxrBtk1C0nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMDRkNjI0LTdkOWEtNDVmZi1hOTBiLTYxMmVhZjQwMTcxMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjAyZWI0YzItMzhj\nNC00YmFhLTg1ZGEtZjU4NjhjOTViMWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPpaJZc5IiypvTD2MmXl7eTDJQFyuH3SfKylUJPEN6n6wxrOkX5omz3Pw/4st\nWATdDoypKtjUSaf2a88uegHcKKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFO/djjzYjU99WER27f0HWkjp30I/MB8GA1UdIwQY\nMBaAFKIPssUfnUWTVXIMwPVhHlloLekuMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAukrezK3sALa/wBm77wN40mmQoVVBdb11\nvQ3lly5y/XMCIAU+OmVBksLKZ6mmDO74Zwuwt46RZFvV+UyUSiLSX1JZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXqieqhq7JcqnRWPZCZyR4EzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjA0ZDYyNC03ZDlhLTQ1ZmYtYTkwYi02MTJlYWY0MDE3MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/Mp/+/Ctmrkr8IiWn8dckzwuLOIComwRr2lXo6nK3SpV+\n1Elc1NOIcZk5QC3amfZN/gM42fj2EkDz4Kf91bUao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUog+yxR+dRZNVcgzA9WEeWWgt\n6S4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU1pVOQ1U2rRy1Ak4O0ma4o3tGJOQr90TTc8WsX1mb7UCIQD5uHz+QRDo\ngRELoOlqccnNQRkYW+B9pikARdBnwUfmLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAab3xemvyuEDHM043HsU7IJ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjAyZWI0YzItMzhjNC00YmFhLTg1ZGEtZjU4NjhjOTViMWQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2FkYjQ4MzgtMTk5OC00\nNWExLWFiMzYtMjg5M2ZjYzBjMWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndptd52fB2ibVCK/Cc2T1QV3VmcL+/qO11vQkoq0ToVcWo+57qgC4f+yFQLf/NVZS\nrFdIDele/YG2vP+1zTkKI6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU792OPNiNT31YRHbt\n/QdaSOnfQj8wCgYIKoZIzj0EAwIDSAAwRQIgeQruV9gNNbhImSH6VYbqgj099IKw\n7jlo9iggXylztZ0CIQDfknPJCx4Qvhp9wjLlfGc8IPifpfkrdOUIIPDHPz+s7Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3662", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3662` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbkUHZlOyKUz3C4lJEvgBJgZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhOTBmMWZjLTZlMTEtNGRlMS05ZWQwLTdlNDNmZmM4ODE3NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDUyMTczYjctM2Fj\nNy00ZDNjLWJlNGYtMDM2ZGJlY2E2YjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESECd75xp4Vp6c1cJkNfFOHLFgQv1mvO6IBveKn/lbhvp2WB+YsukqlIt4QvY\n0HZlO/NOzWnq5fM1Mn4pjMr95KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOkP8NY3HVZ7pG3X+M1VJKp1JoXQwHwYDVR0j\nBBgwFoAUEwaHalPMCuusApbeOPfheDMSwpQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgQQjNPqcMKNdk\nSfmWYtIm0Ytg+l9zbvMJzAMP4u9a6uoCIQD0gqYikabIf1g6y+xJ99iR8HwOTr1D\nXMeC+IZpJw/Wsw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfJQwyZKNtNqc9kCYTuj1/2pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTkwZjFmYy02ZTExLTRkZTEtOWVkMC03ZTQzZmZjODgxNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7QkCUqzPTPdl49CbyZX38FCRO8Hk5SxVfBGFmnpoRfTKk\nSfkV3BhFNj9Mn5U2JJ5WxqLKZtyuWm8kNiKaEtm/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEwaHalPMCuusApbeOPfheDMS\nwpQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMtQJwK5bt8tlH9A8V4jRHAzdNJohaApzVgYdEG9D3DRAiEAt92Bw6JT\nCJrY2YhFxDb2GafHMlDJoRphSXyLmVxh5JU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAUodwFgm5jbrp8QFfdu5VTtAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDUyMTczYjctM2FjNy00ZDNjLWJlNGYtMDM2ZGJlY2E2YjIyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWY4ZTRjNDQtOTRmMS00\nZTRmLTg2YTAtYTkwYzk1YWM1ZGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLShxDYxSExbpBpp9W2lwF2JL1npelArxoUHDZ+Nk+ByVV54e51dtscXu0XwM8Wgm\nTW8UrPknPrE6DJHyswcegaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOkP8NY3HVZ7pG3X+\nM1VJKp1JoXQwCgYIKoZIzj0EAwIDSAAwRQIgErS9BcsjwfcE62MVXy6A3g3uZ2RS\nVXyAeEzeZq89ObcCIQCvAM0YoGjrdzPe+FGLolc26AvIQBBw9AedcBKBdttIfg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3663", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3663` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAQX60wHkMjHl1SQsiCW5hmVJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5OGY0OTVjLWVlODMtNDk5NC04OGRlLTZhNDk0NzczY2IwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU3NzM1YTktYTA1\nOC00Yzk2LTg5MjEtMGE3ZGU5ZWNlYmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQAezVVhaXMa19Rxu5T8rpbZUs1t0IIbOm/RUkL3wriDs+mohM0XQA0TeFNR8\nKOswe0G9bgUUaOEsHJTE6JYPnqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIKhTT9JT3aBIIVYjgUwQm+3ivpIwHwYDVR0j\nBBgwFoAUSN4jEeGMONjC1A5AKCjSYUsaxwUwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAL7Y8XqYzw/A\nWxRmk3Xx84SDxEqvH1OazSA0eMrvheShAiEArzXPGIIlqj8M9D4MAkKfbRpDpmKv\n+nBUQZYBdmrcPIA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQEXQTUmxb6YKAPBz0z5PuhxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOThmNDk1Yy1lZTgzLTQ5OTQtODhkZS02YTQ5NDc3M2NiMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPW1Z8Zq46gYJTkVvOlDXi0seUVLmT7UHaLUFnqPZqN6Hc\nzQFSdlwL1lq0qyndtMJUTF1k1YeRfbykWO+kHIiwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSN4jEeGMONjC1A5AKCjSYUsa\nxwUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPCzQcSYlGDY1Cc+vzhVEORdIcUAssr5VYh/XGzZCbqcCIGJty6RyTAV/\nKoAVe/xbGtgcG74EG2Yp4VOpfUWdGkUU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAfJnluhgFRDcmzU/0KPSUh3vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU3NzM1YTktYTA1OC00Yzk2LTg5MjEtMGE3ZGU5ZWNlYmZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGExYTZkOTItNGFkMi00\nNWYxLWJlMjEtYmFiOWJmMWUzMGQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noeZwAjBkyia5jWsBGNfBZ1SHoh3OEFGCPNACFyJ6dWE0zjgYHMiYylpaRkbEJUGY\no8iBdWDX5kUGwSqbdH+zhKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIKhTT9JT3aBIIVYj\ngUwQm+3ivpIwCgYIKoZIzj0EAwIDSAAwRQIhAMCZevgCUH5eMG9v8rNGdve32eek\n8Yx4Cp4aLSMei1UIAiBGurim6BlSUCYpndvKe92ecCKs5U9a2bABSLZkRq16cg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3664", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3664` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAcPCzsPw7D7qS38zei93IWyVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxMzk4YjVjLTAzZjEtNDliNS05YzI1LWY2MDJkMzJlMmEyMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE2MTIwMjUtZGQ2\nZC00M2NhLTk3ZjMtMTg0YjFiOTBhNTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2cY2j40XB0esjSXZPLdfeBwLomh1xH/s6pcCLFyY46+3HKwhLJHfs8pjcF20\nuObOB+MHoTrQq6StLwBtcWSkHKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVtRIqQ/XPAoCFjrlkch9A8QuqTowHwYDVR0j\nBBgwFoAUdS8DG5STI+0r1g3jrgpbEsT0O4QwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCID03lShM3TY2\nKY1XxEVXfWA7LClb9ziH5nTHa7HthKOwAiB2ekww+i8TeAo58uGrx4THP2FQyDLd\naA8Y4pEUrp4FsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZje6R1iWP3FMsBfn72Dz99yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTM5OGI1Yy0wM2YxLTQ5YjUtOWMyNS1mNjAyZDMyZTJhMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzqiiOUdw5rFe7gfA0OcGF1NiDm6GUmXyiptcRvgN94Tkh\nrBO0sgCMgjSv+8ngRiu1w1aL9+6zuFBkNKibo9y9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdS8DG5STI+0r1g3jrgpbEsT0\nO4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMnN97jhFNjbvEgBKQXWwvRTLB4olJU61CPOYZV3OWtXAiEAy3pB2Ukt\nFjOn2OVcI9GcEhuHOjn0el+PCBjKcLoxzAY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAVQJl7zlBeAS/7RwgLO06viHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE2MTIwMjUtZGQ2ZC00M2NhLTk3ZjMtMTg0YjFiOTBhNTYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Y3N2I2MDQtZjEzYi00\nY2FhLWJhNTAtNmYxZDNmNjgxMjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6A0dmg/4PmfCvs7cWnWlB2/YzdRfRbk1s3H6q6Su+zqHly64JIcHkxeHW4zOK+Nt\nec8RzmOBr5OUVI9T20PQ3aNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVtRIqQ/XPAoCFjrl\nkch9A8QuqTowCgYIKoZIzj0EAwIDSAAwRQIgavBPF1gsXfsZ6cQhX7gyoBrbD/Cx\nJMxhfU9KUJ8ruG0CIQCNYzqmN1UlG3wCeNH74yG+dGDCUIYx1UTDBY3TflSuqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3665", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3665` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdxZ4PPquYWgJJ3EH+Lu3XG3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1MDdiNzk3LTM0MmMtNDE3Yy04NTdiLTc5ZjhkMjAzNzNlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RlNTU4NjgtYjgy\nZS00Y2I1LWI2MjYtOWZlYTNlZjg2MWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy77CxrRNNJJKouBKyJDvrd7K4a+DvFlTU7DwYQxO61OYif/z5Pj5X94tvrV9\nviG3MCpaJKGW+bocr7o2OPk086OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF3igrETJzqeChFNqWcBvlWxTvsowHwYDVR0j\nBBgwFoAUubr0IW8W6g6qlR7iBRKvt+jcHrYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDOwylHIdfc1kRi8qxwzh2MAJnS06615XFNe3GaxfPH7AiBlZ/3yPK1LQGcx\noaoj0DiJNgASpkzUXxrmNOx7JgvCSQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUE6vjIBbN9FfH/gjMGJpf2AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTA3Yjc5Ny0zNDJjLTQxN2MtODU3Yi03OWY4ZDIwMzczZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQz9hZM4UWs4NiSlnaF5ETxjUXGym0MP83vfjsUSPTghILr\np34FMoXbMwWls++Er+6+8QV1jxSdZ+Ixi191jDmuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUubr0IW8W6g6qlR7iBRKvt+jc\nHrYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO8lOanE9uF3o2XW/jaC13kS6CW8IR9g6SdoLoY2wIxhAiApPYhJ+aut\njAidbh6ed+vf2phe0yFMWg3NdZegEeUg/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAehrRD0/1daUhWpiQozsB0M/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RlNTU4NjgtYjgyZS00Y2I1LWI2MjYtOWZlYTNlZjg2MWM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTIxYzg4YWEtNmFjYS00\nMDNjLWJmNmEtMWE4YTkzNzhkN2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0Kbd8ZeatpuDjkcCkxt59+bK37Xuw9uegJCoHe9+NOpzRUprtgbKp3cqkiVpyTTb\nt/e66Gn76a/2rub34vqpXaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUF3igrETJzqeChFNq\nWcBvlWxTvsowCgYIKoZIzj0EAwIDSQAwRgIhAMzm8jpWgLSSsD7GIjS1NcWOHx6T\nXbmYJuIl1SoJYXvhAiEAvg8EfIHRmgfUdQ0EetShZAJSwlt306H0yDPjf3xNkmk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3666", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3666` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdtB0kkCah8ov2OYSKxY++9eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwNzE2MTVmLTIzMTUtNDMxNC1iMTEyLTc1ZDQ3MWM1OTMwNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg5ODQ0YjItMTMy\nOS00MjFjLWFkZGMtNDg3ODZiNGIwZDdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6XHQkpCnIIEAdAytHsBQJYXMHTSqH+/z2r0EFh9q1P6JKdvWG+Qg3dRV/4H3\nOrYLyWC6CybfaFkqjOhziGHZDKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUwh64bRDzqJmETZoIphAf0mCyWgwHwYDVR0j\nBBgwFoAUMnccxG8iUlomQaiwevDv0ZquHPswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCAjtUSYz+9iwkpGe3HNQClBTeh0Dl5i6ApCdmfC1UOcQIgCOof20A6KTqL\nTgcVOmpu6r5Je5O0wRW3cShL8Hcuw0o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARLDhRt0h4L2ItybvbJTpofmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDcxNjE1Zi0yMzE1LTQzMTQtYjExMi03NWQ0NzFjNTkzMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6JYAY/x/fJIBFK098SJM47PksnekNraMryxWfki3gR84h\nq1YEJmXhjLWcl+mmO0UUg+JRvfdTE0/MrHYZ+vPao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMnccxG8iUlomQaiwevDv0Zqu\nHPswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL2KNLx7Sy9h+SXD8tqgdY7slIIZa37C2Nn4IKR5yviaAiB+7yzqtc5M\nUWEqoolt7QpRAdfwPQ7CWnNqWk3lUWEm6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAZcZF8CMaMmuxQdezLO9vD03MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg5ODQ0YjItMTMyOS00MjFjLWFkZGMtNDg3ODZiNGIwZDdmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDI0Njk1YjQtNTMwNy00\nNjJlLTk1OTMtOGRmZWQ0M2Q3MTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDOdShHzA4NxKNIP7WVUhAA/d2FuMj3BdxOn6tUH6uOIKP+hTXGOUkZGO8SZWmuna\nSAh4YdEpB0/ogqF0hIMwzKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUwh64bRDzqJmETZo\nIphAf0mCyWgwCgYIKoZIzj0EAwIDSQAwRgIhAPUMsyHINHuy8oEv6CkQFHKpVwdO\nlrrRfgDTj7fiGhXfAiEA//HJ8hYZ3GKUXH/oliqZNT7mjvGmn7TjVXo42qigFF0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3667", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3667` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAUbCondm8wN6rZCCfD3P3/BmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3MjRiZDAyLWE0NmItNDM1MC05OTNlLTdkOWYyNTAzODg3NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzFlMWM3ZWItMTAz\nZi00NDhjLWE5MWQtM2YyZjliNDljYTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgULivRMQZ8mc4wBukbLJrmtTT0APMwUEkSc4tcAJbC2K2ykRmEgM5ziqpYH8\nr/HSNvDNoDOkDa/Piqj7R3rcw6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8r27pFkwhJreQwD5fx1b7FE9VtIwHwYDVR0j\nBBgwFoAU8+zh73c+vznjKI+Qcd7JHFnVf7UwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFg3\nve9A+kwi/elm95XN3LETJ0malt8YLmf/esBb1wL+AiAUObsDSGTqOvDgNZ12w8C9\nuAh+PS66U19VSuVcwojNBQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWVBANtB+FAStvlbX0R27VORMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzI0YmQwMi1hNDZiLTQzNTAtOTkzZS03ZDlmMjUwMzg4NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgVaKVC4VQqLvE7ahzx/9/Jtup+JaMh8ybfxss8cNrBU9J\nKHn9w2CPr1wEyxy88ruuVpA9OGQcxl6DAGiFXqK6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8+zh73c+vznjKI+Qcd7JHFnV\nf7UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMXSmTFF2tAx/vjpeafH+Rkt/TIwagzyNuIxNFTzoeT1AiALSJZLax6L\n2ZusQcIFzmAD+LTPMZ5EbIBMDCpbQHm7/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISARjlITkWYyMkzrm+4aGzzb8TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzFlMWM3ZWItMTAzZi00NDhjLWE5MWQtM2YyZjliNDljYTZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDZjYWZmNjItMTY3MS00\nODdhLWIxMGYtMDBjYzIwMjc5NGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBe7D56i8prBK5DwFX2n/hePOt/UqTak3D/joltuplGa/7bHvgUrACQcZGAUD7UKm\nbzl41eOtg36T23H4blWbp6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8r27pFkwhJreQwD5\nfx1b7FE9VtIwCgYIKoZIzj0EAwIDRwAwRAIgd0UvEfcGHUWboO1Y2WfJUdcAJjLb\nKPaOWpV3wRw3MLkCIFwBOgeuLcjzleLsvyZDZrvyBB4/X5F/JYYuMVhiS7eZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3668", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3668` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQe0XTOSFCRndLbqOgMnfSUNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2MGNiNGZlLTUxY2YtNGI2ZS04ODUxLTU1NDhiNTA0ZjI0NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWViYzAxMzEtZjRi\nZS00MTMzLWJhZTktZmY0NWM1ZDU0NWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE16XGIm+bxxcDIa9sMs+MZr3HIunrG8JIMhKAuK+cDECmFJs6zC5XZJAx6N5x\nsWyEiNhHyXavNCwD+9niaPf2JaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrA32yA1rEEv6fZ0ZlelvRneoh+owHwYDVR0j\nBBgwFoAUZLe43i8gJQFHT5ebn/8MfiG/KfkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCuxKzfdBQ+gKx3rkvU5rxjUS4PV6JefX67TNYvwU780wIgP+GU\n+kSg1ji07IhUqsuISAE6uxfY+iWgZ50nawLBPFg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQbaEtDikkwaIORWura/elKIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjBjYjRmZS01MWNmLTRiNmUtODg1MS01NTQ4YjUwNGYyNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASF2DGBnkaMNhCynBEkA9ex/LNV92Kn3deoiUbNjUnegri7\ndVXvLW9Lyp2bF8cHF+vT4Rzj2t/NqrEbaAT4zxwpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZLe43i8gJQFHT5ebn/8MfiG/\nKfkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdCCbLfxRdUYbztztcmnZJXTbCirYwLgIAYk1OQIhBAYCIFIpaMa/IEUy\n9YSNjXqr4pJ85wbbaf9WvUQhlhKcPsWd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAanlHERxV685m9AIIo9yDV2FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWViYzAxMzEtZjRiZS00MTMzLWJhZTktZmY0NWM1ZDU0NWQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTk4NzAzNjUtYTJlOC00\nNTc1LWExNjgtMTNmN2RmZmRlOTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndXRaeBzIHBYvUssooCa7rKtEgrS+MfGlAw27bnovue2/Dq3lyykRLcCwI9GTsacD\nOnRgApaT6OkkdKn9W13oAKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrA32yA1rEEv6fZ0Z\nlelvRneoh+owCgYIKoZIzj0EAwIDRwAwRAIgIASzZfePY+Y0pqRm7OPYA79uPJsN\nsUJR9O00QQxmg4oCICBTeNU7W90+v9PlSArGs7ZHpR7jH6uZxVPsaRgCsEBr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3669", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3669` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISARQm6Tc3SHoOuFUnIuCZBkrTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZjQzMGRmLTJjZDgtNDMxMy04ODcwLTVhYzNmNDJjNjYxZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE1NWQ0M2ItNjFk\nYi00MDYzLTk4YzktZmVhOWIyYWY5MmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdg7c0+ao8KoJ6Njof9lwfNJZ5xhTI7QnrIn4+05rAoqCMaZ0fwLiDIFr35AB\nSoFWqnURIwNPhmsltM1lE/tbBKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIFkori0y9XdtfctEVttrjcnLXCwwHwYDVR0j\nBBgwFoAU0ECtX3kBU7S3eQlyhNiqNWyj2ZkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCxLmaZ851D/jo53czhZyky6X0vnUyKw5q71g0MSd66YAIhAJbv\nClGLUPZc6HG3R6cY++ZQhrgAYBxwqCIJhya4HLlZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASFHRb2DWFwplyG9Up5uwyc4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2Y0MzBkZi0yY2Q4LTQzMTMtODg3MC01YWMzZjQyYzY2MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqBRuwHpa3gnVqlLAPfXJUJQCCIJcPSnKOysgIdbUaX2By\nnnMRXtsREqHyxLhigtSZauSJh1DG4D4sqbi3AwhAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0ECtX3kBU7S3eQlyhNiqNWyj\n2ZkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPgivHSZPxHvtUKbPp+UscbCEZ4abalp8gHS87OpzSshAiB7r7Fq8Kcm\nRAFW31HwNmUAttG8I/wOmkGnXKPN5bj4Tg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAd5lnhMq09pLQ8ev0GZZEL6uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE1NWQ0M2ItNjFkYi00MDYzLTk4YzktZmVhOWIyYWY5MmY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjdlZmVhNjItZTZiZS00\nZTRjLTk4MTAtMzBiOTcwNjhjZjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqVBPUEDoes02soQHfn3+UDINhIEKcRc4g6TuwvEzv4RAeyyY2LP7DWCFgVkT2gnn\nkaDAb3nEicvVHxLTrNXJ3aNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIFkori0y9XdtfctE\nVttrjcnLXCwwCgYIKoZIzj0EAwIDSQAwRgIhAMH2sz8BwexMwKiW9foPaj0dRIRN\nPp/kPfPe2B2Iv//MAiEAgl9Gz9A3CYr5hJK94kFnLzKaleDep5mQHZptdMPe8J0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3670", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3670` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaf0ryqNX5KUvsh8f0nDaxn8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2YzhmMDgxLTc2N2UtNDJhNC05ZTU5LTEzODZjZDUwOTYyZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI0NDE5YzktMWRj\nMy00MjYwLTk1YTItY2UwNzA4MWFiOTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpv7TYB7a52mOAzOoTRMl4ZeHStJH13RmqtuMZYHB/16rX87W3kpixLP0KDeN\nTzfc4DESemwvpuquOoO7FyFoYqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMpdm4Ql6iBAvzq1sOhHrwHRK96IMB8GA1UdIwQY\nMBaAFOglXt9Wz2Fzar9KCpQxtSUxbNn8MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBJqhHp041TKFnieio/9nGvVoUJX2l/OuCG\nhi6vcII3NAIhALeYHMd4UzW9dIg6GCkiNDK1341tqTGVJnZ0CljPOB8E\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS9ZsOfGxW7pnJPEcveou8uSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmM4ZjA4MS03NjdlLTQyYTQtOWU1OS0xMzg2Y2Q1MDk2MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQa3JQWtUosRcWWx1BUL+b8CSEgq0p4v+tdb0KFTQhhAe2q\nrpMigoTOqtBsWPCt4uyQlB9tG6f8BYRbAad9Ooqpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6CVe31bPYXNqv0oKlDG1JTFs\n2fwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLAl4Y9DB5PtTSHBWO4NfZ5fTrXVO/SbBolEz3kjyx6YCIG7cDPf89Fab\nlARdQoKukvMCgLSmHZaxeWwBxTcw+wb4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAbL2+j5VmawYHNseOPRplP2yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI0NDE5YzktMWRjMy00MjYwLTk1YTItY2UwNzA4MWFiOTliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDUzNmVhN2UtMGNkZC00\nODdmLWJiYzgtYzJhMDFjMGYwMmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTwR79QvqljDcJhyDLoSkL0tec0y5m3X3eK1mfIRqJ2SEb2DJZWSjmLGBQDhQPgtn\nZc1CKZkXJEweqJ75+T6Zd6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyl2bhCXqIEC/OrWw\n6EevAdEr3ogwCgYIKoZIzj0EAwIDSQAwRgIhALLatehoP7TIq9B9lvOES3bVODIU\nypSLwK9dTDXOK7j6AiEAmpgDUOrbt4TuMSA9rwdHPHkPKOwhQ/pTjiDIMb9qSOM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3671", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3671` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAa/22qO2pdR7syLCsIcKcduEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyNzUxZGQxLTI1MzAtNDE2OS1hZjE2LTM0OGNjMTJmZWM0YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg4N2ViZmEtMjc5\nNS00NGZlLTk3YTMtOWNlNjRlZDViNThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFI0yTGz6T6LTz+ZtrqGYDWLZCMw7eTx5xc487fS8EQyZn5CkfR/SCvsSAl9E\neh4sH27hjjMoqyZ+RvOi5vgG0qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFOddqkYxoK6VUJesjLEN/2qO/2AwHwYDVR0j\nBBgwFoAUtTxp7bq+mmzZ+Q85YdHX1ZYoLHowKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPH/EvOI4mrt\n5o4vo6gfYWyyAWCZEgMc+CE0CPIjED9ZAiEAsvl/61oaw7p0YbC+up0lVn4HfD7D\nhsr3iAhkbLOjeEM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeQaETAIR9NRDZJjiEd4T99VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjc1MWRkMS0yNTMwLTQxNjktYWYxNi0zNDhjYzEyZmVjNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbRQjPRj9vvwiU0x6RpB9HwF45zvMpgfU48BPHtSxjfzsE\ndMgy1eSXzTAwaxcovMvkPQpDSfDCmeJO47Zw8gewo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtTxp7bq+mmzZ+Q85YdHX1ZYo\nLHowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOivjTr3iEqMeIcXSfeHUunUk231ZTT5yTWDp3URZKYjAiA3bqqWa3Kk\nIyIU2iLkzsGwB1uPmC4dGs8l+jJPNBXHwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISASFTagUXCUB4D/zVJkvLw1JXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg4N2ViZmEtMjc5NS00NGZlLTk3YTMtOWNlNjRlZDViNThlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDFhMmVmMDAtYmJjOS00\nYzYyLWI2MDEtZmIxMTFiNDFmZjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuV22K4kIF1KUVW5ICENWOgfLhfhkldaGjjFDgBGaStBYeXgOdGG8NPxq/HlJ8lwk\ntKaGtHswxcV25O24qQVCwaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFOddqkYxoK6VUJes\njLEN/2qO/2AwCgYIKoZIzj0EAwIDSAAwRQIgFftrV8RpNYkbM3VUdWrY7EGwVW9J\nW33BtcJvyBxMeM4CIQD6iyyBlwYaHFa2PN0XHM+vCmny9BHudtMTmYTGlQJpVA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3672", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3672` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAY1KM5clzvu+uTBPzNmcU3JpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwNTZiNzE2LTQzZjEtNGQwMS05NTFlLWQwYTlmNDE0ZThlNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZiYzYzNTUtMDFh\nNC00MWQ1LThlMWYtYWI4ZGUzZWFmN2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGme9bl40t4FFQLNLIHEundH28i544vsOkBytz8W+j6L1zXxJr6H35Q5lgJ+x\nbJCtTPGbMEag1b6lTySxG7eJGaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOu31Fll6rhIhqDZ5QAyFJ7SsH9AwHwYDVR0j\nBBgwFoAUC3XIOylzLjgpEZNv8ZCzYnGa+eAwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgNHmS2zdoHDGF\nXEa39IlaVde4ZajdPCguU2qwCbQ5l6ICICAjy7dvR9kP3himKhrAUKl1YfHosESl\nStVeiD4VdNE6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUYmaMRewOGGdQeHmdiiw3HbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDU2YjcxNi00M2YxLTRkMDEtOTUxZS1kMGE5ZjQxNGU4ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8h9AaLMAafskcgdzWQ1wEN8xVguznLIM8t9T+x/n11JbV\n5Ha/T+Y9SfonVRk+h0CnGg4dIiaA2EVtIA4EUG1Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC3XIOylzLjgpEZNv8ZCzYnGa\n+eAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIcNq78CznNk0pHWRM/R6dkO9gvhn1Q0oJD4qydVNQ6UCIQDDcBmf65bL\n5OtrFvHdNF2s1SIWCatCjauINyHdvB2Nsg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAQELLn18BW2iYmxobh76+CJ5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZiYzYzNTUtMDFhNC00MWQ1LThlMWYtYWI4ZGUzZWFmN2YwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWMwYmYyNmItMTdlNi00\nNzI0LWE4ZmEtN2RjMzM5YTc4OTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nglVWP7y3nFo7WaqbKCvnde162Uu1ipV6Y5uFyoy8mEmUhhoUqb6GW+qlHMj4qA6g\ndH1Ovxnjsm5EYay4zavxDaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOu31Fll6rhIhqDZ5\nQAyFJ7SsH9AwCgYIKoZIzj0EAwIDSAAwRQIgS2ODtrewwPaeKYr60n8YQCTpT6ip\n3sLf6r3wdLGS5TYCIQCJ0zaD2HYYh5oxmUY1mWBaaDZ5PtPiHXk52n+j9DH1xQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3673", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3673` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAT7dOCK574rRx5CBWMnS+sg8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiYzkzYmI0LWMwMTktNDYwMy04ODgyLTZhYTU0YmM1OTBmNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUzNWM2MTctMGE2\nNS00ZTc3LTg2NjctOGY5NDI5MjhmYTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4yauwLNhrndzbZdO7+xISHPnTJ87HbhH38RxI28qYvmILVKdVr0dvhf7JPGr\nupkb5PnaEvmP0fx7THyhmcE6tqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhTxbmPAbppfMux/+g8RpWi3QHggwHwYDVR0j\nBBgwFoAUOLr6Pe5oi3junHlX+JVgiAo8jp4wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIB8kLSCJ/LMt\nC1mO9SQfHCf30pde/fn293XHf4eB6TWcAiAJw4O9v8cQdn7g9oHPQ+l3UJFqGSIr\nw+abW0YLnW5+yQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcRcCjWibbIbyx5Dd11pHxfiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmM5M2JiNC1jMDE5LTQ2MDMtODg4Mi02YWE1NGJjNTkwZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbrXPEBFYZVOpoPUaPIfPiRl0OpqCKsBPJymGiVO7/6ZpQ\n96KxG95a9IX0mIP7iA2viLfWftArfmGK4jy3lwmho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOLr6Pe5oi3junHlX+JVgiAo8\njp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIHDolxoBh5cwuwVMKYiLjNI2o1dRgnXJBqRytAPWLUmAiAXAzw60D5V\niojvPnh/ccnKtX6UGVvJuesBKZOM8GwdEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAa8H+2+Z4mLyAvvB5d1RMzfCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUzNWM2MTctMGE2NS00ZTc3LTg2NjctOGY5NDI5MjhmYTViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2ZmMzY5N2MtMTA3NC00\nNDUyLWI2OTgtYjhmMDVkMDJhN2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOEATTK0e6WDORda/bJBLD/lifMsiSnJZ3oe05GGruhBQs2i9PYCiuxy9G02NRuyO\njLUY9MdzlrZv4bNobYM87aNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhTxbmPAbppfMux/+\ng8RpWi3QHggwCgYIKoZIzj0EAwIDSAAwRQIgK1V6aJj5Cc9whmXhEETrdk+JJU2x\nY/U3AA7DLDovxP8CIQDglqllodrGjSlk8OVUAF7P4yWDuzN3MiCzY44gu3s5aw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3674", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3674` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAa2LOXvVOxyCYoX+sRmIdlQ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5ZDBmNmFlLTA4MzAtNGZmMC1iOTM3LWJiY2M3NDdhNWMxMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM1Njc5NWQtOTE1\nZS00ZmE0LWFkYjAtZjQ0YjRjZDQyYjM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvnS5D0BqJBA1avQCM2EfyXKZxRD242DS0or2N1UFRfYOALDaQalqbLHCtm99\nqzRz6Nyg6zUT9JDBEm/J/QYSm6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+mtSy1ZsjY2jJzoEC11594fbM+owHwYDVR0j\nBBgwFoAU1xf8PsRpdj2olH6hycyNlNRbRkkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD/xqYCRR2fJ3oh92WiRzOJPFno1n5gYHEYgtW8fBwQgAIhANWeUyLHT87m\nivJS3IYIlDfIVIEFI1T5EsNnmSb4Y18g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZKGaGVXMTw5y6wIPHD5z36IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWQwZjZhZS0wODMwLTRmZjAtYjkzNy1iYmNjNzQ3YTVjMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRACuHaMNKqIbYwYpxPS8o5Mfaox/BoY3Lk8ZeQ9Up5O3H\nPxeGzOrUWuT7xjvYbtXBC1njckWBnF6aKJ4fUvFio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1xf8PsRpdj2olH6hycyNlNRb\nRkkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK1FVAI4keqvYHuAQTn9+4tRY5V5Fh1wL1ezJQY1I9zTAiAtbjDDBmQf\nylFMLy6H8f255DZDLJ68shyTyC3XsGiSew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAeucY7MATR3HqiP+BGmNR4fCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM1Njc5NWQtOTE1ZS00ZmE0LWFkYjAtZjQ0YjRjZDQyYjM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTI0ODUwZWQtNzFhMC00\nMGZhLTk0YTQtOWUyZmIzNzk4ZjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngymChd8opPfn6RCp60ky4+I9dFUkUBTWXg7rPuid03onI5VGzOKi4QRmLGDYfVT4\nsDPxDV3NFkMDAWPnoeHyLqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+mtSy1ZsjY2jJzoE\nC11594fbM+owCgYIKoZIzj0EAwIDRwAwRAIgEe18o+H4KvqiSRDgjGpN8ofsS3qD\nEorVw8N1MtZ7oNgCIF/kv9dQdX3Z3h93ND6OvARIHGHdpP3Biy1WltmeBtcX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3675", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3675` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAR+s3liR/eikYXP2IKsxzP+MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxM2RjMTMxLWY4M2EtNGMwNi1iYjM2LWI0ZDc2MTk1ZjA1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVkNjVkMzctYWZj\nOS00MzVlLWFkMjUtZGU2ZWEyNTkzNmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMGK6pJHZmAcIIvrjV2LoKwnVt4eKpBXEi6xcqxDq5ULPIIj83mUU0YRGwMbc\nbfvmpAgcoZO5+LH4f5jlW2Pa/KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2O+HUqWXXgJclcsoIVmecWxfAQcwHwYDVR0j\nBBgwFoAUYAyYIGn6i53rnKluKC/BOOjxwr0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCgAcRYgdm955y3x9tcszpnkwFi/N4XE4IaBhqoJjO7XgIhAJN3CSA9lyo8\nKNtWe7fxZnsBOTIhFFq6eauKCsRJBYYT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeYrWcVbq8rxZ80KeWBrOThxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTNkYzEzMS1mODNhLTRjMDYtYmIzNi1iNGQ3NjE5NWYwNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5+0u6QZ6M0kIGL4xpEEYpbOjOXo5ICLWX8Som5OMUEkJl\nYdQBqf/P2ONMs99iT5Otx1JcBT+1iIEqS+ICllcmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYAyYIGn6i53rnKluKC/BOOjx\nwr0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKqghr9mWiQOT5qtrcO06VXAcJ2FN6C1RUkjjDv3bfZUCIGaUL5dkGF7o\no5gSNwzsif3uTWz+hAngcfAMKzR73emp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAT90Pm0+vzMciefoFb/YixvSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVkNjVkMzctYWZjOS00MzVlLWFkMjUtZGU2ZWEyNTkzNmE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjM5NzMxMjctNzYzOS00\nODZmLWE0MTktMWVjYWQ1YzEwNzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9gNNSHh2dUE0FwKNyhgMQlbyktFP+7WjLSwjq/pblnMlLnoBy8I/ZcKzAkA/Ni+D\nzsPpUrMaYMOvYlz9oRbaJaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2O+HUqWXXgJclcso\nIVmecWxfAQcwCgYIKoZIzj0EAwIDSAAwRQIgMUW/vj3GXY2LYvGotk05BYYpKhkH\nVtt7WPJUb/4UFBQCIQDCDagKRsyxqbAOFu6nDgjdIJVriZK/xjx4Om5iD1u6zA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3676", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3676` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISARN5sYt2X6Agvxk3yw3dyGWVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyNzE0N2I5LWQ2ZjctNGJkZC1hM2E2LTYzZmYyN2M3ZjA1MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFiZjY0MWMtYTgz\nNS00NjQwLWJkZTAtMzQ2YjU4OWQ4NzUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQzfi0coG7msKPZDHStR0lv+XRRnmPe5DSIoC1rPZwXaMp5F6Z9qwleMolV3+\nhIHdmy77Bsde9gw+rxv0wtmsPKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWr6Q5HfkhYAm68gVM85CNahv+iswHwYDVR0j\nBBgwFoAU7DkWAw6JKanxLzCOc+8XX+gZXQQwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHgT\ncL9IFPXkLcXHG4BvHgTnAzTbOlRerCdQef234whWAiBStpc731vKgxUnxEuS8SBc\nUe/OrH33zRZJOZKR2OlLSQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdSyNtlNrt9aK+NPoD5oFi2bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjcxNDdiOS1kNmY3LTRiZGQtYTNhNi02M2ZmMjdjN2YwNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+C5YM8EnpINL7tHYZWtpgWdshkscQhKZ9hy0YVGh/xCt2\nQ08hff5BcjVofMCkhcq4126ZPMyLLxP7p77v5bp9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7DkWAw6JKanxLzCOc+8XX+gZ\nXQQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUMDQt7xTGcQwrO5d5CgUw42a/OMw8YonpHkqKWF6CkMCIDKEjKrRSrxl\nONwNhUCXpfiG+qckJLFxK9nqSBCzs90+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAdj12vb/WxNRtHsuMqSG2QuyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFiZjY0MWMtYTgzNS00NjQwLWJkZTAtMzQ2YjU4OWQ4NzUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2NiZTMzZTAtZDIxMi00\nYzQ2LWIxZTUtODVkZTU3NmZhNmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nU2/QT4OxuiLNt9pTRktQRWT8E+7c5/9r8fZEFCvySDJ3iscJ6IXfpyciYo39cMGx\nOmokZuYXtf62gNZMqa31i6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWr6Q5HfkhYAm68gV\nM85CNahv+iswCgYIKoZIzj0EAwIDSAAwRQIhAIJocv7HYkg14ws4Thbk4LBW4Uds\nxciVgalOT6g1COHTAiBmlDdTk2xSWQGk1rxS5KfhIGSaJfxzeS/jjpVywB8+5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3677", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3677` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAf0AFS55Fi+UD2qnCco7RXJSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNTZlYjEzLTFkODgtNGY1Ni1hZWIzLWUxOWQzYjM1YjU0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM3YWQ3MDAtMDM5\nMy00YTY4LTk1YjEtYjNjYzdmNjI1OGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYokAYHGOFOt3ZtEYVRzn5hA1Jsz4SlAGOfT/AlWSpSjCl7NPd1TKzS9Ep4s/\nIaaKY3DxkcWdRE9Oyiprz58MxaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqo6ECmko5QcLm369KplVcWtHQ8wwHwYDVR0j\nBBgwFoAUpzCMdsZPfrGLvaTsHYDWPiGEM9YwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIG+soPcQ4a3q2FstDQ70ZJ7XN1rG5blIsk+CyO0nh4dUAiEA6UYo\nt65Qd3Gb3Xx+Vn9J63LhqNhkp2OnDp0I2fondW4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeDuIG+cRhAEGgJ8seKxUCP0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzU2ZWIxMy0xZDg4LTRmNTYtYWViMy1lMTlkM2IzNWI1NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQG1wR0+yNmJeY5RvEPY/oClPgm+WvTfymWOpm2PKa2ml0V\nNr9HxfkcPbf1s0rxXy8VUxkqvTGa0b6m1n3wlDsNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpzCMdsZPfrGLvaTsHYDWPiGE\nM9YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO06EeoOyYUvNyAW8PrJbmhOOrOoIndIVHzmdnnDORkNAiEA0GBi81Tx\n7GbROrfnKFhHjMG3vp5qyubaSGfbp84cICs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISARhSotf3QH1bzY9Xs5s9AlRtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM3YWQ3MDAtMDM5My00YTY4LTk1YjEtYjNjYzdmNjI1OGQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmFhZTdkYTAtMTAwOC00\nN2I1LTkwN2UtMzMyZGY5NDJiNTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvfsvdfnba+Ojp//GvB4oZ/npRlFpS4btT4MaEGS3ToOpiA8xqhGWTknUK1rrz4kS\nn20M1zbXrELqXlP325QYTaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqo6ECmko5QcLm369\nKplVcWtHQ8wwCgYIKoZIzj0EAwIDSAAwRQIgDnn3051OYNlYn+Z+e8e8eP2WhdxJ\n+0z7jGeJoG2K6v4CIQCqHieF2e8WhDD6AapyOB9euFW6YxEwSG2WAuu4s/Z0EQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3678", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3678` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATFrHAy9CMkDLwWCFcVRQMR1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2ZDc4OTViLTQ5OGItNDY0Ny1hYjQ1LTQ1OThhNzEyMDMyOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmI4ZmMzOGEtNTBh\nOS00OGEyLThjYWEtNmY3NzZhYTgxNmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeZpDKst1d+lz2/7mlzTITtmBhOyCd7LjViLlPadSiKqXckBrndReh5qGoMzn\n4Oodf4Pa1ZOHqUUg+ZxnCgKnfaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrVzEMbvzSo/5ADR7zWIP4s1UuXUwHwYDVR0j\nBBgwFoAU9YocPMmcb3QW//wQRwhwKXyXIigwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCBB+KMDaG/osaTwZmBR4aoZSlMh50V21LX2S0hNebuOwIgPGjW\nQE0atXlIiDDJByqvUPPCh0/60eu72KhYTOoFg4c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaqSoaUNO5HvBlSiodFAZS9TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmQ3ODk1Yi00OThiLTQ2NDctYWI0NS00NTk4YTcxMjAzMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOV79kTcUBQUEu/lgVVcxZf+ExLhjy8iiR0kc9GFBfA5ml\n/pvyzDYYqeztCi89Ka7I25f+cfKTcIW2V5zC+BuSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9YocPMmcb3QW//wQRwhwKXyX\nIigwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMbdlt5ZrpRep3UBCJSeR4DfpyRGU1iVsNnhRhmtWtVYCIQC4pfXXzqav\npJL0JJ896ibVUXbD7toIQ18GzfeapJ9k0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISARS456Nfc2/IkMW7AsocSXRGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmI4ZmMzOGEtNTBhOS00OGEyLThjYWEtNmY3NzZhYTgxNmU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTcxNzFkYWEtYmIyMy00\nMjYxLTg3ZWUtYmQ5ZmI4MjI5NjYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngiUhoHRZB9Gjul7VUAD0LBtscaAD8o6OX7FkZ0Q/w7d3/DSuDgRJ5ScUya3uNIn3\nWoe8GcQxftUXX2Ev5SyiS6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrVzEMbvzSo/5ADR7\nzWIP4s1UuXUwCgYIKoZIzj0EAwIDSAAwRQIhALitvPwoJcMtwa83OnsFuaV+MvnY\nnhsl4gu5yjPRD8BAAiA3pVng4i63TQdDzkxBJ6ul4f7eI/kKJkmoYLOGtG2yLQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3679", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3679` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAdTZ/thoObXbBQR1W2NiJAmfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5MmZlODU4LTdhMGUtNDIyYy1iNTBmLTBjMmZiZDViNmRlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZkZjZiOTYtMTkw\nMi00NWFlLWE1YmEtNzMyZWNmNjMxY2Y0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETugoLlWKO4LLGOfuXxWiqojXaqXmuqqlEhYNdGlZ6uPDm10RaCBQq5AfYzDY\nxKJ9bNwdzC73hg/ke6ZkCaRTB6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRs9rTBxSrLIuLBOAxHv+BeXk/86zAfBgNVHSME\nGDAWgBQ+j1qxCRu0ojx3cBLaQ/iV0fcQszAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBbSuQGWoi065zu/WnvrAsz7ByfTWLRy\nRtyQT7WM4DKXAiAh8gPzRvxGYJq+szVSYkn0wfNjYhVvPd8L29SGJADICw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXafiwNLkQLvoNUlr77MLGoDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTJmZTg1OC03YTBlLTQyMmMtYjUwZi0wYzJmYmQ1YjZkZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMiuZfReYfoVHCwGKL2MPOGWt/YsckJ0blB3hr76DgisRl\nIilc2OXPnOqXInsNOg/RPt37CbxaM7SjgmQQQLoyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPo9asQkbtKI8d3AS2kP4ldH3\nELMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDQI0hcGdB/HW9N/82VYU4bIsR2XsoEN+DXurw/Myql4CIH/1jXlV+8YH\nV0VvUtlmtKOFDE+6SLF0ZNAT+OfAqQR5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAZgEL5DwZ+S21uRLHSanHvWnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZkZjZiOTYtMTkwMi00NWFlLWE1YmEtNzMyZWNmNjMxY2Y0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmRjNGIwZTYtYmI4ZS00\nMTIzLWFjZmMtNzcwMDgwYTY2ZWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nm13z0ecZp+/orfV3aKfx3dOOtNLBvSDGpSJF3s5jPriZ9g9iNVaM9zcTMdIjkSMF\nhFOwX1qzefY/7hDFWYnk7qNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbPa0wcUqyyLiwTgM\nR7/gXl5P/OswCgYIKoZIzj0EAwIDSQAwRgIhAJuCTOenNxNosl4fE0T3Zv37yYdc\nSdvg+korBRKkBXTHAiEA5lNdgNm1efhtV3PRErgE4U7nFI4OttML3lIygB7LhcA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3680", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3680` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdhGkG9VJH4yyqXgu8+d7aDEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5OGQ2MmVjLTM2NzctNGU1Yi05ODVlLWViZDkwNGUxMWE4NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA4YTk2ZGEtMGQ0\nNC00MDg1LThjZjctYzg0ZjhjZTJkY2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkEI8YTy90CWCw7Vqj13wRrDFL7a3HTSURcC4yWXN7IXVqmmfAYq+jmf4XIgy\n/0Dthww/u5kfdDzaJnOD59auDqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWpEMaRLFBUfJeUgYgnAGbivO0nYwHwYDVR0j\nBBgwFoAU9/S3u8J6lFd48EX2jhcvRvLFln0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDHCqujbVidy\nQhGybDb69RmM8AI7wKeoCQ70Ap4mU8WUAiEAqPaogjmiZdLpu71DoUJWELL2r5iy\n58sUN+hA72rjXro=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATTcPlItppUGNRK4K1js8VDzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOThkNjJlYy0zNjc3LTRlNWItOTg1ZS1lYmQ5MDRlMTFhODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMIUuo/HMi4o+wncypr44dQWynG52KcAPejOnsSOpEEX/N\nt8RBLnugkwXPig5oABI+sXo95iUp1/mnQUR5a70Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9/S3u8J6lFd48EX2jhcvRvLF\nln0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNcdGWXmZwwHQUn8czrry6vU2HTDWLLeHROvw99yFqiwCIQDZfm5tIIfc\nH7yMsSU6D3+wX3JulwoiW9cJsvf7tWH+/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAZyUe42wqWjH1u/yq2yayrfuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA4YTk2ZGEtMGQ0NC00MDg1LThjZjctYzg0ZjhjZTJkY2EyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjdiMTc0ZTktNjUxZi00\nYmE2LWI3MzUtM2VmMGVhMzUxMmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPds3YXgFardJer9olaqvE5nlt0veiPV/Oa3MdxJWJLCiTYUSEEFB7fz4EGVcGXFf\nZKFCwAsKWjCp4BAo3zhNi6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWpEMaRLFBUfJeUgY\ngnAGbivO0nYwCgYIKoZIzj0EAwIDSAAwRQIgakMVGVQsmxEvzbGq7Q8+jOcl0k/J\nxOvh9OLVTQRvwRoCIQDKdjWCm+Ld0H6jwNjU8C5UccIfP6tnlPIY+ZYxi+C+yw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3681", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3681` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbiOWYFEJ/WcSog0ffksuU8WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhMThlOTQ4LTdhM2UtNDQyMy1hZDQxLTRjNzdjNjJhNDMxMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNiZTM5NDEtZjM5\nZC00MTU3LThiZmMtMDA4YmY0YzE5OTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVF9FQYWHMxpQ7X724HKDJF08IsVBYsiP8qc4r5w5Xu1C3ca95DbZ5Gkx8Ls+\nqvCaDZAh6MK2CvdH2RMcyW2ScqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfL9ITIZpE30Zm/xy5MNHXra2zgQwHwYDVR0j\nBBgwFoAUyGh0y+OY1Fkm63U7PviHYqux5xMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQChukUHrwDb\nb/7pIMBC8eqKqEJWqElTWygBGWbPIS2t5AIgW25sELln1Wa1oU8c9qIOmu9ifz26\na2orUikioXyOhTo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYGm+QKslmSjHrae9E/eQGk0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTE4ZTk0OC03YTNlLTQ0MjMtYWQ0MS00Yzc3YzYyYTQzMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnkC0vZGMbY/Uf6HVdcg+2n6iogLMwYTNPD8kbz6LMW/9R\nZQKgsZXWDprIj/qBjhObyTK4OKKUEsVLMQWPDUINo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyGh0y+OY1Fkm63U7PviHYqux\n5xMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTydUvFBCgW5ygVImUTEXOBgHxOZGGwAHGOiTSjEdgG8CIHfge07rR7sm\nbjVFV+9TTNe7XnnPnW3iuNHFRR3F9oo8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAXBB/zkHjRk7oJTODFOTT+9IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNiZTM5NDEtZjM5ZC00MTU3LThiZmMtMDA4YmY0YzE5OTJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWNhNTJiMjEtY2JlYS00\nMThhLThmMjktZTc3Y2IwYTk0MDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWO9/SZjGdpTfePpHysNQEhPWi8wKYyWvN5SUze55Ba+V+r5etlyCSJMBl0zZCi7B\nDTd/IqYWxb4s8rE1XGGmg6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfL9ITIZpE30Zm/xy\n5MNHXra2zgQwCgYIKoZIzj0EAwIDSAAwRQIgKQubkzwJblmLsbbSggAkAgf4Q5ne\nN4Qo/x9x8epHCF4CIQD5M9YUCCoEumYl1swbibpG1PQrGqOQnDoT+4h6b4kMnw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3682", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3682` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAbjbEM6BVdyxFtYIqC+byXyPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MjQ4YmQxLTMxNTMtNGEzMC1hODAwLTExNDIxYWZjMmQ5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc3NDU4YjktOTY3\nYy00NjVlLThmNzAtYzhjZWIwYTAwNWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEllvIkXhelxR4fHAuZs8dokuVjCipy89JkQaE128ESeox5OYCiN42WXafD86m\nM0J6vtq6b9thNdbWiMwqNuiOv6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfPQJ8taMkK19b7FRFlSrWfImhQEwHwYDVR0j\nBBgwFoAUOmczOOZHuqx/cmg6W57MLqi1Z8kwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBwH6Lr/awS\n11dpCFSLaslZhdHbwRDg97SpKDp1FKAflAIgSEafimGykfAACJJB42frGlBn9xSe\nvnAXZPqIk3gaRDM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATXxCadOV3hr/g+32cAER9b4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODI0OGJkMS0zMTUzLTRhMzAtYTgwMC0xMTQyMWFmYzJkOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjFtthxof68M7Ur2nEA8RSYEiBCPaAPisqifSjA7+5Hsuy\nAS3N/oQpcFVuogEpUHu0wSNTMIa5k3k9QBo71kHgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOmczOOZHuqx/cmg6W57MLqi1\nZ8kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeod9G/WHo4En/nu0MIf8Moo71ZoSSyJXKVK7CSZnatECIQCua0AiO/Sq\nouJE83/ZrbfNDM9LJHMJLq1BE9Hoc5hc+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAZ6IgKUG9sdpqxNtg7aN7w1fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc3NDU4YjktOTY3Yy00NjVlLThmNzAtYzhjZWIwYTAwNWE3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTc1ZmQxOWEtY2RkZS00\nNWNjLTg1OTgtYWUzMDI3OGJjOTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwO5rgCncEMYzq1nkJRgGENjXH+xjQMmRPkMoqgsV7pGhpAab6pVlivgtAG/y7kh6\nnJcuqPdsk+uy4t5FTB1mBaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfPQJ8taMkK19b7FR\nFlSrWfImhQEwCgYIKoZIzj0EAwIDSQAwRgIhAIT4iZDkCJpZFv3xRh1qcxGQyr9o\ng0fuZEjJCGXKziTmAiEAmzaYD043n/BGbYyn8ordPWaQRLc91aU/AsADMtmpPMY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3683", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3683` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAQcDdLTQJAgzy3JbHfUDzb0tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxMmM4Mjg3LWU1MTItNDNmNC05M2Y0LTA2NTE4YWVhMmNjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY5ZmQ4OTQtOTU3\nNy00YTljLWJlODEtNWI3NjcxNDMwMGQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz5i81xyLrkOPv+c0S1almDd7K7G7bE+ycqIV721O+idXHDVApNrexcnjVSFu\n8fkTLEnYMT9YWnIge0u5vafam6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh/qnHPR/8QhbjeuXZkbu1WRzzgEwHwYDVR0j\nBBgwFoAUkqu41Wjm5uc1Ej7Mk8BhUZ9Ie8EwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAvpD8UMUll/510KMbrnafN/DYNRY+2DI+hCtMqtuyxckCIQDB2FTUu6NI\nw+Ntmz0KX2c3cx206DWyCnLmiea20E96kw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARoP2zNnAiQQ00VBlEELNbx4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTJjODI4Ny1lNTEyLTQzZjQtOTNmNC0wNjUxOGFlYTJjY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQH0+AJdbrRAbwMEZ9iIutAS0ydi9UWRjn0roa9+uMDifWM\nwU7kMw1MS4JM0OcI6rv0eZqFT+RKWRshbsBNOchvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkqu41Wjm5uc1Ej7Mk8BhUZ9I\ne8EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEvLQhx+T3DVEtwoApUxfOfgpJGMdKznvvhR+JKcKYNUCIBRzHvo0np+l\nAntKPLox3OpmuRd/bP9cmbMs2VmIAJ5r\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAb+Gu2pVOjKlEy0t0FQ/yI+7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY5ZmQ4OTQtOTU3Ny00YTljLWJlODEtNWI3NjcxNDMwMGQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTQxMjVhZTUtYjYwNC00\nZDllLWFiMDYtZDA1YTUxMjEzYjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTZ8F72/Hvj7dJIr2gelJRmsQzKLWEybQeDV3zhDKXaTKHGgVKCZHgkb/gIzD4tJX\nhPnfDz94lNlBpnORYxmbgaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUh/qnHPR/8QhbjeuX\nZkbu1WRzzgEwCgYIKoZIzj0EAwIDRwAwRAIgCFijn/2kfJqbYeQLLuHQShH/aG1/\neqk8h76Xc43pkUcCIB7D/YCDqA8IqmLZE6RKGMu6zPZroCiaodMwHVJu67+F\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3684", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3684` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAcytNTqLuK2W/ikIrioGdn4/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyYzdhNWYzLTJlMzQtNDM5OS1hNzk1LTM1MTVlNGRjODFkOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTEzMzgwMTUtY2Rm\nYS00Zjg2LTg3ZWMtYzIzMGQwN2I2YmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA3SX1oW9POHX594lVUGoLgND3wQJ1r+O+wvbj0TPzxGVWiXCklYf1dHam0kv\n37wTTMtgqnh5u0PMTPn8CgPb2KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU56y3HI9MuksgUurdAqEk5sTR4tkwHwYDVR0j\nBBgwFoAUy5zYM1DYMFaXQhXrf6QCOhPbooQwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiA3So/bi9duvPoirSV7mAlxZRPsXrvfYdZN4LBRjDrAmAIgRuU11PthC+cG\nWZ/vpEO1xoaIZ9V3NtOrs1GqGyKH238=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV+Q3qYwZs9vuGQAPLwOSq/WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmM3YTVmMy0yZTM0LTQzOTktYTc5NS0zNTE1ZTRkYzgxZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwE8NZUo5fzqC7d2IvUfXDH1gil+pDk8BN7QyB+/rB84Jy\nG+//s0oPbApSDqJsZZqVRybmTiIG5ftQ3DHgpMxWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy5zYM1DYMFaXQhXrf6QCOhPb\nooQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKvD/G9tbupw6+yIoamBhHeifdY5dLMxClQupVH3aITcAiBpBpRNCdRj\ntBqZNNXxnFo+AqdnNeUkjuD2+XuevrdJ+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAZlJ5UK4S6oDr6LZG+E2AAzJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTEzMzgwMTUtY2RmYS00Zjg2LTg3ZWMtYzIzMGQwN2I2YmU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2U1MWFhMGEtODk5NS00\nNzI3LWJkMDItYTQ5NTZmNTgxNWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndjPGaK8tetxtNMrXz1Xq/rdMD2PAA0CKH6zDJSou0VVP0I2bw7e8b2/NsfHXH25z\nxW35otb1qBWeVyhP/NKpcKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU56y3HI9MuksgUurd\nAqEk5sTR4tkwCgYIKoZIzj0EAwIDSAAwRQIhAOmpVv7mInZHicgGQOTF1Mni+ksM\noB/o1dlCxdMP1XmvAiB0qugiooIG8UCaYtWIegIzcA8AcirrTaTVo1Yq8RBG+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3685", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3685` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAd8Rr4u5x+IjGNJVDEl++eOSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1OTlhZGY0LTgwY2UtNDkwNi05OWI3LTA3NzBiMGMwZWY3ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ5M2M5NDEtZTlh\nOC00ZGYzLWIxOGUtZTJiMTRlOTM4OTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMip817UI35JraPeJaJ5Oy3Wif+s/PTa/oE+EY2ahQLxfrkbeIkCZRnY0X1y5\nJfAV+gVHbskps758APIUPBWYjqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw1Qpmq0lJuxvFay7Xmz/nHoTtUMwHwYDVR0j\nBBgwFoAUTJyMFkOeVaLGXK13yk6Vx6qjB0cwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAf\nojlfYSG9UOO9P8Udd4NewdB4SA9CgD74/JfhPeyOLgIgIuWAJ1rpstC2sOOwy8H4\ntzLGuNMczGO76vkqSHYfPHU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT5HZ/FyBPnDTGMzbgc2vRt0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTk5YWRmNC04MGNlLTQ5MDYtOTliNy0wNzcwYjBjMGVmN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR92PX094yNHwTG76xFSLpXfp2NKptq+UU2O1guHvwR8cTe\nbcLfb2IlWoao7FAeqpxFQHN5aK5ka6ZrUvGdItvSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTJyMFkOeVaLGXK13yk6Vx6qj\nB0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH2pg7201QrzBT9QeAAxzkMCAgFl2MR72ziO1TxFHqnQCIBrTq2oDispP\nDbkrne2OjgbTmNfmOde+/QGwqfaQ4KvH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAf8rP65IK6Vj8MmyEOs6N/lGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ5M2M5NDEtZTlhOC00ZGYzLWIxOGUtZTJiMTRlOTM4OTNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTVkNzNmNmEtZmQ3Zi00\nY2VlLWI0MzEtMTlmOThiNWJjODRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWdW/WlrBaOC9K3K++De0fN5vLKcGCfw0qFJsVJOU84YfsQhzJRs+xSWaP4+xPnWI\nNehITT05qUflklQQu38UlqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUw1Qpmq0lJuxvFay7\nXmz/nHoTtUMwCgYIKoZIzj0EAwIDSAAwRQIhANdu44ta20Kc6kHk3eNgBQRWK+ul\napWAi42KuQ8pJMwKAiAINrsQAulKLZ7ZwJI3Ny3GeqCYVKHmJsDCBKhQ348v+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3686", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3686` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAa7e4w8jtgB+xC8Bz+xISv3AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ZWJmMjUwLTRkZDUtNDMxYi1iNDYzLTUwMWM1ZjljN2MyNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYzNjhhNGUtYTVk\nMS00OWQ1LTlmM2YtMjdiYzE3YTQyZTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELDSKt1OqeafaVpoz5dKyHY83Ywmw9JrACkBp6ANOOXwrEj1c6xwSeQnvJ7rB\nTP4gs6VD11cecEuJhXNPJqC2u6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvpl+ctcbC/csDWX2p4cgulTlD78wHwYDVR0j\nBBgwFoAUKaGq8T1bxkfFabYxUFi8lZIH6d0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAqkW3JYY5jsFPiNLagu3LFO/qKfRirYWPmGT9sgVpURECIBOZ\nRWMF9RxVF8c39SD798+JZOe4Z9MAvGRRk95neQh1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdvcau3rhGHoza+OxxENSwqSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWViZjI1MC00ZGQ1LTQzMWItYjQ2My01MDFjNWY5YzdjMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKRCfuWRtyHsgf9011KfKHrYHiVf4VbscuIsMsHlBJVhQo\nixev7OGo7kY86mfhy+zw0WAt3/SDuJBk91L/M8LOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKaGq8T1bxkfFabYxUFi8lZIH\n6d0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMUT5KE0FWDol17k0h52TudzN+WvnIOoYQakl8hAcqVnAiBz1YXPzyR2\nt+zpcHZeKUFkChhlxVmfFrkCjRHgVWphzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAdrKVLnlCf09jlL1PgJxl3yEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYzNjhhNGUtYTVkMS00OWQ1LTlmM2YtMjdiYzE3YTQyZTUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzQxYTljMDctMmIxOC00\nMmVjLWJmZTgtOTNhOWNkYzcwMzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngxsWBnyIpBFKJWuthxhN0fPco4iws9SLDeUlrcnMJmVENNLdTR88P6/hCOH3uAyu\nwY343Fexkc/bEBftswfrNaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvpl+ctcbC/csDWX2\np4cgulTlD78wCgYIKoZIzj0EAwIDSAAwRQIhANLn+XA3Mv5IVIkBq7/vZSioSRw3\nYUJnrjyT5PEQxJt6AiBmoSNi84mIPYqWEm/6U5ce1GP5vGrDnCPlOpF1Kc/Jjw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3687", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3687` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAROnigucJtutjiiwEmwPlTirMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjNWNkZTA2LTY3NzQtNDRhMC1iYzVmLTRiMjIxZGU5YmMwMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdlOGEwNjAtY2Q2\nNi00NjU3LTg2NzUtYWEwZTRhOTI3NzYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvO+7Jib6yGdu+XvD1TXZoghJbmZ17oYD1BlDgvdj9Kp24gV7S+i9Ilt+wYoc\nOFrR5BhyaHgdJjP8uA/vE1qOQaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKIWhK9P/nbzA37ID1Ac+WREU8p8wHwYDVR0j\nBBgwFoAU6TFr13hf3jpMq1HQzNGC5c09dwUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiAhDRC6Atyq+/3gGtMHudEXgUN6HbnIR+w+gxxcgk8nawIhANDb\nhLKQ8zE3G3uYGoY5Hmx90OsogOxNOo/Ndmw7mZwU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWPCvxAC7Du2YvDBsvk8frZAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzVjZGUwNi02Nzc0LTQ0YTAtYmM1Zi00YjIyMWRlOWJjMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAL8Gx7m4Xshx0bJwvVjla50tKc0pJn9gW+kMJNg+PIwdD\nCN37xdXyRBk4zGBEcHcmpcVF2Zw5WXtPH+MM3fkgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6TFr13hf3jpMq1HQzNGC5c09\ndwUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQUFGv4OVOYOFnGwaM8ObE4Ingy0tuFbNVfMjaR8NsQUCIQDTeY5V27dn\nHssSnG3b1/IwPRQDt+HISxR2M1wk+HkaJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAVLWOdjxi5U0TgBo5N9RnRp3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdlOGEwNjAtY2Q2Ni00NjU3LTg2NzUtYWEwZTRhOTI3NzYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTdmYWQ0NWMtZGM2Mi00\nYTIzLTllYjItZmUxNGM0ZTFjN2FmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1Uv2VdnHV/oT1XO7pxWApDzeNmNdD82Vg/LHM8QOoxS9dT5UmBNr96KlSyVvM/Fk\nKkxurVy8Ph1eErr50wzji6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKIWhK9P/nbzA37ID\n1Ac+WREU8p8wCgYIKoZIzj0EAwIDSAAwRQIhAMfCnY9NydSum4fmp557cu002ZWO\n5LlPehP28nhq68q7AiBYn604v8hhLRUg2YsRmelxSjGQk2vNuRoCUyDblXJ8mQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3688", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3688` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAY0wv95Zh9WwuMwnWa/eei6oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxODZjYmJjLTA3MzYtNDk1OC04Y2Q3LTk4YTI4Yzg0OWVmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRkNWRmYTktNGIy\nNS00ZTI2LWIzMWItZTU2ZjcwNjE2MDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4ITao8z+pxO/G51mKys+WMHp4vxHoQaW24NvJeahOyargDMC39Tb/9FFy6Tx\n1N4IbN9QfQI5uKiPWNACYNTBU6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc9FmlxbJgJLUlVGI+uTAbAGbEB8wHwYDVR0j\nBBgwFoAUvjyX2bpRGCzgKn0lRzchkeZTaf0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAmfhh/Zl0mpYW\ntFg4oKnJTLJH+glu6CAb5aY3csJcC/UCIQCLp0Q98nvTvDxvatpPQwErO7NyIl/o\nJ+/BCDLc/sEDJg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbfcyjo9im5U1+ZL9jIKVZGmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTg2Y2JiYy0wNzM2LTQ5NTgtOGNkNy05OGEyOGM4NDllZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlmXBfo06VV/AELgHjC3pasBLbNzd5gwkY5ATtYY0ozL/y\nmlR2tfPVRUp/fw08tHVBsHzRYWdB/QG1yXzw5kNSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvjyX2bpRGCzgKn0lRzchkeZT\naf0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTlwbzNa6ZZsCHHSWHENk7unAPI/CADotqW+53ayYtsMCIH/6FkxSOuug\nQ99UJE3KIllFHUR0DlrjK36wOFFs8kG2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAeLHJjRaMpMAvRFjc7cCPNbtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRkNWRmYTktNGIyNS00ZTI2LWIzMWItZTU2ZjcwNjE2MDAyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjdkMTdlYTUtZGI3ZC00\nM2Y1LWJmOWEtYzZhZDAxMzMzZTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMB3u8oQNfHSNt4RdALQdnQV7m1q9Qhc0oV8+g4ypfayk7nEeGBbT1BifP1KmTtrT\n3f2FI4Z7CoDfvTGaLtGbx6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUc9FmlxbJgJLUlVGI\n+uTAbAGbEB8wCgYIKoZIzj0EAwIDSAAwRQIgWg+Xu0dw9o2nEYJDmLsJg5xNKBr+\nv8NcFes8U+LH9g4CIQC6jqi4kQs6RQB6FlfVykPXgs0PgDszrZeCtDN6+Tdeeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3689", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3689` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAesb1Y4Ro219KvbKW4I4/f6HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNzg2ZTk4LWQ3MTAtNGM3Yi1hYjVjLWQxMTg0ZDhiMmFiZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk5NGZiNDUtMGFi\nYS00ZWRiLThjMjQtNjA5YzNlNWIyZTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBxjSI18CPzhCyaP1P/JYTxTTKVmf8vMP7pzDzksh70NFPtL0il3fB0OrZC68\nEaWFso8PAGVa5zP1hBLenuuOWKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU29q3gAPqkh1QZahlh5HCkRjR4egwHwYDVR0j\nBBgwFoAUkCF8Fx7soHZokynXHw7uXxL2cKQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAiUvjEa2lNH7gpFosvORSXxQ0EIJHeLNbp153oZgQdeAiA+OcHjeiVeKZHU\no0vX42aDDQqeOhPDX/wpxaLnbEY1GQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeZEAmlhXlPiU/iQW4kNpIEFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDc4NmU5OC1kNzEwLTRjN2ItYWI1Yy1kMTE4NGQ4YjJhYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASw0A+N+SUWYLgHMXEJoViuB94eCk2YqI1GNOyK5YQqCPyW\nk1qJZamrTmukkZ6TWUlmLNthUtX8to8gixIxO2qro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkCF8Fx7soHZokynXHw7uXxL2\ncKQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANzzmXv6wQVP06s1Ws07bXB01OlLys31nzcRqK1TIlGHAiAnYsKg6BQn\nmfsoRDT3Lt6KGzxHH2Pidxi+OHp83ojf4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAaIZjnMCtv7azrHH5iNMa+geMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk5NGZiNDUtMGFiYS00ZWRiLThjMjQtNjA5YzNlNWIyZTQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDk1YzhlMzgtZmU2Ni00\nNGYxLTgwZmItMWNkM2ZiNDNmNTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAsG73Lk7Zwm8uV5EdN8nBqGeqHGqsG+GnEuDi8xUDNLyc8P02LrG9fSd7ejgAEId\nSdpxHZrPbfWRf2eF4+KolaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU29q3gAPqkh1QZahl\nh5HCkRjR4egwCgYIKoZIzj0EAwIDSQAwRgIhANF3ekA9xA0Og5rAL7cJfYJeZqkq\nlQC6BzPUqfnJKMOtAiEApDMux6a32QeiBIU15GwvlCA90EYORPhq0QyJ5PQEiGA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3690", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3690` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUwVvzb+9sU8pmAEJEZz6IrkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxYmJjMzIwLWJkNzYtNDIyNC1hYWVlLWM0MjRiNmEyYTU0NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhjMjc4ODAtZDcz\nNC00MzFiLWE3MTAtZWU4YWQ1ZTM1NjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz3EWIHMfCr4oCPsvS6Zjs2qoE8e2UGUUVEiEzeFgZ/RdWjc1oh4mlEAz6YRi\n7jK+MGICdGDb8RzrCDow1LmVUqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk+0vpI1+q6XU3IRB7UNBauJuZiMwHwYDVR0j\nBBgwFoAUx7NsPJ5z0mjeJbpC5kHGDu9Ai0gwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCh5XMRBvg2uxGNtW4HpjAQb/JRL7PxKX9uBpqLqr7I0AIhAPX8PjWFffkd\n+YBpiMjX582HGcFs/3zeLu9WQMKSYjTN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASNJUpWTAaxRO+QoGaQltyL+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWJiYzMyMC1iZDc2LTQyMjQtYWFlZS1jNDI0YjZhMmE1NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARezy9uoFpj7bed7KwZ9qToGVVwxArq0P3f7fIo7+zZSi9z\nTG/o0tfe75zUNboEYmPzr4xtuc+Hg6SLGokKV7elo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx7NsPJ5z0mjeJbpC5kHGDu9A\ni0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKHS30PIflPiD6kYgpRFWdpaNbH+imUF4eQRB5Xs/qJeAiBnlgTVB1Lu\nKfEtEMUWevSlfJCuTIeoKHU/X9BLdJzq+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAdcFAinTYctojhXK27oqlPy/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhjMjc4ODAtZDczNC00MzFiLWE3MTAtZWU4YWQ1ZTM1NjQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTY0MWU0YzAtY2ZhNS00\nODAwLTk0MmQtYTZhOGVkNDZkYWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSSf2MSraQk0fDs8pwpOJGwrV35y/vWDm38MThIk3bubu9UBhnF9n8DcTMy/S+gem\nhQvld/owYBfj0XQLUhSTcKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUk+0vpI1+q6XU3IRB\n7UNBauJuZiMwCgYIKoZIzj0EAwIDSQAwRgIhAKtryXe0DRcKX3djyW2hl7gAe/8v\nS/6kPwzfZ2b7o5A4AiEAluk8LKyiB+u/uz+oNeVZWOvhvX4+D5ejSi/xTUfHGLE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3691", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3691` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAT0qfRkmHyakdZq1WJa/ElKNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1Mjk5YTIzLWM4MGItNDk5Yi04ZTRhLTQyNzQzNTU5Yjg5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2IxZmQ5MTctMGE4\nNC00Mzk0LWIxYjEtYjdjYWU5NDY0NzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkMUOp+kBHf2KCNdSvd8S1hrXBP+gx+Wn01AYklT9LGxYd77GuK391lrUuSK8\nJ8ZZW5KmiCWA9TdfjmDppN7YGaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMdKwt+Pe5arO3HqUQtQOMZOYvdwwHwYDVR0j\nBBgwFoAU4QtJ/9CsPS0VX2bjECfRb0r+tm4wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAbDRGqFKc9DhMYpFN2Yt2Caqxuj5N5BpG2pq4ljJ7i8AIhAKr3fcmBWgW6\nJOgqPqx3AEElNCxejrD2zDiyOuZQyhjp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUS+xm4pS6s1mvPAlfKcLPbWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTI5OWEyMy1jODBiLTQ5OWItOGU0YS00Mjc0MzU1OWI4OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARg+ewwkliA0vg9hI9Cp4ucUNGablGWT4PgthiTL4GJtmY3\nX9YyGuoz2jljDWVMPLHPI7cWnu7RgZDW5uqvxnEio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4QtJ/9CsPS0VX2bjECfRb0r+\ntm4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOcbZ9fuOLsaVCsgQg0VWMmZUkR9WUPozR4ChgDg6Is6AiEApONmVmAX\nTsU5HO29ahijqAO5WsrR4KPc+z9LnliYUxA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISARvVnuugbOYli/3ejvJmmKlOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2IxZmQ5MTctMGE4NC00Mzk0LWIxYjEtYjdjYWU5NDY0NzIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGM1ZTkxMTgtODY1OC00\nYWEzLTkxMzMtMWEzNzUyMTE0YjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9tgDkZdijtQLMpoYGBEpVsJFCZ85Fd60rKoqOBm3D9VPQiNfoO6MhXXQFcXgETtx\nLnSSCUXvIuytOtisp54EGKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMdKwt+Pe5arO3HqU\nQtQOMZOYvdwwCgYIKoZIzj0EAwIDSAAwRQIhAPK8eTkslNAWwKoDd3TGNmKme18+\nTcyWL3A2SNfM6+ZPAiBwgcROLZttxRuOG0CTrZhd+OBlmYpZPdwby1SHr82+5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3692", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3692` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAWRvz9L/zCiIUzFJJFzo50eNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiMzRiZDdmLWRlZTQtNGFlZi05ODllLWRkYzc2YmJkMzRmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI1ZGFlYjItZWQx\nMi00MDhjLWE3ZjEtMzFmYjQyM2MwZTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp3DLpvu1fqBSH7ODbEAa/kMduDWyH4BXLEnZMWN+8drrPferjUmMabNJV3V1\nE0N+qATRVheMvXztbfQDYNyfQKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMeh8zbcbw/QPiOemgoDAGnF+CvEwHwYDVR0j\nBBgwFoAUpW8YV2tUEfY9P9ZAJddQNNHWRoQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiALEaCKvrP4t2M9Ut0f5O78vBqTL0/PcKpU4RuJpiig\ngwIgAaakJo2cUAuVeKA3Rp684f6rY3vUOVcXzJz6+1HzkDg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAekeGwMAQs4wN4HS6iutXGCrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjM0YmQ3Zi1kZWU0LTRhZWYtOTg5ZS1kZGM3NmJiZDM0ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARocTP9UdLs5jGOtvi086EW5BB0rLm9ZRP7jc8N7m/XGXAC\n5whw8MzA2EZiWUwMcXuLvluEGwA0v0Z8sEaBGO8+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpW8YV2tUEfY9P9ZAJddQNNHW\nRoQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK8gNBY+YZYj8JMxIh3k1Csn0XhGr3qc9goVoC6N9CdGAiEA3sbAQ+gv\nuqhYKFjitsqhnQHKCgTnO5+rhDw+4vCrHv0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAbW7k6NC4WbClfzKjX4Nm4aAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI1ZGFlYjItZWQxMi00MDhjLWE3ZjEtMzFmYjQyM2MwZTQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWIzMjAyM2YtNGYwZS00\nMDE3LTk4ODctZjA5ZTAxMDk5NzVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhM4XWGBt5gY8aukOUmIWJLzhUsbzymuUPoWS/1agozu27SUPUmPFv+esxaFksvbu\nYzpOLIQSHcHt1nFjYlqyKKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMeh8zbcbw/QPiOem\ngoDAGnF+CvEwCgYIKoZIzj0EAwIDSAAwRQIgOSb66pUwsbr6Pchhqvi8mJh9UV0L\n6Zwc2T3q0YJsPQsCIQCOuX1+gE7e/UqfJ+RvQpWLJDODNV6K4k8SW8k6vTrKvg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3693", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3693` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWQhTyYUH3xDPg8ZJAjzc+RIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyNDg2NzdiLWI3MjQtNDIyMS1iMDBiLTYwOWUzNDcxMDJhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNkYjBiNzctMGE1\nNy00YzY0LTk1M2EtYWJhMDBhZWI5MTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4seqneulEWeWTzxr9GmNdmBwNFd5P9nsJYCqSyur6g+O2mr91W5ZJONArdg6\nTsmWg3Rx5qFcHwaR9HT8odLxJKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY4M/SnpFTdeVtiA7Pvm+txiKChEwHwYDVR0j\nBBgwFoAU5qRbyF5aP4lSJ5KMJdZW4oWu92kwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAj/3KY7G+pgl+o0JsaX7wvZDB2/2dAKgTNqA/9hMbx\n4wIhAPgMpSnBhw9cLC0XJYoZyw50RGRVKCVUNCaE/FWXGmMW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQkB/InAMMKYj8eBe5hVBwxQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjQ4Njc3Yi1iNzI0LTQyMjEtYjAwYi02MDllMzQ3MTAyYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsfcVMz+HWh6KxSwbFDGWs2eorbcRksnigNdhXh1y7DhAB\ne2ZnPSApr+kG8eXXTlWSNaozjpejjnDI/d6LZo8yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5qRbyF5aP4lSJ5KMJdZW4oWu\n92kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH5dg/rpgvIiQe2LsyF/vtcQ9zkOF3+aMzEuoasUAfgICIQDsd6QRS2t5\n6xyERyJV4JLU0rVQd9ZIyd7hnAr9//HqcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAeUVnspKINdAmNC4fYi9VMDZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNkYjBiNzctMGE1Ny00YzY0LTk1M2EtYWJhMDBhZWI5MTRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGM5NThlODUtZDAwOC00\nNTlhLThlNjYtZjI1YzY0Mzc2NmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4Qwc32CvT0hWpFCqqwCqCOPWjTeoC1+cRlcPvHaDqs2iiTnfKC3RgTKrSyZPoe9z\nfIlSshddx/yz18HA4gnO8aNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUY4M/SnpFTdeVtiA7\nPvm+txiKChEwCgYIKoZIzj0EAwIDSAAwRQIgNM6Nnt1xCjvHUkISDOI+hw3fye13\nHqXE3VclRwYtDIwCIQDF7nFeGSxr+kg5kIOyx25t5oTbLcivvT4D5BcqcP9avQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3694", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3694` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAR9DkitbNOOvrGA2HFr5I7ZXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliOGExNDI2LTJmMjItNDI5Mi05NmIwLTA1MDg4NDdiMTk2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWViYmU1M2YtZDQ0\nNy00N2M3LWJlMGMtZjljNDNkMGU2Y2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8OTdZX6ebDTGmDWDZ2MStqILEOa7b47Q3e3ojlV06x/SCmNsEjX7ilzYrxVa\nencaXmw46RB1AdrFNNeY8a6nOqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqcJF6+Y/r3kT8FeRjzpjHbV42+gwHwYDVR0j\nBBgwFoAU5m2T8H8iOxUj0gFsG6boe/7E6e4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAtCoLJBELS9EDwb8imywqe/IMbqhkQuvBlU+UzHCyV1ECIBkr\nrL1IkZCrUVldFO+31j1UF+wSMI9dZra2wABQPDM/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAequJqCYOCCNXqujpP36IXJaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjhhMTQyNi0yZjIyLTQyOTItOTZiMC0wNTA4ODQ3YjE5NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASh6wn2Rf56x4zsxD63I5Wu5trsCYqYOO6brjpaYO0vrQGJ\nazi6QX3jo2Nc5NV551kWwIo/FUuYNbcfpI8TuFbco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5m2T8H8iOxUj0gFsG6boe/7E\n6e4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP38YUFMfda+oeYCgLSiiKghS5vVn6ojOJQaywRspF6IAiEApmNKjVtF\nNe+6W9Mpy+eb9G0uRU6lYOYpHP7E9wIC+5E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAVQM+uOHsLrsWMpGB9u2mflWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWViYmU1M2YtZDQ0Ny00N2M3LWJlMGMtZjljNDNkMGU2Y2FlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmE3ODA5NjgtNGY3Ni00\nMTY4LWE5MDItZTFmN2Q2OGE4OTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nB/jVBDhk4jnupGlwU59sjoPvQqPHuIbYoE3S9xEvKMctAZnxt/HnLOM6KRxJUAc7\n75lsrPJUyk9kD73//c8vs6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqcJF6+Y/r3kT8FeR\njzpjHbV42+gwCgYIKoZIzj0EAwIDSQAwRgIhAN7Stv6M4W1GCFFYX1ELAgVvYeAV\ntXEsqUBFDIFErYt4AiEAuy1ftR+KSdJ3NI5fSNryzxJspI/c5X+gzn8epVj1Fa4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3695", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3695` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAcmK5D5+wvZQdcweRbRxS9QwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhNDhhOWVkLTdiYTgtNGJkMC05MWIwLTEyNzJlMGZkOWE1NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJkOTdlMzUtYWU1\nNi00ODFlLTg3ZjItMTcxNDQxZjRjYjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0vUrT+V+MkL0Gdf8TI7mzfCWMv3A4GpJkiKJFd8P+9juUNvJfEGZV3AOsrhR\niXtq/Hw8gyzeLzqVKAZNkwK4HqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTV3ujRzmDJKe9JIDxdkGMl87S9AwHwYDVR0j\nBBgwFoAUkxSQ7cGPsoXSboS/G8mymcxfBiowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAuX+AZG19p7T28RRPs8Znz2OJkAgDnecn\nJ9k0pDP0A64CIQCbl35nSAkBIT2sMJ/1v5clrkjgGbI3gHbeCxcDBp5B3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUnEGPmNHZkPHZUYIIwf18QQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTQ4YTllZC03YmE4LTRiZDAtOTFiMC0xMjcyZTBmZDlhNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGr17Dkqrexd+bacV5+1Bbvt8Pn0r/Oc4GfJoGflJHtkaV\nPEWplZLfhsmISDcnlZymoxMruYYiRRtDw+pRdsmoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkxSQ7cGPsoXSboS/G8mymcxf\nBiowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDbbxyFKgf2cfi8z89W6GIur0dopGnwEPOEb5gjEYtwgCIQCzHN/Xxrk5\ns6HiKi1340dXdVxxrwe6Fqt1Q2GI8UtftQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISATKHdxraZr8mvvKVF8zbpUWnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJkOTdlMzUtYWU1Ni00ODFlLTg3ZjItMTcxNDQxZjRjYjQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDI2MTJkMTctNzZhMS00\nOGJhLWIzYjYtYzlmZTI1OWQ2YTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n84Lksr3qD1xKW35OmlAVQVgNx0S0Vj7MBC6JzBZpzbCP27DK10fGTGEqrtzuwlJQ\nGWq81vnTwFlgr3Erev8b/KNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTV3ujRzmDJKe9JID\nxdkGMl87S9AwCgYIKoZIzj0EAwIDSAAwRQIhAPHqqfX1diqd4r+eTUoQnETJdhan\nRIsmodo0hZwlymEKAiBQh3uzLR7OwVovK9pdq6LfYGCVaubhNRTkLxIbqFu+pg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3696", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3696` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbH9q/9LmURm/5lHyAGcDs1JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYzU2ZTcwLTU1ZGQtNDNlZC05ZmJlLTlhNDQwOWZjYzMwMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI2ZDllYzEtMDkz\nNy00ZmY0LThiZTgtNjNmYzQzODRhZmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqlDmdAfOMSCT/zxdDXdUdaugZAdpt7B4Xorhm4pkry8stT9vcXyizOq0BmUV\n7QcWU3aov9kIEntrAUQTNUMOA6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAv/GiJJe1gMCWnWALKgKeKwpeJUwHwYDVR0j\nBBgwFoAUXhlB1tDLUkwBRUdzEPAElFQK4I0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAhWX0I020ASf7kg812pJCVSlp0/cNaQLv\n57uNVs7OuN0CIG3FkF6BA9m2kFo7jFELGDGwXGJLB7T8lGpDF/HFMZSJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQxjfJT2gqcFtBITXQEvEUqnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmM1NmU3MC01NWRkLTQzZWQtOWZiZS05YTQ0MDlmY2MzMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbYgqvBNfEVR5/bCbh+rlOqpsD7rYDY+Cd/H7svMpMy5Hc\nqvywbFClUCxX98dXnwNL4oWsKSy7OK7vtwM8LPI/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXhlB1tDLUkwBRUdzEPAElFQK\n4I0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXC/2F5RdmyhU9ao5bjJgJsyJYjhxDKCmdOSaKZ10XywCIQC5OJexhjcB\nPT8gxkpddVXdZUJ2mrasxZNbgCMLiQogbQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAalqzHlC9OILAVHJwJ4gBKygMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI2ZDllYzEtMDkzNy00ZmY0LThiZTgtNjNmYzQzODRhZmU2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGEwMjdkMDYtZjE2ZS00\nMTk3LWJhNjMtYzMzMDVlNjY4YjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQ3TKQvnmiX06tt3kzZiJ9n6NhrFGvIhY19xs67pYEyOIbpgXrVHxORW2+bos2M/j\n5siCCQTs/oOcuOdZO5SEJKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAv/GiJJe1gMCWnWA\nLKgKeKwpeJUwCgYIKoZIzj0EAwIDSAAwRQIhANdrLYWD7zH+yaoWkbL67xMEm16B\n+4Y90OZJ8EetVi2+AiBS+vaoqpFCf82uTNUDqm5DhLgPH1Sfj3P3vv2O5MedFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3697", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3697` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAXMdG42LwwbP//BaEt0+8/paMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MGY5ZWYwLWFhZTItNGQ1Zi1hYmY5LTVlYWYyOWYwZDk5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgyYTA5NjItN2Ux\nZi00OWY5LWEwNWMtMzE0MjY2OGVjMDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMxCPyoTVVowWDELH7maRB2IAZqifnLEb0mx7vii26gVKDknezmLKwHElg8gB\n89H6ErxQseDsAL3DQWR46dLKHqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI2HFtCw/mgbJLUYy+shNLksTf2gwHwYDVR0j\nBBgwFoAUe+nYTpPdMjrnTtL+AHWLuC6SnBMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA/RMAYCG+sGdR\n7iQ5YOzHEtIXI7P2UU+ZNsXicNOo5+YCIQDSBW+Oq7jit9ZWzyPANtSLoXo5jktt\npSqcG6Ws4ZA5rA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaGTU97l5nJkecVqBZqyhUrRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTBmOWVmMC1hYWUyLTRkNWYtYWJmOS01ZWFmMjlmMGQ5OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStFtmh1VEevwRmFUvzrR9L1GZfY6MyfEYyw9ZOz09OHOWZ\nlK1KCRsjQorMunivHkjSyI/Al8M1OinrNPqszF8zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe+nYTpPdMjrnTtL+AHWLuC6S\nnBMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOnFJucKjS5clXFk9zZgDoo+4Y72EVl04UK8ilvl9X55AiA+HSfbRSrw\nzfzoyOlOvLs6vJHTsfZMKCBOcmCn8jq5rw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAYB1tLyB/+bvcBIEu6ChW+hWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgyYTA5NjItN2UxZi00OWY5LWEwNWMtMzE0MjY2OGVjMDA4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODQ2YmY0YTEtYmNiMS00\nMzIxLWIzNmQtMjI4MjVjMDFlZDM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQBRe9COrnQxi67ii0qIOlaxNuTNB95swk33jdO9U7M7GFFYuS9SMNEK+GGP25jCf\nQNzMkGuWiFwwUlMjCHzLZ6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUI2HFtCw/mgbJLUYy\n+shNLksTf2gwCgYIKoZIzj0EAwIDSQAwRgIhAJd4s6BjO6xCm85CBfKLQu4NyZzI\nA60cOsjT2RubSNZFAiEA7WSTigvXOiAxEJemPQ47Wb071VsZmlUPGhVI/1F4zBA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3698", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3698` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdW/lnEwFvfxwU40UFfI8IN1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYzlkMjNkLTI5YWYtNDJjNi1hNmEyLTc0NWFhMTc4ZTIwZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJjNzk2M2UtZjRl\nYi00ZDFlLTlkMGItOWIxYjUyMDk3NjEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiZAMS5AzInsyoKFsCk/z8FGHGD0uiGQcQ6JmlrpHQ1BeKH6WHBPIOiHbAotd\nt3DH4xikuJJdcgzhCVi5YmB5FqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJkCQyiQKkkPCJIYLM38YO786Ln8wHwYDVR0j\nBBgwFoAUT+c6Y2Cj0S5zjkU3lsT/KTwNCHEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEWH5MPipXvXJWXVUc5fhJQEN4OciwPgG7oqy78V/LDnAiBSU5P2wuhRDssg\n64CblxZcKZPxu/7JFO5KDwak8oDkfA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATKKJU/FaCMmss4hV2cZ+00aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2M5ZDIzZC0yOWFmLTQyYzYtYTZhMi03NDVhYTE3OGUyMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCDpylvbrkZVOIVuSO1dzs6lFEiGkLz6+LLAaK7tt1w2gn\nu1m2skrG1YJXBqlAhXJE5LkL3xdTYrRcbqo13Dcdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT+c6Y2Cj0S5zjkU3lsT/KTwN\nCHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdnNUe2RwFzqTNQY67/79X5Rz0Y8eR/tDntzcuMGlowwCIQDBrRkh/Kea\nuNVT2/pG9HtqlganPqob97e0SYj6A/Hwbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAXWgyJkCSw4gwRhQzxiVsrXgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJjNzk2M2UtZjRlYi00ZDFlLTlkMGItOWIxYjUyMDk3NjEyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODg5ZDhmZGQtYTY5Ny00\nN2I2LThhMzUtOTc2MjlmMGRhMDM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n99PlmqvX5VUM3kcwPLiUodAxjwYssh0olMzzdaWjhPx73RzwOGiQw+PLOJHLuH0t\nsfp2EGx/afPIYadPUyh0s6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJkCQyiQKkkPCJIYL\nM38YO786Ln8wCgYIKoZIzj0EAwIDSAAwRQIhAOt2C1TjaVDa6/MysYLLV2+smn//\n1uxCCIBe/smcz6IcAiAuh3E5hKsBFNh8RucTsGLw/gkNkkciJ3NeAOv39+zlMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3699", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3699` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbNttijmBhyQaY22BG1zTdHaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5NDBiMzBiLWE2MjEtNDdjMC1hMGU4LWNhMGQxMWVmNmUxMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNmM2Q4YTktY2Mz\nNS00NWQzLWJmNzctODVmNzE2NTM1MWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+4SgudUbsjhqwzubzVKGJx4zkneKIIhW4EUFmMbkfF9l2QribwQYbYwuMc9p\nxPteu96Xk7pRJ4pU7BQSeXdiWqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU92jAkeQV8goXonJRVg7l10cl4wAwHwYDVR0j\nBBgwFoAUZKWOVaC2aK2wOgwQZVO1KJsb3NcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCLYJgt3+kr6dc31X7T6yDGuSaGd203NVb435xhe/IyfwIgVdNVCHmfFdC8\nb5FavNJrLUjCmygef2vBwglhis+ErU4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfUF04ibiijxyTMUnucYM4KCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTQwYjMwYi1hNjIxLTQ3YzAtYTBlOC1jYTBkMTFlZjZlMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIARaDkVQZKb+hBPLaCvDPP4IwvEP+UC05fAkz30lrl3Bl\nfXHMIRE551RbNG0TN5tIK1Pb5yw04ona0pmzKXEeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZKWOVaC2aK2wOgwQZVO1KJsb\n3NcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMIhUtzVbvpX6BV/oxqwLAxFAsNaFbynjeDN5PrUgeQaAiAH9kbKWa6U\nMBzZXv95++Tg/KHjM/3xyeaF+acFdiHAeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAZCbmfkVasgJMwL0oztpsbp0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNmM2Q4YTktY2MzNS00NWQzLWJmNzctODVmNzE2NTM1MWU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDliNjc1ZDAtMTQ3OC00\nYmZjLTgzM2ItMjA5MGJlNjgwZDAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCSELg4mROfJLDJITEOmHRe68jbJWjmEubkavYPCeyyN4Sy5RkeiINAUJggAW/sre\nfhV82sn96XoprL0LrzmX16NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU92jAkeQV8goXonJR\nVg7l10cl4wAwCgYIKoZIzj0EAwIDSAAwRQIgUg+LrtRxnP5Xc56r8CvHIID1S+TS\n+uQk9sIvswlwcooCIQCTeC7vKvUljBRKXEpa1iNMHc9K2OHZD6NySr8HiD89yw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3700", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3700` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISARrpg2NkLffGCPVhk4jPGmKOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5YjA4MWQzLWM2YTAtNDNlOC05MDBhLTZlY2UyZmVhOWZjZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRlMWI1ZDgtYjFk\nNC00ZTczLTgyZjEtOWVhNGNmNDZjNTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET0b8xEYaenqYhSxedOCAbN1P/ndYh2ysfxzVGQ3RswT05eHT6H8dGqYa07TF\nvaKR6Jnzb1sta2b9LTDvZQW4MaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpjNM9Gn/TznvY42X2EKit7bH4kQwHwYDVR0j\nBBgwFoAU2eCMSwK+5ESPBv5U4My0vutxY38wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAiTvRxUxylWxXG0X7EWkbkh0x0IxSH+TiEq/h+ySphPsCIQC+uIP5i3P0\nuxt/R9q+jy3086jP2V8/h8DFb6gCn3GVMg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdjq/wqf0PVPumnMZhIKfQtDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOWIwODFkMy1jNmEwLTQzZTgtOTAwYS02ZWNlMmZlYTlmY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyunNawV5NeSqIW8A54SzPC7Vt3F2Rk7usVWmZsb6X1BDs\nlhEpkIVk279K/f7TAdhsrsaPhv3jLnoD9NyxeDcqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2eCMSwK+5ESPBv5U4My0vutx\nY38wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFrE+rphusjlUxTTas0IiL4anKDX9zxQbhId68SC3jYICIC4eh78Cyolt\nASpf/kcvpP7CZkJk0OYjGI/e73rSj2Yo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAUCg1XslYqY1rLTf5MjIaDuaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRlMWI1ZDgtYjFkNC00ZTczLTgyZjEtOWVhNGNmNDZjNTFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTFlZmE1MTItYWMyOC00\nMmYxLTgyNWMtZTE1NDA4OTA4ODFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVsYkZY/9NYoIXtKTSrb7qn/DkDG+qVARCdC9SefdFVVHvT2TI4Vmee89U7Asuii7\nPmsUAx4ex7Q5sENNv2kFWKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpjNM9Gn/TznvY42X\n2EKit7bH4kQwCgYIKoZIzj0EAwIDSAAwRQIhAKagc803vD5PLhRxo1yKso2U9mIa\nFv/K5Erh9YNNj4NMAiBh8uMjQufGqnQCyReiYXAV/ZRA+tenRFH+mIVzafpkcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3701", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3701` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUul6PbjzdDP9reaKrjEYDk3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2ZDBiOWUzLWRiYjQtNDhmOS1hMTcwLTFmODg5Njc3N2UxOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDAzOTE3NTQtODUw\nZi00MmQ5LWFlYmUtNmVhM2VkZjkwMTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmPrmgxn+4CJoIz8rDuGv3XDDYzhGOSmFNLzF98QZHcGjC5vkhH5pQoUCySw0\nR32IBeC4oEEvCKtLyR9ZnG46OqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcvaYYaw8TOYLF1qsEurAdviC9qEwHwYDVR0j\nBBgwFoAUOg8to0xNBQvzcp6picBVf3SlVZgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEArxGudtojUwTY8kb5s5v3itVxCicF6UIdRQoAEQjX\nXWcCIEvNK2dR7TgtsTNXYSHt7kLZjr2X3fekFdOvoJ4PDGGY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQw2T8IatQus8GMYhPiucZQZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmQwYjllMy1kYmI0LTQ4ZjktYTE3MC0xZjg4OTY3NzdlMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNllQa0G9DP65gz0If1wo3gKJFCFDJxL3i+oCe3J2iOQA1\nMXYGCBSxDhMcbunKCKQX7IzwA3u0q5iJrksjkPEqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOg8to0xNBQvzcp6picBVf3Sl\nVZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWtMeQpWBzTbGHPzAXOqv/6KQ2QBMGSYXqEnYX4OVhT0CIQDWG52KQkd3\n0b3349ditvLcVelWqlSB0Pgt+P/yfBtVfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAVhYFQPDXt/MzXFLhJPzZMJPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDAzOTE3NTQtODUwZi00MmQ5LWFlYmUtNmVhM2VkZjkwMTdlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTYzNTVkMDktNTIxOC00\nNTUxLThkMWYtNGI1MThiNzEzNzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlDGbVQ2NY8xplj3PXk1df/9T7Zxj7EcllSOnc1TuUJ1ZMSLtMKSkn5gktPRtiPs2\nGgrM8fHszbeA67q9HxILRqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcvaYYaw8TOYLF1qs\nEurAdviC9qEwCgYIKoZIzj0EAwIDSAAwRQIhAKOyA6JK08aimmL3COOuq/yU+3vN\nSj1beCbBaEw6Su9FAiAmYtn4f3qI7WnMRtlACaW/2UMKNVThCuFsUSwSEbJYrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3702", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3702` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAQS4pqrIpra/bVrFudMIYZIfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5MmI3ZDI5LTdjNGQtNDY3YS05NGZiLWY3ZTdkN2Q1YmFmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2M5MjQ4NDEtZDIz\nYy00MjZmLTlkZDMtNjVhYTg4NTNmY2JiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjI8Gk8Ol5Md+02yMYkJkLMtOIZMlu+zehDTT95TWYq1SGjlZhiswY80R0Fni\nyt54jrrXo8tILfys0cEB7MFqyKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaeX78SEI+Z2m7e0s+FRsyZHzdwowHwYDVR0j\nBBgwFoAUelelC4sgDpspCDDerKzcZreuaCswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAmE5NU5A9aSf6uES1PTXJSOSiE0bWccgEZjo63qEPa\nowIgYZwGT3BRgG1xgAAbF/0FZId7/ZYjUa46Kkcwv6xBNI4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARwJQeBt6WgSXfzsx3484HveMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTJiN2QyOS03YzRkLTQ2N2EtOTRmYi1mN2U3ZDdkNWJhZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPdtYBxbDj8SLlL908tu4k7VYEsBpfOtIOAT8buDQ/L6YQ\nAQgl0MODUXtMtCHFWDXiWYYNTpquB4jRdyr5qYsLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUelelC4sgDpspCDDerKzcZreu\naCswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKeKtsXbocBGCi5yLx4TuDqDQwUJZxjHmAXz5dXTeF2iAiEAlGOUlkAK\ndriYvNt/54VR8flGZnCo6mrRfMWkw+wy91k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAUS0/2aKJkcPk7BTvJz19xOEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2M5MjQ4NDEtZDIzYy00MjZmLTlkZDMtNjVhYTg4NTNmY2JiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzQ5ZjI2MTYtMmI3NC00\nNWI1LTkyOGYtNDQyNWE2MmQzZTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyHD2BoJSvJF9At+eQX4WSamYSnB6JwlFys5GeYWrUsIXjMJmJDpG5y/NrUI19nQM\nDPyOK7L7ttFpuDa3GLm9DaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaeX78SEI+Z2m7e0s\n+FRsyZHzdwowCgYIKoZIzj0EAwIDSQAwRgIhANB3RLuxMLa+H9bWQVdMjWjY+0ca\nrfR0f1cuP37x9wVrAiEA/wTmLEtKO2fCPsQaj1N7jSjWmqNKc5kdlWzhllJ9Zeo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3703", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3703` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARZ6zlJExDvptTcHfvRQAGqaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhN2MzOTA0LWMxZWItNGY2OC05YjFmLWMxMzE0ZGQxODZmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGZmNzI4ODUtMjg4\nZi00MzFjLWI3MTgtZjA4MDZlOTUyZDJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEffb8nwn4PL0/dqD3/rjsQLOkkMIJiq1Ex8AOj77FYCxVNXslwb17zdgSuYB0\nPWj39g7NMxyrLBBMwhXtmY5v36OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoO+HzmWR1GS4x9TB9y6WmBoge74wHwYDVR0j\nBBgwFoAU6Hm7Kqnx/LDuLuZhEzAUc72xpX0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAnkVnqjWgHGx2KfnwLy9NzGy7uSnL/5552Wd8JZELTuoCIG9g\n+lX/3FFyMzuzrFkGOYZNgNHrcdc+k/VK+qX9Aw0s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd/p9smYRHxjUL5vQx1+yJsBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTdjMzkwNC1jMWViLTRmNjgtOWIxZi1jMTMxNGRkMTg2ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsNWyRfzpnkvFhXqRmGbv5g/1cQy/Q9Yc5O/voyqPwyXKd\n1IMOEEwh9FnCbdzOMb+lHSt8R2D1b7LOJs+lBQjDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Hm7Kqnx/LDuLuZhEzAUc72x\npX0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH4EXTUqkzW3baEQZedVZLxL/5Ewd8hTBU8zfmzKfhZYCIQCkqRs60kdA\n0E/O2bQlUAag0UqYEoJLdtHDIcWVOIzbHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAY2aIMfD+QR0R3munhE5qkggMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGZmNzI4ODUtMjg4Zi00MzFjLWI3MTgtZjA4MDZlOTUyZDJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTM4ZThkMzMtNjY3My00\nMmQ4LWFiN2YtNGIwZWY0NjVhNGZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nnUOfSDRSosNnSPX4OpAWrGTkTJY87coiTEJlPGNkjPXck9vS/H0fWc5XDwqunQ3A\n5mZ7jPGJAT00LGpEFnDCiaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUoO+HzmWR1GS4x9TB\n9y6WmBoge74wCgYIKoZIzj0EAwIDSAAwRQIgc8Sriuy84PDueNTKZjhe8wJIqC2y\ng7MMBsiNprdJSUQCIQCQxWVULRma7cizt5ZDWpj1YdIzvtXtsV3zvI4JCxkA6w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3704", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3704` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVOBDaF6NgDbaIWuXXCtqfr2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhNzgwNzBjLWM4ZGQtNDU4ZC1iN2NkLWMwYzA3MWY4ZWUxNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGUxOTlkNmEtYWEx\nMi00ZjM5LWIwNWUtM2VmN2UwZmQ5N2JhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEStYIX5X4/scxBHCyQDJD/l9CwtPE35o7deIBBGaoeaqtlxPTQoF8hlbeTAOT\ntx6NIGJqRevodHRS100LitFpe6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/N9yHe9AKxUGU3mbOc6DdqLiKw8wHwYDVR0j\nBBgwFoAU9x9B19tttjNVUjABJelAqsS1go0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA6OsXedxZ+fsSsfMnxhmaN/DgzIZz21x2\ndsWXTBNQXyACIElvdr/UHXl6WOj7EdjDg1J96A1CtT3jD7eSDuyQQIJh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUC9ZBiDd7IKQ1bhkM4gMpF8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTc4MDcwYy1jOGRkLTQ1OGQtYjdjZC1jMGMwNzFmOGVlMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4KXg0ab+tTCTNt66qkGVqZslnff0MHrGjudB+FA5XWCJS\nHO8lM6fWfFQGinzfXNOWYjd4rWf9U0rs7rNcIt0yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9x9B19tttjNVUjABJelAqsS1\ngo0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJzm/sPMYTGV7WiFc8dGXKCbqaIvc1hxPGX1rcWb7SDzAiEAw14U6Yd9\naB8QbSaYuMwXn6fS5/+1acyUhMJ3U8ZzodE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISASv0SpzXpmNyUvTiNmcdGjQEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGUxOTlkNmEtYWExMi00ZjM5LWIwNWUtM2VmN2UwZmQ5N2JhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2QzOTExNjQtYmQ0NS00\nZmE1LWIyZDUtNzljMTQyZWI3ZGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n99Kkv9wc1lq2WYUHm2ewJFesdkYpoHrLCF20ANDJSl02ozIdvNwcWHjambaSsPP0\nwtyiRiKxExMwvvq1Y2BJ3qNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/N9yHe9AKxUGU3mb\nOc6DdqLiKw8wCgYIKoZIzj0EAwIDSAAwRQIhAMIOBsbCZUVvhVAMVNkB1K1DqHqV\nyjjLUpWCMCiBQOqRAiBsK/KiNjHPGMlToamhyzqqwn+KRw1bZGWB2HA/7pvAGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3705", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3705` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAeG7LS9PNlzAMnbSu2uqgdkOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwZmU1YTVhLTc3NzAtNDAzNy1hNGIzLTU3NTI0NTFhNjg2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEyNjM0NTAtMTg3\nYy00NThlLTg2ZjMtYzQ4ZmRiZDY2OTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE756EfUfc/eJyjuv86ednqsqhvOaQyc6MlNEk9DiXBkCuw9eqkpggFWB/CYCl\nnV8QDdfYc34GahaCaJXPtyjKeqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUchu0Alem3WRUc+PpnLKvV8+OJ3IwHwYDVR0j\nBBgwFoAUhy3d9+MOZC65wKImWCiRrRLKZMswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiACgJkgVN94tcBJ2kkHxDPWMjJSswyEh1Ke\neRkXsr4n9AIhAOoyfVjeKkOdcN9TCxpfAWzOracgqz22bmy9jyYcSkzC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUCm1LP2X/ub3fIg1/fYQaf7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGZlNWE1YS03NzcwLTQwMzctYTRiMy01NzUyNDUxYTY4NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPfd/yXw0HpTHseEAtaDXXcqJA7ofw5+gJGhoNB6cd/V+n\ntrLl+cBwGrrQcGIpx3MnmKE1VwSzSgrN3i4sjh7zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhy3d9+MOZC65wKImWCiRrRLK\nZMswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIXV+/9Er15jQLW3HwIX3sU0qynjd3AcVLQDV+lcMqigCIQDlFrhGqs1R\nD6oYmVfzOuoh+0EiRhF6ACMBy9FVUQacTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAXRMeT5CJ3klylz8H3jHiCFWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEyNjM0NTAtMTg3Yy00NThlLTg2ZjMtYzQ4ZmRiZDY2OTllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjFjMTY2ODEtMmNjMC00\nNGZiLWJmZjMtNmY4NzBlNmJhYzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzfvLQhWtSR/sWx0kD4+XMCaoZWptRW55QQi/Yz/CzZ0mEYLuzQStsyi5XyzmNTSz\n9+nMgqnVb7mSnsS0BN5idKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUchu0Alem3WRUc+Pp\nnLKvV8+OJ3IwCgYIKoZIzj0EAwIDSAAwRQIhAJ5Ex7BkseKDUQha4ZsbKBRUV1EG\nQ7Bei87NqJfE3YLYAiBEa1J7uGCmgz/pzY3ev4KdDu4Fg+TwPohO+7RQDsg8Mw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3706", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3706` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAf9U/BoQFta97Pzi0ji4E4TGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiMDZmMjIyLWQ2NDItNDU4ZC05MjNjLTU2MDM4OWRhMjQzYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY2ODAzZDQtZmMy\nNS00ZDdlLWFmMTctMTUyYWNjNjdiMWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5zDiOoitMojYFNx9NhF71iUxrjXaolY2JjGUjUb9Ea6/Jsu/5iAiwIuHV7QC\n4CESx3ALi1lWPrGCnUE+KM4MEqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsKWHV15H74IpFJV8m90kOqWjJ+UwHwYDVR0j\nBBgwFoAUGdJzI9LuCoO2AvstGKNngs5Z3RowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCZRkt+PioKMyoQM6CEg4/FsZie\n+jtDDq8Cm7YQl/dd6gIhAO6uaTTUdP/hqJlQoLi58bt9ugTUkmfgDYyQbAOcH1cF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU/COWGMOxH/f+jZOK2wZkcSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjA2ZjIyMi1kNjQyLTQ1OGQtOTIzYy01NjAzODlkYTI0M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREXK5pJDfmU78qfmIUYoVD75aKF16l+uOkY0oUUCMyQWq/\nJ5Uh6TGDVr8tfO7zLvXrC1CwDAWzJzSL0KfQGt6Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGdJzI9LuCoO2AvstGKNngs5Z\n3RowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJu+f00jTBtKE+KPPlxD7Sd3JX7N0r0tMUCXGCugdtUEAiEAhWauAWBl\neRrXRIrDHd4fFuLjrHcyPBGXAVLcAS0ye/4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAUGs/WSC35klQM96sz8DqmXMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY2ODAzZDQtZmMyNS00ZDdlLWFmMTctMTUyYWNjNjdiMWJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDIzZTJiODYtYjIzMy00\nMTNiLTljMGQtYmMzZTU4ZjE1Y2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntlXy8NY5CL0FReHC3QDH3Ubo8T048oOiK/AFeDqAWRebszCBue55kSbrLZD8Ho6f\nSlgEU4I5Ydb+RbduLMsWcqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsKWHV15H74IpFJV8\nm90kOqWjJ+UwCgYIKoZIzj0EAwIDSQAwRgIhAKBBSXU829uz1L1+M7L4QPRRpHHf\nJH8bDd3WnuS9hRtHAiEAw1XWuW5QmsUqg7DygnKkEZ1RajT+iqXgQA6MDcB+JUA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3707", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3707` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAcn0Anhyuam7VIGERBpxawdRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYWUzMjlmLTk2MjgtNDJjYi1hN2NiLTljZWEwNmY1OTlmNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGRkZDUxOTQtOTBh\nOS00MjYyLWJhYmItYjViM2VhYWRiMjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGqU1bVwzx+5wNndWuOM5HI4ClhsXTDtMKf+p/tTZDT6Orw4SSLCDi0MnRSYu\nrzrDgcJKstOo5ybW4wWqJBYOraOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3pFmgegf50Mob5SLsY/o7z0gK6QwHwYDVR0j\nBBgwFoAUsPfnX2Sk8P26Ps4xCfVacK4pexQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgH8tA6Oxb\n0j1zBqUD52VC9uEYnx9cJt9juMt6eSFxwksCIQCglX6o6J4TOrRt53p+U9fXMkYf\nXowuYwIu4oS/Ty3Xeg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ83QvLxTHBk7O1LbAY1Z6apMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmFlMzI5Zi05NjI4LTQyY2ItYTdjYi05Y2VhMDZmNTk5ZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuAp0o6MsE31aYEXMHnFizx2Q4YplF5FYmIRGdJ6NMU8+I\na2Qc4InSDjWKK9fJrxvJpVY0rUivWcC8iZTEPGNxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsPfnX2Sk8P26Ps4xCfVacK4p\nexQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOm4br9uKyT4Bg+5929KkeabPmnSjyFjqz6fWntG0F55AiACwUHoXzAW\n3vZb1fMno6wiX9EUiDJgnQPMFBBNd9BIPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAYis6VwfB6yUvixKeTxwXvSlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGRkZDUxOTQtOTBhOS00MjYyLWJhYmItYjViM2VhYWRiMjA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjY1NjliN2EtNDAxMC00\nYjVmLTkzY2EtZDllNDEyNzc3ZjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJU+BYhwV7v1QzLbFEiUewS32XnlsMy6b1gVX2IbUHBT2trztNH+jMjQ3u8oBtLFl\nZAsPEoNELkAw+x1fqh0A7KNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3pFmgegf50Mob5SL\nsY/o7z0gK6QwCgYIKoZIzj0EAwIDSAAwRQIhAPkUQMXGVnlvNIb3OPzavbgtOKlO\nBq+OhqOUQWepw+M/AiBw/8EYmgv5C+4aqYv+RbZjTalHu3FiMq97V6aVF5XFoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3708", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3708` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAV/u6xlmfanpC5w/Jn+kmwRLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlMzY4OGYxLWI0MDktNGZjNy1iOWM1LTVkY2JjZDk3ZGQ4YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmUxNjdlY2EtNDkx\nOC00NWNhLWE1ZDQtNDIwNjM2MGRlNmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOzq4OInfIdpan8Wl3nYUR1hmINwQ8Z/lIpHWHCyB8DJI63SIT4OveFvfA3Gs\nf70KXOuYneG70wBzMPFarcN/8KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvpZG9HDCy+b2onPNm613+sgF0C0wHwYDVR0j\nBBgwFoAUxZBV2wV4t+2kASvNme1JO84eNQ4wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANsYvG7c\nSpWIxScpE39dQ32s2pNudMNIwyHl3+giyt+ZAiEAiEGvhSQKIApKsDLnYaZyawq/\ngW9vfFgxRLaNuoVt2jw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdow+NISoVIUenrjHPt9IUEjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTM2ODhmMS1iNDA5LTRmYzctYjljNS01ZGNiY2Q5N2RkOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8sDheJHGzMoiNVnEutoKO9E9xI/mD73StLxB/ygJFGCHu\n0Zs0dOcpkoVYI0M9caAqNE8QWiNZxhTYU1yd+J9Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxZBV2wV4t+2kASvNme1JO84e\nNQ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKYfRZoIMQcS70WjCkwXb6DVvolQi0kogKVqHRz6kERDAiA/c9GU7PIj\nmL4ve8vzBPtjI74dNUHmTzA8n/5Zt8hi2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAfbytu1XtCIxtqkD6xi0W2L3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmUxNjdlY2EtNDkxOC00NWNhLWE1ZDQtNDIwNjM2MGRlNmQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTU5YjQzMzYtNzU1Mi00\nNjNjLWE3NWMtYTE1NzdkNjBjZjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4QXmqfa7YNVRUiwWFoAXTTUnin6Emv/FwAspwxMJ6/dmH+06Q4SgDoW8AIt8f4j/\nhV41y/dmcYRxtRyhD5HzzqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvpZG9HDCy+b2onPN\nm613+sgF0C0wCgYIKoZIzj0EAwIDSQAwRgIhAIE2O9s/YBgmuR/G5urr/Pe/Wly1\nI2547ViOFbVmaWvlAiEA//nZCc0BxjO1s6tnPk8W2qYf18m6zBPwuxKYWtz6OsE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3709", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3709` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAYiZWE3So63LBdeDJqO5iKswMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2NGExNzg5LWUxY2UtNDI4OS1iZDMyLWFlYjI5OTg4NjQ1MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjcxYmEwYzEtMTA2\nYy00YzY2LWIzN2EtYWI0ODY0OTc2NjEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXbd+TXOjtLBHvFPDTyx5yYgDF4QVKkYKxmm7js23seopFOSKCynjGrlKAYvP\n7ESndicuSGAnVyA4PcZvVnZSJaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfu6OPy8N5V/cDMSFBdKtJqxBFV8wHwYDVR0j\nBBgwFoAU05KXuvBpwB+i5pKdjniO4oAb+fEwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCkkUia\nZ42WqaVwNnLegIVUVGRsG3CPLLFq6S+K/eXqDwIhAIY8bztu42hdpdDBuAh3LOHI\ndgeSlWhLw2shBaeFvxqS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYvf0XHBS5jQz6gZTB8RXipTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjRhMTc4OS1lMWNlLTQyODktYmQzMi1hZWIyOTk4ODY0NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8nnGwoetnwOK13/ICjPwYB+HprvLi1XS9Uezbo8J6cCbW\nbcKkqLPnn4ULiu1y0hredmJHutLK4wdv8TZXbWkbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU05KXuvBpwB+i5pKdjniO4oAb\n+fEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbn4ye0b/mWYlpN5Xq3GCjp4+VbdEeYr9ZphVSx689r8CIQCAl9R+Cnn3\nqjANjrSR8jzTuexSFclFNiWq40WFs1M9Vg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAfLQGlQL3zFFUhKyJGiMk9SJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjcxYmEwYzEtMTA2Yy00YzY2LWIzN2EtYWI0ODY0OTc2NjEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjZlNjQ5N2YtZDk5Mi00\nMGNjLTgzZmItYTM0M2M0OWQ2NmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntvjZ0lj5sL6lsdjnP3RbRXOsm8lQL7k8OUbOYMWSreZTw5nwOkpkV0A5Omx3fcxs\nd3yEa6dtRpb3GkvURZWg96NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfu6OPy8N5V/cDMSF\nBdKtJqxBFV8wCgYIKoZIzj0EAwIDSAAwRQIgUdTEMz9nIPbAiw88jZ1lEeGe8lLc\nVMq94WfkiSY7PiQCIQDnp3ahsmNRx3lWpvOrunxrZ1TKEaDvh5YK/9+Jp2nsbg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3710", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3710` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARA1SYNlhep2vGhRVQ1jVKRSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNzJlMTVlLTdhMWQtNDFjNS1iNjVjLTU0NWNjMmZiN2I3YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzkwODkxZWQtOWM1\nNS00YjhlLWI1MjEtYzk1MjNhODUzNGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGW9jZwAMKtnjLb6jMKWkpPYrYDJ/R9312aCMmAVhjcSUCnCNWMTFt99pxPKJ\n2basdvf+OtcsL43brTIds2eejqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBz82ZPXtfMDl2Vub6dQx+jWrrqEwHwYDVR0j\nBBgwFoAUE6AUIIvaRqaF0YUzLVOQTdo/+GQwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIFdGlD3AqUHsWAFUeqeHEAaOxSLZU3brUdyVIfd2UMHVAiEAxNtUYjZM\nA5ypS0AiikdYy69YLYU78rNUOgKdTLu+eIk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY1oLdbN605MiURqwOy3NnZcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzcyZTE1ZS03YTFkLTQxYzUtYjY1Yy01NDVjYzJmYjdiN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQR3C067SVyhTFmGDlb9Zb3s/j79O91AwL/MlN2kySXJrFv\nMmS+mk7dUAB+HDCPH7J+6MDxi9HG3tPN3OCVGKs8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE6AUIIvaRqaF0YUzLVOQTdo/\n+GQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJtzTSGxke5o+MIeGdUVykbiACCNUZsJ1434fNJQlE06AiAt24N+AOMs\nFro89sWeeGYk84+TgeblzaO/Wi0lM/PEFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAWKCKXeboyptpW37Sd36X7NvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzkwODkxZWQtOWM1NS00YjhlLWI1MjEtYzk1MjNhODUzNGQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzAyMTVhNWEtYmYzMC00\nYTNjLWEyOWYtY2FmZDJmODJhMmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOnOMzo3k4IW2fcnVnF9IYCQN/MRUpEQVAobAEHp4EaZPxdYYagsMSZ/ZHCjqf0nJ\nCSxVNpEfT988ZanVVXr7jKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBz82ZPXtfMDl2Vub\n6dQx+jWrrqEwCgYIKoZIzj0EAwIDSAAwRQIhAN50Q8iM1NaCh/5Tr1+vwMA9G8E7\naduzb1w1/kdQl9anAiB9dqcS+F6pzP1m9sAxUlz01lNrF4avAWiXA0NdX1IXag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3711", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3711` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAb6TT4IHHIa7E2yirnnMhmeEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyM2IxOGNjLTlmYTQtNDRhZC05OTliLTZlYWY2OGVmMzE5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWEyN2Q5MTgtMzQ3\nNC00NTE5LTg2ZTMtNWI2ZTU5YWY1ZmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfdm+38RGs7tLvHml8Roe2Vuat5IyFXBXjp8tzqcv+hR5q6a/wwu2r3B0TNzD\ntUy8YDxMY9d58luHB8Gepa6vgKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU81ajnT7hFQI5kcHk3fDC771x5zcwHwYDVR0j\nBBgwFoAUsX5bd7dUzVhbsgrH9FVibS6JhzQwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDwdzoLiPibW1hhHoU0dxK5Oww1o/Fn3w+OBsGzDxUaGAIhAP2NK8yF\nhS7y0x+/BKpZYVYa2EIG1s3BnC5MD/pC7TWn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARHmEqhhIpn7V1qnWmzw2WlgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjNiMThjYy05ZmE0LTQ0YWQtOTk5Yi02ZWFmNjhlZjMxOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIjXcnJENOsGl1x59p5ceKRlMW5w0txMxtCeyYocjCA1cB\nPAguf6lgrwhCkhVCSf6CCFog66030rs1kilvBEjxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsX5bd7dUzVhbsgrH9FVibS6J\nhzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaOpQn3pAEo6Fgb2AH9zwPGdBqJxmo79qoXJcfXlO4mQCIAa1ZxjS6tCA\nMqkLkHwDNC9jtbePabjrQGfFi2g5XSQj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAcnzd3cjBxMtF6XgOLg73Yz9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWEyN2Q5MTgtMzQ3NC00NTE5LTg2ZTMtNWI2ZTU5YWY1ZmMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTQ5NDg3ZDYtN2ViYS00\nOGNjLWJkYTQtNmVmMjY0MTIxOTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxAO8al9BaXeT4Typwza3lrVKNOUENLFsqgxvwKZC06+5/tFJscpsjTwwrXSxGSCC\nFGqkHFFYZRNXHbxgS79V2qNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU81ajnT7hFQI5kcHk\n3fDC771x5zcwCgYIKoZIzj0EAwIDSAAwRQIgfLaGc5JuP9kmYIfL4t0qS7B8nRjM\n4JzkGevc2XF0BP4CIQCGLhfP8gbBGbXGP2J24pqsU6rsgXbLaqFwcBqEO20x2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3712", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3712` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAUQH50NBqQFHeOYHQmHuWuS2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmYjhlN2Y4LTQ5ODgtNDMwZi1hZTgwLTRjZWY5NzFiOWFlMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWI5NGM1NzYtNDg0\nNC00ZTk1LTg4NDQtMDQ4ZDU0MmNhN2JmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERcL++OuAcpPXu6zNRkey6I7tCv4inHwn1pDLxtWnv/wUs+SOt9bFVmC5hznL\nKNoM05Cexm/kUniPUZHAzYG286OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF7o5G9NA6aeWOz2e+8CXQsWab0MwHwYDVR0j\nBBgwFoAU9PEss5N0NReyuaHMLWg9RI2Ec8QwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nICRKehOLBneyWq11FpSfftpNNUQNRCoqrZhxdiDhxDtSAiAsC4b5zUkIxFKxJ0nW\njgpzzZJwr09ZV3a8Cnel+AGNOQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcTBZRM1lAwG8fRlj4jwgxFPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmI4ZTdmOC00OTg4LTQzMGYtYWU4MC00Y2VmOTcxYjlhZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/Xp2zhwP4KZylvf+9dVq8hAdAsEtT8+8rH9HDtqZu17tf\nN8RFA5L2bW02r26By5oBRM6F6bbub2oBe8PQ1Pq1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9PEss5N0NReyuaHMLWg9RI2E\nc8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG1DAS2bDgNCAMEpKP6B/oy9PLlineaeLxq6T217T07wCIQDX9qX57Xdk\nzLjKhB6PDmipsGu/TJJ+wIghWPJGeiTUdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAdsj9Hhs9tLgYOsHA2zrHLktMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWI5NGM1NzYtNDg0NC00ZTk1LTg4NDQtMDQ4ZDU0MmNhN2JmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWU5YTE1ZTMtNzIxZC00\nNWRmLWI3YzUtZTA2MTAzMTk2MDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUVSOFfHp100mn0nc3Zz9H7VPOT2TbBnfC+qf6U0dFyFg5p/bJNRgtpJRlDKfdTpT\nVxNgg5pPBsFuVfcyCOFy7aNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUF7o5G9NA6aeWOz2e\n+8CXQsWab0MwCgYIKoZIzj0EAwIDRwAwRAIgOK8ImqDUVPdIgtLmoHJShUiPKI1w\nhfV5ku2emZExMaMCIEtZPo3IaHQl/E+DNfvkQipTfl8FNTnDZ67zVMLGROjf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3713", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3713` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAci2nLLVCZOwu4RrjmLrXrKoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlOTY5Y2E4LWZlNDctNDU4Yi05MDBiLWYzNTNhMzhkMzE0MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUwM2JmMmYtY2Yz\nZC00MWU3LTk4NmItMWNjNjgzMzU3ZTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjqcGGDFXpLeKjTlUJmwyktOuC+bJyiewGcj7HYO/OyCcRBtx0ynSPA1THFB/\n2mDHuY+MoS2lV+KvP0WcLlPdvaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU54ybJ7MpI79WKC6vjLEgTa1RVQEwHwYDVR0j\nBBgwFoAUU1ymhbJbj/NNzYdfxIETmjOIbRswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIGaihUZwnjZIsg3CIj2CasTKJFE39/x4RcNJU3p8bawqAiEA\n+okEW+gcwIaD8x71LyVPcLEK3iRTo02TL2Le85eiMvo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5ZKL77mni8nzEaGmqOQ58JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTk2OWNhOC1mZTQ3LTQ1OGItOTAwYi1mMzUzYTM4ZDMxNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6iM1Mgqzn890aP84mA2Yl8IGFMiUD1E+HgeQG92j+Y3EZ\nKwiyH2bvWeHnV7Tt/n+vT6VRpFsS7sbnYeZbgb4mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU1ymhbJbj/NNzYdfxIETmjOI\nbRswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGujYwTXyhqgsLcCBVDgyhG2PhvVJY3WamZa7U/7fPAwCIQC7hnvSth/c\nmsfm9UsBlldZZ6QNoNBFZcoG2FyAGUBIgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAVWfC/W+8HJcAuf23QzFZZyyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUwM2JmMmYtY2YzZC00MWU3LTk4NmItMWNjNjgzMzU3ZTAxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjBhNWM0YmYtYzk2MS00\nYmQ2LTk3MmYtZmZlNDZkMGE0NWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFuGjjJx+sJ/kXnmHzigMZXlRaoPazkSDVeL1jMrNA84tVddI+XIbSxjy/7qv76oZ\nD3N6mqJnYjyjJWtrG9w0VKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU54ybJ7MpI79WKC6v\njLEgTa1RVQEwCgYIKoZIzj0EAwIDSQAwRgIhALhJy+ncRDotq4WFORE+KMtTgeHW\ntdluZXPQx6DZDFoEAiEAmO+66UgTfbrMQUFsqng80a7QJn+cJnY36F1yrlpURDw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3714", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3714` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAdeKMsypZMWMDjXq6gKcWtIXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0Mjc5ODlkLTJmZGItNGE1NC1hNThlLWZiODNiMzVmOTdiNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM3OTEzOTQtOTNh\nOS00OTVhLWIyMzAtNGUyMmI3OTQ3M2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9OWoeaFNao0GTAMB5LvOy1scZHAFJhTjcB6IDzAg6a7LVmVE9m0MIx+OxW1/\nDbua1ujaYavxhWlSJZ47pm6oDaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXKs+AXwKUNwFJRMFY0XJUD1gfEIwHwYDVR0j\nBBgwFoAUfXNn4j8w0zN8AuDqmJSPJ/sbyGIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCANycRYaJGu5TnEc7kbAfDgZS2yI2vf/outIIb5MZ2ygIh\nAJ5J7Ov2eYpO8Ox8o1hPZJkLgz5WkQsIDOdA/3Ns1hcS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAejbaxfpJdBLrxNi66yJj9dpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDI3OTg5ZC0yZmRiLTRhNTQtYTU4ZS1mYjgzYjM1Zjk3YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUFiSdWNp/r8MpPhHL4kcFLhxPnWfuoAxdN9EOXlOU7azH\nLvYeXNcFUlGukXRDbcx520KYIixH3mrQ42Yzkc5so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfXNn4j8w0zN8AuDqmJSPJ/sb\nyGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP21KnsgGiBmr/kJ8jrnQxPraJ26B4mzeAiHP/uKfDIzAiB9d12a0jNU\n8NcQFgUDQXLT7z6L3MOlPEhukIma7aDcWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAYeJ5cD9GhdfOnrfm65YA6kjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM3OTEzOTQtOTNhOS00OTVhLWIyMzAtNGUyMmI3OTQ3M2ZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDA2ZmMzN2MtNDZlZC00\nYmNiLWJmMTYtZjQ4ZjUwY2Y4OTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTWmmcvnFa5cNu4tyLXwh3HjhL7JYsY5eR1QR9aSWFqPJQWxR25o7bQKPsP9xEjMM\nh7rWRKSgrBoAu8eBs/BIq6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXKs+AXwKUNwFJRMF\nY0XJUD1gfEIwCgYIKoZIzj0EAwIDSAAwRQIhAIcM5nDEJB2ntN6syX++sAxIC6rD\ntpvJacmUp+v1HJ9PAiBz9fOoonxV7Qpw0h5b+yNPscaUYZGcSZA/1E1DJYHG3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3715", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3715` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVgSmpo+3xuN4ARCbbdNU+KXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3OGI0YzJlLWQ4ZTItNGZmOC1hY2VkLThmY2MzZmQwNTRmYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NjZjg2NTMtOTE1\nOC00Zjg5LThiM2UtYjI5ZmFlYTY5NmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbwiv+FwKZKvJv6AHT+lV+ubjf/PfFBKlrVD1H7r0GP9FuAzGZEoC3GE6P5Er\nxG8kERimR8m65TeQ4jPRLbwP4aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVJ6GFb7MyZAbjVMIt8jL+VtV39QwHwYDVR0j\nBBgwFoAUwN82HSBj9i37Whwu39gmRGJksk4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDsmqQgCMSO\nf73if6ljiEaeh8oCvqvnOdEYRyDDEad7zAIgWYVt84zEjlnp3lZiXbeQK52aq5O3\n2KURISPpkHSyJx0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAShWgusgHsUdmpHssIA5u3quMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzhiNGMyZS1kOGUyLTRmZjgtYWNlZC04ZmNjM2ZkMDU0ZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu4afA/LoRY3PxfHyKj1kDQ7ExsK3CWWc5ejPwyBF2cMKc\nWKEa80Z4W3uelphuYRWfNCVyc5zJMdPMBU0XV1Mfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwN82HSBj9i37Whwu39gmRGJk\nsk4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKA4UbrGEhjK4KMDSMV86S8dbUn0PaWrpC8/TT4mCFz4AiASaRJtFb++\nAZr9z0AUMmSDGuE+ed4EuM2sz/31oK+Oww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAVHDLPK5TXpr6yQZ9HilNlcgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NjZjg2NTMtOTE1OC00Zjg5LThiM2UtYjI5ZmFlYTY5NmVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2NhMTRmYTEtZjA2YS00\nOTllLTlkYmEtN2QyNjcyY2UwMGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHwOYZUa3Eh1Xue76QMaNRS6lsm77t0wGHleIK5FfRBTY56UlLrDBT+rWCSz19zgz\n9g7An5+qRUGMUFde3/gilqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVJ6GFb7MyZAbjVMI\nt8jL+VtV39QwCgYIKoZIzj0EAwIDRwAwRAIgZxNu2mh4OUANLrtIVc79vV9LyZLL\nY8NVw/JvxQ8DzaMCIFZaJjazLotdiPhF1i3pwntiJyaubr+3OCTE0u2g3dYK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3716", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3716` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAUWZole0XahXewsy3a9uOvP8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2N2JjYThmLTYwNTUtNGQ3NC05MmIwLTNkZTk5NWJkNDI5NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk5OTVjZjYtYjdm\nMy00MzI1LWFkNDEtYzMxYTY1ODdiZTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOI+h7RXmIH4HQ8g6YyacdxrNemR6JWLOhq1PqYGQMDXYK8qVBCI7916hvX52\nfH4KlziNswgWzjkpCua7B0x1FKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMbmnTb1K2hPzzElQMfoQsWnXbAQwHwYDVR0j\nBBgwFoAU4odrmPnqxSbzHmG2UzL+DK0QZF8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgLQ7I3SjUACBrG6yf5fnaZK7ScAF//S/63Ib+xpVO+6kCIEfkFa1TB3Zr\nHhv50RywCxvVTx+c1aS/NIs2UjmuHF5W\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAdLtMfnmERa7AG8vUVAgb4cfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjdiY2E4Zi02MDU1LTRkNzQtOTJiMC0zZGU5OTViZDQyOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnhQqmFgA25eWqceO/F+uOCZOyuCbeK9fyXTG8voUby4Jm\nlAdxrnLyQPveBgkL7+bACzg5uCWT5TUnnNuo4bJ2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4odrmPnqxSbzHmG2UzL+DK0Q\nZF8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIfFYVK0XOvfLQs3b26oTk/xCIAfGVGRcXVLu451eCUFwIgXyas5SipTDf5\n3GuUeFRqZhMPdsrRQ8O1BGnKznf8CqE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAbpD9LPFUSc5GgVTB/k6xuPLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk5OTVjZjYtYjdmMy00MzI1LWFkNDEtYzMxYTY1ODdiZTU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzhlNTQxNjItYzEwNC00\nYjNlLTg5NzQtYmQ4NDU4MWU4MGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbJ3AnEOLTPahzf0hifggRR5FKu4doMe67Q6Y5cNOazUWFCUwh1AtBPg2pWMgTbLZ\nq9NQMuamTc6bFw/fFycs+qNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMbmnTb1K2hPzzElQ\nMfoQsWnXbAQwCgYIKoZIzj0EAwIDSAAwRQIgXHwewIe+FzLm9xnLIU63iMExiE8D\n0HH5MB2AliuoJMYCIQCF2T+dB/Jx5/wXbWt+zaoU2hgn4PeuKfJq0AG3jAnDqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3717", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3717` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAar8clwsRd78ztV90i0Dk8AZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0YjUyMTg0LWVhMjYtNGQ1Ni04MjJhLWI1NWY3OTNiOTBhZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNmM2RmM2ItNzVm\nYi00ODZmLTk0MGUtNjZjMjcxN2I4MWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER3spPlZcuscFGd47FswTGlKFzvL0Qs02b+ErGyWpYTxlorQhA6XQR33miQT8\nVpkaxpB64ZOI60veZ2wHzNqujqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdRQ3hj/54UyjiywpMDr8n/OvT+AwHwYDVR0j\nBBgwFoAUSw5Lez+edKBEbnWhhEZUYIsKhaowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgVLNjsQK+VCEsZOM5XytUMDYrZUaCzR2HJnPCipLo8egCIGMDoaUM1nyk\nwkuQ9K83/c+qGOoiQFBRN6wcO3ZLWLJu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbRgwuOjJdi/b98w9ytgjiF8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGI1MjE4NC1lYTI2LTRkNTYtODIyYS1iNTVmNzkzYjkwYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDrD0Ke6pXiWDr+S8TnkDcvExTK6AT9msd1x6/FOLA5qHM\nSpEXPngxK01FatXGzzLA9VzCLpUzqFrIfOFfWWSfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSw5Lez+edKBEbnWhhEZUYIsK\nhaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKq6+MfJKupDQmohVqxtfWEr0Vjz/kAD8xLK8SSZz8rQAiEArsGXVPyE\n9dIaQRALMHvnRJVC2MFTBXiavQQjVhzTqM0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAbvtx2n0V/rJdSBQcM2PjtghMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNmM2RmM2ItNzVmYi00ODZmLTk0MGUtNjZjMjcxN2I4MWNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDkzYjIzZDItOTI1MC00\nZTI3LWI4ZGUtYWIzYTQwM2I3YzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5gXR+ZBHFfn/+Mrc1+cWGRUNaeEzNIeYk7Z0RAWHBNl3QYtj+WKZooqaoj/f2egS\ngKaeh/3dpTBuziMLLXvkLqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdRQ3hj/54Uyjiywp\nMDr8n/OvT+AwCgYIKoZIzj0EAwIDSAAwRQIhAPmWc45RkRNPwKkR/UGu+M2o17F7\nk480Jis7vgXzFcyuAiAGMvXSmbAyOwUHkeOOA4Bhan7nPnlu8o1jI3yjY2sLew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3718", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3718` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAfCsb8rvFXONTULTWkhwvG7JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0MGMxZWM5LTczODQtNDkxMS1hMDNkLWQ4MTEwOWVkZjllMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjgzY2Q5ODgtMDRj\nYi00ZWEyLWE1NDgtNjY1ZjY2NDU4OWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1cdh7yJ+Mv2e9jS8xlMl81OnHLjgAIcNmVIYTFl/nhczcKRdRr+Wz5sLr5rD\nTbsBgW7U6m4AwOWeUIL0Kp9OaaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx1s0kECbCbOVhO/MLxeJsyIr+v0wHwYDVR0j\nBBgwFoAU/fV9Dvh1iuL3h9hxGmu2IkTMMDkwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCGj1L1i9O5MJB8tkcpQ6Cmd7dRPwf631xfIi2WO4JEDwIhAKDEW1BO\nqtyxp8+aEEjYv+YByAQxC9ZEBUU+bzk+gLjl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARwMtWGFXYLwuHsekwj8ML7zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDBjMWVjOS03Mzg0LTQ5MTEtYTAzZC1kODExMDllZGY5ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPCDEqoQAYjx0CjDX9YsdRnv1ImVrIE8WU8VALhwiDEpH7\n0Cv6o1Gy5XKDRqvcLo3zgVdIZyC5skurWuuxBZkIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/fV9Dvh1iuL3h9hxGmu2IkTM\nMDkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOF7sqPrXlDNgMXXhDdtLc7IIMzapOTcgTZwemEYS2DXAiAVHJDtAEZv\ndp/mwwk48uLVpYQUJjeuV9ZAossT6/Udug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAQp3SjIajG7rX1x3Mv5AJMimMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjgzY2Q5ODgtMDRjYi00ZWEyLWE1NDgtNjY1ZjY2NDU4OWQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDk0NzI4OGMtMWNlZS00\nMzZkLTk2ZmEtZDhkYWExOTJmYjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqTu0Q20+LYtoThUuPyO85+O8wbFcedrwoxrfjkugIwYkg8vPDynPBThgYF7Xkmwd\nIc0qUrmn4ErT3Qp+sap1J6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUx1s0kECbCbOVhO/M\nLxeJsyIr+v0wCgYIKoZIzj0EAwIDRwAwRAIgLc59dP+a9bY7njtvU5135mi6gpOa\nXqodU+OUEtPFaUUCIH0HsBld2fHks1vslbJXuIfsAAVC82q1KwzNotLA7vdz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3719", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3719` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZTpem2zOrnsuVvv9JgUzRj6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1OWI5YmZjLTUyZDYtNDc2My04NzZhLWVkOTBkZWY5ODFiYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg5M2U1NjgtNDY5\nYy00YWFkLWFmZGEtMmYyZWZjMmYyYjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELKG1JXj3nf7d/UTY9s4gZYZ2i9M55CzAYJc7DVlo+zNcbV5UnCKfYS8Y9bV6\nBva0h5VqMzjka4hnYFMsMoTR4KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlKG8J0unWFo7racD89wtVwrAEzswHwYDVR0j\nBBgwFoAUb9g7DLzDf1Rwj9STx4Yry8j0TiEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDsFyc/dHAl5L7WuPu4wLc2Sk9tQCOjtpCKUJiit\nH/lNAiEAsYzFxBfWgJyv8hw/tan9wD0PRYQxEPkBEiO0iFFTBNw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARmyCA7VswHky0zlIEyBIAmOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTliOWJmYy01MmQ2LTQ3NjMtODc2YS1lZDkwZGVmOTgxYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPxDbWVG0oLaXdgjgyBz0z0hVStoAv54APd5Hwfj35U0u3\nWhClNONeKKbNJkNYsRZW04TQ4BQe6Hzm8oYztOW5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb9g7DLzDf1Rwj9STx4Yry8j0\nTiEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO5V9nKUwlA+AXyiKHAZ1/VHrEBwFURQ4Zz9mHb234cHAiAE67K2g+WY\nhuWRJ0wCpiHV0Gkc8ZFxfWtngMbNKfQLFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAXX6+DWBCLV442pB/RDg3YRFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg5M2U1NjgtNDY5Yy00YWFkLWFmZGEtMmYyZWZjMmYyYjg0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTAwOGVjNTUtMWY2ZC00\nMzE1LTg5NzctYmRiNDJmMzI0NjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nl6BnE8rxUKFsE5qoe4bYlbu4XSb6IkeisK7rbQs33Ca4U1D8An2zBR6XdQfnN3Ue\njq8u9nBrdJFcIp1TTD2jPqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlKG8J0unWFo7racD\n89wtVwrAEzswCgYIKoZIzj0EAwIDSAAwRQIhAIcAaZuOPap3PiMiZ8g7l/BpdZr6\nRkKbF0moXGZlcoHWAiAfGdzZBsW3Q1HF+limCaQhn9NHtdIFF/lZAm7iXuUl+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3720", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3720` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISASWifX+YzbyYQSm8g8acoTxlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1ZmVlMDBhLTBjOWMtNGE2My1iMDkzLWY1NmJjOWE4NmExMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE3ZjhhNGYtN2Q0\nOC00ZTljLWIxMzQtNmJmMjMxODM0OGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhJPKYqlCnsiMqnJEAspvwtEfhVzixgYHBMQdH9+E2axJ6T5pfOKj9RVx4jeH\nN0n5TQE9GjBvwStNuS6V+bSpjqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfAFi87kF+q4uVaEx+c23mBiwH4swHwYDVR0j\nBBgwFoAUuz8uS5HeUaUUbASqQuOZvTOTwjIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIG5msiogFVoEr5r9Xbi3kd5ZRfgYpp7Tv+J67zwz\nQsNcAiA14mA65f0GNP39bDC7oepkJb2FexJN6b9TqVxFdnpm9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeFqq+qZgPf8AKOIAaWR5HBmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWZlZTAwYS0wYzljLTRhNjMtYjA5My1mNTZiYzlhODZhMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATU8AfbpxKfJL9tj2xF34lv8WVtxYYF3Ld+1M/jDLQuLbLW\nKSYAh5EWnfkfuynviy7HB1lBBGh7M8ImKltMqMQoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuz8uS5HeUaUUbASqQuOZvTOT\nwjIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOKhgaHpZjVHCyEzkIT+tnvTuxC3Xj2oGMTCPbD1qA6tAiEA5hZFzG3N\n+iQ8IVn0FEX22YyAgQnDc+FyRFL7iuDPdVo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAbBWHCx5EneUOjUDNqZ8Wd5zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE3ZjhhNGYtN2Q0OC00ZTljLWIxMzQtNmJmMjMxODM0OGIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGI1NWRjNTYtMDBmNy00\nNTA2LWFhZmMtMjk4ZGUzODY0M2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7oHWzX2HsALnJ6BNqjmlDFdG0Y88j9mvxcGgnVUNDVO1dG0QMR4087h+aF4BRjZO\n/sK/FlayFi8r8MYNRQ66kaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfAFi87kF+q4uVaEx\n+c23mBiwH4swCgYIKoZIzj0EAwIDSAAwRQIgctjNktheEBRPYFn777DkSO7Ujsuk\napzKsOgK4Z9MQgACIQCuiJUGVMYJEgIOiQ8pOdD8eqpPciHPbdL4GgGf6Oqu/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3721", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3721` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAVdkL4jZiLu9sX+bGdVQftA3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxZDlmZjg3LWNlOWUtNGNlOC1iYTJmLWJmNTYzYTNlODU5YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjkzYWE1MmUtNTJm\nZC00ZmY4LTgwOWItYTIzYmQyMzZiNGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2w0PUV3CflNVHDqq8kHtJ4+5BzbUxQdCelgR+hxScnH1qBXDZ606xsJGIRrw\ncXZ90ykAXIi96EixwBRWu6yOb6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOJ9S6d0TfTPCV3GhnB+f6BpxGTgwHwYDVR0j\nBBgwFoAUuptMZxkGfQF/zX9fHqvTjdijLDowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIHBJ3DMJGHlo66R4mcEBb9dXuR4mx2xMqZ90ISBIp8adAiBZ\n4+2WStjbE2LbzcehddhJ6sPkTBnEEyiY4hjz71XtUQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbTNALdsC/BAlqLrbjtcxnvdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWQ5ZmY4Ny1jZTllLTRjZTgtYmEyZi1iZjU2M2EzZTg1OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBaTcAl1UMclUD/MTZYJNsP7Ex7q6VSM3rBUhgVInPzs6c\nui2urGqwjjQs8gssGUo/7vwsYbHSIwBlW5IWXe7fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuptMZxkGfQF/zX9fHqvTjdij\nLDowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPkFCKb0TCSf7C1s6XKqXp1gx+ZYAqtRszf56QJUbc4lAiEAstbTnolZ\nEy9OeSwP0lxuo96vs/9y+DqlvIQdMv4EfOk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAQcL8k3P1OU3auxxz8nan71iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjkzYWE1MmUtNTJmZC00ZmY4LTgwOWItYTIzYmQyMzZiNGRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGFkNmUwZTAtYzBkNC00\nNDI2LWI1NGItZWRmZWNjNzE1NDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nABvJ6KtvgwFIMrIQYLBpwHYr4by+yS7KBCirPhpiGVztTbDNhO8+6CPruRgbLcy1\nl6FBjj8Sf6FfAU3pLK5UKKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOJ9S6d0TfTPCV3Gh\nnB+f6BpxGTgwCgYIKoZIzj0EAwIDSAAwRQIgNFQHW1aAJNOWH82u5p4i5k1OEKM8\nuEUNKr5lI17BIBwCIQDhCuzrCjFLuDI0wlOB4P4zY4NCKtC7r0QLFocfr9W6UQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3722", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3722` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAWnbmkQqP1J2sSVc6C6xEobsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxYzQyNmRhLWI5ZGQtNDU5MC1hYzI1LWI0MmYyZDViZTNkYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQ5M2RiNTQtNjZl\nMC00MzNjLWFiZjUtNjA3ZTFkZWU0YjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGUtuA9DsBY7qplhxjSKOyO0RoyJcYz/HKJr2Qpg4Cx4vwnhUH3lgLAZwAtyq\nw2KLjL09+UvyngypNpW/Xqwvh6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5c7KkHfKAu4dISBqANBlJZFkT6YwHwYDVR0j\nBBgwFoAU+oIv+qPxC2wwTFlDok6YNphfCTIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGK94XdmBGX8X40KgNK27MxVvRR5Sl/9\nuM1zlEq23/G3AiBRLV1GgntKkV1L9obCr33SQSbUYYN93mWuirkqRUJafg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf2ObCsjpPl65y3ofOsw44KPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMWM0MjZkYS1iOWRkLTQ1OTAtYWMyNS1iNDJmMmQ1YmUzZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMiJcwhPJXQ25sqCYB+U80VoOevzPCV7LCoNmtVnlS5t8A\nNc5XPg7MoT8nQK3pr/UhIqGE7N7Q+ivWCV4wz8hao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+oIv+qPxC2wwTFlDok6YNphf\nCTIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEjycwXySQXpsCEL8ZGjrPvVmCgvY2xqw5VUMfblHz38CIQC2h/aIw/Mk\nBt3+DUHlnuNvMR/4K5Rr67C+1rSjINgcpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAT1ltDKWwAj4h5JT3zbpJscrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQ5M2RiNTQtNjZlMC00MzNjLWFiZjUtNjA3ZTFkZWU0YjZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmUxNGY3MzEtYjY4OC00\nZTkxLThmYjUtY2ViNWU0OGViMDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nO8IEB7/aLhY6BCURMSeps25i+Avhg2q0UJ7cCqX/Fa6zVd6WAp4FIVvbP5c/wC5J\nTCrVqJoyrWRopS7CNaBLKKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5c7KkHfKAu4dISBq\nANBlJZFkT6YwCgYIKoZIzj0EAwIDSQAwRgIhAMRGtPVMD9cq2EKkEvOut78Oal6X\nLoyjb5xw33aG8K5NAiEA2vH+3yDp6+hFbpCqcbCo33GFgrJ9RWeMNjqvOeCIsls=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3723", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3723` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQqz/UDujgsVAFYD8xXrVuF/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiZWFiMWQ5LWYxZmMtNGRlYi1iNzU5LTAzZDc3YmRjNmYwMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWFjYjNmN2ItZmMz\nNy00MWIxLWI1YzMtYjU1MTU4OGQ3MGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELwyUzsL2hJtL2857Qwxc3IzT7CGmq7faTTIdcOn1QxIFp9S2Xvgh3gHWlmqN\nx4Qe2SiQzAKaaLLu5FaYFLqLW6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJrFQLc7uobyN88vwJyMHuQR3CnswHwYDVR0j\nBBgwFoAUtgIFDJEpwBouNfoQ6RveeVJ6odMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCct8wzKPVVUt2Cx5TFCjH2YiB4RgaV\naTC2JSD/KV9TsgIgb2nXRehV9SQe6Sp2SiVgbwcl6aJ5uUR/ZAU9iIieQlY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeUoQYkdq13PDM9SKJMV8OVEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmVhYjFkOS1mMWZjLTRkZWItYjc1OS0wM2Q3N2JkYzZmMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfIVAQyhWT2FrAo+VEk6S4C3U8iIvy6ODUyVU+JJnw3H7I\nBO6dUOzZLe9VdJzOVz/Yz4b+5RwOcKrOHRqf2Qelo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtgIFDJEpwBouNfoQ6RveeVJ6\nodMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI09bVHTjBRBFIWqt9R5ezKTTGz55RD33sO0mjKnpSCsCIFpNazW5lzYN\n4alsNYXzFRNlxnmadYxUwuGZfKip9Oqq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAUe3lgKErzUF2srPQ7Jru6H7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWFjYjNmN2ItZmMzNy00MWIxLWI1YzMtYjU1MTU4OGQ3MGZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzExYzMzNzEtYTcwYi00\nNmVhLTgwMTgtMWFmN2UxZjU5MjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFW8r1tS/R5yZ5rQNZQKH2xwMaQ1zlw4iEFY0A8AWxbYpz9VSQ31znu7a6kRxOByQ\n8MF17W8+r7bpfV0wf0RrcKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJrFQLc7uobyN88vw\nJyMHuQR3CnswCgYIKoZIzj0EAwIDSQAwRgIhAJT8wx1iS9428eW+TjL3anWMmIXC\nJuctM9hRhjUEQbiaAiEA8yH5l7vN8liOHObamCig+d1Ov+oIfA3yQ/oR6OJP/X8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3724", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3724` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARruFwOqwy8/wuJieNMmm+FNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzODYyOTJiLWY4YmQtNDE3My1hMDAxLTIwMThiMzRkYTI2MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNkNzg2OWMtYTNh\nYy00ZTE3LTk4YTUtMTgwODVjYmUyZGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET3dJc/YYqP+s79XKVa0JC22J6Bc7XwiMgzMU1/jAiJSQ+uNzpL9ua12ag+qe\nVFc3szMLQK3m4KzkRSPfw0+yVqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs2yHWHXOGgFrM3RdDmSXWFmc59YwHwYDVR0j\nBBgwFoAUc/fUO5CBk7TOBoZFod6LKsj3buQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDaQGFoG+/n\nTTsJgjL361KX8wknGsWeuXO/1fDvKJRhZQIgUqdvhclZ6D8MjPTm5bscZVMkmAH2\njpncAZKy7Vh8gto=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXZxsHdx4GkTQdetypNwZm1xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzg2MjkyYi1mOGJkLTQxNzMtYTAwMS0yMDE4YjM0ZGEyNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR82vv5bKg9ZZ9AoaVjp2IgZ23H3XrJRSY3O1ke1/D97hUS\npCRQpGRpetI4ObxY9EA3qQ9MmtqkeAqOaZY4/w43o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc/fUO5CBk7TOBoZFod6LKsj3\nbuQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCGWJco/JsbDkks1J/ZYGyYf/Dgxiy/NgCLiCzIxvsCcCIQCDt23b7zOM\ni9gQBL73600VB2/Rx3QapdUyjpP+TXRqww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAa+M2Bx4LGQFjZ9KY1ZBKelMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNkNzg2OWMtYTNhYy00ZTE3LTk4YTUtMTgwODVjYmUyZGE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTczY2I0YWMtZTMyNS00\nNjcyLTg3ZDctZWQ3MzJlOWM2ZDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/z/lzoV0UXnXbICDXPIoOFiwWxYoNFd8YQDB/lvKXidNGjNFV33HYUiaMKVpUIcx\nfwIvJbhCwaxHoyakrnP/xaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs2yHWHXOGgFrM3Rd\nDmSXWFmc59YwCgYIKoZIzj0EAwIDRwAwRAIgBDXdaCrfaun2qZLSKEXUc6hFT8te\nQxlHaCy4B/U1S1sCIErgNE97geBCaFaLmAOI73urNyd09Fq5HCq9wo4+KjMJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3725", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3725` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISASC4ZTUdaiDbIzQdHmCkf3vkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0ZWZlMDgxLTI0YTktNDFjMS05MWRiLTM2YTc4M2UyNDFmYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM5OGMxZTAtZTQz\nOS00MzJkLTljMWMtN2Q1NzI3YjAzZjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUxWJlIu3OcHIpooJ3OjlVatokegKW/LkjDEyCzGthktc3XwbU+jMbN4SJft5\nJRojbygL9UqVq2M9oIdjPLhiCKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBF0C+ALPFDXZAxxmXGZgTf67Fg4wHwYDVR0j\nBBgwFoAURHgVOx5L2z4O+amDkir35WJM+/EwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAOtrvdPX+6T8qWSnzoBTtz3ogqzpGC22CNa+yW17e6T6AiEAmJPQDEFb\n5vQ/xwVB4eCTnDgqEwXc+a0nWx0qR/kSSNI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYfBeNG8JshVqPSKHVnZFm3YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGVmZTA4MS0yNGE5LTQxYzEtOTFkYi0zNmE3ODNlMjQxZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaJ5FjmYaBIy+cz7rYLRqIET74Z4LsVM5IaJobeI6TRCb7\n0iVo7WewUOH83aW2oCQZhl+rFWZ2TxFiUf5qb6c4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURHgVOx5L2z4O+amDkir35WJM\n+/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJTRpLQFf0C76i0vegvTnSwjl6dhMZrBa2ens+fsMEDwCIQC9Lu5Akh63\nyRB6prdrmZ5YxKxunBEnv0hsPRfav5pphA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAWc1cBLiKitsfJddFkRiOkLKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM5OGMxZTAtZTQzOS00MzJkLTljMWMtN2Q1NzI3YjAzZjk1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTRmNDRhZjktYjJmOS00\nOTYzLTgyYTQtMGIyYjA3NmUxMmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKP/SoS/IHNiQvk9PoWcS0rVIOyuf0uNTArs4HMPML4FNGiV9Wl/TZzqNhdLd17+K\npSiqaBoOFFsCHv2QPkoe+6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBF0C+ALPFDXZAxxm\nXGZgTf67Fg4wCgYIKoZIzj0EAwIDSQAwRgIhAJ8hT+gkOUkmtqIXaKW55JmGyL9/\nAV7PPNvQA4XFYkQEAiEA/n8Qjlu1lKEDKDEUHYlQIpvlibIhiphfu6ROZmxd0Ck=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3726", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3726` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAdFvLdXF1/EpQGTx6ys9RMi6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2NzExNWQ0LWFlM2YtNGJkOC1iYTUxLWQ2YzYwOTVmOWRkNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE5ODIzMDMtOWQ2\nNy00MTI1LTlhMmUtYTYzNDY1MmNiMTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+t6fF97E634gRJAim5MUe4HM55ULp+KFJ+EEqgrMaIqfeeKUye51prsSRRN4\nQtHjITIJbuQlsOdhqoPn+zxaraOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT3I8Ki7Tof1/qFOnb48EeyqAVUswHwYDVR0j\nBBgwFoAUgjS9Kk7fdAD5OHtk//owIfc4CLUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgA6KpLuHLXcH5qRDm1pV7+InWlejh8OMf1+ANldY5ZFICIDMZIeBrjbGB\nCptEkam4iCOc5D4WUMv+M3Dzmbg/+iuD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb8hMcXljTnhOnsvhda3XyEsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjcxMTVkNC1hZTNmLTRiZDgtYmE1MS1kNmM2MDk1ZjlkZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrfbFcwPRqG08rIdIDQU6iqMSawhYImGvfPVu/9/RhC41t\noD/HjBMtQR1ZBEb9vDZtoA5Rl+V4LKnS7Cox3gGao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgjS9Kk7fdAD5OHtk//owIfc4\nCLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJl+yBMfFBa23sYoivED47+37YdH9Jh9tt/Mwlh44ElwAiAE8WWcD0pd\nlMQieNZ1tmLBZh3j8VB6WLDRuqc2WmCCdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAeC+RBpQn6NIJNa2AKP7RorhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE5ODIzMDMtOWQ2Ny00MTI1LTlhMmUtYTYzNDY1MmNiMTlhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjYyZTdiYWYtZGVhYS00\nY2IyLTgyNWYtNGJhOGExMDE0MTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nk6fbCcvkA7n5wi08Fz7mcQLO2/n0MpmdMhtib9pGmJ8ZbHn3H5fY1dDSFtVvH3to\nlrcCVh4yhczkWBrvdMkKEaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUT3I8Ki7Tof1/qFOn\nb48EeyqAVUswCgYIKoZIzj0EAwIDSQAwRgIhAJCtTDvp2ovkkq5BVp/WpICCn/VJ\nAB2DwVtJGfyCIBXoAiEA7COF4bbWGo8B11YVl4Ut/pi9B5qDxMv2k18ry07FQMI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3727", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3727` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAb85d+KaOnRbAvbp9FQSXqiQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjOTQzZGRkLTExNjAtNGYyYS1hODJjLWE5ZGI5N2U2OGRkMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjgyNGUwNjQtMzc3\nNi00NzhhLWIwMGItYzQ2MTMyOWYwMDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8MPBk/5zL0uIj8s5EiVEG4g4RrGjOYiHXfBnk1qBfaLTYRAFW+UkNfg0XI9V\njWTsklKOp2EU7Y8QP9eSKrfvlqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEecA6yb8ZB+FtAEiTIft47TbvaAwHwYDVR0j\nBBgwFoAUJL+yjFA2RCPuQaKD2e5TGbSrxtMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDZwDIM4wI+Q/xxtfJqeXOl1fkeZWh/XlQxGYeLsV08yQIhAP2wyvEq\nTNl+UYQb2O3ZNmKPWEgls1ow2w9wl81tfUpJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYUsn88vLqas59ZNzASoN94JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzk0M2RkZC0xMTYwLTRmMmEtYTgyYy1hOWRiOTdlNjhkZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYsGzrnV73VKC2Z5Y/s88lHdZ2eDr0jrGatEz2VR4gChzm\n8C6KrnJLj5SvL3HWYTWWn85FYgUeKPIFeRcIWRwBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJL+yjFA2RCPuQaKD2e5TGbSr\nxtMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSQos4aupcAT9xx951mwgQjflcMIAzgtrb6EIR7u3gRACIBg1eGWzLNo1\nNmtU6H/gamvsD1zhxC/GUCf8awvUh+pY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAQdyJ+ffAiVbisMWCirvAf3XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjgyNGUwNjQtMzc3Ni00NzhhLWIwMGItYzQ2MTMyOWYwMDc5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjkzNGIxZDgtZGZjMi00\nNTdmLTgzYTQtMjBiYzM0Y2U3MzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nH4I3roF0EZ29aL2A687ABoKJlws1Q+zFL3nWEXG0nTBjSRRi4fulaexEDby9X620\n0nayazyY2W8J4PboKnxnAaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEecA6yb8ZB+FtAEi\nTIft47TbvaAwCgYIKoZIzj0EAwIDSQAwRgIhAIuzfo2mkL5u3+4iiwGJfYYpL5nc\naifOyIT7teEhjPyxAiEAiSRVS7txkG9D8yyDkK7uIq/2/YtA4Kr7fTF7gGDNUao=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3728", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3728` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISATzFy4wj2qZFuuOsGjKD1cqPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1YTA5Njc0LWMzNDAtNDQ4Mi1iNzJiLTg1YTY1ZWU0OTJjNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUxMGE2ZmMtNGY1\nZC00ODg0LWE3ZDItN2MyMDA4ZGRjY2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYs6bAzaDwSq8E5PVsP8Wvv88JdirnPML5teV/W+Eu7YACdnWtEXXvF+FqVtc\n5E7dQhit/g7+BfUeTYzE3ZA1IqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn36Yyr7SKMjf3DWrC168vAlkyewwHwYDVR0j\nBBgwFoAUGDSSPeTPxNNnFqoGWLLCw+KQFAAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC/yM2qElfCxk3lfEYc9dzFfgWr5DmK/0fuEelr\n/NcBEgIhAIRgwe3/h4SriTfQy12bN8zecDlAgZBlKR+RPpwwMrlw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9KmupsYLB1mMIJstgcENvuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWEwOTY3NC1jMzQwLTQ0ODItYjcyYi04NWE2NWVlNDkyYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJI3dMzo1fItdrx2lQuQnUApIDBvRNSITtlVktSZ7HY+HJ\neO39ZYnXyZLOD2vff1Byodn+4b1/9xEYUrfxC9NMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGDSSPeTPxNNnFqoGWLLCw+KQ\nFAAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPjqyEyLkBSZL2ia6/SUNsHII6cU+Lv18BUWHG+zrs48CIQCXVp0mJCAk\npihnomaUujeDGs6FDsykeSME+7DnBbWaYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAWCGLEMpJHTxh2wICPpjXNxoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUxMGE2ZmMtNGY1ZC00ODg0LWE3ZDItN2MyMDA4ZGRjY2YzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTRkNDBmN2EtNTkyMy00\nMDU3LTkwNTAtYmI4ZmMzMTM5NThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\neVp9sVOLvY40evXrfu8+WqQ/rUUxIwDGp6mtqe2gWX3dSCkGtmTO06S5tCSINXEX\nQUICmR/sz5TXlfSru/Hym6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUn36Yyr7SKMjf3DWr\nC168vAlkyewwCgYIKoZIzj0EAwIDSAAwRQIhAOfFKrCsyVpaZe8TCbUiwFbC0b+L\nYhCWd4JOTnVPQSZpAiAP1OzE5KBMaQzvXJzw8vvs00hs6/j0KsPIaPR+/yXSCA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3729", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3729` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAemS4M1zQOdFmCbhYv0gE2gMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhNTM0YTY0LTFjOTAtNDdmZC1hMDY1LTM5NDFjZGM0MWIxOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZiNWVjN2MtZmM5\nMS00ZDczLWE5NGQtODMxM2NiYjU0NWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjfQP+SqWkop4LFudNtFqQn6u4oh4KCbY/Q+EgLUjP22INHvWbLYJ6OC66+7G\n+oclzgDZpT4inXOeHh1pUYDgVqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrsDqud7e5UGoAgc0Xp1EoNQcGnowHwYDVR0j\nBBgwFoAUxHE+C2eEA7G/k0v8BxNO9g7Bsu8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFPLjqI6SeKeKDqavZ/MERTt2hjqnjYn7lxQTyeG\nXT4KAiBhlRszCm2HwnS8WolgER4WGi4GPExUaLPTcPrwnSxxpg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQT1X6Femiq3ZC/5/qsTzrAUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTUzNGE2NC0xYzkwLTQ3ZmQtYTA2NS0zOTQxY2RjNDFiMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9iKx4GsspzHQ0iKvdAl3FYXJlDsrOdxa3bv/7ZlYhjmVa\nRY1mGg3rpezUGtjeVDTXEfzK3ZKFt9/kATMqZiQNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxHE+C2eEA7G/k0v8BxNO9g7B\nsu8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJeouBzu2e+x1UTcayT7pdacEHRy43oGITklTneKnHhuAiEA4VBdLsBU\nO+nVekLdWzPba++VCXsdza7h2eyiMNO/IQ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAcBG0QMlWXcQr1Ud19hIvGLmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZiNWVjN2MtZmM5MS00ZDczLWE5NGQtODMxM2NiYjU0NWE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTI4OTU2ZmQtNzgzZS00\nYjQ4LThhNzgtMDZjZjQ0Y2ViNWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+s08OPuXde2H4zvgeiwYAD7P1aVb81lRoqaY/P2ULT6VdavAzEaVfvOjlmZntJ5T\nXyfxph24NbWncsCIu//2paNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrsDqud7e5UGoAgc0\nXp1EoNQcGnowCgYIKoZIzj0EAwIDRwAwRAIgBfQkQCXtsXZgFDorY36crkTK8gKt\neybeuLiwjbmqkU0CIFzW2PIEHiQ98eFN5YTZIcUTX7zLRgYFM1EQ4IBmtO32\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3730", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3730` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISATG2HEynEQkfLNoKpTBDwGQkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlOTM0NmIyLThkNGQtNDYyZi04NTUxLTU1ZGU0OGQyN2EyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYyOGZjNDEtOTA2\nNi00YzEyLTkxMGUtODViZjM2YzhjNDZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEkEiedZheILrDe0TsacIHApVB7jQOWeo8xWKG7jSn76SDfhBnx80Om04O+GD\nMy/X+dmxpaDSonmMvJfn/qoWrKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4WkAPcA1NfGnORaYemK33ROsPpUwHwYDVR0j\nBBgwFoAU2phR6QDBIr0XbleQePaHfNle5GQwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDQ/CMX8UkHy7NmtrX0f0So/GsFURlNQkXKqnK5UvoArgIh\nANNzpppK4Qjn+dsR8VycH0cpVK3QXBeIWXq/bSbyxBpx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARVuhYxCXBuay8iA9DjhAWXGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTkzNDZiMi04ZDRkLTQ2MmYtODU1MS01NWRlNDhkMjdhMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWa3Wlj1f24goj+9uy3coR6fHyfzp89BUanTj2cS/4inL/\nnThWSscIqH13WY6vjMEyWPljFJtTpnNT0p0sI8+ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2phR6QDBIr0XbleQePaHfNle\n5GQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANzIIp0zc453DMqDyhuCAuoW6gxYzuJO0SEePkgD2HVsAiEA4BCqf73D\nb7WTPLWniYgSbE1qcFaLFdERTkeI3jiwajk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAR+btQy9xejFOGHyDc9xsD7/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYyOGZjNDEtOTA2Ni00YzEyLTkxMGUtODViZjM2YzhjNDZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTE5MTNkMzEtZDJhMy00\nM2IwLThlYjUtMDZjNTUyYTg3YjEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nloNp0ON0X1iUtdw/U4vGw7Pc3QPo6SXYRFosmk6psg34NIW/VkliCEJNNJ4u0THb\nF9J8L5q0c/KhAao1WfhVmKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4WkAPcA1NfGnORaY\nemK33ROsPpUwCgYIKoZIzj0EAwIDSAAwRQIhAISh5JyJz35ILSAdRQxtTWYQWurx\nZSFSZHaFXN0ClMWcAiBZ8l9LjbIQ1R7b58FNCSEG3pROTfwYQq9jjI6IsSPzEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3731", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3731` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZtXzxPAM0xMeFfRzDsVPS0dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkZDIwMmNjLTI2NmEtNDYyNy04NzNiLWU5YzY2NDA4MGVjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY4ODJjZWMtODJj\nNy00YTg5LTlhYWQtMmIxOTY0NmI5ZjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETr0n71I9VF3+2i6lHksiMeXscQUmsdztXU5aBEaG4yBOtsrwMxp7SwJzRuNS\ne/yzeBm4HYzE9nc6O0W408aYZaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULFWdfqxGe+XGul3tvn7Hdr1OEMswHwYDVR0j\nBBgwFoAUvXXOwjDIMaJ52Tiry2mZEb8znSowSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCICBGk9LqAwbI4ieRSP/SvO+biydaRPXa\nIsVxSM2T99LAAiEAg0lAYdU6Hj/WmCQECddhajAlBjFe0/bXYmmDWo0s2yA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASTUFC9XMjLK8QGjLXe0IMiNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZGQyMDJjYy0yNjZhLTQ2MjctODczYi1lOWM2NjQwODBlYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVzeo6ToRukxXWtsLSQFLZJupUmuoO3NSu9N7eWgnxgxWr\n3u3fPYCnZVEYRnNdR0mXkUowCQ65jcqFzD2s6uz3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvXXOwjDIMaJ52Tiry2mZEb8z\nnSowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPU0Q7wnSFcbR+ozqeTXT8bZS7MdYqeREeS/IQmRGM/4CIQCqr+NKpjyx\nVX83ZHQ88x1OtCwVAmu+1uWQUyiWQqF42Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAb5Wr4ru8r4oo79OtkrgMoVoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY4ODJjZWMtODJjNy00YTg5LTlhYWQtMmIxOTY0NmI5ZjA2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTkxZDYyY2MtYWJmOC00\nYmQ0LTg5YzAtMmI5M2MyODU0ZDIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+F4V2GZpL5qgilFnrNhKQeDoha8uZgnF/bHxMCw/t+AvobksCicPY1l697zR70nU\nBseubaSKS7V1UOGs9YJmFqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULFWdfqxGe+XGul3t\nvn7Hdr1OEMswCgYIKoZIzj0EAwIDSAAwRQIgOO99aGyETmx/lhEDmDNSzQimv7cF\nKJ8GVCF8kR5AE48CIQDDVONKIwYwKVvwDVvEpYPFkgRHjQTmFVMg5fXXEMoS/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3732", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3732` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAWMr9kG5aSEBwAt1QsoIAMLwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlZmNhZDI3LWU1N2YtNGY1YS1iY2EyLTFlZTA5M2Q3YzAzOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI4YmY5ZDMtYjA4\nMi00ZWJlLThkMjYtNDFhMWVjZmQwMjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEve5pgQ91g3B7p2q2CUQToQNlewQD8uxHtBWg8Hyo15gXPth5TrTHeTfRlyVO\no7l5gZfxjdw+P32dx3OAIjb6dKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm5IbswrgQrrfYy7q9lt/UfOF3UIwHwYDVR0j\nBBgwFoAUXd510riqroc9TG9+1o35k3zfeDUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIEtUnBStuKL/UEBi53wlHpFaKwuFb4ix\nZqlXXsOuK6P3AiBKkroC3vM0a4Z6LQVdNQM+gREc5rKGstDsRL1o4ab1QQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVUjv/VK2YpJRkwolS+Q3zSGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWZjYWQyNy1lNTdmLTRmNWEtYmNhMi0xZWUwOTNkN2MwMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARo6Bt2i8U//mebOJEsI0mFcg597PLE2y8ezg6cYbBpSgXM\np3RjyZbds5RPNycpLBl+S0FhlMMQ1tRoHZilPxrWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXd510riqroc9TG9+1o35k3zf\neDUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMDuBYnv34clyxdGDQ8+2AD69wyw3j2LmmxCXUeOODhEAiA5cbcP9DeR\naIRxJr0TJB23Gp1S6Rh468UgELq5apCy2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAViw+Lj5ds0DnOkUwPDj8oDyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI4YmY5ZDMtYjA4Mi00ZWJlLThkMjYtNDFhMWVjZmQwMjgzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzRjNmRhMmEtZTdjNy00\nMzE1LWIwNmMtZTQ4MDBlZmVkMDRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6l3xrYQPMCLsKyfYcJTvqFu0zyQgjov/+KPwR9v0HX9vyHiyU24Y/ytCdsGvkTuY\nFCYGfvO0LlzEqnprVppQvaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUm5IbswrgQrrfYy7q\n9lt/UfOF3UIwCgYIKoZIzj0EAwIDSQAwRgIhANwgFe0ptKthAFvuKnqfpJNzcQhg\nK7IaHB8DZhxrJNA1AiEA49+muk46r7boxOadtFDkFV3sbgRMHjkKUu0yCfAiMBA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3733", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3733` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAdAlMxMbNahZkPu7TmLFi7/VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2YWJlZGY1LTFiZDktNGJhNi1hODg3LTRmYmE4NzUyNWVhMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzlmYWM3MTQtZmE1\nMi00YTQ5LWEwNGUtODRkYTViMzRlMTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE44NaV+CJiUKf9uIvC9a8HH2T6xU1UH+9h52m661yvQXtCKbbYYIbo9HJa0OH\nAgOzg8tdC2s38rw0ZbI4zEO/QqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMyZXljsGjSV3I55bq5n8WadEIWiMB8GA1UdIwQY\nMBaAFMpxtS+xH89SjQzXu/SuEPyD7woJMAoGCCqGSM49BAMCA0kAMEYCIQDj3l8n\nhbl+cGnRrXWoQfIa1aLg3GUDVi8syiySGdudkgIhAJTNsK/JImkX1vHjM2JTLs62\nSctbxY90lHUp2FfxI3dY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb0AjpoZTyelKZYl3hCqXF4YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmFiZWRmNS0xYmQ5LTRiYTYtYTg4Ny00ZmJhODc1MjVlYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQK01/lqoUWOo4dPmi7t2W4Z+Iv2S9IKRbqSiuOUxVBovVu\nU/sPaGtbhLJIusF5fi54X/HZPLG0hIinGD9wnSpIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUynG1L7Efz1KNDNe79K4Q/IPv\nCgkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKlLAfs3cVQgnrFCCtWk/SXhBz93dqD3K+aHhsqYaEHEAiAYYBENoBab\n4iS2XDqliwhJWs34tfe3l3G/qNeglj0iAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISATarknNd2/cdZAi2APRdaldOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzlmYWM3MTQtZmE1Mi00YTQ5LWEwNGUtODRkYTViMzRlMTBiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTcwMzdmMjUtZTQ2NS00\nNjdmLTljMTctZmE3ODQ2YmI1ODZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOj8+UWyVcH7GhsvQYYaG+IhPlCnVKtKW9weS5hjdvHzFr9epP4UhCL1IVHVcO2SG\nudh4uIjnTTX0US0fSM5sK6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzJleWOwaNJXcjnlu\nrmfxZp0QhaIwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAB9HMy\n9nhgdE3aFee7zAuAzwRXLSxh8+TJPtBdgAzuTwIgAxIw0axHHDnSjU6pmwEBu72L\n3RZbN+AtaXY7xk149mE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3734", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3734` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAW/X3Dyay0emv5vBnEwNu8B6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlMTA4N2I2LTRlMjYtNGQ0Yi1hMjZjLWNjYjE2NjM3ODNiZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDcwMmNhYTMtZTBl\nNS00NWIwLTlhZTgtNjE1NzYzZDFmYmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErHA2Z/DPBUUa3jw2Ddzd94yl0mzEJSCIVqFm9NFUPrU4fSIaHe7YyUl156UX\neWpSp/WvllOn6qIRyIMP2imObqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFO/hRBqYme3dH9H+U1sqR9LG9ASjMB8GA1UdIwQY\nMBaAFO4s3ROvoGL43rX6lGHRriU1WLN1MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAwux9a4WMuCJ84Za+UOGhff/nvbC0LIxBT\nDvaa1ELNuAIgMbpmY8PatrE+J6CypO6qTIZ7dNie/RPEZjsr07lPZNs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9MA27mRB6A5WMUqkHD8C1OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTEwODdiNi00ZTI2LTRkNGItYTI2Yy1jY2IxNjYzNzgzYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASL28iyS9MB9BOulv12Pr+xVkqVt7AdAD1o992j7qHR83y3\npYcwMtx3IJPhziQpiotxf5KOZxoaJWNYd/kV68keo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7izdE6+gYvjetfqUYdGuJTVY\ns3UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOL+3spad3NuBcnP2ZEeEHh9BUfSNPq16+9X3Xm7H7z7AiBEIpD/lIq4\nRbS7Ase3RTbL+MZQbLnQ8v57ObyKC2J1iA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXsWrlEKm1QV7YJnmY6dOHSKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDcwMmNhYTMtZTBlNS00NWIwLTlhZTgtNjE1NzYzZDFmYmE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDQ3NzRhMjMtZTM5My00\nNjgzLTkwMzctZmJiYTE1ZTA4ZmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBjh52tYcMP7a8Lmly5d7fbY6DP8bS9tHX05hz+Ip3NHAS1PeuRQMAd6XiGvFqTYt\n9n6zoVbtJgNoFCAzlFQF26NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7+FEGpiZ7d0f0f5T\nWypH0sb0BKMwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA97cY\nHlBZUrSQlfSwvdHgeAIJkFbKmj7ewvYQLWR6JvICIE06CaRBfzjXD1JjptFFo9a+\nQQnpBE6iQPxm2L4oeM5/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3735", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3735` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWewBb/Tix9OCVnJmfoOtFqbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MTBmZTI0LTJiZjgtNGQ2My04MGQ4LTFiNzk2M2Q2OTk4ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDAwYzM5ZDEtMGQx\nMS00OTg0LWI1OGYtY2Q5MGM0MzVmMTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwsdWJmOvJ4SCImcb/2mEhb+MEogbXPpbkgwyinXiDgJLlJWKc7Tf8BV32uDr\n90wCBVNcfX2Rf/MKy8ByCPVWDKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEKg4GF8C4qjDhQnMS054GY3TnHdMB8GA1UdIwQY\nMBaAFO2qU3xTMlTJcsc4JfNmoC+VqENzMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAi7UDFErVi4oJKyAzF798cj/Ft8zjP6Gk\nDV8nz/9DcwICIBFDEIHkHCDJdtmRXu508H9in9kXLra8zF2UV0VPYhlB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATLQ4nH8ulglC6U94v26yzMQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzEwZmUyNC0yYmY4LTRkNjMtODBkOC0xYjc5NjNkNjk5ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNOpD3OpF3PylC6XfgNDbiUdvwFRYWXg7c8LBpU5mbobNO\nzRXqBer22qSBWLvnI0/KRQYNqy2+NGZ9I5ATPSn8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7apTfFMyVMlyxzgl82agL5Wo\nQ3MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSypK/R19AMkEcBsEOgjq1unlRJwnb6cLi+JopMjI4PYCIQCLrJS3E+uN\nhdaaRHxGJuRaqwNR2j6ZU2+cLnyJ6ZwiQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAfKnCvnTA5MtH92EicldbqJJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDAwYzM5ZDEtMGQxMS00OTg0LWI1OGYtY2Q5MGM0MzVmMTVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDMxODMwNTAtMGRjNS00\nZGU2LTk3YWItNGQ0NmIwMGJhZWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFbJSeDWgqwbQ4aaEbMEfX1CNd2KXFV6OI+3evcywc9MLvUQQxO2VLX0BmAVs8pOq\njNxoV7kuG/vEy1eGGyV04KNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQqDgYXwLiqMOFCcx\nLTngZjdOcd0wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAeGKq6\niiFZ8lIypUBfrRsKpGrVDNt3e+9x/A2hqWuRHQIgMb7cBxVVjni2/yZM3z5Xllht\ne0aMebEc64VWpVsglqA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3736", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3736` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAdTmf0H5QEaMLik5OXRqtN1HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkOWNiOTA5LWNlNjEtNDUyYy04YTc1LTY0NGQzMjkyOTIxOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZjMGI2NmUtM2Jl\nNS00YTBhLWEyOWItNDk1ZTZiNzdkZDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu8n0WE1CzBpgY/Mr6WkYiU5Xgt1kti4sI14bWkK+PI3ZBWx0HTcOpngUh4ko\nC0/euqlPm294QRPEwyD9cykEGKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQgAza7/u2YRPucxOBJPLkgAVi6EzAfBgNVHSME\nGDAWgBRKCRm2T0ll0EqB5lUOzptnDMZoZzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBPdry/evhh3vRHJ3w27mA8dcudfpPjD\nXEte9S8zz1aYAiBs0cdWp3cRDkzWgNi7jB49S5LgaO79bR20M1CiG0aNaw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZDr/ffAMa4Tgie5E0etuoy1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDljYjkwOS1jZTYxLTQ1MmMtOGE3NS02NDRkMzI5MjkyMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfETChBbOtKn7aztSZENGdSGsZGIIX2zPOqjnjzLO6y+uH\nCYhdJ5HDQz4SSMi6Et4Q4jJS63SR5s3iYhU1iczYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSgkZtk9JZdBKgeZVDs6bZwzG\naGcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgchbAYCUILhkDEx4D75s76bLjifJLlFVHQVYO/1laWCcCIQD9itYp0/KV\n3xSyN2Dkh1tfn5mqpfUN7XMfzh5O+CTaTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAZo/pS+uCBB8HX7FDM/LWc+4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZjMGI2NmUtM2JlNS00YTBhLWEyOWItNDk1ZTZiNzdkZDdkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODk0ZTFlMDYtYjAxZi00\nYzhmLTk4YjctZmFjZTMxOTU5MmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nguZcR2h3PGP+bgxzjssVdffoVnc4RXwJ9jI0KfRLvS050CTW4hIK0qOeHvZO6BsY\nXkVFr0msTdsSafhtTk8s6aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIAM2u/7tmET7nMTg\nSTy5IAFYuhMwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBrAO0i\nlJ5HVmJSFzSOgmossab7p3LYimcZ1UgWVRi8PQIgKSrlYi8ZiShbUXOi5BWQpr7o\nztjfP4SPFgUEfa+i69w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3737", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3737` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAetI9c9570h0dW6M4CLeYtaNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5MTYzOTU5LTBlNDYtNDUyNy05MWYxLTM1NGZlMzYzMmNmMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhhZDBhZWQtNTcz\nYy00M2RlLTk4YTUtN2NhZGIxZDRjODQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEciPzrjXGUo/hADJz7a+z0hoG4KqO+FFoYHpRYHowWtAKbri06Rg+cxi7aOsp\nyAsx6pz6gs04LojKKR7ucOIk86OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+XTLpO2bcGeZk2M55L6aM9bjzaMwHwYDVR0j\nBBgwFoAUX0L2+DIgXbplysaFIXZ5EijBAYcwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA5FL9rWOk2aiL\naYWWPGrpp7ur9X31mdOy65+RWfwvXoICIQCOYqEGvXH9JuyYZJYECsLVjbqiM4Hz\ngNmbqO7VHNg3Qg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWfKUAWtbYBhgPYyoOFqfx+OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTE2Mzk1OS0wZTQ2LTQ1MjctOTFmMS0zNTRmZTM2MzJjZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjKS77fTXF/LBYEiQyeAXI82j9G0F7e3QNiiElDGJmbf+y\nYJwEbiSNCYX5r6E6D3cMdbb6aAj2t3kwn5szDoiko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX0L2+DIgXbplysaFIXZ5EijB\nAYcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFQ2rjcHkVdfW0ZTMoEJSS/ll8DALKpDZlBe3Vt+zYmoCIQCYc12ouVa1\nuC526ilLSsevUdW+IUMY1Vk7NeQSPVsNxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAQXdSRWsYlxVhunrTJzwqxyKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhhZDBhZWQtNTczYy00M2RlLTk4YTUtN2NhZGIxZDRjODQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2FhOThlOTctN2EyNy00\nZTU4LWE3ZTYtNzdkYjUxMWVkYmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nIkGvMRbf2reAxtkyoMw+gCSnambVrjN+qPAItTm0xJ4nxQnXWHVHclnGbv33pl3g\nf+tiosMfCdG4hEXey5Iy/qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+XTLpO2bcGeZk2M5\n5L6aM9bjzaMwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB63FX3\nBg+o4tw5lyMGkMH9lPolniv3JWruxFI8bgk06QIgCHFnSFwyHzSamRLvZ8WDEMKj\nXnETNzJeq9K3adNxas8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3738", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3738` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAVZTgIxOh9Ax40IAZKVt4P0rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3NmJhNjRkLTE1NjItNGFjZS04NmM1LWZlMTIwNjdlMDY2YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWI5MWEwMjQtYzBh\nZC00MDhiLWEzZjktNTM4MmI2Y2ZmNzllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+XJc1HBB+JzRiiyDaLSgmvgjnE/PQbWB2jyOZCsPlRI+1Gb8FGXfj1R6bliw\ncfnmPogCQtBeUoFDmKQhB+TmRaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHh5LGiJ8LE5eNgCAXkF+4f4rVAAwHwYDVR0j\nBBgwFoAUE7QdSxpqaSzvzzTzGGGh8kQ95ZAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAOnrBzJ+QDWPFC\nfE/OizKE1AB8vj2kLOztF9kGLZPCjgIgBU8l5l+qzIIt9hFkOGapC4iAiaB3ZOg3\nk3DBGo3YuT8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARZJho5qk+48FgO6omqQ5Jm6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzZiYTY0ZC0xNTYyLTRhY2UtODZjNS1mZTEyMDY3ZTA2NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGq9jECXlXrYugFJ23UkJ987LQqcN278RzcMQ1wJfUD1a5\noYT/+C/J7WI9qp2/YJKqpocpaMpkCKOwDjWnUm1zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE7QdSxpqaSzvzzTzGGGh8kQ9\n5ZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDC89CLC7TQQ+F9DMleAylmPsX/07Yov1u+xE7yGBvKYCIQCTXFshjFFP\n1WWvU6xhJ1W3kRiwz86C8s6jtwMujJIRhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASHDuK7XlPCsdlBeSdpNGGZXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWI5MWEwMjQtYzBhZC00MDhiLWEzZjktNTM4MmI2Y2ZmNzllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWQ2YTg4ZTMtZjczNS00\nNDRjLTkyOTUtMDJlNzJkNjA5ZDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nG8MALwF+CQB0/Ektb6GUxy5hb9ngnP4Qm3vlelFaRetAqb9YyRKHmteCk/cSx0PK\n45L9v4cqcsNTPZPVC6CZZqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHh5LGiJ8LE5eNgCA\nXkF+4f4rVAAwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAmOAt\nXCvWYActGJQlT/y8y4+/Mtau9/id4DU8PkneslACIA6Ow7dAGETTOApBlpM3bZDr\n4hyxC3iW5XllIBSPEdZZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3739", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3739` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISARtVKc3RdzVIi8p/UF1vBmdxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ZDU5ZTRiLWRmZmUtNGFjMy05NjFjLWY1YzE2ZDk3MzU5YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM2YmRhMjctNzlh\nZS00YmNjLTgyZmYtYThjNDM0M2VlZjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHh5nCu14nHWkzqNkvqD5bCtr3ivflwEqDivXI6m4v+52vuOxeJKqj1FW/BMR\nlEZ84bXQEKZoIyFwisrfcMcbxqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/PapIf0qqOyAjo8SVlxpniop79owHwYDVR0j\nBBgwFoAU9iAGS4xd/znT+FB6C8ve8bL2VVwwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAV/O/2JXPbIlMp66PZi+k4\nzSc1t/Li77jOOCwLiLIBOQIgP5uNweJhiQFS60hB94DJTvVUdSlkdix6qzxmgpNw\n0yo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVSLsZgkEUg1VXQfe0wjN/jwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWQ1OWU0Yi1kZmZlLTRhYzMtOTYxYy1mNWMxNmQ5NzM1OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQU34SyDGIOOvzywtsNvDE9CSz8CEZIsH6vMRlvTqVTIe64\n/9KB2MtgyVleMZlE4hPXu2HwOk14/pfDNjdOAdGao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9iAGS4xd/znT+FB6C8ve8bL2\nVVwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYIq1F1YGdxEuatrWfh1kBkCKyKjzfPD9eN5ZkBWXT+cCIQDn+Rqi0+6C\neQ4N7bz/cahyQH6LkWKSgmiKfB8dHWW3lA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAbaXDXT7z/0OSL5jW6nwGaJgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM2YmRhMjctNzlhZS00YmNjLTgyZmYtYThjNDM0M2VlZjlmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjZjMDA5ODAtMGE0ZS00\nOWU3LThmMzktYjkwN2I2MjYxMDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nm6AY+oADm8upyWpxAqb2KVVLEVorq+N1AtOZuOo6at2uX3U33PJGd2wK1fxg9D1z\ndhTMwNcvXv5hkBecwDX8F6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/PapIf0qqOyAjo8S\nVlxpniop79owDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBjS5s7\ndY3XzqSZ4ag6SZK1eRlqhqJTl/8R4A2ovnSbkwIhAM9plOkKzXlwRpVaaa2+NdIi\nPKwARtQmpLGxKZvIEDXW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3740", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3740` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAS2pA9cqwLXmcIn0JS6G4WYzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhYWUxZThiLTllZjYtNGM4OS04YWRjLTNjZTRhNmZhMjc3YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE0MWE3YWQtZTEz\nYS00ZWQwLWJkMjktOWEyNTY3MTljZWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI4NwfnyYVfF6yRDxZod0Qp5TQKQ6+AnJ0eYY74GaugNzMLyd9gDdyBObeXAV\n7S9NVOq+aiwbgBncCTlG13wvzaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ4jqDuFFxqweG0xWtFkPyAhzYhswHwYDVR0j\nBBgwFoAUou0qXe3MrfbqN5KzTCVjv70SGuYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBBqikn\nu2WFA18mlWg39hr+9TiTUZjJsEbvDJjl8WpMVgIhANoRKeAM5qNvq+QH5IF3N2Z/\n2DrHR7aIHuj94b+lNSB8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQR+nrMwzGrv+HZ6ak2/sejBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWFlMWU4Yi05ZWY2LTRjODktOGFkYy0zY2U0YTZmYTI3N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4XvQRGF/u0kE0Yhh8sE3yzO8LxsdSnoyo+dviJYwKCu0I\n1/IOPGaCKJkatTvZ2rFXPeBljOPxRAaxS5h0Ng5/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUou0qXe3MrfbqN5KzTCVjv70S\nGuYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHFynq5XzoC/cBxFFit6HKYf2NOEHemvejaj3YzX5m1ICIQDc/u4uZ9rI\nV/3GWLNBi9rAW1ty9MKm2FFaGk53n4uRTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYQ7d8HsoKchi+dJNMWT6NoYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE0MWE3YWQtZTEzYS00ZWQwLWJkMjktOWEyNTY3MTljZWFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmJlNWFhNDItOTBlYi00\nYzEwLTkxOWMtZjEyMTBlZThjMGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTkIgsS93pH/xkqbWJD6eOsd+demlCUk6ati9b2rRwEALnkbcILSm8uLEVUVYIBat\nhhSpkBcL13PzecDI8241XKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQ4jqDuFFxqweG0xW\ntFkPyAhzYhswDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAShPKG\naa/IUomh+RMT8fDSvzDZlATDmFq0ELh1J0CEEwIhAJaVKsXaNHt6dhAIIIHRQxck\nocTJTyJHaDCFB5MGMoVP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3741", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3741` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISASmdPolh1cM9hIOvWDzx+mLSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NWE0MzQwLTg5OTAtNDZmNi04MjRhLThhYmUxNGMxNjdhYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FmMTUxM2QtNzI5\nMy00MzExLWJhMzktYzU0OTVjZDFmYzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGpCnimN5tQFNJGTFKb5zd41U7D1cU423uQ5WrDldhaUNEJCmINco/+FwwDRK\nSXw+mf7uJd4OoqcSc3tx036KIqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeK9YC508HwjH4bFchG9ztj5jeCMwHwYDVR0j\nBBgwFoAUQC0v1dscBpsePDM0VPQUOPgYGu4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAHnxvd\ni6vKeYwAIFnVvpS/YU0oFs7hf7c2ZaK32VJwNwIhAJ8UtQs9Bk3AOJixsJulWdl4\nHENr5ZU3GPuhtkdoPTtm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX+Kr0+sguZ80ouQcSG6V8M7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjVhNDM0MC04OTkwLTQ2ZjYtODI0YS04YWJlMTRjMTY3YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwwaCJwTZ5V/j2HNjZRvdiw9pGH19LjgY0X+QfygPSIHed\nFTK+BpNlmVw7ijpPj8xQ4AYD60Q4HyVF5Cy1fai1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQC0v1dscBpsePDM0VPQUOPgY\nGu4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFBo1wLQeef0/UodK9ONvtaIEUhARY33UMpAS49wXtvcCIQDANGxeSeqI\nTvCV1aUvPxUO8HYX/rUE9jIBDzZISS47Nw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAcOUNk64IcCLFe5tFgcOqw3nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FmMTUxM2QtNzI5My00MzExLWJhMzktYzU0OTVjZDFmYzM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2U1ZTJmNjMtZDEzYy00\nODEzLTk1ZTAtZjQ3ZTQ4MmI4OTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMPtzIyKkyrZT31A8fclbQYoaXjAzkAUPXr9lBpOn3enLfnWmQBASb2zsTINef3NO\nMmvEkYAarGvGLux3/6yMNKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUeK9YC508HwjH4bFc\nhG9ztj5jeCMwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAigLG\n64GBgFm/BMt0DBO07Hlu+Wc4DsttG7UCFTEuTBACICQwDY2r3S5TZKLIWAcSzAFI\nX73/nOa0vx+qSPVpwOn3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3742", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3742` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISActFGScdE8Efg9k3oIytuca2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyOTkyNTlmLWFjYjAtNGY2Ni04OGMyLTBjYmM0ZWY4OGIxZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I2NzE4NjctZmYx\nOC00NjcyLWIzOGEtMjM4NDE4MGJlNzBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYN5y6nPTmLkg/9eeFzUHbWeJUYGo1mLgd/xb105y5qe71LR8nBfERP5AGaYj\ntEc5oOu//bUxOopLxIQtvyssd6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDXzWw3901bBrOapIGvZj6zvdXr8MB8GA1UdIwQY\nMBaAFKpNunJoXI2OfDGFHEA85BLEqtfyMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiA2/GJSftbRlhhp1cUE7N/c1t4ZpiwomkRd\n1f9GiAKSewIgMCkwmNKmyBSJ3Yr8aODEJ5/BFzYCqpeyLyjfAMzD3gw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWctrVSszedpTsR+htl6vsktMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjk5MjU5Zi1hY2IwLTRmNjYtODhjMi0wY2JjNGVmODhiMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATn7VpCrpkC1m3A4DUp5eJh2v8Vgr6BmwoBZ91053LvI06s\nCfgBvGVhlHBM6wSGZaQehqBq/qpq0qtkHFTJw0uDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqk26cmhcjY58MYUcQDzkEsSq\n1/IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAImnNAmEH1y+Pt0hgh9P6jFnvjcky/ebpx6AKmF+5D0hAiA8S8Ty8Q/o\n/Py7pRH1Taqy8wOaJZgbb+6Stmvk87NYww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAUmmWxLHokq2IHUgkixNnhEgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I2NzE4NjctZmYxOC00NjcyLWIzOGEtMjM4NDE4MGJlNzBhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTNkZmY5ODItNGI5Yy00\nMjlkLWIwMTktNzhlMzg2NDg5Yzg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/2EvbRLgtZTbcu9lWeZdALp5Q5iAnai8XsOZmdTCPsRXpOny4YCIYe+jWAS0bo/2\npqKxCv5SRXKrZQDEhmEEMqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNfNbDf3TVsGs5qkg\na9mPrO91evwwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiByD7u3\ng9YqGyVjzKR3Wjbsl67B289PUHFlY+Ig08uIdwIgE3nzoPXX8v9eFL8uYaE9Z22q\nOkziQ9hLOiyOdKDPRCA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3743", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3743` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAc6+yckEJ6K/9r9VT+LOmzMSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjYzc0ZTZlLTE5OTYtNGI1Yi1iNjY2LWY5NmJjNmQ4YjBhNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTRjNmZmYjgtYmIz\nZS00MjVjLWE3YjMtZmZhYTQ3ZDU1N2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwtuptH7/BLW1taDKVR+0meqeq5DmUcmb5X/KWwXrq+1fNZptjO5P8Bat0Qs0\nA8OB68krqdeVUl11oS0TxQjoe6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGgPnWJEH97TzXBzQg3FBfPofSwAwHwYDVR0j\nBBgwFoAUhC2pFS+Nf35/o5nn85Z8JVesPvAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhALOSRQngK5R/\nUy9VFIICIjMc9xLdKmofKaurqUWmvdmwAiEA+79C2a98UwtWLew4nxqgIceEJJC/\nWndaKqb8vGpXqEw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQn1Y729nF7xS3+CCKtUYxSXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2M3NGU2ZS0xOTk2LTRiNWItYjY2Ni1mOTZiYzZkOGIwYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThnUApmy7KBsObTWeqp8zBIYN4+jKBHWR0iIDnDPX4DI76\nI7mxrrklVYglqtSS65ZkGYpPN0aDQDCAj3K+uP0Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhC2pFS+Nf35/o5nn85Z8JVes\nPvAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPk9LCT3P7rztth3CP+sgwbO88G8OdR50dghhbXtvH9JAiBw6tpjZ72C\n01wRzKnxe+yo708WsUHXHol1S1vcDqGjnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAZpeUrEcOceW+tAk+L4ylbAjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTRjNmZmYjgtYmIzZS00MjVjLWE3YjMtZmZhYTQ3ZDU1N2YyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzRiZTE3ODctNzY3Ni00\nZTgxLWIzZTktZTc2ZDMxZTI5MzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1aMFl5/3Vb7dk6bVmMcNWXfFWhfOV/7pgcOC2fonkdl54y8b7NMSHl052TvmY0d5\nEPv/wCaOPWitSB8KdylDhqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGgPnWJEH97TzXBzQ\ng3FBfPofSwAwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAnpao\nxoRXy8G0eNHDV9GWVf2sBNmVIIGevv57m9FLsgACIQCjbDynHL3n56GiXRXEK8ym\nowVo1cx1cvlMPwz4l76wFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3744", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3744` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAUptBw6OfKyyAdLoEdboV4PWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkNGQyZDk0LTViMDUtNDI4NS05OWZiLTNmZjZmNjdjODRmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDkwMDM0NmYtNzg1\nZS00NmJlLTk1ZjAtOTFhNTEwZmNlZjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHO4wd4GT/GS8WR20bVQOYFrJx+YJ0FLOeQKg+HRAI8deNAVvr+t4MogwHBqt\nEcoMa40FD2HcaMEDWg9Kxs2jRaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyElPQBT3bNnIi8+Xpa/zd1vGItgwHwYDVR0j\nBBgwFoAUhmCpOyfOdbO0nuWxIwhZu51LByAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAI2+fRAme6wJ\nAwKzaMD2DbtQHHfI5ugkf0kFgIaXaOZBAiAc71M6Uk1m9WNUBoNM0KCWxn7hPNYX\nuvU9GMvgABjpOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYiGjh7dNi/3bQTA7CJiFhNSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDRkMmQ5NC01YjA1LTQyODUtOTlmYi0zZmY2ZjY3Yzg0ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXJUh8SP6H6SpBddfffdpWC4vbBxYPBwIYztHOHxE7hDP6\nP62GjzxdFj2qnnghqy0nW6jSkNhwp5VfbDpCaXNjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmCpOyfOdbO0nuWxIwhZu51L\nByAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVao/LiYJsaqKVKZQECUvdHPJd3w9PsTwlDf8LjqPracCIQDtaU+VABeE\n/DM87B8rGSCyq9yqg+VN6cgbPfkOyX0LQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAeFjFkcQu5q7Qj+/89lgxTHhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDkwMDM0NmYtNzg1ZS00NmJlLTk1ZjAtOTFhNTEwZmNlZjE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTgxYjMxMTItOWYwZS00\nNWQxLThiNGEtOTllZGI0N2JiODhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4Y1qmKJ9C2c7xZrZhsaK1NqrJTFXe3Rm985AMvDMmteqXeYY6g/YY03WSl0cHSKK\noQS1rF3gIstM8fGIm9XEFaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyElPQBT3bNnIi8+X\npa/zd1vGItgwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA2rip\nH/W3AYpPSdxMpya3/sswQLAL+k18Rpq7hmKrcgMCIQC0hCoUiTc6lICsdX2ww66P\nt2TihUCzasS0Ot/pDfAE3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3745", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3745` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdZWmFHbKefVsS6Z5XEcBPj5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwY2NlMDgzLTA5NTItNGEyZS1iMWMzLTUwODlhZjc4ZjBhNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI0Mjk3YTEtMWU3\nNS00MDExLWE3MTUtMTMzZThkYTgxNGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0HKpsHdOgsfkrIH62gtvjo+kTdHLAPsbDz/apwN2hDqfWeCw3nkePvicdzML\nFHMYY2hxccyNXAdxJ1R6WsA7VaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWBEkLaDxSzWxi4KzfRnuA42C/jgwHwYDVR0j\nBBgwFoAULQxdkKl53Zq7qoOPU7yW3Sb/KAowKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICtwh6j50uEU\no+LPNozsbVCjamXvDL2PaFA94Ek5mCPbAiEA5fZJNXkJZbmupiOiZeTUXm68nCDQ\nMnFHz/fmFklAt3Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUPraaHnJwXiBJ/jR6/wNbB9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGNjZTA4My0wOTUyLTRhMmUtYjFjMy01MDg5YWY3OGYwYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwRiI8KyUubsoVMBSdYg4tUzSCpvZVw5LZKqThOWZw+4mC\n4oNGnLwL+JFK2/qnguViIr6GixvSWZR7bZtThAMeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULQxdkKl53Zq7qoOPU7yW3Sb/\nKAowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMSFrjR++HF0ft/jBQjx0vrn9BdjDEr7qK+hS6MHL4DcAiEA/Z1xurHS\ndEPpBnfUe4TwhiYFLJw+alYJWdgmruX84nc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAbUCmfrFAWSaHMIqX1A9dRMRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI0Mjk3YTEtMWU3NS00MDExLWE3MTUtMTMzZThkYTgxNGQ4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjdkZTNhMzYtNzJhYy00\nODk3LTg4ZDYtMWFhZDUzY2RlMjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ne+Avj1MW92ZDWl54oC3FwpgWkDXnwFo/97cAOQzdQYwJoSRtKXk2VLWjE6FAETEp\nxZv2U0pvmotjypfp5QsJ0qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWBEkLaDxSzWxi4Kz\nfRnuA42C/jgwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiApjBTT\nfpzroe7xKEyx6rLzBoGXHTZb5XOcna7xjlVn9gIhAOHfR8Sv+X3PLXV8MRPSbf5U\n/AkGZE/V63W7zHRbWiwU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3746", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3746` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASdySqRmKuo51asAt8sIgwTwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxYjIxYzNmLWM3NGYtNDc3YS05YzVjLWVlNjY5NTE2Zjc1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmI4YjI2YjgtZjA2\nZC00N2Q4LWJlMDUtOTlmMTRmYmJlMDhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1+iPrBaAAKmnvMPke0cv5V6g3BimOvSwwstQ26lyvLXm4x9/wph8F7xcLZyC\nnGuGWm7mII7A9HEcnMZ7r/KKzKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUadDZ2dQM0I35emi5BAhkcAeyf54wHwYDVR0j\nBBgwFoAUgv/3RKTicgxk0sbLlrU/7O6OYUowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCfms0gNowNDnD/e+ji70kRLmlMOAENEYjMG3akGF9vHQIhAPZgdhizif9k\nix4Sao8Y2od//x2rImVJDOao/BR8JwWC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYjyopBneOKrnYZmCGcz30cwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWIyMWMzZi1jNzRmLTQ3N2EtOWM1Yy1lZTY2OTUxNmY3NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlS7YCKsCm/aT2r4FGYuKVCmej2OqbYCUm9t4oURhn7vH2\nkEOGD4sZdOCig7zaj+ovmSYSwOsbMDIVHfVp8+G3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgv/3RKTicgxk0sbLlrU/7O6O\nYUowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIIc73OwNqoFRZDe5P3miP0GnzRtsdVGOw8gFtbej5mqAiAh/iZlWc0Z\n6vrHucM9IWnMVVSHx5mz9fus8r2iepWGcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISATy79vkXMXLPGu4egedDm9HYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmI4YjI2YjgtZjA2ZC00N2Q4LWJlMDUtOTlmMTRmYmJlMDhmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGFhMWFmMTctNGI4OC00\nZDUwLThkYmUtOWYzNDE0YmQ5Zjg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZKSkccjFHbRaNWalgfTDHrR5wQhsZVhHw90Gmt6Jv3e2r1lHpwe9o6wac2Kok8i5\nOmA5+N84gaoKRIixRpRnnqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUadDZ2dQM0I35emi5\nBAhkcAeyf54wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA21/Ir\n7he6Vhpvl4w1+IU3D10wI7TjkZXNnyVfKrc+SgIgew4DAy6+w0YkSAzVIg7Sl17h\ngxZOyqyPHnqZxGSGoPU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3747", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3747` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATwQlee3j8If+XSraj6ywO46MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3YjlmM2UyLTBmZTAtNGU3Ny05Njg1LTMxOTQ2N2NkYWViNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc1NDk1NjItMDQ4\nOC00YTM0LWFlYTktZGY2N2YxYTE4OWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEru1iuPK/fIpaQ2S7oUAOtIZrinddG90RbS94eWNU0uFauqv/4ZoG4fJBJv+Q\np3l5KCI++Y+v2/MCN25zS0Fbs6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUihXnZwyRnF5Y71AtwQ4nGmQg74wwHwYDVR0j\nBBgwFoAUZLohB71tWDbSzL2WFPCixlzIuIwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD7kRYtVdkiFjOoL2KNVJlsdkH3SwFSNifqNCF3zw3H8wIgVJD/tbWxzAJc\n9kMbHAf/0tS9uwy5s19bnuluijt8d9o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeHsl+1diCgi4d3nb2OaSdZmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2I5ZjNlMi0wZmUwLTRlNzctOTY4NS0zMTk0NjdjZGFlYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4+wMfTcWFw1q7ZfhxK5NbHCA/rs90nmDEuwRigsHla+UC\n4MJP9k/3o/8dNmvn0AAvkMSYegGSqcMR6m9cKBljo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZLohB71tWDbSzL2WFPCixlzI\nuIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRbVHRkreFPSPd0iSM95diwTgc00dwcqfk16sXeTU68cCIEXZgsxF8OYU\nVFWTIfFxrlY3d3S+8vLk6/cJ9WCrJB68\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAcv1m3QjfpT23B4yOj2NiWNAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc1NDk1NjItMDQ4OC00YTM0LWFlYTktZGY2N2YxYTE4OWMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjc5NzYzM2UtNTA0ZC00\nODQ0LWE3MDQtMzEwZGYxN2EwNmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nk1dJL1n9w0cbOgyQ5ynIVwiU5nyk2SYM+VdgM9t1Y3urhHzlTxCGDB7gm1y8a0ny\nRHSrNBEPUt4JUj+fsI2FWKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUihXnZwyRnF5Y71At\nwQ4nGmQg74wwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAzTy7\n3kkFZJaYu7xsQYD5uW/U2SrmJpkeG7MCrFD1pZECIF0tnz/VXs5eM7RROJ1MXuw4\nCeEDItHvHu/KOZgsBw4w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3748", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3748` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAW4OQe7wHkf14vrgs+igwUKNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZmQwM2MxLTQ3ZDEtNGI0NC05YzBlLTE4YTNhMTM1MjBkYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA1ODlmOTAtMTQz\nZS00MDY2LWJlOWItODU4OTYzZWE3ZWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWhbMDPHIJS0AYgF84dMzmfREbDCw9prwxQr0L9Tr1v4PEH2GZ8g20/kI/dkX\nZQE2HaJSfh9jqKFdSJBwuD74XKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeiibVylzScw5LEHioYoBm74Wi8kwHwYDVR0j\nBBgwFoAU39xpp3nPpCZIi1DeC7tgH0TiGWswLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCH\nII3j4IOGtPocjzAYkjdhv8tbZ8cQr7BpJy0cx6hIugIgE6jz9koHDwpctgQvQnW3\nxVjQC+rfcYKSfpIjyhQ356U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZPOQZk1xm+eJfGtWnS0dYxHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGZkMDNjMS00N2QxLTRiNDQtOWMwZS0xOGEzYTEzNTIwZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYqYfVeuXHVTzjoTpJHmejSuaCgV29w8IVna62AQEVAFkD\nGWdxZdCS3caEDxOWib5LN3Sf9UcQideZr2A/E784o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU39xpp3nPpCZIi1DeC7tgH0Ti\nGWswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEpfz4C3QMEiHZ3H1f72l7KmbAiMgd4OrgFpno8e5OVcCIC8rTXrq511B\nwpCy8kKyQfjO6lorhwyUSUlgJfFKEjRw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYKYv5qSvbcNR3sVbNUOF5+ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA1ODlmOTAtMTQzZS00MDY2LWJlOWItODU4OTYzZWE3ZWY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzY2Mzg5YTItNDU0MS00\nNWI5LWJmZTgtNjc4MmFkOTk3NjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOx5OfE3sApIIe6dfCu2n5wmH4+F/tXDE5B94bjJxT76h+oIQpVQoGGptgUp265pp\nyQfb4s8UCGCBRU2bTy//raNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUeiibVylzScw5LEHi\noYoBm74Wi8kwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAHp9pG\nWAPoBZBcwNCPcs83bu8ChL70+76+GEqPo/B85gIgXgj8c10IwkiKXeVpLRYPEo+7\ni7vCv5NybeCK/9aIDSE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3749", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3749` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAW+N3xTgjQPzqtDguBXKTlU9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmMDA2YjdhLTBkMWEtNDMyYS05NzUyLWRmZTQ4NTMxYWQ1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTExMTkwMTYtNDMx\nMi00MzZjLTgxODktOTdiMWM5NGQ1ZGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPA6LgIzrujRX4AgCltd89Fqer8Ou0PHYlfcvgo/3VJVOzpc+3xOIlV3XTYDZ\nZ6FpRb1cOh9ha2FVs9kOsDYdv6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoJ4ppR87cz72bPI95jGhX4Erve4wHwYDVR0j\nBBgwFoAUnVHKv6H8RkXqAhm9Aq2BegPDCkEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCICZPeGFcvfSB80E7X3U20FWbpvWm8e9DuVAVlD5ipRIXAiEAqD18\nI4zu0wZY4+g/G0MprLqOfMTxdHtQ/NofC97AqmE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe8J6lJHyninJsTxGNOLLZK5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjAwNmI3YS0wZDFhLTQzMmEtOTc1Mi1kZmU0ODUzMWFkNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1GRbV6RXGW/RBhoXdbNN/GySj4etSV/iuTqfr1wMhw1PG\n8zQ5ZnABANA6Z4AMo10oltbBPQL+ulq1+JKIFYM3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnVHKv6H8RkXqAhm9Aq2BegPD\nCkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGawRXD9WAtNY6Dm8cf6uF4Phk7gIB/voJzHT85XqPa8CIQDv/qJ+OLG4\nzkcr46Jc3U9r9QfrWzUzOsEh0gsPZGLyOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARVCJzQj8k2A0ZVdoXJCh5etMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTExMTkwMTYtNDMxMi00MzZjLTgxODktOTdiMWM5NGQ1ZGFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWJlNDhiYjEtY2RhMi00\nZDQ5LTgwOTgtMDllNzhiYjM2MjBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDY93mnLzQbvcVZldq/0vRP3ezg1bFzqCYfxpH6d6oFrS+gx1xZaZ/B3VWn6QAYCM\nGNoECU2SCrd9Qr2gV7s67qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUoJ4ppR87cz72bPI9\n5jGhX4Erve4wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBTwh0/\nZ/9bGwOBlMZ9pUnjrc+wLRtP1blRZ3IhF6DnAgIhAKD3ajrUTIaMXguVzI44EXGg\n8LvqTNFFLHuKrm4pBFJp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3750", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3750` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAU7ZQBs5//Iqf+nsqOvnX39IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5MTEwMjdiLTM2ZDYtNDczOS1hYzVjLWYxOTg2OWE0MGYwOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNmYTIwZjEtOWI2\nMS00NTkzLTgxN2MtYTNmNzU3OTgwYTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExo9QZEGF+ZWNRR6L30tccrAh+SJZhvzn7qsXi7L6VNugDEN3AMuy/40ho4SH\nTaxJ/75nyTXHKN0ldacKl1zzUqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNXjQAJMuBTnitH2anpJyaOsNWx4wHwYDVR0j\nBBgwFoAUo2WWULV97MLLMCNRlqyDjjwWiLkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEvCufPfv1juuQ1aZKZL56uuLl1RMN82aaq4w9q/+s6pAiAW59QV\n45B/cmSr+Bf4ZkwQrMbquZYlvt3KcCWCmpuv4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVHTtNZxNmNt9Ei/gE00m4qIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTExMDI3Yi0zNmQ2LTQ3MzktYWM1Yy1mMTk4NjlhNDBmMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATd9DFaPfiW5AFg9Qtwq4cptuVFy5NIy/7GMrrgthPtJelW\neT7n+h4ab+4d3mJMkzXFQjavsG4/Y3k8Ix7MY6U9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo2WWULV97MLLMCNRlqyDjjwW\niLkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALZF5tZh1rywbTlyv5Dd/aOUyjulwtwywNjSXNvLaXELAiEA2ksYhAYO\nNg6lkAyTTtPvxR+mNtG+tGX/LSIOa8/6nvo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAbQLsowBtZMaWoVgjvBjLnUBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNmYTIwZjEtOWI2MS00NTkzLTgxN2MtYTNmNzU3OTgwYTFiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGNhZjgwZGYtMGMyNi00\nOTUyLWJmZWYtNWQ3YTQ2NWNlZTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0MXFW5Av7vKtlODs7UT2Z82aFC5H175h3CG3vWOuMSOddGcZCkB3DgKMZuDEVcKd\nZsbCBpfKqTCh9o500oYj1qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNXjQAJMuBTnitH2a\nnpJyaOsNWx4wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA9+at\nK/a24sSWt4jxRhJSnGrydaSTOfNFUm6fk/CvTJoCIFCSBBpXbwEWP7wx3bfIn0w4\nCD9eVtGf8hDLbM0xg4at\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3751", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3751` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAeTwpnp5sTTmlWFiO5QbnPJKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0Yzc5MGNiLTk2MDItNDg1MS1hNGMzLWQzZTQ1NzgwY2ZjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJkMjBlZTMtYWE5\nNS00ZDU3LWE1ODAtNGFjOTMxMjAwYzk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0YOORReZAN8FXkriNhPO41y7cbkZiCOUCyF5yYVPrH4jOepRb4ZCvvFei5mu\nNgTtdia3YHFDF54CGZUQBpAHY6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNUmD38JG0iBFp4VKCSNOcfzB463MB8GA1UdIwQY\nMBaAFAMt8gs7Tc6UVab2bkyg7VZZYHAAMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAtA+oXYEGtCsUa4UyWb9wRpVXXyJjGi4w\nC1EDMJ+kbgYCIQDBzrTchvDTF7sRCyJ+LPH0G6lOdYtNxR2LH6Kkbp1aiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT+92qBCZkTXfVCcKBBOLQo4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGM3OTBjYi05NjAyLTQ4NTEtYTRjMy1kM2U0NTc4MGNmY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiIjvZjh36aBrHnAEYCsBOjCzdVlFmSQm5oEOa9YevMgXN\nOsiU3grbS18AgH9ZtllohiiO4QRyTGHnYXPtYhm4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAy3yCztNzpRVpvZuTKDtVllg\ncAAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHuigykU005ZcsvfzDPXISCc76Mz4FpUigX08f1TJS4wCIDXNj+PqpUgr\nAjJd2uN8fnonQByQpodJbOPmvCdOQjxT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAZqBSdc1ZLNoY2E+vv7uCFEoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJkMjBlZTMtYWE5NS00ZDU3LWE1ODAtNGFjOTMxMjAwYzk2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWQ2YzJjMjgtNjIwYS00\nYjhjLWFiNGQtNmE3ZDA1MThiYTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2qijraEm333xhchNXwT8TUICIM8kPxjwaHQpeUVNN7thAxCi0eU7WkOaHLsVwTVk\n3qiQIhTSXJBjEdCl66a9o6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1SYPfwkbSIEWnhUo\nJI05x/MHjrcwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAtiGa+\nVKL9VGdC+X94IL8binyNQ/fEfRK90JeziwcJIgIhAObvOlYU7eut0vY37vW2gEva\nDzHqW7p6puYEcsoCtv0u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3752", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3752` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAUkSbnuyhVQNlGg+345+gPBkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliY2MwYmQwLWE4NjYtNDMyZi05OTg1LTAwZDc2NGE4ZDVlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdiZGE3YWItZTEz\nYy00YTQxLWE3NGEtNDk1ZTUzYjYzMDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK/OPDzvUC+S6uiuFIVfamL77x36XSNnQrIMm0CXqYzp3XglWFDu273VKCskA\ngO31mmpXtFe5tSSyFIiLvp8tp6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx5IKbwIXdD096xHaov60SLhZRqEwHwYDVR0j\nBBgwFoAUHPLTvCuljsxl/6NnAIuKd92xKAwwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgYb2/n4ZTbnT7\n54KjntOcn/SxG5nb1L+4ZGlLzuyE3cYCIH3WghyZx0W0yqLJLJuTVw6bgMxSOqVH\nLzByc6Yu0p/n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAau0FHgdo4zK0/2zyUaFY8TaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmNjMGJkMC1hODY2LTQzMmYtOTk4NS0wMGQ3NjRhOGQ1ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhZ+KgG2zGDWSoCpIYzyxqF1d1rKGwGZ2ZBwDCX7qlFcq/\n48bXfOFFJVmcLEJ3NFEaMRs0/H12RyqD0jESP6IPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHPLTvCuljsxl/6NnAIuKd92x\nKAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgb9E7MEqgnaGP4+Dzf90ApHas8EaUzLqweI/dbCKLIZECIQDhB8uXvOGk\nHP0a5DcaQUATXLEXeHXFXc3OenSA/zLhBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAZ4ZV/UumQQ351IET4Ozm3IcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdiZGE3YWItZTEzYy00YTQxLWE3NGEtNDk1ZTUzYjYzMDcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDVhYjJlYzEtZTE1NC00\nY2MyLWE3NDAtNDM1YjE4MWY3NTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8f10rcjr9DhCZlk7UF+9gRkHXVas47dC0xIrZ5qhc1AroS+gnmLKnyYA2DY+zmZc\n69E2WVfWlBiWRKWltZyFCKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUx5IKbwIXdD096xHa\nov60SLhZRqEwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAkcCM\nCtSbe4e57127furjld+t6cihVL5nq691PRcbToMCIQCz4sMSOIFXAkwRvcfJjKJ4\nW3haPTZmdxQFSXjRTb2tMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3753", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3753` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAaXl5CbW+1NavC2n38PIiHV9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwNjJkNmZjLWJkYzktNDc1Ny05YTA3LWNjOWUxMjcxOTI5YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI4MDdlNTItNzNh\nZi00MjA1LTg3ZjAtZDg3ZmMxYjNiNDM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvStczJ6SxvN9rna9GQDbVswHI2w+uRXbn72qlsp7QsMpnrqvHy/dAjxF7Mft\nYUJzp4egVZrUhxSdauWWdUOhLaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNzv9OKAZf/Kb/Rv3j8Z7jmm+kUEwHwYDVR0j\nBBgwFoAUBJ1x5l7IM+lz6zsf0WUIAif85PYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgNfAcHTcJ4LS5\nCtu9PsDXPPgYToqqE0xUWIpYi0H59hcCIQCgvN7Rrw7jd1kqg0suHQ+4iz3p8p8k\nPraAmfuS6IT13g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeP8FDHb1WxRQkKncY0CUqGmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDYyZDZmYy1iZGM5LTQ3NTctOWEwNy1jYzllMTI3MTkyOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbulidPJHXdZqTRix9G/WYEfgyavbHLj8VCBLkQvqDHVlp\njj/7m469Vb5f5Kv3zwPbEr1Qa27iKDY0AiEmAAOFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBJ1x5l7IM+lz6zsf0WUIAif8\n5PYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLROt6gQ1k9tOnrFrCW2U01Pwaqwdu+EwVdg28ka4eMECIQCtsovxLDkW\nd7tqGio0U4Yp+12hzrHs4I0NYLkoFYiRig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAa6LfzgUICBvLn20/R5jJngNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI4MDdlNTItNzNhZi00MjA1LTg3ZjAtZDg3ZmMxYjNiNDM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTA2NjA3MmQtYjEwZi00\nMGJkLWI5YjktZjU0Mjk0NTM4YzFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzskBJXKMHt52AovcnmzYzH38uyj6WMez6Ygfhtw322lw0EH/9H7K9UCG98NosY82\nJiwzK1+UEgtsGXNGx6qi66NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNzv9OKAZf/Kb/Rv3\nj8Z7jmm+kUEwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB2MUjL\nSm+Eio8a2MCKTGiHDpKIiQpN8KJaV9wdQq9+aQIgMfdPfipdDvLlLSsNUMuac1/L\nrBFhacF0Nfn3q7Rb5gQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3754", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3754` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARxm6ViqITxz4kU+DQCGGYwhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5YzU2ZTEwLTA4NGItNDg4OC04NzA5LTUwMzg5ODE5Njk3MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc1OWM0M2MtMWNj\nNC00OTljLWFiZGUtNjcxMTVhZDY1MDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcOoJq47Xh+zc4w3sp9H8MZ5MvBUty++BrNQ3M/ql0/2TC+87sGnq5qnMlkSt\ng9VuzrVjLbZZrv+/dmedSQ6DqqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI9dZIizGLelK8R5rHUy5YW6p5H4wHwYDVR0j\nBBgwFoAUNlkTeT2QsHYYFbQ0NZxW0QnC/5YwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDFDDxJPYqn8\n6D9oLLrxppPCRPwfqw7PwBjtIoEeQTiPAiEA5kFCEgl37+UuJBZjfBF2u/LavgsI\nu7HcRAlJZKh+pe8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdy0+e22ZXPpsKz74Q//zpxoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWM1NmUxMC0wODRiLTQ4ODgtODcwOS01MDM4OTgxOTY5NzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3cNviUMBsGJgLy3/b4oU38keWV42HLDCdrNm3f0b+cGT8\n91dfgijf5Z+ow4WsE5hYBzMFbPlg99Yggwr2EGGUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNlkTeT2QsHYYFbQ0NZxW0QnC\n/5YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO9NTIlsNc5Y2A/YJCJTurFe+SPqAQcakHK4drmZRDR5AiEAqgGlJt+c\nFW76yo6RrLLhIcKxGzON0GbOYq+qmmj0/dM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAUXncE96JfYVs1iwy4So5oc1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc1OWM0M2MtMWNjNC00OTljLWFiZGUtNjcxMTVhZDY1MDdlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjVhOGM4MjgtMWQxMS00\nYzZiLWE3MGQtNzkwNWYxYjVkZmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nP3yATIZJPTgXZTZ47Im46xIOioW4pI3Ey8JfIFzHW1wl4u56q1mzZ1ujVtDWKejU\n8ciSWsfHd5s9+g3D8CN4iqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUI9dZIizGLelK8R5r\nHUy5YW6p5H4wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB3w1/E\n0nLhF2v++Z7il7awR6yjfbz3F8m1L5ixxfbcXAIgC9PyekCc2rST4DU9uTNv5dTG\noEtYVc/0NkD44uwJXXc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3755", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3755` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZ/6qC68SoWC+FjSdtrKCdUNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlYmMyZTZjLTA3OWMtNGIxNS1hNWRlLWRmMTNhZTNiNGFmZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmIzNjE5YzAtODA2\nZC00ZTRjLWE0ZGYtMGVjZmJhMGQwZjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENGSG0x52zdpFDqdrw4ezNAEe0QGEQUyxRGe0d96Ta7Usdu3JGR/LRKW2UjLj\neh6tXWlaia8p4WRV7xXzSXHSwaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+olH+xWMwKy7Yr4sX3nbatW2lugwHwYDVR0j\nBBgwFoAUw3T1fhuu/zpCUm0bRyDXluwBsQEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICizdxT3tyZUijcTKmI7nAqaFf5uz4IcBn+GH6ojgZ+TAiEAtqUE0ZLwKvVw\nEU9nK8u9A2DXsCSCiZUnX30JrRMWvtA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcRNPVpzV9kjiX5dTrlcLMYdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWJjMmU2Yy0wNzljLTRiMTUtYTVkZS1kZjEzYWUzYjRhZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6kTPDxFSXtH+jvlQIHyvBr4G18JDurjYnqjyoDWMXSfPe\nLICbUkbVI032nrtDDKcBJ1wjns5mRd/CVrlcs+3ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw3T1fhuu/zpCUm0bRyDXluwB\nsQEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM7Tl+UK/jppv++ApeGN4TQNhk/s1eqpz5QOq5IlijIMCIQC0HfWweqhG\n1rCs4/9p5h8kUuTjNxB6gOSnQDuxwL3N0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAaIGpTo69GIGEPYtOro6i0MDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmIzNjE5YzAtODA2ZC00ZTRjLWE0ZGYtMGVjZmJhMGQwZjM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTU2ZjU1NzItNzUwYS00\nNWE2LTg2MjAtNjA5ZDQ2ZjU0YTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVliep4guF4ii5sZp5k7Zm3IVKRdS3Jz8gP8cjOvGppMbenE2t+aoaap9vZF3x/Ng\nqAeK5ym3oaRadRWUMnSaK6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+olH+xWMwKy7Yr4s\nX3nbatW2lugwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA9B7D\nS/Fj0SU7oYtifiotmZ3fQYM6mGK2pBMzPtdbsRACIQD9pt/f02h8C4lHe5yz0V9s\ncZtOv/fMKs4y5qY65eeb3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3756", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3756` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAcjvg2W2W4X6ZK+cxHSRtlxxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmMjE5MjhjLWViYmUtNDViOC05OTEzLTVmYjdlNTQ4YWY2ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA0YTAwOTUtNjIz\nZC00YTNiLTk2OGItZGE4YmMxNzBlMmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq18omof9aDgQwj3nRB9ILoXpIL1lXDOFyTqOAcSMlKuT0NwH7GHyLlTT07Iv\nYeFrMMwkZXDf0GOSs1fNmc9F7aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCTAeW2G424JoXFFRHlyKxthqQLQwHwYDVR0j\nBBgwFoAU2JlmApbuZUShyinr6fa3qb4xuzAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBPz7NLssLdWzLvBhI12oAN+avnRCzXRI/LzWNcGYlf4AiA6skYCINIvQ2dV\ni6O2osuc/FClIfnC1b3xOP+0PEQgew==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAep0Idz8PeGbMedRyTaGCAdtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjIxOTI4Yy1lYmJlLTQ1YjgtOTkxMy01ZmI3ZTU0OGFmNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWJ04V/760o2GAHaH3C4Q+VtHJ6yWg7GCU1j+nDpiGl++v\nKTmttViNBf/CTy20ClaGWqqmNqw4sZOlq1cGrgDao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2JlmApbuZUShyinr6fa3qb4x\nuzAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIdbkLshMfxXdO8pnxEmc2WJjIGAqD3Lxv5AAoMEKDMFAiBCfJt63Axm\nxgCh7uxAAbYntnUpkjrqMiRhHl9VfH2nLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAaSiYtcAI/TY6RJsoEvVj8CzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA0YTAwOTUtNjIzZC00YTNiLTk2OGItZGE4YmMxNzBlMmZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTE2NjQxMDMtZGRiZS00\nZmE3LTgxMWEtOTg0MjFiNjc2YjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFQU9L18Vfe8rIsEX2BEwW5UrtRbD7eD1b99s9+Y1xTBLyDKiu3hPxbjlbvgqhvf0\nlXzZlF+KCAFGHv6FIu7NK6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCTAeW2G424JoXFFR\nHlyKxthqQLQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAcfyr7\nA2z2O1nQyU+gN92vGJmLyLXMl3znTWvEbJ1NPgIhALE5Zv5cZ+q9b3V3oMxQJVkj\nc+423aABRWYe3pAVKibY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3757", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3757` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAdky6mHIayxFlYeue5LgMjQBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkY2IzMmJjLWRmOTgtNDJmNi1iNTdmLTI0ZTU0MzU2MWEyOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZkOTFkMTQtMzNh\nMC00NzQ1LTkxZmItZDA5MWNmMTQ4NzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI7draHaZ4pvqMKK/CcGARJZUqz8c8aMnCXlWOXgWcBRC1IdzThG/F82HuL0z\nIcho+sXZvh+NhFCtjigAAvpLV6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2jqmSWWJs87aQLAJpWHOUuZem+8wHwYDVR0j\nBBgwFoAUlJaRDGTN2naePjDnTqUBvKwULyAwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCM\naZ16jOwflUBJkhSEO5RUfd4xe8AYNAZzxYKDuXppwwIhAOH3z3bRXNzXQGI4SXt1\nyyUFHwVDwfxCWZIWSw91YgvR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARPykoAsGIRHV16qH9XMV2OjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGNiMzJiYy1kZjk4LTQyZjYtYjU3Zi0yNGU1NDM1NjFhMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEOnUPuULZUK19ovem7Qw+2iV81/Mu9uZ9xKMTly4rhXBj\nWE0uksv8jw3v4ubacrK7p7wBejmYkPH+q+kL35vEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlJaRDGTN2naePjDnTqUBvKwU\nLyAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgROQqyvYXeB3UyVL+JuDvJzACRvQz1j3ulffkNztyxcMCIDgLOpbp1SSm\nTTRwWfARMWdkAADf06RcnpG2rK68Me2w\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAXg3Z5yZIYuBA4ZkDS+lIyA+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZkOTFkMTQtMzNhMC00NzQ1LTkxZmItZDA5MWNmMTQ4NzY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjk5MDViOWQtMjQ5Ny00\nOGQzLTk5ZGMtMzAyODI0Y2FiNDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nG54Jc6JTajuDmz9o4rIkYqLYhh68gcxY6SlZbL560y17qwxWHguv3VpfCmaeDiTu\n48E4c4lSH1Zi3/cuMPDog6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2jqmSWWJs87aQLAJ\npWHOUuZem+8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAVEvSG\nNOVrGiq4dd/va8qis0lCU3uVYfokIwpqn6sH5gIgNHz2xVDEdZ8rPkC6sXwXVyR1\ngFWcs25EEIrJAnm/eas=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3758", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3758` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISARwDELq6XtzwFoGmYE4xI1zEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5YzEzNzJhLTExMTYtNDYxYy1iZWQ5LTUzYTUwODgzMDA0ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmYzMDI0NGYtYWQ3\nZS00YzViLWIxYzgtZDBhMzIwNjU5YzgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExW2L9fZGQcFnhuxfnXPk2ACHpCPsIWSF5hvrZRjX2zk8qgR0IFPLEiq2yuy0\nO8PmXYOc2HNj+CtsuCm+PGvWa6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0MNIpZrAoETl8rZNu5zzmHV9PTQwHwYDVR0j\nBBgwFoAUl8whiu0TRuYUOxFQde0aT4jMSHUwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFfmDXIXwBoKldOl611vokH079+zWfxw80tEatfchuSgAiA4NdMg\ny+ldNbVdPpHr1wdSCjHKlRHYLFeGn0hdel1ZgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeZ6GGVYJ+p2Oi4u68Ur2pQCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWMxMzcyYS0xMTE2LTQ2MWMtYmVkOS01M2E1MDg4MzAwNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1Bsso/SfldU25qfpb3Wn8BySaP0WHn+vO5eTbQTrznMtx\nsA+pSIhXXQyDfUK9mMrRuMGdcxZtA+Kokg6VGwmpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl8whiu0TRuYUOxFQde0aT4jM\nSHUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC6H3IvChyqmOPjMGBPt8aMOy9JKflAfxLD5GYGs274gCIGBp1Tc4ohLM\nxr5Fxv5vHosUobvdDpzOKkuEeKpuvOXf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAVJTYxtRMPJozbDyQrXPoQ+yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmYzMDI0NGYtYWQ3ZS00YzViLWIxYzgtZDBhMzIwNjU5YzgyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjk0MjI1OTAtNTRjNy00\nYzM3LTljMmQtMDYzY2YxMzI5YTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLx2iMF9+RyH7hiIpMkB4cCbVYvgn4aRUSV5Hqam1wbRm4AUJP86PaAKBWF0fHBmO\nFWWrvJWewpo9mv2rGjXp7aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0MNIpZrAoETl8rZN\nu5zzmHV9PTQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAodMe\nQ05pen3f0B+nyOufTgbkpiSA+7oaWkFGMfp9pBkCIQDWAHTrcEqkxFtP5OCHMCfV\nbtSU+YSIF4nkvZ1JgtpdTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3759", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3759` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISASs/1gGLfw42OnuK4vFYWk/bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzZDI4ZGE1LWYzNzQtNDJhMS05YmVkLWNmMjZlNzkxNzlkMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNmNDg1MzMtODc2\nMi00ZGYzLTgwM2YtNDIwMjU2YmNkMTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ttFiYW+JUCXaw7SES55HUPNxZIJ5kMsmQAptM8EmhkDIsAHMCiTGvARXRnj\nqNoI7Wce6vaCOrqujNnfEAoauKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6YdGGfTFQV7as+HHoA3fChAc0ZAwHwYDVR0j\nBBgwFoAU6mCbIgViOKsA2DqKiN8RsfLds3IwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQD1LIaV9GomO0LLMmojBoHE/VXufRG3jOBNG5TYhxvBYAIgIgsH\nLxWZOpxl3bjU27SbMjFmygKYPJUjyE5+96UUq8c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARzASqkLv1u9TAbWQiDJVbWEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2QyOGRhNS1mMzc0LTQyYTEtOWJlZC1jZjI2ZTc5MTc5ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsGYGYC9BWS6mb8rsKQ96uZo4xDMu/hqrN9POKx2iRNVP4\ndk2fbDup4b+H9eeaZIOXDpeUEZUEfjU4PfJSneFdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6mCbIgViOKsA2DqKiN8RsfLd\ns3IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUN9HFiR/+5SJRExpb9G+CbKuTJOpjpe9OW9tsWcMy+kCIDBjQxXbenR6\ndwB5HVM3UTIotD9nkUipCyvfbMGTEwCe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAZEE59eKAFYlV82n2ktwGV0qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNmNDg1MzMtODc2Mi00ZGYzLTgwM2YtNDIwMjU2YmNkMTgyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGI1NWQ2ZmUtOTE2MS00\nYWU3LWJjYzItNTMwZjc2ODcxNzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSco733QM+igyfztpwCOPEMh5g/oGAu+OFAocU0+5krlXoHeqf77hnhHJNlv4su/l\nmsS/4L5o4MdgMUflqlocRqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6YdGGfTFQV7as+HH\noA3fChAc0ZAwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAr1OoD\nbohLgOzA4bJAVk0MmUOajk1ZILeUb2Yn9yILKAIgLndmv7HtCFUTddfgStYZUryI\nhtCQrPuS6CW43P6823w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3760", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3760` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAcjoe1L9MnRg2QHYAACLYt+XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjY2Q5ZTg2LTdmM2YtNDA4Mi04ZDAwLWY5NGFhM2FhNGFhZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc4MDdkMzEtOWU3\nOC00MTU0LTk0N2MtNTg4MDI4OTA2ZmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWS8r70OtBZrQ9tDZJnG9lrSa7KG5P10lKJmL+tUvkUpj6t/Bx6g3Q/hbeEeD\nc3kWYQXyv2Q+dr7Y4yI5ol0OqqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRo6N5qGftf/1VA9ITbSGhTwyc3JjAfBgNVHSME\nGDAWgBTuKDE3EKMJ8QnzaTNPehdk1yKvyjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGAnqzl/MReQZJwchoEk90/eskEYZbVQ\nlOwG3K8tTEAmAiBaj+TFn8deJbG6+zCMP1t28lylOvRqvBOYwvz8Cx34bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZN2+kSlofOEpgx0zvVdUM/2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2NkOWU4Ni03ZjNmLTQwODItOGQwMC1mOTRhYTNhYTRhYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0LON31Q4TCSNPWUL485twYkne7UMN3xAfCL/WNUULfg26\n/nSwqzqMxX+/hsiiegxM61YRA/+Fa7j4y5sF9Pmco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7igxNxCjCfEJ82kzT3oXZNci\nr8owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU23vOqMaqem73Htw76YpEX3/MMNiv/62ETeSx9OKGfYCIQCsgiZAPI70\nb+rrXpBUkqNIBfAWAjuEnpXPuOgt+y70Ew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISASJcDnGPZMuv6sYUqdUXjfQdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc4MDdkMzEtOWU3OC00MTU0LTk0N2MtNTg4MDI4OTA2ZmE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGJmMDFmNTItNTI3OS00\nNjZiLTg3ZGYtNDAzOGU0M2JmYTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nc+apG4Qhsr4RdUK6Ysu9trL07gyubkCQckqs3A8aGe8YLhvcbgUMcikkYLsKPAQ+\nzoIL8lIke9zqqpSCnT7Xz6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaOjeahn7X/9VQPSE\n20hoU8MnNyYwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBfQY42\nyEYZIP+kpFmr11UJzYS0IvoT89dnirRv/at6PQIgJN2H4s0EJY2MRk+g58dPZ3KW\nSb+VRVqF+QldsMApEYg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3761", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3761` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAV/iZWuwPP6QQvzxfNh9jrciMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhY2QzOTFhLWE5YzUtNDQ2OS04NWRkLWYzODBiNmJiMjQzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk4OGMyMzMtMmVj\nYi00MjQxLTg1ZWMtYzg5ZDdjYWUwNWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENGTZglsr9Mh7qmI39AAptGmCHraipdSacca+p8PaHjWLcBDQAXb8uDH5F6iN\nCghmV8Q2arIAlD3BaDGRKxQON6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjtCjBjIm+9/xd1BtJrQv+3pURZswHwYDVR0j\nBBgwFoAUHv0/Y7+DUOpCsET4+GB9lGQbzGcwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIE1jY521p5Xi\n1co2XZou6rVTvVDH2fKg+lAm76otKtEjAiEA44Wo+C0Ya90gR6SLn33XARkRRuI6\nMeNOpc/K1TfNLFs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZZtT4GLGzBmo0YAdj0T9lOtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWNkMzkxYS1hOWM1LTQ0NjktODVkZC1mMzgwYjZiYjI0MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATq3y1LPd7wLVLKtYdeqdNRO9GCBDItIsGVvC8ZiB8l+l80\ndf7nlORC7EcBYZZ0f34nFUin+FEeAchdpanDKH0Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHv0/Y7+DUOpCsET4+GB9lGQb\nzGcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANYAHm+nMRmhmfP6dKy0SX6QeYQxiO+VtDPjRMnQmOvnAiEA7BOXvnFa\nhIWf1ThSrBUFUkmthXCh7ByuF6pVXMOJHQM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAfo/wrt7CRp2UuOrWar4yayeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk4OGMyMzMtMmVjYi00MjQxLTg1ZWMtYzg5ZDdjYWUwNWE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjE4YWJjMGUtMzY5My00\nNzgxLThkYzktZTBjZDA1M2RhNGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwguGhEFFAtgH2yvA+0MySutyq8lwuWAzOGlk4K92yV8M6iRc9dbcHjUYBRQmSVTu\nuiGAh24D6sN73v88Qa3IkqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjtCjBjIm+9/xd1Bt\nJrQv+3pURZswDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAquJT\njgPky19I/PhASVHTbD7+IEqY/dVGERyLUqsL/6ECIQDMEBOxPUGa2VckTOXB+2Hx\nBUPUY/34SoADD2jK1ywLQA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3762", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3762` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAc3+EvuuTmisQO34SLBZv1+VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxNmNlZWYyLTA1ODYtNDQ1Yy05ZjE4LTIxYmVlMTFhYjNjZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE2YzIyZDEtODA3\nNy00OTc0LWIxM2QtODRhZjhiYzk2MWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfGLyLk0Q+biovy4H11yYCG3Okn+CANyXBAk4Aj7jAGtxzWM9i15mnG7/7O/0\njCiondWhf0/xs0k1eqiHXBN2M6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyWyM6CM6qG3VWpMscY9s86tw+rcwHwYDVR0j\nBBgwFoAU4nOdWeKEBDh/hTJEEnGl+bIf+pAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIAXur1IMJULK\nWHWQkm2AyD7ftPi+VDRdFdGCOHYxA7BIAiEAwIYOt2Cb1Y7eZnE+uQxw44o00qi2\nYQargzoD5MTsRCI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXWj3wf3CbM/yYfm9JJLzOEPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTZjZWVmMi0wNTg2LTQ0NWMtOWYxOC0yMWJlZTExYWIzY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFB1PNS425ZkORl9131aNvvPoLks3m+hGDuQ2p/YTZ4Tt+\n1JDyp1Vnl7JN7amuvYfG8tTsk9ijLHDbLLABnE0No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4nOdWeKEBDh/hTJEEnGl+bIf\n+pAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK7DXxUQWH/hDH2aJvJktgSqH+4/XU9uw1GVir7pPA0kCIDtN6NQHDgbv\n2mN+Oes7Mbc6NJfxp+gfX+3cWc5qRVNs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAags5Y+MMkqreT3zaJS2Zt4hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE2YzIyZDEtODA3Ny00OTc0LWIxM2QtODRhZjhiYzk2MWNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjc0MDE3YWUtYzUwMy00\nY2JiLWJhNWItYjA1NGU3YWZjNDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOrpRSMg36yUmy7QVPIYECXtrgoIPkMfoZWNIzZ+35+IFo3DcqYtUl2yGBHhYpFj6\nDqSpHJvAeaSlQLvLvS/uQ6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyWyM6CM6qG3VWpMs\ncY9s86tw+rcwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBz9wch\nJHfL/Slr02vqiddx9gf9uxxXDLx59JGwR3XCtAIhAKmgNbe75VEkgr/7sD0X/HZe\neNL+k/0CJeMXq2f7nAKj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3763", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3763` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAepQ0YERJ4GlyaSb51ohrw4LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyN2E2NGQ0LTA1OWUtNDNjOC04NTljLTIyMTk0NmZkOTgwMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY4ZTk0YTMtMTkw\nYS00YjdhLWI2NGYtMDgwNzQ1ODM2OGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7+AbHYzbeknoCTV864IKbA0Cxpia7HXB1aADHVrGq+QY0DJJWapZq5gSsvEi\n8M7ZUZoIY3qPzHdkOvwmNJnrgKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX416m0QeME3p6KE7lnfG0iRj8B4wHwYDVR0j\nBBgwFoAUY7Ly07QAi+L8JnGJkdvtMd18TJwwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA6LjsvJST\nFlxwSWCD0jr2rPg5ELOSh8t3P1ThxcCHauYCIDZGqhiQ5oT4GeMrF+HjaAOdZRSO\nL271dAAHWPXoNaOi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAas8kIGmeKKPghK2ZFso2iG0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjdhNjRkNC0wNTllLTQzYzgtODU5Yy0yMjE5NDZmZDk4MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZ+DJBeVXhZ8Hm5EdHXJFitXeSSJ1DeZvJwoWkkZ8yEI0Z\n3zWCvkFurr9P0hukP3AfSxP1gk+3IJ97O9p5D+xVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY7Ly07QAi+L8JnGJkdvtMd18\nTJwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgByG7mVV/odULvmVsMSox0/KSZzl/0/gp4JIrWO8hLG8CIFGRj1FePoEY\nca4cSDHtVUSvhvmEM/D7RmP573D/FW4c\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISASdvEx9meCRl8WAIrPXPkbNMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY4ZTk0YTMtMTkwYS00YjdhLWI2NGYtMDgwNzQ1ODM2OGE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTI4M2JiNTItNjFiNS00\nYmY0LWIyYzAtZmNmMGQ0YzMyZjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2ag8ayvr0AWfgq4/O78qTTJJBJSXFiJy3qdMRvTjUy4RVErYLUkAKB+2ny3J75+F\nT1wzmnV9dMFBRKq/A93dHqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUX416m0QeME3p6KE7\nlnfG0iRj8B4wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEArwYg\nsuLWFeInzA3kTTcbbvlyHdBeKowrR3x1MkfvhlgCIQDrzoqri/LwIvVmYTJ6cR2r\n1Celis/HjR0YD1QZxuACqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3764", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3764` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAb1mbJX6+oFlIYP4x8+DxQ5tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3ODg4NDQyLTg5YmYtNDFjYi1iMThjLTEzZWNmNjcyNjBmYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVkMWQ5ZTgtYWY2\nZC00N2NhLTg2NWMtYzdkN2M5Nzc0NTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8UswsjMUUckN+jKQzuIvIr5wwz2VENkXKIj8Oh4xxaXtxeIjvQW8y4qH0I8M\nf9/z3GuEZCia4RXYkSzE+pzx2qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWsNrgapSnbHGTEZ4fHm+MPVXUwowHwYDVR0j\nBBgwFoAUPFJAOBCKJ+8rGIELOPos4lovgQUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiAEw+0/qfkXLZU63i5nyE7fecdgFqILkA++pMMp3AW8OwIgdAWXUSV6xLyX\no+x47ZjZxYMEMK4n/CrJHr3S6d7BGbs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATvZ4pCLaNC57JVk9s6UgqMYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzg4ODQ0Mi04OWJmLTQxY2ItYjE4Yy0xM2VjZjY3MjYwZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbf5PGuD7oa29/+oMX2OHfrn6PZjVqRmMpEyadUp1oBSXZ\nsNtdrRXmIDbMmUJ/+vFlfIk2Uy33larMU13Ynwdmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPFJAOBCKJ+8rGIELOPos4lov\ngQUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMV8Z4uQgP3tXCSUnEbOhdGkvrDlhMjEdGikLBPFGregAiEAhf7eLJpc\ny22Q2pDC8Ts/DK9K97dHc7mGkWLvvQIWT60=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAeqbAbSWK2lAZGzlkVc2CIoEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVkMWQ5ZTgtYWY2ZC00N2NhLTg2NWMtYzdkN2M5Nzc0NTNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzI5OGVjMzQtYzllMS00\nMjc2LThhMTEtZWUxNGMzYmQ2ZmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwSv10BarAZ89UmhZfjendg4ZiXNAj42b0z10D1fCGeodZlT9PzmsMpcMId4lwrhD\nbt1MQ1HZI//dlFu9w/3zTKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWsNrgapSnbHGTEZ4\nfHm+MPVXUwowDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA7w1w\nu8KFemOT+mXgqRwvspgkGNJrAu5FgPOy/xKlbNcCIHTtDTijcHyQzksvdzAM35DS\nUA5PflCjG+7gCelIoZ7g\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3765", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3765` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAd7DDAJV71WZRsMoOybU7UlFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2NTY5NTMxLWZiNDctNDExOC05NDg2LWJlOGNiNjJjNjk3NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc5YzE5Y2QtN2Q5\nNC00MDQ1LTgyNzQtMDhkNGE4NmRlZTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGxFXqZcoi6La1p/st1NOyLq7paNh/mqKx9WZYbbFSW7Gxb6hsP27F/+EcLqt\nuAaFjsYUoke4ZLvGhB0Jozq4/aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx/94u7jPCzgx3+ei5FZnkqd3D9EwHwYDVR0j\nBBgwFoAUF+6T9W0H60gBd5ZAKq6jkJUk0VswNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAsIMoC4UH66m11K9DyCY4gmqEpS360+kRHw/yJ9ubqvQIgA0iv5vg+U1EP\nLlBh+0icX/5xj9kCeBqx9j9iLuDxifc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATvkx8x8f4ThnKAdNQcdNHOVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjU2OTUzMS1mYjQ3LTQxMTgtOTQ4Ni1iZThjYjYyYzY5NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZr77YVeiP9n2nYYIs00vgzEPHVpWXjM9zTh1W5AbHw8mz\nQMQNAFysfZeTi087AtDTMNcei3wuWuVsuI35iX7ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF+6T9W0H60gBd5ZAKq6jkJUk\n0VswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYEyC4FWdkrQm+RfZQL4/4cZ9+ibyUij03tXgxxhSyZoCIQCnrn+PhfRC\nrB6xJqGGqO0Vi9hY+vz4ScSNEZ4IilhG1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAaSOZFPjz/lY2Y2+KaAeqncZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc5YzE5Y2QtN2Q5NC00MDQ1LTgyNzQtMDhkNGE4NmRlZTg0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDNkNDU3MzAtNTA1ZC00\nNjFkLThhNGQtNGJkNDkzYjM2OGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\naq4BWrHdVSHqfOvK2VaxFweMugH+oOWAj9GV6sUz+f9zlXRn3dFMYA6qRyTv0g2B\nrB4ukmcq5y1LoVKNLxfQ16NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUx/94u7jPCzgx3+ei\n5FZnkqd3D9EwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA7MnKc\nes+O3Fe/padQ5QBl4P2Xhjg9iQyfro+pT9T/dAIhANc5PBC7yaB84zDKmJLgbl52\nUyH6j2YukQzAZenYpSrL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3766", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3766` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAVF2JSJEvmKVpaEpTCk6mJedMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4YWY1MmZiLWI2YWItNDgxOS1iYjkyLTRhZDA1NzYxMjg1OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBhN2RmNzAtNDhk\nZi00ZDRlLTgyYmItMDIxMWYzMDI5MmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQQg49A34w6BSlxfqm91L0gr6u2cfAK5TsHUnC7UOMzID3RMSH8ZoloXGLXOV\nxCFJTU+cHyNJA2KuTfbktJ43JKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs1U/P+CvohN44x/eHjc366gUy4kwHwYDVR0j\nBBgwFoAU6cVkolEzuM2ZTUZab2HBrXeKEa0wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n1Uh9qniAmLoP89c8YUA9DA1efPPKy8RRGHek7Sv0p5cCIQCFllEnVABjebbXHxql\nBgFc2HePewCpxpRIkq+4Zto42g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe1FR1HRqydTliuihVF9kXlbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGFmNTJmYi1iNmFiLTQ4MTktYmI5Mi00YWQwNTc2MTI4NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2USQakoCFTM7CFc32STKplQcnlzsJNkkcnb0+o47xFfts\nZyufQsH94cdmdKxSkCoz/qky0/ibEPNlvsvgoacZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6cVkolEzuM2ZTUZab2HBrXeK\nEa0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP2vufEMJ1kjAcgikFAMwzyn3GOZ1p7eHl7B4zwKmqB+AiEAxIM8Yb9w\nywV2uON6CDqVw4USGqrZ8aMqvd2ZFAb31bc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAZzjzFaH9A9vLaHAgiUrZLmLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBhN2RmNzAtNDhkZi00ZDRlLTgyYmItMDIxMWYzMDI5MmE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjkzY2IzYWItZTFhNi00\nYzk5LWEyMDMtMzIwYzJjMDA0NzQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFV1I24BPk7pPqhaBFAODPN7+DTP3cuTxKUMRAVEWzSXSdzsUJgAVKAMEa+WlAX9d\n4x36GliltW3zKR23wiel4aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs1U/P+CvohN44x/e\nHjc366gUy4kwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBPFfDN\nAkwnMYAybvHuCEEiXLntwF/rxYy1yYGPiQqZvgIhAJ9GgEAdvPwqhhbLUDuZ0YuY\ntcRkJnknT2/D8A0xSSxG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3767", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3767` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQkjil6ds/fAHoAROQQOApmGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkYTQxMTM0LTFiMGYtNDQzMS1hZWI3LWRjYWE3ZjVmMDA3NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ3ZDczMmMtMzMy\nNy00YmJlLWFlNWItZmFlOGMxYzBjZjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN8aFBLMmCjtaQ1K7rnK2iK9X/1jjmgY4UvlE6HVLPyYZr+mMssMJ8Q5qxJOh\n4dP6UojR+DAUfJRrO4brv7Q7BaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7GbvzXeyXkYsEDx/ERirktwSTmYwHwYDVR0j\nBBgwFoAUb8jyLmbWQ2LN418uyF3z1kSnwQswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiBdkDsCD3sDhe7Y4c7OxgISxEfILqDdvhof21oihcgvowIhAJoz\nlYI6U9EN1x6uErGTP2uEEQYIkAgehcN21xgDm5Mk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASeoZfUbcV25jY4wAmZooTtuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGE0MTEzNC0xYjBmLTQ0MzEtYWViNy1kY2FhN2Y1ZjAwNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKC8Ukr77hIrtlXfgXm3PDq4LQW1Ka0MM6lIv+oiwef7L8\nldEKRe2T0Gx58LY56Q9ELydeVFAWjMMUIvRUIoBTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb8jyLmbWQ2LN418uyF3z1kSn\nwQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgboQxAhnm8VEr3w9zxJg7kVkXYW1eNq1T9SKV7/7rNfMCIQCBE+u/kDIY\nLD/T6HYl+vYMPaJztCFCeB7B+vxKtGa8qw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARPb7Gotu2yvC/6lCXuj30vSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ3ZDczMmMtMzMyNy00YmJlLWFlNWItZmFlOGMxYzBjZjdhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzgwYzg4ZDMtMjQwYy00\nM2YzLWIxMzUtZmQyNDdmODU2NmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWAei7n0OIfaijJC1DAVz5yxRdSpkuNRFW5zBCxBq7Vo9Ti8irkybmKill8gFvwa0\ne4UvDd6sUboRhsoDv6pDY6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7GbvzXeyXkYsEDx/\nERirktwSTmYwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA1BqHQ\nb3YJEenhedrRb3mU6dXW8FDAoMoWAy59cIs9RQIhAPGclZWfRV4KnCwXk3+iOWfo\nCVA18yH3JKNtB48u3mTA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3768", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3768` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAUhqV93ppCUrA344LA6EHOBRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNWRkMjM5LWNjZjAtNDA4NC04M2U0LTI2ZTMzNjAxYmI0MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjgwYWQyZGUtNDU2\nNC00NWUwLWI5ZmEtMTVjMGE0ZjExYzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyfl6uvZuaMhWc+1hzrqfsMYuPdi95sY8bTvE+e7d1uDOgW5MDoI35EJelsXs\nr17K/vZR+Z3vaZMAPHdSgfuwDKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3d+oXMlvwA9A8wcmD+3+LXnNAoMwHwYDVR0j\nBBgwFoAUFQUUWW4yDVhHJBye9QscM6qbr5swPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAzC7RdNf0VpcmjvDsHlKEmugNxINaHxP6L2laIr441doCIHqr\n4h4IqtM5EFU/N2A+j+lLa1Z7BCyncVjZq2AJA8FU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfatQDlU6xMrSKUCm83dJbnTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjVkZDIzOS1jY2YwLTQwODQtODNlNC0yNmUzMzYwMWJiNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWTsmb71zjKlOP1bEvdmGiK6qTRgS1D6uKtlgVl6o4WmYf\nBeV3XHYCWYA38AKQn8E2Jclp6lAguJcqecg72BcBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFQUUWW4yDVhHJBye9QscM6qb\nr5swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI1LRNN4/ZPI33AdB8AgB96MiFDg4Aeh1Ko8HhabGMqqAiEAloHgPm+S\nifuyK1OZfhM9pt/VHk5ngR8MCRXEcKPsbxo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAa88h9q3qRAKVXATJpJCpWYAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjgwYWQyZGUtNDU2NC00NWUwLWI5ZmEtMTVjMGE0ZjExYzM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzRjZjU3ZTAtZWE1Ni00\nZjBmLTkzMGUtZjgzYjQyYTkzZTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nm+9H08P1HhBv5engEuNm8COTmgFaLt8FMo2AhLxp6D8biSNnBXZLopsjqQqQNuUX\nM5XMixylpd7jwjWbiE/UXaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3d+oXMlvwA9A8wcm\nD+3+LXnNAoMwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAtdpS\n4XD1rdTIqYqPyEFtX7FPk+lW4SYbvvEVO7YdzDMCIQCuI1PfBASIiFqG5jL+HI0I\nepCR+Cm3NPxmnkPr5IBfgA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3769", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3769` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAfoHv9TPejjPZ3V1WlYPNRXsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkM2M2ZGMyLTU5ODctNDZhYi1hYzc3LTI2ZTFmNTUyMjY1NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDU4MjM2YjgtZThm\nOS00NGEwLTg1ZWMtYzQzMzRiMDhlOGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Lc1+o3l4D6hMeZqxbfi41JKjVJwvrskg680/dlRWZ7ElVSZ1rtoenplz2Bc\nqhguIys22btbWnSUAh4tsIoOP6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2kOHwTnNSEC5kLORh5shOQjSFhwwHwYDVR0j\nBBgwFoAUCwkOLPBPFI/McO4x/t/40GyDYEEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA822dr7dyLtMH\n6ewJobmsOH5W3fflrhfzIJELR08Wru8CIQCczaKlu5bwD0EGm2QkEEJA3RJ1/znl\nSRf4SM8x0bj5YQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVfKElaVhubvcvRqwrzsvMvkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDNjNmRjMi01OTg3LTQ2YWItYWM3Ny0yNmUxZjU1MjI2NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ47CGJNp4XGUEweJLYaIe4uUdRIkcS4OfHznwMz3iXryH4\n8u6HTsgPcWSp3HOemJnqh+FhYCl+oq6oA02tuaufo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCwkOLPBPFI/McO4x/t/40GyD\nYEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALWkLo4Ty6TTViAtbniVGzsFcFUGZ7JnZPldHdWgHEQ4AiEAiNZlG5gr\ntzZ5OAlsfUFbUpEI0f0M95or5hNg46dPrBo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAdAA3gUN1DcRDMeO8h/MnZPGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDU4MjM2YjgtZThmOS00NGEwLTg1ZWMtYzQzMzRiMDhlOGVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDBmZjJmZjUtNTQyMS00\nZDJhLWIyZmUtMmY4MWRjOTExNjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8UHaS5mMhCspCJJFUg7oqZ1vwvHeJqTfTI61KhK3NWKhg7WXj+88hmTZobT2Lgtg\ndTM/6YZ4Wpq6oKlIpvkFqqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2kOHwTnNSEC5kLOR\nh5shOQjSFhwwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA7Aya\ncnYlKb85W7dIAYJtC9GG4/WxFS1FutR7SN+aqYACIQCHG5Q66g4t3mqDCgkPyPwh\n55piugGFZ11phh+D9ZKRfQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3770", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3770` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAadV+ZT2z4wsnNNEdxMrT5lDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZDQ0MzM4LWNlMDEtNDQyOC04NGFkLTc3OWQyMmJhZmU1MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM1YWNlN2MtMWIw\nNi00MGEzLThlMWEtOWNmNTUxNTdjMTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQqlksm2RJCDdmlWujVpvjLJlf+vLEAm4TyLIFHIMNWAUeMzlUKR/bvy62wih\nXGlhDW5FgKAcdarrsAlr8aOLNKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaXiqlEVvDcyM810usLB7Bi0GES4wHwYDVR0j\nBBgwFoAUn8KFCAyjf9Ehd4+P3GGCTJ/8T6QwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFVEbCqKkzBXOvm/IRzJ1BF/3r0rmAGQkY+WT3lzQahbAiEA3s+pWegHdwzM\nnG2Ec6z1JDPSRl8M+exiuDoT1uMC9F8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXHTx0QDOFF/foIBqYJM4fWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGQ0NDMzOC1jZTAxLTQ0MjgtODRhZC03NzlkMjJiYWZlNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxgeOxdw8PM0byHW90wygG8nUvllaEvd6h3KDd2g04b9MO\nDe0rEJi6niOCJo5VTv2uUeh4wSXLeso6FtBR4hXco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn8KFCAyjf9Ehd4+P3GGCTJ/8\nT6QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANnU1E9S+ABSHI1+cwMma483dTwtraRnWrn1/b7VxVhoAiB+WmYsNK0v\nUU0GH5keWJTLb5kWfrhLucNFywdADvicXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAWKIFeDfl6K8unsedH3Jkth6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM1YWNlN2MtMWIwNi00MGEzLThlMWEtOWNmNTUxNTdjMTk0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjVlNWU3OGMtNDg4NS00\nODY2LTlkOGYtOWE0YjY1NWRjMjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyGbjkBi0+nIKLZID+XjH2b8op23BgbEwhd8NTh1MKALNAMoqzSB1Iivy6J3MAmWA\n8SSr+NSkp9TkARJqLtwKRqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaXiqlEVvDcyM810u\nsLB7Bi0GES4wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAj6Zu\nc7J4ixQ4w9ZrOvQdiHgodxFBvI1a8xGtz+P5hJwCIE1CgXm0h9VqNZhpVQEzK7Nd\nVtREfs6mu9sU9iqloBuy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3771", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3771` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAY/I8ep4IQz5zN65PL2StZaNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkZjBjZDI0LTAwOTUtNGIyNS04ZDdiLTQ4YjEwZjhlNDdhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q2YTM1MDUtOTY3\nMS00YWUzLTkxMWMtODEyMDk5Y2E0MjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEycHSxUHTGUmAeAApR3AxNjdhng9piHhpI4TYkpgCH9dieInzE92jBRz6p/MO\nZynn8KWTJyLBzXHIRtU4gU8q8aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjuDcZHpajeIm68+pT7DyKUFrOIEwHwYDVR0j\nBBgwFoAURtqnDsK8bQg2Vge3oaywKF7lCLYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDcJDmdiUNKm6Hz907jJ8hYO5Ti7M5WQm2EXu68Qa3i5wIgY/iPRP/JkRsk\nvJkidf2Kk4pzcooeZm3p4pjsmmlfHVE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYVdKn5jvqD1GtzLcenpne4hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZGYwY2QyNC0wMDk1LTRiMjUtOGQ3Yi00OGIxMGY4ZTQ3YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9VUQ/jKDiCnfAvTdgI37jedOPFi29u0ByctVIFhoODmjE\nmlXPpQZKFfiWmvqGIAVbXm9puTP95NFNTpmM64xWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURtqnDsK8bQg2Vge3oaywKF7l\nCLYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMde0DKxz8E2BeVevRgC1IlPBadYj9M8k79SPVWKW0mQCIHrDnup14c6X\npQAVfka0T3w1p+vv/O3WjA0yTRIaw/T1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAV8nLP6rNNoCPc3Je3XW6ANBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q2YTM1MDUtOTY3MS00YWUzLTkxMWMtODEyMDk5Y2E0MjlmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzM5NjhkZDktOTBjNy00\nMmJlLTkzMTctY2ExNmRkODlhZjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0Y1xEDHTnwm8HO8MW2u5ar/Pe0cNphhx8etoqBNUmur3U9HXOy/cJ8Pb3q+/4gDs\nea+Y0tcCzc3W7uRj2fzxIaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjuDcZHpajeIm68+p\nT7DyKUFrOIEwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAktil\nC9VViCRTw/OZxnLruAirNG0T8mAraB57Yfyhe7cCIFreTfPzFg+VadgdIBDWFvhk\n07sO6TPIGsA6wSjGO58C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3772", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3772` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAb5l6j2fzN1MWIpEGzc/m3rEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjMDA2YTdkLTIwN2QtNGNkNy1hM2JhLTQ5NGM5ZmMxYjQzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ4NjJhZmItNmZm\nNy00YTdmLWFhNGItNjA1MmIwMWQ4NzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElwxJERE2KhhHjLHZ4g/98u3nQX08hsWoxw75EEuuxYgHBAChYPuOGLOg85pI\nWeiU5rWnAOtrrNFB5tZZ1kls6aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULfTucwdFQVIDDgau5I2NXHu+ELowHwYDVR0j\nBBgwFoAUskDWNETOMUohVUHIs66FpCpF1Z8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAnvEGR7xGHzixMhc0aEInnMsw915JUJk7okc7gYZY3zQCIQC5z2ESTVBM\n4gv4EhYeRVguZ6tyKGz8U9BPfneJSX4Ygg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYao0fOnZt/kISuXUtCn9Q4XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzAwNmE3ZC0yMDdkLTRjZDctYTNiYS00OTRjOWZjMWI0M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZnvlq88jamb/yH8rg+SgfOLeAfjR29N5Vo/m365SXBXOi\nkWcpTeQwOqwmNO6LO9K7WHHoLaGwQvSQ90/T5glio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUskDWNETOMUohVUHIs66FpCpF\n1Z8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRtS63SSvAy9ew+/E4EOig5cJhUiKbtHlofcD0fczyVQCIQCrXyHhgBDr\nWgEs24PRaq7tv6roSCPoIYZE3jAlAHEJKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAZuNHei4NJ/yK6A02R0LVq/3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ4NjJhZmItNmZmNy00YTdmLWFhNGItNjA1MmIwMWQ4NzJkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGViNzIyNTYtZGJmZi00\nYmI4LTkzNGUtYTQzZjZlMWMwMmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrJ5DWa34bX/j3Nn3CVxAJyN1Hp+kvhlzT8mEWk8sGxQxH4X0D36F//Qzlnq0MlSJ\n4nYruHRdV/tiYl9CcHc1M6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULfTucwdFQVIDDgau\n5I2NXHu+ELowDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiByv369\nhZxxuEc0Q16XTcjs/MxfJcYG1I4NfZLsDIpKFAIgSfwW7/I9XyrDRKVxso+sWX61\nx/Om/ODp3psMYNKSZZQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3773", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3773` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAabRxF14IowRN81Y9bpFYpj1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlMDQyN2Q1LWFiNWItNGNjNS04MzkyLWNkN2I3YzY5NWEzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY4ZTc3YjMtYjJk\nZS00ODkxLTk2NWUtZWJjYTMwYmY3OWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsYqEJK91QtMeenQ3kOWg7SAmGhAXADkOUPCqX7i9Ltu5FxclCUjBag7ClHhr\n6e0F3fmVXvmikfdq2A/DtNarTaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo4GPwiW84K5urlsPdfvitoTnt6MwHwYDVR0j\nBBgwFoAUMyrFBTCHpV6kQKd8uSLPPExVT/EwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAdErk/P++Y4yHMJRAa5gdXZQn4k2GXHuZ9Ax+oellz\nqAIgfNGqBQVzbaw5f0wDEN5E0hXOFhNflXRZ6mZx6MK7TZw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARA+W5pGH3LR0DCe8nwTt3NHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTA0MjdkNS1hYjViLTRjYzUtODM5Mi1jZDdiN2M2OTVhMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0Qh08HFszQUmmoa8rQ6rzhaZj9a41SoNEcRl+oB4+fdyY\nOGoqzCB/9iPamTIAxyP1iUzmkXIvvGQ/FxgfSrUro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMyrFBTCHpV6kQKd8uSLPPExV\nT/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRNDyF0EodPhltp9oVeeEW2BkHmUSFRcVRVPa7hgEJAACIG3XW/sLoCQz\n53822ZyFRnpuCtNANs3b41HhlqfhVDsw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAb/7i8ww6CAn8D1++i0pJJZuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY4ZTc3YjMtYjJkZS00ODkxLTk2NWUtZWJjYTMwYmY3OWEyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTkyOTNkODgtNWY1My00\nNDY3LTkzY2EtN2Y5YzNjZWI5ZDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nM+bfncUblrfEfGPdSb1P9/nwf4mpqUWW6IB4OIa1LpCC81LQ6iwlavTYJU24RPYz\neNrDi3x+JrNY6KxV7PxkEqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUo4GPwiW84K5urlsP\ndfvitoTnt6MwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBuLW6K\nok1Ddapu9eDPDu6fGGceNr/tyg6MyMefcOiIcgIhALtkC7z/9ohl/wnyf9nn74km\nvxhwKN9RsmKxZHsXH8h0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3774", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3774` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAT08ELGhe5Jy2QOHW154zwjrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0OGQ4YjNlLWY2NTYtNGQzYy1iZGNlLWExNzY4ODc2ZjI3YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmVhODkwNmUtYjdm\nNi00YmE0LTk1OTctOTI1YWYwMWFkMGMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE23K3KwlYxizr6vXfMWBhP1HD8SzUkZBqc7DTo+B4TjErKuhHm6kRwG7AJtJW\ngw7l7KiPQjVOsIcSB5GiYXF99aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsx4kLuJhaveucmtrd7ny8JUXbOowHwYDVR0j\nBBgwFoAU/2o9PQV6875DC0sEGZMV7grwAD4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBNzYXXtJwFY61HAPTUH1F25lpgrE66fjfiExm5pTcZ\nsQIgf//BgLm8BDMwMk1l8m1rQYVB9+FyPaENxPS2n6FaerM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARcaE9aj6ipYJHSPAmgg9z86MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDhkOGIzZS1mNjU2LTRkM2MtYmRjZS1hMTc2ODg3NmYyN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJFGRFZ97Bvl4SduifS1WSwabKwXM1BOlfmsi0UOp80Oz9\nySheun+ENDO0o4OF4L95AK3f/7EzjcqHbO/OavR1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/2o9PQV6875DC0sEGZMV7grw\nAD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMHzBCjK53iasUcFdNxHuDHqAMrlTKIjPff6C7JCeExVAiBpY1k8+/3I\nLEkb8UzJbt14Z/uTU/37xNkqY/op4R0jCg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYiiTq0RZXOcZ+nfpqxLLoE0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmVhODkwNmUtYjdmNi00YmE0LTk1OTctOTI1YWYwMWFkMGMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmQ2YmEyZmItYTBjYi00\nZDRiLWI2NjQtZDE1MWZiNmI5ZGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nd0OmV3yXdMM1uKoA8vQ6GSmhwh9NOVtHb+8Lt6Y2nNRfMnDtnxKZaFzvP1GICuDo\n1gGzZMSKZMWfYfMMPTQ+AqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsx4kLuJhaveucmtr\nd7ny8JUXbOowDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiATUqis\nHNIwlrAFCFdJoSX2USn71n/zoWfv5N5J4x75tAIgCVTpsxtOAq/WyHafM3R9KqG7\n79Qx/CQeWC6d0YLnnJY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3775", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3775` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAU8L8iU7rjsSz4oq5QsCIR7cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4YTEzOTdiLThmOTctNDM1MS04Y2UxLWYxODg4YmY2OTZjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmJmZTE0ZDktNDY4\nMy00ZjUyLWJiOTItNTI2NGMyZGNiMDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOqmxKZP3DK13RrjkIAadZBe/570k86iEqY6iL9DgRtLndbARY5FZhQqtg3uK\nFPIKylcYa972WhFX2ZtMi/GJgaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQU0YvWQBUAqDezg8FrfXDUeIuF8wHwYDVR0j\nBBgwFoAUN0gjPTBCS7IUd0anQgQVNBwSh4AwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAbj2C7x5JVFHDzPORVyqZsQylSgcAsjYSiVtb7FtrhOgIgI+mN\nRYTaIbhXlNENfPlqoLeIZW9dvQSvquihKdEbtBU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAekii69WPzoTaZ2YciO6yE3GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGExMzk3Yi04Zjk3LTQzNTEtOGNlMS1mMTg4OGJmNjk2YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+NDQb5lP4JYCNpT+7BKUsaDYSsVVYlvd+3L7TO43Ay2KR\nuDd/wzYIBWnaw4DFoJ2IJ5dgc2SxUP4RTqB1p9E9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN0gjPTBCS7IUd0anQgQVNBwS\nh4AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYwGwd4jVNVN9Bl1iUGW3ma+BBhEIpNr4uLr+LRmaM4gCICEx8PK6f7Jo\n+tLd0Kl5iY8juxLQGJF8OBuS1yjHViE4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISARxRHFLz8vaedDvGLMOzLtdSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmJmZTE0ZDktNDY4My00ZjUyLWJiOTItNTI2NGMyZGNiMDY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzc1NDYzMDItY2I4OS00\nMGM3LTkwNmUtYjM0ZmE3YTFhMmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7oTqyEF+OS3Kw1WzuKD0KLIOy3TuoGgbAMfxMtYrwmcDfgJIGMwg4bIy1eXzzpIL\nRcdcl8/LRncIXADw+kHy2qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQU0YvWQBUAqDezg8\nFrfXDUeIuF8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA79s5\n5OUqFjrxWNWKbxRI4FP4jMlxbd/1J6ZvUkxgcHkCIQC+uxepM+0IGTxi40wQ6l4E\nzAfcFjiYm5+3klUIZRAuzg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3776", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3776` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZk7TMrAQNQBpOgE7xn2cxTmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmMzk1ODgxLWQ2ZTEtNDJkNS1iZmI4LTQ5ZDEwZDI4YTllMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjJkM2ExZGMtZWY2\nNC00OGRiLWIyNTMtYjIyZjZmYTQyZjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECzzScdaw7+R9qU9m5ie0H/wJyksjqMXo1ZbUGFyuvwUW6KGc0CRsWT0oi2QV\nAgbeQV5jx4TALElQzOOe6zg0KqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8jwDBFagQWbpxBXQTPg0G4kxg+EwHwYDVR0j\nBBgwFoAUcCM2lcglPzZalFc/k1qn+WHujx8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBtlddnregJGG6gClNo8GaVDC6QhZPWrTfO\nwSWGdIpq0QIhAMz3Fi4L1MJq9yBEI+JRWzTU9mGg4RcopUvz72PBk5pX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe5vAtZ9GXRuc7YAJoOYv//gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjM5NTg4MS1kNmUxLTQyZDUtYmZiOC00OWQxMGQyOGE5ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8OnZDAclFMom1hbW/KRpKUzP9WeLi9+S67RUuUavJxffi\ncKsxF/oMc5oqllVTf+qXotlXmt+YGgQfDjG4c76Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcCM2lcglPzZalFc/k1qn+WHu\njx8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALnzOM7NS2Wsg28Aib9BcIXSIaroGCgBLbVy9Tn5/QPBAiAoDbkXflBG\n5iL6s3Z/vB+M62EufsRu0cRQaSMZyXN6Gg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAVxLl10GsNwZZewnjddjDMTwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjJkM2ExZGMtZWY2NC00OGRiLWIyNTMtYjIyZjZmYTQyZjA2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2M5YmQyNmQtZTdhNS00\nMTgzLWJiZmEtM2M4ZTlhNjYyZTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nT34tFe0E4/8uPtuF+Zo9PNhU1+zASQBj8rS74wMS9RuFtu1BQFwFlyhYNJz6z/7h\nMgwLLu1Z4Cin0c0l6vWvOqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8jwDBFagQWbpxBXQ\nTPg0G4kxg+EwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA4Q0yV\nVk3xIzq/gK5/jFabmKDoUBh8E8DuvGhE0L1rHAIhAJcCXcg4QPLPXqqcLKiapT6v\n7c2BgE1p1MyYSB/wBNU0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3777", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3777` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAeQ7erizW8hHVwsrWk4MZFACMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0YTM5Y2IzLWQyMDgtNGFiZS1hODBjLTM3NWIwOWZkNWY3NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY0NmEwMGMtZGI1\nZi00Y2NmLTk1NzItZmFhODI2YzZjYTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA7waUhLPydTHJ6lOTm3WmLpSMq6CHDORXbNMCQJ+gBQ1wmVVvP6ygsM4Eb7w\ntNc4Q14dYxMMgPim1vwt+zy9P6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMgf22IRFloPPmqEa9OdBDUQ/wz8wHwYDVR0j\nBBgwFoAUI9PTZfHjaiUZ0kabsvy/yW59F9owSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBDkJCKWjj+CcAGCu5s0TQ8IoTx/OGphlAr\nyCqnwmT/2gIhANu0iv3htd5nZH4Bwcmx9ukEypSc1NEIxfE1HNJNJTNk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfqu06EfO3cVsstGrFK73jPMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGEzOWNiMy1kMjA4LTRhYmUtYTgwYy0zNzViMDlmZDVmNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToSF6eCHkKi2SiSFzuCj30ahrku44yN4MdHFQW/DdVdbXz\nnFRVUHTcl4ohJKkYSt0Qv1pm8tiagsJCjFpCDFTno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI9PTZfHjaiUZ0kabsvy/yW59\nF9owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMXquDTTxtP1Bk6wR6ewkaYIDA12XhHdWz+XCKXSxcJ+AiEAlPzltdqE\nyla6+V24C7cU5XxswRkizgZgAD2l/X0m+lw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAQAd2y2Itadit4iqSZZDfAoiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY0NmEwMGMtZGI1Zi00Y2NmLTk1NzItZmFhODI2YzZjYTg5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGM1NzY3MjctNWJhNy00\nOGYzLWE4M2ItNmRhMzdjZTE5YzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUjZKw466FdWrK+01j9wnpr4RyKx6ViONQRzMd6J5QDGcCrST1HDzUnb8Oyj7eEPX\nBvo9Ojawih/4qtkR8ymDAqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMgf22IRFloPPmqEa\n9OdBDUQ/wz8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAVVrMv\n2DB4BDGghs11OfgdoT/7BNRrhlAxV6FuXF7mvQIgEgqReZPD63R8Nl09pcjsFtjC\ngUK0emEt3FmoGs55DP8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3778", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3778` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAQ4LqDzRxwHz5kkHXARsCemaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3NjNjYzkyLTBjNmYtNDllMi1iOTg4LWQyZGM4NzMyMTI2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlkMmNmY2MtODMw\nNC00YmE2LWE1ZWYtODBiNTYyOWU1NTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVzp+4i1g3u5vwHvFevNhLFZwO8nDV8yPHE9ivj+xwjM7+ECDgtySvyiow0kJ\nxj3cgkf/dloXwNdtRuNiDR21L6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD4y8qvPFc4EaO7sWjmE66nA+5WowHwYDVR0j\nBBgwFoAUeo5akp99jRxGFX3w71kuzmKGq2wwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAzI9707u/vMmG\nI95iu5QMsL5J7L+LNO86StaUhIW6HIMCIQD1hXTmAT5GQAyJm8D9IkZMvs1AuuiB\nO2KzDw+N6KZoHA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ0sTBw2R6RvDECRft+AwNWKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzYzY2M5Mi0wYzZmLTQ5ZTItYjk4OC1kMmRjODczMjEyNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoJI5fTb9Ee6SSx8pm6DDC9aVZSKQDLvkzuIA1UCjyZ7CQ\ntqoRbs7miklrhs+dlAsUtWy8mTVjPC/h0/c7De9no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeo5akp99jRxGFX3w71kuzmKG\nq2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALR3AWNPAaCWWJXBYe+85NrXrWkv0bn5SUKzqwrcrD6LAiBzdtHLr9NN\nNeSpB9k/Rv6wl4P4YF7mNrQYwCPkwaS/Gw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAXZhIBiyTnT81dWJfP0wW5kcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlkMmNmY2MtODMwNC00YmE2LWE1ZWYtODBiNTYyOWU1NTIyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTBiMDI0YWQtMmQyMC00\nNDc3LTg5NWMtZGU3NWZiMmE3NTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngBAei8l5mzq+QYhP2W6L/VHT2fGmcqES8vrRuSAD3F45J+XgHA9ABpGa9gxa5Rms\nC4jejrqfmB/fbvpSZEXueKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUD4y8qvPFc4EaO7sW\njmE66nA+5WowDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEApAGU\nXoheWB1NvcH3yP9NgllyZ69bt6kyFCVhXBieS/ECIQCwJCcEPmzXox4n1CUeNF0e\nULZ8gZSwYepsIUAyiriU/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3779", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3779` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYSKZ4dkPZ59OVZH9htOFud0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5YjIyMDdlLTdiMTMtNGUyYi1hZTBhLTc1NzQ0MWY3MTljMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmViMjJkODQtNWU5\nYi00NDc3LTg2N2EtYzZhMGMzYmVlODMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6BaO8KTSFZ0VoQT2Y+s/Yd28F9evQbhCad83pDenHwIriIx2Blj1JUddZsxM\nG2HuKMkcpeJuVIaEijaFbwCGl6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZaiszj4avU5iHxIlz36UauA6o/wwHwYDVR0j\nBBgwFoAUsg7n2a0RLikVNFgWOqrNhRd0+x8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHSwr2lFrw684Rqqy9kNVQPfFKTRjAn+35/0kbfv2wWmAiEA/NbeK4wdinPh\nq0urvB663ceEPe71ivCdrPaZQJcj4uw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZdgcFTfaizYzrI5TYxc4Xq6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWIyMjA3ZS03YjEzLTRlMmItYWUwYS03NTc0NDFmNzE5YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXZEeYEqX70V4JIQTFKi7zLk/rsU6KQEr3dcZDQtLvauOm\nLnDdHwXfgR35m61VKATDKC2SxMesnqSsHpR+vE+do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsg7n2a0RLikVNFgWOqrNhRd0\n+x8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJnvRlRfQtroIwF5+fgd6uebPVsO6jvw5wDyXFPuL3uACIASIicFOAcZA\nzVaf7J/8FDEVAd9XtfyRbMXraPlGD0vq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAUEC5b6MtjctKuOXJxw7tKdZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmViMjJkODQtNWU5Yi00NDc3LTg2N2EtYzZhMGMzYmVlODMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2UzYWRiM2ItNTk2OS00\nMGY1LTgzMGItOTZiMjI3NTZlY2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niGJQzpn/1Famkt4+v9HiHxEM6RY2yzP1+HQaE+3cmvKxmTSX9m69arbUa8/Ay9Rn\nMthva2poY7BqGnVju1ad/qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZaiszj4avU5iHxIl\nz36UauA6o/wwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAq6ww\nJbA9yvQdc10PbB6vUP3ghT0fxUxC8dIHVDAJG5wCIQD+TW+F1WgTfC/CRYKwAAX9\ne/vsMsvj7ZINSftyMaWoSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3780", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3780` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZUd4/PTxqPlMcvHeV8xp/U2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxNDVjM2VlLTk0MjgtNDcwYS1iZjZmLTFkYzViNzE3NDkyMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZiNjBjYWUtOTMy\nNi00NDc2LWIwMmMtYzZiYWI2NWM2ZGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFUcvKJbDlnkF1IBmdz/8H8EoYyhJbtI4log5FiS8ERAiAiRnvByrERGWTOXU\nQQnCLE9IvOxfwK2ha4wLrVZTh6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Ny73LUCeb93K5QWIVDS2iQOdv0wHwYDVR0j\nBBgwFoAUTfJqTE/baTRY5Uze882rWHn6mlQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBzUYaqMOjVTA9WhQI5Wt7pN5xvGrt/2ApBghOeqSCHdAiBfw9IETncXQAaX\nt9HnCrQpelt8WQBiu3g28ovs9vMkWA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAezUUKHv/+CMCt4JXxMUQXA7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTQ1YzNlZS05NDI4LTQ3MGEtYmY2Zi0xZGM1YjcxNzQ5MjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWwhSIjBsqReEx7mFHPHK9W/57vo1+n2eR8/9YgmcP1y/H\n4/zCM73++KlOV7wuQNiFDuEcFxsGAQ/EP7BgdLMNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTfJqTE/baTRY5Uze882rWHn6\nmlQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIWb6HIFIU1iICnOZbSW8s9KAku2/7Cr0nZI6TvLS259AiEAjRDms9uc\nNGyo8f7THytO8PCYKprDa+dp0Q9/aypkDTY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAbNc5mwBiRhWcnjrwK1ecOYYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZiNjBjYWUtOTMyNi00NDc2LWIwMmMtYzZiYWI2NWM2ZGE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmNiNjE4YzUtZWYyZS00\nN2MyLTg3NWEtYjBmOWI1MTBlYjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ni595E8nY0myyA1Z76ZUhO8qBpbUBWV4LdWslcl+1RuAiT8PV1jRC+mN/JeHRO3LK\ncb/QQQetwIMCZgmvLH2/ZKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5Ny73LUCeb93K5QW\nIVDS2iQOdv0wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBPKs2O\nZ8n41tzKMrCbSJsnO0jUgR7icAyLqBRXrQOd5AIgJHK8wq2xj0asfqxezfmGzXW0\njGHZw7oHDZTMb3HTRIY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3781", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3781` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYQlWTbhl6iLfoaTlnJmkQquMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3OGY5MTI5LTdiMzgtNDJlMC1hYmRhLWNmZWI1NjEwZTNmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODMwYzVhN2MtZDRk\nNi00ODhmLTliNDEtMmM0NzZkZWEwYmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEppk1bw0fwaK3Dp0M4DeAhyMIKan4BtNQzqf799bS5puhcXsAo04XUG5EY03a\nVd3lgt1Krwzv/QF83USSSS8fcKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjBjykSdb6CQnmsfX9tjpSOodsVEwHwYDVR0j\nBBgwFoAUei6CAjA29TsRYHMB4jvxzzrFhNAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiA4MeZmYz0g7WUH4NKLfsoaxuvjSWMrqTQFxIo+9W3zAAIhALujhNKBOpbr\n//tZ9RDljpiX3UKwdxnPEl9raSePF9g8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS4EvFh9huyJAqBuShwweQ7vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzhmOTEyOS03YjM4LTQyZTAtYWJkYS1jZmViNTYxMGUzZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPKPPcaKq1jRMjkoBU7V5CEu9YiituFUqij5ZeXItMC+/b\nHCK5/xZW1a9qHCoHNquBI7POJSqiX7zty6umvPSfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUei6CAjA29TsRYHMB4jvxzzrF\nhNAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANVBnS5H7Uqt8unhX+8FBr2pJJitovaN0FGQo9TVgpOpAiALg2CC7lM6\n3WxCXRF0s/tI2RP065atssC+AsMgSa7CHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISATMYIzm2JSukIBu26Ffe34RyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODMwYzVhN2MtZDRkNi00ODhmLTliNDEtMmM0NzZkZWEwYmM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTU5MzAxOWYtMDMwMS00\nYTRiLTgzMTQtMmY0NWU4OTllMjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1X82218VT9hHT6rHDyNxETD1k8V8Dm7+IMEnFKR9AoB6w/Kd6hgdzHZfGyUd08NN\n1sdRoCJUge5RC/TvKVXUR6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjBjykSdb6CQnmsfX\n9tjpSOodsVEwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA8rRY\n4/27ujLFnwG2rBQ9TsCgVfGQl6Qk6q9vWyha/GcCIQDs0hbfUMr07iYZ0nSC93z4\nYCi2siO7NwJ7v9GtMx52qA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3782", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3782` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAbvNXsRguKsjFwr46D8Dcy9vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4NTM0MDRjLTI1YjItNDIyMC04OGNjLWIwYzhlZTUyN2VjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYzM2YwM2UtOTM2\nMi00MWEyLTllZTAtZWIxOGZlNGVhNGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAxNC1nKJriA/YMAvpNpL4Pje2AOQ9rwCRYj17P8bm6NtNH2F/7TFrEQbUbok\nyMUNhSikaLS3Ft1UDZdETXTa/qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaUS7h2gMCBlD4C68e3Lld2NdR6UwHwYDVR0j\nBBgwFoAUNIVmw7l2l4w/ajh3aNeJsv9wF8cwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBC6vwl9vEkdmnLmye7FYHuwjC3VOcreBmGRvuV/WHm\nvQIgftHFfaNKry430PVvdex/HqyanQosWYxdNfeJB0S51f8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe6m0mJUZ05thfLcVyOx+JRnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODUzNDA0Yy0yNWIyLTQyMjAtODhjYy1iMGM4ZWU1MjdlY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQHUx9E/ZkXsOVHs6zJ+oFDnVvHjZOJbAakQLBJxz3P/0O\n7P0WROsRUCvKOpKlhwvH1p1qKab7lgIR1/CN6bGJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNIVmw7l2l4w/ajh3aNeJsv9w\nF8cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLaEkhLIu8o6V0WyIkj+1iVf6Sa6xzo+xXdX9ccPJbZMCIQDthBLGyMB3\nZsmlyKshBbTp1uK6dgSrmoceiE3PWqz+EQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAepiwlMxUupaOOTbr6fkjcGoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYzM2YwM2UtOTM2Mi00MWEyLTllZTAtZWIxOGZlNGVhNGZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGU1NDRkMjQtY2U3My00\nMjY1LWIyMjYtMzRmN2UyZWE2MjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMDRiaQ1dHVEW4phmjUGIy49e/0kK1OraQTPuPuZRtcx5RDn6pjRonujivlK3C0zP\naSooGZPtQWgrPKFCZuVwXqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaUS7h2gMCBlD4C68\ne3Lld2NdR6UwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAov54\nLQsStBkqoK5fmOnJ9AGJX/cFMs+ddBL44UX5ZxsCIQDmf3j/X9u/FbLdNXGXqyM/\nxNxLwcBSsEQBM/S11NeVtQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3783", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3783` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAV6j8HGtF9zbuNAa9au5XT+XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwZDhiZTg2LTFhYmQtNDk3ZS1iMmNiLTMwNDY1ZDQxZDJkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI1NjM4OWItZTE4\nNC00Y2JkLWE0YTAtYTU0NWZjZGEzNzQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1a+2JqII6Xx9pIYZqEicE0gkAQn60f9kczjk79BaIQRKOgvtriUalgwF0cSB\nFWEE6Sq5Om73Xh4HrQBUwdoheqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvUgGmztcPGXw/UdFfWWjQ+u8EoUwHwYDVR0j\nBBgwFoAUu1vaRuRE1AbW0+gjn2ECm2Io7n8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAPyzKZOcQdC/rZ3GWlk3wBXQaDHwh4me2nIYj3+Lti\nmAIhAMOr09Mvnslx6m+2a3qLDGC2spkuqTA+G0JlWM4GW45x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVr4qm/eCi0ueGYXWpfoUrcUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGQ4YmU4Ni0xYWJkLTQ5N2UtYjJjYi0zMDQ2NWQ0MWQyZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1Y8uQCsA9qHhcoXeA0KGklyiLyFM2WIrfUwxT7hv3YLZb\nEPKsRWb4lhxeRwr9sU27TsPvz8vC3McDMh3+i0b/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu1vaRuRE1AbW0+gjn2ECm2Io\n7n8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWpRgDG9/0NHetfcdSkaSHq2aBIEv4OYudyVMwWTTIqMCIQCEouzlPl5B\n0yp70u79bqyfKvKVbuk6o6jemGdFMZOuZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAaNqntDPf4JWMNxy2RLUuGtBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI1NjM4OWItZTE4NC00Y2JkLWE0YTAtYTU0NWZjZGEzNzQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTkxNTE4MGUtZWViMC00\nODBjLTkyZjEtY2U0NDQ4NjQyZTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWYXftfmNOhI5w0Mac+PCu+IWEAl+jYt1sg5S5LMiJXUdKXBXC7pgzLq5kb6zOTdA\ngglpym8UMphSQoMf6JxFNqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvUgGmztcPGXw/UdF\nfWWjQ+u8EoUwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAh6VlN\nS1smyJFjbOEBV/fjVmx7ZnN3dSeUyA1yF6OAFgIgF5IQXrezAj3O2jlF5L1+OJ+W\nTMBAsPAgjNV5E6R0rwg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3784", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3784` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZMUXAt+46xJ1l6IrlQVa6PlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwODdiZTUzLTlhYTMtNDdhNS1hY2M0LWRkYzY2ZmFjZTU2YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk3YmRhOTMtMWRi\nZS00MTNkLTkwZDEtZDcxMWQ5MjY0MjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuM6GCVOQ86P3l6lStPoS3Q+BqL3k64RRCmQKFA8Ad1dDvBxVj369M68mQXH8\nKX+dz9z8ErsNcw1EGJvn0cdKJaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6zddbw1P37xKU/U2jeKGpujU2HMwHwYDVR0j\nBBgwFoAU5hPknw/Q+74GvvGEeRhrmTtoK6EwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBik33nRJVq1p/AemK3c0Qt1ZKx0H6pk/T6FRz2DS2pKwIhAOfo\nUmOItWWPpF41F56v9iEgDkFq2ssG6oUu0gb6WCLr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW0fEvfGGfvjgAoqUAN1tIlDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDg3YmU1My05YWEzLTQ3YTUtYWNjNC1kZGM2NmZhY2U1NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQu/r2siQJ7GsYPu3dZMlZtIIsyhPkdTUTw3DsUyjMJ3Xz\nYW5NO6cakT1JitYs/IkPlQk2QCZg3jAy+kZQ5v07o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5hPknw/Q+74GvvGEeRhrmTto\nK6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF/5EXE1znkez914iXL2Cui70evkUou4zw3tyAWRNuzQCICTpaUQMN/xX\nHXZpoGqOr4tfMyjtT6Hfhmk9TBueZya8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXE1sjOwE4yoUpo83u9EXSraMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk3YmRhOTMtMWRiZS00MTNkLTkwZDEtZDcxMWQ5MjY0MjBlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmEyZTI1YzYtNzY5OS00\nNjMwLWJiOTQtNzAwODdjYmZlMjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3EH4R+DH52z7a58fUecjnkx7Em+T/nD7c1oR8SRHUlQRiAXOmj4ZNtkEh4NZRpeS\nnlYl6d62BozMoWal3Qelh6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6zddbw1P37xKU/U2\njeKGpujU2HMwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEApYM1\nairr9pq1951RYLxr6hki/hjE/knN8bvTN29/BHkCIAXKKfNfyJ2r8QMtfSksiTSe\n49bWhmXhHxbEa3KGsJGM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3785", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3785` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAaqcawT+fMDSFLjOaKNprQN8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkZmJjMGMzLWY0MTItNGRkNi1iMTk1LTdhMTM0OWQ5NGQxYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZkNWU5NjYtYmQy\nMy00NjdkLThjMjYtM2VkYmE4M2YxOGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE27e7FqlHsXpjyqMC5xWYL6DwzirrK8vdUmW1wmy2MCZQHZ8p4atVnJrZTrdG\n4NRtimRycEfYxUjKYat6SXh63qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl5j51SmJUeoOwB578e6m3EF/tR8wHwYDVR0j\nBBgwFoAUQZQ9j7ohvPgBBEovmqxAlxQbSFcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAikwkvZS9l73MtjRQ/UB3dSfSofVmYbNS\nSiAiriAL/fQCIE+RWo3bhb4NuDozOZzKUSnAXQ+8xKRDCR+FXLOAAQ2C\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWsIy3vcRfW7V9C94SETAi12MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZGZiYzBjMy1mNDEyLTRkZDYtYjE5NS03YTEzNDlkOTRkMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmfcLw/Tq+zPSZ1gvishWVhiXDXxEUWIE/ajIW21h3YtKD\n0yPBG6AcPiFLIKbHIB3i5f0XcIf2PuMF9BuuRkpao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQZQ9j7ohvPgBBEovmqxAlxQb\nSFcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK9D8mHxe5g5OXFTyRQLRlGIAMSWSf2FWGccLGKfbbupAiAyD6xbtbHU\nabFhrsUqIoqW0L4KgllTMrfNjn3TKazKkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAQZ15p1yTkCpiIwU1jPysPdeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZkNWU5NjYtYmQyMy00NjdkLThjMjYtM2VkYmE4M2YxOGNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWQzOWU3NWYtZWZhYS00\nYzA2LTk3OGEtNTZjY2MxNmU2ZjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhCwZO9+xQXR0C5kF56vD9euVuR6hsDR8iLSZmRrR7LsGYcS7ZwbrGoHzvwaqC5uC\ngkNkVOQi1Iw32BmvcEFHX6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUl5j51SmJUeoOwB57\n8e6m3EF/tR8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAhvgSR\nqSo/xjIph76Fpp/NTEXQuLw29sUhRbIOj0WVMwIgb5uBreMMQOiFq8gQXwf43tR1\ndl2PaluCNwqGT7JOpyc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3786", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3786` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAcEpnsjuNoNY0qMibsGqg6F9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmNWUzMTMxLTJmMmEtNDE5ZC1hYzE3LTE5NGZkYjI3N2VlZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FlMzM1NDEtNmE2\nZi00MzRiLWEwYjctNGE5YzdiNzg0ZTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3NzizlaVi1sELHeNgaIIGyd7bi2/T1q+BJPGvmPxK/q4f57lTyQK/BhYr4oV\nN2MfhQjXmg75T8trtKLbmENr0KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+mskIWG7qCotxaVFy1zsRtT/eZ4wHwYDVR0j\nBBgwFoAUFsu+7gQpqL8gZHQs0OE1a+XKXCwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAZ3V74s/lAD8uWcPiKba03nMTjP36JUObz\nZY6u3snnLAIgDPDAts+aAOGMrDrLRgjFlIBtbayCANiSW+zVEauenOo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbSbmEJaOfEtJeLnumH/bQ5wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjVlMzEzMS0yZjJhLTQxOWQtYWMxNy0xOTRmZGIyNzdlZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIKFd7/ImgJAphAT7TGiW6YpOOUEJZC9qDbGR7mEQowgNm\nV8Gn4tEJyp6cD4ehTUbKNskmSWf6siUUcqHs18Aqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFsu+7gQpqL8gZHQs0OE1a+XK\nXCwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK9vWO+WxSC+pFNN1thiNWmKWaUB3YJFgxAAxS9yMW0aAiEA0AxekavT\nwaC0viQ+zonqaqZgZsRKpCwDMAb3leStOBo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAQpTAbTsIb8XiL8FkvN0XjTqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FlMzM1NDEtNmE2Zi00MzRiLWEwYjctNGE5YzdiNzg0ZTVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmIzOGIyN2MtMzMwZi00\nNjA0LTgyODgtMTJiODc0Nzc4MzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJztAIgwtqVu1obAMsebiAxIccl5cvcdPrrTAD/EcCz1VQD7LLusahGm61XUlsxOa\nj9L2xUFWP2fZoC5CLNHpyaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+mskIWG7qCotxaVF\ny1zsRtT/eZ4wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAh9op\n+OjXk5YwuRhcTq7liuMmfYNgbpvo8WjTjzu89FACIH6KkPoPKG2d6WThru/OIWTa\nlmFgjz5kHoS8LbIb6GMR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3787", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3787` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAVhEtYWyRJ4A1t4hlq4nqG86MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZWIzYmUwLTM2MDEtNDI3MS1iNzQ2LWZiZTlhMGIxZWMyYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I4MTE5NTgtNWQw\nMS00NTE0LTllNDYtYjkyY2JmYzhkYTI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkYxakaFN1QXd76PjIHzdJICp+631Vd3OsaaOVScjrwnPZ6S6P9IqcxCexjZU\nJX10X3Sri/ffM0lQP/AJxUp4Z6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULjwizYGF6Gx9/HnmoB8N4g8Ns4gwHwYDVR0j\nBBgwFoAUaPpjaDzF7r717AR283+CdmjdHEEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCcOZawkG+ndmWYgVtl7oPDK83g\nPlNVMGJMCOVWRaktQwIhAPmzTDY2ZbFpJEkY9BvloFtr+ZNNz3hGbKbjvVRkn1Gc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYipC7u/12R+A3ew0Dyhtx3kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmViM2JlMC0zNjAxLTQyNzEtYjc0Ni1mYmU5YTBiMWVjMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbad9ikTnU6myBUXv+DH9haZyMU4PC83e9WgpeU8KAtKub\nZzSHZ2piIIJT8C+o+hs/okEDNMEXX4MWi2Vq70u4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaPpjaDzF7r717AR283+Cdmjd\nHEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL802PDJRJrf3sXGR3E3TMDbfV+Zt/+17hvW0T+83a20AiA+i59pa8s3\nGe+8Mjs+bH67jHT2jGyrzn/K1Yo9M6zwww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASPAi+LljX8jDjF6WZrvE0o1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I4MTE5NTgtNWQwMS00NTE0LTllNDYtYjkyY2JmYzhkYTI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTljODMxNWItNjc3Yi00\nZTEyLTk2ZWUtMDJlYjY2NzA4OTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNTW+iu66zrMjX4uPXGlOnkEgKT0aRp/dgbTGk6ibmUSZe0488m/6p1cLdRkJmiF5\nhd4KsBbvpiHv/1CT4K3W5qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULjwizYGF6Gx9/Hnm\noB8N4g8Ns4gwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAqUdUQ\n82KYRqi0cLnJ2VqNoEpsUE3LX1T0K/bxr/UQhgIhALD2jzVR9BubgpMlYFlvvcye\nFc/ZEhwUW7FbXOqVsz+P\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3788", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3788` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAXLT6xCW9wLCxRlL1Hru4pHEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NmYzN2NiLWQyMzgtNDk5Ny04YTA4LTk4MmY4MjFmZWIzYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVjM2ExMWEtMTA1\nNy00MTJiLWExN2QtNTE0YTNkODM4MWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE11xXAYEGl1sfdaew364Eq0CrFx3AvPOZUx4eTfZZUlOKiloBaNUruVFhQ5bG\nHgySKpddOsMttEAesySibRSx1aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJbUaYODDgUKA3D0v6cVagvYg9DAwHwYDVR0j\nBBgwFoAUZF6fqSc+gqD/gCKaZPRgWwKNxj8wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAK5BE3Ub\n67kfcrdEj0OQB3DxHfmJ9t/Y0qU62pM3NaHPAiA9x0tGuaWboVv6S/V5VPuajrO2\nVXm8cR01mJSwyafzXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUNuQkc0IF0I/88bpGOnHakHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODZmMzdjYi1kMjM4LTQ5OTctOGEwOC05ODJmODIxZmViM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQghqYW0YyEliZR29hSvBruDiomD+q+S8bdXhTtCcDtlr4S\nzIm6OSbD0tgi3IoMZzT7IP1R4RqWHLft4/rs6bJOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZF6fqSc+gqD/gCKaZPRgWwKN\nxj8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIQly9uAydHz4R/CK+jhCb3DEadtp6cxHTOerXbqZMZZAiAWU96INfPM\nSPb4ctgp1x3kU/DWCY2HR8iZ2fKLhnIGVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYd5r8XOK2v9BFPnuTZOFi4RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVjM2ExMWEtMTA1Ny00MTJiLWExN2QtNTE0YTNkODM4MWI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzBjMDU1ODItYTZlYy00\nZmEzLTgzM2UtMGNlMjUxZTljNWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nowQZWz7L6jmh915d+IhMp6zRnXl3YYA/0w0c9XqhdQxJBMPxJIF4bxI3Gul3zyyf\nzogIi1vjd1cMCFIaHhWWiaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJbUaYODDgUKA3D0v\n6cVagvYg9DAwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAoclD\nk/NzSDsvVT5y2WrSM+8+gvC+HrwajAnpEc/s4ksCIFGPJdGAwY7ZvxrioMB4i02m\nC0PNTaOec7qVwnMgPYwK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3789", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3789` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAW62t61qrAONGzC39X7lS8cDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzNDg4YTEzLWMwOGItNGQyYy1hM2E5LTJmNzBkZGI5NTViYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M3NDg2OGYtYTdl\nOC00ZTA2LWI4MDYtMTEzMDY0YzE1YzRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3A1ZV9xazxuwPsQU+E4nhsJJL3dks6SsrWkVgoC4F5JtAwgX4p09jLPMJ9mC\noeBdyTcBDhpWr9U9kbZ/hCGqZaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Z51u9OewAAOQM3yROKbS2xXliAwHwYDVR0j\nBBgwFoAUN8+JC9U02IMnhA+kq/3BckC2/t0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhALi63EYY\neLumcLQyM3iMQfAcmHiW7ld37iqrgQ4Nv0DBAiEA9t0Dv9ANkzVnZgzQxB6t72ef\nufWty2z4ipCuz8B8CD4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQT2XsHlb3vaJz1FHkkoiMMCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzQ4OGExMy1jMDhiLTRkMmMtYTNhOS0yZjcwZGRiOTU1YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMKy/evTDu8sizr5E5lHXd75pAY9e0SNGZEWG6bvRh9ceU\nYQDnnKXORxTrKaAvVhFUrQl2iRiScrrTiduwSHUko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN8+JC9U02IMnhA+kq/3BckC2\n/t0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIqckmxpvXSgP/UagUTiNI3YjtJ9cALlIUk8z4L+q24aAiBlil180e4M\nlvvupzWB6VOSbQFCt82Bu7oIrc1qaW/mYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAUkdNsYAg2UygSn4oxAiuw6AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M3NDg2OGYtYTdlOC00ZTA2LWI4MDYtMTEzMDY0YzE1YzRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWQ5NTgyYmItMDMzNS00\nOWEwLTg5YjUtZmQxZWMxZGE1Zjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrzPW/UgwlHXI/XrE2Msviss3HzGqv1sr1Zd2apa3HD4eDVxYDO5j5VWNKZtclpYK\nSKDLoZUWy+vK7yZ7lCc4OKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/Z51u9OewAAOQM3y\nROKbS2xXliAwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBmLOvU\nKwu/fSu0p0BxERDyWk/EIKndyw7j2oJbS7dmnwIgErdnmsgoDxChKg9JyUop6QpK\nlxETPhoZn1N9YDc/1q8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3790", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3790` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAaTCtHz4aSswPz+3injznds5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNmU1OWIwLTc4NmYtNDY4MC04YzE2LWQ5OGJhODE4OGVhNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTgxMDdlYTItYzcw\nZC00MjYyLTlmMDItZjQ2YWRjZjA5NGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQBUvMiAD1fCxzt4486pVl+0Taxs8xLbq/6XwyMHvZ+a7r3DENp/289BWv5/Y\nhpXUqzX0sdAMbzQ3KBxWK32Ay6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvAHdrHZgxcQrcCFkDnv9nIAJdEQwHwYDVR0j\nBBgwFoAUvdFKHWm8tctZlRFhV4YlqP32qIMwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICljmmEU\nj313FDjSc/Vlqtmi4bbyiXiU4++4UzZm+NNlAiBkCNzBHP1KThqtE0rN9p/MXGpi\nk+IMIKt/YDWE2qyKXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfsvTX5DZpO/BqkXkm4iEqWrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjZlNTliMC03ODZmLTQ2ODAtOGMxNi1kOThiYTgxODhlYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNKn3ehrM7qC9xjpoQQm2Ll7z7WrPFOnIEOwqpzhmY0F7I\nYzsXUrrmlIIHcc9DC9uFqrcv4biI3joRXZjyN3F6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvdFKHWm8tctZlRFhV4YlqP32\nqIMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMPwCuAJrsq/5v6hKygE5Z9iB/yXjIHdw4kRtINhs3hDAiAmYo+3ohBE\nmEswgqpFSQMY67i+n9aSh82Z7smHniG+eA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAbMa1ug6dxH9jObKTzMFiQZ7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTgxMDdlYTItYzcwZC00MjYyLTlmMDItZjQ2YWRjZjA5NGVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzRjZDAxNWUtNTNmOC00\nNTMyLWExOGItYWM5MWY1NGI1YjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nh66LPHY178DrttKDNAFheXAdj39MnDRhNJTydlF2/0YUJC4qcJevAZ9+odz6Dzhl\nesV0X10znP0gHx1boe/2dqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvAHdrHZgxcQrcCFk\nDnv9nIAJdEQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBIE8os\nL9G5ZjshcN40cCk0hbaRKluK8xtNqMlEFk8SdgIgWloh6Ajx/93PM5lKEUkTL9tQ\nRMVcjK8UARdnlDVuiGQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3791", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3791` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAScrKD2p4aAhCe/a8c5jETwWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZTBhMTc1LTA5MTktNDYwMi1hOTRhLTU1NWE3YWViOWE1MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk4MTgyZjAtZjBi\nMS00YWU2LTgzNTUtNzU5ZjQxY2Y3Y2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+TtiUuI6542cfypivPCXD9bGIvXlQv7sCHelBLt91sZpOsWXM06ryWexERrE\nBZFM5uRrCkeTecMa5eMXM3a9LKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZiznA413wzstnuB2f7XX7aDaqyUwHwYDVR0j\nBBgwFoAUnoUd+jSu0WhBCn0cObo50gTLKCIwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIA/6zckw8/3QrBqb/0+rGS8+sKDtAL36Yg+UIXRtNFeqAiAgBZU/S4+1\n2OmDXsbt3JDVeYlOrEGoqSrpfZ2btDhGaw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXbO/K9nZfnftCtSbhSGgXkUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGUwYTE3NS0wOTE5LTQ2MDItYTk0YS01NTVhN2FlYjlhNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKCOBMAn2DKOJI8ZHgT+BuPGeE+Tzo0hUxxlIi/Oliyf+d\nWPQGjgOFBEslYnwJgxaME4xkZADMaObW81I/0npTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnoUd+jSu0WhBCn0cObo50gTL\nKCIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOttfvN4zIRtK4KTuBbkngWkzy0vQBG14wfyZz+WWaSPAiA10GFOhor1\nd2Dsqc4XLGfp5l5BE/v0cc/ML+bn2UT0eg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAWk0L+8bY/uFcErKax7bIS09MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk4MTgyZjAtZjBiMS00YWU2LTgzNTUtNzU5ZjQxY2Y3Y2Y5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDIwZDVmN2MtMDBlYy00\nN2U2LWFjNWMtNTI1MmFlZjljNTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nP6S8i22PWMnkBrgBeVVGMZGQezWJX5uwkldeLnj/vd+OeJ/I0pAM3+8c2BAol5Si\nFB7my0RGGTAzgCAXlUxl/6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZiznA413wzstnuB2\nf7XX7aDaqyUwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiATDwLQ\nQ4I3kWPOnE3+6UsZAalcVzJ7UptMuJb/2xPIigIgR+d+X9q7E1DzjJ7gfmizfeCY\nwoHTB3G1ubJFRaVBLX8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3792", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3792` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAXkeE4OPEdTxTYruXdZAjkXwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3MzU5YTcyLTU0ZjYtNDY1My1iYjhlLTAxMDdlMDE0ZmY3NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGZiNmEzMzEtZWUz\nYy00NTIzLTkzYzktYjk4MmUyZTEwY2ZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVkC8z3F0JfDQ6mNqaKLWPp6jwsMGRg26RECuNzJMwzdp8AvEqzE81QPsbzZ3\nZO77SAJTub1XaEhJSSkeSbGbsqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzhbwnlBZdNVlk+7p/5G4vCPKsXgwHwYDVR0j\nBBgwFoAUKmkXQ3YCniP7oK+C5MNExEQCYhEwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDbm2tIQ64u+AfzrUYh9USopgvwzs1DH3+vN76s9JxANwIgL4ddql6r\nTFi6m3HmIFjaoNmPI5FkwZKt2FwGYIyEk3k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASKAJGusYWAwz6ewtySEOhf3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzM1OWE3Mi01NGY2LTQ2NTMtYmI4ZS0wMTA3ZTAxNGZmNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtezL6kUyw6tYBFIrMzy2T8ynO0QG23WvslGBAvRlpTHT+\nC+vEFY7H1+mOr/CIIl9rii02C0LZD/zoRgn3zXqho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKmkXQ3YCniP7oK+C5MNExEQC\nYhEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgT7Xonn8IPMsI/pL+lrmXM3DiF/vkdZQgD0utFx/T7s8CIQDdTz5WQI4k\nb9QeC2JlR82osEuAJssKErNT2CJ60OwMbg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAU/3BcOSm3PWoMSVSFZ/i1QdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGZiNmEzMzEtZWUzYy00NTIzLTkzYzktYjk4MmUyZTEwY2ZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjkzMDU0ZDItOWZhNy00\nYzdjLWFiYjYtZTU2N2FhYjNmNjcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJBzaISKYZaT5YopnO0khxOYdBGqStdsDNJjcqubYpTXAv5JvlNGqdunIXk21yT6I\npRmjVX67x96qp5bYEJrJ06NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzhbwnlBZdNVlk+7p\n/5G4vCPKsXgwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAjwnY\n0KANnP9aSgfiVV1l4Fg0VqSnnu6kUguoQvHFcu0CIC3Jc3G6HQOKydvXd8yYbVeu\nEVsorRXZWEens/MdrGLM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3793", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3793` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAaeD1gDR+LYT3L2jCrYikYWeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyMGEzYjk4LWIyYzAtNDA0ZS05MjYxLWRjMTk0YWQwMGE4NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTlmZDNkMDItZDMz\nZi00YTExLTg4YjItNmMyMmM0N2U1YmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvTcQhd/UDcjxAWRaEf3S12EgB+vGaCKb1SKP5RD0aLuPavga9cnd9kABxqqX\naGQpQo8zEntnKN+7Tgi8dOnEX6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZMaqQBD1n6AOMsE4li+MRKQ3tx8wHwYDVR0j\nBBgwFoAU+HhIX/HXywxjrwsWOqF4SnyjmxcwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDlR6pIh/9sbTNqoAGRUpOF+h5D9FwSiJlx9RxzEHyegAIgcXP4su3GbUq5Ljwn\n8/lm0PirRLYwlDMA3hJNxJMzelI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb7yP5+i0GOYYgZK5/tQ3zUQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjBhM2I5OC1iMmMwLTQwNGUtOTI2MS1kYzE5NGFkMDBhODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjWE/x8+TTLpgIpVjjx9Bfy3fV7H5YjkYx6KzS9Cp0x7Go\nZor6deAvPi3kQxHA39VAmC+7KJKKr5SpRUyDbLL6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+HhIX/HXywxjrwsWOqF4Snyj\nmxcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO/8fHJ5nUWTuvnBxo/BKixQp019RhXl9aj4VLm1cRzSAiAxPoHiws88\nZ2wch4NQI+WQAfEjMBJY/pRkyfQxj3EhtA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAZ9Z84hv9HOnkZSJsy7+sZYAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTlmZDNkMDItZDMzZi00YTExLTg4YjItNmMyMmM0N2U1YmU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWQ4ZmUyMTEtNmE3NS00\nMTVkLWI0MTYtNTEwYTM4YzU1ZWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlYfwv8d0mkOMUpIqcN2yxNidt0PG7Q/8B6q8wwV83bXEM7nK4oU8oErt2RpITy0+\nPfOGC6ikK57dyQnvgx2t26NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZMaqQBD1n6AOMsE4\nli+MRKQ3tx8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAqgAt\nGQiC9dgM5RUdtIaaoHV8E8gENtFUJd5+dI3xkjACIQDvsRPguFLHgEkIY14KtEUY\nFpKbeDpzLigqVU4MgMyEJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3794", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3794` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVEqll8USUjK2uov+S5dLBPkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwZDE1M2Y3LTI5MmEtNDA2Mi05NmM2LTNjMTU4NWQxNmVjMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjlkMjgwY2QtZTEz\nZC00MmVjLWExZDktODFhZGZlZDkzOWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgQ48z7yWb/GllHqASCnYgixaimdcBcLQI/9WAEmmfyYxmfrsBtuOIf9EEMwf\nGC/PThXDLlUQ4shcBxh+PIKdDaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxSx9dRtVkZfM1Fnszpi1Jc6U0kEwHwYDVR0j\nBBgwFoAUaUNlzvMEAk8yOJ8XhDuFO9pe/p8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIECytoTUthFeFlw8PnAdpoz1nLIVf3B1tM+3HwP/PdeCAiEA\n3LbT5BBi3xuQAc9FCjktninqWR/X34WFdhUPR+1SWaE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWnlXxWZpCsJLR+C1SrL1YpxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMGQxNTNmNy0yOTJhLTQwNjItOTZjNi0zYzE1ODVkMTZlYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe7LzeSux5205EU6tv0CRUfmXktgIk0Bu/Bu+6UOqCHn3s\nYZUwu1YFD4+7t3QnzrScNqgE8oNKYSJSn50gpDKto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaUNlzvMEAk8yOJ8XhDuFO9pe\n/p8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIjDONXrb9ArmvJ336HJzJFxAJtUKBpjoLEQS3vlNRGCAiABB2AQT6IR\n4xIthwSKlkCeEDYworWF6ShqglVqTvfvZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAeq2qbSBZr88L3iHEq48MlENMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjlkMjgwY2QtZTEzZC00MmVjLWExZDktODFhZGZlZDkzOWFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTFhNjU5ZTUtOThiYS00\nODllLWEwMmUtNmNjYzlmMzgxYTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLdzFv2IynM3d9IhvZLaNzM0VmE4rktjXktuR3ML95jtOu3OcQoZltZBt79uEwKyl\nTEF1xUDZLO0e3IL2IszPR6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxSx9dRtVkZfM1Fns\nzpi1Jc6U0kEwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA3sRt\neNs9yVK7FkUVfE85mPVc6nY5kAmW4ayLewOQHIYCIDepmD31BPbImmWcXhQKHFGy\nVBUNtPORb1JUUDF5n4ll\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3795", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3795` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAd+oXNIqBLNokMg0KBBzsxeEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlZThlOGZkLWYzMTctNDk4Mi1hOGM0LTg4NDAzNzk1MTg5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY5Mzk2NWYtOGZh\nZi00NmI3LTg1NTgtNTBkYmNiOTY1MGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmOPhzKoQEDRQEVn9qRI/T8q6jcbOnk7LYc1KwSxMCSiBINofBi1z+QMc0Xm3\n+dpiBPoLHiZaLNX71tODdC8vgqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGmhxrRfLQjDZkQ0KZZMrne4PPGMwHwYDVR0j\nBBgwFoAUYZDiLocNiscINunXTYKqP0qrD8UwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQD0ZWVI2VWqYRzXLDAPvzQeJUT+ANulR/cvNjuOMZDLTAIh\nAKnLAH308Z4GZEPHZcCRS2nFD6M1P5iI8SFGojgqDIxx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVvf322mHM3Rlv62mA5nNGvAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWU4ZThmZC1mMzE3LTQ5ODItYThjNC04ODQwMzc5NTE4OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvQrJ+o/HRP0vBJvzCND6N9pkmcRpWrHJiFKpbCIkhPQUi\ntfhuQnc2cFTdyHb6wB6JIyZTyJwcfLBy3vmsMut1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYZDiLocNiscINunXTYKqP0qr\nD8UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBJnJNqfofgMsHtZayOMEztGmOAngvkfPflvUv5XgecMCIGeXqX3oNSL3\nXQS903iampJWCC+2hO7IMagn4q08draD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAa2lXlaQIfImIOEnxVYBKI3ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY5Mzk2NWYtOGZhZi00NmI3LTg1NTgtNTBkYmNiOTY1MGJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODZjNjQ3NzEtYzhhNi00\nZDI5LWJkMjgtOTg2OTE5MTA2ZjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7OQ4zzhdN1CONR60DpehL7PlByZBzm6mbJGQmDFm6Q6EtvmrbpfySoBAresOtXYJ\nR6e8KSlqVt7GpSZq4nmyRqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGmhxrRfLQjDZkQ0K\nZZMrne4PPGMwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBt+V05\nFYjHVLVz3r653JAHxmNIfxl1sXJ31OQxhJrVwQIgIn1SPQJE563eg+7aDKcm/F8X\nbpucMleMvR9QAEmJonI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3796", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3796` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAREV5ZpddWkzNYXHREZyU9JyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMTFmN2UzLTkwZTEtNDE3NS1hNmE1LTYwMDkzMDJmNTRlZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUxMDRmOGEtNGFl\nNi00MzdhLWE4MWQtNGEwNDc1MGIyYzRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWB0HeTYt2lgSKGNPpEHTlVDVp6qPtHZgwRcVOiYFaQbkATvr1gIOKojYsCGx\nppN6+YlNY0EAQxVrWs3mRVbRQKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6MR9FqjgRfFbbkKuRN28xHQ0cqowHwYDVR0j\nBBgwFoAUNFcbHCFrRY00f5f21tChhdp6kfQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDjgY15GiVC\nojJOno15mM33mWUeA6CrLLb21NFLKXWlDgIgRAhgX81ofhuXFpXRA20vjR+KYW8u\nhonV3ryPQGhIKAY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcym+7WieCBMJQZn3rNVFoNCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjExZjdlMy05MGUxLTQxNzUtYTZhNS02MDA5MzAyZjU0ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIfmW0GV4Uz2M3aNDwrdGcvzBCFBNnh/8YQ8FcoSPcEzfO\nMitdaX/OiNfmTu4i2Xbechdh7LQ+lrw2KoePmDYmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNFcbHCFrRY00f5f21tChhdp6\nkfQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPSff3F2OuJkH/IcdCemdkdKjxRO7RTpkM9hy9clW8kLAiATRn1f6i8p\nlWYK/vAuMeGdKJFeyAX6iM/44UxidvXdUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAc6l8F2egREUq5cFUFzLDcJ4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUxMDRmOGEtNGFlNi00MzdhLWE4MWQtNGEwNDc1MGIyYzRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDQ2YTQwYTktZDQ5MS00\nYWYxLWE0YzktNzgzZmI4ZDk4YmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOp3IFpTI4/foQG7FgHJGjDvgdccLkUywb8iQrSEYo7Aoir+U2WBqufC39jADnL+G\nVX2VTpLHhc26tEKAsMqe/aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6MR9FqjgRfFbbkKu\nRN28xHQ0cqowDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAgr/h\ndBByijUtyWJuPAV6fcz3/fg2zL1km6v+Et+3gqACIEwQqNU+hHZBUl2Hqr70P2X6\ncJFR/L9tX9sj37ztnyy7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3797", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3797` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAdKYbdSEbjG8hFsHxvYOegN9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMDkxYzUxLWMxOGQtNGIxNi1hNTYzLTZkOTA1ODI2NjI2MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVmOGVhNjUtNzll\nYi00NTQ3LTg4YmItZGViNGUxODU2ZGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqQpqT6Ffz3PY4MwFgh3WewY84il7/0Hk6ol7rEefnoRWYivd/iQjiOddhBrj\nTMeEZ8C2u7jpPRgE3roVDqc9/aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBEuC44jZkOjoe65GSCQn+6TGIP8wHwYDVR0j\nBBgwFoAU0C7LFh9Bi9O5cIkpfkbMnpJ6VkEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAKVw00CYYCSqKMcOEao33SKpLAtOpoXosjauj4vU9R1JAiEA2W2vSfXZ\nCNmN74mAKlvCFTBr5ntQiAUxmhwScLAkMaI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZVZHt14APJamQo+BMCNhTHeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDA5MWM1MS1jMThkLTRiMTYtYTU2My02ZDkwNTgyNjYyNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiWSnRFwuOfnhmdu/++FXjzFlnOhb3Fz0Bso5rUPeOkooY\nvaI1CaHoRRe6qoS6gbUokd3m3c7VKOONWGOPZkquo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0C7LFh9Bi9O5cIkpfkbMnpJ6\nVkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOFS1DEthMBX/JYD3p+yhrptfHZrB6DHPJ3W9gj0CX4YAiBOKPNmXuL/\njI0uHbAD0v4ItzYFgn8nDzayNY/IW7PjCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARL4+j/O+0hgYAGeSGi9EWhyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVmOGVhNjUtNzllYi00NTQ3LTg4YmItZGViNGUxODU2ZGQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmE2Mzk1ZTgtZDFjZS00\nMDI2LWI2NzItNzIzNTYxYTlmYzRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwwhFOz7NF9i72Uj2xNk13StV0PI5GxKj4zb2Ko8ekTXx6xPReaX5QT/I3FeY8mX+\nmPC5tqoGLLN0SDsKZRmuRaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBEuC44jZkOjoe65G\nSCQn+6TGIP8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBiXvUH\nFuLJZ1KBpnRTUQMOoAj3RwYS6zFXsnUvNjm9mwIhAM2QXwqCEiFfD7y6DRvfNplJ\nUplFdH/OY2Ij7Z8bqcF/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3798", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3798` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQBru8ZRLqG9nuzY1uV1mW0uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjNGMzOGU3LTY3Y2MtNDM2Ny1iZjNkLWE3NGM2Y2JmNjJjZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmIzYmU2MzYtOWVl\nNy00YzEzLWJjZmQtNWU1OGZhMmNiYTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnPtGd02oiVR//vWAFnzJEq3yvaPxXeiRT37+Uc41mS4jFPSPr9pPEYmeUJ0h\nIawZem5cUn4vdvJTrstvbS78NqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMI0prrx502/Kyqs1LYBArz4l0pIwHwYDVR0j\nBBgwFoAUygmfpUgYhKt2a01VO+e9mcjzxUYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgJmuFRLv1GU1LSKP9ktTUxqg18c8X7A9LGzNR8y5hMjUCIQCrTf3J69TS\nfwer3j35MIY4o3rvSsJ7ON4cBS5cLialWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASXSH157gIVvOgRgeVZ65DCrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzRjMzhlNy02N2NjLTQzNjctYmYzZC1hNzRjNmNiZjYyY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqO70mRoh+/h+KTdGnnWhUy4kq/tISTjNyf5DxVb/1KKT7\negdeKxS3Oy/V3SRUQ4SfE7wtmS/gprZ7Mrq6gNWyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUygmfpUgYhKt2a01VO+e9mcjz\nxUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOLnuHLDBxk1XsxZKx3IMLhmy7YrZRucFBY9zrTtBnBRAiAeWdL9dYDE\n1O0vd3cS4HVw7g7ffhOlhfqNDC4kJx005A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAf/Lb0AvoU6vlr8TxcJb7xekMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmIzYmU2MzYtOWVlNy00YzEzLWJjZmQtNWU1OGZhMmNiYTRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2I0NGQxNmMtZWQ2Zi00\nODIxLTg1ZjAtMjQzMzZlNmRiNzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngmg4kHWM5yxtABN9UnhccPD5430bPofjQHQ1+3VMzlLZDXEf2KDqjh/VJZijttKS\nyDn88IP20M+FSHohJ3CjkaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMI0prrx502/Kyqs1\nLYBArz4l0pIwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA0YAZ\n3/mu6zjwODmaaUCOoEoPOWj9DmCf/XVpIiaQ0b8CIQClECrpejr0+72iBzm8Mn8B\nUNms1RK00qNMz5At4XWQhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3799", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3799` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAcrbYy2jRuNsLt2jdGJziArWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYWEzZmUyLWI0MjktNDg0YS1iZmY1LTlhNzFiODk0Mzg0ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWNmNmNmOWQtNzhl\nZC00ZGExLWI3ODctNTNjNmUzOWEzNzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj/7bypUV35Yy41wm9fDPBD1hyx1/JjDEjApPNehXXPGySP3fJpYjY/+sxvR1\nr+Sc6EmzoirjjSVmx4ODmyvouqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsE8WBxxPk4rOZlM3lD5/WOuW9Q8wHwYDVR0j\nBBgwFoAUmxEzxty9QrYp30GyEzDzBrY3VB0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCd8vmlTitgu43smWyDxEbXzd66aE3GXnT0RpycTxm8HgIhAMlAGszg\nlvkJan1dKeGtk7ScuApn4EFeWIWfkKxZU5VB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASqejQemmgV87/oD10PfW18DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGFhM2ZlMi1iNDI5LTQ4NGEtYmZmNS05YTcxYjg5NDM4NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCuR3EbNnJY5VX4lrEwJOW5Qp0BjyqZOLIK9m8JSXzJHfu\nhpzUo05hW27fgFRyoF1t2RYjYdciV/k3WxuSWoLRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmxEzxty9QrYp30GyEzDzBrY3\nVB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK/4ZjclSiBnEupjudbadm+4aNTu4UR43nBK7r5GH6HeAiEAtaw9/hYm\ndNp8QVXaqriPU+36Wotgfkym1RrLhGcmREU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAZS9ugZbpO0VFsUdAQYV4vYqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWNmNmNmOWQtNzhlZC00ZGExLWI3ODctNTNjNmUzOWEzNzczMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWZjMWZlZjctOTdiMy00\nOTZmLTk0OWUtYTRlZTdhNDkwYzUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncb4Paeim3yzGbUl7LODSvIt2s99w8hQMYN+nNl3RwRKwKjPEaHGMjXmb4ql/9cMo\nQEH+KlN7gQs85wJoRy8KSaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsE8WBxxPk4rOZlM3\nlD5/WOuW9Q8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAnzMR\nnIgnZwJ1k6wQYeiYBHxZkqS+6eJv7usQvkzxXGYCIF8Ts4wGRzvMD/3uGhfVSywu\nMDd7KP1BiTtvPgcyNN60\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3800", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3800` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISATqeq/JqYD/U7uP/sweHi4AqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNDYzNjFlLTcxNjEtNDc2My1hNDUyLTk4NTJiMTI2YzEzMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjViNjY4YTQtY2M0\nYS00YjEwLTk4MTAtZTczNDVlNmI0MDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA3G4n176+D4LdW3occDpSXj3sRwlwmQRebpHsQS/BTcfl90AM0koLMl/9abN\n3DsWnSeZ2LAsXhdzmPiwSTTcJ6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm1f/CmmeJR+Hkxe1m3eCFW6EUqcwHwYDVR0j\nBBgwFoAUBetXC+myHu6tJSipa+eHi7CPhxowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBJF7M23sLFCN7sFmRSi1pE2jljlijnvsrbmQBDz\nIQVnAiAe3FCFZ1HK6hvaJeu0AUtC1AMeDttYlBfLIEdLkEj9Ew==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfPPNNraOrMmD7U2sp41MIbMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDQ2MzYxZS03MTYxLTQ3NjMtYTQ1Mi05ODUyYjEyNmMxMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1D/puP5qadiyYSnT4DWvQT0aYDNhhIhy1vSIQPGkvMrUA\nUvHPCDOxek2Z+LpGztTpLYChewvjP740Q4WfmyTao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBetXC+myHu6tJSipa+eHi7CP\nhxowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM70tlyPg+gEOJdfiMLl9rTSKTgkhuIgy62Mq9d8BvSDAiBO3Aa06I40\nGdKkL/hlUCILbn+03S6TbTqQQ6pma7B+GQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAUXPU8mTR9j5DkX7wH2cHVEmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjViNjY4YTQtY2M0YS00YjEwLTk4MTAtZTczNDVlNmI0MDhjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGU4ZjY4YzAtZjViOS00\nODU4LWJhNmMtZjFjMWNhNmUwMDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3UhNCDJhXfzQK/M3Byx7qvSCF+pJsN9xdLPFb1Xt7/aX5vqJKiUfmZGbyXoM5+6u\npE2tYkMqEOE/bwkfljjNu6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUm1f/CmmeJR+Hkxe1\nm3eCFW6EUqcwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAiQ2n\nZxcH9bcJhj5uGSrZZFXfiPZVPFS57r+EtrCEN1UCIQCfqUbt3DJGI3eJQ2a09Npf\nFAFL8eInu6JKd/g4Ax5AAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3801", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3801` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAS4RLaIZvLR8ton1UA9X2cOHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2YWVmYzIyLTVlMmYtNDkwMS05YTcwLTk1MzU3ZDY1NTc0MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUyMGEzYWItZjQw\nMy00ZTk4LWJlOTEtM2EwN2FlMWFiNmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENH0j9zsb5RhW1FWHYZCVrCc+CzGYl1YmkyCK2HrB9v4RrX1n+bQGQMtJ6kFs\nSqAd6lvVmDqJO6QuwXD57s7ADqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4R6IjSikVQCJSfQ1cvykwkRbAqIwHwYDVR0j\nBBgwFoAUmG0gj/jCsoPouE0Eb3FDkpN/orMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIEynRrVylQvSVxgIoiHDEAtlxgqPxRv6ezQyfpDM\naHBeAiEA93Xq+c0L9eDJVejRFkq+C21yMnoPlsv4T8JFQBxumWE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATHluIeSOEWE+06DWvfnjNVHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNmFlZmMyMi01ZTJmLTQ5MDEtOWE3MC05NTM1N2Q2NTU3NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROOoesgg3BZB7B8c/9P8mLHEJePjhj0DAu4LRo/g1fkv7e\nN+0gs7xCL+HVOsZfP3romCl2/+8yzyJy7ZZdjeiTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmG0gj/jCsoPouE0Eb3FDkpN/\norMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGpa9PHrxxnENFDkS8bISVQ/95oqgpKDpm8QLTnJtN9cCIQDyG7tcrcov\n89g2+K2G1GqOZ/iKDuxNwv7hhoEFiLXFDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAW5/SgKb4xOihBxj9XtUXEKrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUyMGEzYWItZjQwMy00ZTk4LWJlOTEtM2EwN2FlMWFiNmFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzIwMDM0M2UtMzZkZC00\nMTMyLWI2MGEtMjFkYjA2Nzc1NjJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwn8zDNS4E/xF2e4vCFrWrpeil7SmetXrXxi1RxspXn9gMpQln6KDSBXdDAVmMoCc\nJCjgNFExSZzXfTUopCSBhKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4R6IjSikVQCJSfQ1\ncvykwkRbAqIwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA9eM9\n9i8YxlnuwNJTCIBJjqaEDJc3rc46o8PL27L/9bsCIQCq6306nJD6c1iJWIewhK+W\nAwh4FQNiTVQd1BGJmw68Ow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3802", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3802` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAUlvlnspCF3uNYdnsHrUHsTrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhZWE4NTVhLTJjOGQtNDExNy04MThkLTIyYTczMDRiNGNhOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y1ZWI5YjgtMWM1\nOS00Nzg3LTllNDktZDkwMmM3OWNiZTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElQz7YL7GmMaBtlGx3Kp7UJnr72q5CJIsnGTb8TzoW1YodldlaJAb7htj7ALx\nhVsdW3eeWNtUetaoDoAjqiI8/qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvtN1jb/BMIZ+duhY/kaa0aAl4X0wHwYDVR0j\nBBgwFoAU8FXqlHNT7govQ0PuZKiODS/0PfIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIFvmr5qr3Iug9XuGdngZyQz9vIX/NFCPcy5A+AEulRgsAiA/\n8V66oivKFUgChn81E5LBC+3JlvgQsxDpbsp+tFF1TQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXM49R5pugvGj9CkF/Gy+8JzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWVhODU1YS0yYzhkLTQxMTctODE4ZC0yMmE3MzA0YjRjYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4f4DOT8MsxIccTkA5RLsr7xJWXTLc5eYyc7rMW8l7I8H3\n4DrUb9QKxRKkgSZRObDHhHeYCGH2pOoHM3gtekgJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8FXqlHNT7govQ0PuZKiODS/0\nPfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW7/UPpOWwhsOUp//HNg1ki9+eB01wRnFXDI0g15E20QCIEo1Pln0lfn2\n0Fc50NYvUZ3XuXkNpZzCT7eHOQxaFX6L\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAbDkMOFMuixodc93IrLJqpSpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y1ZWI5YjgtMWM1OS00Nzg3LTllNDktZDkwMmM3OWNiZTM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDY5ZWI0ZjUtZjg0OC00\nZjc4LWE5OTItZDIxOTkxMjU3M2RmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nnsR731tzTKyaO8EBhKg54elgHU5nUSWba21MjMbGBYFKu71uuDI6XzOTHxisEvyx\n6/HpmSvCez8OScrDp+lz8qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvtN1jb/BMIZ+duhY\n/kaa0aAl4X0wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiB3wLag\nDZAyxEwY3SClHR8A/RC/GqusMt411SzEcwwF6wIhAKJhr/lPk/WWg0AGxCr65GR7\nl2cE9aT4l8V6lZ7OJklq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3803", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3803` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAdqxQN3Et7/mUFYil5KCl8/HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4MGExNjliLTQwMWEtNGYzYS1iYzRlLTIxNjdiODFhY2FmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWEyN2FhOWMtMGJh\nYi00NjE0LWI4MDItMDk2MjdlNTI5YWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3qHGfx8M8StJYMtz+hnq/7AzR05DWF+JGGqu++zo5MK6zPghP+mUMRdrilAw\nBn9XnXucn7FA4lUTaEOp51AjhKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUelzhQtsh6DfM16d5Mdn31KZuJegwHwYDVR0j\nBBgwFoAUPpiqCZY60CmOwjxJM52W/WHYPG0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDMWXEkpYvQUQ+2aqs8dCgg16aagjtCK\ncdcl7wKgf/wIAiEAzgIfzvtf9Zqs5fciOHg7sfmcepooishcvO174CNohNY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATn4KGJ8Je453eSRmKZPMDL8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODBhMTY5Yi00MDFhLTRmM2EtYmM0ZS0yMTY3YjgxYWNhZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsRr0T6F5jsLKXc0ajhH8FKAp3BtFJiVaZKUVuTSvvFEvI\nMIx4gW27Ny0GxzxA9xD4Zfr/HP/lwgVawC6kbRYYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPpiqCZY60CmOwjxJM52W/WHY\nPG0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcJJBIqcROUBAXhf3w3O/IhBQ8a+Gl4mSl131C7pLijwCIQDuw7ViRLKT\nfOwPVQz6SfsYrQwebxtkDdSsC/sZM5ULxg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARqtY0ZDgdC4y+XkjW2osNclMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWEyN2FhOWMtMGJhYi00NjE0LWI4MDItMDk2MjdlNTI5YWVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjdiNGM3ODQtM2Y2Zi00\nZWM5LTkyOGMtOGM2OTg0NjlmMTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuLu4k8dXVMl6PbDXiysY8DgCtM3ialelBQ3rb2VFQALD4HNlauLsHrq6kLIj0xWr\nKNTsQPHLLt36GYdpnfKXVqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUelzhQtsh6DfM16d5\nMdn31KZuJegwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBZ084U\nNXuU6VaQzFaMfdjmEd17aymSADKnk353+2dkHgIhALGNpcdJ0evgLHaukDPcjr6i\nAp+7n/R9lLPqwdtzBwOU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3804", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3804` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAfFpp7xY8OMaajWjC7+b//goMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2OGYzNjk1LWI0MDAtNGQ3My1iOWZmLTFjZDYyYWI5NGFhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhkMzNiZmYtMjBm\nNy00YWU0LTg1MWUtMWU3MGIwOTBjZDg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoHNjn3dj2JOVGoqpown/YGXWXhMs3G3s3EXsd8nIU2MAyUAmGnhbjNArnacT\nUPSQxsQrtWbxRoWRf+XhPENn06OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOSIRk2dtUB9+BXh0k5eRczOloo4wHwYDVR0j\nBBgwFoAUpRi/sTLXt0XYCbKQk0gsmvX+nLwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDLic/+uw7Sb1HbldhkWl24cBiLeZhi\nfgVkp2kNXynRRwIhALNQiNuws/j4soRQTq9xGp0gESDZWTUj1lUmA+Ypmx09\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfQxs8FJw/OLEtb+h7LNodXmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjhmMzY5NS1iNDAwLTRkNzMtYjlmZi0xY2Q2MmFiOTRhYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5FuKzeIbkEKhD9vZ1KcsnnDR3Y74KVud0cKQmFUGhUtpX\n7A2HhCata0fFbElaqN123OS9uFqGYBVtwbEycToBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpRi/sTLXt0XYCbKQk0gsmvX+\nnLwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKwi1Eris1rOekFFaqEYZ+f1GbDwtndX61sK6+HrCIMPAiEAkjOln7y4\nUCYy8gaPb3lsI7UGK9gJs70Zkbhnrqxn6lo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYJW02BPpxBtuPHG2Zgyr9bQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhkMzNiZmYtMjBmNy00YWU0LTg1MWUtMWU3MGIwOTBjZDg1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODVkNDkwMzUtMDMxNS00\nNGRhLThhZDctODZjOTZhNmJkN2ZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+Bfl9tFp/ot/4xgUaqdvHhWlIOfzMQvUp/ZVmfZH5qzhqLk7hL/Uezb9L4Ytmddh\nDv6fMuAQj2jFFVq1sOranKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOSIRk2dtUB9+BXh0\nk5eRczOloo4wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBAGIhp\n6aLynRQ/Ym9xXTB4IVeDs9p5ua45sI+og2AV1gIgUYjwL5GtBRkCJ+Ors3MYm66S\nX4SNxQZbKuwUmSEEeQs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3805", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3805` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAcIer1nlzsnr4bIEELDThLhoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4MmI4NDdmLWU3OGUtNDkxMC04NGRmLTU0MjQ0MTQ0NzMzMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWMyNTE4OTEtYzI5\nNi00MTEyLTkzMzEtZmE3NDlmMTBhMGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs3Le2LmlSqkUuEXq+bSdg4MHqQcUBN25TQY8lUEWMseLho/4j4kYa+pysJJs\ncYtxJ2ftWAlq/skTOn47q6STuKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfSzOxqOitG6KpmCJQsCtsgqbTKwwHwYDVR0j\nBBgwFoAU6iYym2O3bpseMFQV6MeVAjT7r3IwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGvKuKZpIMlP\npfsdfNbtM72cUslVIGzft3xr8pT4iRI3AiANdzGgkqGrbfDhJIXORpFbSnP4zeor\nqne32AAdyI8qmA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc0I71ydptEYuluwN14vSuDLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODJiODQ3Zi1lNzhlLTQ5MTAtODRkZi01NDI0NDE0NDczMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHk/fvtr93UFFGeIbRck+9BjuYqIGhd5sRcYPf4iWOi2st\nAmJAMX0aup63OprUIlQcyFDIwdLNKPz75uIWdSYio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6iYym2O3bpseMFQV6MeVAjT7\nr3IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM13+fFm0zc04YAP35bMqA7seLUNEWfqEB6JfgU0+yGiAiEAuKgPSBNq\ns7rplP48JKdJJ8FU+nFGAIw9g8jX0yBg35o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAUFri3xVuH3ggRx3ie0Os9DSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWMyNTE4OTEtYzI5Ni00MTEyLTkzMzEtZmE3NDlmMTBhMGI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmQ4ZjU4YzAtZDc3Yy00\nMDE1LWI4MTYtZGZhMTY0MTU1NTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\no6HvBeugqI+1WiFb7qutUSvQnR8+R0Helf1YCm+OZ2CjHY+pPWXxUZWGiB5PukHJ\nAhT6iCyCRn402bdTCJyL06NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfSzOxqOitG6KpmCJ\nQsCtsgqbTKwwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBExryu\nLxIe+isFYbq6j6QuLWsMVv10WKVYC1rRNksXZwIhAP9ZHmvDXh4qIKuNPnbiTPlB\nf4vhvG2T0TYvv88/ll/X\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3806", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3806` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAelkg+K+ZTSdKpPtdP1xKOZHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZTgwYzQ0LTEzNWMtNGM3OS1iYWFjLWRjZGYzMzk2ZWRiOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQ2NWY1ZTYtNzI4\nZS00MzcwLThkYjQtYzgxMDczNDFlOGMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY215Bi7KQpExPOt9WkvoSrJeXAICDS987cFSaBtL6emWxf+gtxefeWvsOxAz\nEsWAXbYfUXe3xr2EDi/TPTSY06OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1tVr+RrnY7P5jez8zUeW5PNWRv8wHwYDVR0j\nBBgwFoAUTr6xNI5wTQCjBZbcQkPzLZO7HfowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgFYCnCvMpsj6z77XfXtqTb8wT1alpuJW5WWL4k6MU500CIH4IsExm0DkK\nzK+RWVwOvgtqjEHwAXv8AP7KBgriePwV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZoNqryDSXCse7XNXfdz/aOIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWU4MGM0NC0xMzVjLTRjNzktYmFhYy1kY2RmMzM5NmVkYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATF4DYhh3Zwha5+9GjMYLiHddQDcSmap+lsLwsFcOmUzOGV\n9sDm4yR3uyNOHBShASAKVOOVou5vsb+9eQnIPOnco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTr6xNI5wTQCjBZbcQkPzLZO7\nHfowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCVXFKdGfA7CpU1LvbSE2dTY3pcP5QYC3jxXAk9R4T7sCIBog0zlqmwR6\njlci+fpfKneBBbKW5f9cMD376TQNrE0R\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAb+6B7e50JYK5KqN5WyLYJcpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQ2NWY1ZTYtNzI4ZS00MzcwLThkYjQtYzgxMDczNDFlOGMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODRjYjA0Y2EtZDg3OC00\nYjk4LWJmM2MtMTc1ZDMxNTYzMTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrK07n5oh/5WmAmxHL2jTDXvgmI1jTQ0dBg+vwvm/iK3Iz7sbTOt8akRS6dkk6AP6\nA7HzQL/SdhJW/0ylZBH06aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1tVr+RrnY7P5jez8\nzUeW5PNWRv8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAvstY\nN5CB2OSVEE/LU0MEF/IQ1hzRAH+65eHvr+7msXICIQC0mKYJvDAmjD97LXhlIr+i\nIXY032CgESw9w58MfDsF7w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3807", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3807` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAWPSwr0ZSXImCpc8XUzgjhyIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjMTMxYTRiLTk0ZTQtNDkyOC1hNDY4LWI3YWI3YjMxNDMzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg4ODlkOTYtNzBj\nMS00Yjc2LTg0NTgtNjY4YTMxYmZmOTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXZj4AHUqa84ntDSeGgETKAKmOeChJYhbM8ETdZouGujCTqAMw0Jw0AJE0Rq4\n+sAdjVAhPv55WZiCBXLDxiP3naOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIYcc9v0SF3uHpGVp/3BIUFDwvgEwHwYDVR0j\nBBgwFoAUxytfR8nl6wkA8cN7YHXoN5E1hHMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAM4nw3ZzXNtC+WqIpzG1VeuFAzw7aNhcGbnDaRbINVe8AiEA+fua7unh\nXyhoCXZqCGnfEAda0AzX4m5z7j+uNrupVIw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQpM11oftAEKtdvWkHNqA3KqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzEzMWE0Yi05NGU0LTQ5MjgtYTQ2OC1iN2FiN2IzMTQzMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyh9qgQx1I9TXcys4MdK6nOVXTao9J3RwBe/3VxmsM9HA9\nX0kaRa8v+Y5evNMMoeLnjtFPHgCYt40xqUATSQPAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxytfR8nl6wkA8cN7YHXoN5E1\nhHMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKipKwBZ783qkcAF8OV4XzpCSJplif3miQrN7lt+JvpqAiEAjubCyBML\n+SeQarYEB+iyctETuT5hIyJcEZxR6hHSzYY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAUqwFyD38k59sTFF9tii7gMUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg4ODlkOTYtNzBjMS00Yjc2LTg0NTgtNjY4YTMxYmZmOTg0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGVkYThkZTQtNTBiNC00\nNzFiLWExNDMtNzkwMTFjZTZiNzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2gtyb87BK9SlgwYgr+4hbkRX1x5pOchQ0dKOqyklY1Eq7Uz5RwPebvzQ+LoXGg16\nhGwPGxYiuZnb/ow5iB2ArqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIYcc9v0SF3uHpGVp\n/3BIUFDwvgEwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA3pwm\nMljN5oqCTssK2Oawj0PSE3S9GfweLOKxZ550QRoCIBtiTQLnnov2bx4PnmFKydiY\nYUMZIrun6rdoptQtx5mI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3808", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3808` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAVIEgSe7ddfuz2lhrCwp/wrhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyMzAyY2FhLTJkNjAtNDAwNC1iZjgxLWU4YWEyYjkxYjgxYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMwZGE1YzgtZjcy\nZS00MGJiLWE1MjMtZDRmZGE3NTNhZTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4JPZGvqy9qGOawXxpooQc0Ggo/k6DV+3dXugk8PdvhL4bjFwHBg490IRpcrn\nKg/FOLVq2O1MMUDSXlrrCXbyPqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURFfvPvkXcctNvRe2LU83vpcRTiEwHwYDVR0j\nBBgwFoAUg59EyDBGYwpwjAxrHy+xPF/CwTIwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDsuz348bTeOT3NX3ByXULxHcQ6FrighOpKCItBEYs6AQIgDF7tJRUr\nOakBYGjqWOa0KV+V5UHV8YYwd5sqjnQ7Nv0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXK2tmZU6wZC7YgmNRt3hRtOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjMwMmNhYS0yZDYwLTQwMDQtYmY4MS1lOGFhMmI5MWI4MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzvt2CHd+iUZGG8QO2IzfJ6hWZkIdvW2TcokLqLYu6K7Wn\nqYmani5hGs0yhp0QG9IEVYkx/TV2FHEctBrVbCKoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg59EyDBGYwpwjAxrHy+xPF/C\nwTIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOCvv/r7qDjiVmKJfMcbGXc3weEQE/j7pNf9bVkOup9QCIBBpcD94SCEh\nwUA64slE2jtewp1oWa4meMHpAKVWW9Vb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAeF5KJ0uLzmRn5fBWZ+fHFjGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMwZGE1YzgtZjcyZS00MGJiLWE1MjMtZDRmZGE3NTNhZTUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTBkYzMzZjktMmJmMy00\nOGZiLTgwZjUtYzdhZTQxZTYxYWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZy3AJmM7vWwPuJguUyJ9UkXyutRBR2LHz7dCcsFYMEK4mV5YmxbDtTIFJiYGu0l5\nbSS4gLhH5gVI2RsXJwn726NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURFfvPvkXcctNvRe2\nLU83vpcRTiEwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAg0Pp\n4loHuRu9Byqof8e5rfrgaISsZk1t2mx7d5sAsw4CIQCwrg52diQljS+vcHO+acaT\nCXo62yEBX4G6j7Ofz+/o5Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3809", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3809` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISARA3DE9zltdHljisvr71/O0jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiNjAyMGRmLTE1ZjEtNGJiYy05NDU1LTY2ODYzY2JhNTYzOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgyYTg3Y2UtNzhh\nOS00ZDU2LTkxZWUtOThiN2UxNDlhZjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfbZab3zeQP4tN/Et3V2ESTckH0Xv9x7nY23KAye+j3pdSUD2et+yjxdZL/JM\nf9txKTfQl4tZGCbBFqaEXGdsfKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBdyB0b1eC9UnXiEt9Os+chzSYl8wHwYDVR0j\nBBgwFoAUlXrMBjYQTqLd5AzBmnIeGtMlr7owRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCcKqJcl7DDTPTiZAiD+8C7WyfP13DRd3Fs/I13\nEGUP6wIhAIv0l+KM16Xs42oI68/jXG0e8HCdl1tKSm5C7pVJHXuQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXcgdxs5O4Q+e4iTYY2K0fDkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjYwMjBkZi0xNWYxLTRiYmMtOTQ1NS02Njg2M2NiYTU2MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLOHELj5ACR2cJaoMUn+Z+K0WCGVCB9dEd5b85XFz2dSzg\nLSARfSQyFyB561pe041tBx15qmConunodtRjC/vJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlXrMBjYQTqLd5AzBmnIeGtMl\nr7owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMO9e+Mmju/ex3GBeXq4zRZPNsBYIS7dW1va9wobcmNfAiALDrZhqpd0\nHQqnzYDu+z6CqeFPbgUNNKb8UvtBw470ig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAchCbP7vcqAwgLhWVl2xp120MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgyYTg3Y2UtNzhhOS00ZDU2LTkxZWUtOThiN2UxNDlhZjNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTU1ZWUyY2YtZjJkOS00\nYmU4LTk1NzUtNTdkNGQ4NjU4MTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noV134qj5TBkz9fFFvSGe5aIdnhOfUROhLHwqqnPEKyN7wJcG8gPNi2LY33ydmJgL\nIPbn8PIA0o0+8BZnLcxaNaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBdyB0b1eC9UnXiEt\n9Os+chzSYl8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA5BlH\nwGmyoEff03bOLqMHVGdbqnG3GiLbOpsNQ+fGFUQCICbpml2eoiczUDf6y/PVflQ1\ntdBZJHB7lxVUqgoas63c\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3810", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3810` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAf5hl18gus6avhvHSzSsxdBrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1NDk3YWY4LWJhMzAtNDJhNS05YjJkLTA3NTQxNzc5OThlNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZhODFlZjYtYTQx\nMS00Y2ZiLTg5NjktYmU0ZGE2Nzc0NDc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0w73Z2mHsA0vZD7ldLCiF5DKrLEawt+/Oy3N6maMyamlgAdjJq3pqaH8wPt8\nLaMj099kBpSUUHufxj/sc9gfH6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2bRuAD1OHwnjoGYrzwPNhVUG2gkwHwYDVR0j\nBBgwFoAUr1n/XH3zfEr3Tyn4MaEG0hrRXKswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBT+EzvPpYY4Eth5H71Zn1HXKqgzp1XqSFTtROCV\nv4JSAiB8MlZL3aJrMIVfhO4gwEFLzBvyXjIhUpvXDWcCD/tkbg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcTQNiKxJ9E9zWrF5MgVk88tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTQ5N2FmOC1iYTMwLTQyYTUtOWIyZC0wNzU0MTc3OTk4ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQOGYEy5LlH4ElOJdTV+oJ18EyE9826rAyT+g5iGd+hm1R\niie+CDifRQ/hG5qxfQGQhzi661SwKODBb3iyXwv3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr1n/XH3zfEr3Tyn4MaEG0hrR\nXKswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTR6lHwZsGBcpSb0h2xk3GmpMtbQyoG+HvdP8ahWj9CACID5h1hFH0rCE\nc0soYp3M46RNp3hbLVmVLJbWA4w/0vSV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAU/+P4YBpAVY66X8MkDU1olGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZhODFlZjYtYTQxMS00Y2ZiLTg5NjktYmU0ZGE2Nzc0NDc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWVkNjIxZTYtZWFiOS00\nM2JjLTgyZTctZDYzZDg4ZTQyNTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntzTOkvCCsJsjufUejBqVohVnu6iDjzsbeWlWQmCJ8uOlxrh14VaROYk2mR2Rcl9+\nwQZuaDIHRlC7q9MFyyubIqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2bRuAD1OHwnjoGYr\nzwPNhVUG2gkwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA/4AT8\nB5UO0GHAVNr5ndcPUC96rDAmKcZIX2fcYX6DUwIgTIk2voCWPVOf0l0Gm1RJkuAo\niJvvoUSLVu28mO0PB5w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3811", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3811` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVqSNVcE0Z4SvG4LmboO9iSLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMjhlNzgxLTI0ZTYtNDA2MC04OTIxLTNmMWI5YWI0ZWE4NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM0Y2ZjMTUtMDQw\nMi00ZTE4LWI0ODYtZGFiOTc2ZGM1Yzc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmgZGkCa2ypx8rGEgPCQc3pclVanurDJsfaijMRKmLnZfiTdv0uC2EfRifFzv\nLAOCq2mGOOyPXZdAQ/UA1fjbKKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0fdWjcvvFkP5azUD6jE5RvzcVJUwHwYDVR0j\nBBgwFoAUSl5gRG1ACuuS3uh8jEMlRVhiND8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIC7T/RIspbj2LXOA8zFZcFvXqRTpsA1b6hFWvxjl7GNjAiEA\n7QKlkhBlaDRZ/UuuGvBIqE0uAOb8s5k6kSHMDrzGM9A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcdqqsK3tvbFuXM3sFk3OQWyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjI4ZTc4MS0yNGU2LTQwNjAtODkyMS0zZjFiOWFiNGVhODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8JDJecHG8Vbtumu4G2LF2S3aftKcjYVWseIW8+4dreBBk\ncEy1djygoLUq+MEv6IhAUv7rrmYKW6mnCXW/5Jewo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSl5gRG1ACuuS3uh8jEMlRVhi\nND8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPrkK8DhanjM02eTeTiIYn+zBojZLblsCEtI3gyk+ED4CIQCgestCPAUj\nVXBdzlZ3Rbldk9K+AC+0FD64LQHoTtnY7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYx3WJyApAzmg7/pB24nkCLGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM0Y2ZjMTUtMDQwMi00ZTE4LWI0ODYtZGFiOTc2ZGM1Yzc5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTk0ZDBlNWYtOGIzMS00\nYjJhLTg3YjQtZTBlYWZjYjI3ZWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nF3DC5DpndnkrmdZ2LqGOP6RuKfmsEvjwRZNfZtyMe10HDsQ+LoGmUvVZK09XX06z\n45iMbTCBmlxSFuX3yaob5KNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0fdWjcvvFkP5azUD\n6jE5RvzcVJUwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBhtThW\nCSphf5RbdIPlGhyKINTh3vdv6YgxSatS2oyyoAIgQcZGtkrmqtgJijclUGJx9Oxj\npdTsNEdWTIEXELJOKe4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3812", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3812` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbq0ziH16iMN/+/wG49VTtjjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2NjM2MTU0LWM2NWYtNDZjOS1hNzQ3LTEyZGE0YzJlYjBiYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzEwZDljN2EtYTNk\nOS00ODI4LTk1ODUtYjdmZWIzNDg4NDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYsbHr+7qQe8bm8zRZ3eu4MnNsTtFzIOZNSU1pvtT/kg2y63NBcEEnESJkPH+\n9VDcUOvWEx4WCMdOypKd9Bzqv6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWSEX6zUNGgDNBf665zPKdsjCOBowHwYDVR0j\nBBgwFoAUL//Pi4bPisn00KMcIJIfN+Xb9wgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHCMYhZiWDwKi0A/TA+PUt9F9ZkEs8QH\n+8VRaY640frUAiEAr7452BuIYpyyIj7ceK4zzqpBKs3ZJ4PK635SQpA1f/U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWminbfbzaUJiwDDEeK5gX4zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjYzNjE1NC1jNjVmLTQ2YzktYTc0Ny0xMmRhNGMyZWIwYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUB0c4bSyL9JKQijURji1m0197MJqJuCNdAmw1U94WMY2v\ncBcj3MsEl02N8gqAMyDjt4SB3GrrWiF7VAQYECI3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL//Pi4bPisn00KMcIJIfN+Xb\n9wgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALUfmlI+qsvKHxHmPRZNE7oJnFL3ZYIOPLyc8qH9cBD8AiBLkfEYopST\nDZZ1b8UkR79R7uzXFVmT2P2D/BVNFeUWyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISASUaMIBPJkq+L48hLGaurG3NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzEwZDljN2EtYTNkOS00ODI4LTk1ODUtYjdmZWIzNDg4NDliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDM4OTZiNmYtYjYzZS00\nYWM1LWE1OWYtMzY4Nzk2YzRhZTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBDCk6cchFJRXf+T+rQtn34DtVR9DhimU6gmwdcOq7xjeqk0xK1L4ZDtu3nsVcHN5\niTV6zhqC7SmiCn5RB7YkAKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWSEX6zUNGgDNBf66\n5zPKdsjCOBowDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBm/5bA\ngE/Oo3ZaYo3+q1enyqTCsIUXLJM8CJ2jj09FcwIgMkBmprQ1fvU7MZDd4rcXMn/0\ntCMZOaGswO9KdVZXiLA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3813", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3813` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAdBU9mXw6bOJsY956a1nHHgcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxYzRjMDA5LWJmNzktNGFiOS04MzczLTlkYTlhNDQxNTM0ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNjNjhmMWQtYzgx\nYi00YTE3LWE1MmEtZTA5ZDIwOGRhMGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERV24vOM0Uf958BFPU+UgfTJtbWmYBE00P0WvY0cBgkWs7lPaPwQXiS9TFChF\nMKwRgC8TzyKCtKiNJxoD3ClgiKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHmM9lPOTe+cCUW5oFlH1xxLXc4MwHwYDVR0j\nBBgwFoAUid/0oqe53Tv3eCCU1YE1aHCqC9EwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCICTJOoxtDYsnOO4YIwIc/ycGUaTegPXn\nCpYOb3V7hHyNAiEAyVas40C66lwEUQrMHq2pddCNT44x1W5UAiP+hOuAO2M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATj24m+zry7x3pAFWwwNLXZLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWM0YzAwOS1iZjc5LTRhYjktODM3My05ZGE5YTQ0MTUzNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9t4VtWDvj6P0mk11HyN2VcR3Nm173xLUfhbq8Iu4nlqK+\n2Aoqx6C+T/w7UuWx8CT2FiGYT4nXV5msmv1DE72ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUid/0oqe53Tv3eCCU1YE1aHCq\nC9EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcLA3uP9L8OysPvrqxNBBE3t0rDkL+qAN8i2S7zp5KP0CIDbMcTxcXH18\nnrrnhqJKFJbHKqyMwsUb7vgvAO4/ov4n\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAXSGbLpHQHhUob/OPPnbN1zMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNjNjhmMWQtYzgxYi00YTE3LWE1MmEtZTA5ZDIwOGRhMGU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWM3ZjdhODUtOGFmOS00\nYTA5LTljMjEtNjg5YjI5ODBlYmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nysnxCejugak+a+VZz69PrBg5jbbr1BxQr9mEII+o9reSIyIhAgoEq3kl/PuWLDMa\nj6oWCCkhWzK+XEJ3jeg7+qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHmM9lPOTe+cCUW5o\nFlH1xxLXc4MwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAmDAY\n7Ko1HXMEYDdqFQD1OtQMPBxpcWmxKayGgxfxx9ICIQDStphc6K3ykvFXkVvqoRCM\nWh/mXoHcRY//Dm9hdX/SaQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3814", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3814` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZNH+H+iWeMnQGUSjSXvSfDAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiYjBjZTc1LTNhN2UtNDEzMC1iZTkwLTJjNTk1MzMxNmM5MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y2YTAxYjMtN2Vk\nMy00MWFlLWI0ZWQtZjJmNTI4ZWRhNmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8ghRBsQW9SOa262D+ePYwuVnw1CgH5cvdEJwON/L5jvzzeN9Yennz8y/3S5V\nfrpz+k+6OOZYRRksKutUG4+UVKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBkIgvc/nTvdrImXgEEOg/pDEI/oMB8GA1UdIwQY\nMBaAFCWE+7Hjkn9mHFG3frHx7x/Kgl4LMAoGCCqGSM49BAMCA0gAMEUCIB3yQIKM\nCOXnQVvq/hb7grSaqmUPU+tqHDXSsxI60dekAiEAlNOqD57VTy94zHgLmvwDd6IG\nZPtjOukcK4olFTXMO00=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUmRhbT/zNFpyT3wdxYrQGk0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmIwY2U3NS0zYTdlLTQxMzAtYmU5MC0yYzU5NTMzMTZjOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQG2AXhOVd3gB9gLe6qIAqMLsrQrZgYVBBtW6+stQiQ/U8F\nVej4FQCphRyU7bBfZzE+CUgnxOGgAGGRYnY3/oIBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJYT7seOSf2YcUbd+sfHvH8qC\nXgswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIHY0Pp7wta9/lnjG+8iwBnaQ1d8SYxu0c6Pb7/RdJd4CIGgABtFX/kg7\nZocoqhh6KPyfe3o3N2dlMd3QLHv8zvPD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAZ0efXNAMrulhcsAk5QXoPIQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y2YTAxYjMtN2VkMy00MWFlLWI0ZWQtZjJmNTI4ZWRhNmM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzkxNDk3YjItMThiYy00\nNDA0LWIxZWEtNjljNWFmNzQzNWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRdDEeNwd5Dt8N2SGFyVLgOAMp50gCvcjnYmXSa1uItAXqw+oFsIlf+845iDL3L3B\nAIH4LVX1nCc9xRyvdMvNm6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGQiC9z+dO92siZeA\nQQ6D+kMQj+gwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAlUSzV\nYvg6RKLZ2tnj4+hd09B1pFovEfqxAcQ2TXiyMgIgF171hGJh4FDfj8R8ngxLuGMT\nNOntbGhYyUZk5ES42Gc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3815", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3815` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVkOjoeHQpbj0HDG71SHnDLFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZmVjZjY0LTZmYWMtNGYzNC1hZDFmLThkMTA4YTIyNzA0NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNmNGYxOTItMDEw\nNS00NDgwLTkyMTQtNmU2M2RlM2IwODliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdyw40Ch+BTuV01xIJ2vyw5AtZywETHfdiE4gEfUHDkjSyLzm5jDNP8vtloZ0\nLZRuUXjSYQhQHOLbPh6RssZVlKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFAELnpaHGIFuYxafXHwLhnDkqrQMB8GA1UdIwQY\nMBaAFLYbrx5UCKAMTQbKrWfrxfHU0RthMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA/rg3/3PO8I/rPNTBtyEDiTugHgmAeZmv\nPtcMGPPzj7ICIEtRT0QziYu5mJ14Hm0i456uOGGaXm0OLoCjCY78ERmU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYJpHUbx+d6JPh1h6j265NZPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGZlY2Y2NC02ZmFjLTRmMzQtYWQxZi04ZDEwOGEyMjcwNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSaMkyvCR+Fohb2imFX2HKHsEzBtWmggRK6iDHOpgEwkNT\nFkBHpAl3qRqnj/I/Bq5SblD7TRI2mH58PIGuFAgVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUthuvHlQIoAxNBsqtZ+vF8dTR\nG2EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRzUnBMqhl/MZaB57METftVgXWECc33jYDMLoKdj/m2MCIBvaV6SfJtH8\nEkdi9xRgd+y2jWNWjL+XjAjhIQZWkX96\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAWVh6lOdlx+GFsqOqEOR2cNMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNmNGYxOTItMDEwNS00NDgwLTkyMTQtNmU2M2RlM2IwODliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmEzZWYyMjAtNzQyNi00\nOTdmLWFmODQtZjY1NjA3MmY3YTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyTP7l9KfZB8Am7MAnyNayWv4GJvQqrp+QUGYvzo0toRNQoPQTdtKkKyNkPlgdEFf\nvnGUwUNLOAWnO+fpnRZlLKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUAQuelocYgW5jFp9\ncfAuGcOSqtAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBY9qoP\nMnT+C6Nlv8EHkMI6Ztbu2iLgAlJavNrY0Mt4lQIgJmmnZxSI0vCHYDU/XfZxG8ks\nBEqYdpmbP+ZmfPEt5Eo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3816", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3816` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAcTdoqDnOIhhG+rPgwlAEUmoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlMjk4ZjFiLThmMDYtNDk3Yi1hZTNkLTRjYTVlMmMwN2UwMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjczMzZmMGUtNGFi\nMC00OTI5LTgxZDEtOWQ5NzcxNjc3N2ZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExR8nulGA/ZC5PwBX/l5gHnfWxbrOOj35b9C+x8nxhfW+lg8dVCa4MGHzIR3T\nVSCD1b5xtYi2b1t0DeBigsInoqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBCbLg0YP4KwWFLtjwr4bX9RUT5wMB8GA1UdIwQY\nMBaAFOqSRle1RiSgmDnGTnX0Ax+uUT0AMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA4UITkdkMwtnMuW+If8XsWY/guqVPnWAe\nTGiQWG7FY5ACIQD45xqmx/7l/weoYOz+6e+IHXlfS9PMAQM9XLPEzMWP9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY48/mAb0wYLB6X+NebcI9lMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTI5OGYxYi04ZjA2LTQ5N2ItYWUzZC00Y2E1ZTJjMDdlMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDNAgS6BvegDLSIajJGfH7k3X8ccG+kZLCfuVLL4Wqt2mI\nx5cGATsSZ870+oLc1tFn/9iByu78EBQAZpfLprXNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6pJGV7VGJKCYOcZOdfQDH65R\nPQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGBK2NlB8euyn/ajHo1niZV8BgRYqv9w9vJsK20BG3KoCIQCGzzCSINgY\nHwDiW9YryBw/AyByanrMSG3NoLgvRBry8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAZ99VsOE+aopPWwq4q4QHuIiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjczMzZmMGUtNGFiMC00OTI5LTgxZDEtOWQ5NzcxNjc3N2ZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTcxMDRlY2UtYjMwMy00\nZTM0LWI2OGYtMTE3OWM0MTQxYTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndhWWuyFTK97gx0c3gt7xEm7sj++HwornDryxuZq3ocKrOPNUhipsnRmxicag5six\ntP0bPzpdxFWpBjojxIduyKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEJsuDRg/grBYUu2P\nCvhtf1FRPnAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAkG0y1\n1TKkqsaRJh9nAxP3pCpahbuBKWUXVhflJwpwmQIgVBlecJFw+8SP72M4tYCgjJp3\nXXXjQ+H+RRtX+jLe/sg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3817", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3817` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAW+T8iAw6R2Il4acPuHeipLGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmNzFmYmQ0LTk1ZTQtNDljOS1hYjcwLTQzZGI3OTA5ZGU2ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIzOTRjYTctYTc5\nMS00NjYyLTk0NTgtM2JlYzFhZjI5MTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkXHcSvtL3KuCnyQrUTLQzM8agvRLFqJ28rdhi9WbcaWpEYUR2vSREXcI9oUf\noZYwJDK46UbIMq74adgb1MA8DKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQlVE7x017LwlJ10XDlUcXw7R4prjAfBgNVHSME\nGDAWgBR8IPTIb1xkCWEYPNR2QYhIIYX1jzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGu6FgLoMvfKzkq1iiohSVdBndYb/i6x\nLfA779GdWlbGAiBInhbr/C7TPqNbbqKqtzJoidq9ExRGXYKSpUzCZMeGVQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASL/fynt2F8rbHh66bYRkSumMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjcxZmJkNC05NWU0LTQ5YzktYWI3MC00M2RiNzkwOWRlNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzBpE+z0faie+xCK0YEFVHV8bfaWZgDSBWKKfxSYpRYIMP\n25v8F4RwlXngoGIaRr9qY4yFrfv/3flBVHS4l3cqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfCD0yG9cZAlhGDzUdkGISCGF\n9Y8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBtzMXoK1grXIw8ZtseY+L6YwYTmYm7CdxOG7XU1kLT0CIQCNlBfEOGC7\nKoWXaidfVnwtZJUUPsY9FWYOf+Y+3v7zBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARc6DxLrqFYWUDePGMPjL4gzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIzOTRjYTctYTc5MS00NjYyLTk0NTgtM2JlYzFhZjI5MTZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjYyZTZlOTctMjI3My00\nN2U5LTg1MGQtMDdjMGRiYzQyYmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbrqYdMd7F4j/lVZPVT/hziEq9xEvlE6v7HvW/yLH6k1rz2+Y5DVJvFUHlgxfjZxv\nwsDAtM1CYEFk2mpEIqSWMqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJVRO8dNey8JSddFw\n5VHF8O0eKa4wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAi31v\n39fHeaBplga0AYAr1lVHABVWllYNl7Dx5eBdCnsCIDO5Ht9GFEorUYrM4Tsyj4RG\nEzsREBCuDKlUYFQ+ekUf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3818", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3818` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISASnCH630PT6d/mLzLar0seKnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1MjdiM2Q0LWExMGUtNDNjOS1iNzAxLWFkY2NjMTk0YThiNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U5MWUzY2UtNWZk\nMS00NTFlLWJlZmMtZWI5YzAxNDE5MTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENEJS7K6rrtlp9aET0Nhw6Vm9q3jd7g84H61XVnho8I023LazT/Px0M9jR3D+\nmHK5XbcqMQxe6X0B6CZ+JEDlbKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6i8bCS6JRu9Vb3T31uzsq2CZeqMwHwYDVR0j\nBBgwFoAUDWt3Iy0GoRa80c2rHpEpoe5A4xswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBFJd4xfOGQmfaq\nzoC7ExDUxls+alu1PJwgSmh+HmtvWQIgQDS6F6CGPJhrqDw0TeCZ3z/WcHXNznTC\nnspBeG0q5O0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASGvx3cAay/Y+OKr7EyXuL5uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTI3YjNkNC1hMTBlLTQzYzktYjcwMS1hZGNjYzE5NGE4YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBJIi7v5U6BmggyM+srB8f80ZoMoFBnoxG+2/N59FBIVZn\nvHQYvrFOec8qyNRnZgDmByUzAmGDnXyMNRXQKZhto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDWt3Iy0GoRa80c2rHpEpoe5A\n4xswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOHcGNlSZFZuO817Ksr0gwtUmofnRGpNvLGGFwElCsB2AiEAqze6aXxv\n6w2t/MywanwY6badRkkpVf0VAkOaJRKhpI4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXwQ8+l1W9lzix91Au4rQq5FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U5MWUzY2UtNWZkMS00NTFlLWJlZmMtZWI5YzAxNDE5MTNmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTVkNjZiYjAtNDQ0OC00\nNDcxLTg2YzYtZjBjNzU5MGU1MjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrX09CsQD2fd0XqMxUB04p6LoW8qAgx3ugSlPN+d2PEIE9tx91yz5+bRoGwmDuHYw\nOtVSDYJhxc3k0IXTwktufaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6i8bCS6JRu9Vb3T3\n1uzsq2CZeqMwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAw4r9\nX1zX8Lqt8j0DCAhV8uD7Sb+Z3DdTXrO7R731y/UCIFcPq7JjVD3fDTU0U9V7KEI2\nDq5pTooAQKkoSntTIcP1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3819", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3819` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAUwq0gWK2v9XrBecrarvKtvKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlM2ViMGFhLTE1MWMtNDBjOS1hY2NlLWI0NDJjZjRlODcxYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzE3ZmNmODMtMWFl\nZC00MDUzLThlMTAtODVjMTM0Zjc3OWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsXJqr+PeQwOGZZnHvGdfz08KL9HoQPZIRQ9inLXV8a6QrQNnrhWCsHscYi+m\n4QcD79PeaPXkFAr4r4UVFtzeX6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6HHWjc5HR+OiRpokzqay/i2Vv88wHwYDVR0j\nBBgwFoAUF1bU8Mkpgk89jWVOaQ3sqqk+leswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAoF/2pVF0QMGV\nKwmKBCkcKGdB5d5LOz0zCWefNLLjcA8CIQDEjbHTf78RCLIgsDrsM25M35RQydzZ\npdcOxeznHiYpeg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVZbh85Q4zyVsO422MiVSCWsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTNlYjBhYS0xNTFjLTQwYzktYWNjZS1iNDQyY2Y0ZTg3MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToAft/gM0hqu3Rp92C9evAV04PVkC8R8VAIj09w6cF1/es\nc/XmHiFtf9PJWRI5rzWTAzGf+Jf4GGnY0is+XmQ7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF1bU8Mkpgk89jWVOaQ3sqqk+\nleswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKau7SWpthzoIQ0cgXqdqSyXCoq7Fpv5ocamkqA3I8n2AiAWhEuE9p1r\n6+2oq1oTJRkn3JuIiko/gMmzAfa+svnJQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAbNBhEKQ8LzQWWfDcbtsAdeFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzE3ZmNmODMtMWFlZC00MDUzLThlMTAtODVjMTM0Zjc3OWIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODI4M2YwYjgtYWNjOC00\nOWYwLWIyY2YtYmRiYmU3YjY3M2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3Fg7jKnZ/3GJN6IceIsjXLeUsS6cDVUph5HGOJz/76G5tRnulAtrhzxBkxySt+VK\n9ef1QiZpPAO2rMyCec958aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6HHWjc5HR+OiRpok\nzqay/i2Vv88wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiARGLY3\nz0w01qqH6clZM26dZRGYT6Polm0myynLcT++iAIgfVsX81y/xPnebUGL/n74Y2x0\n7OEu5Vu0VtDUJpGyenY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3820", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3820` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAV1RhzRERmaL/9fNn6i9bE5PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NjdjOWU4LTkyNWQtNGJkMi1hYjAyLTE2MmQ3YjBjMTE4ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGExMjc2YzUtZGI4\nNC00NGEzLWEzM2MtMTI0MDIxNzk4NDgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUsdlNrsu9MS9rbcd+X1dx2uxfchmQ6HhPiFpO+lQpr0NI8Sh0oWZeBSWIhH/\nzTXCwcAjUX/9g9z4rx21Ekf+MKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU19s4tyaCsNoGV2IEW1/6GcjGmDIwHwYDVR0j\nBBgwFoAUzkIQVIzewNagzuZMdfUjpXqt3CIwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAydCQ/xiwtXuu6IXTcAm/\nqgwqJ8ebrTGZoRdi3k8nyK4CIH2+OrkFCj2ry/YzVBmjobOCUAYcuvYywWaFMrCM\nkSp2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUU1ptbjaFR9nn/UYPsJdzp3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODY3YzllOC05MjVkLTRiZDItYWIwMi0xNjJkN2IwYzExOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWLjPzdkxjagbHErkNUKlRa+MT2/XnakMzTLqh6wHTpG7s\nQW0JfGSy1HAgp9s5buscRugiVOKFU3zq/DYA4oA4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzkIQVIzewNagzuZMdfUjpXqt\n3CIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI8aOpJwa25tKxpPqMSMCtmKHdwGTRf7sTSjl6I3YjavAiAHuKW+R8pf\ncO0RtG5xD8WZE1TpmPU07dA8p9TtuEDyTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAUOXFG3CZGMqM98cm1C7mZV9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGExMjc2YzUtZGI4NC00NGEzLWEzM2MtMTI0MDIxNzk4NDgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGRlMmY0MzAtNTEzMi00\nM2JkLTkxYjMtNmQwZjQwNGEyMjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+58s3PIrMMLXdShbpdWSXu/gWyMVqxDIVKjJbQscK1uMJ+mGzdc+sYZEvxCnetnL\n8f/KFvFNwLZ9TsTCGo6InqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU19s4tyaCsNoGV2IE\nW1/6GcjGmDIwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAx/5cO\nfrfer86RJnjyyPJNy1h/GlfxrHrgDB/SiFz9ZAIhAIiElNbAf0kn9oAMvuIRWWNP\n60Xsod2/ifXoLiGHvpH+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3821", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3821` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAX2fmIVN/n1YJYH+w8CBgA7dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MzVjYzk5LWM5NmYtNGEwYS05NGQxLWJkOGEyM2Y3NWNkNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTViNDM0YTctNjdm\nYy00MGM2LTllYjMtZGI2OWMwMTljMTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPbvFxr2lPP8GwEbjUjZQVONGmDHhnwaYdmpX04tuDMrCRxTH6oLyKy9hiafH\nYqtcPVjEctJTlbzj+eU9sll4F6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaExtGrerBxRMB1Of6iaQ1SY+SQkwHwYDVR0j\nBBgwFoAUKzKIRaGU7IXDBnsPM6tvTXYBBQkwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA2lXW\n4Pnh/n1i+BHaZuwJhq90svEUJx2PDdRi55HukEMCIQCxrf19vB37EUpd5H2YeoGW\nXCzl4A6c3a9ki0XS6En4Iw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbsnby0cWp1t8opwacQwankBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODM1Y2M5OS1jOTZmLTRhMGEtOTRkMS1iZDhhMjNmNzVjZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9OVI3NnuZwPRf1CVhKyKlaznJFwkWh/ikLI8D1QH/9v8q\nKczTj9/qTVbcuY/4YMBujVMfDyEoiqZdH8xARkbIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKzKIRaGU7IXDBnsPM6tvTXYB\nBQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJDejR9PYx32oN6Ad4tgzSoNlym/eRh6cVtGfMQ7i/vqAiEAkRD8mFcH\n+HAG0Lu1LZk06CNJZDNLM0qL6IaQrdHObxY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAWq+B+iBKZgOdXDMFNHS4wJiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTViNDM0YTctNjdmYy00MGM2LTllYjMtZGI2OWMwMTljMTE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTkzOThjZDctMWVmMC00\nNzUxLWE4MzAtNjgyNjdjYzZlMWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nai7yCUfPF3c3XiC8SJ09CEDo/GV+KnsIkQbHI3RRurWSELaz7IyfB0kfSRcHw7Aq\n4fp3073R/rPfc1+d4uL6DaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaExtGrerBxRMB1Of\n6iaQ1SY+SQkwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAoI5z\nAfzfxbl6+OFk3DokzKWuKIYYj1BCYrIcTpAyGFMCIQC0Q9lLu7OWWz4S6WX3Ox3r\nNlQ3QzbQOya00A66gfr9Vg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3822", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3822` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAST+v/V1+jeYgLjHF99PgkzdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwNGE1MTZmLTRhZDEtNDZlYy04NjQwLTU2M2U5ODJhODJjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOThjZTY3M2MtMjlj\nOC00ZDhjLWFkNjctMmEwMjkyNTQ0YTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkEHjm8t2yJMRjpthROVxmj125znu2454mT92hFd8IOwJ1iK4C6hruVsIgOCn\nL2yF/bha0ZhRCZuMDFaKAdPtr6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUchgpDjCZpE0s/cXbpqwexFRJy4wwHwYDVR0j\nBBgwFoAU0fZRkaY/csPEwCMpz0A/9d12dFIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiArHoVS\n7/680qNjasdJdt3M1mC1+P3x2DLHn2H2J0+J4wIhAM1ZsdPAoS6J+MXDfgpkl73h\n928a3LUpiU4Ks9Es5Dl7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZRWrekw+9n2qM+iXZMZn6vqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMDRhNTE2Zi00YWQxLTQ2ZWMtODY0MC01NjNlOTgyYTgyYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJWlQBUfJBJtIYrOmXPimgoR20jhd/I3Q0s9fC30DfKFNB\nORFWe3SMGvXiirwyB91FkNQO+Qm/olyj+KACwRVKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0fZRkaY/csPEwCMpz0A/9d12\ndFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfTJnkVCDi8BwKhYMiM6r3fBwOL+t5+RZ+m5Hx4oKDrICIAOvS/USgBB7\ntUIFliCQfayz0iN5ceWDjYRAkR66wLXN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISARZS4bAyF4wajaBVgrQOjP78MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOThjZTY3M2MtMjljOC00ZDhjLWFkNjctMmEwMjkyNTQ0YTA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTgxMTEzMTQtMTg3YS00\nY2Q3LTllYjQtZmJlMzA2NDk5OWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPReGyRHX0DEb8sOhvj0od978SJHuaDP4jdoA2p547rHzdT9kn5LQtQG1OlNPPKZ/\n4sdLeZbMlFoJQ4gytzT2xaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUchgpDjCZpE0s/cXb\npqwexFRJy4wwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA77of\n2NZ5dGQwTgK+TDvbi+fYjnyGA/cblhfErDbyaXoCIQCyJJDsSdAo+fv47MJHd/ed\nURwGyMvsGz+zZd/7uLqkWg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3823", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3823` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWodLPkvo1SkcYfy4eO1kCkJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNTg5ZTZhLWU5YjEtNDA5MC05MDhjLTE5NzBjNmVmMTg2MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQxM2EwMzMtOWIy\nOC00ZDk4LWExYjMtNTUyYjc3ZWUwZDhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsUZ9k51pWnnDzK/TdPrBqn1Ji6ZdLDxSQ6ygu4Jb001FHrQufAUpv7UI65nW\ng8+9OhjlfhIF0I9TfqVk/OAi2qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLPMgB6eyjPPzYAuZbff1NFMnz5dMB8GA1UdIwQY\nMBaAFNmwpsgSGf5bhwfSDqsQFv4aZy4mMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAICGd0sx7iZwdGX4s43aUpI493YccBjwLZ\nj2RvVUbhkwIhAJOYoVs6ziQGFRvXfGckkD8lYVrD0pcJ0U5/PAVd6OEE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT94bRj93HSRkAT37HrltRoEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjU4OWU2YS1lOWIxLTQwOTAtOTA4Yy0xOTcwYzZlZjE4NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHrkx2OOpUfRQBkcV6VRsIiqgc7Vszz0RiWSanhGQXZ5SB\ntUGxb0+hy1tkc9hUO/g0xZFTfzU7ZP6sxMzBzjG0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2bCmyBIZ/luHB9IOqxAW/hpn\nLiYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJP/C7BummnEB48YV+FDwzqviEbBm2noEUAXtglJrgw4AiEAzl19JH+M\n+gYq2sMCkouWqToCoQ+xl/UUQGpQvdCu7rA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAWbT9SlSrt0wZRxcSqJKO4I2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQxM2EwMzMtOWIyOC00ZDk4LWExYjMtNTUyYjc3ZWUwZDhkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmNmZTBlY2YtMDYyOC00\nZWU4LTljZGMtMzQwYTg2MDVlMTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMmJEhrFuZfRBqfYuh8sEyVtcDsd9+fa+5Vnnl90lr6KBPdBMqbPyBzgn2PhQGHMm\nHKC67nSaHZPvH+jor93FxqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs8yAHp7KM8/NgC5l\nt9/U0UyfPl0wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA7cPQ\nNasQ53a68iyr6bmbk1Xb1Y93oU/PKA/w3OG8e4UCIGsuFKQ/cuulQYGCxc9HH9pe\n7ElxM0HTzLD6WzZM5i3/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3824", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3824` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAaVHnPP8/uqDgQHappgqJVyQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZWIwZjExLTQ0N2YtNGRjNi1hMjIzLTE5MjdjMzY1YTMzNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQwMjYzMGMtYzZi\nMS00YTFkLWJlNDAtM2ZlZjE0NTc1ZmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzUXllvqtZHDIktBRUpbh2xckufvdrJPD6o2MZuavmTW4C46mS31wJF5RGaPT\n5Rg6DPFaKTEkcolcp/uWje5AzaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHwMMIGHStFDMsiNXuVxfIpmaWXwwHwYDVR0j\nBBgwFoAULabJTQl6ujgFw1+83TEqr+p+zb8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgBw3BtkbPB1fa\n2MfsdioW6Zpal7BkOeBgzQEJZgnqNZoCIBWkxlVmx59gYzP16in6TvKiLj0n4365\nhdxb9BFvTEmv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdbo4a6SlccO3dVtonVtroBMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2ViMGYxMS00NDdmLTRkYzYtYTIyMy0xOTI3YzM2NWEzMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8wP7gcATwVvobn8KRt+siWSwvqiRwQrDkoOLNtpKm1xTr\nGLXymiNyaZHPUU+mmacw3o+5rDiqzv/8qgm4hIqFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULabJTQl6ujgFw1+83TEqr+p+\nzb8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMtPBFU06lE/JTkgShXlsz6zPa+GwlLcf57iEi4Q5j6hAiBqJN2Zv3MU\n9sa7oll/Ax2UlhwLuK9Cjf8Kmsls671nYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAWPoXsNmoDPWaq7/uDcDCQdaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQwMjYzMGMtYzZiMS00YTFkLWJlNDAtM2ZlZjE0NTc1ZmE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTUyMTJlODctYmMwYi00\nNGRmLTkzODYtMjBjY2MxYjc0YTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n36cjFLREeGr3zRZtgq3TyDHH8g5rTe+9PodtklyDzbwFAEiWTSjrDzY/6iFne9yA\n6l96KfTEB5qT5L3jpMIvUaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHwMMIGHStFDMsiNX\nuVxfIpmaWXwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAbk8ma\ntzzi3UojgE6fi6n4FatSxZ8ohGqZ+LnmLCcv+wIgbstlRH5pjmOjqWm6hJHF62ha\nyCVxoOkI/BJItKejS9Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3825", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3825` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAZGV0lMEbZk8ZMB9sFVrftphMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NTQ5ZGMwLWQxNzYtNGY0ZC1iZGIxLTM0NzlhYmI5MWQwNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc0MTkzNGEtZTRm\nOS00MzY1LTg5NGItYTY5ODlmNTczMDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnfz7/Z8Geyv4QNfvhkYW9OUxDglLnyXcouslIx1zceVdz0JU0eqZf9Cfc5lI\nGX8bfrpbZ8hcv9LSYvxy4Y/MR6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgrKrzgiYaYwKB+WrO7C7/XXwVEIwHwYDVR0j\nBBgwFoAUuv8D3+fwGrlYUNlmwL6FU1vX01cwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgTsjcqN6CD9DA\nY+HEC5UC+koLncOLTxc8xnMd1PkFps4CIQDeH/ROORtR2W230uh9onYtObywlLwf\ngX5VGerKRd+jVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdEbmOO82k7lhGSLvsRidJcFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDU0OWRjMC1kMTc2LTRmNGQtYmRiMS0zNDc5YWJiOTFkMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLshRn3wakUWI0y8+knV63+c+fQtVg5zzll3DXBu/Ce6Mu\njjatjIn5SzP8l+GWTkT4tV6Ciq+leZ3y48e1JisOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuv8D3+fwGrlYUNlmwL6FU1vX\n01cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR0m/rwI3zMhSrxiAIxIjXF9kHuUdke2uoJVsRX6/N+4CIEAaHz/YaSQ0\nL1hMo2d04yLQvapptUcH3YVNNrEY22jm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASNXgguVPQLt6/Z+5rGKMmLMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc0MTkzNGEtZTRmOS00MzY1LTg5NGItYTY5ODlmNTczMDkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTMzNWRjNzAtYTRjMS00\nNzY5LWI0YzItM2U5MzIzMjc0MWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ne1SHIgO674td24JkYM4qrrSWH7fWi+CMiEkb/eADZMHNYrfgqQUfbwCauTTAEzD5\nWBYPqxvKwESiPThUZbn+MKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgrKrzgiYaYwKB+Wr\nO7C7/XXwVEIwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBW1NZM\npNv2dk0p3Br0w3bNy07y7kOc3R8MnuVgz73uQQIhAI7UHUPWe9jrGqhk8SM4+j78\nr4mRZUyYOOHZqpVM7G74\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3826", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3826` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYo5gYTjBCrJh8auHF+/09f6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMWVhMDA3LTZkZjctNGZlZC05YjIzLTFhMTNkMTRhZGNjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE4ZjU4MDMtMmEy\nMi00NGQzLThhODItNTNhMzQxYzIwYTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqHzgQB8BJyQKIg9gqKko2bgMsjHDSslU3cZVFdi4pssEtHfkQaVMBOGeCWko\nMW7ZkooQl4PETryqF9GvEx+EeqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAtx+kqLMUX0qaU5RP7sgA1QKbuUwHwYDVR0j\nBBgwFoAUvB3WOVyCJhW9ewDk/kfkQzVzpyIwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC3vVOrSSDs\nFxlPxKFaE5gREG8IyDjdSh5qyLXqNQXuTwIgbN4ZrF5vaeW5hgFSN4RRG9IpRSGU\nxKDoIZGTC+6gPUc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQdNB/xYH9mw0cbL5nt2yh6CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDFlYTAwNy02ZGY3LTRmZWQtOWIyMy0xYTEzZDE0YWRjY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoVyuW3mlSfuSUjYA/qd/BpRxRA60yrn5XqYgc39qyaI6c\nP1Ht8W3MwC3fhklnzVK6a1TzPrWnJG7vqfnSh3hHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvB3WOVyCJhW9ewDk/kfkQzVz\npyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUmTkmqGcQCZPp77k/LRFp2YdmFMJOlYINSS1uCzK7UcCIQCy8wN3J8ve\nAuvPg0lGpxRs8989cXsOZGFoJnbupb6vMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYCIiIbqMcynAsIIt56NXt50MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE4ZjU4MDMtMmEyMi00NGQzLThhODItNTNhMzQxYzIwYTJkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjY4YmUzM2MtYmE4ZC00\nN2U0LWEyZjQtNTAxMDYyYTA2YWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUhruNla+/jKURkQUNlHv3ttPoMKUzvYD/OTEkdbSOGIvdgK18fvCwGBAR9NDcToa\nZyufollNZ+IsBDoOVKkuIKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAtx+kqLMUX0qaU5R\nP7sgA1QKbuUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA3uJP\nfNUH25N+1D/mqdeKHGwt4ZDiaHb6f9Ak6hqywEkCIENlKcCJLECJYOsZvci1Xa4S\n0qMod1+Pbwch3ueqNmCd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3827", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3827` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaCVWb3bOHV5hg56OOBnnYJ6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3ZjlhZmNhLWUwMWQtNDVlZi1hY2E5LWRhNzM1Yzc5M2E1MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVlYjc5OGEtM2My\nMS00YWI4LWI5NGQtNjZmOTA4M2FhNDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQWglNpPOm1Uj+FXErcBEn2akTDu4Wz2IUwnWv7VqgF3klm7Wapxjduyme3CD\nTi3iJapKhh6/VFMOUNRhYLX836OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2R2IimEfj5tehJQQdkmNTZKq8IUwHwYDVR0j\nBBgwFoAUXoMJUL/muO3q12keA2kGOxm9oXIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAEARAdGqu+zTenRQ5XiDMLpdnwmiIdZfW6RpZU7KuRGAiEAmzhQZdqcR6L2\nj1RhdP/S6bzJLQbut2gxTqzUa5IBLWw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUeS4uqFqvPe+USHy7rbVKNuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2Y5YWZjYS1lMDFkLTQ1ZWYtYWNhOS1kYTczNWM3OTNhNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMB00FWPR8X4eA9xp3Qbd8mhOl7WXxY+1App/sXj1Go1Qe\nPAhZHMTKhzMsNKM342qpchm9H4q+AeBhxiVZ/kljo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXoMJUL/muO3q12keA2kGOxm9\noXIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIh49g7rRbJgkf4+h+kIi4DWfd2FWOWriXscwAJiUVxbAiBs76X9XaRy\nLD6ujBo9bfb4rBv4Lzc9MRofLbn+TtrkDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAWw9amJUxcCiU7i1xLhODN3EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVlYjc5OGEtM2MyMS00YWI4LWI5NGQtNjZmOTA4M2FhNDVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjVjY2ZhYTUtYjVmYS00\nODZjLTk1NzgtZWJjODZlZWUyNzZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmci5Z8sTiTZsXIojGxgv8U/m0EQERlvwAS5NtVaJb9Amd9K9EX8YEAo37D6+rjYZ\nYECXphpoCAS4UwGlab/4WKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2R2IimEfj5tehJQQ\ndkmNTZKq8IUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA5Ymm\nf9XP+FneuuRoNKLgw9hh31GXYZqEXWyNOujru/UCIQCFm7EwH4M1qEYdzt4F26iL\n1IcSebJZHWW9RL2ui+rMDQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3828", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3828` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARB5XpJIL6qmFEEK/+U+RGeAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxZGFmN2JhLTI4NTAtNGVhNC04NTgzLTMxMGViYmYwNzVkYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUzMGI3NzctODYz\nOS00NDRlLWJmNzUtMzZlNTYxN2ZlZWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENfLXjKu81y8B8uIYo/JhdV7+0Q/8t2V6Z1dIw0BVHfUpL/xi8M2yNDTuvGFg\nwqmPDpAVctq/ir078sAI2VuTP6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU81aqKyFE1MjLNn7jF6dtEfWGmEYwHwYDVR0j\nBBgwFoAUaWb0aEEYvegAVW205mEwDosoNIYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDtehNYv4l52O6Gfa32VaaNSRJyGQedag9FS/8x1Sjh1AIgXBwv5dPPnEPm\nKu4jN5dWvCeej54bhQiUAsJA0hHbKAs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbJFWI/wSZOOm83XQBb0djvLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWRhZjdiYS0yODUwLTRlYTQtODU4My0zMTBlYmJmMDc1ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHtdwMpjq8kRIoFqczq3i35YAJwkiMdEFVuti7Lbh+dRAB\ngiuQXhcyXIQJPIjUsBE5cfJ2uhVwweP+2b0ujUSqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaWb0aEEYvegAVW205mEwDoso\nNIYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJuwYt+GMYB7GtuDB9nEnDj9Mb26nMPJZzHm5VsjZq+sAiApwkCWLRNK\nhKe7LejHobVDLNY1xTN5hIV+s904sK6AIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAdh1LvSvS/9jQChY25KoY0KJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUzMGI3NzctODYzOS00NDRlLWJmNzUtMzZlNTYxN2ZlZWYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmNjNTY4MjEtMGUyNC00\nN2NjLTk0MzItNDY2Zjg0ZWNkNTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5M0PPxitGOPAl9IM5eBh3fhKKFD9SVkGv45Mh+a+Rwf5zAWSTqQYtmD7kDeA/LUn\n9R1wNtTqoFKLtA3A+y7IKaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU81aqKyFE1MjLNn7j\nF6dtEfWGmEYwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAEPvj2\nSOnywAvBDkTI2t8VloAIxa6Tk0VMrTn0cZvTnQIgFMLAeUUmdQvnkFZmPNj7Ku4P\npP5Wr9HcSzA0aeXaN/c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3829", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3829` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAeZUNey7hiu8r4eddFpInqBtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhN2U3NjAyLTY0ZDktNGExMS1iOWJmLTMzNWZlZDRiMDhjNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRhOTY3ZDQtOWYz\nNS00OTlmLWEyODctZWQ3YzczNGVkMTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW98jp69JTElbn8WD6pPhPcjQWRSHyUaIWq9OC5uFmNVFa0xwjsDQeRGrKuqd\nAbcK7zfU9gGGLnvBv8yd9AwuM6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtqqsAZuuacc83guk4iPlwxlIhZIwHwYDVR0j\nBBgwFoAU1/yj+BfkWx28bEVfRFHofiSOi+kwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIF4i\nSM8V20UoQYpVIkpVFuCSFjDXZU2+VmszK0hHcRMJAiBtPV8A5aM1bGWzfRKDm08g\nfiO4TnsVkyV/yFxxANYerg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbksR9kkN3EIeWUjrlpv6vAeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTdlNzYwMi02NGQ5LTRhMTEtYjliZi0zMzVmZWQ0YjA4YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhZWAlXouSRf8QBqDzuG0WBTPgd7afFunaQ2WCsTpEY8FT\n0bLL+bkp8r5mzJypFdiHpGrcgnmowp7ZUtc+rB5Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1/yj+BfkWx28bEVfRFHofiSO\ni+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM/nKgrtoU432h6jnULprCHkRAezQbewWKzm2hd3m0xOAiAl/9otfH2M\nxD75IIS97hAgWwhf8FF0dohITIPKlcbb9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAW2KnbgRDWi0Av6+RL+1VivEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRhOTY3ZDQtOWYzNS00OTlmLWEyODctZWQ3YzczNGVkMTdlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGUxNzU5NjktNzliYy00\nMTNkLWJiOGQtZjk1Zjc5NmMxNmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nL/iKtQV042BlGRjlwf7zBCoLErffQ9aFDcIYCtaLvfJSH00aesICD/PoYRxpHdJh\ndJIolJI7rUcXA64LIZofjqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtqqsAZuuacc83guk\n4iPlwxlIhZIwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAgHmR\nU1sBHfR+fN9AaaHAUnIKSB7gp/3MpLjyIGVJUqwCIANN0T7mCoSsXcLXTtJACg+o\nRK4yGDO7T8kuFF2t8KRC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3830", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3830` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAfB0X9V8bPuMxVoIHfpaRiB/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4MGE5NzBlLWMxMTktNGI0MC04MTZiLTBkNGY5MWE3YjQwMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAzNDc5NTMtOWQ2\nZC00NThjLThkM2UtN2YxN2Y2ZmQ0MTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcYNr+G9wzwzgZ33fxjYMlTSt6l1UlWHM/HpXnt8aETXvlVk/n2Vtgd366QZ6\namTtiH63t4pBb0UPog2gFS3I5qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXxWkryvDDnxd6ABOrnYpzbl2vLEwHwYDVR0j\nBBgwFoAUixkN8Jz4okh5rIHll7CbDN75L/cwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHb+Gnk74WSpSyG4gqI2zQSSrm5GuJUyos7vXQw7caokAiA8xTMw\nYOE/SjpUp2uHsvf5N2cmpekDDI0HiawJT2FMHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXZ+fbeUStX99vAuPBAVTxfLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODBhOTcwZS1jMTE5LTRiNDAtODE2Yi0wZDRmOTFhN2I0MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlDR5qx78ooymQr1345hyKDPUOD33iLthe7401bEugmYwK\nRkkeeozfr2yuzVr5wv9XOVXTJXAmGkqJxIk0As5do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUixkN8Jz4okh5rIHll7CbDN75\nL/cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOujjK6uJmTGVfYsf0Hrg00ZnpusHqShhf34EKk50Q8PAiBchZYnVZJv\nJjoLrn837DZ9FMCPpLrekfJhL9dI++x9Ig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAVTVcewJX8lt7pvaPj21BrVlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAzNDc5NTMtOWQ2ZC00NThjLThkM2UtN2YxN2Y2ZmQ0MTY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzJiMDMwYTItMWUzMi00\nNmI1LTg3YWYtMjcwYjA1Y2NhNzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nizFkr1v731Nc4XXVjxfZtbV3JIU67WsaSAKjXt1F+3uT47WsU5eZok7F58B4DFoM\nySndwB4gTjf/zRmo9TIYvaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXxWkryvDDnxd6ABO\nrnYpzbl2vLEwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBncq6P\nEv+QXXZeLfhMJrOcqm6KjZJzD4zCHIAZ4SpI/AIhAPDAxv8E+1m1m7zwQ+6fmULI\nfKylrFpQdTmEoR3cZuJT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3831", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3831` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAZDKzbwxim1wkoNwUZ4RaINUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmNGRmODg3LTFkNTAtNDM1NC1hMTY2LTExZmRhMTQwMGNhYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmIxNTkyNmItODA4\nMC00NGJkLTk1OWUtZjcxNDc2ZDg5NjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJY/47tc5BFLXspjGrYG0nd6GxK4jVeY0RVdReVpqqppc4EuCEUm3/keAtu2E\nkeGo0fwAFj0FjeqTKPTdMhXj4qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXzJIr2+Db6JiwBPwbcS8fpeUeu8wHwYDVR0j\nBBgwFoAUho3SeZ9uFjmERg+TMjdhHHQW0kEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDggrP92JSrOouxEi+ZqwN4kgtGMcoroM89txGX7poumgIhAJR4\n44GAOq1c8r50zQzT8gU65cawpVwfGk5ffElSYdNP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbJzV337kuojITsFXcsONY68MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjRkZjg4Ny0xZDUwLTQzNTQtYTE2Ni0xMWZkYTE0MDBjYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYFlp3hT9zSrAFWYly78Ztw/rVCBn+mzpU654YqVuiQoDe\np5E/5jjygfFQAVPswC3BkkIxkn0f0uz/GMTf1COEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUho3SeZ9uFjmERg+TMjdhHHQW\n0kEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdOF3DYm3hxvpFeYkNzFO5BW6PGuLkC7p9k7AzSmgNsQCIQCbCr3LVo6D\ncdzfNExOyxqzVBJdJOlF1MlKvN/DWngEPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXBqmlUorHkz1ohzRyC8vhr3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmIxNTkyNmItODA4MC00NGJkLTk1OWUtZjcxNDc2ZDg5NjczMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjEwNTUxMGYtMWZjYy00\nMDAyLWFjMjEtMmZiZTAxNDMyNTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCxSMSq5F1m80mOVKblbk8VaNso7xZhw4UGqgepyomyB6V0EvMHmUIrtF62OD15Zv\nzSzdxnMso7gEoOOFoL8ubKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXzJIr2+Db6JiwBPw\nbcS8fpeUeu8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBapuOl\nwQUBBhS3BjV3WHVhybvhJi81OeF+hL//RuWTOwIhALIJ68JzpexhEJR6MW0y/yFx\n2+1GqcK1NeSVrz81k8PG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3832", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3832` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAWQoOhhrYEc0EtvQThhbJioaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyNjk4NTZhLWQwNWItNGE0YS05ZDFkLTM1MWFmOTY1NzBjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY5MDJiOTQtNTBh\nNS00NTUwLThmYzAtNjFiNTcwN2U2ZTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKRVbQchN9QJEHEk9OcRPsZXfKRVOSctq8bf2FJJMVGFIPfBwBo/79DcXtrK5\nbprZGGOp2avbLAAKGeYVEuziGqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJ9huDxybgb6nrPAtiFii2xfLY6cMB8GA1UdIwQY\nMBaAFMLiYMCnuO5Hl5zNi1h45BDVfgaiMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAqP9exr2iUegr/vucCqWFq/M7/JYqyTzi6\nDRX5ClbwSgIgWaGZzArj+ykle1hU0Gj/eD/wQftisoxaJq+X7qt0+9o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAejCAxuYb9XpvMB8AJ2kI41LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjY5ODU2YS1kMDViLTRhNGEtOWQxZC0zNTFhZjk2NTcwY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoIA3ipPOGwgDZXylAhZTnIZSAcQKVuAb2vrj7OwshgIgj\nPm/MYOT9CtmKTTuE7IYAhIdbvn8HaHCZ1sCX6IQHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwuJgwKe47keXnM2LWHjkENV+\nBqIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKJl9hgFRrAcTIUs6Q2xU8ctTT+w8aeKGW2TWbs6VWSTAiBRdcobA6fT\nCNSerY0GGJGEU3s2oPHwe2Os79zqHXV6wA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAWvRcLIOlOXUtpIiGLPV46jUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY5MDJiOTQtNTBhNS00NTUwLThmYzAtNjFiNTcwN2U2ZTA3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjlkYWIzNDEtYzIyOC00\nYTY3LTkxNTgtYjUyYmY1NDQyMmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTEDis4i7eNCTjMTyf7Oy2QCChkcQslLPn5nP/RUdbaPxdHk7Vq6peF3xwTs0Zobx\nolu8uGX8/0/HNV/bd50RXKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUn2G4PHJuBvqes8C2\nIWKLbF8tjpwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA3Iuf\nueypztxTdtYZ+KaIpU/063f/eVUwlDgyECJox+ICIQDqlnQ2FE6m225L3tsP1q6u\nKR+nar+wHiWhmYLz2JWs4Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3833", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3833` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAb1b/5vynHdekAhZhvpD6DatMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0MWRlMWY0LWYzYTEtNDExNi05MmJmLTg4ZjUxMDAzMDY3YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQ2NzkwYWItNWMx\nMi00MDhiLTk3ZTItM2EzNzU0N2NjNDk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaqosz6Oe0IpagiYFWwZFNX4B1FFsYJ5MwGbLuL+3NCNVqmqAfbhVe7GGiDFH\nl7KjobVE730fitU2b1XSI4QxIaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbehKqjbXjnOd5wxjbnsNZmajodswHwYDVR0j\nBBgwFoAU17F8PqEDZtUppO65lqM0Ypural0wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMgfRj63mDuE\nxnAwJtjqCRcV+3mBTyHFYlnhJl3CPjyHAiACyStbjD+I8vITyIagWzyccjBf6hrL\nSmzM/8rVTAtKgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQC+1ZlV56md/WLr1n4sEIohMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDFkZTFmNC1mM2ExLTQxMTYtOTJiZi04OGY1MTAwMzA2N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLItc3Rohcx71emIX+P/jG3Jhbikgwf0Y4ljomXbfTKXGV\nlyYQ8Skg424xcAsnktQ1KtG57X98tbNZJvnPXQxZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU17F8PqEDZtUppO65lqM0Ypur\nal0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI4nDcY5MVdmkLCkK3eoBy9VEwZapey56WEsmDsglL9kCICCM8MOdeibZ\nSVxu4swuuAnIzGkhNtrqJzj3sQB53+uE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARJxqkD4R2m9e2t0QSFn+k6oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQ2NzkwYWItNWMxMi00MDhiLTk3ZTItM2EzNzU0N2NjNDk2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTQ3YmYxMjktMTJmZS00\nZjI4LWJmYzQtZmE4ZGMyYjI1ZGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJWQiL0b8fL2frHRRh+gCOqXBx/wtUAwe5l061XxKyirSVCGO077z+UxkAJfZtBWb\n9vxmiXVKHXkH6yHJCymjZKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbehKqjbXjnOd5wxj\nbnsNZmajodswDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiB/wLSB\nqtsplvdqmnUpH7nD+AagWMVA4hTRcGOTHU8SUAIhAL94Onp3koVGCuRacFZq3H/T\nopXXufD3fD3g2xRYsnCU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3834", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3834` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAUxvL4QaCwaOu/YXOmlhN3dFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwNDRjMWYyLTJjNmMtNDBiMi04N2FkLWI5MjhmZGU0ZmU4YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMwZjhlMjUtNTM5\nMy00YWFjLThjNjctODJhMTgzZDE4MTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZksszwH6718eCJdgKEIY0YxsGqUGsxUeRcYuj/dAG3aQbWNisPnZci/ib0Ul\nvTUTW08lEuoxSi+ZYXbgZz7SGKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1j7c1lvvhBEOIUW/zHthbXGcK7wwHwYDVR0j\nBBgwFoAUzYs7oNo7n/MacjyoDqLxA8qRd9wwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPoJOBkjq5l4\nByf1+oWTahXYj5h+q9zo8y69rtHoHBmtAiEA+Jb2z9NHJDLuawVrhT4ktTZhHzNq\nyI1/u2G5QOo7ipU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVUEnomCmUm8ceyJaklK0r7oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDQ0YzFmMi0yYzZjLTQwYjItODdhZC1iOTI4ZmRlNGZlOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+kUfJ/YfB5xXTlXf4agn4Dn+uNWIsRytQ0kVPbZdlKpfn\nuyb/UjDYLpzehCDQRnbwSABbBLmWq7d+UWkYdaSSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzYs7oNo7n/MacjyoDqLxA8qR\nd9wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJAgWiJU77fW2dWmca6k4wVW7dDIcZIui5sy+U8yimJYAiEA3+HP7plW\nCxiuN5xAcFSEWAlL5ChW7DvtsgK6617f8UY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAU+9e7+jPZZnHlktdc67f70vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMwZjhlMjUtNTM5My00YWFjLThjNjctODJhMTgzZDE4MTFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWRlNWViM2ItNWFiMS00\nZmViLWJjOTYtNjYxYjc3MjQ1MzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYkLDCKpWaNnkZ1kGJeKecKcgAEJECYCZmrlkYugQ2ABdvhxSz9oZYm5/nIHD8Zgj\nHo94Md3J5K5/7amb0D+5E6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1j7c1lvvhBEOIUW/\nzHthbXGcK7wwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBZt+7l\ncd8YsgtRMEdiLmlJ+GtNIsSv//0oxrdPl1SjPwIhAKOB/RFpFX+7I1qPJC6ceK1A\n2WmErZMktMXpGbQrCo4w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3835", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3835` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQqpO7itHsjXiVNWeQoVH2IqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkOTQ2NDYyLTIxOWMtNGQ2OS05MzcxLWE5NjJiYjA2ZjU4MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjczMGE0MjUtZTJi\nMi00MTcwLTk0MzAtYTQ1ZjNjOTJhOGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs3gt3Qj1Y1fht993qew9hJG/IQLLLtqL1D4Sf2fwuu1ta+jqlui4ZX8scjwv\ngkQ74gZtx0H3+cP4sONVq8NScaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7fIwLWOAJtwAiRojgdTy10FI5OwwHwYDVR0j\nBBgwFoAUcmLzfTWWvEEWhgi76N6cygO9l74wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCh97ouGmI2\nsSG6H8t84RluiLe4hWXIr0JFUSmzJ8vbzAIgJmEc+sKs4uT/6jzU4/pRqqvP5VHG\n1Yc8mDSCu+OOspw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYqjLV20byAmxmbj2F//V8GUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDk0NjQ2Mi0yMTljLTRkNjktOTM3MS1hOTYyYmIwNmY1ODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUow8wu9PQUyOPErwXKVZIqWoK6UL83PD3UQe4L872ZklJ\nQxm4t+PQa2NnZCuWUxA+P/PiSblEGZkrmT9GPmOJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcmLzfTWWvEEWhgi76N6cygO9\nl74wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIQ/obgjF8H3ojf0w0qcXo9V+XFmxg85N/MHjknKx63UAiEA7kZcx0hF\nNo8VmQ+Rdq3HIxqTuPQDD8HjHpdetv1Evys=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAU1tsjEabR6uRKc3yxB8Z8RgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjczMGE0MjUtZTJiMi00MTcwLTk0MzAtYTQ1ZjNjOTJhOGRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjVmY2EzNWItNWFjYS00\nZTc5LTk5ODMtNzYyNGNkMzA0NmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nV3YMAMWirYuLWHbF0uuZPcGj7sLYb9kpxFy/q2NmPpKXikPZuPNehtmCfOCRz1PM\nHgDBX3PXyRAX+chgyyy2mKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7fIwLWOAJtwAiRoj\ngdTy10FI5OwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAqg+1\ntVix/z6lUrusgeWgOeiY5LtTiKnSCO91a3Yfx6YCIDrTi2z0e5REs74+e1uylxXQ\nuXm1qFuZQz5xC09e0/GB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3836", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3836` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASnAm7rZRFzXw9KpFQenQHhNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4MDkzYzM4LTgxY2YtNDY2Yy1hNmNiLWM3Zjc2ZGJlNGZlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg1ODkxNzItNjM1\nOC00Y2MzLTk3MDQtZTA2NTM4MGVlM2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYNVR7gksSIu1iT3erbVJ3QroTWk2Il/BbIMTwtMh27Slwx1OY9v+hIGiNE4D\nLJwva2NChaQLWRrD0TH2tNRc9qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBRjweUqjFmb0hcr2mtgyJe73XyUwHwYDVR0j\nBBgwFoAUiQdMFp9/cq+1Or0mvfcTxXN1eI4wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIANw4DNMAENb+Rj47r10cvc3LXQmWJ96dLu3q8gUvPz6AiADgtj+IFWKjf1d\nL6dJqC1Sto/YFMPxlohatNp2jDW2Sg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbXSau4Mw81RTF1PvFc97FDmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODA5M2MzOC04MWNmLTQ2NmMtYTZjYi1jN2Y3NmRiZTRmZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7tAw8d7SrUmmcoZoA/6yHt+ZElnEISbVf0mTDXddPqCdO\neSvpPfdE+Y3Vp3FkUwhO/7S9FMvUauSVsMfgpaZSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiQdMFp9/cq+1Or0mvfcTxXN1\neI4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK5uI4TtB32suY50DbKQbBjQwl17b3Trsq/utXcp9PbdAiEAuS+n67Pv\nF9IYkUrvmEi0qO37ETVpSYEfRw7mwIA9Kn8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAW0ekA0L/n8BsR/EWGOHGOUmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg1ODkxNzItNjM1OC00Y2MzLTk3MDQtZTA2NTM4MGVlM2NmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGY5YWYwOTktYzU2Ny00\nZTY3LTg0NzgtNjQ1ZTBkYzJkZDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2ieBvVqeKVbx7TGe6jAmYLcOt4g6JT0Bbul0GkJep8wUSJ5a7eYGgLTFrJkgwV/q\naD+4wRf+o+5NoVXEJK3x7KNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBRjweUqjFmb0hcr2\nmtgyJe73XyUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiB494Y7\nMi+zA4E+Vz0Taz+dDjolbIgciYjeWXm1iyQY/gIhAPah1DEYGNcR+lj6QpCrZ3JQ\nzKFTYJM/u7fZ1XES5oJU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3837", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3837` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUG9skAOLJS+zrSB82EyPxC9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMmMyNDdlLTc4MjctNDI3MC1iYTY3LTAzMTRjYzQyYmJhNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NhNGIwMDgtZDU1\nYy00ODVkLWJlYjItMWY3NjBjYTU2YzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1y9+eOJPrmojOsAgS2nn4yDLrIUlzusfKCLovqWnNec07wJ255c21bBBBS1R\n/a26Zk44RtwMWJmZ539Y1e9sQqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgkYikm/QamQUf/DwhDfA2lt9rwwwHwYDVR0j\nBBgwFoAUyzV/eiEeRtRY53S6N9vHGUZWku0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDV+Q4+66+qlXXoIoGNgUN2rzXZ629Y8ulmQgIUKvzp9gIhAJKJTwUv7QT6\nWHYBioI1sqpsh/flkdI7SJeJnA3ch+ai\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASoIli5xC65/sigsErO5CxFLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzJjMjQ3ZS03ODI3LTQyNzAtYmE2Ny0wMzE0Y2M0MmJiYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQRVBklI0AbURypJj8oagd5uczGYERCH/uVD5pnFl1rePH\nlbfs+mrkpIoOFgfa1TWDpdpUb3g1hzfMzJvl/+1Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyzV/eiEeRtRY53S6N9vHGUZW\nku0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIDCHzmaPcFzz1D75673yEWj4tn3Tr/m7VxXLRnjPUy8AiBEQhKwlFkT\nUq9mih+xhIDuCE8KgFLXumuRKTNJdXU8Tg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISATz/o0s5d6CZO/HgKjTYpkTIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NhNGIwMDgtZDU1Yy00ODVkLWJlYjItMWY3NjBjYTU2YzY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODBhNDI4ZDEtYmE5NS00\nNDFjLWE1MGEtNzJhNjU5N2U0NGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n24YvOmeDCJUlleeIcliTY4K2ljQCOzlFio9L8xqOCrDjuTCtBNHHLfaBkJ2oajyA\nxexY8u1yqEgT/qnmXNVG8qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgkYikm/QamQUf/Dw\nhDfA2lt9rwwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiADUacr\nck5WydhlSIdfLT6DCGBA4TY7KLwYkQCNzeqQLQIhAIhEDDMtjLgta4ncAVAulW54\n6MNf7SvX5LwAGhDR31V4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3838", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3838` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAU9fU/IlETqrugAqv/6nWyE/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjOTlmNDJmLWE4MTItNDkyMi04YTcyLTM0MTkzYmNkYmRhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI1OTQzOWYtOWNj\nYy00YjdjLTkxMjItNjgwNTYzOGRlZTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7IyS/dsN0pMB3fuGdgZc6eT+ldcimipvdlhJjYgnbLSM6fDd8FqlSQSN1H+l\n96psa9QI9K8HFa5a1/ktVZW+YKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBpeEvnl0qDTdNSlj2ON22HblkDQwHwYDVR0j\nBBgwFoAU0EKRGMgyzkIEZvkHBWxZV16VLx8wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDv\ncuewSt34Ii/VQlxMe7eg5jJAN8A7lle6RfHcHOHhSwIhALVnhZHY4hSFvA5Dlvlv\nlAEtMUtVGDpmK0D9tJME6OsB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWhcd+b6AK+9Zp87cPiINTniMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzk5ZjQyZi1hODEyLTQ5MjItOGE3Mi0zNDE5M2JjZGJkYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBfwnqcPwrK1qQThBGQtM4KeuqSzJWaSB6lz1V1hEVFyMZ\nsVv2GYrtPUhmiikWHGPAbFexZLRZYEWx8+TvC7SKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0EKRGMgyzkIEZvkHBWxZV16V\nLx8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPWgNf9AYXRRD645ujNzTSwimNkAgbtXouOlYwaC8bHICIQDEKT4HEGkb\no48GSjugu5jEokWHyGE4D/CEOSemREusTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAU0KCLX1Xm2egYaoGkZQT+8RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI1OTQzOWYtOWNjYy00YjdjLTkxMjItNjgwNTYzOGRlZTFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjg0ZTczYjQtNDUwZC00\nMzk4LTgzMWItYTgzMTkyMzFhZDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqLtZvFnCM467OaIQ/cCdQgQUXnxXq6K8WE/zgj365dKoQvDc9LUI/lyOJCeIAXV8\nxMELCwbGCO3gxoVACwkCN6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBpeEvnl0qDTdNSlj\n2ON22HblkDQwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAzVWy\nsrh8R0GtMLwG4LGmzFrZ8Qdlp4R3ig4D7xZX9yQCIQCPKSsD+jI0vb7odg0oqMq7\nSmxLb8fuGa4a+OGnAIyncw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3839", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3839` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAfJ8Wy6Sr+G6HTsoVS9zvQMTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0OGU4OGE3LWVlMGQtNDc5YS1iYzgwLWQ1YjA0ZjFkYmE3YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdkNzNiMTYtOTM2\nNC00YmQxLWI3MDctMTNmM2JhODZkNmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvmpgWGo+3nbbzOXUGP8LiBLPY/I6ZeOmfVR6FfRv41Tvsz/FbEJX/ckcGn0m\nT1G74mn3GuD6SUNPO1tXgc9q5KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUznZ0csM6D8cah6xHc3PeLJMxCdwwHwYDVR0j\nBBgwFoAUiGRDKZsQYBfQFJnhxyPMEC9U2BkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFCBt4S+qaZdjPtOVjuqtd4vLi3ULqjkK6GPJ4zC/PD5AiBWeDrb\ncBEQIk2WjoESOga2IBpum2bxbkFdNVEZ8R1g3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbIU1w0tH1++jXIC+R8Mx2nZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDhlODhhNy1lZTBkLTQ3OWEtYmM4MC1kNWIwNGYxZGJhN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQyLygHsucgLaSqc2OwXXPxAAsyASMGKuMLVlLP7hiuJP5\n1vthmNRzvikRRchBK3cnk5SMAxmwhmfW3IjNrqzno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiGRDKZsQYBfQFJnhxyPMEC9U\n2BkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANp4Vnxg3sCc2EWMP8gb1EAvxlUCNSzpPMg/Nx5NfseUAiAz77zhhVEG\nY990pscUy4gwuLnsK61UZ3F/A8+h+5SNJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYxWCQt1lB83PWW3h/RrcW/hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdkNzNiMTYtOTM2NC00YmQxLWI3MDctMTNmM2JhODZkNmQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWJiYmU5ZWQtNzIzOS00\nNjk1LThlNjQtNzE3YjVlZGFlMDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nA0TbFrEdZZxq+W+nAxt0SE/SZEYPMA3KW0wKvX4dwcSlH5gVc9gvyFOdXCjvZKFa\n7IHbvQ8NvE85rw2VzadvoaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUznZ0csM6D8cah6xH\nc3PeLJMxCdwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAO/sBM\nmvOn8yd795B02RG8rjvMqphL67hq3a7VgUbMFQIgaP6eAWGul0yOhSYT2iKXp+ip\n8pud/Fj7ot8046WiOoo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3840", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3840` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAR9vjxBkAfv8hPYe+BYrebQvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2ZDBlY2RmLWNkZWItNGUyNC04YTFkLTYwZjA0OTEwNTdkYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU5ODIyYzAtNjc3\nYi00NWQxLTg5MDMtOTZlZDg4YmNiMjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESrPndHhBnZxgkbVB0Erhz07T18skpTZvaZfXSupYH9qoeNMRYk3BWENzLY1W\nq5/y7qgfmEUJY5BCjwFP+yZTGqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUShx2B3b6ClYiaopC5lJzrQqjkZMwHwYDVR0j\nBBgwFoAUa4PS3AqSt2jg7sVoau54PNv8PNwwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIC8ssXNRmQea8AO164q2+5l7BMJcTIp+wta5QQRbYu68AiEAtz5i\nBm9gwxSCNXpRD2KlyFqL6nh3I+hAMWkQtOrSUoY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW7lXQf2qHMrTzJN10lDK6EDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmQwZWNkZi1jZGViLTRlMjQtOGExZC02MGYwNDkxMDU3ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd58g9/+A87+fSTCCUKkeLCpke/InmN+2nl9yvjY8TT3Ha\nraOKMtbctIoTQFyPby9wipezmnG54vl0dudOjLOAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa4PS3AqSt2jg7sVoau54PNv8\nPNwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTtxTS3lCowu75swK0NnaXtoJRfEBOeUEal01UR1V2+cCIA3bxnU1iYSO\nZxjIk9OEaLIbbzmbc8ZDi/Cafx9QF6ih\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAW5Uy1dtrlpi27Yuygi2bi75MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU5ODIyYzAtNjc3Yi00NWQxLTg5MDMtOTZlZDg4YmNiMjU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzUzMDI3MGEtOGUyZC00\nOTFjLTgzNmQtNzVjODkzNzAyNmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+NXHYJfLXhKRsv838PN3XrAuJ9QVpazl5WMS3wi1U+iDxJ66zBsLBQOarsB5TAPJ\nfyF0BvG8UouQ2Ja1u+jZeqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUShx2B3b6ClYiaopC\n5lJzrQqjkZMwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAGS/H4\nyGoxOeTEIWLZk9Tsmm9KjSCfGhsqzALxMit+XQIgS0TXWY5V5VCRnWyLpRUsIsI6\nGZJKpacRU7o4qjc+SEI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3841", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3841` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAeYulPvoScRl0g6q05Lv8mIFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlYmExNGFmLWM1ZDgtNDE2NS1hMWVlLWI1NmMxZTMwMjAwYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg0Y2U4OTYtZDZj\nOC00YzM0LTg4YTgtNTc0ZTU0MmU5OTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnKCl8h3SjcYRA49+jSvN8hJkxpWQnH04CPwPDPJ6K/NQwzWX7jGrbppwej4W\nGLXa4RXD55IayFKvA0Kr+BpHBqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSOrA5dXgRD6L23iTmb6WXL658faTAfBgNVHSME\nGDAWgBQZDL4D+ljUkulFA5jGzc2E0xFe0zAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDvoIXx45X+HQ82jn29jvn6sqRo27tN\n3hb4aOn8WWQ+ugIgDLrTZNr125cB1e8DhqxhQ42UXCoMpZQksvwF7Tv8ESE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATMQhUvNmw0tYfZfEvl28ua3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWJhMTRhZi1jNWQ4LTQxNjUtYTFlZS1iNTZjMWUzMDIwMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS409sfzXwz7x4qvKNXPB5J8ufsF8aUU28uO3sy++emzo/b\nihKYTzFj/0pWW45kF/rJFFksILRr9iaZR0QvxyLpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGQy+A/pY1JLpRQOYxs3NhNMR\nXtMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZth0Yw4prNFzVJXEbwWp5aBcA3ebxOlQgkgIP7M1MwoCIQDXd9Cu2etJ\n5INyVq6SvWRvUBtMUBJXSk/qgkz/kKn5XQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAbVs7kp1HxPXXxbtlM6mr4gYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg0Y2U4OTYtZDZjOC00YzM0LTg4YTgtNTc0ZTU0MmU5OTYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2U1NDkzNTMtMDU2Yy00\nNDBhLTg3ZmItMGQzNTg1NGI2NjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+1hUirGk82m+WZusPFSvUCUr45YXrza3huSPP+fQLPX9zHYQcJGFQe0RlsmbsnKG\nN92QqUSlru8QSLMw575ZTaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjqwOXV4EQ+i9t4k5\nm+lly+ufH2kwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBcCIoY\nER58dSqhCzi6bVEjNx81xcZCqaR58YtVUTRmPgIgGK1SxWMGF5fpKLc2HoJEK/H9\nZ57gdDBHa8TGcU8JGBo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3842", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3842` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAa0rc+CPECQY3sW71gcyFGAqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1OGVlNWQzLTMyZDUtNDRmNC05YWZmLTg1OWI1YzRjMmM5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWI5YWNkYjEtOWQw\nYy00NjVlLWIyMmYtYzBmY2IwYzU4NTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg6d+RFK6ABeTC1BjI0IQvyjdXAMJp6Fu/OqofVgk8kmyT2qn0T3EHDPmIIYJ\n2zheBw9ZLymhCMUDjwKLIYHYiqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYO9HBDoVCaMjLw1ybxHB8mSeiwEwHwYDVR0j\nBBgwFoAU3HTdbxpdFcsY4R4hMx3GOu0sVq4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIFtlk7tqYjqq\nQRL2Z3mh3UipA8ens05aCRDtMk1e5IEoAiAubzuYFA9/hrC+6NZqvLSyEe5ikwQn\nQsfhrxwWjmYmwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARo7fPJ2NkMfxiDaZ0eBKTPHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNThlZTVkMy0zMmQ1LTQ0ZjQtOWFmZi04NTliNWM0YzJjOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOkR7H7PRtiHV6EW7RV2zPkm0/2b6cNAUL1/4FLUFrBpng\nTYE2n+FM4GB4eEK7gL2pbfVuISZO/gHQReuRLT2io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3HTdbxpdFcsY4R4hMx3GOu0s\nVq4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANxtxSheOzpYCMR/2EKsdN0Y6TFG/0EZ2QBEs/Tf66CPAiB81qXYtNiw\n9YJueBizWzS5wkTpbAq/w7gdqlX4TXvxag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAcysxWCtn5SgZvAArg2h2narMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWI5YWNkYjEtOWQwYy00NjVlLWIyMmYtYzBmY2IwYzU4NTRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODc2MjA5MmItNDFkNS00\nYzkwLWI4MzctYzNjM2UzZGE4ODkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQ0rleYQezhXQ6kJgOj7MVMgwA9euy3YNWwxvJ2KmvED4GVyIwO9hQ8+wbmyuwJ+x\n+jUPEqW8H3oetoQV0bR1faNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYO9HBDoVCaMjLw1y\nbxHB8mSeiwEwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA+VQi\nOOhWkNli1J0bJGKfPogYp0LsYoPXCWBRq4KcjLICIEdMPY31cDpvFlRmGW7mW9Ie\npFIFTYZputS6Bak1es/Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3843", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3843` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXgbpzWcO193SwJmGcyGs9YxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4ZTI1NzZhLTg2ZmUtNDM4MS1hZjkxLTNjOGEwZDZmZTQ3ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM2NDk2ZWMtZTE5\nOS00OGM2LWI5M2MtZmJmZmIyYzZiODBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkbWwlJcPcth9FoblPDUkLW10pRlNdYEpPL3TcJ0b2b4YQ4PMGL0wklW0tk5q\nh+LNkLV5HMSFEqZRreu2y1ufA6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPCVLjv42RZ7uR4N0iasK7tPkUO8wHwYDVR0j\nBBgwFoAUXEZSAtbV8bEHja0ZP/wlfKCPsogwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHbBfdKxrxxf\njPJZXwerNOmM14S8e1/5pusVspvAug2YAiEA9A6It2BDC4mcVW3quOADhI6639K4\nl3xLEJ2m0g+Qgh8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaqE4d6lPU+3QkzPnWw9xkmzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGUyNTc2YS04NmZlLTQzODEtYWY5MS0zYzhhMGQ2ZmU0N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATp3e8KL9K7ePQGpJYIJ3YiW/gBb2GjaXp8UI1yOigIZbRL\nGG08tZsVNs9/tzfhicWcnjFC1vdzcFr5ycCfl9xMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXEZSAtbV8bEHja0ZP/wlfKCP\nsogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKFG3sxwpo/m/X/saYms5Txw6Ndd8kyAidNd7owfCwvnAiEA2eiyCbIt\nbCXQPjJcc6lB2NAaTFXJdlDb3pTGLhx+EJM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAZFXljp8JkdirroxUDjZJqs3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM2NDk2ZWMtZTE5OS00OGM2LWI5M2MtZmJmZmIyYzZiODBiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjEzOWY1ZmEtZjY2NC00\nYWE4LTllMjctY2FhODE1NTYyYTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/XbvuwXDxnohqk9CMqN5SCdocN9xxpcpf0ooC47BAuUPSRGrR0x8DmyxtYR8hGZN\njDXd3T6lIaHWKHjrnuOxFqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPCVLjv42RZ7uR4N0\niasK7tPkUO8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBjkK4J\nx+30ej4U1ZZ7M6bKhupKP4f9U4meNC+qhBGbQwIhAJZUTXbmseZgjj5HeFHbGJGG\nIlPqQ7/IWy+yKuLSoF9C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3844", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3844` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAbwMnjdlRQIJPvPIKIgnzVGmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhY2E0OTIxLWE4NmItNDc4Ni05MzE3LWI0MDFlNjI3YTU5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE3NzE5YWMtMmFl\nOC00MWMyLTliMTMtMDdiMzg1NzU5YWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAzbbbednbCi8fZypSIMRb450blOWHz+kppXTXvMShsx4wBioMIC1OAD782mJ\nSRZ2ZB6PIsL5ky5pQcweXA5q0qOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX1YwSXP8OuRPnWQu53irC2onatIwHwYDVR0j\nBBgwFoAUJoBOAkWyFwYHpWekvrmzH2T1xq8wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBgwI/Kv1gV\nXP3PA5s7l486cK+uJypezkyedpxsXJszfgIhAOCm8cHs75XqIM6fGYIZ/qVpjTeQ\nsIM7enN3K3F/EC4U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQmdnIFwK/zEn5Y5Uz6kOzMHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWNhNDkyMS1hODZiLTQ3ODYtOTMxNy1iNDAxZTYyN2E1OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASalRtXmiE4m9O8uGlplqzoM138OjdDNJf4SHDBMi/D/dp5\n/TcQj5/ARkN3REzW4MYn0npIwffBkgVGYDQpBRsio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJoBOAkWyFwYHpWekvrmzH2T1\nxq8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOrSyofeA55m5SadKyXB6L8s/d5hT6Evn22G0ea28gmMCIQD5Dt05ZjC1\nYkevP1d1K+bNBtWk7Gu8qU4z2tUhd9E9Pg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAc7wZD4YgmwzRiSKB6zZIP9XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE3NzE5YWMtMmFlOC00MWMyLTliMTMtMDdiMzg1NzU5YWY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzc2N2EwMTUtMmU1Ny00\nY2JjLTlmZGItZmEzOGZiNGRiMTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ny/oTdQngxEEcIiVEjLx0/IGq5f87EBcTSbTNhKe/lpnk7ljws2ZO9e7iAbID4fWd\nTnEh/xuwmkeS3+1kUPJ6H6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUX1YwSXP8OuRPnWQu\n53irC2onatIwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA02is\nUPOHDaRo2O/0AouVI+v1Eimy1xzktXwRgeq0hxkCIEhlPiEFRguQFSXjDkyHr8EI\nF1F91DXPZRyhT3XwDDJ5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3845", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3845` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAX/cT2nFBoKSeTRsH+g+rV4xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExZGNkNjZlLTY3MWUtNDhkZi1iMmY4LTBkZmRkYjEzYzNmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y5M2JlZTYtMjRi\nMS00NGQ2LTg4MTQtY2Y3MWEzM2FmZmJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdIP3iKzwz/ElXdPrreKykqFgl1S7x4G4xZ9rBlZx4Xn7yFYnENVkXvbDfIJB\nL+QPYiQHnRjre76IntUNbXnS86OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg0rtbqHV/q3FapOH5bykZ3cPiqcwHwYDVR0j\nBBgwFoAUHkb5YsCxg6FVUjBgg3DmSKntK1UwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA0a62aF4K4c9wSv2zh5LkfdQPLx6LE/bQIlXxXguodSECIQCwaU+AVO6D\n/a79GsrTwSlNiDKYEpdecAAjDQvbckp9uA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARdKgSAlvXVhP6h2Z8JBQrYuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWRjZDY2ZS02NzFlLTQ4ZGYtYjJmOC0wZGZkZGIxM2MzZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQttUuJ8IkT4W2oQCZlu+3k+EnKjkmu+QvS03Aqyiiut1PN\n13QTl6ZrXjlh3+VH701ok3YnzB/H2G+Ej1KPGvd7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHkb5YsCxg6FVUjBgg3DmSKnt\nK1UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEgrI0Y53ncSXmjjgvNVi48na6hGFR8UnJWmYJgAvvOsCIBvlZrF/Sq2n\nVUz1swTIKTeEPH3cP10l+SKnQOtQjlWI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAarndqqSCN0nV/5yxZgAiMLCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y5M2JlZTYtMjRiMS00NGQ2LTg4MTQtY2Y3MWEzM2FmZmJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTViMDhlODAtNTVhOC00\nNGY5LWE0NGMtOGQzZTY0ZWE1YTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzN73ajUg2tdnogBWARxeMWIiKZvyIMvFzhPNj7BheMLJCsuOsPhh4pyq/mYXBoM1\nkuvOfvV04g1tn4nFG2kAyaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUg0rtbqHV/q3FapOH\n5bykZ3cPiqcwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAnSD/\nVyDxhoksgcMOWEBXOlnJVooPmhWOZU3kSwic/MUCIQDLb1p0W+1bW/n/WAru55XV\n3Fbr0qxCg3vBhNcd0SluwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3846", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3846` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISASBHuKtX95GKLsfbaejf3CDfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhNDg0YzQ3LTgzODctNGNlZi05MDFjLTQzNzU0NWEyZjdhMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQzNzBmZWUtNGZl\nNC00NmIzLWJlYjgtMGUxYTg1ZTk4NjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm28qoZMFOfVTE2c5Nw4KGhnFYBs+vZ6HthecVbn9IqKmgGrE+SwQRpYv2C0P\ngBgMzbAPB9Jq5FmC263QUAN+QaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo4IAXfC7CvbnncuveVLI3RxCmF8wHwYDVR0j\nBBgwFoAUP52tVGZoL5GmAeCPUjJKTrYI77YwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAtIUmESFS8gunNA56rjaK4n+N3TXat934eE/4Mn0dB68CIQDeW6bH1XKh\n/G6GEJqzS2hn7vq0EF3GXWqg2lksX38blw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQCO9lMgSUIP+E46s30WBL76MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTQ4NGM0Ny04Mzg3LTRjZWYtOTAxYy00Mzc1NDVhMmY3YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsYf9hFjAlqzJ6mXbY7Xnl6p0+drJSDHUTmG7kh7DhKslH\nTrLuJ/LP1fVP7Vba/7qb969TyxTm1IY/khUEgab6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP52tVGZoL5GmAeCPUjJKTrYI\n77YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJUOQsYA8t5u0fKrjD7YAXCiIg9NT0oV+RCMWsu3qs73AiEAmSECDQB0\nHhiPwF+amELWlv9tXzlNFDefVQEyjUg7540=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAc4xYgCrLJnQ5ZEZPgv84LzzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQzNzBmZWUtNGZlNC00NmIzLWJlYjgtMGUxYTg1ZTk4NjE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNThhMzRlMzYtZThjYy00\nY2VhLTg1YTQtNTEzODU5NTgwMDQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRqdX0o5hrnKsqf+bKZpSUCT3Q+JekEPSedOsILosBwjNj9fYNM993+ecOQVEhMou\n6HC8I6xim67JA3Hsat8cVqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUo4IAXfC7Cvbnncuv\neVLI3RxCmF8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiARrCt4\nYUXWyyVRv4Q0jSE6F4UzVcTtqacb/lX0qdomnQIhAPv7sNy3bwlGhrllPyVfWDih\n1YeygmO4ZaCgRzVSA6vV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3847", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3847` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAUkHbXiYb/NfH+k+ekwpODOVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmYzc3M2U0LTFhODEtNGY0YS1iNGE3LWE4ZDQ0NTg5MzFmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ1YjUzNjktZjk0\nMy00MWM3LWEyNTUtMGNhN2U5Mjk3NTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb3STDgOBWssjt2mOwdR/Hxu1rBWcEVfXpuQw/FO/Xn+RBD/pKOQwBT21RJGV\nYDtTG6FInDOgdyT2hYUU7lAc5KOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAMVyfqUJ8tG9vg2BT79d2V02xq0wHwYDVR0j\nBBgwFoAUMKM8GyHhmMIb8ussMB++xDuuzxIwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBI\n6P0YvdYFNGdCu4Mv4zL7t0+zMVIhCPj+xHb0nJGWhgIgKisfZrOoxRwvw85/s2wG\nlpccZRfy/ciPgblwksifkPw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaQJ0rXZt53Qbbuw2/lxckJRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmM3NzNlNC0xYTgxLTRmNGEtYjRhNy1hOGQ0NDU4OTMxZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0hK466DZURqc9YcMaIkyvyH6eaeYVjLW62RQ8XU3CWAyy\n+Hq3H+2g0B8AWf54TuRo07yO6zaBAGH2ykXgWrt9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMKM8GyHhmMIb8ussMB++xDuu\nzxIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM4UDYAatXbGgGpjshJgZZ53Deylz8HclHjhR6CgHysIAiBuv6+YR++a\nOuZLSqvH0N7343J3CK70Ga87nYzPVsukEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISATlTyHme5/3t2dbvU+SbbrA9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ1YjUzNjktZjk0My00MWM3LWEyNTUtMGNhN2U5Mjk3NTQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWY2ZWQzZjUtZjhmMS00\nZTY4LTgwNmMtMjIwYjJmOWEyNWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPf4KY5AopKAJKw5j8IpMCxAcxpWgflxaare7APhZQvdNaeM0Ijbsx5jq7pluAOBZ\nxN/aRBnVp+DgcVYoEvMiOKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAMVyfqUJ8tG9vg2B\nT79d2V02xq0wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBwaZCy\nF8FfRO3K/8LXnMYOG7MWd75kg63GeXTu/q2poAIhAL9yzh1fexa1ExjNf9KT8dlb\nu4v4ULMx1qDvEfxeGpsg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3848", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3848` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAUFmFrTii3MvmnxgiAKB8XT1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjM2QzMjBmLTg5NjYtNDRmOC04OTUxLTE2ZDc5YjJiOTE3ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI0ZmY5YWEtODky\nZS00N2Y3LThmYjAtMTcwZGEyNWYwMTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGWOpAQKmSlqmUe1odQpaI7iId7XAr1riDKLcWJubVlbET1rvv7QVxYUViDIg\nnIcOxLvbzLG/++UdXY8mdDEWn6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2s3iPX0fxWqU3WD0RDhQuTg1S5QwHwYDVR0j\nBBgwFoAUjbA1ZEb4s4elq1KYF7YmcyDckOQwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA79rEkWXrKmbwvfnYjMgYb3VJYdaMt5Jn8uOAhFti+z0CIA2s\nLRZAT9UdSvW8DW7O8PtII/Csr/DKDqtN/ZLI0Wbe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcuvruDGCACE2+tqprrkMgeLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzNkMzIwZi04OTY2LTQ0ZjgtODk1MS0xNmQ3OWIyYjkxN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFdgB8nw6EsR0AOA9bWs3tzRJavNhtliEIKKc98G+5GpyT\nY/xQCyFZPC/CojlcM790BEPl7V0behUFIEtiWMnJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjbA1ZEb4s4elq1KYF7YmcyDc\nkOQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXDFBfMw6CF+/p7YQRIPtyHdNUnIudS3kvV5vC3Aw+jUCIQD+GE6tcpUB\nQTfYjHwCHhgbRf9R32FVmPzrle3/puQHeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISATBqmnWFuwZJdJyLtJQ2S8fEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI0ZmY5YWEtODkyZS00N2Y3LThmYjAtMTcwZGEyNWYwMTc1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzBhOTVjOTAtM2E1Mi00\nNWE5LWJhYjEtZmY1ODMwMjNmMzI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEJfiAISS/7P1MG6FtbEE5rWxnWtLNhWToXJxHaAd1qld863gZUZWhQ+kgtSPpnN0\nalqBKSwMZUmkltxSPLWtkqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2s3iPX0fxWqU3WD0\nRDhQuTg1S5QwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAna2y\nOzGhfu0rCAWZv3AAoAFXvpWYa3VDy5eN910BUXACIQCaSsXNtoebm8+fEo8BPBkq\nRln/LMIbjvnb88RUacKupA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3849", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3849` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISASo+21OsTWwBenrAd1zUpicPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNjdlZTFkLWQzYTgtNGI0Yi1hZTUwLTE1MzdlOGI1NjMxODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI1MmMxNWUtOGZh\nNi00OWM2LWFmNzAtNWMwYTA1ZTk2N2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM9eS7pUCmUpUkl8fLFRURtCnuLrvNAO1KrkcWQMFB4fsCB/qaNEJasaeQ9gE\nQPPyIw5W0Q7s+XyPmY4lRYTUB6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1t710XetVQrS+hqonWuoahv3DfUwHwYDVR0j\nBBgwFoAUmJppBYhoM3jHuHZQZ/Bqb/ptEzcwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiAG7e5gJ3yjGLY2R6yTSGWdBK6tqW4J9o6mH7FqE1j0dwIgKKtB\naFwPlGGg9qJPXfe6gI7N/jaeWSFQTjsR6eHIRPM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfkUfguhT2KOVEq3eh9rXq4sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTY3ZWUxZC1kM2E4LTRiNGItYWU1MC0xNTM3ZThiNTYzMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+1PKYZQm4kcwlwdIMEphH9NvYvPKsiLAcTcCvqkGfQPsD\nOy1CRnWdGuOYplK5iPAxEh3KZ08BQbLH85fq4OqIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmJppBYhoM3jHuHZQZ/Bqb/pt\nEzcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY7SrQ+YxkXVe9oE2SZaU1ODcxkg2CleWMACkdAfB1JwCIQDOfQ+CJ6st\n3jhqrBt/qBf38kwzV4WqVbs/RO6or+J6Sw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAY+irA7ZL+DNBwAtzBVlvQGoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI1MmMxNWUtOGZhNi00OWM2LWFmNzAtNWMwYTA1ZTk2N2Q1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzBjNDZmMWQtMjlmNC00\nYWQ0LWJjNmEtMWNkODE0ODZmMTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqNWf5E0NTrzycG2tARvSRQhuqfyGrFiQpdD90ncQi1s0g97ghGK3C8xPJOi6tXiP\nhjJ5lcJbmeJqtOGpxaLj1KNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1t710XetVQrS+hqo\nnWuoahv3DfUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEApinj\nqZpi3tDTUvmkyfZIh+7zIUY29NeJC01QfSpgUB4CIQDjC4cVJ8/V9zJSahQQa94+\nyYWXgg2Ct///F06aLcF6DQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3850", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3850` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAdZYvIYJrNdjF5mMt/rabjlsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5NjRjMTFkLTViNzAtNDQ3ZC1iNjlmLWNjMTY2M2UyNjM3ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY5NGFhMWEtODVk\nOS00MWE5LWE0M2UtY2Y3ZjBhNDRiNjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIzEcrk3WGayZ+5vb6xSUm6yqjmOn4YhpUTnFfVKaJVZSzg/wqeXIl157i4PZ\n3gRio+vlGjYzKW91q191DeuUk6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUibS6HRG0ov665Y3GSYqEgbnmOyAwHwYDVR0j\nBBgwFoAU5CAEamXKygVSs/XB0ZbvU7WAbaYwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBFJFI9VVrj9d6X\namS26+tLDtjjCHEM1UyfEaKQz+j3WgIhAIA5QJLKe5QR/iRf2/UqLGkwt/Jzakk0\nMTQUjlkAppk0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARQIfD8BKyBbWCviXHCd+umuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTY0YzExZC01YjcwLTQ0N2QtYjY5Zi1jYzE2NjNlMjYzN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV9lNfkkM3Zj4gHvMuPdZmp1cldKcqfCysMSD151wjtrZW\naQT+H325/4Qr73lBZAlMRHgp0l7K907bNzU8+SlCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5CAEamXKygVSs/XB0ZbvU7WA\nbaYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIAThjPND8rnUkJwxJrDMctXLCi9izA02+c0EG0qJkYBAiEA3jOPr1JH\njoNOcTsYE+D9849ONG6jmM3Est37xyRoakg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASknAoCpxo2PWQKdXfb5TzSHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY5NGFhMWEtODVkOS00MWE5LWE0M2UtY2Y3ZjBhNDRiNjk2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWViZmZhYmUtYzY5Yy00\nZjYzLTkzMmEtMTYyNmY5ZDliYTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6Ru+pd68V9GG3u5M2SvIpNiKNiGDXjSs/9yptHt9mDwi7QD7xXktFJBBz2Tmeri2\nlspUHTlnE6MbtR0KGf9NM6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUibS6HRG0ov665Y3G\nSYqEgbnmOyAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBrGoi2\n+TKs0HvxKPKdboAxtfxIns+mxs4RE+PnT+8WKwIhAKY0wKSL8vrsfKM3Ja6HZprz\nD92OgfX6ojILRV3cRigK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3851", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3851` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfIk/BGpbr+Ohf114drSI0jrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmYmQ1YTZiLTkxMzgtNDVmMC1iOGFmLTUyZDZhMDY3MzAwOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNjMDllNTYtZjVl\nZS00MDgyLTk0MGUtN2M4OWJkNTcyYTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIUkXtNx1hd37Ua6oMfFaucp/4eLVka12y1Jp0DEyVitSOIJvc/zpjriL49nT\n3puuqq+wOO1DT83QE8eozpD3BaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeOIT2z6bxHOmQTi8SyHOYy/03ocwHwYDVR0j\nBBgwFoAUjqwBpEYj9G6yTEBXxotNFmtrFwIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC4+0R9wMA7kcbi8lTxwLB5ijuACSkW0O0HIDE5Im8iUAIgVJ3D+fDjJ0jQ\nLJCW+O7HI6VTrDdXAHUU5+3rA0g/Gmo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVN1SS+CtHIbKyZ68H32R36WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmJkNWE2Yi05MTM4LTQ1ZjAtYjhhZi01MmQ2YTA2NzMwMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjNzP5JiGPeLPUlA7Ut9g0zGtyJ4t3gxJ++L+Ee6dmtfPZ\n2w+Va8UNXmJ9aFNSafttU8pypn/4RB4FvDD7/90Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjqwBpEYj9G6yTEBXxotNFmtr\nFwIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGymLDuRdsLl7dbM+hJvoq77lHSNhwwsmP3LvAfNlDVoCIAG3iB5WMFua\nprMxbAqdduhjJOVqmdq++NenU5piXQrr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAWh3+tolsfHXyReADgynYKl+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNjMDllNTYtZjVlZS00MDgyLTk0MGUtN2M4OWJkNTcyYTMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmI5YTkxY2ItZjlmZS00\nOTdhLWFiM2EtZThhNjEzNTMwNWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBb9quUMgdFKBVwHEYkIEWt6DGG24/3ESnZxTBQsYP5BIPCIoCDPhkfGW1QzGngIT\nqWYiHwAfTiBmBIrfk8u4FKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUeOIT2z6bxHOmQTi8\nSyHOYy/03ocwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAnmbq\nqANjNiqu0w0RQSjueJvjX9r6j8HJjdUAK0+0XZwCIQC7RdpRNOGdHu00CA9pNTC8\nN4ZwhrF13wnLm68mUwyyqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3852", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3852` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAb/K/FYoeYBKxUY/K+K/Cp4CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNDY2ODI2LTIxMmItNDQ3NC1iZGEzLTZkNDg3ZjhjNDBmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkwM2IwMTUtMTNj\nNC00MzcwLTg5NGEtYjAxODVkNjRkZjgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs9cKeoHud2KfdG/WE4EP7ldnjy2RBTxTex+BR0/KeUshZ3JwW/KZzXD/IGRt\nqUJ+4FKx86MhlDhivAxRWT9bcqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+gC31rMeAmT8boJqbISepZc1x0gwHwYDVR0j\nBBgwFoAUOejGH4y3YqU6cCJYqK/Iry+OF+IwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEqqLQFMANpRhpi5IJy8L5knjNYtp3RYja37DdZh/f6VAiEA7fC696mp9MtE\nqlmW18F6LFwXgCZ2dnfSC8WuM1/fEek=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcABFrSWmt2K0R/8rD6IZzU/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzQ2NjgyNi0yMTJiLTQ0NzQtYmRhMy02ZDQ4N2Y4YzQwZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6fAk/I/YnVuiH/G/s0HnkVl8Vxff9yA536Xp4rTKAv2b0\nayO8J5A/jnub2yeg8DGcIX5HTeNPrMZiA/gEEwyao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOejGH4y3YqU6cCJYqK/Iry+O\nF+IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOxKX4ywCppXEkCgDbuqReDJum/Z/gSqPbwy0ZABw8F5AiAv8Drfwo9R\nCW/AuZXoxe0Zgl4K5i4iVh78LjW4s5th3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAZTZja3nO6bjUd7SluTmnrGNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkwM2IwMTUtMTNjNC00MzcwLTg5NGEtYjAxODVkNjRkZjgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjBkYzhhODgtMDliYi00\nMjUwLTlhMzQtYzVhM2ExNzBhZDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVWoPUxzXEHBWwHXX4NiXNQH36wZNO+PB8Vor4Lp512yH19IISOEmAzkYIvVixHmC\nYsw3wrCcxGN0tSLpzblUpaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+gC31rMeAmT8boJq\nbISepZc1x0gwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA8t7n\njqoV7Wko4VbMI3dMHuU8J0v4GJ/Xn7+LfjxibyUCIQDVYeZTMeWsJUP2TThyKJeY\nVJOVQCYGclfX5u1fCw+cmA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3853", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3853` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAXb9z68/319CNb6FQseT0lFWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyZDQ2NTViLWVlZGItNDIzNC1iODY4LWQ1MDhiNTVmYTg4OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDdlOWNkYjMtYzll\nMS00MzE5LTlmZjgtYTMxN2Y2NWYwZGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhz8KHuNfYIaecpsnPXtoEtaQCLwplynX7NQoDwyWKFfXSbH09cWfnVLkVh3M\n5BtL6xX6hLJFkxZyDhVzFVGOOKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMHoT67VhwxHN39B4wBbp+Br6mrwwHwYDVR0j\nBBgwFoAUDFZ3KEEnCBAvOFZEvWqf+0ORbZwwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiA5Jyf6FFLJ27XmBKbhL6Ptr4BMHrd7CeW4cYfABhRjFwIhAPbSQmGod0oG\nLfxGnx7RAC04fWQwQE8Gd36Z2IrUMkZp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd1fA8QRxE+PWkTWDrOd+RGiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmQ0NjU1Yi1lZWRiLTQyMzQtYjg2OC1kNTA4YjU1ZmE4ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARntzqOjlY8oJ7nJsn88FAzNwxpJ8flbEoI/IMC40ZpmNKX\nc7+rn96Ds+ET0hu6VuS3f16TWHgxb/D/cDfJHebso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDFZ3KEEnCBAvOFZEvWqf+0OR\nbZwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANVovCEF69HWKPCA3tuS68MjfDT7MkPhS2QaydeHq1gnAiEAlXS1j6UW\n4a5EbHqTBmmu0KpSf2H9rD4p1prOAB+mkaU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYSOyZMD2KIpCdZVIBkU6uy3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDdlOWNkYjMtYzllMS00MzE5LTlmZjgtYTMxN2Y2NWYwZGU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDVmMjllMzUtZmYyYS00\nYjEwLTk3ZDEtNjA5MjU2MDFkZDMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nId56v4L14Z+XCe1+ZiiomDreJ04F3EnBr2o4scrHKsbzP2DqBXsBvKm+/Lv2OrxX\nf2vS41zc1izpFNO8jcm1raNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMHoT67VhwxHN39B4\nwBbp+Br6mrwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBug+Sz\nwkqIe8rJ8cgBgQTPSGrokG5Xh0v2hQbkQWO4jgIgH5M4g6IPICTE3GVKqZXA9lJ9\nUXzpEmdAH+A6nd8bVc4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3854", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3854` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWGYrJAfm6eaCZZYHLUgXxl5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyNDg0MTM5LWJkNzAtNGY0Yi1iZDFhLTA4MDRkMmEwY2NhZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJjYTkxYzAtYjFi\nMS00NWU5LWI1NmUtMjMwM2U2ZGEyMDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiYATiLSN3P3H0c/vxQr0MoEfx+o2rsb+5EJpZU80YSnDekcpyPWc6I7lmUER\nJArniexFo297o5Pw1ldk94tjK6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR6y+Xkbo4p8R1hLe2WwPudpmOtUwHwYDVR0j\nBBgwFoAUecyuGZGxaqvMgJ65BRNBNolOWTIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA9rjvR2Br1FOLHpm2QZMaKNPeoLyBpRKBG1z5pDzR\niAcCIHCsoaCmcTWt6B7lCpxNADaW4OAJwEkGqGgFouKC5WuX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATKfVXHCc7/cKdUPZ2ghk8V5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjQ4NDEzOS1iZDcwLTRmNGItYmQxYS0wODA0ZDJhMGNjYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASm4sr+BtObjSVT/sXok7bMOECHBfg1p9qj1WPjRr6yIU5M\nSUczR2i/DvwZpPNUHtDfxO7iwlSTwLXlryvsVo6eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUecyuGZGxaqvMgJ65BRNBNolO\nWTIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALPMkUYXxuXlqV+vtCxpG7LrybB9HFyw8GPi/G9TlMn5AiEAg7E2qVe7\nSTiBtnvzjEnzBMUvdbbi2PMARRuMIUodrHI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAbx4Zf1JUJWZQRVWIAsaEv09MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJjYTkxYzAtYjFiMS00NWU5LWI1NmUtMjMwM2U2ZGEyMDYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmQ4ZWM3MWQtYmFjMy00\nNWE2LWFkODAtYTc2ZDBlZTUwNWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/kEPlByKi4QJdwvpkc8WQ+IylFCzx1B9gR3J5UUl+cQehb0ZgmNYeNPihgg0YLuc\nixyHC9gJkohYBcVKHgf6E6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUR6y+Xkbo4p8R1hLe\n2WwPudpmOtUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAum9L\nredJ4Oh1+pUb4/1jlEZvui9v1X/QukipLO9iQRwCIBP3H00PQzF7hvYBsV0ArkgS\nDC4ckBF4ixEPrTHJD4kO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3855", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3855` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAZe9R+yyhvGXpQLZX0JVAsMFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhZjJmN2UwLTg3MGMtNGJjMS1hNjA5LTc1ZjQ4NzAxOTI5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNlMjk5ZTEtOTlm\nZS00NjgwLTg5MDgtNDJhNWRlNzgwOTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6dAL6/2lF1AFi1ZRO/S34JgBM6WCKlWmZ3xfKTT4xE+R9zrsKkCaXvmOE7AS\n9cXMWRk568EnEzzoxlUkt+s61qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQL4kg/ntqS5daSt4AeKSy7gLAY8wHwYDVR0j\nBBgwFoAUI4gYOLcNJv2tUyTt8jBtGjmL0QAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAhcCYMwvbSYoH2mAGHbWq4sg/t6JhB7nf3WtwZkKxa\nUwIgRh9KwE97hcTscrfXjVERLsxlefEGesaBh4Vnme99KC0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATZj1viaW1EmWVlkaiRsy+hOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWYyZjdlMC04NzBjLTRiYzEtYTYwOS03NWY0ODcwMTkyOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI7kkaj0G8MMK+gXJkXEh9axr+SBnINLvBoVSTHiRTE0aK\nPFJGGc1c45yx4Tp+tmxiBGumjCgphHZGIwnTrxcfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI4gYOLcNJv2tUyTt8jBtGjmL\n0QAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCBnlmq6W4KUYucX0yrnll8S3T2W7dyIzX8O/5S2MqD4CIQDqDmHPruvz\n6KTRsr7+UQ0e8urOMoIJrYkkraScU5py6g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASgyQP6JaxyksfIwoJee3/Q1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNlMjk5ZTEtOTlmZS00NjgwLTg5MDgtNDJhNWRlNzgwOTlhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDBkN2ZiOWYtNDU0OS00\nMjE0LThhZjYtYzNlZDI0OWRhYTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+cgA7LiMuIcP10cp2yRdyoyntR67PvaWJmYN8s/2/wxfLI2B5iY/lU2wfm71U4Ir\nzn/HI9WhHXov061ccHPah6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQL4kg/ntqS5daSt4\nAeKSy7gLAY8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAojyS\npGMQwkKryf3kW0YCe4HLHbpZSeJKBwGarvBJlqwCIAVCxWXuz01EOEDG3vmfFzMm\nTFzG5W9uYPqAYfX/SGQH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3856", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3856` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAYMMWVpUEJrJrT6wYE92qjb4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1MTkxNjRjLTgxMzAtNDU5ZC05YTJiLWMzYmY1YjYyNTZlMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk2ZDliZWEtNmZl\nMy00MzMzLWE2YzYtZDQzYTdhMGNhYTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETmlV4ZHcx9/Muj+V6DeyDxxPyVzCa3db6KuTihvTOJV5JHOO9McunJ1xYnml\nffQ96CEcSrQNzBeUxJl6GWEhiaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEQgP5u9VTUOs/3mSh6ekI2LSBicwHwYDVR0j\nBBgwFoAUgDodDF2kvFzxqy+4HhnqJo8qkcEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAh+X/HHv0NNJxOh/sZ0BzU7mnx2a/Kw1WOz5cWB5Zo2wCIQCf\nEe2nWq0++p1B2pRaYTHRR8pmQ1RJs34FQGQsHTv01A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb7/Y8eSzZHPhVJd4Aluvkg7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTE5MTY0Yy04MTMwLTQ1OWQtOWEyYi1jM2JmNWI2MjU2ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARX/n30dPxv0IIBr85ShaxK2boX+Kj9bDmy7Wd58O+jCTJH\nwz5Crt8mOjWSctD27w7h+EA6eOQf9L7p6FuimtiRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgDodDF2kvFzxqy+4HhnqJo8q\nkcEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOK81RRp6PFulezjULzP+q2hryJLeSYe0c9xGo5qFBgIAiA6nG349pAI\nLu5RzI2b+UsKmjix3+CuwRBZrkGeRv/C8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAQC2Lor9feN2gfqLeZce8h5UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk2ZDliZWEtNmZlMy00MzMzLWE2YzYtZDQzYTdhMGNhYTJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTdkMTIwMzgtYzNlNC00\nOGFhLWEzNDQtOTYzNDRlODAzYWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nG3w7Nki6qRk75KoB9D9yEo2Hg1RR2wH2P36dV9hT8f/IqFZH0+Wjf1Qfbb7cU7nZ\nupqPDWUjxHQpTFmJ8ERAl6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEQgP5u9VTUOs/3mS\nh6ekI2LSBicwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAiUDZ\nDT6LABlpVoUi0Kw4K7KQP6qwnF96Yjp2hnNMu3ECIQCOM752t1VBxRRqN+LcKRus\n2b+rTBcthhrYhRit7mDguQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3857", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3857` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQSJUUc945BEf8EVOeyigGUuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxN2QwZjgzLTA2YTItNDdhYi1hNmQ0LTY1NGRiMzU5MzVmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJmNjFiMjMtNmQ1\nNy00ZTkxLThmOWMtYWQyYzQwZmJlNjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2kFfTVJXBCgpIloWVg0rv1ITGz6CakysL2SPsA2fv5vIi8W/z8yyJHynTwkE\n3W6huu/jtllLAWp7wTgMe1M5GqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULaoWy+rBHsvGEvLVYS1ahnf9uz8wHwYDVR0j\nBBgwFoAU2AvAdeKqxGDQGy9FktrB4fU+jKkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBPHAS/ymTeg/BAWt19NkhiGCXfKluq8uox\nEgRJCznaDgIhAJ5ahdd6Tl/3Ns2avEVVPmxxx5PcrtrMtnCI2w5NyrFt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT13yUwUujfpSEfgr2V4gkt2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTdkMGY4My0wNmEyLTQ3YWItYTZkNC02NTRkYjM1OTM1ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATs/OZnZVBPhS28Z9ONrkaSQsQuf6VnBPkL7uCgzBmRQLnY\nxSgf3/NHhleiWYcMA0XaoXp1XYXInlHqv8zVA878o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2AvAdeKqxGDQGy9FktrB4fU+\njKkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMFFKJzmdB2Qcj+fRt/LG6NJIPURLN00UJYE1q+FqVK6AiBJgKMyHzUx\nLzK9hsf0EFMmCaeMkezI4CgwiL8i0tWH3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISASZ3wQ0NJTJi00G8LUOFE7OjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJmNjFiMjMtNmQ1Ny00ZTkxLThmOWMtYWQyYzQwZmJlNjdiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzE0OTQ0NDctZTUyNy00\nMzhjLWJmZjQtZDFkYmYxMTZiMzcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ni+pbYG7kPOOPUCZdsM08C+yuxG9OzycWmkGrqddDFtc787Zbfw6aUzApqxI96YPo\nAg76c6VexsbZ/Xegrj27h6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULaoWy+rBHsvGEvLV\nYS1ahnf9uz8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBW/8xu\nzgqiCIONdeaZZoea9wg2TxWSbmjssktvvDuRjAIgMVoqW6Sc5yoHKZhrtQp+sY4a\nKQW8wtM3N8/kmjj6YC8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3858", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3858` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAbozHMe1pUTosvOacLtUlElaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmMmE2MWQ3LTFjYmQtNGQ2NC05MjRjLTZhMjBkOWVlMmJlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdlMDQxMTgtNDk4\nOC00YjFmLTkwYjYtZmVlMDJkNmEyZjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf1VhbNiKCNQsBr7XXDSmI5BhLHUfxJlQtvO1CwR1FlVz4FBojh0eIBw1qOda\nS51YdUQF1KiLsFczAviewFsWiKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5BQYaGrZs9RABnbYZ22dEA6BodkwHwYDVR0j\nBBgwFoAU+6v18VcJQtNIWh6GRGyjIW0pbJ0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA3GrWhfvctcE0MrZhJYENvStvOzEOD9MF\nTg0GI7aGaScCIQCtJbxZiF3kBSNJrtWqUBpVgNfp45ooogS2lWxfqdUmyQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAShXFja/4XBoizJX2soZ3GfZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjJhNjFkNy0xY2JkLTRkNjQtOTI0Yy02YTIwZDllZTJiZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+4Ba4iOs00JudiwaPXwkoLcnEHUbttCFzHjlP7NLPwLaA\nagItRPb1qYgw8Nc0gTmJ9BpPfgQ5NFqOoCyqkcjGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+6v18VcJQtNIWh6GRGyjIW0p\nbJ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKBNd/W/c2u9Uv41tc7H+IFgyKfEuthcNco5ZMwHvAO+AiEAsDh1SakU\nfPX5L1691vAXDTuFs+YQlSvh0f7kvE/eePg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAZ8xp959MgsfeP30N6+7b3oQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdlMDQxMTgtNDk4OC00YjFmLTkwYjYtZmVlMDJkNmEyZjc5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzA4MGY1ZjgtZTI1Zi00\nMmQ5LThiOGYtMjliMjIzODlmZWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n19Us9ZlmTQ7HzDYTmDogaRTDXxUDN+6+KDi6CsDLXOJDP+Swyct9ITAotM0CWFI+\nMsUCp8e2y7/OAwTz/wDBvqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5BQYaGrZs9RABnbY\nZ22dEA6BodkwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAkptR\nGer0Zb8SueGGZc8CJnB4a4H31uwPrSMXRxeDnDcCICh24XKRBlKxheObRb621lae\nuts9eHaIdQ/NiYldPUkC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3859", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3859` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAV/zl6SFM0kDj86BN1epC5sLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiYWE1OWZjLTI5YzgtNDFiZS1iM2ZkLWQxZDI1MTM1YjJmNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU1MTAxZjItZTk4\nNi00MmQ0LTllOTktODA2OGI2NmUyMjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6UEPS9CcDhMmhRCVa1h6K97PuZ9K32QnoQnD7bPwHa4z2sV5mmebMxZW21CZ\nsc9bF1HwbK+46FYAiC8W/Ek08KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmulgQjQB6lT4szbYzzmTwHHu3GYwHwYDVR0j\nBBgwFoAUTKtLcZap7ji0Aw2PTk/95x7cx/swJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA/Pc++cKlDDCq\nR3lQju/m4Mwyu0HCk8RwOsbBcvD/snECIA8J1Mlgifqm5cQkxz3bgKnsR9PSb4Um\nxdkxWhYLPd5r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf3E77HLouGV+4bwW+FGttwvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmFhNTlmYy0yOWM4LTQxYmUtYjNmZC1kMWQyNTEzNWIyZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARI3FsypXYCTO5815wsJEnPFvwddDiqQfX90uoTtwzg0d/V\n3eqOnfiiG4VOfGXUlDcTWlQaLI43QejYqP/yor9zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTKtLcZap7ji0Aw2PTk/95x7c\nx/swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQdJ5n54ta8L7ndtMsLHuavoOiftjByApvnO3YUHO69oCICsbYh7GfBnf\nzHF5/tqcKeeO559PaOChbjXMFSciH1Wj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAWGgHqWHk429axnWY4oh8G7mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU1MTAxZjItZTk4Ni00MmQ0LTllOTktODA2OGI2NmUyMjg1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmI2YTEzNDEtYmI5OC00\nMDQ2LWJkODQtZTZhM2I4Njg2MTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0HIHr2qdywy+KqhnnkCK/xJso5+OwT8eUSSvF+ds/cPmQ6lfDlbzsQrASEC69IRe\nGHXnkhS/5LFvfTBxGrNnqKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmulgQjQB6lT4szbY\nzzmTwHHu3GYwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiB66y4s\nlNwLY2Pg4HbzK/g2vISrALfHsRAOgoyDjf5+2AIhAO2HpgEYK9xNkmmUvwtpjVLP\nTP83qrNUY9sI13XKyhq1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3860", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3860` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQKsvb8wFXBxypEiXL7+J7O3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiZjJiODZhLTQ2ZTUtNGU4OC05M2ZiLTRhNGYyNWNiNGNlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU3ZGQzNzQtNzM2\nYS00MGI0LTg0YjItYWMwMGVmZDllNjM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjamdEQr9nudTQyZjm/ygkFWM4Ty3JNaOtoPMiF4wffZFRfwnb/6fC+2lUowM\nV+smQUH2kByoIqpq7jgojcRal6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlzvB47d92sI02ugyA1QefgO2zycwHwYDVR0j\nBBgwFoAUXY0576HfEk2H/+Kv399mS/018i8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDl8V9eh1i2fUtw8G7Dn6hgs0LTPBx7kzQxSxIK7bqmfgIgZSUMWd3xEhNA\nGn7kwkrQ7Z2S9Icr7bZr7GV3dtePohk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcDhkMrl9HKXjmbFufo6mbqeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmYyYjg2YS00NmU1LTRlODgtOTNmYi00YTRmMjVjYjRjZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASemW+ZhIcKUJTJMI3CeNLD7SPVJZJVjwU78ZuyzCbf/T9L\nbJswT23rACZKnLc8KRzC5f9iKLzUjT7aEuD+h29Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXY0576HfEk2H/+Kv399mS/01\n8i8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS77NEzvvhZ13vmMpCelkbFST355uFUSy/r9rdYmK0PkCIQDW2U5i+Ezn\ntRykS7ptv8sElmHjOhtloWycAlZNEA+WiA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISASJbT6JU7zLlPwsbS3aZwBgCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU3ZGQzNzQtNzM2YS00MGI0LTg0YjItYWMwMGVmZDllNjM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjY1MDFhOGEtMjI4NS00\nOTk3LTg3YzctZGVjMjE1M2U1N2ViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKguCkhOjPy5vmQyb03lNNzKwAAL6UTtgxS2HUdP0GqxVR5wT5GwsyN1jOoNUseEB\nSLNJ0hzsuVaibPN4DyEt0aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlzvB47d92sI02ugy\nA1QefgO2zycwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiB/QLVP\ngsueQ12XR/Vuk3IEF5tBt87eAQHiRHpOzsxdowIgK0vkOLV+vc6Vp/6DD7iPfoP0\nwwD59sCuOIJyMUJUp68=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3861", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3861` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAat5gyuiyfUTY6gcpLQJDEtBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkZjJjYTc5LTIzMGUtNGE5Yy1hMTViLTZhM2UxYTVkOWY1ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWRjNDUwZjQtMDdh\nMy00OWE1LTliYzItNThjNDA3MWEzMTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPjXlVqdfMI4Sty6yxObB4WRltIvfDtjzD6S2v54UAIHaAatAP9RrkFwa4f7T\nz6arbXylZdHPCQluZ7LRtGoZa6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMwedvQXltPT4VmPdH2p8oWP28CAwHwYDVR0j\nBBgwFoAUgHSfNCo5q7L9W4UoHDi0A/W7Ui0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDvD9OBUavTDf+0h9W+eSwkBuqDAO6YiCzO3IGr6eRJ7QIgcN1URx1x6pwR\ng86nfmP1CbSN0bQNbuKTb5GtbsqXCdw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAchb34eqCfWEktA3dy/7PO7UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGYyY2E3OS0yMzBlLTRhOWMtYTE1Yi02YTNlMWE1ZDlmNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASymZRBzflPm8D9TmGRSHKVSzDcG3I6KqfNiemXJpM1Hmf+\nKf1Dxb45jG+3LY4zhSgLn/g8FUMuPaJ2/+8himnxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgHSfNCo5q7L9W4UoHDi0A/W7\nUi0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFC/+q5XYirTIhKHJNmdmt+BMF/LKDvd1pXfn1hnhLkICICua12uwL0jX\nh4C1fnwJjs1GveeuPnirQjAYwSnn95Yt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAQrCUT0Illb1bw1ok2Jd4vcfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWRjNDUwZjQtMDdhMy00OWE1LTliYzItNThjNDA3MWEzMTVkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGZkZTExYzEtYjA4NS00\nZDI5LWFiNDAtZDc2NTI1MTIxMWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9oBOeRTB2iXNiVDo/rCfLbu4Ahk004rZ98G0+MUALkPLUNHzLOXmZ5u+mDVrXrMp\nl/0EJeJjyGD7ash6gLtN5aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMwedvQXltPT4VmPd\nH2p8oWP28CAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAuHmO\ndpAccZxsM4oLmJRIort5IysxOQorUmkmPSxIEAgCIQD9KXojL+ss5k83UrJnTboc\n1gXcC2GCQK7IkrdKKjjsSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3862", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3862` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAaVqNFwquaBWbXH1hAR8cfmFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2ZTg3OGI4LTkyNDUtNGE2Yi05Mjk1LTgyODg4ZGJiZmJjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRmYzhkMDAtOGFl\nOS00Y2VkLTgwY2UtMjQxZmE3ZmYwMzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+QlG3Q1PE3VnXggMM6+JOwgPL8EVrk3GDpojuEKHqyGvzZarDYoxJAACGOC8\n1/W7J58C9I1ePuLIbOSvlaff16OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn62PWHAlibvSc9Z2s5RP0SXMw1cwHwYDVR0j\nBBgwFoAUzPovqtGmZlmnKpY/1NOY2xF0yFIwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBx59DeDWAF4mCESJW5iZcRGLNymfFeGweExZ5Ka4JggQIgf5yedK2m4MLx\ncbFIFkfdrWeUAEMB/9DpqWnVWgQQhHE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVFRDvtTBF9ANGmcLiwDea7bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmU4NzhiOC05MjQ1LTRhNmItOTI5NS04Mjg4OGRiYmZiYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtoFUEVPOEmq/V6IBZwTpWmEpq/J3bdN07Ny41VQKBEfYq\nPrly2fNGKRRI8QaNFHJvGuqcVy1QAoI9laXOkeYXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzPovqtGmZlmnKpY/1NOY2xF0\nyFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf7SrH5C7GtITMZxqwm6AO6bfD76+Jg81a4qqP3sBLlICIBXs2iRYdjQd\nJhJPYW1GseH8diAXO2jl+DugGHR6veWN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAQz4QGLBJb3rQgEWi/4BP9KCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRmYzhkMDAtOGFlOS00Y2VkLTgwY2UtMjQxZmE3ZmYwMzQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGVmYzEzOTUtM2ViMy00\nOWFjLTk0MzgtYzAwZDAyMzJhZGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxAsb5D3uzUba8effLOCcuIakdl3KKAYWuVFZj/8PvfPr/Yx/mZ+6L3uwqxi6DYgd\nPQ/aDkJXXNBz6+aU/x+CNKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUn62PWHAlibvSc9Z2\ns5RP0SXMw1cwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAl2hh\n+UlbhR55/KpE3ao527MbBE18hbkUX/utVc1C5KoCIQDVSIGVrBlVcyWH4gKaDXKe\n979o1nfWUN9Dq0qBVvex1A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3863", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3863` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYubpG8zQ7TmWaXPNfOb7VYKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5YWNlN2VlLTM2MGItNDcxZC1iZWUwLWIwMmFjMDk3ZWQyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdiYWNiZTItZTNm\nMy00YzYxLWE2MDktYTQzNmQxNjQ0ZWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHChVr+3crHAAj839/1yim5GWCYm+biVRc8p0EDU99daXVlYP2Kc3hW0P7/LR\nFxlak+RJaG8WaC9VSDpunmxT+6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxCVhrB9znCZAXy5j23c9K4t+PegwHwYDVR0j\nBBgwFoAU98h52i+Nc+2aLaY4UQgn9MdQM/8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBSSvnyPUTgQMTF/E2krAz+Bvo+qZhVrfbnGYh51PT9\nOwIhAI0TCN0VUZmXbRtjdkclZXdMSamLzy8UggN4dDWl/ODJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXEPsQ/jkO6Cg3oY8O9U54q5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWFjZTdlZS0zNjBiLTQ3MWQtYmVlMC1iMDJhYzA5N2VkMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0k1il9gA55Gulv1OlVEGEHIaFb0qc4o3GAHMWismjNaRt\n0IKDY0cg81vKgPO8EIXmyWxMUVtuhDa4j2LSa75Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU98h52i+Nc+2aLaY4UQgn9MdQ\nM/8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ0d8leSWu72EXunVh3Hn5uFqLKb2tpB/KODfbknD2EMCIQDkVecVI1xM\nxo1dcQY4lQgOOQyZJ8wGSA2teREwUS4TTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAdi2iX7P2vey9lqfCKKLED0JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdiYWNiZTItZTNmMy00YzYxLWE2MDktYTQzNmQxNjQ0ZWNiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWZkMDY1YzAtNmQxMC00\nYWYxLWE4YzctODI5NDdhMTA3Y2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyUJLc8btuOjoEqjAKl5n45a6QrXKE3h9CIbgFb745cVowGQFsZTXFlc981ueb1oN\nuEyBRznObiFUQspVzTxjGKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxCVhrB9znCZAXy5j\n23c9K4t+PegwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAl2Tv\n82t1IVaZ0xweBi/cRJVpZfiF3L5XqO8+hPVkUq8CIHtCu5659E6T0Cs9FQsEdA7J\nfKGOHgen8xjC5fuzZf+S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3864", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3864` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAS79q/KqnZDxaBk260DPD1HTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5MDk5OTRjLTJmNDctNDE0My1hYjEyLTQxMjMwMTQ1NzVhODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJkODg2MjctZmIz\nOS00MWU3LTlmMDAtNDIwN2JiNmU2Y2I1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERof446dTv7E0FA/muklTEwVtRCxxGYMMETXWMnXmFwW/ShzcWCYUrz9a1GPa\nqjpHWzGg7QqFaSRsYaPPbmlkSqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKYFxmBenDhfxBP07QCyk70iBWvMwHwYDVR0j\nBBgwFoAUKeCUunWSfxrJZHnjODWj9fpvpdIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAOGjmyYP2NO+R+Cf9PlgaJLmJnL0vJLvy+w/uYIx0B\nngIgG9ycGzDO+oqOqoOiO+U+U4th7LzZLdopvS2EkVXecSc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXUer7z9NOcjyGfDiTXKyTnYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTA5OTk0Yy0yZjQ3LTQxNDMtYWIxMi00MTIzMDE0NTc1YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8blP++n/T426gPWeErOdwSzAHmvLwuRHx+1CBoZOtrlqa\nib0fGFsWWZ+4oVW/sJKPROBNuWvzz1KtcU4XAhgVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKeCUunWSfxrJZHnjODWj9fpv\npdIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOBorYI/C4HEAIz8GksCNvk/YvbSbKNHg6UjT1UoL/A6AiBClO4TUsmN\nBz+nGIoF5bADrZd+l5Qh2ROM0xW8DhVyEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAWkC3m23uvlc7RU2r+MLc5wwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJkODg2MjctZmIzOS00MWU3LTlmMDAtNDIwN2JiNmU2Y2I1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWUxZWVmMmUtNjlkZS00\nOGQ3LWI5ZTYtNjcxZjMxYWJiZjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAIOQHNpMVNPvMkzDqX/lR0mCwgTv7HrCZJ3qdHAhqiuMvuTQMbYTlvU9yLmqnRuW\nuOq343iAdgkfzb6pLayOPaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKYFxmBenDhfxBP07\nQCyk70iBWvMwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAmIxCP\n8cSzmujftk1y2NRbLxzPrHCwMLQPwFyEkZM4AQIhANizeHDIhfcIXPOjUTYGn9vX\nIpD/fIP3MPPQcw+HuDag\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3865", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3865` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAajoOZ7z8gfwRwYGWrI4swXGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNTAwMDFlLThmZWYtNDVjZC1iZjg0LWY1YWY5NzQ2MDIyNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWMxN2ZjMWQtYzVh\nYy00ZGU4LTljZTMtMmRkY2VkMDNlMjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8QKOUa8Vi4VdWxOzqlnV2P8kg5rZTHvF2kiSwI7Vs8MLrXHDAQq7UZr+Wj3K\nITcQNmNK5v22TqnajShODtB86qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiA+dgiDER/tkaGL2m6wuULbIZv8wHwYDVR0j\nBBgwFoAUM9itU5+ZZ6Dr/xFkp81wP2j7c10wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA9Jo9LDbCfg888IBxoV7lOpyeqoRvryQEADtphc6lSuwIhAOQY\n0OypfnIT85dqZzy3B1zG7RzXv6vcBaGOJJ247Gfl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQtkpPiCBpjmd6NddGQksrBtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTUwMDAxZS04ZmVmLTQ1Y2QtYmY4NC1mNWFmOTc0NjAyMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyzn3hA5l63VZRs17ZzIayjhrp5zc1Yxu9ZcWnBe96Xpn6\n4EmpvqVm2TNWKMY4eLy1QO6wMjBFCj6mCSvmVO49o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM9itU5+ZZ6Dr/xFkp81wP2j7\nc10wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZyIi7vetg876QDxDStK1IcNVhgS3M0Hmf+kV0EXKG3ACIDrYnjZ/+Eog\nSrPfXaY6s3pajUP4ooEX5rbcOTsbDZox\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAeLs6byQkBxOW9qDTahKa+M+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWMxN2ZjMWQtYzVhYy00ZGU4LTljZTMtMmRkY2VkMDNlMjk3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2E3YWE2YmEtYjhjZC00\nYjZjLTllNTctMTE4ZGUzNzE5OWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvVbKrN7C12XQ6vA3uyK015lDLSmJjTihp0uwVd3p849hve1fzwVdPts9NG4vdtdH\n4Ytj9R1Uvi+oPcJaF3PbXaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUiA+dgiDER/tkaGL2\nm6wuULbIZv8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA5LIS\nN0AQn3W5vA5WRdDorVw/MGNmXzTCtgARM9rQJAUCIEZ4TxwP8xaA7qtk4/r3ahnC\nqhUZfUfRER7RFzV9yzha\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3866", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3866` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATt3cXSaR+ErkQm3FQ5X4Kl1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1NmUzM2ViLTU2NjYtNDdjZC04ZjQ1LTNlODE1ZTI4ZTFkYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzE4MWY5NzgtOGNk\nMi00NDkxLTg5OTMtZjQwM2Q5MDE2ODQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE13NeHiXlB++XqJOKQiHOM+EoNub2sUTdlOOBYuywUN/4U+NN95q3h1mAfvm9\nJr5qY+RuPd7VNtHmL3c1o/GyAKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4sys1NzYl1LP1FMmVrjExnlw9zMwHwYDVR0j\nBBgwFoAUQzh1gAxQZEuWVSXigV43lTcsTdAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBc3h4HciVMjOHvk2bQGy8ebLRdGutas2Et\nI7rD6sOCJQIgQKYGf9ccQwA2D0dd2qAfZhcjmAUad+P54VbBLLexRfg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc2tpmtPfwyQbJq7/vmWKBzXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTZlMzNlYi01NjY2LTQ3Y2QtOGY0NS0zZTgxNWUyOGUxZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0l3c7D6lIr0iGVjbkI0Mz+8K6CmgHysVs4dPdMOgjWTqq\n8WJh4VaaSYun9PUWmx058VzgeYRrSWtijZCFj3JFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQzh1gAxQZEuWVSXigV43lTcs\nTdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaCQJt6fYsPacQPYWaoVESX6BKiHYv0T37wzzIZO5w04CIQCtsCZ6cnJf\nASsF4p9Q5CL2KLoXm5SYU9oac318/o+z6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAVAC5dKGimB1SkAy+CE5th7HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzE4MWY5NzgtOGNkMi00NDkxLTg5OTMtZjQwM2Q5MDE2ODQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmI1NjJiNjQtNDg3ZS00\nNWIxLWExNjMtNDcyZDgyMzYxYjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTBDtLBu89PW953Cgz/qgpv0nFvENHu0vHw4PPFdH8hFjliXzvyLGAvzcYVXDabLG\nPrcLgquQViBlUSesCO+9naNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4sys1NzYl1LP1FMm\nVrjExnlw9zMwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA2Es1\nWCpwZDlG6UnqTzv2r6HLG8k6NJTY1kzmv7MEQLgCIQCmW7MUt4sf70l9/fClb657\nOC961jzb0qvTtMPQcR11GA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3867", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3867` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAfwUlCLWq6iHtUJ7DoyMYpAiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyODlkY2M1LTVkZDQtNGY1OS1hMTUyLWQ3NzM4YTllOGI1OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNiZWM2ZTAtOWQw\nYi00ZTc3LWE3MzAtZGRhNGU4OTZlZTA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9QPinlDgyxbZPSnzyxZtTUnADyM1BNyXCzOci+tX0VaowLLd/FXodtuc+ot9\nxVRQiy8/vnAPW+EgZxrUoSPwpqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAKY3JiDi7dOU39t8PB4u/X4IFlowHwYDVR0j\nBBgwFoAU++GCQTjFIRMCzrKsUVdm09wfHhswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAgIlnG4do2/4ZpHd5V1Us19pW9X2XZF/a\nDSMBfIQavE8CIA5Exy6qyxiHMIrTFkE1yGAibCvoAsvghQ/PoQ7y+AJl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVshupDpfFVZleE4jqQFMJ8LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjg5ZGNjNS01ZGQ0LTRmNTktYTE1Mi1kNzczOGE5ZThiNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKqPVw2bPWNF1jncxw1I85Gf/UZP2wcm2UxAR2V5x5ekdl\nJBu6JEtyshFwPGupSPo89vhaNzG/tADUlRoY4naPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU++GCQTjFIRMCzrKsUVdm09wf\nHhswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIGz346p6Nv1Ea1GTaYX3rdU/1OKqSLO0Uuu77g3YXL+AiEA/21AMvXN\nDKMAow2odo4MKCKWPw2GmPgfRwjX8yimeMM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXPvCv79faDny8cgHcUdTaMVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNiZWM2ZTAtOWQwYi00ZTc3LWE3MzAtZGRhNGU4OTZlZTA4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTU0ZjZjMDctZWU3Ny00\nOTBlLTk4NjktMjgyZmMxMGE0NDFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRpz/qzlI1AFpNwV60ruxdphD9F6RVKwPr9zIJKh186sSbZfh9Y54PWBaN2xBBf1P\ndl7F92plyVXnasmFRKqcJ6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAKY3JiDi7dOU39t8\nPB4u/X4IFlowDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBH+CVz\nkBzOe167cI8dlhB7yK7K4o6qhU9T3BFGAI5R1wIhAL/eki1a8dv49eTJn7XDHhEk\nokj+LhfzKRw0CEahPrws\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3868", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3868` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAXvTGycCtEaeBXO/8GuRv3yFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0ODNhNTU3LWNkNWEtNGVkNy1iMjNkLTUxNzUwNmNiYzQyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkzMjYzMTItODY5\nYS00MWE0LTk5ODYtN2IyMTQwN2IyNDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2cal+RR/mo0ehT42JXnXwCIup6Z/IbLVHEFN/q5GEe3mkkllHsHviEC+Pl6Y\nR5+J6tAv2YmeaLxaHYic8jpcNaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfrJ5ZYZZLQj+ykCi5LOR5K8IqQwwHwYDVR0j\nBBgwFoAU0/WoqmYCtd5ecbiCuzKNxpbg0qwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCObCu8Vg9hLY8tHmhPLbKwd1fp\nAkVPwFArFJIygRJJWQIhAO95upkQKnBxDQFLSaevzEFiiWKVNetNlNmHOdXeS3nH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcx+mlQCU9dkppHgefOgZbZBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDgzYTU1Ny1jZDVhLTRlZDctYjIzZC01MTc1MDZjYmM0MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8zjELvqLF6TSoL7GkkcFHjRhOiA0ZEHcMk3uw051QZ1J6\ndl+0gQ+LIcYogN7lav1DNFbWxiwN3wegxJU3R7mYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0/WoqmYCtd5ecbiCuzKNxpbg\n0qwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMak5FoR/H5/fp3NdRdsUxRmbLsSJaXGBec0Qbva/8kzAiEAkjSx3NEt\nm6pMdRZEVfpMlY2DlIOpVtijVvYPb4fNNTA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAetWpWUGk1GeHT5VNMN20LtGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkzMjYzMTItODY5YS00MWE0LTk5ODYtN2IyMTQwN2IyNDVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmY2NGEyZTEtYmRkNS00\nM2ViLTgzMWUtNTBhNjQxZGY2OTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3lMFLZ3gWoEY6tNQBu+IXRUbyIwaK2IPxqjhwAfkl8ACBTTG/RlK9w8mOKC6tGhJ\nZzxhQScBTsI/6rV/Uzc5MqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfrJ5ZYZZLQj+ykCi\n5LOR5K8IqQwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAtWUm\n7wgb15u5W3AdisS+IgumNfuuy+6yvvHQPQ/94GgCIEXFBp5UaAzx2PWpZ6VvreHP\n936T3yINOSPYkk0/9ilu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3869", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3869` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAdAs5eYSZyuSkypaeJFI5FcTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzNzAzODViLTI0MzYtNGJkNC1hZmViLTMxM2Q4ZTRhMmI3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg2Y2I3YjAtNGQ0\nYi00NmZmLWJiMWEtNzViOTM0NjhiZDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi2uCITXH/MIDENsSkyNWPwMOqjli1Wx78DaBPbygEUPGhJ7jYDe0UiB+ddV5\npizhUQe2XwfWTsxNcJ3kTjQvhqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6UDf5wqISxu9TInYurO5gGmxiI8wHwYDVR0j\nBBgwFoAU0ezXGDD8g46SHw8DVA7qz9LWoewwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgasHu/y+9\nLKZMcHaci7+vf7X3Uu49ZxyltaNoTpks7LcCIQD5c4SW48yjMKYCPCWCxxGPh/MP\nfRvV+z0lsh+OP58IiQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZQcIvIzgfKhCTI4/vUYTZCtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzcwMzg1Yi0yNDM2LTRiZDQtYWZlYi0zMTNkOGU0YTJiNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5uw9cDUaZCwg0embB8W+5qxJk+qTE7vYTuSKmMLt0NdpI\npSdryKJ4pgMtUilaNViNhv8ipScGHkepfcd0tC7Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0ezXGDD8g46SHw8DVA7qz9LW\noewwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbG8lsKPWHpTxZ4TF5jXP48JplYd5gTYb6RK7JKf6ksUCIQCKDN5IWhdE\nEx2Re5FrXtJFhLzHpE6nlt8RB9s8AOXqFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAUoR6aL52YVZqVIuTdJ1WNT+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg2Y2I3YjAtNGQ0Yi00NmZmLWJiMWEtNzViOTM0NjhiZDkzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWZiNDZiMmUtZjI2ZS00\nMWEzLTkwMzktNzMxMjYxMDAwMTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6MuwPO6ZAR6uCy0mUFrXK+cnydFg7yEdQL7tmOsMeybT4eQ7UtRfArnOAuXAe6+B\ndX8KgNjmenSfxH9Wp7gdcqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6UDf5wqISxu9TInY\nurO5gGmxiI8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA6Id1E\nLR/3gY68meyVjHdFBm7gbEwy/69eQbjrOuk/3AIgRykEIpMrgusOYUYmkuzJvJC0\nG4E5hmQjqL1hh3bkqfw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3870", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3870` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAYqIhS3HfN0avr+3L7MgbXyKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZWM3NGQxLTcwMmMtNDc4MS1iNGEyLTQyZDJhNGNmYTcxNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUzMTliNzAtNDg5\nMi00NTJmLWIwNGItMGVlNmJmZTI3NDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk8dLLR714obOfQ4CesxGhJR1G/8hvjfIVZ2Q+FzzRkHX55UozqRsmBAbhQx9\nYxYk04fxR5rUIYU77ZMC1+YMXaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Ieshr4sloFJTVHMOMuHahVGkm0wHwYDVR0j\nBBgwFoAUKUeVK4NHmHoKwi/BVX+ITZ8Cx2gwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAO0Iz/zi\nciYd3XfbEuGk3Zo9eNct9Pc2jGX+SY7dcr0rAiEA+nNUKRQAPoDlspRnx1T08c33\ndzvoCSP+IwkPqnAjqxo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASdPm8lA9kfVFyviWwvffetmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGVjNzRkMS03MDJjLTQ3ODEtYjRhMi00MmQyYTRjZmE3MTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStA+TMTwJOE7fGNaJ2YSjfEyDvKHJRX7WkoiQMu4Dn7pmy\nywIzLQQCAlN9M4hCwQrCxQdlS0uXLWfC4Q9HOflWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKUeVK4NHmHoKwi/BVX+ITZ8C\nx2gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGPU2hp0pL/xFyMB872xPHBZNF4gjjdDAHWHEeauJrVcCIQClQEC7CSYe\nF5dZi1z1hUIccdXoLBcZHQeGitTnmnd4YA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAR0D16BRS46rgHocVfIKkOcwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUzMTliNzAtNDg5Mi00NTJmLWIwNGItMGVlNmJmZTI3NDVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDk0MTYyYzQtMzgxMS00\nOWQ2LTgwYzItMGFlNDYzM2I2OThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nz0D7CwlX9UqTLq/KF6JWcW83WBXnKmtQYX7gN4l13sFEh8vJalKJ7jxgqXLaIjJT\n+f+AzlBmrE+tvzHh2Ouc9aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+Ieshr4sloFJTVHM\nOMuHahVGkm0wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA83MB\nl8a+Z91r+UjdRHHcQMiQm3i+ueM1mStLpu7+77wCIDcclapK4uZjXAIKurq8dF6e\n824Ue0ruuIWR7dHPUX2F\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3871", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3871` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAcSHLNdW8ZKd/k/mb3fDb4tVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZmM3NmQzLTY1ZTctNDc1YS05YTViLTA5NzVhNWRmMjU5OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdlM2QxYzMtZmFk\nMy00Njg3LWIxYWEtNWJiZTRjYWYwMjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq6Hk5KOmhHxpHr4r/wtdMFjZI/nCWkogL3E/m2tI/fAVesBPoOtw4DoQlDA2\nBy624aYQx2xrds/AzRvBjQ1mp6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/tI7KlbwMhofIyQqOoebsbUtOeMwHwYDVR0j\nBBgwFoAUXRqrMR3CGp62FDdHZbM804b7Tn0wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEu6W60l\nIJBCA9ZO/Gnag0M6FC5bj0hhhFfM1Sd5Zlp3AiBarx5GDYHwykvhUS+q3is1osp4\nZv3pMyZgIfU1jAVaMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAStIIrBvsOq2avBBDeRJUM3SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmZjNzZkMy02NWU3LTQ3NWEtOWE1Yi0wOTc1YTVkZjI1OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShflLj82yWoyG82dSnS3py831ceaHbQzfDgeNXAAIAaa4b\nNmWzoL12Dlq+nh446NMV3wIwlASUO4ECrLWJEuLWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXRqrMR3CGp62FDdHZbM804b7\nTn0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMg4QyPz71DwXKqUoOvqD2zvmVP8rh2qae842eRVJ3dlAiBJg5abdXDN\n3kaKdp3RGUK1jzVgJ90XcXfdmltXe+KAHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAXledMs6s06eOtyTYhJzFG8aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdlM2QxYzMtZmFkMy00Njg3LWIxYWEtNWJiZTRjYWYwMjgzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWNmY2M4MjctZTA4MS00\nNzdlLTgxNTYtZDkyN2I2YzQ2ZTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nudCqHle2tM7DnNA0oh1nRhor1eCqL4E3BE811ZMG+le6ZLeCaHyV8BnSukr4x8wa\n2lPk5iqXpoM4HKAKlsSWEKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/tI7KlbwMhofIyQq\nOoebsbUtOeMwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiB8D7VX\nm6JYr9/VVfVlR96yLUp+wqKp/HVCBXMXBpMJjQIgfaH/zXCqVdSQ/aI9tyR+2r5m\nlezx0L5aECNPFSad+/s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3872", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3872` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAXK7S1UcX1/RWS2JOVdtc4HtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2MTFlYzc4LTAwM2EtNDI5Mi1iNjk5LWU2M2I1ZDg1MTZlZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdjMDYyZTUtNDU3\nZi00YjkyLTk0N2QtN2U2MWIyMDUzZjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/cHq/rV+J9e7g6KhZMtM7sE2eYh+3x84r6PYvtqjfyGYBYhARU33bMBRZeau\ngIdn6s2S7jLj+AduHGdhrLzcuaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzAkuTNJCZMmR7W9cviHRMe7YKL0wHwYDVR0j\nBBgwFoAUwR/fdVrhXsUGnSOsTmGFmTW9UFQwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCKNpQpVB4EDoaByDOnY8LSIQgNquqa/rI+oYRej13q3wIhALCzOUVZ\n7UqTLbhhUN/rRIe4WpS6XFxcTA/ZsI/xBhdH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARzPu6ZSql/+mFOBhq2DUj3bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjExZWM3OC0wMDNhLTQyOTItYjY5OS1lNjNiNWQ4NTE2ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjEwa1kFVXmBTAiks1E/22midMQ5lIcbA4sluX6bYtL5J6\nllW0pGfOqghrCibqL3XT8zry6P6I3u3iv4pLGmY5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwR/fdVrhXsUGnSOsTmGFmTW9\nUFQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeQ7vonV4pwVs7tvCa/FUc2XQZbAwpalf95aIcDXl18QCIQDFTATATq8o\ntdUTl9w35+g6UYms7t+AempZHvid3Ml9sg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAXmDu6Go4PtC7E9fcTVVSFSKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdjMDYyZTUtNDU3Zi00YjkyLTk0N2QtN2U2MWIyMDUzZjZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmQ2NDRiYzktOTZlNC00\nMDFhLTgzOWUtNjI0MGFjNjhlNjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntPPjcO7uv+s9XSyfFl3EsSa72QqsjlqFIu0uq+9+cFZsTa8rVh7vRKT+Kd3PhXXM\nxiI2nM7QZY/oti0K8wuCs6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzAkuTNJCZMmR7W9c\nviHRMe7YKL0wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBczUwG\nucwIL6yjwmHeqFVGx0jJHniYiBXlgP/WOi33ZgIgHigmBO+v1viknUDdd90kwNLd\n0aXeN2kzs4qu7cg2T5g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3873", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3873` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAUJJinD9AnluHvZsziw7fnp+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkNTllNzdjLTViMTQtNGJiMy05NDhhLWQ3MDc0MTJiN2MxZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmYyNDhmOWYtOTll\nZS00ZTBkLWE0MmUtYmIyMzJiMTc1MWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXirxZOYRVh5sVc/gE8pzVTeLBnXa3z1tI1s5jVaVsfUoGcJhKhFkEIdjin5+\njcKymJTHoWo2YInv6qtDDx1e/aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdE63Mk1eYbc1QdNESPrskqYXpqUwHwYDVR0j\nBBgwFoAUFT7as7w1FBKW8aIaMjiGBuARK2IwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIGW1GQbRVzwPJf3Q4T4Hi958P0nHW9ulTsZd6duw+HFFAiBHmtd1yZa4\n1UtV89iSfpMH25GywyxI0UnhCmxif0ccRw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXDCafYn3tz17DwFCDr29q2JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDU5ZTc3Yy01YjE0LTRiYjMtOTQ4YS1kNzA3NDEyYjdjMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVTc6kXrhJ4/WPw9VDiVUecsc5Xei1qm0OyME6fCE6mVOR\ng0QsEBgwb2nQyygkS0W6grFcc5Mnt06EoK/Y9w5fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFT7as7w1FBKW8aIaMjiGBuAR\nK2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMTbGK260Uw47FJE+u5KLljKGyyC7eJLZ4+3Hmd91pVlAiBfh1W4WFGF\neDt+8VzjNdqUyCLLGlh21Iyi0AKCFNaCRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAW8TENSCkbmIprGajY++mnViMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmYyNDhmOWYtOTllZS00ZTBkLWE0MmUtYmIyMzJiMTc1MWM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzcxMGM0YTgtYmY1Yi00\nNDQxLWE3OTktYjk2NjNjOGU5ZDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1RdJ7hkTIK9txj9pfjEw2SzOceac6pOxoFVa6Pe5GT2qxwFNiJ3+UGqtsv0T9LAW\ni5ia39ry5BYp8sznRl23fqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdE63Mk1eYbc1QdNE\nSPrskqYXpqUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiANdtbJ\ngniYCJB9Gr+DZDCLVZ4NduVtFsMlgtHLZHZ7hgIhAJJlT5ZZMpmkKwFz7KIt4iOw\nRd40BudgEysQwtt+IbJ2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3874", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3874` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAXuytaftkb5/jZPtJMwc+5+OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2NWE3MjYzLTM3Y2MtNGQ0ZC05MDhiLTVmOWNhNzkwZjNmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2EzYmY3YjktYjM1\nNy00MTk1LTk4NTMtMWQ1MTQ3NDI4ZmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoAT82/U9KdRW2bxxfEJpsGFbEUoLn4BjkXA07+Xtasna9Zfts97+YLyF3BzB\nZamZf8thNAP+DxRho1IxSFg6u6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIRpHjVRA0zu/AYzwEonyTUW3Cw0wHwYDVR0j\nBBgwFoAU14Pa3/3BpQq7FqdZyPo2+6SxXCswMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQDQfauf+o1FCd5gvoJ5KxpLuJKL4oNW894/SUAIheyJxQIhAO6ySNvopTePpdhQ\nK8xsIMnGXkd+dRhMsSA4pTqJ9OcC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYtDfWKC3nXW1mDxEDwWBWepMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjVhNzI2My0zN2NjLTRkNGQtOTA4Yi01ZjljYTc5MGYzZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfz7+2/ul26SkJOflQCAVoYkVbMFyRkcJ4TsgE0e3coxw9\njkxKF3jro8lguL1lmXwunhIoxri6b28+xrzNDnLMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU14Pa3/3BpQq7FqdZyPo2+6Sx\nXCswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANlKrFlS603YIPeu9usN5wuPNV/45qgvhsmGjgfY4nW1AiEA+D6FalGq\ndYQPoysmgIVnaZs8gcO2IyWEc0eyEd0RCVI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXssL7EZVCZmdfDzD1i9a/FEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2EzYmY3YjktYjM1Ny00MTk1LTk4NTMtMWQ1MTQ3NDI4ZmEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDlhODQ5N2MtOWUxYS00\nZWEwLTg5MDUtODkwYmQ3NjMxNDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCABRsnCs5bBr95vWczFEpReuDJacmJaM2ZurpyhwM+Xl5ovJrduHmltc0B/aRR2t\n0fqk+PcTahudrSdJUFZStKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIRpHjVRA0zu/AYzw\nEonyTUW3Cw0wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA/EzN\nnkNqzCU0YliAI0m8G74f+YAvpPYRVHpgjWCT1zoCIHdPlDH+N+w16NMU/XZeykO5\nUueXs/mxyGlcaSPzeWOQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3875", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3875` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISASI+YUSveU6tKaGU7N2ySjqHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4ZmY2ODhjLTJhOTMtNDJiYy1iYzljLWMxM2FmMzkxZWYxMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZmOWY4M2QtZWY5\nMC00ODJlLWFmMjctYTRjZTQyNTdmMDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmYP7dzxk1F0XsdBphjYdQSiKHQCV7ydqkvISGWRl5Qhhr5RFKl8frozjk0/z\n1MBugh6jQVf2ROrPUxkQM6DxzaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUirXzs7d0OJkHya/OsQIUAlRZQgIwHwYDVR0j\nBBgwFoAUzKgwSTPvNqUHU/gIY7z6e3kPTSMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIGHufCvc7nWHJ4iMMsNz+v5/dq+Kj4wPCO1am2GI3bIhAiBy\nKQ8gAwMqn08baGT8824rhjhGJyZnVKjBua+hHW0b6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYpYL9SKyEX9wJ/xPzgGqQdJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGZmNjg4Yy0yYTkzLTQyYmMtYmM5Yy1jMTNhZjM5MWVmMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQr7hkp216OcAtYbxpEn1C7t3lAAP95opIKx4XMumrEG6zh\nVopFxxtd21YU5nveRusQlhnU4LzLd2hRqqiAJ862o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzKgwSTPvNqUHU/gIY7z6e3kP\nTSMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY0fOQQB60UbdC8MUINDs7FyoqMEgwR21ajKj6DdCT1oCIG0ImqL6r30h\nrets5ha6V3h6jJA+xB7bDeCsDCI4tskF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASIczpeD8vOhEtXL+vjVIh8sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZmOWY4M2QtZWY5MC00ODJlLWFmMjctYTRjZTQyNTdmMDNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWY1ZDc4OTgtNGMxMy00\nNjgwLWJiNWYtNGI4OWY5ZDg5NWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNXWkDbSlXkJELu9dUDMRe1M1/Ux/lwoWp56sIot7hjA+HHKd8cEBkU6THcBWEoK1\nqgF6Cgh0v7EnrFa0pMs4uqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUirXzs7d0OJkHya/O\nsQIUAlRZQgIwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAul+G\nQ67zcOvK+0WUKyIZ0mh0ZuPPcFUGbfidJZZcZGACIGB3feCfrE6i2jpBr0knkUzN\nDEliDk13XRCDz67gJRxF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3876", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3876` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAeTUd5sid8rcc6y7dvCMgRdIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkOTc2ZGU4LTdiZGEtNGMxZS1iMmM4LWY3Nzc4ODczMTI0MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUxZTRmOWYtYjBm\nNS00MWJhLWEzYzItN2VlZjZmZDFlZWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO0LcMWeOgS7ZETpQe/GrVFFH+WZ+kdZCkEA2AKu+z1F932hMJV16DK1mHMqL\nE4OTov94XMAVdP8yJGkUul24Z6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHEOFnV/Z1hOPK83G1DMSsz2ASYUwHwYDVR0j\nBBgwFoAUK681E5Q8LfNqHBQkv3v0nmEOmOswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDnah56lftDfDxJB3lPqsfCmiQoXikiUTQKLtsVIV1W3QIg\nHTodndQuD2gzKM1vKIwTWguPNeuyozd/9WydW3liO60=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT1pBqYuCR3HjhqQlOfVCSXKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDk3NmRlOC03YmRhLTRjMWUtYjJjOC1mNzc3ODg3MzEyNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+3VIyi/66qX1q14KVwcnqZTu/X7Ctnv0ANClQCFktsR5u\nAC+6hSJwRKhdfMil0wVTe+l1MZ4HCLSO0Ers5gOko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK681E5Q8LfNqHBQkv3v0nmEO\nmOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOVtnpr4Ed+7qXYq7DFyphZPkhS2Q9NgSbzca1Mqw6/cCIQDHiqimXtuH\nWQUtNKYuD3FnvBpIIkYkDPZg+ZFWoRBmlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAXyMr28SYb/nkmtyFrtiEOxRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUxZTRmOWYtYjBmNS00MWJhLWEzYzItN2VlZjZmZDFlZWU2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWU3MWYzODgtYTU5Zi00\nYzI3LWI4YTAtYjZiMDkzOTFhNzk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZLBowI2Lm2WONgXhu1rXmYaV/N9s39rWVLhPNJ3gpNfEOYUoH13Zhfbsz6rxBNZG\nCNBfoAsZvx7Gt/LBtNGNS6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHEOFnV/Z1hOPK83G\n1DMSsz2ASYUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiABMJ0L\nxPOyRZiEj6J6whEbPgufwm7medmz+hCvRylGIAIgc7RAnd8AJDZrhpyVN4on4VF3\nCtrv3v0SDmWAiCWFnvY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3877", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3877` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATwHS7f0vaeYQBz9UoycyXROMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhNjZiZjNjLThmNjItNDJhYi1hYjFkLTc4ZTRiMTkwMTM2MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZiN2M2ZGYtYTcw\nZC00NzRhLTgyMjAtZTIxM2NmN2Q2MjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnQ6I/+Z+POJMpCgBIxPn4e5ylcXEQVytTNkcUvpE8yk7vLNSzKWCF8oRXlbL\nCOHbeH0n9a3G8xb7s+7whRwXKaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIRMtOgoHEEk51ZSOu08A10kV/3kwHwYDVR0j\nBBgwFoAU9GAjckBYVXZYBXQi+UlPbznhK34wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC5no5WyIfn\n1yq59DQnM+YTD8ySh4HCO1Jbq4SAIovTVAIhANSG5ID45wVq6CJmKN3tsZ/vYyRT\nfnRG5LrhtKxlJbQL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATNVw9t1AIQfPDWALSJIscK7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTY2YmYzYy04ZjYyLTQyYWItYWIxZC03OGU0YjE5MDEzNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWQkvyRukp4qxKTmqf9eTqabcu7kyvLnKmzCL5ysRCiWF6\nxirLc/xy5lxmuqm12PPUonQE117topfX0awrhkqho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9GAjckBYVXZYBXQi+UlPbznh\nK34wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKjZ5IYWADY9cuSup3/zSGFZ5dizFVMIsb/K8WSHAHzoCIHATptMS0jQj\nHfG5/23zUfO+vCfgcf65T35/FaLAwAT8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISATV8EZ3z/uq7ysLTPIVgfs2eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZiN2M2ZGYtYTcwZC00NzRhLTgyMjAtZTIxM2NmN2Q2MjJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjUwMDQwZjMtNmJkNi00\nMDQ2LTlmNzAtNjVhZDdlYmUzYTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6T42YlgmRDK/gY1zs+dJy9BFPw/tFWjam7KMCD1PZUJtMHRET+f64O8UJarXBRCh\n1izJfxk20Uwkn8EwpPwPdqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIRMtOgoHEEk51ZSO\nu08A10kV/3kwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAk+ip\n3RkpPNTGvR0cEjH+oeX6a854JzkX/f9EA1d0V/ICIB/6Nt7X0HoJdKZYtOl3z3B5\nMWPZWJZlX9q3lw6lkXTn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3878", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3878` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISASTSQMKiEVmX/Z+ayhmtvtEnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzZmE2MDJjLTU0MWEtNGQ1YS05NTcwLTM0NDM0NjY1OGRmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY5ZDBkOGMtMjRm\nMC00OGI5LTgzOWYtYmZlNWM2NjUxNzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdDDNFK2cm6ayGyOLV+8EYY/iLmrBaOOhcI9mMhsbDpjjH94nHpmgaujEq3Tz\nBS2xX2vEhw7cH1YidUoillWfSKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCqSt2sz0YrmpMPJzyFslQtdHVYAwHwYDVR0j\nBBgwFoAUdvC3UpWfkxtIl+mJWGE2uhzVc+cwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJLY+Gdt1McSseof1QI1GrNMAR48F+yvZx7Tacri3G/LAiEApTDQBxXM\nZfZmObcdNIVVbdJTcv0EI7VUquphlQSsSOs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ3/TYGOIcZIIeiQx3P9x407MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2ZhNjAyYy01NDFhLTRkNWEtOTU3MC0zNDQzNDY2NThkZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhLXT2rcVek3IHHbC569nNVPlp/O5fQoLaCoadekjdJ0np\ntsFCWUQJTDXwnFBNcH8B0rRRgfmiddhprFx+5w+4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdvC3UpWfkxtIl+mJWGE2uhzV\nc+cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKYjiJ6BO0nRHYKrEayiRoEdr1eCrG2cN+9tp1hANEtIAiAVedy8ZnQW\nnb97wtLtsZBAGwvKYoIA0iPoVISxIuEhuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAfC2hFgcwMp5jE4G07fDRFZIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY5ZDBkOGMtMjRmMC00OGI5LTgzOWYtYmZlNWM2NjUxNzM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODFmOWQyYmUtYjU3NS00\nNmYxLWI0NDgtMWQ1YTljNzczMzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4176K7dPiNPYf+4BGMsVAV21+ZKY0AwvlLu60vxd7IwDqlKT+BYpfrktm2oNJTXa\nxsJ8yLXKR2fYDwdQ/vNVR6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCqSt2sz0YrmpMPJz\nyFslQtdHVYAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAgoiQt\nd7xitszTOD2R/wZWs+ZqutdQWyXfkB2AWpXrZgIgZsWe5YPjZVZefScXC/g/SPkJ\nJv3QAPBjK7nNBOGwyfM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3879", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3879` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISASztTuyDIUhlxqG4ZLn2xfW5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMWY0OTRiLWJjNDMtNDI2ZC05MDFkLWEyODFlODQ3ZWY2OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNjNWJkNjEtNzA3\nNC00ODg4LTk4MTAtYTBjNjY4NjRiMmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw/48wCXBj7l11oN51Hc1ZPorveEUms6nSkkD/AEOugm2Imw+LH/+w9EsMch1\n7A94rkoX93oqJHyAS+j9tXr7RKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFnQwXAxY6RcL2xv4QHmypKxMEJwwHwYDVR0j\nBBgwFoAUwSZLNwmsl7s1WlBlkXhzLmdzz04wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKj81+MRh68/qO1yWNNbA3khR2nobgINpzha0o217Z/jAiB/26ikzADL\n+sJaltUtwx1AnklifWeKKzMbjJR4ymZw9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATWDet9WjbcKvBZ9xj7t/N/BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTFmNDk0Yi1iYzQzLTQyNmQtOTAxZC1hMjgxZTg0N2VmNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbKBGBghnP8e45y5KdGN6ub4rTOUwBQ1BltuiYRHsCEcS2\nOfjUpT9CZJYWrX8yarsCOkqgRlScdbzNXyS0EhpTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwSZLNwmsl7s1WlBlkXhzLmdz\nz04wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN892AaNYP8lp3+vQqwAjzPxkeqzv5oixGTIJAP3Vc2UAiBfzZOgBfG5\nafaWvFIVYUAHLTTLSDCO+bT69hdz7Kg9ww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAZ2sAvNX99fSIaCX01wcw+K2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNjNWJkNjEtNzA3NC00ODg4LTk4MTAtYTBjNjY4NjRiMmY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjAzNWNhZGMtOTJjZC00\nYTcyLTgwZDMtZGFhNDU4NDg3OTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nb/wWRorjxJ00Dsj8c4pDq1so/Siily8oQvACFw88HAzjXztrgYA+TueoN1sWUUyM\n0gS7WBII0IaOJ/zXTJcReaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFnQwXAxY6RcL2xv4\nQHmypKxMEJwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAj2bo\ntl5ZYVTtJn7kTXJW4yaC71D9lt72g8SvMROT3pYCIQCcvqy4kK/29s+0DUXZ+39w\nDDQw0IbASDtAPQkoCVktEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3880", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3880` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAZnp6qkglYIrsIVptSqiy5QLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyY2UyN2Y3LTdiNGMtNGM0Yy1hNjQ1LTMzZDQwNzVkYTk1ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE4NTI3ZWItOTNm\nOS00NGU5LWE0MzEtY2YwNmMyZGI5NGNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnlcoPolucwxd/I3GfQSmaZ4JHLlF57zvdcPOThud4AXBGzZn2i8BEvyawjEj\nfY7xlNiWZQM0JzmG2xrm6R4xgaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/zoE7LryJHhfPRziMZI7MwdJlMMwHwYDVR0j\nBBgwFoAUFd5mCR33rn75JwitHsm9g0sFqKMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCaIL7xXYQcjLuUSUc4QgqYKIglhsjKg21Y9pOySM9UgAIhAIs/6oMF\nKtEwDak4kitjmmEP2lRjnnVmuhNZdO3jwrXU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdT88qNFRyRiz9Yx0l5oM2O7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmNlMjdmNy03YjRjLTRjNGMtYTY0NS0zM2Q0MDc1ZGE5NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV5YgPHX1lK2w83eXzsQTWnywQRxBWtlTd85U3hAAd3U8K\ndw+h+HZ4P7g2lPhFZuJcV7PzjIbF7X/WyC0+qT99o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFd5mCR33rn75JwitHsm9g0sF\nqKMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA0NMrI8bYzNcHmgYQxQTK0+dZ9EvXTiMMOpAEu01kSUCIGVV8KTUw0bK\nvqakUT+SwG3uuHzzDj7ge+dszELKVWzu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASjM+wY5NY5In/9Qc1OglDlKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE4NTI3ZWItOTNmOS00NGU5LWE0MzEtY2YwNmMyZGI5NGNmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTc3MDg5ZDAtOTJiZi00\nOTdmLWJhYzUtYmQzMGVhZjBjMjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNwcAgHrRngy3kG5w7UbhrW7Cz8/lg8/Zb27Sdlo4nLt3/d5e1pGHJA/KjJ4Xn42o\nBB2fyv4osNWsmtmN1KIjJaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/zoE7LryJHhfPRzi\nMZI7MwdJlMMwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA8qN/\nr3vn8iUjuq2q9HsLeCvd1K7lO7Fh5JVB/1CviMUCIE3WTzaiK12Wnd0wlKHn9inM\n0fqFeAHOE/eWxbHu6sfG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3881", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3881` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAaVAfFV2LJDjrmADXnA7xKjGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwN2YzOGUxLWY4MDYtNDlkYi04NWQxLTVjNDllYTZkMGU5MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzAxY2Y1MmYtZDdm\nZS00OThjLWE1ZjAtYjc4NDc1NWY1M2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExDn7UA5S9bTkUetwlHfsydtfQesYevabqaeVabrAYcQ0U9WIDSENEOlkMcYX\njEfnfExCj+F0LM8p7x5LhHUO1qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQrREbspczckEo2tCrIG4bgmHFVMwHwYDVR0j\nBBgwFoAUyn1WDFuWEYrUcLDOp22Tuqzb5K0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDpeF2vj3V2Dh3Mq4lT2v0rrOhy2pOlfrVoD1kib\ne7w1AiEAods+RJhMOusDHi2cwpon/dABtJODkOKyzw09Pdn5kVA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbjHlL4/1jXof/nwxViuDUHsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDdmMzhlMS1mODA2LTQ5ZGItODVkMS01YzQ5ZWE2ZDBlOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3RgPVUSnyuOke0dUnKu6wOxx1WjzBAqLr/xEi/TacmWvB\nJ1qHWYByZ2xsS0Yte5P72iay1ax2gUnM8ibJQjg4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyn1WDFuWEYrUcLDOp22Tuqzb\n5K0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPvOEzqSOecyTP992Exx9aBNA2IUPxmDh2+ZvabsJxbkCIQCt3Zq+OYi4\nbP3HDXxcTrg1yWjYKFEencyUzBFisdYaPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAZKuBfqXWzwZ/vT6YIPAFAWxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzAxY2Y1MmYtZDdmZS00OThjLWE1ZjAtYjc4NDc1NWY1M2FlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTdiYWIzNDYtZWYxMS00\nZThmLTg3ZDItZDEzOTg5YTU5YTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAGPwB1lSrCZt8HpA7tUBj/Hy3CT6tK9/Fpj5kAo81oFmIcaUz4jpumZpi6eRPrZ7\nwa3kL2bq1SVVY9Wyt9hzl6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQrREbspczckEo2tC\nrIG4bgmHFVMwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAz/Y+y\n/YIF5PfPg8LppO9j2gTj6be59u0KfgpNgT2UowIhALGXBX6vNWSl5HmV/IJUrk7J\nqD3Bu9kPyg0krdI7KPQ9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3882", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3882` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAXzDijQleX10A3QQZaSeIAjAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNTM2YjhkLTg2NmEtNGJhZS1iNDA5LTM5YWNjYTY3YzAwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM2Njg1YmMtZWNl\nZC00NmYxLWExYWEtM2U0N2ZiZjg4ZmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvQJ1ftzoDp14aOYuzuG+4QK2xUzLYt7L+lI1xHkpQ5vK7N9xBSY6XQrTJjMF\nOLXpG3AJSXlNw7qqt2na3Ze/OKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi3gjXlC9ONkryWGwq3hDLrEUFCowHwYDVR0j\nBBgwFoAUchulQR3nNiEsTawW+x+HynChoqMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCyALDoLojn+vf7/q/GX4/hN4DR0hdup2MgJTWS\n3r1/IwIhANggYhhpiQFYSg53YE176OD/WPCpLgwtYgW/Vu9gQHVd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS+JA0eILpBaaKgud1Psldq4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzUzNmI4ZC04NjZhLTRiYWUtYjQwOS0zOWFjY2E2N2MwMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyZfPbUzsRZ/WpElcfxd+xyZc1u1EDzjkJ2m98vcngsRjE\nwlr+YWMhAJ9gE54Un/Hd2X+XlDtwWn9qqujQLAKUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUchulQR3nNiEsTawW+x+HynCh\noqMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPR1fqQIb3pBOjLpV/ozijcDhB6pawdY30lNsoq0C+rpAiBVsbvLMoyK\nkSYI4cyg1X+UJ3FNK2z2Vbn7bNlGpPp3lw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAV12BNvPe5MiHnOudjWk0UsAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM2Njg1YmMtZWNlZC00NmYxLWExYWEtM2U0N2ZiZjg4ZmYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmU2MTc2ZDYtMmFkMy00\nYTA0LTk1Y2MtMWY4YTE4YjNkYmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nirH581T6MkKeL1kmKKCDlN64B6uLZtoQw84ZHMBliFZ6Nl/rqL/MYi2ieY3SSNt1\nEzdexK9PLx4GVVddgIh2yaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUi3gjXlC9ONkryWGw\nq3hDLrEUFCowDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA6CiB\n/aaRxcxki8yhR5LejEhe9JX+mXOpShr2m71QxPECIELHyF6IODqiRhr7kk7zQ/bo\nGQlEOj1YSuYqlglUhxj/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3883", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3883` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAajbynrsrTvKPvlhMwIG1y/1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjZTUwYmMzLTdhYmUtNGQ3Yi1hY2E2LWE2NWEzYTZiYmFiNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmEwOTc1MWItY2Y4\nMy00YmRmLWIwNzctMTkxZDNlODVmN2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw5dK0AZQVTrfp13xwY9UyH99G3POG0tdY8mpy7Sie5a8QoRZRyVUbNDOcpNa\nyJYGobk48YscV1DgSyo5FpOrQ6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0iWmPRWN60R/PdIjxJnPvrPgvJYwHwYDVR0j\nBBgwFoAUfXejE4E2OtH4uefclu3r7uz7WIQwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCXDzh0HGQBFEfp7D/8uAMrdiCls8+5K+tbec94+ss+FAIg\nDcqOZ2YHZo9/QG8brzRA3mBz816qYa0NLO7bERaGOG4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc22XfQyaCl1SDKVW3rZ1eXBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2U1MGJjMy03YWJlLTRkN2ItYWNhNi1hNjVhM2E2YmJhYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKphYXB82vORM+T1UUOVGbq+aAAnR9G0KHDcpyXuaDkins\nSnzl7oCdk+BZztGlkSV9UGmLvFgmyRJXG+mF+lmlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfXejE4E2OtH4uefclu3r7uz7\nWIQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMLpDx1tTaopPIxetZ2jhTYWf7zkYV4DxgtqxVBSuXgZAiEA99SyOO9i\nGUHXn2zbLkPzVKJ29WDOiX7KlseXFVHHKTo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISATyleaggbEIiwhsdNtn1xoLSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmEwOTc1MWItY2Y4My00YmRmLWIwNzctMTkxZDNlODVmN2UzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWYxYzM3ZGItMmYwOS00\nOTFiLTk1NGMtNDFkMmVhOTRiNTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nI8GISLE3aC+CdVmXoGu04Uq7OHwccBYk0HA1uUiZkeZ2NwrzoLOADRlpBCscNLyH\nmnvvhFByfiDIZLlC8kRvXqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0iWmPRWN60R/PdIj\nxJnPvrPgvJYwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAx+C/s\nWu5sL1EML0MYVdqv5KBn8slKEKHBuRcVxEeDpgIhAKnediXY24a/0+2IErrggsk6\nitbsHCAWgxfDMZiOVWeI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3884", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3884` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATUTAtMBJLFSxhpx+1qMDCocMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwNTI2NjA5LWUyMmEtNDFhOC05Yjk1LWZhODViZGQ5YmM5MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTllNGUxMzAtYTE1\nYS00MGRhLWFmYjEtYzQ2YjBjMGZlNzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgCyaNe2y5oI7tge+nldUwB+fhTeIPVgG/tQKQ80pS9xb93By2YRtjLz9Kc7N\nj2W36M5S+030rsTvHyrsripyBKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaNXbJ1Wg75aQA68o/Y90W9MYW+EwHwYDVR0j\nBBgwFoAUqEsMJ/HCKq7mUiAokFJx/x18XdIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIB/c6g2GtmmWkwf6QiQpRSUxhBBsAlUo\nPbpVyUG/myytAiEA/aIEpmqpXFtgXmJ99P9OZEM3+oOAigirVlNWnqjdgp8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdacYthwQBHXH9QqObGwoxjaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDUyNjYwOS1lMjJhLTQxYTgtOWI5NS1mYTg1YmRkOWJjOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRbcffUaoMy5HeG3b/dFXIh43Dh/wel3xljn1F5AstX+LN\ncvYPGLgKKfNI/wyycnuJea5BCUDiJIh0sRRAtoFGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqEsMJ/HCKq7mUiAokFJx/x18\nXdIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMnSa4bp18qiD25Wgz//nZfov7S7Jz729ypus5h7LU/VAiEA23BHpkuf\nsb7P3dip8KRg2YapOh97l2uwyplsbPwNOTc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASYsA7hHT2af2Y1z0VAUJlIjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTllNGUxMzAtYTE1YS00MGRhLWFmYjEtYzQ2YjBjMGZlNzIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWY0NmQ5ZmQtMDRmOC00\nNGY3LWJiYzktMjdmOWMwOTlkYTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncU2vxWs0wZnM5Bgp8IDh9h+VLFxXUknRfIqcVXjRQnhhV2inxjSzhC7zFmxZSLci\n8lMW1D0x8hBVx5imEkmzFaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaNXbJ1Wg75aQA68o\n/Y90W9MYW+EwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAk5pm\ngDQxu1jzw8k3dK9vKhYXgRCnsGXIVMGC0Jum6n8CIDC6g4XNrKSd2AhpDMZHLCix\nuT8fZEhd3q9fqYzj/t0H\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3885", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3885` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAWFgksp4oXyMRqEzryte965OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3OGVmY2RmLWJhOTQtNGY3Mi05MWIzLTQxNGU2NjI5YjA3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJmNjYyYWMtYTk5\nZS00NGY3LWFjOWUtMGEzZWU4M2JkNjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpEoVtMwYmIXTiow3b0QzBv7rBxbgqOv+YA2H0mFXpbIYqazI0wn9eWZmg8oo\nSrHmpJA5Lv1p1PSCp9FT3f8XEaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUI1SDvWLSDRz0zV8K6qDcGpD66owHwYDVR0j\nBBgwFoAUUZhXu9yKglMmN2z5hrOI86XBQfUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCICUvPmyHOezdl4z1y5HU/AQIdBC7BNyp\n49MseAlK6d4WAiEA1XqY5w2Da+4t4OTuqSEN+urSaT+qkIVuRqyYDgPnEi0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZSEOHtRDs0HiA5ZAwk+MxasMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzhlZmNkZi1iYTk0LTRmNzItOTFiMy00MTRlNjYyOWIwN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS222Rx/esmEpq0YaAKvcDcOJDPIQYhNfvB62nzTc12Huba\nlWUmPFsf9rpxnBX6u9nQJ+mPQVYNenf3X+qkfCrQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUZhXu9yKglMmN2z5hrOI86XB\nQfUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAImbZBfNF5g4khGznaWm2xOPJhsQL8HtDgOZt+Ia+nNqAiAyQe9rjqfn\nktjIeYYhp/BZhBm7WnrXqvxlaDEJzQ863A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISASoI/kYpm5oMdfoaBJAxj56TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJmNjYyYWMtYTk5ZS00NGY3LWFjOWUtMGEzZWU4M2JkNjY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTQxYjBmYmYtNDhjZS00\nMmEyLTllMmMtMGYxYjY0MGJlNTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3wVGZpEIZ2Au47VDOwZvDCpW7scqvu+50u1loSFlFtFGoUYFtiqZKFn8k4af9oal\nm+ccDpJ9SuxyhWPnLKW0l6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUI1SDvWLSDRz0zV8\nK6qDcGpD66owDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAlXlv\ngSWcUr7hbTYfOrYrocM8eeFAbaNX/dJ2HcIP7JICIQD17A7B8bpeczI9PcuH2+zu\nAWvbJanP3MrXGjqvAPwR+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3886", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3886` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISATc6xb19D0H7ZCoN1eMmSg5qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjZjYyYzNmLTI2NjktNDBlZC05MWE5LTE5ZGU4MmMwMTg0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA5ZDQ0YjAtOGQ3\nNy00NjZiLWExMzYtZTU4NDYwZWJlNDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXMXu+ZF1wjOc4p3gv1HMyslJXnA8CkP7JHBljmVfTglmMf74POtaVbFRI08B\nw6AMpMIG6Gpb13vmEvVkJsVjBKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO6YXD2rCWhhA2eqQZW+zbhUO4qYwHwYDVR0j\nBBgwFoAUS5ErO9nhakBOEdu4AUIh+Yuz2q4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIE1SunAwgG19\n52fHmlF7rlkVlNVSrkvQHt39YLDBXuqQAiBZyIZ5XYTVCM9+dV5vLupE6GzMXSkG\nYJEZAH6m9CM1gQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARVEC19oK5590jFeEXuOsWAyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2Y2MmMzZi0yNjY5LTQwZWQtOTFhOS0xOWRlODJjMDE4NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5iaWvsa7mJbszRlwynRpW9nhAO9W3PFjNpMJwRbkctxlc\nBktGgl4lvnpZa8F+afb2dKq8Lb+8MnjOVBgCjm1Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS5ErO9nhakBOEdu4AUIh+Yuz\n2q4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaWZi9HBNlUU+LcaDsGQ0e3UPYa1IBWEa1ihomYL65o4CIQCSxxwNeASe\nveqiN+XvKVGZPlj+G/mUGWz3dl52eAX8jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAWAi26vo8JVae7jwQVW7SOehMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA5ZDQ0YjAtOGQ3Ny00NjZiLWExMzYtZTU4NDYwZWJlNDRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGYxZTAzYWMtZTkzNC00\nODBkLTk3YjItZTMyNzQ3MmRmYzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXwNdBk1xmqtU1L/HhZqLxj3v89WrIjSUaUAz7Enyf8KTyriE8wTLLEI26swSqKrv\nmtt0crrZ703W/XcDa2Tf8aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUO6YXD2rCWhhA2eqQ\nZW+zbhUO4qYwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAoDqa\n60tfQg5ncV0Ymo92AHLQOMh5cAz6rm0maiBpFnwCIEH4BU3AQAB1TaoC6k7/b5KC\nFwzxoRe4KejVmzRIhlcV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3887", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3887` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAbLnnDRdtt2sV87V7CCRf2K0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyNmIxMWQyLTVhNjMtNGI1Yy1iMTg2LTcwOTUyN2YyZWI5ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE1NzU4ODEtMjBl\nZi00NjU4LWE4YzItMmMyODRkZDM5ZmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcSzEh0HOCVzQJWctqPuwX/x06Kr9gqYBVzeS8tQ76q9iHIDOT0o0oZSBnlNo\nHy7wMf5Reu+U0cKIcDrXqyraXKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwuuoycfHyVR34JuGMTNy5zNJ/MQwHwYDVR0j\nBBgwFoAUKwFFwtzCVJvGHREBMGIxnp3AP8EwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAN26ed8G3kC6CkGntstQWiIn2lXzqbyZdrI3y7NhwzLaAiATNXCN4dT/\naOZ33dmEOwZMe/gWgSEuwX9qHgFVoY0nmw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW07rjHtI7risSd41zHKAc18MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjZiMTFkMi01YTYzLTRiNWMtYjE4Ni03MDk1MjdmMmViOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASy7RBv3lOnKeueQzMQth/mMm3bfTbwF1HjuDjkEal0CpZ6\nY0G64xEuBgMWSqOWt4v4UEVbwvG/sgkJYfHterMro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKwFFwtzCVJvGHREBMGIxnp3A\nP8EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKvp7StNwKfSkrVEpD7nr2hFhyXkCFlu1j0tjXQ4KgyMCIC4atZCS3C1M\nnmLR3AwhcTpmNVI4vttndA1pvUOvlh0v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYgV+Y3e/MUilzIzjaKLwGgMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE1NzU4ODEtMjBlZi00NjU4LWE4YzItMmMyODRkZDM5ZmEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzJjNjdmZGMtZWU0OC00\nY2U2LThiYmQtNTNjZmY1YjM0YzQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nThuK2OC/LDjFVplPdye5r8dFcf0QbYQlQDne8PAiindJuz9lc+74OCyeK2/EGNS2\nZFr8Fl+Udh3g/WlK8h9sfqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwuuoycfHyVR34JuG\nMTNy5zNJ/MQwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAivZg\nTDH4/UztA60nRJ/ybR+IKIzBddxTh+JDOWyvfPkCIEwydDkzH8U3VBk/5bEbphdA\ny9+nWqLPNadGPVZsxAeW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3888", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3888` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQBIB8ecTRZv63kGvu8noqs1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmNTBhOTZlLWVhMWUtNGEwNC1hZWNiLWQ1NmZmNThjNjJjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2M0OGRmMTItNmE4\nZS00YjAxLWJiOTYtNWQ1MWU2YzNlODFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtyOLqnwREqal4LY7DbtIRmqp3thpYWZWTNsPAsNqXePjjqPBBTAq9hhYa6Ut\nmLhRYa8axIWkSgqL37A1F4PpGaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURDuFl5jcQrBFDxqvCZyIIXGJqAEwHwYDVR0j\nBBgwFoAUa/QWvYxSs65KneJ77VkspsaERAMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAM5wtUqFoDaD/CKOIn72DY7wZbtaF6R8zcov5ihi+SfAAiA0uPcrbgra\nFUWztzFtNMuxjujXbEoByDeIN/lg0EwvLA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARCyehmUDHqeY0cKHAPP4IihMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjUwYTk2ZS1lYTFlLTRhMDQtYWVjYi1kNTZmZjU4YzYyYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8acJF19gQHfpnoreyfiaU+tQmy78H6CAffC6JpkjyMF4U\nNKhlkiYIE8hyDb24T+8clqYRBWzDoQt0fk/pivuMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa/QWvYxSs65KneJ77VkspsaE\nRAMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOErgv5xFRs4KQmaST0UFQGV/VR8myc2PcZzKzh35XlqAiEA3Ahm3HYR\n7VWnCsm1Zt5CTZx5BcJAETXCdHC3VPtidU0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAbM6sNZhTlPv6QdOtlaWxU7IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2M0OGRmMTItNmE4ZS00YjAxLWJiOTYtNWQ1MWU2YzNlODFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjhmY2RiMzItNWZjYy00\nNGIwLTgwMWItZDkyYmIxYTRjZjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFfVNeCU5w3+vt674V79vXD09LJl2vt8SWs4ZgzGEsKveHo9Xj/mCe15BLB7xNMjd\ndrg0+/8ZW9m7anhjEbZIuKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURDuFl5jcQrBFDxqv\nCZyIIXGJqAEwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBaTG7L\nPs4Zxz5kWfhD3++VeFxxv3XpdmudE6dKZx3kMQIgBFYlds8uq47H0c3bdRFEf/Sr\nhaBEFWu7HB5cpFCSA24=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3889", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3889` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAYcZnW1KoIaDX+pCeIm27QOzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4Njg4NjE1LWQ2NDMtNDU4YS1hMjI4LTI5OGVkZjY0NWQ1YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY2NDNjODEtOTMw\nMC00ZDkyLWIzYWQtZTJiZDU0Y2Y2ODcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzA+LDzxt7h9ResJARNWQDTsq6LXEpBtVVYbt0CFWld0jQbR6LqkeO0oaVtMc\nWXhvAAkb4G14lKf1joESTTMMyaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdS5wqtmvrkkBae/XvHkeCOIPnL4wHwYDVR0j\nBBgwFoAUgNxxR9S7Blu4j5t6C2p7+eL0I3AwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIH8s5KAcGpzCUZfj36+g9tqyESvevIHvLXx3FX62H1gyAiBRe1TyBlbY\naUjjyuWHXXrAEFJxqzpol1AJ2rhl60OWWA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYQgPZRJw8AH/DB5dM4i5igUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODY4ODYxNS1kNjQzLTQ1OGEtYTIyOC0yOThlZGY2NDVkNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlHM6Yj52op8enyAgCWNt36Q7p3oZKgqKIaVIUWqXDJ8nH\nZJa3TV/iyafT7j02h7Mpb86F6k9RT92NlE7yDBxPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgNxxR9S7Blu4j5t6C2p7+eL0\nI3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgS0UCRO6ay3kc1w/iuZXQf3ErkUsdkObIRyEMAw5SLJwCIFp50pL92E5T\nQKr9sKIJEnXF2+zWKpOUe/ZFqznbvnXk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXsaQZe4BpeA6ul1X4FdTvn9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY2NDNjODEtOTMwMC00ZDkyLWIzYWQtZTJiZDU0Y2Y2ODcxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzE5NmYxZmEtY2Q0OC00\nMGZlLWE4YTUtNmE5NWQ5YmIyNWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfGZAgyMISDLmTKrb57L6t0pufnI9ePdGH6rrkxANfTsJlKQ8jXJiWDo6eWbZRo8C\n7/xkowJJpcMDSIF/jaVCGqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdS5wqtmvrkkBae/X\nvHkeCOIPnL4wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBhVnhg\nNWYOK9X1PDEcXE3S16KobE/UkWdJyX5pSTtI/QIhALfm9TYyNu+QqCJJuwSfg67T\nxQz7g6PNqNfqIfvYttZ/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3890", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3890` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQQVa67hJ3504gQsyaYt/52vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwNjY4MmI5LWQyMDQtNDk3My05YzdiLTcyMTA5ZWViY2NkMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGY1YzRlNzYtNzQ4\nNC00N2ZlLWJmZjUtN2QwZDJmZWY0YWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiq/DKUYT+lLrN1+OwLzE9kzvt0ijx2bUhWe6AGKZwrQtRzAi7vEOpKQKVB4t\nLQ9HfCd68s3IEuePfBnANIa6Q6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8TUaBk4UsVUiHSarEv2q01amr6kwHwYDVR0j\nBBgwFoAUr42PS6NKo1Y5iwTgp1mPv2y6i04wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDZqsS2yH7dYfIiTLL7yh68w/vzq5O4Q0GnosJvq\nRmnbAiEAz3gE70uMtuy00Oul+Byi4brPVVjofByAS5tHBiaVvM4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeN4e8rYqkVEA/M/esl/Dke2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDY2ODJiOS1kMjA0LTQ5NzMtOWM3Yi03MjEwOWVlYmNjZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi2rrP4ZDNCPVE4CUPfn1eDDM4w4aiJ2yTjatUqUS5k7yK\nKIa84IiZMyt27PPs6hIWamFBSCI8AJ3Cyy2Debdwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr42PS6NKo1Y5iwTgp1mPv2y6\ni04wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOOuRSCPURNzLldVi70RAUEhC+QFIzAmjrNWqoUOm5etAiAuFb44FUpU\nJPByYBgZhGJgi6I2tyssllNUrBamCDUVPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAQpWW0rGu784vkFTTzXHOX4mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGY1YzRlNzYtNzQ4NC00N2ZlLWJmZjUtN2QwZDJmZWY0YWExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjZkNzQ5MTQtYTI2Yi00\nNmJkLTgxYzAtNjI5NTE3YWVhNjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFKwNxtolTdI2BgxHzSs9J/deAZ2UwPsmihgr5hRpF8OxqoITdDohfVnBBb1faChL\nXp0+5+4Qk2Xp56Vn2WodB6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8TUaBk4UsVUiHSar\nEv2q01amr6kwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAiR08\nuj9TDhZyuN+ZodJkjAO/Kbc/MdHKNpFmZl9ZwQACIQCM+NaTNtcfdbDsGATrNFPi\n/BVWd7aJABdJHnth79jrkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3891", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3891` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISARJZCL4dxooevkSY8mjwwySsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1MzRjMmJkLTlkYWItNDdjMC1hNzkyLTZlN2UxNTkyZDNiODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDVmYWE4NTEtOTAz\nOS00YTZkLWJlZGYtM2M2NjBiZmZiZDQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE13seoHtay8ZGq14YnemSer++Pn6tmZQB37fwqH/9Fsg47atlGdY5+PStayMn\niwYIWNPK2iZoxTwSrf/QYRnwOKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKNdoR+RiNPHlBXxqGuGOxkqvsFAwHwYDVR0j\nBBgwFoAUbZfPgZOYsjrJH47gX290GQ1Zh4kwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQD49ySjSXCS54ghcf2wemmY9Y4eEFBFrU/77GX0\nW3JOjQIhANPv5CCQOKPLxOcLr31y3g0oeeZ37JZZgbZblTCguJbq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUs3ayThkykyP7IUJE6valZcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTM0YzJiZC05ZGFiLTQ3YzAtYTc5Mi02ZTdlMTU5MmQzYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATevDIkFAj3+c/fchMhilJUy8pBE3OzCiUt9qif3P7iJR2K\nEsGAunBPwb0m3ZF5PJYqHdmChq8GNZHvN0WMpA18o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbZfPgZOYsjrJH47gX290GQ1Z\nh4kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJv0gcODscYz/kBS7LuCmjOTPrtbvx+SX+qbjBfRjoRgCIHuInyL08eXu\nwTL+n5nqEww5WRD6n1SeS4deideIErJW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAbktqL/+ScR/4JyzzpnM/08qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDVmYWE4NTEtOTAzOS00YTZkLWJlZGYtM2M2NjBiZmZiZDQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzdhZmViNjAtOGU2OS00\nNDM5LWE2NjUtYzgyMGYzODE2YzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbtJaioB0PE6LfSCHDngI/r8tQJ0/MxaaE2XhUj4vtxdMp3ZDrXTfAxZyYOOKfLWV\n0qzT4erRiqOVExdp0FNCDqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKNdoR+RiNPHlBXxq\nGuGOxkqvsFAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAfhGy3\nWllhZPubw5xUfMwOMTXRuZ4+9uuLjFi1mPCBKwIgSjixPGWc0y5j5g7g8IrtauuO\nIMhS5HWOla5vvagvCa0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3892", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3892` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcp7B74IfNs5KaPhNl1sMrOBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViNWZlYmFhLTVjODgtNGI1ZS1iYjA5LWM4NGRjYzg1ZDM5MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJmN2M2ZTEtNmIy\nOS00NzNkLWJiMTctYjlmNDAwYzFkYmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJIKaDX1IUpKs62QWoMCnYEmx05p5bLRL/Hqt87ddq9E3l6dw/KopHx16oQlS\n28xIDZH6PZ5xn26G4y1imKZeXaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcbgFy9qGIPasTP9EboGSJcb4hv8wHwYDVR0j\nBBgwFoAUpcPvavUIoNvGfwa7f5OL2tEu6SEwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIB/1B+GdhS+8ibspgdUPwaM0vcwe6kH+V+k2KrVb7WogAiEA\nxETJj/VpUQZ5p0Hh4wLZyXNHM5i6K2h2bbIvi5T5nUQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAarJOi0l2pM00vttP+nAsK+cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjVmZWJhYS01Yzg4LTRiNWUtYmIwOS1jODRkY2M4NWQzOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbu+ocZGxOLgMj1fa/Zc5Z0ZR+avy/Cu8nJz1euvUegRwH\n972GHVXPxnNJ2csrykmVy6T52+BV7OxFgz6cnZ63o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpcPvavUIoNvGfwa7f5OL2tEu\n6SEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANjtkHB1jhL9uxl9wHMcPimdTSLPXR6XeoG9sH8K5uvOAiAlMkARKULb\n+54uQh9j/2d4csVAQLlp4o9ONXojy5sitg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARrpGiPTeLXwrGdnzEF5g3FjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJmN2M2ZTEtNmIyOS00NzNkLWJiMTctYjlmNDAwYzFkYmU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTBhZWIxN2EtYjQ0MS00\nNDE4LWJiMjMtYjRjNWFhYWMyNTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMJDg0QmWS7Xy8ixIztzfNBzILhYQnmFmlg5jLL6DwXt7SIGWPyw44A4f+9wYd7i7\n39q97SlPoTkUry7BnvMX6aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcbgFy9qGIPasTP9E\nboGSJcb4hv8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA7hG5\ng+FZv8muSQicLisTJ8j4vtqmHy+9qI3zZRg2jGUCIBIvypIrDDOZC+HMsrJNI/k4\nLC2bMaP9A2FkLvshEpO5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3893", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3893` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAXiPCI/NvkE9OjgTkA0g6MU6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhNGQ2Y2VmLTZjMTktNDQzNC05YmM2LTUxODA0MmQyNTNjNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVhMzA3NDItNTY2\nMi00ZjI5LWI5ZTItNGRhNzVmYjYwZjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETQb4ctwZjYAMRjXKUhRfG4adyktC6FJh2QQRWYznGv9+ihl9yGkFGvLWcLoJ\nZEF8RVbYJqKnlfbsfUin1JgoiaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaWmOnjCI5yy463ZumUOQLLU5iN0wHwYDVR0j\nBBgwFoAUhsmILfgG9Tm2ReZQrXBh8iYwvfgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIFg8YZNBh/TPl9peMeRRYTpbNeKMJR7F\nH0Xk9jetehNsAiAPBtnnEl6t/PBqgfqdDl1sKhiADm1ivIYo/vah4hvedA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZGZX0w/UVP3xvei0g6KJpCgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTRkNmNlZi02YzE5LTQ0MzQtOWJjNi01MTgwNDJkMjUzYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRruOL2EAodX6TM4TCF/JM4GCA3tNhkJo5mCeNr2BoTgzY\nUQZ6n7s4KSxNQC9OWZloYDHlt110NL7HysspkpwQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhsmILfgG9Tm2ReZQrXBh8iYw\nvfgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBoLzEAG60fVqMs5+Gv0esnGl/PAas2lNCcdR4oLGV78CIQDK/xdL21Co\nYwwpn8kqZPWTSp8QX1aIovsbqpaBGu1GfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAUP/FNhQmfBS45E4NhhBrcIPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVhMzA3NDItNTY2Mi00ZjI5LWI5ZTItNGRhNzVmYjYwZjFmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmM4NWY2NzctYTRmMC00\nNmE0LTgzMmEtNzBlZGE2NGU1ZjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSk3UXlgGkM2+U+VvwTKF69qH5mfwyvPOzsbiYyGSUJTTTNyd0kzmt6NLTyud/9Nv\nLApt4uczvLbtol+PSYzKhqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaWmOnjCI5yy463Zu\nmUOQLLU5iN0wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAw1w+\nrANsO+JF8bP3dq0gNT6+HdfewPc+J74PYNOAwLgCICZQlZjpY3I6UlCnOkzytZV1\nksql/+ffEVrRalYqFn02\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3894", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3894` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUip9OWQh8TCf3UH5xFg6CY4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMTM2NzM2LTAzMjItNDIxMy04NmQ1LTc3ZGYzZjgzODUwZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDIxMzVmZjgtY2Rm\nMC00Y2QwLTgzZWYtMDA5MjdkZDdjNDhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjoMPJvBVkYE+3hLlgX/SKeejJP7P6kyuH/R6lIxMmoLap9uqncS6m8WaxukB\ne6e8nuW0CUG2cHVRzo7kBOuGmaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFHAS7lmDoMvesa8/oXZVzNU5CQwwHwYDVR0j\nBBgwFoAUWIq5o3XI0D0o28M5GSS5yCvhBLAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQChlB0Vk3RJTe+uFVdfn8R7pOkJiBKp\ns4Pkc+HsPbNsjQIgXs4O+g7X9SB3kJmbBaR5WG0aRQZsJGmG+yQ84iUo1oE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfrVxYf8dMH0ti5srGDLCRa2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjEzNjczNi0wMzIyLTQyMTMtODZkNS03N2RmM2Y4Mzg1MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcyozNhwsGd5fOONc8ykY4btBRppelXvSF0VhBQQ0l4NRn\nTF7jNhcKppxfFGTY+LKtif/S9ZuE2eTTt7C3qpgRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWIq5o3XI0D0o28M5GSS5yCvh\nBLAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFihsW/bKGad5UuQGia7qcPEH8txKgLHeKx2WS/ZTPaQCIQDK1P5iyJLe\nuLvC4PCebA69TzwbFC5inHXsM8n+D183mA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAe2vsWdO1rV5r1vSuIH2dt6dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDIxMzVmZjgtY2RmMC00Y2QwLTgzZWYtMDA5MjdkZDdjNDhkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGE2NzYyMWUtYmNjMy00\nMDhhLTgxZTAtMDRjMDVjNGJhZTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+QBcHlSkurov4owdyyIi2WstqlC5t32EEbcYdOXJzDz/ajJQgQp9bj8CGl61hriM\nGuhCY7DdT5xZOEsSpFZIMaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFHAS7lmDoMvesa8/\noXZVzNU5CQwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiABGdN/\nwaPBKjRkhKyEg6zFki/QNJWt7CgqhWXUHKoJXAIgTYZx72o1MyItB3XgL/wgetkF\n2lLVE6JzpXpC3gigi70=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3895", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3895` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISASofp7Uq7e40DUmkCUkMHArdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkNjU2MjBkLTliOTEtNGMyOC1hY2E5LWNkNzgwNTNjYmI2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmMyZDViYTQtMjk2\nZi00MzkyLTg0MTEtOGZlYTY0NzE0NThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHnOcN49yjbPiMheA5uXDKypTlxG0vjOtTKnZKqOQQ04Y72j787W5Mbp4ARLE\n+eXotW8vkHRO5Nc3eZYSfpUbTqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIKljOCLgYNaUSFb0agII66jdkSPMB8GA1UdIwQY\nMBaAFKHeHWJXpahYyAATYn2K0ssBRjoJMAoGCCqGSM49BAMCA0cAMEQCIE9N5H1J\nxyH2vISawOEEsuIfJ4WeLod5lPBF5RLDsOFIAiBQ2pVYIYn/+zknUqao8nx3r8ws\nNaciXNqRhYNapVroAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWv92US5t0H2Bq3LHMDhbQxMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDY1NjIwZC05YjkxLTRjMjgtYWNhOS1jZDc4MDUzY2JiNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1a86FezhCWEUjilFF2+JiozQmvXJZsnVKm9G3whBGL6sM\nG+kuw//R3Bm6GLP59KKd9dr4bkn7q5xpK4uJwQMao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUod4dYlelqFjIABNifYrSywFG\nOgkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIcpb7xy47g+BQZ3bU0vUFG6HvDTHYYfarbCFqU09iPhAiB3Fwk+U36B\n+ooQIZcp1G8m4A8uJR4vZKXWvdNRgTUKFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV+F8iXjLhl00IUGMB3fLgZbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmMyZDViYTQtMjk2Zi00MzkyLTg0MTEtOGZlYTY0NzE0NThhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDQxYTE4OTYtMDA3ZC00\nMDJiLWIzZTUtZmRiMmMzNWU4ODQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nW64oYPN1jjE3TA3ie//HK3H5qK9wKwrTzcwf6EiZ4uuzYEtCZ+/067F3QGyIGvLI\nGBcRIDZ+4s6y0feBjDzpdaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgqWM4IuBg1pRIVvR\nqAgjrqN2RI8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgfWdKWTrrbTNPrUCdYGMEhU0tXN4QmlK3/tosJPoT1J8CICRZxXj8X+Z7\nlKJ7TDVNapECAfsEdhGF8rSoAZpLBBza\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3896", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3896` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAVDVhnh3gUjSIPyQY3f5pe47MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMDQwYjRkLTk2YTYtNDJiNy1hOTA1LWYxMWMyNDAwOGIxZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTRhOGI3ZjMtMThk\nZC00MzAwLTljY2MtZGE2MGI5Nzg1MjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu1F7R04hoxKF2T+nVHA1RWv+TOZEUq6ttHlt2OIJjouZGB1f1GCsdQbalDcY\ntzRyRxaBmpC79iDS+Fn44fXQW6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMHtIz92mJIisFplaGU36az4rzFvMB8GA1UdIwQY\nMBaAFOHmnjVBKReoAnQ1fCAXuVDJgpOJMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEApjuXML6xSqkp8fPpf8asLukkw4T+mkYS\nCuD1NofyfIgCIQDINXQE1Sx7fr7imAPY1L0dKNsfN6xVnA3Mk3XnBlGL2A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdNT83Yw+EKzxTX85w48Gn+wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDA0MGI0ZC05NmE2LTQyYjctYTkwNS1mMTFjMjQwMDhiMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATadcLYNwH1NgRgYQsv8UkX7c9xDBTZRmsIxbU7v4miXaqd\nW4dbpm2omWi52JT+Xdtsb7M534+pZnv7vHUK6kVYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4eaeNUEpF6gCdDV8IBe5UMmC\nk4kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOWlV3sxIonQ7FRbaAoHBMuF1Wxk9wigR78UMtscAsi4CIFv0E0xUJ+7b\nSsHOcbdFQrBwdjQREmg/ATrKp9ka2uuN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXueDF1+ni4zXyMe4lK52fssMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTRhOGI3ZjMtMThkZC00MzAwLTljY2MtZGE2MGI5Nzg1MjAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzgyZjdjMTctODAwYi00\nZDMzLThhNWEtNGM0YmEwZjFkY2E0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nX5WmjgdZUfCy/+K3YrGcsaNW7zkMXNx7Lx+qdQJlOFVtnkNd/TnJZLcmZIV5xtuq\n7fseAnSIM6AFmJICOJGb96NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwe0jP3aYkiKwWmVo\nZTfprPivMW8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAJvB8RPACN56v8gcB/0apHg8mlx+OP+fYvrbtOfez4hhAiEAlibkJ8uM\nayL2Qw494MVNmMPfyEU2HFNgmSONiKDdhr4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3897", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3897` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfUOVKzhxhlJEfSL8Kyv9yLDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5ZDE3NTE1LTU0MWQtNGIwOS1hODc5LTc2YTk3ZDhiZDQ2MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYyNTdmZDQtMGI3\nNi00MjEyLTg5OWYtZDVmZTA4NzQ5M2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcDWurmqjXJM0L3iNEmesHcrMeApvpT0jqjaN5VLc47elogjkQ5qf4pfb2gxo\nIqKjFw+5ehVzUOYigua2bwFt46N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDJyHWRTIIIIJrw+Hhgz8z+zSU7UMB8GA1UdIwQY\nMBaAFGj+kg5PPfou1xaPJjYMmXnHWUxoMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAecPCjuMI5oUoWmb11ZxAUB+xqCW6D9+sL\na9eGeZ/JRwIhANTPJM6MwC+ttdg5KZknO1Q0TTwQ7/DjJ9qyDTQlq6pt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe+xWWF7Qr2A4/5D6AUAm6nvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWQxNzUxNS01NDFkLTRiMDktYTg3OS03NmE5N2Q4YmQ0NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQs8JoK1iv9muxIftRyAzqwRB2TKCWtOSt63I5Jw7ewJejD\nGN4CPqqqbyEwaAeJiYhgQeKJcdPPCEcBWhPXD0NKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaP6SDk89+i7XFo8mNgyZecdZ\nTGgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP2/YfZ+a1opSVXSGIHmaZCLb+cUCff04rcyi5EXKPrgCIQCf9GZMSIx8\ngLQHGxmIsYiuGfq2hL400EDwojVV5+rl1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATYeAn/UV90YlkPkGQ0s3rwPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYyNTdmZDQtMGI3Ni00MjEyLTg5OWYtZDVmZTA4NzQ5M2QwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDc2OTVjNzItZmU1OS00\nNjkzLWE5YjItNThhNmI3ZjQyODU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrrFzLsCRLhaamnIiBwoW6TT1udn7oUfmkQldqBh5GWCq34TbgCCkB44RZZXAsRzb\n93kQUZ9DQlE9Zc4O3MYjoaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMnIdZFMggggmvD4e\nGDPzP7NJTtQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAK+Jlt43rjkF0P414uKp8QGKJUoFL8qL6Hgt64yo5YYgAiBdaFCu4aho\nR5GakqhNdEGx/iuzegRnQGOFIGNv4KMKFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3898", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3898` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAaNOSsEQ5KyolE501rv8VwZrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljNTU1NzZiLTQ0YjAtNDdkNi05NWFiLTQ5NGZiNWUyOTJmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZhNDI2ZTctOTlm\nOC00NTFkLTlmNjktMzI2ODg3YTEyZDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhjDw35lk0xCKZIfDT8DXFgTjAm5NyQ5poIjktddcFU7zAeKdSG/UEfJV5qQq\nQ0tcEvE64EslrgFx3/cEL5GOpaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQU6TzEeDNCTGSrLUKZZ63wEbAGlDAfBgNVHSME\nGDAWgBQHRjvf17nciIcuoweqfYw0pNwiLTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEO9Rk3JQm1ixfvEdXQiaclidxnHR/O9\nIxn+1plXXbKwAiEApHfSJli6hZAYesNTlMfaRe4KW/VaXh3FEOiWleUCDSs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXEIUs/rbuj2LpD6nO6stS8ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzU1NTc2Yi00NGIwLTQ3ZDYtOTVhYi00OTRmYjVlMjkyZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATe5Py8tgSYfwWHOs8GII7JhOrFjXpbT0Sl4/INHWc0dkyO\nfSRL1qoiBdmngERfzAYlkw1aDaGD4dbB35K7v8vCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB0Y739e53IiHLqMHqn2MNKTc\nIi0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU9FEC85vjdWZ/Ujnqe8xff6kqMDCjlE9W40BwDB/Hb0CIBkWRydirnpM\nhPAkijrvzoANBxoTnyplOAa/mBG/nkh9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATSeCXm36Q7Yu41wzrQXVvM/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZhNDI2ZTctOTlmOC00NTFkLTlmNjktMzI2ODg3YTEyZDYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGQ2Y2RlYTgtYTZhNi00\nMzVkLWJmNTctMDdlOTI2MTQ1MDA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nIjvNwaxOGtAEcJQy1uvj1ZYx6L/QBEI8uoXU2LN/jqPOAUPR9vI5m0p4uXl9WA+Q\nlOKQeHWRAuBbWKjrT9ouGaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFOk8xHgzQkxkqy1C\nmWet8BGwBpQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAJfmaZEAYTRLWCWDijXP4ADEQUns9uvMg/3hvmoh5fHJAiBE58JVUjNv\n4gXjSzBvhRJsarQH+ooHq5MwAiO64lAJXg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3899", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3899` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAaZ2OUgxn+wpPJlBqyuBcCyaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4MWYyN2U1LTI2NDItNDYxNy1hNTM5LWJjNTcxOGFlMzMxODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI4YTk2N2MtMGJm\nOS00MmI1LTg2YmEtYzZhNjJlZmE2YzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc7oATFeKfVT0MvxPst9m4VqY0kF7KaNAVr3H4cWlfkQ0r5Qn+HXBZH0+QkAc\n3dXQ5si5YHFOHE9dRokCBSmDBKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9SukZ21yANeWpYpMRsz0sbhcDGowHwYDVR0j\nBBgwFoAUDU1SxuncHigTjwrof+mdgR3j/1cwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBpKASWa4YRgcgs\nv9OlfzOXhSNSuB65yNmpQFABeFMJYAIhAKyNPivbScJSeM7wIQaS+ESj7zHk2sgi\n00PXl2JCUVQQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaeOFvDua7qveIYEbNT3wzVrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODFmMjdlNS0yNjQyLTQ2MTctYTUzOS1iYzU3MThhZTMzMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThkrm6R1lExUlSXEJea7uw7/khdzsc49lY3aLpz/nYC7tY\nXEOuU0mj3EcerrKdpWckNrlnynZZNBKDqRCmdi45o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDU1SxuncHigTjwrof+mdgR3j\n/1cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAbXW60NrtPIMUpLcVeFsOWqamGdKLVqdMgm1hkqtSj8CIBAFsAFvQwgE\nYu7xb8vKp+E/ScDAHfqKe41cZgQCxxNN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQE9yNHw8xHNYxE1amVBPwj9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI4YTk2N2MtMGJmOS00MmI1LTg2YmEtYzZhNjJlZmE2YzkzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWNiZmZhYjAtMmVhZC00\nN2RjLWFlOGYtYzcxYzVjYWVkOTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nT5lJ1XSVMOpdKcSN82KiGE5okigJ7DbmGVzJE27hn7QfSlkBfngsbWyREkru747N\nZL70AzJQfFFImLZg2knDlqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9SukZ21yANeWpYpM\nRsz0sbhcDGowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgZ7sFcegSoBy/kLSLY9QjwBlLx97UoK/VyJ4Srvg51fICIQCxcKzdEdwc\n0Jsu5v+nD4zjFQ+FtbQpiI4XE+ZbrK37oQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3900", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3900` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWQ9crTaZ+qhnEdXfsdsFZJaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNjBiZWUzLWJiMWYtNDYyYy05YTIyLTU3YTUxYTA4YTU1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhiYjgwNjEtOTdj\nNS00NDc1LWE4YTMtYzBiYmMxZGQyMDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK51rkVa85qUbBj/wqiKdaXi5eWO1ZOUN4Nd/SKvouwraV9b7OsG6bJhDuEwL\nABloidQda47ZlqCH0jX/VuapQKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWUg/ph87GFAl9KT9+9J1XCpOWeowHwYDVR0j\nBBgwFoAUSucAvy9fRKhnJv5KvaGV17xgDiUwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB4sj4TnO2cMTNm\nVRQdBSY5hpFkgq7Qc8mWLOPHcT4V1QIhAPVPeRoNOvCm4sQjSYhlHPWM52qNtQzX\nGZm4zy9ch5M9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa/CQ2+hdhGzhvuLhS85ptSRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjYwYmVlMy1iYjFmLTQ2MmMtOWEyMi01N2E1MWEwOGE1NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIzE5DukSEHcnx6BjqBtdR0ws61VYJByOA/PR9PzB8tbzf\nfiXgWXElGimdcfOO8rzDos4ZVgqFxbmfI3vIAU8ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSucAvy9fRKhnJv5KvaGV17xg\nDiUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLOSz6kbcQONVwKyZpX96GfBDwmoKpeVQgAWYnVoKdW4CIQDfgbOqzBBI\nW0P/P1JvkxexnzKssmomeC7LMu74GxUJ7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATq6TzHLnN47wIn4JFD2IeV8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhiYjgwNjEtOTdjNS00NDc1LWE4YTMtYzBiYmMxZGQyMDhlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDZlMDMwMGQtM2Q0ZS00\nZGJmLWFkNjAtZWZiYzQ5NGVkNDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSE+P3HR8RO9n5GYWqhCo8JZGwGSPGnExBqBNqwc7C/ozktdpkiYqzups3sO6ZLrC\nOwpe8Kc3Cf2mFnkH9F2yKKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWUg/ph87GFAl9KT9\n+9J1XCpOWeowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgLOe5LGotj7mLBCBxy7Y8+gyQX2sxa12cwbgxOxxMuC8CIBGSqJM6RBkZ\n+0aDPU9ZR09d6O8LPhC0OeT3IEUXijQn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3901", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3901` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISARhvFN+PZsAsHyfMY8eTqYtzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0ZmMwMGUxLTgzZTEtNDgxMi04MzFmLTI2MWM0YjJmMTZlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTlmZjc5NWYtMWQy\nZi00ZTM5LTlmMmYtODNkM2RjN2U5MDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJew33Xz08whtmh0tXb1mSTtqnRuZhmqx3UCr5Wv5urFWw8tg2t8y3xBGy1MX\niAPrbwaFp06lIDY/fU5UQ33bVaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUjarcLQgbb2x+aOCgRg+z5KrNl4wHwYDVR0j\nBBgwFoAU11h5TPQXh+4M3xmQXOhK3wiOLuwwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAtkSmDA2OH+5la7opFDh8\nI31UMyehYXaJMe8f383kym8CIQC3hLV+DPk8c8TwOVP6lGklKGdlGEJGH4ggidpc\nOxM0bA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaEkGFZNEmNgpoqmK53bcFZdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGZjMDBlMS04M2UxLTQ4MTItODMxZi0yNjFjNGIyZjE2ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZk5OGEJO8VQ8ThE+Uy3rlDkrTEA0kyXwF3877hSKFJ+ov\nfBrDykhSW4BKjZldZUMWl3VBz8cnyVwEWRAP2clRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU11h5TPQXh+4M3xmQXOhK3wiO\nLuwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI/qYsiPkfB6H1BQMbEvH7s+OiBUCX4Mexcuk0I9Hkw7AiB1JVRuSo0U\nKWgDGcD7v4GdPeuk4X8hUl700EWd5kVA6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdeCj5ocbqGS1dkQrg+YhsBdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTlmZjc5NWYtMWQyZi00ZTM5LTlmMmYtODNkM2RjN2U5MDlkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODlkOWE1MjItOTFiZC00\nN2I3LTlmYjYtOWQ2YTZiYmM2NDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5Yc+3DpUb9RSe1G8qI6wKrVIxMkhLwjEm2/6NtNo8Rcp1CdoCqsDoUb6FJaBbH4P\nUHBcT32lzVDtNQov2Csp8aNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUjarcLQgbb2x+aOC\ngRg+z5KrNl4wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgNQULOPM0NkrYB9WZ/OHdBN2f3xfL9brfw0ResyLFxZMCIBH17PnFPYJv\nmmh2NWP1spXjjdxGbu9bxq2YbGfzO0Zf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3902", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3902` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAd350k4RnUQUofusOhbNzU/IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NmIyNGYzLWRlNTMtNDJmZC1hNDAzLTBlZGY4YzYzMmEyYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFmMTZjMTEtNTJj\nZi00MWY1LWIyMWQtYjc1MmY5ZTU2YjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPVYFQ72FHA7jHMO7dHuu39wejrsb+kj1Ly49FZhI0tzof7PVof75O6WeEdIG\n5Bmrm9GoqP3KKY69yeKzr4JWf6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo6hMf1+tejkX9kftxxaaZOqGZWswHwYDVR0j\nBBgwFoAUKiKQDX2X3IlA1Ug87yZLvYN1jgwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBmSVUJ\nMmKbjWAVkDxz1BS5bYJdFpQdMvCe2gLnhJQuBgIgRmapBKjrUgU/NJRjFFWsS92d\nHKh1G3Dkmm6kW9LXw1U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWojYQ1ErAuAFiVxt5i5Vp48MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTZiMjRmMy1kZTUzLTQyZmQtYTQwMy0wZWRmOGM2MzJhMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATa3kYdeFTuhQo/KaEl5WzMd9aB2ugPEvSftf442F5JaGBn\ncAb8E/h9FfRE0S6Udw/7SIOHwtjfsZiwylGM4TPmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKiKQDX2X3IlA1Ug87yZLvYN1\njgwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFUWzcOvkUib5xxIMu9fkNmKfbl82MNGxUAdBNfUoI1kCIE8E48OhjQFL\ncZPYaHXH2e2Ai/uy+YwjLWa69/JF6mw3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfPc8BZGDLVYh76dYnZ3JDhtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFmMTZjMTEtNTJjZi00MWY1LWIyMWQtYjc1MmY5ZTU2YjlhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODY4NjNmNzgtZmE2MC00\nZjc2LWFiZTgtMTkxM2U5ZTg2MTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2qEKZpYA4vt6sDijLiI0QKHzd87CsOYFKXfXQ3LFnEXXX6mib2a11My/VBCZPmIG\neZSwRASiEtwg4fMIWBKGb6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUo6hMf1+tejkX9kft\nxxaaZOqGZWswGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAO1lzLDuO9q4CDHlO0f1ODMqwS00A1+EHkVegZ+LRdo9AiAvuC7DLqzF\nAt8Je06efOJsa1NRIBa86PsqQ0odgT0Uwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3903", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3903` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAQK7ennfZ/iwTl5RjqNCK1zLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlNzdiNTc5LWIxMWYtNGUxNi05Mzk4LTVhMzJjZWEzMmU3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNlNGMxNDEtOGY0\nZi00ZDc0LThjZjktZGNlODRhMDliNDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENiLNG3eejnMiJBaEiSICNgozDcGbx7CkeqGfXRVtYiDKxSgwt9xiU4+TEM+9\ngXBHt41kLFhhCp91qKx2d9o9TaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw52beZok7NolxphIlqSM7hAN7z0wHwYDVR0j\nBBgwFoAUTwTZM8K2PT5kLGAqKBrPSpQsvJ8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB4F6AW\njzgk1efMP8TZBrHbbX+71JWH15wKz2YmdJSvtgIhAL+JGwCjnr1fu6Cmcd4AqNdA\nBZ8NAkv/BbmfJMayxaBk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYkqbMkMYX1efST+bWQcwYLNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTc3YjU3OS1iMTFmLTRlMTYtOTM5OC01YTMyY2VhMzJlN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKgcEBkmsEflvETCOTvPXOpg8LKQyby/9drdSqK1WcwS7U\nlJ8Ll4J1MH8S2E1Ug1QfTB0ZiFYzgA0UFAtgZp+Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTwTZM8K2PT5kLGAqKBrPSpQs\nvJ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPe1KAXYs1imDb/tWc145KIr5XGxcq7dPxa/NKjcYWO/AiB8Pw94GhjN\nd9xBwijtesCqPSuQ6f7bVAyAKumphxH7bw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbFzWF3r8bxVkzFcG4qWFFt+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNlNGMxNDEtOGY0Zi00ZDc0LThjZjktZGNlODRhMDliNDlkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjE2ZTdmMGQtODBiZS00\nN2NmLWI3NDEtMTQ2NTFhMTAzMjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6w5h6+jejJaaRIBGv7gXeiXABYoEzaepBbRWmQdcQZHvKgks9MCSK/VTG9Rmlpak\nQtWBFrAleXLqdcU5pmqT6qNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUw52beZok7NolxphI\nlqSM7hAN7z0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgW4mHRKpC5pqxWe+EU2tukLr3nss+lbk0UI+9lr6h9LcCIDwSYXTsm5ZD\nVKTUmYipKtygFpySHTJ7cX8Nq7gcNkH6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3904", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3904` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAcQ4gPbmWYJ5HfY0mbXkvA/CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwOWYxZWIyLTBiOGYtNGY4NS1hNDcxLTExNGFiNjUwZGZmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQxZGY0ZTAtNDU5\nYS00ZDVlLThjMGUtNzk4YjM1OTVlNTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZqCttDbaIQbJmV5ty0Ao2byueToD+pqhhBG5T0rRGPMBrNDv1BjT5GVfOiKT\nhB7sCxhCDViQW2Fqtbx1Y81D6qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDAQiR8au9Jj+jeho8tETw8CmDk5MB8GA1UdIwQY\nMBaAFMJKf+mx93y81iedNGgyB5VhpgZtMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBQpBBwSCKB57PkMVFg3eaVfcvU4A+CUFch\ncKBUpXhWmgIgLrx/DxONz/xjwpfWWIP68j50qECbq7/MVVfL/GV5aSw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZmry8Bfjc8avKKVsFuAG2VgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDlmMWViMi0wYjhmLTRmODUtYTQ3MS0xMTRhYjY1MGRmZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZGF/fv0llV1mqphwL3Ak+jjlvsdLXOjjTUykKN5mwCmCx\nHWYYlugbWudCN9RDhtwuFq3lEtX+5WyHKe4ha7oio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwkp/6bH3fLzWJ500aDIHlWGm\nBm0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD3OiMeBWCjnDUaaERrOo02D8CACbyWS7YnkTT0k5zLECIFiHNBpwuKny\nCK5RCFx4kZlvYjT6gbmpSybwlbh1ude/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZWAs2q2jK0FjOn/Q53QQqCOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQxZGY0ZTAtNDU5YS00ZDVlLThjMGUtNzk4YjM1OTVlNTEyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWUzOGI1MzAtYTczOS00\nOWYwLTljN2YtMDEyMWQ1NDlkZjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncAf7xcoKcyI57uhZEHJ+vkbzydxD4T+2YyKQclf5b+M3CsaasUxSVWTDcB+72oQj\njBKXWt/OlxJ1p8o09fXdXqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMBCJHxq70mP6N6Gj\ny0RPDwKYOTkwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAPp6mGtz3DnI4sCyYAreEeYUH5btJiL3jHAVZfuU93XKAiEA0/jU8a5/\nJpR9MraJBH91qocN8B+0TDnrr6xRiAceBEk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3905", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3905` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAclxI3oXgbJojjJIWum7CdGeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliYjA2ZGI0LWI0ZmQtNGFmNi1hZDBmLTY3MDUyODBkNWJmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE4YzlkNTUtY2I5\nNy00YjQ5LTkzMTctYzNmY2Y0ZjgxMzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE03bXEShzT4k8HccVvYQY5ba6tOV688s0wHY+HjYlpmJ4Rn/ocgR6S5evE9ky\n6DDdyggvUeXl2sTJML4AKbaWZ6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW36eWpvWuJi8ntSk1f7hU72DSdswHwYDVR0j\nBBgwFoAUyznsdWuNqg8SCQpFMulsmuEh6yMwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMjevNp3UvCr\nz+ev4c6yl5wp44LOYcDEg+27kSqFskT6AiEA02WGFl0DcZ9vZItP1f+W0JFXboKo\nt3OqMPsWYGtl7lk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAejihikcUA6B/FymqOl2Ws4JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmIwNmRiNC1iNGZkLTRhZjYtYWQwZi02NzA1MjgwZDViZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQToup6m3MbnWEG3tCAPfZBvszQWko8p9oFpbMCIZbakd4v\nkYx4iCpooeez/XPt6Rjo622POa+I6B+2WVFiRo11o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyznsdWuNqg8SCQpFMulsmuEh\n6yMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaPOr9tSyK+hqETGKgVAHyjHs0MJ/Q4DEJ0wtM1SRNAUCIGLpiui5n39M\nN7DJIobCWUywC2XoqKhfgl+Hh+g/GcP0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbOPTQC9rrHHw5G7dMm5F43jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE4YzlkNTUtY2I5Ny00YjQ5LTkzMTctYzNmY2Y0ZjgxMzU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGEzNzVhN2MtODcyNy00\nZmUxLWFkYzgtMzIxYWUxZmE5MmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwlsxJtZbxxliiONHC0g0GJgxU0zMekZj+hWH8R+mioU6cROKGuxLtiO5lcYUWQiH\nDLWcG2pOzf4RXZh0vj0xSaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUW36eWpvWuJi8ntSk\n1f7hU72DSdswGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgBrUVp8vEzdH+jLoYUJLkMmfoYjq1u4YumuiXmGfYUL8CIQCMCiuQ0X/w\nbz6MQR9+frnDeEbPY8vjxS2X17I8oZPROQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3906", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3906` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAdOn/cSkege4V4IfbpfbVislMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzNzIzY2M5LTM1ZGEtNDRlZS04NWFiLWU3MDBhYjNjMWNhMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M4N2I4ZTEtOWEy\nZi00ZDQzLWIzZDItMTMwMzQxZmMyYTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5NLVKHVM+AY2SZVdbqdTfe/Uwf11S1jBKpwI14X9GdS39PULWEnLenwi54IL\nG1zquvJlTHKdmhudCYxwtZrHUKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEnYbsIhyXYeqeib46DpNff5Fb2QwHwYDVR0j\nBBgwFoAUACLDMCQ7nDsqlMkmxsDG7xBfHPYwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgYyduBQYkLPIC\nnXO+5fyEfW8JfBLBDGp0fqgv+lT9WkYCIHwbdvClDLfbFnNVyN+ULTCLWhu1Y+PT\nwB+5uyGjuT9q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASsUR5S+WIqFbXoKCDOvwsN3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzcyM2NjOS0zNWRhLTQ0ZWUtODVhYi1lNzAwYWIzYzFjYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwuZNgzVu9mFzsetsRdDbn0N1v33dunPlZ94x78DvOK1Rs\nBNP/E9cZckHhdWEYq6cOOdpL+CR1qTm5w+HrP+0Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUACLDMCQ7nDsqlMkmxsDG7xBf\nHPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN6ipp/yDjWkrOdMi5awXxvaMEc8cp3r1VXSXd5sFxPPAiEA02uoXhNu\nc539aa4ug7d1iAs7tS1Rbb2RzFn1lGtXSdg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe2fmPR1DnVcr84jlXnj9bFTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M4N2I4ZTEtOWEyZi00ZDQzLWIzZDItMTMwMzQxZmMyYTMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzJjZTMwZDUtZDY3Ny00\nZjMzLWIzZjEtMzg5YzdhOWE4ZjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3FSMiVQHw6XjlP3NVS+XzOcnz+3ZG1P/AFPIDK7Moi8naNJvYlBhUcsdX0FP1X++\nXRn6VzW2zVUiC6MXDmENuqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEnYbsIhyXYeqeib4\n6DpNff5Fb2QwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgQj5XxTr8pmfVxYlNRDC5ai3p4+zI9KxUOnfkplugTJQCIAwlsGZ6a5yA\nXzJVw1ahxtksnV38d/RjkN5TI5uYs3TK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3907", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3907` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAeHa12KHEB/1l4K7o/JFa6UdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiNjU5YzFmLWY5NjgtNDI3NS1iZmU3LTExMzA1OGJkMzVlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU4M2JjODEtZjdk\nYi00ZTYyLWIzYjctNzJlYTFiZDYwNzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwUBge00dD8Htr3EPAvwBw9cwYrUk57ubW0S4eprtin6w3VQ601cMieht3voG\n6XPtAUhO7w/lbQZY4FNaBkUa3aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuzV0Tt9XQA4viPkVkT85vPAU9RAwHwYDVR0j\nBBgwFoAUwJ7QEjEtEOYScNlGhgLcZ3pWtOMwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCvBXoCqSJX\nwZD/SxF57fIi6SF9hO3c8r2RiQslOB3V+AIgcgsUhd+hCpbKWhEXmjHjoJdqVvPA\nakNH7/gU6KcteMQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeBLJHB+UTv4v4U/nJiLCbj4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjY1OWMxZi1mOTY4LTQyNzUtYmZlNy0xMTMwNThiZDM1ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNyTntBTRvmyZDgWIGWb1o7alc4Rz/QzZ6WRrgUrnX7W3B\nHny+EpqahkPnyBZwIp7KGqO6nunT+e5O0KDkDD0Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwJ7QEjEtEOYScNlGhgLcZ3pW\ntOMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKWGq81JpprCEFsPOdcZ6PjgGeUi1zPtRrjDvOTdODRXAiAHwbfiwEDn\n4u6rSdYljzQ2jbRyC8FrILkvS+5qFQ4bww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdYyRDj8CtOrSCM3BDto6wnlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU4M2JjODEtZjdkYi00ZTYyLWIzYjctNzJlYTFiZDYwNzA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzQ3OGEyNjQtZjZjNC00\nOWNhLTliNjEtZDZlYmQ0YWJjOWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nO4AgF5gp4SPiBkLuW2e7lMrcgHbbgc8WR8Ufxf74+tPpdjrMsZpkAEBNKjkl3ER0\nxaX7Lnylw1auTu4EAokagqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUuzV0Tt9XQA4viPkV\nkT85vPAU9RAwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAPCemQByjfXw3cCwGO2Zff+1qO18m/hlFbm1Irbjq2bVAiEAo/4lJ4yv\nMhw80MxZGCVGHiMB0g1KWWC+nG2iX96FRQA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3908", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3908` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbjw/6l4MnPJ1bU9ouaFQNuKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjOTlmMTNiLWU5YTktNDczYi04OGQ0LTQ1NzM5MGUzMTIxZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIwY2NiYzMtNTI0\nNS00YjdkLWE1NzUtNWE2OTVhNThkMDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtEMh8vxPjKZX07ohMVKuU/uVF0xIEqADzVIgEWby0i1fBpnsQTjxXMXXL2w4\nUWMWMpJTELe+vRjFyiBM0twbn6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJmtL7djfi/lWpNH/LBo6r7DUPQ0wHwYDVR0j\nBBgwFoAUGXEcjoGcDo++dX1/OswWdLXNWSkwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCID1Z9KwUcBt+ZElaE+uSVSZJwM0E/rrWFnUBttV6pvilAiAMSlHpzfQttrv4\n22SF4bbp48ZR/wQKp4cmk97l2Zh/+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeAUZ8pHPzyHEkVgINtYPQO5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzk5ZjEzYi1lOWE5LTQ3M2ItODhkNC00NTczOTBlMzEyMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTuiAwFlRCeuUVvBE9C5EaaSGGgTnUM0lI04RkABj5ZF8g\njVeJPhp++OgiyAJfsycpwdJAdPd+oElY7QLeocF5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGXEcjoGcDo++dX1/OswWdLXN\nWSkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM/2YAChz2MA2zVfz59SohtxgfyRuELKl3LL4oRoXe9JAiEA9Cgf0OPl\nzQTO0XDvsCNJxPWhVrhtFojTltcd1oUMdsU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYJLNTHzvO7yynkFN0NX7IeRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIwY2NiYzMtNTI0NS00YjdkLWE1NzUtNWE2OTVhNThkMDBkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2NjYmY3NGUtY2EzMC00\nNWRiLTljNDgtMWVmYzRhYzU3NDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGdHSpk+5lKVEP/xXfIolV//XH/ZrjTbFXnihtbk67rYFA6xQ9Kr210D5pNH3xrx5\n29r+38xhqB6vTUQP8D54p6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJmtL7djfi/lWpNH/\nLBo6r7DUPQ0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgVhUNqjzs1gyz8V6DOuTzYKpvLjIPJ9/fsjmY+v6lvQcCIQCmnUZivvHT\nDeM7jBASF3RD/NErXJKxqO28AU7iSZ3Oug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3909", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3909` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbIBA8oS2Op1CDJwRWp7srYbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2YWZlYjhmLTM1ZWEtNDQ5YS1iNjM4LWMzNmExZmY1ZDI4MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc0ODRlMGEtNGM0\nMS00MjU2LTlhYmYtODYzYzBhMzAwYmU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwy5VvZhly6Xsm4jXQmGmrmLZtCW9kf9bv6VoCPwRhCpqEBpVKcid0SBr29lF\nCTza8mi5mXff6rKYW7QaUV2DEqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUefUHTIfYP/6v+NW+GKVlBygRaUcwHwYDVR0j\nBBgwFoAUUkrX8bvH6wpMOCsqbTntlhgf+F4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC3VgZOc+P0mgcjF/FU0/37KRMLHAdnB7NvftiAlMJhwAIgKk89c+cSvCSn\nY6S90/VRf96JeM1f+3F8YeBqNxDcq4g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWOTFQjCwvXO3duMqHv1fiOWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmFmZWI4Zi0zNWVhLTQ0OWEtYjYzOC1jMzZhMWZmNWQyODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZnvLV0KlopevVvpbBaNKD6Q1pt1pa1Psp+eNuUfvjyNfk\nZD67RbxdypP4tC5kTsP/F1f1bYqaFgXVYKS52oeRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUkrX8bvH6wpMOCsqbTntlhgf\n+F4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIorgczB/ej/usIz6OCu7j8SP1+PgYyoV09q82H/iMK2AiApSII8fHGq\nQsv/A0lPxsjkwrwyJdKB5qfyrIGMig6Xrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY0c8OYG3sg/SEOeXqV42OozMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc0ODRlMGEtNGM0MS00MjU2LTlhYmYtODYzYzBhMzAwYmU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzJiNmFjZDUtMzc1Ni00\nOWUwLTg2MTQtNWMxOTJmNjg1ZjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1o1PvVozEjyV9PW6tv+OMY8MCsufpWn4OiGwruwS5mgkWLHLYlyiml+M2v7XeA1K\n5Qseh4qNTIbkIBtkENmgdaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUefUHTIfYP/6v+NW+\nGKVlBygRaUcwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAKXUPPXKTepbQhcB42tLIRIQjgQtDaHZre7Uwpu+VaywAiACaHQdHcXd\n39SYeqmUBEcAG3erZaX/R5OzxAjQ7InHRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3910", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3910` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAY0VCqFZHkGcQsDkj0TW10nKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3MmM4MjhmLWQxNDItNDY2My04NDYwLTM0NjNkZjFlMTYwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk4YzU5ODUtNjQ5\nMy00NDkyLWExNjgtNDhmMzJmNjgxZDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhaI1AuBxvplRwDR79mdbPFftAtdaIVbmpHjZQil7WIQk6rvkTZ8R2E4Zyo9k\n1U+FO17yAjc5ZKB2xXqMvNoGvaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdgebC7jswKpaamPgcIMpHFBs+J4wHwYDVR0j\nBBgwFoAUxK1T2F9JyK+L3KUHJo6oYuvjfNkwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDZu\n5X62p1NXxadLQ2iSowZ7+kX1dio5iqkXAEkBDAdpAiEAisN4A4g5KiR+E8lnhXxp\nVlhlAW53YQiquuP2QtIEEvE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdBzfZTSVT0D7KDM/toguPfsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzJjODI4Zi1kMTQyLTQ2NjMtODQ2MC0zNDYzZGYxZTE2MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/6I9+X/qS/OjXBGAHAUM0/BkUMIOZlGZYCEaBforbv8Tq\nd8U4bLgtUB78AutyIfmi0qEic7nUzrciCy+MBVwMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxK1T2F9JyK+L3KUHJo6oYuvj\nfNkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM23kIBNuEAvUSqqz2rLQxRHvhDFG6MuyeJZbux7JlQcCIQDUn6Sbk3RT\nIT+NQla4+CtE016a35EVSTNj78MKsMNTtw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVwuobyHmvvFKL4Xfz68Dhn6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk4YzU5ODUtNjQ5My00NDkyLWExNjgtNDhmMzJmNjgxZDYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2MwZjQ0YWUtMDhiZC00\nMDk1LTk5ZjgtMzQyNjJjYzA1Mjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4nNhdKLFoVmhRPjRhSYhyvhPL8gdCBssgdAMhPqR3kqmz94W5K3AQGLEvFgfcaki\nkgQccXzso0VDFRnRB4GCu6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdgebC7jswKpaamPg\ncIMpHFBs+J4wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAMkQ9Aua2gVhqtHGgah5r7tP/ugB094HCka/AjDmBqnCAiBlZoQ9pRj3\nfMEprRAVe2JRgbgF5ggAl2wDEE4JyMQfLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3911", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3911` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAdNR4HHoJCfSjA6OTY3wrGnyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllMDZjZWNiLTZhODQtNDVmZC04ZmNhLWY3M2QzZWQxZDY0ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ4NmJjYmItNWVk\nOS00MjcwLWFlZmEtMGNmOTZjZWY3YTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFA5yMe+1zUP2TcYTrtj8kturPwEgJL6uLdpVCiP4Inmb6JXe9FV4WEKF6pTU\n04tpv7fvaw78c7P7vE41wUNcXKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5V78dTXmAMvQPJrcXUeBSwlAKBwwHwYDVR0j\nBBgwFoAUGkW8EvWoUa5+oYwMJm9/qHno0uQwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHZfkDc1PJ6trn8SzgDb2bxi+jAFXP1pSD2CSWx+0RQIAiBl4nX1\npeTUyOG35o91pgabvSH+0icnmIDCjGJ+MMQNMA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUZYXjmQ6FaTVpxnLjMh0A8HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTA2Y2VjYi02YTg0LTQ1ZmQtOGZjYS1mNzNkM2VkMWQ2NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgVI8XPr40LpdUqMJHMnGbXP7iNb8ytGdbHpbG978TwNd+\nalklY7dOwm72NzmIw7ZWa+iJQv3mHM/Y70T9HSYlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGkW8EvWoUa5+oYwMJm9/qHno\n0uQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKyPJqcnXXWH7UAziTu3siHbrDKuwEJuni7ZYk3vtm4IAiBk4YJF0dKG\nMXg1BkiFjMtEojaQxtzvdO0noaVECI3otw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe6DhlJn4jT7caw1UQfhB97TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ4NmJjYmItNWVkOS00MjcwLWFlZmEtMGNmOTZjZWY3YTZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGI0YTg5MWYtZGRmMi00\nMTk0LWEzN2YtZWU2ZWNjOGQ5MDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntHPbWJsoYLOBwrLr72SRTVjpO2VBHvi821LscyWOqIaiglCLghz1bNzMHRnpMyzY\nkYiu98Y0xHYNYfJ8PfpEcKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5V78dTXmAMvQPJrc\nXUeBSwlAKBwwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAN7wgkaI+3O+yIFzOmAPx1Dtt6f85gdOOOyEKtqo91iyAiEAxguk9Dq3\np8yhrVR74EncgbtIFyWHPirj4gOMqa9yQu0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3912", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3912` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAWLDsrZuq05zJFRk9CvaTdUsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1MGNlMDg0LTdlN2UtNGU1Zi05MTBhLTcxNzZmMDRmMTllNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRjYzU2NjYtZjEy\nNC00YTFlLTk3NjItNzBiYzcwM2U4ZWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF0t+vQ6hNDApes1cMXWCc2JvtJveGLAWvVbDdJRbT0+C+CJWr8470u+6yKaZ\nW0sn7BW9w9cV7koqmT1jxKRis6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX+xfzbghw3wcOgQeyR5cn+pZZNUwHwYDVR0j\nBBgwFoAU98fQMSlwql9yqde4Q6yds/RwddswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDvhGOImwDeGpIip24q61q3USZ1ZS+aLOfyr79VChtTfQIhAKgW\nziTyevSfjFN8l8JLsNkJABW8mMqJZ7PEY9AXxjG5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9h33h7I+pl9KyNmtbEhswCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTBjZTA4NC03ZTdlLTRlNWYtOTEwYS03MTc2ZjA0ZjE5ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUHeo2x0vfXDtXnqdUgEa7lJsb0mvJJ7TWdeqsi66YAzql\nL/bVFYJGhLpO/cjurWsDVdBJntYnYtSaU8C0mXd1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU98fQMSlwql9yqde4Q6yds/Rw\nddswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANMpAe5QYwyo1sl6roJbAt7fuhjG+gWSl1Lhyhh3/eAsAiAnX6c3XTEN\nU6DWVvJ6RmYT7906yyE662bjmwyIDfZ0lQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQFpqdPzO1NnvJ37/6OFHUS0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRjYzU2NjYtZjEyNC00YTFlLTk3NjItNzBiYzcwM2U4ZWRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzg1OTkyZmUtYTY4Yi00\nNzhiLTkxNTMtNTA5MjhhMWFlMDE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4G/LBeoYxzcLYmlULUmAYH014xof6ji9QmgD4fqjsZUGAgP/6JJPG96LVPE/3Iug\n1Nswgcs7e9mhgvpq1NooOKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUX+xfzbghw3wcOgQe\nyR5cn+pZZNUwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhALWkjsW9iL3nvQHjWEuTeI5Mr58SmRliaQOEe7ot2in/AiAuTDK2TKUV\nd3yjSGCPolymwGaa54nZSHFKdaDEhnMiOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3913", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3913` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAbtExqzRWPPvFHmorxVK5ymmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmNWZmY2ZjLWU2YTYtNDJmMy05ZGI2LTQyZTg0ODU2ZTllMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2MzMGEzMWItNDNi\nMy00ZmQyLTkzY2ItZTJmOGE2NmQwMzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErHPGVHGunl8TP+xArAAsvR2GrvhFDaXXCKXM0K/oY9MkuA0Uynw93VlHiKTG\niwv6FKAHj9XEB/8eP1fFzWKu+6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEHjRU4Mdis3kyzZr8yu6qDglLBfMB8GA1UdIwQY\nMBaAFDmcQ/Mu6YLDS5kY2c08u64EqkL/MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiARkACetnKbVVVeEoCeJkrBLrOoi7HrRgkY\nyVf5ev7A/wIgPmoLP9qlUK3gi+gnxdqmCkf85FJYyBEs1dw+880JvwE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb0vF4/xnrXs3QV1Rx4Fcv/ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjVmZmNmYy1lNmE2LTQyZjMtOWRiNi00MmU4NDg1NmU5ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXm9wEl/2nYvTv3B/KQkfnPRYUxyp1W77fn8ppSe0p2QGW\nGOVoBC+8CfF3vzC+v5SGz/uFn0+VU5Ks/5yW5uzto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOZxD8y7pgsNLmRjZzTy7rgSq\nQv8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKLR9nnYlMx+5MwtUMHAqZO/nfM5xSdOb3FiRiO+y8JgCIQD65OQKPXuW\nNgne8yJi5EdG+PsyqAtH6SeoVOueZgzCCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbCs4R65UePtaU4RcaR+r1rwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2MzMGEzMWItNDNiMy00ZmQyLTkzY2ItZTJmOGE2NmQwMzA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWJiZWQwZjctMWJiZi00\nYzNmLTk4MmQtZGJmZTI4ZjJmOGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrg/NB/g/kNIoWSEV2+tukkJun4zSeEB//iIAkh6e7wOyafhZFL/GN5VXaWBZUxs6\nxdeewXbNx2PFzH0uyYfjQ6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQeNFTgx2KzeTLNmv\nzK7qoOCUsF8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAOMp7GAoeI+ZyMCFqxAx0NZ55Yx0/yXwQgqAo3no1gNWAiBg+mKYvjfy\nEMCAMSunns2s1U9w2QJ7LfIHkitEmKgRHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3914", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3914` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISATNgDsh+/FRZT1iWPZsIGVx+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1ZWZmOWUxLTQzOTAtNDY5Mi04OTVlLTc2YzllMjI0ZDZiMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ0MGMyYmQtNTQ0\nNy00MGE5LWJiNmMtODlmMWNhNzZlMWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE38bqEYiGmc3YHxrkhuTqT5juW8aGV5l3AdLHbiRU21QqQlimSKP1cAI/VQCE\nHHJtqb67lxwe/37MOsaf/wkH4qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1q78jJuefKPUv1WsSnlNRUPWPXgwHwYDVR0j\nBBgwFoAUQq4TUgp935HBIsEYWDBHBatavlQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgWE+aTEJMN6b7\nBmccDchZ0rVSzpDzMz9l6AALNZzATwwCIF5l0oCzp07K6NzG3TWu+/NZAuybNMeJ\nGsSqo1HmPZiX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaS1SLWyJheskeQPD5pIm8VKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWVmZjllMS00MzkwLTQ2OTItODk1ZS03NmM5ZTIyNGQ2YjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9H9PwZvFbRgB8v6oXroCQ3qWUgVPY+MrgpNrpZqlKWeDd\n2COzPp1Ex4DeOP9eTKq2RNmWZ3qeWN9lGL3yX2syo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQq4TUgp935HBIsEYWDBHBata\nvlQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALJ2jdhGRn2J8tO8qmUirv9YDNGDF87wfKirGRtSqPnEAiBULzLyaj1Z\noOaD5CH5mmmeuE+8ekTxfTle606NiiCKMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWSpeLFgy6on+Od0dQp4xh2nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ0MGMyYmQtNTQ0Ny00MGE5LWJiNmMtODlmMWNhNzZlMWExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzcwNDM5YTItNGVmZC00\nNDRjLThhNTctMzk3ZWVmZTgxOTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nl3+6Nhdcq4/1Q3QNHx+1sQvnMHZ8PcuTOWSbZEJ0p8mo2dNN12r8VFZx02rS2sqM\nEgOJOIRT+xhLJK5Ys8ls/qNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1q78jJuefKPUv1Ws\nSnlNRUPWPXgwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAPwocUinWs8BAZHLGVhdjtwjGZkyrGn3xGOLz6m9pt6lAiEAnxXBvYXF\n3DGuf9we/z3/010+y4YBM5Wr2vnvq+t/Pu0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3915", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3915` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISASh3nQKI6+TLa+3KSDBpvjdqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2M2U0NDQyLTU3YTktNDQ0ZC05NGFiLTNkNmMzNjU0MmI2YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQxNWQ1MWItOTJj\nZi00YWI4LTk0NTAtZjFkODc5ZWRiMDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE66OFcq21akoKM2nuHYX8PxW5DSgnjjziIvxxvGqRUmQ/cDRWn96zrJwXju85\ntdsHU/XgB6aHkdsNUBMb99Z74aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVE+PF5wmCxlcbW6u0rr6i/5EcaUwHwYDVR0j\nBBgwFoAUeaFnFQyt/cjiicoF2bFcfH6Rsa0wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIqiP2BS79Ny\nP+twqoSieR8RMuE9qS8dwcgslvNpTnCmAiEA4h4n5yZZ/nzro+u3ZyQtEGKbkAKb\nrZRt1NWmOjNLkdo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR4WkgQa2rto50tbGB79TXFQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjNlNDQ0Mi01N2E5LTQ0NGQtOTRhYi0zZDZjMzY1NDJiNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaVI9UdOajb8J+xNouNdisfHfxY8Kbi6gs/aVz2/jaSZYf\nvR695kd5GYQaibAv6081M1IAUV4rzqs/Gy3/Z2C7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeaFnFQyt/cjiicoF2bFcfH6R\nsa0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQXOLkf6rKNjtKfOhMOEG/VW6hOU6l3jvqVQRqNRK1MECIQCSwQ3LvVEr\ngT+ilPrXdqNGCNPZdK962w1JR8W0q4tlWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUZl8J0QAF9wWCWixUZcNDWhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQxNWQ1MWItOTJjZi00YWI4LTk0NTAtZjFkODc5ZWRiMDg3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGFmNTMwNzEtNGM3Mi00\nNWIzLTg5YjAtNjE4NzY1YWZjNzFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\npXB1wcKm6dRIXOZPZ7chNfgGoG2lTP0ZrGkmdR1/CNjPAiIAm9+MFj0SQYgqXTVQ\nHRh2dol8hbJ+RTh3awrlOaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVE+PF5wmCxlcbW6u\n0rr6i/5EcaUwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAI031mQ9Hr6ex56lhh0zlanSWPqzLTJVxQGmBmN3YIqwAiAhhCy3TzHd\nRwUVTvjUkipUCoSViCzQ9jqN8FK7cplXhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3916", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3916` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcJTD6Sx1p7ME29kTPQaIplgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MWE2ODdmLTk0YzctNGJiYi05ZjFkLTVkOGM2NzAwZjkzNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzNlZTg1ZDctMmZi\nOS00OWZiLWI2NWItNDM2NzJiNDEyODI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBhkpTrQn5p7PNPLtyNpMlkFpfhLMRF896rUJLRnkprS/pqnup40EMJ/iH12S\niCkeTRaeOIEoMLDwmuQ74fRs0aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFtsxiclUM4UysrFP5r2vqtm+rVMwHwYDVR0j\nBBgwFoAUuW3n5ABB/Q+GIR9UjI0Rkwa0OXEwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC6Wxd8TEhK\n6tbSMbxZCpjjX/IfdmmwB+a8QQsGYrAfegIhAJ9XhZdL4DZMWnssksPh9cEFsjds\nYR3SfUOgkzUb3nNB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaloLYcsxubJidl2GVY20tDsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDFhNjg3Zi05NGM3LTRiYmItOWYxZC01ZDhjNjcwMGY5MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYUMs/c/WwIcbTBJJPgZZgxc9tCv8n0PTKYqbk42zmZKa3\nN2UlezXA7HHJ3Nmq13pMhuJ0iRu5+W070FDka3gVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuW3n5ABB/Q+GIR9UjI0Rkwa0\nOXEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT8ogNZZ0JuD3KkoVAUtZ5CI7WKJlppHj6940yfmP5YUCIEHJCft5jC+B\nw4wAxVrHFTg21o7sGst2FprIyLCxQ69n\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYsBJ3duAiQn/pL5KLfPzAwkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzNlZTg1ZDctMmZiOS00OWZiLWI2NWItNDM2NzJiNDEyODI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmUxNzE3ZWUtMDE1NS00\nNWJhLWJmZWItZjc3ODZkZjM0NGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nL2jdjSnVkkJ2+cR9XFm51IbFCw7DzHD1HpQTNKtaraMzoVOrN+KJoVZsbhopZ/X0\nTA8VN9mfycsF2Q4EF9XLUqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFtsxiclUM4UysrFP\n5r2vqtm+rVMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhANPfTYfGTeT8GKijTqeKJsCRSvBtxpDI2STM22CmWgJfAiEA+q7MGSE+\nyEECSsCx2p3WrYmJO+g3AoIPmsaiau2yuSk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3917", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3917` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARslG8vARdC4B+dPjfEW9u/HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5YzQzYWE0LTlkMzItNDg0NS1hN2EyLTA4OGRmYmQ0ZGE1NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUyYTNmMWQtYTQx\nNi00MjNjLWI1ODMtZTIzNWE1ODdiZTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc9E01QPVslOrtVZLTrFStxySztEyzXi2zr8WJJLxdPWRQAScW+CxR86njB9m\nS10KlH1rzoBTtp8uwwN39xgSd6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIu1XeQcNQMmj5Q2C6oNFz9ywdI8wHwYDVR0j\nBBgwFoAUsnsiZ5+B484YVt8m9lkQCA+3vfUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD+7l1laDIBFvDgDX4lwUXEWPN8n6c4wf3vPKl3hDZIlQIgbHb1cnSQ8Av3\ntACmvyhaGycpcOu5p7cmnT70TalAjkQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY/YOWxGfDIjWlIWuFSUfEDMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWM0M2FhNC05ZDMyLTQ4NDUtYTdhMi0wODhkZmJkNGRhNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6990xHQ/Bt8S6AydPdruNZr6JPsruZoW4sNB5GC4dQpEM\nNDebcQ1GHFRpjJsaDuC6wXDL1nueZo2tcSZHP3yNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsnsiZ5+B484YVt8m9lkQCA+3\nvfUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAII7iz+7TjDyYgwNzudX2Vxsz9PNAZDNcouzN7dFwuxxAiEAlHcNkW2e\nrtTc0RrqTmn8ODgI/4yIaQNlCC6wmHJcirs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbAEqL+t6lA1VHvCwhT6qHsbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUyYTNmMWQtYTQxNi00MjNjLWI1ODMtZTIzNWE1ODdiZTc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDIwYjQyMTItMTIyNC00\nOGM3LTk4NDYtMWJiNDkxN2E1ZTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nndHGy8wZextl0ITvI25TSKJtm8Um/3PMqXcKYT3hR0juwKy7BUl5rGspvC8dc2nj\n2tX3HAXG5k5hxPO6/TgB46NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIu1XeQcNQMmj5Q2C\n6oNFz9ywdI8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAPDlCjVzI4gGGCthEwd3MiYHmob38TjbxwAoSTJo6UWWAiEAvVnSasiW\nfX3HofOhqR6p4tO35iUN4bIB7aeOml/hRRA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3918", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3918` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASRmyI7tnuJ3BrRPinkvXqe8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NmE1MTZkLWFiYmMtNDFlYy04YzUxLTdlMDY5MDg4NWZjYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjlhNTg5YWUtNDEy\nNi00MTZlLWI1ZTktYTgwNTRlMDk1NDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETMkvn3YISGY/w1CC6t79ptYmMIg9gwFypDiPPhYSAhWzB4oAFuUXApIPd8Fb\n38JjbsFQ1soQK5exD455ln1qhKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPyc4XbVns84cOsyij9SIYq0W3xQwHwYDVR0j\nBBgwFoAU1rZTi4TLScsP3HZmXbHj5C7k4lowNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICteX0crziQqwYbUsAz3Hp0pJMr1cEKH0n7fZGUFrtmVAiEAmctyGL1DA1cO\nwYudryBiQ/9zDIJ6yQv/sJD7pGeJbTQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYm0pmv6H0SjWNyDeJTKwE8wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDZhNTE2ZC1hYmJjLTQxZWMtOGM1MS03ZTA2OTA4ODVmY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASl7cJNxjlo1YhWBCP4HtYecfpPZEg8FS5dTct1OTcp1Zwc\nmOH3Qmy8TmOmJM79N6Lx07anMu/xfDPQ2zJPI3jJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1rZTi4TLScsP3HZmXbHj5C7k\n4lowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMgNDZi5bKf/5T0OYJrNFBwDneqWpR2ToHrmwnSNeqFYCIQD4ijROqPHJ\nvUbdd/2K9sHwPVTFCiQIRwKpQ+9w32mGAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdxbjLk6xZP9A/AmMbZ4uNIvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjlhNTg5YWUtNDEyNi00MTZlLWI1ZTktYTgwNTRlMDk1NDAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2I4NjEwMjgtNDdmOS00\nM2M1LWI0OWEtZjIxOWYyMmUyMWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nga9M6q/8SkYLieclEtX6JMyOG6Xc9hLluGV2TDuMo5NrAbiOn/HBvGEZvYFsxb9N\nQMqG7btUaeBFUiv+ks5x7qNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPyc4XbVns84cOsyi\nj9SIYq0W3xQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAKSSTisWSsiaenAdhao8OjehB/sioqFcHyJ+44IDP9y3AiEAqnigz3vA\nDFE/xEK35Wiqmswbdthn1C17L9pNuMjp2G4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3919", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3919` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAeRfQ9wOJJtsOO8bTxUkQDnBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzMDJhNWI4LWYxOTktNGI0MC1iZGMzLTdhZDEwZTRmN2MxZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTgwN2JjMTMtMzQy\nNy00YTgwLTgyOGMtMDVkOTQzOWEyM2QxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEikspvH/A5MflkPFadjvPnmjHB6TLxHe5uMWdsq1dmUr8KjtOCrsEx7gAL0HW\nvd63uFbzC/Vsmiun6Srr1/p2DqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCONle6VMwP5kT9nG6p4j0KcYxmMwHwYDVR0j\nBBgwFoAU9EuWZZVglCcnEh9iXVx7PaO92nkwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHu7\nFbFQG3OmEN7sktZHxLD1TuNdDhnkENdxbDjJoPm9AiEAsqF2MoscEtFGfbZSLqks\n+1wu3cu//nnDRmIV4WJrM4g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdzE5KEQepvM9oH+pYv/F7IjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzAyYTViOC1mMTk5LTRiNDAtYmRjMy03YWQxMGU0ZjdjMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmihgVyOlSODJBzUMqB9J8EjgUblp++2cOViLEiWp/0mrW\nMUwExu7egeE9xP26JJKDQt3rO9nmShX1eWUsRjlpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9EuWZZVglCcnEh9iXVx7PaO9\n2nkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPvmmd4PVM/f5w9nfSaYn+vL9SyRR/u7q9BG294fvaFgCIQD4ReHmRsLU\nb7U2RT1NUX6eU3JGA2vTzlDI6G/uJa+F7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQokwyAmmV+zf7wrOPQ1NuSjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTgwN2JjMTMtMzQyNy00YTgwLTgyOGMtMDVkOTQzOWEyM2QxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTViNGYyOGUtNmEwMy00\nYmZmLTgzODgtODI0N2Y2MGNhMmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nh9hL6I/GUBBs/jwEZVYIPbHr+PsrLEjv7R6THqvnKPWVCftLvhgeKFPuOgwSA8gD\nJKtSI6xgxm2ZIdtOhVfYGaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCONle6VMwP5kT9nG\n6p4j0KcYxmMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgM75IGFKJ+NBqooA8+sOQrUuJXQ1dmWzY+OwKGgeIaQsCIQDXgZ3J144D\nWVMhTfxSyaJW2mit5c6s1IivzkgzAmM/OA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3920", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3920` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAcjfzIYJ2t/xiK74wzNOGZGxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0YjkzZjZiLWY5NDYtNDI3Ni1iNjMwLWUxZDY1NGQxMjE1ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNlN2ZhOTktOWRi\nNi00MTI3LWFiMmYtZjg4ZTc5OWMyODNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExh70wQ3AbhYq5FSk+dJsdarxvcvys+QyIF7g5FZ/cbr4CoVeBsLcWzWw3XB1\nfXiY33ucFSA1NQYX4gnrYbJBm6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULekKeA7PNNBi1Egr7kD8fpiWY6swHwYDVR0j\nBBgwFoAUpq7CuQD5NvIKL/k79q6zplQznhUwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEEqlD/TCi6s+YaGuaj2AVYGBHJrYj23TZrtzDqNNzRQAiAnrj14\n4zF7PjdispOaZTsR0EumLpSBNBneOdoP3saquw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATkEWnuHS43YOCHCSYFq6T5rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGI5M2Y2Yi1mOTQ2LTQyNzYtYjYzMC1lMWQ2NTRkMTIxNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5R2mfOsOW4Vnix0bkkwV44lCkDpwVJ3mzrYd0Wc6Tk9hw\n/jPukXAZMf2swrKej5FYMeILgxPrVlh4TlSkROBxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpq7CuQD5NvIKL/k79q6zplQz\nnhUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJtHgdClASqzM7RVf+dWIr/86RqTcJLrWJsmIYDpxIzuAiEAkDbFATGo\nShMtRsCC8CAsry8iPFk2UL6IPWoNVfkcDbs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWJZDQArAeTkOtzozrnPsHpFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNlN2ZhOTktOWRiNi00MTI3LWFiMmYtZjg4ZTc5OWMyODNmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Y3NmUwNGQtODE1Yy00\nNmVmLTg0ZmQtOTIzYjdiY2VkNTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEmlEavR2ullCJYINXxJUFVL0tUQ9PqtXQWbHQEVI8WiyMezJjAN5buOztbJyJJfa\n6DB3j3gxZm6lySQHJptHJaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULekKeA7PNNBi1Egr\n7kD8fpiWY6swGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgT/ISjEZGnm/WGos5DN4CYUourfF3D9P6rXS2LbfSnDACIQDnb5cTFvP4\ndHcdgSLdYi2ELDcoxatCTCH62CeloLFXxA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3921", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3921` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVdi/0FKjA5smyQgnANzbIHMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NmJiOTEzLWUwN2QtNGU3YS1hODBhLTQ5ZDFhZDg0NDgyZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWEwMTFjZjgtMWE2\nNy00OTQ3LWE5OWYtMzA0NTA0YTZhMWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE5bWCvZqvW/gkEzUJfZSLKpD1LBiLyoAxNJJokxvsyBwRybNe5Puc5W/QXv8\nwUhcDQBg/UI+gQJgDkZqZMqZgqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFUzG1z8WvEtB+I9K8YihJ483fKwwHwYDVR0j\nBBgwFoAUSVJJl/+cB0KWpAEX6b1mCKyK91UwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCICqsmOqQVtvGvMXV5z13UVXrJ34ZESy1MnKWOMOs2BDqAiEA1e33\n42CRWO4wFQqwuQ+ZTqsOwNcB4067YUCSONTUaCU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcrk52efV0qDbk6QHWwDaqd6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTZiYjkxMy1lMDdkLTRlN2EtYTgwYS00OWQxYWQ4NDQ4MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqBSaDt3S0AqiKmAwhswIr5jDJfgdrqmGABMuDcKfGydib\n9j5zKxQr5flwwP2n7QvunkDf/j54LS/bnnoKGuhAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSVJJl/+cB0KWpAEX6b1mCKyK\n91UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPg213TpABjNVDBQmJsnEyjaelbvrzC7BtSP5FUJKeuwAiEA2GmrUMGN\n6g8svOzcA2BtxHFHb72Sgm81yFELi0GOYh0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV0/kLzxUy9jv+NRwiJL4lwlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWEwMTFjZjgtMWE2Ny00OTQ3LWE5OWYtMzA0NTA0YTZhMWFkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzMxYTJlZWMtOTNkNy00\nYTFjLTgxY2UtMTBjZTgwYjg3MGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noE0PcJY4WUj7jbqJCyGJQNKitwsRcG6M+fBeUgBL8jyHklKtNEmxp4ctHr6U1cCT\nSJglcWJZT9eLWeJkKbmkxqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFUzG1z8WvEtB+I9K\n8YihJ483fKwwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgGVkqSckAn5gEbOiiG2Y7i5TSM5IZ5gqmneEyxXuiDMoCIG5MxjWifUc2\n7a+SuqtIcxrTe2HGuSLkHoyCBzE5arc1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3922", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3922` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAb6y9pgHaLRCozYx9UFVQFSVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMjg0MGNiLWU1MDEtNDJhZC1hM2E3LTczMzUyNjIxMGQ3MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ0OWY4MGItZmYz\nOS00MjE3LTlkY2MtZWY2Y2U4YjBhNGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsdATKSpcrJukzBKIdI4vvFoXYjzh6+go1Y9/Av/t2jfZ/b+/5e+HFW5PZKD7\nUBf3T+PiMGLkOAAFJ96xS9Ehk6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQdMriSDfE354NLABLMvxUH+E1LGDAfBgNVHSME\nGDAWgBS3fueA2nx1rLKCAmCHRiEZAGKCRjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA9bfbTivrmQ/BEH4BnfF9MkfVomVjeM\npX2zTmkiT5w1AiEAmF1o0EzpsVMtzAuNp285ybInNxP50G7BQW5V2rebI/E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdAVYIBD1PKjLam8K94+4DarMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjI4NDBjYi1lNTAxLTQyYWQtYTNhNy03MzM1MjYyMTBkNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1gacbXtgMqJvV4EbNLKdVXIGYC808BLkBYaCNP0ulnYoB\nnxN3iwrikEelxEo+1+zVjOSmfrnEv+JEvBhv1VRMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt37ngNp8dayyggJgh0YhGQBi\ngkYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJH5/MjHdHmQY9EZwNp1APAEw3Z530CfIyUGVzUbTToSAiBRy1D/bVdr\nGaKCWCqD2q2wLmRmeELG0UZftefOXaW/IA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVLlGut1VY2uP1/ubmPaA2acMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ0OWY4MGItZmYzOS00MjE3LTlkY2MtZWY2Y2U4YjBhNGZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2YzMjQ4MjctMDUwNS00\nNjdkLTg2OTMtOGViMjNjMjMyN2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJGoV4MOKxmsjJOjqzwPjmmXQNA+uZnFLxrhJRCM8ImTIEaSIoUmOwTOfHSZsp/I3\no1uusei92k17lp//QQZZ8KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHTK4kg3xN+eDSwAS\nzL8VB/hNSxgwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgQyCHVr2W5tCEyOf90dYFF7HFzkthUYPLgTmIkeGQ6gsCID9N3bJNI0iL\nsQZWJk3OJJNtmHidrnopAOejYjVb1XY3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3923", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3923` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQZ3OaGkJQKE87oUTA0UqYgaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ZjdjYzE4LTk4YzAtNDBlMy1hMjZjLTJmODRiMTI5NWViZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU4NmNmY2ItMTJl\nZS00Njc4LWE2MzEtYjZlYjVjNWMxNTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP5P/hTObI9kihBpkDOdSZjYn7433bGQtfVFggt1/pDjUbc6e4efAjOMdd8L3\nAw1gLJtGhkWMqgb5fTWkH2D7s6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOncoCC4+An9R+5IFGbl9h9qKUUUwHwYDVR0j\nBBgwFoAUv1XRYdps1NU3dktFTnhcdjZZox0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGpwbeN3Elri\nlXIdJtEIlUgUxzEm4MTozrZ3J0Tb/KfvAiEA6c4lOMy+XDCQH1s5FJYmQLCGys0Z\n2PqvWZfb1LvvFBg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaqSuoTbYXMFKvkfxxoMhzf/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGY3Y2MxOC05OGMwLTQwZTMtYTI2Yy0yZjg0YjEyOTVlYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv18oZqeChBNNafZhxHUQioOtkLXmY9laCSkQ/KIgDuGRV\nVobtRpjZKqhJfF2fP0NsaALnH27Zpg6NczBkPiPmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv1XRYdps1NU3dktFTnhcdjZZ\nox0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZYrY4UZ4WvDq6Hgusr5V+5Z6a13u73avQhRL2BwOxYMCICRtd1Wk7OOO\n95TyqmOKOG/VdZxvCFn8xq84fi1Td+9Q\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcO1XZVjfepx4d0kgQGbCMCjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU4NmNmY2ItMTJlZS00Njc4LWE2MzEtYjZlYjVjNWMxNTI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWUxMzM0NGYtYWQwOS00\nNDlhLWE1MzUtOWFiZjJmZTc1YWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkIIN7j9EDjhLJzAx+Eku1aQ55VzAtzPrhkSf2z3HbeQBGc5N1B0Us8bZUwJ0AA7M\njh4IPNYK/fL10wwdsyn1UaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOncoCC4+An9R+5IF\nGbl9h9qKUUUwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAIkr/CX5UdNpWmNEtuydnvoaovRkf64ejPhOFG2p+x3HAiBTBhicSl95\n8ZOBe6j5CSjvNSC+S7PG4aoFXKq07xtYJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3924", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3924` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAbAqQk3/9QbEreey1ZO2rXmzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2ZWY4NTI0LTI5YTgtNDg4MS04OTdiLTE5YzEyYjc0NjFiZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDcxYTg0ZWQtOTdi\nNC00OTNiLWFhZWItMDU4MDc0NTc3NjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8I9jXgKNZyixRY6gWadAyXHrIWsiTiyy8jxw+XTPn9UhPlCKuaLmV1nH4Qqh\nwDz3cU60ACslpILp0XAHcxdZjqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH5KGfYgW113F5Y+fRjiusAEb1WAwHwYDVR0j\nBBgwFoAU2+PWvD/7YlcCI9Zt7FV/XAjdXFAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDSx3PA/igy\ndUoh1w4zF8ULitzrPxpPGGoeKT6x7sYUEgIhAMh2RxLs63S1Uyd3yxeMstpkU0wr\nDqt6Hp40KCDBLIA3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQFXPoP7T13oGbDt6WFwbuIjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmVmODUyNC0yOWE4LTQ4ODEtODk3Yi0xOWMxMmI3NDYxYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARryfBidr0zDnB7m766PIKst1gSVLG6xn/cZfoU4GZ4c/rS\nXVY3UISIXzfD5TheBn4JiabrVOC5RXxdP6b5zjOwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2+PWvD/7YlcCI9Zt7FV/XAjd\nXFAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOaYmCxi8C6EPXyfAwk4H/DRxFqBFfq0NC0tlYgu2er+AiEAm+ovNVCD\noxplHSvOREbroYG4+H2RDm15yljZvJd7ahI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaSksydmxPOMyisd7M3f7YWpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDcxYTg0ZWQtOTdiNC00OTNiLWFhZWItMDU4MDc0NTc3NjIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTMxZTc3NzMtMWIxZi00\nODdmLWI2NDgtOWE5MDY1NWIzZWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsBq9St/xHPNTW0zXW5Q2leGDtdqT+F1kqD2XbbxrqhAGSd+7coaUfvsNRLrzr/KY\nx/C835SMQ4qpmMcU5QljE6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUH5KGfYgW113F5Y+f\nRjiusAEb1WAwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhANze0apgBAGEWIc6Ryg39PYDxeUw7C3xwk4/AU4ql/2GAiB2P7C/GpMu\nHI/mp6sa1J7GGUkkf0AtJljdHl2b8FqRTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3925", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3925` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAWlLXuSf6h2JY6UQGSyVTVDSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwYzBmYWE5LTg0MGYtNGVhNS04MWUxLTdlMDkwZDNjNmY5OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjIxNjNhMzItZjg3\nMS00ZWQzLTgyZDAtOTY5MTExM2NhYTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERSbU0ykyCVH4FOu+z0Wdcf1mfB7iga+hPHubazwjVsbavZnJt7lBBnqoMOxs\nl/Hveuz5PzePTC470CAVNGtUwKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBmOlHujwKBF1o119XKvZzso38mIwHwYDVR0j\nBBgwFoAUqtK519UML6tW0VJi+26Nk34++H0wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiA0TZX67lQ8\n9ApWdd93jwbA8qgTuphqlOjJ3QiPC/17mwIgYuSBOoZrwIx0omE5GKRAczI4CZAx\nhupkYg5tt+i4Cy8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYdmNog9bA8GhARDQ5h5vUQrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGMwZmFhOS04NDBmLTRlYTUtODFlMS03ZTA5MGQzYzZmOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0+Ei/Sa4z7lNjyZOlLBQs8jI0d7kCRJTtrvf5nZxx/Bu3\nQHIVfcwPD9A20CzYZ5EeGJWX3tEfyidvrBa9fCrUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqtK519UML6tW0VJi+26Nk34+\n+H0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLEjZxdy3IeXf6rtP7tO8eZhq+JCKZM0ixEhJI6gaQ+YCIQCxK4O7Jf0e\nfu5kTr0K7pntsPv2JQQ1AQDiceyouHu8EQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW0RNm3x+UnK0q9xPqafLa/6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjIxNjNhMzItZjg3MS00ZWQzLTgyZDAtOTY5MTExM2NhYTZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTgzZGY2OGUtMWE4OS00\nNTRkLTgxYTAtN2VhZDQxNTZlMWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZn+SVwLyrsR2WeVNL7Aw+soDG+kct5KMKhzkA/PXtW0ck9xlB+4SE9xFn6BqKi/i\n2fFCVK2t6c8uohz30n1a96NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBmOlHujwKBF1o119\nXKvZzso38mIwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAPx0PfRzkQqxYKDBcTftmSLDQO19C08ZsdUesVgKkugHAiEAhSe88D6R\niKy7Hh1p3fSBMOrZEmuZzJlI53YtqfLOjUk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3926", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3926` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAee9KT6xDX3v5CgIzELeJpncMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxM2UwM2JiLTA0OTktNDhhZi04Y2JmLTlmYjc0MGM0NDczNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNlYmQyMDEtNWM2\nYS00ZGY4LTlmMGYtNmVlMGM3MGIxZjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQx6AOnK+Zo6pNRA5rEj5gd8j6Bl6puYWVMNUvG9hOi2siSfkT2caUGAIkiXh\nqBkoJlusw29JAG/X/ugyS8EHbqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbIbhr0Z/lkHayRnt4Z7hgUUeMbAwHwYDVR0j\nBBgwFoAUFV+XKfM/SAnwdDTvgwMp5pXeEHcwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAzcHRZiGBVEsuaFXUCq/F5zI6ALqgXKpUX1jygR9ph3sCIQCnjSORgXwR\nmW2jPAEvbd222Nq8eIevKWzCCmDm6y1iGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfins61GLFn9xAskhXH6st35MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTNlMDNiYi0wNDk5LTQ4YWYtOGNiZi05ZmI3NDBjNDQ3MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASumPBFpfxnpnuEZ0OahQpS7T1OC1r4Kx92J5pefnsd6Vr4\nO+f/thva62fMzpO+kt3Ws3sKizaqg3fSRu4rDR7Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFV+XKfM/SAnwdDTvgwMp5pXe\nEHcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN+uY7/d8LEK90uMwFz6HlRjO+E08BUUW56EYc+wfZVCAiEA7kE3z32p\nN6L27SCfUZ13TVAAoYyJnP4fBmgVFMUq1X8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASVHFJ0zStjnw6zVJFvsJH9xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNlYmQyMDEtNWM2YS00ZGY4LTlmMGYtNmVlMGM3MGIxZjg1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzUxZWVlNDgtMDNjMy00\nZWZjLTk1ZmYtYjQ5ZTE5MDhiNzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3P2Jh8nCAhYjyTHN/C1XRjdjydXJ68Erei/OqPoN11hdaKsx3UBpTFU2Dj03FcoM\nYDYn3lpYF42f6fGdudJX2qNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbIbhr0Z/lkHayRnt\n4Z7hgUUeMbAwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAOh6f2aFn8I3Wih90ICoH3goA0lNrJaokTNk3PX/1JJGAiEAiIIKGAJe\nDAOLSffOVsh8be9qEhAl3/z0ds4gPvhSGn0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3927", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3927` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAY24LpHx9rk+PGScIA0GFUmiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1N2UyMjYxLTMwNjctNGU2Ni05Y2M5LWRmMmNmMWQwODJmOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNlY2U0MGMtNjAy\nOC00ODkxLWI5M2QtZWZjNzY5NGRhZTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJmNVDVpsVB2M2gh5382tIIWOSGTMwzWcv80A1JvfUSEJEdPQUFA2wEk6KVEw\noEVCrhXIFoJ7QYQOA2/sjSZwkKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbz+QbRn5Gil3QctoQGYYixv5SzQwHwYDVR0j\nBBgwFoAUny9TGm3/walRprjlgPfLFwl+ePkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiB2FOor6zj2itvOkOWw7LDHbFhAn+x6233N2Ql8NPQGfwIhAK8eLDWBO5/W\nk034uEdVp+p5anZ9GSmid/5JjHwx78fh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaqMdIPkoQq/QGDdqJ6l6tRzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTdlMjI2MS0zMDY3LTRlNjYtOWNjOS1kZjJjZjFkMDgyZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2RaSEvcE00FtT8DBMoLEY2HJc0adTA4CVV3A4D0z+xzZ3\nu2m1WGWFQVlXYUVH1p27VCJZhsjPw3GoKBtByBm9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUny9TGm3/walRprjlgPfLFwl+\nePkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPdPVUGkSb9crJaLINH6bCeDheydhWfNfrooi3UZyYXSAiAxruQ1duan\nkjpDoGDX3iFA925Mwrbl1oR2j5sbvHDSyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATpfvfYEMqT0biBEfjeWcMaeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNlY2U0MGMtNjAyOC00ODkxLWI5M2QtZWZjNzY5NGRhZTkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmYwYzljMTUtN2U3ZS00\nNzgwLWIxZDUtMjZkM2RhZTEwY2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nI+SJ71WObEc6hfqSrCM0TgpSASxSebOKmCzSLrkt6EVXmJqdk5bTv4gQdb1YMeRH\n/+GoiFPd/SCFH/65KGsZgqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbz+QbRn5Gil3Qcto\nQGYYixv5SzQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAJ08UiArvQRTPUA5gVW/wPH9fTaYu3mnHmNvMOHIdkvDAiBovAmBBf4L\nQQoL4N3stYY6gzaoZPNyZh0YrzyIsTWVcg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3928", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3928` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISARkdep7KtGzJ3QcM/84ITGONMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyZmE5YjUxLWExZTctNGEzMC04MDcyLWZlZWFlNTcwZWIzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFiMmViOWQtYjZl\nOS00NzM3LTgyZDItZWQ3MTBlMWU1NTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQi+bRqJ4Hk1lnLIgMys5caQ0ZGRZ8nXxK3KeNwl/jFstZ8nr0yOV5DGDnHjp\nt9Cfcmy027Zaj7tkPgU4J8TQv6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV4YX495g4epfTKqpfqrR29rhN3IwHwYDVR0j\nBBgwFoAUZ970E1Nscbgv0zB+3o4f6R6dv30wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAc\nThQ5HOJGKph6K/9W0ctHt+Y+A83RPYX+XSJBfEdstgIgezb939bq8XM+8KN+g9f9\nhaElUfp9XTdUFDi85ViCFYw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY3Mo8ABvLwFTysmxkKcsR3oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmZhOWI1MS1hMWU3LTRhMzAtODA3Mi1mZWVhZTU3MGViM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxK974k+TIXeuxRI3JamckqUsrtBtepyOm8TWpoKeHbwiA\n+HiCHKvY5jcRHlF3UgfTlTBb3iLLe5oXbuwmm67go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ970E1Nscbgv0zB+3o4f6R6d\nv30wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIiP/21tHex3+E29eHlglZz+g2ULv+EccaMdZNwA+mWECIFu2t9zAN0BB\nxGtLa+KuFVaRhCkWoIu84/aIxvErbhaP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXB7V2LDw9OX8Tyo7KagmYj3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFiMmViOWQtYjZlOS00NzM3LTgyZDItZWQ3MTBlMWU1NTc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Q1NzBkMDctNDU1Yy00\nZTk2LTg3MjAtMjM0MGJiNWUwYWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDKNeE4JxXRall68slYH8HupMn+LQdJLesaDeUtRcqC13CUnvCvdAYuN4VCYELjn1\naIZLltV2HW0yCZZIYrrxb6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUV4YX495g4epfTKqp\nfqrR29rhN3IwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAJOu1Wfy4kqdpInMcIcZ48q+qPsWwVPPFVqFuGtCY98PAiEAlaxfNyea\ncfTQCrJzP6T/WAcIz5iSRE9zt/J81wq7Mww=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3929", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3929` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAe3BJM1q80gf2baYe7K6vqyWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlNDAxNTcxLTAyZDItNGYxYy1hZjYwLTg1YjQ0NmYwMmZlOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU5N2RjMjAtNDA1\nYS00MGU2LTljODYtZGJlZWEwY2Y4MDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESLbtwzsI5Cs/c67RHkyTQJStQVqtmc3ApU0KBVyW932eEoc7c6LEnrcfA0Q5\nSX2eKchk6LuusQwvWm1hB2BqrqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv3ECXizMFTCfRbbDjAhQV+21dwcwHwYDVR0j\nBBgwFoAURVZLdZMF8Sx7/9dAqJeGoRkXwyEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAu1IzHsaBxXogD7wXSHgVfMJkO2/aWICd3R/ZY+12l+UCIBtI\nGCIcs61DUKb8maOqobekB5RA5vQXL4utcK/PB2eE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbEWjSvYElE3nqtmTxqicrw+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTQwMTU3MS0wMmQyLTRmMWMtYWY2MC04NWI0NDZmMDJmZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQb/amyS/uwp1Zrq6TQwghibL3W94QtD/ey33VpbXpsbI59\n19oZvuublx6yypqM9QoYmkZgxoeK+mnG1nEYVuRdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURVZLdZMF8Sx7/9dAqJeGoRkX\nwyEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANe+q3hUVVuFkXukPw+jpCsH28cd0BY9yN6x1z2gv29sAiEAnATRQvP9\nFHHiOID1eyZhrPe7F1qHnDCIKxi80oacq+E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf0KNphT02emMBq2Ui2lzmTxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU5N2RjMjAtNDA1YS00MGU2LTljODYtZGJlZWEwY2Y4MDkzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTFiZWQ3ZWItZjQwMi00\nODBjLWFlOGItODEwZmRmMGQwMmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/WWqZuBIIsTu+ibHEzN2JXQfqQChEbptYHcyQ8aTjmQa9JiSH/2KdzZzrhkTc6Q2\nJtu/UEj2NWbtrO0as1JOYKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUv3ECXizMFTCfRbbD\njAhQV+21dwcwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAKloRr/+l3BIiPgFiccDYpN7EMYCoOKlAPGmZkdSxvXUAiEA5mrIgoE8\nkQdPpgfddTawINeO/iR+D9E2/FyaaLM7Lv8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3930", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3930` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISATpIGDDz/tk6r3fAZjxBpUg6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4YTMxZmI5LTBhNmItNDRlMS1iODk2LTg2OWMwZTY1OGI0MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZhMjdhNjctNjk0\nNi00ZmM3LTk2MzktZTQ4YjE3MDZkNGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwvwkCGutarIwVCUHsLDV/31p7oy940rvFfujRGs4YH4ts11VcJ37PZ+qmD01\nlITYEwErxIozID/GnsfoiBzn5aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpBM8rKGnLgvRLv4fCBwCdfYisi8wHwYDVR0j\nBBgwFoAUeydHx1j9yRRNLnN0bbIvGZ5/t1kwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBCGQcKnRjuQo14ZtP935Noj6PGjyGSg3l+QOVbEzDfgwIhAJIo\n8vboD35cD85vo+RTS/Qfij6ZoJ/JNwRZWB1WOz/V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR9n+fuGMhHeLXSpTIn/oPK2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGEzMWZiOS0wYTZiLTQ0ZTEtYjg5Ni04NjljMGU2NThiNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkRIeD+Rw3gHNafH0Saz6zS1D3y8Yt5B6U3lqxo/gKmbzE\nIWObRBzWojw7cRaawrPOZaDqfCcoE54siDIfI+XGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeydHx1j9yRRNLnN0bbIvGZ5/\nt1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB67jqElg7hbzBVbc68r8k0nAAwDfsUwQjTxRdUCetYwCIQC/rpiJpOJ2\nMVkBksumFGlJV2QZ+gSi4L3aIjqha5NqTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUB5qZoc4gXNkbsHSS9cIuUJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZhMjdhNjctNjk0Ni00ZmM3LTk2MzktZTQ4YjE3MDZkNGUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTliZTY2M2UtMmNlNC00\nZWZlLTk0YzctZTQ1ZjJhOTZkMWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nitjdNHcmdGK2NUnCz/OO3CGFbSfxsvHDG7+mDXWFHmgH9cSc1G74OwA5A75mLdQp\nFvSitwVD0FnhP1Rg5EIQXKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpBM8rKGnLgvRLv4f\nCBwCdfYisi8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgEe6EVsnmoo3aHdHJyGnw3m0u0492qM6R2u+8xhxQc0cCIQDWlO3zyzd/\nzxrfwpZ/F/P4oxFvJ7ammwxuZmBhFxquNQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3931", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3931` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAYWadfQyUwFPWJ81TTjfx2eKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMzhiYzM4LTMwYWQtNDYzNS1hMzU2LTVlZmZkNjRlNTY3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZjMzE5OWEtN2I3\nYy00M2Q2LTkxM2ItZjM4NzU1YTViODBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE893jRZvopg3i2WZL01VqjgE3VQItwUQcwETTKNW9QlDcyC4lNtVqHzNdkdJx\nsg3B6SUmZ0GdJ6w74PhACN2d5KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFp5yTF1JxZk779jzjeoALZa/W4UwHwYDVR0j\nBBgwFoAUTCFEySyBAOa6ZVto4DFKGNOtyEcwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBBUiBJw2XepQ/6\nW0HoT7UEW9VEP+xFrwzYURqNaXC+ZQIgBW6vBDUP2XDZ/QlwszAKkj8mhFE6psaN\n/j7SYyBie/M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR9MoFTAMJy43nEOt154i5YdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzM4YmMzOC0zMGFkLTQ2MzUtYTM1Ni01ZWZmZDY0ZTU2NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCwAkYS9DJcoiRm+c0fPH2d0GIe2kfLL0o+PCVz4BVEbP/\noZoEMjqkTsOLmLKo34FgSy726q1k+aRL6l8MVInWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTCFEySyBAOa6ZVto4DFKGNOt\nyEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCNF8rTgBsaZ8J2fZ+OCAwdfqWpq13FGK/DOCTxPckEwCIQDIAPcodCOt\na6dyuLVfMzqY1t/JnrLTFY7sXu8OJKVuyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX06D+qboinRloVwLBMtl29fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZjMzE5OWEtN2I3Yy00M2Q2LTkxM2ItZjM4NzU1YTViODBiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzVhMmI0OTEtZTU3My00\nNTVhLWIzY2EtODE4YjhjOTAyNzE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nP5qQAQmjUVWopfRQaoV1j/JJp96ZIJjjjjBWY3sxfEEvgXY8XwWkYvTEJbVMc2lt\ne/Fa8Y6bg7tEMsk3E/9/daNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFp5yTF1JxZk779jz\njeoALZa/W4UwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgL4tt51z+wZVI70qlNC3OJNOZnyiuN+BhgY90Qb73+hQCIQDC8mbM4Pvx\nyaH0jtwiDbJo5yANIuiadx1pHJYDQlANUg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3932", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3932` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARQf6uoEwGTkHcgnHTPcluPaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyZjMzMmVlLWZlNjUtNDFhMy05MzMwLThiZGRlMDkyYWYxMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU5M2VlMmMtM2Rl\nZC00OGM1LWE0YTQtNDc5NTAzMzQ2YzFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfu8ZKss7kE5Xzxh3kIeBHiOlfiRhK+KM0448Qc+CnywCxsxivaRLldC1r3uQ\n1IVFyQugIff9uErGobrbn9j2aaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoC8I1woZN7MQ0PqnfDpzEFNd2GcwHwYDVR0j\nBBgwFoAUFxCygyTKJZUdjkv8lvdmruTKfPUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCUOwPNYMymMaz5QpLr2gS3hmrKAIw5GR0dJiEOixKnxAIhAI6RfeKBib8J\nqhMf/pwZsV9PwpSb51QlU2kkskagBkrz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQGXWIQhnQYFAfJBsdr70g9sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmYzMzJlZS1mZTY1LTQxYTMtOTMzMC04YmRkZTA5MmFmMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwnQYYOKm1XKaLcJnFYO4xqrvVXbERIUs8jsGc/WBrYliw\noMOfK4tc1OC+/yQAiXvcbC2FoncZD64cf17WR3KHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFxCygyTKJZUdjkv8lvdmruTK\nfPUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIhOwk3iUYKdTc5l5faRtNCLWdTErj+3Oim0XP9XeSkWAiEAzrTEgyDS\nfl7NMQWCg0Q4Y1ouL0IJMyWXl16HLhg9nDI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWRLscQxqpurowJOzREEXEeDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU5M2VlMmMtM2RlZC00OGM1LWE0YTQtNDc5NTAzMzQ2YzFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjliMzUwNDgtMjMwNy00\nYWViLTg4NDgtOTI3MWRiMDBiN2U3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nR8xPWlX0i6kh+QCzea0kfxHZdvcY/KCdDTk4FfoxwxyKaevtcYAee1FxzC9mkOvi\nBsFlbsG0a04NOILOUIkzYqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUoC8I1woZN7MQ0Pqn\nfDpzEFNd2GcwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgF7DslF4nYTe7Djp6RDWb9dHXYD4QIGialdguN0hZTbMCICkwibQ3O9kk\nFsoUanAwU0Pn+wk5dbC6e+pq4ykI1oqg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3933", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3933` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQsW2omnVB293a0dq2kpYNB2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyNjg2MjA5LTFiM2QtNGUzOC05MDZhLTY0MTZkMTQwMjAxNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQxMDRkNTItOGRi\nMi00NDhiLTg0YzEtMGQ0ZTMzMTJlMDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO7nuDJzNA8YU4E3ZLrdFN7o0AridGuY1Mcx7prTAZuXuM+XSo3lgWJcxcQv1\nekp8xu1yrwaZ1KaPCsVOBoiZh6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyxdXIQhPnHxZp2eh7NRaU1ao3B8wHwYDVR0j\nBBgwFoAUq+pU16K+HHwZl1Ermzt7ePcBiSIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBWRzI3SPurvJOeu0Cup7Fv62H9NYF9D/BPmnHHI7eb+AiBfkRu6BdpWp4/3\nMpGKMWzYUg8gyVJo9bGJS3OIYPPwUw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZJ9vO0SF8rKXkABBHQVR9VhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjY4NjIwOS0xYjNkLTRlMzgtOTA2YS02NDE2ZDE0MDIwMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQ5uico2wmFttdNtilO/yQoH/xZk4QIFChyOoN88caoJ4H\n0TIh4qVDNRaQeOvMyNXt8JOlCgoHgLviUCiStZ/5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq+pU16K+HHwZl1Ermzt7ePcB\niSIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgboQ+pzNJV9VA3QquA38mEUqyE/ldIAS9KAxcAXTr9voCIFG2GrMmCIif\nFAYfWxsz1sZEzd2YKw9paJ5s+jAcmi/+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYqd1Z8j4qi3qgx9nJAgE26YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQxMDRkNTItOGRiMi00NDhiLTg0YzEtMGQ0ZTMzMTJlMDhjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjk4YzBlZDItZjhjNC00\nODFiLThiY2UtOTAzZGVhOTdhNzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nw8m3GPP1tXmdMFwfI5aGsm7N3SHliaLtnEWCDa196SItp0qiSYDHhCzSJPQUCu1+\nOY8ABOErIY/LLapu8zlBdaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyxdXIQhPnHxZp2eh\n7NRaU1ao3B8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgHD5oa2G7vIF9YB4S95mLElGcRLOnU6pSGZ8WH+iqZjkCIASjL3TPSJlm\nmNI8rBejvFjHc8Eh98HPDR4HIcd+Fv+r\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3934", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3934` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAabgST4w2XV56mAGAlYPw14UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4NDFmMDBmLTVhODQtNDZkMC1iNTUwLTBmOWQ4YjI2NTM2NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgwMDllY2YtZTE5\nZC00MDQ1LWIzM2ItNjdhNDdlYWRlMzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7e11SzvNpqG1PXZCvv53bNz/barfa/+I0z9uUA3ZldzZUoyJADLmLq6u6G36\nAWhG2BAr2zfbNwHflsq2nxoUB6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQmtb6JQ4ssVa9C8Z+ukdInESyWUwHwYDVR0j\nBBgwFoAUxPjMhEz1XBx5P8nE/dVAojua+pMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAuPspvUJCG0IFI+biIGMPt6qpWJ7O6JgpCAt9MiBDjbsCIEngjlGWFxwU\nDBp6moVH+tk468JPT6ehq0oB0R8Kp/Pj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaKZLUZ3RB8NP5QYgDG11Wl7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODQxZjAwZi01YTg0LTQ2ZDAtYjU1MC0wZjlkOGIyNjUzNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBGPWMVMgim11fm4UIV+u+ZV3FcNjCMPMnobQNa2z5R1u5\nB9D/2BshdkVZQ73TDMpsAEt0azneGs2BaNGcpmT6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxPjMhEz1XBx5P8nE/dVAojua\n+pMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAO8CORJ5oatA7VyLUNjp3nKgywRK22IvkPUHwBj3/ni1Ah8og34AqTp8\nR2ttoJeMTMFWWw3F3E/bNpSnDEDvuTN5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAelFBpbFLkXUr51+v9D6H3AmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgwMDllY2YtZTE5ZC00MDQ1LWIzM2ItNjdhNDdlYWRlMzkzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmUxNDAxOTgtYjA5OS00\nNTdiLWFhNDgtMmJjYTIyOTc5NjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJVYWCBPV3s1ROTYsqr56A1Few+JoBldja6rr+yFglNxGxCuymfQUg6riRawwUoZN\n28c1hY4zs3XvqSlCSwbUNKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQmtb6JQ4ssVa9C8Z\n+ukdInESyWUwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAIH2Yrgle58J7JPVWpiMGc3pGoM7EWotHZljhgJ3sPSmAiEAhstGIF9m\nKFyYJNPORPVR80FDIuAxw4zdEFowpnoR7hc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3935", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3935` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYsffPg7/E48GdJIHkSU0n97MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NjdiZGVkLTI4OGUtNGNmZi04OGRlLWFkMDM0MzZjYjQwMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJmZDQ3OGMtNDMx\nOS00NDc2LWFkMjYtZTRlNTIzMmU3ZmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Qj9cJqLtZPCuCYsPQNZB/2voWBk4znUK7Obnymp6xv01V2NP+rw1m1olexx\nx7VmBdliaUeP3nUnZSU/zSvcTKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1eSa0Fy2TiQZchuF95LJLc2Nb2AwHwYDVR0j\nBBgwFoAUVbJLNyqEW/6S7OA5/54V8FJZtzMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA94egfA5LpEGTz9K7bNNk2eO/NnlnN0K4YGMDrbhD\nYCsCIAiAvJiVxf9cPmbAgQVm89NElRaGGDu6DB6rqke0Ylub\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf8LsWp7iNC7Y1R0884SFLoyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDY3YmRlZC0yODhlLTRjZmYtODhkZS1hZDAzNDM2Y2I0MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATc327WpoRgneGoXZo+WJ3pJsnRTKHOoBfVpBsMSCMMc1fH\nbA0O1faDhRlT63eDzcaPP1b8WxURt1FFD06feJaJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVbJLNyqEW/6S7OA5/54V8FJZ\ntzMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMS/7CU75M+P71WV4pT8WSGUwnHKddUYxrNguSS6nSpcCIEH6tuaMuxfr\n9CDXZiNPrqGLifh5GtdOcd0Fq/NItz8u\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY3YMPyJg71zpCV3GpJkbGLuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJmZDQ3OGMtNDMxOS00NDc2LWFkMjYtZTRlNTIzMmU3ZmZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzkwN2JmY2EtMTNjYS00\nYTNhLTgxYmEtZjRkZjMyMzU2NmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWmj/e/DJNV6Ie91wbyBuoTmxDIYzf6LZuCAS1bn7A9NYYuhNB3T5lpE1VOX4plUW\nyenl1iqpBxEpGoq+uQ9zTaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1eSa0Fy2TiQZchuF\n95LJLc2Nb2AwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgSLPl1MVeWtNC5YnD/ryQVBrCmDlaxGrb1tW1TCzCkDMCIEUK7RXmTT9l\ntPNA/eY7IDzEXlyyV0pQefZs9PyI8Tgk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3936", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3936` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAXaD0+QtUzplgQFjJ0Bq8T9cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0ZTQ2YjM5LWI5YTctNGIxNC1iMGM4LWZlOTc2NTlhYTBhYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzlkMDcyZjctOWU3\nMy00MjkyLWI2NzUtYzhkODI0ZDAwNzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuSXfakU1iaVSB4eZ1JXSkl6PYT2fPWXzmafB+N9Se4mHkwwm39ItEM3RBsfl\nlA1eMX9z9RQK3jIsKVSa/W4x26OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZWP722GEpkek/Wl9GUkyybNN3ZkwHwYDVR0j\nBBgwFoAUOIhHvf3wGlgG93Y9ryEcTUNZ5Y8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAg8Jw8Uni8GeEzrYZj23HcISOTSATpMmneBqFkjhSb\nmQIgYw7Ma0++SylJcBJnU9HhAyGZAEukFkD3aaPtXpJbblo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASrotJZk2274OkQucVe+q6QVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGU0NmIzOS1iOWE3LTRiMTQtYjBjOC1mZTk3NjU5YWEwYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk/9jk+wIwk9f0TFvnJrG6F9IvAMTFhjrrCRcOd3unLobA\nl6SCzpv1T2r9+elNneR9XNgfS8gS9AvHVD9xFgPpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOIhHvf3wGlgG93Y9ryEcTUNZ\n5Y8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVUSRAIAyK2i19RMrR/i+G435zgAgCTKpBYyXZMK7IboCIBME9Nv+l5F7\n4tK4VDNWI8286KxQMqRGoqLT+M+ZdgBc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASgxaBOa+VGlN7cXdrT5ifdIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzlkMDcyZjctOWU3My00MjkyLWI2NzUtYzhkODI0ZDAwNzI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjcwYzA2YmItZmNmNi00\nMTQ1LTkyZGMtNzk4ZTU4N2Y3ZGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuvaELRXeebloLpV23VlJZsrcSMvCOy1PwH3K/a5P5TVFAPbMv31PwYDf63cXi1sz\nGwKwgQ8HbU5HoXPQIv4SWaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZWP722GEpkek/Wl9\nGUkyybNN3ZkwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgddKhyhmgIjySqqVB/AaQmfOhPs5N/mRV1NKOBZU6TegCIAH95ik+ZCKh\nY28i3042O+87hc48fdqyihE4WEV3b5tr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3937", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3937` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISATw2KKHYmEbZ8kjwilFsBOujMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjOGE3OTk0LTUzMzItNGIyYy1iYzE5LTMwOWU5ODBlMjQ0MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzYzOTkzYTAtOWRl\nMi00MTIyLTk3ZTYtOTUxYTNiODYwM2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDBrF3L9HmMsI0Qruce9F0wVqFRQ3A4bEqnM5uSQZFPGjFCeyqBIl3xlDU1sL\nEryvj6/6/jis1ucaSs6zShiTQ6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz186Q6NUxN9d7LJNwoZsK8CKaSgwHwYDVR0j\nBBgwFoAUwkLBk2I6zoa2G67XuqcnFsFGdNswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiA037C/P2pQc8Tk40MZLHbeUGJkdvXdbju2jGp3IzSa7AIgHCLj\n4TT8JyBWAnnm8kGbruPnW/1ySD6utjz9ilTyFjE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUkOqksTrYMwjYalEP/H8GLpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzhhNzk5NC01MzMyLTRiMmMtYmMxOS0zMDllOTgwZTI0NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScE4XX5mIE4YflPMnf18DPjcWGk5LLeGiblOal5G55C83x\nyABRfPb8cV93jdIt6EFjn9HgtalMmGEzRJTFvA7Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwkLBk2I6zoa2G67XuqcnFsFG\ndNswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGI4acqeYwon8kQvVnxfRO4qkDIuv+m1ZWj3F3xd+HVECIDLzR6ntRgOy\nI9zlW1A5Wp0XjmwErob4s2iNk7ggm4TX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS5hvL3ZfVB1cIh9rvf8U+igMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzYzOTkzYTAtOWRlMi00MTIyLTk3ZTYtOTUxYTNiODYwM2YxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGZhOGM4ZWItMmYwNS00\nMTBhLTliMzEtN2MzMGY5NTI4ODU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntY5hKKlhLk7nJr5Rtn+tIpwlEhLVxluLw+JgWsMy4GkhX+jZ+kaeKs4g2rOOQD8R\nqY64BGzzEKINlK3odCOW7aNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUz186Q6NUxN9d7LJN\nwoZsK8CKaSgwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgRkTNxvXtphKbaO+86PcADtk/O2Sx/t8FvZoiFAk44xYCIQDHyMMyK7d6\nZv9uOE7kts60cJ7xKY2HE2uhWZ2ypo7zWg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3938", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3938` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVv3+AapIibSD2raNvhLhQfEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiNjMxMzk2LWFhNTItNGU1MS05MGQyLWY2ZmMyNTY4ZmQ5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFhNmVkYzItZmJm\nNy00ZDRhLThlNGEtMDcxZTZlYTIwNjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2rQo5ZxRfkHn7OQcuWugORz4UKLLASHaOezJJI2LoqGAQ4vUBq75adyxLayZ\n/JU2BR1eSWSwPPi5gzOqg2MeR6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFGhEUJUgiOlhYgLwq36mzsIbskowHwYDVR0j\nBBgwFoAUb5CpIcuFgNfuCkHYNr1JW8GEi0kwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAkksnl+5syHz3qYdCfIE19k4baAv4ij3M\nWxCQ7fU3D7UCIEMLn6l3bnWFvWbqWkQyDt0Bl88ChVtWNpDZDlM6R2r4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUc9V7xKCOvg39eRgD5sCnsyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjYzMTM5Ni1hYTUyLTRlNTEtOTBkMi1mNmZjMjU2OGZkOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbvY/z9voYC4tfS9sScj4ExhkZ8BJYv6jygu5W+R3sTWMw\nqm8VtNMaX9nqmQg83D19W8muvPIutX+aud4J+wjWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb5CpIcuFgNfuCkHYNr1JW8GE\ni0kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPU/9LvTk43l//ux+JkCnMtxHMlpAMkCZITRX2WmojM+AiEAp5l+0/Ee\nJC+SSKoxBww1cZhLsJNjx0AVeAdm0UvXGfU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb00g6n1dVizADlBOySgyfZEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFhNmVkYzItZmJmNy00ZDRhLThlNGEtMDcxZTZlYTIwNjJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWZlZWQ2NjgtODcyYS00\nMmNjLTk1MjItMjFkYmJhYmUzNzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZOurqhAm89D2bGQeFol6BJCgtaMuPfb2aLitZYE+nsWV65naant9xKFenGXCxtwa\nE2MdBJtyRejgBiPj2R1gR6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFGhEUJUgiOlhYgLw\nq36mzsIbskowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAL7iyU4F6pfUtP5RrIAVH2PEfUBnq/ztYlw/iXi/RmvQAiEA+fPRrs8y\nb7e+pBCX6MQEaOwyP4R34tTN5dfJhjpScLA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3939", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3939` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQJ+UYWY7RnIWUw/1JBBkqxpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyMDgzNmJmLTkzNzgtNGY5MC1iMmFjLTYwZDIxMDdlMGU0OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVmNGE0MTEtZGUx\nYi00ZjBlLTg3NDEtMGUyZWU4ZDI2ZGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERMDW7k0TsWMVxZmG6a9/LcLqjeyvYcZ5rqdpfBPE+tNbIuCGVtx87fMgrnIY\nfmhxrZ5jgnDXjV9eLefGQjxwf6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCli8anT0iUhjlpsrtrTmfgtoUWkwHwYDVR0j\nBBgwFoAU4X0ofgH3IXk8E7FtRo/Xnryc4cgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAhaXo1Bs0kBBT3vl/qIswib/nncG7sp5q\n3PwocYRrF7UCIG5pbNEPKR9A/5glLME9XWCadHZolQlPmzv0qThyTF/B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcRudC7GX26izMuJylfI8KW1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjA4MzZiZi05Mzc4LTRmOTAtYjJhYy02MGQyMTA3ZTBlNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQb6uRVnmgRtrQ9x2JzsDcqfg3MEbAGxm+wdI2/rvNyFAMm\nmO3fPUpjlI8V45VQpdvkVjsaG+oGUSNS3JYun2TMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4X0ofgH3IXk8E7FtRo/Xnryc\n4cgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCWLsa9W2zmQiNFxEuO9XxhR7ZKAArJnINghGD51W9NACIE5+2bk7Gd1Z\nitWqGnYFa8Hyht3jc7v0WNk0cQsH5qEP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYiofqBvVQ258LRJbut+LvqEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVmNGE0MTEtZGUxYi00ZjBlLTg3NDEtMGUyZWU4ZDI2ZGY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYThkYWNhYzUtZGZmMi00\nZGVhLWIyNWQtMDFiYWMyMjQ4MWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkenmPhxgifFopf+sMBXMollhrmirJ+6YIdVEh8eQgpE+17OWguaBnPGzdZlWVMSH\n9A73wpgdi93PYRRwbA1mMaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCli8anT0iUhjlpsr\ntrTmfgtoUWkwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgK7+RX1oi1any0sXxqtC3WoJVetM8s8mtIEpsQnSSlncCIEIWwRnH2lC6\n3gB2CW53sYNJuyoJsrQY8fsZTzkp7dXo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3940", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3940` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAd1TCAAyQShhfRdty4ISPWrnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhZWQ3NTdhLWJiMDMtNDg0MS1hOTYxLTNkYjQ5MzIwYWIwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzYzYTBhN2ItOTcz\nOC00YzY3LTliNTMtNWEwMzBlMWRjNWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqFZy3ZFmLO+uVS7/vfNJ28xuhbifmRnXMZlba+zCydqCWMwDfaS6WbJjlGZX\nL7LalQuYstMwnJ9SqtSfy4hd9KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk5OwRBRvrViap0bJ8xjydKMp/JYwHwYDVR0j\nBBgwFoAUSHMwRoviDlU5qrSxZJJmkT8ymsQwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBxUvwTUdQAsuCS\nov8bRw/9Le8qcxaX9qI2tj471sCTLQIgOjvOFOpRE5SpqJkYi/8SMCUw77hC0+UL\nrPCFOrtwMVI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUMda4AyQwbo4F3OJ2Ss92U1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWVkNzU3YS1iYjAzLTQ4NDEtYTk2MS0zZGI0OTMyMGFiMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwlUjV0wBtyd0SrZunCIJF3a0/cLjJDp+5C06q2nl/e4xK\n0kyBg2KrLEg3BCoyt3TO7Vi6wZVTkM9BA+Ra3xxPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSHMwRoviDlU5qrSxZJJmkT8y\nmsQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALD/gPIiiezDlyCVqP8FRmBdsVIW+gU4YBOmhTd2fx0jAiEA1fOfcR1v\n7bOKKOThLTM2dD5NwpFVS8IgXsP/bjwOce4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf35Jfp6qt1fwsWJY9W3twq9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzYzYTBhN2ItOTczOC00YzY3LTliNTMtNWEwMzBlMWRjNWRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTEyZTRmNTgtNDQ4YS00\nY2M0LWIwOGMtMjY5YjI2MzlmM2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTh92EkALQ1nm1Pvwt7GCutVoU0IBYN9M3FPQwEp222OQjEdjYhn7EFfDHMV1JpA5\nyKMIgYk54fhaI39eq1Y1E6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUk5OwRBRvrViap0bJ\n8xjydKMp/JYwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAIxU+v4KAVnKS5fwC4m8FPYxvB+qdzXVbCc3+d8D09M/AiEAqvt91PJG\nN0qgKFTcOVNpPE7zNlbfDo2D1+u7Cscm3QM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3941", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3941` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAecrz1jY+c58Pj/g6PrBwpJSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0NjY3ZmQxLTUwNGQtNDdmYS1hNDYwLTRiMzFjOTc2NWE4ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE2MWQwZjQtYjVi\nNi00M2M2LWIzZDctYjAzMTUxZjRkZGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDiCSmgCwg3w7vaOMMd0hEfZzj0yMc2eXe7AqbYr/IuVOQVNLa5w98HtwSOiQ\nS8kTqARcAcfOQrvDV/IrXogWNKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYyMqmwZpsDdZrN6a8AgbTItD3KowHwYDVR0j\nBBgwFoAUTeGTphXB2DOLGRIOtYMAO6n1LKswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCmI8nVospSmyZuUEbFIyR4dKzj9lHxrq1PwbSsHFnExAIgI9g+q6dphNOe\nFWfcddSqHdBGNBl+1ofan9vJHBVkqig=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf2ObjmR2tLiVsR20JNFNNOTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDY2N2ZkMS01MDRkLTQ3ZmEtYTQ2MC00YjMxYzk3NjVhOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9uCNmJdbqaW8G4Gdaymvu7K1QQ4mKD98XrswGjD67ZQqh\nydw5XgEka5rTFo4zBYvCWO4ZnulLcQ7VQTZUZ7Eto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTeGTphXB2DOLGRIOtYMAO6n1\nLKswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPVm0bOBq9vlRpE+QXRNkXu0Qru5mFcbP7knsiShZO8kAiEArhhGnMPN\nV/gii2XAEyZszE9TFomFHqWBeAgeZ+1RHjY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVJ550vEtX2MmNE5gFzk0/CZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE2MWQwZjQtYjViNi00M2M2LWIzZDctYjAzMTUxZjRkZGQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzYzNTM4MDYtZTlhMy00\nZDcxLWJjY2EtZWRiMzgyNjkwZDlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGpBwftmuIBHfmusOEXopooZzYYwDVALn0nTZMULNBdIF66NTUwReyPIX+JwWyDCY\nsGXkannpK0cvlf+H7nQzD6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYyMqmwZpsDdZrN6a\n8AgbTItD3KowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAM18ipAR5K6f25V+sTrgN6VysLT4R7l5oo+VxDtx7/irAiBvXTnr+j7M\nC78x0NL7Yn30FznkJsGfOOkqsXUO33pb3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3942", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3942` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQKm3FzGpOMKoTRZNCqp4wVpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViYTU4MzNlLTlhNTAtNGQ3My04NTY1LThjZWE5YTQ2ODYyZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZmMThjYmItNGE0\nMC00ZGEzLTlmNGEtMTU4YzBiNmI4NjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHICn20kAvDQHD4Y5vtOJ3eHw3Ox59TxkARJH+oXet+h7Y/5aGjkxVImQuLpn\nWeQ/fLD7pyW8ZcZIqnmeWXDt16OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlGQpKBbOaDdj0735WLAb6iyg5/UwHwYDVR0j\nBBgwFoAUFr2OeKBsuo0Fg/MRai3XUCbkJfkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD+7h2Gen2VrecQfTQ3Ec6NiIzUDMRrA2Ynfsk16/j9GAIgdw0exODREMMO\nGQO6bnYMHgI+TofRDRVllkT0A+pCUBw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdmlA+Hv+TZDt0An6R5/qRTeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmE1ODMzZS05YTUwLTRkNzMtODU2NS04Y2VhOWE0Njg2MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+GlmXqSuBbBBQFQrTU1nhH9n85K4GMNPh6Eq+EcddFOGK\nEd5jxfqyehwPbywwxs4ee/GULHJzVSQzT43tUaETo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFr2OeKBsuo0Fg/MRai3XUCbk\nJfkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALSWyZW9omkrUfqDL7Y3DqMID7aktKTFghvUMb3DMIjcAiEAnj7ApYdG\nr9tasfYbXfJ18NRUAc8x8sC9GPA6vV12W2o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY+UzZGGek0Bx9k6Mp/Q16q7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZmMThjYmItNGE0MC00ZGEzLTlmNGEtMTU4YzBiNmI4NjJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjM0MTVjN2MtMTIxMi00\nMjE3LWFmZTktMDkyNTI4YWE0MDc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nACSUdJdYQ5VYErTRd4cp9ru0drVmAFCKOxd2mmGsbvSe75N8P/4xbxgAPcGp7zrh\nsG5zlmaTLZQ7kdGf4wVjp6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlGQpKBbOaDdj0735\nWLAb6iyg5/UwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhANfhpetzKCt3Gv7eAVUXj1XUfLmtjWF7wypvjr9NyYWMAiEAyq8aVlvY\nwXeTqaV7QeFOtWNeubdQFknuyp48o3m8aok=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3943", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3943` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAd6e6cp9uDGfg/yV0EstX2FTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiZjVmYTcwLTk5ZGItNGEyMy1iNmZkLThlMDg1NjkwZmFiYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzExZmU0Y2QtMzRi\nMS00OGYzLWI1NDctYmJiNDYxYjE1OTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcTQH6Gf/M7W03sBaaHytcSUE3m26s7SLSbA0ZysCQGVpF8+hR3HmBqKj++ox\nRhisaU5XDPJnVTP4bvJuVoaxFaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHQRlig/wM1uWzsUbzDXaizIp2oYwHwYDVR0j\nBBgwFoAUURmqKV4UXDiLNGudJr2qU3jJK9wwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAqIiY5yK3twNMZqK8TtPApG1Zm9Pz+PZaNaRjWIknNdACIEGre2r2yNUA\n5qMjEAPVI7s4rZq6TC+Yaqd5Y3kN6vsX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAepeuulsbKSHnEawGRAHRBKkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmY1ZmE3MC05OWRiLTRhMjMtYjZmZC04ZTA4NTY5MGZhYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpkMngqDnmS0T8mVYDCBjNoF8A6NyZcAGCvQ1HIoSCZsXI\nwgdYJwKhq1QbAQtHU6kxnLPXph9KG/QFmIC+XRRWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUURmqKV4UXDiLNGudJr2qU3jJ\nK9wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCWOozqUcx/SCJ4/hj7tUsKmjABpFVrzEJ2iOLpXfsp4CIQD1U3UOW4fi\nBRrwip8KDkp20OPtY1Cud2MJCq4yZ5DANQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcyr6CYCJa1xO2XJOVderycnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzExZmU0Y2QtMzRiMS00OGYzLWI1NDctYmJiNDYxYjE1OTBhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTQyNDRkZGMtYTE2MS00\nM2MwLWI0MTAtM2FjYjE0MGZlODUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8Ofav8rC+zCKRUjx7XXTzK1SodrStS2Awdtqx1ZGvEpen6j3ISnZiWS7BJhrF+VU\nQw87lPLOjvPoUhki5iYl3KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHQRlig/wM1uWzsUb\nzDXaizIp2oYwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhALMJUxwbq5YId9T+ZqAioSrjNQFDH5WC0AcnS+kAiMNqAiEAtUpjrsA0\n1gAUSRI5erdct7QTqPlBXDzPIEfgOuJ/1rQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3944", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3944` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYM3TwhzS34RPvW34WOridziMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjZTUxNTA0LWNjMTgtNDg5ZC05MzE3LWI2NjA3OWRmYjY1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA3YmJmNjEtNWRj\nOS00YTkzLWE5ZTctMjc3ZjZhYzU5ZDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHP5B3xhG0HSDvOxd7izQVnIHEFSuLfsT4uRAzQvouMsKc8YFIYQDk81ejxA1\nf0IaTx6jsigwJJc/T0Djbk4zlqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrTvl/yhZ7kdfDZR8vx3xYFk84K0wHwYDVR0j\nBBgwFoAUHo19fpJcT2XEZnCm+r9N8aEprxswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBjGsqW7CnhGLgcChjhhdjzezxEpq/UJNl/5bwx0mv/\nwgIhAL5LfPAkQUk1D3Hn8Qa0wyBOL5pRFkKvvoVdB9VHSN6K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQWeJ+dhxfeaXxy/QpXOwS82MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2U1MTUwNC1jYzE4LTQ4OWQtOTMxNy1iNjYwNzlkZmI2NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJ6x2em6EaLcnwo/SPQYaIlj2u/XghKX9Gr0AnKC/oP6VR\nBOoOyos5Sb024jqA7CV1EXjPrO1GPyIbMLV3AOi6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHo19fpJcT2XEZnCm+r9N8aEp\nrxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALXfuQPOYjlSelx0f3mrdfwsSRF3/GB2NZlcuyFHgoqVAiEAyH9izbYL\nF3fkUPUbp0rhKJ1k6GFLSZ/TtpRdNzGZ3gg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXMPEGGge5cnZriGZNSFBkG9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA3YmJmNjEtNWRjOS00YTkzLWE5ZTctMjc3ZjZhYzU5ZDYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDM5NWQ4YzAtMWVhZC00\nZWViLTlkZGYtOGJmMTEyNjAyMDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nS2kvINArXtYIA6H2cghhk9Sw169LFxFkd+F+GpwJpc6D2sE5J0vk2CpOOwjWOsYV\nAD+15KBhJfwM7KjjJA589KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrTvl/yhZ7kdfDZR8\nvx3xYFk84K0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAKbLcxP6Hyz1lSRZTrdgifiFNGErM1f7+VVNwSeP5hb3AiBNRL/yeBSn\nJJJKemG5k2dpChtkT6AvGg5F4rpEYOwQrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3945", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3945` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYurTmw3aZFIhxw7cOHEwKMnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjNTk4MWZhLTU0ZTgtNDA3ZS05ZWNhLTEzOWRkOGM3NTQyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjg4M2NlYWYtMWQz\nYy00YTNkLWExYjctYTgzOTllY2E0OWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUuLDLaSb8FCdBhULJLtfiJaYnhhuw0sWPt5p6Ej50TqPjBvK/LBPKVz3/hxS\nvSXK+EJQiSAY/h5NvGFEkmRyCqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUntYHI8OSqbc8jBvAzN8Na5Vh+ZYwHwYDVR0j\nBBgwFoAUSnf5ehTCiqrrgFtpU0OEMaREa+QwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiASLpEF3iEGYtdKVLD9jdnFeEtbQC2v53i26tIJhXZR\nvwIhAI4fjlXSkdk+HVYbFWAZHjbUix7AXo1NASWOvidyyF7P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXKC4a8Ee1zDPsQpUKeRTIq+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzU5ODFmYS01NGU4LTQwN2UtOWVjYS0xMzlkZDhjNzU0MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKK3GLUGBeRmM3fT2iqspGRxQlGwFQBAmxLG+TZpGAp1Sv\n2bSi6b0T8M0POc1R2ISIpe+8Hm1D6ePYK9EdNLKKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSnf5ehTCiqrrgFtpU0OEMaRE\na+QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKCqmYnor5HqfanMcLOyMoWVMZn7aGkqOvg/toQDu2CMAiByDFWbiJxz\nZvJbG4nMSLbZxfmeaROH/lNg5A911gFCog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfjlus7V8gJ5khuPRXCpVijAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjg4M2NlYWYtMWQzYy00YTNkLWExYjctYTgzOTllY2E0OWM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWQwMmVhYWYtOGFmOC00\nYTc4LThhNmItOGE2YjE4MjNlZTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noU1TzRoi5EFxVmpqZ3nkGPtLJ6/bdNsTSXEZ6wU87zz4QtWjwiQPKd6XjjmgBXdq\n3aajnqOnrdZcaVMCE1FW8KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUntYHI8OSqbc8jBvA\nzN8Na5Vh+ZYwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAI4FbgMxGjf8XullMr6uSqiUCsYmTLMTLgFL9ToYnDOgAiA8d5vfdiWF\nr2nvr7MRqmnWf/iNut7gYlhgXIWvlM0CSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3946", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3946` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAbQ8u0xlQO9XLHtaS9hyGvaoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4MDczY2Q2LTE5YTAtNGVhZS05OGRkLTdiMWM2YjA2YjJkYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzAwZDQ4ODUtMjc0\nZC00NTBiLWFlOTctMmY0ZTc1YjkyYzgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ZyRpQoieoz8V1oiMJI9UR0z3lSt19auRMGkDKHkHzzBmfCnjCIjTcyrXJzZ\nHzlPKvbTVN3bnBzqUyATuI3moaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgK9qVsiRFJjj6WWfS55bMtofQe4wHwYDVR0j\nBBgwFoAU2ww0bUee0u2KKGuQB27RPXdH9MwwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiB0vmwzoLNoZ2aaySkKufOkgCoN2/52YDgJpkFbAOPWrAIgT89k\nWr+F4DR/jB9v8FC/GwgeVCyBIyp1PuvidzSNV+U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfHcgQk9wgCPAinRV2A5thdqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODA3M2NkNi0xOWEwLTRlYWUtOThkZC03YjFjNmIwNmIyZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgEyzBhlJSbAxpSEFOTqffo+9YFnFw+BD7k36wNNdsz5jM\nO31F3SG454eVk5i56NKOigkrl+yFi59uCpqlIQsGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2ww0bUee0u2KKGuQB27RPXdH\n9MwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHgof9IbrenMviEp0OhnEAYzxejr0jLYMoUX9qJsUmo0CIQDdOOzkr7Ci\n5DMJCIdYn5lQFL914hxY0glc7n1AMC/BhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZpsILBcXh5TJZGRjWMrrLcNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzAwZDQ4ODUtMjc0ZC00NTBiLWFlOTctMmY0ZTc1YjkyYzgxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDIyOGEyYzgtYTA5OC00\nY2E5LWI1YzctNjUzNGViMGQ4NWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZn3TK3r19zMzrm/vj/kop9n0NqZfEuXmej4qZKBcyDX5Opxh36vdJhXtyKZ8JiWk\n8T+bDm+hylwosWm4Kwi7+KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgK9qVsiRFJjj6WWf\nS55bMtofQe4wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAJ4hIwer1cnyxPiO7wdJD0vzhkuYNnyMqL6San9+bFhIAiEAmLLNjl6d\ni6Qrcv3e6wbrVwHU2nnepDTvdArfeAmnevA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3947", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3947` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARfzl69pTDgIU2ln/MEQ96f9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkODAwMjA5LTkxYTgtNDE2NS05YmYzLTNhMmM3N2E3MzNlYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWEyNTYzNmItOTZi\nZC00MThiLWFlNTktMDc5ZTIyODIyODVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELK8uv1HClvfpD1jj0MmIW4WncmLDiSDTDx+az8wlaYBS69yM9dhMaOL+EKOe\n4/Ku3UFAfODGBVW4eYVp8uDEnqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx6T5QwkQDA6N2bWN33yQJkfRYyowHwYDVR0j\nBBgwFoAUkZEQNH2sRTBzpfuMlDIitq779oswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAwdiShbGeuuOjf//D552j+7AFfD4R2dJgL\n7mqh8A6AHQIhAIdVZ+/JQ6qeM5mr8gYTbs8P1IUsa/HdpoA0ouCYwhFS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeNaqhf4IneVOrL27TuQYPk0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDgwMDIwOS05MWE4LTQxNjUtOWJmMy0zYTJjNzdhNzMzZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKzWDfbPZVXJIuF2fOsffdgcPwqBO7PAldqGpwo0Z2wDK9\nMPeTmGDxVjyW6z26nx1uBin2fG+tqf2FVqGjcYB7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkZEQNH2sRTBzpfuMlDIitq77\n9oswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgID1rQEau0h+Q8o/uB9onZtu+0wb1xe6Nn4LrB79+ETICIQCT/tvxjqmw\njGkdXfpF02JOiw+eRIyURdIALONzP9D4Rg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVrcQdGmk3LQk0FDkIao68NsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWEyNTYzNmItOTZiZC00MThiLWFlNTktMDc5ZTIyODIyODVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDBlMjYwZDAtNjRkNC00\nMzczLWEzYmYtMjYwM2UyNDJlN2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPjGO7XSEkck6KxmNhv5K/Jjart8CKSg8WxvAlXJhMgRsHxgT7JNg1CDab4C51Mr/\nnahfDFcoS6jduQjNzarW1KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUx6T5QwkQDA6N2bWN\n33yQJkfRYyowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAI2mCaZwllUe7g6zU6DnyQup4QuB0qdk5lUWUUxlLcj2AiEAjGCsyvpG\nt2/DAtrO1upIIywLgdejrm7lGX/No2c5zjA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3948", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3948` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAdrhbFH1zdBS/q6yEaTg7PLIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxODFkNDNkLTNiY2MtNDNkOC05YzViLTRjMjk5NjExMjQ2MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmIyNGM4OWEtZWFj\nMi00OTM5LTg4YWMtMDY4MmEzZWNlMjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4YHJgUiPM41qNIm/dQLdkhFF830a8Jk0BzKNLSxbveh9RkO36RWNF34xVyHO\nFetz94mc0ijEY+b57qahBFZMJqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpKoV3m1U/HAa9U3YcXOejIGWruMwHwYDVR0j\nBBgwFoAUhkUzl0KeXVKcXYPu52pFvDPcOu4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA7jOpRlWZjRa1Mse0JaM5RR5p4W6nAHsAJ\ncPXeA+ocrQIgTJP7jKq1a2eriNB1Qd2ulwotgjwMVoH6Fo6z8SRKEiM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbVNK/PNG43SbSepgDD5jJwhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTgxZDQzZC0zYmNjLTQzZDgtOWM1Yi00YzI5OTYxMTI0NjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARD3jGctaYf17yc3JgeT1hyfB5rlFM0N+8JbsO+gsYB88XX\nHwg580NoHb5QyCtiBUuSjCWW0TmCcIeFoMkkK1Dwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhkUzl0KeXVKcXYPu52pFvDPc\nOu4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD8yiaZEOsiQBvsM2xRCQGpaUnsc/7Th59bZPZxuBKWwCIFddj2wWMJ/9\nTKPiysrYzTot0ps21iMOLg9kTc6X3uas\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUmXGqZDMw1WGpQhDPtgyRCAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmIyNGM4OWEtZWFjMi00OTM5LTg4YWMtMDY4MmEzZWNlMjYzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjU4Yjc5YmMtMWY3MC00\nMDA1LWE3YzYtZGZjOTg4NDRjNzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nX8Yr/NnqF+m06X8ib+mzkNr6ZFogzykhKowUIccyjkah4DaC6DvRIUINtoimt6cZ\n7extQzi4AiHNK/v6NFaa76NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpKoV3m1U/HAa9U3Y\ncXOejIGWruMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAPXW9uKIBbwLLpy/VIlAM+ozP4L5D0aIIK0A84NCpkOBAiBy8dSq0K7J\nA919l4HmmUVUScPbNnBkmd1d3N4YvYkMIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3949", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3949` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISARBAUWRnFegoFoKc7t07GK+oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2OWQyY2RiLTU4OTItNDUwNy04ZjVlLTM0NGVjYTg4MjQ0MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUwMDQ1NGYtNGI3\nNS00ODg4LTkwMjEtMzAwOTk5N2JmMzgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESSht1mpOGsxo0XOSW6ct/o4AgIROXbAmORqK768qKIT4e76zhktKYuxjoCga\nj/tW2BpwuXl03gTdoSOjsddlEaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFdcqdzN/na+l5j+IOpoybRFnGx8wHwYDVR0j\nBBgwFoAUb3DgI1vqChrCGBldnNTr7y3oaOYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAJv2/1G52+WWYx0xus8dmKZoiwQ\nH2H5DSnHaQ2XSl9LAiBZ/D6FtIpnpAOonuKeqQckVFL25uUDvEvDJpll+zyi+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATUzEvOAFX8RMJEVi+jVZheOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjlkMmNkYi01ODkyLTQ1MDctOGY1ZS0zNDRlY2E4ODI0NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARW0YVcehdO6xI7zsQxptHvQg8BdkpTrNoC2WNS/im61+s8\nduJ056qt1XjZGN+st/WO1kH5ugAkEd94CQkb4OR2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb3DgI1vqChrCGBldnNTr7y3o\naOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRrVXYfiyQelWboXb9Sth/nCWyNpsSxTAwmwbO4r1aRUCIBQMbsW5ekMw\ni846gOlaw2kIn7VdOpsfV0mbgHHGyvbx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdGUwNm1vCk76JQRqVrNnstCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUwMDQ1NGYtNGI3NS00ODg4LTkwMjEtMzAwOTk5N2JmMzgyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2NmNWFlNGEtMTYxNi00\nMzIwLWJkZWMtOTkwMjNlOTRhMDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nb/osQRjq4vl5RtnG4Fc+jYo/iCeZXk/uL7JqNYds52CJr68AiXpecXmRhliOojY+\nUu8MHHueIzpO9CwnGUCAy6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFdcqdzN/na+l5j+I\nOpoybRFnGx8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgYYYVdGXUvuvimzXS5S9AK2m/rMQjnxHpTadZzqVjRpMCIC6j4kUMoPUT\nwIGtryRTwa20IACFEeydg3BwyH/dD5Bn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3950", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3950` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAVSw2O+Hhiy4NzAzT1d06vk4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5Mjg4M2IxLTA1NmUtNGRkMi1hYTVmLTQxZWIxYjEzNDQ4NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgwOWEzNjctMGQ4\nZi00OTBhLTkwOWEtZjlkZTQ4MGU1ODYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAHctdrH8Yj0oQKbRZNgN9RKOynyOrwi+E2abhBJOI5qPRUr0TQb/2K3S1zY3\nIW9vC8plTmky/euLSlsuawZY+6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgs9O8AO/ngnYLI4AarjjVbx8bQMwHwYDVR0j\nBBgwFoAUCYH9vICmWXUTjQ784dGI0b+Q3GcwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANB5ivwc\nJZqHBgB68yAF3DFfB1GraAa6TTPKmN14EbevAiEA25tgPdGEN6Bg4Kt87Zj+dj/4\nfmNy4AfaxLa1jwvTv+Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ/Fu7fSq3Ct14ucCt8pJ6TjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTI4ODNiMS0wNTZlLTRkZDItYWE1Zi00MWViMWIxMzQ0ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8u7HL+T+DHpW4142kbLufL0cx9OnZcg+UsHUhs5HjqytI\nchpk4RwX4YbefC83jC/SSNLc7Q9/4KS8BQecx5hxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCYH9vICmWXUTjQ784dGI0b+Q\n3GcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMWZDj3aP3JciXCaUy3r2fd5++yo46IRkNY4tD/hkpcPAiEApnzSmyc+\nlPRDxTYQ7uLF7tg2BX5bqOyv0AIaF0QWvMQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdXYzXXe4WUn/li7rATztW97MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgwOWEzNjctMGQ4Zi00OTBhLTkwOWEtZjlkZTQ4MGU1ODYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmZjMGZkZjgtMGNjYy00\nMmIzLTkxNTktZmI5NjcxOGM4YjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNrdVtL6rBicppBO/+Wqzm0KF0eg508HbyboVD5F7w64Q7LF8jvB7lv/33dep7nHp\niFdocGOMlqPe5HXp7KJEZKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgs9O8AO/ngnYLI4A\narjjVbx8bQMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAIbaJSvapFjzQc+PfGHyCS+Br0m8ku8JpT7+VaK6c+LSAiEA5cSjLmHl\nEF+1Yjb8+jot6p4oT5Z05Vvab5uFsBFbU/E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3951", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3951` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAeHf2P9VfCWwX5dKXaBxIBXJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxZTg2Nzg2LTIxY2MtNDc2Yy1iMjU5LTllZDMyNzBiMmNkZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJmYzhlYWYtMTIw\nZC00Njc3LTgxZGMtMDUzMTZkZDdjNGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX9kSq+cLiIiSVYDFILswCnEdKETetnewFG3OLFifUllEkBP1xMRjjQYNc/EL\nwFJE94UMXFytFSEnr6dH6Z+h4aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJtzsE3eBX+u8ZBKqRcf3F7zpW5AwHwYDVR0j\nBBgwFoAUS2L3ZH7XLr7QZmn9BuPFE+KyH+4wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgNtFynoac\nKRCVOT9Bg1lf8CRPiQkWIoQgNACxR0gWoqUCIQCBoD/KtAQyrRQCZxYDxp+76Dc/\nV8gCmoJ1/cp1neVJBQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR20mYyMtw/BB1Pd65atSJwSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMWU4Njc4Ni0yMWNjLTQ3NmMtYjI1OS05ZWQzMjcwYjJjZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAVHqzpZSsQS2kRrybce7tX0rCGP6P2lZ+vQ+F0WH/xtwJ\n9dhHDt7QD0FAXf3Xpc88zWK8vfJ7KVI8gODC9YLoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS2L3ZH7XLr7QZmn9BuPFE+Ky\nH+4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO62xzKP2a8iSVAFLXkt/1EgFuDgiF301+4rtn1e5vndAiBKeKT5vTyr\njov8a2MQaQJs+G6QbwvghNagp8/+y6haJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZxF3bPHn4ePDctvkXYIZmX3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJmYzhlYWYtMTIwZC00Njc3LTgxZGMtMDUzMTZkZDdjNGNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjdjZTAwYWYtNmU2Yi00\nZmU4LWE1OTEtOGYyMzRhMDQ1YzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPiIX60ID/n+8d+Q1aLmICm5fR6hTnqG1xZMT7T6yjvr1dvUvSWqq5YpX8ETS6LNK\n+XK5eHbu+M2DxH5RUDycKKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJtzsE3eBX+u8ZBKq\nRcf3F7zpW5AwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAOKr2QKQNGuai8VVxW+V7kYUI2D1O0fTa/8yAHRgwbgeAiEArdCeldIQ\no3Xi6SJgPN8dK5y/t+QFqUb+G6Esob+Xo1E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3952", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3952` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAaRQTM3wJE9VRgdbHzk1kXApMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmODEyNDMzLWQwYzQtNDQ5OC1hN2RmLTZlYWRmNmY5ZGU3NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjUwOWMzZGItMDg2\nNy00NGFhLThiOGMtM2I0Y2JjZTg1MGY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN0bE3mG1KgsD2RNS6dOQcZlq2ea1m1jroFA2r7+B87VmYqYaWp/+MUSb8rN2\nxs70FkwORqOnvmK3sCBqQXZ24KOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB7oOQQElXiA7afZxkEs9VqAH/OIwHwYDVR0j\nBBgwFoAUxVRb/Z7GX350aJbTyae/NFN5j38wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCJN9t/\nggtrb8kNbDyD6AGYNKXB0MfeG/j8duEJXBp//wIgX2i2YnrlKHAIV7BKMiYQ7lWq\nxwxECOjQteXAVWJPJ54=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdhM8Qma/fBYU5MxS4VBEJLjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjgxMjQzMy1kMGM0LTQ0OTgtYTdkZi02ZWFkZjZmOWRlNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnqBrbq74BHi+hrhmQe0Y0L4Z4ACg5vNzWV5fnc3HDeKwf\n+2OkWJIuLpMuXJPWzFOebX0eRdYY5UbzEwE8qdLUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxVRb/Z7GX350aJbTyae/NFN5\nj38wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJQD0BLT+I92YFBJaaWnTEtcQlKPsILYlqqX6NgSVR7HAiEAgyl3/Q9L\nGeGe4Y3uDZIAnXyYeL7HZ1rzYBwKJVzi++0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUrK5lSasV8KriHQWf8RZf9jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjUwOWMzZGItMDg2Ny00NGFhLThiOGMtM2I0Y2JjZTg1MGY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTFkOWJjMmItMzU0Yi00\nOTgyLTgxOWEtMWQ5MDk0MGYwN2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nI7Z43rPu/4lLUJ+y4DbgGs80i/ozTOvfueoJcUfqGbCvECASubVrTSB2AU83HA4G\nRfXm2IDygt7uVvJBc1F4xqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUB7oOQQElXiA7afZx\nkEs9VqAH/OIwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAPDhtt4wsgVRLNeU93QPRihfJ0SGENTc4uQ97AytjdBiAiEAuxENDMDv\nam2oiMIsh2fmlK4/FUg2mi/l/vitrS3l1gI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3953", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3953` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAf5pQTkVgYre8x6denD15jfpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5YzI3ZGYwLTk0NWUtNDQ4ZS05NzI4LWZmMzM4ODI3NWQwNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzliMTAxZGEtNmQw\nYS00MTMzLTkyNjYtYjU3YzQwZmJmZGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Xv9aFHAd5TYm05kjcOkGj7hOuoqjdGapuAMwzWT20l7GfqC+WjZzsqUQT4Y\n6MrIWi8ldoRuxPwZWTTevSFszKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGx0cpGHiirASjdOW+rfv1xtlYecwHwYDVR0j\nBBgwFoAUxBVDaodXHeSfnicakt3WK+BM8QcwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCHq5nENAH8/6VsiIUQS7Qr7su8RoQR5rADiZeuC+2evAIhAP+0zbE/\nnOTdtibBqKPJjcQEV/Qg5muQwFHHsQJN0xhx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX1bjfJsub+WTVkNd4coUnCUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWMyN2RmMC05NDVlLTQ0OGUtOTcyOC1mZjMzODgyNzVkMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9TdTReWJ5fopOcQLhCW+0rR6Px3RbUTsPfpdlQoY/l+tB\n12/9ldgwGdxpSjuVCArPECFyHU1G7z21bnjcBR12o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxBVDaodXHeSfnicakt3WK+BM\n8QcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIpsqegQkH3iJ5S2k0spOdtfCCGRnQ/O9vyGjrzPpeeXAiB+MJKwPd1b\nL3SvD/aTEf13I7+27nOWNKXo0KmdOjbItw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeiofqSWdwII2Q5ZoaqcjuF+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzliMTAxZGEtNmQwYS00MTMzLTkyNjYtYjU3YzQwZmJmZGNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmMxZjZhYzYtZTQ2ZC00\nNDViLWJhMDktYjNlODZlYTE5YjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwgCjxt2pJKYykgLuEGpO2D2VvGWyegHHcu7l9YArUpohnBi/7aKhDQ2CgcqGC3gS\n88yjzaHjBFoCc98WaJRo5qNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGx0cpGHiirASjdOW\n+rfv1xtlYecwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAJ3pra6aCYVyInMdu1OJkZIc+pw0evJf+45TzjqCM2Q+AiEApZsoftNJ\nWjBMCg6drV7GEV5vJRtLmfHExOGnDmJ95II=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3954", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3954` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAVE01454J6dOL5cz73NLgU0TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMGVhNDQ2LTMxMGYtNGJlNi05NzczLWFmNDhlZTQ4NGQwZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE2ZDA5MzYtYjNl\nZC00MzE2LWI5MjEtYmE3ZmFiZWExZWYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQn1/TXOMsYX2u2yDC+DQhAu+duSDDRzs6X7hJpYsUsDKFu+JwcfO8IWsMnEk\n+q2uF6LN9pjX8JFSQcWWFS5YPqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvrRQFX6MHYxG1VAJHph9kvuC2KMwHwYDVR0j\nBBgwFoAUslHAivVYmGues/x7E0KsI8oc0CowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCgdPP1ucPFCEKfvT5B46Z9ds//iLsyMLFobkVZc45fhQIgCtFeJ6t6\nIDDl9qCTy5s5XkS8EYu74DfThkg5u+3lhoY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAczpQLcK2sfcI+lU7C2gPkOWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDBlYTQ0Ni0zMTBmLTRiZTYtOTc3My1hZjQ4ZWU0ODRkMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy9CVWFxNlMkqQ2Zd6I98lLtnmORJ4/2nOBFwv3afFWjvh\n8UwlGPoczVvg/wn7AAlM/5doXkEA/VM6YXyug1Mco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUslHAivVYmGues/x7E0KsI8oc\n0CowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALeyGz3jVymwD7n/h0pYMfGluCwoDhx+l6tpN6gPvKN8AiEAmx8lvsWl\nf2ojD+z14///Q5tczeenI7BwR1vHZvzvPvk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeYs2GW7uDKqrmWniR5ctwpzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE2ZDA5MzYtYjNlZC00MzE2LWI5MjEtYmE3ZmFiZWExZWYzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDdjYmQ1NzgtNDM1MS00\nYmZhLTk2MTctN2RiNGUzMDhlZmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nS37aYJ5yMu3Hi4g6z2kSH/GByzRrzJwFdj40kP8Duq+OJUxnjUUbD08EnNl6TYuE\ny8s9bWpkYHvv2N/ysggUn6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvrRQFX6MHYxG1VAJ\nHph9kvuC2KMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAMNCmu1zHteCwFKW7nFTXV6JvnzEQDnuqOL+Clcf9FoxAiEAtigOBaOd\no6Zx6a5kpFZ10o56U2bSEuOYf1CF2fx7NV0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3955", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3955` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAQq/TMMiQ6QveHPOW1dNpMDLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NGM0NTI3LTcxOWMtNGQ4YS1iMWExLWE5ZjQyN2UyNTVjNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWU1Y2ZmNDgtNDZl\nMS00ZTBlLTlkMjktNjQ1MWY0MjliYzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuyCsg2xr/FpSkuBrmiWIUKDrF3zpYRf5oVNA9pwsxFm6cJZ8vdRgbW8pWhvc\nzTHzAvwXxDnGoeGKG4pAgOq0AqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm7CVUIkaygvVEXCTpgbynsX8uUowHwYDVR0j\nBBgwFoAUABLqvcHtLpT1EhjICXVRQQzP3EEwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIDHkdPncpe2WJXzXXOqyY7Xdys3P8hQtvgJ2K0oPeT9xAiBNubJDJeau97G5QTDg\njkdjhjNbrV/eqENEZDhSOrCXoA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXI6LODRQYiv+uw7VFbGM9hJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODRjNDUyNy03MTljLTRkOGEtYjFhMS1hOWY0MjdlMjU1YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQN+2pjwSyAe5aIsYErohgqTUQwdb0Dv9yn2A9g/itBUle0\nKdIu4Pw69+CX8k5kDXaAciTIITrSXt/Erx1r1XRHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUABLqvcHtLpT1EhjICXVRQQzP\n3EEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKZchYb/ZPvYifwx/ZTqJ7eJJV/a/yEY3Jzyd87IsqaKAiEA/JWsToQH\na0vs5HrCfTr0S8k0KlAbK+hvFHqEMAFoj8k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAURLN58yh4kcM9bI1rCeQkH8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWU1Y2ZmNDgtNDZlMS00ZTBlLTlkMjktNjQ1MWY0MjliYzQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGRmOWEyMGEtMDVkYi00\nNTA2LWI2ZGEtMTcxYTM3ZGI0YmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlxz1PKoWzxfXYI5Pb8S6UPaxJwUZ6qgu+yyP2Ep0rAACOP4SRvaJJvzwmUhgFQyA\nriJo/Dduoh4+xQvUMpoLF6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUm7CVUIkaygvVEXCT\npgbynsX8uUowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgS8EinMYBriCmUOrkzy3+aAiKyA2N9HOisgn5A/iIsjMCIQDj5Tk1qRC1\nLa50h++aq39G2uO712xwdPom6gp195ajeA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3956", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3956` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAaATV6MQpTqX7grdcl2d3XCcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiMTY0ODQ5LTA5NjYtNDIzZS04ZGUxLWMwNzAxZDQ0Y2FiMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBmZjBmY2UtNDRl\nOS00MWQyLTkxZDgtMWJiNTFjY2YxNmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEolOapR7UTkxgalCQ7xX46Yks16dvv65tGLgNbNESwTH8xpj/QGo+1QS4qR2\n/we+tkGy9VuHIXppGMbte0/+T6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULz6Xc3sUQPx8yIkzi4thwEsJBa4wHwYDVR0j\nBBgwFoAUWYeVzMmF04VdavM783ogz8hRrt4wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCcvNcS5Tow4iqQQj0cD2FBJbjcjRDK0i1XDsoGYJq/sgIg\nOYAMnX3/VM2ulGEpTIfPXeePScVgpg5PhIEzWCoQ/as=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAasvlQS/aAmgzuSRZT8w5OmIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjE2NDg0OS0wOTY2LTQyM2UtOGRlMS1jMDcwMWQ0NGNhYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVQBAa/pcBneUVUD7ReAnp6snlBNAylF4vOp3Fa07rNYcN\nnN1+tTO/iFGrJwvpy4Ck/Fv7JyVhRx4HwIU9gxdAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWYeVzMmF04VdavM783ogz8hR\nrt4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANn1YTQCc8H026BYpFLrYYz3JQVwbmqz2K3bP9sw9SoiAiBUSLN7FDos\nVUT2Pq6h0jZ23bhCQV1gTlMdWUfMDH6Emg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQdNiquDqtGpC1H0XXNoeiPjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBmZjBmY2UtNDRlOS00MWQyLTkxZDgtMWJiNTFjY2YxNmNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTVhN2NkOWMtMzI2OC00\nMmZmLTg2ZWItN2Q3ZjA4MDE4ZmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+sa5slIkW/cU1Z39+E+Wd33QgZknHrd3UObS1tYBWm84FVdO6KV/sBvpNZIYfVl+\nAauzgyzLkQ/jSox1/HLGW6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULz6Xc3sUQPx8yIkz\ni4thwEsJBa4wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAKaMDZlrkU3+TgcSBHRNj9dIWDrbx0vy2SUXqYFkhzdPAiANo8zwPmRk\nqObCKAMdqwr66/fooxldkL4iutmRbS/GNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3957", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3957` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISASoMZPvldFms41vPywUnASq2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMzlkNTg4LTQ0M2YtNDc3YS04MDJlLWY2YmIyNjIyZTk2YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk5NmYzOWYtM2Ez\nZS00MWIwLTgzNzItMTg2OWFhNTdhOTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY5UBuzPsetFgTKApG2Im/4MUsnmEqmxOxoVG1NijoExptnNkWiO9khZRUueJ\nu2Zo21RvQ04oftkkumhPRUZ73qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0T4swFFrcBsm5hN8MFuQuYG8AuAwHwYDVR0j\nBBgwFoAUiIOKWi2HBH7lpI5GUW1K8sUDyL4wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIDnuKPwWxjk0R98UaH5mEbskxoGkgbhCiSRbjxTFx3D9AiEA\nv3VGtBH0wPcp4JkmUi/fWnMg3uN+PiB8Yj1QnsAE3zc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT9tM9mIPiPPXIeW/2wIPoGJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjM5ZDU4OC00NDNmLTQ3N2EtODAyZS1mNmJiMjYyMmU5NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1SHOdNiYDoMi1l+0OUnio7StS5+vhb9OOLRFuM46w8kgM\n/aIJ1GFEUyyrvOdgQ63WjCvyyf+i5QpOiSMbxxh9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiIOKWi2HBH7lpI5GUW1K8sUD\nyL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdkPwdOgWNtFX14Ev2BdfJS2q4DS3WwtMkyQWT3l2W0QCIQCR1KQwezQZ\nxFLo2Q8lsECCHYhwvm5Pmi/Sh5eFQmN3+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcP2OSEb6/E2xV1jyigH+tcaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk5NmYzOWYtM2EzZS00MWIwLTgzNzItMTg2OWFhNTdhOTlmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDUwYWM1MzUtOTc5Yy00\nOWM0LTg5YWEtY2I1MmIwZTJiN2Y2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKTsjyEaunangkR0yC/cFv6qMel4jZQPEUUyrH7aVisehQbFc0nMABfT0cPpEq+zj\n1iHKikd8Ansso1r7rRdeIqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0T4swFFrcBsm5hN8\nMFuQuYG8AuAwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAJ8OGDwjFcLZCVoQ/DBnihXp+rHtdSu/Mk7GnqGzLWAYAiAkjHOo2INE\nZIdksl8h2IXQZMnV1UxqqORygKR4UWpq4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3958", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3958` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAR3ix1ig01hcKzUci2aIaDEiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNjhmNmZlLTg0MmUtNDQwMi05NGY0LTA3MTViNGE0NTc0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg2ZTI4YzktOTRj\nNC00MGVlLWI4OGEtMzJlM2Q0MGRjOWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpDFUJcb9juPqesHgWvvdQf7eMo7IMUs/5H+rvzpD1o7PB7NDy8MN7D/xNKEn\nACCjw+EFioIRhRzRcwukMUNpgqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwSqSdmv3Bzph3zjO7ZW1On976WIwHwYDVR0j\nBBgwFoAUv1Yy9rouKU94jT3wrbc3BP2FiuEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDFPRGCZ0xk\nZkciDFqR0kx7G9TSi8GclG/r47Zjsh1m8QIgHPeCGS6Q5sCKoneVvufB82xpyW2y\nu+g9+02xAEiAD8g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbheSGntK6HWLGoBjB/RScshMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTY4ZjZmZS04NDJlLTQ0MDItOTRmNC0wNzE1YjRhNDU3NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmXT/zpJDsGfpHNJ1VS4ipmGXnliyazEH1YlvNuzPV0la/\ngXXpROy0NUCQg4A2dC7j8t4/JArK50HmyHpL3WhPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv1Yy9rouKU94jT3wrbc3BP2F\niuEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJjbCdtp1++6OjNXQOgZvVCMvZJKCRJh/rvJ5+CEfw+0CIEQMMGBJnfA3\nnVgdNmxdzqsOvVVjFMUfxLrpQGKhJVtX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfinH5GomdFlgBNhDH8zz15CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg2ZTI4YzktOTRjNC00MGVlLWI4OGEtMzJlM2Q0MGRjOWU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDc0OWZhMzYtMDNhMS00\nY2MzLTg2MDMtNmIyMGY3YWIzYmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTjfzRF2JMksF2vSAV+vLn9Sn7Xz+7TrcXHbeLGrFGBRM8zJhG5FlHkieaI8o5fXq\ncKpS3EKWvi0UL5kplUiQfKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwSqSdmv3Bzph3zjO\n7ZW1On976WIwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAJOEzcbUlzh/WfVGhCLcXVGIUHWxxBkPPyMe9ky6F5nTAiEAid8ouKvJ\n531uWw8Zn6r0MQZq/2aB/1G8wa6pGcTO+bU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3959", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3959` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAYU3DZPfwocIMQHmMmjqy3uqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMmQ1YWIzLThmY2QtNDdjMC05MWM4LTEzOTViMzk5ZTBlNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjkzNDQ2MmMtNTJm\nNC00ODc3LTkxZTAtZDhiZDAwMGUwODg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaUmLfYVF4LIS1qQZJO/JoVjtJUPNKR1mpSOtBwB+g0fsdaXV68Nvh/p/CdwU\n1FCM4OnimhCRjgAYP1rTGddOVqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDYqUgqZS4uWmhQ08/A/E3s/miP0wHwYDVR0j\nBBgwFoAUvZFo7HEtiqmVwzpJu3TJwsdpHbAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgJE2fKy4GXCfL9RlJ1BxbTw2CID6w6VYavaNEEp8dZvkCIAiIUwSb8wiP\nQ2nXmGCGy1Q/LW8EL+tU01oZl2Fki3yy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUg8eB7AzvE2gclRJxRbWZMgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDJkNWFiMy04ZmNkLTQ3YzAtOTFjOC0xMzk1YjM5OWUwZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg1Zo5w8D+TIbfCMPFV8+khp0zQ//uAYShO8gpvCBiIx7u\nWl24HfAsxxQC3i/sbU/m1/ZQOJsiTg0sJQz4laCDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvZFo7HEtiqmVwzpJu3TJwsdp\nHbAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNy64hWpaVO4TAsP8g1YXc0SUPREbj+AcUaZ2jcoydqsCIQDBAjecH2IZ\nElgpECtkTWr+MaUlsUTdFmKnzsu6OV8+ig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcpNJd6XOwjygKOQKJ+63DG/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjkzNDQ2MmMtNTJmNC00ODc3LTkxZTAtZDhiZDAwMGUwODg5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2YxMDY3MTEtYjc1YS00\nY2VlLTlhN2EtYTE1OTIxMTY2MjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/wmSCz0xj2I7DUkILk4AwAolFu7W8NTQ79/cteIdpJ9JwIG0Ory1d2QqrP11HCG7\nMCjIYc21bOvkvayw8JvjcqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDYqUgqZS4uWmhQ08\n/A/E3s/miP0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgfjN2hE0riEk+WZqb4EznBV80qCRlh5Df6WNt5kz5o4kCIC1I/ielo7dA\nLPd25Y55JuP/0VYJBkwRu2ggqV5H0p0F\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3960", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3960` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAYQPe/5y3R3BsiFR9ers/wQjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyZGRjNTIxLWU5MGItNGNkMC04N2I0LTU1ODA3NzM1N2RmMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAxOWY0NGItYTJi\nYy00MjU3LTlmODQtNTczMDBiZmU3N2M0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZqNVfCDxX2a9EoqLvwzM9FCfBKg6GHYSCWh6NZFJaSWs6Mot+eIK4Dy2+YfK\n7Xpr+qHZ1SIuOVxP3sfxSRjAEqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Yd0HgXdL6LtPG+W0lrfZFa6UhIwHwYDVR0j\nBBgwFoAUrt/RHn1eaCXaXZyhqj3nAuhJk1swNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgcCzRUChVmwIQE2GVpUbiaQ37CU6EjnCDwTh+HCBVMtECIBvRqyg8x9Jd\ntLuHqkhSUaKlxKkCsGJobGU2dDkYwYJj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa2rKQrwi43cAUMPfklvskQHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmRkYzUyMS1lOTBiLTRjZDAtODdiNC01NTgwNzczNTdkZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUIoZsVkVtbXvgyR2Hkd6rlXzPK8Q7ckv1Dp9WCLnhaI/g\nTAxSSb6cXZFfmaOLIzN1LCZcsmDsLlHZ/+jWBxg2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrt/RHn1eaCXaXZyhqj3nAuhJ\nk1swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMOrWqwxrn2cOfR6aT5jFF9OftCrjsJlWDvgzh8XzXiPAiAKkqvt57+E\nZzh2AdjVnaU7hWvreHx8mtdzeeq390YRXQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU91paTKpSN8jC79k9cLEZnWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAxOWY0NGItYTJiYy00MjU3LTlmODQtNTczMDBiZmU3N2M0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGE0Yjc1ZTgtZDAxZC00\nMTVlLWExZWUtNzI4NjE3N2Y4ZWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkypVmqO+r0pl0sh6i+6uBOwzaJ1KVVt67mCZa+bRMMymAu8cMUEo24ZwshRq9X1W\nMa+uS/LspnALCPQqQ2PoZKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2Yd0HgXdL6LtPG+W\n0lrfZFa6UhIwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAOuyZXy+QBkzwCYZ/uFNs8Y8MHawSFc4o6N1hfP9P8UhAiBLxEmr8u38\npOv10sInv+SBs+mH+Pj15FdeHcIpI1MN8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3961", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3961` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAcknAeZbUUKitt2xgMwrpZFJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5OTlkZWM5LTRmNGItNDJmYy1iMGMxLWIwMGY3MDA4YjQyNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWMzNDA1ZmEtZWJl\nMS00ZjUyLTg4YTItMDg4ZGE3YTIxMTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUptInCownQYxRLTnTBCxKxkC8qdo/J04EnG+ELMOes23YJh3nxBkq/ZbyTB1\n2Y3KyrNPTbIukSWQHR4XTGqkMqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsNf6Mh+asXG6v4ET/0aEka5lthMwHwYDVR0j\nBBgwFoAUTyseoCK88PjE7N5q7JzK8gPIQswwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDUgN4S8qcHNR0nkv7eIy3octLOT4dZTO/rMlRA6AOOJgIhAOh2Q2Kh\nOR4GKpMzW8SXPvYy31LDDxQytpxwhpHppzEI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb9z29HraVLi0riwlnzL53RQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTk5ZGVjOS00ZjRiLTQyZmMtYjBjMS1iMDBmNzAwOGI0MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZrIj3kaezoDIBdyFZ37tn2CZy+8cGu1H2iO/l2hN+dgBa\n+odrtMPfs5/7OPBzuacRDFl0OfmlwHrmrYDnx2e7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTyseoCK88PjE7N5q7JzK8gPI\nQswwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKnDL5xfMyL2PwThSMUbxNkTwD3BwKom9DHoXFg35nV9AiBALYhJ4shE\nXRQGA0Ub4VOrks9M1teCtW40X9Vgr0CMjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARwM4p2LFKU4jOXTFy78473jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWMzNDA1ZmEtZWJlMS00ZjUyLTg4YTItMDg4ZGE3YTIxMTRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGFjY2UxZWEtN2NjNS00\nMWNlLTk5ZjQtMjk0ODJjYzY3NjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRvWAchunAM100c4tBrozzh+kbE2v4mXFEL47J5qVB5UC+Yjf3PsmZqj2MNXekEYY\nO+6w68GOWXUmnqiuoobNY6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsNf6Mh+asXG6v4ET\n/0aEka5lthMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgEADYefTZFUprndPh+Hzxzp0DGGnO55d96D01E5EqdtACIEuNE82McIE0\nJSq42CT39GX9quJv+fG2NaKsNnT/Mo8S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3962", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3962` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVyCewnxeqhknEAKYmIh0wtrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzMTRjNWFkLWVkNjItNDY0ZS05MjQ5LWM3MzgwNjFjZTMxMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E2MTZkNDctNzc1\nYy00ZmI1LWE3ZGMtNjY3MzY0ZDUwZDQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWv/+xqbL3y8AjYAe+7nzp5MB3RCYJJPLyt3mLfDlPto4TQe2scUmhUfO6DE+\ntxwuWHOCQ8q/uwzT9nrTV8Q3laOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUit2kWGzo+RK+L5ULxwjVrGGpfHgwHwYDVR0j\nBBgwFoAUTIN0eSLWaulv0aIKI1CFCwPmS0kwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCb3wIppmqEaAMyjYy3IvzVmkY5mJSQo1yh15r0\no4j1xwIgKSY8HBnAltF98ZVpridVwKRdlZaUhxX3bhlVpEnABWg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAba4Q4vjRFyPODRUbF4stIenMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzE0YzVhZC1lZDYyLTQ2NGUtOTI0OS1jNzM4MDYxY2UzMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2XQZDL175xIbZFaoAazDF5Z0GqsHBOmYbFOUoCMm6Ack4\nqYrpJqPjIbo2ts8tvhNG2WLFLnJeQDMKMnWloyYSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTIN0eSLWaulv0aIKI1CFCwPm\nS0kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYtZCB7fW4/wGVgEVZ8J3sHbsZSGUdfreXhqrK/UjUycCIFaxkrzJTn/D\nvhXq7hV6dx+NxaTkUF5MWBeZT774VEOq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUoQnmcZ16lbbIB3sqO6viBJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E2MTZkNDctNzc1Yy00ZmI1LWE3ZGMtNjY3MzY0ZDUwZDQ4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGYxMDBmZjktMjQ0MS00\nNGZhLTg3NGEtODYyOTViMGY2NmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQ7baYwsRUkXF1Ic/jjxxewS1Lf16FkYulMUNm2ZoumsrKUakGsMQPwjxUfuG2CC2\nNw1dy8tCSOouDY7RoFUyOKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUit2kWGzo+RK+L5UL\nxwjVrGGpfHgwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgAiWeaDI0PgCG6hEU3qOMGd4vXgN/0ue5EKwK2Y1zGV8CIEoRIL2W5Xxg\nNXkjgwMjItJichXedtZJYgO0usv8SXpz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3963", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3963` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAQdZSjhatCZ3SDC/SlwRERvOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5ODE3OTJiLWNlYTgtNDkwYi05ZjBkLTk0ZWU0ZTg0NTRlZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVmZDczZGMtYzgy\nOC00MGRmLTg3ZTAtZGU0NDZjNTVjYWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvYlx6WI02Vp9GXDrmG9IUkuQU2R/o+6kn6NwWjyj9vGXBPIMt4p6A8sOlqOi\nf0HPPXwXuTV1LI6Ir0vnTSGQZqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbHOSjPShzTsph582FYRVQ0SZx0kwHwYDVR0j\nBBgwFoAUno/ExH//uZ3p+SRJKrmrfzcmqbMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDxFUFhL69pGKDyKBbtvo2bbjtVldpJebccKOdl\nIEh8wwIhAI2M+uXdlAaSY9YtHdFYzY/tHKpSHRLOzdQfCMr5oxwB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATOfe/MTmmn9jkFfbgkYyfl8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTgxNzkyYi1jZWE4LTQ5MGItOWYwZC05NGVlNGU4NDU0ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS40vB5YxWvY8hn/xH30JxREPfKVqmZj9LC+6RdXiyzHys9\n8BZv09Q8dEs6FDqUtSw8qJ7kkKuupDuUZLqG+X+9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUno/ExH//uZ3p+SRJKrmrfzcm\nqbMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTakst1VuloZkbv+0CZAiVvF4n5gOMeb+aPOPaKd6104CIDZUptRNQtks\n5mYkx3QKUkoM0RbAq2DhgGvU0XxB/kVb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe/p9QftccYW4FWVxZgb0TDGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVmZDczZGMtYzgyOC00MGRmLTg3ZTAtZGU0NDZjNTVjYWU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTEzZTE5ZjMtN2FiNi00\nYzY2LWJlNDItNjY5ZDM2ODgzMmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVTxjRjbahewjeBy6TQGweLnwFy6D1MjuehhLVypsc5d5lePX9JuAjvgK9oJupu+E\nmomGWL4sfvkHAMzncalaIKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbHOSjPShzTsph582\nFYRVQ0SZx0kwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAMYQ1UgNCAdbC4IYQQNvtmeSUqSlGKLI2XNRrxYK5ScaAiEAn4rVYO9z\nIWuur+VAaudK3qOQM7PL4L16xmAlABp7NNk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3964", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3964` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAS6YlytBXEoC+PRzKRmEwgeMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5YWI3MDRmLWIwMDgtNDkxZC05MTNkLWFhNjQ5MjY4ZWQxZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUxODE0OGYtN2U1\nMC00OGUzLWJjZGEtNDE1NWU1ZDA5NDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+JSLppv7y/aduvnl8UWPla226q7BXZJizd0+hrmXi9SDeaPXbECU8ONPCZCr\nBG4THYcwUjTHgi9cmXDx7S5wbqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkvxenS2qjr1M5XHQmVL4zFOzfc4wHwYDVR0j\nBBgwFoAUIyst15PHN4HMc250fXy407UOU58wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCM4sfb7a5b3b1BB6TGR1DxlOZ4WwD0Cg71VrUnth0u9gIg\nP07bZv8RtHkQ3qqfsI+Ccfeg0jtho9scjj2e7DxjtHQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASYaaJQpBcB1eY/zJ6QWOwKtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWFiNzA0Zi1iMDA4LTQ5MWQtOTEzZC1hYTY0OTI2OGVkMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdomwhV8L5ApUkzYpg7z8DI4u/TSlPx0d5R6FGMvPaqSEe\nlQ1I1FKGv8xZQK1RZIdgAFQTMyo0EQvD6WVYiM6bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIyst15PHN4HMc250fXy407UO\nU58wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPjfXpXbGu6KkZMS34MWAH7KBaxpSlBkW4OqhAPxFfvYAiAhAwgmjtSy\nT9Fymd03Jxj4TmyXjsB3wT/EOvZGQ11mKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZW2x/P5PTgC/nPCvDof+ga/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUxODE0OGYtN2U1MC00OGUzLWJjZGEtNDE1NWU1ZDA5NDYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmRlYWU3ZGYtNzFjMS00\nNWQxLTkxNjEtOTYwNDcwNzNhM2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrEcOFzvPA4UXKw86NI21kT/KqJ0zSbS/w/aLbjmZW4jPGRTmkXfeb9vjfz2Z7UXz\n2JfvVEQ8YufNhDfyA/AYqaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkvxenS2qjr1M5XHQ\nmVL4zFOzfc4wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAOpvBI8u7jxryN6wIuJ+ezu+4cPpGZNOVqKQ+lGbac0gAiEA3l3FA5vv\nD2MvJ4BlmlRZxddHOGk3rZbSHHE6tUHiVnA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3965", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3965` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAeHtqftzeI+Z8E+E6MDbb7EIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MGY0YThhLWY4MWUtNGExZC04YzI3LWM2NjU5ZWY4ZWE0MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM0YTE4YWMtMDlk\nOC00MTZkLThhNDQtNzRiY2QzZDM3MWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2NuHGj8B4hxCQZOiF1gRmEaHKAJ+TZLOPlKK/KrFnhS8uYSU/hspCc7bNTZi\nBLiziYGv+67ceNMitz7fTg5K4KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQR8KCEw8OdLprgIE9dtrOrOdGawwHwYDVR0j\nBBgwFoAULKZgz+AA34o1v5iC5orag0B2BVAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIH2HG+XwWpB/0wubHGCvx2sJctM1MGX7\nfgN+PSPBqh5hAiBfkgmBC8JQm9I/5qk09kdhsm/BH2govLcGbu8UhvLH6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARux4LrSIUdNNjK+jUqfEAaQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTBmNGE4YS1mODFlLTRhMWQtOGMyNy1jNjY1OWVmOGVhNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS6iPTrw3ta0zVyb3oSV6Cy2K9J4qdP8nuoOS6JKlcz1Ot\n70DNmog46cbteK+zh3U7PgJFJHl8Fuct21E7rZjeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULKZgz+AA34o1v5iC5orag0B2\nBVAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGaGiZrroJwRdOTuemMqDXA+5X368aXJVBHYdsJUqGRoCICWuu74avI42\nori0zhYMzx5RiRmdyz+czci3nY+cxYlQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXnlrpufcUTwZwS9DEI/HqU4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM0YTE4YWMtMDlkOC00MTZkLThhNDQtNzRiY2QzZDM3MWMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTc4MWE0OGUtODg0NC00\nNmUxLWFiZWItZTEzNmZjMGE1OTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBh2pZM0GRx3FYbCPLFv4HFENzzr+m8wXQzd6CrjziAh518IzELmYoL0MsGmlIWK4\nGtfhnuqlk+rokuu5PYtPY6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQR8KCEw8OdLprgIE\n9dtrOrOdGawwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAKbNvFHDmTlhlPyYJHVjtMSX0ofVXETBMCv5SzgohEypAiEAsObIti3W\nGn9BEKfyVSI3Q9yEvsvk/YhdEqcliWQXj7I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3966", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3966` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZSkAtLn3JWlwtepwUML6AWrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5MDllNDhmLTljYzYtNDZlZi04M2JiLTVmNWJhY2I3MjBiYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjExZmE4ZGQtZmQ1\nNy00Zjk2LThmMTktZDA0NmIxNmM2ZmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwhmc2m57j3ke/QfeZuzBzTWLF1JDYhlE4Wkt74ybQC2AFfHkoCGP3WI0voNp\n6ALMzAqJVrYtP1MP9K9yQJsa5qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUphQNoVMEuCQIk2A4w5LAxhGEzJwwHwYDVR0j\nBBgwFoAU9oJO3eRVZ/MDthLMCPtnQQR0yHQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCKY5qo63f33+/uQay95kj5mqgmHbCR\nnPdjEzz1VM03lAIgDJ/ARapJcFAUt3Lfew6cwkl8P1cjtYYl5qTJH/nUHbs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd14usMhNqYMGwyimm5wOJJJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTA5ZTQ4Zi05Y2M2LTQ2ZWYtODNiYi01ZjViYWNiNzIwYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQItCLmmaT4rVMLOtVwPzBA8Ig/CSTzSqleJgZ4fCVsKXZP\nrXAz3fPCxVj5fQ2ecPmfk0J4V+4aXRugK/pkAFQBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9oJO3eRVZ/MDthLMCPtnQQR0\nyHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdIcmBvBTtoK+yM5ne1R0iTknw86G+R+Jph0gjMY53FcCIQC+A5c/zqeI\n1LnMx3q3RpX95ieu3/G0SBTvWdkhsNQgTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcnZw05wBO8yQ3HxASPXbE4bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjExZmE4ZGQtZmQ1Ny00Zjk2LThmMTktZDA0NmIxNmM2ZmQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDdjM2VjODQtMzlhOC00\nMWY3LTkzOTYtNjczODUzNWFjOTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxlWLRNm3OUqQ9ywQFiL4MpIaPJaL3EmyrbSRmw9haVvHclRZiDo+nV3QTAn0h9dt\nyhqNMRQQGyaAO/0aLcRGhKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUphQNoVMEuCQIk2A4\nw5LAxhGEzJwwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAK/J8QQyJVeNIztVw4URjk5n62mj2/Qr49RotgmhaM2dAiEAvuDbwvUh\n2JIJM4UBl1Q/8B3900cWsqlyBs5dg/1UQIo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3967", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3967` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAfKz1LYSk6wyqKc45Gj4CL18MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MzUxZTdhLTVkMjUtNDA0Ni1hNTFiLTNlMjQxMjk4MDAzNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZjNjc5NjgtYThm\nMS00YTUzLTgzMDMtYTQwODE1NzI2ZjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzcikvpo4na1E6vb6s/y6MMVHqeMXBpXy+wmqpT/8VM25NqQcKirtsYI7ESds\nW4pToikk159IHMJgyAR2qsz9kKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcTRlM6QvWJmQ46jtG0e9WZbesyEwHwYDVR0j\nBBgwFoAUsnPW9Sx1jboz/FI36ckUPNU0gcIwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEmcCYWKANV2\n+PezMSdMsGEiTzQ/StrCZn8LB/4ibcr4AiEAzLAcl+vmj/EGKCTfYNw4b8M0tTeP\nu+3vdRGRy2eaA2s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAczq4pH6Pp0fPKb6ERoQLVLuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzM1MWU3YS01ZDI1LTQwNDYtYTUxYi0zZTI0MTI5ODAwMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsLzQtnK5QAEH5mK0ZJFfdjHvSqsktkb5ZzPscAneNP7VK\nofwjzfiv3sQdBQSbYKTtgoMErv8lRHvTOHMf0wCVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsnPW9Sx1jboz/FI36ckUPNU0\ngcIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYx5zkhL08LUBPS1Q4ZlxFyMyUAQI5e+vBSh9n/nqA6MCIQCrp4/qcD3g\njj+KEY3DwkQPSaZvLTCDpzSSc+uwrLhs7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWdNWqLNPlzvBjEXVfEGyk+/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZjNjc5NjgtYThmMS00YTUzLTgzMDMtYTQwODE1NzI2ZjExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWEwYzFiM2UtOGM3ZS00\nMmI4LTk1NWYtNzMwZDk1NGY3NDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhwMlV/+Cq0tfUOgSKkar2UpKfU76Oxs4OCJ9DpQRlmjSSRninW76+5nbkGjIA8AN\ndAjIL6VOe+AuxUYwSp747qNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcTRlM6QvWJmQ46jt\nG0e9WZbesyEwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhALrNc6xRHi2YqVpvYppZjtUi5pmS3XsGAFMj8Iim4U+4AiAXMQ1Ekcr2\nr4SZB23FLeD6AIyu+xRZKlfpifxXxXIzMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3968", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3968` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAdBPLQnZo4q/SRpMAPU9OQluMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5MDBhNmY0LWQzZGYtNGQzYy05YWM1LWVjYmMyODY5YzE1MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE2OTY3MWYtNzE5\nNy00NTM5LTllN2ItYzgwNjY5N2E4OTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXOvsWn3niC34N3CUeoRCMzGZ/+NqSlxu79zCldVMelUkfC183iDtKY641OVJ\nBZucG6/Q0IlgEi6LwtPL7L1XuKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBs3JHjYMbEQBbbRgj58NUW2OJTEwHwYDVR0j\nBBgwFoAUMMqSMOLzEkHoqUcsGArWqRAgdXkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMEDFll1RpJZ503dvl7ChinG12dMGi7+K38M4Jg7UTSKAiBvoVKJ13rm\nN+QPiStFYEB1HFB19Yslg3tVxhzmkQYXHw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASbR/Gt02tmK50bBSBuXfMZYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTAwYTZmNC1kM2RmLTRkM2MtOWFjNS1lY2JjMjg2OWMxNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASz+LBpBklj/pNsIGcv/fY8pz1VwrrmLvLiNBALfBLBs7xl\nixWYWzrUFmQPouDqGcZUyLt08VCOZz5/7zfDUEMmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMMqSMOLzEkHoqUcsGArWqRAg\ndXkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIfQ1U7LSbTPeAyKittaUvs16CtulFzax+jvzFOK6CbLAIhAJ8GBDjZCysl\ngHlMSPNNp1RrTVQF7d+ucfixn0ORPi+J\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWfDkm5coI9aLv2eItcQx3wCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE2OTY3MWYtNzE5Ny00NTM5LTllN2ItYzgwNjY5N2E4OTQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDJjNzVlNWEtOWUwYi00\nZGI1LThmODUtZmQ5MzhlZDExNzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqxLLY8XEwed4MQ1dK+F1OC/81tgjxH5iFaa1XDHOqPLRnXQpb7Tp1nj1NzHajs+G\nAVK+CdXs6H8YMNdKox0P0KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBs3JHjYMbEQBbbRg\nj58NUW2OJTEwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAMNfT04ctEqDhE6stt4FMaSYG9iFgoXi2NoReBOqLWskAiEAnJ8J3HMF\n8km6jrfExoZy4ZbZJI5c5yP/BxPeDuOPXIQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3969", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3969` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISASUC2EjLh3TtKovA6QJjjWZwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyOTRhMzc5LWNkYjctNDFhNS04Nzc5LWJlNTQ4NmJiMGQzZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM0MzlkNjMtZTU1\nZC00Yzg1LTg0NjQtMTBhZDg5YWIzMjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBolD0mB4EjU0xBHddQSBrE2EEeRF+HdpFA5wMw/MsrXFuOm5+W6duJsmUa3b\n3sJEuk8dtHBX+u2yi4CEYxyD8KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdGqGv9KjPlDXrpWiMkR04+c9++EwHwYDVR0j\nBBgwFoAURLnqFNiTlpIv8NPJHLDGYVXS3xswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAP9SsltD1M2akAx+wj3P070KSKjAMN3l2gEFzG81R//6AiEAo3QgLlPa\n11kdD6mYHv5KPTefAvGrHDnI2EDOAzX3bTQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYveMz9KW2jNrg7K1pUGIFaBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjk0YTM3OS1jZGI3LTQxYTUtODc3OS1iZTU0ODZiYjBkM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATl+4EheP+Of+EWuSDM/n46pv0CiZXHSyJnTpx5ksDNXNgH\ngI9abJN9iTYDS6bnrIm3IYdeZ+YXq4PwiqJ3ypuho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURLnqFNiTlpIv8NPJHLDGYVXS\n3xswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEJRG4b0sKqqlE+K6O1xDvtIh1Anvw9uTym5/5bHjOSUCIHYgHOOluedh\nLro37aPweuNoluIRIeO7eN9UKjUCnn5x\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeE291E3qabUjBA7q1m7AVygMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM0MzlkNjMtZTU1ZC00Yzg1LTg0NjQtMTBhZDg5YWIzMjEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjg1NTVhOGMtNjIwMy00\nZTJkLWIzNjAtMmVjYWJjZjE1MDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3w3HWkCuRtdHaDRIgmr4VTtNGaEWIFF5OFAXvA8GBV+BpgNvpKNFe3x0VFwpiHmN\nXR2c+a0KLORffL0ZQmsR0aNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdGqGv9KjPlDXrpWi\nMkR04+c9++EwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgHj4jkuIuretrzLf3YUiwfU0MGMmMZM5FdcYKnkpZlGECIBGAf7dB+LxL\ne1QWqqOvYP/+B11ywSyNNAD0MAazOocf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3970", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3970` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAWNleh0kHL2O/DQpTgJ2CjebMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMDEzMzU3LTAxYjAtNDUxZS05ODY5LWZkMGM0NWZlMGFkMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzk0YzE5ZDAtYzgz\nZC00NmQ2LTllYjgtYTY5NjA2OTdjY2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyR98hf/NItrFp55ziGRuTTqY08bZ1fvZlptazwB5Ww275VIsy5oRJM0jBqMN\nfKBi/EhOOP2QR2jHggmhlSnKGKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeZV9sX9OdH66KPZyfIrl6y/gfbAwHwYDVR0j\nBBgwFoAU5pVFb8NYNEw2QPjcVBk9578FvAwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIB72ASdEpqo6XCNPFkRNGyPkMtAGbOxMVZie2C7eq9KjAiAY/o7sYtsT\nuD9156RxgIUyklQSRV20xqbEWM42S+AnMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXuyGkr+fij7KqLaGr1w69v/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTAxMzM1Ny0wMWIwLTQ1MWUtOTg2OS1mZDBjNDVmZTBhZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDbqH23Nx6p8D1TvfPanudJk5CzvNQOJLAAa02bbTGBuMh\nKLB5vNUKJ9bdJfw6RDxv4D8OCoSr1+qCNANYYdP4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5pVFb8NYNEw2QPjcVBk9578F\nvAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALUo/e64gzg0WED27dci7m4ZQilbtGMHPoCVOGQQC5qfAiEAma29N181\n0L5EoLJQucvoLap8OqpuVaPn9PyQe48TBZ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR6vqFpeovCjjP4OeXHMXROYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzk0YzE5ZDAtYzgzZC00NmQ2LTllYjgtYTY5NjA2OTdjY2MxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmNhZGIwMGItZDUzNC00\nZDk0LTg0ZjgtMzZjMzZiMzhlN2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLmmAXJwAAxxd4s+iYn7s1f7xdCi1Z0I36QEhbDqSVXYFs4Qpo0J+h3PPgluNp4Lj\n1dbK0nG1JEz/1q6iZ/ptXKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUeZV9sX9OdH66KPZy\nfIrl6y/gfbAwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAOLxLbQlNx+tXspLWDfXUKcuP7Mru13ek60ec+oPVDLeAiBJ9d/Qn4jA\n7LFbVf8SeXcDZtP+IkL8BSkch1SS00nrBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3971", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3971` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAW04vbiEZOuTj0eDuFFOga+PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxYWMyODMwLTBlYjctNDI5OC1hNWU5LTg5ODQ4MjM1YWIyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ5M2QyMjctMjAw\nOC00ZTk3LWJmZjktMzQwMGQ4YjNhMGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkeZm1nzK9K8ZSVOGzzxKWkY04LgtqGFNH34GAVqgeNAAeEzIevaP177537AF\njyRrazhMIgBzfA+S2EdKAieaQ6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURQadQeaiKeebJkjHLHpw98JmRvUwHwYDVR0j\nBBgwFoAUoLpDfXeuB9a7WKc9FmdzK0Dc/7EwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCKfDEWlU4qhGmn8TFsyt2Z4xhXa0aBRZ0CXb6Y\nYvQvGAIhAJ8nm2TBMlewYQ2RE8ODUGmKYTtn2uz6xBtGLTdJQHuJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATAx3L1HrxottBD14eFTWkAgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWFjMjgzMC0wZWI3LTQyOTgtYTVlOS04OTg0ODIzNWFiMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPtBiXSrv3Y+irZHXc55dSMmuCELBPW6AE2ix9rDtmroXQ\nUKaqmVdEmZP2SKPNCDofZWFkH6BndBew7kwYa8wVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoLpDfXeuB9a7WKc9FmdzK0Dc\n/7EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOHvANblw+9j1UdmRM18FFiKHL55QsNnR//hXhSYEvNUAiEA482zcLcs\nl3+UYWu5sf7bBp321Yu83ZGk2YZ8hcBJrYA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAarjlEd1y/v0foKI+KJTPo4NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ5M2QyMjctMjAwOC00ZTk3LWJmZjktMzQwMGQ4YjNhMGQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjQ0NmM5YzUtN2IzMC00\nODM4LThjODgtZjlmZTFiYTlhZDk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nun43fqPnDY0JLOe1vJsRver+sDu4SDj/7p+U+q7tcK+3VA6mwL3dmUHe2MQYIZCO\ngPyPUYBvXyiKxtNdr/eb56NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURQadQeaiKeebJkjH\nLHpw98JmRvUwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAPxDNohA6QtJH+DnCGkZUg16EnM+qJSWyRfN8Z1ZEeXuAiEAzp+1Lo6f\ngN3R7Pl3Yz9/f1QFzjYd2LDmRWj5oLwl6Fo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3972", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3972` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAW87UwkBfWaUxindb/COdL1uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3N2I1YWUwLTFmOTctNDk5Zi1hZGU2LTA0MzMyZDBkZTc2NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA4MGE5N2ItYTE1\nMy00NmQ4LWE5NTktODI0ODQ3NWVlM2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU2tO0zXURDuBTPMZlbCp8J1tHmtfdJY37pVfN33FqHk0OSeUZzh5ESPH1qQH\n24Vww0/WIeT67yeY7cql9Ze3LKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsToel8VQ43oHP6q2XurRqLv1WpIwHwYDVR0j\nBBgwFoAUAzBrDAAozmGjXeBg5EwFIBBh/P8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDw6BLgF4TuNXGrpT1OHRawSXt6Wfb6G1brxTk8\nuqfxeQIhAKUjlJDapPSf/7JUSTyKKoPVGaIUKcdzbAqUP0tHle/s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXAQqIy2yWH9HjeEc4BfK4/CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzdiNWFlMC0xZjk3LTQ5OWYtYWRlNi0wNDMzMmQwZGU3NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDUm2eYZ/NQxIIoj37TiM7o3EEIH7bt+3bBnUQyLcbriPj\ndC3mLYR75vN/grxHFcZFzNoATfph+yJZxs0dEOL5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAzBrDAAozmGjXeBg5EwFIBBh\n/P8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfEZC2EoXWG9UC6NJKlXY6ODx+i/SnTOSveEsKRwjsg4CIQDv6JjydPwc\n8Mq1F3ezhnJKWKmSrOmqjx1mdGt4Tvjkvw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAewNJmYYSpOC6O4tNWJlptEnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA4MGE5N2ItYTE1My00NmQ4LWE5NTktODI0ODQ3NWVlM2E3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWY1MmNhNDgtZmZmNy00\nNDJhLTkxMDEtZDg3ZWMwMjM5M2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3prdWP3YLrwUWQubG/IFWJEwebIYgG1ctVojGsildpqhgIg3ePlCT4/FF5M5/7R5\nSngxAt2i8yAPLacTZ3H+CKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsToel8VQ43oHP6q2\nXurRqLv1WpIwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAOtE7Gylf0j1uiVCvDLpWskzL8Os9CtyMibBKhUS2xpHAiEAt9wbjLf8\neNFzru/eKXLO+Vm2op2Zewv9sfadd0vAt20=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3973", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3973` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAdsY08Dwh45Ikf6yW66cPrk8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljYjQ0YTY0LTFiM2QtNGU5My05NTRkLTZlN2ExNDlkY2JmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJiMjQwNTEtYTkx\nMy00ZmYyLWE1ZDMtOTY4Y2Q1MWVjYzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+eFrUeT9wrDb8rYMr99yDYoyh4y6MPz0I8uQJRDNbdm5m/H/jDajdIOZfz3n\n6R7xiWcfRiiaYFletd+g+ajLaqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+yGaz2DiZZOm8TQX2/W39Nrg6GYwHwYDVR0j\nBBgwFoAUTj1F4nGd+q7RjGWnRz7v38FA20swPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIFseFLjbLOpFgQ6D2D8tVDAFNbEhtSXWUtsRkiDv0hMjAiA7\nrj4FcyZ1ueJXBF+/0hbbXaFBQjfzgo/kdzT1FP04Ig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdyfR+NZ2MW2JfboEvNVzJ/OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nY2I0NGE2NC0xYjNkLTRlOTMtOTU0ZC02ZTdhMTQ5ZGNiZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASa4VQ7H/dCO2JQPhP7qHYO/Hiy5n5o2mmXp4i/C4nX7WY5\nppG0V23PEvIhNp+m146QVC3V3TRQcKP9dz4mWb8zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTj1F4nGd+q7RjGWnRz7v38FA\n20swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc27Gf9UqdSZZvC3nRY1wwFgT/q4rmDilpgD/8qkbgfoCIDGuvDHvyveD\nb5iUiwakrXa/DpR++qIbiSJWw7Pea0Ey\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUy1EearKdjhmokdNGiv6AaYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJiMjQwNTEtYTkxMy00ZmYyLWE1ZDMtOTY4Y2Q1MWVjYzhmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWM0MjU1ZGQtMDJhNy00\nMmYwLWI0NTItNTAzNjZhNGUzZWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nM3mLtx61Xlj4anepqVklO6H5Q1++TACuj9tvhvVeSLECKBgDVN4Cd/ehrqIQ7ymC\nHailm8hE6Do1/F6RpgBQq6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+yGaz2DiZZOm8TQX\n2/W39Nrg6GYwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgPnzUBHVsuYxij92LVpZRCJeawxkJRForoZMD3LUU+gUCICb9W7dUuLgd\nCeYRQVJOhvhGZCUBqmPiF6jE9hskHudL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3974", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3974` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAR5azJp9175qfCS3iRclomAFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYWYxYWQ2LTQxYmMtNGIzZC05Mjg5LTk2OTVmOGFjNzAzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdlYjg0MmItNWEz\nNC00NmQyLTk4YzItODJjYzE4ZjU1ZmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEunTB/TzG/sBCvHJiASOp4qTVbB2fELIcKggilqNk08FtUDtd3U1LaJ49HD7O\nzV1t8cC9f6z9TXT6AIsDCJkQ56OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+NV+rHHg7Zx/bZlscpQos3uDN5UwHwYDVR0j\nBBgwFoAU+UBzYBgGij6ddREigVYKZ1qXiXwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBkqtBSXvGihR6pX/OQm2Z0VABN281P8\nPTA5lTFrmYoiAiEAjQbFJ19L5k4sFIu1M8Qp+M//8ibfkaj9o8WX/p3DjmI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdQUGlWqtUotH1664p8g5KwbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmFmMWFkNi00MWJjLTRiM2QtOTI4OS05Njk1ZjhhYzcwMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7t+HBE1CW8Zsfm3EFG75XDGKTLmrBl1EVzyXvz2ubVJCd\nO2sDetbfOw5uyefd92nDx+T3RkgEpHyDFcR18pEao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+UBzYBgGij6ddREigVYKZ1qX\niXwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN+NaAOBIj9RwdFN1IaFpuOD6gcOklFI1RVAi+fTCtMBAiAmmvyjeTVo\nVnSZoW0co5E7XvO9Bdn2HpkOT1lw64gjMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARmw5PHqGx3+s2dwTmKJlAmZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdlYjg0MmItNWEzNC00NmQyLTk4YzItODJjYzE4ZjU1ZmM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGVkMjcxZjctYmU5Yy00\nY2E0LWE0MDktZDA1Y2Q0ZjlmNTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmuOtzM6MyFmsLr5IvQuixshv5B0FepllPTKibIhcj9lfuLfUmmE+ffz6wf2WhoaY\nwXXRGJJ8gkm+fm/T88lJ+KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+NV+rHHg7Zx/bZls\ncpQos3uDN5UwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAL1m+CcH92r6skV9l+Wj/TmDzK/B+5b8F7S99KUKkHT/AiEAq8V8peaF\naierPr6xA1ZSE0p7RQbzPygVqCc8pYvg5U0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3975", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3975` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbs9oKqu2+dLk6WA0rufeceHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmOWM4ZWJkLWVkMTctNGYzMS05MGE4LTdjYmY4OTY0ZTE1NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNiM2M4OTEtYWQ4\nYS00NjFkLTkzNDUtNThiNTkxOTM2YzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ4VRgE14+ZbBhEe3QDdYc4iakrioKzTn8KVAzOsOSYm7RadWsvPmLFCt1b4Q\nqb7QaYYCPtIkjH9xjgxpN0K/lKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqIog9fJueifVHMjdRYtXk2Uv+GkwHwYDVR0j\nBBgwFoAU/kJs1c72PposDrZB8emPDVolt6kwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDXhYBXwy5R4WI3QdQAz82RZ7+ApL1U\nwWNAzk2vT4dvMgIgOZk6e3ngIntE1M6zIleTFjediIexy/0Ik7z7dbbMaCg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAevCgDrEH2B+nhvWHEBpoiAgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjljOGViZC1lZDE3LTRmMzEtOTBhOC03Y2JmODk2NGUxNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARupQh0eNPM0OD0n2r3Z1pS7dZryWpfSqmnAICZmlzAJ9JZ\n94/9kHXWNb/BUN/qFr6uhaLLxQkLgiYkrVe2U2iWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/kJs1c72PposDrZB8emPDVol\nt6kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc7uKRxzFkJXXLsK91+/yxM12cAeRuU8tK0sw6HbrTSoCIEHkAO88/XRU\nWdHDxbiPYiEkINpsQscA5O26E79PEt2a\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATC6DFCgkW4p8+FfEfMEawKrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNiM2M4OTEtYWQ4YS00NjFkLTkzNDUtNThiNTkxOTM2YzgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2ZjOWQyN2MtZWE5OS00\nYzE2LWE5YzQtOTQzNmQ1ZjI4NmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlZvbh0oeQs9NpqD/Z6dIN+1kZJ7i62RFjxie+BB4fgh3wTZA/uFXOlHk4+orVW6E\n7Ucyvwtzd1+BkCAyM8CivaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqIog9fJueifVHMjd\nRYtXk2Uv+GkwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAMNvgBltZASX3BmW99ODw50ARfDAI0WRbz6n2rsG1lvVAiBRJLanuRjr\nBJUxcBxgd7yrZ4LjjcnkarMNX1XEGFAPPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3976", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3976` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbrUA0icEiFehtD8GUTNsc7vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1NDkzMjU0LWU1MGEtNDg1ZC05MWRiLTM5ZDY1MDhmZmJlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRkYTFkODEtOWVi\nYi00ZTYwLTk4OWItN2I4MGM3ZTg1ZDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9wPInin1pqE++XAzoyR0l2pPXpNk8QlLG80KXokOQpIHXJ9Y4ZtyeZUiIhAd\nMPxv5qNu9niuRwEWNr0Jo82A3qNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFG2guGHhUQfmdyP4LwVXTA1me43nMB8GA1UdIwQY\nMBaAFA6N4AyFs4iYxeye90m6YLIXl/BNMAoGCCqGSM49BAMCA0gAMEUCICUi3SDv\nv44mHWk57yZg0jGmhlsNmP6a3mbPj9m9kBgNAiEAtD0x2uppLdn5//FsXfMzV+jE\nFiSi22dqDCuuMytK8Io=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWXcg8+/3XHMLtoz5S3pTucmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTQ5MzI1NC1lNTBhLTQ4NWQtOTFkYi0zOWQ2NTA4ZmZiZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUimtJ5k4u3NBiQQbxJXdsJCY2TWKdaI/FXtP4Q6dTeaf6\nhQDiyUqNoei/elatYxWm5DETvd05OWQcizgDiM7to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDo3gDIWziJjF7J73SbpgsheX\n8E0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI5Ne4yRIBY5e5QRq3uJDHvM78qhw1QHa420uUjzL4+CAiATTYotwQ1I\ndruvNcPy5imePYmopHlgyQ1aHw3kV1YoRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAb2nkyN6wh7N0yM0PBUHa2O8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRkYTFkODEtOWViYi00ZTYwLTk4OWItN2I4MGM3ZTg1ZDFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2M5NTg4ODYtNWYyNy00\nNjEyLWFkY2UtMmZlZWQzODlmNjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXRsAnpZa2JVQyGuJO6ggOzt/JyhOGcvJaZP9aH7q1hA/yrfyRqb0eYoumFaH0/23\nb6iQxY/gSjPVuuP2FPu3NqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbaC4YeFRB+Z3I/gv\nBVdMDWZ7jecwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgd56UK3343PF501GxQiMBLhGElMt9JbCFEfMWMVH4R0oCIQCx\nxfD2Myz5UUIGJW692rN4M2biUn7kVvuOpAs1TV8B5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3977", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3977` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWF3QbdW7Yck2R6Tou6X1taTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2MTg1NDE2LTIzYzktNGI1My05MDk4LTdiY2IxM2FhZGJlOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRmNjNmYmQtM2Q3\nZS00NDk3LTk5MjMtNjNiMDhmNWI4OWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkvQ337DUXGU503P/pJmK+VjfU2+tFaS4t35kHnHbY7BELcyvgI/2wMUiMC4r\nNyJ0Jnzz+DYlKurRKCw/MdZ1RaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBXA1bwOhZn7gZ2TBGKVaz/mx6ukMB8GA1UdIwQY\nMBaAFKRfXXH30VLNjn7bdlnrug7EUlLaMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA8oFHjSEjQp6dIk/L+b0jAXvGo/6Jw30Z\nYj9YARmYOjkCIAJDzOLlFIS8L5H485YseBPEtD0jOZuFeMe4HakafXzG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeCheTcuk8R8iv66Va7vlOBlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjE4NTQxNi0yM2M5LTRiNTMtOTA5OC03YmNiMTNhYWRiZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZC8CXbXt+YKX+zD0fyrhoNuZHx4wX4YcKfiI1+zy3BLBE\nzE39QwJxjkPP3smQ3HOo1dVhcz+DCn7+WUwuMLMqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpF9dcffRUs2Oftt2Weu6DsRS\nUtowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMIYTTNIE2+O2WQufPje+Tycl0WVwT6TLfhw69wg91T4CIDGOm0YttZaI\nJacCS3ms/c3k+V7Ps4CfY9Y8zFGcCZqU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAd4+zYppdoS7WaJJntUFoWqRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRmNjNmYmQtM2Q3ZS00NDk3LTk5MjMtNjNiMDhmNWI4OWIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGZlYTg3MGItMTA1Mi00\nMDJlLTg1MjctMTg2NjI5M2U4NmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPFBX00wuIv+kcpQ7jfqtjBMvpfvJtL65XizHbkfo2nkgXER8s98hADjBrwFFvCMo\nlNzoD/Oan7+4944XqBe91aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFcDVvA6FmfuBnZME\nYpVrP+bHq6QwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgPBJKMb0oFbDYBWKvwXtmW12g7eZYEvzADC+yGnY/QlcCIFa0\nUO4vTNzEDblIPkT3hmerm+NWEENbkmdTS+wiPPdI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3978", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3978` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbg4LT5YwYRoP8x81WySbm7DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5ZWRmYzA1LTgyMmEtNGE2OC1iOTUxLWIyMGU5MGIxYmE5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE0ODE4ZWItMDQ0\nYS00ODY4LWE1NDEtMzE3OWFlMTJhMWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoIXMSLrXWCINfWzkRsyLRZVE8fN6BvZCQPXe++okffqQsqkSYkL5waormqWH\nOlPEi5DUn0scpRDJen6fFCJfjqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFH81IOyTcOFwZofj2FsSUMEzKeUYMB8GA1UdIwQY\nMBaAFNDO2py5M+V7P1fxZwT6wUpivMggMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAx4e6myvStMF3OOLUDeFcP7QX+EKW2S06\nx6hW83wN6OkCIHOuVTdtWUYrUChHzb9gVbcR24mNQK4WhDYZgwT0IsrR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXD5Un987BUFKpUt0G/gph3yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWVkZmMwNS04MjJhLTRhNjgtYjk1MS1iMjBlOTBiMWJhOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQe+3QoH3ysT8aWO9DNLMKh5wKcDhEi+jQ1e7S62r4Nc3ex\nORVYOd7GTP4B6G/OPQ8nJNycGa4mRuV1QHdFZ39yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0M7anLkz5Xs/V/FnBPrBSmK8\nyCAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJO6S0yUYYYP7DSzRo7eYlE9JNW3q64fTot19P6uwR15AiEA+bt2F5zr\nCqM3yDU9TKKnSBjyW3PehyZS2Gwv5ON5Ozg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZT0oYtLUHWIJXHj/JKj00y/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE0ODE4ZWItMDQ0YS00ODY4LWE1NDEtMzE3OWFlMTJhMWFkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjAwZjQzMDAtYTNiZC00\nNDVmLWIwZTItYjgyZDQwYjA0MWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3T0gZKpROl3EkSla/A+Mra02Xr1WRyybtMpe+lHYexVejVlwYnDHBkVd+L98/lAY\nl/4SgxGMemCW8whNmgHP0aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfzUg7JNw4XBmh+PY\nWxJQwTMp5RgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMdq/2rBAS1C3Stw7qoyq4e3OTQ6/4saffZtMUAxSdjWAiA9\nwPjFUVWenEGORYt8z6TpV0OO4Ft+aRgZoqeooi55+Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3979", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3979` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAWP8l2ZSOoZhDGgIwJ8dDWhGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhMWI5YWExLWFkZDMtNDhjYi04NzI1LTNiZDRkNDVjYzdkNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAyYWEyZGQtOTJj\nNi00NjczLWI0ZWMtYzExOTU4ZTQzNzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYyYQOhGC4S/kvcQTstG3uhlv1E8R+edmSqYCTZ67yyaLB4qRT8Pp9yXQBj7j\nrTEfNNvb2jNfjnWmXYEr2/dRg6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRfzew/OMmlEE7kE5ANjAMBnhMZwTAfBgNVHSME\nGDAWgBSE051o/YO/DWk/RDoceEHI25FGkTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFw5acWMCE9faz3acoVKaRbLLynlp9iN\nzzJIoN5nFzQFAiAvErHFjC+wepdfzoGH5qyTOkXZ9piD5NK1mwbkA+hdAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT4feENYO2uHkCjXc45k4wNDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTFiOWFhMS1hZGQzLTQ4Y2ItODcyNS0zYmQ0ZDQ1Y2M3ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQN+dTwLPprf+kufkGC2k9hgRSvJumvdFlKAH49EeJ5oRpD\nqCUoBcO33u0RcY77s1KzlXru0fhBZhkGJNKxA/xJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhNOdaP2Dvw1pP0Q6HHhByNuR\nRpEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIge30CVvBNLxDTdM379yFclRtjBrlSrv0cTcI6MWS8blECIQDobHrNR29g\nHfiIgVur/kXCT26OCROz1ntLCg/+uXDR9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAY2oeYCA74liYMP32IVtCA2EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAyYWEyZGQtOTJjNi00NjczLWI0ZWMtYzExOTU4ZTQzNzI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWQ3NzA0MWUtZDJhZS00\nY2ZkLWJiNDctODc4Yzc3ZmY3YjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6owmUgLly7Wc2b0Eoyhqfh1RN78UjBYEyiTOYOelptugqxrAc+H3s1oNY1UTf6/H\nopt77JX7iwq7h4eG2HlfH6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUX83sPzjJpRBO5BOQ\nDYwDAZ4TGcEwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgEm7ai3zdqUZl4WWplQtVufnEfA+sbi+mD5DSexsRYSgCIAgz\n8ttYSrGMAEutm5QNFQ/otWtEsXI59jTUG13/nbIa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3980", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3980` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQCyL+JspJDibIPlLDI5GMs7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyZWIxY2I3LWNlZTYtNGViMC1hMDA1LWQ5NjVmNzE0MzU3NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNlNDZhMjctMWQ3\nZS00YmFlLTkwMWUtZjJhYjc0N2RhNGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmUzDtthewvD7Ny7E1b2V6X24W15suD/ljLKwfKHf6s7IPN1fAI2M6Mayfr17\nlbVzVke8DhaIwfWbbarzAMOW9aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULTIrWr/Fiij2jHe+3wQKRYGjarkwHwYDVR0j\nBBgwFoAUUb/x6BK6oDmbV4yVbPdDr0WpN0swJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAAl0igFn5PhKmx\nMm93RDSmfRxySlY12GETUfUMtgkOYwIhAII3w94/kkobBmew+h24i5JkE18WkV3E\nZrUmoEt/3pOt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS9zAXlPKUc/pPCu87gnCDPoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmViMWNiNy1jZWU2LTRlYjAtYTAwNS1kOTY1ZjcxNDM1NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT977rqgSwsHDmhngfULTL46Is0oggG4vy9DTtZbnzoipqI\ndbED2ZvcHm+NifDqP3eicdLIO70cJ1vG6hcB3cTMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUb/x6BK6oDmbV4yVbPdDr0Wp\nN0swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX5NmOIXbKgeS1JSmec+Rqw+uBcwoIO/3h4hVmdVU9JYCIQDVrZc6ocRM\ny/PimAXWjrG0NOAcG1soc0B9QfrTY1hYBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdjYWJaeXqj67KqmCXvlDcXrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNlNDZhMjctMWQ3ZS00YmFlLTkwMWUtZjJhYjc0N2RhNGQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWNiMDcwOGMtNzhiMy00\nNzBmLTgwZTctN2FkYTU3OGQ5ZTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nD8XlcCiITxQMQ9dTfg0UoNY6sOfRlOUQgCXvOwVE62gTDEEFxqNi+eC+Ig1SRZkS\nS0j1/th/swcrV31Ocj2O7aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULTIrWr/Fiij2jHe+\n3wQKRYGjarkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgYoyKBRRiKWkaVkwEKaMwYnf0mz8DuDC3WqK+HeeRa0oCIQCe\ns8504saLlxlEQ2SAkpu6gmB4YPUH04j3R7A4MtHA3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3981", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3981` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAT3G4/J/1PaPTtVSuPbz92lkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5ZmE2YzJlLTNjMzgtNDY4OC05ZTE5LTkyMGViMjEwYmE5OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdkNjIzYjMtMzU0\nNS00NGE5LTk2YTctZjYyZDQyNTc5YmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpwxa7sP0brVfdRMCMRK/3yD9itubDromZIxADr8PoKqQ/daWxgEQKkz/lhE0\nZHRhDAr+ugp0k6L3W3I7XfNlkqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBUFi/Aldc1wxJLW/iatxVV3bT7owHwYDVR0j\nBBgwFoAUCkb4p5nEkqKs9C7iQi1boAbQL/gwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA0CD4v4eCrGzc\nP2tJwooJI5lNsouoJtia7Be4wJamYukCIQD8JYxct40GOdnh1+ReBTRd0e8pM6Aw\nuBWHD4lvTjxn/A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcdDXZZmM76cAGfTaAaTrlctMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOWZhNmMyZS0zYzM4LTQ2ODgtOWUxOS05MjBlYjIxMGJhOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/kvYmv/N8G0z72qjRethLKErzo3wmJI/b2zECMWfuZS/2\nXhnmUoMEoSam/ri0Ht7wmbvjLEFYfk6bozAaCjIjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCkb4p5nEkqKs9C7iQi1boAbQ\nL/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIlEHmL/JHysMizdiuruhBMWfXd2Vg7PNVoxAiedBt6UCID8g+XPmD8aV\nE5y/nLfrvt7cNrhvnIK65/zSiZP9F5tv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZ4k7KID/B7b/1ahEgppIJDNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdkNjIzYjMtMzU0NS00NGE5LTk2YTctZjYyZDQyNTc5YmU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTVkODQ0ZTEtNGU4YS00\nMWU0LWFiNWUtZTQ1N2FkMGIzMGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nd3oRz8zd7nBJk/Bg13yxfSfxLEIZmp2gEnqKrJZSXokSR1h3iI458v7jJv41y+v/\nccgqEfbqRROBOqylFPJD5KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBUFi/Aldc1wxJLW/\niatxVV3bT7owHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIga/nTlky+dmAF50f6u3ShcUAsKAiOZjJhkD+jcX2Vn0ACID0O\nSHCLpIsLRaHhOSSmqUZgjkphz1a5XLcc/UErYUzr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3982", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3982` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAZz9XSas6rJ0vqMlkrNqBncoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0YzAzYTFlLWZiNDktNDc2Yy1iNzQ4LTc1NzE2ZGZhZWI3NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFjN2Y5MDEtODdi\nOS00ODRhLTk5OGQtMWZmYmE2ZmJmNTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfApWNeJFki1CViD5Co7e7i6TJQYMxdxvnNgd7eImv7MMrhs4OmfsCisM9582\niIrMk+6ItVkSVbonF+D3iMg7y6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkYAwZlvDyZAERaqq1gysJdY2QNwwHwYDVR0j\nBBgwFoAUVr9u23iUg0gNI29YmucbopLG554wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAxVptpRAW1Le5RMq9BTWS2\nx8upF5EIT5p1iVBKtgHRyQIgfTyL8hrVDVKkYhYqgPI8rC/bnEuf7+xdZe0ICssS\nYOE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVNABFVXRKrshQlmz0DAW0UXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGMwM2ExZS1mYjQ5LTQ3NmMtYjc0OC03NTcxNmRmYWViNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+qrvGl4Pf/4uoR2LLYb6Iny+R5cJjBFzwW8wTtMFMoFyE\n7A02JXVZHistiLNuxgtqf5OtlgO9aQ6trmMEaxz0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVr9u23iUg0gNI29YmucbopLG\n554wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLe9saMcCvsjIYxi8ITns73QVvndZQZYQ5kuM5gN0gH0CIQCcmw03I+Nl\nvYcvGwyGefCVVIxAvtolpwMx5suzqRTWlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZHK2K7ah/FxYC7LtPfI8aoNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFjN2Y5MDEtODdiOS00ODRhLTk5OGQtMWZmYmE2ZmJmNTRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Q5NzY1YTAtY2I3Mi00\nYjQ2LWIwYWUtMDc4YjYwZmQ5ZGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkz5G16UnxS+1eCRrNFdtvoyErWsRulqRYhqP5Ho5rBBOzr0LCIsB1PTD/xQJyoww\nZfYri2KH6xvIKwfC+RMyeKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkYAwZlvDyZAERaqq\n1gysJdY2QNwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOARxTfSeEeQ6jxcjw0WdjKlSp1aUWSy8TuEf4OZNDHNAiAr\nVYAcUJWVtLWQwUJUdj7VzNy1N5ZatmakkDP6H0bCiQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3983", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3983` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAQqvfJAuV5v1bnRqLbx2U3KxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiNGNmMDgyLWNhYTMtNDg2Ni1hMGZhLTQ2MWZkMmYzZGJhZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q0ZTM3YjQtZjk4\nOC00OWRmLWJiYWUtNzljOGMwYjJjYjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGx3Uc3N5MByOV9uiiDIKURrzHnv4ujns6NS+VP+/ah80Cu12adqWuUhVKuSV\nvssv4EVfg6DIr8Vjux/nLzZco6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxy62yKCx1n2HbGuTgQg/vvwBvHwwHwYDVR0j\nBBgwFoAUceUWWe+yp037WUA/3ocLW8l4mF8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAoSaU\nNsDkCRSKbwIGvHwkg6NPo4Y6cFD/bQ/z11Mv9VQCIQCo4CmCSG0LlIUhZ/GjbH21\nbnIfKXBmLXYjqq5q8RIstg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdKhGh5759EcsdvL9CQHH41kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjRjZjA4Mi1jYWEzLTQ4NjYtYTBmYS00NjFmZDJmM2RiYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTWROkEmcyEfWJOSls1s3Ij+aE7aKF8JIJRjvUMvY4CvJY\nDIJU8yjWM3UAqy32gYNR9a5N1ZUdDgz3iWDo91Xxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUceUWWe+yp037WUA/3ocLW8l4\nmF8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKiuusHdqH3wgosSPx8/WJnL9PfnbsE395h2Sp+SjRupAiBbbLp0im3s\nb6VrszWjUMhdoZH7U9HzB+AUiBcZVNBJiw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAah3Aur3KJ7M3NIrBAkzjrmUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q0ZTM3YjQtZjk4OC00OWRmLWJiYWUtNzljOGMwYjJjYjM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzZkY2QzMTktOTM2MS00\nODFhLWFhNGMtN2MxN2NmZDBjMWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLdSBUXHk/54v2tuHI7rvxj4uN4zZG4DGgfy23rZ92z2djOcuun0EaNKs/NCbfjVo\nA/CD3CZb7XbmI5WJ9lFM9qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxy62yKCx1n2HbGuT\ngQg/vvwBvHwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgajDGL/q4SDq1W9D0tTV3pujTXtWK883NvaOEOMit95sCIQCN\nm1yWMCsG7Ztjron31CPP1lXaRlfQewFdotFgI6X9ig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3984", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3984` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAb+toPGkgZTUEQ48fIJu08bGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0YmJlODdjLWMwYWUtNDU3Ni04ODcxLWRiMTVlOWFhOGRmNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmI0MzIxYjctODli\nMi00NDk5LWI2MTEtMWZjZWI2YjZlZDM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj0tTz7M/Qdst/1WEcEi1lgD1PzxmiS91vEUqCfakxK4ZH5l+qx+gNNwh7em5\nrkOmIuocsyUC8izAx2vG1IDYh6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuZTn2zVS8/EvIbLycsvjEsZh55MwHwYDVR0j\nBBgwFoAUrXqHHDXPk3bedT7hTXwnnNlQoD4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBFAlvG\nRgniTOxvKyv7s+VQhnAWV01Pnp31rpCXGo0EcgIgfJBmIkai1Z500ulCKOmDLUX6\nwrbVXHBpTcRLL2/jPAk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdhe+3deLzaO7XtCJQbxk5NfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGJiZTg3Yy1jMGFlLTQ1NzYtODg3MS1kYjE1ZTlhYThkZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTg4+MTmnSekn5ixSFfm3Ud57MTNj9OK2uNBn5UXCGOuAu\nKkZ/jnFXvOwj0XzKZFANCbTmqn8lxPGy2b7EpiMyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrXqHHDXPk3bedT7hTXwnnNlQ\noD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVutur7/d+jYDzXe68etDQ72kAeYzBlt/JiQglw0u2ZYCIALsSBq6SScd\naiQCcVZ8GewzqjqZlRdj2zdWBWTEQ4cb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAbXxt4sgw6T426Q1m6dMGgVUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmI0MzIxYjctODliMi00NDk5LWI2MTEtMWZjZWI2YjZlZDM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGZhNTAyZWQtOTk4ZS00\nNGJlLWE5ZmItMTU4NTE1YTM1ODIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3HL0fuMV6yv2ogsl4uP9sIhmqPRm2xaMKiYl49FH9Qk4N7W+PmW4ZAt6sek+WbHG\nM7fAW8wFHf0xQSohraiS6KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUuZTn2zVS8/EvIbLy\ncsvjEsZh55MwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgCZxGZXBPXm12KMeiwcjIVxqnuFoz7tkJC+y4MpWhjI4CIQCW\ngGBp9gko3WsI07jW45eY82qtS3jZXabR3tzz50DJPw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3985", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3985` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAYK3MEGcmETVswKIs9tFOr80MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwMjMyOTE1LWFhMjYtNDVhOC1hODFkLWZmZTkwMzk5NjQyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ5M2JlMDMtNWM2\nZS00MWJiLWE5MjUtYWE2YmJhM2JkODA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElYJZqB3VD3ppofqsrERfnDnAhrLyYptZuRE5hpjJZ2o/10m5AZoLmJhs8vtI\nultoKg2xkjKvCz9YYKq2lfOaW6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGmRJt1cL2WFhjdVppCrnpnV3XiAMB8GA1UdIwQY\nMBaAFA23rleAecLFB5r0TRq9kNW3AhOkMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA6P7UDmUvxB1mGcW7/DwHvgbjGUsims3A\nwItURyKb7toCIQDL/WlEmJbqCCF94qg6QEBPrLujOYsl74oETsKIkQXoJA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcTi0xxqBdkI4yKnt77vUDGZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDIzMjkxNS1hYTI2LTQ1YTgtYTgxZC1mZmU5MDM5OTY0MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBMMCWpUMVXDSnH2ezInKvct4yXI3JOM9S/kqlG4jeIAOr\nuMkr/k+DhJdbbXDflh7QBJoAJIZHNGXnbhWIfBu1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDbeuV4B5wsUHmvRNGr2Q1bcC\nE6QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKS8M1nMzhtHZxqjg7+8YYyVSb3a5iuwCyKWTLSPPMP5AiEAyYZoQlos\nAewvbEtQI/6R7JRWx+MVJF8pYCBn9cF3aIg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAYPWjp9sB532L/SEKGCcxcWsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ5M2JlMDMtNWM2ZS00MWJiLWE5MjUtYWE2YmJhM2JkODA1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzU0MmRmM2MtYmQxYy00\nZjZkLTgzMDEtMWMxNmUzZjYzZThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3jpQIHYsTkZkEmjHdkVihNFarC9fJ8dVDwbVeLNusO1CwiUbXjaItf/knZcqzS6S\n9iaC9427KPQIJ6E4scN1kKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaZEm3VwvZYWGN1Wm\nkKuemdXdeIAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhANuQxyCGaGGnB5/Z/hsbXqUFLjwM1Il/nkWAhDTRAnRSAiEA\n+e2iYu/7BGKY6NYrQ4CkS31zHEt/XuhmtFJgPHuEgM8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3986", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3986` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAXJy5F4G0+yBgLOI+hCCFZOIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MjViMjM0LTA3M2EtNDRmOS04MzUyLTNjY2Y1YmYxYmNhOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVmMjhjN2YtOTdi\nZi00MmNlLTlhNzMtMWRiZGY0ZGVmNWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfTdW8XcLJtTvPrcUKB214LAwoZolEWF0JLsnux7YltMWG0johxsG2UveP8b0\nbsqzAopqi6ms+cH1NUDDfFGNHqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZv1svF+06KrK3Ilhdo1g5ECVpaYwHwYDVR0j\nBBgwFoAUrbwU/CO9Cfbx1cmikh8F9I2FrUMwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgE60uo6exWlYO\nWQdUtZoC6L17M485dOi1gxin4K/qSskCIQCvCe11kgrchdU2S/IaqA5xzKCruMlB\nayQgUyua+9afAQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdtqE7/Xr2h0+Y0FF/7sx8CrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTI1YjIzNC0wNzNhLTQ0ZjktODM1Mi0zY2NmNWJmMWJjYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnSczXyme5xoc6fEg7NyEe3x357lyG1YpfyLaxavCPbm7t\nFsu93nvlPV/lbihL0enll+C/+kV9JhwYk+vU/gedo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrbwU/CO9Cfbx1cmikh8F9I2F\nrUMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALfMciKTUQjqoBEthsc+rvqYF0Ve8iWv8qPUPqnx4yIzAiAzLBGoPNXh\nzcvXc2eLw4TRmFOr0x0YgXuWWtXMQwA0zA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAegn15IzeZHaQGE6MbWezAgPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVmMjhjN2YtOTdiZi00MmNlLTlhNzMtMWRiZGY0ZGVmNWE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmU4NzE0NzAtMjdmOS00\nMDIyLWFmZTQtMThlNjgwZjBlY2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nnp3+Zg+XALrds9Rd+dvo6bKw/mYU1aHa2pqqC3YGu+urP+7Dbf+6/tsMnhK/Kquq\nwxpE7gbHMgyvYM9ggSbOFaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZv1svF+06KrK3Ilh\ndo1g5ECVpaYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhANxF3I8aTDeHtZDiuiN+yike3KUAY1BMEuZ2RfMTKNHBAiEA\nw2GAhvod01FbcRjnCKvyE+kbhAkHHMgssu0ikWiSRxI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3987", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3987` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAdmY3Xy54PI1UNLto1CqGQ+0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhMDk5ZTlhLTRmMTQtNDlhMy1hODM3LWU1ZWRjYzAxZThmZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU4NDI5NTAtMTY4\nNS00OTViLTk0MzAtODVkNWQyOWNkNTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1u+r/gPuMczMOhFNSoD3s1yJw76muChOjLou3ubS7n6X3RaUClPxp9uVecni\nms6y9h3NuOc3HlBTuk8zJ9gvcKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo4REjVqzHgDSsHbSu/yACCSOHj0wHwYDVR0j\nBBgwFoAUF2Ig1KVegWJAgpGEw+389YZM1NwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALExNtS7EyKl\nkvQnFGE43Q6bWlgR7+jfQS837DdwipJUAiBPPzSFtJKjN7xlDqsxYxwhMJtmGtvK\n7cDPXglpxbwETQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATpehkdmQaxUHPaBsud//VIfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTA5OWU5YS00ZjE0LTQ5YTMtYTgzNy1lNWVkY2MwMWU4ZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxxurHBq6CXSANoeUGppBF/QvcwivLAKGpFhFqHzmEAE6s\nbPoBFUeG2tWoMYH8ucIGKFrdWYIuCxERMTt+Cz1uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF2Ig1KVegWJAgpGEw+389YZM\n1NwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALpA7S/CfcUm7YsnZ6xXYfgIuZn8aYnKyBJg0/6GJof+AiEA+OiQ0w4y\nx1brq8eJhQnVHtKJgJ4OSstjf5Fxhe5RU2E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAXOyIyg+QcicjJe1b1kfKy0TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU4NDI5NTAtMTY4NS00OTViLTk0MzAtODVkNWQyOWNkNTUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzI1YjVhZjgtNjhmOS00\nYWI0LWIxYjktOTg4YTIyNGVlZjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJ7Jn6cy6IVg0TJeEidmMKWOGyaaE4XvNSGuxy36ko/KOFL2MX57CW/Rhx6fY7/1L\njnJZW4pvCYyZQuEAifcAjqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUo4REjVqzHgDSsHbS\nu/yACCSOHj0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhALUE/HwuCp3MtBw5SjG1z4fmvrPa18DC7Ntz9Ma5a9mAAiEA\nw7xqaA8Ww/6oiyfC6XAh1+ZKcYnFoAG9M/UxeMtmHsc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3988", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3988` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfNGxNxiIJOiclEQ/Y/lOV6EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1ZTRmOWU2LWEzZWEtNDVmNy1iNDcyLTY5YmQxNjlkMzFlNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI4YmJlM2ItY2Nh\nMi00ODZmLThhOTItNGExMTY4YmI5YzQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPzni9XFmFH4CCz7uaJwms3cuy7Drqm+F3emOtoYE2ww72cszTwhnFm7A6QEz\nFAcDh7MClZFW/qFfG1qerUJFbqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrdf8Uqt9FTCN+gwXnyhNsk2/VAIwHwYDVR0j\nBBgwFoAUAFxiRHINC9E2bPHeq/OMuerXMV8wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBwF0doEGNci\nGDtgEomBrR9ELOR2fIPKFfDJS0+P/CG1AiAH1bZ30pHHr30U2DNBHLx2oGrZ7YH8\nUWsmlarSkt8sqQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc30AidWWC8zZWgAy0cXDOTcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWU0ZjllNi1hM2VhLTQ1ZjctYjQ3Mi02OWJkMTY5ZDMxZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZWUrJnB1+uxKpwqg0LAYu2dSuQ/4jKWSuUQCAJWUGEFpw\nWh/u0eaFTx6RmrGh+dPmOvBMuAs0M25TzZaPiIWCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAFxiRHINC9E2bPHeq/OMuerX\nMV8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaaC/Rs3kopvcWmCXeR4jtRvMa844QJXPgwLSbAgmVkgCIQDfKEM1tvGj\nXl62W+r+rDTrr6eAdu1ORi4390LCdxbA9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAdPVIY706GeaF9Et+E22vDp2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI4YmJlM2ItY2NhMi00ODZmLThhOTItNGExMTY4YmI5YzQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGVkMGEwZTQtMGYzNS00\nNGExLTgyZmUtODRmOTNiNmY1NTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nehUbSEeauIvu7lpVdonuxC+DIcQW/QhoElPIxhSF9rOa83jQgLWQyWLnoKn+E52v\nsVJUHqLfhTNqqVN9c5F3xKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrdf8Uqt9FTCN+gwX\nnyhNsk2/VAIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJW1MsVVFnjwHb77UhupzmX60/hjdS1df0dK7iiJXkakAiEA\n08dbwXVIujEM85SnvDK9521PXstC2+lhDBkc7zDuRnw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3989", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3989` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAb/hJbl/fOosT0p4u6TtzD1FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhZDZlZDU1LTk1ZjQtNDk3OS1hNWM1LTgyZjRjMDc1NzEyZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBkYmRiOGUtNTAz\nOC00YTZkLTllMjQtYWE2MTQ1MmI0MzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHmUfSfvB868MpIFrui31ns8WhVibSIGG1O88T3Ilz+jX1zTU4n4R5Iqpy9N/\nzLgKe3wrGF8bShYBqiTNl2L/B6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxdrri6uqus+HBuJ09vVGU433AlYwHwYDVR0j\nBBgwFoAUSnTT+XZCnx8LzqY9t2y/YpHv3TkwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCa+V3Ytaj3xn7fKYhu6eJu3psNr7MvPmepX8OJBnO4UAIgP/9hU/6dYMY7\nvKIzmOWCc6TcYQg+cW0jVl3k1cVwP+4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASG1a4bJ8hlwcB3thCC4soSiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWQ2ZWQ1NS05NWY0LTQ5NzktYTVjNS04MmY0YzA3NTcxMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaIoil/HOl0NBCSxzBSnERv2PqgRmYw94Xe6phbw1WQOfQ\nVBH9zSL4KIcEQEFFCjOi3kO1TyqZgka3Nffc+JD1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSnTT+XZCnx8LzqY9t2y/YpHv\n3TkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMmPFqHUplvcGAHXzV3GFvs9YSA/jEEEw4CS9zpZNULDAiANXWF8srtf\nXOFlPvciO733DkYl4onEi5i57dG2JBsZtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAUZ10c1k+tQk9A3kcxwszEL8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBkYmRiOGUtNTAzOC00YTZkLTllMjQtYWE2MTQ1MmI0MzY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWI2NDljM2YtY2U0Yi00\nZTgwLThmOWQtMzI4NTM4NzJmOTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXs+2adE2q6aFkMjtQ3XBal/U3kahaeO3peUY+TozTp/D+ZYrWH88VUhCGKX2Dude\n7kLK3EG9kNhRPgDTaUIfCaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxdrri6uqus+HBuJ0\n9vVGU433AlYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgZAkbm0du36JbFZpG60BcMrAhiHzlI2q/0oOBhzsrJ6sCIQCm\n8q3PCCUxRX3mGz783dSynn/YSb/RQ6T2fVHRGN6oSA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3990", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3990` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUpLXLa2hQbhN9e914jWlYQ9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhZTlkYWY3LTU4MjUtNGY4NS1iMjVhLTQxNTgwOGZkZjQ5ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJjMzNjZGEtNjUx\nZS00YjA4LTg2YWEtZTJlNzUxOWNhNTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX9yAK9PhXflgBCrCz/UE3H7GAYIQNYQdShrA6soyW5W0U+CpBC5RXI2kY6U/\nw4cZrKI39L9TsCUr+j2r14PUx6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/+b7/dPd11YgmVbMcpihD9tpctwwHwYDVR0j\nBBgwFoAUOkjiHlwbmte6Spxvpiaj45/ZxnQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC/ecZY4R8tuPNxVHi643g1NBIQ1xBmBXchVcOOqCb4uQIhAJKIpsB6CTTA\njaXHIoYa3eJr6vYZlmulI+WWenkVgnoe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeEDA5+ZQdl8DjVpYpWpz0msMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWU5ZGFmNy01ODI1LTRmODUtYjI1YS00MTU4MDhmZGY0OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCOmMT7EgkG4H7uj3C732Jd1RaO6ICvaFwcn702/n7pUex\nhhkImZcuZOE2ZiDoTBGhMtdiF0/+C/fXArWonssFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOkjiHlwbmte6Spxvpiaj45/Z\nxnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQGiHXjWAviEGAqw4zY7DBy4sb2L1GxMRHCvBITKV7H0CIQDGUOkniSqb\nZdRaD8cfSC1Xj/AZpB+kDNHDTQodZcWdMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQEvMwV+fbT4vTqN55mjpIZwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJjMzNjZGEtNjUxZS00YjA4LTg2YWEtZTJlNzUxOWNhNTM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGEzNTVjNmQtMTBkYi00\nMmI0LWI5MzItMmJjMjk1NzBjODI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJtYIqhneOaz+8W9U2Ja58xvAdKR8RgZreGNmM6IMMivOKnfpUaxRiL7sMlUyhVpi\nSWN8HmhNulPBGc4LSt4UZqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/+b7/dPd11YgmVbM\ncpihD9tpctwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgMzw8x8rY0R6eZKM01gaebd3cNdg2Fave61uR1bEUOmMCIQDc\nvDqPHK3IWXuDf/ZPA0L6Ux9kZZbWeW+l96Q87abfMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3991", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3991` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISARHSJeTYnUGLuErP8lH1eepuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkZWY5Y2U1LTc1N2ItNDY3Mi04MGRiLWE3MzNiODYzNDllYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRmNWIzYjUtZjlm\nZi00ZTc0LWEzZTEtMmY5ZDg5ZGRmZmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER2iKUGLF4vTyg3m0EeTbN3q/BcS5iXUoWaOhzikDE0oGk5nXd5eU7RIYu9Ak\nDfRzUEDTKfUJ2JWJPen0ELypbKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTwd3AST8FDL3vk0rKwqsB4T6Q8kwHwYDVR0j\nBBgwFoAUsxowQdnZ13GPN0QSBIDSdr5uhzcwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHhg\nmuZtEFbulQBfLJ++3NylVNqh0YfZJRM8y6a7F+llAiB/v6quUxRj3D2SVHTDk4bz\nDX/Y6o4Ka3KO269o8Vqjtg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASYVuasAbz4WlPsFWSeYxcstMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGVmOWNlNS03NTdiLTQ2NzItODBkYi1hNzMzYjg2MzQ5ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvI4ZQMCng26eJSHrrDL5DKCWYhgQvmrhHbqqJslVwnCKo\nj56Ilj8/iDGWOyBg/ytB7hxOgaBCndiKDjEtTRKwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsxowQdnZ13GPN0QSBIDSdr5u\nhzcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALkYenQFMT5at5/5k8TXrvW4LQsUE8yz2gS4ag748603AiAEqgm2Hk4G\nuFAHgkk0ikSlK6YANmKj96YqtMV8mnVjrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAegp5rR2B+YH/TmFMg2Cx5B7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRmNWIzYjUtZjlmZi00ZTc0LWEzZTEtMmY5ZDg5ZGRmZmM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2M0N2RkNzEtOGM3OS00\nMmQxLTg3YTItOWNlYmNlNWQ5NjBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nu2LdXLlaFUghbXa8WCyrj3y7v1zHvBW+CHcih/5y5BeQAxMOkwSoBFZqQTekt8EM\nX9pSUWZNyis4lWyEqaggmaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTwd3AST8FDL3vk0r\nKwqsB4T6Q8kwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgcThYVaWGewQWR+gWIneTr2xCOlCMjdX+3VwNRwmdgI0CIBOA\nLgDtXXxluhkcdT2L8j9kmk7nCOnOTpcsEU+Q9Ytm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3992", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3992` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAbfVjPDhTS3HXGR2AMai853TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0NzdkNmFkLThlMTItNDA5Ny05N2UwLTU3NjJiNmY0MDVlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOThkMTg0NGItNTY1\nMS00OWY4LTk3MTUtMzYwZThjZjA3NGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFNKF5LUV1hl8+sY9OZVGP3ZxhRAI1sjV+W9TKc6Xi990hze73dfypyjWOdam\nPfWVq0aklSnAcAmP4r6L0K57jKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFh9EvdlU7UTsys/tca8JQKoqNWkwHwYDVR0j\nBBgwFoAUgaZtSACJQO84SwHQTrHi9BN5mOswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDbLG6FPhHd45KWr9T/vfkoT7GwwtGcYT/RtHPEtx8euQIhALaY\nVmctwo2oZWERgLFcqu++htnNwA3S3SFz8d2bLhG9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeSX6xzO3NnZqJ7b9b6DE5fSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDc3ZDZhZC04ZTEyLTQwOTctOTdlMC01NzYyYjZmNDA1ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmnimqTN9twV5SJ/WSv+OF2rsD7CRTV4NXdrt7mr8m+tPH\nQ56YgO7qcU1iBSD1tujmyNE0KsnnWay+RsnBJjIEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgaZtSACJQO84SwHQTrHi9BN5\nmOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMPKd0VDmF3FyDNl0aMTQGaUFaasFGFqz48w2PJc1A4WAiEAktuZvADm\njRL3CHYNVkSAp8+mBPUiUUB1i+dYGSNx//U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAbxWTXqEZcpDaigQL6Ru3KxWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOThkMTg0NGItNTY1MS00OWY4LTk3MTUtMzYwZThjZjA3NGZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGM1ZTBlNTQtY2M3YS00\nYzkzLWEwYmQtYmJjMDUwNWJjNjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJzed21sr39jfkEwDxtFBah2mgIcjA/lR99maI8mIvPtGPIRfiIpm1IFWPG8h6uFW\nOiZO4FtAZ7iSooDiyPiLcqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFh9EvdlU7UTsys/t\nca8JQKoqNWkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgS/D8e+QCshsgIFgm0TvJgdpCAzNlvKQpyRa86LjF794CIQDQ\nCHGrfKpyOPLifPzmcu7p7gpLOuh8A5ve1VLmATTcwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3993", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3993` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZx7bi1P0jSC6mpvneu5y+wSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMTBiMjQ1LTRjODMtNDFhNi1iYjRkLWE2NjZkN2M2NWMxNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQzODU4ZTItN2U1\nNy00OTY0LWJkZWMtYjJiOTc2NzFjY2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzZIvw4tEokEt/dJkMAtAN+k8LX8RqxGr5YMibprSonvlzTr/sPDPRszcPeA4\neuHUKDf0Z+QaVBz7gKHaT8I0xKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfGav4lxHHfuLf9P+YfzbJA0GUVcwHwYDVR0j\nBBgwFoAU7X2r7aEoSPYK7yhBlzjLVt731l0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCR9TR9IdBJ+h9mPAqFJbe5wicPwTUogJ5UqEEOo+H4qwIgf7I2\nim8bFA0zRpDQ+ZkxEXSKSi+yt03PQJ3h5pnXcEA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaHnG5z3AaygK0pqEYv1DVYEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTEwYjI0NS00YzgzLTQxYTYtYmI0ZC1hNjY2ZDdjNjVjMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkFJ4rqmt8eMCiHcsTHX8/YDXu7jyd+fqUzB8bLpKS0I4e\n3b59vQh9y8EVKqjqnZihTUHN/JUPwj9h+diK7jVXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7X2r7aEoSPYK7yhBlzjLVt73\n1l0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIkdZAeqhrAHn1BRFE3jVW9nPtfw4aZdgqnHvBQ8G/m/AiAv9tde67Bm\nsWHQx94sncJTOtyfq71e0jCwPrE+GhTn8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISASgdz89XsZ973mXhBJvNumQQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQzODU4ZTItN2U1Ny00OTY0LWJkZWMtYjJiOTc2NzFjY2YzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGNlMzgzYjUtYjE3Yy00\nNDc2LThjYjctZmVlNjBiMGFjM2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuEcOY4FtGp5amOUANR4JgH57NKia4L1U/hAcDK07DW01LZjBIfZHUeIH0xVc8WxD\npQK8VkbEdxlbSRfflLIBx6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfGav4lxHHfuLf9P+\nYfzbJA0GUVcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJTtST5Efzyqx1ngNOGEowiqxoHTcBtRIGN1PfZIafX0AiAZ\n2ZX3H15HwMOQE3mcRbqwmE7l8npcpeiczQB/wLdzeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3994", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3994` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYBv1LKiWbBMoW3Gw/gs/rV3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhZGE4MGY2LTI3YTMtNGNhMC1iOWE4LWNmNjhkZjhmMjdlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRkYTllOGYtM2Ez\nNS00NDUxLTk5Y2EtNmYzYWZkYTFmMTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYfcZkUbWqbXHrUijrue6mSX4JDjBbI1FyIDuibk71sZDV/SIU7N5pDDoDOfa\nLhUpWg/sMYMi6HFGNMUMndCWIqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFElO9aGbLPpPvfzeqwjyd/xqomOjMB8GA1UdIwQY\nMBaAFIlzaXksMdEkYC+xfGQdTL305CMvMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA2mH6LRlAphmlcw8Q9HOFVMZBg6gkW+vY\nx+s1AesTn2sCIDvxD9fOGUr2Ke4DW/McUiLXHCs66gGWWdZZxGlCw09h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbNhyJJ6aKpA1hFaLahSlM2HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWRhODBmNi0yN2EzLTRjYTAtYjlhOC1jZjY4ZGY4ZjI3ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUjhJzmpwRKKxWrsOyBrhQXq/lEOpubJ96vPwqV7ZTjgO/\n1P2PzOX5kQq92CFHPomy3neF/G/dkGTH10fmGlASo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiXNpeSwx0SRgL7F8ZB1MvfTk\nIy8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIi8pFy2kyJP8tDF7rUgvTOojEIGp3sk9yH0iWRx2jP6AiByAVBmwraG\n1uUYyFbH0f6ZmUd6hLan1R54Gwv1DFBaYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAajJ+gBk27TEFpn6Nb/qrXN3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRkYTllOGYtM2EzNS00NDUxLTk5Y2EtNmYzYWZkYTFmMTU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzhmNjY0NDgtNjQ5Ni00\nOGE3LWFkOTItZmMzMmJmODg0NjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njnrJQ2F+VJFRxzvwBeEnXnPv9Lmq9m+nR6FGLgC9Lm95HyqjDZz5XlYEAT0N1fTl\nBO+8PqHRykzG+q513F1niKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSU71oZss+k+9/N6r\nCPJ3/GqiY6MwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAKkOhO/zXMzpD+TpVPyWLhzG2feV4MlLA9o1+r8Xyj7yAiEA\nwKTce0tCzyUr4xOkCzDSQyrcJqzaGr9i+ycYIOE1bEU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3995", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3995` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAawQzK1pMG/lq2Qznlpg7hhzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlY2M1NDIzLTQ5OWQtNDM5My04NjY0LThkNjNhMDAzYjk2ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NmZjcxY2YtZGMw\nZS00MTg3LWJlM2QtODFkODQzNTRmYzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEThv+Z4LaTgwfaiMKi1wYy9JyIwGUZpxCRMlE7LH2D2il0OAX7xBqbh9f6yi/\nibKZG3zDedVaUr53a/dqs4G9AaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPDXCVSYr0EhDg+299X0ccpvtX10wHwYDVR0j\nBBgwFoAUJM9dLwh/kAUq3DI2wF36pnmTlgMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgYdYx+nfoyw83\nO3O+FjtxMqe8OjCSZmgp6n9YvmmeO7ACIC8MkQLUapyPonRb5T/R6fColIEC14zx\n7h0KuLG33ApJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXYbjQz405bwgER6T0HAKDoOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWNjNTQyMy00OTlkLTQzOTMtODY2NC04ZDYzYTAwM2I5NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuzB9DQNsnhgBZZwcAvtRfHBfHWEayy+qnvdmc9zZ66/8y\nXhrj7Qhic6V/ImckJREWGjw3dfCwGce/3gBKpDGBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJM9dLwh/kAUq3DI2wF36pnmT\nlgMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK7Y8YkzzwszA+1j2IxvU3bPYOWAjqIRQSCvS1zDrmOgAiA2k7kyH1od\nPoxLqIG4ezCaXKVXnSoELdlXlkRrJwfN4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQWA9gFnkC2GCAIUFjLwJivIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NmZjcxY2YtZGMwZS00MTg3LWJlM2QtODFkODQzNTRmYzljMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTg4MWY5YWUtYWU0OS00\nM2MyLTg4MWItZDllYjUxM2Q5N2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbD/FvELHSpu9wPPiFm52VoRN0Urjn1pgCYH1qriSXAFYm3plsA3DoxiFkEanVrJ/\nrP7sz13ISFSN6ZqPW2w3oaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPDXCVSYr0EhDg+29\n9X0ccpvtX10wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAK/jUDyOYPQjHg3p9ClpAry7UmQ1yn2ZX/xCF79MwXG4AiB4\nwkLqMeKZl5kUly2TNZ4rnOwyIMMrY7QKdBMH5Podvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3996", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3996` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAXcBzguz/NWpe9oMtj+yWJ1sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3ZmM5MjJkLTgyNmQtNGQ0Ny05OWEzLTNkY2JhYWIxY2I3ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZmNWZkNTItNmY2\nMS00NDc1LWI3NzItYmUxNTU5YWVmNjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmNO/tvcgpSOgp7p3/Gm2KpWyd0aOgsbSfngbo8mOUc4v7dzIYn0yHTZLtq2B\nIQEr1eu7/yUWjIijjjYdGKlEXaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPt+nXeJ9z1jl5hLNGaJLPp9f6s0wHwYDVR0j\nBBgwFoAUpR8d2fVVvtCO9/4T92u+GHOYf80wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMXQIfpi4ktc\nKQon+vxSxMrXZ3MNFq1C7IvI40S6/CBbAiEAjCgjUe/uBxU/qaQXyDBitj4qvsSI\neDIH1tg0HqvR9HQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASxL84LMfuTTfCYAWgfQnZvKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nN2ZjOTIyZC04MjZkLTRkNDctOTlhMy0zZGNiYWFiMWNiNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOZzj6dn3AeGC5q7HGy+Dj9ecMw5RZRgEnBI/qOPTCpQDw\n0VQT7CbCQUQf6NB8PC4hehqLKiL5jBeJmw0INqF8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpR8d2fVVvtCO9/4T92u+GHOY\nf80wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOOSMAK1X2SJ2JgFUxfB8gjekJWn4mq/xeaPl39WuniSAiAobbweXmIv\nZX0OL5MiyHgaONs1IU77Qmdoi3pJu8w59w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAX3yBz85f325ZpKgz8kFLyxJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZmNWZkNTItNmY2MS00NDc1LWI3NzItYmUxNTU5YWVmNjk1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDVkYTY3YzgtMzRhMy00\nN2VjLWI5MTUtMjZjZGMxYTE5MmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9WDauwOoNrZGQ7jYreiG/4FoBwR1FVvcPyrgimN+daJKwhptpDW3TCIEG3VO2Ce+\n6C0DK6TMQxaBHu8C7xAj3qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPt+nXeJ9z1jl5hLN\nGaJLPp9f6s0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgWTEAJX2cx+6uK0zW1Lu28loQQYE5E/YaXG1wCeRCgy8CIQC/\nQrVxfbMV1Kn3WVrnAlSqPDxH2wILW85XChV44v0NwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3997", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3997` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZGrpZiZbGirVTByuR3EPjb9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxN2Q1MDFhLWUxYmItNDY2My1iZDYwLWIxMWMxNTE1YjZiMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTEyMGQyYWEtMzlk\nYy00ZDEzLWJkNzItZTBmZmZhNzA1OGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEij9L0a/POGMbsxmUAfqXC0yBw29T81wChKBMDGhnlmZ1BgnkQO3oJdjJ8rEh\nTXxFIGWb+MRqBsZ62RL6xmV6DaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkuhWnD3jg3f40BFbixyScg+AObAwHwYDVR0j\nBBgwFoAUV81rZoOrx0SRvdFlXdKkHYnuP2QwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDbuaOwdB54\nK5gtPYkfDooeyxmdEpuEidPvKiF4EwrFRgIgHuVYWYELS4jRKYdIQSw0qh2WMet4\ncjJMdPu/A36FfXk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbal5ot6dFcwAfTa7P/IFPTIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTdkNTAxYS1lMWJiLTQ2NjMtYmQ2MC1iMTFjMTUxNWI2YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtLsJtQcIqqxOZljMc5zD8puMgItxEk5U5qn++XZ2ZSQDP\n2NXRquwfM5U5bjUi8JPColH99iARjRChA9XHghzoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV81rZoOrx0SRvdFlXdKkHYnu\nP2QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSa2HNcR3QWia8QcSJQNEf3uwwD1FECc+XDrTWVRkiiICIQCJoVGXXcWp\nPqmQQKqW/ihNLnjEWlT7uSnffb2TYx+dAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAXHjnUMq6KJZN7Ddo90bIsXqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTEyMGQyYWEtMzlkYy00ZDEzLWJkNzItZTBmZmZhNzA1OGVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTZkMWIxMWUtYTM0Yi00\nYmZhLWJiZWYtYTAxOTllZDZhYjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nB4xqq2J7PioB5wq7XzMNGf+0ZNdbIVuh0dCeULV8YBwZfLSlH87xflRyQQhSuiEk\ndCPb5PQ6XOpJKu1coJGwaKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkuhWnD3jg3f40BFb\nixyScg+AObAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAKFPYbtqKxzLncYYE7SlbGDX+3n59flIWt9knTArzrKaAiB1\nKYywWgfDCD37nErATwHNbFhlxxJzQ4U8aUXsbcHHXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3998", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3998` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATEUhfqej2el9fdJ5Cj5QqTwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjZjQ4MjVhLWI1OTktNGJmNC04OWRhLWY2ZjUyZjc4MmFhZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGI4OTlhYmQtMGVi\nMC00NzBkLWJiOGYtYTA5ODYxZjNmNjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbqgnW9JB7AtSLo5Y+/S+txXdzrrs0Bq/6NUw9OUidpLxlmSVdOU3yphYF3iI\nsrdlvRwsCTSYtj+fJXZ/qmQJy6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURxV6odSTu/WRneAbeG5I1UNtfRYwHwYDVR0j\nBBgwFoAUzxjbAfFdTtV3/fMSnK4nLP6UbBswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCA+SpuBBLK3tIdCnbP6tyksuU3hUgOEJk47wnwaovYugIgSlzOAhdYEcf5\nZsWf4WTL+pY4q30Ol6REi7HPonMNq2c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdpkih8wGUpKbGrqkc5DDSU5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2Y0ODI1YS1iNTk5LTRiZjQtODlkYS1mNmY1MmY3ODJhYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNwqsOlYZiM0qFAw98OS9treDwzNaQGXIAIVw9FublNF/3\nxa7+0+EfUVDoWzDfekggSX2IGNNaUeYRgZqIgqTWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzxjbAfFdTtV3/fMSnK4nLP6U\nbBswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO/EMI2MeCwqsrSXGHXHdXKNAGD0LZqgwEUYiG66aIM5AiEAj0exWsdy\ns528BatH8AXsEaYpbc2cMwL9jOenhlRGF8M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISATgK56Yw64skNAIfp1Bc+jx2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGI4OTlhYmQtMGViMC00NzBkLWJiOGYtYTA5ODYxZjNmNjQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDQ2ODkwNDItMjlkMS00\nZWQzLTg0ZWYtM2M2NzZhYjY3M2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nInNI0a0gUdUedWXc6haL3shRRZ37fPWAR6qW498utN00MKKk+J7r9EuBKR9RzzWc\nrRzIeScyEjhFLJwvLU/YnaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURxV6odSTu/WRneAb\neG5I1UNtfRYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIbmz1a+MP0aAofLFuFi2Rjzzy0KVcuUWN+yErrTzII6AiEA\nzUkC4kz1dzlmK0WRKR3688sPicpjWuwXHNCH02fC+oY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc3999", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3999` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAToA6g9qsgxLFUkJaPLZQ9z6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzZDc1ZTYzLTZmMGEtNDU1Zi1iNDFkLTIyZDAxODhhNjFhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc0NWFhZGUtMTBl\nMS00NjExLWFmNTItMjVhNWU5MmU2YWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmF7W82Js3N3S1m58jLlhCKC9RMBZpUScNzVJr73Edq8r1LiZxJWlGe8YGG9u\nTEx9bA91AOIgq9ClnqaJWEc3zqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Z9mTCHOQiIkN1kEz7ZWuCyDk04wHwYDVR0j\nBBgwFoAUPo4r1taNxbPrpYD81rCoR8r6YbIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAF4V1s7Ydc4I5iF9ZzISiGzAO70YiimgPHm6WVyV/m2AiEAteLow4bb4/vz\nNf5XfFETl2o0gQWDjIZlIS9XDboHKkg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUag5XN3QeFeLMV4LeHtq6VVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2Q3NWU2My02ZjBhLTQ1NWYtYjQxZC0yMmQwMTg4YTYxYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV4KpwHrpySZ/pEHQjhyFw9rVz1564mtqk58eZTVnhqdNA\n0YIJ/SJrd7lSvkTyfX939JgLzg37q9NHBoKg2jiuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPo4r1taNxbPrpYD81rCoR8r6\nYbIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALOTYtpqpxoxGP55scuVQPrNDcTw6r/bzGpeFpFrBVaMAiEAnu+d0gh2\noYMKctnzh6LYLrJIYtso7X5CdqZ7B4xIZo0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAYNu/z1jR8ZETJjsxJ3q8cKoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc0NWFhZGUtMTBlMS00NjExLWFmNTItMjVhNWU5MmU2YWM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTNhZjc4YjgtOGI5MS00\nNmFjLWI2YzgtZTg1NjJjMTYzYjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSet1Ywyq6cqt8ll11bRQnw+X3Mlv+7uhuJYFZKe0xtKyg91S9FQEsPkuoLMCGZUD\nFIPc04Gk8mO2QqKPhmF8/6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6Z9mTCHOQiIkN1kE\nz7ZWuCyDk04wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIxRCHwFlPOWxtGmB+NQVf1aNKlQjVxzZ7wsOiyfHsJ/AiEA\n2HetYlMOCVTX6Mu6hnHC+587czvBL9gsIXeFhEQ2ujg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4000", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4000` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAQBR/PcJ9T1n7mavdYQOCS0NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MmRiYTBhLTJlYWEtNGNhYy1hY2JhLTkxYmEwMzA3NWQyNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFiNzhkYzMtZTJl\nNS00NWE1LTg3ODEtYTU2MzZmYzAzMTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbeA/Yuu4qmRUVGU0V94/IO3UOBAhHm7txG4JNCyTSqJXGgKd3b1LL+JZV8eI\nYxVUe6zcUwbmbR7fHDwTbDqxmKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR2+E8UfYVpKbaqbblDsmjPsaGJkwHwYDVR0j\nBBgwFoAUym1YJWjPBLevNG0qD8dnd6DBFwAwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDTL\neChix8RaICngO0NWan2IMXZLDR8qZ36xnaWO12ccAiADgMJmvP8tV7LeD7HRtNkY\nqYM+gWtQ/8EUtgmTT1uXag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATshRJt4v1SAdc9Qx+t1HFdIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDJkYmEwYS0yZWFhLTRjYWMtYWNiYS05MWJhMDMwNzVkMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkQec7Ucwkl4G2fnRRuuCibXEQJ1Ppo8vxq3LgLWlfWYKX\nbLNWr1SHjQST7y25Cf55MGTpYAViGgS+NMu9/BlBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUym1YJWjPBLevNG0qD8dnd6DB\nFwAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN4CZtB2Qv5IHi+sKlCFha5CId6klY+pLJodCNbMjgAuAiAdXlRW+ADa\n65nX0QVbSanUZD6GoD0wYjsebEtF3n71Tg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAXJ5DJnfybA2rfPMhlQPgiyhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFiNzhkYzMtZTJlNS00NWE1LTg3ODEtYTU2MzZmYzAzMTU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDI1NGZkYjAtZmEzZS00\nYmZiLWI4ZjUtMWJiYmRlNWYyMTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6fvUIaePXnE6To+94+qn51QW1Ov+dJMaUVGngrC6Tm9T4cv4AW6cf8b3cpNFliK/\nOfYp84UYo8tGHfMIOWYndaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUR2+E8UfYVpKbaqbb\nlDsmjPsaGJkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhANFkOuZpuRWtQfpLx55QZrB5izof9xIdpay7IolGqsCYAiEA\n/P/xk4v3eAJKgYPdqiESHmvyW6RFmHU8Ys50Qc3sqCQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4001", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4001` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQmytra+6WO1okSas+Xdkuy0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2OWRkOTgwLTQ1OWMtNDg2ZC04ZTI0LWU4MTE4NWZiNzUzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA2NDFkYjAtMzMw\nZi00OTFhLTgwZTQtOTMwMTBhMDdjYzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmDyAizpgmVNmHrkaLk3ARfbOG4smn3S+irGvJ57t9FwH0007eLceYPYj7YT0\nzqT94j4ujzNLjgHqTEj/0/3wxqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkrt3TH03qa1tC2yyrrUnt8MgfIwwHwYDVR0j\nBBgwFoAUmrQjwp7UyKYnuw6C2XfbDJrNSxgwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCAUT2b5OiRRT+zGFhEjv+e4itSlTD7lbun9JJNX9JyTAIgV6Bk\nsr+E26fZNhPg7Z9diGEon1U0Iq7IfYKxRjEgQ9g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfg/Wn9XkgcshjE/9YG8rIwBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjlkZDk4MC00NTljLTQ4NmQtOGUyNC1lODExODVmYjc1MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5PWOPgtBUjlp+6ZhFjaMjOlz4Xroi5cZSur7OCgAxgpZo\nEyIyIkfr9UE77QLHp8d7gqM8F6S0aVw7dMRAv1yvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmrQjwp7UyKYnuw6C2XfbDJrN\nSxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKVvq/PfvF9tbuavk+b1S+UQhkyyl8lAq5tw6am6UgQkAiEA/PFFysfv\nfj4Rqw+eLyACCyOWaXggH3nxTCl6DQa/bxk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAdEDdGJ6B+bBJzdpRRGXNafoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA2NDFkYjAtMzMwZi00OTFhLTgwZTQtOTMwMTBhMDdjYzQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjUxMWQ4NzktMWVlOC00\nODI0LWEwNTMtODZmYzZjMWI3YzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMi/IHtL4CP3gOLRsZhev6nWbH7sMd5NjqCrS/lz+0ff6Rky29fyTvlQBgUoh+OYp\n/v71x1W3pdudWmOY2N7mNKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkrt3TH03qa1tC2yy\nrrUnt8MgfIwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhANvcI3HQQDUSLU+RYiz+iXBnRtieBJIv81rfG9++rwsOAiEA\nyc8zCNCSMiuC+EYdYHdHF2mqrJqIxVq4l4KqEdvQa2c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4002", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4002` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAeYvIrbig69kQLdF1fl54773MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5YjNjNzQ5LWZjN2UtNGIxOC04ZjhmLWUxYzVmMzA5NmM3YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjMwOGFhNmYtZDUz\nZi00NTU2LWIwMmMtY2ZiYjU2ZTViODNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu0eTLSk69VHSwTx7TQfEdDZIroGg1BNVbQs514RAeQx3MVh79znzFMGyqpfc\n5HvDl6Vw95MrwKWYOxI0UirMb6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYrS8U4ewu8C9gJldzQcgmPX851wwHwYDVR0j\nBBgwFoAUYSbERexk/jK4hBsw2eYrMc7iYwMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIDegSbQ2aToSJjljDz3qiJOr7CsWyw0ix4OdFvNb9m3VAiEAhyj4\nQCQLUtScaBAWD2biJdIy+NyzVqUohBQc86tIa34=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWlCH7ox0Z+xDt+s/BDKAU5DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWIzYzc0OS1mYzdlLTRiMTgtOGY4Zi1lMWM1ZjMwOTZjN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvSxGW2ULIUL7femtKU9wmRithK39eyUx8qRfj6i8G9yBj\nePIMGLZrBFsj+JYKUZqkXgvZ4GUob75Zx8cBBqLgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYSbERexk/jK4hBsw2eYrMc7i\nYwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMgYpabYSZqkPsckcu6CEAO+Oh+D2VDGxbOdKG9mCSXkCIQDArlLwuoV8\nSieT2yohIZE/GxYQOgVizjUrIzYN08bzlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAQJpVZkPube/SW/h/2kLgBrGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjMwOGFhNmYtZDUzZi00NTU2LWIwMmMtY2ZiYjU2ZTViODNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWZlNzFlZWYtM2UwMy00\nMjdlLTgxNTItMmVhZjQzMDgyMTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSRZslaOnMaLnHJEDQPUFZS7/w8xAnzBrWS4l1k/dx/oIUhbUX1Y23TPxrvZyusMM\nfKKK6vTPBqHYm2bg3HOU06N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYrS8U4ewu8C9gJld\nzQcgmPX851wwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJWlJUbm86O7q6G1x01ve6LKPQYoMi3HpRty52XhfyavAiEA\nw4oDS9ANkOGyPGLmQF4MfiUjWxXCZsoV2bZlCvJ0IXY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4003", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4003` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAXen83DcFFX+fD78XjHzB3xPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwOTIyMmQ0LTk1OTAtNDA1MC05Y2EwLTdmYjdkNTY0MjFhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDM4MDZkMWQtZjVh\nOC00MGMwLTk0MTMtYWE5ZGQ4NjIxZjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE28bFRkG+gXkfC1yCraD48/k1EI3aRH6y0Ow2cPASzdfNIco7T8XZ8jo1w4PY\nsFYMo62md/Xp8Hjy8cpq0mZbUaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTkLjE7ntfmbP6qudDESgFUPs/UcDAfBgNVHSME\nGDAWgBRGwix2u0DVYT6FWnIFoOaUFErOyzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDBnJvvevhPX830wGNG5zqivvWALee9b\nTHeOYfKY/UDiAiBETac0AQens7mZTrLM6uBj0ohcvPPCqX53NCJuq9XCiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY5dk+51XedxkkaGTamumqlfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDkyMjJkNC05NTkwLTQwNTAtOWNhMC03ZmI3ZDU2NDIxYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtPbEaZQ2NHBhPs+p8C9bE84TtGGDrsdlPQo75JlDjPAqi\np6ipcHSEZdndxvOOtKrxB8mseKbffL3zHpEhCz9ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURsIsdrtA1WE+hVpyBaDmlBRK\nzsswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCI464tMXDL+jcF/TSFqEhUwG41fVEVd+QtpQOOKjkLECIHWc2qD0n6Mz\n9AVbRQqBK0TdidvxDsp/1/oEqHqIuADz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAdV1ONxI9XGVDaiGaaUOaigOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDM4MDZkMWQtZjVhOC00MGMwLTk0MTMtYWE5ZGQ4NjIxZjQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjM2ZWExN2UtMjI4Ny00\nNjkyLWJmZTEtMGE5NTI4YjdjOGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZdC4g6eUmwGTUM9fyPLoptXTPoGImqkNF8w4sIC1SQ7f0NahjsVj62TCGgG6vXfx\n0wLanpW4+4zfJ0ePzJJTyaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5C4xO57X5mz+qrnQ\nxEoBVD7P1HAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgH518c8f0ZmvQJmUp+QHCXEzjaaDqJzCiv4Riu3xDTcMCIGHC\nPbVXN/gnkHYkajxnr5YS3lTfMoNWjYmE/ucJcAIK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4004", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4004` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAfS0VMXeu7iP8PJshiTWSaGKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwOTUzYTc5LTg3MTYtNDliYi1iYjY5LTNiNTQ5M2Q4ZDVjNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA0YWQ0MTctMTA2\nMS00ZTIwLTg4YzktZDRkYjM5MGYzNTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJVxNnr48OSHP2RZDHfcgWlReef/YaleNlXT/xljMCHWPF2lt1Es8fAC1FeyD\n8Ugtyef2/PIUQr+xUgAEmFNrdKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvvNtmekz0NazGcAUyAU6tKkM+78wHwYDVR0j\nBBgwFoAUcx5b5/L3MJDYGUgTt+Lt7AedngowKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCqwT6U3yPq\n7+ihLdRz4F4aidy4VPPiXnwcn3XpYMnfhwIgY5W6QxRVJdpEH3ySjOGQ40KxRRCh\nXVmuI7mxs3ckTv0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWYCyyRb/Yaa7LEwxVg2PmQvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDk1M2E3OS04NzE2LTQ5YmItYmI2OS0zYjU0OTNkOGQ1YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeJgR4MrH2Dsbm20h7XmgBb9btUnAaQbPr+elBzQFOcc28\nOFBxQ3okWTA5r/XSh9cBT/btvj4819kInlRYHZWLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcx5b5/L3MJDYGUgTt+Lt7Aed\nngowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIge8iTwyZSulOXvUUvDHuwV4BN+fv2JLmu16WGNo7dPYECIQD2y7U9SVoi\nC/WoYs/KLGZ06H6Lc9smwVD7PnwjlOZY6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZlZ1d78lKlzXwSeDCZKQfAcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA0YWQ0MTctMTA2MS00ZTIwLTg4YzktZDRkYjM5MGYzNTNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2I5YWM3MjEtMjcyMC00\nMDU1LWIyNTctODJhNDYwNGVjZDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXZVKIeSls7NCmttC7vKtzY1Ze2pvXw+xJxOnyr2SiFA7n0mQfOGBLnXL7PA+9+hQ\nso2XoaEanqULSgYqATJ6NKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvvNtmekz0NazGcAU\nyAU6tKkM+78wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAN79Cuy1btMNa1A79rMtlekAcPiYOTSQp80assyxkdSRAiB7\nMc51a84nOphzxItWZjXnADxXtnf7YvuyTWes01DO/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4005", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4005` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcuIYDitrl3MD/DdyF5fd9bVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZDYzMzMzLWY3OTEtNDIxMC1iYWFjLTNlZjE0YWJiMWY5YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA2ZDVmYzgtZTY4\nNi00YWRlLWI4MDctOGU5ODkxZDIzODEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETX/X6eyq3lwEg4EbNa0/sXShnrUYgoM5FBbbsTl/wz+7kqDLR2Dy2jjkcVVH\nU8561s2iPP2AFWFxeClqPcExnqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHzlwi0l9BkFelq8A2CglwnBHp5UwHwYDVR0j\nBBgwFoAUOZ/XI5lDk0TeNVzP26P1OE5/mZkwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCICOcDbevF/Hw\nJvt8CE8Z6Q9sQxSDxOWA75atRk3bIKS2AiEAzY510heL8xlDdqewUwZCTUy0OiCj\nb/rVJHSlquNGniU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbXev7CZgDX57dAy0W3Z3Jb0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmQ2MzMzMy1mNzkxLTQyMTAtYmFhYy0zZWYxNGFiYjFmOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwLkXjaW5GKaDy2P5GS+c6wVjDNK/buLR/E55jr4bXmH46\n6KkazjM6RaqFyK9eT+awAGnae9zdZtPDGDi7LW3To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOZ/XI5lDk0TeNVzP26P1OE5/\nmZkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALltKohR8bJK3kLN7ZG3CZ3/Qpnx+zfbXFi9SQ2zKQBdAiBJ4nrBuRe9\nBv/uYLySxsMAxkxgZHpVMUMyoD+YlP6YOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAW4vyRbpki7XbCaeIHrYvbkpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA2ZDVmYzgtZTY4Ni00YWRlLWI4MDctOGU5ODkxZDIzODEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2E5N2E0ZjUtMzI3Ny00\nYjk3LWFjMTMtMDEzM2FjMTM1NTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZ25SD7cxn9nqfsLmFMXLogN/9vVvE4Ybos9lMnra8w8opIT+iPMYCfvMCHTiPk+B\n0P6ycowjo6Pi0fdNPohdyqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHzlwi0l9BkFelq8A\n2CglwnBHp5UwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOx2WafrYo7Ma9ZdlOnoOCHZzk2SM/xw/XJh/BKNaeL2AiB6\nrPqgNmrZanG5BVXYedHaZCyl+F9krpjHzdqK1ci7mA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4006", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4006` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAQo2iJjbVSiQwLg793xWWbjuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmMzNkOGU0LWFiOGEtNDkxNC1hMjc5LTljMzMwYjBmODU5YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM1YzBhMGUtZjk3\nOC00MGRiLTk2MWYtOWZkNWI5YzUyM2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu5zeIIg0/miMiWNMIk9tD9RnYm3DK7b0qNkRZLbqOX6+BUgveOq52LKIQkRi\nnB1Uk6Pzq1t+KbzH3cUiJv0JKqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUavdgSf9NxM9ovxQKT/MwiLtG9ccwHwYDVR0j\nBBgwFoAUvn0d8twLb+5nZWvIMig6d4hcNdgwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAk1fCoBRs\n8jsWNzZmVmPFJnWScOsTE4FZe2gU1ldWeq8CIHlsT6lL9rhpkr1SxgNKIBvZcFdX\nTkCNryk/UvdhmWeM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZMJmwhf6OZEfJZMNDQkH9R1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjMzZDhlNC1hYjhhLTQ5MTQtYTI3OS05YzMzMGIwZjg1OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATALWrOjqB98KhtW5SZyh+KCeTtEba/k6AVoBmQlgOKcHOG\nAt8YmXxSR71q0og79jqSiJUXR7X9GZZA27Bd0kIlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvn0d8twLb+5nZWvIMig6d4hc\nNdgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL4bH3/pLTE9G+r2B647rYGNqYKx3ezaGzOujLjxdTlAAiAVryQxvXw6\nOiiGe93S/uG3SRL0YlhTueMeoSKu/G/c3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAXnDhI5Upaliiz1nypRnW7l9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM1YzBhMGUtZjk3OC00MGRiLTk2MWYtOWZkNWI5YzUyM2M5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWJlNjNjYjUtMTI5OS00\nZGQ2LTkyOTMtZTc3YjQ4NzkwYTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1b/kSfDiPCtBFixejYxW1PW0JFVDo0hVp2ZwMuD7WaA1fMoxwq+NX4zt9EuBCx3S\nqApE7Lge8XL5uS7JE7zsVKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUavdgSf9NxM9ovxQK\nT/MwiLtG9ccwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgBlDPcaFGAKvG6HpvwJ0X4nSq853sdFTRstLt5U0T9T4CIB6J\nxugGc7sOO04kmFtuBhToZZgxYbX4CaZD//bEJfUX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4007", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4007` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQC3B3Jvu8nxkvp+26K9o3nnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NjcyNTdkLTU0Y2YtNDU0My04N2VlLWUzYjQ4MWJkZjk2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFiZTM2YjEtMTRh\nNC00OTAwLTg0OGMtMWRlNzkwMjgzMjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/usfqtrRet+Lr7VeZV8o2O83Eh6L+WiHoPlW8ya7Al3vRhBqLwV17Hq/kgkT\n600iX3o7+srKkNPO9/4OHYDm86OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2pDnZODcznorFPeeSha5EpBqZGIwHwYDVR0j\nBBgwFoAUncpFlg4kIbzqEODBpJ7GMe10mncwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiAC7aO4eLuC0EsKQiQOairRgdLQERkDt/llzUMQi5ayKAIhAOTWBfjFiblD\ndjNXaoas5gsy9OoKvdsWQwbvcSkNv/C9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAefWfy0G1a/UmIFblMXY/zOkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTY3MjU3ZC01NGNmLTQ1NDMtODdlZS1lM2I0ODFiZGY5NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnMAO37dZt3H/VG2QGaJgDqyqa+mZRmgMksuHp2BSglxms\nDebSD/c3g4k7/VOHQgvjGBup7pvQSDTHOlWMhTqfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUncpFlg4kIbzqEODBpJ7GMe10\nmncwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUBqURMilA67oEYw+wiW58UlgJIHTjXQYahd3lfWg/PACIQDYngjSRd9Y\nMghNABAdvyOmPwO86pkgXyKtQhdKQ+zjKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAU25lIuHSa1Se/XIDAFOsIOYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFiZTM2YjEtMTRhNC00OTAwLTg0OGMtMWRlNzkwMjgzMjAwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTE1YzEzNjgtNzY3My00\nOWRiLWJkYmEtNjEwZGE0YzllNjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJDOLDQYyjNdrAfZbVZkrxB/BGuUV9mo7gq0yWKchy/ETXociYyS80O+9ZFELclvz\n8iT4kyZz3B62ehk4InvPCKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2pDnZODcznorFPee\nSha5EpBqZGIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJiO8x8LVUbJ+dzkrun0HH35EdcFRBffDqC9Zbl9TJzGAiEA\n7xXs5v8fzv3pAF5OsTFzwtFGpuTpJRH9oh9sDstA1oU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4008", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4008` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISARIZKlF3dc/Y70/+oLYvsBpwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3OTFiZTIwLWVlNzktNDkxNS05YmNjLTM4YThlNjc1ZGUzMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA4Zjg1NmItNjY1\nOC00MzNjLTk0YTEtZGY4ZmU0NjllYWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd/IuOsTKHd4pJJvTG4fhER1dtAchAnZ609NDL1xRH/GPXxxpQeRVLqjIVzTu\nD+ynUb7gEUKlkm+60JmoNhh5kqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFABFtOt3LPYyBms/XYE/rL2EQDcwHwYDVR0j\nBBgwFoAUnAZVRmYuy2uANI6rsoc07uHwgAEwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiApFkdBEnd8LKS4lGITQfc8X5mD3WWTY5DMUO3JiDyyJgIhAMgo8GRhYU+d\nI5BMYnHHcKOIIJAkxQ6hlmL3C4ISO9eQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfZ6pUc7O95LfQYojOb2kGk4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzkxYmUyMC1lZTc5LTQ5MTUtOWJjYy0zOGE4ZTY3NWRlMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjUJNGUPb3z1gOilucBikxtbXrKQ+ioKMm4GkHrGMHUQ5j\nVYvaMLx4GQn4i1KHPHVQnKjxs1oJZ30nvHzwhN/Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnAZVRmYuy2uANI6rsoc07uHw\ngAEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaUB/dJnnjCeA10vXIscyDOTCWZvrYL1yOnyoHdWgREQCIQDrUljDm8LE\ndVN4KyoKcl1EMAVrFPluBcTPIT7l02Z5vA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAc1UrQ7Y/JMDOtclcMEYmVOkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA4Zjg1NmItNjY1OC00MzNjLTk0YTEtZGY4ZmU0NjllYWQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDExMWFhZGEtOGU5YS00\nOGMxLWE3ZGUtNmJmNjhlZjg2ODljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nK7wLB4JlnCK6qpR75igT2kwEIDL5hE+nCFW6CXD67OxWb6olgsuuMJViTIjlXt1l\neFb/O7xlg5a96QMylxOMuaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFABFtOt3LPYyBms/\nXYE/rL2EQDcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgHCYiAcru9IKzC/JwR3zVESFS1Zdt3Dpox8Dd2UZBDnICIQC1\ndh4APnPQ5111j+54H9RytqgVb0J1/KW3qyQeXDsscw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4009", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4009` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAVlTaCa/uA9LbYGKZ/kvUEZ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1YTQxNDljLThkYmYtNGI4YS1iZTY5LTkxMDBhZDVhMDgwMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYyYjhiNzgtNmJi\nNC00OGM1LTk1NzItM2ZhYjQ5ZDdmNmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOYbsNkJHrFx5d6GT/Gr1rKGVnWJacpjDV2yJfoxyrcWJrT2wQrfnDAqW65co\nDkE0JqFwQO3mPSVG4MwoIPaA3KOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ34hyRhlRfjkK7HVL+fuXcnXNiQwHwYDVR0j\nBBgwFoAU7rYTpYpBg4FkgEactE/EK3lcABowMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAS\n4HSOZlPtG7Niznn+f1sisT099hZ+McghvuAhoTZz4QIgUE1oygwBTGAXt4+FqvgA\nusBXhB6CSqfaujdXrZPlVa8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASGdyFxPnRjKrrjEACfSFaf8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWE0MTQ5Yy04ZGJmLTRiOGEtYmU2OS05MTAwYWQ1YTA4MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvudzI3+mMQzIJtP/LbWXNrzsGc+CXa7arX/JmnySiH34x\nA4Iih+R1aZO7MWclDvZtVQEl+UFgR5fbDv1SEVILo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7rYTpYpBg4FkgEactE/EK3lc\nABowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcE3g6qCGmJBJddvf+DMBqpOrc1EwtWIgiRZMY7O4gGMCIQD42i4+z4EX\n+fT/6LCx09gHl5z6CM+xyEd1xOhIK+kKhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAdqFUo6ABa8UjGVsSf3E5pXIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYyYjhiNzgtNmJiNC00OGM1LTk1NzItM2ZhYjQ5ZDdmNmE3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDkzMDNhNjUtZGM3Ny00\nMTU4LTg2YzItNGEwNGFjYTc3OTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8lYlcUUe1YH66w10NCP63CHg+w+gNFK5p152u/lHU6LhtEsdmvI95CaWs+OnODFm\nGjC+nl58jsKscUEMTOkdJKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJ34hyRhlRfjkK7HV\nL+fuXcnXNiQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAMEnUsSfTiclgVYrs1LVIF6UpkgE/LT0KT+hVi3SlJVkAiEA\npnY6eyBbKBJsJxX3p/jtn11xfc2e5YurPOrCODWGXCI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4010", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4010` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAfKUMixkPtplUuxNoLzTNrLhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2NzVlMDdkLWIxNmEtNDk1MC1hMDA3LWJiMDdkZDJlMGNlZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhjNzYxOGYtYTc3\nNS00Yzk1LTgxMTMtMWFmMGU2Y2Y3MTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENWamlmdslhSzRHRkzsCzgg0KtkoFaf+oVh2BX2VYDg+zob7Ur03mjbDSSLfF\nuzX9FPloElPO36mJLMozdy/H6KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWCtXvovKAn2puKY4xl5ZYcyUEeYwHwYDVR0j\nBBgwFoAUAB1US9gVx+noxx4hzuFQgz6y3kwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA0HGI//SGPlSVvSHd1U2isA8ie7NrcIha75HzxpAqc70CIQCU\nIEu2iVEQzbMxjF6LAynNAp47RTjo2L7PXgqvRg8fHw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQDTAxyi/lfkd/MZIcu0B+5yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjc1ZTA3ZC1iMTZhLTQ5NTAtYTAwNy1iYjA3ZGQyZTBjZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATS5KbYT+wuyqDvKKTWthF6ZwRHOHQV0pbDFCWIz4JfW8/h\nd+cOsn7u7eLzLUHdb/8xs3D7SR/8TVfS54YDBwFEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAB1US9gVx+noxx4hzuFQgz6y\n3kwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbLQkFC3CKUxswGYCoO/P3K5rtucXzW9tSh/uCwkj9+QCIGHnrV+SKBdk\ninzUUm+tvbWYu5WMOGkazwvd+EZM/fdS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAVetHKWHNsIMG1yFz52Y3oqjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhjNzYxOGYtYTc3NS00Yzk1LTgxMTMtMWFmMGU2Y2Y3MTQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWQ4NTJkNWYtNWQ0OS00\nZThlLWJjOGMtODk1MjU5NWQwODU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\naWzQT04LAg0BJ4iW1f4pCgqgfrDt/UNEfyHOat5dcMGf04vT5aquGTpp6QJ3MURZ\nAYrAVB07bqMa6hQP6enY2qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWCtXvovKAn2puKY4\nxl5ZYcyUEeYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMXW6xnBBK/MQlndiMLu46Mp0rrjtHkWesKa6uMZU3cmAiA6\nkTTTo/WnE6/A1TogghYVcFdugDMMVQW5ytGYsN7wkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4011", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4011` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAaGgQ92gCXxlfsBSMT/WjO92MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYTQ3ZTQ0LTkwNWYtNDRhNS04OTEzLTM5MTU1OGYzNDllMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2JmZTc1YzQtZTVj\nMC00MzBhLWJjOTQtOGY4ZTZiMzE5ZGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQXK3AR5aosvCd/G580y7d5A6oGoctmLLA+e+q5hoyINaKtWBCXPzn6EaETDW\n86Muh/FPTP5xqvtp/IXmmOW7H6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIjDRqIboGcyH2/lNhlWbtmXg3tYwHwYDVR0j\nBBgwFoAUTkq3LsDVaD/ceZ7HabTIwqahboMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiAx5DHJUZFIr5ga2KOWeGTUKZo1FkUhu+3T0EQAG6QmzgIgRqRt\nhDpsnq87P47DOm6n4PQ7ZwdCbT4Xs3aeINB9G+4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWYGPrpJM6mtVs9NpDKjpcRQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmE0N2U0NC05MDVmLTQ0YTUtODkxMy0zOTE1NThmMzQ5ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvD8t8wiOCWk4mXXidOX0OZDSKQpJatKlCsLlT4gf7xYU7\nY6P2b3C5XGQ9yQuMEh595JAyX2pRzVOgUJAtm06Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTkq3LsDVaD/ceZ7HabTIwqah\nboMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOU+XnkmpDxioyKvadAo3bwJuAa+SD/FsGviF17a6cUSAiEA1frk1A06\ngQtuoYmOuTOQHLeulMEaQjq9B/b9PSZceKc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISARtWbXiEcFIa0TqxHMe/rgvyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2JmZTc1YzQtZTVjMC00MzBhLWJjOTQtOGY4ZTZiMzE5ZGYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDEzZGIzYWQtYWEyMC00\nNWQwLWI1NmEtZGFmNWE2Mjc5ZWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5rhmA7LJ2dLkvUIW/zY0/dY9ySUYE0qSVEgaySrBEyYfhECEEUfEBTlShSLi1g+8\n3k8MeDXMvVDUdw4cLq+N/6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIjDRqIboGcyH2/lN\nhlWbtmXg3tYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAI0aRmTJPCXAI0NPpWEbjyGwg6HrypQmdUImRq2C0QZfAiEA\n0umaoCvSQPEWOpIzBZ/8LJVblojmrpFVhW44yhUUvwI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4012", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4012` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASrSTCzJIi6A0f88PkR57Mm2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1NTVmMjZkLTIxZGYtNDE5Yy04NGY4LWU1Mjc4MDMwM2NkYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2IyNjE2N2MtMmU4\nZC00OTg5LWEzNDctODUwYmNiM2IyNDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFZpAvR6mjNjLrrm1Fhw+zlUlamYq214HZNbYab97xJjL5IklFe0vcUL1Nhf7\n+4iYPlGoghRIJHwQPF6LTLhGvqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdxKq4y4n3Iw5LXUwTzGN+8Th5nUwHwYDVR0j\nBBgwFoAUYM6dOMXpMYf5vKb7xkmKtdJ3aEIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAn/W4YoMxdwDJ\nWEPVthtpxRVnIDtZWeySEnzhLk5FuuACIBrkHvXXlH7Pj+SYXqZo0prBHz6g1p2y\nkn0SwURD2DeY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWrpd6t2BckplpdX8cglXDT1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTU1ZjI2ZC0yMWRmLTQxOWMtODRmOC1lNTI3ODAzMDNjZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZlIhfQu8ePqJlvVn6TJFKQdU9MekKwTOHKsBBNvZw8C+P\nHnzyvTiJbUiUmOEVII5yU0pvSfd0h9pQd0dO40sUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYM6dOMXpMYf5vKb7xkmKtdJ3\naEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKQuAtFp0/jOE78VkYJmf50WOp8jyaxeYxtWrZIeojfkAiByxM1PcM4t\nEo/H4dNgiuvlbXBiRO7Hm3Wy0QeFMV6TPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAUTiNcM97An+THmc/4cxAl9aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2IyNjE2N2MtMmU4ZC00OTg5LWEzNDctODUwYmNiM2IyNDE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGJmMzE4Y2QtNzliZi00\nODg5LTg3MTMtYjQ3ZDg3YTQ3NTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBToESYuTbLDExGqLYowXN3sSjOL+/+/K0HUvOHNY2mh1dIUsIdTkiP4BMPkypY81\nlO0dK3hvp+8hIW2T7xT4aKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdxKq4y4n3Iw5LXUw\nTzGN+8Th5nUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgVHCnPK06QGWgPXgunOo7h7jvlChy3jdWGGhm/KFiY2oCIQDa\nsj/SwOaVCPLnEzo7pEDqFGx392stZvZXqzXHKn5TAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4013", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4013` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARXLyPtP7Sq9XQUABRuSaalaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0M2Q5NTZjLTMzNGQtNDU0My1hYmM2LTJmOTQxNTEyNGU1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQ1ZjkxY2UtM2Nj\nNS00NzRlLTliYTUtZDU3MGUyZWYxNzhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERu2Sbxp5/ZP0TEIhWyQu9eaI8K6YrR0eoPCLy8uoeq3ra3HPRIUQl8o2B8l+\nmYt+zYcZVJ2sSEruVEOzbUYyO6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv6LHtX+1wZHj5j0TIy99koWkm6MwHwYDVR0j\nBBgwFoAUwQdCikuhmyIwNdyVzwslkXRPItwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCrqGfBt+rFyPIXdVHyvTX/Yg1E/DHew1z0ZxtiATT8WgIgER8LCwwQ78Sv\nwhGx+7fXkhZpxHH0YgvGFN33qLF7Cyc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc1HyVcvPNSfaI7ZLUKd+7O6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDNkOTU2Yy0zMzRkLTQ1NDMtYWJjNi0yZjk0MTUxMjRlNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFwsl1WBByQrALXRlx52e4tHb2ZaWpP13dowAlZdVXF+8V\nXOEkJOarpXgC5jcDgKAF+eo/ILonE84U8k0K0U1/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwQdCikuhmyIwNdyVzwslkXRP\nItwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbRBEJotvS0Z5CyYKuS3OUQGDvwipEwkp58tA6Hq5jdMCIQDVvM/UQVrA\neKjEz60PfUP23+CU2cYZvyxiUvEqilk7Mg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARehsHzIrP1530jK4qtKLE+hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQ1ZjkxY2UtM2NjNS00NzRlLTliYTUtZDU3MGUyZWYxNzhkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDRlN2MwMTUtMDAxOS00\nODg1LWJiMTgtY2VjZDY4N2RmMTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nypjukjh3G9I3VX9ScQuOvf0ywkQjX+/mmO6NBmKif60ZEoB2W41VwP1stBNwjSb9\n90w8cdf0fkU5jrkfNziZ6aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUv6LHtX+1wZHj5j0T\nIy99koWkm6MwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMvGIc1zq8vWUuJnWrUN0KgniPX4G65prR4eJzSCYHsxAiAg\n2ruFBVGiSSdzFiqgrzbKn2eAjgZPM5O2j73Dl6b5ew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4014", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4014` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAXG7skW3fU8tM3ee9aK4PwBDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyYTJiNTM3LWQ3MDQtNGU4Ni05YjE5LTNlMWRiMzVhZTQ5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RhYWYyN2ItYmIx\nMy00MDZhLThkM2MtZjY1YzBiZDFmZjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEirfzo3Bf/xlDw0F3CQRYKZiUP0G39pL+ssmDq3NdaKaVp5McXiZPTBkcf441\nIibXUk5XcQlLx3D9kxUzI7b7B6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi9rXtzbmbASBjwL39MVcXXJJMHIwHwYDVR0j\nBBgwFoAUB6/u36p9ed6pezl1bm5JIGBQ+HEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDx5MDm1rrpHuFyIerJOCTxRZDI0S7N//39zSsStRImHAiAeXcr2SlypxRwQ\nBYcT1UsL+uKMai7VCFrDs4UjH9DRKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW6WWH2AzPNDSQtcKKV7uO+aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmEyYjUzNy1kNzA0LTRlODYtOWIxOS0zZTFkYjM1YWU0OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfz4UcgzH4aoYqf7UWk5dEzRbakitUfUzK0gHaxbGugALr\nVujm5I59jBSjwF6fWpNV5O6LnlvdMekosxjQrhUBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB6/u36p9ed6pezl1bm5JIGBQ\n+HEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOKvK/r56HFZcfZ/8ORwAdR7d4EXa/iHfOqzM+zHDZYFAiBnM1EZXJyB\n4/iWoF57pFzlJTh2ccYuVyZ/bYkJ3AxrhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZpJnHFVnI/a/rzWkiMT9n8TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RhYWYyN2ItYmIxMy00MDZhLThkM2MtZjY1YzBiZDFmZjY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjdjYmJhMTMtMTkxOC00\nM2ExLWE1MTgtMjUwNzZiYmEzOThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nR6HamPP4u4fVJbaod6nu4JS68sTFtkXrni1+FG4oJ6D4AYTbixe1BZquFWFsY1jH\nL3FCQprSF7ei9nDWXZl7TaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUi9rXtzbmbASBjwL3\n9MVcXXJJMHIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIga+PjlKWsfcEr4yDbhpTq34jjMpWWZa11G9wHqpuGcUMCIFLF\nMs9WF5onmYWGNmVFUHn/riGG5T+MGDYMWAvzXRyz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4015", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4015` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAX1hgUpXkmAWVD+Fq463c6TXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ODYzZjc0LWUzYzctNGE3NS1hM2Y5LTYwMWU2MTU1MjZhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZkZjEwMTgtYWZm\nNi00NjcxLWI1OWYtY2MyNWIzOTNiZTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMGvGiY/lZWRbrtYnKlgcIQPYW5FmIfhpudBVmCwLNjOiDJtZDOle87F6w5DW\nNzIqtId8NWOKifZWbJzvhZ3txKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU60OItiZYZhSR8WVpqjmYoPravmUwHwYDVR0j\nBBgwFoAUV288zeNxuofP2qYkJivVm/NolIkwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiB3Z4As73Aoyt0eFs72Stc8muQTZ4UfpBDdN80d5VPq0gIgMsAhXBvATCVM\nP6XTI/M2o00PliLl3Wau5VmUlEcbP04=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX6pxVFLA0a8BpE63VpuJuoOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTg2M2Y3NC1lM2M3LTRhNzUtYTNmOS02MDFlNjE1NTI2YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUXH+H2qZ1A50Loih1LP3rFl5VR4RtBZynNT69aZd7SHf5\nUxelZbZAd5S8cx4SNvyKTf28FBRkEBmNPFLRAP4yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV288zeNxuofP2qYkJivVm/No\nlIkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRfnYYE1Zm9gIL0AI8dM8JcFq2lg2Ex/M5sDa82Mi2eYCIC30pX0Z0iLD\nb4f0B+28DzIaMyQdPY7hrZoKr21tWC8D\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAfslOSVODAqX/ZqWF9b+KG55MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZkZjEwMTgtYWZmNi00NjcxLWI1OWYtY2MyNWIzOTNiZTZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWQ3NDNhOTgtNzkzNS00\nNjQ5LWE3NTItZjQ0MTE0MDMxY2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niVx171D6GwQZ1Tnw1zPFhntCvHbKNKstqloFZ+KS7dV2DycFDVQ3X423UbLKHepe\nZiakwHKsAcrkw9+9TnWJl6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU60OItiZYZhSR8WVp\nqjmYoPravmUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMEyPmYNlejSnLyDRsJ8EU4p4s9NdkOjciF73m/BUQcFAiBj\n9Vnj0rgKeTxag65mKd37QGzav2AA9UIww8Y2Xyz9gQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4016", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4016` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAeAVeP+BE3jwUS1I1l2yvaG/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMzMyY2Q1LTc5MzItNGUyZC1iMWZmLWUyNTA4MWFlYzgwNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc2YjRlZTctZmZm\nYi00YmNjLTg5Y2UtZGY4OWFiOGZmNWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwBKq5rlmSUHyJB0+5+mnheMAYr3H9GzSBKAHMcox3mh4KF046iLtoiRGAz77\n0GeuQsdP06nJPzuPR7O3YjftT6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfiV90zXZKXXF87TzDceS+xPGn5cwHwYDVR0j\nBBgwFoAUAjhlf3XpCDXoWA+O2XFcQvwa7okwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiA4uEik5TLUoU/v4+zulOZAJ/qxaPpI6/5XhQQgv/zk\n6QIhAMm5LBmJrdjyYMNVSPuRGZaGtNpUjJemB/8aA6QJAkSI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARaRAnaH2mSadxssMPlBhGIFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjMzMmNkNS03OTMyLTRlMmQtYjFmZi1lMjUwODFhZWM4MDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzqamibxFMzU3Hws/Nk/XbpgkrYWmpXnao2s/1yLJEbbh4\npADpVY1sMMxTkogQ+8uVSe5cEfDTi2AzVt03PNgJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAjhlf3XpCDXoWA+O2XFcQvwa\n7okwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgapFohRGWWEOVagXALh4EtmVrT9vHiuOaoyBEH6BN4BQCIQDztFVO35Zo\nb6sdrpvy5e24JzIxHQSl2z+WsykKmeuihw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQ7gE12dLc0jFXRA1MTDGLrkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc2YjRlZTctZmZmYi00YmNjLTg5Y2UtZGY4OWFiOGZmNWYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDVjMDY3YWYtYmVmZi00\nMjZmLTlkMjctNDAxOWQ4YTRkMzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMa0adyOf2U7v/oisHFdR3D/ph/t/bXm4Rh1eRdMiWs+LmdJz06YMmjuMj42MkiLz\nEHthtTeg445rotrIgnn3oqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfiV90zXZKXXF87Tz\nDceS+xPGn5cwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgQGzqeOdBv3i3OjAtOM7bQ9Anvcp5Cyz+cWrwZmoEp/MCIQCy\nLAj3+LpFV8ZjTp/BvhEbbrwK0SLa27ujmfbCXRDxuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4017", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4017` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAcMWDXMTH4PXi/a51jTQPm+kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkZmRiZmE2LTllMzAtNDVkYy05MDgyLTMwMjkxN2E3MTk2NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjViNmU1MTQtMDQy\nYy00ZTEwLWE3YzItYmU1Y2NhNjgxZDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESY43phXV3iQXvUVMspQaIY9i3utQpzmre0cUvlmi9e59kH2azS+bGyHsQPDN\nPi0a+ThHTT1SNuHC55IpSDcE0KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtLZ+KHVzoZAZ4VRZGIRAV6EFz4QwHwYDVR0j\nBBgwFoAUS/K8whY0Z+I9zYfki0I5I+E5rK0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiEAgeQoOC6hhuLT3BvdGUiojESLPf92sAT2hOPsrQHn\nYBoCH0y7Mp1vG2gSJUqtiQ7U5ZRbWGG7khOEhydOCCQw9lc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeHmqI65xazGPvSJKDnNkMFnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGZkYmZhNi05ZTMwLTQ1ZGMtOTA4Mi0zMDI5MTdhNzE5NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7+7tan7HPUIEStae49aC4nhyiw6c9Zq0luvQGtyZCGXPS\nzMxMEG42be+rKdLRoaUvUWg0MjJcojHBFcMQ0CTKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS/K8whY0Z+I9zYfki0I5I+E5\nrK0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV2qIONg232jkGCNvjKAgwtt6ymaLp4bOBaC8W2mDwW4CID9GXXZIX+Gp\nmW6otkQRv9ChiY3uyyVCe4JBZ9PYyuFu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAaIcMiVnGto5TisVhlvh7mG9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjViNmU1MTQtMDQyYy00ZTEwLWE3YzItYmU1Y2NhNjgxZDhiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjI3M2M5YjktOTFhZS00\nNzIxLWI1MjAtMmVkMjg1MWM5MWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+uacUYM+vUse/MpFNzmWHBBq3WBRqiF2zPVntNzxmg6JJzlNnt3otP41DDg4fgfW\nvOw3ukAOP9dauwo3sGrJ7qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtLZ+KHVzoZAZ4VRZ\nGIRAV6EFz4QwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgHVq9hEpypNG7uKuQ77ZUQuS8Q0+h7O/jDTNABsxpOi4CIHrp\ncDEWVrmLisIg1Xp3liUp+NcD/S9mVbDejRWTmbBP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4018", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4018` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARHEJkXiDl1ZXgy9Rw0Y60dwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxNTk4M2E0LWUzMzctNDgzZi05NGZiLTFkMjUwYzU5MzVjZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE0MWZlMTUtMDc4\nZS00ZGVmLTk3M2ItNTk2MzQ3ZWVmZTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENHylKyYAy5pvy4T42opLRsT7738gC9i3jTNUxOG8ENXj5mvD2JvHTBl+I/ap\nxDDCsIbBXLLkU357kvR9Qt3q2aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0N/AyD7BNn2mP5Fr2ZsYq+kk600wHwYDVR0j\nBBgwFoAUIO6ihbey+dWuwXN+WPZdukd8k3gwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAwdAKeBMbq2yfuyy2TbsTBmchlxJfpILmU8g2e59LZYUCIFvq\nbCf5NeayLbEKE5b3ik8CAJqQN4YymLu37ob/haoA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATuON7DAbhsYKWseVGvvGnGHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTU5ODNhNC1lMzM3LTQ4M2YtOTRmYi0xZDI1MGM1OTM1Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq4hEqwX/qu/3JL+8eaIyUhS3Re09zNv3ipLaPEAl/BF0F\n/QzbOBpMzskceYQN+LfASYacbKvaNj8ngd6hQxvVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIO6ihbey+dWuwXN+WPZdukd8\nk3gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ2/jQE4j+YTefYk9KG8msNqQNSHyi/VPLv2SoGlK+ChAiEAk/EgIYfN\nce9CHwtLlvxTcNxKvEGPGKdFvFvqvxPE85o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISARxRrbwlCSHznBN5mqrxHXq7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE0MWZlMTUtMDc4ZS00ZGVmLTk3M2ItNTk2MzQ3ZWVmZTZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzgyN2RkNmEtYmYyZi00\nYWEzLWJjMTYtNzE5ZGFhMzE0MWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nG9+gp4hv4rSxyhrJUbf3PgojXV8vz1sbXnYtQglfYiiydMlolcoetO9L0sOKgMCl\nPsz/MXm1TQhWByfRHG6eRaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0N/AyD7BNn2mP5Fr\n2ZsYq+kk600wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJp7BuPxW5X9zYxN7aZK+RC6XzAd13uF0xTM43E7LEtkAiEA\n9DK0NkfYF28byOCCaimV8b6pYLtGJUv5jSU5UUJA4bo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4019", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4019` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbFM4LDzKJyQWtlwt+Wd0ybYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2YzlkYzRiLTlhNTAtNGQ4OC1hMmM0LTUxYTA0ZmMxODc4NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGMyMDEzMmYtZTdh\nYy00MGQzLTkzMGUtMTU5ODRlNGY2ZDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc7XC4nK5qEQMws6SZVAdhnrCIrAmVbIHpzpqwbdhAKyDL8rlmYUXrnTNf4vJ\nma+HzoAAdSaY6Xir5zC4/6FNqaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpBsFWRNaQaYwwqeDQGlMeTi+yTEwHwYDVR0j\nBBgwFoAU0hodJBa93BSbZbGfl/QW1VtR61wwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA9YMJM04Eph0ugn9s6qSr+I1iXRhOYK4Z\nT/IeZL3uyQsCIAfG8OP9+ElodYj7Zf1qb4LMwOsP7hgFsOfSzsXDhhRE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWDfNImudIe1vKafgrmqURV4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmM5ZGM0Yi05YTUwLTRkODgtYTJjNC01MWEwNGZjMTg3ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8jZjxcyWuBesNmsq7jsgp0qGsOExrmLQjL8PX8TC8hSSg\n+WSXvOrZaFXliHtPdlHYS6/8a17HThc58zlYTI3yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0hodJBa93BSbZbGfl/QW1VtR\n61wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ2quXyyel02/tgiLTnOimBygG21Zxp5N2791//Ao4R4CIBA7I20oa+GG\n4wKg6/7fQwoabAMC9ZSHIwE8jgiNVArN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdpCJCM9WmHFLSVH5ReF2wg6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGMyMDEzMmYtZTdhYy00MGQzLTkzMGUtMTU5ODRlNGY2ZDkyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzQ4YjBkNWEtNGJhMy00\nYjJkLWI5MjMtMDFlY2JhNmVkNmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nU7Bbn0QTpvfoeo9Pu9tMWaFurFVUxo7pAptfETnyoZJeX/JkuDtd/YjuhRWqTUDw\nrMP+FJloeRfN4lKRhlhNgaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpBsFWRNaQaYwwqeD\nQGlMeTi+yTEwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAPqQ1XQVnA2Iq4oOdJjjfRPNkQOT8SWxelHkSwtyZy+tAiA7\nhLPmEZUTjOgv8oDxAM1zCD7oLuA+hsalG96UPKCrKg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4020", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4020` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAXQaeK4fXEi9MmqyfbvTTZ1RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2MWMyM2I2LWFmOTMtNDBmNi04YWJiLWY4NmMzYmE3Zjk3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQwYmI0MzUtOWI2\nYi00ZjAwLThjN2EtZjAzNzg3Mzc3ZWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECMpR9StJiUuyqurIcrShs4zSh5QYYc6h446IgQy1LIg1AeYAWOW1jGkS2P37\nu+uemQf/8r75QPCNvGw8jh70cqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGDI9UBwHNt9oZT9ZoFkfAStSMMIwHwYDVR0j\nBBgwFoAUE6JATxzxtA6JsHMeAqAre2MkACYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAj1iqY8WF7tQypZTXl+Tp8ePMBeHTmBV4\nMBQyQcgU3c0CIQC8pGmCgmIkddS6EeIBmPpFn8YkZ1iZhIyb4wqhFnLzXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX9ArJGKOkihnqkCIJl53IKIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjFjMjNiNi1hZjkzLTQwZjYtOGFiYi1mODZjM2JhN2Y5NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQH/4u3NGHnGsMzLtbq05qpVKi7jvBsS5OOtmU3NG7F0WyC\n56C/S87aljgwBmEPj65pa61HoBV53n6IqWRPmykZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE6JATxzxtA6JsHMeAqAre2Mk\nACYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgServn+I1nnUyqNYNI08D/oqWDx2VnKUaURy6BPv/M24CIAOHif12wdd+\nlhEXVBncvrMhLESNfcQXeT1tcJspsYw3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAcm+Vqepc3yJaV/A1csvD5CqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQwYmI0MzUtOWI2Yi00ZjAwLThjN2EtZjAzNzg3Mzc3ZWU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzU3NTZjOTktMmIwNy00\nOGY5LWEwZGYtMWI1MzZmZThmNWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXdv6vSv20kgZMYILA0+GzI2soyqN/eesbVTRmmNQCgvTECCC7fdKxrOZohP/DoJd\nfpdcf2aqMUk5NMplgi7j96N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGDI9UBwHNt9oZT9Z\noFkfAStSMMIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJOMplOoP7pXjm6oYBSSyiBV2HuapwhK3Hqn5uJUHkqIAiAM\n2Bt8pVSlzM/lv+db4NAsqlyokSbkk4dcUupSYM4pGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4021", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4021` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWNZ0Wh9unNJ1Jz+3V9dkONhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhN2VkMzY3LWUyOWUtNGZiYS1iYWFjLTI2YjI5ODA5NmYyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E2ZjQyZWMtOTg4\nZC00Y2MwLWFhYTctMDNjNWQyMjA0MDUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELGR8TECk+ZreCYQVku6ApMQo+dBktv0GKiNuWADqrejgm6tNcWJWTmDyxAVw\nZNK7L+dahuswPcwmjZp58LTi/KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkvM1xrJx4Skl8ghBwBtLkJuNiQAwHwYDVR0j\nBBgwFoAUS0+BvFA2tRt45VNhsc0AYU0N1HIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAZWXP9c6L9NALQ\nkxQjk7eL9pbqMUhfjP31bNY4DJuTPgIhAPYfk7EXgSO7oUDaG1XKCzS8mwXi8TYo\nwYsEs7fetC1V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARHF3wRZp/mEeKcH30ZUedaBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTdlZDM2Ny1lMjllLTRmYmEtYmFhYy0yNmIyOTgwOTZmMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFyY2awrS0HQZrzSJWr1PMfHTP0Pj/CkRwq4W3Bh7csb0i\nNbBGjSprU8hC9WW19AenjzzEFEhsTmeTHL2o4FRMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS0+BvFA2tRt45VNhsc0AYU0N\n1HIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALzwO2mAAzX7MuSKAiEFNnZh1KSlvveET5yC0yhOJOyZAiEAxjFu9uOL\n+r4iNwq+lNLCzwQeKH3XXFlT8FDr2U2+kUc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQ1tHgVnTshYxNzHdYByLx7PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E2ZjQyZWMtOTg4ZC00Y2MwLWFhYTctMDNjNWQyMjA0MDUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGEzNDQ1MWUtZWExOC00\nYTZjLWFlMTEtOWEwMDBmMGYyNjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlVjm9Gl0muwyrteKmKJAhtsfRSvJtfQUGcM8drsrfoYDZDe71E5j4KPWLyEIwrKj\nluijzlVpVh+6T/0t5z5q6qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkvM1xrJx4Skl8ghB\nwBtLkJuNiQAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgXWCv/GM60REidjtlwpNx9hOcW0APMU4P2hvlR5dR0NwCIQDQ\n8CifGhw5i096PktSXOPUhKN7sUAjc3nkSKEju5eGqQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4022", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4022` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVmRsW703kiQPyTr/7SoY1kgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNjA4ZTBkLTExNTAtNGFhOC1iYTI0LTkyMDdhYWY2ODdmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNjNDQyOTgtY2Ri\nNi00M2E2LTg0OTMtMmMzMzc5NzliZTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDx8aSoM7oHAcADAHuVHOTy4fibCj4y8CFrBZnHFdw/BwOOxznf1m34c0CrsB\nu3rmmWZs/5zZofirklbb5fpq5aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5u4OW/YfLuBrrJ6PV7zcXT+o9PYwHwYDVR0j\nBBgwFoAUCJLH8WiTLivgeqCDtELXKYE0kv0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDsODYzc3+m7whN++GPMdS22DJBcboBSic+18GBz1cq9gIgFz3EhaI65m3s\nGQ4hltGqkWmI9tbVbkeTmuCz1tyro9A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASrfdPh3m+VXQtz3MXvhkkE0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzYwOGUwZC0xMTUwLTRhYTgtYmEyNC05MjA3YWFmNjg3ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvGpWFRSiVnYSoseeqvh8Aezw3GAmaFNsBI4JOMsJiDqRi\nR/+IObFwAUCHCvvCrkUi8V1nb1dFGnG7Tr+6RXHao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCJLH8WiTLivgeqCDtELXKYE0\nkv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI0vGlK8ianHCTM1O4uwymWZU2H+Hn9EmpekKfrGotM1AiA/wBQFMwgD\nhyDUlWHRWGoHkyZhHFMGhxk3VLqErEL2TA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAcxw8Ot3wZ5hxw0u+M9ApOw0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNjNDQyOTgtY2RiNi00M2E2LTg0OTMtMmMzMzc5NzliZTY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzI2NTliZGUtYjhlNC00\nNDVlLThjOTUtY2Q2M2JlMGY3MmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nw+NSuUBFKNs23nKwuYT1D2TaNIUBiBaA6N2aQM9m+7yv2d/wx1d707dUjQV0kwvG\nZRX4FbcYrGjMljYNF2zIj6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5u4OW/YfLuBrrJ6P\nV7zcXT+o9PYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgUP95ulI3BhT6gnpeizLaBY3jn4/T0SYmG4Kxdd7pUC4CIQCP\nN+C6XXihqfO/A1RgYN/AWTiWCGFbTjxCGGiULAcPzw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4023", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4023` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQv3CpfZbe5VdNu6e6POdAtuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkOWFmODNlLWIyYWQtNGI1Yi1hODE0LTdmOGMxMmRjM2MxNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjliMzJmYjYtZDEz\nZi00MmFjLTgxMTEtMzdjYTM3ZGYzOGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj0WNWnR2dlFE9n09Iw0QDEb60YPP0mE6Mhv6eNjsioTDuYkZtW85jkkn6a2i\n1qxzvgd1fPQzvqjeggBV7kXVbaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq8+ivANLa0YBeAc8MFdxIhMY8BgwHwYDVR0j\nBBgwFoAUZX1+KknUMbG0DWV2Nwl7qo1RPsMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFoWfoky2EvdNeXXv15yDLng8eA81dcsPeabPB95fB7+AiEAxFTgSHCzYnFh\n3tp6T6ZLB+6qCcSwgHB7ovgpbl9Gi88=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATmgtlJBob36GkB6kPE80zMBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDlhZjgzZS1iMmFkLTRiNWItYTgxNC03ZjhjMTJkYzNjMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUc2lmePqB+16HUEoGHK3p3gl6ZWMEwrn+H5eSxnt/5zTf\n199ZPT3w7dOD/Q0XbYsa6T6NOnPQIU2HuS0XNG3Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZX1+KknUMbG0DWV2Nwl7qo1R\nPsMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANtCUw/A9ROWVtTklYTNb3WYY/LfLrVUSTZd1nSp2reGAiEAhRuyvVZz\nDi4tr4OvxcQEFjv24r8Dct6e7gKZ/uq7Fyw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAeKBiCnQ7I7yUJhqpEn1Z8hMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjliMzJmYjYtZDEzZi00MmFjLTgxMTEtMzdjYTM3ZGYzOGZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTQ3OWY0ZGYtMDRiZC00\nNzQzLThlNDctOWNmNzRiYWNlYTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVyuuGJxysVVjWIwfk+dY+Rd5o5lzPxHV0lKZsi6RldT/tf6pXPWyBLXzH0xtQzxJ\nls31ZY/M/iT5Akzhbnr/HKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUq8+ivANLa0YBeAc8\nMFdxIhMY8BgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgbAeZrotckYs37DZ3nutdyz/03bSV4KsKqE0ugn4fKm8CIQCT\nuUI/60kOctsvk3L7Dtagf50S9ubuV3IiAq4XEziK0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4024", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4024` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAcpzowzoTHzQ6sIp4kfG8jHZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzNjkzOTAxLWFhM2MtNDA0MS1hNWNlLTQ3MWY5Yzg0ZjViMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjgyYzcwMzAtOTBi\nYi00MTZmLTk0ZTYtZTViODVmMmZiMjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYpkl50zSU2SZQfWaD25nUOpAr4Xu7BqpGdBfrviTdhiD1DWr14xGHxA4OIEn\nhM0uP4nIRbRLHxP8oy8ecA7WMKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqnp7HIT0NPMz0O/I2gSYqCsHG/wwHwYDVR0j\nBBgwFoAUrGrz+TZLX6J4pDC5TtDqXtBxyTYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiA1kaoSTTskzsTW7bo0en6XNSREWdBJ8W0fZAmopjqfnQIhAOKK8DyWjBE/\nWi2sBlhQ/W1Dde+QmnYo5ZdQfJPCgLk/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcCbVf4d+0m/ztt2NYMccxTNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzY5MzkwMS1hYTNjLTQwNDEtYTVjZS00NzFmOWM4NGY1YjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1hSYmmLBzb5vlsrMRV8Nqjzc1OegYSfzPI8JaSc7ubnH6\nkN1mtpn/1uy4pxBHWVq5FachqCXxyi1IEt8gOUgEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrGrz+TZLX6J4pDC5TtDqXtBx\nyTYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKaKEWv8OBWLuocnVlg4fJ0XOVVdvN+RwCxXP08ya4ytAiAGR3kz9XVM\nOJC0ZqnP3edJ+4mle/94ACzEkViRh7qlHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAUH6s5/97wiPU3fXmDiVsXaiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjgyYzcwMzAtOTBiYi00MTZmLTk0ZTYtZTViODVmMmZiMjZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2MwZWU4YmMtNTQzYi00\nZWFjLWE5N2QtMDlhNzY5ZTNiZTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJ+y54iQD+5ByORcRD4TuFGQJobBxdjuwiXn4gEGc69eAxQa/3SGZls21RVurTuXn\nAjZiSnUrley7ZR3FTQ6jR6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqnp7HIT0NPMz0O/I\n2gSYqCsHG/wwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgASfVlypmJB928qd5nzhsYvhGAVG2gzW5gIwrjINbuWcCIQDx\n5zeKa0AsMKVFgmkAuLI98kfeucrePyJa29jesSV3RA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4025", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4025` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAdzlh/6vlLqAKsp5KOaP/gMVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxZmI2OGQwLTlmYTQtNDkzYS1iOTJhLWRiOTM1NTljYWI2NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZiNTc5MDEtZjQ5\nNS00MDUwLTk4ZjgtYjgzZWNiZWY2OGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEztVnPOubMfY9oMxmjJl0snKVk9HWhuHSNrUteOdkS8kWG94EnvrMzmMeSRyR\nzsnxt0IvE3WKM7XIK8J/j6ESlaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Ceg2aLMrGWEUY+ARh/SXuIQ6eMwHwYDVR0j\nBBgwFoAUGOjMKnR4wwjCvryBeMnSP+Z39ZowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA+G7sj+wfTU/wqww1A8wqj0QSNrJBGPKhaV7WU4Fr\nP6sCIHAax6Frw10mKuWqqsCk2xYVxH9gBQXM30N0snYRsO/7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAegpnYykKishPCbYtEMWlLp/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWZiNjhkMC05ZmE0LTQ5M2EtYjkyYS1kYjkzNTU5Y2FiNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhKGhWPKxWb5ytnSzKAFHJGmge3AQe2es2p1MgRCf3zH5c\nAXJl4B3EUNCHeJGB9f+TSzJPjEuoLEYOxJ1AIS56o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGOjMKnR4wwjCvryBeMnSP+Z3\n9ZowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXNB78XHmt1ierjB3PwQJDBnX3IhAO+PAwJ4jqZ4j3nECIQD/5Cr7r64E\nf5CO2H5UUf0EY5ZyW9fEJVNBJmWcZdS53w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAYSm3j7xJgl95qq89XdrMdv8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZiNTc5MDEtZjQ5NS00MDUwLTk4ZjgtYjgzZWNiZWY2OGE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGU0ZGFmMjYtODlkOC00\nNDQ4LWFjZjAtYzgxN2NiODAzMWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSveurOxq7D8CZXvs1+WmtrRLslMEhscUpqnkLuJDb1MGSbIVTh0fhfQjBhe7ySLW\nqT/pGKBR/P2UgljFbR0EdqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5Ceg2aLMrGWEUY+A\nRh/SXuIQ6eMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAM5mVgKiFWalKVZq8dZrwsPLza0wzhK2s2nnsYy/ADcrAiEA\npmxdoZPdcMIT1jZTsW0uFHweag+kiSHLsVMKI/6G7Rg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4026", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4026` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYn2OUM9KwgjCgdbV0UVwO49MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlZWM3MTFlLTM1YmYtNDQ2ZC1hNjk4LWM5MjU2MWIyYTA5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJmNmJhOGYtZDIw\nZS00ZmYwLTllYTQtMzNiMTdlMTAzMWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9eDy8qX90bejc5O464zXj17Il3S7OY0oNZUuptzU7tt1NIp3KdFp4czJ9OLf\nEuFGaM9cmgZI7fkuxfHMQqqqv6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5eFzPJA5rYeDv7mBB0GO22NTf0UwHwYDVR0j\nBBgwFoAU4XDOo7rDVpGtscbX9OV9aC3l4S4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAudQgZcQI02HqigyMnwzUOYGvidDUeKo7Leb+cdQS\nz4sCIGWxjrjtaNdZnmGBJkcNVYCaWswHPMSCUt2QOzXBq5wl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUoGC1lDMZn9ngG9AaXZgd/CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWVjNzExZS0zNWJmLTQ0NmQtYTY5OC1jOTI1NjFiMmEwOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6pkoCeDgIyDfRvhPOUiBgXhxXMqJwmFr+DJiWUj2dgsoD\njdTulOiYC3IXRhxQm91vM1N7nZfvcbEV0yiKCcJpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4XDOo7rDVpGtscbX9OV9aC3l\n4S4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWqPlzFmqoUUOhICvpZnCkIm3D5svlRgkEBd8irLWqm8CIFPSiliA8bRh\nFwnXZdJsieke8NyKYos47+yedVApWugJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAVBq4t8DMcvxBIMqqqQ6QhkSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJmNmJhOGYtZDIwZS00ZmYwLTllYTQtMzNiMTdlMTAzMWY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjZhZDU1NjQtZGE5Ni00\nOGM5LTllMDktMWI1N2YxOWIxNTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9zOAxvFOsBsuMcbsrPglzTFbvQGnoSv0z9VjrQufUHZr7KwrM8D779ghV32QXdq8\nt8QVQiUPAtsWFAY8OCVNRaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5eFzPJA5rYeDv7mB\nB0GO22NTf0UwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgDEGG3YsFYxtC2erW9Q/G9jFKHWE0EKp9jTcO4HSt3yACIQDS\nlERYH7rW6Q7PRP7TCqDpruH3uX9/haerPlvEST9cYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4027", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4027` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAa3jpXn4HnibOO6TW1K1P9eYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxODZkOWQwLTM2NTgtNGM0Ny05MmJkLWM5NmMwZTE0OWIwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBmMjUyYTctNzBj\nMi00MGFkLWI0Y2EtMDQyMDRjMDlkMWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo3eQjph/eEwcWnC9Za+0NdyHeDLV5D7SnyhMz4m7CRhvNMvJxXNbSZk9jCKW\nz1dJdhZlIOdIxZDg5627aT1MdKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk2oo62wi7iEgpmLCN2kTlXfrSqIwHwYDVR0j\nBBgwFoAU7WUwzl7+rgLTv7KdCaqQ2HmPhMMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBaemFZxFz4XRbthHsjajdp9rIxeZEKrOsiJtgvsy2uvgIgaiPW\n35ZTWHV9aSYR4dHV9+f6RonDm/Y3KM3m9QVVx28=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfA/cskv5qr8OMZuiy3Kc9j/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTg2ZDlkMC0zNjU4LTRjNDctOTJiZC1jOTZjMGUxNDliMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWoxXihMsYgpODNzLW9ewBfEWynfupPlfq15HYKcIoKDiV\neVPou6enjyAFNPNoGXl5aA0IutE6rcPT4btV3OrCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7WUwzl7+rgLTv7KdCaqQ2HmP\nhMMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMc1+52TzAZsRGGvesnC/+78hEwquclHhtNcYFekzxxTAiAfvVFgDx6V\nMeEcMeHByLwB0D62GRgCgHSnHDh5knIy9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAQn5aQ5yi7YTRdN/bRCL7jepMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBmMjUyYTctNzBjMi00MGFkLWI0Y2EtMDQyMDRjMDlkMWZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTgwYWVlODAtYWJiNi00\nNjBlLWJiYTEtYTg3NDg2ZjdmZmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLsHuZXzArkICwdrR3sOzFI0v74u+gIoCnFxI/pKVCWg42ItOn+dvkkbEC47GLjxh\nyP1xHbnlSO8euJUAD5umjKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUk2oo62wi7iEgpmLC\nN2kTlXfrSqIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgDIpToU6hxFuIXrXphZGltUk9KKl72zmEQYc4sbmKCPwCIFHE\nKMoYAcMwF7NqrpZ5qefS6dBUZCXukeCJt23iBcKC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4028", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4028` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAe5UBArQsGQxLRjmviuOguGwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhYTZkZjk1LWFhYjgtNGViOS04YTYxLWU0ODEzMzkyZWYzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGUxYWE3OTEtZDIw\nOC00ZGRkLWExM2UtMjY4Zjc5YWFlODZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2n5uJ7Q++mDQnhjQiN6oIeb5QteGkr91v/9n02niZSenkzCBni+/snJ7xDLe\nl5JOAjizKuLj0O5ysOp74sjq2qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7+clWZpT5KDVym5pVLN+uW/UOYAwHwYDVR0j\nBBgwFoAUx+P4h2bqguF7EcwK0hotDNhP08EwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAg+gQ6mf5Hbz/GooWvpjpbfW+YSUL8ryg\nDRA/p+25+iECIBt1oc9S3EsE8V4Ti7bc4CzgdZ22dHNEdb+UIn9/oRhb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaNRKkggQ6graXlcMwbgpU5jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWE2ZGY5NS1hYWI4LTRlYjktOGE2MS1lNDgxMzM5MmVmMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZZd724CpXK3HiPF3W1EiXKxHQu22zA6rqk2nueCXxQpA2\n1sVbiSQhbY5pJGHMkCAcJPJ85uWwgk43CKtaIVV0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx+P4h2bqguF7EcwK0hotDNhP\n08EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0Q+RsNKv0I7KELmWWlnLV755y7qwjROLQYVrusJ73sAiBMpxyI4Y7T\nlAJzfRPFXSoAKR7rliPsHGkx3cXvnuEd5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZyp0Xu+zMjZfBBnCmnj8dKYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGUxYWE3OTEtZDIwOC00ZGRkLWExM2UtMjY4Zjc5YWFlODZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTVkNjE1NzMtZDE1MC00\nNzFjLWI2MjYtMjA3M2Y0ZGE2MzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nP8JoT9bGU1XBJ0GlvKBTvX4A2QbUkgpQ6pubOLLOvrtHYZ25p/5zIUyXNt3+chMO\n2GW8Q07Y2oASATnJc+lCDqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7+clWZpT5KDVym5p\nVLN+uW/UOYAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgPmFCAiVUJMhWIT/HJf3NX6mF6wlgz8YktbslgFUfMfICIFVa\nzPwywK0nNHhRz9zzpxHuHy09zajt+SLed4ZtRcpm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4029", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4029` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAcaA0Ywls7mHDJRPvusUSo9eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxNTg3NTdhLTc4MWQtNDE1Mi1iNTIxLWFhMjkwNmI2NzhjNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmMzOTgwNTAtMGJk\nNC00MDZiLWI0ZDktZWQzMzIzODk1MDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER2Y94kH7bwBd3RrQ961wSJYvOhq0dtuOTH682Uo2KjRyJZJzq+f9cVQiK7PT\nAbIezFwFKEFD40R8swuX8uZZ7qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIUhVq5ZMOSpUiscj/NxZKcWpizcwHwYDVR0j\nBBgwFoAUq4c0BaU/q5tz279D3y3p8MJonqswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA4jPi8Z5swLx5vXO3OFxPeFrrWVwkNZWz\n3lWrKU8B3YMCID5uwTl4uz0WizuFCRIsMNIqzh7s01F94RuY0BiBnl86\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdPeueyQmx3DyRYii/+EVxctMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTU4NzU3YS03ODFkLTQxNTItYjUyMS1hYTI5MDZiNjc4YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgw9D5g8Jc7aeMmlg8ZnNAONtX6kSMx+EAnF9YPs5pYk5Y\nfbVC1uYKa6jdE26cnnWPFytTOUubGncTtaHuEtw2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq4c0BaU/q5tz279D3y3p8MJo\nnqswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANfh9jTYnLG3oUPcaf5TycDyf44x7oxdM98PXnLw1hxeAiEAjyLScH1+\njEPgw57lsjcudGxchnsGOzWziCTU475wdV0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAW+0r8ZdFjuY3Oj+jNYqtc8aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmMzOTgwNTAtMGJkNC00MDZiLWI0ZDktZWQzMzIzODk1MDI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWYyNThiYjEtZTFmOC00\nNzAzLWEwOTctYzMzZmVhMzI4MzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3beqL2vEdcV0+D7QnBhNYrBfIHtc5qoX9fodrHA7EqWU8QniVR3EPSIoNA0441Wk\nO4ia0xfdAtuH6du+X+Ce/aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIUhVq5ZMOSpUiscj\n/NxZKcWpizcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAOfQUnIiSPbTTH32sNww+VFk0ykcORFgWIIrxeEN92mqAiEA\ngF9nKnwUHpn7P4xZ6h7wuTkblCcfwFaqgn0OScff8TM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4030", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4030` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATdQFUpScmNMWjCOKkL+7dtrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4YjE4OGEwLTg5OGYtNDQ1NC05MDUxLWEwZjBkMzU2ZmE1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZmY2QyZTgtMTNl\nYS00MDIxLWI3MDItZmI2NDcxYWRmM2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyb3jNrgEOdbVQYa5LyLrg7KQQh85QQKwV4O9BGf1xDO516u/LadFPO2vPDZH\n1RbUe2nEhDgSQbakG35CCQLUc6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyBWzsiwWbhk8LgbmYPfZoU3Zx94wHwYDVR0j\nBBgwFoAUaUniQzeIwOWHZxYNAG3o/6JCscMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC5bBgWeWiltLdNXCC5iSn0AY6n\nNLqtz8DLeITIlRCyIgIgZjHzL7r1Mg5xXASo0AhOQOedCiq6iaftxRPppOkp43w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWgK0W/41AcVHEyeG7NjedrKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGIxODhhMC04OThmLTQ0NTQtOTA1MS1hMGYwZDM1NmZhNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQU74oSjzEFWiU+bU5Q90CLWYqzK2xqFZOrRQcReUOryIam\nn5ePtBvuR9lQvYbuwze2FArap1wrFOk+1R4pIXO2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaUniQzeIwOWHZxYNAG3o/6JC\nscMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIevYvjCJxOAYkFylpC0WJJWG8+A/lDeYs66XJEab4oMCIDFzOBxR5ngy\n+PrZPlwGPgN+Q1K1T2Q6skwNATvEIeYr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdfFzgbTwxfH3QCz8wTf44MkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZmY2QyZTgtMTNlYS00MDIxLWI3MDItZmI2NDcxYWRmM2FlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODdhMTc5MWUtMTdiNi00\nMzg3LWI4OGYtZmJmYmE3OGY2ZmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEnShZDKAwqoc499TYj0h0F3HewOhxBEjAMJILVgcOsGRg+YD7nz8Yh3wWpBp1bn7\nCuF7gzSNnfdbj6GuvnZmjKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyBWzsiwWbhk8Lgbm\nYPfZoU3Zx94wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOlF7JbzDPYBwxsPCEMN9lFGxOyPhgnIqC0WRTcVnloEAiBQ\nC1aMEnvbgZrvbWUMr7vwnmUsLSTcDHPYle78rIXRrg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4031", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4031` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAUKxsjrqHFz+XUyR45852HXDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5NTI1OGNmLTIzZGUtNDk5ZS1iZTdmLWNmMzg5YmVlYjQ0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhiNDNlOTEtZGQ1\nOS00MGI2LWI4MGMtNzliOTFjNjk0NzBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGUYpr0Lo+Z0oCts8TVpjAxKW6C5ZjHIruivVpkjDyn4hIe0awLsQCLt3p2Vt\ndNyTHM/RjEptmwH6rNWwgd53pKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhCzheYU7ONb8EVWh4VQ9p1D9d0AwHwYDVR0j\nBBgwFoAUoRd8hHLoQK1zwNkhKB9MA92fhdAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgWdu0OHZC\nxbhU+AGPMEkzAOJEDgSnT4x3J62YycVyDwkCIQDvnzoYmmlulpaoW1OLfFraqKhR\n5rxNheC12WQ406MVQQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARvVdG+ibR8+SErX3wXg+U6cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTUyNThjZi0yM2RlLTQ5OWUtYmU3Zi1jZjM4OWJlZWI0NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8VfhfDpLI+66WtbwUrmuelCRHKvVaNkAxcpasTvBps/V0\nJZow/5ZMDcIGFI1U68k3VcPmpJoPlLV1KriT0z0Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoRd8hHLoQK1zwNkhKB9MA92f\nhdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYBCOwW9m/CXdo8MsVk5oe/4IpgMhSd4jcbV0Tgf6qdQCIQC33lW8dJ7g\nZYBT0a724/+8ay+S/+zTuMxhhlQIu5kspw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAeRC2LdIXPbQmvO3pf8eUzOwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhiNDNlOTEtZGQ1OS00MGI2LWI4MGMtNzliOTFjNjk0NzBiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjg3ODYwMDktODljYS00\nMzg4LWFiYTctYjdmYmI0N2RhMTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUPMJLmrewBEFzEeL+0li64npQCOsVz8QmZPTd50IUpKzGqoX/o1LQh+2cPg+i4tP\nE3mnGDo225AUXmvXdOs0pKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhCzheYU7ONb8EVWh\n4VQ9p1D9d0AwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhALH71Qb5XCtyF6jmaQQq0ZuklsmP5k/0Bcjr7o7S15FuAiAE\n7FTYL1aZbv4cbcNdCTTyWbhmWaHnpW6h7wyEZtYueQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4032", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4032` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAXgF8bcMf+CymBwH7cMLwq9vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxZmE4MjBhLTU0ODktNDE4YS1iYWEzLTc5MDE2MmQxMzVhYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJkZDE0MmQtYzg4\nZi00OThiLTg4MTEtYTU3MDBhNTFiOWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Pf8mgRFONPZ59n1nRHl0EpJMSbVhJVqiNtmSvdYCUC4lRTkMNs5fLc1tQGv\neaydeqjteDqfryP5O/pcRToi26OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU3jy8FzsucbiSMM0z0Z5Cv2Ves4wHwYDVR0j\nBBgwFoAUS0ZheftvvHTK8Wiq16ngwkj9+agwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgfA9IdJta\n7Zl4plEgbdeoQoz4kpxivYbi1CPVJNnx+ykCIHi4/B+VFcsucYcHlMO+E59ioJ/6\nCtAweboOCGNXld2v\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa7vdP23SUpa1QKjCNfBr4uPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWZhODIwYS01NDg5LTQxOGEtYmFhMy03OTAxNjJkMTM1YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSQ6fkwBxERS2G7v+daQnNR7lMbwjbpyPe9PjthPnI5rrZ\nl4akkAWc0NesS9pFZLnHg8BP1xLlDOBlm8bN2oK1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS0ZheftvvHTK8Wiq16ngwkj9\n+agwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcHO/mXmqGdfw7+t5yllLa0hk82bQetg2C2of7+7UF8wCIBZzXhIfPfWe\nvTsdN18aRIEjcL1PDRHTzDRRm7G/hWyV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARj/Iy6BeBq1k/DIpeEjfizZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJkZDE0MmQtYzg4Zi00OThiLTg4MTEtYTU3MDBhNTFiOWIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYThjNjRlYmYtMTMzYy00\nNGVhLWJjNmItZWY3ZTI2N2NjZTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTq8OrcOS5xVP7/1JZvhEce9iFZSM5/83+QroJm4mEo0ApNydoP2Ns6mWM4fTW1PA\nfPbVXWRceIkgkBHHsAdFn6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUU3jy8FzsucbiSMM0\nz0Z5Cv2Ves4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgdIenWAUqGXmyfsWLdyfRk49zPAGuUwlGnEoh/zN9DTsCIQDm\nvnPKV7hE39EHxbkK+h5zZ47WxydNcQRF4eHsvVAviA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4033", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4033` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAfgDsoWlBNGfpsJ0PvkW3kmfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhYTVmN2VkLTJmMTMtNDM3YS04NDgzLWQwZDg4MzRmZjkyNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk1YzRhNmMtNTZm\nZi00OTI3LWE2OGQtZWFmYTcwNjllNTFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZyZoMWgzp1uj7TRpYa3zpTxEmY92/Bj+n67WbDBV/sovbtZxHmYA/CpGy3G3\n9ezSOhjHcne5eQQu9j385r5eeKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTz+y1FxlFWC7IqDDg0ybBrqf9s8wHwYDVR0j\nBBgwFoAUEVTf55soKtq0xw+1e3jCc6YQSQYwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCxDI+q\nESDtIT77UseU7RC+T4bhh8rBVtHRQOSzOhEqPgIgb2V5RpAcq2KmQk80xHMHku3/\nWFff8J9Pcy+wiX3GwpI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASmExBF7syVbDet/Qj4CjG12MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWE1ZjdlZC0yZjEzLTQzN2EtODQ4My1kMGQ4ODM0ZmY5MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASF6+ftI6sCid0ZgpUhXeW/OBmKmXqD7Sq5/FsMATGwhNZu\nUWCg6UG4/C1Q9fWF5t3rouwNsP2qQiNZCVhoFylQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEVTf55soKtq0xw+1e3jCc6YQ\nSQYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANxe0l4ytvGr5Ourky0hEqJZvuvWNwI+B4ocZEQE84prAiEA2dvnW7/x\n9EOuMJcH/H0HO2vjkxWvXkk2icwUCqtgRpA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISARPInTusGQzB6WmC+2/tiUgAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk1YzRhNmMtNTZmZi00OTI3LWE2OGQtZWFmYTcwNjllNTFmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDdmZjExNTUtODViMy00\nZGM4LTk0NWMtMDIzMmUzMDU0OGEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEQHNyj+2o6GZmPDw1X/Z3HaL8lcD70WUSl0BrZs7O+61VW28K9cVDmeokvy9BTKy\nA6u6X0o/ySQjA49zFmfqSaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTz+y1FxlFWC7IqDD\ng0ybBrqf9s8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAMGUEBWlZ+chnxZE4slmW5UdHrwn4mM8TCqvrXYBfM0iAiEA\n444CUeioLOaGkjUy3yI1Okozd4C2Zubz0wMjqKwC4gk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4034", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4034` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAcnMw2HGRyLhx2hxsqL+BpHwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1NTNjNDlmLWRiODYtNDg5NS1iMWQwLWMxZGNmMmNlOTQyOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZjYWU1MzYtYWVj\nYy00NThjLTk2NzAtYzBiNTI5NDQyNzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAYyEfs5FTtquyhpyhSmZ3+aPPe6kYn9W6RHmxPdIa7uf+LanCU12Faq/i1e2\nq/VheTp+o/I0yLUPj8SLlOrIt6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFRpc7Mt6dU7j1KeBGgWl1hm90F8wHwYDVR0j\nBBgwFoAUKb/hX7Rac1KyWr1992MiORMU8sYwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQC0pwFqAG2ehZr9QuK/4lkpyoH0q9bEDq3ot4cCTke5aAIgYC3d911i\nK3whutPlMC9xaJwumZPGVdqEUxC5j1RCGUQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcbRlqW0O+HpicYkhq5l4HiQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTUzYzQ5Zi1kYjg2LTQ4OTUtYjFkMC1jMWRjZjJjZTk0MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaInMeteg8tVxxdBcFFP+UUNwvYGxhj3OROlrpJ8iYGhuF\npMwzrbH1Q1Gt2wvjnVNxzFA6I6zf/S6hIFaRZdC+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKb/hX7Rac1KyWr1992MiORMU\n8sYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXEOLSiD6EQrS1MlaPzcbOlAWRzP9rR/gkcrjWAT/vcACIBSrkfYZkm2e\nD+xmwc6GZ9Onyz+kz8wYZwXp4+z3Kdj9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAY7TRh/U8uNnGFZkp4AHnU/AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZjYWU1MzYtYWVjYy00NThjLTk2NzAtYzBiNTI5NDQyNzY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWY4YTNhYzctMmIwMS00\nNTFkLWIyMWEtMzNiODM5ODA4NzRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkFKAEAQHkga+C3QZ1AgwYotUIiXYVmGE+2ooxb+IFOrgSF4vC/YbQ8viVOfYbRzg\nQrIjJyV8oW/qNtmEwUdwvKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFRpc7Mt6dU7j1KeB\nGgWl1hm90F8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAOIqAfne9E82Dp9cNsT/Y/b12V8fkr0r+ZUZGvTuWe5YAiEA\nlsZe0DqSedRmDLU7Vo3EyUN8Og4DItM6pj8DTGjXi4g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4035", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4035` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAV+YkudMnzYHuSuq/AFavpYpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyNDJmNDc0LTJkNjktNGEwNS1iNjU1LTM1ZjhjMDRjODM1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE5MzE5MDAtOTcx\nMi00ZDliLTliNDItZWIyN2RjZWUzNjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfNl9uloPrroxnfYeuA7vEU5mKLQ8E5LVNBGifXD7Ku8iGMjT0qo0kaBd85ge\n86fTqwo84Ygwvzmiwk3KIXAk66OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnTdE3bn4dx/230Ed1ea0kJSi034wHwYDVR0j\nBBgwFoAUDhZTY7c4csV6uzwFJfOR7B+845IwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCYpKgTWn2843LR0GrPbrsRMwHHsDDMWsw3e1lL3agRjAIhANUkl8X/\nNak8jA+e84L4LTmrYdjJVjYlUrHIlcuMlglX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUqwZukOjHvP5rJt+oCgB3M4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjQyZjQ3NC0yZDY5LTRhMDUtYjY1NS0zNWY4YzA0YzgzNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXiQXGOsg/D5kK7wsREhyT/tta2xmnXx7ZknQFppFwc/5H\nsHBK837PzBtJU7S2VSgW/JqyqGZA1qnR1w2br1SSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDhZTY7c4csV6uzwFJfOR7B+8\n45IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI51/2cdGQRqSurreC3YGUdfroOsz0LJBCDgJjfUW0YHAiAk17QeiIzk\nwwpW0FEcQ61ZNG30qm+q3gs8p788wLu5MQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAcPoGIQH0m7h7lC5FnhjhQ2yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE5MzE5MDAtOTcxMi00ZDliLTliNDItZWIyN2RjZWUzNjNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTg5Y2E4ZTktNzk0ZC00\nZmIwLWJiMjgtYzIyMWM0OTg2ZjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n03WUmueUxGMWq0N8MHlXSqLB5MVRtLadsjn/doNlMDXhtnoqt28MOcf4RD6upWsq\nHN1oLcpyubz1sP47f5R7KaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnTdE3bn4dx/230Ed\n1ea0kJSi034wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAMNOvKfwX7RoEOBJjbCnqfhpqJvncNYPXjXxrSu4YpjTAiEA\nlAmhL53L2fE0O4jpJwerBHPS3dxwctKw5NksNIEnHcE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4036", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4036` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAWBonmEBdivItQEx5bzA9w9pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MjRiMTMxLTI3NTAtNDM1ZC1iY2QyLTMwYzk4OTU1ODUwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFiMjk1MjUtNzE2\nNS00Zjc2LTkwMDItMjlhNTQ4OGU5ODIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENwHeO5Lxfd7K72iNK/0hF5wkSQt3SaLUAbm1CpI+/3L4zwY1eWIpyBm318Iz\nhXoOlagRWr5gb5A5TIcsmmmp76OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCR84I+m91xDTuYuizND7U2Gyyw8wHwYDVR0j\nBBgwFoAUetTuvMOkbZmqJ3wOl0p3GQSI+48wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQC1ZvyTDy33ZuDWJzk309OH3HBNgd83mpVsVimPZe2ZBQIgRKJHQoh4MP6Z3H5L\nLfjIyJRqcVD/kSSjl73Az6Kua0g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbXiFQ4UYKexkRUjQpKrNzLmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTI0YjEzMS0yNzUwLTQzNWQtYmNkMi0zMGM5ODk1NTg1MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk2mUMsZ8a8Dkn0/9o6kyQ0u8bJbr81G4rjTmjGw4DMGKm\nQgBlU2N1euRgqfSeVJ6QG19pb0rJxho51fQ4iHEVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUetTuvMOkbZmqJ3wOl0p3GQSI\n+48wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIuuw7nr58yyLhRJUrPvJ4Skc4pnBjikLxVMjLTwEqSwCIQDYJEdmDnhS\n/LsFPamlKHx4J7osCv+FCdoffrgUtwCl8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAUS6WaxCpfTJraBM8issj4BTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFiMjk1MjUtNzE2NS00Zjc2LTkwMDItMjlhNTQ4OGU5ODIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGY3YWFmY2MtYmUxZi00\nZDRiLWEzZWEtNzJmYTRjMzgwZmUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9CpBlmn4LQxLuj4CBWW4RWsU+p1Z4BQ10AZ+QdOnoh0+dEltl9LVcQ+JOO7Zus+N\nT3qRtqACAqZddHDQGcI2EKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCR84I+m91xDTuYui\nzND7U2Gyyw8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgFEVGA0Pgz871yt2K4IwY4ZR160YQ9Ly1xyLlSYDGoaQCIQDQ\nbpL4H7EhgXE7Z2JNijWIk8JXmg4gpVjmXJUqJq0mBw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4037", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4037` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAW5zZkzikRN7ieN2HvETiFrbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhNzQ0MTkzLTdhZTgtNGUyMC1hYmRlLWZiOTdhOWU1M2ZkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg5YzE0NmYtYmE5\nNS00NGU1LWJkOTUtZjEzMjU4ZDdhOWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELd20BU4qYE0MO1xmnz2DQ2sOn9azpG4uHeNLkJ4W4i+Awc3Fv8vqTUiSx5n7\nI2pS31a9m7Adb/gWGLTUisyveaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/p5NspJ3KC6/D8N59zraiTK8zbYwHwYDVR0j\nBBgwFoAUgn3HAdS50uNV5nk5Ay2g3G5uSi4wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIG6lB98kikxV1mohgBHWc5ikYCDh57PETtg15nQ5fizSAiBy\nh7qTLepEFHEks6OJi8Tlbc+K0XqLN4ho8dryGLjaBA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaPrELlmbUP6CWMSuWIecNF8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTc0NDE5My03YWU4LTRlMjAtYWJkZS1mYjk3YTllNTNmZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATG/1C/QCC0jxz58A2lV7+kh54aT0OZDraw4fj0wwLBgm1P\nvCAn5hvLAggPfZ+kCkykkal96v97uS8m8bWWa/SCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgn3HAdS50uNV5nk5Ay2g3G5u\nSi4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTUTEWAjE1n2MahMyZU6PQbntdUAXByqhejJqVzhlwW8CIFjqYS6xm5ym\noGfDurRdZCS76yXb1XYWRlVD4uN2AeqC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAQCRATfeqD4LayXETDtXrOYqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg5YzE0NmYtYmE5NS00NGU1LWJkOTUtZjEzMjU4ZDdhOWFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTQ1NzM4ZDUtYTc3Zi00\nZDk0LWFjYjktZGNmYTZkNGRjZmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\na206LYPhiWjTs7SBkTMpObkO1PutK//DgtB+Me9bMdxPyzT76+xyyihj2GmGHSr0\nZGcu33F/CmeuX2ibyRSF4KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/p5NspJ3KC6/D8N5\n9zraiTK8zbYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgHY/rnmdg0FtXgth+w/Nn2WWJMw6v29tkKAEssDVZTuYCIBt2\ngftc0pzOHUduyKM0WDBdv2fYkioUU2R2lCYJ2eL8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4038", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4038` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVfyWlUd/5QXWSCE6okoF8XFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5MDBkNjkwLTg2ZWItNDYwZS04NGU0LThiYzg5YWRiMzU3NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzgxZGE5ZjktZmFk\nMS00NDFmLTg2OTktNzhhY2U5MzAzN2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM2usMdNC8bRbQi+XqB1ls3AMztYbuDmNvViAHD8hTUrzcBZ5zYXWqbHvK+m4\nHUxmCKTcc8hfzza51xCsCFIFiKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlvg990muDkk69BgJRBfULXbmoCUwHwYDVR0j\nBBgwFoAURoq2CRRgl0FwGj4g5Q728cFqpqgwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIEs3ol6hkDki8SPqGiRA91dCO9ZeVWHv9dfkYl1xVyD2AiEA\n3gUl4nQPuSxI9lYasB2LDnp6OtVconw2fbEKdKt7+IM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbgETCxuMk45AXl5VglqiTe4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTAwZDY5MC04NmViLTQ2MGUtODRlNC04YmM4OWFkYjM1NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQk5JrU8nAFM9+PcwG434Htk7eN7fvby1ZiKhdh/v+cfh1G\nCvnsSrKeleObf+YOZnARCUcEWxc4+3yczUGZ/Xmyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURoq2CRRgl0FwGj4g5Q728cFq\npqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeQVXDwd/HL+4lvO4ZP4xAgs0a0E9zV6u7NcBDg455zcCIG5P2RGcsYuI\nh8q9a3qNh/B7sqyGTBMkWxeloqkUuDyD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAUXrPptD14osmiL4RVNdjhWmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzgxZGE5ZjktZmFkMS00NDFmLTg2OTktNzhhY2U5MzAzN2VkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGQ2OTMxYjEtZmU3NC00\nMjEyLTg3ZTgtNzg0OGY4ZDQ4YWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nu6vH80P+L1/MU4EaXHl+Jrn8kIqu3gXA/I/I8iA8F883AmIwBUjYQDIIA8sMz6FE\nrSAqZSZoYNaq3/zJD2alQqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlvg990muDkk69BgJ\nRBfULXbmoCUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIlhjy42EhKAjFjeiDkcjQSvDVsB7QqxAxrcvzxf1G2UAiEA\nvjOgpZT5xxysw2CNnooUU9vdn5xaT1HNg3p2g2GVz+k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4039", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4039` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAfa3bDbFnwowO67kXNSDVl4mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlODE4MmM1LTEwNzktNDJhZi05NDY2LWEzNmUyYWFlNjkxZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjY2OTA0ODYtZGE5\nMC00OGI3LWI2NjMtNjhlNWEzYWZhY2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE47K5hBu6HkndwhiKaPxhaVH2renEtNuDQiQc/0Zz/yfgUnSUnP/ns9eIooiW\nwqW7g4NBjrqWU5RtVozEvhmDKaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Re/ki3J1qhxegJnyxo5Hh3ZbrIwHwYDVR0j\nBBgwFoAUhmTEWl5UVWE8LysIO+dHEByrW7kwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAiSxb6l7GI5\nTPMkL14OfoT74dU+NP7d2vCSA/n+vToxAiEAt1tlfboLP3JkKPHU2ZfnqZd/6pzZ\nqm8D9+bu3S2Ij3k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeZBrKhQBPl4ELEatqhFMJXMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTgxODJjNS0xMDc5LTQyYWYtOTQ2Ni1hMzZlMmFhZTY5MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3BhK+jUdz00aeU2UgH/LDJZHoiaXCh7hGIsnXFsZ4HVK+\nMFLJjxPz30Puvqryi0Cnuqj8GGXYMjnDRf/HdwHro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmTEWl5UVWE8LysIO+dHEByr\nW7kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgO1QV3je8S5tpMsn6UQo27fXsP2KXRBegH5BriTgI1C0CIBRR1cWuMaX/\nqFNGCzC3HQWwcfKEnqs7rmJJlXfSz8kz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQKt/CVCg4cL/1cFWZ0PcGA7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjY2OTA0ODYtZGE5MC00OGI3LWI2NjMtNjhlNWEzYWZhY2I3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjA3MWMyOGItNGQ5My00\nMzMwLWE4MWEtMmFiNjczYWJmZDdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzURV9xTfqnx2BK+sjCXdw3d9D+oPFmD0DuVUwqKYplCC5noHLvpAU9COzBeCeRGs\nPY1vlURzemmHfxSl80AA+KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0Re/ki3J1qhxegJn\nyxo5Hh3ZbrIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAONmk3E9EgGQ2bc5KEaIp2lL+lhfKtUmY+RtpPD+jjrWAiBK\ndbc/jvghozhdmENProqhrMYllYQTtFNZScHgiGZuSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4040", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4040` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAaAvW61dVO+ISZoxoXfg96zaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhOTBmOTBkLWNmYmQtNDU3Ny1hMTMzLWIzYTQ3MDdkMDlkMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ3YzBmZTctMzgx\nYi00ZTFmLThmYjUtMDBjMDA4MzlhMjE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsyKYQSaQAq5ts2Wh80VlKZHs3CGQh80k4O2fXLBYiqGxGEgDTbeTpqN+93Vb\nQQXjJNd+nZehJMPTP1RJJvwfJaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMGMIUYoW569y94dWfpzk6QTVmrswHwYDVR0j\nBBgwFoAU8wn6i/AW+SZrfgOagXpaCkVnfM4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAL+sCkBJrE1hr8Xa3x9xwjv/knpQCXo+Fd6N+jJ6znrQAiEAk1NcByU8\nv0PPD53XYDD1F9sBId59sRDaZ3SzZsn+DKU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAawO9jFGnCrCbAhSdrDnjXMbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTkwZjkwZC1jZmJkLTQ1NzctYTEzMy1iM2E0NzA3ZDA5ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQy4oPQfinX3sGshz4+I+n7sg11cCcx9P/+qcgpxn0HU42R\nMXZzRoEnmGZTqxgDxEX61KEsk1/uUS9XvVNlyIg7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8wn6i/AW+SZrfgOagXpaCkVn\nfM4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgft1IHDQfdWAZTerLIvNuIoghU7biJ6FbXHJ9XfIcn1ACIQCBTLXOripj\na0kUKLSooXnwZ+T0q6Oam7hRTymjBWe04A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAYs+mcsCIbjtlKI8aVgR+AduMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ3YzBmZTctMzgxYi00ZTFmLThmYjUtMDBjMDA4MzlhMjE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2IyYzAzMGQtMDNlMy00\nNDRkLTk1YWEtZjY3YWM0OTQyMTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrEILuKJtMaRcF32Yn0JA/lto2uoPfNxztptV6k4rWchD8zlaFn7ccww15Ka7RrEG\n9ilaFg5JOSYa0Ze/101YGaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMGMIUYoW569y94dW\nfpzk6QTVmrswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgPdLbL1I6iZ36zgjdDPa19GexBIIztHwDLpSlc4/E8okCIQCP\niVcehLDxKBY2Iyi9Tg4n9K3PrSFAOIfkddRPuhPtPw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4041", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4041` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZdif0Nwpcgs6+XxBoOhpYe0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzMGE1OWJjLWI2MzAtNDViNi04YWMwLWQwNjAxNDM1ODgwMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTFiODJlMmEtM2Vj\nZC00ZGQ2LWJmZDUtOTdkZjE4ODIyOGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3v0gNw2HnzLAhyufj75GEcBw5PqR87Vvc8F2j/+jnhu15FFKQy7F2a/tsgoT\ngV/YpU+W6vfRx/LqAoFVJwFJEKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4tt/arHKLR/aasgJ41LvYte6WMowHwYDVR0j\nBBgwFoAU8kNr38mRZJkS7eqdWg52GubKPewwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgMeC9dgm+pH8nyokci1sgDDbJBrJRI+xFO2QfUaTGda0CIQCIqo9f1Tf+\nP6c8WpRry6P0LJHioqIXs3QkBHZGU0ZiwA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ+KI6k3Zkiq01Nog30WoXgvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzBhNTliYy1iNjMwLTQ1YjYtOGFjMC1kMDYwMTQzNTg4MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGScz8AJVcriS6e26taPjG54eau6EPKse1f6P9bWkymXKQ\nOYxaiAdmADokxpun1H5EpuqBkAJ9m78R5zEDh+rOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8kNr38mRZJkS7eqdWg52GubK\nPewwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMSlHHWEkGwoXqrUicWw2PgOKeZvhbD7145XcPGFpVTnAiEAmRU7hgVk\nYPubZBZ5N6uKoWbay1VIrVTJFMAVCUoJ+eQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAfzoSwYn3VHPAAhbUReYA7PrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTFiODJlMmEtM2VjZC00ZGQ2LWJmZDUtOTdkZjE4ODIyOGE3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzI4MTk4MmUtNTJkNi00\nNzlmLWJhNjctMmY1NjEwMjdjOGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDXkKQi/TBQbO11zpLT2rcUSJ6vQTBurFESJI0YLwexJJqz+GCsK8alpdzUTc/hQJ\nxw+h5EYCpDvJEks499k2uaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4tt/arHKLR/aasgJ\n41LvYte6WMowHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgTzapema2vVt/WI/biEpI2xGxgOhP6Yjhb4oonCKrtF4CIQCe\ntGYcvJ3KRcev4f/ghQKJpakGBUCNFjC3Qp9ZzatnCQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4042", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4042` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAZPGwA33hfWmvRhXaMv3uZUyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ODVkNThlLWUwNzctNGJjMS1hMDIzLWY2YmY5YWMzNzBiZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE3Mjg1YWMtNzk4\nYS00Y2ViLThhNDUtYTM4OWU1Yzg0NzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEnYYb14h9Z+THbe6MF+3d/XFnogELReXRfd0KUzpphShO4dDftjebaPUYOCz\nGJDzTjPpm1rcF5VgrtMhoL/zKaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUW2C6vFqmB1tFO47VvqC1rifzZswHwYDVR0j\nBBgwFoAUZTWjFNH+HdoPN6a287wr+CJrgPYwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQD4I+MC3uZB4iBHo7RZmxX2Sru8Vh/73T6Jg2Qu+ZZOFAIgELdX8+vG\naAc4B/LFmLxnpDCyjW1heL4rMtEvYf2fn8M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQDeF4pXaex5SwALJnOgMgjDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODg1ZDU4ZS1lMDc3LTRiYzEtYTAyMy1mNmJmOWFjMzcwYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQT5G5SqdF+DlhKVswq8iOWe7AfZajXJfAGyLM7AwFKXIgh\n39y2gzPSVUSrYStm643kZJ91ImXmjCMsCJd5/H3ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZTWjFNH+HdoPN6a287wr+CJr\ngPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIl8Tk5V1+DqCm0GcbM1GOW7EVKW1E2AQioNkdWecVaGAiBUMKxLRTTY\nTLUVvSmx26NS3zk4e77bXDcmOITME6jAvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAWKyKHJycAmHrhhf4yzEzivPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE3Mjg1YWMtNzk4YS00Y2ViLThhNDUtYTM4OWU1Yzg0NzczMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2E3MTc5MzMtMTZiNC00\nNTRjLTkyMWQtNjM1ZGRkMGE5ZTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyQurBXMa2/HISLeRfC8T1je6q3zT9BaIKhjWBvQQwlD6L/KeSmhv9OokzAEOSqKE\n32rETRrn2coKRY9Ea7Kzj6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUW2C6vFqmB1tFO47\nVvqC1rifzZswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAIJ9vpPlZHfNymnM6c7pIMNC1/nT9L35h9ld7wQtRozpAiA4\nWQCMyg9wOkwMo9D8IyeLz64q21sXy1D4iiqQ628Gxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4043", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4043` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAYzyYKWxqiCRkD7mY1aO6zs/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0YThmNzg2LTU1YmQtNGEyMi05ZTQ3LTEwNDQ5NGE1NjFkNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFhOTYyZTctMmM4\nYy00YTQxLWFlNmItZTkzZTNlNmU5NzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6IOq7C5TL+TKF4SFFApUUUWoYYSHsq/hd6CNem9X+8LyuxK9P5memB+gMqg1\nsjKGYf7IVKwmhNT5jv5fy3FSxaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQF4vmjHgzrpPkkhRIGSAkCJcK3swHwYDVR0j\nBBgwFoAULMNBNxf/Xl+mdrBsl/KnveO6WRAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIC2u3cRkHjY7wPANEe+0wvSiBVnZJQ//iNZbMa8y\nEMGmAiEAncBGZQEnD8Ghy32dwzROPmyTka35MTp/vZbTiH1Op/o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATYRKnH2TYKasrSLik//NlcAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGE4Zjc4Ni01NWJkLTRhMjItOWU0Ny0xMDQ0OTRhNTYxZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9CD69DTu8y5+D/f/TmU0r4Ux7MvV2yeXEk6QMYDlSR0UW\nsZnyYrfBfLbBm0yMS890WS0Aq8e8oafpQDnyXZ+Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULMNBNxf/Xl+mdrBsl/KnveO6\nWRAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV1wgr2UObObU8BopT78He4YGEVLW1kQKfhJDHV23SKwCIQDzVTkEHQFF\nRZlzEGMnXqjb1g5/AG4NIQKULyGWdUEUrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAfkQHyvBgY7mFl+ADxhmx2f1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFhOTYyZTctMmM4Yy00YTQxLWFlNmItZTkzZTNlNmU5NzgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOThjYjc0NzAtMGVkZi00\nNTA4LWEzZmQtMmFmZjYyZmNjZTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/fjk/TronXGAycRWYTrxc4oxuHjzlLZw2YAbKncqheEYK9mt0fa3hyP55abwa65s\n1TXrCv+p4hBuCnU78AnN5qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQF4vmjHgzrpPkkhR\nIGSAkCJcK3swHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgMeGtrxJ/IYZB6lpFmQLgpM59CgXsjeNdDdEUfKr/PGACIQDN\nx/RX+392v0FftQbFtWyX5gzTbAzEkKCjL/RcsqdyrA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4044", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4044` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAebCveeHsQLvC73+dKMR6UlIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMGRhZjQ5LThjY2MtNGY1Ny04NTk4LTg0ZGM3ZWJmZjI3MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZlNmZjODYtMjRm\nMy00N2UwLWE0OTctNTliZWQ4M2U3NGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWVEv+LMM4LYqEXreNcrBvhf//2brA27dmW5GmDrbgh40jSyQ5ijbx3asfAAf\njekskB9HxA3CakdV9v96+8o1DqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTKOHTgTWD5b2IZnWt5/O6WLKm6QwHwYDVR0j\nBBgwFoAUu3+vezXqN3BnpAJuLjr112DXNqgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIG0YzOwd8BpegO2nPDrtYqBlAKHqhLlG4tXyh5gv\n84VAAiEAw9nJE6LEDpSLOO3TPqYC15O7Lsbj2BKDqZytDUh5AOo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY5ByeOspd8dzI/e6wVtdNyjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzBkYWY0OS04Y2NjLTRmNTctODU5OC04NGRjN2ViZmYyNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrjVlvHjnjpwYw5dXSSbCdDFXosbWPjR3m1cYqL7MHhMKm\n4M9d0X0sjNLBgWZXuXa6WNV9MWE9ObhMfMGQce+Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu3+vezXqN3BnpAJuLjr112DX\nNqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIfm5c7ezY8fD/LgVUakdcgL2Jq8UX6OTNAb3KbjjhbLAiAeJq2mQR7Q\nsbPsUu/l4RT9FVzecu4dZ/uaWgamFHtsyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAY3Ovru0M9rYD9I7B6KQYRQcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZlNmZjODYtMjRmMy00N2UwLWE0OTctNTliZWQ4M2U3NGUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGY0MzI4YTUtZDIzZS00\nYzE1LWI1M2MtNzY1ZGU3OTI5Zjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGATWJFTCB495+DdltZ6Sh0wPpSmrTmmzxaU8U+OTMOnf/hyGsJQgsYFGP4moI8Ld\n4KjoOwGqCs09T1jEs1h1/KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTKOHTgTWD5b2IZnW\nt5/O6WLKm6QwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAP/oChYZypM50uwazLd19OJvul+7xMGISyja4Bk7/IVWAiAj\nEuqN42KIu3Dl/VgVPi4DR2tKJ7tP+kyUq3yYQ/7gpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4045", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4045` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYwSwn7xisO46FCqtuGlpbD/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExYWNkM2NmLWM3NzYtNDIwOS05OGQ4LWRiM2YwNGY1NTJjNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWIzNDFiOGItMTE5\nMC00ZDIyLTlmOGUtYjc3NWM5YWY2YTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBTXS/QM76qSP0SCb7mIV7IZabYWAlDVvmy0AiWMHL9EpXm+OJuxiRRCCziFy\nLnYlwMZRcGmMulvyzfaTIAlDAqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBcUyix9mZgH7gFAl4IOReiXn9y8wHwYDVR0j\nBBgwFoAUfyltTc57BwtbCMbj4a71R6LigI0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQC4qlDb2veHa+FqlR7BtrwFwSASuV04jjP5j4ww5VakZAIg\nH8uIAXzFPRixJ30i60VZOAtzEwO0KM6fjvl+xuOlI4g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf//i1WzLp7AZ4qoeZ50aEQRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMWFjZDNjZi1jNzc2LTQyMDktOThkOC1kYjNmMDRmNTUyYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLz+hTpzpP4WbiLvWAp+Dm3nSyVkoan5+ikAYhWAQrNvBL\nrxVHhnt42TP+PuDlOVJJzruckJz7WoItKOBiE40Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfyltTc57BwtbCMbj4a71R6Li\ngI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdcFZtnCiA5inP2XT96/NAU+4CKM7AL/4JCEScJFco9oCIQCvLTfmUZKO\nB+VoVYrm2zyWa2gObvTSGbdx0C5KUSwATg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZYk/fiO4cAC4gcvaMPB9D7TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWIzNDFiOGItMTE5MC00ZDIyLTlmOGUtYjc3NWM5YWY2YTRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjhmOWIyMDUtNjZlNy00\nNDU4LWIwNTQtNDk2ZWRkYjM0Mzc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndLsDaOwZGJbMiLF7bYaArXHcRhTz0tLInBTpca+18zsQgloxxgARRgcqopEBI0t7\nzat2GsbX4n7q0YVUnE8pQKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBcUyix9mZgH7gFAl\n4IOReiXn9y8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgE9kaKlJPyWqkmqEpfwoV9pA44gZ5Bm3Y4K0rj3pmrKwCIE/V\nO+rwYKeJ52eP3nx7upphDWrZueZ4nQ33ZejEGyY8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4046", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4046` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAXXxUReLlKAwtX7ZdcQ/f/heMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwYjQ1YjdjLTgzMmUtNDMxNy1iZTUxLTZkMWUxNTQxYTg0YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFlNjBkYzYtYjQ2\nMi00Y2RhLThiNmQtZDgzMzUzYWE1NThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjLLxgt1+/TzusyySTNiiGehAYNaq2jqVPWceSiEVVO0JLxYYmZlbHm99MlBm\nrNmIpjjKymmiyOrb2JMDWS3366OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkn7u0qYg7mDHc9tW6OUuWgZe+aIwHwYDVR0j\nBBgwFoAUu9Ok1IRQRQwuSizflG/02WohM7AwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDs9xpHuyuICJbyhmfJW9qg1en460uv\nuRytjMX3wHdhBwIgfcwy6k/k9AKFhC4bT5xFatbHhSwRRHYrT1Ejah6Bg7Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa7QYRPAgpsoUVn4yow4NjqMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGI0NWI3Yy04MzJlLTQzMTctYmU1MS02ZDFlMTU0MWE4NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP2R9EpJebeKoeqfgfBSZQhIsWO96NePo+2GpzrP8vMbu8\n4sGyorWwfJKb9EB+G/uV/lnx1qh+//T7Ej3JkWnAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu9Ok1IRQRQwuSizflG/02Woh\nM7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAON/M99C+se3puxUAi39Giy3AZ6wFCOxS7GYmIFg5VK3AiEAhOmxsPqK\nEYc2j+oGp03oaIVJjdBZ2nVgi0gFCKLydAA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAQctmnvWIy/dkrV4SJyEEVgsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFlNjBkYzYtYjQ2Mi00Y2RhLThiNmQtZDgzMzUzYWE1NThhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWU5M2QxYmMtZjE5MS00\nODNkLWFkMjEtYzE5MDM3MjdlOWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQm7RD6YYlKeKbbZUDBGyYnN1sqf1S91MOEEvT6vlaZvpZr/beUd/4SkYLpcrPbZ1\nfwU9iYgNoTbEh+2592MOVKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkn7u0qYg7mDHc9tW\n6OUuWgZe+aIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgCkhRMaJN2qIl2Hb+PNIn0YM8o6U7DgQ4faPCLs2UlnMCID7G\nblIJd1NV+65NMOBvhjn/C5A+GdmqKNSxa/Rp5AIr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4047", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4047` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAaN4fnWqb3FZar+9ZBN4qxT1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwMTg1YmM4LWIwOTAtNGUwYy05M2ExLWM5YTkxMGUwYTU2MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg1NjE2MmYtODJk\nNi00ZGM0LTlhMjQtODRmZDUxZTdjZGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK073lyxN6cyAGBs8FiQYRtPQzzvnHvbe4YV23RlgN9uUHilKSKyfSwFbSm89\n5B8tFNO40RXyNee0KVVRhTUZ1qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgiak18quhFUKJVlhraoJiBLNDPUwHwYDVR0j\nBBgwFoAUcF9Tps0ZDpoi38PY5DD7ibblugAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCzauEX4mfsrag9FBlT4NOBp3vbpMGU\niVrf0ynqF9gwQwIgG1Ya8baVLeQL1VRnYwsqJW3UsimhR9fzvcCzpsPf6/g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaPX+Z6sklE/NM8uNpXPVOyhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDE4NWJjOC1iMDkwLTRlMGMtOTNhMS1jOWE5MTBlMGE1NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5BGN+geGDr7fSr/4/z/vv/rAErJI64oSKaKeDaVGeQJIv\n9qkjlmLPECrPcU9Bbs+x3Ivdd25YZZkbLuhMe7mdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcF9Tps0ZDpoi38PY5DD7ibbl\nugAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM9gCoaKX21ertIAby8KN7cw7wsoPzXLGzKlTcf7rPOzAiBMAFClmW62\n5p68UkvqqtR3ir834IYePBYhVuLileW33w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAUcDmLaf5nP/5pxzLfJdDcpuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg1NjE2MmYtODJkNi00ZGM0LTlhMjQtODRmZDUxZTdjZGZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWUzZTk3NzAtNDk0NC00\nZjk3LTgzOTMtMzkyYzU1Yjk5NjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nejoHZs7ahkcoFZ7Xhyx8rerIfQJpzIAt2hvEnDrBg5iyNm/8YinuVgeM02Vd0ElJ\n/KNQSzeWYmBSB28SlzxhsaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgiak18quhFUKJVlh\nraoJiBLNDPUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAPx7YaTk5jQlL+opdLzFOFMe41a7GfTjiYSmy9RKMt9iAiBU\ngomsxbOIYajYNMdA7hfCxWRRdSKGkwon9vghbPZsTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4048", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4048` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAR5N8wY3/utiMJNNJvlI0DjZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NTQ0NzhmLWUxMmEtNDBkNy04MDYxLTFmODE3YmE0YTE1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTJiMjU1OTItNTVh\nZC00YTU0LWFkMWYtZGU4Y2UxYjRmOTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV/5bB8N7OINyxDDhImvcUNkZ6US+bqsOssnnpLYR1wPMp8Ctigb/eFgG0nw6\ndb1uGjd5URYpY32RvMHgc8XbT6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGxjp5SEOIntWl5zZOlXGYal/YzkwHwYDVR0j\nBBgwFoAUgCbVkMKDyWYBpPat6Lw04vELkmUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCGDruDg86L\n6t3wiFl9skmfX61iHzI5P353Tl5gr2oBwgIhANToyKXwDEyTOShYOohjlJcfRwLu\nQ6eAeP/uE0AVuZdM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVYpawa3TtZHA9w8xUbnLEeqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDU0NDc4Zi1lMTJhLTQwZDctODA2MS0xZjgxN2JhNGExNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARef0cda4zvVLfLeHYLYTP39FS+CR6wq22T5wGPgZ/ts5jY\noEAoqmxQPXD55sTx06WzYjpSDetTLUwGqdQOiaYJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgCbVkMKDyWYBpPat6Lw04vEL\nkmUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOhW7dLVE68/hLJ5zr03sQqHoTp6jJqtxoNm4Kua8P29AiBMhPHHYWkE\nDWyN0QeS6/eiVeA082coLAq+5p8+YloV8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAbF6f9DnpAuNUDNXxGG0AQSWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTJiMjU1OTItNTVhZC00YTU0LWFkMWYtZGU4Y2UxYjRmOTY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzU4YmM5MTktNGU5ZC00\nYTc3LTg1NjAtZGRkZjIyMzZmZjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9xLh7N9ZKDA98mHo49P4N7DAXp4xfeXnkTiwUv26vsHiknkibpYYUrE3zCsvErcR\nQ1CONS8cRmw6w/FwikU6t6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGxjp5SEOIntWl5zZ\nOlXGYal/YzkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgfUvzJPS6tVX0EbLHbEW0FVLpjl43otlQLnm6IjE65+QCIAQR\nDMPrU/RfJHd6BdA+BODfvZjZ1p9VuZp1xT0ZpCiS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4049", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4049` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAYPD2okyV4up+xk2Ry2fJ9OCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NzIyZjZlLTMwZjMtNDViYS1hOTRhLWU2MmZmNjg1ZjhmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBmMTUyMjEtYjUw\nMS00YTEyLTgyOGMtNzVjYTg4NzYxMjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9ta2ERkrtUB4FJb5XkXhxJ/j3lhr0J4R2xpnsbK3jHXUV5FLOYlMaUKGOurS\np1xjTY2uHUirwcoiN01jWq5xmaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCBRkflxe280BvVBxVFwNqSRADwkwHwYDVR0j\nBBgwFoAUocEkihhj401Co8SpdF8+o8vl6F0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAImt9lkfOtYdqzoVlc4eFfAm4QZBEKQATA8uXeCm6zw9AiAcDta5+QQ1\nNY7JapLXwFDGX6IPTHpMeF45mRQkJWvnnQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATlWUiM5V5OU/WcLIlX+PL2aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDcyMmY2ZS0zMGYzLTQ1YmEtYTk0YS1lNjJmZjY4NWY4ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzHTIfnmHPHiJeXghcVBvdckw1Y51TyLfu7iKvdhxCeJ/D\n3lYZmXiwLhL2mTAgom/q+El8EVN0vI81Ufr9gTp1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUocEkihhj401Co8SpdF8+o8vl\n6F0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMgip6RkkHFWGdHON9w32RbthpfFX435JtkEip8Z3WQTAiBGz9m8B3mQ\nMg562kYMDbKd4Rz/um2C/yCFgZ7F5ru5uA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZoPH8hd8MFQsiM5CNo4h0GVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBmMTUyMjEtYjUwMS00YTEyLTgyOGMtNzVjYTg4NzYxMjMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmVhMjk3N2ItODA3NC00\nNWQyLWJmYjItYjUxNzgxMGU5OTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlti5NeoIty+0cwitV0WAKLPWpGeBTl7DXUYehdGs83g/BqYdBB8ikIbNkwy5V7pq\nIxhx6PGqf37uZXC5P4bdwqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCBRkflxe280BvVBx\nVFwNqSRADwkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOZffNW9qUY8a99kYJNIJEOsfPryjxDe50Do5hUuS2Y/AiBE\n1zjnpA590jhH3wLxugNhemQ0FBBfh9WKmnvKkbC6fw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4050", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4050` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAXQ5ayienzWVLT5EDWNzif97MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MzRiODc3LWYxNzUtNGJiNC1hZmRjLTYxNjE4NjQ2MjAxNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU5ZGE2NjktNTlk\nZi00YjVmLWE2OTktOWVhNjM4ZmNlYWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjr/USF4Z+PMLgQXCEvbevYM3BVcYgPRN5J29ejQN6uja8MeokWZlsTfrtOW1\nuAPfil897pIIBBFc/DyqD0Rsf6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmAf09cUxhUXEVtg1L6YnfjpX7powHwYDVR0j\nBBgwFoAUAfMJJOSRybr0RLp6cHX06/e9jhYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAOG6fvXeKnGNF+uz1PQEWsjD9/VRUutzMg+zxCGUVmTNAiEA4sTlWwQK\nA6naVdQMzt/MwBvSRg84ra2fTRU+Ytw8Kec=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARAcGSNM5M88+XxWQ4ozzlxgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODM0Yjg3Ny1mMTc1LTRiYjQtYWZkYy02MTYxODY0NjIwMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASm0lw7Dktmb98B7Ke0j1z/bRkRdqA6zDVlab/V5thWx9PM\nB0g2ksTqcIzLH7xplk2JIG1ONmRXgfMTGIW7FFZ9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAfMJJOSRybr0RLp6cHX06/e9\njhYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYol5TcprL0J+mnixAURstFZc4SWSXykIo4gNTTbWjgQCIB1CsfPcFHNS\ng7exmjrLrEAF2ezYEvCV1bEKx/8oXPQD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAaKe2yy3dMrvPDrpdwlI4yEcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU5ZGE2NjktNTlkZi00YjVmLWE2OTktOWVhNjM4ZmNlYWUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzNlYTQ5ZjMtMGQwYi00\nODA0LWEwNTMtZGVjNDhlMDJlMjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZ5Ss6vk2LLHSN74QlCXyz4sAjHFD/C0C78wI1GNZBuyx3tcRpz15dYD18WeDbeZK\noPqhhVfykOpA9aqoxFNQ4qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmAf09cUxhUXEVtg1\nL6YnfjpX7powHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgckK4HjMo3G+jG0fCMFsopz73Tk9DK61lns5xqEglzcoCIQDW\neaPeND7q4jolHXhPWrkmyFbrLYf+04uVoZgY9djD/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4051", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4051` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAZUcUih+/pZYLFbnLShAjzXeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxYmIyYWI4LTMxMWYtNDQyYS05Y2E2LTdlZWVmNTQzMjljZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNhZTc4OTYtYjIz\nNi00Njc0LTkyODQtOGU1NTg2YmU2YTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuPYa4u/fXQgGjNaQ8rIee0ElKEbh8LZ0J5exrnvaPUEK58cCyZN7e4Mbpnah\n0IZO1vYWhLDN1gBL6V9Ki9705aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKe4c7NJKVnAdQ19N9govJeZVTBUwHwYDVR0j\nBBgwFoAU8jFVwz5VCZeMzP+ENmyNpjQ9HKIwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCg6jWWfc/LsayZgbxX5v3RxW6Xk7Uc1JluwOlHqpP4fQIgCBhO9Kk5\naseT64i+COlC+tLVwNWDcj13x+jgFFqB8MI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe+LD4gU1ZR84PkRmeLy52HsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWJiMmFiOC0zMTFmLTQ0MmEtOWNhNi03ZWVlZjU0MzI5Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYXR5t1oc+n7fC5Q7KmG11HjkLMGNfNtLdSgJgC1IrS5b2\nGgSkMAwLuDw0wHR7Lubzq/lEaiBRM9RQsKahlWlHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8jFVwz5VCZeMzP+ENmyNpjQ9\nHKIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC+J8V/ZL/O1gXfKR5Kq38HK+gxxzSLCDEsb4BW8iqn8CIQCK+FlvzrSA\nQNSjIBiP7pYFzngQwevFJ32Ol/0SYaxi5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQ4OkMSlQVPKqR6nLiJ07AmeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNhZTc4OTYtYjIzNi00Njc0LTkyODQtOGU1NTg2YmU2YTYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTBiZjAyMTItYzZmMS00\nMzU3LWJjYzUtYmYxNjAxN2Y3NzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nykPhxGX0uSK86Ge/JjRRSG4zkutYcOS4yQOl+icyZD6lcdw24EuvI7rd6KgWs8ey\nqE2Bpy7hXw2jJeHamJ/rHaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKe4c7NJKVnAdQ19N\n9govJeZVTBUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhANaRXjlaSZ8kYL47jdRW9xdzSsFGeTGQuvJ08+n8IE72AiBt\nNIsE6Q1gZrVE0fuXTvN2csGE3HFf4Kt8ncb5UhsvYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4052", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4052` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAbVsXOEkm19KmC9hRqrHFFV+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlYzIyY2M5LTZmNDctNDUxZS1iYjcxLTE5NGNiMDQ1YmI2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE0YjU1NDYtMjFm\nYS00ODFlLTgxMjMtNWQyYjcwZGIyYWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhfAbZ3pdqb+hrTG+UCg4WnZ6SqwSjV1R/D/GGNzEI0DfH1fRTPSCzqQZUz2B\n/Tqb5sW1v0iOfFsS5hUGM55sMaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6VnWnMQyLqfVQJjdwiCslkEHq64wHwYDVR0j\nBBgwFoAUrNxR/hWYAh+5096Hp0Nnv+KQPoAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIAyzXSvGpmSG7XiVD4M/SLrWFCojE1t4uCR4ckTF\nDlRYAiBx/cN+NXg24Y3eyti9fsM57D1vWemN0n4op34u+r211A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV5cS1mCdRQK8GJNhOWSgNgEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWMyMmNjOS02ZjQ3LTQ1MWUtYmI3MS0xOTRjYjA0NWJiNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYQ7otM54kKywyeN3IyGviPOUD/0ibkN1m+B1ep+/wNnek\n0fS7LHE9+xJGzp0i8UjJ/kXq+GLM0SoXQ7fJ/Rluo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrNxR/hWYAh+5096Hp0Nnv+KQ\nPoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZi4E8KEZ4ZyWUtQjpjPYVx9Pk4huYZ4Rehn9QlHhau4CIQCeKWcg4eaZ\nw6gahIB/MP9Ehcq7SUpAHt+Dpp7yBbtdwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZFnJccIu13bTAgHmV97I4eHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE0YjU1NDYtMjFmYS00ODFlLTgxMjMtNWQyYjcwZGIyYWJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGI3MGZmMDQtMDg0My00\nMGU0LWE5OWItOThiMjI0NGU1NWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmKnNeB9oruF3gYHdQn/M4OnHC+fT2BZc/4FNGWTAD9JutPdZMydPZUcvw6zy7aeg\n/BxQnW4qZBHfpK4tlfvRHqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6VnWnMQyLqfVQJjd\nwiCslkEHq64wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgYI33KDESSYwzbWCesV37a+KNq1/F8GIGyksAUvPykPsCIEz3\nmQ78Tk/9hSPJ7XQZ15VOE3dv98zioF+UMGsU+HfQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4053", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4053` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISASBPmmAycKLr0Mi32OLz5Vg4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjZTNlZGJhLThhODEtNDQ1Mi1hMmRiLTQ1YzJhOWJmNmQxZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZhYzYxYzktMzlk\nZC00NjU2LWFlMjEtOWE1YzczZTQ1ZDRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9xgIKzjE9Z6urzT5skyuSylGsSsw/QbIyTB5Q8F65SbytVHaycnLx+/zSZx0\nGhW6qfKsltldqXr3DW4eNKGLLaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUThWRX16I9WiBKvgnRFcyeOBv5o8wHwYDVR0j\nBBgwFoAUATcgLmkXgRh+WmeR6dfMNvC0c+QwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDA+TTVuZCHRt7TCZnCQH2uPKTIjZvq3RjuMyMw\nD1M7iAIhAIz2MqUb6gR/mwv2Fqqp0GIjwd0k5mKN0fn6+aB7/aNW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASGNR5R+o3+nfvvnGcVQ6WioMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2UzZWRiYS04YTgxLTQ0NTItYTJkYi00NWMyYTliZjZkMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1BZGYtT82hH+LCyA9wRZ/dv8XGHrb7K8JEf1+gkkyRfN4\n/ewOWTi4uNY5HQHmrlylYyhKlUjGRgt+xXZKc93Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUATcgLmkXgRh+WmeR6dfMNvC0\nc+QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMo7m9gzBxoLfO1JGg+PUgJ59+o35kDz5eYT4GmY+4rICIQCdN+zjiiX3\nGvL/ZXwwtCOQYWW4Of6UuieS7NXlzjzs5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAers3EAf1ZfKp7lzvnRkR5jcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZhYzYxYzktMzlkZC00NjU2LWFlMjEtOWE1YzczZTQ1ZDRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDFhMTYzZWQtOTYwNC00\nMDI0LTk3NTQtOWVlMzE1YjFhMTFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEAM92A6XBBTVMtjggwDqgu/ON7Y5FU/BZLuppNvUzLof547icTZZhbYiOhQTVUrs\nEl0XDXt/l1z/4RB4kDSagqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUThWRX16I9WiBKvgn\nRFcyeOBv5o8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgYrPwIxkJ0yc3ErrchFsCnO1zsGNDqiRcsAflS1JpSmACIQD2\nWpmRI5fZCL+RhGaMUVEFYkN5Ak/vWC61ZvL9aWg9DQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4054", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4054` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAYnukfOnwxrg3pdpxlufLqPmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjNWJhYzRmLWUyYzktNDJjNy04YjA3LTIzOTdlNDQyOGM3MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDVmZDY5MzYtMmVm\nZS00NDcyLTg5ZDAtODQ0YzBhNDA1OTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyx46DTc+I8/XDXf/WUG53yYXhLIbpXoffEBLyvmzE5jp81yTffZPWG1bfYN4\nPx/4wNBsNDiCvipnj82DtnnzFKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJvTW0NkCDzUOFXcUEcd0Hx1cOnYwHwYDVR0j\nBBgwFoAUDY1KULh0ioRmU5wsTZ/m0wtRSPQwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIHH3Tl3fSuOlPETVMAtxlom6+CSEufLF1sBmlBwytRQBAiBv\nqvrXdmCI9gEsO00L5H9NXHHbGRSXW0TzXZPyRUE23g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYMojwxMLmroRlDKJiycM7S+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzViYWM0Zi1lMmM5LTQyYzctOGIwNy0yMzk3ZTQ0MjhjNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2wcarnve/k0Px0snXwSHUmjuregRm7WTdiHRHY+R9g4wG\n8ZWahr/hyDDcKad2cVi3NHQcDubCLj2a1dg6BgFko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDY1KULh0ioRmU5wsTZ/m0wtR\nSPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFeNZFoX1DR5bJPezYRi59oLUOKlncQ5xTVr84FEn+fUCIA9cXiO+uEKH\nIcV30lMNwvy7VSGDxKnAnurAhcZep71t\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZO0k0wR/VBxWmauCqHzZQtxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDVmZDY5MzYtMmVmZS00NDcyLTg5ZDAtODQ0YzBhNDA1OTU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjQ0YWZlZDEtMTQzOS00\nZWM0LThmODMtODNmMGZiMGQxZmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nT/pNvE5sPAPmF5k+lOhRFJyniUgnHHhMua/0VOro77p9U+cxRTyv1zlNAHMPiXgF\ncomCBcrFa+9H8c+YByC2mKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJvTW0NkCDzUOFXcU\nEcd0Hx1cOnYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgal6B3cxJfsunQqtsXQdfPs3x4sLq2sWU8kiimyAeJigCIQDi\nNJdERyi9uNiWR9gIq0UCK/YWh4l6PXSmQ5QQirlp4w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4055", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4055` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAVdXGIR+hohXs22kXAcOHuHJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MjY1YTgzLWNmNGUtNGJkOS04YzFlLWQzMWFiMmViYzYyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ1MjQ0MzYtNGEw\nMi00NTQwLWI2MWUtNDM2MDE2ZGY5OGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3yCNXde1jal7vBTHGaYKcNYFl3ObuWRtG7ESsYTKvnz38Avmw7skKdrMFipy\neysCJzbMlk7/nOFjHQJ8h1HqnqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBTeGKflqmY9SKuLsjMaP4pYyL5IwHwYDVR0j\nBBgwFoAUtUDm0vs0u8q9MJ90q9X4SG0ewzUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDdo1jxyFgNJm/gM7r2Jay6VfNa7b/G\nN0cuwdUIkMz8VQIhAPtHObkCIAXamxmtpBnd33wfkNN/W4eW33MsDmLjr0+j\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATpSyoDeKrSr7VWb4qRSs7G5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjI2NWE4My1jZjRlLTRiZDktOGMxZS1kMzFhYjJlYmM2MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQu7RkR3v1bs32pqBeztXEPIp4fcCZbvPhzCp+6IyjMPLj\naO9w6rQYCtpjbDwHFttl4HdLrSElgum4M4y+djw+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtUDm0vs0u8q9MJ90q9X4SG0e\nwzUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFaLclEl0Q4C/dsopK7pYr3tZWNGY9TVqqK+tcdcAx+8CIQC1XhttXjHA\n9hoHZ/nOZymPLzyQUfrh2dVuXXpcEzrv7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQvIDacqHkP5lWxX14BD6sBqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ1MjQ0MzYtNGEwMi00NTQwLWI2MWUtNDM2MDE2ZGY5OGQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzM2NzE4YjUtZWVkNy00\nODMwLTgzZjUtMTM2ZDhiYzc0N2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nw3YZ1LEZ+leG+yM6fC//6S2mHOnYeVAdqysPiFXJT/j7rhY32MAOvy1YrKL7iNQI\n+G8IXKR6PG9lcC/3Y7yBZqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBTeGKflqmY9SKuLs\njMaP4pYyL5IwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAIzVcdVX3r5SlLtv5UunttXrxzrm2QQnDhlHmGs5VUZ8AiBO\nX89VUXFyLSWihFgxMphGwOUNaBWbd77IM5xSXBXWgA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4056", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4056` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAVW0mUhSPUFwjl6ef7gFoFrBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4YjY1OTI4LTAyYjItNDRhMS1hNGU3LTBjNjJiNDdhNzk3OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDYzMWExMjgtODg1\nZS00YzNlLTlhODEtMGQ0MDlmODgzMTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFuK3WN/pXF0IqVF/FGPbhwOEQ32YgiV6SzMqkPg7z5Dpghr0CpTsc73eDBJn\nFpdvaGTU1NdfG+qv8hfWlbt4hKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8t22o0sVz/juIffhV7O55pPoqUkwHwYDVR0j\nBBgwFoAU5or+nO099Xr20fjqbzPXWN0ONZUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDyFdEc+R7DYVLpOYsLizszZq12Oxi2\nq388l9p6/BTuPQIhAJk4LS7CXSZBilzYJu8BYBlb5miqyqlr1xiA1n3yt4A+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ04E9zhMdA4trjNDq/QvybmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGI2NTkyOC0wMmIyLTQ0YTEtYTRlNy0wYzYyYjQ3YTc5NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0m1PO9X1zJyKFcZkXUWhtBim5KguyBuU7vndyUdKLrCG/\n7nIPVl6bJUTBlm0BCfBRzi4eA64p7TP7neRlGPrIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5or+nO099Xr20fjqbzPXWN0O\nNZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPn0KH3mcpMSCErF1sohE/CnwsanDFsdQYCHqZcZjPE4CICAuzoKUncHl\n+MoZMER9g58OP9LAkMe4NvZ/YuUu3OmZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAc3UFSakP0sPe6LUcQZ5WO0GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDYzMWExMjgtODg1ZS00YzNlLTlhODEtMGQ0MDlmODgzMTJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzA1MGYyZDEtMjE4Zi00\nZGE4LTg5OWItNDViYzhjNjZmY2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n08rlw+tzDXK876Kq/IgPnP2zBVbDr3YmbtAnCFZwfdL0QePcW+Rx69ZcOy/GDq7S\n0vXCoEKpwwqPifl7p7of8KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8t22o0sVz/juIffh\nV7O55pPoqUkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAIDuE7wlQ3u02LbGCgg5jF3dNM8iM/dYboVT2JRUHqNeAiAv\np+iqiLjTAmTZQ545Oly8pzAYMfR/XzER14GInbrJ3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4057", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4057` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAT1MW1J2M0RwZKM4dWjH9UQIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjYjNmYWJiLTJmZmItNGEwZi1iYTRkLWYzZGY2ODJiNmNjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJhNDc4MDgtNmQw\nYS00MjhkLThkNDItYTc4MDdkNDU2ZTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM3HYjvJh7vxZLb0yCTh0WLigJEjqJh/p4H1v/amn+OkhAv+sSb9AvBwiOGsc\nlsCMKtisSY87vXndZ/Aux0KAlqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCaTmAVDgJz7AXxy1EodUiUDsb2vMB8GA1UdIwQY\nMBaAFBrEZSmCLqMvtrtxd2mfMac5dCg5MAoGCCqGSM49BAMCA0kAMEYCIQCu5+a6\nCT6Jo062vuOvmWJNnrDE5B9hPseClaQC1WeZNgIhALFJtrDjkW7NZ1HP9wgDG+B1\nk9chPJwdCmNdFDy3nFCA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfnPXdISLwrZiMNIJ+4j/fuyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2IzZmFiYi0yZmZiLTRhMGYtYmE0ZC1mM2RmNjgyYjZjYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRvT/SUm6spY3OWNYSu2MTct7ifH6APSI6BKDJNUUSC3Gd\nCtyPmEk0lHdmcdWR5woKfjTfJkeWrE8WGDV6c5WJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGsRlKYIuoy+2u3F3aZ8xpzl0\nKDkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMBnsSY1nzmze/q348PYVOWkF4EeoNNP9HZA3fFMieV2AiBxKSTQeA3P\nW/t1Cnx5AWvHKIEyn8U4gsic/mLTFh+N8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARXH/K/Oe2ak+5FYDPgHPmM8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJhNDc4MDgtNmQwYS00MjhkLThkNDItYTc4MDdkNDU2ZTdlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzg5NmY0M2QtOWU5OC00\nZDNhLWE3MjctNmYxYjA3NTk0MjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/ZQVHwqtsJMUAW7tXFWRhj8vEdVSxITIt273OIZ4pIHb+SMBeiAYS0S/MlGQK2gj\nVUmdkeYqm45i52CdW8PVeqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJpOYBUOAnPsBfHLU\nSh1SJQOxva8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAN5p/U20Wohq86EVDFRXVx9pWqmYibVFJhQtlJRPKfXlAiBP\nm6GXC2w/Wq4nJfSEhv2HS2tNYEqyrKdiFkSN+ZMXMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4058", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4058` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAUStrLsEglPeOpxFDFC9NzVmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzMTA2MDUwLWI5ZWMtNDAyMi1iZjA3LWRhNTFlZjQxMzRkYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I3ZWM1ZjgtMjgy\nZC00NGFjLTlkMzgtYzZiZmZiMTA4MGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYrKWPX2cd8XyG1TI6J++C/LLWsmRQ7yFfCaPhS4mrbCkYDspUV1N3rf8goiD\nO+I42bA/jbMSQhD636kcST8XO6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAIrgtFHl4mpHWiwumN3HkBM9FOGMB8GA1UdIwQY\nMBaAFJDZbYdl07+L0IBM3F3iyy59nGXmMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBSfIwGeZU6EI2gBP5q45A5yJYUEZlHx7Lt\nK42EfmGXxAIgLK2Qqup0ngZ3NJchNqXrlPYJoiBeUng2yfDskCv1Pis=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQYzYProblbJeXHn00AgZhVaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzEwNjA1MC1iOWVjLTQwMjItYmYwNy1kYTUxZWY0MTM0ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZzqykaa9l81LRG6O3CyDslMx7HTGX6e2TkKQV1LkKtjd8\n3xATYUjjA8vySUEVNquywwC0BlO7s5ygC28ZJChOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkNlth2XTv4vQgEzcXeLLLn2c\nZeYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOkrFl5pUvat0JFXARMHPDxNGIBmLeUTiw3KIFiEdqf8CIQCLVzpb8HKj\ngR8R58hG75ErwAJdffvr9phEUbJtUOS6fA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAQ7l8YgrnCEqtfnYri329DgtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I3ZWM1ZjgtMjgyZC00NGFjLTlkMzgtYzZiZmZiMTA4MGY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmQ2ODdlNGItODNlMi00\nMmQ2LWEzMWUtYThjMDUzNzYwODJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nh08v47JMV62Kq4EeSLAUnJCC2YMKDIb31fzejBcBonCCkMX0UBIezsEWC42GeofJ\nK//37xCcRznL5BvHn1I3yqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAiuC0UeXiakdaLC6\nY3ceQEz0U4YwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhANQJBlNex8X76bXaNaiKIAfRdc2WKkiKXUeKgurO+dToAiEA\n8zoxGxhShtu0vVPa6iof+fpnJnTml4XUqHS6VYp6uU8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4059", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4059` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAU3nA4LDipgo7q4jlBokNmqJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwMzMzMzU3LWJiNzctNGU3Yi1iZjIwLWQ5NWNhMTYxOWViZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdjOGU2OWMtMjE5\nZS00ZDRjLWJiMTYtZmY1YmMxMmU5N2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElaYfaobbHcfR3SK6WcDmVUM7OWq01SLcG+khYyrDr1iZXWXGmrX+llCfV4gw\n95AF0pgew6ShVrKzzXAwPvepJ6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFB0NryubuIPyjgIzLHwAHLZmnuiMMB8GA1UdIwQY\nMBaAFCK4xfEyFmYS432rKcmPnja/I6SvMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAwbGokWAtf+0BnlkCKb2t7RyHkXSTU+MC\nsssG1NUvfT4CIEZ5X4O49dlzTj4Z1P0vZRpLwiETRYdSG5CPYUWcTFh5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASxHoaANLEuC59P3jwDQvEi1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDMzMzM1Ny1iYjc3LTRlN2ItYmYyMC1kOTVjYTE2MTllYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXSHs4XXq487toZLZOjVrI4POvzXrjwpeTZYOMhHDAkwDc\n19KJ/yKjhPhbCj0uVfOTwCbD/q/Bjunqtc4PnQvKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIrjF8TIWZhLjfaspyY+eNr8j\npK8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIIykL7z7NqqHbwxygVqi2O6X/+pBktFVbT2cnO7I+NMCIQCfTA2B5RWv\nGbM23NPDX8Wc1BTGLYsOIVaDXf6STEMqCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdGtjFA8NAH7m9ZZ1RtI0G74MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdjOGU2OWMtMjE5ZS00ZDRjLWJiMTYtZmY1YmMxMmU5N2YzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZThlNDYyMDQtMzU3Mi00\nMDUzLWE5OGEtNWZiNjliZmViNDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhkEn3kcn3yLbQwH9EgSRAXEygU9ctVqULE9VFByU4qQk13WjKaB4q+bGZ6LwVsqI\na82sSQdU2stDy7/ebbrcGaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHQ2vK5u4g/KOAjMs\nfAActmae6IwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgc3FoOporvMls0YgMEXsQA3izD0yt9yV8rBv7AAAsOhUCIQCd\n21UQIva9O6GjeWG7tJYOAuNLlSqNL7HBrrlrItmiPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4060", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4060` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWz9LkH6j/gTmNgu/aseDeMyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyY2E0NzcxLWUwMTEtNGZhMy1hNDJiLWYyZDk3M2ZlYmEwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODczMjg4NjAtODhj\nMC00MDUxLThjMDMtODA0MzY5Njc3Y2ExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI/j+5qBHFfiSOtiz040UZTadZZN0AbwlV35NwnXFB0D5mJ2KN4GTTlN7a6qu\nq44Oef79HxGoUFvBS4dxKY1Rt6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRRKqCyjymdkUb3OpZUeDi3aaaNyzAfBgNVHSME\nGDAWgBSr2x+cyJd5wcni7vkjhHGE6XgaljAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIALwD2MvXOyvT/BGhmEEYDdyVTrH7q/a\nclax5dcl92qaAiEAjxfmHtnnT6Qz7cUpWRAnE4RVENbdQ5lkIP7bK22IQtg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAexkPPQoms691FfMmq6zK1vzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmNhNDc3MS1lMDExLTRmYTMtYTQyYi1mMmQ5NzNmZWJhMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATImIcTy6OJD3I5U9zkluJL2FfjWvbDO37RA3yG9vFVHU2A\n09vaJ/JaZZ8JtNRM7K1694D9gp7EdRud7kw6OXI0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq9sfnMiXecHJ4u75I4RxhOl4\nGpYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ/iP2KDWC/+IDfwvU5aEmfeOlMTRiXiUF51oikXfGngCIE3uJd5p9hBQ\nxqxILzewHj0ZsIUyp++QqXD3WVj3LY4l\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAbBY+7nQwcC1QVG72vlTS08nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODczMjg4NjAtODhjMC00MDUxLThjMDMtODA0MzY5Njc3Y2ExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzc2YjMyNTctZTUzMi00\nNGEwLWI4MjgtNDlmNjcyNTQ2NDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7RZMSMjCqHdORMTDbXWSSknBm8w6ConU7jYtKtVxmY9hu/4uHDyELrgZC7O1Bttm\n/DoXM7khRgLomCkSCi5arqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUSqgso8pnZFG9zqW\nVHg4t2mmjcswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAKiYwFFXHeNNGWyCxtfA4EUUTkGuJEbR3m3FX/JZfmfVAiEA\ns/2w2clpl2WYmnuiuVudICunpA1VwkmIl6V9t4+yxso=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4061", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4061` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATMS7dwebNYBrww137a/2YtXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5YWE0MTA1LTRlMDItNDA1OC04M2I0LWEyZTM5ZWI1ODJiYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTE5MGExZmUtYjUy\nYS00OWMwLTg2YmQtZDdiNmMwNzc5ZGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXyllfASK4krttGjPfmSbnzg01txuaVpqakQSwEkcf4ZckEj+5tYkQUG1YA/7\nbconFUbWKnsu2a3TQfc8JXs53aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIkYXKP115tAw9hMjEkIXPATQq60wHwYDVR0j\nBBgwFoAUlVIIwVYrmsCr+/4nrtRtJmQes7swJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBTqrXaNvLc1sBi\nGEwJFQim5lvp1V5+TDhsJGVmmXXuiQIhAMlbiNz4CsEJuZlIxg1r7eaQQBZWAsV0\nxf6nZ+sOw123\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYdw65obXANwROsN7skYWUkyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWFhNDEwNS00ZTAyLTQwNTgtODNiNC1hMmUzOWViNTgyYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8/+ul3HVpSqx43QF6eATG7eUfqrraCMDR7qoTI2WcH3mO\ng75Hsqi6tfFXSG2pSGk7iENjwe6pmkLEfn0C8LMSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlVIIwVYrmsCr+/4nrtRtJmQe\ns7swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANmghZO/zbySmDvlvxGlkZGMGgorxJnwoPt+bAGmwszFAiAq8OgTAOj7\nwUxzuzaP01mei14LXb9cNjn01J64tBjrSQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAQp4NcaS/LuP//9zp4lQ+HfGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTE5MGExZmUtYjUyYS00OWMwLTg2YmQtZDdiNmMwNzc5ZGY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDIwM2EzNTUtMWE0YS00\nNDE3LWI0ZjMtYTU5YTY2ODFmZDk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAwOcRJ9tvXRwNSzt7vX8CsYfyWP+wK375FPSG+7pdwu2eucaQNfkXBPexQxXvwCN\nmtU5UFvYyYxH4RmtYJgfHKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIkYXKP115tAw9hMj\nEkIXPATQq60wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAPjXvrxs4o59LLMA5ZzZPP+Hv0gTUQJVVx3vl5GON80xAiEA\nhvDrkiQnPExf7tUG+TueIc4LbFDS2vXyt7J6GHu66t8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4062", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4062` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAaVe7kD0xrk9vf8gHriIQE9lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0MDVkOGJiLWM2NWMtNGNjMC05ZjhiLWMzOTU3ZWE4MjMzYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFmZjczMzktZDJk\nMy00ZGRlLWIzZGItZGFlOTBmMWE1NjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJXfN0GNmdC/xLhq+G1EjlabnuPmvIrwDLCKtBpDMrPZZy2py+btr/Kl/Ovfv\nG/vghgie75mFV3x00ughxDp+SKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIbB9NB5C2TJWDkm2sMIVaDCsgiQwHwYDVR0j\nBBgwFoAUzNKpzlMVw29cSiv2rY+q0NekByAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA0E4qcsA3I21W\nJ7+cyLcqc/qJTBohujlfE+8rs9cORKcCIQCFoEQzu6G/m/HosYyh7GoZzMMPO6SR\nr6JS5BHxm7/i0g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfUf/TZvePhcwpNs+dxDgIhgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDA1ZDhiYi1jNjVjLTRjYzAtOWY4Yi1jMzk1N2VhODIzM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARibVFwn+0M0GNfMhPx2D71TUxJuNrVBISuegGnoeuY1UUm\nX1r2qV9x9GED0hCV5UBiq+au2hRX9I1PYO0rRfceo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzNKpzlMVw29cSiv2rY+q0Nek\nByAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMEgAsbufiQ+LbXBrGiFoHB90+l1WvLR4p9cRasO2xfJAiAaB/qmzyX2\nxt4uuehhP+jONu/Ux5Vv1sgFrstHpCfrwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAUYQP8zkeIQwNPrcsUPfRrVyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFmZjczMzktZDJkMy00ZGRlLWIzZGItZGFlOTBmMWE1NjY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDY4Mzc0NzItMmJlYS00\nMzM2LTg2ZTEtMGU0YTU1M2MyNDEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzvx+noOZY8w/rU/E2USirO9iworRpGvAoSQ5Fv33zJK/Lshk0wJCQi1FB5eQROuc\nee4fanKCuCmOMOodiMWm8aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIbB9NB5C2TJWDkm2\nsMIVaDCsgiQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgdMmZxSTqQ3DU41iJs56rT5l/CMFoh7x/TL/hW2V4yC8CIEF6\nqmQVh7HbYtoYzttsm6oPTSFaozHz3FsNcIYfzpcg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4063", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4063` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAcXNejv+FVIBW3cTPdyFqap/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1NzFjZTYzLTUxYzItNDlkZC1hNDBkLTY5OGFkMmRhNDQwZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZmZmNhODEtYzU5\nNi00NWE3LWIwYjktZDQ4MTliZjM4ZGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERQbyQtveqfHBYqAMTe+eQ4YmNhfNqafnsai41t64Dy9n10hPYAs3UdCP115r\nv4OCu4lIjnEJCMUGLh5QlCweCaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpfW7Lil9r5MewG+rp7Y6IbTtV9YwHwYDVR0j\nBBgwFoAUq681NT9zh7ZpoW6R+vT9Wy1LTIswIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAgei3HCK0bQwzHONoj0u5\nAKc83qLcYaWAKn0wfSZcXEoCIQCAAHyE8WUExJSPMV8fVF4YhH+iDQQs87hDBYoI\npg4/dA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWbfRq8SGj+MbzupAQ0dzsShMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTcxY2U2My01MWMyLTQ5ZGQtYTQwZC02OThhZDJkYTQ0MGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiwFlKj9UMcD9meyXf8CsUMeRmf6+WnXTxO9ry5naOEXFt\nrC1J1GfEc1zwxxEyDMJVGeN7psccPNBy/9IIJRaEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq681NT9zh7ZpoW6R+vT9Wy1L\nTIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANInclQiqKYTW+EYMeuq+Yjs9jXu02Wpo5ekZBw9Uxn+AiBmtJwpN6ry\nb3gn3NXWcIjSNASpUmnfzWL+hPOUxusELQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAU8pC75CcoiWy0uc/BxSVgLBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZmZmNhODEtYzU5Ni00NWE3LWIwYjktZDQ4MTliZjM4ZGFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmU5NjhmZGQtNzg5OS00\nMzQzLWJmNDgtOGVjY2RjMTUxN2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGk9DC+Hlg1aNTLxl+A+rYwzc2Rcz5NB7tYO9bvDtQ+kk7abFTz7k6gBauEfzi0Wi\nbwj/hsAFXqEwgDzqqMRzXKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpfW7Lil9r5MewG+r\np7Y6IbTtV9YwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgRoBOXP5hgpCe2CyXV4xzMi3nBKv0Rg9Gzmj0PMx3ouQCIEI1\n8czsBVSYoenv3pCKtr0Y+WpFVh/it55R+BOLvtif\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4064", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4064` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAR8ojm7iSZLV2Mvxued2LTGeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmZDA1M2RmLWFiYjQtNDdhYi04MzVlLTRlYWIxZmJkMWUxMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVlYzI0YTYtM2Ey\nNS00Y2U2LWFhMWYtZDNkZGY2ZTA5ZDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKu0gGn5kLVWx4HsBPWHky56sR2VEZzecfoYWcEnkJqMAT296ENHU9zON7bqD\nIXb6OyttLbrq/04fn8hF8muMEqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU81YW/7Sy+7cHNGzdxbdNu4UnW3gwHwYDVR0j\nBBgwFoAUggJHN1eogwtf39HE3FXWbG7PR9UwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAsNRm\nEDwYhhTD3nlUT/JqZmETLS34GBCA5Tk5usmVcBoCIBeeY10CPMw7RQLAuZilI+qB\nHlEu28xlu9Jr3KXgBWdx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe6ppXHv5B1YDaDMshNsNPM6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmQwNTNkZi1hYmI0LTQ3YWItODM1ZS00ZWFiMWZiZDFlMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASp8I5jie2YFtTq1vKeHEaBrALSfchokshm5PhSwaYks9MI\npzZOY7ACZItuFZDznoKMPS1S2tcklvccfJrKBz1jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUggJHN1eogwtf39HE3FXWbG7P\nR9UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJr67R9fyNso8LWlmCyIDtkWQ8Acv3R3VCgyVfUf2ZB8CIQDCXGb6JWTG\n51D9yWr8R32tfcTkIiV2wNAYul+GUBYlQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAXM6UhwSO82vLEBZrIlelCc2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVlYzI0YTYtM2EyNS00Y2U2LWFhMWYtZDNkZGY2ZTA5ZDcyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjI4YmE2NjYtNmM2Yi00\nNzczLWExNGEtZjBjMzM3ZDVlMGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxKvyRO2LZX7xcLpXS242dqdVaZvZLiFmj2hsU8UmDJ1gEFY39JVFz5mxlTNXLgUv\nHZAlfKyQuOIodps8mgO78qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU81YW/7Sy+7cHNGzd\nxbdNu4UnW3gwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAOfUWC0A84kDuuSog9Nm5HUfSS/ZMxO8Gh5vu2T84dksAiEA\nu5gnKeyKNf0KGVQ8vQ6/csk8Hf646f/SXoCkHlUeRTY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4065", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4065` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAVSPFQf1HEtZ2TrBmUbdtcXhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhMzkzZjllLWIyMDQtNDlkZS1hOGE1LWNiNzVjMmIwMTc5MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ3N2QyN2QtZGRh\nMS00NjU1LWJkN2YtYzNiMTc5YWUwNmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA6QBppXn8HU32NppMKZdGLfEQmIvkWSWNOtQA5zh+V52JJTRwRK9ZFUfLH/7\ncUzgK+51DIUKD8cdu8/j4E9CAKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJDio/LwmXZxIN8zt58xZiB6WRD8wHwYDVR0j\nBBgwFoAUyFbLQ8Ymy0sbQ7oLOWuTmcruQ7cwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA3eUX\nH8a2T+lvL/QdQK1E6bRNy1YcpA5VayOXXoiVBxUCIQC4v1BTYEAGakVabqfEfOs7\nwESPjj2/FtGCTZ8vDRaQQA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfwCRzdP2K1kU4JsOqBoG1ckMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTM5M2Y5ZS1iMjA0LTQ5ZGUtYThhNS1jYjc1YzJiMDE3OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKlBBCavioqa7eBuqiI/vy+u6dpVoLPmKhMqRUlQMhYaV2\nujSlVsz6mcYDEOiTLvDd3PYr/f7qptY9ABOqqf/vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyFbLQ8Ymy0sbQ7oLOWuTmcru\nQ7cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAObtzo7aTeGyEIg16L9K6o4NGocigyqViErtJGUtdDH7AiEA/aPhQTpX\nT48vunkyEKTBHM9fFQ/R7inzEZJXAr2S0HI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZcnyAr7j4X4tcGnpLWFqeeoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ3N2QyN2QtZGRhMS00NjU1LWJkN2YtYzNiMTc5YWUwNmQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDI1M2JlNjYtMTY5Ni00\nYzYxLWEzYzAtY2RkMjc5NGZhNjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nL7Sb9Yi6ZR/DTfYZeYaJZnAlLPfY1B9ZnrV6K2UkNt8pOyS+nG/UpuMF6Z6V/JsW\nCVxJe1pTiiqqTQxPLDDnHaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJDio/LwmXZxIN8zt\n58xZiB6WRD8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhALk1GpLFkm4fTiOyI0xlTB0/8ihSAm3qrJW6oHO8VJpHAiBX\nqOt0r2DF3pp9h05vQOJ5UawHYgE+5IJIYfSM5uBimg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4066", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4066` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfg6EXIWswEQKUWYOgGmbOQ+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1NDk4MjdlLWM1MDUtNGQ1OS04ZjRjLWY4ODhhMGM5MzAzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE2NGUxNGYtOWQz\nYy00ZWFiLTk5MzYtN2NhMGUwMzRiNWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiNSvSyv6WepcvYFmPE+5Mav3Qqtwv8xZTNgVw0uApaT4cpt9ABiPdygvToMq\nE9+d5MGsugOpdm5ViKXFTy12kKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPH3ERCJKgm/l09CmMkXZ2V4XCY2MB8GA1UdIwQY\nMBaAFCjwLFp4O7S4jRg+TVZqzLmKArvtMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAgn0KD9lWHBzBGYGdnNgCXqTXo/LULmDf\nGsjj2WRCFKoCIF4t6KsrjrrcoXoZXSX+lT0WejMDneWmKIedeYX0iio0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVGKGBhqUtT6tVlnPCwJ67E0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTQ5ODI3ZS1jNTA1LTRkNTktOGY0Yy1mODg4YTBjOTMwMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR02mCdfJcuWzHmV4+msAL38MNSI7ywbu0/ek/PXEabnzmG\nQ3aF2QVSY/GBQFm6GwQebW6gsklWPMiBZJPmzjjmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKPAsWng7tLiNGD5NVmrMuYoC\nu+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM3WqA7joNHFUx0okAOGz6n7D/ZULMsiQEFzEY4Kd2fQAiB/3TxLOdWE\n8q5BVvWBDQqv+duFyRAvo35wP/53G+qoNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARX09lF2kxiijiZWNHdsjfZCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE2NGUxNGYtOWQzYy00ZWFiLTk5MzYtN2NhMGUwMzRiNWUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmViYTIzZTctMmQzZS00\nNmQxLWIwMGMtYmNmNTUwMGU4NzcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7JdG6TIP/Pcv7CoZ6rVNkTJ9MT6nd9dW4ON9ZfTSm4HC5Fcr4kWCIcIP/b++BNEb\na+OCUWhg0+tolfyiEe3fi6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8fcREIkqCb+XT0KY\nyRdnZXhcJjYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgUIlxp65ePno3NvUzTIflY+A0hbtlTOvJXjRNQlaXArUCIQDP\n7wVShANajIhJsH1yNP672tKzcsH/NnJb6LKg0KMNJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4067", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4067` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAeJ8U34sg8zRMYZWGjk0nQbyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ZTJiNzc1LWM1MTQtNDU3OS04MDU0LWNjZDE5YWQ2Mzg1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDExZDc5MzctNTBj\nYi00MmRkLWI4NDAtMWVmMzk4NmI5YWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExb60hz61yzec1r7G2ADmjF/jRK/6iTMOsXS9J0nNmO5om+pd2neeXMb7bHjJ\npPLuvw+So3k25U4/kUNw+FCgAqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3E9hXXySR6uaW3cJpsuj5LidqtQwHwYDVR0j\nBBgwFoAUX2mr5WRRwDDriIzHhfInIjOun7IwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOnOE+pFTYA0\nfkczhCGtkKoR7YPtdMv4hY17cs8JYmgIAiBnXM5Z7gOpCZzcmwnBIUFRBJIFjjXK\n8a3S4O28CKXc8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb25d/OKJy4C8jOon95TqVJQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGUyYjc3NS1jNTE0LTQ1NzktODA1NC1jY2QxOWFkNjM4NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKD35//SYEEDxmkQokmQnrOljco422IL75i5dH+qg524xI\nqZX5a0mxQIbFV/+VUDl8UDFs3M6kfTAeXW5er+r9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX2mr5WRRwDDriIzHhfInIjOu\nn7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdqN8nnNvlPDmTXA2qD1fIBpVj/vDNTT1YcZhAOxTJ4oCIQCGZ5wBTesh\njICknCuREIVQbMmmrwuQ4Q3OJHs3jPtwdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAT5LYLRZXxHE/tbPmBWfDtgbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDExZDc5MzctNTBjYi00MmRkLWI4NDAtMWVmMzk4NmI5YWY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODkzZjEwYzQtZmFhYi00\nMjU4LTg3ZjAtYTFlNDc0ZDJiYTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLMb/LJkHlEStMVzJb+ZwvVeZvFY/oAn4GVHCankzoPCq0zbzy9SGzH/ZYILhHshD\nlrH5PVKCtPRn+XMwiJTDcKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3E9hXXySR6uaW3cJ\npsuj5LidqtQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgIOplX43uzH8jKv1+gXRO2NiP8O+BjW++UXJoqSvpUjECIQDz\nxqOY0C5FoIwwD41xONmPr1irQyK/BGelN5Q0v1/SUQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4068", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4068` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAcH9Ij/NtaTqaNmgj2OkgHlmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZDEwMDdkLWIyZjItNGNhMS1hYmYwLTYzNTU0ZjdiZmRkMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdhN2JiNjAtZDMy\nZi00YTk5LTk4YTAtNGQ3YzJjYzhjYjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi69tM/WiPpuwjTdtrqdyohtMd9Ax5nBo2EjtMvySv4q4NXb7vl/Y+cUrWHiX\nYE++oYAQBHMqd9Fj4QGnozTjSaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfMIYNA1R3euMCE0ofpweX3IuksswHwYDVR0j\nBBgwFoAUz0uN9PMJZmICdCcLAsWCzsH++DYwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgGZoxTIDlpEkN\ny6gPBQ0+lgIP+O+CfDsIcaXdK3OTA8ECIQDhDO+VVswZmHE7u9mFpvOASMPj7jkV\n3v2IgBXgPwkFMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe3L0cshAMoNOCy70WVTR9M9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmQxMDA3ZC1iMmYyLTRjYTEtYWJmMC02MzU1NGY3YmZkZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgE/FuVaFq1PRxbe5catagT4W1BfzpP5Osy0IM3DJxtENx\nqEzhLhc01PtYPft0Z0huMav+ef/NA4pMu+tGTIHYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz0uN9PMJZmICdCcLAsWCzsH+\n+DYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOZ+OfkDyzsCQEYGyEHYEm114YLYz/wFarMyZoOKlMghAiEAgMMs/r+z\nCmTYzue6S4XL7AMYjBcDJuAYUf0R3P8qItE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAVLQGmxMwoO/4W74uTDeikrVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdhN2JiNjAtZDMyZi00YTk5LTk4YTAtNGQ3YzJjYzhjYjE2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTBmMTNlOWMtY2QxYi00\nMjJkLWI3NDEtNWU3ZWVlZjljYThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOWwhvkLK/IbW/PIn6wEUhxpuPx1Qvxgf6sDQMZVXqrNZgFMzdvs0KgW6J81mkG2A\nEOjtvhwjTZXJep85p2XXFKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfMIYNA1R3euMCE0o\nfpweX3IuksswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgPO1qFb3E01y3GPflcoLvtflSM8sKEW7sVwrcSKDii2ACIQCA\n8zHquPw8v7x6NbG+GOLCYGWX5CkyuhM/+IS1aynZIw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4069", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4069` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXLO4UWv8IWhYxQvmkcNNPRhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1OGI4MDk4LWM4MGYtNDMzZS1iODY1LTgwNDM0OTdjY2EwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQzODQ4Y2ItZjky\nZi00OTFkLTk0N2EtNWY4ZjM5YTRkNTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ed17jRuyxF1EFKmWoj0gLJy/pb0X1bOi3v6PR6pvTKdTE2YgAD4d3En/sd5\nlXcNejzQj6sRBO/jH6tGE272EaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwccH1JsRtcrpyM1stF9w6l4tHYIwHwYDVR0j\nBBgwFoAURwa88a1/yrtJeJycPQVrzD7rH4UwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD1p817FMYJ\nJK7A1dXZydMZ6lHhEVA47wqv7QG6fjf9TQIgNfa+h0F+R8b4zPCja+15UFt0icHI\ncEy2WtxvZYCFZDo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUa0s8nadfOpH+LAFJV8GNTrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNThiODA5OC1jODBmLTQzM2UtYjg2NS04MDQzNDk3Y2NhMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaY6IYqxKkjxXGvLzbboX0bGCbp2DKEbLfijljV7xFmC8L\nvt2KM9tAq6HmuHKH2Bgwie8uueTzB1uFlpdFy3tho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURwa88a1/yrtJeJycPQVrzD7r\nH4UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPPvLA7Q6Gwi8Cotj2vY2ze1rLJq2119R4/1RnDXLk4JAiEAn9oFmlyd\n0VJjpDbh6doP0r9iXAj7Li7tJUEXPDJOQ9s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAXdBMrEeXKCqUOw3MCEUZ/bkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQzODQ4Y2ItZjkyZi00OTFkLTk0N2EtNWY4ZjM5YTRkNTY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTVhMWViOGQtMTJjZS00\nZjM1LTkyZDItNDc3Mzk3NDlmYWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\naOrX7/68f8bSLeqfB3GXPGfVyN3QH04SHpMe54OX48UuAwzCihc97KVNFl7VW2h/\nDtE1WwIzSr0SyW1Z6nIBDqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwccH1JsRtcrpyM1s\ntF9w6l4tHYIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIJ8U61eQN9lOaGIVh1StTR/oSZt0zrmo6uaXkWuDK1/AiEA\n8RMvZrTQzptspTvxK3p2HdNCjBsIiecsZaV0iH1HMP4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4070", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4070` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQZizyM/qKJk7kCXGJhUj7Y8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxNjFhZmVlLTE5MzctNGIyNy1hN2Q4LWNmZjJiYmFjZTE1ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQwN2FiZWQtYjE3\nNi00NjdjLWIxOWUtNjY0YjVlNmI0OTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESshmhVGRtp2seMGLaEqRygnGLoCSMJTpKhHR5tvbTECECMsNaygXCz+Pg4pj\nu/tm/UEcyO/IVG//L81jMo7N2KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8zj6B3HEJ5wVurzxdh3shcMfY3gwHwYDVR0j\nBBgwFoAU43adZfYb70wgsijbBUD+lt3DZGgwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAw6n4GVUPivZ7lkocQOoU/0HMl48RoKCqmvguPdO1qiAiBojWHuxpObg/TK\n7y2wXEZGcbenMng+QNiA9Taw718XwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV615WxTPzbwsrUft6MwhW4vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTYxYWZlZS0xOTM3LTRiMjctYTdkOC1jZmYyYmJhY2UxNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3dSPYDE5vHLQKtJRt1wyPBCpoTbs8SpcUZIKAx6/iGent\nMM0OFG9109F3bTPQ+CZQ6lHzga24Us4VH3UMSqAdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU43adZfYb70wgsijbBUD+lt3D\nZGgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKEq4SM1q4Z6zVKIfhJHKIx0ZV5Q1c7aUXRAmpXjDn6yAiEArvm3V9YQ\n2wHn1YHBvBCEqQS5o6OQ8Nza88ZQp48sFBI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARwW68NPrdSCXtdz7w8R+tZjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQwN2FiZWQtYjE3Ni00NjdjLWIxOWUtNjY0YjVlNmI0OTU2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTQyY2I0ZmItMTIyMS00\nZTBmLTgwNGMtNzJhZDIyZGVkYTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCQkmqYxKTG943J/4Z6nmG1wXRZSycNbcFhmK4wc9FJ89XGUCmo2+5iMuu2w5IUsZ\nKfdlD+FwWsXM4UlnIBCIUqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8zj6B3HEJ5wVurzx\ndh3shcMfY3gwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAIdXLn7wJHrnl6ENZNLiFO2Cp4PPiFEgbLfgPSxobz1rAiBi\nV6mb6gZyl8ueye5X3cWgsTEnFOHVdz7xyomWceDvhQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4071", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4071` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdbw5p6nvXA5lLiJWSdM8tYMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhOTIwNTc4LTAyMjgtNGZlMy1hZDFhLTE0MGUwYWRkMjIzZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdkNmZjMDQtOWNj\nNy00OTViLTg0Y2QtYzM0NTdiZWMxNWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhmLt45hTrXAR0cJv7chyA8ANMmeqlxT23DhvBntD7tckg25al0rs/sXAQft/\nzmdVP1ACL8Md8J/K+rotgL5a5qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1aUfhbLfzvu+YWG7yVjVslmXP/MwHwYDVR0j\nBBgwFoAUQHSBhz5+TZ5VXtJYiWr5z6zcw40wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCz9GSJGfVx3d5gaU3a+ihqNBIXvapkalW858wHrJB06AIgSpDjFfDDM6fh\nwjIYg1P4oF73Iale3sPFhtYiz0GwEIU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcO8RWdUdUHYP4dpJqYeZnxRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTkyMDU3OC0wMjI4LTRmZTMtYWQxYS0xNDBlMGFkZDIyM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZ2r0+ewIVAzziIGU9+ARKYKRv33QGFuiNummX9CJglSie\nGFCsevXZX4YMg4lT1Q70maVgWWWgoFHxkB22uxuJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQHSBhz5+TZ5VXtJYiWr5z6zc\nw40wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIvZPapBcUso/TBFM6qtYHYUhSL76Dl+J+cI2Fum1KbwAiBDjbPyilbD\nP0+Sbebz/wd4HWRuD7WIQ10OHULfD5jplA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZlshvF5NN7NQ4cJ3+4roe5aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdkNmZjMDQtOWNjNy00OTViLTg0Y2QtYzM0NTdiZWMxNWRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTJjYjlmYWEtOWE0NS00\nOWFmLWIxOGEtZGYzNmJiZDc1MmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvNlvCv4j5GkQOjg3aXlYij4Zj8kxGuH6Hiw8YIknpytavx/Pcl602DQc8Nw7YX9l\nGtv3eJuwkJcvU0rMHFcqo6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1aUfhbLfzvu+YWG7\nyVjVslmXP/MwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhANJ1KAL7XeTvurN5s0NPuFUA7DVTStNbJbKZLZB4eaMaAiA6\nTDicpk5hgGfLM0sU4is85xVeskXuXi4Kuhx4yRO/dQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4072", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4072` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAdIcfivsHTzu2nlrKfWj0/P9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1ZTU3NWMxLTM0ZjItNDI2My05NmY5LTEyYTVlNDFjNWFhMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY5OGFmMWQtOGUy\nMS00Y2FkLWE3NjktZDVlYjcwOGEwMDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZv505IDvPmKrNhCwcZWwwey2eUniBHht64vwFvKI18MfOOfhvqrR4kfBj1Xz\nAI21aBuYeJ8QbXlvE8bWchgzpKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF4/NRvn9s8VK+IwLFPx20JR0Bh4wHwYDVR0j\nBBgwFoAUHCvUkf7e1Uu3fLHiSuA3pq8UzGYwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC7\nkliH/J6WAOg6/cHIAc7aUxeEgns7eBpOPssp37I70AIhALZst5tHC64UD5giCSTX\nxsv+WT1UUwSpJsOaZDvKs9v7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbu/TCR4fRPTZ/KavStWFcSaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWU1NzVjMS0zNGYyLTQyNjMtOTZmOS0xMmE1ZTQxYzVhYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcis3bRRBeqd1teTUYmITDasTLZU6DwG/v6AucJ+t+2+sa\n4bFDIFaSRo/Zo06sL2L652+jeYDz9VKbyDYQ4FxVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHCvUkf7e1Uu3fLHiSuA3pq8U\nzGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO/yyo0bhdQ0q8s1BBUAIFy1T9ZQozR6zh5xuIrjj3yIAiAI/i20z+FR\nSiJrUCFO0mbuEuO/Xc+/UTmXVuxRi9q2hQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAfBe6GIJaba6wgPbc0j2czo+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY5OGFmMWQtOGUyMS00Y2FkLWE3NjktZDVlYjcwOGEwMDkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGNkYzVmNzctZGVkMC00\nMWQ1LThiNTQtNmE0Mzc5OTFiMmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nev3G+OfOmPH9wg8G06Q1FOA86OF10fX9dGZPto6fE2/C6gCggdToNyVXAuB6Sa3w\nHv9gAYuHY9gPq6gSdlIwyqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUF4/NRvn9s8VK+IwL\nFPx20JR0Bh4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgaI4tGaOhMxAUacozwk1CQY+WXkJCpD1Zsqk0FIzvzuYCICPR\nrOvVVTBSjvOyIc7Z8kJMLcro/ZdnPUTm/y7jq8Jk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4073", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4073` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAd/YENv0d/QITnYDxqbCPsNeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZDVmZmJlLTEzYzMtNGU3Yy04NjNhLTY0OGFmNmMyYzM1MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NmOTkzOGQtNWNi\nNC00YWZlLWIwZWMtYjBmMDk1YjE3OTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ5K3yBfCDBUzpiXvd+Z2xKfR1GfLP7vwx4M0AA3cY+zTbPkOTGMVHGy6XQ/r\nUcGxUgIvSkG4jPb1sq/R3cgnWqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp3ZduO4bNOmeD5HRSJR7KPftStEwHwYDVR0j\nBBgwFoAU7G6oHUupw54/+r+4rzbGH7DYoI8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIAZxYnQk/oq5Ff4sInu/LLqHCJ8s/352ZOZhgpiv0VysAiBknnGY\nz50hC1xWUmraVUQWn/Hbz8TcK29TfjVPz2ApWA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZmkDai8d7dW33/18Vaeqi6zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGQ1ZmZiZS0xM2MzLTRlN2MtODYzYS02NDhhZjZjMmMzNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW8liflJm0C0EfRGONBX9oFI++CuSeGBYWhUuQEK4dOPrr\nnoMkXfIMvF0l6YA7TsB1zbju1KKbCcfO84pEkkJIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7G6oHUupw54/+r+4rzbGH7DY\noI8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJAOnm7HJF+uqwL0N39bo32tvjmXgGpBDqUV9XfVR/SmAiEAmsfbv+iG\n3W5dfzrK1x7DV1ulZoPuU42BKlnO3tzcXmE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAVY7Bq7DiYqSWWhqjjZ1niQQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NmOTkzOGQtNWNiNC00YWZlLWIwZWMtYjBmMDk1YjE3OTI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzM2MzhmYzctNjlkMS00\nMGZjLWIwMjQtN2M4ZmM0N2M3ODVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nw6kyqJMWSa9XPRNx6lpzldy+C45I9H7GqEr/lUQV5/YdYOmaPjB2yybIRp4XKhsH\n9kV0ZyeOBRQQPsscDA9da6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUp3ZduO4bNOmeD5HR\nSJR7KPftStEwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgXeP/sWr37vt45P3LMMN2wfsHplgTBa180VhABATuky8CIAHR\nqriby0GtkScliGNjzZzBnI0uGxVSkC9iIMbTRMxl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4074", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4074` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAZPK8iX3lMRMTL4KexrgahsKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZWE3MGMxLWRlMDItNGJkMi05NzRhLTE3NTUwMzgxN2VkNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY0M2I5M2MtNjA2\nZi00N2UyLWJjODAtMTM2ZDFhYzRhZDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERm+WvMmSqSn3kV/PoPjRTe1fzZx74019Nz7QA/uZ3pC/ccivsv+jW/nrqdeK\ncI8jv5nsUA91XtpoZNUEnrG03aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1rD60KlSVzMrWXJpjU5Y6sBP6S0wHwYDVR0j\nBBgwFoAUeX2RFi250ME3+T0SWDN5dgZLaRkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDHTekowtW4870W4Lxjzr2zyxcdNoihojA9AHsOFUh0IAIhAMKm\ngTuzzsoqkI3KAmIr7MPM+mCUWcfad3p7QJ0LwZm0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWDxj1F1gwBcqbJfQl4ols05MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWVhNzBjMS1kZTAyLTRiZDItOTc0YS0xNzU1MDM4MTdlZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQraSZMkgKoaWXtY8HQljzqu+FprkNWr4zRTfWtnBCo33Dl\nFVt1sJovfXPUwYIQqckUf7OUjOIKshUbQbPaCN0Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeX2RFi250ME3+T0SWDN5dgZL\naRkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbxmOYo3zF+91g1JEnMiUO3NzPDGcAxMtzly2ok6gGOkCIBBBexz2mr1p\nV3Sn9CcpSDQYaUw49ATR8uC5m8j/C1cu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAcoJY1Jkl2ZzORdfXUjW6q14MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY0M2I5M2MtNjA2Zi00N2UyLWJjODAtMTM2ZDFhYzRhZDI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2RkNWNiODUtYzcwMy00\nMzk3LWI5OTAtYTlmZDgzZWYzZGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncojZFJa6l0Yp5okLwrrdB07ULTah1wcbGYpzcNDH1YCcQ8gUVL7+CxL1geFKMu4E\nspIM1TKk+b9xBaEweC6NGqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1rD60KlSVzMrWXJp\njU5Y6sBP6S0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgNOzFEgd4mrrzw+QlbLzsurHKiMrm9KJFd/1akcdE+uUCIDmH\nFWBcNPhN4cSxE7ASUMmhmFyXwtHDBdWd1oHmV3oZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4075", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4075` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAStw2NfIBSuP68R95mHvu9ZuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0ZWUwZTkyLTQ3YjQtNDhmNS1iOTY3LTBiY2FhNTQzMjY1MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ1NDI4MTctNzVl\nYy00NmQwLWE1YzYtMTYzZmI3MWIyYTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECg1USIu4kr1r6TMyMi5EoEVSoikjkhpUb/hCuTAG+rDJdX9flMePoemt7+JJ\nwus7ynOUJrxWLj4lkcLJDQlN8qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDuShkkUWOFRTYj1i2ZjUUiJvismMB8GA1UdIwQY\nMBaAFCXuqZLQZbnSxsh4rEjQmZpow62rMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBVpiz3yxv/W+Mce6zBb0KF1uIMO5zkvwQJ\nkQjbDi3zswIgcjkS7pvtJzmA5we4NZS20/++F3LXkswn8yBCMKDH74I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcn6ypzRCPuKchTzkqyQAgTiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGVlMGU5Mi00N2I0LTQ4ZjUtYjk2Ny0wYmNhYTU0MzI2NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5sryBHEJ8fbzd3R1OnyT9JLDj7VqJA3eN3RjRFfM4lEBJ\nzI4be9Zm2CpghbJAHcPUpdHH08C+QR/3M0eyKBD2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJe6pktBludLGyHisSNCZmmjD\nraswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNIgIjWpJogt3cPxyJIvueTiTpoRNzCmIHEVjYLjnUtACIFRowKR/1l+U\n0v20X7X5CWPC3Y9WepwZR0cdFt3ELomk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAUY/ymzpdRP+/YjOCgJ/s5tGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ1NDI4MTctNzVlYy00NmQwLWE1YzYtMTYzZmI3MWIyYTNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGM5MzAwZTQtNmVjYi00\nOTAyLWJlOGYtNjgxODJhMGJjOGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntkVmu7gpIzXKfkm0Ue426a6VY2uwq/cEgUjJTXt0imTCMDTgUjX3yTL+DOopORDC\n0vAdfJN3Z9iUN2+eq0c6X6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUO5KGSRRY4VFNiPWL\nZmNRSIm+KyYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgAWSgexrlP/MTz28yNDsPWXpOb/7KERWdEFETi8/3otwCIAsA\nEsYdHbfU68nu/k0EHBz98URzIeDEP6rjRU2y5Y5u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4076", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4076` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAdnB32QDUV/dnrWN5P9nHww4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0MWI1NWJiLTY1OWMtNGZmOC05YzBkLTQzNzA1OTIyNjExYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I3NjQxYzMtZGM3\nZi00MTZmLWFkNGUtYjU2YmQ2OWM4YmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQODYhyzPfsTOBATYMY1ooY16Bin0QEYzLJQTXpqlF2rE2K4bg2YI5W9x6i71\n9O97LqtPNrydPQiHgeufEA6IrqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUso8QUebor+DnsK4SllXdp74gBkswHwYDVR0j\nBBgwFoAUt8B1WG3Qq44nBnibBb0tqNPVCqswKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgP3zbw6oAVsL1\n1/+IWgdTyK1Hkbt9s+pAveJj7Lka6iwCIGNecto7P0B5QkwRU7kvC4CAv45YCUvt\nGH7oqn/4zUz/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY4fluAOkpVlOuNx6vd1n/C5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDFiNTViYi02NTljLTRmZjgtOWMwZC00MzcwNTkyMjYxMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQmcBmaO2Phg2eTBZNbg4he122tMYsKMBDdpqTZiDAv5F+\nf0HHfd4bwgt47xOSBUDkzrV6xlHOJ7bL8I6O+2Coo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt8B1WG3Qq44nBnibBb0tqNPV\nCqswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfKY7Popd87VHFqt4T89swQ3T4EA/QV9wb4DX7RWUfJACIQCAezXBF0c2\nJCuBzNFlEp5ZnBjddPoIgwh0jY1O+wwm8w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAXjXEtHScPVmTSOxFudmsSGeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I3NjQxYzMtZGM3Zi00MTZmLWFkNGUtYjU2YmQ2OWM4YmU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGVmNGRhNWItZmMxZC00\nNTc4LTg3N2UtNzgwOGIyMTE1ZDY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nnpAHoylNajgUzVp2WfC8nAPesiFmx1EaqCxd6ETM+vOyF5MU7vEgVYNLkDKJeyyc\nnHI4ugtPGzWm/etOnND9iaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUso8QUebor+DnsK4S\nllXdp74gBkswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAPAKM2ZQawn78qwb8cZxf4kayBar4c4gi1iI+P/zTsuuAiEA\ntHMRv9noScegOaT/W+BRskF+Gds2rZG8uBk/oyFksvk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4077", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4077` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASer4BFXKaMlXRwGJC2BG1eGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjYzFjNTJkLTY4NWMtNDEzOC04M2EwLWY3OTc5ODY4ZmZmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmIzOWI5MDItNDQ3\nNS00MzgxLTkxOTYtNGQ0MDQxZGI3YzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF+gUX/D5UL1kyh5StUEiUGuUteMyeq3JSRf+kAk05tGYQ/BvpxBF604vqQPB\nIyiTUq7kPnZy76Lvb03XjnH1uaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzMnTHtdfKjylEB5sCoT6qIR05+wwHwYDVR0j\nBBgwFoAUG66G0ouXua4BKVCXrtvXVpZWU50wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgVHHNSkAMDUj5\ncL2ztHwQnNVsLT0WseSPdpLNxe5UgnoCIQD+fGUZdh5LbqEF5tTXAc6m+SmoP/Eh\nRJVydolWvoN+ow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbUJ9eNumCeMt0a6ioNtWH3yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2MxYzUyZC02ODVjLTQxMzgtODNhMC1mNzk3OTg2OGZmZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq0D1WACYtBfS876kFkoDYXgnLtRZqr9QMqbModSR3azJ0\nM5gh/9TeIzcC27ZDqpoe4YppUkP/MPmIKNhCXiWbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG66G0ouXua4BKVCXrtvXVpZW\nU50wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRjxlH1bB8MJyv9MPrg12kzZr+S43InWBXOCYEbHzZFgCIQDXPQZF0vY+\nOrLaRUf+Z+cInt+Ii8IMQyVsuLycqrCXFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAc6sw48N0g+1jBDUHRG+Gm+VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmIzOWI5MDItNDQ3NS00MzgxLTkxOTYtNGQ0MDQxZGI3YzEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTQ4NzAwMTMtZGQxYy00\nMDFkLTk1ZjItOTRkODUzZWQ0ZWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvhsV3CqibXbrozzdzPgDvSG/foIMee97STuJDOZZPV+iu12n2JbB8QMKfcSYvu7H\nHBLP1o1iw/gSAmcfPTGJ16N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzMnTHtdfKjylEB5s\nCoT6qIR05+wwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgcz5srM+rQ9WU1e/rR49uk+W15I9vzvgZD5JeQ40eeL8CIGKD\nzo35B0cRFmJg3PjMsWxr9eguVDDe0+bnhZG1f2MQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4078", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4078` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcYiOcSJ+1chMr1Wa7XVqRpZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3Mjc3OTg4LTA4YWUtNGQ1MC1hZjVhLTU2YjM2ODg4ZDg3NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ2NGJmYWItYzYz\nYS00M2U5LThhMTgtY2MwNTE1MzIxZmJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENqWTdeXkA4ftxOcVEV30nWk/p5PtMYnue9x69qEhuIXD8zuSQaoIp6rZqIj/\nNYc3VA6W1ntOuffggP67N5Pwd6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhh1a26Ip9l/eIo4GVMl0P4FKujcwHwYDVR0j\nBBgwFoAUv/EaP/IMiouOKiH6MN+02nN6LegwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBX3tO39Itpd\nw8eiAmQV0dnHf4oiYytTuDzl30YDYiyLAiEA7ZloJ55lgJKzzrzRBb/qzLpoITZ5\nam5N6UeJY3AOWlE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASFKFkstwJDP1PxGX+Nr4KNmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzI3Nzk4OC0wOGFlLTRkNTAtYWY1YS01NmIzNjg4OGQ4NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbnDswcSkjQPFK/eUtgKlvStGNxjIKUhwmbNr7DSfcn9Li\npZ0Bj4lf/OYhm7/VLasdDzlDI2xZMgQ4HozGc6BTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv/EaP/IMiouOKiH6MN+02nN6\nLegwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMC+LZxQrlgc1pk+LSri8nuuPU+6Xfl+xHLhbUDFSKZQCIQDNlVHdvHrp\nLc9zpsWOpb2s7vZaXEOAYQTeqMb2YdFgZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAeJ4JnKxHzbP9/dgYZqLmVq/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ2NGJmYWItYzYzYS00M2U5LThhMTgtY2MwNTE1MzIxZmJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTFmZjkxNDYtYzIwYS00\nOGY5LWFiOTItMzA5NjI2YTIzMjBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxbejyMrc7zbgmb4vXtPHzdiVSoAe8R8lf2CJZgv/oLoDYr0KSW1tDx2ZpxIG1EJu\nhyKKgQY0VYkxF+I1P4oK1aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhh1a26Ip9l/eIo4G\nVMl0P4FKujcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJTnsxKjreqa1i0Jg3WIJZ3wYcqHkuHrw8nBrEmOKs/pAiEA\nsdssBCOb47FNsqJxJdNyvS2TZvBEWjzFwWMIAAWJxVY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4079", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4079` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdb2rc7zzWzMKGQiXqdw+pxsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmMDc5ODQ2LTE0NzItNDNiOC05MzY3LWIzNGQ3Njk5Njg5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDAyZWNhYjgtZGIz\nOC00ODZkLTk1Y2UtMWRiYTRjNGRkNDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHne5+Uv10yhBtLNnPdlO29OUPSWTSVYv1IOBHawoqT1sKPEN5vAomBK8ExT8\nYFtH79JlY/qZDUMAk7idTU3vVKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA0LQpF5HY8tydHiLWs8ZGr8+s1MwHwYDVR0j\nBBgwFoAUYkDennH3q1xAcpjzmhYM1Uy0bRIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDrLsbF/8l6+4XB+gz4I886tiu/vSW9Ch35+5tRKJ+CQgIgEYFvxRR3HSjY\n/qzF/x4xe42D/ZTed/iXFXnXMsTz5M0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfyQ70wks6+ngowjoSoUlbhZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjA3OTg0Ni0xNDcyLTQzYjgtOTM2Ny1iMzRkNzY5OTY4OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQn+oWWyJWlV/8HYT9Z14ImrnHjkz0TYsdgeMCG3HhjZjia\nuDJKvkvERbvm9wbl1txAyOKG+g4Ghkm5ImiMWHuNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYkDennH3q1xAcpjzmhYM1Uy0\nbRIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY/j/zFLqX70wqkC6ZotI0uMzB0vlSgORxPD4UgMSJx4CIQCo/BFon4wl\nUb0zNtjHzlQHN9iHfUYsrdup+LL5VnllIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAcKwvtZzyKTdeJ+2q7TpCM0GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDAyZWNhYjgtZGIzOC00ODZkLTk1Y2UtMWRiYTRjNGRkNDViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjRiNzBmNDctZTI1My00\nYTE3LThmYjMtZTg1ZWFmNWU1ZTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxgr7Mc89Lz6upG4JQUTV8mxLG/MxWiC5adOpbM96PKnu+hnU0FvvcTJiLskxeIDG\n86170VET/xLKkWl6RgDpmaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUA0LQpF5HY8tydHiL\nWs8ZGr8+s1MwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhALNKOXirO2AVDWlpTIE/OVHb1M1x05bwF2HDJwIPERZyAiEA\njJjYdZXG8uxBneibJzY/tJNCkNQFdrIAHGbjJRmMrjQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4080", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4080` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAawu7rKLeAy0o6/3eWFV4yAJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiMzU4ZDExLTBiMTUtNDc2Ni1hZDlmLWIyNzAwOTE2NzA1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI5NWZlYzItOGNi\nNy00ODUxLTk4YWEtNDdjNDc5YzVmYWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEre2kC9hLGxOL8k3e9DqLJn0r8oARu9vxU8zt+CPaCA+rmoJPn34bzWV186+V\nSNLNkmj61hFvIdd/U/d5NvK1HaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5b/3DCGx7uKjW2Kfgj0UnHS/hpIwHwYDVR0j\nBBgwFoAUmwb8lFqLaPO0lTrq8v9BE+c/etowNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICDqUDWshVBjYvNLWcLSpe7JQ+nfbfFeVC6Md1+wwDG+AiEAl5aqfbfY7Qoo\ntPNq9L7CnVEbNrZqL7xpCI6oPBGZVoc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAckGklRGPBN5qKJNV1btSPCGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjM1OGQxMS0wYjE1LTQ3NjYtYWQ5Zi1iMjcwMDkxNjcwNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsqJNCjVW34c/PV/w1rnDUPiYdRL4ecmqfB78kB+4hPlFD\ntOMCF6VLUX6XGZ/N++OSAiFpMx4Pa3HYSLWx65yLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmwb8lFqLaPO0lTrq8v9BE+c/\netowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG6RJDndgnNYPOmBghOgjg8upDTyjjA4dRRY3boADm+cCIAoPzvNaNT61\nytuTXXOnvmevv0YWcYIycRTte97yuVMt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAaUmDAfCNEfFEGQsU+peLX31MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI5NWZlYzItOGNiNy00ODUxLTk4YWEtNDdjNDc5YzVmYWRmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmQ1MTVmOWYtYWRjNy00\nZGQ4LTk3NWYtM2ZiZThiOGY1ZTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHbJxW1WXrqZp3pWOclm+NM2q9upPNx4J1TdyA7Ph/Go6IfXRstQh+lSVxcxXLWzw\nC+qS8mU+y5UPpiHeDdRyCaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5b/3DCGx7uKjW2Kf\ngj0UnHS/hpIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhANS8v1EK+gqlMWfHafqWyF6lVZN2z10rRIzW0YMIfeYxAiEA\n9x+mEQl+KYd1PTxx89eWCSazyXyFwl3f+OcR7SLu3YI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4081", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4081` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAXYT0KUA4Zer+6DXBPj1hkfmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5MmVjNDQ0LWYyNmQtNDVjMi1iOGRkLWU4MGU4N2FlYjRjMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjVhYWQ0ZDctNDgy\nNi00YmM1LThmNGUtYWNmYjQ0NDNhYTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoYCLx4hj5ZFaMwMhFFILSwYyXDHpYaPKrNsKsaUm4dctW0JwL/8pUlQoVv4Q\njqzseQMFMlfd3/I8gqzz6G5suaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzPmeT0N7pGbIcpXE1MSITw5sqHwwHwYDVR0j\nBBgwFoAUvLuITUL2dSDtrUv93RHqNOuOmhIwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDr\nrxFwMVU8f1jUQIZ5wpKBU9xWN69obmAGWjfwDnr5lQIhAM9gV/cDiMIVNgQLOwkC\nBCMOLtiO48HB8WHY3WMxt1bH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQBtbSSGPGNIXgczwyfWNuJ1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTJlYzQ0NC1mMjZkLTQ1YzItYjhkZC1lODBlODdhZWI0YzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATe/P5PqxhYcq29v/fJ1xRHkPpoPtN4QspYn2vclLBCIWNZ\nIgaSBtUvLnEjfHdhDkmPd9U2S4QqQyiwYYQEloYRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvLuITUL2dSDtrUv93RHqNOuO\nmhIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPDbpliV+P7GwNuNOnMhx0BQO/pFBWNAKncmVTpx1sQKAiEA2joPEdRY\nVnWPliTupzZ98aED0uUj+75iM85HWTSuDAY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAZqX70MVVBvktQTMC609iM96MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjVhYWQ0ZDctNDgyNi00YmM1LThmNGUtYWNmYjQ0NDNhYTZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDNjNTZiNmUtYjBiMy00\nMmIwLTlmNGMtNjc4M2JkM2I0MjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\npEO7oU5ZAWHbgHzlFiY7lFSto2VcfmXgmFuwOmcNLOsb4R4v2TvW18AbMV+hG0tx\nkgjbm1Nbw4tKTmhkF+G536N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzPmeT0N7pGbIcpXE\n1MSITw5sqHwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhALUQg1j5IB5LD3AN8X+cSbfkNw2QgO8eOzliUnpjBeBhAiEA\nhCQQhNkQfYeeMldLsygTNfrv5RdNpmS6NOfI2deHbNk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4082", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4082` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAS3YYMUKSD8GJNe2ha/D+V1YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3Nzg5NmEyLWZjNjUtNDg3Yy1hZGI2LWU1NjYxNTEzYzhmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZlNmQ2ZmMtNDJj\nZC00ODhlLTljZTItYjUwZDJkNTcyZTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExRf/AjGdI4vBJYQCb7+PXSJme02911WkHlhENbig0E5CyT5r2K1TXUlho+Zv\nMlw9NVQqflzUfzZ5UNmS/h2LBKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQLT2x9/4N+oOJmP+/at6uvIRKLIwHwYDVR0j\nBBgwFoAUfGHrdTiwOCwjFqP4osbDI9RxS28wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIHIcOkyPTeheXQBQ+uIUdilg6BkSn62PA0UhoNHSnoIvAiEAwV5M\nXbMmGP3nA91wLEuTFDr8HM0JR6Dio1q5oL7d80o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASg3fFeXI6jTz/E65W0zKfViMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzc4OTZhMi1mYzY1LTQ4N2MtYWRiNi1lNTY2MTUxM2M4ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXT7sC9Qt96njpmiOPgV8T1VBbjxYHE2OaNHgSjjZZ0xQE\nu4KFky8A7RCJWrqn7xluoaz7alztl/x1lrPsG9Kdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfGHrdTiwOCwjFqP4osbDI9Rx\nS28wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJgznbP+eSC2WMXmSAALGR3SHvga3fBoaqKzSb0fIoDmAiAINyj6CjDq\nZmcTFiSk+BFewIji2dntLohX/vEMAF75sA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISATWC2/r4gJtpTu22sSnss39wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZlNmQ2ZmMtNDJjZC00ODhlLTljZTItYjUwZDJkNTcyZTM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGUwZTEzNTctZmVmMi00\nZjIwLTg2OTYtZDAxYjI3OWE4MDE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/FQ2Ds15j+QEaafDc3bTX3w0RAQfKNTrNbX8dgGih6CdvMs+2N7AlONhRPPf+FhG\n31Zgy+ESl6NnjdpjsgBmAKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQLT2x9/4N+oOJmP+\n/at6uvIRKLIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIRhb6CNuQswhr/erHT5MYe15KNHbf/1K12kEE2JzrF5AiEA\n+GB7wa/mgGYlVT00S/qqecM3aBPUi6/8BZA2CcXmKA8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4083", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4083` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAblaVzB02VGSB7AyOnXFbfHvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyZmQwMDZkLWEzYjAtNDM3Ni05MjQ5LTc4Mjc1MmRjMTM5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM2MmNhNDMtZDZm\nNy00ODZlLTg1YmUtNTMyMzg1ZjdiY2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwG8M++ql8jqAOAZnQkUBUSrqZwdNrRhSffwe1vzitLg81kp0VD/BlXof9CYj\nlD8CCdmOG0EVc3xU1oHw3/wgHqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPypnb0KdSbpp/nQ/Mqi9MsiCwZYwHwYDVR0j\nBBgwFoAUkhTl5sRSXzAfyOOAt5y/eu84i1MwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCMrYMc2tyK20C+9r0ZaTuIkG/fxqxZyfPe9lqEm5igKgIhAJh3\nR4wLASMPABwumATv3RgCuRYkT3sFSuScidQqVJ9o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcLkXn92aD8CClgX1SE5kRHkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmZkMDA2ZC1hM2IwLTQzNzYtOTI0OS03ODI3NTJkYzEzOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTkSFm2eh0hYGMRw4/EWCVnKXb7qFClH7ia41gQd54Du9o\njm/RzFgderP3A0Zt6WJZ/D4Oi9+5kJxdMyi2wwRLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkhTl5sRSXzAfyOOAt5y/eu84\ni1MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgddnh5Gq9KiMXmDkUbezZCjqGvHhLd/K7EdGapdRV+aACIQCZg3ZsuPk5\nv+kpdJGEBgiWj7sTGJJka1DlcKD3J3FHVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZ9d4dhTOc468TUsohoEzxLLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM2MmNhNDMtZDZmNy00ODZlLTg1YmUtNTMyMzg1ZjdiY2QwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzY3YzBhMTMtNzM3OC00\nZGI1LWI1NTQtMTQ4ZTQyNDkyYTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEJv6JMXpKKph9tuCFoJzKIkirHmklgk8CAvb8YywhKXzbAimYX+ON6xhaRxOTIpC\n2D1XzYk2U6dU+wa26i8ynaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPypnb0KdSbpp/nQ/\nMqi9MsiCwZYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgcFpm20dnsUWtihGauak7RMo9k9O1WJuECEzCY/WFWSgCIElI\n3V8lohXTRkyuhz6j2IqKtoNQ7SJGFkNaapVE789C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4084", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4084` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYvvSp/MMJLGpwprH5GxWqOdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMjFkYjE2LTE3MTItNDI4Ny1hOGZkLTQzMzRhYTNjYmExMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RlNGI4NWMtNzYy\nYi00NjQyLTg0NzItNTIzYWI1MWVmOTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEErsLXv2kEdap3z85kmTpMItVqhErkFOopDlcVdKvWJAxiozXp3luQvZiUJJX\nIS0Q3XR5OBg+aznqbCX2kiFIyKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTIA72L23SqzPa5I3fyKnL3DpawSTAfBgNVHSME\nGDAWgBQUdS6HqisXe2eot9vI8zZzxpVtKjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICTKpmCA1pzFkDpPjiZcarUPYhhzVdCU\naqVZyQcUVqb3AiBR/BlmZ37Np6hkfvVllRTR8udUCvrUecazEzWSMyy0sA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU0tXPhzRJULGMdmBMuE4HaRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzIxZGIxNi0xNzEyLTQyODctYThmZC00MzM0YWEzY2JhMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUzGE7WYT7BxNNse+h7Uf6kkaFYfE0hgWKqItnDJ0htMCJ\nhyyo7wsxzaY5q7qxyWjgB5ikDyNlOWvfdDVWHORjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFHUuh6orF3tnqLfbyPM2c8aV\nbSowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAkzjYCxVUaWHmBc5H2zPUAIuiA7yvATuUXBmL8mBUXUCIQDoJtLu3Z4t\nTCcqNRMZaYxZ1FiT1t7llzDWWohXBEy1AQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAabvWKvPmf0xivfaJpOvfhZ/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RlNGI4NWMtNzYyYi00NjQyLTg0NzItNTIzYWI1MWVmOTUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTQ4NzhjOGMtZDQ1Ni00\nMjlkLThkY2MtNWMyMjBmZjNlMzkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7FPyxtmCcPO8/eOZHmu+5QT8La3KY2TRo1fJMfNhvTy/egty5i1o65cgJ1GAtUOd\n7P8Tlr2y+nBQpLqJY6GzdqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyAO9i9t0qsz2uSN3\n8ipy9w6WsEkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAIJ8Dur+SkU2gsQwhhkpvgRo2MdXYoqQNt3EJgsWboDjAiAW\n+insujUg7tWS1Um2kjP2flgfMOb3Qyoe8TTP/wuoog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4085", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4085` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAa8zvXgkPMNux1HlU0DU+UXsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNGY2OGNjLWIzYzktNDEyYi1hOGIxLWJiN2RlY2NjN2U0NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdhZDliMmYtOTg3\nMS00OTlmLWJkNGYtOGI2NzQ4YjcxZWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVLH5G2O6Mrziux7kgsjGAGOhlJGbF4DEXFw2GzAGPHIzZkdr3hgTvWqQCUFf\nauK5hF4P+iCiXmpRNy7W/IyHpaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUENaqUsLWDuIQyln7WmEV73HIOBUwHwYDVR0j\nBBgwFoAUeqRxSaH+S4UkZUZFbE+fWtHlcx0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBhPEJsO2fRX\ne97g8f6ajuF+eVkqayDFPAAoFDJA4NZpAiB3iedXVKEqIb7YcgsLD8mIQ/jTxPoB\nvFC5DfhHXFhHUw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc3iw2Uv2F62Sfb8FFOnamfUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjRmNjhjYy1iM2M5LTQxMmItYThiMS1iYjdkZWNjYzdlNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMCRlh3XO/W/V1+GgBEMKMyPiQ8bbFF0BFiwhyMSqVHtjF\nWGAAZeUneu6Xe1N7p75BURe1QBOkkHFhdJsyINSPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeqRxSaH+S4UkZUZFbE+fWtHl\ncx0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ9YVIshwCRpRhM6LarXnagMnlB+vJwpFmN5kjBv6PnkAiEAnX+zyIfk\njjVne8+xH03GdMt2YPfnTfhEI9UZJSonbJI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAVLhBbcfw59/foTRsmKWzApBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdhZDliMmYtOTg3MS00OTlmLWJkNGYtOGI2NzQ4YjcxZWNiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzA3MDViNzUtNDIxMi00\nNDY2LWE2MjgtZjZiMWU5OGM2ODM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWC9lDevF6NSwlP9l1roVfuEKqi5HCUPIc1/9luLo2SSN75CL0GNAdV5JqOc/cIh0\nDume0OEC0ijyKsIBj/z8uqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUENaqUsLWDuIQyln7\nWmEV73HIOBUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgHhdK2vyywoZSrzcKRKVBpYa3OSB1v13Jd7YO2kjWTAQCIEuf\nUmf6b+5lDS483aZhQv0PcWt8Vm8LqFWDZ5q+91d4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4086", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4086` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAc9rxn2Sq2ql4L1iov4slmIcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyYWQ3NWI2LWFmMzAtNGU5ZC04MzI4LTRhYjcxODcxNjE5ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNiNTY0NzMtZGFh\nZi00MmIwLTljOWUtYWE5ZGNkY2MxY2MzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnvXHQbwmTK4csW4c/afsIQwJycDYA4Jb9BoJZkK4P3fipRdme0tcvMGNg0+V\nIsOpLMyYRQvLV/qZGx1yhcuTK6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR/tRb56XxwOL6ukmz9lbgZZuJJcwHwYDVR0j\nBBgwFoAUnzk7whygNrSL4v8S+o+NfHP2Q2kwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIB1SWFT1fdnh\nY+OQQ2G1RTdEPEvGXHt0z1RvWw0/Ox86AiEAhA2apvn2hUrtlyAP1rWdnoW1rHHE\nMKHqhbIO5urA3bI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcv5NajHUQMDYVIcUjhPAWlBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmFkNzViNi1hZjMwLTRlOWQtODMyOC00YWI3MTg3MTYxOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARG6StU1d7QUyXxfHDwi+/uBFpgWNBa5smVeZSxrHzfi5Pa\n5rfbI4JO1I0sQpTNekdXpC4+QWdEyN7Isl6rVxE9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnzk7whygNrSL4v8S+o+NfHP2\nQ2kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOn7bXosQSRE++NBlJmvWvLDBpHbC+SAtr5VR2SGtyv8AiEAo+vODsNp\nZjFrhOEvT8N7QU7RENxrFd6IHRDRHc5lXy4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISASKwCYJpm+W59GnHVlu00L3EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNiNTY0NzMtZGFhZi00MmIwLTljOWUtYWE5ZGNkY2MxY2MzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmRkMTZlNDktMzI1Yi00\nNWYxLWE4NmUtNGJlODFlMzg0MjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNSSupgAH+Agsf12Yg+DjRdLMgvxuoNJCqgnc/pY3MEAsTg8Y5Pyufw25U8kNRF8Z\nITui9eDOBzznIRhsy9Sk4qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUR/tRb56XxwOL6ukm\nz9lbgZZuJJcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgR71+gBy9qG/+osPz7zpJMjFRWuri3jGLRto4d/tZABcCIBHp\nxwD4ISGLBrbRRVseJzIQ//ICW+pbKiK10kpdKejc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4087", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4087` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAboXxTY6oJRI2tpI1opuOAaFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiNTNmNTYyLTQxMTEtNGViMi1iOTljLTMwMWRkMzQ3YmRkNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNiYjljOWEtYzcw\nNC00OWEyLTlkZGEtYjI5NDRlODUzZDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESDbqfM6idWjy0p2DN+FHNwV6qsd2/pyGcyChaOKDARwgIOMqrBV4K2vY3fLu\nyG0iE8Lzob9/oo7/823gTj+UgaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUON/xZQcekkjT6u3Q39d1xHAFyM4wHwYDVR0j\nBBgwFoAUasaf/oyC50JvOHJ4dhvNn/m7WWowKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBVASmDo8Kc\n1t//EXtWIX+xAaTwA4zj80ImTT8HIFuxaAIgZkRpum4aKsXytos5tn5Di985a4C2\ns052Jk2Rdzkp0e8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbeGPEERfKp/RFAijE72No4YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjUzZjU2Mi00MTExLTRlYjItYjk5Yy0zMDFkZDM0N2JkZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT581zGLo5mhCAoH60ydla50a+8vwuoic9cvPKV5w3OSXkj\nLQZsmsD5EgDoCpIUI2+ELnguwKlWH2vmrr1iyesto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUasaf/oyC50JvOHJ4dhvNn/m7\nWWowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVvshi0dZ9Rd6yFG5lon6JhloDaxuLNgbhSQv5+u9aMUCIQCvJ1Sj6QIL\nnNqy6xXJ8kJioH9+IgPyQrvEtH+3rb+GjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISASHDecSspuugw9nEXDlLcotKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNiYjljOWEtYzcwNC00OWEyLTlkZGEtYjI5NDRlODUzZDliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDgyNjRmYmEtZTIyZC00\nMDExLWI1ZGEtMWQzOGQwOGRmMWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3vlIC++pXOHxSeikPFrevcsRt5lFVRcNTqWfNwVnmI7bUqghQ8vNagPgYQtG9+tB\nTRn8KqkvWI+4xtaGMT4neaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUON/xZQcekkjT6u3Q\n39d1xHAFyM4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgduG6iwZeMqlfaHhcD+yS5mtji5f+RNBxpY88jwmO0igCIEmx\n8VPW0t+ylmJlE7/Weq/0uTB44mrJcH+SYzS4ILTv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4088", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4088` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfeF8HlyI0Riz+O1ZTcWXokvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NTFkNWZhLWYwNDQtNDAyYy1hOWJlLTA5MzcyODczZmI2NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGZkN2QyNWQtODkw\nMS00OTlhLWFlNmQtNzhhOTk5MDRkNWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElkhnfA20gp1yxo1JdahokIOnJxpwFfORDD0fTGlDbJvunYm55hr8iRWZ0Vsl\nCDSa4189kCG+kTF4JImWTruxhqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhgATPYq1x8/M0sDNRG9b/qQPvvAwHwYDVR0j\nBBgwFoAUxO6l4+l7xAzp5FzaUPQwGN/8E/UwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiANOnwrNVAh0IEa12KQIMVyJL1lZVow3wct7H+3AOyjCgIhAJW1SzTT/njp\n1/6YsHHtYQ7quieSkuKEu3t9FuMAoRPQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ73vhz0fEeimFb8eQn9120xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjUxZDVmYS1mMDQ0LTQwMmMtYTliZS0wOTM3Mjg3M2ZiNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATy1IEPL0KQFHybaa0LdwPL1XvdcM6w5y/z84PCcn9PhRIG\nf8zN9oSw1tqHT5JaxilzYiAyY1xWniXZJc9Yspe+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxO6l4+l7xAzp5FzaUPQwGN/8\nE/UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOMrl19lWBiZdTsD6oFSkAc0wB1lcRy05TzWXfWGOJr2AiBrpj2M/xDL\ncPrdWqP64ykwd3rJn/dxlqA6c4dhwq3jNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdbdcxk0zXzgHT5jQDGscKqhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGZkN2QyNWQtODkwMS00OTlhLWFlNmQtNzhhOTk5MDRkNWFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTc1ZjgxOGYtMmFiOC00\nZmI5LThiYzUtOTMyNTg2ZGRhZTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwLWTq59HefybdI3SD368QYCxh9R5piZWO3ZcNc56Srd79bjnJbFGy0RO9i6yXm2K\nqqna/2ORjk7y804l2BaXUKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhgATPYq1x8/M0sDN\nRG9b/qQPvvAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgFa996jxsfaNRFk6utP+aDO0I9+e7LvWp+pdGyZWJ3UUCIQD5\n0GUPh8FL3Oa26YoKm75ajD3DQcSZjVWgxtoz4jDIjA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4089", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4089` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASq+ariiKoV/76OE6qSpDwB3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmYzU0ZmNiLWQxM2UtNDA2Yy04MWVlLWNlMGM5NjE2YzY5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIwMmQ5YTAtMDdk\nOC00MGVhLTk0MmYtYTk1MWY2MDMyMzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET76OkL0a3DqC90y6IyHvvfIQTrY9P7q6oPWxXCC8nJc7ksl0rLRR7jcMd9k2\nYMXzoZUNplQ0/CisqUi9HQB3xqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFhksCFrB3hCOiaMig+pFYUgHAncwHwYDVR0j\nBBgwFoAU0i4TcxzLJ/4OQS1c/IJq8/XPoQ0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAguk9lg0eq/gHIAZ3eBQZd9G2+xzGq5WYaZ4rsmmSkcAIhALiafLgctNjn\n3iQCoylZ23NZxbkPXnF3Qgc+2mJjK88N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbOmrkFYr3m/fYoaAWtCz63QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmM1NGZjYi1kMTNlLTQwNmMtODFlZS1jZTBjOTYxNmM2OTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZ8LRe+HLxpif96Zv/g43G771cR/ANE229J9ySQcY9Ncux\nqahVHyfTWYIJcLNnoEM2150rnrSvD8sFM2q6Vbtio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0i4TcxzLJ/4OQS1c/IJq8/XP\noQ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAItDiWfH+cBipr8qxbsTurLcLd+L0Oit5tj48Q+7mA6TAiBvh2fVUsjm\n3KHM51g8C7aHsHqYgJCHuSbrFZEevmilzw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAW+3PdomzzVTtlpFIUOvm0IKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIwMmQ5YTAtMDdkOC00MGVhLTk0MmYtYTk1MWY2MDMyMzY3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzBiMmRmZTYtYmVmYS00\nZDRhLWIwNTEtYTE4OTA3ZjAzYjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndQ1S1ta8HVhYtFBMlraj7UxZ+AeCB4PeaPue+NKQqQeqRD+5CZBFfKCByIZTqPjR\no3BhIC47KPd+3uWcAc6q5aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFhksCFrB3hCOiaMi\ng+pFYUgHAncwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAPYB2budeLPsxDI/um5erLbCfKq0614tlJNv+NHqmpQ6AiEA\nwMLIDI/sFF3CuDKwxkluGRM8jz6VoLUe6jIA0NhD0Kw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4090", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4090` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAbgbfSxj7YZHZ2bubD2rwE7ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxZmMwNmRhLWY5NDQtNDkzNi1hMDlmLTllMTQ4ODE1ZTc1YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg4YmU1ZmItMGJi\nMi00Y2JhLWFiN2MtMDBjNmRmYjU5OTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHP8hSa3F/qX72GRps4+4oUhZabEJ8Uwa3mSlytaITyR4zF+ztrBjjPEdwbmo\nznoGBXXeY6Mbd7R9Ro6yNs35jaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9eWRG+5BJmnD05+5CfZXhJ5YZZcwHwYDVR0j\nBBgwFoAUWlZf8zq0EdXDcuArl0jACrx/jAwwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\nmV/jmMS1vBSZLHVwZLTYmRtmG2V2m5Kmn1RJF1FGAbgCIQDG/vjoVTJDM0E4Yc2z\nYMsyWYrMfjd9EqYhWpNAA7UHwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfIMIEqmpPN/e7/Gg/IAvaH6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWZjMDZkYS1mOTQ0LTQ5MzYtYTA5Zi05ZTE0ODgxNWU3NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcTlow5bUmUs18nyKpXQMUWI2JBFlgFWtXkeAqkOqWyae0\nE5/Ha18wKuy0B8/P1z5X3XQ7qbq9gorq5mb9Hv1Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWlZf8zq0EdXDcuArl0jACrx/\njAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFkC5Gi481YPy4024xAxfcSjYTx8HR31dn716J6f2z0kCIQCzoSYZWAc6\nURSR/S8W13UH+/FP8vifjW9clB9mq0dfyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAbrYxMU0PcpR838rJt+pFiMoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg4YmU1ZmItMGJiMi00Y2JhLWFiN2MtMDBjNmRmYjU5OTgyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZThhY2RhMDAtYzVjOS00\nYWJkLWI2NTQtOWI5Yzg2YzEwMWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwHrUrgn0rnT4hJu0JZc/tiC9wImDsTeYBGN6ijeRXOydB5Ww+4peLBAJ+/2g02FP\nYvU+qMAeQ5voPOvV9kwFrKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9eWRG+5BJmnD05+5\nCfZXhJ5YZZcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgCaRkPjFrKk/kX8HrR2XTAtHqkdmtqNzgwzRMoac+geoCIEWh\nqWqB3zRlh7kJoX3c/UDwcSzHVBnnx6Fl7MglQVXA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4091", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4091` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAbZJctY08HbdKM6/2z3tZkLaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5Mjg0ZTNhLWEzNWMtNDdjZC04ODMzLTljMGY3NTdkNTdmYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzIyYzQ4ZjktN2Qx\nYS00YTI1LTgwNmEtZmI3NTlhNjc1NWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgz2UBi8TQMW3dCVxNIn4SKluNq78x5aG3PWX7I/3MXPWCAZd+ph6xGbr1G9T\nLEIb/o/X6Ks5SWwTwFOOGgPb8KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfYKJODX1kNGIgf0M0ASyLY+fpkUwHwYDVR0j\nBBgwFoAUQF91bP2BR/hwl3jElsXGYhavj0YwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiAb95Mi5icENlfN6dvk+wNE5W6IH7JV8pCoYkdMuZYUhQIhAKRe\nV7xlK+vgk5IwfpqJ09VG9y8BeL5EFlWDdl6GuBbh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASZAC7YG6O8yKqfAwq7vWOL5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTI4NGUzYS1hMzVjLTQ3Y2QtODgzMy05YzBmNzU3ZDU3ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPdhWXOPTH/0+dmUjn1hXP3pQ61kyILNTwoG9KLZ2ZJC33\nD6EWFUU20aIo0wr1st+j9HGBUkdMLKI1YK83OhN3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQF91bP2BR/hwl3jElsXGYhav\nj0YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNm+XhhCNCx1X/TxagDFrWN063kqgvCnKpvHGx9C2C+cCIEyFHHT6It3M\nN/WDU8SDR0hpOc+5WVbZkPZV0Ak21yKV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAR0M6xc3DRZD95P6p2yZecptMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzIyYzQ4ZjktN2QxYS00YTI1LTgwNmEtZmI3NTlhNjc1NWZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGY2N2ZiYmEtMjBjMC00\nMTE1LTg4NzItNzY0OTJlZWM2NzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZhca74eeP1JKrALLsQMI5H+8VI3PoJliC+GDjN24XK5MPtu/Y1UL398nu1FP//GE\nmF4tKf9rMgd3hCQW8eJWfqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfYKJODX1kNGIgf0M\n0ASyLY+fpkUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgPQ9cuxgaFrr5PfOpxl74EhPp2lkf7wJ+id7EieGHfaoCIDAd\nBA29n94JmEytw99tppp6Xpchc8KsaUB8AUvtci1N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4092", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4092` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISASE15G4akmYG3YR1bmsl2W34MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxOGJlZjgxLTY5Y2QtNGQ0Ny1iY2JhLWE1NDcxNzViMzdhYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFkNmY5MTMtNTNj\nMi00NTZhLTk0NmYtMTMxZWRiNTI5MDMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOJPf78HNlvv7eOUv6Dx1DEZ0k7QtDBH+xfMTSwUNUm3FG7IakbVGioYNfQEZ\nGIhYDOnl5RcxGF7Z/9RG2Op82KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPAnu+maqvjOo2+cucqK6HqwBPHswHwYDVR0j\nBBgwFoAUZVY+mnuclND3enTUajv5lSrvcfgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiATQzzF/X0e6ltDaUhfOffVTM5gDBFsTygm42rIPcNQegIgXL9x\noz4S0V3RFiv9V4oMh97hfwNgUXS3jTtn/E0P9Kk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY9phFeoXKg88M59jDc1s8HRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMThiZWY4MS02OWNkLTRkNDctYmNiYS1hNTQ3MTc1YjM3YWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlZW5eUq0KiMHdbt3y9x2CJt8UiVJXRTaFrYZl52Yva1Jc\n8KCQeOIKSucVAgF6arNjdjBjIAdjcnuBkCZeRcJJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZVY+mnuclND3enTUajv5lSrv\ncfgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJTKbMESUmR4EdZ3VOsjrDg4pGe88hzcvy7R7KiCavP/AiASoFyyrjxp\nDvef17JjkiKYOsARsuVrnl0b9AW7HCVbAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAf3GD1S0/PEnjuwh2LQrMMqLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFkNmY5MTMtNTNjMi00NTZhLTk0NmYtMTMxZWRiNTI5MDMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmY2MzM2NzAtZDBhYy00\nYzMxLWFjZGYtMzEwZTQ5MmRiZjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCsNd0CcAbBTj1sk9ceU/K0FR2XQoS0gdPhn+Gu1F1gpYyOUxSI3BHPatQuQSyYL+\n7Dnn0X56BBw0RnfsBI7JJ6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPAnu+maqvjOo2+cu\ncqK6HqwBPHswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJwOo3qWEmkdoqyUUoYfaR8TISeaQH+NafKv0cwJ4OQVAiEA\n15l8K2aE08718wCqWVpRaH2kbAgVkbOlD/kXbuwku6o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4093", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4093` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATM+8kvIYhNfOYTb7BrvrR9rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlNjZhZmFmLTUyMWEtNGMxNy04NDI1LWE5ZjdlOGE3ZDc2ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRjM2UwMWMtM2Jj\nNy00MTI1LWI2OWQtMmY3YTljZmM5MDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECzWPhq4FIwztqmKQ6HGeX7nhgPJ7GNjRZipe+lwxQXMo47UNfVVHHqjDZ3zc\nCUx548y/j6O4/1ri+FNM87d2yaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuQJDrHyTpZBva+QX6b4U79gtP+AwHwYDVR0j\nBBgwFoAU92NXftmtpjMu1PD+zAT/vzOQ0ocwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBAGNW0FpRQiKvm\nEKszf83cE+XjzXygiE8mKi0bnV4ILgIhAOEVccF7QBBAX5+VcEY19GUNvFEp92mP\nzkLUzJ9z8Q8Q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARYAKZ1Z46u3yKpKN5KW23uFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTY2YWZhZi01MjFhLTRjMTctODQyNS1hOWY3ZThhN2Q3NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATekPUvAiWTUFjRaMqycV4b6bzcPGIOKERqu4E3J44EiyFn\nA+Vz0+X2qW8ZFwqN72cly1KmV+OKZjtyZHuGCRaQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU92NXftmtpjMu1PD+zAT/vzOQ\n0ocwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOdHY3LxMHvl/G+PGR6ngEiaqOQvJaVhvZ+TkMI5cTrMCIGSoCs5lyU3v\nUGmEZIuOl6AKI4iT2dL8LW2DTOrV5jvm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAUFGfzuMGgSfqxBp6cP/QvGEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRjM2UwMWMtM2JjNy00MTI1LWI2OWQtMmY3YTljZmM5MDJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTVlMTRkMGEtOWM2Zi00\nM2NlLWI2YzktZDlkMDVjNjhhNzdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrGhq+/NNEjTCJlEaG6Bbt2RvWOMytM9O8hAC1otoXpFMBcXVGK8JaYRfWkO8Tg7u\nuj6fRKZZiEBX4ao3+zvuZaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUuQJDrHyTpZBva+QX\n6b4U79gtP+AwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAPikIvO5og0NaDrGC0/JQy6TN0yLB0ei0O7NJZmVC6x3AiB7\n0KgZGNwdVBJc8mQf6OsExraGPSCEr9C//NKTyY6uYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4094", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4094` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQP2orMC5DeV8y5wWOntp0BIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5N2RhZDE3LWE3NWUtNDI5MC1iOGY1LWM0NzU5YWNlNTQyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZhODQxYTMtYjg5\nMS00MDVjLWFjMjAtNTFkZTlhNDM1Zjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsqJoZE0hDfb4ZdOeLBBiwL/2bgfxLDTx8HT43fsHVxx4juinMpvRR9qkQbg3\nnOOrUjopZTUt7MlLj+ABzW2SNKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURUOxDt4iOCbh599f7mmp7M9I1BswHwYDVR0j\nBBgwFoAUParyR2gTzt15rd+4v8pgin5l83swNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDFarZ5ZuzIVHKrdrtFr5NCezlICYQw3ZQMfaTjog8PbAiA5BFjN3+kq2v4Y\nj/quGpMhvxDM7gw/MRGUIdbaaE+H8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ3H00cPt9kpPJ3e/vropuBzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTdkYWQxNy1hNzVlLTQyOTAtYjhmNS1jNDc1OWFjZTU0MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVMuyC0B5/lyCZJ9yPGC7D34L6d0dgYlaY1PXJIK77c3hx\nMjOfL/GwGFOub+VbeOlfGlNU3mIe79TbRGD4RUQro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUParyR2gTzt15rd+4v8pgin5l\n83swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKj8dRy7nF6jj/p2KFyPcludqyIgh6ikRKkkC8fQiBkyAiAD8B4RcuPk\nldHtubp+1lvC3z02GA1JYdzeQvgsU+/gRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQt1csudbnqoRHTfaqGs6sfaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZhODQxYTMtYjg5MS00MDVjLWFjMjAtNTFkZTlhNDM1Zjc4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTQ5ODBlNzItOTRiYy00\nYWQ2LTk2MTYtOGVmNWU0MjZiZGExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6n6mIAT6zwg5EftR+xPTwk4e4BVIHIBHVsUOGHmgYLEMlRHYnG5m6jcM62ifOb+2\nLOjnyqAZGy+/rHBWmRU57aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURUOxDt4iOCbh599f\n7mmp7M9I1BswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAIvj9R7a1SIflGetvdh1jZNoEpH6jLkLl/sFHq63BrqbAiA7\nswOOhtHSn5u0e9G4dvVKamGzzlInbrsL+xxrV+ERZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4095", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4095` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWE2o7wxMvb5CoYecWSWdPNYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjOWY1ZjcyLWI1ZWQtNGRhMi04ZGQ1LTM4YWJhYWNmZDA5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM1NTM0NWEtM2M0\nNS00ZTIyLTg1OWQtODI0OWY3OTBjOTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuzrmkdBSyjLVOJ2m5BXt78VRLWCRRJnhySwCFTyPG/LatA3r4x5P9Z5gdV6t\n/B4PgUGwfAyBymWOWasOk3XXI6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBSGO1T3wEH14CnvLYD9hndiTCtowHwYDVR0j\nBBgwFoAU/OALfERJ1e3dTqnSnKZQUuoJ/9owNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIE+eN+j4RCGx+kJE22nTpP5VDcTMSrmu7zQXl3/bbHuBAiA6KaqfL3f82Jvw\n9+pSN+ouKQ5E2pVAGcg+0yg2yuH/kQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXWNe2P24ZLs/P6EL8QOPtQ2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzlmNWY3Mi1iNWVkLTRkYTItOGRkNS0zOGFiYWFjZmQwOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnVBfPqyKxP2XGXJyhm/Bxj0HvCe5cVT3CJn00/u7CXEiV\nB8Hf4aO7EJqgIjcri3BXr+d3wSklBd52N1EOnTwjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/OALfERJ1e3dTqnSnKZQUuoJ\n/9owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHU8lKRgTpHOYdhA+nFUpBsLXKzwcBXS/X93FOD3sQqwCIQC0TwRK1cSj\nxZgjsspqM2AmYjCrnCbyUBUIg46VLKLJBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAbHjGqaX+fxkW/OrqXndwMeTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM1NTM0NWEtM2M0NS00ZTIyLTg1OWQtODI0OWY3OTBjOTRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODk1MWU4ZjItNjFlYy00\nMDAyLTg4MDYtYjVkNWEyMGZjMjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHhJJIzuttW7fRaPj95hDU3W3Y6RAG4R6hk8LvOYLWxzk8Dm/rHtlARh1k9wDhKGA\nX3cfP9UD9M9K47NYmJa946N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBSGO1T3wEH14CnvL\nYD9hndiTCtowHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgFkSvQuyp+gMWEIfcM+Jtpu+U19UmapAvpkmewRxQBPYCIG53\nbMWWrFL8hdQ9JN8WLDnk3LUZEZNUYMHYj4R+8iD2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4096", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4096` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZQCoE1gjcbkGgRK8zRCXMtIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExNWM0ZDlmLWRlMGYtNDEwZS1iMjlkLWIxM2U4N2UzZjk0ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNmOGMyOTUtNGEy\nMy00MzNkLWFjNWUtMmY0ZmExZjVhOTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpnTx/Glum4xB5JRAiZLp9eBYGRFqYX4jsPUdGJIIS/1co9MZLcwH3fu6V/Y/\nOz9ptOxrqxDWySPE4P+xmtS5V6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW4YfrCgHp9hJfDqnnJT3+aLY1DwwHwYDVR0j\nBBgwFoAUqePzuwCAKTC/KC+EGGNO5NFxMpowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBJgLX7KAAfTbx53ZpfVFBt3lMrLvB/F9CXZTvfEkbUeAIgIN+4eYUhleKb\nBhuj6m62QMXeEO9Tpk5XsfP/KUJY6kU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV/dKBuJD/m0NuTOISBOeGQpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTVjNGQ5Zi1kZTBmLTQxMGUtYjI5ZC1iMTNlODdlM2Y5NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNN2th4hRVMKxJlZlWWJl07pHNvx6jUHWacUGOxcxQLqTA\n79KC5Gj50UFT4svsNZhH/yJkVCV/jufbW0xVpB8so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqePzuwCAKTC/KC+EGGNO5NFx\nMpowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM5sevTEG6RnmEVejXhDUWNFi2dznbAJof0YAajFZ9FgAiEA6YQzH11x\narsyd7Wh2auDbBrrQR6cKLrH7qfKmb2b8ZA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZJxqJ+RW2osupIxa/Zn4jLwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNmOGMyOTUtNGEyMy00MzNkLWFjNWUtMmY0ZmExZjVhOTBmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTgwMzY3MjctMmEyYS00\nZjkwLTk2NGQtMDBhNDY5ODcwNTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPq2C59osv7QKTRHBCU8umTihTFcikrCGZldNo/9hjypxaYjYDHBZvymMOqf0gRZY\nlnpuIH7EyCNwa8GiVTc57KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUW4YfrCgHp9hJfDqn\nnJT3+aLY1DwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgSrVYaW1EBYPKkl/rqffA3DHGmTnavGWuu9oF8/c6FrsCIQCx\nKZueF7rTuDPG18dgV+NDIyVSb74i5urTetjZBzv/rg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4097", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4097` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAaQKwWID7UIQGroZlQoAr3L3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjMTBkMDFhLWZiZGQtNDljOC04ODYyLTYwZjMxMzY4OWQ3YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VlZjlhMjktNzdk\nYi00MDBiLWJiOTMtNWFmNjJjOTFiMTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/wVhjkMUk/MlYVSz7wXwPnoJrEPQu+kElGaMg9M8x77vPEpUlftmzNDhX5SV\nJ/S44+MVAJpILq6fKL1LWnzG3aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZd0TP36qFjpboAue0J6WCp3DvcMwHwYDVR0j\nBBgwFoAUbHdCUXTZsTIzLF5dPWhSgzLxQo8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBk/8ldSmrpEWvBVIlZetG9+WBh1iKhpv9LILOxDbrx\nDAIhAJ+5lS1poZleRM9T38r7sCUDnFbfDj+6xB9kCvOsmP2b\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASa0C/ypPjswExaqjCzP8cMuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzEwZDAxYS1mYmRkLTQ5YzgtODg2Mi02MGYzMTM2ODlkN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSv90NJqM7XoR7pthCP0LxbHZMIpib5tv+30dh0gbPS7ok\nrLtSXWZPPSFvGfZ+qKie9LCiutBK0DpwxFGsECV4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbHdCUXTZsTIzLF5dPWhSgzLx\nQo8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJqmec0D7oV260W4OKeY360QBLVmJMdheGsN6+JVW1yACID/8HyHsJ9G6\nW9vPsf2XpwWep/aKY5mtWLpX5HLKY4KH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAYvIZrR6XAcRJ7XkBjUVqxX7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VlZjlhMjktNzdkYi00MDBiLWJiOTMtNWFmNjJjOTFiMTkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjU0YzQzOTYtNzM3OS00\nNmIyLWEwNmEtMDNmYzgxYzdiYmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nf3EahwtrBayF6SF1DFkCRzxvhcV/f+Er8N0S8+odP0EnD0UhsDE7E7VMfK2SFJat\nEViqYMJgp9O7rw/pN0hneaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZd0TP36qFjpboAue\n0J6WCp3DvcMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOxpf0bxiUX1vVBIVxpbWqNPF5v2OabxO3P58LobMiC0AiAh\nkQZE3aSrPv1/sBAizQBZuLYVFero/JskSOudCSCMoA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4098", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4098` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUuZt12ezDKVfPeul6l93+G+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMDYyYmQzLTFhZDYtNDhmMi04YzFhLWVjMTIxOTczMjBiYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTcwZjM0M2QtNzk2\nYS00YWJhLThmNDQtZWFhN2U1ZWZkZjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKBLdcdFJLzoB6EUAtIo1R8CwTjQK2fbbkxq4L430EET/9t0PlJckcnPdfk94\nFDCWjPSc1I4TifUrlmHTrby/kqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy0c+zIHruMPdP+cEHbO/JwvHagowHwYDVR0j\nBBgwFoAU8wIUgZPz7eR19TVroA2NR/reK0UwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAxlQFu/9D9AsFukvkc0M7cK5ks+n7Q83OfFLQiayaY\n2AIhAIuXlfjzYhvtvLfVYDNaEcXlFPddEUmqRbrGKCqq8d0g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATiOWCQDLMNcpG4YYvnoC2GOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjA2MmJkMy0xYWQ2LTQ4ZjItOGMxYS1lYzEyMTk3MzIwYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFZjDkR65Q9rIM1Cvdk8I+LH11yLg6ae+SvmtrpoPgCy8u\nuFXldRA1Q6ALY+CcpPz2HkcDtbQ9FoFhFIgLqtVio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8wIUgZPz7eR19TVroA2NR/re\nK0UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ2PvhtLcLUC2h7NMbl9uVjIV0wQuYS4FkQcuwy8/q1kAiEAq0MVWx+O\nn0pTtJhlYMufTTc61u274hRG4dDaHNUNMGo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAaU/8hth9fpoeVD26KQqqU/lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTcwZjM0M2QtNzk2YS00YWJhLThmNDQtZWFhN2U1ZWZkZjRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDIxMGM4M2ItMmU3MS00\nOGJiLTkzOTgtZDNjMDBmNDhkYTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzm+fjNzvy/9XNRnAqno9IMFakRoZs2dIg098fELd1YsURCfohJlFiU71t5Tgf0H+\ndecSMfZGgU471D5ZKgXmfaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUy0c+zIHruMPdP+cE\nHbO/JwvHagowHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJg4LbC6HAEvBS4UT4manx4MZDnBVVvUEZa8tEssenoqAiAg\n19iJMFnaHaxd+NkVyRD/di++Ormb4/HoOJUAy198uw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4099", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4099` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAafZdRU/euxT/k679H9OyKQdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmYWQ0ZTQxLTU0YzUtNDkyYS05NGFiLTM4Y2NmNDBjYTU1ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk2MmE0ZWUtMzk1\nYi00M2MyLTg5ZDktM2FlMTliYzUzYWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOf2BMWZtuRTuNI8hAZ+LaqKyyyHHiNm+XZ8EXTIfDNO7oTRSo7TI5LoNeqpS\nim19vXhINU0TticfvVvpn9+xUKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdn1EcibskG4krqFYZjkhtKB0N/YwHwYDVR0j\nBBgwFoAUxcRlmDhyQkhB+5s7qnP1ODGJxE4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA+eM0iAH/ioguyNA3LtB1p/tPW6zi9+GE+r1vbU5yyQUCIHq6\ndYETDqT3kmm8LhyxGpf/DvUOjLZ0qTglSkwGxBuX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd23dAaZXyM/NKzajWGNIDi/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmFkNGU0MS01NGM1LTQ5MmEtOTRhYi0zOGNjZjQwY2E1NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2mT7KjMZQexgSX4LVlRQw+ndoFxO0OMlQ0n+zekLlpZQo\nor4vF70+iWfe44Dd7QIc3K9dFVxOL4AnpoDevnQ/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxcRlmDhyQkhB+5s7qnP1ODGJ\nxE4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMA8hfwp3jfyYsW/bHs1evtQeY3pMw3JjW/omuhhM9iVAiEAjq630XlL\nHRW3rHTct8ok6a0/k47g0M6zqRaBzbKWyO0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAcXjEfr5O7RhBYVzZB6aGG2NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk2MmE0ZWUtMzk1Yi00M2MyLTg5ZDktM2FlMTliYzUzYWNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmMwNWIzYWQtMGNiMy00\nMmRmLThjZmQtMzA3M2FjODJhNGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqpdIvpCqFhPzUS1W+Gx0tW2rwjzj99b/XKnV0Mcv/M/9EGyBZaJGS5+5nGgVktSM\njEdu4b5D2cxaX9+sglhBRKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdn1EcibskG4krqFY\nZjkhtKB0N/YwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAKEHItnB2Ktv+HNIxu0d0wmOkNYswJKU/ebiiM9bqUJXAiEA\n/XwS/nv9TN8m3xKRyw4MRJp9kzD/PHpydjRRnInsu6M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4100", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4100` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAV0aoa4/B2PRJ0rnKTMh6PN6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViYTU5ZDQ0LTExNWYtNGVhNi05ZWM1LWQ0YWYzNjNmYjg1ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2VjOTNhYjAtNjRl\nNS00ZmIwLWExNGUtNjk4YTIwMDBiMzhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz/PSj/KFN7W3NZzQMUyFPnCbVzclFarItqHwk2rt1rETZ5aTM3YEeYiH+M7W\ngpC2ToAL6TVqPvKlyPJfQNI44aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhYdBu5SHX/uD3jy5E2/AYsLxT4MwHwYDVR0j\nBBgwFoAU3ncCfsWRUGVqhyN+lLRyeXrUqw8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAsQ0YgsanTqTZuVob3TxoI3wA3tJTwEFp\nDcnUbK0bF6UCIDZOPEnm9vvg28clEnhLZXwUTdcADmFnNMkiidYL6bgi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdlJDlnjQhaoexUSt/bKEhDHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmE1OWQ0NC0xMTVmLTRlYTYtOWVjNS1kNGFmMzYzZmI4NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVNybADDlk3G0sbiBJX2NrdtrIgIm/umnYONLrxJCRDVUf\nPq/3ZL6EIorrk2xiEztD2rteoEkrm+X9z/F6d2Vio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ncCfsWRUGVqhyN+lLRyeXrU\nqw8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM2/SeV8RKj5ZkfVHsWn2mfF/puCp2ZcgAiJ17Zr3hAfAiBCE8lLWMXN\nqYXLepdFSeROgVpoU+hyg6vlz4BDsFHL8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAeg+hFp8POOMgELBVGQTJ/qeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2VjOTNhYjAtNjRlNS00ZmIwLWExNGUtNjk4YTIwMDBiMzhkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzc2OTMxN2MtYjg0OC00\nZWE4LTlmODEtZTBjZmQyM2IxM2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nx4vqtRkcyI8W8BVnqkESupteY/9P7Sg3fYNEcnyICjQUWM3enpTyA0qday8C8EiH\n5jUVuLTNPH6UxujufP6uOqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhYdBu5SHX/uD3jy5\nE2/AYsLxT4MwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAKbGcnctSTznIYm4ERDucnFLZMKJKdwhqmrcWQpJd8kaAiEA\nu5wv7LpasjHdcsy78FOEupuJYNuuAmsb4kV1fpX6kP0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4101", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4101` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAeydlL97yGA6Waz3+q5A2AHwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmNzI5YTIyLTkyMTctNDE5ZS1iZGRiLWM2YWQ2MjZkZjlkYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBkMjIyYjItNmQy\nNy00ZGFhLWJhYjUtNzM2NWE2ZTBiOWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1dG5eyYkvdYXx2pDKCjKLSdXNYUlVF0vxNmbxdmKELAg2sNtSacI8m9R3QRg\nzTGn8MXzI+uCjsnJLhhNDnvnYqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUONvF8Y5KPdR02dQxSmNh/uKCepIwHwYDVR0j\nBBgwFoAUkGlAnXdrdHXZ5xH6ESzcn/P8VzgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA47VSVZB6UDfHxRFWIqIxPbaGHfYtDPKrK\nrZPhUJ+e5gIgK5VMshndYnkfcdo4KbEo/4G2oxCDKQh3hs+pZkjdS8E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXJeLkOsi4aprmJEuRe6cFB+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjcyOWEyMi05MjE3LTQxOWUtYmRkYi1jNmFkNjI2ZGY5ZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrj4rMLNBN46trjLLulkujXdyJDd9NjujsQEZmrRIt+oDP\n6Hd7sU2SQnCAm/8pRYB9+ekn7pbABTrtjDPIR/O3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkGlAnXdrdHXZ5xH6ESzcn/P8\nVzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOepxBhJV4Y4OtIGzO6fOvFhpgFoDHwO+F90VBNII3E4AiBfPz9uQpcA\nTs2xXIO32jNQQApcjo7FnEhdXJkHpYXmFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAVai1lZqI1PPpEGx9DZ07I2NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBkMjIyYjItNmQyNy00ZGFhLWJhYjUtNzM2NWE2ZTBiOWViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmUzOGZhY2UtOWU3Yy00\nYmViLWJkMjYtYmMwOThjNjVmMDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDRW6gxEsM3EzIhRgg8aXgtrExiZ5lvgio1rQeUNqixuZBs8rYdmuwrSS+PNPE19d\nyovI4mxGSznVd6RJlgywHqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUONvF8Y5KPdR02dQx\nSmNh/uKCepIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhALMke1Qf5Asa+jyzIQZzqjinKkg2qRZ1mDO4nioLnmuUAiBm\n4PrxT1EXUn+c+e92bhy05DA+kRkTr4MNDDzzbapgtQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4102", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4102` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAXekLNs+IKyeaGhvQGXHfwC1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwYjcyZjViLTk4NjAtNDFjMy1hMTM2LWI3MGJjNjJiMDQ2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY2NjJmNGEtZTdl\nZi00MWM2LTk5NWItOGNiMWJjNWQyNzU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc/+ve3ELnKrfY2QHD0SqqnN2NC9CWsXQK9/hMhp0vMSi0yb8Wci3ztU55dVd\nDJ4J80aaDbZYq/K6eCbOfjTgFaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq6r01/vsu+jHxz430dUzqBKhhT4wHwYDVR0j\nBBgwFoAUmDp7SC2+YPqUn0gxAJvbjg9NJt0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAly8zJ7hMnv4r\nJXYS0wU/ONQ9f1CtjczNlIL2fsecog0CIQDNurAtxzFNgWV2wrz4QLvyEGTEBtni\n6pWwyzokaHKZ1w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXTYtiRivC9fwkXpsq14ZIeDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMGI3MmY1Yi05ODYwLTQxYzMtYTEzNi1iNzBiYzYyYjA0NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrRZtVKNzgs029laEUnSMvjkkj9zb9iQPrtAVXlYud1IaV\nA8f/Xjzs1iE+5b9jfxhbjnmHhfVQ4HzTVgV8OaOCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmDp7SC2+YPqUn0gxAJvbjg9N\nJt0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGiiRVXAZHPdQewsV2ia937opI4S2F8MjxPujuax/gjQCICIvUjiXHnFx\nM58Khds3IwnoJJ7o9hR9/v3J50g/iosw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAUzc+2GshNSJ47G+4sAgNxxJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY2NjJmNGEtZTdlZi00MWM2LTk5NWItOGNiMWJjNWQyNzU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWU1ODcyYWMtM2NhYy00\nMDBkLTg3NDgtM2U3OTUxMzA0M2IxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGIDE7/dkBI9rUDtHtg+EAdkgQozQKfwo3TCgQplYYy6GxwpIgrkrRabYyWV3y3ub\nWvypdsaP25hlxOPb3MGIOKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUq6r01/vsu+jHxz43\n0dUzqBKhhT4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAL2nuZQplLhrrrKLoIKr2csCXaLXCqUCqWYohgxQE/6nAiAN\nwisqZLIapU9wyy5WMGErC6ZdBvCbx8FlI+/JLqNn2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4103", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4103` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAb5eX+QkEE4MkLqs607mF4FhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwNTM3M2ZjLTVmNzktNDMzNC1iMjE3LWE3MTM0OWRiMmMzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBmZDVlMGItNGE2\nZS00MjU0LWJlM2EtNmM2MmZjZjgxYTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz5s4FSej3AyWD6sIlhTl+s+7PiFoIEEDjSq+5+V0BCwSCMIME9y830wAQb3r\nmLv42AeBPvzAp1NQIiRcuVhPxKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIGIQwgGEOKIH1k+H0HxDd2vOTdYwHwYDVR0j\nBBgwFoAU0Nx6SqskwLuY5dWSiP0Lvs/6FhEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCTFYm7tl137QLN3nOzJPZwWqfD1lvHox0SgKbgVPU8KQIgXYayMpGg2dAb\nTieNAeFcSdUCWG9xm73dlNAJhhtaYrA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXjZmJr/YvcMHnf5B3Bb0ZoXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDUzNzNmYy01Zjc5LTQzMzQtYjIxNy1hNzEzNDlkYjJjMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxdZCG3/0xrx76ZK6NzyJcbEdx3ypJdhmmUewPXHGkFrrT\ny8W3idQW0/A1/qFZhcd/oaH3BfRJJdv2g+bWBmxzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Nx6SqskwLuY5dWSiP0Lvs/6\nFhEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZFko+BzmLiauQGvRByOIpDnNgqNHnjtyOhVbWWsjhx8CIQCKvkAKWmfX\nn08WTU7iKbMap+GIgL8v6n1Y6se/sNdTTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZ8pma0MdPVf7BbBxbvQt98dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBmZDVlMGItNGE2ZS00MjU0LWJlM2EtNmM2MmZjZjgxYTMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWQzY2I5OGEtOGQwMC00\nY2RiLWFkMjAtNDQ4MzY2YWVjMzYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNbZlwIhJhBbZm88SuosOmbWbbMdgnS4WVR6KmIzB16WNxfEMGGmIb1GrG0JWXEmQ\nH7nzhBphWIoaGN8JBfD2Z6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIGIQwgGEOKIH1k+H\n0HxDd2vOTdYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgBaSBvOO5G7+QmLvf67/Jw0W0FEjr1XCEYiokZ12VY9ICIQDY\nnk2eX3pU+kk/8DzY6sG7250A3mS2NowNobzSDwjF3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4104", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4104` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARoE+WaSPVc2bAk/ZydmhIcTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNGE0MTQ1LThlNWYtNGFhMC04ODk5LTg0ZDU0ZWM2Y2M4NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODUxYjhkMmEtMDYz\nMS00MTQzLTkxZDEtNzliYzU0NDg2MjBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzBBbQAk5sXcnM0/Th0wEzXAZU1dP1JajKU4IoGHBD5Fy7o9O0vE9ugIzbQHS\nLS4Af1weN+ZjkHoOSoecyb98pqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjsoM6tU0tdhrTBNRdRrQPNHmn7EwHwYDVR0j\nBBgwFoAUIMeaDJ8IwQR8phwLnfmyW2zXFgEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCFf/8ApTeIzn+V/ACrd0hW3qgdOCWbE7GWU5dsFHwEJAIhAOjqkAuM0mbj\nE1q1MzqKVvfN8wHn7Fp4JbPYEs5camaz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbL4Nh8YR2cAeh84g5wab1GZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjRhNDE0NS04ZTVmLTRhYTAtODg5OS04NGQ1NGVjNmNjODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDySn5yo4JZdXB6N+EikhcArfhZblNzBqY10BxfxHoJ9aT\n+QXyrbL6ecHsItFqrJhYn7wDC2uTDqwAg3eF7WEzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIMeaDJ8IwQR8phwLnfmyW2zX\nFgEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJQoMEmO+17DJ8QpnBZjIqPMjvbaBHeWnIMhOLv837ROAiEAnAR4IjIQ\ntStyVkfU0oJxV9YmkxkbIrXde9xxrcfs4mY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAcDQLWVxsGuFo9hAox1ZOTM8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODUxYjhkMmEtMDYzMS00MTQzLTkxZDEtNzliYzU0NDg2MjBhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGZkODg5MzItNTFiNS00\nYmRkLWFiMDUtMWQ3Nzg2ODVlMzUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ni4vaWhI98AVFP51JG1VinJ1MKa8nKMLW33AtViehjMkGnRiqckGHVAmJkJDr+SZ/\np5B8VX9yT8oBulVSo9p3FqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjsoM6tU0tdhrTBNR\ndRrQPNHmn7EwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAO3GOZBoibuz3kDOuKMrYF6qgIKcGvFsfeyCOLFi7Oj9AiA4\n/QznxNzw8kZy7SHuI5Xta1KAM11DAe0YO6amfF7gyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4105", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4105` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAf/FNRUj3ftEUnIdTQPU2rXEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxZWI1Zjc1LWUyMmMtNDdmMS05NDU0LTFlNWI1ZThhNWY0MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI3ZTgxNjMtMjQ1\nNC00ZGU2LTg4ODYtZGYyOWUyMTliOTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELjllEd1IrqpxxC1uTMzVoQ8J0j3YMjnNKS7+UYskqqFT+GBy7GIneaitWdmt\njPc8F6NK0ZdaWHSahknTEzfszqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMirDsyZ+RxMNUNGyFg79fXZXtI8wHwYDVR0j\nBBgwFoAULSHgVgOscEudAR+JmXVbCLVeyZwwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBfCAZsCA18/cGjSfEiyZ5Fb+ReATAMPuG8aX4fDSYjIwIhAJ3juhf5klyx\nIUIXoRo7OSenVk6SUxifDuJstn58M/fD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYwA2cTWdX2Alb5HUR1hJ7o3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWViNWY3NS1lMjJjLTQ3ZjEtOTQ1NC0xZTViNWU4YTVmNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjuxDyWRoLti/Liphlmb9hYsusMe/Q7ZfKZ5QbmAu93XmP\ngSHayHMNjWi0o4kaqR5GOwXbkqR12zHO0GB8lRY8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULSHgVgOscEudAR+JmXVbCLVe\nyZwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAObXB5UWNQV62F5yCV5fRvtfd36YOEiY/ErESTx5EuE9AiEA/dLJ+6Iw\nLrsVYqgocvoQZr8+Zcd/D36gUxeTw1AkxPc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAVcyXrKC4DsQ6k118E/YneMSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI3ZTgxNjMtMjQ1NC00ZGU2LTg4ODYtZGYyOWUyMTliOTY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjcxMTQ5YmItY2M5Zi00\nMGUzLThjMGItMGQyOWFiOTA1NTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJZ1c0/OQj7b/bOONkh+PJY1bvG4eZgWuEGMCUV23AEbvQ8NOPJbujOyGm0RPW3HM\nIJL148qqBFKo4PaD/cNKJaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMirDsyZ+RxMNUNGy\nFg79fXZXtI8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgOfjGbfI39SL25XyVs9+PpOM+nQWc6NvKVCTh8kYKnhsCIBgW\nXVGF09JoTV/8E+yifvbZYWUFsJ/HlukUF5EW3Z/e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4106", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4106` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAdf6D/hVFliOGKhWUfBxmONTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxMGEyYmQ4LTAxNzMtNDM2NS04MjU0LWY5OGUxMWM3NzFkMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZhMDg0MDYtNzkx\nZC00ZDRlLWEyYmYtOWIxOWY1MmRhYjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEakTFkF4pRcwUBfZwG2zs/ItzHeIH/E4X3mP245CNS72gjmhJ/htwgQWXZDWW\n4fHOzR7kOE0QxcWUypBpmumVaaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBeE+DWc0RYjuE8l5NYT+xy3NKL8wHwYDVR0j\nBBgwFoAU7TYvsLyzafzVPZGCvIKUyftKozUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBFbVl52VI2QASoW20dU8kVD6DD6PN0/ar4zL3geny+\nHwIgMS19QpP9xWP9f5BAlFfziM+I/XWSxZsHSmzbuT2ynN4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARfGY5Ej1W3UmDC9muQ8jQb3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTBhMmJkOC0wMTczLTQzNjUtODI1NC1mOThlMTFjNzcxZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQK2MGHF/fTCmLjfWDxqQuw5J7U+dRQ3W9uZ2GpxsTwxDtL\nyKqumuwAP+poCZ3VnafUxxUwGa7XxOw6p8fS24P3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7TYvsLyzafzVPZGCvIKUyftK\nozUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGxf5X/cyzTl0flPLi3lUS1mqgyELZhUMKOMbq+8odz0CIQCkISB4vRxQ\n6GkHEuP4BqAGsHPIf0tkTr1A6WHgCnwL6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAXzJcf2FwsTOyBtg3wwataD/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZhMDg0MDYtNzkxZC00ZDRlLWEyYmYtOWIxOWY1MmRhYjQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGUwNTQ3ODQtNTJiZS00\nODc5LTkwOTUtMzRkM2M5ODlhNzUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3pJQ1kr2UGa7Q404TCQslau6pMgCFZg831qiAnDdY13H649ZgUDQUYEzCbHavAQM\nFJJStcWEHV2K63n0jfaEoqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBeE+DWc0RYjuE8l5\nNYT+xy3NKL8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAKO0gpksEGjonC6furnYsAb+aoY1mev32ULOZlJIXrabAiEA\nnRFJoDVSHfx/tFRxvLqqe9ggBkybGVChZHgG5hDW7A8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4107", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4107` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAfCHGgoHMokkZPsa6q0WvryCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhMWY2MWU4LTBmY2EtNGEyOS1iZGU1LWM2NDkwNWFiYzJkYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjcwNmVhYzgtYWZh\nMC00YjZmLWExNDktMTUzOTQ2ODY0MmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEloOL+BIrDpE7krUmIv7WVNphVA//wDsj9RtAcuhn86XV67tmKzCOyqgdNKso\nfbkm4ga7le6lGv1uZhbV+DqMX6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU88iQzIYMErsosM2WoygJ8puNrMYwHwYDVR0j\nBBgwFoAUffGi0AFw2R7YmYGv9fgLe7Y7fh0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAhzH+Pc5otOG3+sAuXlJMXy5YIa39ktPnNuhRWs7z\nk40CIQDdgO2Vpa3NOkv8rp+qOkAS7CXjgtY+JJCNef+uR5t9hQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc3XSreln8X+8ZBa/zgu/qShMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTFmNjFlOC0wZmNhLTRhMjktYmRlNS1jNjQ5MDVhYmMyZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZFLmIUGa2LiArvKIYaut4LQXzyCw4Ly6nrn4S2zzForxi\nxhho7TtgO0HwizA9KChG1lGWLTjN/nRsTc7fXQCto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUffGi0AFw2R7YmYGv9fgLe7Y7\nfh0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIfwqrnXle3Hb2IfZ2Nfun2BrP2fB4JAIxQ6kLrCG7yxAiBqFz+b2YbY\n3lougNB6Hm5gUYQDWbxhYfxaafTRpH/HOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAWqbugX5Yd64ybB6vWPK6f9aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjcwNmVhYzgtYWZhMC00YjZmLWExNDktMTUzOTQ2ODY0MmVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjM1M2ZlNDAtMGZiMS00\nMjQzLThmYTMtNDg4MDQ2NmMxZjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nymCoe1t+ixUkBW9J5O9NaNrRLILdymwiNs32aCfRgwwi+q4DQQjd2xUz/2P7FHpB\nuvlFUtgmiyaI15RTZ0gF3qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU88iQzIYMErsosM2W\noygJ8puNrMYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgP+TT875WCRoirVsck99xxcOP9MmkVKUQycyR3jT0B3YCIQCr\neeilWJhp6tb63UbEPHXAIRi2/IArIYSX9o7I5brRZA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4108", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4108` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVsrg35qmthShOAXHK/+RLNbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiMzk5YmJlLWFkNjMtNDAyNS04Y2VkLWZkMzRkNjAyZTgxNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM2OTI4N2ItZGEz\nNS00YjAwLTkwNmYtZGY3MjNmNTliN2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM3kuidce33rniZcv7g7PT5kmZZDOTs2MUc4KDzgd0R+EH6KQ5+c/ejonAfn5\ndkv9tKoewiBRsJxex655/ZtbsaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1+9DyOXptUExm4hlYKD44Np3s3gwHwYDVR0j\nBBgwFoAU2d//YrHsutexA6GBTcih23hFQi8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAycPqfVGVrh5vAP9LzgeJEcxNkqz7aox4JNTskR2zSywIhAMYu\nSgtDnvfMZ5mvSmzNbM4UJkhNLbP4vFH2UFbeZPKy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUQWizG6nDCA71a4HHF0wpzgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjM5OWJiZS1hZDYzLTQwMjUtOGNlZC1mZDM0ZDYwMmU4MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmFzeBk2Ru4+7X/EQ7uXPcbve66v75Nt2I93YWNMYbYnWD\nMyUovxZQNCd3SA6X3znsAI2jznqcc7SnN+sSqsnJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2d//YrHsutexA6GBTcih23hF\nQi8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPsbq/CRK2JrYD401ACa7X4Q2nFtcdFtI2nKMN/4uxIxAiAF6FWW8+nL\n6ZgVtI5/gCzhXJUCRpC9je7Z5+b6zNWzBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAca9eUQ/S+H41o4GPQLWEaJBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM2OTI4N2ItZGEzNS00YjAwLTkwNmYtZGY3MjNmNTliN2M4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTRkZjM1N2EtM2RkYy00\nMmNhLThjNTEtMzUzMDE5MmM0ODZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+P/uzL60W8DUmmhjJWQzpsriVWH41w1OPYfypxpCCDE9samTmdBjJWzBAMSW29IA\n84Y128RQg0HrEyEX+/vKO6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1+9DyOXptUExm4hl\nYKD44Np3s3gwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAMW7HA1Ec2C8VyzQoDjtGMTtr/dGm5R4YzF4pLnd70QvAiEA\n/Tk8m6G7QnZWJpydT6eCAoPcChj9OkBxWZZScDW7/Dw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4109", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4109` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAR99rPS2Eo8i5h3Xo43DRQpWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3MzUyNDNiLWYzZmMtNDZkYi1iNWM4LWY1NjdkOTIxZmRhOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA3YzA4NjgtYTQ0\nMi00YmVmLThkNmEtZTRjZGRkZGI3ZTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzFtK3n2vwe2sJSs3dzqUMonbJV+toPOp+ukkZ3Q7BccQksRKzO/tNxrhs1Lv\n9q5QKGNQ48zObdBCENmwvTj7UqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/MDWRbQV4QwGZP7dsHLWo7yFeXQwHwYDVR0j\nBBgwFoAUda8epQNn+GybQ9Z4DI83YWsee4AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA6HxdVg5Iz6qFsobxMb8Lv/XFRJNnlDmm\nYCI5bsoAAooCIDTcBv2cjt2wn4N7Y2Kz7qzoXd2fik4uYvain31SMaFm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUa/DtwFm5Tgf/cC3O8lbKv+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzM1MjQzYi1mM2ZjLTQ2ZGItYjVjOC1mNTY3ZDkyMWZkYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHdzU500HsYfH4d4ZE3PThBTc4W7y1oymxznC3p97DbMaf\naomc+ffoflPl6N/II6OVHQlbat5rI6zaNKSmK+/do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUda8epQNn+GybQ9Z4DI83YWse\ne4AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMg09t57MH6E9rp8cxSsAFht7zTATv+JAaXOd0buN93IAiEAok3q2ps1\nDkstt1UUhAWimyBEITqLQcMQbKQSX4Bg90o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAeac/WgnIC7hsCJnnPz+E5hMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA3YzA4NjgtYTQ0Mi00YmVmLThkNmEtZTRjZGRkZGI3ZTk3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGQyMTJiYTctZTQ2ZS00\nMWQ3LWJmYTctYjI2MzE1MGEyNzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbHAJwzVkPzmiDCHTZgZRW4Z4QEqt8DIsB9Eoh4KHsttb63/8bhDEQMdZqn5conx3\nxwHu3umBfsUv7ppLBN2FbqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/MDWRbQV4QwGZP7d\nsHLWo7yFeXQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJkWnk+unAxlbV0Ybl2rbJ7jRsW1CWynfCr10hfxeEdNAiBq\nz91BRW4e0lS72aBI6GLb/FzRCJxWh1F1fz6dTOWgZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4110", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4110` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATLL3DtlUOg2osdFMUWfBasEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmYjVkN2EzLTY4Y2MtNDJhNS04NDQzLTkzMDdiMDc4ZTFlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdhOTViNzgtMDAy\nZC00N2FmLTgxMmEtMjE1ZjcwYWUwN2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEveRfk35RsqPJRsY8+pHQUMDWKv3bBjhm1qIyvDpPaAMm6UAFKOwjroxH6taJ\nOgv2j0aBzc47asnZRFoOwZcKDqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUotko98mqP4gICxeV+r1tqC0D5NgwHwYDVR0j\nBBgwFoAUvLDTNyrZ9cMcmdSjOz47WMAcQp8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBVMxuAGhn3S/M2zSYX8lOpNzdHBk+OLOaV\nuNytbIx2iAIgOe1NmjRv4tivZLOT1byceL90vfZhNlb/PT/9vgEHfYo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZORTsYQNICZiPnAJOsEb8tfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZmI1ZDdhMy02OGNjLTQyYTUtODQ0My05MzA3YjA3OGUxZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT681YdwIJRRE72gF+i9q3eHF+BOyLPamqA3hUoyxD/1zQx\nFCYvLe//8X2t7x10MX+JlR/kHMLN3ux8ACf5CMKGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvLDTNyrZ9cMcmdSjOz47WMAc\nQp8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI5/vOY0gEY8dwtwV66wTrzzAZp5PfUAbrAdJgss6UqaAiEAgrIg7cxv\nUd6bkZLgXbORGdeoGJo7PcRsfZ6L3tiELDk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAYlNpOnoJf99ux60J8eF+n/ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdhOTViNzgtMDAyZC00N2FmLTgxMmEtMjE1ZjcwYWUwN2YyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDE0OWU5ZjUtOGU0NC00\nNjZiLTk2YTktNTA5MjBjOTkxODliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPo04PM2xhi6+y/DgBDraNtQTI4zYfwNkeapR9m9Ul+G3L/2H5N//iMh9tDJwRGqS\nyb4cmkmK8tlHHg7Iu8trj6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUotko98mqP4gICxeV\n+r1tqC0D5NgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhALilC9M7dSk0hqKeTTqz4Pctl6oo7y0CXdIWn7lx3uAMAiEA\nzLR/08sEHOcKrIMhISf6G7pXyRnDPuvaqXrf6X4JKkw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4111", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4111` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAdF+MGGXM2q4MVrh4/C0YqNGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllODJhNGJkLTVkN2ItNGMwMS05MGMxLTMwZmMwMTM4ZTI5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjAwOWQzNzYtNWZh\nYy00ZTc3LTg1OTEtNGUxY2FjMzU1MWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs63UvfGpdrJFzEutzo2Ts6OqOJ/I605q7zlXUsQBdhqAD/Zo6HaTMyf+QTt+\n6CtDyyYw2RjLNI+XycTcpCUpA6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmi6v08NtsKbFbjBdT8uD7M8H14wHwYDVR0j\nBBgwFoAUg/Knn8qUK5Yjv9b4Fc5Lpa2wgYswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICnWWW9MsZaYDTKVyhPXRKlcMVVu\nyXWmIqTIPx0rUOy/AiAX45q1AZ1jmtKx+NQ2wu9CKNGLjRMe26zN/cbyi4xzyg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdF3yoeLszv/ksnD/aCYbBT7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTgyYTRiZC01ZDdiLTRjMDEtOTBjMS0zMGZjMDEzOGUyOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu+TRLKBLBKqv7ey8IggMXaHD4EtdWep6zvKN0gy+DUjqg\nUvRUjioxaJikXBKFHJAnONHMm72lj5qZSr0Za8xlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg/Knn8qUK5Yjv9b4Fc5Lpa2w\ngYswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE4MMUs/h5BK+thjPRrynxcKYwn0pknGlzpizRaTAGzgCIQD1KyMEWKNy\n6o7NyE8Gh0v6Di3+wiSZhVNk+3TRNzyMjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQFL48vmtoy5DcEgBcoUy9kNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjAwOWQzNzYtNWZhYy00ZTc3LTg1OTEtNGUxY2FjMzU1MWY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTU2YjFhMzUtMTUzZi00\nZGM5LWI4NjQtMWY3ZmIwYzgzODBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nw5vWgTCyK65U1bo9mR1D0+wqBNdnk4vjuaX5B2aiqvtxD6EP3BV2rGJ5ZVXgz/gj\nDWrsy8tvKqw2GX8FhQI12qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhmi6v08NtsKbFbjB\ndT8uD7M8H14wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgSaU1+vUb4SFZ4bdzLusptsWMq2asJBohrBSxkNpg11MCIQDn\nY0XmCnHM8dWCtxPFi5XOsqSfpIe3ntlvnDZgPgVZnw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4112", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4112` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAbNmeXgU17kerxSI9yRIvh0hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2OWFlZmFkLTI5ZjktNGE5Ny04OWZhLTI2NTU1OWI4Yzk1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjMyNmY4NWYtMmU1\nMy00ZDNlLWE1YzYtZGMzMjI5ZWUzNzNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9UxdZ7mm1MGv18yRH04AItMQi3LUTG0EK1cRBNTYPoaCVwGP7kdico1vJT5j\nFqOlk1CGBjG+RjgHFVzJexbvsKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDrKN6AM1pLrbrbWCl5Mb2CmQDTYwHwYDVR0j\nBBgwFoAUJjUp1TLzIWKjnieJ4ujqNBVuCLowKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJ5WJ5nb\n4azH5nQ6j6aQIhiexMH1kjiXRaknO8fGkZyAAiEArc1nQd78tj2xNkO077Tkscoh\n8gLjcb3bnfDWjoRjGA8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXR4ZGN0pqXZpt7y5qM80IBhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjlhZWZhZC0yOWY5LTRhOTctODlmYS0yNjU1NTliOGM5NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3j9CzOmG/B3Agi8Og3fMBwnJnwzjO95LFvif6kZihqEDZ\nUbW5fBQr/hfpZYiQ3SnBsUWmCV0w1u/rcVxwODUBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJjUp1TLzIWKjnieJ4ujqNBVu\nCLowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKNCWYMmV5/yELNG5UdhzptNRhpB01qknnY6DVTmkV/EAiEAk1zB3ft6\n+N8E9dw/LIlj0Ik6RzmKVEo37RHEwKl3fqA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAcOPjmgFbasBjCOY40nJnacVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjMyNmY4NWYtMmU1My00ZDNlLWE1YzYtZGMzMjI5ZWUzNzNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTNiZjBkNDEtNzViYi00\nYWQ3LWE1ODAtNjRhOTI2MDQyZTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvJnfB4VqGS2mbY9Bmy5I4OXTin6C3HF5WqoA/xUqdtT/KYRcAXV0FPj1haD8xhW0\nNptjd19f8XGwNP1XyKqtkKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDrKN6AM1pLrbrbWC\nl5Mb2CmQDTYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgFGkY15vqGwVxRNUIX6gt8FvOmu/G62RF+OunYE/sLekCIESp\nT+DC05v3WjuLxeQS1OHtA90urmOg0JMRvdcoBkZN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4113", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4113` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAVyBZR/vbxxGmV5UpKNnBQthMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiOTExNzU1LWI0ZjUtNDgyMy1iZGMxLWE2ZmQzNTZmYWY5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZlYmRkNzctZmM2\nZi00ZmIyLTkzZGYtMGExMTNjZTMwOTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwgs+Wu70tbtpZmYOwdXoInuteBvp9Oyhx4faRGqkU/OsXc2gxBY/9flzlrd4\nu5PGGQl6Sk530Zq4wIQGiBFCaaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQVY/2m8kkWyh4QKdNBDEkwDWOEYwHwYDVR0j\nBBgwFoAUEcSv9sRoLsTyTHWdc3OZfrR4o1QwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgNvBP8xMU\nmgYvZ02uT9udFYdemye8efQRbsk3Mev2/YYCIQDzwvs3kzU1/j9//hbg+q2q/PHO\ns1X2HiLdC/vr3w7j5A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXtZAE0o8x2McXyc93urvmncMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjkxMTc1NS1iNGY1LTQ4MjMtYmRjMS1hNmZkMzU2ZmFmOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6yH0yEcPKXt7QNPweRp3oWGT8HvcLtZhFEjE1eysoR7kq\nF8jM3Fz2GiK06UuvGSd9MiK6y8w9hOROlQPG2tFao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEcSv9sRoLsTyTHWdc3OZfrR4\no1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeJTwQzIukmtD/xi21lnyftPsAq1TeM/XvFFTMcHXjJ8CIQCU0fG4itVX\nwz7alOkDl5evKiWHuuH3GewWEOvnwCJFRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAT23LBuDn0WpmLnbOVuD/Mk7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZlYmRkNzctZmM2Zi00ZmIyLTkzZGYtMGExMTNjZTMwOTNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWJkNGI5MjgtZmVhYy00\nMDRmLTg1NTQtM2Y1YjhmMzg4ODhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nnEQ0B4++nSeCKmXR2b9oxasHTN1PTIlmdulH/aE1qtj2K5WzZ5UL/uI7VqHkImz2\njIwy+E2yAxmkG5S9JPZFEqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQVY/2m8kkWyh4QKd\nNBDEkwDWOEYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhALBy+d8S5BzzTG4JOPQQXww5NqcIh14DyMoF1yM1IZkDAiEA\nsiKDeG9iVmxGdDwzArneQwYAZ6vevD00CpjNCcN38FU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4114", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4114` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAQ+W/aiSTk83hZsvxBg/W929MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ZmM3ZDQyLTE0ODQtNDZjZS1hMjk4LWFlNmJkYmU5YTU1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWVhMzUwYjUtODRl\nMS00ODhlLTgzYTMtNDk0ZjUwNjNmY2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7F7o2PWpb7+KVKucQtBomEUkKjn2oW5EJQkfT2eU1KGgOSff58xCfHAFl7HC\n6FsG1fx33chxv78UEupGc4VkqaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrtjfsdAp3ZieHTgQe20GmKbX7fcwHwYDVR0j\nBBgwFoAU8qFme4RCB+Di4COSlvgVNoYEMEwwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICtXOb6+\n1Kq7ROiXRP6qQvRiE5T4Dly4HxmKATynvkVYAiAy0n4E34AYmaQ+JHHoU9B/3UZD\nUFjiAThtR+PHgkH9tA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd3J29rJ2SyhKcijghPYV9EXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGZjN2Q0Mi0xNDg0LTQ2Y2UtYTI5OC1hZTZiZGJlOWE1NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSf+U2YEG2rUoBBYKhEF62lB9zK0ljVTmEDBiitFmYCeTX\njuS+VpX6WNBz0glFkdL2pWxFDFbO/VasY//iB6Cso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8qFme4RCB+Di4COSlvgVNoYE\nMEwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKmmehMLNJ84ScE7obNRn2V9lv4cTzHd2mW3JD61YNdCAiABe6oBMeOz\nF/pohw+203Bz7i0cVbo1Qb+TIW50kzzxEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAcXX4nlekptOSD20wPFUZLADMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWVhMzUwYjUtODRlMS00ODhlLTgzYTMtNDk0ZjUwNjNmY2Q3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTUxNGRmOTEtOWZlMy00\nNmMxLTljMTYtYmFjYmViNTk3OTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBhXj7nSt3p9BFSwJa8QIm6IVqV1vSbNNFIDunaFbz4e356S3edSv+qIvby/N4/t6\n9c4zF0DcZbTRthaP2u08XqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrtjfsdAp3ZieHTgQ\ne20GmKbX7fcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhANSZEw/tfhHL5kiEYUKcCOimFo+lCOmp69E4aOx2BWtoAiBx\n6Hy1tymGBr2p60LyW0+1vWTcF091sIt9BwINXAXjqg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4115", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4115` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAe/LfefZHhbSIcHbGxdPWAkcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlNmZmNzUyLTU2MjYtNGY5MC04NzE3LTdlNzgwMWRjM2E1MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdkNjkyMDctZGJh\nYi00MDg5LWIxNzQtMGU0Yzg4YzFkYmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvKQ3No6UQoWLBkxhYxYK2DEXs9BRb5mcDFk6xDoCQi+RmzfBVPlozp+s6M4q\nAGQJzzZ/1nYX4xDOl3kKIhdHD6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJZRvm74qPfQUadRd5DgsH89GGa0wHwYDVR0j\nBBgwFoAUntct9kAOUk+cmGk7xdEjn6iZU8MwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDYO3veZbcouxezM1RCEcB50nUwSu7C0kcBYll5KQNXggIgLiiivqM4\nPEeY0t7gWfoJyxgRq/L/WEvwqvP6uDbETpU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc3u+YTr44JIpx8nG5l4pN4FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTZmZjc1Mi01NjI2LTRmOTAtODcxNy03ZTc4MDFkYzNhNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHGnBBIrT8RJUc7eAN+M6xB1sxoUF0EdNLLudK/RI9ybJM\nyC99gsRT7KrRHB9wspgOmuLz/GQpBnoV/a3Pte68o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUntct9kAOUk+cmGk7xdEjn6iZ\nU8MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOpOMIRAbif37n2Vqkdq1tdytAH+845yC8Tewmg9svNoCIE9iKx3vpoBp\ntyG34osBIHhM0UGJuYJbpUOczXXQK7bt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISATb99fFopeMi6D5JRdJAy05eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdkNjkyMDctZGJhYi00MDg5LWIxNzQtMGU0Yzg4YzFkYmRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGI3ZmVlMGItYWFhYS00\nNWE4LTg1YzMtMmVjNjljN2M4ODlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nA+JNE0jV+KV368CVoBBOdY01mFGYSk85Fh3PZ7yvoTw1As/uXeysNvOg9GMOhhEK\n0MmPxBwKf15RuE/CdjWTPKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJZRvm74qPfQUadRd\n5DgsH89GGa0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgA6kL2UZ6nLptYbwHzIQCkWDSr10IbsK9l0IFXg92yfICIE8Y\n5QisMlJLrplIt3CL+CbdPLDOafFZxxXaLFsP9ITn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4116", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4116` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUMzO1/ngaXsbXyzvfawmlF7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzZTQzNTBlLThlNjMtNGMxZS04OWZkLTgyOThmYWM1MmMzNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY2OTQ0MDQtNjA2\nOS00YjEwLWFkYTEtNWVhNWI4YmExMTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBFF7aZAYTtmwVwvinpxRynr6TT+pQYj3UsehuRA2QBtaOxigVraluQqXAQs0\nrZdEE0zsUA7jMLSbSwCwKfxkjqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9M8eNczGTBdc//IN3B2JujXgThMwHwYDVR0j\nBBgwFoAUutWP8zlpJ68RNU3kBeEHUKJJe8MwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIGp8/k7WHXBocbRM5KHLoVuHIeUq9zsRJdY3UTqKI7mgAiEA9oFBuz2W\nmtzKibyMFvDQuVrlcUZmZPDljJ0D/+ZT+Jg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ5XL5KiLXIRuZIXXyAyY17bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2U0MzUwZS04ZTYzLTRjMWUtODlmZC04Mjk4ZmFjNTJjMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV5xQjWmv3oGI/2O3+UvC7yxUqsHz68zFXcbOhSUucZULb\nDJaOafsaM9j5IGMY8/HvS9LZbLZUeZAsXHpQO0zHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUutWP8zlpJ68RNU3kBeEHUKJJ\ne8MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ2SnJshWH+8P4PBasx8njdwb6ExWSiXz9Iyq3MGsN5MCID57TakkJZDw\nXKXs14f6+6f8dMuzTYp9j78glmcG1eGD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAYR89oyUcGaoWeKozKE2LIj7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY2OTQ0MDQtNjA2OS00YjEwLWFkYTEtNWVhNWI4YmExMTYzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjY1N2M1NGItMmVjYS00\nNTExLWExYzgtZTNkM2RlNzA5Y2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nimzAlhgaX2wumgSpwB7SU/W+g/mtsoomc+8ftnATVeny8KZpS5U+3PiW2xt5lQqq\nvRvmYcVfP9QYoclRpWGzm6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9M8eNczGTBdc//IN\n3B2JujXgThMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAOOesF2sny69aL+eLSHD353+sa6pSpYvwE0zS0nKTWpDAiEA\n5Pp+8rgrDFowaQMqy7CJOCTAm5mxBf/o3xMN+twT0hQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4117", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4117` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAd7/3eDOggNeqHUZ7E3QojMyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3ZTZlMDVhLWNlYmEtNGNiZC04NGNmLTI1OGE0NzdhZWExYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc4YzgwYzQtZmY2\nYy00NTlhLWIzOTEtMTNlMjU0ZGU1NTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYOOu59RwVMNyn6+Jf+1Jr8ZvQHd+6kB30AwllI793OvcLKcy6B3BcwDqMJgx\nET/TW0qzZ5gIDaAH13cqTh8hyaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXt60ChHwhoQyZ+3a/CSoUK6VTzQwHwYDVR0j\nBBgwFoAUG/co5F8lRTQqpJ1H96jvNymXqkgwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIDyX/iP1+QNmJlX3LfJgGRY1g9ji0x38bcS/HrWMgSLtAiAmRHvvgndcsIr7MiWV\nMQvcf5MHxfj3ST8q0tTuL687OQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYZmo7a52AqIYrIXefUcOSogMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nN2U2ZTA1YS1jZWJhLTRjYmQtODRjZi0yNThhNDc3YWVhMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUU8Q7t5UvJpGiTZ3sS1OPjoaLyPQDVw9P54ED2LdSdXXh\nXwXkeynkZAsDu7WZ2CICVaufIWDXUq2gYqFTWo+io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG/co5F8lRTQqpJ1H96jvNymX\nqkgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgb208lrvBc5lH/rsEX/WfljkkTH+brKjPUhAoQyvCc1cCIFKJQm+IDOaS\nmoLU/dzTjwqYTypultKjUH9eOK5UGB8b\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAVKa6K7VWdR9Ri6044uSQvD+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc4YzgwYzQtZmY2Yy00NTlhLWIzOTEtMTNlMjU0ZGU1NTc5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTkxNTZkODAtMjBhZS00\nMGU0LWIyMTktYzk4YmUwYzQxNGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ni4gYILvI61+oYNPBqsx3ZHF1eBK8vE5Ls8Ogn02dlQU/Dy0Bg67Fl+s5r5N9ZJdh\nONL5X2drFtUUKyraHpOE3aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXt60ChHwhoQyZ+3a\n/CSoUK6VTzQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgZklGhcwb0xgt2jK4Hor7p+400oq6xlSBj0hZHokasFMCIQDV\nbPrAc3UI57OqzEupwsjbEyCAcXroyoMpArjqWEC8lg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4118", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4118` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAXk0F4/OgAp8twb/U1FLjsXlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NzU0ZWFiLTY4YzgtNDAwYi05NmI4LTY5NTE1NmM1MGY4MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRhODg3ZmUtMTg4\nMS00NjBlLWJlZDUtYmZlNDVhMDBlNmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQWgwtTWsB4DYfz9lNmCUHAxDWOTDbT9tUlGVwEay0Ze3b4zrQ0UijhcAqxub\nOzDgVlLgcWot7dkPl2wXqGvYk6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpzPv5AA8NfU2ziHaWOJZHN5U3GkwHwYDVR0j\nBBgwFoAUqSNkmMyY5UP1rwkLgdbc3mzBlakwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQC2UeFs6R6qya1+rMRhUx6oPTqPQsO2Tp0igvlNo0DKQgIh\nAPJSg25CYELJOQ1TfusZ3y2jf7wmwEiLkm6Vdgs/nEN8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfpyMKOrpdWx9zyB1C/Xf9VrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTc1NGVhYi02OGM4LTQwMGItOTZiOC02OTUxNTZjNTBmODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6QNrbhylA4Rh5erPSRfKmzErIRc64JJZptfmqMONTWcUQ\nxdl6l+VnVcM//Ci24LvW9cRng5nJFwa7A51BXukYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqSNkmMyY5UP1rwkLgdbc3mzB\nlakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga5TjH9B+y5TmzH2ZlJTfICPKVT4tNZyQgm88GkCZjacCIGA6waKxF9vV\noUVls2n/ff9m+SPCzs4MRKJGGvj75JuX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAf36gL9KTpdAA3ylmW5umbDPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRhODg3ZmUtMTg4MS00NjBlLWJlZDUtYmZlNDVhMDBlNmMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDNlMTJjZjAtM2Q2MC00\nMjY2LTg1MDQtNDM3NjZkNjg0ODYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrMXdzxRHZWidm0K8wypio+th0Cyc1m0Z2iEfIJabtkWqEjfb4dQPZ7SlNYrjcTlt\nFaRejg05EB+ZUXFBs9tb9qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpzPv5AA8NfU2ziHa\nWOJZHN5U3GkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJnG0RMZE2kX3z3y0g4IHYBnZeKljvIiZzSV9bYPTBijAiB6\nUZDJ7JTjuO/OCAz4gjI33kHLR7ztz1xXB3zxwb08Eg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4119", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4119` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZ0prxiDo6QtG2am7kXuyorWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2YTAyODRkLWNiZDgtNGViZS05YTYyLTJjOTA3NjRjZWY5ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWIyMmJiMmEtNTE4\nZi00MDRjLTlmNGItMGRjNjRkYzFmZGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDcnejTvcIW6H/VmF4ec90YvLsB1Wk03LEYbUwas2wOGEgJX+NBZxD9bsINH3\nIjQ37LP1lv7EL8I6RvMGDb85eaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpbXE2Ex7wV14VlDxDF1OXkiqgOMwHwYDVR0j\nBBgwFoAUJMneEDxioOqH3cm0pBqv9vz/QFkwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQD7JddWChvk1JIMNHFF54ACShuCueRhDrL2MzHg6SFGmwIg\nPZ5/zTKOkBAIbSNWdz9hBs+pU7f7sUwXLgfd1X1nvtA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcl9i5bxPuI3molTyaqqBIALMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNmEwMjg0ZC1jYmQ4LTRlYmUtOWE2Mi0yYzkwNzY0Y2VmOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBr2LfGmrlH0DznbtPoHsajE7Nsv+gMGmd2C8g73PBEASe\nXo9mBXmcPJCKSEkgNtRu0ZsXBDtITuoE7gT3XUbzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJMneEDxioOqH3cm0pBqv9vz/\nQFkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUh66U5gEDvl9uZnEHlDBClOiV/cCGXGTUxaddKpdYN4CIQDDZKk9ljU8\n0R/uqegTobDIIob7VTd8IzW9rkLD+OvNAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAWCdfhYWCKinGyf9JgURs8qEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWIyMmJiMmEtNTE4Zi00MDRjLTlmNGItMGRjNjRkYzFmZGVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTZhYjUzYTAtNjNjMi00\nYjA2LTg2YTUtMjUyM2ZjODYzY2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEjQYqPs8cZm+76FF5ViKdFEFj95278j99LQcP/6nJNMy0TQgjKBjEgUyAufKts+Q\nkIn+6MUpjZsV5knVGcmI3aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpbXE2Ex7wV14VlDx\nDF1OXkiqgOMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhALwlJcaiEzmmMo38WbOWZe1JWt6aEsiHYo4iUhnPf5UaAiBk\npjhh9WAIfcW1AxzK/Sp9mMHGYHTVw+yT5xYAbQ3E8A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4120", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4120` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATn+HtBpuSqYnvwyIpetTq6kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhYTlhOGVlLWJjNDMtNGE2OC1hMDliLWI2M2EzYjg4ZjZiNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc3MzE3YjUtNjUx\nMS00NzAyLWI1MmItYzYyNmFkZmYwZjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER5XCeA1vVB01WHzl1FU0rnTDGf/tn+kGSolVPN0r6dtRPDNobvUmOOVKQ3cy\nkGQ/rd07AK6jp2F0ICFvyPbcjKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWpl7G2KuTjnwypiWVADZOPpdrKMwHwYDVR0j\nBBgwFoAUwvJ8m2GulL6ilRCYDuxjrmTthl0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC11XlM6MYp\nIvyjTKfZok3s/n4S/fO0X8VhJ1QZRawBwgIhAO8ZwCW/0NkDVHpyta8MRI4/eGBj\ngNalDc01R0Ht+GcV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQyaL5pbczK2Rj2x2qO9w3qPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWE5YThlZS1iYzQzLTRhNjgtYTA5Yi1iNjNhM2I4OGY2YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARz5S9Np2njoVn8m/LRBwD4pCXm8XJnOc4mIyOJv+uLK7+M\n89MxjiJRUd2L5ihnNVvUgR2itlMk/1arFEUg6p/xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwvJ8m2GulL6ilRCYDuxjrmTt\nhl0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIQ3Eo9kpRyXrwkhtQwmk7PbGAKIhHHvCKYFBrpeB7hICIQCXrVsyPiZ7\n/h8FnWR1+jBwZeAzzI0/q65jv2FJtRxk5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISATkxIWnBDpvgwW59bnKFW+HcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc3MzE3YjUtNjUxMS00NzAyLWI1MmItYzYyNmFkZmYwZjY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWMwYjEwYWEtYTY3Zi00\nY2ZjLTk2NjItZDc0OTk2MDMzYmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njwKEvMSgGGQ+zlzJ0JSi+C04wcBnVVbp6yKEZEasaIO3ait76E//BJhppd7j9Pp3\nANjB5DPpKcJcNbOPeU81ZqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWpl7G2KuTjnwypiW\nVADZOPpdrKMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAPNkUBxk2icCCO/7DNx7cXoK0Y55sBD6nnFqZm4Is0bmAiAM\ngRnEXQgZwpMw/8XsExNQJvWikAY6CD8Z6RMAmpz8+Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4121", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4121` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAVmImjQVVY/FFm8ohKarN/pFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0NDQ1MGFmLWVmMTgtNDM5Ni04MjlhLWM2ZjFiNGRjYTlmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM5ZDgxNDUtZDA3\nZi00ZGNkLTk1NzItOGRjNjE0YTEwN2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED9kdFVtEgt7Do7FbXE2VynrxAb1bcVvZyVBhB8cxSL5xqtkPNVpfOCCzVVVF\n7R4vVzrv4lhmH47adS7pzWRLlaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU71fRPsMzylFt792s4idTpDj+cmwwHwYDVR0j\nBBgwFoAUuqSkmmeBaDw+DJlLglV+OVz9vMEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgUltU2iOhp13mWThj7wxWQZSxj3qoGKlhJpfwa5ANNL0CIQD8goSRUaxK\nWfjO6SiJyJDLAJnS/giNcQrPZGjONFQK5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd46txIch370/Wc008TFOLrpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDQ0NTBhZi1lZjE4LTQzOTYtODI5YS1jNmYxYjRkY2E5ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARY0vwPT4TmlkEfVur5CJexPWHtabGI0byKes3yN8FoPsld\nvBioZJd0gfFNU/8fL3k3FQdpthMQMJ4PJC3mPRp/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuqSkmmeBaDw+DJlLglV+OVz9\nvMEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgR2GAFRheBOIJx1Qj8sik+KC9BNtYt7L0ALjZgxBLjlICIQCAsL7BkDhw\nhdQ/pfuyUSlH+SjBvKLqMA60DRP0jAlbMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdbsYoESpZP49ItcHx7WGi0QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM5ZDgxNDUtZDA3Zi00ZGNkLTk1NzItOGRjNjE0YTEwN2RkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjNiYmRmODQtZWI1Mi00\nOTMzLWE5OGQtNTdmMTFkNmRmMWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niQOa3YLQfK/IVik5jeGFKRxaIqjWdVtb3RKr10glUQTHCd7gx1RjoqGSBHF1Bz4g\nzlhyU5F5vjfe1n+O4SsfgKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU71fRPsMzylFt792s\n4idTpDj+cmwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOKqgGKKZQa1QQXytQapbIk5PDtE2UAvJhgh2uxxmbn2AiB0\nrgnQ4tAr3KW8kZZ4XO49gA2EytEOWA+QrYdqKRIwZA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4122", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4122` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAaXdrnrmw1w0ikru1hTi+YL9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkY2Q3NDBlLWM0NjgtNGExMy1hM2EyLTk4NTQ4NGM4NWM3ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA5N2Y3MDUtOTll\nNi00MWRlLWI4NTgtM2YyZjJjYzU4OWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv7ovxA4c6KSH3fawUcPhmzxLr8Ldi+hntzsj2OciWWNdQ4h38QvaybZZV8Va\nl6UPnx75YpvzuC8t51nj5ZN6yaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzaqSch6Flx0in96aWzvbh6YO6ZkwHwYDVR0j\nBBgwFoAUWrZzCn7naToN0z4VUJbDF7bGCOUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgbymMi36kKrEXLHwD0jNhmf1Tq+qaXA9gU7j4D2ww38ICIBvRQhEWCJvt\nhK40hXYUyMJLObVjhTn9BB9Obr7Gi1gN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAauANIzc2AdCTSU3DURKPoqmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZGNkNzQwZS1jNDY4LTRhMTMtYTNhMi05ODU0ODRjODVjN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmse6Puh2F+PSN/dWabyyuiGOjpi6iis6uoAc3SrUi3z/p\nSxiNwYcGtZy3mu5RjlnzaOJc850jJtciG3m+Szkfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWrZzCn7naToN0z4VUJbDF7bG\nCOUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSp0MAQMSGmSkfhXlk/arJgUK1JYePifZGpmG8oYT2f8CIHwiY41twbzN\n7LzXq8FkQzil9rrs5onZfviAbWzJm6o3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdeoLGIG/NQ9Vr60p3nFaAAfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA5N2Y3MDUtOTllNi00MWRlLWI4NTgtM2YyZjJjYzU4OWVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmUwMjBhNjMtZmQwZi00\nYjUwLWIxMWUtNGZkZmNhYmNiMjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZCQ8TA9oaUrXDreAbjnISB/wfmdJSL3qQqNts7kS8KZJJgiDv4WIABummW9o5mb9\n0DaqZTEWrh8OdKnbyikkGqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzaqSch6Flx0in96a\nWzvbh6YO6ZkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgGCr84ESvf96+oicTXd8adjfMwT+iLOUNoU2kE2B3dsUCIQCT\nVTue38xIyQCTVMvRhlccv8Y2XWc1K68jV49awfztNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4123", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4123` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISATotgGvH3puoLkLUemA/CfsMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0ZTZhZmIyLTkwMTEtNGU4MS1iNWYxLWNlMmI1YjBjOGM4NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODMwNmFjYmEtYmZh\nYy00ZjgyLTkyZDUtMGQ3NmU4MzBkYzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV0y/C+fOXT1B7y6xtFYsQmerRBNGPbxxblXlZ/4XEHfyEvUQSvX4H0tlktE1\naXDPZg8Lsz8USLlelXvJYde95aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEvnoON5sCLthPSfupQ62pAynNIkwHwYDVR0j\nBBgwFoAUG+LcrUOAkZ6WmGb70pjEdypAxlEwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIDXBCrCSrBYM8r/GXAQSzcZUGqi/P6bpMHnOU93iLTzKAiAsdHluZNAm\nJOSwlw894di2CLaPBlLyhTIRm/tx/yEFqw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa5hGRhQ6PT2+o3APEhG0BqQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGU2YWZiMi05MDExLTRlODEtYjVmMS1jZTJiNWIwYzhjODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToGZq+Dfza2oTLSQW3jPj1GS3xeO+QuXGsL3LxVYZSvwzg\nIlx/rCDuCteGDw43oanBo6yHobyI4PEpXLzPG6V4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG+LcrUOAkZ6WmGb70pjEdypA\nxlEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN4+0IozRcQvEWg8/PnicSH8mZh0wu2rZineOX1hJdxgCIQCbp4aC6ffC\nE1g+3WM1710VZCHUBqWBUY6P2aYQ58CEwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAchHXeuoaxT5QCqfJe786PShMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODMwNmFjYmEtYmZhYy00ZjgyLTkyZDUtMGQ3NmU4MzBkYzI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTE5OWExYTMtYThmYy00\nNzdjLWEyMzAtNDUyZDNkNjkwYTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkGv+ZHKMEwPrKYoSFqG4qlcyTpHDz2y1ZWevjHqIFFht1d7bkSMDXjZEFIAS6C64\niElQVp0c3z43Tt/pA1DY16N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEvnoON5sCLthPSfu\npQ62pAynNIkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJRLDR+dJEDdwS1WEeWt/NYiRyJ8s4ZhK9n3JleO/UfGAiEA\n8IIaP4qj4tRrBt2F93x8HfRXK+zMtJ8QaJVTQjMS/Wc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4124", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4124` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAQQw8ZG+hMA+PFh0yVqwI2jxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzZDNiZGE3LTk3MmEtNGZhOS04MmVmLTBmYjcxMDBkMmZjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBiNjlmOTctZTc0\nYS00YTU3LTk3Y2YtYTE0NTU2Zjg0ZjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/wchzqHvN4dvlGZ7G+k911rLSv9YjF4HReBnL06eXoNsPmlCC17/POBETUQe\nozRKpataT/pNFdFy7j+0WGwyM6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpKQudAlEg7MF5AyNSzZoZQdFZx4wHwYDVR0j\nBBgwFoAUlekM108y1pM3KtDiu7bPGODTm+4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIDic6xdBdLF6DUJJTv37H6jlyxJnBXNUoz+su8RQ\n0SszAiBSgzvSK49opHYqHaXDCqcYhXXsLv1zH2IDc2I+119qEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXVaQAXglCPxyCEstjx/pVNnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2QzYmRhNy05NzJhLTRmYTktODJlZi0wZmI3MTAwZDJmYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2u+oZxQfHhuayHN/tqLB48BzoP6BRtUR09kJwdOkB1xgD\n+Tw9krVSEpFrOngBasH2HoisSK7YVHKSaKMb/i1ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlekM108y1pM3KtDiu7bPGODT\nm+4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQkWGCuiOUANvy0U3RVjl45ogG8dWjwV9/BtXlv+01ycCIQDY4X6Lioge\n7KH9IgsFb7zR97ST5Y4muEV29+jG5ArkwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAcdbOcy+l8G/f18ISiyX8w+7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBiNjlmOTctZTc0YS00YTU3LTk3Y2YtYTE0NTU2Zjg0ZjQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDA2M2M5OTUtNmJhNi00\nZDM3LTk3Y2ItNjUzMjZlYzk2ZDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+1JfjA6iMm581jxiBkzrzHpp1FZCkHNVH6x16IgYzXy0C6OyrB9fdhKhjv6VF1va\nk9h+YdQLqGdOAmrUOymd8aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpKQudAlEg7MF5AyN\nSzZoZQdFZx4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgDItzfbLDf+/Du4Etm9P/z5BKdWeCUZXtK+n7sjylh0ACIQD1\nppTv7NZY/oM7uay6C58C/PGgfrl2LV2XbwKdSvZjDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4125", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4125` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAc1+2wtLfRYSb53xP2MUtsgqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwMDIzMjE2LWM3NDctNDg5NC04ZmQxLWRjZWE2YzY3MzkxNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FjODhjYmMtNjhi\nMS00NjEwLTg2MjQtZjQwMGM5ZTExNWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3ZSlS2R8EZyP9vI+Wp3JG7riBtlQdUusj0b6d0o3d6HVDnmIHQrY69Abs9OM\n3t/MZOGvwn3oMM0Mslq6594xlaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT2fV33nwJ2AwRWaDe12nyy5QmJ8wHwYDVR0j\nBBgwFoAUjZb1mVr3L54fyz4Ft/NAjDZTxXUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIBmKcIUt8a7frAUsdfYSOKJdPPnaKI4ppQWz0cJJ\nHsH5AiEA50cCpAzDiF6aasEUy+F7hjHJx6jKjoff/N1wEXU/nZs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZjXZpIpzS5FHOcVQIzb9RreMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDAyMzIxNi1jNzQ3LTQ4OTQtOGZkMS1kY2VhNmM2NzM5MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoIAVNpWWK93vJwDlcW8cmx3EkBSYNrj9tZuUmAyyaHG0K\nnSLuc85IzLmO7asQivujjAZcCoE5zG41sprX3ASao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjZb1mVr3L54fyz4Ft/NAjDZT\nxXUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGsfZGBSm5Z/onfNTviuwEAthPKDlMLYak6d+ait6OmMCIHdzZmjJ8PSZ\ntfhR2MkGvALLm12eyfmUOjT+7fpyz+4d\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARn9xW15PyzbOTyRlpjxNayzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FjODhjYmMtNjhiMS00NjEwLTg2MjQtZjQwMGM5ZTExNWZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2UyYWM2YTQtOTc1MS00\nNmM3LWEzMGItMjIyNWIzN2U4NGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nq73RjcT0ELCziiRQ8U9qXBmNGyga2EQUMdwvdXoAY6J67NCF1RcudwB2ZorNl9S6\nPRbEzlFWae99IXqwonppI6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUT2fV33nwJ2AwRWaD\ne12nyy5QmJ8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgJuzlQBGdzPls0jyHxx/56PVzqxbDSP3TTd7gzwGh7kUCIQCU\nWYsoniFEV+YYwuwsjdqaetQJlc/nq1DhRW1PnrNJgw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4126", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4126` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcgbzyoT3kE0d/60YalqjLKMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiYmY4MmExLTgzYmEtNDVmZC1hMzFhLTAyYzNhMTI5ZmQwNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBjNDFjZDAtY2My\nNi00MTY5LWEyN2ItMjUxMWFjOWE2Zjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz3JgFqmabsdloXDP0ththMO6sewgoDMInqQnom1gR7iDcEQDtK5zdPQBYysq\njr9hqNK25yvLcok1RgCjmFJVMqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBMpI3rU5En6KIUxaHL8Z83+goP4wHwYDVR0j\nBBgwFoAU04oiRq3Fhsmd6yddOoMk/mGEw84wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIF1h1vRlJ0PTJoOBMMv/BGTbpSCO6s675J5DB1GTLQcIAiEA\n37jwlH/CvB8Y46re8RkD25T+Ef8yJGdF7Dhtr/JlP90=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXBvwQ3JEcdY5Oayf3+nJqw9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmJmODJhMS04M2JhLTQ1ZmQtYTMxYS0wMmMzYTEyOWZkMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARloqm6ZUVCKU+NAziTthGni7P4iK0jOnE4t3Y0jxEng9nd\nLtd5awf04ro1i2WeYHom3pwqnB5d8FBwYrqzlixEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU04oiRq3Fhsmd6yddOoMk/mGE\nw84wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZIsNJz8F1e8V8KkvB2jo0GRVxihuIzts72NuJQPMaSICIQCewnS4Dp6z\nu6e+kY8oTGoj7FSmM1FYRY1ycu4c5bWZTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAS4SaBzLwCDoCsx6ZPZpZN71MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBjNDFjZDAtY2MyNi00MTY5LWEyN2ItMjUxMWFjOWE2Zjg4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDMzYTYxY2YtZDZlOC00\nZTliLTgwODAtNTliZjQ2N2U2Mjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRpBYYfux61hRvQDNdYsuiSYjWXhwxGYHkWmRVIHQLsXuk7HV8KTzFMSg6Wui0U6/\n7oLAeJoY0UDw4Wymy8lv66N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBMpI3rU5En6KIUxa\nHL8Z83+goP4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgQO88vHEo5PFwcLnjgFozFIASk5qR8EJfFcrGeS0nacgCICNx\nrJGyK+39kpr4OIYHXGCkCA+6WjwZRpD/epvbTv8t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4127", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4127` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASopZAH0JnRr9HBJsp6JM7JQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1NjI2NDFjLTJiNTktNDFhYi05NjYxLWRhY2JkZGMzZWRmNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc5MGRkNGItYTdk\nZS00OTUwLWE0YmMtMTYxNDdiMDg0MTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM3ONwJavrFAsF0Mbsy03f48wcXxmzJ9mRgkETMG4FtDdzXnH74yBMmDue5or\n4W/6eD8rFg249HbNj31gsh6qfqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIOsuQuAULpAkuUYes53mO9vCIkgwHwYDVR0j\nBBgwFoAUdHF5jvj8ueYJAFNn6EimJW56l5UwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDJFjBe8jXffDznUMjJsahxKYT2mcKI\nUPL1a5djo6k0SgIgColz8are/gZkczKmuDb+oc/59gyDFi8apYjSKymF8aU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASnkIsU+nqr7aDhRJqREpgz6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTYyNjQxYy0yYjU5LTQxYWItOTY2MS1kYWNiZGRjM2VkZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAqa0I9HmoNIWXY+eNemLi9/V+f9P3bfs08yZWOcEvvUyz\n/Ei4OXeG1s/8J/y2V7jSeUQFgKei5byLS794M0f2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdHF5jvj8ueYJAFNn6EimJW56\nl5UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPV3zuEoCmGyDZKJYJHR30iVHL4YEWeQsuEqvIQTpOM5AiADj4G6tMDC\nzXcRc0qKH0yG3NH6UDeA7JnDfp1fzomIpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZqgBIFeR4mf9I3vkyklGO7mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc5MGRkNGItYTdkZS00OTUwLWE0YmMtMTYxNDdiMDg0MTdmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmMyOTliMDYtMDE1ZS00\nMjg4LWE4MjEtOTkyZDFjYWZjMDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nv5fr6dMNPBVV+BKGx/UkzjbvLJzC/2Maa1kDmV8VnlUtVcpntoKktRA/CGBfYodk\nJ02hpb7jT1vYbh0sHCxhw6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIOsuQuAULpAkuUYe\ns53mO9vCIkgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMWH4cFARhXuoW9ijKLBgqXNcUAPQQeDwTK80x33kdfcAiAE\nsJGDkcXOwx9BRomNAg+gKEBC6NzXsxwcRKrYS1HjlA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4128", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4128` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAeSazH0JTbTJs2GLIecmpYe6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3NzE5MTNmLTkxMzUtNDMwNy04ODYwLWM4OWVhMGIzNzk3NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdmZGY4MzYtYjEz\nOC00NDdiLThjMTMtYjkxNjMyNDRlZWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/I8iibRWqS/xyom76FJHtaHb4wfgIXGFf2Y+RW8fxDmiQiOECc3MJTzlRXVy\n455bvUQZJgfjDlMmw3Dr1s+2paOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXkBBLt1sG6VXl9vq6YYzF8qoY74wHwYDVR0j\nBBgwFoAUoxGVQI2KqPO89TXFDthkqvvvYXUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIFEzYl3sF392HZ/A3l83QNd0nWm0ef0f\nuO2HIl5sU5zbAiAUopTXZoOHE6mqrpbtKVhl5KFPLzKGdVy0LdDnPPg+Rg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQqOTOJFwfFEy3SvkLvqAAu7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzcxOTEzZi05MTM1LTQzMDctODg2MC1jODllYTBiMzc5NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4CIOvtbAggEwE7BSwlcyBTCLlp6iOL6+xQFPVSy5ltub/\nEtsxDMeovM66iUQcckpvPMFsd/cnDLkZbORdRe2Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoxGVQI2KqPO89TXFDthkqvvv\nYXUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMFdefdW/cdQMjfDRofL40iMha6XhSE0Vc4m7xxnf92GAiEAwm9G+8a6\nRuPaq6+d/4dgftVLgppwy4jwL1mp+7vCshc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAeoX3XtF2DPBHRK7QkoMUuUgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdmZGY4MzYtYjEzOC00NDdiLThjMTMtYjkxNjMyNDRlZWRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTExZDE2N2UtM2VjZC00\nY2I1LWFhODctNDhlZjliMGFkMTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzzti3l/PCcyeNPQkm9X42xA7uFjoabhCNweK55QVF4BNH1RlIpgdLvsAudp89gK+\n+oQYiGl4STDeWrsc/QPmYKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXkBBLt1sG6VXl9vq\n6YYzF8qoY74wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgZYzCwW2CBZSZ+pvnEsAuYpa4Y3W1l6vXmsm+Bs4+pU8CIBzi\nDb3vDMnT8+Rni3TfkbEtPYxdkndiaJXvPKp+jnQo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4129", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4129` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZFqkk097ceZLrA0BjVxhzDmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhZGJiZjJiLTQ2OTItNDRiMS04OTZjLTgyNmYyYzg5NTM3OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA5ZTNkMzMtY2Rl\nMC00OTk4LWI4YTYtNzM4ZjZiNDRiMmU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE51ooQF3oLe6rHLQ8dINRcvIK4gZ56n+O0OwunKbHbsFMcK8yeWGdTPgrktjB\nhzFt5TcBO4+Ux5nm5UqxB7ap6qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmOBHf3G8HUHUUOyqJ+14DSe7XyMwHwYDVR0j\nBBgwFoAUcm9aCdktDt3YfvgvMmZoX2DOkDwwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCx2HFYNPxB\nxWv7HjD8QHLdlMSF19yErcyzdExlra8SgwIgUpW6PxLJa+W/IvI1RLD8TRxc5Gmy\nzye6YA6jM2NKSQ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATmru8uUntlQJghIrZZvTXSqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWRiYmYyYi00NjkyLTQ0YjEtODk2Yy04MjZmMmM4OTUzNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSoMYMhOq/1ZLClKgB+p1wn4bxdHUPSfBgpZ+9FMiwnp2q\nEF7jVco2ixdvIti4dp++zq5e+hsGTcdz9MUqWP/Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcm9aCdktDt3YfvgvMmZoX2DO\nkDwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRlOk5LOaK0sWba5JpFrfkIADo/XbiJzdc094Nx86ankCIAr9Ik9QYdHO\nPEzNnICFGfq5xL7A5gnRjYfoJjzjjSJr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAdW5Yam7qORZDSO9Tm/ZkGAtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA5ZTNkMzMtY2RlMC00OTk4LWI4YTYtNzM4ZjZiNDRiMmU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTNiNzhjYTEtNjdhYS00\nZDQ1LWI3NTktYzc4OTJhOTg2NTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncLbHldni5bzID/aTYYHg1pQ8ZD4395Bueq6KSdAai2r2pU+ROneDK1m2vkvCE3x8\nq9YC66HLz67RItPCl6I3AaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmOBHf3G8HUHUUOyq\nJ+14DSe7XyMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAPYjL4L5WD082zmZTygwWBm3kW/Uhi4Tfra0lyxa0GFTAiEA\n14xOZ2OHvNz2E/4bCeDtRpXEHn8CE3IxnTe7dC4qKCg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4130", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4130` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATi/4mxCzno7E/JCs8K4642zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwMGNiM2I3LTZkODQtNDY5OS04ZjBhLTcyNmNhZjc4NzJiNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFlMjFkNDgtZGNk\nNy00MWMwLTliYTYtOGJiNTc3NDliMmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExXFjsJmFdpFhn6aC/jjKsoXD9SeBcaHEhVxaWUHKn7BFoEtVn9GcbqGucvgi\noOX9idvqNPG4twYENwQde/TlzqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkEY9Nyqe8ZJKgLOPHx3uTB4QZPkwHwYDVR0j\nBBgwFoAUYU/xneo9hfNADbLndzKhp6vtudQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhALnHUOrdjR5mlvH8rLWTvAliQULG8NUTNNX3++iQbRzOAiBSQ0MDmhVX\nKkzPfE0nCYUHhZCd5aD7cB5rE+R5dJaUNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaAUzQ7L7n/lVzgG8AU1sKqwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDBjYjNiNy02ZDg0LTQ2OTktOGYwYS03MjZjYWY3ODcyYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiQ6kapn8GO0hS1pX3WgqD3tr118/EjwfRB+n7ALGv5DLY\nAVmBRJWD4aLW6nIsDciY8VYTyrC9jRXcGuiQaabuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYU/xneo9hfNADbLndzKhp6vt\nudQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALqE0GWUkPzGhAONGWuptUZdMr6vEKZhK1Piduki9g5mAiEAkwqWInn+\nhKkOT8GHux4oI8/7QVvyy4ZWLqcq8IiWZgQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAYDTW+kOOEfGJjtDRw7VdMhQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFlMjFkNDgtZGNkNy00MWMwLTliYTYtOGJiNTc3NDliMmRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTg0YjYyMGMtMmE5Yy00\nZTM5LWIyYTgtZDdmMmIwMmIzMzVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqcfCJ93kQKZJW6Hjew32og57GlMJdimbQFerDhYl+JeXdagEJxwEYmvaOWP1hvoJ\nirNpbkPw1DaD8zpfPnB5j6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkEY9Nyqe8ZJKgLOP\nHx3uTB4QZPkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAI7CUeoQ/gOVVS8pl8li2TOpPt0Xs/nkkAPUZCLlV9/vAiBv\nvmHsXlRtV8GFr/blWKjiwNY63TqjvTpMgIR+q9vv3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4131", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4131` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAaag8EvwoguwY6HaOxSSVdunMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmNzU0OWE0LTZmYmEtNDIxOC1iZmNiLWUyOWRlYjY2OGFjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VhMmZjNGQtNTY1\nYy00MmQ5LTliNzQtNWY0ZTEwM2U0Yjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc96aMaayn/Kmo/ZPP8MUPtotVlodRxMjqknj9mdx8EBMoVGgJtD9dMkWtNib\ngktZSSA5gpHlBU/ePDEIXReHSKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXCH2bhbtgg83NMOiadmFpbD4rVgwHwYDVR0j\nBBgwFoAUYh/3552z64dDcMLOvIjlHU1lIR4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgO43gLPBzEOb4p0gkdUB2aJArpuDoLm9nIYljtdHMnRcCIEj5XTmwP3b8\nnQqtvK8mW7V+QHdT69197JL44zyc20Fc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYPYsKpxsfgw7zmx+KgAEmgrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjc1NDlhNC02ZmJhLTQyMTgtYmZjYi1lMjlkZWI2NjhhYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzJ0xkC3IfrSmuL53oPkKLNWZRHfKyyj6eJrlxqcCxz4jO\ntS4x1tGKoZ2uLI2cKdLo1RS2RGRA5DeLZct015hto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYh/3552z64dDcMLOvIjlHU1l\nIR4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSzGPXrrjdxQb/wNzLXqtr7wnUDNpWwnA+K2Xnw0QzzsCIQDzBVvbmVyT\n8kQ8tjd1WNzPA12/66YAD1+nC1GN0rdybg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAUmiH3DZ9lJvjxFfiPYkBwW8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VhMmZjNGQtNTY1Yy00MmQ5LTliNzQtNWY0ZTEwM2U0Yjk1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWRlZWNiNTUtZDAzYS00\nZDNlLTg5MmItYTI0NjE5N2UyMGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9D4e4AyHr5PTVa5c10Wn8vcO8u+0uCzowuW7/iybeiR/nUGtm6BnsLk6PDPaBBPi\nsDCXpzsyC0ktR2rHzmFkZaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXCH2bhbtgg83NMOi\nadmFpbD4rVgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIeWCRikTYpQbIP+9/jyn+KvnMZymLy4DDp+pqTykgSdAiEA\n5WSRxCC/Ec6adPo2AEa8jsuQLWaLLZ6Kq/N3XdjZygU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4132", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4132` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAaGFEB0zfKnJY0I3tPnrauPtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0YWFjYzE3LTc5NGEtNDdlNS1iNGFkLWU0ZWYzZTY4M2E4ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM0MTc0YTctOWJm\nMS00ZTYwLTg1NmUtNGZjZjRhZGFjYjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErQ41+NtZff6Nqdsr92GPni49yKIfRJ4p2TRp50xH7iO0jkfkYAL6aq2Tw/YS\n86WLsznJB5zTp7K49jNxKkEmyaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxrdUosD1j4aBySPYRFpPy93o0gkwHwYDVR0j\nBBgwFoAUO2FtPY89TIsoH27uwfe21lmWGocwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIEEkkGAPYa4sXah9DxJtZx73cUBgK4V53LgZC9ZQJvJeAiA4sen/wPGm\ntOE3a88qKU0TCBbc+XVAtMqT1Tsf/vlCHA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUeP9h6jcTQl/q43+3qj/QD3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGFhY2MxNy03OTRhLTQ3ZTUtYjRhZC1lNGVmM2U2ODNhOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6eFYFIl4cr7OWMXklIpwfKFN2uCPwx3i0ehOhOi2nOhHc\nx9oDzHGTtT85hoY+Xa6JVmvTQVwNFvtyaE5cWDj/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO2FtPY89TIsoH27uwfe21lmW\nGocwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRLv8qNlCBF8xP/WJ5xJp18Pb74k0huIOlFM2wOGVBiYCIQCnQE8jPw4S\n0FNnAz2QrPbXS7NVUHN9YGLcTDJkKFfITg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAVKa8Y7A/sq0oGYxM9UGP208MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM0MTc0YTctOWJmMS00ZTYwLTg1NmUtNGZjZjRhZGFjYjQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzQ2OThlZDEtNzQ5Mi00\nYmQzLWFlYTctZGMwMTk2YWQ2MDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyv6wsulEAem/dTIiZQOyE3MB4Y2aUAglG8I0up42107o+alRQI6iN7T+TM2JQl4q\nKl3wWVKM4Lvx6UyYbbej0KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxrdUosD1j4aBySPY\nRFpPy93o0gkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAPTJUp9Zqb0yKkbHKDZeeUNm/8cyqOmYTcG6AoC0iqIIAiBo\nkCqOVjw9uMz2r5+RTcWy+gGUFAKCUpQQ2fD+L6yU+Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4133", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4133` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQwboB0V0pDJuLw4Gpg+7ZXDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiOTYzMWVlLTQzMjMtNDZkOS1iMGI1LTk4ODczY2U3N2U2ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc1M2Y0OTctYjZm\nOC00YzZkLWI1M2EtN2E2ZmI0YTUxZjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt4Q7VuRCT6AN9dZ8OQxUo/PV6Uq2bpPCW/WBefYtcUTJAi+W4jUgO2QQhAkY\nzj9YJVJ9/lO5n8Q5HQ/E0k9vYqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjXZj+DwnCYvwSpKAnIPXpPNaYcswHwYDVR0j\nBBgwFoAU1vTaHa+sOF7o55EeYrmM9bu8CL8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDhPycuDCYiuAZDFLrDsAWlhmpwFE1VHN6sMI5Qf\nTO5DAiEA61ZakKDRja7/pan06woJpew+MMJQIOlPeoSa65A53wY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeUd45HuHrdePANDtOiDhu6YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjk2MzFlZS00MzIzLTQ2ZDktYjBiNS05ODg3M2NlNzdlNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP5Z4hkLdsA5QqB8w9JHUH5VYd4CmiICUfG2EbJgd+wOju\nAo/nI+V5cRczdPiRvOUYTBwzcsir+674QpazaYfKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1vTaHa+sOF7o55EeYrmM9bu8\nCL8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKFElAZVWXxvYIhakeDKxrh9SLgpP5sLUNH0mwwS4Z4dAiAZL9xHPEJj\nkEKrr7knSmpA1N5HBGvNYu7F4nldFMpNtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQwFPKbvjF6ZuPOArkoSzjyxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc1M2Y0OTctYjZmOC00YzZkLWI1M2EtN2E2ZmI0YTUxZjAxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDcyOTU0NjUtNWM1OC00\nMjY3LTk5MTEtZDAzYTdiMGM1M2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhINCFnCfS2Alquq5UORMol+SkvkzEG0WQr78Iu6znmOXulVOvhZrST8k6BGsFWLe\n5jyII2+v1B7ytqFLmjNXdaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjXZj+DwnCYvwSpKA\nnIPXpPNaYcswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMpwE0wVas9RZD8KWvZq8s39Tf//FdQ1GfYKdsUy/xBqAiAy\nHL7MyprnmqrhEtaoQYFqfLwZOg41E1gMRsWwykJ7xA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4134", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4134` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAXcaAVecB49T5+5P9eT2IkULMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljOGZkZDY2LWMzOGUtNDEyOC1hNGQ2LWZmNGY3NDUyMTNjNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk4NmNiNmYtMWE0\nMC00Nzk4LTliMzktNDA0NTY0M2JlYjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg8wyRvN8UVQOMBh/77L90gUV4y556wagA6wecaHuNUesmdEQwsl+of2QCc56\nU7hpCKwIKwu9JLXq/P+xu+n3tKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx/RkeNIOLQCByLmLM+ZMJvxQfCAwHwYDVR0j\nBBgwFoAUtHjP0WlkApcfDXFiaFfB/hehyaswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDwYsBrR/CiTKOmV8CPRS6eZbqc1VA66DWd1v1d\n8hYvYQIgGI1JGHP30T5A3sw9/tM7MsrRgY1UySoxge00gbmGuCo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATLS1feLJOPqD9J+48eZ7J3fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzhmZGQ2Ni1jMzhlLTQxMjgtYTRkNi1mZjRmNzQ1MjEzYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMy/SPu/qzSwFDpock2JdjLS1kp//3MzAD8FUhS46Z2uc4\nbwCYSLLt48x3m0uiIbdNWbpv4MLNdyReAVR24kCwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtHjP0WlkApcfDXFiaFfB/heh\nyaswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPuKOCULGevU8X//3qwgj/TKQQvhSwMuBMU4wzW+tQf6AiEA0f5nmeqy\nI3KhHEUy5SGR4A4iahDG5QPYLiJZNUStQ38=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZ2Exa6NEkAjLtptfQ5MDj3PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk4NmNiNmYtMWE0MC00Nzk4LTliMzktNDA0NTY0M2JlYjNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjBlNzljMjYtZmRkNy00\nYTU2LTg3ZDYtZWZhMzQ3MmM1MTIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6QYmJee2pNwBZVuYQRujzhj5eXWlcoPQzdyjqTyQpnK/DO3U6ewckod+BBz0afUg\nuGCOwDOTj1TmlJk/A94feaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUx/RkeNIOLQCByLmL\nM+ZMJvxQfCAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgMNcAZvc4hyNqTjGu19xoy/LZSrX2SR1f6KaXbYtO2ucCIQDx\nuxQZxgRpAwyVKXtkdrtRhgDVv+LReUCIqbEAJoHSFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4135", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4135` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAanYWTG2l9X15vKfCNxOzzzpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3ZTAyNmJlLTRjYzYtNDQ4Yi1hYmQ5LWIwYjAxMDQwOGFjNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk4ZDRjOWMtNjU4\nNS00OTRkLTkxNjUtMmFkMTY1YmYyZTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE39sDC8XlJY6Q5M52iB/h/la4e8kb4B9oUkhl4f/OHB+0czhQ52Jzq1Q7rjcx\n7OWJkppito/hZXSaEZn57hqIbqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOccMstemnst5Xktwrdj9X45qvFUwHwYDVR0j\nBBgwFoAU+OAjKJicyVVBPXjQrfkgxeINdfMwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIF/SYzsh0HKfqonB3ojtxODVrg+umli+OZEQH7AysTclAiEA\nqbyqZZUnmtKa2T+jbQ+L4rdIl8yWLQ8YoFEWHYNxwwU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXgTXwQFiY6UwP1086AkA+UhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2UwMjZiZS00Y2M2LTQ0OGItYWJkOS1iMGIwMTA0MDhhYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9e2FJrkIaPP8fAZKtBCFhTpDl7l2Nb8KRnKbeArcCJqqa\nmJxGQ3f07QlSqaKYdVxC4NVsSNgmC+Nfn2lM0lFSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+OAjKJicyVVBPXjQrfkgxeIN\ndfMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJGTGMg7Y9Pm+lI74PmvGjpqEiI2KbScsf1BDvf0OtJxAiBu7i4dxMjo\nJd2r2L9IASPBb+8Ji+dCu5vB+WF2JW3O+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAYFDw/5SCL/CgvWD3h8YIoVzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk4ZDRjOWMtNjU4NS00OTRkLTkxNjUtMmFkMTY1YmYyZTJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTg5Y2I0ZTMtM2YwOC00\nZGMyLTk1NzMtN2RiYzM4MjBmNmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfVRzc2cpCvtYD95e/Qk73kunMukd7UXgywksVz3o6EygAM2dkhMmvRHBKU+Ixbff\nHw3tyYPg/XWRrwT02IhY7qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOccMstemnst5Xktw\nrdj9X45qvFUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJ+rm5VoifF9hMx6Bv8T7u2y8E4bJRtdSwQQ518fbWfPAiEA\nwYWHqdgOaoWwVqjt1RjacgtiKZfzIjaQsqfgMIzqsvo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4136", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4136` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAXwoO7kahbnu4fQoam++eWfHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiYmMyYjRhLTNjMDEtNDkzYi05ODg1LTRlYTg3ZGE0ZGQxNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE5NTg0ZDktYzcy\nZS00OGU5LTk4NjgtYTRlNzJjOWE5NmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA+egCCre864yWgVW0K6eP0lL0ubZ92VKQHqAUnkFoJJARdAVccqZJsTBV5Cj\n6xF0napOYJCGQsH/V2Il1SoQ9KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFD7qSoda9uy6hQfnwTweumDlO4owHwYDVR0j\nBBgwFoAUm1dc8XtjWqfyhqyapJdzHi3xKXkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCICDJJbyZixfRM2JnbwpHT66FssC4K6eR\nsuI0HaVviI73AiEA6AuZvYyIOBUUK6cgRuqXu4vtQUYmkVQ+UGDRdUvCM5o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARZ9v/fAsZwLRg7L3f/Ut7YmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmJjMmI0YS0zYzAxLTQ5M2ItOTg4NS00ZWE4N2RhNGRkMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQv7DnZeOFKRT4oXZMNZOgdCJio2I7zsDQmahyzQLrO6Kla\nF/Zf61PZM6nHXXXBsVH9IFm8opGkJ1UZ5VN10sCao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm1dc8XtjWqfyhqyapJdzHi3x\nKXkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDLmHql97uT6NOx5u8zMCASt9m8BaDmZ85gEgMZmG62QCIQCkenMVRaWs\n4i0B1r891nnAMCd3x5SYFUcvEwMGrH+T5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAR9n28bXY+4gCShS5vh0dhdSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE5NTg0ZDktYzcyZS00OGU5LTk4NjgtYTRlNzJjOWE5NmU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2Q0MzhmOTMtMjVkZC00\nNTY0LWI0YmItNTM4Njc5YmU1YTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nD1DOQ+kyth+aP5C71cQUqVFh/8z3hVBoGeHm96nyUQaEtuPXd57oz6JmuLBbJUhP\nYh3AcWNd0qQd0rd+oWmGDqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFD7qSoda9uy6hQfn\nwTweumDlO4owHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgfCLy3qS8xpg9hwKI6oq2R+U1IOhwksJAEbuTKefd4fACIEDQ\ngea77M207v0MWq7Ine60hrNS3iVhm0t/EP1jsf+W\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4137", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4137` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAXKIncxNYTNhJetMQLxlxDdnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0ZWZhNDlmLTIxM2UtNDk1Zi1iNDJkLWE0MmQzZjQ1YjdhNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU5ZDc1MTctNGI1\nYi00MmNmLWJiYjctYmFjOGJhZWI5ZTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG6+4fhq+4P6UWXxNmnavTyBUFKUygCYoeJ3R40GpQgznYlJXJKBQ1p5lCLse\n/50lusur9VNECfogY9JIBBCqsqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Di/CUzerwopMukgtCgjKb7nwBswHwYDVR0j\nBBgwFoAUMzwDxDoAfm4ok9Kdy8c6n1ajNe0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDZe+/6fjYzb3YqhdJaHAA/R3DYnfrs\nsVEMKbK9bJwjiQIgCxJcPDCzaGzCozJ8Re/y6xtdNnkbmWdjaWX/4ndkKlI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS2vV5hWOJzA4RjkU0tWBrjkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGVmYTQ5Zi0yMTNlLTQ5NWYtYjQyZC1hNDJkM2Y0NWI3YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATS3SfX750O3tVp9nqzA1+DocMty7AQq/jvuBKI0u6ZqqnP\nApiM8eltQtiFeMdNT3nAquelIJ7UC+HAqwEMtgTbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMzwDxDoAfm4ok9Kdy8c6n1aj\nNe0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMc3PrhIXcjhCuO8MiFfjDaxY4bxmdFMXg9ssBqqBSxFAiEA4BdE9f56\nK5kymU8zGs3W59udwCZBmLafzXnMONG/yaw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAaa15231rzZMwdAIs929f+uDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU5ZDc1MTctNGI1Yi00MmNmLWJiYjctYmFjOGJhZWI5ZTllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmUyYWVhNWUtNGM2My00\nMmM1LTgyYjItOGU0NmFlNTE0NGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzdRZqxoLP6uqDfj2sFTohqQ76dZP5UTScADiKzN5wz3ofx1M/GWgSZGvCJmd+QfY\nzqAE0JlwdWYlfTMxnnWHtaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9Di/CUzerwopMukg\ntCgjKb7nwBswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhANGccE6bZgkjWA7CxWGusepmtdENfxGLEDnU2ue1A7flAiEA\n4TzVZ/Tc+c0+eWe1IV3zdbLIQGGc60jvbKSHDehsMWU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4138", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4138` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdXrggXT8/1kR0/hGEyjdECRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4NWM4NzNmLWZmYWQtNDBlYS1hODcyLTZmMGMxY2M1NmZkNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkzMGEzOWMtNDI1\nZC00MDRhLTk4NmUtZGY4NjRiMjUyY2JmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqDHPML5qLmMA05G/LKFO+rt+hnRqPO5Pfme6hWaPUQciwOBa1XSRmzh+oo1B\nUE9GG9DQ2ILRiAcJNcjpGA3+UaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPixOzEA0wnwXmxRP0Jl1SViPcK3MB8GA1UdIwQY\nMBaAFOjvoGMivnhgX0Qr0/CfPnhRka9fMAoGCCqGSM49BAMCA0gAMEUCIDKWCfrZ\nwvWQZDtPUvOxoGhwvVVJdz08Yum9RVSqrok0AiEAu39msj090wjTHys5EXhCeedI\njnK27oZZLQF25RQjASQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAabeB1C0jSjkkgZx3z6Oeyf1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODVjODczZi1mZmFkLTQwZWEtYTg3Mi02ZjBjMWNjNTZmZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMIB++/+I8zqij7b2zBpBSaOAk6aTeopzscwTFlznWWPhP\nKGj/Tgux44PvjmbdWbcy8BOIlYRnvxJH6ov/S8gpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6O+gYyK+eGBfRCvT8J8+eFGR\nr18wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALy1/A5EZpjuLRfG8q1UmbIJpDv72PbLOsy2uPJgK6xtAiBsSbKREc1A\nPDpfeeBej0jSsdYRS44Is1kRWDuogNWmyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAVJF6xi3L0Km1QC//ICqtJ0NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkzMGEzOWMtNDI1ZC00MDRhLTk4NmUtZGY4NjRiMjUyY2JmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmNkZjMzMTItODBlZC00\nMjRjLWI2ZWQtMmM4ODg5MzQzZWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAmXTn4UglBUUwuPuYq2lkUagWo/cfHru9phQmPv6z8hr4st5pFPiTYlStCt6K0U4\nwntCizeW+gzc8hpOzTFfOaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+LE7MQDTCfBebFE/\nQmXVJWI9wrcwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDorcIuERHzDcFUz6GqU6f4as/E9UHPxCyZP259s51QHQIhAPyj3PzZ\nzhBUYyOTv7Yn/iwaDLRFItySNlw2Tp8p83Zo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4139", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4139` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAeZAD1hvOpzxoPCsuvPaTAm4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNjdmYzdmLWM4OGUtNGZkMS1hNGRlLTE2ZDUzYzhjMmE4ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQzMmYxODgtODUy\nZC00NWRkLWFmNWEtM2M0ZWQ1M2JlYmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/LpF4iPtVFI7BvuDeplfQzrbHS81uFj1u6hAePIwPvdGBotjQOE8BOevhAgM\nhihyorQ5BJL7aF5V8Md4Z59akqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFItiazj6i29znwap02nm2nraMqP2MB8GA1UdIwQY\nMBaAFKlNzXl3U8dN10MbpBSo80Gqd+5/MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA4IcnhP60k3vVaTJsuEPuP2z0ovrgJuZp\nDV+zpTOFD5ECIF8F13sDmJoSuU3syLsdIpkRRyubwJfFHRDz6lsvaF20\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWXDhq95rybUx6jyjcTLqU4vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzY3ZmM3Zi1jODhlLTRmZDEtYTRkZS0xNmQ1M2M4YzJhOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/bGwdbSuZvgdMMmeQM/jbtuYCnTyDoExfiMKFDAf3Fq3U\n4CqcnhnQa7ytBH826ITeTttGnoZfO6KvflZ6hmD1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqU3NeXdTx03XQxukFKjzQap3\n7n8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANly7c4Dayy0V7wj0wuLlzNwNOS2cOoxyh1zbhLkkn6FAiB4C0zU34Sd\nPn2Y/pXXrpHfjrgqVb14zSz7tNP9SJInxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAY6TWbtnYHjOHg26TuxjmtcCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQzMmYxODgtODUyZC00NWRkLWFmNWEtM2M0ZWQ1M2JlYmZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTQ5YzI4ZDQtMzVlZS00\nMThjLThhNmYtNmNiNDIwZDkwYjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6qptbe3QTIJao4XzGjnkvBdaymKo0rrhFzwAKqlrTzlgyTqbbPSCiJrbZWMJ4okV\ngdi11EiG/JKelhNIUNh8CqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUi2JrOPqLb3OfBqnT\naebaetoyo/YwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCv4F2dK8tGF7Zl5jZWIRtX6TMmTajldiE9S5/YDTl4VQIhAL/cLmRY\nyEKhvLAcRQa9imB4h5rpRdz4tfnXAPfe8dah\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4140", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4140` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAY7dXcZisjAYUClTYfpaxs65MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhNjkyOWFmLWZmNmYtNDBkNS1hNjRlLWRjODQwNGQ4MGZkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhiNjQ0MzItNzEx\nYi00YzRlLWExMDgtNWFkNDdhYmUwZTFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaf/AcmAmy4AbQOccgOntX4m4xoYrSxjiMUWJJbTRXHT5xd3Z1RUMwDSzpj/O\n/ZscLI60GixTL9IpRVu3SCsnr6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOCDGmi2P6MhL3zvDVhP5hlEDkYhMB8GA1UdIwQY\nMBaAFDhMKnEQ6PbCJzofcnY5Vk1FQIcsMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiALbi8B0OQ+zuq+i3QpKsDVc8PsByQXT+yG\nZdPgllOaiwIhANbCH2txnOdznZV4preXDodU6C1QwN1psTdqVyE+7k1P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASR7nbu6o7r74EAUsNrsajyfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTY5MjlhZi1mZjZmLTQwZDUtYTY0ZS1kYzg0MDRkODBmZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdRBU6YaTR3xbflO0kd03rqFeSu/CxvjP4KDQ2fXGYPHPV\n8rIwbDDpj3zo7AthIbvCxKWC1EiPdnAR7p+jTugHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOEwqcRDo9sInOh9ydjlWTUVA\nhywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdwL5MlEaNLdoAIp2HWarICBLVTRKKn9jv1bvP5cl9UUCIBWbbViEaOmB\njpzoZCllcFMGuPnBgScJv3cgFCWR8gVh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAVr+SIv924HcAD8x8Y7EpvKPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhiNjQ0MzItNzExYi00YzRlLWExMDgtNWFkNDdhYmUwZTFmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTE3ZDM1OTUtZDlmYi00\nNjYyLTg1MTgtNWFjMWFiNjQ2MzQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nm8ycOBxVWIfujcRvfSzFiTw6gmwfln/KZk7fmoajeuQ8nBhxuHaR/f9oC3ZBscA4\nWAlSZ12S+1yJq3SQ3Xxkc6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4IMaaLY/oyEvfO8N\nWE/mGUQORiEwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDuBnJM/rT4ELI37KAqFBIIGwslaGMcV6EwNhqx2CZKAAIgNcurMdNk\nlZ2qG0drMNu7ft0YVBJS23rLyr1EXhkSeFk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4141", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4141` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZYRerCPjny2OTiwbSj30SkYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzYjI4MDlmLTk1OWEtNGYwMC1iNDE4LTU2ODg2Yjc3YjFhYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk1Mjg3NzMtOGEx\nYy00MjE5LTk5MmMtMjQxYWE3OWMyMTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFqKrKKvnutr0fRlRfpZ0yXGnQejA+Un6Yl1MHNNO+/0L2kg0b3d5JXhLVZVV\nLqeNO420VtM0jF9ATXm8NMDuIqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRu5UlNrWb9Ca9eMBtQ3pkXxstMcDAfBgNVHSME\nGDAWgBRIqXs6oeJ5Ieqgbe5lZuxXvnGBcDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBELi7xivRG2TkKeQyA3ybZS9lRpfiUz\nP8Z1n/G0DwToAiEApYUKlXCfQF6byxilII+x8YjxixRp5RlKJApONjFIfLQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR8oJ0HEUw22yMojDOu3UnMyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2IyODA5Zi05NTlhLTRmMDAtYjQxOC01Njg4NmI3N2IxYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3pivwMqBOQV9TMOSX4VOkXLC9XqDquwiSbiVQLqGTCESO\nhKmLKwTqOI180AiUsNfQQdSupEN/fpcywzYq7fUQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSKl7OqHieSHqoG3uZWbsV75x\ngXAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANzv7Sch/KVDK2aPTKm7uT5sY2dW4wNSrA/SnaCjdoCnAiAkjmvLsAim\nU063hqVtJmN9Y10fKDTC+xBzMnswrze8UQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAbQ5f4IWJ4FC1nGlq3GUAsh6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk1Mjg3NzMtOGExYy00MjE5LTk5MmMtMjQxYWE3OWMyMTFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzYwNTU5ZTgtYmU1Yy00\nYmI4LTgyODAtMGJmOTNiZWJjMDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUqytEUps1XZybRY+ztMlIO0eADGNfqziNPWvB+zGy2jL193UkaCGl8+FIe6vdjkK\nrXx2SO8xfIw68MzbjVdxj6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbuVJTa1m/QmvXjAb\nUN6ZF8bLTHAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQD4fUBuwmiYQe5H3abgvtMsL3CfzFKKsPdOJJS87eN/4gIhAK9bQDgQ\njH0PxMeMKWuFMjzjiFquLzaADeYLV5IIBdDI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4142", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4142` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARxjmOTFl1QakCvrERGtCj0cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNzE3ZjFiLTIzNmItNDM5ZS05NjdmLWMzZGZkNjg4MmRkODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM1MjFjNDQtNWE0\nMS00ZTA0LWEzNmYtNWFlOGFmMjNiNzZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjqq/ad2M4e0d7jXyBKBuUNJt0h/4Obr1jUfJEKUeRUCNKgqHAihYTF24BIld\n1wiEcv4+bs1c5Me0HsfL2wgdR6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkAdKzGUn5sDgiqrQPqkIKRIn4R4wHwYDVR0j\nBBgwFoAUpQmS3f975dEIa97mZXtEnD98qlIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiA/aj2qK29F8ve6\nPSWiSdZNxoldBm/8lHh2w/oH6EStbgIhANwIh/jp4KdhPAd4r9of4MUhN7roWH++\nCzxtto84nFbi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaPPbmlAsszplEQrh7JNQJdCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDcxN2YxYi0yMzZiLTQzOWUtOTY3Zi1jM2RmZDY4ODJkZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8R8tK7U1IwFRHYxku4xJb+atxJ656cl9SCXzLGflwkFUP\n8fKwmhqTV3isXXByVJotz9etkDkbf7/8huR6wcTyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpQmS3f975dEIa97mZXtEnD98\nqlIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOJnu+VAYB69n87ZU/BEL8yJgMNKjHKViPDHMnribnnXAiAj/YGcY1LD\nTmKtJu3ToU09zh2XpJStFhC3X7v80yMoTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAak/tEn8e19aFOjPrIk8xiR5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM1MjFjNDQtNWE0MS00ZTA0LWEzNmYtNWFlOGFmMjNiNzZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTA3ODAwMjktZGViYy00\nYzYzLWE0YWEtMTA1YmI5NTg3MWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\npKJjS+vmyheaM7uqz0GMpuaGP+wSfvtgvzFkpyFqkYUsOqovvZnYkOlpzsWHDbY8\nk1y+9s5PAsPY6G5e3hNl7KNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkAdKzGUn5sDgiqrQ\nPqkIKRIn4R4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDRKP3RwR/0Pm3oHcfL/xV1a5HFNImVdbvWxPHiib2VoAIgXwmmwHNS\n5oJwV0W8KMc1Qr2yJJeiuFdCmGyzDkY0RVk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4143", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4143` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAZCGeaJuFAnlio6g66sgsMC/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3M2YwY2UwLTVkZWEtNDg2Mi04YzE2LTNiNjkwMGUwYmIwMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODljM2ZjMTktYzFh\nMS00YzM5LTg1N2MtNjRmMjMyMzNmM2I1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUbS+kND8cZ5lSoOGSitYppPTY+1x8h+Bf1Ov23Qz/51SgiB9eB/SbrtXaB6a\nS2m61NZ2ektGsXub1xn7+r7noaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsCF5IvlDCZnPQjFkoxKF+y0DwSkwHwYDVR0j\nBBgwFoAU1PQLRXj3TbXrI8uWkbllTwaFthMwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAkK6zIujKKnvv\noJUgjttfScGG0J9GPE7OpAgnqwX3HaoCIQDp5rvBfA2U8H1b8W1dH+YZxSyT/oI7\n2tecpSvO5thABA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdowZFl+tCWc9yQEOgxwTz+WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzNmMGNlMC01ZGVhLTQ4NjItOGMxNi0zYjY5MDBlMGJiMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeshYPHopcXljCn8U+Z5vwEq2CPlvcado+BbhEAHG0b5ow\nuuviXP2Epq5Kj7TflylQrAwNiZ6568+WFMNP7d8fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1PQLRXj3TbXrI8uWkbllTwaF\nthMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYPyKP/JOF0XhFB7pX3jdjEzdy1vfCWhK2b2ceNIQs4sCIGk7RObL2MeW\nOrh+yqKLerXfui2GHjfXfnovqPHB2sY+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAaXLBP0KeSV6M09NiN65phPWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODljM2ZjMTktYzFhMS00YzM5LTg1N2MtNjRmMjMyMzNmM2I1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWJlODgzYWQtMjVkNy00\nZjNiLTliMmMtZjg5MGE1NzQ5ZGJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n18AxwKjveB0kYeR90LqvPAppbVsJw+/bChdQtijXl51Qn8fwSw/x8l5sMTj+ylli\nG0jtxWBrMMJhl3gThb/fvqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsCF5IvlDCZnPQjFk\noxKF+y0DwSkwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCICCx9Hf/wC4SZjh782Wa7WLU7gzRILSQpcuT1CzUjaZNAiA/9BNh3c9j\n3ZyrqAfiTUpAeOr290DeRYZa7PzGizc4VA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4144", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4144` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAa9JHtGlLlop5TQMZT+Yy7OoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZmYyYThmLTU3MjQtNDdmYy1hZGQxLWM4ZjU2MDQ5ZmVjOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQzNTdiNDYtNTc2\nZi00NTZlLTgwZDEtZjUxNGZiYmM1ODllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5CJqotkmN2e0ANFN0TczMWoVgP0bAMDdxN4uctOuaiURF1mJIm4n9IwvWowE\nizW7thDkRyCmLHEKqNEPKC08LaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd3WtEh5BiwQaznSPML4fh2CYwtgwHwYDVR0j\nBBgwFoAUZqco/nJFR6y/rPqwqjQKeQbngVYwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBDXafC+kYbRfslaukIQE4w\nv3a8mF3R4SE227VahbcQqgIgAxqVOeL83PkoN5XfAQewBk+IbkAm9H5IYFydW6+A\n5J4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR6GPCWWKf72Z7aIvK72RYADMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2ZmMmE4Zi01NzI0LTQ3ZmMtYWRkMS1jOGY1NjA0OWZlYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUJ9vooIDIzri73fvM9Ld69a6Zr2sCjNDQ1obfoS42eLMw\nkg4HdJ9iBj9L14P1j4A0S5/j67y0hSFMEd3kEgoMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZqco/nJFR6y/rPqwqjQKeQbn\ngVYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIJa0YRufHy79rb7sYcdp8+bxBIblmniy202vCzinDUEAiBkxLQaNOmJ\nk3Far8nliUp1sdHOq1qldE+j8BYGOIAWBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAQuJEls/gv+4io55j8lIJmtaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQzNTdiNDYtNTc2Zi00NTZlLTgwZDEtZjUxNGZiYmM1ODllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWVhZWVjOTUtNmUyYy00\nNDcyLTk3NTUtMWQ3Mjg0NGUxMDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVFVqvJEdSK4u6AjIolrT9B7aiOHltKoai+1sn35qn8rqyB15qAROY3gh59Ixtk+g\n/3KjRn1ydivqLGzKXwTBrKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUd3WtEh5BiwQaznSP\nML4fh2CYwtgwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCID5tvc9Vd4WlH+H9vmHCmzCu1IzUkT7gAXn6Q/83Rg1EAiEApQdo7Ujn\nZTCaiWQQ0IufPjY7DSyjczngOzfOPYh8nc4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4145", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4145` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAb0m0tk3+shTeU1k5zitY3OUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxZTRiZTVmLTBiZWItNGYwMC1hNWQ2LTQyYzc3ODU0NTA3NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVlNWQ4NGQtZTQw\nNS00OTE3LTlmNjAtYTdkYzNhNDM5ZDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMdQ6KDJZw8odIHsrM+imA84r9ZinBjQc834Q4K33E4HP01yyBAJrUPFuN63R\nUqgBFo33FdQHY9vNygo5h8WlHKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUquug++VfwkEMflog1A4c+4/MR8wwHwYDVR0j\nBBgwFoAUcPlrlPpzVl/MBU/SU7Xx8PiK59EwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA5598\nPwHb8/n8s7q6Y0i5jAYxmRg9mFNBUC/FB9c0zkkCIQC0xLWP1Qy/KitzmTpyAH8j\n8ZhiC/CODp4fK1mpVMwGeQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUfCjMaVYaaPA8z0o2YQRz8VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWU0YmU1Zi0wYmViLTRmMDAtYTVkNi00MmM3Nzg1NDUwNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQggQModqpfyVgKCXRKS42nglBudq3chv1uFKpTMoRICs5l\n/55nQTBSKsE1zyZcEJuGqayqJR1wsYK6XfW1/1E7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcPlrlPpzVl/MBU/SU7Xx8PiK\n59EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJB2lClU9rjNw7rooBoeoMCjUutSuIIwIR1OrTMRtsFfAiAE+81/Eszy\ntgo1ZT+koz0b0fsrSsyCDyFKd0qVzG8HqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAV11UYJU6C74qJvKgqG+IsKGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVlNWQ4NGQtZTQwNS00OTE3LTlmNjAtYTdkYzNhNDM5ZDY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDA3MDNiNjctOTA4OC00\nMzYwLWI3NjMtYzkwMjk4YTQwOTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njjdWplSzsiluOD1Buz0TT/jP1mgZz695OeBhPOksjokog6MPVX0PGqrNlFhr1TIl\nxuLYuZhJZMmf4Gm/KiuBTKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUquug++VfwkEMflog\n1A4c+4/MR8wwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCGYNYps5wAVPgPiYBCLtdAkMSCvoGTmp1VBcZXAtkY2wIhALYMNheq\n2uSTz5ekNowies33UT7pB4KBg77Bom6k+ZYG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4146", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4146` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAREqJmFa6IudIagWdyxxmQm2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3MjI2MzEyLWQxMmUtNGE2NC1iMzI1LTk5NmY3NWQ4YzVkNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc3ZDhkZDktN2Y0\nYi00NzliLWIxODItODYyNGMxMWU4NGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEykgwARebTo5WUUFPYb1zRYT+f45HNsWIwqvaoJTTW2i8RoJ5IxreesrdR78G\nw0CxHRsjFG5M8RkKN2Z/Dbqkc6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh4vULwMG8bRXVEqlBUP/Vk1AaBAwHwYDVR0j\nBBgwFoAU77mmvbVXWwMeCWp2YZrhN1VlQ10wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAheLH\npou0a9Jmn9/fUFKW9ixuXDyQqxlEeZkP0cQkrpcCIQDrna63CdcnZeEj/NBhS1BD\nSYOqfuwiExI47ft9zIKopA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdMR6soFS+SO3YT0p2QFbbQCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzIyNjMxMi1kMTJlLTRhNjQtYjMyNS05OTZmNzVkOGM1ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYYG6rW2EQmrVB3xKCq9OvhAdx6XppvCI9+9enpUlN+m0M\nEwAJDS8/ihyFEGqfxwz0zrW78ZWR/nqQno6ZtDqFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU77mmvbVXWwMeCWp2YZrhN1Vl\nQ10wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZdB1YD3LtL4+NPyP6jXjDqN0Iy7KZg0nn7dvOfYatBgCIQDBZF4d6SZF\n80SiSeq7+s9PadqqSToErcnFNvlKUws31Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAST/Wa0kwKgv8IcT2/cZXeBpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc3ZDhkZDktN2Y0Yi00NzliLWIxODItODYyNGMxMWU4NGUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTJlNjNlNTktYTZlOS00\nOTJiLWE3OGQtNzZmMjBjZGU3NTk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlIddWcUkYPFrWzdtKO0kxWpVxMjT/YBfUIQaHZHopaUcdot6d5bodei6ajoLGqVx\nrzR2Po3xRPYgEud92J7AqaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUh4vULwMG8bRXVEql\nBUP/Vk1AaBAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIAahnmrcCYLhx5RCTzhYU7OOr4kJgr3TOzl5cRUPDoSxAiEA2enQTvbB\nXR219/l3aykEFcVh3Tls/HLyE0/Bv4a8I1c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4147", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4147` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYSuVT3ZhhDpfVLzbvUB8eSGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMjNiYzhjLWZjYTEtNDYyNy1hMjgwLWM2Y2NhYmNlNTZiMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODUyM2IwYTItNTI1\nOS00MWNhLTk2NGUtNDZhNjI0ODRkOGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELsSLcrbeMtqUQAWicowDAlKLuUMx1t6R8SLVhTKbOxb521On9n1ihlB3pCiF\nhGReWfSv32XvJW6TSO+cTpDFVqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMngYwZO8vTksEPZ2BQt2cGU/i96MB8GA1UdIwQY\nMBaAFLDmUc7nYZBG/b4ZdpJFZea3jfV5MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiA2S1A0SUL5Gr2Mpapk7AwyvO59sTy+E4KY\nEdGUtsIvZwIhAPqY8QRPlXfE7tRNlJE5OedpGCi98Itv8hkhkQniv1DB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASqb8DbxqFSNgx4lQCoJLdB0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzIzYmM4Yy1mY2ExLTQ2MjctYTI4MC1jNmNjYWJjZTU2YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2d1jhhkylqQeTKBwTwlxV+fu0ftcAozGtOyujHgFeuZa5\nG9I7yLqykYD07rPj6ebkNDYBE8TmZ0cD+9RdV1vJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsOZRzudhkEb9vhl2kkVl5reN\n9XkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNN0KLIDDhe6ycAKutSqFMO8h3N/npe9zMg46V/t6W5MCIQDCLzulvshp\n1WJTJfn82bgIIA0yPYp1TlHyUwy41HNoBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAZvjJVLZYnk85s0kl1h7E81uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODUyM2IwYTItNTI1OS00MWNhLTk2NGUtNDZhNjI0ODRkOGQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDBjYzQ4YzQtZGQzMy00\nZjY0LTgzZGMtMjQxN2M2NmM3MWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2vMtNSp8KrWuPVrpeBAbAckJMYnL6IhoQbPHJrvbeKMfzJsif+GeXGrjrPLRl0SZ\nk+FmpJZbb6YV4+KRscCsEaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyeBjBk7y9OSwQ9nY\nFC3ZwZT+L3owGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDS0rH4IH5OPnvBgdC8FsTAA9qK3uF5ScphVEN6tq6fiAIgNrjmM1oN\n+qqn7ffjEWxlZ7+UeB50qGIoUvw87cmyGvs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4148", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4148` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVgNesz9+2aNGB1crwm1m2QbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4NTQ0YzhiLTM2MWItNDhhMS04ODFlLTFkZmQyYTNkMTJhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI4N2ViNDItOWNm\nOC00NjBhLWIxZmEtZmJjYjkwNGMyZTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDoBhEyWPcJU78ERzZwJtY/LYyH15hR8/Q/asjl2l7wffF815VzKciv3KT8L/\nmk/P2LKy4qfuzogRk0h6cRFHP6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpnvLiyLL0egmYcevsikTkJfJdu4wHwYDVR0j\nBBgwFoAUGzYfxnRGpJ0dEFxSPHKyLLn16QYwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgQ8yZynUHzLJ+\nQ4I3TIgXY8gVmhmGZtL+UGRpue/K0I8CIQD/sTXd9gQhz/x06wCO3VNUF4uJO+8W\nDoDcCq1FoIx+Gw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbaFpXJoYADdgaFl6EL2BUhZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODU0NGM4Yi0zNjFiLTQ4YTEtODgxZS0xZGZkMmEzZDEyYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt1YWDZ1+oJTHF3v6MW0P+5JmLsZWBvU9AiWwI9Nv9AoUH\no3Xh+f8ccVTvV0/6Fpv+zWJa0oUJ6K4iCTawx5LZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGzYfxnRGpJ0dEFxSPHKyLLn1\n6QYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMKI23m/pomJMSEtf/ngI+r/LThtdo9XYGmFBMt1oPTbAiEAyyZWRLOW\nHIXynVEpcNY9gxmL0GJMO4r4mq9kUM3lLkU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAVe3Y945RPHhG60ovzY6pBaDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI4N2ViNDItOWNmOC00NjBhLWIxZmEtZmJjYjkwNGMyZTNhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDZjZmQyOGMtYjZiYy00\nYTk4LWIyNDEtY2FmMGFmMDNjNWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/6T4YPJGnDnI5jlSBO+3uVn4pyEiVYiao/c364r7D9mQ4/CpBZlK4um153wHi3zK\nt7vOWD2YgY6JRQRIHmmf5qNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpnvLiyLL0egmYcev\nsikTkJfJdu4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQD5HbXy4rAi5vcgsI5EkQC7vRsytbpvUv5a+eqLr8QO6wIgTm4nEtAO\nH4Glx5SOz9F3mK8QMU/xVi4Tfw5LLVDB9SM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4149", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4149` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASFffeeKQ06stv8XVs7zXLhFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhODhmYmEwLTcwYTMtNGNkYi05MTY4LTliNWZiODQyZDU2YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZiMjdiMDctNDVj\nMi00NjliLTg4ZmUtZjc1YzhkZGYxOWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJPiQCkuHv28e55hCJkpgRqSndIkQ8jwn/28b48Gng0r2wKwzKOa/Kn0hIzuC\n3npL08IbEYqtRMSfg7ulNcxbOqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL9fx1hcPM5jSoSHGs6PR/YtrkKMwHwYDVR0j\nBBgwFoAUpyqwpp2v3EQapdnJBez6UFFbL9UwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgDP1dIPG7HDw3\nqLMapmJqO9LSWliBJUgqxDGywguQHlsCIQCNTPS+U9Hr5AZw+I9ysge9LiTXEqVz\nT4EXrzs2VFKdzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARwSmRsNzt/j+QT0SAR9BMCTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTg4ZmJhMC03MGEzLTRjZGItOTE2OC05YjVmYjg0MmQ1NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9j44il7tzgxR7NveoWGphHIwpRX3BuFlNGyDa1u6svW7x\nsQex/hkDo5U47pWWt1fiHqnlwWz4HBVEWVKxGp4Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpyqwpp2v3EQapdnJBez6UFFb\nL9UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOek4BJGkertbfkgLZecNz9e60vIe9KHSF//vXhPPNuGAiArOCxq454/\nBCqpde/CCW776yBsjZ4PDqgw/444RzN2Fg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAZtLeymgOaW6wScg5v0yX1QXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZiMjdiMDctNDVjMi00NjliLTg4ZmUtZjc1YzhkZGYxOWRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDM4YTgwMjUtOGJhNi00\nZGVkLTlmZGYtYjc4NWQwMWQ0ZDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nB1xu6UyNyi9WVoi2VxtTpn2Jo2aPVNNEZk7496zcGp4IRwTcaZRNpDXxZfF+dSMm\nIu1xreR1Jz1PfKbOSi6LZqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUL9fx1hcPM5jSoSHG\ns6PR/YtrkKMwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIESQeD/DL3F30z5Scrp3f2iPhuOxksuodYxtq+71Vr0jAiEAjgDMfVqp\nszaWby5ZO6Of5FzodIgy+hXwUDltQu+cUJs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4150", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4150` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdW/pupVx++yI1ZKMd64bW97MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmZGEwN2E4LWQ1ZjMtNDUyZS1iMmNlLTA2NzMzZDJlMmFiNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFjY2RkNjYtODY4\nOC00ZTBhLWJjYzctNzg3ZWZkMTg0ODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENildrvFnykigkcvG25UXB6o5OW0i+ALhWdcLB/CggbnJBU9Q36VAWvTEw5R3\nEGC50/AF/EV9IxJb2+z7XiVYGqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQhNQolTZMI4v+9Th1d/2H42G7pQwHwYDVR0j\nBBgwFoAUWyGFE4PaqZV5U+K09FVALkkyvawwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIF6mkSMJ+e15\nU+QCNmlwfJUO+yiYhP2FUcw/ZCFGINmvAiEAr3uSCSirqkW/C68ZSPFqnrgncVCI\nQMPymY1XX3MUKpc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdKDj4LmcuUihQavMEuOfMmOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmRhMDdhOC1kNWYzLTQ1MmUtYjJjZS0wNjczM2QyZTJhYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtKxEh6VNnrQ7hjkQLJ+H3zFfBJl3sEv/462bDLo9prgq8\nKe7KjkR3C2v51h7rCN9EppPmtlgkY7yOWLz9p0T0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyGFE4PaqZV5U+K09FVALkky\nvawwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAITvvKhQ3hl5Vz+TVlW6NuQUDfTL1SeXPNkVeiUxVt+7AiA6F/NrmOoa\nkJhoPFhiNjBc25KKC4aHvW8kZg7Bm4TgKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAdSNRSTomeLqWw/XI7LHgobRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFjY2RkNjYtODY4OC00ZTBhLWJjYzctNzg3ZWZkMTg0ODI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmY0YjliNzMtNDU2OS00\nMzIxLTg5MTEtODhmMjdlZTc3ZTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBYu4hrLkeVnUvkBbbLaeWCWJQsaeUccIg8h7Nobi6iHVjhRBrQGlMA3PK6eKkR/c\nmez0qaaCvUdqv/9itAMP06NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQhNQolTZMI4v+9Th\n1d/2H42G7pQwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIFp2I8wcOlG5BnJiaOLWw726LgeOJI2yv/chER6R1bOdAiEAw30ISY4r\n+o+UMEnQzAT3HMQRBKd6X7orGNAimlIBKbg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4151", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4151` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAW/4Bq7y/Pa7pjR+nb0N0jZyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkY2I5ZDM1LTY0ZjAtNDJiYy1hYzhhLTY0ODJiMWVhMTlhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE1ODkwMzItNTg2\nZi00NDRkLWEzZTUtYmVmNzQ2ZjZlMGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYTKwMT92WSxc9yp9ERW/VanWPqWWIOmEKBAkgHmDrQJyHEFzrjBCmYxijNGL\nssQegpIFshLw2dqOPwcZPnDGqKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+2diQfdRdQdl5GO1KIM2t1/NpxkwHwYDVR0j\nBBgwFoAUkdE1sAfLCJFa3sWJBbYtgC+DsPYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDyZ6EyRx0gkjWFpkAZ1nUpZKEZ3p1TYK56F6D/X7CuowIgDVJUisPjloR6\n3xUT9aKimwKKgVoKZqVs8Clq71JJRTw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXRU+0z4RznQ49duluC9xmktMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGNiOWQzNS02NGYwLTQyYmMtYWM4YS02NDgyYjFlYTE5YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ16tfkfVu7+0FGQwQ5bRtHatcdpvYYf5lH2dazFRQUEpEC\nLBZKYh/g6OkyJC7ZcXvwLIq34RbSLEM20FXoYGhuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkdE1sAfLCJFa3sWJBbYtgC+D\nsPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMAofQITym/l3IVjrjiT148szIzLfnSbfpixMM1ffLYPAiEA+xPsV1GO\nBp7N8IAes0eONUV8u4moImHZCDP0m7RUtgY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISARmrGtq77ges/D0cBAodLcwGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE1ODkwMzItNTg2Zi00NDRkLWEzZTUtYmVmNzQ2ZjZlMGI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTM0MDhiNWQtODBmNi00\nNmZlLTg3YTMtZmFhMWQ4YmU4MGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqdrziNOsvd1me7mZsdn1Ds69XkoE/RdJRF03o9f7Yqc0QmuH9MMMcs6nvu61Tkrb\nSuX9fOIA+uyTxO+tGeFYtKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+2diQfdRdQdl5GO1\nKIM2t1/NpxkwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQD6tDxVGC/um1kT3VXcVmqtWugAJb26u0l/tMI16VQJHwIhAPV4O2UO\nycWghZmrUugibpaAbov4Kgog9KiLtNH0wl9I\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4152", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4152` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfNkMib+UTee1ere5bGi8FT8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhYjY5MDRmLWIyNmYtNDE4OC1hYmZhLWU0NDIyNGJkYzU0ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDcxZjU0Y2QtZjhh\nOS00NmIwLTgwMWYtMzQ0ZjI2NmMzZDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY/mpu9TmWJk9grq8mfH9XwZE3xOOo74dzG86FX1g7bVQVzlrbjDUr/R5A1od\n6ec6AQVi4j23Jn/VstSkGs65VaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL6HxS3y0ooQgihT3EMPhbmGQe+YwHwYDVR0j\nBBgwFoAU8iOXEvy4URikVluVp/w3pP2owZgwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDiuzCSxS5rREVkWnpWOPZfr/MTrLHpb19seoR+b0I2GQIgQoJYM45/Tekl\nnfi/BiFHyeJFqQy95LXb2eh4pHIVvFc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVHm+Qzv+XccfPl/w7inFr1fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWI2OTA0Zi1iMjZmLTQxODgtYWJmYS1lNDQyMjRiZGM1NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvRSCLAgCQxnD0mIpiJjHidDTcL1rnrAIcsYWIgGhcU4Nf\n3JEAi/88er/8ie2dK4WOscDxJIAEw4po5iQGKVCRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8iOXEvy4URikVluVp/w3pP2o\nwZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKW4yi9ov3H/I8/F8XGSA0OiPHHNW76oMr2Zh764ViVcCIFcgUvJRrPuj\nqnobtt/qRBuP2rWpJ/bjD8YDDOJ80Ane\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAUwXrllW4V0Yp37jXVoJmBKkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDcxZjU0Y2QtZjhhOS00NmIwLTgwMWYtMzQ0ZjI2NmMzZDVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTU5Y2RkMGYtZjU0My00\nNTg2LTkyMDgtMjBjOGEzMDA1NjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\naVoB2jd0GcjCUq3mOeZEPG01+t+Jl8YfcbZh68nWOJwuEyeqXhaDGCviaH6eMFDP\nLx6fzn7FgaCCN2wRnUbIkaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUL6HxS3y0ooQgihT3\nEMPhbmGQe+YwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCw3KV1MQnytq9vGiDQMAXERLdehQodHP4PVUdJe3KCTQIhAPRY7Nf1\ny252dsBNdm6Mqwhyj9N3R26tiryRjxb0o+2y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4153", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4153` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAc2je8HQlvN70VaNWYMdZWrbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYjgxZTgzLWNkZjAtNDdjNC1hZWUyLTFmMDAwMGFjNjQ2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIyY2E5ZjEtOGQx\nNS00OTBiLWIxNjktNjNlMGU0NTdiNmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFBl9HU0bi20X+JbA1rqmuFCbtsfF+XZg68eNgDUF3xWoDAMBSthgz5gwS52D\nrRWMbl+Jt0NmRuUCAitoZdblRaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBcI+Cn62QNWWz2whdxDXBUPv9nkwHwYDVR0j\nBBgwFoAUhCxfyxa1DRlbfEKuwdOorSgvRBwwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC9\nut/sdyQavRlWssH3HdOIsKyDbleZ/zDXclKPThsOLAIhALCKow1ARdvepJw2K62U\nQV5BuVTiVckobmsJ8rOF8VWL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWYNDEUGXdwrUf7ENl2OwZCpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2I4MWU4My1jZGYwLTQ3YzQtYWVlMi0xZjAwMDBhYzY0NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1mXMGANpsFxswuro+uh0lS6Z3U1VsRR/WaWHwPbP7ay2V\nUOhF/qKkmnM15hzzvfK2fj3d75XJORLw87yPayL/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhCxfyxa1DRlbfEKuwdOorSgv\nRBwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMxHeLNz9KMpI8suukCKiHkdIxUCy3G+czFnDBXpH+MIAiEAm5AiMq+7\nke+fhEJ0sxX2cdcirAszDMb4tzZwvBmCke0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAbH5wpnSCza2GyIsZlP/hKpvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIyY2E5ZjEtOGQxNS00OTBiLWIxNjktNjNlMGU0NTdiNmEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmE1MzliYjktNWRmYS00\nMWM0LTg3MTItMTQxN2E3YzU3MGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCqR3FtJN8UDdeQOeFs40RLNI6/0Wj4haxcYMNl0mLcHMgRBHYPz8pJq22f0Kz6Df\nPia+7FTPcLOmFcCwVznvlKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBcI+Cn62QNWWz2wh\ndxDXBUPv9nkwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCM/fPZ4WUeGhoXnIvHB2BdmqkMSZM81NCvBqfe8pQEHgIhAJWVANe8\noXw5TZFJ18ALS+eicCSDzSJ15W/qTAVma8IQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4154", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4154` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAVOpdnYLzseqQHuvNWeTSfN5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MzI3MjI2LTVhMTctNDgxMi05NTI2LWJhNTVkZmVmMTZlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmJhMDJhYWEtMTg1\nNi00MTU1LWEwZTUtMzY1ZmQ2MDQ2MjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEClVxzk53xRUnICmE/d/lxq1Jxc5b/K0QEkiWA0veFeKJiIa1a1j0d6PmNtk8\nFcIH0b/7zDX0HFwAukllLLVze6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHofszrKy1eYdoKCXegmjIMMJvdswHwYDVR0j\nBBgwFoAUAwExNKgdh/Zm6MP3yBKnw3NQ0LswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIAHupCo/cuviA78FQU77lBYKEhYgodzrxanXOBKsEAJ9AiBxAwfS\nZsw47M2CD8J/aiyo2k6hnBDItgDBy5X2SIRRWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT7GMgWUH3S10xGZRCF17DLwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjMyNzIyNi01YTE3LTQ4MTItOTUyNi1iYTU1ZGZlZjE2ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvKURJFm78d5pqMfjPxeqXE7jPaFuBtuBdjE4z0AlAsC1Z\nKOrVPXvv6cdmeSI2v6vb4eapBCHr3KgtxyxZWBf7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAwExNKgdh/Zm6MP3yBKnw3NQ\n0LswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNNTu+2kq2FZSZm+MXxVwEDU2gDA17+S8GYg/ol37agACIQDfq4BQEL2w\n68TcWA0wfZdEv5YFAhIYtMJ96dEJ8kJEsg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAa2BmQz1zSZmgwGTlegxrHGpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmJhMDJhYWEtMTg1Ni00MTU1LWEwZTUtMzY1ZmQ2MDQ2MjNiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjNlYTdmMWEtY2U5Ni00\nNTFhLTg0MDYtZjBjYzQyMjY3NzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nahA6vJrq5BwiZDX81+H7OZ81tqmwbi6rAoZjcmiXXppY3Q9oOladko36Yu7DX+/Y\nKeMYEnri2jzFIm5c4YBjMKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHofszrKy1eYdoKCX\negmjIMMJvdswGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDeUv/x3vYN7/1gMpuiRhSpzffKlr0gRgIC+8akOhjtFgIhALtYZP1B\n90tn944V1W02PGQF4QZOku+UY37rM33w7OOA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4155", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4155` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAadg1IGfqtH0UX0zwKrTyys1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1ZjllYjJhLTYxMTUtNGFjZS1iNWVkLTBhNGEyMTg1YzEyNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUzZTNlZTYtMDhm\nYi00YzZhLThhYTMtNWJmZWIwOTQwZWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAb+hw2UhWD64125CobZnhNELHVDcQkA8LeFnSRbznw+mET/yD//wTFTc6HSP\nLRDbMgMoxUEKJ/im3k09YWxdwqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFeTzIrQqQlo764Cd7VQf/JXyvgMwHwYDVR0j\nBBgwFoAURwMb3qyJWP1vzDLF4U5CZ9BKZm0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFAk+6YG/jTaxxkfCxAp72CKdwXbnmz0KhZWPNZHcVlmAiBhfL8p\nPr78XIz4aJHYJ/+5PJ0HFTEbD0HOVDUsMbkZyQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWz8NmkOGqcaDsHfkSsjEr+uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWY5ZWIyYS02MTE1LTRhY2UtYjVlZC0wYTRhMjE4NWMxMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTvA+WI3eiTfISE1rRZHEO0G1RE5QV0cjoBCuFa5tsug+4\nrH8+L4cZaDSbIsCbqLGOvaPX+PjyF+6Fst0wJHaYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURwMb3qyJWP1vzDLF4U5CZ9BK\nZm0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIcO1ui480Wvk1Jqb1VLBt6J4Gz74uU8aD8L2PcW/SDPAiAhnZ0UdRVl\nVe5gxxHTE9TiCfvzhCd8vm7ZKPDuEJbLYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAWethaT+NfDcANyfQb3gIW+NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUzZTNlZTYtMDhmYi00YzZhLThhYTMtNWJmZWIwOTQwZWQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzdkM2JmMjItMDBhNS00\nOTEzLTkyNjgtMWZjYmM5MDgwOTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nX4HS40Fsbsl04CWYoLw+WtrDsMB44tgPsEOqDy66KfOvt7Vmh8y9glIdJBJMOGoh\nvIij0NPgrTzblQIZUa6QEqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFeTzIrQqQlo764Cd\n7VQf/JXyvgMwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIC6KMqd1eB7qZ6pvG2nA7U/+lVxonDCgv+KvblVJY0vhAiB9KXWAYYIW\nuE7dJRv5eKc+2tRujGsemw/3YqJLnnkgbA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4156", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4156` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAeqQyZX0ELSNs269eeqMHXORMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiNjE1YmE3LTM0NDktNGFhZS05Y2ViLWY3NzdiYzU4NmZkZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY1NmZlYmYtOGYz\nNC00NGFlLThiMzItNWRjOGU4ZjhlMWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgnRU03SzeJyx0uoeHacI+sdMWv2rOLG+I2qzX1J/9pvZEcaxt6I2iL9ORqJb\n3DNMYXWZGgegZ6fjhEQjTijSS6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFfQGNHoUsnyuHRcVHX+ffVQBbwFMB8GA1UdIwQY\nMBaAFAxGB86NynZPRnJjx2XqBORNZeU7MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA+gwQcMIIsmT2V8A94RJkoS5IWgb+B/5T\nT2C5CroKBEICIQCb7KIF0KwlsW81ytacRE2kKG8kSgzGTcDMQqjgg3RRaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWqLpuHBny+3QM9hn2+Cv8/kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjYxNWJhNy0zNDQ5LTRhYWUtOWNlYi1mNzc3YmM1ODZmZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7CEBOmglSGbpuzf/8zOIOC8+squeX0HQNd+Yuicxl/Pqx\nknn3rWe0HLCLdEm3CCWWI5Fa8gqx2ufdFDGhhRsAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDEYHzo3Kdk9GcmPHZeoE5E1l\n5TswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI77PoJsf16cTh+qtW9oWNzrO8H3dmNebAx2WibRaE0ACID/3hB+ZvFgK\nMjaRTRVp10YHGfsia9xz0GV8t++DeiLH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAdr0z2e6B/+6p9YPqUOGLxryMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY1NmZlYmYtOGYzNC00NGFlLThiMzItNWRjOGU4ZjhlMWMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2Y3Nzk2MTItYzlhMi00\nYmQxLWI0NmMtOTM3MjI2OGM5MmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLVdk2W44u32xJWgDctvLS9LyhlXXrNpOwXsMFFptynxztK9iMlXCGvTH0LeNkT5N\nHNPOoeaD7UQy7HaOnACMDKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUV9AY0ehSyfK4dFxU\ndf599VAFvAUwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIAqFk/OYeF+CBY/EK9SHdo4nmhGTswsqelg11s+t53hHAiBIabqzFamo\nuJniepLAXTt0PH/frewJ4msmbnVzqLUotA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4157", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4157` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAY1BvehLmuh15/3elG/MylrrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4NzY1ZTQ1LWM1NjYtNDM3NC05NGUxLTdmN2Q1MDk2ZDIwMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI5ZjE4OGItOGVk\nNy00M2IxLWFlZjMtN2RjNGQxNTA5YzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYmuUCQqPuMRunwlLqgbTkLJ3WkxEI9pdf/Q4xe0wGqnwxFrIarkwvYw7NmuD\nMp3KAIQm/MEk+2K3QCF6zapj4KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqLT8JcpoXvfkuf4yJ60iHyfKtf8wHwYDVR0j\nBBgwFoAUOi3btoGG6VSW46pW82oR+LxGhncwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANXjfj8B89h6\nNxZBvYY7Ht4papI18H9nVeSZGFL1HmVyAiAZoqFRaoz8+MZLjva1Ps2M3/T0dvNp\n3CBlzyOtUxPDdA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASTr1hrD3QXPl+IEsfbX147UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODc2NWU0NS1jNTY2LTQzNzQtOTRlMS03ZjdkNTA5NmQyMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMTigAnj+n79dfwtWhryD7NmJst3mPgqB6rrR9KBDchLNM\nBY1nmHxrV3KXkYRwoI/LPHQrpzi1dxbNsc++ywLFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOi3btoGG6VSW46pW82oR+LxG\nhncwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANf+BxXb8DH5kfiGiw1iXt0s8ny9f3f4QFnEazl3fcdpAiEAyeexFjMB\ndF0prsJM5fPPXbH9Z7H9L9+f2Gzc3J/Vklc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAQzyYtjScFNFNtDM169NK4vUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI5ZjE4OGItOGVkNy00M2IxLWFlZjMtN2RjNGQxNTA5YzU2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjc5YzQ1NmUtYTFlMC00\nN2VmLTkyMzItN2Q5YWE2MjczMzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMLDfNnLg7TGkngsM9zXzmpKGtZhSS2quEXtyyzu8cXHio+q4pAyfRN1dy+GLBN7b\ngwnwVX/tg25RHnsJvQxNIqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqLT8JcpoXvfkuf4y\nJ60iHyfKtf8wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIG8yo+NNOxmjAdRsbc15J0ejFfg1+GNcIdSHlDhC7wCtAiEA88xZyw7b\nnQrBLIoaQu1w+9Fszd+Sx/3XR99baNjnhaw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4158", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4158` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAY8VOPLB1Wed8Cw7fMG/WT5iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlMjhiM2QzLTA2NGUtNGYyNy1hZDc0LWZlNmY0ZmExOWM3NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE0NTFiZDQtMjEx\nZC00NTQ0LWIxMDUtMWZlOGFhZjEzNmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaZJWOKZrIkCrOIKVhcZszD2DdKQInJfizq3M1hTDOJHht1W68OBMHIMl8eLp\ndcFYpeNV5PVflPFrjv/JwIotAqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI87GiE8hPje8oIW8WB9VSP5OfrowHwYDVR0j\nBBgwFoAUmSNPMmv7EIwUZHGwmeGkamQZD/gwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAI4aymXAdMLB\nFMvGRMlzyfIC7VpMok8v+YerDE92mxXGAiEAg03txGiDlfV9jkCS+RWLEggNIIan\ns/N1uhp80Sun5FA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZyzDViGBvrpQZ9sTfNX1grbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTI4YjNkMy0wNjRlLTRmMjctYWQ3NC1mZTZmNGZhMTljNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQst/gX/Gir/o5pTvpGH8Z5yAYTd1zjbIhUu+y2bOkzQVSu\nxwKZ8dS8M45NPsgnuqDChWm/DWXTPFaEeBxdddiFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmSNPMmv7EIwUZHGwmeGkamQZ\nD/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMsq6DsYIxu0o7a8SCVlabGv/wzyq/H0qsB1C+Uj03zcAiEAmG3TqMQ8\ntrdJL5bwUWF/vFQIezjtF3PtTgWFvOwjMs4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAbQ7KyJI/dQiB70olVN9t3TPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE0NTFiZDQtMjExZC00NTQ0LWIxMDUtMWZlOGFhZjEzNmFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzljNTc1YWItNGVjOS00\nMjg2LTk0NzQtMjkwZTE4MTkzODg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nB1jVcIzEeDX0YjHsYLWs5HcRF5ZyhwnPxfiLGVxoTmTnLpPTImdZ4m2A6y+VF7iw\nVvfo+j/JBXwrafOnKc+khKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUI87GiE8hPje8oIW8\nWB9VSP5OfrowGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIEzmLmJATcYU9CQXikRO+kX2D+oRh2cQHRZ8OMuTEiRhAiAAjMfPJeI+\n4QGPxg7dk+4+JEQwW2e1+FITVh+IZGeNgg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4159", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4159` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAaA86n0rRg0U7ULulgcZQgNCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNDlkZDBmLTk2YTUtNDZmYi05MWYyLWYwNmY3ODVkYzZiNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM4ZTY3MzktZDg3\nZS00YzNhLWExZDAtYzBlNjdhYmFiMzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEie/xTxzvZdzo3HYQooC54LW2ZEbnB4CQEjqJma3ETYZaSOza5naI+l94Lor5\nuQgWYB5mKUBt2+MiCmCZrBJj1qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA0ImKFf90x7tXkBiOe6aQ66UGD0wHwYDVR0j\nBBgwFoAURPZu4U5Vehtd0YxxO3L0Yk842GowKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCeXbAzFfzB\nEW54hcI0BA8WzAzwEFGqpV9WlMOHSYeR7gIhAJwxV07AdvzKBdkquXIhytIBO2Z1\nPQuovPsUXhzvZPBy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAclNCpyqtpy24ljpL9rc4mUcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTQ5ZGQwZi05NmE1LTQ2ZmItOTFmMi1mMDZmNzg1ZGM2YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9/pFSkfhU5vG6gGCw7NrVrNqCSI9JpvvjrwZpauabfgAf\nhK9hI6mQxfrvjO1gWKbwi6ZtMJy4emMC/Y1SMxY/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURPZu4U5Vehtd0YxxO3L0Yk84\n2GowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUzji+eqRFLS4kFtxpsY/AsRSheFFo8pgcegx80pAYmACIQCMObGtkl8k\nq9Qf6J/bGKAShV9QSaBd1Jg1DGNC/NAiVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAQZ8Yry44eTGsZ1x0G9bnLQ/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM4ZTY3MzktZDg3ZS00YzNhLWExZDAtYzBlNjdhYmFiMzUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzcyYTg1NGUtODcwMi00\nOTllLWEzMjQtZWRkNDI0YjhlOGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCIZZkVZOKNGpFnM9TURnEW/UasA83gu5o3Q068mBMzNKRQpPDUdPP5RZ/YECkeR+\nVSmNxAPHb2a/nnNWLz1guKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUA0ImKFf90x7tXkBi\nOe6aQ66UGD0wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIH+B6bAr0cLQGUP/h0TTlEojF1KXAHnYRuxA2bHKt0XeAiBViUvRTnjC\nPRnoxq16jNE6vXWqfbbTx4czJRkrKBZ1xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4160", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4160` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAeXOX982D5NpxrnweB0x34MNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZWJmNGRmLWM2MzgtNGJiZi04ZjEzLTM5YWNmY2RmZTJmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc1ZDRkMzAtMWU0\nMS00YWJiLThkNjQtMTY4Y2IzZDBmNDEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXEhZcF/YB9USlrNI4kW+NwtOO+oMb6Jm+41aUShcKun9t+pI0wZk5dQk9uxv\nEuQfOnpFiz5TYMqBeFZt0iAgOaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqgGb77LA24zamLqfvhSilHxBW7MwHwYDVR0j\nBBgwFoAUXLEgN8x6VAip1NvFKA9N4x9tPDMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDE1L8h+ojZeKB33YbQ1pisoHZekQDqmlEHiShws5onpQIhANxJjG6NdMKY\noSCIuOOH7DSO0CLW6fKFYFlQ/xwVGVv7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQPGP6WPUG4WAXR7jX3zLJ7jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmViZjRkZi1jNjM4LTRiYmYtOGYxMy0zOWFjZmNkZmUyZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2GzBI7BT84SJ7s4Zarhq59Y3nkHK+Anj16jsw0aCh2sTA\nPqXCn1xE8MmHcsMCVQcXy3nXWPU9kDHbvLo7WkAco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXLEgN8x6VAip1NvFKA9N4x9t\nPDMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN9YFW3cZL5M2rXSFUtXieKcSie4emLGKdnL6tt4EnUvAiATcTz1qgFr\nZvhCVT4d5Xcf2ks0fGpa49md99R+Bo3diA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAQDTSXHnDHUNYY18umD079SiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc1ZDRkMzAtMWU0MS00YWJiLThkNjQtMTY4Y2IzZDBmNDEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWQzNmQwYTUtOTdhZS00\nODYwLTk3YTEtOGQ5NGQ5MzQ1ODQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n41sbr0odaPI6jLlOrJ3G3ih1vhaOnqoM31orF+a8u6bFNB5M4ZD2gaDqbm27Xw/p\nXzinw9xC/Mz8P5Y5KgtZoaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqgGb77LA24zamLqf\nvhSilHxBW7MwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIANrAn9uBvNNa78bjmtTYFEM3iPULoUhAD+da+cdqG2FAiA26VvwzyAt\nOGmdC0vlS5Jcs9EO4557cGKzvEW1l+kqeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4161", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4161` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYPAS26+Ha6A84y92Wn53sflMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjYzA5OThkLTc1YzctNDAwYy05YzJkLTU1MDZkZTBlMTM1ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQxMGJlNTAtZDc5\nMi00YjI4LWIxOWQtNWUzYjczMTliMGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtP0uv/k4xkM8A8Y6vdF9NFnyaaavrjru45NN23d0BfSIsgxiWX/98SkEHnee\niZNSieB95sJDfS02PTgP17T14aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBojGNq+wRwcjuBw/5yZw2SXJeDowHwYDVR0j\nBBgwFoAUrRdNwi8MiqRJduxRIGtTGT2UYpEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAXqiTn3jDQ/C8ps1W/R2fGIVBv3o4IajfrarkxlUyLcAiAOX88cEC1sqmyD\n7gDYdOAXMj/ykezS9VJi609Q4CPxSw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR/zxQVENGP4E/C0cDhckWr8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nY2MwOTk4ZC03NWM3LTQwMGMtOWMyZC01NTA2ZGUwZTEzNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAT5DwHI9XVtVM6uDDoI7ZS5S5ZnQJFapvFTiLWkEgZSKP\nrNA5ykUpIBsovJ0erJ0RB4b4p+OwCYauj5P0ha19o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrRdNwi8MiqRJduxRIGtTGT2U\nYpEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaDvpYPob15MkB7R7uKHWgpB5l5Hbi9nnWBFtKfNTJeoCIQDohFjbcr6n\n3wuQZ762XrO43PxQg32dz0/78oADHcQc+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAWGBAnFK3wm7J8iXHcSXndP1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQxMGJlNTAtZDc5Mi00YjI4LWIxOWQtNWUzYjczMTliMGFkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzE4ZDg4MmQtODc5ZS00\nOGQ0LWI4MzEtZGU2MWNhOGJmNjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkgQxfOgm2IxvOPCNpEynD/LhyHitbTiIO6CpTWNc4dYTF8gs3uhbPN5LUoiXgaME\nQ6TxzvI/iRJPqXz6MVOFbaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBojGNq+wRwcjuBw/\n5yZw2SXJeDowGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDsOFeaJP2UumwvjXMLHHwJaldSCqqDT1fm9z/+Ws7LzgIhANd4qUGH\na9invCWyofWNCjHp0PGwIs6pMXdcxWQKCMN0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4162", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4162` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAZzP99UDP6qVB8orpgwULSDyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwYmM1ZTQ5LWRmNTUtNDJiZC1hZDVhLWU1YTAwZGU4YjFlNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBjOGM4YzMtY2Y4\nNC00ZDgzLWFlMjAtZjlkZjM5YWFjMmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9ujkh4Vn/P8ht3FIqmaWCT3yXL2isza5xVWhbIg9u/gdFz3CU24xGMj+a/Za\nwedkYlk5l0kU1nzeuERER68KcqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXgFGQptecFVPE6X+6mJ47x4iuAYwHwYDVR0j\nBBgwFoAUYesmAK5CR3PEx36MfTeZg8dLYeswLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC+\n1RJRrM/THfw/8e51jj1o06ksA6/oTZQ1Mdx2xmie4gIgDO2ezN+xoX6RP/b9Y1rR\nq7dVZi/CNcp8QE9OeHBqU1s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAesM+1SlWpMYLx5f556Y4rviMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGJjNWU0OS1kZjU1LTQyYmQtYWQ1YS1lNWEwMGRlOGIxZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrIZISXJ+mAzatvHSHP+/IHFLKURQ9AZ26iTqHu16ioJG3\nodpsXEudSFaGkj+TJzBKyxZn9XysfbP5FQxGcMCoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYesmAK5CR3PEx36MfTeZg8dL\nYeswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAImdBk9bRKGw5SMgQ3UT+Bqjtsej5WrMSX+5xNg8iV1EAiA37ZXNv/Yw\nbAVYpgc2eRkpPqVcnX9hd/0ICJg/JGygAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAcxeFfU0Cde9cLjDQkobUjOcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBjOGM4YzMtY2Y4NC00ZDgzLWFlMjAtZjlkZjM5YWFjMmNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTgyNTYxOTctMGJkOS00\nYWFlLWFmYzUtMDk1YzlkYWE1ODU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nn1c53NPgVwerIOQGRDikBzEzcoBOZ7QQ9pexEPqlWVH4v0rrejQiimzWJlt3PrlD\n4ZbVlV29tHMckDgbio6tjaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXgFGQptecFVPE6X+\n6mJ47x4iuAYwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDp2K4WbwLcVWV2CFViQjtYSx2df5Bf6eK1FvDO7aspxQIhAKGDoRFW\nU0Fkw9jnyv1KJYnQgG0Q0pvnw/HCetSugC7A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4163", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4163` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAQQVlsgKrPvAFcPwf7CDv/I6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0ZTMzNTA4LTNjYjItNGI1Ny05ZjA1LWM5OGY5MWI3YTIwZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJkM2JjZjMtZDk0\nYy00YmFhLTk4NzQtMTNlOTlmOGFiMWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgg1HU5gnmYj4uhvfy25F5Qaw/IhRoaXS4ud8p+1zKnPxuyhbl3AWzk2FLbTk\nEAiRYcQxUt94mMt0VgAHfi4afqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM3sCEx2GnXm43d7nKjwWB3pzRFMwHwYDVR0j\nBBgwFoAUgL0DgvprYcoh6fnkQSk5BGC2JKQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDMvxtcaknxpDdl6M/Qxx+Hsnb/IvYMuXky9P0HI6KXjgIhAPF8\n+5okUETkktrkaJCzP278rr/Qptn2nuBrNUgof5lj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZysni09zps6M+vP3QcdwiN+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGUzMzUwOC0zY2IyLTRiNTctOWYwNS1jOThmOTFiN2EyMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxr45CyScDsFBwy09YdbBCm3P7eXWAEu9vLrb+TrfNctl3\nzcVrnmC+yoKNM4VoavsPw0l+AL8GVG7i47hfQzwOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgL0DgvprYcoh6fnkQSk5BGC2\nJKQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPjhxAaZkv4Z48bomyuaD+rdf8D16uOk2Dsbdq+oBPIIAiBc/m3l5mUl\n7rtAx200ylpI/Vlgnuemje6dPx5r6M3BXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAR7OFr6vyHt10L7XZ8sx0ZVIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJkM2JjZjMtZDk0Yy00YmFhLTk4NzQtMTNlOTlmOGFiMWI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzhjZDBmOTQtMDFmMS00\nZGNiLWFjZjktNzdhYzEwZDE3MjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxqdsRXhrN2Fcd3X5zHWHGq+vlckFRBL8OL3gYRdyNFQ5eHFFN1mUrJelLxKzVH/I\nrTHxt3Fkluj31Lp5CgXT86NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUM3sCEx2GnXm43d7n\nKjwWB3pzRFMwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDZHYR2aTMHsTNjZv66aIhn57Fb5WaqpyKo0xz9sx8BCQIhAKD5Z81q\nh+4bS5ECr2IyeJpXNjszJM4Td3D2FZonpr7f\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4164", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4164` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAeSMbjh4i7+J2dj3n1lweFkSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MzZmMjg0LWE4Y2QtNDBlNy1iMmM2LWJmOTlmMzY5NjhiZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYzMmRkM2MtMzQ1\nMS00MmI0LWFkODUtNzAzN2RlMTZiMDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU5rjJBhSD9PL0WRcrRv8bXS9fwjrTaWyRwEWMO52K3SC1SvIxFrNBrR2jzhX\nM/wtwfdeaHsjcrHNd38br2k3xqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDiizG/Tm5AClD+bL5C1iFTXZdRwwHwYDVR0j\nBBgwFoAU7n8x41pkyzIz/oL7Ap+8uVidRoMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIG63wPkUOBHSo7IMyBoDPgPRbqRGP/RIooFsAlhueDxaAiAZJ8s0\nP814b7eIPiP98Rv3Mv/9ANJEk7L27s4dIM/haQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaufnJcOKFv3/THBRBqDzzUrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODM2ZjI4NC1hOGNkLTQwZTctYjJjNi1iZjk5ZjM2OTY4YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBaUNUB9KUHnpatSxAnLbl0/nnwXdtcTJCCA0ePdgDYEhy\nMz0dbrnaa7s6AiTDdOIHCxeX1Mc5JzaELPBxDATSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7n8x41pkyzIz/oL7Ap+8uVid\nRoMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRyA25imWVu6hIPJIbjxM1r/1F9SR7m+Tnd126rKCbgECIEi+XSaquiyj\noGvbh6Hl1dcnQygQaA9DDcVasDljWYxG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAW+IQfPSA7DUbJlomIqPDYKHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYzMmRkM2MtMzQ1MS00MmI0LWFkODUtNzAzN2RlMTZiMDRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDBiMzg3NDktMzU1My00\nYzcwLTk5MTQtODQ5YTcyODgxMjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvMmZGd/GDq7VGVzw7Nh42G5lbPfmlqM97nW6/aA3UWmOms1ceiBBF/1paRMlGcGs\nlAHFljWHsGDQ9J0TGsq4J6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDiizG/Tm5AClD+bL\n5C1iFTXZdRwwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIALmlId5XN3Gb0tIbPC6rhAybzzFYRPNrWnopaZPWn9YAiEA2X2/V8Uc\nqHx+qRwXvPzyb6sucrmeOGLJQ/nuRkX7ESM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4165", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4165` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAfS5YcD89lwHV/uY13z+shXQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4MTY2Y2YwLWZiODMtNDQyMy05MzY2LTYzZGYwZWRlMjMxZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAzMmZkMWEtMmRm\nNS00OWFkLWFjZDctZjZkMmI1MmU2MmU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUuOE0efxEfUGtl0GRLFQZ/DKvCZL02NUQbhw127+c8wYimuRg7gjzbUOB5c0\n9eBJpkJ0LoKh1mJWekLRsshkx6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSkH6pxMxbJsEjb3/yCRidMX9dMXTAfBgNVHSME\nGDAWgBTlYIopOskoHVium3F5R84I4ygIjzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDiXQWQOPRrLKXQQSooR+d/nY0e/wfK\n4xFNz46J1rrmzAIgIfrLOBGYIFPFaRhnRheS+VCABKLgBarvrMCzqB8v4cU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbQWtFC8fS2I+nliQ2XLHYY4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODE2NmNmMC1mYjgzLTQ0MjMtOTM2Ni02M2RmMGVkZTIzMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR04/Xh0irADPdHVb/4LeVlHbe6bRduMIDsRdbPZxLO56HW\nW5q9Ww/TnSTZ3tsaF8HGY+kvMpEQFfcZzDysl3aBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5WCKKTrJKB1YrptxeUfOCOMo\nCI8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL4mg37boSurRFNDVIpVFDjfe2JSCUlobI/Ln0yQ7gbnAiEAi/ERRpjs\nCIa6xvbrKz0+PskO14bODEr8CppAjtnmpPY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISARNTvKWz1o+jK1BlgeD5qttrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAzMmZkMWEtMmRmNS00OWFkLWFjZDctZjZkMmI1MmU2MmU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGVjNjRiZGYtMDM4MC00\nZmVjLTg5MTQtZmJhYzljODI1ZGNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxVIAf9Bc45qO1BqBd7J7KQ3jGgLRwd87H4I2UeRe4rdSYm570WcRz9zQdZnBo2HJ\nHZPOtAy49eshUdpL36//bqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpB+qcTMWybBI29/8\ngkYnTF/XTF0wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIG6O0/MNPrztJri7MNEPCaJvgYK4mAcySq8Iu2rY215xAiEApO0jje3R\nq6hyf4Iem0Ace9RHztMMaLehr/dpzSpXJII=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4166", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4166` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAXF957CJ5Tv5WsAeZXYHPB5tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMWIxZTIzLTlmN2UtNGIyNy1hMDRmLWI0YzhjYzVhYzE5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk5MjZmNjItNjIx\nZi00ZWI4LWJiNjEtODA2M2U5YWU2YTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3Hj09a6w/HuX1jlO/fXTPIkxOOFV34PLCFdZfw3zdkhgJ+6v6MaeO7kdjkir\nT/g+734kc8M6EFJ6jzzRyvXHAKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7WwoSam/S4MwkYqlAw3sXcQJpC4wHwYDVR0j\nBBgwFoAUi7Xml0Y+bqwB76HprgdUKgH0n5cwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIEWgqB4NWNK4\nPi2cbQqPDkci5SdpRYV7osMmPtea5TFyAiAbC1k4gpfPt4nRHNc+LJJJ5CyuwUVI\n1ty9dNKJatnHNg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaOVxZs0Hxaxcb6ZZgspCVsEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDFiMWUyMy05ZjdlLTRiMjctYTA0Zi1iNGM4Y2M1YWMxOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmIeKoUHD4YuJ80l/JtwoKSoB7dolfED5+aKpU4SaA+paz\nZi/FC28/3TlNXJ2VEpqt/OIqC2Isj2CMmmBBziCAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi7Xml0Y+bqwB76HprgdUKgH0\nn5cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHya8PrteRwegD+ESHfd+hJbQgfSITeplCTXROYlBtz4CIFTtxN0c6rCs\nfRndv7xR4CL+3NmbZy5G0cUzRoD9bmmY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAU13fNaSaXLb3fzHcwLGt03JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk5MjZmNjItNjIxZi00ZWI4LWJiNjEtODA2M2U5YWU2YTY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWEzOTY1YTktZGJkNC00\nNGNhLTg0NWQtYjRiNTIwMjdkZDMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyUVwZPKQB1uIbPIRF4nr7vrE/ZDg7XHYC8YKn+hylS9akBE26Ntk01QvZbEuENVp\nU7XOLj7KS+yEyTgHuHVygKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7WwoSam/S4MwkYql\nAw3sXcQJpC4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIEBFB2IknWTK5kS8U3zpxitm+2/wv/Qzbeli6Au/jnceAiEA2mxC6cUV\nd3dDcyIDST70PXGz2bf/giTHrIDKjF5Lu1Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4167", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4167` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYxNB/zGbe1FP2cF5R3heyBtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2NDI1YmNmLWExZDYtNGI2Yi05ZTcyLWFjMjAwOTE2MTI1YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJmZmRkOWUtNmZh\nOS00ZDM5LWIxMmEtYzlhZDkyM2U1OWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqBmp7QvBwwUs4Z8feKaDXnCFpTFWBgfoj2tpGhEB33QbaGjiqmcVwbZAaxLj\nb4w9De+Lq5vkKbZSF9jmxcu0haOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5JBoW0Z8eOJ6ctTkNtwqMvYkqPQwHwYDVR0j\nBBgwFoAU2hxmGxf25VFbp2kxE3zZMIBQc+kwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIB6L99GqukTs\nclrISHTHCGeqvDysmiq9GND0YkAzgrYGAiEA/4m6uq+C0oy90cH1PVBPmlE1Mxvk\nRD4EXt6CDAaxnr4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARCEOSS9BnHrRtngGeCVRoy1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjQyNWJjZi1hMWQ2LTRiNmItOWU3Mi1hYzIwMDkxNjEyNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATic9j2TII9iJzYeCYstTCNFyqWTg7GgelZOLhO2wYilS5b\nS7PsMVMbeF4/HrfbFvVzu5zt9g45J1C2lOHXcMGAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2hxmGxf25VFbp2kxE3zZMIBQ\nc+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJT7DRHaIvvQ0/AN+uNUiWl60nGmBTgoI4LCY+l7xy57AiAaNfnBs145\n3b4A9MYqPSoKr4hi4LOeflfBZNgEFZ2G7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAaSk+HMmwe1YsnP1pJNmXrinMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJmZmRkOWUtNmZhOS00ZDM5LWIxMmEtYzlhZDkyM2U1OWY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjJjOGZmYzItYzVjOC00\nZTU2LThkODMtYjFiOGJkNTZlMjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqSFum1hBr83aGWAboXNxVcLpgZOR90nZp+fDukPXhx6NRU5v8eH0wiOTSUf0lSC2\nn2qszJvSdRdR5O+LFqz6fKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5JBoW0Z8eOJ6ctTk\nNtwqMvYkqPQwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIHc8ERbcSxDQ8vzOpPz6Ai5i58hXmBkdfBME/NmFqtkDAiEAigL43fTn\nKB9Gj5HT73ldObDxWh9c0QUqJqQBDubVQ+4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4168", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4168` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAX9RGE01F2zs7M9edv7jpAb/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhYWE2MWU3LWU2YWItNGFkYS1hYWFmLThkYTViNmI5Yzg1YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ2NmZlYmItOWJm\nYy00ZGUwLWEzNTctMjRhY2ZkM2QwZGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ZfuS9o5EuIi5jCqhBmIOJfhh9uw/IxYDVKoHxlv0ZhUnPaOeRnFlie+SbXC\nsmPlycGY6UkRvG/atxmfTCRgpqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/9h3VF1xEh9HOLLYQdde0AZfs3owHwYDVR0j\nBBgwFoAUhxXXZuK+gP/32Fibn95CJlfBjSEwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAtOiKL6PQ\n1+01sQ26vyOX98ohfhhDr0jN4/SNjW6bNRoCIQD25cPrCsXzgAWKvipHrT1aSCx4\nDUzkXOXVXyInt2n1aA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXFlAAlUTdzbMqei0P1VjnmUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWFhNjFlNy1lNmFiLTRhZGEtYWFhZi04ZGE1YjZiOWM4NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyVo1XYGPKqhWKomdP+cI5X/XW4A20DLv4Kmzwxclw2RWf\nqCnPPdoR6YegH2eCXrFcWW97rYWvdGbiJYXLhBSJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxXXZuK+gP/32Fibn95CJlfB\njSEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK9H0Iv08i9CRQ3w+r8Py2M5/OD/UpBXZvpK/VOiwVE8CIBNZTWsf3DM8\nPJ9m/8iKz43j81wvv9zXwKkdgKU0vaAj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAR0ziPqbziGxhvAAMhDvdPthMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ2NmZlYmItOWJmYy00ZGUwLWEzNTctMjRhY2ZkM2QwZGRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjZjMWU3MzgtZTdkNy00\nNjllLWJmNzEtOGMwOThiMmMyZDM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFYW1tq/XJ0k2cSTEEru7V9cp8fhFSifPyCboKZz0PycGqMBFHsANKf1bhdl1hjit\noQqihhX1WBsurTdCUelCcqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/9h3VF1xEh9HOLLY\nQdde0AZfs3owGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDKf2kiwA/zHpS9iUMDqwsKQRtDLCQKM8TreJTHIoa84AIgD5lgEIy5\nlxAg8Z63LLrdJwbuOa+wMxW291VLVFXU3dk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4169", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4169` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAa+46B806vv50Wp4oqhBy5TeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5ZWM3ZWM4LTAxZjAtNDM4Ny1hMmYxLWFkOGVlMzUyYTExNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGExMzg0NDgtZmQ4\nYy00ZWZhLWFmZTUtODljZTc4NDYwMTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECdOcRWFMj1lUEMp4cneeyIHCluunyarAEhbDrBlDWYfzLBWlf7vCjFqJcw+T\nF3tNDNbzWyiGIDWXjnYcaCYmfqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdo1igdtxLg0XtPXRIabrPXoGiVAwHwYDVR0j\nBBgwFoAU8OJSf+LRyIrPP7V+Ym37CwawjMQwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA1zkiBSGTK6pkhQjyCNiV19D4SvRPJj4yX5m6jKPY96YCIH1DhbJC2g6S\naIrwTlRcUY9EdBsdKCELN6Q+FcPovXdD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARVPwQyUFdXEj2Uj4lO0zmV9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWVjN2VjOC0wMWYwLTQzODctYTJmMS1hZDhlZTM1MmExMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDByOmKdxglAEyhJREYeW+0W4g6VbG1k4l480WVsv4tZ4L\nhBZ2ZZo9PwEKfyoWu/QPJJETmoDxkCybse4W0pxvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8OJSf+LRyIrPP7V+Ym37Cwaw\njMQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMcei1bnLU+uAUsKDp/+sqNb6yArNhpVAZlW4SJugtKsCIAiZUBj1IjLH\nnPFSyzlXPKyA+DHihjsfhJEKvPx/kkKH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAWwGutFSh1Pvz33iFHGT5Rh6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGExMzg0NDgtZmQ4Yy00ZWZhLWFmZTUtODljZTc4NDYwMTc0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTY4NjQ2MjQtMDFkNS00\nY2ZkLThlNDEtMTBjMjgwZmEyNWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMDd+rYQPb/gMrqmu2y0JxY5pgAvR61K8yIYFxvh5+BRlVmpsJKC79ohzIMFeRF4s\nAUeIT+Djw2TN5tm9lZ30zKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdo1igdtxLg0XtPXR\nIabrPXoGiVAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQD2o6mNl8C5/Tr3rH9NsUP4scWzWzw2tMDQ08GQTs8VQQIhALh4+PAN\nQYzSO15YgX1UTop+b5QPVPuPApKBWnU/zysh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4170", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4170` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAc3lTDGi5otfjETNOgijF9M1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlYjE1Njc5LWE3NzYtNDU5My1iYTk4LWY5NTM2MWMxZTBkODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM1OTE4NWUtNjU1\nMS00MDE4LWI5OWYtNmQzYTliZTE4NjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaNE1SvV0yFk0e3IGq82Qx8N8GhQ3pP96soVAS1+IzhuO89pUq/NPlriC4JE8\nthvyiZDOZvdQOOYu0VJCYBKmLqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZwm1oenDMPpluf72mPcZZlWVgnQwHwYDVR0j\nBBgwFoAU7AdEmmFhxhDslIZ1gwjCHwvyz/0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiBtP30WoKL9kb73I/nD8bIQ6IObI4xi3PnbFggWkaBdVAIgBlFceGCuPhEq\nBsaVUDEx6d0ybgE2tI30mYterI1uPL8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVOdP8KlMX4ut5xYLj0A9EAGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWIxNTY3OS1hNzc2LTQ1OTMtYmE5OC1mOTUzNjFjMWUwZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAJKUDf7miV8/7SQ7OhbqwB7UTZDDDl1u4owd7wKvFGZ1T\nF/K6C4a/mmveFWvRmpT8VqCRoukj05Gu4mAFMahio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7AdEmmFhxhDslIZ1gwjCHwvy\nz/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDoQN8ypm3dfY9l4I5jEzOzyBzOaO2IPcll3aTAhrglkCIFH4zoSDznPs\n6/xj6LrtIx20COKDXZXUh1E1uPIiCw9P\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAVaO8vu+qlILCkBsokX827ivMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM1OTE4NWUtNjU1MS00MDE4LWI5OWYtNmQzYTliZTE4NjE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWIyMDg1YzItZTJhNC00\nZThhLWI0NjYtY2ExMzVhNTA0Yjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nd7MNB8hKGxj2Z9ZMzurhHaisu5KiKSaocHsmVhMnNTVbZQG4s5Ff0UhbhK8yvB7H\nn1I4cxkFWqLlYEjVMRZnYKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZwm1oenDMPpluf72\nmPcZZlWVgnQwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCaKj2G/ghFz7hUlSPtHe0kqan/ehC6zOp4G6fqyqSDlwIhAIjUBnhg\nVzlyX/BAK1zNXxF8xLrOTLCtkqJ0MkiSCgcN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4171", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4171` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAdYVDkczxa1RpNMVESomrBiTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhMzgwMWFiLTE5NGQtNGU0Yy05MmJlLWFiODUzZDkyMGNmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFiMTlkMGQtMDAy\nZi00ODkwLWIxZTgtOGRiYTM2NzJmMDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5ejyX4erd00a1uJ0ylJrb1IhQD7FFt2+qIV+hnk1YiGWLL8OdLXq0hoMF+IP\ndw2aPZM8VLZGz9EpS/eWFllr5qOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZYP0UU8yfBWeLwZvlxpKZ7SH2LMwHwYDVR0j\nBBgwFoAUiwR/z6CTSt6ZpIdnBOguW3dq2MYwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n7914jZ+eahj3fnphvjwULJ5acgf0P3JN5ENZINFsftQCIE9no3jwgN0KmdAS8KFt\nPS3sbQAIdE2Z0ZW6kxWdFMhA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUD2a9jIb2LZFalMCp/OJo4RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTM4MDFhYi0xOTRkLTRlNGMtOTJiZS1hYjg1M2Q5MjBjZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5d1w2RjteDg53QKwznlR5v6UClZpZmeEMxExS9NXBj7Mo\nAJI3nH/EDKVRHV4ZBpFRjvpLyFTUgo4gsatDF7G3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiwR/z6CTSt6ZpIdnBOguW3dq\n2MYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKWG6FTv7ZPgUTjUi7N+FVZLUD3VV8vTjSAAvlpyZE+ZAiEA7QjkBl+6\nFwoa+JTgjeZfxw3jMPf0VCAhm4G+Kc+pirw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAb4r6Hksrj8h9Uu78jnEkpSLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFiMTlkMGQtMDAyZi00ODkwLWIxZTgtOGRiYTM2NzJmMDljMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjllNTllZGQtNGEwMy00\nMzUwLWI3NDctMTIyMDBmMDMxMjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFwIBF93l3fOFGz9ADACVR/FkvErgk5BTXxtMoqgd6MuMe7vNjI0V33ELnloe9Dif\nNDkBP7iICUTngAD4dK/MnKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZYP0UU8yfBWeLwZv\nlxpKZ7SH2LMwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCVa8HtnSYy3KPOprDeneHLSLuwd0gkV5ePhQHa5k1XoQIgYLi6KGAr\nO3BEPraX9Pci0S4upa73yVgoRI1IVWLncBU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4172", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4172` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAXN0k6+UFDQyM9z3j+ljGgC2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViZTQxZWRjLTU2ZjctNDI1Yy05YzY3LWE2MDY2MDk0OGY1NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RhMjc0MzktM2Rj\nNS00MDRjLWE4ZWEtMWY5Yjg1OTc2ZTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn1HxzrveuIXY7wHm3OofWjqbD/Eb+mf4gMwrHk0P42jBUQeIP+JJ0NthUyxr\n2fkJa/CWs0AtSn4pCwlwUvP9FaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYhEp8kjbrb/oAWJPLHsd3Fsky4AwHwYDVR0j\nBBgwFoAURyhY3oZlpaytq25NdZI0CSBOKIQwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA2gc1f88lDiKwdO2fK8JRzC0mls9h4C0jahDyC0CqcxUCIADa\nfKO7hArzPDwoIcsrhomiRVwGtHtt0e2R2aIxt/9B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAftuI2XpsZZ9zN0YKxtOd3UcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmU0MWVkYy01NmY3LTQyNWMtOWM2Ny1hNjA2NjA5NDhmNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASp2VnPK+TYz4d19OtzLzp+A5zTJmiOKGuOO6zqa8psnQka\n8AYG3NSzQ5p7qF50lk4NA9r3t9Q4pHJSMKHeft/ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURyhY3oZlpaytq25NdZI0CSBO\nKIQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANIEJliIRTsGGukrU7n4XSBC7RUTW3SMp/g7Pg85+owKAiEA1OwVsMM2\nAaWfsKUqAaTVIBnLoxdtKBPTH1nChlrM5bQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAbnS58LLDpy0q8UF+KoKSmGCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RhMjc0MzktM2RjNS00MDRjLWE4ZWEtMWY5Yjg1OTc2ZTgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjU4ZjI4NjAtNjQ4MS00\nMTBhLTlkYWUtNTY4YTk5YzFjODQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMc/hTUT83pXbrexiFpKDtqusNZnfw63ICO/s3LpDKTUb3gNgPV2XclXdigP7RrMI\nnKEMTgN7DEkNXidfOxzf06NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYhEp8kjbrb/oAWJP\nLHsd3Fsky4AwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDmjAMpeNQZXS1M0yBS4++L9AwRRwE16vZf+RliLvbnCAIhANbdVaK+\nkjReIHOpyQXtPEvY2d7MZPxSJPPRbZC6DXui\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4173", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4173` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAc//zNG2Yiy0aeB6paxErubbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiZTg0YzhiLWU3ZWUtNGJlNy1hMjNjLWE4NDhhYjhjOTcxZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjlhZjFhMWUtZWU1\nZi00MTM5LTk1NTUtNjUxODhlMWYwOTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+W50XkInWfIVnx/S7WBxjdUehqLYxqaRqr7c36ZB3f5XoF5K9dzGdUIpt8x6\nUbJSRkO/Er6Mnu2KNuxT6eIk9qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUG3ddD6qpcsm5Ddri1LkseSBD50wHwYDVR0j\nBBgwFoAU2hkBAGdVTvvJtShSlpxrVwBFvRcwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA1s+mByHL2PSkcPM+zbTzemqV7xSF08fed2w/Ma9PwiICIB1D\n1I4gTIIpmEjIKAVATKtywscV1A4gRz16dPGTnzZB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcQkNO1ksmIT4AwJE/bD/CBzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmU4NGM4Yi1lN2VlLTRiZTctYTIzYy1hODQ4YWI4Yzk3MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvSdGimmuZwyRV00WEMBMvRYaULHS4p8vr8ddMqJrmmpyh\naP6/dHGro+Uruyue8SILWrRFJx1m1E0QTjjApENCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2hkBAGdVTvvJtShSlpxrVwBF\nvRcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKWW94DkNc64kUPXKkz2cXposOSgF+cWABZKL8N5XCvRAiAqDgQ7LXy2\nevRVsXeC6crMKmIUau7rja2w/lNbRWHdNQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAcNNgkQGP6YRhJ+DhRTQwHeuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjlhZjFhMWUtZWU1Zi00MTM5LTk1NTUtNjUxODhlMWYwOTFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGJlNjg5MDMtNTJiZi00\nMzkyLWI1MWYtYThkMmZhMTcwYzQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlTeTH8hd1ym6hCPfuBMJS3gHQiJ9jKI3skLnem6IFmdeZItAnFJB6MPlfMMXzwpr\nO4QJyORP0+emaloGZggHkKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUG3ddD6qpcsm5Ddr\ni1LkseSBD50wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDE01jq0PRQCtoCBy3HKGD8AEgUM9IBd/N2hBVBkIRS4QIgHFQytESJ\n82/wlRMSqPJxlvaTHDbw2Vjvefhxl5CV6QM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4174", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4174` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAc5AMsvg5gOj62hrSTrmUXMTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwYWQwYTdkLWEzNzYtNDRiMS1hMmNjLTlmM2U5ZGUwMWFkYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUxZGIxYjktYTJi\nZi00MmU1LWJhNjUtZjkyZWUxOGI2OTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEheLymeXwQdotWYkngiZcDwIBAxy3mAVuUdV4oTMd3K2y70dJgewRbhXJAkyv\nQmVFF/Y7VHB95L65Dm9zxwJj66OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcvnAGNu4pM/iZOQaM06wfzP+ITcwHwYDVR0j\nBBgwFoAUJ409y5ApeH8WvtW7Lm8djmEPl5cwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA8A8f31Ms7zG8\nWY8vMQFBCWJREathZ+VzIQvWAfHZ/bgCIQCmICcnQpEnGAU+G+z3v3Q5Q0+6Nshp\nUNUwiZxOucIfwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUpA+56pGdeW3CwQD8qBJmkNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGFkMGE3ZC1hMzc2LTQ0YjEtYTJjYy05ZjNlOWRlMDFhZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVM4Rfs7ilR7unHMOBnst4uql3hx1gSG0+NrMOCbqz9H6Q\nGeC2idLGtK4Sh52iJ57QvybWOvF1LvwX3AANAaAjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ409y5ApeH8WvtW7Lm8djmEP\nl5cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXcuI9vYg5USxOQjn3txOpKVlCqp+c9ttayhdiTLLKcACIEvzMKCUnl3H\naeMSrSehv5YB84fcbl0tXVYGTlmUxh/v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAShpC/jBC/oQWFP7oT1e3dQjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUxZGIxYjktYTJiZi00MmU1LWJhNjUtZjkyZWUxOGI2OTk3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTg5ZWU4YjQtNTE4Ny00\nOGQzLThlMzYtMDUwY2FlMDlmMjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nv6e2CYQJ5QxO8SuQxs6yVZ0VNprLvcc2PHLrDSHnNKVn/spUEG7w1Zt1uxDNU8+m\nEvwc4zffpLdaNgvfvhsfe6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcvnAGNu4pM/iZOQa\nM06wfzP+ITcwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDeVkvTAndATYwpAVivNofvirXLEAYCQ6KR6wZm4vq8FAIgfyAsp2a6\nE4N2QuuvuS7fgKatijCv5qQRe/+FqG9KVBc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4175", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4175` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAa/shKKNgdCzeHF6jphwLxVLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlN2U0MDJlLTEyNjUtNGRiNy04MGZkLTBmZmQ2MzJmZDEyMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q1Njc2ZTgtMjg2\nMC00YmY2LThkMGEtYTJkZTI5ZWYzNjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAUX27wfz/B/AqfarRvXyDA5U6b2tSiunDzX99TO5jbHaLFdj7bcrdg+s+POX\nHO9MgxZS3uLubR/xzssJ5jaqmaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR31MkJV+uJfcMa0ISu4RrIFICk0wHwYDVR0j\nBBgwFoAULAJDoHEOZAewFy3bb6WErjq8xwgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIG5cHp84ABC2vZFbTIran7PdLbZXFjs52tozisLBFOphAiA+ZB9VwlR0x+3d\n6b/MVlRues4UURTuTgxsgI8yNKcB+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdNBkBLfKNDHp5rwYifjpwcKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTdlNDAyZS0xMjY1LTRkYjctODBmZC0wZmZkNjMyZmQxMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKCA7OLGvjzmuVHt8Tsm/rId4KEfO/z2LPnMTogeEs2pn0\npyuTVwhwrOB+MYW6YqnbGT6GXkKw/pVBo7hTz03vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULAJDoHEOZAewFy3bb6WErjq8\nxwgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdG0LgmOTaI2O/I41yMe09MwoxuLTSx7JtJ3G9iCiwwACIQCqCA6zSZvZ\nXHjkjP5PZAofL951vBOpEEv2YGJzoEzQhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAS+ba1ZYwbpuj1Xt6BaCuUicMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q1Njc2ZTgtMjg2MC00YmY2LThkMGEtYTJkZTI5ZWYzNjNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTNkN2NkNmYtMGUxMC00\nYzI2LWIwMjgtOWI3ZGEzM2Q2YzNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njqocHdGDx5ReZUWbTluHvc3R8mEio8NhKOe7WL+kZhBNLgiAAF8KoNGgAUusdUGh\nS0bfwdQliUVz6zp29TbVJqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUR31MkJV+uJfcMa0I\nSu4RrIFICk0wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCrSm0cisyiqaaZXpnoLQVRq/PjyCl+yZXP+PyQYFsXHQIgZbOPVA69\nm3SlewLdC1HGrx+kKdKb+oxpL2S7VGZPhXE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4176", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4176` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYB6ddR38ufAeSQD9sZo2fhdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzMGRiZmM5LTg2ZjYtNDM1MC05MDA0LTI0NjMyY2YxNDk1YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ3ZGEzYTEtNjMx\nNS00ZmI5LTg3ZWQtYTgwMzE1NDNlNTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH6shBK+tpl12yZ/3oLhZsGp7u7vhodFyQSICYR39ZgUjjlGk1dWCXt0/qlOZ\nvGUwcN/AJUdZvXdUWraJTPhW/KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaHPyp8KNTQSZ04SQSMdgDs7BJlAwHwYDVR0j\nBBgwFoAUEPiyonVewE/K/x7EtfBzDobooqwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBx2tr/9xc3rI5ebRlIx4lWdd+qdAUqfJXCsmOr2ksWCAiATfczzHnGZBsmz\n1qNr07P8E48cmzHMEM32ilRU6gbxcg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc/dqWEP5rCbkPtVTVj/4wsAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzBkYmZjOS04NmY2LTQzNTAtOTAwNC0yNDYzMmNmMTQ5NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASleVeNsBnzDbji+BTkhiO1FRHgpZlZVKYSoBv9h9yK+so2\n4Vg+HjOTpgRIKvho9gjZaZ4uGh3FLRu3BqT/MEvjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEPiyonVewE/K/x7EtfBzDobo\noqwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOLr6tyB1ngLGvGgDkvdp2p9wUKgY5ZUZs2yq2/ql1OjAiB0+Rq8eJZQ\nW4D2cSdk06l9Pjms4LdpHTbruRBZbg2y4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAXpknyJtxcF12gzlFRyjVZsRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ3ZGEzYTEtNjMxNS00ZmI5LTg3ZWQtYTgwMzE1NDNlNTg0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTdlZGMxNzQtYmY1Yy00\nMDZjLTgxNmMtZWM5MGE0NjE2YjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlio/ng2XEMF/2ZRfyRNvoPGJV0f8lJ/lVujkyaOfMbrBUZnFw4p7bxQTXS7FjN44\nNqgxxXA5SUgnuo7j3jOTHKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaHPyp8KNTQSZ04SQ\nSMdgDs7BJlAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQC2q2fdUfneBE4MIoV6tJE7eO/b3BF5NJjBOeAq0yQlFgIhAOhJPOrz\nmaBIXLVKzr+jM7vy9R9npq/zq2yoy23a/Pjs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4177", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4177` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAfzczJEegs/jKUbV8AAImvMzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZDNmY2ZkLTg2YzYtNGQ0ZC05YTdhLTYwYjI2ZmZiN2IzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTEzZDRmZDktYmJi\nYS00M2Q3LThmOTItODE0ZDZkYmYzOTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET0rKWlD50rQiyIz9tI2EZuwjvV1FytoGS4lIhzBZ0fkItT7tEiNv2AtHWBo0\nqgwCUJZjnuw0bR4081WHXaQzgaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL5DzbL+9VX0OgORODqas/Zgfj5cwHwYDVR0j\nBBgwFoAUfZSyC1WCueRxaeFqj9Lol5Xz5VwwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAuaoX/u/PpyA13x5EjARX6Ysmh0fsBZ3DaHYgdGYx29UCIQCncvi6sEOJ\nre6/KWkdZu9Uoq8DblOuoQTwyNvCiwf1sA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQEcdq4IYShYvtSKsaa4ZWCxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWQzZmNmZC04NmM2LTRkNGQtOWE3YS02MGIyNmZmYjdiMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARG1Y0N3ANLA3nrlxQZRZ6KncFVFSdwbSEXEJ9baCekdOJJ\n2Oc948+F/78bvssro2yWjdoX8X49LeqJ4sBPlhvco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfZSyC1WCueRxaeFqj9Lol5Xz\n5VwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANgpZVFBmeCLsD7+gn0JaUqlj0sNMB0tjOZPIo3jMpZdAiEAmuxfAY2H\nLEFMj7r3G4PMVDoX52NNzGPAa5C8kLKwZts=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAYGtzawgdHvi82743Zbva24DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTEzZDRmZDktYmJiYS00M2Q3LThmOTItODE0ZDZkYmYzOTUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzNlOGEzNzctMjFjMi00\nOGQ3LWEzMjAtM2MyOTBhOTg4Yjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJJGB3+V5Ss2pCTVh6poZzG2b9N3fQ6plAuoSYRkc4AVbV4gHLUSI12kmrZg1xBeO\n5eSayE9O53nsoh7feFdvD6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUL5DzbL+9VX0OgORO\nDqas/Zgfj5cwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCZWmg+ur0c9gdfF0C1/xG30BlKl5IDUFu9q6yGRr76dwIge5IKt2+7\nc6k2gwYdgKuwnWT3bx/xU/QqEd5HHi4I7YI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4178", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4178` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQkEszB+RaYd0qyBxG3I7No1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxZDM2Njc5LTJmYjgtNGM3Yy1hZjNiLWU4OGI3NTQ1NWRjNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTZiMTMwMjMtM2Y5\nMy00NDhiLTg3YmItNjNkZmNhZWRmM2RjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5YAo+w6Qchi+0Z3LI+Vbxmjar/KSl5j9X187imyknKtSZez23W/ilOAjoX28\nCAi6ICkoTjHHkRZ8jcbeuc47bKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+YTM/DrypVd7ApeN6hpaiN/aI08wHwYDVR0j\nBBgwFoAUZ68LIsNaZCHDTIZvuTxUdJfUFeUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiA9DhM6Lx/HhaGiR1pko3PwCEZiqrkerJZULy2IWn/d\nJgIhAOZz5rCpnRvBVQy5w2eTqiRNnOOjSsx/Ql5eIZtd4B4V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASvnzHKVGlUyaehNz+bAG48aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWQzNjY3OS0yZmI4LTRjN2MtYWYzYi1lODhiNzU0NTVkYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2f44KJE3oAHsar54rfJ1b+50IMBc0siIdAAO2nykZcxIr\nwRcTVOEklrNl3tAzIJ/EDuQ2FGZHSDpiDra+vXTbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ68LIsNaZCHDTIZvuTxUdJfU\nFeUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeBZNFa0A2m2+k69Qucq75Qgr2SltgN2/frNFMCiB1qQCIQCXkppc/Rne\nZ5eScOHgivE8teibH8dABA6Nq5LQDEo9GA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAZccCojmlCOSK2X13H/2tZzPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTZiMTMwMjMtM2Y5My00NDhiLTg3YmItNjNkZmNhZWRmM2RjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWUwZTFlZTUtOTcyMy00\nODJlLWJjNmMtMWE0YWUxMjRmY2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9wMjaWjIMSW2c2/jn2gBm2/QKPlp0exc212U1stcQQ/lH8W1KgQVIh8yPaNpwJ5T\nYhhypvCAZttVBSjbImJzFqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+YTM/DrypVd7ApeN\n6hpaiN/aI08wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIA8R5xmRwcdaLP6k3Ic5ZXWFE6ntjpN1zhMEwWJAetvRAiAO4cJK9a/u\nFWm64YB9m0OJcNfYdIwuhJitsGcoiJnfew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4179", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4179` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAchUqebboDHGTGNq+8AsNzjPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMTI3YzEyLTBmZjEtNDVkYy05MDk3LTQyN2I0NjcwMzQwNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWI3YTZlYTktOTA2\nMC00ZTUxLTlhNDYtMmEzNWNlZDU0ODdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkOH+j46KTYVN8JcxLdXrvTjkloyMOyJgMRK/myjDD4ZtegpR47dIM0waYfxK\njzg/QHySNeX7MqzYVPLvhRo/lqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/HvprA+11Wxsu2/3ulbEdWhvlWgwHwYDVR0j\nBBgwFoAU/O04MaqgfGfsVAkPIvxXvW2UKOAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBFLWXs70KclYUHHXvHymZIXjsHi1mAESMOEmtuIXLW\n/QIgReZ9LLRaoOnKCs1vARpYYt/92IfxaxrLvONsol5Osz8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZDqB4UbS+yPcnmqeXFHzRmjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzEyN2MxMi0wZmYxLTQ1ZGMtOTA5Ny00MjdiNDY3MDM0MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd9Th6BUUMYzvdoGgNlwFYt8n0/TDX+ldir8/915Htusms\nV1mgT3L26lhsM3JK2LLMqteo8k5fLxRqJX7jG2IZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/O04MaqgfGfsVAkPIvxXvW2U\nKOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIA57sa7Rne3akILxSknevjE+ADP2mNGkNkBabQ+OWLYCIQCm9VKooNZA\nnxAubVmbLgiB/1w84D62Ifsiy1maKlScpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAYAAULoKGMUDhtkfc/tuY5tkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWI3YTZlYTktOTA2MC00ZTUxLTlhNDYtMmEzNWNlZDU0ODdkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjc1YTY1ZDMtYzM5Yy00\nMDYwLTlmMDItMGI0NzQwNjQwZjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAzIpJOeEiqVui0bXEbrBGuceTyuqcmHK8NdyAA3PEbsdp9jgscbq3BxwVloe1PFy\n3tUqSnHIs6H19IExvEoiwaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/HvprA+11Wxsu2/3\nulbEdWhvlWgwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIFiZ5gWZvgd0yYK5z64jr2sOUCa4ry5tpW87O3oNJMNzAiAO7hbqx4KR\n1J0nIcefTkwO0pYRELNsJrhhc18Yp36Yhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4180", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4180` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQ7/TbOI5kvfqGcEM3h/vj+yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3OTA1Y2M1LWE3OTQtNGM5NS1iMWExLTM1YzcyZjRjNDdjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBkMzUyMTMtN2Iz\nNi00ZTBmLTg2MmMtNDY0YWFiNzBmNWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz7OOaV0PED2G1vmRHXCeAYwzQBzmF9vB0BWkq1l75uQk5Smb2Oe7HIqY5MnQ\n8fYgV9TgTnwU90RTjAeJaeU6K6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOvIt3BdAeMSNnqpSF+el39kC2RAwHwYDVR0j\nBBgwFoAUxF7g85Yf9Fvt59niM3P1FDUjiw0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA2asUKRmD60ZxYSe9h8sKHtoiEgsodp6b529ed20CLDQIhANgO\nN83HFw1Q5dBwE9vyv9DvnXL5dsok1cYIo8apSTbu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY/472tXl7zPUdO8ClDrNHc7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzkwNWNjNS1hNzk0LTRjOTUtYjFhMS0zNWM3MmY0YzQ3YzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTW3CEuyNnrHbSzfmL7CHrdfwD79tNZ684ldyMWuL7yi1Q\nUYiIVXnM0PIfwx3DtBFamb4ZsfY404jBl5uJ+x3Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxF7g85Yf9Fvt59niM3P1FDUj\niw0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHrK9hFL6a0jdyEl58FAxuXePDcT20aRf74mKtOApKgcCIQDTnJP+6lPz\n2XgQAwEXDa6y6rCMcATVFp8E69Yo7vdQLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAdl6kWmslzuqy1emgrv5JahqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBkMzUyMTMtN2IzNi00ZTBmLTg2MmMtNDY0YWFiNzBmNWEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWYxOTk5N2UtNDMwOC00\nNjBhLTgyYWYtOWM5YWM1MzI3ZmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqyGU8M+J2wApZAi8nN6zYXRWhMwskCJYunaU4RDzE6gGu9WNtzxj8bIRSsdD20sM\napaQ7qCv0xiYqkiDxoi1gKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOvIt3BdAeMSNnqpS\nF+el39kC2RAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCbDT4lfGsw8yQh64nCfI4dcFGqF6RhNQ73R1VM1V4QJAIhAJ1fViNw\ncRUyWnhpESxGzhOBv2RizvsLiLs6P0vZxJSx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4181", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4181` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAUtqNEjgTkkwn0uo0LPU2OkEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2Yzg3ZDU1LTBiOWEtNDQ0NS05YWIzLTUxMmQxMDUzYTM2YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGI1MmYwNGUtZjlh\nZS00YWZiLTgxZjEtMGU4ZDZkN2Q2YTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKtIXrdXHKxOezThJFr7F+Lh0Frq77MU1wqLLrBFhlxf3wZ0BzpTsy21x0sXp\n5WuIrpmhdgOl4E6bB0T6xObuuqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqxBFOUqczAHmnJhMJy4LxhWH8eswHwYDVR0j\nBBgwFoAUBa71lm+/SgbtD8iIKMq4gjQuXhYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA+kAP6T/dU5/ODUvZUKqE2RnlKrYBvk/v\nUNfwzdNa2ngCIQCz3GZaP0942PBzymq8QYjfDUdQZ65KakgEEX/wx7Csuw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbw3xcZaszmc3LX4mvATztkxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNmM4N2Q1NS0wYjlhLTQ0NDUtOWFiMy01MTJkMTA1M2EzNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREaIRj9MSHAA4JyNKoqqf4sN64W7cxktUdCbJh1YSClsOb\ni8Si1ks+7lL0l7bbSXaMLM0cmJE5M6JiWn3lBkdyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBa71lm+/SgbtD8iIKMq4gjQu\nXhYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGwYS2sQyGFw2v1AWMlKHmEQxqFgiX/zDKVucHX8a+n8CIFbwsEJJH/qt\nARd024+8rz5727BEYLZM5NXVmufJ7PFv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAXpTel6AE1TGeU/DL6QxXkxcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGI1MmYwNGUtZjlhZS00YWZiLTgxZjEtMGU4ZDZkN2Q2YTRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTE2MzhjMzYtZWFiMy00\nMjA5LTk1YWYtY2E1YWVjNjY3MmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndVku8nAgAOQW4pV6FyYQJLW4THLwP4Eim+oRl5m06Dec4vrnaGUAW1XkEp79v0Oj\nH2NsAUhXYYGhP8vmnuxc3KNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqxBFOUqczAHmnJhM\nJy4LxhWH8eswGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQC4zUsQffGq1RhQs+U/XwmOT5liYGGMyKQ9J3VVGkx16gIgMAo9plKm\n7cD5SWA7vA1fObBORr3oAdiihKD9iQ7GhHI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4182", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4182` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAT+iOPKOGpoBwPt4lMjqP1/FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjYWZiM2E2LTA1ZDgtNDVhNi04YzNhLTZiMTQwOWMzZjk4ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYwN2YzOWItYTQz\nNy00MjYwLWExN2MtZDM2OGY2ZTllZmJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsJ2U23GuswmL1J321/ncG5OETID9gqIKit3ahnNpEBVklRWbzUvjn38DbalD\nD1OVmoprtiwqKDrSDaLZF3ctlqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURMHu4WcKDWBN6w4N33+6wN6I3VAwHwYDVR0j\nBBgwFoAUhmj9qr0hHGto0zzLVa97OSV58fowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAs9i5GDtXhi9LsU5mP4w4EivKMMdgGVJ6\niVBGOdd3FywCIG62Bj2P2X1KfhgbcQjnK1f+wIvWb4KxBtP0hH7bCgXK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVL+Zo73cnKrbksbhLn9YiVeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2FmYjNhNi0wNWQ4LTQ1YTYtOGMzYS02YjE0MDljM2Y5ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGvHw59Ycd8CSp+vupo4XJXVKQ2cWPHU2eOmkxioB3O6UR\nMbjIz1E0MLC38u4DBHLL1v/D+z5+FwLcByQe6pefo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmj9qr0hHGto0zzLVa97OSV5\n8fowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAMzejpxZXzQQ0j0+h9M5p22gqh+6qSwWqawSX14BYxq5Ah9L4W7ltB2W\nMKIJzT+jTaCKrzO5J18YdJXD8ydy7puT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAe/HZ44GfDWFxoe2msa/cZ1LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYwN2YzOWItYTQzNy00MjYwLWExN2MtZDM2OGY2ZTllZmJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzc0NDhlM2EtOGJkNy00\nYzhiLWI4MDItMjdiMjgwNTA1ZjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFqi/K65znC7hS2cOO4h7nBTdkb3szBt5YCgInTtWRGaHMzXcAd9k4ogFnL5sO4oO\nE5xRCCdJx9ACQ2/fEsgduaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURMHu4WcKDWBN6w4N\n33+6wN6I3VAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIHovJ7+GMDYFvZmPf2J7fJELhPKoc9gWnJs4blBPXriAAiBSAbpllcqi\nmfZd0GGhMYXTGiv9it1Cu44xxWrCySVkSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4183", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4183` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAU5S22TFzTvjPM+jwUUpInJzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2ODQ2ZTg5LTBlMjktNDk4YS1hNDNlLTcyNjE3NWViNmYwYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM4NDA1ZjgtNTQz\nNC00NWUyLWFkNDAtZjJmMjFmNzQ5ZGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6nm9AgBU8/mnXw1x/Q8NzAtNjLdegfOohCN5BVjfDrqSnUsd4DiRq/l9clqV\n01G0BrmWws0uzmkmYXcM+REWMqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdAPtKp1+UWNy2moEfuhrqu3xDFIwHwYDVR0j\nBBgwFoAUEfIT5w6y6fZcT2zYo9EaDwepKOgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAuMMyGtB4hL5l\nHfKZVpFOJoWYV8Qxjr/weDj7WpF2sVkCICx5ksK/cKQSzNtb8mmjp5CdixEc+A5S\nBxe2zQ4CQz0A\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaJlI1PnFyKXP0ZTuF3Q5E52MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjg0NmU4OS0wZTI5LTQ5OGEtYTQzZS03MjYxNzVlYjZmMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmmr9cPrk+RlrqpTmSEoVnvkt8F1uqCGMGlSveJWhtV9ut\n/keuMxBdRXLdEW7nby1dRai2c2cQ3MDdH564VcRHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEfIT5w6y6fZcT2zYo9EaDwep\nKOgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWA/F3ijXDsOW6WK+uhX0XctPAjoK6ab5nY5mCTs53sMCIHiCtHuxLZyJ\nIjDCAZX69ip1lRGhK95iJ+Csx0GTnibM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAZCeT5HP8JJM8nI3VzCz1X6SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM4NDA1ZjgtNTQzNC00NWUyLWFkNDAtZjJmMjFmNzQ5ZGNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWE0YzNlNzYtODBmYS00\nYzU5LWFkNzMtZTVlNWEyMTliYzFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrvJgIyQnS1CZEu5E/poTEFi9Hr+pUOD18AHApwKKlSSVAnmowHl7aIKzOxSYUYxJ\nYBzLbDEGkiuEUGvMBMVinqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdAPtKp1+UWNy2moE\nfuhrqu3xDFIwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQD4Psckzo/zP595z67h7zPGz2uwtXGLacpC87EUoqfO9AIhANqS0X3A\napR5BmYBp4TWhr/mR86Qn7lgJpgjCfjg3Aht\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4184", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4184` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfkAA5m/FLcwSQ6v6HueApqSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNWQ1NTUzLTA1MDctNGFlZi1hNGQ5LTgwNTMyNjlhMDIzMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I0YzFhYmQtYjkz\nYS00NjU0LWExMGUtM2RkZThjNjE4ZjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoH8dejtAVHVYCj4EmsHSSfn1wL6ccC9RT09ybH/spDnrANkvlMgxW2LcHVgG\nCvsl0gdkAPOuupgAJXuEhtwW4qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7UyNw30CMypel0dZmxyLi59u+AIwHwYDVR0j\nBBgwFoAUU/9nOpMLdImEJSh2ijuCuOSsfSUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIH6wgzGlVhNOBT49ZWDNec8YOH4YnAjTMKk8J61yDJ5oAiBbcFLY5kp1QUaY\nFLFg31BSUEr/rS/2JWOdTOWO5gjkcg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe4vlBI182eDLslKgJZbB85ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTVkNTU1My0wNTA3LTRhZWYtYTRkOS04MDUzMjY5YTAyMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQD4XUjVrtTQZtZH8OHtff+tgjS4CYfevIrQhzGdZIJchD3\nWn+OImnJd3DbrPhdxvGFhhLzSF5fWuJBfE0NC/fpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU/9nOpMLdImEJSh2ijuCuOSs\nfSUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIJdsxapXiGczKC8PKgrJBQxSntKKlxO4B9yQHCKs0aqAiBeiicFsl+I\n/wZVwvc5nWOU4U+dkc0/TBEvg/QqGjaaWA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAfhmbe7C2KVJqeI+dQae+MtcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I0YzFhYmQtYjkzYS00NjU0LWExMGUtM2RkZThjNjE4ZjlmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2M5MGJiYWItMjllNi00\nZjY4LWJlOTAtOGMzODFkYWU5OTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwAfjxYImWUzJySAZeVUbPsry6B5ZgklSpYeKnv0iRzEY0YnaZBhUxL48ksS2x/md\n1PmzdUZUA/H/kx9lRkDOAKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7UyNw30CMypel0dZ\nmxyLi59u+AIwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDOAt4gyV8pK2VXCh7oHnBN7QqxyOlhop9qpEGZs4FxIgIgVl4DjWc/\nm7IF/M2xOP3zDSMaaUj7curXohHkbXInq58=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4185", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4185` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZmz0qp64Vbrg1/bcg/7a3JUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzZjlhYmQyLTM5MGItNGIyMy1hY2YyLWRlZGUyZTYzZjMwNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNkNTkzNjEtNDk0\nMi00YjU5LWFhNjItMGQ3ZWQyMWQ5NGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGVw6+nAMvLduHGwb8BSNWEPsugJBQPo6wxKKaKwhRdITEbpCYFxtI5uUQFnw\npuJX8f/vBNGTGrFjdYTuW5LOrKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR90MBXLogo9JDcY9UOXr2socDnEwHwYDVR0j\nBBgwFoAU28vh6sEFz2kGqHb1If1YOHz9lIswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCACJ2wf5O23gRfjtKfsf0gW0oo7bGPrxT6SQLP5C9MpwIhAL2iJ3LEVD1I\nJ59MW3uQ9ptvYT3kbABzFxvmMORpxrSn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU+w4tpXF99X1nLqKlbBCezyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2Y5YWJkMi0zOTBiLTRiMjMtYWNmMi1kZWRlMmU2M2YzMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATle9nKzuFXzVxXgVxifVH/V3ysEgetZVTNDQxJPq5WfK6+\nwafAztqPba1g589/rb6KZS64b94CFv3Kzg4+UHTho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU28vh6sEFz2kGqHb1If1YOHz9\nlIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKDOtS3qOvVDtuPAuufm6MNzCeDZZ4fin+zKR0+NzCnJAiABWTycX3B+\nKQJUj29gl/K+7GogejIdMNTW0Il5POwszQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISASIpHQlyfxojATBkQ7nXJkdtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNkNTkzNjEtNDk0Mi00YjU5LWFhNjItMGQ3ZWQyMWQ5NGRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjYyMzQ3YzMtZjkzZi00\nZDViLWE0OTctMjg4OGIyYzE0MjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+SPLoJJzecO8QfEZOrRnrJJZQjKGLRLyjdhlmma4OJbhyyJJm0eLgybt9i8pue1g\ns1VDTBEaeeEgpAAIFSYFAqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUR90MBXLogo9JDcY9\nUOXr2socDnEwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIDyIQ2YX5JQftXC991WHhgR9/wepWxUf87VIh2jA/T8UAiEAwKVdm7nw\nfexfbL8ty7Q8DvcmKgpAsmCVxHk83RbTkWg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4186", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4186` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAcRLE5VJsHqKOAP42E1fqlNCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1MmE2ZjAyLTg2ZmMtNDI2Yi04OWM0LTA5MjY3NDBhMjBmNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjYxMmZmMjQtZTNk\nMS00NjRiLWJhMDgtODU0NTM5ZWZkZWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiCadKCWq8TPrIHcLYG/w9ziI5tjpFFLtJO9O0Mner7n5LmMXAT1uvql8J+LE\nRzZeXFwN63UN4RXj2Y7dP3plj6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS3ZwO30T7pkY8tC3GZk0/a51tdMwHwYDVR0j\nBBgwFoAUAJX4ocu57aDrnmMdzO4H344GbZQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAicPwkezAyxhDogdranUTWZc4797k8h3ZgWzS7qRgWa8CIQCc5xfaeiWf\nLfczvT9B+BBIL0NyIPVGKck0r7n2EgeCYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAemCXDkRR6uMLlOKdbq4ASgnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTJhNmYwMi04NmZjLTQyNmItODljNC0wOTI2NzQwYTIwZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ72Y6qUsLJ9MoU8DMDRcw1pGbhaweZzyFuG6PMBEUzWbe4\nBa9l9x51XkzuuBtLr2lm4WbSVEaA94ZL6bLwrofho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAJX4ocu57aDrnmMdzO4H344G\nbZQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPOJdSc9AkM7dzMsp3Y4QnWWyqQ4+Dts73IZR4Er7JgDAiB+tg01gYZS\ne3URbJvhN5joa5kbJyaiYq4lq76YRQD7Sw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISATUWBWpOlAEC1NZWVARQ+AKQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjYxMmZmMjQtZTNkMS00NjRiLWJhMDgtODU0NTM5ZWZkZWU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzlkNjJmZGYtMzMyOC00\nZDI4LTk3NjUtZDg2NTk5NWMzNGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKL9dSd/qWQ9WGsW9bEO86cAbxzkpSWSRIFaq3kmf0GeuQwOynZiQEv0pk0GrwC7K\nqQ4hyIfZ2jsMj75dxk0Ua6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUS3ZwO30T7pkY8tC3\nGZk0/a51tdMwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIHA2nlvvZq0QnFWVI+AifatRvj2VLSFbfCNM1hBntQHBAiAzv9uC8d7l\nXwHu5N9RrhMwf2OH7VssgemuZ+q9N7KHGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4187", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4187` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAcF90kv1tKtOONQuwrIGxLTMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3NjgxODE1LTBhMjctNGEyOS1iM2RmLTU0OGQ4M2UyZTI1ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA1MjBhZmQtM2Q4\nMS00OTUwLThhZGItYzk5MmYxNTJiZmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVGvlD/1642z/gaqF/27a2Qovh0gu57mcV97Uzb8MkAgSI/sPqOaMkJjbwvxG\nPqZGdpf7vOmckitZMmDn+OolmKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZl+WY9dcj9GG/2wzuVIHRa+vlNEwHwYDVR0j\nBBgwFoAUT5ty2R/5QIRZq0/ADWla06FRUikwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBJZrkIJAgb44Hre46U8DikMLobW+U3hk7plEKF2qP3\npQIgJI1EyUfhWnWepBtMuqGovQlq2qBy/Q93vZ1R2+iEDJg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV5Z1poGtLbLIJoYosccVRY3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzY4MTgxNS0wYTI3LTRhMjktYjNkZi01NDhkODNlMmUyNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdjADJGfScM/eXGPDZys9Pctgjgvwkc6SckgLRLlQkn+jg\nOocJ0wMRIbePg59YJMkyC/6pbyo2OnmJ9v/+Gh05o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT5ty2R/5QIRZq0/ADWla06FR\nUikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM7ULg7iOenk7gX/XizajJfzUw+m0Udi2x0E9mRPnVbcCIQDv4MobeN+f\nhQwmcCFDWMSs/eNrHd8RsPEhhBQuoQE6+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAaB58z7XoVOrOcZM+9Kgg4vHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA1MjBhZmQtM2Q4MS00OTUwLThhZGItYzk5MmYxNTJiZmYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzhjZjFhY2EtMWUxOC00\nNmJlLWE4ZjktZjVmYzFkY2VkNTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWFlzRXLcJbtW2nN4V5rsEb2ny77CGthS5rUBxEQ/z63RYRWu4qu+IoJI+0jurWY5\nGg71aJjfwgY85o1q6sF79KNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZl+WY9dcj9GG/2wz\nuVIHRa+vlNEwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIF9vnipRTOkDMK8IY7aneyXQRnU4pDTEfuN/KBnNED60AiA263uEAdnj\n5r+kBo2bflHygBGpffvJBQ8dHH5zDHptzw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4188", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4188` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUDMsJlO63teKyNfO44VNpStMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4OTRjZDdhLTBiYmEtNGVjNS05ZGI2LTZmNDM3MDcyN2UwMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA5NDBlOTUtOWU2\nZS00YTdiLTg1Y2YtNThjZDkxZDNlM2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVT96GSIBcnsppyRsR9cmGVcKk5qbWklgAR5NG8Sbcs5ygLHFwo6WxeiTfFqq\nWj0DBEi807pB/Yz95Sf7oB2EXqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8ySYkPUZwCNWkihXjKgCjraFk50wHwYDVR0j\nBBgwFoAUpkZ4idlB5nPhT2F6Tz9uRzdrnskwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAfOkbuawiY5jOLHGPWr0/nU5tjHvz5XYoppJpBk4A9\ntwIhALAV4uUFK0hmSN2UtFxBO99PdqCcp7seY0JY1yz4d3L3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbJNtqyfZ2Lo2g0VeAZnLEuCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODk0Y2Q3YS0wYmJhLTRlYzUtOWRiNi02ZjQzNzA3MjdlMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUrFIh/lH2IbCehCP1XsQ5+pPbswXXq7KMCblR6wchLDql\nr0jZ4O25CD+nICQL1/ynuRRMlv3XS0uK9Z9/PDk7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpkZ4idlB5nPhT2F6Tz9uRzdr\nnskwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM6yDX4gl4ZJBfP/aJGabQBAFkqo7U7k2H1Dpa1T6gs0CIQD0R5eyd3mt\nFG4MWk6FBUtlPMCJ2sSNC+lEjP2omZZJeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISASzMjd82L9qRezmcenzNXjEDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA5NDBlOTUtOWU2ZS00YTdiLTg1Y2YtNThjZDkxZDNlM2YyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTEzNTUwOTItOTJkOS00\nOGJhLWI4MzktMWEyZmY3MDhiMGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noe+JfUdGy1SwGYZKtZElFAe5Itz3xs33dN2IM9IHwg48I9FVx+h6KlGcd/mh2vgD\njQAJ6npj62kyoQFuUy/5raNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8ySYkPUZwCNWkihX\njKgCjraFk50wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIF57//4y+ZXfWPNafquDHA9gP7zEoUZsc0bMTzK4JL1kAiBJaZwjQqxi\nEEG0nwh5zLdYaKWtFE7ayznrjIzrZ8vVEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4189", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4189` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQqpc6xAse4D28PlKgPHB5FrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmZWFkNjBlLWI0NDUtNGMwMy1hZTYzLTFjYTA0N2QxNjYxZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJlMWY1ODgtNmFk\nNC00ODkwLTg1YmItMjI2MWUxOGM2ZWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXK5Nm+o4/ldcbe0IRqqfUvJyxR+Eld6T+eO9+KANHIWA5iFqt2t5Zeip8Pms\nsZ74W1VFohcp9Up90f8aqs49rKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKSrBJk/YazPcQG8Tbl7ULV8xARUwHwYDVR0j\nBBgwFoAUW3yrJADShw/UBm5rC4keRvn8/5EwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA5lYgU1MWRAksCtZL9Ox1W2v87vbEjbZMw9Ml9EUEknAIhAL2T\n+McG7WzJDbpH3QN8ZHfyvvun8GQyovb6B6B2s8Ks\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZcN0m1oMuczO1i2ir83SNEDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmVhZDYwZS1iNDQ1LTRjMDMtYWU2My0xY2EwNDdkMTY2MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQnJmHFRj5msOnYaZDqt6FcY6CY+YmPobl2cPOWOwuyJ5Y\nMEWUVqf/LcxAb3vNuaky2DoB7zx3akUGziU8Lpb5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW3yrJADShw/UBm5rC4keRvn8\n/5EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPEf7hwNowfKd7h5LLwq7rK/NHIvmRKIC95/AjXSms68AiBSeLE5Cu3O\nWPzXVv30ppTa7DpZ8yGx3D5RNUqLxHJTBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISARUw7PpfPZ3Mm9bjeEchvsnZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJlMWY1ODgtNmFkNC00ODkwLTg1YmItMjI2MWUxOGM2ZWQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWNiMDhjNjItM2E4Zi00\nZWI4LTljNzItNmQwMDA0YjE4YWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4/wqKj6wVkIRr6veIxzvlT+aFIgHtt2T3IYhh7UEeLWwH9EFpBz0DKbYVACniZKt\no9nzUQzY2rsu9ALpjLLmlKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKSrBJk/YazPcQG8T\nbl7ULV8xARUwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCID38BRm+O/CPTRvrME2001xCQ/kBHTe0rck50T2S1vgbAiB4elhPg/rM\nM9DnkIpqV8tTNWLLTK9+ImFODobC63bLJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4190", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4190` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXWP51KrtrhL9KPA0+ZN6EipMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhYTYwM2IyLWE1NmMtNDAwMi1iZTljLWYyMDQ2MTU1ZGM5YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYzMDIyNzMtOGE5\nYy00MDhmLThhM2ItMDEzODUyMjMwMGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdJrRu9wEho3tFJ9Ji78bUIEj+JDaZ1VhD8+nJcZaFxfcLISKeFAUqFmQ+Xf1\nul3GIZajeuGrMftA7+6JhUp8+KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1vLpimssW9qhNomDi6qm2CgKIOgwHwYDVR0j\nBBgwFoAUrlQX+7h9wNjbS36xHRaDDL6R2gcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAWRt6bBRoJA7ZU2GgAE0j735vlOhwFk3Zv\nrpzxFut0RAIhAJjNMyFjOI3Lg5ep8AcyREshAS9nwJaZ1nX1WKAYqHEe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa9WZOTZMQhUv/cp6AJWXU8xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWE2MDNiMi1hNTZjLTQwMDItYmU5Yy1mMjA0NjE1NWRjOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnE0KeHflE/5xgVA97AzEt+K3MwSbxcoqlzjSiwWllZ+1u\nxOCqmjmKqwPMbhcdqBweeTMUlfb9sqBX+/wjws0jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrlQX+7h9wNjbS36xHRaDDL6R\n2gcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPaqxgB3mXmr/zHiQdzAapQUbJhTcHnwfSrFGO+LWcLDAiEA+aAxUrun\nLIhlYYY3AEYympYqX25rooHYsy7cIJtpx2I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISASDLgh/HCwVnFKZbr8wsjFIdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYzMDIyNzMtOGE5Yy00MDhmLThhM2ItMDEzODUyMjMwMGNiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Y5YmE5NWYtZDg2NC00\nYTI3LTlmOWUtY2VlNDkzYjc4Y2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDTyp61txNH0wHZatd/Qzce11eM1CYSzO0XVNifZeG/jx+hgWZWtXIeTl1C5/PkbK\n4t1+vX+WcQAkcRViVeidkaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1vLpimssW9qhNomD\ni6qm2CgKIOgwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQD/Hfs6YRpqu7r90vmGiWcx1K3fIF1uJ5Tdp+DX+4iRQwIgBsNJA9Eq\nmt3LShIdEklLTK4UDEsotBxXNLJr+cnsrj8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4191", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4191` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARd9x+ytmwf2AqoxjFZO8QF1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkZmJlMmZkLWJhOGUtNDQxNi1iYjU2LTdmMDZhM2I2YzY0OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRjODUwNjYtMjg3\nYi00OGU5LTg3MzAtNGM0MjJiZjI3NzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtysKfD0rtALbB1yQ16PhqwzKyR2Srg0FEfnzZr09TbWspk2MxhUYYNm4+Kz7\nipanEiC2pKOKkvEdtrbLtao/4KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxj0Dj43hQTJ84sM0zC9mKeX2JOowHwYDVR0j\nBBgwFoAUShCYk9DS8+WoyaPitJfK2s5qyIIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBxXVb3XhkeaSftDKK217R9ZNivRCAss3Pk\nZ5u2znGuKwIhAL166WIvIZicYaZvL3W9mQqIAQtwFjT54a7OdW3S46hJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYvWsSyxs/lPjY1Gb+LpE5j2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGZiZTJmZC1iYThlLTQ0MTYtYmI1Ni03ZjA2YTNiNmM2NDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ57OB2Ztd5ALMep97W/Fo7J++85gPNN1VwcRSikMAoRzLS\n/KyItzqGBbFhWesdMIXjSNO8AySiara4fYtfwJXio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUShCYk9DS8+WoyaPitJfK2s5q\nyIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIvsouLNv032MJe+tERA4KKUYiaNQMs6xNkE5q54JPDgCIF26XquDSSzi\nGBeALXl6eaeamtQLYnfgQjieW/2eNvQL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAf79zv/SKzE1ANRAk1sUWoHLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRjODUwNjYtMjg3Yi00OGU5LTg3MzAtNGM0MjJiZjI3NzU5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDBhNWNiMjctYTgyOS00\nMWMyLThlYzQtZDBkYmY1MWVjM2U2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLXOf5kmurav8Qi0svvOrJN2vEDbq8jZBUnWSVwXYF1p280Oa50DjC/GSECzGSsbE\nu+dwBToPtXzeXuU5z8mKgqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxj0Dj43hQTJ84sM0\nzC9mKeX2JOowGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCucFALkCZjg4lMsDV8jtIsSOP6ZNyzgz5zDE1iHYasggIgX+vXSF/g\nnllDKw1nEubUsSz26HZTybgI/EOKwnoEbEk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4192", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4192` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAbfSYuvZtAn8G0PE+fxfe1WiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjZThkM2JmLTg3MzAtNGI1Ni04MDA1LTU2ZGRhNTE0MWZlZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRiNjVlNzktZTdi\nZC00MzY3LTllZmUtODIyZjU3MjIzZDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErbae1c2IRsgnEnOu5IFDZL8GSc1lKKuaL3LjjfDS5w0Y7FQ4dYxPmZqfVzJ7\nmOKGKkYLR0nsJAvtt1k+Aoug16OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURRtz22cjkVJniVMu9V7CNXeGv8cwHwYDVR0j\nBBgwFoAUvRd1P2VTMntiRoHwxIwdEt1KoQ4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCID47BjxgtNIQyg8LjsjNcxuLAe+1\nVYZX5J8g4C8e3VT9AiAVd6PiOvff4LMXZeXeoqkeITPGnOb6gNZ6een7Xs87eA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARwRPnle0FIH1t4TiwRtxb0dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2U4ZDNiZi04NzMwLTRiNTYtODAwNS01NmRkYTUxNDFmZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFrzQf7+hBF00+iH8l3xf3Ow12XEeZEbf1a7nD4XYvPJG6\n0Rf+L44qaquR3B1qh+3Xr9nhEucI/Ke9YnNQ4DGOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvRd1P2VTMntiRoHwxIwdEt1K\noQ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZTHffYQr4SqnVpdmNHeE5LZ2F3zMWxVWJMkXTpTfyfUCIHN4DNX6Mhwb\nOJmxArASblDd3WCgUl6E8cXKzzsjDVIT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAW7Md9nIJjnuSofZhiPdviUdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRiNjVlNzktZTdiZC00MzY3LTllZmUtODIyZjU3MjIzZDg2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTNjYmQ2NDMtMzQ1NC00\nYTYxLWJhZmItZjdlNjYyZGUxNThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nay+TuwhtVNO9u0SbnZLPm5hyi4vZDzFtmlQxKUSG3PBhV3M5HYLzU0IoDe/oAN8f\nBqHN5dl8U3kHO3uY8JZ3GqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURRtz22cjkVJniVMu\n9V7CNXeGv8cwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIG0bIcHj6OxTCX4c5xvI6qQVZtP78GbU7H4eRirvSchdAiBTyAEur8Kh\ne60YBiX3cTwO1W5Qx020qUy561Ew/P0vqg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4193", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4193` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAT9GroCLbYKMQfs8n2iISVUfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1OTU1OWJlLTQxMzEtNGE4MC1hNmQ2LWExOTk2YWU1OTgzNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk0ZTc2MmYtOWI0\nZC00YTZiLWE3YTItMzQ0NjM0MTM3NGNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0u4z+aALTMNNuIlAiW78B2tluLXxQr5b1+BF9K72oulJOTUEmUmNQxMXkPta\nWNZtJDN8AnA34GKtUm372WZIkaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmtXRIdmyJ6ErGDHw31rcprbuzLIwHwYDVR0j\nBBgwFoAUZJ0LhUVTSV+joOIAm4WfeoDVm9MwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMkqMlST\nbjPleAk51qjW/51w4LYO+CxiYblTCzp0fPIXAiEAqAoBUTRqLBqYIG9livwgmEsB\nlAt7NyYCwH0DTv3VYGY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQIDvM+JvcwN1y+d8JOgJ4DeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTk1NTliZS00MTMxLTRhODAtYTZkNi1hMTk5NmFlNTk4MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS44yY0ohdORDLA3woPkG+KG8V5/l7KcQ5AKNxVjIXuxZ43\n4kmAVHx5wjLNI6xA1+O/HtJAvljhXtx+OpVc3Gxmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZJ0LhUVTSV+joOIAm4WfeoDV\nm9MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPaRalYamM9lCVBc45SuEdikUwIgTswl5YwjKobZxbFcCIF64XblP0qHv\nPo7thRFji1899s8Q6CXH2mKhfXMN/ylr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAUj4vx/7X8GxOsy24vjokDElMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk0ZTc2MmYtOWI0ZC00YTZiLWE3YTItMzQ0NjM0MTM3NGNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTQxY2NmMzAtN2JmMS00\nY2U2LThmZDMtNzJlOTg3YzUyZWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0qwEiQHmiWhoW0ilErlyWWoekAHSJjObHBq4hDzOv1mAGTpgFbeIF7GhFHhJj/yz\ned4W6EChqoR4s0uH5mEF/6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmtXRIdmyJ6ErGDHw\n31rcprbuzLIwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIBtaHk20jKgCUpX3nQbzZhCMya2gr7uIcekfJwp/6wcsAiEAr4uOgUAk\nUQIY0UIINA6hhtShPnZjm3/YuCAxMA7Xvgs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4194", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4194` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAVHcayhM06v25nOQHm8n6j+sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhMGQ0MTY5LWIyNjYtNDllNi1hMmFhLTZlMGNhNGRlOWNkZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc5MTYyZTktZDMz\nZS00MjAzLWI5NmMtY2Q1ZjdhODRmZGVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgXp0gSmOzSoZ5ETiZP2OYIcTGdVvj4wmNzdtDf6/PjYyiqopEXtXaUzp0KOV\nC8r1l4HCa0Mpz3+0JtYVnFx9UKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9HBD1b5hyQ7xeAUSAOSy4ai/71cwHwYDVR0j\nBBgwFoAU6IpscpesgmnBsn47xig0MossjDAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgRIrN343U\nOxXaZqiRMXe1mhg/VingMaLDB1JfaMI5g/UCIG9+bfMtSM+YtKqFBJxAwF6E4gZr\nyXnHytHP/RHhYp8Y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaA87dcY4pFEhrnjQToFNOP2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTBkNDE2OS1iMjY2LTQ5ZTYtYTJhYS02ZTBjYTRkZTljZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASA/s5vxk6LFiF2wIdZwuVi4ZJWVPjUZKU/6l8UYatPgyDX\nVSr+fb7lejma8+a4byQVPvQALppAcpqCztSVv1cEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6IpscpesgmnBsn47xig0Moss\njDAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRoKb0t587yjCeN9ESdMo65uCbWrbrsmp0wd5aWRgJDQCIEwc8xYlHwc4\ncpgsKxO1kWxxxG0DSZY5d9xt/bYzAAsq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAfiB4q0/TzxHiwXwkoHi1DaSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc5MTYyZTktZDMzZS00MjAzLWI5NmMtY2Q1ZjdhODRmZGVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGNhN2Q3NzAtYmQzZC00\nYzExLTkzMDUtYmEzYzY0YzAyNmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPxarCKASl9fJUscbF8aJcehfTH4o/L19Lr0Gj9l5Tf1N9xMtUNLnhCTcubvuGEsX\njjptkyFF12+fpJKf5Nlu16NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9HBD1b5hyQ7xeAUS\nAOSy4ai/71cwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIGrfwIGXnj/ReLnKwas/7dcqPyIdaOlN+/oQ+C8Bms/GAiEA24dVSKM7\n8Qc2LbegrjtIixxWH+HKcJf342CV+nOJtFM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4195", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4195` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAbP4SC3J62QfvnSmjCTDomtIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NzljNDc4LTlmYTYtNGQ4Yy04Zjk4LWRhNGJkZTI4MGI0YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFmMmQzNzktZTA2\nNi00NTQwLThmNTctMjY4ZjNhZTBiMTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpu361FPwmoeG90Y0BbPGq4lS1P19LZcpcNtaJsfg5j1mX2yfD2H86SMBPuY7\nYT7YeiDR+LS/A6LruUdjZrZXFqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNBWAy+Ne11L4hxnneE4jqv+6QG4wHwYDVR0j\nBBgwFoAUML1pZWh4oGJYLNXsrrA0xkP3rIEwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCX7NDs\nNMGP6Tbkdal1xgVPszgjQY9P0TSw8Eyu36EhKQIgefXD6unyzDWHnJGr+6yjBOoS\nhYqx7CkJ+poBt5Vb1x8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfQbx/eFFpbdzYh4tIYwOHXsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTc5YzQ3OC05ZmE2LTRkOGMtOGY5OC1kYTRiZGUyODBiNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHbrD8OCfmm4xnpnYDAYQxmMxRAwEFZcZJghOeeI8K97AF\nSa9hmLIu5U8fPax664pYrwdyg1Y9SiyxmNDluIUEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUML1pZWh4oGJYLNXsrrA0xkP3\nrIEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVn9022QZy7330FBzuc9YUUZINAj6iFbDgx6ZCyEg6BACIQC5qmX1a3V9\nY7bsQOtkhtGaTGhYqf+Dz5Gugc94upIQ5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAfhL43ercTmE+XckySprdlM/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFmMmQzNzktZTA2Ni00NTQwLThmNTctMjY4ZjNhZTBiMTRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTkzZWVlMGItYTQ1MS00\nNDZiLTlkNTQtZTM1ZTg1Nzk3YmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nG0niftfigORuEqHYdlSHibFtWCp7OP93s/DMlXz8lDGcZVXw6HSstoTFauNlWgio\ntAXSY7k4RAKnq15nINWPsaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNBWAy+Ne11L4hxnn\neE4jqv+6QG4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCICWW8ScskzF/m4VIeaL4SZt8Wl05OIwgQ/dTwtuajhBDAiArasEC25Jh\n/BxBe4DQBHZR+QFBjh1BEW2t3qHXlLWACA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4196", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4196` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAbZ4Iv69Njy6BkKSqAXAbQe/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYTFiMTc0LTM2NjItNGZmNC1hODlhLTY5NDI4ZDU5OGUzMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUwNTdjMDItMDRl\nMi00YzY1LTk2ODAtYjQ5NzQ2Nzc4M2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkbe9hukY42vCPrqEM+mx7Ghpo6KFlZhpW6FNP21sXVs5+QcwONKr+s6ES/8O\nQoHCpGarVQXmYnPBc0iU4lPCVKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNpCQEXUSZkY9tKWfougkdJvpCBEwHwYDVR0j\nBBgwFoAUIZGh04qOnhOhTWhpjong+Y9l4wcwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIBKenn4PLtj89QDM4/Ti88rJqiwNn71IhXiIxlaYwbr/AiBGrX9vvj0Z\n4teOfglsKye7kmXU0pY0LBZX5Ws+QoGOfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATy1lseYo3OXX1IPJCfIiGTiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmExYjE3NC0zNjYyLTRmZjQtYTg5YS02OTQyOGQ1OThlMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0enQB7Th9mU3rBif0IsRH552D2iAtmI8hDkGcYZ0uEhqq\nJCnyRCxJC3Xghv/AQuHj1ek57mFSPt+SVX073Fy3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIZGh04qOnhOhTWhpjong+Y9l\n4wcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKUYHnIOODNZvXe/DXNhJB8xYoT/62UrFAL7HKT6S51wAiBaa7V6LDdX\nXA8xhCugH+KIQk6pAqZB4PNXv1o4xlf60w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAVitau8K4/HpUGOplXtjQZn6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUwNTdjMDItMDRlMi00YzY1LTk2ODAtYjQ5NzQ2Nzc4M2NhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDlkNTk5YzAtMmYxYi00\nMWVjLTg3MTItMmM2ODZhMGQzNTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXHV5yiiOUX8raTMuHXFT2+cqqYmtffK6uZe4hYu2yswSs7GGJz6Io/Bvj1QPMzog\nGcU6vQRTxYTlA5acIA7Ju6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNpCQEXUSZkY9tKWf\nougkdJvpCBEwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCICuHbadGiKPEkQ4ss7gwjaBt6f6sT/AioBe/5QwWGK9gAiBcxtRpf6GV\nRlq9iH/9WZdp22XaS7e0gfQx8eaFVX4TNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4197", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4197` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAT9KvYvT4LDibnwF47iSVxY5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMDg1NjU0LTYyODEtNDQ4MC04ZjI3LTY1MTQzZWQxZTlmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU0OWNjMWUtOGZk\nNi00M2JlLTk3NGUtNDI5MDU3ZDE4OTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/lb5Q9fy+ggPelRi9vdB8eDSQ8jRZntKUb84jWgQnEOeItlPJq/CmY41hpZJ\nb5GN9+9XMLssHsYprYX23jshSaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN5QvpP6+p6p5jjEZDw5UFKwzC2cwHwYDVR0j\nBBgwFoAUWvxJkCAVz4atDYPwa2gyLtfBSOswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIFxYbGrNSQbsj8O5UehjJt9RPreZyhJhBfwjniJQ7q3eAiBNw90I5D4c\nvVnocBFssyiAa+Lm7yaKeG0PlrqDZ3ozoA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV4RfvlXdT+X6LnDaiWeBRl6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzA4NTY1NC02MjgxLTQ0ODAtOGYyNy02NTE0M2VkMWU5ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmo/MsDqVGcYN6hH3s8SUT8U9Gq88C+Q3skBs+raXqGw4h\n+isALZqyfZx0H+ItljvxGXlUt4fIq65PPID+Pk7Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWvxJkCAVz4atDYPwa2gyLtfB\nSOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOkPuGNroaum4PTLalE/8TrGVmpOh93+c+hyZbm+NNOiAiB2xd2BF45d\nOH96Xqmf+TvnD+hsqPK6jusL9N6ZRowisQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISARAfbB7IMeOkRC1meB1pgsgKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU0OWNjMWUtOGZkNi00M2JlLTk3NGUtNDI5MDU3ZDE4OTlmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTI0ZDQ2OTYtODJkOS00\nZGFkLWIxMTMtMTU1OGRiMjJjZTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHooOsReqKbM+BCQ3Z7q6sT2tRWWVe/D8nB48FF3bGYVGMzlzb9X2lItz8Fe/yt3k\nTB/vNqYReBW7cakbde1M26NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUN5QvpP6+p6p5jjEZ\nDw5UFKwzC2cwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCBCotWKzQWFfrODjBJW4xxsQtcJW4iAI+PHciJAYWwFAIgPz4Nq42H\nsilW2O1u473JXxdekWF4nKdGFA2FFla5gvo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4198", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4198` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAa4Y4GwR6uyLehZDK0DS3ky1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMmQwZjY0LTlmMzgtNDViZC04MTM0LWM4MzM5ODk5NzFjODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmUyNjU3OGQtMDMz\nMy00MWMwLWFhMmYtYjMxYTk2NWYzNWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENa5vpNmrHmf6vQGkPrnAebxmBC55zInGDVKXBotoQelg4AFkM88AQlPTpq1M\ntukfWj8r1BjQRTeYIXmJTOYYHaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnOehkZj+XyYBVJ046y2rx4BvDAAwHwYDVR0j\nBBgwFoAU0OglrD29E6BCF2aZf7nx4DvDZNYwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nH1vSBYmBVZTTU7vP+VhgpUK2QArCL/wSv+pjlu3dkS8CIQDwc6tMRIifhONhrXA/\np13iVVMdpmaRcRx0HjPPxlk7og==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfDj078iONf8XIYkHbJXNOvdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzJkMGY2NC05ZjM4LTQ1YmQtODEzNC1jODMzOTg5OTcxYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKHmqxWvLPc5zAoMRDg2TZYBT7bbSJzOSBz2dBd8ZhLzQv\nSHHRIJro2n318Cecp1QGAEUzTRQnUgnTpD/PkJ3bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0OglrD29E6BCF2aZf7nx4DvD\nZNYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL8OdJUms2Gr5oyGs3YwJhAsC1YZAXsiiVkmAslsltEIAiBXuMtLd7Dd\n411ani0cvJ50EavTKht5wUt8jJqDDkgFIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAScmwWCGEiFSzndRIXWNEbMBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmUyNjU3OGQtMDMzMy00MWMwLWFhMmYtYjMxYTk2NWYzNWI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGU4Y2ExMDktY2Y3ZS00\nNGZiLTgzMjgtZTA2OGU0MDdjOTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFxTUiSp/Y+a2ig/rDHtNG3qGlMGCsmqCHavEu+geQ8b2IQoaFs2/d9nMHM/EBJcF\nd6ec3LDOFIO6Xe8a3IrExaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnOehkZj+XyYBVJ04\n6y2rx4BvDAAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDMsEa6kgy27lBpp07GV/yN8QEYpRv5GxG503JV5tGXwAIhALo6IDnT\nkWKCtHjNnf//tef8PTL1pfiGG4VEZIF/3u0Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4199", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4199` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAdR0u2cHO6loI4A0Y5TiTH0cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2OTNiM2NjLWNjNDktNGQwNC04MDUxLTk0YTMzMDk5ZWM4NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIwMjNlYzAtMDli\nYi00MWI4LTlhZmUtNmQzN2UxNTkyYmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGyaw5s1zNdt9vEWDxofSPyjVM3ceaKCCfpsKujclBA94pyuJ8BnLNzisEBlc\nz1tiplCL/+Vx+vkZ/V7J2lR0cKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8AoJd3x03Jh2OD/Ui6MWIJXAvogwHwYDVR0j\nBBgwFoAU7l3Opb7isfewKkLNtnP/Euol0AEwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDJbEW5C2ELffvDKR/Lzn6X/l+xxdXTEeuUcma6zPh12gIg\nPNSuW6PhgLqKuA+zIA7l+U/jLtLhsEEbmHr/SgI9jjc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYkFMTneCFNbLL7q59f7jVgBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjkzYjNjYy1jYzQ5LTRkMDQtODA1MS05NGEzMzA5OWVjODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrlTNlpCi4/VgqD1c6knMakeFnbnfXazn+VA0o11O1WHLC\n6/3zi66Vgssoddpo0wVskZU6bqHGhzEoMQktvct/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7l3Opb7isfewKkLNtnP/Euol\n0AEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPqQ1SpcFaNmGGdB4qfXQfcZTlYvUTGKPYJzBLV5sv1UCIGJSofZQ1ieb\ndnWyA1d7LgDurm4G+jhHgMAUedZnugot\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAUGmzeG61xV5JMYQNU/1F63sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIwMjNlYzAtMDliYi00MWI4LTlhZmUtNmQzN2UxNTkyYmYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTMxMGYwZDUtZjQyNi00\nNzU1LWFhZTMtNzk5MzFkNWU2MTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSXL9KZZLr8psXo6CKmypVorOIFIecpg/fu2WajnVbxeKifunHMmiDnKN9UWd8wkU\nfp+wyuW6cxylF63Fc4J7P6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8AoJd3x03Jh2OD/U\ni6MWIJXAvogwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIHGCV3YFrBKvPaMHejK3/phrr1FCPlr05A7P4U5vyemKAiAe2sPsY5TC\nPRaL93UT4agWsPLRAJlQqx0xTr1e2F9VgQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4200", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4200` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAaYKHmeqTLYkuCbRyNgzQfIgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0YmZhOTBkLWE1N2UtNDYyMC1iMTc2LTBiMDNjNTZkOGU0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I5YTkwNmEtYmFi\nMS00NTA1LTlmN2YtNmUyMDgyZGZlNWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj3f2v/LfyzH5LVxZk5XqAWAFAcALttnSKMT5B40audc+c8YMLcJGtHfxJEag\nR+J4Y3gMYy98F1HLXMo3D3cTkaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBPB5bXhczAD9f9WB2H2eKuatjQ8wHwYDVR0j\nBBgwFoAUqGjIl1nsnvzAdIJytVsP0QumAdcwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIGoP6pKQFxTVZMmHcJYTZrRetVwAAj/MxW5agEbJ7vbmAiAD\nvcdS+VHU89BjQoj+ZaKizAac9CSZojjOIe/J4+PXoA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAclaDYw6juy3PQkzjW+A0Yo6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGJmYTkwZC1hNTdlLTQ2MjAtYjE3Ni0wYjAzYzU2ZDhlNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLFMVTzx0MfKWcxRgYYsUCwjljjuco0I5BdQtAvo1okLWY\nbTwpznewf15oaWwB9MHw2BnBy4Ml5lT5RD1U374Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqGjIl1nsnvzAdIJytVsP0Qum\nAdcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHQDPiZjsdBzSz+VvWVdPKWDwASLqvNJyUqLvqtHWSx8CIQDQX1wcG5zH\n2V//0pGhDpgrr3kb5OiVyrt1ZYkAMYe4lA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISASf82nyIi1pupyUZS7CmecmTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I5YTkwNmEtYmFiMS00NTA1LTlmN2YtNmUyMDgyZGZlNWIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODRmNGI3NDMtYTNkOS00\nNGUyLTkyY2EtYjExOTE3ZDA2ZTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nty4uhJRgOsio7ah3apD493+Xg2UGC1nACK9PWTcum6UouA0bHr0lyVUa9mDZzhcW\n2WA0gRI5oEBKMsrl14v+A6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBPB5bXhczAD9f9WB\n2H2eKuatjQ8wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIHdh1A4Yh6dVfrtincHpnYOB+S5HWwZT9/KC3W227fbdAiEA5aJOhsYV\nlRoYY0ge1vo/1/Qbc/fQgQk/GPYpOZOyT54=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4201", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4201` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYwFLtKzErIGXM5c4cGYCpbwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0Mzk2NjAzLTZhNWQtNGJmMC05NzE2LTY4MjQyNGZlMDBmOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI2NWM5OTUtOGJj\nNS00YjZkLTgzMTAtNDlkNzk3YzUzOTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZo3m7JEEciWiU1hvaVxdJu0RyA1IE2crQS2kamqwIL/QXtz+kZq2+P8KIUp7\nqZStiQWh1+Ry07msSHrnIecSWKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZHDXM7ylSNNGUucseCwoxyAnT7gwHwYDVR0j\nBBgwFoAUdAc9W1kgn6tqWYXNOq/PCMakOwowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBCDoa5A8loj\nupJiRzHvCX5mUTxk18/Eje0pf6g9awUWAiB/k03rkTP/vF3YfdPWZHV+hP1nWnUK\nud7q7Gx8VHe9cA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVQPy8LSRvUVYEHP4y320FY+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDM5NjYwMy02YTVkLTRiZjAtOTcxNi02ODI0MjRmZTAwZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARh35r6vYSCsZ4U+wpwM7ZMunDDXAgaZgrA74faO+2+AZRb\nV1ooBInZzCq4wNLSsuuIlzWbBcXxUQal3FFsPXRGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdAc9W1kgn6tqWYXNOq/PCMak\nOwowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYyJToYJenwNBd6ZDNZT7SdqXv6xj7ylAUzIL3W3XVNwCICURQtxdAzAO\nXyLF17yeDGMWMopr4VjoWWNZ54RJE8di\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAa8easSnKt/t82Tn9+w7251JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI2NWM5OTUtOGJjNS00YjZkLTgzMTAtNDlkNzk3YzUzOTM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Q1YmFlMWYtNmNiOC00\nMWRlLTg1MjEtZmUxMzkwYzFlOWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMi4wMIQpAvMG3wyUFu5UzdgRMv4HBmkYh7+2pDm4Jq/X0F1xnqeM/JqXHhpm2NAd\n7RJdThg54+CDwfxCdhUpUaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZHDXM7ylSNNGUucs\neCwoxyAnT7gwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIDlQLdc9Wjn5vyHcfvzl/GvrOM8wArD+BCjcdAruJg6ZAiEAmtpZI32R\nTvE2MCjnbxeU9GfhGYCg/5okS9ofYpeUeTU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4202", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4202` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAeBhMdJWO9USX3ujT0qcseThMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYjkyMGM3LWE1YWQtNGZlZS04MGNjLTUwNTJjMWYwMzAyNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc1NGM4M2UtMGE2\nZC00ZGZhLTg1Y2UtNDBkMDJjNGExYTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkP8Kl5IYjctATxwm7Rhrf6O+ysE5pI/wlW4FiJxBnYa3KAyBRsxFj2yqf0GZ\nZGchNJkmgVXimHWSLDnNR9A75qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdq0o1YyxYsOc5qmIdW/ppuBnv7UwHwYDVR0j\nBBgwFoAUtV/KhR/hvp2LGgtkzvRn4Ey/Vt0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgPL5usNF90ctJ2y8xkk7IIJ3mlJ6FZCicGFRazoCfbY0CIQDAVhGMMkRQ\nHZsDxQ4m+sxm7C9rCPlxdlEQeZ58APlWEA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWXHKrJfhYl1npTdgClpdlscMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmI5MjBjNy1hNWFkLTRmZWUtODBjYy01MDUyYzFmMDMwMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+dsVoT6e/JUrqDvMzPiONh9NZBD985PGr2LBIrYlsMFoR\nGC4XtdcxVsT5YsTKSFzwFOE2WTmbNTurlAK8DEfwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtV/KhR/hvp2LGgtkzvRn4Ey/\nVt0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ60euEuDa8Jrf3khmSgds7cOkyXYiXCtXEra+GDh2RmAiEAvOCMyFHA\nbf/zbgLgveizXuOM4Zne7AYLrGu09uT1aQg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAZli1jSOU0vfns3+CXzGrae9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc1NGM4M2UtMGE2ZC00ZGZhLTg1Y2UtNDBkMDJjNGExYTFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWE1MWVjMjktYzkwOS00\nZWE0LTk0ZDQtODhmNWQzYTJhOTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngLZySRR9tDOn+Ip++S8fF9BtX8neqv0UYkZvei0CqDVUPRwyurSJxqWB/eCwe9T1\nPS+VgNC26s4TdTQj4Uqhh6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdq0o1YyxYsOc5qmI\ndW/ppuBnv7UwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCF5KekG04zskxHOLuhA+IjqohiFYLcuP6TZz1HVCxq/wIgKzj5OIeq\njJKdILJMXpnyvgmIiF+KLmEFDGGugryqOAE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4203", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4203` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAa8ybA1ByQ4+rEbtrP5RPmj6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzMTQxNzAwLTNjYjEtNDlhMi1iZDhiLTZjMzU4ZDkwY2ZiMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjRmYmUyMDMtODgx\nMS00NzhiLWFkZTktMzNhMWNhZjU1MDAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2jmzV9VnplRpK0NRmzcFIBhY2UAQNLvdmpeHanmjIFFCF6ERAaU0IWG3vHIv\nWVCYEdT/Q7lv3En3NZTSit4TO6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVFyFBQcJrZILRomkVoLyuFTDeAIwHwYDVR0j\nBBgwFoAUmTGoKqLxy8o+F9QHCVN+dF3Bc8kwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJm0bhJZsh+9Jn5ct8y6jMA4ykKHdAtiBgCSn9f3o3+7AiAeVzPoZ+iQ\nH2BQCZ8as5eFwl9SHYeZSVAPVpO1KXSuCQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY08sOWeGSqK5gdyEPfZBJlWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzE0MTcwMC0zY2IxLTQ5YTItYmQ4Yi02YzM1OGQ5MGNmYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS0z0+HYmyBBLt04gYeJaiyReOdvw/3jnm1E75vflV2m3D\n4AsuiMXWIOPovrCbtEqRE7x5cmbl3/ikNuMpHaVgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmTGoKqLxy8o+F9QHCVN+dF3B\nc8kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIw/3KDTLR5FQ9/Ff+H988O7uNOl3RPIiS0KrWJg1eVuAiBu2OmymKHA\nBbT4MA59GLm/emKBLnGpdh1FeUc7TxOUyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAcuHrcRaC1q84iojIzqkvxYQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjRmYmUyMDMtODgxMS00NzhiLWFkZTktMzNhMWNhZjU1MDAzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTM0M2ZmYmItZjdlNy00\nZDdlLWFkOWEtOTIzYTQ1Yjk2MjYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMv9VmGkA44VmVOU4pWFNIU+cbTOb80U4FZcEb30go7H8E+blPmyBjCjYuHPX9BHg\nJIp2eF3qFPVzb8MwS2rvt6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVFyFBQcJrZILRomk\nVoLyuFTDeAIwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCID+HZcFI/SVMkf77Fftlh7kRNwlzFPXv9OPQOGLWTtrCAiEA2AZRKB2t\nsTv76O1QOIi2bAJYd5pAzxnfxfZFepN84ys=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4204", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4204` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISASjLdRXGUbjipUMMjfNpiio6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwYmEwMThiLTQzNjQtNGIyMS04YjJmLTcwNTk3Nzk1MDA2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhhMmM0NWUtNGJi\nNS00YzUwLWJiY2EtMDMyMDY4N2QzZmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqkzhTiIYo+265yUDjHsqHixCNcrLgEQVYQU1R2rEWbOsoSadJUQfbgC7nesJ\nGdNXw666T+/e7ZUJJh81g0Ynw6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpEAsvdIcElwf7v9ldGWwhnrEdtUwHwYDVR0j\nBBgwFoAUwyDlUUr7qGiJUPb265GuAlOsz2QwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIDLrFim/eyW7cBt1cj/b7FJf9Ngm64qPVFO4X4xACBYwAiEA715ToZfw\nzOQi393fR/clu4/gEHXcFB2cZoXO2+fASNk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeb0pV0UtHzVkjKyQkDGFqU4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGJhMDE4Yi00MzY0LTRiMjEtOGIyZi03MDU5Nzc5NTAwNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZE/y+8zd7la2vpJckJTXhLwKoQ7EysbLJ66EqScVu17jb\nMmRswfc+XVi+rk9kLEQckrTs1U1pQ2LFR1XqmjYko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwyDlUUr7qGiJUPb265GuAlOs\nz2QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgATgi1gxi8OCpg9mAfaOKuwYRRn993Cf4lmeYOBM1pvUCICQbZwHvX5vq\n64CLgzeL0VJqqOM/XBpV6i0isXbFisWw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAa4LQJdIgT6AmJrBrksrQ92UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhhMmM0NWUtNGJiNS00YzUwLWJiY2EtMDMyMDY4N2QzZmQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODNmZDlmYjktYTVjNS00\nZDg5LTg0ZTEtN2ZkOTllNzRlYWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nX8iS/FUsaRPlEttZF+/gZLkwX46iPxH8FS+3JIPPX3hY8MImx7ic3OHlyjPIzDuP\n1wUZn0U0VU5K+TYxuxz+06NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpEAsvdIcElwf7v9l\ndGWwhnrEdtUwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDlNxETg13I7FNsjaMQUtEurgoLSNXSQp9IN3uplfeTgwIhAIdRmN9T\netaqBltf5xX8U8Y/sBJ5yj+lEInmbx4UUMwn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4205", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4205` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVmOJm34PX9ySztukRXh0rdlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMzNjNzVhLWZiZTMtNDE4NS1hNjJiLWM4Mjc4MGJjOWUwNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA5YTM4MWYtZTBj\nYy00ODgyLWI0MmQtOWZhYjAzZmZjNzVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK3PXQfZ+oYa+dxiJZ13IpVgoRKc3r0drRrvos1bxE3dhj6TvJW1XeP3FS9VQ\nLvEh0OX5eMFp4paze0H/JLHDr6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdJk8T253O6lkTrzyFxqMxL7TtRUwHwYDVR0j\nBBgwFoAUx2J2Z3SOezlDHO2WphQCqyA0rn4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCYyKNzWr8nUm7AKw3tudLN6ELV8O+QxkXjVCf5\nnvPKagIgCBKrSCN7FHHJl6KC3ikd2/FDu2EdwLz9z2R/fYonDrU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZhyotPjmlxLKHhq1ijhAL3LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTMzYzc1YS1mYmUzLTQxODUtYTYyYi1jODI3ODBiYzllMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPn6/CQEx4uxsSWLVsCaByUcE+ZTI5F0pqvUhuBYSzIVKT\nGvo0bk4UbB54LW1wDyPJl98uhc5wNKBTA9t+QahSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx2J2Z3SOezlDHO2WphQCqyA0\nrn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKBcQz18/4wD0CE91WervlzmqcQ7kMZf4nZfHfb/MkvwCIQCpoTYTA/5L\npgI30Mrea00KRzIzqnFI5uIEWX9kqHTl7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAb4xI2AWXHerJ7VXP64g5On2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA5YTM4MWYtZTBjYy00ODgyLWI0MmQtOWZhYjAzZmZjNzVkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDQ3YzBmZTAtNDcyYy00\nMTY0LWI5MDUtMDhlMGFjNmM5MDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nG85jEDckbQzxk8xmujOy9/SGkX+JMv0w9LkJn52avir/wJCJnWX9MwEmaDLqFkp+\nSHLMxtOFQclM21v2Go7V+aNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdJk8T253O6lkTrzy\nFxqMxL7TtRUwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIFKi1SzzATfvyqbjjZIfx7+n3hpfpsX2/mMcr4NQ1MAuAiB2qt2lbTyu\nk14+mY7jc3SnqUbw9v9iTHIULL6U6YQ+8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4206", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4206` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISATvElQihLedsy9zWc8wCQZsDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwYmI3YjkxLWFlZmYtNDBlNC1iYjc4LTU2YmQ3OTcxZmRmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc3OGUwZjUtMmNi\nZi00Y2FjLWI5YjAtOWQ1YTY1NjZlODkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENamvYUBoeRdzXLuwmA0AS3HOLCLc33ToRc9JW2byKRuXGBFQhbvyOwSihzDp\nQEg001SHnM7jZaiUN1eJmzVLw6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAKZhe1/ZAiW9knm92BXN2JMYUPswHwYDVR0j\nBBgwFoAU0DsM05OMlGplHeI6Fc5EdKet5PIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDY8c+I8/+i1VxTFKH8Yl9PFc+jzWw3rmJt+qHI\nk+nK3gIhAI1TwSUfG3pqZaxDfbO3ugqTVcat/thK6U6e+TRnylmJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZAL/nK6aDMBiLA5OkhwbCzPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGJiN2I5MS1hZWZmLTQwZTQtYmI3OC01NmJkNzk3MWZkZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaiEHZ98MdFhI0zJAyvmwlgUf2FHEOHNWmGlF/7VnUnbAf\noVmj0n+sBUx0tMgNQMtuikCoUbye+ANCAoAfn6jzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0DsM05OMlGplHeI6Fc5EdKet\n5PIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO5JXRJCZbOSzmbgfgrR2ehhGjD+DtNabtPfQ3eby3QCAiEA4i+LPE+g\nkwdDrb4WGJoweQLkpWPVMUMv39whTdSkomI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAR180WwTahPzIiKkbScxm2F9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc3OGUwZjUtMmNiZi00Y2FjLWI5YjAtOWQ1YTY1NjZlODkwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjNjY2MyYzUtNDIzMS00\nMTY3LWI5YTctYmUzOTQ5NjE1Y2FmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMgbQsLaBQ+CYKvHKUwiCGnhDdL7UKWi8WZ3JRF1v8NAy4OtCpN9M0HQm7fDUNo0U\naiEYKvDxi3firEAesG03bqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAKZhe1/ZAiW9knm9\n2BXN2JMYUPswGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIE5IuHV7/dWTCD/pNRpZejAfkmGOPXaWlilH5L/5E0WFAiEA45nEpN0G\nRJJ29YgHbzBbVWUybyQSb9Z+6Gv6bOa4mXE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4207", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4207` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZbSDBXShwo1AwcQeOvfzAjEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2ZjFlMzQwLTk4Y2ItNDEzZi04MDA1LTZlYWQ5MWNkMTI1MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhjMzMyZGQtY2Jl\nMS00ODcwLTk2NTMtODgyZTlmMzQ4ZmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5Bvsv5g5kpnFCPnqjKkiUpmS4z6SzFbW01V5q6xYiWNPugl0d3sZs+Q40KxC\nC8r4carFwUuGty3ibx6RJYldMaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmtRpAumJlYocKAFTjEcx3szcccwwHwYDVR0j\nBBgwFoAUSoDrqcuQpNxiG3BV2FDu39Nfm64wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDKhTxPMfkjEh8KC7FnWfL7CppYZSLbDSPeS96OWilE3AIg\nbfaw8KXKhgHDcBz4Aw7s9+G1WR1FNICN/G9APuVJ+4I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATTK6pDiayu2VftFWwdD9KnCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmYxZTM0MC05OGNiLTQxM2YtODAwNS02ZWFkOTFjZDEyNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSJfZ0ld+yB3pVGouEf8/huxEWdOtWO2gtXHGQHTAUM7Cp\nMgHGX+Wb+c3Tj5+hOo+pkp0+u5Zi3T+ZSQAXNl5po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSoDrqcuQpNxiG3BV2FDu39Nf\nm64wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfpn0oXPkTczWW51tH4yFzFTHA7RZ7zzPBN/gDrdWz3UCID4nL8XZGXBs\nGrvIh9dJbYJY92hwzgUwVjWOMnR6do7+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAQoBlTBCGfL9uyRO0wC7P2pQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhjMzMyZGQtY2JlMS00ODcwLTk2NTMtODgyZTlmMzQ4ZmY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWU3ZjRlZGEtNzY0My00\nZTM2LThmOTEtOWFhZDIzZTllMTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n19tUpeA+m43CWT+p8SCH1+cIVgbV8O7H4uAzr/D0Pr7MZgy2Ra8iNQz7rtaC20q5\n88oBIiIqwFASfmMjuV+3xqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmtRpAumJlYocKAFT\njEcx3szcccwwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQD1miihs3OZsPZh5eFXJNNauKuf0Gwd6DX/Bow6tHiEKQIhAMnAKPrU\nLsZq9BmCrrUbsDHsLo7tE2bF7tA5MY5leJZ5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4208", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4208` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISARI0vaDdb2ItJ3iVeCkiHZbuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjYmJjMTQyLWRiZDEtNDRkZC1iOTUzLWM3NDEyMDlkM2RhYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI1ODUxN2UtMzM0\nMy00NzYwLTllMzItMzFjYmFkZDRhYWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmlOwpJ+VAF2J1x189sWYFQL1nWoeFKdjVJttd1DwM0mFSnRMwo57Iy0PCrNu\nafPQAN/iIqozuTipiEb5fRpae6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBx/WnHlD5ynU0Mki3Vdko6Lo6LAwHwYDVR0j\nBBgwFoAUEzHqmcn555lC+00kbEcHiw7HuZMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIC9KWHuw3ZQEcR7K6Y5Nh+C5b2GpfvhU\nLymZk83LNfdgAiAgX8ZTQXhdOj9mzqZDyOh8K1pSXsE4fsUA4yqKYwL6JQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASbk9mr3EQ3qRPiPk8FxmepKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2JiYzE0Mi1kYmQxLTQ0ZGQtYjk1My1jNzQxMjA5ZDNkYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQB7hh1uYB5/pYqPf7HO8WBLTPMm9kgc7XTlibcTb0G2v2H\nNme3VXJaDoKc6oftjXddY/+UGDRTWVg1wzqOPXqmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEzHqmcn555lC+00kbEcHiw7H\nuZMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANhLt9A8CNYKqr93DWBHuvd2VoKox7qmmWffPneWGdMgAiEA3YJjFOxp\nZDeqV/V/jG0JMfVsteyGBAt6JW5/SUNII2s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAYUMPUukf3yQkQ3QfxIt6OLdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI1ODUxN2UtMzM0My00NzYwLTllMzItMzFjYmFkZDRhYWNiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjQzNjZhZjEtYmRjMC00\nMGViLTg0YjQtZmEyZmI3MjA2ZDNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsWFQnK1+Xz7zd4553Na4gnDuTX84sTVHAdRFj5vPeyoQf/NmYP1jxvvnjHSi22uk\nTxzc3CXYcCBetFRpsVBFY6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBx/WnHlD5ynU0Mki\n3Vdko6Lo6LAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIF84SBaJG5kCnWdsrxLTP74HdWjIsn8fwy+a4n1C0mgpAiA1I7G4fAYk\n6h0ccF4YP4kxbC6hCg/s0sYgGro6fwpnFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4209", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4209` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAWsvDc43ffKiOZ+++SfxgSiqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1NTk3MzIwLWZhNWQtNGE2My1iMmI0LWRlMTE5OTU0ZTM4OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc3NGIzNTMtYjU2\nNC00ZTViLWE4YTItNzAzOWJiYWYzZmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC9o5FzrxdAvnH2VtwaMtnOTDEqadiupib5Pi5QdV6K3mysTkLCvdf3f/DoM/\nfhTUVaMd8vk0dwmBKu3zda/jZ6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7lyB/6+GS+SFC7fB8lSv+JEcydgwHwYDVR0j\nBBgwFoAULxKqgdc4ZHUcLHMKkxzKc1+Fkf8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD4i88P6V9bMdotNdQeV+ojkkjdwcVB\nm4CXcOs1CUfAigIhAOHM9ydbOx7ghmILPaBP7gP9olJzaIXJPh+2EW560SaA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdipKEkVtT/eDoW3i4UllMC0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTU5NzMyMC1mYTVkLTRhNjMtYjJiNC1kZTExOTk1NGUzODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBJLJszmGW+Qhz88MwiyphIPC1khS9gdsEHITG6eUja63I\nMtK7A2xW+Sn5INpWEIlr+GKMyv9REa+VLltEHVoVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULxKqgdc4ZHUcLHMKkxzKc1+F\nkf8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK3xhogHnu1o387FyeABspZIevf05RtapUxls/BXv401AiEAw80wgpol\nWyJ+HxZPD5tuZqo5XgaQDiz+LPB4OcfhJyk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISATqU0+Xh5xKlonaJl7ETDHmhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc3NGIzNTMtYjU2NC00ZTViLWE4YTItNzAzOWJiYWYzZmZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTE1NDkzNTAtZjFjNS00\nYTA4LTkwMGEtMzA2YWNkODUzNDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzwecGY+yW3LZOD8Q7SDMEVRjV9Lpwnvo1i/dCvq7kTbrGJT9F+aowFacN8OCDMgR\nKftvuu9gp1v0GSG1YetQl6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7lyB/6+GS+SFC7fB\n8lSv+JEcydgwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCUvEReIhsU8JHOZTJQDAxieAJ/1DfhADLa3BezWxbKLAIhAMjUIBqa\nkmam8Q+5IqfsJ1sulys61MLceURgq2cyrhuV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4210", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4210` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASydqVJDKxKcoAjCf6vgVj4AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhY2M4ZTM1LTQyYzYtNDBjZi1iNmVlLWRmNzNmYmNkMmU1NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdlYjI3NzEtMmZl\nOC00YjhkLWJhZjktZTBlNzhiNWJlZmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED2GE/Q2p4MCa/fRnDkENld9mI8morW73O2Sc4q8gRFfBCuy3GIpu89tHOaa2\nHT9BR/A7qE2HBEuXNtxTGKHdMKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJgwhcJqlpgoVjvv4iQToH7B28JowHwYDVR0j\nBBgwFoAUP2X+sAQIrZD8zxZffrWOdoDSeCEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCFtK6Cpo+O\nVQe9ncsuw/ryPFXRXKUVp0q4jK88uNunFwIhAPrjVnnYrgPBq82tuMVPT8dGyR6P\ngiLVd92qtWCSTl4m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQrPMa7n7reoxmJMQZ9ke1skMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWNjOGUzNS00MmM2LTQwY2YtYjZlZS1kZjczZmJjZDJlNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJqen7cT9/jmoGTmo4+gq4R7xR6tpkGkL4RuU5G8XWsi8Y\nR9l6MO8hT/3747VfOpFuZ2uxDv17+dGr3YrQZU+Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP2X+sAQIrZD8zxZffrWOdoDS\neCEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJmV7uLG/QcSxYT5pgAsa0QtsWcKtpNAaN9M63WWvji4CIQDuwIGOAeDo\nY9bct3Wp7iuCPwzI9K69O91+x9VV1SzuWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAU7nHvAdYl0JCxd7afBjCNmeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdlYjI3NzEtMmZlOC00YjhkLWJhZjktZTBlNzhiNWJlZmVkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDBhOTZlOWItZTQyMS00\nNjE0LWExNzUtYTcyOTMwN2QxMzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7z+ZaCyXfgYieBdjcbxPomTxLhxbnbGx6EMxFIxiGPhoMzWgZ1mR0kAVjOeavZX9\n36T+vWsU1QBZWbQQEqI486NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJgwhcJqlpgoVjvv4\niQToH7B28JowGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDNYWOKV9q49U8J4efUc6/6uemL+39pz5wd549VAyiTswIhANdC8BX0\nplf+lfQJ0qlKpsr2Oa4HP4l0/mO6A3upcAGd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4211", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4211` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATOtQ0CG0xNmTrDmZ8llBheWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlMDBjNWY2LWYwNGYtNGE4OC05NjUyLTY2NWY2YzgzNjFjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODUzZDNkY2EtN2Fi\nMC00NmJlLWE3MDktNmQwNmVjYmZmMzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3a5sjWDIR6Yn2FL3qOsFhMuHAXdu+z16YE5dN3+3gNT1NOHRgR4sdXwhp02g\nIh27JghPcDa55YZgoSa+P7O6HqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU15DYuIoXVarzlmJWnFCb1zA2KpMwHwYDVR0j\nBBgwFoAUamXZQ6HhcwRBeQrjLlNC3n4ERoEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAL/5bd5SA+9J/sHOh+oh//+Sxjqpc5zu7NuENQrUegSpAiBS9xs2yJYj\nInddOT7aKTZW3oo/3lEPEs6qOv5piZh58Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbL+Ou2/97IDi6vxofMvESOhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTAwYzVmNi1mMDRmLTRhODgtOTY1Mi02NjVmNmM4MzYxY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCaqoIwInqZRZ3ZlyK2G3a1rZ1k+FbuI8V1PJ6hEKe0KNd\nYT/2bm9Wfas9yOXUzLwM4ayodxqYSYW0jtzIKE+Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUamXZQ6HhcwRBeQrjLlNC3n4E\nRoEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAItpHVgM7icnR7O4q0wPwpE/ie1tj4y6FPXLUDY3VK7YAiEA8qAoXJFg\npKcl+pQZGMF5C0Ui+pDdg/AS8CEE4MUD2js=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAepgO3kK3Wmxij85QIZqEz9nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODUzZDNkY2EtN2FiMC00NmJlLWE3MDktNmQwNmVjYmZmMzA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2E3ZjU2OGQtYWEwNy00\nNmI3LTljZjgtNDA2MmUwMzhmYjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvr4dy4RMFvqi0B+JKy9+QxlY1S0iYnGUup4yiAlc/SrPAWmuw9yzZoYLhKTaCXg9\ntDDQOuLF51QSHUP6UBr3SaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU15DYuIoXVarzlmJW\nnFCb1zA2KpMwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCICN+DOX97/zT810UWcgCzEfWzHu9n5WsZpJMS1ySfN8fAiBAXhFIdaEn\nhvgMTE58EcA7J+9CbbQwHfxQJXBolkoCqg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4212", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4212` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAWnQiqv6ru3nc0TApwv+qTL9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMzZmMzBkLTc0NWMtNGJhMS1iZDFiLWNiZmU4YTk3Y2ExMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQxNGM4YTEtM2Vh\nYS00MTExLTk0YjctMmJkZjQwOTcxOGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI9uWLcI4Ae9Z2+vgDvgjewWsMGdiWW2p4OycDfr+1EF9zb2SnSDGpleYp5fT\n4wTW64UAlgWqarDc29TEYs4CBKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZko66sBIYGXE8+YSxYFwYiy5UD4wHwYDVR0j\nBBgwFoAUDSMARySwSTLAHaivpqkkPu5GBhowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAKx1ken8//QIAkThVlbsvN7ziSU2+vUqI1SN34KpqonIAiEA/eIotfnZ\naMI5TY/FkUK43lsaD5+yP8KCcqnYRDVoK4Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbl+Lk5WHNPD7cm1/C1xOL8rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjM2ZjMwZC03NDVjLTRiYTEtYmQxYi1jYmZlOGE5N2NhMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQcvejMDVdN6djOtDVesNTPd7yRgpfTSofDI1J9uYRC7cE\n5MjorOFXrPCWjyd8v4GST9fWq/hM2Aojnhjw9ldEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDSMARySwSTLAHaivpqkkPu5G\nBhowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRIfmMmQ7tIakTVod2k99TWoT3Yf6Ji9GGECucePavMACIQDw/R0TwHyg\nege4izPbscceIHEg5R4M5HUUmiAENI710g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAQ5rt/NXSuZMSCoGkpKJ1V0wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQxNGM4YTEtM2VhYS00MTExLTk0YjctMmJkZjQwOTcxOGQ4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzJlOTIxMWMtZDk0Yi00\nOWU3LWI1NmItZTQ4YWNhZjI1M2M3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXz0Um3Rmm3cSlOCD+wiggHqEodnD8Fpvsjb55/Qm2Hfkp+P4IZFtoAwhY5BRiIDp\nW63a1UXS2MAb6aq0X7ZgUqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZko66sBIYGXE8+YS\nxYFwYiy5UD4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCfIWnAazu4LsKC2hXW6ro20an1cGwOJcYcmNLGqCvYggIgdYYQ4D23\nNzYrnwHdVXPUBmU0Yxa6uZ7A4mkJeEdv7Wo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4213", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4213` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAekgQV0uRo1QrNKz+wS3lDm+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyN2EzZjlkLTdiOWYtNGIyZS1iOGQ3LTZmNTFlN2RmNWI4ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDgyMjg1MzMtZmY5\nZC00NmNmLTg4MTktOGU4YzVhNGI3ODU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/BhLn2MchWsAwExmXVeOeIu1w+JHSiCGwVzZQlVS+YFIV9h48G8rtGfwXZu0\nNEB4F9bDbGUfG3RhYIYpsugmKaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQil3m8iamfhyXybAld1MjIRzN7AwHwYDVR0j\nBBgwFoAU80t5m6fbY8rUceC+ht50xSGB3zQwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIAcHYpz/rvMyc71bjOcp+ols4WCsVSPWiOkaAtmKJogVAiEAz5HNUPyp\nAldbBT95ZnidXG4PrR2L/U+r12m191YQLnI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZfc3HIN2SKl+ERbWgFucDQ+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjdhM2Y5ZC03YjlmLTRiMmUtYjhkNy02ZjUxZTdkZjViOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASw1ff18ca3jZaZyz9zThfrQkeX2vqqcLl3CXGlvTWDArKB\njXqWrRRkwhDlu0n7ho8Wrr7qqAio67hRQ8KwDQOto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU80t5m6fbY8rUceC+ht50xSGB\n3zQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKkOK+VILQEbhzpDXW5V/LosTCad1PGb6FYlleTNW3ahAiB2R4W8rzDC\n5Jm8NevYQuw0SWJ0ZoYleNzfz6KQ7H1NMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAfYdcqo6Rr4sBOfGp/ob0o2iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDgyMjg1MzMtZmY5ZC00NmNmLTg4MTktOGU4YzVhNGI3ODU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzk2NjljMDktMTk4OC00\nYjBiLWEyZTYtODg3MGE5ZDkwZDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyIWKk3fys1wF1ucCHaea+HnmZrYUGPb4yA7Eu2RykGlMjY2DJ2VLswINx02GeTfJ\nE9CprxosZVL8/WKVhRF9f6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQil3m8iamfhyXybA\nld1MjIRzN7AwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDWC2b+xVJaOFdOCJapGXRl+Zb81APk8GvgoHrimrDgyAIhAIRpnzU7\nMOz+QH97FX0JHTZDFSxAJDNYrfcsD5QhTmvl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4214", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4214` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAZvuCwxqjjK2DuvtEHOqvKnFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzYzg5OGExLTI5Y2YtNDE5Zi05OTI4LTA5NGM4OTY2NjAwZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE3OWU3OWItNTc0\nMS00MmE0LTkzNTMtOWNlOThkOWI2NjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnUdiD6ruDl3jISwrw0Ay7hJxABy27ufRqYaHf2xU0jFsF/fYXNGaLbgVWsNp\nuvCz+yXjzhYbk7HoL3haxPe5kqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgkIwcMSTF09yH76CeQ7g8av6eY8wHwYDVR0j\nBBgwFoAUiWfTZsVmUaP9FVQniArqKpNH26wwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEr9mCtSyZMP/nJEutSBIy3lNFmebUHGwGjKCSGL\nHfw4AiBHEeQZWoS8k929CcIBRw0fIAG+jYvLZucAMxkLv7zi/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYh8I8JZlG7K0p9TtZNSbpVDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2M4OThhMS0yOWNmLTQxOWYtOTkyOC0wOTRjODk2NjYwMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARF+u+t2AquinwdngiGVlIVKorBHhJjFsL2ZmMCLmmtWsa2\njiZZVkHzWoePlQRgeep5U+1HZY0e+gHcKbiTVYeko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiWfTZsVmUaP9FVQniArqKpNH\n26wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALZHVwgfkijhp5uiIzTrQsFZ+HugvMTx7JeZDQ4jSzimAiEA6UDPLn/X\nPuKhDwzq/oper8MjNyv/BJVeOY+XcxMOL7M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAdawiVHqVHCiZD+Z9e2JYiotMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE3OWU3OWItNTc0MS00MmE0LTkzNTMtOWNlOThkOWI2NjQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2ZhODFhZTctYTA4OS00\nZDJhLWE5NDQtN2QwYzFhZjAwN2I2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nx0zZZ5xH0bxJO7CL9lrq3Z/R7CuljQQieSwnU3GRITB4kQVZFraBaRTsqAOkVuCd\niSArg+7HKhzUMsNajQjA86NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgkIwcMSTF09yH76C\neQ7g8av6eY8wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIGlbo8JM96SKad3NX41Z65zdIZ6S6MJuz7UQRQhMnVaAAiEA9ImE4d+K\n6ILLVcbC9RUrUQWckzxQZPs1ArNLS9T/TZE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4215", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4215` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAcy1JZb6CuD5yfGL+hy2kOpxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiODcyYWQyLTdmMmYtNDBjNy1iM2QxLTk5NTBmMWIwNGFjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUxYzRiZTgtZDU5\nNy00M2Y4LWJlYWMtMWZlNDk3ODg4NzUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6IMS+AqDVe5wUxVydev1kfZ/WdnstOmd0upe2fQVQR4elR5emDpfQ1K2LgM5\n7LEW8EH/awcYNz1x6KbbY11P76OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHeBDgfD3Xxr6ke06H4V0EpwSUrowHwYDVR0j\nBBgwFoAUw2lDm0A29Qac6Y1nc7krUU+x5ZowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCK+H8yfI4BILfnYA/zWwoX7/lnpg3+pQsI2NCE\naLF4VAIgSWobDdEub5DpmdJqFFpP85mtGpp/9dUfNVdCvTc0vbY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZHOumyFWIjKVJnfNcyb0YKYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjg3MmFkMi03ZjJmLTQwYzctYjNkMS05OTUwZjFiMDRhYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/mISvmDPm1KIx9/CLu0//r6pVPFM+83egxurZkPgNww2+\nbCavyvY/eq7y9wJoHTDAY04eY8ocj5B63VFUHxkHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw2lDm0A29Qac6Y1nc7krUU+x\n5ZowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDn9RE/BwBu5MULB34JpK5znVOcNirLvnPeYTdmEMhd8CIBLXwo1usAdi\nCJDtwjgu30DTmVjyn2ONLKH/WXu//KhU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAZK6DjJIHfzxyWdXhp+7FpyFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUxYzRiZTgtZDU5Ny00M2Y4LWJlYWMtMWZlNDk3ODg4NzUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDI0Njk2N2UtNDZjMy00\nZmNmLWE0YjctZDY4MzdmYzYyMmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5c/AmZgJFZ/eNjW1vF/WjR6cvICZzuzzYW/iYYlkv4tdjIvF8qOoY7cEUZIINBDO\nTPOb4Xrf5CvuErb+z6WGIqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHeBDgfD3Xxr6ke06\nH4V0EpwSUrowGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIB7zlr3ouCb36dcB67j1QYCT29kok/6v/PsA4thaRbHfAiAZSlVdvx6U\nkRYKKVTNaWXfQimKlvNnwUECaVtdnRlMEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4216", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4216` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAZx/K1lPuyHqS8MpeC5NfsE7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwNGY3YzNkLTQ0ODAtNDNmZS1hMTg2LWRkZjIzMGI1MTA3OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE1NGNiZWEtNzE3\nNC00MDA1LWE5ZWQtYWY0NDIwNmNjOWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpl0RIVSCUeYhAo/Roy8ZX66oohwntE2KwKsgOVj+Zfoo41B/guv6+1wdprbm\n/QYqi6oJ6tHs5LevQrz1b9cZ+6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTR4ssnn21C9PbNHC/BxVNPCDF/4wHwYDVR0j\nBBgwFoAU1zyGLCYfYdLM5+wEuv1AyW+4qM4wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIFcvxErT9aZfHddHp6PD5U4shkVtn3VKgf/zs31WGv+vAiAm\ntIKhuy/WXc5H9BQwtRj4jg5HH9dC4UR3LPR27Xlp0A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYSdxdydajEd1uXFzVEdopoMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDRmN2MzZC00NDgwLTQzZmUtYTE4Ni1kZGYyMzBiNTEwNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoXF56SuJJ7jnGDxBEialqWqx/aFDEjvi1gZULHAfzezF5\nTFwPY8EMejttd3OU9dZhN6jqmuwNVAg4Q2xg+inMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1zyGLCYfYdLM5+wEuv1AyW+4\nqM4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOxy82wa/C6uW4apwpwnf5d2P+JvPkW6i0LwBC8uQ+udAiEAoPcof0UE\nqZTGo9PddvF0xGCXxzKj7UHJaqy3wEtcqr0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAYrcWuFjWKyBWMF9lp7kIpPqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE1NGNiZWEtNzE3NC00MDA1LWE5ZWQtYWY0NDIwNmNjOWVkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWJkMGU2MmItOTdkOS00\nMmQxLWIyNDEtNTVkMTcyYzMxZGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsdNpKsG8bwQp9E3zaJDGYlcMnXp4qPxr5xJt2Z2+jrVz2YvQdcXLICaYWUV87tIk\ncnb7si4BDljV89YSfW1mlKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTR4ssnn21C9PbNHC\n/BxVNPCDF/4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDf4iDr6nq5tz/LC1zZedCiXvozdyJJT+vI6OxbqDRJ8gIhAMd3cFbD\n0QX3YVh7etGbNuhcBncccZiDlfKwj4awvHtq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4217", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4217` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAdSf3EdB2qiMbrOFsfJhgccAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5ZWYzZTFmLWU1YzAtNGZjYy05NDYyLTU5NTI0NTc0NzZkMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZhMmQzOTItOTYw\nMy00NmUyLWI1ZDAtYjhmMzRhOTUyMmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBgvexlbJBd3GLfRgIP6adAZaw8CyctFTmHnExAq5EkVDR/FhFrTFGUdcf7KL\ndjRBkvsC/RjQC7v5a5NBdjlVhaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKQvJgp21dHa/bqCO1XwZA/NRRVowHwYDVR0j\nBBgwFoAUWGH3GDvkdidRPPbPEVGmI3Ks83YwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDZ8+AkB9oHZWEOB5ZYND7yU8gms3Xy\nXuWHSPrCMApLqwIgKz/ncJHg3MiZSVgZl+RcH/bQOjogHWIpPsGZRytYnWg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdSUgegjDvE4uC5t5PjLlzefMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWVmM2UxZi1lNWMwLTRmY2MtOTQ2Mi01OTUyNDU3NDc2ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgB7sjvgzVVDlzzJqMUWOlm68BOv5MlWlL/TZ2SXhEmfZt\nXJteEsFwVPdHmNSWo55XwyS8R/M2rDR0YqV5TMvuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWGH3GDvkdidRPPbPEVGmI3Ks\n83YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKFt7tFzv3t7liwRt4DHliGZnaOBFIsWn2GABXinrRiOAiEAj5WU7n1v\n9KL+b58O0i1xXkv4QAHoZ1+ZbudKgj2l0kY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISATpbXJNineghZ6N7wiAmZIXqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZhMmQzOTItOTYwMy00NmUyLWI1ZDAtYjhmMzRhOTUyMmZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzE0MDk0YmUtM2IzOC00\nYTI3LTgyMDMtOGZjZTRmMTA3YjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSw19tXfbMMvEx7EFvK2ThlA1NMpjeI8oKSlo/EHIJgVchxnFcb97qUIc63qH7Luj\nR3EuIx4JSmTxD6rMj7ZF3KNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKQvJgp21dHa/bqCO\n1XwZA/NRRVowGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQD7jE7Yr1KoAqIOJfAxAba8m7Otj63Qw2cTEUf7L/u4WwIgSesFjvQO\n1yWKGmGxed5Qi6X48J0V4i2mpsA8MYE2rZ0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4218", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4218` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASiP16lZqjLmKE0/ZIL7mFBgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzOTU0ZTU1LTJlMmQtNDJhMS05MjRmLTY5NjI2NDRiZDY5YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRkNGQ5MzctNTdj\nNC00ZjFmLWI3MzUtOWNkOTBiYTJjZTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETsT3k9s08teExEyAofpJKn/pshA3xVErhuzPMRT2zxypT8LVfbXtmLmclrAJ\n3npZiBn/trStu1/yiyvKFZsINKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPbrcliFSFNDZrmhcF5sQre3JqMIwHwYDVR0j\nBBgwFoAUcA1OlUFvbrQR4LiGkQmsY9jdrtswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD5bvqDl6SjnMmzPagS8TXQELQE+tDv\noMPhebnHNmf8ZwIgdwGcdvsqffUKZPMomTMtZkLSn5yCYijaIKRzdMUfnrE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVS8L8CJ3Cuo4hSEnSfRx9NuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzk1NGU1NS0yZTJkLTQyYTEtOTI0Zi02OTYyNjQ0YmQ2OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLDA5Kg0AASRQk65gzSrpq3nClXod0V8eenybd8z7weOdc\nWYfLIFKUBCmrzCFLUq59xeJ+mJR6Wq8uke3SbCqXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcA1OlUFvbrQR4LiGkQmsY9jd\nrtswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALCrihzSAOZ96OQrNxSxx5V/mnBga1zq0FKItiimrXnCAiAaGkWv5Xuw\nvMin0YXAuCVgqO6FrW3cd39mD6gU/qMULQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAXbp5CV5lDvDd2sb/0HDlUgiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRkNGQ5MzctNTdjNC00ZjFmLWI3MzUtOWNkOTBiYTJjZTlhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGM0MzA5NjAtN2M1MC00\nMjNiLThmYmQtN2RlODc1MzA5ZmJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\np2wB8FQxtXEhqxz7CuMYtzKuspJMNPRMO9UjYuwaB0Q6GpnaHIXrPMDQ8pUmELqw\nrrKQ0q3nkB5zcqvZVrOePKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPbrcliFSFNDZrmhc\nF5sQre3JqMIwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDm2sOZ/VkcBRPB+dzycbzI58D1yUR/bLTQ9EZQqxkU9AIgDtlDhPs9\njN8ktUjc76LTuh0sJEw1teXmMWDIG3y3oYc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4219", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4219` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATkaplCSpew8FQQXoa5Ci9WkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1OTcyNTYwLTBjMDMtNGQ0YS1iNzZmLTI0OWMxNTgxMDQ1ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlkZmE3NzEtZTM2\nOS00ZWU2LTg0ZWYtNTkxOWY0ZjA2ODllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo6GqsWLVPzdkGtinG9xB7m0Pt03ZmU77qNryaEkv7m7PqMLpskP0/6GsbTr0\nUGEZLKPpCsKuNh09F7tQd1buHqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLv/AFXXf9uP+kx7j64bwAbZjKzZMB8GA1UdIwQY\nMBaAFMhZ2xGAZ/FnYmVgyhk5QpskbvkcMAoGCCqGSM49BAMCA0gAMEUCIFt4q6BQ\n6k3g4w1Sw4aeEeXnaXDartWREmNTNDTVfw71AiEA4xcZR4j+0lQto6WmKh2tAzZd\nO780Belhn1P2DkyvP8s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfcJaYg3S8Kl1/0Uz3wk2qhGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTk3MjU2MC0wYzAzLTRkNGEtYjc2Zi0yNDljMTU4MTA0NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATc9s+Q6vbcc9wX6sC7ppbdlH5ghQ/DOWsAVNHUVPOtg/Nh\n8qRoQ0xZk66mIh2wco6pUdVa8jiyn41ohdtx2DPuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyFnbEYBn8WdiZWDKGTlCmyRu\n+RwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPgUAxhHKwc8p8tSQBRgXnPmyUs3/2XQiXLz9Vu84rRICIQDoOpfL7BQR\nJjHMjuVHhBG3Xw56qOWomagkSCTvgcDrAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAY52+7kOhzAXTx/2MWAi30XIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlkZmE3NzEtZTM2OS00ZWU2LTg0ZWYtNTkxOWY0ZjA2ODllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWViZDM2NmItN2E0Yi00\nMTRjLWFkNmEtNTI1YTVlMmU4MDRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxwY6xYBgHvGKtQPI2wbTirJcamvAsNo/uGsu0cyFvCw7BV0yE7ya4l4N5R3wDFM0\nTAU5t9dQQeHrzMwB1tCKuKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUu/8AVdd/24/6THuP\nrhvABtmMrNkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDkiOu/Ei/+O0Wbo4aw+YyyagPprmavJYUhAAB21JFY+gIg\nA5+vmo69jQMov7baFXftrHXkUe02DkT5QQ56TjGwBY8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4220", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4220` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVRJcoc8eyN9y/6C5G467oVDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzNTdiNGRiLWM3YjctNDIxYS1hMzIzLTdlZWQ1MmJmYjk4NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkzYjc1ZTQtODc4\nMy00MGY2LTllMzgtOWQ2YjNjOWI0YTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEThew8D+RpIH4PZ2OBKjuhFfZN0B8ggwPPoxBDYlLZhi2rMqgCYUpwTs6nh4n\npHL9sK2L2yFiQdjFQu1GlgL156N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNs0SQBOAqngG/hffN/F5W8AzchrMB8GA1UdIwQY\nMBaAFGEQDTPFb/9HH4Z6j7u87+gVtwoNMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAL99mpyycyz+wLrYM4A2rFVLNw+WKUOPb1\nhaXcnJU5pQIhAKNC3LtMORpaHsyenr/wzYwpo9QBor8MGrzuRdEKxAjB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQqtemDw5NqZ0dQw+loHinMbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzU3YjRkYi1jN2I3LTQyMWEtYTMyMy03ZWVkNTJiZmI5ODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPiQQdgReF762RX124iLomDcMccfRvUnsmIbV4zYFEPsTu\niainPcq2zhPaVdXNf2lPnm5B4zOcFt719qx0mFS5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYRANM8Vv/0cfhnqPu7zv6BW3\nCg0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOIn5x6Gv63i2Yxy3lVYrYSjajDkIlKMqAliuBqt1s/gAiBKmDGGclVy\nB/7JBPSMrpRkLPKFWrdzmL8gRNPllCsSOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAdhwcZ4xWzKCFrJnoRtN9JzKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkzYjc1ZTQtODc4My00MGY2LTllMzgtOWQ2YjNjOWI0YTViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2QwODMzMWMtMWQ0YS00\nZWQ4LWFhNjYtOGY3ZWE2NzVhMmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsw+dIVgEJzHGOqtaaAqWj8kCI5tupqS96W0wzpkrfCozPyqrYsx3dTuB3j1E7ziy\nMkH6nawbixV+0jxKcy+5QaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2zRJAE4CqeAb+F98\n38XlbwDNyGswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIBv3BF+UHzgzxemLQyZQzXU0I83WX80VuFb1evaLnbzRAiB+\n8bUtr9HGl5Poza/yIZ88bzICAaCOdjp+NH2XWcv0tA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4221", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4221` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAS2x0Mif6Ql6Oa6K9xHVKPJLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3ZWQzYTkxLTMyOGMtNGQ5ZS05ZjRhLTZlNmE5NTQzNGQ0MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjliMTYwNTItMzdi\nMi00MzA3LTkwNWEtNGZjMGNjZTc0MjM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWQgWQtehLEBIoLoFGh61s0zMk1Woz8Lowi8Kod49VsHyWB9jvkovzpYggDGO\n9R9MjjMl01u0Bgs8sUKvbYFeN6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFLj3HTZs52dQwq6J2rRYfuZUpAmMB8GA1UdIwQY\nMBaAFGe+t0I0DtajV9yy86D2luJsSQMfMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAxV9HIB9/Uj1S80Rqcyv/p4Zf2WaEmiUS\nL8SyLE8chUsCIQConP4VjyDYBlUJCpi6SyHFQIuF2J0Im2t9f+K7WnDEhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARxv1xxFaEB9ILjN1egV9su1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2VkM2E5MS0zMjhjLTRkOWUtOWY0YS02ZTZhOTU0MzRkNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCLodiLIQNGd7t+vwF2rT85kVhL9euuKc93zfp9RPdvRki\nwG+iyWG3NPIjY1Me5CpIn1JqhLiApvABbu0OJtjKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ763QjQO1qNX3LLzoPaW4mxJ\nAx8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG1SeyQEEhwW0bgyZLtotlKtEuEegQfyjPayk1UMqWe8CID3vcUESTfNh\nL52Eij/2Qcds/TEF5fuhe2eeBtPVOOXW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVtR9paK1t1T5kZPEOzpq0b3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjliMTYwNTItMzdiMi00MzA3LTkwNWEtNGZjMGNjZTc0MjM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTAxMzkzYWUtODQ2Ni00\nM2I1LWFhOGYtODY4YzhhNTQ5ZTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nh85H31bXtJnNqTu6TPdOFIxmcamPu3hrpyaxdcfRauFzUfhQHLRj5+xx/eLn6SO/\nH7y2BEar4zqRZ+yMAy16WaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUuPcdNmznZ1DCron\natFh+5lSkCYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCtcjpI3pzQLkzLQPwmVhynB85xIPVc3CkPwKsAs3qy5AIh\nAO+cTlnxqHPQAhscr04zt0Vv+wFeJMkLYzs7mOzZyEBb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4222", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4222` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUP1qgH3hJcgC06P5rNl9JeMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MDA3ODVkLWY3ZGMtNDI4YS04MDc0LTVjOTRiYzFiNDBmNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU1ZDQyZjAtMmE1\nNS00ZDA0LTg4N2UtMTQ1NjNjZjUyYzkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIfyyOcrqvTxKozao21YRnZ8SECiW4IhSS1leWaRvv8uTuBsDItRlrgLNjZpc\nxd6l9YXv/PL8cxCaVkRXPLWYsqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQiFYpdvze/D7vPKPn/gmHhNYBfBTAfBgNVHSME\nGDAWgBTFcBi08tzif7Sblw6+fkc0Zam9JjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD2GB9R9ROKNvxUlgxKsOtuU+ZjCWUX\nwDO7/uWGcFRX4wIgRF+2cVHhRLFjFh/9w5LgzdijYqZful+Tz6B68HyR9uI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd3UyZXl+r2YWM3z0iMNWsc4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTAwNzg1ZC1mN2RjLTQyOGEtODA3NC01Yzk0YmMxYjQwZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvLSWxbzXGI2X2kveazkGIY9iCFZTV+DjRXE/Wd0pUMERK\nTrOhQuCIq58tZeVFVg5FrTp/J5Q5MYQCGjUBQ0+Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxXAYtPLc4n+0m5cOvn5HNGWp\nvSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGy1HZKuuZTB0LfYikG329ZoTPTRnLduu56c0/8Ty8rwCIQDNRvv/KdFZ\n4ldp8ta0xmRfc1mAcof537UzQVl6THepIA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAbCJortFvha3KM47mw60vTkAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU1ZDQyZjAtMmE1NS00ZDA0LTg4N2UtMTQ1NjNjZjUyYzkyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWYwMWEzNjAtYzU0ZC00\nODE5LWFkNDMtNTYyZmFlMmU5ODYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nO3ILhA7BIhtsLuk/gRaraju0wk8IzFIwXtDq+EQvEgX0Aqp8OoL+PDtL7CorZJyv\nT8RFODWc5aEA37r/W/ATLaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIhWKXb83vw+7zyj5\n/4Jh4TWAXwUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIFyZCcqFY2JuC9TN39QWkyB2pYJe1T5g/JwqujyktrJAAiAP\nPw/Cxp+NqPaFITfCse4majJXmWZgC2a5JcdcNC5mOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4223", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4223` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAW9RCaqcu5L3QjhK44Z97ZuGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMjNkNDY1LTA5OTItNGJkMC1hY2Q5LWU4ZGFiMzkxNzI2MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNhODFmYjUtZGYy\nMC00ZmIyLWJhMjItMmQ5YzA4MjVlZDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf3trF2uaMShTqVCdnPavHd4iKQUeaF2UdeQNt+7BZTNVh75I48wt+hPJ1REE\nxkp9IG86A87AoQKR/gMOeYbT1aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWx6E84Zuf8EI8+lmdJXaQDhPCOQwHwYDVR0j\nBBgwFoAUs2twz6bGtpZlTM+m7NvOcsjNXaYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA7RXq3ZYE2Jyv\nuhrhFIOvI6g9ClfhyMa1Y0YHiwVxQ8kCIQDj25hRz8AKKUSrKwQKuBhZ2ViecG3n\nf0AcjV4bRVf2iQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT1I3R7QqfjAKqmKORBUVDM5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTIzZDQ2NS0wOTkyLTRiZDAtYWNkOS1lOGRhYjM5MTcyNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDNA5XKucLAmvMZM/yOA/DHML2GJITF1h+nDIPb+3igfNk\nrM4HP4ew0i/pZGcb07G2kcnnd9TZU8T3p3tfqusuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs2twz6bGtpZlTM+m7NvOcsjN\nXaYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXlbh88rJusqhN2Yj+i2xmnsm8gymQJxaX1xOe1WtXnkCIQD920f9/OPO\n06j3KZz6kRqSW7bjK47DME8QHGSFpeeXow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVEP10iIvED3xV7lDYALKeE7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNhODFmYjUtZGYyMC00ZmIyLWJhMjItMmQ5YzA4MjVlZDk0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWVkYzNiZTAtNTFiNS00\nOTA4LTljZmUtOTliNmQ5YjVhMDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYE4IokJcEaFFJT+AfVvsGuilpMUkwmOKcAdwOsn43aCI3quxiPZKvBk4butptFSd\n21CbbCncAdgwSqL/bD+KR6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWx6E84Zuf8EI8+lm\ndJXaQDhPCOQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCCQurpllek4gRBsK43BUbAsXgm6k22h/nXLj+Se5RAXgIh\nAKvkNWCKQ3cTyN15hOOWsvG385QU5qhtz5jebOUqXvLD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4224", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4224` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAWtFl2MXnODbdc6DVvz7c5uSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0OTFhYTFhLTFlYTAtNDdmZS04ZTAxLTc1YWRiZWQ2ODVlMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzU4NWFlNjktMDdm\nZi00NzlmLWEzYWMtZjBlMzkyZjM0MDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuA5j5rLvU3XhK7GTWV1+EE4t/vzqhAELx1ztQ6pkmsJHFnyfxrB3bIV1RKa0\nSrEosnFi2izaGnMQjDVvKZZbkqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh6eValS3F4sF8gWqkUMAkrhxMWEwHwYDVR0j\nBBgwFoAUE8AIPAwMvIUpNax2ZccUykLpx5gwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA4CuP8nbU/KNZ\nRzic9XtDQ4cmkcavl5Od6sJ+empKDLACIQDhUCTtOkrychL3tTLwfWjTsx2frjoN\nqDAgAUz4aZK6MQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARseI5n9RixGhDyuuTQlUSgqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDkxYWExYS0xZWEwLTQ3ZmUtOGUwMS03NWFkYmVkNjg1ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzVgCuSELq08XShfV4RFgsw4vvfSNLUb4gyhsKkd7MAF5A\nIaCkhg55qbjPm+l0Xu6OrTf3Sfq9Rg4iDkSlrLOko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE8AIPAwMvIUpNax2ZccUykLp\nx5gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMwsZYE1SKqQ7rKNUmKk/6JYKI6BtesUcgz/ImPTDYZlAiAnyaeBAO9K\nH2gulesYPpxLGvcF0uTECcS2i41jyq/8qg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVIvijdHFyBRST98vJWQR288MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzU4NWFlNjktMDdmZi00NzlmLWEzYWMtZjBlMzkyZjM0MDg5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmVmMmU3MzUtMjQ3Mi00\nYjIyLTk2MTctMTc0MjRiMTdkNDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJeTYROGyGX5CR86lGm4sZ/yqT5ZZP2SHQZLgEOfPMy52zTn/NwouCiw6cdkwfhq/\naE/bKnJW5qcG+0PGQlzYoaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUh6eValS3F4sF8gWq\nkUMAkrhxMWEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIFjpOvwJuLKUXoSazT9yDquJ0SOwmUEkljlVKSGgOPRQAiEA\ny/Gp7Qv58FWx23A7FeYxMPk3g87Js86BgCd2bJDkkns=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4225", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4225` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISATx9HRTzrgpBB1HD6VQrgVMKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2YWNmNDVkLTE2NzgtNDAwOC04Njg2LWQ2OGNmMDRmZmJkYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNiNTA3MzQtY2Q5\nOC00YzkwLTg0NGItNGMxZWE3MzgxNWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVWtrEnqp+Qh83QmBGMykub3XFV68XKHBlKJGki7gksiS0f1Uo0K+VSin2Ybf\neO6DRBZvGPH6/Yzwa9rKEOEhbaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWybdBeZc2AK22ZgXmsyhL8bQleUwHwYDVR0j\nBBgwFoAUN0PZjiF+qP85Rxx4+ZNCcnxw7w0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBTqZtWkVNnvArcU4gPwhcs\nEA34cZBymDR+0PmJKTnPMgIhAJo+aFEiBbz2Jyt+5NSjJwqV7RkkZNfAbSUdT1pH\nkMqh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAecVJhqlknwxzdVfD2q8DEqoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmFjZjQ1ZC0xNjc4LTQwMDgtODY4Ni1kNjhjZjA0ZmZiZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPtSpoZEIZL/w/ZShCo4TdBApgeDWWKQvmow5ii/QMpmFG\n0bGLu0D+tfUFH69VvGNki74DHAmy3pw/0c0kNnpho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN0PZjiF+qP85Rxx4+ZNCcnxw\n7w0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM/qqmQUvJQyl1QQON3e01s8DaDDQNttLW6asBJVSPuCAiEAs+prghw8\n50wVM69fON1eAZaxvPgSR0ZQ8FA1CdFzKEk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAdkCuK++PEQ0jDiVY+aXPT46MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNiNTA3MzQtY2Q5OC00YzkwLTg0NGItNGMxZWE3MzgxNWZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmMzZTcxYWEtZDE0Zi00\nYjQ3LTkxZGMtYjFmYTNhM2U2NzkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nblrVVtjEfEMfDgqLfSI+clyTo4bpkl1fFtfm97KCt2xUN3Ecp/8hEytmaiFatr0B\ngOG+DRONxoH+3V7UMO9syaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWybdBeZc2AK22ZgX\nmsyhL8bQleUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQC7f98BO3fhVV5JkpIbg5+PDoJ7nRgP4cr9nXNY8dOWQwIh\nALIUqajCHYLePxL7/injAvBWnINrw7UB7saa3nwp5hqi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4226", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4226` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAapQchLGGrT22ymzR4vuWhx5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4NDA5ZTU5LWExODctNDg0Mi1hYjhmLWFiYzRjOTdiNGMxZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFiODgzMmYtYjM1\nMS00YmEwLTlkY2EtZTM0OTIwNjIzMjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEi7jsW9619sINjkJL/d2OfONXKK2jGtfEzF9dzpjzIGesbIZjtnTZ2LnnqDp\nPNc9hSvljSgZTydFPqDhSgoIZ6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ8p/aOzeMFiS2+Ll0ztMJ8XPHeEwHwYDVR0j\nBBgwFoAUHDSxOrcrWui2kzv6jMPWyLJOH1kwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiA3pffJ\nlfQjCds7aDDjnEVBWJjnrB9rHRaV0Ta/CyvXUwIgXvUxfu4rs70+nalPtLdGQW4G\nC00XCjncNNxH0CJ1Puc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW6SrZTIfN6wJLFOEN/9dA4FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODQwOWU1OS1hMTg3LTQ4NDItYWI4Zi1hYmM0Yzk3YjRjMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHynOJL4ojJKysdJC1vnO/uUwQLCH/vjMe7NFeS+m8fmo4\nem/6dIjKPnxbz7dVrJ67fAFsUXI50dcC8HrO4WVbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHDSxOrcrWui2kzv6jMPWyLJO\nH1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMaEVS5jVqLFVB249tGehc36YnZzo6nurIl9dBirCHpaAiEAwAbfkjh7\n7mYF5OqUysttCIiwo5A0fn3hHAYGJqwCjZw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAX//NuQGVHKX4IglCGqzWjEXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFiODgzMmYtYjM1MS00YmEwLTlkY2EtZTM0OTIwNjIzMjdkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2I4ODc4N2QtNWU3NS00\nOWEzLWJjMjUtY2VhOTRjOGJiZDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMnWD+uygeVJ9iiibpj48sqE45ghkhgXOUs5vlHoXakS4rkEL+ynsPNHRH3ydvKJw\n20pHhWbY7yIwUaZFTFUbfKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQ8p/aOzeMFiS2+Ll\n0ztMJ8XPHeEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIC8ZIJII5CvOyuX0gcbYkNgEV7GCg1foRKQG+T0X4H+2AiAz\neysngEw3BR1qUTd3rIhqyCq5q4toO199Px9c7FCNUA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4227", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4227` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAXiVYfF01ETZQR6xODBqNILBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwOTZkYjA1LTNhMWQtNDRlYS1hMjA3LTFhNTE3ZjU1ODkyOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGUxYjdhNDYtZTI4\nOC00ODA0LWE2YWItMzQ3ZGEyZjNhMDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ5YQzTNf4HrxwuLQ5fWo0E4prx4F/K6JDkSYCRbHJkQWH3WKFPCfEg2CWRdd\n0aq5Dt05Nm7OmNIu7d5sAVy9lKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyboxKU1fNjvlV0Z4XEK0accBpOQwHwYDVR0j\nBBgwFoAUJta41m+qLpksi90+jVni4hbPhk8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAORe3f\nrSzw/X4CBcXDzs4A78J2pYMlyDn+UIZ7eQY0RQIgZdn8riceePutn+wx5z1zQoN8\nUQxwP6xRpXiLIxiFq1g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYlxbFPZG9Z4fFSSzmHuU1bkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDk2ZGIwNS0zYTFkLTQ0ZWEtYTIwNy0xYTUxN2Y1NTg5MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeWid0K/ZzL1z+OLpIeQQNMm056GEPiwdg8QSEGuUr2w2T\nJGS6W34/QUiQpyqmuxzMuVmoA8DVmXgsafFf4cTuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJta41m+qLpksi90+jVni4hbP\nhk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEXvvAkgm7iJEfTxurza8Tfri3AYveK60U6oL+WcHNcQCICPLhWuP1rLM\n725DccfB+L7Mu66zFZJqb03+X90WSxCh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISATcg1PDBJ64mgsWGNoaOpgYeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGUxYjdhNDYtZTI4OC00ODA0LWE2YWItMzQ3ZGEyZjNhMDRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzE5M2MzMmEtMzNhYS00\nOWI5LWE4YTgtNmVjOWJlNjdlZWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nB88PZCTE8KYye/ZQ8DEP5KafvFlmJyxqP4rlBWAZpkcXMGyqtYut7kC3qiuCb11k\n4UTlO/PKcet9QCqOONBoRKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyboxKU1fNjvlV0Z4\nXEK0accBpOQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDifjYWYqzA+qVph5dCJvuXQl9h7MQtENbdOmGjVMYtaAIh\nANfyP0WmAGLyG6u0QlouG6KXWlaA+iT5EHkgk//M93M4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4228", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4228` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAU6NGT/tM8J4LL+3cNDSa/GLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxYjY0Y2E3LTZlOWEtNDgwNy04MzgyLThlZGMyMDJiYjQwNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU5ODhkNTUtODBl\nNC00MzUyLWI3YTQtZDUyZjVjNjdiMGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEML8Setv/k2Sv6C58ndgwYZ2Ws63crrN8PUJYuE2slbqUzKY0h58WGDCkaQxR\nWvFrwAPnZ4BCEM9sW1qcArmXnKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCDz6nlTD1aEjtQa/D6ZK7O1dVzfMB8GA1UdIwQY\nMBaAFE8MFbHpFOsdW4Cp8XWrUeNrUQEoMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAxPsUEC4OS+SFAfFsf6HZzq4TRwn+asoN\nuXMybiE7WG0CIQDZE6Y5KaYw+g5Drja8ZRK7Ia+TjVCoybbdNPtEsKX4ww==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcc0HNfwMrVg63n46m8Ny63sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWI2NGNhNy02ZTlhLTQ4MDctODM4Mi04ZWRjMjAyYmI0MDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQc22sjOMUP3eFUrZVqCYJAufh0rlpjRAKtlernbj6wJZTy\nLlhKYjNOhXQl98ik6G2FOkaF2AF1w7sxTjP4+MFPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTwwVsekU6x1bgKnxdatR42tR\nASgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIzFOSVDV0CVSTwU4YjZEdI6mjOqt0wmLSWTEVtFY//5AiAklkvVn3wt\nlqNoUSjdVEYnTSmBXPQqRvclsPqtwVLUqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAYk8V8E6b1n+aHUIf8QsNtHXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU5ODhkNTUtODBlNC00MzUyLWI3YTQtZDUyZjVjNjdiMGNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmRmZTI1YjYtZDhhOS00\nZmY4LWJmZDMtZWYxYTljOTkxMTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvfnXo1DUQdv+XsB78DJXJkf4Sy7gtN7kH/BwG4uwORRxArmkVhRkHlm9vnHNMvCF\nV8C+solwnCjD40QwNWZEEaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIPPqeVMPVoSO1Br8\nPpkrs7V1XN8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDZTTn30YMa4w/6nDRev72KG1WojlQmYW9f0D8lm1z8fAIh\nAP0yMPX1P/2q3B5tZ2o4s4pUjcbyEFIjLnv0G2yICTvW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4229", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4229` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVHCXhiLWHRel11FyZ0XJvqcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlNGQyNjA0LWQ5OWMtNDc3NC05YTcwLTZkYmU1OGMwNzA5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRjNmZhMmEtMTA3\nYS00YTk4LWIyNTEtMjM0OWMwOWMwY2M3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEknamlacnAsnVofSL23yo5hFl0UwLTlXJikhBJhQEqG7Xh6/QiiVGMzb+IrJp\nB2axQooorPgL+AsIMgKkWmjoWqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI7Gg/7JXnkxFMlij3ZzbndJAjJUwHwYDVR0j\nBBgwFoAUtxr6ht++MXhMYB9Ob3DIW7C7jLkwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPUyChL4klPC\nv3X49soDaZp2oRX6hFjFG/x8sP1gLSrqAiBxyE5J8L+hecpMbWhEUzkW2FlxcBxr\nNhu/mlJAoAuQiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQLssXaKyTPIlII328iwhM+pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTRkMjYwNC1kOTljLTQ3NzQtOWE3MC02ZGJlNThjMDcwOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbMmX+dzqAFtDHS9t20CD8JKS6egBGofGoAWhRxZhQfbrw\nGUB80PLHOoq8u3eRMnE8ku1SbwuBbb8w3KAWnhkto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtxr6ht++MXhMYB9Ob3DIW7C7\njLkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYrSoQI5OTkHnUOs1V/vBdxwoueIhddQio3Nd1ZI3MKkCIDyLJ7YgvlaG\n+CjyfyV9Un4l+lH2jpQylW94NGFehwH4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbpmAgRzlRQShH5JZ31vymRcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRjNmZhMmEtMTA3YS00YTk4LWIyNTEtMjM0OWMwOWMwY2M3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDRhNGFmNjktNDJjYy00\nNmQ4LTkwOTMtYWNhZmMyMTU5NTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRRU15iFhnzRlKsHehYmcbM1RR+TamvrM1Gm8nb971SkYMT+9x/1/QcmyaBGq5/5z\nUvAaXu0G0A/56Y4jRXLmJqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUI7Gg/7JXnkxFMlij\n3ZzbndJAjJUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIFMtktgFSzFWOUfPO5UTXFLp/LWuaUSK6cgejI6MzNZUAiEA\ntl8u3Cvu0fHcMdjU5kfK+b3Mu/KiESkCqSwzarQKcmw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4230", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4230` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARP3431jrgUZf09dYzrr6NPkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2MGNiNWRmLWY5NmQtNDhkNC1iNTEwLWQ2MjI5ZjM4NDVjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBlOWNjZTEtZTUy\nYi00YmEyLWE3NWMtNGViZDZkZTFmNmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVXRhHitOqTewe+ySwJplKP8uCUfVArILu7ZXPupG6om9YDOv44ON2ZORUKRZ\n2v5nhJL0nHg0zQUcwvBuFpAX66OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhouPdScIYYK/wV+lGZ+PwIrD9X8wHwYDVR0j\nBBgwFoAUBBYTtG6SkZhSGmN2f4bzdOwXqgYwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgX1yQrWxqBPvg\nqbM+wBs6EG/f381yr0h95becCm7MsrACIQDWzpYoMjOml9GVaVq5fJyPziZBNggV\na9KwcFwh+GauYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXsjOKF5lc+GKJ2dpU8c4NbKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjBjYjVkZi1mOTZkLTQ4ZDQtYjUxMC1kNjIyOWYzODQ1YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwiMeB12sApT46jQJJI+QB3WV9fACyHbLivVntzep8VqR9\nU5i6LCHPfNvni3gOX8uwdZvWbgZ9XRYdzum3/MZDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBBYTtG6SkZhSGmN2f4bzdOwX\nqgYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIePyb8DTbgO1jn/NPYIEqFaECAGu6LEO2B4WrJwihPvAiB9fSfbC3zd\ndkHOCbM1ndoBHDSFrMH+SVuieMBZcJMGiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAVhOI75TK1RIVhsLW39LpO9nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBlOWNjZTEtZTUyYi00YmEyLWE3NWMtNGViZDZkZTFmNmJkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDZlYzIxM2YtYmU5Yi00\nMTQ5LWE5MTctYjMwMjM2OWJmNjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCTRYq0GKhsuZ39cSnunUDd1JtDtnrtF+Nfnz+3rQmTLec1he05uE/RImQoYnxlnN\nmorYTkutcfVaLP7Xk/N2QaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhouPdScIYYK/wV+l\nGZ+PwIrD9X8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIEjyovVspSBYXGIzGDSPq8AJ3N8gM+y4/H/KyZsktj1HAiBR\n2+SlTf0x2xOUB33usqZK/d+b5askJ5E3PHQykaVktA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4231", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4231` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATC53IpqncJ8RSqzSO5CWG5UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhM2RiY2E5LWZlNDUtNDM4YS1iMzNhLTc4ZDQ5Yjk2ZWFiMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzkxNGE4OTctNzQ0\nZC00ZDNkLWJlODMtMjYwNmRmMDQyZWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ8WBfZMwehtIvTqFvabg+yYNwVYTwdlzoVm2EspnRsE8VLi0HlnE1ZkZHI1C\n57eVbhw24mov8kiBeWqBScQ/kKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUElyDvWtuzjmiQqyw/IY8nhN9K4EwHwYDVR0j\nBBgwFoAULyucCw0c+rYzS2DL8F9Ktey3wikwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAc6/fQoJU+A\nqv3+WJ0vYtCAWbHDM5a1FbkqOcmB+no7AiEAi8BEwPGaXa8w6+Z48uEIka9QjXXT\nrK0lh/cJN+ud6ZY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd3qE4k+Rjb4Jfq+wEgIj0NCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTNkYmNhOS1mZTQ1LTQzOGEtYjMzYS03OGQ0OWI5NmVhYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLhMPnVvnC27xCLaoj0rM5of5moRVTyKcbruTNufOng0aR\nVwTHlDZxuh6TevWKRdpoJKpLRudQy+a2HjIMve4oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULyucCw0c+rYzS2DL8F9Ktey3\nwikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMTkx247sOJmHp1MQoXnIuGMiXPzWnqUrJPULp++u8MYCIDLTQXKGKcrb\nK0f3zUySZ+P7g591IY+K1UsgnRDrRMHu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAQke0wEo/RomIekbuK0zR6TcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzkxNGE4OTctNzQ0ZC00ZDNkLWJlODMtMjYwNmRmMDQyZWU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjBjNGU5ZmMtZTc4Yi00\nMTgxLTk0ZTUtNzAxMTNjNDE4ZDlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSMsRdk0PZmQH0j/jRypkf5vYFy+KTzsjteOQNRrYTIlVlBYKNQbL2kX77E6FkopD\nAGI9I6jZ7IRQaAO8LiPOhqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUElyDvWtuzjmiQqyw\n/IY8nhN9K4EwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCvU95UHJzk0FCuZ1qcMrzszwAWNHCDNXfbseuF6BDwQQIh\nAOnfaOuyUFRxai0NZaBTsZjz7PHgW5ZjM7xV4ZKkEu7a\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4232", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4232` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeRpWVv+9w1ksipn2fvhxZsuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYmI2ZTJhLTk3ZjgtNDdlZC04MDBmLThjNjhjNzE3YjlhYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FiYWE3MTgtOGY0\nNi00M2IzLTliZmUtZmE3OWFhMGZkZjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQtCtpwJLpE3a/ywSdai1TKEfkpUEkeVikovtIKubdQmKy0mrC5KsJp5mAv2X\npIHogy6azwMOG9nqAywjOBO0r6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPynjGUSn+rpETqlBKgAlo36xtNYwHwYDVR0j\nBBgwFoAUvNS93nLoKCrYAaWNaevpm+vVxRgwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEaxr3co6eS4hLMY0fN2eYNXkNPIKiEuX2FNOSYes3CNAiA3uJIh/gGo4Osj\nYB4bGy4XleNrJXShJ23t7WoWRO7YWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQvWmDNYW7ROC3rZczRl5BklMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWJiNmUyYS05N2Y4LTQ3ZWQtODAwZi04YzY4YzcxN2I5YWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkUrafm7JVbsOGNm815p2G7Q61cHgcfX8KyY9pslFzuVuJ\np+5jKZK/B0dS/wTOU8JaQ9LJT4P85ipJEIfjD8AEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvNS93nLoKCrYAaWNaevpm+vV\nxRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKbpT1DD2hUn19HBJfzVR4eJPmdPbIuL3lh7kjQpshyWAiBMX7/vAvT0\nGGdVE0Q17+tnQncVWGZ7XJdNyCfCqjASaQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWxchG/8esINlKNh0Ncp9D8wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FiYWE3MTgtOGY0Ni00M2IzLTliZmUtZmE3OWFhMGZkZjk0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDU1OWM2YmQtNzE4OC00\nOWNjLTlhNTgtMmYwOTQyNDRkM2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nc3qlsuRXB3t1jjZ2/Ote2/R+EKMWCL5FRn1KRrBza3mnt4X+9h6smAq9Lr+0tGeO\nYUwi8isIqDk4Lu09vXtbKaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPynjGUSn+rpETqlB\nKgAlo36xtNYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIAyJyAH5mCa4twUcjgsRPPGrPIsekfiMJn89rUW3L1coAiEA\no9eqPZlO0vXa9m9s5s7OKoL6Z2MFUpvB+IcfuS4+Xsw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4233", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4233` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUSBQdu7g2H+Fskhw7L5Pvw1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxMmFiMWQxLWY1NmItNDU2Mi1hMWExLWM5Mjg5ZTk4OTJlZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWRjYjY4ODItNDk0\nZi00NDhkLTk1MjktYjhjNWUzNTRkZmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqqPfF1X8rlXa3fEj0kYojbqGn/hlvzxrNd/d2gD9vc9ZqQxl5/jyvtk077uz\n3s2BdoXfwqXBZGZgFXtB1lWloKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpq25AZ8MXukb9rHco/qeEcNoOZcwHwYDVR0j\nBBgwFoAUQLhsrQPuSnj1VJTOWq5QSVKR5bMwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCrL80F4lDi5laga7BlOVsQJZtnJ66mAamEynnfGnFsYgIgIftIbluQHzQN\naXPZ9H18kG7jZ+CM0fREO6I/dJwwxEA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYPhGc9MfZv9okYeUlKCV6H0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTJhYjFkMS1mNTZiLTQ1NjItYTFhMS1jOTI4OWU5ODkyZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOn8jtiHb4vP+0ukaV2APG3prC1j/uT4GshGFRJQfDWfHi\nMXAboEjgTyZSYoh6nFYdGBehhDcDXG+pE1O5lD9Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQLhsrQPuSnj1VJTOWq5QSVKR\n5bMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSwW1rE6TSNgcClF/qz834iU6UERnxrAbmyVKFWtZO4sCIGzbpSwaHnHS\n0GfFQHC0yad3qE5zeMBIxxR+9htiAMon\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAYK7i8Lv2t8vxAfIh6JziCCHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWRjYjY4ODItNDk0Zi00NDhkLTk1MjktYjhjNWUzNTRkZmVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2Q4MWYzN2YtMWZlMS00\nOWMzLWJmOTUtZjA2MGEwMWQ0Mjg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n74cew/9g6CpvwsCaZ6AwV05Plfudhaad64/JDf9/8femYQRK5srk2chi3S631Qyc\nQvKujbjD9aqQ8/RdP1xP+6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpq25AZ8MXukb9rHc\no/qeEcNoOZcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIFkj78NXPJRj3263nhDw5vMXvMvKsyIpEOQEW71kopeHAiAS\n6licv57291E67fiI4ndZzEGpN0du7Ufswzl+2afdYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4234", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4234` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAYKv2YgFokJ/T99dmoqFPqh2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1NWViMzUwLTljZmItNDQ2MS05NDUwLTg5MTdjZTc2MGFiNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI2YWJmZDQtYzM5\nMC00NTBmLTliOTMtM2JmYWQ1MjAzN2JmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdvj2UjopTB0ecPRHF8RrKvBUazGrhxKiCEfDmwU2+j11O54rsOpqWshmK7nQ\nAGY55Glk7kp/ZjkxLBZbUQTTj6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxPzfUaBbMBfdtjwD/G4QvH0FJyAwHwYDVR0j\nBBgwFoAUY+Ruu+2Zp0lRHNmk3V38qn+0IFgwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIB7o\n2wEivHMZM88PW3fyAme2LMVn2WP/rtkg9zxrkC8xAiAlbuVRfYvPNeaC6Bvfo/P7\nT7BAQ8qBhg+xn5bkjLvhcw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXB6LvBnjQdUl3h05g6oUfrgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTVlYjM1MC05Y2ZiLTQ0NjEtOTQ1MC04OTE3Y2U3NjBhYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGLNL2PQ0Cc9T6JdeamUaS+hUOLOu604bHxr+D0fhW3Xn3\nv0T5Dd1YzoeUdqgXkfDjUomWgwcMBqP71AGS4QJOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY+Ruu+2Zp0lRHNmk3V38qn+0\nIFgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKE3p5DDK8E6dRNQpfyZDYdaQw1C7FpnyPr5PQELic9XAiEAy7qQdGlZ\n8fuc7W5t9hMnfnOifeZWZy6cGZ8iBwgPa8Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAVwe6GQ0BqOlK0cbXKAA5ld9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI2YWJmZDQtYzM5MC00NTBmLTliOTMtM2JmYWQ1MjAzN2JmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDliOWE1NjItNjExYS00\nMTcyLWI5NDEtNmJiZWU2YjhiNzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4ioLkqvaNPk/WaDPNKgeR2RkGfsc8fZ92GDLdB+3iG3pyJdqucxxGl1EDYAwdMNY\nSNlcuguQ585sF7uiVIVMTKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxPzfUaBbMBfdtjwD\n/G4QvH0FJyAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIHfR46ADqqqmy1vfiDsP5bhiW/lKgjMI6cUJBniXSSWKAiBj\nQQYHD77a3jS+LNF3GhvrCqTZUUjfXkV714FViKR/0A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4235", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4235` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAVd8D8c2sGk9/01J/ZTSKdFXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmNTY2NGRmLTE1ZmMtNDQ0Mi05N2IyLTQ5MTFlYzlkYWNhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQzMGM2NjMtNjlj\nZC00MzNkLWI1YWUtM2JkNjZjYzI5YjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzVWaKruAwIPH5dA85XBjJP4A6dSL2iedAAYu2vhWwU02OekDtVCIz33gVzVe\nYwe70IVsHau7QAqVY8Bk2TYVsKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBj58ea6dGuXb6vAd4yIJh5T30UYwHwYDVR0j\nBBgwFoAUMJNOY6cN9OLpGr9BzuETugdX+kUwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICYw3P7e/+qT7I6yL5Duyc8m4ap/O9QluxhUvvdZrYGFAiA5ABlm\n5At3dhyicvsqWZMeNRpJ3eQW/JfPo7gIvEdUag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQhNnnBZPva92e9gupeuWvJZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjU2NjRkZi0xNWZjLTQ0NDItOTdiMi00OTExZWM5ZGFjYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+W9FZaRn13RWXcI9/KZ26xqcFDg8palGsM3qzCwMfhrkE\nWupJn3z+Yq4S2BDUrj3F3vCzj6OcLNBFlT9RiFSno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMJNOY6cN9OLpGr9BzuETugdX\n+kUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXGnX/cm/LLZHzP8oOyk2HlA7CVJfsroBoR3nl4BbFtUCIAHkheAkelB8\nXCgUw7N/E7SRziCwMqHKZOwll53gXUep\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfoqdwEA6PxK8dHSW1MqkUV9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQzMGM2NjMtNjljZC00MzNkLWI1YWUtM2JkNjZjYzI5YjkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGQ0YjQyN2ItY2U2Ni00\nMThkLTkzNDEtMGZkNDNkNTI0YTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYzqxXGKcDUZBaahkeFyQQM8jSOFplje3h8Eqammt6ry233Zxg19c/swdJNcBOcep\nxIcfHVjG+NEEo5AljWaOGqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBj58ea6dGuXb6vAd\n4yIJh5T30UYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIDJkf44WRMEeV+SuEU62RaqzIlRoa1Xdjd+z9EJiFQnhAiEA\nk4bBH/mROvLPRVIna9DGzFu8I3F2CDLi+uuODEHWVs0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4236", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4236` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAYUbzTh8gJpvVigAtnpy6aciMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhMjgwZmJkLWVhZmUtNDU3Mi05ZmUxLTA2YzQ3OTJkMDFhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGEwYmRjMGItOThl\nMy00NDE0LWI0ODktNDNmMjRkZTdmZTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGv4qV0vdPkObTogsL3Ac5pJ9fTfz/CKZloEKCot+664x5unX1qIE1QEIBhnN\nIh026v3BziEI3JrDOnEyxMRv/aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/hauEqSZADHdPO5Rh0sXd9SljnwwHwYDVR0j\nBBgwFoAUZx3IgaPFsU675u/OLZYxGjdljA8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEq/TZRCOxCzzR+wWxt3+QTHFxROq5bAqsX9kv11z5SKAiBHtlfK\nkO1lFZtqEyX/o7j/WmpzQ2qd3Dl2mP6afz6Mbg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXVn4l/Hot8POfW2VDWlvhqkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTI4MGZiZC1lYWZlLTQ1NzItOWZlMS0wNmM0NzkyZDAxYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVclqXWvlWsKqE1LeBbXS7hO2d5WIbxrwTLy6l/DjQs/QS\ntakqbENFJWEUszDBD89vwUOpO1+dQL4mxynTcrZ1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZx3IgaPFsU675u/OLZYxGjdl\njA8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALLz4TQrst5Ct5QGB8qcOYHrldR6O8eB+h+WAW7QTjPbAiEAsFn8VMQV\nyFYrVky4Q3g56pcVi1Dng37zGfN8GHjNUoE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAUUHTvQ+N5p/+srH2dvJoiniMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGEwYmRjMGItOThlMy00NDE0LWI0ODktNDNmMjRkZTdmZTA5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGY3MzAyN2ItOGMwOC00\nOTY3LWE4YTEtZDZiMGRhNDFkNDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTzt/PquN5Hn/fYNwXqJMGpkcJk5W0HLaYjpsOpSoROtpzGt3syQEFIjnxFhGLwER\nBqItzo+78q0ScmP/K6rtEKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/hauEqSZADHdPO5R\nh0sXd9SljnwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIG5ep5wjQOYIrvTDgtQc+tVuo5YpLCRePzwdPgbhFoNnAiB9\nP5z1pxkDqIxWaSFK7sw0gl4NWGhPIgMgJN+A+/OGCg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4237", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4237` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAW80Y8eeNGwns2Q5F8jvpHnjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4NGRiZDI2LTBiODItNDBhNi04N2U2LWNiNDUwODAxM2YxZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhiYWZkMGQtOTYx\nMi00Zjg3LThjMTAtMDVmMGRkNjUwYTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi1bSgxjY6lm6/hvclL+CR7/3uaS78iAkBncrFK3MN1EcFjUQ818jLSIjQOKh\n4bLoZAkx+RYb6lGtIGn1EwDuXqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHwkdOgrKh4c2DeKq8prA4aUPSFkMB8GA1UdIwQY\nMBaAFNC5WL3Cmd2f/yNXTIdmQabFJCGMMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAmcsh4eVj5MfUNN7B/d6yTDwWJ9vWWoRZ\nRdbQfok0Y/kCICwTFG8cUbCSofuvrdhX73qXeni2YnJVx6JAkSNi9t8n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS2LH1DSC2VbnC3UvciN9d+sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODRkYmQyNi0wYjgyLTQwYTYtODdlNi1jYjQ1MDgwMTNmMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToIFxdTbJoSq26P/NcK51CwdPfUwPLaeVFUL0F8IskocNn\nbgKRLuVz82gP1nJMtHH8uhKiUKm+GKh1+uWdJPBro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0LlYvcKZ3Z//I1dMh2ZBpsUk\nIYwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPOlZPUcEvZ+XsZpdORlkL8M5au/G0Z6BExT9ejHjdwDAiBhkPkgucu8\nHIC7L6SOgvYa9sNOhrjttwpM+tWNNkDAmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVZBCJKv8JaoA3K/h3U4XKEqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhiYWZkMGQtOTYxMi00Zjg3LThjMTAtMDVmMGRkNjUwYTNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjFiYzVkNjUtMTE4Yi00\nNGUyLTgwNGEtNmRmZjVhZDZjNGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqzIzlzTOO9+GF/Z+TLSpp5dd+bXVL0vYi0r4cJ/2ENbf1eA3M5wg7IwLIeZbfRyf\n81WfRkcYgzWrvr4eFyI/dKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfCR06CsqHhzYN4qr\nymsDhpQ9IWQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQClQJRs/Ta+J3Hu2cL5qWMdkQq7IanWA9e6TKJcOlIynQIh\nAP6HQfpHXYQqKlmwAs0XQihFruywyUA4O0Xs1b8NRh4N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4238", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4238` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAS5ZR1Gtf8QBGfUs4sVzkKIoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZjg5Y2ZhLWM5M2EtNDQ5ZS1hOTEwLWQ3YTkyMTVkYTIzYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIxYjllM2YtYmQ5\nZi00NWQ4LThkYjktOWNlMDJkZGUwYTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQjgb6Bq1p6fjn03MYOeWuiH2z3r1LyBJaERJdRr7xpCA/yLOhxtvz2gT4CUk\nut5rrPFJ5PEQWduVZOUpFzVkz6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUka9hXUdBLi7kwwNMrensuprrC8UwHwYDVR0j\nBBgwFoAUnOYJb6XyN2J/8OgFJp7VpfmofxkwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgZYMC5dg5WbXb\ndYRrz84Jv9piHOYwXEjfhVDxztvfuysCIGR92x4QyKrGxZ5WdZORYtWzhl+X5ogZ\nEGIpG67qkILu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc3u5+sHvB+s2foLcMtTeF73MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGY4OWNmYS1jOTNhLTQ0OWUtYTkxMC1kN2E5MjE1ZGEyM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFLe9M1vIs2e3zJxmnvD9Q8Vmg1i3IDYrFSg0SPxFjy9O7\nFPeUFD+BpPPVIkPrSSCPG3r1OlSwbemcJPTYLzZjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnOYJb6XyN2J/8OgFJp7Vpfmo\nfxkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJuVi5x3cx3Dye5dvodFu8EgrKGfnmQgnC6g91tj6TySAiEA6VgYJRd4\nudpU1dJkKJPgU7E1TqMweqrePl6WiaNYwyk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAeBAwdznnvWdZKIjWBpiOM+VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIxYjllM2YtYmQ5Zi00NWQ4LThkYjktOWNlMDJkZGUwYTk2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzllNTlkYTgtMzdmNi00\nYTNiLTg3YWItNzFiZWIwOTJkOGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nY2LGg83IZZOdFkOrFMwH/uj9tl03c1t8+1YNHTHFRdpZ0CT+rJt9DMhBHI+0gDTm\nxLN5nvHJA3OpzV7GdhxbmqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUka9hXUdBLi7kwwNM\nrensuprrC8UwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCoNmyItcGpcGtXyqKmGfr5x6HwP5JXNAFizJZaHGR2DAIh\nAJJgBLiHS3ohI0oVZEct8WrCWwNnNucUCzlOYkG6eLGb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4239", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4239` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISASJ3qKlwR5JQc/2IgOEdAjejMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MzI2Nzk4LWRkN2UtNGM1Ni1iN2U0LTEyYTAyYzgyNTlkNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUyZTA0MGEtZTY2\nZi00YzUxLWJkZWMtNTZkY2RkMzAzYWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDq0J6dGke53gi09PgjvjXaRK3rREA5upejWmoQpDFJVkQSfXYhu4DpDc6iAZ\nu0sS8gaEd02HDItNEs0QwSDD86OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm5uYaX1gnKvDhRXXpWQAq7lh6vowHwYDVR0j\nBBgwFoAUespQAtSNIJQdmrHblrfDxDzRCpYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgCUO/GQ310y8y\n3RV5YYLPV2auf64ouztvoWxfw98BFNUCIFeFIbjJp4PO7PHTK3wNEoQI9UzndjxV\nACvPPNAjQd4j\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS4QccpVk1m33RQK+d4c1WPtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDMyNjc5OC1kZDdlLTRjNTYtYjdlNC0xMmEwMmM4MjU5ZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARERJDB9tQUTj/uzx/4NDG9YfEMiOTuwumJLsg/4eAPTpAF\nixTMIVtNqM5GSFC8gALd0+ki0xmKSlKV6hZQRdfRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUespQAtSNIJQdmrHblrfDxDzR\nCpYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALN01PINVJtqV4615UGqOZ+felEAGnSrQ5Ac/ySaUjtmAiBePzdv3ibt\nwDzn9uePAFAWhwiKUep6Gd3vg6LGH/vRSA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAURRwFS+vDxvUMePIGeSZskNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUyZTA0MGEtZTY2Zi00YzUxLWJkZWMtNTZkY2RkMzAzYWVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDAzZWQ0NTAtODJkYS00\nOWY5LTg1ZjItNTI3ODEzNTdiOTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvS+QMgsEM4xV+Gg756Bge2+wS7ehtQ+4MD8rdb1YVAdPosdIYe1SyEM8FSeQeHFT\ntYfpAgHmptGvP8ckf//4ZaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUm5uYaX1gnKvDhRXX\npWQAq7lh6vowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIH+mMJ+JzTL8bYruacX4CllfhzFaSxloZEK+RQosIdI1AiB+\nnWq81D94Uoj0YnK9z5gHIIs+swLV0IV+FxaeUzX33Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4240", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4240` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQoeTCDOyjzMf8Tg+J2UThAwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1ZTI1NzJhLTM1NzMtNDY3MC1iODBiLWNmN2VkYTA4Mjk3ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFiM2FkMTAtMGI4\nNi00NGUwLTgxZTYtZTVmMzI2YWU1ZmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs3EnUdsoFE9R249zHiv6FeJ3+gNLNnm6hKtnKBbBS2T0+WOgl7URCzXyFXLt\n7lNQo0rOohH4MWy9gF3DyK0OnaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKCWue/eq8CjqDoFdwuGBPkzF2v4wHwYDVR0j\nBBgwFoAUx4H1Yd8ettIba3I6n2i6Co+dI4IwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICOwbdqqvtr5\nGQK8Jb5T/GoKIISvOg62mzAYcef1gniIAiEA0zseOevtso+vMx0srPEUqdiER/AJ\n7L8xjhiFKHYcxgs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdHGt7RulHAddZAfS6BMYokNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWUyNTcyYS0zNTczLTQ2NzAtYjgwYi1jZjdlZGEwODI5NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhPr4pigTpMG/BnApKvmWA3Gskkv/78BLIt2QvA2GAeApP\n5ABWL+orf0f0xyMqmpsEzaooCcoJSF8bgVh7BGlvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx4H1Yd8ettIba3I6n2i6Co+d\nI4IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV3cca2cQ3oHU+SHBwp7zcPpoTaM4gUlMpgoVhIHLYYICIQD9CcSVqqGi\nylIVifn+rIm9Q8G6t/ewRKiuWQVO0XKw8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISARmWtzHQG18D+6PSjNbVo2UnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFiM2FkMTAtMGI4Ni00NGUwLTgxZTYtZTVmMzI2YWU1ZmZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjUwMmU3MGItNTM5NC00\nZDkxLWIyNzEtNDkyZWRkNGNmMGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nB/bXmorNti27odaoo0nTFYhQeSWGSsG6bXgRUv3ksSlilEg55+CWnebUgIcJSfSq\nlAo2xp32iLuYpLMUGytPH6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKCWue/eq8CjqDoFd\nwuGBPkzF2v4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDZKQQ56g/Mb6ZpcP1BaT8gucK3ck7gjO4bJf4tlCUEcgIh\nAOw/AbmyEXp5Cb0T2nXtgu8uzKktnXzwlumXYR8dopuW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4241", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4241` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXlyv8jxHa+r6QN3IFfz9iSCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljNjAxOWRiLTRjMWQtNGU3Zi1hMTM4LWNhYTg0ZDkyOGRhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY0NGZjMTctYzk3\nZS00MzYwLWIzMTUtNTAyN2RhZDM3YmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENvFtV+4+bqOYmWa6DDBc7SiVXbmi5/rAx0WnVYmoaVc5LJOvMa2sYC3hE1FW\ncY+bdZYJdnJsorYfqamGAzEdNKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk7ro4hlGPjbx/bfHRnZPSjLrNSEwHwYDVR0j\nBBgwFoAUEvPsoS9DmNE7/vqMK9qUzZ0x0/kwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDqgzlM/+HSWEho32B0kcHeOr9502gq8mZ77Uyy3Q1XlAiEA+F86nL1WA+kb\n7B/455D6MgBjMh4R7YGsTj/oNj4FDTY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQuvOPCJX/rLI8qU0g4Ov53EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzYwMTlkYi00YzFkLTRlN2YtYTEzOC1jYWE4NGQ5MjhkYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaU3IxTfs/+d4QndKAhWnnywS82r0XnKfIC1beCm9/4oqo\nD2mQJDaAcenIiqKQCtG2EHwHRYpwolDdKuQ9KDX2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEvPsoS9DmNE7/vqMK9qUzZ0x\n0/kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHA4CBig88S7QxRNU0mcIsq45vAhDpNwkJtriE2ucktECIQDITD6MFJw5\ndPmPZnuzPErGEqUaICC72BnKVifv77hkMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAUQ7s48WkZb9K8lsQhPz5NWlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY0NGZjMTctYzk3ZS00MzYwLWIzMTUtNTAyN2RhZDM3YmRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTUxNmMwODItYTUyMS00\nYzVmLWI0ZTItNDY1YTkwNjU0YTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nD282Bz2bIqUIR5TAizkATdSgmXpHqERCRU5EhXtw3h9kqDtKUg/r49bud7BCCEsm\njIfBMqRaUYLFYERt7LS+mqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUk7ro4hlGPjbx/bfH\nRnZPSjLrNSEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCNT2r1Cac8YAKka1qht+ntqZgTVW/Pv4YCBmnxB24/SQIh\nAJON/jtuQdFlx+Asse9Xpm+LJHgZlODEL1S9gcUGS1yZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4242", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4242` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZCLOLYly5seQLXx62GeAPcbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMDczMjRkLWJmMDAtNDJlMi1iOTAyLTkyMWRmMzg4YjJlNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdmNzBhN2YtNzI0\nMy00YjYyLThlOGUtYmQyNTZkOWVlMjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0tJ0kzErfsQD8nPPlS3aH4Of6bGeGeneTytzV+uomtRjufzu3OESMwulLGxx\nAsectfell11vffTkMCEU9PJhWaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOyLJWy2bcaSYMirCgnFYTcP6YKAwHwYDVR0j\nBBgwFoAUF2j+iSsEQRwKjSrX/zm6OnpW4WowNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICd8thWfTBjuhL1EAB+UDD0yngA5Lxy+gr660wy20sA5AiAhwst3tuX0Ucgy\nrNAFhpsLHhC/4jOhiPEHAyEr3pbXJA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYmaPt7ZpDLLs/0GssSD6/RUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjA3MzI0ZC1iZjAwLTQyZTItYjkwMi05MjFkZjM4OGIyZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKZChpXGE8QsNgqsusjsGICmBOVsfBW610eJ9nDKJ+nYXu\n3nS1TfBmEL6WP7mP0EsArme/FsJhsUgPcx83zEG4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF2j+iSsEQRwKjSrX/zm6OnpW\n4WowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgT7ZW0NTNnHe/NMP/366+e9P0yWKOSFDSxIsSSzvcfMACIQCbNJM3fXsR\nAHOATeWvVjRIs15bS6hqESX4n38p+CwMnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAdvGzm7b0SD+faWeXefpdZguMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdmNzBhN2YtNzI0My00YjYyLThlOGUtYmQyNTZkOWVlMjJkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTdlNmJlZDAtOWI3Ni00\nZjk2LTkwMzUtZTJhYjdmYTQ3ZWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEYco2XeH54Qr4nGSIgqZHinQwfbvpqEiszDHuTOoA//k+NCR3++URmipKx0wx6No\nN5xA2TEQaJ8cuyUyp2Fg/6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOyLJWy2bcaSYMirC\ngnFYTcP6YKAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCPrjtgDVO5sj9orXURazmDW1QOypuo0kyupOvapwpFGQIh\nAICOSy89czFVM+QWu9nuKRp7/s4LCvqa0thDHyIr3CWF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4243", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4243` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAYIJRszV70bBeeqXuAoDWtZFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzMWFhMDBjLWQyNWQtNDY1Yy1hMjEyLTExMzhjN2RlOGMyYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODNmN2I3MmItODEw\nZS00ZjFkLWI3OTMtYmI2ZDJlMzIwMzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEedVXQP28Pn9bOPg7BYULWknPnewxkBEqp7y7pk7bNAXkVlEs78uceGM+LNEX\nTf8Szv/qD4y10Tjk1tYwIulSKaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3lZxix9/qV3FyNQ8llORWgUsk6QwHwYDVR0j\nBBgwFoAUKapoeZl2Lsj/Qdl7xJ2FSeolGWEwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCP\nOtYzxoi3f6oDQBX0azwfMbDtj7f9DLq9EL9QSAmI5gIgfKrxovNYFIa+GCHmVSPu\nHW7JxSifDC41LwWHEYDeKcM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVfx6Nf1Y9HfCgeYPLN9X/5AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzFhYTAwYy1kMjVkLTQ2NWMtYTIxMi0xMTM4YzdkZThjMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARl95bBQC/+wjUOOr7uXvXWpfsP+k7PJf31eHzNRAyrm1/A\n70gezYQ3tbjjWGUi+LYWB2TFCEm6gErnVHUT3c+Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKapoeZl2Lsj/Qdl7xJ2FSeol\nGWEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFs3hvYrXSNp7b2ajZvqzBCOQv5dD18ueXoEeSsA4jjYCIQDg7Hm2JMRJ\n/12jt7hac3/CgcG9Cf1mjKCwyauOMfCbNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAU/cRIBjyx4YHrOEldOiAn3KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODNmN2I3MmItODEwZS00ZjFkLWI3OTMtYmI2ZDJlMzIwMzkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjcyMTk0NDUtMzFkMi00\nY2Q4LWE3NTYtMzlkMTNlY2I2ZWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3WOM/xJA9wF0DjEG2uYRBwZaYrnHzXcdbvXMW2hGKY085gO2YDJq6+X2llzMdHEK\nfS2CPLXR5nBVn3pVGHeILKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3lZxix9/qV3FyNQ8\nllORWgUsk6QwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCICxGnAFAb3t5kYexAT53t9Vpm8lapKzJhvNMhmUa8TAQAiEA\n65GeOZ1GjMMliJOBoW9hnR4IViJbacfLJDI5jqlRybA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4244", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4244` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAdAdU5KxT0y1Yj5psLHC5X7lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NzNhNjlhLTY2NjgtNDUxOS05ZWVhLTlmMDFjNTVhNWYzMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIwODRmZjEtNWYw\nZi00ZDVmLWI5OWEtYTY3ZWE3NmVmYTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESm898px81TpPOR6t6pqbE3NWT9vLZBUCZeL/Y3OvM5iTnON/MZbK4aQ9/6Y8\nTIDvmlp5760y7eAw7zJVUACoEqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmOgSw0lA1337grqqK3h9FslpqdIwHwYDVR0j\nBBgwFoAUaZdtpBTgtX1M+U2WDXuC25UaBRgwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDJxsDa5o2nLNTe9iMPsyJG8UGyrrVFt5XtNQVesm4NuQIgIjrg\n75JlZ0hOmpC76R5gX5qEcQ3m3unji8G/9ulyido=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUFm0WUBDhCi0ja0B2o8NSnqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjczYTY5YS02NjY4LTQ1MTktOWVlYS05ZjAxYzU1YTVmMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDWvSVRE8d944MtwPTXLhgp58IVJ1z7ohbWF4jQPvAzNhw\nGEWwUqc7vTce3zxsk+7KCGKsm5dAFEkfKLh+HHMVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaZdtpBTgtX1M+U2WDXuC25Ua\nBRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOV9BTE058p9BRTbwNw3Jce+g9ORMg+C4aLXL4u+jEjnAiB9aHngADH1\nTMtaWOpnQ9BK9angx8AXWe//+xpbsNU1yw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAawqyxD4jUQKtTlkQQp1deDyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIwODRmZjEtNWYwZi00ZDVmLWI5OWEtYTY3ZWE3NmVmYTExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjZiOGQ0MzItOTQ4NC00\nZDI1LTllMjUtNDQzMDE3MzUzNTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvFSGlwv3GA01WyrN/6BBAmlnS8I9Al+DpXmCx6E0Bj8Mbr/aNLq0aPSBQmxWuNl6\nkKxoKnbvA87g0L/MzrIczKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmOgSw0lA1337grqq\nK3h9FslpqdIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCZEjcnG/wlXHcR9jb9dAJgPOXoGfxxy8Ga6bs2GX6yGwIh\nAIGc3uomxWyrfUhCPWpmw2BOKnZmd61qT37mvswzvHJl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4245", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4245` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAb+NVcMpqfvctrs+ey4Fecf1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyOTY1MWFlLTUxMzUtNDI2MS05ODEwLWY4MTExNGJlYmI3YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjczZjJlOWItY2U5\nYy00MGJkLTkwNDMtMDE0MmE3YWRhMzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnZIE1zyTWaJk7AKOOkGmDKDajU+o62Pr+kbqq9G0WVRFNq9dQbvrk9Sym3ZF\na5tQ9iC1WHZSL50f/9kDRHiKyKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkZyIo55lXLmUQcmo3sBhuHU7+SMwHwYDVR0j\nBBgwFoAU5X3bcc2WOcbV7qjk50HSxItGmhAwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCuSzAQAzebnV886xTY2EqWOG1JspUTjcKki4pvWrqjkwIgBvwg\nVJ45dL28Q6R6YoeDlJTH+LfCQkLfD4+uyXBGUbU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaDvU7Xa1QPnXdB2C4j/ABsuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjk2NTFhZS01MTM1LTQyNjEtOTgxMC1mODExMTRiZWJiN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASE2zptkKB4iWtOUEiC7k4P6m5Q8Lic6+YsKvNG1H3434Dq\nC+Qz7n4HHvuEZjWh0nyn3j0MozWrDUv/EqMl1LqDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5X3bcc2WOcbV7qjk50HSxItG\nmhAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF6DRSr6JFwVny148DSFHKTdIJgKVJEeg25MtZnyR5r4CIQDKRollU3mB\njC3rcRHhG9mubj16sjMyIqVqpPWcUYYzWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVf+OlAbPgZjkj1eeV8qeyIPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjczZjJlOWItY2U5Yy00MGJkLTkwNDMtMDE0MmE3YWRhMzhiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWVkYzhlNjktY2Y4Yy00\nOWNkLWI5ZWItNTM1ZjBhODkzOTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbswH7Msl5wTAIGmP5wwm841cY62cf8u3l9ULRR98HmQMEjfCkc+/s8qjYkMFbOld\n73lf88QUX2HdKyMgwqeqjaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkZyIo55lXLmUQcmo\n3sBhuHU7+SMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQD7f913R4oWR4JgGkuncv7J7wiBRobK+YXKdXb4w2M/hgIh\nALuWr/Qu+QeBHKtPjw8FPjdHr+9/WtLz6bHAYWwYpUyO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4246", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4246` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAXjpqP42aoIdUqJG0NVp5PkOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMTU1YmQ4LTJmYjQtNDhkMi1hMGRkLWI4NGNkMGZiYjYyYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM5YjQ3ZjctNmVh\nYi00YzY1LThkMjYtOGQ2MGMxNmI4YTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC3KXLGz3UTtncn76hs244OYd6jBrSgRTum+DPTJRKC+/lKu+kAsSGdwe6KbB\nUcWm2dXzOA4yk80iLNvE2arE/aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTeLRdecPCAGywtZYUJM+TmTXZNczAfBgNVHSME\nGDAWgBRFUa585SHotm5y4wVNpcSBiO0YTTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCkzSgSwV9oeBHn3kJxKbrQlmI8LXTn\nYwfZiu+7+4zVoAIhAKeG944WWs0WO4/5qV/QWYJzZwk/ZLRSWDqObDkyGD1B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXryVy3i+05+xNIJSVuULbFwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjE1NWJkOC0yZmI0LTQ4ZDItYTBkZC1iODRjZDBmYmI2MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxI5zepi+sAXHngZgD+X4nun+Fsf/TueZ9b4H405mPDNDX\nHuwTvtGLDHRt7o0q0qJFUYjV4rbNTVzwrXqOJKr9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURVGufOUh6LZucuMFTaXEgYjt\nGE0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfLqMLEWDP5GOkNtrh1N723nsUqD3ahfja81THRi8a2ECIQDPGc1SadPq\nDRMuy+zQF5IciWf9lU0h4sn8JLwXuJsEpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAT+4yXTTJfZYZe2iUtYxCdlyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM5YjQ3ZjctNmVhYi00YzY1LThkMjYtOGQ2MGMxNmI4YTRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjk5YTAyZTktZjg0MC00\nZjhmLTliNGQtYjEwMmE3OWUzMGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEXGFWFIQOS1Reod1S9CYqlWQ48dnJE1nXXDq1EPesgSI5aKuLe3OoLNslkAHaAt0\nb1DT5ogvkbDyy6l98LSSyqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3i0XXnDwgBssLWWF\nCTPk5k12TXMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCICLMFc6yVYXbQ8mFM/fAIqC+mV6FTVqn1W5rwGLHKQw1AiEA\nwLvQOiRv37KUJJ+kELuB/tRE3ScL6zjMQ1eNoGhwxj4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4247", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4247` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAdI/GEpANlEnCQvmfV8eaqkiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNTc5NGJlLWI3M2YtNDFlZS04YjMyLTk5NzA1NmI3NjEyYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjcxYzU4NDAtMDA1\nMy00NWZiLTk3M2YtZDE2ZGU0Mzc5ODI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmVmN/xT1YLXU0n0cJPgR2yFBmZtihH6jyK7K+1nlr7z0nJaWC+gMuURRC1+3\nOzNwc19LvvtxeuBhfihm4zEHfqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbqI5gDjBhJP5VK5lR2NEbRt61JIwHwYDVR0j\nBBgwFoAU6mSx3CdSl8JKJMGhHuasOSL51QswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIAyjZsuJJHlY\n/UdbLexEvUC2z/Mft6kzmbYAjXlO6fQ2AiBYD5l7gN06vCqb3bEzPwu7JYduH2sh\nkxFVreGK/iZAmw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfDPksdTsZF330B8Rd8wrKryMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDU3OTRiZS1iNzNmLTQxZWUtOGIzMi05OTcwNTZiNzYxMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGm4VBqZsFhYToEMzfdWvGIC15gLLpXnyhpsp3s9kWLv3e\n7yO7bvtgmu/JkAulm3v6orAHBkIPuw+WXFwmv9t0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6mSx3CdSl8JKJMGhHuasOSL5\n1QswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJTu9Hi5r1iIrhpXoF+3VBdnq1Ky7h4/mrs7M8A1XhC1AiBiN8L/KTO2\nSOKRpzsrRhRCE1UxK86CYqgIY6floIQIdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXJFA+OF+PcVCOSXiw7y1Ru2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjcxYzU4NDAtMDA1My00NWZiLTk3M2YtZDE2ZGU0Mzc5ODI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDAzMDU1YmEtZTZjZi00\nMWViLWFjZDktNWJmNzRmZmUxODYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGHkgSSH1xBUC/xUimoQSAKUM5tCssGFIVGcCeXnqGEourC8BvsGX2bPfA2rYkYEy\nYuM7U5eSG4EBMKURnxx3u6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbqI5gDjBhJP5VK5l\nR2NEbRt61JIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCA7f4WmfDyWLjWAio6TepsLQzmcpbHxFnVcwqLr3smIwIg\nNjVtdrQNqpryHGFrDsbfGyEEeYg1IY7gOTxE3j5BTgA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4248", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4248` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVrnEgBuwGHkrcKRLLdDgBtvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1NzcwNjUzLWU1YWQtNDRjNS1iMjY0LTc5MDBmMTZmMjMxNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDg5ZGZkMzYtMTgx\nZi00NmIyLTk4MzgtZGYwNDA0OWViNzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4tQXu7W96Qv1brUnYhJ+ID5+z+xtHEjZeCMwWJ6WsW+bv8bdTMRzdg+WyxeM\nyn4lv84Fth20U3IHO20SoLPn46OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiKABLjjnfyFa4QgZ9y7/t0xZ4MUwHwYDVR0j\nBBgwFoAUyqFaAHJU9VXFWcNUYPo3RjdrxZkwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDu77APlNYo\nuu+D5lR4w/R0//hrppvKtnj+PrTt731UawIgRheciEt3P6APwBs3GFi8FRbNLvZn\neBZw+v8UM6ym/nA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXj0YO6DX/NXhGGs14eETiwzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTc3MDY1My1lNWFkLTQ0YzUtYjI2NC03OTAwZjE2ZjIzMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARI9wU7Es9d5WQPSNYYfolH9b33Oq0UdmsWAkuaJCNlkvlU\nPLauE9RHGGfJ+Z+7NtbkK8DPSR+xLjMAun69B25Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyqFaAHJU9VXFWcNUYPo3Rjdr\nxZkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJASNl6t8U+qNaekkc/591bMnbH2jgNIbi/ORSZnFVIkAiEA0c2ZOf8l\nvMHxRZy302D4eaAtuJvDGjZbB+A0MXzEDCM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAcJcSVxo5j+iFZW6CG0BnZQCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDg5ZGZkMzYtMTgxZi00NmIyLTk4MzgtZGYwNDA0OWViNzM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzNiYTNiZmEtNDU2OS00\nMTM2LWE3ODgtOWYwNGVlOTMwNDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJOxqbP9gDwC3gaW2Qo4vQVZXC9iXtg32UAZrHLBb33/yJPBdgVNuYF5xbRE1uV1d\nYpujcqWbD0Gk04cy1MviL6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUiKABLjjnfyFa4QgZ\n9y7/t0xZ4MUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDeKKNA20b8VIdTeHJG+C7taT/7dHp5bj9kTT3DN9PoQQIh\nALBmsecmyQ6ndj+kTDFIKx1vipuY6lQlNpPIpCmxn9Ok\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4249", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4249` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAaAQIUT/7rpeaT+tjryaWh3SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2ODdmYmQ5LWJjMzItNGY2OS04NWZmLTVjNTc4ZTEwMDM4ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk0ZWZkOTktNTIy\nYi00NWVjLWIxYmMtZTVmMWExNTQ0YWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6ZLPzme8M7WN2t5sXI9YzvyZ84dVlza7xeekEcFBMpZHvGip/IpeLPQrB3K/\nq5oPLyNPv5wIoSVhMhyvK9P48aOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYWDSVw1/idIy5yYoPRPXQOgmAyowHwYDVR0j\nBBgwFoAUGmpahJ1wyDgEdGsR9DVx8IabqEkwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBqIELzlJhB\n+dIlQu9D5oeBgz4IuzQC/IojDIUrLbvW2AIhAO04BE1wk7gxCQ0HpPnrmp8VQMtz\nsyBRhMjEIRQcX/fs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATvQ8gGFsg3ssYy5ZxUV8gAGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjg3ZmJkOS1iYzMyLTRmNjktODVmZi01YzU3OGUxMDAzODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuSccKTRJkk3Kz9MG/Weg9eYm8LbuelK3kVFURaCPt3Fmz\nje3hogZ1xZpT1PdZXrxWrhOqxuyYUBQbY6kJKi5zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGmpahJ1wyDgEdGsR9DVx8Iab\nqEkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJhYxb00ko3NIt+/AN3n0hkn8/6+nfp5ppJbwQijmFmsAiBM9/PkeJm9\nweEq18xpLqDdtHJZpeTawdycRtyEB1ni7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQTAQLhcdNK5tz1ATweXRmQXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk0ZWZkOTktNTIyYi00NWVjLWIxYmMtZTVmMWExNTQ0YWQ4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTMxMzBhMjItZDBhMS00\nYjFjLTkxYTUtMWEyMzJiNTljNDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nnXwJlXFfA8Z+TN5qoXfrU30SiosImKydRByrphng+SlcdQ3W+ibcVYk9K/yG3d3V\nAKMG1uohqfvEWCnTBdRBmqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYWDSVw1/idIy5yYo\nPRPXQOgmAyowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIE0MawAOH1oUERLpYrdC3jj/EDJkfC1Qe2FxQ7uyOSfbAiEA\nunMM3pC9L2Nqac7g+xTUWDNWbv20RgK3UBGNo+cFFfk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4250", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4250` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAbfd46d7ebnnyd/q1zffekOPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MzU2NjYzLWVkYTktNDVjOS04MWY5LWY5NmFiMmY1NjBmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ1NDc5M2YtY2I2\nZS00NjVjLTg5MzItMjRkMDcyMjkzMDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETHCL0AWmAYVZ5GD3mWdWV/zR+ZtdjkEferNrUwSRRFZAp95XLinGkLRz/iFB\nxlkOht+fQ0Ffrd8EXKWOh5aS8aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN44oJ9LgZwtjvtaSPFW5444MMp4wHwYDVR0j\nBBgwFoAUBYrKdaaq/RW33JIo+8IVrVTGDP4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA+NI0yrWXHJ4gIt3ir+YGgbkU9GQHk05gSe/e0AYHnWECIQC/FU7+2z5n\nTKJ4F3SnpqztNqGOSNH0VP81Bu0xSyFaEw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVDo6up317dtW+f5PsyCAkSPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzM1NjY2My1lZGE5LTQ1YzktODFmOS1mOTZhYjJmNTYwZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjGlrRGUy+yDf86mzTYllmL7SnY7HhNyfZRyTevJps9K9c\nmrlGsy5jVvcv0zJ/TYH1UEcFjQy5XApiz9Fyqtxyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBYrKdaaq/RW33JIo+8IVrVTG\nDP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEe5luK5aja83YsWMnTXF5uXVUwVuFjs2m7JvZD+7ZvcCIEgH9NPSM5d6\nfOKK7ZA5HngEtOsu1q4NrQZhC6zHo+BT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAde+zS8RvTvmcglZU8FIjJgSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ1NDc5M2YtY2I2ZS00NjVjLTg5MzItMjRkMDcyMjkzMDcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODE3YTc0YjMtYmFlMi00\nNjA0LThmZjUtZmJiZDgxZGNiZmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7UlTOyZIQOurm1IJf9rXG7jZvs+F5q6/86BDBXVz4cTO/YO4Iq/1iU4a0RYEPTgh\njv/SzheT6HQce+2BJfLhBqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUN44oJ9LgZwtjvtaS\nPFW5444MMp4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDo8cF3AqHcb7woFdmd2vA1nkR05PFn2dseXhvu4+LHYQIg\nRkwucJfCgxg8GXPBecx25tM19SyTAD9OuO9oBIp/WiY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4251", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4251` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISARTo4AKfWgc2+3W/KqkQtWLPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3ZDIwYmQ3LTgzMmEtNDc1NC04ZWMzLTM0N2Q2ZmZlZGZhZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQwYjIyNDktYjNl\nNS00ZTViLWEyN2QtZTM5NDk1MjA3YWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIJIlXqCtOriPyuqe9nSlPI/gc2E1Wq+JCN5atOCBKnn8qxn4uHV5cHvkt6mB\nZT0zcMsQ4Z5qX9NU6U3Q2oEjj6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/YOgs/vFqvjdAfhFK2LoftQLNX0wHwYDVR0j\nBBgwFoAUIz1x4Q+16joYblC6AvXBk4XZzfIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA1CBUVanMsULRLZkiqbNTZYHxaoEKW9a6ApkYPw0PBsUCIQC4q3xkswR4\ni50HQ33nDcw9qKkF/kg8rG+uXjaSrBBRgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeMGYJgeDzbkQSTRDkR3fJ9QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2QyMGJkNy04MzJhLTQ3NTQtOGVjMy0zNDdkNmZmZWRmYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwxDO9TZFL6zNifCu7wQdYw92CpUI9EET6XJY5Z+3D2YEx\nXf4hQqi8+7+DiVg6nFicyB4/UegX6Pfy0Sh7/UQdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIz1x4Q+16joYblC6AvXBk4XZ\nzfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJF/L66GAfn5VneCwRfCp+xCcdtCdQ6IkvxXkX1pqwHHAiAg20eSJzlF\nFIqGIJkzAozYw+PMFaMv3Z2X6f2fdZbciA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZo8lKOYga6fGcw5/DEetzARMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQwYjIyNDktYjNlNS00ZTViLWEyN2QtZTM5NDk1MjA3YWYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmQ1YzNhMjUtNTU5NC00\nN2UyLTk0YTYtNTFkNGY2YjI2NmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAmqnRZSBAdXW9pmVQfL53vWM+ikW7bjqxj3Q1rr7vM1nOVDkT7wfP/vvk6kgqBjE\nJ/vhQzdbBEGPeN0D+O/vyaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/YOgs/vFqvjdAfhF\nK2LoftQLNX0wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDCLwtbZP1msUS/OcQQi+xswZvm08GmP7kmetO0X4py3AIg\nIikymb3yCgr4FPANmUaVLc0TFjc+91b1evprj4gKcrc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4252", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4252` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAVo4MPMBOjEND2XCifBSB01AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNTY4Mzg3LWU3MDYtNGNmNC1iYWY3LTczNGYwN2ZmYjEwZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM4NWUyYmUtNTk0\nNy00YTQ4LWFiN2YtZGEwY2ZmZTRmNWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnEt7/ZABmTeLgB4K2ekyH7FBX3ONzh5HDzAa9jhti82u4PPn6NqsMcSGACgN\nyFWeLUlHXKZgF+7stINulZCJJaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5wUKxH7nt+8HHN85wtb3RoUyANgwHwYDVR0j\nBBgwFoAU6VRCSHSuP3lIAGrrw/7XecEqxkEwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBW\np7limwAM4xpmPRwmiDJ001bJKWkFOLMC1P1+Qk2VWAIgCchErMe6nAhQrgNEziYI\nnXh6/qxrq0uuPsrBz62eT6c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcFBIS55BAoUbnZhguesUzwXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTU2ODM4Ny1lNzA2LTRjZjQtYmFmNy03MzRmMDdmZmIxMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7k6zpp1ZXtljJcXPAmGoo0xIb53GFJgsB3u3Bs9LS8Y9i\nDvYY8HT0euB3J3oZ/yJRVJjgZpAdu3lwcN+r4AX5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6VRCSHSuP3lIAGrrw/7XecEq\nxkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU2g/BnkFvL+h4ZcmQPATQQgkQtXJppJsxjgFzNxI0/8CIGwbnaW3W9IU\nPweOwW4RTWf41OtAXLBoBfEYJYJQMzTl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAaNzh2N5+uGmK8DONjg7W65RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM4NWUyYmUtNTk0Ny00YTQ4LWFiN2YtZGEwY2ZmZTRmNWMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTQyZGM1ZGItNWExMC00\nNDdhLTk1ZGUtNjZjODNmOTc3YzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWtfCyemtBjW+DkPwVuebpZ3AFDP70WLXrc6WF8hOPzVPRmY2OytnM1M+nEfBDxx+\n7kD1G8l6rK+eZeclIbo1YKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5wUKxH7nt+8HHN85\nwtb3RoUyANgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIEKQ7Xmx6xiO2IQ8xj1+ALpeORWOzmqtl2pA79kuDObcAiEA\nt0eVYhS5o7i0XeJkY2JLWBwWNILAZxiAxnR/8Tfmw9k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4253", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4253` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAZeh8LpaxtnQ+HnU9cpkx5aKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MWMzM2Q5LTUxOTktNDdmMC1hNmQ0LTFmZjMwYTVmNjI4NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZjMDY2MjEtZmU4\nOC00NWUxLWJlYWYtYmMxM2ZlOTc4MTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv38esBcTkNfP/O85DbmRWr12pEqDiy5PqZmOmbPsss4GUIpynj50je2Ae/M5\nuixLSMmZ5M3AWR2HyyGTDm4bQKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXnhp3frVNhIjOfAiq+Vu6/FxPnkwHwYDVR0j\nBBgwFoAUysJt6fgkGqGhnuCcrEFsNHDbPZAwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAiSGrqLgMlW7a8totkgMHIOsCjdJ5WWWJ+0Rmo9fpNlUCIQDo\nzsBQTIyr5xYQYVUl73FBl+npZMzbheQyAfbgW0Zw4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf1OQFTfkbH8NQfNw+YaUXoeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDFjMzNkOS01MTk5LTQ3ZjAtYTZkNC0xZmYzMGE1ZjYyODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtiTRMfyA4a2yU609p4JfSlTFXj/rgmCRjOJcRlHAYKake\nYZbMQUxDawaa5IGl41+k42Dv2aN4KwkU2BsWhzr5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUysJt6fgkGqGhnuCcrEFsNHDb\nPZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALI512HHkuxzUW52s5/tNBoxoAI+0xZT1pY4rZj2I+Y0AiArzGQxsKWF\nbsF7wl/uM4IE5FmPanJLdyODmq9EIGf6Xw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAUeWwShN70SQe/Z6moDVgO2RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZjMDY2MjEtZmU4OC00NWUxLWJlYWYtYmMxM2ZlOTc4MTUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjNmZGQxYTYtNjVjNi00\nYzk4LWE2OGMtOWU5MGI3MjllZDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyCFtofEh5hl9ImtuzishrpsgcWJwiH/ISKym0lB7RMdetxk0+oH8OBWWVHLOpZQT\nKjgoF8g4TdEjO/vTeXuUBaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXnhp3frVNhIjOfAi\nq+Vu6/FxPnkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIBJwRgk6WsYw46rHM7MC0C1UC8ZdiL6n3kKIJoJm/MPHAiBm\nGytSbMnZ9B3uVIR2xtvzn5GOGv7R2q4qBjLdBmAWow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4254", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4254` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARtTDlWhvkm8a+THkb5drnPxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMGJmMzkyLTA2ZjktNGRlYi05ZThkLWNlMjdjZjFlZDRmYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJhZDE3N2QtYjA3\nYy00NGQzLTgxMDktZTE3MjZiYWZlNjBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnKqLKqDe1REce0yxCcfs1O/ixy0qkFG1uMU8ZSyX3Kgx3D/T9Qf93Dcvy8Pj\nzk4Jo01LnbrsMV3tdSsk9EBVCaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ9jNi7x0ti7MJ9v8YUM5yrI9zBcwHwYDVR0j\nBBgwFoAUPLooNBK+t6qEbySdE4uEdWmRQMIwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBajU0b7JpcrfrZUpyuD9ZXz/X0JEFDpQ+Bm1kv9Xn6SQIhALFZ\n84YfwnTjB1qq2WyugVgtLijelloO7RJBXj8/Z1AT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdEdjo6EJ5gcedaMCekf+RgSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDBiZjM5Mi0wNmY5LTRkZWItOWU4ZC1jZTI3Y2YxZWQ0ZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMKssQZ0K+fPipL+Jsngh4qcL7weiA6HDbYYly8SGpV2a6\nLemIUBUlzXbQqiO/z/YkaPHkEB+NRshh/zBTuRp1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPLooNBK+t6qEbySdE4uEdWmR\nQMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJG3eiZQ85eiP5JGhaBPPQPZC/qZZdDWpr/uCOxEgazgCIQDknVoqnhkC\nfpzmQmlUJ7AWGauf6TfN1Ds56XGqPs483w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAVNX81FtoYTroOWpRNX82SilMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJhZDE3N2QtYjA3Yy00NGQzLTgxMDktZTE3MjZiYWZlNjBmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTgwYzZkNTItZmRiNi00\nYTg2LTg3MTItMjJkMGI2MmNhMGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNA0JeED+iacNErtNLm5G+zeYSUW72edexPEdEMnMaUAQH5AfmF1y2S+/dLDyXGQN\nhMxRO4gy+wOJZpbuxbAXW6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJ9jNi7x0ti7MJ9v8\nYUM5yrI9zBcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIC6B73Se9dY2b2wpk3VavbOR+2iJy89x2qg+jr4VBqgJAiBl\nZsOYfN57oeymGPxILurisk2weADjp1xlMV903ILxew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4255", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4255` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZVULSdsEX6U/T+X6CYUIDQ/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3ZTg3MGUxLWVjMGEtNGYzMi1iODEzLTlhZGQ2YzA0NDI4NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzEzYWNlMzktM2Fi\nMi00MDViLWFkMjItYzRmMjI3ZWUyMWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERFd6R6zRfg+BRyVwd5Q8alkXVkvG3bTyshdCfIq8e8dZ5xWv7GYNQqueyoxp\nhOCq3gLV8dcz4VHtVq4sO11qPqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUavjrZ70i2VKskAJYSUgDAx4ytyEwHwYDVR0j\nBBgwFoAUzNoE2GDr3iizc8UouJQrnZXtZcowJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiB8nTKs56LpXF7E\nJRsR9dL/m/DICwK9wG8GFzLIkO21IwIhALdBp9Jce1lsR9WSG+4A95w6bG2WQbET\niLu1SMxFhCNO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS6JImz3KucdNfb6+W33Vd52MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2U4NzBlMS1lYzBhLTRmMzItYjgxMy05YWRkNmMwNDQyODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaCTHXk6/yheHOmW96ADR8iUJumA8ipbQ62KDgYTb5Kkj9\nmhp+l9LGkVKfDYalfgBgmPaXMpjbrsVXWpQitBUuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzNoE2GDr3iizc8UouJQrnZXt\nZcowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJHzYKSFxQfUJi9JXCSIIstFPMS8le2UQKEQ6Suuf4dHAiAi8DdaNqDX\nGZDfL4L24nMNnLbA/okQBmzTrYEqlPP5Ww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISATK11LXXsZy3shqCffum2A52MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzEzYWNlMzktM2FiMi00MDViLWFkMjItYzRmMjI3ZWUyMWU0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzg5MDU3YzctN2IwYS00\nM2YwLTgzODAtNTRhOTBmZjBkZWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOQDjKzT54c8Hk9tltQO1e3Gfcr7m3GyvvxbMdBAXBYz+VwmEVRgQDsnbLaq7+Ifr\nypWjDe8c0ojwphBBxkBiYKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUavjrZ70i2VKskAJY\nSUgDAx4ytyEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIB4t6RbH6Hz4m6r/2PvRB9vbZPlbsubllNqKMIhAJ97yAiBi\n+wwAYNnRl9IOWr5LUzMedYsN7Zdno1YozVV6MvSpgA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4256", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4256` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAahQ7f4GBzCXRTBVfjiX/4oIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMGVkNWY1LWM0NDctNGYzYS04OTEwLWMwMjc5MDMzNTY4YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE0OTVhMWQtODBh\nYi00ZWYyLWEwNDEtOWFlMjE1N2VmOWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEudMr9nEKKU1jp393BSlc56s9SxGLF7UFMhduipcB3P35b1XM2ziE0GXysZS/\n4j41v24CDv/EbLMtio6XD5mgzaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDEcdYaJG+mkg248+gfx8451MarswHwYDVR0j\nBBgwFoAUKL8MbuN5qAqaWEAq/lQJ83g1X2wwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICkDz9c2sijjRD/2xwXGGK0+Xilx11VoR0/7tge0IKqDAiAQ5qN9SdpIyFaL\nHjPElGbPRKDSgVK1xgs490p2INlYYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXQa2WYYACXuyh/DS83EPtjlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTBlZDVmNS1jNDQ3LTRmM2EtODkxMC1jMDI3OTAzMzU2OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7IcjVt1hqcSZs8+Gop7vVt+ktZ2sGmi3YoETTnBBwrANc\n68buk/XiJVJNpTZeThylI9WmJ8U86suPAX/AjnJqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKL8MbuN5qAqaWEAq/lQJ83g1\nX2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN40Y+vQ2NJJc5mn4WuG13yzOKFLZnWbZKLTcYRht0foCIDLq3ryfqjPz\nFlnIMOegpl9EXqz2Sn4cSqFkVOMH8nGK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISARW3/RvpMHkFbJdO/Ne4Nbg3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE0OTVhMWQtODBhYi00ZWYyLWEwNDEtOWFlMjE1N2VmOWVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTRlYWI0OWMtZjYwOS00\nMzEwLWFjYjYtMzE5OTllMzc3MjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5MetjZ0cN2GQUTz+UoCTjRr3IaQ7ee+SREqqlZni3Jq6k/ppBHW++zU3sPZKOPK2\nPLTUm9cXf3lnh8y/x1g1yqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDEcdYaJG+mkg248+\ngfx8451MarswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQD+A/G0griPYypZh4fvkA/skgYz/YjG6x7EzJ3b8mTeoAIh\nAJg6+Jrtj1l5ntm7FhdNQ8RgO1dh1qw0/4LG0MM9QlYv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4257", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4257` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAc36gcjTIKnuWcqpGTqhVq32MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3MGRlNjJkLWRiN2YtNDU1Ny05YjIxLWNiNThkYjFkYWE4NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBiNWNmZmQtMTI2\nNi00NjFmLWI1NTQtNDRkMmRjNDQ0NWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC7T8wIta7HFmOqQ04UTZUIJqH1C1VJR+k3FJ47F4RzBObL/GJutJCR46X2lf\nI+i97KTpUDHPL73qQuFIbguwnKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy4vupOwqYYoZVDCqoBrfrDBRoTwwHwYDVR0j\nBBgwFoAUc7zcHa05bZVtelrVK8ilvSCOzWMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIA9kbd7+koUX9CHnZ4lVGOuT8rQTbTOE8lC6hMbK4W4IAiEAmp7f8toXLcXh\nE9oYIZ36vNyGJMtdrcn1qeqBnywknOk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaHAVfKAiaFdcZwU7wKfo+7EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzBkZTYyZC1kYjdmLTQ1NTctOWIyMS1jYjU4ZGIxZGFhODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYhUqfxZ8RNWXmlcPijDxjUatres2QaB2dNEegaSK+rP7J\nVdAxkv1zaSA6AxMOZsYVlXCLfcv4Jbd1J+ovMmX5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc7zcHa05bZVtelrVK8ilvSCO\nzWMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJAFgIOsYsCAAl/LSqhgY1znqWNuZtGfMshHwuBaI6LjAiBonQhZsFy3\n4uatkHDHVK7dcDhf7zL9xkU6dzee1QUtLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAR6m0+u7p0wsp5NmTR+KXi9ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBiNWNmZmQtMTI2Ni00NjFmLWI1NTQtNDRkMmRjNDQ0NWIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWFkMjE2YzMtODkwNS00\nZjRmLTk1OGUtM2M0YzAyZGM4NTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqmL7SrDqqqiVPyKYAdSzQCvhTbcvm+Bli2wxwaJvGtJ2uPwQ94wBuQLdIKsq+l6+\nDzg4kriAz7bzVJZVurIGYaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUy4vupOwqYYoZVDCq\noBrfrDBRoTwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQC1a+kjWH5gVUcGlclSx/Uk4SniHx38KRzpN9rajE0XBwIg\nT1Fi/6nLkWrVxWzSvg1CboB7ftvMsH7qVrZ/CFap1eI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4258", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4258` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAWFYI89TL6QU2DAZXuhQFdxVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMzU5NGE5LTZlMGYtNDZmYi04MWU0LTFmNjQzYjE5ZTdjMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI2MGM4N2EtNmVm\nZS00OWJmLTgzMDYtNjYyMmViYWFhNDk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXGqjCpJOKvSwTuRQh3rA6pd2JiJ1gLCKc0CmnTFNy8m6gaQpWrP2oGi4tVLB\nECZDOLO1nvehhM5zTdD8krUF2qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFXgyMpyUAtFjxsRDOhy6gMhuaSAwHwYDVR0j\nBBgwFoAUNSleqJtx2WcRBjB7jm/5ga932vEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAmlADs96bLhEoFg1K3+SF1BSNO0tHXIUlUlaUtnX1+ooCIQCOYSMPg8R7\nX5obZSvjE+VRrFFKx5Dn5Jgk67a9cxFIvQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcGtesvZtDFXmXAphvD/aVstMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjM1OTRhOS02ZTBmLTQ2ZmItODFlNC0xZjY0M2IxOWU3YzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxqL8+MxxEc6h36m98Ri0GqDceuZXfvvzWNDxaI9X0P0da\nV5hahsKCU6r/Jm7Fpn5M1iUm5RfxvaPAMXHdIsmQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNSleqJtx2WcRBjB7jm/5ga93\n2vEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQy/7DLuBZHXIybA7ITYmQK3rerSc9dfomu49qdodHYACIHjV6+EsrbP1\nXFrc3UZaTQIKF6EWs5XcGjsaSbgvqdf9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISARCfmBjOsfm1Kblr+PACC41+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI2MGM4N2EtNmVmZS00OWJmLTgzMDYtNjYyMmViYWFhNDk5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDFmNGQ5YTMtYzdiYy00\nMTMyLTk2NjgtOWNmOGU4ODAyZDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVnjzwsIUVEJifqI8CKdumWH1DCFTmlMdAKxBGpEtD29xey1Aqhy2Q0wZA6mFb9ZO\nuZ3lEEbhhUyGQElhFzayjKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFXgyMpyUAtFjxsRD\nOhy6gMhuaSAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIEOTgk0d6Oh2t11sFxHyfFrWQQOsY5Wyi65ITi3qP+QnAiEA\nhLLn75PR9OKufmnJkIWV3vALaF8g+CnZeODXGw8vgts=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4259", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4259` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXPDcLxqmxlPSprK/DZyBPvSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyNjNhZDRmLTZjZTQtNDY2MC04MzllLTM5ZGVkZTU4N2M2OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ5NWYzMGEtMGMy\nMi00ZWRiLTlkZGEtN2RjNjc1ZDM1NTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzr5ySFBtH33t5n1CqZPzf8S3jyJanlhUqFKgJixJExCSo0jFCgbosnd5t9+9\nBs8uImEIJeLI0/vobQX78b6n/aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS7HsedH3hlj2ck7pSKSNU84N9+IwHwYDVR0j\nBBgwFoAUXSyKEvgl/WPyO0I6nhTNzFG+vggwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBu5H796etPJ1nfSMhwNg8mog45UKhB0gzEfKaTUFS7\negIhALIED4KgA569utLhirDmQ/les2qSCH39/WOSY/68ecId\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZIftxAJnuHQZ62nJOo92ShkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjYzYWQ0Zi02Y2U0LTQ2NjAtODM5ZS0zOWRlZGU1ODdjNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1OhWsJIOE2qy9DXA94pSwRYnQj4L+Tsn2ZLgNirPKMnzs\nfVzNYLSqrNzC6yQpzs+0FTq82G/bZ41nCxJ8Q1NFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXSyKEvgl/WPyO0I6nhTNzFG+\nvggwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIga96CtG46ZmFuyIu126envUBoyrsKhQ6e/loaacMesf8CIQCaWfSl4RRd\n1nAoqmgHTDl+k5FEap8dkyBi3aZsuy61sw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAXoKMg629g23a+CaBqckSTXeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ5NWYzMGEtMGMyMi00ZWRiLTlkZGEtN2RjNjc1ZDM1NTE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjk0NGE5MjgtOTg3Yi00\nYjQyLWEwN2EtYzUzNjg5NjE2YzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTDPDwwvshSfWeAtwNMuA+UMyI/ITs9yg+9dYhAFrb45bHfuE7eVjPJaZzd3UD9X9\n6rgNGPaMsVb2OIsEO9qUcaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUS7HsedH3hlj2ck7p\nSKSNU84N9+IwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDK3q/AIlu3+lxU0XuAS3KZC7wgXrwSItaS5uK15Rcq3QIh\nAIebicQXfAGzIoYrQ2LwIQQcXYbBsrn75ktT98tbB4nj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4260", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4260` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAdk9bvrX4R5aQvb4IklR5Bf6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjODdiOTlhLWZiMGEtNDRlZC05MWEzLThhYzRmNzRlMWUyYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUzNTE1MjUtZjg1\nYS00MjIyLTkwOTEtNDM1ZDZkOGRlOWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3l9JoEsgtG3RhcyoQANvTINh5NmrPjWTTGk2jUTKbd2pd6iyfC6rzafzx2kY\nR9G+Zx01ZuhOsDJ9fKykCPaWbKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKkJxHa8c2nAfgmlQVQc2mm12ZakwHwYDVR0j\nBBgwFoAUviHcqsCrr5OqA9Z6aZu7gqeC5dIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAq+kyiCTaSXjaoE4KgWQ+8dLPu1NikilAlmMzkXw6\nkyQCIQDeu9LwgBEEY0fW+C0bHKMCJRKb1Y+i3teznopqq3AEcQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeMaF/s68IKTqrikOP2/VYtfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzg3Yjk5YS1mYjBhLTQ0ZWQtOTFhMy04YWM0Zjc0ZTFlMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWagIcLgrQ3R/jJ3eMU7sJbLQnh05K1WIGEZDjCh9i/yge\nZSdLEu9y3+fpGFJKjENRb+75SJ0pHQ8xLXA0S3hoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUviHcqsCrr5OqA9Z6aZu7gqeC\n5dIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANq585iF5zUPSyrFIIhHAauE4ftRtgOvS5TksFanomKgAiEA41xABkuT\nlo4uOBeVoGamovQSOTsMWMUT8yU+UGFZzX4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISASJcy4HFZjlxXEMOzRTrUsjtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUzNTE1MjUtZjg1YS00MjIyLTkwOTEtNDM1ZDZkOGRlOWJiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGMzZTRiMGUtNTc4Zi00\nYjY1LTg5NWEtYjA3OWMxZWM3MDgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbJz14wm3+1vQ2uje1oH6PugbxHxi+gN9suyMibayy2b/B3vCnnDEEwZ1+9ScJ+5e\nWPv/NjkZh56ReNqN9+0mUqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKkJxHa8c2nAfgmlQ\nVQc2mm12ZakwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIGK1jg8Q3cxd5eUQAX66sftYOPZbWwycBo9b1xMkZnwMAiBJ\n2+d4NAEJuKXP7Sj+zpdsjlLv+wQtakrFV8LbJZJFHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4261", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4261` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAe0/eOgEYGrpkDMHD8uCUaxsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MTI1ZDAwLWU4MGYtNDk4YS1iNTE4LWNkZWVhMDRhZmM4ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJkMjBlMjctNmE5\nNS00NGJkLWI2MmQtNmE2YWFmMzAwMThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExxAYTCiId6eCRMoxXQezjWtQWOLI6UZVIZQVEISUHwFrkX0zgWMKktNehnzz\ncVA+VqkO419tN+mkgph+AJ3uJ6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvfx3goiIDYzKWihn3B4//ZJTBdEwHwYDVR0j\nBBgwFoAU8gb6BiuW1XrM9pIa02xYk+diPeYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAICaY7J2lxbP00B5+jE6ujnwFVJnxxMphXA4v5VEW+pQIgMSAI\nohUXDOKPk6kxh+EOVJXC9vLfDd2nlWoXkT/u9Yc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdir1aMyZ4mdMzVNO4NdYViMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzEyNWQwMC1lODBmLTQ5OGEtYjUxOC1jZGVlYTA0YWZjODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIG7CwF1xt6rqQJhnBT0Bukgx5a1xNv+zh8dhPeZhWzaiC\nWTZ5UEP4FmsRsJGzld1DXWr2E5QPKym8N8TGwzZ6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8gb6BiuW1XrM9pIa02xYk+di\nPeYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIZtaHfIxhQofFW9pxHnDpw9JvSlyh4I/AyluBI2pJZgAiAa5U/hpy8G\nxy/Ty6WqjyFhjtqU7SBLCEtOmhVyqDSDWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAaNgXODwVbDwYqZ2VEFoJvZBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJkMjBlMjctNmE5NS00NGJkLWI2MmQtNmE2YWFmMzAwMThkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTM5MWFiODUtMTQ0Yi00\nNGQ4LWE5MGYtZjg4NzgzZDVjYjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPzV5yLfEED7aVxW0FNaZoZHKiw5ZafYeI+G6256YjvNx+74LHgVfxuaJ86bC76qT\ngOEG1JnzDqMmXb0GmDIRW6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvfx3goiIDYzKWihn\n3B4//ZJTBdEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCMhU8s4o0dLh+uJhCcWoMGGzONTYZlc13WmwEDunfUFAIg\nFxDU7pHLstntPR5qY/k9oHY0b5Tq41InpvhWP+mLiYo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4262", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4262` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAVV3+llgA3uE8wxsXNb//46sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzYzQ0MGQyLWFiNjctNDg1Ni04NmRmLWY5NWI2ZjIzOWI5NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ0NGU5YTItYTVk\nNC00YWI1LTliMjctNmZhZTc2ODIyOWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+OC+7MVHXo8cbtw3P7jcZ2vASFKbyGxwX54+ITBPQCGXa6vhKHG/2bztBEPR\naulz+c6NgQHa5OIJyzp69Bj0y6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnO7eniBIpR9fjcyqDmb29qQzbqowHwYDVR0j\nBBgwFoAUrgXudz/DNV9PNagoUyvepEGzBs4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAx0ZLk6Mbj87sZncXzkzpMe2+6VtkwFmo\nPH7axSwgLGMCIQDU6EJ6yu8P86MR91xdXV3MggY+0YekBQWQD87fGuk6lA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY6HttPUKgqBcKWP/G/GLioYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2M0NDBkMi1hYjY3LTQ4NTYtODZkZi1mOTViNmYyMzliOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASA0Lxj/XtadDgGZpUT1sGeZypPP0tof1LNw8XUwg+OPrnf\nZ5/dbiOhBc/tV5qbCVBRzaXSbRyL0ONBLDrAp/Szo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrgXudz/DNV9PNagoUyvepEGz\nBs4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPPSmyBMoWlzMnteIS37iYf3Q1l3LHiEVZ4dulgJv2bACIA4MIgUuOvwU\nHhl6Zc+lFdl/+3O0Pmd7sb0s5UCbkZVi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVio+oWc4LJYdihFywlZb5AMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ0NGU5YTItYTVkNC00YWI1LTliMjctNmZhZTc2ODIyOWFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWMwZjJiNGItMjJiZS00\nMjlkLWJkMzAtZTFkZTYyMTNhMWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBf+Lrjyx/u6V+dytsUyigeuOHSjqXcpWo/DfrY+RER6CW8cpFiI1N9RH7MbLomhM\ntsEnyI5UfWeDObDRJiP/LKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnO7eniBIpR9fjcyq\nDmb29qQzbqowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDJ5UHJyk8HTUEKPbvw0q2rKLn/Kl6tbp8tkL2aQNzI6wIh\nAPLlsuZlvmoZVhlR5N4wemRBIbLgpYm6Xv+9MC05CL//\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4263", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4263` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISATU1lb7I2GmHq7sNxmfGVPdpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MDVhODE2LWFmN2EtNDdmNy05MmViLWNlMWFmNjRmMmZmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQyMDM5YzEtNDk2\nZS00YjliLTkxNDMtODBhOWI3YzcwYjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhCR6zWUl0PUn2WWUHEAv/vfHeCA2NjZYdjIt4z3RYjRtOQ91ZwXY1hnOM6wC\nchxRmATg3NMUFLT0uW0gkMM88qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuUJrq0r9ClVY8Wi6HWhttFVCI/wwHwYDVR0j\nBBgwFoAU2PDIjCrZSz28Qo3EdMEkqpbQ8jMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA66u1YMC//RI2JbFrcM+qn2KgyUl/xqqT\nJ3n9/7P62B8CIQC2VcWS3f9Y/QUjS9mi0Z01Np9K3MwVkAX0NwfPih7RLA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQtOFmnLX7b8Ay59L58qJAHwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjA1YTgxNi1hZjdhLTQ3ZjctOTJlYi1jZTFhZjY0ZjJmZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRwMqL700tDbM5GYhLnB8dpjjUoUJVqzKy1xJeLCRUlYzZ\nZizimsZTKPVR/tbTLKNJoYvycx3slXTqVUw8H5I2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2PDIjCrZSz28Qo3EdMEkqpbQ\n8jMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMTjnyCslYRsdAfcruKKt0oYYdHfFwsfkKPkikrVKKonAiEAtS6umnYr\n5U5sqfz4OyUT/B6ICTIZOLqom02rwR7Eyh8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWf8RaY8KU8SZu45xsgtje0UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQyMDM5YzEtNDk2ZS00YjliLTkxNDMtODBhOWI3YzcwYjFmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzE3Y2IwZDktNWJlYi00\nMGM5LWE0MDMtMmIxZDlmMWUwMDlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nX89CJWRnKYU4NqgrtCvT9+0+Gia/pEKLpUhDTJri2A8+DRg3DVfmgD4G29Ze3SJg\nIQsIFrGxDzqFiaPsBzWxEqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUuUJrq0r9ClVY8Wi6\nHWhttFVCI/wwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIHUMOXL7Bpgq6RNBEbAI89OrvmggYl7btAXNIIL+SETXAiEA\nrvsX2/KZfTAhAqIaWLzYHUqJ5BMKP81Tm739HR6IVvg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4264", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4264` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAW+J4s0gvffWJZoK/0H5Ml4gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhNTRmNGJlLTkwMTgtNDQxYi1iMDI2LTIyNGY1NmYzYWUxYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ2NGM4NTUtMjc5\nMy00YWQ3LThmNGYtYjk5NjRjNTg2YzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETYQlAJua1iXeBzrTxQ8slPzavJmiNNO/QwGO5o5s7bxwcGjY6ISVgB+HLc4B\nawRNRFV6k9CAijyNqww0p082RaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKN3ZrAXS22YSGumWrY6Qegp0kHkwHwYDVR0j\nBBgwFoAUwGefFGK7O8fvIj91NmaAuWbVA1wwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAk45jFvG5Pu/h\nMIqp4aorRb7SLc/OCTaNqRdlWpIQrpECIFaQZ1cQUpXpo/MxzVBzUjy6BpqqsYHv\n/0DvFZuyPcR9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcvHi23m4UgYd4wVo1pqJwbmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTU0ZjRiZS05MDE4LTQ0MWItYjAyNi0yMjRmNTZmM2FlMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShjloqviAwW2inupEMZqne4QI2H4liR9cn3B5z5Sc2R73Q\nXmd1yTI87zN20z/AQ8p55NqJ64bC4Hwm+Tb/1ykOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwGefFGK7O8fvIj91NmaAuWbV\nA1wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFC+eJclvjSCd8Iq/+1mCVnRR8WHMmN81Vt9PGXapVWMCIF/veBixh6wL\nAaGCsagOpsAD2mruIhoi800j+mJ9LClp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAQ8cbplXpDNYLvKARl1WSwNsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ2NGM4NTUtMjc5My00YWQ3LThmNGYtYjk5NjRjNTg2YzUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjY4MzJjMjUtOTk5YS00\nNTZmLTk3YjQtZTUyNGZiOWQ4YWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOZhf7vGywEEiHGbFfSBKWrJgfT6UTgiTXnBvEtSqDCeLzZnu2585C+0au28tRPq/\nH9Xj0mxC5JDcmHMpniJLt6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKN3ZrAXS22YSGumW\nrY6Qegp0kHkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIGUcuCtr3hS3D+GYKuDKDkxgrMVQcFBuhww3j2UqUbYIAiAk\nsFFPv39OCzN80YsbX16H/FEeQwjMFG3YVSWyRq7hhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4265", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4265` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWON1PPmxbJ+rGvgGa/kvEFvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkODY0ZjRmLTk5ZTctNDE1Mi04MDhkLTc0ZTg5NzRkYTk0OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJjZTk4MGMtZmQy\nYS00NDc5LWJlN2EtNjEzOWFhOWQxOWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbCasOh3SQlwO47q4XiHxka3fWFdJ16kBpxCP28grwmI0B6npzf9ZQcPOYuTH\nkUZJ3BLjRfDSCQCd9FbGQPdXnqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEKA0NMozkvORqpOefdz74qVtQfQwHwYDVR0j\nBBgwFoAUxAc6UUwf0SgLP/dKou3Ra73eOYwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCYiQMShlbtkBODa26xs95LtkcFVZPPNxsLLfTXVHq01AIgOk0lGnaPY/QQ\nWO4Ta3e5yYwoNEyUEU4eiyzCVcFICHk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcsg85sZvILLyRsImTGX1Oy4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDg2NGY0Zi05OWU3LTQxNTItODA4ZC03NGU4OTc0ZGE5NDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfBdgfdPjS+3GxseyeSn097aH+JbyCJr5QiAvVL70Bm0Wd\nwQ69T8eYCJoPFzYBb366dL+Ei/xHz8XdA4UB/5+9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxAc6UUwf0SgLP/dKou3Ra73e\nOYwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPzT3n4sMnpmySfPtUs8aFUBm79DhOtWuw3O714D4G0wCIQDG8PXrMVRl\nt7tUjH/UtjkyA+hIMLZAk1WQl2ZszxVN8w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAQ7m3ZD2+wAqUzOIoG1Rs0i3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJjZTk4MGMtZmQyYS00NDc5LWJlN2EtNjEzOWFhOWQxOWY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODY2OGZmZWUtOTAwZS00\nYjk2LWI3YjktM2JjOWQwZjUzYWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7forYgzP3XEGmb/HX3Bc5Y6o27Yv94tZOmsID869ZRYy69l516MRPIkeglAM87WX\n0csJC4Xq1hNBQudNC0pnJaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEKA0NMozkvORqpOe\nfdz74qVtQfQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIAyqC0dxg/4xxQM9gNVH2c+mbNkh9oZ6OH9MGoV1kmIjAiA3\nYzzVXTdC6jGHJl7yJpMVL7OFObymFWaO95GOC8ZGKg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4266", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4266` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbu1DTc4xRIGN8pLvPLufwKmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxN2RhMTNiLWI2MDgtNGMzMS1iZWM2LTM2ODVlMTNkOTFjNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk5ZTNjYzgtOTEx\nMy00ODcyLWI5NmYtM2I3NzcyODQ3YjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEySAcB4Y1q795YYn7XiLpDYEG1bzFXSBL+IQkmkFg0iu1NIZIt3lOsXxUOMlh\ngYq64Mk4la/2E/hIUb5lKX3n76OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoOi1MbJF5h4N9KTBDyrhhIYUql4wHwYDVR0j\nBBgwFoAUMJUY5blYVKnmXBObQc0pdCNHW/4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIA39SoePNdzoIiqT+REaXQLVXmq6A7XElbfkdFg+jIL5AiBQ7Mqn3m9i8YOT\nqaSJyIupEPRhB6AoQ17nNArFN1OWsg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXMfXomCSqB8gtslRo0q+QFiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTdkYTEzYi1iNjA4LTRjMzEtYmVjNi0zNjg1ZTEzZDkxYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1K6Zk8+WtmsbpGzyDyTr7dcGXgCKUQSjSmzJ/9IB4TfHk\n8NZY1EJiy4Bj/he19U8pVphVUkhRjBwM4glQ9Rf6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMJUY5blYVKnmXBObQc0pdCNH\nW/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcSwuhAMd0kWvn5u8YnAcOCbM4XUYS3v+DPzxm9j8vl4CIQCyrNUX8BaX\n04L8mtxJ79AUAcNaxH5PaVv2MJKxnv6OeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWRGHCHlB2H3Svs8HcSvP+kzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk5ZTNjYzgtOTExMy00ODcyLWI5NmYtM2I3NzcyODQ3YjgzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2I0NDhiNzUtMGM3OS00\nY2I4LWJiMTQtN2E1MDgwNWJkNTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwzhg1DM36nzCpZKFZ1K53dQgs+8QlVsL5FU/LMpSH5XIISExHDqwAk47hAECPGun\nLr13JVwdaXtO28M7jUaXt6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUoOi1MbJF5h4N9KTB\nDyrhhIYUql4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIEJ50CTQAgHDvKEiiWppJcky5nTWxSXbQDOrR1bu84Y8AiEA\nnJLPd3/seTr3hV5bV/boHHqjy8LwHy36KMxn9rfsIrg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4267", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4267` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZ0H+YKuG2DI63W8l2ggqLkFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlMGI4ZWI1LWE4OTYtNDQ3Yy04MDAwLTZhNTA1ZmJlZThhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc4YzIxNzItZmYx\nZi00MDdjLWFiMTYtZjk0Y2FlMTA4NjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFFoG+3Kyljr6r3uo/RnrE2H88Eod05W/v6SMJjTH6AKoHPZHq41p/+XJhAcR\n/nMXNXB9Bc0E9IpF3Pr8CC3DH6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk5Nz4kvm8/RQ1DDPnnPF1PwiMYcwHwYDVR0j\nBBgwFoAUFPe6Yi3L90uK4iTJ6jkS4kepPGAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBNolPNebM6PJ8Zk1jE7hjqb9jneYaqMZwSRIdlyyb7jAIhANPUMquMdcA6\n891hFGdBO+cGM2paTK0FvJAwZIrRiGb3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXLlsZxVbw85DZxucrdqBstKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTBiOGViNS1hODk2LTQ0N2MtODAwMC02YTUwNWZiZWU4YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnrf3iY8CH6qharUvWrX30fIMrMPVEO3A1h2gQk3PdoskO\nam6q7jwxMoLswM+OPFQ8CYBLII8ralAAxwML+gWfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFPe6Yi3L90uK4iTJ6jkS4kep\nPGAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMkQQq5ddOzXOFg2tegvrSti3PPjD9R+plFyFw2rCD43AiA6zCKr+DjK\ngFLTczxEe8/foIzF1tp1Sv5JnuZ6rrgv7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfpV+VZYiJ824lc7ewgU7Rp+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc4YzIxNzItZmYxZi00MDdjLWFiMTYtZjk0Y2FlMTA4NjFkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzVhODZiMjEtOGE0MC00\nMzQ5LWIxNjEtNWM4NzRiZDM3YjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\neVOT5CZQ/rzz9j/iNGRPXMQsGh5O3701Omq/PyPqeW0C9TaFxvv4WHSjgn37P/9M\ndbzriZWyh3Zfonll1b9B0KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUk5Nz4kvm8/RQ1DDP\nnnPF1PwiMYcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIAF7rw+l4jkjC1ECjJS0sTCC271BoFpFUUzHbLC2caT6AiEA\nsx09hRy5jfG87ul/BeNj9J9anZnQ+4qoMLqDH75uhjg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4268", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4268` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVMcuolQ0M9usCiIQi3gP/oqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxMTY1ZWQzLThjZjUtNGQzOC04Mzg4LTM0MGM3ZTQ1NTdjMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA0Mzc3MjEtZmM2\nMy00ZjE3LWFiYmMtNjI2YTY4NzI2OTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExHRKkvMjQ9betvYcPtI2vZ3ps+j0yWbEDYC2FeqZxC458cptPI1ro8BHu2Ww\nlJs0BJN0PE+t2xAWlnqKYWb9mKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeRGTFUPm/ziD1CDLSFLWMkahFFAwHwYDVR0j\nBBgwFoAUBU5Hqb6BaI/9xcd5lhqPrHqD6NQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEArR+OPEiQxfHd4gnJR6/mEYgkBDvwnTBFbSvQ8exq\nnmQCIBnpD5hAyV1RAva7F1CRIGFeXhkOzs3Oi26ds3UW7ncS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISActeLijREKSsdcOJh8C3nbsxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTE2NWVkMy04Y2Y1LTRkMzgtODM4OC0zNDBjN2U0NTU3YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyYOHYX+HU/lFXre3cTAdqduNcG+udRlEtc7P+C6epY8cf\nW74HhnLjLos9dH4P7IY1JglLW1NPtjtQICdbWnLoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBU5Hqb6BaI/9xcd5lhqPrHqD\n6NQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCQmdXEuqmjKJ0TXGa4S3DmG7pbG+hX1UJBo+GpSxY0ICIAgmLFDWBD3B\n3PWEPCNxCtG2SVI9wHJRcCFEpqdSs3Hx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISARNgGi3piWGJpUgJkSUVtXLCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA0Mzc3MjEtZmM2My00ZjE3LWFiYmMtNjI2YTY4NzI2OTZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjdmZDM5NmMtMjU4My00\nODcwLWEwMTUtNjNiMzVmYTg3MzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHbrOgrNoKT2N6j4AYlW56pekPX0Yy/jag3TEQsQYkroVD15T3ZwKtk0A4uFAAogO\nMfHH80M3/Bs5JuPDf27PSaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUeRGTFUPm/ziD1CDL\nSFLWMkahFFAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCICYsYa11qTLC4uPD2SHhixH5gfPVemYAmPPdPRHxy5+DAiEA\nmgWbZEC6Ms/lwIHnP3YKZeY1/8STgVnIiuMBS0qfOKA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4269", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4269` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAd/Yruj82FyEtw18LcwWJIpdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkYzQxYTZhLTMwMDEtNGU3OC04MmE3LWRiYjc5YjcwY2UyNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQwNTBjMmUtZTI4\nZS00MGFlLWI4YjItNmM5YmRkODA2YWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Sd6HgbxAvGt3xeXYQ7r4IFoLjNYoqrg/if41bxoMMwVpgL9JozFc+inoHNV\nj33UAPTLdZdlNPoSoctIXHIZIKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX07nCFlsv1NmF378wASEOFBILu8wHwYDVR0j\nBBgwFoAUsW77IqBzs5YPlIpWBWBD9xgvTF0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAx+ZxSVKMMmxHfLZinc4g++nTXQNrjWpeCLCsBFkV\nkJgCIQDPYgkcR+ItuXD/aXUuI/08LpSvvu0VydKY5OnwmmmjYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUwSPYRBjwI3EMBJwUny4JTZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGM0MWE2YS0zMDAxLTRlNzgtODJhNy1kYmI3OWI3MGNlMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSPjjopIkgxCb+iVYUVNcPp4eYVIUzhL1pYdIUCSnaBeIo\nTo/gEp3dBV7Xf0P8oU8ypk8oli+igr1cg0pCbTtGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsW77IqBzs5YPlIpWBWBD9xgv\nTF0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALZ81H3ZLaU9eotT+SvS8M8oOGt/16zdUmAqjPAFcUkUAiA1Ws7+TBt9\n86CExeK7NGqTcAqxRsSsPsRfgFPIKmXVXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAUn8NsoF6xShurfIVSVEvZrVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQwNTBjMmUtZTI4ZS00MGFlLWI4YjItNmM5YmRkODA2YWI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2E1YTBjYmItOWMyMC00\nYzJkLWFlZjYtMmQyZTZiZjUyMTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSYq197yOr/MK9VROw5LoHZtjnyWGqduhjjQYJwA62+2tSbrGNY513ft8xiRwL/8N\niZ0Jlap8HZLkv08pocfFuqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUX07nCFlsv1NmF378\nwASEOFBILu8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCL3LEgKh+tPVYrfpegXoyBJxJLbgCZiSc9prKwzHqfyAIh\nAK6Up118WJebWv8ai5AZiwJQlTCxrN/FvDtRptvG3Sy0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4270", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4270` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAaagApUNzPR/ca/2BBQVZZ+DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhOTI2MzA2LWIzOTctNDZkOS05NmM5LTZhNTQ1MWQ3MDJhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQwZTRiNWUtMzk0\nYi00OTQzLWFhMjUtZDVhODAyMGEzY2RmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2+CY3vj3J59xsB58SaJaoopNGzc21ueA1jvs3/984cfeIa75lVdA1DNMjksi\net0TZMY1PLdnc1KQ+O3tSQcwraOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUknR2/8K9x2INpTOQ5NM1szVzG1wwHwYDVR0j\nBBgwFoAUw73kuV65/GT+a4cVHoaBu6VuddYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBk2xNDHDD6npWHBcwXpMS+N614AW+9CnLsgbmSNeqmxwIgI4Lw\n0PXbAnogFA1TKFJE9475KGcwJHT3UYR6CyOzOy8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY8BWPGQWomej1+JEb1wKvHNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTkyNjMwNi1iMzk3LTQ2ZDktOTZjOS02YTU0NTFkNzAyYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQT5H4GIYGx2KICZTelypAH22jAh08ebflL4Uwicmi/XPkm\nSxDajpfCox+8rLiolsxzsb9/zuEVCDK05J8iiM2So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw73kuV65/GT+a4cVHoaBu6Vu\nddYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDje2RY3+M7FSMIwy1DHn8H1tX3XNYzy1LQb4eSQ0rV4CIQD9pU1Eeuet\nNUoyueEOLVEn/WoFl7h0XT3SCrc25iCAMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAU4uRP57pkCuM6GPo3Y4VII7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQwZTRiNWUtMzk0Yi00OTQzLWFhMjUtZDVhODAyMGEzY2RmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDVlMzEwODItODVlOS00\nNzhjLTk2OGItMGUzMGQ2OTVkYmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTYGyOa3wMB/z98XEUg/YT37ur0GO7/OlQlgKAQiEA/CLuhuRawpI4wO8SN+SpeE6\ngu0cJ2Me52Iv9UDVunsPoaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUknR2/8K9x2INpTOQ\n5NM1szVzG1wwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIGysElLhCVYCzHbJLvY/auT0ZETgQAOyWkzAi7aprC/CAiBp\nzqZv6JKnPp3avvT7kOjHPFh2hNrIBB2VyDfEma7qFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4271", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4271` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAfmjw6HH1lGIJwBAinUPM5e9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkNDM1MzVhLWNhNjgtNDQ2Ni1hYjg2LTNiYTBkM2RjZDRlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI5MWM0MmEtNDAw\nNC00ZDA4LWFhOWUtOGRlNTVhZjc3MWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpoB8ezb0kqbq4hF4SQnMY1sy0JOeXql3e+NVGbQtxvFLUwjoharlJJkigdcI\naCAekdDfByaL8jS8blPKqR1t+6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7N4uBf4v+cVKFe4v5Q3zWa5bIbowHwYDVR0j\nBBgwFoAU8J3za1nMREtJZi1IOs3yRDKASEMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA1b4l8s9cwKCFX9qMbFAzbhikS0KhWkBT\nMWoSCeYFTA4CIEn4BEk5B1jEpuxk1eH/yidZAoK78vK4D/pWuPsKtZXS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAciDTNmMXVODRM+uHSDbUlMQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDQzNTM1YS1jYTY4LTQ0NjYtYWI4Ni0zYmEwZDNkY2Q0ZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzgo2e14RuYj6GmnteNn6zcCx0ZokDwh3JXQ4p6YgtqWbO\ng1oHf/DMmgJvJ07nLnae/s6uzIeQaVUvz3zredxvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8J3za1nMREtJZi1IOs3yRDKA\nSEMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKDdRQJV4VbwsiPeCZ0rbcnkAi4NTlg5oujYjTrvlquUCIQDtqs5fSdIy\nnHDYalq4VlgGuFSrbZoapMbsFgn7bIYbrA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVJom63227dxw7DKIxGuoKb1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI5MWM0MmEtNDAwNC00ZDA4LWFhOWUtOGRlNTVhZjc3MWQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzU5Mzc5Y2YtNGY3Zi00\nMTU1LWJmN2EtN2VmMjI2MmU0MDFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPSSVXzkZ03zUmTdO2I8h+rLBVXyE5R8hlRK3JjK1uicmqslz5wK/IVFxDoKQ4IVB\nBuLgeevY16xuciWn5cac3aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7N4uBf4v+cVKFe4v\n5Q3zWa5bIbowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDhDIil70LJexYyn8s0kYeyPPQyzD7SZerQADLkxRv1aAIh\nAPF1J2/eXwHhpqoUC36H5XJIf00dXAyp8na8lG+mcz5U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4272", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4272` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAWDEPVz+197ngcFrQ+OINqjGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjZWFjMzFiLTc5MmEtNGRiNC1hMGYyLThiNjgxNzE1MDczYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYzMTQ4ZjEtYjg1\nYy00NGQ3LThlYzYtNzk4ODgxNjc5NTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy+F5QI1n4fYxphh04k45vS5yK8PHIY4Ps8o8w0AGL/9vQdwQGehInE9jvjXr\n67ygE0KdhpEybqyI8e5hwlslb6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCkedqF/fo+m37vyOOnVl//fgWCIwHwYDVR0j\nBBgwFoAUFY+Id7Rd0TCUMYDDxTMSFdk1FsYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA8tr9m4jATw82cTHD7v7NBa07vLhF+L9h\nIZw1hZfZ8iYCIQCiSWMufQF+h4BFGaVQYHVFzZhBYFS3hY0GjBbkwdFaZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR30W0ysCIYu+V5O/rSPg1x5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2VhYzMxYi03OTJhLTRkYjQtYTBmMi04YjY4MTcxNTA3M2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASch9Vw0MhrnSv2ZmiUKn6yWerqQze1rM0N66gglrXE6NFh\nfE9NpF9vUkEvVqz1NNzZS3N60kqzn2CRvzl8/Zjdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFY+Id7Rd0TCUMYDDxTMSFdk1\nFsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM/N9J2cTRhXNxZM57KqvRjS5NWYBHy8nsVXTcLubGhlAiAcwezXKu/H\njOAfTMhyYpPIIipLQ1HvufwT+PjapudNZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAcm0246eOSe55DAUlKOprtkaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYzMTQ4ZjEtYjg1Yy00NGQ3LThlYzYtNzk4ODgxNjc5NTNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzBkYTg3YjQtYmE5Yy00\nYjNhLWJiNGEtN2FjOTVlNTVlMzg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwTDvF3ExP6vvqt4tuKM0JoA5kF05D2Zxjschu7DHAQqFjG35iva/KPPbuDKe2/7c\nCGd9scibwA0wtz2QRyKKu6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCkedqF/fo+m37vyO\nOnVl//fgWCIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIDzIpli/iF1skSqzkYeb1WXhL6JkfJb162D4QNnyJQtpAiB1\nEEE+cyGeCl27GMOKaiGCL0a6LuvUWXCHIw27YXEx5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4273", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4273` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeqnUm0lulmoxKJGRBa5F0PBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5ZDdmZjc3LTg3NTUtNDMzYi05Y2YyLTFhMzU3YzY0YjUwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI4YTE1MTEtMmY1\nNS00YWFiLTljYzAtYzg4MTYzZjQwYmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeVO0YLgAGBt5B/AchQ5BtDIsaWeM3kddkqS+JT+LS2BSLMx5P0D6Eyw3vl37\ntDETjMb+g8hwnUj3FZmuRM2kVaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyi+bcZj7YP2HaAJHrb5tmoGAKFAwHwYDVR0j\nBBgwFoAUaDMND/CIHaQj+E8dpY0mxm5Z6fYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDWPFYJLRIvipNfAqyPylfM4Qvv\nEPlojpmWAnk3IEb2ggIgZOCNEDSFIIzxPffy7rrLX02V31OK3b5CFdFgAgMM2WQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZstVFsL2ZHNk8wiSCeD1Q1hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWQ3ZmY3Ny04NzU1LTQzM2ItOWNmMi0xYTM1N2M2NGI1MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV3M5ro0sQX8Cqx8EFFv3M54bFuL1B2RQQRw1JBbWMr5Xx\n1T3p0jx3WDwPSaQhl3y4V0R3ZxBcDZvaQlJ39RGMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaDMND/CIHaQj+E8dpY0mxm5Z\n6fYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEvaBb5ANUYnvNAdfdpBN+dR1N7PEZbS1dq7OvnJ3SUwCIGMEb/Jzkh01\ngxWgsBs7uxYy96JBoXc9qI8MlkcYSym4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISARhd2TLV8WcOxShKdRl6WYIfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI4YTE1MTEtMmY1NS00YWFiLTljYzAtYzg4MTYzZjQwYmJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDgyNDg4ZjQtMzUxMi00\nOWE1LTk5MzMtMGJkODRmYjMxN2RjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n45m9oH5WTysHmFi2KhzKMZbSSO5AqwEMlSCRyCjYg+/WDOLKvPnd/4FDeg0BKJpP\nbCCV/dc4VJrAVNEAwLq+PaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyi+bcZj7YP2HaAJH\nrb5tmoGAKFAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIAcrpZMK5y3X3i2NxKYiBGCXuudn9NOZ4t6k43FA2xhrAiEA\nzH88C76mkjeRdhh6fD5vOOZzXkRLE5tz7sVIghlAXd8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4274", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4274` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAbqKVfRMpg6e4I+m9t0HFJ+FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxZTQ1YjAxLTE4ZjYtNDk2MC1iMWRmLWU3MjgwOTE1YzI4ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmEzZTMyZTEtNDgx\nMy00YmM5LWI1NDAtZDYwNTBmYWI0ZTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn7iHwBFmpQXDAU3COy+LJjpEZ1DI00B6f9GDX+tLwquPXmEAfOGS4AfiDB0a\nB1TFzMuKixrWT+4IY9tVizJQsaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU30eSxG0TtTgBeRW6UbA7SE8kjKYwHwYDVR0j\nBBgwFoAUY2Go9eyLS6pgcRWXckmlW4UGVzQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgW0kMFHvl\n6w3luTRdN2Un4YbRC3Q+ZWr6rGXqjVjiPggCIDs/82FZOn1oAdilZSpGcSj4j4zS\nsKJUvyF28GdLTr7w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXB5a79Kjp3D4uREcMNHGTViMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWU0NWIwMS0xOGY2LTQ5NjAtYjFkZi1lNzI4MDkxNWMyOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHyWModnYUmPclii6IK7q9n53rGi8/a3CiY2GxFWvxNC7R\nIz8A7rfY5d8AXmjFFgK8hIk+ATJGd1Oimb+zs/lMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY2Go9eyLS6pgcRWXckmlW4UG\nVzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQyAwIdduEYyV7akjHuxTprtnn1ZudDf/ITbt/139rmsCIQDnCPaLAger\nj/utrgyJufyvLtJjkKK3TRQyVJ8mnZY3Dw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAX+sABUMKNnvsriNUp8sifQwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmEzZTMyZTEtNDgxMy00YmM5LWI1NDAtZDYwNTBmYWI0ZTZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWZmYzcwOWItOTg2MC00\nMTdhLThmYjUtNzZjNjQ1ZWEzZWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncJ/wxqt+B2a2W11EKv47Qe0ysjS4tPMR80HKouvc6gKyebcdtY3LjeNsg6hUOAS+\nvDaLputcv39clVUQNNUfjaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU30eSxG0TtTgBeRW6\nUbA7SE8kjKYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIDlwUVAqf74pLBIaj67gFgfvcbyOoYrUO1rV80LmvHBsAiAt\nQw+8LZZk7GrUnBOmIUSwk9VBL1Togq7xXuMXSChHCQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4275", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4275` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISARMUbv+8iOl0wIbIhLHp3GaMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxZGUwZTQ5LWYwMWItNDQ5Yi1iMWI2LTcyN2ZhMDBhMjJmOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBiMTBiNGItMGIz\nNy00NzI2LTg0Y2UtMzAwODJmNDdlODlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE86a44YIAi3gIyJ02wuFPfraaxFYp3Btp833i+QRVxPpdXftKQY/cJZC4GUfW\nZRYvo0NyzeOLJLK6GWal8LzVuKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdGXSZnZWkSkri/ANL4oEo63rRI8wHwYDVR0j\nBBgwFoAU8aetIKbxR6REzfFYaO8HMFOv+0YwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAME8agcY\nawDD7GCt4NoDjlfnXLPhtr4J+Gn8CK9Ezj0kAiEA9A9aVhq4Qw53Sisb7vwxWMFb\ngmrc4X1zfRJvwfkCA24=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbqomOukLgUDG5yL/O6+PACyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWRlMGU0OS1mMDFiLTQ0OWItYjFiNi03MjdmYTAwYTIyZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBh/oMQT6U8Vd6msSJWb8q5b6To4E6MNZw3XkLt4M+9k/D\ncfqZOoQMN7m9cN3WSraoyGQ2k1myjmOoIXSfEbnvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8aetIKbxR6REzfFYaO8HMFOv\n+0YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMLBBbmEDVvJUhuAPY42nNz3G7CCshJ43/EtC/UwZ0SHAiEAsAnsCxJQ\nM2pgbcDBukwQ0gEUZqL3gDIiQUWnKUQ6gB8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAYjROMaOTvd5fmw6Dsw4ua3gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBiMTBiNGItMGIzNy00NzI2LTg0Y2UtMzAwODJmNDdlODlhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2ZhNmQwMTktNGE0NS00\nMTAyLWExZDEtMjk1OGFjMjdhOWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nW3Ve1Ew2TcNRcRjATE7aXy7EO8HlTPiZRFcHLIfutn1rSUucKnbKyOK8z8aQfdUL\nyfKfcs78iTswmdsL56rCl6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdGXSZnZWkSkri/AN\nL4oEo63rRI8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIFyTrGcIBXkOfxlP34FZ0kk7xBrhCL0ymT3/hTnvg2NKAiEA\nwHARlehIeuHxZifdLYnaWtlJdCgKlAKqWVpQ3madDSc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4276", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4276` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAXmzuZF4rW0RS0T0zJayIYfpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiOGIxY2U0LTg0YWEtNDRkYi1iYTcwLTg4ZTRlNTRjMmE3ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY4ZWVkMTItZDQ3\nOC00NzE0LWFjZGEtMjhjMjI1ODA4NjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUBopdzTQ6eKkS2Mv9dOSmtDwokm+HMEdQpA03jjsyT4Uy7aujS/UCDlAzCyq\nZJly34aVmFCD5DvpXz0Krj0BE6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Pa7KvvpYODwacsfPhG3fE7641QwHwYDVR0j\nBBgwFoAU7eAf86lGRgL3BtXYE/yiuhXb9NwwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFOYi4o8\ne4shoPpi5co2heap8dXAc8h1SoseozVaaca1AiAg6NxNPFjHGYrOAXfBVPm/A4s8\nVEuyGGMAO/fRkSZZFg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbuiK1xcOgVMFECakS2FkcdHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjhiMWNlNC04NGFhLTQ0ZGItYmE3MC04OGU0ZTU0YzJhN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHweOlSRwS2yXkf7FrhWkDiqZtByvG67Zm+9bHVZgPOdQj\n1PrXW493K8Pg2cGW1/fUrC/G0zw8FzbdSY/6vS6/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7eAf86lGRgL3BtXYE/yiuhXb\n9NwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDyOvSlRNWBByMOCrQxhUjpnkn78RRXePT01DdKH2Y9gCIB1qqgyTTTPC\nPPJTybqqZaEsFC/Ul4RvrN3KVyQNiIhk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfhHLwUhcUW1pYngDnle69wpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY4ZWVkMTItZDQ3OC00NzE0LWFjZGEtMjhjMjI1ODA4NjM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTY5YTY2ZGQtNzJlZi00\nYmVkLWI4YWUtZTgwYjQ3NzY0MzdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9EZVTBOLmEEMiGftB1H1p4YI+dzSs6PYvN6InAfiCIO79Aye23LNcg3HzJDF2RDp\nv5qSpfHEfdk7wjqSsTI/t6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0Pa7KvvpYODwacsf\nPhG3fE7641QwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIHAHHif85PSO6H2T3yxBH9T2+JVTyyJhvfKZBLZzjXcPAiEA\n2viqS8rqhg+xvQHlGk9gqepUdmk1TW1GD3o7EQmUCD0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4277", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4277` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAX0lJ4u1phwKn9IIKnRWG4xtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYTFkODU3LTU4NzQtNDg5Yy04MTMwLWQ1NTY5NmFlMzQ3YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI4NmFhZTUtY2Jj\nOC00YjI1LTlhYWYtOWNlNTkwNGNjZmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhCNKnebTpTBilq4c8g9LNmSlLDCQs/0mxv05uBHuu8v0tDnjM7Z2XZxMQWvo\ndlxpu97yvB9hddu394PBIwKeNKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJTlvKReUngkz5OtBPyT+1ZAebmMwHwYDVR0j\nBBgwFoAUBt+usuY30nckifv6VU0QRXFcA2IwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDb7IkedYkpShmIS3CnWthuOzzTAdoSkKcXZW4RHbxa8AIhANbVtHgK\nh5sLJBb0iItDw4v/p8i6Pwo78qKzaKMDiALQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWY8pvKhvXoGkb6aZ7R3lSDXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmExZDg1Ny01ODc0LTQ4OWMtODEzMC1kNTU2OTZhZTM0N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzySh+gPpdodvviRRuYaMnWqpXffyaR1+vIRcvrvOagsHt\n2kYi2ZpNKey3Cf7vse8aUfJWjQzXJQXw0yW26Djko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBt+usuY30nckifv6VU0QRXFc\nA2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKh45qCuzVUFdIZuOQbKemA5xi13wuJDCczC6K1zpno4CIQCdEemz1kvu\nY/M09KXrahcxUOiU/xYRRoI20ivKWbGmcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAZBNU49Js+nhxh2HAueQUk6vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI4NmFhZTUtY2JjOC00YjI1LTlhYWYtOWNlNTkwNGNjZmU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDMxY2E4M2EtYzgwMi00\nODQxLWJjMzMtODYxMDkwNjRjZjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngIP65OMOris7ayokCI48eHxk8MJLhP+5oeIbCcD63n8zL+lXoyt8PxrAcnyRL220\nFFFRrf+lfzVJ28SSMn4DcKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJTlvKReUngkz5OtB\nPyT+1ZAebmMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIH6uld2tBiw784iaMsLWxc6jOEpZDbnP3JuGVouPGhPYAiB1\nEn0igZINs+/arCSvYVRlrBVAnS4kKcaRr5gcdwLCjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4278", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4278` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAYk4059e9hHOopQdhlQbrRkkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyOTA4Mzk0LWQwZGMtNDc3Ni05MDQ0LWQzYWU5ZmUwZmFjMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ4NzlhMzgtODk1\nMi00NTY5LTgyZjktZDlkMTBjZDY5NDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELHMHngRrPQXoY+HXOSZTP7ySZkKAoGvX6IxchoKcXNcs1/jLNkFp8UNTuZtI\nOJHP6Y3yplSeCLmJSYypXJUoTaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNxKSqNLYJwPgFrFGknKU9tXxqE0wHwYDVR0j\nBBgwFoAU3Fd5ijLLbxKIZSNy2G8Fhg77fPAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIFEchR4Y9nCfhSqF/IICZn6EfSAxk3MdmOaiJnzgjETwAiEAvCyEJON6\ndMMw/4vsNwL3KXp7I9bYGiFjvcuFATiKmqc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbyOTaQr+JmoXjZDDSRzwD+RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjkwODM5NC1kMGRjLTQ3NzYtOTA0NC1kM2FlOWZlMGZhYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZ+vGetqP651Pcx33+Ssh2m5bQjQdMMlwr6NRYu7JkspVt\n7C5NtgGnHCnOFewaHCOyinXRI7kqOib1JKaLEJoLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Fd5ijLLbxKIZSNy2G8Fhg77\nfPAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcarFsCeOm4TR6Xxng+CF3dQOq2Y/HCOtmjHqHYE6fCYCIQDZBl1jyJYT\nBxJQhzjaUruPzzEMqHeBSnzRkYZJGrAWMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfphUm5lnLGqz4/Zek5DtRC1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ4NzlhMzgtODk1Mi00NTY5LTgyZjktZDlkMTBjZDY5NDA4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTY3N2YwMDgtYzM5NC00\nNzViLTlkNDMtMjA0NGM5ZTBiN2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqQJpLMr37rkIMWq/pM6Af7HLBbcuk2nd3F+LixLpVqS44QRyp2mPqDEAaggtVCrD\nqOxWn+zpIUb2sDg7HGOyiqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNxKSqNLYJwPgFrFG\nknKU9tXxqE0wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQD39UcJSILbgpKQNoT0TFTK1NGWAMA+SbyJb1PxzQU18gIg\nTxm2EP2KX0+bCNPrHKWZx+aGPfYI6QPXys1aDlFq33c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4279", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4279` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAVqf5IBQXnFMCf8DJJPFAaj5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjYjI5MDNkLTdjN2MtNDA4My1hODdjLTk1OWYxZGZkZDM5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjRlYTRmMTUtOGQ5\nNi00MGVlLTlmYzgtZjk2NGFhZDBlNjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyuSz8wRxLwXDzsHZuV4qFJ7RK32UoK8qonkpisSj8e7LcWXqLRWhel5B9/fe\nVlaxQ3rF5YeXPkFtc6eolK7DwqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpdZlLMlGZQ4aMXH2/aFxv3avDqwwHwYDVR0j\nBBgwFoAUj1mDpzSA+VrK1SPssn+zTUqkC8QwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIAN+GjmTvcNVfEyIauKgqqOrqeAcc5JUJVdGZLuGvKmRAiEAs/djpEcQu5zKyX0V\nyg0A+5yFKWw9GOyPVohuhEo2hUw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXFe24ZajzqAptlbfn/yTx/nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2IyOTAzZC03YzdjLTQwODMtYTg3Yy05NTlmMWRmZGQzOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4HL3JxfqJkXjlzlSZgHLACHihdFcuVwJJzV3jktp033px\nQYdp/0VHQW44A3lhLyvenGMwG74qAd0Z0yHklDK/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj1mDpzSA+VrK1SPssn+zTUqk\nC8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANX88axVWcUL8FMmFGYnpSkrAnG6o1Nk1Mzf4otp2M3YAiBewZGf0MwS\nrbZJk3OnDJ3ch1C1UbPeh6nPHK2z2txGqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXTr+yGLRs1eGunRvPzW3eGBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjRlYTRmMTUtOGQ5Ni00MGVlLTlmYzgtZjk2NGFhZDBlNjYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2JjZTQxMWItYTg3YS00\nOWFiLWEyODMtZDg2ZWFmNDAyNTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nirJp23YJwOM18kXT8YrCcO8388jRrd/w7a+O0M059+4cBoJEQDqNSfXwUfOw2s/D\nMeeltgUVm2ot3vU65XCQn6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpdZlLMlGZQ4aMXH2\n/aFxv3avDqwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDWFW/3nY/w//ekjKVaT9nvFFHoNsmoZho4WNPdfivlhgIg\nPXWSN0GVWzLCyKZIWAsLHOEsdr2muYKYBJ6BxA5FKhs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4280", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4280` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAUfa6JZ7i8/25Cf+PUOEx5S+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkOGVhZDdkLTFiZGEtNGY3Ny1iMmY2LTZkY2ZjZjdjNzIwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFhOGYxMmQtMDI3\nMS00ZjNjLWIxNzctYzI0Y2VhOTVlODQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXTdoWVFmraCY0lKvfnKTl99K5aYN9EgD44UjWWQyI2jIJGTzD9EHiwAHyCTj\nFIZEG82Rm+YCY9U4d4qo13cL+qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfY8ddaY1G4Y9ZrxnT2nlHVM/Y5swHwYDVR0j\nBBgwFoAU7lHARCVDQ9NpCCUZoCOYJCVRAtwwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDG2CWBVaEjJ9w06LscXcDiG27EjZU79KNDahWUt9n0+AIh\nAJIWpJoz6cSSBxI7v4M2ypp3AYwnnCUS8ZgWnwjstB+/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUx8iGddfd9PFATzV68y7J2EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDhlYWQ3ZC0xYmRhLTRmNzctYjJmNi02ZGNmY2Y3YzcyMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9jI3Zivjtm5/HMOza8m+JS87RO/FiPiFAJWrF60ds2x/K\negFSy4p3MBnzvAlrUlmDUKzm8k6gJcLO6ow40oo3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7lHARCVDQ9NpCCUZoCOYJCVR\nAtwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP8xVptp0PJQPf0OOcyvjfK+6stqIjoB8iXHUxP2A2GsAiAqZLQOvuhR\nuHGvVu/XIAbnzNx3z5veaetQ4+tzpINHKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXd/gPw+jxXsBcEvJ5jKZ5E2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFhOGYxMmQtMDI3MS00ZjNjLWIxNzctYzI0Y2VhOTVlODQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDZkZDY3OWMtODBhZi00\nZmExLThlZGYtN2Q2MWU1ODM0MTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSD1abjZO3ef5MmcpV3oxfDNrfddd1NVmtixfTgTiArZtl4BwinTrfifQQz7lkowA\nTnScORW2WuRsc6T5+uQMtKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfY8ddaY1G4Y9Zrxn\nT2nlHVM/Y5swIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDQU7e8vMbVMd4GhEaOIY4IQ8XDYglHWVA4sYtHzatgGgIg\nCJFeCoGPjbutyLaVaXW7BrU2AOwBjEWRxcPrtyCylfo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4281", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4281` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAbQo07VD1wDTODcIE7rFCrnEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjOGZmODg0LTk4ZTgtNDIwZi05NzFhLTkzZWM1NjM4ZmE4NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJlNjkxNTctNmUz\nMy00YTk3LWFkODItN2Q5NDFiYzhhZmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE109300P19KYbQ0Yp8KEssReY2T74YdieTJW1mKruRO3+wAKhIMRnM80Wn+9P\nrSxS5bOK11TAOOWGlFTiTnAZr6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5S39SRoEqS8Huq9a3TcIy0cKut8wHwYDVR0j\nBBgwFoAUP3mOZ2768E1dsUe/2Kzo+JkMwyMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIF13GBczKebzjs5EO9yNV9FVkBxNaTDKuaPn7EAUuyjnAiEA\nnYQ7O+H4UDRxDh/+r8xTWh2JZmjJNB+g4G0B7E6sWrI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAczk2ca5DjWmGPnbYb8BDS+WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzhmZjg4NC05OGU4LTQyMGYtOTcxYS05M2VjNTYzOGZhODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/MLEKlQkv50YpAA74ACMHRsGAvDgTra8n5jYDWbyXcWso\nr8RUzw0AHYBFzvcu3Uy5vTTo13q7d6x5C9dQJMSxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP3mOZ2768E1dsUe/2Kzo+JkM\nwyMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALlkjEWEXyPmyFpU7r+k+zoeK8u8WZn6YYkA1X3P5yjUAiEA/iDV5/NG\nkqJSSc/pffFWmFMXkU3B2NTvTCUmbo66JdI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAc7/2eDDOD7m6FudGyIykTdaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJlNjkxNTctNmUzMy00YTk3LWFkODItN2Q5NDFiYzhhZmY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDI5NDY1ZmQtODFmYi00\nYmU1LWFkMTAtN2Y4YmI1NDhiNTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/WYw1kHDL52O2qYoA9xd4pjN2AMpN3JQ0o7MsfYrYWOmFEBlfNipcw3kPw/OWQVb\nudafQhJ5lTHord5+HFh6WaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5S39SRoEqS8Huq9a\n3TcIy0cKut8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCxMcpUVyqWt0VAGTn1w/MA3MEaJ3iKTwtBkFEZIBF7iwIg\nS7YCVt4SmSfgZ9BMaXyxKmVpAZ34DyZKEGC8mt1Y5Ag=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4282", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4282` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYSUt/Z0zombXjSy/4A5mIMIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NGZlMDA3LWFjYzUtNDgyZC05ZmJiLWUwYmRjMjU2ZTY1ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhlNjlkMTktYjU0\nMC00ZGNiLThlMjEtMWYzNmNlMjEwMjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHbKzuMWK9dBBuzjWF67uRfzihhVqnX3kwz3ae9TZbaisdzmE5Eyi+fMdoSSm\nIpPugrUTIA1yi7s/ZiRSZeWYpKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi94CDqhmQ9XciDyGxDFvnlbU+DAwHwYDVR0j\nBBgwFoAUasd3DcfJ4hNSXOulN/hVqHy67rQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIG07rOOPZGEB\ng0+YTtqkM6/UY1ZfvnsZcvgsvy0q0zQlAiB5arqUzuqMdvmCi2/FoIvQbMvTe3fi\noMRScy6VuNRYuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbD3ThWSQbQG43DFhgmLR86LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTRmZTAwNy1hY2M1LTQ4MmQtOWZiYi1lMGJkYzI1NmU2NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeEPVwTagQbx98N5O9iE83zrqwI/ysrPgZ2wA2FKBjY7sm\nkbEkkPjrSIjDJMt9X180vd0yfBhYTKr2GFeQIy2Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUasd3DcfJ4hNSXOulN/hVqHy6\n7rQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMo0Twyo3ffRr+yRriCEBsO2nMz2xNsnjyYdvwl156fSAiBCynDzHq5A\nb4iIiyNiiZcBvw9dbrAO57JpZ8v+5ER9/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbZm1Ri/Pi1ocqP7z0v54lHEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhlNjlkMTktYjU0MC00ZGNiLThlMjEtMWYzNmNlMjEwMjY0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjM2NzM4YzEtZjIwYi00\nNmIxLTg5MWMtNDE3ZTk3ZTVmYzQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSYZ0Kh77tmXta7iIEtX27Q/wtBF8v+MKH0aTgH1h1vD0usSMKvJRgFrJrmA/8vRb\nOFRG2Nz1ZoidnqlVsRG5T6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUi94CDqhmQ9XciDyG\nxDFvnlbU+DAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIH90GaHPwRHwu2bamt0Wqzo6KZQ0PvfiLzcheuLBnH2FAiEA\ntv4S4KZ029pcvwwdlZ1E4haONGYk9WpDWyKhK3Uhm2o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4283", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4283` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAcoU0MRg9SH+FDYmtccW2dqpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3N2RjNzQyLTA4MzEtNGZmNC1iMWM3LTgwYWY3ZjMyMmM5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY2MjFhY2YtZDIy\nYi00NWIyLWI0NDQtYmI1ZjNmZThjNmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfYrdV99It7B2NTskBAGQKqE0x/otkKX2Do8pyT4XtE/9xejMJiRow1FTDF6E\nASZMu1Jx+1PnnVvhCVlTAU1tlKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUemw1BFWfbQ1Q6zLR2181z9wGtmcwHwYDVR0j\nBBgwFoAU1Lt6yP9bBAYeZXEBS/FDZZW19HIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAKdVbnZQvB6fJyn27cT4a08mkPKzDYQPiGFJO7UFHX2aAiEAr192HW5V\noQDwiayaNaifZMH3dXThqkL1PP8vvgAwOnA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVbnbOfuGvI8Cly+9If/fhdjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzdkYzc0Mi0wODMxLTRmZjQtYjFjNy04MGFmN2YzMjJjOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsnwV5ymJdwciohLrY1SABCPkq/N8QTcu1N2HNDT5LQEus\nzlDI9lRirxOWD4OOq2EWAr+A2XUjChCYq2I9AeH5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Lt6yP9bBAYeZXEBS/FDZZW1\n9HIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUwMhLumsY3CAfcpxvHXaRMHihpaOv/RauM57430EPGECIBMnHd9ctVNA\n13Tr7gqvR+tToh4wLP4TFCfJQL7U2M/D\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVGzYS2mxKIecMncoHrQeqcYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY2MjFhY2YtZDIyYi00NWIyLWI0NDQtYmI1ZjNmZThjNmM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGNhYzdiOTgtZDUxMi00\nYTZjLWFhMzYtMTBkNTdiZDNhNjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/2eV3HBOnqkBHSswafbBPcabYnrnWjiwRxQB53FgUJ4IKo8J1/ZNMPqIg4dPU3Bp\nrx2HDurAxt1B68f1YrrJvaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUemw1BFWfbQ1Q6zLR\n2181z9wGtmcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCcweAPakv8yauHD6vIhK5wIWezDnhI+JF5010YZSMveAIh\nALLOwjWd05tCUFfNm6ZNterreOetbjLrC9pmr1xU1OC/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4284", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4284` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAX+eFVXeltTLSBOqw/Lphx2qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4NTc3ZDZlLWM4NTMtNDk4NS1hYjVmLTdkODQ0ZDAxM2VjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTEwNGQ0ZjgtMzIw\nMi00MGFjLWIxOTUtMTdlMjljZjcwNjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESI5mXzRyJYd4jjD9kPGWJxpczqhsXfsQpP6bE+w6U+I3velNFiIwBaG+l7RC\nO6T3O8L5c8nAwB2wP4sPggEiP6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAgHG3AIG30WcdAMuJfrny9wP8OQwHwYDVR0j\nBBgwFoAU/b0HGn1E9pFm6g3f7q4jGZQVbbUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgJiYDmuWdz0eN4Elv37o9dAZs5w+APchLv/mD0m5Iu8cCIQC9Tt2dKhKM\nt9VSUMiIKSqNdJTyqd4DDQkCHL4GAc2EHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYTM4zoJkzhKY3GUVk1SLTHaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODU3N2Q2ZS1jODUzLTQ5ODUtYWI1Zi03ZDg0NGQwMTNlYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi+4rps3Rsm4ZJC1XNE0+1a1tXu2N7qIQznRI+CurGvZSd\nvu4Ui7w5kpov6XbnZavG3SvGr3Vlmd7NPCdrP7S8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/b0HGn1E9pFm6g3f7q4jGZQV\nbbUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGjWUGLETDHqHH73pYCMO7FF6NHb80sQIcWWvW9wV6qcCIQDQhlH4MF84\no3aZ84ce6fwgaYfdsH9jng4ji2EaUc+QoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbfcF4kyC7uVfeG2e40/CNczMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTEwNGQ0ZjgtMzIwMi00MGFjLWIxOTUtMTdlMjljZjcwNjE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTdmZGI3OTUtNGY4Yy00\nMmJmLWJlNmMtOThlZTgwY2VmZDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbUO0tlHYClFkMw8rgLB7T6L+o9CU6b4ONqWbcObT7dbt2g519lUfcq2VXcw+cYWM\n++Ww78NG8CBL3XMR4L3GVqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAgHG3AIG30WcdAMu\nJfrny9wP8OQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCqsJ+o6Y7exKCWBo9IaG6xwWEEn40xOu1bzKzwjvMc3QIg\nQn5lFQHDHFdVXgmpOz2lzww+BPrzzORm+2my+A9Je2s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4285", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4285` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAeGjtcc5t16t74OFget7NGdLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzZjRmYmIxLWI1OGItNDZhYy04MTdlLTJkMjFhYTZhYjg2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVhNmIwNzctODJi\nZi00ZmI5LWIyZGUtMTY4ZTIyYjhkNzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqdDK++C2m+nxX93WmxUrQhPPZQvobgngSVNJFru/GSollFV1OY2VlcyuHs9E\naauECEgBFUa0DUoHq9lCYlfX1KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7zbRCm4t3pXtTK8tRnRTp8Punf8wHwYDVR0j\nBBgwFoAU0/UvrbTjBmwP6Ixsz4P6CjNWERAwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQC3xpjHeFVyD5W1k3af7wKyJtUhS9Sr4uBBnFtzEZpj0AIhALN8b34/\ng4b3NfRnooCaQ2l1z0WuNNX9O2xO/yfJrEBl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUKEGF9o0mINN6e6c98hYiKZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2Y0ZmJiMS1iNThiLTQ2YWMtODE3ZS0yZDIxYWE2YWI4NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATor4nN/y2B4YZy7GYuHeIGnkIwkPwZiz9m7mxx3WkrtNe6\np+0RI+A2DIw+DBX8wrIAyqYKjkkIJQ55ZgCaA6Yzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0/UvrbTjBmwP6Ixsz4P6CjNW\nERAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALnSUTJlUO09dE1/xVb0kfwJqDHV/vIeYBkAx4STB8ejAiBor1BoKC+k\ng0plbuTfGeEY8N/5MQYC9DOljegO1kMvSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAQJHJiAlMe/YLIaoHR15cDvjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVhNmIwNzctODJiZi00ZmI5LWIyZGUtMTY4ZTIyYjhkNzQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzE4OTIyZmUtNzE1OS00\nNTBkLWE1NmUtNzljOWQxZTc3MjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\npICZDVPWTsve0Z+UuLOI0vUCfrL4NDHpgSR3nWPdydJbAQlMhKcbtqSZ7bpExCJP\nrY1swJxVtywOeCAli0PWDKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7zbRCm4t3pXtTK8t\nRnRTp8Punf8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDLUYDNguzr/ywHhz+tT0+qj2wPDL0UY92w4Lnp7wU6jwIh\nAJ6gN2t8f6lkyTcN3sjqqduaFgy4dTKCo1rOgO0NvAWU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4286", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4286` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAdZgTjieVg5VndVoJgX4J1bOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwOGY2NTBiLTMxMjUtNGQ5NC1iMGYwLTgwMjljOWI5M2Y1NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmUxNTI3ZTYtOTVl\nMi00YjljLWE0YjAtYTAzYzZhMGQ5MTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2OSYyMDcf+ibJupSdlBLl4duInHU2epiHaYbq/WKMVuiKQiD3sFpLMXnoTpL\nWk6p+a7vN0LKnMtVQRa9h4igw6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDY3bU+1KkMtRmQ/DUd2dXgLURSwwHwYDVR0j\nBBgwFoAUCj58a66pxBr2bQMpW8lnMgEDdTkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCpYyqutb9cHUyxb4eTnnWVX+9HvAQYIpcpfGFz\n7Fr3kAIgD4d5Z5gq9FlQQJZ/LYLpwmrnS+jBsHD7u/XlU75ImFo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV2Tqw7lesg1ReArbJORFtcJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDhmNjUwYi0zMTI1LTRkOTQtYjBmMC04MDI5YzliOTNmNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjUXcvduzrkOhafFUMbKZlLoA6ebRV2bhQLNm9K3G6jAsO\nc+jFLh9t7xmRRpJ+5JlEPIeWpPm7FebznXLwo224o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCj58a66pxBr2bQMpW8lnMgED\ndTkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKETHANF0xj4vdZ0gOJKSMX4ODF951+T0E4uQzDTDAEiAiEA/SQH516W\nfDT+fkcXLautVo5UAukAHrsVv6ybU9x2CRI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAe9xtXEeFNnNvUJSLSyuWjglMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmUxNTI3ZTYtOTVlMi00YjljLWE0YjAtYTAzYzZhMGQ5MTM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzU1NzIxODgtNzAzNy00\nNWVhLWE1OTMtZjZkZDc2N2Y2MjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1Mpn68bWivNiGFdHSvD/7bhH3oLwhQ2DOMgaSrsNjDrkCDafykrcZQkCFeNCuBHv\nmrWKlRdAHlAF8nodMd4dxKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDY3bU+1KkMtRmQ/D\nUd2dXgLURSwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDNvmVMffYd9muylBC+PDxfesTiCQGI6zG0oYIbuzAxnwIh\nAIxNtld10gUHAJKiaB4HzcEmdcU1Sstx/TBWMAx+dWrw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4287", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4287` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZkS+tDLqxIcP7F1CLw33KI6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZDQ0YWI5LTA3NGItNGVjOS1iMDdhLWM3MjUzMmIwMTA4OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM2M2EyMjAtMDI4\nNi00MTc5LWEyN2YtMzFlNWUzNDEwNGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXIXh4HwRRCBNN2YvoJE3FyItlIgJHE3uupY7/rbAu5RkgB1fo1QP7VjvqDo1\nH5fz7xur9ZaTYFvQVqvsoAjOnqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyq3yZ3/Xgp9ZjaYANK8EYPbI3L4wHwYDVR0j\nBBgwFoAUE9mgj0p61VpykGg6pqPcT2pxQZ8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDMDnY2SfN9NIA4lFc5OkGXhkYF4DEBouOXisxF\nqivCTgIgI6jKQXAffo9nOj32rW53rkSL3BOP9JRR0+ea1cd5eng=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWs0z7c/jGPtmp3dOnGT4JhsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGQ0NGFiOS0wNzRiLTRlYzktYjA3YS1jNzI1MzJiMDEwODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ++/DYDcPGO3mfbUGguSxuE/w8mz8LjKIUAs/G2+q6g+WO\nADEb9QLx98vAPBYexMGvz6RDXd9REriN2rNaiPqDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE9mgj0p61VpykGg6pqPcT2px\nQZ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcSx/Ax3U3sFkKjMP6+aoDfAbhzGlEhso3W1lze4ykisCIDJslZD8aT+k\nHKuetk9TerALN8xy4MXcKPP+qdvIHcaC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISARCMyiKv+EzTNi5ri0waPxqnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM2M2EyMjAtMDI4Ni00MTc5LWEyN2YtMzFlNWUzNDEwNGM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzQ4ZWViOWEtNTM2Yi00\nZDJiLWE1NWQtZTA1OGMzNmI4ZDA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVz3P1WQYBlLf9zbUKRtKLfADVYjWBvxiDb8+mhXMNe7+YbI02fkgqpw5Rm3CWYmv\nsxAZKep9/i7uEi5u0+9RVaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyq3yZ3/Xgp9ZjaYA\nNK8EYPbI3L4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCUVNMFUdU41+JrFOpNvmh0Ns6b4TyDKVgIcRV9Kd/a/QIh\nAN9sKlBYQo3dcj4ZqEAKJ4WSEZIpi+TZrMgNn9oLeoPY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4288", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4288` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgKgAwIBAgISAcK9iLH0BYXC9O/aJzM++R/2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiZjI5MjgyLTdlNzQtNDQ1ZS1hMzU0LTRlYzYxYjAyMDJkYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTVmYmJkODYtMTI3\nYi00MTAyLWE3YTgtMzlkYmI4NjQ2NDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf4DqBJJFE/obzj6pSHqzhvE9APmvojSDli8Q2SjCyBC0tIzLJrPTuHcl2Iy8\nb/VnDN60yhs3Z/rYVvI6l4NSzqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULTyp72iUZUbPCs4Phy7DAMM/UDQwHwYDVR0j\nBBgwFoAUJwC/pH1ZO5mIH8qExKkrE5pvpnIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0YAMEMCH2cqxgYMIQlcnChXEoGpiVPcyykJGHbrKJrNqTJ5xjUCIANp\n6YaT3ODMub0Ms/FfnFrFdDDaRKjZD8+EhD00YW9W\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR3kXX2boRGif/6LAf141IqGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmYyOTI4Mi03ZTc0LTQ0NWUtYTM1NC00ZWM2MWIwMjAyZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQF2Am93BnG989T0sSOZoutXXlwIToTwwaMVajlOK2v8/6H\nhih26LZUVFd37w6/nfIiVfLXpPMxfYqIUt8mx2QAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJwC/pH1ZO5mIH8qExKkrE5pv\npnIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKx+PGTSEcVbibg4jISGiT9udD95YQySx44WIDKsu/dmAiEApsBRTG6Q\nQZYpk+DruEV3uVE4SJ/PQSVFfiCAUOw3Md4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAS4x+htGDizcgfnUEXvux8eaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTVmYmJkODYtMTI3Yi00MTAyLWE3YTgtMzlkYmI4NjQ2NDhhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmMzYjNhY2MtZTJhMC00\nYTc3LWE5ZTAtMzg3YWJjN2FiNTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ny+hvFdFvfFi5xroKmQ9paMtc0+LLAxf3lw74z2c0v5AK5b0rbGQ08ovwSCpAD3fH\neoDvLAv4ydW6KeWxpWZwAqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULTyp72iUZUbPCs4P\nhy7DAMM/UDQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQD+5WW1hK0Vqxbi0n8mV7gLc/GCOIwsPguUgbB/gT3vgAIh\nAPDMKKbzVhLWiA0H66SNQKiDNdTYSOWc5uF4Q+GVWOJs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4289", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4289` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAb8j9aoG/+MATDS+lQeBQE21MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmZjA4NDgyLTlmY2EtNDE2Yi1iZDg4LTFiNmVjZmQxZThiZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBjODhhZTAtNWFk\nMy00YmYwLTk5Y2EtNWU3NTI3OTVkYjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKWMb1wep2ocrArCdCBf3Uc2iJz5DORKx9HxA6xc8gPMknzHlVupU+6gz8T0+\nk3Xh/WleJydhe7qoXETgBdBN6aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsY7YcEYs669yV9ISPHRoJTiM0bowHwYDVR0j\nBBgwFoAUqb542sHeZH3JO/kCeZnFUxDODdAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIA64HkfkvnKKrMbzbDopGKV3Tr3gqCj+\nztiSxbwQ0OlbAiAYh+4XjNHliA4g/oTYAac9LEJblpmFB9E5J7ZJ7OmkCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeFDewQT1v/ds3CV1prfcbaBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZmYwODQ4Mi05ZmNhLTQxNmItYmQ4OC0xYjZlY2ZkMWU4YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeLHL8QQiTn2f3CgGmJxayQD8UNulRw2r7iy+2QID4qVOe\nYbki/pQ4HzcpSxsVpR8vG4CSdPJ42IMdS+r8jzEVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqb542sHeZH3JO/kCeZnFUxDO\nDdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIUYhVWqcL+YihYEqVW61W7xERYzWwymLBqoYdjQmp9kAiBzpIZFqzTy\nA27d2yWqewbknoX35V9DpCfgyDYKz/hoJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISASz8bwA1lZFqpZWyFZbCjVE7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBjODhhZTAtNWFkMy00YmYwLTk5Y2EtNWU3NTI3OTVkYjM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmQ5NmU1NTItNzgwZC00\nM2QwLTk3OGQtMGVmZjRiZDEzZGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndzffHpu3MOwba5rI/pEZupiYP0YMnBqQ2e7x6D13Z945zfBdveu1Oy+iAPmII+IE\n1+61RvxNVqXdKtEvhsvFi6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsY7YcEYs669yV9IS\nPHRoJTiM0bowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDMDPdrb+2B20khmdSFlONR7MRLjrn6RRShFvRR4FkqOQIh\nAJO1cipHx40y4yrdxCmO/XzrR29pNFP/OZ3LfqN0qMxj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4290", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4290` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAeV4Y7M7rpchXj/128mQS8PAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4YWQwM2YzLThkNGYtNDUwMi05YzcyLTQwMmM4ZmM2NzBmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWI1ZWEzY2ItNjFm\nNy00OTI0LTg3NTgtMTEyYjNjNGVmNzc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZcUX4gaLQ6X+fQWhVRhzLwoBa7qjYZLmSiqrOWApE0wnVMftB1cJcY1TXwlU\nHHMwEMHnMvN795wExvCVYUhOx6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpjnmEw9jOIlwlyQDnZlNxdEH/XYwHwYDVR0j\nBBgwFoAUAHCLHrNK4hPjYTQq9eUQ2VtEg5wwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC0SkemVP1vbckrEJFU81vuJr9VLtY3\n9sbCt6KegUmcugIhAPz2lqam0DPPaoTln7SjHqbPlT6wDgMuHeeeEVU0mE5e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARsKlG+9RcfIW6a8ZtKUMLJCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGFkMDNmMy04ZDRmLTQ1MDItOWM3Mi00MDJjOGZjNjcwZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpoetwmdX2nZI+ERagaEMY108ykjzVVV7FGmMza2DCPeiv\nEHtcK9Ig3eh8hxL44tKllCrW3iFfPgkKeahbMS6xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAHCLHrNK4hPjYTQq9eUQ2VtE\ng5wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKjGUwZnNfNS8MzrIa9Pef+mmGzmbDCA9aXazaPTfQPUCIEbbIlOKI6HC\najmDOLmR+okkfO7WVpkmUHzLbeYKAHpj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAR5PCoaOus+KmG5XBPfTCrhgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWI1ZWEzY2ItNjFmNy00OTI0LTg3NTgtMTEyYjNjNGVmNzc0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTIwYzc4OGUtZjM0MS00\nMmEyLTk5MDAtNGQyNDMyNjdmYjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbdkzyiO7RCyO6nosXSAWscUmychrknq2MUw3Aer3APKVsbcz69CwlxtFd9kgqn84\nKPTU7v6whQooy6gwL6LIHKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpjnmEw9jOIlwlyQD\nnZlNxdEH/XYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIHLzYoD3WwhwTdWkL5qLo+Na+Ee8000z1avrrsIuT0DMAiAx\nkOp8ieB1EEthDmnXxSMNuHauAvBUj/6bY0VFd6dTiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4291", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4291` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWaHti+Iiqb1SqA0R9bqK55NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NGQyNDAyLTg4NTktNDIyNS05Y2VlLWI1Mjc2ZWRhYjU4OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJiY2UzNWEtMjli\nMi00MTkzLTgzNTctMGZkYWI2OTI1ODIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3XiuAwzKaT04xyaB/HD8qPbiT97GktbtLRmLFOhkJi7F8EDeGA6XGkMu4bo/\nB5tzb7lWQ7GYceVDeXcs96CNmqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF0O/Me7mx5t7YJIjCfSxmJnijp0wHwYDVR0j\nBBgwFoAUEsj2m80RuF7Z5Jgdwem46UNYciswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIHgSItdSL+VB\nDeEh6rIjV5Xq0MAFejZWxRnq74cT/wQrAiAPbOIqj4+iFqIJlqpo+XFmZTLB53L9\np0qgwa8NSMl7FA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaND3RCwQITxmSEXV8PZLH+fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjRkMjQwMi04ODU5LTQyMjUtOWNlZS1iNTI3NmVkYWI1ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATa6iZUrB9S+7S0pZBTo6Ji9NXNf6293yzxtAi2WDQJ1U6l\nQ5M8WFHuj2nwEQa/94Ilo/9DhT0qAftP+OYpxVuRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEsj2m80RuF7Z5Jgdwem46UNY\nciswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMhKLE5HMGm+8ptrXuuMN+tf/9pmFkIAU/uhHUVHplNmAiBshVXf1ezY\nan0GuWz/2U9e2c51MQEN6vycfUTsImnHVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAdAy4fb8a5s5YzEVm/ChmzWIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJiY2UzNWEtMjliMi00MTkzLTgzNTctMGZkYWI2OTI1ODIyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjIxZTgyMjUtNzc3My00\nN2IwLWI4YWMtOTE1N2FkMTg5YjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3R3E6LedP1tLhVAF45tZwjbd8TC9BgnnbQMFYFto4pjdm/cA1C/T4wturdr4DcOA\nsIMP6ofGgNf95C5kF13+jKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUF0O/Me7mx5t7YJIj\nCfSxmJnijp0wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDrJG7ym3OqRziTHvbknLIEl1Bj/5aCRBnxvxW7dtb7UQIh\nAIVQxsYb4u62OoLHXqd5TsaSdDlXr5lPGg0Z2KPkHEeN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4292", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4292` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAYKiP/r/zE9dl3lT9L7KNQtBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZmIyOTFiLTk4ODAtNDdjYS05YmQxLTE0NzY1ZTU2NDAyMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I2MjlhYmMtMDQx\nZi00OTM4LTg0ZTItMzk3YzM5ZDA0OGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc51aOS6sA6cbrnQOshYsPstsA53K7v9algGirWRYB7h8FBxogtJFwFHIkxZH\nLMnB+JqY1UxEWFp/js9mvVujK6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn/PlYWCarIyR1W0YMHmjxxfuEx4wHwYDVR0j\nBBgwFoAUqco48XXywPyLVFymlurqiwKCGlIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgfejF9x8NFjKK+aqsFViANe5YHbh9/EPvX9CeouT/ta8CIQC1jY9d1VdK\nZen2LwhqThawm2gHJkWdCFJPj/bnGEqaCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYBOLIydAEBwdzlZ3QuYRzSfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWZiMjkxYi05ODgwLTQ3Y2EtOWJkMS0xNDc2NWU1NjQwMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOiAKmbCOyiWIYalbV0pCiFSIds2FlNtKXX0Ku2SZdnlFo\nfQwZ6DhXOASQ4sPM4RdlKMyT/a3iz7tgGbCXI9MCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqco48XXywPyLVFymlurqiwKC\nGlIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLLqHczQ2j44jHxodSfGEwYWWR1Ux8/e+PU4LJm55+sUCIQC3L6P1lRIN\n4Iw/OP8cPBdAjAszJfFI7u7sEwrnI56CAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAdIxODinEYAIOkFs4cRl4gnFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I2MjlhYmMtMDQxZi00OTM4LTg0ZTItMzk3YzM5ZDA0OGFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTI3YzAzMmItZjViOC00\nODBiLWIwMWYtYjcyM2U0YzhkOWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkzhKe29t3mAvjMbbmuHc5leDpbJCzg5oBzVgXKiGtti6WENuYmaA+vQQ+lHsxX/e\nktz/5A9+Fi6uI7L/ejNGZqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUn/PlYWCarIyR1W0Y\nMHmjxxfuEx4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCv4ubHhvFoAI8wRbHSlbSuiiwA14DovzgmVZtt9DNvxQIh\nAPC765X+wgNgwJNineTb3S7y4Ohcq9/Pos6SfRrlKbSS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4293", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4293` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAdA3R4Ww3J0tDk5v7WUDfSlaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjYmE3NDRiLTU1NWMtNDRiMy1iOTNjLWNjMTMyZmNmOThhYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc2M2Q1NzItOGE0\nZi00NDA2LWFlMGYtNmFkZTI0OGNiOWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK5SvQMcbYyidcpGGYLgFlsh8MQt3eJD9YKygHZOHOSba5+C1JZ/8gYGsNLC0\nMYzfkO7PmNTVpHRWVcVZk42rYKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFVL2PaWaLOTf0VbtK7/BAzG/EQQwHwYDVR0j\nBBgwFoAU9/omcJe6zrJ9o0lT17jRe7n7TrQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgGLl6DBpQv3Bu46Frh3/p9IBxogwH/qQXhzDw/Gp06WICIHaRGV/pymRu\nBFljZG4438pUXp64LPd4mN6wi6wr7PSv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZb6f34OwgAU90Ngo5h9mKIvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2JhNzQ0Yi01NTVjLTQ0YjMtYjkzYy1jYzEzMmZjZjk4YWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/wA6mYQmAogLSuu6mYX1fJikIb3pFJF0pWEx5Hcpl00H7\n/MBm921fk0iUV4rxfF9cST86a6SYlqeSWDpXuLGko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9/omcJe6zrJ9o0lT17jRe7n7\nTrQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgL8vjNs5IJHxSBDu5o+iX5z00HmoSWuhHmfJ3wUX9/f4CIQD126O6eg47\nFX8hDfk17NUbUJtpKjo6YzuRLq/mgYI0Xw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAThPky+HzQu6ug9/9aXc8n/IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc2M2Q1NzItOGE0Zi00NDA2LWFlMGYtNmFkZTI0OGNiOWQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDkxMzgyNWEtZTNiNi00\nZmZkLWIwZGQtNWEwZWNiZjFhNDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWy4h8zDkW5oxTLuZu1yYHArpb0PPMuiO1WytatNWKX0wrIRTCxqORw8bsQJotlLP\n0OMecHlD4uAXIrgO6rD9KaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFVL2PaWaLOTf0Vbt\nK7/BAzG/EQQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCZiLOtrrSZFsBldEkYqSnXND+q/NDtN75acAkZ65dbpQIh\nAK+2uW9W591ATCf2F77/w0STN+LF6fRC7UQwINVHVXmo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4294", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4294` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAcGfDZ1TPrwFcv4slyqkOtBHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhY2U5OTVmLTYzZmMtNGFhMS1iMWY1LWFmZDY0M2IxOTdlNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVjZGRjOTAtYzYx\nNy00ZWQ4LWFiYzUtMTJmNDNmN2M4NmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5V8V9ZaLXPkzKJVXh92LfsZbsoudtCeHaTvvqYofeftdSYUS4Eu01Y8WM52P\nijhJcgX1sfcoxX2dzJ0mNN6cNqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEDIDWgSD4/nV3+2qVvDcEdoIdB4wHwYDVR0j\nBBgwFoAUdXdnFBnTOAoD7zhNLTMvBHKHRiEwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCdyNHO72IDLI18FK1DClYjyP61QQ7lisXnutGHHpm5XwIhAOm4qv+g\nRtArBpfAUwF7k3Iq50fYoAx+TXsKvLlvEAeh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQBsrPoz0Tr+PV4XAPFatVg/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWNlOTk1Zi02M2ZjLTRhYTEtYjFmNS1hZmQ2NDNiMTk3ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx+Rx3QIsraqrAI0MY1AWUe+Foh/T+HOkO0z+R64tvmwdr\nd8WDthnDOGm5laW+5jm/0SjVPlk9kn/Tw7R7RzEYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdXdnFBnTOAoD7zhNLTMvBHKH\nRiEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMmGd2NgrxSHyNXTHchic2o+gCFJbsmx2p6fsr8MNksOAiEA05dhUotH\n87BQG8yrUQyZkTAtsD3iiBuOJkFWrS3eX1A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAfsEmQzsd6GfndUB/FOvi73bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVjZGRjOTAtYzYxNy00ZWQ4LWFiYzUtMTJmNDNmN2M4NmQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWY0MmFlYjgtNjUyYy00\nZTBmLTg4YWItYzkwNTAxMWI1NWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndCio+womc2MxaGwcBEsC8daKrps3cwUik/fCDSLkvysHkfPfZG/qR3q6BK2L2zUn\n6GEvO3woPbBmUttOSA6EhqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEDIDWgSD4/nV3+2q\nVvDcEdoIdB4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCICwJ8p+3cZeSGH3oVFzXJEDXZD+SBfiPntOl1B9db4dfAiAJ\nUNsjBSyXCs2s8tGzLtPDaVRIVWsy0CudMwTsU3cwZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4295", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4295` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAYw9motsnvje9HjhYOlxHJcuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MDcwY2Q5LTBmMTUtNGY5Yi05OThkLWJhOTE2ZGVmNDQzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODkzZWQ2Y2EtMzc3\nYy00NDM3LWJhMzItNDI1NWYwZGMxYmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsLYM6K33H/FxeAHfQxxyZiSGKNqRFDGS5MeEqAhaFQE477ANGHVr6lAhRcfT\n4zdsTYThDgYz7/ilZQWsbVUnYKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpPguaG/bLzJ8W5rf+OyTR4/2+BkwHwYDVR0j\nBBgwFoAUrG9geptpO3LvPxIhx/uWYIio+jMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIDkCNhKZidCNqWKAMIe+PR3g3LX81p9fux2k56Ec\ngOEDAiBQFTbLInoCKSK6BdkoJpN4wJbfz8c0Bnje0cI5B2kXzw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWIpKMsO0HExL1PTChmQuRjdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjA3MGNkOS0wZjE1LTRmOWItOTk4ZC1iYTkxNmRlZjQ0M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4rb2XrBWLHwnjPHIi0KW9uzS0rKgCrDMZ87pm9oOX7sq0\n4C3yQNUFgXGllAh8ltxyqB59mMEQiLxTdbpV1i08o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrG9geptpO3LvPxIhx/uWYIio\n+jMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANtP9hJujQi3fxU0Lnf0VeZPxZZSyo32RSnmvdEmGI/9AiEAshMazky0\nhGZsHfu/Bo29pfvkyJ/fKM39q3q5PW+iCOg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISASmIqIY/BEkxE1GeNLFkX2+FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODkzZWQ2Y2EtMzc3Yy00NDM3LWJhMzItNDI1NWYwZGMxYmYzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDExODI2YmItYzZiZS00\nYzRkLTlkY2ItNDMxODJlYWNmODY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyshS8mXT709qgAuj5t9AVSvPFonsyaQZ1nmC0CCQK+npTutlk4BrIhuuwSm6pmp7\nYG1FqyJ4OSgj/PUgjkDLdaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpPguaG/bLzJ8W5rf\n+OyTR4/2+BkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIGeTkCwKp/nlrDk5l/T2e+UUY93Um+z2OEBU1W9DMIGlAiEA\n7MRgjqFhHoBNjKLxSxf3mccdauhSE61HDYY0TAqOtL8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4296", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4296` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISASVwhML9dTfFg+jSpD/IH6xMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4ZjI5ZjdhLWMyYzktNDVlYi04NDMwLTY1MWFjYTQzMTA5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU3YzUxNzktZGEy\nOC00YjI1LTk1YWYtYWNhNmI4NWRiYzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6b24PLxaZ62iRzNhu0077aJwTlojn7mGUcD4A3EJ4nNBBLTieNey7UpbxSlU\nvJfjCaEOP5v749gP/FHAH3IgWaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS18zG9OPC4VUdYpIPtG4ICx0VVkwHwYDVR0j\nBBgwFoAU8q9XspACVT53xF/bG3iheAl1t6IwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDnfQ8FPvnXxE+CuqmH7jbOAngVQqipk7oHL/a7\nISLkowIgO6Ic0AMwLHzq+g8sQdc9keKinoffVFrvrtqhH/7+rtA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQDAJfVrx/BYdggcbl7Kg/IiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGYyOWY3YS1jMmM5LTQ1ZWItODQzMC02NTFhY2E0MzEwOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2YpUf4Mn64kTtuZY2qZB6MjLIbDJR3sBD+nigDL29xwql\nZTPiTyFEtmsLkvodRdm65B77zV6ozgqEwK+M6GLZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8q9XspACVT53xF/bG3iheAl1\nt6IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAJFx5LMUkMJwnSATfrqulX2y1LYaudDelKwHDn+v7vYCIDnmrAiFRALn\n61sOH/jzoONkeBD4zaBTzcr4XpAvuqjd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXLKxV7WIYt01CuYZp8EYtTpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU3YzUxNzktZGEyOC00YjI1LTk1YWYtYWNhNmI4NWRiYzRmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGQ5OWZjMDEtM2MzYi00\nZDc5LTkwNTItYmE4NjEyOGE1YmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngBqS51ruAjLY4dUNfvtKaC62taKoNpeoAU1MqkMXMYA2itkcJoXodB3MNNRu+TJk\n3oIg62iliCSLlbCXSQLrqqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUS18zG9OPC4VUdYpI\nPtG4ICx0VVkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIFplKNayT3PzBERrfCiPE7VPJhWYa0zL7LKMsHIT9sFqAiEA\n2xBlv+jE05HRsuGNwzfrTHo/b8mbiMVu0L9YK5VjnFI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4297", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4297` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAV/oFDVcoAnV0yvB7w6ADUJPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0NTM4YjI2LTRiMTMtNDYyYy04MzI5LTVlMGE0NTcxMWU4ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc3MTEyOTktMTBl\nNC00MWIwLWJlNjYtNWRhZTdlZjJjNWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdTBYm/LJF0qKVfUNN86QDzA0PWFhmFXwZa2/jHBZNmQkNMD9m3VJfgEs6voE\nEb/iiyoUk6P5l1W0V63YVGQpsaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8mh+cGATAGrCzGap3BndU//NBE8wHwYDVR0j\nBBgwFoAUYAQfedg7ormLQltW5MCioTFVhcIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIA8FHPBCcEoKZcpmzyDI7yWGohqcN6fkoFOARUatO2uGAiA4\nnwy7knae4IHB9kSh9jOT40GJ/bLc36wIwPGCe0HSLg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXNm+i/61nHdxgykwOqoSHmRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDUzOGIyNi00YjEzLTQ2MmMtODMyOS01ZTBhNDU3MTFlOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASx89D05tZwQPUFW/g1LI6Bh0lv+0I+CSXT2PZKSbC0Y3YW\nMFanLGIuYpLKADeUipeo88lbGhQ8ksZUhXw+wA1qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYAQfedg7ormLQltW5MCioTFV\nhcIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJkzdPC+ZSKqoqpakyUH+cTWKI1IDYsaGZPMvqOKLEn7AiEAwZA1VpXM\nSQnUjcZTkoySj5eGBAbKpV9zvNrHQiA2rOw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAW9HfUKFrsDxW1c2GxK3IvJwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc3MTEyOTktMTBlNC00MWIwLWJlNjYtNWRhZTdlZjJjNWY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzlmNzFhMTktNzE4MS00\nNmU2LTk5OTYtNzNmZDY5MzZjYWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6vMz5U5vH4ohxQLyYzvvMVSvn4o4wpf3cFqeyppdTc5EOplhtzb0XLGUOsMtsURc\nkIAobf+AGtzkIuFbthHJfqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8mh+cGATAGrCzGap\n3BndU//NBE8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIDnrj4HoxUCd80bWVDAUNRdgzkJ8hQdTwyvYxJDMD+O7AiEA\n+GGrRMSmQZ7mRbMtjauFcFr/7umX/2cuw0IzUlxneag=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4298", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4298` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASDQj/S3jO2eEp8EztuSYBsCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxMjIzZjI4LTExZDEtNGUyZi05YTkxLTU1NWU5NjJhOTU2MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjliMjhjNTYtNTQ2\nYS00ZWIxLWJiOGItMjgxMTY3ZmJjMjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpQZsiHDfktlhXsRkNANnDw4WBHgaUNwOeq1Ja8Tm/5Hd66W0OowOTS0uFhpB\nG0PWn7d20XSO47o1JAeX8RXFF6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUftkBHaxN+g8lohx4VAoBVf6l6rgwHwYDVR0j\nBBgwFoAUUCwE0NjSVZUMCYUn6f/vMiXipFswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGrd8obT4S54+BFdhlQYuKihAiJ3yt5o\nSW/++oCn5BOrAiEAqZlK4/KtehaRCrMeuKVYKOjx+lIfZ8w4bU0lfZ8j0fM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARC5gd4eahZXW3wIMjvkmyc8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTIyM2YyOC0xMWQxLTRlMmYtOWE5MS01NTVlOTYyYTk1NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1cU05FlScoTbTIM2L9dgVapgsRYikKxjVbiYYd5VsFAwj\nHgzSo+dJbbbMlOxpp0mWM020FTjGMh4dysmGU4Oro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUCwE0NjSVZUMCYUn6f/vMiXi\npFswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIa5a0pLxMzw2oXJnMRDyZqlCwNVtTbeect9XqLrWKIhAiAaTs2Np7P5\ntWK1HXI+Ab/f14XjJZLc7Rh+TDPItgSwtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAYkJ9cRpet56gXU7LoFZ3frHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjliMjhjNTYtNTQ2YS00ZWIxLWJiOGItMjgxMTY3ZmJjMjMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzVhMzllZjItYWZmMy00\nNjcyLWExNDMtNjU2Y2Y3YmRjZGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0zhRYlqs53KRxRDKjdYKkMNUQ17LO2qxzrsnCIMXMEt5tVUEP1B48DadwZ5Tptvg\nAILlZ7qS7BpE5a5TcUkxH6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUftkBHaxN+g8lohx4\nVAoBVf6l6rgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIFDNEOO2DsvKWHEV5PJqztlG5uAJPaBuJKaf2PCUDlRuAiB8\nQx5cIfqXGk54ntt2I2FcbiSqdSPpnniHxUoTbEi4Cg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4299", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4299` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAen5OfTf3JYq3oKEVhBno85KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4ZmU3Y2RkLTIwMjQtNGNmMC05NDExLTNmNDMwYWVlMDNmNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdlYTQ0NGQtNDVj\nMC00Zjc4LTgxYTEtN2UwYTc3ZjQ4ZTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvUPwa3u8ypXEnoDWeahbnwzAbJA9PuZN6d6OuiMnY0xx280bPaW9lJao2fDR\nQUMgerg7FSvck77XFM98ajuaT6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzvz74PSgyDlDuHHkHNok92ch20QwHwYDVR0j\nBBgwFoAUz7wDKqEH4nXn92DuKJxLCi/oZq8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDONXeOqK7in78WmlrcW/7bpJFcjPsz\nQDDL+cxUy2eAdAIhAMvu+NriBQvazc4nA8+wzfxmi35kCS5s/Z8nXvkkTnqX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYk7Avr+taIBgJStVtbpSCVHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOGZlN2NkZC0yMDI0LTRjZjAtOTQxMS0zZjQzMGFlZTAzZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT32mhTsQBq8ChoH2b3BbMDG0YAWwKgttIlCcvQRF3by0ES\nnFxiWSR7BrtWiORdgW7RWhlkrtEVS4ofblXC/Vkwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz7wDKqEH4nXn92DuKJxLCi/o\nZq8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdc6+EnQlbQoh94HyjhgLdSQXRsUeFjsBTL86j5idQhICIGG882GIWSjU\nYMXVF0ASTjmHLddrzK1Ad0Z34PNGgJBV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAa61mred3IxkpSQDoX1oz2m/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdlYTQ0NGQtNDVjMC00Zjc4LTgxYTEtN2UwYTc3ZjQ4ZTQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzRjOTA2M2QtMDI1Yy00\nZGQwLTlkZDctM2E5ZTUxN2U4YjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n033YjYJ8D3zpqRPklQ9QtNeutOMsiQ/IZgNPaWhxZaipcx3uSQimhsMMrC6Vs4Dl\nG7j4pKfZXaxHSjfLOQkiP6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzvz74PSgyDlDuHHk\nHNok92ch20QwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQC/ycYsNXejaRNmhu5uawJhzGrls1L/2+DcW7ZJitAWwQIg\nKQWdMU0JhRqc7dpOhuNwZA31fF4yrI3PZ9MxbOuucsI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4300", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4300` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAaan8LJ0ZAQaIIJFvKeKWqcUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyYzMyZGEyLTkzODctNDk1ZS1iNTk3LWI3ODdiNzIzMmMxYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg3NTFmNTQtNDg2\nOS00OTRhLWIxNDItYjdhMzdhYTBjM2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV8w8OgvJSQj/l58jIojsBhyHl/mY4Bo1zab7xR8vnziymCSDkHyx9ELCE+ZH\noF6fXWTqxULydrHpyFk3TvDRvqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGpMg58iVjimWJ0mnF8KmL1ZHO1pMB8GA1UdIwQY\nMBaAFHt39IYZvYv0uFfx6zzyJs4wXsf8MAoGCCqGSM49BAMCA0kAMEYCIQD2cm23\n5SUARIpLdFbd6kKFEuauOXQ1sj94SfsPJGiwVgIhAJj0kXRqhafANE4/xwVheE1C\n9wjOIp3J05dAYozXORk7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXCcmBbvfv1xJWCK9fevdf30MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmMzMmRhMi05Mzg3LTQ5NWUtYjU5Ny1iNzg3YjcyMzJjMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJkxSnkz2NpBRGBMzDRc8YdQeAca0vKhPoUstuICIVXDRY\nHU3WKsFOmh2bzVxUEPYfIYfTMhsJvXSeeCgAoYhOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe3f0hhm9i/S4V/HrPPImzjBe\nx/wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfHdf1BgLyuE9etVIIqv5qwRUeEoUmE+367btaveU2YECIQCiF0FPT+Wh\nYeXK2McGVgB5QznYp9C6Rk6XD1llgW7oyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAdIv2AZKoedpjFAk47aaja0sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg3NTFmNTQtNDg2OS00OTRhLWIxNDItYjdhMzdhYTBjM2Y3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2I0YjQxZmQtMmViZC00\nZWYzLTllMTUtNDYyMTk0N2FkOTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLwCPRU7k1fyD9NnbPqsRdIsknvVLq4RDChtqkxRGaoGBdJ80PUcR6Jt+8vXwEUEP\ngKJQw4YeTPwExnNviDnosqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUakyDnyJWOKZYnSac\nXwqYvVkc7WkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDRzZlrmVuDhhBvLjYMXxxexwVRcHsFpzVGfP8yxkWuAwIg\nK2dnRc/8uE1PANvoZHl8ypg9Ob6mC8Ol6kjmeAtB4wg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4301", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4301` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAW+i0AhstmcjIt8gHndmLjfjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4ODRjNjdmLWNlZjktNDQ3NC1iNWQzLTljYmQyNjIwNGZkMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWViOGVlZDUtYTVj\nNi00ZjZmLTlmNTgtMjdlMDljZjA2ZDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDn++OcAtZPC7CmsSV/kW3QCTHuGGr6OP9oQig55fY/XH2IgUSI6kSdTyBO6l\nsZJD85evG4cIwKg0SqwiVa7Zl6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPX/z2wDfqKmDsdUVtnRGCAqQ/1XMB8GA1UdIwQY\nMBaAFM9R9TcFwvdHp2GEIHB66LUEnY/SMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3TYkO4jshon5mmzapbbocCm2/1/0ECyZ\n1pSjowtoMscCIGmSNH7sXwhv6yUCH+7VBLP87CPapkIiBmCRcq5w/kqp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASpE5Nj49o+neSsTodnmpm59MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODg0YzY3Zi1jZWY5LTQ0NzQtYjVkMy05Y2JkMjYyMDRmZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSDItg3GLtjB52Q6rugjfc8FLZYMV3FzDzuBhLmUbmr8+1\nWbraAkN1XRDR3iuWT1230oIaq3K5lkQcibc/+lbso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz1H1NwXC90enYYQgcHrotQSd\nj9IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPtxrg2cNiMucuW3gxRA+H/o/naN/Ij5vXRaQR/oTlYyAiB2umnjl2Bf\nsZXkMeRX6JGHDafu7wtwNcoBmpvyJwFAdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWxe8lzBcd6yzniHqUZ9Yg2iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWViOGVlZDUtYTVjNi00ZjZmLTlmNTgtMjdlMDljZjA2ZDRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmU2MTllYjMtYjhmMy00\nZjMyLTlmZTEtYjMxMmQzYmQxNzFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nF/8B3Vcl5nUtqeMOVHt5vR8xjlTLTPgf2hdK3lL9RcX59vemW6irp0/i+PvT6Nau\nKf3iW0cXczJ+dA3T4ygLe6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9f/PbAN+oqYOx1RW\n2dEYICpD/VcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCICdy1Oh7VPaQAis7DlWmaR3ftRUpLl8EmMPWS03SwSWDAiEA\nlzWy8qz/7ehHke40coWsF3trPqGjjnAqbZq6Y2nhAlQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4302", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4302` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASd3/Qyl3zyD5sdZsHg+sdKOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMzFhMmZmLThkZTUtNDQ0OS05NWI1LWEyMTE3NGVmZjkzMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI0NjZhN2MtOWY1\nMy00MDlmLTkzNjUtZTYxYjVkZTRkNjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9BUkvAiYIPb/IH9Y9YCxr0b/SwJqeBBTS9SyUZglA3CPoCv0Xvu+oUZ4B1RL\niLDD3aXxHSxMRplL5SmxFqBpI6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJP4oKpP/8rXBVfLkhKTVR6AtSu3MB8GA1UdIwQY\nMBaAFJyEG0Qrem1bEwLRTQao4rS5k/FnMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA1dpfSC5LttqZcKRUm5j1lg1kAzEth386F\nU4UJLWujhAIhAI8NuykPTX24ruVE6xbMMdkKOHzmI1bbsz84cfvf6Xnz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVRswFqYgxjLuMgoPiNpw+xsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDMxYTJmZi04ZGU1LTQ0NDktOTViNS1hMjExNzRlZmY5MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRdqxunhv0BqL1Z/t93TzTmjAGVpY4XxiPyY/s9NIW1Orw\nGhkURLZ0mX8NNrbSG9wGjtdPgAUeNh62b6Bhoq4no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnIQbRCt6bVsTAtFNBqjitLmT\n8WcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE7o9ablO4PBY++JqaHD9G1KlX1nXoR5/ZiGT+wjkzd8CIQCGYQhKUsdO\nmtuIfEk6FwKEYnQ1m9p9wbWV9SV8dE1Cxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAY0ikPlhpucy0Y5ZgMldtfMdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI0NjZhN2MtOWY1My00MDlmLTkzNjUtZTYxYjVkZTRkNjkwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWFlMmJlODQtYjMxYy00\nYzA5LTllMjMtZmMwNDE2NmFiYmI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4OA8U7MxPYwsmt+Py1KxlaAnx7hFkaef6Se1JSB7ZEBYlO+Xgb3mTdnp+Z3pqgCC\nB8jKDm1jw1jsk7/vTYoMuaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUk/igqk//ytcFV8uS\nEpNVHoC1K7cwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIHyD0Ke8EM4cBQ4SR4388MeMttMkuU+lUvkhz8IVzxqDAiAT\nERdCW3vPwh7WbuDhS9nwcw2anecggc7xxRYxS2euaA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4303", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4303` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcRFzeldeZXj/ooA9urH80HrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiNmM1MzdhLWEyNzUtNGM5OC1iMWU4LTAyZTlkMDU0NWJkZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY5Y2RlZjctNzU0\nMC00ZDNhLWE1YTMtMzk3ZjdkOGI0ODM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmH2hl+6gyeaHvu/obsCvXAqSOZE69lGC4f/GsH9+s71IRb9qPitMMUIL6EQO\nZPofQZEyQCaV0uWzQuZ1J+nlLaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQjAL1P+HLOvaRSquqjHLyfhOzEVjAfBgNVHSME\nGDAWgBTtIU6lTUNx16IdLq1m02fHc0BSrjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCqKI85I0VQ97fE7kwJ4l/4CmgoOafg\nCcpUiVYyLkzvigIgFRFis8tWg8Oirdifa33aPGbUJKyfeVb9cLW3XtTvBs0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa1HM+S8YhNwIzXtC7CHlh2jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjZjNTM3YS1hMjc1LTRjOTgtYjFlOC0wMmU5ZDA1NDViZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQg2wNEtI5HVxlVVC/CiXMtUxKa2iyOWUn6In6OocmJptdJ\nJ+FvR1XeklGCy+DhCIAlNbmiPONhfajBoa+dkjLBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7SFOpU1DcdeiHS6tZtNnx3NA\nUq4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALd5Xd9If2TLpeKxOxiWgrE8vLvZ9RGDUG95202hmbD4AiA0iHre6NI/\n0PrpLgg93AFaGZ12PeqWn/oxynb7aPR3Zg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQP3h4p89LEhBfW2aDhzmA8IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY5Y2RlZjctNzU0MC00ZDNhLWE1YTMtMzk3ZjdkOGI0ODM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjkwNzU0ZjItM2EzMC00\nY2ViLTliZTUtOTE5NmIxMGNkMjYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/3sGLNCPbFeUA9l3Gtjh5OEKAhH7e+mz7aiav4764VDOGX51YsN1fYqtthAwTtym\ncOdLRHmtDL5leF4vDlkf3KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIwC9T/hyzr2kUqrq\noxy8n4TsxFYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIFmzHyEcKETv23NuJyGMgbnP/YAj+hSmzSSHreNFd7wMAiEA\nqz6bruJjJdzHROkGXY7KxryJhMLD7wyGArI98rDoY2Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4304", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4304` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAfWHFfoxOuee/NZRPSWu8Z/MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MzIwMjA1LWQ3NGYtNDQ1OC05YTU1LTQ4ZmY3ZDAyYzY2MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg1MTZiMTMtN2U5\nMy00YTAxLWFlZjUtNGM4Y2QxMzlhMzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECROf1xxI4Wolh7dON49ic70DdS74hzEsd0cSa3E0jUUFZGqfAoJkJn9r3OiU\n8opCbpgKZz7G+ZVHNnvcRnc9UKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM/FxcbLqh8yqjhZi2IX6YBSAGRUwHwYDVR0j\nBBgwFoAURW2hAQ9gr+X4+2HoqjpdavAkYgMwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA8e+gOlQGxnBl\niCHuJZ+47S1zke4N4NgF5ODEvvODFl4CIQD8QMpxnVYk+HoNedikcNTQmVFCrzsF\nj1qJLztxN8ih6w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbJ7+AK3HqbOSL68kZnzqMJnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDMyMDIwNS1kNzRmLTQ0NTgtOWE1NS00OGZmN2QwMmM2NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3s33adFvZd6s/OtFn77lsMANry0lvgODzEexQLtckGTt9\n6lu6E4FcVApvhyNXB91jLZOo8A63mtvejWgjfpHXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURW2hAQ9gr+X4+2HoqjpdavAk\nYgMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOc+OmiO2EJ4z8hqO7fNCRYPmML7fArMnczigjAk91BeAiBOiUnRBQuT\nbz55zumPxc3Ipi2pCXjwvNxq+Ehm0o4dvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUmAiKcsODeMe+sTHaJ1XugOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg1MTZiMTMtN2U5My00YTAxLWFlZjUtNGM4Y2QxMzlhMzE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODZhZWNkYzQtYzkxNS00\nOTVkLWI2ZGUtNTIzZTgyZWU2OWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNPaWqP8G1IboRK0K2c9uQnSA5euA44yBLBcwIKgqFOvbBYjcSmCuM0Y91Fq6yqM9\nWvCwedLiNiUhrREGYY7qmaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUM/FxcbLqh8yqjhZi\n2IX6YBSAGRUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIEZ7kawWg4QxbPCFozPcbIIsJeBLoXicHnHl6nDvEZiuAiEA\nv9WqqMDzegL4zDPQtNhpMcASpXE2JGVoMtfCtJkxFns=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4305", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4305` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISASghYd7Ce1QxzafWwFWp9RXCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViNjdiNWU3LWNiZTgtNGRjZC05OGE0LTA4NjhiMGJlYTcxYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZlNWJmZDUtMjc3\nMi00Y2ZjLWFiN2QtNDZlYWVhNjA2NjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqLHX6PysQ4sAGyorDieoIuVoKd8fjdzw2Yy2KAt06Az/lkb63zX9BeYOlNYD\nmcShv8vq2dzO9hO6BUyZeWe04aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQakoP1VfTXYMpt2Dt7pw4MgD2jgwHwYDVR0j\nBBgwFoAU/qQeKhRDt3Jtm2GbOVtQOvy8HwYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBLgrRhTxa1t9NF\nrPMMFGlE3ldc/EKhYyjcpdAmiCYzHgIgX6rxkEWJbNlQxPkMoIAZzNh3FUrzGNd0\nZ6WVfld2T7I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX8vsEZLY92LuLFDbgmt4N5VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjY3YjVlNy1jYmU4LTRkY2QtOThhNC0wODY4YjBiZWE3MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaxwRYeiD6WYv7O0hCWwtbRX/jCoJu+fNcbdYQmUGiuket\n3X11hbfwQPTtWWwD8QX6z9jdGW1nqB2CLTGJekaio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/qQeKhRDt3Jtm2GbOVtQOvy8\nHwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga/QAdfqMr1CihtM3C7unhP04U8k4muYTUwNd+EEuhZ0CIBDEZ/kvE4AI\n/zvL/IDzTj8NhnBZ7pJNYZDlxB9T+gom\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAX1zkREHcy8pQQdEBWcxnE/yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZlNWJmZDUtMjc3Mi00Y2ZjLWFiN2QtNDZlYWVhNjA2NjFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjExOWUyZDYtM2Y2MS00\nNWM5LWFlY2UtODQ2ZGQ4MzhjMjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0Ddz8kH4bD0AHmA4MwZ+Q0lW7ljmFCy7Y8kb7LEWVL9dfsT0oqcULY7iM5gne7Lp\n4w2XVMM7L1WIEaKGO1PCmKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQakoP1VfTXYMpt2D\nt7pw4MgD2jgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIEbPLVXaa7Rl/xah2wWMe9slGVy40fuJ41gwkQsXr7JpAiEA\njPIzrXvj65+x62iKgFZpYPCN7gA/xqSKeDj1qFk7gaQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4306", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4306` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAa5PCsal1C+Sa6HplC34hGNiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ZDQzYmE5LWQxNzMtNDY4Ni1iMmQ1LWExYTY1OGU1YzlmNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYwOTgzODUtNjdm\nOS00Mzk1LTk4ODEtZTFmMDJmNzRiNzFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Vkt6Y6V03bdjp+JaqqIjXrSTQqIb/Cj3SQLTNXFNEoPmNJRG0OJeg1sKyGz\nhm2efZ+cpzojRovPC0tzo6tojaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgiIGWd0tOL2pkiydNv+VM5XT/TkwHwYDVR0j\nBBgwFoAU8XrAh+heAlv9P559LFHzA14CsYMwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAxovhpjIaQIeHZ1o12nLf\nOkca3d34f57wLavpXap8YgsCIQCCPo6ncnIX4/O4ZRyUUTInYLtpJ2odVYUoempf\njpM+sQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYH4wnZa2IWkw5UmSwy8HfPxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWQ0M2JhOS1kMTczLTQ2ODYtYjJkNS1hMWE2NThlNWM5ZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEkt458M6ERLQ3B0vacmNa80TQe68VtDrmRJsCYK9k5klJ\nXObAwoQGjqlDuJe9MaR/dp9hvnvFivheTUnUeCPTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8XrAh+heAlv9P559LFHzA14C\nsYMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKrD8yZKMoWF4FWwkq44lU5h/LT8bUZtRTAjqXLjdjKzAiB5JyEhJCw1\nT/lZ/QJ47/Torh8gyJuQeDNG0gwVnpmxnQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAeM+8nuvZWnM08z73vB+TQvcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYwOTgzODUtNjdmOS00Mzk1LTk4ODEtZTFmMDJmNzRiNzFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjAxM2U4ODgtYTkzZi00\nYTQwLWFhMTktYTgyYjcwZTVmNzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5brNKowzWKtA5ziSkrT4ZsK3re6+d3I1vPW3G3ZHJMsohG/L3KxwcleKYlvurJPa\nfF4FtZsjmmFvb5qloAEh7aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgiIGWd0tOL2pkiyd\nNv+VM5XT/TkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIGfJY+gSkcLY7fV8q4nAAthgyuc5wlDH586sy50M78GUAiEA\njiJ/cHFXHy/7z9670xfHg/BNdMOsbqS/k8Bp+I5NcFc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4307", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4307` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAU4jgaYtgTvfOCiypTKgAZGiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ODE1NzMxLTIzYjAtNDg1YS1iM2QwLTA4OThkYmJkOGVhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVhMTYxN2MtZDZl\nOS00NmNlLWJjNzItM2RlMWZiNzRlNDQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9vmrqEiQtuk5W26iVh4dcX44/rYntPEQ3gpS0q93QlV/TCEjXYZW3Ph8jg5s\niIOrdWbdjKDsWN7bAmjU7N58LKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYiwbgLzhzCy0kdlOGYohibwNPT4wHwYDVR0j\nBBgwFoAUYLhA2XJx0s3pdSaqWhHpzpfvGAIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiATU+jF\nNfHvHS0wN/M5ywDYQXPfNd9mM3cAM4BRvI2Y1wIgWSnbUgYaxfTSe7GCtDSdXadi\nlvzqb6TauZFx1hQ29Hk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZmr5IrdAT2nvHO9A+31kXuoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODgxNTczMS0yM2IwLTQ4NWEtYjNkMC0wODk4ZGJiZDhlYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6OafUrB/DQIKHhYvrUinvwxtyxwCWaIi5vx0EFdZwstSA\nKg0Vrt6y+N6LhKtoTJN6ULR72eu442XonMIJbVYto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYLhA2XJx0s3pdSaqWhHpzpfv\nGAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALQeO+PHQfBlzpNYH6nHY1okp2s35aK9mHOcglm1ryvHAiEAsiQSwttr\nhMHlQ2ZAuLfaxDVV3T8GFKa5llkcZSHdoH0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATHBA2g8w1dDv9l/5tDUNNG+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVhMTYxN2MtZDZlOS00NmNlLWJjNzItM2RlMWZiNzRlNDQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTQxOTZmNGQtODkxMC00\nMzgzLWEwZDMtNzRmZmQ3ZTgzODJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\no+HJq+NgYPKQmvyFA2NQ65kTCHRfG4/P7yhsl53tO3J48g2FoTKAaHNumXYgTINV\nJjE5PYgl+WhLe/PcGee0HKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYiwbgLzhzCy0kdlO\nGYohibwNPT4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDfe7U6uk2Sy+QjXv06aRMswh8vq4EpL5+YrjFmBU7EYQIg\nX18Po/IHAgGQCayeBMTcWxm/D7wkANpe27SpBb05B58=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4308", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4308` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAREW0ctToAL8WKM3H9QQViSnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwYjY3MmYxLTU4MGItNGI1NS05NzUzLTNmZjM2NmQwNjZhZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmJhNDc4MzQtMTcx\nMy00ZTY4LWIwYTctZDRjYWFmZWU1YmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE20yiNxXng36LokS3U8IoyqtwCNk/CPYci5U7WPNtn4LnuIq20gSMbdSItPDw\nOQ620xebZb+vjCTrUZHhPB1tQKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi3wTONM/U73Ml82Lws2ZB3EeFKkwHwYDVR0j\nBBgwFoAU0r/FIF8uJiW+XCEOZRmMHib/IGAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAu32i\nBQ5FAfEpmbAEO20P73pJxoR27a1Ibf3HDYHX+uQCIQDoQujnV2Q2vaZLrWFJncbC\ndVm8mVkosYVszPDUPO9pAA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa8cr5a6KN7wx3Gh6qSllYBKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGI2NzJmMS01ODBiLTRiNTUtOTc1My0zZmYzNjZkMDY2YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaQPuyrZ9cTaWhCJhAerUhDGsBDvuEbZmzm4DFEYCXcKt/\ntK8Ru9IjfVzqzlEDPjSgWRW+frMhym1LsuwKbg0lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0r/FIF8uJiW+XCEOZRmMHib/\nIGAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdceESKrR0AbwD0UD+bFq7xanET7vnncu9/p2ky3hwQUCIBw05FDuZTaU\n3eNmzSVlT0QiQ24yffpfXvBDu2V2rYx0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAeruU2k6Tc+g9wkV0cVYC8v1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmJhNDc4MzQtMTcxMy00ZTY4LWIwYTctZDRjYWFmZWU1YmZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmEyODg3MjYtY2UwZS00\nMWM2LThhNWItYTM3OGU1MTAxMjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyyd+v894+DNgWsWMtPS0hPFKP7J48roRjLSt5OB54VKbO+uH7DK7OoORvPwYNXB/\nUo9Zv+YzFkjrh8ZUiEK2kqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUi3wTONM/U73Ml82L\nws2ZB3EeFKkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCID7xsEMBebRriZJ3snZbUM4i5rNHsQE+EiHJkBFundaVAiAt\nl+0XPLAVqi27c3dHf3qIsT3CGX69qnPcdFwXSClNNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4309", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4309` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAR+rINa0yS/+FX8UpluN+v1jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyZTliNWZkLTYxNGUtNDg0My05ZmIzLTIwMTg1OGE4NGM0MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2UyMzUyZWMtMGVj\nYy00NjEwLWE4ODUtNWY2MDFhNmIwY2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaMbmhIPy0ZhXd2AXIpL5tMnWn/Pxbm+bSRx5Zh6vRsO+KX809AFHoGZR2zWy\nzTVKF2IKK8x3u0F5uH+ANtqavKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKlyOUuCtNeQTYTglDeMFUKX5FsDMB8GA1UdIwQY\nMBaAFKJ4oWT2rPUtGNjkbAkXLdZ4us69MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA5kTRKw6RlUCs313lAFi6RGcz9RkwLuHf\ntEw/yWDQ6V4CIQCjOzFSPKPEfoWDdhF8betCeNVVrnFKtGIj6nZmA1Tapw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAal1mZfu3ExqPD+NRp8xA8VnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmU5YjVmZC02MTRlLTQ4NDMtOWZiMy0yMDE4NThhODRjNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+SS0X1K7kind1U0WiBwn8HWsdCRbV9NLCFHVr2DhP+qsE\n5hgM7RqsRKU23U0ueqMfKKP+WWdGGXpptatcT/sAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUonihZPas9S0Y2ORsCRct1ni6\nzr0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPq6XZPsYt3GmMJmUJNYwzKqVNJ53I1weeYv4b6i5ljjAiEAnh8dsPc7\ntVSA6JzhCixhf0jft8BCtV11VDIOB+ePJy4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAarRfbAU+PoCoJsC6voGusn6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2UyMzUyZWMtMGVjYy00NjEwLWE4ODUtNWY2MDFhNmIwY2NlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2I0OTFiMjAtNzVkMy00\nMDQzLWE5YzctOTEwNGIwNTMzMjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkYzvk2RHlKZK0tTMl1o1IKwDmlxjw0IA0FdSchnYRMgQ/QYIbkJyMl4PFbMGKZbo\noekXHqe7Q5yu/04M6x9pfqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqXI5S4K015BNhOCU\nN4wVQpfkWwMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCd8mKnzxGfgpTkYNY/5trYxOpIcFCZtpnG3Z3tSe3YngIg\nPior+1sYoTcCVsvZ5c9CFYGm7pjcIbMvDJMl8TXoB2s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4310", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4310` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAfsdqIDkAJdgcgbQs+fYsTJnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0OTY3Yjk5LWRmN2YtNDY4My04YWEwLTc4NWIzYzMxY2U4ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZiY2NiYzEtZTJh\nNC00MjVkLWIyMGItMDBlYzJmZDFhYjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqMfAQGDRZwGQgkB6a8lPyafb01WHHq8sQTdihIqmSuZ5OJ72RnZwZZrnE/4p\nyYR1+frPQYrVTChoHU2nH7bkVaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3TUd1t9aJRH33ApagGXSGO2pG04wHwYDVR0j\nBBgwFoAULubuk5vYIbtf7UTp1qGejmBpUp4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAN6h2WzvYd/1\nH/BFU+37iZMxl39ysh9SCQmUCkadF9ZBAiAYG66DNr8C+d7FEQPbkGdjVnNxRV0v\n48VLrKPaTfjUCw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf++nXCfdAwG8OdVosM9zMN/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDk2N2I5OS1kZjdmLTQ2ODMtOGFhMC03ODViM2MzMWNlOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASz0WpW4Lx9H2lZcN8+YzNFtLcLe5MF6VlXqqeaJKJ2CiVU\n/ny1cLVZFyimlSFVKpW1sawX3gu4vKm8ulWVDH7Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULubuk5vYIbtf7UTp1qGejmBp\nUp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQRniB/TSv9xNbXWOiSH4mPLpcKHSeKspO6ceN/EIoMMCIQCNm38OoJ5x\nTlvyoEuGnWxFFv9Pl3PRiN5/iMH3ANzayQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAT2N/BJEstUkhqeItu0bitTcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZiY2NiYzEtZTJhNC00MjVkLWIyMGItMDBlYzJmZDFhYjVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTIyYmYxY2QtN2NhZS00\nODQ4LWFlMGItZWZjYzZmM2YwNWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOt6aIdF7W5Hd1FtD5GXxLlk+oA/Glh53XCvYjIvzo6voHx9RiorDSxIy+31aHWYo\nJgPNZOE3UXc3GSvntA+PqqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3TUd1t9aJRH33Apa\ngGXSGO2pG04wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCICOGqu/44EvhMj58UqPBwGHc6Ag1TxIHh0U3lXf2sgN4AiEA\n0VZKWrdpo2uPQDqH5L8NVs4v8OjN392xcinko59/e0E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4311", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4311` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAfk+/pVlRZo6wfZVk4mMkMjMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwYjc1ZGVkLTgzODItNGU4Yi1hNWZkLWFlMTFkODE1NjJjOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQxODUzNTMtYzU5\nNS00OTk3LWE5MDctYjdlZDdhYjE5ZDc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVpXFC7/9HzyCEWCHKxHPMUozjIzvmU7P6lX+lKwpNXVBVUDBGebJtI2zMBmD\nN7dynXbEaltSjL0lK1+2GAmarqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFc3NKaYaTpmYHjI3mggODfGyeTAwHwYDVR0j\nBBgwFoAUinSszq/b5anbLINkFexJ+Cyy14wwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgaYma5rW8tXfh\nzTU53J4WTDYMWu3l3JCVCw3bxRcL53MCIHJT/N5VNv+N0TQPf4n2KbGnReW6fqXN\neVWPvqJaQe0V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaLbNJs/I4wgKijrBx9tuGayMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGI3NWRlZC04MzgyLTRlOGItYTVmZC1hZTExZDgxNTYyYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrRL/oCLW4P7SF9Azn4Zj2PmbrasIko2q2NsdHXOrSjlgL\nesLF+Ht7+wxQV4B8DZBKoOIokvq4OioclChc20lDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUinSszq/b5anbLINkFexJ+Cyy\n14wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL5PTNnTIVrp8tLzcrnfo7khgPGmhbRX1nk+w+7GSIu3AiBCVGyULw/A\n/AIvhCBfhtB3oP/9oFgj/jZ5tHetkPV94g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAU5iq7bagnUcB1K8E7U8/Z0VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQxODUzNTMtYzU5NS00OTk3LWE5MDctYjdlZDdhYjE5ZDc1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTNkN2Q5NmUtZjZlMC00\nNTAwLWE3NTgtYTJmYmYxNzU5NmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZlQ3sgN7tinanwMVGY8kLtlqg3BkgXayxoVaW06YOiS7tNWrWrLBongfTEFJfX9C\nf+5g0r3OUQSH2TH1Yy7bKqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFc3NKaYaTpmYHjI3\nmggODfGyeTAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIAW/ywh4cCagw1R+97XkWYg5YRwGBpwaH4WU04cIgQvWAiEA\npVTv4gGbGn24FO6e17a087oDJ6Vy9svarb4xISLx/9U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4312", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4312` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYsA8O9pHPdji4ctILJ4UK5BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1MTJiMTk5LTEwMWEtNDUwMy04ZDAyLTY4ODdkNTNhNjdjZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg4ODVhZWUtY2Mw\nYS00MGZjLWJlODEtNTJkZjEwYTQyMGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQi1vRny6EQoMrOWp8W+v0Eao61WDYsL5SQoNXl1c5aw7m9TloQLtdlB58Tl4\nJAqI7u0eEKNOlXGHmYsTiWDOFqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWzY0JEN+iuqeHTbTS/3CAabR0zMwHwYDVR0j\nBBgwFoAUGGS5od6VurblUzRkPVgbPYhrS2wwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAQ3wR7qSRGH\nGha35ygiv+12KaI/SwzwYi1wJBzPfuQEAiAV3N1lLyh7tWFW7T0gVibrPQDt3h0m\nQA/oA9SMa86dEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQFyCrg5HTXh1Na+lGx7mF2ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTEyYjE5OS0xMDFhLTQ1MDMtOGQwMi02ODg3ZDUzYTY3Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTyWNzA4FVAi1wnL5G9TEUzbqj34Q1y8XLFRz1gsXCucpG\nqtgnq9TtxUpZ/Abf7MdcmdfFZC9OvbRj06CfN4S+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGGS5od6VurblUzRkPVgbPYhr\nS2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcbpAZ+usE3wmbDz+dAbAagn+LpmrYKcmxz8mdiyW45gCIQC3FUbZnIr4\nTPjx1oI0JPSJmafeO3V/v9N3ZUQmZl/KUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAW7QKzH+EEhIHomwJOte01OKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg4ODVhZWUtY2MwYS00MGZjLWJlODEtNTJkZjEwYTQyMGQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODdjNmQ1MjQtNGRhNC00\nNjcwLWJiZWQtNGE0OTM4MGI3MWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEn5T5skz/YjQW7VZImF6WyMJmq2wRKa5iGn8pRS9bzMlVUzf4fFagFSX8VndxGS1\nVeRndpOqlWrRd3whxN5v26N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWzY0JEN+iuqeHTbT\nS/3CAabR0zMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIEXpH1I9EKiXwaffxL4WJj6evqH1mVnCjlZzMewVZBPQAiEA\n8X8ieuV2JPP1db5HkcoFxDj91v4so1U0g7VlrGnKHME=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4313", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4313` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXRa8nmWxOaRqvN+IY5WLT6QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4YTQ2ZjNmLTg3ZTctNDYzYS04ZGZjLWE3ZjdhMTU5OTIxMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA1M2NhNDAtYTk0\nNS00M2E2LWI1M2EtZGJiNjZjMDdiMmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5iLwd7dbST8YUSuhu9yIQ4L1yhTp5APUjzCCTyHR9zV+C9F4z4eSWHbFkqPC\n85YKL2kpRC8yKy4oWu6EQEvYE6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3KIXz2d838d4weZyalLptHZ2AekwHwYDVR0j\nBBgwFoAUUdNwWXTHWDvW29gFZYrvfrjeS5cwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDaGTYmNeOhS5cjEWXT8nWtwbT4QlBYjMUSuZnqwxuyagIhAJO6CeDLrsCM\n48+7bkN99FiFyN51uXwbiLXV+UzqSVjS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeMQ6jjWiS9S5wkNIk7+CL5TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGE0NmYzZi04N2U3LTQ2M2EtOGRmYy1hN2Y3YTE1OTkyMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROQa47G1YSgrjVVIckTtd6uKkvC5Zlm+JjKYlP4s8rcDre\nv8xHJvSdUDpco6/cHfXHILfvNE1I6AyRH/oLmufOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUdNwWXTHWDvW29gFZYrvfrje\nS5cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALU4bFUha8t4R6KOfkrI5SJyUxpnTmJHLBGGO6LliLBJAiAWn1+Nuqgy\niATa1yKhNt6ZnLrahYYZtGm0bAWWsi9hJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAcNiLaWMD9wVKo3+Ml/pBgy0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA1M2NhNDAtYTk0NS00M2E2LWI1M2EtZGJiNjZjMDdiMmY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWMyMGVhMjQtNTM4Zi00\nOGM1LTlmNDMtODQxNTc4Y2ZlMjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2Te+6b0FgNgh63Fq70vCLdal1gKGkdLmWbpc0EniI+SeRmvs3ZzuJUiCPzlZTDDl\nwsCAWoCzcH+iFUuWg8xOuqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3KIXz2d838d4weZy\nalLptHZ2AekwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCpXbpRURfGHrBVQz1ut953Hx7J1lheiD589b43XmUAcAIh\nAKG4YhFVhRuRLf/E/2btIWILplqfwLL5j9LrSo8sPH/i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4314", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4314` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcKAlipvOzDfOGQSRG6PzdNJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMTY1ZGE4LWYwNjUtNGZhYi1hNDM5LTU5NGEzMTNiYzY1YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFkMDdhNTUtNTRj\nZC00ODBiLTg5MzUtZGU3NWE5ZmNlNjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDmLfTpwlIR0cPmAnIBPUXXqi4DqmZ8q5nyLRvsuWLydCAq5PsxjvzrUFI+rX\n++4TsMo/k1JuhevNzyQ6cB7Kn6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSnkvzi411P04Ga/TeCh5XtNZY3wwHwYDVR0j\nBBgwFoAUrW2b37GOZd+VyNUlOtkeeA0MFa0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCnx4Br1jWYAB/QmuWTKD/zNaaHm6zX+rbCyZQngwxB7QIhAJa4ABsXr+A6\nBcnBO9Te8d+9nko8dVqaYQKUxKLsF0bl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQPiqT5lgd37p4UE+xSr79EcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzE2NWRhOC1mMDY1LTRmYWItYTQzOS01OTRhMzEzYmM2NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3GY258Cze9Ba/G1/Z0hqvDnnnXFIDbz0PPzPpbudkK3rP\n50MzMaUOwHMjoSpBOinTQBFicLTvvisoGl7kG5PZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrW2b37GOZd+VyNUlOtkeeA0M\nFa0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWVgQLi7TTtapgiHxUnBrfY414KC93FnxSxScnlsQ67kCIQC4QHD5lP1R\nM0ugkY8Lkk2BQW6wyizZ5EeUrjQ05x/56g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAeQFg4QSpyW4eKjOSNXn6HV6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFkMDdhNTUtNTRjZC00ODBiLTg5MzUtZGU3NWE5ZmNlNjA4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTE4YjM0NjUtMGZhMS00\nZDI0LWExY2QtYjUzZGQ1YmZlMjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQdXJLEJNSfX1unDWm5AqsPfH4u11uDpmW+gXtFkDLBfYaaHFzd9I0IO5D31/Wjgf\nOmrMgUjw2xlKMztt4hWcv6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSnkvzi411P04Ga/T\neCh5XtNZY3wwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDUJr8J4FHm4mh+/utXrfmsYwKcj9pYnFI0K48JIEkUQAIh\nALPeM6Gv+QfVlpT1nhl+CNwbl3lZ8H6LKr5UZmFDCENn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4315", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4315` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAdcKdlLKBQyuB6xI/Ebaq4S4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiNmYxNzI1LWUwNGMtNDhkZS04NTQ5LTVjMDY5MjgyZjgxNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJjNDU4NGQtYzVh\nOC00MTdjLWI5YTYtMDU1MDg1NGE5ZDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ2DGv0cogA4PDz+dHKP8/iZCdY0H+mUFYhIF7Haz+Ocs+tt9TZLADRmupm49\ng1bYuE0eh2GywEyFlyBE4h1krqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy6JBqzWk8aepzx1eXDXn4v51zKQwHwYDVR0j\nBBgwFoAUwPlisVh9yh+xMAOqjhJFnivzXSAwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGDH\naLbKX40jbEZy/TQUOFIkCB2LdQun1hZEj6bj5YWXAiAetMGh8cyri/SBISaAyCBM\n0vvKdB0qRLgEBLbfw7ONFA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAce3zUp9JX57G1MRcG29TCawMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjZmMTcyNS1lMDRjLTQ4ZGUtODU0OS01YzA2OTI4MmY4MTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1pzn/mNIQ6iFR6uq6vtkqbIAr4JiU7WjESHQNh9Y1Oduh\noeH/Qq9/c2fPjwwEaBCSXUaJbgUyEwsBXsXO/5Dko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwPlisVh9yh+xMAOqjhJFnivz\nXSAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKq0VNwJeTKksldrJklLoyt9KO66DE6GcdmWObJNYbHRAiAjHtd1S6LK\nHQ7NgzRToC1HEWv3Ey9jLkJRzRbbdzgCcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISASlO/OazyAAtDk4+94f66tZlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJjNDU4NGQtYzVhOC00MTdjLWI5YTYtMDU1MDg1NGE5ZDI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTUxMmI1MzMtZmUyNy00\nMjY5LWE1ZGQtN2YwOGQ4MzE3NjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nV9AoLWINswlbQPSOC75Ywug3F+23hH8Txhr4WNjFHlS2Qw/JOJuNmj2LgrrkUQpy\nI1FjOf7oNcIeESj3A5vn9aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUy6JBqzWk8aepzx1e\nXDXn4v51zKQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIAp2f8wGtc9L8xOuZriqj1R6UutYkN1Me3sSoplnQz10AiAH\n0vtIGTtFaDSGGDtLo0CQZhyqj2OVe3CaS7SyurSitA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4316", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4316` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUvniAlV5cLLRTbulMjX/WC1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2ZGU4Yjg0LTI2ZDMtNDI2ZC1hYzQzLTVjZTZkYWVhOThmYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI2MWE0NTEtMDgy\nOC00ZjdmLWFhYmUtMzRiMzI4ZTIxNjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKeQswSa4REaIhJaaFna5SZzzySIImnq41HKta16ELABJoeJzW2hZQb1/Ou0+\nfJsY5nzGXyCQtLlEw6E2u6ebcKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzo9nSjNTBjNGz3nAdmtg0XmViNwwHwYDVR0j\nBBgwFoAUx3vHFXSvaQaBCdqVWmvRTV2r6hUwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDbih9/FRCT6Oq5Ia07ulBHQAQe9cYt4UUbaeWcmqM4OwIhAOTT\nVusQ53LhkRTDn6/2WFiTCRzu9MyLanmPrIc/FKzl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUP8QKj2XI6qcjN2vkzcKzjwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNmRlOGI4NC0yNmQzLTQyNmQtYWM0My01Y2U2ZGFlYTk4ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmVsqqChtmgjqHbURFm3IkWFFizcNFPf4oGCibRrz2CgiO\nPTSi+hi6HrFUXtpGgELoKWVt47bL0o1ovz2QQedEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx3vHFXSvaQaBCdqVWmvRTV2r\n6hUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZpGhmI7FKhpF2LyoR3UEXSOmskYcZtPt55nr/pev3QcCID2Y8o4HS4sK\n9wFJOeTCAPGemQr0ZfJY5gXEZkZ9V567\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbrzspKVcIpXGbnfpySzvWbXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI2MWE0NTEtMDgyOC00ZjdmLWFhYmUtMzRiMzI4ZTIxNjZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDY5NTE0ZWYtMThkZC00\nY2QxLTk0ZmItMDllN2ZmOWVlM2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\neXZSTPIFFQ9njBkB4363+Fbf5zhfWkm3vxuih69BDGQrzbPl2AqIcBhqrmf3X4CQ\nnVsOGttqgOsauCOJRLES8qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzo9nSjNTBjNGz3nA\ndmtg0XmViNwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIHLz1BfgGEtu5JBkW5lNcWK4XtmsTACy2u48ZCgaj3VWAiEA\ns9pO2Z38xY2363xQPjUP9gzZvcjjD8lEtS4LVV62hv8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4317", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4317` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAbzvXXU3VvF06PwsHCPzg2SxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiOGUwM2Q5LWQ4YWEtNDFlMS04Y2E5LTZmYzVjYmJkNjljYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQzZjg4ZjgtYmU3\nYy00NGJkLWJjNjEtOTA2ZGVmNDcxMjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgPFmHO43u3mdcZ9wjXPKRaOy48KXIKy4Gpsk8OayEm9j9XK7hMjVENlpAWBN\nWV7l6b5VlnMg3+A7HszaZbZJmKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr6YEn3BOm5cPp5EDvv6xLNKtUU8wHwYDVR0j\nBBgwFoAUN+fndz7DDCaAmfJXbZ9pZ0TETrswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIAoMj79KJGNezvNtoghBR1VFGcHVQmIjXZqrw/RuRWyYAiEA+M0c\n3n5120fSHSuCGNUZ3jp8JWB8YB9y324EO7ier6w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWWMMsIS7Vm+HA45vyyVS1ykMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjhlMDNkOS1kOGFhLTQxZTEtOGNhOS02ZmM1Y2JiZDY5Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQd2bbbLAYbh3IJsHyr5+Wrt8Fq2pbj0H6Z9XSbLpqad42D\nA6duGODF6ooFNznOv4IqeHIE4GV/ZE9BdkFkqjzUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN+fndz7DDCaAmfJXbZ9pZ0TE\nTrswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANixriawCTYgnFG0vpBMnRavMVRnCbHy0jwSYIkxaJWkAiEAzaSO2Xaa\n5dQUIXMsJDTRoa1/b8D70/hlApixVKVM0yI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVM8nMp7mbzgUc/bWGRjPzuRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQzZjg4ZjgtYmU3Yy00NGJkLWJjNjEtOTA2ZGVmNDcxMjZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGNjYTJjNTctYzczNC00\nMDI2LTk2NGQtZTliNThiMjljZGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFMvTbP4W1/9ci5uQC2/RstS9XmWgh6NkYIBUXqcfLJVNIsn4aGCYKkW03/5kr+xs\ncWERQdOk7t2fIZMvimnLHKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUr6YEn3BOm5cPp5ED\nvv6xLNKtUU8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQD0ayBOphLZEnwwlzGXCYRZNuBp1uLAiHlBTB6wpNi+8gIh\nAOtBLUNokWtMjsY6u6eUVnraQyzeXe+j/CaeBnVW3Rsa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4318", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4318` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQzTqakSXl46abP94CiEMLGyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwOWJkZjE2LWIxZGYtNDc2NC1hZGNmLWYxZWU3NWE2NzdhOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAzYjRkOTUtMzE5\nZC00YjJlLTgxNWMtMjE4YWEzYzc2ZTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiZ6RbHX1lLnXiu/9W6CkwEyrgzTTWkUkMPtyljIYi+Mel2sYV7/k7vvnRRho\nWtxFIIkNxFrpfKzGyQsyMTgKxaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNrkbOOpPo/R2+kaAN4Cm2Zbzrv5MB8GA1UdIwQY\nMBaAFHdXRpHWQqxRgXSbTjBjmw2Jc6G/MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA6uTHs9ZCi5r22txf+M7wl0CahSiOuAHh\nm3jdfhTGwxECIGpe9MXp8KZ2TD6/qYv9nZb0HqSp4dsglzKRnDBmZmXD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfEiSeDdtDBdrpxXLb8seZWpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDliZGYxNi1iMWRmLTQ3NjQtYWRjZi1mMWVlNzVhNjc3YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXeZA9/kFtu/Cu1mXgidM9+6/zOhl1goaNAwnwK9xIV2f+\n589LmHXyeMm7om0Xxd8iazGa/ZfTYVL6+GvvBrxpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd1dGkdZCrFGBdJtOMGObDYlz\nob8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJrpzm8OFTmmtMNzRAR61LDEBSKaGmOPZeT8iLzI9olRAiEAlugkHAPm\niekDxA0rWx5YmfG86RVkVy+ZrZIYj2ISRzE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAefJs5yhOcYlNnzcN5yNYMFpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAzYjRkOTUtMzE5ZC00YjJlLTgxNWMtMjE4YWEzYzc2ZTBlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDVlNGU1ZTItYWM5NC00\nODA2LWEyNGEtN2UzNjA0NzYxNGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQe8Lt1Q0BEwj8xj4kNby4soNrBXnx2Lbk47zLseThbb600rCS/SGCr1xZXgqfhaw\nUBuB0eJk2BtavqKL8T0L3KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2uRs46k+j9Hb6RoA\n3gKbZlvOu/kwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCR9hZYQgZMmhQiQjppQd3j9U0jjx7bXbbbhrd2wiYv/QIh\nAKRtfVIiNSj/hF2SHdAyxXeAlq/7cogDXot1meO0EOsB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4319", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4319` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAcNSie593A/WAwxKvNEu9ZRCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YjY4YzlhLTJmODMtNDNlNi05MjcwLTVjNDA4MTA5M2M4MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFiOGJjNDctMTAx\nNS00Nzg3LTgwZDgtNTAxMzdkNzIwOGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECiXrJ93suMc6xoUQYjDxzGJ/btq0W5rOAzbxluQI30+xDlD1GCLlm+7UH2hW\nBu1ZGBx5PeUPN+f6tVoipMnE5aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2/K9CiLymiSgqtBzxtePC8vzT48wHwYDVR0j\nBBgwFoAUSaRb6pNRlEuV78lc5ishl6+7nvkwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgM9sCwcDegMvT\n5N5zcAIaHsLDTlaisdU2mxQvZmfflLACIDLheYrPFTuO1ib4d8+nerYO/J6YHmFE\nR1H62VKdCfV4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdHBCmD+Pge3Ki1RA33uyG3cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWI2OGM5YS0yZjgzLTQzZTYtOTI3MC01YzQwODEwOTNjODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASn9NPzt7VIB9KheAK2903ZWXUXnzXbWB3UQlvKJPA2GY1H\niZw+dZlfJeON7Fb769+6PsVA/mz08S4be2SgtBUoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSaRb6pNRlEuV78lc5ishl6+7\nnvkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL3N1UwJY8PqLZePuxO5c6fHOyQiQFB+hb8VTZuSqxPAAiBVefHJrd28\nhSZLUGiVACGqNhsLWI0wvA1oK1Bc2n9nuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAQXE6w2rgL+hoSWj8b3NObR5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFiOGJjNDctMTAxNS00Nzg3LTgwZDgtNTAxMzdkNzIwOGRmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjBiMWU4NDAtNTYyMy00\nM2ExLThmODUtODAyYjAxYmZkNDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/NTDH1jNVQ/SrqOeepmg0oXzbji8NnZM3cLeU5b009mC03eCuxJDiMTjoPBuHjnH\nrLBud+P7oK1STPoNU8rGf6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2/K9CiLymiSgqtBz\nxtePC8vzT48wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIAyhTi6W15ridVgHWmPH9JjwKv01JB9A6NW8unHfzB59AiBS\npU9anudthUNvvaAiYIBZhahoGpMjEitV1SWu+15hgg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4320", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4320` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATbC4BegLjHaRC3L6bfGH5paMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4ZjRjNWRmLWY0MWYtNDdhMS1hZDUyLTdlM2Y3OTQ4YzQ4NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI1ZGFmYTgtZDZl\nOS00ZDRhLTk3ZGMtODU2MzVkNDAxN2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy8q18fYYJMZw+oeP8XLHgOudZ/b7Y66F3VNl9iUDu42IxA7z4PxBT1hVrnN8\nkJ1x4s9ac5S9Q7EuiycbQNuOyqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJsAV0yzPiIaWESSysTaU4Ri4RrAwHwYDVR0j\nBBgwFoAUZttOBTGL0d0IH+nhfEJzCKjjJiowKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgF2tNWQkIoK9j\n21SJgKit4OMCnoH90qV+q3Rtp4e7kt8CIQCT6uO7pxBtj3iewZoHhT8qbkGi2i6w\nNMeplXbEQ7nuEA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAas/eOCvDs5sLJsVHKfi6COIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOGY0YzVkZi1mNDFmLTQ3YTEtYWQ1Mi03ZTNmNzk0OGM0ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2WX4TeUbXpypkzLaAEWQpfdtNBdH5BkqA+tXDbxhh+yzP\nLVxxfCgYeF1SyQPdgpaWnO3GQpSM4kEbagRxrDyJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZttOBTGL0d0IH+nhfEJzCKjj\nJiowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXscvYUc6wbsiWwCmntQkbpwVHp8KTVLaHY97UnUx9VICIAZtI+TzQa1s\nJuZZap6v/vF2uBDdXyakrTY8dPZO6k1Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVQ3P9+mv2/l+/5AqdpKCZcuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI1ZGFmYTgtZDZlOS00ZDRhLTk3ZGMtODU2MzVkNDAxN2U4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODYzNjIwNmQtMzMwMC00\nODA1LWEzMDktNmVlZTAxZTIzYzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntLqYUQ7OBSXTj0NuyCfERI0m6vzuZKHG8a2wt0Cqm816TnEeOLSFiDgJu7xSY8QM\nU8pbgR8Z6+9DY8Ufb1w8lqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJsAV0yzPiIaWESSy\nsTaU4Ri4RrAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCp3TneQJWYCJ5nw3H1Hq61Didg5JDfwq6dgvwj6k+ySQIg\nemapO/Oh0N3GN1gqMKXhvIhrx6b85sKhLDeP8vAe8bg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4321", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4321` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAfRHCiV4mg+BP8/T+ZndSJAqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0YzhkYjEwLTYzYTktNDE4MS05ZmVmLWI3OWQ0MzU2NDhlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTJmNGZhZWYtZTY5\nMy00M2EyLWIwOTYtNjM0ZjBhNDU2YWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdTCCpCOntFFaLZL1WTlC0toaGAXOYEyhlXG2j+u08h9i8F/YOq3XxcvAVLg4\ncFRT1nmqTMC4e8//GPOFg0Ps3aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxDneot/8OD694AS2kDRz8myudhswHwYDVR0j\nBBgwFoAUkKrtyzZAtrpfWP6p2EU3fH9NfBQwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDFjoFmf1xY\n6hUes4JGk/IHtiIEJcqNU7Yb9qcQ0whFewIgGfBZq83AajObwQ8f3SB3Ato6d8JG\nbtx0ojb3tY+tjl8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQjYDBqTCUHYi8In/FJXkQZAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGM4ZGIxMC02M2E5LTQxODEtOWZlZi1iNzlkNDM1NjQ4ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUZDwa975D9flixp12aqMLRHXYy/o7fml+xd2KjS+R9699\n5G9WEmlJSmu8DlA3GaY9B92qci9zbtyQaIAtnL3Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkKrtyzZAtrpfWP6p2EU3fH9N\nfBQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA27a5ERA/I9wjESOpXzc0air1Mgzq+wlBsjkuwQwkRsCIDlVk6Xbcpnp\nkMI7Pd7QaEWhjW3qoWlAUVniBwfipzxH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWHHuM9D5kHG540vi8KyNiJiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTJmNGZhZWYtZTY5My00M2EyLWIwOTYtNjM0ZjBhNDU2YWQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjg3YzVlN2UtZjllZi00\nYmY5LWFkNDMtMzdkM2JhNDk1NjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nndhCzUg7YH2AIe1bymuOmWRhdzKcv6Hr2jw1fFhjRAuAJTYqK7sKVU3vgDPHR0Yh\nA5VZ+fkGI9vbOfnQqlBn8aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxDneot/8OD694AS2\nkDRz8myudhswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDNhy4HT6rH3NtjTGitBlyOVguvpzpeVPQPVCl+uKEhDAIg\nRvfMQnq391RgFT7PYR1KTbh7oaISZRY8IEcaV8T/7os=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4322", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4322` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbuDots05i19CGxPPy9uW5f+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4NzMxNDkzLWY4YmYtNGI3MS1hZDdiLWM3NTlmMjQ1ZmZlOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZiYjI5NGQtMjI2\nMy00YzI0LWEwZGYtMWE2ZjkyOWY0YTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH07E6hfVE6l5cWZ6P0Jtgyhi1PnU3no5g/jT0T1JQ3NODi3Tvc5Nb16lZayY\nBRE1Ue6S8c3WzxSA6x8Ij3EL+6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw7Nb9b2jDuRK6pJ9zIw9p6lSzaAwHwYDVR0j\nBBgwFoAUW0R13XgN36vsmsxQh8N5ZCwKueowNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDOPP0yi9bBimVAa/doFNvF42YgoXusBz0rUeFHfj/G7wIhALmCrD0EW5PI\nWiPmsevIqxN8ILUVbPNv2dyzVeDVNHKh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAadQ2zFGWqEAZmZ8u959qGntMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODczMTQ5My1mOGJmLTRiNzEtYWQ3Yi1jNzU5ZjI0NWZmZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpgQGBW8fMXGwmf28wSdKrnA3/sVrmfHfLaywWQWTrbFuv\n2v2sNxRyVxfQI/ODQwlsHLgrDCb2B3aaspirz38jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW0R13XgN36vsmsxQh8N5ZCwK\nueowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAISZGdqboUkF5wpu8XLDb/VRTWSGL38fSXKM9/xdwkriAiBVvuxE/QWy\n6WpXe9Im+baPnlEa5w1zQGWEV6nUW/bEqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZ+uHKojdPoNi8VmZAmYYzUhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZiYjI5NGQtMjI2My00YzI0LWEwZGYtMWE2ZjkyOWY0YTFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDA2NDFjZDQtNmYyYi00\nODlmLWJjOTYtNzAxZDBlMDRjNjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWm0w9StVmx+CYhjtEfkvqoOeA2Fw/7UWleTTrvuxaYEdpwBqEqIOA9BlX9gCJTkq\nw6zH7zXzrvKrYMKkkgAT3qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUw7Nb9b2jDuRK6pJ9\nzIw9p6lSzaAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIDeyFaHxhPqOcLadYe/dt56MN+myhT8m/FzGZh1jheQIAiEA\nlSoStI/ctl8C1+lYvKshGAl9IdCU2xQVWlNKxB4BwT0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4323", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4323` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdsjP9S04a042tLwIYnWk80uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlMmI5ODA1LThkYmItNDE2Yy04NzY3LTU5YmViMmU3NzE0ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk3Y2YzYWItM2U5\nYi00MWFjLTgzYTgtNzZjZWIwYzJhMDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkBDXusfqHEXWzwHWdHEORF4cm0qkpQoZLdGA3P81o9r98gikQ3CMPeDEiz9a\nh4v1i6WydlelFQUwLXUxN/OjkKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjUWIaC1g6X8BIu+xpGwiNoZmCqcwHwYDVR0j\nBBgwFoAUd2f0hPjBW7/WkFD5GilJoYLOkGIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDWkPM522mdQZvttKc0nIaAYScz+/IDkJP9uqrxSnE2/AIgc95o+vNVhJf7\nxtSymgdKbzcguupugW9bHC5i+LfEXEA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAetHKks+yrlcblFMBb1xZFBjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTJiOTgwNS04ZGJiLTQxNmMtODc2Ny01OWJlYjJlNzcxNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk0DMBeyE1dPrR6godQUb3NX7z3SkknqNcSzydpmETMkK/\n0W9038xVeIcW1cyCYgW0OJrJZadAWWc2/JwcCVguo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd2f0hPjBW7/WkFD5GilJoYLO\nkGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ9UL2m7i03ofJIu/Nb5aQPd44GOACKcFfJFezxhhYC0CIQC/1Z4XurBe\nuZ2o54bK+i528SbMBmWmTNBJNaHPRvdwsg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZS7PgfgvSy32G23aUSxew6DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk3Y2YzYWItM2U5Yi00MWFjLTgzYTgtNzZjZWIwYzJhMDliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjBlYzg3MWEtN2VkNi00\nYjA4LWJlOWMtMmYyYWNmM2JiY2QzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTcc8zSWIqEdqz9SIE8DUydLfs7nsPpdSZVUSRMz2Tpf9i72PR7JiRsfomz8lup1D\nUQ2v69I3a8CVVRGK9mYaV6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjUWIaC1g6X8BIu+x\npGwiNoZmCqcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCICCl12U7eI8E1Wp38ySncKWRGexkwqPBi5pev0Ra+FWXAiEA\noRDpXIkkwSPSo0jlDtwjUg9WDoC8Rd0W8fKGw0loW3Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4324", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4324` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAaX1E8OfmymSjryZ4se6y+yzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNzgwYTUxLWEzN2MtNGNjZS04ZTYxLTI0NWY0ODAzNDU0MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJiYjM4M2YtZGU3\nOC00NGYwLWExMWItYjdlMTRiNGY0ZjM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE34olqncNF/n3TjzO6OTm0NcACSuo1K4TZWVsgMP6UEe58PsM44yeZ+K/x41i\nmfz1k6s71DFQ1KEHmbgG66BpcaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNjhacpHScLwkly68FMzeVRZPvBUwHwYDVR0j\nBBgwFoAUEENnvssI7mtWk/AtfQC2xXxoKSMwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIA/T\neBcwdzyvdbDDpkJGHIIepu5clT9blQChFq821Ia+AiEAwLSCRDDiClZlH3qp+t9s\nqwnURWOjoiXNw9IyNIzpLuM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAak4D04M2g73cAkMC0iIUFDoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTc4MGE1MS1hMzdjLTRjY2UtOGU2MS0yNDVmNDgwMzQ1NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxjH6JiS18lcQg3R+kCIoVcbbR1iqPpcr10si69OM62iJx\n4J5TJJF5dZy1Sd+tvYIkT1c/o9v1gAIhve62J9vIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEENnvssI7mtWk/AtfQC2xXxo\nKSMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPUy30jA/SRj2hFNt4L5SSdwXC5lm+UTT6eMX/dYbwiWAiEAkHNT7Q30\nqAxblA3D/SW1HaQskuz0isjBSBZ1hJPiE+8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAXQphkwg8TnanPn3z8pfSKJrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJiYjM4M2YtZGU3OC00NGYwLWExMWItYjdlMTRiNGY0ZjM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWRmZGQzYTYtYjZlZS00\nMTMzLWFjZDItNTZmZDkzMjAzNjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxaJNEQ9rvI+uEJ+r13OlVJZOvrlznWCrJ4KWertU9HwLgvOH4NqTBwxLXkSkHX67\nyuMnlLmsniOYyenynvZAC6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNjhacpHScLwkly68\nFMzeVRZPvBUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCICqEBLTM/typ5YwlW7Z1lBLnmrDSATDd12+2tf/ZLQjEAiAN\n0/AjMKj/cMEyp/taGom4s9kqqjlOa4iQvL+2s8bLrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4325", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4325` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAdh2tV7WCcYYie6+RJzy1dH5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxYjA2NzMyLTg0MDktNDQxOC05Njg5LTUxMWJlMWU4YzBjOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVjMzNlYTctNTNk\nNC00Njg4LWE0NzYtOTc0NDFhZjNhYTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjXME94F0atcYtKYMm3T0JxXgCktlXafeqU5394fs/D5r6TlD9jUCCZIMMcHV\nT5DmoB+AbDTfXTMdlg8gxMiJqqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr4Dt1CXOBAbQgFcMyu9Pl1doImswHwYDVR0j\nBBgwFoAURLJeP9/rkbZAbhTH8wULWimkywkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIAjICHKaIds9G0An1D4gpcOCQrPO+/SaJGq2yIeO4fgpAiEAwHEi\n8OzBlDmYXPHmfxV6Cem2BcZlon/p+yhUc5Rsi7U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfWM409Wwj1Fb4V9qBN2Rii7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWIwNjczMi04NDA5LTQ0MTgtOTY4OS01MTFiZTFlOGMwYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7plAKOGqu4CylualgCzeiANXBI4NKSyPRF3erL6QvJIN5\nas4K3Ir1W3FS2v7pBfE8R+dncBLLau2K3hIn2yQLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURLJeP9/rkbZAbhTH8wULWimk\nywkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU8uYCkFWhluANXu/R3O24PyUK+iuo8Wbb/2pcFIF/3kCICkBlRwA8/D/\ntRe/1xTlyU/+8eoDgSDFVYaqitjjhuD/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAS/+S2OwANb20GmYRXoWr7L8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVjMzNlYTctNTNkNC00Njg4LWE0NzYtOTc0NDFhZjNhYTMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjkwOTM0ZDYtMWNiMS00\nMmFlLTgyODUtNGMzZmYwZmFiMGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nabbxXTUt51KzNw6IUZN6ksa+iRazsOGHxaBwwjemvr4SME/vGJGGaPDw+G5smWa9\nTAu75TfZFa0vfx8fOkPOqaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUr4Dt1CXOBAbQgFcM\nyu9Pl1doImswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIAuu36tMEvkhQU0G5h3Sh8Wu1OXoehIVj0RGlyJUk26XAiEA\nhDqEHkXv/i38nyqBrh+ZM60ASnvaGXQA5i9fWaEJhzA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4326", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4326` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAXlKe081NIcC7sEC8cBzgaDNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiYTc2YmI2LWEzMDItNDM1Ny05MTRiLTY1MTM0ZTEyMDc5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQ1YTRiMTItYWQ3\nMy00NjNjLWFiYzgtYTcxZDEzM2M1MWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiPGhKiwT4dqn57c56JkU+PSVwiEiCR8WxBgHgtvPLHAxjPsKtpGPqsw2f6iX\n/uJqxPWOlme8k0/RV8KJ/DfOU6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwOwGLmIyNsSgG3oHGCWVlWEX1vMwHwYDVR0j\nBBgwFoAUyWk4vzb7iCTJj9oAvQz1UCcMsaswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDSHP9WHmkxGhxE68OORlfDsBdoxPpeEXSEsJVIIsd/SwIhAKG6\ngm2Uj2v6XHv/4gCx8LuSuLVD8cQiL2v6px2vuy25\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa2TPIwpBkRwNZiG5YNZiSCUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmE3NmJiNi1hMzAyLTQzNTctOTE0Yi02NTEzNGUxMjA3OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbgKsR2UYStR8LbTTWzndLydwbSW4iAm3mf6w4lTlf9nw+\nQogW1LysIm1pDAakkyUsdkjZuz/6z/7yiRx7To+Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyWk4vzb7iCTJj9oAvQz1UCcM\nsaswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKp8PB3vwR7fLp48DKXiJlZXVdNe+tPpMy+Kk6kJZSHYAiATk4yEa3xR\n83QzjtqwKCv5M7a43dpV98zHppQxy2XTbA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAU3r3IvxAfQILbl4Py/VMUfXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQ1YTRiMTItYWQ3My00NjNjLWFiYzgtYTcxZDEzM2M1MWU4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmE4MjRiNzgtYjNkZi00\nYmU1LWFmNjItZmI5Nzg0MDc3NDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ne53qKdlyL7X3sVtiSk/DgJm3t/lPOkJjyyYXxCNpvPLB78ZAOW9wEZpO0LHgBgk9\nXwdZjzA7zM218Ft723Y5JKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwOwGLmIyNsSgG3oH\nGCWVlWEX1vMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQD/hCz3ahXW1YjRIEU3+yz4HrlKquvcCU41gX4LfA/tEAIh\nAO1vvdTQzlks8zkMzkkhpTSvtgqMCK/PNhV9yxhRBX59\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4327", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4327` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISARRuHUhwXYIQVChyHczgKK66MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NTNhNjFhLTE2ZDEtNDZmZC04YjZiLTA0NDhkYTdhN2U1MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZiZDA0M2EtMmNj\nOS00NmEzLWI3MDEtMWEzYWE0YzRhNDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHK60KBHzBs9GB71u94NEqAPBgn6wfJKRJfL98cyjmtGlvXQmlAu0sfhh8AnI\nI63TxpKir98OVQvJzCk7yejYa6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQS6vUh0xShowbNWzFH2DC0AJIENjAfBgNVHSME\nGDAWgBT49Tkh4XOjTbFGzeWwOkze9/HssDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCquGhxyMpcaUKhAstsrsNGyvEq2VBg\nu0jiwD6umr93EgIhAJSglsaGPAJfV9kos/m62HVkqehths4WIzvcffs3s/Ci\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATxW7/T9+yEWwlPm48KU0j9YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODUzYTYxYS0xNmQxLTQ2ZmQtOGI2Yi0wNDQ4ZGE3YTdlNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+baTkVMSpU1sY4txB6XeAiWYP6sCKGZov7d8czCZEMFTJ\nZHeptaGRn2h/Yui8f4B9xQxLVjNm/8BAHY5wXqKmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+PU5IeFzo02xRs3lsDpM3vfx\n7LAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN2PQmGxk4e/9gfK0lgw9JqGCseALviuNmWdF5nGcm9MAiBxIb7WxjIz\nXfPP7RcxRY7aW2XVWU1qubmFCZBnY9zUKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAV9dv9gAayTfOnQFCgFTczgvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZiZDA0M2EtMmNjOS00NmEzLWI3MDEtMWEzYWE0YzRhNDhhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDkxZGRjNjQtMGZlMS00\nNWFiLThhZjMtZjg3NjFjYTIyYzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHEbRbCyiikQGD6LyYnTar1exxvuXNZw1hqNzK5KqjRFK1Q7ibz5hIIw3Tqeu2Fvq\nI4aNdHU3p9vhd8chn9M5xqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEur1IdMUoaMGzVsx\nR9gwtACSBDYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDCKBg11S4JUKhFi+oo/ANLISrxjg0bpRbvipiM8w+QawIh\nANV3FFr0I/zQfgBUADdv22wunhe9UP5kZ2VkeSpaJEiU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4328", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4328` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAQ5atfTN8XxPls+FwoWUni+RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmMDY3M2FjLTc0NmUtNGNlMi04NDkzLWEzMWM0MmFmZWQ1ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk1Y2VhNmQtYWQ0\nOC00OTQ2LWJkODctYzM3NDhlZGEzOGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF0e5eDEI0EJpCo4aAyDteW4ZzcS46e4zSFjrakylhtSRI4vMXgfiDtBYeZMh\nu79t/rf/ID7eIAbZ+dVH2QAKKaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtE4gQJDF2VbirlWc1EoZ+JSgHeUwHwYDVR0j\nBBgwFoAUJAQOHjVPPgBCizz6638Ci91zZ0IwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCn7Z9TcU4N\ncUMriGvDn0XPtguQoIWmbuygP7HgKKLGEAIhAJ4+MZhnXilbe/i1mCXkvHngNPtk\notgPRKNTReiEg7Ao\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYXqpm2qnh4x+tvwDFHsvIlvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjA2NzNhYy03NDZlLTRjZTItODQ5My1hMzFjNDJhZmVkNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5z+coGc58/oQlLrDrXFe27kcTgO5N+yOXD6SFqEKAqj2J\nlGi6NHbQbdEHwYcpP/hbG/EvB4LMM+3yTmDH/nu3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJAQOHjVPPgBCizz6638Ci91z\nZ0IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIFaz1fVBvdR/7KCgR/VwFw/hIGnJ7ZULvrr8ZI9MBakCIAgAzT670IbH\n7OpwjS8Ly+PIRezB3SeSyNdWjXb1E/dj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAb3Roo32VCRxYKQz6S97bHKNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk1Y2VhNmQtYWQ0OC00OTQ2LWJkODctYzM3NDhlZGEzOGYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDk0NjNjZDgtNDgyYy00\nZWE3LWE3M2ItYWMyN2QxMTc5NDJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvaywhYdK6RcjQcGOjxmZxnXPDocYkFFOpmJYe2HQEMmxdQsjT4WrpMNOkHgqLt+b\ncfRtg6S4ByrnBL4307kGIKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtE4gQJDF2VbirlWc\n1EoZ+JSgHeUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIHeVU067SFAkYBy9SVLj1lZnrVblHj5I8WnTGaGiErkDAiEA\nm5PdeFqM6/JHNe1Sk4nHgeRXKtqn1hTUTB5wF5Ry3nM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4329", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4329` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAa0I59Juh+h00YfI0WZ2D8BzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3OGI0NGQ1LWQ2NzEtNDc1ZC05YmU5LTJhMzI2NGYzNzg1MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUxZTExNDAtMDBj\nYy00OTM5LWFlYmMtNzE5MDRiOWQ4OGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDsoKtbSWgnbqVjX+aIPa3PRRnFcA1VIzQx5/Hil1wlMTESEOXskeL8AVJhNU\nNI1iFpxJOpqpI6WfYZz63pcXkaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgZU2w0OCnjUDOIkFViooNhW5m/kwHwYDVR0j\nBBgwFoAUX3hAZlPIhlHliyGkiTFtMn1eVRUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDbdjxDf8Usq\n6oV25G2aoqj1NNhemhyCvI6w0qm5sn6hAiEA4oFDyxw7jrvRrOnbGqgFaxSTLMdA\nXFmvtnR9gBPBSow=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfNkMXaUGovcTC8eZQhmf0GKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzhiNDRkNS1kNjcxLTQ3NWQtOWJlOS0yYTMyNjRmMzc4NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1LutlayWKF7RiMGE7sWUZjBE/21VJ908wt4sqOzJ69JAh\niXqoWx/FG6sQtjYYKn0HqcHNCRV463TNoVqhHhlzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX3hAZlPIhlHliyGkiTFtMn1e\nVRUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKNKmx/8hvl1khtNo9rZFHH/xHTT1w686pzPXnm5CHiLAiBZvXqyqKNT\nH/6UGscwEHtFI5ynHlITHebjhF2DRMAm7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQ86Qv8RKnff0qCjXCk23GOTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUxZTExNDAtMDBjYy00OTM5LWFlYmMtNzE5MDRiOWQ4OGQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDU3NWFhNGUtY2EzMi00\nMjE3LWI2NTUtZDUzYjExZmM0OGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSe40VPxdPWmbrPnuZpBX7Y2NEE+PivI/sceu4FImS5vq9R4LA9i63ExdfL3vX6ht\n96F8WIiksh8V1bcpESCTUaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgZU2w0OCnjUDOIkF\nViooNhW5m/kwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIHhSfKvzeX/DfULZsuXpOJ6+rJFdw+HFcR2bCW3kRReSAiEA\n4OWlnDNotNvU+ydRHvy2EwJKIpVnEoGdx0C+BmJ2qmI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4330", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4330` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAbp6udJw5glNFsok0lTTbjLuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMWQ2ZDdkLTMxMzctNDkxZi05NjM0LThiYTg2ODJmOTU5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFmNjc4MjctZTUw\nMS00NGRkLWIzMWYtNGU5N2RkZWIzZGMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELkkSVJoxqWcpYbDW68R5E8lBc41v/Hpqf27zzXxpnPZauiNG5+2JiSVdgQGl\nTs6XHrBThe7mjU07VbHXNpg2haOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpiIkVOYrY5sVOL0K0gmnL46fw/QwHwYDVR0j\nBBgwFoAUpfAkQ8BWIO0OfI3Zst0Swyk1vIswKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEA9SgZ0f5i\nZA6/Pfvfq/N2PraCDebzcQeDVK9pSQXm+xUCIQDBxsdvWbUByT5lRDlJfKASKxVR\nKnk9cI+CXTX+mgAWtw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaT/0NfB323oR/eTpvRlG//SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzFkNmQ3ZC0zMTM3LTQ5MWYtOTYzNC04YmE4NjgyZjk1OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/7uqtCx7yz9lnn7S2R+4O8YYiNJ7pEIxjx9oH9fgjqAow\n9LC7TplHYILjd5e4KKLFZnI9kHKoHikgUfrJtg6No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpfAkQ8BWIO0OfI3Zst0Swyk1\nvIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRv8RDluQSa7ZktStkMl/aGZGVdm4LFj8aqV12aS4tWkCIQDn+4Q0oyv3\nwTPm8k6gR6aNh5fPKYgn6aUUnZ99Oo4P2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXfC0Rhe4J0W/YVAoV3wqqrMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFmNjc4MjctZTUwMS00NGRkLWIzMWYtNGU5N2RkZWIzZGMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjhjMzNkNzAtYjFlZS00\nYTBiLWI2OWQtYWM1ZmY2OTljM2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5EtHCDc/9peo6c9zvkJT7of7FLypRo4hxQdqreXb838nahS/Ie7cLBPEL6IO/Mbj\nbbWmExKbcUGYR18d+NaKKqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpiIkVOYrY5sVOL0K\n0gmnL46fw/QwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCbF1aee3HM6pMX9GI9rV+poIJmcwVXpei1TN/pJkvzYQIg\nGuKtaYPH4w7bZC7iHRDOEZOoS+z5NXHuFEZ4Q7vq76w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4331", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4331` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAfb7kyVQ+bbdRQzi5+AQzPTKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ZmIyNWI2LTY5NTQtNDI4MS1hOTQ4LTI0NjZmNjA2ZjkzZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RlZjE2NzAtM2I3\nYi00YmQ1LWI3NzctNDZlNTc1NDBhNmJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQAmsXBnO9QX2ndMTChGZdkd4pkotrPibetQFPm5bbGwLk1zPfDDg/Ey4/Zl0\n+rawiMvM0Fvn4fUQSewjGEZHxqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVy3+VtBe4UxD75IjjnJh+SjwhJEwHwYDVR0j\nBBgwFoAU3hdPFBzX5r6/NSc7tFPnenHp7WYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiBcDf8b9TKwvQGvfJlIa3TtFRHvZovXm6jD+LGpHEBKrwIgdEbTBsrQYKpR\nyTg5NxQezRor/jmCsFWwrT8yVYiHStI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfM9vYPx9Yao9R/t/XDsHx8GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWZiMjViNi02OTU0LTQyODEtYTk0OC0yNDY2ZjYwNmY5M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzNH8KBEmCzh5s+qZU/V494QVmqh1AWdsRsLJHsSOQGRY/\nQrHgqoA7/m1FV4b8TeMJANSH1wDN7+QBfDAU6/BBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3hdPFBzX5r6/NSc7tFPnenHp\n7WYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGbcAJGJIqQJ29UDZcbkIRImzAC8OBI8L3/5C64Gubm0CIQDAInqtqCYa\nl1RGrHbd+KF6Cov4buTpJp9IqcgfpFD+aw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAVzdJ3Ys2Ts5WM6adVSctsI8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RlZjE2NzAtM2I3Yi00YmQ1LWI3NzctNDZlNTc1NDBhNmJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWE2YzM0MGUtYmQwZS00\nYzNmLWJhNGMtZWYwNmU2MWIwODU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUHmjeqt5BFlIYcS3RauitP5HsCc5oWOZik75iJ97nGYyHaPvyBgsbNyDBtz7ugQp\nkWJ7M+eEaNochEOdVbr5saN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVy3+VtBe4UxD75Ij\njnJh+SjwhJEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIB9zD1NUJRoe+kfL8DxtYPn9QD3V66yluZObDFFAtuMcAiA3\nRqy02G3pN+RsDwFVMzfrTyMFDkv0xdLmBkT23bnz3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4332", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4332` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASVYGjAZMkKjvNy0OIPu6K6XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MThlZDM5LTEzODQtNDg4Mi04ZGZmLTMwODViMzkwMDA0MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA2YTE4ODYtYTk2\nMS00YWVjLWEzMGYtNDI1NDNmZGJmMzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1V0yb6RVyqzaDEkwmFl4Z7u8+J574OYPOQGYL7kHFMHlJDhIML+gULPePzPB\nLajPRHf1bOwQy20XzIVny+s+7KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUYpqg/u2ZgARPiVp5EReHEqYLq0wHwYDVR0j\nBBgwFoAUq3j5xKKapYwKK9avYKFteA8ai1YwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAl6Pxl4GKPlHDExF2ZgxlQt+PNEt0+vVFCB+XVMo0bs4CICr5/pBk4NHO\nnnjxq4rE5wDI96PYpq+IYoc/9lanWdKS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ5Xr5fyvsHkz/axqEkOshm7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTE4ZWQzOS0xMzg0LTQ4ODItOGRmZi0zMDg1YjM5MDAwNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/sryquH3q165sDAZieZUUjZuTIynaxWxdNYMJVSY5hrJT\n98NEKXMwFUlnlNi+2JbQfKMQgJNH1OJDAvuM0IDso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq3j5xKKapYwKK9avYKFteA8a\ni1YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD39j/2mWphBMz3L/Ven06Q/c4e1BSXTTB13RImrHNWECIFUtmZ88WS7f\n3QhoGdCvKfEG3lx5vwhWFEv5IxR2R/cf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAe4WgL9dhInmLHcxI6XCL08FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA2YTE4ODYtYTk2MS00YWVjLWEzMGYtNDI1NDNmZGJmMzFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWM2N2UxOGMtZmU3OS00\nZTYyLTkxZDctMzljNTkyYTlhYTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ns20KED5GIZVwwJ57xrbeMZx287bgGhm1v8qcs9h80dWe1HN3GiPLiysiRBCJ/Zxo\ny8n3UsvsEZDBmZvOCsCubaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUYpqg/u2ZgARPiVp\n5EReHEqYLq0wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCvPH/4lvqJcd9OXWnb28bdX4SZ8+WX5H3K2YRUHFMigAIh\nAJVZEpeNO0TJnl4vazt6VAHe13EBJJFuLuIW0RCEmj5q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4333", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4333` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAa6mAOqq2VY7Btn9vgmSTa8eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMGI5ZDE5LTljOTgtNGViYy04MWM3LTJhZjM3OGE3M2JjMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWI3Y2Y2ZjgtZGY0\nMi00MWIzLWE2OWYtZWIzMDQwZWZmNDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGZHJqt9lSs+b3vl0b3+uheCVaGV4xREQJF/OfZz1J/m71kcfmr8x8597SBYz\nckNxiUJ5PmE1NahFJas+ILGKcqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ROwnFxKTpVPTN4HQriencfoXlMwHwYDVR0j\nBBgwFoAUZNaKkzSE95a9TV4EEX9djlW3EbcwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAs\nqiK0CowHSMv2Wy8jUqNMiCryItdHKG3lIIOI2I9zBwIhAKTUM45K1h6jbLXhrOhT\nqVMfo2OPcL/DkXd4FpJXGgxW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWVkTFr4JtUM9BroohI118i9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDBiOWQxOS05Yzk4LTRlYmMtODFjNy0yYWYzNzhhNzNiYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9scVpyzv9LDpsMskV/BZD/MWGJF2BTykEvLE+rGuQReAX\n7kDAG094GO3D1gHy9CguCax57Xs3IZIkpZvLNLMNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZNaKkzSE95a9TV4EEX9djlW3\nEbcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKYSDk3KXgeUu9SdVDp+T73k64531z85a8PEVqczBrNIAiEAsQ6+U+3j\nqSrdiEWurT1xJYnRcEgtt0kd6Ha91hUWxt8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAeXuNIp9D6+W0xFJknjMlN2JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWI3Y2Y2ZjgtZGY0Mi00MWIzLWE2OWYtZWIzMDQwZWZmNDBhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjQ3ZmQ4YTctMzYzZC00\nOWI1LTgzODgtOWFjZGZjMTNlNWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nV+sodOb84tD+mX07jaVafXASX97LUqhahfJAj5P+KuYr5r/2EO9hGpp4ggZALoWd\nSZU+nQxxHgO2HPCUWqlRVKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9ROwnFxKTpVPTN4H\nQriencfoXlMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIE3mtf0bbQKl/ur1lvhKjNBYj+DBKnQ7pWh+O2DzHvxcAiEA\nnv+qNYWa+Rszu+ZXgvpvs9TVzu9gXVh5BTOL1XqLXnY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4334", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4334` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISATUYVRP0hPEI68FCHYbF4mVRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0YmJjY2U4LTRmMjYtNGMxNC1hYmY3LWY1NmJiODExMmZlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzE0NjUzNzctZTY4\nNi00ZWVjLTg5ZTktYzQ1MzIyMzUzY2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERL0Xqs/+xv6zE//eBekcHisphy871RWjYErl0AbGw/4MpWXmzW3D6nUtSRVi\nsfXmHi8b41+exHOOozBWxFLu3aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwEJ7qMIcGXUZIPaWJqS3KtjsRLIwHwYDVR0j\nBBgwFoAUJuqy6a4/b9XFdaJVtHeXNvQKEm8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEApriSJldqAGPTZOXjVJovkOYGmcybcurVN9XxpFPuyV8CIQDT\nZqdkrUcamdULeAOpoz2S+vH6FL/iMSEmTkfHeyzmLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfDdffP68Lnuf1GmJXkdi9GTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGJiY2NlOC00ZjI2LTRjMTQtYWJmNy1mNTZiYjgxMTJmZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOr1uekvEMm27SrDTTFI9t/pppgKpJT3AANdgT6xwEZpqU\nFNWQ+dnrgxdDI6GiyJJrWlv5ml4ORlAfry0vr4Bgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJuqy6a4/b9XFdaJVtHeXNvQK\nEm8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAItIqpzzvwc3VHB7RT84qet9GLorce/6JphEtw5ZQ3HLAiEA93Cp9Qhv\nZ5Vx+p83lJrMpouWPcVXbgDw2Yo78JYjLxM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXB1eLNb7XH5ZDkYVh8TssJ4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzE0NjUzNzctZTY4Ni00ZWVjLTg5ZTktYzQ1MzIyMzUzY2YwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTZmNDhjMDktODI5Yi00\nNmQxLWJmY2MtYzFjZDIzNjA2MDRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/6bKbxsPVwYfJ1GxDxeat9K2iKZkOAh7LTY59r7xWnXxvtTnlUGHh7e3G5CAhxtQ\nqj1cYyrgxp/pU24opvjTBqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwEJ7qMIcGXUZIPaW\nJqS3KtjsRLIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIHlKiXJrFBYhLFfJEQbVlntvm712zw9RgwZjPVeWj3IhAiEA\n4xItyZQ9uRy/5gut1pbFkGZTg8KvgtJHL0JmxABD0/s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4335", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4335` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAbVgHepbc6P2jTi6rCecT+RzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZTY2MTg1LTk5ZmEtNGJmZC1iZjk4LTJkYmQyZDg1MWRiNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2YxNjMxZDEtY2Zk\nNy00OWExLTg3NDItMGE5YmI0MDZjNzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4kvl90q+PugUQmcTyKhg+Sp11JEDX+egaMqfNBrCPZdXa8BpYXd7nGHVjikh\nm/DL3N/ZF/AS8ahoZBmCeExphKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXR7elR7E3H60yYYqQTqEwzMO2e8wHwYDVR0j\nBBgwFoAUSvEX3iqJytewazM7buk+fItnUa4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBTbQ1vmhV1k4Pfyi9nk1TUdDr+CWsyxE8Pd7c0gAECGgIgUYuu\nXvhBCg/5DVUTVLuqGOQgRpXOoLZHp3FWj/j8/I4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUHbiO4AQYWwx+7mYaLu/UrXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmU2NjE4NS05OWZhLTRiZmQtYmY5OC0yZGJkMmQ4NTFkYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1ejJU/M33Q0czrQXMgzdeZUv4r/EErs/BmAu89lGAk0wn\nVLQzVuMFVBmTsGVXbkrmgVW3z+gpBRD+cEWcbxMoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSvEX3iqJytewazM7buk+fItn\nUa4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIok5J+jD3zJn0MiT1O+MWbwyQgrZA+lkPbpeoUuZFPfAiAaFtXmwyGy\nXbDUG4JPMXUbWS7teycNj4uQCCP9XJBT3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAQINvmLaPNC+dYsqKP8Nn+tIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2YxNjMxZDEtY2ZkNy00OWExLTg3NDItMGE5YmI0MDZjNzI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjMxYTg0ODItNTQ2Zi00\nNDBmLWE1Y2UtNGI1NDgwZmI1NDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZD/fck4lGMUZp7sqSHKWU/E226077mD3AcY3jwroDrPUMc/G1aPKD56kQUkDFOZZ\nqMMIKUsjJXD7mEygBzxHhqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXR7elR7E3H60yYYq\nQTqEwzMO2e8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIGrcI3/XZPhSwAtos29eVGtDOjKWGB3onmBSFM2UA4LeAiBh\n8WDliFyGM+eQwODMO802mDGVm3oj3alV/963U/jeXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4336", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4336` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATEmaNnLoYGGAJ1oS0l68RUUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ODg0NjNiLWU2MTAtNDk1Yy04MGVkLWRkZmQwMDMzNjI1ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDU0YTYzOTEtZDMz\nMC00M2EzLTljOWMtZWJkZmE5ZmZmY2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkw7NiGNcFrx+FibkuOux4Thv9kWaA72nZJXCMiJmpICDaYYPJbAESvo1GE0R\n4rLcc+hKcGqMfhvmCUiHZAsZSqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZBxW13eoVsWXQVX9jR7v01ZIGa0wHwYDVR0j\nBBgwFoAUFj8gc3DUkb6wl+IL3go0heZ7abMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAp4eANZy6OuNe\ne3AKxbrGEQe9pmmZUTGsY5QbszwgtBoCIGJDAuw525tbMXJr5SPhUYRRpeeh5XSJ\nXsJWk8cFutUT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcaEA579ayEsNX0a7g+05NvhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTg4NDYzYi1lNjEwLTQ5NWMtODBlZC1kZGZkMDAzMzYyNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP8n+75XNw6wD42S+UYplGlIuAmKrsKeUGjLgZSkC7j+op\neSsSK8NlN/Wii3dEAAtMWupDdWOms48SV3HFFrLCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFj8gc3DUkb6wl+IL3go0heZ7\nabMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJDYdA8ZLVDFAfHvALdOsIBzGeUUvvS38+O98XGbEFrTAiAIULMzLogt\nG03QFSQaRtyYLoPpsCCSPsB3LVkN6Uf+/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAX6aS6w8wqDCREkN+U24A3cGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDU0YTYzOTEtZDMzMC00M2EzLTljOWMtZWJkZmE5ZmZmY2NhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmI1NTMxNzMtYTJmYy00\nZDI5LWI5MGUtYWZjMjVkMGVjNWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nntGB56tV2due5h0WUOIPUS6SK1V9+WIy8Ua1zEJvph9tzyvOEiOlKutydU14/RNw\nuuyibRs5Q4o69u1kH4FIqqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZBxW13eoVsWXQVX9\njR7v01ZIGa0wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIAFWL3eVWpXlij6O/g4NakTAV2V0+K/dvCYmzNsh92LfAiAh\nz33DEnA6boLL5gc+STwTJvmII3Mh9KQAVPMWDaLurg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4337", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4337` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAYvv7ykjF+e/RXQ13WjS2stKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3NDU5N2E0LTE2ZGMtNDM5OS1iNmFlLWRjNDNhMTdkZDc2YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUwOGE4N2ItMWI2\nNi00NGNiLTk3Y2EtZjUzNjcxZDI1MGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE34dA13ds5VFgRbPI9bi+KPlQxQhsXk0L1Slrk8f+egcCFNQcxijxkH95dDAC\n9UleF/SFgsl5PvpdEtngPZ6i2KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqjtTJs/v8JUo+InN0DBUwKtxYuswHwYDVR0j\nBBgwFoAUbf9/said+PN2RJkEZa2mBfbGg+8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC5Nabf+uJNO37W+soAtwnBs8B913v8h1vl8j/it10TawIhAIpvhLstjzHI\nYibj9yiJiM73E3RicVTXjK3gA9xC2jXI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYmzl8/M4P+GJ2zIX32by+HPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzQ1OTdhNC0xNmRjLTQzOTktYjZhZS1kYzQzYTE3ZGQ3NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+wH8tbKeS4jw/dhg4bBBpKeMZ7B0w9DsgYTh1WcZ9kxey\n5YD04ZVOAa/y5swjL/hrKlMtxkGKia2nYUyzmfhmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbf9/said+PN2RJkEZa2mBfbG\ng+8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJPxMK692CO94kejMzsJ37njr0cwgDUTAUUSE/Iv40/TAiB2P8E7bjP8\nn6l4aaNIk17nS+CynXA/fwSnjAR3m7700A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAWLyzsKsDAga+6550AeF8nUOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUwOGE4N2ItMWI2Ni00NGNiLTk3Y2EtZjUzNjcxZDI1MGJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjQzOTQ3ZDYtYzFmZS00\nYWYxLWI1YzYtY2JmYzNmMWEyOTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nK7dh5tYhbjreVljiVo+0sldDZqkUq4POcdKaD8bKEs3D6Q8WJsj7whN99Eh2LW6m\nDGmTRrybxhM47P0/sRoyIqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqjtTJs/v8JUo+InN\n0DBUwKtxYuswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIG05VwmMKo81QBtK4Hc0EbR6KnHQfbVqwyYZ+tr/N8r7AiBH\nNLlt6u9gZIQUK6yWT1D996GvNZdHSnZ6BWd0EI5laA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4338", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4338` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAf/zF9qne6hzCgVYslVomMTfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5YTY3ODE2LWFmMzMtNGJjMy1iNzUwLWFkZjAyOTFiZTU4YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg1MTQ4MTgtOWUx\nMS00OGI1LWE4NjQtNWNiYjUzMmEyZTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7xfR4RH9cMRF7J1Js2R0bCIA7HexMRp5ReqtpPVAFernv7vFN1OiVWnH9I+d\nQGfTTLTzJWvv+Lg1r6WaM+VEhaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj6ufDOyQt4RznoY3/VFas2Rj2yYwHwYDVR0j\nBBgwFoAUeHjZOVjgfkRCCzaPUNmXZGOKR7wwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDWfhUWZ5CCB/pdB4vbzWHqbLi+WoRLx837R7yFl3QXKAiB/d49em1Z0QhOx\nC5SQAyWkLjfcIDhSoceiXjsxR9Yq/A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU2EBgEoVQJK+Im2KcgwVb9gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWE2NzgxNi1hZjMzLTRiYzMtYjc1MC1hZGYwMjkxYmU1OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjfe+MPSa7aSw1nA5eMOcoozR06gq0bH/O3aEsACV+n0Tv\nLdbRXh7sg8tgKApdbtaSUz3MpmGkKn6TEVinnLyJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeHjZOVjgfkRCCzaPUNmXZGOK\nR7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQFyTLn4zimeYEQMqDsTtel+V64ZKHfjDBF++ptyJMCUCIGlYGv72X5pM\nfCaJSOr/XUw1nySF0XNDbU6pS9TWuiUo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWLC3DRZmMHiM9T8zjgVZBphMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg1MTQ4MTgtOWUxMS00OGI1LWE4NjQtNWNiYjUzMmEyZTcyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWEyMWU2ODAtNzFmYS00\nY2RlLWFiYWUtNDMwZjNkZWQ2MDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuh2Gly3DHwb0qubMBHNlWs1uJzsQzUXQ+8THYmjyCmJRr2BbKMqoEd3YQ6N5MKh0\ng/N6uWV81V9zueIC1BnamaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUj6ufDOyQt4RznoY3\n/VFas2Rj2yYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIDibm+dDYn0Tn1YJ4TlE0RQQECiEbkdfg7upWqjIWKBgAiEA\n6zTWpt1q/buLoHhLm6fum6Iuf26wGoCzMIWe9Sx9UQY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4339", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4339` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAec+nTzDNFnptgyEUTEdPCtKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxMDMzNGQzLTI5Y2QtNGQ3Yi1hZjFiLWI5YTlhMjYyMzhlMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYzNWNhZGUtYjhi\nNS00NTRhLTk2ZDMtYjk0YjgxMzg4ODQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDTiGphAMF6Yz6fsWJ4n8dx4lr6MefxnDwnkL/pOiSkWyr3ejeM0CTtUbyQTc\n7MlQpf/xtF64/s6pww/12eD7jaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkm5a7ooaFQW1LVxPvhO6GcnjOsgwHwYDVR0j\nBBgwFoAUbntlrlFDngVL7fyUVfCWRDWtGlswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBp64AMqxqs+v+K9cTB6A/9nrCwpoicYpWQFKatlC6eMgIhAOHlAyjm+D4I\n+w+zkixir2cyAnXZcyCgTv5/oSUNxmYT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU3zMQYLiyDyhvlenoeIjZdSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTAzMzRkMy0yOWNkLTRkN2ItYWYxYi1iOWE5YTI2MjM4ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUPUnNpOjDpBy/a29IIMQsqYSZ6WapgVzY44LFc7hM/yxy\njV+090OE4mzW+ySRf0QsQCcx1JMRd3MHZKEMxQhyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbntlrlFDngVL7fyUVfCWRDWt\nGlswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEcSVO6FPpH7iI2m0YaWVWYrOhVW3lKurkqwesi+l6i8CIQCihOi/JI2J\n8hmSJyP3Zf3ZMv7rY+zvXLgcBjN+ROTMjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZVHUuT393gnZx+MCZcIaylAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYzNWNhZGUtYjhiNS00NTRhLTk2ZDMtYjk0YjgxMzg4ODQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTQ5YjY2MzAtYWRhNy00\nNGM5LTljZGEtYzFlMjlmMTBlMDlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlBgexb4o91Fpyacd21yKFDAf09p4vcqVii8nDjt/FxNZOprg02rzd4bmXqoP1/ph\nQux9uj25AJYRB7YIPsgNTaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkm5a7ooaFQW1LVxP\nvhO6GcnjOsgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIC7cx/t2bh57HoK2KCi4fKvuEZk28raxWyjIPvB57ku7AiEA\n4bwahozpwW/EoC3Qh2EMCxe3en674N1TmcmrkFolS48=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4340", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4340` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAcrY5MZrI2K3qy+NbVWMdOVSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjYTA2MTM2LTU4YmQtNGFiNS1iZjBkLTU2NmRkYWY5OWU5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUwYjNlNDEtMDEw\nZC00Yjc2LTkyNzQtN2M2ZmI2Y2NmNzMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEghbo+3KFYaWJkXtne0s+BQqCUBghsVkAyltxbIPrU3pHOGgzK+Dg2VdvdHW4\n+X6bN+JeGNlS/ZykdlyaxOa1RqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU41wDTpn9PE5XcFWgtqrk12mY0mAwHwYDVR0j\nBBgwFoAU2lXwwZuGaZ7k007XGV+iNpWskYEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAkVY0lXL0oTTbWGQ1vtbj6dSUsq6XwVsZp1tbjzRM\nng4CIQDospNW1UFwSzHGYWZWUBA9GIPK/1VyLqSEAjMeFrh1+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeLvUiRLSVNZooj8g2A8vmWMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2EwNjEzNi01OGJkLTRhYjUtYmYwZC01NjZkZGFmOTllOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMx27slApRpHa+s93zNCbKaprVEGDHeyJiASsI//6asIm3\nFnOQNipQi1495YX247hvUEuadh6V9e9NcWToKjo7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2lXwwZuGaZ7k007XGV+iNpWs\nkYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKFMX6Xv7PjIfgKFp9TIU8XnlhMVQw9GxSfDbvH9pwUMCID3k22j+LJgI\nlQe+bX3sZjPc1bYEfH2z+1PTc1OJpKvp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAeoRi8j6GZORbMfvsyXZ5KPlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUwYjNlNDEtMDEwZC00Yjc2LTkyNzQtN2M2ZmI2Y2NmNzMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2EyMzcwY2ItZmZjZi00\nYjk4LWI5YzYtM2NjMWQ0MWRlNjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQypd5CC1rqFg4zqSJWnQ1NyQvvQnAAVx08QoAuQkNU9mltqzToXoOwvJyRT9ND2o\nDb/5++F8d0rA1kIwfeMrs6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU41wDTpn9PE5XcFWg\ntqrk12mY0mAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIH1sSGSDG0QRIsWIt6eunUDwQbVyMKg1LT9hSKIdy9MtAiAC\nnCGPwnDlPwFIXK/p9CvluWFK/yEk8BLwkJSMFfsNJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4341", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4341` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZhVxhhjfnYP9q7dYtVPMMYHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0Y2Q4MTlhLTYyNmUtNDJhMS05OTIwLTUzZjliODNkODI5MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGVjODEwMDktODhj\nOC00ZGYzLThiZDQtYmY4ZTRjYTlkZDQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3O+nJaj6c6sHH751/5/3BAgswHDmrz/LaTVh0tKR7B5Ff4IGJTQ2cEWIoa1t\n3igji1uerzM2Ljw3970Nk6A9SqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbLzMVI7DOCZCUO160IosPCuproIwHwYDVR0j\nBBgwFoAUPRbv47VSXh/l4/H6L8URzS/BAfgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAhcUzF9OkeOrh1RYp4C+geuUNLPALwtXw+o+MzHvb\nB/0CIER5r6oyZkaUM26jBlDc2cQ3onalcJSVsJz9udhVtOGP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATVMqK/f6t+5QpTlnYVcMOgIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGNkODE5YS02MjZlLTQyYTEtOTkyMC01M2Y5YjgzZDgyOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDXjvOt6aYPsX77dq5zFm04wwOwpRM8RZSm+Efanrsvnhl\ngYFaCq97+4BlaKdq0AYCcXztUpelsAzezEUY6PNfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPRbv47VSXh/l4/H6L8URzS/B\nAfgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ3KgrhdG9QTzHzrMoKG9jMkK1BF9H/7V4DubjwPbc5cCIB/wN9I7vHNo\nNv9yHeHVV8yixxPCAm2mFBoGXg0bxM8Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAUK5qYourScTSltXlLDZm9iPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGVjODEwMDktODhjOC00ZGYzLThiZDQtYmY4ZTRjYTlkZDQ4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODA2ZTJjYzItODc3OS00\nOTIwLWEwZTItZGQ3MmM4YmE0NjM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOSAxE4JaySrUHdiSmtgr99F3hRK81wVFWSSKcuWsk7C5lco6z27ZsVn89rxry30F\nO7zJwJAJBR9lxXA+IIBBn6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbLzMVI7DOCZCUO16\n0IosPCuproIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDaUJlOpr10hlwk1tkyUiM8skRaozMwl48EwqQPRGPE6QIh\nAImWqWn0rP5RUW624tyQEyFKJCQUy21DntTR8Acav1kB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4342", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4342` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAUPIRIpaI7c6oGYJoF8OZqpcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1YTM3NmUzLWUwMjQtNDQwMy1hNDNmLThhYjhiMzQ5ZTA5NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RiZDdjZmYtMjFi\nYi00ZmI5LWJjNDgtNDkzMjMyZGVlYzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7+PStQc5jYeElQqxmPhS5AXTRnhEQFpCSAr9YfkwAssHrT/YkBCmqwyMt4mf\nUMAWGLkVtQmVL9wLapCNBSgzkKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs7R2cxD3E7TMJR6lvjaXuwSaNZgwHwYDVR0j\nBBgwFoAUF2h1NOl8/eGrjrSKGqX+OQbyTOUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAMUTPfzoWJLNwgUVC79omgQXt2prNruSl6TgN8N9GoIgIgGKyd\n+FWZeS5C1QaIxkb8s4lHc8hTxsEVRy78d51NM7Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZjtEyOY8pwAiDa1LRlxGsF4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNWEzNzZlMy1lMDI0LTQ0MDMtYTQzZi04YWI4YjM0OWUwOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZiNwbgcD6EU9NpuP/9p4aVazHAKuOlR7yd3cutu5ZM9h7\n5PYAeU30QtotTx/ysH6UgMPsd4ch0RZDBEqTlIz/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF2h1NOl8/eGrjrSKGqX+OQby\nTOUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgesOxg/JM5RkWRgDx9T5bM5qsUHHVafvnzxbaCKZYB8gCIQCJCEfJZ8nV\nYoL0srDrqQjXwDH/do4r7JA7guwRC43jZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZQvZBg9peV809FTo+AN/We9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RiZDdjZmYtMjFiYi00ZmI5LWJjNDgtNDkzMjMyZGVlYzE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmFmMTQ5MmQtN2JmZS00\nZjM5LTk4MzYtNGQ3YTBjMjlhNTA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVLSBWe5yeTpmnvOnlzeJk4XANb2Pu/Bri3CNxX9Iq/XvWcT5VOeFPrb1NzvY0esz\nY55AeCGlxWrgCgvMAKKKXaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs7R2cxD3E7TMJR6l\nvjaXuwSaNZgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCVgmZAh2k5jFQtJe2CAh7IcF51PDRp1I7rdwaWkM/BiAIg\naX18fXfhUDS7h514PjMkdwhfQTNcpYGHjXFJwElXFIk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4343", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4343` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAekNHw/l9i1aRDtFztiktxbdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0MjcxMzY4LTY5NTEtNDA0Yy1iODhkLWNmMWZlNDk5YmVkYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE4NGM3ZmYtOTNj\nYS00YWZjLTg0ZTItNTljNTVkNWFmNDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfFlWr+jjdO2PTE/FM+WgNvVArDCCtN1Rdzd84f64m2qYCDVvOMfKoxhZWaVy\nDyBdbTCObA2JVun3OYUwja3JFqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ4EYgoL5sKK1S4oAOVsFsE4+hdIwHwYDVR0j\nBBgwFoAUN5TBnWSJUgBgJjlwel8ho4laueowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3fXHklnBrDmAKP61sBOdXxDIRufMlMJD\nVbtLRa0ubw4CIAzvpZAK3k76UP3K1utaVwV4BMXHFTpovXYmbSbg12Ed\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdpgpaCckyL/GDMuptOTBaGgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDI3MTM2OC02OTUxLTQwNGMtYjg4ZC1jZjFmZTQ5OWJlZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyu6WAhQgsRJbvOAJRsQOIG3RmeDZdCuSKO5Af9m1IfXuk\n4tTNH00xh48rF4I1B4ZUlyyzkcwtMUrPVdSODWtdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN5TBnWSJUgBgJjlwel8ho4la\nueowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbvH3ftxGbeywgA1B83ecmgF736TYEY62kIDZGVzC3msCIGYMOmrRpVjk\nyh2CIyjPXFqBgOQQCKKhjjWMA2KL4nxr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZonPLPx10yiSADdXMs4BN/kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE4NGM3ZmYtOTNjYS00YWZjLTg0ZTItNTljNTVkNWFmNDYzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmFhZDAzNzYtMDg4YS00\nMDFlLWIwNDAtYTlmNDlhMGVhZTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9ZQKPUbsdq32kXjdm4sHsm6IFdjn+D6mcZOvngDwdJ81QoRQPmnNVa4iYY4wUYEF\n0NT+dyyhW93i3SIsSb+dLKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJ4EYgoL5sKK1S4oA\nOVsFsE4+hdIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDbSfFBlVXlfGv9649W9iNohyrmru72ekz2jCT7ofCBxAIg\nOFWiVQLa5+X7Az0L6t5jDYhCjoWBRmQOWohUGtxw54k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4344", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4344` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAfQvCCMWAm6pSMAE4+U3+L2kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlYjYxYTgyLTIyYTItNGMxMS1hODRlLWQ1ZTNlNDdhOTAwMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY3ODhlYTUtNTQz\nOS00OGI5LWFmYzEtYWViODY5ZjE5N2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcq2OOkPtezwl8ZS4sGsWSVCxnA4MnXNAOjvFiQr/zuQRQS0mj81+wy/PvM79\nhHFj+PqLmr7QR0jNSK96klUW6qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURVL8hBhWVutFJTm4oS+elzKv2W8wHwYDVR0j\nBBgwFoAUQksN0+s2SQa+ssec6ss/lynzG38wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3Eqw3pGLhlwzMUksldG9b7oUMRi3hAJ/\nvsUVcoz1C/wCIFMzS7uClKg4/lzPAsoltsf4eCRRmvHGyHTPxPsWkVGD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASkAzbjB5OGzv0kyfm/A99CbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWI2MWE4Mi0yMmEyLTRjMTEtYTg0ZS1kNWUzZTQ3YTkwMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxsd6p/bskW6WNw5nGKT/ouK4oju/sS6/VVIHWpVmDsZZm\nFTDuAWHFM6SPMsvZNTHHLLSMEyhOHqRpGLD2zyW2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQksN0+s2SQa+ssec6ss/lynz\nG38wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ4tZHAm33g82F3AdbPbz/knjL20n2mTL/A2NwXWtrPQCIG8KzMU9RKTu\nYKoRuELdMJb7Le7TAmseMOy8eu2U8/4H\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVsKwSJev+0Uvnzu3EGJlOszMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY3ODhlYTUtNTQzOS00OGI5LWFmYzEtYWViODY5ZjE5N2EyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2RhNjllNjAtOGM4OC00\nZGJhLTkwZGYtMGNiN2RhNTVlNDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDLdhloTbT5ZmQi2LAbBPsJ7TiwaIDR4+O2c+D6EwsdCNeZboQ9uJN6XmedxeIPWa\nuK8b//SQTwduFxJ3tF8Hz6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURVL8hBhWVutFJTm4\noS+elzKv2W8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIBbMrtzt0T4t8oFUTFIlohyQwQWv5IOZMBSgrsJEoZW3AiEA\np41PiTs4nOv8xZhh3Ey1SCm0tPJjmJEF4yGPA+ke4kc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4345", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4345` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAU10scZBQzj1s3g4qupKw4X0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0ZGQ0ZGMwLTBmMzQtNDAzOS1iOGJkLTA5ODExMTUwNTJmMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFkNmE1NTYtM2U4\nZS00NjUxLTlhMTUtMWQxNTQ1MjRmMTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF9cSH3/eAJP/JP5r78UBWjw2+mrrAaQmNHNvX4kW3jfBUqQ4L8/duA7yWqjx\nJfq1DZjEeZPqKugpWF7UPi/HiqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwANBQK7XZ+IRWCXL6nquT8HpAeowHwYDVR0j\nBBgwFoAUf9yj9O+k53YikiNNTJJlzOhiRlUwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAsMK2OsfS/kcK\nZ6Ijt0WkYSkKD8NstC4v+unwpr10XcgCIDKjrSAsSMj7BQDNXNjSGJi6nVUy9kgw\nCbRUWebKsKas\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXDvJGwS+vcpdJM4k3PhbmXYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGRkNGRjMC0wZjM0LTQwMzktYjhiZC0wOTgxMTE1MDUyZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7miV0TFF7Wqegn6bG+uSDJ7RTQWWQHpaGvtBOoiFDRqWk\n2OC7s6BBeNJGgUpShkS3YMQiAkgdbpdGnVKgUevWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf9yj9O+k53YikiNNTJJlzOhi\nRlUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALRU+4h5ulweQHfv9GhdpiqjzSavi7A3RVAL1djRbKtRAiAyorLX4LYk\nKeR9l6cTB9TRlqi8pYKtU4PT9ac6GiNEmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISARSxd/FvfITCQ0pF6I1QCXxzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFkNmE1NTYtM2U4ZS00NjUxLTlhMTUtMWQxNTQ1MjRmMTU2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODA1OWU4NTktYzYzMS00\nNmEwLWEzYzQtMjhiYTBjZGM5NDlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuPST/sB9/GuIzvdZLgw61LbBj/AgjzI+OKhDtaOrn6+SFD1MNrLaeaTqiq2jhigQ\ny8H+/HkmHA9Cin8kDEoCcaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwANBQK7XZ+IRWCXL\n6nquT8HpAeowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCICagITtKDRmwldjf4T+4PtnUIX7GlaQJ4wf9IMmOarWGAiEA\n7XURh0HyJPUJibZ94Hxfj0//BTXD8FjGS3I+qolWmkw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4346", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4346` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATCh6RGP+GoNOW8w2X6Sr643MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlZWUyYmQ3LWM0NmEtNDlkMS1iNGFjLWEwNWZmYjkyMGI3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JkMjE5ZjctMmNm\nMy00ZmY1LWE3YTktMGZiMGMwMzQ1YThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf8bQJCFe6XnV+6zw7RsCZ2PM0IPI2i0dJm4+Wi0OTlDtauJZZ1SJa3b6+1T+\nz34IzXzxFyvQCzTtNR22QAppdqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUITOlGXTOurdMDpt2QQR9wJgGKqUwHwYDVR0j\nBBgwFoAUGHBTH7qLDH1Kz/Jq33mRBGs1X5owNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCQMstZtfabH81SLNSlYBGJNGltuUHA/8JKXnzXvnq0ZgIhAPoq6O+IsMS5\nKRY6CZnIwmn0ggTiJzD7cIMWn0Q1/m3l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf8PVEcQGwQ3uhh7NNjsq21DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWVlMmJkNy1jNDZhLTQ5ZDEtYjRhYy1hMDVmZmI5MjBiN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9R9cK6oJ1t7ZViWhByvNx9QHs+fP3TRby5e6zcnwLm3b7\nHZk4phaYwFQFbclbLAQfxb/+vbr5cmprxmLydoPYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGHBTH7qLDH1Kz/Jq33mRBGs1\nX5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIilw2yRgpB5hVX1xNJdp95wqzQ/eKouwPlwrW9GZ3oECIH6garKhIZ8k\n4mhGqVfwihc9l6oSHgK7AiDUKXAOqnIn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVsI+qol78m+l9FavtJYQKAUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JkMjE5ZjctMmNmMy00ZmY1LWE3YTktMGZiMGMwMzQ1YThmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzI5M2RjYzctYzBkNS00\nNjM0LThiOTYtZDVmMzhmNWJlMTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZcZsMoeBxuLn1VotZ8o33Oe7WK1JQ4yWKvBp7JUOkhefd1TGOmQd6WQ7dt1rOWW7\nx7i477CEwRw0TV4bEiOlKKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUITOlGXTOurdMDpt2\nQQR9wJgGKqUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCICKltjsx+uqsqFZua8a9GJd6mjkg/Y7jP2U2j/GxSnANAiEA\nkvtnK1kg85+3dR3QSWYhZsLPKT/UyCvQq5UgtsI5PmU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4347", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4347` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYQ6aJudsy55ZvL708gTx+XvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxYjgzMGI1LTQ5ZjktNGI1OS05M2ZmLTYyNTc2OTc4NmVhZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdjOTVmMjMtNzQz\nMC00YTgwLWEyYWQtOTQwMjM2ZTNhNzc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyLYgVpEDTbysgfaUBgIRAoy8zh2XcbTFaoJmfOAgeYwHdbzdnahfMHopEwMs\niLO4PRgyhO90P2/QlCmYscdcAKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwKRA8HbG+uwp0aS9PuYCTgaPTlEwHwYDVR0j\nBBgwFoAUerCRP70wOH8KlZoMYf5D/rUyS5owNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGVPcC5clZjxJL15wFqvgM3D/JZpFxu/ds2FW13nD4BDAiBIwYpAe4q+Kz3r\nTqJzgdkOy/DQcaRDUMEuiJEanlLBrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASMpZTQa7n18FB5dqL5h4srgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWI4MzBiNS00OWY5LTRiNTktOTNmZi02MjU3Njk3ODZlYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASX5uGiNV+Xz2ai+Uz/GIhz6KlSP1SI7t3QHm74MOtxGLUZ\necWD7Utk6NVi6dbTybNwaPSDyNYH8Lujp+ukSIbbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUerCRP70wOH8KlZoMYf5D/rUy\nS5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVOHhIpTynND2/Q7FiMVP1zUZnpMAKwGFb8HVLM0ag+gCIQDZy+H9oLud\nZlbSTZAD8dHI1RqaqCb+KwKi8HcAgEUKzw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAccH+2oJi2xl+TsOEPWzMSCxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdjOTVmMjMtNzQzMC00YTgwLWEyYWQtOTQwMjM2ZTNhNzc3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjQ1NzlmYjgtMzg2Ni00\nZmYwLTk2MGItZTMxMDIxODBhMjJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlEHqCkHC8wVncqmNblCYtWt7DJL1j/2cTmeoSa8V2LGRfc/yrz0XHwf4HfqcC6h/\nIJyndyFTDAjzptt0qTeGAqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwKRA8HbG+uwp0aS9\nPuYCTgaPTlEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIELbHwz9JZk2nfZwJcTVujWQBHLIFZFCMBzK9WQ/hyVjAiEA\nmfKk7BSK1G+pWbYRpOMje9bVPGVyE+5UkojMg2WAG0Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4348", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4348` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdjQylYfrBHFnIuYjS+La+fbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNjJkYWRjLWI1MGUtNGJlNi1hODEwLTUzMWQ2YjM2NzNlODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQwODQxZmMtMTg0\nMi00ZWRjLTgwOGEtNjcwM2U2ZWNjMjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhwH6U9o0F5qgN5vEf7JYga6s1c7EqzQ9TsGtfaw2kY2Avs4JfYpBWMgoxFhn\nALBupciwSYEXhswfH8ulqNfOuaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqcTsvX3hJ1BO/AunqVBLEfxI3E4wHwYDVR0j\nBBgwFoAUSczTwJ8LQfhH2I755gGso6Nh9NQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAzcxWMSOA1oTNG8mDPWDzHlxdKLX4j6CqDFvRx0aiQvwCIGAOH507duMk\ntWROhNk7H54DeF27N7k6KsUd8RsUtcYk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZDrJY+x7ktlOVGkIFvOPKrsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzYyZGFkYy1iNTBlLTRiZTYtYTgxMC01MzFkNmIzNjczZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2s8bOnqdcbin2kyYropJ+raJxRSbXC+nnuc4Bb6lKzUu4\nETGQGBVnhiuzzI9aaWzC2CHlgmmaz0U/FOH7PfFuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSczTwJ8LQfhH2I755gGso6Nh\n9NQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGrdEhUpIDRsP8x//g9jTw/7nQyjoF8vhQNJxZlGVAIkCIGY5JA3w4TZj\nROBsjiKtkLztDq3alu5Wrga1P+Y5CQ7r\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAc/cRLoEsFb+U6CpaJUlLhk9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQwODQxZmMtMTg0Mi00ZWRjLTgwOGEtNjcwM2U2ZWNjMjRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjE0MjI0MjktMGYxMy00\nNWIyLThmODYtZGQwZWFhM2MyNDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZGI+S/7MGHvz3cz+4MwXhXMItm+9wouCFCE/7eExcTtUoEM72WuOA4IyuYyb7VyA\nQnsw3wbqvuPVGZZ68KyejqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqcTsvX3hJ1BO/Aun\nqVBLEfxI3E4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDSW1LhrF1AdaDzrDmz055ewT2Aq8+XZBmvdc2zcNKztwIh\nAI5DtXLvQ/RuKxAj84e0tp0DmYSMNrL/6xuDt4K2M/hE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4349", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4349` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcU9DGcu3a2DyuIU/o6VKBR4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlM2U1YjEzLTM1M2EtNDIzNS1iZjAyLWNmMmYxN2EyOTUzOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRhOWZmMjUtNDRl\nMi00MjI3LWE0ODEtM2QwY2M0YWE2M2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkqCPBcQjW3rZUHEZvN7T3N1s5ElvsfucHnRbFTM9ffyZaeMBnrF+XSSf4UZd\noAWEt2fiD6dYhQ/Z7JIJRNonxKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeo8c5vuMgVH3FJAROJWDKx0wY3wwHwYDVR0j\nBBgwFoAU710cjqe3x0DIlGFWETKQtwCNYeEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAydRH3cSRGQWc+ziaBJET1m3CaFZmQbKXPlepmaNp\nw/YCIAUapKWSeJzJnW44qiFy4++s1UG3NB2f4rvHckj5112i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXgRMetgx+ZPTSsiGssReL5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTNlNWIxMy0zNTNhLTQyMzUtYmYwMi1jZjJmMTdhMjk1MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARALjAXAyWQlZJuPUNVLU40nwi2JRGBmHwva6mAiHxJj6h0\nwU8NlhZ9HfmC+eq5ChFA9ohKFxMZcmIkugHngsLvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU710cjqe3x0DIlGFWETKQtwCN\nYeEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYy+393ys+9LU9opbCEhJCKZAtO8WaoEYpnNAnpJiEBYCIQDyfx3VuxuR\n6kydMjZibQY/V7Byj0M6uce4egk+662ijA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAQIByr9yE9UTNuIdQUSqDJUkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRhOWZmMjUtNDRlMi00MjI3LWE0ODEtM2QwY2M0YWE2M2VkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjlhYTAxYzQtZTI5ZS00\nNTU5LWE5NzEtOTkwZmQwYmQ3YmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2606G3SWPZlUUimsFLgZVPgbOe12jw5jjQQ8m3H4BmnbPlM0bg6lnGwBYQt33Tkg\nc0vPPvaz828y+dmeq8XAN6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUeo8c5vuMgVH3FJAR\nOJWDKx0wY3wwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDCkbNybBEdbnq6pRRNLzAD3vk3XaHkm5HZU58VEi6iWAIh\nAIOWXdu0yL/7xJv9I3b1uGE5j8/8erohPITb4AGMaJJ8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4350", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4350` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAbWujj2FKQP/20bwlGeBCvWXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4YWQ4ZjQ2LTVmZDktNGY2Yy1iNjU0LWQ0YmMwOTNmNDgzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVlMzI1NzMtYzE4\nOS00ZTk3LTk1MDgtNWExZjQyZGU1MjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJkSb87N7rn3R1YmgeSZC1ZEbgohilwOgeoPsIyRwm7KjIv0Qq1z+STi9qKKR\nB88OLG6kRvJkAACdCdp9DiAY7aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUknXW2a7BwgX4G5xA8wFT2J75PdAwHwYDVR0j\nBBgwFoAUjw0GHCunwAY5z0ksTrCRFg4QayIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA6vlGLLYmopMsYjCNRYHgLisKm6yLdHxonvw++DsG\nzzMCIQCGQrT9GRMUKut6NLxxUQg1sInoJIhgn2dkfK3K4A/3bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfAsLy1nMIt2h8t92EJ8wvQ4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOGFkOGY0Ni01ZmQ5LTRmNmMtYjY1NC1kNGJjMDkzZjQ4M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaLfBaFhkkgBg3gVbV7itXifHH0Rp/njakYzhnl0P9HSBn\n8ffrKUw4aSPJGG4GQPLbPtmTiRuJmrXMDVZK8yhUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjw0GHCunwAY5z0ksTrCRFg4Q\nayIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJyOMdmQkpVsybray888nHSS8Wh1AA1LfobCPiU+DHVeAiEAmK8vu0DX\nXVt3bydQWiX25zcDzbA5tMtvgj+h3oTqUfI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUf3KM0WeT4YjMFkmRRnuRjQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVlMzI1NzMtYzE4OS00ZTk3LTk1MDgtNWExZjQyZGU1MjkyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2VjNTQ2MGYtOTI4Yi00\nNjdjLWI2OWItMzMxNWMwNDY1NjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noSieTZqX+dA5PdwSKWuRH3b/8m33MoOWtbhib1/Q2WjOM6lkaIb8Ret+HfP+TiYo\npNnCMbCLY5qwZ7DLSfIKeKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUknXW2a7BwgX4G5xA\n8wFT2J75PdAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIBlQLw1DVrM6ly1uqe/vkKLojVA8kTH2a7I9M/+8bFwOAiEA\n7YYbPmchEmRVT6p6llYRSWKYB5AfxasRSzO+YBUfXKM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4351", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4351` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISATamDx6Jv9D3s/bCMOizhZvhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2OGRkYTJhLTFiOGUtNGFmYy1hMzhjLTA2NTdjMThiY2M5ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM0MDBhMjQtNGIz\nYS00ODYxLWIwZDUtZDVmNDViNzIzODM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0KIC3u34uaxOiBbDP1ffU4gbUSH9uW/9D/Lyrh3Co7P4oxE9fRcOsBChWTUL\niTCdZL9PEUOwkZx1QE3B4qGQVaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBGfiSQS0mqay8ogF0zqfuRQjMt8wHwYDVR0j\nBBgwFoAUUzu8P1czse670M0bbfr2B56p9K8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAt/0uEPAsI7xvemce4LVhfzLut0KXOwqmdqpHJjP6XkoCIE+1\nqMkDRtJq/xOVPjyENkLZ9vKki6RC69P8dmrDEgDf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeoGFJ6pwJynNVlHF741GOdjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjhkZGEyYS0xYjhlLTRhZmMtYTM4Yy0wNjU3YzE4YmNjOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS40pPWiRdgoLLO3UZxreG1BrWMihuNLNgRRt8Fx2wx7dXp\nkGNlvMkd5rVPuXr+9d+BpQk1nhBtGsVW20YXClx2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUzu8P1czse670M0bbfr2B56p\n9K8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANi+j6B3pQQGyI8UT41jIvbEzigQM/+D6AXIYoxDTFd2AiA89154dUSu\nXNHQNWhZSMfNyZcSXEfgVF7bHjJDs8pwag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISASCySrLBHFdIolb4Df+m7yYoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM0MDBhMjQtNGIzYS00ODYxLWIwZDUtZDVmNDViNzIzODM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTY5YTc4MDEtMDMwZC00\nZjBmLWIyMzktODEyYjBhOTI2YWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNbj5u0tmzy1haRmmzaMe1xd8S/mPr/ILH4qdHjYdpdgDnSfMhR9o6omPXBYs4B7q\nKe9wndV2DEvwGTL6bTfC2aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBGfiSQS0mqay8ogF\n0zqfuRQjMt8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIDsVCa/vI+sN6zO2Ga5lOe5F5dTYE2AUxGnUTIIbNh6WAiEA\njwFGMpQUHr4W6UxCuOgCNPvoRGwRzhSWAuskd5xH/UI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4352", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4352` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAaC0NJbZ2X3gZ3zM6MVTHkZfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkYmVmZDQyLTkwNTUtNDYzOS1hYmJjLTlkOWIzMjkyNmIwZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODIzODVhZDUtZWQ3\nYi00MTMwLTkyNTQtNDU4M2JiMzhmNzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZChquHqjcOtIJny/r+3QjA3kbHQbvYJV1rdZWR+G30tkrr2/VUaREI6KKEZW\n+bB4KBssH+qdiRKtwWa5P3i4TaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCeoWmpjT40zDdqg6YXb+aw+JRTEwHwYDVR0j\nBBgwFoAUDGJ0uoMSRAVxNSFe0vq7n9OH2f8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAm/ec19Hu7zw2YJJWZFZ5pAovyQbcpmCJ\nQfatfPOKykoCIQCZSrXr05Itkb/SCPjANnDBTxz0VEQ4j8mIIh2ySgWvXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ4l8W0nBKm3e0hEoBCEGjd/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGJlZmQ0Mi05MDU1LTQ2MzktYWJiYy05ZDliMzI5MjZiMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARK6hVETnERD4/QdC6A9KgDOytwcL1WId8vrpWNhf46gkem\nXHI3GtDCYRAldmd0xqdWvcAT+VTULWoNDrwskMg3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDGJ0uoMSRAVxNSFe0vq7n9OH\n2f8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFwiH81ps03C9iy5Y5FCE+zLDcI89NzEawCoQdqsOiuUCIQDMqG3+1Spb\nUvKthX7IdqZFoDVX/uqZCtd5RRhDkCWw4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATQnXD1ySg+E3IyC23hKzdeIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODIzODVhZDUtZWQ3Yi00MTMwLTkyNTQtNDU4M2JiMzhmNzljMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjI0N2E2YWUtNDRhMS00\nZDAxLWFhMzUtZTg3MmVmMjQ1OTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nv2sGp4PPDrEK9hKxM9it/pvoQRby8Z5aqX+4B825lJr9veSKcilT9QApuyE9G/xF\n0IsS/B75Much/DB7kjde6aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCeoWmpjT40zDdqg6\nYXb+aw+JRTEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIHDlJrMCdMcgOue4oUs4D55BobAOv4Z3/bRq49N2AMMFAiEA\n4s7+OsaDvgC83tywJ3QhnuNkhLK2SO5TFR134ueh6fo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4353", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4353` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISASgu4wYhrIHdAWziti7a+PdpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViMzQwZTFjLTBjZTUtNGJkNC1hMWQ0LTg2Y2QyOTkyMDQ0ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY0YjJhOTItYjI4\nMy00NjYzLWI2YWEtNTEzYzc5YjM5OTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj2LPoqSMrd470FJhROfFbm1ykwoS4pKHxMus9OW6rJgz/PE/lOuYL3wQtTwS\nvJ/8D/m5loVrNz/QWQe65INCzqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU67LKu9wAWnyOdxeeBxMZKjr9xrgwHwYDVR0j\nBBgwFoAURYL0MoeRFfl+oJl1xJBP0H5WrIwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAZ2ac4uL73gqw2aVKbiHx9JR1RUushmfuB\nYnrIMkqAzgIgHMGVhBbemOPICy/7en0/qUA4hnpUK0AZYyZoGZ/GiVQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbv+a3qO0vTJoNHywU3JTseVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjM0MGUxYy0wY2U1LTRiZDQtYTFkNC04NmNkMjk5MjA0NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUDxWI/TVlhqK9fl8MoBEAoJrwUEcQBeaRfrtdvMbrL7wV\nymNCE+ZZPHXeEJuJ4RmPf0bOx8Dx2tw6y2pUI+nJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURYL0MoeRFfl+oJl1xJBP0H5W\nrIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKMIVMAZQ5YCY5x8yc16Y4mFLgqXBxRYgqwosHYhkgJMAiEAgY0kD//i\n3KONMDdoGtSv1P+bKK1pw+LKq1zCvzBCJkM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAYNP5nb/qbtYiN0wn7kTzYk7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY0YjJhOTItYjI4My00NjYzLWI2YWEtNTEzYzc5YjM5OTBlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmU0YjRhZDQtY2YxNC00\nMTllLTk3ZDEtZWFlZDEzOTkzODU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nma/BIMYYm8fkKffk12gHWYdD+VbLPoMeeLpk8KUwVQEIUMmYv4wq6HfajwWWDz0p\nJI9uQRH1VyS/OGvBkEzfW6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU67LKu9wAWnyOdxee\nBxMZKjr9xrgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQC47NPtsDD5ZJ8D3wRwRQ03vm3si44wSA0iu+LzQNGqOwIg\ndk+hEU0qKZ27G59ERvH0GGouEfGPJGdi2fvshiEMAPs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4354", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4354` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAXJ68H5S63McoTrvfV1nlbLxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4YjA1Y2RjLWIyM2MtNDlmYy04MWMyLWZkYmI2ZDkwNjExODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGMwOTIzNTktMzU0\nMy00OTM4LWFiYjUtNTE0YWJhNjAxM2FhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJKVw+dTH8Bms2s+2reAtjBR/LSnasxRQYktdAq7z+C0hq2CBQQY46AJXRkdY\nci+vCkEhcLd5+N+CbxVST9Hx46OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULTI8e1zUwUmTShCFPSkIoEBYepwwHwYDVR0j\nBBgwFoAU9Aisui2DFG1yGLkibKVhu8USNPwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCTzsyFrpxXEsiBYjlCDrg+jjmZ\nU8qx6cUJ7DOpgvUnewIgdc/tRqRXo2CUUbWHAg+gz4IybmiwAteQZFseaay/h20=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf541lmdOP3fjo5vxvBvymD8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGIwNWNkYy1iMjNjLTQ5ZmMtODFjMi1mZGJiNmQ5MDYxMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJ5bMaoudite2NQKcbrjldnQOi9VHKWUTfh6ULpZ468hpd\nt8xNI0YOJtKELP8chguIDZ9wGHPGmoL8T8QUuLKQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Aisui2DFG1yGLkibKVhu8US\nNPwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKqI21GONn8DVjUcSzX/Et+Kp5upQj78jNow7uNZzzwVAiBX/956s1rQ\n+bLmuZhhZ82/8XtIP2s9x36We/+TX0yIjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAc6w4GlD95WBGrrsQEpL2740MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGMwOTIzNTktMzU0My00OTM4LWFiYjUtNTE0YWJhNjAxM2FhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjQ1MDZkYmYtOGNhZC00\nMDIyLWFlODktMzI5ODc5YmI3YzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXEfXY3667DdsTMJrsWJ7mIwW+sMeSn4oIvuBTaDYKVMqZmsFYkAWyrTW79JUDNPV\nCP8HVCWnFuyXVWabHWzvSKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULTI8e1zUwUmTShCF\nPSkIoEBYepwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQD6xj67/AFrWrNnvPNhFmJcanJQ0tSKHKtJ7wRG8b+6PwIg\nO/uZD95/3u3gdEGToFSyh0ioUi1GUmpc+tN69t+XHuo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4355", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4355` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISATbdFnkmPtzw8VfLmxQrcFVCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MzJkMGY1LWUwNGMtNDVhOC1hMjZhLTc0ZGM3NDI4ZGUwMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBiMDRjOGQtNTRj\nZC00OTFmLWE1YTQtZTYwZWM2NTYzMWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEYO8SP8fdvkHCS/rajVRornXIlZZJ/px9FXg06NNe1+fdaqFYl4CtqVpz+Hj\nAmiAFf5blAuG6eT1VnD1X4d6t6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdZlHAHBGDsu5RvKm6jkWjkeUVBwwHwYDVR0j\nBBgwFoAUQmsYAJ/wFlBPuFno3hDjCZlNCF4wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgVGmp3ean\nmUFlZehawackkvWMREhWqoUwhOtEYNpxErUCIC7dVnpXlmIZLBgRz5vkPUyPUXT/\n6mQSSSPI3ayDDOMQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARTmL1E9PCY3ZzEmYfVqyrfrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODMyZDBmNS1lMDRjLTQ1YTgtYTI2YS03NGRjNzQyOGRlMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+3DH9qIY7xAnCzNoJrDXp7OvQtMF+/HgRUhlQkP9Kmjna\nd6+F8VzHitU7iO4UQa3MgWSZM/cdP4mwrSN/jk0qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQmsYAJ/wFlBPuFno3hDjCZlN\nCF4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK1IJecG1ZsxfW06c96wgbcpD9rd9S6BtOZLs3/yGZc3AiBKxu2QQoL0\n1exBASnwgzGeD23qOWZ9PXPlO+M+1aS/gw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISARzp4ioA9VvuQuUy2bNDsV7IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBiMDRjOGQtNTRjZC00OTFmLWE1YTQtZTYwZWM2NTYzMWViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWZiOThjMjItMTkzYi00\nZWI4LWIyMTgtMWU5NzIyZTRkMDJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuMEdQV0po7dyGhVMTbr4EOD1UOL0/k8U0xNFD73Wo163oLlomSVRWs8sYyCxxTzq\nzDFtGd22CWz8i3a3SKgVxaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdZlHAHBGDsu5RvKm\n6jkWjkeUVBwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDZ799tobdx1n3gA2B+v7MkC35zV3HC4wOfMSe3kEPX0wIh\nANQ9reu9EmyfTjSMMQurM/fisTFPJgJKRC9Gjd6BkAsP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4356", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4356` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAYXaz3EFbuCQtuPxQkj8A1SJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhNjYxYWRiLTlmZmItNDBhMi05MjdjLWZkNDJhYjJjNTNmZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM3MDA1ZWUtODE4\nZC00NDdkLTk5MDctMmM4Yzg2OTAxZjE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo0SGK1hWGQ018Ke3t0547lh0exmbhdi03gGW3kWsCXhUZkKRdGlwk7WQEtHu\njqRnYeYaKVngpG0G0kl1nmqNSKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOI/FREFj2zDR8Rbhhn6c12hETVEwHwYDVR0j\nBBgwFoAUyb+IZKqTKXyv89kBwJp5fQME7i0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgZOlupeX3\nuJ3oOQzJG5IOZRUWUgqpEiTvzCJx2I/kx1ACIQCiaey8x9NZkFf8yCLL7GO/M2Ob\nSOWbb27L64Oln4EytQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAULFX13ceRnkYuqR3FM/ZWdsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTY2MWFkYi05ZmZiLTQwYTItOTI3Yy1mZDQyYWIyYzUzZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0YQX8O6nX7BORoKnZd+gzxKkAjlPYWhSwb1q2ajqzWHzV\ni92UsDyD63SIZeqVkTrXSCwI6aWLyoapUt0Ci0sro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyb+IZKqTKXyv89kBwJp5fQME\n7i0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIRZRfZIMl5/Hi+JM6UaYeWhJB/yp1fedFg/qj3bPdWsAiANOaA+RaCA\nbxjZDhtNHq6MxVAc7kjh+AxGLkaA5COBnQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUhRSkUz/fYtA3t/RjaCP+DJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM3MDA1ZWUtODE4ZC00NDdkLTk5MDctMmM4Yzg2OTAxZjE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGE1NmQwYWUtOThlNi00\nMzRjLWEwNTQtMTI5MzM5ZWRjZWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8cnBujVIiRd6KiWwfF/oRBdPnV6ptAP1fqTubllEJr5geiT2ULNAldkMc0wVUlu0\nxmHTSYmd3XgN9ledrnokQ6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOI/FREFj2zDR8Rbh\nhn6c12hETVEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCd4IK9Jgbkm+TmrHN6QQs1OF+YgYfLtjVqTk9VzR8aUwIg\nZrVb1mWAdnB7WGpwJGf8Igd/xCfq4pW7ca1Ekl+2iD8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4357", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4357` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISATq31/PcL5TnGUO16eAJjTQQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNTFiYjYwLWI2MjktNDk3Ny05NDFiLTNlMTFmMjUwOGE0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg0MjNhZjItNzdi\nZC00ZWEzLTliMzYtZDFkYTcyMTUxMDllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3s9jr5ldiKOH1iVs9fynOCjAJs9diRuj4xN4E4a6e0gHro3dy/zipdIdm1Qz\nqIdTivGv+9KByQlvrcarcj6MyqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKV5oMtJ9rkGGhibJJRuGtTaPbMkwHwYDVR0j\nBBgwFoAUFGxi6rEVsK+dGfVduvvwsXzMOccwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA7iJbuo\nCHB3II/65j9NZPFDJGtuSlrudNmFF+NKGkrhAiEAyDZGUJMDiwermzkNz800LtbK\n2jqzXBg4elHAULVBE4s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAabh37UrOI3lw0reF+dRe8SZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjUxYmI2MC1iNjI5LTQ5NzctOTQxYi0zZTExZjI1MDhhNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAFL4FkJ3quslDHEt/bVNcn+ZUleH/Uc6xN0D1oY2/6HmE\nokfYSOT4kkaGiQQC9XemSnMRZt1FpRO1yX2U4ULXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFGxi6rEVsK+dGfVduvvwsXzM\nOccwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY8EsMTaqJNtFBRMnwgnCySGUiDnCay3L4rMXfiYvXKgCIQDzLlJv7s+C\nqbeORZ/PRttBtnhmhrCN8+V0umXjL3YTTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATobj1fFWokNPDilKO3szrZWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg0MjNhZjItNzdiZC00ZWEzLTliMzYtZDFkYTcyMTUxMDllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTVkYjY3NjMtNTc1NS00\nMTVlLTlkMDktZDZlMzM4NjgyZGY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/5pRC3NVm7NAVt0vpkgzyCmlZWS3TM3fk8XurvTaGu8f/mSdZTZr85XbcMLnZXMz\nBGo7fcqW0CKw5tDX6oslNKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKV5oMtJ9rkGGhibJ\nJRuGtTaPbMkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDSe1xG7RsIRgGlCit7n/VRbkWZrnf7OeS+crVU+Ln8swIg\nIADVeFIRQysQf46he5Sd2QT8/xB19GoiPYaVi5fCRE4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4358", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4358` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISASqsqr9K1HrEiKvHaJthQGamMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkMzk1YTk2LTgwNDItNGE3My1iMTU3LWQzZTEwZjkxYjY1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA2NjJjYzktNjg5\nMS00ZWNiLWFiODUtNGNkZjY5YWQ5M2M2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPPx63QQ9UFMCdqYkQsHbUvfpGz3HXHPHaQf0EdQ2B9AcVuixzqmZaYPlwkFq\nrt7qEibZ1IuqrpHHIIjttsRcuqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX0PCOnTfDi5pgbKZ52Ja/9rK3zkwHwYDVR0j\nBBgwFoAUwVp2iExmtiLqjX9qiz1CqFbXuxswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIAetKRyGkhBkM47k5f14edd3m8TJRndn8ycgvzm6e2SoAiEA9+AHn14C\nD2x1v+Q1eLqa+m4oK9RcLlMLTkSUj8DTUbA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY97d1RDpTB+9sVLg5zWVVbfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDM5NWE5Ni04MDQyLTRhNzMtYjE1Ny1kM2UxMGY5MWI2NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATn0Mt5C9kI2hOapEgaqzC+rn0rbdUd4pHCoq4ZaC7Wb6Br\nCXXDoPXHhj5rLF5AhCQJNRkZvAQdClKohp07MYivo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwVp2iExmtiLqjX9qiz1CqFbX\nuxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKz7B4lCOTJ6u7RmfHhECmUIVXyrUZPWrJuImAse6sfCAiEAm116aBE8\nPToL+I4QE6vDc4NExQS+KIRdMUqYtD69scE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAZPSdWzc44nCViaCj5fyDcc8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA2NjJjYzktNjg5MS00ZWNiLWFiODUtNGNkZjY5YWQ5M2M2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2EwNTg4MjUtY2Y2Mi00\nN2ZhLWExNmItZjY3MDg4Y2RlZmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nclB4i38K0TYC/jfnebvCNwg6VZbn40jtSzBvE03x+/Vu6sbIwcF3XnJHWJEgyNSP\nZb8ET/EXgMhgjvNGh7fdE6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUX0PCOnTfDi5pgbKZ\n52Ja/9rK3zkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDh8BpCaCMo3wARpldFtsFkrN/ipOUOLWN+3OdnWRPDqQIh\nAJN1qaKIUi5zht3a2DckE2gpJVEkPh6ioFCnjEUhGmZo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4359", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4359` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAeoQ3USof9wAxAjvvNDZIBs5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMDZlY2M0LTRjNDktNDM5OS04MWJlLWIzYTJiNjUyNDRmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ4OTMwNjEtYzQ4\nNi00MzcwLWEzYzItYWRmNDk4OWNmMjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJqZi9+epMWyJgDoiYlD8vd7MVmw3FRzAbPU6G2wDelrnZCy6IGHj6PHNgywQ\nKnslWxpKEjVoYSbxzyhToDSRyKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK7sVsSpKWYCZvNIiDqGDi8rNaZgwHwYDVR0j\nBBgwFoAU6vtRjP4BmiQVreh+Jk7xlgwmPwgwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCuWyjcQ1W60BSAK8rPFgO2tKmXH81pHhcGLrmllQiN+AIhANLwUeN2\ntvOEBOLR2xhVH/5z1tPiUzAZV7YW78rhL2SD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaMcL54SBwOCKcitOG6mthQ+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDA2ZWNjNC00YzQ5LTQzOTktODFiZS1iM2EyYjY1MjQ0ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBpt8XWyeXXHvhQqSEmZWtupcP2LxLE4UyrAhOvlbeGDCF\nmyxNNUhD+j9ou1Sh5Ru6itQYYbZRGD2V5MiBFY3fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6vtRjP4BmiQVreh+Jk7xlgwm\nPwgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ7E3Qk6vc2CPQtG7YKPaRfzmR7XD/45Uc2sKzWB1PvoCIBgpLWCCYDPo\nbxCMPy7ppAJBaRLJSrI5nuZ2xQeS4hnW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAXMVDD7APgecj/Mp162tdAYJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ4OTMwNjEtYzQ4Ni00MzcwLWEzYzItYWRmNDk4OWNmMjg5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2ExMWQwZTAtNDBjNi00\nMTUxLWE0MjMtZDUzOWJjZjNjOWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWbvloDIGaiXpw8wXpkBMeTdMdmqviNtr3z4TPGAmoHsTiYGx0NrMHjvU1yvmSEuR\nPGLJvhbhH4xqgoJXPEaUvKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUK7sVsSpKWYCZvNIi\nDqGDi8rNaZgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIEJU8GHU16FMcRY6fX6O7EKL7PC+HGPZcCMwPSM7j2mTAiBg\nBni8znJ8JVstIV35wvp5qdW2aUZZ9/iM/RqyxQX70Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4360", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4360` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISARtb3qkxJFB2tDr92YRww7+9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZDRhNDlkLWQ1OGItNDcyYi04Mjc2LTg1YzMxYzhjMWQ0ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRjZDkyNmQtZTll\nOS00MDg1LTliZTMtNmRlZDFiYTBmMjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+Ovkqfkr47d/gte49p26v5f6VBHdsa8FWuPeCZ5EUCj+GhgpVEm/naMSKxv9\nGKWUX5xiP7WqoJ/MDvTf0XF17KOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB0E/BZzUeEVCyHbdM5OxN2xAkcIwHwYDVR0j\nBBgwFoAUgYO2VFc3D+YljRWb/6o0GvsdEL4wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIAsPjI+WMsFlza9Rb+FWSDCimMZpXwSAcLNfsHaS/fRBAiA4C6H/pGpmk+Uveg31\n7XsR+xtessne3jJQbEF/tGtLXA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASaB3w/xc1sFzA2+U6OGxib5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmQ0YTQ5ZC1kNThiLTQ3MmItODI3Ni04NWMzMWM4YzFkNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSGORqnticwWl8qxDFHUZRzNoZkhbQOxr5+KtTvoGBpFTl\nudM8wIxejdE1KCb3LgZBG6/zoKhPdbLUxp5RYnhro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgYO2VFc3D+YljRWb/6o0Gvsd\nEL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRLeJHmCCyOyEkRY/PaeL9W2h5SIZPqgzShN9rrE8GEICIC0mpxc3X663\nsgNQ++Sck3ghwAGrOZXNSuM7yvM4PEHA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAcwHqOQ9cce5C4Zgl7zkJjmVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRjZDkyNmQtZTllOS00MDg1LTliZTMtNmRlZDFiYTBmMjIyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzU0NjU5YTMtYjQwOC00\nZDA5LWEzZjEtYTM4MGQ1ODIxN2JhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nntbYhON68ulW21QCOmGFQx2SQUszxgh8zbmK6NhIyZoCzkUIw2Cjq6snZtx0S7XN\ngOAEXgRqvASinCtixD+dVaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUB0E/BZzUeEVCyHbd\nM5OxN2xAkcIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIHlTxiOuYAbsVnarLxtSLs4yOSlq2fu3clgK7PJHTSqyAiAm\nYZDCvx/pPpLoSqGXt28AOlL+GBbQni8+PNcDpa5SzQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4361", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4361` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAc+MManoBM3bY6zqjEQ1WVMkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiZTQ4Y2Y5LTk3MjEtNGZiYy04OGM4LWEwOWM4ZTBmOTRjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNmYzQ4NmYtZGYy\nZC00NTU5LWEzN2YtNzI2M2ViZTUzOGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdkVQ/vvQCN1UdCqo5/ocCSFWvHLZAOqQV9AFT3dTYQ/NFg7329l2TiJDOTB+\npHWOaXC1U7+NYgC8cSyv3riUD6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBSlJKr0y+J5+CM/E6GnkuPGyng8wHwYDVR0j\nBBgwFoAU9VqwnoAx00FTOWeqv0HoHKTZZXAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIBM3RI4vFueQqGZ71IO2WME7+oA84LeAhfZ6Y0rrzdo2AiEA\n08qCro7GjNIVU/BjcHkglaaXenZsDuQJulgMvUZPJvU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVgBLjKGGkUbI/rAhBlnjNYsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmU0OGNmOS05NzIxLTRmYmMtODhjOC1hMDljOGUwZjk0Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFVH5YGru1PifpdyH/Lmy3SM7eYcZqRYyAJFjVnpLaxQXm\nR0ccx/kR1FgNuuWQsFPBlHixwTHflYWc4IDPSGzJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9VqwnoAx00FTOWeqv0HoHKTZ\nZXAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYyb9AmjZb4Hn4pw2ZCM8B629iU3bQ/ZIJrEjRwSVVPYCIFNh+L9swTSr\nvNoU8BrdXsDyc7rT2wDPee4WwTZ/30Vq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWWYsEl25UR7gjPJrk79pKpVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNmYzQ4NmYtZGYyZC00NTU5LWEzN2YtNzI2M2ViZTUzOGEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTE0YWFjZGUtYmYzMi00\nNWNjLThiOWUtNzViMjViNjc1ZDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nX8Gx0utXBfeK4gwz6rpxQ8N+XRsoyiFd3UH7wjL5ef5bheH0Yhn0XYyLcQ31gVql\ncSn0NocFm1JZoR6y2o6WG6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBSlJKr0y+J5+CM/E\n6GnkuPGyng8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDOrZlcT3+oUC35W+5jm/d1D2SJVyo9qwHWLBUeiZ48qQIg\nIm1Ls1Rbn5SXRXOLoyc9cxHngBSk66FOk3cu7NOe11k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4362", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4362` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAaNdfykrylGNjAXVWjuwS0MmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYjMxOGYyLTk3OTktNGQ1OS04YTI2LTQzNjU2ZjNiNTEyZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDAwODg4M2YtNWNl\nYy00YzdmLTg5NzQtMDBkNjcyMjA4NjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvWayM/feKHhwR/gUmBvxSbRGIfgb7K8l2XiHCcwH1sF0LFwspiweeMBCyI1W\nadS5lRKsZgbOokM09TVZqtcu/qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB3wmOkXXUORzwgUQx6ycrlLZQM8wHwYDVR0j\nBBgwFoAUjvIpO9pGEOF+vA9mqpptUwcBGtUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIDpZARphBeex6YqO0MqNsl6hxWxU8nPWXoCxFkks2xoaAiEA\n9aooqXDVIk6PRcTA0YfUjH7tqxsLUH+UG5cW0+RgMD8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa7+NxIc4lnb7F/9aKG0jA6eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmIzMThmMi05Nzk5LTRkNTktOGEyNi00MzY1NmYzYjUxMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAmu7LLTVBbucJMv1Th7jTTiGuJJitGmGMWm18n1kXZnvP\n92XCsWL3g7sn9GyHN5/wWh1qPnFpE/CPTicz04zpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjvIpO9pGEOF+vA9mqpptUwcB\nGtUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgarW3dE1tX+Cs1Ti2Ar9n6XY1x9y92zz+T1DkHINgC78CIQD3flShZ4ZA\n8CadNdn2ttjxoZNzusQnwXS81xPxmo+mQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAYrieA3hUWpAOXxsle40h6q9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDAwODg4M2YtNWNlYy00YzdmLTg5NzQtMDBkNjcyMjA4NjkzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzk5YmIxNTEtOTljYS00\nNTdjLThiZTItNTUxMTRmNjM1YWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFprPKAbAcYaFmG4xvS66gr9zogVD/rkI8MjNHGgG8vDBjmfgTaVMQH+VpKD4sekp\nEO/S55Xm9hrSMdSALHII1KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUB3wmOkXXUORzwgUQ\nx6ycrlLZQM8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIE12GzGdhHBmcgv5KIvqv38hoPemuXj9pbDGwztewWxEAiEA\nxj8EoK2DO3D+XwzlUgqMvCg8CCZuXCzt00qd0+RVjkI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4363", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4363` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAQ3LPZm3NwARiKGp2C9ogw7BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MmRkMWY3LTY2Y2YtNGJjNi1iNDAzLWRhZDdjYWNlNDlmMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNmNTZmN2YtZGJh\nZi00ZTkyLWI5NzQtZmZjOWY3Y2RlYjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESlnBwbwK3JjVmjJaQoUskcBkXz6WPpJBnfkco9LpmqY3nrsDfVxgjNGEYMnP\nA4ba87ih5I6wFRrRrDfu54fmqKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGbiT8Ae7iRkRoalXqDWt5BJjzXswHwYDVR0j\nBBgwFoAUIX+aE/Bl5zKeJ/hXmmzbmVqemWMwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCt/i/I0rfd\nFPXK2X+dFUKoSJMXyQ0RJSkEN/RV12teNAIhANFghnEQMY53JeuxHVn497VYYfLj\nZ9IF7CtbcPv0C664\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ1pQsG1BtXoQLx5DbmdrazVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzJkZDFmNy02NmNmLTRiYzYtYjQwMy1kYWQ3Y2FjZTQ5ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOLoJLEZQ8JQdqUUN5PMFvQ8TC4Io7uUVJXnO1pBHOACmw\n41ZQmLLUi9o1txASnwIudhPNWqJqWa0XvajAWMrro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIX+aE/Bl5zKeJ/hXmmzbmVqe\nmWMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcx1BzzNQJ/WHktvMbxajKVibAGphrkHiOIWG+zCLPRMCIDhBNrUl396J\n5Ig644WgSttCSpVp+Nnn1LiE0OFiVVjR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATeVXQhEHykLfTNIUXHpZGloMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNmNTZmN2YtZGJhZi00ZTkyLWI5NzQtZmZjOWY3Y2RlYjdkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzFmMjE1MzAtOTc5MS00\nYjFhLWI4ZjQtNWVmMTgwNmY1Y2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkUMXhL3W9UM5aAy2gEigG/kh3GLXJrf3sMKj0l6u9j5X+DHqycPAlWYkTAXZ0jA7\nCfHfnMXuVbr32+enJWaitqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGbiT8Ae7iRkRoalX\nqDWt5BJjzXswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIDAleQnfJL8B1eHV9jJNiJtKK3qmMEPxoCN4VJRulhrJAiEA\n8LqrKBhNDIlD1UV0k+jYB3gJHQS4SaxozyCJk1atVEk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4364", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4364` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAez0Xlse4yGFfiLABFPe5UevMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5MzEwNDA4LTkyNjgtNDc1MC1iNzY5LTY4MTY1NDk3OGMyMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVmMzJiYTItYTg0\nNy00MDQ2LWFjNjgtMzY0MTViOWQ4MzFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhkuNKnuWaX5UHx2o+J90UYNFqt3DjN4NLUcHmu9UI1vEbEzz8jtWxAss70KK\nyPAUjkDd44d/3EFWxagXYnvUSaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1dsZPb+Cnwgpz+n3w1b+FqHazHcwHwYDVR0j\nBBgwFoAUxHdwox/guLfccBO0dc3SMk1tYcwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAMIbQ3zv6ie0XAwM5YzypKcQFk3QZgDTyO7ugP6ijQCQAiEAg9okwR2Q\nGE5GN2kwaFBJP+usqnX6EzHeWaoptPzQ1mk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbhOLvJcOTlAXpAkQgnZZQClMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTMxMDQwOC05MjY4LTQ3NTAtYjc2OS02ODE2NTQ5NzhjMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaHbwUOme6F82ub3VjloZpXNC16ttiVyx6k+SWI1c7M7PJ\n9aF0h9ONISExE8SodamTURtnMsE7CyuGvsxnwlyzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxHdwox/guLfccBO0dc3SMk1t\nYcwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMLyw4T2zR3LjyA6CRnTfSkTatGFLb8b1vSrY9XsFnNcCIHmi9i2VyZ7X\nkFwHikV8HzLq88yuOtJvzFSYxjJFImQ7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISARntbItGv2WZPag3Pj5JNSOUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVmMzJiYTItYTg0Ny00MDQ2LWFjNjgtMzY0MTViOWQ4MzFmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzZkY2Q1YTEtZjMwZC00\nMDVmLThjYzMtMGRkZGMxYWQ1M2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1jrxlcVm4yvw9l1cxYX4Cm3RHoTqXVGLdD/24LAiGiTqvFB50klqeSkgYWwAq0qr\nQjukWhNMuuVdLiVedSh+X6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1dsZPb+Cnwgpz+n3\nw1b+FqHazHcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCILMYokCsghlPpnJzvyNqSLhO4JfHLnwI0XUf/6SRNWwIh\nAIBc9PAJdAt1y9wBMT/X8QGgLMSujFWW7sSKkU7jnkbJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4365", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4365` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQWIspd8nLLPFl7oUQAbiuVqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNmVlMDRiLWRhNGYtNGFhYS04ZjYzLWMxMTZkYWFjZjY4ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc1NzNhMzUtNTI1\nNy00ZjkzLTk0MzAtNjk0MWNkNmJmZmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsq5BmV+JnVvcQuBWKmdv8UZw0VFKLanEhn8/F3+uz0MV2wWCPgVvsvXNxKLl\nm9ec/QYc1C9BJoK9wmN29G+5oaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOlbpDvfGctjCu1e9bfa7gqcUtK8wHwYDVR0j\nBBgwFoAUwzdCI3hfsb5Z+Ff1I/4D50bmp8IwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAMUuYdDp41T3VGL67YdbwCwgMjFTmJGiv+nqQJ9ZCTGRAiEAiQD+jIGs\nJyrTw9n/uthr/RSUseVeE+96vneHWgM0N9A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfx1pFVYBWc0mNNXc5gE8/YJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTZlZTA0Yi1kYTRmLTRhYWEtOGY2My1jMTE2ZGFhY2Y2ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdKsNuePyM9PupwX9p4P2DHPe5r2nxGl8agwTyQu31aMYH\nBNnPGIvAZGa3t1XsxRMq6CIcYEWG3CvoUtpOv0sHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwzdCI3hfsb5Z+Ff1I/4D50bm\np8IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALM3a/6ljJ/C4r3IyEcsJJzv8Rquyh9rujXZZoNJGL6BAiAbdUHkBXAK\n2+XN0OV4Dx6a1DlZvujtVpSvZM898hMetQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISASv+I4ZfB5elC39ScheBrig/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc1NzNhMzUtNTI1Ny00ZjkzLTk0MzAtNjk0MWNkNmJmZmNmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTRiNzRkNmMtY2UyOS00\nMjQxLTk0N2YtMzYyMmVjNTM2NzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBjpaG7fP+VdGCfEfwpBGeufmuk3ey3vHXvrmvoN1Ac499T/FZJ6FzZAOBHKUfu69\n4JTA1ezSqI8KCcCylvpFs6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOlbpDvfGctjCu1e9\nbfa7gqcUtK8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCgmNGshDX8MM1QK1sL9T3m/24vynd/uOFZaiNV/9v+iQIg\nK9IcufiQ3nT+Tl57r5a6Qt9VtvhzcEQSekyHEkbKr6Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4366", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4366` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISARCeH7VaH1d1KoHcpFQmUqLlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjZjQ0YjlkLTcwYzItNDZlMC1hYjdlLThmOTk0ODFjODM4ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDUxNTcyZDItNjU3\nNS00MjBkLWE3YWUtNmZmM2E2ODIyNWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz3HHSfrG/touYFi7LZu/xE50rpt33CuFcupCgKUfGiD6NT3d/07DlyD05pNC\nZrim5QfSmqj2Hb5AWAp5d2VWEqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmrYpqSK3yfcS2RSD/kj5kb0IeJMwHwYDVR0j\nBBgwFoAU1FGKHFosr4ebECf3sYErV90ZchswOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDhidrIK6a2J4XA2g9YEFj+bLHnbrYxj7EV3edlidHzCwIhAJ8k6pFj\nBDndlcvR3cKq0GC6Qtb9TNqkDdmyhRFn+nEV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcJ1eKUw0bSMa50X1AAKYafXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nY2Y0NGI5ZC03MGMyLTQ2ZTAtYWI3ZS04Zjk5NDgxYzgzOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmxoiaeJLOrNDk4I4lOAJSGoSZc6TGbDFFGr1r2/i4MMy0\nomBMrkKJw4FMFa+JOLiyI/KAGq6kBFrbf3CQC7xGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1FGKHFosr4ebECf3sYErV90Z\nchswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ7vZsLQhUc/Dic3+znaJj1SfruZ3HSaxirj4iQIt/0IAiA+duurnSR8\nIgb5zAhKV/c4rfsSdM3TFN/wTMuP8YVTcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAZkttYa3tsqK2VFBwfqDQLQ/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDUxNTcyZDItNjU3NS00MjBkLWE3YWUtNmZmM2E2ODIyNWUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmY1OGIyYmMtYTk0OS00\nMWVlLThlZmItMmFkMzk3NDY3ZjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKSh8TGHTH0V21zd3SU0d7cE+7aaoNHEpSoawHPlw5qvCwMN2po2AF+S4pDRjMuAw\n/dhPOiBXP9CqdFhHRTai86N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmrYpqSK3yfcS2RSD\n/kj5kb0IeJMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIHIhI3p+FMNh4NjBw+n1A52kjDvyViUoC/FbThtRMh8bAiBG\nYU4WGNYYtisohQTwWAC+SJLkD8IQ5MT/2M5tcOse5Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4367", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4367` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAc4/GmIlppIJRjPF0Pwa46V4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5ODVlMzY3LTg4ODEtNDA0Ni1hNzljLWVjOWJhNTZhMTNjZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzAxZTI4MjAtNDcx\nYy00MGU0LTgyZmMtMzQ0NGIxNDVhY2ZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr2GQfh8tTlcFoJ/iCz0XhANsPNQoemX45+FFTWVi5/fRqxsorxmjwsJcprVF\nIrXH7JusNbgdQ+80cXoGBTmZHqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi10OXcK8QVEfJl93e0ZRRCZj2VUwHwYDVR0j\nBBgwFoAUF1PcjXM+zuHA/R9tubddOd863hcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCqIlqchZjMNz6wUsZeLJHsvZriZ0x6C9fQ9eCo\nnBb0NQIhAK/jntaW1D6NzptQyqx45KUajzDyh1UzLe4B9rrNcG3B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcDLfNQPC75mt6I+XSTHrNq0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTg1ZTM2Ny04ODgxLTQwNDYtYTc5Yy1lYzliYTU2YTEzY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQT3nk82eDur5lPzqZQNc9iggX+fQw1RmlnXqLPSYnzotEP\nkSMFCXQwo/46ngR8Aw755ru59+jya15OMSbXxLBjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF1PcjXM+zuHA/R9tubddOd86\n3hcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOH0U5tewMeksPCFVIej1aXFVTcoP7CSWGBfgPIU+kyAAiEAimNc5Pzc\nutkWWoMiWWvAXpT5xef6dvrqS6Nt0mk3BEY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWQJw2bCt7JaBkgL04qrWrYRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzAxZTI4MjAtNDcxYy00MGU0LTgyZmMtMzQ0NGIxNDVhY2ZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmM4NjY4MzEtNjhlZC00\nMjk0LWEwYzYtYjI4NDkzNTU5ZTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncYd5f9UQeZSGoezgs6jNA545Qm8cuiSvBHgwKwtijp9tXlTD2v9rGdVSgSblZxnM\nWmCHE54ZG5Tm9k12Kgi98aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUi10OXcK8QVEfJl93\ne0ZRRCZj2VUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIGi07EtS7MpviM64SPpPFK3/pY74Jr7q4hRTX0rFwgT0AiEA\n6Dc9yVNGnROfo1ZPm9t3cPSS0DwYGaWxQlgIrUO+uj8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4368", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4368` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZhe6STCqDXXEmf9lTL98xhdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2OWIxZDIzLTRhY2EtNDhkZS05ZmExLTBiYjcxY2NmNGZmNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVmODM4Y2ItNzli\nMC00Y2MyLWJhZTYtOTk4Mzg5OWI2ZDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr5SjzWc7sw+YqaQO3RXLmHRsigMBW+R0+9pTNZnv0H8yTTUmr9Ub6bX4KGaZ\nkO+KM9SPqeInruMFH/po3I6cRKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcyR1ljPbAKdttJvkUWL6wyQIuDowHwYDVR0j\nBBgwFoAUrdVLLGqNqzeUnt00epylt55WBjowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHyumUuCMIAc/QsgcEQzE81Rs9ZpIwMKaApAwwYl\niCW/AiEA0cXAa1Dmp2gJdVRFbgC+yUYMJik5Y7qATIGUk9cDtWU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVhCNs87gky6xSWUdivRBsMaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjliMWQyMy00YWNhLTQ4ZGUtOWZhMS0wYmI3MWNjZjRmZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXD4N3B2YzivRGIj+JVk3YPajTcROLWZpW0AKxGFziePA/\nAy5uq5XWQjIBSwJLjHw5CZVxrUDAwv79Br7VoR0io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrdVLLGqNqzeUnt00epylt55W\nBjowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMIiwpiXzMyCGEtmNlfhbjzJYgW1+v91mcYVxvHHUAtzAiAgAiakjair\nYKegkop2rgDp/VS7LbB0m3yx4Dg2dDH/LQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAQNRqcIBn29kVQxO1yhhuP6QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVmODM4Y2ItNzliMC00Y2MyLWJhZTYtOTk4Mzg5OWI2ZDYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjMyMzRiNjgtNWJmYi00\nNDYzLWE2N2UtNGU5MWRlNGM3NDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0JpeK0fwJbfLYk5AYMQfZc5i3/eQpfzvS1vwmr6pjbKBdkT902DHmZLKet1WMggr\nglUrABvfIaqgxDBqvY90nKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcyR1ljPbAKdttJvk\nUWL6wyQIuDowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIGbbgImjwr/k/1SlwgwWkHFi3Kxn4fhLlYjRm1EH65B4AiAh\nK9YPEHoSG413Zl947Na+griS9o7WY0/ZBtcCpOl2GA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4369", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4369` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAcf9Jndh7wvb9eVUqaXyfGc1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4MDM4YTczLWQxZWMtNDEzZS04YWZmLWYxYzg5Njk4ZTRmNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJjNDc3OTUtYmYw\nMy00MjBjLTgzY2UtYmMzNDBmNjczYjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY2x6lwUyMthPx+2ROb3b1WsIlGYUlbhkROlhKrgMx9A0pR9AeTqOYtdTw0oi\nNLXkqDA8NeecccyUaO9pvQUUb6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV1MWsnrVhkdoeZahMoeQTxaWwscwHwYDVR0j\nBBgwFoAUP+0prLgxSv0NqlHASiRCaSuFJZcwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIC27/tKAECDba6NPT1OVXiH5OlzlEnSipC5iR88wNd1eAiBY\ngY7x45eavgkLTJS7RjxYyMPLthwK01M/XsS6q0RDDQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATW4oGQ5kMPgxbwN7D2m6QvQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODAzOGE3My1kMWVjLTQxM2UtOGFmZi1mMWM4OTY5OGU0ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjrSwcQqDbTmWwW6lg1ne7s53SxuGfcu3S5kVs/5EPb5aD\neVx0opF8Zoolmye8Sb6xQNMCQ2wrbnRvSPJxnoexo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP+0prLgxSv0NqlHASiRCaSuF\nJZcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC4zQ52szd8cLbngJkfAL8U3UI4ZYHYA97pZCbCKt3zACIBEPq9I7oghy\n3Y/ioyFTvnXXU3NC+tHe/JOYFrOWpbOA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAeAbW8GVJOln2SW0ow2oq9RnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJjNDc3OTUtYmYwMy00MjBjLTgzY2UtYmMzNDBmNjczYjk3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2NlY2Y4MjEtNWQwZC00\nZDVhLWI3MDAtMGQwMDk1MTZlM2VjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXiRWqngzdGuFR+/mxyW2JTZrEH3VXTk35IDJzkWmbJXkwEX4sxIiYdVQtlNO2U5r\nTIaF5gGMxPZFYQSht0YjOKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUV1MWsnrVhkdoeZah\nMoeQTxaWwscwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIEnjlu6Bg+rHeo1XVG7EV8+y6WNPCzXNTErolppHIHkGAiEA\nmktHMbwrqoFfhijo90rMWSxfnUGSGRnDw4eMd1g5TuI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4370", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4370` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAaWw2h9a61EZ1nA5bNfpKVf1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmYzczNmEyLTQzMzAtNDM0Zi1hNTMwLTAxYmY3MjYyODliYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY4YjFlMmUtOTE2\nOS00NDA5LWEzODYtYjQ1ZTRiZTgxY2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENlbqUFdOhpoDfKRjOPp65j5L6m2XPGCR1jG1qeDGW6pOC90IbcQZM8Tt1cT4\nBj3FeNdKY+FWz4Lv1Rn/D9lo2aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG7jj0Z39YK67cu3ECK+9czK5zOUwHwYDVR0j\nBBgwFoAU9ZS/ykPPfZ1xoD3W/WAI+p6mtyEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGF6abk4pN0LFtn3M/ePVKjNFFr/QoVW\n2a5aKM3V5SLTAiAS3JfWxmc/VTMCmBM7yzRtm5S5GJ5n6h/UBveSPblBuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUXUV3hCbkmGxgln1nLcBalPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmM3MzZhMi00MzMwLTQzNGYtYTUzMC0wMWJmNzI2Mjg5YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaeEjx1b3NZ6Bcjw/1DMqBozW70xA5l5Z6leGtM/sPsds9\nxNARhDD5CNSMHImpIBJAZhGV3uS9qvGWfQtnCOf1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ZS/ykPPfZ1xoD3W/WAI+p6m\ntyEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANwY1tRSyJDJzedxfuJ6K2iKZBaj+f6hZdRks8pb3xExAiAfgovnGC6o\nOINIxEHp17tt0rqnxeBfYH11SOey7yVuIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAf/UdjEzCBC0TowFy9RgCUJPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY4YjFlMmUtOTE2OS00NDA5LWEzODYtYjQ1ZTRiZTgxY2Q4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTcxNzYxNjQtY2EyNy00\nZjJmLWJkYWQtYWQ0NTFlNWNhMTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMUN7M1P9mfmbKsI0Iczs3qXR5FgGqu8V9OjT4puSOmhLYUVf6fg4PNjp8ZAvl7ia\niAdDbviLrTjodOcaFKEbXqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUG7jj0Z39YK67cu3E\nCK+9czK5zOUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIGEkzaJnBXPqmUAh6nBkGBkvBSVxEXimXKpc5v+z3lcoAiAf\nLXNXnGq3ZQH4pA02N843FFpUH/i9YQZD4mMJszvN+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4371", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4371` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAdRdd5RH5l5WK/vj8MLo61VJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhNDA1YjBmLTYwZTEtNGYwMS05YTkxLTg5MTdmNWRkNzJlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdlNmViMTYtOTY3\nOS00YmJmLWExM2ItMTFlN2QwYjUxYWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPXzUZL0RVgog/VLOOopm+cY5RKHXMNMLeY/dTNPZa+RddV3X1Yl4AWJ2cBEH\nJeWBIrGDf6t3FLe6xTe7fi4eIKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwyjARMY8nCMlwhz+FrzuFLFpaTgwHwYDVR0j\nBBgwFoAUDR4ZFZdPQQkDcHM/O8rRFOEGeiQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC7LepwAsUIPwbd+Y7RE8nr2kl8xjw8\nl2czSXFaXY+uXwIhAOxT01N91UCwBky11lup+QijUtLGssjNaCLT6+vfYW/e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYNa1cHQToMkERO+sa/zmOBkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTQwNWIwZi02MGUxLTRmMDEtOWE5MS04OTE3ZjVkZDcyZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgIUUSbND6x/TN5owBGtLoJzXhYARKrezt8ltLEVn81HD8\neo/sDLQbCIksgmJCQfTD5yvGqihpmE+uKMFeHa/fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDR4ZFZdPQQkDcHM/O8rRFOEG\neiQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOA0ZSVgbMM+HkFyDwMJ6jg0sULW/LHSu6/dHvF+shHPAiAhwPOKMAEc\nk1ET+dTrFZT3SV7nnu2Jr7dAb9oRimXh4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAR8/2asCiDK86NfD2pcZd+lUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdlNmViMTYtOTY3OS00YmJmLWExM2ItMTFlN2QwYjUxYWYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDc0NmI5Y2UtYzQ5Mi00\nOGRkLWEwYTktZDI0MDIxYmQ4NjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nIJqhK87lF0AoYl3THgV/qmXOgieTKNKKysZ1BDpzS0MyLz7XhnJnBqIeoLkgKiSG\nNpACX4gr5ovmxdENuvvW1aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwyjARMY8nCMlwhz+\nFrzuFLFpaTgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQD+XQYXBuF+WjIrYfNkC6EOwaW0UKc7WCg5JoXzKbWdSQIh\nAJqHgukp1Cqmc6oy+AM73SYh9HxtkHcW+hO+qH8WhQ69\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4372", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4372` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATkODi4zTPX52X40mcdJeXzDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzZTk3MmUwLWE3MDktNGU2MC05YzEzLWM3NjRkN2FhOWY3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q2M2ZkYTgtYmEw\nOS00MDc1LTk5OGYtY2QzMGEzN2E1ZjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzpft6etd6MmUbaLyqnONA52F6D1tI6aMu894pSCWXqrY4H5UJXPjbrSJvGoz\net6qGHbydjQWRz9BDCaC6IVp7KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM+GhYJRI/ZM73zcM/RLQCds5vXowHwYDVR0j\nBBgwFoAUMfLvpzAC8NHTp8gR9T8Rp6twlOAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCM1Qu2x7yO\n4CSTdAqSxMvuSY457HyUGbV7nc8UTFwUcwIgV1JvWs9qc5k78ThNtWvdUd2hXGt5\nwP7XFoq0i6OGIQc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWIOfUoF+SQXeTamys+PsHSFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2U5NzJlMC1hNzA5LTRlNjAtOWMxMy1jNzY0ZDdhYTlmNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMv0LZ5O4+MnuMihF/3lujFCUDapEuvDxIZW3mljV/zJnu\nzNi8Y4EB2bjjlwfLjtcZfQlhN4mvXzL1VHcA7fRyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMfLvpzAC8NHTp8gR9T8Rp6tw\nlOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJpW6zCiqiUAKPnFTutkuu0QXnVWqQUOO1uySx/OKMhFAiEAvqhQUPcX\noJZITtiamJULCWUx8vPTUvqrPd+0LUKNMR4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXLiLeF/2chThbEkCj0YEHyJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q2M2ZkYTgtYmEwOS00MDc1LTk5OGYtY2QzMGEzN2E1ZjRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjNkN2IxYTItYjZkZS00\nYWQ4LThlZGUtMmMyZDU2ZTQwYWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJtkuD8nHHKkqG4W88gQPQBo2FUcOV/cSBjVzIEac7MQK9NLyDjduY0bq7bhYJeou\nTYY187z+f7qQHV5hLxuDAKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUM+GhYJRI/ZM73zcM\n/RLQCds5vXowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIF6CZfiIRE0YbQJlOKrKflwGobvH/8up8Sl48j12KTkWAiEA\n+py0C7n0OCWjYIG54c/fLuTOVQt1VhieL4SlQWXXO/c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4373", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4373` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISASyRGcHWEeFXsj8dlD9GcyFNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NDQ2OTY3LWJkYzgtNDQxNy05Zjg2LWEyOWViN2Q4ZGUyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIzM2YzNTktMGRh\nMS00NDY5LTg2NjAtMmQ2YTA2M2QzYmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwnmDIcCW6x/6ctzbQbWzXDhgXM3aQ6wEJWwnqF5T62SGG4vnSKCyp28dsNEN\nneS4Au0o6z7Vqe5t+qHjnJPFyqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxAQ4NEldjJd+2h4rb469a1rLJEswHwYDVR0j\nBBgwFoAUs1r7/K7jXJpKzfm2j9TatdnEG9UwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgW25g8nM2Qi3k3RpMFdTu8EHxix6G7VkYHyhkMK7cQZECIFmJ/EeAVrk6\nzfd56g+SOzx0XNBCz1RKUkRW+qV1l2oy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYWH0kbUY2W4pFYfoVTshw6jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjQ0Njk2Ny1iZGM4LTQ0MTctOWY4Ni1hMjllYjdkOGRlMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQh4UOEvE9SUNHshVkB1TSC4mbdQXGMKpqZliiQ8im4QYpS\nLDz2Wckvy3dZ/qTd2PoE6bQGtx870pdn0M3bdGdeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs1r7/K7jXJpKzfm2j9TatdnE\nG9UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIlZmmNAS926iLWoCn/WjXVIaduDvgpK83+2YJ2O5A+ECIQCKL/dJ5Ss8\nPHKwrcTyxxFL80/fcJgDPYHF7OY+QCqhBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQ1B1rD7TKnlQ7eMKRUZNNuiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIzM2YzNTktMGRhMS00NDY5LTg2NjAtMmQ2YTA2M2QzYmEyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTA1OGMwMTYtMDliZS00\nYzM3LThkNGItNDA1OWQ2MWU4NjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFMzKz6VXZMohoZgVplzc0WqdPiOHqQ5Xu1RtT8J5Z7paL+z/cuRDt032lRXsJnWf\ncFAttuqxlcMkL3Cl45Tdm6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxAQ4NEldjJd+2h4r\nb469a1rLJEswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDrdMmEHq/JBW3pYhzF57d0CNSyxticnqbGTQVpPI2ElgIg\nBEUjeWEOgJ770ivDR4eoPpNGesWZ4ayaMKHqFjBLCLU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4374", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4374` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAXomFitlnL0N3CRzhMDVhJqiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxYThlNDgxLTY5NTQtNDM0ZC04NDYyLWM0NDM4ODBjMDI2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGRiOGJkYmItYzFi\nMS00Yjc0LWJkNDYtMjllMjFhZjdjZjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKPiQ9m2o2glTXSmAjxl33fo138oo4BsbKNlc441Y30Wrdx4PNFGO0pIlXp7g\nnw7fzskLIqANBxfPUG9JhSMR7qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Jno6ZCSLx4XrK1n1FW2qEspCb4wHwYDVR0j\nBBgwFoAUE9EHbe5Dbu8Laq6CuD3X8Et6aOwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgKfKzZTI9oFdqDnKRgMg94vNoxFhVx2zRY0xXrdCjNN4CIBFY7bONvC/+\nbx2xqxx4ebvOweO38BacGYbKZ5k5t5cJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARAOdI/LSyUYVAH3jsA7bHnZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWE4ZTQ4MS02OTU0LTQzNGQtODQ2Mi1jNDQzODgwYzAyNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSTss7LQdOvyngrsmvuXH0E0oF5PX3B4FYPMK0/QeqOfK6\nzv9Rdn2Ia64lYCvhEQex7V7hLHkZWKhCBBRVwR2Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE9EHbe5Dbu8Laq6CuD3X8Et6\naOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI48ZH8eNBcpek0k3RgHj6WXNmDfMqSDnhrrDC6iUIg8AiAqeYyz/lm5\nitrhblgORdb9pC9ejugMkd1XGBnfT6WfBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAd4h3zgDgjED62M7tVgd9uy5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGRiOGJkYmItYzFiMS00Yjc0LWJkNDYtMjllMjFhZjdjZjUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTE2MWRhODUtNmMzNi00\nYjEzLWIxODEtNDk4NThkNjcyMWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+BT37T6m05RFYHu/WLMsB6ErWu8VZayXZxuj+ccR+OGOb8imvKDrGopRDu3QwxFV\n3aZxi+s+fHYkNJHdZXpWMaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5Jno6ZCSLx4XrK1n\n1FW2qEspCb4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIF/SWYLwAlmJsWeXuxz5qK1v+QR1cx3wAws4MG7qrdeRAiEA\n1SUycUGHNvrlQpymqPeIAYj4OYEK2AnkoRU5qLV6Qwc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4375", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4375` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISATiFzPfz6M7J9ZxQ6wKye72TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMThmNzMzLTE0ODUtNDFiYi05NDZmLTQ3NGE1OTlhZDA1MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUyOTlkNjAtOWVh\nMi00OTg5LTlhYmEtYTUwYjY1NzEyMmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESjPeB/gZaTy/u4G3ARRdSI6cZirxWNUpF1kT7ozl6R3fRmaC8NhbjZElrhdp\n9fk4PTObuuj47PFWtz4l8lA1jKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqLnM5ak16h/dnlyYuxGu8I9ZYucwHwYDVR0j\nBBgwFoAUs9Ia+70nJfjvvhyO2aPeoEhGqckwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIDJI3qn1mhiexO1dfqh2PsyFaagphLkq4Hv0dipmbqy5AiEAqXvLT4/l\nENKo1zygAa0w9KfaPZv++ttgTPHMHr6vNJc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQxDgNIuKG4F6Fa6vYqu0JnZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTE4ZjczMy0xNDg1LTQxYmItOTQ2Zi00NzRhNTk5YWQwNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8dkICo1us6izLS1mPHAB/tB7aYTVAwUCOcAjJN5uxoqt0\nChoR9OwWnYcfDAOdsxlYARpkGrzHCx5jrfQPSAVKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs9Ia+70nJfjvvhyO2aPeoEhG\nqckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK9gYtmbkWuQrvrbbhQBiBfvwMydmiTwxwJUGaKDPisXAiA0sfz0YRZ3\nZXjxUUQ8sFLKUUZNAXXKNgY8bP3WRlogvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAeCCg1a7LeM6/2116S8g0V4+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUyOTlkNjAtOWVhMi00OTg5LTlhYmEtYTUwYjY1NzEyMmMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmZmMDQzNGYtYTdhOC00\nZDkyLWIwZWEtYWRmYzY2ZmIwZWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngjwi796Xvys4msBsguq+XzY9lUKsnnPLZp12jrWfJFOYdHcbQ72SZXEAnpvZGmzx\nbpeQ6n4Sgv+XwhJ/Lmt5X6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqLnM5ak16h/dnlyY\nuxGu8I9ZYucwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDf6aWBfKYMOQXl2fEj+aTSsUiJj0tPl53ajv0vXfQJxwIg\nZtMxUsjLkC/ZkZHFcij7Sw1CF1+Y7WmGI3izhCD6opg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4376", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4376` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAdy+erDDmf5XkgInB2jW8CWmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3MDI2ZDE5LTU1YjYtNDRhZi04NjBjLWQ3MWI3ZDAxYzg1YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFjM2VlNjAtMTRm\nYy00OTU3LWE0OTMtZmZmNWNiMTE4YzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf/ao/h9x+Vj5tdfhvUair75SbPfjn11UxpYvB2AwS9L7BUF0roIKzwcc287Z\nHi95z4uS6tQ7cwzch/aNSTwNnKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPn31+dZ8nlVySptZWd4hHmidhkgwHwYDVR0j\nBBgwFoAUEnx7+VgCTZJVU+xnv4aTL09epOMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBi3AEp44hAo+/BQoKS3mQEoieCWvu6EYbIsy900\n1FEKAiAjllwlJUpdesKDFenItag0trCRmI6EoNDgc/sGVDdjXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW+4POA12ast2q2E9oCTncxBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzAyNmQxOS01NWI2LTQ0YWYtODYwYy1kNzFiN2QwMWM4NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQplJRRdu+16aUfIONYMRLsk2vvgbdD/TLFuQmCyi9p/n3d\nQZQq98NIu74AZwGbBkKKeeiS72ymxbMdB3KbkX8Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEnx7+VgCTZJVU+xnv4aTL09e\npOMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANry4LO3Mi+7H3PcThQhWwiqrOQoKPk2yKrbFZDwhOQDAiASYyAohThA\n4pi8qLfF038FeNndoHvvLkmlF5sowK08SA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAV/Xv7oLAwa1gp62mOuDBJnSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFjM2VlNjAtMTRmYy00OTU3LWE0OTMtZmZmNWNiMTE4YzA5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGIwNTlmNDktYjkxOC00\nYTFhLTgwMTctNDczNzcwNzQ5MDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntk9jLofgUOGw8ZfMyJ31sBs+xb7O+Kw1ZQyO7ot7MZOjPgLwwVh1uHrDD+5DCOVs\nZkqmUV+jplvu2i5dKI0p5aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPn31+dZ8nlVySptZ\nWd4hHmidhkgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDXv0r5Q+Qi6nkCUIGuneyjPB0sVBhziEhz5HQlpSnzQQIh\nAMn90bU2+wM1+p8OVtnrytbvcJQ93EFtqcA9Hr0Wb0Gr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4377", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4377` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAZUSYPKlcECJZzcSHg/njvvUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMDYwM2RlLWZkNzYtNDgwZi05ODc0LTNiMjA3ZDA2ZThiZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc0M2ViYTgtOTg4\nMy00ZGJlLTk2YzItNGIwMTA2ODEyM2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkgaJIrsiRXXTo0j3mYkYN7FH4NBNhZIiw5CCntGbska8WKh6psFgQFvrHc8T\n9lsoehxqmxmInOk6OUqZcCHlLKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUesrEXmFQVUJ93W8hi+ERAvuJZcMwHwYDVR0j\nBBgwFoAUm4VAvHKivAa4i+RU+91XTpU73ocwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIHBBbUJnxxVODy8v6bFiokb/PKV0S37AnZNM50T4\n2hD0AiAquVyxkl0CwbmSmCrT1kXY4+0LG6PMG8m/aXLsPqyKIw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASdtS1Zaax8VUTuW4zuIwYQ0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDA2MDNkZS1mZDc2LTQ4MGYtOTg3NC0zYjIwN2QwNmU4YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzvoGeadrtHJmSh6RsbyA5Wa1gttdaLAg7e218WUkHTUWc\nYN8yqF5NY8Mstleca1hwTTHyzOcaBFaG98dk0DOTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm4VAvHKivAa4i+RU+91XTpU7\n3ocwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUvKap/jFczsIBMu5k2eD5feW76ZQzHa18By51CQl8TYCIQD0VVz8JwsA\n8anvvqrIDCM0Zi2DMbWUzaxGzf7WtosESg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfO/G6Oiicl7qCdEi/EbcP6rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc0M2ViYTgtOTg4My00ZGJlLTk2YzItNGIwMTA2ODEyM2I0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzFmZmVkODMtZjhkMS00\nNzgwLWIzNWYtZmFhNzYxOGNiYTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOImVye0SYq9wHGHCPJhyLW8VroDoEHSi9ZvfkCrgVBl7fJPW4nHVImx1NceETzrI\n2/J2muVHuWL7E04O3/pOUqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUesrEXmFQVUJ93W8h\ni+ERAvuJZcMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIG1irzP2zY9MxPoZaXoeTk+/dgdPD0Wg3IKXwANC4FBDAiEA\nzbttWeQgUygwUXTfHrrntt5IaNoiQzv9MiPVSFaJFsM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4378", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4378` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAb5ChUW2dfehXnjI/liKEUQ2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjZTBmMmRhLTQyZTItNDhjMC05M2U3LWI0MDg2NmVjMTg5MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDAzZGUyM2EtYjk1\nNi00ZTQ5LWIxNzgtODc5OGI3OWZlNGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW/jRlQZNmVwqWtDkCsJysTN949rKOVOPGkcH9xuzllYJNXq8rQeRKsK8jRqj\nKdwM8MCbV6tlJeha4N9J7HZ7KKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpRquJHlhpKXUOjx5ficYpK09RXIwHwYDVR0j\nBBgwFoAUgswcMtaJNLjKG2jZiDq7SKC0NDswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCrev+jOFTRfMH5OQUmWqzvSWN1iocZbGGcN8Xpco2tFwIg\nSzbnhBAsK6wfGiboDKBcqcAjGN3P2DBFG1d0l7dAcA8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARJVcMaOnQAuEuV1uMliDw3EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2UwZjJkYS00MmUyLTQ4YzAtOTNlNy1iNDA4NjZlYzE4OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPPMiwKCAeIFGNalAN40McF/4pERtnJiEa2y+xsxTeZ8R2\nF90WRHRM4c2YT1KinEl64ze7qgTOXcnf0nCiSGP1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgswcMtaJNLjKG2jZiDq7SKC0\nNDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc2pGNxsKwuTowT7V0fHe+4sI6jB4AFi9/AmzvzSD5R4CIFJrUtJhTVxo\nn31sJoeAUAxBLMaFcvWp6paZ7CPwJXxI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISARsUe5arC563PdN0JqZgKeqJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDAzZGUyM2EtYjk1Ni00ZTQ5LWIxNzgtODc5OGI3OWZlNGI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTY0Nzc1MzYtMzZiMS00\nODYxLTgyNmQtYjA5ODVhNmZiOTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ng1+HMsVCLqXt1IStGemiMW9qagI8QDpZsWX5mYmqFr4AfR9Dv36e8VM0KIaqCJoJ\nVo2HiHs8mXEqhKfX+hWr4qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpRquJHlhpKXUOjx5\nficYpK09RXIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIDuNXbCbs1jEhNHVRYImvxBk6j58W/lFr/reB6eBYOd7AiB4\nnnqNvsSp6Bnft/5keuZ3uJYEB5k8tJTSpNi7nWO3gw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4379", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4379` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISASMbCvqjoOZlSxNdbmnKlAhnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NmM4OTQ2LWVjMTQtNDNkNC1hMWRjLTJlNzczZWYwY2Q5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJlYzZjNTUtNGYy\nZS00MjZhLTg3NDctOTg1NmYxMWEwODM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcBG0qGabLq4QFp6le1/5If6m4dcRlWEwBdH4EhtmBcM/jTT5EjAcWH4TjGqF\nsyeXUE0vHXjMh3xXmpanEmp7QqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3M0EMi3PNTJZCd53xnVdd5ipvwMwHwYDVR0j\nBBgwFoAUeTTCeOSeUOfo0t+4NeHIsCuV3VswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC3HVANZZd9oBGWk0CuwFtm+KcUOtZp\nuwUG/w73M1+A+wIhALWF6tsjO+eTiPPWuqacgBQs5sbGbabTzVeOzg95spWq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeMMCC9C75O8ebV1DZAwFJYXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTZjODk0Ni1lYzE0LTQzZDQtYTFkYy0yZTc3M2VmMGNkOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFtYUNJ92AWX4MqCw35mH8OFsfKj/b9sTyLc3TXGMZ3rVa\n3qGxYzGa37Ai8mdIUFPMv6wwRPVYa42UVOY40MJPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeTTCeOSeUOfo0t+4NeHIsCuV\n3VswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ9a/hsfs630c8zH/HVNoM94CKwdDkhmAjsO+AIsp+X2AiEAsVIoB6Rn\nENN66kbTzFmsie+Jk1BdT6DO4yHPdQe294Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAc+ktnW0P/DFqM/3X7tI3XCDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJlYzZjNTUtNGYyZS00MjZhLTg3NDctOTg1NmYxMWEwODM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTAzNGNkMzctMmNjMC00\nZDVkLTg1ZWMtZTZiNzY2ZWZmN2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZURYYdvsZR4mo1NHfvbAjWnT4OqXwQi7aO3HjXoVwzBDNXSQ8GA4fcqWCmGNvr4x\nXPkq4X6tavhq7vJE64it+KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3M0EMi3PNTJZCd53\nxnVdd5ipvwMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCICpLdfMeqbkLl3l1Ayq5q/tV6FFAbS+S4xuuwl/n7fMCAiBY\n1vVjNMyt/gSSecxJD86TUdB5TbNxCUgOD/Z0BvFiDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4380", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4380` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZr4lXAaGgGXQPvsUwKdTcH7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1MDc5NjhjLWQ5MzEtNGY5MC1hMmU2LTJlMDJmNGY4NmRjMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJjNWFjMDgtMzNk\nOS00NTUwLWE1OTUtZGYxOWU4ODhmZGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAh4kboaph8LJ1IkprLyf5ySJ4oDMYOt6uLn0iGZyt7/7WAQ1lhxKdXrPIFW9\nSLAf7Tcq2B+Cvpl3pQo4IVduUaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+uvMj7Y+yx+VdDgYJ6wnGSbwXSYwHwYDVR0j\nBBgwFoAUbK1gQ3LE9pBrUiuaY8oQAqnyg/4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIE6zpb+SFggbEsEgHfKFF/Wm0L9gGrES\naTNnLznNPHjlAiEA1PH64Cd5X185KwQsFmMLeddsUPJgD5Uk7ngzI054aoc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXmsQ/JYxkNeiWG8EYRP0k6fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTA3OTY4Yy1kOTMxLTRmOTAtYTJlNi0yZTAyZjRmODZkYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATf77KbjH+M5aI45Fjngz0uMgdzbWrCDFBTXcU68N1ooJgK\nLuM8Z+P7P6lnCQ7bnr5GM/GuKFSZzU2DO9E3JPR/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbK1gQ3LE9pBrUiuaY8oQAqny\ng/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW73wDyrCOJ3h8iIBiIx4QRz79woO6pkH+bJ9Upm8sW4CIDiE5Zbub4WR\nyWCYX6n8EACMSG2+XMGbxRpYfTNUSg8V\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAat7SrXZoZZew47zxTYQzQXPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJjNWFjMDgtMzNkOS00NTUwLWE1OTUtZGYxOWU4ODhmZGQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjJhMDVhNDgtZDkwNi00\nNWFjLWIzOWUtNDE5ZmRhYThjZmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrxucIe7seQYPuU1lTckFKQ6iH3k1vEetItPDN4kdbaUGupTzKIVcF4J1mDwLIfc1\nYT0hrc8EYOq3ezNn3wgTgaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+uvMj7Y+yx+VdDgY\nJ6wnGSbwXSYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIHHdc9BxzqqrUsgGJ2JFeoV8UvSshfG3IzVNzKneJ92xAiEA\nv/C8flmp9L3Qa2CmmwtdwaVoHEJmhsm8yZgQjEXZ/D4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4381", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4381` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfORXOzRPJVuba7woPedQwQMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxYzRjZWM4LTVlM2UtNDc4ZS1hYTBjLWM5ZThhYTdmODZlNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjY2NDc3NTktNjg0\nYy00OWRmLWI3Y2UtM2FlMDA5MGM0ODc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5fMlDj0z/pFOjwcEYYbM2tPNsl1he42RxSM7YW9niLwSvx1WEeM/vxY8NfNs\njtZNreL+Lgj8ExPlMLRzd0ngX6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIQz2sc+N/eJQ+kn4tqjd331rzYVMB8GA1UdIwQY\nMBaAFDCKUBuNCJh1m1IaZicK91fwWK0VMAoGCCqGSM49BAMCA0gAMEUCIDbEPQVg\nNdARzuJwst/HgM4XWnx0xVpceVCEJmbB5Y0WAiEA1AC1sFtMrSsmQb55a5rQj6wT\ns/V0GxGrnQaHtwYRomU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaK4Bw0827dVqJPNP7+t/nqfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWM0Y2VjOC01ZTNlLTQ3OGUtYWEwYy1jOWU4YWE3Zjg2ZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6ZvxetW2fWNFx+Z4S1SWN3J8Lxje92jKqC/EgKMJz9UVb\nR7xzuuAaob7IkA+5MPY99g2SZ61WHNYEaNP7oL2Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMIpQG40ImHWbUhpmJwr3V/BY\nrRUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZFE15xo4VNc70ZuXvWn8y8FuDS4m5WLp3B+qZ6PRr3UCIGnIsaS0xo2U\nCzgHxT+T/aXG4fqdIRjd3WdUNeAeXQ/K\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAX90YQTe/ecXKtftNYL3vEhmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjY2NDc3NTktNjg0Yy00OWRmLWI3Y2UtM2FlMDA5MGM0ODc3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjI5NTk0YjctM2VlZS00MjVkLTljZGItODk2OTY1NmY3\nYzc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELFbScBNq+1/UyjP+TSB0Ge3U\nUi58VMfrVPuUkh5m8vc4Y0AiQF5gTg68AClBbbFbv2iKzUiTzVNNj21UAtTgXaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhDPaxz4394lD6Sfi2qN3ffWvNhUwCgYIKoZIzj0E\nAwIDRwAwRAIgQe1GBItMl18cUp37n3ckPz5n7a45Ym9tChj0QSIi9r0CIDKwb46E\nWCJK/sACyySK359Ta6PW1D61WuvZc+C9VI5u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4382", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4382` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXBDoA5D+iXa2A8qXBU7Q0B/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3YzA3M2I0LWZmZDMtNDY0My05ZWIzLTA1OGYzODczYzJhYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQ0MTBjN2UtZTA5\nMy00MDU3LThjNmUtMmY4YmJkMWUwOWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERaeIJBB5stfo+i4vRg3Ex547gVvR6CLdjAwQpdHVUmSbitqI2iVwY9sgwEQo\ngQjb9bq47Hgz8qZ03aSlQf5wJqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKRAAMGAWQo20zNO19K+g7lSfnwGMB8GA1UdIwQY\nMBaAFOeGEvX2WPHT7ANaF69SIPlPlxAsMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBsh1s+K5ZZkk3YvquPhuwwxfXKbXRCaY0I\n2G73BAVk3gIhANJzzUdWkBsa3FNJEE6oo803m9TQz6TZpACZuYmO+xM5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe6Ey1kphjfYTV+kjYR02pvJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nN2MwNzNiNC1mZmQzLTQ2NDMtOWViMy0wNThmMzg3M2MyYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStj7A3rInrXqodxbJnxScUFbvhMIznoXFXujendkOCS3Jj\nUdluEhVh0Bn98dvTXaA9RLIYMBsKfU7Z4gq0+VO8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU54YS9fZY8dPsA1oXr1Ig+U+X\nECwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOJDwf93/hgswLK3FcGVPhNreLu6hopuTbmpYRHbCrd6AiBUlTgJ1kD6\nNM7eVMIqLnPxajpeubkbwPUmxgy0/xxx0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAR4KcDYdbC/x/cNdyzzit+S6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQ0MTBjN2UtZTA5My00MDU3LThjNmUtMmY4YmJkMWUwOWYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGE1MzNlYTctN2Y5MC00NzM4LWI3ODAtMGNlZDg1YWNm\nODNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+AvBtp0+fLjLuxWbvZwvyJdt\nY+QfdPzn6AxVEzmXjpd30vRpNwtXHXwy6hvs3bkxUxKFPSY0S/QOdgdjjArxcKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpEAAwYBZCjbTM07X0r6DuVJ+fAYwCgYIKoZIzj0E\nAwIDSQAwRgIhALRVWtHbaTweZ02JmPCLr14jvCL/UIAW/8vrO/qLC0pjAiEAvNFU\nkkWksqemzlqhN8DtLgl3OT1IlLLZFUcmIsx1WM4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4383", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4383` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATYGtMLyrbRg+LYbVPyhe5YbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwMmQ4ZThjLWJhMjQtNGQyNy1hNGY2LThjZmI2MGIzZWM4NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ4ZmI2NDktZDQx\nYy00ODc3LWI5MDItODllZmFlMTNlNDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfk7cGQrgyt4sU+EmaNnrPopY9lY5qBIzrBnIHGwm2+e8NlKHGOiw36ezRivk\n0whkg6wHU6rcWPIFGDregU5nW6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHLhf+N1RyFv0O7QAf09u0EqpZC0MB8GA1UdIwQY\nMBaAFDAWohSqwWSbLLeoT+LG/aN7CwGnMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAV4QPMhgfq3T3uoomD9XDY/yDtsKU2bm19\nxYwqadgtCgIhAN72Vj5z+mXySCwvIix0LacQkR35LXQgCyn5mpFA2hNc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcBo0RqlH5fv/1k6Y7voSSo8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDJkOGU4Yy1iYTI0LTRkMjctYTRmNi04Y2ZiNjBiM2VjODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSk6gnuWr7Yhnw9Sr2w5dssBowlnGRdlqfU2zKXuxr4r6u\nsTYsD9NA9Sy0mmyITalSFwu7YtLl8gmx6OSE5xSDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMBaiFKrBZJsst6hP4sb9o3sL\nAacwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZcoM6Uc3rNdngblnGyJWhQH8ktScxwzLRFrK1j87BMMCIQCVx0SFoN9w\nCJSUN4xP+XKnj7REdkogsLTuYR8AV5zciA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAULV3JEh3nAeWYMygnvw+cXAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ4ZmI2NDktZDQxYy00ODc3LWI5MDItODllZmFlMTNlNDViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjI3OGYxNzUtNGFmZC00NzRmLWExYzYtNjlkZGM1M2E5\nZDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzrp2+1ii4UbumWV6CgDbM+us\nNvo/ygt+2co/iw/ngKgMZDn8dBzj7I5SqO/RmNyFF5B++U4lPR16SuPUSviuuqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcuF/43VHIW/Q7tAB/T27QSqlkLQwCgYIKoZIzj0E\nAwIDSAAwRQIhAKZp9QD6p5hNrmacSSwt+qa7AHOYUPxBhg7Te4Rw6ViuAiBwAlc/\n45eVnu1JYqr8sSkgOms6qe2czSFOcN1LChb6VQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4384", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4384` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAVvkzwvY7B3NI/NL6TLa4bWKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5NzBlNzA2LTU1ODYtNDkyZC1hYTVhLTE2NWE1MGUyNzM5NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA3NTcwNjUtOTgw\nZC00N2I0LTlkMGMtNjg4NTczYzNiNGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHDHh8S/aCzE/HRiBglleCs0C/99YLIxpjCeRviI2f2UiildF1WbLCLq+HJCF\nvswpDWRuL/BvCntQ4MsmrWoCoKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBStc6/5YOKJDQ5RB3AvdgsMa0C//zAfBgNVHSME\nGDAWgBSK0UMnZmwz+aiLBy4/y2hX8AjsUzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCQBAg51OykEcP8Yy2ks57FRsZa4Dd0\nQoDRrhIWYENLCAIhAOOVDblszoHbjxy6pxKzMg89quq3mobZxQ6IGcdcbC3B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbkJbZsiXgbyhtBlaGBMYB3yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTcwZTcwNi01NTg2LTQ5MmQtYWE1YS0xNjVhNTBlMjczOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDi/QD9ckFuqO0UQOMcz07BkgeXSRsQYwWgwh/iuLasAOF\nEDKb8eKIgzgFZCl0JlvKSa5uFBzkF9KrMefptxt4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUitFDJ2ZsM/moiwcuP8toV/AI\n7FMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMwI0nZ4gFX+rMTv9rbk4MWiReWA2pi8lyw7YPGQRNmlAiEAlaJZmsqV\nfmCVF0BxzmPhpXVqn77KDdpsbmjbkjrklF8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZmEeeyI9ML2AWZ/nWHUPXCKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA3NTcwNjUtOTgwZC00N2I0LTlkMGMtNjg4NTczYzNiNGI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTc2MTE3OWEtOGY4Ny00MTFjLTgwNDEtMzMxZGUwM2Zi\nOWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP/wDuTEZZusPgmBpNNPLMxuq\nnMgQOKR3Alx5S0ajjgo9D2+sEwHGobUogh6jS+QpMGrxRY3U0ExJ0pJC6oetlaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrXOv+WDiiQ0OUQdwL3YLDGtAv/8wCgYIKoZIzj0E\nAwIDSAAwRQIgDTVZXhrf+wVyNRR7IcsBe37DBvJr8+iOGrRlW8nj8K0CIQC2UoZV\nqCVj7bySjYTcYOb/tKK68m5N3e4CSSu6WmD3zg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4385", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4385` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAcm1m1nmsnracY99bLYGWPXCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiMjI0YzY2LTkwYTctNGFjMy1iZTFhLWIwMGI4ZDhkY2E2MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU5MmMwYTYtOWQ2\nNS00N2NmLTlhNzAtNzFmMmQ5OTNjYTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2nuQ9T+qTe22o+RaIKrBSF29VEx8dQg5tqV6Cn8wAhEfQXi7XbRW17M2rE/r\np3V2EeelGHrGzTHUjB9B2NfmcaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu44+NiW4ATep+EMDStOwUCB9H7gwHwYDVR0j\nBBgwFoAUxcDo9dPf2rzIv6nMBSCqEvtqBNQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA4RI5fkc073/i\nGrSB3dPS9h9Gy24a5ccMBEcADleE4DACIQC/lRrTS4t6NbobjkuEUPDQwWMSRhrk\nDBm6liDzsZ90qg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX5eOBQStdeSZYOiCYSuLbfPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjIyNGM2Ni05MGE3LTRhYzMtYmUxYS1iMDBiOGQ4ZGNhNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdYO4bAC+SzP7rXw+HsQJbfIPCfRyO12C4JvS7GULleq20\nEHPehb1KfxhBGas8ULY2O88Nr8u6hwgKcHixhPBLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxcDo9dPf2rzIv6nMBSCqEvtq\nBNQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALxQqtQs7u8+QlfUuh7wDa62iHiTEvGYDuvvH9r+8Dp8AiABuF4DNr79\nYtoqzbJUgyn1tzjC7N4v3F0KmxQWp1LLhw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISARfJbHYTr5Ig1t9IuKxl1MxpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU5MmMwYTYtOWQ2NS00N2NmLTlhNzAtNzFmMmQ5OTNjYTQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTc5NzlkNDUtNTVmZi00MWM0LWJhNDktYjdhODhhMTI1\nZmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaAqgiMVzR4Nm+eclY0kV1bnP\nGw7g7W2X7n4rcgbpjNAFBTlNkgLChgc+WXduAutg8CyG5hCahlhLFjJwR8XSlKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUu44+NiW4ATep+EMDStOwUCB9H7gwCgYIKoZIzj0E\nAwIDSQAwRgIhAKHsMLURTHB7XUZ8BpFjQG+rzXdXj2GCL2RkvXSFyDzKAiEApopx\nNLNUT34RYS94XFeEbLeHLKZfAr2dlpFQUVgkGWo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4386", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4386` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAbAD2qVCXnLb2HkPWwL65CGaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ZDI5YTNjLThiMzItNDRlZC05NmUxLTVlMzZlZWY2ZDFjOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQ2ODA4MWYtMThj\nMS00NjQ5LWI1ZjktZTc5OTJmZTA4YmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM00StY09z42FGXTrlM1UUBTgMaznCvvuSjB9HbSAf4s3KC6VowCZLk7O1f3H\nqVYK/VDwQN7fiPAgPHlKF6jhT6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6NDNhm530WvayEI9X4kYX5kDu/kwHwYDVR0j\nBBgwFoAUtp1h335gJFvn2nskkAqXaRANAhYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAy9VxwQ9RL3fX\novzeGFwh0fgwA+40js2orC5igcgB0LICIQDz7dd6H3vc117qjVJ89NWDREUxONJw\nhSOeU5PXITTuig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASUdpdeqbNqsdrm0HeKQFYpzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGQyOWEzYy04YjMyLTQ0ZWQtOTZlMS01ZTM2ZWVmNmQxYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQe+RQ5GUMr2HNVTnRp74drrqc8Gyy1He4gLCzkPz1isa6z\n9lmeM17St9C1CHdf/bWGgE+YNBsmUXQjzK2f/dmqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtp1h335gJFvn2nskkAqXaRAN\nAhYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKLVqOrX52Y5d4E0aOjxlH1wS1hNMeDmsS1mx0COLJoYAiEAh1xOTw8z\ncmcxRU0f0EDsfqL5QDGKVi0RsR0/umoY6wU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAU9RWPgH/bjBfKnqf6fBpy24MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQ2ODA4MWYtMThjMS00NjQ5LWI1ZjktZTc5OTJmZTA4YmI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2MzNDY2N2EtMDlhNi00ZGFiLTg4MDYtMzIxYTVjMDU4\nMmJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElC4/Lc4e0ncbHiNJCNJk/yPy\nInmgBdJ5YsPWmt9Eg6wuvN7DN+Q45gDI1cG6D1wJBxuRufujNqcdWlQJCA0HX6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6NDNhm530WvayEI9X4kYX5kDu/kwCgYIKoZIzj0E\nAwIDSQAwRgIhAIc7pApn6qJ9YfS63VjTzFWFPjaOB+uTiG4YLrX2ypYNAiEA1mGB\nY+5FvqTk8zDe2g36Jn9gY8UGOd9++mn5tHDS2Xc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4387", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4387` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAYMnt1xr2xz2xLwzovpaO/zdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MzExOWFmLTc2OGUtNDBmMy1iNGVjLTZmMmM4Mjg5ZjIzYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFmZmQ3M2EtNWI4\nMS00N2YzLWJjODAtMGVkYzFjZjkxYThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdwUW/6S6Lj0wsWw1zFUd7LjLal16h/UACuZ6s6GC4k+fITZZkw9JitqKOyvt\npVj6E1hue7OOcfdBcDXa0qq+6aOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ/Yx13MPifvarivKAidhyTG53YwwHwYDVR0j\nBBgwFoAU2vUE7SeRCBnWMLqL1jVrcAbXjEswIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAge4njGkkVAFJHN45G+jb\n5bDxsch+TMSArokFxGydABECIHb9DzmIlhdOezjHwV4eSdCvHQ0OvpcoM51J8Fj8\nfa91\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcFYF86J1VXZvqmRHbu0xw83MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDMxMTlhZi03NjhlLTQwZjMtYjRlYy02ZjJjODI4OWYyM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQs/IGtMPpPdoXhrcRQVWhXNRfeGAZXo4Qx8tlkfmZAUHn3\nZVn+ynF/mWTaEm+3pDGIDJWcJJ6su8do8Av+9zKqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2vUE7SeRCBnWMLqL1jVrcAbX\njEswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAkQj+vTEwn6yQYvbzkETHFS3O/IbczA0XrPKXKg13uACIF4giru40SGH\nquokK4jprBg0OOLY0W2rI4DAmEgeSe+M\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAQh7BXjYcTMa+fE+hjmtacxxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFmZmQ3M2EtNWI4MS00N2YzLWJjODAtMGVkYzFjZjkxYThlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2QzNjAxMDItODNlNi00MGJjLWEyMmEtMmQ4ZDYyNTgx\nNmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEu04e4wVmYY4RmEw0vYaHNDPm\n+QGhePJHONOxQNovnLXka1BhBNeLA0Dygm+dwbh0CmpXSdKFaT+leKwEOdLesaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ/Yx13MPifvarivKAidhyTG53YwwCgYIKoZIzj0E\nAwIDSAAwRQIgYXRFX/Z0KznRp7y3D8HkvhWlYrNUT6jZJvrnCYZxvUsCIQDlm2wZ\n27zQvQPf2IE5EDZDz0RrvNVlJGeaBMamVEsSVw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4388", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4388` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAcnJ6FJ3xjbrI0LPLIR1nOWuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmODk0YzM3LTkyY2QtNDRkYi05MjBhLTA1OWEwMTI5MGQzYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzljYWMwMGUtNjYw\nYi00YzA3LTkwN2YtNjBlMjhhNTI5OGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+D+ILIoPAVr82IeRIlHwa94ynq3zYsJcxAAQzoP3M/JMiQdPo0p1+i4zkduS\nZO9kL7ebd8TfLSUzeeBQ2LnF2qOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKNUuiyPjb6LPv+pi1CsWHh6Mu/AwHwYDVR0j\nBBgwFoAUDeN/z1evtBPRcoexnJT5wrFCaqUwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAy6S9\nku60O/ttKxI1YChYISoRyo1R2pu/3TxSm4hJZgMCIGLMJ8KDEYZCZ+vz0vQvIOpk\nivM4u8fbvEpkKX/dVOeb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU8Y7sp6dty+uSxq+MdxYvKdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjg5NGMzNy05MmNkLTQ0ZGItOTIwYS0wNTlhMDEyOTBkM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASX71o0AgzJOIhz6BWTHy0pCVQ3utqNR77oPhQMZrfkIXWF\nb6zUNKdhtr1ZXL9n4Ics3m9nwExksZfVXdYa5FQvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDeN/z1evtBPRcoexnJT5wrFC\naqUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANezA9tLiuET50NmdSNAPH/14i0K0bz+5RcQQYk0Kh8EAiAXyXYMruc4\nPv6wEjdIoQyELONZuMn4EBmbNVeUae8l+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISASZzWWL8hjgiTsjeSQSbZPLvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzljYWMwMGUtNjYwYi00YzA3LTkwN2YtNjBlMjhhNTI5OGFmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmFlM2FjYTEtYzhkMS00ZmRjLWJkNzEtMDdlNzI5NDE2\nMGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0rQuwZywi9sadGyajYXylW0R\nxryjI1FKQvspG0gG/eaW53rrJ9C8bAny9viBPi2WVudIueDAa5xMCQIXCDFrMaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKNUuiyPjb6LPv+pi1CsWHh6Mu/AwCgYIKoZIzj0E\nAwIDSAAwRQIgEPWKJ/HCy7nku8oMjlOra54f27cdCTeSyXCuw8klvD0CIQCL9XlZ\n6XF5k5gix9Id+BlNxB+Ss69onIQhzSHL53hZ4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4389", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4389` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAfQVrnEwkV3QYR2URsR+nCcRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2YTI5ZTcyLThlYzYtNDRiNi1hZjY2LTA0NDM3NmI1YWViMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFiNDQxZTAtZmZj\nMC00NjQ0LWExNGQtOGZhZTE3YjEzMDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3M/f+0w/CdncneykeGock/hdQLK9EphsL6c/WpwfP2JTlxMdvoBtIXiHa0wb\n9x3kOcpav0sjljbpO70Z6/qLG6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2L+l1k6Z0k78UU6ejhIU1ckwvEcwHwYDVR0j\nBBgwFoAUDD8q45dww+rGrx9sKpJa+SXu2HgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAtZQ1d\nfeNLqD1dJMLINkovlrQCys3xxqDEJkKuUtxUwwIhAITeT9wIZXoSqm7yaN41aGx2\nA6Z2ImKh/0dqIkLGBT0V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAURYrUJx9eLWfUFn3XbaXE8fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNmEyOWU3Mi04ZWM2LTQ0YjYtYWY2Ni0wNDQzNzZiNWFlYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjieunn5cQSLTh8CAzxYIK4ch7eBwlnczbXrokldzBpMin\nghiNOuCC0c5XatWaTDyfDZ0Qf1cOCPNU8tbKMPcUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDD8q45dww+rGrx9sKpJa+SXu\n2HgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI6pnhsai2+ngnyXj0KJg/pg9NBAxhH2aVlTXbXYneE7AiEA4fCg+z4K\nbs4m4AhMbWIbIBEnFjaYhEWp0UF8VR3x22w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAVsBNEFfTnPtyGcjKZtVUDkdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFiNDQxZTAtZmZjMC00NjQ0LWExNGQtOGZhZTE3YjEzMDk3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjI1ZDMyZWQtMTc0NC00ODNkLTgxOGQtODcwOWY3MzM1\nMjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElnhOgHkvGYG4qGsscCQlLTbd\nwykhkTCdYbgjkOG2iKsJHwvr+OwlfxlQyI8dlMBl5hT2mWDeoYeVuyBXVxPdgKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2L+l1k6Z0k78UU6ejhIU1ckwvEcwCgYIKoZIzj0E\nAwIDRwAwRAIgOgWgftrNt9IR4TuESgho28epXkncWh+SQ/WI5f3rFqsCIBs2zC0m\nqfM2BEjcu212oLNeE5hCMGUjuagmZPERwiWL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4390", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4390` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYvB3264h60ezru9X0Ha0mAfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhOWQ5NjU5LWRjODEtNGI4Yi05YjdiLTIwZWY1ZWRkZjExNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhlM2UxODItNjk2\nNS00OGFkLWE1YzAtZDY1MTRmMWIwOTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaVZ62jR9T0SiLTWb8YcH9/AmqJ59UlwOKAyzrPC38Eh1rPB2QBEFOSjXiO+w\nd0VizytN9rOicNVI0ji7ipE4o6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGN2depwMWJJNUp0B1cd/IptP2e5MB8GA1UdIwQY\nMBaAFF+O7Ec3pwKGKT0/VSteMmbJmtkdMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBPhzEJBeiEzODl0XDkIMXBT+YbmcjsFlya\nI/AqJEkbxAIhANdQCn/Pu/eko/lSL4fh7NzPgxP3AmocLI6BA4kzJhve\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbwhGvEcyTmItkkdEzNftIE4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTlkOTY1OS1kYzgxLTRiOGItOWI3Yi0yMGVmNWVkZGYxMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUBvPiwiw8vDZK2igt1+sCVa0VgXVG4HcU1hCpApf2FOm+\nUxaQG6psJDpO8Puqgpn3Z6YJ/3ArumzWXVmnUWdro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX47sRzenAoYpPT9VK14yZsma\n2R0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKexUKPHDR3O00/xC2Ps89CIWgeht2kf/JETwBukH5kiAiBdrTwHSn2k\nenuDJgjtmDyWxc/ZHaWV+AbM/7C/ftPqHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZd0lCNMS4fg1etQM4etDGUpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhlM2UxODItNjk2NS00OGFkLWE1YzAtZDY1MTRmMWIwOTI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODBlZTZjZWItM2JhNS00NjZiLWFmMTYtOTNkZDkzNDA1\nNWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/MfECG+tJGKPxiBnYhOHW1IB\nqHC5d4uVTRBMR5KxzeKzZb0kNggP4rSCOO1CtNhxKthqFZIhYIPM+6qmFFGjVKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY3Z16nAxYkk1SnQHVx38im0/Z7kwCgYIKoZIzj0E\nAwIDSAAwRQIhAK/2Vdu/7VJb2hKVfYsI58+V3+iuK6qlhlPwFfNuKU3TAiAy+xrD\nK1yqt6TKjCb8J+owyQ8XvgD1ROMatWvC9Yt2Mw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4391", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4391` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAV7r0Dq4XJY70/mYm3SVhyFNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmOTA1NjVhLTAzMzgtNDY1My1iYjExLTMzOTE2ZWYzYjUxOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc1NDJjY2QtNzZj\nYy00M2U3LWI2MTctYjE4N2FmNTNkNmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeCIVGQNJgmqLdtN1G0gMiUrNcUQU987CwYFnq1FfzPkyAhwVc6nMmWE43+hQ\nWvQUbpmBjyoER4XygqZ78KewFKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA0kM6tXDnkozTCTGBOWz4OuJXbQwHwYDVR0j\nBBgwFoAUnipFHgkl5VDozG2qZi3WdOXP42QwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMGdmM+ixRxA\nlB0EIq0ySojn6xp1Cciv4Bv6xd5/AjjYAiBt9w0dR+ouUd36rMrzD11SVgNlGp9g\ni8OqsY3D/GFvIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVefK/Fy5cxift+TgTTEiL24MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjkwNTY1YS0wMzM4LTQ2NTMtYmIxMS0zMzkxNmVmM2I1MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT40m4TddjXps/X6quOD7hO6g2ILYimlXpl+TP6F3LC0dMb\nF1lMyXaJp3Mkm/P/QX4ewgnIS48AAY7soceJ3QbVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnipFHgkl5VDozG2qZi3WdOXP\n42QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANMG1N0ixTPgdm+bIOktg88EcSw9+Xz+F9Odqg/7YwPIAiAUDdPknTrQ\nLcT/tquay3dwENc+y2vDlQc2upLnmqMgJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAcCOiWXh2aEmpoWq5sUclmdQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc1NDJjY2QtNzZjYy00M2U3LWI2MTctYjE4N2FmNTNkNmM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmVkZDQ2NTctN2I2MC00YTdmLTkyZWMtMTY2NzQxODBm\nMTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY8xPRuhDMT9+mzVdAd+FMkWg\nk9UHJZJMwooaUB3PLOXex8b35QW/0VmnEI6iz7UcxchD591lM3E6QyRJZOmKT6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA0kM6tXDnkozTCTGBOWz4OuJXbQwCgYIKoZIzj0E\nAwIDSAAwRQIhAJ94tiWYsWcWpNw2mntMOCZzZ/XUluohPJp+jQehijIzAiAg6+8o\nFwPLwuT3RYAIUomDotWQX+99PA/BPjXgJwgz3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4392", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4392` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAZWAtNQNgZbwrmJlI+oKugE6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMmI1ZTRhLTkzODItNDgxYy1hMmMwLWNkYWY3NmY4NGRlZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVjYTEyYmQtYWM1\nZS00ZjgzLTljN2UtOGY4MjhkZDZjYmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbWWtC5jNaXdDSWtItyUoORtksgPLvR/kJNBJv5H+v0BN1JTZQXUIgJkjD+YB\nIkbZ5gCXh1OuN9xguVkl1wh+P6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWx3ELA2pTsVJtRNpLN0dCSRC5REwHwYDVR0j\nBBgwFoAU2nZzMImCVeNSyxrZ4FRBcpypkuQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJwKsJXP5RyE\npNzsjiEg1bzCShPzBZmjzUq45Gfh2izuAiAm4cgoiSZRUkr1LmiBuv4h0GPXzIyU\nGOBzYC9uo8UwqA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWdUq+ujt6kuU2uoHVmvUTjYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTJiNWU0YS05MzgyLTQ4MWMtYTJjMC1jZGFmNzZmODRkZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGW2cTohCm4gm6dQJPcvt3RhqSOmWp8JbWL6WNXPI/Iwte\nO4LFhNaGwtbrSZSsKTgj4Hqwo/tiBVBuW42tItMJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2nZzMImCVeNSyxrZ4FRBcpyp\nkuQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXd4Eeaqi05Ik1QTFiGAQ7qXGELFNuc+iCIOqrIrnTxoCIQDY4No6TVT9\nESz35Szol+FaHQWh4O3hkvIIU7Po802kjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAUQ8RIM7IJFBRxg8pvm5CuTUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVjYTEyYmQtYWM1ZS00ZjgzLTljN2UtOGY4MjhkZDZjYmMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGE5YTUxYzEtMTMzNC00OTlmLTkxZTYtYTk5MTRkOGUz\nNjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwucjQYbsiNZAPTV95ucDWPkJ\n8/pMiw5z4Yn/AzR+m+8Uz69F50N8E33iMZMxYt7y1J+O3qmKjt63tVHvdyIHwaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWx3ELA2pTsVJtRNpLN0dCSRC5REwCgYIKoZIzj0E\nAwIDSAAwRQIhAMKQUxfs9C+GDgZDXdxXflGGzEQOkUf/XnYqoSFdCXRKAiB+3QjU\n+meOCY8p0cPTnRyDtUDknuL7F4GJYvT3Xut+3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4393", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4393` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAa+DA2DTlNiJNgY9DN/uUG2sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5Mjc3MzFmLTIwYjgtNDk3OC05NWQzLWY2YWQyOWRkZjMyNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTIxZTY5ZjMtMTAx\nYS00NTlkLWE0ZTktYzlhOGVjYzI1YzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEejo8THONnGHk3xF5Cs3LY4D+OXwyw0qD+9uStt4Ls64ngUZxmmQZyFZDvRJZ\nXngwE9YDve6GnXYZVFRsImKTe6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD4BurjV6jxu7qgIg/2wK892GFJowHwYDVR0j\nBBgwFoAUFaIVmRZJ2z6Q9zcUHOTyy9Lo7yMwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICtWmY84jEEF\nl7z1dahNByxo9eAhPZ0aZj9IQeWJWHFNAiB4QmyJe15+sgB0jzgs3g5WkWfbYWYh\npv7i1rI9nMzJPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR7RWpHnR0Mq+jJSlGGCucWGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTI3NzMxZi0yMGI4LTQ5NzgtOTVkMy1mNmFkMjlkZGYzMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/vc4Nq6SGAgzaURai85rJYNar4yA9HpuNkwAcgNwYCuOx\nUQJMvSwrO7vEZ/Sen1n0+kU70mYX81KeT2KVF15Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFaIVmRZJ2z6Q9zcUHOTyy9Lo\n7yMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO2OcQAJwxDP1t2IJ+NMEvYDKYtAy9xcLtMpFSi9C7JwAiEAlQKJ8ORS\na0Su19+rgC29EWfjZu+ySeORS1o51q/V2Qs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAWQakWjar5L1PfmC1wtMUhlWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTIxZTY5ZjMtMTAxYS00NTlkLWE0ZTktYzlhOGVjYzI1YzVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWU4MWM5NTAtODg5OS00M2FjLWIxYTktM2NiODhmYjdh\nYTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8yH2+ufOqqzdWCoDBvGY13mH\njGlTu9W36XNcHpnIuwClTcxc9jlnOEqHdcCUcMxyWpuYMh7ia6i4MHgcEsdYaaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUD4BurjV6jxu7qgIg/2wK892GFJowCgYIKoZIzj0E\nAwIDSQAwRgIhAM+w3YZP49bAzfaO2+smnNHeOHlzoZbkfoErDOeqANtPAiEAzTFl\nSTk5BeuYwVP9cbs+hNqp0COUPc1B4sLx8k7F9pg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4394", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4394` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASVTFvmYnwAM6nFS2l6s3X0MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjM2QwOWFmLWI3NWQtNDNmYy1iYzhmLTU5ZTMyY2FkYmNmYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM1NDgzNTAtYzU2\nZC00ZDVlLTkyYWEtNTc2ZDAzYzA5NzYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6J/CyFip5XzHW/XfYKjpvu2nYln170CLHs1u/SRKZsurGO+Uvcc8v1DMW5iL\ni76HhPvA7s4C1Q5LmFyDBI9cSaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0TkV+v3F1ZATQwBUCECI7IqQAmEwHwYDVR0j\nBBgwFoAUkfP+r4YwszL2EluNkZoRXEU0N8UwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICZTZjATEDS50EQ2rl9P0VCX67rNiww6fl9xuPT1e1mEAiB1GdnZZlybC2z9\ndYzxTsI+m7VvKOTPvoJpiesCVROpjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAatbBhXbQEIsxoeRGOKIIV8hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzNkMDlhZi1iNzVkLTQzZmMtYmM4Zi01OWUzMmNhZGJjZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxfLeoxhiN61AX1GQwNzzhPWUHzgIV+Frw//Y4t1oSZrpE\njQe4g0KLi2WMogI9uwe777TaEGFUaywkPvQcu/Geo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkfP+r4YwszL2EluNkZoRXEU0\nN8UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP0EZGR39Cy3C6HIkDFpYryc1nlkq+5ZhQDkY3Gq2l/RAiAVX4uAsApH\nN0HaCcdCQgXHyThogZBqXN6eCcQ0tr/8pQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZslGuitPf3joVHdhy+QCrtZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM1NDgzNTAtYzU2ZC00ZDVlLTkyYWEtNTc2ZDAzYzA5NzYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDgxNWE1MGYtMGFlMi00NmM5LTgwNGUtYTI0Y2I2MTdh\nZGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESpR/WG1rA2tFttK+dkndbGr+\nA8J5ASnG4rwPBet64JVlwduw4nzF8CJjknXcgCYaWq5i0+NlDxl64MF4aBoaL6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0TkV+v3F1ZATQwBUCECI7IqQAmEwCgYIKoZIzj0E\nAwIDSAAwRQIhAPBD5IrfymUPsffO+dxw6WqAMgOiUqasJ+eivlS8/G+tAiBCA2iW\nj40ttDrO3yWQO3jK3i8BfjoJ+EGDGjHkNOUD9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4395", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4395` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXIYvB8VR3+/hewXwbDJA5bYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4Zjc3MjFlLWQ5ZGYtNDcxNS05MzY2LTJkNGFkNDk0NTcyMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjJiNDg3MzctODNj\nMS00MTkzLWI3NGMtYTdkZTU5NjM2Y2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5vwYJN9t8myvhz4HPDAzp27qCQcXh7jPrpQ5aDyeqWdPgNmoTpv/WyQVaN0w\nB/K4/y2l11kdpAJU18KUud0FqKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1xHIAzb9j+FDuHzLKM70NevFeZIwHwYDVR0j\nBBgwFoAULmJJs8B/OzM7QQGxxzGlv7lUbTAwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDQCNhjU1awldqu1Nz3mh6zak/umrQD12jiUoawAETguwIgI0FhfceI5Lc8\nHXsRHiDfoxHJQ4lr8XDic7XNTKQT6cc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXkYjUpndgsHJceMbHkLK4kLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOGY3NzIxZS1kOWRmLTQ3MTUtOTM2Ni0yZDRhZDQ5NDU3MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq+LdzILG9cRlgbR2OQzw+61poZbkjO4+anAbmasXpCNRX\nU44e6JF/ltoZlvVT2pQZHx0R/dfVMPBBlKokDVX/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULmJJs8B/OzM7QQGxxzGlv7lU\nbTAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFwJ0Vpk/YM8YPdqOWijbEXPbVvLUD4qO3AMHnzVxR84CIA42/lUYRDVr\nN9QXzUnyanbYM/fnUNgM0/aGHVl2E61F\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAe85z+ooT6i8VDHfp/a+f2X7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjJiNDg3MzctODNjMS00MTkzLWI3NGMtYTdkZTU5NjM2Y2VkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTljMjQ3ZWEtNjI3MC00MWUwLWFiMjQtMDk1NDA2MDg5\nYTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVPwopu1LulYvyQkmezU4Cz8a\nJ3Ja5yMmUFlAkNqMvxJS2jw2Pm2sgGZItLsfFIaO6z3GJBEqqzS+phFzqAAWUaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1xHIAzb9j+FDuHzLKM70NevFeZIwCgYIKoZIzj0E\nAwIDSQAwRgIhAJWkQvEWpGfELCRYEr1KIHMP736EIBYMRD8azix9t256AiEA+QCc\nu4Zr9slDPFeh4vZz5QOimjhI8TNkiteJTWkGm5Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4396", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4396` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISATntRxzF/d6oP0DSauXh6zYMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhOTFkYmY3LWNiZGQtNGIxNy1hNTczLTAwZDk5MjA1OWRjMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc1MzA5NDYtY2U1\nNy00YzVmLWFhOWUtODhkMWVhYzcwYzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJMuvnMphPOpqtsz6H34U0J6jfScx8VYFz0jRjU8dfSDFUgR8DdKpiBVOzFcV\ng/syGQxKe45qnHqtwpUkU861Q6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKHjkgamQpVaQO3v4r3Tqk9ZMeRAwHwYDVR0j\nBBgwFoAUlxSNOgrKGZ/kelp3e6yw8SBoBlcwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHMr\nw3bkEq3M0iN33UGIDbqpi2WusnXFnPhWKPMM/6OiAiEAs4Zgj65Ln5FBDUhcfPuI\n+bOaDKDVp4fdYhHf/huAjYA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVPvB2p0owz0qXpF1Y5+C4dmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTkxZGJmNy1jYmRkLTRiMTctYTU3My0wMGQ5OTIwNTlkYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlbGTWoc5w1a/cv4cVO5cLMl6/h5pMjkohjo02cc10iFMT\np4EE5E4Lk4SamDavAOnxORVnJJ8O4wMOSHU7JiwPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlxSNOgrKGZ/kelp3e6yw8SBo\nBlcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgINUQhbaNnR5RNYQL3464+8BCP+qGnnPR0MHpu1oCs3ICIEc6w6aIO7Ra\nvyoMT60sj2XnQ39Jt+wBgh7KIJxvYPcQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAXr7EaS+nAg0ETTrgecMUEGQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc1MzA5NDYtY2U1Ny00YzVmLWFhOWUtODhkMWVhYzcwYzM3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmFhMzlmZDQtODI2NS00NzUzLThhYzktZDY0M2NkZGE1\nMWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfDyr5MoC5Bcv8G/lFPJSqDoK\nb2ACJ7zWipyPlx3u0IIEdqh0alxkFlP0RTlPI53TwfzEkiYgpwNv16HNR6DEx6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKHjkgamQpVaQO3v4r3Tqk9ZMeRAwCgYIKoZIzj0E\nAwIDSAAwRQIhAK//8SpPxxYeIhR9WcQ0ycXneWnXAOTxo0k9/+G7NcXjAiA7lpCK\nwv4M/RlvhnqTy08DPN8dVYTuwu8CaPfw+nc3JQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4397", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4397` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAeVnNK7mQscjjR0kxXYrQDE2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNTAwZWRlLTllMDctNDQxMi1hY2YyLWFjMWMwODQxY2FhZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2UxOWY3YjQtYTBh\nOS00ZDY1LWI1MWQtY2Y4ODZkZDYxYzIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETQ9vbt5VwwJcrha9lN68sCrYBx+5xDIuNTPmoH1o3oKVR8u+6sUO4mKDzI7c\n2YDnsgm8pSvJOukTJL29Hwr+N6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV17fbtqRIyJTAcv8rJF62AbC7BQwHwYDVR0j\nBBgwFoAUOzbZcjHI1hamItIF6Mzxa7u53BkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIC0bxjIF9dPcMMbBrH4WawVDqpk7zyOEPpciH1pXe2NVAiBsgKD7\nEpHt2UvLKHJwEA5UYhbM4PtH9guBfDVsUr4V3g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAROw5BjfjZxd9dTRSPDMIB3uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzUwMGVkZS05ZTA3LTQ0MTItYWNmMi1hYzFjMDg0MWNhYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6m/hVsnaVq7GzMVf4/kG7Kts5bOuGXQB9U+bi4wNQsSzS\nhvCdkIFVTWdA4+o3+BS9wrjKosky/KJTBlctC4nTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOzbZcjHI1hamItIF6Mzxa7u5\n3BkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPO3YA+aEatlAKu7g7f7PNL/XJtQ7MxT7+etGzx8Yf5bAiEAwSMk/EU/\nGCFRQ2sCEKyAHpPrmyx2AHLTXGhhL5aFtvo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAao8csO5H0/kqufzEHmVoE3BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2UxOWY3YjQtYTBhOS00ZDY1LWI1MWQtY2Y4ODZkZDYxYzIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQxNzlhNmYtZDQ4Yy00MDA0LWI4NDYtODIyY2Q5NTBm\nNTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzKJnu3j323RvPBIoZKNA+MZu\nLzRR3AupwCqTXfDQc5ko8TnWF1JZyw6hOPDIcSf1uh9lJ4O0DU5e7cwPcB5dt6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV17fbtqRIyJTAcv8rJF62AbC7BQwCgYIKoZIzj0E\nAwIDSQAwRgIhANoASstX2x8T5Kx1NruvDl9yBGtTEVJcqQheZEKUWPgRAiEA9bwW\nxXlqEjqgJNJaIqGSjbeu7vIjMHtFLnknN//8OJA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4398", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4398` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISATaBSLMmMskWNdb0B4jzLW1BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwYTY5ODc3LWYyNGMtNGI5YS04ZTg3LTU3MDAxNDBjZTIzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY4ZmFkZDEtODg0\nOS00YWUyLWE2YWUtOGU4NzdmZTgzZTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEshaXO/J4FdtExpMsH4lC0PI7qnXvJAUSqxkhrcNMsD/Ho1JwiVgd4KNZCjYD\ncpwWePwtI9u5XWyR61LYQg8hw6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7HeLjCsJezSGIhJ4OqT5uc1CUNIwHwYDVR0j\nBBgwFoAUYW5jAupjeV3R1J6ahCbHBwL9khAwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCDB1qcJOwwRxD3MCvZW/BOlrfzwCd7JTQ7h+4Aq4T1tQIhAMST\nuV+TUT9KtJLM/zr3V1TeuHws2VuNtxZInBGVOPo5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYqJ3o7ITg021VPqVjBKVlAsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGE2OTg3Ny1mMjRjLTRiOWEtOGU4Ny01NzAwMTQwY2UyM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5p7L8BoAmvZeNKVl/GjHAsKmsgkoCcxXlv/2NHyUOTDnh\njOCoQ/5pyKjs1lKHGPfrV3PhAXVvoD7Hawokq4aYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYW5jAupjeV3R1J6ahCbHBwL9\nkhAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgS8e0ZX/+Bg2Pp4f+Ku3nZ5DIwy7SamO2t41Lc40lsX8CIHDXgMh0sSe+\nMTDNqS/A8G35G7ufyBL3Efqbq7cKngPA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAXvp0SwNX6P95OkcDlHwkFC5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY4ZmFkZDEtODg0OS00YWUyLWE2YWUtOGU4NzdmZTgzZTc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjM5ODg2NWMtYTRkMy00NGFhLWI1MjgtNDdhNzFjZmM4\nM2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJtD2wWuT+5PN13g7p+GqCMwf\n5szqGXYSznnq7XwCPG+JVNOBnt0JntWhxzovb/0jKWHsatIjb5E+yj/fhSQ6gKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7HeLjCsJezSGIhJ4OqT5uc1CUNIwCgYIKoZIzj0E\nAwIDSAAwRQIhAMnL369birjpcTEeqUCLuCXPvknlpMIi0QgzR2yT+qYKAiA2rPA+\nBk8Oq2HimDg37dUayNTfMqVQtSAR2hDAtSunQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4399", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4399` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAROPvDOAj1uErZx/KdErYQ4ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5ZTkzZmExLTQ1MmYtNDcyOS04MzRhLWQ2NzZlOWRlOGRmZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY5MWRmMzUtNWQ1\nYi00NzlkLTljZTctNzg2NjUxNWFjZWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQJmfsaDr/uy8JbMEw0tRVgXbOYu/h3DhQLg0BiMRvgYtis+3WtzcibloCWNq\n/F7UPxymvrapcV01jY2t+ypsIqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDS6lRUJlV7pJLbimutHgIp6gbI7MB8GA1UdIwQY\nMBaAFN4bnPPeY7ayjLxuZxDloJn2bRKyMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBAUj0HY+t8eFjUYmQKcBaEP2I6vxpA6r4h\no4edeVCYeAIhAMvgJ9IUnubGbekvqiULYo1gBz0qUgHt9BSuS2tGy7Mn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd1seNfG7lOqc7XzDSni/7ZaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWU5M2ZhMS00NTJmLTQ3MjktODM0YS1kNjc2ZTlkZThkZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpLu/uQeAd7gThiqJr4igBp7xLWvYFUhlWOaWrE/dIkhV9\nsE+aguBl8MqAwHIFqadijPLhfKimmUnHUVRmAroio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3huc895jtrKMvG5nEOWgmfZt\nErIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKt0k6sCPPd9KkfZlTNdY5WEIVdLFkX3nfBCgIaVYQ5fAiEAgp6Hl83I\ni82d6uLZT0p7AKd7nW7JpGkHtR7A13v7Svg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAYtMh+/vtDIuk5eVqqUdOx4TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY5MWRmMzUtNWQ1Yi00NzlkLTljZTctNzg2NjUxNWFjZWEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGVlOTQ2MzctOGUwNi00NTVmLWI0MjEtY2U1OGQ5ZTFi\nM2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYWCG3CuAIHdA3T6STudnkJjQ\nIqPbx9XealW36Koo15O9074oKVUWJCliokQytqk/YXGGyvZjX/O1clAfHSqe8aNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNLqVFQmVXukktuKa60eAinqBsjswCgYIKoZIzj0E\nAwIDSQAwRgIhAMfN7bDUJAte+/iPfUQuyXHx3f7qLuYiwkBmCU/gkicdAiEAhikX\naNK2OtojP3AUpN+79o3tkm5YdLbvAHojaFvmW34=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4400", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4400` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVHQyG4mbE01YGsGw5tXpHB7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkOGQxNTk3LWJmMTQtNGNkYy05MDk1LTVhMDNlZjI4NzJkYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWYwOGRiOTctNjAz\nYS00NWE5LTgyNzQtOWRmZWIxZDI2MzMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyZArFCfvIf9plZxQ7+PBCoq7FhjrQCfWFzNq0i/Cl6YjPg72TlmoJXyWLLa/\nQEy35DRo3ajMZyHFsfIJIuwW3KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5VmHq3J5OCMhZiTd9WTPZzg8+Y8wHwYDVR0j\nBBgwFoAUXkWEAPi5J695pvTBECdWjSwr4aUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANe4a1y4uXq0\n4epNyGj67MXQskmobKOavX9VeXzE+kNCAiBepbJXpJc6xB2Zsm8S8zzgfboxxDbV\n+DOeun5NSihxgg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQRCbwZc2iN5UZ6l9CtuKGG/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDhkMTU5Ny1iZjE0LTRjZGMtOTA5NS01YTAzZWYyODcyZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8tvntQEy1NC9SkI4ku//O0gvyI7nnOCsRremdUBjDm0qc\nLBfh0q+EmAPJDPEnURVl9U3P99dqTWEYKPpntDDVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXkWEAPi5J695pvTBECdWjSwr\n4aUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMZkckVdKn9bkF5zWR2H+l3Y+QJGauJLU/K5GlBZPeUtAiEAx8W6F+IU\nIaIPFkWsdjaN6owjU33jNx67+Xqu23PEH6Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAYj/FJDI8ZXyfn+DqVwoDVW1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWYwOGRiOTctNjAzYS00NWE5LTgyNzQtOWRmZWIxZDI2MzMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTJmMzg5NTItZGI4NC00NGI0LWI3MTItNzg2MWM1YzVl\nZmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4iDqmcamsCeA2tUEgsufHFcF\n5FIIeCRwmz0DxTlEvBALdXSWcysECbMLUhwiCl7jJOXO5xmw4WAVsb2hfdi20qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5VmHq3J5OCMhZiTd9WTPZzg8+Y8wCgYIKoZIzj0E\nAwIDSAAwRQIhAIVpKdMXGHwFzmnuq1Me5QTTZ8sZMFppNb0QbIiz+5nxAiAfoVZN\nNFW4hsXTpLseQW8HRY5PUOjieG7e023Tp488TQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4401", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4401` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbpxZtEaMsZ0gaMhwqzNb3zDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmMmViOGM1LWM3NDEtNDYxMy05M2IwLTBkYjFkOTZjNWUwNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhjZWE4NGMtNWUx\nYS00NjE5LTk2YjMtMzA2YjY1ZDBjZmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQKXPu19wKTlbOsawAd2q3yLwqo3Pu3elk9AgiHL/Z+jJqfVHzDCpUcGAqMCy\nJT0awHsLr2ErVu4aElos/bdh0aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwg7nt00aRyD+j6ZTR6/lLJfRpJ0wHwYDVR0j\nBBgwFoAUkJ7hDUi1WCtDnxJSy32kpHvIjPQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMhkqPdEAsPY\numSOHY75j2VdzEc/ZPzDVCysKjcpZ0qWAiAw+S2wVIiwKSPAW9RH+sRbdLVjr3gB\nc/vw1eLjTewpZg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQzGeJNk7FoucZn/5ZDfgIERMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjJlYjhjNS1jNzQxLTQ2MTMtOTNiMC0wZGIxZDk2YzVlMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASP8nRpL3yK0fwzXFQDB9ZV07IxBJkzAOtJDrWburg4hPJa\n+R9O0XSKfN8XITTl8jQcOcNjZ6JVG7du2v3a1ioYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkJ7hDUi1WCtDnxJSy32kpHvI\njPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVTn0mHNsly1nCnrzaKIGoKuHz+ofqeMRFwujPcFDEwsCIBkfbDoMmOJS\nEcKWPa9FQHzK/ECTdrthf4VaeAL46ern\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAcKAAeMa4vKn/v5Gfe7VaCkCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhjZWE4NGMtNWUxYS00NjE5LTk2YjMtMzA2YjY1ZDBjZmYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzhmNDRhMWItZTcyMi00M2EzLTk0MWUtY2NkNmE5MTc3\nNTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXFDi9RXtg+Q7czNMgAgkzC98\n/A+t96aVhdcLiPXU27Rh/CoNz1XXjccLhdjZCWx9zvm4o90mopSNxq8rkhmsQ6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwg7nt00aRyD+j6ZTR6/lLJfRpJ0wCgYIKoZIzj0E\nAwIDSAAwRQIhAL5dBfS8bcJt/m5MvI5zLFNO8NaLy21R17M+qRCP86YEAiAIdiJf\ncD6A34YOKTs8x2r87ojCuvj8nf4SqZjWSAT4VQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4402", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4402` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAZGmQNsAYxro5r1PwswFWl47MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiNzMwYTk1LTMxNzYtNGU4Yy05NjMxLTY2OTQyOTlmMjdjZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZhOGNiMzItNmZl\nMy00NTJhLTk2M2YtYzA0OTZmNDczZjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ+mbq55n20E4SQGM8TOUlWZ3OgRJkLgljD/Te4zJEDcFo7YsmBAyKWKCVzcR\nTfTNZ5O9mjelUeDVIgbvD7Yz0KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7bBq8OgQv/+BF/o5iznYhreFnmIwHwYDVR0j\nBBgwFoAUlSWX5u33v4RxNI++KYELLKALH3IwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDgLylCQKeo\nxvqkrCRzqyu660vrgOuHSSSlGJWwzFFciAIhAKaGEUyf4FH5iDk4uct3NkY6hzTB\n9CuL+TRm/KAQ6JEh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAap1q7IcH7KCvvEWukMOuSs0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjczMGE5NS0zMTc2LTRlOGMtOTYzMS02Njk0Mjk5ZjI3Y2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJqYqWd7BGSRgrFc+v6fkkTBpOdZolSlKnMGGDeA2vu9NJ\nyVV5bQYBrTPavMjjOKX8R6Fbo53Vt/+X2G/Wzn+0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlSWX5u33v4RxNI++KYELLKAL\nH3IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHtn9IflqRzXxmpV/P/6TBRy2Kn30tMKKs+RFxwohAOICIQC9Guytgrw7\ngBCKYTbtFQCfawUJ/qwwAvMRfNLyOwo3BQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAWLjXJueT4gmwpSttgdRyBi8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZhOGNiMzItNmZlMy00NTJhLTk2M2YtYzA0OTZmNDczZjI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjRhNjdjZmMtZjY3OC00NDFmLTk3ZTctYTQ3ZDcyOWUw\nNmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKnXoms+WwbZ5cZq43RdVfvcT\n2e7JuTuu2IfeOH9enDud7VljmSMd2V9NxMNt2t5MsikC55ZLFUdPQW2kWjXcq6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7bBq8OgQv/+BF/o5iznYhreFnmIwCgYIKoZIzj0E\nAwIDSAAwRQIgFZ7HkE/PshnqD7pycr55Vzc3dwsTIQ7HTauaUSgD40MCIQC+Uo51\na513yJP6bKbG0QtxjUFrTWO0RTzw06K9oDsMoA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4403", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4403` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATqDaOwsCiH+/it1LHpgK2e6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5YTg2MDU5LTA1NjAtNDg2Yy04YjhkLWM0YWZhNTBiNjZhMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE0NzliYmQtZmQx\nMC00N2RmLTg5MjctNjYwOTY5OWFkODcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsMY7BXryZS021+7UPo+yJx/DmXMC+5nctq6f2hXDXO2p6671dbZ+/8dx1HQu\nEt4IcVr50cnSg4uvjiZTJlE88aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURZw7kAMPW3WPBs06EtEz9nOI0dIwHwYDVR0j\nBBgwFoAUrn2jaM3Cmfnq8kLd+Nu0VOBKwS0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIG8eHvXDL8V4itBi3BtG9rTmhwOvueGwvXMFQLDLMwyXAiEAmCAumu6HsNem\nIC1z2nezjA/AlQlRgSr6M5Otacy6YEI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVnSPInydx17ctEtVognEGPYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWE4NjA1OS0wNTYwLTQ4NmMtOGI4ZC1jNGFmYTUwYjY2YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8u07STa9bDyYBrCs6svud7PFe2r+4TKGMTaOCqGJ7+kUF\n+g2sS4WYpEPpNRj3D0eM9IrK6BTGLfrfCyxZBDD+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrn2jaM3Cmfnq8kLd+Nu0VOBK\nwS0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA8wAqe/5Z8ICHGQ2cVj6uCJjsJ+x10bD8tT1/MPjwI4CICHj/wm1IfHK\nLmyBq3a+nBXrHOcV50hhCfaCkFjaFGZz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAWiLh6EOffHz2w6JuU19OUpTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE0NzliYmQtZmQxMC00N2RmLTg5MjctNjYwOTY5OWFkODcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWFiNmU2MjctZGFkZi00YzkxLTg0YzUtZTBkOTA2ZjFi\nNDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKECjbT8waAqxwYTmvPbyz8u0\ngpmWovPq2vdveHVJ6Nog6lt7BYgTp38e84Cs2xa52pY2RU3l9l05K2mEz/iwQ6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURZw7kAMPW3WPBs06EtEz9nOI0dIwCgYIKoZIzj0E\nAwIDRwAwRAIgNlyvbCh8qKuOwPsbj0gcU1VRS/wunRo1GM84uwk1SioCIBlwIaSu\nvAxqdGMnzpvaz+F2rjrYgNrXfmmBTBmVNsBn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4404", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4404` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeYiUHK3psEt+FvrNulzyTXMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxZmU2MmQ1LTUwZTktNDMwYy05YmE1LTE1NWYwODQxZjYyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU2MzdhMzEtNDcy\nZS00YmM5LWE5MDYtODM3YWZmNDk2MmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9ezBzh0SInoQmCViEFHrGoblrWhNmoiqgaI7pdkulKHY3ldJo5+zS9Gq6/lP\n9XrUoRnE9fpyRa+By/X5ecT3/6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOXYo2daBx8SvhNNK4V0zc15Vdq0wHwYDVR0j\nBBgwFoAUlC4tXTufMVKAAtZ5NcS3Ngbr558wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDR0UOAGkuUahKHcc06YCWjptx2GqX6+S5CdQMnO3R75QIgeMfYAZrRkVuG\nP9Xepe65XrDufPWJOMqgwDbjFyb+Pr8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAecanZPOTGSHqBRGEJkOnuvcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWZlNjJkNS01MGU5LTQzMGMtOWJhNS0xNTVmMDg0MWY2MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzwIcyIrvm4d9DEWm/AglW/Iu2yhBnhCi4nuLlIx4RFcH1\n6OXwJRdhDkX5oIeCrLRB+bhYBxGsyT1KXCY+IyCVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlC4tXTufMVKAAtZ5NcS3Ngbr\n558wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANfuj8a2RDCVQGFcPYo4GfXHRXyIAZdEg/WxRVJ/jRJEAiEAhbKlU6w/\n/MGeSghtAEjp3OdhUpapt+muTbptPL/v4gc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISASlucQ/sSpGbUyRS7+Fydu8yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU2MzdhMzEtNDcyZS00YmM5LWE5MDYtODM3YWZmNDk2MmQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzI2ZmMxYTktNGZiYS00NjZiLTkwNzItMjA5OTIxMDI0\nMjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZg5TKcAja/BBAhK+aepEm9p3\nJO08dFzNszBe1p22c9cG8VISfnQJlY4b7WrbH9zQGte4DyTCsUnYPL8ZJXXSX6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOXYo2daBx8SvhNNK4V0zc15Vdq0wCgYIKoZIzj0E\nAwIDRwAwRAIgdX9etNvbxg3XdEPxCxTXoX/TpvSkBfY5+cvF5W34iBUCIFIltSg0\n7MmVLwnBfWsnjSPQ4yso+GpETNF4HETzk2w4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4405", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4405` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAd9t5h6CF3S6FgwuGF/w9ra5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZDc0ODYwLTc2MGQtNDlkMS1hZmIwLTAwNzIzOGRjNWRiODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzI2MThjMjctYjQx\nYi00YjhjLWIwMjItNTVhMTIyYTQzMDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJz5b4dTp4iTmeR2WjsJxTTmVXZ+8Iqx44F1WIZ6h7PXiCoj6KM7zZaKEkjAj\nOT9/uYw6u1BHwK7ISIAnzNdKiKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTb1Ey0W8FLs8y5kBVNqoUdtBCBIwHwYDVR0j\nBBgwFoAUGDUCxiMegwNMwubHGXuqz7D+P88wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGhU\nVRGepsZkcY2YMXHSsaBfY+cl0qDoy/20NbpgySVSAiBj0GhpXEyqBgWaUQg4gD9z\nFcD7syzSVoP5+lW3Kec7Pw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdb4rWbgIByL+cJWQuSQOKN/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWQ3NDg2MC03NjBkLTQ5ZDEtYWZiMC0wMDcyMzhkYzVkYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6wIovPrnz4ODjQ/TuwlSpybRnB88WOwwK6F+CyjbOLKa0\n+9W7zl+rOEMjmLqhPJpcu+qQUWpOarBFPrYuhgcBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGDUCxiMegwNMwubHGXuqz7D+\nP88wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL+WNPj4I2GpjJ8HC+tL8e9TYi6MoF2TrkM2J8QrT5F2AiB8kx2spQL1\ni8403LQQeq9yg4oYyOfFM/QKF/v8olkY2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAX69LPwop+DqruXNB6kIwATOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzI2MThjMjctYjQxYi00YjhjLWIwMjItNTVhMTIyYTQzMDMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGVlOGZjZWQtNDZlZS00OTU0LTk4OWQtNThjODk4N2Y2\nNTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOxzm3WoZuDwlITG/yTo/HoDP\nm4PKhGfQDinO9+Rqy9lBVnlnHER94wTOVO8qepqgVzgFu0UirircgVDy1ewkJqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTb1Ey0W8FLs8y5kBVNqoUdtBCBIwCgYIKoZIzj0E\nAwIDSQAwRgIhAMoxWpeAXWQy+P5v1DxqDZWCgWNql2WQbYmsw7rOA3YoAiEA3f3i\nnj+QBLWcqgx5bHc1W17xKopf8nZk/aTZfqfZW64=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4406", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4406` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISATCdnLPKj+oTkCTWq1zu7MSeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNjdkNmE5LTA1MjMtNGNmZC1hZjgxLWFkMWZlMGFmZDMzODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc0YTYxMTctMWUz\nNi00NDY4LTljMDktODMzNjgyZWJjYWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6ybGylMZKAU7Z98RKo1ZoAyfRTnyObKCcWqcyjtwrk+0Eb921wVs290LM9NY\nuNPDDGlYSK8ztHi0AWp2TVVTXaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM37xpMyHYbmGrgwuwp9EchZUnFAwHwYDVR0j\nBBgwFoAUzYh1vvvpApKFpQe2zAJzkH/pxo4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCQfkGE2iZ9KEAzk82FL4fkiDEWoq3sNs/R6pPvOolwcwIhAPhM\noTtcWXBVUCky6QQSzjwbd8wVAdNE47lVLLC2KqIn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAerCkgX94MK/rcgsrikc5xCEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzY3ZDZhOS0wNTIzLTRjZmQtYWY4MS1hZDFmZTBhZmQzMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSxL0NuYJ0e7rW/O0gSVNm4Jn9PAsrQHQu4KjBUSU+m/Ed\nlK4RWMfwMYNmCScliBzSjQ/YScpj37C/Uj2ILZ+Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzYh1vvvpApKFpQe2zAJzkH/p\nxo4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIEpLaqL2g7gp+nRXc4gZbajquL/fPOsz1BJELvVnYxYAiBQ0J50IOdG\nNG2d49biBbir3QiCxI8Dn8yhmFc64rTtYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAfGZfVyvpfXOTX3Pj79Z95amMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc0YTYxMTctMWUzNi00NDY4LTljMDktODMzNjgyZWJjYWI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWM2NDc3YzUtNjMxYS00NWFlLThmNDQtMzBkMjc3YmEw\nYzFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdq8AQWTG4MHxjBVdqQNfkOpL\naChmllspmRAFHXymqxY2gS60tb5u0/ui2+w7QEciHRVMYaYaldQfGJGToULIYaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUM37xpMyHYbmGrgwuwp9EchZUnFAwCgYIKoZIzj0E\nAwIDRwAwRAIgfE9NTlphjhmll3HKGUP5M2bOURqQ4FplUtX4G/mk9pUCIAWF8S1G\ndp2RxVNknci+Z0B/Q6su1jmqMbnPdmw5oJBV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4407", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4407` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAVtzry+L9T1EnjA7pVL78psiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjZDEyOWIzLWMyZWQtNGIyNS1hNTY4LTRjNWFjYTQ5MTYyMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzFmM2Q0YjAtNTI4\nYy00YWY0LTk1Y2EtNzQyMWZjYTk0MzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEpF4cZvfxj/PIPDNZWgyjIc3xbueZuVMoUhrppD0uiF97Sf2LXycLwvsy612\n0awGvxbRyBiz3DzvC1kcfkLXXKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz+ula4FZ14FNvs6uclKHCCZCtkowHwYDVR0j\nBBgwFoAUkjzdDj/Hmx4RsNqxLXlkLjFk4tcwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEgdXroj7A11zwD6yoV53z3n39jY/d8YEM5mAjt09gbCAiAA1VDB\nyLH3pGubWp1lvKqrBXCZ010GjBebtc+VQSTMEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa93bdS0j4vML/bul4Oltm1/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2QxMjliMy1jMmVkLTRiMjUtYTU2OC00YzVhY2E0OTE2MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARj5lKCDNgJOgjjrFe61sdwQJD/OPE+YKbHhqvn8isXOk2o\n6GtePBLpbLPdPjYrCxtgP67gqQkRFhSRJFzGpsl8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkjzdDj/Hmx4RsNqxLXlkLjFk\n4tcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIEpZEMRHhPfGVezrsno7F6fBlIZiQnnELPZXhAXF+T8CIB22y8i4A2yI\nti4e9Aggsye6FyOadyHyosMmOQrwLVGq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAWeYUb2l+5IF5iAtZMNu53BhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzFmM2Q0YjAtNTI4Yy00YWY0LTk1Y2EtNzQyMWZjYTk0MzQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTIyZmI5M2QtMzIwNi00ZDEwLWFlZjMtZDJlMTQyNzBh\nY2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2yLx+UrFqln0Y9++nW6NK4Kc\nAc84fJFyDRWwvjMWaSmNnM8bxHJaVPMWHh/jPjCKC7DIZk2f/LpHSMHAYgsjvqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUz+ula4FZ14FNvs6uclKHCCZCtkowCgYIKoZIzj0E\nAwIDSAAwRQIhAIC4wJnzZUeZ1ZBa6f2uSRfSYUorvHXHUSGdS0/o1S9bAiB12rgI\nO1ePLz+MLlIdFGzBTwcnLF0tnA9fW5laaU1qgg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4408", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4408` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAT1gKtVqSToX6RECVO6qCBSBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZTlkNGFlLTQ1ZWUtNDMxNy05NmUzLTg5M2IxMDIzNTk0NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZjYTVhMTctYjg3\nOS00Y2NhLWEzMTYtYjc5NTBlZmQzOGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsN8DmyycP/ojI08khY/QkD6tfN0plU6WAChWrjCIL1/AYEK66McY4bxp3GrK\nyQDyyd2ZVE7C5NyyvuDhaHTFKqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRDUeEM5Q4WfeWjE0JCY/zNcsn+tDAfBgNVHSME\nGDAWgBR589y2pImMW4eVurH3Uhw+/l0UsTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDTl8AKo0uuOOzR4DM173xFmayQ7A9M2\nBt1jZRuePVTBAiEAp4cJRrnFvJoUYYkNB4kfYVwVXrJKM5KjCWG1EqHRtio=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcgVQbLxe6YG+atx+CSJhdtNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2U5ZDRhZS00NWVlLTQzMTctOTZlMy04OTNiMTAyMzU5NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgXPdcdUQ2nPIGFU2SieORZjOCpfhp2FrhqinKFjLbLCJU\nS6QZa+pjn+5y/l1M/8D5148AMjYasKa9rczuEozPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUefPctqSJjFuHlbqx91IcPv5d\nFLEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIGqQX1Tv4tWSqk/J4i2p2h3lXCjLuBghzT6OclJrRfjAiEAhAnu35QJ\n2pVMBiJsylQ77H858ACUEpLOqHVvdPS0mjs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZRkFVQZAfWm7AtHxMGT56kEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZjYTVhMTctYjg3OS00Y2NhLWEzMTYtYjc5NTBlZmQzOGYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDE2MGE1OTEtODk5Ni00ZWRiLWIxNGUtZTc0OGVlMzI5\nOTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/XrHxPPFjeBLXMDYKL1UNBAp\nadTZ/33lJO/xV9tOkOz5f4qQf3kV96Mj7qvPVGminl/ylcBakR7eURPBj6DJeaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ1HhDOUOFn3loxNCQmP8zXLJ/rQwCgYIKoZIzj0E\nAwIDSAAwRQIgBYcnGPZseF+gW5FS7dac/ZIzhoxdZaUVG5vW0BZDwBQCIQDQbicZ\nwVn/cOquD9mSkK3OZp8h+2hmLPH0mHwEhUji1g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4409", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4409` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAY8rf3uVta/heH0yBLgwwyPwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiODVkOTZjLWY3NWEtNDliYy04ZDY1LWIxODBhZTcyZjM0YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJiMmIxYjgtNjIw\nMC00MGFlLTllYjYtNDA5ZjFmNjE5NGY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtxkHvsmeiwIUetllLU0Huj82NedCJ2YLKvmfOHMO9XIX3BGt/Djy+8Byvd2t\nA6/biXz6pXq3AXVgfEx7287x8aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlo5RrsEoViUaKHLav7RK8h2UP8gwHwYDVR0j\nBBgwFoAUHKSb832FmcIw6cedhIXw7z08s0YwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDUDDoY24pZ\n1rueWJVLynpIuZhvo7BH8ZmzZHzD48HgIwIgdyOSppqq74azyNXe8jCmFcaXMl1X\nfEcb/XJGLqPWyLE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX83+ZvZT8fHHXOL9Dy5g9MyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjg1ZDk2Yy1mNzVhLTQ5YmMtOGQ2NS1iMTgwYWU3MmYzNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBsDtEiK4PciJV9UGrLbtMLLjF+sdL4VJ09elOxLLK5Ugp\nePlMmo+NZ0dOcKQ0bDLayjnprRLJABhvzMo76cwTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHKSb832FmcIw6cedhIXw7z08\ns0YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPdQYLVT0uaPLshke2OP0gozBmLr2tYvBwgatT2GRywrAiEAir7mFrBu\nAZNID+xV48lsEQEL4jo9wBZvpxK0d73IZTg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfln8aT3c0qu1gwEzplVcGbKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJiMmIxYjgtNjIwMC00MGFlLTllYjYtNDA5ZjFmNjE5NGY1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjdhMjNjMDktNjM5Mi00NzM4LWFlOGMtYTQxYjVkNTI3\nNDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5KhcWYWfWIqFg1QC82hdrnub\nJaKocv/3qQmEpD2TVR9/O4Syv3wpgL7PLjpoa+yWwYIvPXcQQpeN00lpIDIo86NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlo5RrsEoViUaKHLav7RK8h2UP8gwCgYIKoZIzj0E\nAwIDSAAwRQIgc3jkp32QwmpXuEAz/tkJrsPk/mDbfrkTslVLm6Xm2dwCIQDrWfX4\nmaxH8Dio5PJLd8YKuhdTM62M/4eT7yUvYIDgfQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4410", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4410` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZ9U25JJpykzbHsxL2ymnzaqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5MDBhNDFmLWQ4MzAtNDk0MC04NTY3LWEzODNjNzMzNjA0ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVlOTViMGQtYmMw\nMi00ZjBjLWJlYzQtNDhhZjA0ZTMxNWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeeDsyniRZnvEwlHpWHcT4xJcpJpYIruoY5PZo4KKpzEUFNM2lA4eFLJTEhYh\nVUZVNHIX6Mm4uh1e2dxjsiQLsKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURaAsJCBRByr9JYMDy4zkSgo1ehcwHwYDVR0j\nBBgwFoAUgnPzwHynDmwxmeESjssgyR3+T/kwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDQPhhtlEjh\nni6gZ0PTSJX/AcWUXhnzqJGgucwKKwDQlQIgKQ5nksrG8g6iZMhyfUIH3o5iOVeU\nAoZbS0q+OF5Xndo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXhE2ue6oVVBjQp1xyY14G/uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTAwYTQxZi1kODMwLTQ5NDAtODU2Ny1hMzgzYzczMzYwNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARN/DkNFzVdBogI7Meoyt3Tw0hNA+2XhryzuHsho6ZrDhrg\nEbCzsD2aOr24rBfEziZTrkAe023wlX6sVKKuYLHxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgnPzwHynDmwxmeESjssgyR3+\nT/kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANjQpaVarAadRPHMH5RErKsXiqbW9uXK3Z2kmqRoz5nWAiEA1It+Zf2G\nPdNUkbO3nVy14D1HoV3LPjYJh2Aa2gMrESE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAZH2ziGwe4rld9M9uVw1+n23MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVlOTViMGQtYmMwMi00ZjBjLWJlYzQtNDhhZjA0ZTMxNWJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDU1MTFkNjItYjliNi00YWQ4LWI1NDYtOWFkYjQ3NjFj\nZmRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHIvzzVVj+cSff7VIu5o8rm8L\nhGdNuunq9tlNbtnzuud4p6glfY5xVqLs4MxlIcDur903sBr97wawMNWowKGdkaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURaAsJCBRByr9JYMDy4zkSgo1ehcwCgYIKoZIzj0E\nAwIDSQAwRgIhAP1FWWr1wOi8UJJafOpJPe4c7fdaRW6U7W5p9UEx6rLpAiEAjgQp\nfTk70htJMiHnVoD3BIQwhN7Pg8ZjIHM9dmIqshk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4411", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4411` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISATDSr0yFcx1rBHYoZXSjJZW/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4MTgwOGRhLTQ4OTEtNDdjNi05ODZhLTI4YjRlZmQ0YmQwYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM0MTk5ODQtMTQ1\nOS00Y2NmLTkzODAtZjMyYjRiY2FjYzA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU36NPRWqMqy4wCHRNmbjLkZrxlxiHTOtL4DzKCiRPxwIcNeeMjx51kmLbHgB\nD7RHVAprPY5cRV/nCg0x5+GdM6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4BM/OgB3Z/8fwnYu9rzCXtM4g24wHwYDVR0j\nBBgwFoAUEiKPA/1K7i2KkiVBKpFLxJmagVQwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA4nQh9tsg\njr532CHoUNIpF3wTyvIDoJcstVR/JgVleJQCICyVsAs9AlDS2AcLwLLCVyDRDr+T\nEgkxgMcagnYlX093\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdDIelciX2b+FY3AoipeOnFAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODE4MDhkYS00ODkxLTQ3YzYtOTg2YS0yOGI0ZWZkNGJkMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzVFy6fF/TD+8E1F3S33WGqRic3D+wO7soMByuC/FZ9t5e\nyRaFQIyBReTRPGZzL7WTJs4yfUp3IyHwpBr2zeVso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEiKPA/1K7i2KkiVBKpFLxJma\ngVQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALjJnQXh8FZUlK+IFvDEzAeVyLbSMF4MtEz8Zd/5W4koAiEA1VwQhTez\nHHMEgK3go6rRL+3jX4A4119Tiu1BNR9wWXk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAVzZwuwp3RGugdVJ/DJlYpdAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM0MTk5ODQtMTQ1OS00Y2NmLTkzODAtZjMyYjRiY2FjYzA2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjkxOWQ0ZmQtNGRiNC00NzUwLWExZDktYzU3YzA0OGU3\nNGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFTvRGUcWjYx5xOqiJrvtBKAM\n703P2YSPJ6n45jKXIpKaMmfYtK5E7cJIIBbEjrUYucmuTexN0DCNpyGXlpcIUKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4BM/OgB3Z/8fwnYu9rzCXtM4g24wCgYIKoZIzj0E\nAwIDSQAwRgIhAK+w+ey5KZ4KbOgHsc/Dqpz/XH/se6S0K+X3vI5h/rTsAiEA0SSy\nQdOATntIgmRX7jd62Z2uQrx7yjtwyZhHKh3HrPU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4412", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4412` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAU1msWBjwhKdUy5aVwm8XJ/3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNDU0Yjg0LTM5MGItNGIyYy1hNjJjLTNiYzdhY2E1NzMzYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDMyZjQ5MjAtOThk\nNy00OWYxLWFiNDEtYmI0NDRjYzA2YWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbzGpJj1N13nLKiOw0rdUAvVHtjYPuhGUOb0i2wmJ17qwXPIMvC2ukAJwp3oe\nsr4+5vYE9GqS6PcRmg8hRcT6VKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9BT7FMSErkGzGlGY0jLzfydxTWswHwYDVR0j\nBBgwFoAUGW+gK4YSTThSfAfrNMkN3wU3vmEwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiBIdg5rVk7rqtUfUQX11vfO2QvDRSsyqGFEAIlSbkubkAIgW4l0mLyKM7hB\ngOFr9EfSQfvgFHwKwkVlW+i3Zj0VnJY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZtZxeCrl+uTuG1X6IjDwFF/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDQ1NGI4NC0zOTBiLTRiMmMtYTYyYy0zYmM3YWNhNTczM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdhJcT179o/r0taRjikGHNpdfGDCHuM7T47LJvuvvJgR6s\nzDOeGnM09/8DOMO/ZZEVVtQMblgTxqosx+3gRjrko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGW+gK4YSTThSfAfrNMkN3wU3\nvmEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPjsC1zv2fYVmu5Hf6YAUEFT+tLCTDsFtTW87J4n0e9fAiA9EQz1EXQT\nS69QsBRM2nSyou6jlVeR8YA69AKdVemvxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAcwtRyELYldfGtCQaxfh08iuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDMyZjQ5MjAtOThkNy00OWYxLWFiNDEtYmI0NDRjYzA2YWYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZjZGEwOWEtZmY0Mi00MmI1LTg2MzYtOTdkODcwNGUz\nNmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETRQ+H3vLXOieEE2wB7v18zod\nIGOfXmTtZxgEhduOd8qfnBd/h3NjE23cXMPn4/34N1n5OAtSAFg0pfdBOcK8fqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9BT7FMSErkGzGlGY0jLzfydxTWswCgYIKoZIzj0E\nAwIDSAAwRQIgXjw/MlQDb2yTQXw3pOwKtIph24SLHu2uMo92nF7r3skCIQC9krDM\n8WPvUyxIalW8JkRE1UIa+coC+F0R0cOsEA9Rsw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4413", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4413` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAaFjkpxYmEwoROD6yud+pgogMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmNmE1MzExLWJlYjQtNGI5Mi1iNDM0LTQ5NWMzYmMxYmVlMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdkMGIxMWMtZTgz\nZS00YmQzLWI2MTUtNWUxNmVkZWY0MDNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKxzPzbkNfgH5Y2Rav4e3WWHdEiDeUNrC23ZFxOseWjSNDG8ZMerUX+ZcNQMS\nDfgOe4C5+9QsdLJqAqZ8DTgni6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXTZpMvWk78CiR0DjQqNvtAUyhQ8wHwYDVR0j\nBBgwFoAUed+Jf5CZgx2/9mHOE7YxMTUBmmIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBfksgtq/QOJMCzznwmbQNdKDjO18o185J1KciMnLfJFgIhAOGabeqSfv1+\nFtA9pZSGVO3RhjfA2J8IC920KDWPqDDE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZx5nX7KMkuZqRGfXeGTvBQDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjZhNTMxMS1iZWI0LTRiOTItYjQzNC00OTVjM2JjMWJlZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQk+Fcq2vOLaUw7h8AeXECziE5D/cRLWrWEIo4iRKLpfeV1\nwKgeB/v9kwxg6vX8Qq/zxxPJIvn4EqVpVSNL+Pguo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUed+Jf5CZgx2/9mHOE7YxMTUB\nmmIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSLuUszwAuIRT36rmTY7QWyqHkq5mjOxshQqE1BTTLsECIC9EYjE8+kgn\nrmWlFYrsl9a4uWLrDJfAG38hXkiRy076\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfdr0/e0EARcARwmBST0qW2tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdkMGIxMWMtZTgzZS00YmQzLWI2MTUtNWUxNmVkZWY0MDNiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjY3ZmU0NGYtMWU3Ny00N2I5LThhOGEtMmE5MTkzZjdh\nMzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJe2nnJFU1ezBbDa1EXY8k6Qh\nJScOksqnb6UX4iHnPNaVd3vs00k+Ji3JYQ8qInPm0tiPZ4kADwQpKQyD+VpPQaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXTZpMvWk78CiR0DjQqNvtAUyhQ8wCgYIKoZIzj0E\nAwIDSAAwRQIgONpq+T1Nf/J+vBvcpkx+fsPX5qdeG5+U1bxHlWTpURwCIQC0evba\ndWkgmDPChtwnp6xatHCyBTU8JMyCcTC5CZ8c0A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4414", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4414` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISARFdHNgYaVoMC4f4IPRj5NK3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5YTliYmM4LWYyM2QtNDQ0NS04YjNmLTY5NTI4MmNiMTMzZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzYzYjA1NGItMGMz\nYy00YTQzLTkwODMtN2JiNWNmNjIyMzI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEge0JMh4kuyHcZJ9epLD2rvQFnUCcQA8bcLXEhZ+XUAEm75qe1+AR/S7RP8aJ\na+mlmAn2CH//NVndrfZpUtc3caOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUftCl9HpDo9FrZTZXSYk9xoTSChIwHwYDVR0j\nBBgwFoAUOt0mgNyCbPDEPjANuo2ychI1ZfYwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBE\nIduVUblGGEPsU2PqSxTBepJ4NzIQ4uQB1XSPLDCYIAIgdPrtrYoJPt2NSwmcXK4O\naVz2iWaKGfWLVSCE+cJH60I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeU4qkID4lQTAsfZ98Off6OSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWE5YmJjOC1mMjNkLTQ0NDUtOGIzZi02OTUyODJjYjEzM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSFYeSbgvz0gVzax4UddsP0I7Ixl4vj3gAxknpsCqhYfSP\n/0Yn7N3s2bS5PJ0tweSoGrip3e+NXRqiwj0qEfr7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOt0mgNyCbPDEPjANuo2ychI1\nZfYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANlxg3gVHS34GTpf47bFdyyJ2bcv90QYha/COENXuVmkAiEAglZHk9kf\nmamOH/GEyXOEtir7tAtarTKDGMxed7AjSro=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZnAL7XCFsHA9pUAEvJWMwS7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzYzYjA1NGItMGMzYy00YTQzLTkwODMtN2JiNWNmNjIyMzI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTQzYzVhNzgtMzk3Mi00MzkyLTg1NzYtNjBkZDU5NzU4\nYmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWOs+Vu63pGvLHxHrgtc3t0YP\nnzWAWPXDsKLqCu4UjYvKrB6D8jtlDc3LCVh6dNSAi2qfhT+98kOTYdFeCcXOYqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUftCl9HpDo9FrZTZXSYk9xoTSChIwCgYIKoZIzj0E\nAwIDSAAwRQIhAJUfCGaOOmCBcPg1To1/htiyYkwj8HsLPVqKtXKrYadUAiBFV+oi\no8b8AoJTfFLrzeXajlx4ARxcbWBspeEBlpytNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4415", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4415` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAW6VBZHU+D6qPWhMIzD80SN9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4YTcyNjAyLTFkZmItNDdhOS1iOTgzLWQxNzg4NDk0MDFiNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYyZmJjNTQtMTJk\nZC00OTRhLWE0NTYtZjQ0NThkMzNiNzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGT7qM5AkE7nLMoA7rQlW8HhUit0133GEEvfx7KHauwaQiRVpXKEKsZgVNSVj\nmlZIIVGmhUc0aiyqwZN717uDcqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6J2pfVlpPxWBHNZ2+bdPObmtXrEwHwYDVR0j\nBBgwFoAUAnTGAwjqpWhQ3AogOjtsr2eVLikwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAvop31E2sQeDFJX+a0rqH+oWVLkZXM3As5JN5r+6Y6mMCIQCS\n67cERmNncHVnU3gplGXbca+6+z46Pug8gHjXI2SbdA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXv0bPtLIjCtCMz7GIauN2xsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGE3MjYwMi0xZGZiLTQ3YTktYjk4My1kMTc4ODQ5NDAxYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQc4vl2Gm6CSifXWJPVLf3+iGi1UMmzY/vg8orssFU27viy\n1gr7kRgTFYQCcKOc5qIuSCUbzV7jXTj7yjZHePpTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAnTGAwjqpWhQ3AogOjtsr2eV\nLikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM09bqUMNCh7vrTnxzMN2SJTrF5C6xnUUwr20n/hLkq4CIHCgRy5uI9tb\nvDK07sgMnwya89qcIlENA2p+hmqwWObx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAUxel9iglYTbT4PnwWzstuoWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYyZmJjNTQtMTJkZC00OTRhLWE0NTYtZjQ0NThkMzNiNzNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGJhNmE2ZjAtZDJhMi00NTVkLWE4NDEtNTU0MjRhNDIy\nYjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPMEZuohv+3424U4diwiBStZU\n+y5Ey5zc2v3X6uSHhPY4g9++P1rT9zRlg0CfdbJ5Fyuzmynk3kwwtLM4syZdy6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6J2pfVlpPxWBHNZ2+bdPObmtXrEwCgYIKoZIzj0E\nAwIDSAAwRQIgT5uDXhMVSCkEBt5CZHxkW2xYujX2EOha0r5V/OSGvYUCIQDSDv9g\n9Snf1oOcz0uTSomZHNVnMKostcY+1EZPIpkFOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4416", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4416` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAfqdF5dtG3/bXYvYG7zhIQY7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NDZkMWZjLThmMDAtNGJlOS1hNjEyLWFkOTlkNWI2YTU1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJmZTgzZjQtMjYx\nNC00OWY4LTk0MjUtM2UzZjIxZGViZWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQeN9w0jBmtz1Nln7uitrS/+9ny12hgf1EttD5Vn2Pbkqdbk2G4R/DYcYujZL\nqUHlvOfujTkWmEi2SP0PCTaYZ6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1DnWK6BW37zf5dIW5Lzkl7SGde8wHwYDVR0j\nBBgwFoAUDEssO+woeNN4R9lbLDNSlh7LfRkwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBLQMvYl7ddbOeA3xqITXNBf0nVKlXN1NjcF4fCA+TxSQIgXfQw\nEeBOpqfDYmaQQ5PvpmTbuQJAkltmk+hjlfcUN60=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATsCQtMGoTqgi4smzDUt/bHeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTQ2ZDFmYy04ZjAwLTRiZTktYTYxMi1hZDk5ZDViNmE1NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmezUgDT0DLzOVdPwXHaspBF3aPIdig6tgjx76Kd5m3Aqr\n+0DBLMxTiSWrENiv77Rubox7+5I/d7X+dXMZ7Tl0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDEssO+woeNN4R9lbLDNSlh7L\nfRkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIvbiJ5U8YKwLy7W91I3qUvrSC5SQQd4OvjgExL6p3XUCIQDYuAqvX7mU\nOdEYm3jcwW9pt7Rln6/kirEM+7UixUN7KA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAVYhHHRtGMTNwCrv0ZZOIFpQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJmZTgzZjQtMjYxNC00OWY4LTk0MjUtM2UzZjIxZGViZWU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDE4ZWViYzEtMTM0NC00MWZlLWE3OGItMDgwMjdiMjRk\nOWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6jf1XLItt57B7Os/QX9m43Pr\nlRPNI/E8xw53Gy1AmgwZ5cRiWrclNKHEZxd0mt5lRP+2Cfc5mG/ZeyL5xQ/tZKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1DnWK6BW37zf5dIW5Lzkl7SGde8wCgYIKoZIzj0E\nAwIDSQAwRgIhAKLq9/8mcvXQ+YNj4O5IcPTKg+Ia7CkSJyftyAIFk1b5AiEAh0zn\n+SwKSrNoeSf4dPiJLdH84zmsdM7Qz9tbYgS6nXo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4417", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4417` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAdbaDiuUMeeJAqfO5V0rFn1FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5YzMxNTA0LWI4YTctNGU5Mi04N2NmLTlhNGE3NWFlNmQ4YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk2ODgxN2QtNDYx\nYS00NjQyLTk3ZTgtMWJhMGUwMWMyMzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL3F4mPfdpwSgCJd0rEhGfhdjau5sjgwQEABIIj6RP13G6EvaxP6eWXJHeP+r\n2/C/TnYlJk9IoH47nT+hBl0rvaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjcc21lYDN8ARFe0GfoVltMFOH34wHwYDVR0j\nBBgwFoAUUI3xDgkGvLwxJI7wWT6ovsDZOncwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAnhFjqa9W0eoi\nJhmO+9F4CTntAC7u4+sSFvRZHEhjgxACIQCqaJ7W0vr9UDeVJPkk53eVCJri9oFN\nQhOIkd1rnYLjYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASh/WJUU1aL9GZR/wCZDaVZVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWMzMTUwNC1iOGE3LTRlOTItODdjZi05YTRhNzVhZTZkOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRY6RpZ7gzlkmlq8jD6QTUHmhwju6heD3h1EzmuVaXQGVP\noU+TeqigRUnEcZx6mJpIPed6+CXPEzPjRZ+m4BdHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUI3xDgkGvLwxJI7wWT6ovsDZ\nOncwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeHA8hnmq8NxpDoYneaAVHohTtg0wJYe1qIlMM4DzGeICIHQ/qCyOJljS\nubkcgAfv5ujAV0qZnrGK4YyB6cP9spnb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISARf3lZh3wwmZxPbWi/fQ1sOkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk2ODgxN2QtNDYxYS00NjQyLTk3ZTgtMWJhMGUwMWMyMzMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDdkYmJhYTItMTdjNS00YTk2LWI5MGMtMzU0ZmQ1M2M2\nZDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE86uLUvMjXYhK8klNsxeqWx88\nWX/s3U0zbtSo6SMjZHXl7INPW4LOLdgR/o41oDgmxFfvtkhJNw84z+l52NIk96NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjcc21lYDN8ARFe0GfoVltMFOH34wCgYIKoZIzj0E\nAwIDSAAwRQIhAO7n9YC+hkXr4vVROxvT9EDJ7TmDpxZaTg2QMP8YlZkGAiBjX5aZ\nohDLWz0Ce4GteTAkmWinUul2TOlKHrzfCXfLhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4418", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4418` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZPKTfPzIIZPwD5N92V8suYcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkY2YwNjkyLWJlOTAtNDdjZS05NjVmLTNhOWY4NjFlNDAyMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODIwNWUxZTQtMzQx\nMC00Y2Y2LTkzOTUtM2VjYzI4YjgxZDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3mzeWQke553ard00pw8B+HzyU1pRcqdw8QWQrBnl7xKQUwLib6vaw+j24kus\nnzrgvQfWIYQ+BqMWmoHO+KsB0KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgbOt/5lOv7bzzMRAVkDlyjI5qRQwHwYDVR0j\nBBgwFoAUATNnk35/ZjNaXrObyiUJbKAPrkkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDm/VkXixyWawV1sMlo31Nfkg+UK/boC5DWeLiJcI9cZAIhAN0eRF/B73Zs\nZBC+9WSz+RC37jd4HW8E2KGzpb5OtkL5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR9wrriQObqGmPDgwjriuSQ/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGNmMDY5Mi1iZTkwLTQ3Y2UtOTY1Zi0zYTlmODYxZTQwMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwaPoiA/a0h1TK4vReLVi9iXNLf26Ixd2m8BnoYbvGGZBP\nw5FvHqCxuQy2+cHBq0tJlDF0ZtMbS8CECH2BBM6/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUATNnk35/ZjNaXrObyiUJbKAP\nrkkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPVuRnnGOdGGuUiRFgMqyy7iyAMiXKEBtnHPcwNk69fBAiEA1Wp0I58+\nGjT+hsNLyLnmmS/0VPelpmhzaNp/4uqf2Ak=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAQIV48XOElWByD0ZiTdqpUS+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODIwNWUxZTQtMzQxMC00Y2Y2LTkzOTUtM2VjYzI4YjgxZDVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjhkYjAyY2YtODdlMy00NTljLWIzYTktMzVlNDEyOTYx\nMzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENRMhJ/GaZPZvMsO4Oh2IIt10\nIGWFY7vrvwKxkBPmogHmpm4QJeK/VwjADuktYhc3O36GNTpPNp+T+6ld8Mb3/qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgbOt/5lOv7bzzMRAVkDlyjI5qRQwCgYIKoZIzj0E\nAwIDRwAwRAIgT0y+szL2cJ8zioT+oZAtg3NrfXeD34+8IE65rWHh9LACIHGsRzr2\nv2Wrqj81kXqAMKiOdRU3Vu6qMD3k0c79kCQj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4419", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4419` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAT+Chqp1fcWnZyuncjltZIcZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiNjIwNjBhLTUzM2ItNDY0NS05MGMzLWQyODc5NWZiYmQ0ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJjZjVkYjEtYzI5\nMy00MzYzLWIyZTYtNzJiYTQxZDBkZDJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6w15/dhJpqDrbt5ae4D/nSyAAb+3cCiEUqhd1KmFN9tBTUe15mGDQhYIYQ6k\n89baw+5VDz2ch8CeYVCEzrC9v6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo3CQDOfcmZplzEs7syJlXIpxZ1swHwYDVR0j\nBBgwFoAUF5GQlHfhEYERjZQbsKMOAs3aImQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCjv0WqfnEw+7NkryC0ShctS6qUgT+mhNkypvivKDex/gIhAIECTZYOr6FJ\nmQUg0r0Bm/YBzVHcPENprN1qL9dwomgx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ336lb3subU3r1Qgwzv1aVFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjYyMDYwYS01MzNiLTQ2NDUtOTBjMy1kMjg3OTVmYmJkNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgFlacIDAar4qikggOjo8gQ9Al3/KbkFyVRnEn7NcpoXEz\nH3snxgEawDgUOXRfMUdB5BekL20rIgxTt/fkmZC0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF5GQlHfhEYERjZQbsKMOAs3a\nImQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcrgy69FoBOTH96SDVEz3AD8ewyUh0bXiIVp3mIodFg4CIQD4j+/i1ksh\nJke7DVcz2G7RmrNCJXmD2AGY/Qz9f5uAKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAYOyoyWRrYS11TFZ49c9kiOXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJjZjVkYjEtYzI5My00MzYzLWIyZTYtNzJiYTQxZDBkZDJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzZhYjk2ZTEtN2QyZS00NTM5LWI0ZmYtYzQ5ZjBlNGZi\nYjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+GsPUqWjrPxlBBtGyULZ5vxm\nTlOZAy1nG0NYdmIKOApIZXHv9lKal4LEOn0vnL6h+qP6+LQ8k5QqLFahTi8oQ6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUo3CQDOfcmZplzEs7syJlXIpxZ1swCgYIKoZIzj0E\nAwIDSAAwRQIhAIyz1D/N8xNm6Uw817ka14wI/+VQf8ajMIE/Ou+ESye5AiBZInFS\nQNb3wiZuW11X8TVfomwD9yV5YwArpZxJeqKRrA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4420", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4420` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAZf6+N3/4vMklVAynjHkoj7iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxNjQ1ODU1LWY0N2YtNDQ5Mi1hNmU3LWNmZGMxZTIwZjUzOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODllMTY1OTYtODRk\nYS00ZGNiLTgxZTQtYmM0YjdiNmNiOGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5EqC+8sj+kkTLjwNXCVVv+w+Qasde/9jcC12XS6GHIVKNset1xsl152ETxuK\ndyjJ3gJuody/JEPt1HYQFZAH36OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTObttZzAAJcdp3RMcQcn6ihlCLQwHwYDVR0j\nBBgwFoAULJEyhkAtnlPorgJFWmjhuTknHMUwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAvMNmyUcOGePjaYr6wME1W06EOd65kL7VAgtMHHbHyY8CIQC1qhAx/6+b\n3ZY6VVDlRsIbdiX9viFFa1kBbfmJ/QX90Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAegCW5RaktGKhaOpuU7kb6IqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTY0NTg1NS1mNDdmLTQ0OTItYTZlNy1jZmRjMWUyMGY1MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXkjWx4hWZ9dkmUrh3zsqALDHJaAu9ahZ8gi5Z4PGMEGxv\nDzVN5Ra6mIxTf2T39DJmHxhdVyJ0ssFGT1DkYERio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULJEyhkAtnlPorgJFWmjhuTkn\nHMUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKQ90+mOLtMedu881lMuT9hud/FLbeHNiTgOKlzdWhntAiEAspzhTMek\nNE7pzSMlCTTbRN36Lkk9NgLb4Dph0jYi/88=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAVm6zVvDOxFW5KXCDtY2Oi5bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODllMTY1OTYtODRkYS00ZGNiLTgxZTQtYmM0YjdiNmNiOGZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGU0MTlhN2MtYjhjNi00NWU5LTliOTQtYzdiNDk3YmVh\nYjVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJJp461onEprOQL1RHFN4d1L8\nWAGcjayGlwURiJQYt2aQqKhIKohIiMzby+TVnTqZ0Td37lJrpfmq+8dQL9U42aNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTObttZzAAJcdp3RMcQcn6ihlCLQwCgYIKoZIzj0E\nAwIDSQAwRgIhAN2CEHKj054a2EiuV+/4MxKUX5iNryfjMhit32B5ztJeAiEA1kTO\nlN56Gl71zP5lJp2iatjY7rW3U8nyp1M2fylWo2k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4421", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4421` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAUMAA4skoxauTjTb95uHvLppMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhM2ExNTYyLWU4NzktNDI0YS1iNGE5LTI1OGVmMDc1NGEzYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI4YzhiYTYtZjE2\nZC00NmQyLWI5ODQtODUzZWM3ZDkyZWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEApXjnxGMP4xsMnngVuWURn0k6kEy6pa+rmhpOhZFu2/pyR9U/goLiANee4K2\nD2d6QCupjPbj2tYrWGLNUUH2jqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBsAVf/NXgRG3LEqtS/IrJm4NGSswHwYDVR0j\nBBgwFoAUlTHhfwnhIjrUORFGV45mCXtfk+wwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAJocS71XKTHd57FYfZR2dzVoYRmzUql2Y8Edtp/uGP\n5gIgXQpxzFW8r0caeRTkHGcLU8sYMIusmm3TX6dJsy1yAlE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYeKhhmEAGUH0wny2/HWB+OKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTNhMTU2Mi1lODc5LTQyNGEtYjRhOS0yNThlZjA3NTRhM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHXYAacCQGvAg6NBixCsm8vhZJ9HIXLbCOfV+GpiFh9Vwz\nQLfQPtKrmyPQW+g5uvXiUU05+pOAQSYy9ltoD7gNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlTHhfwnhIjrUORFGV45mCXtf\nk+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOmETbSl56nqRbRegk4ogTYGHtYRFKpnwBFs8/kErVPgAiA4omMkyVFT\ngmWhPS/zJU4ywN+y++RTdhnkwRgqgPge5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISARkZTcdZ4BEKeJjhyZg11wloMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI4YzhiYTYtZjE2ZC00NmQyLWI5ODQtODUzZWM3ZDkyZWFmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDVlY2Q2MzItM2Q2YS00MTdlLWJlNzctOTIxZWM3NjYx\nYWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb+5NvP9eIUv6slxZWDiBXb45\nyXFwi/MOsEekhn8xAICzD60DBFcLvpNiJr6BCNAzvOU5CdiWR7J+l9L3HE3gtKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBsAVf/NXgRG3LEqtS/IrJm4NGSswCgYIKoZIzj0E\nAwIDSAAwRQIgL6FSblOd5Wp8o89YvQtTESbC1vg+2S4Sr7SeUYKnI5wCIQCumAE8\nGFs40QjZkwsMaTnSGiwSF6ExlNmJJ0Y8GGtLew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4422", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4422` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAZCsRD+Anz/EMQv3XJPbO9sdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZjdiODdlLTg4ODItNDU2OS1hMjljLTFmZDE0MWUxYzU1ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE2YmQyZDUtMzcy\nYS00ZGNhLTg2MWQtYjUwNzFlZWE1MDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzvroEW7H0XmTnJAyZ9j+BDfXXQb7uLg1ZTz0Ufvr5ByyKVVr3bklSTVDUpo2\nAj3Ub6Q5AJSdhXGQu5EONMLvjKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaW/TxdbIia6eJ9XzsqXA3seH7VcwHwYDVR0j\nBBgwFoAU3LIECi4sUTQSdHJtX7X1aYV7hVwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBPSLzYAxfnydb7lIzEfhv8cV7Lbrj0hxvkntrTiiVo\nrAIgVs2aetqkcZJuZycpdZuhzYBCtl4ZmSKE7OVyXWOuT5w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZQ496KGVPFjRl413cI+ESPAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWY3Yjg3ZS04ODgyLTQ1NjktYTI5Yy0xZmQxNDFlMWM1NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6ERRwOCORblIHg4UJYrdmK6friupDopRBwbGSwIrhEbZd\ndYCb9eBEx+sERVDUf4ZBP/VHldP5CpNzDO8pn2EEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3LIECi4sUTQSdHJtX7X1aYV7\nhVwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOlYj+QBnxvUtAycWDDxWj/hyu30lbE4mAYESsigJCOOAiABi4PvFtnX\nf4fFJo5wsIsXVP3KH9YnfFVLbXVQJwkZWA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAdu1RNtZdEIig44oFnHubcNPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE2YmQyZDUtMzcyYS00ZGNhLTg2MWQtYjUwNzFlZWE1MDI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTA4NjliMmUtNzgxOS00ZjYyLTgzYjQtYWVhMjBiNzE4\nNGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyhapcGCKeKkbA3pwRKddgTjW\nSbADrMQENY6N0R29H9SduuCbNkTj35ejRPDtZM4atuA4Jw/B6bBmQN+R9SPEgqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaW/TxdbIia6eJ9XzsqXA3seH7VcwCgYIKoZIzj0E\nAwIDSAAwRQIgO4QxqkPJcKHIS+nZlFqZdlKgqiHCC/1W5Gj5feg6H+QCIQDZ4aRw\nhxv9blUxBppG4Lc+oPEZtPzb1dN4Wc8rqsLIwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4423", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4423` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAV71F8decK0+MNKgV58AN6mEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwOWFlYmFjLWJmNTEtNDlmYS1hM2MxLWY3YTE3MmI2ZWJiODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg5ZWU1YzMtNzFm\nOS00MjViLTllMjMtMmIwZGQyZmNiZWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8fPfmX7ejVHT6ACDFy7yL2NBE25an8Bh2N472KB0jMuP0Dk+g5LAQf7oSkLo\n3Gk3l6omr0YqZe6/zH2iDvGqeqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgGV73E1JY4xWb14Ns3jYRiK5tiswHwYDVR0j\nBBgwFoAUTPRLyhaBal2YA45cdhcrrwIspwIwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBqBAdM2sjPIxkWVVFlvnYWyuen+iS/1LUcjN7GvHqbxAIgX8xD\nOvvLA0K11cnNIUDuYS0wbRXJ0b3GiHJEEGwgGDk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAegEfjWSpKCgdTQylFUhsPvpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDlhZWJhYy1iZjUxLTQ5ZmEtYTNjMS1mN2ExNzJiNmViYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDc6XBEU9Zyl5oqRP/522JdDgIckMl6tSKEFShOrSgg3cS\n2zUlrjN0x7Z18yRaZM2cSWr5QFwhlTRaW8rFpioeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTPRLyhaBal2YA45cdhcrrwIs\npwIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKaLwJp5dP6M6l4OzdaXBSG8+G+9AVzDihTODHnCMf/YAiB9WhogyCjU\nqjn//BgleeZHQ8Z4BMP+S8fPR6XwCgsPFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAfe1r2QQthXo9YrWXD4qBA+lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg5ZWU1YzMtNzFmOS00MjViLTllMjMtMmIwZGQyZmNiZWZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTY2Mjg5MDMtOWE5OC00Mjg5LTlkMDItM2M0ZTNiMWUw\nM2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ73wJlPDpKwILah1CANw5de6\nEj1rLLLIdr6YXsfnjA6n75l6A1y2qd6HBEImfxJtpVdnFuBPalKd4tKzbscqXqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgGV73E1JY4xWb14Ns3jYRiK5tiswCgYIKoZIzj0E\nAwIDSQAwRgIhAIjKVU2c4xTsyPMpukihNJ46B1rHpMltSnQE6r9h/QXfAiEAr5rX\nuviEurKmKYW/37ihEK3990arC1cABvSrlupIVuU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4424", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4424` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAcHf9os0vX06/sLvnzBBdoXYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwOTkzMDBiLTYxZjktNGFjMC1hNzBiLTcxZTA3M2Y4N2UwOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFlNmJlODMtZGJh\nMC00YTUzLWJkNzItZmY3Mzk0NTc3YjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEotP38z6/RRWlJseZZpff00wCjiVnHbSyr/kW9sVaaj6BHS2C3uHD/yK7vZ2h\nd3LFKWKAspoZ3TagPM08eSH2fKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo5s1M5wiz5e3wTwvAXw4kHAmuk4wHwYDVR0j\nBBgwFoAUn78o7Jdvc5Ytsu6/EfXs9vTZxPIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBwHZIOhUQ2iAO3ZV3uY+AB4Li3+KmyosMD\n2BYoikzukAIgSaF4wCQw4SeIh8Djze/eOnOQjcJ+le8+ribrbIwONw0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT/yknaI7GXXo4QbtNd6iQdkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDk5MzAwYi02MWY5LTRhYzAtYTcwYi03MWUwNzNmODdlMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNWJhj8gGK/an5VaZJIMiHDAHDoaP1UcLujrw5eMUuIBcJ\nZjPSEw/5qq4YhjdNWt2FMtgS4gFAe3LJqNCotlmoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn78o7Jdvc5Ytsu6/EfXs9vTZ\nxPIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWwc/XYPYfXovu2iwggjS6WdfRmZWvrHnssZprSYuB8cCIBdERp1vGr4K\n0f/ahZlk7/+L7J08zsRSFs+xyQqkTW/5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAabT6u9TaYcZOfRU+YNEEEsFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFlNmJlODMtZGJhMC00YTUzLWJkNzItZmY3Mzk0NTc3YjBiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQyZjgxYWMtMzM4Yy00MjI0LTlmMDEtOWYzZDAxZWZi\nNjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvYGGJEv6rRYDcgfunHoovbsD\n9Le5wADYRYjWoWCNIyRDZfSfmyyULvEbyS5WGHLD1E9WR7gJo3+Ot8n4PRfxYaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUo5s1M5wiz5e3wTwvAXw4kHAmuk4wCgYIKoZIzj0E\nAwIDRwAwRAIgQ5Q65lcO107I4NzeCofHEAKbf07sjh75gg1FxYyc57ECIAxj+N1x\n/8IZqFeDVOCXSXs732bMIq9ZlIAGtXEfykrV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4425", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4425` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAVjnQiLqrVAisOt+smXWs7p3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2M2RhOWIxLTZiMjItNGI5My05Mzk0LWQ3NmQ1YTk0NmY3MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNmZTUwZTItNjAz\nNi00NDczLWFiMzUtZWYwNGRiOTg0MzFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtMQq0xaOkWlhUFSPGaAnUPFp8CL8FV3NLZbZ7nNXx0KS5NNlztsc6pVBeiul\nCw+49wG+aZ0efAyIXdQ0yCfMNKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWxGf7r4hjunORMrGpL0QNCUzslowHwYDVR0j\nBBgwFoAUEBH0CGc0CCKPQ2B/pkUXwWmyIGAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA0/JVzi21Na531axkRnWDylUUVonX0lyS\ntZwYGpO3y2kCIQCRQ2ELEJ2vWSyAir4YEN3/yndC1OfqPI1zEN6CjVsZ8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQawqRQcXDcEKUHgb/sX3WxnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjNkYTliMS02YjIyLTRiOTMtOTM5NC1kNzZkNWE5NDZmNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPJ1fJRs5jjdq/88mv2DPef8UnBepOUizTuosyTl+pU3Tx\n8uZ7i9nsfYOQkKB1dTsVPn+WRF2SvuGCXFRjQLsdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEBH0CGc0CCKPQ2B/pkUXwWmy\nIGAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALD5a5xN76qXZGnrkKG5rGrWmzvR1PqUs/SP0EayPddOAiB6Itq0OyKa\n99R3yGvqmBSMN03Fhaa2up3WAv2ywWemwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISASErW+6ddnVZLMv8GdbYDzAJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNmZTUwZTItNjAzNi00NDczLWFiMzUtZWYwNGRiOTg0MzFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDk3ZTNhNzItNDM5Mi00ZDVkLTkyNWYtM2M4OGE5YmZh\nYTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJtP0sPhz2WR52dgqIOo8pVRR\n7+swE5aKh8qSnBIbcGzSOKvjOCJ1KelfV9bkOamhC7sPDr9Vze06FQx4tkqhlaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWxGf7r4hjunORMrGpL0QNCUzslowCgYIKoZIzj0E\nAwIDSAAwRQIgT0fBfWyLr1Dqz7XtjaUt59z4dBacKLU0UGcpHMNkqxUCIQCzVA2T\nMONX9wEKWJjlcm8roGYrRUz5KH0/q25EsHbSkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4426", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4426` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISARKE+V5wTVqfWR4rFfpHfzXQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4YzU2MmQxLTk3NTMtNGFhNy05MDg4LTQzMzZmNTZmOTgwMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGZhYTRkZjUtNzI5\nYi00OWRkLTgzYzgtOWZjMDlmZjBlNmMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP907ABiREBIkIXyRK3iNYpQIAXEe7oTAPqPQcbCVnmfMCqOqFBErZzWwVWPU\nXRQ4MQgg0ixSB4ydcm+nVkj3wqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb6bTdZjsOIy2BA7xz3bs45DDjxYwHwYDVR0j\nBBgwFoAUmVCLRGDQ6qUmaZ4/RRSGFaB0dv0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAMvU2O7oYrPoGW\nHT0xAnLLVo2ti0ocRe9SF8ph5u/CjAIgLMn4JkkcFBZhDrMdK+ZPhfqvBdQAAB9Q\nosIeMa4r6pE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5yxD4haRUvvd3UpMNR9jojMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGM1NjJkMS05NzUzLTRhYTctOTA4OC00MzM2ZjU2Zjk4MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFHUVZRa/uyBnVDeKC3eJ2PDA9YnhuzNiTDlNYVrYKzC3i\ngpROPARI/vMYXF+O7NC2Ij9gpZ64Z1iG966Qr58No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmVCLRGDQ6qUmaZ4/RRSGFaB0\ndv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAb3twfM8RSftSkQ9DdWIAT3wbq6sKf7bCIe0cRuPCD8CIQDG/K2HqVPa\nFPbeQ3r8mHHM53HEALjGBBZBJ+p+sn08Wg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAVROYPGqt4FUZkqRlg2PRxp8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGZhYTRkZjUtNzI5Yi00OWRkLTgzYzgtOWZjMDlmZjBlNmMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmE2NzJjOWEtZjY4Ny00OTAyLWE3ZWYtM2ZkZDNmNmY1\nMTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDgnLtfN2B5GCR/jHDd0DifiU\n9jYo+sF9Jgzs4EetHlvIGQzXnw/tnfWG/+udB9/FDvebPY6l2pSWsjNsfOUVqKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUb6bTdZjsOIy2BA7xz3bs45DDjxYwCgYIKoZIzj0E\nAwIDRwAwRAIgML4cAN80Hi+opzYyfGllh9UAEdPJ5DXoTo0GiuJTM3ECIGseVGu+\nN0m35JFiCwIIQUGUeCzGfhONHkVV7tY+bpLz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4427", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4427` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcs/oPgii9moSMeWnETu2rS4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0OTEyOTg3LTM5OTAtNDYzOC04YTNhLTRlMGY1NjUwNmUwMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZjYjM1NjgtYzY5\nYi00MWQ3LTlhM2MtYWY1NDM0MmNhMjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErfOoRtYw0dje94a8k4gV/4kSU5iI3QRE50jQ2JXVx3RO6GnukNFZ0KhnWI38\n/JfJ2vPYnn5zturLH6Yup4ZryKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0sD6VRPFPCp/YFfYpTLCLB018RQwHwYDVR0j\nBBgwFoAUZKPvL7Uz1uA42LGmGPLgUk+tXNEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD88evadmSQqUm3icA0iIaQrGyhpTJSdtANlPwupgAmbQIgGkdHYyxZF/TE\nWmmaUav7N3TJ0/QVFUTQ3vOeT1aBKFs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWcqAk7Vrccbfn+oVNsAfG4BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDkxMjk4Ny0zOTkwLTQ2MzgtOGEzYS00ZTBmNTY1MDZlMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRhnVQDOb+nZEXQDTzks9bqxZtF2BoCYJcmbChe98hiw2M\nv7MQzq1Uwd2yCLaNExu6iNxif39iHEn19MbAt4Seo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZKPvL7Uz1uA42LGmGPLgUk+t\nXNEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNweQ5urQonWse4RE7+1gvaADhkui5aNdCTnXmdxyjCECICLsE/LVHc97\ns4lAu6VE6ZnBRKTQ3d2Em0okn15t0Tyq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAT9afMrrf0d02PxDB7477lItMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZjYjM1NjgtYzY5Yi00MWQ3LTlhM2MtYWY1NDM0MmNhMjMzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJiZDU3Y2MtOGYyZi00NDY3LWFiNDItY2JlZDBmNmUz\nNzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8RvK1TlVgYvKQRoSh0hagkXy\nloGavRjnwY79emQFk4gVmiX1lxjvl2ZPtCj0LCWyuheeU/4ct0yuelkYWftNiaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0sD6VRPFPCp/YFfYpTLCLB018RQwCgYIKoZIzj0E\nAwIDRwAwRAIgKvDAGzpj4TzNfkIlgfvkWLYckGuNsTmxWy0We3H+P8cCIGbberXC\nSiHClGbV3xrSlEvoGKwUM+oo0luf4AO1q/mB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4428", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4428` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAasOTrn2K4Qx6zIdw+xQrauzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwNzViODM2LTJlZDQtNDA2OC04OGU1LWY5NDI3MTBiZjMzZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RlYWJiZjYtNjJl\nZi00ZTc3LWFlMjEtYjA4Y2Q5OTI4OGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAyeAe1+lWLDvyCCY72GyXl4xcZfxrjO0E648g6Y1Gg7HnuNFLg9+8IkEuqKx\nuvGpl0VB5yJ106BmepNiaopzSaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyTfvlz6mLPXtr3WuUxkmHoGyxaAwHwYDVR0j\nBBgwFoAUaOqut02rQ7bcMW1ZJvCnJczXToAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCWBvlXXmHFRzePRXTiHYXKOUVIV/OSWlXZdm/RWO6mpwIgQGIhhbwgDGlf\nV0uI9r2lt8cC3bon5vTmUtaSmp4WFWc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbF4lvXja9bcpRGvqVdtDhvBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDc1YjgzNi0yZWQ0LTQwNjgtODhlNS1mOTQyNzEwYmYzM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+C3b2mNf3tltag4QsjUrLF9jr73nfNCL5nJgeFqUVcIiy\nx/GaqAEmM7Y3zKQqDnTazXczM2FoX60K65z4LcuBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaOqut02rQ7bcMW1ZJvCnJczX\nToAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYAGlQSKMYfc8MILZhtO8WUUYfBFjJ8TeY6iaIOCThWsCIEFJhIlQOYXF\nJECw/pxuPJ/U2A/ntyU7Z2QybFoYFdya\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfAerNGycPI7FEDOJUjks9IXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RlYWJiZjYtNjJlZi00ZTc3LWFlMjEtYjA4Y2Q5OTI4OGUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjVjOTAxM2YtYmM4NC00YzU3LTkwMzAtNjFjNmVjMTk0\nMDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtDwJPE7zOXywKi7DM94Q6Rmw\nduADp5DxZMOEv4j4gvePDwOS70MCOSoKDal/IALCDmn2ZSiPePbLprPsgf74X6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyTfvlz6mLPXtr3WuUxkmHoGyxaAwCgYIKoZIzj0E\nAwIDSAAwRQIgKZ6++CBzO4xHKW85f41yMxWcrc/AHXsPoEUFGsiNdU4CIQC4iBQM\nhNoWUKwuMwSRs6sjj8Ad164UXPbgl/yLUs4tBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4429", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4429` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISARIrNrvpDmX+0x3Ii9RC749CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1MjYyMDM3LWYxMjQtNDg2Ny05NTU2LWE4OWNmMmQxOGJjNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI1NzNmZjktYzYw\nMC00M2YyLWFkMjQtNTRkYzM1NmE2OGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp7M8Rixe7s9n6uaQD6JNlUk8Z5PVTfBRcnKq2PRYJkGa3Bpifjqvc7IuufL+\nJ3wVKK4aKDc5dbIqAxjaWdqDzqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgvNVZe/PWE2RQ7zFa+dHt7CulakwHwYDVR0j\nBBgwFoAUWDpD3WFz9Sbe5RhcxOjs1r/p3zYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAlYduuvc5vFBEgJ0Ryiad6RdxuDe48leOr+FkFa0SzYcCIQDsP3Cs5tg4\nBXqK7J8cHjxRM3xTD4uMlluiHm0WY8gA0Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAedVkBgkRYYTYwLjCXvKBVwNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTI2MjAzNy1mMTI0LTQ4NjctOTU1Ni1hODljZjJkMThiYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaAYYjmNlEqN9SkeAiA4HDsWkUmGB6Bp712/4vZjsc8rpq\nD7Gckn+SIhLE6Eoj/Pv2sNycYjP7k0WMnGz/WiBPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWDpD3WFz9Sbe5RhcxOjs1r/p\n3zYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVcRQqbBd8/a8MlwETcmWNcAMscB9AwvG0CPWkQjxfDYCIELwO+bi0u8a\n8TDbQHhlr9LHEzZ4so0346SXwVi6ZPeq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAdAxopQ2F+lk2TPIoH9oKmp4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI1NzNmZjktYzYwMC00M2YyLWFkMjQtNTRkYzM1NmE2OGVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjgxYzEwMzktOGRiMi00OTY2LWE4MTQtMWM5OWM4Nzdl\nOTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE8WWiiKr8VlNuN4NUl0q2O0O\nADA0qdcvkrLPov1fPQ4DMholWJqXCPxyeCk/m12vmRHSMEMGRaDaNThcomi6ZqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgvNVZe/PWE2RQ7zFa+dHt7CulakwCgYIKoZIzj0E\nAwIDSAAwRQIhAMy4Xmo8zwPCy2KW5fa0vObcZM2cr7e9J4ODegTd3UQ2AiBimOes\n3WkBLUB30by18BVJFNinyTU6wOKcedJkvUfMFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4430", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4430` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAb5noGLNG5uaZ4JPxRjT/LF9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiZjllMDU5LWNjZjktNGFhOS04OWFiLTkxMGE3NDFlMTgxMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA3ZjAzNzAtZjQ1\nYy00YjkzLWIxYTEtODY0ODM5OTZhZmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF0mK5ilCkPuCi7aTETwALlZh3v9nUYdCanLsknAa46sNldB+oT98zMWMklnR\nPw24Jz59VxHgOTupu3GFdlWlqqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU0L1ZK0dw6y30jmwme9y/0cN6vowHwYDVR0j\nBBgwFoAUJ2LzC1bVMSNOSw5T4CvWYYJHjwAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAq+l8J7LT6gQquEAgujel9ev+oll1gUDMW+PhVVyq\nGzECIDxA9Ku2kS0cqk7QZhiRY79mqMx7YA7WNo9ni/RBHmw0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWUKd+MZyDrya3QG/YQmPqLDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmY5ZTA1OS1jY2Y5LTRhYTktODlhYi05MTBhNzQxZTE4MTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpbUvCasMf60jUL6OW5PtZIFYQdvChOO82+1IjVyviOKLv\nmKQcOROrowTY5xIGCsuiz4IsDWXkW8nk2VHJMJNso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ2LzC1bVMSNOSw5T4CvWYYJH\njwAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRIEM2C4wUe/r3w2v4DyWuSC7OW3BYJ/QkuJy00fY1+ACIF5cg3vxkltd\nz/zkYwy355K8cvhGcN4ZCSF9k1XLm5Zq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAe0eiQxOjIEY7CQpnndf0LmYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA3ZjAzNzAtZjQ1Yy00YjkzLWIxYTEtODY0ODM5OTZhZmJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2VhNWQzYTYtMjNjZS00OTM2LWI3MzMtYmE0OTBhMTgy\nZDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/THZtj6NqUKmWXVY0l74Nibq\nv4SXh5Y2gmuIcgoQs3sg8/xk2e8indhCmBRutsxxop+adSTk2z2arpVuiq3Is6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU0L1ZK0dw6y30jmwme9y/0cN6vowCgYIKoZIzj0E\nAwIDSQAwRgIhAP4e88dHDr+mx8sL0qylBIRGkyYmK0ulGYZaZq0EYEoOAiEAgrrE\n4wT28aYYV3nBV3DKhssAk92Siy+z9tE2Z6fwu/Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4431", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4431` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAVz1nWydj/SsSqO+YQJUQ3z/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ODVmYmRhLWY1NDktNDIwNi1hYWVlLWNjOTUzOTMzNmI3MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDZkMWYzYWMtMjM2\nMS00ZWYzLTlkNDctZTE1ZGE1ZTI3ZDFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5M075ZxUbi7FgWfxzf2n76JBzrVgMv8N9QL5KPc93GCbz3OZzT7ys/wJO1c1\nlbhyc72ZSmciXKuiasQHqC4ViKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYh8aeEQPiY5CDj9aq8kGhInXr9kwHwYDVR0j\nBBgwFoAUDvatLCvp/YkxprjNxh6W+A4qKscwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAojew7DP4bk3kNLkBNuOQVggKuFxgm5B8g+THDurBC\nPAIgfIdNbpyjydcoD1wV9ieMm4mK63tRkXaU2V3e2G9bNfE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYWCbQa+/dmNbsceJz2h7IBkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDg1ZmJkYS1mNTQ5LTQyMDYtYWFlZS1jYzk1MzkzMzZiNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDgsQDC/PLcVcwn9vQsi6u4AXTkfqLm1g68cC1JvoQc+Wj\nD0yclX/b9O/aXGczH75JFKGy1AUZ8PfGWN1bNgazo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDvatLCvp/YkxprjNxh6W+A4q\nKscwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMmmLayzzG/+mSkidqw+YTXSNSi3X1Xk9fJmND22FDCQCIDYW7vrgaJAo\nJ+R2ngMDOlHikElMw+SU6VIVuiF1VUk/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAVl8D1+37021zPmbPxw18uDYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDZkMWYzYWMtMjM2MS00ZWYzLTlkNDctZTE1ZGE1ZTI3ZDFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGIxZTdiNmQtMjMwNi00MTgxLThmNGItOWI5N2M0YTJi\nZDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmZrB8H1Mymck+W+1D/1Vpnhi\ntCJLZ/6ecB3L7ToHuksucSlOvaXbTiDgYGwEfD9q6lqyQZsaCOwmPG6LA9yvlaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYh8aeEQPiY5CDj9aq8kGhInXr9kwCgYIKoZIzj0E\nAwIDRwAwRAIgIusRbUqooTzWvWPsiYTG+DdJnQABcY8eZH3RktRVinICIFY4Lif9\nHZmXoKPYLFmk2NQsN+JS/A6sOmScjy9jTWt1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4432", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4432` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAbL1eFQaAAaZN8jh5U4TiTahMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzZTgyMDZjLTYwMmYtNDg3My05OTI2LTJhOGI2ZDBkY2JlYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGEwZDQ5MjEtNjdi\nZi00ZjQ5LTk0MDItZTVmZWJkODMxMjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs6C/clxSlKgjb93Qr4YCFiGPTXm3fmLm81oCrysfsaStzG3PE2+VVeBbJVyd\nj31FCTiJmLv7WD00e6zWAjHwxaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlixAj365h0a8YnAJcTNnywO2LoowHwYDVR0j\nBBgwFoAUisIahHHfNjubOPxATmdaCXQU82QwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAFJnpOa5+hIH9nNKzrbItBwhSNJITVfAI+zxRKCI9SgQIgfX0e\n2UdB+tu2T5wNgefO8Crm63Znf+9bQUe3BOJbIzc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa9zgeXwDEmrU6n+KLnOmREcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2U4MjA2Yy02MDJmLTQ4NzMtOTkyNi0yYThiNmQwZGNiZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqeuRV2B23ANta1hCIpRqDYs9PQCd1+FQB9WVTFHWxxHKg\nwtGoyQSAm27N9fhqpsHZoz3MwYL8WtIuLo0lVWtJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUisIahHHfNjubOPxATmdaCXQU\n82QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga7ni2Pg1JcBQjut8a7GwCeajtWo5wz0sCsHwT0gHXeECIHfTqWQHaVde\n1G7DHzYLOUk1zQ/ToZVoCInLOF8gUV/m\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAYMOmiB0iutVtbGCY4ObBlpDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGEwZDQ5MjEtNjdiZi00ZjQ5LTk0MDItZTVmZWJkODMxMjg1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTcyYWE2OGEtMzcyNi00NWFkLWE0ZTgtZWIzM2U2MmM3\nMjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEErALG9GDZuGbdq/AQm3PAUjZ\nlbpGtZEladOXGEctFCohlC6cyOVtC0gIBsIlk8yRRoS+OZc5hnFqyaLRvLwg6KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlixAj365h0a8YnAJcTNnywO2LoowCgYIKoZIzj0E\nAwIDSAAwRQIhANVvoqm8tvP4s4xkR2pxFviNcPdsJDXQWFngkbhm/TuxAiAzcU1G\npcXu8UX8XEJojyLfEQdqHpN+wVUQ+eANmvxxyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4433", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4433` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAds+KdjS/bxcsFyxbESJ80HyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxM2ZkYTI5LWMzMTUtNGY5Yy04NDBiLTliYTEyZTU3Y2NmZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYyYmU3Y2QtYTg0\nZC00NWUyLWFiOTgtZWQwYmE1M2M1YzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8yeQx+bag7y7s9I5NEhtx9sfPVnY/W8Mz7fMFMBgLg7FXVv+UcBWUBU1XpI4\nnBTxCWnA3y+lWdyadKfsdPa3WqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiKHk+ffCyzQVf/49pY4Bx/oWXvcwHwYDVR0j\nBBgwFoAU+FoPfABi/ythX1fFjAo8XQtsTkUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBq0GdTk7PDZQwfIZTfY1OnHyOV2xp5K/VT\nBwnWXN2TBAIgLE+gbBOtBxY2/HOR55/apwce1WL84nEFcpOHgoHRXxU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbh1nlbPQ7fpjJCInZa8BC+sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTNmZGEyOS1jMzE1LTRmOWMtODQwYi05YmExMmU1N2NjZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEi+8kNu/sbLKkNCrIfdE8fS1KkKGEHgFrPSU2tgywy4To\n/NcSqiZSwHxHRTZMMkV0zmYcIoRAL8sSlVc89avRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+FoPfABi/ythX1fFjAo8XQts\nTkUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC0ThLBc1kY5J6tSdOQrkA2sFjxMy5hcC9qLjQn6kyNMCIQDcjhHFpP4M\nsy4T5H5ZD8O5GQMboEar1PsH+fQdpKepAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAa1a24V2yPJcCrvLSIXlcRTVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYyYmU3Y2QtYTg0ZC00NWUyLWFiOTgtZWQwYmE1M2M1YzliMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzkwOGU3NTMtMWQ2Ni00ZTIxLTk0NTMtZWFhNjZkNGIz\nOWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETN361YW/xO2EmUrgBArlOoNS\n5f06OlcAi9nBsNJTezsZNWTefubzzUx8gtFoJ4dE9IHozMPYcsHm8dc0s6yo0KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiKHk+ffCyzQVf/49pY4Bx/oWXvcwCgYIKoZIzj0E\nAwIDSAAwRQIgNeoXlbJVMDQJQwHp1TEbe7wK7ms5f5RZojtCKlZ5pYQCIQDDkmSO\nxrit1dkmNMECIcW0k/7qt2bWsNvkh+9Ggz3QJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4434", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4434` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAS++SAF6TdoigN6u7BOnTOLZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiYWI3NmMxLTZiNzktNGYyYy1hZTVjLTgzMTJiMjg4YWM4MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODkzZWIwMDktODQ1\nYy00NGQwLWJlOGQtMWRhNDE5ZDk2YzZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpQf9sishrnBuAlb9K7i/hB5a5gO/Dy73tXfEhmGll7UZeA9x9iiv8P4rtwdi\n9Oi8kcwh1aDJ9+rJRXDnRMOdQKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHbn/laYcaT3AXejPL6bwHubhxgwwHwYDVR0j\nBBgwFoAUszygtOBaWilheqUfOJ8vcOe5dN0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAueG6QZ5HdzybEJq55ZevvCX5J7JQ9h5F\nnrYSU3vUDsYCIFbjxtuI20IDgG2PNbHgm6R00eTb1tCyaWsstvv0y/XA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS15tI/Fi/xYEdZGzyH/diLJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmFiNzZjMS02Yjc5LTRmMmMtYWU1Yy04MzEyYjI4OGFjODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCtfOGxbE/4jurZusIeR7kaGhLQn//cVlD7QafDuMGOhuF\nyHIfRyuAQTF6gyiGPbtSIRDYUUBgZRoEAC0uMvj9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUszygtOBaWilheqUfOJ8vcOe5\ndN0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHOsxkJyDEyLB4iHYpvrkCjeyfz29g77XiXwXPl2jKykCIH/zhc3IDZ2t\nDo/it7QsFCHtpTm0/ZL6Xvwl9j4Xz1K0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAcDKdlToVb2lvU3U1haFpPd8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODkzZWIwMDktODQ1Yy00NGQwLWJlOGQtMWRhNDE5ZDk2YzZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWEwMTAzYWUtY2RjNy00ODQ1LWIzMTctZGE3NjFmZDUz\nYzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfp0aCh/bdIBKgMTPwuDIql2j\n5akhzgFFglTTJkJw7xL6bpvPeIFtmnw6sWd5RNCW4MIQPPpX1O7jCUPEm3VI8KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHbn/laYcaT3AXejPL6bwHubhxgwwCgYIKoZIzj0E\nAwIDSQAwRgIhAMW32S+pcKW6Z+f/LXVs5/PJM1HiBgv3yWD9lYwtUOs6AiEArI4N\nPZ9Tw36WZ0cimhBleMjy4sqEaXOhxI/+u0UVPE8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4435", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4435` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAdOsovAvBaD509gV1harJYmqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0Nzk1Yzg3LTRmNTYtNDI5NC1hNWNkLTc5NDc0ZGI1OTk4ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJiYjA4NzYtNzcx\nOC00OWFkLThlYzEtZGJlZmNiNjYzNjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2kgDlj5PirbEdLJ9CqJzRW8BQNDE+DjN4/hTTlxasMIALZuN4I1kdKJQUmNx\nqgvn5Un7/sUiRu/YGxoUSFgxe6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmYTw3Y5+kT8cOlMc1QaEaYRLMtIwHwYDVR0j\nBBgwFoAU8yVvBWK637/2npzQ00lrCQJBwGkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIE4U7ojpQWXhAv33HoNpz48FSUBQ\nfPURcaW4s7+iCGthAiBAYU6XlfRNk2YCwo/YQt+gnSAC0mh72ameq392EUO1bQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdiCUd7fiZMM2tAPgYUm9WqKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDc5NWM4Ny00ZjU2LTQyOTQtYTVjZC03OTQ3NGRiNTk5ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtac2eQP04YQE9GNdkI+JfB29kTAoKdgfQkluK0JfPeT0U\ngZXvW8yoyrmgUwFpflOoF1TDx+S7Jpm8znbnijIoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8yVvBWK637/2npzQ00lrCQJB\nwGkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJF4dEiNHYfs/myup+Lec0DD8U+skCh2ENmHjyEYLtG6AiEA0H4KW0Ms\nGKEJipcvAcZouFKbKGaNAke1FM0jz97ZJnk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfuYootGVL1K0+vLl83RLCeCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJiYjA4NzYtNzcxOC00OWFkLThlYzEtZGJlZmNiNjYzNjhiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTc5MmI4NDctNDc4My00ZGVhLTkxZDMtODcxMjVkYWQ0\nMzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+gB/2bkRA2aIGSutu7qpTVHS\nt2mrd65K7SjvP7+/corCrmRX2EFNKK111/ciKr9bxxXuwZq/jtx9q+CshTgI/KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmYTw3Y5+kT8cOlMc1QaEaYRLMtIwCgYIKoZIzj0E\nAwIDSAAwRQIgVRnzF8oXgcfR9UMNmiDe9UqjBvAz7W36X02eXGYbGysCIQDLPFAL\nlTZPldcfvE1Fk4vVZ6hWs1sTbxDiqtAublvIpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4436", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4436` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAZlVCZ9NQIsXAEOoCt7hHDVDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlZWM3NTlkLWM3NzctNGM5Yi1iNTM5LTAwNDY4YjI3Mzk3MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZmOGU0NzctMDZk\nMS00Mjk2LTk1NWItZDczZjU2OThjNjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3C5vEE885iQFGA0hdYI96RtzM3Wqqk5Gdmcaajv7eu5QyW20tA6ZmPoLcWDU\n6T7joz+wmiisv3QVepwqb7Kq66OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDhM+dHFNtcxX03JTKivwzOqrqLAwHwYDVR0j\nBBgwFoAUfUueor8umnBB1P3CHhYfOUxMGREwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgd/rXgcIU\nQFyqM1/j4r3XHTevJSJ+HDtp+eBLApBV6v4CIQDfxDQQ9F9L5Sjhq9QjPy0gqtCx\nCkxZm8Oxkp8vsOCopw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV/CEgpWrzYYniUGjPA2pqnkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWVjNzU5ZC1jNzc3LTRjOWItYjUzOS0wMDQ2OGIyNzM5NzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLesmFgQuzVk+xnzCsqqFSM3YWPZWC7+CdAQPHgrfR2n4B\nQ1pTOXeqTtCEqtADu1i39Ac5kcZKVe4gO3RwdnP6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfUueor8umnBB1P3CHhYfOUxM\nGREwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJglWdUz0aMOGoIHcy6wMcjKr3gSLd2BfY2Ho6L0In64CIQDazIztcszt\noTsHbDeuUZyz7G6ut6kxyKTeAQcEgSjjSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATPQlxWQ1/gINp6HszEwxDIgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZmOGU0NzctMDZkMS00Mjk2LTk1NWItZDczZjU2OThjNjBlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTc0NTkzMzctZTkzYy00NjAwLTliMmUtMTExMzY1ZDdk\nYTIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAPnEb5j2dwXfIlDvaHDwkHC8\nQt1vBhBj1BCWeF9MFjEBY7q3o0QvxcSQxCbamw/v2Uni6YODRv2x+w1yQUX0I6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDhM+dHFNtcxX03JTKivwzOqrqLAwCgYIKoZIzj0E\nAwIDSAAwRQIhAI+GGScZl0Bmy/6uXu6u4gr8IEWtFNt+W20NNKBydc4GAiAB5mqu\nUC65leLER8/JD87Cb2AIjco109nMKXiIui82MQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4437", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4437` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAQhQ9Hij8M9Mg1POlm7UuomlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2Mjc1NTVlLWYwNzItNDY5Ni1iMmNhLTJlOTFmNGY2ZTY2YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjUwMzhkYTItZDQ5\nMy00MTM1LTg3MjMtYzhlZmY3YzQ2OTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa2M1x1k6WOSr0qStuGuyPYPcMQ6rFS7bUZtAeQhRAkqlSernLfXKUM/qgf3q\nqHa46Wcdu2GNVzVL82ajmqc7nqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6AZ1LZ4WNTWekXkhVCpFSasnr9gwHwYDVR0j\nBBgwFoAU2x/OpDSmYNlKSO/ni2SGYzNDY7UwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgIxAOBrKL\n/DMX1TWNU7Ba5fG6npcPzVTJZtomGiLE1GgCIQCAqbXSClBwtVYqe5eUx8wJyOdy\n+ennybYwzpll50IebA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ4wUSPc17N/oCRMQpD+ZyxHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjI3NTU1ZS1mMDcyLTQ2OTYtYjJjYS0yZTkxZjRmNmU2NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7wTA8mfjy4M1MXwpyDVxvZAVWy812rFCgmpD9gdGTDOyR\n+QODyERpoxktPcbTr5jpESvOwXH29QSLdG7W+kt9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2x/OpDSmYNlKSO/ni2SGYzND\nY7UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbWOZ82WHLtrpcfCu2bTcz2fZu0p/DhMw0ZVJoIL3UmoCIG+tF1vhQk/j\nk5rFJpin/kejEh4tQlN9WlaFaQdl8xOm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISARtOveyWnXmmGzDzkI1xnxHiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjUwMzhkYTItZDQ5My00MTM1LTg3MjMtYzhlZmY3YzQ2OTIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmUwYTk3ZDctNjVlOC00YmI1LThkMTMtNzI1NjAwODVm\nZDQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj09/Z1gvPQLRXvigIEIp/32z\nfvRMRVG83m/sGQqzIhZ/WggWqt40LTc94pXwsCaShnnpSQ7zO8xBhhTo3lsh2KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6AZ1LZ4WNTWekXkhVCpFSasnr9gwCgYIKoZIzj0E\nAwIDSAAwRQIgd85gohCDaWZSYup2FZD5MGE2Qk8sS5ZXi0/HkkDltyACIQCEa0ZG\nDbTI/6GokBxhK2s0mngNNFZXye9VRSeWpAGxBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4438", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4438` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAerV3MlaWbQOOvgLBCzeVUGNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4Yjg5Y2U0LWQ3NTMtNDdkYS1hYThjLWQ0YmUwZDgyNzEyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ2Nzg1MmUtNTMy\nYi00YmNkLTg0YTItMjQwYWRmMjlkYTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzrqisLcLWM1z57iTB7JimtAMYAUdZQ3EeyqctXtHDBPJr0dRZLrRr4KK0kE4\neQoVDNSamA/z5BdF/qejLBkLFqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvLGM/fMwIcCz0hJxZNANPpRanjIwHwYDVR0j\nBBgwFoAU0XaB3LDk/PRu79KhsLwsU7d60S4wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCID5bcAPh\n2HyOXlCY0okGNJkPFRjPat7mrXzCuYPx1r4EAiEAwvF/bMpeaUIXi74hFGV5jfRu\nscJNevPBsr1vKyehqEY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfD5Zrs6zUDnC3OL0VU+Hl2gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGI4OWNlNC1kNzUzLTQ3ZGEtYWE4Yy1kNGJlMGQ4MjcxMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdvQA/ReZrJQ72+DWPwXNZ9pGCoyBFJV+jw5fjMLzJJSom\nQV2gs6X0mp/+SqDLse9O52IibZUxzb7qsfrjASpDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0XaB3LDk/PRu79KhsLwsU7d6\n0S4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBZ9eN6jgSF9TOTwvEiB+DruVTRn8sDXkBEA+z/1U47UCIQDcM5t2rtQw\nTEFKQ8P0PUSFph2VddFoKcBTw7TVYCLXMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAWsOYwlwppfVOcq/FrwEy42dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ2Nzg1MmUtNTMyYi00YmNkLTg0YTItMjQwYWRmMjlkYTFiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGEyOGFhODAtNzY1ZC00OWIwLWI0NTAtMjkyNDU2NGY2\nOWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY6Gmis64yDybk6r+x8ODSAEv\nFRWgG1j6GOIYc81FZbm/OC6QiwzQI9JOOcZBm9mpHAKidsp73qycHM8OXXVYkKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvLGM/fMwIcCz0hJxZNANPpRanjIwCgYIKoZIzj0E\nAwIDRwAwRAIgdSzWw/aBl24H1BO3lw0c2rHDFaRLv16HJY42lE6M6nMCIExucylH\nPSoTlYx+3yLB5VbylI3Aj/yuZpql+fQgV+rA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4439", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4439` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAVbmAhBu6KXgCdxDy78uSwJjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3NWUyYTMzLWI0MjEtNGIwYy05NmYzLTViZDk2MmJkZDdiNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRkODhhMGUtY2Mx\nOS00YjVjLWE1NGEtYjNjZWE2YmRmZDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENCblOABVqlqBwi8VWP6QtTqN7/qzC6gh7NoYfXDEAArpaj2NjbfppfQyBO4/\nEeQOdTYZQIHeviDcykD9LstK2qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCjUwTHyQlE3VSO5+Bn9OQkG89GYwHwYDVR0j\nBBgwFoAUR4C7xWgpJt0DzyG4PSLrNLMxue0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDhpi5VHZIvTeA4VV7fVvW27/7bB5tE87e2S8wUtITgCgIhAMCLtYMt\noDOkX064wNXEBMRVtKAaBOBGI4P5P9cNGzwb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfFgs88kTiiTcnRjNMC3SeQUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzVlMmEzMy1iNDIxLTRiMGMtOTZmMy01YmQ5NjJiZGQ3YjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3gC4kmcOoLZlp7yw6d8OL9v8jPqwITIQ7IyMkpJLTeAa1\nHFcgM5V0230GCq6kB8Gh3qDZHisH06gcnC0bcXrFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR4C7xWgpJt0DzyG4PSLrNLMx\nue0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRlLce3pQZ9QU0kJWg6TZhf39W7Zc2b0858KYcWy+kM8CIQD8O3Gno64k\nU156M06mQ2Cow8iR7WWjJeBhYU4rWxm9wA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAULiMgvVY7AmEsQRkIj9vsf3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRkODhhMGUtY2MxOS00YjVjLWE1NGEtYjNjZWE2YmRmZDYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjVhYzNkYTMtZWZiOC00N2RmLTg3NzAtODVmOTFmNjk5\nY2MwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkfoLAsqJ+8CsbBwm6umVUtu9\n+Fe+Wi2Xf3nTwt4oADH4fp6mfEXwmyCUk2pNIR11JIYfxkI3wKTOcWrv622sGKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCjUwTHyQlE3VSO5+Bn9OQkG89GYwCgYIKoZIzj0E\nAwIDRwAwRAIgZZqrSXvtLTzbbmexnrM1hBD3bejkR71sr2Pn/mnNTrECICIhxy08\ny8uFjuHVEqaOCr3ENroMj9oE1D9t3y/RRYUK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4440", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4440` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAeWH3FQf+1e4l5GBGoY+20uzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyNjRkYzRmLTNkOGYtNDQ3Zi1hMWExLTkxYzM1ZWUwOGVhODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQyOTM1MmMtNDAx\nOC00ZmQ3LWEzMTgtOWRhOTI0OTA0NmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoWh/o7Iejwg2D9yRr8Y93SVenX9GxjfWaH8Lxpw2kz4OCa3a7AHb/kBGZNjr\nFbXKdvCSNBft5G8/CACOVtEoyaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUInzKJkFaiOAzMFGek+N7Gvyt2dkwHwYDVR0j\nBBgwFoAUc3OGVYOr/5Nw1+luoMgN1ZNysU8wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIEBNDc8l+gYZVBsiHUud5TxAAawuJHxl6Cd5u9eTge8ZAiB8iNqvUc1D\noF40uhXvyboLmAgyaBp3U/A47STr1rXgVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbK3u0opTMnuI9503tbQbFacMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjY0ZGM0Zi0zZDhmLTQ0N2YtYTFhMS05MWMzNWVlMDhlYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmxi48tTupSFMMO87nxVAPnnnYaXVynHjd7vx0byp7KZ2F\nk4a+fZDtB76ROJmx2fsCaLlHc8asOOUir2V1FN5Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc3OGVYOr/5Nw1+luoMgN1ZNy\nsU8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGNm82hHJm3uyvK+G36ADirtb4h7NpdunDrnElC9qb+oCIA2Pfe7bgphO\nBTa2Hx4QM4QmnAB46uGeP47wxz4eOSa+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAXjKPu6OQRudtt884+7FS3ubMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQyOTM1MmMtNDAxOC00ZmQ3LWEzMTgtOWRhOTI0OTA0NmQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWQxZjdlZWEtNzgyZi00MGU3LWJlN2ItMmRhMDRhMzVm\nMzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErsR4amCIaPgNRiEV1ZN3Kv6v\nGVfijzxd5/3YB11F6mDmAoe8zjaQz2q9/mSEFXykB6t+vJY9wM57uU1swHH83qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUInzKJkFaiOAzMFGek+N7Gvyt2dkwCgYIKoZIzj0E\nAwIDSAAwRQIhAMXdAL04K/gJqLQ2ORIlsaaxLlwO01Mc8vKYXlzSstC6AiB9pWWt\nrMxBMVd4z20P1GaTlOVnMFh3bLf/bWUYo/gWrg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4441", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4441` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAf4eghO9wsHow8MZgfg1R7X8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MGQ0Mjk2LWEzZDgtNGNlOS1iNTA0LTI1YmE0ZGVlYzI4MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2MzYjVjODEtOGRk\nZi00YzI1LTljZTctMzdkODQ2YmExYWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyWNM1dBwdQksXICCKWwccM9Oj+4LEVz4150FfEYuWMzBuZkiYIpxK1cotdR+\nVj0IkV/xVMXDn6xj9Yc3u68yGKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0M2LTUmWfHqXLrBNUg1gHVvNbiswHwYDVR0j\nBBgwFoAUS9+EW6GuHjYj7C6bPb9GY8YW4OgwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQD9rmSqcT77Fd2aWlNPqjZW/KrcoBM7wxi74ZFliW4hRQIhAPuDiAI4gddkPlXC\noi0I79ukD1E0QCfFhXXJPEbG7rRN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXVA5zeDv1UGxrJemwNOj8nFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODBkNDI5Ni1hM2Q4LTRjZTktYjUwNC0yNWJhNGRlZWMyODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFSYuESWDYlFM5mD/dAKRGsAX/JlQTrDafFQ/+s8RiZqFM\n7bxOMnu3WYUX27HewmouW9GfMcGobcZ1h/jDyC8bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS9+EW6GuHjYj7C6bPb9GY8YW\n4OgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOhNYPkZFIpADa2QS9tDv4ULKJp0KPqdecZJIhXfBHZoCIQDDZGBrdB3Q\ng3fPY/fiFNWwjJ+oWGVlQiLB4O9bTxo/aQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAYWoX8JMFZkgzGPIxglrO0PzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2MzYjVjODEtOGRkZi00YzI1LTljZTctMzdkODQ2YmExYWE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjMxOWRkNWUtYzFkMi00ODczLWFiYTItNDJiNWZmMzky\nZTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeD4LtDgREyxgctJdpeEMkj0h\n+TvLFvfTt0IBuhfqRaM7RUzI/dciLOILFchKKyumq8OQwGx0hUQ1ez+eN8Y+BaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0M2LTUmWfHqXLrBNUg1gHVvNbiswCgYIKoZIzj0E\nAwIDSQAwRgIhAKr0lcIGbIiAhO6tmkejQOKWkMUKD+2Xa+daonU5GT37AiEA76fv\nmrbC5ct5PLjZBADr5X2fShSkbLp54pvYdgdkB5k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4442", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4442` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAWAoz0PM2G2LC/vAF2LyQsndMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5MzlmOTk5LWE3MzItNDA5OS05YjZlLTYyMGM0ODY5MjU1NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkxOGU0YzEtOGQ3\nNS00Njk3LWI2ZDMtZmZlNTlhNGQwMGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEflK7oknz/SJSf3ePFfELE0nx49xd5F5I01iDvymnu6r5u/MiM2zwgYe9shT5\nLTS6SRf0iC/htb+ySlvaub7et6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMoWNNHKQQKaRKXtwVeZcrkvVlxYwHwYDVR0j\nBBgwFoAUxvXmMqx7psvUX1vwel2WvGVMhKMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIHqBQCRanwgLg+rtUBH06eg/mAwV0fwoR06D5Swg82abAiEA\nvhNpCit/4A+WVGVbUB2fR3Qjqv7fJY/mAUet39YGaDY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR19nhXHfRFxXgsCFymFh0vxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTM5Zjk5OS1hNzMyLTQwOTktOWI2ZS02MjBjNDg2OTI1NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbIbpeq6cy8sDQuyivnqUpc+YIVztXUF/kK2Hly8RlSGpU\nBN4+ZsIxFUfjaWDHSqThXYLY1NQDk/aCMGUhepBno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxvXmMqx7psvUX1vwel2WvGVM\nhKMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPmLMHCjDTiJaWWFj7zTrw7saTCHqRFHTrI55wPxnayMCIQCZhfCV+2HO\nSA+Ifsp6uMDgSjlxS43H4ep7xtQ7BUiz+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfDZirwB8iSNAYrWvW2GXNZ1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkxOGU0YzEtOGQ3NS00Njk3LWI2ZDMtZmZlNTlhNGQwMGUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWE1ZjhlNDEtODBmNi00NTY2LTg3ZmQtNDgwYjk5NWM2\nNDZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEc0RHoHzWr7/xDMnfkQV5SQAy\ni6sKVVeH0TDwKQyS9TR95072GLCCY9hj8Ry7pPHshZSImA/1Ho+qwWJ9AhMHQaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMoWNNHKQQKaRKXtwVeZcrkvVlxYwCgYIKoZIzj0E\nAwIDSAAwRQIhAKX+kPBDeyHkGiL5Dn4ee1cftbde4a/TxvgzgmcQLmWrAiBskPAs\nb6iQCsFAJXl3ouZ+eIVq0yFyGN/UOn6jrY8aHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4443", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4443` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAbU76KNrgTbIK2v7Esca3naYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYTI5ODhjLTZjY2EtNGNhOC04MGFiLWQ0ZDcwOWY2ZDNmYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY3MDliNWQtMDU4\nMC00NjRiLWE4NjMtYTYzYmM5YTc0OGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8QAiWJcsbIjB82Uf4O2ui2iokUqJ0ZdzQyqR63c2D80ch6BJ/L6n17cuZoJG\nSrs/pK+wouXg4Hvu4I2MO4LQFKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg5eWI5s7SrjxxdfTOtMHph6DnaAwHwYDVR0j\nBBgwFoAUY8/HtHdHH5840rOnUswB81uHHzMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIFrjpJOAWUNMbMH+eNEi8bScsJEO7A0iGhM74U4bF4k9AiAN\nuj1HkzgDkuoXF/UVLOdXjggCRuPVF8fpjX0ZY7dtow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfetNN28KUBeiqJkJ2THl85qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2EyOTg4Yy02Y2NhLTRjYTgtODBhYi1kNGQ3MDlmNmQzZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZNpxKNB0kAjANtv7KCKCL6+FwkB16lGecEdq21JUTu8mU\naeombt3GO47SdwaGI5tcIIw+LW1u4Pe9yPVJhtY8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY8/HtHdHH5840rOnUswB81uH\nHzMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHhFWIwNiFvWqxSIioRQ2hyfcE8jtwKBS3/fiACXbS3ICIQCYz+UC37Hn\neINpQqb0w2xpcra3kZd8oUfoNfmMRKm1aQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISARY8a9K7slReJb0ZlNkL4W1JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY3MDliNWQtMDU4MC00NjRiLWE4NjMtYTYzYmM5YTc0OGE1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjg2ZDgxNjUtNzk4Yi00MTU2LThkZmUtZTE4ZmUxOTA3\nZTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjkAnZ4aZb0fU0n3B98K0U3Ti\nPO2PrnDGQv2Yo5vhPedzyyjDSOHCYcHKcyhB2Br6St4en3iXjiZ0UrNhdERoKKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUg5eWI5s7SrjxxdfTOtMHph6DnaAwCgYIKoZIzj0E\nAwIDRwAwRAIgY6rLy7xBtNToLrai65mQuu2pskC8vTFdWioud+Y2z5UCIEhVCzSX\nBJvTybNe9CSjFonqT3TK6CmwpEYOn/SzwV+T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4444", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4444` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAUZZBRmT1hI7H1G9ZY58OYvMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4NzFhMDllLTBmMjktNDVlNC05OWU4LTYzNjc5NmFhYmY5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY5ZmQ1MzEtZGZh\nMS00MTA5LTg1YTYtMGRkMjk2YmZjYWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9TtXeg2XaUuMb9oU9Z4c7fsuIiuVz3kye7pLkDBwwdHzxTd6ouhoNSoaeUQy\n9jo9Cs0snbT3Cp91WVvjtDY2OKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKFGHXsk8HUQdKIXQxSBD1dhBftcwHwYDVR0j\nBBgwFoAUISStrvXmjcK2fodT9ZYbNpPjRFUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIFOfnjD5/hxK\n1F1bchNT5d9ETCrVmBBghWkv0l0OXK0PAiAS5HJxApD3hctZ/CsK2DP5L2R+2mFC\nqlVQFEPZmDtU0w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbpoDa3ATZzwy3Lg23f4IyfmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODcxYTA5ZS0wZjI5LTQ1ZTQtOTllOC02MzY3OTZhYWJmOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXjA9a4F8lKQSWo3hkeK3rNiF5irDbBkiZACt8WN5btP2g\nCkwrEMlRkRWFLRP7qrdIdOgdntRqW0TMSMT20juio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUISStrvXmjcK2fodT9ZYbNpPj\nRFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcERhl02tjQd6hcOb9rkTcXTAOTUy3LAc/2R3dQ2RfpACIHDDJtO4j3mf\nnjte1kOYZgPz/y26kSwks2Fo1lFJe9HM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAUuFYQH/aD7s9T1aHq7m1/fBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY5ZmQ1MzEtZGZhMS00MTA5LTg1YTYtMGRkMjk2YmZjYWYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWNkNDlkOWMtOThjOC00YjEzLWE2YjktMmNhOTM4MDVm\nMzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6Mytl+o/bXgJ29uBPSeXfcb9\nz0KXbZmFUqnsuUmWN8lAvcWJH7OeT6B+mWXzeh0mOgnXYk90Qr6LnFbk6YJpyqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKFGHXsk8HUQdKIXQxSBD1dhBftcwCgYIKoZIzj0E\nAwIDSAAwRQIhAL4utoebOjYJ1uKVdzrlkq7eLQul0/oRjGS097hIQF+tAiA5jaUo\nfJq2zNTgRh8IjQXXQhN78EAZmaF8R2qCoHPtWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4445", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4445` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAW7MtyYXWp5smKxBd3yDfJnUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwMDZkM2JlLWU2ZTgtNGM3ZS1hOTVhLWNlYTM0M2M0ZmU1MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTIwZDlhY2EtMTQ2\nYy00NWE5LWEyNmUtMGI2MzM3NDAyMDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDSEw+nFYVbYVfFQFH5Qefkf306cu3oo5N2dMlQuRgULWPuzLctWx4QgwPGSV\nFvdr3iEtccfxh82+dKzcqGlQcqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoZt32cHGWx0o5A+9501xY5RvoW0wHwYDVR0j\nBBgwFoAUy8XUhucvStHOPdv4SRvJ5NfGjQAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgVuivwH1rmsBazIq8xNhq1eBIOtavj+ZAOJuI9a2jy3ICIB5deb7ilORA\n0/UBhOaL1Jm6VgNRMgfatJDOuiFEDenI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATduHW7ggaA27Ak9av8IelE0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDA2ZDNiZS1lNmU4LTRjN2UtYTk1YS1jZWEzNDNjNGZlNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcdab1dl1RmpQSttE8vQMefKbr0ATUQMfGJuGMhLZXRKBm\nzWr6RnCzdatDBlugYKHkJREaTamiNq2CKeRbm54go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy8XUhucvStHOPdv4SRvJ5NfG\njQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDbUMQ8xHhUfvBc0cJbGwLHgc/+CzW82WlizRKOgmjFwCICVOQVXMgtUd\nt5PaHF5rnU8ZyVNNcxsqnqZ1VuCPzHZs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAV3YJjsvKTWD8oSPgF4SnEnOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTIwZDlhY2EtMTQ2Yy00NWE5LWEyNmUtMGI2MzM3NDAyMDRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWNkYWZiZTItYzI0NC00MTg2LTg2OTgtNmEyOWI5MzE1\nYzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0GpPdcch8bBgnhjCuGx4SHUo\nJmxifAe5TMs0Bk1o2la7XGnmHqbUGCtqmUWUorcfsgBBphvCNQwEWGudJ1v8VKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoZt32cHGWx0o5A+9501xY5RvoW0wCgYIKoZIzj0E\nAwIDSAAwRQIgSOTzIN4lc1Yo6joKC6A0CGSCOfvFwVBWS6LMaqoBmlQCIQC3uSkR\ng72KXPQCEii2ISw7N3xwQogs9AzaQHoK1u5oAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4446", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4446` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATMgGi8rYOc8BAs6zPK+laA6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzZDE2OTU3LWFhMDgtNGI4My1iY2QzLTZlNTlkZGVjZGNhYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjkxMDQ4NmQtMWVl\nYi00NTAwLTljZGEtYjY5MTFkYTQyZjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENvUmBFA6Q8LtvzJjmjXUS5x52wnGU+a5ceTJPtgJZPA8570z79xD2eQ0Rhjr\ndAbMbPG4Ykc1AOX2XtantG9hyqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrqXyeVyQIeaONY1/kzVNtuvMrlkwHwYDVR0j\nBBgwFoAUFdeLwek8DudspWzntE6/EJT0nvEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgfUGVp3GcTGl9KOcXaL3EBYnDJFdOKoekzg0RS42zPS8CIQDDrbaJ4qYm\nIOsMTs8jKOGj7oRGkbWFXllYSsck3szaDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeZ/uaV9iUVaABQvJ4QOcwGLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nM2QxNjk1Ny1hYTA4LTRiODMtYmNkMy02ZTU5ZGRlY2RjYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATot5647erB1t6g6zMCBU0imtS6WSwEAOIXzcnShTaGZehq\nYvX2Vxh+o7ghcUm1J5yjsHkiqjHjor7hPtbZhObDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFdeLwek8DudspWzntE6/EJT0\nnvEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFKm3uKMGHKhl0R9Axo6zoHWLl/GXEagQ7fuIImEgxPwCIGneHrE553QW\nJXEYXvFqYNgwFzhtcAPRoKVBRRqPNkfH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAd1ALlVP3vORqDkcM4zqEqNkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjkxMDQ4NmQtMWVlYi00NTAwLTljZGEtYjY5MTFkYTQyZjBiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNiN2VjZTgtYTg0Zi00MmUxLWIyZWUtODQ0OTIwNjA3\nMDI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDM/c8Bo0PWnXblVSIt/GubI9\nPrmZftqvFtwMbPKB4Rku84r/JdEEtExLIrmaSTTvSG0l2BB1RQXlO1A3Xp+u7KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrqXyeVyQIeaONY1/kzVNtuvMrlkwCgYIKoZIzj0E\nAwIDSAAwRQIhAL/N2HVDeNgfhAmszewKs/GLwYNMN7wykVIZVoT8ZQ8bAiA6j6vo\nJhkvzO7MZBKg1Dv/08k0xmvm7JPx7MLwytogew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4447", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4447` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAYvCx+ozyZPb31kY03UiVzusMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlMGY0NWNhLTZmNDYtNDg1NS1iOGI4LTIwZWFlMWQwOGIwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZkOGYxNDEtMzdk\nNS00OWQ0LWFmMjQtMWI4MjczYzJlMzNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc2UT1TcSoQ5Pvyn55DemDB78Ua0sN8R605pYwAHZEPmG3uTd3L6a0mNql7mE\n3OzSJivw6+YYixWB7+52ZTzbmaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyLR7TD/PKhbvGwHfCM0P0pG2f8AwHwYDVR0j\nBBgwFoAUxhBD2laVnhgyprgWrkh1J0iGDoIwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIFmRWlXavY4uylIRnAx/YEByfr939rUICqQy/qUy7p4hAiEA7xrRrkJp\n9VE6VrFT8MxA7zHWMU6nQ8UUf81+DuQjLQ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARMpNpePdJEWfjEMsi78Q5RdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTBmNDVjYS02ZjQ2LTQ4NTUtYjhiOC0yMGVhZTFkMDhiMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmQgfHwDorikvJIoq/EQ9il7MFfY1UgfYG3YxN7aQgGGek\n1qSwePVKxMTfwW3GzDlrFhKqiSsfT1dFQZEaXXHJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxhBD2laVnhgyprgWrkh1J0iG\nDoIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI/Ej2ZpDHT1fQ5XP1VDaQwexk8vVWLdsZW7kXbl5H7XAiBTwmRZ1oV/\njapL6WR6BketQYzdHR9bPm/JlIZCrupMPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAehRm1qGcJY801Fmzw2aNv2jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZkOGYxNDEtMzdkNS00OWQ0LWFmMjQtMWI4MjczYzJlMzNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTE5NjQxMzQtMDcwYS00N2I3LWIzMDAtZjdkMmZkZDgw\nY2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPKNNhIEq+acduErxnirfcKhP\n1r6PP8+W5Ye6+y8sFUaLdS41rYc1bTr72Mmx9NSPkSBTLTynDU6BqlDM0ASND6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyLR7TD/PKhbvGwHfCM0P0pG2f8AwCgYIKoZIzj0E\nAwIDRwAwRAIgKHz84b/ZPW9cJrf0kHgek5OYM/rRmlqFheFAB6F1s7MCIFAvBThA\nQm0TtZe2qd6fScljn6IPpfW0+iRqfz7XT7wL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4448", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4448` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAYnY3q3IIS2og1wNtSDaUaTGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzM2ZhYjFlLTE2MDItNDMyNi1iYmZmLTJiNDcwZmM4MWY5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI3ZTgyZTgtOTFh\nZi00MjJkLThhOWYtZGEwZjIxZDM0MDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE55GUieoIFtEGZU9EqHvYnFo45XEOhtfkSHwch/SxpTeDf5NlqrqK6qVDf/b+\nGCcFZQQK1ZXnqTWyVvHGdV86/aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1CPVc6TgdMQdOPWHo0mBaV/i0NIwHwYDVR0j\nBBgwFoAUtH2JVtaEyz07qFHAvufWImSd/g4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICCNcelI3ButVa4dukqsnFydrFwBuUUbWgZ9fUc3\nUtJqAiBN5dsMGwjHLBxGolGEDDWl1lOQ0JpltRYjnf5oNJj62w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWXR4ILwezRzEdEP+Rf0spmFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzNmYWIxZS0xNjAyLTQzMjYtYmJmZi0yYjQ3MGZjODFmOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyUO5rIG/SXz8im+IdHCvxIsJTaK22irzvTOGcSBLSuATD\nBSeEVzSByqtvjxkHfPYMruvLCEE7QRrBJYlD8vfWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtH2JVtaEyz07qFHAvufWImSd\n/g4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPL/p/viqq+ybcEW8npGIzghYEoLxXX30Y5aAquijAyoCIQDB5FQRouPe\nonHZTzOEg/L6kHixowihXp93E0D58KDC4A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISATZCeAxuNWCOneG8MENhysHmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI3ZTgyZTgtOTFhZi00MjJkLThhOWYtZGEwZjIxZDM0MDQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTI1ZTVkYWEtNWEwMS00YTEyLWE4MTMtZGU0YzEwZjhj\nMDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAFg7K8wHyHmiZCXreSXOOV9M\nAhEgHUzqPwptbV+p72gnlBP/lhwvMP0xlpPqXDpyhGBdt7Q72Hs7jrl/9cWxxKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1CPVc6TgdMQdOPWHo0mBaV/i0NIwCgYIKoZIzj0E\nAwIDSQAwRgIhANdVdt40ZVOxXPCnpC2SJkRUfN2VXnqL4ClVi1JlnG8jAiEAwszQ\n67CM3dlBLZTcm1iJJU3KxZdkZv2v87vUaZLbor0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4449", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4449` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAYmUuQj0AbSTJkSIBUDSjyJlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0MzA1M2NkLWQ4ZjYtNDQ5OC04YjJjLTdmNmE0YjliMjgwMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI5ZTcxMTYtMDRk\nNi00NGEwLTlhOTMtODgwZGU2NGZmMmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbKocXLeCu2CGxBXxJNxIn/8/aqmXuswicr9R7VSKLrA31QMBfttL8yish59+\niIKsK2O4j297mNiKwxEfoyFXA6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbApE9mlosPga7DmjdHBXEKXu4A4wHwYDVR0j\nBBgwFoAU5kT6dM/0KOALFbc44zblACJvdTwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBYU8LEn6w7dMXNrTKtbSAOLFdA+Jj1nU9yn5raF\n9dCuAiBN/6Hmsv6wk817Tp02OjJOtkPv+qwm5Vizkg33QhVACw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZuiLjnaC4XKBl4ZdOiYXkF9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDMwNTNjZC1kOGY2LTQ0OTgtOGIyYy03ZjZhNGI5YjI4MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfkFveqpgIsPQGbMlTn/dLEWG6JTnFC3qgRoiXPu893VbC\nqrHuJ5BqG7IRQDr4mKWO+5iwu0CW8rXx4zsxgaULo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5kT6dM/0KOALFbc44zblACJv\ndTwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAObAXcATxP5ECRYC+gyz9lEIRQuQ5puOTHyWB7soroDHAiEAndNzdCmz\nIN+6HL7uof4UrWQ3LLVIWD/FrNWsVdt/HHI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAUqZ2cIMun3EifYhZuP8V8jVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI5ZTcxMTYtMDRkNi00NGEwLTlhOTMtODgwZGU2NGZmMmUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDFiOTk0ZTAtYjQ5ZC00NjdiLTk3YjMtOGZhODdkZmM0\nY2U3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPHSdiM/TFAF3XZ5pQHoNEe9E\n6lF9kL4t3bV0O05NnytdtBuej+7laPefYGYfi9FaImcCjVdOjikMQG5kGP6E+qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbApE9mlosPga7DmjdHBXEKXu4A4wCgYIKoZIzj0E\nAwIDSAAwRQIgYRT06cDpXv/mYqanm0A5hcTogcmWk2nC9eN8YNDSBXoCIQDYGmB9\nBN5VCb83dthaWaTzVCjPg9eWMENxzU1TK0HHrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4450", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4450` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAdvxDO7KtxV+UZu4Tnk2b0niMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3ZDc0NWUxLWUwY2MtNDFiOS05MzZlLTdlOWY0NTNmNDVkZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJhZmUyMDQtZmE3\nNC00NTI0LTgzOTQtYzA5N2U1MTZkMWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEacDAe+/Hnzm7WjA9fZXo8U/TWKJdSxhrdJLmATGYlfuPJvAfCGFU9EkILfAD\nAZ27ozOc6EySl0rOKkUIpk7toKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3MFTzG0Zi2PyXECEviz2JKM1FcMwHwYDVR0j\nBBgwFoAUmLyWEiUsXMbCJC23btlh1zo8AFswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCLBupFFe+ypby7erAKnDyBOt9nRZSmlvdrSxux1VvASAIg\nYd8CAJctwsN5usYm6kLJJ1goiqxzW5RZpnw2mCvymB0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfKzCMPVohA/IQbPT4YWrQt/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nN2Q3NDVlMS1lMGNjLTQxYjktOTM2ZS03ZTlmNDUzZjQ1ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6/BvcVPyx1GibhISgJ/PVI5JD60kmTyJ0Q7IzEkvWhRo6\nYAmZti+d7wGE5rcvj8fdCX6Iu6QaKuMVKUbLSA/Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmLyWEiUsXMbCJC23btlh1zo8\nAFswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMXv3A3K7pWK2bOq4D0G2lvpiqXCVDxeKrGGkhoqBA/cCIQCt39NgLiTS\n1XBGYWHr9RpPLbq+XkfXAM3WQRKS9d704g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATAJk/vpEQIc1FwNkM5/vqIoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJhZmUyMDQtZmE3NC00NTI0LTgzOTQtYzA5N2U1MTZkMWQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWUxZGRmYzQtZjJlOC00MjdhLTgyYjEtYzcwMTE5NmVh\nNDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV/qgTkbnMC6nJIOHEo14xkCJ\nKq3sJGykDlNdxyumzvvhsyIEFNF6Wd6I7AGtZVNSTfd7jl4Y9iAtDvlOxqhJgqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3MFTzG0Zi2PyXECEviz2JKM1FcMwCgYIKoZIzj0E\nAwIDSAAwRQIgfVqnk3nIoPPMHe39b2ZR/qzs/+MriGm68qEii8o33ccCIQCZ1Lig\ntpVJ9DmEF4FjlVLwzUnyZkpxUGnPl0kR1Wm30Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4451", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4451` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAd7l107eonI6Ha+Ej76FFkSTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlYzNmNTc2LWI2NjEtNDM3NS04NDk5LThhNzc2M2EwOTU1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMwNDJlMGEtZTA3\nZC00NjllLWEyMjYtZDA1ODhmNzk5MzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEopom1o3Bn2X7NXwp0VYXTCgqQgAw1cYrwhWGQ1eSo/R2K7qV7FxtOBec14dE\nbw5Fxc41yUnSqadWQQ8FUUssD6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5RPDT+xIMxMswrbUVgNlyepmlR8wHwYDVR0j\nBBgwFoAUxBMafvFOZMjds89LCk5XE0l79IAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBUmnUKe0tGN9idZ2bvJ9NQzkFmEZ0Jy\nlAkCF5wCFkd3AiAQmMFsNQKnzUqlhMyDIzUHa+wlUZs+gfmu1mU+BMvVsg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARH0xbzakSce212Ze/Jh5kwrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZWMzZjU3Ni1iNjYxLTQzNzUtODQ5OS04YTc3NjNhMDk1NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQR7bRyATJ8Mt7U/T4RUdn8exij03v/wqWEme/ey4CHSEtW\nG+JALUEbhRscF8fuWndJUjSJ7CpD+fh1CroJlOAco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxBMafvFOZMjds89LCk5XE0l7\n9IAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANbuWkzJ2rY82jtWyEo7Y7jZDj908YOHQsSSqoNe1SssAiEAnjVBmqOM\nB8W2jobB7Wsag+YFjPuEdg17SYw0zvjCOrs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAaPY5sZbpRHiT0a8wXkFmGz6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMwNDJlMGEtZTA3ZC00NjllLWEyMjYtZDA1ODhmNzk5MzI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTA0Yjk5ZDktN2U2My00OWQxLWFhYmQtZjYwMDg5MjM4\nZDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEytV/dwLexc/3W7mWXorbwokD\n4UWvUxBKDDjL743PVc3s8qN6bIx0J7cS1mXK/rqlCAWFVIS/TTYIjaHAls4Y6qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5RPDT+xIMxMswrbUVgNlyepmlR8wCgYIKoZIzj0E\nAwIDRwAwRAIgAnBGGc6c60cuHpZ3L+UD6HrbMPAJeYGu8hmi5b/CrrsCIDD1b1Kx\nYjcABNX+37qyQ8WkBmYXdB6R5cBPtpf1ZUgo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4452", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4452` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZtI/3ZWXaMt0yeC8QJGk/gyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjMWFkMDg0LTE2ZDctNDUwYy04NGZhLWExNDIwZjZlZTQzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODkzYTNiNTItMGE3\nNy00NzNmLTkwNWMtMWRiNTk0ZjQwMGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+YaYHl74cHQZ9E81GX2uYQRCTx+1jxdtBiiYLa9ha3esCZPcYT5Ylv6/7Zwx\nGHL9w7PZZdkZgMz+sLlkecxynqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTaZkhs0WWIwLmUkCY4TfpCCk7cUwHwYDVR0j\nBBgwFoAUmbgqWaAkmEjLp9R2OdemPpyyUC0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIDT7QmOnBzZ2XIPBpiLybKEZ2FpVVM8v\nWiYrfBPsFbnYAiAbBGXZEWcX/6nadUGoIwBCcZL4ld+aMeB/600BQWEL4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVNuvsIJ/LTQfu7xpov/6tmVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzFhZDA4NC0xNmQ3LTQ1MGMtODRmYS1hMTQyMGY2ZWU0MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+DGc1lGw9xLljjWxlf28iO/RuXILudZncC2wzG+OTf64H\nRuAZMIYrpX03ismBaE9LJ+jWbI/Xez4PKuBIeQQoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmbgqWaAkmEjLp9R2OdemPpyy\nUC0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN2cDigsgOJ/4mWn4Fa2VSl9wPQzy1zkPwAVCDyBXId0CICau4zRNsiqG\nnA/d/Z93Pa/zqrBstoqVAGKGar4YcXAb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAQCjEzS1Bo4CqcWNOnC6DoThMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODkzYTNiNTItMGE3Ny00NzNmLTkwNWMtMWRiNTk0ZjQwMGIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ0YzU3OGItNGJiNC00ZDRhLThlOTktMWMwZDgzZmY0\nMjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2U21OkLM+opRoJpXNXTi7N+o\nUlz71hcuvC5JVZrZzmgZBJJEW66PnUyFdocAWeDSIa3itjQQOrCinPHcVtQKZqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTaZkhs0WWIwLmUkCY4TfpCCk7cUwCgYIKoZIzj0E\nAwIDRwAwRAIgVH4uxn3yIE+BktyXlU95lN5yNYSNz+O7cgQT3+VN7jYCIFbs1vm7\nMypbuncMJMkAWpG6rgZSrFnJp1veKtLSQeJx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4453", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4453` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAU+2Wyrm16q+WMt9Bf1KXR0YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjOTc1NGJlLWJkOTEtNDY4ZC04YmQyLWZlMTlhYWMxNDYwNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU4Mjk1MWYtNjA3\nNy00N2M3LWE0ZGQtZWMzZGE0Mzg2Mjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDyqM/Aj+2s4rf1UeUPZTaQAPXWBx3xILqA3Kg+d9bRIuCiH1YuqT3490Sx1u\ncRUvq0SCVBCoiDq8vBWlWh96QKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC2sGC7B+ExkEtIeZmOxUcthCoNEwHwYDVR0j\nBBgwFoAUTC/eQ/EB8w4OK9x1r5sSvAfQi5owKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIFaQy1r8wM/3\nxyYJRZhYU8Yf6n+azsEGLL/ihzU+bE75AiEA+ZC25MjvezE9msORv1zmdZrlCygs\n8IhR25I6kU0rquE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQLzcs2Au2cTawdZlKsj3jcSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzk3NTRiZS1iZDkxLTQ2OGQtOGJkMi1mZTE5YWFjMTQ2MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMJE1UDsnHXExSRH+UL54asJlaTk9raYB3C8yoY4cxvsCX\nIAymQWNIwxEJPBAn2Tz9q6lHUc/qaC/SuoyF9vSao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTC/eQ/EB8w4OK9x1r5sSvAfQ\ni5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKnc7ZB2dIIfywyAyKZ7Gn4KrkQNgsAgWhviLR3rKmx8CIDdUfMFDeB/W\nwqOWRbqeFRv+sJtJfu+8ZFzgovJcVPlG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISARGUYuAxaXhv0x6VmtWOeamfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU4Mjk1MWYtNjA3Ny00N2M3LWE0ZGQtZWMzZGE0Mzg2Mjk5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjI1MThiNTYtZGQxNC00Njk2LWIzMGQtNGFkNGFlZDEz\nNzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6hr6TozAVATFPRBpbw4OlP00\n2fHL7odHLTnyy4/K19NNmdhystpA+da/cgg8zILYtjNtkvrrF4G5N5LReSxxcqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC2sGC7B+ExkEtIeZmOxUcthCoNEwCgYIKoZIzj0E\nAwIDSAAwRQIhAIlJgRYYgGJQknqA5Zzxup791pfAqqSCdwr+jmYSWTkGAiAP69qY\neb23epI/pRtAo4SkXdJD+BmCESjJcDorY5Ttkg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4454", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4454` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZW1IZaN3gawrl6lrBVBx8w/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1ZjlmZDI0LWQxZDctNGI5NC1iNTMxLTFhOTBiMjhlMGE3YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJkZDUyMmMtYTJm\nOS00YzIxLTg3NDYtY2I3NzcyMDNjMTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERfMss6Aq/71FbNcKYpq/sma4vvLvysiDo6S18WmelIuPIgchMn9YYAcKtm5J\nak7tMMoNK4hl33Dk3LEEnW8AK6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnK4rHnUAgj66mkVCxLKhccpmUTYwHwYDVR0j\nBBgwFoAUNVJjEenZfL+4Cb+cIvuUnPsEVAAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgHVHWdOGX6Ch6iSb0YbM5oCi4aRGITmgGZVjm11E7fUgCIQClpzW+HZMa\nQwJJ+MZmL0Bs9zNCR8OaIw0iCeAIyNNeSQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWZwnf2Gv821+jGObiE8nr6oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWY5ZmQyNC1kMWQ3LTRiOTQtYjUzMS0xYTkwYjI4ZTBhN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvkDcoLf8Q+Hhwy56Mvyfdpn4R3cW4Qv34DreNdWSxIcXm\nE95TcOtOWtPlNfWhBzdRJ2KL5J4bBWauR0zAOBD3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNVJjEenZfL+4Cb+cIvuUnPsE\nVAAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJbkema4PnnThGAjk6Vl+m0DvJmBhh+5D6FbqDu7ux0oAiEAw24ok7ft\nDCWb6naBRW6zUoXLwMG9KNbwiU9VmBAUilw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISARXRpZ8KuZE7zZUQaTyjxnwlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJkZDUyMmMtYTJmOS00YzIxLTg3NDYtY2I3NzcyMDNjMTNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTkxZDY5NzUtYzQ1ZS00NTUzLTkxZTEtOWI0OTA1NWFm\nM2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGchYJX1EWwABxhGGwTZqAAU8\nE0Yalh7N1Z85xDO2QA5AiL361fzLvt/oAlWPUGhU1cCD2kGCtpt51sm2BhRTSaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnK4rHnUAgj66mkVCxLKhccpmUTYwCgYIKoZIzj0E\nAwIDRwAwRAIgEmXsPBLK428pmV85aJE9JTTuOAYzBu1g64JU/RN4wAsCIAoaTU6x\nsh8IwUkYIprvcG6HovLHp0RP6IXgFJj/sQec\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4455", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4455` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAb9On46HumTNMjxgYMFjfYqIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjM2EzMGJlLTkxODctNDUyOC05MTE0LTQwMTVlNTY5YjVkOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg4MmY2OTUtNzRi\nMC00NDVjLTg1MWMtNmIwNGFkMGYxMmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOw7RgNwP7GRqmoObNsFAzXeQJZoLQHWfIyG706JQKMZJetLUaiK0Ojb5fCzK\n+ubGyfXWPvDZ3lK+DpIGnEQQf6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8GtWPC41guPiCxHZg1gyIe6rUZgwHwYDVR0j\nBBgwFoAUtsBpyObkMPu84ocWuWUFl8BmmxQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgBDaNvf2T9+Q/OKZd5nri/nU6IwlLb8GZvd8v+2PqNhwCIQDeHEhJHs4l\n++ROQB0rh81+aI7iN7njb2vQYWnpt6ESwA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQOxBT3CakXeA1i7leQ7vYlmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzNhMzBiZS05MTg3LTQ1MjgtOTExNC00MDE1ZTU2OWI1ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXwYykXObzmljs1zfqWXiF2fQsJpupH54xU/36J2T1bbQt\nMcxJcMROdDayzY/TnLIrqnnJKTDHr+v1Dev3So6Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtsBpyObkMPu84ocWuWUFl8Bm\nmxQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBW5fqbi1C7LV6e0JDETsSmenI/952SQ9kit/f5hojaUCIHfoopSvYjkt\nkhytxHcpfD6kBPk2KR1rITr7TvPst2cB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAeewENCh2Owf0qIjNzRhm9HsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg4MmY2OTUtNzRiMC00NDVjLTg1MWMtNmIwNGFkMGYxMmMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjc0MmI5ZTgtODZlYi00ODMzLThjNGEtNGY4MzZmZjQ3\nMmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+g3PQCAzOSJxPaDwngMcYskt\nT4V4x+PYDa6afBRCmKcgwCrNO++J/3chC5NRT79KcxPoKIVntG0hGXhg8epfKaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8GtWPC41guPiCxHZg1gyIe6rUZgwCgYIKoZIzj0E\nAwIDRwAwRAIgcLTMsZsnTIUZSyTOtdX+9VHEhjesMeM8/K/bqD3LOy4CICTE9/qc\n0TrGEXbwt3hd0yzOZkKJvOmSZPN5ch+JBgta\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4456", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4456` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAcWfkSreEToHkrDaFyb1ee1TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhY2VlN2QyLWQzMDMtNGFiMS1hNGQyLWM2ZGRjOWI1NGI0NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdmOTRjOTQtNTIy\nOS00MzYyLTgyYmQtOGZkYmUzMmU5ZTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQIQ21Vud/JA31jysN4FXJrQ3prr4hp9RKh4SBpgMMhDKxi049hUdi1sIC7lf\ngJ+pwNSg0pif4rd7QnCfn6CwZKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU65B91NWuRikHozH7WujxnJeU9m0wHwYDVR0j\nBBgwFoAUDkh033CaKd1KdPO8L3hHLEZlpXswOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQC+fYsqunb/EnVPeyy+aeoe1LMHNWWZG/0EcWHdoduiRAIhAJXzefi5\nW96EFKQRyJN0AnEjrzgEDJ2ssJCTkaEizoiB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfvoqyVPaiP0orsy5lnNycOYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWNlZTdkMi1kMzAzLTRhYjEtYTRkMi1jNmRkYzliNTRiNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJq1C83Dy8etdwGDEGAIFCvBJDumJY9BDg5DNgnnb+Efj+\ndVJ/x1bIGUCyiI0EnCFr2VhAUCl51obH+8oFQBZEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDkh033CaKd1KdPO8L3hHLEZl\npXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPG3DxpfwJvpodZEHF2fVqNu+WsNzrouDwreGMXesP1oAiEAwCkdEOgk\nXVa13e0rADlT4Sz9pkiFG1Q4RQyfNbhmcyg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAefwOuhZkUC+HEUP/jUkNLz0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdmOTRjOTQtNTIyOS00MzYyLTgyYmQtOGZkYmUzMmU5ZTI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2YzNTYxZTMtZGY0Mi00ODNkLWEzMzMtYWRiYjM5ZGI1\nNWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVr+1DojhgBUIjbuu4dzV0n55\ncjwnEQ6MzqzGpWXoYHLeLJVT8oVT6McgUveAjbFeJeg2azActYNg0OpIIfnvA6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU65B91NWuRikHozH7WujxnJeU9m0wCgYIKoZIzj0E\nAwIDSAAwRQIgCWAJkXb2J4q5KIIPysRxdP3j7SRMIteYWOLlJEiECY4CIQDtlbBL\n71G3n4RYIW8aYH9Hzl7eMGxh5a8PFrzop23y4w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4457", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4457` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAfP8sHGHIQ7kKcm73CTanowAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjYWM0OWZkLWE4MmYtNDA2Yi1hNjYyLWNhMjEyMTE1MTJlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM1MGUwMjAtNmEz\nYi00ZTJiLTllMmQtMTAzMTkyM2RkOWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqAdE6qNkJiN7sgR0Hq5t9PvJV6EYL4eXmvQjiAw6oJcPayQoW8Qf2CzJb+Dc\nZuwKEs9TSV1wmJNBNeLI2KvFT6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFRPiZY25iZ8nn3EiQoHGZ4gA4CwwHwYDVR0j\nBBgwFoAU08+RSL+bM++X4TsH9l8K3Gppe9AwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFVZge6utFEJr1sk55ionVxIvWj15zjl0f6iyjIW\nFhUOAiADhY/3i1YG8/uUepnGUGWiDGHx9+BFkPbPakS4BFPZsg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVRxRnBIMz4QaYJCjW0OQ7JlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2FjNDlmZC1hODJmLTQwNmItYTY2Mi1jYTIxMjExNTEyZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq/IKp/UAOmfuQQeJ9aT3lg7gtXImyrM7Qw/hUnSMQTInk\nfwuH5IAl3cnoyTU4GpR+LFTygzVEzfd+3FQ1Nlq1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU08+RSL+bM++X4TsH9l8K3Gpp\ne9AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDO472NgHsBzYPwGnt1zViQsYfpuVELcrhI8VaRxHuEUCIED0zil+xLGX\nJqNcgh0YrlsH+aFmZefV1PVG0q8mOZe3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAe6GAwP7c6SQA/1SDVJBUBNUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM1MGUwMjAtNmEzYi00ZTJiLTllMmQtMTAzMTkyM2RkOWJjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTJlMjY4ZjAtN2ZhNy00ZWIwLTllMzYtNmVlY2U2ODgz\nOWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOsNL83u7rJbp87eoUJUXeHV3\nbXHiEhaAdrNNcahNf1YtcjLgWNouSAe/A/6q1+iOdRw3e051oymE0YyWPty5CqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFRPiZY25iZ8nn3EiQoHGZ4gA4CwwCgYIKoZIzj0E\nAwIDSAAwRQIgU3qrfkq6LPVRuDogT1eqN368QzeoDgD6OE0XV2k5vAACIQC6mqGn\nAgIg/vhAGclspoB6o30RhtfkKyLJMokE1QvrRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4458", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4458` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAT9PRUymNNJ/7xWxv215IJo3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3OTY4Mjk5LTQ3ZWQtNDI1OS1iZGEyLTY1YjkyMjQ4OGMxMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDJiMDIxYzEtNTRh\nNS00YzlmLThhMTAtZTNjMTdkODA4YTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcphX9AAm77zN/Tt0wNZyg8jOBhqOvg+U75ZsaupkKCk+EFy2PAWu44biDDlX\neKYSvTZa7dzeVSui3p1GO7751aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUICLgHvy1jAR364uIqGEVlUYYNzEwHwYDVR0j\nBBgwFoAUiFD3MR7buuvvXngHgl5axXzpy7wwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEGM2/mrhkuG97RAvMKyvhSPyZVNZGMs4p7cVrnf\ngn9LAiBk/Mg+EpbwPolAw/ysKWrRAozY+aGJq0MQN+5XYoRQtA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASMx8ed1khv4hIS+F0ZYsx6kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzk2ODI5OS00N2VkLTQyNTktYmRhMi02NWI5MjI0ODhjMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWZZF5Ls/Ht+YOnr/HJlVQ56iRmUPtho6T3Wnx6lg3EGaY\nX9GkHGSwfCmBSGx5AzNNPC9dZRHsWhdKVJIHZin9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiFD3MR7buuvvXngHgl5axXzp\ny7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZP7A17DaJ9860EsYmgIDxDhOHJZRipm9VXy8oWMOD/0CIQCHtXCeOxUk\nSWkPPJrFTmSMepyYO2Kd6MO7n1QW5Ukeeg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAdcLKUu5qCAT1ftfzjGJjFJHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDJiMDIxYzEtNTRhNS00YzlmLThhMTAtZTNjMTdkODA4YTFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGFmYTM1YmYtOTE1ZC00ZWVhLThlYmYtN2U5YzI4MzVk\nZDEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuBSkOtg0IYP8Yp962yBr4H06\n/0MLV3c0AOvmxoZU9f8KkCZKw3tHpAwWAAm/aEkh+zUHayLwoXD2TcSIjxkO96NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUICLgHvy1jAR364uIqGEVlUYYNzEwCgYIKoZIzj0E\nAwIDRwAwRAIgUlzz62D/n+jd2tYqVe/oivmMHFJFfALhnJIjlzRUOwcCIHg0wIMl\nz2uszHKxascjB9pUaC72mxIO8eu3drbgABKq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4459", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4459` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAT7uyiriqa37dxoWiOgqDKVgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1NjVmMDI3LWJhY2ItNDhjOS05Mjc4LWIzNDI3YWJiZmVmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ0NTRiYWUtOTcw\nNy00NjJkLTg0NWQtYjczY2IzZjZjYTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoReM4sSj5qKraQdnaOem6vZ0Dp3hzkMAcFoILL2dTvd7uvliRn2E2YNXLLqc\nnN9g3UCXxlqLCnQYUrto58AjCqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTfpEPJm3H2ozSZhSZbYwIjKApu4wHwYDVR0j\nBBgwFoAUovB4EgGnjrtPxyiV7wjIzdwb2fswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCtAOWTzYj52eJ6euyJ7oeZXgyOBO4Np/UNBubaHGHa4gIh\nAONZmR2B3J+RB1V11BjYXjuA7Uxb3jEylt6O0ocR+B6m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbDQQMKxtFmOK04fpT1+jQZJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTY1ZjAyNy1iYWNiLTQ4YzktOTI3OC1iMzQyN2FiYmZlZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6RyAepTA5BOUxeJPRZWqcgHhGlZk5UYl6tn7BeP3XROxK\nURYya/6cI92amgAwkq1UutpeL3oG0iOIBVFDaGS+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUovB4EgGnjrtPxyiV7wjIzdwb\n2fswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVdP4IxdNtWs4cXfeYPCutGIiAzBkrKLpVLeiftwepm8CIQCQ2KYWlNNG\nBiOE+g+LkNGV+xIXhS74oZrg+13jc4/zTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfQhJk/NmgwA4uylMuYB/4QvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ0NTRiYWUtOTcwNy00NjJkLTg0NWQtYjczY2IzZjZjYTM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzkzMjIwYjYtOWRlOS00YmFhLTkzZTMtODk5YmViZDk5\nY2VlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZlXGjqj1dXiVhcMWA4pLO8qa\n5nJz96rzt4llg8qy2GzAq/x1Npg8xTRqRatamgl8gbvuXdHB+Gkzpo0uoCxtVKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTfpEPJm3H2ozSZhSZbYwIjKApu4wCgYIKoZIzj0E\nAwIDSAAwRQIhAMcfcVEA1YApQnnYsgwCXeKWYM8qhraIhi/PfSjR7UpqAiA+ojV7\ngX8QsR2woh2LMKp91nTRthR5GYMoXsPfTreIcQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4460", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4460` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAcMnDMDXdMnFfbu1aeEH3/x3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4MWUzNDc2LTIxZDMtNDExYi04ZDVlLTdkZmQ2ZjRlZmZlYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhiODY0NjYtMWU1\nMC00OGU4LWE2MzMtYjEyYmUyZmQxYzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfmef6rGmMAuuofbbq7bqxdZD9JMB47DfFBX+iSnChPTTIGdwT9/Bew27oXZx\nR7h0Cu1KEN6ikQshP9ZBQDkGpaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdTxAbXkj/45wbcVtMhFh3ZTdSAswHwYDVR0j\nBBgwFoAUUbQEH+juvgZnq662Smu7LW7DoJ8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAMJJ6MDGTJyaeeS6lcR1RyI2KLM/S0i\ngzp4FGVzuK+DAiEA7rfqgHzEJdQ3K6tjFKTjrx65cPe0IreUIEj+PLooKaM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcPB9GPo1+sbHAFCNJOSepwqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODFlMzQ3Ni0yMWQzLTQxMWItOGQ1ZS03ZGZkNmY0ZWZmZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvX6MywP3TAPqIWxtDCJKeCnnx9tygEQLDiyaNtJjHpUgy\n2eZJVbzVA8atYkx9DvAAD0eU8OakLp3se6Th3dp9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUbQEH+juvgZnq662Smu7LW7D\noJ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNg7bIlsvBuXbm1DnXvauMHRypUrmFeQs/fmP5oMQ9OUCICsMtN8g4snW\nEtMr4Mk6x/sYW7qUquyBQYpCr2q5XmJJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAXgpxPAPwTt+DL4FML471+lmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhiODY0NjYtMWU1MC00OGU4LWE2MzMtYjEyYmUyZmQxYzQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTQ2NTcwMjUtMDE1YS00OGQ1LThkMjAtMWY5YWI4YTA1\nNmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPhBJN4I5QGauPF4YQ24wD3CW\nhcIjyYcgHYWVu2uAYniTy2UiNiyzByQhB0015fc4lXb320rcVKFsEddUi849lqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdTxAbXkj/45wbcVtMhFh3ZTdSAswCgYIKoZIzj0E\nAwIDSAAwRQIhANxFa6VDMK6D+h1DbUyJ4FQ63pRztM/+M1mwwgwfPxCDAiATp7eY\nOxWnLaBHnml2RGMQYWtP7hetK0Z6d/bEH43LbQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4461", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4461` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAVJh+47LIZEpNay59my7qiz7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkZjgyZWZiLTg5MjYtNDBkNy04ZTQzLThlYTY2ZmMzODk3MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM3YmIzMDItZjRl\nMy00ZmMzLTgzYjEtYzFhZmE1ZjhmN2U2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUSPdv9CEpjg5l5jZmDsqb4KHFQ+XT2YUb5VcD4s8AQFrGq+yHsNeuQa637rG\nTAP4MMfx0xi5PgYkHB4f+3y7xqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX+I5CAtjpI/TpjiWLTOUe+m39KAwHwYDVR0j\nBBgwFoAUX3Cwc7J5Kmy7yyjza3nRJAQJJkgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIHOmXhU3XfH6r2daJYKivj/tLfLaz97P\nUMP4pxzrsze1AiBaHhrm9rudzD7jbRbTuZfofiZmxm8BNDU6gUzVQukmlw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWNk+3GGYW5XWma5Hw+jplcaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGY4MmVmYi04OTI2LTQwZDctOGU0My04ZWE2NmZjMzg5NzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6vz7WDMprNNy6XpyL8HrpX6NpTXccsU69Yx1kAgFZFswE\nMJHMF76rYs/rKkSebGVTFamdgEUXk2HqWNH/gBJ7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX3Cwc7J5Kmy7yyjza3nRJAQJ\nJkgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMHotJaCj/NNw9k3vwDEphSkZLXQlM1vASFl6aGa5k38AiEArc8qUkvV\nSBg8Xx2nnUyK1QybNBAJ4jCCcG2p3BK1E+4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAZAiaVjVUDZdxQCA+B2OhVYDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM3YmIzMDItZjRlMy00ZmMzLTgzYjEtYzFhZmE1ZjhmN2U2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmRkODZlMjItNjMyYi00YTJiLWIxMzAtYWE2MjA2MGYx\nNTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPqhLy+LiLcqGVSkF3Ukt/g6v\nyvMs0g7r2a/nhCTXWTmsdXKZP/o02Y44z4Au610DCHn73XKfTTeLe1yS1iht56NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUX+I5CAtjpI/TpjiWLTOUe+m39KAwCgYIKoZIzj0E\nAwIDRwAwRAIgPxduZmKFkfmeYLu7Z5jv4qjgty3qS053uWPnGrKl+XcCIACCIz8X\nUVAN07KXZ8W6CnLoeKAYCZzNXgHDDCSqOFA3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4462", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4462` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQPVPtyrGjkPuW5hN2OXRf9OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljZjdlYjBmLWQ3OGYtNDBmMC1iNWM0LTMwMjFmODhkOWU3NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgyNmQ1NDUtM2Qx\nNy00ZjA0LTk3Y2EtZDU0Yjk4MTNmMjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ94oIiQCTknQ2YQx+ol2B5R17n7xbVClO5/TR2Bk44v4Q0hOwuLdYonQMkjF\n5m3WCL7QX7pZn6MpYIYm1m/4g6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIb91W9eaCHXUvq2iY5o68p98t7wMB8GA1UdIwQY\nMBaAFKtQ6Wlg1zPsjFaiQZtMjnDZLgldMAoGCCqGSM49BAMCA0gAMEUCIBoGhhTD\nzJUtAe4s71+/IkKIMj4ev4C/MzqMQoJuMJkTAiEAskOnwIWKgTSDpgLmdBnPgO6N\n7HhmdkjT3M6dSe+D47k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARsykM0OrPOHDIBSrtPrWEQmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nY2Y3ZWIwZi1kNzhmLTQwZjAtYjVjNC0zMDIxZjg4ZDllNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqqjdhTJRkchLnjKyI5U/TxGVa1HOfN/FRds3e4xQHpQ0k\nJkVl+6WykiKIL3sXF5uhPlAq6n0NcY5an+AkvuZ5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq1DpaWDXM+yMVqJBm0yOcNku\nCV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLPT5/pNBr1BugdB6l93jOjHRWQPlDYcGSQ5xBdbK0uICIQC0BbdegkmE\nVFEKvtK64v2K3pHFmdQ4tVA2gx17mMC/Og==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAc285K1HB8f0+AijdPn/cug3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgyNmQ1NDUtM2QxNy00ZjA0LTk3Y2EtZDU0Yjk4MTNmMjhiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjhlZjNlMDItMGQ4Mi00MzZhLWIzYzAtMWNiNGYyNzVh\nZjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfjnprYScuAQ9ZoAyPHbrPEmC\nLhLOTtdWCzA5BOIgYWvBQ2kp5CiT0cinIxI7onh6rkOsaJsN0l/gAnI552zxyqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhv3Vb15oIddS+raJjmjryn3y3vAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA6U+1CLMQYm9cppuUaN+zWkQyuAbt\ntgwqE6GGeBr9HXcCIQCzzKTerOGFx5Gt0RVp4OyNCdyUy/kgxWV/BJbrv7UxTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4463", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4463` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcuv5GIFJJpXeXFC+Pbf7uyEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1ZjIyMTk1LTc1NWMtNGNhOC1iMzUyLTJmYzJkOGVhN2I4MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JmMjJiODgtZTBh\nNC00YWI0LWFhZDItMWIwOThjMDVjZmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhEpXaaHOympZdaiqa+CDd5uEi5IVnW8n/VgSrpxYodYuR+PYFC8UDuoKDecc\n399KDQVyFkbUR4rwymZjLfBwwaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFChF92PfFkDgfJMdX8e07/NTTSXuMB8GA1UdIwQY\nMBaAFIMETKC/b02eNtNzIYTpPqcb7uQqMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAjAz4Hdvs1G28jzvd6k+RcAhYk3a0SvhOD\ne0rOHHQovwIhAJfNE7jNi6OJMDQZDtk5DyGrnB9dkzyqf9gTe5V1a/lU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS3scfKAvaLrKZnnvRKu6Pa2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWYyMjE5NS03NTVjLTRjYTgtYjM1Mi0yZmMyZDhlYTdiODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlcue0v9McRkIhZhdOXZZN1QpcZe9NShDukxoxblh6iwzu\nFmlmcj/cTuHnsNYwVKAeB2IYGVeuj7jBdYWlBp3do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgwRMoL9vTZ4203MhhOk+pxvu\n5CowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXlo0LV+m4Fc8Eh5XRYmCorDQxGl8O6l20dkqAM7NpWsCIBQDGg+0LidF\n7kKDTLZoOd5xm2GvgO8EBt2P3++bmaLH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAftGV1Pv98MYBJqQyQT8IKhsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JmMjJiODgtZTBhNC00YWI0LWFhZDItMWIwOThjMDVjZmI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDcwMDBkNzUtYWU4ZC00NmRhLTk1OTQtYTQwZTlmMWIz\nN2M0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBo/OOUFEfQ36EigKjdASmuo/\nSJRftOYjffIGK6s1AEpWjjE/Rvi/+PWL/t7tD3zvFwB0IaKpRGp/yHeGin+yw6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKEX3Y98WQOB8kx1fx7Tv81NNJe4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAsSDAq5JJdA7dfLqryd7eCx/vdrWQ\nSGn7OsGFSlRMrhsCIQC1tP8qcLSTrYxl2RVwnBHtydI9O5VAMRdoyKCp7ERcaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4464", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4464` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAbHKVHhpVb1bY1GNo61GZ5qtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1Yzg4ZDUxLTQyMWQtNGY1ZC05NTVjLTAxYzU1Mzc0OGRjYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzI0OGU5MmMtZDMx\nOC00NjYzLThlNWMtN2VhMWRkZGM2YWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3l479ze7IxlZN7ioqFb9K+UydMCUfUU7CyQ/1Mh/5bEugyItsTCg5N8lxLKJ\ngUMNSIxVoVxMXT9n00H3gFSxgqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFE9SqXlTng96XVJhdH5rros2x//FMB8GA1UdIwQY\nMBaAFAArKhVcW6W+cJvFgXn8vGkBEupTMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB3RqG/k2jejsYbT6nDgF4sSqVeXPvBEb3E\nnaZ39t5prgIgR7LorHic08Xnu7QxBzXx/3SCFm0oodQnH7Y5U2o7OOA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa2aohms9EsUZrMhjgpTAyrOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNWM4OGQ1MS00MjFkLTRmNWQtOTU1Yy0wMWM1NTM3NDhkY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2tnxVQwhqkaK8Mo8nudhnDXMigLoPD0YVxV3y0U9JC8BK\nnRk6cJxqoQ5KuMB3gk60FJbF3BNK1MLPR7ez1Gfjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUACsqFVxbpb5wm8WBefy8aQES\n6lMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWl6AFO0sUQ3apz5CnHe4bH7YbVMpSDtmAHpjY9/0KVMCIQCUcEzJ0iw6\n6vyCkUN3Tx99MN10jV43/VlQVbJp1l0MpA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARL2Bd6z38qZ5ctJEDtQPYl+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzI0OGU5MmMtZDMxOC00NjYzLThlNWMtN2VhMWRkZGM2YWRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDQzNmM2ODktYTJhZS00ZjQ2LTlhZmYtYTc0MGMxYzdj\nNmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPn4Lr85fzc7yc44Sk2Ho3WUj\nw6Hq+tGzNE0tDot+aJ4noc0XK7rzl7+x2t31JBXf4wCRCl8+Xi8/3S8T3OP8TaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT1KpeVOeD3pdUmF0fmuuizbH/8UwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBSZugnyDa40mPM2aUx2FZODFIK+Ua2\nDw26g7zLDy3ubgIgM153oFfSzOWGlnKEdAczEfZEAgvyP1pBti8K2sbY+Qg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4465", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4465` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdXomY/ZEmVtcB4Y91UvI6CbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiY2RmYTJmLWNmYTItNDJjZC1iYzk4LTk2MmExNDJhZjc5MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZlMmI2NzEtODIy\nMy00NTQxLThlYTMtYzYzMGFmMTNhZWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf88viXp7WV6Q5ohMGUB+paSsPB3Tb9VF+KYh/GrvzMRWf0Y9T9QV1y7ZDhsF\n7YiPt15qriUcwbfG5KB4/SkfKqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQJBQ1YDD2yyzK3wjOiw6bMnRHJyDAfBgNVHSME\nGDAWgBTW/DDOUGTmOpBcdyOQyPgk6owinjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDsaPaJhBh6vGyFYnd9F4HYauIFXRsL\n73fQJoiYG0jGmAIgYheU84Fl0V5FmVhgHBgrg6X47SwGf9t849IkzBWuAjE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASBOxKbffngtQCoO6uSLuLPyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmNkZmEyZi1jZmEyLTQyY2QtYmM5OC05NjJhMTQyYWY3OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDTA4Q3KZ37uDMj6hbdqDNy3MfaGMFh6/HZGZfy4bQi09B\ndz+foV03Oktwb+GutWk8Ui8lUR5WBvVz2mUICR6/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1vwwzlBk5jqQXHcjkMj4JOqM\nIp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMy61nBGjQqH/QV1TXjsA0UQgycfEaCVX8kMIShOwSC8AiEAvHGLyKkO\nPt1ZcucSNYFaKg+X5rBKTUpxUzAeLulW48Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYPwfnWdIB/rn8ia0HqegXpQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZlMmI2NzEtODIyMy00NTQxLThlYTMtYzYzMGFmMTNhZWIzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTJjY2I4NDQtOGJkYi00OGJkLWFjZjQtMmE3NmM3ZGJh\nZTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXX4ymuBXQdvW8Gotz9CTrr3f\n+5TXfsf1x7qvueBE2/EdRR3WNOJlxakSIX8VfJRgSVsiQZOp2b/q4xgVY2WU+KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCQUNWAw9sssyt8IzosOmzJ0RycgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAW6uD3CqxIee0EkDPr8bXKMGaAbuZx\nUBhJDZGrJVSFEgIgc/wxNY+3UcR+2MQofSomHt3L6gBayUmJhJos8Lo9lxw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4466", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4466` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfx10nPJXm1zMwe7E7ZmFjfGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNzcwMTU4LWI4MTgtNDE5Ny1hY2I1LTY2OWI0NWNiNGI4NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZlMWRiOTYtYmQ1\nOC00YTM3LWE4NzctYTNkOGQ4ZWQ1MDEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE51qIlBk4Emkmf3xe6hHcBnW5j6Zt/e5QQL5IBV+kgFqzqDH61t3AzD91WEIs\nsxjSI1gVcGyprV9DTRocEPLSWaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIpzGVyQHxuolYhyG+ZZb5MjpLF4wHwYDVR0j\nBBgwFoAUFNrM1CfuxmLHuBwPM50UG84vQEIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAEtejuJsCuMHzX\nPwVPg58rpXNKY8+eO36ZbebttAuihwIhALTbQqFPZuhHQvYKR3fQ1m+fbJgCBF5n\nFToEaGHMM5oa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeA7FcW2DrJS47jah5kHwvgMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTc3MDE1OC1iODE4LTQxOTctYWNiNS02NjliNDVjYjRiODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMIDcSuObNQWowTHVqxeABe6b+OVZ5jq6JGNCbnoMcn/9h\n0UjhUASEf7K0jndcBn5d8xxTbjQLzEQuvhBFWnOWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFNrM1CfuxmLHuBwPM50UG84v\nQEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKXgis9ULCjfEY3+w5OhfcLY9IDOyaDpmUoJedF9Xqq9AiEAtxtnRDv1\nkAelIZY3hfT/U6V5UQAgVDDq3w8FH/Gu4y0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdbdGUIzFab7Pi1X9rH4CiJWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZlMWRiOTYtYmQ1OC00YTM3LWE4NzctYTNkOGQ4ZWQ1MDEzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2VjMjQxZDAtMzYxNi00ODU3LTlmZmUtNzgwNTZhYTM1\nNWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHfcRPBkb9DEpisDs9Gy9b/eR\nA2mbmAGGndZ9PTynnQ6XYyaaLGW0tn9MvM3QIpgsZgHw+8GKdqiKvxbHbjFhnKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIpzGVyQHxuolYhyG+ZZb5MjpLF4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA79MEeMYcgfVd3Xq6ayKqKapEibWr\npUp/+HctA/TrOusCIQCZoYuMqOUPLn4swceACC+0LXjUGKPVjgNPwJY/H1mk/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4467", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4467` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISASH+hwvqiYXsOf5iol113AzlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmMGM5ZmU3LWFmNDItNDUwNS1hNzhiLWIxZWM2MjFhOGRhOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdlNTBkMTktYzEw\nZC00ZGNmLTgxNDYtZWNkNzdmMzc1MzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE674eAXNMqKxCJ9ljg+KEsvM+DALEAUyWwXyyr3cIKmFs1yVAj/5W7JZ+Z1FZ\nf64an5DSd4DTP/qz/OztMQNPtqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUar9lH/R9DlAcamfsulHb4T5WkZ8wHwYDVR0j\nBBgwFoAU6VNyDWOoFNuldsp7OnUHCvZrxKQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBKK60xVHHeaiTP\nI9sC7FtPRkRZA3EHLDEMq8dcWr6uBwIgGm+KG391tXWlUvFKCaxBgqWKBGIKwcQC\nIA+AJ/kjohw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUZ7EJ7lFQoxSEWrASUquDnmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjBjOWZlNy1hZjQyLTQ1MDUtYTc4Yi1iMWVjNjIxYThkYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATH4jzY9inokmJAS1Rua8dQ06u1WHdRtft1EW3xFx2hA4cK\n2ibpBd9AuuzEVCLL06tTlayDKqnKSA1chBNU+0/no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6VNyDWOoFNuldsp7OnUHCvZr\nxKQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI/Ynwa/M3R2xEXdiscMGumsjEz9IeNwLD1VuM/jK/XxAiEAlwiF/Uhd\nIxQrmAI9HAPVo/1ZWmAU7PNKnkeYL/bu+7w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZRO0V5X2Va1blZDo6RsXSzUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdlNTBkMTktYzEwZC00ZGNmLTgxNDYtZWNkNzdmMzc1MzgzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTc2YzJjOWMtNzFiMS00NThmLWIzZGUtYTAwMjc5ZTBh\nMmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk1kUlPqgKwSf91AqoTgRdJ+h\njVLkStJgDjt8bQXWTRaYkLsdBsg2kOPK+Rbz/AkC1IjgP4M3xenNaJc58tKWNqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUar9lH/R9DlAcamfsulHb4T5WkZ8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAw3gEr8NyIzQ+VEioQGCTNEG1A+vo\nL7rE3kfVe0NumEwCIGdgk8o0rOf448lSGCNMl6HISlF0TESNUqW73oY2+/Jw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4468", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4468` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISATwvSEeFQbPxxNgc6Km+jLWZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4NDdhNTIxLWMyMjgtNDczZi1iMjE5LTZiNDcwODQ0NTVmYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFiOWNiNjItZGZm\nMS00MzliLTgwMTUtM2MxYmJlYTAzZDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuhvkH5+XqFV3PBT9Z7eBWlS34LlKbPR99O9ahSDnN2Fe+Eg8LV4cRvk/exoZ\n/+WJiGHVamjKJLXHUUkwKrP9cqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5aOi5z9s03MR98S5dgZfZ2dyysQwHwYDVR0j\nBBgwFoAUiNDkYehRzbmhUh8sidBgKYNOyGgwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAxcZFV2QjD///FGR3sr/q\nvQUwTi3jRgBGoK0maTbwihoCIQCdayA7yAhjecRiqQIcyO0lkRzHiTcftm0ghh3Z\ncTiDyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcaMrd/ESDWi0PB70QeZCarpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODQ3YTUyMS1jMjI4LTQ3M2YtYjIxOS02YjQ3MDg0NDU1ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbt191cz/uBLP5hewMKbwIOt5BlZnyOaAelPKXCeNDFZrr\nVvbEBT639l3Fzv0vnSt6KUG5L+Hp52fIIpYZOcYqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiNDkYehRzbmhUh8sidBgKYNO\nyGgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPZ7noMfUDKhbvzG/21WFuC1ug5c+znAcj6SIATw5r86AiEAyYRNrEB5\n3TAsUAu4Sg03yN+a+EbFaN2KXG9RCA7HA6I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYkEm9QD3YLUIrQAaszNLPkAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFiOWNiNjItZGZmMS00MzliLTgwMTUtM2MxYmJlYTAzZDY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzA4ZjI1MWQtODFjOC00YzIzLTk1NzUtOWNkNGE3NzZi\nMjM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEauDko9YsDfr+RmpgdWZ+u2oU\nBu5yIHpfJ2G/7Pof0VI+uZWEOaVz8f+J8ScnGqY6OCHsyraIimOtkJb5HbnCBqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5aOi5z9s03MR98S5dgZfZ2dyysQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAuWcu2nXmwTeWEKUqjSr+amYWnQg+F\nMALVzrx+nInA2QIgWkp6dbmofCVL7OLVMEb3tQsUnEkH0KTmEGt0mRti2OI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4469", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4469` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAZDt4oSrhucnITf6E1keesWaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjZDM0MGM4LTJjZWEtNGMzMi1hOTBhLTJmMmI4MDg0YjYzMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJhMmM5NWItNjY5\nZC00YWFiLWI2NTctZTkyMzUyNDAzYjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyB1PcfoZwnfMUbbruj0PFg+vrR8has0twDQDHBhbxOVLFeIlqhj+WIvxlFqz\nqsstSN7N9m+BUNeloxhFKIui4qOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpE/xYlPfSSzYyH6RZK8fVs4YvpgwHwYDVR0j\nBBgwFoAUBAUTMLzIb+oMRJG3AGRkephtwNkwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBTd/oB\nmA4oNwst+DAwKO8RLoGOK12xccAGL3YolaU3XQIhAPAgKvml9hGO1a5iWR91nwJh\n7Rakj4GePOwvOcKu6Vjk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY+v6OjndEFwZmIyDtuiOfO+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2QzNDBjOC0yY2VhLTRjMzItYTkwYS0yZjJiODA4NGI2MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/zZEygoliEqrRQxE3nKHZy8ve9sHlNWb41WknM1h1hikc\nGHuLmRoHLCga/hHK+emvAabElPFJAcZYiz4R7ilCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBAUTMLzIb+oMRJG3AGRkepht\nwNkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ4cdcMel/ZxnmW03RlDHBDok1oxQ/HN/ECiQKwb02E6AiEAjHziLM1h\niPWCZK7JqpNPMZ86FiZHgyNGwKgwpC17ZT0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASlrPdq7buPm8SXLTF9LKdYyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJhMmM5NWItNjY5ZC00YWFiLWI2NTctZTkyMzUyNDAzYjFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmRhMDFiMjQtOWQxMi00MzJlLWJkY2MtYTFhYmI2NDgz\nNTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAU8Ivb3tMs0/IEfl8kDjgt/T\newWiNHk/J3xfUpY4LXRREt9nGU8Jm8f31eU/pTmylXD1S1SYyuBxTeOllAkhpaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpE/xYlPfSSzYyH6RZK8fVs4YvpgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA12Ump5V+F+OlIFNROQwxF2pqnPsn\n/31GvtJvr3HiUB4CIBQf9oVxDrfDjwjgr7z/CPo84Zs0sAf3w3KyHMAuy7Qy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4470", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4470` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAfLqWW/sY7hbHuq+/LnbnGMEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjOWI1ZDY0LWQ5NzYtNDM4MC04OTYwLTNkNWRjMzlkZDM2MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNjYjI4ZDgtYWZh\nMC00NjQ5LThlYWYtMDg4ZjNhZjkyNmMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQJb3PLQPrMWZW8HfX7M3bRnwGh3oPH9K0387xSpPK/6j1I8kq50AhVIUK9K0\n7v2bY7I1VPn7SEQZtyKkm3BIx6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3e1P3epry+GPVaAN0Bn7ISCROjYwHwYDVR0j\nBBgwFoAUi383in4ux654D5tlyfILY6Ov7wQwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBrhIMm\nt/+h17iv8zAoUR5dutOJcRA6lkbdMXtfnFzQuAIgYlVDkGPZwW7zxYG7iinjwXZK\nIq1BXFhnc8vtwnkWV2U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcE69qSgernMGVRh3O4xzMP0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzliNWQ2NC1kOTc2LTQzODAtODk2MC0zZDVkYzM5ZGQzNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSLpf68f5mGTtf0btIDQtLYD+3rRh0y9ZHlBMwl+8/br3i\nIjSKv8S8p+1WnCYm9Od7ArmB+loSHLD2JKNPV7ero2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi383in4ux654D5tlyfILY6Ov\n7wQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIMYvKIRMIerO8rJWOnGExJVNyKdSuRsQoHLE4hB0NFnAiEAsqo9x/jT\nI7UGqgyryYZbGAZ25alD6cWB1eiTrMv08go=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAU8vR31VPaVzusrD1aObH1zsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNjYjI4ZDgtYWZhMC00NjQ5LThlYWYtMDg4ZjNhZjkyNmMwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTE5Zjg5MGItOWM3Ni00NDgzLWE4ODctNjU4MTgyYmZm\nYzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENZb8il5gdJM1KXrLuHXwu5Ix\n6Qc9KhEtKCY8gdC/DDrtKy/CBZ9/gRrFDCgLAtfUsHgvx1Px4ATHVpkyml84W6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3e1P3epry+GPVaAN0Bn7ISCROjYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAOLbTdlAJYxBIVsxQ83jRqaOx5aY1s\nJBFA7KEzFE82sQIhAM9L4l0QQba/xiT4i7IRmpIfJR4rX6UcHXtQdlHor3jQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4471", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4471` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAVzRx5UW+7faJK7B1mj7EgTyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwYzkxOGI0LWU0ZjAtNGZkZi1hNmUzLTJhMzE3MTdiMzY0ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI0NTQ0OTAtZGIx\nMi00NTg1LTgzZDEtMmEwYzYxNGQwYWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV83dm/a/StZ6GiYe2564ytxI8X/IcqBlXZPxtMBgA3RxSZoCJqb+JEywkvc8\noGl69BWDR9ghaDTfeqcOQvU2R6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOa71ezU8YaHE3oiKLBHzSFWwAuXMB8GA1UdIwQY\nMBaAFBgmiRlKcX6yrXWkVj78k0lqWI2hMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAwIaaq71cKWphdL15fy4IxCRYzLYJXUDb\naTn0Wlq9VYYCIQD0qv5aWLlVrQtztfpTqdAk7gHZ5Wp26D/rIm3fUWv79A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUXMa3+0CpiVddJ5grqizs1aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMGM5MThiNC1lNGYwLTRmZGYtYTZlMy0yYTMxNzE3YjM2NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3z16EjajhNSQhF6+wkmFXPZlSwl8wB3zU5grXWtz98Gvp\nPM5p1Xn0Aht5Nk1dnzWDIpmd+YolHpLcCIx1By+2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGCaJGUpxfrKtdaRWPvyTSWpY\njaEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMvHjaY2CZqQW9nz1xMdvASZ5eSmC3vXkPSZtWo2tsxcAiEA1AICS/GC\n+waWtfzKWB3+KbYLFOdaHVjoQgVWv3q8F78=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfNvSLR6RDli3VT5grsKO9dFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI0NTQ0OTAtZGIxMi00NTg1LTgzZDEtMmEwYzYxNGQwYWJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODFhOGY2YjYtNzY3OS00OTI2LTlkNDMtMDBhMmZjOGY4\nMjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8p3XCWMwRRes/nohJg9K9vTw\nRY2NrzzKD+x16QoNYZ0x4peD3pOXmw0BmsCAopSKN5AXity/k67X1Gz7tnjkt6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5rvV7NTxhocTeiIosEfNIVbAC5cwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAQuKNaVUjK4K2ETfqanuUv+ez6hlbM\nXtxrCJR2kq4coAIhAJCJGOXExf2OKkjWbu9pPPyb3fIJqNB6Pmc/U03TN2YI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4472", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4472` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAbD9xSbjVgR3Jd5ypNAkPgFMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMWNkZDUyLWYxYzYtNDM5NC1hZmNiLWIwOGJhOTRhNzBhOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMyM2YxYzQtMTM3\nOC00YjgyLWFhYTctYjI4MjU0MTQzMmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1ex58jsUCbr5O8me9lBqfeUxZNi1WKsYWni+Ub8YOSvU+dcia6DvoAW3ctJV\nbHuyvOFywdrHq5E7XXxCuYDNPKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7+U1DFsdy1h6UPQyYYI71YDrFBcwHwYDVR0j\nBBgwFoAU+kZxGWX+/AmTKec2jxnNsXT+5u0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgO8AmkGct8GW7\nk7Jc5iH8GHugvbtUOfjhp5JQ5Eqr61kCIFmlH882rP2XL1Fp80UT8RyubZaQ5seY\n0sGqoqKJNVAv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdH/hCWM52zywTKmIvwlJaeqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDFjZGQ1Mi1mMWM2LTQzOTQtYWZjYi1iMDhiYTk0YTcwYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsszIUoo+q5znzB1tPTkl48OtcspiIHAAlolkjKuIiH2eF\nRZCnceCIWRxPrJTSfdwDcOh95yCRGz1G1GnOr0INo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+kZxGWX+/AmTKec2jxnNsXT+\n5u0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOOxADjJMUIHbLw8Ub98PrTUsORz7eBKSmx1zPStb8lsCIBIfY5zKX1kS\nhsbqirMutExWv49MmCp/DafsbiwIZMVL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZQpGGbSSI+W1okVmoitng/XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMyM2YxYzQtMTM3OC00YjgyLWFhYTctYjI4MjU0MTQzMmI1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzQ3NWRkNDItMGYwNC00MjRhLTgyZjAtMjA5YjcyNTAy\nNjgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELL1m6wc6u50qCggQ3yvBNVTG\nmbgx3IyQQFzoYywSXRBG0ra0Yq/AKE7u1KEdvRhsYP8epyAzJ1l///RpDVGxpaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7+U1DFsdy1h6UPQyYYI71YDrFBcwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA5JU6pzx1nnhZgF5cvjLDI4UHPT8U\nQZaGnGoF4YQU1XkCIA+5FcjjlqWWXp7z4lpKSF/e04DOPOuNEr5utR7QNmZP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4473", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4473` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAYzpBsT3g1aLLl0OAjeHOK8xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5YzRjNmE1LWUyNjEtNDg1Yy05MzgwLWYwZjQ4N2I3ZWIzNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ1NWE2MGMtOWFi\nZi00NGNiLTk5OTctZDBjZGM1YmNlYzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvrMTkt9ttabeinhBgdn4B+wqV9CfnMEI4pEVnLuObo6LQt96TguXTYZ6114R\naz4lxDL3VLzZgz7DUmcJmyLkgqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwJQWo6595wrqzfNDF0r0JgLux34wHwYDVR0j\nBBgwFoAU9iklQ4HxyhBo5wnLrVISZAKik1QwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJGkjW8ohUsi\nS05+N51G6/5Lai5klQB14j2Q/4LXYi9RAiEA6FnTjnP5fxFJvh75XqGMW5H52hPd\nJB/PZxBYQl5xtAM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXCs/GD3tYgy3/Z5vWOuUaOxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWM0YzZhNS1lMjYxLTQ4NWMtOTM4MC1mMGY0ODdiN2ViMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW+qycdXvjR6wu9VHTARMBkWSzQvhn0n2OH/fYeCWlXLKp\nrmaKNqzWCqRdmAtU8kNq8djg8a2kI7hZtEan0lYbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9iklQ4HxyhBo5wnLrVISZAKi\nk1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANIK8Zqs8z2lQlprrw9PZrAOkHVf9Fl/45epz0vVroGtAiEA1HT4eqvI\nUHyDI/wVnXwbdtO2RI7Am53PoYRaC6+3ILc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUW40CkqHvGpMs6l4fq95Rj9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ1NWE2MGMtOWFiZi00NGNiLTk5OTctZDBjZGM1YmNlYzQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzM4MDJiYTUtOTdjZC00OTNmLTg0ZjgtMTM3MWQxZTIx\nZTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZdzdWJKqhWtyITlYzOYuhiN8\nwjVMt5kMYpPd8sFUkQEn5A6xV5uBTQ/la9gidZTjl+g8Mj1L5bUDURdQRP7kT6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwJQWo6595wrqzfNDF0r0JgLux34wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAwjrxzwhuFtD7Yp96CPM4+G3izpiB\ncbnVOA2WLdYCB5ACIQClFqt4/Tviu0eaokSIfXV2/3j4XP6JpeV+jnblwygCsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4474", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4474` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAe2gAwIBAgISAV4CMHhIfrj3ND3mcLOrzzwrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkNDg1YjY5LWVlOWUtNGI3Yi1hMDIyLTU0NzdhNDk0NTY2OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZiYjhmYjYtYTQ4\nYS00NGYzLWIwY2EtOWI5NDQxNDE4Mjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElURhmIpchiqGNoR8J90rGQGbD7ouKKQuM6Q9YOtSAVGJ5xKffn1Z/9+pN8/8\n3xQaL4k1aYsLHjxFFHnXXJjne6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyW3+7uGLxvCR2mhUI4DcsNZXd1MwHwYDVR0j\nBBgwFoAUa4QzWz/OPgId3ofxJ+dz0pf4ZKcwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0YAMEMCH1qTDrPftzht\nb7cbyFHhfls6cWYlY3alqdwDiNRzqrICICRUVLOImNTn3B/wHBY6tOFZi/8JjhGN\n1jXa+m481cN0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc3w0awUJJ3IvIU4XEg+Du6ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDQ4NWI2OS1lZTllLTRiN2ItYTAyMi01NDc3YTQ5NDU2NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOwHobWt81PyKfEZxWYYRDVGXPT7N0MeDj+mT3wbUa6mHq\nMILJIdZku/ZnL3RYQxV4v2zFo5K8nPSwaZaQIk/Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa4QzWz/OPgId3ofxJ+dz0pf4\nZKcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN4XaGGxVOG91goL1JeyBDFC9htrgg4T5XgCG/1SRWHECIQCGYFnO7x8K\nA7RVfya6l/4h9mWcThQELkRnUW3/rWcQPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUwCTxiqjX01Nu3LzILki0XvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZiYjhmYjYtYTQ4YS00NGYzLWIwY2EtOWI5NDQxNDE4Mjc3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzAwNGQxZTgtN2JlNy00MjM2LWE4YjYtZjc4ZTExNjg3\nMWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZkIj7u9yGpJegYKaa9aZIrNq\nfOZgA5d+DwSQWJE+Gg+TIxcd4a1/omMOs1PTGN9dlESxGkogZ274Jy92rHCdv6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyW3+7uGLxvCR2mhUI4DcsNZXd1MwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAESp596KLJhN8sSw2jYvimuaEBjWqr\nQrlScna3peI7NgIhAO4nFhkmQAxeyHeCzfrrH9ATXkj5D7gOafrGHxR+pO3H\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4475", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4475` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfB/OZb7d2j2IVwz974Yl/SeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhOTNhMWJjLTJkMDQtNDUxZS1iODcyLTI2ZDZjZWVmYzhlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU4MmQ3N2QtNWU2\nMi00NzI2LTkyOTYtZjc4NThlODJmNTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIz4asBcqkXJ+MikG/laoGKgWpi6hNIl4i4O1YFAZzLSUJQ9j+OCPhvODbq9y\nY7FOn49tIaZLiGkf/8ej+m9xuaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1W7dFmbT5Vi9G1PImZCc0Coh87UwHwYDVR0j\nBBgwFoAUR8QzuqKcdsYRpk10q+xDOCJsiyIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFVG2KZpyu8whCwBbHjPcgf+YixtAG8tT4fiA+G8HfwTAiA6hHET5I9CBRDT\nJNr7sWeYnrqOhzm/0y6z3m8kFgH9jQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZdbh/kZyG78r0oLwiFnuM5+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTkzYTFiYy0yZDA0LTQ1MWUtYjg3Mi0yNmQ2Y2VlZmM4ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVkSDECMS3ko6zR/b37ytLVxT3BeM5FkqWcM2tx2sjC2IA\nWLftlDw86iSXxOCsbYcAFBeKYzifvri6mxNrzWfPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR8QzuqKcdsYRpk10q+xDOCJs\niyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPnhTA8eadW3Ow/2p0wAzrDsZ2H4ZqGJ5Hi6BPaa50sMCIB9b+3x4cEJ5\nazferiCEX5ElT6RyTKlAOhxHkjjjLESj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdx0MyB32VM0JDYosi+KjgkXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU4MmQ3N2QtNWU2Mi00NzI2LTkyOTYtZjc4NThlODJmNTNiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWJiNjhmZjktMDVmZC00NzU2LThkMGMtNzJhMzI5MTlj\nYjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA2tIJEkSUapbe84gmkr48MGU\nh4qrCmwFPmCG0Il3z3njQAL5Js5pqi/QQrXtMAhq9ckH7oLWwZUa9fRohyMbW6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1W7dFmbT5Vi9G1PImZCc0Coh87UwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBhDDUiMcoq/x8sfgU5nxqlagEcEcdY\ng0gxLNi0YRH7dwIhANrcp5ybuMWIg8KlTT3VFN8GguYSBFqoPq/9jpC7ANRh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4476", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4476` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQzhiDUomCe4gZo9Wq/JvxSBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZGViOTYzLTc3MTctNDY1ZS04ZmYyLWE3NTFlZDkyMDUzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFlNzVmMzctYTE4\nYi00NGU5LThiOTktYTI2MDk1MjI1NDc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETdLrE/l/JJufcI688mPwu+O6ROA3HzUKEQy1rcgedC4z5QeQsvTr7CCJUR3u\nh4jCHpRrWjAKQuRFIDIYhzdwtqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFYGkNalLjyUGhSgzf3REWQCfCdwwHwYDVR0j\nBBgwFoAUrEyV8Ef4UF15vX8lvh+/5dDHgBUwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEOAl414ZO8jYuRM21TFW8VJFuj5uH+anWv8tOhDg7JRAiBIARGIohTOEfUW\nkdEBi6tC3SbFHhckdnokxGJbKk3FSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYiQaaPu2yvrLClQL50M1O+DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWRlYjk2My03NzE3LTQ2NWUtOGZmMi1hNzUxZWQ5MjA1MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvjlhj8WFWATiwS/I34NYyGN7iBn08Ma5ABgJUf6b9atbn\neuMXytNy9SF4cS82rtbZs0DBZkIBuwFKCFhZz315o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrEyV8Ef4UF15vX8lvh+/5dDH\ngBUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIBlG0X/F1guHRydZlQ2+TqZL5VRAhT0lsx6/G101NYICIDp6Pw7VBLW1\nD5KsZCtPYywN9YYMTZqY+R0AfXoTtrgb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVfWAO67m9AynMEDSrn74WuKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFlNzVmMzctYTE4Yi00NGU5LThiOTktYTI2MDk1MjI1NDc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQxMmMwOGEtY2I2ZC00MGQ2LWFiNjAtMDA3ODdjZjhl\nMjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEt4wWt43UW8MZ0VVpjz6EbktM\nmIJg+fUzBZXGNd8FOxOexjAIKMmhzt9GdxxP+BfrxTls8AwXqGIa+EeuZxL1HKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFYGkNalLjyUGhSgzf3REWQCfCdwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA875vaiKrSrut7zsyB0wq0L6cYwYRY\nANzFFJi6S/3LsAIgUatsyuSpncrcDsRioCGBxB+6Jdw3Zq/GF/kaiSJrG7w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4477", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4477` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAfAbbGWuiPMTnpuTBsDu1gHEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjZDU0MTE2LTdmM2EtNGQ1MC1hODUzLTM5ZGQxOWEwMjE3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk1ODE5NDQtYTFl\nMS00MDczLWJlMjItYWJkMTE0YTZlMmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEygI48KzhrV43eALTcnDklXiLgsa7rVfDhFuoAYe1RgpT5sSHAM9h2GTEgiqI\nwjPFqTAzTNRTF8L+uvwFfU449qOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1hfDfzsf4X1kqIb2KoSfdflLjEQwHwYDVR0j\nBBgwFoAU0kyWvas+d5eNXv9s68Jn2HCyur8wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCy\nGmyA8dgUGsXpz4Q0YXTm/DS5npakuM9bHb6CfukjYQIgAPMaxtS8F7MiS1OgUY6z\nf3V+HhOIslRYGLpsXHsj3Lo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYw8Nx/iHaKMpV/+ZyzjKqhtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2Q1NDExNi03ZjNhLTRkNTAtYTg1My0zOWRkMTlhMDIxNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR6/av6YW5R5bO8/ZwIOFD7etJ3DZ5s4AXEfyBxe+5JOA1\nzj5jV1HioAk9ze0WGl51E2Xu80wWcHDV3lTWiJOko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0kyWvas+d5eNXv9s68Jn2HCy\nur8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPgqtgrguJdc8MKOlCJiO1KWeKlXQICsdDcxEuUeqG/0CIH7XFhqVG9/d\n4kKVbufmsiaTXTkKq74azIDJVA3dXyow\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaB6OpMa3qFG3s4CFXecFzMfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk1ODE5NDQtYTFlMS00MDczLWJlMjItYWJkMTE0YTZlMmNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzhiNzU2MGItYzNjOC00N2E2LWI0MGEtMTM3YjViMmI2\nOTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErDpgZcrPak+YpNlLnRnQx74T\nkuczbLL5Q7Gn6mY/gv9OW/HEl3DzS/qJH3vaPaU511hR1U0ee+T47UikqbpOvaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1hfDfzsf4X1kqIb2KoSfdflLjEQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAuCNev4LKPJi84QKxwgVIpDVFNP0j\n8gQJauCOpzMG2o0CIBqiC91cRvH0ZvEOxKkhEJJY/3mzEKDV/SFQgDgm6vEu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4478", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4478` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAfmnZYjtJAxstM2b4EuJA22RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4ZWM2Y2VkLTAxNTMtNGE0Ny1iODU3LTg2MWE3ZWMzNDI3MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQxYmZkYTgtYmMy\nNC00NWE5LWE0OWYtZTc4YjJhODc1NmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7uN8Ovz1l1+4GlJk7ifXZC6tLUyr9BRZXqVKiqTq/V+jd6j5xSgkANlhoEkD\nZCchvvVhaq0nKGUKqSGcl+4+yKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY5XG9xu6iytUAcFsVVal4iAM0CowHwYDVR0j\nBBgwFoAUvXu821qLI90rjyiGrtcAsagfdH8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFGLsfsYJT7oiNt+h1AtmCLHqCG+Idz/WIIz5aXg1HpdAiAm2JLU\n6hqVb95SjWivdHyech8uuD0SG30+T2CbcetBRQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYc+bU4Te0FcO15hH2uWZndrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGVjNmNlZC0wMTUzLTRhNDctYjg1Ny04NjFhN2VjMzQyNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnP2GjcxV3u6jN0XEiskE8wu3qctXpC+qsJZFOHmnnSSqU\nqVwXJzNBE8VOoOuUU3INi6yOOG/tiqxxjD4o4G6vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvXu821qLI90rjyiGrtcAsagf\ndH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfJDAOJ1aXJFYcrVi9N7tWIvNt2CiPHiJOyqNMLIPFk4CIQCok7j3BEHR\nk//AsJLG8vXGlQBN0vZ975ot800mVBNjJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUJUNR3RQiyfVRfKBiwMzLlqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQxYmZkYTgtYmMyNC00NWE5LWE0OWYtZTc4YjJhODc1NmU3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOThkMmE3ZGEtY2I3Mi00NGY0LThkNGEtNDU4OGM3MDY2\nNDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcQuNbD1DQz3ESSewrSSnIkIr\nDVyac0pg3fTeXvSH4hz0H+iuGwjqtBhE/v10GG4TjBCdkCmJ2oSY7ApkbfrkBKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY5XG9xu6iytUAcFsVVal4iAM0CowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA9MTXnhyzmhaf5d+JPIpm+a4+EIGCh\nQfT6U1KGEemt3QIhAOHYUE9ajqtqAOp/4+/qiDe9Ln6Ralh3XL09SCCeC66d\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4479", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4479` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAZO2XP+yBevQQzMa4oOC+ro7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmZmRjOWZhLTU5NzItNDJhZC1iMjAzLTViNjc1M2QxM2E3ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGViNDU2MWUtZGY3\nZS00Zjc2LWFkNGYtYTdlY2EyNmNkNmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtg3J6mK/b36Vkh6HZFOLdLUCsO+ZXjMLkxsyPWHYwXAYSUsiZNoVgz7fAmcc\nDYWQeOLNxosTSL8uAaNe5qituKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0dPg5NXqaGgwP+euypHv4MlXi1gwHwYDVR0j\nBBgwFoAUquHXimqnNrpIInCibIJ/RrITwj4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDeumUVZQtj/cKU4tZTyee6SImaRYD3MiwoQXSahWYwWgIhAPu4\nb4AWAZBHkEDapM1CfAIzYUtOTFSQyv7TPS128L90\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQcycLqyt62c7qKkewljITkmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmZkYzlmYS01OTcyLTQyYWQtYjIwMy01YjY3NTNkMTNhN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/C9mpt0fL7hjebSCGsTwY0PBOmO+HjwOHybLRTtNcDsl2\nPVRZYGA/+ZEv/sCNvMmN4tbHJQO7y/i7E5glpuS3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUquHXimqnNrpIInCibIJ/RrIT\nwj4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKONouhDmaqwkhhLPEyCGwE13c4VHtRQJ4Vyco5FMha1AiBiJmdCX2RE\nFYhzi3wUIlBEUG0SeP+fuUMR27fBZEkjFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXXxpmuZT29dSA/5roEJ3eThMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGViNDU2MWUtZGY3ZS00Zjc2LWFkNGYtYTdlY2EyNmNkNmQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjI3YzcwMGItMzEwOC00OGI3LWJjY2QtY2UzZGUxY2Y3\nMmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiZQ+b2KzmPqSMvB8jmRn1FDt\nSnH/9J5udQGnLLiqA2v1At9Nxv3bjFiW0ZU1/Z7kxcsJq3JqK9RvY4nbcK3wJqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0dPg5NXqaGgwP+euypHv4MlXi1gwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAnImcekm6qiSSiCGqGpexVpdM3PvWU\nDZCvjruJXM0MoAIhAL0LTh69wmsxE/s68qACHvVFP4sDG8HENTejPV8BUU13\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4480", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4480` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISATyQbgnv3IC2dchKVWfMuqE+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyNmNlNWYxLTI5Y2MtNDUxYi05NGY4LWFkZWM1ODgzZTI1YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ2NmJhNjEtYjFh\nYS00MzkzLWE2ZmEtNGQ4MjA4YjQ0OTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7o9nQ4+FfnWS9176EO9vRrfFCJeX3WMIRVL9NqcmL8cirbLwOiDjcOFCUm+n\nb6y/ds6WrsdlfhXdrC3VN1HlI6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFL62LDZ6rHf2j8WGca2R4sWL9qEdMB8GA1UdIwQY\nMBaAFF8/KQaiIVXM4UItpI7xotlZSpH4MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA5pqMQ0WdWLTxXK1BDwVYcDhCj1Fa6F4Q\nM536s91yjjcCIQCWZNanenT7Pidnw5kw9vDpmWjxWRVkGhZGuSQu6i3gnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZgfbZmHWuDgRcy3me2fBuMxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjZjZTVmMS0yOWNjLTQ1MWItOTRmOC1hZGVjNTg4M2UyNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARecXPFYynnyFp0R2ntb/Jv54oATm0teoitfeXu9avrc+fM\nnE6yi0L7DAWQULPhk0YVhM7qSugiZQMLM/z7b+gxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXz8pBqIhVczhQi2kjvGi2VlK\nkfgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANF7jhYkv2SoeHHHLok0Gi//ZY1iRZ7OSvJTZRqX1FFgAiAgP4LTHyFi\n/lAY1fztgkDSM7tfVB2yvWchCHhcoLzUPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAacl8JrUvPNQtIusZkkDjqS+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ2NmJhNjEtYjFhYS00MzkzLWE2ZmEtNGQ4MjA4YjQ0OTllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzVkYzllZmUtMzc1ZC00MTMxLWFhZmItYTgwYjEzYmU3\nZjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi0lhix/3B9zeM8u9Ydywyc0o\nZgfh8RLMmcOOIrU9M/tkKbnTOJfnGObWOCa/VPILEsfkZpDy8/m0ffJoXbHUVKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvrYsNnqsd/aPxYZxrZHixYv2oR0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAju5srzq9dSNs9cPgm62x3Klqkjfh\nouaaJ65HF+7DqgwCIQDenzSEhaKDmHg2qb9cQiNe9pLrQRcvCPUuVe3xMdDAzQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4481", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4481` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAeR2DnrAqiTm90fp9HuzIdKhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzMjc4YTIxLTk1NmQtNDc1OS1hZDliLTk0ODQwNDE4NjJjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDVlM2Q5NzgtMWE2\nMS00ZDFkLWEwNDgtZGM3MmIyYWFjZjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpN378Fxf6809RQvIrEoqAT/urRNkXy4rYS3d/uIDZwlxWzFScOCbnN/4Tbu0\nn3FJ6JUMhiBAb1cZ75VRSsg8saOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQLY3qTMOTpP7dpsrblTS6hv1J08wHwYDVR0j\nBBgwFoAUgoaKpBRa1xqoxLn9eurio9r7wsYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANxUGdLejxRV\nMOeCxpWeT9zF+YKeVTR2+9FMvrmwUHHyAiAfLSbdOPj+QvCOnJ/FnGhvAJB7u0OP\nDP8ivY4CdyJhqg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUfg3naCg16/owndkvgiXu0yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzI3OGEyMS05NTZkLTQ3NTktYWQ5Yi05NDg0MDQxODYyY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2ggH1DjB+eReT57qSZNYr064R9tMIF+nNsRzYVnyJuDav\nUOboJrE9xcz3lg03xQ2HmLqVpuLEryw25aESlGwlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgoaKpBRa1xqoxLn9eurio9r7\nwsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge2rHL3tU0/cyI1hLK3+EqZfSY3/PSyuhXp2XuDVksX4CICMUx0FV42Vx\nfcBpCt8dxWKSntbrSdWk73uhNLpeHdTE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAd2IooIVpSxThA1yYpOk6QPfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDVlM2Q5NzgtMWE2MS00ZDFkLWEwNDgtZGM3MmIyYWFjZjA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjkxZTFjODYtYjIxNC00ZTVjLTg4NjctMDcwZjc3Mjky\nNThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJdhoXEMu/JeBg0r6OK7b+QUm\n2JruedRfdRM52OVUv/L618YjE6MgqLSONHeQWxej17++v4IG5z8Vf5KpyShjxqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQLY3qTMOTpP7dpsrblTS6hv1J08wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEApt4TKYKtRS0RMxcRPiCir9Kr2wDw\nNKzNQarPbF5J/1YCIQDaDNxgkx/XFKQlZnU6ogUjQGjfk1wfnVF6deIMTlsUig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4482", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4482` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbZawO4YJ52HJP28a2Jl8at/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwMTkwNjczLWVlNzctNGVkYi05ZTViLTA1ZDU3ODNjNDE2MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZiZWZkNTktNDk5\nZi00MjA4LWFjNzEtZWRiZGIxMDFhMDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoetbTWfLxTQOqfSrW0Zb6hDA//6pfaCvUgWvJ1lHlQSzoY2wP0SPUCwJ/J78\n4XjC47GBi6FzfEI0KoeXzrCGmKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFYIAFzYHvY1Th/rVzn0KuPyNmD0wHwYDVR0j\nBBgwFoAUWIxbmDgUntjP8LmaTvUV1uCCiz4wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMUf3VuS5aGD\nHYMUd8BBhfvgjyHe51ef29/GdH12cS6VAiB7q9xjiun+Jf/T0g0hAhrZgFO93PAq\nbpeO2eTT+fJbhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVpGBQlRZK5N2CM6rLU4ORpRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDE5MDY3My1lZTc3LTRlZGItOWU1Yi0wNWQ1NzgzYzQxNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARChv/dC7GTFyZeWCd73Wk39mJsXA/8U/F9WWuczzR/tIOl\nXxegHnSmSKkwLHcSqACX7lmiIyP6hozOphWJ8c9vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWIxbmDgUntjP8LmaTvUV1uCC\niz4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPfppi9gJ7gqUvpaZApa2Daol7SXFlVznuOFHqVGbOKkAiAYAqO9r0Bd\nv6V16cREExrL6lZWbjhbj8b58gZRbefUqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARdK/BKbLTBdsyTGJsw3MeUDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZiZWZkNTktNDk5Zi00MjA4LWFjNzEtZWRiZGIxMDFhMDZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTE3MWJiNjktZjcyZC00Y2FiLTk0ZjQtMzM5MDc0MDBh\nYWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5MPLW/VfU4TzfIAcIs3IX+WP\nmC2UUr/gsuq3bhfZ8OkyKDRBK3YPH2MOZAWFnuJXcgjEEcHauU40wCR5VUkWX6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFYIAFzYHvY1Th/rVzn0KuPyNmD0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEApQ5/X0y/P1fkOY+QqnvzFdgR1CmW\n1U3BCE6qZz7I8lcCIQCzyIWEPOUa27aFmD2YJ4TOu0WIUTlerVAiib2Bve4OMA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4483", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4483` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAQ2JugmmXAd/9q9sNqX/Kk/AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwYzgyZmFkLTE2ZmUtNGZkNC04N2NmLTU2MzBiYWFhOGY2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y5YjU1OTYtYzE3\nYy00ZGI0LWJjMTgtY2JhMDUwMzBjMDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg9eDXHr/IYJj/3CtwzL/muU+nP3j3BQLDl88ypcSDJiqmhI2aHEbFeKOpdsL\nL1q0zJxLo1IQ51nQF9KiKVHIxKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7L+tQXfYM+0CpNSlDXyGAO0jTbQwHwYDVR0j\nBBgwFoAUg5Bhj8U32Hupg99LEiGMs7aZDBcwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDnNJf+/gEN\ntagDctUfefWrf/hOkF68Uua0jOvzfWNk8QIhAOVm0Ch8b2VvRkU+FlezRNJB0jqD\n5gAns2pmHeV62HjV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWNYIThzyUpsUo77aQSnUOtrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGM4MmZhZC0xNmZlLTRmZDQtODdjZi01NjMwYmFhYThmNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToJ+UL+em3kpEWfqjeVXBEzEZx8exy0XiwfSnDyb2Vmijk\n3QQ7ahKhBydL0SmAHwl+H0Kn/N+M5eCBLE8Yuny/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg5Bhj8U32Hupg99LEiGMs7aZ\nDBcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBhhJ1XryuZpvhAZp34N86rYxbuPi2PVn1G63B+hbQ5QCIQCMwJqrwrkC\nrswwtGMDCVJ2EdEqGDUImUwxnfWS9zeAwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcFruP9vAkcpYo4pYeSaiWloMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y5YjU1OTYtYzE3Yy00ZGI0LWJjMTgtY2JhMDUwMzBjMDhiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGVhMzhhZWUtM2YxOS00MzZmLThlZDQtY2I0NWZiOTE2\nZmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6PK9t0ruKfjOJkOdzGDNc4Xm\nxCoboZQvZtsBzyXHC7sMypAB0cCi+nAm3cSpeayPhxtQHh12F+CB6XYneles5qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7L+tQXfYM+0CpNSlDXyGAO0jTbQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBqZSeS6WCfOqvT7au/6YL6q9mbL1lo\nnE74zBy0ZWKPMAIgcAf3Jgbd/Q0KEzPc5ITEnybZHz60KCKqvd1H2/b5v38=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4484", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4484` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAST0dxruV+295kOT7dLw6QikMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3OWYxNzdjLTQ2MWEtNDU2NC04OGY4LWJiZDJjYTczMzI2YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI4MmU5YmQtNWUw\nOS00NWUyLWFiNjEtN2Y1OTc2ZmYzY2RmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER6U0SGXEsXQLISeYFfnUUYFX2gczcN7UsXkWSYE6ao1CZezvnbd2VTW8HDmV\ne+MUxR5eRnK0Y7qgTZbEOrJIaqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXvEuUSXMn212OgLpIdsAnZqwJsYwHwYDVR0j\nBBgwFoAUdNv9UjbZMo/OyLokUglxuq671CowNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDIyCQOK/CXpJFM3ME31toEClkXU33e50yp12NimiX+twIgHXpa8tcVed5G\nUqbLTofbII0zt4DEaFS2zGeb2rYtPwQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAYl/Ch1jJT49FcfvwnbL2nlUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzlmMTc3Yy00NjFhLTQ1NjQtODhmOC1iYmQyY2E3MzMyNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsxACPrRoRn8oP/faawgTZFpWyeUapUBOxlMxHtcYlHtx5\nLet3pHKUQYBu9iF1FlpVKbeHg+vOfYF7YlakFnaQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdNv9UjbZMo/OyLokUglxuq67\n1CowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIgIYIDexKYi1CEKZKHNS3YEfna7GQI+L1uFnKBH51bbtcCHypqWwkv7ZfK\ncdqNbGRHJoY24T9bRoZTJ/MY/XSzCr8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWOanTPe6hqNQfMwnzhCdZebMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI4MmU5YmQtNWUwOS00NWUyLWFiNjEtN2Y1OTc2ZmYzY2RmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmNjYzQ0YzgtNDhjMy00ZTc4LTk2OWUtNjAzYjFlYThl\nMDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp2vLfPc+98pfMbvBHKpevDUm\nGc7Cs2JjRdm2LiivccqGBKpUop+1S7DTSrSU2hDtSgY2gEV0pUHWNQQ4i1cPi6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXvEuUSXMn212OgLpIdsAnZqwJsYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAkwcQ0BjO0X2qtO0XDYGUpDch2dY4\nw7snquqDJS8uMOYCIQDJOSv+F/zjL5B4/J1NB3Z/bX2f1W0/0GSF0Wp9aAo7XQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4485", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4485` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAev1dNy8+8zWS+Ytku+uvm6/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhMjk5NTNkLTZjNWUtNDNiMi1hOWI2LWMxYTMyMjYxY2VlMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFiMjM1MGUtNDlj\nYy00MDk4LTk5NTgtZTgwOTVkMGQxNDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2fUpoosP9UpmWwKpVhZZGm3lVP9NWscMVXPOLWe+4+8hcobfC2hELSyf2oc8\nsFr3h3X9aCfcS48ziRJhcwEpvaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe3RTJnpwpPEzqkjQrlNazUxxlLIwHwYDVR0j\nBBgwFoAUvDaQMz7JgXxuQrA7tU+ZAel0lkowNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIB3fLDTJYroV6ACmMna12iUZt9/2tPXUMEQhwGiW/RWTAiA8Qj1JZbpBGb2O\noVz9ZgewlGTcy+fMmAtnlTMGpg/q5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfJ85fDGIP2aiVNu6M7Sq4LXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTI5OTUzZC02YzVlLTQzYjItYTliNi1jMWEzMjI2MWNlZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQeIaQxRsVeQt1/+ulbmDx83qYOyop44eXjdFIJPSbPIGU\nHekBTYJO/8DRF4kcPrAOguOw8C5iPwYgtk1vw3nJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvDaQMz7JgXxuQrA7tU+ZAel0\nlkowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaXUKeEX6XTFLvS0NL5I/wiX7Zg5D/o/7vls3ugOccNUCIHVKQix5/4bc\n1gPZ37o//ogOFmeZjOEHOJTrtifBh1wC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUxTM2716dRNTOW+Gq3FsMnPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFiMjM1MGUtNDljYy00MDk4LTk5NTgtZTgwOTVkMGQxNDE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmFjZDgzYmQtYjliNy00YzIxLTk0YmMtZGE3ZmE4OTUw\nNWYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7pkogJyid8xxSXcOLb4v5VVm\ne1avLKs/TJLAft1hzc/s6r6oBnJRJ5dtBmWv73RccmQYjaIKXrP2K8MgfIwgFqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUe3RTJnpwpPEzqkjQrlNazUxxlLIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA+9maHVsZGElqNgwZk1imkaqFQrTI\nKhN4zM2QS+9Za7oCIFnT+7U1EWM7PLfP5K9b0Qg+M6b1I5R86POJc4dHTLp2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4486", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4486` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAVzyNAW56D93j/qiAkOWF6pJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkZmU4MWYzLTgzNzAtNDE2Yi1hOWRiLWM3NzdlMTE2M2M0ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQwY2I0ODItYzky\nZC00MzdlLWExYTUtNGVhOTU4MzRlYjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnC9yKphk60+oYKV5ifdoXr+e5mBwN8LnVPYKl91sDvjI4UwMVFXApVixUoBx\nDVdJ+0DphfDf8fUJbU3QV5MUmaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQRvHtEF0+Hem08/AF1F1m53OVOgwHwYDVR0j\nBBgwFoAUgx0w8265/qpxEey5S0wF9TUbMYAwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBYe\ngACGocH/3wdhv9KIahUFH2pcpsrLkXTLxiZMKc21AiEAstgDxf2Sn9lZj3ELE1om\nhO5XvddNENesG28XUbmkeAo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX3jZbJwBNpwiw//ArGRP8CbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGZlODFmMy04MzcwLTQxNmItYTlkYi1jNzc3ZTExNjNjNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQb4TyuopiJyhe4cZTAb0wNNj3fBrsi9PT+FEJrx8CApoH0\nCAR2Y0WAwoNSULV+g2Vx2RnLMR39e3j5+Xhmfzaso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgx0w8265/qpxEey5S0wF9TUb\nMYAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBapwZLv6u5GDHmQVOEiPqP57dwAzkaP/ZDzlb033NssCIQD43zNLw5Ef\nNeq4iTMq3XTdGvzahAeDOk3/wC3opWsarA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQv2EKEnhQgVLC10tq/YdB7aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQwY2I0ODItYzkyZC00MzdlLWExYTUtNGVhOTU4MzRlYjI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTZkYTZkZjAtZTM4OC00YzlmLTg2NTctZGU5YTEzODFh\nNjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYJVo0FpyNyJ6X9Vw1HH8cZka\nwJMCl7yKb8lWm0fByZgevPP+7B7KRi3M2xiBFKrHEUh/HUzsAH2Ecc5Ge+pQBKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQRvHtEF0+Hem08/AF1F1m53OVOgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA4w/gIorPgfPe4LM9f9vGGn3mCzOdj\ngZ+dpSbB2qoHtwIgVG/7aRhW1t+UcH7S+M3oePoTELR+OvzHIQ1HC2SmBTU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4487", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4487` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAWTTLv/H7n0KCOqw/YklUq7dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiZmYwMWQyLTRjZGMtNDU2Yy04YzU3LTA5NzNjMmMxYjdjNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU3MjFkYTItMDA1\nMC00YTMyLWI4ODMtYjUzZDEyZTZkMDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhtMlBi0zh0ArQ9o/X3izd5+LBL1xXUlHjd2v171xiSIAy7mcjr/bMTNmM2Ae\nMcvcFK+vbbJW9r8A4qrOWKld2qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0293LTBxyTQ28jtcs7Ck986bZ90wHwYDVR0j\nBBgwFoAULQhAWAyFTmLvY7QLor5s6VpdQyUwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIDSGuWeH/aDkvEvX09gcrFBdpeiUVHr56/aY4hZqqgXOAiBqL6EJ\nfW1RzN2FfCtL/2DzXNKUQPWqlN+LsTnydWZcGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZXZcjqo8bbHt95zTnRH36TnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmZmMDFkMi00Y2RjLTQ1NmMtOGM1Ny0wOTczYzJjMWI3YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMQfZfr+eqVJb03EXoJ3ikd50ptsnfDU/DCgqTaR/b6NKE\noZlBZk5Zgv7RwyOConTuEQK+o12hxFNcZ57U7Bayo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULQhAWAyFTmLvY7QLor5s6Vpd\nQyUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGOjIzxsP0aRhytOKHh3Pja2CsIYjTEpqND8lhUpBYzQCIQCUzrUO7LvD\nFSCMRhPqj0Gg5lZDrBqQ4F8hSyNHfVcK8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYK+45YGwIrlDTw2zYV+JGL4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU3MjFkYTItMDA1MC00YTMyLWI4ODMtYjUzZDEyZTZkMDcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTNkOWFiNzQtZTI2Ny00ZWE4LWEwYjMtYjNlMGI2YWUw\nNWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzFjfbeVtsmAOB3xyk8bP9ZmF\ntrl6bsfXfuaqxf3WBYVTMR3Tt9LemE1T93d9nBuNWDgqtu5qwPVp8qOVcYA5CaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0293LTBxyTQ28jtcs7Ck986bZ90wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAvRsORAuuRNIS7lUKOUxW+lQCLMu/G\nsdnjBE/8YiwVdQIgEh46T9DueyN9yB/bpAIPUqts4W0TtAv4Blz6jWGhyVw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4488", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4488` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAbElB5corlAbKJI697zlkBXdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2MmUzMDFlLWQ4NDAtNGNmMi05NTUwLTNhMTVhNDMyYjFkMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM2Yzg3YTgtYWY2\nMi00N2U1LWFjZGUtY2ViZjlhMjg3OWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM45NxtQ00qtKB7KftUM5C1kF17rgih8/c2W5HMfJQAjfvTXenFEXguKKmGp/\nRhELmBiL0L+hwgH68yLs9fQpcqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbkv6eK6rXib2AxbTTVmSkGQEk8swHwYDVR0j\nBBgwFoAUQeP04kBpu2xwF8DzTLPJpRqFCSEwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICdcuesl7BCFdtWlwxnWo5UQfW1WsKUVgjGDkohXTXt8AiArE2tK\nPu/qWq1yCuddrFk9D2QGqBs6I0StxE6Zo+QFFQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaoYcDk/Z0YEwkneRVRro7IxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjJlMzAxZS1kODQwLTRjZjItOTU1MC0zYTE1YTQzMmIxZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg5eFhtdtPD1Qq0ox3znRiyxyZgsTkBeyUAoNFDN6b8UwR\nxcc9OW2/RbpemqWyz+zrTnQvByKyE0g8z54U0ldso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQeP04kBpu2xwF8DzTLPJpRqF\nCSEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ03WFg71RbkIKMWjztg3RrnwcaySqfJao57qzUsZuxcCIGGf2CjGeHkt\nt2yNgi4iXfpj6DH902Vs1VilMBUd1zYe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQ4TwoN9LnP0fKltSNtDD2bnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM2Yzg3YTgtYWY2Mi00N2U1LWFjZGUtY2ViZjlhMjg3OWQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDI1YjM1NzktZmZiNC00OWIxLWFlYjItODJiYWQ2M2Yz\nZDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5tFjHva6NPoY6RSctk7CJIsn\nNwYv9ty1mXTwLslM1yPqigDPXVEVEFHLRfmcWIYvXCTJEcqjEx7dH3dVQS+xJ6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbkv6eK6rXib2AxbTTVmSkGQEk8swDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAnrYkuBgPtQIWGKsDi8H4WKUWeYsTj\nGh+vhUQZp+ntuAIhANf+v5VbdQiruFJuBENC5LmhQ3dvM/KsjDlDko5oKCne\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4489", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4489` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAc0sGXOT5/YcMYfDVCWA1wNOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhOGY2OWM1LTFiOWEtNGY5NS04ZDBiLWViZDU4YTVkNTliNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI2NDI2Y2QtZmI4\nNy00MTYxLWJiOTktZTY5N2RmNTM4ZTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGXMMtiO1OnXIxu/5mSnT2xD8qmqRKOiZfRm1urceQjmWDEhullLpWm1aDHFm\nbE5QOuMr676POMuo30tdAT1dh6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQdSE98xLhcCr9mG9Ut1XSoE7UmhzAfBgNVHSME\nGDAWgBSvKkZVX6ZIjHR0jIQOpwWdUmfVgDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIA4wLiRIqw5kCaWfmcT4Py9WB/NtLz6w\nPT8IAzqC/6IAAiBYmII5drfW0JvQPpBIX7Is2CgOXEt1RHPner+uOVrKeA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe6FgaG6VP75pvsQdyu5tp8/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYThmNjljNS0xYjlhLTRmOTUtOGQwYi1lYmQ1OGE1ZDU5YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqX7Gn51Kd2m8LWyTZ+ILyjxkHgHRrB5ViaWvfyHuyrMCe\nM28R6kwjiB8sx+/mUF0a2OtoWjOCJFzulsEVcQADo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrypGVV+mSIx0dIyEDqcFnVJn\n1YAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWG/MxXeiJ6HeueI7+fxn1M22BOPv0eaDp3fV+3voEFUCIQCI96ktR7tO\n3B66j6d1GnfRGHPzA9bCvS6uypXUtXUuFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbx7+dao2HTRf/FYtXCnnlbQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI2NDI2Y2QtZmI4Ny00MTYxLWJiOTktZTY5N2RmNTM4ZTRhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODE2NDJlMjAtYjEwNi00Mzc4LWIzNWYtNGViYTBkZmJi\nNmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETRk+vZQKIeFbmXjhDGiVlK11\nra0vSMatDTw6kOjDER/UtwwzsU7AWT50nSNwHWCmiNyJL7KsjaFf0pC6gDDWjKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHUhPfMS4XAq/ZhvVLdV0qBO1JocwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA8VCf642CY9nzROpubh3b/BY4CPNJn\nqLrEXEkEVP3GlQIhANm2dNBkXkp7wEeKSAr6/dA5sWHTohoLu34cI8gxrCvb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4490", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4490` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcGQjAFVg0gG09mxEIADbIZiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1MDE3NTUwLTNiZDItNDNmNC1hMzQzLWNmNDhmNzRiMmMxOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjllZTAxOGUtMDUz\nNS00N2JkLThjMmEtMzJhOTVhYWE2MjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUbS78pLCbe1dmeIPkSW1Y16T14B1kfq90RGdAuaBv91Wuc76qvNaFDYotwNz\nmtUxny1UV1vtARE7EMT8edBLHKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ6IeowybhxUyt65/sENBh952P+MwHwYDVR0j\nBBgwFoAUBsA+tks2wgWugSpYNKTOFZ1Nz3kwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEpW0cjWGqgM\nDXPiKKJA7OigoQIOM8XlM9XuKJkmZwQwAiEAlPJIDJwU/5lLe7rIxR+xwcuzBIcz\nHaVrmB24PzvgYZE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASo3MPPyOPFHO8Nnvfa03ikPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTAxNzU1MC0zYmQyLTQzZjQtYTM0My1jZjQ4Zjc0YjJjMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoCD3sp8TFAC1YEzFDhpOZJIS52TYZGpbWC7+kxIj3Ghue\nbEJYPUGX3OavwE+09xGoOlVKboTvjfrH9Cf4WeOpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBsA+tks2wgWugSpYNKTOFZ1N\nz3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWN5HgDqqozeBXlzEwdFP9Pdtfur1N8PQcI86xgeBAe8CIQCTgDoZcE5a\nWmUM2pNshYX8xd3bowroOHLJGwfLXw2Z4A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASSpkOxwylDPQwqstgRF4IsPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjllZTAxOGUtMDUzNS00N2JkLThjMmEtMzJhOTVhYWE2MjQ3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmNmZmJhYWQtNDM3NC00MDE1LTliZWMtMzM1ZjNhZDFk\nYTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzJqU5vbiY15bBFbnVnO51zF+\npttir/WI9dlKXNSJwj6zY/XSHQKd7yg4HbsSeoSdYxteFAlK/SAAiECKpT8bX6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ6IeowybhxUyt65/sENBh952P+MwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBT2ai+xB6UhtInsytoQ2vOVpD7QAF0\nRTQ9/SgYm1BmpgIhALBKTRLZhHsx8WQCQLCi0XjKDs9etU0RNeMV/g3R4pXt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4491", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4491` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAQDHWKkq5QEs/7c4Bum71aycMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMDExNDJiLWU5YWQtNDc1NC05ZGFlLWM3MjE4NWE0MWY4MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FlYzM0YTAtY2Y1\nOS00ZDhlLWFjN2YtMGU2ZjU3OWQyNTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERaYp8BPediLm9ijXWqYx5wvw/Usj00zzktzSUrSQqbEPXEA/4WV1iYlulbLL\nNm7WFEHkXBgptkASth/ygSjN+KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUph6mtNBFmw8+7byrbVTb5ylJorwwHwYDVR0j\nBBgwFoAUmZ30/IVFvNGnp2fXd4nS6Bhe5pUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAo3SZtKg8s0\nS+NOJKSxoJyzOWHZ834WnTG49jUy49vBAiAky8HouwYw5kuhDMHfzVQWSNOnCx/C\nuwmvU1G+TaclmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASeJgjanjzTPEgx1tXQwtM7CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTAxMTQyYi1lOWFkLTQ3NTQtOWRhZS1jNzIxODVhNDFmODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOHLyzNB9zZeh4vHkHV1Cz/xwp87/z8xSww0IGbzSrMh/Z\nbP8FFtu827eKcX6qY8uO0nfpUJr5E1Lb+MhM7ZSeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmZ30/IVFvNGnp2fXd4nS6Bhe\n5pUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeD1h19a5gGVfLCzVrmlzG1IBudAtLhosgjW9RuvX87ICIFXO2jbQhJRN\n5HovdHxjz+I+AKW8uNLo4WZ879Z72BSC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASGIoEW+yYN58Sh4DTUZvFS4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FlYzM0YTAtY2Y1OS00ZDhlLWFjN2YtMGU2ZjU3OWQyNTExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Y2MjkyMTgtYTFhNy00OGMyLWFhYWMtMTZiMDNmZmM4\nMDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtFxpd/z8ItVFM/ftOpYjzFyq\nhqyA/MmN/SVM3CtvJ9HRkT0RHhu0CqDXvCGQ1ZlWNpeHUyv4axPEFkxOu7iunaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUph6mtNBFmw8+7byrbVTb5ylJorwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBLM8mKS5N3bWKzhKnUz54Y2B3lwcn8\ngROp3oW3LiZ36QIgA6SHpF1S9+s08LxAxJdJn3rmmhJM22523sKJ/lww2mU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4492", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4492` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAdSfIXU5NKUMgNPmV4Pa3mG9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzOWI3MjEyLWJkNjUtNGJkOC1hMWI2LTUzY2UxZWE0NGZjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVhNzJmMWItOWIz\nNS00MjdiLTllMDQtNzFlYmM1NzBmYjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEul/eOPLFPX/PqLvMb+onHHWawYhblc1ySC3y4j+4Eo/YrMETbfPs8Wehx+/V\nrYCflk33GepWNANNQXJcEJg4aaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaUn8jfZ0LPKYq4vZWLb2Od+0V1swHwYDVR0j\nBBgwFoAUaqXRgEeSCLAhW4Oobr4sy0mlPE8wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEA955PT40X\nrIXc/eyexC/ktrqsGd8cvf6k5dfu3T7py8ICIQCxo5weJzEVM9axfD9OuEbRDLsX\nz1sAH9qo2UlHIl1jRA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWEBDPhBKiBtfn4mS4/sPJq5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzliNzIxMi1iZDY1LTRiZDgtYTFiNi01M2NlMWVhNDRmY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARz4VnOtcBb6z96Kvibz7bsxtK4moJVd/Hdn3bOdZITR+F2\nuHPYRrGBakHmvmdY+t4dIhJ0Qeb1+n8WrY/W7IcRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaqXRgEeSCLAhW4Oobr4sy0ml\nPE8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYTxomLbyMjs09cugpxDsN6xGgz1fDZKDLOKkrUYkJYUCIQD11XhZ38KY\n7zCnYpneZBeI2DT5NOUVQVC8EIqZpR67sg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdjF42jUOE6xH4UmamVpdI7OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVhNzJmMWItOWIzNS00MjdiLTllMDQtNzFlYmM1NzBmYjRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2FlZTM1N2EtZGVkZC00YjI5LTk1MGEtYzcwOWViZDg1\nYzNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQEFxmP1IZhxy7ul1sfk9aSvS\npNYK8eflPzP0ZXi2ooiCek2J7DqL8Ojl9bdwWVqdV6aGQv2/5K3l2zCeYmDtfqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaUn8jfZ0LPKYq4vZWLb2Od+0V1swDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA1A21S9WMAWUm4NCEXkKenfDvHXPR\n+spxObcjrNZyBnoCIQC7kwU1qQeYrH6PQbtexpGWUWSMnIT7oEasuYhrYowDdg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4493", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4493` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISARnT9/SWj3RJTYwrCEpugQLvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkMGI1ZWE4LTIwNzAtNDQ1OS1hOTM0LWNlMTY1NGY1M2VhYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTg3ODIyNTUtZDZi\nNS00ZmU2LWE1MTYtMWJlMmRmNDA5YTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEScZiIrkg5rPU+wvDfnn2PM+SKuB2u6Q0iTzKwdjyYLj6szlZc7efowj3KOxm\nSei7F1KoIFu9y8Bd0q9Tkl4P3KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlboTM5WwustfcMHPgN8Xu8VaiRgwHwYDVR0j\nBBgwFoAUoyUV/0312ApwOr+KuKXYwRQC+BowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA/Y7MR9g4FOVVSjg/zNhWIDOK1G1/aQNIUSvLyRcljSQCIF3p4QEPS8BJ\nR5KjyJf/ifeoJSXgkBatTAnS+GoKzxF/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU0xw7lDocYMpZ+7FtmszLiUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDBiNWVhOC0yMDcwLTQ0NTktYTkzNC1jZTE2NTRmNTNlYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQttTqkUhzsKdwawhMMa4mO2ZJQoMg+4ULDPlsKyYBVfU/e\ndRKhGv8Vp4w49snbKUlUCQeHQpB9qmdnMo1vhelMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoyUV/0312ApwOr+KuKXYwRQC\n+BowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ4t9IbAJgysFGiz388ZCc9lOjLD0EvJIlcapqYcEfv4CIG+lL45OLRH7\nloH+mEqgM50Sg1BN3thvxoH/LooFY3kp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAaObeyTZTBVKCXeol9GOxP97MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTg3ODIyNTUtZDZiNS00ZmU2LWE1MTYtMWJlMmRmNDA5YTNiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjM0NjM4ZmUtZTI4NS00ZjMyLTlhM2UtYzI1Y2QwOWM4\nNzg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAqglcp8SaqXlG5bIcwFbzlO/\nfuYzjLrwyvtpwYgY6SG7rHU0Xl+wcNBIznQ3uIhKoIffqN5b10We0eHiDiGxV6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlboTM5WwustfcMHPgN8Xu8VaiRgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAopsa9i/BaSku7tytT/ronSzqINWV\npL/eJO8G6bM1GOcCIQD1uDe+dXhiF/Kcjx2XtkWXBqXDdbrkJqqcq4fu2nqBNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4494", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4494` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAZPDnnZ0ku8T1N+e3IBiyh+vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyZmUxN2ViLWFhNmItNDJmZS1iZTU1LWU0YjFkYjk3ZDc4YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJmOWM4OGEtNjQ2\nOC00ODdhLThhZDYtODg5MjNjNTc4YWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp0DRCbR8Wz9jEjABuuMngyU4U8LUExPzrGe2lzzV+CGuvz18e2Z/PJc1iVhk\nTplPjIdFMkHMwcLfYraGM79EbqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYq0DH120+JyMFMdvVHWpD0onI58wHwYDVR0j\nBBgwFoAUlPKCCfQYUdHmYb5V7leYMOvefVYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA6UcjTDFPbXstGBlwgPEp7Ts1z5Dz05GF9MhAC1fa3zACIQDpzH5dGKPA\n/ypWZ8/k2v+MjMnwyosUOt4T9b37Zd1HHg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATI90T26opV09Ww9n1lxuZzoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmZlMTdlYi1hYTZiLTQyZmUtYmU1NS1lNGIxZGI5N2Q3OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3EsFDsyzLevy2BvUER9YOS2m0XXp3rtMEG76+HuZCs8qV\nlBNTbH2rGKjoFusXa5LDEob3a1nI3GqsxFfdZSB4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlPKCCfQYUdHmYb5V7leYMOve\nfVYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeNDo4fx4TDrVLtWGhKw5Sx/MmpDfisKMbu37G6V6/GcCIEP0dCqVhKUg\n457hMmiSkJP+f1+ee8DKWZNukqBJ/vrQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXnLxWRLnjNQuY7wed0D9PaoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJmOWM4OGEtNjQ2OC00ODdhLThhZDYtODg5MjNjNTc4YWVmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmZjNTM2ZGUtYzlkZC00NWE1LWEzMzAtMDdjM2JlYmYw\nYzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9R8sRFTo0Fc5qhYIu2TAAsY5\nQr4xuUn3WxgWtmCGds4PJgfzychj+OiNGkLeKCV73qfSFH6KaA19g+MqHeZTI6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYq0DH120+JyMFMdvVHWpD0onI58wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA50LQAvWi3UZtAbc8ZuAneH/uB97ks\n3d4qqtR+um+VKwIgImhY1K8DAP8spgYiQuZD+ZdgtaAi8r3V7JFlP2o7tGc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4495", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4495` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAVG94D8vETHMkBvCXD0kYPLZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4MGYzMWFiLTA1ZDMtNGUzZi05MGEyLWNhOTJhOTJiNTcwMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU4NTc0ODItYTVk\nMC00MmMwLWJmNWItNTFhN2Y0ZDczNjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET3CAzNzO/Rn8rKgMgmaWunQ5buMet4oFP24Lh+JeuEmoREiEVn1czJzTg4Xi\n6JDBVlmssuZTkicr1pfxMa6kqKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTGdNoAym2RYgI9trsvWtlKMuMS0wHwYDVR0j\nBBgwFoAUazQS9qPUYdDhVL4xPGXoHzy9bKowMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n7BMjEO8efLm740CYinIPazSND0v5yQHLF3kTLH7W7zwCIQDlExBJWVbdJkqYL/M5\nTeWnnHsJD6BTJx+PMWtqTmypCg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ1tYtcQ6JkX5jBg5g9coBIjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODBmMzFhYi0wNWQzLTRlM2YtOTBhMi1jYTkyYTkyYjU3MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmoCnSzGeaGmgakY/ebB4va62BnU5/yHK7abCH3EhRlkmK\n4V0KuRchQ/2CzyZNAs4CLX+J9aHQhAO3Oux6dKiZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUazQS9qPUYdDhVL4xPGXoHzy9\nbKowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBYtaarispaMzksHPdgWKI45ovN2wpsJzZKYsLQ/gMfACIQD2Mw3c5kIu\neAx4dcIzc6oTC3p8UDczC+ctoaRa1sQEbQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbwa+XBgfUCAqdDWAyCSZN0YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU4NTc0ODItYTVkMC00MmMwLWJmNWItNTFhN2Y0ZDczNjM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDkxODQwMDEtZDQ5OS00YzljLWFmYTItM2U5YmEwY2U0\nY2U2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgqzA/kY9ht2/4YPvml+Nftl3\ndcmQcIJFIrYLZmhNwuwRR/XZ9JGphsREUI5LvPLS/GnHfk/80evdLOPn5fA9q6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTGdNoAym2RYgI9trsvWtlKMuMS0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAmCIz7ZQKZ6QmYOjrCgfF6Dtv2PDY\noNox1EBTP8VNotoCIE+DJXieAVeX8E77uvz9W8iD8sqOSMhw2gxRAw1i1Fip\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4496", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4496` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAbQvD1rnYc65S0rAK5dQPZqwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwZWZkOGRmLTM5NjUtNDViNy1iNTY3LWJmNjkwNjRkZjJhZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM1YTcwZDItMjZk\nZS00YmE4LWFhMjgtOTRjNmVlMzdlNWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOeFj49fUJpldhm2IhelZDHMcKhrtDLJc6UAqWoeLOJiUCP2nRzYUopCqiNV+\n3nCgdPIKVun5JuI0/FM+MADA+aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNuDIiizGXJ+eXwbHv9J3l96SbsAwHwYDVR0j\nBBgwFoAU79bowairGnQKF9aCCKxIHcntZuowPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA3werWJ/XpicesEToVomtLNNcVumSIJbtzcmgXDS4dygCIFfO\nxgaPwi05MoGFF+nxT2x4BpEUVo1mqspSJMFbb9z8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWOEA1SnBc3BX3UmUGYkPpmOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMGVmZDhkZi0zOTY1LTQ1YjctYjU2Ny1iZjY5MDY0ZGYyYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbO/7AthmmNALwMwXj9JrMBdUVmSsqG3K2FuJ96zsXqxMh\nVM6Z7uzC5rcATQVcut6ci+s9FArdF8T4Xgct/Bl4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU79bowairGnQKF9aCCKxIHcnt\nZuowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAInXOsNhp92Bu7VWEft5pW+IleqW66HHA7HT9UOdmRaYAiBex0f6B+FB\nsxfUlu75r7IQHwgjpxLsbvstM4umhcE5mw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZohdlYzE5UF64jl64jsfIvQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM1YTcwZDItMjZkZS00YmE4LWFhMjgtOTRjNmVlMzdlNWE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWY1ZjQ4YTAtN2I4Mi00ZDA4LTg2NzQtYzM3OGEwMDY3\nNzcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgypT3V8T8tkdPqcgC1j/Kvhw\nDJO2uNC2Q9NdkNNLqfgZez4tsWZjH8eKSaMNz0a1tU0RQ3NxwczwB8zdDdqN9KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNuDIiizGXJ+eXwbHv9J3l96SbsAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA+EhP2Iszs4RCLRe/gQJtmpHjh4H7\nXJrq2XxG1T7HzGsCIAcrOOT5SCTEAQ/Qj1m3wPCnK6Zfpu9z80LFh8NRme6C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4497", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4497` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAbgoV3BO2PgTXhwC3ex0XlVEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3MjQ4MmYwLTg0ZTgtNGZmOS05MTA1LTg0MWY5ZTgzNThkMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdkMThkOTItZDlj\nMS00YmNkLTgwYTEtOWE0YTQ5MmY5YWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+ERQuT8P1GOnNZO12x3qTLjBw2Sdh2NTNs2CE1P5IG46QxfnBg7NRX/M0HH7\nFcIdJUKdChdx7HHUQTUVb+yn0aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsQ8qsikWsilpy4UosGO8YfRF4JEwHwYDVR0j\nBBgwFoAUP8h8JLzhGP+P+KN3XEwNJ5Ba5EUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiALdz431xYMCxwcKXfpdnfw+PEiw0IYU3IGdVPwL/3HsAIgVVqS\n92r1OZUSpNhMdZ1yQ43qvbCzGqp9XJFqInMZGJU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASdW3+KWDU9SUNCONZxbs5xKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzI0ODJmMC04NGU4LTRmZjktOTEwNS04NDFmOWU4MzU4ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0XID0CkXw5wiEOhkqJFafnvRmzWVtOnFWlOXKZG5/besB\nm7rh+ro3YUuoYpNDYBsuz50mgoDOEzTYxUeQI252o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP8h8JLzhGP+P+KN3XEwNJ5Ba\n5EUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcRau9eVFYVwHXhrd3l8Mlq0Q76uwQmKMWUSkhD8RpYECIQCsDt/3iDdA\nGfvmx7T6RCD8kirWd1lROAd9QLqOnaSYdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVE2ZSvwlfXA9heOXuwFNx/mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdkMThkOTItZDljMS00YmNkLTgwYTEtOWE0YTQ5MmY5YWMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWM0YzQ3N2ItZGM0Zi00OGIzLWJlNjMtZDU4ZjI2MmE1\nMTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEemjWmBjgYYkLIZJKGWHgxipg\n2BBBWouFbLCqxb4RMBOMmse8l5wNT2SEoW+I8wkW44hkoRkKWMHIz7yh1yr+fKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsQ8qsikWsilpy4UosGO8YfRF4JEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAfhFrQYcvTSX1a2fB3HQ4fAoWFAf67\ndwqf4ScnwkaL1wIgEFLedYcapD38N4dSL3mKSWslUQDTQwZILn5MVILyegA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4498", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4498` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAcmMDzjKOdBmC0ou0dxB29J+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMjNkYmJmLWQzNWMtNDUxYy04ODg3LTU2OTg5NjRiODkyNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTMxODdkYTktNDdl\nZi00NWRiLTg1MGYtYThlOTljZGNiOGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmz7s7/DmuVa3rpdh0395zCef4rT8wi1XGNPOfW8x36U9y2JdLyD1dCj7lhPt\n1UNH/taCiXpiTMYztp+/9rMdAqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgcrRONBsbu8tkmEOKZA6X8tbEJwwHwYDVR0j\nBBgwFoAUP5Jr2quzTX33fWkmN0IJc3dLffQwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAikEBTUBHEHck\nQ3HAao5w7WkXKsJcuQxGP0qAQDAJmqUCIBYxpE4Sd2UhK49yvrB5aEUIv7tSIKV+\n0l3vu5fbBpz/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQbtP7GjFEpt1BXQRSQg3dggMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTIzZGJiZi1kMzVjLTQ1MWMtODg4Ny01Njk4OTY0Yjg5MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT01cRvY5kBflVl8k5Yu1R+Yyk2geb62j348VueiZkeFocv\nERgqmVqMhQWjk3oGO2hEREkcxxYbikfPKGYCt1eoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP5Jr2quzTX33fWkmN0IJc3dL\nffQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBi8g9Bz1AbJpwSFMtWsK6F4IqXlsSIFflzJmlEmvf0gCIGmlBQ0elUIs\npwpq4Io9GUMXUCrWkjYvj3rW2l5yb/iv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYZCcetrZWWEgBNexfEailT6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTMxODdkYTktNDdlZi00NWRiLTg1MGYtYThlOTljZGNiOGVkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGJkOTNkMGUtOTJjOC00ZWE2LTg4NTEtMDM5YmQ1ZTRk\nZDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVKeEG0Gv6T7ML+a4vIKhGp3B\nwLjT3wWeV2oWsMricB739Vo8ylj/3atCIBSYOQF3Z8o52GJF9Tlyd/b68qvMxaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgcrRONBsbu8tkmEOKZA6X8tbEJwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAppwKA1HuP5V/N7qrc4bWemlmnVZu\n4rMqZnt0cwREACoCIQD1Gb4onB2yVWZrE3LEYOUOrx3xHvU6DthdQ1VcqEIX2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4499", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4499` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeIWbdxUrYoVX/4FLVg8e+VEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MWVhNmE4LTQxNTUtNGYwNC1iYjQwLTg5MDBhNDk0NDM2NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIxZWIwMzQtZGI4\nZi00ZTk4LWFlMTAtODE2ZmFlODVlMDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk/5JEC/4KTqWj0pwtYi8enNXd9aJP35R9AUlWxr9Eenl2+0ppDj/rqpB/Qe5\nTe3NqzL2ihSdBl83nPDCW53hJ6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNFgW1lJGrCL8C9ixCe75kYxgFqowHwYDVR0j\nBBgwFoAUiBRmvKbcD/0BYqKaL3D6MpwnOqYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGnkI/QcqwGyFQ3/Y4KkhjLenPWBqbH+1WjewruTrPBDAiBKK1bmHNbHUmRM\nclqqusRBNH92B18Cu7qEXhZW8xk0dQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQxnRJRhoPMMnUqUvn9/mJe6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTFlYTZhOC00MTU1LTRmMDQtYmI0MC04OTAwYTQ5NDQzNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ27hbCb4CH0FUAi99B+ezYOeiiGLTmyhfjEyHW3r1If9Mt\nBA/a+5WgjgGynJ7f37dsqhq2beQlPKhTUAbCBraEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiBRmvKbcD/0BYqKaL3D6Mpwn\nOqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAONZMIjIbL6onPnTqmOslRFNRiAlIlbYsULA/38jKY6hAiAX0jMR0fAq\n2Sa5kXiKhJ5eTqTyozsksPeVXClV+lm2oQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASNR4cH/RXxVNOzzuDIok21RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIxZWIwMzQtZGI4Zi00ZTk4LWFlMTAtODE2ZmFlODVlMDc3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzcyYTlkOGEtYjcwMS00NWVkLThmOTktMjBjMGMwOTUy\nNDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErLQ2K3nNDzev9KjhkJE9H4zE\nQ0DgtXYoDn3qm+kvIeiPMSAJLKQQWMwTeAGcvH5yqAVQ9/9xDuFIFc4NVMOQZaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNFgW1lJGrCL8C9ixCe75kYxgFqowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBDvOsN7UuRSpTSAyUHnd/u/cKAyFkX\nZKC5zBvrAq9+dAIhAJp0dS+Ej1lZV+vH5gcc3iP1SUFgLlh9yZhS4Qa4ROpv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4500", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4500` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAS2UEB33zXNH/vjW1bz5aoX7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3NGZlODE4LWE4NGQtNGZhMC1hNDg0LWVkZGI4ZTE5MTE2NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdmM2M5YjMtNDE3\nYy00MWJmLWFmMDEtZGNkY2M2NDE4YTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB15pirN2SAbklxc9S/HhejMZ7ucwKQt1/0YvAJrC7hITUomjyfuNaFK0epvx\nNYaCfXx/tJuD/U4NnLuxBpi5faOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjcJ70QmbY24WN4Tp1tNEVGesA8swHwYDVR0j\nBBgwFoAUBsvy8tue+0occi3hrodWCDYZnfAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICpMFZAKVuIPn03vAHldgXi/DFcASacvTf4NKqvi+TWjAiBR6ZXoXG02nhtj\nqo+Fokf+678JEHPwvBGgyoRCV+rySw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbLQDalWXQMKdhhmb0gTWe1uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzRmZTgxOC1hODRkLTRmYTAtYTQ4NC1lZGRiOGUxOTExNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI6YH/AaCXGNmzhrhf2enslN3SZ9h9073hvY1SEQj8xH0T\nCP6oCJZr1zFnZc2NT/UHmAK4M4cGrBigcuydjn8Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBsvy8tue+0occi3hrodWCDYZ\nnfAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKrE7sFvtWubr7HDaSB+fB22raBprcgeBQwCYlAY6Z4EAiAZLbS9MvNn\nZzTz7OyP8uZOdGLSa44wAvI16aoSb5VQ/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAadvzZfFWG2zqRbKeh74juj2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdmM2M5YjMtNDE3Yy00MWJmLWFmMDEtZGNkY2M2NDE4YTZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDJlY2IyZmQtZWExMi00NjQ5LTliNzktMTRiOTU2YmQy\nMzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa2JRnF1oVVsKXnTRiDDd9J5A\nl2sdHTNPCFoytvKeenKc35d0VUIXXw78EJHm7qvnfdcLW4ykHJfr7SJIO4UWnaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjcJ70QmbY24WN4Tp1tNEVGesA8swDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAlbLzQK+Vnpmgvmm7dU2G9Qn5GSAY\nJk2y+yvSKHUWCRoCIEJ4f7py6dWNeIbuB5UUBa+Djb6iYo1yufPEjCH7HZsk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4501", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4501` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAQzhieAatGS2kzFss97cPgH7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkZDBlYjc0LTk4MjQtNDZkNy1hMTBjLTAyZjg2YjE5MjQwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFlNjg5MzItNzY2\nNi00MDA5LWJiYTMtYTZkMmE2NWE1OGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ZUk7XX0jO0LKwQihdmNs7Z6RvjxlRe/fTnPU1Nvz/jAfNp1UzhYNGTiqHNe\nQ6dvHfUJK8X3oq03RkvL9JGkVaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0USIrxCuD8/uCo60l1WFHzQecSowHwYDVR0j\nBBgwFoAUBniKwS7OIzEs3qqD6Icusqw2u70wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBPueHEvKN9bL176M7doUJdzTR/wNKv7W42OzD+hINT9wIgM/sk/085imCT\nxqp3bf2TtFyimaq3enXsMmr1fZ41D5c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbBZfZd3KEC6G6DKci52Y8TQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZGQwZWI3NC05ODI0LTQ2ZDctYTEwYy0wMmY4NmIxOTI0MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZlW1W88xgLGmBXjKRWDW34Li9lpwd1q5hY2IunpMVva11\nfK1lpZsBc8gsu4KmrNXVTCXZi5S0bItHfwxT36Bro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBniKwS7OIzEs3qqD6Icusqw2\nu70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdd/5P0CH598/JepkGzE6ItUUmF82qsUZMjeEtqtEDxACIBMxChE9Qqsc\nN5gAQ0W4coUsZB48hHyEaEL+DioaPCSw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaSRbg4vOfmYZ8wqpBzcqacZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFlNjg5MzItNzY2Ni00MDA5LWJiYTMtYTZkMmE2NWE1OGRmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2FjZTlkMzYtOGE2OC00MzcwLTg0MzUtOTUxY2JlMGFk\nMzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBLz2MvaVjBC3Zrvx63PXLiqC\nSQ33bkankTvCiM1Q9sVwTnWyCMXULU4bzfI2lK95Oj6qsukyEMCdiY1K4ZtK8aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0USIrxCuD8/uCo60l1WFHzQecSowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAXncP9elsmwT9XN3Ur0sAF/0Q/gLxW\ndQ4pJj+qakXF4gIhAPYxE5thl9sNsTuKpO1x9rulwgqI260j8kReZzjtseW0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4502", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4502` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAT98vTo6aCtuZ7+8Kel5Cu4ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlNTJjMDhhLTMzYjctNDBjMi04NWNjLTNhNmZiN2Q3NmZjZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY2YmRiODctNmMz\nOS00NjE3LWE3YzktYzBlMDQ0ZmU5MzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErQsbwtlZ2ZY0wfCbHz6609pwdMqaf4XvOGwe8k58BV5bbKm3bp+SxDNZejcp\nslzSST+bCZd0pcayl5I/Rsb3T6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUutsQRZ6Dfjghy1CTQTOs1VyqxrswHwYDVR0j\nBBgwFoAUx6oTWlCQ5VrO+kNj4ts0LyXeXhIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBuTLXBI9jHuj9aN0CuAF2FIMGZWVk2P1S7xaGvvDB9\nJQIhAK9/LKBIj4BYS6pHoLXOBqXpNvx4/HFq85J3blcJzlNH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVKOLMyUfxSBEruMGmue4dqHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTUyYzA4YS0zM2I3LTQwYzItODVjYy0zYTZmYjdkNzZmY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVHrG/I9gQJP1K7IWoeHjR/trdGYA8TQ8aflz3FZgMscd2\nC0m849+UmZ+EQRlkiMZ6hA8PofqEIk3MyT2PT/D7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx6oTWlCQ5VrO+kNj4ts0LyXe\nXhIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXAaJUaD0g38OFO2mqV7X3raPp73JJgmXU0lVLbB6Y8QCIEVwFYW1q4H9\nrbCvVicKlSUBudZ+3bcmXh0Lun/UQY5a\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARyJieQyov1fGFfRCltPcYITMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY2YmRiODctNmMzOS00NjE3LWE3YzktYzBlMDQ0ZmU5MzQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjVhMzI4Y2YtOGNiMS00ZmE0LWIwZTItZGQwN2IwMjBj\nZWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuJXTUeNNAte7HLP/8bOpzZra\n+ORJGkwyAsUZPfmY3l3lIrLCh/PBc+t5MLE7og4SSPxfGA0E/wAmPtk4iqrGlKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUutsQRZ6Dfjghy1CTQTOs1VyqxrswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBGwgHhWgY0kcOxGGRcn8fWeemO9tmA\ncmnz2025ju5DNgIgMIkB1ACIQXtET7PXnnNgdCEWMApwimP+Lk+v6VHWk34=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4503", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4503` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAe0MpFX8OKCNyjf+drzSVQ4LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkYTIwZTY4LWU4YzQtNGU4OS1iOTY1LWRhMDY4NmQ5ZGM3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ0ZTZjZWQtMGFj\nYi00ZTc5LWFiZTQtNThhZmE1NjA1ZDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQCtOKBoInnVm7G/1ayqnOQQpcKHf9+sgo2d/nW8VIJW3O8J/1BT55Eh3zRDy\n/teXQa48spbI+cuwtfYdyrzpQKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSSTn+aX8aT0r0WCd9pB5JwZECkYwHwYDVR0j\nBBgwFoAUB6Gz76ScWG6liLXfkbRgNGk4bnUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAvzdwtazL77YfrApvx5xz0Kl75nD3cJGui7l6iXXd\ni4ECIQDd8RwpRexbvO7KFFVZaz8aAb8jzAYpWdbUT0GX+ugiBA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAadjLrXuv07/hbLMpkg9eIhdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGEyMGU2OC1lOGM0LTRlODktYjk2NS1kYTA2ODZkOWRjNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAzmDDPqRAmkJ+O0x0k0Ox5asSw1NI2JIpr76eKYCOgcj9\nx5pHKtoUOHdygqD6jcUVr+fUxnCquTK0fcSasvFVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB6Gz76ScWG6liLXfkbRgNGk4\nbnUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcH9AVcnyveHjTfavE9hEyygRGCQTqq7J8mB/Zfh+lBoCIAtiR52T2xrA\nq/UL632mhIXlfbIK+of/hPzcZJ3p9om2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAUqmhcnn2wUCawTlIpBjUzy2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ0ZTZjZWQtMGFjYi00ZTc5LWFiZTQtNThhZmE1NjA1ZDM1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjIxZTYzNTgtMjhkOS00NDQ5LWFkMmEtYzExZjQ0ZjMz\nOGY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQk03itc1LlYblKuBEmsafVvS\njXRldYxmRUrujzHrIWiu6/lN6NXYWz3J5W6nb23YDSfRx0PnxIqQ2qAUPgiv5KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSSTn+aX8aT0r0WCd9pB5JwZECkYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiARmeou10MehvQ6jldbOZx+PKhRsUk1\nlA9l/sjcm5rCtgIgNwcgKauiicnHkokmrLvtQXBWf4ko/t0rlm2iqQZGxYY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4504", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4504` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAcFc45fUTdIZQtOwz9XMLVocMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2Yzk2M2NkLWUzOTQtNDQyYy1iYzg2LTE0ZTRhOTViYjAzNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRmODY4OTEtZTEy\nZi00NjZhLWE0MGMtZGIyZTU0NTFkNWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFbLdrW1URkrni0+fRB++0Aq1Jx6m/DhZdVvUpJWb+DgbylL+AUWnD56nMKGS\njn4+2482CpuwQYo+BpkeuwZ8tKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURR0B2/BDCLU3Z9LI+4vOBXfOxtowHwYDVR0j\nBBgwFoAUI3gCSP+RA4gJAuNHfHMMTFcUs/YwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAx+HvzWVu6BVn73AXaSg241xsJCTjoket7BU2ifqtQlkCIA8J\nrRr9sEGMVECr7YRvQ66Sb0Fn+rcHCPpCviAxdS7i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVf/Drmx0SbBdUBxX+SfuXOuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmM5NjNjZC1lMzk0LTQ0MmMtYmM4Ni0xNGU0YTk1YmIwMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuDeuMq6Lk+cBamNhHzR9GUGqLho9uqosIBQ3t4/8oNSaY\nq99Sg8nshLzg722ZEng75SncKZE9scYLlM2hbS6bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI3gCSP+RA4gJAuNHfHMMTFcU\ns/YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcTMdGTe/Bd/v4DqP/i7B9lVrJEQzokbjGzNdD4xDVscCIQC2yDAqeSbP\nlgafZX2LKIMIfGL/SwK7e/qzrsGElaZRnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZC4FM71d+H1z3vnOnmVTmWnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRmODY4OTEtZTEyZi00NjZhLWE0MGMtZGIyZTU0NTFkNWI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGJhY2I3YjAtZDA3NC00MTM2LWFkNzctOTRjMTRhMDcw\nYzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPKX0Sok4aRdQlNE9dxA5ez08\nxU8IqQMmrCoGw7vR5MhCUHeWTZ+Ym0R+PV9UoDebn1aBltU+L2qJ7izavcRcgaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURR0B2/BDCLU3Z9LI+4vOBXfOxtowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAqdOvd8pPWw3L0eeudmqBjUgNEURy\nEGATfUF9/zrcnAECIQCrenfRecptqt0dpR5GHoblDXQ7YgsB/V/FoEVFeUDmEw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4505", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4505` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISASGltMRqnjYZKXsnXJ/fDoHCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ZWE5NGVkLTdiNzctNGYzYi05M2E4LWI2ZGFlYjA2NzFiMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2QyMTYwNGEtOWQx\nYi00MDJmLWE1YzktOTQyZDZmNWQ4ODM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5O6eQKVpKah9LpSdzou/6lykPsgYm+ybjdwl2hz7qmBN5aiCzjg0wBRtfMrK\nTDGLn+UK3ff3SyEvD5t7QkgiAaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU70X7yi55Bu9wDgUKdQhIg7Vzj6cwHwYDVR0j\nBBgwFoAUTNrxMGVyJ9+gqIZ2/Kx3+QExfgowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEApbTFia+eO/cRVvl/zWt02sfXss0EBoki\nmBQJNNJKjYoCIQD4YTmJZUelR0YbWHodnUTrUtWi79QfjfFNmAczu+fmOg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcc629+oAbrtu7vAtDcBVEbZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2VhOTRlZC03Yjc3LTRmM2ItOTNhOC1iNmRhZWIwNjcxYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATri6rqFyC3Tp0NixNEbsMPjLFW4wUlv4rMQIzZ60q++Ije\nLNC1FDObLJgKHXAFmgsWmKIwTGntPxw+GNPdEvdHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTNrxMGVyJ9+gqIZ2/Kx3+QEx\nfgowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOUQgtxGJct2dZihWzQ5NLzYW8MLhNzNBApV8LipTPclAiEAoKZmnQ43\njT/4j2gRJ9+awwYBnEW2HvBHQ2PenNdVb+g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeZGoInJvVVowVTIncG/sbRpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2QyMTYwNGEtOWQxYi00MDJmLWE1YzktOTQyZDZmNWQ4ODM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQ2MTkwOTEtMTkxMS00YzAyLTg0YzUtY2JmYmUzNTVj\nZjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL+5GNoFgLMNzfwQ2ikQH/GV/\n7ds8a1oJm6D5ZO1ExotmrJEelRSJaNR6ihZnbFijEEggZv8qbla/AymbeLLnPaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU70X7yi55Bu9wDgUKdQhIg7Vzj6cwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAqPEmcdeqYplqrIC35vqGo5ZCBMKt\n5sM19UwJ9SSKtBUCIQCuCo8eUX7ohTpqRjn7YPm3rzUpJLgBaZimVyVw/HV4Rw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4506", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4506` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISASemjjLPxSWMec3iWcFkiI9CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZDY2ZWFmLWI4ZTUtNGM1Yi04YmQyLTA0ZTNjZDZlNzUwNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM1YjEzNzItM2Nm\nYy00ZGY0LTkwNWQtODY3YWE3YTcwYTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWGHBt25JvwlNa4o08iXGIvuC/5wOad9Us/lFtpDyfovPsPl01+yf4n7nst1x\n43t0/f1QwsefuiFeRlWtYbXEtKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbHaHT/FOUbe++vLc0vufZ/BDKoAwHwYDVR0j\nBBgwFoAUfpkqRn+4e0Yvvxy65sbU6H9dDB0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAsWMnlnvvvfblGRD5qrGSwA3p6DkhECus\nsthtLeVgWoMCIQCph5RL8H88/5Xe5hndjtvOYRUxpv6X53ismQttj7zPCw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUQye79H25y1hz2E/xrwQuhNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWQ2NmVhZi1iOGU1LTRjNWItOGJkMi0wNGUzY2Q2ZTc1MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfi+3HPS53WKznsrDOcvIPni3DeeMBnKuzed8q9x1/hjCn\nApfRR1FEexim31usYsW45zm3+IkdIMDR8gz19PBWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfpkqRn+4e0Yvvxy65sbU6H9d\nDB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKEyw6H/ObpAzQxnllwihG5pfHcUrwAK8HMdO+c6bkS4AiEAmsEgIKOa\nzQtD2BDs+JDNJ7RcC5SByhRVtIzY45AR/C4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAeMk+mPTOYFKJFq/PYqx1k5RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM1YjEzNzItM2NmYy00ZGY0LTkwNWQtODY3YWE3YTcwYTRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWI2MWJkMDgtMjA1NC00NzU5LTkwNTYtNzhlYWMwYzQ5\nNGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElkQVZ8qtkXA4v6Te3xcwsOaM\n5sGOAta58WFYnyngG8DetwSsH0JUMzqwZscKtoqPHF3Qp7GbVR/SB5VlnFCBtqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbHaHT/FOUbe++vLc0vufZ/BDKoAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBJGyREBGdYa43rgZhGebMRb9t1WtZl\nn4yqRfEjHxnfTAIgeMITVItZALEucGL3eHgu6ntLB+Pjd6nT4aGAjZdGCi4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4507", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4507` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbmm2rAjl9YTbJuuHKgiLycdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxZDkxM2ExLTI5MTMtNDFiMi04ODQ3LTdhMmNkOTg2NWNjYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA5MTg0ODMtMTdi\nZi00YjNjLWI4OTUtMmZjYTUyNGQ4MzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1677H0EphPLVRuiNDCJdFVSD4pesleyuyvI5SlPBg6ybIIMu3KxKz5B7vH33\na1e1XrfaThuAC9QcT5hlYI8Rj6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuWXEFes/fqzEk6Y8UZCoogmbbS8wHwYDVR0j\nBBgwFoAUOS/HqM8XcbUx3CWS4fqWxmBtvz0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB7jW2rzYxQmq2g\nyDUiYOFOi2NQtEASknMy6srcusY6jAIhALliX0prWPgI5FRQQewGzmukSCdZjA0v\n8XJx+iAGG/oP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASDG6oleOtQd5EUhzROTXi9WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMWQ5MTNhMS0yOTEzLTQxYjItODg0Ny03YTJjZDk4NjVjY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtze5FUhWIPJ6i8nWLwPHF96eF07o50fU0T/5j8ymGnadK\nC3KTo87i4TpC2cJ3l6U+T3dNq3oA7Uh1XHXBwZ4to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOS/HqM8XcbUx3CWS4fqWxmBt\nvz0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANgQb4VokWvlemDA751sfyzdLJyvW3kutCOp1WHJgwL1AiAEFeCjcmU5\nNijsf6buk1ZqEZmmki/UCPVCrvWQXuBHUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcdT8gsjGFLv3BgQyFSO0gnAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA5MTg0ODMtMTdiZi00YjNjLWI4OTUtMmZjYTUyNGQ4MzZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjc4Y2EyMjQtODQ5Yy00ZmJhLThiNTAtNmUyN2I2MjJh\nNjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdxfOSNy/Zk/UlLjeDge+S8IH\n2JliHV9bGRp1AkhLHywVSKcvu77kRrO0G8+I6qE3fbczKbmCz4Jv52RJKRlABKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuWXEFes/fqzEk6Y8UZCoogmbbS8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAhAXhHxnefO549Y3tcOoPaUhXmOwu\no9xrkZkTwXE+y8QCIEf7pFtJAooTWsS7dLll1ersySkFKgR3mFjU9oKt5rmT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4508", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4508` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASLxZB/wbtIReuN4ZXGmFo/mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkMWMyOTI2LTllZTMtNDFkZC04YzlmLWQ3MTRhM2ZiMWEwMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFjMjVjYzMtZGE1\nZi00YTJjLWJiZTItOGE4OWM0YzBhN2I5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYhkr+8abgDTGe3+JOYhw3N5txQxs2g8I8+GHgfEoX+xxb8AokMmEpSZ9ClZd\nejO1i1c3XPJN0kDYms2qYTEP3KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUayvqom16Q/VU403QB6bmTBKdeFwwHwYDVR0j\nBBgwFoAUe3GflZpkKxJVR9NiHdlkx/Exgz4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBDW6ejyOr9CGGWlLvHVJgBYyFgEd6PeYdPma9+0MdIXAiEAhvJ5YHiMZJe1\neKppOtVydkfLZTa+rLvLlm3mbLclaGg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcIBi/CBbc8OhglTR5TT/BsOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDFjMjkyNi05ZWUzLTQxZGQtOGM5Zi1kNzE0YTNmYjFhMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7yzYgq21XQLZb+XR7KAPavTkF+LMij4fwmBOS8llpOIY3\nbQHsI1p/MeMv2pSYdm5pDFPMczqE/ReuzfD9UAOLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe3GflZpkKxJVR9NiHdlkx/Ex\ngz4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ6OxKoMm03y9pNdfmypO0EFKnpVyaPW5w9DzJJ+qx+0CIQDdxomQIbXI\nUjoB2GnVst8+T9wNxLtZC9HOuA3Mh4QfIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISATmfdgvBQfNSR9chRZXAy9vyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFjMjVjYzMtZGE1Zi00YTJjLWJiZTItOGE4OWM0YzBhN2I5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDk5OTQ0NDMtZjdkOC00ZDNkLTk4MGUtMWNhOGNiZjRi\nNzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkyi4b3M4HaVYqFxl/urAiu0j\n/I5DxokRqgl35POmZbGFi1vNcd718eUR/4bSiuh2qkVN/ISXouJWAh0nhhLIFaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUayvqom16Q/VU403QB6bmTBKdeFwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAqPf4+1GePnImoAKmLWOaH3N7TpXE\n5JuC0povI8Xg2yYCIQC5hfV1sDccs+eFUMqe/sxTFgGXjbNLPoufuei/ezv8Zg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4509", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4509` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXEB4cFDSmCQHcoAEjAzc59FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzMzdkMGE0LWNlZWItNDFmZi1hOTI0LWI0NTk3OGU4ODdjNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFhYWMwYjAtZjRk\nOS00ZTNmLWFlOTUtYjI5ZWU2NjZlY2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/CsnahNXGv32UJU15E/3wnpkm30N0BmbMwlunb1YTrT9GXmaDKXz66vY6NBb\nW5kQHJ+Zc9z+qihJf5Ht57QECqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZeeUHwupJx01DskOWCeQHy7xof4wHwYDVR0j\nBBgwFoAUefOvcb40RdTZrZjAoRKlh7KojuYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDaK0CSb1CfO6O9/6pwq2HYm5ju955adIT4tT8mrFdb0QIhANmGETqE3v5j\n8jinSrZs5vViWgrPYHgWYd5+5/zdtNvi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAam5MKUkYDNx3y8mmJoKazd1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzM3ZDBhNC1jZWViLTQxZmYtYTkyNC1iNDU5NzhlODg3YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARizccdwCONudH5Qo9LeAv1qwtAis99dYsy2t7GZm202M3O\n1aDWBGVuUHApCcuu6KsOZuzt8YOZLRvOzaFJvYXco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUefOvcb40RdTZrZjAoRKlh7Ko\njuYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALj16oG6C/u4OtCAoU54lUALESv3nVDo2UyoBmkUYX18AiEAi+hPSfFK\nDZF/gbATvaMTsVGku8YjA6JZueMEh7dVOyg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAf6weLRtgqN4ZYD5jQkyY+xOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFhYWMwYjAtZjRkOS00ZTNmLWFlOTUtYjI5ZWU2NjZlY2E2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTRjYTUzNTYtMWQ3OS00ZDViLWJmNTEtYWRlYTVkMjY3\nMTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKJvgJSmc7lgL9Sl5TLczR8qX\n/GGu1i73tN+ATJPYYvTPgEY0oNlJyrfj4fhyRONhEaJ/78ItEUL3F6fgBM9ao6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZeeUHwupJx01DskOWCeQHy7xof4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB/LrGHZZuzUic5G4OwWv2uxglkdUQz\njT11jmdbuYG3fgIgMW/ES5WSQA3SRa80CmgY9x87FFk1oJZxMSeZMRinEes=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4510", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4510` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAUMJ8cyGdcy0Jn+QkDbvt9GNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMjQ2MzA0LWE5NWEtNDM0My1iYjgxLWZlY2E3YjFiNzVlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzYzYzgzMTItODY4\nMi00MjMyLWFhZjItMjE4ZjYyYjQwYWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGnpT4BYwfedQBs95f8i9muqsqKkU84fZIfWkH9XQeo0wWIq60OfxlZnzwVpG\nutf8nfE6OT8PFhZPOil7TJqMg6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7uc4Hz/raBnzr6lbBgwSVVUYy+IwHwYDVR0j\nBBgwFoAUJrbaXCLkZ9aX5IFN6wYEE0K6t4wwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEApwS/Ms3Xr+59Q6Z2drp1FUUga2F1nk/WW78C07DTWekCIAX+6YtKvquQ\n5ZKm24BpUBiMCx5L7gfok9Ueu5xrnHLG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVz4kFVMWV5VjB81hVxtozNhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTI0NjMwNC1hOTVhLTQzNDMtYmI4MS1mZWNhN2IxYjc1ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPKu9NPQsohDQ9YdBvkjjQZt7r/Ivw7GI9xkr83u3z9wz5\nXb2sarNz3jpcPFZCYBssozAnqlLXCkUGlASe78Dbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJrbaXCLkZ9aX5IFN6wYEE0K6\nt4wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaVbolwzFBSoNsEyvxpIZaOZ8e9B2HQq7PFiyrGDoL/ACIFonf7plxnxj\nNiMKiiXTLKirKoVx11DNur47KtAKw9UQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWPqutTR0RtoNQPCYMzcU1hjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzYzYzgzMTItODY4Mi00MjMyLWFhZjItMjE4ZjYyYjQwYWQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzczZTVhMjQtYWNkMi00NGM0LWIyYmYtMGYwZmI1N2Q0\nZjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERg+LFsW2ILNOf6+eeNdrl0ZD\nyqTdCRz0cx9AyDfMdeRiQso+qySEyWD+dI+tYY3buR+18vXBb6ksv/eK2+4NyKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7uc4Hz/raBnzr6lbBgwSVVUYy+IwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBX9ZmMyoPY7xZu2gCXcpNaIhGt2NTc\na8LpDZr6SBVR5gIgdIwchkjLsBh0GGjIY1BmBABTenF89GkwbUMjVqD0BUA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4511", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4511` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAWYshBBP8q/vOtjpMtuSETsXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyOTA5MGIwLTc4ZWYtNDQ0MC05NTE0LTdlZWU3NzI1NjBiYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDcyZTI3ODctNDA5\nNy00NzYwLWEzNzAtODUyMTc0ZGRiNGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE23hYZ6OdlDAytArS2TC6CdSEpj2/qBbDW2gZGc7uaVrA8S57yHTvoiE2TmyU\nIdNGHX/7QUHga/WulS/5o5dca6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK/JUmhXfCFYt2upPsfqp3D7Mn/gwHwYDVR0j\nBBgwFoAUDwjLERS5xqC4sLyzIb5e/+jDiXkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAMxZp9QxuncJi9O+AdUvyQAJaOQMsDiohbFL/wsOnT\nZgIgJk5OAP+UCz+5FRrsf3wePD3lmlPFPww4L/vx8kN//PU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWDzG32IMlztipSUpXQ9FlGNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjkwOTBiMC03OGVmLTQ0NDAtOTUxNC03ZWVlNzcyNTYwYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMlfTD0seIZT8L1w9l8GeqArOAPLwTEUuhbBiQlGt3CIb3\nI0g6k6rk1m16LeXN5nREJRP2Y4YPmT4ay/AqsmZpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDwjLERS5xqC4sLyzIb5e/+jD\niXkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAajyQeiCBVHkS0kCDxIYEanIel72ghmGU9NXGGV5+DECIQD8nxENs9IM\nl2MGT5/t6vAbDa2xTEqmH6/7TA9UjRbkGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVQmNyCM/E9vI5JAKAVJ3fGrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDcyZTI3ODctNDA5Ny00NzYwLWEzNzAtODUyMTc0ZGRiNGYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWNlNDVhZWQtNWMwZS00NDJjLWEyYjMtNjNjYzhiOTAx\nNTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwKfs8CDNHy+vej7K3PJqlznr\nPRycfQY7gD11oLuXJvXWRdMp3x7wMZBjxtSfuqbvXOqlTLk+z+/ZTeVyr4RtcKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUK/JUmhXfCFYt2upPsfqp3D7Mn/gwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA9gEoWG8ImGokzwPywOjKF+xmdICp\neik3+iQh0TDKfV4CIQCpzgEPVbG9+EAYW3YfLm+z/xgHEVO3qYMVqNwGg7OzHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4512", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4512` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAbc9zWTtw0Qzw22G/19q9Cl2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkODVhODYxLTI2ZmMtNDViNi05OGQ0LWUwYjM3NTQ2ZjVkZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNjYjUzNjYtYmNi\nMy00OGVhLWJkMTEtY2MwNmQ1NGZkNjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOLWZDn8jSB3pVJutc89V3ilNrvkcOPh5Gjjv+R2T3RJEICI9EKAJSiQG62dK\nHyKCpmovKJTFNdIF1nYMswAXAqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGoCZYWeiaTL+uMQkgHTCSdHcGSUwHwYDVR0j\nBBgwFoAUnufmx6W8WxVQgxT92ypYpRHWViIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiB4pyp74te474bbey2zH+1QxldL06TpP5MTWNm9DLfq\nOAIhAKQXS/fQ1tCzoN4NaIWzvjU27p4sWDwyHA4ghbTjhYXt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ2KIgVPm5RPGqWqgPzWcPvSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDg1YTg2MS0yNmZjLTQ1YjYtOThkNC1lMGIzNzU0NmY1ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyme03BTPVlcQQa6rxosmw7UGnXRSlPcbBgTATQswqHE5g\nRliOaV6/zQyj1ZCfUf386hEXn0nJDrSX79f5MA/to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnufmx6W8WxVQgxT92ypYpRHW\nViIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOuw28pXNNoCqMTAtj+NwnCNnX/7udCzzh1A0k6RfdP+AiAVpjUkknlb\ndbLkg1rHEPqJmfw/nVdF79mpYelzRqfAIA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdsrDW3xpms/5Kyngs6nTgS8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNjYjUzNjYtYmNiMy00OGVhLWJkMTEtY2MwNmQ1NGZkNjAyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDQ5YzIwMTMtNDM0Mi00ZDZlLWEzNjAtNGEwM2Y3YmY5\nNWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkSkl856fRDrDCIhOzXa/jLRi\nCWGwrsFplSN/intf2Vt+rviP6CucjAGNkA7xlLRodWAQ0ls0BiJLXox51UuTY6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGoCZYWeiaTL+uMQkgHTCSdHcGSUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAwKm60H9ulE0yJ9LTLyhdLjw9Mggo\nt9YV6ipUnc66lJICIQCboaO723xTva61LFTDyzoCpKzZIgZ43oMyswROGU7I8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4513", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4513` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAcCzotsPxceEmqHweXBY4AX0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmZGIyMGExLTExMGEtNDEyZi04ZWVjLTAyNGFjYWZlNTE4NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdiODdkZjItMTBm\nMy00NTNjLThiMTEtYjUzMjNmZDM4ZjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExnUEgrrbTez/Rl48xlI/tBNqeut8aKBJpWCW6iUDho3PiETUZjKy6U+FNUFZ\niinE7Jr6l62/uB2LFuRFlj6J46OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrqg4G0GwlKmZaaABekdr22tkyQ8wHwYDVR0j\nBBgwFoAUsyqi4pQmRG6x1v7cOHLlRuAUiZ4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA/z/uQGJKBTqgH2nQ79RKwp+DNZ+8YgbWkQqMt1oTd4kCIAQc\nwY7cCVCxGJRd6C4/85qnGgE8TASmSn9jHj+vZ79F\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ6E9/gn7BbwyTwl/UHT2PMUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmRiMjBhMS0xMTBhLTQxMmYtOGVlYy0wMjRhY2FmZTUxODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlSaIFI81ktqVXxpvR9WeViu/MI29rgVu9K4poQ9UgvhNX\nvOUhamIsWBzsDL43C6ZVcVfsrTQH1P65Lko5W8g7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsyqi4pQmRG6x1v7cOHLlRuAU\niZ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJQI4vlE9MwSo8x+sz6Un7ERqV5WKo4V6etStBQrAKA0CIGp0F0a44LQt\nLZUGOl+8wB0WPYpWX0pDdLApyTmfH8B5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbvuEDqXLF1z40f1ALEAhVRZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdiODdkZjItMTBmMy00NTNjLThiMTEtYjUzMjNmZDM4ZjFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDRkM2QwOTctNzAzMi00MGY5LThkODctNmU3MmExYjk1\nNGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuVwp72f9g8R0ybqDfk0LtneR\np1nA80gcDOpbDb+ZVLFwcoVw4hrWsxN4dLVFeQ4T1ZrMGHJ0gqWEyB8Y6m82yqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrqg4G0GwlKmZaaABekdr22tkyQ8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBK7RVtptQGKlfF365JHLAtXRAOVvZF\nMHULWu1jTU4bYwIgZ3+gw5bj4g+xbd9DbJpYtukV8uYYN/uD9uBFviGP9f8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4514", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4514` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAXKO/n9YmXpufKHb1SYETIweMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4M2JmMjJmLWMyNjItNGYxNS1iMmJjLWQ3OWY5NjkxMWE3OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzczNWY1YmItOTRj\nNC00NmRkLWFhMWYtZjk0ZDVlOGJkOTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbn9BpmU0hmWPH3xHr8bDNYTdSTIFRNxjDFbhTUlBeeodSEbeER6KiwCtHjHQ\nsJaz9YVIANLSbhqQHadFrGNS0KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUncEgeU5iNwc/YkreU38BkRQDsecwHwYDVR0j\nBBgwFoAU7uxIpOBPqFg6YVIle6yMC/y7L+0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiACdt/wjxccxJuDmK2lCf8APBvbPtH2sxdu\n2b/lq2oeaAIgBKk/HyJu6EUCX2YrvE2lUchZnqYeQhqLVMpHoH+oSCw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWYiE45csu28htMjxgG7+0BQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODNiZjIyZi1jMjYyLTRmMTUtYjJiYy1kNzlmOTY5MTFhNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGFflkFTMKxJRKBxQxvFVWTeSO1nplQ2Sarfyr81IV4MEs\njiZN7DAsuI/SC2NvN+38U9lubWhblJG6nauuhmnko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7uxIpOBPqFg6YVIle6yMC/y7\nL+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDnAPlsHxjfSE79P6wyJIqMbyknpsw7XEfjTJXgch384CIGuvDHF3yOH0\n6XXAn13sDYmM5XQ3Q7rYpCI+p3a6Oc3s\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZo+o+nCKKTHf6IxOIdoNQFwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzczNWY1YmItOTRjNC00NmRkLWFhMWYtZjk0ZDVlOGJkOTRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDFmMjUxMTQtZGQ0Yi00ZmI3LWFiOGMtNjRkNWE4NWEz\nM2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHAhKmEwAgJgVbFG8myTms8Ul\nyLc0H7RzCA+Aqf/jqCLxup/sUpSEDWsWVafO+gV1vSPWb1T6K8dcmudbOCW7EKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUncEgeU5iNwc/YkreU38BkRQDsecwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA1LVfq3rzVH6bU8QAOYwiKIdBaskm\n89YqBIPxUwTSjT4CIQCfSGmoA4skveE5ymr9mBUMoV102/9Kl3U6dkqh9FsrSA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4515", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4515` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAVNXoJMWfAQY+HxU5DiVctpVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ODJhOWM4LTBmZTQtNGZhNi05YmUwLTNlYWI3ODUwZDFlMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ2OTJjOGYtOTRi\nYS00NGUxLWFmNjYtY2IyODlhZjY1MTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAZxe4Nvhu7Lf06u1m5Ep3eH+CYtVn4oWxp477YC08bm0xypPql36yqr7+7se\njyqyDdKkPG81HdNcTAZIblS5pqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtPqldGj9+KUrHMuUV4eDbndRLC8wHwYDVR0j\nBBgwFoAUC14fr9O+1Gl2HHjPLzP/uWpJEQ4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA284AzeyXN9C9AYNdWgvKjMvBfLavXk2I\nljePmgkqQUgCIQCltNQCG90mCjYP96jIc02b2IhEMwTJdrmnmZHSq11n/A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUCFGpo77oQzQMWeoNf0O5LvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODgyYTljOC0wZmU0LTRmYTYtOWJlMC0zZWFiNzg1MGQxZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4ZbeQN8JU78DidVA/5HorQXeWOLJAGZXR5I0yqb5+WZHH\nwyfDWtnR9ZmuovxGYDSVaqHZDgr9zpfg7iMe9ElTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC14fr9O+1Gl2HHjPLzP/uWpJ\nEQ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ5qmN0znp9MsjhZMAT4FbTJ/Vu93GhvG8AlH31NtuDgAiEA1v7wb9yR\niMXw2a+rYQ0ugBuO67Lkf5OJRnm7khLhg+8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWcTbTmVzHz8Im5evlcZ4vsOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ2OTJjOGYtOTRiYS00NGUxLWFmNjYtY2IyODlhZjY1MTYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTIyY2NiNDAtOGRlZS00MjZlLTljNmYtNmJhMTUxZjFj\nYjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEubw1M+kgSZ044cXV+Rw+u/Wg\nK4gh1xCOhK9Acj4bxi7w3eMGtUr3pEySnfQtKm9Yjke16An/USZZP3J5Ju7/eaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtPqldGj9+KUrHMuUV4eDbndRLC8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBX5SV1RWZG+FS00HO0EAVwW/rYV66B\n0GL75kpuc2zQlQIgOwigJzBh8NBTM9Lii807jRviNskfFKmfFIBeWuaNAqM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4516", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4516` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAR4kJ/rggZhB4kpJ9lGE+5ExMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4YTQ1ZTA0LTM2ZmQtNDY2Ni1hNjk2LWRlNzFiOTI0YjI4YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM1YWY3NWQtYWVk\nZC00ODY5LTk2MDgtMTc1MmIwODg3NmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUTqJGgc+t+GQAYKnmR4TQPaI8vV6muYUEZX4N6CNdvYU4Ms0WWc4/QHY8QCX\n3280druP4n6a8byw3Tv5zaqvZKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqn+glAwwSFIT1D37nmy1pEtQ1eEwHwYDVR0j\nBBgwFoAUOgAop6fzl+uegjlEDIooSIWUrAQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDEYic/KUO04tXgBjoneLkADR/M\nixvYS7WCOlIxVtenVwIgZiod7iNv6NAZR7feWFHPLL0uvePODlF68br9z5w+g8U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQwUddY0Dsu9u9ZPiD9jtXz6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGE0NWUwNC0zNmZkLTQ2NjYtYTY5Ni1kZTcxYjkyNGIyOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAMhquXnuzxlYyrLa/m5xm5P5sqGZ/dY5cFTLKgpiLuCBK\n7ig5zpvdsAMVS2tirDXKPPhtX1dEVwmJNwGtPAdJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOgAop6fzl+uegjlEDIooSIWU\nrAQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIsg894ipqG++1RaH0FQKS3QX8Bx2oYON+g+Bqoza9yKAiBpnMvUNmBn\nopo/t0kdmqGbP6/n+h2wDtQuEKqTbyHmpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXkXZg6HXNQ/PxU+ceTWBQDOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM1YWY3NWQtYWVkZC00ODY5LTk2MDgtMTc1MmIwODg3NmQ2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjgzN2E5YmMtYTIxZC00ZTAwLWE0MTctYmUyZjY1ODZi\nMjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExA/Y7dbzcvlqWB1GbvfH02iA\nvZ9iySLXPhgboagKewEEy+MFGcllsLddJwHmc2MAoxyuRyXG5bOiQbFNaCVz2qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqn+glAwwSFIT1D37nmy1pEtQ1eEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA3artdFQRoX7UNHmZUl/DbrVM9Njd\noSZHDdwqZSr5kHMCIQCGTM4xdouUmyHapKCEDfCE8d3549sm4peTr31dcbRszg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4517", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4517` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAYDCZmaNUjJh2mN+3XPDZ6lnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2ZTRkNzkzLTMzZGMtNGIwYS05Y2ZmLTdiMDQzZDM5N2E0MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA0MGFiNzktYjA4\nZi00ZGQ5LWI3YzEtYjhlNmIxZWQ5MzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElDTXZJLN7jkc0x4dwFkn2k1dFVvqQh8lZJXCTsytDcLG5J3TAebV/xthFRPF\nw49OBeIYH+FIerFKilrhzh5uvKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQwb8eC0dT/C7yXOY60IfjjFaeh0wHwYDVR0j\nBBgwFoAUAkz2VWi9JrB1qHXgmWRsMMzMdY8wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgBPCXQnSG\nAaZstXcdk2xiGI6wjqToWCvkTahWXWBHjEECIH40iXtT8RkWFhfZu4Jjg9nLjExt\nRhxhfl2h/PxF4nQo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfpozqZpE+cCiSN5l9LF9sxiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNmU0ZDc5My0zM2RjLTRiMGEtOWNmZi03YjA0M2QzOTdhNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQC7EEbDtbKsFN0DTOZpzu2ZjdelOHdxKrgZR64MkCo/h7V\n8hKvPOGfWAjTWqk83KsejF8OUH55yPDb36BGPy/9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAkz2VWi9JrB1qHXgmWRsMMzM\ndY8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJzBy+d+DZwjHc1r5QvYzdvIVsPWUmGyICGWX74F3+DoAiBs64dXyqIE\nszGRhTzL01qBpmb11of9VCErZDpXii+pfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXbRc1Nj/dkQuGeSPQiwzRMWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA0MGFiNzktYjA4Zi00ZGQ5LWI3YzEtYjhlNmIxZWQ5MzNjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDJkNDBjZGQtYzdhMS00OTllLTk2YmMtOGMwMjZlMjA5\nMTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb8jrO73jJHkejt7s9ebkqOVV\nHRlpCgTGLZlLY6yLMHrzAGrGNDGYP+FU8yJQ4vUQKyxoDyJiTAp4XnmGFczqK6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQwb8eC0dT/C7yXOY60IfjjFaeh0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEApDY36R/SH32itT9w2bXArirgJyiw\n82nH+h8+4coy51ACIAsjCG4OZCRQagjCKhOYqNYSrfwb2SGsAWWguzk94zJZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4518", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4518` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAcc8nlCblcagapPSOGpuMXNaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkNDE5OGU2LTVlODAtNDI0Mi05MWVhLTlmMWYyMGQ3YThjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA1YTI2NGEtZmUw\nYS00YmQxLThiZjktODYyMTc0MzhmZDBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE53bGtKkKct1oXxuYzkEcaZUexLYwieAPMMYzbF3pgHzeWtUnNxX+UraGGsw5\n6ItIDqAdAEIFqFyc6EulE8pBLKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjFIYWal4Z1skrkfbGd0muBpPTJUwHwYDVR0j\nBBgwFoAUGR2ej/Gj2fNQwaiRHflvPsySOoAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMk8eT7U\nr57w7xI3UDY3NYC5hJfcqTHWCnDziiUQiU7XAiAY11hZpZP+JU3is+0RPKT0WIjz\n4i1fm7BDQux30Iacrg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXcZQdpVK84AFloi743A0AjEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDQxOThlNi01ZTgwLTQyNDItOTFlYS05ZjFmMjBkN2E4Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIZ0ZsmEhHQpm1mAboDBW7DhQR5Fn2A1M1Xi4phAmoRpZh\ngw8JLxSayOnDh7Ef+f95aULQppAD5Dno1OHd06tYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGR2ej/Gj2fNQwaiRHflvPsyS\nOoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAORj39X26DKWmZF0c5MXOqoOjMr4h+Mq5kzoWY+eUuHWAiEAmaSfpFLp\nYu5VaekMzP6qUJkBb+Bm5gF83c68fSYZOxQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVEgZw7bhpOFxj1jwBinbklpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA1YTI2NGEtZmUwYS00YmQxLThiZjktODYyMTc0MzhmZDBlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTdhMjliYzAtZTk3Mi00OGFlLWE2ZTYtZGE2YzA0OTAw\nMTIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAO4hN8UcRG1busMPhTKXBO0Y\ndqzH3P1pJp1X4PwBI2jKVGHM/3E/fZRARLJ8n9hcbnmBmcS9EsoT1phAXrCha6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjFIYWal4Z1skrkfbGd0muBpPTJUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAxfndHsVflhhK7yyqf0gg/9No2VjT\ncoaYSPewoG6BUuUCIQDZ5if2PBw2hQSDvX3Mdj4dAF9IJebmgU721Cr+832Z4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4519", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4519` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAXNkAOd06HhWWnrGrA/RT+qyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2NDkwZTNkLTQyMzctNDI2My04ODU3LTM4ZGIyMDJlMTM3YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk1OTg2NTktYzI3\nMi00YzU4LWE5MDMtYzg2YjhiZGY2MTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE44H/TQoAgf38Qz1nxdOvLCq9sr1HhItGcHMl/mbA6M3rgz9+m/Wm9j5bq2IO\n3uRoR8uiMSulCVt+1JMzw0p/9KOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkXJBOFA7ufVnSc3edflhb2Cg8AAwHwYDVR0j\nBBgwFoAUfoXlY4Pxuw+FQB5tHPMOAJL5rHIwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDvBf+n\n+rfsm0CcWctw9ghH+L3iDIHzMcFHECeu06YSigIhAL1a2rrOvwQ3scqjdC0yDQWU\n6T+sOErGoZofMYFpcQBa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYjTchoIq6LtIinb7dLjFsDlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjQ5MGUzZC00MjM3LTQyNjMtODg1Ny0zOGRiMjAyZTEzN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROhrt48jYX+7XKbmHbkv5bY+fvsgffwq7REXCuSyq2DQW3\n7lkGsMolZ4pklY9XP65zBXN11Ji28QKWwXeUE67fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfoXlY4Pxuw+FQB5tHPMOAJL5\nrHIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPg5mA15A/HThNKRZzNNxdikB9vE6Gfl9jT6bZrVLV/vAiEAiS88VdFV\nLlFHOKBH4V2+XF24u3DdxwYuXnWTdzqRVoM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWsb8RLqSsAiLThNGUolgs4CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk1OTg2NTktYzI3Mi00YzU4LWE5MDMtYzg2YjhiZGY2MTE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2VkZmRiMWEtYTA4Mi00ZTBlLWJlOWEtNTc4MzY4NjY5\nY2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsJySieX8fs4B+GUfPROe2JHI\nCqjNV0rCB0y644U5t7AHM2y+CcmPiDKKV4dFo+R/cRbm1PGCUNnkB+61g9XqIKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkXJBOFA7ufVnSc3edflhb2Cg8AAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiATOdf+fbj6t6JsQwscFL3D63M6IPtj\njwaC8MpeTMpB/wIgIkRt2W6mdWyu+O8oLP9rxvKZZNsMyyq52OBSdgect6U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4520", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4520` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAev1PXulgi6q7vOUjRwMY/VuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlMWQ2YjU5LWVhODQtNDNjMy05ODA4LTFkZGFhOTlhMzA4MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE0OTllNDctYmY2\nZS00M2ZmLTg5ZjMtZmQ5ZDEwMDg2M2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw1muTYk2Itykp1N49NCfx4RvKDJ7KI/5xxhOS/tQCqJrAEX+sH6wLlQRoovA\nU7PRENe8iMeNT3EM3t38KJ6SfaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzDYrR1gdTkmfjtHcS6rVseN1ppswHwYDVR0j\nBBgwFoAUF38mjCb/Fz6RGLTYUHl2iaQdDF0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCycXf6QYWtDpGcEYulq2JCjq1qCOA7WkyA7aPK9Ku5cAIhALdvXdJi\ntuUHO4zT+A/D6xc9qOcjVpvF0qEujTvOjSib\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfUA4lBCvSnfQ/DMUFUz3JNnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTFkNmI1OS1lYTg0LTQzYzMtOTgwOC0xZGRhYTk5YTMwODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvqSzwywNbRDj7IPRwLoAwL/T8c4moD51DZQBhpEciN3Cc\nayIwBAY9lAN7/jbzysJn9DASK1IsGV5AQQk8oRJJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF38mjCb/Fz6RGLTYUHl2iaQd\nDF0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFWkAJnL6FwZlUFI5kPwbrTiENdBu1zevQzQ90NZfi6sCIQCjvjzEEZ7Y\nVMZ9URSPCzuYtUbCCW0vGpdKFwyRPeNASg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa1xRg9N77NFGsDxl7Xp+kDsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE0OTllNDctYmY2ZS00M2ZmLTg5ZjMtZmQ5ZDEwMDg2M2U1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDk5NmRlZDItNzViMi00ZTAwLWJkZTktNmJiMmY3ZTQ2\nNjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvu3vMoVQZYJ5DAnmlZ/haai5\nkNMTv8GKNsKnXGDWEFOXuCs/nRX/HXiCRHaLlG52jjHsHVAYiqMRdgo7wnPEMKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzDYrR1gdTkmfjtHcS6rVseN1ppswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBhpcct8p+5QICbsFvuxmMt1eYs8JUr\nXqDytt15FzTKTAIhAKJmnN1LwwDwnc2EJH7wbDLkoHKjXeEMuTZuzVvP+j6i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4521", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4521` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAcs/mVkHeuyTCvwwF2MYTHhOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmMWIxYWMxLWI1MjEtNDYzMC05YzI2LWQyOTAzMTA3YzAzMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWIxM2FiNzUtZTZk\nOC00YmI3LTk4NWItYzYxN2NhYTEyZGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuttZQHjxtcNPXLXrHLDzxx15hKWdIb9wOT5Pe8n7u5FV6eBLx0ytNnyhtww/\njoFFRfhDngf63iy7lXwbhKhnK6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5LirLqTDIivM7pR7ZNKjM1DwmkowHwYDVR0j\nBBgwFoAUjxc05QZCA1eKnMvqIwfKWq1BhM4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIFbjq0Asmrbk6KP46xQsJ2rtwOjEFZmCyPIih5n9f/OMAiBwvbXhTUel\nf/HWJzLz4vl88Q6yOfjAXYEK90Yk68/Xwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASkWex/5ETsFWbL5SjrUJY6LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjFiMWFjMS1iNTIxLTQ2MzAtOWMyNi1kMjkwMzEwN2MwMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoWs3VuzAY5zs3ee4bKIclSzf0e6EeHoIrkrpH8CHnt6ai\ngH/GkZuHbf3CcdBRg1qD4hIui+c0cMkKRNsac+ZKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjxc05QZCA1eKnMvqIwfKWq1B\nhM4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANi7qfGFAu+DGPF59mRl9ht1SfYkx7eLec5GuXcTBTT4AiAwdpssYxkr\nLtjEB3RUi9aQ+SAtFV1iUAw6ZNDFVdCDoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXT42e/TPECQ6VnEs7fx4IuRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWIxM2FiNzUtZTZkOC00YmI3LTk4NWItYzYxN2NhYTEyZGQ1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTA5OGE3ODItN2UzYy00MTFhLWIzYmMtNjRiOWJiMTgw\nMDEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhcWj7HuIsRfZjLYX/hb7MVYz\nBTuEbP0W3hQ0ZCoKHgitoYZYxwVYMKifx1hX6f24gjj6yUzxCsrFupQdTlG9yKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5LirLqTDIivM7pR7ZNKjM1DwmkowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAvsXlyECSDaGE38s05yOaBzOs90A7J\ncERUOCKw7pXFvAIgcF5uSdhjf7Y3gq39Uzyj/sGSKobNX9R4QkY2O8p9oFI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4522", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4522` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAWJDu2VaImKEvjhUMJzVFE93MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlZmFjZDI4LTY3NTEtNGI3Ni04OTY3LTUxOWJmZGRiZTU5MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM4NzIyNGYtZmI3\nOC00YTYwLTgwMzQtMDhhMDdkYzhkNDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWYCckMVhrkzzGA6QDXve9BRuncc3ot7Zz2CIg6q5sGjleG/UZ6p5AnPYly+E\nCgDqz7saOwPB5cFh9Puqe3qUNKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXiWWAzGDau5+IjzPs2rdBSAkEUcwHwYDVR0j\nBBgwFoAU8jnLirZw97w8JwiRHX31fv6ipjMwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIEeWlHMgDn/gPAzHwEFrBJM+sKtD8KHNoBo1H4CZJyobAiA6MtQzngqKYbf9lpwe\nWkUechh8N/uuofI4qC9EtdMG2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXIe4FALvtIaX7fuaHXmf3cTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWZhY2QyOC02NzUxLTRiNzYtODk2Ny01MTliZmRkYmU1OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLoiyH2gIr9vGJ1UDJmP+hWKvV52TYZ96IhfEF5wKmdfi7\nD4nSzJqBMzQUJLwBU5cufFhfb11oiIdh0Kl9KrnTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8jnLirZw97w8JwiRHX31fv6i\npjMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ4148TK6WHscVKZFZa05/ry96g/M7qJXKUmtWo8asPEAiAkl7H4Ge5Q\n/zIoLfARH1BsupXoSVAzdTkwSwHnNZliLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQNbx3Y5wfiNaHzVSNvvNWyTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM4NzIyNGYtZmI3OC00YTYwLTgwMzQtMDhhMDdkYzhkNDE3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2RhYzYzMDYtOGY2Zi00YmQ1LTg1NDktNTRiN2I2MDhj\nNTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBt2BLPYPYQZo53i5+ioBZ5nF\nD7r/GpA5UnIi4D4IdOPEw1Nq5B555wUg2bI9Zdy65Yy9XW8W/3mFtdmUO/DGQqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXiWWAzGDau5+IjzPs2rdBSAkEUcwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAgH1vKUbHLoa+AxQIXcUMSpk+juKt\ngKn8R9IHPEcRnrgCIGSBqmEPSQwzibRkknGJC+qM/GGGX/9+w5YLhyqnMpS6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4523", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4523` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAVZ0fK98Fs7q/wOJN9V03vxPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyMjBmNThlLTFmOTYtNDgzOS1hYmY1LTlmOGQzMTgzZWMzYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ5MDYwYjAtNTlj\nZi00NzMzLTg0MmItY2FmOWYwNjM1YjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERHTlEsVPTxjbnPGuaV9NlZgosPEfPFv2upvL9qOmU5pKfZFbiqwosdgFd0qj\nl9biY6B+alJdIYnswXiBC/LILqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU05oREsItCQtJatw/Y4fW+0tZx+swHwYDVR0j\nBBgwFoAUq02buoseK74MjEJdiOoj8I/vf2cwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIEMiT0sA0VNLfyo511XdBPJAVwd1+HLMT98NwY723iGMAiAe\nukdQFvud+cWOrLDDaw9mtQ//4zP3qNFJimNSY5O8Pw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVytxj4zywJ7+4QyFqDvxq/bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjIwZjU4ZS0xZjk2LTQ4MzktYWJmNS05ZjhkMzE4M2VjM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMBxgTj1YvAYyOqflwTeu3L/qmnMOauCKk5kw3dpu0nojz\n2bGb1lESYsBFtc0TTjkztouKo1eLMOvqPoh9NAuBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq02buoseK74MjEJdiOoj8I/v\nf2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPQn5IRQMq40sdZJ9WbU4+PVEgaV9lUoymHWJl6oQYGAAiEAxStKx2tI\niIeEL46sGKS0USinWRHqDTiLiAG1GOgx1Wg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYZFCqrmAep6iwQQMdowKu5XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ5MDYwYjAtNTljZi00NzMzLTg0MmItY2FmOWYwNjM1YjlkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODJmNGI1YjUtNWRlYi00ODA3LWJmMGMtMjMwMmEyN2Vk\nMmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEh0WXqKX/eJJidBel1clYUNg/\nIfDPZFN+X5J+J3qLEy0unKnwgKJKRzHxpz05YSrQB9rkbYO9STAAEzoiplN3caNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU05oREsItCQtJatw/Y4fW+0tZx+swDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAe3OE+XG+k/KgpVblPkRELAP3BoKxi\ntHSjyUG0R/WMNAIgUDji/t3KsjTVNYb+ggajt2h5kb/s6vuIkUzbERU/3gU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4524", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4524` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAdt0egb0ixM9urtxpJJewb6YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViOGY5M2JhLTMyOTMtNDk3Mi04OWM1LTgyYmEwZjQ4NWM3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY3ZDg1NDUtYzMy\nMC00NjgyLThlMTQtN2Y0MzkyZDEzMzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFVEMSEb87c2tk850qprsnvKeeVpW36wAfhzmEOH9Q/ktiBLm8v6sdxQP8SOn\n1CuP3GRttAwOjbHXcXohyzNq/KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUn+Aum5nwZrwAV5qf+6WKonjftAwHwYDVR0j\nBBgwFoAUM3gBmR50/MBkIw6jP0Z8Yero4+4wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQC8Rf25ynhdO63+ixZzdV57cpt7NEdeYd1Q3fY3+RhNEQIh\nAPboXCm3at+0UV2mOKLDRQ0r/iE0TeSG945zBPpf4Lp/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARpUccqhXGw/gKEzjoV7gw/tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjhmOTNiYS0zMjkzLTQ5NzItODljNS04MmJhMGY0ODVjNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEZgKGKrl2y5ZRoY/ZOzLrXNbv/K/n0KfujFFkPC7oRJGw\ng8JDN0WEk7SmTe3Y9Yt9QtAxnISKoL3i00cZTmkHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM3gBmR50/MBkIw6jP0Z8Yero\n4+4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPfGqryt8Ootz7TNQd7gStqqk0yFVmv3VFVuAXb0z4qoCIQCwrMIdICXi\niSqKVYMOWOLPv4feizo8k8iMzXUOaz7Vyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAboN4ubDpI0UFX3OK0OjKecfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY3ZDg1NDUtYzMyMC00NjgyLThlMTQtN2Y0MzkyZDEzMzE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjA2Mjc3MGQtYjZhNy00NmE1LWIxNmUtZmU3MTlhMjI0\nN2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmuiDhnVlNX0XbXDEAmiBOg0G\nViZLaVeTnKg1VjlLr/vcs0w84R77nWDCKEjJBv02GXInAPI7Sijo2cxqYvF90KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUn+Aum5nwZrwAV5qf+6WKonjftAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiABfQpBvQmOqipuOt5mJp+6USTaPxjL\nVHQ0ZZ1nJzcvxgIgPsmPwfJG9/xzMFba+jQ2xniyBs6QrmdvOjIZuNf28sM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4525", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4525` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAa5i/o3uckpIwQZCP5GpKcDyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViZDA1MjJjLTkyMDgtNGNiNi05ZmY4LTkzYzJlMGQwNGI3ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA5NmQ2ZTEtODAw\nMS00NWQ3LWE5YjgtOTIyNjMwYTE3YWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0znDzc3xkJjxktm+r+DoH+6swMlR4z6rd46zDfJXP/ABx1usbVVF/BivKsst\nj73FJRuZlGZ42/7AqjxsTHRex6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK1TBtlf7t0aohSsrPIp53KQw354wHwYDVR0j\nBBgwFoAU+RZrlQpkyr/cI+UldtAfTON2W9kwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIAffg5z8Ix41\nULFv0GvBZ0uIVFddzVf0Pm0YKs69TtQXAiBi6ToE8jUWVZGUxEDoDZv0EzdnanIm\nS6LP95HCk/BeXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQiCYRTrD4rRiJzEbQJrzhFXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmQwNTIyYy05MjA4LTRjYjYtOWZmOC05M2MyZTBkMDRiN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWnHgWecrxjvJ8P8E4j7+vDoIwAquGZCU1YWE5A5Ea6XV2\nhsIOs0r1CGlnZVpetZxo+It43874Lxd28FRTJOSVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+RZrlQpkyr/cI+UldtAfTON2\nW9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALO2FAEdPlSXxzBl9JYv5t2QncThqQA4DE4P6RkByrUnAiBhcp3xk2Ck\n0weEoWvRyVH6WqlTvsr29b/EtasPSdOmNQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAap6pT+MWq0cGHEmqmuuaqXXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA5NmQ2ZTEtODAwMS00NWQ3LWE5YjgtOTIyNjMwYTE3YWYyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWMyMDY5ZjItM2JiMi00MTgxLWI4MzUtOWQ4MzFlM2E1\nMjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG13dDX7QPvpk790LlOXdExYa\nPfgNO+s/aE7JBp+QnGDkbDUYw4N12JXHht89wee2QUV4J1iErCE/KizdjZYmdqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUK1TBtlf7t0aohSsrPIp53KQw354wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA3yuJxDDSX5d8kk4j2TT83ys78rHz\ntFiJsGGX6+9QdLMCIH68ayXDP5vskYs4gnCr9fOJnF7ooDfxOCE/e/dpNcVb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4526", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4526` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAd3XBU2V5JuHBKowiX/57/XrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NTkwNDZlLWQwZmEtNDM4My05MThkLTQ5ZjRiMTE1NzQ4MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQzOWRlZGUtYjY2\nZC00OWZjLTljMmYtYzNkMzFjYWQyMzc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMY+LAvTEIaHeK5e8gHDk4YdiOQlGnQx9l1ApVPI8xJ5t/JcjnB4FxxwZt8I9\nPRBSj0b3j7ThEbxpbJuQb3s8RqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrhomIsQP9T4QXzIYfRQ30a6iEyMwHwYDVR0j\nBBgwFoAU2Vdea+x9RLYvdpeMaNTYipGgRNswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJ2xaLiGc5JskMhmtaHtfosDMvBwaPaVMYllMUZ9UeNNAiEA8fvZwsjt\nB6PSprbDyliylyXTHly76G2tq0zamD9tlEA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaeCwEJLEh4S4FH/sqJMQYF8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjU5MDQ2ZS1kMGZhLTQzODMtOTE4ZC00OWY0YjExNTc0ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQAOBIMJzzzC2Zr79bkGr0jjrdC0gsQLBwqukf+JWhLLF+\nSVH1VeE9YxucXToNeSeBqCXMrO6sGL29ItMlwZO+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Vdea+x9RLYvdpeMaNTYipGg\nRNswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA7KXM7WfD34xaidh1i0y48g4a6TSIJPzmEFx0XhXME4CIDtCMTDJViEV\n53xU/oftRV2uNZ0GVowue7SCQpi4y1V1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAX/XPeQOmoQbzn+wndGviIN4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQzOWRlZGUtYjY2ZC00OWZjLTljMmYtYzNkMzFjYWQyMzc3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTkxZTIxYWMtMjlhYi00M2FhLWFlZmYtZTM2ZDVlMzIw\nMGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA1NU0zy8BULITVSeBlOiXJ3Q\nWrDa0fbwOxV7DhYVF0xbawKKN+o0RbK+bzwrE8+W30u2nR4mzQrXNK1ET+lfb6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrhomIsQP9T4QXzIYfRQ30a6iEyMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAkE0V1jRCAGv1wQzB2bOldt5AdxP9\nSgc5CaNvGQVpw+ACIQDJaLJgcj5UH68mw/SNVDw+JnHV1CL4u+VIUoZIj09ByQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4527", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4527` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAeM6NaW5uE9oAqt42vTHPXgIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyNDU1OWE3LTkyY2ItNDdhOC05Y2Q4LTg1OWNhOTcxNTBkNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODNkYTQxZTgtMTE2\nMi00MTViLTk2MjQtOTIwOTRiYTE1YWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUzShpdC7gBjSxpDn0d6TiJF0LVvFM9lr+aoQMxCL8MfCibMlef+AM/Jp9RT3\nmJPEMcdEPn7LV++L+dJ81x4oR6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFRk1ebqCE/0SkyFmEdHbszCwDbswHwYDVR0j\nBBgwFoAUOlZly31OjpjTe6vaNKT2YsRx91swNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKxOfjRUJv+x2gZW0C4LL1gV+wFWzOZKyuLDbKLooF3rAiBL3oKXvCtM\nBXiXNEqCfJcWx8/fRGV6WDTFXgOW4ov1Fw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARnuZV/Wx/3ssqGbq2K3LD0dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjQ1NTlhNy05MmNiLTQ3YTgtOWNkOC04NTljYTk3MTUwZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2sM8IYf6E9ZgDkTKEy+lzHe08JiXU2vdqXL6fx4+/0S8G\n0g5CVeLD9BPV7SRKnxW2FLxURqtpSSXW8TlnN+9Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOlZly31OjpjTe6vaNKT2YsRx\n91swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMZRkf4un2AnFxnox6j36eOPN/iffI2Bm2e1eWInsG94CIQCymPHj1v9L\ngokG1rrFg+q5xAje7e3a/Sj09WnHrzRgBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISATxYhhRd9N8Kt6AhHs7fHoh7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODNkYTQxZTgtMTE2Mi00MTViLTk2MjQtOTIwOTRiYTE1YWU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzgzOTBkYTUtYThiZC00ZjEyLThhNTktYTlmMjc1Y2Qz\nOGY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqyon9H6tKKwnZH/fgPduCpvr\nA6rmCeyTmGi44H1Dtw8oAMgm99QfngPF534HgtjppL5dEf5b8g0tf/WYTaOBT6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFRk1ebqCE/0SkyFmEdHbszCwDbswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA9bZ7suamgP2OUMSsUaFA2dgQQiA6\nAT2FQNqs1OGHzVcCIQCxKuV/rrwBAcPy3/L12CsrN6CSMuEW7leUKG8BO54asQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4528", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4528` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAXum8kOtOgdB8trRVOzvkKBsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExYzIzMjlmLThlMTQtNDM2Yi1hMDMxLTg0ZTlmMGFiMzE3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ5ZGE4NWYtNDc5\nNS00NTQ4LTliMTgtZmUxMDE3M2E3YjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEimEnNqNh9xJT1hASLq1RXDdHCkeOgfI0bJjj2eAPKDRScm2jMdScS7DcJuBe\ni6VSYR+CrzkthbmYrENznxTAzKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU89FLpsPnWG0htyhW4sqq4eOX6qAwHwYDVR0j\nBBgwFoAUUjwY2zkdHHlXeoULZzBI2rOG6MowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQD1OSotQeEBjABAtQpR4XpEHdMAiBc+a7Ufspy7aNxudgIgH+tIJnEA\ns5bAGjZ9XiQGkRqyB/A6d6ejbUPgY1IDD6M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc2SSKNsNXAVsTw4fxitWHsGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWMyMzI5Zi04ZTE0LTQzNmItYTAzMS04NGU5ZjBhYjMxNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5whOMy9pV/pPPrOKjwJZ4LZJFpmIms9DbVFsxD4sSlUGz\n6hq5xl01sFEjxPlY9GZfh0Cap8VsPwBj6YVuEMhKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUjwY2zkdHHlXeoULZzBI2rOG\n6MowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPUdfmHeAOJbZlcRprqzBtywVaIjkJ2t4YNdyDBZ21iPAiAm8RlUpQLW\nMcokbFFGImliPZ8U/Ury14AZ+cCtZs5I+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYwWg9Uze9FeTwtcjYtX47scMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ5ZGE4NWYtNDc5NS00NTQ4LTliMTgtZmUxMDE3M2E3YjcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmJhZjY1ZjEtNDUzMi00NWE1LWFlZGItNDc0OWE2MGUz\nYjM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETX8GW2Jo702VLp+eIDwmZgrO\nisYJQ0TLS6x2PgtluPX181dYJKHJm1uhE5Kw4/CjZd7Z/aFl7J5Oc4hVNC+B0aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU89FLpsPnWG0htyhW4sqq4eOX6qAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBkY0Qm1GCsVqu11OCQD5cGS1cJ4Fx7\n+KTfWJjOM8g53gIhAOaXZjXly9T1sS2NKB0fm3noC9Jvgw/+cwSXpv4Hqb8w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4529", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4529` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAfdhXR3WiGDzjCoxWAEq3VTvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlMjhiNGYwLWY5NTAtNDdlNS04MmQzLTlmMDE1ZDg1NmJjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZmMzliOGUtNTdh\nYi00NzNjLThmMjItNzBjMzNlM2VjMGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI0wZzRz2o/Lg+0Pg5xnCzbQkhBtXHqmRSf/vRfiKWEVm+tn+Ek/dhoZs0t4B\nNa49xjiZrt6/SOKQanHJVCPUGKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWRSwAse5hSL+48iZddmjMvqRTkgwHwYDVR0j\nBBgwFoAUOWpvAT5hnxXz5zKM+TfBHDNEiF8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDHgEGQec4faXSoZbNf9gJekwr4/C0i6JejccvM\nZRuHHQIhAJxyYLE67HJHyKWiwaNWb37JqGg5F5uSsqnjvf/PpLFs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW6vTqVe6FNtk/fSpZB13F1AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTI4YjRmMC1mOTUwLTQ3ZTUtODJkMy05ZjAxNWQ4NTZiY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwMysqhOtEmM5u8kIey0igLUqTNZ9LCYDAavQ5ECSouNNu\nKlEAcvOn9mx4ATfxyGpHi1RQvIRHxShm0qc61nYLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOWpvAT5hnxXz5zKM+TfBHDNE\niF8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSY3HDqCzu7eDZd816L4BbkKDUKUQp1uftMeS7BG1WOUCIGMLGLTWPWzL\nSzqhnNo+zTRVBF2HlHB2tEf9An+d3fYY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAY9KnDmTFSW9LlthUOCEo8cdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZmMzliOGUtNTdhYi00NzNjLThmMjItNzBjMzNlM2VjMGFhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDdmN2U4YmYtZGViYi00NTFjLThlOTEtYjJmMzc5MDhm\nYTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYcgWse5gHE6xJCULZNRqOgt3\nOu3W11/K6DkMewtTVkRYLuf9QG4jHD61/L9MunmgoiP4eCJcq7KlFyGarjIvVaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWRSwAse5hSL+48iZddmjMvqRTkgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEApctjrzQYgjM/gcjD0t59i1Hw9gNs\nrU4A19ESsWKPQ6oCIQCUVFfFlTdFucV2WuroEBAYxAD5JvESmiJ3Cv/cygbrtQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4530", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4530` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAdQ/fPMthLZ8NQHZtxieEme8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2ZmY0Y2UwLWU3ZjYtNDRjOS04OTI4LWY0YjQwMzgzMDdmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTliMTQzOGItM2Y1\nNS00ZDU2LWI3OWYtMGU5OTliMjU3ZWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAn2BhnFcRy2aAztnoJvC0aXTEfXjbAwkN0ApkSDJ/paobgNHP/rfto4JH9/f\nzcgbwno2M7BVTyHE82wK7Gn+z6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8tyGX/LlM013siZ+HO0yIALbSkUwHwYDVR0j\nBBgwFoAUg4bGSxr24Z5pIQowwoV/E6v3OlgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDSz0RzlAIpZCc3yDPuecvmSbdam7nzAXtrrFiS\nONhGJgIgXJVvC6lCE8RPQf7ke6DpQbLFYRfJ/y1Gn4whl8ljWXM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe9RSjex/Dv65Z8ofrtnh78WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmZmNGNlMC1lN2Y2LTQ0YzktODkyOC1mNGI0MDM4MzA3ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsbqZ0UDUJTwhluJc9PL/Vk2tVaeYVBdjC1pHWuokFpvEU\nep++BO0hHEYANbPytCmpJ9+nSw+djHlNDHAtOcBAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg4bGSxr24Z5pIQowwoV/E6v3\nOlgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPtHgN5W689pPRBCIfiUcgYfK27mWTej1iHhZICdWzMUCIQD3sQ+0Vr57\nh/hTaZbZ4hPZgMkQsup2nqHh/AyhQ0oRyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXroyrNFQt72lb//TzEfQXjnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTliMTQzOGItM2Y1NS00ZDU2LWI3OWYtMGU5OTliMjU3ZWFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODFjYjY1YjItMzVmMy00OTllLWIyZWUtYzFmOGY0ZGYw\nYzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFcdaC7ePRchMlygtrJZYhogd\nlZOP3009iToC9K+6Iq5caV3fVZ8fkiamQcpDAPP5oHArzfKUqADa9nzsG3+IQKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8tyGX/LlM013siZ+HO0yIALbSkUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAMtah6ww+mI84WdXHYJaBWLHcy6UTP\nrbAOo86aYd340gIhAMZhxiFQp0t1UUiN2yUR9xFqaRPK+5HqNw3spXEIMAkC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4531", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4531` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAU2kWSUD1IMlfx/ZV9ChVBhtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViZTY4NzE1LWZkNDItNDFiZi1iZjQ5LTc2ODE4MjM4NGFmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIxZjUxZTctNTg0\nNS00Zjk2LTliZDEtYWQ5YTMzMTYzNmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZGTMobtYjbD9G5U2l/bCT8enptRS2QG3tPKUX3k1yFF8/9SW+AUuT8F2t1un\nnnH42YjGwmHjvd2U3FtkjWTD5qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU5KGBH09OsJAxLaLpxejuLBFXigwHwYDVR0j\nBBgwFoAU/HGt0M6gGL4UHHKeh5rjucodikIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQC0Xm5hVppeETWBY7fqZ8wBawAHY6w0kimt1lX2lrRXmgIg\nf7cboq+IvloxCLUoSJCGDzI3eY/sMeM4BOP3MqUnBfU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAetmp0q28k096RB8AuBtTCfDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmU2ODcxNS1mZDQyLTQxYmYtYmY0OS03NjgxODIzODRhZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsDpY27GYX2N4++hqboqM0KCkk/9L2YH8KBCVZRrtdfp1B\niYw9XN2zYvgBbG7UdQnq1/FbWia5AtjEdFRMq2nNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/HGt0M6gGL4UHHKeh5rjucod\nikIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALu2a2KYNKDPk+tUQ8wPLUaDCMbimlgyxPGC1oBCltC5AiBFo3iiyBY4\nkNd6pswett/j5bK6fa66fMkH/ayXb5Fryg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAR2oRHb5Ww2m7CtRfjaA2o9sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIxZjUxZTctNTg0NS00Zjk2LTliZDEtYWQ5YTMzMTYzNmZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGM2ZGM3MTktMDVlNC00ZjE2LWE3ZDEtMThmMTJhZjk1\nNWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiGMy/tpietNpIEOoxvNRFOp/\nXAO0cCpHHfl6DXMd4/Jzp9CYfjqnsjHnIH9Enb3M8pa8Z+Cb6u3MZiQbsjmJgKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU5KGBH09OsJAxLaLpxejuLBFXigwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAmXlfBhguXbYKeNTKSUq0xlFdAS0U\nSNsrB/wUicOtemACIDynhRHQv5hMT7J0bWhTUtMR2yhxeGOV8riSvXhSfFnp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4532", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4532` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAf6jCvXPnEF6ryahOO+opPyOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0ODM5NDhjLTdhYjItNGIzOC05MjZkLWE0Y2Y5NTQ5ZmVhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI4MTNlNWItYjA5\nOC00MjMxLWFkNzUtYzY5ZGI0YmNhOTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwA67I8BKFDF6/iw6H5XLLsEsXlJaOAmEnaGV6WcHaGn3eCp/oOAjQ+asXHyu\nR0cMyxDNUMlGeKaamMEt0pnqdqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgCiPJuUnc1pfi7wDs1SGXd0JWAUwHwYDVR0j\nBBgwFoAUpt9Kel8SdcBjU/NsuiX4VQIMXaQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCID8U9jaV95mRUGJU5pyiz4ltRMoBMokN\ny58BFp3XAN7EAiBxaZK+99yn1WzjneEt4sLnLPtYcQw2PAMYCRXQnOHsHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX1lVo9+GMbb1zhzEqGDAXbkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDgzOTQ4Yy03YWIyLTRiMzgtOTI2ZC1hNGNmOTU0OWZlYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSz6u4+a1mqdVZGimhxNlXuwiV099/wrneKITwQqKfaFLf\nNXbCFgicZudIj/jgwuDWBcBVuE/giP6GNmLD+gPto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpt9Kel8SdcBjU/NsuiX4VQIM\nXaQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKajaQkrPnnyWcwcVZoFtgFHzkdaF1NVJDfiXUT9F2qrAiEAyOvmfz93\nqxBVMRbcEcRtk0fohnv3yxzoQYT32VzVJ3s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAX/XcXLOPbPU4gGsA4LEwkp8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI4MTNlNWItYjA5OC00MjMxLWFkNzUtYzY5ZGI0YmNhOTViMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNThkNDMyMGYtNTAyYi00YmVkLTg0NGYtN2NmNjhlMmUw\nNTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE61Y0lHmPRcOpbnONt5oN+ba1\n6LwOn7wLcY448ystUrqjQ8+fTOvSawJeLcbL1NMpdXjsuWwWtadb7aPHmIy+M6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgCiPJuUnc1pfi7wDs1SGXd0JWAUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBbXyZGXED9T64TaHzUTDTXPHUY/GBx\nst3C25p7fWUdnQIgKHxwtRnEEyjoicf0dpI5rUzY+UDNLXVq0ppfSu5/mXo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4533", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4533` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAWfhiCIuvoBMgzajUXGR2jMUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNDQ2ODc3LWQwZGMtNGE2Zi1hMDM4LWJhMTg3Y2MzMDMzYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWVlZmU4N2UtYWI5\nMC00MDM3LWI4ZjctNjAxOWFkMTIwOTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEylQTnkzWy4HsM87hwY6UFZeX63cHKAtXkA8CGWALOpMZFT1o93RhVFnG4UAq\nrYqpFMzIDemsG/NtnaKV72HKeKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8XaD0HJMvz2nzncbb+LLV8yB7eQwHwYDVR0j\nBBgwFoAUuVMRi4Hu9lTPxeLS41uyIB7uSbkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIHm98ygBkkPRTAeCmSRfSDqUkiwkIOBP\nw4OHMj0SbJOnAiA1iV5nKCO2fHAYLP6roQrfwBF0zNKfTxvoZ3y4q1Nsjg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATdw9CsulQlOhifWK7jGX7gfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjQ0Njg3Ny1kMGRjLTRhNmYtYTAzOC1iYTE4N2NjMzAzM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuehrN00nag2UF6QLFAaFmR4EzFW83u4tXh+I1gVVcPqXw\nC+VsYI1iBX5gpYJ05AQsUNC1AUWIKKAAvHp/U6/0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuVMRi4Hu9lTPxeLS41uyIB7u\nSbkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaA1h9qMcjbxs5vwvyaa/QInRHbJ0yFRLx/StyPQbBmICIFUFMpumkr8u\n6ueHUSK0PUbmZHOhrIVkHtwbBupmliPA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARS2wbUbLSyeSPPHyaQZrvqwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWVlZmU4N2UtYWI5MC00MDM3LWI4ZjctNjAxOWFkMTIwOTI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDA4YzhjZDMtOTE1ZS00N2M4LWExNzctMTI2YTkwNmMy\nOThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQItmubanz0FG63UbQsNZner2\nIkDif2FPxUsCv7FRn+XTGfQN48BixZnJqixs6SvVrOsQ8UavhpKZWx9xibaMBqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8XaD0HJMvz2nzncbb+LLV8yB7eQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA8r7bZWcm4eG7G4DUH2/naqNmdSWw\nRHUu5/W5qoEU5roCIAm+bSbfpTffwOD05KZppOUinCFqbDsObYCbALCqlQIs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4534", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4534` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAW76guMWwcFdfqwJdNWGO8v6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5N2QyNGJiLWZjMjEtNGQ3MS1iY2M1LTE1ZmM0NGVmMjNkYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDc5ZGY5MTMtNzM4\nYS00YmEzLWJiYmEtYTE2NjM3MmE1MjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB/DOnn+5cRvnw8eX9udtCONsrGkvSA4EKnDLeOc21vAniuUEkHGEqY+J68+y\nGqK0BS5bZrR55kBXl3rDYWadgaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbjLOtLOTBMCaflT5y4/0QTgCszgwHwYDVR0j\nBBgwFoAURDSml9nmmOJhKafKkog9OJxSzAcwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBv9Cc/f+8Du\nLl2ohTgb/KHXWvoKSpvXM4zf8yCmboiFAiEAzXGLUv0I9bjfZlVh0lSFpTU+s1xW\n5+2OT6/g2+vtzcA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfLBSDReq5nbRb4PtxRxSNgAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTdkMjRiYi1mYzIxLTRkNzEtYmNjNS0xNWZjNDRlZjIzZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNSVKBHIG5ef7TaacE4jfL8T3wq+tsuodbVxQyZldGlsiC\nkoP6ycE4pcu8R3oLgX2n77vVX18LcVvYKkIP3FS8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURDSml9nmmOJhKafKkog9OJxS\nzAcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAIavJRhUx0oz2LaUOenwXA6O7i7QNwoBftnto3iEcrICIQCMNuCqLYNE\nFfM142m9yxVUalUCqi7Y/7N4it3vUwfdQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAREv/1x5kbsLgXILibTOPlMjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDc5ZGY5MTMtNzM4YS00YmEzLWJiYmEtYTE2NjM3MmE1MjUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODUzMDc3ZDctOWM5Zi00M2NiLTgzM2QtNjI2MmI2M2Jk\nZmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMJABFHLTw+PI8u8xkqWAKxV6\nTwJqtiIqoIqym/vFT6A9Ph+taPHczv4vRgYShFnAOfrf38VtpdPwcNkoEeqoSqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbjLOtLOTBMCaflT5y4/0QTgCszgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAy76SNABRNBiKlffQeBaaD8x+s6ODD\n3gfHeWnDgXpNhgIgcG5I7HLIsdckWTsMqAkrEyoC46wDurg2Bxrx1qTGKWg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4535", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4535` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISASGz+5whVocwk3qVzDmnnfvDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3ZjRjNWJiLWI3ODItNGM4MS1hNjk2LTIyNzEwNzNiYzk1YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE3NzNkM2YtMmIw\nOC00MzE1LWFmMmQtNjA2YzU4MDBjODIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXoqRuWXvgg8ZS+dKpvAQYcI8ai9GKFAHGM7KaQJ/niL8h/SLuXdGdxofS3fy\n9iX0Am3mo//VnZYw7T/Q7oDvr6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURRxIAEYXK6tWr5GCt0TWsNSzZxcwHwYDVR0j\nBBgwFoAUE1CghRxJqGBI6USjVcefdZp+VecwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgKZ+80eDiaM9XRv5uybp9Vqz3E2Mol/SyUN5j3GMVI3gCIDgrSnFpVEbF\nmU4n48R7OQXEwSCAzNQYCGugvrJMQ4t5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATgOSvpjsqYWKxLOfX1nFV6PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2Y0YzViYi1iNzgyLTRjODEtYTY5Ni0yMjcxMDczYmM5NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpHF4M8GOU+2Ge4NwJZw3GmEjB24fiUCdS9OVKu1Qkndaa\n6T6X5zBJOeBrjdPqH97lZY1B+80L1Il0SSNKTS0uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE1CghRxJqGBI6USjVcefdZp+\nVecwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVHy5O+pm3kqOpoxS0u6b61dimLiZwKtOv7vyrYLXD28CIAJ/S0kH4gtC\nEB7qCPyuBKKfidYNjyf+qwDqKeUM6aip\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcj5gM9QpwGk0klScLQw4UTUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE3NzNkM2YtMmIwOC00MzE1LWFmMmQtNjA2YzU4MDBjODIxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGM3NmIyNzMtNDBmYS00MGRmLWI3MzEtOTBlYzdhYmI1\nZGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDEhfqfrnWTcy0qfnnrUYDSlh\nynUns1oavSNVCQ8DNc/Nicd+zAwWZ9x0p6ZLIhjQ5NWXysdR9rm5Niko3+zPY6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURRxIAEYXK6tWr5GCt0TWsNSzZxcwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAnFqpFVAmx0PPUySdhK0Mkv8d7u0c\no1k9V8sNt8aQWBUCIQC8DD4UNemBCVQovSdADxKsmH/i+pLfCKXYxWl5NgJUcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4536", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4536` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATKG77hxZaeZmbqPuej2++OZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyYWMzYTMwLWVmOGUtNGNhNS04NGVmLTBhZWFjZDYwOWY5ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIyOWFjY2QtMmEx\nMC00YjhlLWFiZTAtZjc1Y2NhZTc4MDIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzbJyKfqLeWV49qvKifuqGkc5Gl+EIM0i8kj9qRSKa1ueulBxWI4akKxkouE1\nfTAuQdvMGkJij0zQxSjxUhxOvqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxLc0aiZD22EMYoLMZMWANjeBA9EwHwYDVR0j\nBBgwFoAUhRQu6ORX6RCljg6Z8Cydy8PkKrswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAP6skX21bgRVM9r0FFv1gScUmPIbkt9LfUs2n8s3levXAiBDFkl/gc6/\ntyQvka2VoIyykvAA6rNuKqHuSAr+1zO+mw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9zaXYjK0x35GVdil5nz/68MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmFjM2EzMC1lZjhlLTRjYTUtODRlZi0wYWVhY2Q2MDlmOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMWoTM2iuXZ1kYy27dyvfEbaV1/Z/3LFi54T+l/ruW4c3l\n3oG45lN+aSrhWBmoYRRWoV3OxaTDQlbcePViq/EPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhRQu6ORX6RCljg6Z8Cydy8Pk\nKrswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIxz8BH1re15NHjkPbKkANaQdWTbhFUXWmiSXvR3ZwVJAiBTOX5LX/ul\nsiP9HOTQlCHmxmvF8KBqEs5O0fmJnwz9VQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVLRD4xRNGsm0E2taGB2Ujd4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIyOWFjY2QtMmExMC00YjhlLWFiZTAtZjc1Y2NhZTc4MDIyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjEyOGZiNWItMjhkMi00MDA1LTkxZDAtMTI5N2M0MTIx\nMzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkpTnQhSx652hrblqAs6W0ILd\nAWOv00l6mTLnhBGHx7Sm0Sb/rUN5pVKpvXL2oCTEN7KcDcmBd6w1qFrZbmm0a6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxLc0aiZD22EMYoLMZMWANjeBA9EwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA3W/biEPmCODQXOAWk5fdcXNLf+0V\nfWoQptX2z1jbD9sCIQC2gISMMoJjGkkbhQdMFlU9AgzmlvuJGZg0snhG0eJvYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4537", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4537` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAV6YSe1gNrceXQ7kiku2o3phMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2M2Q3NDg4LTlmMTgtNDI1NC05OGNkLTgwNGJlNmVhOWM5ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ4MzRmZWEtZDc2\nMC00YTgxLTg0Y2ItNDY1ZWUwMjgwYjBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELUtR09jnNvUQmpjOd1lMHM/+6xhv0RGx7ZXM9vq+ZKSzv/MkydC0oIDMTjLS\nAqlqmNT1ZsoVkHrpMAokJYXQ06OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhglT/1H8wGRXV8Jl13fsIhkjOw8wHwYDVR0j\nBBgwFoAUJSrSfwj4WMnC+TBz6WEBrHMfb2cwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCD6F6byqO7gdpvyitlrERU78EMI2f6vij45VKeViPjMgIgA95+Cmzs\nuw+yG8kLjD7Q+MJiV/dB1ctLnpjfY4y/vpE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfVS+HqJWmyhM/wzUWBxPBUMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjNkNzQ4OC05ZjE4LTQyNTQtOThjZC04MDRiZTZlYTljOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5kQfovqcTPBLc7rsdJDRV4BAY736vIL+wDwr42UPIhRia\nUi3Dpb+uyE0fs9zUUW5FXIrQ6BfdoAaZUiFGTCX+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJSrSfwj4WMnC+TBz6WEBrHMf\nb2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKo0V+Rmx4zGbYmQTc6l2ixuURH5f4VzUWFIzlFF6OEcAiABf4VoKo60\nb3vSibDI129AORKo9HelAoRC/a/kTXrVaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAd6tIJCg392Rtf+kJJIfEZjJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ4MzRmZWEtZDc2MC00YTgxLTg0Y2ItNDY1ZWUwMjgwYjBmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2JhYzI2N2MtOGMzNS00YjZkLTlmNTQtY2ZmMjBhOGIx\nYmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA3arlRkWLPGF7xepgjgQiljG\nHaqcd7pHS5x0Mg4T8hdU0X8sDH5etDMIU+FjLy64QI/Mzpmuypm57tlcq/M0cqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhglT/1H8wGRXV8Jl13fsIhkjOw8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA2RAIKbmwf9RD82jQNFxq7in2EJjb\nNjo5rTfL/k+jJssCIGXsvgzmC8AfOJEFTiwzgJCY2ot3KEmqgUXl30/czPSa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4538", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4538` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAU8LSyeOrcCa/++lC4ohfEC0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllYjFmMjk4LWEwMmItNGM4ZC1hYzJhLTIzODM2OGFjZmNjZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVjMjFhZDAtNzg3\nMi00YWFhLTlmNmEtNGIzZmY2NjdkOTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhT449/BX9B1ihgPuArRVIQd+r/qh23x/U15dDJpUGNafgxvjJqFeRXEggZcg\ncgQ9cEJsg5X0azM7KGH8kZwpDKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqOkSQRpJ4dQGIMpZgz9Pw2sEEJwwHwYDVR0j\nBBgwFoAUfzV+oZO/HeqySRPClAjvg+r5LcowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDcIVvxhS51qj0Zeu7jfBxjKJ+VIGFI1PundZ8S\nT97w1gIhAKPaiaNyb/tE56I150cE4Bb8321ETtS2UEkTQ04Rk0T+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeyNxWvlnPHYSGiM/7XpI5RGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWIxZjI5OC1hMDJiLTRjOGQtYWMyYS0yMzgzNjhhY2ZjY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASM3lgwvhz+slUqvda7YQtaQ3CQekXL0TJOwi+uV2mXhwSq\n19G/+10sMvLiFZxuO7epAgSQOeTpAC8aLZkYaT3Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfzV+oZO/HeqySRPClAjvg+r5\nLcowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOBX+2WjmXuo98nJXSkU4m/sEwQ/dKdobBX0eoormN//AiEAmmCDLvUR\n2RkU/O1jfyBj6KO2qBufNFOK4zoUKxG/d3U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeC2qDTupg67Y2/RKYrJP7s3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVjMjFhZDAtNzg3Mi00YWFhLTlmNmEtNGIzZmY2NjdkOTgyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTNhNmJlOGItZDUzZi00ZGYzLThmZDYtY2JhOWYwNTk3\nNTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoS281yLDCDAdSY+p6HbUPGkQ\n0u2NoON7/95saoVk73Aa/Cx9JLEcnecr6PCMbaPoNMdgZovC6DA25+Dto2/0HqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqOkSQRpJ4dQGIMpZgz9Pw2sEEJwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA/TWyE4AGG3C5sDaLJM0IudEgLEmz\ne6xVOji65n+OE3ICIQCBc0W/Wd9laFHgSHYshvPLogcfFI3y6+MlpDvfXpzU3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4539", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4539` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAZGlHn9zfX3hR0fGz5sR3cRsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NDE1NTBkLWE0NDUtNGU1NS1hOWE1LTlmODE0YTJjMzI5ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU4NjEyYTMtZDZj\nZS00ZjkyLWI1OTAtYjVlNmQ2YTVhMTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzREcVnoGdRFurXDTAJIEaHql6EQIeL+qPgctoxcUJ7Rh4lkZNJn/ZMvquSfn\nlRgrdeoYUjqtACuxv7eY1KB55KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+HpfuJN78byOZchzwv2xbRgyFVYwHwYDVR0j\nBBgwFoAUq09oTuTfUmGppKPOboEdRD9ObrgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIGaE51SPNUHN/X8d6SIAyt77hf5gflXVjsjRvl8J\nljaYAiAertyZxHcfdDnHFMGUEh46geKuSyTC1nDL65xOwymp9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZMnIPRvDdvRKOUidOmVMIjjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzQxNTUwZC1hNDQ1LTRlNTUtYTlhNS05ZjgxNGEyYzMyOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtHkjlrYplhZSBY5Jig8ERp5GDWd9ptT8KMBq6VRH84V7r\nGvigMmN7bbkW7QFEpqa85dRZx+aWsgSaiTTf/Hloo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq09oTuTfUmGppKPOboEdRD9O\nbrgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaefAQgPL4LMFf5g7iVGkDMYWqLvJf9FclvmNaf1mp2oCIQDscixhnvcJ\np8fUGABR3bPUxTae2Z79k+9xBOEDYrtLrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAeOa1vEx0zIojLHJ8bTKW2P3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU4NjEyYTMtZDZjZS00ZjkyLWI1OTAtYjVlNmQ2YTVhMTRlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjI2NGM5ZmItOGUxNy00ZDAzLWFiZmMtMDI4YTVlZDU4\nOTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpsCLEoI8eG2IAIYB2h7qENTT\n/C0+DjJ+aBJHchcWYWY3ho12e2tX6Q6W+tIq6dndAfiwpGc/tVhqb30lNOZB8qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+HpfuJN78byOZchzwv2xbRgyFVYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB0QEBK1ZGX5omsWSOzEmTnM6J/G5P+\nspuk29MYAgqetwIgJ7sT/tuSCLSZ5PshcPeKcc5filSab3aTPTe6ySfaI1c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4540", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4540` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAaM+Xpwa4z315B1aVr0Nbmm3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NjNjN2FiLWU2MzAtNDgzZC1iZjIzLWVjZjFhODI1MGUxYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjg4NGYzMDMtNzU4\nOC00OTI1LWI2NzktYzAwYjM0ZGQ2NWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIxJa0RbTitqqydZSQWaF8T3IegsjetFDdDNJQH/KgQC0XeuJjbMhxPQRVFAF\n/Jbk9qUiAJzHi0OssYQ7cCps7qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE/J7R8MwOakC8AWOfYwLWU2tG60wHwYDVR0j\nBBgwFoAUSmb9FGN3JQ9dp9+UWRXozApqaMkwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIG1ZtkPzZ5Yfl14S4IkyKpkxUEq+nrdr/MyXcrBsOj7rAiB4\nPWzK2hcJTj9+i8xq/LVh2Jq2szCnqwY61JkRo5fMMg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYjUhIHtFNSNxCbnpe9tgVoZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjYzYzdhYi1lNjMwLTQ4M2QtYmYyMy1lY2YxYTgyNTBlMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASb+DpYIF3MOAjhpZ4/vZO4n6FwpqkchujJS/kUVwwpSbG/\ngNidpofR/zF7Aew/PFB76O/5o+TvtDTpmyV53Tcco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSmb9FGN3JQ9dp9+UWRXozApq\naMkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALKLjXS+JfXk3mgod3rbIVJIPV/r7dML8gaXviysvtm5AiAyN5uHxTpi\nRwxB6/Iw84yZBjVcs2a9oALLNVEVsyZDlQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAet9ZhBVOJb6k/f2jBc1UI6SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjg4NGYzMDMtNzU4OC00OTI1LWI2NzktYzAwYjM0ZGQ2NWI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjE1ZGVjOTAtYzkzOC00OTFiLWI1YTctZTI0ZTNjNjll\nZmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEklhB+uv2yjlwzl8FCyzTg5si\ngbrMXsItrnq8JOcDpBer+qwa+0i7ljHQ5AAq3BojtPTlEsptFT9Vvvq8YAcH+6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE/J7R8MwOakC8AWOfYwLWU2tG60wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBDaC8BOvcQSJPMCS7wY0STpgCcdMap\n/BTnAfyhyyu0XQIhAKyLSyS/z4TUvH/W9dxrEffQu1AT5MJj/01OwcdSOrbM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4541", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4541` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUMZIeVtgFXHlmM6g4tvWQbCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzMTZmMmQwLTQ3MzUtNGZkYS05OTI1LWQ5ODFlMzkwMWM1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTVmY2VkYzEtYzUy\nNC00NTRmLTkxYmMtZTUzNWJlODYyYmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWUtWmIbTjz8uiNlmGQM+QSSTE5byNcAMburu7H/QmAfZeivKxgkrKvm75Gjp\nHxWd5Kv0+81L2dBZkwffVnRdXKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/azEg7dJP8ogQMYPZf+eEJLtH4owHwYDVR0j\nBBgwFoAUrEE/+HA2P+c4cq81rERMNi0uQ38wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC/dNcLse3GaclnBGoa117fQmZHFtyP\nppNBy1ZmBNsWDwIgeZOolINBNxp7wnTm1kw2EXndlKMf8CBs7eb2UdFvmp8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfhlTE5G4Z17N6Ko5mq9AATgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzE2ZjJkMC00NzM1LTRmZGEtOTkyNS1kOTgxZTM5MDFjNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8BbB4waync2HlFMXHuN4cLe7Jeo4k+vW5pI4sPpb0bxH3\ngTV5YqmdUpcf+21GUzLq/HPpAYKGA0nMj0+2QKTOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrEE/+HA2P+c4cq81rERMNi0u\nQ38wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCJykwGw4anSbIaLArXLbWefgRSsCT4i/TQPa3/bfyewCIQCAf/LPl2V1\nmrkyskD42ErRgeTNyITswF2upkR1kIN2QQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYn3FYX1NW4/iVZ0iNKvHRrWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTVmY2VkYzEtYzUyNC00NTRmLTkxYmMtZTUzNWJlODYyYmU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDBhOTYwMmQtN2ZhYy00NzIxLTlmOTYtNDUzNmUwMzQ4\nNjE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPIiJQsMqacasB0UNRsRDQWPO\nMhZ1YAJciv6EvEqxW4aJJgVUXPi/5jyTUrq79I3d6/v1l35TDQZ0p6RvGcG1DaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/azEg7dJP8ogQMYPZf+eEJLtH4owDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAgAW0bCB5D2n3xKbzzSMcJf6uaB5D\n9lMSgo2AtW9pCH0CIDnAC7fsUkURr2LEzwOHWU0UgsC/8nimFeNfg8arlcV5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4542", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4542` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAUQTsF6tsyxlJ1zZYiCH+QWJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ZmMxYmMyLTc4NmYtNDg5Ni1hYzM4LTg1NWRjMTE1NThjMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFiZDI3YTktZGE1\nNi00ZTUyLThiNTQtYTliNDY3ODc0Y2ZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExaJkNb4fjyxlDRmi35t2XuzNrM3cXhN9wDIc7UYKeAvm6lWI4cJcTM3DoOI5\nR/ywllwHGK5ng8vbyN4FuIZ0y6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUofhinF3ZNJIaMd2+R84HhyJ1XjUwHwYDVR0j\nBBgwFoAUNTNIElwUV6/pvUwNcO6YIml20RswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD6QTCvz9dzHva+GEGR4jX0EbCS9x8V\nw57+lWRFTldqJgIhAISeAymbS19zgJ0h+dxX0N9YvTCrFcgbg2UIbr25Twsx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAakTSnKe4bza7OWlC5nfKJIGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWZjMWJjMi03ODZmLTQ4OTYtYWMzOC04NTVkYzExNTU4YzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvWNss6kvyj5uCph+nqqCbbeXE8kpoF4462ll29gLvV4rP\nTCA8nkTi0CxHj84KclQYTW040xb2XwHw5+kmCXojo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNTNIElwUV6/pvUwNcO6YIml2\n0RswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAabIgoWnsNpd7Gm8OS9Fd8Id/p+rqbb1yHwI0UxN9MICIQCNbW8M7eAa\nRuUnZw+lPHdmWApF+6/BtEzxU+GNr88RCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAUxYYckBWrzxRT8naBWAS55jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFiZDI3YTktZGE1Ni00ZTUyLThiNTQtYTliNDY3ODc0Y2ZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjE4NWVhNTAtZmM5NS00OWQwLTgyOTYtZjMwYWRjNWI5\nZjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE70JXst1R8Uu67rHjmyPKvula\npqUoPRTm7oTuoSbdJxtxKZIg4IQfJ3A5hqHsknPkp9aJn9PWujloWJyt1sRk6qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUofhinF3ZNJIaMd2+R84HhyJ1XjUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBwd7hEB/Gq9LHCoww3Ygi/flpejrot\nKfV+RspgHEpeKQIgK8tY3k+KemNm1eyyuvZDTwR5S075VWVsG6A5+JFxboY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4543", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4543` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQoYYqq+GoTHd6SF5e+8vdtMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4YzE5N2YwLWMyZTItNGRkYy04MDY5LTlhMmVmNmY0MjViZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA3YzQ4YjMtOWM5\nYi00MzRjLTk4NDgtMGU2YzM0YWM4M2ExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyOFcGBz21mVXZMmZGVxNefJqbW+c7Nt0GiUwRf8yaHk04FeW434iZIbKdMNK\n9Yr7CKrMPnIXX0OnSsjBOeHCPKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFD3Lr1meepmInHuCfgDNqAyoG9BVMB8GA1UdIwQY\nMBaAFFAkSL2Yjvf8IY+T6pb8pun7n2+6MAoGCCqGSM49BAMCA0gAMEUCIEZtkw3E\nwhSttSgSyIC8SKIQlV7aKvDwy/YzHzhvvK0jAiEA2Zd2Q6NhYN0Cbzaa3XpcKrUZ\ns1yS3ATtq+Rc/21rqCw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdUj4k5meR+5CtDsv/QPakV4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOGMxOTdmMC1jMmUyLTRkZGMtODA2OS05YTJlZjZmNDI1YmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0xSj0sAkp4tOINdgGTBiI22eJKuoaqp+QxwTY3VragPZq\n6B+KnrByYGgPYBpI6qVUixorELGwSRjX/zPEilQ/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUCRIvZiO9/whj5Pqlvym6fuf\nb7owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKwhrYFCMfT5mHEExsNo2SmIKyOmrKUtCMIYDveRP6GICIQCfMVCZIze3\npFNiAACKttQDwzg8WaIhj4hZ9RwJmXw6Aw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVrlWf6X7mgur2BA9oNQ19VsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA3YzQ4YjMtOWM5Yi00MzRjLTk4NDgtMGU2YzM0YWM4M2ExMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTBhY2UxM2UtOGE4YS00NDBmLWJjMzItNzE0YjdjOWEw\nNmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3KKZTyNlPIobOo8FAHrHIZsh\n5+pHsPM+CRZjM897YV2qzywNaAUuKdZ1z2LFwTdXYK2gI9tU4oMlopZZiyQVd6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPcuvWZ56mYice4J+AM2oDKgb0FUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA/BAX5LaV5BZRUsHCDxMYYkUpaU+Bh\nOpdO0AKdjwySOQIgATN6dPHAFzUfHINRB/uqjGmXC+86YouzEx/wq8v7Rno=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4544", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4544` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZz8dwBRHSBlpyxiVeSh2kFYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4ODI1MjZlLWJmNmItNGVmMy04YzZkLWRjNWE5ZGJkMjkyNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQxZmM5MzUtNDYy\nZS00MjI0LThhNTYtZTI4MTQ0NmI4NjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhsFZDUYH3ml9oIXbSDGO6z+HBW6OGFLx8SZcGmBZOxpveEJAmzCs9kck4Sh8\n6neYU3tsx9oOxvXwSAofcxQLNaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC/sdDgHgOBFBH5tEzgY8qsWjV0yMB8GA1UdIwQY\nMBaAFMBpd4xh/gyedzuvqaE5PeCdfJMTMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA832jNyG2pEhBYGYsggOIZDr9EhwBRM6M\nG5KwBAUIX98CIQC3msMHCjAAeMa2Wb0YXbKwwCJOSC5jqctGlBKoAYxiPA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAesNdAvsYUykAXyKcSQqRnN/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODgyNTI2ZS1iZjZiLTRlZjMtOGM2ZC1kYzVhOWRiZDI5MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGkXT3vtkaJzn0DpnzIvqfqE+skxRHNNqhxYxbbDkjiidB\n4SyLSrseOG1Q5O76Wqd4JCKDjrLPv9xGu5GrlD0bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwGl3jGH+DJ53O6+poTk94J18\nkxMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN5VJIW2hFQwavUCCGbsQ9Jnz171aNZ3DY0FtjvKSCK8CIHmJLIO4hSo/\nIdsAz/jjmnTIsUOx0WpqBtxl9UZvFR1w\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfI6/Bh4enyGsgV1Vtqnj5tDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQxZmM5MzUtNDYyZS00MjI0LThhNTYtZTI4MTQ0NmI4NjUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDJlNTMxZjgtMjY1Yy00ZTE2LTg3NGItMzNjMjBiZmEw\nMWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETn1Hiaf4iEJnkwE/M9qarD1a\ntFXRNxTmJhv+wyZr0K/WGUHVJw7Glw+9HwZe6KyEIBZNdOUqjArEbJJPCKHa7qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUL+x0OAeA4EUEfm0TOBjyqxaNXTIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBgU0MgxFOC2mD4roiab7nCAcbSXa8x\ntvoEfKRM4YEY6wIhALxYFjIfFdFFp8/JLsGQzn367KiwhMhY25ANoMO1QHvn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4545", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4545` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATCKjfZjUcl+AEPVXJP6rx3iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlYTBjM2RiLWI5MDctNDNjNC04MDNhLWE0YzM0YWQ0OTlmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI2ZTM0ZGUtN2Y2\nMS00Yjg3LWJhMzEtZThiZTM0ODdkMjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOw2eHg6UDlKWoh0DgHo9ZQ+gzeKq4EjRQHCuTxgFlZxB9/YLhU4ZEivw+GAN\nQbyJXYPsL4reMMbhj80HI5VC86N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJtnst7uoFtbXruYYatkOZbyTJveMB8GA1UdIwQY\nMBaAFIJySx6ibfguOH+OPlvyIITh8eqVMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAuWvRWr24Dqoun1K6jzwSL8+EphAKkHT7\nz0citlPM8+ICIA2jnN8oKMGacIGPwPIwhJaP3Im3Jy+SC4y2Yk+E0AEO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYHFUOT/et3GGVOzUYFjHqXiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWEwYzNkYi1iOTA3LTQzYzQtODAzYS1hNGMzNGFkNDk5ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/d6tIwAXWMAxDsRlVIMpRHXmSOEkddSOYzVH+6VQqSGZi\nxoPE/fe9OiTcW7vIXoiRaOwGoBmOTweAV3IuxKkQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgnJLHqJt+C44f44+W/IghOHx\n6pUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOYjGXxoM+S9fpkJhAWHXh1oVSeR6X9AzbqDmCduBBqGAiEA02HKL9NN\ny+/cZORlSCrgAzMjFx7VXcpqskYAZL1vMsg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcx6X2WfeehDOtIb5NddF9r9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI2ZTM0ZGUtN2Y2MS00Yjg3LWJhMzEtZThiZTM0ODdkMjZmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQxOGZmNDYtMjkwYS00MjkwLTkxMmMtMTQ0NGZlOWRl\nZGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkiC6X4oJMsI9mdihurOnFwe4\nGVuowODnYHh9mjxJ6VAZXJVW/ikbwzEXhVIB2QAekVDl+hGrV38Pg17/nesrzKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm2ey3u6gW1teu5hhq2Q5lvJMm94wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBJ4bXDvAFuG6nWDs25+MTk1eVN8t9G\nv58qupLiBRrxkQIgRue0D70DFC1kwHvBNrf8uFbzaHYsAan2SFKagYW3My8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4546", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4546` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbZe/2Q1tuRNfGcff7gYan8bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyNzNmOGI4LTRlNDYtNGFmMC05ODY5LTRiNWY3N2M5ZjJiYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc4ODhhZjItZmY3\nZS00NTM2LWI0NWEtMTFiNjdkNjA4NzcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw49/6m6Anoln8nrBQ+5d3U6Qlpm4u49Qr9eA7XhKE7jbdccQzCaqkduFT78W\nUY9nOcqlzPVanoQG9ivciIdzhqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTQ+nN4tXIlFa+oW+G0yQ3wVvwTiDAfBgNVHSME\nGDAWgBRyF1BcZWr+0F7Sp9IWtxrdrELSMjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDtt1VltMNnzNmFnf5CApEmBf6w6pEJ\nwJht0m9a8ifniwIge+J0pfN+LJ/30g4qODq0p85oCzUiXMpOH4gUuoBp//Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASZN+yEc6to7gLsuVuReO40FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjczZjhiOC00ZTQ2LTRhZjAtOTg2OS00YjVmNzdjOWYyYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/0pwdc7aNqsfPBBXAByZh3uoJkxetUIQZljgXBZ6jtFoT\nwhJ1/MIbfZYMibGXyK1f07LtuMegbBKLjboJ4vhEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUchdQXGVq/tBe0qfSFrca3axC\n0jIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIMlTmJ0l6yomAQLMaEtQAQu+7zf8JBNHkX4aIWqiM6NAiEA5HAFemzy\nuiNZRjPjmzD4MK4BuY1AWLOG8uccqO9Zp7k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQVDq42EsaKl+a/PGHHGPPs5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc4ODhhZjItZmY3ZS00NTM2LWI0NWEtMTFiNjdkNjA4NzcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTIwZTE2ZmItZGViZS00MWU3LTgxMDUtYzQ5MWIwYmU3\nMDQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQD2Ffg8uYSUPJ0BlLZ93EZ18\n9PXjxxWneItISToRFeY33ArUWyGwbYnp6yjs1GSIAW/lHUDi0YfQXwRDJmy1k6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0PpzeLVyJRWvqFvhtMkN8Fb8E4gwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAgsr1yt/fMup86PA4qrz7e4vhqU7W\nr2ZgG9eixYs3BmMCIQDFSLcGvzwCj61/qy8FDmS7P1P5RgoWbS/+f//X7Pxnvg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4547", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4547` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAcsUQYj4jx6TgEATy42XqUcaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyNTM5ZTZhLTJiMWEtNDFmMi05NTNiLTU5NWFkYTA0ZjA5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjgwMzdjYzMtZjE2\nZi00NTAxLWJmMzYtZTE2YjhkMWYxYjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI8s4566r8J7t7404OgKD1zUSe+wAcLCu1FgXZoS3UzmCgY0jY2p8OJWKlGrr\nw6OwA7UeyJOdX0qjyeR4wNi3oqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU577iDvsWpu9rQcDec0p9xo1mtMQwHwYDVR0j\nBBgwFoAU3dwxNBycMgD6TpbB7e/n15m20l0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA5P9yyVZh1Xg/\nAmO3lDfCTY7+GWkxvZ+hThPmT+8LQlECIBUPQWo/uTD/Mf6XgHlcWCcIhB8OSkEE\nhlYH6vd0Fvvq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfc4xdbLw7Hq2xrsKL4C/FzTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjUzOWU2YS0yYjFhLTQxZjItOTUzYi01OTVhZGEwNGYwOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARc/SOfr/NC3ChTeRN1tDdie/5GSFjJvgmsJQnAv9Rl+y/Z\nPNeWZjuMyEkYpspMYwDe/drZYFikXpOd568qBltco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3dwxNBycMgD6TpbB7e/n15m2\n0l0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPpHMO4LB9XMrmZvdc6KKgiq0RAq0VaRR1AE/qoyExc6AiB2vpBlu0ti\nWVZHJ6BFW9jvmrsDvmaLtv1Oqft1UyS70g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISASnjMtIHvkAX9CY7tJ9pR1WOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjgwMzdjYzMtZjE2Zi00NTAxLWJmMzYtZTE2YjhkMWYxYjI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2ZlZjc1NWMtNDJlMS00N2MwLWI4MzMtMDIyOGJhM2Zi\nNjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBna9bQ2SHbY90CNTdahsV3pe\na9Hyq7TIDM09loIHTDk/yWO8oRxFzhm2+Nka0RHjFGMQxibwAMafyg8vc02uoaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU577iDvsWpu9rQcDec0p9xo1mtMQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA/gHZeAcXvalCTrU9pe3wEHo2khSc\nI3izdsFdsSZK78cCIQChtJXYSdhK/+VckgZ2Gna9vZDBiLrp/TtWX9caRk78uQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4548", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4548` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAffolYfLtS8MSE/G+fQZD6FqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkZjc5ZTgxLWUxZTAtNDBiMy1iYTA0LWM3YzdkZjY0NGIzNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjJiZmVmZTEtN2Ni\nMC00MmE2LWJmMTktODYwYWU2NDkyN2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoFMtytGAoE5loZKna2MjTl+UylXwcnsuC0Ocq9aiUx5nax5V9nuXTw4MQ3Yr\n2cNz2fOu7MQBUA5g1pbpS8WJeqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYMOUOFLY1dwEK25WzY3YkpefQpQwHwYDVR0j\nBBgwFoAUZ/NDHlGlTONtJV+nZ+uE7WdQJ9cwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAy2UwcbtsIcsJ\nx3XsemEjqStporPre2HEos9WYA3yLIACIEEq1uURUv0H8K9JLHlaZDxuvz2S5/sq\nU67TIGchvBBS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfAEi0DBqy4+pfojLrY9kXJoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGY3OWU4MS1lMWUwLTQwYjMtYmEwNC1jN2M3ZGY2NDRiMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPg3FfsnygJGPUtpAERXVB8bqoF1E9Cz1xpEaAWQgs2wjw\nO/Gldlx3N/Y4j+MfPGhtbJdtacjzQdukA/ax8A0No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ/NDHlGlTONtJV+nZ+uE7WdQ\nJ9cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLHX3on+MQboUG8PQHtlBhLURDQiOhjEIpn8WBnObeDMCIE8hYitKIGiv\nJOdLVayGsGtJDcVDfVdxpn+E0XV9rVTj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASIxK3zapL8zg5pVEMa3+UztMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjJiZmVmZTEtN2NiMC00MmE2LWJmMTktODYwYWU2NDkyN2E3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWZkOWVhZDItZjIxMS00ZWEzLTg3MWYtNmZkZTc5ZmVh\nMTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2FYZvQrWnyZR8Au02q0N7kyN\nqGiqNNiZqo7fR9afvH+tCZ2mrMsC9zItKtwy2cxm9ENtQVlbqlBhfhr2AkAKEqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYMOUOFLY1dwEK25WzY3YkpefQpQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAZD/0qWO2xB9QgW29GIXHsOrWk+wwO\nj3x2GjdyMk6AVgIgTEiSzSngMaUOek9csYIV8bQLKZ0KOLAFRCHH+02JeaM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4549", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4549` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAVYjnHwRPczRZBfw9RQ/WYE3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZGMzOWZhLWRlNGItNGMzZS1iMzc0LTU2ZDVmNjZmNDNiNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWFhMjMwNDMtOTEz\nMS00MGE5LWE1MWUtNTlmYWI0Yjc3MjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqti/JknpAoFBwK5ESQRH8uskHC8JV/YilxeehJ7zOFocqvPUwRvbefpWkUG5\nnO5wTBqKAmQ4D/t59F7XyAEMvaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURaYm4BBfpffyZEItSsisHCCruRwwHwYDVR0j\nBBgwFoAUmkwBuPf2j6mkIpB8a255blrHdTgwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAHeNGsGNyhoLMDMKjYD2ke\n7ZWno1pbKKO5XTGG8VK0jwIhAIzhU3S3HIqw/tw0lfY/kFN7e5GRXRwcHvFjmp8l\ncBQ/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcvv3jzTv42JIcaQdG6UAwZeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWRjMzlmYS1kZTRiLTRjM2UtYjM3NC01NmQ1ZjY2ZjQzYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSM2d1wjloKsGPBymLCZB4oqhr3g8eaU8pCcJ3LOom2lr3\nOTgELGBjCVcSIYDKQnNYEuQkhLVJR6VyDLfjFos5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmkwBuPf2j6mkIpB8a255blrH\ndTgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNQaje0OB/38HolccYLfmpIgTfAQcAaEV7U1GRd1tHAICIQDLH+lW0JE1\neX9EgkxVj0sSASOPCt8L+5NSjNr89j348Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUqfu7wqCCdUQPYrf5oaOXDOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWFhMjMwNDMtOTEzMS00MGE5LWE1MWUtNTlmYWI0Yjc3MjNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDEyYWY1ODAtZmRkMC00ZDU1LTk0MjEtOWUxNzZiNTIx\nNGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl6zFpx1nnex1k3WNUF6VfBYY\nGyr2ToAATqnxxeFaenawr7sNAPIVBxzaitLfLWgCOYRxRP2NYmndcVY2r6UurqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURaYm4BBfpffyZEItSsisHCCruRwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAD3NuGbkB/BYn8iU9vQbA5k6izC6xL\n01z/Hjar636/fQIhAPONdUu0XZIbAn7SF+lMbNfgNOis17zd9+AOcp89BFzz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4550", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4550` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAZ9cbx9tY3/xoregS6mP4pAWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MDhjMjNjLWExZmItNDNmNy05M2YzLWQxMjAwMGQ4ZWIwYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWIzNmQxZGMtOTFm\nNy00YTU3LTg0NDItZWRiOWI3NTI3YjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM2qWt57msc9MzqnFI5bV8vQ25KpfDx4xqj0WXoR/zyvpK1uXjtHGEFxuYRVu\niRosnSQLwXzhIBuPnqrv3m5Y2aOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0+GTZ7GU/dWYU0O1xm4XHOqP8hIwHwYDVR0j\nBBgwFoAUEB96tYF17UkxhP3lgeY7oELiq/4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAkmnE\nkowiC+dSkfMKvyrsDPTMXiHOywdvFSlNWGpDo/oCIQDuFxvMtnXscWtId78mkQ3/\nuOXQaSFS52CVZFhawxE/CQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATLQdttmtH5mj8rWIoklwQKtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTA4YzIzYy1hMWZiLTQzZjctOTNmMy1kMTIwMDBkOGViMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToL99f/hCGuyDWktVGXrXDSnmtBHHrTrZefSI9/3alYVxt\nQyasLDx0OJD4bhT57WySQdtnVin0t1Q4zYhk4ExWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEB96tYF17UkxhP3lgeY7oELi\nq/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANZLMUYpY/SrzzXZhYwLnRt49146JCEqnwHGA1ZxezECAiEAz3W+vRdc\nhux+ropr78ghd1sqDE5nZx88bA8gvuzCCsk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYfIigcJVSRhUgE1KI9pJ/2wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWIzNmQxZGMtOTFmNy00YTU3LTg0NDItZWRiOWI3NTI3YjI4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2JhZjkxYTgtYjM2MC00MWRmLWFjZTQtNjkxNDI3NjAw\nZDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs/sVGZF9ieVoGRuXm11g0O6F\ng9E1oSJX+R2hvryT0masOiPpKTYrS1AQQcVzOqGKSL4X5E/Mh2zkjyoGi8j1JqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0+GTZ7GU/dWYU0O1xm4XHOqP8hIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBDKMdhdFo5BTCpZZkQ0INfbxBk2Cw4\nVHqdBJHiKYzm2gIgIkYuUvHqCMOiYzz49s5yyOZmvBxqqgE1WRmv4/ADfto=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4551", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4551` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAe4MKmDysrPIcqZuleykNOo/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3ZTBlNDAwLWE4ZjAtNDY0Ni04NzRmLTJjMDQyM2Q3MmVlNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNhZTdmNTEtNTky\nYi00Yzc0LTkwNDItYzZlM2Y3OGNkM2FjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO+fecY0moeVSQ7DMHWp7fA0hRK1ArIXlFJJxBdGMUowaWvDsOBLQLOacm9e8\nuMsq81JJaFmDfF6mFNnVLJk8UaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3C8DqdmumRyf4khDn71cY9CwPrAwHwYDVR0j\nBBgwFoAU4jyGJlHtU9zCfJQ4yBQmCb85RNowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAz7970\nSNBDJy8s94Q7RCqZaCik0PsLA57WQSVMs46xpgIgJr126Y8LYf6QphwBnrrqSook\ntqCSGzZQhsI+pWGTu+c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQz4qW4KU/tcbcQhTfuKzBE5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nN2UwZTQwMC1hOGYwLTQ2NDYtODc0Zi0yYzA0MjNkNzJlZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6tw6l8WpheY1mLjm23bxSUbfZBRpZy2jEYtTem8TkdS5K\n0y6OXPDyzotRbR01LBfTx7Vqr05ogZMTiy1iua0Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4jyGJlHtU9zCfJQ4yBQmCb85\nRNowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdJvbOYUu9C1d7l7SfOdCWQ0ec9OP7ArW1LS1fthFf1ECIBuBh/mQr0mC\nN/eP8x12QyUE6mGXOnd+ovPor51ScGrL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVQm7YypZTM5i2g5cFK7PcJ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNhZTdmNTEtNTkyYi00Yzc0LTkwNDItYzZlM2Y3OGNkM2FjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQ2OWY1NmYtNTM5MS00ZDkzLTgxYzYtN2Y0M2QxMWY5\nYTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmjFLDL0m1WEsQYMK/tDo5gA/\n41gJXyWsabss3LCxp41KgZzahX8pJkWpRwAQY0AbEM/IVcX5P83hl1+/fSa8hKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3C8DqdmumRyf4khDn71cY9CwPrAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBFd9EPnoPsiiXmzBYdXwXfEYhiy8Sd\nOhPzFyPeVuAmeAIhAK67wNCNI5NBem9mc8qPZsQO8aXicowrDy1gbot9EWFX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4552", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4552` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYxRG+e+fVqYuSgTZP9y2yoRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiNDdiYjIxLTM4OGItNDdmYi1iZGI2LTQxZDZjZDYyNGM3OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFhNWJhYmItZWM5\nOS00ZGQ4LTliMzAtNWI5YTU1MzBhNGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Hr08EXRTySusNqBBf8cT6Ox/9A4IBo4MgLPKZzUZVC1Z6d0RvnX+SCn2pbk\nQ+VG/JyVv0tLUcv/WHJzfGVby6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFM2+nhLkuN61/MvqKZ/kr0WMqLV9MB8GA1UdIwQY\nMBaAFCrCSdcX/JP9azyNiVZD4AaqzXbGMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEArvRgtEndCiEHkY6yXggCTHzQmoYi5nuE\nMv658IbASGUCIHswlbhKrb7mtsbnLI+2toEV2lUY/CZr1eI6UQnnfztX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdt8isTSK/gLfdKLchHmE5vsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjQ3YmIyMS0zODhiLTQ3ZmItYmRiNi00MWQ2Y2Q2MjRjNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4lXHg9Qf3OnyB9U/u+A2C6aI9j+rx+nshQNxr4HVjHiD4\nMEqVUFsx+rIDwI6+oTBNZV3qeqDW3vf6Qe1sZc4Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKsJJ1xf8k/1rPI2JVkPgBqrN\ndsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSeAXhNE/ww8qK65YtBJsuyjP6ST2pp09Me3nejHbZ7UCIQD+Gnmd9bZE\nYMneydHrKXg+1H0Bh85e4dLx6Tq9OoT/aA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZTAP8KHZIjyYw9mdBH69iauMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFhNWJhYmItZWM5OS00ZGQ4LTliMzAtNWI5YTU1MzBhNGZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjc1YWQ5ODgtNDhlYi00NWI1LWE0ZDUtMzU2ZmE2NjIw\nZjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+4XABXk3qCR/1m8Bm/gn0cpL\n/HJbhQS3KQMh6Rhypyu8DfAzR46KSeJEyjLPjFtg8Kz6EVcS8KuwHzIdHfunuKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzb6eEuS43rX8y+opn+SvRYyotX0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBacItsM00e6pDVzGrN3uwDV3O855mY\naRHRlcezsfHyvAIgKnYTl9VAy3XdRLL7uC4pqMqfBuicoOI+A9NACvCgHhk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4553", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4553` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATZQj5lKOz02fVRmzh/fBZDpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjNjgzYTkwLTI5Y2MtNGYxMS1hMDNmLTRiZTk5YjFjYTQ5YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzllYzM4ZjMtOWNm\nZi00M2FlLWI1MTMtMWMwMWY1ZjM5NzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjk8STCsAe2jMfIJKReWsi+vDDRNjv6Vx5cACj2O1v67K/iwUVcUSe+yNH6WI\nJeB7cF2lgBDVeMYoduCy95hGiKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgz/A6GqCalDVEnAeSMyoYBb/2McwHwYDVR0j\nBBgwFoAUdFFbfhl7SLhTCNp5eZAVJ3QscPEwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgK9hfJ+pHFEZm\ntA5RVcHlbcJ7mfFkL1nPAkOo4wLTHUYCIQDdxwI9lAQ4mx8Y+Y25gW4/ee6QokKc\nKJnaXYa9vSQAeQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAay0KFooZvmwkolyraTc+SBBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzY4M2E5MC0yOWNjLTRmMTEtYTAzZi00YmU5OWIxY2E0OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIc98At7Kbp2kaEkuWWgic4og1Dqz85hsYla2PLMcp/eio\nJ/U3n6f+7NDzZftNr03flZRWE5rmle7fEB7lI/kXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdFFbfhl7SLhTCNp5eZAVJ3Qs\ncPEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK/PNmMZBpPcd+KRu87vnU9tmtsYS+M58w8C6HKYRNkwCIQDlxkA5sNLb\n+vAxLC/3wYczJMy5+tjE5VT2mKwftbO0/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYzscfmP2eR0C2lzMAxgeJpuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzllYzM4ZjMtOWNmZi00M2FlLWI1MTMtMWMwMWY1ZjM5NzJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmQ4MTZjOGItMTMyYS00MDFiLWJhOGEtM2YzOTgzNzI0\nYTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG8jJDbW5AhXECYjGGSAASGIF\nZElFX++RVzA1mFkZiNaI/3q6NWBJLX70c0rl+Kgb+Uk3hAyNb15p9zl9vt6m9qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgz/A6GqCalDVEnAeSMyoYBb/2McwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBJASz4V+EmqSRX0G3l+vxmUZCmTykt\nmjhp0qebXJvo+AIgPEAtoqsXSMxLo2vjfcynfo32hwo2c65NQgVJ1rhrWEY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4554", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4554` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAf4pPXgZfzFqObfPK2oChEU6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMDg4ZDYwLTc0Y2QtNGQ5Yy05MTE4LTc2NzEzMmJjZWE5MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODNkMzFlM2ItZjZm\nNC00ODJhLWIyMjYtMTA2ZjJiNTZiNDg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErWnHZ19jf4FbjEiKV3WVgX5fLod1Sz4IjFEQZTBePPkabO6h5ADY2f6V6iVY\nknb4E/6QptkGF9o5QuFzKRsJf6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5cQXDNMVx/4TgDRB8snyiI0eFVYwHwYDVR0j\nBBgwFoAU+mktDQ8Gjfx18zaSldP0M7nkTeAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgWPDuDhlzMmkZ\n6/VKxPV/ZtiYlTA6fYmyGd+9tTOq2OUCIQCQXx2ez/A7jkcYopQooRt4POuegkrd\nZeaqsvkTWGtjTw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYnZdSDdx0+mGSGFdGfCED0TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjA4OGQ2MC03NGNkLTRkOWMtOTExOC03NjcxMzJiY2VhOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqWlaLcIRQbtYXgYWMxFctmOBlvs3GdDyGsKbTC612EjOd\nT4Stnj+O1+FDyhd1y8gQTioQws7z+Q+/Njb+5WtSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+mktDQ8Gjfx18zaSldP0M7nk\nTeAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI9/a2GPi4MqYOZXj7Bm0awEzo1fmnpjbHMJNRx712FNAiEA3YWcpIFu\nWV3FTtE7UepvvZ83I1dqURS17kmE4Gr8+t8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXM+eqPZjBr0UqZ34NHzJvGvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODNkMzFlM2ItZjZmNC00ODJhLWIyMjYtMTA2ZjJiNTZiNDg4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTI5ZDNiNGItNjNkYS00YTFjLTgxZWItNzIzN2EzZDFi\nYmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEMAUGGxCIXnDvyV/2BNrxSRu\nv1CvgoDHtcDpSLPMUskg4UhM37e6IiFt3T77KQwRyiZcxB0Okir/B/u2oM8iUqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5cQXDNMVx/4TgDRB8snyiI0eFVYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAokHYA6uaNtHn1cs6sPLf5Fs1mlH2\nZBW9tXXB9THG7rsCIQDBzwaaoA/wbQ0spw1Xms7rmeTKTf7T70qnqeoym5dk4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4555", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4555` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAc970itNrucA0fxTr5uT/jp1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkNjBhM2JkLTRmMDYtNGI1Yi1iYTRjLThkNWVjNmMwYzU5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzU5NzJjM2MtZDBk\nMy00NWQ4LWFhYWEtYjI2ODdhMGEwMWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdq5TsYwpHyjWbvSoX/A+D+oa0xM64QepuJ3BP/15ySdJ7kxEpn2ElrHTw2ju\nQLZKFiaNtQ2/ZVn/xhdtYJtcfKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmIpqtEdAXpvylj448SzRvOgV5WkwHwYDVR0j\nBBgwFoAUw5gAAXlw48ko2T6kgN23SxHC3sMwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEW1bIevPVUi\nX1dny5C5qTw7Q7CNooMWqlp875W261oqAiBc1b1f8yLNioUUZOWtmt0HyEmTSd6L\nzHtYz01OC03Mfw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdmwDc/ljF123+ThSkVZuGWIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDYwYTNiZC00ZjA2LTRiNWItYmE0Yy04ZDVlYzZjMGM1OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkoTpLq3weeKrRS0BEDQvizAVVyrBPPas4ebji4wRyQJZY\nYVHrcEkErrKmgoYWiSBAS2lJsmLCT5VWJ461AjCko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw5gAAXlw48ko2T6kgN23SxHC\n3sMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQghQnFUqro+qYjuF6Kv4ACpli3yJTLpM1hLvyF6zPTwCIQDB3NLHT5D1\naCZInxPVby3Qi2C8F6CVx3SnKZKQ5eFMIA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYS5wbhGJie1dTzdesLXRuzOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzU5NzJjM2MtZDBkMy00NWQ4LWFhYWEtYjI2ODdhMGEwMWEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzFhNmNjODgtMzI2Zi00OGU4LTk2ZmQtZjg1Yzg4MzRl\nZDgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4UwcjAKKAkMabDc2MAFvTTLS\nPXkAhdX/eppZWDevsgRJqzSccAeLFzndWanxhrHDdYsQsWaYJTKq2jtXMP04RKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmIpqtEdAXpvylj448SzRvOgV5WkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA/h8vvwNNUyh0ulA2TiTEPf9jNVn8\naLbUf26K6rR8J0kCIQCClRiAdmqSsxWxFB8RbsnsyvhQS9OsTSRGRJ1ZjkN/BA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4556", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4556` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZhCSAaSZ6oVQaUCpEX+rAsKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MGM2MzA4LTY1NzgtNDBlMi1iMGRhLTRkZjkwNjUyMGQyOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjUxOGJkMjQtZjFm\nZC00MWIxLWIyNzEtMjhjZDg4MWIzY2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVhI2n9h8ynkCWx9h0eLa+//2Ce8KX7G+1QtY/YNn3PzuKHQKy9+0M0n6EoZ8\nmJG50vXskzreJ/oiKP2gHgMEoaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvSZRB8lewDMsXn1NcX9mUmUifv8wHwYDVR0j\nBBgwFoAUH60gJeLvOIUExBVj4a47JpjbR5UwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIA0cWFVj5JhQWJkWFs0UZsGRuh8fes7vHeAbMLHWNobzAiEAuzohgiH+KRoQ\nuP/c1ry3DN1NYCYG84xqb3jrGt82Tws=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWwZJ4m89I2mKujsEGSUQ/aEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjBjNjMwOC02NTc4LTQwZTItYjBkYS00ZGY5MDY1MjBkMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9SkTGJPwUeXWoonizmlH+WjPuIPXM8suiWHKaviRAvkyN\nZO34woYBfmmqG41siscWKbPM/PHmDmxxfS5Vilu/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH60gJeLvOIUExBVj4a47Jpjb\nR5UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSDkY0A0ZmbOOMO9DKcyxLAQz7rqOXHRpJ5VQ6pqYH5kCIQDZJd6WWuDI\nplA8FPLD+EuRQnnmC6WspvOj4xJ2fzYDxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQTgQTGE0hfPwzTAIvls/Kx0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjUxOGJkMjQtZjFmZC00MWIxLWIyNzEtMjhjZDg4MWIzY2Y5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWFjNjM3YzQtYzU1YS00YTdiLWIxZDEtZTU3Y2U4NmU4\nNGZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaz8xfVH/ufBK3nsVwa98YpuK\nA1C93k1qSsAIHIVbqtr/jwOHyxgwWaGnC0eL3Tipw8cr0Fuc/9se4YVHRH8l4KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvSZRB8lewDMsXn1NcX9mUmUifv8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA4NvRLT5C/IY5wKJH7/E2gROQi+eg6\nDztfda7cboWl/wIhAPlY8uINe2Tf4YRBXLZr+a8h/fLFBp4lENGfyZTie94T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4557", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4557` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdXlDzWTpmBoE/gJ6+rLz9sTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5MmI2NzFlLTJkNTEtNGRhMi1iYzM4LWQ2OTJmZTEyNTUxZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ1MzU0MjEtOTU3\nNy00Mzg5LWFkYzEtNTlkNmY4NWU3MDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXmHaWsxgVLRVKVtCz8RE5IPnnmLHu+ODDW5lSp3zlvSXqFyuwlabL9B/Octy\n06u9ComzsoXC0GXPgj+cjE+4qaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyeKSXXsLd99z8tfIUOcXeuZQ7C8wHwYDVR0j\nBBgwFoAUwaljMZ2fK3Gp8WCNqFtqxaVXKbQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCAcJxdGAW0y+ObcVsOyNSDLHk2srJV9dXcsBZnyREG4wIhAICuBT9k9isA\n5Z4Y56CuZxMj6JAkpQgIgyXFkH+AgyeW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaKNM5swZOCrL0H8iZ8Ny+hSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTJiNjcxZS0yZDUxLTRkYTItYmMzOC1kNjkyZmUxMjU1MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtyU/2LgotHmeUVUV3fwofdG6lbiBNqoBGT5d4EpD0kLlf\nnGnB85vVSGdv/2TjXLLOLjWoa9sr8quVNwGB7BuTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwaljMZ2fK3Gp8WCNqFtqxaVX\nKbQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPqK9pzfx5huRIbUGKM3zlX9ctSpOrqCULJCyGayK7S5AiAZb9hm/koY\nmWqo2Gc6QeoXz87Ml/raclFASUsOGzRnpA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVJfVq8gT0P7NMPN4umMcJ3CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ1MzU0MjEtOTU3Ny00Mzg5LWFkYzEtNTlkNmY4NWU3MDZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmM1MDU1NmEtNmM2Ni00ODBkLThiMjUtY2U4YWNlYjk3\nYzZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESKgQRRLs+YMngjVVLjygRtsu\nM9A8W8K6Jt+xnEJPV7iD5JDrWRgOZOHb99N+n7iXVkbqJYedw4/KhsTEC2G+caNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyeKSXXsLd99z8tfIUOcXeuZQ7C8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAvDwMTb27LWv3pCBLGpi14wL8sKQV\n9OKMFpyW+HMANnECIQC4CcHFZ/iV+/wwrAd+iPOwWWbX+joDUwvNP4ApNsWPnQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4558", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4558` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAXodFD/FC5llwXi9bsbRhANhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0YTBmZjQ3LThjYzMtNDEzZS1hYmU5LTVjNTFmZjNiZTY3NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFjNWIwYTctMmE3\nYi00ZGNhLTk1OTUtNDk3M2MyNTYwZTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcI/kYzo+KL0A2HFf7nALD+gZeNCKUYEy7swPbrr36xZNtyB6VUG6Ifn4oYvX\nMToLCWrGdDNJZDcWuTG7u9b+YaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdEhgPA8llseoxsvK4HHJRSex/nwwHwYDVR0j\nBBgwFoAUthToaLnEMrWMQ+dB/FJheVh9oCkwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCt\ntmql944/abBp06rM+QnktxxFYdgHW5t8tfefN9wwjwIgRU+Xw3z25wrmFrqL7ogX\nAIcN4gXvSNf0S8n/yedilIo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdHpXBHFl2LYtbOOS+qiLgfSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGEwZmY0Ny04Y2MzLTQxM2UtYWJlOS01YzUxZmYzYmU2NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6NXY6mzCtmmF2TUjzJz441OkjaLT1IaRc/OLkR8p0a1P8\nTTA51TT0kxNITObJdA12wdhcsmSQ+lHMeHC9+sICo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUthToaLnEMrWMQ+dB/FJheVh9\noCkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR9h3C1ZyTyRP2jL0IgcZ0dQl10BzrqRcKVOjIvr7QroCIBTzVTErvNCx\n0zUxQz5idYGon+zKYDdR51VK83jagT+2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQm51MbCA6m+d0DPuTDDIMghMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFjNWIwYTctMmE3Yi00ZGNhLTk1OTUtNDk3M2MyNTYwZTZjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGNkMzkyMjQtM2FmNC00YzMyLWE2NjUtMjc2NjJhY2Zh\nZTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIFvMCS20oEKbWCVFmIZMmcAl\n2we0lhC1nw+aZcFsluQdvYUNkbOeI1fwVmBNVQnH54oa614JwR+y1DK7ztC3NqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdEhgPA8llseoxsvK4HHJRSex/nwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA2MqmsdvTEZPbiNcBOvswhkvBr2hrY\n4/XWa2JZAjIbQgIgIvJeMGxL1Ex1sqBu4aNmnjUy9/m5unkYW8N/yPaB+og=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4559", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4559` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAYRDB2rmSJW4rw4ORZwWW5gEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYmE3NTBiLWRmZDQtNDkwMC1iOTQyLTVlNGRjNjZiNWRkMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA2N2QxZGQtZTgw\nNy00YzUyLWE0YWQtYzNkOGY2MGQ5MzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsIrOHc4uzJeO3fAzfY7ht+jm2zcyCOZ3VeOphG20QYvrXjrJ+4XiLX5IjQcQ\n0p6Nsx5zsrjGePp1WhZXyswMKqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcRrtVkBeDOS+IEJLVYNEQlMMHnQwHwYDVR0j\nBBgwFoAUJ8kBm8q2ExQAzfxaz6/Rr+hX4GIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC4wA0WN3rD8Dlj3tM2Tgy5bCa/p2bS8c3VDIr56Vv7xgIhAO6J\nsUgz1vgQLCli19JfJxgyI3YDVCN5FSWnnYZ1PzlT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATAb1DYvJDVUUMv6uTiSo4+jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2JhNzUwYi1kZmQ0LTQ5MDAtYjk0Mi01ZTRkYzY2YjVkZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWKbMK+puRjWbKd2JeBccC6L/DBeNPnLzu9BDoTubwR0xe\nBv9SMYoksbLI+YGHxFLnlByueV+NF4OYqoYBmQjoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ8kBm8q2ExQAzfxaz6/Rr+hX\n4GIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIGmTMAyE768Eka3/f7bsycJbNr2igb4Qq75cyqbnW2nAiEA6VkeKas+\nDTn8+mnBYhGlAfWHQ3eyhFpEedMbMYVfhAw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQXS+X4O7ubxYvoqtgMoFWEtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA2N2QxZGQtZTgwNy00YzUyLWE0YWQtYzNkOGY2MGQ5MzI0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWM4OGQyMWYtZjRhNi00Nzc5LWE1YjgtZGUyMTZhYjYx\nZTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ4zY96hcRv0mvPueh8r3BZaL\njM83vdCZRWZOJaPMb42C6xhirBIlRwC/rdx/n9SDsLbm+Cbp81LzdS+PEY0rFKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcRrtVkBeDOS+IEJLVYNEQlMMHnQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAwqHgxGru3bIg2Q9N79afoOfx7BC8\niP96BEckhwxwKj4CIHpp6PZZx7nNQ0d3i4IDoZp6f/IO4nRnFOST6SxSmJwy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4560", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4560` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZQ/3PIizrMGworiWouvrCNEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYTc3NTJmLTNmYTAtNGJlZC1hMjllLWU5OWUxM2Y1NDJmYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjlmNzI3NWUtZDI0\nOC00N2M1LWJlYzgtNmE5OGVlMjAwYTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESXAnaXvPLO7LNmmJm2XlgS+SqFy+p7BDO64tDOv7AwsJ7QyTFzlBeYM53+Dp\nv9bkiA1RWUPQUgzrcEWILWA4DaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhEABPZHTtMRi+RptMRsfhyrQTdowHwYDVR0j\nBBgwFoAUlfiI1ElJb9Uy6ijLWib72f/62O0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIDOG43MaHfUoxmSfNYhH70cX91DcV0BB5Hsxqohju8GoAiEAwHbR\nEMslDyDloi9/jSuy2n7e9KmY4oZ61CeNbhsKbYA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATrujrEvSGodDCEThXqnqBpjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmE3NzUyZi0zZmEwLTRiZWQtYTI5ZS1lOTllMTNmNTQyZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARygNNb6hAapc/+SL+869JpmS6+FYXHBwN4RuO2O3TnDGxc\n1MzjYDgOsySYt2d6BgdEz0YWYdDkLpDgIlpxRbEYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlfiI1ElJb9Uy6ijLWib72f/6\n2O0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIy6dj/4INg19nKcQmcZPN2fHeXdbZRZz0HTrwiyjEJVAiB3CZ1gk5YW\nBwz0FBIwUaiDFcab4OspYoHWfijsUH9PRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdvl68w5pcP85CR6eo/byRceMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjlmNzI3NWUtZDI0OC00N2M1LWJlYzgtNmE5OGVlMjAwYTYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmQzZWM3NWMtZjRlNi00OWQ1LWEzMWUtNTVmYjI1YzA0\nMDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELXRDrgJpHqGEh8zNMI338dhD\n6FRD67OhT6Y4gG5pZcgsUM2U0O6NVdVWoF023rNCg62UmrUIJshoR/bvSX4KNaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhEABPZHTtMRi+RptMRsfhyrQTdowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAK46+NgL9igFZpf6BXqT5VOQGq3Oci\nHqaOcMZgrGa+ogIhAM75Mjs4ubW7Na3pwoK/dKkgnpW4sV2MwYoD6XWpeFZo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4561", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4561` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcCQcnq5cXgbS60vaRB8KJe5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2NzJkZmZhLTM1NTEtNDE5ZS1hZTZlLWYzOGFhODU5M2UwMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMThhMTRmMGUtODAw\nNC00OGNjLWE5MGUtYjUzMWE2M2JjN2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAX/kvMvEKIWfcFnkjNUwa0ov/BmNbIxRfkKcs6zZVSeHIaVvsbl9RDEsaZeR\n4se8sit+xXSSB4lg95agCgdANqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLMuXRrmwdDvrq3rhN48xeppXUdYMB8GA1UdIwQY\nMBaAFKImZn58eNnCAR6vdFyU/eh+FojtMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiB+ZJFS8TVkwbyHwhiNEhPDZIZs7HIJNOJV\nC8dXkqYYKgIhAI3yB9cZlvsGRsu68dGX4ne66Q2JZr67XE6+l/VyHoKZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd/C+KMKQejdOUzmyW5ZeRlhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjcyZGZmYS0zNTUxLTQxOWUtYWU2ZS1mMzhhYTg1OTNlMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpTrJLdZC0a5YRRdDX2qtObETUyg/LrTr33tGZql+Q9CrR\n6UIwXK74Mdba81G/UgzmRG4Jx9om40UY0bvlw6pBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoiZmfnx42cIBHq90XJT96H4W\niO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMOpCsLTDdFJOuy8A37M/ssKOeADY/3qDpMACo9dO3CDAiAn2gwa1+H0\nNR1c84aFCq3gm2bYpqEGy8JOtM8RcefOIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWCzSaj2C3YnxEhKhp7P8A3WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMThhMTRmMGUtODAwNC00OGNjLWE5MGUtYjUzMWE2M2JjN2MxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDA2NWMxMGMtNmY0MS00MzEzLTg3MWUtNjVlMTRmMWVh\nYmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXvLE0tgnNofRjcemhCcqdVTZ\nr8NhcO2/hkRBAc76+mHSTZdwcHorGsnjZhYjL0tKgk8FEJnhMDhIlJ6IYPSNHqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsy5dGubB0O+ureuE3jzF6mldR1gwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEApn2QFiQeNFuYsxZg1T5rjYACs00C\nyDZ3UjCTVSK0YOcCIQDIQ/fF0Eyh7G+aX4pCmtXVSIiU37zOJmKT3CijQSt2eg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4562", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4562` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAc5XBpQiEpJylgMHUkRGbquoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwOTJlN2RkLThiZTEtNDRmMi1iZWU2LTFlMWRhODc2MTZmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY2YTY1ZTUtM2Zh\nNi00NDY4LTg1MzAtNGJmNmJmN2M2MTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETa24S0xBwwGdK113g3l39dil8AoquuU73A8X2csnH4hinlyX8qiwpxKwE6Dt\n0ksqCVbdY23j189DWyytxlhUeqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvDVmC7kdzJCxrqgzNW7Jtw8ON8kwHwYDVR0j\nBBgwFoAUTKxsK3wXg1Rj9fgv1Ie/GrduNCUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMhl6kihVo6m\nSTIs/g8t3My3B6AHu2n7stvpUBWD9z1nAiEAsWmYJ9eDJ5bTg1jGNdxuStuRGk/C\nIoKh3AhZNHujOtE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbbNGr6UbvbdxGzwdz6Dh26QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDkyZTdkZC04YmUxLTQ0ZjItYmVlNi0xZTFkYTg3NjE2ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARizHrAUaAQMBK8XY0Hcqsh1t55Y8TXr45h+hd5a2fcU5A9\nKzRmcuYGJ0LC+PYOyYtC0kFkw/yIZ73mMcdqpFbYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTKxsK3wXg1Rj9fgv1Ie/Grdu\nNCUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAINIif7yONzfG/pCm030uWOH1T8/mQ0ftBK9CnCs+/GMAiAiHBueaASD\no0lMU4xq4KSy02usEXl1/UUA+MuI5M/gVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQzyfP2MgXAJ09BD9kOptG5aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY2YTY1ZTUtM2ZhNi00NDY4LTg1MzAtNGJmNmJmN2M2MTM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGIzNzUzNTktNGNlNC00NjExLTkyODAtNWJmYTMzMGU5\nZjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4wwJoi5RWCPFgezKc7UQLrVQ\nUT76Lxn4a9tCeRgqKNmTcIRH3WokTlh2csVKTxv3voj7mK3wToe/5nLzn5U8NaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvDVmC7kdzJCxrqgzNW7Jtw8ON8kwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiALVI8kBMitD+w5Tn0dxMoDmwWE50Xh\nQXLR7H9ZHp/7NwIgEKIVh9DDpxGWtqYrSQixs66K8imCKFLkNdR6sxOvoEQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4563", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4563` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAcZWcwLQ//q1zo75FPEWD3FAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjYTBmODI3LTlmNDktNDI2Zi04NTIxLTQ1NjVmYWUzYzYwNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2YwNTYyOTctZTFl\nMS00YzU5LWEwYTktYmJiNmNiODhmNTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfwzkXQv5zTYSPXploTs0ySifHuqPWLQB2q2V1FoXebOifjpLfxBlKMP02+rl\nE7h6SgSvf7k+pr9fNk6HzocPraOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQWojWNtMZwDgSB0OFD1v+GORwxcwHwYDVR0j\nBBgwFoAUZC7OBFcu2fMqRuxleh9cM9zGH6QwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANdyfXBo/eAB\nCv6HFOZMIWGG94C7NJLkysPGwNIfEhtqAiEA/BvBHpjg12z70KvIKszJhInwp/Qe\nb+pr0KWozWVRb9s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAccO+YRD9BNHqryyGo2pse+nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2EwZjgyNy05ZjQ5LTQyNmYtODUyMS00NTY1ZmFlM2M2MDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjf9ufaDWnaUGW+bGVsqyCTZtY1FoIBTuikTtW5ubMVjxq\nGF1IZGxSSl56c+a0M3YWylU4isEr7JsK2Nwy3HYuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZC7OBFcu2fMqRuxleh9cM9zG\nH6QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANjRLZc/hWAgl1Fbw62WFka+g1R+cIoPKWWB14sQNFKkAiBo0siOYluS\n0JX2PpZZvRsma3+RQG8e3Mr0UwyPwa+jhw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASbZufRgIwf6OetNhM4mIngkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2YwNTYyOTctZTFlMS00YzU5LWEwYTktYmJiNmNiODhmNTU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzhiMzQwNTItODg4OS00MjU0LTlkNmYtMmNjMDg2NTI2\nYmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETOTZvSd4SnAc/cs9/rc1god4\nNmkynwBcvq3eVBeq07Zagd8/yrE5V2MF4xSUtgirQZJ6T6NR0M0lw5L03unYjaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQWojWNtMZwDgSB0OFD1v+GORwxcwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBWFS/63FnDn5jXxGVvTJv5u9B3JyzG\nxgh4p1tbweyR+gIhAPF6MQexOh7L9L8G73H+U00XVmEDZIoHutxElmN0xJwk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4564", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4564` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAbH6zaH2PmZ79P4y3LkAPCTdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzNTliOGM2LWEwNmItNGM3NC1hOGI0LWFlNjViYzBlZjkyOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk3MGFhZmYtYzlk\nZS00ZWY0LTgyMTktMThiZDJmZTY1MTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEficnFiwKILtQPqBbRFLKR4b/ZN1fye09CQRAk5LFNQNVOcPi8AaVWiO9rXWp\n1+KxPJuFr+xXYmHJjaHmRtxQXKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIojreozHCIj2/XK6WFN7hPqeHX8wHwYDVR0j\nBBgwFoAUsPJnKoxoP1xG5E1+EuEv/tYMPqMwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDw1vzFWGnj\n+tMhx7qkllN7hbD3angqrMvMfJmOlse+xAIhAOYRQzp62W4dUxBHFAP5Aq2NMvHw\nPGB3dtavRYfiJz6v\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUkYU5H5/Yz/m2zXWbvgV+uJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzU5YjhjNi1hMDZiLTRjNzQtYThiNC1hZTY1YmMwZWY5MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARj4r+eYZd0ctrstTKYDdKnBYogGrVKsxrpA1DDepwRAGc1\nP2seTXClXL/Hu1dUi2g5N5VetZ7uvXf4ZFwqxzW7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsPJnKoxoP1xG5E1+EuEv/tYM\nPqMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf80aDZGLp2KMniKG0sitwvpE+6lMF8AhXCZWcyCsCUQCIAn5ueEachnu\n5kKguaMyJgTka91pXoSKFiBM6LeD/+IX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAb0b0gLmOU+gcDZvO7K1zgIcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk3MGFhZmYtYzlkZS00ZWY0LTgyMTktMThiZDJmZTY1MTAzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjAzODlhNTgtZjc1Yi00Y2VhLTk3NmQtYzBiY2MwMzZj\nN2RiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELBjxl7RkhzY7kKJ+pQBvNlwN\nRtHVUnmwvdMhUDriAQIK6VrRyseve4Xiyxaa0ZrSC9+5/4Nu0tCvsbVrRf1Z8qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIojreozHCIj2/XK6WFN7hPqeHX8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiArBdwxK99AZizDL1N7Y2FzHhtrhHMM\nTd5ZG1uAY1Yy0wIgL1oDU5BL4hXm2nZ901v+ce1uI7m5Rep3bGzwX+Vsq4Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4565", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4565` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbjC35vAbwypsW5MVyUDLze1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYTA0ZmQyLTgzYzMtNGNlMC1iOGE5LTc0OWMwYmZmZjZmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZmZmQxMTItZDE0\nNS00YmY2LWFiMmEtOWY1NzM4YWI3YjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEZMFD6Awe1sRE7qxZlm7adhhX+O58vTpR1TLEw9vLn6t7DGf/UKZTlCR3d3Q\nspENLq0TTDE3ohsA1wyes6icL6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURG3JZoReb3vfRK3Hiqptil3wKs4wHwYDVR0j\nBBgwFoAU7FOncQaT/fkllbHrRybkeuU7VDAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCOzXTZ/OPCrdkGpDYyD7qutNc1c+uCUuW5OzqNHjwxJgIhAJ2dT8BKLbCz\n+/1GhvWsDChiFsxs3LeLJhDOWpOsHoI8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdiX6YIdLisRZpG7DHyO8s3pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmEwNGZkMi04M2MzLTRjZTAtYjhhOS03NDljMGJmZmY2ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBgX5ksIJp+tX7S5oQMYDJg07UWZSOqffKf3QAEm8m4Bps\netzsKSnF60u5bRuWeNUMglG3uQf2bCNKtAbKDS5Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7FOncQaT/fkllbHrRybkeuU7\nVDAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXUvxSJkGHI+x+mVB7G5k5n/4Idn3cj8uxX7zYOkGNSkCIBgvlxxw1ZsZ\nQdtO+0f18EHD0tSmum3WEfelQTMkcHF1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAflUsMv9QDnjxT6yKssIAlq9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZmZmQxMTItZDE0NS00YmY2LWFiMmEtOWY1NzM4YWI3YjRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODkyNmZmNWItNmNkOC00OThmLTg1ZDEtZGIwNDEyODY0\nN2U0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEe+kElCjn6LlQMktLEDFaae3x\n6SWHO0lCDoGOjy7kvv/VXo+rFwkEZgB8UpNGaXiYGNFO5dK3bQzeg9gHpxvam6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURG3JZoReb3vfRK3Hiqptil3wKs4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAnrwx2w7lFLIVrqvxPWt+9/ljduGOR\n1TylGa8opPpTKwIhANMgLe/5SVwOPz/x+fRyEWw4DhgRN/TDItRNWg1LTRQr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4566", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4566` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAd8rJ/AlQ1qbfkti9pDg+XYEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmNGZjZDEyLTg4N2MtNDAzNC1hOTE3LWM0NWJlZmMwMzFlMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFhMDM3NWYtZmYw\nNy00NTJjLTk5NmMtOTI2ZThkYzcyMjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1GVv9Sq9zPRSzRdIkaUL2DMl+0c5y8W4t7hsYmn3ttpB1rNi2/YhgwJg9aUr\nARbZVx7lbhLq5yoP4uTic5YNMqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ShHlNW5k+xwuVXzdkCGL+tHgfAwHwYDVR0j\nBBgwFoAU3XgWe6G9cLWO9AakJJx5NM+KspgwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC1MM0hGQ8nqaQ+CCkMZDw5Q5IHVGdNBnbVPaguB0zmEAIgGznF3eblKJAg\nUnLhhsmLD6W/LoG1TkuHmkxowWbJk/g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXr5WwTLc4Lz9h+1xVe+cNpEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjRmY2QxMi04ODdjLTQwMzQtYTkxNy1jNDViZWZjMDMxZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyuFK3b+HfEN4JPOWizpZ02azkxWnJwEr6DRdriUKmMJom\nBxbBtGakPez00CZ7mhTOilgoEJEzjffUc1SE4cBio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3XgWe6G9cLWO9AakJJx5NM+K\nspgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeJmSHTrEnR42v7bXkv5n08LA1QjZyj0/BYGyH5y9yOkCIQD5ECXYk92N\n7fRO3EsL61ssiXN+ECW1mQ9I0rLF08g3hQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbKmDdB6lfDl05PH3i9uP4J0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFhMDM3NWYtZmYwNy00NTJjLTk5NmMtOTI2ZThkYzcyMjg0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTdhNTJhNmQtMGY3Mi00MGJlLTlmMDUtZmE0YmFiYjQx\nNjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5das/hA/9noPAoKCO9nRBkVY\nvZcJLJAdZeQDIYvU2GVnJKxi7qUIfMnmiqH4bthR4gvGQsPfHsqPyEAvHrbecKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6ShHlNW5k+xwuVXzdkCGL+tHgfAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAv5asPSCS2jbYfUNHebz49AhA/9pad\nGfa76aX8CgQNsAIgQuuwnLnivNxFdKbJfL2b+r0HVsne5xOD1LqcXR/1kGE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4567", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4567` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAY1hekhRBa+oSkd166mTabtKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2Nzk2MTAzLTFiZDUtNDhkOS05YzVhLWRmMTdhYTQ4ODIxZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI1YzkyNWUtNTY4\nOC00NGFiLThjNjUtZmMwYTgxMDQ1YTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUAcf+L8rWiX3HeZND0LZC+n8Vfsi4NhYMDK484gnDtuWbwWgHMPodLQO/JkX\n/ocDRGMUxzXEJmJgXe3E2pRQk6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUCrbRbgoj5hHnGM7DnFsHsvA+FQwHwYDVR0j\nBBgwFoAUemzu+oi6sPLQQVmbL/cw5DD4vXUwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBxJ\n/XY0pR11oatjOOyMVptMaCIFa1xE7ePGURVMkYO0AiA9w5NaUWmJDb49bVdqMUWe\nTPfhu3Kau00w9CXeFmFEig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa6CaOGMFUbXFbx3stMeDZ95MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjc5NjEwMy0xYmQ1LTQ4ZDktOWM1YS1kZjE3YWE0ODgyMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRrb+tFU2zvuLEh/ozW9Ry2GUcBXtGEon90Gmn7T8t8RzN\nAtm1a/fqCXi6JF5NwHhLIpwRt6/nCTVLoGo2ZTGNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUemzu+oi6sPLQQVmbL/cw5DD4\nvXUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALzsWA47TJRc6wvttW38h15OFMHsQlXnxs9IKXqkDry/AiEApi0t8oj2\nD4+I+SccuVtff30un0nKLiAdAecGKMxJ/z8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVsvlvzeQilaxeQ483k6+fhjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI1YzkyNWUtNTY4OC00NGFiLThjNjUtZmMwYTgxMDQ1YTYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTcwOGNlNDMtYTE1Yi00MTVjLWI1MGMtODQ1MGMzZmZi\nYzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj8CdPEinel3UynuWAKx6N31I\nTQrN+WfbIgcobrAetLBcBz6IY7SSGJoOB/GE0gCH/1yMVBRI44iiSZYgPsaH8aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUCrbRbgoj5hHnGM7DnFsHsvA+FQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBGKrdCcmkJ80QJASPqnCZoRESTICZC\nA6/lTKHMBa2JwwIgH/g6evHpRq8MErifLf1hRqyGHBkqQlYAiG1LJn6dNqU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4568", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4568` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISARYswtny5pn1UOopaTea0UT2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlMDQ2ZmU0LTE1N2QtNGY0OS05M2M1LTIxNGY4M2NlMjBlNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q3NTZiMmYtOGZi\nYS00Y2QzLThmN2YtZGE3ZTkyNmY1NjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOPMWiNclJ/62xpe4Dkpf6LJdqmrIHZQIxKKXiWLnjqsi38t8WjFtoilsoO7f\nMU4HuxvUL/fnE86Cq3adxxPZO6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuqG7O30Hp7wnC6r0cJ8mCv8A3vcwHwYDVR0j\nBBgwFoAULEkqiuvTEVrf4eM0yWgTtuyLMM0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIDBZ6qH21//sHjjNb25/I70Z0wWAWv7Nqy4NUlAgXXCTAiA2nz0y\naGjWsqc+CusIb5r18K4AJMFMr1f3GxQKgFE0MA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU7cTel08AjwNmgorJYMft8/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTA0NmZlNC0xNTdkLTRmNDktOTNjNS0yMTRmODNjZTIwZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+G5KSjYadxITsGhS4nDXRJB1ULNI7hjDV+9JM/igIOj7+\ndyQYdLesvX27WkIRf1eDZ46Ms6Asn44yN33mVAD3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULEkqiuvTEVrf4eM0yWgTtuyL\nMM0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIepXVvDnoWK8KAI83jxkOc41PblPAHnjOqQCLJurHBMCIQCP4Cuj/ZCf\nFA6NyDdN5ooj8eu9J9ijlUOFL/yxEbiMZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASc49+uEM2u2mw5ztcj3JDPcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q3NTZiMmYtOGZiYS00Y2QzLThmN2YtZGE3ZTkyNmY1NjIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2I3NWE5OGItNTA1Ny00MWY3LTk3NDAtYWI1YWE3MGMz\nZjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE43HeGZvgE4OufxDL3mZRtohG\nv1Eka5nYmPFFwoFgyfg6NWrwIFzzYfWl8kFoxn6/p4Pulkm9XoFVa4739lYQZ6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuqG7O30Hp7wnC6r0cJ8mCv8A3vcwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAlTVpNx4qtQwsw102eT05iMCV7F4/Y\n5T/NFrqtbfDs1AIgCH5USrI/DjBL8IOI8kItPTP61hInqa3T1qpLOhYj5eA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4569", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4569` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATULXYqmIPMTAST+sTEiD66hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhZWQ2MDIzLTNhMWUtNDVmNy1iMjMxLTdkZDBmYWI1YWFmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmUzNjdiM2EtZmZl\nYi00OTI2LTkxNTQtYTc1ODBlYTgyODJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4khmWGvx/7WCgwGhXC3VpZlTB5McjEHnJMDTyiqBOvOlsc06brlgEJroAIvK\nW9h4xjOliemxW1tYsNO8DVrVLKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+A8Oio8kHrfUwtlriNh+IGwXcfUwHwYDVR0j\nBBgwFoAUgPEDK8cPHnQBHvh6OaQ+4R4CLNQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIGZzOyYwXoO3k7nbo1RDskdrFDXqfivskiAotShm1FbiAiEAgsQm\nwGgXoLZjzidL0NkV9jp2vRrIwQOYx3vJNQI47mQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATG7bk/6etH4TAfjvPhwtOIbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWVkNjAyMy0zYTFlLTQ1ZjctYjIzMS03ZGQwZmFiNWFhZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuL82bysGx6ff+xJlGJCMDOdDj/ZfDB8uxGbewV0B/Ae3t\nd8v6WcGXpU6gjTKPS7pRFJAymyVk49Ft0gD/qdmXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgPEDK8cPHnQBHvh6OaQ+4R4C\nLNQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBF4llmtryniTAmFuuXvRNTy3AeREyvuxG7U+/vcdQ7ACIHoy7/9df5zs\nzXhq/OX1yrN44s1kVMU9DKZSxJEv4Xau\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAaCoFhtIbfRJwEjQApUss4hRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmUzNjdiM2EtZmZlYi00OTI2LTkxNTQtYTc1ODBlYTgyODJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDlmN2Q3YzAtOWY0NC00OTI1LWIwNDItMDhlYmE1NzJk\nZDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE36cnZz6R3chFFGjCGz21q7G1\n6B5H2Q+2LniClsfSex+2qjLbp0UkpGvoK7Cxp9Ss3GxFqAiwOn3hvfnHo7+D5KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+A8Oio8kHrfUwtlriNh+IGwXcfUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAHAfa57hIf01XhaOhCUphD+9KTyPuY\nPwbwrEOpwdjQEAIgBKScHzd6aNC5wYiNuRSJyvC0O/boNCTKfl6aL5c7p2E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4570", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4570` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUanr5F6chWj/1+d04xJESrYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczYmY2ZDU2LTFhYmEtNGIwYS05ZTU4LTJlMDUzMDBjMDRhNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE0ZjQ3NzItYjFk\nNC00NzgxLTg5MWEtNGE2NjNhMDNjYWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFTC61jIUT9IDReb1mOm6K4uJbPCYYEhZJi/ynkJ6L+NHXHKTR76h5vtawDIA\ndsmegxqgOIRIlvLA/UQKCrmG4qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQLlbLrsPrOIdl0ow5XLHf0HgWW5DAfBgNVHSME\nGDAWgBRdlnjHj0BuaEwngSq24Y13gS1biDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDWCWHeqdp1v+Lv1o4a9GpGkcsdxyuB\nRgD+v1fLS66L3QIgFgrjR6EClPx10KshMlJuo99SQn/0fZACQBmtbHkFSzc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAau3KuBA7huO/NBTElzdJX3sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2JmNmQ1Ni0xYWJhLTRiMGEtOWU1OC0yZTA1MzAwYzA0YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7/Z9S8PfApQXdSQ2yMB3+OjeIBelbsTzXH0HTyuy3Jdp1\nIzAl78vRf6qD21DU4sBQzo4PLN3ztQdM90rDfdavo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXZZ4x49AbmhMJ4EqtuGNd4Et\nW4gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgax/bYLjjU1flNcrh/YZxsbL8pRer74otW3UA0onkuCwCIAgmlckUFEr/\noFUi4iQpKNqOTANYw1TjbbeYEUMVdT8d\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAY1FdRCc/bo+xPoigrfkX3kQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE0ZjQ3NzItYjFkNC00NzgxLTg5MWEtNGE2NjNhMDNjYWM2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjA5MWM5NTQtOTY3Yi00MmRiLTk2NGUtZjVkNjEzMjhk\nNzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb+Eg+kAdHvjXwin9w4N1+VG+\nKxXPJqVsTRfxdIu7ZhwWNWyjvSRWQZV0BDwQRmWfz3kTh1sFNMygDn4bie07VaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC5Wy67D6ziHZdKMOVyx39B4FluQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBoorE3MRiUWIquY2YTGTdNptxZwuFL\n3wx8zrv6yw6ISwIhAKZA1pDmKE2Xgt9th+vB9Ac270ftSBeHf2VTK+VVW2xQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4571", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4571` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAcCZqStHMiJwSOe5KwTsJTFxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ZGI4ZmU0LTZhNzgtNGRjOC1iNzhhLWI4MGEyZTA2MWQ5NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjlmYzdhMDMtMTc3\nYi00M2MyLWI4ZTItODY4MTljYjA2YmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEElPbvBz1s+69yNZq6I+nOc57sOtg9iX6N85rV+7opCr1OtKEoi8RiPsYvzRT\npxz4tqQpS7zq/hpAle7x0yiskaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXyF7sEVd6iotn/Sobzm3OEHv2r0wHwYDVR0j\nBBgwFoAUnmym81AcFaw2cBYAh3kn3NLnVGUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGMlzDV8ff9e\nWRHuZ/341/QQHB6/c8KklYB8m7UcYFkvAiBd9aBQ1U97T6uBePGPQ7BEz5CU4fGC\nRI30EecCO4ub4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZJHaiQKDBdkjJhTNI/hrJY1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWRiOGZlNC02YTc4LTRkYzgtYjc4YS1iODBhMmUwNjFkOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpuNmanBOCVAtAHUfjlh4+VlIkrcyBr6WYxLkL5+sqZ5fB\nBCQ30MIjAivKD5AAeYyzkzRPRxUjqMxeTiFQQcbko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnmym81AcFaw2cBYAh3kn3NLn\nVGUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd0vhteZNQCtDIqCsQPZ4MuNNOeK5KMRHd/ST2wh9ZY8CIGs9GMcWVLcA\nsC91CE4ySJROjYCIDlWVsVSrIAh6mH0r\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASb95/ZU5+CKCy9fTSYMpI3iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjlmYzdhMDMtMTc3Yi00M2MyLWI4ZTItODY4MTljYjA2YmYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjBmNzUxNDYtMzM5Yy00ZmUxLWFiOGYtYTgzMjIyZTJl\nZDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX3LgtZJEpMsMBjQjki5Kdke5\n018ekvUESllhMsBUVFI3qFjYxBaMm8OJclfm1gCKGRig/2VcJctKWGFpvZHrjKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXyF7sEVd6iotn/Sobzm3OEHv2r0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBPYmFxQ7oarG0OuUFdrPI2AkPEwOaA\ntjydy5H/TLvlMwIhAI4SY/mHf3zIn/I9fUkes0Xf4ahfhWJBA/Aj7P6l0kaE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4572", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4572` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAdA+1Z1NJq6OXRbtPmtnp34LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1NGViYWZhLTRjNDctNDAxOC1hZmEwLWRkNDZhZjdlMTNmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2QwMWE2YzktNDUx\nZC00NTQxLTgxMDYtOGJiZGFiMzBmZTI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO3lEFTsgagFRRG68QZP0Zf5jt+ko9fwty8QYWuPCsmN3PaYqkKY9XpHfgLGK\nq0J5tkTSXSTRLmRYKMwQOn1JoqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUumbKGUrjen7Cq88u2e8Rw38pan0wHwYDVR0j\nBBgwFoAUKt/mZEJ7vfTwf3aqHuz5jThlGRswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCwYHNRsMI1\nYlvX9zDJw7y7zB/sp0tO/NvixA/9WSNROQIhAKDB62VAVDMhPH/wUQdaYyq0E/TY\nxQbzRlFRXMJiCP/Q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeKG7ah9ua4m3yLhMrpbWPGhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTRlYmFmYS00YzQ3LTQwMTgtYWZhMC1kZDQ2YWY3ZTEzZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQp31wxqwqBGXiX69Of17nN5kBU1kGHD2ddmXuFuJvv/57g\nkh9I3YBJ3d4z2aWEIak2ahUUVcPvwLYawM993yXCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKt/mZEJ7vfTwf3aqHuz5jThl\nGRswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMjkvG/AgasPLOycfQAng9UgbGJoq2WFpppU/ax0yAOkAiEAq5ygjakU\n9UpKGD3X50dRjZqpo2p5e8lfo6p6i7Lsllk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfyyZe9SNjsIzY0F1nK4afDvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2QwMWE2YzktNDUxZC00NTQxLTgxMDYtOGJiZGFiMzBmZTI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzI4YjFkNDUtOGM5ZS00NGNhLTljMTktZWM5NGRlOGQ0\nYTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESenNxb8hni8Wsr0H9zpdjwlB\npKhSp0VVLMtGrqOAJcZlxf9fNnpsKKzcGRl3ZEkM+w0OgD6zjMfAziETn0kY8KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUumbKGUrjen7Cq88u2e8Rw38pan0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiALjkANiYF9hK8D4ysPJeUlcBeE3Zs8\ncaagSc6AkOiTxwIhANV26v4gLg3LGkn5qyZILQAxhlC6rFGwPPTTTt76dGKJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4573", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4573` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAQ/IogVNRq6SgvDQG07PoBOsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5Y2Q1MzJjLWM0M2QtNGMyYy04MDgxLWQ0MDI0NGY2YTc0MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg1ZGRmNzYtNjM2\nNi00YzFmLWI2YmMtYmM4YjdmODA4OTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE11Z/FwkBPBY7aG1iD1JufZ92OpKP6/fP2h8NKKF5rlpSochypR8pT9Qc7h4C\nB3L5xBTHHQMi7ZfanrUrSH28Z6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO2UmK6TJEKYOhyXRhCW9cF7KgF4wHwYDVR0j\nBBgwFoAUuRlJuWMMLzSwO4DD7jl2T+iTf5AwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBpMOY62yZy\nnQumbNvmysuQKMXXC1aMuFSxJxfA6Q0qogIhAP+dshlh9cvYKMBCklp6P0XKjnCr\nxAqoAz1C3IiZ9rYe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVj35hUriKD33W0Bmewzb80rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWNkNTMyYy1jNDNkLTRjMmMtODA4MS1kNDAyNDRmNmE3NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDVpNYZZcwAYC+TrQ+lONe89IgdBmsp2EspyYiIH9RWUAf\nvVO9NzRsvmS93b1GeGeR6e+1nM9Tde9JcXkOY8Pso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuRlJuWMMLzSwO4DD7jl2T+iT\nf5AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJpAcv/CQyrQHzF3JTvo0plyghzpYs601x9x3dKABVHjAiAyXlhhnigy\nVuYrrTihTf1qq0Wy/OV9IB7hKfkJ6TddoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfOzIcxEwEmGkolL9zDUlEIsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg1ZGRmNzYtNjM2Ni00YzFmLWI2YmMtYmM4YjdmODA4OTQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2M0YjMyYWUtYmE3Mi00MTEzLWEyZjgtYTAxMWE2ZDhi\nOTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi473X7ezxUhb33obi7HQgvhI\np6whX/+3oJm63okx6bDbZSGP6OWPht2gcRupCQEy11ZkzIpBVJ2fTyOkWc+SZaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO2UmK6TJEKYOhyXRhCW9cF7KgF4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiATJ0ewOclv+IXZZI4CkUo1zgrn0hKV\nUO70NbJoYmx41AIgG9obxDV2WzeyAwwx7Gt+jDSSRocJYgKRvXaPkowbB1g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4574", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4574` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAYlqg87cpQIessp5hOlcXE6xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ZDQwNDM1LTBhZTYtNDJkYy1hMGM3LTI1YmFiYjZlYmE2YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJjNDg5ODUtZDY0\nYy00Y2EzLWJhYjctOTk1NWUwMjNlOWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFN534Umd7TvbC1OLoleWUH9N2QTi86gWS5k+t1gLLaNkeQivnRH3jrIYmMoF\n8o+9cAkX0GaUYfQFxT/PZacFwqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMfUkTb791M2Q24kQAzt7H2Xjf+cwHwYDVR0j\nBBgwFoAU1yL3NuynQVYcBAg9tnPBMq3EbCkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAhDl/iLTtnyEIXKI4RhqHKFAX4r0dIkfUP9EB1iK1hU0CIQCQv+6YRToW\n2s/abiY7L6qY9yLX/e3roDvFW8k0XN8NAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXJUwPnQdgN24AuE85euDUL2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2Q0MDQzNS0wYWU2LTQyZGMtYTBjNy0yNWJhYmI2ZWJhNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcCRqOp+ByOJQkkcKfxBDyo0ecNffSUHkCXzmjIj2KVQpg\nHhx465NdtY2qNiJrd6S+euZyUmrrLEkJq4Ugli2zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1yL3NuynQVYcBAg9tnPBMq3E\nbCkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOHzkGT8LF0Emvi0YapZgq3UouYFONpL5MgaqLNGv3JgAiEA1xaPDVYv\nKCaOgdFo731Tzsb0JPT8b86g1KEWaog1Nyc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbvtUnSHlEV8KEgjS37YX8PeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJjNDg5ODUtZDY0Yy00Y2EzLWJhYjctOTk1NWUwMjNlOWUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTgzOWRmYTItNWZlMy00OGJmLWEwYTAtOTc1OWYzMDYx\nY2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw/+REPxtAreeqXLfYRnfajbH\nlMsDh+KB4ktIPVvSHOz2JcNQeyRlofmNgbr3xjRG0e5Oy5C5MDwfgmYQIvPd8KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMfUkTb791M2Q24kQAzt7H2Xjf+cwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAw8fG+OB1CF89CWa2Gx5jUs4/Mi1F\nCIE6DCnyZxa2/6QCIQDWAewn3j3f05gmsYF+ULyy2DSCts+cvYa5uGJr/Gc0WA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4575", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4575` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAaAyyHi0mGWgde8xdFX+8NvFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1OGQ5MDUyLTM5MzItNGJhNC1iZWU0LTQxMTg0OTc3MjdlNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmI3ZjdlNGEtNWQ0\nYi00YjliLThmMTItMTliZjAwMDZiOGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7dAkFeH3zndFvNe0hGEVpvisXN0YlEoZhUT+iMOjx6BKmdYjuq9pYhxMVJRT\n4FYjVgqaUSX0DJRwWgVNcWe3zKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtmZr1ttRwzDLT841Mfg8j0AdOoowHwYDVR0j\nBBgwFoAU6RvX8BSp+YrUyBapJeBdHELsFFUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAIHAJm8/djp0230PMeVuX7xcg1N/xVTNeoQHRU5PwZugIhAKZNLuz298BJ\n3biwVc4rXFva5h0KPSvNYdd3eZLJWfBX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfppULZ7jrIF9aqaLvh6q3l1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNThkOTA1Mi0zOTMyLTRiYTQtYmVlNC00MTE4NDk3NzI3ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMtltReLVvVbTF9S4FgUY0/d3Wwdkn7WZ2cTuQTlN4fo7R\nvmy7mcHyDyCOc6hzGo6hHtO47AO7eIFc23n4y4j+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6RvX8BSp+YrUyBapJeBdHELs\nFFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJntbjna9fnyJqQepbvzMnof94xYTV0xANcPuXaswlb4CIGbZsfssvQEf\n0i8IvyFkcGsZCKpQtRUCyQKJ8QKrldrA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVSAY9XCfcIOWv6yiGCxsnKfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmI3ZjdlNGEtNWQ0Yi00YjliLThmMTItMTliZjAwMDZiOGNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2UxMTA0OTQtYTA3Zi00YWI5LThkYmYtNDVhZTVmY2Zm\nMDhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEStUI7sP7KPGLS6+1o48SOgNb\n34BfWHlnzyOgAr+8vQ0Rt68vqDpUDTpe7WyeLdEXKA4rfVeOIOMn8awnULfinqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtmZr1ttRwzDLT841Mfg8j0AdOoowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAt0xv2ZKDzCx2ZVdiTGSpzmiBvnKo\nDEgn2y7c8ynrGxYCIQCu4whHEfyeyzRf/ZyqJO4ohzVkiIJ1+I+DVJDJlhcYHQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4576", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4576` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAU59NEcSmJmzB773iSdelvR8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwNDAwNWQ0LTU4ZjQtNDk2Ny04NWUzLWM4YTljMjNlZGY2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzUwOTEzMDUtZGVi\nNC00YWRiLThjN2MtMzFhZmY3MzQ0NTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMJ1KnHKORdS1wZ92wmqtVYGed0oqwbJgXW3EPD39PuukNSXE8hMzG9vsbYlF\ngrZxdKCdDg1brsLu0DqPRVvlDqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtsv3TKsabwsAbZiPuSXNmEtAfTowHwYDVR0j\nBBgwFoAUTpt1sUVAroh2oEhojRXgrJpop/4wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAt\n5ZAddEA11xuGl7l6IZB6c+JhfWNAIQy3O7Q2+HbfwgIhAIiRCe9wLwcCQBppGRiy\n+NWe+q4+PuGwkb1dQsbhWQah\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZIdlkIQ0GfUol+MUQK94ruZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDQwMDVkNC01OGY0LTQ5NjctODVlMy1jOGE5YzIzZWRmNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATO5UqLM3SzGg+Zz29BCrZiCNUk4Z6FGbw+Yfi8TcyAFURD\nuzsGSd38jxaHgj7zjmYrOUAQ/AFfeL7/MlHgaJnvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTpt1sUVAroh2oEhojRXgrJpo\np/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANeczWNhdYXJh6ZteXG38V0rwhKjgHkjVnZ23fNPZHLoAiAI99brQruH\n1yxzGEhzzzCxMuO1hJfR+xPwci3VWj4jhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZy6BxX0RAgZLoERy2VXYiGaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzUwOTEzMDUtZGViNC00YWRiLThjN2MtMzFhZmY3MzQ0NTI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjFhYzA3ZTgtNDgzNS00NDFhLWJlMmQtMTE2YTI5NzNk\nNDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMulSUru9X8rSU1H2X/OMbbB6\n0jffkaoHl4FCIRRMznILzCpNzl9YGv02s1I0H3lt4JDDspl5WY+ciiPpqgSnoaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtsv3TKsabwsAbZiPuSXNmEtAfTowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAWgTeGAnFKQxnB1r4E7YmD1Pit0lBZ\nFm464p5doHIZOwIgTwCkl5tb1RAXDHTDyGSXKrOYuTivySOT6OTaUSZSRB8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4577", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4577` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZyQjIXwSyjAj3wOghuqiDrOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4YWQ2ODgyLWUzY2QtNDU5Mi04MjdiLTZlMGE4ZTgwNTRiZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJlNmY5MjctMWFk\nNS00NDVhLWIzZTQtMzY3ZDM3YjRiNjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjoXVeo7i9m2/quyB8SOBSRx/3QL9yEroUBc9BgUAMeSxP/e4XMEX9lr+sTnw\nllR2Pvi0R5jd4P0xqW/JdK4JM6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOKiSOEyK0DbBSE766m9VLzWO8iMwHwYDVR0j\nBBgwFoAU3dHXIgEHOyEvRU+Q1/dE+DFL1EYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiBacbN2RKNnM6WKj7rmzUzDGWFTbl46szc4G6lqxTp7rQIhAN0a\nThbErbr6Q8W9VBxbkzNP6GvRInWkzENvKj38rsF2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcj88Qt0kzy/WlD1uyCkAdR9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGFkNjg4Mi1lM2NkLTQ1OTItODI3Yi02ZTBhOGU4MDU0YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPx+WLX8N97cEhytr37FpnLKeXH/c0x6Wv03+DewtsWQfO\ntCnRyNfn4X7eluyytrNtwEew988eT5BFcWCnD+zNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3dHXIgEHOyEvRU+Q1/dE+DFL\n1EYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdcYItld7CYO0lSPquhietnYkGp0eSzbc1Hr8TSm2/NkCIBupGlV0elnm\nZx9PIJEDX+99snv/RYYdlQYo75JBsjTu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAelCxXapQG0OM/b1yTS/fdbnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJlNmY5MjctMWFkNS00NDVhLWIzZTQtMzY3ZDM3YjRiNjU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWMxZWEyMjItZDBjNC00MWQxLWIyMWQtMzIzOWU5YmI1\nYzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeUPK8Ya86tPZ0bJOqexD716f\nc/RFlS6g+1htIdVdoyAGVo3r8nkqN+6DQYRgfNAMsT5a4EDZtnWMzDJwOfdzhKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOKiSOEyK0DbBSE766m9VLzWO8iMwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAl989vgzSpbPgTnd2JFtYX+5EyWJX\nOkSYI3IvykRUnLMCIQCredekz9ZwT58L07CRaqjnCYEXphN4w4S0STv1fD1VdA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4578", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4578` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAbtr+EYeWiGKx3b35zdj/wBxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkYjM1NjVkLTg4M2UtNGRkZS1hM2M0LWIzMWQyMGZlYmVmMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU1ZGY2NzEtMzZl\nMC00YWVmLWJhZTItZTE5YjdkNGMwZWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEhdjHFq2NaccJ1Wei/Ya+RZyMcUcg4g9qDtmfI8pK5vkVs2LuAap5OUsIuF3\nTAewu/sSKah3Xe8BOqE7tTxw16OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO93a/kETMoMzljdT8mJZKOGGcpwwHwYDVR0j\nBBgwFoAUFWD3losOE8tg2sEvmyeLJ+Hmc00wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBwpluXFVGyNZSKwyadfypkdZUnPVjZSLTKwcyL1u0EswIgbbrW\nmhqFVmjBJGRakABDlRPiwE9P5wk4U4GNB18I8Ks=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARfmYNij3kEsGK5bxN9+sInQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGIzNTY1ZC04ODNlLTRkZGUtYTNjNC1iMzFkMjBmZWJlZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARl5d8ZPQr3BE6FpKjjoGv3XJTYIxrmFMffz5T0CuABZWzl\ngiruEoP0WKPWACqvBeqkM5JutsYj7Uwv8Ljf4yCHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFWD3losOE8tg2sEvmyeLJ+Hm\nc00wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJIx/ciTfOHP6u2g8pSDk0nRgVrXj70kPKaW1bNQtvM/AiAxnF3zMm0B\n1L0ZcheoIeXxh1I6m3u1VzNXaoeMs4hY8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUPJgieAuNta2t5/iIha4t0WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU1ZGY2NzEtMzZlMC00YWVmLWJhZTItZTE5YjdkNGMwZWRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2JiMDVmYmYtNGJkMi00ZTM5LTk5MTMtYTc2MDIwOWRk\nMjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4+Buatsc6TvaY2QWcQKwX6dO\nDoCOxnysYXG+7pGEmg4GEuC+GRlr8X+ZYxk1P3OEv0rp320Nm65An6tfaBW2w6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO93a/kETMoMzljdT8mJZKOGGcpwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA2FqZORPiTIANhJtOT9IWRHIUppFc\nQ5PsWz33DUmR2QMCIQDbsVpefQkS3ABVn7WxWLsmZqksS1nT9bnl59+0j6SK+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4579", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4579` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAZmQo/fFyR6EUHWsRWYmHS5yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyZDU0M2Q0LWY5MTUtNDgyYS04MDA4LTllZDQzZmNlNTIzYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM1ZjBiMzQtNWYz\nYi00ZDNjLWFiYjctOWQ2YjQ1ZDEwZTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuWZqI6UYCV6e+sz0Wb6+ohANLP2e5fCAVspX3EnYQkbVyrbvXqdDTj8MfMMl\nAB6DOdJ7kuUwyBQ9vWRHtSOOoKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYLB9Evf0Abalqjh4Gin+3sT84QowHwYDVR0j\nBBgwFoAUr9mp8Y9uCqNYlRJABRYLRbMrh0gwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAse9llNtPfhOts\nJWuCG5EJtjv6cRhodhC3itBDzDCiCQIgXieCItIzTJRgnx2a8C1KHSJI5tuZ64KU\ncoO3oiQe/hY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcFXAZ4ib25IKYRkrxUNlmRYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmQ1NDNkNC1mOTE1LTQ4MmEtODAwOC05ZWQ0M2ZjZTUyM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvi2lQUZHu8NOisOJwTFAA1eij5YMR1CNmZLKvFIqiH1nK\nfnUwBBkDZYgkSzMR5YIMr46lz7sq1jWYYRfoIjtio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr9mp8Y9uCqNYlRJABRYLRbMr\nh0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMkk2vwL/UPa0/XeUgZZEtaYQ35XxwtHm6fNt0pfUCQ9AiEAqVr6c7DU\nVSeL4EdXXH2eyPe6e5vIHoRvwGrAfi14cZA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUt+pv9qpdRBFfMm6mJUlBTXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM1ZjBiMzQtNWYzYi00ZDNjLWFiYjctOWQ2YjQ1ZDEwZTcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTc4MmI1YjgtYzZjOS00NDY2LWFjZDUtMDMwNDJhZmM0\nYmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElSCaHwUOO9Pz8rnvaWkd08J5\nGkyQVYGYMUeyztUR3QGJlZa1r75HKCuw/SsNWMU0hWGB0ur/v1dpQWKUor1U0KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYLB9Evf0Abalqjh4Gin+3sT84QowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAkQc17zk+HUedeRhIXUJvPw3LL20E\nGuFwB5ZcEWldIj4CIE7FX6aJTFnKlVr5/RBJnILGE8k8+Yb0WXBPvYy+/ine\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4580", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4580` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfmgAwIBAgISAcWV/43m3gy1zXMVw0BsUv/kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhOWRkMTVkLTExMmItNGI3Ni1iNDg0LWMwZmU0MTE5Nzk5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRjMDE3MTUtMjAz\nOS00YmU2LThmNmUtOWVhZGNjYmMyM2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERlhJMC9N8/kUZXg8i8A6R8BGklKVFdOiKkFkou3iciU9Oe0gUIHOXo9EgA8P\nf/Ola0HlsZQ0XB0oY/KQ2jBLtKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0hT4QZgEg4T4BUsbZjDrFL7vb9IwHwYDVR0j\nBBgwFoAUNMbb+fbiVHpPKLlaaA2ci3NFg34wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0YA\nMEMCIEXKIYpxfpke3Ue+jnzyNr/ITDq86nTR3Ix4nCn4VYR9Ah8Y+qbsqMuzS6rZ\naZbwch235oVP13bea1Fjb1LjnmjB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVwCTvUQTXs3w6e8lubGNcawMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTlkZDE1ZC0xMTJiLTRiNzYtYjQ4NC1jMGZlNDExOTc5OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVobwiFdSSG0r0UNc1/UyL92JiruKQxNhLaVt2gHMcFD3a\nCnycqbvVmxnPcTDDRacgsB7oNZ4oUBhnCUtVPxzfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNMbb+fbiVHpPKLlaaA2ci3NF\ng34wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOWaVtnxi6tS+FevFHhmJTga9jMoZAXDOp8hODXRYWQICIEFlWi1EMTek\noxF6Ll2FxaTdQzQKISfpc/tRe6/I3S/n\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVG+eTswej9GBp+TophZua1bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRjMDE3MTUtMjAzOS00YmU2LThmNmUtOWVhZGNjYmMyM2VmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTU1OTdjY2QtZmEwMi00ZjVjLTgxMzUtNzg1NDA2ODQw\nZjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyW+PfY+fSNfRTOO+K2+DvCKP\n+j3N/gmJoVQPAAR5rQsMYsG7jl9UZUkJApbOk5RrhxD3wudYUQ+fLR1IQSWSV6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0hT4QZgEg4T4BUsbZjDrFL7vb9IwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA1TBPRuNmfSqD1o6PAjBdJq+bgBau\ntmA0BYZq0s4jJtQCIDDp7z1Oe2LI4G6f5tZq4u9/cToY1QWovl2DcuIYwCvI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4581", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4581` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeoHEoWrzvkB4WfUj9y+fQtJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjOGZjYWY4LWViMjUtNGQ2NS1iNjVkLTdhZmI0NmEzZGJkMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg0MDI4ODgtMWZh\nMy00ZDc3LTgzNjQtZTNmZDdhNTE4M2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVNj1Y1QeIEueyW1IDgvO32v+u45IK+pb2k/3vOmgwQo5hc08dhQEv3ENJ75E\nMcw4DgqO2UzxqBlm3aW1BiGPPaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzdrl5Tf9x6gZjdV6qj6w6NrDsccwHwYDVR0j\nBBgwFoAU2p7hRor6G0w/WfrwDBf7ektEQx4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDs347PQwHxj0T6wrhg9vN1KR7JQKQ6ee2Wtu7VYRu5KQIgVxiPn5t1QuVO\nrmcP4wf6AREv6AjMAbKc0HgVMF0275g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbq+5gYf27hGMrBD2nkHNOgFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzhmY2FmOC1lYjI1LTRkNjUtYjY1ZC03YWZiNDZhM2RiZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFwudxCXkuaPwG3JUi8XKsXFjewkLIvQ093zWSPqahvd5C\nK2qBX10L/ofHEmsdahr+9BVzGRoyoFhU+T8pVDkoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2p7hRor6G0w/WfrwDBf7ektE\nQx4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN9L6Gl+m+Ud6HP8W2ivf+jy2cnZZ9O4weimRsFZJavaAiEAxqVO/lq/\n20nNvez2eNEPIpT3MYFcT5sRij5rhqwQako=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdZaCalg1pxfJ+rklFqZFGr2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg0MDI4ODgtMWZhMy00ZDc3LTgzNjQtZTNmZDdhNTE4M2NmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTY0ZmE5MjAtNzM4OC00YmU5LWI1YTgtYWExYzU2MmUw\nZTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvQeC75Qh0QI71Bxq6tliuQWi\neVcN8x4TyHJedkLlG1GBvBPPSSZhgZPYN5ohExKCBwyNYYNA8ocdEwfeg3Ch1KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzdrl5Tf9x6gZjdV6qj6w6NrDsccwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAxOgeI/zZb1CaOHBSURBIIR4MrVGJ\nWm/bPp2FvSEeZ6wCICBKWssHoZz4Hbt1IeX9EW8HF/1KesfKPpfibwf3im+R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4582", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4582` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAd6SN9d9OStilvNalEQwPf4KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzY2RmNTBlLWJkYjMtNGEwMS1iNmFlLWQzOGJhMjdiYzNjNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VlYjEzZTktZmM0\nYy00MGNmLWEzYjMtMTkwOGI3YjVlMWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEdpAmCuySukn+OMu24Fci7sALUV8xfUsVWgbGU9sg8jH1hJdz+h/C/urkcja\ncp/uEU/3lxHAxTXOR85C7zyWSKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzQ5MzGZJtcC/UrAK010WCCY8RE4wHwYDVR0j\nBBgwFoAUl+Jgs3zybkzIOJnZhVrfHClM+yIwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBd23dRaf4IC0C00EpZSTRc29d+r+c53Fag8dF31RS5mAIgOuVyyZo7/cZb\nLn4OTqu8os4sKGfMCRycw9aJ9Ep3G4Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfy8hA9cbZAh88YhV0YaqyumMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nM2NkZjUwZS1iZGIzLTRhMDEtYjZhZS1kMzhiYTI3YmMzYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8lUHoXQUIebYCdG0HH3vxWszZVaKav7NvdSM+6q5F9BYY\ncgFrtGqWX43XUJP7UsO7anLNNGEHpIHvP7Q6phe4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+Jgs3zybkzIOJnZhVrfHClM\n+yIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCrnhcpgyI9fdQseNmuAC3V9cMOjrQMpBNXetJsh21SsCIQDkImIeMwR3\nSZzvJcoRrYeA5TMxcdUGdTAfz67ckPWyyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAValn+b027RQJD7P/EMkbCZRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VlYjEzZTktZmM0Yy00MGNmLWEzYjMtMTkwOGI3YjVlMWNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQxODM0MDMtNjdiYi00Y2E1LTlhMGYtMjU5NmRlYjUy\nNTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWTkHPV0qTXrGjCgD0DJ6BPYJ\ngPTn5p88Pv37DDK7yrSzolmDqVi0STCOv1QWpjAWQN8RuYa7wcdDMx9OhGjqPaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzQ5MzGZJtcC/UrAK010WCCY8RE4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAVqMk+DdOtcikVk69aKZcJ12Wzduox\nc9a5VOXyRWEW3AIhAKAeSSNDP/U2CvEtu7zUGAV31aa1LJUilNuoXlZrACet\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4583", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4583` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWj7ZFYcF3sctV96SRg0EaRFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwNDNiMjkxLTAwZTktNGFlYi1iMDQ0LTJjNmIwMjgyNzNmZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE2YTkxZDktMmI3\nZS00YmZlLWE4ODUtOTE3MjRmM2Y2NDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEew/ZTa4oKZ0eEVERezH0xNcfx2hb+8Xz4Eazl1oCN+XP4wl0N1BPsGh+lShG\n0cXCvJY20h7BOaG6YZ8sV0dYpKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU//DUQ/oldikJdm50LOhd/jW1aVwwHwYDVR0j\nBBgwFoAU2gNPzao/A5AOiNdH/K/WA8bXRT0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAwd+KzBT9sS9P4Iczr2A4LAUvRpS0sMEZx5YgwseZ\nrKICICj7DgM05B5mpBhX1WofZACpm0/yi766Jrwk0TOZtOnJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVFaLyyaviLrvl2jDFz03u2PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDQzYjI5MS0wMGU5LTRhZWItYjA0NC0yYzZiMDI4MjczZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhO2M5TxJ5TIUHt2O8c05+0PKjHWfKhN/sPizgyn6g+BWE\nVfZw7DpyZdz9mb8nRkPiZosl7YBfMOtigEoOLELeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2gNPzao/A5AOiNdH/K/WA8bX\nRT0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCWGooWCdsZcTVQP7biTQKqgI88/UhE6JVeu8/30TpMoCIDrsJxEOKeND\ntKRlj7hCM4CrdufUskNa9XfBtQt/Uc6Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATEdQr/1SaAG7Fa9riAKp7JYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE2YTkxZDktMmI3ZS00YmZlLWE4ODUtOTE3MjRmM2Y2NDZlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTUwNmU3NmMtNGFlZS00NDM2LWJiMGUtZGM0YjIyZmNm\nYzE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjs8C2EMPVfNyPYchKxY/syHv\nF7i2CStk5e4yJwDbrCmRgbsyG6SnHTWgH+Q11n0CCWTDIl79gbSG3rid33NZpqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU//DUQ/oldikJdm50LOhd/jW1aVwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAXCBcxlJZZfAE9B+c8xXkFCFFFYAkC\nkYQMUZY4TLqHTAIhAN1uv7BM3Ww9aGmQsZYvo73vd+9E0X2SyeI9vwdnRsBP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4584", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4584` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAQ11GijexkJWQC7nTMJUFW4XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZGUyYjM5LWFlZTktNDdmNi04ZTRmLTBlZDlhNzM3N2RmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdkZTNiYWUtNjM2\nOC00NjFhLTk3MTEtMGI5ZjYxYWNmYWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGfUq1Lr0LqS/XPuwbn2E0a6zcee2+Bt5olFf+K6jo8Msu07DMqBV3ffHFHxl\nltfkavqk6zjGhyJtLGvDPjYnXaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPqv972ABFY64rIkriCHhyFtDJZwwHwYDVR0j\nBBgwFoAUt7cQ+Gwvuoi9g/csJwiW0MWe36wwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBVW6PvkivL5zIwwUBK9SPkBNNOMEPcFV2PXuhXXcz5\nXgIgaP5WOPo69F6kVmdasHMQW6cNYFixEq+Fpr+nYcA2RqQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY5jn2nWjeLnvmmRbY6hFqjIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGRlMmIzOS1hZWU5LTQ3ZjYtOGU0Zi0wZWQ5YTczNzdkZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARorgJFKqkmNGvz7L2ihJDgV+oo6HrEwA4Y3yPpEpJuPd8n\ndlo5L2ZtkpFZfVESrjOKjBoXWcRjpWDO65nx0VkDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt7cQ+Gwvuoi9g/csJwiW0MWe\n36wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeBc6jdDe7vB1aknaIfNKC6+deshPXXLZBgLfx11RU1gCICqeGuiZYYV3\nHeO2NoN2STFyAq34zHbH7BMAQ8FO5dsS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcuQwZ2+0RXL6A392KhfZ9YeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdkZTNiYWUtNjM2OC00NjFhLTk3MTEtMGI5ZjYxYWNmYWQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ZlZTFhMjctZGM1NC00MmFlLThiNjUtOWY1OGI1YTNk\nYzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGopAB7l3XvwF0Yk1MHIM19LB\nPb0UDP4cIfDGmVIF6E63C2303tCXYbC0yd73yA2EsS671tDiEQGrtymowCL6+qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPqv972ABFY64rIkriCHhyFtDJZwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAloPmuSelD1o5kx0IGcLDBhsT3GgN\nbk2h8A5oQq+QR7ACIQCsRae3NzS4fvOcaWvITq68ipVfHiTVy7em3bqTghc6LQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4585", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4585` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYuZEGtNXkozp1Gbbtcuq9mAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5NzU0ZDA3LTI2OWUtNGY0MC05N2JmLTlhNmVlMjliY2Y3NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdhZjMzOTctMGQ2\nZC00OGI2LTlhNzEtZjI1NWQ5ODZiMzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVtkI+zyErXwnm5bswMHICmOcf4xMyeESXtwNKpoQ8RNSuW0pdtVbGH/sdKvx\nu/iCNBDF2GPri7WlvXRGTuH+AKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUCzjlhuw5JuiUrxsa7hyXK763VgwHwYDVR0j\nBBgwFoAUVRtBsIBlZVV93ihAfxAEAGlqyDMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAqYvrt8jjo3uGP5BI3ZrpYUw5HMe9R8Cv20l2eyAhy/QCIF2r\nSwysvUPQ/4p9qDmYVdknTkHPYlf73yZLUuUJVMHn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf9hskF1AmosR2KtvdN+doL1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTc1NGQwNy0yNjllLTRmNDAtOTdiZi05YTZlZTI5YmNmNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk1Yv/YjmdAMJzj4/8pJx063xibkpNZ5GnuLl35a/+MBxC\nL00431gSAV/0z5FcpNQqXrKbBohb60bl01coR3rno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVRtBsIBlZVV93ihAfxAEAGlq\nyDMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJFmrgYY2j6SnBP2xbFIuvZfTGZdcsw33Ve+bJUvFsrxAiEApUphjkch\nFWQcxGrOPUkje4j/FhdcJpsKDgwqS4aQCug=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcZBQMh2LeWMmilxRWIvWkkHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdhZjMzOTctMGQ2ZC00OGI2LTlhNzEtZjI1NWQ5ODZiMzE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDE0N2ZkMGEtYzQzOS00MDNlLThjNGMtY2M4NjdiNjE0\nYWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjtlRTArWIzoxfAbN+9GW5rZY\nZyB2I/zDxVR10etzHDxmO9je0Jlvg1N9gN69YZvfuJNel6+kUyQPMo7eT2gueKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUCzjlhuw5JuiUrxsa7hyXK763VgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiB1WEgMFabDcTVY0FA4NOj0ETGF6q+o\nHYZaao3rXcjwfgIgXOKVXkW1oIzIllbO50c6ydKKuMFb3BF3HisbUO9FDM0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4586", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4586` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAUAQc7zp2QkX6IfU786I3ZsjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMjExN2Q1LWFjZDAtNGEwMi1hMTZlLTdmZjA0ZmIxMDMxZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM3NDYwN2MtZDQw\nMC00MzQ4LTg4NjgtNTkyZjgwNjNkZjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBxmFvZJpohoBdPJpjEnOb3bfwBu370vQVmqPD14Guj1F7Oj/QYE4TQZVHbrt\nXjP0Fn2mV9/fRuabKwORcifxzKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCWCazjOwb7Wo54qhdiSoltzZWKQwHwYDVR0j\nBBgwFoAUUiobzqEFVeeasVuVSoQ9J5wMHKYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA7zxPRPOBUXlnY+C+na8zo6WGhUW5iZ2i\ntrh/GGKJG68CIQC32UeWJ8FqfyzhVRTd9gSpxcTn4Fqs+W+0vF8FDi+2BQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfHM68lZZlWSvQ51sa9z3qqBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTIxMTdkNS1hY2QwLTRhMDItYTE2ZS03ZmYwNGZiMTAzMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHOdrNgyd3CEODbmQ/EDpgOtbsFl8w5kIrNQ9eVVMyNPFf\n4XMizmCDoE0U4OWtn8klVePrBUC+WXaJ+fVVgB3Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUiobzqEFVeeasVuVSoQ9J5wM\nHKYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW3Q93JN+qrzDj2U8TYDcT2iBjAYKkPRUIhoaqErYcfwCIQC1f7BkHEb1\nXODOIztOfS2br7eEbdGgDLBOwYN62xTelQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWQZwD4nKXPv8jT0PRd2gtm6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM3NDYwN2MtZDQwMC00MzQ4LTg4NjgtNTkyZjgwNjNkZjJlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjBiM2UwYTgtYjU3NS00ODdkLTk0MTEtZDUwZDRlYTlj\nNmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEojjQeQWIY+RCl1hQlalHYiqy\nS/2+8g6Dn0thUvSm/UtwvZUGx2eIEIHJUZX4/EQ6arPdHTHp9Asila2F3Nnx96Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCWCazjOwb7Wo54qhdiSoltzZWKQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAlI9X/buBojLY9A3qAAFKTIcyVcEm\n1Shj/9LmJ40E3cwCIQDSuDC0G7YxESssDIrBleA9TAnIQf2Xh9w6aqBiGWkSFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4587", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4587` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAeDgxulB4Ze6ojV4M0qVTMlZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkYTQzM2U1LTRmYzQtNGRlYS1hOWY1LTVjNjdkYjQ2ZmRiYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ0MGZkYmEtM2Y4\nYS00NWE1LWE4ZDMtNGUyMTllMTc1YjhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc2pWYh8TX8Yn69fHCtsJ8fC0HiHW9yHtvX/RazU/DOMUb69IdRyV+eM3p4qD\nr5/li7ezFg3FM1PgaJUAN6ZrjaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHOczoVkV886TcDcqowlUSGm7vngwHwYDVR0j\nBBgwFoAU+UcSsQvWzdszer4GLrTYA6BbM+kwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBWcqCKczbsYjnFUYhgBAobuxIdS6ayZ6M+\n+8MJjVfa0QIhAOm6He2E4mKm384IzotfbdKMINjiLUn2FwTxeuYAm3N2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATcYiYSYVeLrCRpAV63qAdMtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGE0MzNlNS00ZmM0LTRkZWEtYTlmNS01YzY3ZGI0NmZkYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnVOkckWa9uwcygpD+iMFkAMBR9MKKqnJ4a/XhxJRUJSJu\n4cVjQfqIJIEWtBKViwooGcSkMrr5d3avE+z0lYeMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+UcSsQvWzdszer4GLrTYA6Bb\nM+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMm1RbvGbtYqyCzxgSGBJMLfNuwo5sexx5MXmn4vrTo0CIQCw2GEAjOqG\nxHWBl+L1oi4K/Ts46OGLJLAxgnFx72DclA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYPk+LwDcN2wKQsnSEARZUWrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ0MGZkYmEtM2Y4YS00NWE1LWE4ZDMtNGUyMTllMTc1YjhkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjI3OGQxYTMtZTViZS00ZWIyLTljMjItN2E4YzBkZTlj\nZDAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwou6OUL2pMLrnumpR2My9v+/\ndlS2kpyZvKoEC1N9syQUJ9jGsrDK1fyFu05jwsQNXePeIleUc/8bDzQ+vhUnvaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHOczoVkV886TcDcqowlUSGm7vngwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBTm+GGFg0Tt3iQke32thl+uA1DNN92\n9DpnmIUH2oamcwIhAIMCTxN0qTVr0ggBfWj/w6FYzWBX1Hf4BgzkgKrxQkV+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4588", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4588` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAamyKpryfQohsKLhheiYZ7wnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmMDhlNjdlLWU2MmItNDVmNi1hNjk4LWYxNTc1NGQxNDQ0ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjIwMzE4NzEtMzM0\nYi00NDJjLTg4YTAtN2IzYjc2ZmY2NWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEafQrbutZR3rP+wkZ95NhEBx9r+qmb9cXqZY3DnMLKjzk1zd3718je6tUUNvd\nL3Yu8iiJX4QCpjf1wWrKgidaRqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIdKMmEwVh+DWxW+nXHMUEjS6P5MwHwYDVR0j\nBBgwFoAU/w35IuHIAsHzQu/6UyBKX5eetHQwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiARiSzCSX7I8vGL\nlK9lBKs74fsZdl4Cm9RxqveYHg8MfgIgEiF93gmSpOJz4Za+5fxGfflDfcGoDTev\n+qnlneKxNJ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXqk9V6XcVSeEfqOaMSD9hIWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjA4ZTY3ZS1lNjJiLTQ1ZjYtYTY5OC1mMTU3NTRkMTQ0NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk5fMqbae7AWnWYkPCNjpXXbsbtPPzopZ0VcVz3I4OP2uO\nYV0Ftd9L66J0ifTPqM5V6tWLf9u9jHkJWL+A1D/Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/w35IuHIAsHzQu/6UyBKX5ee\ntHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJvuIvaDVEHtnbzcGqq1hejdFNF1jartLKDHb6H2UjNECIAplgZH2yDuz\nIkG/e7dRB6i+s7hJipXCxYK823v5a4Fh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAf6KuwGmMA7Lmn/+xYOs9isVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjIwMzE4NzEtMzM0Yi00NDJjLTg4YTAtN2IzYjc2ZmY2NWEyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmU4OTIyNTctZjMyYi00MzRmLTk5YTAtNTZjMjNiMGJm\nYWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp7FqRNbp35p8S913vyNzhSQq\nzIbDLvj3jEALNAUMboiHXsoWCMpgGw4fVTAxw4+/bBsDsHXe68mujrQxj81uR6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIdKMmEwVh+DWxW+nXHMUEjS6P5MwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA1e/ifqnaBGlW7Pm+1ge7HtmAUP8p\nmsQLvY9CErQfG0sCIDABvXMsU6uMWIADfaYjMVvsPDBTG4cJR5BmoojwpM6N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4589", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4589` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZcZ+HyQ7dGsKdvHdQIHHZ+jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4OTc2NTk0LTc4ZTMtNGFlYS05ZjRjLTJmZGRjMjgwZDhmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQwMGM1MzMtZmVk\nMS00ZDBmLWE2ODYtNTJkNzc5ZTFkYmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIlOaz26lzbOxNtrvX7+9NvZirZ1N073wMqgh/rRRyB+4DoF8eOoexpJGw+WQ\nQTfZKmwkD+DP+4BDwLKQIWCHc6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIXGb5V0gFSVxIUynkLwxsxxjpIEwHwYDVR0j\nBBgwFoAUGJR1muLFQ64I9+Wl8sqbKcv+XhUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAhOOnLueyKmTzIT5f7mD390GkLJGTBid6kPF5e4et9+AiAYXN56KpLE+GeV\nt4MFBry/wRnAWrOfyz4RbGu5jbj9mQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdV+uNOu5AWuLtCMhpOCJAGdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODk3NjU5NC03OGUzLTRhZWEtOWY0Yy0yZmRkYzI4MGQ4ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd3LBriTHcpQlsZ2asCRxPSQxJIo5WnhoDh1xdSytSJAZk\nC/Aza9YAvIiy587LgmfoowCvdz5eiDs07nBSs9n1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGJR1muLFQ64I9+Wl8sqbKcv+\nXhUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI8NbNzKs9GDcV2+/6EbMOUZeOytHb1RnJOvyCb/C9IwAiEAy5xs6k9R\n7mMNfntLPgDaqpSurGtgKmBVVPAxvWmU54E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAR5tbQ02eNcyea6GeQk/bzUAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQwMGM1MzMtZmVkMS00ZDBmLWE2ODYtNTJkNzc5ZTFkYmMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY2ODhlMGItMDE5MS00ZWJhLTg4MmUtNjk0ZDg4Yzdk\nMWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEd8v9160qIid0GpnnueNSAlBk\nD7Ed2j+gMUPHbq2sMykJjlcCuHLX+pVA8eNmthGI7AY9fGp/XwnfQ3xDeRkFNaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIXGb5V0gFSVxIUynkLwxsxxjpIEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBQ7xnodw8VB+dEQBirIBABA940xRid\nkYWckBVTWCgbmwIgb5gXbzqEP1g7lABLz8saw1lm4nj1D8NkyTdB6JN2KLw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4590", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4590` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVaD5hc46uTX43787F3R9BpQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczNTYxMDgwLTI1NDktNDZjOC1iYTE1LWJjYTRiNDA0YTNiZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRkNDRmOGItYjA2\nMy00ODYwLTkwODUtMjI1ODcyYjljZWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgbHVFmdUnyDbxRi/+RE1Ai1a7btxmi1AqsiZm3Xins8K+Hz5Xo9A42sI78oO\nvFLnCTGC0h0wfS2ly59W0kAeyqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoXAb1Bj0OMVzcsqcTwp4+Zr8JeAwHwYDVR0j\nBBgwFoAUER7Amz27biQ6dq1eMu2HEOwQjZgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAN1rnie3M2co6R/VSkSEhlMBOoHRynkNYAm9FB9ttR3AiEAqtgCaxh52rhI\n+yxu0olToXk1BtAgHuZVJYKG+KBVnz4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ0G5p5UhJc7Xkb3wYYf2zquMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzU2MTA4MC0yNTQ5LTQ2YzgtYmExNS1iY2E0YjQwNGEzYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1LaIKF9tiZiFXLrWLS7g30b30nTKFRHs7rz14/M0dcMdc\nWIxYh1AroH5HylLEyer9X/DvJWBuiaUHSPOffr2Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUER7Amz27biQ6dq1eMu2HEOwQ\njZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIhuzt4ifXiRtzjOpCnlii+/Q5pZm/tIPDz1zawQ3kMgAiBE+D85UT1y\nozg7QdIDHz3Snff5e5blZD5I3ISSW1jy0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAa7oXj8flVY5NMcqEC6vHyqxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRkNDRmOGItYjA2My00ODYwLTkwODUtMjI1ODcyYjljZWZkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTViYjViYWUtMGVlNy00ZGY2LThjMTAtZDJmZGI4NmY0\nODdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6uJHLSPHGg211fg5vHYLse0r\nil79nBrjXlSEejd6eI2HbGX+WN/NQxV5vojZmq4HYT05zOLC4ABwpBXGFrfpIqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoXAb1Bj0OMVzcsqcTwp4+Zr8JeAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAjJW+p4uBvjEDoucn6vQCEgzoMETW\npNyid4P514avJnYCIQCb6tzj9/xE4/ehYbZzoYr8+40IIB0pRELfm9PpQUEy4w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4591", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4591` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAe1KgPMVEYHe2sw8vWHbeFQzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwMTdjODUxLTBmMjctNGM2OS05ODg2LTE5ZDdlZjM5ZDdiZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODlkOThlN2MtOTdm\nZi00ZTk2LTkwMGEtZTIxMjY4NjliYmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyO3VvrEIB9BipDFBQ24MBfj6N3AJNmM50baPja7tRXCQ/NRqrYVnSuWLu3Mm\nGM0En9O/kxS1yfO3fdIAznIqLaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJcv5kGCxn/Af15KVgR+cTuY7oLgwHwYDVR0j\nBBgwFoAUuERcQHqFUT1PkVdztwymaV+FX14wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBaTsUzAW17jj93VsEjbqnLe4rbFHKZTm1gcbmBDYzU3QIgZiZmH3DzLh7g\nwk7I9u3x97A9JTSK5zYaz48YO98eFnQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY3NmZDFNQj6hKPabCKm069QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDE3Yzg1MS0wZjI3LTRjNjktOTg4Ni0xOWQ3ZWYzOWQ3YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0OAXYCl9MgIfAlAzT5wosVMWqsuooxDn86FAObeEm1TB1\nl64X8sd1CJwV1cW1au5DhoibYbdcViB6Xpykf6zOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuERcQHqFUT1PkVdztwymaV+F\nX14wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALo4hmOCtGuB0KNYGQHYE5HqgfoR4GbrufR6CT1VejcCAiBkCfk3C/Rz\nmsVMyap5FGBWJ5NKqO5KSkVbyxglAzye0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXaHGFhD3JNoRdkA9VyYD3swMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODlkOThlN2MtOTdmZi00ZTk2LTkwMGEtZTIxMjY4NjliYmQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2ExOTg0ZjItMDkyOC00MjVlLTk4ZDEtMjk4MWU3MzU0\nN2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3Hy/WBkbEx0HZLhPDlvIChCG\npgJZgm3JBBn0Ak2JUHVVrF06oPCnwAK70yFjSX3S7cw+xCIp9B4ckI8T9MsxeKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJcv5kGCxn/Af15KVgR+cTuY7oLgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBL9F+KzDaRAQ70EQn3BjdVI62M6Dmv\n4tpE26xfsH5tawIgeS8/I9FJBI48Xf3F/k3gUG37mVjGEsmZuLqOxmCg0p0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4592", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4592` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAU6kba3b1tmurgfCTdxg+4oYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmNmE1MWE5LTY4NjAtNDQwOS1iNjcwLWM3OGI3MjVjYTM3YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU1ODUzNWMtZmZm\nYS00YjJlLWE3YzEtYTNjYTBhNTYxOWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs8f+C/sHimhYynOEIpSydmOTc/VjCt7CzMlD5qmFZnurJP+GNh1JgU1Qxryg\nlrIEnXZz4itljET/XMtt3YFg06OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtWNRO4+k57Uqn47wwKrvUOb48j4wHwYDVR0j\nBBgwFoAU2cn/YMrjLd4OlmMKmUj5ImEWWG4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAvcwxVo2gfZYwdLLIdmd7pRVaxg/3gJOtuOiRT7/jY\nDAIgNmtIsm+YWjFVhHRI1S6f4spG/bFxlBGkWzcJh4SmQVg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVGANbvazZjMICTEm9G5SSsWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjZhNTFhOS02ODYwLTQ0MDktYjY3MC1jNzhiNzI1Y2EzN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSq1fWqFv6a/8Rw5N5JIsXLTeR67ikklI2k+T9e2nDNgA4\nU78cz6M1O+p4JV2L9DynqWyI4x7T7mDsw++vjvamo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2cn/YMrjLd4OlmMKmUj5ImEW\nWG4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOQgMrNlYommsDisGvBwG2S3aRKYQMySsedXgO7cOcLQAiEAkY9DNx5D\nhhb+4we86Yl7IZKUQZ5Hp+Jqv/CdWBSZUxM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYRWqvsr0QyNtes7a8JvawkgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU1ODUzNWMtZmZmYS00YjJlLWE3YzEtYTNjYTBhNTYxOWY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTE0OWE4MGUtMGZkMi00NWEwLThlOTktNjFjYzZhMWMx\nNGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhP15V1lA7ir2UtxrKfrzAHtn\nM/nkBrfOlDLUNnmP0WKLyHyLT9A594NZBoXzDXWj8oRE3R2YCHBz8ksYk6sPQKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtWNRO4+k57Uqn47wwKrvUOb48j4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAqZbBHtg5td2+l8UpLEXykc3mpaVe\nc+XG/17+yRR0TPwCIQClUwoVRyOtv0K6FG1eDbdQOJ+fm+kv0kOuPDhg0ctsNQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4593", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4593` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASKMOzQEx4zEcowVJ37uIOEeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyYjQyMWI2LWQ2ZjYtNGQwMy1iOTJlLTRiMTA5YTE4NGZhZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI5NjU4MzgtZjRl\nMy00MDQxLThmOGEtYzAzMDk2MWMxZDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoVjlK+vBSUpl9IeZ25BODdf7MfbDjOBMv161l2fUwuiyYXl0nzWK77yfUean\nlyuD6MFpZ4kBiJ3Xsw/2VS0FT6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0drCDPcvD1/H7nPiome3ZFujy84wHwYDVR0j\nBBgwFoAUygbidQfCVIjZnAdO89VuZ1mCQIAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBUal7cS70em0rjJoll6fRbZ7J2FVV5UWSL9raGor2F\nRQIhAL/DGPet+X9QGy9/j3/Ww/IhOqzds9fcGbo5wDHmr+hc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS7LRI/hi7LRH7UaaH7VRocxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmI0MjFiNi1kNmY2LTRkMDMtYjkyZS00YjEwOWExODRmYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2oJPqEzJXnPwbc7QTsLmdobYyhHiHhKrcE8S2KG85eMN8\nAh5jOUvsBGOy2HP5+6w/Bc0kBlaf6UYysFP2ed9Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUygbidQfCVIjZnAdO89VuZ1mC\nQIAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY/1b2dFSXuiizYgC0PvtWl7OJJ3aC2zrc3Sb6ElLGNsCIBD8G9/3ekRz\n4+mZspcSxkHn4o2qOhY1tksl/qDbk45i\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQjVNgBnGLWhQ7WBihEAXr0uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI5NjU4MzgtZjRlMy00MDQxLThmOGEtYzAzMDk2MWMxZDU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTJmZWQxNDgtOGUyNS00MmZkLWIyY2ItMTVlY2M1NzZh\nN2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZIid1mARm82G92bmkdvt3sfh\n3+TmSek1mUsklWh+nrHTP/qhQRyOOi008h4bcrA32loXOpYGkeCh2ZLEYNTA4qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0drCDPcvD1/H7nPiome3ZFujy84wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAguQRRGy5EnAYIg+jahtWrW375pdz\nejUfQ7cHJL/EXGQCIBk9YzPr3EsgzsL/Ye/bksOs2y78sZZ96i89qgcXgc0m\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4594", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4594` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAQR09Iy3ztJ26Y6umBMpcu3qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyMzU5MjM2LWQ5NmQtNDlmZC05OTEzLTE0YzM2MmJhOWMwOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNjNGM1ZGMtODRk\nMi00MzdkLTlhZTEtYjhmZmQ1ZjEwNjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzx2gAvvDucu8dQ9L+MqXh5lwuIn/KcSw1/RCyguf22Jp/SDgOt7g4bBkD37k\nqC7CLSmSSvXXRW2Lhz8ewbtagaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXdYNAWWKBSVf2554sbTIIg8InVowHwYDVR0j\nBBgwFoAUacJ1ctAQelYq4wVaR3nIeY94WHkwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBoL90XdLSlsR4mImUh615bmaF8gLGjmDmWJN9GuXCP+gIgYhQk\nT2MsYv3V17acdc6M5Rro6038q4k60DwcgQhY6Xs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAflXwsdPb9ExklpB81Vu8Ns+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjM1OTIzNi1kOTZkLTQ5ZmQtOTkxMy0xNGMzNjJiYTljMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjJOaRejclYLyVaYfUmZc9gyyuaPPHJ2VQMPzDk0K20QPP\nQb0PjQDqbix/kQdtc0KOYzMwHZXiHic9nOtnjqHYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUacJ1ctAQelYq4wVaR3nIeY94\nWHkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMFZq8yxNN9Q19+smLATQQFFHwkvVMzXbVpADpC7PUcAAiEA/fDkNPmC\nSZKvLr69HyAMqjcPHh6AyfXSwb+HTObRBOg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAf0Ls77PEzqosX7wYnUB9mRkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNjNGM1ZGMtODRkMi00MzdkLTlhZTEtYjhmZmQ1ZjEwNjQyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjI5NDQwNjYtZDE4ZC00MTMwLTgyMTctYWNiN2U3NTc1\nYjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHCBLD03eIEiYipG+etFKFSfw\n8Qgv/aP3s1Y6RXT2BmHb04L+ANmLnhYRerkpLIAXSGU9guMZJUJ/4jTmkq7YdqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXdYNAWWKBSVf2554sbTIIg8InVowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAk4CCHBAgp+Riw4YJf07ENSSZTU/l\nJf72qFSoZ//GBbwCIQDiS1wdOGLvmKhdzoCqWelVh97fYZFW+dn/7v7PK1YRag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4595", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4595` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAeSKJC2eKoh1cu5R6nppjW5nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNjg3NTljLTE5ODItNDI0Yi1iMDEwLWE2MGVjMjI2ZWM3MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOThkYzRjODMtNjIx\nZi00MGYxLTkzYjAtMjY2ZThkOTc3NmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESs7oOPsy0Z/dxQcQK3q/oBUVksktcJ7+RlrvrTGIq3CzaXQOvos63ei00369\nPDloTfjb/VXjgK5IzeTcRr1F66OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlXe75XvYQlp3PtuRtId9cu3Z7oswHwYDVR0j\nBBgwFoAUCXkJG/GXPYTEi+THoFTROVLd/CUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAp1Hx7FZ/Jk2aVum81yp2uT3DNX1XgqsSc\nYdiEf9QVMwIgRdEjxn4IZA/m6Ow8+daWhctyf8PniVlSiXb7azEz26g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWJSq0Hzvfzywc6FAX+gjYANMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjY4NzU5Yy0xOTgyLTQyNGItYjAxMC1hNjBlYzIyNmVjNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCstDO13bjxkjpV0W6AFVahehh+hx1rsdP993CWhZ1O/Vp\n4IhKgPTzcIN8rZLFV8yc3Ucq4Aa3SnisZ/J69FFco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCXkJG/GXPYTEi+THoFTROVLd\n/CUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYExTz85ki/HU3AHV50G8GdqgmlzlgZtgvmV4RZE9c7ECIQD0bnF1gSHh\npw00rzwWJ1iEqlPBBITVI7uK3TU+IeZJ2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVvSFFZLc0Ag2MdgY8Llio4bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOThkYzRjODMtNjIxZi00MGYxLTkzYjAtMjY2ZThkOTc3NmZhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWMzMzM4ZWItY2U0ZC00MTE5LWEzNzQtZTJkNmIxYTk0\nYjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn0kM+eUmY6lHy0vgX+/Hmx4e\nHcukMR8kXAHHVPxUDhpRRbCy5Hh2GTkj+PXmnSMQeyIxJ5Hpe7EPiJ1DOVba5aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlXe75XvYQlp3PtuRtId9cu3Z7oswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA4p4qyAqqZcT/Lej5mTG1fUd9U99M\nBm/cdDyJVuqWnJkCIQDJV28wI1M6unWdXLkkby+4cMBdTcKn8jnz78wHo00oWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4596", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4596` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAXDrKuqcBipNQu1yx+JWenzSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZTkzN2FiLTJlODEtNDg5Yy05MjRhLTBlNWMzNjlkNzdhZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc0MjkxMWMtYjk1\nYS00MDdjLWEwN2MtZmQzZjlkNzQ0YjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBsKyjiTkhtGou1XXtavVDaOJqlqvbuXHb+0iAz7QKgKftU8dhCQGwa5swPfr\nvOp8dK1p4O06cnmqqH/myMws4qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURxw1uznlC64WXsVp+nvE+DLwI2UwHwYDVR0j\nBBgwFoAUM76ctRqHojfIYRJL3xxLDYwUG/gwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBkIsWNhzgW8dfr/LzE0atg9k4RKWl7LLIG\n2VlZxweI5wIgBY9kf2yGsQjF6R4aZV8VDS5UVY90SqXLWu+XVavyNFc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcOnBf7ajmv+8zi5w2VZ7PvBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmU5MzdhYi0yZTgxLTQ4OWMtOTI0YS0wZTVjMzY5ZDc3YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrviL22icM/rpG11N40wUZLf5own8Mmkj5+3GAftjz+TWB\nnSUmla476C94EE2BFdT3nbGFKhxFfZa/dYzbwNDho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM76ctRqHojfIYRJL3xxLDYwU\nG/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf54cp3NLFtrUUor4WGbqq0HWHXhCX9X9XlW2jS+wAcQCICUQwiEpBhNS\nQU5ErQn3kW0jjnNgXS2uPJQhx7pyHPNv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAaNp05Q+bjVHbLaE5lIeSQkxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc0MjkxMWMtYjk1YS00MDdjLWEwN2MtZmQzZjlkNzQ0YjU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjU3ZjNhMjAtMTA4Yi00OWMyLWJmNjMtNWY5YTcwNmQz\nMjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGL8Fc8MiKC+VLzJPf6eGc98I\ngpm01ZIPmvSlgQU1kN1yjTxQIxruh9k8ZVj4b2EC7mgM7ft281f/sEyaZwF2L6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURxw1uznlC64WXsVp+nvE+DLwI2UwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBbG67PzpAGHruqgSIpZAWCJ8XuCmfr\nyXJgFbaz8rMsSwIgF1Fxo5CW2JEfLXxBScM98J3lpGtiTa4PrGBOZoJOYAg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4597", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4597` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAcdj0NyIKeeWQyzLctTCBAZoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwMDg5Mzc0LWQ0OTktNDBhYy05YjQ0LTMyMTU1MmM2ODA5YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk3YjI2ZDktNjFh\nNS00MTQ1LWI4OTUtMTc1ZTM1NDBiMjhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3uPEykLEbTTN79V+/d05XPEHXy++zg4xSGqfXZG5MdDNkTR+6cSD5gW0Gehy\n5sD53VYBrYftZ8Bgt7ycrF3m2aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfHqbOF1gWkW6phIWKjXw7/Ht4zcwHwYDVR0j\nBBgwFoAUgM7wALtc7ctEFsRov6nNKgYxQyowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICPH0y1s5HPlu2k2aqX9CPIkmhc/\nE/SzKp6mkk3NGRGmAiEA5RBSRP0nDl7O0yMBx+v2uNdPfyGwap94up1Pr6tVr/0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZPCX4QgkDQGGu+ZZfXf094pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDA4OTM3NC1kNDk5LTQwYWMtOWI0NC0zMjE1NTJjNjgwOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9vYxUEQc8vDeneg9Gp/qwRT+dT1ugC6w5NwRPZGN0gniE\nYUlZ6UE6KaBp7D2M+KiHoV718Gcui8lgpxjWqkgDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgM7wALtc7ctEFsRov6nNKgYx\nQyowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJaA9OFfqTJ6DMYl99toPIGA/8veyXa25VQ36KdawoxgAiEAzViDbgxO\n1J+NHeqcycPIyv2pGImk4WBC+L7nYj95pxk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbkON6CY1MFYtRIpSlVelhi6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk3YjI2ZDktNjFhNS00MTQ1LWI4OTUtMTc1ZTM1NDBiMjhkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTNiNmY5MzAtMzc4MS00YmI4LTg2YTUtODA5NjFmYTdi\nYWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjAC5Tc9RlvJANMVGFAIITNPs\nSd0oPrb17UVxuYSR+TohL0ZYgkscmtMK0rBZNT5Ongh06WRo8tttsxE7+PfaaqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfHqbOF1gWkW6phIWKjXw7/Ht4zcwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiABREWFHYoH8tWvm48RGmt2SWqCsimJ\nsCboY0bqlW8LCwIgDNqthSQ/dIotGa6HeoG8/h8jspzXIgxU0ERSf6d7YdM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4598", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4598` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAfviGu7y8cLWIf0TA82oLHOpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMzM2MTEzLWM4YjktNGUwNy1iZWM0LWVmN2U3MWIzOTQwODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI0YjBmOTEtMWJj\nNi00NTgyLTgzOGEtZDYxM2QxMzZlNTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESWJETppAV1F/IW4CZyfyijwlQaMpsqVnJc+3Wg0tPD3AypTcMmKIn1LL/Kj3\nGUSI0h4mQhzNUVepAaWrHTqlmqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUknkFMKH6iE+JbOXNbh5HYkgbVeEwHwYDVR0j\nBBgwFoAU89HOlbbpp/R9wj3VyAvU7NG8zUQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJX8lDOH\n583vEl/mkCfrWLnYCexeI6IJD6Y76dVREFl9AiAHJiT3v7e38zCL6tWWrwlm9X1s\nmBHJT6nQtFLub5C2GQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATuuIP182iOjlsQEkANp6ouvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjMzNjExMy1jOGI5LTRlMDctYmVjNC1lZjdlNzFiMzk0MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASez/OylMeKRy6yPtc2eVp+mmNFEF1oCNcNTHYnUGfYTqco\nJngxs3EOOfpVQ45Zuaz/Wtsv0NpRveMbN/hBt6Gbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU89HOlbbpp/R9wj3VyAvU7NG8\nzUQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALipPWxiCmyc+EO3/C0/bKgimJCclq9ogziSYfn5sR3TAiBoiFSxqP3A\nEHBXboomb76wdm+b4UAXIjunMAfkbySutw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZuPeiVM1S6qMZHEpSVDgUYjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI0YjBmOTEtMWJjNi00NTgyLTgzOGEtZDYxM2QxMzZlNTcxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjU5ODJiNjEtNTY4Yy00YmY3LWE5N2EtNTBhZTlhZDQ3\nZDRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/W3t+9XWEyH8xEXsnfqb1HSR\nCS+Et8f824Ayf9u7SoIECZtyx5CAFPrxOwIAUs0IlSo8ZTbzkSMPc6jnfWiobKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUknkFMKH6iE+JbOXNbh5HYkgbVeEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAx3tVocnwsv4GeZnuPhbnf5pENuyN\nb09rV9hVRDRHQM4CIDFRRZ49NL9Y8fwwz0hiZ16iD21J+m9IgAJTSjbwLSrx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4599", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4599` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAYnkVmljVnviyPnd92yflJZSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3YWI5ZDNiLTkyYzItNGRjMi1hOWY4LWQ3YzkzYzBjZTc2NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ3OGQzNGYtZWQ4\nMy00ODZjLThiODItYTU1ZTNjOTczNzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX7tc4/o+O8ceKI+dsbn1OjVRjHnTnqzV7SSSWGn66H8heRmQKG9YH/VF6MlZ\ncIk494NgQLp/0Hj4CzSw8OFHxaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDWqvvYZZyWfMuht83lTRoE4WqoIwHwYDVR0j\nBBgwFoAUTzYDQ98q3nbQFh6RVLVbNkCBk+swKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgYTGO1UUC\n9Mcx13s4R6hBT3dvrkaJqC5PVEkvOXFER0ICICeXruDeAkRFlrlhEtC0tGHmvkk1\n3YIppsQ3PVSDItX3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASeb6r3n99BbdbsvV950BWlNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2FiOWQzYi05MmMyLTRkYzItYTlmOC1kN2M5M2MwY2U3NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReW5HQaqTHUygAeb/es8ffC7sLZKulP+on/Zje87rcdGaW\n9WvOpKB91xonH+hDrzAKlBklsweEBqtYl2anLHrwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTzYDQ98q3nbQFh6RVLVbNkCB\nk+swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJJ5jAm4sYjtHE+T7PDPhPvTxL0bhk/ovkEthbWc1jO4AiAmLtW9M89n\nQfH/t6dGRGBwT1ZbmErsCJvvL8V5YhA+VQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARc9dULsZKpbGzbzOVYWgn9IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ3OGQzNGYtZWQ4My00ODZjLThiODItYTU1ZTNjOTczNzFkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmYyZmJmY2YtZjAzNC00OGFmLThjYTMtNGVhZDM0ZWQ4\nOGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExp+p1IL3w2I6HIHr6mYYxxMt\nhgV4N6xBgZk8ce8oPkBQNQ6t8UoC9sfQF+hmR2QAKA+ldh51hisTlOOsyazND6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDWqvvYZZyWfMuht83lTRoE4WqoIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAh0zFGUGaGWStCFXsovx3B6lb8ycp\nWFCcUmJryBb31poCIBaMV81ha5uUed5JeWmsuC1X+DR7tPtbQFu793MevKjI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4600", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4600` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISATjUsq9ScL2W5SqBl+Asif5/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3ZTI4YmQ0LTg0ODctNDc0YS1hYzFiLTZiMWJiOGM3Y2Q1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjg2Y2VhZjUtOWMy\nNC00NmIxLTgzOWUtNzQ0NjVmMjc5OWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8HbEJwtnoluMPOA02ZkJG+8m/4zi9eA2w8+JVv0Rdi7TolaO//mzMpXtVRSr\nzmb1I2l2H7+6ClnqF3uxmphYyKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXF8/SlddTCGZJT3GX/C3iDM/N3UwHwYDVR0j\nBBgwFoAUP/ouG7Wqj/or9WKC6zzodmU5Z88wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIESxxOtA\nxZl/loAXOeU1xyRpB6Vhs6D+PDX/b8ZNu4zHAiEAnn9+ZH/0Y8L7uNi61oWj/jtG\nQxGRBN7rzIiohMc3zBw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYDDoODzSktnBRLcaqWPeV9FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2UyOGJkNC04NDg3LTQ3NGEtYWMxYi02YjFiYjhjN2NkNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZsGVuOCwd3qyR7VxKlgF3cYHaV3agcFdSIPwLZSK8xwCx\nLhtiGBFMR7+9a3q81Tdjjhn1gL+LSOElXUZ8HSdYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP/ouG7Wqj/or9WKC6zzodmU5\nZ88wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALtFryWH5Cvi38UDwEq8NCvE+RZTAwLyeH5p3B6KM24dAiEAyp4xj0NQ\nKL+w1KNXG2YK7A0A8/r3jPEM/njZ3F+p9rE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAccOgb+QzNr08Q+JXkPDfvxGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjg2Y2VhZjUtOWMyNC00NmIxLTgzOWUtNzQ0NjVmMjc5OWY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTE0NzRlMTgtOGM3Zi00ZTA5LTllMmQtOTJlNjU0MzE4\nYzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESq2P6N8C9xvk6MRxH+e/YJ7d\ncutk3tjRzOSGZhzZ8uVXVwNXPAaoSgnrZKJlFnLRR5rCUzwIhT82KLHYZJtPHqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXF8/SlddTCGZJT3GX/C3iDM/N3UwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA/+fwrWen4DplVFXrRHr1uP/DyVpXA\nLWxoTbzrXKg9FwIhALUTL6bEim+rT2zyoFw0sp0QjLOWv17ibYYA8WfyZt6w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4601", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4601` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQSr5a3NwCBK5Ea1QRLUxh9nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MDNkNzhjLWZmOWMtNGRlNy1iZmM1LTBlYjcwN2Y3Yzc4YzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U1MzNmMDAtZGZh\nNC00Y2M2LWFjZTktNjViZTgyODIyZTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEySWWVmucJcTuxZdlNMKJtWo4VhEgMl1QUdUqUDoaA2OOMl/eIFI4Hpr9egX+\nHppwoxOVqGFPBKohIkQcNMtuW6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZpTgfnjvwrf40egwvS6LVcxyfjcwHwYDVR0j\nBBgwFoAUnjV/IJ2QGqQpvzmLGn1IyJizdUYwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIAdm5d4VMHm/fylh98jmrrS5zAFqveInDa2JLRqMnR66AiEAin+fFPVq\npm82CHo7Vhyk+l1/RYvtqlgvMBbpREbaG8g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAat0EVYst3+jrDQSxX/zAZa+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjAzZDc4Yy1mZjljLTRkZTctYmZjNS0wZWI3MDdmN2M3OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDe4ZPDKhmZA4HJaxn4ryedDBL86QfDEbf4lm7StxlCTYo\ntNlmpNkEZ+e+iEzIHCDNsFlGP1OAl5Q7ij/Wdyooo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnjV/IJ2QGqQpvzmLGn1IyJiz\ndUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAh2n8V5uZsTi+O4KO+eQmk7OQVIvRkaqqMrmfb+qozoCIGuka5F97+6P\nlbBffI4PESsZ2aai5AfG6/jOgEpTEXI+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdiwZCVjJONlM1cvMOI1viFaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U1MzNmMDAtZGZhNC00Y2M2LWFjZTktNjViZTgyODIyZTlhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTUyZTY5YjQtMzdlNC00MzdlLWIxMjktZDQ2NGY0NjEz\nMTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkfQPd6PnN7NF1sBjBisi35FE\nolOgGKZ81cHFgj5oMENXUGoI7emB6EcN9+ivyRVXqH7lSOOhxDzC7qi+aoP7JqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZpTgfnjvwrf40egwvS6LVcxyfjcwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA0hEfB18jh9Z6yspqRo1k0ub99F3w\nTSIbg4z90kdRA8UCIFdV/YTQa5ehxu3HydDBY1RhFok77x3Ao3LdJgB5KC2+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4602", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4602` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISASEVN0UR3CMrWruRhUxmPr/GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3OGM0OTQzLWRlNDMtNGY3Yi1hNDBjLTE4YmI3NDI3YjgxNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2UzM2M5MWQtYWFl\nNi00NzA3LWEyODItYzM4N2Y5YzA1ZDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuy1PeIQrTo8ORcYZl2D+N1CUv5p3z+Znr4R+3g4RFj470st5VUJVoS5Zbp3A\nuYmPySRMwSx3EYUtKYPsaMn8XKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrqF2Sk+D4HG0FJRecm09jzmlRCowHwYDVR0j\nBBgwFoAU7Lfim911oZCiKAo3PM7AXxg9LgAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIHqDpTWcY8Ric+triiF1kO6anL2n06AlqsBqko+zz2kGAiAZRlvhpJPv\n3NW5ODmgNwawFvmwVKRbKyqhgk+8RvaVaA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd2toi0SRy/Cvr+FFW+9D1cMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzhjNDk0My1kZTQzLTRmN2ItYTQwYy0xOGJiNzQyN2I4MTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWkN/qJWS/TvDjKEBPhz2LDzx9thMiNG1lw4sMqWO/OPtF\nqRpwUdmH/RdS4C5F+yoG/Y1H4B65cPkgX50jSyS+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Lfim911oZCiKAo3PM7AXxg9\nLgAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPE9v+maeIrjQgWT+YhMZfsy4ubmxWXbFUj8Ht6lAvzFAiAtmtglxlfC\n/gn8CuX0aDCqJWjb6S1NSVieoR45NhokTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWwvxGazNooPQm5cccW5ilg7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2UzM2M5MWQtYWFlNi00NzA3LWEyODItYzM4N2Y5YzA1ZDA5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmZjNWM0NzEtNjA0Ni00YmQ1LTg1MTEtZGJjZmUwM2I2\nMDAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELGqrl5tuy+rnufUyv1Xh59mX\nz7M6sKov1wAl+EV+keQa0xd4xGJRxh5q8C2f/bVepKtftsh1/ti6iUgQDEJ7kqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrqF2Sk+D4HG0FJRecm09jzmlRCowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA3NqLHuUValDgHZ/lBjZhE4oJdYcgZ\nT6jnX9HCu2yj9QIhAJ/OZobN/uUtzdlTXsKDnUYs8YhIqaqtm3pG1sex65nV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4603", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4603` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAe6cPY3u8MU7YqhM73t/S3cLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlZDJiODNjLWFmNjUtNGMyYy05ZTVjLWM1YmMzYTRhYmE1ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE0MGE5YzYtYjNi\nZi00ZjU4LTg0YzItZjFjMmNiNmYxZDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQBe36V552Vv5rl+DKjPT44nXXM2JsEZdv5Su8tqoYfbg6d67y0UuKA+SkWQY\nbMvm5nXxlg2N9wOR0wCG/6N8x6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY1CBWABE7oUndCkRfrMpWyVKfkwwHwYDVR0j\nBBgwFoAUtZJbcqWRLbfXz+6FQztlS34zqAUwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQCrS62nNKGmxw61Kxe/5t6Mwo+N/wt3Wb1QafH3BMiUPgIhANKHzFAwfCzz/pmn\naAkX0xImZUv1i3ZxPhQ6sYgnlJDz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARrVUCzqH549UJ2EsS39NNsvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWQyYjgzYy1hZjY1LTRjMmMtOWU1Yy1jNWJjM2E0YWJhNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3JtXUn3FblHFGuzEZYluw1NpbzgAyntgzJoop6E/9zzp/\nrF9fUrTE3F/I6VXx3A92Ipgin1wyoF41F1C3TrKRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtZJbcqWRLbfXz+6FQztlS34z\nqAUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGQSsKYSokCIosbMBDhWAjL6dGsOZpHSKI3Vuz6H11doCIQCQfNFZ4Yli\nxJp7v0eQYoew1gUghFAfIlFDc0/P/VgajA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAe8A95azq0QioDXiyA14IkvFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE0MGE5YzYtYjNiZi00ZjU4LTg0YzItZjFjMmNiNmYxZDY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmM3MDBkZTAtYjc1Yy00NjA2LWJiYWQtMGY0NTAyMTg0\nMDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyR2IEvE3C3W0T5wgZPVZp5xP\nWba8cwngQietoXVj8YkFCyh1cS3tlT+z3G7HaTzcEdHtB4b7nFKW6OWtm7fv6aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY1CBWABE7oUndCkRfrMpWyVKfkwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiASTuj5h9ehswWx0j37+NAraSD8QVXX\nb4x2RRy499gSGQIgCPvE2QSfd54rHzc0LOT/nkJYyTt1hYT1umvJY+U3f3o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4604", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4604` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAfqfRa2NIjAZQAHSiVGf8XNzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljYmJmZjgyLTljODktNDBjMS04YjY2LWZmOGUyZWQzY2I3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjg5ODI1YTUtYTc0\nYi00MzkwLTk2ODctYzVjZjQ2N2Q5YTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6pHA05rZtVOe6pUxmCRYcwkBO1JzPlyGJb2DJcQ/OMPYfcevGznhhmBindOq\nz+OsAvuHffKMSzROeUgdGMR+yqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD3pm0sXAbasljfkhbNVI4pOR/zQwHwYDVR0j\nBBgwFoAUPofFJD9qE+8KckeT5PSzrppHlDAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQD1RCfI/9vQap6JXeQMyTif/wQhYiNtfe9MMqNVTc87wgIh\nALOeViChAQQwIAFbMZwOasT9TlP4Y6xzhLzCWX4iMeO6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVPJqII9W29W5pj17FiEHj55MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nY2JiZmY4Mi05Yzg5LTQwYzEtOGI2Ni1mZjhlMmVkM2NiNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4tt2WhyT2BQKP81yscD5Z+vMm5EX8AKhJ9ZgVvZ7MUvQp\nuFTFwALmhdDISMJ/vJAXkcIN7YCAorTg5i2FRLOuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPofFJD9qE+8KckeT5PSzrppH\nlDAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZj3kgkYmC/GWEkG5vMnD0l4+6s6zsB4ttgWqFQfn5jwCIAJpHzvWfkZm\nGijUncioupOtOB7lp4oakt3oIlZL0HDs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAf8m2D9QhGLggyLdPAGhmmDMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjg5ODI1YTUtYTc0Yi00MzkwLTk2ODctYzVjZjQ2N2Q5YTM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2UyMDE0YzQtZDM2Ny00NGRiLTlkZGYtYzI1ZGIzMTQ0\nYmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkwWG3BT3f0HQ8jVRYUoaBRDO\n0bp/5ltFbfUiLzA0St5NHXbuHSdsOs8/3fFZc1K/e2xjYuAPKiNnBFoFYX4S8aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUD3pm0sXAbasljfkhbNVI4pOR/zQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiB4Fiw2FlyROCvqgKdVXyWieqWQ/LDd\np1TSFqpp3MGSnQIhAM0pm2B2FJ8FCMCqdMPbV1YQq8fWoH0A3QHnQvbtDb6p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4605", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4605` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISATh7VvZlw/s1lJ4E7oC+ElTQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyZTkzODY1LTA5YzktNDYyNC1iMWVhLTlhOWVhYzYwMjM3ODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU3ZWRiZjYtYjk4\nOC00MmFiLWJlNzctN2E1Y2NiYmQzN2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA9R/Mre7A2nYc3BIchuG2f92HahfanmekUQGpWhzUf6Y78yxlGzzfOnaNm6i\ni52t3ggWa3hVQFrMW5oW15aDUaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEu6QM4SGBIdMX6C8VJFfqkBoN2IwHwYDVR0j\nBBgwFoAUNVFizCJjTqSOg0qucJuyE9vgCH4wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCULgGaAhJYB6TMccP2a8lmBGN4bfzQH8JGP1259EnWPgIg\nTxffyqEu2vPk8zi4VOvPbnZNY++9b1HIeizVvudZG8c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWzSDiOutye5zgX0bXsA82xKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmU5Mzg2NS0wOWM5LTQ2MjQtYjFlYS05YTllYWM2MDIzNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARK+6yEfiDgp9EMmwO77eUBZ33abbbDj3U5mpPNfA4fYHYk\nGaJPRIitHtdI6LeW0KVihdsApH+WHh3RlTlMjmAko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNVFizCJjTqSOg0qucJuyE9vg\nCH4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALcUdChyFcV9X7mKU3X16k9x0Ztfn5O6KKd3e+2DEQcjAiEAwrdi8Gba\nXGS7QE5XdXbMhjQj6tNudNrtC+WxuQeha9E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWHheBJDn5p3uNdTz0Vt8r7pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU3ZWRiZjYtYjk4OC00MmFiLWJlNzctN2E1Y2NiYmQzN2YwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDgyYjFmMDMtYjM2Ny00NjNjLWJlNGQtMzk1YzQxMmY1\nZDNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOFnLcJhOvkvAVhhdvlvdmvl3\n2/OWb/jLBfmI5tFog8VdGR8Xs1oPEYepAAAi+1tF4vsy0QJI3BKMFjFhgGaVaaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEu6QM4SGBIdMX6C8VJFfqkBoN2IwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA4JepMXjEG9WWe3ZyRxUevuunAVih\nuWaLzN2zjLkJacECIQCAOuvWtOkEku5evZVWi0+tqU60V+ZY1C5OoRIErw9Grg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4606", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4606` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcikOMCCY8Uxb2pc2ifFeFpWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2OWM0Nzk2LTllYzgtNDRjMS04NjMwLTZlZDEyNWMyN2VlNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU5NWE0NDQtZDA3\nYi00MmQ4LThmZWMtMmQzZmViYjdhNzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu1Yq+cQ2ILuF0Pqqwje5c4NSOVUHIzHyMhi19+clf0RmS/biuI5qvrhe4YVR\nROLd3Cuc1G7gVxuhpwFs4d1H/KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY9JcCsOsqUN0Jh/f38HBtvEt7UowHwYDVR0j\nBBgwFoAUbbkr7w/rmogG+sMKCDew7lO1xAMwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIC1LsSs8Lt9C\nt8r6c7iKpNlpM6reHpCy7TAkcuOAvLVUAiEA4MUET/HCE07x0mNSPHex9vpmrkp7\nwuH61YcklCTO1KQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT3CnMmcJ7nu+sIZgab4ZeVTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjljNDc5Ni05ZWM4LTQ0YzEtODYzMC02ZWQxMjVjMjdlZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6EHFlY4uQFkht1i+TGyhNeaELzADX5kIpYx57ixjsCQ+h\n0dwonMdfAq9ZwBNCKhGx6j0EbbGFzjrDqB8i3aj6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbbkr7w/rmogG+sMKCDew7lO1\nxAMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPDkoCZe6esfuM2ZlCbwx4fLETB4Xe9YLKXLcfv2Y3YxAiEAuiVe0PFj\nNnvxqwdF/dhXHYc6axOMqLm+dJN8ytPPeCA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZ7cM8nstH6q3e3M3zdwqQe2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU5NWE0NDQtZDA3Yi00MmQ4LThmZWMtMmQzZmViYjdhNzczMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODdiZWFmZjktZDA2ZS00YmY0LTgzNjAtMjE4MGRmOWVl\nNTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqb1oCTDi1RR2okP+7g4QiPF2\nABF/RAPdq/q+0JhVPXEdbKB70YQi6x88wCHSrvTSl3noL3JO3kMsAb43toxuVaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY9JcCsOsqUN0Jh/f38HBtvEt7UowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBPpIH69iJTb+sQ086HAB2PidONIkwf\nC/TSY8glQ2/Z3QIgLmj3n2KphBpKsdJX6O6BBGqvWbMbpZVcOfiWfRE7m6k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4607", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4607` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAeDKbeAIxXwpjKUdVKP6gAlnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4OWJiOTYwLTI2ZGItNGQxNy04OTc0LWZhNTM2MWU2MjhkNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY0NjlmODMtZmE0\nYS00NzM0LWI1ODQtODgyNWUyMjI5ZWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGm/0UlD2QagpfwjW9vnDealfKewo+huDxr9KyzsCfV9/IUuwLfwJLalhHlJe\np5ReKcuOsKestAi1i90F//0cdqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs8gjayDHC0jbttZckbygmlt4Q3IwHwYDVR0j\nBBgwFoAUbTft5rOOxeMjLfOoPJqqLp4i7vkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgHujWJiRZ2AWwHOseit5VmTckWOh60uYlAYV2X4EzjgcCIQDdNRQYCX+O\nsrUmPbzmShAUB/De1CBPAyR5xJu9498//A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeA8FDeqcL1GDwuyMQqiZFDSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODliYjk2MC0yNmRiLTRkMTctODk3NC1mYTUzNjFlNjI4ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASllooMq2RvPGOrpEe0YMCoOofM61sfDiAtdHOabW6ETEkT\nh3Qkf8Aj6iG1BPopo+WgaPllnNcHskA3Ly8Di50no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbTft5rOOxeMjLfOoPJqqLp4i\n7vkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRNoq9LS30P3HHzMPZxc2abREq9xasmTq6ZrdjYNOHA0CIDoiHWPrLQLB\nAjX0/QivmzThaQMXn5a2wqLWJ3d+mBF9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVjDF7CFRm8GbJSj/4PuZN2SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY0NjlmODMtZmE0YS00NzM0LWI1ODQtODgyNWUyMjI5ZWUyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDM3OTE4YzktNjg2ZC00NjBjLTk4YjEtZmNjYWYzNTM0\nOWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfbXxLtgNpbEIVrxYhKgQbOUw\n6LuY1wDq/cL5YUGOtMxtnxx7vYeiuTXzs92yZ5wduyd66et8NSO0GIRNu0zGqqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUs8gjayDHC0jbttZckbygmlt4Q3IwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAEK/dfAh/fvVt9jwPX2BHcu8AFSPdk\njSCuhec2fkphOwIgGQ1CL1L/aX6vtA8Ef6E3/6cboM6GahVyAYa1Zk5R2M8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4608", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4608` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISATR/9kT+GrinIurRQmSrffQWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1NTE3Y2ExLTIwYTUtNDMxZi1hZDFmLTI5MmVkYWE1YjQ5NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI2ZWQ4MTMtNmRi\nOS00MTVjLTg1MjgtOWRjYjlmNTg5ZDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEptvH7+mUaADpATTVCtVcs32yV5B3raDGmml+d3exuogxSX7geolS2sGL87Iw\nwTod6uM28g3ZePYlQmWz/5/50qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaEop9poIHV7P+4GQuga9bZTAz/UwHwYDVR0j\nBBgwFoAULLThZ4dWg0/HmWPtVFdML6EEl5UwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgXvFrChyBdue/9MA65Z76+64aODh0DmQniooPixNOKFECIHr58USc/ubv\ncOaqG7Ote+EmsmgKeamhgnN4DZJGU7z7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARTnypj55LofLEfvI1ugVg3lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTUxN2NhMS0yMGE1LTQzMWYtYWQxZi0yOTJlZGFhNWI0OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNUEY8bYurYRP4nvamcapy4yMly6OgnVL9qFg4btwV12TY\nzkJDq3NohhAGJ1K/ZGDx2EodmJWpyDPU1d2Z7Dpho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULLThZ4dWg0/HmWPtVFdML6EE\nl5UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgefvd1pDKrTI+uX0KfqNoPRrWutt7BP3CNPfPD3rNrNsCIGIKFp1PWvPF\nMSuEcOxipRdnYh7bVJrxxl6eiUFH3VO8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARa/jTErgM865+E8zP0T9RARMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI2ZWQ4MTMtNmRiOS00MTVjLTg1MjgtOWRjYjlmNTg5ZDhhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmQzZmRhZTgtYjU5MS00MTAzLTlhOGEtNWIzNTZjMGM2\nOWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERizjqxjICgoD8gGxTXPk/9Pm\nEso66l+nowOt1sO+4J7yCMaAF3RlY4mS0OzSiqs0vofmL/i58lwwTNj1AimJiKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaEop9poIHV7P+4GQuga9bZTAz/UwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBi9yJxpsKXykDnUYTcVnPq2a+Fb6Ed\nCA7jglTqAS/AcgIhANY7Jp7gP/i7fl0uRCW76T58e892IWUcQCfrerIxzyrs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4609", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4609` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUS6fAiGlUUW2TIGkmnepOLHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMTY3Zjc1LTdjZGQtNDhhOS1hMGQ3LWQ5MzYxMDhhNzRiODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzlkMDc3ZmMtMzU0\nNC00MGE3LWE4MWQtNjQzYWU5OGM2YWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIwalXd1W0Buni7CQzSyYFapiG7H3f2LojLoAp1uenvi8mSun/98h9BO5Z6y1\n020vFG799rdLhdNKjvVHG2mBcqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP7o6wnhEPhQMt16Zz4i1e1ZrelUwHwYDVR0j\nBBgwFoAUSYux2nfBCeYrdJe2nrq6iUv2F2YwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQC4A5Bcb4Eac5qDrG1kwMcMxHQagzOfvFT0Pl9KX5DewAIgXhb/HfcN\n5T8Z06xP7ddNGk1Rl6ctI/zGK2xC8i826dg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfbikJ3qZdgPeJThSlkFM1ZpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDE2N2Y3NS03Y2RkLTQ4YTktYTBkNy1kOTM2MTA4YTc0YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZuVrHXla/ZRNu2CYBIMvDgXZLv+zLGw2eTmbRHiD8Ccsm\nCYkLY7muwkCR4G2vB0SZtvZZl94FsaL+Zm+MBlW0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSYux2nfBCeYrdJe2nrq6iUv2\nF2YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTSotDbSzGQttzkNuZ6mlUKj0bi6OTIY/heT+uwGcTBICIQC8xkpnMtQC\ndElPkZmFgqHmvouPwgr6ROPzAjy271A+Jg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfz2vu4IoEepFvm4UhPrJiUgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzlkMDc3ZmMtMzU0NC00MGE3LWE4MWQtNjQzYWU5OGM2YWE0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWI0NWE4YTEtM2Q1Ni00YThmLWFkYjYtYWU5YmNhMTEx\nNGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvB8b5VOwoxJ21MNEx1f5j9U2\nqkVm2HNDn5zOTPWxsqXb808hR71ICG5pFsMdTvFN7sDXc1iDIpIqkz3PXQsGMaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUP7o6wnhEPhQMt16Zz4i1e1ZrelUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAtEDNym/kljaiOaEWohlDQnARKcZh\nz5UfrC5x22eDg+cCICP3LJ9Kn6RsEl3ih5ZGjadWs+Bp5zmvyQ5bY2HUuh+y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4610", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4610` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAacAD/uRZWuYEi3i9M/yVm5OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmOGU3MWM5LWQ5NDItNGZiNi1iNmE2LTdmMzkyMGI3MDQ4ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk2OWExMGMtMTIy\nYi00OTZiLWFlYjYtOWYzZWNjYzc4YTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsE2E17IIFH2PXMVsqTjqqli/QoxKKFIGMEny9yBRhtULsxF4DmK9D/ATVytl\nMCabBdUdQ8Y/shMnykn6SviNHqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ0PzW331DcY2+3JJHOr+tNGxV9QwHwYDVR0j\nBBgwFoAU+evgDIfpbQwCzfMHHqw4z44gT+QwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBYcRnzTrC7wbVzxpIzw31UuK49dDEoiVgPLSUJ3\na0LDAiApuPq0BCjpI3WbGMpYRaxDNlQULodw9CnmWD3zJGm7SA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWh0O3hbUIFjhbkVZ8p0CpJaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjhlNzFjOS1kOTQyLTRmYjYtYjZhNi03ZjM5MjBiNzA0OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCDV3HkXIhxotHZwYvwefYXzoFTgfMGxBe+Olqp8WU8fIl\nmBu/UXlVplm7wEgwhsj1yl4fEp4bykBARMwQH7Xxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+evgDIfpbQwCzfMHHqw4z44g\nT+QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALazLKUbWPd+u+BQFiQa3EOYQUdy6tciSqKLQlkRhsv3AiEAmtK8yHOk\ndTja0nJD1J+HTUXtc/EU9hmpYbhVqJuYUp8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeO3hMO4i1hbKcyipFYRDZsJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk2OWExMGMtMTIyYi00OTZiLWFlYjYtOWYzZWNjYzc4YTc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjIyMTM4YzAtZTMxMS00NjUyLTk0NWUtZTE0NDlkOTVm\nOTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi8tpXZNMEvGipq98QAz2koPA\nkVZQ5A2n9LBX1WqYHGCtjRMvkckGAHPUSExG2vaO8DZb0w5iChc7Ar2yuGzxzKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ0PzW331DcY2+3JJHOr+tNGxV9QwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAYwvsQGUlvfiN/33Hf4csZrUcJz7QY\nXi40U2d7jbY7igIhAK1oV5M5Za9QadXUvgJWEKQvUs1kQnBngcbSIagmkuWz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4611", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4611` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAW78YFA8NzbTYgpZhT4pQiBxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViYjc5Nzc1LTJhY2UtNDMwNC05MDk2LWRjMmE3ZGRlMGUzYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA3N2I1ZDEtMTkz\nNC00M2ZiLWFlNjMtN2Q2OGFlMzYxM2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqm9qvXfNITaq8K+5YBNfIMqM0q+iadXJJZu7RCgKMsEypgVxAo7mZliPy2s2\nv6PTZHuR3M5Nyb9yzfoA1hZpY6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl3jSiAzCSp2j0Nifuf5ZxoIntpIwHwYDVR0j\nBBgwFoAUpBIKcPakzpljDzXOxWTjfoKp3a4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFrDNsAAb0JYC8FyiuNpnBlYOhSlD6Mh6q4m5RN0\nzTwaAiAWhicw/lrx5+YX5r+JPDXerg+SwV39rM/3FUe55tKU6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQbcEXVODmH4Rx8cFb9JUKSSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmI3OTc3NS0yYWNlLTQzMDQtOTA5Ni1kYzJhN2RkZTBlM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyk43uIK/JExW8tzvHMOWRk+hbWW1X8scZqfSr++av6QwK\nKCGe2nxJBnAl2aNGYUDdUSWKR3Q63f6lMtjnLIE0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpBIKcPakzpljDzXOxWTjfoKp\n3a4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB0ZZE0vQH2PdXB/dNkID6Lh6M2KU/TMGEhGI3ayBchUCIGbD57EOiQiQ\n/5s5lNZRhPWtGCDm1Ea/GSOxhtTAEFPx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYiNGcwMuEEyQvctTZll/xk/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA3N2I1ZDEtMTkzNC00M2ZiLWFlNjMtN2Q2OGFlMzYxM2ZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmJhNDg1NDAtMTU1My00NTkwLTgxNzItYTIyNWQ3MWEz\nYjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEW68frGjR8UaZHQS02+wzXwdi\ntLJ50BUjbWrkJktRHg0CrQDx1nEbTBihHMLz7i4kDb5jSc5rmrAKZ6xMvaMKyKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUl3jSiAzCSp2j0Nifuf5ZxoIntpIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAw5IscOS++pvnpWlRqmy28+EZk1//\n5zbyU+bgJpazUlMCIDeYvxq8Q2to7ahM2ecto1yZ4gdjRtSpIiR9w1Mbau2M\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4612", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4612` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAQPrvy+UL8VaYjy9StFoPEL3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwOWI0Y2M0LWYzODEtNDQ4NC1hYzg2LWY1YzRmMDQwNjg1ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIwM2M1ZDctMjE1\nOC00MjU5LWExNGYtODhiMDZmOTM2N2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEseDnwfZQ4bk4Xw14hfTAuKCL0nDrwdNi3kmAQ1GO3oXwY7EFvVmpahNuu/X6\nJ5L49shNLCkKvoNuDCmCc8tSAqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnls8rcMYjRBzxdzGhKs0o9K6lxAwHwYDVR0j\nBBgwFoAU3lqWyJxE4IlmGhLV4gz6/yY1NlEwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCYS4z1Ce9JK412sX8uXcuJ1o/5dBu1cfpTF90xZbIf8AIh\nAK1Y4cO7cwKpI0NCrlr17pK9C5FACyVJyR7vXx/vCVX3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW//b/5ZHwbN+B/rqCNJUyEyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDliNGNjNC1mMzgxLTQ0ODQtYWM4Ni1mNWM0ZjA0MDY4NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1C1Vl3dD9qjTJcjKOWF9zpjqeJ/xHEktEI42uu/li3PHl\nyoN9sZVKq/qY+NC8Apgq5P2CyPssc1w9jq879slio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3lqWyJxE4IlmGhLV4gz6/yY1\nNlEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBzBvvFKK268ph+wmLTxUzaRTGRtZJ9thwl7a8nkESAoCIEXY3/pmGDPZ\nN+gMHu4LfDJlEfULzQaUaMKMHf8yjZuU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZg7nfXICRwN5PpQTtBCSCvdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIwM2M1ZDctMjE1OC00MjU5LWExNGYtODhiMDZmOTM2N2Q4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjdmMjY5NWYtOWEzMC00YTQ0LWFiNzQtYjJmOTQ3ZGYw\nOGQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYWZ5e/SMNj3YVheYwGcPFrDo\nq79zQ/xcyf9ppm62uf33USIOgi1PdmFYDXC0MHC5psUlL0j9ZjC7iQauKRmf/qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnls8rcMYjRBzxdzGhKs0o9K6lxAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAdKay4d7hffGyUT8fsFTF2OyZD4AXQ\nrKx/5oqoblVFpQIgA+GzxkbcO63GyeKmVxa9PVsGIzImSznkzwVNT/a3R4U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4613", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4613` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAS1Ty+E2HT3wLOeds30yJeKLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxYTkyOTkxLTllYzMtNDI0MS04MzU2LWQwNzk0ZTQxNTE5MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGY3YjgwNzQtY2Q5\nYi00ZjY4LWI1YTItZTlkOWI2NTk3OGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcVtlRQJjpkiAxjYwKiKwCqtfbi9ImUZGjCtiTwV3tY193agIzlABToO3BHkn\nJHHcFZPu2XwN1QZgDleAHdzCeaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwz/CMNsT3af8gZaYdNweoAdeB2owHwYDVR0j\nBBgwFoAU1e/vcJz1pvKdXhaPmfeWCt7nRvkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCOMG28gi1fypxQ1rsAyGSgyUnxLa6e\n484Xw525J+6GOwIgHt8mO3PkqsCgsnncG/Szt3dIuyOWyO1h8jZYseQ+iq4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASW6l9P8Ydd5Q0O6D+dKpoLEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWE5Mjk5MS05ZWMzLTQyNDEtODM1Ni1kMDc5NGU0MTUxOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1cCgNvKvO7Cg7K/WLvUSxVxpgiu2PDR92oWsD73o3Pm2J\nGVL8b/eCD8+m1bE6xxbF8hW33xrtHpIuQsriyos1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1e/vcJz1pvKdXhaPmfeWCt7n\nRvkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPe7wEUMLIeq8PmdnhKGUpHHlxsKnJXXT7Cja97BTnoCAiEAhNFySM38\nu098eUdefULBJGjn4P7kSnpzaCvioXhnUHc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaPlgmT/xSt4eglYLz+c1WotMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGY3YjgwNzQtY2Q5Yi00ZjY4LWI1YTItZTlkOWI2NTk3OGMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjAyMThjMTctNjc5Zi00MmYzLWIwZDQtYmE1NGNlYTFh\nMTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBe3TkDvIcf2r4FM9ksnHoUjD\nsDyZ8FtxZ8GJIOOzwcD0L1qfsA31zOwdtYP6MeU7pxiyCXYt0kGods8dc8L5z6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwz/CMNsT3af8gZaYdNweoAdeB2owDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA3DXP2lychX+ChbbckIEhy+j63RCHf\nM5lFxNAKgvjzogIhAPmxdvy29wgNaAvtEOycBDHcN4Qa6Y1h2nvOkR0vQcev\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4614", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4614` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAeEnKl1/7khwdStOrhEdZrEQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxYmY5NGEyLWFjYmYtNGU0NS04OWVhLWNhMjdjMmYxNGIzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY3OTZmNjktNDQy\nNS00ZTMxLTkwODItZDQ4NmY1YTUwNjQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Apmv45JcEpn/vgQxDoJL0mUjlbbZtMHCp5LXoFgpH3fcfnFbRCS98hcUmbY\n+pkLvSq/khJ+NfQ6Eyo7i2o4PqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQyladk8lMsn3I97qDeUfWli/3HMwHwYDVR0j\nBBgwFoAUiH5r1229UitlzY1fIvilFTAMPMUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCLV21XwbfOdZvjLjwzg5WtBA7KWC/J\nILXX6hI1wY0DzgIhAJ4K4Sh/McSJQa/eNZuhYgWGWc5JlVcwHCU7eAD8QoLZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaWjdAC9G9DU4OCkF7FcVJR5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWJmOTRhMi1hY2JmLTRlNDUtODllYS1jYTI3YzJmMTRiM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrjJtGHx7uxCbZM6LWcPNykIw73FDyq05S2uX73IXTP50p\nHsORgRV658dQCv3e4TFbs9UkVOC18cv/UcxmjcZjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiH5r1229UitlzY1fIvilFTAM\nPMUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOr2Y/eRBHjOpcWg1nV+xWCkIqDxZHIT9BTEGEr4VSEUCICfzS3hlmHGd\n30SzA3OBpCS3qDM99XIl+o6EO54dXWe3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAX7jMCraxzjiqA3r1RpNR7s5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY3OTZmNjktNDQyNS00ZTMxLTkwODItZDQ4NmY1YTUwNjQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGIzNTU1YTktMTdmMS00ZjYzLTlhNzItYTBlNTBjMjdj\nOGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpoBvkZpoGUWFcXN1e0ZqgJR0\nw7FnMmiivhVTInjP23PYPxH2huTAAl6q+zaft5HftIjHgw6EMvkPHzkzBG/eaKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQyladk8lMsn3I97qDeUfWli/3HMwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEArmMVn5oGm4gQ6ql778MLoUo2Yguj\nCBfUkfU5J+GgxyICIBdfsyF/P/Am1ugtC2OpRMQIRLLzkoo80bG/rGxnbpE5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4615", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4615` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAeNOyKTEsa5sfELw/ijQqcGcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZTZlMzEyLWM2OGYtNDgxMi1hNGEyLWVhZTc4OGQ0MzhiMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY0MDdkN2MtYzEx\nNi00YjdlLThhMDItYjY5ODZmNWE3OWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1WrmMV53Zfv+/0+xHkteqY/p5jwI3RUjWmoCtYlvkUmoCjd5PFBIXSMP9hLK\nhQ84ANgezehe9svJB73HM8im16OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwE4re6HjsWQ97iHrFxp6unXGWXQwHwYDVR0j\nBBgwFoAUa0CL54sNmC7VbHdL32Pf6TDU4AkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD5rDuIz81c\n9KFz/pASXMYdINYSRDznaPbcSuepJLuJUwIhANSpwmDJDpuVMKzyBA8KLn/Klie5\nX696vPUt83Y6tRoA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWepK5qqP0M19k04FcMKOBtGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2U2ZTMxMi1jNjhmLTQ4MTItYTRhMi1lYWU3ODhkNDM4YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSLrjKMSl23vuVaksw7oWEekG+S14KM90Rdq5umDt1zDsG\nJ6NviAvnJJxTeOhBxE1ESa8Pdp5qCxoi4Oj7loLto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa0CL54sNmC7VbHdL32Pf6TDU\n4AkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRq+unq/WuCTmFMocT2Lfj8SAaqJDQX8BNdU5XTKTQ2oCIQC887FOoLEB\nEmJIFX3FBBHxkpiWIXxRwRJ3B3h3Or6Q3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeuOxuZO+To4sRW+l/wQIPPdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY0MDdkN2MtYzExNi00YjdlLThhMDItYjY5ODZmNWE3OWNlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzBiMDUxYTAtZjk2My00NzRhLThhMGQtMWU0Zjg5MDFj\nYTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGWHQDv6OdMge+CZ2CA2+rOFq\nG/8gw+pI2B26UlvvKUrE3NTe++MPftakMwDiJy8O4zw4RDSitbQLrH4ykcGmbaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwE4re6HjsWQ97iHrFxp6unXGWXQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA9mrA3Fr8oS5p1aBrIwW+90RZIe1s\n35MNN9sEnU+2LVYCIA8pwZxvP6dgRYxqO7qwSNYcd/keQOmSdXrx0J73dcgR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4616", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4616` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQPPscBXZdZ8OsNDKcVyTyfGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxYWY4OWJmLTIwOTUtNGI3OC1hYTcwLTNjNWFhMWRjZWRhNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVhYWNmZmEtZjVl\nNS00NjY5LTljN2YtMTFjMDQwMWNjZGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiiD1w1TwDS2gt6Sc0eymd1sQ3mFDtiuDsrHDl1DCNNXyZQzb6aaeF4csWqqy\nlRpIzqAJWAEo/rE9K8s4gkj8maOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZzCab4eHqWyduXbOQ/yGFG8zb0wwHwYDVR0j\nBBgwFoAUpNeg+NRThSy7KVT5fWUy9NABn0cwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgNQ02FU9GZglVPSfhZh1NZBFxhejlfXINRRW0lrh7/X8CIQDFGpYTi8BL\nXKSNPmppX0YvNdbVjR/5td4EaZVkd70AwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVMr5aR9CzuQg5yF6SHm6ypvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWFmODliZi0yMDk1LTRiNzgtYWE3MC0zYzVhYTFkY2VkYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVLq0PIBCORXsvZxfVLbPw8muc0xpqPRtFpd6UBPnne8BR\nHrkaBQ3FAhqI/hrIHqVQJczmBamFvg/4uEKQiHSCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpNeg+NRThSy7KVT5fWUy9NAB\nn0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUjdV4NfH24s19prBiYBPrp9Yg5D+uxxjeUJlSm/1KasCIB6dpFlgqjob\nQdy7mqaeuh4mcbpeQOGLM0caedxfwv1F\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUPKFk+gCszTU/f9DjB30XQtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVhYWNmZmEtZjVlNS00NjY5LTljN2YtMTFjMDQwMWNjZGE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWJkMjgwYWUtOWFkNi00ZDJlLWE1NTEtZTJlMzhmODU2\nOTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3vOos+1mKjm8TLJVi9gCGU0G\nKKjdsq0wMSjTHxVesPqbzMd1g7bJMVHkLE1B7avGzgvko8YatZWXj/XLJ3O0zaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZzCab4eHqWyduXbOQ/yGFG8zb0wwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAzr+UG4Swo7M48EnATDusZdNMvG9zv\n1vpIAIGAQa+WGgIhAK3Kb1MrR8qeNO5ygYmurpfoklW48JVs0Y5qhnceEuvu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4617", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4617` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAW6E9pTHP1ntvs+1sJA5t5ttMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljOWFhODc3LTA2NmQtNDZhZS1hZGJiLTIxZTkzM2ZhMTMxMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUyYjFjYTYtMjQ0\nOC00MDQ0LThkNmMtODEzMzc1N2M2ZGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuhF1YaXWt9aXPAC9tN51FHi41tQmaODfC5iQN/gEe035Ik0SYIV3+S6UZCWS\njoG+FcfuAmurf+Q4L7Mn9+syhKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZo8fwMJTZRVt7GGtL6XvaxelQlkwHwYDVR0j\nBBgwFoAUJPtevCUpgbyRmDdj5x2fOjVKDukwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgMIbGHZyOed+SrB1r7/Va9zjdIiRcTl1okwG8OCek4nYCIQCSnRyUU8NW\nf+gSf20ORcllJekXHsYDQPjR8n3YmAW4gA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAegWJZecSgu8dFfIQFeo2s+JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzlhYTg3Ny0wNjZkLTQ2YWUtYWRiYi0yMWU5MzNmYTEzMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2hMoXIlLKpJkzXx9UcshFEfFLpebwZIABXPHYrtGQU2dR\nSynREEmvI7gEN6ujhC0Cn4zeQjFX61IyHbBodqego2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJPtevCUpgbyRmDdj5x2fOjVK\nDukwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIq9bnuO3EEMPOzAK/chsoePJGsX50eMDHFWYyKkLvniAiAovg4Xv3kJ\nIHmlOmpizg646m3HafUcF63qoOPh1jmIYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAe8VZzsT9IHiH6RMok76lJrSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUyYjFjYTYtMjQ0OC00MDQ0LThkNmMtODEzMzc1N2M2ZGQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTE0ZDFhOWMtYjM3YS00ZGUzLThiNGQtNDY4MmYzNWI5\nMDllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoZR3rQ0nYwvIc69yueom/f0w\nOgfbN/azv6sGBFoIbuoFujCb8ORIq1q18RW7FWY9pA1DHCkelJtktOL4rNa8mKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZo8fwMJTZRVt7GGtL6XvaxelQlkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAr+miCXlIHf5n8Vv5bo0HTUotj2AM\nBN9kmmXz7TSfM54CIQD+ZHsMZC8CcVpeEcFT7I8p9qIBY/EBPvfW9ZrNIDrrZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4618", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4618` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAWnZm5eODvksxTZbpqOMMtbwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMDk0ZmVlLTI3YzgtNDZmMS05ODU3LWFjMjg2MDczNjI1YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ5OWJkMTEtNjQy\nZS00ZjhlLTlkZGYtNmQ5YTYxMDg2MjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8k8xFrmyNtk9iw2HwWTgq2IVJt0VP5/DqvdThurkzE3krEvzk+K5qwj1Gp1a\nkzmJoSJSLErfMLkKbS1/DMJ4FKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURgrih+1EyqiwiIJ3fGmHyHHasVQwHwYDVR0j\nBBgwFoAUiCbEUycnkMNgu/7I8K9/aGGld4cwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICN4WRRNCDE82yMRbI3HiIOGokpFwiozeztP6pEPHWNJAiEA8ByE83ll\nv32K96pF7HiQYCR5He+gjOVg8AABEi4i87s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATOFc2atBtPxf46jxmMEq5W+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTA5NGZlZS0yN2M4LTQ2ZjEtOTg1Ny1hYzI4NjA3MzYyNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXKvlL94DaTxH9YYEBtwtk2jboo7n6I33AQgxMKNKcqabn\n7gFLNr7UfHFvi258hnoWZLa3QDQRVe0rcjtHxAg0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiCbEUycnkMNgu/7I8K9/aGGl\nd4cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVjvr+2dH/OFpwRc8votDWxSU9tyIoEXwjH2BvqLA4h8CIB64nnSJer/3\n4aZTxAVz55kybGG1hRP8FjlHnwnOd7Kh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVkqncxdyW0LDNgg0CN26lTYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ5OWJkMTEtNjQyZS00ZjhlLTlkZGYtNmQ5YTYxMDg2MjJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTk2NjE4YTUtNzdhNy00N2YyLWFmOGUtZWJmMWE1Njdk\nZDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVQ9yIlKx+xk04VMAkTdi373d\nC0ZcRrEhYfTrYSyB1Wdqv3NwqLFUtk9vjLb5awpnY3LbFonBdtREiB7thwfc8aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURgrih+1EyqiwiIJ3fGmHyHHasVQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBeobOBqWmLpgEKbxLUHNHoPQOIpjsK\nn0Wq81U3fTJ/bQIgPoF2+36yLALUbFYLCI2Re/GxeN3KRtcb0zWp9GFEbCY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4619", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4619` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAS5zl+aAXnVecP9kY4BwyvELMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZTEwY2ExLWQ1ZGEtNGEyMi05Y2NlLTk1YzIyZGYzMjBjNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJhNWY1MTItNGVj\nNi00NTAxLTgzZDctNGE2ODVlZDExYjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6kmlG4j9Z/i/FJBS7lEW24XZxCymPBmB15lacS/ot2bfrQB0tMQqyVeO74iN\n0Hrzo7spD2g/JXg+YJo+BXqgeqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4/T0b7mDZ9rWEM+2LWtcwx/Zl7IwHwYDVR0j\nBBgwFoAUs2lmCkHQsEnOFbpzkrAYQ9cdN7YwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC7rmqUN9dnDcLUlZ9iCgt6k21zGPBSD/L81x3G\nEsiUSAIhANUHzzBTKeE7MNGrJrMUW/mcGxjdOy0OEjkWoaPq3uqt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbTSqOquxAEyWil60MKfRwOJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWUxMGNhMS1kNWRhLTRhMjItOWNjZS05NWMyMmRmMzIwYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSV+HGxA7ygMgoTgUyVUUrBroTJZGF50xqxW9oACY7upEz\nxhzN8CIaSMoTWVhtHQ3r3C17mirPi4AdMWB+XDtOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs2lmCkHQsEnOFbpzkrAYQ9cd\nN7YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPTbU4yPHVzx3mNoDW9dguRD0DmscDQWG5X0nhKtijOXAiBXGVM4guti\neHRuGSVlmZAIJ9IlgDUHbn8Co0JNe6TYig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAeSiFgVtzskFE85t//mdSyYvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJhNWY1MTItNGVjNi00NTAxLTgzZDctNGE2ODVlZDExYjI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjhiNjY5ODUtZDMxMC00Y2RiLTg4MmMtOWE0MjA5ZjVh\nMWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECpd7ketDpB0ZOhoP/T+ukU65\nBDpLl+86gRsu11EPGNZ+/IYIpiWYYs+DqkdcEx7+KWogdmR7aeuJvA8PEXKPDqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4/T0b7mDZ9rWEM+2LWtcwx/Zl7IwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBNsEzh6jilMWmGIK6TaMFMWUlbHxTR\nA1TWIkbVsaPsSwIgSZapvofu8ujL0Ov1izVHmjy0iEkCYQX5fS4Fx9bBCXU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4620", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4620` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAb6mJUG3E+skIuhUCDY61Y/xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkZDgxYjFmLWQzMmItNGQyYS1iOThhLWY4YzUxZDdjYWQ3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzAwZTgxMzQtNzVi\nYi00NTU0LTg3NTgtNTMzYzdmZDg5YmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH3Gn2+RKcUKiPaGzJJURSmR13Vx6XtnEdgyjtLqjK2OuOOWTmK6NDZuu+6Ad\nVfbvRpd15BbvSqaS3CBs8JuKNaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/IZ/aixQmbq5YI2AoiiBgjotFxowHwYDVR0j\nBBgwFoAU3UyyRbygPLpZdRI8hcZx7PVaK0swRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDkJoVwadoGdDeNK8Mkhe1bGG+OcmYyYsIroyMf\nuzadtgIhAKfNMbwYpJiwCCkZ3SafVIEEEBUZgGNnRAlR4AnYZTZA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd7uCrpx4l4OdpJJa1lVTQX6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGQ4MWIxZi1kMzJiLTRkMmEtYjk4YS1mOGM1MWQ3Y2FkNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARicGFuFfToeSCmFseQV9BJcgRC4ii7qWWmoRfg6k/CtfD/\n6Q68rUde+jXAXq36al3ex3c/mJ6yYVjbsVbuLb1Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3UyyRbygPLpZdRI8hcZx7PVa\nK0swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMl/1q+WHkQwJH9uSrUoGm4lqqH5ckd3leb7Wp/9m+KoAiEAkc/F0xRA\n7KNa6kOQZ8hEHW3LqLH6aFIjWhvEDKyyCSg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdE73Dcuoctk5XA1+H0PMRBRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzAwZTgxMzQtNzViYi00NTU0LTg3NTgtNTMzYzdmZDg5YmU2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjgyNTAwMWQtMGU0My00NGRlLTk4OTMtMWEyYjEwYTQ5\nNzQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhcc4Yn/yYtz4wkRzHslKEKLY\nkpfa2WYrSQP2KVGIMOuCztT66DrvAuVBrns+axJhx8O/ezUUF/YjOVfh1OUNYaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/IZ/aixQmbq5YI2AoiiBgjotFxowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBzpBo972Mo647CMlRnX4O2tmFCAzX4\nUO4AK980jyV0cQIgJGj/tLnvHvmm5kvDW+xIyl+APcxi38DhTjZXI31IpnU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4621", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4621` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAS51YqsXLe5Ifrc4vJ8zYWLIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkYjFmNmY5LTYwMmYtNDM2MS05ZTFiLWFmZjY4Zjg3ZmJkNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUwMWQxZGEtNDE5\nYS00MmU1LWI2NDYtOTNlODE1ZjYyOTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQiLC4lYuAdKbmW79eYrT6kG+DrN4R7pU+kE8DgDmeZeJmcDzcLShd1CH2T0p\ne5SHJkOgzHk8Lg7/5mKIGTUb1KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMHH0TcV1gmeYgIZ6wAVT2PSTZzUwHwYDVR0j\nBBgwFoAUqki7MKv6/S5vLg0id6qc5suxqpIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIF5vmz+GJPz1MbLFDkpjj9unvEKq72JFv1hA8V5G2UYbAiEA\n3ciKogR+wF4cjVt/BIyf0oqJGUeVNttSYCjIvYttN5Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVReWOzUHEMOaSvPUcs3yS2fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGIxZjZmOS02MDJmLTQzNjEtOWUxYi1hZmY2OGY4N2ZiZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4ymf8/gkW8qGqUZm1ynxaHJ4ghlj8h/ab9+yzForlIp/t\nyahnTAnxk92Yc4Y9K/8FGVVnx3DNIh3x56kUnbzjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqki7MKv6/S5vLg0id6qc5sux\nqpIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPjQ0/+vocu3Oqsuaq4wWPdjyoPYYKwWlWxrwYq4vOQRAiBEJzWpaMfE\n1KJ92OZ2F4kT5moaNGpbl/Ne7Ufx+GoQ6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAb3ofekSYKdA1RWKL47OkP+uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUwMWQxZGEtNDE5YS00MmU1LWI2NDYtOTNlODE1ZjYyOTY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDk4MTRmOGMtYzE4MS00NmE0LWE3YjEtYTMwZmM5ZWFm\nMWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbSzcCuxAGPD5x6tvWs/5JaVi\nOzc2lb7UCbFbxuyczJkXxh/JtEUNkLy1EGdXax+lGJIP49VdowMFkmwzITR/36Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMHH0TcV1gmeYgIZ6wAVT2PSTZzUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA1I29cAwlK34uh+xFu6S0mSfYEiLX\nfQbr6vkDdxEYUpMCIHCYbqdLwYN7d63/39k02SucHAhlaPdlRxGotBJLc5vI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4622", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4622` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQ2dekwhgAFc+gE056SSGD/gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhZGM5M2I4LWM3MzMtNDc5MC1hOTM4LTU1MDU5OWNmZThlNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE2MTkyNWQtZjQ2\nNC00MzZhLTkxOGQtMDk3MjRhMDYzNmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwBAVlBILUmeova/buoA3LEVwXYL46CpHxd1BrIdOhWeZflOaOs+ySKkFxjZU\nySYFkLJVr7Pf2EhMI/D4dH9BHqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtdWUrFyrHeb2ftjD4CyzqHn76qAwHwYDVR0j\nBBgwFoAU2B3LrE2NDR/E7RIj5ByRI9ETkkQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCID6db3aBE+Bjme7quUVEAGD+gxUJl2gm\nae5vs/SZ8hWVAiByMZYbP/zfY6KMN5CJVddTzvl7aGlpEUh7DdBGUsKFTQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYkeX/hiZKuBYBHzDzmK7EBlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWRjOTNiOC1jNzMzLTQ3OTAtYTkzOC01NTA1OTljZmU4ZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATM7wphYFilvdHHex2PtpfkvQjD0AZ/lRcSGt/xqN7V/h8S\n4KFoJMMXpZjd1Y+oHdaK4rMud5N9qog7oknUSh3Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2B3LrE2NDR/E7RIj5ByRI9ET\nkkQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDHsF4dVsiRGhQ/Hdls6ZG9lc+FrdyhG8uRIefFT3Hi0CIFL8S7gCMXqv\n9unCth+knkrw49SoR5k/uKT0sS3hDSDH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAf7y1qiC0bA1Tz272vV3f6XhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE2MTkyNWQtZjQ2NC00MzZhLTkxOGQtMDk3MjRhMDYzNmU1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTMzYjg3YTYtN2FiZC00Nzk3LWE0YmEtOWYxNmViMzIx\nZjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+02TjFwti8RXqKQYyAnDDsJF\nzIt9vO3Vzf/Jz0HNpZwoLMGcVPklcSZmY/VlYeYmqULIlNcezKzbDXIzTep+OqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtdWUrFyrHeb2ftjD4CyzqHn76qAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBR7rriI3J6nPl5a7Y9Ic8xd3fi0J8j\n0qc45i2jYkKeIAIhAP7cJ1/t0RpMwdRQvuu8vvnW67ad8+3F6RMvo9CHCwHQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4623", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4623` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISARgS6P6iBrm4JKEB4YzwCxkWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkNmM3MjdiLTYxMWMtNDhmMi04YzdmLTllODYxY2IyNDBmNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU5Y2MwN2EtNGZh\nZC00ZGVlLWFiZGQtMTlhNjY2NzkxOTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKLiGTkuzQuHWFSfAqp+YXTKy/s8N79hiE7aQ2JvpJtKP0W6CjmcOh+b//uPj\n78WyQY9tDgBCDOkMi6o/zgDM4qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcLkDw9Wgdqot+gJXwnpmZv+Em9EwHwYDVR0j\nBBgwFoAU44c6bKnAkz8AB3mm7XqJrAsPcQwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEWWlGKEabTyRibkMuOhSj+LSzJ06sai\nCPNfqG4vbQTpAiEA8VokJaU7N9BW8w84TWoReG0xIa5HM+0hNtbRHdZcVG4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbkda4ljF1ZRxdxurD1WLOnkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDZjNzI3Yi02MTFjLTQ4ZjItOGM3Zi05ZTg2MWNiMjQwZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPyfSADLvnP/UcgiOnVPP1DSEue8EW/pKe9gdGdB+9B3h5\nsnCBKF8uWCgTZnPcy0Cu8Wo3HoVF/m8GgtVIfYSao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU44c6bKnAkz8AB3mm7XqJrAsP\ncQwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIgNnvTMcdB5mhXXA2MqNXjJxG7eo1fGIKUD3EYpEK7vAiEAg/E0iIo+\npeFLHatnk77JZJCrt2qDUZUu1A0DbHNqslU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWdoi5TNwrr22KqcXH3AaqNFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU5Y2MwN2EtNGZhZC00ZGVlLWFiZGQtMTlhNjY2NzkxOTljMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzA4NTA5MzAtYTFhZC00OWMwLTkzOGEtM2IyMzBmMWVm\nYmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWdC/eOEfXS3T/xeRWo7XIEC5\njYwIOTJld8FAhsaXtoC/rQP2FPj/jiSopDRitKvu9dD8kZ3BJRnFF3FSNMkrb6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcLkDw9Wgdqot+gJXwnpmZv+Em9EwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBbwJDJaPZayCg3mcMy1qXjadtiF+gO\n7XLo6HV/keEwZAIhAMvb6M8CwD8UlTKIHCwWQAfNrFLK1B3JQImrZySE+uJv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4624", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4624` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATv1+jMdk510Jzb692a9KFohMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MDhhYTA3LTUzMWUtNDM5Yy04NzNlLTM4OWM4MmQzOWE3MzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUzMTg0YTMtNTk5\nMy00MDQ5LWE4MGItOGYxOWExMjc1Njg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKg7HUK4YAocD1UF/mHQXmW7K9UKQzaGCslisTOyg7zkxy4bBfIKa+VPV93D/\ny9ZVClRU81eoSQWj5UoUUwUq06NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFM5MM+GY9WFf+56x1aX0EZcKnDvUMB8GA1UdIwQY\nMBaAFPslLWurzTnno8Fdl4vikBna5WkSMAoGCCqGSM49BAMCA0gAMEUCIHPQWuDy\nPV7fzY1BxyKpfbwMIzt4DvxeKq97JNhJJNAFAiEAoUyrYbSrdv/Ra/4Dlz4UGtSh\niVUm6StTARJClOIsgks=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARTzl4MS3+kByZLYyV0WXlnvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTA4YWEwNy01MzFlLTQzOWMtODczZS0zODljODJkMzlhNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFDWOrMOBSDdAaYMqW1F7p0IG7WHK4UFREMaTd26TvpSHe\njeN9nNwoge12fRn3oKrrKMtJJ2zqiIOn0qqN+5+8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+yUta6vNOeejwV2Xi+KQGdrl\naRIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU31Va4RDjWTI1B9LWJ6fEeTuQ8AEBTeG9EmYVyQCzgYCIEct0Vmwy2WD\nyX7d+CKkSGFowpjKknYKzhyS9eV63gKx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAYdVVaA50miUBlLy5v+iWlsLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUzMTg0YTMtNTk5My00MDQ5LWE4MGItOGYxOWExMjc1Njg0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTg0MTFhZGItNTY3MS00ZWI1LThlYzctZTQwZDVhM2I2\nYzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExbd27qoUe0aHPqRS+6PZBVNF\nD7vIHQLI/UxB0wRIqJgcbKSP1nLxFvtSUwbOFTr/aBGfoAp/tOs5E+QplCwZnqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzkwz4Zj1YV/7nrHVpfQRlwqcO9QwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJpixx/TI0Vsenjw\naGC7vq9UQZJVLhZuh5qRojivFIUnAiB/YH9zEG1dI+Bf6jNEKdqwAqm0iYNvay/b\nZ7GEYbjJVA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4625", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4625` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAUxgNlcknMEG2/H/ltMrsZMrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlMzMwZjE0LTIyM2ItNDdjNC04NjBlLWYyZTMyMzA1YjFhOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM4NzNkYjAtMjY5\nZi00MjY5LWJmMDEtZDY3YzRhMDExNWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwHm5pOZ0hxq8R+WrZ6hzIcHB3qLDcCTmP64ZF7iFKnfXoNMoyqxMZwcHmxCE\naQHwt/sd6p/rMCo9/lkSeLLxaaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKKY9alfpR1bxs+kcfbjYZ4C3kzIMB8GA1UdIwQY\nMBaAFKYXZVg/mFyNtpYe7ueMh3EG1x8rMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAwl3LKDnqeA4BQrKKGMDzhnoGbXZw5JRL\ngWmBVuQmkzYCIQDJCL+RgygdWFs81M/CGqe4s1zwlY9dnXfNS5N+8t7Lsg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX1axXe9knzArNh0PwvUyMhPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTMzMGYxNC0yMjNiLTQ3YzQtODYwZS1mMmUzMjMwNWIxYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWf3ntSsODDkCSRxGqEyyqo5eCCtt2ScvTaVfQcFmQ6NWs\n8gJO6/NIQMcBAo11ojQsU5ZGFdbl13PkJ9Bglk3Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUphdlWD+YXI22lh7u54yHcQbX\nHyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG7T8BVoNflyrNOaxEN/qSbsLSUwngmj4As5A9ErpTHsCIBPrvmdrPd7G\n4VGh1AB+nm75JgS3eM23tVjuYYCdNQPK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISARs7y1LGU7uhwEFxBTM6OUC7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM4NzNkYjAtMjY5Zi00MjY5LWJmMDEtZDY3YzRhMDExNWY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWY3ZjgxODctOWEyMS00YWIzLWJmZDQtYWZhMTUwNzgy\nYzIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElIGsIL9F++MfvfXrDrSiFVLV\noEZX6gAOAcCto2DdGk2ARWcAxitTbYCFcFgdrFTAlmib5wS3+C0xhTDMkS629qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUopj1qV+lHVvGz6Rx9uNhngLeTMgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgIwGtzPglW84/v4rh\nkAyExtT+2g/EkRKsxt6m7my0B+MCIFkcEhyzQkRaxI6DWm4T8gT2pkiyd3AoLUyh\n9CzXDgan\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4626", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4626` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAbhQCn8O4fJOpyQW+Aopav8+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NWFmY2FmLTIwMWUtNGE1Yi1iNzVjLTllNzQzNWY5OWU1OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVmNjExMzctZWY3\nYy00MjMyLTkzYWYtYmFmYmE4Y2I2NzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQvODmqMQbRShn8x25r+nFEu9KIDaVSnPotEUQ1BNMyKvn2ADHq1XI/JpMQ9Y\n0sAIFo1Z/G+s9WcceA2u8SKHKaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIbWkHGobXVMj4vnkkL6n6gxMQ2OMB8GA1UdIwQY\nMBaAFKWSRaA3kTzkq8SxSKSBBLJpMI2NMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA7K0yzpxk1wl3fY5f5Fz40GuWqKTFfZPy\n0las53SRe18CIQDLChVel7/GR7pkU1yzR53Z0gUJFr1NRJFvgMxpA0hdNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaOGYdrrNONbb242cqM5yMN0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTVhZmNhZi0yMDFlLTRhNWItYjc1Yy05ZTc0MzVmOTllNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoURf/zv+/f0nKy7Bv1GfMac7W+8n0DwLWralVjJhcpzKn\nHxHoROw4lOHLwR575pTGdnM1yYRbhvpud8grea8To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpZJFoDeRPOSrxLFIpIEEsmkw\njY0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALgo14W8rT06Ppl8JItSU77H8uUGHYdT4Qvkk9FymTeIAiAsJvAZz/Ue\n9lPSOphhVGHPHDz5m9AQ+Y2AjTzOGMhp9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAfZLTMLpufzm7VDf0d74mQF8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVmNjExMzctZWY3Yy00MjMyLTkzYWYtYmFmYmE4Y2I2NzAzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2Y3NzhmOTAtMGE0MS00ZDc1LWJlMTAtNjk1NTY4ZjBm\nMDc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEshBIxY4yaimqwyjQ5gLBPSuj\njj/tzLykNu/l+3gUB18DYbYd3KEbsMXyhjonSMlVRZjnz6jzQv8j+hLa46NY6qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhtaQcahtdUyPi+eSQvqfqDExDY4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALMeEaShvZyZ8Uz8\njlsRSdNH2BED4FeXOx5V/eNg7uhiAiEAxtVAO0Oj4xU7XzcthUbxc6Xo/fPc4faw\nspCnhBINma0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4627", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4627` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAZmSKpsoBU+wPDGJUCuRDAh7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ZDBiMTc4LWUyM2YtNDY5OC05ZjgxLWViZmY0ZmI5NzEyZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc0YjZkNDYtM2Vi\nZS00OGMxLThlODAtZGY5YzEyZWQyOGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtUWXmIIt4xcMh5pUzQs+FBUQDvy7vCdXifZHJ8f68D/9RfzWRi/l5zn41HW6\n7zK2RyZu/eJn440Q+73Kea0fS6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRxETXYEiZylHwsACc11Ln5M7HUbjAfBgNVHSME\nGDAWgBTot2noOLzU8dU0dvb76F6zS3GIiDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDWS+7h+e04g606pOaEr02OqSiNatHA\nqREObxToyutx4QIhALT/XSMu2TSkTWmNTb4IKqUrG2bAU4D8TbtfkUXL1PF6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX3QjWeWBXOZkubciC49VIHFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2QwYjE3OC1lMjNmLTQ2OTgtOWY4MS1lYmZmNGZiOTcxMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2+lRYOPDSDwFkSTj6v/lNCnGCEDaWlYZsn27O0TA0YZHq\nIygjYPnHPEWplabFguWLeFKXJOPJTDjkwH7y9IkZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Ldp6Di81PHVNHb2++hes0tx\niIgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPzP317X1Avdx+vZjGpVek7NmyXeKL6bE5cTGNhRDjKMAiEAz4avtPVI\ni/D0+UBiVC+9Qu+bfF3OV9IFZT8MUkKTaQw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAV5nawqGCzjU8WiJ4Rx4mv2ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc0YjZkNDYtM2ViZS00OGMxLThlODAtZGY5YzEyZWQyOGFiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDEwNjgzNzMtYzdkYy00ZGQ0LWE2YTItMWZhYjk3YTVh\nYmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJy5zWsWI09yVG9A6pVDNztmd\nfLTESQeXGS4OPF4qLeCSYzhk4uPhbHumchhZgfgyI7KEIMp42XC8q0kgSNUkHaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcRE12BImcpR8LAAnNdS5+TOx1G4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgCspSzvgu59p2qMsd\n8aMu5VLVpmsJ+OWeCwlTPJv6PM0CIELAer4xIeCc6tU/hlCmi1u27RzO9+Ous49d\n7ES3qidT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4628", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4628` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASFjqKFVvbY0Ow8NfMfOmkd6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxN2FkYTk1LWMzNjUtNDRlYi1iZmU5LWU1MTk1ZjljNjY2MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE3MDIzZWMtYWFl\nNi00MTdmLThhMDQtMDBiZTFmMGUzMmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFwYkN2zGyp9X+AKopXgO7hVOSq/VldcxSABsp/lLCo2sYeRN1mjvQ2WluvSb\nGoRR/kaMTEZ2LVlud7CNZHU5lKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrgXzS/65gdI/jbJ9HKBFMwz1REMwHwYDVR0j\nBBgwFoAUwYCPwkrA3Lea8VdqvhjXhrWgXvkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAJWuOZHAy397i4\ngdS1ibd3vOPbUoItfVt5mB73ZPZKywIhAPW4K8tp5EMgB7Wtg2bH0kZMsGM4uebG\nGHuzFCzKPWPp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYcKm7tPmYLZbgG4gVi2fr6KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTdhZGE5NS1jMzY1LTQ0ZWItYmZlOS1lNTE5NWY5YzY2NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJeyMZcXruYbnAVHHzOUlmpeHy0O5oG6njruVzLut9i7gX\nueZAwPj4UHwmZf1awYVyNQeegD7yW/9jKK0DWzIDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwYCPwkrA3Lea8VdqvhjXhrWg\nXvkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSW3KcKTKFdwLrTvV+yPM2LwHk0+/Z08GQI0wLez7qhMCIQDnsVsHP5sY\nxLuRK+YWSoesSmR+tT61qHtHIWlGi+Goaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAUFSvDiW4hEFTCFXgy1JEpswMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE3MDIzZWMtYWFlNi00MTdmLThhMDQtMDBiZTFmMGUzMmI3MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWVmMmI2NGMtODhkNi00ZDY3LTlmNzgtZDc5MWI0MTQ4\nMzQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3p75OSYZQaoFJYuxKHNiMiZA\nKpWllEhaSBqy4acDzZRHbrQvGkX9Jf5c7TTJiS50pjFtgU0h7zz5gqk7GJIMJ6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrgXzS/65gdI/jbJ9HKBFMwz1REMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOf0QuHNfqvCpN3/\nbEYwSPyp74JlrQRUFRiZEk3BLgxWAiEA0n5CoeMkOw8FRJTqa2yuNkzzhOmHLJGW\nR6R1BrFX7eM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4629", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4629` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAavAaCRNb7t4sB0h0kzt3C5XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2NDJlZmZlLWUzNjEtNGQzZC04YjgzLTRmMDJmYTg4N2ZhYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhkNjY1YTYtNGY5\nNS00YTA4LTkwNzAtMGM5MjE4M2I3NzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhnQukHJ64rVXhFHB/L2e6gqmopQCpu2dcRRfVszSs4Rpv9EU7ztIdkhaxgmy\nVoogIZGHAy2UVbRKslysaEHYfqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdFAAXX5MzoOodnLi3D9dj9gvr9owHwYDVR0j\nBBgwFoAUml3faE65a9CZIUIRRmVJcdYzoVMwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBC8U4pqnc1tAd5\n2J0g2i19jQ8wPAenyNVnH5czogSX2gIgT+IqIv+Gavl89tm2BjtFnHRncr698bkV\npF7d7xtGI7c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfadj+qEFYLjMO+ADJF+q/vTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjQyZWZmZS1lMzYxLTRkM2QtOGI4My00ZjAyZmE4ODdmYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1ZXi/tNEimub6MXuBcgXmkgLyfSpLq7u3j7L5vLX+n6+Q\ns/C53pBsoskBOYWwMFgO1Okyq6GISKJXybzCxFKUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUml3faE65a9CZIUIRRmVJcdYz\noVMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgexPrcBsiRe2xZZNwYbVaKnEh9LG7VH0qXkp+hG5yMYUCIQCtvjViOypk\nteMXsvWDdibYcKo6eg+w0cxvuDdb+L7Pgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAVQWYw9EL1/5MX/lIhiDbVDVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhkNjY1YTYtNGY5NS00YTA4LTkwNzAtMGM5MjE4M2I3NzRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTY2ODFlNmItNzZmZC00OWJhLTgxMzktMjFjNTFhYWMz\nYzZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER5t9A2j5PIP5z77y6avojFHp\nlcrYOeU0gIZcJ93AESKvchQ+Z+1rDhBcPOGQUN+V+x54MmH9UKvz9rD4oll9kaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdFAAXX5MzoOodnLi3D9dj9gvr9owGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANq08Jqs85z3Vt47\npFaMoF3gAjYbpOCbDyDSgq4iR3zsAiBw5Yz9jaqFyJGfIAum01Iu9GdAvc4+8BRS\nmZsOgf4Ggw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4630", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4630` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAcj3C9+cd/FcaplSwsmkkgFnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmYzJiYWU2LTNmNjEtNDg1ZS05YzhiLTBlYTcyZjZkZmNlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI4MzUyNmYtOTli\nMy00NjUzLTg3NmMtYThkMDE0ZmQ4OTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENO4UaxHNyQcnqxqiZ0A8J0ZXsECdcm29HN5AufgV12Tb1kXMbwCKdtLBrFGN\nkkmLwZHwtcQmtl55Ui9hxTcjOKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQmGd10pdFDCpHmK0ketngrT4YrQwHwYDVR0j\nBBgwFoAUWC/JXMshvj1r2uofoUOY+5KX52IwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAn7nqlhoWaFBe9rkO7tOA\nbbXrEoFSa8mal8Hbruap/XcCIQCBjuA4o+BbcMPL8wBjwTcGTEfsN7T+9gHD+Kz7\n062YBg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASkUIXzL/5r3td/9jbucQXvHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZmMyYmFlNi0zZjYxLTQ4NWUtOWM4Yi0wZWE3MmY2ZGZjZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATA2iJDV3U/dT5SiRpKYcv8/f/ayyCI7FP4zwUJ4q6aqiO+\n5FxzmwjtHPojzLjU5eGR72a/yu7yYDOqk4rEZsOWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWC/JXMshvj1r2uofoUOY+5KX\n52IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJNReBlfCk91Cu7rpOM2GYOPoMJvQt9YXS/Ip/JX99xWAiAR+Qn+E2pe\nfnWHJUMoZqpVx26V/SWGWlwkSrR/Qkai/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAQ7YTfJarF+TrzmHo8mDgfSgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI4MzUyNmYtOTliMy00NjUzLTg3NmMtYThkMDE0ZmQ4OTAzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDRhN2RjMWYtNzIyNy00YzlkLWFmOWUtYTk3ODZlMzZm\nYWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOnNCyBpMeGLDi+LdJhQuhA1K\nB7iIeKxgufVifkuZtFvvKvhBMLQ8OqxosQzxjHCk1oSL4KjIwPFv2dJoV/Wve6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQmGd10pdFDCpHmK0ketngrT4YrQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIG86nsmUHlz7ENN\ncsL5fFFRWgzOcJ+YAEItCTX1v7ThAiEAkJJsjRPGENPQJVfXYKwEsZRZ62J8K+oK\neUeAUoku/i4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4631", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4631` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAaXjivBDX075dBymsUHl6ePZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2YmQyNWQ0LTE1ODgtNGFjZC1iMjIyLTU5OWRmNjYxNzc1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlmYTk5YzItY2Ux\nMC00OWNmLWI5NTktODJkMTZjMzYzYmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/z2aBBJHgVoiG89+E676C4A0fhRi+rePEuPLVxmIQgSmH+7sevCu56T88pT1\n2bGUfjMmEDEM6FMZXqdbeOyNkaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbyS1Gfdxq2hA1dwHRn0L9Q0V/tMwHwYDVR0j\nBBgwFoAUnmRdBqyAOiV9jOCVGeeUb3P1cXIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAxN7L0\nMrbXJw26ScN4m1cHcGxvJV8jPcbl0Cmalay2wgIhAPElOa7gDv64OA/US384u4+Q\nV2RxJwHiEYcDHvS+f3Ad\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZhsfn7AsZQIi2fZOjxYbkDQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmJkMjVkNC0xNTg4LTRhY2QtYjIyMi01OTlkZjY2MTc3NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATf5h7VbPZ2KVQ2CKtM0j9/41ATYuo5ZtformV0uO+BTvy+\niVfPC/MIowTvp18ADmF1X9imfZypyVGZLKGnbxCLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnmRdBqyAOiV9jOCVGeeUb3P1\ncXIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPbbT8Qa/1BXMfxwATkXALqXRR2DM1PkICOBy9jvwa5MAiBSanfaOUP5\nBOP7+e3p36K/3Q7VgizJIRj//hYfw9YRcg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAR6Q2WlJvCdYuCJ2z1BZ1/jUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlmYTk5YzItY2UxMC00OWNmLWI5NTktODJkMTZjMzYzYmYwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTBjZTY0MmYtYWM3OS00YjM2LWFiZDEtNGQ4ZTU3ODQy\nZGExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAET+FRFrlleU5DDV3nazytCr10\ntkPqgMkBSIn+v6287j4ob+kKqWIDglT3H3ee+gUf+Xgx9vKwbEx1t5FvW0j/9KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbyS1Gfdxq2hA1dwHRn0L9Q0V/tMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgKPXG4xWm/TvSFXI1\niO5cGhiXIl1Ar8Mowr1d5Q+Y8DoCIQDoRkKdOo/mF3XnMpQZyz2OiygSSXnrtQjb\ntIz4cEYhpw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4632", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4632` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAXxg0IEL/l54nkhhqBk7iwdaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzZTc4MjVhLWE0ODUtNDM5ZS05YjcwLWJmM2JiYmJlOGJiOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU3MjhlMmMtYjk5\nZC00NzNjLWJkZWYtMGY2N2RiYzhkZTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn9EkCjFJyRYnjCGZ2yN5ha4hMtxr/wAxuyPCUjU0rgvMleH8DM+fJTUwqAha\nix4d/OENvDo4BQG7GGH0TKObvqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOdfDZ9PnfEJox/UsswGP0CjoQKEwHwYDVR0j\nBBgwFoAUDihx9ET1cWs5F0QCiI8dK9vM/iYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAr8kg\nKGNDuyDYjepE1OfTsKhNWYU19smnBxKAr1FwpyQCIH+4uCA2+1uc/7WNlBQKeFCK\nJgonfseRyGOZ2SqnQT7J\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWikFMq1HWNdKPtq2OfXLgW1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2U3ODI1YS1hNDg1LTQzOWUtOWI3MC1iZjNiYmJiZThiYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR7mxppW75Wbf0TLbOCBjg16+9oC23dpPX9UdjxcKMjObP\nweJzfJUvpvsCrICTqzVOLDhz3tQkGyu8FvJAnorGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDihx9ET1cWs5F0QCiI8dK9vM\n/iYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgd86FiPF/UA8KiqQt589+He29QZK1YeSCBrFd2TrBjUcCIQCJzqfMODlv\nM1VWLE7Fl+xCo6ihJ+peIVM/r/zvIoNeIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZrOeQuLmfb+EMJSO6k9Yti9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU3MjhlMmMtYjk5ZC00NzNjLWJkZWYtMGY2N2RiYzhkZTcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTllMGJhMTAtYmQzZi00ZDU1LTlhNWYtMjUwNzk3ZGY0\nMmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvdYdMZT7p6udOcYH9oMxPNGz\nLYNlSN2VoF8tpAdvGGGsfDjeFCMRlL6doPCnwM9MiVy6RKtQPfdtiihQ4zbZx6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOdfDZ9PnfEJox/UsswGP0CjoQKEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKuBNwHXvbdKJbKV\nEt47PjnIq/vQ4aBvhSD4UaEHV7gqAiEAyVAMjIZJkc5w93AkyIcHihZj2jVJ7IyP\nIM4oRihUdnY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4633", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4633` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAfCX/m5IfQurb8uJ3OO9shF7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmNDkxNGI1LWM4ZjMtNGY3ZS04ZWI4LTU4OGY2ODM5MDk1NzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjAwN2FjY2ItNTAw\nMS00YzAyLWJjZWQtMmEwZmE0OTBkY2IxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU8/PCNzTpIVl7TAqlsSLnJJGJCh71KebwDC3u1kJcIOZFo7pfkwO1okf7nxf\nOCDKxjoZcj4vOfI/e9YFoxcGtqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKDRacJyNkXBKqiHWn3ir7JlplukMB8GA1UdIwQY\nMBaAFOOC0hHWJVak0Zx9g2Gzxl45y9s5MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAGkby264A/2cVj2VyUo+4sV13b7TkIbxB/\nhnulzrQD5AIgf5Wy9t5ki7Bp9Sbt4oN2+Bc9wQAX3l21hJPvurOVCpw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWpbQIVNyiqlVbIpQvCPKRkfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjQ5MTRiNS1jOGYzLTRmN2UtOGViOC01ODhmNjgzOTA5NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/Hp6ErI3flJZYCYN7WcsRE3NR2ftVoVcNO/Pov8XfXmGC\nYWp2W52cvcigCcugPqUZzPlNPwxNFWJf+1Jeho5Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU44LSEdYlVqTRnH2DYbPGXjnL\n2zkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPljtyMqJMFolEFEDILhlOp1Or2EYp1EtLw0VSXEI4dkCIQC9o/IgATZG\n1AYMnSmrSjFPL86/VqeJTGD5wGSdG8l9+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAePyA02UvBqnw8nag1Ng9dA7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjAwN2FjY2ItNTAwMS00YzAyLWJjZWQtMmEwZmE0OTBkY2IxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDc5Nzg0NjUtYzg5NC00Y2NkLWIxNWEtNDUzYWUzMGNl\nNWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEq7Qv7e45E+ntEoMw7BXSwRY1\n4vnLL+nF468UbQ30PR87YYgotvtuudgOHceb/YFvBwwgFuUYunjZpCjCMhFQa6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoNFpwnI2RcEqqIdafeKvsmWmW6QwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIkoIADv5C2vIHO6\nQhdjvibornG3bZNmFqVXbovvI2/JAiAgOqgQwm2FkshiV0p2dx8I5BdolRNww4/i\nRHqnux+AwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4634", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4634` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAcoWXCZm8yJq3iFwNW6BvmFuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMmE1NTkxLTU5ZDUtNDdkMy04MTUyLWI3NjM1NWJhOTk3NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI0MTAwOWItMWM2\nMy00MmE1LTkzOTctNzg5ZjY0OWZlNzYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEowCtv7gDBQEo/0AJQvVYdwxEjUQ+z4Qp5JgGNer1fThxwrfSOKbeMNexEsTF\ndMGJiKaePHx7+RMUWj02TxwWZqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg/ip0DUwM0aa6+k9CJF2MNLRphMwHwYDVR0j\nBBgwFoAUm9EYk6fbXxhyYHQSoD1rRUCKZcwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgazrpH0RKkrJT\nUzxfdClb3VGQx1hX1tVoCzZ34WtV/y8CIBPFuH5IlFsqIuwbjceQHHIm1vvk7hBz\nE6UmVMQIpysm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcbOQOoCDJmIKmDoJ6r4TzSsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTJhNTU5MS01OWQ1LTQ3ZDMtODE1Mi1iNzYzNTViYTk5NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRhYXca0QhNdbT79prQ2WZ+viVY4OremnQ8CCJSirL4iHQ\nW/JbRQ21Ivf3HEq/OvGz/TR4tqBG0YuOYD9UmQA0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm9EYk6fbXxhyYHQSoD1rRUCK\nZcwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPNRArLH0dNaQoA8ItQ/hbs+slpcx5+Ucj+2MSvd4lJOAiEAtR25cU2x\neImv0nQjebtrGk+guYSviae1Tj8zWESyzmk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAY0NzfuKKNDPH+NbVm+6k23fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI0MTAwOWItMWM2My00MmE1LTkzOTctNzg5ZjY0OWZlNzYxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2U5ZGVjNjctMjgyYy00M2ExLWI0YzgtZTgwOWJjYWQ5\nNzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsLm1/ni0p3Jkp+td7NVopQda\nlK7kcC7n+EArMHPxCLkiV5E5ByE8cSIYDQH+avbS77EwVmtmLBmYOW2Lln8BpaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUg/ip0DUwM0aa6+k9CJF2MNLRphMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgBK0Cy8hWeW6nFknE\nc/OS/C197kRDE0MtrxaxvkCh0jsCIQD7X3KLIng/TEYj6zCp8JvgvI+1DI3Fb/3r\nWYfuvIeQxA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4635", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4635` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAQuII6Th1cDdsOTg2rw7uNXsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1ZTk4MDJlLTQ1NjUtNDVkZS1iNjUwLWJkMTU3OTFhY2ZmNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQzNjhmNmUtZDcy\nMy00ZGRkLTg5NjMtYmE3YmY5YjNlNTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEURFKQ/B/uH6/HNOdlz4fOgLAsZ/K8lx0eoYqw6lrL0FqLQQLrWnfVitFrIq4\no52M8G9cRBtioHx+w3quKkLuWqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4hp+pnWugrIloyhGcENttk6HTSowHwYDVR0j\nBBgwFoAUrES1b2YRG5Z1hV3f7qBvzmTvtu8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhALTqvHj+FBt7\n0eXFfcJhwwhoITmEVO39sr7WShUF29WqAiEAhgnfhZ6JtrFxhoq0oBgwpuj+Nnrc\nQE6uFWnFvsY4UlE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARoirG+SkWkLGFRruRU7R2usMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNWU5ODAyZS00NTY1LTQ1ZGUtYjY1MC1iZDE1NzkxYWNmZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBIwDj/CuBfgGsqiKMaBVKD6btWyCLEtTWHM6Dkqun5C50\n8LBSPUzzT0moWc0mTC28cGVEujx1aD/YGclhhMiko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrES1b2YRG5Z1hV3f7qBvzmTv\ntu8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMp0vqtwaxaxy5fzroh4UC/b3E93tVdWtPne888XtnjEAiBVAcYGs0iT\nNLjQfd3HAPWzGBtnRe7X/JsVjLsoincKeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAX9WzpnPE98eP48zOJnH2YkfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQzNjhmNmUtZDcyMy00ZGRkLTg5NjMtYmE3YmY5YjNlNTlkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQ1MWVlMGItNTYzYy00YzU5LWI2NjEtYzUxZGU2YmRl\nMzdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECKXQR6cOvGwq8bE/vTzW+oiX\nNFJ1Y8ki6aHypxKNoFy8oHn/KndI0N67xvJQ49XahRlJsPwMlCtpzm10c37lnaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4hp+pnWugrIloyhGcENttk6HTSowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPjfnKxcjoiUoQ5t\n5wonf9sAvH1TBDmfJQRrlbeseW27AiEAzVn83TssVFzoa/tdgbT7c3WS1L9U75im\nzXsrcEksJsM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4636", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4636` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARqduvm0raNTI5y44yBbMS6PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmZmRjMDZiLWY3M2ItNDNlNi05MzJkLTI4ZDUzNmQ5NGYwYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIzNWUxNGUtNTZi\nZS00OWM0LWIzYjQtZDFmNzk4NWY2ZmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2izSzhCIeJ/CY1wRR4n8O51jMiwVN/3XIq3asL3NcNRs2BlIVzFvLvRXshHI\n0T+s//otk51pJgTws1JPMoFNwqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0UJh6dwSFiqDAJoM8bkYff9nXAcwHwYDVR0j\nBBgwFoAUmVNJ9nHi02koy40GK6gfec46bPUwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDoqFzuvU/2\nrqbKEIu4HAeiMnuxA+mozcz++hyk93Jc8gIgMu2LA9RHjWX8PJjNwjROz440h2Y7\nnWTIamnM/3L/j5Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQhaDcr7Gm+Zh3h5UuhveF6QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmZkYzA2Yi1mNzNiLTQzZTYtOTMyZC0yOGQ1MzZkOTRmMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDEchXCoqUk3OGvjvmlJgXDxvJXcFvoMmwDpjYjfFf6EmB\nV6vTeKdET3qlnRQ1okh4UhnPGUNn8oocuO/ZJLLOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmVNJ9nHi02koy40GK6gfec46\nbPUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPdG6+zDFqMd8LPUvd9AAzD1zrfCXtfhViBVA9HrCF3PAiEA/2LlydLm\nkVk+5WMi4HDg+9auM5qW3CVekXxK0ycI1hc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAYiSrmpgi0k1M1HxNSFXeMyCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIzNWUxNGUtNTZiZS00OWM0LWIzYjQtZDFmNzk4NWY2ZmIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGYzYmQyOGMtMTViNi00YzBkLWE5NWQtNTQ3YmY2NWQ0\nNTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgTGpI7tbnNLS3Dr8bldwTznO\nbRey9tYN8gVeDgn7plECcvFF8QkR9BYo02XgejHaEjbDS0+IAISi3FXN0wPHi6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0UJh6dwSFiqDAJoM8bkYff9nXAcwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAItHsxhVlmUa3YDq\nL87r1YK6Zu5EHwh469INDK7phk0RAiA+1tKE4bPSETE07KAS8a82wMr8cXZAmTzV\nnZ7NSqlaCQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4637", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4637` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVsLQeM1D6CBLiyWmoMOEnBrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3ZTk5MmZmLThjMzQtNDlkNC1hNmRkLTlmZjQ5MDcyMjlkNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYyZjFmYzktNWM3\nOC00ZjQzLWE1YzctMmQ1NzI5MjUwNTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhAlhZtKwjvWHHBso/d+lGw6sUjklh8UwyTiHoJ5vC22fGTjgDDVsBT8Nph4h\nMuYuadETTJs8bIb2YS0A3nCnkqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNPXfxjqFdQcLxnML5dsFPxAFBNUwHwYDVR0j\nBBgwFoAU5ck8gACCbRopvvLdmSIKWme1lkswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICFSjJ6q6DPhNFTunjhQUZ0yY+UI1tKg3cd12+2R2efcAiBGTHoznnrx7mTY\nX9yd7oo+hCqPnpnyGVVvMLNiYBXmyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb6HEkwP1zQQG1UrS5q8Sd4YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2U5OTJmZi04YzM0LTQ5ZDQtYTZkZC05ZmY0OTA3MjI5ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGo63g/8UawM6LAHzYAuz7vwbv9NoFf+vvhXaFYv1p+hX0\nZsPkW1jiVdtRLqRjwSD5Z1Ir415IAH5UIP6MhkOEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5ck8gACCbRopvvLdmSIKWme1\nlkswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZa4wnxTRdOHpwoOXL7pKiaz8PfvmQXCKttcPj/pL5KgCIQCiaKOTrtlM\n9BvdWwtdtMzAPs9kbDnsXpDnf3Yok66j1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISASr+ponL6/uJhigmQ2gCvttIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYyZjFmYzktNWM3OC00ZjQzLWE1YzctMmQ1NzI5MjUwNTJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWRmZWIzYjAtN2QyOS00NzllLTg5ODMtYTlkYjI5OTcz\nNmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0JW7ybKadYbqaDTq62VuL1Uo\nutrERSJNB5X7mQvSBbRBlw2Ga1PCoQKHQKCJLxdz5snzQjll4c/KlMUn++TC/qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNPXfxjqFdQcLxnML5dsFPxAFBNUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgfFDHb+qzaC1CBfgF\nAWaQPRPKZjVOE3+2qJr/NlAgb/QCIEpL321GLEO8zHYLN5Vt89gcthDXQwSkgvac\njOZ2FNlW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4638", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4638` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARVu5oVblWhZEOsiChj9r6UkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZWNhZjU5LTQyMGItNGI3Ni1iZWEzLTgyMDc3NjRlYzJiZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ2Y2UyZjgtMzY5\nOC00YjUyLTkzMzAtZGFmZmZmZWQ0OGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECGCMgxR0S+pHaK+uG5CUJ+0hodEAr6MKqr3m+uS3ND8YFGIXr7630howZyZG\nLaxL4WBbrGhgCzqif71jlB4mAKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXAmfby9SBA/8gLjzVVCCHZ4dx+cwHwYDVR0j\nBBgwFoAUA+ZmPOIS7E6O/br9u4H0oTVvuXkwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCeoTj37tpGek0zDJAGR2t82Dpzq5NTOHaXbr2MHl3lwAIhALJ04mZ4HRHB\nBthbSaQekGKkUO+UQcyyRSzqS5ppgMl/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAepHPIoBCuORPGCT4YbcNiK7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGVjYWY1OS00MjBiLTRiNzYtYmVhMy04MjA3NzY0ZWMyYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1BkPt29O+hevrewsk02JPLQwatj/z8SjmnoVfGErQGMEy\nkH7BLRvpQ7FJcrzLjAoAoi5md18BaRyd3zKKIQDqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA+ZmPOIS7E6O/br9u4H0oTVv\nuXkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCJzKJm7crp+MYpH5kGs7vPqsvzfGdCL0DYN2D7mZ6jACIQDVWb/O918E\nQXhnfHC3XZZbx3QMlIsajTkVmGi25xNRvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAXuKsGMD+Kq6Q5ieE6yi78t5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ2Y2UyZjgtMzY5OC00YjUyLTkzMzAtZGFmZmZmZWQ0OGI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTUxYmI0Y2QtNGFiZi00NTkxLTg0NDQtNzQyY2Q4Njcz\nYzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK3+/YjUsEW6A4Q8+tCv4vhCU\nQw4+qvDC+SheD4K0sZRX4zgv06ODLt2LcfExvZeiKkSeEq3pnBKNk4ijGGjVsKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXAmfby9SBA/8gLjzVVCCHZ4dx+cwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJ3MBXbTy4OLVCCy\nZVc07UrIB+RLejZWAS7U7LtMQmGkAiEA1uszzS8TcubuQ5JOERchtuDFDUuIL9fi\ntgrQYKSdsB4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4639", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4639` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAV3IDvMM95g7J6ApjHM0wp5YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMjFjMjg4LWNjMjUtNGM3Yi04YmQ2LTU3ZTFhOThkYzFjYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODY4NDAwNGItNjUx\nZC00Yzk3LTg5NWUtMTNlMDM5YWNhNzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyg44LHrgWo12ARHfcvm8jzUD5q1PeCDKx41VjZS/YScPkJm44zVfWl9oJ3LT\nFMiQU4a9tjYoIdt38Fz3DtaHPaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwlrj1ygEjS+nsKMp/D7qLem8SCEwHwYDVR0j\nBBgwFoAUyZ1SO6ozo6Y77mf5AcKAh7o4430wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDk\nVYpRmZNxnSdu+moG2wAQzHFLuArG6oubxB+OziRbfQIgPetzByz21Af8V9KRfrtj\nuJkNHSSYJPkf/DRSsc6nYgs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdIZET6ZaseYAqm4Bw5TqrFRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzIxYzI4OC1jYzI1LTRjN2ItOGJkNi01N2UxYTk4ZGMxY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShyG7xiVfCrq1wnTuUCf5eyvzW78FqwA9ETFASDswpQbkN\nPpiQlqcLrl0SvxhAil+zVT2gBGkT7Curh1GxATrpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyZ1SO6ozo6Y77mf5AcKAh7o4\n430wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgactSWLFZe1h/1SVUmCeazhrvnLWhpkvSKKKkFm9oRtICIQC+FT04vska\n9saNfbgwtN65kWcSqMc8XSo4xKDfXRu9/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAefoxAhQy/znWo+GDBO+RnkjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODY4NDAwNGItNjUxZC00Yzk3LTg5NWUtMTNlMDM5YWNhNzQzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjFlMjA3NzEtYjdkMi00MWUwLTg2MWItZWRhMmFjY2Rj\nNDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIc2EtHCT4vwbztvkilZ3LUFk\nSjHXl/tc3ME77dessADxXGto5N2P6l/chJkzgo2vLKqtDoK4NlnH6f3FkepUOqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwlrj1ygEjS+nsKMp/D7qLem8SCEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANF9olyjp0dRpUgJ\nC4pUtcYHdezF2MP/12gBxwLNJ64oAiEAjf9sHsB9m3EpykApfHzXKJ0cKIlDgr11\nqI+tJrRSpco=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4640", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4640` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYoAQ6js3azvVxz91vJcugqPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4OWQ4YTlkLTU0NzItNGVkYi1hYmNiLTk2N2M1NjUzOWVkMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY3MjlkYzEtODlm\nZC00OGEyLWE3N2UtYTI0MDkyMDYwYjhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEls56rr4D+7pFHD5aZ/fmEGdRuZ9nZR9C4JEVF6EvY9ZeFW6j1buOjlG1c1Ea\n2cwUSPKOYq4fixUQhKv72NP5oKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxJ4GCXAOa4xvO07WonFxeg5LU/owHwYDVR0j\nBBgwFoAUzCHKX/oY829YQit48DUpDx87PoIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDNJDUVx/E5iE161iyE9cRrK0+sUS0nHcdnvWW6X9HXswIgI4IH\nklVNk27HRvI7wT54SpE/jN0+slyYLc6vL76dTIk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbWu4rSEi1kw7iBHvUo5NW3EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODlkOGE5ZC01NDcyLTRlZGItYWJjYi05NjdjNTY1MzllZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV7WJ8Dda+/bvNxETKnLmKtMTxLTzBrQEPE71hbiiOSAhF\n/R9WWGOvinbn2+Gh4r2HcpVGf8Qvw0UzJPtMQl/Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzCHKX/oY829YQit48DUpDx87\nPoIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRQN9cVVZjDGJTr7ZjJZCy0tlSPYKwBf+C/MThsxVqIECIQCfmQSdqldj\nwo0cyqxIvz9vASs0tej/fa791SJu1Rjj9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAVkVmUK3ZcnLhCVJmsRXlNy4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY3MjlkYzEtODlmZC00OGEyLWE3N2UtYTI0MDkyMDYwYjhkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDkxZGZlOTQtYjhjMS00N2QwLTk4OGItMGZhZDExYjYz\nMDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIzvxNkzO/CPf4YgcE/8LXCTM\nZwa98nc5JHUi2GB5JRmhdfBvRMCRKrwUrV0SZQe+k/PhxnNV9RAE+gC3mShAsKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxJ4GCXAOa4xvO07WonFxeg5LU/owGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMHJtW3+i+WX5qEM\noA5Zxz3VdL/ElsP3ZIIidrLiaS/BAiBwWIY4j2OZnM72d0HYhKrzBA3uG/0IS6tK\nG/qbuZ//Uw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4641", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4641` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAaqcDL6MKJrbowScc5rnk46YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMGU0MjVlLTA3MTYtNGJiYy1iYmM5LTlhZGU3NDhjZTJlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTkzYzliZmEtMmFi\nYS00ZDFlLTkzZDMtNTJlOGVmYWQ0NDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6CLSTjtYXNDHghe83Kzkd2DyvY6Et3YRuWxvMpctdZOjYpyXnwwiiXvfRuYF\nGkUugrPvMRYOHLSjdgqZDBIAf6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIrO01b5YkAbCLScacCG1TgCOILkwHwYDVR0j\nBBgwFoAUCv1g3lCQZK43lyvWd5P4DIl2GJowOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIA16XD0sNdo3N2MVHQ7h6Hu9EYAtAw5YT8G6HYFEkyV9AiEA/nZi\nZI3W27upENNbtkKN9NTDZFm+uz1VqM0nUu+Kato=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATo8Tm4saxqa1UKHQ2LDMb28MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTBlNDI1ZS0wNzE2LTRiYmMtYmJjOS05YWRlNzQ4Y2UyZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5c0rUOtM8IU6Nw0LOGmDAXXL/fJBDCtj3YT7zL0qG+d9s\nv7CxMlOftGLaaWdaR1KRRkGPEz0FUzoaS/a1+i9Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCv1g3lCQZK43lyvWd5P4DIl2\nGJowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO1DJqmOtTYFKQBN21P/e1CdabRFGBZCw0qUlym3PGEWAiEA/tczsk7s\nmNfbkaj+5h/vU6yX9CxWekt19Djo142er2A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAaC+MMGIhWAnTbU5mtOfxm8PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTkzYzliZmEtMmFiYS00ZDFlLTkzZDMtNTJlOGVmYWQ0NDljMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTdiOGY2NmItZjI1MS00NGE1LWJjMjMtYzJkMTA0NDIz\nYjg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpJ0xhFEGQT8pjht3YWV32Yth\nYUzbJCZ8WHuHyPHVLKitkEAM6+eY4Os4Gv8qzYVF9gAU0wfvzmMvxOsMhGAmjqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIrO01b5YkAbCLScacCG1TgCOILkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANzV7W9oaiG/ncXm\nU3cJvAh/r9juxp3+ooQ8e/AGJe0iAiEAkBm6ux8VfJbTYR8rhECtDyKvLadeFCdm\nzi2QiO3BjHY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4642", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4642` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAS4YLRCPbivZnMUkU774l7dzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5MmEwYTVmLWZlZWQtNDkyYy1iNWRiLTYyYWM4OWRlOTRkMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNhYTYyN2EtYWE1\nMS00NTQ4LWI1NGMtOWIwZDk5Yzc3MzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWzqfOIM6iO1bU2s1BYp5D+cd7xXgfupiiec8Jmr/fuOGdeJJ1Me7axZBSsqE\n719njPKKgawQMqtYZLibO0b3HKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLoazLwgWA1KDwpCnyU3BEJyg/SrMB8GA1UdIwQY\nMBaAFAoKpG1VEQvEqbA9EPubd28v8gGwMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBboRELbm1o4NlxnZN3hv8aT1Ml0fT+IlRP\nAg4V+9QbigIgNtkDTPhOlshdhjy5LvIs/YEX1XyBtyyBRfTm6fEqzPM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAePNt/PuIK4oKub7JBI/6CU8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTJhMGE1Zi1mZWVkLTQ5MmMtYjVkYi02MmFjODlkZTk0ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQALcfpiN0MLlQKniFfzGDeijiVEkVwHApMDadqKc2T+og3\no/IiJM12VV85GJFGzwv/QDiyNWkWY2dllRVNyHVYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCgqkbVURC8SpsD0Q+5t3by/y\nAbAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO/QDaGLHyMACqgOgPPDkllxEShtCcB7EDTnewWPwxqKAiA8t+GD11gM\nu8YiaTZn8iiesjmRZd8xotmuudtrk4e9fg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQ0mceI0xSpZtRq/R+t/fvw3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNhYTYyN2EtYWE1MS00NTQ4LWI1NGMtOWIwZDk5Yzc3MzAxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmE0MWI5YWItYjEyZi00NzY5LTljZWMtNDBiNGYwNmI5\nNDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYYGawciWvF1R7Psvzezse7Av\npEWCr3DIeRMbXR9dYejPpuC8MYQyorA6qB+gnfCzUp86S7+F1RYqk9mXudN8raNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuhrMvCBYDUoPCkKfJTcEQnKD9KswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgeBNIWW1wBZWu7wTv\nLmcAxE1VfR9glZer5X5pZac9b+8CIQDot7xWIiEeD0Bc47/4m3AIYBCfiwTW2BcY\nQaPYjm21KA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4643", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4643` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAamjmqSUeGsxjALsMc0Fw38cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZDc0NTJhLTQwMDgtNGFmZC04MDNmLWYxZmU3OWYyYjMzZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDUwYzA3NjAtYTk4\nOC00YWJmLTkxZmMtZGU1MzY0M2VlYWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfTmx/t1pJXbt++vzH8o7q6tD1ir1ePt84Mkl2ug4F1C19JkEVyOa24tPe9Fu\neiNM+/U8PRDoVUm8HPWFB069WqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY/LGyTOVeSKIqE14RfSY1uIS9rcwHwYDVR0j\nBBgwFoAUnm9ACMMbUQRioUPhc6LfpjZpiM0wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgfkAjT8bMpuZP\nhj0kMdhDimUkmufHdW2gIYPOsrmW8p0CIQDJb9Qid2yrkTozCJpKDV7RbU/LjqTF\n7Qn2A6lkr5ROdA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfP0qTEiSIYc+BBniq9U2AcUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWQ3NDUyYS00MDA4LTRhZmQtODAzZi1mMWZlNzlmMmIzM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARevhuNGx0krl4R36aLeS5VNVxXuY3sauf03KRinEaOQ04D\ntuma5l6s4/Jk+3OvkL9reYKYToegslJoRsEAjA+Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnm9ACMMbUQRioUPhc6LfpjZp\niM0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIRXHBPLlZ51JpUoa6U3yk4hW16LhgndL9vjIOr+i3AyAiEAwq7y/UBu\nA4kM/Cym/B4O4LS2slWkY6PiHbtfuNuHVvg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAVcBh05rs3rr5NqS7k8uIT3UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDUwYzA3NjAtYTk4OC00YWJmLTkxZmMtZGU1MzY0M2VlYWEwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmU2NjhjOWMtMTgzNi00MTAwLWJkZmYtOTY4MDIyM2Jl\nZWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqpiflZ9e8q6AMtkWRJVSDEWU\nN+D31tISZeUYNeDepyaX3OvjgLYupmjPeEGCIoKyouKOGXtaG1a61KSbReEEoKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY/LGyTOVeSKIqE14RfSY1uIS9rcwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgXvnGZufm8dVCwp5X\nJ04SITV1gwVHqF9pBTL/WS4jY8kCIQC/Bx38dllDT421rxNqsUBWVu8plWL6x8KJ\nbZgI6mWBaQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4644", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4644` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAeLLRzhicZlFYDFcb3e2mkvUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNmQxZmZhLTY4NDktNGU5My1iMzlmLWU5OWQxMWU4OGY5MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY3YWE5ZjgtOTRh\nZi00Y2FjLWI5NGYtZTk4NzQzYjUzNTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsFufykRAGd29YmA9HlWep2eQ5X0efXsWunC7+Xvr4A9gvCI1Td4fZhnfYqS+\nZLCrJuIG/gFM+60tebVQxMnLCaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWL9nsQYRSUMebRAh6qtF4DshkKcwHwYDVR0j\nBBgwFoAUf8vPhrkKVPdDRd0e0uh+YhInxJMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIZ5UMafxnKh\nz9Q68YL1qEqncOTWW0buUGroteE0jiUIAiBNn14j2jRLh9CV5zJwdn8jor3p4w0L\nMnsZON4UBizAKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY1fmv2xSP5KvkyZOnUJAABUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDZkMWZmYS02ODQ5LTRlOTMtYjM5Zi1lOTlkMTFlODhmOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdEShyEsbNpYuTvab0rMjX+aw3AbS0aSf+JKCsgeAUtTWA\nbVK/87ixDP2Znnl9PgBdn5SV3WZ6sSH85W5ZDL76o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf8vPhrkKVPdDRd0e0uh+YhIn\nxJMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKIJBN9ykJBMtbdpfej0c8IO2sIOONdNlMFVGlFGsWhdAiBk2/tOAXpy\ngfS7/XiiqGz9FsuN/amRoBWVorRP8tdLlQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAQycR8oBjtjiYGkdUTSbXvRdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY3YWE5ZjgtOTRhZi00Y2FjLWI5NGYtZTk4NzQzYjUzNTM4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTliNzE4M2MtYWE3MS00ZjZmLTk3MTEtNWFjNGQ3ZDY3\nY2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl7K5zap/pOFznzFA4gxre4tW\n7V46sIK0oL/9tLhHHhYfWnIinKOSWvffE8Zk5DWJ2ywY0hu+vOIEeLf2zzkYBKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWL9nsQYRSUMebRAh6qtF4DshkKcwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANVxaSla+Xr4yahQ\nAhOLl3+Cydh4Oru15PVTO2p5Rb+PAiEA/b7BtcTCniSbqslXr4KQQzYPnA9Jgtwl\nd7rial7wb30=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4645", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4645` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASa9dTB2XP0XBbxqC3DJSTcDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3Zjk4YzQ5LTBkMjEtNGIxMC04YjViLTNjZGNjZTZjZTcxYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNiM2Q2YjEtNTdi\nYy00NWZmLThiYWMtYTJkMmQ2MmU0NWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ/rvyaTXT1gDCEJhUVafQ7h5BxMo3IgZfZsjjb5FQm6n+XmDAb/Of/+PogFG\nKREsSKD8xwENQzOh7Ee2C+j1y6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmKSSkdR0sCSmqvB08hsJgLl3Y60wHwYDVR0j\nBBgwFoAUT+xUXDdWZxj6O5y/G5ywgK5dSxUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIClZSv/haC00\nSaq1qnUiQ7IzXhEEnojHrCq07ia8e7+rAiEAzY/fpsubj8+N7jnpV2Q3lsDADzuf\nTWmQ9ulPsOILB8o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY9cdgjcZYOVl1j6rZdmQeAmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2Y5OGM0OS0wZDIxLTRiMTAtOGI1Yi0zY2RjY2U2Y2U3MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCsZB6hAWrM1NRb6JwfnLRm0xyZB+TN01QHTuKDkLia0/6\n4tcqvJxDjoTrcDwRxYSDMjPnY5E5aSA+5eFCHKRSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT+xUXDdWZxj6O5y/G5ywgK5d\nSxUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcZVry+u9h0pObFW2JaOlOlAlHtOd1KFnIKX4AVI7L98CIAVB2rpwNpsM\n9/BR8DVLlzQsHj0ZnCw0+gnlpLg9ZjHp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISASpFk08olwC7aYGy1lYXf5DBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNiM2Q2YjEtNTdiYy00NWZmLThiYWMtYTJkMmQ2MmU0NWRkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWU3MzY0NzgtYjA0Ni00YzA0LWI1MDctMzM5N2Q0NzQ3\nMDJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENwlG4zeOWOQZfWduA+JZNTz8\nsLVSxJTBlKWyUhvG7s5MCRFoufYCSSY2gThSYXR1E0Lc8QxwuBNV5usLZvPNAqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmKSSkdR0sCSmqvB08hsJgLl3Y60wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPEVwbBl6nYpSHIv\n9EDSCDk0A/3blKDnQKLZ3t6vuF77AiEAyPxzUdqNOUGnqm2aVnqgsnal15TF9VUM\nAfOIq29+Fbw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4646", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4646` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXrZYuRDCRoLoPjqL3F2jcNQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmY2I3MTk3LTJjZjUtNDRjZC05M2Y4LWZhYjJjOGYyYzQ1MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI0NWNlZmYtNTQz\nNy00MDRlLTk4YTktN2MwN2E2YzZiYmJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuBV67DRjcCzur9/iaXwy1Hkex6zrO3fvwYdPE2LJFqdaHNcxSfXdRICaNr65\nbiM1fbAiB/4l9MP0V5h9MHFnSaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEPvF1dzgYK1yKjzuMOrFPfh9BS8wHwYDVR0j\nBBgwFoAUz8LC6gXBSNmCgcjfZrYF2YOEJGMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCZN6lef/dYm8AEtwkkr+FXAvbwtKAvb84F0yxDffQC7AIgG403XJ96cOqk\nOcUyN77GQ5enG60nYabHgEUZ1RNZQCA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYMeDzvXxQh1O//ygF6KRkadMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmNiNzE5Ny0yY2Y1LTQ0Y2QtOTNmOC1mYWIyYzhmMmM0NTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMYgiZI/7FXFNCjQeyQfFyiqOVuw4MQGZzBKCSHATCBCtz\nlQKNZ2XFfGPlfgSG//C3vZWz2tlmX0ByFitRY87Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz8LC6gXBSNmCgcjfZrYF2YOE\nJGMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP/alWEoODTlcCd+vOANwzdiB30NUOA/Fp3mnz25t+F4CIQC0hNVT4zRX\nEuJSVqnabAVK7L50QAeyOcFk15ZNnv4RYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQjKUwqoM0l4ST6uIJoU6I7sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI0NWNlZmYtNTQzNy00MDRlLTk4YTktN2MwN2E2YzZiYmJhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODgwNDdhNGQtYmViMy00N2YwLTg5MTItMDU1MTM4ZDA1\nZGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8Py7WrF54coeTqwzTmX0D6KY\nyYPXTaLMNqHKVEOQEq/V4zhXXHl4V33C6i0IVljNlyiCFjswtstaxR5usL9WaqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEPvF1dzgYK1yKjzuMOrFPfh9BS8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPWtpcQyL9uUKmvo\n/qRDI8IPC0NholJhKP6JxuDYVaAbAiAfS8sU/YxftRfHZYItga10g9uN++6XNYW4\nsOoRUsl9bA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4647", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4647` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATzQ4oyol7SrnQGH5JTl0KWqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4ZDVhYjk4LTFkMGYtNGFkMC04YTcyLTJkMmQzMzZjYzRhMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVlNTU2MTUtYTEw\nNi00MGJkLTg1NDktOWU3Mzk0NDUxZDEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw9fFnfPF3ar1AHZ0q69qXb8o9qGPfzjN2JOMuJe/mLK6mDG/qV1978O4EKBU\nUkU7vnkijQyBQMuoKL+yKOMVyqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUavmyHtz2CpMHAgiaA1bBh5jUPpQwHwYDVR0j\nBBgwFoAUSdBy7Y0XOKmUuPRPCckuNOJZZi8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHdwXUpGfneetODUAM2FAHsY4R666PjKf1bZ8zAXYe2uAiApSi8B/mRSAi3/\nB4r4LdxzkdER+0S6cvmOGHooQKqEyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcYTEOHfSD2s5ehaCl46Wnj+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGQ1YWI5OC0xZDBmLTRhZDAtOGE3Mi0yZDJkMzM2Y2M0YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkhPKi64Y7h4wFN5tbbHJXL5ySeDf827BRcOxe710CmbDr\nOw98bsESb6PaTZuT8ArDUMt8zYfifNn0jRsvoRifo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSdBy7Y0XOKmUuPRPCckuNOJZ\nZi8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALwpWWVgptZAmuuUXbDyEOeEMm6LnKlRD6CGN2wNZFtmAiAF+4vbnrR3\n5yo6BAxboka4QNEhAK/D5dV0WPdcGBC8cw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAVCufgTa5yrorCFOgDPCK+G3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVlNTU2MTUtYTEwNi00MGJkLTg1NDktOWU3Mzk0NDUxZDEyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzg0NjRlY2MtYTkzMS00MWQ5LTgwYWUtYzM2YzNkN2Y4\nYmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGV+LkudOt7LCbOAHtH0KzrDQ\nQ7OUqydslcc/Qxzv/KoOGm0ei+sHqCCWbw6qIt9WcIExpNSWVDFDlkVhJ+uxXqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUavmyHtz2CpMHAgiaA1bBh5jUPpQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKvIi9VOQZ3THBoL\nAi09D4h1RyQppTxZu5lsqSf1oKDJAiEAtx2ETwXQ/1YWaAZjW9dhCfOaV7NXYPbh\n2ZQHO3E4xEU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4648", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4648` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISARHwJiPwHMP/0OI1bX7VkfeDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExZTk3MDY0LWVhM2QtNDFhMC1hM2RjLTA2MjQwNGYyZDVmYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM1YmJiMWMtNzQ1\nYy00NzQ0LWI3ODAtOGNhYzJlNGM4NjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvf0qZvuWNkun0+tA5a7z2BGNvEG9p+2MkCban/WUX/W+X+a2K6n8s3HkksiW\n4k1YxDIt+2fRvmbZgN5ifppn0KOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7uodA9xl01kXIt7ICKBtFYkaZT4wHwYDVR0j\nBBgwFoAUIPBngHcQRs8bXNA9PdlKY/CnjckwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC/\nkPI2poip9CRfgkcwYuPUxqECjZGa+w+RxRvQ2alQZwIgDWCt5pwU2x+uCYNkyJJf\nibvgyXvAFaMQ8q2KBul6PlY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaH12PKSLdL4BhZUKou6G0+DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMWU5NzA2NC1lYTNkLTQxYTAtYTNkYy0wNjI0MDRmMmQ1ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARShJD0vqOqk3Ijvlcphxs1eCBNmBurUd7kx3nVg7YXbRtz\nlAKwre+yGnEkRhqg3C9jNNVKmyC2WEngcuPh6IfUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIPBngHcQRs8bXNA9PdlKY/Cn\njckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOLvSRtRYdAxEEoJJaQtAgPHrYfp5utONW79yHNhdK9xAiAYBKOVgJ8y\ntXFJEPaECwYfP6fiXY9+TY7s3aJUryqifA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAVfr/wBzwUBTYnUyOKKWDcfZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM1YmJiMWMtNzQ1Yy00NzQ0LWI3ODAtOGNhYzJlNGM4NjVlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTU2NjA0OGItMzJhNi00NWQwLTgwMGItMWNlZWI1NjBl\nNzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2kSrjHo9+hPgnlqubt80/gVq\nyaOb54ruM/Y4aQ78c5+A9xCA9DpcV8ZX5af1pMoFJ1ZKexRDDlV0S1DvKUXib6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7uodA9xl01kXIt7ICKBtFYkaZT4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPGASNYwjf1Ii55j\nxjSzEFQs2+qx7WeRGWt8CPdZkWhqAiEAnhTOdmKhEPh1k/tYmjF5iJws/2/FjYEU\n6i5R2oieJ0A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4649", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4649` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAdd3d92dDANeuNAAPlS2y1pOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmY2Q4YTU3LTcwNjUtNDU5Zi1iMDE1LTYxZWM1ZGRmZGNiMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg4ODM2NjMtMWZk\nZC00OTkzLWEzNzEtYzhlNTdhMzU0NmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDW1MWQoW2RuG1IuGqQAb+RgXTBqFJkhWBs9tHY/SlzEwwsanAwxZsm4HpHM7\npCW46ytMYbd2ZBATWwKyjvJVN6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO/tjp+0o6kJ6DNJtUImy6K8CTvgwHwYDVR0j\nBBgwFoAUwnWrsoKK4K8VpztxzpdtR+DDPsowOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDGG6tF5RrTBieunniLRMrowuBEvvZxBeMWRnVmh0e7qAIhAN32\n49pbySiBtOGgKdolDTKSvBgbu+uKfjlZVdEQdnG4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbhoGhL2Kd9jua8VrPQY7+dsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZmNkOGE1Ny03MDY1LTQ1OWYtYjAxNS02MWVjNWRkZmRjYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+toeouoKOsru0JtPKvv0QotxLmiqfIiA+MhB5MkUJ62zv\nB48m/fm7I3JFqsTmGh1fh82/+iJNQ9CfE4i2jT9Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwnWrsoKK4K8VpztxzpdtR+DD\nPsowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOekW+vUcBhQjvdjebo7zF/R5F4B2iAaEQ0BMC3273vQAiEAm5wTTtuG\nu381r5jhQvPX1qjoXdWXgMPqXXqZRM6sr3I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQfNmgMhNlX8K3Ostm7MeaedMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg4ODM2NjMtMWZkZC00OTkzLWEzNzEtYzhlNTdhMzU0NmVjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmU1MjM0MDEtZDFiYS00N2Y2LTkxYzYtY2Q3ZjY2ODM2\nMjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP938uLjCjvoIba+9DNdvusqY\n4OaW1KodnfrxC39NDcE6Q3+gkwzahRj2VksiA3aIbz51oDIaxTtwhG7esb1GSaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO/tjp+0o6kJ6DNJtUImy6K8CTvgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAK+FMUEi/+ECZj8h\nvx4UznkVNajNPVl8XAvCud5V58VzAiAqoV6kOg85ITYe6pBzKL2Qzuspu4+buYQn\nWJTPyJgbSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4650", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4650` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcq/Pr6G0jKr2p2o9/AVHnc0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyNzA3ZWE4LTFmOWUtNDk2Ni1iNTVjLTFiMDAzYzQwMTVjNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NmZTAyZWEtYmUy\nZS00Nzc4LTgzMmUtZDgwMjEyMWJkNmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUPnFobaJnS19P5liaB0GjguPcsu0zaUL/bkHyoGrYhhEtuFgFx00YTOyj5fr\nmCqzv8GghErxDYZp/qpkNOOXW6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULSc3+G54DnlbQr1ZsiwnADJcB5AwHwYDVR0j\nBBgwFoAUtUcfD4SsAFm8aPmLDgrUKxbbEQ0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDu4x7Q8hMFuHQHj4it87lIi3NFhyU0iu4DVkDPcCLjuQIgCOYN\nfIz72br1DufLk8FhGxDkgZpc2NjHduIDbX+ry2w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVwkRLkX4ESmcOvuaxy9op0PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjcwN2VhOC0xZjllLTQ5NjYtYjU1Yy0xYjAwM2M0MDE1YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFBZCdvn4lElKvKJcOLutC/vcRPKRxWmsqF44RmP3OiTG4\nJnqNixhJhcqovT43CBnSZC+U/5jVUmYgXxEidSmBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtUcfD4SsAFm8aPmLDgrUKxbb\nEQ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQVTcof4XTWhLBuCVlQ/fqd2/sl08/MGUDt5R2o/yw74CIQDvJaMxsjVd\nzb7b48VvHFGDDGSKJMJHYc1M8AzOT9vi/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbV+IB0v2le7y1nfN5yPP54cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NmZTAyZWEtYmUyZS00Nzc4LTgzMmUtZDgwMjEyMWJkNmFjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQ4NjY4MDQtNmI5Yy00OGZkLTg5NmItNjJmOWMzNzkx\nNzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL/JbM0nx/lKTqW46PWSCSm9S\nY2eUm/84H/YyeLyQTj2ruX3ofRzYkExS+6PQb3yRYg8B32JUu7xhkWDWzZqkNaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULSc3+G54DnlbQr1ZsiwnADJcB5AwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgTmbev3ukMI2PqqQs\n0TBg5/oSPETRp0ybcdvPXSdqn4wCIQD5L3cjMHmL8zOXmaQtfkiQb26Ipfm0uks2\nCqNOtEK4+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4651", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4651` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYOMWSseb5dIP0u+ds0aHLodMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzODczMzkyLTBlMTYtNDJjNC1hOTA5LWQ2NmE5NGM4ZWFmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUyYTIxOTEtYTEw\nMi00YjAzLTk5OTQtZjQ5MjU2Y2IwOGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwosGmEeW5OPphIg1zliZjBBHchkbZtfJF30XGuoUcCcxm995lda1/cD4E97G\nt8nBupR6uguVqwE001PnUzj7EqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTAAdpwIXlCg4toAijubS313GzM9zAfBgNVHSME\nGDAWgBSzSQaBGUqjMWMqXM8cUIwDMbhUUzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIA/SVNex9uZxKDOSDyJqcht6XIVCjnoI\n7UVFLVgWs474AiALucCmF93Vyd9+fqdY/dz3fpIZNVmykB9yalG/3zrG/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcRW3G+M3DO6WpqO10aP9JWCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzg3MzM5Mi0wZTE2LTQyYzQtYTkwOS1kNjZhOTRjOGVhZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARf53RTr/L4wS5TSIn902dS0aGeVGDWP46vni8FVhn1QR8l\nqSK/o9GPVkjUdB3KOTlTRAwwiVYtrNQHsda132lCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs0kGgRlKozFjKlzPHFCMAzG4\nVFMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMgHjQeZGDOtA6DCvCG1O3b10T3FbVwrIXv/oq8N8oJpAiEA8bBvL2oj\nwAwd7fbwnH3YYHsD8z0lFum9GsVIxt/Uv3Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAf9bb1KbZGW8QCkrcIifQ7iPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUyYTIxOTEtYTEwMi00YjAzLTk5OTQtZjQ5MjU2Y2IwOGJmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODBlYjQzYmMtMDc5Ni00MzExLTllMzYtZTUyZWM2MWNh\nYWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMOXpov3ybNszdNAbebdLWUCP\nXDSjTg8sYO35JLAnNSY2kyL4Ur8zYePQ01j/UVfUVWK9EXmmKzsQ+YzRk+8a0aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwAHacCF5QoOLaAIo7m0t9dxszPcwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPhTMBZbB56/QeUh\nurxhDehUrbITmU16wr7dxPoC1EgWAiEA44Ag3JjS/ChTB5vgCWrRL/nJfzlqSIZV\nMqKP196x0Io=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4652", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4652` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAWpyD1M6t7PJURgqTzWLPFFDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0Nzg4MzdkLWFjYTctNGI2Ni05YzM0LTI2NGVlMTY0YWIxMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk3NDk2YmUtNTcz\nNC00Y2NmLWI3ZTItZmE5NjlkOGIwOWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG22NrLx4FIHq4kgb2qkFcGi1mYDWCBWVEru7CdFDhy4KfU7kpafEh9u/E4uR\n2mFZmQKamU+bfBwnQR62sO68PqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPtFDV1a7xJpLS2/Xio7AfAfMABMwHwYDVR0j\nBBgwFoAUBgXOOgoKyrFDk5IquVc689RoBYAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD8ssFrazu8\n3SgAnwrrSevTKUDHc/UZD3/hJBuzFGeHDQIhAMy7g/tiyWgUFZCO3+GOZEdQcpXn\nonOEn9zh8GNXyEFU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaECzT1Ky3wZUKGPRyg6x3Y9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDc4ODM3ZC1hY2E3LTRiNjYtOWMzNC0yNjRlZTE2NGFiMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATM7060C35ciDQlmNTuU5dD1mJDulA5YOMiBa6tIEOSHuh4\nvEU8JnhuEjCcE6ulX9YZ8OuBGlIF4RYWJtjSFjxBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBgXOOgoKyrFDk5IquVc689Ro\nBYAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMD4JBbYPDlaEeXu+lI4LrrMOx1tsF7JEhXNJuNC5fthAiAdnbXsBZke\nC2wovKQVp+Fxq43jGcq6gT8zWQRLW/lBqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAeJ2lrisb7lqrKSISOWDxX/vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk3NDk2YmUtNTczNC00Y2NmLWI3ZTItZmE5NjlkOGIwOWVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzg1NDJlZjktMDA5MS00YzY4LTkxMGYtYTk3ODFlMzE5\nNjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEU9ldCSlbJwYpHqVw9gJowfi+\n3aJwhU+2essK5jJUFkZGbQsLAx0MkVCQtAx4qDMJA/HIt2jf2A3B8GKJr/4blaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPtFDV1a7xJpLS2/Xio7AfAfMABMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgRaFNuLzNdHxrafH0\nQcOvWEKlh8CL1E7lueYxpwzsIeECIEkP0gqqpMn4cXXAud22bKb8apT5o5EER7mZ\ncoYZ2G+k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4653", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4653` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASaf0MdwuQyJ/Ji6T5HqBe2rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4YWFkYWNlLTEzOTUtNDIzYS1hMWU1LWNjOTgyY2EzMzU2MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI5YWJjZmUtNzQ4\nNy00ZjcxLWFlNzctYTdmNDQ4NDYxYTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaK26tTcBwhyOFdz89fjjMgRS01/2lm0ZuzyFv6bBF3k1n1M0STH53T/2/ej0\nNemD4a9WzhuT2yFJFVdTxyDmN6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuSn6MX/+kZ8ahBQJAPt8CzxIVEMwHwYDVR0j\nBBgwFoAUB3l6BTeitrPIAiLESVE/nN2Iq7EwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGfgjbGnLonq\n+qW+NrY6Rm4xzcFoVa1cKo6tjjYl3ABdAiEA3n9KD2k6X1pQCXTJHIlGU6COfEFK\n4uNC5ah/y5pIit0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVC0GFmN29PDolNhDVLCXyUSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGFhZGFjZS0xMzk1LTQyM2EtYTFlNS1jYzk4MmNhMzM1NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkhwqPl2BW/zAUaKjvj40RQ+CFIofjo1sWYd1iZQOhSmxR\nK0atWrcPH0+SRYpqjiJCo4fWf1LyCurikBmgmM3+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB3l6BTeitrPIAiLESVE/nN2I\nq7EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMW5ggimbeh/NjXCxs0u0csjAj5Thhs0b9w20FPyd5cEAiAXdvU0q2ib\nOICS5GQ5zOkTQHHVhRtYIJEgCtyV6wt/uQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAdHndv3fBR8kr199AqQhC1dNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI5YWJjZmUtNzQ4Ny00ZjcxLWFlNzctYTdmNDQ4NDYxYTM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGFhOWY0NzUtMDMzMS00ZGFmLWI5OWEtZjAxZDAwMmU4\nYjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAES3c/PjgtxHU5YK6cAsX8eKwN\nkrvMl+AnkJOBkQdejcS6p52R7jzbuqdDtJiSYinkula1oM86yTorcd1SOKt1laNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuSn6MX/+kZ8ahBQJAPt8CzxIVEMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPlRX6VR2ME1o3cE\nt89IhlSd1CwLVlEPpEtj72MUUKaiAiBjDLu49//X2/U0iICrllhZfs+Hg/2rOQMX\nlnic2OoGBw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4654", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4654` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAdbewHGNN3j5Q5i0bDiKnG9mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5ZDViOTFjLTJiYjAtNDY4Yy1hMTQ1LWU1YWE2ODZhODU2MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRiZmVmYjUtY2Ri\nMy00NWZlLWEzMmUtZDM2MDgzMmI4ZTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEw4uG2InQs/sa1UQhltBJjL3evvdZbN36L6/vUz2Y2Q9sj8Q+tb85C8YbrOO\nYLTisCXfS5MhwiLP8AVn//xW46OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcPSN7JkI3sRik1BQTPDExa2rb84wHwYDVR0j\nBBgwFoAUrff9Dz5gxZDau3T13lV0jBy10A8wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiABzaqYLDU8\nEdCiu9Q1t2S+GettvRl70O50XF84k1O/JgIhAKXW8ylgAkU1ksqXNSc3x7fcABi5\nsdtfcMq1usNmmO3j\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdxBW7SWUCrSnEnlrLlp91swMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWQ1YjkxYy0yYmIwLTQ2OGMtYTE0NS1lNWFhNjg2YTg1NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLtfTwTEnNF9OKOPgQluaNiOEccYbcDNU4LlaE7nlQpPz+\nbggHpU0v/39jU+vnm64334andh6wW5qrNPl3tSdto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrff9Dz5gxZDau3T13lV0jBy1\n0A8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRsWSn5wGUo0OU8QzWebINsSEfbIpfNOkiKodtA34uOcCIQCZKCw6OYml\neq/y9GXFfBo2oOSJg+jk+/kEKaYY9boQ5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISARk4FdBGq5GFpKZTTsbNjnnqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRiZmVmYjUtY2RiMy00NWZlLWEzMmUtZDM2MDgzMmI4ZTk4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODcxZmU0M2MtYzg0NC00OTZlLTlkNjUtMjI5ZTkwZjJm\nYjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAED1TLMk825SeApFP42P4+tjhF\nZZ8GIBRLvilLcggxZ29rK0JyVnTajlfWVYE9lg0AItFWbhtwJ34yrF25+9/GJqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcPSN7JkI3sRik1BQTPDExa2rb84wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgaLz+fLvrDpOmtr/0\nrTt9myb0X8FVnFdf7yL66Ggvkp8CIE0e8afjrOnsBc6VUxVrrX22NCMi/XCoOkyO\nF+eeD6CS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4655", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4655` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVFZO3VFkTIPI4wSvkWEDZOMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkN2E2NDkwLTM4MGEtNDMzMS1iNGNmLTRhN2Y5MDc0ZTFjODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDU3NzNiZTktZDBi\nZC00M2I5LTgwNzQtODA5OTJhYWE4OWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeil+Nl/78Qphop6OB2QA/GhczO5SkuxKEKdCv5UdIq2XC2DQfYWPVmq8h3Oy\nablwHZcBeY9ytSxMHL9AQA5KeqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoKA/6aTEfuvDkgNRtj3JeJbIE24wHwYDVR0j\nBBgwFoAUSQK18mZmLI6QGlUKMsRvgSZAiUIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAozk1SCt1xGHHFlDeNMz8g14Qhwy6dJGzlikoAWNhlTwCIAX0V1g0W+OE\nmSFDn6tPAgqPCoPHBL1qoQfoIc+JD/HG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbONltk8yxT9ZecJII2zWywIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDdhNjQ5MC0zODBhLTQzMzEtYjRjZi00YTdmOTA3NGUxYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQl/CrXx0muSKChkp0VoV7odNLDdHt0tgbw6PJlpGvOmdwY\ne4AJu3UlzvRRWhTbZpzUO2dstsRty3TFpoVtOE/ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSQK18mZmLI6QGlUKMsRvgSZA\niUIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOxefzkp98fbvJlKSbvxhmBKvtOSsgUvWpbUZ49jU7EcAiEA7nK3f5JJ\nF7T6a1Zy/yFF50Gn8S9+2Fw++K25T9z0Ro4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAf+X0Y23e9Af05QfmXuwkopEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDU3NzNiZTktZDBiZC00M2I5LTgwNzQtODA5OTJhYWE4OWY5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmFkYjdmZTUtZDFlZi00YzM0LThkM2EtMDNkNWZjNmRk\nYWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvdslJaEwJOfWBjcdThCxMhCb\nPPOBAH15ADASUJLlIVuch/286wW6A4P+fLjkF2s4w4EUepmqzq1iniUv9xcP26Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoKA/6aTEfuvDkgNRtj3JeJbIE24wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgbbhwZzuksAgm6wEr\nSvIKiCr55I1+g2NJNw6Kz+IC4nwCIEUo/p4tgfawY5XLYgUXc1YepLG2fFzoy2So\n4YZiPZ6/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4656", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4656` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAS+B0E5yvYNBupiGs4zBdKxvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkN2FjMTYyLTcwZTEtNDg3OS05ZTIxLWQ5Mzc3NWFkZTQyNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODAxYjY1NTYtMjBk\nYS00MTUwLTk0ODYtNjdkYTY4MGZhZjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqC41Wjn4zjmNxcSv5nUkdPTp/u9a4J+PK9p0DMjjeQdcolmgdeyrx59xqvDX\n56CTxgKyypKMcpU/CTJqj01bTKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKyaiS+tt7f9gCI7XA9ezZPoQWu0wHwYDVR0j\nBBgwFoAUdThGS0ykFKUIkWY+jL5k99rMPM0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAFOKFIB60SyftX1JBvjHnIWSTkMUTZXH4O/5us+Xfn6AIgGJn3zQyGjNtm\nfUfBmnuRxwtZ/9JV3j3MlG6dcY9aFBs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaoaM1UYdqlt0hlPNcwwxDtvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDdhYzE2Mi03MGUxLTQ4NzktOWUyMS1kOTM3NzVhZGU0MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOAjLRHoRJ2gDR0wFBce6LSeujAiwNjK9CJkEoYrELd9f8\nV+2lFIHgynUO1ZOrjAbojC2teY1kHx99Ds64tPCWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdThGS0ykFKUIkWY+jL5k99rM\nPM0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEGiPTF2k/r3QmYMw+tBpVi7D9gij4mt9BX1SPjf2mwQCIQDI4SJq+05X\n5uy1zoXHdF8eH5qBNNdriFNwqeI9o5fgLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAeSgoSjcEqEyFRBpRLazU8iyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODAxYjY1NTYtMjBkYS00MTUwLTk0ODYtNjdkYTY4MGZhZjg1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjM4Mzg2OWQtMjFmYi00NGI2LWIyZmYtM2Y1MDgzODY3\nZjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMDwlMr9EMPt1gOWaUrwQxatQ\nWC5WJ+SZTxhv/Y+oT5Wrl1+YQkLoiv4Oksl5rjWjDsNPhpe2yRH367Ny+7MtoKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKyaiS+tt7f9gCI7XA9ezZPoQWu0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJCQgAtMWUc+gxyu\noOrHXIecUjWHEMyDb1wUmazKAZo9AiAfefti6S2P8XwMODM8DtqN+EyOGGRKA28j\nw1sQB38F8A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4657", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4657` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAcah7HYLgEza5v/EvPkXD82VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1NmI0ZjA5LTFjMGUtNDZhZC1hMjQxLWI0NTgzOTBhNDIyZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY3NjljZGMtNDYx\nZS00YWIwLTkwOWMtNzQ5N2E2ZWU3MDZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt2nM6yzbN+37jMJGCPwbVwt8NAcqQHFNGHd6A7CgOCG1Tb7wlSnNgJ+B0OMn\n/x9JlXtkNSSBGFkq/xnGEIBoSqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmdOOpNTVMu9NByJnAUxGv+kJNzUwHwYDVR0j\nBBgwFoAUwor8xM78ndEiBw3u7O/HWFajSAwwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n6K913Ua9OQ9Lfidqa42+3kmZaUFeBli1ihLvsZEVeUUCIGCBtAu/GRVBIm3uo9xy\nWl5ze+4JeHyCJtrUNbgIqXZE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXS9pIUTbXmkd/xvjLqxzHwdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTZiNGYwOS0xYzBlLTQ2YWQtYTI0MS1iNDU4MzkwYTQyMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSrdGPsK0BTizs2wSimtIpT02xFvUWaL4F5K/7bI4A0kAE\nouHx+JP2Ivvl3amiOxMgA9SVLBNEjGkNuSwOnpflo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwor8xM78ndEiBw3u7O/HWFaj\nSAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMFNYm9vDIGGYMv44ZJHolOZn0uPMlqLzRr1+NpDo+BYCIC/Yghm8DAMB\n1conXJMgn3K4bd925Bd6whHZWKzPK9hj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAQ3NuwLFLsZfiXkk682IMd51MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY3NjljZGMtNDYxZS00YWIwLTkwOWMtNzQ5N2E2ZWU3MDZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjJmNjVlYmYtY2MzZS00NzVkLTg2YWUtZmQ4NzAzMWM2\nZDY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ7GacvY03XdT7XzBfsa9tvJ2\nQtwSS6dEBtvErqjHHpvagvUqCGHlWizpKJ8SMF+kc0tiCh9HxCAQyNlVJwRXIKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmdOOpNTVMu9NByJnAUxGv+kJNzUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAN14wuDMd1BCQuWX\nXdmlHcmhRwLJjeCg5dAYMBfPkEXwAiEArdQNAxiwCNDl7crPSmvZDcP74iLkbl45\nLpdFdQDBjOc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4658", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4658` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAYXLnCYuQ4rLfNhrdn+cEc+ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkZjU3YjVkLWQzYmItNDhhYy05NzM0LTY4ZDg0M2ViM2ZkODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzUzMmFmZTItZTUw\nYi00ZGM4LTk3MWEtYWVjOTBlMmY0NTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZZYi8WpTGpczoLGwJsNfv1jNEtaBRnc2gGlab6JMLgfEe5L93oGNQKIS3Aq3\nQK0rrBo6ylKXngoLGXr5dKZ9u6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3YE4ZdCAjQN2e+SD0ezReDb8qzgwHwYDVR0j\nBBgwFoAUMPBkq5UJHPxmuBWToZ909ugYEv4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiBiwfHnpJOp2oHN7G/jVsKCiF6obGivi4uwy3yEe9NvkQIgPcId\neWfVjqb8u5rtBgcLZfd+qnnlTjSMKyU6aZfUulo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQgdl5AIBh2f4gYwwV2dWHKwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGY1N2I1ZC1kM2JiLTQ4YWMtOTczNC02OGQ4NDNlYjNmZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHHmvVM9n2XODw6Y++JXmNtZIMpiIUizAO7QPiIzEkoMic\nMm/jzA+Tbm311vOrSoFnCI7nsqMLkf1uzT+bqUxso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMPBkq5UJHPxmuBWToZ909ugY\nEv4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgb8bMAEx3If5gRjdBtKyxfzzVRnKVoh6qDXH77zKSrSUCICVQ2zTiAoQf\nSt9flLngIdXYnnC7f1MLtM7Us73NaP99\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAek96lY/wqEsLTg6NrfGDpMNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzUzMmFmZTItZTUwYi00ZGM4LTk3MWEtYWVjOTBlMmY0NTUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzNmMGRmMjUtOWE0Ni00NmQxLWE3NWEtYmNmYzJjYmMx\nMzg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgS951fKk2yXuye/FDXnkjypX\nE7r5VIYnyzOqIFc0CLSdZPaE5p7sPwwh1njB8EOHcpxYq97fcsXvvwIx8vRo5qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3YE4ZdCAjQN2e+SD0ezReDb8qzgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgBtT96vJD6sPI63ee\n/cL3APwWmnqemVFtHVmW5VZuCh8CIHv7Gg872nDr6/dVbChxLuzTlW91zVFIJ2zF\nKRf2m0nS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4659", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4659` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAX7gzqyTpVq92pEp9lszrCrCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiMmVhMjFiLWRiYjktNGQ5ZS1hODk4LWU0ZTNkMGI0NTY5NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ4ZTY0MDAtZGRi\nNy00NmFiLWExYzEtYzVlZmRjYmY3M2JhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXDRZSWq9zO6QuLpST10YrmbqdapVyyjSKGxdyHjMINs4RwD/rDFsxY3mjSzP\nGl1KfyRAgcn5NnkO3w+nJzQw9KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGmRaLF7tgGWMYBSDitg4wLpbVI4wHwYDVR0j\nBBgwFoAU978qweTyP5a5toCChl4zt44ULx8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA/QZtjqe3zCOW7n5PNjlT3oLWJhK7R1eCt8DpwyqesWICIGwg\nGHXeE2r/wfobBdPWpx9vZIv3Jq8stRMi7Wg+5Ujx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYxsRZZudMCvSBgONe2p9hvvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjJlYTIxYi1kYmI5LTRkOWUtYTg5OC1lNGUzZDBiNDU2OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZ8dx7H+1V0WGe7shy9ljP+ANCC6izVmJ9IUgSsKuauYLj\n4jiunFdmlzwk9FhcL0XD377TPzoZKbATtwMnUHd8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU978qweTyP5a5toCChl4zt44U\nLx8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJuP0zkRxXqeGDHoCQ3EbMvRTECS3hsFGCLlfxS6ZMerAiEAkfIYpxjK\n8k6gZ6lwz0Tes/+MEs2pIs4/r/fhLR/+I0s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAfQZq9yjEb16fXBbYawg+xpYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ4ZTY0MDAtZGRiNy00NmFiLWExYzEtYzVlZmRjYmY3M2JhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2RmMjkyYWQtNTMxNi00YTY3LTk0MzctNjBmYTI4ZGFi\nMjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIJT2VZ06EZv5CXujncmknyCb\nQ+6s9JUGrss01Cc20Lng2acT8lXbCukqGJTAnOVC1k27kJXmrfCHVCLdNPqmIqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGmRaLF7tgGWMYBSDitg4wLpbVI4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIf6VsRBtmR//M8u\nqLMmLywQyH7n4zqYVRNpWse4JOKIAiBw+Y2U5oPs02wpXH5leMWEBqbK69SYA0X7\nJKWith19Tw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4660", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4660` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAahUVbB01ZYDJOmA/qUob5LvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1N2EyYjdhLTVjN2UtNDE3NS05MzQwLTY3N2JkMGIwMTFmMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNmNDkzMjktNGY3\nZC00NjM1LWE2ZDQtY2ZhNTEwNjk3ZjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ07HYcVrlu9VUmgegLRrzHSJ8qmaBghy9fMpQmfLcxC+usilF8CEKzYZ1uWR\nK5GvtDln6P1c2m+s4SLg9eVHDKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMtjD6ja4UWNsQperno7Rtrn0NBswHwYDVR0j\nBBgwFoAUCGbFCHm3UbCOxwo6TeoS3GxovwowJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBLgndQ2LnZZLsG\ngxjoJ62zVl36EoIrj3nqfHyiFs1H6wIhAO8a/uyuo9CBtYSd1M/AGnU4wCzO+ohb\nhhl8mVUKAaPe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVX46FUt9BIDu8mJCLpFQmaDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTdhMmI3YS01YzdlLTQxNzUtOTM0MC02NzdiZDBiMDExZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASParsYVxHgE9HxvAHGKPKsOCsnWMMYzd14bjJetT6v8iwN\ng6tpo7H9JbDzIWIAoER4H6SNxlWzAg+rIistCavBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCGbFCHm3UbCOxwo6TeoS3Gxo\nvwowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIga9au2aycSbbjWcTgrMVg2A/+ahXkNs/NZo9Pm7pBFRwCIQCM8vWpmLpm\n/VxcWZ00sHmrIPufCZITveyy8CXrvmvo7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAQQvn1r7b0vi/SrAniXJmDhtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNmNDkzMjktNGY3ZC00NjM1LWE2ZDQtY2ZhNTEwNjk3ZjRiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODNlMmQ3MWMtZjY4OC00ZWRlLTk1NjgtMzE2ZmIyZDRl\nMDY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyt7gsgxDSYEgdI1tNJNJ51Z/\nojxKzRsy1ZHxgf/2hDtnD50bV15xPAu70jlgacz6HfFOcxXfNfWMUtdUYlWDrqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMtjD6ja4UWNsQperno7Rtrn0NBswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAI5b5Hl8fPwpTugA\n42pbBODCnV/lHhcPQkJKWdkes9SfAiEAkFyzVFznBKB4rt4oL7EWH4xqvX0ScXZZ\ny7/YhVZRhec=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4661", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4661` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWDJhkxXeUfelbADLeDZDX3FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5MjJlMTUzLTg5NWMtNDBkNS04MGU3LTE0ZmNhZjc5ZDZlNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjg5MjA2MmYtYzhk\nYi00NzllLTkyNjctYjJhM2UxODM2YjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzne+A5Ab8LxJYPex17Fx0gkLmd0JpLfVcUCsqMhcvYajKc3tDTtBspkuONgT\nktrObQAXdYsPB4mTKzOOh9usIKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw54/OiZDJCH7wafsLxoOqjKe+i8wHwYDVR0j\nBBgwFoAUunXVOA6xe821FFPY/jT/uss5KIwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBgXXkFwrDmD3Qnt7AibIdrBiYANVw6n+g3+6Z9cYFOKAiEA375IjyR6U4wB\nup/cZOC4HgrKojlacznY+f4FLNJ8gtU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfyiSCvEhbT6JeUp7asJMXmOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTIyZTE1My04OTVjLTQwZDUtODBlNy0xNGZjYWY3OWQ2ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROaOtiCmFLD4g5HhBOsksLkfpJSa2DV8gNyIqPKYPaEGXO\ndVm338bePChvT0AxLl7+itIHc6a30r22GNUrgNIPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUunXVOA6xe821FFPY/jT/uss5\nKIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJQqGc2iSlk+gEDMjIdNNpAhsLyh5bKknpVv4JMpVlYhAiEAyZLf8j5l\nNBycABW2dJFACtHkcES396R09ed4SYCvfhk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAe6dqIhLFpDL+uAsG+qCd94VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjg5MjA2MmYtYzhkYi00NzllLTkyNjctYjJhM2UxODM2YjUwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDg1YzgzNzQtOWM4ZS00MWVjLWI0N2ItYTYzOGMxMmNk\nYzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9Owke6GT8hl8LOkxJG0cmkXb\nvcwdjQqYIZnD85pL6ZaC+B6ZKSor+e2tzzEfOsO2EY3r1Yw0cEdW1EBkVQ2lh6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUw54/OiZDJCH7wafsLxoOqjKe+i8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgTeKRvBQCtY6RVhmV\nuB7cgP6j+fz3XSzY2T+rqLg9HuYCIDB4lsTZcL5SF08wt5Oodj505rtCHLnq8A6W\noICKz7FX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4662", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4662` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcJCfgXN7V1Mcmhj4ynSdgA9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzODhkYzIwLTE0ZjItNDNhYi04MmE0LTk2NzIwY2IzMzE4NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE1YmJjYWUtYjNj\nNi00MDdhLTk5MTQtNTcwZDc4NGY2MjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYWeg5FPZAty2XdZZ7jk7+YTFvL6Mx7ZN398/iwnbJIMK/4O/bcPOSZMVrHsI\n4NlUQLhhnXioD+RZfTuHXqdrbaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY8Sywhhs40bYtqr7WUuJOkadkd4wHwYDVR0j\nBBgwFoAU7enbBkF9yTQfQJXODjYAEEBNmJowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHqmUF4FgmAvQmiIeLUjTOQ66psm7OOVYqBEuBQSFZVPAiEAklSaRYjJTfRk\n1je5WhY4lOvO6038CaJfTTfJCKngcJM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAflb4jJursa3aGgKmnV1oxyjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzg4ZGMyMC0xNGYyLTQzYWItODJhNC05NjcyMGNiMzMxODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpYpuu+taqg4IQ3ug75je85OtjzrznkwvubZenuy0nDl0y\n89Ff4Oik+p3S1iJf2s9ObVeBD1o4KDOkey5mPmVRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7enbBkF9yTQfQJXODjYAEEBN\nmJowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMW6fiR32gTuuIcqXHByp4t0JQ5iGO6IJdFURU2/MINlAiEAjCZp0513\nxCTkjnIceQhE2PUovXc8XuL/w/Am2e0tdYU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAaVjwAB8a/bYyOTsRplCwzvhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE1YmJjYWUtYjNjNi00MDdhLTk5MTQtNTcwZDc4NGY2MjY2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZThkMTE2YzYtNDc5ZC00NTA5LTg5ZTEtNDNkYjhkYjQ3\nMDhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGt4CBbPD5b482THRui6l+0HK\nm7Mw04JiMbjurtR/+IncdYTbZEiWBbij2Q/MXfLecxr8Cw2+o+AClWMBHK4iG6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY8Sywhhs40bYtqr7WUuJOkadkd4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAONU4n0+85wdJQ3E\ncQF5aAJrNVvgIa/T8cOkpWzH9H/oAiBHiw35Z5UmGfUXifHnKEh7nPwKQCoeSMi5\n2GAzlkXdCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4663", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4663` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfsUvmWXWIHe0DPdRUiBPqCPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4YmZmNjk0LTQ1YjctNDE2YS04ZjU2LTYxMmFiZTA4YmNlMTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThiYzM3YzEtZmZk\nZC00Yzg0LWJhYjctNTg3YTk4N2VlZmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyl342lIn9zrBTXsJx6z3HNKgw0cXKGq6BEjbPI9vmVTXNoxrOUDn78LaibjU\no9Sm9+O6tKN6bGU90QjWy2NBVaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO5bt3ILXNxJtoOhtz/JeFKf9w6kwHwYDVR0j\nBBgwFoAUOfLC7C2/SLOwNRLkYqrGn+j4gaowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA6L6q2lfp93lvQdhMaInoRt9D6Oa1ZB2oijhcy8I8ceICIGQNbcX2pfo5\noaJ9Uz5ElfbXwJrHa0e1TrZtE8hzbwNV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATvKuMg/aWoVBzx2zZhsrqA7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOGJmZjY5NC00NWI3LTQxNmEtOGY1Ni02MTJhYmUwOGJjZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQTy5kiRmMfwKgBiE5sVsUzeq+rmmzzxqUti+zsG3uUxx+\nF6Yc6jcdJejts1ORIsQJyJWajo9ekNuqcdPtBfxgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOfLC7C2/SLOwNRLkYqrGn+j4\ngaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOKQhykFNXlvjeIsDQeWp9yGMvccRHWuNq8K9nLZANmwAiBw9H+mPzyO\nymjB3uJFlSlOvm2YJE61HSrhHnBOSSl6Ww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAUWA65kFPcvS/iEDT2xzh6KhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThiYzM3YzEtZmZkZC00Yzg0LWJhYjctNTg3YTk4N2VlZmQ0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjNjOGE3MDgtN2UwOC00YmU0LTkxOWUtMGJlYTY3OTUw\nM2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENp7/Znkuc7fyoFLcpqhFwFA6\n90QXT5T/4RrXrbViO9jjAgIi/8ixLtUQjps6Q2Ga/enYVYbkpWBJLoKafRCAQaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO5bt3ILXNxJtoOhtz/JeFKf9w6kwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgWNOcjVNoV3Ckinsc\nbHbl/ODiEdPM92rTHegQ7b374ogCIBs3RrweqYelwXCbLzIDB4xniLb5KIA88maF\nxrs6bSNg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4664", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4664` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAasCqHfqG3mUFO/rngEC2ePEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3NjRhOTkyLTA4OTEtNDZlNy04ODU1LTQ4NmZhMmNjMDk2NDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU4M2ExMjgtNjIy\nZi00OGZmLWI5YTYtZDhiZWYwODVlNzNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExfpU5IWVpD4bc5R6t53O1Cyot+xUxqpKl+ldiJbRq+tVh9R2d1KtGugGWAds\npXETpYAYvouulPj7kR5SoFNQnqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO5DU+IyXK3f0mxICHVerZMIe3NQwHwYDVR0j\nBBgwFoAUhoDbP+hjUzzoZFt4sW28n4mzwakwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAgy6U4RrcTyasZXfzx3mNFwc1DHeeu7HvMCzVoT5y\nkMMCIFQ0mmEWR81rSus/HPH9B5eS87OXDxBD/LhrNTCHcP1U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQwJT72nP1r8IyN36k0KUMz5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzY0YTk5Mi0wODkxLTQ2ZTctODg1NS00ODZmYTJjYzA5NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsjzRZX0ofL1NpvbQAPtmcZLJat5Br4yDVKwsBKjp9Ql7V\nVW2KhhBVt+YCRiC+/zIN/3CeRAJAkAGD10q6SuSGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhoDbP+hjUzzoZFt4sW28n4mz\nwakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPrMFTMKG4KAlZn+g9t9BA3EmLf4y/TOXY4V7oeHvqIcCIGEV/aXvwbrt\ncywflTazVKGCgNiABXSM00FktoqWQDbC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAdNpfsOrOllJH7n5+kjQUsZSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU4M2ExMjgtNjIyZi00OGZmLWI5YTYtZDhiZWYwODVlNzNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTcxMGNlMzItZDdlYS00ZmE2LTgwMWUtNzU0YmEwNjlk\nYjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL1YEQPHqIk+PhwHO2gipJm0j\nB9Vz7hQJAbi4OaCqH/VGTeqfbtujA3aCEOHk0ou4/Yt1+GoGuO/nyYmrU1enG6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO5DU+IyXK3f0mxICHVerZMIe3NQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALCUsbc/iFCoTZHm\nDyAfcw0ySZG9K5Qs+8Vyewoz1k44AiEA3SJlL2aPt/5ap6CGvST87PNQUlkZ0yKK\n0OYgOoKRJeU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4665", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4665` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAZIVXdfNkNDmoJWZaH6L3UoIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwMGEzNTk2LTAzOGMtNGM4ZS04ZTZjLTVkOTdmZjdmYTY1MTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRjYjJiM2EtMzgw\nMi00YWJhLWJhZDMtYjA5M2U1ZjRkOWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpTYp+roUWELzjQZ6fJQ2+Rt+Y76S5ikz+iu8v9hreFj+ARXEErZR7zn1ip5E\njkLWg0LQvP0EEBeE9kJ0/DkaUKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSPPpMyeZyWnRe/BoXthZezX6AtwwHwYDVR0j\nBBgwFoAU7+jl56BYbmbSijmwwVu/IjiqlMcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA8+d6UzGeVQgYP2FvYmIGrVDPWbFnReBKap81x7NY\nQx4CIQDvaiaTJwLnkxVtpCQGy4HF6qQ8Uxy8+pjJ/0XUxrQZYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdTNoIRBhPCuqNOEuzJEcDpUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDBhMzU5Ni0wMzhjLTRjOGUtOGU2Yy01ZDk3ZmY3ZmE2NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzzwEWNTFGL/8ZwRlR2CKYu9tiQWh1eQ2+yLYvC7McNGXo\nhiJMKNjyfVwPQYALEvk8IyL4+ClsBCvMlPIz740fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7+jl56BYbmbSijmwwVu/Ijiq\nlMcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMTLEW87/4Y6xJSQDifmN8EGdebUtk1NYvMsbw9oufobAiEAoFgYNGOP\ndDi+i5sSzIMSEz7YbjZciPw5rAhQ2RcL67M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAbjjlmBtNzP+lBys/Hi5CBWxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRjYjJiM2EtMzgwMi00YWJhLWJhZDMtYjA5M2U1ZjRkOWQxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQ4NjY5NjEtMmRlNi00NGU2LWE5MGItZjg4ODA1ODk0\nYWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7LbAV5cbzlqtEub0YfvGJa3Y\n+tiYcuJ5o3aamjdntb/FT+iR1QFaIwSwKw0ZHQzYKMVffh52DyDkvxjxTaVuzKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSPPpMyeZyWnRe/BoXthZezX6AtwwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOgkxYebCAaGwfyr\nMMWafFHZNqqrOY53lSMcwvGUbFiWAiEA1Yux5+thY2fzH9GTEiG+z1B30m7rIUF5\nFnmrxhIpkQ8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4666", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4666` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAd8FiSk8fZvpJlC4Ei1I9kjZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2Zjk3NmI0LWY0MWQtNDliZS1iNDU4LWRlMzJkYzIxMjE2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U2MWY4MGEtNDgx\nOC00NGRkLTllZjEtODE3ODIyYmY2NTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+oCaIQwvOr5obQh9XfyHHbUuBi1s+mfW1VsUPZUh4tEKXjpffD8txPdXGIqB\nTRMIKEHWEIE3V2hHFMLi8+59LKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcxucoFkzC6aQ72pjrCPtwWsHedUwHwYDVR0j\nBBgwFoAUKboVo5l8WD1Rq5QaQmg8eLPk/S8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAfbWnzIL284T4/abj/QgNxTAcss84aG25bzuM0cpQz+gIhAOq7\n5eoqXxSK9w5L45CXFSd5fn6N4Bm+h4xmkG4Y9G7w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe3MQhoY0SPhJY/fc+yPfYk+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNmY5NzZiNC1mNDFkLTQ5YmUtYjQ1OC1kZTMyZGMyMTIxNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0S0fXCEzWCIFFln2mOqGv0kxVx8fgJyRax0Ty6MiAAvpP\nTKG6h0XYUfaj/81N6Mon9LHjwRYlwhA5UoLPcwKpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKboVo5l8WD1Rq5QaQmg8eLPk\n/S8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaUWfSPsOqqFnKT5GRdHpUnXLrUtjxoWi+Fa2iIefrJICIFLw8IXkwYDI\ngNfXcAnYqhnEhCDpKeUbbRLUapwaG4MP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAQxXyqawRVML3cBEaLmM134fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U2MWY4MGEtNDgxOC00NGRkLTllZjEtODE3ODIyYmY2NTUxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODJkZWJlM2YtY2ZhNS00MmE3LWE5NDktN2U4MTYwMTVi\nNjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElyNKScmhsJOIlW6ipCDy6h3o\nsjKfm4kTSrAcVWFwfbrxpNZppStyTI2PaY0ozzQ1c7QelrKq8BIhU3A+f+owpaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcxucoFkzC6aQ72pjrCPtwWsHedUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgIdl/5wPax0v29S8P\nNQ9p//iLccJXyk7H18W3E0u4XMACIG76S6Zr/nOyOUsgyw+hO9yjhrfiD8upQoNv\nItsXj32L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4667", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4667` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAWdGGKDoR+Jgb6xtNXM8KpUYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5ZTc2ZDZkLTY0ZTQtNGZkNS1hZGY5LTY3ODExMDQxN2IzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBmYmM2YTMtYzEw\nYy00ODA5LTlmOWUtZDNmMzA5MGI3NjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeVbObANbkywgTmmXxs/3Sq5LnVlpQi+Ho0JDjVeALdCgNFwJh78N8ioDg0DR\nWAM5N4bxty926vcsNEc6OuhNZqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmG+uL/oX+tC5ZjtnMzSBV9rshOswHwYDVR0j\nBBgwFoAUj4AslJhQofbKXdyqyjtMdOdGACIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAk7bcNI28jTVJFXWKy1+UPjMr46xxea6m\nIRC5Nj9TBQkCIQCuxN2Cc/3LhWTO8Nzoo8Zn5V5lVXUjWkVLWs4V/WXyzA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaEaFsz+iwN2HG3VFzyrPre4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWU3NmQ2ZC02NGU0LTRmZDUtYWRmOS02NzgxMTA0MTdiM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5hKSrQaVPzK1iW+rrMphZ44gn3i9mLnDmtbBvcGkvfokD\naiWERgsnmPyn7wYiIaG722pwTg74AmDgxl4ItuKHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj4AslJhQofbKXdyqyjtMdOdG\nACIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOd8MusZahhBBWwXUQvCZyjtAPzwx74RRVMqo5frJ36rAiAYzf63f2f4\nOJxPlDbJVxOQWN4/dW0wLNzAxFGHOWsqdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAeE85joU6fCc0lFjxv2fw4jAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBmYmM2YTMtYzEwYy00ODA5LTlmOWUtZDNmMzA5MGI3NjkxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2IwZDFlZmYtODg5Mi00MTE0LWJlOTYtMTFkYzRkNTAw\nMGNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/w+xSKvPzoxCJkM7TSHUHRB0\nD3ysDytrBK8L9qWxDMDlxdfu6+VTBGY+Ky3tHtxn96y8kVfM9TMrWpsnrtWLuaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmG+uL/oX+tC5ZjtnMzSBV9rshOswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALd+gs8GOmO/Tkte\nAHK9JD4cD8KsmECAXIfjiZ8dXM3NAiA/cn4X/5ThpA4HPX558WDalv7+RZZ8H6pZ\n4lV+xvGSaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4668", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4668` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATDwAsGPTHC5ydUBKE3b/ZurMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2NzcwZjJhLTdhMzMtNDdkZC04Y2VmLTVlNTg4Njg4YTg5YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUzOTQzYzctNmVl\nNi00MzkyLTg0YmYtZTYwMzNhZWRhZjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIazBUgBa5pbAeoqLyzXqVpSHgLGXu1w2OlynAkkGTt2IxGMDn54JJ2aMmUMN\nrPQhpGH1k83bXxuAFpe5woqjw6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHmZug/yprChAefqPovO32LbsZekwHwYDVR0j\nBBgwFoAUQAWFNPJxwnCyazrlkaAs8DiKQYcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBMUV6m6JBRorQNTQK0qLKNfvZ39xqsD1N3\nYWZkS1b1HwIgf/nrXkq5uLg1OlB95eLvaILi9O7HCvJd3u8TokNy2F8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUFOCGGIl0bU2FpOg0tzBONjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjc3MGYyYS03YTMzLTQ3ZGQtOGNlZi01ZTU4ODY4OGE4OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScvtWeJJlazj3HGGbG3q6ZU1aHbwlp12QNB7zZIo44kQL7\ncVpOC4Zdh+jz7dJL3pTKnQvn7Ney6y1tfJ9fyE9Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQAWFNPJxwnCyazrlkaAs8DiK\nQYcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAoPUFKXMxntq7/tnLRQaWyeJWuyd3YHqmOjLEYSHdxMCIQCAK54TEgQ2\n9LJ2TsibU92fgaSudDpPU1SiHctFy4eCDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASGBBB8R2XKz2Yhle0PAaSbjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUzOTQzYzctNmVlNi00MzkyLTg0YmYtZTYwMzNhZWRhZjA5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTI2NTEyOWItZTI5MS00NDA1LWExMmUtOGFjZjIyYzEz\nN2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGQIYhMbeC2ofA6K0YIfRcs7A\nJyO+wLx9p8PutHliVbNPbWnTXLaDMRw5NPKuht+yishIOCcBvVmySbC+k+pFdaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHmZug/yprChAefqPovO32LbsZekwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgI8hLMEcvojE9kssg\nCdls2G1FUxQp0btCmz46tsFB7hACIQDEEYd/F/8RRxTzUcFO1mdKoSkgB4+k2prA\nBuOR20g8Gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4669", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4669` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAVCMf4xasiqmywoA2HbdAZmJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxNjBjN2QwLTNmYmMtNGQxZC04MTExLWUwNjc2NGQ4MTczMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDFmMzE3ZWMtZWRj\nZC00ZmI2LWEyN2ItNTY3ZmQyYWY2MjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExqx6cqoE2c+FD3I9//W9E84ff7U1ST6YpeqpUBHIUgP84H5wSyzwO7LayLlS\noKHZI+GCXjlGMkt41ZgIabgmlqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfJAxkOGLOpZOfR2m06hMN17g3z4wHwYDVR0j\nBBgwFoAUqouxFJfqGggbWwldRvT4W5kQadkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA2X3hTpNUdiFS\nz6c+A/Tx/mhaHE8rPQG0GCWyD0l3WbYCIQCRi1HNdRqlP+/BAq9czllazX9QRZZN\nprsw+UkGAPzzFw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWPsQgViErfQcFfYbgI+0DbmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTYwYzdkMC0zZmJjLTRkMWQtODExMS1lMDY3NjRkODE3MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT44CnAzTxgG5XC9c042MB3EQIm2stMnxCKWVVCp4Dip6CF\npq6MVSANljIkkEpkR4SLY4p/W/e+PKVdbg+yMxZeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqouxFJfqGggbWwldRvT4W5kQ\nadkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSq03jUhLTx22cZOJP88hTHZVA6DcYODgcFqtVikqK2UCIFK5cF7h7wDh\n59/GM559ehQoQOGvazxxb7ObRSfl4+DD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAeZPCWJpT4btYJvQukMGSZ2zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDFmMzE3ZWMtZWRjZC00ZmI2LWEyN2ItNTY3ZmQyYWY2MjI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDE4ZTljMGItZmYxNC00MjkxLTg2MGItNGFhY2VlYmRj\nOTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpiXATfDWGdJ1EkFgZ5hGBetm\noegplSXL0FMrNq4Zy+8SJd5XiUgPPodK68fGdNjuk/ASvfc4roGZU9/lDZrms6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfJAxkOGLOpZOfR2m06hMN17g3z4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgb3N2Jth2Hjn+x1rp\njXhxssRnzD6jVr5OdidtI66V6m0CIQC8NxhZtlUioiGb9Q71N5bp/vsz+/UvFOQv\nWr12tIkY4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4670", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4670` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYQU3LvBz593J/ASsjWLnBeyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2MzNhODE4LWQ4NzgtNGM2ZS1iNGQ2LWNhMTZmNmEwMWEwMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDg0ZWM0NDctYzdl\nNy00NzcyLTljYWUtOGY0OGY3N2MwOWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGBey5m0AnbMP7IOfKRvrKmgGei6JI0Eowgp409ONGZzoOFw6I4aYvQ6Y9OZa\nNig1mQolg4X4sb57+Ow6TlEWKKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU82OupzBMirdZkQIt8n7+vXRuYwMwHwYDVR0j\nBBgwFoAUWDmmFe8WVCl+qWdhanS+WiHL3bIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIErIiq4yz5EjRF6dT8m/h7OOTCSGFYixWt4sT5KAnoWxAiAr5cqmQ6ckwrAW\nivYVLIOiAZtNJE3E82S97FbOZUHEbg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAefRr/9WnRZrwb+EC8CKuobwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjMzYTgxOC1kODc4LTRjNmUtYjRkNi1jYTE2ZjZhMDFhMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQE6gTOwPYrjYNczRwYBifhxbJZi/HsRw9cT78bVUoHXidK\nSY1sU//J7OZ1FjNlHr9l6XqxEt01xADxWui3pq29o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWDmmFe8WVCl+qWdhanS+WiHL\n3bIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR7rHrN3zPVO3W41QSYTZtlmeNlYs8VU4jGOTHrEwIMACIHId69oD6UcZ\npR4HHeaQ3EWGYfVhPFavNXDNDIa7U+Mv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbxtDhvvou0JBdexhZdLGe08MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDg0ZWM0NDctYzdlNy00NzcyLTljYWUtOGY0OGY3N2MwOWVhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGM4ZWMyYTAtYTFlOC00OTc3LTk1ZTctODA3YzVjMjFk\nODM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsrlVWQHQg8CZ4K9bxy3M3ShT\nTSFyfQQtr/LxToxCyAU2M7wcfuO1IddCs8XPZD1hV7fHIVy8VTcigZYiKJwM0aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU82OupzBMirdZkQIt8n7+vXRuYwMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgUOv2J8J+uP6EyFoC\nCpibMksXWH7Blm8JXqpMdSMLNJgCIQDraMksUKwvOzgNJnUwbInoIh088HcCMyiz\n5RJUVPPtyw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4671", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4671` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaZDg3bc44UE/W7sRKlnJUNAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjNjM2YWIwLWQ5NTUtNDgwOC1iYTA0LTRjYzliYmU0NmZlNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY5M2M3YWItYjRk\nNC00NzE1LWFlZTItNjliN2QxMzg1NDgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXAevprtNBUO7tT+E+5RdEg78t/XN8MDsV7TGsSf9fxaqxDyZy/aXrbrjtWuC\nnTOM1Ku2hLTS5nzpRK1i73qib6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTsaODb0FlEyaoyZbheqXf52WV2AwHwYDVR0j\nBBgwFoAUDwZNKXHasxhKKHrPtsN2cLeg9HQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDJ3znFC/kv0RBZszz+BNekqRDvFHsyPUjRBie5+798hAiEA5bieH4FbEZAd\nZ6LtrLYYUjBlkU9egh8G8s+rCOMWhD0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVffEK/22K9NPXdrk24fzarKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzYzNmFiMC1kOTU1LTQ4MDgtYmEwNC00Y2M5YmJlNDZmZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS25oeKiV6PUGX7gmAe1WbVNclLyvMyBy5JY90e0dx7ZEJB\nBvho8vQ8jXfKG+oCVZ0JW4RSqjp36FsF0HS7OOkAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDwZNKXHasxhKKHrPtsN2cLeg\n9HQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK41vnTDxM4hqyw8zEqWllsqs2OonbqR4Pto66qdQYIQAiEAxPT+uEDa\nqfcN6kpYy/RgeswfkrzEPSHWWr0UxFhpJ2A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAcZxFmG6wg+TguKP39u3B+onMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY5M2M3YWItYjRkNC00NzE1LWFlZTItNjliN2QxMzg1NDgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzY1MTc0ZDYtNzMzMC00NjZjLWFlZTMtMjRlMGQ2Y2Qz\nMGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENJVLMGxG1X2AfFwHTSO2HIYi\nCk/FktULg0SFqOPMF7xh9whxqv/m9PLKTNi7HhT+OglvOXdbBDM8r6+sC4Ea26Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTsaODb0FlEyaoyZbheqXf52WV2AwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgLEwLXekd4SwlBfwC\n2hHZqDvbvVSnGgm0bw0jNB2CtpcCIF/6aLQ4a8zO/S8j5M7vdpL2ZHQmFJtWiE6U\nT/uNUpjv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4672", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4672` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAX15y2EMM+j3Bs88yn7awZfrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2ZDJhZGQ1LTIzZjEtNGI5NC1iOWEwLWFmMzFkMzQwZjRkYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA2Y2U2M2MtZmJi\nOC00OTE4LTlkMzctYjE1MjQwOWU0NDk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELHUNn2hJWQuIf2sIR4EK0katjnMv/Joyo+oqn4/FzksMDCPP5w13VHeL/JA8\nDghWH0rWD4cWUaplMV+dwznjEaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJLniL0GSIrGL2zjs454WpZI8KdQwHwYDVR0j\nBBgwFoAUmvt07mP/BOX4YfTxeUos8j1mj6EwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEApXDYR6jIS72XqMtM/b0YJfwokFC/mI1dOT9A5+lyOn8CIQDYh3FO8WM8\n9d4YkyKHbqEQ8umhylPKqFSBzscbp9Prrw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVUe46X+KVW8MuAhUVi+oT62MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmQyYWRkNS0yM2YxLTRiOTQtYjlhMC1hZjMxZDM0MGY0ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdyJRWuryMzIV9qag2FEJPHiZe81JsF4I919LnslHoRJMg\nJ6At2S35KCY5JKwlS4A4DOCF0ujrzUZ/SYlqu4JGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmvt07mP/BOX4YfTxeUos8j1m\nj6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKUlSDBPeL2pa7UKpsuqva1nhLQ2kZc87/ZzCxyh2m1wAiEAkzyXI5j9\nzyejg4jEK1CNkXLO4zqZMcvCBX8PfjDVBbs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZH3iIK5k+MuB+Ppz4nnHMqWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA2Y2U2M2MtZmJiOC00OTE4LTlkMzctYjE1MjQwOWU0NDk1MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDcyMWY5YmQtMWRjNC00ODM2LWFhM2EtMzI5ZTI0MzJj\nODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEthnFBFWI9EHF+wPeQyMKK+qT\nXk3VuOuj6eHKBZzw8F7TV5WiYKCdmXO+Se6c5ViX57oWy+Vjzjx0nFV1rDwAGKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJLniL0GSIrGL2zjs454WpZI8KdQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANUFPGi5d/gex3Ah\nIfLIO1F3hhdiVX0bRlnhMrExvxB0AiEA4+4xm15Adi7bArqidTbqLHRx+39YZd88\nKc+efxlfrUw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4673", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4673` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXqHG2ZQd3Y6j88KKaHtITt7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZjk2MzE3LWUxNGQtNDY3My1iMGU5LWZhODk1OTBiZTczYjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ1MDk4YTYtZGFk\nYS00MWNhLWEyODYtMjY2MTQ3Yzk2MGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE07o1aqU+Q3MuvP3VShRFQpqW05r0d+UDYCpr9kXz86d/FVrLWqm0kI5sZ3tC\nmc1jxVQa+Y0dRh4VuV3CjGNYKaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvy2M5hzXwjFSZTxK9GsFAgmVRlwwHwYDVR0j\nBBgwFoAU5gvWfKEy+n99PfTfuB9kejQahqQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBNE+LJgKoC5AiJCtD+O7LzgtXMrrLbt/J9hoESYVCH\nawIhAKBVFtE+U604f9wpCac6GByT4nz4blW6rGTWPpBamFJ+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU0h4yDxYmUFbMFP1caqisOTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmY5NjMxNy1lMTRkLTQ2NzMtYjBlOS1mYTg5NTkwYmU3M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAcGW+ChNlPGeHSSYjSjIDwhrMRkuhDH3ea5w2Svcd+CxW\nfFhpiEE2Aoan0hnA9CIqT+Y2eQE7RXHXSv73YqEEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5gvWfKEy+n99PfTfuB9kejQa\nhqQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKfOtPUS0RwfVMgN3tMk1R8gwPpSLvQVugaj8LVqXS2lAiEAxtIVROhW\n2jopVE6B259MOhyLeTu8fQSb9jYuypDseqY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAbTts50KFw53/8jpsLOfqAi6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ1MDk4YTYtZGFkYS00MWNhLWEyODYtMjY2MTQ3Yzk2MGM5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2U5MTA5YTktNmIzZS00OWZlLWEwNjMtZGZlZjgwMjAz\nZWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE3b6PlzDxA8jkBwmA0oRLpIb\n0wDOYWOU0M71LYQvAd/dbv43p0msM5LO2EO7klV7rSuwQcm+949vUPunWpk3k6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvy2M5hzXwjFSZTxK9GsFAgmVRlwwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAObKhstyLQn/4KOb\ngC48lKhOMK5IimMzC1+bPzqZ+5+VAiEAg/FFZPjD145TT8bn9ucV+xDgZrvbxbpd\nV/koh3VrlRE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4674", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4674` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAczg3rKTk8FarsWiOTvxmgNqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1M2QxZThiLTRkYWUtNGVjNC04Y2I5LWZlNGQxZGQzYWQ0ZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGY3NDMxOTEtZTk3\nMy00MTQwLWI0ZDItNmI5MTZmMTlkOGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6czQIoriQmRQaOGKcQH41l84NqXXUdgDscyeQe9bqNsPp85345NosD0Us+SX\n9kYWc3Q9SeztWlTLjlVVPqr3y6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu7j1+4MzeqB9+E4/7e3Nv0+837kwHwYDVR0j\nBBgwFoAUXr4oEnG+arBFd7qT3ggOJq7hPD8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAxEi+n8BM+1nWiHpYyUu4kCKZ4A5sWNzjQd+e6Lxi\nyiUCIFsB2HTBQZuXNsBYt0LdArc5iR19rAKzs5UN6/e88aT0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW4oM1NGAQR5lWEldTG5kaiZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTNkMWU4Yi00ZGFlLTRlYzQtOGNiOS1mZTRkMWRkM2FkNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0/j0g/HKTO03ksEaQE88UhZBfMDO8Hl2UtDrChVK3qM//\nveISU0lo1wVqWYhwtg6KQdKs8CxICFlcHAkwhDxxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXr4oEnG+arBFd7qT3ggOJq7h\nPD8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKZZh1rvbt0su2RS9VxoNQ/wERhAYncraHsiNcW6QsbAAiAw+BzoVrBq\npoLXPS6i2+W3Cxj+yiNn31eHX9S1Ca2YaQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAaoSQcxv+DwTctaG0UmhbVNkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGY3NDMxOTEtZTk3My00MTQwLWI0ZDItNmI5MTZmMTlkOGI5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODU2NTg1MWMtZjk3My00NzM3LThmNzQtODllNzVhMDk4\nYWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfGxoM5Wf6Es999gqyiQveem8\nYKyYeMcGA+DrOSV1yJFAM3bQnoMXXDWWi++XUbjuvBQJqRGA2wAOfQKsuoY/d6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUu7j1+4MzeqB9+E4/7e3Nv0+837kwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIF9tGEok/kilaaq\nPgFRaonYxIdC4tWrH8yQSKVGYk3+AiBC+HEB3yuxU8O9LQl0/kinWjsrr1vjn58i\njO14Lj6gWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4675", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4675` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAXLlgs/9gQRf8F1k0G5tA7CoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2ZDExMWVlLThlYTMtNDdiOC05MDc5LWU5YmI3Y2I2N2E1OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk5MThhMjYtODU1\nMS00NmYxLWI1MzgtNzNmN2FiYjI1ZmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuBysZeUPkqmkJLwIS3rJWIvtFd9JGIK7yZibPEwlBs33Yvap60K7DkT4hHaG\nSyxz6dg+KcCiL5ysir8HXAG0ZKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpUb4HqM9JcjHJJFBD4czr1bbE5MwHwYDVR0j\nBBgwFoAUlcgGAGnOSAog7Il5M2e5tne+dSAwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBzZyOO21oTkTtWg2s2mvrO7s9opQ6+l8o1Ia+jTtecDwIgW/ZX\nA41N9PFU5N++Ynbh9VgLn63WmuxVUP9AKU/iPYo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZuP4P1t5qxqSyHhTYBUMax7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmQxMTFlZS04ZWEzLTQ3YjgtOTA3OS1lOWJiN2NiNjdhNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV2djnXlKzLQYKS3NiQ+kp8FAXd4iHZRbQ9BDitGx/ixU4\n4opQ8SlIGZL9efvOMnYuYVUmSM2cDDwVCcYCid2mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlcgGAGnOSAog7Il5M2e5tne+\ndSAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPV6rHc3Tl6PvzEZcBJZC664G+GmPW4Dazb4oZvKdRM3AiAiCzLxU0bh\nOoc+tcggiTTyw+wnKLOuWolRuCJNHcX1Ug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISATLuf304sbfWb2dDkOiercFgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk5MThhMjYtODU1MS00NmYxLWI1MzgtNzNmN2FiYjI1ZmM0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTlkYjE4MzQtNWNjZC00ZjQwLWE1NjEtMTU3NTM1OThk\nOGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfwslN/Iqflv2ln/7Thd8NFKL\noVRvqszZIsiyM0y+do9iHJ4dEgWdxpIVpE4CCdMlqdFopJzxAjZ9MUtcVntvBaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpUb4HqM9JcjHJJFBD4czr1bbE5MwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIBDJ6+qWQsJ38nO\nJTeKIXaeCwyNPSZG6PFqrY0Lw+MqAiArmzChl3wSVc2OdSpqYficdRF/JL6IMf2I\nW3t0en2YkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4676", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4676` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAW0g/jVg0cJ5yllICqC6GQBPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmZTUyYjI5LTkyM2MtNDM5My1hZmJmLWEyZWJlMzQ5OWE3YjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZhYzlmMDUtMzdk\nNS00YWZlLWIzM2QtMTZhNjEwOWMyNDRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh2NgTKfpyDjgXCkGpT1TM4x/sX1y9JZPMLaqNp19YVYDKhQXQU34stu+fXy9\nGZqddRjP0iNyQFyJHdUoak6Xi6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmSFxJU0g5ShJ+91o82m/ultIfGEwHwYDVR0j\nBBgwFoAUki6whLloinB9TmOWJTqNZqeGlFIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiACizUK5k1BTyX27lKKBto+AOsLQFijZ/Kv\nuFwM6RT7bQIhAPCcrcjhxiJwFVZ6o5862yTyRDH6sSGwovwmLx8VtfWz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeivoYQRrl/LZEb5vl/1CwvzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmU1MmIyOS05MjNjLTQzOTMtYWZiZi1hMmViZTM0OTlhN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuVDl9+dcYXzlwcg/wt+qw7MTF1C/zCqpILMBBFGkK5By0\nCI6EvL4vGY/DRhuTaoYDB3xrLIWH8C7djg11kE0co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUki6whLloinB9TmOWJTqNZqeG\nlFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJq5X7qs96CI+Jn/cQA541NFuwdT/VGS3QSYHN0dI70IAiEA0CGwQlKk\nORIDCrC2aCJ4yhHIasRPtSZOGYFJRgPoyNM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISATsPjJKudDNV3lDptsLoi1tPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZhYzlmMDUtMzdkNS00YWZlLWIzM2QtMTZhNjEwOWMyNDRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWVjODJhOWQtMzA5NS00NmFhLTgxNmEtN2YxNjNjY2Vm\nNWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWV2ZgTPoba4dw6ruspW0dwG9\n8lxkrXWvNTdJ2MZfhJDYc/9/smCfGYhita7XgK/xgRPGyG748Q0srgjQvsfQnKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmSFxJU0g5ShJ+91o82m/ultIfGEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgPfs+g02SSddAuBtL\nFyD59H+1AfLpUj0s8WgLMFwqVvECICrSISR1A9tIGWDarVI/CmvBUD09wGs2ATlF\nezehLSBq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4677", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4677` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAZw94CTLEYJaS6Er3bcy+FvqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmOWU1NGI1LWFjNDgtNGEyZC05ZDBlLWNkMjVmZTliODJkMDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGEzZmYwZGQtNTg0\nNi00YTI1LWEyMGMtM2RjNWY1ZTQ4OWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoKVhTDmWtgRrrZMUBw4KQ754xbctDM2umHIjVfMxH9dq5xR9hW/PjJFysxC3\nJBj6wOwVHRRC2HPRMCT/FHaDWqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbmO8n0UaghIF6Koj1amXCHBov5wwHwYDVR0j\nBBgwFoAUIqlbM5lOVX15gtL5WHwJ2q+y6AswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAh+/2Jg4UjvJGng8VJ0EUOcYlbZWUtaR7\n7oz0k2QL9fMCIQC9y50q3TVZZcaRAPIoAiYw8UgihBTy46a6SvWHBnhFRA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQLTDDkLYxA9YndNmkxmn5nBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjllNTRiNS1hYzQ4LTRhMmQtOWQwZS1jZDI1ZmU5YjgyZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxutHlZpjWxeQtoJtvJGZVLAbMUGCI2vrIOkHNVKy9/VK5\n7vxx+/htKbDWy+WWtV4FNStOSi5QYN2o1BoVH0XLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIqlbM5lOVX15gtL5WHwJ2q+y\n6AswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAICrgimATG3UAx9mQTc/maYvXSkW1Y5brysoODle3NpHAiEAh6E9Sbh7\nQy00FDiL86dBKD8PMyTzsqrhLf+f3B31OuU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISARzWE5GnUFoyekbLFBcHa3Z6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGEzZmYwZGQtNTg0Ni00YTI1LWEyMGMtM2RjNWY1ZTQ4OWRmMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWVmMGJlNWItY2IwOC00MWZiLWE2NTktYjhmN2IzY2Mz\nYmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBSANxgJtjiA8Mgt0NXiF0Toj\nYjcfux4IOrZq8zq+Kf68SXVeDHfW1m9Mu5S9rvkdmtyxNJPKWjV+S1Jz/yCtr6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbmO8n0UaghIF6Koj1amXCHBov5wwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgCoobAqdratd/BvXY\nUolDSoHCxwbFbMgSR7LK21Q5vDUCIE0+kLnklLwVV/FcYvzutR40nN9bxqNMCkGc\nhel+08UC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4678", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4678` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAQjuaF91cnAw9sgr+dmabfYnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViY2IzYmIwLWNlYTAtNDU0Ny1hYWY3LWNiYmM3Nzk4ZTlhNjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGEwNGJiMDctNTJk\nMC00ZDIwLTkyMGUtMjk1OWE3ZTQ0ZTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPPxslWiXBgoBKOJlByer/UF00kZg2293uwgFgyWq3sE0K9enIL1O4FQLXIXZ\nFtrjeo3eYcmLtUIKEpqlnGNXTqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMPLkI01sj94dwSA8Y+nPZDvm158wHwYDVR0j\nBBgwFoAUhxG73Zu9QtWiIZYNstQU0vLmc90wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHTy0NBaHpyFNHg3QPJQ3YErmuWb\nc5cMO5IjjX1lJu7eAiBmzr6TdQuFw0k6ujSz2YOEFevKJdYukXFlD/0hBdPjpg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaUt9oOq4ffwQeqjPCvYOhC6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmNiM2JiMC1jZWEwLTQ1NDctYWFmNy1jYmJjNzc5OGU5YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrMdrl/F35WFI2blUuThDdndV17/4wJIN332rM9pOp+c0q\nrQttsyWh6m/wS/vAdnmwRbTrqwr3ycEUzJ3VcoFWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxG73Zu9QtWiIZYNstQU0vLm\nc90wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANK1Mpq4AL9zm2ml9j6dqcOkRagzlOfrCS8HZzWjwAa6AiBpakxWW91K\nj5MfnoS0RouG7WBtvLJTZUkHMhroB5Rylg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISATb5kArGbNRlJd/4H4AYTTaMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGEwNGJiMDctNTJkMC00ZDIwLTkyMGUtMjk1OWE3ZTQ0ZTNkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOThmODE0MTUtNjQwOS00N2ZiLWIyYTYtZmJmZTI5OWI2\nOWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERxNpRDQz8dY6BHMdNb7Oj/nV\nx2sUF2LDHB5H9IFOaXVywP2iT7MIusCcVzU7DC48UbG9p8c8CjyammfWLEvTzqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMPLkI01sj94dwSA8Y+nPZDvm158wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOaZwkfgjJNKygxJ\nofQhM78JAou7g92l4nWnSNNJ5FhEAiB08XZppGKacjOwdkux8osByrJ7kfTmx4RH\npxjYsjjA8A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4679", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4679` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAeiCGV7ElJRqc2csmqfgF78SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViMGM1YmI5LTk2YjctNDUxYi1hMGNjLTZkYTM4ZjIyMjMyYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBiMWM5MjAtMDM2\nYS00NjNkLWEyMmMtMDAxNDFiNjcxYzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEESSLMFgKt+Gz3KiozZ/rY0oV80vgu4WuSZdqj9eAg7p31NKmqGSpv0G4Ykhf\n1h2k7zIBq1k41ZXbH0gNgNjsz6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKTX+5brWYhSEyPQM0wx0e3QOMZQwHwYDVR0j\nBBgwFoAUqzevp4dkljmGX1ESrdLUsB+sXuwwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMkz2UGn\n6aybZcWdOs4SMIAPt3HdNnTDpYUUJ3JHehMRAiEAg7rqZ6gfYbMd8Gt97sFVBSK+\nP1kNNXWSn//Hg2yr0ho=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZxtqL1RrVS3w/MtHgCJGxKfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjBjNWJiOS05NmI3LTQ1MWItYTBjYy02ZGEzOGYyMjIzMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKSfizbw7G6vdhk4hXr302f27aeflJ/lMj6irdAzPt0Wbh\n0wrtuQcb1VT4Nvs0x3VLBIwVvHVe8ddet1yaBoaeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqzevp4dkljmGX1ESrdLUsB+s\nXuwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJbFwcIcCXC+90431Ej2CuFc1ZiRwDS3NK7ZSGZVe6R5AiEApVU4NIMs\nkMQJl1NOajYX/8P8Q5ICP/AbaXjF6NThbkg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAdM/bVY92alGCJEb5m9r+vb5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBiMWM5MjAtMDM2YS00NjNkLWEyMmMtMDAxNDFiNjcxYzMxMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTkwOGYxNzMtMzA1OS00ZTg3LWJjYzgtYjQ0ZTU4MjE0\nN2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzPQlXn4FZztE1dSSntdEYup3\nN6SZR0CSsr1PADNVyMC/WFSZgWIH/5hp3BLYB+sbjUbVBpIytoUV2BQ8wu2doKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKTX+5brWYhSEyPQM0wx0e3QOMZQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgePpfgvFbjM19dR3p\ngVg4ct3yE48Nv5MAbQtmFwhx9gQCIQCUOvS42Gt8NxTGDRq9Jfxi77FMg8W4zicr\nNfthSyfQJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4680", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4680` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAUf5YJXgzKlzvZXoWx4qlu09MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxOWU5Mjg1LTI2YWQtNDAzNi04NzU1LWYyYjc5NmFiMjM4ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZkMzNhZjctMjhh\nOC00YzJiLThhYTQtZmNiMzFlOTQzYTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE17GvzV52lMfkavdF9gJTVYJ1AJlHwvTgw8SC+Cs46yBN+/m9Wcw4FN7ojSRa\n5Ox5L5Pzf1KI9fdxy7OHdYwCdqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYJigMT7SMgfCm3Yv0iDeO1VhneowHwYDVR0j\nBBgwFoAUmjfgqO75we+wsLK6WXWGIlp5f5owKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgQFHQtCxO\n6XejCLfzWjRP+yJgqvhlKyFBwbt6Vme64pMCIFLm646T1GmZLfUOcJhGyhIw0xXm\nadafm7v8y3KzreH5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYeEUZSPVHqHmO8HrmGikfA4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTllOTI4NS0yNmFkLTQwMzYtODc1NS1mMmI3OTZhYjIzOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHOIRhlheSXXHFX28kaweYXGVcrxc+uELBh9MJ7i9QySaM\n7eq30OeArDWeOmMbSPoR8Z+84mfv8OaapuB39kato2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmjfgqO75we+wsLK6WXWGIlp5\nf5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYfzm7D2nlBZCYKc0g1gaCfgAKM+KPEE4o2VFuQ6P770CIQCw6OyVXrNo\ntxhZ+DX9+6xiobNP5VBtBDMvncGz1Nq81Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAanDXv0trBFqvfobZw+0WM5YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZkMzNhZjctMjhhOC00YzJiLThhYTQtZmNiMzFlOTQzYTc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWE1ZDY0MmItNmM0Mi00NWIyLThiOTktZjBjZmYwNWY2\nMmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESEWABo4rQ9NGAGzE4hi2UOaP\ndJiT61OHLRZl9QmxT2aqHogUNrnvOWkcPzOy8u0BKGM4bDQzUQeSo9KpoYDYpKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYJigMT7SMgfCm3Yv0iDeO1VhneowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgM9CTz2QHgUJUzxRx\n0KDdkn6FC7w2OM6UILTOmxpGERYCIEEncQoRRpuuPIYAsgyO+cIiV5n8hdMLllKb\n/D8BRdU3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4681", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4681` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAZCywBTituPswsjLPYvlNtxWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxMzdkNjg0LTIwMTgtNDE4Ny04ZTY2LTdjZTA3ZGYxNTQ4MDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzFhM2U2MDItZmVj\nNi00MmIxLWJhZTQtMTg4MGQ4MzBmNzA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBR5TdP0ruPRnwRIsUnu750PSUfTD23U3x5WY1f1D702kIiJm230COxpWKQ5z\ndyjauCvWT3lYMLQBuVabDeXzd6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAKzyqYHMPN6AsuH2tElYyzWEvScwHwYDVR0j\nBBgwFoAUqKwoxI5Lv8fA166MFsKtNz8Nq3gwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICVcRNXY\nLrTDuonMSKM2U83Dvg/6DLJ8V98KQI24e5WYAiAuIoX+7zNl+D082Q1Xz4cOkppE\nsWCBg/KdyhHiszzNXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAV+3FCDw4o43BLynO7Di8uyiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTM3ZDY4NC0yMDE4LTQxODctOGU2Ni03Y2UwN2RmMTU0ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSRRzIxDZMf1FG3ycUeX83BZhKeS+SLEw1aUkSpCNmYr/i\nUjU3sMPPCBvb66ckJHpSWPFlU1V968Rkkn+6nCJ+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqKwoxI5Lv8fA166MFsKtNz8N\nq3gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIfAr0PSNL1h8QdbW8RJmaE7HhFyAt6ejLUtVpnnFMX5QIgMr100CgdD9dk\npbIg1IQum3e4E7/epP/z9yQr+NtkgJY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAZ5hO8EMwURD/YYZC/dYpkh6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzFhM2U2MDItZmVjNi00MmIxLWJhZTQtMTg4MGQ4MzBmNzA4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQ1MjNkZmMtMWZiNS00OTQxLWEwZjMtNDJlZjUyYWMx\nZWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHJOSN0dLRFPtEoQgyUr8cjzb\nqowsjaHNMsiqoYg4ivaTVaQ4q3FjC3rrIV3QuqKUBWUD27o/EhKPRh8Z/K024aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAKzyqYHMPN6AsuH2tElYyzWEvScwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgAPrdT1cpE6llsQVc\nfzjjk6qGvH5aIKnd6ddq6clZGQECIAZS/Ree4Dogj3vKNVAQb1xip1q3KComrCxw\nAwJycrD3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4682", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4682` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeDT7pL9gto1SAM4sQHW1fjZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4NjMzYmQwLTVlMWItNDFiZC04MDNlLWE5M2EzMTE4MjNkODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjVmYjA5OGUtYjNm\nMi00NDg1LWI4N2UtYTQ2OGIyYzRiMjgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEanrKgufnmLAoxVMEivvFkKg+YKwKPAFeSiD9Ass2lAfwcI/hYzLCcm6he9LC\nLFYP3HwjPGUaMwpXolYeyXBMu6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULOZmnujnOqLEELBne8MwLrMv2pkwHwYDVR0j\nBBgwFoAUZtoNzI9x3rhuKopOrRo9MzUdaoAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCCdGfrw2djRgmIlzyOCiwXzFC6NaTSxF7MZNBWiuc6rwIgEc37e5d/\ndJzL5Yu8aGyFSCPMUn8Tkbo+lYITBL1/HyA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb3rxcAzsU+IKxDAbS6ksT6QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODYzM2JkMC01ZTFiLTQxYmQtODAzZS1hOTNhMzExODIzZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdJpdaF9+FQNLqJe9zeMrUAWg+5ygPkbTr0HiREeWG+6do\nUJ2kGW1zoFGMq9wokUNbH/NnjMU2a4HLyGgwF7p2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZtoNzI9x3rhuKopOrRo9MzUd\naoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPng9vM6k0PLMu8J8McpUkXW08ibJ/dO3M44Nl+q4mS+AiBNjSIBoytq\n2QuIx/ycx8GDKbFusvfGnt367lVwPejHGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAdtM1k85/P4bMUrpd2u0tt2hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjVmYjA5OGUtYjNmMi00NDg1LWI4N2UtYTQ2OGIyYzRiMjgwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWZmOTRiYWItYzE1NC00YTMxLWEwZGYtYWNmNTVjYTMx\nZWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5WQu7f0SMw4vEtSynTLnqcK0\nAXtqWUJ1SrAtlZr1EkDLP+JUhQyhHetH3KAoe8nUKRnsxRZ+bCXisjONzTxEJqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULOZmnujnOqLEELBne8MwLrMv2pkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgYIkI7FNunjAtieqz\n/EsLWWIZYgssAiaOzUfYeFGAmbkCIQDYlDy8IY1LS3vEltZSeWqNWXmhErACz+Cz\nFZrCVwxyhQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4683", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4683` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAWy7JUAWS+BwweZGvwW2acC0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3MDQxMDBhLTM2NWItNGM1Yy05ODFmLWMxZGYyMjk4OTkwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzdjNTUwMDQtZTlj\nYi00NWNiLWFlZDYtODIyZGE1ZTE3ODZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY776bLYAf8C3ZZzGy3O0I/7axKRBSSiUz5KMsyArSW3qvd4XQn7PdWNCw4VW\nNCNRPQvUNcDbdqtBtnaZ92UwFqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQU1F6pNQdeg4n0Dgew13U9QP8icwHwYDVR0j\nBBgwFoAUvpgUGwiGa/7q+j7ljmi4jU3d5WUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIG7nOiy/+y5oTObuCM6jasZo7YzB3D2T5dsCnC6i5HayAiEAqI1bIHqb\n7t+69Rcs2BeWP1o3hcoYRdPXhd3L7+0ccJE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ5tWbNBnGUWUG+tI0YVk4SdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzA0MTAwYS0zNjViLTRjNWMtOTgxZi1jMWRmMjI5ODk5MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARthEzTdwdA3sXUYAGdQHP9OZ07dnehnnlFDjN8AUosbPsp\nOhcBiimx6EtxG+/WpIY8zbNHl6Oc0mzEVNUBqKk3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvpgUGwiGa/7q+j7ljmi4jU3d\n5WUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOMiVLZwNzf/vN9bA5aXHQ3iuKvt+ms8F/A4gd32uBMdAiEAnMl3Vbv7\nWKcjW/h83fq/kslnxuiP5t+Z7IGevdkOxl8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQNT3ysFQVWYAN/K0lZzmWt/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzdjNTUwMDQtZTljYi00NWNiLWFlZDYtODIyZGE1ZTE3ODZiMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzI1N2U1MWUtNGI0NC00NTRkLThhMDItYjk2MTM4MjQ2\nYTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOJJAfaPHPxfT8e3fNDNRnmYj\n9TCtcdrHlAd58Una8QiDTEVwZVcitQ5IqCm0LXlBpdZVNKiqJjIBY5k5usgxGqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQU1F6pNQdeg4n0Dgew13U9QP8icwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgcjjU4t08geJXALu8\nPIswq6+nGhOmYHQb/vwtEfp4mkYCIQD6P0TV3lFFRZfcXtsaFPvkR8+PIzf5HA0n\n2eEar3sz3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4684", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4684` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAVdaGDfGzj42p96qC8/BtvsiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1NDU1MDUxLTkyYzktNDQwNi04NzJiLThmN2ExMjUxM2YyZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjYyZjllMjUtYTU2\nNi00NmJiLTk0YWYtYjI1N2RjZTNkYzhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3tkRINXHPQHT3V2C+ZaYgxvs23rK4Bs+HhimY77+1Thgg9MLbm5wk8kWxuXa\n5KA9TFpw0zY4DyecyRWo5ImVK6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp2pN2IsI0Baj5GODe7EkBR/DCkUwHwYDVR0j\nBBgwFoAUx8KGtiI0sgi6FYlscWlngudqQk4wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQCleY/Cg5BJq48u0rSkLwAHKOToH5w1Dv0yhWRTsWIM1AIgaEQOIOO4O5JTdWWN\nH+SvU/LBp6lGsyFCIrQlXbbFKCE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVsW7J4Mwo+YwmeYSaLZNwdfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTQ1NTA1MS05MmM5LTQ0MDYtODcyYi04ZjdhMTI1MTNmMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfbokNoETf+WORnT5FTHGSna4WpbFt3nVlivdZrAvX9gfM\nOvxMepYNQyw9THaJ1MypDoYu+S4hQWc5sSfLc0Kzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx8KGtiI0sgi6FYlscWlngudq\nQk4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW2ln/ZBaxFTEEZn3pdmj9AcQe4Zn9noMpBe2wgxla2oCICesghRDXsHs\nruJVKwojHQQ1gif8udiLqp/fpgDtj6Pt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAUlpHJhqWxLREoLnFnVgJclfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjYyZjllMjUtYTU2Ni00NmJiLTk0YWYtYjI1N2RjZTNkYzhjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWM1YmUzYzQtM2FiYi00Y2UyLTg3MDctNDYxYWZmMzUw\nNjNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuxGSYt2DFSqvqAkAWQBMwyCX\n1el/oD8IbIYDfu7Tse5yDgnH6pnUO7SVhcb/+ZEUgL5GwJHtbyNFwUOUR+aeg6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUp2pN2IsI0Baj5GODe7EkBR/DCkUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAK7jUlUInLeDog+k\n0ERemBwBeuh0XWWkEGxFuGQoVdAeAiEApifQ0iD0t4t6PXHb437HQagKTosVVb4K\nA48ewPSnVNY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4685", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4685` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAVa+TuRBfVoaR1fkpxd/CsYFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNWFhZGRiLWVlZjMtNDk1MC1hZDA2LTVkNzMxODM5ZGE2ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI4ZjUyMDMtNTJi\nNy00N2ZkLTk3MTMtMWRkMTgzZjMzZDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfuGTSbVMflWvuF17whWYOgXnTsn6a0pktVjDoJvX+bIU23wPbHV0W+6w5T3o\nThXJ6u/AAsJZcsSBEai5cwfnmKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPe04qtlZ2nz8NpvI2/FRSglGb9IwHwYDVR0j\nBBgwFoAUK2UQEb5Ak0yuCWLYZJqdnbl1xLYwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQClnvwWEvukNzRCu5kojEhBFR32Lmo3BxWulJKpq8k/qgIh\nAKVOjTK/RqhO1bEVYE11G1Ad8yIrKWqhqitHhx2ltdxk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdeVO/PCXbh42vbFOaCjs5taMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzVhYWRkYi1lZWYzLTQ5NTAtYWQwNi01ZDczMTgzOWRhNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARg/pCB7ct0riGAvq3pewtZHWbBBUZnmw2+Eq82/OR6117C\nfrTalzPKDXraFqNudV0XIklPEuWp2pL17eTfF7YXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK2UQEb5Ak0yuCWLYZJqdnbl1\nxLYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLPjVGSsZ2R51DHFKszLcjKyBsFzZz66iKzWO6ftSVdsCIB/hCYyAgDvW\n/pLpLuZnGgiuYUUQU04uhV/IxSzRbaDb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAXCOuwS8wShoumv7ybSFUAGCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI4ZjUyMDMtNTJiNy00N2ZkLTk3MTMtMWRkMTgzZjMzZDY4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk4Y2M4MjAtZTEzMi00NmY3LTkzOTItOTI4ZjFhZTUz\nY2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExGAKyXkIRMKpw7aVDQtZMAcU\n7pt2rynBXFCgD7Azl69yvEjHz3SzPCcaBa9wNZShYQvfIyw5RA1TUeJYFEud1aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPe04qtlZ2nz8NpvI2/FRSglGb9IwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgSR5BParZkm7gYwEX\nnxOFZlWsxY0K2bGOEpYPY16nvh0CIQCBlwzE6ZV0Zt0TZ2DbU0o3T7cs7UwIFsK+\nHd1i8iffXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4686", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4686` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAXhVZBlc4CyP+nrcRfGwNG2cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjZjIxOGMzLTk5ODUtNDEzZi05YjZjLWJkYTQ4NTAwMGI1ZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YzMTE5OTYtNTM4\nMC00MWJkLThjZTItOTNkZWViYTFiMTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy9hkSIeOl803bAx7c49hq/ckio9qUdfFBSiYNZP7I8PqN4JUBclBj3OI6P6f\noblx14roI+s/noLFAvho+1giwKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk/4tyS5rLudihuwQvhdZov6USPowHwYDVR0j\nBBgwFoAUiUDg177hr9J6aN5+GddPhxokiSowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIFqfg5s9b/tj1lm8rCoaz3Elu9Zt+mtgFmPPe8jjT9kyAiAg\nmSzgNJh1R8sSTDC0lWXqV/aPPNmskUZqWE/16/ZwaA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU8N9yqXzVlbmiPj4A3GvANNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2YyMThjMy05OTg1LTQxM2YtOWI2Yy1iZGE0ODUwMDBiNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcrkfhlYo5mS+3vPakQYYBS7e16bVHq/whpPvjJstUMCm5\noUBFmjK8V/fvC1mEAs51anxRG6mV1JYPEgL4oX/Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiUDg177hr9J6aN5+GddPhxok\niSowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLcW3wuRrHpZJPyPb3KiVF8bTK0M9/74+dsa7slX5/nACIQDyWhru+o6Y\nlLd6HFCK7KjQF/nzNlDNVD+ZxeZ5fokU7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAeJhx5t/0uvx/FNA2/3Y8rKJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YzMTE5OTYtNTM4MC00MWJkLThjZTItOTNkZWViYTFiMTYzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjAyMjRlYjQtM2YwZC00ZWNjLTljODMtNGZkYWNjMDA3\nNjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExeHoX57WLCXO5cHA50NCpdId\naO5326RsSkl1KyhDiIuMugGFPqUHLImH1BmxyWF0+CyqGalnPmMvuhNo6oj3xKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUk/4tyS5rLudihuwQvhdZov6USPowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgMmTJSRPsEs0HOYQk\nilTyAC6IpqITvp2NmYDf29d0Y50CIQCXwjYrEB3aQHUOIYwvOsQy06KQL89FGxVy\nqjLJkSPRNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4687", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4687` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAc4KdIXalQzbeF31TTtRwnd6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiMWU5NDRhLWZlZDgtNDc2Yi1hNTFhLWE4NmI0MmRjYWM1ZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNhM2I2N2MtYzcw\nMi00MGE0LWI1NDktMjVkYzlhNTJhZDRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMTWupw6XW3msFln5pb2IPrcj1tCY7M+ozKh/WstZtOCoSob7V5/1GxcQ6/Ak\nAT5JmPrbukWPxjKZFX8Z7x5yDqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK5rhzW36zuRgXw/UGHfVv8/JpRswHwYDVR0j\nBBgwFoAUw3uI3lmMDtC5LHSPPPwvXhpNhwswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC/f2VWA395\nA9hvTNTJiNYthZ6pDccwXMZpJHXDHK1PEgIgIVdBRb4LpiPkrdw/CtqkAlHnxpW/\ntz6UyLjnoVoUWmQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARekLUKJoYXp4QuFR2rJkQK8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjFlOTQ0YS1mZWQ4LTQ3NmItYTUxYS1hODZiNDJkY2FjNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3hatK++I42GPoPnr0SaprhMraFvBanPXic1HFVT4uyXh9\nx00J1LIBZIH4nMoOjkL+p0BNs96nxPM9o/85iAB3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw3uI3lmMDtC5LHSPPPwvXhpN\nhwswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOwHqEf7YsxgE7l47g1Dqh6B1S9ihmroU9B6DnYhep2VAiBO3/7HM+wh\ncF0R6qE7Xr8FfoR07zR9FOeolhg757fAcg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZ7mqCh7UKEzsgqfiZnPu+JlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNhM2I2N2MtYzcwMi00MGE0LWI1NDktMjVkYzlhNTJhZDRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzgzYjExMzQtNzU2Ni00ZTk4LWExMjgtMTFmMTM1OGQ5\nMzk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVvm6PL/TsqsjecQ05PBncED9\nf7Rfp32vpGsm0fdApMgPhqrFhe00W04tWnNqalOk4fH2uOjHGoeozBzOPToxpqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUK5rhzW36zuRgXw/UGHfVv8/JpRswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMLNfDiz2MagsVF3\nMSTg7dHFp75uNFEoJBAUj3xtaqNiAiEAuG4FhptykQMPUAmpdxCW1AobcFn69rIc\ne2e4PSwjF4s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4688", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4688` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAUtiU7kwsmUxC5w03HPt7yHFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxZTY1NTBiLWJkODUtNDAwNi1iNjI5LTM2YTdhMGJmNDg4NTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdiYzUzZjctODQy\nMC00NDYzLWFiZjAtOGM0NGE2NDBjNWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwL1IMggiuNeopH926XGMiX8F+dcrK1BlBondxCCwTLriuKnWtIhSamgjfMrn\n0XwZDs50vuASprXZ03+YLXDXN6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlqrEdeenCDmH505Y3vcxGYzX6+YwHwYDVR0j\nBBgwFoAUb/znN1gnx/rz9nLvw6f+Vw1fZZMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgJ980fM8N0UmC5S1amSmlFp4NHSnMb92YatcgqN9MMFICIQDQX2wuanQ2\n5AWkHBE6EQGym4EJyZuImo8Tu9oET09dYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASEN5VgkzknNk/T7CCrvo8H1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWU2NTUwYi1iZDg1LTQwMDYtYjYyOS0zNmE3YTBiZjQ4ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASB48k4HKc9YXivtUS3eS30nUZnyZA/jzk7Mdq6OyS4RdJ5\ngka0wa8KoSg8NuSdBkZ8gRYI6l7B0g1nBo5GoT8mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb/znN1gnx/rz9nLvw6f+Vw1f\nZZMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALIm/5QQ5haj/d5y43nCa3MH5ZmzcEpS+ZVAzwlKgARGAiByieLVI34M\nYveiy2th6EEB4I0lftzKr1feuj5r5lP4dA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAcVNx1t7rwfeMRwpu7hHIlO6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdiYzUzZjctODQyMC00NDYzLWFiZjAtOGM0NGE2NDBjNWE5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGMxMzNiMDgtY2NlNC00NmI0LTk1OWUtMTFkNzMyNDY1\nNDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsFiGMTT5U+4N61XEViF+8di0\nHM1YMPASgeqY+87dywwvrrI6LFgwmdsX5fIZDyrqGo4PzgrzQu6METkedYqldaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlqrEdeenCDmH505Y3vcxGYzX6+YwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgFRrihUanPUJ8W0xd\nYVW3YLYzDYwkt8rcSE84bB/DfhQCIQDbwbq11RCojL1R2AbwDaspNHJGs33O2im3\nVXBj3ixRpQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4689", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4689` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAeQTNTqq1/Gr/sU5D6njBrXFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNTUxOWI3LWY4N2YtNDc3Mi1iZDc4LWY2YTU1YTc1NTcyMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVkNjJjNjEtMzlm\nNS00OTI3LTg4MGItMTIyYWRjNWY5ZTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIh4PVRL15KAeGUT20eYOGZaE4y0P2n7pqXs+tj4gdDY6NcQ4D/QxMBb85yn5\nK6L469gfW3b58tabkgHxD1eRHKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2h3k5KaR/wb2/M269EyH6g4CtCYwHwYDVR0j\nBBgwFoAU/PzJujR/Ryt9YKnE7W1/ADGrqW0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALJHRnxdhILObJOshExbgiP6wLMpaEOnQn5V3DC8DxhyAiEA4KP6KJWm\nsJSYKtHwgHeiKgSqaP3OxE/MymLWYXQ+pj0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX0Ul0IXIieKvlJlUztaisCXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTU1MTliNy1mODdmLTQ3NzItYmQ3OC1mNmE1NWE3NTU3MjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQh90dKZV5o9AK6OBFUkHTYHoK26Ag7BpcpVPl38GKENX4H\noCtx2nV2zvUHN0zdEakFmuCajxtZcH2YUpZf1vyro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/PzJujR/Ryt9YKnE7W1/ADGr\nqW0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgViH7uDLjOb/soojPkQsNIbuM03BNZ76kLs4Nif94F1ICIB7IhUrVvfRv\nBkPwcW/PiJm4tFJxnL+sekQCYnh2d2vX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAZ3bkfigrNjcTHeE2iRXqDaDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVkNjJjNjEtMzlmNS00OTI3LTg4MGItMTIyYWRjNWY5ZTg2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGMwOWE2ZDctOTI4Yi00Zjg2LWIwYzctMzBmMmU5Y2Vk\nYWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERqh8Hw1cQKMD3HeRIsoy+bBM\nocrFrRf5XgSNdOV54f0Uv1e/8WEuW2upiWoBUCJwZbSe4A1Sc1JQwaYo4legVKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2h3k5KaR/wb2/M269EyH6g4CtCYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgZkhl1p6DpuaF7F+T\nOFcTCy3uwzu73Xnd7hRQtLNKOekCIC6nKzy2ZjOr9OApKD/YoCyM/6H0v5LfVSlw\nOidjR6vu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4690", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4690` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAURdEzNF1mHJPopz9rmhfYvgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1MmVmZDkwLTE2NGEtNDIxMC05OWY0LTZkOGY4YzEyNmFhNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdmZjZlMzMtY2Mw\nMy00ZDMxLTlkODgtM2IyNGFkYThiY2JhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbgJSLqE4Ot6Z/raUJAAPr/sfo+llMF14EERTMFIsf0mYLanylHO5lOdOM8lw\nYIr2X2lTgZrzJOkiP6G71ZUoIqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNAjq/UDGY9WwPp0hGk23j6dTGeswHwYDVR0j\nBBgwFoAUmHWHQDs4AaXZdRoJuZ4Tuup7Mm0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIERktiQjQ97G4KtELcaocvam54xXJ56ze/6OzjIQfmHWAiEA8MG+YxVZ\naGYrLxrUmermJbcfHNZs6s5R0FYubIzcFp4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUOD9cuiQwvxDXs5LueZQe1vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTJlZmQ5MC0xNjRhLTQyMTAtOTlmNC02ZDhmOGMxMjZhYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq0H+lhaMNP0ulscjYPvlkq86ndk/0kpmvSgBrctlgYsJr\no+VghOIWumbLEc+zkgqsA/sBHjHNKd9cJCsmSGnVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmHWHQDs4AaXZdRoJuZ4Tuup7\nMm0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKE60xI03I+8uQq+ZQpwNBtkeG9okoRQ9eUBTBlOTtzwCICt5bl0VsXJ2\nmMcuwYsIi6NWdwVcOOeW/j07rys94uSp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAVARM+BtNBffUwdRwwZIH6rmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdmZjZlMzMtY2MwMy00ZDMxLTlkODgtM2IyNGFkYThiY2JhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTA1NjgxMWQtNWExMC00NDJiLWIxYzAtNThkZjE3NDZk\nZjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfYENNUoNhjjLC5bLqqt+Uuzn\nRPGYP6IIvrvwzuGFT33EzrHz6O6OaXBuGlFSVMf1L88Je2fOVhrFH7c7f43G9aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNAjq/UDGY9WwPp0hGk23j6dTGeswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgI9Qlxb3VixHpHUPf\ni2RTJIiTVlLJT2xvGnMxai5hIisCIQD9w07ge+24KW7G2J28v1GoQ03J8T35IzkL\nDg8Q0jVx6w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4691", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4691` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAYd0A6D+c/qB0e4Fk2vvsO3CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlNTFiNTNhLTJjZTEtNDk3ZC1hZDg1LWQ4ZGI3NGI0ODI2MjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZjYjk0NWItZjA1\nZS00ZWZhLWIyOGUtYTYwYWUzYmUzMGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB4kdV3RmwtPLRuwFFcFTy8hhSm0XWB5nV/pG7IEnPvZJAUWBObDR4EBHIBxh\nxDgiwGo8OWqJfCogOgjWEB63v6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULctj5WFY8v7CgMqimoVZc6XVv5swHwYDVR0j\nBBgwFoAUu7+H4DAfthrAhwJaQ/9aRBxmW00wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDKeJq+A3b/xUlHd6dK6PLH+u8FFTBuDtZlFnZbl\n7HuJAiEAgUwVSEp6C/i4CRrlcvkXbMpT9mID/NlX8Nr9fMEy0ok=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbrFx+ekQNRud/BNy0Eu1xi+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTUxYjUzYS0yY2UxLTQ5N2QtYWQ4NS1kOGRiNzRiNDgyNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQn7XKCnb4gkpj59u+Kjlp+03zAqtPX9McmjJleC00b8mti\nmcxWExW4dgcG1o285n8+mjIEJazHQgsovDdTel/Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu7+H4DAfthrAhwJaQ/9aRBxm\nW00wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANijpqpgt5phdNyUMINek85ua0UZet+iX7LpNVBFAD5pAiBH+z2C4OeU\njYGomgO8gzakPCUisTiIfoKKmfHI7lwFjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQYbUrAcOQbvHvyGp1fx7BThMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZjYjk0NWItZjA1ZS00ZWZhLWIyOGUtYTYwYWUzYmUzMGVkMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTNjOTkxY2EtMmNjYS00ZjNhLTg0NjAtZTA3YTgxODI5\nMWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeIpnMxbCoL8AEtVwTgqVtn2C\ns6CglKjh7LK9SW1fvVnV13TvaQD5ggI8W02grTlkIGDc8dObKvWqGJDJ9wrpNKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULctj5WFY8v7CgMqimoVZc6XVv5swGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAK5FxkQBwcXyZR0p\n4pJIwgVok3btWanqLLals3q71eaLAiAVXrSpZCDKSVXK7BmTnrAC9jlbFqHGigB1\nPEiYAIlcug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4692", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4692` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAahIv59q+WPoljICYDV+Q621MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxOGFjYWE0LWZlMGItNGFlYy1hZTg1LTg0ZjExMDk2ZDNmNzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlmZjIzZGQtZWQ2\nOS00YzZhLTlmYzUtMjhmNTcwZDQ3YTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjQxDWXqNKzkCZz9QilAf6TMz2Bdp0jzOyBmnE5olaWBR89wJmUzXqM02IvAO\n4vvGLSWkpr7MzBua9uKowoDrNqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+WNpUsaCPEJgjmO7GrA8yW7ahowHwYDVR0j\nBBgwFoAU/QPbRgU53Y1MiJhblIxRAiQHgmIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIH26vbWjs5b31mVBeAnV7lYiVjG0JLuBw18IL2uW\nPS2FAiBPXFT9kYUNLaxC+YbvetHb4Lg7lNuxrOTZPhtwIe9/kw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATTHGl0aOgIA8PNe9rZiqV5wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMThhY2FhNC1mZTBiLTRhZWMtYWU4NS04NGYxMTA5NmQzZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+FrQHl/9kYksusSyne322KSjJa1cAdIHOgKLFgspyIF7e\njTf05hWMdyvq+tQHwb+Y+dm+oVktCsYc0uHOrPTxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/QPbRgU53Y1MiJhblIxRAiQH\ngmIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgITzad3UYC7fu2gPlNQmYKU+43l9GSVAVfJqE7N7XJXYCIQCshbYDmOQH\nRTbLeDhJkpFk64UTyczLLyJfIg1L+R25ZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISATKKJgwOAHQk+THf2yELWh9zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlmZjIzZGQtZWQ2OS00YzZhLTlmYzUtMjhmNTcwZDQ3YTMyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjJmMjFlOTQtZTg0Yi00YzMwLTg3MmItYWNlYWEyN2Vk\nNjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhDjb9bqSYs39F0kAofmHlkBY\nXFK19gJ/5axcWiCZYDW6x2uAMkJzBJSA90U+XcTm2jByNDJoNaPCexLcz5YNRKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUu+WNpUsaCPEJgjmO7GrA8yW7ahowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgcpe9+qvPNViTUmtj\nzYjLkxH8B8a1MQ+sNXFvgejyT2ECIDBRUOLjs+p4/rnjQ8ySsVSpIDehmxRrfYzp\nCTQ9c3JC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4693", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4693` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAYgAToJF8A4lkZpaQd3uZ7X3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNjBkY2RjLThmMTQtNGYwNS05NTk0LWZmN2IyZGMyOTNhMjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRkZmIwOGUtMjdj\nMC00YzBlLWI4N2YtODYwZDRmNDdkMzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgwBHGogNBj28Nv7/5TD5zfK7xZr5TZAbEvuKeCy3u0QWokvF9CMVSpNprD1h\n6zwzc4NXRQKeyuyukpOcYtTbXaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiaNBwWM0DtEjNsTkQOP1Uci+Dn0wHwYDVR0j\nBBgwFoAUG+U6r0MbZO7ZslQwF2PsdT2XqswwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQD9pVLqfqGH8LMfHRnnhS99FspRM2KErwCK0b35ZNVktAIh\nALZcdM4dxs7rZhWAxKsQbDlNILVY/NhYOVA9s0H+URM7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYA6I9DmKPY1hG4OQK7bx2qtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTYwZGNkYy04ZjE0LTRmMDUtOTU5NC1mZjdiMmRjMjkzYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2Pzhkk9Urm2MxFlf0Yy2Z81c9daOnLyAM/NTLzmXnOK7x\n4QyKaTzB53f9szAaIwH+vG7spq7abEtYd+Az32ZCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG+U6r0MbZO7ZslQwF2PsdT2X\nqswwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKi7t1/MHt0zXXNvuALITGiU5Uj7n5rNrmXXJjgYPt2+AiBE7jl/+GRB\n4gtFvO8S3CevH7FhJgazFApXnF9iTYwIOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAX0HzQTCoyYeIhYxy7oSsC0+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRkZmIwOGUtMjdjMC00YzBlLWI4N2YtODYwZDRmNDdkMzU2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjI2MTExZGYtYjQzNS00YzdkLTk5ZTAtODk4ODg4MDM1\nNWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEveHB+tOvIFc23Wi+0JAZtQZ7\nsCmph7iJmC2K5YE45T3FRF03LSK8laRceqR4BRlsRoNrtXsLsJ2iqg7O5u8YqaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiaNBwWM0DtEjNsTkQOP1Uci+Dn0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgd/q79V4vk4wmMsns\nNiWgbnnp+Q4tUkdbfmuT/9EVcBECIEeebwnWoimMX29oYkNFDfJAqyu+VdfpjaG/\ny8avaJ26\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4694", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4694` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZILXLXzEi7TGrVDO5MHRcCdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5NjgxNzljLTg0YzgtNGE1My1iNjc3LTUyOGY5YTBhOGEzMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTYyNmY4ODMtYmFl\nNy00YzVhLWEwYzctNjRhMTY3OWZjYzllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElxqYuCmlpLitx9G48GGmEsab6JItTutXSmD3i2cHAsA1AVnhsrixG4IotVhq\nOmsIW36RMRuHXOdFMIGCIoTG6aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn82LezprQWmQYwjCelklEQvsCBwwHwYDVR0j\nBBgwFoAUN4QlG/SD+C/dJhaJi0o8eJkYuRgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCONb+3nw0qWyHYjthb+x+HNGDPY5SV\nUSsy5Uzs3SsdggIgEER5Dk+IvdVYb3VejiK2RXXzn2qVgsxjQsk5oySZ3Y0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR2dnclpqn9ZkTN+u4RVOSpoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTY4MTc5Yy04NGM4LTRhNTMtYjY3Ny01MjhmOWEwYThhMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBLEXY/ZQNGPTMwQ3s0hM3TCMokTrFNE/6xXo+5mJorBmJ\nnZakyZXeSZouThoBBaM3zT74VigwJ07YfPraX3Hbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN4QlG/SD+C/dJhaJi0o8eJkY\nuRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKFr2j53Go6hpVTrPm4o0c8WdqYCIGekulv5csDFf9JgAiEA4Mybkn8B\n1NLtQhuBtUpAMO9FrU0SIvEEbUF42Vqo4JA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAb630fwHXvPzghDS3guf3qMPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTYyNmY4ODMtYmFlNy00YzVhLWEwYzctNjRhMTY3OWZjYzllMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjhkY2M4MzMtNDA3OC00MzRjLTgxMjEtMGQyOThjMWVl\nZTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECafT7iQG5+1oki1TtJix3Lrz\ndO2MUDMhBoIi5+a00QM76laGkMzryK9qDrjqyUpphXYDFfxt5LwGuYDrsGsn6aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn82LezprQWmQYwjCelklEQvsCBwwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgXlUeer0pSIPOQpIB\nshS95fYf5Q5j0GK+PyTcw8MED3ACIFQlskqoS2Yrs8Qbkes0VTWDl8hKkEJrX5la\nURe+Vrc3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4695", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4695` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAZY3PgSrQ/GjThjpd7WLjv94MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlMzFmZTFiLWQyZGQtNDBlOC1hOTY1LTc2NTg3NGNjODZmZTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBiMTkwZjItN2E1\nYy00ZmUxLTk3ZjgtMDllNmFiZmNkY2NjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr4xE5nEjEb5rbVRoOqMRRagKsLg0pRzCKsrFSqk+nsGhB5W8922HhsVVcICl\n+3UCh14QmYHqfhVszZlndwKm7KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEBzdO0aiXTF6BJWLu4M4yrrb0LYwHwYDVR0j\nBBgwFoAUTd+g4UhaVt4dN6eXdnHxDlR5pqswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCWyMb3iZ7dvTHvBSBeR3Y37jjZyTGR\nor83SVJ0gKyOXQIhALZP/+gbYAK935ImTiN1cZIVA2nHx/qEwYZNbraazUm1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd7xlzmgLHoLSuOSd6Uj/fSQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTMxZmUxYi1kMmRkLTQwZTgtYTk2NS03NjU4NzRjYzg2ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbXUall4YcedKCVcTKwwkVusFuQYpZOHkllb1fwVhV4X14\nvKM4wtHPhdj/c39Sn+69Ie/9r/LHUb2Sjflemabjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTd+g4UhaVt4dN6eXdnHxDlR5\npqswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYb8H1vf3Xe9y8OkhK1Jp42uZr2GSw8necQTRIdkwB1oCIF2RR+0ac1ub\nTOI+sc9ftH9qdgZm+iJYZrv8YOmXoYKI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISASpIUk2lTFcjl+JkW0jz5waYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBiMTkwZjItN2E1Yy00ZmUxLTk3ZjgtMDllNmFiZmNkY2NjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTA4NGM3ZjQtYzA4ZS00ZjY4LTkxMTQtMmI3OWUwMWFl\nZTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8HNM5fS77tqdwJ4+4zjtBGDn\nw2bNUBM2+Sua4BTAE04MXxS/uXIKlssa8PAbB4SCf0fUj2lE3CqLbDzduiVAeqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEBzdO0aiXTF6BJWLu4M4yrrb0LYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgUuVcg9hLM8AvRP2P\npE3dAaOwX5L6/oP8BGFoWDBE7aACIHtuNih0bsbuqaohA+nUgXQgHpwWlD/2D+H/\nH238D2od\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4696", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4696` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARunPqVtTnxA2WWo0OVoPxMNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhNGE1OGJiLTEyZWMtNGQyNi05Zjk2LTk5OTViM2Y3YzhiYzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzMzMGFlNGEtNzUx\nZC00ZGIzLWEwZTYtNjYxNmM1OTA1ZjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6X9AQPduq0cfQGLgBgT94CHaWu9buyrm+q7ah2IXZLAtJS0siUwMfxdQkUcW\n5lc66pVErDn2coqdb9JnOaiVKaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJkpgivyzjQBzltCs7Lr94WY2a8wHwYDVR0j\nBBgwFoAUJQiwnxPr4wbWkAoWoIsjMUxdizUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDzhpy+8SzUV\n9fGuiXH0VEVUxEL7Hw8Mbc4jFVl4V1OGAiEAnalHnBpvyWN19ULgJgErMGfgFU0v\nif43xzaqeNKri04=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS3wofXaVRVNxHYkpSkxBAUYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTRhNThiYi0xMmVjLTRkMjYtOWY5Ni05OTk1YjNmN2M4YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2k2YBwqUYMicc40atd48bQqnO3q4srKfTnLRSDFiQ5x2l\nmtjtFOmFOPsjc3OFLpC3NivzQSDTala/H9rLm1oJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJQiwnxPr4wbWkAoWoIsjMUxd\nizUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP63sQddcsN6WHzWCoG7AXuPknhNojYorGfs+EGcGjLpAiAewROK3Vdl\n3HRrCd17hsfBNrqB95jChvzjHpEQNdoszg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZl6odlH3liePTRN5lJ0uvQnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzMzMGFlNGEtNzUxZC00ZGIzLWEwZTYtNjYxNmM1OTA1ZjA0MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTY0YjRmZjAtYjU4My00MmEyLTkxMDItZWM1NzFiZDQ1\nZTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIKdrTqzu4/WBFS0l9Vb04cMr\nffDPC5whe3Px8fp/VEmusSW7WOM6ll7J5G98FHTYnjw6Sv2qsdkPhrNAi4Fas6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnJkpgivyzjQBzltCs7Lr94WY2a8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIQbwjSWtpJ9Vqmp\n30x630IYPy+5fM6UiXnCGir6rWzqAiEAh7SB5EqgiHpBoVVrGk0cKxYDhORybRrd\nHyJpfPn+cYM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4697", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4697` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZQt7EfMsv104e7Yi91mf/O9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZWJlOWI5LWIzMjYtNDg4Yi05NDQxLTFhN2E1ZjI0YTIyODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI3ZjQ4ZTUtNThm\nYi00NjQ3LTg1ZmUtMTFmOWY0M2VmMTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqHQ4RxTPKATGFwGmJlTTEh6KeweZOt6Ay+mjzpwWjzsoS9mXDR80VW0WrwRP\nbe9MqVSPdZ9CMN3yLJ4IW32Y/qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcXv4muPTK0ALwzoZRpAYuF02Oa8wHwYDVR0j\nBBgwFoAUdKDtOrZmEzMukpOoVDklYuBbRtQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJdBav0rRKiOx3R/rX3WLV/zRmIJhwoFHQN2Gdn6gYARAiAdXeVSMMtP\nTNhVuR51Ybvq+GHySS5Dk+usui05xDBx9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQR6ga1vn8okMnAJ+q4Z2U7OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWViZTliOS1iMzI2LTQ4OGItOTQ0MS0xYTdhNWYyNGEyMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNH3NCtB46Sc2VwGscUE4YK4YL2VMGH6J44gq+f3CYEaJx\nIqa4R9694m+ZnOvwAAqcJ2M9r7v5D6XnJJZeyx7Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdKDtOrZmEzMukpOoVDklYuBb\nRtQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPa6E0M0FaAdkWODeajSokmKiQSoZE+m4uEyTT0w/UOAAiEA8njvjaVQ\n+X1qyJzCZIf4O7VurXE6PGdai+5WGVFcsFc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAaN0SgQ3yFqstZJ/yUxU0W2KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI3ZjQ4ZTUtNThmYi00NjQ3LTg1ZmUtMTFmOWY0M2VmMTc5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWNmNzhjNzAtMDQzNi00NGQ1LTkyYzgtOTI3ODE4ZjMz\nMjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYnwGtDy4vkGrfxnXKkveG5+6\nzsF8rZUub5KYPPGd6m7xJSP6LbDdnW79wkT6qJWaCTe+ZWpOuHyLhFXqIUOoNaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcXv4muPTK0ALwzoZRpAYuF02Oa8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPvXSd4PbggOl4Ji\nycjE+leVO0MdStsQOypmLvArNCZQAiApYwBR6VeScHrtf5CAhASc7pExzlQT6jY/\nuT4kLDjCkw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4698", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4698` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAa+5ve/Zkp4TEn0stEF4o5zpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiNzk1YTAxLTNlN2ItNDM5ZC05ODAxLWIwY2EwZTg1OGNmNDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ4ZTk1MjEtYjg4\nMC00N2FlLWI4ZmEtOTg3NDkxZDg2ODFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd1E67jZ+d8DPZitaskWtmO4Q3RIJPff4s6sPMJHQPbq89OsxQ4Z3p6vQ0cb2\nGn4d1QqfJyj1Yicb/Ct5ioILbKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIpcUrdKDBDq6SIgorH9tJHI00G8wHwYDVR0j\nBBgwFoAUVlUnuS22ep3TYEEc7/hQmejcaPowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKGEp+LrywGugbppzZ7JA+ExdQdQSJ+hq3ycArCH+QX3AiAMOnKkEL9R\nY0yDdU22MJhIGQY/cCcf0a+34W0Plcw87Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARpBhYs5Cw3PQV1ECNexwP4EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjc5NWEwMS0zZTdiLTQzOWQtOTgwMS1iMGNhMGU4NThjZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATahreFtDfdJvfaAKKm8OIxXi2am2U+W5wQjokhbg5ep5Ih\nFfyi6jam721XHAvxzMXZkZI3N5c/jK2VFSGl0zpEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVlUnuS22ep3TYEEc7/hQmejc\naPowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWi4iJ7ZmkM+xHjY1So/Njh05JY1mvEDs4VjIJ8TZvkECIQChWjWXiB04\nGnbRBHCGn2jq1ug5ZZZmcZTh2gKeRxX8YA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAdBpp+H3+K+AdsTzSUAGPW0wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ4ZTk1MjEtYjg4MC00N2FlLWI4ZmEtOTg3NDkxZDg2ODFlMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODJmNTg2NTAtMjI1ZS00NWYwLWIzN2ItMGY0YjZmM2Qz\nODBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAKviDK8cCuti3/XDNPQBlO3G\nRsFyK5AP3DuLt2y0dV6zgODltOg6SBYERN59QdW+57oL7HrSDrh2nzBpKmqshqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIpcUrdKDBDq6SIgorH9tJHI00G8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAM+Qtm4yqEk8oers\nPwDS1yYYQr31aKNgIJ4MTy49OfBCAiAYzLK0ytyATQ1zSFqzM/o19fqGDncrHrpV\n2Ln3KbCgWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4699", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4699` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAXu/GtS40zyVxFkON+AQ8+8RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzMjMwMzUwLWI1OTgtNDFmMy1hMjkwLWI2ZDUwNTJhMDA1NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU2MzI1ZDMtYmU3\nMC00MDYyLWI1ZmMtZGUyYzIxOWMzODA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc/N6VmZHMVYgYf+7/7oSVg0JoId8pcy1/sKGYrXJynj68PIjCGqRPmmkuAMa\nk+8EY06yU0fSBtkdpdhhCTdv46OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZoUckFaupUDf2CZpdybxj1N6BGUwHwYDVR0j\nBBgwFoAUBDIrm64oAZG/NuOgKqZTiQ5hpdowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCYlAMKc+E3lMlcKQnhu3pzhL+4hfVrigWFe+OzFKU1cwIhAJ5JkEfu\nkbOahbyM+cMqMENqk/75ngm/IDHlwG+ZJ9hE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXnRzrVJaQiZxcIeIe/hyjh3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzIzMDM1MC1iNTk4LTQxZjMtYTI5MC1iNmQ1MDUyYTAwNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKi4zy4CtluvzZEZd7sW9KuxQQX+Ss9O63C+ZkHAXlknS/\nTqSgsIYwRsmFN9/Jc8zeUOIaElh7qKu8hVDdz0k4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBDIrm64oAZG/NuOgKqZTiQ5h\npdowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbu30gB1ZENaXuOR48dZJ8O612OQBM0DlUoXtEXHHw1YCIQCMRr2ZxaCI\nd+gb1lh1Pp391GIdWO5fHpTyXydvcAW2jg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAecJHQ/N0luwr0DmemD56TM6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU2MzI1ZDMtYmU3MC00MDYyLWI1ZmMtZGUyYzIxOWMzODA4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQwOWYwMjYtNzE1Mi00YzllLTk0M2QtMWI3NGQ4OGE3\nNGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaMxgg90p5ko9QFWlvIjocrKN\njUJOXWMU/dcP6/60dudM1W2S8WN1PujUzYSz4/h6+tnEoH0cKrFlW06CuYObfaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZoUckFaupUDf2CZpdybxj1N6BGUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgSL4FHev5CmcKsaPG\ntg+zzE3frW/FAwSpFdHktWfUaJkCIQCbPaXhsCwhhXU14ZCSPiGzSZlnhtrJxLsO\nOgvY1qKJLQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4700", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4700` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAZv9w4iFuGssou2tI4chfMVNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExYmU3Mjg4LTcyODUtNDZkOS04NWZhLWIzYjkxZThlYWRiZDAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUyMTEyN2UtY2Mw\nNS00NDZmLTgzN2QtNjg3NDQzODMwZjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4qdE4+kk0Urh9LN75gZQkNqHtT8WrbCgU9bF7Vt8nUW9lPwTE2j6SviB3qKC\nERE82Tx76AzyFEXH43IQQcAnIKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ648kiBnZZa7LVXRCis2nRtkRKAwHwYDVR0j\nBBgwFoAU1GDL02zgr88//n5lsvb1KoWT4IYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBoXdYZiGHJfXbIjs9MQAAj32EcPZ9Os7ubsWYPs\nUMYOAiBuoHwQgqdHiRPTsv6qhj3tS8e+JwQUoJVg/SWI9pHgcA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfmx1bbTRO+/VkDboXSbYLiHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMWJlNzI4OC03Mjg1LTQ2ZDktODVmYS1iM2I5MWU4ZWFkYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYkn3Fc1T1pD+rn6EuyMnBDBl2e333KwH7/GqbLa4H6MmE\nLr05y0SMRA0Ihuktlea784zm56ISq2hm7Yv3Qtkeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1GDL02zgr88//n5lsvb1KoWT\n4IYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYZDUGpDxVa8jbBsXDWjlvBkMZp2rdWpPag+I97I/lYsCIADV2JeArOD8\nztXkDJs9luAXiTkLWgczZjRfbScV22+o\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISARn+eXxsvu/J1OrvHuIXadz7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUyMTEyN2UtY2MwNS00NDZmLTgzN2QtNjg3NDQzODMwZjIwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjA5ZGQwNjYtNmMyYS00NzQyLTgzZWMtYTY2NzEzNWJi\nOTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBQyGaSon4L4L3rRbOE9gj141\nJqa7DB8rDQ41nieGsgjdd81vKRjkoWB5pwWAfX13JC0bo+yRrG9Qqby6lFwfQ6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZ648kiBnZZa7LVXRCis2nRtkRKAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKUEC4XzYa2wWNvI\n5zeu9sSdc0owy3FQEqdCqwvpZiuTAiEA6ZT+grSq77oaZERLp925jQ0yAoqbvR3G\n0QH1Lqbife0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4701", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4701` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAf/6RdXw6HAOAzU7ziJoX9kEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkNmRjOTYwLTAzNGEtNGQxNi1iNjRmLTY5NjQyMjY2M2E4YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGMwM2RlNWMtZjE0\nYS00NDgyLWFiYTMtNjdlZGVjNjYwYzcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK0gWPrKErqqFkZRNjoH/qMxtkmxf5EQ0TKy/k0NMyPZiBmhHPkHh8Dpq2T9T\nTKxp6srPQ25Dmw/FmuM5RWfLs6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn1MUrJyX/XIl+jG64ERcWAQ9w1IwHwYDVR0j\nBBgwFoAUfTZXHk1yEIej9zQLoySg6mCY8KcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBmOIeyE7pMAMrWBQmDgkRYYwzt0YJ41BQAoQRyb\nYLhyAiBR8ovm+tF2MYDcJKag3gjfkwylyILl+Jut6HznvbyXuA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATEssNbE6WpOlDs9AM5cZeqRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDZkYzk2MC0wMzRhLTRkMTYtYjY0Zi02OTY0MjI2NjNhOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASosv/pM9qf8r4RhTHaj/MIOcwNWTzmuk6Bg5gVeEDXJ5k+\nI2e7ePnxkGpr+igmECkSwvsLjZOP9HkANVXzTwh+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfTZXHk1yEIej9zQLoySg6mCY\n8KcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaQwJNj8RtzCiBB0vIt+x5a0tXIi7miiut6ANWOF9B0MCIHEodq8Oum/X\nfoir62jhn+rMSKhtGpc176/+QNME7EfZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZ3Mdoz5zdgDCNSnPh1afipLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGMwM2RlNWMtZjE0YS00NDgyLWFiYTMtNjdlZGVjNjYwYzcwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2M1M2FiYzAtYzU4Yy00YTI5LTk0YzMtOGYwMWIwMjcy\nYjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdWMmVdzRkPdmEr+WD/PoEKL/\nYxrLc6/XY70wZtXQEnpp9K8wv75xD1GOfLlZ+Euvz672yQ328JQTs9WcjT+GIaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn1MUrJyX/XIl+jG64ERcWAQ9w1IwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIyAuGuS+c31vo3S\n/i7j4e4oxjM7dNiPJRuDuB0LWiFvAiEA5S2bkYJxWsHHg+qSTPgiBn1t7H+ByzGM\nNGK9Qvd4c4w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4702", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4702` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAY6gwkB52no8rY0ZqhTtgY8WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NTg3MDk3LWQ5YmQtNDk1ZC05YWYyLWNkMTQ1MmNlZmIxNTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRhYmNhODUtNTY1\nYi00M2RmLWEwNjEtZWU0MThiM2VmZjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZhHxYQwrL+C89CxIA3VuUyQd4PQXt3X8Drdkl99fIL216DK5UinnD1pZDw6d\n9uvDwlOnY41ks31lb7pnLmTwfaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBkxnBvI1EGyz5llHCJacdzEjtWUwHwYDVR0j\nBBgwFoAUwgggpc3vFegxLZl4mcLP998V3KQwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCqKSyddMMVgaIegG36pYATnCe/Bor69pI97L5Tg+OMswIh\nAPOQn5hqoySdk0qyO5SEY5qpww9Qwz30AwCTxHC3V04i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWSIFVMW9+jy2RSiWlAObOgQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTU4NzA5Ny1kOWJkLTQ5NWQtOWFmMi1jZDE0NTJjZWZiMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjNQiAIsB8mVUSG8xw0fetXUaXhMx2nxfJNfq8SZTr7uYi\ntSFvWxjUCnNAB3upCqbzbNmLo2TfLLihJILzBoPro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwgggpc3vFegxLZl4mcLP998V\n3KQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf5ZjO6fj0BeCTB5DOcrxnjse0M7rJdWRRAPqBYKFh2oCIFhFpOYN+wdZ\nZlMnaZ9FtF7+khmpezsfbARWkIkWk5pg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASv3Kumpe6SujJd6QaqXGYoIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRhYmNhODUtNTY1Yi00M2RmLWEwNjEtZWU0MThiM2VmZjc2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Y3ODEyZTktOTE3MC00OGQwLWE5ZDMtZGZiNjJiMDdh\nYjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErb7ddtvSjtish2GCS82Ne6q2\nJdFAgsNNaDDrIADVJ90xTwRCJUQvQvyDwRlrIwZZlIefST9DOYlwquZB6yO+0aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBkxnBvI1EGyz5llHCJacdzEjtWUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJwAl3Y67jGS6aPv\nloPztaNpZyi42IW/0PkbWIBjOUUxAiAfTDrrVkGohNTsuWdYKi9k1QykGmOItCHW\nIbZ5pDBc2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4703", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4703` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAWgqeEAOxdv24UE/jVULkgsPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZDI1ZWUyLTJmMWItNDhhNS05ZDgzLWJkOWYxMGFjYWYzZjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q4Mjc4OTAtOTEy\nYy00NTBlLTkwZTUtYjM4MGE3OTcxZmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm+3RBCAdFXst6+VdS/gU+AVGmE6BRYKViA4U5tpgXo3omnplDjHLmKKKV68z\nROBrJtle/SSg4FYRtwFJkHq+8aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEMpFwFxFQzjyFx4j+UvToI+9kQwHwYDVR0j\nBBgwFoAU2HSeAR4XBAVVn3aRCrpMaVkdvR4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCJvv1mwfxEVgyxN4fNPSQsRhbENgHm\nUtiC8n0og8vJmAIhAJVopQkfhJ3BopsUM+SjxCnvKoUmYTiCp1NmSTd6j5Io\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcsCUpCfSfZfmgrpoqeZeqXpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmQyNWVlMi0yZjFiLTQ4YTUtOWQ4My1iZDlmMTBhY2FmM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARClmC8RedoLn0RrAG/PYSbRNlNRLIzxobrkor7U14oUuTO\nPIJ6FiMY0On9QJInLZOwFvvQAutcuabWnJpC3vVao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2HSeAR4XBAVVn3aRCrpMaVkd\nvR4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI2yQyYVXcoGsCNwoCXj63lqFVS0SCg8nMisHIdnsi3UAiBhCjsuFLbB\ngwTqfS/KU7fR1WmNKbvMvtSTo6PftkTocw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAe6S+Qi5F4jbkorJovRhxtaEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q4Mjc4OTAtOTEyYy00NTBlLTkwZTUtYjM4MGE3OTcxZmQwMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWUwOGQ0ZDYtN2Y0Ni00NDRiLTg0ZDEtYmE3N2I3MmEw\nOTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwq/EDrjDg+22UAE+AwrjZ2XP\n9unJdjelBbTwY15PE1IUAk6OaDNJgd7VgtRf+SoRYf0fwFJAE5fC+OxK2lhu46Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfEMpFwFxFQzjyFx4j+UvToI+9kQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANoYWpn7HUl2NXL/\nuyfu1OFQ470MoIgOl+ytVZOhaVp0AiEAgiOCrq3zQFE5t2v14CwLaHfL+IVpljWY\nSb8+6PMxejQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4704", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4704` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISASoV58cXXiWZ1GJi68ktzNAgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5YzhjNWM3LTFiNTYtNDgzOS05Mjk4LTY1MzFmMTM5N2I3YTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdlODZhYjctMzM0\nYS00NzE2LTkzZjMtNDdhNjVmMWMwMDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE80MGWlkebd3yE8OOp/PAN6jFi8R1UobzN5xL3l0yeuPUSBHj5ClfBFLemo8u\n2aqBABWzF+6WxcZ1L0LXZ/Y2lqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJaiQP0H9W5xrssyilZ9znB2VKJswHwYDVR0j\nBBgwFoAUuYSz8CuVdLeXtI5l0dsFRfFbelYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIEt1L9U6lhJXj9uZiVq5PlzFAi4/pMaG\nZecIDZfF+l6FAiBLUhhkfI8qgvczO/PUUCvcrkjPxvaCbrEvThmwZ4854g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXQDoINmNAG7P3040+gK9qwQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWM4YzVjNy0xYjU2LTQ4MzktOTI5OC02NTMxZjEzOTdiN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCSiJkDenKlFL+9dkfIDjxjjBt689VyfuyACWzEEQi/nf/\nJRDs2HAtSaLZmAPZB7dzkxnVWXgut+bzwCMsBR1zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuYSz8CuVdLeXtI5l0dsFRfFb\nelYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN+BqKsHYOkF4SSrLWxuVa82/llv1iwcGrxCl0MHZYZzAiEAuJicK+Wu\nLzpib/q5i6PvEvbMzfh+6Vay8nO1raWkM1c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQSsCBhoN3EXC+EdIvmrJng2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdlODZhYjctMzM0YS00NzE2LTkzZjMtNDdhNjVmMWMwMDBhMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTVkYjE4NmEtNWI1ZS00OWM0LWEzZGItNWU5MzRjNzdi\nYWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfY9qOk4zXRdSxltUOj6J0BEd\nUu7tbObNNeGwJuhJtfmlWYuzsI8/yrgsPCe2DwVc2cH3AT0cB0EzuVuWMuu9o6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJaiQP0H9W5xrssyilZ9znB2VKJswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALPJ8aQsQVu+fJ6v\nPcC1OKEtLwiKzjP5H5udtSAivR4nAiAsRLgtzeQL4Emr8J+RjTdfHLe00vD85NHb\nCOSJzH2U1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4705", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4705` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAco/kRooSPR3bFUK3VfadOtSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiY2M2NzVhLWM1NjAtNDEyYi05YjNmLTA3Yjc4ZDUyOTQ2NjAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTM2OWI2YjUtZWQw\nYS00OGE4LTk5MDMtNjI5ZDI2YjNkYzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOC3nd6AIdpk1ZerR64CC5Dman3/0dzpingmCbg91tNR/egIoVzBSOsTW4rQ/\nTm4RLctFUcupXnKN2fJHjOZDNKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDxKVltwWOQznN4r5X+yewup3oPFMB8GA1UdIwQY\nMBaAFAV1d0cCg4zEOT/aJR2kmH3J3CAYMAoGCCqGSM49BAMCA0gAMEUCIEZB5Yum\nxf7PivGJYNq8xwmxSAWPBXWp/jrIWNusF63PAiEA6ngNwhuMLHFhhmUIi6owR0U5\nlEKkmRzFobvBidsqHUY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb6dSPYExCRt0ab86ciN0OWTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmNjNjc1YS1jNTYwLTQxMmItOWIzZi0wN2I3OGQ1Mjk0NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATa3ocI54LFohcSXawSmX8fHddmQtteQoizOBjPGwYm7m1b\nkkk5+Bp43KEifZqPgYevJYibh0ywQWxPc/5IQSVFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBXV3RwKDjMQ5P9olHaSYfcnc\nIBgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOwRXLa4DcDblEgIZWqvi9WA+jjMZi8fk5is6+vZQdDlAiBY424uluFD\nmn4W4JRtBBa3tMd4alG5F8dvCaru167Npw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATspDjzeWeSepMFtmB0CE+4GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTM2OWI2YjUtZWQwYS00OGE4LTk5MDMtNjI5ZDI2YjNkYzQ4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWI2NDlmMWQtNTYyOS00MjI1LWJmNjYtYzQ3ZjE0ZGE1\nNWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKkZNI3Ll7czHTlOEsi87h5DR\nOEj4vpb5F+KhDj1J3UCq5THP0iAVmo1t0IFOj/TkYcIT10BP85EZnjpkj+bLiKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPEpWW3BY5DOc3ivlf7J7C6neg8UwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMrYlsOs\n5XVHhYXqu5dZ7Dtwt22agw6Mb+rt0uAfa+skAiB8ZDjo6H5mGy+yzwHqVm4B3X/s\nmj2Dx+2cAvU+Osjh5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4706", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4706` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAbgkaqoo2C/Ny67D32nt2e1XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNzQxZjFiLWZiY2UtNGQ1NS05MWI1LWI0N2ViMDEzYTgwYTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdmNDY5NWUtMmNh\nZC00NTMwLThkYzgtYjMxYjBiY2U2MGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ0IrCmQ5+4wtcKDQBxcL/pcr5nE87uC96UAVwKPeHf+xs2R7wKiWJEvJy1Mj\nYBWnsDR5CDYoEtAKGedJ3wotYaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBqVf5s/GcOi4faC40kewqIop3dWMB8GA1UdIwQY\nMBaAFOl2uI6ieX1niI5sRr6NXfUbEs+nMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAZrEf8BXGLHlKXm259kTmfXotOvDwNgus7\nsumLGP81ugIgcYG1qF3vURPac4bH3rF+meAyNov9iDBhMsfs6/jecgI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdsYOFMYjJnUT3WVGZaRpEiEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjc0MWYxYi1mYmNlLTRkNTUtOTFiNS1iNDdlYjAxM2E4MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2dqRDg/mcoKo5e76yyRv5lT7JWAHuQ6L65RvT02zgHJOE\nV+G0Ost/+ntJ8SgSrdy7XpiM8PylY/1zQgfmY7G4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Xa4jqJ5fWeIjmxGvo1d9RsS\nz6cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANs4DvFddQ7M46mrmWrzB7e/TZRuI8tES0LVpSHNGp2mAiEA/brRjg5u\nXhwmPxdNqsUGz0EQq7hdzUrLca29gdeG1GU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASUP1U0xSqclV3iyHCbKmGmiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdmNDY5NWUtMmNhZC00NTMwLThkYzgtYjMxYjBiY2U2MGUzMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWNjNjFlZWItZTM3MC00YmVlLTg1MjUtNGNkYmFiMmZh\nNjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWTvRnXBf4CEzFIPAxK71igqc\ndAj8vip/B/0pfVJa/vlFH1NB4sZq2rItu7uE405XlszfOxATUV79dGkiqFNqE6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGpV/mz8Zw6Lh9oLjSR7Coiind1YwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgOguT3k3U\nOOCt53GXPGOmvx3/pJat2pzlKtQj/j+IlWsCIG2X651ddTm9lCBe6eWTqUV46Ab0\nU9mJ6WzUh42ZDj/C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4707", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4707` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZK2I6sRAe46O8xSEMhihvm3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlZGZjZjU2LWU3NDEtNDlhZS04ZDYyLTg3YzY1MTY1ZTNhMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc3NTgwOWUtMDkw\nYS00YzhhLTg3NmUtZmM0ZDU2YTAzNGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3efJGakcmBqguho/b/NTuybuY9+EdpFDjbbiE2sbwjxvajBWyfWpWU0Nndct\nZuYug5wz3Nj/wRULLUHNhXWXSqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKZOP6l4I02i45hJxhEyY1ZeZqeqMB8GA1UdIwQY\nMBaAFBBE/DhLx3q2OIYLBKs+v0grKmlfMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAzkGKI2vDfVyGq6OohPet/SmkUEk5CUJ0V\n6Fnmj/4iOgIgA9/0vs6HdMTUo1/EDcikRbbGub/30j1DUGlDFjQ1OHs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdCXMt8rQTULYKsknTkR31YEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZWRmY2Y1Ni1lNzQxLTQ5YWUtOGQ2Mi04N2M2NTE2NWUzYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbYrxnGiFAYAMjeQyQTyW3HYozYgWEWxayOZMaSqFHHF3u\nzeOJReK6b/G2Le4gsv7KDR4c8UwJRavrGO3AB89Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEET8OEvHerY4hgsEqz6/SCsq\naV8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc8LK6z8r3mZ+IAXqQ3L10oA8vRDTkE0HvxC08mzL0+ECIGjiLPW+bdWg\nOTlxPFN92gdOY7VYk1vxu2GwSbjqR4Mi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQnigbIJsjLfsXCqV9pqYFvoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc3NTgwOWUtMDkwYS00YzhhLTg3NmUtZmM0ZDU2YTAzNGI2MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQwOTliMjgtMDk5NC00ZTlkLWE1NjctM2VkMGY0Yzdk\nYjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExDSXKrpbr131/t9aSPrpFMG8\nS+bkmYc8A9RYHuH5RQl+TXYw7zLqEvhsFLSYWw4EEVdMDV2XkdOkDabcQphFsKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpk4/qXgjTaLjmEnGETJjVl5mp6owHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJmtAMlx\ntDLp7/PBFg1D4ex3cNha8bmc/rZkUUjFBc+tAiAye0s6YPL3Nt2BwSUnSnaznwjN\nKOwiZv/oZLkqm4r3QA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4708", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4708` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAXoRb9NK3mIuL+7ltyB3DeE8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiYjUwNDc0LTFhZDYtNGNiNi1iZTM3LTY3OGZjNGQ1NTlmODAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBjNjQ2ZTctYTMw\nMi00MzM3LTk1MTUtMjc4OWYwYzEzYTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaySTiVPgLRhRw0ZSIwmX47ge78bM/f0Yehl3wkfMQSZR6yLiY2wENkytsrj/\nG5LtP0RfGhgl9JXwWpi47jGuwKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQFsIpyVvjtNTmSWQRuknPJeH1ntDAfBgNVHSME\nGDAWgBRMroZ8IEbsIOJsbn+x7Fkarw/KRzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICyEY5GBen4NMy9Xmv2tcuLWDKIHjIZa\nobpluHJfcXBwAiBc8Rk1ShkClgt0PC47sF92YiSgFUav6oNrNqn4b5YP/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATpURoUWUbaSxjcD7b0IYKQWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmI1MDQ3NC0xYWQ2LTRjYjYtYmUzNy02NzhmYzRkNTU5ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9vZYJR4EYFNPOUDwC63/Yq40eICwoo9DpWF8I+GpXDAoQ\nSlLiUH1urAADGIfiMIZTk7iGtVlWHPQgDsOnikXXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTK6GfCBG7CDibG5/sexZGq8P\nykcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBa9nVeFxQNb07pGgCo9ec4aVVh8Ov76xtN4N0j9QU0gCIQDO9Xijj2XJ\nB2+ErcaWzvZnHbmulgIiVIKDE087NtjS8w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAcc3U+8RUexWXuOB7NUeIjPgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBjNjQ2ZTctYTMwMi00MzM3LTk1MTUtMjc4OWYwYzEzYTE4MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTYzMzAxNGEtZjUyMy00MWQyLWE0ZGYtZGNlZTAyMjc5\nNGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+DNBtpxmeWZBXMEOpm+eRt6+\nEOFOWIPHFfuOKHNqZuBo1CJhSp+INPbqM798j1gLSrWMME2J7JSMzPVFQg+4PKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBbCKclb47TU5klkEbpJzyXh9Z7QwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgEOeP+hAU\nyBrSKnwPg7LGWmKGcSyZ8epTZsuduuC3erMCIQDqcaJhTU3GpTpeJbVeBjz6GuNe\nE1+Tfj7GHUsICoPAdA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4709", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4709` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQPlTcuk1DIYZU/YukHZ0U95MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2MzdiNzYzLTYxNGEtNDI3NS1iM2VkLWJiYTQzNjI0OTgyMzAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU5Nzk1NjMtMjcw\nZS00YzAxLWE2YWEtZDMzNDBhODE4ZDQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDpzdFxsMuFxRoQuXWlcMzZEkO/MvGUg18Ph9ZG4QUT+n14ba8MBar8FRA1Zq\nbEe7+Ugnh+yuyg1f/DXNGNcCgaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA1NMB5dAHJd1pOustTsx8LmFY7AwHwYDVR0j\nBBgwFoAUaxmpWwnI9O6rQc+lblbZsKXSfq0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBuawVRvlLpGvk1\ns6piLwo/3uJUjydePKEzldbxneINugIhAJHxVfYFffACGK5Ge8CfCxSZupx0hKtL\ngdwyzpG5vqdB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdtz/y4gVifmHwSsH01nR1qZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjM3Yjc2My02MTRhLTQyNzUtYjNlZC1iYmE0MzYyNDk4MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4vKceZyRbbz00ZbPcD3mnoO4Yu1BXQfpqzoDu7vjrMCyP\nO4t8zxmde1txeMMwWcRRavSfbiHCmfvXbR5Dtfz9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaxmpWwnI9O6rQc+lblbZsKXS\nfq0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO9F3gkafz6jX2NgHykR5LZPSGJzzEtcqwpT6ludZucaAiEA7DboonhG\nU3KccuQGVh2wPIbZo5iUKf/bPetgRc3GQZ4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQNXf3PLoiTdw5B0pJGVzzDZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU5Nzk1NjMtMjcwZS00YzAxLWE2YWEtZDMzNDBhODE4ZDQ5MB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjgxNGM3YTItY2MyMy00MzUyLThiNjYtZDY3MTk2NWY5\nMjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsk31bSNT3YzDEcHEDn8RX08k\noFaC9ZCtMCQRkz+JmX5ifFzhz7852n43Uey5f4y/VwSqwHvSIDPTz8rWeAFViKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA1NMB5dAHJd1pOustTsx8LmFY7AwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgMUfNRK6c\n6EGJSz4N271t0cHxMyTr+wicCAnPBvHNsJkCIEkeoavv47gO/V8pDiLmTzCczuG5\n0qrpFDnseagEPbeA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4710", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4710` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAY+CqbCgITxaHBQv6wc0sG0KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1ZWQ3ZTMxLTE4ZDUtNDIyOS1hMDI0LTNiYTc1MzY1YTU5OTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE3MTVlMGEtOWE5\nNC00MDY5LTkwYjEtN2FjMDM4ODMwYWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+xqJdY+BL7rLLGuJ53GvLMBA+L8w1lLeb4EPqGgEoj/jg7BHOKD4WG4fa2Yy\nq4uLqPdsYGN+NLFPJ7PtVfbmH6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWEO9afx1AJj7OiF0F6QVreqvgLIwHwYDVR0j\nBBgwFoAUptZzl/m+p2u1se/M8mPcotn2IFAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAwQKHgeLJNAQ2\ngJT4+O+dheSIssH0fb7H+PFAHFdStYoCIQCzTbDKavDPY7SaLYsXjWHt16BL/CeH\n7XyewCRMqZQn+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYQHAciDl/2wKp+yTQS7GoFGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWVkN2UzMS0xOGQ1LTQyMjktYTAyNC0zYmE3NTM2NWE1OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWv/iS8mE5lMeS9KBimm3MkMqJ/kRgyLKlHwptqSvYYMrq\n5+FnopJXgRjMJ+nbOvABDOPCK9HREe8Wxy8YQoGWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUptZzl/m+p2u1se/M8mPcotn2\nIFAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSYY1/imHGz1a0xgUsKMJs+raKe7+ws2Pv8TDGwVZC+wCIQD+eL1KcNkl\nYhAdEUAr3+mBc2ZkXtL6ob4h9itYsKOVfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAR1l1yuoAcoslTh7AV+GgjC0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE3MTVlMGEtOWE5NC00MDY5LTkwYjEtN2FjMDM4ODMwYWRjMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjIyOGI1NzUtOTU2Yi00Njk5LTk1MGYtN2YwZWY1MWRh\nMjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvwKl/qfEI8jSxSFKPmSDHg/M\nXrBPgeXziPto6E70fK5KarorTCEFiz/IWmCirvSlqt6dabUT6yP1CdrVaQiEyaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWEO9afx1AJj7OiF0F6QVreqvgLIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIKGdSRJ\nwBX9OTjYmUTccRx+1fO5l6flLtSM09OupTHWAiAEaOPsQsHIZlmLdAASAGL50p1G\n5CqBwWIxSayy9bdDSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4711", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4711` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAcGhBCXT9XfHEJ0XTQP9edmYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmM2ViZGM2LTA1ODAtNDA0Zi05ZTcyLTRjNTNiNDg3ZDIzOTAeFw0y\nNjAxMTkxNzI1NTFaFw0yNzAxMjExNzI1NTFaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM2ODE1MTQtY2E3\nMC00ZjIwLThiOWItZGE2OWU0YzUwZDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJJayVAAqCJ7Mo295uyiko60as4TBELbNVXCuWQPv2wMPN9x8AupvgJ6ueXUo\nDXwfBor62TrW20NopBls8jUjEKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiLVov45jlGaZVKQy2tTiqokG6FswHwYDVR0j\nBBgwFoAUQz1yO9uFt2vvw5IDSYArhOiQW8AwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAywJzifkQN9SbH7PcycgV\nCKsrj72LSJA2pNjijn9FbHcCIQDkbSMGgTtcdTZEM/0WS+Lx1v2DpOXy2mEQmRaf\nxRR/Zw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdp3L5F62wjO59PBfyO2VcNUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjNlYmRjNi0wNTgwLTQwNGYtOWU3Mi00YzUzYjQ4N2QyMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNKyJOhE3ZLz1Puhmlv+SImHMivhk8SCzditex6rK1tlIo\n+2qB4XfgicAceyla9/NGpDS4yLu0cxUPIRccsKdRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQz1yO9uFt2vvw5IDSYArhOiQ\nW8AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ2/g/+xtCuzLAh0XK7BnDaU73pIJ8q3JO46xEWpCcEZAiA/3k7FwTTA\n+OLHr4GI66/0Z37ZafTie+EfVQrXlEUUOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQBgXVNdAsw6D/MLnS+BJhb1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM2ODE1MTQtY2E3MC00ZjIwLThiOWItZGE2OWU0YzUwZDcyMB4XDTI2\nMDExOTE3MjU1MVoXDTI3MDEyMTE3MjU1MVowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGViM2FmYjgtNWJkZS00NWY2LTgyODItMzkzNzQ4OTAy\nODM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3Z6HScRnpeutiMNYRdeN2a4m\nMPqpQvIc45QdWtJdj33nR6KfjeN69EGyvsVIEvnKooAX0Svq8JohvYKax9U81KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiLVov45jlGaZVKQy2tTiqokG6FswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIV7jyOa\nCGJ/dahYxDO1KSKFsWXZyIFvzPSJM3nnYA0SAiEA4FUmJm1AnMVjxUm7yId399xy\nlxkZQnGn0pZG/k0+etY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:52+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4712", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4712` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAToiTcQSmEjLcJ6rgwGdiUYdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyZGY1ZjZmLTE4ZjctNDcyZC1hNzI0LWNmZTg2YTA0ODJlZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU0N2M2YmQtYTYw\nMy00OGNiLTkwNjYtNTMxMThlZWEyZjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESEVtv+pgtTad62eg3SL/GGlRfdRDo9HZc+ueFTZL39a0ucgUKVEfNNi3RSEt\nCCXs/yfbA+tvEsGS/xkXqLtG7qOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT6RJpqO6Ba2gYmntVl1SJ6jn/3AwHwYDVR0j\nBBgwFoAUS0K5kfWKLtJj6rAGd2kTh1lhMXcwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA7jo9\nt/TQHvCRqr4I/+FzQXfLSvD4MdskMThTirUPZEkCIEWjJz45gc+YfmgrOs4omT4t\nk5wbEQuiRiiHIAijsk7R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9FfqEmU4ZlL7DiiwxoFJHcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUxWhcNMjcwMTIxMTcyNTUxWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmRmNWY2Zi0xOGY3LTQ3MmQtYTcyNC1jZmU4NmEwNDgyZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVwNO9bVonNruwetLBJR7vk9aBK9208cZomVBczJ5ae8Uk\newgfA6m667PPvjW9tsIQFR1xFxrd3KKPiCU2s69No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS0K5kfWKLtJj6rAGd2kTh1lh\nMXcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeCF3O3HbKV5se2dNDhjPVsIGZ6at9vwZhOW85lnhl9cCIQCvovGB8DA0\nI0fGilxhCF06ccIpslWiHz1PhxN1Nibr/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZeBAPBJmWFQE7x/oiNvXprHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU0N2M2YmQtYTYwMy00OGNiLTkwNjYtNTMxMThlZWEyZjk2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjhlOWFiYmQtMzY1OC00ODEzLTk0NzgtNDQyMzJmODRl\nN2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/qncZDSDHbbEm0iGS5bPpxnd\nfXdMtZbzt2oqCFoLPK9xUpwBh32xZiTU1gz3t3ZDeAPSm4k/PM+riIaLcu6W+aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT6RJpqO6Ba2gYmntVl1SJ6jn/3AwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgUBpNCKtE\nRhe44lKxcDF7Psv7Fl9wBs3RIeatgHzMqRECIARqrYe6D6fpLfTy+1vBICBbMCuw\nMJtveZA+33mF9TX/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4713", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4713` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAWtEEay5g48/c4nB4WVw7NQMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3NGU5M2IxLTc1YzgtNDI3ZS1hMTk1LTEzODQ3YTczZTNiODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNjMzliNTctZTc0\nYy00NGUyLWI0YmYtODA5OGE4MGE1NzUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2ZYlbaLPcr2mrARrX83TH7TLlvDZYjFEaBEu+HCsuoX5X+/WjEpARSUZx8v0\niWYxUv/eCPy6DAb+OcAlQeDoraOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxHL6zg72dAy0CJYIJSuQkhqiXO0wHwYDVR0j\nBBgwFoAUtvqnBE/z9SV4O4wPLHSEYQNaHQwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBiv/Ui\n49mrtuuKDYRaSprZHXvfFncqr//QAO22lLJJhQIhALE1GSI0dlhJPzafyjsHOsvo\nwY7Vf7HSsI1Vf87E9s/J\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY091ZMTGQ3oyusXBi4gIe0fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzRlOTNiMS03NWM4LTQyN2UtYTE5NS0xMzg0N2E3M2UzYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoPXrrZNw96pkEKmHYBu/WLUci7qtKGGFX0RviqY6R1dNV\ncKK6CCmw/MwWW/pGOONi6TUPUyuJdrejzvyZfNPvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtvqnBE/z9SV4O4wPLHSEYQNa\nHQwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE7tQWgJ5bZNBhGm3lsYVoUBF4S7qA6miZxyUFubfffECIDhgonHeIloF\nHxCAeCGMZEp/vbjHL0qil602IzNHGcPv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWyjCF6V7TLfag8xhfGF94bQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNjMzliNTctZTc0Yy00NGUyLWI0YmYtODA5OGE4MGE1NzUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGJlNTlhYzktYmJlMi00YWQ3LTg4MDQtNDM2NDIzZTY2\nMTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA6OOTfdRMx+3miVcQOWJ+/Cj\nYlkSrPRNlISMs1ArLMwSEqsm16pfszkn9tLDurVqqjIqcaQCZ0ww/yyZQP9hgKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxHL6zg72dAy0CJYIJSuQkhqiXO0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgM/GEVKsh\nmZ17EZ1X77K6XyNIM7XS3K7s01rNhWkG2jACIQCeztSMYyY7uPfx6iWkhO34kDsf\nBXZns1SnIp6GSLKOtw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4714", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4714` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISARBf7Ccuwq7iR8/o5Or9TqlaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhNjkyZDM4LTM5MWEtNGQ5OS04ZjBlLTNkYzJiMzdiMjJhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzdmNGU1ZDgtYTE2\nNS00MDM0LWFhZmQtYjdlYjE3ZmNmMTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkxiteM56/XtUCn9ti6+jvIopzuauBrqlJ67cztpKdfAROOAlOIYMro2cTX/E\nqJTNO4aq4mM/vuyMKly7XqfRuKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGgkgsHM1T4IKiM1K1RtR0XcRMx8MB8GA1UdIwQY\nMBaAFN/jx3pr3FSOb7Dxhhk18EPVSIvpMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAgi9XfUJBb6hmWRQHilJbCkGDsUBCOWd8\n/DBQeTnXYV0CIAuwPUUn91ID5mbNHNoZf8zmUHFNgRhe+Cs8Yo40Q3DV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU6ymHzgK8WWVr0MDQAb4oTYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTY5MmQzOC0zOTFhLTRkOTktOGYwZS0zZGMyYjM3YjIyYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZbYJq97x/+hDLuXgL71qu5QSxUqtcz13OUULgD6lIw7AC\nXYOmtLaw/IRXSkUkgA10dMYmjBLQnXN6U1w3ciQno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3+PHemvcVI5vsPGGGTXwQ9VI\ni+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgONVHoaGS+M6iLP9Bu9oN5fo0Pq+cnGJ1o1uY2F4hw3YCIQC8hwpC4QWI\nVPrCObEJ81Er4OiyF9i/Wmrys/6tpwEANg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARy3sppuoMWeJIPbBjXyBG1TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzdmNGU1ZDgtYTE2NS00MDM0LWFhZmQtYjdlYjE3ZmNmMTU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzM5MzE4MzItYTFjNi00MzlkLWJmNTMtZjMyYzEyOTcy\nOGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElgqqPgF7KIgb1ymDw7Wy3ZuR\nS/C4Ga7SGxMqirGTTRCSg9WAKCGks/NLS6WDrUewetIZHZJGP6CMRwadkAailKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaCSCwczVPggqIzUrVG1HRdxEzHwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgSbt3guOQ\nxn+nA2FvnB1YMxuZW7kT6mvwPeIUNn9NJdUCIQCm20MiMBtWeawBNgBGjdonLjMB\nZux2Zz/EEyBnzmAVPg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4715", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4715` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWthtm5D9FR7Cn75Oz1+XpbIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNTdlZGIwLTlmMDYtNGQzMS05ZTJlLWYxZWU4OTQyMTZiNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFjYjQwZjktMTIz\nMS00ODAzLWExZTctMDczODE4OGM1MDhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcYgFm127ibuRW8xlHbkpKJJPnfE5uX8lGZvtMo/m1LOoKwJs+yd7tp1Mc8TD\nRj1w+Es3v4v2XK7784h6SfA8fKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqEpZvEu/ZmlirzXGotc9XLpeBSEwHwYDVR0j\nBBgwFoAUhupXe1FpJZ+kiNMv1oeulX4IQzEwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANXYIeaKUOc8\nfhRqPM2foQhZ4ozFydF64e4ODDFxEl0AAiAIAi2OlQYo8ILfQ5DRlWgfLCKcxdcr\n/phBHs7OOlstVQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATx3fDag1dixAKs7UEhUO+EtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzU3ZWRiMC05ZjA2LTRkMzEtOWUyZS1mMWVlODk0MjE2YjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5bwsQkFtqkO1akYuCqVwu4Rf+0w04VodCeXLPzWx46NFy\nzhgFEgScE7//I7gbFP+cQYOKeMmW9skDGn/A7BbVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhupXe1FpJZ+kiNMv1oeulX4I\nQzEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKDUAarAe+i1Gd+izPV1vHL3T6u9PQVzvvLijgUpU1rbAiEAwYZLz4ru\nKc/WWC+iSbWfYZByqF7/Tdnw+doLC/V81sg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWsOlXrQL3BKpKjYO2y8z9hlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFjYjQwZjktMTIzMS00ODAzLWExZTctMDczODE4OGM1MDhmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjVjYjdiNDQtYzdlMS00ZWMxLTg1NjctZmRlZjFiNmFj\nZWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUE97Ne7g6kcXpBpn4zbyLsbY\nlB0MkdXDsum2gIx9keLpJbyQq6B55DOpAuED7Aga8dMrD3b00UwU87Ijc+pTlqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqEpZvEu/ZmlirzXGotc9XLpeBSEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgNi1KBcgd\nl8/lys5laPFgEScoC9+k/pPf5EIU5TanhIcCIQCnNS1VCUoHjsfezrsYQkvLBJiG\nLlXbCptxJhN0YRpONw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4716", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4716` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAeUohZhvq2VsFck2gHHfn8H/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhZTk4ZjBhLTk3YWItNGM1Zi05YWYxLTA1OWQ4OWEzZmI5ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjkwNDViZWUtZDhi\nOC00NTIxLThhNWQtYzAzNjgzZmY0YmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESjALu316lDJwO+ItLcgmXJGPV+0Jq94wCpRciFfW6TJ56BGm2HtEvdCBtkPc\npA1UZgR3HlxKYQQJTJVvFxmNk6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0WG2D2bJ/jeHSKrYKPskRhuVs00wHwYDVR0j\nBBgwFoAUraCuExrz5DZP1qr6SWDZZvjQLkgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgXWB58BSij13O\nODUJtNuPBaU1qIj8Lpbn7bZ8y01n2RQCIBzh07GfByVtuCKr70K4jQ6whiURah1F\nzjDVnLgEUorZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAShsANLYvBsQCLpL8gtJaaIaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWU5OGYwYS05N2FiLTRjNWYtOWFmMS0wNTlkODlhM2ZiOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgKFYNJwS74UuX7cGBdSSBao7pLLMOb1KPjguD1z6OJtXe\nEXhuaS14GhnyVe1i9CHGuKLRjbe1DnxPvtHU6oMMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUraCuExrz5DZP1qr6SWDZZvjQ\nLkgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKRG3dE57fjQphPtm03WXcr883UY4Zaulc8LCK1N3r+iAiEAt4YER6Kl\nmEnigqhwMwVLk9XbmiIoB0i8J7kEYwtZyaE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASScp95x8oZhZeXbARELo/lcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjkwNDViZWUtZDhiOC00NTIxLThhNWQtYzAzNjgzZmY0YmE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2IyOTU4OWQtZjg0Ni00MDc5LWExN2YtODlhMTdmZmE3\nNmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa9IHwXiXhHSMOz+zNrHx+V/i\nxYdWm458HhvVTxeI/woF4XZ2zfwNKogijHybEvnUkhVEAfmTF/EjWDZYOdQdMKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0WG2D2bJ/jeHSKrYKPskRhuVs00wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgUaU/JSMs\ne0YgoXEORhUpqnr1AOTitXqWJzDm1xuEjEACICgojOLufJQ/4IlPPqgFhluSKNOd\n49KEoC/RLbTmxOBN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4717", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4717` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAV/SHa3v72T+XHwxr/YxNR3LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5N2JjZTdkLTJmZGMtNDZkZC1hOWM5LWE2ZTZkOTMyZjU1ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTMxYWYzMTAtMzMx\nYy00ODE1LTk4ZjktYmU3OGQ3MWFmM2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/NyNxMPWpPgsNFXTJu+z4HxgBtD4OF8gD0uy/eFRLk/cVF2jG+X7c1T4A0nf\nN1I1EmOl5FiWaYU5MWQH28C6gaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0sK3Au+XlNKALyl5CWeqOMGfqSswHwYDVR0j\nBBgwFoAU2MkKiKJotJ29nLQ3GZENm+MHQcMwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDCbcXrVjEb\nAgXLsmLvL9EMS7+TMHVjolMAhZU/go7V7QIhAN1fcqa+amdMIOzeNojArFStQGdr\nTibiysf4Nl8pyMh9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVPelhBvdHY2p2QTRVRKIkbEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTdiY2U3ZC0yZmRjLTQ2ZGQtYTljOS1hNmU2ZDkzMmY1NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQn4iGiWXJMyzZ3UrDSpvSZeJOu0abKSiIGTIw2lm3Gifmj\nF4bNxM84rEYJ8jXcbRJa+FIYxkcKU6FdIpAcVA4Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2MkKiKJotJ29nLQ3GZENm+MH\nQcMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI4IGpLl1RFXLxzoa1wIjDrOMgmJq1UHg8/EG7d2yTEpAiEA1y/H1bsw\naa+uohCbR0O4drZSYXJaZkUC2n15MpUI8oc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUVD8dGIe3Zt+PrUNupcR3ItMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTMxYWYzMTAtMzMxYy00ODE1LTk4ZjktYmU3OGQ3MWFmM2UxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWNjM2IxMWEtMDc0ZS00ZTdjLTkwODQtNzQ3M2M4Y2Fm\nNzhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyzIbw8h4l94LC/D4omou5G5A\n9YSaogTPOU5pK0jTgmMzzuKwA6Bj/5y1HQ9/6WzJ6xRLae2PT36NHmP14tEL4aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0sK3Au+XlNKALyl5CWeqOMGfqSswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgdCKKG9J6\nrOaULkkQ85ysL1qT91Ku+LzkK45u3HTiPgUCIQCBLeVzRneFX39z6ajarJntCMTi\nX042l8YXYARjrl0Uhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4718", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4718` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAd6zr+uKhETWnD6niCaNCZPGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1YzVhZjg5LTk1ZTctNDg0MS04ZTZmLWE3ZjgzODk5M2JlODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGY4NjNhZjAtMTYw\nMS00NjgwLThmMDEtZGE1ZmQzZTI1M2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqwF7T/2/l5XtW8q3RGpPhCnyrD4+/bbA3YsBl+y6sUhgikNqEIh4JrFzbwxU\nHeLthQoAf0g9fNVu72ocm3MBCKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0e6gYjCPkiw9hXHjQV7qp6VmFUIwHwYDVR0j\nBBgwFoAUI18NOSb0YOqdvzxcWzPvzMZEK3EwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCUv/E4rhkN3Y2Nohk1ZyZQOaUvMKWQECjk/RkDiHwDbwIhAOBLIKlSQ1cO\nqn4iw9StGxOgOf0mz9ulNPMxZnmuNU/p\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASO5jUegSRoBBvnUU+sAE+SdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWM1YWY4OS05NWU3LTQ4NDEtOGU2Zi1hN2Y4Mzg5OTNiZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQW4JEKn2RHy7Yp9yApEsFnO5qkMz3NkQALs7GuWilDE4RD\nwTgcE574t+ueYmloG+LuXd4RYb+oYjIoNK4HlM7Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI18NOSb0YOqdvzxcWzPvzMZE\nK3EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO1P4O4hRoIAl+E53Mj1Fe68wuyMuq97LpkjLH5daMpQAiAfE6VMTtnF\nba6GX28Wvkn/z8BWGa8lgbqlD7Ded/0WoQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAetSpYr24IdfNCKYcPuy90g/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGY4NjNhZjAtMTYwMS00NjgwLThmMDEtZGE1ZmQzZTI1M2I0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGMxNzg1YTYtOTE2YS00NWFhLTkzZDUtOWUzMmQwYTFm\nZWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEACb2yYd66Ivk6oLBmwGi38iA\nHXPOZHgq8ucz19Asgndk8heHlOuQ8/cxBf4VQjFRO8KBtxx1amVGtxEXuNDpRqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0e6gYjCPkiw9hXHjQV7qp6VmFUIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgHqZJpnXf\nOoCGdJylk2SbINa7rTiG2PfpXlohQ3Pv+1MCIQCgF6t8i5SClndmOqKet+hGwMZy\nYvVmaASwB3wjCSemdA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4719", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4719` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATRsMrmFtSbEau/zl8N6DAbmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2ZjNhMzk3LTkwNzgtNDExMS1hODA5LWE5OTNlYjg5Mzc2ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgyMjM1ZmUtNDRl\nZS00ZWVjLTg2ZTUtNGRkN2QzYjNjNTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkxpFhdqYhAszTPI4wC29nFbE2xao27EDz997sWxx1Sq+4ZtqQeov8aZbICI8\nkTx5VYfXo+5K6bJgDI+Z3UkHlKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbyioYGgI6dJR55soxvzEZq78LWkwHwYDVR0j\nBBgwFoAUutqTtt5D18OUnhMc2poafXmy8rkwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDdOIBXpelEn3Bi1GK5AhTFaa58K7ghwco2CM60+pKjygIhAK7uIr53QzGK\nPzIFL7l1AiYQLk4PdoyW0+3j28E69QLY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASEW89Tx+m8yWigh+4GMC1L9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmYzYTM5Ny05MDc4LTQxMTEtYTgwOS1hOTkzZWI4OTM3NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzJynX3Tauztsts214vJKhOLCHbkeksoZi7bS8rzL2ESSv\nBEvabmt0M3+tBUDmqxQuzFxgSheLROmYZktMXrAIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUutqTtt5D18OUnhMc2poafXmy\n8rkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBFSNCv/JUHvA8aj554uob37itNZYO3FKvoe0+8pstBsCIQCL0EzPZwO+\njXzyQ+TNvx0uxg+5x0bM3/Fh42A5i1ayKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAa1HZbIqJIPdWnfDPc59ODBYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgyMjM1ZmUtNDRlZS00ZWVjLTg2ZTUtNGRkN2QzYjNjNTM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzYwYWY1OTAtYjU1MS00NWE3LWE1MTQtYTQ2NjJhNDYz\nY2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4od90bFSwgqauqF0Cnq2b4d4\n6A9XDiCQ3veqAjY0f0cLfsfPflf/y00lZDhcZILbPt/mxixhuD5UM9VcPfy/TaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbyioYGgI6dJR55soxvzEZq78LWkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgF/bKYw8I\nQ0G+jrtvuNGXByqDUcBfFyVPz+APuZstRFkCIQDJhvDiTCpaXAmGQXNqP9WEjn2q\n55Ip2Hie2b8SyyVFLA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4720", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4720` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAdREyZZw0HrpVNf8SQQ6s6J5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMTFlZjgwLTE0NzctNGIyYS04YmY2LWE1YmI4YjlkOGY4OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDYwZTZhMjQtMjg4\nNi00ZDE3LWJhZTMtZTBmNzA2ZTRhMzA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEytBV9e5DZE8biAFVF842QfoPjYPFkIHVkU6SXSbxBoeEkMY88FhWyNEBGbSP\nCXZZBrF83MtlloovBWab85fR26OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV7JbaB/HjWLpWt9F2UhESSk90RwwHwYDVR0j\nBBgwFoAU1TZUHgbMKsCV+nHCemWoOE6ci5QwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDr\nzSYEKD4bhCZb6P5oZlwxFeSaSGPsEwGmb8RxouNKnwIhAMp5j5HoBx9TYD0m+ckb\nNAqhzrAZvi9VeMNFzZdA+fID\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbOGm1M0DSvAdw8P/0z5bOQdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTExZWY4MC0xNDc3LTRiMmEtOGJmNi1hNWJiOGI5ZDhmODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXikCXGjXbaER5TbKjj1lbHyjA8eLL8+EJRroWNvVg5915\nMhXt/ux94fjcnpkC0F5FKT2H6I2GEWqkpZ1F5geNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1TZUHgbMKsCV+nHCemWoOE6c\ni5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBeOn1xPW3YeYXhyUuY0QJKs3hrf+NpCFlfdCIwtDZt0CIEyXPY3jH5pk\n9RHJhVUZcW4whR/6iZy4Rj+nJoA+iGTQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAUw9pa5MBMG4CCt15Uf8pOtWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDYwZTZhMjQtMjg4Ni00ZDE3LWJhZTMtZTBmNzA2ZTRhMzA4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDExMWNhZGMtNjhkOS00OTNlLWFhMDItNTkxMWQyNzFl\nZWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPBtpGTHtDGIcURA7LVTEyhcm\n/3enxQwBVMe5bln+lqw2hO2GaycIsoFCabqv94Hkf0O1kdzJKAd2U3USQw2ZjKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV7JbaB/HjWLpWt9F2UhESSk90RwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJaEGjb4\nFkOFqvgjXLQKxTH0hCdGG6YpahXfdC0goqO9AiEAzBkhvXhYp64lmOTBgF8WeG9P\nhXFg2DKd2HcyqbnSRMU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4721", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4721` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAc7PD8FDWhidYAfTDICHmSSFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3YzczMTg2LTFmNTgtNDgzOC1iMTY4LWE0NjliZDI5ZDIyOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhhZTlhOGMtNWZl\nNi00YmI5LTk2OWYtMjk4Yzk2NTljZmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECoOQtUFlbrI94XgEwlHEkwZ3AQPBTFXcVjfxdhJ7bCbbnxTHNxHQvAbzWaDy\nAScC0+WIN56GTpQyCYsA/Xd0xqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4m9DHYdVJ0h9TEpqiAs3Yj4EBzEwHwYDVR0j\nBBgwFoAUbMaN5O53O90OzbYGBAJMo6QN9hIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDucKNU3MnAAqB4Upa+Vmhp7z6y3RGh4t9ZYcWUR2UnUAIgbVD2\nLRKdzY1HmxhOk2CSpmrx7UMqW9ESh1YWEZhjFJk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARMboax0or9HOSktDtYnTQnRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2M3MzE4Ni0xZjU4LTQ4MzgtYjE2OC1hNDY5YmQyOWQyMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHCp+yQr5K09iSrfnLcL8OYnR26Tbtfh5ejMGfUHGcIKGq\nnQ4Gx8Qq4KTa9mysi6A7aUNhWYKkc4Oa6FpHWYdPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbMaN5O53O90OzbYGBAJMo6QN\n9hIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgep3adjQsrnYuSsKWXlOOauPRXdhCU8uJB+nP3s1sYZ8CIQC0GoHCaJOV\nLycN83SMbxiK4HR63wi3NhpsYj30s3uTrA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARANS9F5IrBelU4qIcbqW607MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhhZTlhOGMtNWZlNi00YmI5LTk2OWYtMjk4Yzk2NTljZmRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWY1MzFhOWUtZGM0MC00NzE4LTkwYzAtNDk4YzA3MmU3\nYmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERSzc/6FCwbXWip+nMowcJqRM\nuP2eMsj32fDGHzD1vbCNM9KPBn08xFjTEoZzl8vVLoPc//f+U2dHN8/AHBg35qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4m9DHYdVJ0h9TEpqiAs3Yj4EBzEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAP5EH1mO\nur1u8AZNG9J2YOpqQGi7sjs9leor2eaMpyv1AiAZyoWV7VqYUfpPRmhbD0bAY3xU\nshm+3wDag3CoMKjfWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4722", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4722` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAeL0BrYiHDFiXC2nY+Pr53KuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MDEwYTdlLWIzYmYtNGZiMS04M2Y0LTUzNjY4MzZlYzcyZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRjMjg4MzktNmI4\nMC00YTEwLWIzYjYtNzc1MjI1OGE1N2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9C9VRcSvh2NiyjW4JTzHHsIdZG2l44pSay+FZoSG4Yd4N2ZZVviWISd/imt6\nmgsN26AtmHcsLXajCd60QbhkeaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGBLhLjNV1d3OgUUTUwI7KvfzPt0wHwYDVR0j\nBBgwFoAUguXAvDRYaCVMHrko1ugF02h2iPAwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHH3mRejpo6oAoTPAz4lE/lDNLaJ2Hh7j9sK5MLFBBOHAiAYQE0f\nz+pn4CWDfcMhdKa5JLzEvB3YYblMDSC5A4Qj9w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUuy9JUG3Ph/gKhnflaoDH/yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODAxMGE3ZS1iM2JmLTRmYjEtODNmNC01MzY2ODM2ZWM3MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnme1awNAuXyXWIohk95UJ7RwvQVnbPmVNByxxePqu9gXJ\n/Zie8JIxuKa8w5p9TDR9fym+MQcp1ZODHbizb5VTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUguXAvDRYaCVMHrko1ugF02h2\niPAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMVUa1P8kwTsAMUI94zo/nfWLagGj1wHRZikdCEGpHypAiACa3GNz4Cg\n4R6lu/7kbqZDRJGaLpihqGLKPpPJf7h3DQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISARFmAInqqfW+4QNLHZINoqxJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRjMjg4MzktNmI4MC00YTEwLWIzYjYtNzc1MjI1OGE1N2UzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTMxMjlkOWQtMmY3Yy00YTkyLWEwOWMtNGM3NDM5YWUx\nMGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBun+6hD071RYbR5QA03Vyb27\n+Yb/PjLkwrfFCfLJeiwUr8/m4ujRlaXYPhbcYLt6yQjDh8K9yzvHj6Np724ot6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGBLhLjNV1d3OgUUTUwI7KvfzPt0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJXw/+qM\nTmH6b4135dY4kkz6LcDK0P9KEVFZi4xG+qX3AiEAxtVPULTDMNKWEaM19mmfLmPX\njF5u3fnMBi6eOvWmeuA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4723", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4723` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISATYW0p0MBJlq1blhuXnScEwUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2Yzc3MWZkLTkyM2UtNGFkNy1iNmUyLWZiMzA3MWZhZWYwYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc5YTFjNGEtNTA5\nNi00MDQ4LWIyNzQtMTAzZmI1ZWU3YjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYPgD6+cIWxo3HyvkMS52Bd2fTK4NKfnIDFehjuceekkEllS99R0le+7OBUrC\nrmKGH0HtFIP+UG3Iz6jcCsEuc6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIwTmv/sKFHgqjnGyd4q9T+tkONwMB8GA1UdIwQY\nMBaAFMm+ipRfmmud8dXGcO0DbBnsxiXbMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBV0vR1byEnkkQshouefQEhkmZIYifJfQy9\nxg1IC0qajQIgbCnCeLUTY1ApGkXGX/2EtpthyWCtsj5/R758WiZy9Ek=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYutxkG4ZMneS170JwNnz7YeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmM3NzFmZC05MjNlLTRhZDctYjZlMi1mYjMwNzFmYWVmMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXLfg1g5Em+GaW1ULL9M+ttKG3JnCFbur4j0ZUkiZPTeJf\naX4NAYe24Y32kmCUMrRWuGEFDcARezIubZ3fLH3bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyb6KlF+aa53x1cZw7QNsGezG\nJdswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPOVhstitDtuUwBuwfd7taJePcgrBSdQFJsg44kJPl2AAiBDjP08EhRt\n4PH3F6UBU+nl684/wl2/A0OLLPZpf5efcw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAaYL6W4t1dNTQFj8Umab3YncMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc5YTFjNGEtNTA5Ni00MDQ4LWIyNzQtMTAzZmI1ZWU3YjIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTVhNDM1OWItMjUwYi00NTc5LWE1NzEtM2QzZGU3NTc3\nNjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2z4W5Wb5A2ecPlboPw0fp+o4\npviZ1pYPe5I2+p4y0Z3qtU+W+rqeBbEByDL5wXlvZwQ01ikQv7BrMDx4UkWPAaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjBOa/+woUeCqOcbJ3ir1P62Q43AwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAL/HRJLL\nbpBKTX/hy1PE38JlX4ZTLTX4ky6QyGURZz/zAiByVdXTtaXHyDam73zsceLA2c2x\ndePCroy7QSQE6doijg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4724", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4724` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbrebgs9XwpeyhwwnDZS9kzuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2MjEwYWJhLTE4NTEtNDczZS05NDg1LWNjNjlkNDc1OTA4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI2YjNiOTUtMDYx\nMS00N2I3LWJjMGMtMmRkM2U5ZDMwZWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6HDU9j3OqdTsJ7MTqQ/4YACfpZ9YQbi3LiiEVZbv9oeWTrv8KVSvtbQOHDRr\nTmhnyclWuddSY4w6pv4jPdfI/qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZok4p3qnfnssRrilrAR0rg6SWvgwHwYDVR0j\nBBgwFoAU8yOwPXFkuUIClNS4IpjCaI1te6EwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgd7rSCYauwiSy\nJ8qak5NR1OdwZ9eUPBzfNtYfOazL65kCIQC1I5vLvgGWHhTb2NDbwx2Xc0Na5V+2\nH6EOXqEJJeT8DA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAamIwtIhsbjv++4hghXt8CpEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjIxMGFiYS0xODUxLTQ3M2UtOTQ4NS1jYzY5ZDQ3NTkwOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATq9E5qCCnSMVb2mGfhEqvGoxd1C1iK+VVjrsWUK8sZj2Qj\n8Va7lgCMlfkxgKoBOKfKcZIud9hR67U75zVLfLZCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8yOwPXFkuUIClNS4IpjCaI1t\ne6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN2EMKCRe5iR/bVbRjOiDD6NLK6s6NYnP+PB3FKysB2kCIEro+ZNjOLz0\nlJl4IKQwxGbI0PTrEcWFReDRNYNo1fuI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZBkgIb55TukYNlGtuq2dXvMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI2YjNiOTUtMDYxMS00N2I3LWJjMGMtMmRkM2U5ZDMwZWNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQ0OGVmMGYtMzhjOS00Y2VkLWE1YWEtMTJiMjg5YTU4\nYjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgJtMnjUpcQlUWHccIY2jp6BF\netoHfK9OqeJRKdm2SR7/tJV0Y4jXH63fE7eqErkT/FHNZQl95NRRxt3H2tFELaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZok4p3qnfnssRrilrAR0rg6SWvgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgAXWpm4Z1\nc6AydytzdFRIcjUiunaY5sKmQ+eS0fTZbGkCIQC0ulENjsvfpkXvdixJ9GFYrNZ+\nQ6ai02ZCRJj7tQGCGg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4725", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4725` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATYCYvJewaHGv5XSR/l21y/ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjZmRlYmE0LTEwNzctNDQ1Yy1iODk5LTgwYTIyNjVkODkzMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQzZWI1YmYtNjRj\nMC00MzliLWFiNWEtYmYzN2ExMGQyYTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK8IMh55mepHHG9nEBKNgv/NOuQvWVQGPuE2VPe4JwEZnIlWUMYKKw4X6du2+\n8L42ZLSWlX+XHdGMnwBJFpbTYaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtkCVTzKfrzQhPA6/SWYa17U21l4wHwYDVR0j\nBBgwFoAUREfX++rRK1EJn/YtKN4gUQjHDuUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgYyRbtnw0ZHno\ngllLZIy3GrDG0hUNqOSI44bX7pRHm9gCIQDMLtk5SaJkpFWLECUAQWvEZL+Ykr+1\nUtsLihQdcmKsZA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASiW8i1/weiFgawx6cCMVG4kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2ZkZWJhNC0xMDc3LTQ0NWMtYjg5OS04MGEyMjY1ZDg5MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkZ6iWXsTDPSooN2jQdlvgNtx8PeNdADpknezv6wnu8z5m\nEWSm2xjyUWIH+kQMxZMUrjtb6bEYUbLh8fr1DJtso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUREfX++rRK1EJn/YtKN4gUQjH\nDuUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALmgg2XBd3IOCVyE5Xxhdnrph+uDxq7Kq6IcHVuNL647AiAmmgL0sQT2\n5GSCCadjXuZuCAIJu5+wn2GFfcMlH6fBLQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATv4+ZuQm03J7HwxKFLlRWu1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQzZWI1YmYtNjRjMC00MzliLWFiNWEtYmYzN2ExMGQyYTkyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWQ1YTlhMjgtODQ4ZC00ZmRiLTkzYzQtYzgyMjliMmFk\nNWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/EXrlXHIc0lIGyfk74/KsKe0\nRFJJv8z/Qynh65M8qjiIuiwWa/i/0m0Frb1fWp8a7YfLZvBUJmSDVa/l16JpYKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtkCVTzKfrzQhPA6/SWYa17U21l4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOhmlmBO\nZyxfawSvwc/VcLnTbMPCw7XcWzTOmjTPPrP5AiAHtIeX4R4v3AlrJqo+4VhnjqNa\n5s5D0mg9A8wRudy01Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4726", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4726` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcVE/jLfYzwccDnq/3K5nBqPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2OGQ3NzM5LTQ3M2QtNDkyNi05YzA2LWRiYTNjZmUxYmIyMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRlMjU0MWUtNzI1\nZC00MDViLThhOTAtYTM4NDZlM2E0Y2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg0Mvgr2Z4kuqzMuDjW+Y4b2WkiatdHBr2f6Xo7VCcBuQaF6zlKAB6O5ski34\n9YmeFUIFD/4BApBVumEshxf4daOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTHA0wVya4HMCTrToIA9SinMaS8MwHwYDVR0j\nBBgwFoAUv5jMCPi3XvknMWTKZC3fU6FgCM4wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCJfrbgYv8W\n451jz3iRi63V0taTXtsfbIF8euNl6flNYQIhAKhVK6oegd3zAeufswsGS+qXFSfS\nKD544PVN7hAEhQks\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZMZ2E2HQgPdcJ8fiLUHUZOOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjhkNzczOS00NzNkLTQ5MjYtOWMwNi1kYmEzY2ZlMWJiMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQV8lRjTSo4Ia+veOk7xz5sdERRG+dl7XIbsn64P0m+u0YF\nUIwV6qbHAPdtTpN4G7eWKf3NkiiL6Hzg8SNIeK6go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv5jMCPi3XvknMWTKZC3fU6Fg\nCM4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNrIDSsl1gdfMLQH4fS+DG8zCg80sIiYd8TycUqYIiYcCIG/ZOYxdsvZI\nz0JYQ5YoAEukihumS9shwzuSr2aJX/a+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAe9IqwgqQr3j560oMwVPQNWOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRlMjU0MWUtNzI1ZC00MDViLThhOTAtYTM4NDZlM2E0Y2Q3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjU0NmU1ZmItNDQ4MS00YzUxLWI1NzctZDgzY2QxNDk0\nM2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEq+3hp5ZyvU/Gg2rhrK4cLPtT\nySnjt0QCMWljHlh47lMhKZBmuYxDjNyl2c8VQZom/WdgMHx1fXRQlOoYFLiFgaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTHA0wVya4HMCTrToIA9SinMaS8MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgVcERruip\njCbVVfxY5Nc+us/5nJmIPxGMY96IfZjkh+4CIG2/8ReWFTOq+G7DNUe+LJeELNzj\nDsxNRVzr9EkJaVrt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4727", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4727` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVFCqJhFCfjAJWmxe4YboBQHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzYjFhYTUzLTgwZDctNGEzNy1iN2EyLTdkM2VhNGYzOGJkYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRjMjBlZWMtNjRl\nYi00NWUyLTljMjQtYzI2ZThhMDUyMDUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx/aPMlIl3qsVjWTXzeRrJLpIat4IJ9mpS3s3WyGf2s4zT6HufDTEUA39ZNpB\nZ/o8PEUU0yDoRlNoMbIXgichTaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyqMZQW9YBYUKQAA4Wz4eahYCnmAwHwYDVR0j\nBBgwFoAUkUsmVNvv73PLRRzvQ4odaEEX/50wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFZzTm0EImvPGeT9VX5cvvC2rw9f7mbplTxdZBSopMMxAiA6iKCSwXb4qRJ4\nnb5fUeJVaflcP5D3mtzsaqQhCkOdmA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfDCf0296kfV4Fqa5y++fuZwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2IxYWE1My04MGQ3LTRhMzctYjdhMi03ZDNlYTRmMzhiZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASc7pRtRpgVzqoBys1I3Rr+xU4eatVmKl86M3/94hiWWMon\n/KTP9l1A5lZy+UqwiM+sCRc0/seQJVH7b3JXzRK9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkUsmVNvv73PLRRzvQ4odaEEX\n/50wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgR801giQe1h4VOZGsBger5GtacSq7kYlvOSJ7inIfKgkCIQCqRSRAQmfe\ne3pTCfS+iPhAjYywrbDsAsPLGL79Q/wnug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAeSQ13uvLLE8UmL3gYGASUpXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRjMjBlZWMtNjRlYi00NWUyLTljMjQtYzI2ZThhMDUyMDUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDIyMTQ5OGUtMzM1MC00N2Q5LThiZTMtM2EzNzM1ZTc2\nZWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE24bydqr6+CYaE7MOmR2Fjgau\nCWSJ/tDLJg+0r7UE40NNuk6J+mBgNPECTCrN8URgyvUlVldMP0gBKL9PLZGLcaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyqMZQW9YBYUKQAA4Wz4eahYCnmAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgMjW7wihA\nsfLsrMYd2VcLgx0j2ikxckihZaiqdT5ga5kCIEI50HlEyyxhoehYnnroxAtwq4bO\nKJ9e2HSj3ZWnmkDn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4728", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4728` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQPm7HKAGCy0ZM15b3nZ7AnQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZWJkN2NiLWY0Y2YtNDBhZC04ZDUxLWNlODcwODk1ODRjZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWYwMmY2YmQtMDJh\nNS00NzY4LWI4ZmMtYjU4N2RkNmVlN2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzlwLMZ8nET6mxgfy+rOZCaJPLkXkwJwIqxEEh4ycG8dTR98XqqVE/gcTJor9\nyXnGYJ+6VMEIcYLAqs6zMg1cIaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrE6R5PzqUFQk2f/bUYOAyPBGACIwHwYDVR0j\nBBgwFoAUm2/dFOU6dIYGBVUyfHMotxMHjXIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCGC0G4MLorhZdfkc43nmXgSgKvfTHpVefl7PEkUIdGdQIgSsU4JozATWyO\nqrVFy0LWF0NWY3JECqaRppeCrTjaDUk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdMsj2KQH1g8VrQYx5mjXseNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGViZDdjYi1mNGNmLTQwYWQtOGQ1MS1jZTg3MDg5NTg0Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATha1yR5dPaIqLsf1I3jHBMPi5g9jLl0J3z2U9n19vPr/m5\nhLbA8mAmffuFJ/JV898nCYSG0ClX9tC9KXpU2nGmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm2/dFOU6dIYGBVUyfHMotxMH\njXIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGYfrhraWs0AAS4lQ9hDu80TqfrmDi1CBTMS/xeXozkoCIQDckfh9+Liu\n0wSqRGanIL4DBPplSZ7tU9QXvtCFJtGvcg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAb1pH8Monzlm7UO43oT4nH2gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWYwMmY2YmQtMDJhNS00NzY4LWI4ZmMtYjU4N2RkNmVlN2I4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTVmNDU3NWYtZWZlNC00OTExLWE0ZTctMjQzYmVlYzVl\nNWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm/6SymE4D9lHEMnbTc4Ibwdp\nnMpVO4AhnV/hkvtv3gETSb4MXa7CTCMQzYbUJJdIDBpt+ryedxDDOlpw1LlOPqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrE6R5PzqUFQk2f/bUYOAyPBGACIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKAlBEnZ\nDHBFLWTaIdjKkeVDotW9TaLfnOlrS8U7C88YAiBbBAX+OE5IUiIq4G9KdpUNbEXv\nJXEet3+XJFtL4cD9Cg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4729", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4729` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISASAbXZrv81z80qujEhQPqj32MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViODAzYmZhLTZhMjAtNGY2YS05MWY3LWViZDBlODZkMDZhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYyZTVjNzYtOWQ2\nZC00NzU2LTg5NzUtNThhNDllY2IyNGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv0x/fVxmGDRigy9T3w7WdZxpYu8cU4Nh0BUYSDL9NQwNNiEbMlQ5Uk22Af0o\nlHLWLRqCynN44PjRH/PB8EA8XqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTLWcqcESVyPnwuhZTJ85oNSRleEwHwYDVR0j\nBBgwFoAUaVS9So69t8GOhFYf2EX1SrRwffgwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIB75\nXdGQLXpcIXZH3OfRF8a2kL/k8YFoE78QUXmwtogNAiBhV1smbpK/mB3AzkEioql8\nzvBIriaU/ThE8PXbQXSgqw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATXEn99Ep2+vKnD05k+KD2mwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjgwM2JmYS02YTIwLTRmNmEtOTFmNy1lYmQwZTg2ZDA2YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0ZpoIXXBJNNX3J0QZr5p3GTNibbhNBX0RJOOWI0wr5cqj\n1l+Lxiqd3OaIdBDLu7mweNWM1DwC0KbueUsP/OEXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaVS9So69t8GOhFYf2EX1SrRw\nffgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPl9oPfFiPDuNV9nKRYsAamjSZyJ8AfHTcvzBeX1TXuyAiEA9FrndI0+\n7Lpp4w6dPbkZ89fLwBP8j0UM5mAH/VAR0/s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISATIshPqEJuKL5GIqSeK8/nOCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYyZTVjNzYtOWQ2ZC00NzU2LTg5NzUtNThhNDllY2IyNGI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzljNDQ2YWMtNDBmMC00MWFkLTg5MmItZjgwZjMxNzVl\nMjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8vuIseigTv+2m7q020BHz8JP\nSz+/YtU0kKuayadgmSvKLDPdPSqraKtbqZcRZoif2C7XI7P5T8hfdLMB4lKuk6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTLWcqcESVyPnwuhZTJ85oNSRleEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAMGp9XZO\nemgQ1fF6xFZaA2/43esnqO1h4M8gqawu2TqpAiEA+CLay7sHAvlykM60eUyrDxMX\nUY8ZZpt0AekiMY0XgcM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4730", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4730` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWiGisWqDYz4pgmW+MXmD9q6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0OGYxODhiLWI2ODAtNDg2Yi1iNWRlLTI2MDA1ZmI1OGY5NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRiMWY2NTItNzRh\nMS00ODFlLWI4ZDMtNmZlYWY4Nzc2YWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYPTk2GWs/dX1RFIkX6SseYaq0NvlIBNuhLBj05jj2g+9GhpnHuCwu5JA3dGK\nHbZcg/y/1Hc4HKdZqMT9nJkhFKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFFYbPjtuRJQC6iXPoTd9T+tcoKcwHwYDVR0j\nBBgwFoAUXY35qcD7qXHuD9TW+M21akHw0oUwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQD97wmahIgnQC/FNuskCwKQII/Mt3JyHZrX0t1gXgcTdwIgEQfu\nJI2UhNUGUK+g963Co0D4MWzM8mUFvcdEQ2zmUHY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQC2VHcutUsSlBpD4h1F8CVGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDhmMTg4Yi1iNjgwLTQ4NmItYjVkZS0yNjAwNWZiNThmOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb23oNBDuLkJln3PbO8MOiB52HFfjJ7XMbibwIyDCBdk37\nO943lafgxpg/DPSzTWjHJYbtvxhy36bcku+9H5FYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXY35qcD7qXHuD9TW+M21akHw\n0oUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIq7Ki72wEjBHK+Yw/SYY4HgLxdVwscM1vxBDnyHlSvcAiEA2YPbWYk/\ndGvg5tXQvL2aq0383QcanBYxr0qFLlLWgpU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASSp2ZhXnpFut0lqU/VSpVZqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRiMWY2NTItNzRhMS00ODFlLWI4ZDMtNmZlYWY4Nzc2YWNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDQzYzJiYjItY2NjNy00MWRlLTkwY2MtYWJjYmYyMzJl\nZDg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYoEdORQNwd7aoItajhXF62LI\nIKfSyxGl492J/0JtSvOilTht0Q9kVVOwDA4oXGqaHDBGQL6yR6o3Qz4QcY0JYaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFFYbPjtuRJQC6iXPoTd9T+tcoKcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgMjOsVod2\n3Yns/Td+UhIgxWfTzRTkjKIHW6UfcQtf9soCIQC6Qag/Q1MU2cRDAl+y/koiWoGK\n2R+IVX+eJ3cRR55Hcg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4731", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4731` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcSdHexSIhbCHxevrDVZhFR/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzNzcwNGVmLWZjMzItNDI5NC1iNGI0LWZmODVmYTg1NWZiZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkwY2JmNTktODI5\nNy00ODZkLThiMWYtOTc0MDJlN2M0NDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEubDoaNUINZMrPVWl7IL9X73jSDIEoQwzRJYkLGdL1ngcEs1SG5nMdRkn+Jy0\n4gvZlHCRk5PHKIoXG1gYJTKSNqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNeZkpnnkHvnMkFVmTSbq/3r93zgwHwYDVR0j\nBBgwFoAURzYDpPchk8Z3evAOE4mXEW/HNKkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDkDnaeCgngCSR15FZJcpi9aM380aQB2ciVOLN41ochXwIgJgk6\nIk21NPow7zGlwc7A1DSLQOeWKqeK+tvvjLTbFXE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe6GL4381lmTiNzxuRTP38IFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzc3MDRlZi1mYzMyLTQyOTQtYjRiNC1mZjg1ZmE4NTVmYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQ8dukCsPiqtGeyLFh3Aijj+CUCN1jNR+dcg9NKoi1LgHm\nRT3GhCvtOiWTaEfFelD1LpB6OfCvjSqZvPaFPKMAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURzYDpPchk8Z3evAOE4mXEW/H\nNKkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPZdpqNbUnu6KuPJWzjRiiKx3P+8IZyYEHneFR3DKzfsAiA/obQB8XLX\n6oKV19YTAXMX6tDoO7JgrImgvaW9mz0iJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAW8LdG750GCyKQ3/nrnvkYAIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkwY2JmNTktODI5Ny00ODZkLThiMWYtOTc0MDJlN2M0NDVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDE1YjZjZmMtM2Y1My00YThkLWJmZWQtNzAyNDI4OTU4\nMmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENgQ3CpJ4jx1V4nX5ZTSLGrwb\nCRTyo4Jxt9CJH41v+unhmdaPP5KaOSyeVQl4WEpDKgH4hFM5O9FGbZw+JdJn9aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNeZkpnnkHvnMkFVmTSbq/3r93zgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgRSlh1uBq\nlAIM9aPUA7VZjh4j6BDEZxzcMvRsrPkHOOYCIQDGl+MKOunIV5rmxGqteBH5WXOa\n1QCbzEd2Dw7Z6whBHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4732", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4732` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASbEaUuuO6AfXv6u6CO0niKmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4M2FmMjRhLWZiYTItNGQ5NS1hOGRlLWEyNjhiZDRkZGE0YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM2YzY1M2MtNmEy\nZi00NjcwLThkZWItNGI3ZTc0YzMwMWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+N1Y8uqIz5dCCpMQWaC17LWERDdtRUDzdegSvTNOZtF+4bVIEGor0Db5ehHp\nU1OtrEdld71F0fZTcxUFkOGDKqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR8sufOmCHPEn5+oGVOKwUVHEkO7jAfBgNVHSME\nGDAWgBRWykP/uXPxO+LfdmHmihnOOIVEgjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHEoZ9eNYpvdmpTnCAtWynNUCmr80uzk\nvMBoj+vy99lOAiEAjGOQ2ySEp+D8jbAZYLNIbDBpQ3FiW+Mr6xG4jL/OZuc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdEgkPsAMgAEyqzTmTraZNFpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODNhZjI0YS1mYmEyLTRkOTUtYThkZS1hMjY4YmQ0ZGRhNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlfM5iRjpVCNrjVdeK4t0gvuk1lWRXdbKo2SxfXcwpUIQA\nzbK5M6O6oxDFNDp5SHdM0rr0uWC8syVSA7TZl+XLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVspD/7lz8Tvi33Zh5ooZzjiF\nRIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPxNemv/Le6dqVgjoctSVZYW3Bi5zgyPwGfWMKTSzETNAiEAw8CfmG9S\ntpGuUYtFloEwwhwKpFAR0oHvcY3/dipQ8Lk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZbKKWRZrJGKOgQpDKeGLwxeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM2YzY1M2MtNmEyZi00NjcwLThkZWItNGI3ZTc0YzMwMWI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTA5MTFiNzMtNTRlZS00N2E0LTg1ZTktM2QxMTcxZDYw\nZDRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhKqLF2lF/vY1GOEh9aq+EBwd\nDGFh+hFRg7qQq8t8LI7rBD04Cx0pTDLygAMMdtMVQvWVlAdaVKy9kOxT1ZScd6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfLLnzpghzxJ+fqBlTisFFRxJDu4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhANLAiYyB\nEQ90Hfzq7l3/JDxIAx178AfmTHRuN6Cfe/MCAiEAy1TWTAxePNO3GPMmb7uIvzv1\nLWx1q8ndYTtqkdYWHls=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4733", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4733` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAX9MLo6ZF0ROrsLUNAg/1s29MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZjE3ZDI0LWJiOTYtNDZlZS1hZTBlLWZkMDk1NDdhZGRjZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY2OTQxYTktYWUx\nNi00ZjAxLTg1MzMtMDU3YjIxOTUwMGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQHED4NthnWP3Ny1gvsXnRg4T44sb/S9S+sDPEBv3hxs06OyneXby/C1jLZLb\nu33zN90Qn0GoVvj0kbOpA4GNQqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzuzfDogPXkIHqN3uINn+LzQG2iEwHwYDVR0j\nBBgwFoAUDVaDCvprzZTpoJMfHFN3EFs6qxMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCpwVFTvCE4\n6AH9l0RHbqlQsGIg9I3nlua9JO9ZUY345QIgFMkWSX+xPuwiJlXC0n1IdT9fVYBG\nQmZKFAkOL06v/o4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXY4LLAe6qivTC6dZdVkP2i1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGYxN2QyNC1iYjk2LTQ2ZWUtYWUwZS1mZDA5NTQ3YWRkY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASquRDyXQ5D5k6I8/NNremhIj2kXuHbFOzbfAqjPiGCoWq/\npqA16xsWriqHdQftHUp6Q3EX5CspJyY3zqx9kDMXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDVaDCvprzZTpoJMfHFN3EFs6\nqxMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMw9zX1qzQg1nW+a4QlDpyanl3T06srAvfHifmeZSHWhAiAPzIoiHrDw\nJRuWpP+OjAjukNXFFBGgj7Oc2Hy74s3fpg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAa4DBOaU8mtZDyZKzlu51z4IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY2OTQxYTktYWUxNi00ZjAxLTg1MzMtMDU3YjIxOTUwMGU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2E5MzI5ZWEtYzcyOS00ZTE0LWI1YjAtN2I1Y2U4ZTQ2\nYjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENXYIH4EqjM7z+icsG+CRuG7c\nGLiqxO7GrvxnOlhyqTqjNjB7l39oydGu5UuzEWiX3aLNf1nZgXO3pCjHy0P6SKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzuzfDogPXkIHqN3uINn+LzQG2iEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMKy8Z3r\nIqM5MDIB+xmpkF7Ci6K1CJ29Ev9vNrMs/4HHAiB6px3ISyDauX3MH9s/3T9yKZFU\nmngMr8tHj+ikyikbJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4734", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4734` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISASTjY/Vx5AkHF0O3xKvHIMA0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZTM1ZmNhLWIzOTctNGE1Ny1hYmRjLWE1M2E5MzcwMGRiZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU4N2Q0OTAtYjgx\nYi00YzU2LWI2MDItNzJjYWQ3ZTgwZDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHejU+QM1iizQFiyX1TT1boppqhOls23AtXhkk+SZJdFNutBPjhhlOzpD2sxi\na2jQ5n45tk9wKsOv2M2ZEJTLgaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBk/BHWYBebuKukfonWLpDPrMegwwHwYDVR0j\nBBgwFoAUBncFJ7JwyAqu+NozLxWknexaPcQwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGnN6O9V7khe\nx4xcjie0uwxuVZ4eknDplu+9VuoDqtRFAiB0ontxdMl4NWwY2uWU2pttqr2AEqv5\napK2KYletTMQjg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ4ICOiFvpdMYxm4aZKJlvqxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWUzNWZjYS1iMzk3LTRhNTctYWJkYy1hNTNhOTM3MDBkYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQA25OkNrL7sREZQqKFd+0QKGw1xmW3tOGDVDeDjLXX4pGP\nbYK8NLTvDLMD8IjgCFwDnshxze3PJUkjJVzTvNqHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBncFJ7JwyAqu+NozLxWknexa\nPcQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB6mZo2KNyth5iMVKhW1kkmImhorFCQeXXCl5t0OfPoACIAiYbkr8wV1Q\nAP9pa4doMdsj9rhdtunhxPTcbklhEqmm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAfTDv18wI6vmWySsltIzd4mRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU4N2Q0OTAtYjgxYi00YzU2LWI2MDItNzJjYWQ3ZTgwZDA4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTU3ZWEzMzAtMjYyNS00OGNhLTk4ZjgtYzY4MDI1M2Zj\nZDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiKuuZNkcC56JeUP9QJDonAJj\nlyQxxVR8Y8/VGroB4e6T6Ukc9yBS7JIOg0fSobk21/bqWfScZorNqrFzgLucuaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBk/BHWYBebuKukfonWLpDPrMegwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgVW7IiT+d\nSeSnhWceY+qY67CL+uUD9mc7iLKM7kNRWcYCIGuF3hy18sTuKO1VB4vO/gaoJ5BR\n33H85chu5tXw7wtI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4735", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4735` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAaHOvk1xoIBnTCmeO2k4IVyEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0M2U5NmRjLWVkOWMtNDAzMy04YTkwLTBhNWEwMjM0YTMzNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjllMDI4YWQtMjRj\nMC00MzZjLThlMjQtNmQ1NzQ0OTBmMzFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEND7ILA0PcV90WZDhWMz1pJ0/tk9X5kZ7MsbX+qY89cOhoIaO8gmikeVH4U9r\nJSzwDI+5+YiODxPW0hbMQaXcN6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnlsbjvnSkoOLosX3+Z0DfqNX340wHwYDVR0j\nBBgwFoAUlWdplKAUekygNCcoJekr3Tj/92IwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiA2rNe9FDR0\nqejq0/OfH0tNiqDmez7kmCx8S4S7rtRjjAIgBasZ6iESOBoLCryEeRBOZhJIktXZ\n/jp6GQ0ihSpJdp8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeMy6xDzs7o5KZX8Xfd4BwwCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDNlOTZkYy1lZDljLTQwMzMtOGE5MC0wYTVhMDIzNGEzMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuyly24a3DNmxuW8NT4lW187biya1JwV+sqIwd4GUceJ2V\n2+NbwUcD+67iJh3oEuqOyr4DB3Ti1B3uq3A7ImHWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlWdplKAUekygNCcoJekr3Tj/\n92IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPbajn3TvjEeuolhDJXhIwswx6SIKcj2/nUP+P+gd000AiEA9AN2iTfn\nZPUCN/nKyXGbAeU9bSCDk2Z3wvBZ+EomY+w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAXcmGeHAozuxlMWRTpGwCXCKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjllMDI4YWQtMjRjMC00MzZjLThlMjQtNmQ1NzQ0OTBmMzFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDE1YjI1Y2QtMjkwNS00MjY2LWFkY2ItMzcwNTM2ODMz\nY2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaEPh30JAj5EkLnf+zJKCzSuM\nfG5/ZHXOf2gkB7lGVtczr2f6AVE5yqr63hrF1W6EQABbFGkE6WnzfF/Bl5+SdaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnlsbjvnSkoOLosX3+Z0DfqNX340wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAPLuwqTQ\n4d0+/x7giWtbrdR/mqBMTn5KVCfeogOg0MVjAiEAg3TH+o31/eN1bMdHkhiNxIMe\nZFo4XjSC2l5N9LpL1Nc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4736", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4736` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbSgRBKgGbYmV0ftndVa0C4ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyNmYxNjNjLWQ1OTEtNDA3Zi04NDdiLWNmZWYyZjEwMjZiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY5YTU1YmItOTEy\nMC00ZjEwLTlhNjYtZTYwOWQxYjQzNDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELFvs1JxQevOTQDzylk+K556W23mZwCYXZI5qDaJzqKIFSzy5+gt3t18S3Gc2\nyoFgFnv4e8PYUpJ0I6F3Z8t+caOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBFOv3YyuTFyPAgwIYXtbfYwMVzQwHwYDVR0j\nBBgwFoAUGq0Q/Kpg+uhkrkgyy7UMWJmdzMcwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiAUnxZC4Qm91N1McIkzTxcFh0zp7U/Cvue4YxucLPp3QwIhALMT0cimRysD\nOM2KhKP+YhwPIbpeJlOP+8MSeedexrkp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYQLSr5gKmAXW7y5d2Pu2GMgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjZmMTYzYy1kNTkxLTQwN2YtODQ3Yi1jZmVmMmYxMDI2YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9rAe0UaqVxPejzV1P1zF5WXy1Jlt5hiiZruiRYAtQpIDS\naIOtEUqK/aRGUuTsoXsiDw31F6g7qKmiQyA3WuwIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGq0Q/Kpg+uhkrkgyy7UMWJmd\nzMcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM9odtH6EkZrEeHdaf9lFBo/9JY5jGyL6K0M6PIT09IAAiBmeYdsTQBT\nlsJcAhBxdGlCpMz1hd1/K8nHnMMBFvanwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAYSRVScOUyHfVG6r8vf7C+hLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY5YTU1YmItOTEyMC00ZjEwLTlhNjYtZTYwOWQxYjQzNDZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmYwNjhmYzctNmY0Mi00NTJhLTk5NDItNGRlZDJiOTZk\nZGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa2it+pHG8xRnDSyl5TNvhooi\ny0sHmtzPMTJJqJm/yAr1A06wlLJXo6C6INf8cgjilM62av73yvvq7FMuW/QtBKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBFOv3YyuTFyPAgwIYXtbfYwMVzQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgcB2IDa7P\n7e+fLGQtGFnhPEwo+O2tMn7DHFXtzT9gw5kCIBZlstw7GkTpZwth/bSHtbXosN2k\nzBjY0vsWW9oe8Ysd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4737", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4737` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAdygLs6B0pe35ljrNBmH2kj4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiYWFkNTFkLTQwNjctNDUwNS05MzgxLWRmNDZlM2JmMjEwNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFiMzQ2MzAtNDNk\nNi00OWM3LThmZWQtY2VlMjY3Y2JkZmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWaYJQyqQ/AgIYfQZvEVtkwNLkYOa+N0EkDqKjH2xcDAK2h6qdBsjZ4jw0Z92\nug1MU6EnIWJA26jeOuFnHNiZAaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUPyMRUUcSLHErCtYE24Of0+L0powHwYDVR0j\nBBgwFoAUYd12Z0UsEiEwNfWmdAD3+uD0xwowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiBS3l9irf1VfAchDS1pcIk5RJzhgD5AtKc8LGhUCAAt8AIgS7oHP58wO/k0\nhemBN66wfygfNUF8UMq85Q5WBO8RMDc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARXsOJRRaBVUfvL9D/XhDIlgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmFhZDUxZC00MDY3LTQ1MDUtOTM4MS1kZjQ2ZTNiZjIxMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRjtLD4HKYGIqilvMV7vzZM9q2LGH1e/vc5Jc65BMQKMyN\n2l3agaqeVEXyvhC8/qrJD2lM1h5697bBs53Vsvieo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYd12Z0UsEiEwNfWmdAD3+uD0\nxwowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK2VI5KCSRZiyhdXtxwhnVTZe4hAuzO/0lMH1XBvokgsCIDBBZLylgDcl\nfdUH3ZFdLbhNVwDyxLbjNZggXtOoNhLl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbk2xxBOeUHYZHlLwX3xO+hVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFiMzQ2MzAtNDNkNi00OWM3LThmZWQtY2VlMjY3Y2JkZmI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGY0YmFiMDktNzMzMC00Y2QyLWFhOGMtMDMyYTE5MWNj\nYTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP/asYK367oPpZftKZLxxfSPm\nLdDLZnygTNyAEIm4KEqDBwo8TSZ/CEtxC5YakuTJONGJWFa83PEWz99FB0fADqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUPyMRUUcSLHErCtYE24Of0+L0powHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJCl4eVa\n8LBvbhQ+z0Y8/f3XCpoFWfDMKhDyRuvemx6BAiBQsrY44Lop+379/XeIs2ws/UGH\nBXjXEJfn0BXvohAYGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4738", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4738` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAWsL+X6XY50DrK1JFLcQheNLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMWRmODYzLTk4ZjItNGI3Ni1iYTU5LTFlZDJhODlkMzEwNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWMzYzQ5NjEtYmUx\nZS00ZGMwLTliNTMtNWNjNzhiZDEwNDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPZ5kXcDjB1UflcdM8WgpLhACXYHw6L+fnGJSlG9DEq3mPgtH59NNcjGKoPQN\nSkNBHliS1tyh2zuZ33Ubd70baaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoNh2WVtd5r0pvf6gsNGcCBeJLRQwHwYDVR0j\nBBgwFoAU6VfqLdsdkdAO2dJbbwUkk4FJ9uYwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\nxA2Bc1X5XEDk9DTt5wY7K4t4QeyP0f+5X8C4gig+OC8CIQCC879lyaGUqKv6p+y6\nbQVUhPlYLpSeNdh5+OVeWlJjsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcgk+XywjzcRIPATcM1cbPtsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzFkZjg2My05OGYyLTRiNzYtYmE1OS0xZWQyYTg5ZDMxMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfPwBirkkXlSlIq1JPGJ6h9qztYcUGyBPRmyfScYc4l8JT\nr9YM46QcXzLU2ItO5uwvkTt9e4mbZdXJ1jBtviDLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6VfqLdsdkdAO2dJbbwUkk4FJ\n9uYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAORgf8fw80pmDnqC19hQsJSuWwEqxI/wsz19oxacEY7sAiApjvXEa18m\njLyNrdE4Zi1Vh81/O9rkmvvaX5XTHnWQ/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVk6HMJdvFuAf6x1u/Z3qO6wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWMzYzQ5NjEtYmUxZS00ZGMwLTliNTMtNWNjNzhiZDEwNDI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjBjODhhZmEtOTA2MC00M2RiLWEyNzAtOTVkZTMyYzg2\nYmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7UUjdp9aZ23dUR/+NkEpxcmx\nmVrVXytXHLKEL8mYb8clyb6kl4U0imXSHmhtVRCBX5O+eM3ZCWv/VCyFkOWmgKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoNh2WVtd5r0pvf6gsNGcCBeJLRQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgFHM+RDU2\n1WMRYKPnXB3LoKy4xAJG9iwbvY6w0GmEytUCIQDdX3GTVbtMlQGX65DYvReB3GsR\n9K/4HIgTEedjq+/8Zw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4739", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4739` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAb0Ao2x5LLmaVwrgj6jETAb3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1NTEyOGU5LWJlNmItNDY3NC04YTkyLWZkMGZhOTAyY2Y5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTVkMjU0OTEtODhi\nNS00N2QyLWFkYjQtMzkzNTI1YzRmZjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE74GsGMx8ZKXR2yI5oyr9/HclNgt4ACAl1FnnmN1g3pXJvkZKleLyTvFk1Ing\nJUFP1fnm8e5zWVSU+LE9mJaoMKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXDYentJhO9ct/6yJiHS5PdDse5kwHwYDVR0j\nBBgwFoAU6Cnharf7ny3wno8O9zGVnH2RMcswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA7j046kdl/NZT7QpKKepEexn5BvCeBe69TnYBR8Ke53ACIQDe\njd9Q/5CLXJ7zOT1g3dSE8ygL5FKW7UB2X7Z2OJ237w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATkj5apR9avabGNxacEmAujpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTUxMjhlOS1iZTZiLTQ2NzQtOGE5Mi1mZDBmYTkwMmNmOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPH6oecmg5dbvRJ2k+JWte5A3pdjUgfA4wRmZxmOX1x6av\n9eszX4MOyq6BWcMGYaHzjwDw6vBYfTtztgj5wsuXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Cnharf7ny3wno8O9zGVnH2R\nMcswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMCgrITYoZ7Kd2e/N46TtM2df7LZbTn5pyaxEBoPgUB5AiEAgZjhAF2R\nulGBfGFZG/mHESBf9LEzJlPZH3QutX5mriU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAeOhHVmFKpNdXAqlcJlAKwJYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTVkMjU0OTEtODhiNS00N2QyLWFkYjQtMzkzNTI1YzRmZjIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTA2MWM4MjEtN2EwNC00NzQzLWFlZWMtYjhkMTZjNTUy\nYzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaKQC+HvunrTgmK9PcQXz7y0P\nGzSxOGEFBILI//DZr932Synhd+DjI1yK0RPX4YcUTnp7R5ql44xB2yfSuM6QraN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXDYentJhO9ct/6yJiHS5PdDse5kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAMk9zZ97\njZI0ZedS+7Rbj1RcRRMFfOMEms6syS9XBZuoAiEA0i6AQEgRGdMI3rvJ9Ivm81qU\nMsOczmovBVFLQwzK8uM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4740", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4740` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAdatnXHV1ZCchAO+2HGRVa04MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYmFmZDAxLWQxOWYtNDcwMy1hNTgyLTgwMDBlMjkwYjQ5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk5ZmRjMDAtMTg0\nZC00ZTQ4LTk4YzUtNmVkMWU4MDZiMDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcq+dFmCFZiRSyGu/Ijhq0sHjdjmXXWagcl9yntjOQZMV6Z6poLmXKGYY1Hev\nHu80dBdUO2++jNvRut7T9O5FXqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmZZJtnMfyfKerzG6O4ik+6KS4KowHwYDVR0j\nBBgwFoAUOb/+gdzeJAv6mqxKQ6REJ5v4m0swPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBHwRYd605oubmuNDJFbysIoxa/oyJmJNmF99i7xCwqIAIhANVd\nL5CyFVkhfDRmTGAgwH4ozSAqCXiQLQhCG2ZuJjZD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbryRcIcGh+w7MfeVdOGgddpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmJhZmQwMS1kMTlmLTQ3MDMtYTU4Mi04MDAwZTI5MGI0OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYQTY6LbDFvVjaYILLDPzAAorfWm1NvrsAUZ3gZITyOvlg\n7dHmZAfNOOenuvYKAJisOUTzUul8TRovG2rTz7Zlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOb/+gdzeJAv6mqxKQ6REJ5v4\nm0swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIjh3/I5dgU+BmwIKdTPAiR90wJn8cHx7D9msNztRGzEAiByYjUEiE7M\nGWg9gbjGRThcGtxsmMrCD8gt52D859juxg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAU9SG5r8TyPCWzw2zh26qKwvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk5ZmRjMDAtMTg0ZC00ZTQ4LTk4YzUtNmVkMWU4MDZiMDU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGZmN2UwMDktYjY2ZC00ODQ0LTgwN2QtYTM2NTM0MGQy\nMThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhUbA4V0fPd9axsn/8gb/YAez\nxs/wJnjuen0Mkrn4LjuLNX47GCv+Q1XMqnThQIiRh7IIMvUG5cRutGIaHCLu56N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmZZJtnMfyfKerzG6O4ik+6KS4KowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgBw5bLHBw\nlAz+boM2uQtzl9F3MAgjxCRipGrD8boXHhQCIBw9iWJyjkwNqWu2YWfE7hDBcyYv\nFs+FDacYi2tLJisc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4741", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4741` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAXM5N2BF0O2VDXyrKsG3GSJvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlOGNhMzdhLTdhNDQtNGMzYy1hMTA0LTdhZmI4Y2IwYTliMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkyY2RlMzktMTFi\nMC00YzgzLWFkY2QtNGJmYzkxZDc2MjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErQjJ4cVXzpb3iglS4rJUb8S3lmagJP2m/nadwPNqsETDObSUr3LdVrRvIuYk\nRz8p5aAObc6f+SRhnvwF1A/N7qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU951vPro6WFJQsX6PASu1xoGIP/8wHwYDVR0j\nBBgwFoAUxMNHuuLP3UkIWcmE61Aa8zTduoIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAlKZ/SX+Xx6pE\nylgLKtt9gefn4w8o83P9YyLafZ73RAcCIQDIqCuh9fREsp+/0IdY2mk3XRyZ/3/Y\nic20LlBWbtBt3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZctCyEQ83AmOMujBJ+ZDI5aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZThjYTM3YS03YTQ0LTRjM2MtYTEwNC03YWZiOGNiMGE5YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNjQcpWFdlcbu4kLKqmwuWdkxYMCgoJLniGWidlrlLARO2\nxxmaGAZYdcO2Y3/c3NiFi3gE7fpVGF1g2OhEiRfNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxMNHuuLP3UkIWcmE61Aa8zTd\nuoIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfOw288M5qXXdAbCKVzwhB9bizqd9HQgtIiYubyaWxukCIARk5P4Ltsro\ncB9ve5rrTv1vwvlezvAh/Ahn9G2IDxAN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAeuIDdr85CW4896kwhinWSryMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkyY2RlMzktMTFiMC00YzgzLWFkY2QtNGJmYzkxZDc2MjFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTliYzk5ZjgtZGExNS00NzgyLThkNWYtN2VkOTI4MjQz\nMzRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2gdO1mcH0GKR067UwThpLYtm\noD7m7LzOalWDNf/BS3tLae8f1vDCq2FNNdjIjZXSbGDmrbeY9cspfgPVlKIO36N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU951vPro6WFJQsX6PASu1xoGIP/8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAI6GIzn8\nc+h9UzD4GXcU6fBRFq+fSxtp5oilienxwWN4AiEAy+6T1FjH+AAvu0zypKcaV7LK\ncrGbIyxuO4bMBx6qGWE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4742", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4742` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAX2Lxjwxc1pADc9tubE+GdvQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3NWRkNzAzLWZkNjMtNGEyMy1hYzkzLTkyZTIxMjZhMWFjYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNjMjc2NmEtMTRj\nMC00ZWYxLWFmM2EtNjc5ZjVjYWJjMGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa9EngQnSHw5NN3/e8SKTxszTZcndeIw3eIZGI/4It/qUOhIl1r3/24Hrd+6j\nTjccxMjF+RLxgoiSzZ+maPB8eqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV2+rTYCw9ymEhbCzRP3KHw6dRMowHwYDVR0j\nBBgwFoAUjc9bdsBBboJ6W6P4IbWwuE1/nBcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCmAsMG5LGcONLSOkssO8W+GQomcTzVRpG5/Zc7ifjE6wIgePRR8hCO/rI/\nqbKsi4VmmJ7R7sVrS/DD5ey0Lin1++o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUiIIsPz5npfmC559dtlyWYWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzVkZDcwMy1mZDYzLTRhMjMtYWM5My05MmUyMTI2YTFhY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRnkAQGrs90EqWMAbyMBN6mJLHAeL80a43zpP0MUoHCXKM\npnDbpCbQPRlpeyzh8TOmjnqRgDaS9rGXeo+mNLzxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjc9bdsBBboJ6W6P4IbWwuE1/\nnBcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANPn0B7Q2BD/FlLi3HfupIgRae8a0Noh+xdKGX3fRePfAiB4lUYNYqph\nHGgZQUlFWPmZRG+OjvTMtlAQrnRL15PaEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdHbeQvPGXJgB4Q5YJUMZTQLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNjMjc2NmEtMTRjMC00ZWYxLWFmM2EtNjc5ZjVjYWJjMGUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWU4NmNlZmQtZmMzNi00NTQ5LThiOGItODEyYzQ4M2Yx\nZjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjcZoTQC32hAYOSfwFC3oyHT7\nRuUMu2pIIR4tRE29C18cmYuW3tGnnxZM9u8KKjiqtxOLQeCfbr+VRGPatKheNKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV2+rTYCw9ymEhbCzRP3KHw6dRMowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgCzp6zNCd\nBhvtno6FH2rkEN7p36XXIsAbW6spsjDV7XACIQC4UNT/2R04TiYHXX1SeFwvfAFs\n6QlTi09xr3GCgQfj2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4743", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4743` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAW3xEdfbOI4JSi0dAT2cbxWXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkOTNmMjFmLWNjZjMtNGQyZC04NWUyLTJhMGE2NjQ3N2JkYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg3ZjRkMjctNDM2\nOC00YTJjLTgzZDAtMjM3YjRjM2UzNjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiC/ECOlzmJwiSoIduIt2tErSA6T1igmhDgoK9wxyI6VWqedOCi5geYDuJtjs\nMBdU1pY3KMNIhmnPPPBHVXOzCqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKp8OqciwnpR3IOH4hy4NASnbp8gwHwYDVR0j\nBBgwFoAUuj823bJKEOhesxLPaLyTS3OZz14wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCrgrW1mJXjrEhDcuxRMZHAR40Z6qAhmRTU9fis0aFQEQIgOKadvb24GKpd\nnAgpGVxUio6sN+s/L3GfqQuWcPrOTiw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYJFgJdVarZv4BOKKGVcraDxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDkzZjIxZi1jY2YzLTRkMmQtODVlMi0yYTBhNjY0NzdiZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAST1RFBrmZT/gCstLuKuI0C3T30GPjcTQHDUA70CKrZ5hNP\nF0BqetrwLEmnCmG/RMbFdn8tCB9Sf6kUlRYBA1bQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuj823bJKEOhesxLPaLyTS3OZ\nz14wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPJOYtWvlsvWIpw4PL+XBKGoFa6Y0nEZOyctVDovLl0wAiEAlsC6CRlB\nyweNRONYO/rBRrP18p4JceIP5qLA291RnS8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZQvKDYE39O8T+3lzkw4QMUYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg3ZjRkMjctNDM2OC00YTJjLTgzZDAtMjM3YjRjM2UzNjZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjJmOTIyNmQtZWFhNy00NTY1LWFmNGMtMWFkODNiZDFm\nNzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpQf3PW9rGmCaM/PYljVFaxRy\ng9uCTzg9I7NPqx8hDfEfAuT+p7MMylOlk1aFWDIos3RTppV765yzrTAoMQB15aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKp8OqciwnpR3IOH4hy4NASnbp8gwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgAyRnz6sr\nXGF/f9tiuPVqXkObzT8cT1O5wHFSv6JieykCIQC6sIOjXH0FM0T6iylrAEV30LS2\nf9uj5/JNO1mGQreNmQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4744", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4744` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAYhdgBADMrxt2yLHrV/25f+OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyMWQ4NjZjLWU4N2MtNGU0YS1iNTEwLWYxNDNiMDBiMzI5MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZmMWI0NjAtZDA3\nMy00YmY5LTgzZGItMDZmOThlNmNhMWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzQTaXjGRin+7bppGWJysOYSapAjZ/hx061jJiTggRtbrxiUKWZ8dQD2H0/01\nvm3XLltIw1cuWbHjNO7FEWE516OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3uThyr4EgZ3xw1rQPU9+u0S78nswHwYDVR0j\nBBgwFoAUtT/aCQ7e+dcs2lED9W2REm9AIXQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAxO0NtAC5LwN63kJ43QG736SW9ZJ1pCPZ3arTf6vsU5QCIQDwkhNs9B7f\n9KH7wv2RI5nBHYqyiFLoG1L6n354WPP7eQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcJGS6PHfS4hVRCAui+Zp6qDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjFkODY2Yy1lODdjLTRlNGEtYjUxMC1mMTQzYjAwYjMyOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+kG80YI+cnCUm7Pu9HP5RnGH1y1s0zAoXB7TE8hcVDm6v\nG4XQi0sA4YO6GDVkts2InwTtukEtQw40XxEPe89ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtT/aCQ7e+dcs2lED9W2REm9A\nIXQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDZGRJnazAFY1Ns4kGOVniWUSrnogIFS9ccy1c7gvbCcCIHcmugI/OWbT\nAIRtq+I25JFGEqr3M+qQVn0ySKEj1wth\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQkwmLhi5nyipGXrBa81/u4fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZmMWI0NjAtZDA3My00YmY5LTgzZGItMDZmOThlNmNhMWM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWExZDg3NWItMzJlMy00M2UwLWEyZjUtYTZmMzczYzQy\nODczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkPeuzO54Egmpnqc8tJ6dYrtu\nMSvgI40SoSv8p4xgDyePVvkR3IfSg8VldnJ9pIzAh6n5mxmO/u00Xh0hIs0TP6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3uThyr4EgZ3xw1rQPU9+u0S78nswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgCNXT4A/U\ni3GgpKwV8r29+s3TRrmNXGt2eblHnvfjsdcCIGrpzR6ALO3tbocXoZHEL06Cbp2t\n1KyULwg5DVXNj/Ky\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4745", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4745` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAQOXVlVn4qqmIf4v/h9x4vVZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NmQ2MjgxLTBjMmEtNDViYS1hN2JjLTJlZWM3OTQ5YjZjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE3ODNhY2MtNTZi\nMS00OWE2LTkzZTAtNmUwYzk0OGM5NTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5Na9ndjXwEZYKWKCPdQkZKojgB5o2GaTGesU900y7C+bsFCDy4e/ZGcPSoe/\nH9bvf9uuSuZ69P5nexxoI8gKi6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeFVs7LMgGaNqzWTjH7KXUFUZd4gwHwYDVR0j\nBBgwFoAU8/foAaPU83zfnBJtQibRc9ZspPQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAxKPtPrm3gc8VU72Z49s7HFikJOUzUjK1cpYeTZ+F\nmH8CIQDKGUUJkBEt4hu53vt+rnagO3Ores2biMGAeFssDBPsgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbvfiZnDYygZzyfzuDvnrzvjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODZkNjI4MS0wYzJhLTQ1YmEtYTdiYy0yZWVjNzk0OWI2YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARypiNUg53w5//HbeCE8tmP3RjJUQh6g/8cMxfI9oW0p/vl\nJVR9Hw6bmyy1rosuulbi1+GTTJXkTh7bNGvWEHxNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8/foAaPU83zfnBJtQibRc9Zs\npPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMSiHfdmrPecatS9vLdQu+WM1TesyaAywZHdPMmGk8z9AiEAvJiSYMAR\nuEPV+v6JXeS53Q8/oz12SZnRM8/NJKIEcyU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARXzR2aXTpKkDF5zgqQkfkSCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE3ODNhY2MtNTZiMS00OWE2LTkzZTAtNmUwYzk0OGM5NTY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTY4MmRmYjctMzc4ZS00OWU1LWFhZGQtNTg4OGI1MDIy\nMDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAcgh2R0q7ii/UE9p61Nxl0no\nUDjYnx3XbQuXJe/JDDQWMTJktiWSUGP3ilmwAuwvSph7gCcWZPnUrzsKacXwZaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeFVs7LMgGaNqzWTjH7KXUFUZd4gwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAK48XQ+d\n7FT3h1YO0TFKY1EQ8Yp0ILJ3UVhARo5f58LZAiArWo0jVv/b6kkjqBZqs5Fz5RFZ\nb54Re2u5xYMxdYbB7Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4746", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4746` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQSRK7NM4cYzSZ8hZENlvbWpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkZjgwMDZmLTg0ZmQtNDlkNy1hYmZlLTk2YzM5NmU3ZTBmNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY0ODUxOTktZTdh\nNS00ZGE0LWFmMzQtZTYzZWY2YjQ5OGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfQkKcXe1+GblfCAkcauFgEljUGU6KVjKZw80kBJT3hs65A/Agilpt3GuZcCv\n8U5YoSIv9J8iQj4JkViBfL3Ku6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh9gicRLFdd1kgungBvOmw2p0A+IwHwYDVR0j\nBBgwFoAUXt1ElYxamQsZF23Okh+APmt4H78wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA7jKjKZ15EKZxoyOMmGa8oRHbFBzUZ82YcZc35LVX\nbckCIHN+If76TFSD99q0OGcw082TKD1UzM2nH4ifILZMAErV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVjmzp28mH9qz5zt3GytBhBlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGY4MDA2Zi04NGZkLTQ5ZDctYWJmZS05NmMzOTZlN2UwZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStmM7OJOTGSp/pYgxyn7tn03RjvR7LqdJon299j1lmkWwf\nZjWA3Yzv2nPbmE7HrMh72NBucS363I/0OglhnSgxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXt1ElYxamQsZF23Okh+APmt4\nH78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZfRwJMdomUl0m5fvqSmcCvUVKoRBJDZtqbmCjGR+qbcCIQCH+isUhKME\ntOctVjjJWZKDTDZDYSoogumurf/Uv2QYhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAav5fwrixmcF9ESmmD78PtktMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY0ODUxOTktZTdhNS00ZGE0LWFmMzQtZTYzZWY2YjQ5OGEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODE3MzdiZTQtMTM4Ny00NjcxLWFkZDEtN2VhYjA5MWZm\nNmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEny4P3d1w5l4j4rDG5UMP/lV+\nvzsaBEUxWyu9bCfdhIpuMc49weEdf32cmcIK8bxx4ZPJz9vfY0TnGjvrIRTTjKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh9gicRLFdd1kgungBvOmw2p0A+IwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOunfjPJ\nvMMPHHSirc67cPqVrExTY/zDfdE+RVAHgfBKAiEA+Nys/YUq4kL88ujRHC3izOWz\nDkFIyzjOGyR+Ud0Jmgs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4747", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4747` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAdasT/fFh5N0Ql5lqX458ZvmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZTA3OGU4LTdmMDUtNDcyZC1iZmE3LWViOTVjZmJiZmJiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM2YmMzMGItYTI1\nMS00NWRlLWI3YTgtY2I4ODA3Nzg5NjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhvqYEF0x+a0JfFk3sRt/CrDrguTeAwt8v0oM7hnte2211Aco4S+t9f8hAbTW\nDQEigo8wP7qAFuYXiIOlE7U/OaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNtNJarPUxSKpn5P/EGwVrSq294swHwYDVR0j\nBBgwFoAUZR18ua/l14/yp5voGKTJ9CbFL8swPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA2wVXHAWKnkYuYt5W7bzvTYlI5+RSX4Y+U95U0iy9gjsCICj8\nMp0zQX3yl6MjaWI7Z8wSi7QKfYRdHZcoWxPUGwnd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATGsKIHNim8pWYguNac1muNFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWUwNzhlOC03ZjA1LTQ3MmQtYmZhNy1lYjk1Y2ZiYmZiYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk8PFWomXdCfu9bm3Ij9Y2N8/X6eWNWBx6GyvxG2bgRBBx\nAr9S1c5JXzaU5Vk7gFdvbawxt9QCPbjxwJ68VSTbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZR18ua/l14/yp5voGKTJ9CbF\nL8swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJV9du6iaLotEap7QL27h/JUdqBPjpTgQDrqJYvdch3YCIQCHWSxq9Lgw\nVKc6dR6qvbpo3jNUxyZR8YCdxgVqgfxD1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAa5nlPB2y4+kUO/eWmbbwhidMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM2YmMzMGItYTI1MS00NWRlLWI3YTgtY2I4ODA3Nzg5NjRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDUxZWQ4YmUtZWQ5Ny00Mjg5LTg3YjItZDI0MGIwNzcx\nMzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1N61ovRKmTPRlDLqlIjKNkt+\nSXUy2TgUxa91uH1Y+db7Q9n4ItktgelUzlOCiVWr3/kozHOKw+EjlrecpS9KC6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNtNJarPUxSKpn5P/EGwVrSq294swHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAP5ypLXp\nHzxMzOJhhqUJm4TrmPEcZssIzeU9aQAe8sKaAiAnBuffAe38THjJkbb0gRee2CQD\nt/DHKDlfcu8pOXhUJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4748", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4748` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAVXuNE4OGXifY84UlsU0S0LGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiYzRhNDVlLTEyZjAtNDNkOS1hNmY5LWMxOTQyN2Y0N2FkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJkZTViOTQtNjI3\nOS00YTczLWE3MGQtY2ViYWUwODgxNGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3vzvQWwFch7SQmB/hNPpTCSA6NxVaZD6E072Q60wLX+QtYM8KheNeFlpXRdy\ncKIE30OV+8eaVksaOporOk0ki6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVAOoU26XiltpacUEGf28Ak9ukAEwHwYDVR0j\nBBgwFoAUGDVaWs1Z1Psd9vPHxhPndH2VbWowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAoRF7N4WXtlL4EViqQCKKs5ucef7Bj2eM\nkT1ILNymgZQCIQDcB7vocN+TTGMNI8frKtoSHf9x9z95bMDYcOXJPxGbeA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYX8Odb0dJHoUy7paG1tyRSdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmM0YTQ1ZS0xMmYwLTQzZDktYTZmOS1jMTk0MjdmNDdhZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbl03RnHxm6NrLLtIWgsHrW0vmNQfhi9EUWOnK/IjS7SH6\n0IAryv9gRrfxJZitfkU3F9vrB1Th781SU5iEV4Xpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGDVaWs1Z1Psd9vPHxhPndH2V\nbWowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP1uBDHorTZEupkNLgs5Hz5LZJuL7YTXoNqAsJ5//aUpAiBYsVhmBbbp\nExbsBh179eFMl32FkNPB3a7XsqGgApI9UQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVY4E5wmfRW1MFyTJA/hlN8PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJkZTViOTQtNjI3OS00YTczLWE3MGQtY2ViYWUwODgxNGFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNjMzk1MGYtZTQ4Zi00MjA3LTljMjktMWM3ODY1OGZk\nZmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE23aJdvwvcfJvigvA4gzpvXl7\nk+nm9iU4kZaLL4QjBjGDz+y8r0zd69cdZdTyp+7FyU1/nnzyBX6kqkFZbD6k4KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVAOoU26XiltpacUEGf28Ak9ukAEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgTQFItzLq\nrlxXqNJM+g686T/tGz5A+6DkY41cpj6Yp6gCIGzJhvh8ld7hKlFmjP2HxemGeBeh\n176AS9tiIGojHwaW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4749", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4749` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAd4NuYk01s/S53DpTWV8viluMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlMDlhOTU1LTYyZTEtNDlhOC05N2Q2LWYwNzk5MTQ5Zjc3NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E5OGJlNzAtYTk5\nZC00ZjJmLTg0OWUtNWMxZjAxMzlmNmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/gbX9NAAIeOIpeGRiB+onGpFH2UPkAsn+XmyBo/eXPwK9mZZH55p5m5spx0f\nZaP40ODQw7uu1V50Vrfcsg94oKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ7DNcQPFWutFuBXT0UTaIPBweLowHwYDVR0j\nBBgwFoAUqZdjxkGX9y8l4rrxQJbTORC8fqUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBdQwS8bLyrwb+NcWETvP/XhyqGsZhyJdc1\nBGGnkL8f3QIhALfw2WUaywro3dae2kEZYdNBT9DCis7DqOVZfhCOrtAN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfpKHTaif0A1tKr4TsKRZt1hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTA5YTk1NS02MmUxLTQ5YTgtOTdkNi1mMDc5OTE0OWY3NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmgAgVdZSEtH4iMSt2Ml7RwzCpPJ6ve1IdewiSeafDLTHv\nTMPrOXn/R9D9agwBT1fFfIKrYy+/4FzJNJPbFAu0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqZdjxkGX9y8l4rrxQJbTORC8\nfqUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0nG6R919kBX1GEY0C5hMjGVohQEMkT/JZJVsNxkGGmAiBnRHeyW5wT\nQX11679EVD3KH97Nw4RuVRCxruVHU2tTxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWgowFqV+TSjWSTGiea4sUYtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E5OGJlNzAtYTk5ZC00ZjJmLTg0OWUtNWMxZjAxMzlmNmYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGY4ZDEyMmItZmE4My00NWU2LWIwMjEtODUwMmMyNGI5\nZDlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdhZr3q6Ra/f319SsoMKXQNAd\neUo5//gF9zFCGqnQy+t/82LL56Ky8SKHQ40GVXsF89arfnw2UOlRygcS/FGataN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ7DNcQPFWutFuBXT0UTaIPBweLowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIB/yAdW\ncX5tOmjhpq+8SFFGe9IRnBszzj9pyQfIkgYWAiBxuzA80IEj5VFqMEPweWO7OVXt\n5CCtOlFvtPhAV6vrMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4750", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4750` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAdH2AiB6sKvyCF2AfQ8B6O/rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwOTJmMDk2LTIwNjgtNGRkYy05ZGVkLTE5ZTAxZmZlZWEwMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBkNGM5MmEtNDgz\nNi00NGQ1LWI2NWMtZTAxMmE0MjE4ODdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOiCtjg1TqkgeQuUMAFM+9A6czBTkKJX6xQfXHvWqVpDrCDaoXUUPUlSdi0aw\nvPRDMsUz2rDrqE4VyzVc6HVuNaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6UDca7+dz+iq84ZHLbe0uRYIWF0wHwYDVR0j\nBBgwFoAUS1HIX4RyxvoV9skkkQmFHSSzufwwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA96ZE2FjvkZLG\nHUhTSfguTCU4tyzEeKCRALEGMgipbXICIQChg7CrYEroBTHzbf7H5/COdD2jKGJo\n3Flx2wl/2gtDIg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS9IwUVHZV4p3HsxiYBM33asMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDkyZjA5Ni0yMDY4LTRkZGMtOWRlZC0xOWUwMWZmZWVhMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSokp3c6AqFoeudSf2bu8apGHIr9xGKal0OJ6iTJSFvYRA\nkvaM3RDLUgqx683gwwdbkkbT/Yc3xvkGOIYApgISo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS1HIX4RyxvoV9skkkQmFHSSz\nufwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJqTSLNdsCSsR8iHY7t6wH1AdmHTarxNy/SAr6dwx9ZEAiBYAaySS2jj\nl/M/V+4zJUFVuOj82BFzpkAOxMJngBXKWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQGfz/siYiVuLHqUgFiVXCnuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBkNGM5MmEtNDgzNi00NGQ1LWI2NWMtZTAxMmE0MjE4ODdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2RiMTk4OWQtYmViOS00ZmI5LThmYjYtOWU3MzNlZjU0\nNDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbaTZfdUlR7lmOYT6qOLchQrF\nx/WXqO8TMVH4xdbDXGWU21TZyFGqkWp8h9oZnrTdI5xa56oKqKVVs6zJCYYfFKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6UDca7+dz+iq84ZHLbe0uRYIWF0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJmGAb1u\nKwihI/MLK72z+l1Ku10ohu1pTt6fMpzVe2KiAiEAn1vpAiNxfylzE9T3qDWGMPV+\nvfaJyL2zE1PchcKJNd0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4751", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4751` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcMA8p7sP1PZb+Qe492y7jZEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjMWYxZjliLTIxZDUtNGY1My1hYzBlLWI3YmZhMDUzZGI5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzE3MWZiMzItNWI0\nYi00YzgwLWEwMmQtMGU3ZjhiZDgwMDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkNzpA8MHdtc27w/ZfqTRQ/lpL6gwbBGQ2LcCF/6ZKd7aFeg+YxSTSF1sjW1N\nZAPAJv1+kv6RACFd3AR4lZc5jqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2WTMRoG8H0GytieEgF/1TWF/LWowHwYDVR0j\nBBgwFoAUnANmSfiA3o+889YITy1gx0dPltYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDArTSmHdUByg7NaWbNd/FERsI4PlIeIgcbDtw2xSQ3HQIhAJxRAYv9Lutv\nfzn7oxcgBECSKIQ+lCKgNCdeIxQpx8qQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcnFMspvqZCf3ajBOU37bRwOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzFmMWY5Yi0yMWQ1LTRmNTMtYWMwZS1iN2JmYTA1M2RiOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpPWPYTLGdXXjvGnm2+vMSWs3yuNG1iyxElHR/XyqBbcWd\ncV5gdTiFnnBPZJmWEVgAR4X7gp/RpUgLCRb3qs9Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnANmSfiA3o+889YITy1gx0dP\nltYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMy4BeEoMCAPCuThG0UgR0Qxn/bX9gAYJ5a/76wBkxB4AiBgAIpvvESo\nu0ORXVfLVg0AC8/S52NQzeYnryDZcOJJ5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUh1BT1bDhFngMnUYKpUXQ+hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzE3MWZiMzItNWI0Yi00YzgwLWEwMmQtMGU3ZjhiZDgwMDkyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDAyMjEzNTMtMzExNC00ZjQxLThiNjYtYzQ3ZmU0NDEy\nZjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQ1iNXhr2PDJ4TV/MqOzpuUlC\n4RbJ1PyC4voKX4l/Y2OFNf6K+Xo0MyJ0a1l5UEjynsrDFOXEXcgSGjcy6wxLYKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2WTMRoG8H0GytieEgF/1TWF/LWowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhALf1hzIs\nhYba/o+pGM2GeJmXDQQ+s53xCRx7Oyft8C/tAiBN6kuLz+eMsrIzG9JkLLMXlH4D\n20GLKxeo9kekJr63zA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4752", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4752` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYsi1nQ4V+Cyo3JSBa6qnDFsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxNjNlNzdmLTI5ZTEtNDUwMy05ODhiLTdmYTkwYzk0NmM3OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJjMGQzOGQtNDhj\nYy00MzdlLTkzNGItMTBkNTkwOTRiYzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyZJL3gIBsd0ycmWUTnsllrEELjDaR65H3ziA9tBNN+rqfH8lTG+oKUAHioqB\nFQrdx7q8v/n28InGhsl5uwyZw6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx+XJHRUfURibGPMoMaWUruW4trcwHwYDVR0j\nBBgwFoAUdSXIe2oa7HrEmCwFxBWBQdmZ5powNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDkw7WifFt0lVxIgntmtFcEa4sBz9C0wGXdegjGaqgmbQIgcYiliJo/kiAw\n68bxdfQbGh1IE5XigT/Ez6RHaZ1BcOo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcNjkkgklwzqBtqxQtXcClwtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTYzZTc3Zi0yOWUxLTQ1MDMtOTg4Yi03ZmE5MGM5NDZjNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASar/eys8LPudcEjUPpNTN91YwNBHCdrMYvKbHG04ktpv3N\nXlC5lQmsm1aB5sCCyJGdgDqA8Pdwh3iRuHAHElRno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdSXIe2oa7HrEmCwFxBWBQdmZ\n5powHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKGHmDlNhGlhtd+8ZJgF+/dJjYmCdF1qnuoTjaRMsubzAiA73zW50x+h\nWuuMQadqozEG/sz0bVUjzHzkcKqTHol+uQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUT/fPWzn8XbCnQEwlhlBDqOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJjMGQzOGQtNDhjYy00MzdlLTkzNGItMTBkNTkwOTRiYzlkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmEzMDZjMjMtMGEwNC00ZDk0LWI4OTMtYmIxZjUyN2Rm\nOTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM4dDwaxCLRwxCwq17jdoFyZU\nUKuh5U3D1oZ77Zyfx5qe0CBpBWdGhGnPrx2RVVF08TEJaRy7YDzH4fIhqZ80gqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUx+XJHRUfURibGPMoMaWUruW4trcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAP00SykJ\n8jZS8OyrGEILDv0i8lF28Xi38EEqv9fI+oFuAiAUqkLz7w/5dUafL6/Rq2Np6ewD\n++xGA5pLFxXm5dX8KQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4753", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4753` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAUwqbuxrOrcQRBa69BKaWNoBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhNmYxYzIwLTJmNWEtNDI3MC04MTQwLWU2YjQ2M2FiNDQxMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIwZGFiNzItOGU3\nYi00Mjk1LWIzYWMtNzRhNzQ5ZmJhYzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuqB9b4R/KFNq2ZtTq+6VDOYcpCnw+5JrB5rL4bmcfiwFlYq8bNk/N27+V0Gv\nP+Uaj50A46fWw8EBCK2zTzW2OKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6GRQyBXegdlXkYpuVKvDtqRraBAwHwYDVR0j\nBBgwFoAUvf7swqM/xX6+mk+sepCh7ThpOcUwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAWmTSTbJYOOnjrwGCE4QpElDyXePdyv8JGiHtvKs4uNAIgX6fZH8RKJRtx\n0fjPTVwiGvMVPzW5hRuEbuhO6OjhiWc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWKh52ulw6qL+zL5zIyKMH0wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTZmMWMyMC0yZjVhLTQyNzAtODE0MC1lNmI0NjNhYjQ0MTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATANpCizah/s/KTIZKkZdo7jwoZTcwEnLOMFQwdx1FahQOt\ndEO0uO6k2YfeFCS1GInUTmY3+TsHufghu9O8DxgTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvf7swqM/xX6+mk+sepCh7Thp\nOcUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbnpIzCaUiWNaZN2JeleeTZQpLT7FlMxkMyv/HxtBImwCIQDyAPPs3Zqa\nN3o2E3s86ysjQ55aF0VjWpbFQ5rTO21vOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcSoWYctvqt/3V0IhsT0fDuSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIwZGFiNzItOGU3Yi00Mjk1LWIzYWMtNzRhNzQ5ZmJhYzBlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjc4NWI1ZTMtYTM4Zi00MmYxLTg4MzQtNTg1YmU2OGQ5\nMTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEApH2USdL+NN+k0E48o6BjyyR\nkTnwpJDVKHNgY8hyGFprsMcSAZK0HBRPe8l7yOKbGMqryAigK+orkQlk3FHaiKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6GRQyBXegdlXkYpuVKvDtqRraBAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKMODc1Y\nPUdmi+PsozDHeBMLLR6k/os3a1c+3EBiRRUxAiEAj0eHp30APofF8OYYJrV39txk\nWRvXMH8p29rWJtJPzYU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4754", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4754` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVtu+kySahMqRcw5gCfpsazSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4MjJkNDNmLTgwOTQtNDFkMC05MmZmLWM0OGNlMjEwYzhiMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGUyOTAzM2MtNzE2\nNy00NzFkLWE5NDMtM2Y1MzAyM2IwYzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5Q49mv8IKpwwL/xm4s578Q7pHC+7QBTeKCT+E04guqEqGpLSqpCPWPlCB9lM\njppzScV6audyf+U8q2CWVQR5SqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcOMXjpYxxGz1+ycrxjr0DOALI5owHwYDVR0j\nBBgwFoAU5QH1R0vbb34UI1lL53GeOrnxxDMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBk/owT/joBuZpG1DfvLQUY9u038fpwSgOflueSbeKv\nSQIhAPwNu+Df+wat5sKAkBXieBoFluPSceCg9hxjezbx83f5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQAZcCzuWQJ2Qe9sg4d0UuOoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODIyZDQzZi04MDk0LTQxZDAtOTJmZi1jNDhjZTIxMGM4YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFc/x9qAvtbxoTbrFqHAJgvh3E1AevSyyw+u3UJdYnTPGl\nEcP87BwJtCiQUcdWKcc/ibr13yikOF3r8GLW5exXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5QH1R0vbb34UI1lL53GeOrnx\nxDMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJABnsh66GWaos8WtVmmOJdBVSwj/o0NB9F/9wHybJv4AiBwFcBI6jNX\nMhIpX6vly2QtblBa8lFhboUgMQkfF8zgBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUhf/RvkD5r/fHtMPLYNgEYrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGUyOTAzM2MtNzE2Ny00NzFkLWE5NDMtM2Y1MzAyM2IwYzY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzkyZjM4MmYtODYwYi00YjUyLWE0MzAtNjdkYzgyOGRi\nZjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgjoXejjupvkfXoIrS7J8OVvi\nQxAjtDgCFdf6FMgaCe4yVQGBbZancUy81ZIpPAKZ2uNVOQoxwLAPsvmr0rA/26N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcOMXjpYxxGz1+ycrxjr0DOALI5owHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPDHUULw\nwzGv9tuz0H1jH3QUltD2/j9lGoLd2zs8yo8cAiAbHC+l1GK1sY0FKcdWtXTjQbhv\nWNbRs/1RzYu4uXWG6g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4755", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4755` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAYZyA17F7FSGNfEuyYrULz0fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkNmFjYTI2LWJkMGYtNDA0ZS1iMWYyLWRjMThlZTVkZDk1NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODNhZjViMGYtYTBl\nNi00YjAxLWEzODctZjEwZmY0NTBhZTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbqT+O0MnE98fI548VMNVnfzkA4TpfQtUeM5DazsT1X5znyYg4CE+85J2QvaX\nz3Z8trFArbgCNLDhbr8xzmwJ3aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS0XeavPSd0ZFoGkXofeRpvZxa5wwHwYDVR0j\nBBgwFoAUfbnMzk2PL8brQv/juwrdY+KZbs8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA0wmjYSdjtoWqY125Nu98QlIhRUCuW//P+pjGFUVp\njOQCIQDIIC7efKq2N8QY7siKmVxrtPAT5yuKmnDjhp26zJQVnQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY5v3+7nmHr21rqBmA4Lp7swMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDZhY2EyNi1iZDBmLTQwNGUtYjFmMi1kYzE4ZWU1ZGQ5NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfBIR+KREfXXVoU6kXSkxZFUj0hacyZiTMeeC6/vOYu4Fk\nsyzYxpxsSQN4171+hxApXFhtSwKJXXkrVIeDhcIso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfbnMzk2PL8brQv/juwrdY+KZ\nbs8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIS5+SvEN6VdonkyW5MX826l6iggirg8WX5NLIzKosVSAiEA41D2V588\nSzdlXqUK4VtgjAHUBq+8eeNkPPyF4tNiMUs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAW6G2FAGHs5HnVPigZZVUeFvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODNhZjViMGYtYTBlNi00YjAxLWEzODctZjEwZmY0NTBhZTdkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTkwYzc0MTQtYjYzOC00MmU5LWE1NjktOWZiMGRkM2I1\nOWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEv2oEERwm3QYiZ6xAx40BBwUF\nbMIX4yPu2ECRHtUKjz8tGXVVevFEil8A3d9B3rP+q0WkRD93Lo7okIIs2KMPFaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUS0XeavPSd0ZFoGkXofeRpvZxa5wwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgRSTrNWXn\nqm/Jy1sRkrKTZWDpCc3yD/Fot2N/JpfhEiwCIEcEg6NlCbHYl4YGO/OO/qfZTtA/\n55T59u6PTFFEaAEO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4756", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4756` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAQnHGTGQzUXkY3+UGNrDc+2oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjOWY4NWQ1LTNkNGYtNDE0MC1hODU2LTIyMjBmNzRiNDk4NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDMyZDNhMTYtOWRm\nMy00ZWIzLTkxMzEtZDcxMGIxNzY1YjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3968cFbEPn2ZlxiWRv8jnalGZJZvFl+a9TXvklOERl2TeUY3CKSU/GHRPvyr\niVCLkuyTN+AXFtQ3RBtqtmdgRaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw5J1h4enNuteg4mDEGvePFT4eIwwHwYDVR0j\nBBgwFoAUV0/cR33eDSsTA5Ldsj9fMOEV7MMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAKA9mZ/QLUh19q/O+xuQb+EZhULFcwBNmLEASaOyuEyAIgG39G\nq3zjh713IATT0oi7C3I+16hgCvwMQVWeCgboIUc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeSW20kEEJgdDVjCDu7af4eFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzlmODVkNS0zZDRmLTQxNDAtYTg1Ni0yMjIwZjc0YjQ5ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStftbUOBmwRfcU2fRfUTqLYbLFBsRP6vFaZDRtRXP75xET\nuyvK+7O1ZuPhSMcN+k3lMvU6+GwBtCWZYoceeQUBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV0/cR33eDSsTA5Ldsj9fMOEV\n7MMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIzr73ofwDrauVh01FiLpQsTpuppwQhUAG6BUGLrG66aAiEAmR2AnJ6z\nE+fb1Q5emS7CaJZdLPAmRjEFwhaOiQWnCHc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAfDnPC34zR4BkujBB3MeY+BwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDMyZDNhMTYtOWRmMy00ZWIzLTkxMzEtZDcxMGIxNzY1YjVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2YzMGY4MmItZjA1ZC00MjUxLTg0ZTItNjczZGJjNDVk\nODBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL8fQMkGtncGgXgMwt6Ow9POR\n4TXjOqYumqv9wEk0MR4Fl+1i35lf6foqz9agDoYvROBNA7gWKO01XS+wd12dwaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUw5J1h4enNuteg4mDEGvePFT4eIwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJtnAoHo\nZn2+hV8Mlv/Ft0PzSgeKmhJOyZu4xCDV8fQjAiEAzj6g38I1zbsdKvV0DTSRUaxi\nhXQhkbkXrb7OO7O+4Ss=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4757", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4757` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAfOVBnQh+P/KdAA1zzLmKwZdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzNjRlMWZjLWJkYTAtNGU1ZS1iMWFjLTBkMmM4ZjU1ODRjZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAwYTVhOGUtNDgz\nNy00NmMzLTk0YjgtNzgyMjU3MDI1NDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF2JQzjM7vOVc7mR8goFLy7tsEW8b5PoMLgq31U00TJ2lpSAPaWIm0hEtnLyU\n0xMZZfgdfhOEO3Y6Dv/VKrzcuaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgp/YwGQh4DcWEud1yi0Bv3JDQJUwHwYDVR0j\nBBgwFoAU1PdjzkNAjso/SECfyTdO504P0AIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3AvbYQW4I152USeZWZQ85QbKfBGeMXnd\nxcabF7KXE6ECIA7nRJcELPU+2A18g1iSYQUQ+OjOhuXAzY2RoxVh32aX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbDLs1D+4AKeI0CI12EYhOD+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzY0ZTFmYy1iZGEwLTRlNWUtYjFhYy0wZDJjOGY1NTg0Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSyC4ALy2Cxo4cKJccxx9MwLdkcqutca1hcAroDBi7hLmf\nFZTWBmWTYVqlwfwHLcvoURIAId+FNJUeiACxCbGEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1PdjzkNAjso/SECfyTdO504P\n0AIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKelm8LwhdIyvk2Ou4LsWnIph7mEeXyX5As7/+fmb9wSAiEA8MHUJ+KN\nOVBLS8CvEYYKhHDSjQCCagUwPGecDHqAB4E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAclf3DGSjejqgwu0PGUYJEb9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAwYTVhOGUtNDgzNy00NmMzLTk0YjgtNzgyMjU3MDI1NDAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDMxZDI4MTYtZjFiMi00NmNhLWJjZDAtZmEwYmRlMjEw\nODZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEckwDM9S/vNFCT1OIuYNn18oM\nkFnmFQCIoyq0NXn3OqYgngOlc1AJpf1yJUm7ZXDsVfYMkjF5+QRY9dnd2pXrqKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgp/YwGQh4DcWEud1yi0Bv3JDQJUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIq599xC\nrr41ElNtGevchj6AnR96lBpgw1ONJs57fMQoAiANXCkCnW9C99ecqlyleZxc3ckR\nQdm3qgAsB3gc9RU/Rg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4758", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4758` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARukAoaofVJf0o5Am4s0J3g6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiYjk5MmRjLTg4MGItNDU5Zi04NDU5LWY2OTUwM2U3OTcyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk1YjY2YTUtOWVk\nOC00ZWM1LWIzZTAtNzYwMTFjMTNlOTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPRoz2iR65CjH7WraXzgNuHfoPsiefCCVQw/Cc2JfJGgSsuaDunZfzyhhDFPj\nHH0SC9U+MWSquM4aQM6s+wVQ46OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHi7/0Bv18dEeDKHjoCUYKGkbbVgwHwYDVR0j\nBBgwFoAUrlB7L5U/Y/rlfIAUCB8rGQstv6AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA0gQtJiujjAvoBGqo4kyQlMaUPm1Ft1/E\nxFnLX/ty7SkCIFErMX2qUjfEFK5HoB5LHCLOue2g2hvgT3Lk+Yo2zebf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAapsgmcbUWJrHjZATe9Qn/hwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmI5OTJkYy04ODBiLTQ1OWYtODQ1OS1mNjk1MDNlNzk3MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGB9Cho+swIkkS1i15tjdlIn1HlWINhceQUOybS2YSnm18\n3JWzCzDIieziOGzzF1kY+WsAAnE2L0iC29q6BIj1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrlB7L5U/Y/rlfIAUCB8rGQst\nv6AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQHooQok52SDrTMgp6FixFwQVqt2KF67aLvI3nDUN+MkCIQDXYx00/ZVU\nnGgzbDM4fCNYE936qWD4lZVZisqImY2Bkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAThiq5EjAsBrdESkZQUx1KVQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk1YjY2YTUtOWVkOC00ZWM1LWIzZTAtNzYwMTFjMTNlOTY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDJkOTBmYWYtNzI2My00OTAyLWIwMGYtODZhNjc0Y2Ux\nYjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXFK3fBMcjic6A28G+436UtTe\n5g9bY81mKYT5W2KAuw/0BZha/M32XlIb8G0ndOHgcJ0AZ3Pf1pSwuf0HP8wg3qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHi7/0Bv18dEeDKHjoCUYKGkbbVgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgCJW7QEhF\nEEGL3O5E6lW/HFYVQ+S0CDde54/rbkXwkDACIQDnZ+aWm2FuehwFH78H8dIfg0/r\n1/zXhYpaV901X4EhGw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4759", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4759` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAaHY92MWpS68dzvDbCW2GN5NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlOTJkNzU2LTJlMGEtNGE4My04ZDk3LTYwOTExZTNjMzFjOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQzZTA5M2MtNzk1\nOS00NDVkLTk1ODYtZGY4NmI2YjUzY2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElGoab2Gz/Guq5fWm2umca+XcwsCYkKnAoYDb8a1WXmXhORSI/J9f4svXfvyR\nenYQkvkQy11REbvyeifPugcTL6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR4pVfrnygZzWGNaxPIbK3jBRWBowHwYDVR0j\nBBgwFoAUEBzcOpJNKlR3W8khEKAs/MclEbMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIB0pUbxa+2UYhdAL91xxeXfJPt9F\nnMAhGdScL3X9eKEkAiEAjLOky2m13z1aWrBslbZxBIUywOT7Q22uW3U9h4LlTmU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASDq0MFLGdbghGmR2Qv7fp5uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTkyZDc1Ni0yZTBhLTRhODMtOGQ5Ny02MDkxMWUzYzMxYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMyBL01oQk9lNo3TIX1lIJyRuVUOOPpsuBcPqlcr4WdpeN\nyVU0XWofPZRG7gk1+cHdHrJHHHfOxpIZCKwgz8D6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEBzcOpJNKlR3W8khEKAs/Mcl\nEbMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALUnzH8vocJ8MkFqJLzJy5puO+fN/4hWMASpEzm9v9s0AiEAsjB4/Gz1\njmSa8h5Hcjkc3i886+UhrFXP3b+LtDK3x9o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAUvZTcBCAj4vIstV9CGq5s7gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQzZTA5M2MtNzk1OS00NDVkLTk1ODYtZGY4NmI2YjUzY2E2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDBhNzFmNjYtNjBlYi00ZTUyLWJhNmYtNjk2YzViZWUz\nMDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERFMD463jQegyR9uE9azmXrrc\nNENrKkOmBslMns1pMJR/QQt6uBgc8PjQ4bH5dQ+kkAdTePfdlYITuXzTdC87pKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUR4pVfrnygZzWGNaxPIbK3jBRWBowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgPEorZOmW\nM9J1S4di0IZNCg17SQDO4DZSJ50lhgKbpp0CIDM7B/vMY2qSujiVBODtMEOGV8eh\ngYzIGyHZZBzScL7R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4760", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4760` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISARAJgdLuByD21HBCsI3WqZHDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNzM2ZWY4LTc4NTgtNGY0Ni1hZWM3LTcwM2I2NDA3M2E1ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdkNGNiNjgtMzU1\nMS00MjNlLWE0ZWItODQ3MDc3ZjUwNWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFKanSFx2SYXcSOuAXemFAplHFDuvSiWAfsZS/bJ4LS+RVWGO9UrKBNAZVow8\nS8Tv7GDBdVCK9s68GeRAmNzM6KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURjbJeKlenbqFrAl7Mq+KLiw0ux4wHwYDVR0j\nBBgwFoAU+he3Ux4wIGnBg6VXUgm+xSzTA4AwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgQot5OoI5\nJbfeY0z/q7uKkoL/3t4T6EXTUkMlKOJwvgkCIQDiTT35KvwCCjoUXKrb0zqmBXZT\niLkf8+Q6/B//UOdeZA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfJS7gxUkJ9JhcWpB84KNGSWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzczNmVmOC03ODU4LTRmNDYtYWVjNy03MDNiNjQwNzNhNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARd++6ssgu8UzbSsrysV32lk5mvsBNG5bX2StODkeJ6Sed6\nImXnhrE2VvOIz4pa2nK+SAiTDvNMkb+SjuoVTsNqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+he3Ux4wIGnBg6VXUgm+xSzT\nA4AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcpI1DI0JFWxKIrBFEa6R/UdL9orVAApoViuw/zoAMiUCIAiEd/vxGTkF\nZQPzyDpQZy5LqW/N1Ap5JaVn51aKqzCP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAakH23YVOeMNAKf16Y5nVgs1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdkNGNiNjgtMzU1MS00MjNlLWE0ZWItODQ3MDc3ZjUwNWUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTc3YTI4NTAtZWU2MC00Nzc3LWE4MDQtOGY1Y2ZhMjA1\nOGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4+iP/Y+LiOTjF5ORI98qT+Kf\n42j9cWxbmUhHcA/Z46t4CwEpz1hO3RSHzJDRH31AS3Ecrz/BWOJJeGanex5H+aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURjbJeKlenbqFrAl7Mq+KLiw0ux4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgWxoAKCce\nNzSz0LdN6Ma8noUS/re/GsQLU59bFzw2uK4CIQCt8NGlZSspPLhfqp+bcBTtw/tg\n5fZlCZ2v5Ia7YnmbSQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4761", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4761` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAXRwU4I92T9g1RbN3eLcsAzlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlMWE4MWFkLWU3ZmEtNDNmZC1hZDhkLWJkY2NjM2JmMDc4NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNiM2I4ODEtZmYx\nOC00ODcwLWIyZDktOTA4NmNkZWU2ZjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtSdkI8gMqi/Kddu5IDj3KvJ67DWeNP1i3PL1fBzJnwOApA3q+WglL0LHgvkk\n75fPxBVJJ3Va38uJqKNaA1V8tqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjJrSUY62uCoHI0GOCBjK5WxDFRQwHwYDVR0j\nBBgwFoAUKlj8sGhx7BWEBbEAn5u8fPY5gJMwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJsyj5cV\nZU/5zdPEN2ZClIugB8arqJD+Cp+mcrRykduXAiBBO44A+/eHXLsT30zLZ9as6g4j\nmwl7QkiW/eKK70OuYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbi4Jtxr+h+PezOiDg3Uki4iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTFhODFhZC1lN2ZhLTQzZmQtYWQ4ZC1iZGNjYzNiZjA3ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPNl/9pThCbN2nEDeITYEBKAxCzl/M0rZYQaw/MV/q/R7j\nt19rvOeselruEghAr5wWAmYjVp+enOZG8YZaFihNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKlj8sGhx7BWEBbEAn5u8fPY5\ngJMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPwtfJ22Izqij/4y71ufbMluGBBseO0X3T5IoAdm/scECIQDp+w2EzlNR\niHoxpggY5jplz6ZhcEDp1fR1j38Qpv+9OQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAfb+k9T6am23OxSCf9nPWnNWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNiM2I4ODEtZmYxOC00ODcwLWIyZDktOTA4NmNkZWU2ZjQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWM0MTY2ZjUtN2Q3Ni00YTA4LTk3YjEtZjA2MDYxMmZi\nMGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ0VQw7W+tVBBX4d51wtBQgXB\ntm5fafkR2Sq/ww5f5vZ1y1nLLw+Mtufnh6js6GdHeC0pXgsHroukHWt6rKDpVaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjJrSUY62uCoHI0GOCBjK5WxDFRQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgCXocI2I3\ntBqiZ2VbyH+IkI022xUnzpDptqXBFwbPIuQCID1DCoJt/um3C5n4ER17j/dKdhy9\nGh6Y1vGesRU62an5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4762", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4762` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAcU6ty87pi0byCmc/vTsskzIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0MjNhYTNjLWM4NDAtNGRkMy1hNGUxLWFmZWFjNDFkNzYxZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjViNWI3MjktMWJl\nNy00ZWJiLWI5MDktZDM0YzhmYmJiMDBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5CXeJ4UjsjAhlbQUQ7qnQ+zMRFUgLCKwMJ1an89crLiHP/xlzxa9kHljSOF9\nFS+6TcGGqewtWA1yBd/3za8TfKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8TnmCa/VaHNYewXb/zVzgwv2IpIwHwYDVR0j\nBBgwFoAUGQd7oQ+pnbF0oyk0o7da1dt34IgwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDy9C+q\nnsqAaiNahVAqi8WyePgcpw3e6kTFUCQTZjpUywIhAMmR+jV4KFWCmwCkMENZWW0A\naBayFTdklBY+fnxNip2/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAay9WxS4qw48QYBFSQbw+f9WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDIzYWEzYy1jODQwLTRkZDMtYTRlMS1hZmVhYzQxZDc2MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKyHdBLBpaNpiq/9buHsDO+fr2NPtAleStXAU4Y1ltiKFq\ncqyAlEFGArK8PRh3vAN3lfRMKseFtr5ZaIUThEyxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGQd7oQ+pnbF0oyk0o7da1dt3\n4IgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOKC5Z/cH+gJIgJejRCBJh1Rwbc9XcHhqGtG4uxBKXpeAiEAp8cIZJHh\n2f0ZxNl/SvZgbU9amRQgzZlhswjUPPypsOo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfTheXoH2E61pXPRGOpMXQgRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjViNWI3MjktMWJlNy00ZWJiLWI5MDktZDM0YzhmYmJiMDBlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2FkYzc0NDQtZWU0MS00MWFmLWE1MDMtZmJhNzBkNjQ4\nNjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1fqDLrJbhjnoe2l82eZ7N7sQ\nWH9g5NytVGMMHfUB9xZz+TzOoekFJUSZC4WPZKhufGNlW9UUl2XS4FtCdxJyDKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8TnmCa/VaHNYewXb/zVzgwv2IpIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgeJ7Zjw4B\nsWiaJZXuCCY0KxWOGxVrbcrkCX0OGGK6pGcCIQD5JLvrXzRtqGvnKp4/r9IPdm0L\n0vJ8JZk15Uknc/hgnA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4763", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4763` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAcqP4ax908fV1YiI4HvhykghMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3MTVmODZlLTcyOTItNDA1Mi1iZGVkLWIxOTRhNjY2Yjc5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I5M2ZiYzctMTYz\nMy00ZGMwLWExMzEtMWVmZGNhOGRkY2RiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKCG9fWSntOc7jih+YDHElpHWf5fpzFVxFpCCiH8q4f59HhXNyqLZiEQN7RVD\nUB4HyZsqnSkiJ73V2o6KJtmUGqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGNREpx0KHuJuk+eYARrRIDwZEckwHwYDVR0j\nBBgwFoAUP8koqc7cPQn/CSA/10rfcS7jTFswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCAeBI4k/W12T4SKdhQgyKUuJCH5xLwRAfCuVp8GscIXAIgG8QN06Pl\ntdKJEY4pYomkddv13Td+tidwVwws3nE23Uw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUJEEhZfmzWpqZC6sDEdcFq7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzE1Zjg2ZS03MjkyLTQwNTItYmRlZC1iMTk0YTY2NmI3OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsPiJPfEVDl3jkpgtJUrnhtta/LZHeSf8+gyK04PiZjtL1\nDHYa7qCF09Q1vKYV3kkV/74RO8clsB4ncLYYriI8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP8koqc7cPQn/CSA/10rfcS7j\nTFswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgI98NliEVnmqfHHaNG47eITzFU3v9/z7RgV5mXgduwh0CIQDpKWx1hyaj\nM9KlWnNEkascNOBAMOkIp6E+dn14/w0n+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcR9L9gNfTaOwAsQ4+SbGt4IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I5M2ZiYzctMTYzMy00ZGMwLWExMzEtMWVmZGNhOGRkY2RiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjY3OTg1ZTQtMzc2Mi00NmU3LWEwN2EtNWE0NDNmNTBh\nYmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7rOkr2+gPXvI7JvGNkZM9G2e\n6KqyUWHYxvbJ2a/mqAabzijOZi+7A2rz9yexzG3FatSLP1onUJTvroSWwxyByKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGNREpx0KHuJuk+eYARrRIDwZEckwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAO/T9II7\nMQ5z+Kd9oJuLQNnZ8yQFA86bUEo7dYNANcamAiEArP65VeDg/ZahcNdqR46yhyCO\nOBSRXu1BuF3HAlQmjhc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4764", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4764` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAeqNuYVQxxTQIYJnXHDEAEZNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3YmZhMGZmLWFkMTMtNDlkYi04M2VkLTVmNDE3ZjA1M2VkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk2MjEyNjItMWUx\nNy00MTdiLWI3ZWQtY2MwZTBhZmQ3NjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKKuz2glChOQwtXpIgiav5ttlEm1xrqAFD/DWx1nwcesO6xQWJL0olVVADLUk\nVJoZMVOLD+C6b6fWj3ZC1RtEzqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ2e9tbV9EZKyiaWsMJH6ZcoFl4wwHwYDVR0j\nBBgwFoAUMkOgm+5dvl5Ss/s3OPLB3mK8kAMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIE3+8cNKpFCwamtqlP6oekXDh1jJpxemzhz1bWCMteV5AiATFank5vIH\n7TthBVc2TCltSmA4d61QB4PUoII9ERUOBw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeCHvrSTEWBFIQ0XiKuF0evmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2JmYTBmZi1hZDEzLTQ5ZGItODNlZC01ZjQxN2YwNTNlZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvKpxedyeMFx33+8c/U7cs0M4CC6BJOhEXtBWN45tIUF86\nnGG9DVOZXRkjK3TcsHTfR9HQa+2Ao6vtNKBFXwL9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMkOgm+5dvl5Ss/s3OPLB3mK8\nkAMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKZAZKu1/xZcnYDArtKxDtgITwSfglYZ39/iTJcAKruWAiEAiw7oNEj5\nK4FvbfR/IYDb6PJKju4Ue0q92/CD9G8E1B8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAY9xIkgWROnmJBmVL/hTeeMFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk2MjEyNjItMWUxNy00MTdiLWI3ZWQtY2MwZTBhZmQ3NjA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTZlNDFlODUtZTRlNC00YzlmLWE3ZTItNDI3ZGExNDNh\nYTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEClPV3+JvzQjVPRSCHGZkcJUB\nkMnqVTNFg/5xb3RbInvPhiBYjD7ZRBeYAFxBdFKAmo3EYCab7UlyDVJiBNr4a6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ2e9tbV9EZKyiaWsMJH6ZcoFl4wwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPExyNui\nDof03YApDZWUVfWTnDaV9WicfTBuIwQwi+faAiA9LHb9cQBOyct7PcN945/TqGB7\nIikaQEQ1YwyAbq5BPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4765", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4765` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISASyWYIwBJr4zR2L6rGoyTV20MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZjBiNzJlLTI3NjYtNDZiMi05Njk1LTJlNWQ2ZWJmYjY2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZkMjVhZTUtNTM1\nOC00Njg0LWJiYjUtODBhNzI5ZjYyNDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsikPpwHRrqZes3GVk9gXv0jhp2MHfhuELwR6MuFzVQU01hanOh9t34VLy+Cz\nWobEl2v/mNo7+1/SP5LJ66Eb/qOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQoU36qscCvm2wQxaVDIEtDkEb4MwHwYDVR0j\nBBgwFoAUrQf7PljeMVhtq4CCKTGZ/5hCI6EwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIEVz5CiiHFyKGC172XQxzVs/9gFcayJSycMIPxy/hHepAiEA60q0og5WMCPAg2aI\ndeaDQcuCPjCFqumK/ao5pSkx4Vo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW00+UVoxiz7ZzS5wVjoeS2DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmYwYjcyZS0yNzY2LTQ2YjItOTY5NS0yZTVkNmViZmI2NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQH23B/EKQCeULNLyuUYGFFrmRS9vVwaq8978PB7eYJ8MQc\n5q5lq1aZujWIpzHre2yMyHwbw98RsGTEmeRUqo6Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrQf7PljeMVhtq4CCKTGZ/5hC\nI6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALxnoJzqifmvspSVr0Xfk5XmXzHjHIEkQbXTdHRQcr9PAiEAucN98v8v\n5R/3+qKmnBq7IylRKoMFPh13GK3b5roWm+I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbIsyzt7BlQGq2TpPiVhXMSUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZkMjVhZTUtNTM1OC00Njg0LWJiYjUtODBhNzI5ZjYyNDY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDI3ZjBiZmItYzQ0Mi00YzNiLTg4NTMtYzMyMDc3NDRm\nOGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEupHayktFIPLUDfwdVV1gQz3V\nqWIxXwvwmEQHEvkU4xL+gTQOQCE+8O8/qKQPxD7h3ANxIk09a6Ted78Oq918G6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQoU36qscCvm2wQxaVDIEtDkEb4MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPJZHWHA\naZcJIW7EQX/pcP7+gbS2u9mUCZ7nXVx5EZ7WAiAiT+373C11TY0i1ISIeK3PVolx\nPisgAYJwPHmDKPRm4Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4766", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4766` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAdC/9lPQTvvsPDIb0YwtKq7MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4YWZlNTA1LTI2YzQtNDI0MS04ZjY3LWI0ZjBmYjVkZGUyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVmZTA0NzYtNTI0\nYS00ZmUwLWFjZDItMTg1ZjJjMWViMjJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8XffNT/CVpxUf4FnA73L58Ty06FMEy/Y4aZKe9VeoUq1Fm4MYVMEOZDcYS7t\nFI8fTi2RP3RIrV0cuXBN0cJcfKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4+LY+DuHZ9hXZ45V6gpoumKgluIwHwYDVR0j\nBBgwFoAUhx6TXzR/HfjxEPsjxW+wSwplGh0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIEk4hQFhsqTw3FK2gibLoRXEpPdQgM4HGDRH6BWVn8zIAiEA\nkT7Ww2GeTQMjVl6wTDiEhwM78hV2Ds/3Zo4Wna4Wy+U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV1qnyWz+DkvgjzuA1p2KobcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGFmZTUwNS0yNmM0LTQyNDEtOGY2Ny1iNGYwZmI1ZGRlMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYcYNRdhfwQnoRbssWTwPtVvwLVtJsk5GI7/BQ8tegx96z\nTdY2lC/HiXq6DDhNZqzX4lQGTnAqOnFKXvV49byso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhx6TXzR/HfjxEPsjxW+wSwpl\nGh0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQj8RyE6rB9qx2RWXji0z8sMFYZ6N0VceKuLgSl9ip1MCIFG/ODGP2G+R\nFYewKvwfd92y/W1a7hFvMoy5nBiQ+izt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAbQzEID+t24kr0RknPvhbYSsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVmZTA0NzYtNTI0YS00ZmUwLWFjZDItMTg1ZjJjMWViMjJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTY1NTA2YTUtY2NlMi00ZDRiLWI1MjAtMTAwNWVlYmQ2\nNWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEakRFiI0+ZOqiyqDorxg7K1uk\n1vSTRvU6Ldog2+bWOF6yZvMr3XtcXzGdbyOdSWRA/YgVbuBLftljXQ86p/WNb6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4+LY+DuHZ9hXZ45V6gpoumKgluIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgbTdM9Tpa\nbP0CY6IrDWpAf20P9bdweOkH6D5XBPEP9kcCIF8bXmC46HC1bm1Qa2PmXj0J3kca\nrKFppEliFhN7SX20\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4767", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4767` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAVvzRnZAZ7fSZdAbtLI5r+Y4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3NWNkZWQ2LWE2ZmMtNGIzYi1hZjYxLTIwNmRmMDVkNGIxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI1ODQ3NzAtYWMx\nNi00MGI0LWFhMjctNDUwZDA2ZjQyYzMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErd3SvCkwUnAsTg4ZWK7qD24r6bOnVJBXMGvEJ1fbcUlOXgKuZcNTGt9a0C+X\nTrwnkF+V2N1PO+RjVVn9TSwaWaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyh0yPJFOZSRkTdeQnaa2ccvUjr0wHwYDVR0j\nBBgwFoAUQRbuFrHYS0ZQXlxnNn9dQZRV3B0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCBbGMARXkg0OVoMA0LJhocbzW98K2HuLiFm2wLppPa/wIh\nAKrgyPapGvudHiYW/ohJRO06XcrVLXOWR2RmWJrr1liV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfrPuZCcjr17gcDUpMXktSyuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzVjZGVkNi1hNmZjLTRiM2ItYWY2MS0yMDZkZjA1ZDRiMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqvDDwExT6Rba8SU1a5b7jlY8NDNMe/Jrz4/SZ8NAMNtZo\nvr7bVP3yD6JXpdDFz9+U5XDMkMftrgnO2EJ3C0rYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQRbuFrHYS0ZQXlxnNn9dQZRV\n3B0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOdnfuDUk3RwFZmshEXQsi2SuIhRL6R7oiYuH5UfDR3TAiAVIyfv1tK2\n2htH3l5S9Pg39UHxD/s/DP4vO8J2iU5F6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQdMKRaIA8wXRe0cwykuPj2/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI1ODQ3NzAtYWMxNi00MGI0LWFhMjctNDUwZDA2ZjQyYzMzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmEzNTZkMWItM2JmYS00Nzg0LWI2ZWUtNjI3YWRiOGY4\nNzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmAviv5kvu3OkDtJxIsMsviEg\nzXw5Mb4twlSImpasz+b0yuvazLDu3I7ChwlW4fdk+BB4Z1RjUpa51FjHv5oYPKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyh0yPJFOZSRkTdeQnaa2ccvUjr0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIlAJbVR\nKGi5Vp85DpCuMuh1rAZskzw5POmNKBD9uWqHAiB/tmGBU7BFyuQU/bOLujY6irWD\nrOiT73So+IYqbWnnrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4768", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4768` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAeb0W7XAPHj5frnR7FYmfUK5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2NDJlNzg5LWQ4MmItNDVkYy04N2UzLWI2Y2ZlNTE1M2E5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDljN2ZjMGYtMmRj\nNi00MGVmLTk3ZGItMGNmZGVhNGNmM2Y2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZYN6fO0lkYGhiV9qi+ujrkEJGM+E53a+7eJuRnbNXEYmOj5aygggMKqPCPub\ng3Oj99LSQTxE+wKKVKWynDHPI6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU++ZBAUC+f5Qd9OEijShJRWczyMwHwYDVR0j\nBBgwFoAUkX307nTWcoKgqNTmPf0eoBE04zswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBcTwLtbik9r\ntnGtIN3RwuqAAfxoUQJRnmiPthhBV+7MAiEA9gM+EFnUTZTayvM8tlr0z29cxqtT\nrePUl9x7xrhKx9U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWXOf3jHNAGFgHyC90EMrkQkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjQyZTc4OS1kODJiLTQ1ZGMtODdlMy1iNmNmZTUxNTNhOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS353gSYdmYmfGxYZx2HkI5/fPbQVjWcrs56DxWFhZXCk3K\nBDpPZWrSolv55Sa70zIh0qVDu18qmuQNpckWySaVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkX307nTWcoKgqNTmPf0eoBE0\n4zswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCB6qb2Gg2gyBp/sMiYwO/Ac3lOR5TxHQulTKAtIY2GQCIBtgV1GZ60u6\nbSJFXbQf3BDzTkiefBG4s2hsLCK5LULT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfXaGmqoqv8TevU/9dtYnCMwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDljN2ZjMGYtMmRjNi00MGVmLTk3ZGItMGNmZGVhNGNmM2Y2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGIyYzVmMzYtYmRhNS00N2RjLTgwM2MtNTM5NDhjNmEw\nOTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfpPVyoaJmVzGgKAVHlv3Fjon\nkv72qaxOBnGkgD+wNWAaZLVTKgqP0spBVltePh9aFNPm0v/p5oCLj4LFTmL7BqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU++ZBAUC+f5Qd9OEijShJRWczyMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgJI0lEwAb\nPs6/TcS8upc4l9TH0a56D8TfvCEuTmM1Ss8CIQDz1saKjLDGmC4LzRp6AMfOAiAT\nuqG732XgG/mbqwVjCg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4769", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4769` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAagWHnWU9x6pFZCepEHb8MklMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2NDc1NzliLTdhMmItNDdjZi1iZjQ4LWRmMDkyMGQwY2Q2YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY0MzI5YjktZTBh\nNi00YmIxLTgxZGYtMTA0MDAwYTc5YTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElNKIkJ7skUIx7nXPBLVPDotWXWubAK+t9vjF492zus749FFNu/RiqDiLC5Jm\nO4SYen7Z3PlcoJF+SUz4OOTZ5qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSaSwvWTrGexffejuOuFnJS/fKO8wHwYDVR0j\nBBgwFoAUWlwN26vqxhue8zAZiSCHz+4lFcEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJxE5VHZ2D3YFnnkt0Xrbig+CXtdp/XmhG4Qd+jJX/p8AiBS656NuQJa\nOqvv+oGA1WHAqKJB1JcBjqUmI5FV6oZZ0A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb7ePDIx86D3g2cccdm6ldZCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjQ3NTc5Yi03YTJiLTQ3Y2YtYmY0OC1kZjA5MjBkMGNkNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiYKkyYt2tZ5LPFF2GB3V4zZNH4AoQwXFvAUuiGlaUK42H\nGUFd/37+LiZ21gmuMHTjM77nPdcHxpev71rF39ZYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWlwN26vqxhue8zAZiSCHz+4l\nFcEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfDTyUHCwIrzJ6EcSyyYeas24SmKxaJtdufveCYRO8MkCIQCemhfppyo2\nn9ShYu8sucP0hl85zJ8MuMax8Z8vhuH+Vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAbtsVxzgctrD+PeLypG6p0I/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY0MzI5YjktZTBhNi00YmIxLTgxZGYtMTA0MDAwYTc5YTgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmU1NDQyNGItN2JmZi00NzAwLTlmMGMtZjcxNDdjNzUx\nMWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY6fCoTYxiHbwkFkpXj/XiGYe\nspbLCkm2gd+qdMtitd+SfhqmmEYZP8uOkiaYh8XD6QO/Rc4P+gtYDXuqM+CWLqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSaSwvWTrGexffejuOuFnJS/fKO8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgFdziHKod\neQlj9IKsLArQy9LtM8jrJymvk0x7IJDHpQ4CIBTkW7+QaUdwp6kQFG7Clf0tVszv\njsXavIoJUPnvWx7b\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4770", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4770` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISATJ45+/tNLonNjnBAmnAqbFYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiYWFjOWQ2LWQ5M2QtNDI2Zi04Mzk1LTYzYzZmNWRmMzljYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMyODFjYjYtNTAx\nMy00ZmQ4LWE0NGUtNmNjMzg5NWNmNDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUMrCbXoP6FrUKyr/BJdQ8/JVshgwEjXFkH/rcDDVrXLX19m1Bb+ZLDq6gMEB\ng6vQG1FRkgLi1DNZZy/jimvl/qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ppxFR0SVZlAFiZfBHo+/ScFiaQwHwYDVR0j\nBBgwFoAUh+sXiRHfIMEvDScv8FbS3QnVHgkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAP/+8v5QtKcRLShp9ybaPGi3grThFX+fvuIk5fpbNBWuAiEA0SwuBTKf\n/CbrdHOv95rhk6UBv8tE5gKpScd36aay/8g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT4O0uHJZwzCSI5FrvxHhCMqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmFhYzlkNi1kOTNkLTQyNmYtODM5NS02M2M2ZjVkZjM5Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUe85zCHWENyDbTGRP1vEf4nY23VDBztXB2WmWB7A3g8u4\nr5td/dvN5ygztt8a9SvXJS58amG1MZXwr3UVDc3yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh+sXiRHfIMEvDScv8FbS3QnV\nHgkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANEbAEYw14xzZKYauzRkZ2ZEN3RMK3cP03+twJjIo1GwAiEA7kJmArMe\n7joYGoW6tQqU270N38zr4WTHl+xrt7NE9Ts=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfTOjI9PKEO4Bu4kUTY8zRPKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMyODFjYjYtNTAxMy00ZmQ4LWE0NGUtNmNjMzg5NWNmNDNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmZmMTRmYzgtMmI1Ny00YmQ3LWJhOWEtMDM5ZDlmYzdi\nMjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgTGta5kFCBgKMH6VdD/ayxxh\ng5EuMv/1pECEneCfBeAl/D8HLkRbLW6te41C4okfuFWT+/H1KWHNOU86/VF4rqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4ppxFR0SVZlAFiZfBHo+/ScFiaQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgOoZemsuh\nN6isFx60AggUWUOh9kwxa/pUQ6TUOnN3QUQCIQC2OFj6XTsEPLkK5A1a/mn47rM6\nxjptVVkqwtAOTC5Z6w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4771", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4771` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAdgiBQxXcLpB7DSqKIe5geY6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NTgxMGVhLTk1ZmEtNDlmOC1iZDVkLWY3N2ZhODI3ZTJkNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg1MmQ0NDQtYmY4\nNC00YjE5LTliMGQtNjdlYjcwMmY3NWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoJ6HTPK3FzNxz1p7+2sAjRCEi6iVU6V4DTEisJvXUz5ofzKVCPsI748vncPQ\nZ3XSzrj4qM2myqS0eH9Dy9nTF6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPtfsL0/D4aVkBObTEPd7CUrw8aAwHwYDVR0j\nBBgwFoAUrT2oPErluGrfrn+WU0W7WqRs8cAwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIEZMtiM3mvGPtMvpBTOMfoXFOBVGBBZ6SUgJDJAzyNUMAiBKDScbfTbE\nrPdONSrXaR3bcK8BQeiudxQzOhiVpkW2cg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdVKhoxpteKlQnuP4oFHIXdWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTU4MTBlYS05NWZhLTQ5ZjgtYmQ1ZC1mNzdmYTgyN2UyZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLB8lUNwy7fUypB5r1k2E8nswadLszLEPscIHF+Cmuc/Nm\nQ9z/qoinPuNvxUnfq0nazBybs8t6qgBYYgfFEtE+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrT2oPErluGrfrn+WU0W7WqRs\n8cAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGVWFLsVJqPTyAs/LqVrdHjuNkl5bK6NHvt/gKxC3heECIQCjZ9ugHzib\n32s4HTrMQlV2wmOBSxDP4HOhv8un0piERA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAX76mmewuXj0kg07rK783x3tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg1MmQ0NDQtYmY4NC00YjE5LTliMGQtNjdlYjcwMmY3NWU0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ5Zjg3MTctZTc5ZC00MWYyLTkyM2YtMDlmNjczNTZj\nMzdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBGxeh0EkK/cKR7GXGxHGqWLX\ncD3Jx0tfeQr964Wd999MuDM2R/elvmETAiQu/6Zv3Lb6CcvW/GvWdUJaBPqGRqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPtfsL0/D4aVkBObTEPd7CUrw8aAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgf3mat5DZ\n7GPpSJJF2UV8oOVGPK1dY9QES8pMLTPiDv4CIQDl5KZR3HtXzEBJIdxyKud7GZJ0\nEZEA/0DvjeFO4pBBWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4772", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4772` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAcr+xyn311xVmbdsr9L4yDJ7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhYTY3MGVmLWI3ODktNDBmYS05ZWE2LThkYmVkN2RiZDExNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM0MzAxMjItOGQ5\nMS00MWQ3LTljZjItZDA0ZDhmYzc0MzY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElyActNoA8UIFlO8pit1EXiDBrKWYYiAUkgMyzUuTeLpD5OnNGdyKQ0ihjIjy\njm0eIOCgihCOidfH7FVBRneQE6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy9bBjCMTDLuNb0EsFZTwbsog3KUwHwYDVR0j\nBBgwFoAUl5WcXG7SSfMa1jATofA9e/naFPkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQD7OxomWbtMKdBdiLQ7NJo7VmItuYBSeKgtmcmy\n8eH2zwIhALtrjxSo6Sk+CHKgwEivLWKUtYrnSNf5Rwu0AWcCHyqk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfsiuZCOFxJIpWZfzktjzd4CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWE2NzBlZi1iNzg5LTQwZmEtOWVhNi04ZGJlZDdkYmQxMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOIDHcj+HgpNhnNZOSoxKRo25lH8RTbtgj0ZgfESqEiBe9\n3Emjtg4YpJdgzs8CSthAIGtO59LN/g7XWsLgRGuOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl5WcXG7SSfMa1jATofA9e/na\nFPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQKuyKOcLueBPQnWSwU/8wcBVbMK+nqSNiPGs/6QJc4ECIFozBxX3rA4M\nDikM3PZm05VJGDPLzdnRt9oFA3pOWFeh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAf54Ybbal6zYKs1H5UA1mRVLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM0MzAxMjItOGQ5MS00MWQ3LTljZjItZDA0ZDhmYzc0MzY1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjZmNzA3ZDktYjljZS00OGFhLTlhYTItOTVhMWY1ZDhj\nMDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcT4KkSnCsrpO1RbGh86iui1Q\nCbT8DdfzDTuq3IyII4NPbIRc46kiqvd075CELi4HEaiPZInRClK7j77oFdM+X6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy9bBjCMTDLuNb0EsFZTwbsog3KUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgZs9NZQ8O\ngPzvTPP5VizIDa2oXLpgM2q/WGbQvwwMfD8CIQDZ0nFtT8ahm9vIU4VsEBcA1GRo\nA1OCnz0ogcINYvD0Yg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4773", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4773` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQodDg0+BZwqHO4E52DRG1HwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2OTUwYjM3LTA5Y2ItNDdjNS04NmRhLTZhODk3Y2UxYzZiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU5YTY1YjYtOGJi\nZi00ZDI5LThjYjgtMDYxZTlhNGE3N2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkZu1qV/58Ypq6/2Tg6JQ7IOxVnipSAkCueDJ2HEjQEJUghWeB5Ny2eE19Ld0\nnp1r0oAUTilCbIvfyC6tlQd5g6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG3wWwwN2AZCXpQZ/Y4Uf+TjVUC8wHwYDVR0j\nBBgwFoAUODuSKy7xVXa62mXY4gTZAXVjkP4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCuGs2eiKmnDGXcnNY3rHjsMo9XkdvaTKm/twBk\nqr6ydQIgKj1DWpUGd2bUVuIoLcnbe4D3iPzYoX1OMnrcxUAwilk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaJ7erU6ip9/5JKUcY9GLO8EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjk1MGIzNy0wOWNiLTQ3YzUtODZkYS02YTg5N2NlMWM2YmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/vAUGLVF+7Yo8aD4d/7NbL1crky50FLlcb+bJCFErvcVb\nmZ+RLXXvQ1RmqVePWKsjVneg5PpFk1OBfVgcy5qwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUODuSKy7xVXa62mXY4gTZAXVj\nkP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP5bfmH2fZ2ydSzf+nACxQL+rIimvHdavPxej/IselSaAiEAkmCJtwdL\nYMy9LzuT9z5p82F1/EWmchvreBMhLh+1niA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdJxqA0+RwSLPJgkoB3USUWSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU5YTY1YjYtOGJiZi00ZDI5LThjYjgtMDYxZTlhNGE3N2E4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGI4Yjg4ZTYtMDU5ZS00ZDI0LWI3OGUtNmE1ZmZjZGYy\nN2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvrKIuopu6JU1a9T6tKcy7jzm\nZXOSrbwP8r0jti4x/xqjcxTjVFCm1p4xynzg3Lf0dNGwShj1mbQhQ24oZ3PjB6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUG3wWwwN2AZCXpQZ/Y4Uf+TjVUC8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgBd9NIaGW\nwtxEfDmc6U8lM32y/Oq/Lo4JePnBagurVgUCIQD96ORScxpwrZuSOV0ES0Pp5o7k\nozVcernIC+tWs3h8/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4774", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4774` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVEIUf7s/Ekl7LmJFonAiWFjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjZTRhMzZiLThiYzAtNGI1YS04ZTlmLWVjYTVhMjIzM2JmYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU3ZTRmY2UtNWEw\nYi00NmRiLTlmMzUtNzFlYjIxNzM0MjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzulEVbPTDb+Wqzp2ANs0hxQ8fWHGGCsu0wzheziXJ6TguwrhxysrzboxKnkR\nhWX2W3OAnRIqHUEJmiQ2M4bKrKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFcooF2qm2ZhplX5WZiWW+a2eyxkwHwYDVR0j\nBBgwFoAUG+f9lRYncDSwHD5U6j2sBd9LyGcwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCICUCKK8G7trQazNxIlVE7SAW/fx9UttU5K1QQyeXh8qoAiEA\n1JzN77mdMOon396WhSB9oyHfIaPPLEl7hlEXp41o8sU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaA6/ZjuSIC5Om2z+QtY+/T5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2U0YTM2Yi04YmMwLTRiNWEtOGU5Zi1lY2E1YTIyMzNiZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARX8g8KVj15NC7UADaQ7bHB6Uoi+eCzYJ7KDY0IbQHnsAtB\nMLlX68VuhGmGHoYJaskgxQJo4fqT1Ga8994QEIaDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG+f9lRYncDSwHD5U6j2sBd9L\nyGcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEWVsb4nzSKLqmGidRCQWA3AG4ekCXUncBH9edCmqbCkCIQDNR1y1ptCM\n6pTV+Pfo/lY8aA/W+y9zZ9BuqLsEj8sWWA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXDrvaBNpih848aO1GC7ewG9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU3ZTRmY2UtNWEwYi00NmRiLTlmMzUtNzFlYjIxNzM0MjNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODE4Njc2OTktODU4Yy00YjMwLWIzYzAtOTBkZDI0ZTk3\nZDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtql2MU744JrXLuIUHnB/iMPR\nKatAYkvb5oLN7ZwGot1xsG94Sr5sH/5Mpgti2ueDc9naP8Z5mDql4wOuUOhLGaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFcooF2qm2ZhplX5WZiWW+a2eyxkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgLwK3EjJX\nAgI8wu9bAqi7Ze3R81E5Gvz6AZuU0ZNJ0ooCIQD5jv7BYe8GbDH1R3wQoRulUEHw\nR4a+xoKO3Ab71DGELg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4775", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4775` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAU/nxifFphkUb5X4D2KwfVUAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NjdjNTBhLWY0YzItNGUzYS1hOWVlLWY2YTk2MzlhMzNiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc4ODhhZGUtZTY0\nYi00NTAxLTljMTItYWIyMThlMTEwOWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5pEs11brGvIn/oIDRpZUpmAKrFGHcUd7VWja2E/wMFzcMPkhN9x2wSPv7CIi\nx+/Tv4Y3lmeaaT7KUM5WQbC6/6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZba+Ct9urq+0exq9JUSkU4kD+b8wHwYDVR0j\nBBgwFoAUFa4/yo8DAtrwZkIHOuDk7HOM/cAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBQ5JhS1KCAz2hecq+GoswgvdJZwP1wz\nHBRpnvH+romYAiEAv28/S8/NEE+rcP/OFXm2ptVI6lZHby6OwbxmpJroE4E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASBR2uJsfhok9qCeQUFHJ1lEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDY3YzUwYS1mNGMyLTRlM2EtYTllZS1mNmE5NjM5YTMzYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvsm+ezifSs/5H8JyDRiBETNM3MKi7226ajE+PmPgKV2zR\nENzya1/JltwxvPfKoOXbVDbk0ED3m+zUmz5o2uoZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFa4/yo8DAtrwZkIHOuDk7HOM\n/cAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPvzFxyWZQStPPl0byp3eAOeq0Xamr6CJ1wjTYM9Bg0/AiAdqzXnQmXv\nq9skyZfGXTC+0STsZaN3CDYgQWdBknhb5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAUsyX6Y3pnDvan3E27IfdskfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc4ODhhZGUtZTY0Yi00NTAxLTljMTItYWIyMThlMTEwOWQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTk2NmNmYmEtYmVlMy00NzIwLTkzMDEtNWMxYTBiYWQx\nZmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUbCvNcSU2Fxde8DltkNwCquv\n2GZAupDXkxbNIc3H+zz1yWyL/3DWYxLhBn/L8A7niEFzSnYfqVZ9djWX5nbqQqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZba+Ct9urq+0exq9JUSkU4kD+b8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJ4i4zNi\ntaNIgRX8GEABJ/QTDlW1M0ccklHawws93+glAiEAqpZAImXE0tCSk0SQ14mDKowJ\nn9NQhGhNCX5A5ZEfYFc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4776", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4776` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAZkXkNFJhK2sXYmLgBmgZf8eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NDNhYmI0LTU1M2YtNDM3MC1hZmUwLTI2NjlhYjUyNTNmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODkzYjQ4NjUtOWE4\nMC00NDBhLWE4YjAtZWJmODJlZjdjZjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER2PY2+oslC2RP+Vl5RiMhHldbG8Qji8z5EYakfGpoPuIXnMu910LjjvxMJW/\nYdynHrTbXjJPp2DBRd+0X0vVrKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh4TsNaPT96QbPnP8NfA2ih5uX1gwHwYDVR0j\nBBgwFoAUZoqAG4kL1PQf0eFBxHAcGS5WvaUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDgtaVBrbAdnSWjBB/TWYqucxlkU2G5\n9eghubmnq+X8wgIhAM3o0o+AQwIspxlVHYmHBwRCavSUFP9twluS80zeXpEb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARJ61dn5Hywabqz5mjdUnTBCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODQzYWJiNC01NTNmLTQzNzAtYWZlMC0yNjY5YWI1MjUzZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYG0peNAUf6n3NNgiAo7Pyo1aV3GSUNGPu87/PZLz7Vf1z\naU/7S2CN4XLjPORhBeG0IQFwABr6uJ79MJB3ULE/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZoqAG4kL1PQf0eFBxHAcGS5W\nvaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBjg7cFdgj5vODufbAO4U4YJgNW0GAxnS8maUqMejHwgCIAkxY8voSJBK\nPl0/5TK9LctMH4oJ3YkY3jHeXlOK0K4s\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZ4mH0UEehb/MUl9KY383JTcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODkzYjQ4NjUtOWE4MC00NDBhLWE4YjAtZWJmODJlZjdjZjY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDIyYzBlMmMtOWZlYi00NDZmLTg1OWQtYzkzZjhlM2E2\nY2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfdat3gKgvwiq+YuB8a6QnGOG\nGWv/DKu9BqtqL0u90kmZgYM7ocU3pmtHXEqIdLTUyAG7JUwyYRNu5YpYah5AR6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh4TsNaPT96QbPnP8NfA2ih5uX1gwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIy73b+t\nTh30pSQQHpOYq4UpMY8Sh2+wweTYYcX4LK//AiAT49ozTu+RG4ajEpWy21TKRhHw\nHFK2EdfdCO9BY3MC4Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4777", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4777` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYqsqb1qaHWq+oTHGGAHCMRiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkMjMxMmY5LTE4OTgtNGUxZS1iNTNlLWFkNDRiMjVhMDRlZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVjMjU5NGUtNjJj\nOC00YjU0LTkyZTUtNWQ5NjAwOGFkMGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZmYWD+wH2a685e5sucOZ9+UuUMoLCbZVWgrRwOBmOLma0KfVIG9WV8KZ6X1P\nx537uZKedQDLjaJoqDh6luxoUqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+yKdkhem72hpczYCXNQVXbD7f/EwHwYDVR0j\nBBgwFoAUOmXAJf9E1MGdxf8jKjHP8DCh63kwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIG2MdfS+fUai\ni8LRU7tppqnQunYD5/82MkxOmpO2WQk4AiEA7EWRyjXyH+cPsF06LKhB7zg+WbCr\nD5sTGe2CvaT2xsk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAek96RDmJgMyp73AOxirlNHRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDIzMTJmOS0xODk4LTRlMWUtYjUzZS1hZDQ0YjI1YTA0ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtJdyzKzrYfCF7/QdlN1LA7ElQDPwd844yzMio7HKade3p\nyvHeEUITLs+VXM8Kh0ijUOcX2Qoq+/lkdkTXbDVQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOmXAJf9E1MGdxf8jKjHP8DCh\n63kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP/uTt5F2QbXEh3S5MQ9vKgiVaDV2z7yrTRiUT9VZpuUAiAzoHjL2VFG\nytiYy7FimJ39SxMg+QRbKDU9VFa68fi6Yw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWcIH3qV9d0co8cHuD6RVrExMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVjMjU5NGUtNjJjOC00YjU0LTkyZTUtNWQ5NjAwOGFkMGU0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTNjYTU5MzItZTg0NS00OTZjLTkxOWEtZWQxN2RhZjM1\nZWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJHczWGBFCei1UNB0R5l4+tro\n7TZdlo0/wg+GGfsBtKmslLT6vKzdsbwMyMzZ+GKrP5wz0Tr95+PGD6FINLJNMqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+yKdkhem72hpczYCXNQVXbD7f/EwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhANSdC2Yj\nFCeUqhPqEzW0uAexTvosay9PEM4e8d+6nAPmAiBXw7IYuyWrxmrjcWnezeAN8xH0\niphKVESp4uj5iPh9Rg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4778", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4778` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISATtGk0gh7jrU6QfXDVAPEKGVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlNDYxM2RjLTUwMTUtNDU5Yi1iNzAwLTk0Y2JkMGU5MGQwZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDMwYmVlZDgtMmZk\nYi00YmM3LThmMTQtNmNkNjdiNTgzYzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXqSxqAUzhsyQqSwTsLxp+LrwFBH3tkvcuhmWCbkCwxsKiWO6TUINcxoRYp6S\nYcn9+Ybd6caMPViLDaDo9zTBJKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXCkHqgRKcZBK226V4z65FgqQT4YwHwYDVR0j\nBBgwFoAUNoqycwNzm3HbQxgF+0xYsHr0W08wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgEKv0sWwJIhLvQQRyM5o3MSEDcfVvX3W+nRIpCOHYaaMCIDm7C6H/wXJE\nuIoWzGTN8lQsBUYbYAGCPwTTv8B8xHOL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARQLZLyK6FEEFprYBimxW2KFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTQ2MTNkYy01MDE1LTQ1OWItYjcwMC05NGNiZDBlOTBkMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiSin4VPTdWhIgJmILpFcxSuZcIj/hD151Ym7GzvKA0iss\nA5iizEN4Xawb5D65arfsvF4I5BAINcwVem/nTQT7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNoqycwNzm3HbQxgF+0xYsHr0\nW08wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAOu2Qv1B630upUWMCvS+EnrPyAVTp3l6a2/gSh5NosMCIC2KwR5vMcGQ\nH+C8pZLMqYa+2nphjulVRLNIl2xc9nTW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAav07n+Yl08ldQIwPRLELc5iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDMwYmVlZDgtMmZkYi00YmM3LThmMTQtNmNkNjdiNTgzYzdjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2EyMDQ2MDUtNTkzZC00NDA0LThlMzAtNjM3Y2E4NTI1\nMjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6xMIbPSyHi0pNl1CRIU7guNX\n8/dGwzbx8J6Aylq+Umx/KVw3moFRHkRN4HE1K/IJ6dhoRyD7IYWyJfk4L0rOIaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXCkHqgRKcZBK226V4z65FgqQT4YwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgHyN9E/ya\nsI0weXZcjy+e1HbNKy0AyYmqk6ItkT07g3QCIF1umrR1CYVGL1z6P91fInASCPXc\nbKFnlSsgatGF3cLL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4779", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4779` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQQgdiXusaeokC/MaP2YLDfsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NTdmMDNkLTZmYzEtNDBkNC1hZDdmLWFmMDA0NzA2NzdlMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI1NzY2M2QtNTA5\nOC00NWZiLWJmMWEtNDFiMzE1NzViMTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgzjQwnQHBMCBL/tmmgOXvXWgcvG89L0MB5tszEeOmMZcgEbtexInvicZ+LQU\ngFnEBn3uc7NQ6PaY3nUNSj0jLqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkVaRTJ6JRrhTtDnv5SgiE9+2F4gwHwYDVR0j\nBBgwFoAUvqyD4nL8JiZbxcKMfo/oEJeq6Z4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPBJRfj0uIFS+cyvMk/ZbjDgCsSpZAgasP1hOrNzB82PAiEA+lUw5EjN\no7oXMSalCpeL7PROa30Dnd8omGp0lYCDXQg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb3/GQH49XQEVKRpc/lMYbQpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjU3ZjAzZC02ZmMxLTQwZDQtYWQ3Zi1hZjAwNDcwNjc3ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATF6F+PrT2QT8tZJUBywdUk96QH/1RP0S9F47auDQ60PF0E\nA0heHywNp8iCW8ZMyvepIusQwqwAAeVxeav/ry1Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvqyD4nL8JiZbxcKMfo/oEJeq\n6Z4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgb4HBolsAznz8jROSw6qSyrRlLSY77OcxVfkeUreZWfoCIQCa7O4pIEbT\n+IasFq6iQBX6+WkZAdm5t5mZ2/+BI/Wqgw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXz5DfzXpdv/yH4iL6baKcDEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI1NzY2M2QtNTA5OC00NWZiLWJmMWEtNDFiMzE1NzViMTAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmE3YTQ3OWUtOGI3ZC00YzJkLWFmN2QtZmU4OTY0ZjI2\nMzI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw2B6b4BNezNrvECffHfSN20n\nUzVeWrtONmXBC10la9N/OhU2rkbOlzm6EHvvIfBua4pb77ufnaTB8icNky7ZV6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkVaRTJ6JRrhTtDnv5SgiE9+2F4gwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgWytq5jZl\n3pki7mR0RJ/gxUIB2e8MqUq8l0cY0Ti+2ScCIG+n1zk0svsKCMIa75gYeUKffvhL\ndyLaHYbfP21KX3GN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4780", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4780` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAfQ1+9TS6WhY4dUhOZrj55cyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1YWIzYjA1LTg3MzMtNDQyMC05N2Y2LWJmOGI3M2UxMThkMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI3OTg4MTQtODE4\nNi00NjEyLThiOWYtY2NlMmJhNzQxZTIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKgpPwpEYpr+4PtqoX+bNs+FyqJe2zVEJ5mgFedKDt/Qe+NzIcOsrr2fzvVMQ\n5XYRWjzIDq/+d1TUYG0QCz8vzqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU67pEfNrSAeN5X+Eg3u3mYXqctoswHwYDVR0j\nBBgwFoAUoXYuDTaaM1kOF+Mf1OxW3HM8LwkwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIGqx+Aofkg+hGhWm7m+t+IAxnjFz8CHoaNXsMR8g12e6AiB0vd29b9ay\nU2b00Ehp9biDEGRW4/nBP7mWj0i31r49Qw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ5VVUjvAZ0Q+i4jNY9GJ22vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWFiM2IwNS04NzMzLTQ0MjAtOTdmNi1iZjhiNzNlMTE4ZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOTqO1FW7mywGd5cZ6DbYslY8X9ZjtlSa2ZTre0p1bYFaT\nRCvKxV7gsV8u1mv0UZgqIDs6OgFPS/4OKk6rpTCmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoXYuDTaaM1kOF+Mf1OxW3HM8\nLwkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOM2F36+/+4nR/k/8NkPBri8GwuebdBTUL44pkQwt+9tAiEA8BeBfskH\nfXIWPRBPHIvrDTXxIZqTdgoR79aWHeCeluY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYLa4cmYNbH1dv7yNi4jBg0vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI3OTg4MTQtODE4Ni00NjEyLThiOWYtY2NlMmJhNzQxZTIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmI0MjRjNDktODRhYy00OTIxLWJmM2YtOWIwOTA1NGM5\nMmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgt8f8uvdgtXzwtlyIEHO1iBf\n+mbEjpll9OEoghrDhl6Aw+Zr1itZhd75OXX+wMqdDzZp0Ezqspx96jjzEXxgFqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU67pEfNrSAeN5X+Eg3u3mYXqctoswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhALZBDnZg\nuXX7eFH8I5Yv9upgVI0lSJ/I+ES35WmZRCxTAiEAucJsfDl7aDleolXU4c3kWwdN\nsIZz/iEKRKFFIzKDJXY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4781", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4781` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAS3EFyCGLW25bMvnLAW8xQQuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMGQyYTY2LWFlNjYtNGIwNS05NWJmLWE3N2I0ODczZmVmMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNkZWMyYzktZDNh\nYi00ZWRlLWE4OTQtYTdjODJlNjdmM2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7d6DwoFl01MmHBVb1EkMQOfJYPARJh/cgUcOJKnJuDWaszwutsAD6EuU8Lbj\nO5YzRf2xuon/ibr+mqcWLqcWLaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzWQX3jSwTpBSvJVRpoKKYN/iqoIwHwYDVR0j\nBBgwFoAU01k4oYWrRjxHXoaoJH+QzaLy5B0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGP8kQqNUcgaAaElDLiUWgZwq6lYYVnOrH/+SdMV\nDUAnAiEA5X2ZBzVVOKtEK3Dl8Wv3bUT+E7/A9A1+wJz0giVvfqU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARiB3mJq9V7gdJM2WIuqaLg6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDBkMmE2Ni1hZTY2LTRiMDUtOTViZi1hNzdiNDg3M2ZlZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAGwwvQXpZRJ446XYKRUtBjRYHrsWYM4KZ83S/1gUViU/h\nu9E/7YWdxyFFiA6kMkx0xgzk7hYHj8nj2aZNPJOoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU01k4oYWrRjxHXoaoJH+QzaLy\n5B0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMfNCy4SO4kRFoaGu72UvOzzf1UBXuHDRpS9GkcX0pc8CIDdCctvvhuAL\n112sbuRyCeT/GC3lDD8FbeK5uVMIdQUN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARz/I3kv2B5Yp2vPehxxPYJUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNkZWMyYzktZDNhYi00ZWRlLWE4OTQtYTdjODJlNjdmM2QwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzkxODJhYmQtZGJkMi00OTQ1LTgxNjktNjU2M2ZiYWQ4\nMGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBbFZR4owP3bkyqUnCMcR6v5A\nf0nNrAyhU4tEqvr/Wd+bSntTEYK+/aA/mUw1aV9BNizFAs1vVMv8tlrou9wLQqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzWQX3jSwTpBSvJVRpoKKYN/iqoIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAL0KT/Ml\n6hZNYP5HUUWOUawn75xH3BGxujI/6NFuxk4FAiABgOhwUtYU8Vb1JTWMDAiWqPAK\nVVl3MOuBezIW8nEUPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4782", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4782` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAWxFR27d4Kk+JqFKtIDAQ/VcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1OGFkYTFkLWY0MDEtNDAzZC1iMTE5LTRmMTI2MzQxNmEwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTlhNDM1ZTItODdl\nZS00YTdmLTg5OGEtZTllOWVlYzczNmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZqMdJoYIJsc3rWKZxijepJ6BKTiz2TIETFoc7xrsLjt/pNp0mXPpweF+LN2J\nS/XQj0/PqqxL5MuDTXn0Mrh3MaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq9MA/rpI9MOqfrWE09KQr1InVgswHwYDVR0j\nBBgwFoAUEl7afDks711jDacZAyaJGQTLaPcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCqplLK5uiCfggaF2bzxFjnPwkaBerpSuQPYyur\n/Cw8BAIhAMHBcnSr75kEoTpQs4Oylv43mTYu0ViX6OItaNhwpQw6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT8m0Mqw956gWdxDzgE84gCFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNThhZGExZC1mNDAxLTQwM2QtYjExOS00ZjEyNjM0MTZhMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScW6zfZ6Smb/VykrAGBe8E5kxLWic7EYgfumP9Ff9o4sB1\nSFhcGNXrw/sTJvmREsvgXkIMelpN4+gYaARI/Hrvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEl7afDks711jDacZAyaJGQTL\naPcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeVwy+l4TR4Nk5xiodUR7TJOdQtp7hc/dyxie/nRg0D0CIQCMk0ApS4P1\n2L0bNbZEXCIe1objNp5+1Uk0Nftq96tWzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAVG7D2EwQl3vzUEccXiJ5vPbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTlhNDM1ZTItODdlZS00YTdmLTg5OGEtZTllOWVlYzczNmVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODhiNTNhMjktZmE2ZC00ZDk3LWE0NzMtNDdiZWExODA1\nYmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ42A4rsgnXL4JD0zGVUAFurJ\nO+/2iibqyUxWsqUUdP0iJWDc4GOe7g3QEmBO8l7bDk3HNI5wY4qcPMCNbsD8b6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUq9MA/rpI9MOqfrWE09KQr1InVgswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOk0P3cJ\n9+4s7vjebBBfrtHL/iPm5rLfEfv5e1vgZtWIAiEAiXYBVIzTuxemTeWxdQKO4rL6\nu3MMEC+kZTU7nMKFKwo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4783", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4783` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAWLbK6zUwx588U652QiRKr0xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwYzJhZTY1LTE1OTUtNGQ2Zi1hMzhlLWY0ZjQyYWM0MTczZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFlMzRiZDctZmFm\nYy00OGFkLTk1YjctYWUwZWVmY2I3MjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWNrRoriVypvLMWes+IKBul6/7H7YYAUaJmfe3osrQ8bf1sQhMpsbtzRFdet1\nFEb2pe8/nO13xfGqA/n2dqfT96OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVBWtL7aqrX8VGqXM+nWKej5lsFswHwYDVR0j\nBBgwFoAUwwIMnOE9Y3Z2lFgf8bgdJMvEIFowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIGNsjBSLItqe/nFn+ERvQgd84a41oSzHNJLEfFDm1gF/AiBI\n9rkRkiRtIzMUMIHCZeJEXb+aOknB0PTL7zEanT9amg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaB4/I4wLWRCGnk5G0Tcd5cLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGMyYWU2NS0xNTk1LTRkNmYtYTM4ZS1mNGY0MmFjNDE3M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARResLaMsfkLBe14cChkbMfeFoVydkpI7uLF3KMNi1zJUJF\nSJJVSxzvX9WJhdDFT0JCvwsz+cBlpEbN1U3FxHr+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwwIMnOE9Y3Z2lFgf8bgdJMvE\nIFowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG31+zTDreeicPngwMqcDMfEr39Y2CdogmvkwgNEh9McCIBLXtRvZdMuJ\niTtpYG/3ZqRhdPJ/jYV/4EEWxHVW2Jnz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXIqy24u0rMId562gAKt9IxVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFlMzRiZDctZmFmYy00OGFkLTk1YjctYWUwZWVmY2I3MjFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjEzZjE5MWItYjM1Zi00MDVhLWFkODItMDFlMDVkZjZk\nY2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpGzcgOIpduhRgmnfLLpEyz0u\nWsVAmB2OqcgqVAmad18sGXKZScXjPe7aJRGMiVLoyYOocHSElTVDXep6oaXQa6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVBWtL7aqrX8VGqXM+nWKej5lsFswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgU+u7A+Jf\nOXDYQbzD2xhdE3Su4CjuTQfaeGxF7ihtmT4CIApX+I2JQzkA31qiI/e99BWR4s6K\n+nJmtGmvhZpAhHtp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4784", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4784` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAe2YsTsH1QLLG3oAFOMEDdB8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4MzU4N2I1LTcxMmItNGI3Yy1iNGZiLTc3MDA0OWIwNjFkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjkxMjliYTEtMmI4\nMy00MzE5LWEyMmUtMjc4MmQxMjQ0YWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1CUe88zfpxj/Lty5+iRzVBgDn+DRm1xh/VEl8TGIYsjMIqAkuBXBBtx4KZJH\nJO+xvM2VtEB5FjTUqus45awNTqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpVVDP9QZMkMSZrgI4tULYtJQ4F4wHwYDVR0j\nBBgwFoAU2fMgjBqltSRpVw2Fp3x/NXV8rfEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDDG0Q1FFOqhOKiB5F63dZlDp5t10BH\nr8NYnbKWhBJ47gIgTNReQdr4Yj3r0p+dw2UvvJnr2RWil1g9ANY77IbNWts=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfAimYXJ0MIGuQQWy0OD723RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODM1ODdiNS03MTJiLTRiN2MtYjRmYi03NzAwNDliMDYxZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+Txit58hK5G7GBseQRB3DyR1Stlan6ju/lJqkv95eACPG\ndQr3RCvmb8wkVy1ep3HXxqWjtbyAnkkDLLv3M2ako2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2fMgjBqltSRpVw2Fp3x/NXV8\nrfEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXXlB3FacluHx+MhrWxjR36c2FmJYV73xocWmOcdBxR8CIQDgvT0Eg07e\n+Rjqrl05Q+DlH15kfjQnT4HqOD1x405PXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAWAfHy8+yplWBOWHaKR58pMqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjkxMjliYTEtMmI4My00MzE5LWEyMmUtMjc4MmQxMjQ0YWNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWFmYTVjZTUtN2U2My00ZjMzLWFhYTQtYjM3OTZlNTgy\nNmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVoQh87iREGNGIpWvP2GRrAaz\nSQOBD2o3BVmdA0nALvVZySnH7fi2HXOJ+Vsu0Va0ySywn+xg+AFXgzqKoSDOlaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpVVDP9QZMkMSZrgI4tULYtJQ4F4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKu00D8E\n1fjvRSIURg91s6wZxNZo78i5KHIiMop9TRF4AiEAt605Pwv5NIa1nmamlN2g5OY/\n1SKjjeFDhlkzhc64nbE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4785", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4785` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUPuqZhy44PJwlnAg62ClQOFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxMjg4ZDk0LWU2OGUtNDQ5Mi1hZGI2LWE0NDdkM2RiNGMyMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZhYWE0YjAtZWY5\nNi00ZGYzLWJhMzEtZTg0N2Q4YzFkODJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmkqMr2UyNHePT+1riSasCrQfEzRU+MJta/KfTTYZTOHGDMmYr5JKvHDi072L\nTuhJVPFvxN0FgYvGZLZ1+VazeaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpwcckVS6dfZ6l9QKCQ79Op1Ma6UwHwYDVR0j\nBBgwFoAUUe8pfktBh46yrd8thj66C8jlyaQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCqLgvKDLW0E6BZfK0eS9C8onZi9MHT\nPOcJZIFvM9I+TgIgVb2qWMaKek+APGrccutwsYP0aq4IXAmB0bN9Qw2jS4M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcMJRyBfHa1Eo6kSUi/U8rYYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTI4OGQ5NC1lNjhlLTQ0OTItYWRiNi1hNDQ3ZDNkYjRjMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR/PK+orrE0OZsgvrpSWVRhp52Qdo+zT3X3SJM0kP5yrZP\ns0C9x7W+mcA71U7WTGlXTYHk9KkKhDANwaYr5Dh+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUe8pfktBh46yrd8thj66C8jl\nyaQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNW+MsFHzwTXpsW3+SBA+rLHJHFGLJArnu2Yyf8iVwQACIQCYFpAQZizj\nQaHJk7DcnweG2mjzrzGxCnaIuGs0CEyWbQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAa67CFQAL0P1DBYkbO8n6KncMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZhYWE0YjAtZWY5Ni00ZGYzLWJhMzEtZTg0N2Q4YzFkODJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTMyMTFiNDEtNGQ1YS00NTMyLWIyY2ItZTkyZmExNzUx\nMWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE129fm3aQQN+VzpKTQB4thGYQ\nPzfPvEjd7R1Y/uZqTIEWVjixHv2eqq9auIqQlRmTSHLmFQ2BcMRMNx+dlU0gfaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpwcckVS6dfZ6l9QKCQ79Op1Ma6UwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgPkQIQh8D\nDRZt7i18j5T4kRfCdnT08+ayCVioAbcsqOQCIQDrpsYfNwVvz+Rw37BDlCVn6E1U\nTgVXPE3rbwDjUJHFwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4786", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4786` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASbawJpagf+p1ede6qiEMNMZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlMjZmNDg5LWExNzgtNDNhZS05Y2M0LTEyYTQzYzYzYzdlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWVjYmJmZWUtZDc1\nOS00OTY4LThjOTctZjc1ZmVjNzRhNWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmHKd2GRa4EIxuRnhL47DGQDb4mlNsAay4eUhPaJZtWGnabMUQj0vbV5Ceh16\nBshKwmaXOVLIa60bb+fYucEBaaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOG8bzimHP7OBaP3JmvsiAXe3y6WMB8GA1UdIwQY\nMBaAFKOnyEfbdoAl2lJ8f1nbQD30fZj5MAoGCCqGSM49BAMCA0gAMEUCIQDvSpJZ\nOr+Kb0AQYrKNXf+6kpHuIgK5Ek98HjhoP6+WMgIgacidzjBldFuoyuvR++s7WfiX\nmAeebpc66IZIyqmaulM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAahQcJy7JQQYf1CI4Hr6G6MWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTI2ZjQ4OS1hMTc4LTQzYWUtOWNjNC0xMmE0M2M2M2M3ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGCKDNRiU53eTDDj1jleq2zUkM9UWJQvhZh5zrxl8sE2zr\nLCvvkg7PJ1EV9R4bvGK73HGkZnHYG+oG/nsxxjfao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo6fIR9t2gCXaUnx/WdtAPfR9\nmPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK+mtq6gXhsdGf7Y5t89Hr6tFoT8C2rXebYB11qYAd8DAiEAqx+6eczd\nSTOZcPKwwWvwYxR2fT02cIyOCJchLFcme/k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZNZ4rMwAyOVlPWrlr7hTYRZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWVjYmJmZWUtZDc1OS00OTY4LThjOTctZjc1ZmVjNzRhNWM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTU2OTFkMDktYjE1Yy00MTQwLWI5M2UtYzc1YTM5NGQ1\nZjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEExlYdEYCwLwvG0ryt/qHoOJa\nXF1ZIiHkUyUZN9cCCQRuv9iYzu1v3g5gFIKBdbSXBFIfgShX91X992J4hVocQaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4bxvOKYc/s4Fo/cma+yIBd7fLpYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIOB/4er\nmqayr9zsqWFvRzHDPiJNi5iH3jfccDc1q/uqAiEA6IwEhT4Jd7wMT7/E6S2rMV/T\nLDtNy7USMIADaSzB2A4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4787", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4787` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfse6oqAZ7Coi4PhCPkxEM/bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3YmFiZDU4LTYxMjAtNDc3OC1hYzdmLWEwMmY2YzU4MmY5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQyMmU2ZWItNGNm\nMC00YmExLWFiYWMtZjQ2YWE2MWQwNGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzpN3RHqcim1Q/0TL0+ehRwwFu0ar7Qy114GTbx3bYiuhvHyLlOAYIHu2TngT\n5l/MkXO3pnO/RYM0rxyIgRH9jqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEGTaNZEs+O0yygeQS/rua7uqoLSMB8GA1UdIwQY\nMBaAFHzHHBrlC8UNqec+LHZrLG/RuvGMMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAz6QlmO/83jYgsj2uX0cwqSna9pNsb+9l\nzRluF2ydjqACIBZgT2o7moRLqikzqnk3+kTxDHBtSDLvYivuVqzWvJ/u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaVqp3/8nWggGoa2ecyrl0DIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2JhYmQ1OC02MTIwLTQ3NzgtYWM3Zi1hMDJmNmM1ODJmOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiurOjHX6rXPy+tvS46gp98X8V8lt8vc9k+LhltBmmXX4a\nlerwHztNtFKJiBsPEeATczggBZ3Sgqjz+KlyTF5yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfMccGuULxQ2p5z4sdmssb9G6\n8YwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN193A2dlszeeCmcR+vdqgNcvc8qQ4CaQCYw9b6TwSvhAiBb1PlgfjjR\niKS49IGxc1Btdqw/GWxi36W67n+FeoHZmA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVl4f2Jj8I7MCuAwZW1mGLSjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQyMmU2ZWItNGNmMC00YmExLWFiYWMtZjQ2YWE2MWQwNGY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzFhNThiODktZjdhZC00MjdhLTg2YjgtNjU3YTBkMWJj\nNGEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx15WO7PY2Oij7BdDdPUMav/o\nkdSPfl0UPr80X7TDPgkB+LnICaFwVNVyJ2VihS9AUsqLikj7tOVs+0hXwPnHxaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQZNo1kSz47TLKB5BL+u5ru6qgtIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgOLweDayb\nC7Jep2RnxC5OqG6UHca/vmW7zdgVHtQJ5ZoCIHyUuy37/fizMeUSBT3QD7OiE0QA\nQnhxlo11Uu/Pmm8K\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4788", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4788` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISATCyylsMFJITlJ/MDbTpfBfPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0ZDIzZDRmLTA3MTktNDU5OC04NGIwLTZiNjAxYmEwMDhhMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFlMDkzZjYtYmE4\nMC00ODVkLWEyZGItYzAyN2VlOGZmZWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFyo7u6OeSQshLUteJihaknafZVFn5iFTsWcTnZkOzHICQzQeea47y0dT7dl5\n1Otyc3vHs/pEC1e3PSWdj+PKgqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBJgAm0kM9DymmLrBj+v1MwJRSjTMB8GA1UdIwQY\nMBaAFBqcEuFYmTd/ch2sS+0jP4v45abGMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAYWZpVNAcdTMqDKAbab2DI9i991VQuiioP\nsi6KxssmdQIgfPImqUDySnAFSgWo4wdi5lNAncFCo1HQADeqC2ZLuho=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAatbDU80rtGRHQSL3DR0PTbUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGQyM2Q0Zi0wNzE5LTQ1OTgtODRiMC02YjYwMWJhMDA4YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyAqwZjD3aOYksS7AfC/OY4HTetdF0Yb8fHmBY333MUDsg\nb3s1QYFTfc+nh3R8KmvKGGckO/vHcytjIuOeYlk6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGpwS4ViZN39yHaxL7SM/i/jl\npsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJkTUtBvZV4yK7HYZU+9VjNFvwJ5wTOjmZLrcyjbSV+ICIQDpF/8kKrw3\nNBOrWVztr3Ws8LdC22/umVtMSAHmoiGe+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWCRU4RqHyBbMyQgWhZBnhTKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFlMDkzZjYtYmE4MC00ODVkLWEyZGItYzAyN2VlOGZmZWIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWNkODM4YWQtZjlhYi00NTkwLWFhN2QtNDUwZWI4NDc4\nMGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAqnk8E41BiuU/zJxEewUlTly\n+ElGu/vq+H+0KS5Ev92xgSZt7IaSk/DNokxqh9ah5+igeE8lNd8w+uBhJ8qvsKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEmACbSQz0PKaYusGP6/UzAlFKNMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgS5v0lbkO\nhXMMO901ht5acbCk//aXpZQZrzWkd97ljFICIQD7TgFJFHRsWt/gaT3Za2yrttYg\nCcvRuL5j4saAgDlJjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4789", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4789` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQSSRXCgo3Ook9NYCcA4Yj77MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlMWNhMzQ1LWZjYjAtNDRkNS1iZDY0LTEzZTFmMDg0MDhlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU3MDExNDktNmY0\nYi00YmNmLTg1OWYtYWYwNTIyZGRjZjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH+uUtIlbfpmatnZ2l6uETd0LTzQpOYFVLn5qeran2R84v1O4i6gjvH/fIMB5\nWz6LkcyJeCtOZCPbOr6zRbt7qaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSm167y+haXgU2sPWcjhDVtFfhD7jAfBgNVHSME\nGDAWgBTraQjGedzYNNV/WfvufyG5kgIHajAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD8JNIJAp8BoAPybVoYutSf4DjIEaFV\nEIVDBvj7pNYV2wIgNmaMacTr/AUslLTcQtAUciTlMb/51iLM1am78mS1tvE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW2D9wCiApgfeQSBTBGmFzPmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTFjYTM0NS1mY2IwLTQ0ZDUtYmQ2NC0xM2UxZjA4NDA4ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfxvaGRqMOpVyIppFUXdytOwWcigrO1H3pWz4YPuQfuQ+w\nMoUz3stLq0ynaQrVNqmliO354ZPVnesu3SnbXh0/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU62kIxnnc2DTVf1n77n8huZIC\nB2owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOY7twtu5UKdKnWD3jlyop9RXrnaEN3TDiW1SWHmSgrFAiEAkO1b90fj\nfAjlYifijw7OVQDoDN/gAGiQheRuCqLpoK8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAUZDjq//dcsddU9VIt8JDU5JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU3MDExNDktNmY0Yi00YmNmLTg1OWYtYWYwNTIyZGRjZjFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWYzNmE4YTMtMWU4MS00ZDcwLTk4NDUtNDBiOTI0OGM5\nYjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbvfVOhHXNS4X0zUxQbtAWOBZ\n5fryeINBfkxXjwDTuEjJVfx1YAAofaKFlw85B9C+6eLv2ollNLlQE4nUZkxxCaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpteu8voWl4FNrD1nI4Q1bRX4Q+4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJC/4z7m\nuTOM3kF3UaacrPQFx8E0IFXfMEpiHGMz84LPAiEAhUqP7c9pZi1BctkxTMOKnL+e\nBwatxmp5CB21uQTtaJo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4790", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4790` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAespoWvR39bQ8c6ZX4oqIUuSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkOWM1NmNhLWRkNTItNGM3OC1iNmI3LTRiYjdkZGE3MTNiODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk5NWIzM2MtOGM2\nNC00Y2Y1LWI1MjctYmE0MDU4ZTYxZTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMSs3zlqUmFDpNKdeibTp2V6u4qvhyJOAxOBjxXeygPpwwQtknHPB6ThqMA7/\nWvvMxLt0vZeZxenw/Zj1fXgBWqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGHX77+p7K2c6kq3VveLcZqCv2nwwHwYDVR0j\nBBgwFoAUlnbpqn7Niv/HPVz4PkGJerNYS3swJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA7NYlnglOrsZ/\n5Whaq00CHG2PzmBgDXUb2XxQMmyfUzUCIQCO6km5OJaTFhv7sH4kcz0qC2kXPPYY\npjJPAGEi2vzzcw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZZSwEDIoIbmsfq8rK8atYDLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDljNTZjYS1kZDUyLTRjNzgtYjZiNy00YmI3ZGRhNzEzYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPhJ/8HCJOX2sLrOdNCxqKIm6ferVmqbd1kCHIgAPlArgq\nWQylYppCEREOM/wCo6qRJn8aMteKVyyMkhBidUYoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlnbpqn7Niv/HPVz4PkGJerNY\nS3swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcaAshNWxvD9y/VAMTqRShQQtUAlvVQFTbOh4kks454cCIEla8Z8hIap0\n025DC8wisSdkrQ4oTmeDiW0yWdZOU5Kr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVMDMJFP0Y3ewoxW1RnpQp/hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk5NWIzM2MtOGM2NC00Y2Y1LWI1MjctYmE0MDU4ZTYxZTQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGEzYWFhNWEtZDBhOC00YzhlLTgzMWItM2Y3ZmZiODlh\nM2I2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZAId/wYE1h+n3WtSDe8BDNNK\n6PMWwmlw3hygQHoIIbbhECpNKBRg2p7nN8vSEf3oRXUdR/NcoMvXjEt86O6OWaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGHX77+p7K2c6kq3VveLcZqCv2nwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgccT9h1xj\nuTG1DvdHUqXPCvzMrzAKJYJziqnuKwkOaLcCIQCPLlbupjG28Bp3h1yoF3MJhKJn\nsIYRuIUnfipIxP/FwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4791", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4791` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAYcvMqM7ddw/gwgW0/a60YZiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzOWExN2QzLWQ4ZGQtNGZiYy05OGEyLTM1OGJmMjZhZjJmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYwNzc1MTMtNTBk\nOC00MTBkLWI2MjktZDBmYjdkNWFjOWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF+ItQ7Rakz5ETH/ItMfiLxg8Ehhm0bzjVlXf499NN9C8/rSJzcK42Yix/lDv\nxYhnWSvUyLTNltI9s5YKS1SmuaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBSgG2N45Ja2hlHWfKe9uZXcVME8wHwYDVR0j\nBBgwFoAULsBSONsDPIRQimb7LqqqLykyjAMwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBu/3FeSAfl84Vg\n5NWGdVywDeyfcrpcr9AOaQMZ6mhJ/gIhAOT/+0lAhpNkkYYEnHTTtVRc+/WCDYHi\nx5mGgyezIpK6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR2u5968MF/EgzHiPiHpbtu+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzlhMTdkMy1kOGRkLTRmYmMtOThhMi0zNThiZjI2YWYyZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASG7t8U2+DFGkG15uiEVnBHrw5mZVZUgsApL41Y1byOhPdY\nNjsYVySOeriv+2wev0ayPwMVygZB+mPP5U/05HdNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULsBSONsDPIRQimb7LqqqLyky\njAMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfPAFlaJ+z9QcwvFa7BKNtHt8AasJ7sFtxRHmoBdPa2sCIQCagc5/3Qxl\nPEzh7ZYfEysocRZTOg+tW6AUiEk3xEKKcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAY0OW41SSp95UEJgehu5m2/QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYwNzc1MTMtNTBkOC00MTBkLWI2MjktZDBmYjdkNWFjOWY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTQ1ZGUyNjUtNjU0Ny00NTY1LWEyYWMtZmYyYWZjZWUw\nMDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXyGZKJZAXUA+q5zB1sYuqHbV\n/+7iio4uQhnh5Z0+KPmVdrmqwClcJipriXXE6/kRKF7EElhVugIIDYWV4i81oKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBSgG2N45Ja2hlHWfKe9uZXcVME8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAM9vhu39\nv4jY2Yixu7WM1d5TdJP87/wZKHWZYd2qyrz1AiEAy9ynpfeCizNJPsO6XgzUZGPo\nzNS9fVK818e58aPMq2w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4792", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4792` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISARhp9FVL2neJy8FIHPBtoZNgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjZjFjYWQ2LTdiYjgtNDY2Mi05YTY5LTQ2YTcwZWYyYjk4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTMwOTVhOTMtYWVk\nYi00ZWY2LTlmMTctOWM0NTNhMmQwMjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfa8p7ihanMzYgv7Wye6Twm3BeuOR5YKvDylz2DkRZidw4HGd5fCHk7gvoV6S\n4AGrbmuukJO6k7k6nYcYflqxKaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMBrXB3gpOd7yOoqa4PHY2tpKcDkwHwYDVR0j\nBBgwFoAU+O0Q4TbO48JVWM/cNFKRrUWn2O8wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBPCW2G+r9+DX8UfNKGAqJu\nZaxTKnWDfL/7RVi1zeoOwwIgff+CfRVKSSKJkE48P35mRLq7nNxuFC4lpK3J+vHS\nA3o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXgsZRDw72c/r9BJXgnP5MRdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2YxY2FkNi03YmI4LTQ2NjItOWE2OS00NmE3MGVmMmI5OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZ4TLnjdrSusOA4ABnZUIhjHp6j8GZHP5j4/OM7NJ2O9KJ\nfLuSyyHtkSJz7l3XjUgkMpUthWvZOQgDePSu7QbZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+O0Q4TbO48JVWM/cNFKRrUWn\n2O8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK0KKnYbr7SXm54uATuo8olx50kCbf1SnYVlsEaeock6AiBqS/wcMzJI\n5cjH3lD/lO5t/1AHPd5cL/2DGnM+YprKPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATujexw9X0CQOTBQQkZ3FXuNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTMwOTVhOTMtYWVkYi00ZWY2LTlmMTctOWM0NTNhMmQwMjFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDJkOWU0MjEtNzAzMC00ODY1LTg1MWItM2U1M2YyNjk3\nMDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQ0z1NTpmS9YCa8wr++BzCPEV\nuP3QfL2GsIsMXqiD1X8kmbgVhVn7q5r8RMC7LJav0CxuiXWhRAk+kcfJidw6J6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMBrXB3gpOd7yOoqa4PHY2tpKcDkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJ8N0t7w\nbc3NVVgUwCMLF0LrYAChGlkBduyOyKPZXqwSAiBXzNz+dcZ8RX/G84/XQoXkgJMB\n0hYTAnM6M+xD3yl9ew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4793", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4793` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAQY3jcKMvWjK4w9aB+5d9JiuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2ZmVlMDU1LTE5ZWMtNGYyNi05YjA0LWQ4Nzc0NDczNTNlMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzcwNDBhZjQtNzll\nYy00ZjI5LTgwZmEtZDYzZGUyMTgyNjcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHXZqmkoGqqIOlib8ZQRdHBCsI3acjKN1dP39nUUYUfPHw8K1Ezj3IGZ9+qWO\n1PCvHjGsIbG9ttYk1c0vdWVRG6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKN6W5hg+Mn+4yvjIJ3mlquBPLkMwHwYDVR0j\nBBgwFoAUnfl2vyiYJFKALgTbf2eGYFRhBWswLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBaOdur\nQpZgqlkNEpdJbiC0Qj//gZ26/nibuNcnH19y2wIgbdP82t/Ll1LuGuGW3e26uboO\n1igK1w3i66D/OKOz+Jk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWCepUFAGBH1+hUZ6A/8W5+XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmZlZTA1NS0xOWVjLTRmMjYtOWIwNC1kODc3NDQ3MzUzZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFuu9AE3NhnibVZFGNYMiKMPBISf6rv5FEvNg9CwIYVqxW\nHXyuZ/VlppsROXP3KLQaVbe0Y3R1ApqGPzkssfPno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnfl2vyiYJFKALgTbf2eGYFRh\nBWswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL7LUkG7HKrnozeZIwaHJhM8x3DyA5vsRCKBNpW+5geGAiB+eSauTYzX\nrXV2iT8kC6GhYqNKc0c53ILAD3Sb1yoLVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAY/jKviYYfhPjpRPuQJnxa0HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzcwNDBhZjQtNzllYy00ZjI5LTgwZmEtZDYzZGUyMTgyNjcxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNkMjdlMGQtYzQwZS00NTVjLWIxMzMtNGM1MzNhMzlj\nM2ViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9Qoyc7PHy0ZM0n++BdkTTgDy\nyUFtRspTVVACOf0/Wv8+RXT5XnYhBeEvQw4/xC+n3Jl1O9pNfemRIMJzHvHr86N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKN6W5hg+Mn+4yvjIJ3mlquBPLkMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgMRuByHPB\nlGNzUPZeKsEG3GIdq/+QdjID5a8pZymptFgCIQDlQ/u+Jrs6fxSyWNNhnfnhyc4o\nGFR/Um9F/JVHZKK8cA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4794", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4794` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISASbIszk34G98XVABqbz0R9njMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4MmI2ZGE1LWZiZDQtNDljMC1iMzlmLWEwNWNjZWI0ZWQzNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDIwODVjMTAtYTAx\nZS00NDdjLThjOTYtYjFlNDRkMjYxZmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqRmQiAhBfSsKuTvzVOJZiF+l2aOQEZJK94W3DEDxwBclF+RBJqcIWr70Px5t\nYQhQubz9doEn75TLxEP13wV9pKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzrqEqMPOXh+rcWZh1KfelN+Vpe0wHwYDVR0j\nBBgwFoAUbca/KcJTPvJKuZ05RakMDS5yePowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA9g6eq\nhNqgCGcFo/rYEQmAVJVKErCxs8PUEuhhPA+XhgIgbSOcFP3uiOfC1rB1KvSTc1ln\nqaYyu70h7VaoS/V01y4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQOhmR2hiG43GlUCbKZ/ZejwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODJiNmRhNS1mYmQ0LTQ5YzAtYjM5Zi1hMDVjY2ViNGVkMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsJTHn6PK+Rnyiv7fMUCVs9mSovnJIglM1uLccRbDhBkLB\nNLVpYgOou4kcGUI8vhzMP5GaBptY5vbierJ1bKBYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbca/KcJTPvJKuZ05RakMDS5y\nePowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP6ku0IPxoua7VKS+pwUZYVTa+5qSg62JnF/zORuvhKnAiEAjX6A9Ayb\nL8NG9So6mf1r1vbmmGJwpPHTQCCSjvNssMU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAcCCLNBI8BmPm5kWNKldK/sIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDIwODVjMTAtYTAxZS00NDdjLThjOTYtYjFlNDRkMjYxZmZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjNjMGMzZjQtOGVlMy00MjRhLWE4YTgtY2U2YWMyMGQ1\nODMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOfeUOKsx2iT2GbrENc6ATHlz\nnPcDs42KVMJfG1YLT2nkhNO6iR85SSC9VeiXG36jBhy9LWTemHfmG5SZ6bKDjKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzrqEqMPOXh+rcWZh1KfelN+Vpe0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPsh3nfM\n0qhh4Eyf5Z3r31qPETUo4yZj0SkSPZN1YtAyAiAFT3WZCIKztopnfkYhOQCfJ9t8\n7Evh7v9YEXbTrkAuPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4795", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4795` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdbJkADGrU64n/VkBj4GtAVpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzMzJkZjEyLWU5MDctNGFmYS1hZDY2LWY1YTIzMjQwZTJhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGMxNDhiZGYtYWRi\nOS00Mjk3LWJkZTgtY2EwNmJjMjg3ZTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvaGC+rIYT+eoUBvlPfFtU5gbDfLRDsaNq2uBnNF1qe63LaYYnUr1IWoVt4Fq\nG6usCdUUzfDSbVdB5QRjPLG+AKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKvypq+OGZXmFzJ4XbLEYucAdrhrMB8GA1UdIwQY\nMBaAFBzT7V1OOsjmhc7/zxFEeoI/anzJMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiB5ib4Xi7zzanMF9M8imk9elKoBdGf1q7Wu\n76HVDQREHQIhAJ8keSx/sWrgnjeW1FaWIONxqJcUqbzCu+fZcpga6eDY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb0CtFm2lNThS6ZP58kk845jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzMyZGYxMi1lOTA3LTRhZmEtYWQ2Ni1mNWEyMzI0MGUyYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtmShV2VSl2JQWKNkw5Kyah3rRA2YVDSKh8nvFW7rXUwqC\nLuhILDQTsE0UUrV6Q5FiF5WeYTrRIgFp+y6fz80ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHNPtXU46yOaFzv/PEUR6gj9q\nfMkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIrkr4NsnQNOc9uK7tT6ePbe8gZFFrVbvZQyfSGz5tYVAiEAin9FB5cV\nAgkqkevtXpqS6DokGDC1x/gWfrnVcBbnzYI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATh2ksKtMjvBbpkAmLw9lvu7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGMxNDhiZGYtYWRiOS00Mjk3LWJkZTgtY2EwNmJjMjg3ZTRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2JmN2M1MjMtZGUyMy00ZGE5LTkzYWYtNWYxNzg2OWYz\nNjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6gQ7dz2HfmxzNPrT3iW4xIDX\nmbnAJTCTvvXiiVOPYIVGf8Qd98VXfklAj3SNsylTNLcefIISjnoHsO05pS08cqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUq/Kmr44ZleYXMnhdssRi5wB2uGswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgBlUqfq0D\nf3BVhGWgm2ai2LsJIOC+jUxJu3c0ZHP4L8UCIQDjFNxEzUHpacoVvxUc/SGE7C8Q\nNPtmPdXnQdo8LmZjYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4796", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4796` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAfgri4IGsGo/1inRBWD54gioMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4NGYyZjkyLTZmMDYtNGExNy1hNTBmLTFiMWI4YmUwNmNlZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RkNTFhZDgtMmM3\nMS00MmNiLWFlYTgtZmQ1OWFiZDhhYjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECz5PjNRIkqSn7p1FJu2o7zweio7kva+7PtJoYVWuH3aPaCYWFjzCx05D04uK\nWxqBV/bJ2g/02HfBWC8q9u/QxaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAQnNtgxAdZlk7g4f7hDGF4X+8eUwHwYDVR0j\nBBgwFoAUY1wcW6cLMC55WtZ7E4uDraurxVowKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIAk6PUwsSW+\n6kl3pR2lfcCKpkwmg8HgoYMKKn4YQGd3AiEA2uUZki87MbieK6x86kTTtTQYIytX\n+GYjWeSmQRnUY5Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ6OzWPuuvPtb320MYu/EujgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODRmMmY5Mi02ZjA2LTRhMTctYTUwZi0xYjFiOGJlMDZjZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfyH0/Q4kBnetG0tan7hvqndzyfko4f6qUSxCUZWYd6lWw\nSS2NwecZ1yzz0HHWiLBVeZ3ePZ2zQNrgo0Tm2Fiko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY1wcW6cLMC55WtZ7E4uDraur\nxVowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCJ+iBdB123IMuIt0u7KoplMrnSWn0tkLikzbmlA+ocACIARk1xX9MaSg\ntk4FlYBZ+7eLF2DqNZ+ZYm7k8a2MwC5V\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAX0jLy+jwQDIvFuMQ2o/+/qmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RkNTFhZDgtMmM3MS00MmNiLWFlYTgtZmQ1OWFiZDhhYjE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDU1ZjM1MTctMmIyNC00NTc2LTg2NDgtYTc0M2Y4ZTEw\nNTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEShWln7F96SIMs2CMN/EcTpUE\nXi7L6jmq8pmb2f74UN/ScTN/zDrhsyf9lOwfHc+pIxtJuuthcYDcshRVlXxTZ6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAQnNtgxAdZlk7g4f7hDGF4X+8eUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPsXAyDb\nyl2cqigj1Sh3GHLO1grsCuVSpWNQjsiSpN74AiBkMYBkH93BI1nmfhNN3iPUwE2S\nJicD8OaT5nqPxA+xkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4797", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4797` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAeC48S+nZ5O29/TlxdllZ8MaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMWU1ZDYxLTVmZTMtNDY2Ni1hZjM1LTQzODM4Y2ZjZmRkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMwNzBlYTQtNDFh\nNS00M2ZiLThjMzMtOTYzZGI5OTBhOTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9d1Y2qfRaneRtKzDqeA77WQGxXMEahQx0IqJWKR8xpCFDTxnbt7Ul2MG/sm9\n9+NTP/84nyuCAhMOkBvnDgOXJqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEr1DYxh18LByH8iXvsYJJzdErzgwHwYDVR0j\nBBgwFoAUfofit8QvPKV1Q4orI3O1e/EwsO4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJqJjn76EUBQ\nK6uOVmeVd8edQ/Oj7PWLV40pxWQb2OW0AiAPFQt4Y4U9F7qsJUiA9S2+0afRm0Vg\n5zM97vY8ncmW+w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQPGvg576kM2V/IiDBhBD5pNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjFlNWQ2MS01ZmUzLTQ2NjYtYWYzNS00MzgzOGNmY2ZkZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASN5+UUvNzlLjjit2Xr2+r1EraL6PGMCRegJyk/CKHUMKiL\nYypKzfrPI8Vlu5Df0LxJjNKi4dgfaqUQ/jXhKXwio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfofit8QvPKV1Q4orI3O1e/Ew\nsO4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANiABzNUOu3DT1mmy4nT1SnjgaIpO69Xc/ehikN0bvggAiEA2xg8hwbi\nf4bBEG4TGksp8R8QYzTP71aUuj67EBk4Tek=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVcNkeDxb2lRIf/5Sq4DpIXxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMwNzBlYTQtNDFhNS00M2ZiLThjMzMtOTYzZGI5OTBhOTQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTlkMjc3NjMtMWI4Yi00ZWFkLThmMjEtNjM0NWRjZDQz\nZWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVbutxAZquo89eAze/rA1d0Bu\nLaRbAmk2dZEljCE7KN+l+byaAVloJV8/QGF/nmwt7BitH2d2QzOrrvoupdsuZaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEr1DYxh18LByH8iXvsYJJzdErzgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKJ6fVs/\nI+MvC83PkOcm/oa0o+eICG3gtuAPmAujDtERAiAfiAR8cu5Jjm8MjCihw+MvW7gg\nZu8yMY/GaU7ZVRymBQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4798", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4798` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASm0+VaV5hhu+1m3IzsbFsPVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZjdjNWQ4LWVhNGMtNDNiYy04N2MwLTY0ZTAzN2ViOWJkYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMyZWNmODEtNDY2\nZi00MGUzLThlYTgtMzgwYjJiZjhkZjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKr+48QAFttGqQ0GP5ZiAW+1JKVLGUdZBsNuapgEa/72z2aRzTGpkF0+dvY0I\nY0MijjwQP0eX75uGLIoVuCUyvaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpZEoDPEpLn6srd5Xe/rOWgxlSkcwHwYDVR0j\nBBgwFoAUOWZq5H9tZNUlj/0FfoFnxZwzts4wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGDp9mvp68kg\nOBtYCNzHyidLErUAzfKI6YxUdj1G6apuAiEAnl2P7kt3thcYXtyXQENuhYTsE1Pi\nI20fQMDUQQPVck4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQrGRzBaOsrpxU/pz33KWaY+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWY3YzVkOC1lYTRjLTQzYmMtODdjMC02NGUwMzdlYjliZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpiA6BM3nGY7froleuCV8fPl5Of4v+ZcT7k5NTeDMB/5CL\n9czQxaJt5Dr/Hcz1VmoaRVUtwiQ1HW2Vu/qvOnqJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOWZq5H9tZNUlj/0FfoFnxZwz\nts4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIRuUZo6OMcs0Xty9Q56+6/RlHx+TD2PwAZcdf7WkmY9AiEAz+GtTwwe\nbWLYtHH35FbHzihzAOgX2wkqNdmDpfAb1JQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAb1plYNPLiW3vKrpFjicoEQ5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMyZWNmODEtNDY2Zi00MGUzLThlYTgtMzgwYjJiZjhkZjhiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmRmMDU4YzAtNzliMi00NWY4LWIzYjUtYmY3YTlhNTBi\nZDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2qtgjnO36gk3lbif0BJnmM8C\n6bR9U/JuFZJln3QPnJIlijYUTthDOEaI9CFTWYQcgPoinNnVrK0uVqTQKo8PnKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpZEoDPEpLn6srd5Xe/rOWgxlSkcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPYWd9jO\nHB7UtN4SN9GOxMNgZl0RSu/vOZ2h28v/5tpxAiEAnX02//BuWt7qB35N4BAqDFne\naOOK/O60X4bfwd4Q0WM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4799", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4799` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZcJLUCFt2yiCsRRjjEBsdKLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiMWM4OTM2LTBjZWEtNDViYS05ZmEzLTZlOTJjOWFlYzhkNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZkZmJhNTMtNTBm\nYi00ZmRlLTk1YWYtZDg1MGI4ZGE1NjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEusjlHcpNrXa/XqeKsMoT1MOBcBd8DDteJZeJItuiVkM9QY4iun4QrRF+PRo4\n3OlpEBRNqDJQBqemPIjyTGbLPaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXlJZ2QL5NvdVSOwjV7CcOUSip3cwHwYDVR0j\nBBgwFoAUakd/yvGBHViUYqxZosqwEMF+c38wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICK8rYPOKd4TdbhtMOQLllU9JQuzDJAaqNFXaGWJdp+oAiEA4QUh5oAxWIja\ncmiqlujnIuFVBZB/1AMyRbUeb5Lkfww=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdArWqhzPXLomCMeW9WvZ5cEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjFjODkzNi0wY2VhLTQ1YmEtOWZhMy02ZTkyYzlhZWM4ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2qDbRZiQTK6idspSubWS1aj7W/uipoK3Ga2WneL/pObzs\nazcP3Zq2lN3votmaWZviBMmNUOmFG3TzbUX27Qjro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUakd/yvGBHViUYqxZosqwEMF+\nc38wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIKue+8GalsjC5JxFdC6KOgGWIR4818aHIksHMAYA3EKAiEA1roP6bTw\n6qs26DbvTfBSjpcdA8aEkXHb8zhUtQ7Agt4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATSnEU9BFbiwnLchfYLcbgU1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZkZmJhNTMtNTBmYi00ZmRlLTk1YWYtZDg1MGI4ZGE1NjRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGYzMWUwZDgtOWY2Zi00YzA1LTgzYzctYTg3OThmYWEw\nZjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+lM1NjjyOKn2eeIYDoJ7Bvu7\niqs7t4BFJrQDUXj3UlOGyCeygZHqSXmTr/OYqWkILqZgR0wsKCOUmUmy3h5n6KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXlJZ2QL5NvdVSOwjV7CcOUSip3cwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMMP9gJL\n4JixBJOF5OAtJWk80DPTmnAsgxoWbhK4tDT1AiAnjmyfSL+navVo354kFdgIs60Q\nsz1x9w69LHBDpn+10A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4800", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4800` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATcxQn28ZLeaXCGT2m0EHlp7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkNTMzNmJjLTRmYzYtNDAwYS1iOTMzLWMxYjc3ODExZWY0MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI5NTkwNjYtZWQ5\nMy00ODQ2LWI4M2YtNTY4MjVlYTU3NmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKC/ScnathUxymTyIDEzCYdCP/c2AtMfhQruowpBCz5dPftII4SWpp1dTY2BP\nCJkSjlz/ECFwV1mhVXOMUQJr+qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqMz3nrfwB+TI6Ag6tJru8mci6wQwHwYDVR0j\nBBgwFoAUz/AyH1j1P9hnE8VFzGm9Sm/6T8QwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCcMAvhOW1Yic26Iji3/MSVu+2WR0rk5X2r05+5M+p/EwIgai5v8EJOrCuY\ngwEHeLkpCjmDxaKAX8OH7k5FxV9OFQ8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY5ZnTbLeKWe/vx9n70YvMMpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDUzMzZiYy00ZmM2LTQwMGEtYjkzMy1jMWI3NzgxMWVmNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHo15FTX4gCx4OfkGKGpnLbrj7h8MjrDxBdRdsFiBTKa2F\nkgGTUTLtIWzyK5cD/u92iNfIT1zD+EaNWiOHrwz0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz/AyH1j1P9hnE8VFzGm9Sm/6\nT8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANSAH/Xpb+DDc5LTN9ND6YG5MpSll4WEtDvi9YXrnlsdAiAR8JhFukTZ\nVxmiJb7C+E9dp86MGktESMOBnBSdFntjCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfItsmIvjEYLnRwNTvg0ai+xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI5NTkwNjYtZWQ5My00ODQ2LWI4M2YtNTY4MjVlYTU3NmZmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDc3YWNmOTQtZmUxZS00ZWFiLWJiY2EtNmNkNjAxNWIz\nOTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMXXAWC9F2xyi9QSPqcd5sSy/\ngQ8AAebHm48teZf3LMsPvbxOxTIuFN005gyjIMOaX2D+dr1j9IZnGsl7Vejqj6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqMz3nrfwB+TI6Ag6tJru8mci6wQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgB7KiAlA0\nHOKwdaLTchOAlwRjpfL2GrhRReUtwKCbWKgCIQCKrJ9LQvLiFUWIkYyMOQOzEVg/\nHqDyYaBvn9hhYOmBvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4801", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4801` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAa/mqMrXyhUZ9YFQaJzZ2iOMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZTc2YmUwLWZhN2EtNDNiNi1iZjI1LTNmNzc3NDRkNjAwYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNhNDUxM2YtZWQ0\nZC00MzZlLTk2ZDMtOTAzM2M0MDE5ZTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN65eE3zLXUkCYKYUDLKoY5/fjGobQ2MrRMkGbzFmEO5XX1knNXtJg1r88Sl3\nrzRe7/Jgudd7uitXPCWuY7onKKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuzn7IDEuM1guvrvE/Jcz0FHZd/QwHwYDVR0j\nBBgwFoAUf9719JLe3DzlaUay76zMjzkphgwwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEz1\n5bG2OLG5J9G2SVtFaWL63ca6vfRLa8/BPgSvF9pWAiEAiDy2R94cJO0n6R62X4ei\nYBOpShsiu02EUjOW+ExutGs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASx1wTHNTDzVY+S1rBBRdhdmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWU3NmJlMC1mYTdhLTQzYjYtYmYyNS0zZjc3NzQ0ZDYwMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZeQGP2T3DyOqSJQcHVfJtI/MUbkqcXGioODFJTlcYtNEY\nBg01nidcdo0fMwxQ3eEypGDW+BQJLwMeRYNV87wgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf9719JLe3DzlaUay76zMjzkp\nhgwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgML9amD1joa8Fg8qE+LRil+4glnblf38LoPF8XkGIMS0CIHJ0cylsiXfF\nb+OpRJoGO5n+2+HYHnn+lDe3dHWnBKnI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATAPTe/VTA/tFGUIv/aamCrKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNhNDUxM2YtZWQ0ZC00MzZlLTk2ZDMtOTAzM2M0MDE5ZTc3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTIyNmJjYWItYzU4NS00YmM0LTg5NjEtYzBkMTNiNjg4\nMjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0/xHZBH35xVcOw2xIStD8YQd\nHUTVj29393WF9lkst6wzRJX2HMwAB8qvdlE+Sn1gAh7ToKDyFBrH7p7djztVFaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuzn7IDEuM1guvrvE/Jcz0FHZd/QwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgIATuGaM5\nz3cN4eRQJcVOzhGTkBLVhq30f79ldY8mM+8CIQCUHn3kRgdRH9PZ2Kbdm+TbtGkE\nvdqcx/AfGLTjiJnybQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4802", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4802` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAV+qKdWTxxqoz4OE7x4LjvItMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNDFmNzc1LWNmYWYtNDA2Zi05OGJiLTdmMGJkMDU3OTczZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWM4MGZlMmYtYjUz\nNy00NGJiLWJlYmUtNDFlZjRkMGNiMTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6ef4HGzMlpX8WU+kbdP/4T0G2QqgtwdSzKBg6HAzrM8drcS+/Av2MSnBpXvG\nwWIIf2ibYpZkqr7EJRAI/gOG4aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Oke/tyyMmSKJEvfpeMKs5lXYmswHwYDVR0j\nBBgwFoAUdh8ohJDz2jhbVmvpOieapCIz7aAwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQD6pLtQP10hJCJSCDpD0JLtPYB+O/eI2nIRWK6m7tkBDwIgI2C9\nTaefmFAD6dFgS56XVzULzyvSWVnbQf+Iuw4qaJo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX/rb/pQ4IoUT3FNKrZjFDa6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDQxZjc3NS1jZmFmLTQwNmYtOThiYi03ZjBiZDA1Nzk3M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0+B6APfXmzbXubSvpJ4qwGUHFTgYM5P7ZrdHGgfug/+yn\ns/OxP3+BBhLqSUaAmi+Rn8bc6iXfwsffuv+1J/E5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdh8ohJDz2jhbVmvpOieapCIz\n7aAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIftQn1P3IfquonQhc5QcGpUGzShzb5L0Dkbj6X0lhcsCIBwk66HLqY7N\nhdgrtpRtE6U8jF//fsawtTUzd55Va5sF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAf+FVtT+ATzg3bpZyA3L3c2ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWM4MGZlMmYtYjUzNy00NGJiLWJlYmUtNDFlZjRkMGNiMTI1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjRjOWZhODAtNGRkYy00ZGVlLTk0YTctZjhjNDIwZDQw\nMjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ9yMsvhg1ltGWkcOdqPaRk6E\nq7BzPrLoO3DR2eNeKxESSPV/DgaIW/x3noHpPMqYkWZx7nnamkbW43Pkt7wncqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9Oke/tyyMmSKJEvfpeMKs5lXYmswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgMbzRSXMs\n6OsB329R8eGiLHTEAGhzlZGvZcqpfcmWuagCIG7f9DqqbKQzwmrDagL63R2pGdF+\n24ZhB5r7RE2/xSco\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4803", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4803` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAezVS1dj7tv/Xu8udKZO6rWxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5Mjc5NjA1LWE0MGYtNGU2Mi1iMWU2LWE5MDQ5MTBmMTU4NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgzMjZjZjktYmY1\nMS00YWNkLTk0ODctZGI0ODY1OTIwZjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdnLnA3VYmFel/2h7GDWIi0xnaZsKX6K3i39aMq0O5Nyy+mmAgNzGSCUal4cf\nKc36JhZy4Q01vRL+oUE+LkjTqqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4zqeApznH//zYoKN40yu/YyeGG8wHwYDVR0j\nBBgwFoAUng8iNabXtzu4l/FReglnharu43UwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQD6Okoo6KkCBQtDjIjulBUlY+EDEPcUvoi+Osk7J+13vAIgKx3S\nsLj/bOy5K/qaA7mPOw/iu+5cDMFd1yAEYOUJcCc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXuehkuqFpC1B6OmtURsXv3uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTI3OTYwNS1hNDBmLTRlNjItYjFlNi1hOTA0OTEwZjE1ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATy2klJl3XJZzRxe+nfHz+TvR5CEYkLAgWGTg6CGj1nxhk8\nG5oaKUhhH02CV6mYG1/UOId0vzTdX4FV2Es/Nf7Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUng8iNabXtzu4l/FReglnharu\n43UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANX3aoMDcwEEitSnR2S5Ubt09qPYvNbWrfZ+xT5rQSmWAiAf3CZnM1Cs\nhWweiB2g9prxw616i0NnYLWN/VlKOk026g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAfnVTBTmcrNyF6dDbXNW4q+ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgzMjZjZjktYmY1MS00YWNkLTk0ODctZGI0ODY1OTIwZjE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDI2NzYzMWQtZDY4OS00MDk2LTliMjAtZWQ2YzMyNmQ1\nMmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7qOkrCgpP4xJvUTMRVCKBWUo\nEEVEDzpMH7D/8222BxGcn4FQQoPh7L8Qm9JCjZgc/qsUBqs7UY+oRpJfnZUYFaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4zqeApznH//zYoKN40yu/YyeGG8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgMc34V9Cm\nnI3PxwLvBZKPT8kq5nSOu8ZlSL/IN3CQrYgCIF7ayLLiZsctNXBmFSpgJrYJauhL\nmFP0gzW7zDqJo6aw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4804", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4804` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAUDFhAk0LfmILnj2lHsvs0JmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2MTM1Y2Q0LTI0M2MtNGRiMi04Mjc3LWY3YTBkMDkwYTEwNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE4M2UyZmEtM2M3\nNi00MDc2LTk0NDMtZDhhNDgwMWMxMTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOQotgLsMk/jlgfaKhpv4ZEKrKhL4P4I8dqDHzCIGJOFXRNQmLj7gXINnUxUs\nLgbODLBt+KSTFpdTzPcndKwdMKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBK8BQdVis2FRmw8vm88mdUy/JNMMB8GA1UdIwQY\nMBaAFOzM4gKBPu6DEkhUtcNY+D0F+0sGMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA1fH5s3A498+npZgr/xP+TmFDLie89XG7\n8PVDmsM1AZwCIQCaif9YUnPyAjvptbiB7vOVjgvgTvuSkR5qxIDrBPOnFA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfR/r5TmeOOz4AwAwaknU624MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjEzNWNkNC0yNDNjLTRkYjItODI3Ny1mN2EwZDA5MGExMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6+NhZcE2wdQfgT5avQjsZQkza1No2MqblsM7gcr/KSmfX\nR42aOgePqZeWMT2cLDl8QpCTTlJ8pm/HBdrVvP+zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7MziAoE+7oMSSFS1w1j4PQX7\nSwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHVsCw8jcMu3ExpuqtaGB8NP53yGPRsEpmFXxp0BVL/gCIQCr8kbfeb8H\nsluHexTe+nAEd/EKaUKdf2l1i4zbx2OZbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASNwXKkRHnHh9FAuCSTb70OkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE4M2UyZmEtM2M3Ni00MDc2LTk0NDMtZDhhNDgwMWMxMTU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDM3NzNiNGEtNDlkZC00ZDk1LTlhYmQtYzNkOWE5Y2Rm\nODZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEliVvU93r3ee8ubdq3I6b9rhf\nXtBoHSTk8NLr/zVkHqfzelkxLRMF0FAwY8hI75KkQH0hEajKRfR4zNkMnv3RJKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUErwFB1WKzYVGbDy+bzyZ1TL8k0wwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgOty6bfeU\nYtzhS3jvMLfMegwxcleCbYK1vr7NvZ83Ke0CIQCeuFXiPj+SU3kCmdFEO/Ujshi1\nvk1Yyai+qKJXRcIpAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4805", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4805` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAVUDh+oDVF2hNHLqxe3aSXI3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3NWJlZDU5LTQ1MzctNDBiOS1iNjUwLTgzZWE3MmEzZWQyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJhZDQyM2UtNTQ4\nMS00Zjk4LWEzMTItNDYxZTgxYTY5ZDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwLAAKA1umdVpnbt1tRCxTJL0/R4CxzdAjr99CxEdB/CWE4Il84dzWXSvVy2R\njqyQZWrkGEt1yBG5QEUp8GFcwaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1jJtszy+xnnDFPdQzERayAlfnwIwHwYDVR0j\nBBgwFoAU6JYb7YdD35XFrDF9JVT0KdxA5VYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJpvt/mkYesf\ny7IvRv6oxk2V2U2L39pVsPFCX2PRlZCgAiEAklDnbkjJyfERQfC/QFuHjPF+Ggx4\nXKuYJ0i25NsL2BA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQZ96i5P5MlnxDtPXwVqsIpfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzViZWQ1OS00NTM3LTQwYjktYjY1MC04M2VhNzJhM2VkMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATa+9Iz8VTlQRyFKqTR3XAaO1M4SxeJMaPmySA6enj7TCGQ\nizxKm5YLUD0Hmma62e4r0+9DKe2grQNujSHYzrQuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6JYb7YdD35XFrDF9JVT0KdxA\n5VYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMSzkXjQqfzexvG0ETkps/7bct9rutXgJ0ZGG2lHsfHoCIQDGf/yxLjDm\nQjfnMbi5nTc+SVAlbsO7paB7EzocP0nl+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAY23PAK2kh1A/fDKkpE9BIzzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJhZDQyM2UtNTQ4MS00Zjk4LWEzMTItNDYxZTgxYTY5ZDA1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzE2NWFhM2YtY2Y2NC00OTA1LThjMjMtYjY1ZjY4ZTc1\nOWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuyyF51jLjPWMgNYXxraiaSl2\n1w0/tuMe2DGnCUub55AarHHUpaHK4rdini3BGIvOI9HyCDUTqrLDvE1BVRb4e6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1jJtszy+xnnDFPdQzERayAlfnwIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhALz1cQ6P\ni51B+5Xsyq1TC2D8qYGJ2DBDrsGJxPACfrjyAiB7+dqVjbX+uOYRnly2SU6Ubb4H\nVqzjUYssL71EZnDJJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4806", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4806` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAfpXKgx/LWssE2cVAMyK7+FlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxODFmNjQxLWRmYmItNDg4Ny1iZDEzLWU5Njg3MTY5OGU0ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM4YWQ4YzMtYzU4\nMS00NDk0LTk3NzMtM2MyNWE5MDZmZDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED1bsFZTs0HQRtzn6fZsZz9CW6HwDRRP3lZHXkJ+343E1dnHDlUYADYken9ee\nmDDUuXcnEBZJKBPKHzcHyef5VqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM/6yrHdO3AeRltsM1hVVNOyDZB8wHwYDVR0j\nBBgwFoAUUvI5JO8807yUfctAfzY42PfgXFwwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgUYyYSJJPLH8b\nta32HSIfQo2oaXy1Iow/WWp1gdpPRdQCIQDNWGt0P6TXMcy5wqpnpum2/TqNDBHR\nhdj/q50W6f5dPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASERosXWUcRo3+b23jNaxmNRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTgxZjY0MS1kZmJiLTQ4ODctYmQxMy1lOTY4NzE2OThlNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlbi/8y4iR2TJJYMN/d7n/IvMT8y4RZTyxTN+7t3iN+0t2\nRZrM3bX8XApRARvyNZ00b3O7bHvmBEjTNIjFa53po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUvI5JO8807yUfctAfzY42Pfg\nXFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbC9LDQeJVJW3yD5QGh8KyYbjcz11QaapqJt5hyC8/oICIC87yseAcvvA\ngXhTKuHFNnIgfllKX7oMjU/K7G3WzB+S\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAUehimCX55ImQVuAmxm99lWxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM4YWQ4YzMtYzU4MS00NDk0LTk3NzMtM2MyNWE5MDZmZDNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGE2ZWUxODEtNzRhYS00YjRjLWJiMGEtNjg1NDA1YWI2\nYzg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVzzsH3Gf/TdtuJgzmGPBhGh9\nvTfc01LpPEu+VyavtJpeGHAjoFoeSQgEThoyaSYUSO+lqwN0x1BiIfv9eVW49qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUM/6yrHdO3AeRltsM1hVVNOyDZB8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAL5ZXwrj\n+h4W0CVxwzGj4Gk9VWNS4Il2X61YosyiBPDTAiEAuPS2hT2SFsr29zVdQy1Dpvy8\nXrGG14b0mTXBE5lurFM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4807", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4807` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYj8KOv4kiZp3p3z+13FQivVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlMGUyNzljLWRhODMtNGUzMi1iYWE2LWM5ZDNjNmZiZTFkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY1YzI5ZjktNWE5\nMS00MTMxLWEzYzMtZjdjNjIyZDIxMWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoLR9yvkoU0cpv1grcTXfcItIhCAK1HABNppBuzx/lezOeChdhLUJNBh5rRDM\n7lhFDyRwhXe0zFeRIGn5gG7lzqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ5iBbxvS6q4BnuGVfO0ZtP1OR5kwHwYDVR0j\nBBgwFoAU4lFVmKiFuk2OlKzhZCREjO2asIEwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFcs44BS6506\nrt8/YbOrqm23XHfyfoNj6pY0OilYm0SFAiEAm9R8qgiQ7V6BVjrRh4Dwu/IG6Kor\nfl2fju+hUCfJqV4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS92X9EAC0eXGLXDMa+XctNuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTBlMjc5Yy1kYTgzLTRlMzItYmFhNi1jOWQzYzZmYmUxZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiscen0VA9t1tCA2dWXqja3MZE92pm3WyisiYC1Jq1NrGl\nQM77vz9OmvdGmW2e34RGUukmBjXQxsjGpizlKYk2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4lFVmKiFuk2OlKzhZCREjO2a\nsIEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRZMkrAjzZsvAoX7v+a+VN77SzityGT0lvIqTgpTbLhECICxFOmXX3dAt\n4AWovdJfBJi01/vuNYEQolSsOSbpQBUF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYUPnv22S3KJajLgyO39C0sxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY1YzI5ZjktNWE5MS00MTMxLWEzYzMtZjdjNjIyZDIxMWI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzIwNzNmZTUtODBmOC00NTdkLTkwYTgtMDdkMTA4NWIw\nNGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb7X9oAvzaPGSsB8bVZvL0j4b\n7jEK6usiGdRGqh8cPtWnS1484dgftjQS9xey7uIEWDVKDgEFZDnwouM6WjoOM6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ5iBbxvS6q4BnuGVfO0ZtP1OR5kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhALtg2dTm\ngmLFZHnuPW21ycgDT9CS/NJc2dxrvW/4/I8pAiBltPJGaA+n0t4cv+4O4rKJ45uj\nXftC6WB8ryy+pGAwwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4808", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4808` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUi9iBnZUc1kTr5DP4a76i4SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2MjFiYjJiLWYzZWQtNGI1Mi1hMTJmLWFjNTM1YTQyNzQxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZiNTExOGMtYWNm\nMy00NzQ2LTk1ZGEtZDk5NGQ1MmVmMTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE50/aBNzMCHNi9MvXD2fq9T5YDAuH7icPdpqgueOfXQsKMbs/BpovPTrMl4pO\nmxZjyLmh++Co427bfemiSUHuMaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQaIm6Zti55z9EUcnVKg7B7FFWtUwHwYDVR0j\nBBgwFoAU5/lSHRViXTF6Vs5VemlVTHlVFuAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCk+jTQgV0Zp6+/udAQPWamUH8sk+Pepoxvk2OGgmY0mwIhAIY+QUrbsjBU\nPwVqkylGP3/y+6PWaMaazTmoPg7SXFbr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYaMegflmNEfXeojobEhgTb8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjIxYmIyYi1mM2VkLTRiNTItYTEyZi1hYzUzNWE0Mjc0MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAvgSGlu9bDXUK3yya6MYKx5Xd171ON766ipmmcwxPR9F8\n5Nz47VEhf3nsJ7rCu4R5eHUy5TQOqEAvcIgbLJEmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/lSHRViXTF6Vs5VemlVTHlV\nFuAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJaIS6oBdZOUAJ8cyrS9OGZmCL+es2nHmKRqU7WwFUTgCICAAghXlF9sU\nX0N+slvRNPKbbwUUPc9w11DMTPRhwKL+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISARXZQUTT3fPXhfkeUQRQB7o5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZiNTExOGMtYWNmMy00NzQ2LTk1ZGEtZDk5NGQ1MmVmMTM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTZlZmE1NjUtZmQyZC00OTQxLTlmNzAtMzg4NThmM2M4\nNjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE27AoBza1vPR8M+Voqcj2GnCq\nmj1nlvB8Y5oXCIlHEW0qohiUlNX0QsTYSHwo7548LWfLtgdIePlePkTSjFXMWKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQaIm6Zti55z9EUcnVKg7B7FFWtUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAK464Rb9\ns5qI/p23+RetYBVVtQX/eAE0yN6HsMroB9krAiEAseheZrTHFBXnCNKw/h1ds9LN\ni+LqTo6T9efxXen9Aqc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4809", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4809` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeEo6m2rSENj/WHunXmOfrz4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2MzY3MWFmLTJhZDEtNGVlMS1iNGM2LTljMDVlODdiMzczYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjljMmRiYmYtM2Qy\nNS00MWU3LWFhNDQtNmRmMGQ4ZmIwZTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuZp8jJJze61X27UcNv3tbjqghJWkb0mrGXl/ayYKaJIqif+8TNv/poJwxX2H\niYNYjLokB+ziqF9e+bsu8J2RI6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4edWkafwY5J4h0E6NCjNqhIerGowHwYDVR0j\nBBgwFoAUJtZ599AxA8IJuO/Lzjya1pWIXV4wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAec9zRQOTQmI8DpwVXjj1ws+qdgbB4eFw/z015uWUR2AiBKW26TJMX1kHbh\nUBKG/qYVHxmsnypnrmREgsLvbWHOqQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASzHCN90nvWD+prbdTGIjl2hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjM2NzFhZi0yYWQxLTRlZTEtYjRjNi05YzA1ZTg3YjM3M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2/FEJV5mNSBbz4AaWMAlmJAb+IcibPz/Q1eQzsuhGIv2z\nnS26wd75X13r0jTrJsz1QkP1xTMgZNzvAjy5BnERo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJtZ599AxA8IJuO/Lzjya1pWI\nXV4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMyEqkMP7B+yCh11svLYz7zd9c6ZQyMQLbSpLNCGBVKGAiEA5edwMMqW\nZ/kY+QHIo7vhLFn/VRuk9GP2dM3kBkRUdE0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAR8kEQrzZLEjRnk1l7Uvh73PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjljMmRiYmYtM2QyNS00MWU3LWFhNDQtNmRmMGQ4ZmIwZTVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWZlYzkxYTktMDZiZS00MGNhLTliZDMtNjBmOWQ2MDVm\nNDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESVE2GmunlZ0cPCj+W34K2mr/\nV9j+5UarvogVY/H78u3AOOPs3a6BZHdrMmhn1zNQQ5Jqxx9XmCHuemmI56GBk6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4edWkafwY5J4h0E6NCjNqhIerGowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhALx1Ffez\nMg0yfcPkqS3tsbmSYcqtFEOPsxVRtCmIbrmUAiBGp6ygDrdriDrOKN/t7uXxQK0W\n/RSW7bQOfE3qidDpfQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4810", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4810` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAVtiH2X/LtUrwcBI33QTPoNjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ODZkZjUwLWVkNWEtNDg3Mi04NzlhLWEzZGRiYTM0YWZiZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDMwNzI1MmItYmI2\nZS00NDM3LThjZTEtZGMyZGVmMjY5MTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp11ExstVC95XiDko2bg5K8xOIRtO/JgDNq4wFKmL2QUJc3pmXQlCdlMNEcDq\nofnE3fp1e9D9Nirh+ikZUpHIgaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdZLG7rY8Ja9S/Tl2IqswDzCGdjIwHwYDVR0j\nBBgwFoAUNdB+sOlcPkWYNNWwVjkkU3MRVpAwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCt\nzlzUifjDXFO8hNN3yF4WpCnRRx18q4Flg/Zxv1ygJgIhANtW82AOrAhgE9bFc7f+\n7w26AFslPLs97MlkASh3JIEd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATYA8u+gPtCbIZV/VLpEYPTOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTg2ZGY1MC1lZDVhLTQ4NzItODc5YS1hM2RkYmEzNGFmYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1gvbX7PfQH3Zzz6tJE6+xQxxjADVIXrhSq85F5v6ej5Py\neVoxqX686TLOHI21K03vJM+4Gkgz78Nl+9hKVoyfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNdB+sOlcPkWYNNWwVjkkU3MR\nVpAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKifS+wO/VHL4O8sxdPXtqAtCqw79kKDZ2C3/I1yUZhUCIGnnTVVqEeyU\nlojEaWMtpGx3lcr19e7VRU48bxPer/pb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVhrQNko+jJ9811hoWFUSdadMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDMwNzI1MmItYmI2ZS00NDM3LThjZTEtZGMyZGVmMjY5MTU3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDU1MGIwYzMtYzQ1MC00OWEwLWEwODItMGNjNjNhNDFh\nOGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPEf2KexQkevPbj9Ia3TI0WaN\nh/oINrcPFh2QEk9UDaoyOr989xlMjtz2g0BUOLwHYAU/XiWyXOCjzViQ8UZslqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdZLG7rY8Ja9S/Tl2IqswDzCGdjIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgYVWTi59D\nnZ9sxQjUMMnudPex7qzi7oeL1saV1BXZJvsCIQCV/ryorVhxTtjrRHcKy35JWqTh\ntbhUc5abON2M1E5Lhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4811", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4811` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAVgTqkJjDTBAK9GaaeLHXPlYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2NTlmMjljLTJkMGUtNDYxZS1iZWMwLTIxYjM0YTNkNDk2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQwMDY4ZDEtNGMx\nOS00ZDRmLWE2MTItMmFiMGFjNjRkNTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeV57Oag0Vp1RU2Umw+Yhgl2ToZ2VkiNVsVI9d7dcw+BGkOg3Ns3LJmw8wIpr\njuZRds/aXgFJ8W/9OCf8n49w4aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/3Yed/rPwwVXrybr2wTQ2fqKXLkwHwYDVR0j\nBBgwFoAUSTE0urXlCyEX5iPInB6e4UAt8kswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEWmsJyOV3eGkWqFrpb+uH5U7WW5AcaLYNs3cGZODaEHAiBbOA4S\nO2EEmSZYafL1x4pN8gTghYx3OtengOOcRSJieg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARTi8DPSfwOGhBIjxBzjWcYGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjU5ZjI5Yy0yZDBlLTQ2MWUtYmVjMC0yMWIzNGEzZDQ5NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWElE7ebtYkje1/pzk9QRX8F3bJL9VID23ptVlnoDEpy02\nzgmWr6JlOhlQ12XOTgMstsxHojJiGLor+27+vtqEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSTE0urXlCyEX5iPInB6e4UAt\n8kswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAWolxciwvWBstV3t9qZKqkZAiVvIJsmIimC6XX29hzsCIC6EH//FUAdt\nd4oeXdN9csFMRJIh2AIoB9OstxF3dtzr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXNBWr8d7sTOtyVuoR13Hq5fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQwMDY4ZDEtNGMxOS00ZDRmLWE2MTItMmFiMGFjNjRkNTljMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTAzZTdkM2YtMDA5OS00NGE1LTgxYTktODkzZjY3Yzdk\nNmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwRit/Abz2XwAETERf55+WNR0\nb04T5OVuU99D6kCqM/LztfvK87Y96WorsiWQCdH1Q8FLaPYyPKstRA+fVH+BVaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/3Yed/rPwwVXrybr2wTQ2fqKXLkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgAJBQqi/2\n5zOV8H2+GEbj7feEmLZ7kuqxrV005mJ8LGUCIG6Mgdc+U82RUoo7h1J0oAY0MHll\nJDZSK59SM0rQU1lm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4812", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4812` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISARNZsFbSTCtrP+ry4sxhcIo/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjMjE5ODI0LWYwMTMtNDhhZS1iMjAzLTQyY2JiMGYyMDAwMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTEwNDMwNGYtZjk4\nYi00NTFjLThmZWEtOTk4MzUyZTBkYzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnnYwi6+DpDlBMvfro7lQ94q5GSd9eIBdehkoMzGWhMPAbII99GsMEmO7O2/d\nibofYOPxFyJFiGQgJUx2VKLd76OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAHyGOyWYgb9cc8B5PunYMscOHykwHwYDVR0j\nBBgwFoAUv0kGWcR8QAd2cVRXFbOLEAeI+kMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIDrmiXyFPnnWtvEnlOV8o2INL3//zRukdSsgJn8SKYPRAiEAxw61\nrHnArCb2ZH1xP0iADIJKDUpL/g+65yNtIKSWW20=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQy6ChkZ+KfombZU5U18ID+DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzIxOTgyNC1mMDEzLTQ4YWUtYjIwMy00MmNiYjBmMjAwMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKxBi64l4/ZcRzaejhGviX9k04PWh86HEg3wUEd5yiXm8a\nnMEOjzYNNQdI/ujxyIEcOVpiU/u+v/ePZzvrmxZYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv0kGWcR8QAd2cVRXFbOLEAeI\n+kMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMAs5JQkhyUhJZHV8j8q317ZAIw/fL1RlFFKqD9NrIodAiEAgfHXTR4T\nW4pW9a9s72X/gKx2CG//FWxBTg87pKeDaCk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASrT+6dVCWqB7ouwgZ9zFvHLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTEwNDMwNGYtZjk4Yi00NTFjLThmZWEtOTk4MzUyZTBkYzJmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDhjYjQ1YTktMjU0OS00YTUyLTg1YmUtNmIwNTBjYzY4\nZGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmvonKnpBS0CKrbnhmxw6Z93f\nSeOw8galiVQjUnpTbu/IyMecOJH6t6yeseUGqrl/Rpu+KxyIHb6vxK2A34SJzKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAHyGOyWYgb9cc8B5PunYMscOHykwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgOViePEu1\nDmb33mVZmY0EoI8/hUYVuP8NxknvBCEg6w4CIQDnuMbbRbaEZ7Xfqb4yYFC5Rz9A\nlaBLRJZzeiDIwc+AFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4813", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4813` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXIsdH3Z3Qv0eGNl4ahka8vZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyN2NiYTBkLWMwNjMtNDZlMS1hM2FmLTg5YjMxNTczZGFmYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZlMjI4MWYtYTQ2\nYy00ODIxLWIxNzQtODc1Nzg5MmUzMTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERUE+xB8dSSemzArnyDaqfx511ovfVxNHu2z/jrX5EHvcoY8LTdNXJ7qNU8fg\nByqlKyUK2RTTbRBN4bjS7a/rHqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQTs3gihcu7BmJdvCiNGlXEZkuQkTAfBgNVHSME\nGDAWgBQXfdP1dixVXNrp0oZIudPIxZSD9jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCkvV99qpXUj4fAqMd5k+vUPmDC9R4l\n3jjyiZa2F6IX6AIgXIDWooN8BjUT++B0DsYyMUQhXpYs88pamqjWeyLGBZ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVMJbYf6errEmS/k0Bd8IjA4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjdjYmEwZC1jMDYzLTQ2ZTEtYTNhZi04OWIzMTU3M2RhZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJizvK03B56Jwgb+FZLqjq8/Fi30sN3uKUUR21dyzYACzG\nYz+uP9mQJfNI/lkVFCeNtu5gi5ffDcGQtJlNz+mUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF33T9XYsVVza6dKGSLnTyMWU\ng/YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOf0dzJdTcKSNU2FcmEsIiGNT8rNk0ik6T1TbyBtdu4iAiEAmXivV0+H\n7ccUP52E4YqEKCGJ/z9KMe2khq/mq/c2JC4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAUYOpglDpzkW8ibQ8IMutcjFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZlMjI4MWYtYTQ2Yy00ODIxLWIxNzQtODc1Nzg5MmUzMTliMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODg3MGI5MmYtM2FmYy00YzUxLWJiNjEtMDk3NjliZTAw\nM2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEolSL/ERyZY0dlQjT8ee5Rthv\nDSSZAK6pCXxySz1uBhG7ZiTb9oSuWZnrQdr8cq3sZ4nRRPYoUaYOEYXZe1AObqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE7N4IoXLuwZiXbwojRpVxGZLkJEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJhk+sbp\nlz8TIDQvEA6izYRPYxvymKifcdwoLkTeR6o0AiEAySzT6DoMiBpoSOPbnrOswLK7\nbUWNDQVfWJ5gsRQkjKE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4814", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4814` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfpQLhI6sZvlKWkMn1yKmWrKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMTJjMzczLWFlNDUtNDk1My05M2U4LWQ4NGMwODUyYjE5YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTgzNzBkM2YtNTY1\nYi00ODg1LThkZjctZWQ2OGZhMTkwYjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdecrOgbHUlwzTmHFK+s3GgSDQVkiNx9sOuFwDo0B6CSfgc0VxTNyvmg3wzKG\nuI1Evl+SvfgZrCOJD4QCTREiLKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXgTERa9RaFPGDhOfwpNB/QaQnnowHwYDVR0j\nBBgwFoAUfC/XI5uTiY7M3nPzvpRIazwuIRUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCID2nBmXit00A\nX1yDTCyeSs2Q5Z6EtG2LUIL37JG88bPpAiBcjUwvVoHAMa7/ldZF20Xg5MjuBeSu\nuBOYyCrAiQ2jpg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAft6o2SUgLOS5Y8vR2YbGpiqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTEyYzM3My1hZTQ1LTQ5NTMtOTNlOC1kODRjMDg1MmIxOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm3nbgW0r4vj5XWjv9HkOKugd70gOHasewuwg+jVuBu+uy\nqmBg+ePCsA3iewAyLfO/NqKS4xIP43ourBiW95Mfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfC/XI5uTiY7M3nPzvpRIazwu\nIRUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP2k6VOZnQ/tV7t2A87ypzG4MuNa/6RKPDa5nRPofl2BAiEAyXtKwBJq\niHbcHjxBoi7uga0Bl/iTg6P0TvAd1cNT3MY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYjllqGAK7mgGK/V+R7qZDxsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTgzNzBkM2YtNTY1Yi00ODg1LThkZjctZWQ2OGZhMTkwYjIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzJiYThlMmUtMjYxYy00NDhkLTkxOWItZDMxNTNmNzQw\nOTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbunqMnxr1ZKvMr9ZScm8p+/m\nSY810VGv6j0BbfcVh/rC0Sp4dYgGlKeta+xNansVa0hmGcxvLFpQMmtL+aVOTaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXgTERa9RaFPGDhOfwpNB/QaQnnowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKpb0btt\nv5h6PssyqUHLwZomEXgX48y+OIEH4DzxeFPlAiEAprDIaSvDUGiUMDLrBHoZZDDw\nJoJhJbTeZ9oC0saexwk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4815", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4815` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAVZDSQhgP+tNCIdgOj9Xa0zGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZDY1ODllLWE2NzgtNDdlOS05MzA4LWIxZTE3NTgzYWQ5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc5ODlmOGEtMWU2\nNy00ZDFlLTg4M2EtNmM4YzNlNjllNzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiwSrHQFWRPJ0VRc4VtJfbCb8LRnBl1Aa5ZtrQ2s/ZKD+55yuzlW9Lx57QnDA\n2adJtPPHgekhV0f+OQTd2NdtyaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2nQfXIzYqioVLXa4OPXEaRo5HzowHwYDVR0j\nBBgwFoAUhNK0232L3ItNh8RWEae9yHvYXpkwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIFJ/BspXcWJf\ngBkHCdLyqj+zDlHnI7Z1LmyR5opgw9AAAiBTANEzXAvda0rYGFBG3dJ/rg//Tb3J\nRtSlOrhCTXiWKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeULfjg8H8rC2F0mUPeEefsXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGQ2NTg5ZS1hNjc4LTQ3ZTktOTMwOC1iMWUxNzU4M2FkOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScUSV7VwzudU2Q9988OrXHAzi+ZAFMWW+muH06dq2h2Qyb\nVtSI/ZkdME5SkeJSOBffmNBFpNPRUpnapctYLuXCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhNK0232L3ItNh8RWEae9yHvY\nXpkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSPab4N9z4eNUlr+yFsmlt4BCGTogGzRjp9XyH9KYzDsCIQCD5BGEFUOg\nW4KPsKYU0QgnvCZw6ZfJenL/LWEDvGwtJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVTKtUGn9OPfb88y6D0lWrKJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc5ODlmOGEtMWU2Ny00ZDFlLTg4M2EtNmM4YzNlNjllNzA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTIxZGRiNDAtMTgyZi00MWYxLThlYTYtZTgzMmU0Yzgy\nYTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdjWrsedpxG+iLxWWF3me8CSG\nj0jtmfkTbg5jFgzdCf6SiX8u8fUf6fGfxXGvpw8yEhZfonsYywhyzTuSZ1HPmKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2nQfXIzYqioVLXa4OPXEaRo5HzowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgeA8ZKWyN\npzEoawSWRvp3vlQzy6Cxr23zGvt0q61Qd3UCIDlOfnH6W6VC0yYqflm2ORq4fz96\nIrgiVQ113HZuYc7X\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4816", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4816` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAXmlvygkXAkwjUeO2JegzB4mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2OGNjNDljLTBmMTUtNGNhMy05ZGIzLTIyMGQ3MmQ4ZTc4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWVkMzhhODktM2Zk\nMC00ODk2LWEwZjktMDY1ODY2NThjZDUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgqMSzhawXBslDPxN5teMQKVHAk8xNVt32VtTM0zUOvaAr3y6AieQ28TNdzpM\nbmdPdBvcutmJoq07q6OWGfNBKaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWEys/pIxwijvnOsbLVDXAilhurcwHwYDVR0j\nBBgwFoAUlIPGwXqjcrXFwtz4ywL+AERYTEowKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiADOraAKjc9\nsM4KfQ9IYklxG8BWQ37zH6r4Ry/IyvszTgIgI8RsCZ69IKcNfh9aTrSSE98yHCJN\nINJOK09kWYgRypk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaa2D4ZMlLoq7MFtXlZRPPhjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjhjYzQ5Yy0wZjE1LTRjYTMtOWRiMy0yMjBkNzJkOGU3OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARH8fp89uIw/r/xpYJD5MUF/QN4Pg6huPKaIP6OFPeM9/DA\nhPNaaouAO2nAwr4OW7fKJdAu3jUKMh8zz6akMHvTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlIPGwXqjcrXFwtz4ywL+AERY\nTEowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN/CFF6lr7Nw4S+7OGJzMCBq6jfMZZfbBsQUn03gJOSoCIHMG9SyniOwH\nlxV2VsHxArNW5ly345i5HrBSM5mV0Va6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbUXjQleU7Wo0i9KR+7vMM5EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWVkMzhhODktM2ZkMC00ODk2LWEwZjktMDY1ODY2NThjZDUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTllZWRmOGMtMzYwMS00NDQ0LWFkMTItY2UwY2Y4YWU5\nNjc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWhxNJhYxqUaxTGyLT3Ct4ZHL\nWF5F+sLD8RIuDvdhJS/gNus047xxcongMSEg6CSZVnir+RXLv3ZXbHiEqX6NJqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWEys/pIxwijvnOsbLVDXAilhurcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKxcmkc7\n0ABoo+ySAY8Ah3QQ2UAfdjvalMSYEsnzSJ1lAiBT/9rgxEZW22yLyjs7veRLnNqu\n1YsjdpPbCJRb6sz1cw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4817", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4817` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQr14+tRt66TUYhgLnOh3CrKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNGYyMzhkLWYwYzUtNDVkNS05MjkyLTQ2MzY0MjE3YWQ2MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzczN2I4NjQtMDg4\nNy00OWU5LTk1OGMtMmVkNWRlYTc1NTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj5P7+EF2XZj9xw2f1Sa/Gx4+u9GCaVbbo20jMvaAeVk64dtB81MVMywAyx40\nboJ6IdUNbsLLMIofPzr7N40QQ6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCweajnzpYxCBqCSbRAmvSWXy6UUwHwYDVR0j\nBBgwFoAUWFaKh7qFxeYlG1zB8DoC5Xa+o+YwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAx2psZvEAfOmP01TJrLU4VJOiUXUA1yKBToaAj/5drE8CIGMhwPmImQAn\nLQjCzroiCxoEoE7rtFqe+TBoR9LSLRfH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcqW86hKZQ6+vZ9QA7cuBMrEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjRmMjM4ZC1mMGM1LTQ1ZDUtOTI5Mi00NjM2NDIxN2FkNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2tjf6GWQcsPqGU4WKZKSdS7W33adxSER8mtvsbGG0Ft7h\nrtaSWxuV+Ax6C1qE453QQsRPTPrbNq08zMQi/0wKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWFaKh7qFxeYlG1zB8DoC5Xa+\no+YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO8sGSpB6wFLxRBOz19Ws8AX/+PowW8Ui6dnqbi4nyI6AiEAnFt7vTqL\n9K0BRB4ZUEsEngeRRNLaqjeZ5Xw2t+r9l7c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISASs0mkmv1AZ+hoHfVm1mtq79MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzczN2I4NjQtMDg4Ny00OWU5LTk1OGMtMmVkNWRlYTc1NTNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDI5NzcxYzQtMTNlMS00NzRlLWI5ZWQtYjc2ZWJmYjdk\nZTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELepAIeNPNW2C9OaWA+4/eKOG\npCiw62RMVnPvEOwHH/j0JzVhv3spJoQkaVOC5Kr8LpjQF6p1R2GUslRrfPDDdqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCweajnzpYxCBqCSbRAmvSWXy6UUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhANfRoQ4H\nIidgMlLBiF0CdbSoQCL1Od8KsuBDKe2NEbx6AiEA7hIo8MWQ19+YHt2cQnxKUnIW\nBjH4NqrAwWgS3NmTtrQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4818", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4818` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAe/dcE8xqI3jhJm8njzZ0Qk9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMmE3MjA3LTJkMTEtNDMzMS1iNDAzLTAxN2FhMDc4MjFlMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU4M2RlYzMtNzA4\nNi00ZjhmLTkyMDktM2VlMjliMTcwMTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXb9d7O2sVp+sP3ALQUSozM6s84njtK6kbzMZv3FKyOERnX9xgcWLRoZUNzz6\n4nhD+FMJvR0/0214WL8e3GqB6qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN+K0xppwhuo3DoWn+/yLpJKIHOswHwYDVR0j\nBBgwFoAUPHoh1zgfiDXZsoAiyXKOa4V8WXYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiATbG/WgXcsRNPQ2NvB08HI4Twzx6Q2mfcUMb7DqIGchAIhAPc9qZli8Byo\nwwm+vKfS0UemPtk/CyAIXjBdF3dLt9LB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASqcJRVf/cyRXEhNWtDhRsxUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjJhNzIwNy0yZDExLTQzMzEtYjQwMy0wMTdhYTA3ODIxZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOA38shCk0gHV7M+E7XXA1sqvKDt48fayJ/iunvGAFSQtV\njAPBCLtHdR2B//0dxVf6r8m4u2ZT9LnGc1U2FqtKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPHoh1zgfiDXZsoAiyXKOa4V8\nWXYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbF/NkWBP63NXDM7bjRsHekKoh0e8vkD2DOZ27/gI174CIB4CEIra4yuX\nHpEYwsEpoJ1LqNNrvOFcO3ptN3M1RAEV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQmFL4Y1EGAMGQ0xnKS97qkYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU4M2RlYzMtNzA4Ni00ZjhmLTkyMDktM2VlMjliMTcwMTRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2FlNDFlZWItN2UzOC00YmRmLThlOTktMzQ5YzljNDY1\nYTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7qgOXOwSrQ7Gw/FToCq1Vqkx\nQ61elE7k7AtCiR1bRtWJiepvCYgznxGdM+SOpNScAlyr/XWc62rsYiJjIjPrzKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUN+K0xppwhuo3DoWn+/yLpJKIHOswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJEcWAKz\nr9Fgn5QHw6ZpxuPHH//1xkX2b+sBeDcAQDYNAiBp+ecl1LkuZhc4Epqzt6ncFHKO\ngKHtIFoH/qdufN2RSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4819", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4819` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAZnPyFsYm2QLe+sp3qlm8nZvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyNDU5NmUwLTQ0ZjEtNDY5Ny1hZmIxLWIyMWU4NmFkODE0NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QyZGRhZWYtY2Mz\nNS00M2FhLTgwMDMtNzQ4ZTAzMzIzMzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESzR0/hJ/xPsVwrXL1U9gfOSblFlMgQLXP6zLgMljH3N5cK9fRuHCmsrge7eM\nuW1jnYrjBBgvcS6hsMb75ngGwqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULYhOWArrDSRbgzNbj1ldcxd2HeYwHwYDVR0j\nBBgwFoAUbd1/nv8nS6P5WJvk9bRV5dapu9YwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiB3\ncitmusx6c82dd4W2nEeSs1i57GLeEvMsqS7PWnXipgIgX8c47adU5uMR4t5ZebJi\ngg52A+seP9PSjInIFH/C5oY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfdIWNDhkO5BAOXMF7camwSGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjQ1OTZlMC00NGYxLTQ2OTctYWZiMS1iMjFlODZhZDgxNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqIawYxsE62In+/b2k+03Tsj7MBUa8BFImlHRUh07LCBF+\n9Cuz87UjIvW+1DeQvTJevui7l9VDebz3nYb+O8lbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbd1/nv8nS6P5WJvk9bRV5dap\nu9YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWEjpJSgwzwZVOsMkPh0LpUYfrt+asI0QfPqksVqK6PcCIQDBkGlHizdr\njjQ1wAHT0pkjlmpLZqNvxKWn3qoaOUCxcg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZr+hq/UsyUugNpceGsmszbqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QyZGRhZWYtY2MzNS00M2FhLTgwMDMtNzQ4ZTAzMzIzMzI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQyNmE0YzItMGNmMS00M2VlLThlYjctNzViZWQ1MTM3\nZjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3a/+H7E6wIYuZC+8ZNR7JSfy\n5xJpda3cloTXziNE+lzFQzvAwnEL0U8XS48namztyC9HCAKsEvzfLH6m3Tyu3aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULYhOWArrDSRbgzNbj1ldcxd2HeYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAOBOxbvi\nCprslhkrhoWf/XSxueeD3e2EZO4ARnjXssfvAiBvJiriueRW30AJkFOW7A70DLOs\nxl/LH1h3jbL4oM+0+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4820", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4820` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYnVmPRplhWmqr9MekkKH51jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhOTJjMzZjLTM4NTQtNGE0MS1iYjlhLTA3Y2QyMDU1NTcxYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVmNWY3YTMtMTMy\nMC00OTQ0LTk4ZjgtYjBjNzI1OTUyMjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECPlSShR8xj0y0QuJegLEXZCHUb71EO0HVBvwejxw01Hbor6WD31/m3adu/NH\n0p2v0nXL7nKdrDIlZCEiL3A1gaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCMEpTlRQZGM63SNAFc6EtYIku4cwHwYDVR0j\nBBgwFoAUDDp9QgiWqDoDbxWZ9deAFyTRYqUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAyV2Cqg7rPxBirGhGIVOKSnWIvGy0raPGxfD+FE7lTSMCID5X\nyMqSJYV19CEjlpZA+sUdb41DEqwuwcZ1JvLNNHss\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARiYhKQDRoyvZ7mZ1/xe3jbqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTkyYzM2Yy0zODU0LTRhNDEtYmI5YS0wN2NkMjA1NTU3MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLIE2XNC8yw9Dwb6Q5JLco0Ubb/nFGx5yz08vwmOq5d9Nj\nCm20tMeD/Te/Na0dcZb45y1F3/tKVjttl3ybRbbco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDDp9QgiWqDoDbxWZ9deAFyTR\nYqUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVFZvVjLJT7E0ICfMYl1JYxQsAcAWPcMmzeqVt5Qvi+ECICit3TW/ynLT\ndru7fWZ2h8MkzUzl3/sUtKvJPG+WtJlf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAckyGBF89Chutv6TidwVtKQJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVmNWY3YTMtMTMyMC00OTQ0LTk4ZjgtYjBjNzI1OTUyMjdiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGUxOGRlNDUtYWQxYy00OTUwLWE5Y2UtYTFjMDI3OTky\nZjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzpV8uP34r2V1i5kD9ZLIevWV\nVjThxqG+u1dCQpZGDQFqgxGOSOMOzzOESQoYGtewb2pgeTtsVkoDfbUBv0om4aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCMEpTlRQZGM63SNAFc6EtYIku4cwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgSK+awIQ+\nyb6L74qdzzcfKGId73VZCswaY4hadt3J46gCIQDm4oqyP1oOBxawa2GfAoXwZOxB\nC8SzIcsLCo6EF3Qnxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4821", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4821` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISATOP5v5WB+X6YB7NQUa8tDMNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlOWJmODhjLWJhYTAtNDJhMS1iMjA4LTM4MWM1ZjkyNWZkOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU4NzkzY2UtNzk5\nNS00NDRiLTg1NzUtNTYyNzFlOTg5OWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdSHI+MYOllZL3m63dwzrvRVQ6fZfMoPF7BmiBKY1fwHdXxlMO4Oaf5i09f66\nAlD7rqP0LycaOXAxlDqS341PYKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdN1B+wC8pa0LfT+wuExeYjrf60AwHwYDVR0j\nBBgwFoAUPm3xM7O9qkCtttSqH3VVV/a/1MgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBJUIOZqoR5VCVaZVBtoWiAI3W8BPptM5qkh+/OaUf/zAIhAJV3\nRghnVurP3zwu+vHYykCKYsbODI2M3dm8QWOarndN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVRn1LJoFuFeg++zUTCePOKuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTliZjg4Yy1iYWEwLTQyYTEtYjIwOC0zODFjNWY5MjVmZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWamxfYBuAeamZXGJC9ihYboBGb2cZgFnjcjEfhMWc20cp\nrUcmoRyGQ7Va7Rj/SzSsvIS5gy4jnBK4C98+stlso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPm3xM7O9qkCtttSqH3VVV/a/\n1MgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUrTPaZctSx4pV4T0WCmwxEiEf7DXfSFKUZ+4zX//TDMCIQDt9gbBC32L\nI4HkXllQwRP2DoyCGptLWxqECuS4nlwMdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWLSAPN2uaaa/vYivpTSadrLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU4NzkzY2UtNzk5NS00NDRiLTg1NzUtNTYyNzFlOTg5OWI5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGJiZmUyZTAtN2FhYy00NDNlLTlmZWQtOGM2MTYxMTM5\nZWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5tIL9+gYnroVue5ji1h7ifj6\nwW8fyEMEIzejn2Qd355/PL6KqXCsEM6eNhv+ebB06gwNoZ02QXP+UcDlC8UdkqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdN1B+wC8pa0LfT+wuExeYjrf60AwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgBqQt4GjK\nmYVzzb4ZbaOD9XwJN+PUGWFcXjCFS0yOIngCIQCIFCpVphQcUfWRM0mulkpURZ4/\ncZ8cKt1duAF4mfGuSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4822", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4822` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAVQ36KcHUKIJBWwQ5Yp+ji/2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExM2Q1MzRmLTM3YTAtNGEyYS1iYzYyLTEwMGNkNzYwYzdhYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY3MWI4N2QtMTM0\nZC00Nzg4LWJhYmUtODZiYThmYzQ0Yjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED5V2VW7BosZQ4GPzCuYNsxugQSpL9kr0hMKn8PB9XBTWesulo+DDMh3nYWoM\nrlSPY+kwlWwDxYQZ/nCqsHdTU6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlVL0CuyncgIyckJfE19fCtG1eVkwHwYDVR0j\nBBgwFoAUb6pAWght6GNTlEpvCbgpkqEUzRAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAscfK5euxtVJ6\nBBhPm3o4FegcC2kT3q0YnJ+LiH4yE7cCIQDIQqWhxA4VqpuDmwxgSyC6j24JNvNw\nKMlwGODKFVDjsQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdggZCJcfQpgrI2zU6+PzDiKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTNkNTM0Zi0zN2EwLTRhMmEtYmM2Mi0xMDBjZDc2MGM3YWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdsi66+zTX0bcxdbJM/UL3hl4NoWToljNykuHTVnzE0Svz\nHDDsq0G8VUvMte+yKzmxNj2UUE1e1EhYkUw4PVfxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb6pAWght6GNTlEpvCbgpkqEU\nzRAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCvS9ElJPH10ISg8zsQPSzD4RwPpwvn1yIRTkUghak3YCIQCnXRzM8/YC\n3wnvl1GB8BULmqCTqxb2sG+idc0oj6sHJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISATzsaW+SyLIqZS3fPoOFpuBsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY3MWI4N2QtMTM0ZC00Nzg4LWJhYmUtODZiYThmYzQ0Yjk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWZkY2M0ZTctM2UwZS00MDFjLWJhZWUtNjViZDg5ZmM0\nMWYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDJDnl3pDd+0w5y9ftAt3P610\nb92bHLUHBC7JgZYEE0OUiGYoSm6i8ffpSAHfwkpIqMoQFbaIvcjAO9Y5UGn0vqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlVL0CuyncgIyckJfE19fCtG1eVkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJECkgKL\n8V4IMM+4Jx5aHGbCuMpICEu4tNdgDCiQZz/dAiEA5WfMHHk6bMClWUGxeje7f4Cv\nrUq7D8MowJ2IOFCceo0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4823", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4823` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAX9DzeLbwHlHfxSQDY4de7iYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNjJmMmU1LTlmZmUtNDA5Mi1hM2ZiLTZjMWIxNDk2MjBhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFjOTU4OTYtM2M2\nYS00ZjYzLTkwOWEtNzJmZjU1NThkNWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMIZlI/j/cz8ZJUTt0A91fkOkROAclsl1ye0ARMePjGKBiikj72njnIwJ6tr+\nIT1/36dUjVMXq3tmAiwHejnZ+KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuvkpQ1m/uSw0qxooP5rr9ZRhr/8wHwYDVR0j\nBBgwFoAUNWohqoi5nSjhQTTdepwY1Rea0b4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD43xRZGSOf3vfkPaXmJCkbB7YZVFT3ot1PMFKGq2b+sgIhANE5V/gJjp7+\nnUXd4EcZ90Mq7DEDqS77MGOnqETzkLsN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWfY9kwZgMe1StJwSKRNUe/lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDYyZjJlNS05ZmZlLTQwOTItYTNmYi02YzFiMTQ5NjIwYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOB9bwV+x+oLCmeoETBJDDy3+6R9lV/GNpacXe57h8zV0e\n6vkI7kn7CfH1RAbwsd3SMM6Oi+Kbvr0TogoINAmFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNWohqoi5nSjhQTTdepwY1Rea\n0b4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJGtLCzotl0fYLko1vejgVIVAY9IrAglHIDyNopyn3OgAiBmV32DAlfI\nT7hZYenKwBRizjmcCJU3r0VY63zBs/3ZWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAb9zIr3tCUmigxSCz1o6yoFiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFjOTU4OTYtM2M2YS00ZjYzLTkwOWEtNzJmZjU1NThkNWZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDRlZDRlZmEtYzk3Yy00NmVkLWFmODQtMGYyMmZjZGRj\nZmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE44hC7KC4GlzdlBriWNwtyzHk\nzvFbUPUFaDV/bjffoEGnGeGIahvDPxvKOvr60sLTpOeWJMRb9Ncx4Q5Pp1EdJ6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuvkpQ1m/uSw0qxooP5rr9ZRhr/8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPF6Cn1t\ns0oKwtYCAj4Dwxl+WrhYRFxL3paqg2rXXxAHAiEAw5HIPejjtYwyQwV1i5rhL8uW\nkIUJZG/8GLSS+SX5hAg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4824", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4824` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUmuCEERGAoJtDDpIiDD0dGiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxMmYwYTk4LTk3MTUtNDUzMS1iNDNmLWMyYmRmMjI4MDUxNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDc1N2NjYWQtMTRl\nZi00N2Y3LTg5MDItM2FjNmZiYjAyNzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyXwLhV6sQ1KlO6nT2pirlW/qq/MVCUj2YXGZnV5pXUoA4F136Inz1zD4cHJt\nkI+6rRBWVa+SxOEpH4qt6cKACKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy6FdDjRhCauDLLlbSRxtPUVCY7MwHwYDVR0j\nBBgwFoAUNZSBPRA/NQ0XcQP+2BkRs/QeKh4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCPVIDvgBIko+y8eWwTofLV7YjoAHefnOdGqVllqTMezwIgYv4FZ96Yle8E\nYbUpcHLW3itB/G8uQnaNlZKc/I1IftI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYR11oBrHLrz5tg9SEI5Hw8gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTJmMGE5OC05NzE1LTQ1MzEtYjQzZi1jMmJkZjIyODA1MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToQ1HSa+LsGUBJf4Mfd0Vn5dhDsnllVVhi1YMVkyZerUOK\nZl4DfI7dyx3vJ+3EafMiCn9ZM9WcltRKmlAt0wiNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNZSBPRA/NQ0XcQP+2BkRs/Qe\nKh4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWq9MLhnH0Im9Bkk/ET3kqEcjBVfdAB04lDCCJ9FiEVECIQDNy626D6bV\ni/jyiZIRbQIFJfj19zV3/CIgRzB0ObACDQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQy07z1GZwKYPC5bSMRbUPJpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDc1N2NjYWQtMTRlZi00N2Y3LTg5MDItM2FjNmZiYjAyNzhiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWU1MjFlYjUtYjY0Yy00Y2E2LTgzOTMtMTc2MjExMzg0\nOWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkUMwmNldTVShtKEJvlyaphDD\nv0UVltYphaAd0aAmXcQOLxcxWwbLhLUesXWKYdpsEwqJHyjD25XgFkM3X2ZL1KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy6FdDjRhCauDLLlbSRxtPUVCY7MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJHW9K1j\nH+Gi8FO9TVcckaNvPPS2Wgnyjqge6TaZujrhAiEA3R/IwmTwSqK5RJSutO3G8Ji5\nr0nH7BP1A/+ty79vEKg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4825", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4825` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAbCVCljDYsj7SitUUTi161CFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjMjhhMzQyLTJkMzktNGJjMi1hZmMwLThmMjY2NDUzODBjYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NhZjBmMTMtMjZj\nYS00ODRhLTk5YzAtZmU1MmJiOWVjOTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2Q1aspfDLF874jfHV+hfP0AHEull2Y1w7BZ5ZfWFItu8/3dyCq3OACqkek8g\nAhg2/TacH5DIacozqwW5SPuk96OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPrWBvqwLyMKQpYeQcKkAM/Sn8ncwHwYDVR0j\nBBgwFoAULCIaWoBxFbZomNaiH0NT9bkMVokwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAwR+MEXAz1nETgsCiqLff5KAYNb79WPqYDKlyHROODIwIgD3HdVKsXEq5J\nk5DH7KLjw48MSkw2AoSEy+jMTxvHzDs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfjqzYhLz9qTNfJhaYbfXxYIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzI4YTM0Mi0yZDM5LTRiYzItYWZjMC04ZjI2NjQ1MzgwY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbk8BPPhIzBMY9mCEGyc7GdYCbHK3cqlYTn2hQ0lEqzmeg\nm1iFxIEx/aZPqUzQUwf6djxtAYS27YD0wAynkeAKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULCIaWoBxFbZomNaiH0NT9bkM\nVokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfl7wNkMtlfJDVpqqQ1K53BYsndD2K5QBCrTnj0itQOYCIBXQRUL3WNg9\n2Ryc6M5klgp9S3HnOogIMsjM6AfmYX2G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAaYIY3fHMCX7kcegNSSgtgVwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NhZjBmMTMtMjZjYS00ODRhLTk5YzAtZmU1MmJiOWVjOTM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTYzMWVjYWItMjBmYy00Mzg1LTkyNDAtMmFlZGMxMGJj\nYmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEYeI/DnGmOWv2tkUf1a5RBLu\n42Zj2lTOEnAmsnsTh888qfYXBrUY70EButG/3Mtg+Hg2zhDWcuyTs84DAHiFUKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPrWBvqwLyMKQpYeQcKkAM/Sn8ncwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIoHemB2\nLBD7s1xKLW7Kmba9kIkwULtQg6WyzB/ajrleAiEA5LcJF4ab4WKoHR8G3zXtZTh8\nyiak/v/8R7m/4+Ogobc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4826", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4826` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAVk0bHeFC+Tnb3Bvs2Ng5uaKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ZGI2NTgzLTZhMGItNDMxMy05NjAyLTExYjZmMDY3Zjc2OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmMyYTY0MGItOGYw\nOC00MzcxLWEzM2UtNDE1YTY4N2Y5MjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKpLR78rfa5Ju4LiAo9aOnJ++kEvHujHx8fnRHiQU1cWmRR7WekTa9VS9kqN8\nPfLxmePVvROwfhEkzFre0uKD+6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTmCYqEE+8+gPJWJ0hU5LMTuNC0UwHwYDVR0j\nBBgwFoAUIvsn0KGAOnDOqe1FEaKvQOQ4fbgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA6c5tkZ56Z8/m71EP123Nbwivmut6wd5b4PL1Tu+A\nM14CIQDlZ1c9xdhw+QBF2RkwntcX2REyt89SjJaTmd7u50BmFQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAabFlyioNd9kZBDzYzFnMEQ1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2RiNjU4My02YTBiLTQzMTMtOTYwMi0xMWI2ZjA2N2Y3NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6ZQDWFP+EX7TyBDV15F2YPRjF6mDmcCmt9dF5K013+CuQ\nbCLdr3rEzeCkzmhdjh7vvGwubqluxDxO2NcVAxU6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIvsn0KGAOnDOqe1FEaKvQOQ4\nfbgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbTNefkff7kcrqvmRtkijHl8W0Jw0l3eE1VpyVW/XjMUCIQCg7t5oav6C\nJyh3CUdzB+i0alsZyT+9wEHrnp+D5jxwvw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISARVW7/9ZU3KaCdePMCYg/ZEXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmMyYTY0MGItOGYwOC00MzcxLWEzM2UtNDE1YTY4N2Y5MjUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmFmYTA1MDItYTg3Yy00NjU0LTliZjctMWU1ODRkYjRm\nNmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFvAZHjKDR0N8DCOwfP/7iOMO\nhJ2Lg+aimNqPOxZLthIWA8M19kvul72qXmy59kVz0xs0NruKaT8HKcyCz/K+XaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTmCYqEE+8+gPJWJ0hU5LMTuNC0UwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgYhqeVWdO\nnHBgNf6KBwCcKkNGm9nAmNW35B6GMMDLJoUCIFY/TD2rchz42bzSuQ24dbhsfOe6\nHms3UgZUUGxr9HGp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4827", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4827` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASZNApSsDY3hzzfIgQK4smAfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYjk0M2IwLWI4YjEtNGE4OC05Mzc1LWJiYTlkYmI1YTQyNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RjOWU4YTUtNmJh\nNS00OWE1LWE5MjMtN2FiMjVjN2ZhMGY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1fN18xc9ynPGSgwErUdU5WLsQWA1/D4HdJADz2JZePwScHsQyG1Wxr3ZbShQ\nWVY7hB+ZcPJ/zT491oAUM55HHaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbb7XVZm9auILLmD+cVYnLAxXId4wHwYDVR0j\nBBgwFoAU55YdsfUj7kks27KDQ7uP2a0p2fAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBXu9Chh+fzb5okabJZquyzrfW0FOW9CsoVdDxN0zw8\n+wIhAJ4YPS+BHDIUzo591S1b5JhszMQ5tNuARTmgoLTzD/TD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVpI59UK9UKGqpnP/RiLlMuoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGI5NDNiMC1iOGIxLTRhODgtOTM3NS1iYmE5ZGJiNWE0MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrevrzKWyqwWHJRx0L+ythSq/iJmsaeNuT8jSCXAAhrxF6\nIUNLCmk1PIS44yF9+g6dfyyPjMAOwBXJEGdiHLJao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU55YdsfUj7kks27KDQ7uP2a0p\n2fAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK6kpWGpeJaFaW2CD5ZHAuJhkcGObiz0krbIrFAFHF65AiBLuL1avuLn\nrB3fgCkVIrn+CRR5HIMl2Ww7abqazJJoiA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdNBVbHP2t26suY3vhCJOhKbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RjOWU4YTUtNmJhNS00OWE1LWE5MjMtN2FiMjVjN2ZhMGY1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTFjOGQ5MGYtMmQzMS00NTJhLThmZDItNjBhYWFhMmMz\nYjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2Idn7gFD8k3ZZn4FvbyYxNor\nKkVDu4OZyYVdDHwUI5SL+ugfT9iq22Y9xW74Swqwqbr+BNZP8c9YP9bMmf8mM6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbb7XVZm9auILLmD+cVYnLAxXId4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgW6AHIWlQ\napcWa+agRwOHW8kPpX5LFi8sKFjvCiswj9gCIQC7TUCYfkkvuRQc/8s+xQtKWdQX\nxmniJ9kvG80xsHZvKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4828", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4828` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAdQUhtAOXTMQ4G4OdM4GKbd/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjOTUyMzZjLWJlMGMtNDNhMS05NDFhLTQyMGU0MDZmN2IwMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGMwOTdiMzUtMDg1\nNy00YzVjLThlNTItMjFiZTk3YjljOThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0WfaX24VQ3/kES7yGZDlb88+hA35bQgpB+wxU++zBYEwgX/9AXq8fdDD94x+\nakSZIEd5zEguzdMbeRWZ38be96OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4q8gRBmBr9B1izMk+hJCg+wzew4wHwYDVR0j\nBBgwFoAUOMroTnHlm89DmoAQg89uzjORUlowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAqGB+RwwmO4SXygE2dfibSRZSRRPp87GoyDg5cCOqWGwIgNGwJ\n3O7oPs8Lxd1xjdMZjzDmpEPZwKhHVhWjy71hmqk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaf5ttZZk1Es9z+n7xJINDuvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzk1MjM2Yy1iZTBjLTQzYTEtOTQxYS00MjBlNDA2ZjdiMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR284t+x5Q7Enp2MwMLzYrsVb1jrsnCdlucjHaPIDEth1SZ\n0GD7nxSzwgYNf0mTe1h6NPZsfDYNrGw5TNSAx3P1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOMroTnHlm89DmoAQg89uzjOR\nUlowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM1XjK5wEBGOxf/dyNXo+U14nytyHIEmhN8QQ9qQgLjIAiEAq1H1c/+2\nBYQfj5GiIgSZz2+U/Se+fzUKaaW8dT8+QOY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAeI+aNufphlFUlAHsyZ3w1H/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGMwOTdiMzUtMDg1Ny00YzVjLThlNTItMjFiZTk3YjljOThiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2YzMjc4NmUtODk5Yi00YzBiLWE0NWItMmVmYzNkNzcy\nYWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE11b5K2UqdEwj0L8CwRoI8MX1\nKt2t9aodVCguWrQcIPsfuPcbJOYZa1sX5oAus9erS1FEZhZjrVo3UxSFblgEbaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4q8gRBmBr9B1izMk+hJCg+wzew4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPdq3Jrj\ng0mKjK978Op8boArspnqzCgJiWZSycRD20ZjAiEAgcPCSFF2xCMAMJx+IZGIRc76\nyzG/ZQKq5t5xCsThUvY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4829", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4829` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAb6f16pautozkysH75TUVqhnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3M2FiMmEyLWIwZTYtNDRkYi1iZDEwLWQ0ZDllOTcwOWU5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFhNjZkOWUtNGU3\nYy00Yjk2LWJjYmQtMzg0M2MyOGM3NzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFf6Ol8r2MbdgyiiT8aVUiiKsYvfRqhT0aycNReDjkFJsVH205OmGrMuBNBRp\nHlDaHIXcwRbpJmLpzbXHu4B2T6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU40JdHygA1E5btDfrVxGsKc0ahHMwHwYDVR0j\nBBgwFoAUl+FpJa/mp/qm94I+b01Td25QZtwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBJ1M8FTmp+nJxnY9gZVAAx6YtScoF3fdoN\n/IHvM5jX5gIhAPGjftQsei90v3CiX9AYR2FdLnwXzroAdx1qHY70Cko/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAToI+Tg7C5qX8zqVIGxDbXlqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzNhYjJhMi1iMGU2LTQ0ZGItYmQxMC1kNGQ5ZTk3MDllOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGBiQZWmXZ+d3PTq5hmzeBR6/HaOYOUd9TsUGKRkm9btlN\nXiJb7PQ5vCfzD7V4LPyl9ydn21rxmabAmSzyfgJJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+FpJa/mp/qm94I+b01Td25Q\nZtwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgELvZ5u3b6NCIENpn6kG48JXnTrni7zXEJhQIWWPIX/ECIQCMOMqlNb2k\n5Xy1hBuMB5IVQ2c1RCgrj0Wzas5igegVrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAYf/TfYTCpRVEO+XFLEAyfbIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFhNjZkOWUtNGU3Yy00Yjk2LWJjYmQtMzg0M2MyOGM3NzVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzM4OGNhOGEtZGUxMy00MGYzLWE5MmQtN2MyNzAzYmQ2\nOTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEukbrSoxex1QSzobbB1lkukRU\nltK3GDJJfdy4kynkLc98B9GhGOiVJvbH6gdDiLsH4AxKFRRJnfqv1o6P4TcoSKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU40JdHygA1E5btDfrVxGsKc0ahHMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgS5CYkV47\nImJ9ic5FOxHceWeD7jmaJ5y0YSOlc1oNqyYCIBNfKWyD4qR25tKdx7Wkdj206nAY\ng5B5qdX6w/YpB5nu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4830", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4830` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAaVKkiv68eW194b7Zl1wVwugMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0OTJiNjkxLWU0ZjEtNDdlZi05ZDE1LWNmMzU4NWY0NWM5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThhOWVjMTktZWM4\nZi00ZmVjLTgxZjMtNDZjNzRiNjliYzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIAL1A5ozjFwyIIb8xFCWQCYSm5Kv5ZKIxN6rJF2rL6MrqmxQS0kKGMih9O79\nMftSFAwfxEybPKBFKZ7VyNNE4qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUshrhmU5O0x9pZIDf3Qy+aYrKZ70wHwYDVR0j\nBBgwFoAUr6DYU2lLI4G7SnmTteQu81CrSTkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA6gP13FRjvqaNWrgF95Nucal8Vc5lRIvy\nNsFHoMpA0s8CIQDQ7tfUgao8NT5etROu9BNUDotZbJbU2/5u2X4yP8pfjw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcALeCG5JZLyX6GR5D1wLylNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNDkyYjY5MS1lNGYxLTQ3ZWYtOWQxNS1jZjM1ODVmNDVjOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARw0UbMlZ2evp/JPHB+yx+QvMXp0486CRaq+6O/8+xDm4K0\nbK0FOgMN/9Lh8poEEqdRF7UatcSY3J+/nYdP3J2So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr6DYU2lLI4G7SnmTteQu81Cr\nSTkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJFesDi91lUXFgbUaOR9ZI0d+OiezrRCJzgQ5WcZzUoLAiEA3hqE1vL0\nv02nFbuObG9vvBSm7LvgZnL5RVE1gS6nbUQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAfkyMwrZJVacUnOY9QrP2a5vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThhOWVjMTktZWM4Zi00ZmVjLTgxZjMtNDZjNzRiNjliYzdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmJhM2QyN2MtNjM4My00ZjMyLTk1MzQtOTkwZWUzY2I1\nMmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEh9LH67/C8o2hfSyfOd/ri/o3\nEU+MPSTfy3Fgimv91ZcAUtnW4BhkGPatr7sptLFGKBlJh/UmBcz/QDpMieLoYKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUshrhmU5O0x9pZIDf3Qy+aYrKZ70wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhALBprnPU\npN6cBC5Zv82ajHSAG5qy5r93Huwi+pBauZVYAiEA3bGYYuskZ8HJI2IP3l0TZAFa\ndacdEb8NmiAOVipO9Ns=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4831", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4831` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARVOQkM0FjJxKNsGlpVV1xGIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzYmZkZjAwLWJkMGYtNDAzNS05NDJkLTgwMjAyMGQxMmNiNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdjNmQ4MWUtN2M1\nNS00OWJiLWJjYTEtNzk5YTE2ZWYxMjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQZ++msSqyBt2l2Sd8LIb3J8pUTttVdW6UnVR5+ZhiImJ9h9aN8jPz3+Ik9a4\nk9uwEAhGNdG2x/ofCuyCbEg6sKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIx0YZMQ97rPo/37shwTDsuUlc2cwHwYDVR0j\nBBgwFoAU9zmFaibx7o57U9GkMXcCVbEIiOIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiABo9ctHLfeyzXU\nSkn8dxCHu+qZp4qflfrQP3Q3C21ATwIhAObNTSqrFoXBXeQxfqLbRfc1TbUzThT3\nxIAqoforeGmN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaZbk3r9zulA0xet7oeNcdsCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2JmZGYwMC1iZDBmLTQwMzUtOTQyZC04MDIwMjBkMTJjYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmg7LtrenpBJp45eRRtlrebO+8SMVpAbGr1i0VThUcHYl7\noG7e3OxtrwPFLL/HvtfbIupUk2RAhV/Q0DDejb84o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9zmFaibx7o57U9GkMXcCVbEI\niOIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANo1Qr998QZJz8xuf6sgtOjYdLeqzSk7EvpxzGo9tISJAiBotnVlZQ4C\n6ex5bxzC4P5hg/lTeMG2RHPg/doGrl8/1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQZ7oreRZOWe19/M7MqVOHBcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdjNmQ4MWUtN2M1NS00OWJiLWJjYTEtNzk5YTE2ZWYxMjk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWY2NzQ4YTItOGE4Mi00OGYyLWI0NjctODMxOTM1MDUx\nNTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERksy5Bi8NvUaXwUf/YJ1udkm\nBXWo13weiAhVvTA04P//CrMNLB1lAGsrVMXpMenw8OkknonOSa9w1bCW6DEQI6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIx0YZMQ97rPo/37shwTDsuUlc2cwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAO7SOXgB\nIrDsZHNPFdagV/YuL59rAsq7fd6/XjGdDlZeAiEAmOJhaP80RxJ1lp4EE0AGp//B\n4xwt4HeW6xJD8TpHjsE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4832", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4832` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAW93sFY62QDy00LZORFyUr4uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4Y2I3N2ZhLTA1MmItNGY2YS04YzFlLWRiN2VmYjczOGVmNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRlZTUwZjctOWY5\nNy00ODkyLWFlZDYtNDAxNjM5NjMxYjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtLJOPloJw+z3RpLwdicsBcSj44zX+SfLmzqGeSFk1keAoGIXOKHsrC6zTmCW\nBG9XyS4VAzsAHjvZ7wIA+jy/5qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU13i86AEbjoXDMvfoqbnUlAhBldcwHwYDVR0j\nBBgwFoAUO+N8hLSo6Cq+GOkxQYYK/U9fF+QwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDl7CdpwKVzlY7FQBn77salIdMniTj4hDDYmipldw7cRAIhAMGtUGMixfTp\nUBlU7K/dI2LZXDCiQow9j8I2NNvV01Mp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASgosyiDknwaDJGRqz6t6hr+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOGNiNzdmYS0wNTJiLTRmNmEtOGMxZS1kYjdlZmI3MzhlZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHpcu05M6cGxQ7HdRLR2i61lf3mD42B9d9Dt3D5QRjzS2S\nlAjDnHqSWq7vSrb1ohrRb3BrZCLRTZ3fzvr9fhTuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO+N8hLSo6Cq+GOkxQYYK/U9f\nF+QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNHd1BRCyIOb1ygAk7JZsDqANejUcQ4wzANg5VVXOh14CIQCd2+ID02hI\nMCzHncb1FvQoU/60M1dJbbbTDPKjuCuqjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAdy294mgLC4XlEWtxzk4nU4qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRlZTUwZjctOWY5Ny00ODkyLWFlZDYtNDAxNjM5NjMxYjMyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTVlYmZkNmQtZmQ4Yy00MTYxLWJmZjgtN2QwYzAwMWU1\nNzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEREun2g8GdU1SyGmJqIjIG8IR\nYziL1bzrTs3rxB3SfmpWqumq4t/0tNy/TnYR12ox8+nRE3cfsE+LNx1/8rGctaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU13i86AEbjoXDMvfoqbnUlAhBldcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgQssG07hq\n7LvPmaS7eUwrK678OykhKaX9llbLVIZBr4QCICfgq/dHqXNe17BJl+Vbi//kJwI6\n9N/ZAW/prRl2xNHB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4833", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4833` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZB6PBbV9C9SUfLcj0SEgUwaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxYTM4NjkyLTY2ZGItNDMxMy04ZjFiLTYzYWRhODIyODc0MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I5MjgyYTktOWU4\nOS00MmFkLThiOWQtOWEzNTcxOTNjMzIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIj5ijdjfN5HGV6IkkBZhK3jUc+0Ne6ux9Oq3W/C08ld3pVpMPiAHB39h9VDc\n8O90GCVOF0FDN6RQNXKCLUDns6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+0wCGYPuZyRwKWVoYQ/iAQxkxNgwHwYDVR0j\nBBgwFoAUGI4ZEU4I6i1rfrv9UECtExfJihAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC0bX78+1DHkic2+7BvL1yIkn2rKBTl8sp/NqtjP1YhkAIgP5y4AVf4bQf8\nXbMT9MqW3zpvzH7xAG1b2K12zIRMNSs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARIV0CzSyoxSed5HdTnV1UqjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWEzODY5Mi02NmRiLTQzMTMtOGYxYi02M2FkYTgyMjg3NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARg1kd0mxTpxISWgc0x+nkYnVIE93adAkxD83QNDM/XkCPm\neu/qOXyDNqiPiYtZpfR/BtCt5/gneMLN7IWNfR9Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGI4ZEU4I6i1rfrv9UECtExfJ\nihAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAM/Z+XNobLCR96EoXVEVtHHiTo7MyPyNDMzlESUzC/cCIQCfOYQ9icuX\nr4DReanI16z6zrKuv4o/m6H6GAqVdUhtwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAa7MB5scd3N4q68n3IF/Y9+jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I5MjgyYTktOWU4OS00MmFkLThiOWQtOWEzNTcxOTNjMzIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGFmYzQ2ZWEtM2U5Zi00OTg4LWEzOWItZTNiMGMyNzdi\nODMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYmt0m5XlM6ekBPubiiMKcV1z\nIkA99tZyL8311ZhUHcUJ5MUFwIQkK4lR0oeRrIsUXq16v4H2bXbnm93/o1R4EKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+0wCGYPuZyRwKWVoYQ/iAQxkxNgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgc2em4mqw\nFSrhg3RbmAMCgIPYfZP9oL2fBj/lChy1iO0CIQC87HUcFGw8IXZIPNq1zVPa9Shp\nlI+8L96eLLSJNAIUyg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4834", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4834` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAUb00Seyv5bRfEW6DHUbavu1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4NTZlNzk0LWI2NTQtNDRhMC04NGVmLTkyY2ExMzJlYTA1NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY1YThkYzEtNDc3\nMy00M2YxLThiYTItNDhjMDQwZDVmNjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdhJUq8bLcXTWo2dJWt2KkPg2IOgIlFp/iwR4FF3wWKNv4dahwsNsVC5sfXvs\nAAmRrhODrk3kQNa6WEO/iFkwsqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWmq7RwknImOyQNDAJbBBQ2CWdVkwHwYDVR0j\nBBgwFoAUdfqGpgfJGg7Ib1sm3myUdDJTZyYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiB3mz/wIHc/PXSxdNhsSnRwKYR04WnaPM/wJDinGGG2EwIhAK2rRPOkYW9J\nYxmnTn6wTzfBSiG7cys5eVc2nh25j9l8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU2vSSjhAfq8i67MVAMW8qi5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODU2ZTc5NC1iNjU0LTQ0YTAtODRlZi05MmNhMTMyZWEwNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7swV2h2zs0Spn4Nqi2QdjuKhqqd94N8ikTSwK4usyNW/8\nYtxac1t4dJgMZ/emuPehfa05AxqIPtaGwVu3jJ22o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdfqGpgfJGg7Ib1sm3myUdDJT\nZyYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaHBHcxbJa2R8MRRZ6tuwtSYagbOOkxnKrxKY4/+LNrICIQDvFvL9akoL\nS8o8f4TYFmUqjv5PT0Bv7xyket3d7GcmuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAct75viqyBApSHBdqpJsSOK2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY1YThkYzEtNDc3My00M2YxLThiYTItNDhjMDQwZDVmNjI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWYwY2VjMDctMDRkYS00ZjQyLTk0NDEtNWJkZDVlZTNm\nN2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgwSadX47yTzkDEuFWBI0e2+u\nc9AXa0vRGp/9ns8C+dlUTeq4Ue7asXJ8UflHmhZnO04+/678iR7y3MNHpaNMh6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWmq7RwknImOyQNDAJbBBQ2CWdVkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgF2ZBqr2d\n2PLKlo1QX79EYHW9PWtyPR2yLbSvyaYc0O4CIQCNa1Mg/4ZXVHmaiK+Pmqcba8lW\nbUs2D9tZ0ma9yAyIWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4835", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4835` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAfVNZE34Tnj6ZBYxLNKpzCmyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyZGVmZDFiLThjZjItNDczZC05ZWU3LWU2OGUxNmJhM2Y4MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBiMTQzMTctMTA1\nNy00ZmVmLWFkNTUtNmZjZTk1Y2QyMmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzXrbj5ngrhnydDM4ZQLVxl8ZUmYEmjgdq6sa9HykROfDkwk4YbNpnx9KXXTp\nQTBuXizY5sl6xo6s4mQfrvGvA6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb0Rcw4PIgMUmcDcjbFSk8TF7UNAwHwYDVR0j\nBBgwFoAUsWtArZ1vJSMlvyOtyixO9h0JSEcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA6FdEoVwQ8Wjn6TFC997AWdolU90ckdje66QaM3tP\neroCIQDMzLMKe4LdcRKtqzXQQRW97xa8NufYYkEN0jSBLmNP4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfvMgwwwQ8igSFbqUZ4SXKUzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmRlZmQxYi04Y2YyLTQ3M2QtOWVlNy1lNjhlMTZiYTNmODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyDSq/iex06aS2CEbL4FLNt40KDGi0jJnbToJD/Cm6Iv9V\nVO29hy8u8JJRYLq1FiYh2APiNwLyHkcK/5ve/EZ/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsWtArZ1vJSMlvyOtyixO9h0J\nSEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBjmWfBd6dzx+Q7P56j8jXocbwOODIdEY4MRkNtc86bQCIDhQpsww03uh\nRgH9w89knuo6HbsRlgYmlJT7iK3gr+eQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcBAlrrAUx1bf2wTffnspPrWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBiMTQzMTctMTA1Ny00ZmVmLWFkNTUtNmZjZTk1Y2QyMmZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWIxYzBlZmUtZjRjZS00YjhkLWJlZTEtOWJiMTQ3ZDg5\nM2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJGJOP20p9pxllxVRiaMxfXku\n2EPsX66jPevLQbxy/6g6/HKyPXupOHKByf/LTzlkFtu89OSIohMH78NJ+G+Wy6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUb0Rcw4PIgMUmcDcjbFSk8TF7UNAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKhMQ/z2\nNMX2V7g14Kn6n9kBFFD5Pb72owB1Jem3BcP/AiEAv8jdN20InlUA/h6LT4BlAot6\n0S4Z5BqIoeSHSVEMTp8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4836", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4836` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASJmJNY8vQj5upCxWMoo9EozMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxMzA0ZmJmLTdmNTktNDkzYy1hYjM4LWFmMDY2MTE2OWQ2ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmIwMjczNmMtNTI4\nNS00ZTQ3LWEzMGMtNWMyNDgyNzRlNmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeqh5T+HJ9AB0cPycoMqkHzaNtH/WUoGTLgf2uf2CNbGOb2B3PaQffs1kM8Zg\n4GC2YiUwoF4LaSSJ/d7bntYHS6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoCpPVf6TIvkujDncX1ez6EYTvcwwHwYDVR0j\nBBgwFoAUFOp58vmIaTCJkVcldlaVEa0B/aswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA3b+UDb2RyEWMdtE6CrMxmmusiP3A6J1xTHisQZuD\n6aUCICyvdMyWhJAQe2+//MGByxcFb8boK7GvmYXxSQAfHIaS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXZCbvd0lYFyjEa5GZT7tFwKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTMwNGZiZi03ZjU5LTQ5M2MtYWIzOC1hZjA2NjExNjlkNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRqj+4YbVH0sOBV2yEiTlPHfOwX26WbNdSV85TZRM4jbOx\n3DbTbT1s9jAsFxaqC5+ozG+S8kYZtwXro9/AtuFJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFOp58vmIaTCJkVcldlaVEa0B\n/aswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ942GrVxPXojcrM9nI2Fo6CPj43mKMeg7sZFUG/NFcYCIDCzD53gfFzh\n84zyzN7GhBy5XoSoLYH87LRABjTAJuwW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcB9X1z5m4o6sT7AHntKDGSIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmIwMjczNmMtNTI4NS00ZTQ3LWEzMGMtNWMyNDgyNzRlNmEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzRjODEzZGUtYjhmNC00ODViLWJjMzItMTZkZjlmNWMy\nZjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0wX6eQJUKz/kn4C2dPWEppoO\ncqqaZq/Hr4MLUZTDc74BVJRLU/wwl/WtKKHJmdq1zXEwlJuYU0FNPvOsneYZ56N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoCpPVf6TIvkujDncX1ez6EYTvcwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMSxk9CO\n14cLE1Ebop6lv66Kr++XAROhvpGZzXMUhXkyAiEA6MOMibVkHJgqg4HsEKHAIZrc\nNFNDjbG5rmQ4S/TYzqE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4837", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4837` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAfXmN8jomInSNR6b0Y9rOifoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4NWM1NjBmLWEzZjAtNGVkOS1iM2FiLTkxOWRiYzI1ZTRhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc4MjRmZjQtY2Zh\nYS00NDFmLThjYzktMTA5NjRjODdiNDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq3cK0b3AVdYb6XbtshpS0H7Fo+b/X0ft/9D75UeA/LT4FPo40N5JCNvfuhHX\nB670JHg3Mw6kG14Uq1cRlcPUT6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1EC3TZ9Xut80C/tGw7CDvckje3UwHwYDVR0j\nBBgwFoAUYRTXSPsRVL47FXylVQVpF/Q+ErMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAmt/0KMeXMXxewuXfxmr/TN5PVeG7hwU4guQv1z3G/qgCICA/\nuTjqchpxaTHvrmVbnimx6T8ssTdl/1dLxRf9FYX+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAai/MNs5JHJZkPI8nsgIC/3XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODVjNTYwZi1hM2YwLTRlZDktYjNhYi05MTlkYmMyNWU0YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqKv9TgZ/XaXCkMSrxIjuGVzK1v4v2591qlpZTOlRE6SBT\njsssnEQXLmr4B6IxprUQMjNCrG2crOn+b8i1ZY8Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYRTXSPsRVL47FXylVQVpF/Q+\nErMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO1WG3RgNidtwpix36mUOybbT5CN7NW6lMh8Hu9Ue9UbAiAosCigVWC2\nLURKjksOv4bIMgRSDxZR4sZ/9luNCzu+SQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAR6HHKtQoxyifCb+bdAT1hsfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc4MjRmZjQtY2ZhYS00NDFmLThjYzktMTA5NjRjODdiNDM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTE4NTUzMGItMzY1Zi00ODcyLTg4MjgtNmU0NTgxZGYw\nY2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg2bIPyVX7FIBfP1/8KrOsmwN\nIEm3NyQH4MXMefxrK8krZG0hC5lDE2emoAAtWZCf64n64eSw6YScFxJO27cVMaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1EC3TZ9Xut80C/tGw7CDvckje3UwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgCkCjsY3j\nD6cFCegRvMhEqbeh/6g5ouPjtqgvgt28xlYCIEzqnLwMgbzujzO+nOK78GPZNqD2\n7+lEs/+gvQedRpT1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4838", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4838` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAcJKoCsXXQoOcmcV8IoNHnIkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjOGUwYTNkLWUwNGQtNDhkOC1hMWRiLTg1ZmZiYmFkYjZkNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU0MjlmOTktYTNi\nZS00ZTYyLWE0MWMtMTI3NDUzYWRkOTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENZP/PSpiwF5VNULyTFiTa23lqxZIrIMDakBapnteaBiM+dbu7dqLbAsVgkBN\niP0mms+70XkzozEX44B905vzVqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuw4aaI4caJwV0ueHlnCaWZHxjqowHwYDVR0j\nBBgwFoAUuzS4rtLn5ZQQ90VsphntW+OMSmcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEArl3gCaEN0Gq+G/4nxiGIsqWvNIiQeBAG\nbLoeYgQuK0cCIEz96MO1Sic1arCeQH8PoSPck+92cnJA3tu99vp9l8K2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXpsO3QotvNd0QV5zi4BLcyEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzhlMGEzZC1lMDRkLTQ4ZDgtYTFkYi04NWZmYmJhZGI2ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZwXGHIw2pwgsr/rWlUK+xzgRaukLg7ktsurmV2iUzbwqF\nTkW4b9Gj2UKPL4ZcvE6UpT//z2C1LBwd2Ksvm/jGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuzS4rtLn5ZQQ90VsphntW+OM\nSmcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGRQdIw+iQWwPXLvngwSMeD/uB7d9NVwD8/krnTp7OewCICsIhFLAF5XC\n/ycI8UzIUKt2ZrYBsw407SZzSl5YE0e6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWKxd7D3sxYZskorWBBVBU+aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU0MjlmOTktYTNiZS00ZTYyLWE0MWMtMTI3NDUzYWRkOTM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjI4OTkwYjItODhkNS00ZjdmLWE1NmQtZGUyMWEwYmEx\nNzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtsIUw7jyktPyn+pkInn1lqo7\nQTzuFq19LU3geyrQfUhaPR7vlMs7VywB/SRcgVx8V/v/zpGqt4ZTWmrdS9rKYaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuw4aaI4caJwV0ueHlnCaWZHxjqowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgeAesJnr9\no54+kHX0EZxhv4ed/zwUXQFC/B58iT9bAi4CIQC6qk7EMRlY7ORQ5+/aAxJGlPz3\nwNcn6P1YmaYZ7IM5tg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4839", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4839` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAdLg6l9CV8+7IVm+T7HpliJmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1MDFmOGNmLTgwMzEtNDhmYS1iMGM4LTgyNjc3YzhmZGRmNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmI1YjkwOTktYjc3\nZS00ZTk4LWJiMjMtYmVmYmZlOTQ5NDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPUqflKH+jJlKExU/QjEghkJWtVhD1Mv7woYEejVK712EyEG41+tduWWxLQCY\nAgzR58jH85HUsqxpuvRgF09sgKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1anufcOjBU+OdAicJ8RNVQ92lBcwHwYDVR0j\nBBgwFoAU6S1ZdJstCswJlwFY+vLs+BKCCEcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAta98pSpHe594CGqI4wEcxp7F+XWhz1cG\ncdH503IfkNACIQDhri2lc3yL+wfK3qB2UqZkvpzL+MeHkHicuHQza2EqRw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUkAJPnxepE6/nAZib8+iYgKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTAxZjhjZi04MDMxLTQ4ZmEtYjBjOC04MjY3N2M4ZmRkZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/+0WH9OYhBlDBZ55XAfb+zOjTtRHaF21B9o6MjoVKQUa+\nArOxwdLxOBSppo73/S3dZQOqsZfhi5gOruew6/WYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6S1ZdJstCswJlwFY+vLs+BKC\nCEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJKNbB8oTHU1/zsPLWxsYpWE4aYOqVG+xCTzjbrUlcKQCIQDimhmkl3Ia\nDlTnLyydnpqubB28BMgPlpmplMzyumLNog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQnxm6ALMdlJjzcbVt1CoD0qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmI1YjkwOTktYjc3ZS00ZTk4LWJiMjMtYmVmYmZlOTQ5NDgyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjA1NzlmNjYtM2NmMC00NmE1LTlhZDYtNzJhNjhhMmNj\nYmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHWWrNUByu+8OiARz6EZoYOZS\n83uM9nnMdyWpxzmUkWZPOf652YmfrC0HDaPH6HWJc9TxNk36m9CEbpyGb9hggqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1anufcOjBU+OdAicJ8RNVQ92lBcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAI8PZo2x\nLS92Vxk6nXumbsnKbKZ6Iq9OneCiDwKT/b8qAiB/wWVIWeO6jn2lqH0FaYQem/Ie\nztP1sKWs5S7/RTGenQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4840", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4840` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAUWI77pCWgaotDVatml227C5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmN2I5NWIyLTE5Y2EtNDljMC1hZjNjLTQyNzU4ODFlMTIxOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTcwZmIzYTMtYzdl\nYy00YWIzLWIwMGQtZTBjNjBmNmYxYzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpjR0CuLpdaZzR+kghRDR6rlZ86KefBpIw1EG4JZ3/a55AcI2+Grddey5m06Q\n1d59Hi1OwbrvohmDc+RPJIWhGaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZASAK2h4M6i3Wj4rks0Awquq9UgwHwYDVR0j\nBBgwFoAUvnnnpVIuQSI8nWwYk+8Pd1VNw1IwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDlXV9QDkzL6HjEmqS6k3wf7Vbg\nu8JlkpvLcMSZYypfXAIgRbuQ4uUyjAz7Gje/uINMUlzuNWb7dYg7gk1Fo3OCjhQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfM1B/w5SjSAE+c+kDmMuCvQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjdiOTViMi0xOWNhLTQ5YzAtYWYzYy00Mjc1ODgxZTEyMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzwXYQreps70pyIPlTRDhBxHWCBbxlanNEsVqyK5KnB78d\n6Ef3rt5sHIaZ6qh3x2BESNGGqVjeMv5yupTOX6Cpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvnnnpVIuQSI8nWwYk+8Pd1VN\nw1IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHtnUKWZJhi2xYCSy2+VKMJQ4TOcht6tEQNwI5BMU0W0CIE9hMnhB4eJ5\nZoBE8x3mkfPQLq7iL10NSuF4jMS6yXWA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAWpp+TCnG+eWBckb2OpAkXMYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTcwZmIzYTMtYzdlYy00YWIzLWIwMGQtZTBjNjBmNmYxYzdjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODQxMDJkOWItNmI1Ny00MmM4LWE5NjQtNjVkY2EyNTFh\nZWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs4iPgTDhHwTfw9fbCI9dgTpj\nW6f3mPb5k14YahQEEQEXCB8PCrR2OJ/54ch43fb1tSYxIKCKciCuKLkhlGb0BaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZASAK2h4M6i3Wj4rks0Awquq9UgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMDJezY1\nlUE3SIHG3+1kYiG16fWEoiLXG1ukk2M0pHIwAiEAnKwO660WmEkZzJVQScsj31WJ\nBnyzyERwoVj6rv0RpdI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4841", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4841` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISATiuYFU8b9GWV61Imf2jv8j2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhZDJkMTU2LWEyMjUtNDk4Yi05MDU0LTA4YzY0YjFlZjg2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGRiNDk3OTAtY2I5\nOC00NGUyLTlhMzItOTY1M2JiZjU3ZmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3TbhU+ZoryF1P8L678+93iZARR25n6nfJF0zTRAE4dZ+9yyoAJ4+K7fCS74i\nfx0GCnHZ1mV7HEpYapveciuniaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu60iWtAJ9USYmOYf6tjkHUmnZe4wHwYDVR0j\nBBgwFoAU5bvcVFEmUVE3EGuLFP9t9cSng5EwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKGAVNyk9\nwb7f6abaCP3MV3hDl8l+PzyuQ/qL4peKnykCIQDeWjMZBxToTJu7J4Y9H00eMwml\nNw+/HMIM9Sxaxs/OUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeRd9o7sbKABkdkEMGlYoHzbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWQyZDE1Ni1hMjI1LTQ5OGItOTA1NC0wOGM2NGIxZWY4NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARK4UD6XGMnMehuR+ByScmCiqSSvnYNHuh3UPWpQsm360eU\nY24ViJTVUFOscXGSiEyE9vNljMSzsxmVRiHpjijbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5bvcVFEmUVE3EGuLFP9t9cSn\ng5EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWa1G8SKVFA9I31JCIlRRN/QzJCw5fDMNHX/FD44CqIUCIQCKnLSlFJmC\nZUF2Ir4yE2bUYEvTiOzzaImzn3mytFw1PA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcLTGoGfT1UCn0W1zJ2kkZgPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGRiNDk3OTAtY2I5OC00NGUyLTlhMzItOTY1M2JiZjU3ZmJkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTBlNWU3YmUtM2Y2NS00MjFkLWI4MjgtYTY4ZGRhOGVh\nZTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkD2GZlMmzkRZd+ZUXfJ11qKh\nWN/RyeMFVPErq9AJ7AaVKy7n2kzDBRjDx2pFhPtIHtuxE3USx1C7bGaQGNvBiKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUu60iWtAJ9USYmOYf6tjkHUmnZe4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAITxSPhE\nLrYyFn5Uxz725k/leydNr3ISyFWD79eGz1FqAiEAz+4QONbYfwdNsY61aFgakoMZ\neSStgb+bmIx2LTHj03c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4842", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4842` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAeX1fMCDw5BYALR7p82FdnFaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMzQ5NThkLThhN2EtNGVmZC1iNmIwLTBlM2NmYWFiMWRiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc5ZmNmYmUtZDNh\nZS00MTBjLThjYTQtMWFiYjc0ZjliMzZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmWybUWo/dkFwWFKTzBPkcDuX8NcfwEAolPG9wPxjR1mLMJtam2C1/BOtgXNE\nVbGPUw3EBn8HhgEVfoNRbBuBvKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY9a/lCnsCFERd2UAc2g9iOwDaMUwHwYDVR0j\nBBgwFoAUkDN0xaLIV43GtAsYLbDqe6Ez/8gwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgUQWF0CfU\nd61Oo0LaSTa1jAWNGkJ6SVj7KkBNmWLUzjwCIQCh1ogIlZAjMFHOo4LZxSgyDbVW\ncxN8dqc5lwsScUOLVQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbmJoiqSJ6q13eR79hebGl/YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTM0OTU4ZC04YTdhLTRlZmQtYjZiMC0wZTNjZmFhYjFkYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3YSUHw5Nys8O+e+zLvS5ZvVprvQUx/g/WW+ZL7fbjOFjW\nVUGxEcx77coNPjDIdqzmsOo+PetMszd4k9ezVFeoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkDN0xaLIV43GtAsYLbDqe6Ez\n/8gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPpyIH7ErZMN0U4vLoCqbfWfjei7FO+nyhfVuqs9e+3gCIQCcQxe5ZFGM\nqyKZrpAtONeU9TDJYucYisdkPG3ZKQYpQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXzUv3Tf9wFnUGZxiDoR5kIJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc5ZmNmYmUtZDNhZS00MTBjLThjYTQtMWFiYjc0ZjliMzZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjZlMTZhY2EtMTAwZi00NjY3LWI0YTUtNzM4ZmQ0OWE1\nNzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4cP6hRapdKvSaHIScKnCV18d\nsQ8GN+7sDpiyxeY7EjaTdxsVE5UamCzBAzYFucQvySyZCwjsuELeLtOMl0U3eaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY9a/lCnsCFERd2UAc2g9iOwDaMUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgSyw+oTTc\nMcj8WrbjUbe0HJCxr7BP8bAA3MP/Yl49w40CIAw8Fa3P82GW4HBKW6V8FFlLo5Xs\nG0mE5qqvKraJ6LHK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4843", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4843` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAboS8y4x9X0ElwmMSCc43hCqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhZWU2YTU4LTcwNDAtNDQ2Zi1iYjlkLTdiYWQzYmFmNGZhMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRiZmFkMWEtODY5\nOS00YzVmLTlhNDYtZjM2NDMyNDY4ODViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEptJGxK4NYC8avCWZRkTR6OW0aX2iv7aNK0fcSIXVpTip/V/C6DpByVATCnsT\nN+cN3Li2oJqm5wDKytK45mtRUqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPhnhoDlvTkVeMNJH9Wzcf4+yqLIwHwYDVR0j\nBBgwFoAUbMj/MODVuet8eQllkluSnztr500wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGMrLpox\nx68D9xbNlIIEGODMS89rZrsjJTerMtNjHS/zAiAIBC11244Ma37aLKwB25adQW2a\nbqkyg7393yW4GmGYQw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQRRnTNwoZWOXlAGma2egcJUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWVlNmE1OC03MDQwLTQ0NmYtYmI5ZC03YmFkM2JhZjRmYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJxz7U7kPvFpsPxniVLrfLEh69H3II/cd5zNNuzX63qp5q\nhdqQAiyEx2hSe4d4Y/ChP5KbcfkyDZc+k3xvLEf1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbMj/MODVuet8eQllkluSnztr\n500wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOUyYeF5uqdZ1eHgqrFV6eTj70yvhAgb6VAyT6px/BMMAiA94+bFLukP\n43ekoQ/ceujW9jSd0tcowEUdjbdJSwuN2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAT8fcCN+BykcJpWSyzpaQLf9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRiZmFkMWEtODY5OS00YzVmLTlhNDYtZjM2NDMyNDY4ODViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQxNmU2OGYtNjYxNi00NTQ5LWE4Y2QtYzQyZjRhYThm\nYTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQTKwNJBL/KPtCxrvrzsLwQtF\nlWlV0K7YtcjVnEI3PxzP3fAsUaCUst19vn7khctbfo0ShXxK3pmYydpWr19gQKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPhnhoDlvTkVeMNJH9Wzcf4+yqLIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgRay71G7I\nGKGl7BSftyHeFV7E6xazf1hr6b3Ly5Jf8dYCIGU1AvavxHLq8OH5psnE/c9AHFb7\naL7kEm9ZXFLqjxMI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4844", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4844` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdUvQKo2ka04S9/tFW1r0pfYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmYWEyNzBlLTZlN2EtNDM4Yy05N2UxLTgxZWVmZTJlZGM3ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkxYjI1YmYtMWRi\nYS00MjRiLTgwYjUtZGY0NTM1MmE5NTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv3+ZX0OaYGwAmuNe/klxppyYGKLnCqiT+PnvMLNu4NJ4YSEz9vTjaZSPMJKz\ngFrzQRtQuMgr9Saoc5KYnVY+DqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3imgm4p+mQia1k7y1dVowJBcIZAwHwYDVR0j\nBBgwFoAUQByqBWrQUDAYZM0Y/LSVnzkvZsowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCEE6zQotLLpUgyJG8opGPA8ytm44fIsPfqnVzI414biwIgLHvOw69z\nq6BbUdi+MSMF5ATO4FzeyoaHGXPY5Ef7JoE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbo7F0OdkfC/g9cVbJBrh55rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmFhMjcwZS02ZTdhLTQzOGMtOTdlMS04MWVlZmUyZWRjN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkwPy21jPIECwM2E3Ja89IspEG4TciKuqiEWiN1AEDiYcY\nPltg6C6+4D0t/NIlLNw3weqFWUhjROVjsqMb9PO4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQByqBWrQUDAYZM0Y/LSVnzkv\nZsowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgafuyvSjlZ9B9nqCtuiDgBS6+sMRy4IVfH8MRJtz8nAkCIQCmnYhTPtED\nyDuhL1I8fpayIFemxWl5qbAh9dX0Hmnd9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAUkc6LXSfHrS8zGV85qGNEf/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkxYjI1YmYtMWRiYS00MjRiLTgwYjUtZGY0NTM1MmE5NTQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQ4YTA5NGMtOTI0ZC00NWFjLWIzMWYtYTgyZTVjYzdl\nYzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeAAmizxOaMFu2/xyGpYLJuSv\na1yakC+M3sBczYwhy5PAWjX7fNwVVtbFSy/BlKedox4jbFYwobvG5dJ9/vYy6qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3imgm4p+mQia1k7y1dVowJBcIZAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIJsxrGW\nNxblFRIq06P0ByBcvoDGEURYm769Q8F9yer6AiEAiKo58oOr06SByn3JUGCl/Ild\nE5pS5aXAfVW437WquXU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4845", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4845` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAceNafhq0WYvxUnXKsnRShRrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExN2VkY2E4LTJiOTYtNGVkZi1iMTk2LTMwY2FkNWIxYTc5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAyMTdiODUtYjQ5\nZS00NDk1LTk2ZDctNzg3OThiZTMyMWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgOqhZSrjWzZDb0JyrWElPGsQ3vQ+zNePOTelqnbNMCtTBD95+Ax0reNJJq1o\nvgYIGD3o0fuUrWLl2L6HoLUzKKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUACBuElwivgz8AkoMvXfdkfn0IcUwHwYDVR0j\nBBgwFoAUcv38nNneRhhMQBMC1iPJD42aVd0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIFWA+Eh5/rlgYlZcC6Jk0Lr+APwtnj34uQcsacbbisWHAiAw2BC/E5fM\nwgLM+RWlKuu6Jrh+5m2+6kj+kHG6Dmo+nw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX/EuDG4+nneoTVY101f9PWCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTdlZGNhOC0yYjk2LTRlZGYtYjE5Ni0zMGNhZDViMWE3OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ090RE89hSlM+Jcl7TSsV9IOX0MTWtpn+UTa+Sl7LXABTF\nD8+OZeSKfOSeeo9zz7RBNE0By3XnsF1VEOF/BO3eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcv38nNneRhhMQBMC1iPJD42a\nVd0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMc8HWD03hMmRUIMlWuDpYEjuKLM+CRRE04/OJ6H26v2AiEAtB10dnvQ\nahBQF5MryWFWgx1CbODjEIomkmjY7hCzuwA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXJ3S3oBc5Nk5jcckYB3WfXeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAyMTdiODUtYjQ5ZS00NDk1LTk2ZDctNzg3OThiZTMyMWU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWFlMGM0M2EtMTU3Ni00NmRmLThjMmEtZDg3MjI4NmZj\nM2UwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvTnnXEIo63MGTNBDvWSG1WeZ\nRfWPbgVj8MP9MDpOJW2iOzeK+Ocm2eHGwNXQKUK5ZL8ougDSEmR81E8h3LWr66N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUACBuElwivgz8AkoMvXfdkfn0IcUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJaj8Wv8\nB3EPyWtd+N07FJXwQtzE4k6GUxcHvDzOhdLQAiBCpA0wnyfP0wp+7Hr+t1hcVMkX\n59RS46iz5f2wp9X90w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4846", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4846` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAdGkW/nWGUygGiVpCskRiLT4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmMWQwOTZjLTAxMzgtNDAyNC05MTZhLTdlMmNhMzc4Zjk1MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIxZTU1Y2QtMzFk\nYi00OTM0LWE4OWQtOTA3YTAwYTMxMWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh1Gc6nPeQFnn2ZPdvsSZ7w0f/tmgnfLFR2sUX+XSECAtoRa7oTXsoFE+CHtW\n/NadYAJeNm169vgbr7kOz48JE6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFYKqYY/LkyfXyj1+XnwXOPaUryUwHwYDVR0j\nBBgwFoAUYxq8mC2+np5LArfu5NO+Nw8vywwwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDsB1DrPKNWGp2UVNdLmfE4s2yYznEYFdZJErF1oJP3EAIgVWt2aUEuWBn07fOK\nF0aTg62jx2ayNmRB3MXS9aLt5hU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAahYGvsLC88+oVCYJR40F+fqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjFkMDk2Yy0wMTM4LTQwMjQtOTE2YS03ZTJjYTM3OGY5NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAkfUczws0iXfq/dJLwRUXzFx4uZNEQYGZsnp90tc6y1Xq\ncnNL6xAomWF6UYxEoiJzXuZz2NMBJf/jQaesNRDho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYxq8mC2+np5LArfu5NO+Nw8v\nywwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANCTgnqSkOEYSTxnvCvKpXf0eOBg5EeiNbWSCrET6aI6AiEAk7FC1VQs\ntIzQ/z99Eozkz4zSSr5EdldJ8EKVEM6kI9Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAdXo6rHYLJwR7f4CbrMIhimrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIxZTU1Y2QtMzFkYi00OTM0LWE4OWQtOTA3YTAwYTMxMWM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2MwMDY5Y2UtY2MzMS00NzE2LTkwNDctMmZkMDcyNzRk\nNTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgRk+kJRzJC8DqdPlE1Zn6LxP\nTx6ry0CIpaEwf90GpUo3ki+BqjEZhJWezRdWSpMbcN6t2YDTlbJ+PPgFitX8IqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFYKqYY/LkyfXyj1+XnwXOPaUryUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAM35MmAS\nDtaco01Q9MbgsfTHTd871v1jbNGMBvZi0gxSAiEA5ziIzTwfh2mROmoLlAaYgadd\nGCDp2khLw26GN+mdHIs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4847", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4847` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISASgHzalKsE0E2Ay6+5uxibpYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2OWMzNWJmLTc2NGYtNDYzZi1iM2UyLTIzZDQ2NTdmNzA1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGJhYWUxNzgtMmUw\nZS00OTU5LTg4YWUtY2VkOGNiM2YxMjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfaOqSTSQWOSEdGW/NlL468OkhFvWH+OY31bbDxTKc+d9T4jD279yAQNx33Q0\nW/1Wp1XICRz2l1/QqI7QIvgL66OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnBaSJHGPkvyJgxAAFZMhhuKLfTEwHwYDVR0j\nBBgwFoAUi/dl2/eWrpilKvjX/m39AoEoAOEwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCQvXTy+jU3edBNjhHXaFK4pBSCKwDaBHizEJJiBuV74wIh\nAL63SrYRXl/1mOlMtaPairoLCHyhm44SW3FloxUBTudg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdjQOHQJpSubGk62CsTI3jVNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjljMzViZi03NjRmLTQ2M2YtYjNlMi0yM2Q0NjU3ZjcwNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYabTVj1GbtXleUCKJkJsy5N0YGkdJxpIRUFrGMw1oaNBz\nVgw+c+7a7Trpv8aompdSuFbmZIKw746EzAI73x0Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi/dl2/eWrpilKvjX/m39AoEo\nAOEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYmUJ+Gc6XvGZm25oyIDVIRngAKoPjEAb4Purym/PIkoCIQCnGz992Gt8\niod2/yd4S8ZrKn1QSiMnTHl1r1GlR11MbA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASVgNTzH5128tE/Pr20bEo39MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGJhYWUxNzgtMmUwZS00OTU5LTg4YWUtY2VkOGNiM2YxMjFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTNmNzQyZjktZjg5Yy00YWRiLWIwYTgtZjBjZWRmYjJi\nZjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaiaL+C5R+775H6hICwlK6WKr\n2OZdcj+BhbmDVVMd2OZMTaWWGz/k/8FfFe1gWWsXkuMe0wal4BNHjTpjG3ETt6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnBaSJHGPkvyJgxAAFZMhhuKLfTEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPNc09UD\nxwfMz3G0j68mWLJ7AymOouSP4Hq6RtyeWPBnAiARYhvNpvrKHO3YBHyIDd11up8I\nf0qRO+hbJiTzcnqVxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4848", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4848` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAfhgmONGKbkvMyCzHzoBPNSgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2MGQ5OThhLTg1YmUtNGQ0My04NTIyLTY4NGEyNDViOTkxOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFjZmJiNjUtZDU3\nOS00MjA5LWJiMWMtMDQzZGNmMTdiMjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx6Ld/Rfto9IHHtw0s4uTSqYzfMWQkAKUJTMnt9I37mBUwbKCuRpzrq39hpum\n1tiMuo3Flsc/gLM8HiR+JdbOv6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY/dOW+GC6FNFCW51P4hWXN0tVrowHwYDVR0j\nBBgwFoAUGoNiBU2nCfBngrMxaG/gpv6ruC0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIF6/yYFECG06PfbC79jCKJdNtrldLuGoLb1aBL4aWvAYAiEA\nlpkdseVWf59f1boqk0/422z5ucV1xm/1dKS8JykpVwk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcx/Uid6I/tkRYraLkKGwVDuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjBkOTk4YS04NWJlLTRkNDMtODUyMi02ODRhMjQ1Yjk5MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7E3ddyZv4F8sA9AHUxxr4pPisp4xWlPKxqzFxfreqif3E\n18VZGHCqQ1gLUjZW40RqtWMdohM4DsW9LkMvhSJfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGoNiBU2nCfBngrMxaG/gpv6r\nuC0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANTRHmWogN78K7FvUS6kFzvd0a2piR1FB0Hje9I8NvW1AiEA8bjOeI9k\nXWmViFIOg/JwSQ/0pNEi0TNZIwht8Q6ctUA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVnpBqGIXMrf05nESq/2uZdBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFjZmJiNjUtZDU3OS00MjA5LWJiMWMtMDQzZGNmMTdiMjQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjMzNGI2OTUtZmJjOS00NmFiLWE2MjgtMjUzZjE3OWFl\nNjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcBmj4gCuyc87vOjHMKW9KVcJ\nJBrMWCKBsRqBuFfAslrgzD6KYuTqi4wT54xmvX9U9SXtrDzHpCs4j+9FLUgBiaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY/dOW+GC6FNFCW51P4hWXN0tVrowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgN1D3DjSO\n4Gm6sJ1cBeQLbjWw1YqKhd/0qUpmv39JtHQCIQDiDHB+jgi7FsU6Ign7D6+F816z\n05XQN4gowofUFfy4Cg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4849", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4849` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZquLE0lP21qlbS224I2nM2NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkODliMDVlLTQwNWYtNGMzOC05MjNjLTkzNmFkNzY2OWQyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE5ZjEzMDEtNWYx\nNy00NWUxLWI5ODUtYzcxZTE5MGI0MmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkCXwG82aEQ5ayC7MQAOyyqOty3Zsf6DwUzOwseQstVbKKqJNfMstDJq847Cu\nT679ZcpUo2Y7b5fn/cjP4DJYUKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0EXFVkEDB9c2FJf4DyLpYP55tRowHwYDVR0j\nBBgwFoAUlnrlRDdd/jLAO+HHP62cziNPOvkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIHaRAGcolu+u\nQyBQVI4bz4a0tMCs351MLHvfOx5rs/Z5AiBpWefJm56gF9nLiA3rG2tXxfjDlZhG\nhx4jH6nZvlBOzA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASIS7Y5FOb/HuFju9J/hOR3VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDg5YjA1ZS00MDVmLTRjMzgtOTIzYy05MzZhZDc2NjlkMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxgqBNOc6/NovS56tXQqZhnc+h5ubKK2CfZD5elpxPance\nPGhcgkb2FyCtMHYlKWd2vj+1nOqyXa5DcvUmJWHxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlnrlRDdd/jLAO+HHP62cziNP\nOvkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEg3GZmZ6GyVBDWBXg6d3OOA8ekWfGCloVKKmyWuxTLMCIDc811UAElw6\n5xMFntUMLWAoWRufb4pMiXBFtVCOza5J\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQLgrTVU5KHtAqYb7PMnCStgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE5ZjEzMDEtNWYxNy00NWUxLWI5ODUtYzcxZTE5MGI0MmE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGJjNGEzM2QtYzI5OS00ZDZkLWIyZDAtOTQyZDIwNmQ1\nYTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE97K621+YTgjWEeZlELlJg9Mb\ntZ8NxKryGA0daGvluVJ73xBpXqk7e4CuMOTGH6UGrSfpG5/FTqIVRRkRDSeB4qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0EXFVkEDB9c2FJf4DyLpYP55tRowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJW6tomN\nY3AG7ZBXIwnSfXltEaDLKpCG7JQL4tEOEhw2AiEA7e75DGMYXXT9WmXowk/iVnml\nW5SaVRotyIn5fRXQgs8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4850", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4850` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAaKdt+VYDkpsxMY4HyxfBumvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2YWVjZDA2LTExNjItNDUxZS1iNzgwLTliNzNiMmQyMDkxYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFiZWJlZDgtYjU0\nYS00NmUxLWJmNTItZmQ5MGE0Y2Y5NDQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf5lCQCW9pHD9ww/cSfzPiwzMU9hVXzBE132wMFV7klPlqiKdS7qijIXAxoLH\nOtiLHkpHq7sz/yDYc4O/0mqVCaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4hKGWerCRLD8a88GTsJ1cK/bLWMwHwYDVR0j\nBBgwFoAUjp4ZwxsNDsskuNetGVIX+2yFXoEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgGSH9Dk//7hhX3lNZ1LXRVrSCl7vVNPh3TubN8ZtaoaICIQDJl6WsjkrD\nBngZTjt0yi1ub4LqKntZHMWsJxLiPJjG1w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQMvazwYar0uijiExml8qI+KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmFlY2QwNi0xMTYyLTQ1MWUtYjc4MC05YjczYjJkMjA5MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQ2J3ZEP61kEtolMPQicW9tBk2JX1lgaffQCtgSlenaA6f\nCdQoKavyvJ5kxSzzIgV4lnbER7/TmC3zCaRwZmd3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjp4ZwxsNDsskuNetGVIX+2yF\nXoEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYisGkiYMi/DxDq56zeYrQlSGISrmFeJzocNZgN0T8KwCIQD+RqcKOH9+\nUA4kBKktxDDnMFqwJXVYCS46i1kWYoacug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAbXfZKHPE3WUqUlfIpN8YtlzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFiZWJlZDgtYjU0YS00NmUxLWJmNTItZmQ5MGE0Y2Y5NDQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGE0MGJiNzMtNjNiNC00NjM5LWJmZjAtZGQxNGU1Nzgw\nMzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEh+5pzSlN1oqSYOF5DtFRWJ16\nAuAXyAMBoY7nddYwWSvU5kONdXwQp+dZ9Tb+gjcIz9muHxeWC5Fo4diPZ5Cx9qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4hKGWerCRLD8a88GTsJ1cK/bLWMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhANetue66\nR4pOFnXqQZ9Org5KByTqltgx2Q7jvK/bBZjsAiEAkhRCB7B5fKU8iaBjiAYMNXq/\nSLywA8s0tJdVA6xdHxE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4851", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4851` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAV6nejNN2ybCIM0WMIgw7VJjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmMmYxNzA2LWQ0MjMtNDFkMy1hMjdhLTcxZWMzNzgxMjdlMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFhYTE2ZDktMTNh\nMi00ZDYzLTkwZWEtMWNiZjA4Y2NhMTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbPzdfPsdW/7POWVw08PT25GO41hKoP+3k8KIiwbm/YLzvhgnrCDUWmtZmMEf\nNll9KDlx5pRVZCQebyFS6MEicaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp/yIDABiqOKt2OVQqgye02IaNjEwHwYDVR0j\nBBgwFoAU+3eE7tnQPEEP4Ps8tAafoofPBqwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMZUWXCbclH0GjgcW3OhRS8M/79m/jUv6w0DiiiLSO3kAiBDy7WS4XK/\njk2gEDlQkaBiA5uvWqkN/hTu/UqMvaEnDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV9UxeJTs+8bdazgPVb1KtlPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjJmMTcwNi1kNDIzLTQxZDMtYTI3YS03MWVjMzc4MTI3ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZt3n8df8+5hBEO3zhyJ7RLHI3Ia3uITaHMdaktvF2kYQm\nAnBGM3jdKTUe9615RvYiA5wEGTLtvDuKHjK3o+Iho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+3eE7tnQPEEP4Ps8tAafoofP\nBqwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBxFeONwQycUgr2lgU0Jwa3d1LaOUyJeDzAwjtGqAGr8CIGFIYicuA1XD\nBCcEePyQoHiTIZAt2zgM4/Cgb57F9Ibl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUm3uREi6z15dPbDYgXNJrzqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFhYTE2ZDktMTNhMi00ZDYzLTkwZWEtMWNiZjA4Y2NhMTg4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTIzNGE0YzctZWQ0Ni00ZDMxLWFkMGYtNjM2MmNkYTQ4\nMmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEibgjDGVwGtypbvgQ27CwX7Mp\nsFmNticScLbcEnHmjuRUrsr2HxPcDiDNyM/+HnDz64JkcWExsFtCm/k+yxszmKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUp/yIDABiqOKt2OVQqgye02IaNjEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgcnrWE4lM\nG7NZTkKwjZ9QDZyHPZOwx3OB+uZqUZo/H+0CIQCMrkmtnU7O8EzOY4mjrYwzBC9h\nEL+sXXrhU7mtt8aCAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4852", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4852` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAc83hbEln8ghVOwySubul1InMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3Y2YyOTRiLTA4YWEtNDQyNi05ZTUxLTg3YzYwZDQ1N2Q2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRhYzNmMGItNDM1\nNS00ODhjLWFjOTgtMzI0N2I5ZTNmOGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHKPunTz7YT44wxSHsJUBoIjJN6+8+C7Cvw4LmczVN/4UuZ1ndV53DDNwCo6Z\n2rAEzmEC4VYbiyHKjHMXLv9KiKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZo3MzW32s6bfILzacn7Y/LhPYLQwHwYDVR0j\nBBgwFoAUk7QbSW8TTLurwbtA+rY0/czeKtAwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQD8G9+N6aBS0AAlxMp4lgFErymrOeHzTWmt3n0LucUFpQIgNe6QzSuf\ntZhZeAmnCCQamjWHVEMkcNm32HIk3yMgHVI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ9K6b3CZSRAigwpu2Zi/IIYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2NmMjk0Yi0wOGFhLTQ0MjYtOWU1MS04N2M2MGQ0NTdkNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4ABLW26WBXg1cojjQR3PC8uktMmNjaz5+/Ybsy3wbVFRj\nkYJGlhLYtlVL9CoyGjodSi8d2UqoY9kcgBRw/t2Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk7QbSW8TTLurwbtA+rY0/cze\nKtAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFqm/buCqU1nPdsWBg4P/ywyilZFl14kD1wI/gr3qiDYCIHFBbiZ9AW3q\nPBLzcgYnHKFY7UpXfYSC2UuHMXS1fpyh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAX9GCSzqYGButnIUrq52yIpYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRhYzNmMGItNDM1NS00ODhjLWFjOTgtMzI0N2I5ZTNmOGYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWE3MGQ3ZDgtMjVhYy00ZjljLWFhMDEtOGJhNmFjZDE1\nMjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqwo6/MjHrNXIgxtrrLUXA7Lz\nI4MeZ40nfM0NFJjnwEhMTo2+dqfXLpHpm3iWagsgVpzR22+VpQ57KWNaHORApKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZo3MzW32s6bfILzacn7Y/LhPYLQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAIFRZYNj\nS90qOtmOgBElzODb+HZo2NhPNvtFz6+sDP81AiAQUncwBD7Vt3TCBdvJl8+xLu6/\n/DRsGFVEcb23OQAaYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4853", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4853` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISASzSgXfSGiGD76zOzSOA8spjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5Y2FhNDAwLTA5ZWItNGEyYy1iMmNmLTAzYTQxNDkwMGFmOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFlNjg5OTgtZWI4\nNy00YTcyLTgwOWQtNzQyMGUzMTgwNzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExM1/Ty+IpHfnQEmpPPrAeKG5DF+6IXlbSj5GgN/pbauOQA9/Mz2FbN/qWWpn\nxCeHEXvcARopimlZIJ7eTORJ96OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiCnEPKC3GU9iHB1z+MmA6FA05PkwHwYDVR0j\nBBgwFoAU3xbEiw7YU1jQCt8SOxxrlqE8t/IwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGo61bmYSEZ3qdpzvcZWS1L2+nS/IMbC/Mhlh3YE\nMNaBAiEA+4f2eMWV6QClgcu0afrSE+LiHmkKfdS3fMr8ubnIuPM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWbsHcf8Z5NLLMO19RqZGLjyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWNhYTQwMC0wOWViLTRhMmMtYjJjZi0wM2E0MTQ5MDBhZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpzppjH16jN3gKm6oQxDRF23UNcSxXUt2AfhUBe0MsV7DQ\nCd6mdm26Amn4o97nUKfggJBYHbhjQfRATx8oWHJ7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3xbEiw7YU1jQCt8SOxxrlqE8\nt/IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUwVtHGVBjhyUsQECOPNEFodIKKsU5dVxo4ALjMarWLUCIQDuYocTsRzy\nfThm1hKgkK7mzsl6wNq3NUPyjOF6Pd76Wg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVBDZErUILTIDG6ag175RF8+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFlNjg5OTgtZWI4Ny00YTcyLTgwOWQtNzQyMGUzMTgwNzJmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmViYmE5N2ItY2ZhNC00MDM5LWFmNjctMjZkMDY5YzBj\nNzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqR22h8Av7L2f08tiu+oFjaWF\nJitScgrwbHIoVtPbVUivD5GNqy2eTX4YsIwYPCNlhlh9650GQ2u8jC3MUYz84KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiCnEPKC3GU9iHB1z+MmA6FA05PkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgfDoB/Jrw\nGt0rfXEXFIpfP7YHSFZDlkn6AmTTxmwyK+cCIDrN/SwuGpO2mllhEapfeM78VQMu\ngVJgtQUvlbZ4+6RM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4854", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4854` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUY4pcOY6PTHbCVkIrN+U2YTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5ZGZhMzI2LTY2YWUtNGVlNS1iY2U0LWRlN2MwZDJhNGQ5ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjU0ZjdlOTUtYjZk\nNi00MzlhLWFhZDgtMTVkMTA1ZGFmYjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO2xvhZRLGkHtDu3xNzO6QWk5a1xFpiAFKcWfeO6XmIIbsK+ZG04SCXcp7TPQ\nUMOOeUcftuoyStebif96m/1Ws6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlAIQmn+aDdoJ+xy54SDln5HIiQkwHwYDVR0j\nBBgwFoAUW5PEQ7PH49GrdnHk9dycjSadFaEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIBKkfM3EWhK25TowG9WyLi8V8XdxP7yT2I3kM+PQ\nELabAiEAlbkQCC8ng/RTN9YTi4XBMIR/HJ1pG0k+J2LyR/5v2fg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXpK7/FuelFBz3uUCk/lKtWjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWRmYTMyNi02NmFlLTRlZTUtYmNlNC1kZTdjMGQyYTRkOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2sYpfzYIop/WbZYzUsah3Ez1kkq1gXYGkWOlsRWkH2aVv\n37DrxgmTOuwJevnp5CJUWoQ/GvMt0rUshk9pGOq/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW5PEQ7PH49GrdnHk9dycjSad\nFaEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM1eLnr5EyPZw6RCsB0CRjymgGaUkcr6Q+jhmggGFD0YAiEAyowUtNDP\nOtVdqKuvksWr14IRJKsZ+BvPDuHMol6nkl4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQtW0e4nnNs1bAvxlQ5aVegMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjU0ZjdlOTUtYjZkNi00MzlhLWFhZDgtMTVkMTA1ZGFmYjVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTA1OWM4MTktODlhYy00N2RiLThmYjgtNTlmNmI5YzA3\nYmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBYNG7PARKMZ4FIhnFdhz8UaM\nfZdZRLZmVUZ3fZVPzT8W6ePweUKOfAL4SsCnJUCOzaQnSSzXVhyDUxgWYGYZb6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlAIQmn+aDdoJ+xy54SDln5HIiQkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAONwAZCe\nezxn9mxpJIs43waO66sZwHS48KJ5umVL0wCxAiAm5M8zcTKx+1+AVhFq9EeGRjlh\nhf5xQ8D/TCJ/LFqlLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4855", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4855` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcK38GRhYvqGdldpsDyC7uYZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4ODJmODE5LTc4ZGItNDkxOS1hNDNhLWQwODUwYzg1ZDE5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI4OWFhZjEtZWNj\nOC00YjRiLTlkNjMtN2RjOTc3YWYxNmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHTagzOHfy62fqWf/i8UUrCo0C5X2mjV0urKNY8q57s1wsVrCKc2AUyqqGfXA\nIx7N3iqpg7sK9yBYhsyh61djiaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt9pedUZPUToWdaVb1kyDq3gE2RQwHwYDVR0j\nBBgwFoAUKwTVbdGC1cynymE8LIsIDjQ8+98wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDEoBsngUL3utwkoMl19P6Bn4FzgA950YXSZPAqm72O6QIg\nULX5L4FbmOWuOtqBuenWlzZshEUUe0V8bjdEBMXg/os=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATQ8IzRQUUhtI7r0FJvg9wcCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODgyZjgxOS03OGRiLTQ5MTktYTQzYS1kMDg1MGM4NWQxOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWHQ0jdAXjwJqrkTTH3fiP0UtrZwe08D0NdM0hqYKzH+ms\nXJBFAKt/Z3CuoWKmkvqgEjQoAiEq04vsVYPDAPrGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKwTVbdGC1cynymE8LIsIDjQ8\n+98wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD2wcFoagwOdpZ8Zcr9bnOQH6qzrJd0tqCK7GNS/lciQCIALh068JByMU\nLjlp9wBj5kKLvvbF1h5MKjwFtNRofnWw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVeFpGSq1LipXO2RgnD0af/QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI4OWFhZjEtZWNjOC00YjRiLTlkNjMtN2RjOTc3YWYxNmM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTcyNDA4ZGQtOTk0Yi00NTQ2LWFhY2ItOWFiNzk0M2I4\nZmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+iVypFrWwaT4grDf7EDi4x2+\nTVQPfB33BefCYwrKwHDZY7rFPETe6ytrPvPC4kQ+6gbjusCeXRMGo6biptX93KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUt9pedUZPUToWdaVb1kyDq3gE2RQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgZmMZlpWR\nQjcmrOk46WzzMnuuteLc/vFMNqYStbn4LQwCICkq+aRWfzcxl+JTf9SA2vXYcI3V\nmdY2bBabINGxuZgG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4856", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4856` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAdgqGmQ4aM2YeH5oW4mnP1uVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzZGQ2ODMxLTg4NzUtNGJjYi1iMWI2LTI2MDk1MWVhNGZiZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzczN2UxZjctODIz\nMi00N2UxLTkzMDUtMTRkODQ1MGQ4ZjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWSNA3PqmgyKVBElpu2VL2yTNG2vtUl7OLGHeQYumbI+CUPOYFFT9c/X6AADh\nybJcooVrraCWCGzb0i9c/V5HuqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrDufnAiUB3pK26rCbkA2QoV3HQowHwYDVR0j\nBBgwFoAUqPWBD7sC5YItzKskIn9ENIU4cgEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHG2yKloCdgGKBnsYsGIb+OtsEtYvH0z\ne6zuCLd8sFSNAiEApH0rlg9j8WCjFqT/IUYPeVjWigeXoa/B1tKAm5oYipQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXb4CnNDevCvc0vfEnpz585yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2RkNjgzMS04ODc1LTRiY2ItYjFiNi0yNjA5NTFlYTRmYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0+Bt9fSc7laCDRUpv7OdA7MPX5hPK6ra8PAz8hlWulBVr\n4+pyU3CCfH6dXhrRXXV7vpGsoa7d5lkuo9CeGFOgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqPWBD7sC5YItzKskIn9ENIU4\ncgEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL65mrMdgu8rYoUxvWS3pjma0eU+8bEY9smyYCO2bdhvAiBgYJ35Y7VW\nsOZTm7Gis9oeGiX1nXH613VW0iwaGpftgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYtHc3oy2JAusEWnZADSPHCIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzczN2UxZjctODIzMi00N2UxLTkzMDUtMTRkODQ1MGQ4ZjAyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDVhMWJhY2UtYjY4MC00YTdlLTkxY2EtMTBiZjYwYzFh\nZGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7Xt9RV3XL7HXvaMZd1zvoH8F\neJXXtyC0PfO/rXBsbv0SsOv6eP7nzEDMJIm0r6ux47dPHI1wIYvbiHyQ4QOCkKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrDufnAiUB3pK26rCbkA2QoV3HQowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOcR7M7b\nHKczuJkFD2FGbRVw+jkV77wOd3tj5ete+j4VAiEA/AcfheynKvjaXqgKuoRfL3MD\nI9iYjGlF0dFWapeZHzY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4857", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4857` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVJCHTiwzTBcbmAAq+kUb/sVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0MzgxOTMyLTYxNGItNDc4ZS1iMzMxLWIwMmEwNmFjZTkwNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM1OGI2MjAtZjE0\nOS00ZDhmLTgyYTItMWZhZWM2MjU2OGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1MEPGegKFauj5ZSLfmfslwQaYMgNxQaazp4ahCXEdooxceBTJqmvTJA+K6eT\nE65++ogcyAr8VeJTyc5M+eV42aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULkcz8iQx3mtcvzx+qhkS+Be8ZqAwHwYDVR0j\nBBgwFoAULUoiyKqbLLg5jUdIZ/hLuR0ZnQwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDLkSKkBjcGt48/AJgMJssktTXa5FGV\n3ORDiUKJ/lzNswIgNSqarBztYtel7t1ic68HQKp3A7EGAC27VZdwZSsqMZA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYn8YThLOaA7W2ZRuEFZSYHbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDM4MTkzMi02MTRiLTQ3OGUtYjMzMS1iMDJhMDZhY2U5MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATofrvk92c8whEOAl1Wn/XRlbFlva2SICn/VsYrSxcuhedx\nryW6kywPuag6aCv2WcidxmU+PSrfJnfDCaoUKaJ/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULUoiyKqbLLg5jUdIZ/hLuR0Z\nnQwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIiP7wnh+gODrIqtCPBSMDra39a0J5PITEWkLfLpKBELAiEAufKZizqp\nOA06WCN3gGLhgUztz/L+Y8oeYMOTHnqDxTg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYEtPxb2MqQGJ3jqjGPh4olvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM1OGI2MjAtZjE0OS00ZDhmLTgyYTItMWZhZWM2MjU2OGIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTRjZDM2OGItMjRkYy00M2JlLTgwYWEtZjE0MzEyOTQ5\nYmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEicrDnBQ7UUf0wgmwK5/R7/Wl\nrIwDjk4t+8y36D65EJPl2UfAlEpuWWj5KdDbsKBIm17f7XUWbkFO+xmxnCUsgqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULkcz8iQx3mtcvzx+qhkS+Be8ZqAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgDP/BOKNu\nFMhL2z2ANuNTHAUrbJy2pwDQySW/Rr9d7dcCIQD/MP+8YZa4E8wl5+Up6Yw9AGum\nhLhJ52zMVjZKlen7Ag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4858", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4858` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZYHI/HwNy4LIg8H5bVUty7hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZTIxNGQxLTEyN2UtNGM2OS05OGVhLTRjY2Q0ODQ4M2JlNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJkOTMyN2QtMzc1\nOC00ZWFkLWIwZDMtMjhkOWIyNTg0ZGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEffG1hGHrvj4gELHBBWL5UqsMC0pcq8AxYNoO1oHnfjsnNJO5JPlvPYGKYJQY\nu5tdZUQldUDmUNo4rKaWqG/PdaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoe8KjgbkjLg5eRWwAotYmgf/0JcwHwYDVR0j\nBBgwFoAULkzMGEMnHEcvR1AOx3zBUt0zxPYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDIxPc+axgL\nBKPBmJ1Id7YOyXVDoFdYxfa2JC29RqjgKwIgY8osGxlsDu4cx7QOEgXVo/dAceYb\nG1qqRR6ClTUY1NY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQsjMZO0ZsDc0t0PCcLZWe/jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWUyMTRkMS0xMjdlLTRjNjktOThlYS00Y2NkNDg0ODNiZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPL1xG60Y1kw0A9MLyr/jtfISByHD4RNuabxiEyGlSQGJu\nOLQeygADF0KRTmulAaBYOw0gfOTV6MEbiBxWgKgNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULkzMGEMnHEcvR1AOx3zBUt0z\nxPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL4qLhhL/w/QXOyRngwKu24AYMHFSMzB8HiYoqySB+WQAiAlOYW1rMvA\ndNcseOQCucvMm+QWfihsRQeI1xPwU7J9Hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAUNb1oVuD6cU5XxL9D/R+WoPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJkOTMyN2QtMzc1OC00ZWFkLWIwZDMtMjhkOWIyNTg0ZGRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWQ0N2FlZGEtNDAyMS00Mzg1LWFmMjktZTc3YmY5ZmI1\nZmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmN3d1CDF/cDSHc4JiNUdL7ZX\nEUn7DXrF+oDoxjefty7gPCIrFF1p3mRF+0niopIadY5P8oaHdvpIV1wnZlxSDaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoe8KjgbkjLg5eRWwAotYmgf/0JcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMfXa/Dh\nmURue9RzXYoeO8sHouxFuj/6aNYJfwopt3evAiEA2NYrSW6mUOtJBMVcnvl35eDD\nUXHDWACQ0UNvmOK0nkg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4859", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4859` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAcnrcVnI3l1dbKq/0B0QVjzjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0NjVkOTBiLWRhMjAtNDcxYi1iMjIzLTY4OGRjNDJiN2IyNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTUwYTA1NTYtZmNj\nMC00YjlmLWE2MWYtMTIyNzE2YWVkMjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7uO4FsyhDBITOYIXlb2CLsmRgVjxNIh7ZJMzMYrBIOcWUdmQQg3wP3QbIA25\np/xryIJeXqFB17exVVntAG3x5qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzk1vGDI/UUgb1vdvOxe319DNCZAwHwYDVR0j\nBBgwFoAUBlxizhho3gVwgHkx7S85MraF2CQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgcyWmPOs86py8edJ+sbh8kbgRuwvPAktG0H1addehao8CIBRj5s3+O2oA\nAMC2NItyrLAHdlsifQQ+uA/1bwyNZTMr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWn6yu08wHFeP8DxKJtUqGowMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDY1ZDkwYi1kYTIwLTQ3MWItYjIyMy02ODhkYzQyYjdiMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6JCQYirLbIFCk4IJVykkyWg5FwSdVZ+teStfP0WUasg+t\n1Qk4U4ASSUNazv8vCNNXnSD0ZQyJIHA6o/CZp3h4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBlxizhho3gVwgHkx7S85MraF\n2CQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA6C8fyYd2oHrexJcXtkjrCmecE9gDt4OipdmHzMeSjQCIDBHOuBec9jd\nDX27vUqGFePrM2MnLt7e5VksLx3PT1mu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAV/3z1huQAEUy+XkuWryI9pYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTUwYTA1NTYtZmNjMC00YjlmLWE2MWYtMTIyNzE2YWVkMjYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWY2Y2I2NjUtZjdjNy00ZmIyLWE2OWMtMWFlZDY5MjU5\nYmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZgwNimIxFoS4ZzZucuEVPd7d\nRBmL7yEKei/FDO+9U/ozqUuRBCh/DCnCealzWZ83afsg3b+RvF0AHuALwebDmKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzk1vGDI/UUgb1vdvOxe319DNCZAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAISuDNUf\nt7THfvTM1B9kaV4/VGmpHsHPPRKxm/9+au/vAiEArafwWmetZFOudn0TxpBF1C8b\nwh/qE3IXOtE54UjxT3A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4860", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4860` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAUK8TWmDVarmCgS8CF4bq/2uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkOTRjNDE4LTUwNDgtNDJkNy05ODQzLTM0MGE0NTU0YzhkOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM3OTY2OWEtZWJm\nOS00ODI4LTg2ZjQtY2I5YzdkZmE4OWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqz7Vnepa4U8byriYi0v7j9kz0ln/vG7rpegPrVduV872uSO666+415rNq7OK\nOxRc3hCY85WTJRtnrM+4z5akZqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk+KBkAQYCO/3PEmEN+NlvUbnB74wHwYDVR0j\nBBgwFoAUiBqw9X/1XP6C74KbZxdK4vRFg1wwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgSaVg/+eaiN3UjlLO/wBZFcFf7YYDRzh7PgZCJlaO33sCIFfkMHq9SEdP\nMF08g4hAzj8gmdNrGRruPg+LjQ4i3J+i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQXGDQMMjAaO9PHU2ObM5H3aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDk0YzQxOC01MDQ4LTQyZDctOTg0My0zNDBhNDU1NGM4ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8uvHh3eep/Is0mQp46WkT7kLG8ne8zdR/W/dhscLGnzDV\nO3Pu4zqzrxLbqe6lech1nIDUlQSabocJNAGRhtl8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiBqw9X/1XP6C74KbZxdK4vRF\ng1wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKexGz9KIJ23h8gdZQLqLcnMoJShhE3pU/Z87YH5y1r1AiAd4X/5y55w\n6s2BCXZIteFHyEgPHnKkqFfpI3WJc6DA6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVkldltBToceZBxT3CDlt/1bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM3OTY2OWEtZWJmOS00ODI4LTg2ZjQtY2I5YzdkZmE4OWFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDBiN2MzNTItNTg2ZS00NjZhLWJiNzktYWE2NTlkNWY3\nZmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkJbSONbLy+L/6fzpMWE4jsPz\n/3KNVLTH0zGQh+uHGBQ/cuwD3VJsfHBtwsOxjJ/HQLQ8n4yq3YkbEqI93pScKKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUk+KBkAQYCO/3PEmEN+NlvUbnB74wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgLoX+8XC8\nZez3BB0nZlTDIS8jvVnvuI15ZhH5ypVfsb0CIDxe6Bp0dul8tvKWgNU7Nrd9UxTa\n4WnpOl4Gvi+TgxIn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4861", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4861` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAT+uMUCs72twegbPC/8hkGWOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3ZWIwZDRkLWQ2NmMtNDhhNC05MjNlLWI0MTEzNTU0Y2ZiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI2ZDk2OGYtNDIz\nMy00YzYxLTk3ZWMtOWI1YzU0Nzg0MjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeCDkg8974jdZCXwzdUEUfdQxv9WjIzSEF5NONpcisMVdw3ySYs6tj4IvKUXT\nb+hPob4zNg7Ot7Jr29PWRQgshqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7vjsuVB3p4St/kHCEo+Wkh8mGpkwHwYDVR0j\nBBgwFoAUvXPfZmUtDojbgZ75TPPKroRw73owOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIGvu58LR5mzp3CSIUf5MwIoPUFg1ZCf8unxMOXyhStRYAiEA+bwU1pLk\nA/BlVG8AjiOMUbHuORmBq1SXtjVV8906UtY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXAHB3SZ+dEgTY4lMYBEZDaRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2ViMGQ0ZC1kNjZjLTQ4YTQtOTIzZS1iNDExMzU1NGNmYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASefiSkPgwkiTTasmDrZa0jALhwcRpm4Hb4h7LK+K4sxtf0\nzQJi5zNUCMJ49W9MiG5xLan+kn7gLCGHydkB8X5+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvXPfZmUtDojbgZ75TPPKroRw\n73owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPXSRja3l5oqhFtgoh5bbdd2mRi3WVrM6GSe2ddGFU3BAiEAsmrPhEyU\nGYI+7xbt7ARKIllgUwZJW283s4NYkvUzjRM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUtTwPF80qjnkOlv1XpvTwAIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI2ZDk2OGYtNDIzMy00YzYxLTk3ZWMtOWI1YzU0Nzg0MjQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDBmNmY5ODQtNmI5ZS00ZTA0LTg5NGUtZDcxYjM5OTNk\nNTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6YNDOWAmmZG0nrlu3ubHDpaW\nubZ8LvKQC/xLuIduSKXHbqRV0xfY66DcmyApiZXzXGzFUfYqTR4RI7qKcfyKBqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7vjsuVB3p4St/kHCEo+Wkh8mGpkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMFRohwW\n2G9Wqr2gTHad+ycRqdZRaokAApNlhQbxOjapAiACT3J2+CuUXbnzvqSt4W9D1wGT\n6XGUWe78+Xmy+KOtqQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4862", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4862` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAZ3Nk/s7fKniKvKYOKcwQkbkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwYWQ2NDcyLTBjZDUtNDMzZS1hNTRmLWUyNGIyMTcyYTc3ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTZlZmNhMmItNmNh\nNi00NDk3LTlhZWEtZTM1MmJjMWNiZWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhj+KWtmWCuXYzFjDdEfRbKj5dFp9dPyXEnuDnvoyXP7BaA/Ycrf6lEIg/O6D\ngyzJyFyjGoDTaiwZXEoFX+GDHqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHgEdXydl0lmndEWlzqWKltLAXoYwHwYDVR0j\nBBgwFoAUrBb2Wg3vNPs/yj7PuialPaEMhb8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEP177QdgIop6iu6MBTeJapgVNa6JHt6ei73Y9fa\n1CllAiAVXjyXAVKUjU67MKG8IwWiPnMWlDigFw2QNFojVEOWqQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATzFcn0wN1N9Ik3w8o32NNr+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGFkNjQ3Mi0wY2Q1LTQzM2UtYTU0Zi1lMjRiMjE3MmE3N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNLXa2VLP1RDVlSk+DOcmJ3cpzoC6NaD3lV8ZYaOFvwNPE\nxKcCZCobspDfIXid7oHPVXwAp6dk9wKmdFbLTnxLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrBb2Wg3vNPs/yj7PuialPaEM\nhb8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeLRnAW4j3p3bnZR90z794NOJrIlzKUa3e65C1417N50CIQChSbOc0GjD\nnbGQVB1WtwsTmlHVnznjM/Me/gy35oY7Sg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAd5kzqYd2usTZ4i7U6nbKNbKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTZlZmNhMmItNmNhNi00NDk3LTlhZWEtZTM1MmJjMWNiZWY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmI0ZjkwMTYtZGI5ZS00NzUxLWIwNjQtY2RkNTU2YTA5\nMjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZhvaMiwZZbuV4WXh8BTdJtED\ncI5kcOrsI5AptyjUXEU5FzLzyR1VbPpFS+FE+PpKZIkAD9Q4K/Q+EMcy3+rY7qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHgEdXydl0lmndEWlzqWKltLAXoYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAI2N10Om\nqHTG5r5Tmz68khD3z+Nbe1FOAm66SRqBioPdAiEAq+FLwTMCIn3kRb+/Gv3s8roH\ngV1Jg/2gmfAwg/pnAtA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4863", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4863` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVySb/ET/Lm0TiE1RRe1HzrKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyN2Y3MjRlLTA4ZDYtNDRmMC1iMGZjLWQ2ZDc0Yzk4MjVmMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ3OWJiOGUtNzFm\nYi00MTY5LTg2NzAtY2MxZDgzZTYyZGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWnrdVSrk0/UL7wmfNGMUXiF4F93yk5TDiyDnhTftMN8URakoHzrQtXPabJHI\nwpveZkL2AHGNvln+K+xiDRJA3qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURqzsilI4RaAn/pk/T+HWQStsMIowHwYDVR0j\nBBgwFoAUKgtV4I5ya0A9hetPWHLEksc4HuQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDh/nEdpcvpP6yMwq4HSqAzdrRINJQqTwQ0Qs6H\nD1OQUQIgXGF1HyeraJOxt8DoWd18h45o2w5I3m5VyCN/EL85k04=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAanpuBcbGNzY8pz/iywST6qwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjdmNzI0ZS0wOGQ2LTQ0ZjAtYjBmYy1kNmQ3NGM5ODI1ZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIuW/Y2MzA31x4lUO3lShOEUS7s9HUX0QDA4IQayYt+wtZ\nZKRxMA79076ilAlntrYyxBq1MMwrnYTygKdvSb4Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKgtV4I5ya0A9hetPWHLEksc4\nHuQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKWAj9+CoDQiH6CTC2F9yFtqpXSpXlDzSdGOH8MZPnAECIQC+o2/Zhic+\nLV/Zv7R0luOyhYMMm+tX/0f9B/plVc7uvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAeXEx3HOWtPBAw1IkdKXG/YYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ3OWJiOGUtNzFmYi00MTY5LTg2NzAtY2MxZDgzZTYyZGJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODMyNDU1ZGMtNGRiOC00ZWNhLTljNmItOTgwMjU5ODNj\nZTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk5glsjTgOjVvkpRJGVts0+Sc\nH4tjTwyv/J6oz+/ePq7S7iBsxxB5ADnd2O+jm8Kwdb9mxD6ZuduDBJtuLt2hO6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURqzsilI4RaAn/pk/T+HWQStsMIowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAM23Xhg0\nefqXMuPK4PiI13fCo/z6Hw9qdyiTHS/4CdYxAiEA+KTfmmtAWa9ZX87F/QDxxLqm\na4w7+16tWfSp+2x8AUo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4864", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4864` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAfZKiuj4vpNPg9xjqpAZteeKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3ZWJlYTQ5LTI0MGItNGY3Yy04NjJhLWM2NzFhZGMyOTljODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY0ODFiMjAtZGM1\nNS00NTZmLTljOTgtZmMyNThjMzkyZjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfIV3gsd/rk2Kf0xxnIk9wJZIQiVprxXyvxUqaaxQfjJ6d2jHY/ZRxwCpcpD9\n15J9rzwfLRhfMaeAoDUtIDwHwaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXqlDigEI9QontQ3kA3a6CzXn1gcwHwYDVR0j\nBBgwFoAUgmM7MfKJb+bPZyZKZFqDe/vxzkAwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCICPBY3dZLxHzAVz38FWxr4oFo/fg1DDFQfF7RVt8oRGcAiAO\n09zaTeH3E80I6neqQoY+DUSFR1sGm87ElQxkZjOWZA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASH9hcysobKDT8o2yBdJlJg8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2ViZWE0OS0yNDBiLTRmN2MtODYyYS1jNjcxYWRjMjk5YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgg70SPnYwHxFU6vC/3rcofnbzJLAUtgtwabxPviduZh7+\nPfCaaDHD0yyYlruPEEArXmyBBG7QD0Lm0JQbaMdFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgmM7MfKJb+bPZyZKZFqDe/vx\nzkAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEBO7bTDK8xJehqm+MLcL5rJ5bnJQrMDMmPXmdczAbpwCIQCboEEOFH2u\nT8pmEryu+9/Ne262AITLS9G/p0Io8NhVLw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAdW8qrk+nsWZy7BNYFyRg1sUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY0ODFiMjAtZGM1NS00NTZmLTljOTgtZmMyNThjMzkyZjlmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDI5OWZmNWItYTQxZS00NzQ1LWIzZWQtZDBjNDI5NTI0\nY2QzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN61JGm2QpT1aC8GTJ+STL+uG\nMLSLphFYC9uIRrQtMxcEZa4h3RiYmriuXphTzIoPzam2qvJGI9WG3qTqODSeZKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXqlDigEI9QontQ3kA3a6CzXn1gcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgCmp+Nxqf\nANl/0aGoI+roU26awrLYtY62vrppeT1T3jcCIFdy+PbOusTeyxI+Rf96uIWhzJCZ\nMJpRomQrE6R3RoUs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4865", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4865` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZZiWIp8GqwpoJ9iRxIlfER1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViYmNiNzljLWZjYTYtNGEzNC1hMzE1LTU2M2JkMDczMzkzMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg2YjEyYjAtMzVk\nMy00N2RkLWI5YmMtNWY1YmRiNWVkYzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMkIMmTvZNAPMJJzID9wpEEDIpDn/McACWrmEXqblYt7QMJclO6rwa7pJQHPG\nE6PV9/EpVQT3yAEQkJzuXd88sqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5YKhq5HQXtEeZ8sCDqRGJGM8T8kwHwYDVR0j\nBBgwFoAUvnF0JsvO282ItPBjPAjOtu/n89MwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIA+KR1IfB7FiXr6Q91ste4hLPeCat1QD\nqPXPmcpYD/d4AiB9JUujzRFSnfSJXO/ZhavYoTtV0K2PHC6w5tsYnMnjcQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASndGz4LLQqJ064UVTka4Oy3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmJjYjc5Yy1mY2E2LTRhMzQtYTMxNS01NjNiZDA3MzM5MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATduPt1XZlG0MRxli8QQSXq9LaLcl1HNM99c5MRdJQLhY+e\nuhIAdln7hQg3f7Vn+VPu6MP8I1jkOrq+hcchSkM9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvnF0JsvO282ItPBjPAjOtu/n\n89MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKuz37FgyHd3WHPYtppXPsSs+20i93t6B5xlYZFvqQ/GAiAZpe0AHNzn\nZP7jAndJJLa3mESvoA4zjpuLoBDjSqIBYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAafFGzJVPw9sMkwl7Sn4ew2EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg2YjEyYjAtMzVkMy00N2RkLWI5YmMtNWY1YmRiNWVkYzgzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmFjYjEyOTktNTZjZC00M2E2LWIyY2ItNTdmYWZlNzAy\nZTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiPEtuygstSDbvIzVWY0L+Jxn\nLynQyctO2slTpzBgAPocEUizy6ulxASGMNhCxM9CxV7ttpZJe+sA8kINaLiywqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5YKhq5HQXtEeZ8sCDqRGJGM8T8kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPhV0M4k\nLGk2HjhR6iEljDLOJwKZ0yfleFWZd/AT2tc3AiASMohd4vGAgLkgg8/tDGpY2RgI\nuf9Uuc6Ids2N9oZwtw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4866", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4866` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAcdRUp1Ba7UARLJE2s8FXK+aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExOWIxMDIzLWMwNWItNGYwNy04ZjNiLTYwNDc2NTJhNTVmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzEwNzMwZDItZGFm\nNS00MDdkLWFiNTUtODgyYzQyNDRlZTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg37nGO60cpJpa8xv2VwtVvu/mbnCD2GZDF7VgrRJBvZTDkgvPxuKuQlWWEMB\nNtCpK+yhNPshQqy0TiFi1ngnuaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoLKSCqquqgXpjEgbgNHRRoyeMGswHwYDVR0j\nBBgwFoAUk0augTc4zK/qiTk0ZfZp8l9I3ZAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC5eJRz1MEXALC77378601nonSSXfJa\nmRjMbIkP0yELQAIhAPedEqgav5gn/I1Y5p+NoS0UtIvpFX5/hDoC/J3CVrzG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAez3AS9YrFgCJz55StHpeHzvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTliMTAyMy1jMDViLTRmMDctOGYzYi02MDQ3NjUyYTU1ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvUnbEycNUuZttN2GWAEaAljdLaQC3hamscoR5cUxayg91\nmAbP44GJ1U5i0UcLEbdSzzMnqq27whh4tz8GhXmZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk0augTc4zK/qiTk0ZfZp8l9I\n3ZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKCxJymBpMc7ranAVvFVddukf4bLkYOXW9sUtYJZkFNXAiEA+MUpSCiw\nv2CgNz9iQHc3pToCsQ2TBzER6xZI6ftBwpc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAR2mB9zqlRg1AUyt1Vna56OhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzEwNzMwZDItZGFmNS00MDdkLWFiNTUtODgyYzQyNDRlZTU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzgwODhlZmYtZDhkMi00OWY0LTkwNDQtMTBkZWFhOTgw\nMTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDMgXbvWIh0/8rqjuFdRQ7sP8\nSu9HjMm7lv6Tv7+CxGDcf2jUlQyLKWn0ARR4gb7stmbqe8WXcoukUrVwkdagfaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoLKSCqquqgXpjEgbgNHRRoyeMGswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgPaJ4s1jI\nMgQBDGyA83XNJmD51gvD5ijgmT0UrRVSC1oCIQCIyGHTwcz6qA8Vs1yGb90QdpV3\nVUI48bdacCNHGxSAtA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4867", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4867` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATBIMunW4oI0q9aLp3VscrmXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkZGI5MWQzLTc4NGMtNDE5NC1iODFhLWU3MzgzYzhmYTAyZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE5NDBlMGItYTA1\nYi00YjgzLWEwYzYtOTc0NDE0ZGRkZmYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgcYLKF9gXt9qFXH5WbkrN9jeuRtmyF2H0e3anQ7MFKVIVvNygwWImPrQKwcc\nNViHz2PIBQDjKRDzKiNTesi/ZqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHvqP/5nJ37G9/gmK/G2JpWui3dxMB8GA1UdIwQY\nMBaAFI54ZKXfOlwrRLWFND8pYH7UsAvsMAoGCCqGSM49BAMCA0gAMEUCIQD/fRqG\nwVNRHba1pPLOGK9TE1X0mjG+5hcWH07j7rx3vQIgbUxfs/PiNMUoSD2d2vCPJrZU\n4A3hOtDwV24vEQOmH9k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASfijDbVpe/cZDKZG2Mv9fRfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGRiOTFkMy03ODRjLTQxOTQtYjgxYS1lNzM4M2M4ZmEwMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGxBAFUSF1vevAbPfQz7lku/9Z8C5tuxiMg2+ZnTxD3ddU\nb13UH06y9nX2I3x4KiYts9Dvgi8y1EZTjHGMeJDfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjnhkpd86XCtEtYU0PylgftSw\nC+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALMzKgdu9fD0/ATScC6maXvM/JsxQxZyyE0fbOhjnwzAAiEA2iR83oM2\nypRHs/wOeATrxkhFIbaOQWMr9I6GO/tX2js=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAepw49FCC9obpt8c2499XhcRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE5NDBlMGItYTA1Yi00YjgzLWEwYzYtOTc0NDE0ZGRkZmYxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWM5OWM5YzUtYjlkMi00MTNkLWFjNGEtYzFjYzIwYmI5\nODE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBqOiBtyoAsCvPd2/8u8wNQUf\nJmdrjuGtNgY+rR7JnhzbhuirqxbPh21JV7PprHZSduEkBh3Qy6wTq4zm/Et9YKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUe+o//mcnfsb3+CYr8bYmla6Ld3EwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD5mzSLqzV7sxR5\nTyTCQ5Bo+mqlNlAwQFV36Ae5LXlWkAIhAI0kzDd/KYvYykQmmoqHY12XszFBCOuz\nuqCSMfkwQFsN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4868", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4868` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAWU9wli4bdGwfeza4l0H/sYKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4Yjg0MWUyLTkxYTMtNGRjYy05MDYxLTZiY2IzOWE0ODg2NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk0MDFjNWUtODFj\nMi00NmJjLTlmNmQtOTRjMjI2NDRmNjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET1pupuvS2OuXkCMcKjp3eWWldNI4M9rxBdGC6U8V4Pdw80QEbWgo1WmijqiV\nWItHGPENTMeZVLDt896J1L1rd6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEk8aZwpioQ9UP13YoxrvnMVMtsvMB8GA1UdIwQY\nMBaAFDbk9SZhEykyFCOCy80fcZ6rzR5fMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAysV8fk0TOFSo/ZyQelIAelWIvXhYzkPL\nziq/vr/Cct0CIQDsFCViN0O3oazpqxS8cczcGIucRqTemetuIGYox4R9Aw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYmOvkgukCnf4p+lmOiS9CrIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGI4NDFlMi05MWEzLTRkY2MtOTA2MS02YmNiMzlhNDg4NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5+/s8bzq5sYKVrvo3FiNsHcCJXP3YDk1Vd9hwVpwdXYij\nDamPjbOChMnyUIzcYX6dHCfQnuJjN53cCdU95VqPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNuT1JmETKTIUI4LLzR9xnqvN\nHl8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMvn2sTm4by7DzYRx9wzWDO1BVtUruB1N/W94GYKyaoWAiB5txPMy2D6\nckz02f3DRCGeyy8aPZeqRaTCCWg46ypBiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAeuUL4iE/JriOx09nbZTSd2wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk0MDFjNWUtODFjMi00NmJjLTlmNmQtOTRjMjI2NDRmNjllMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODY5Nzc4ZTEtNmM5Ny00OTAxLTkxN2YtZGYzMjI3MTQy\nZDA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIaRhmWmodPcvp9TZ4G8tO8d3\ndzBjou75AkxPENZlQye9aJ2rDXIdiNg/lfZZ8eJjzMbdXBwT8dLhuPQIDhOXwKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSTxpnCmKhD1Q/XdijGu+cxUy2y8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDua7CNxF/HUn5W\nGbEP+XgDMpNBhk83i6zoAkqLRp1rQQIhAOIgvRyWBuTLB//zkqH/OYtGQrlpIKZn\nfE+cEFLWwbXY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4869", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4869` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASoVnv76TekHOPLJZMKAgV0xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2ZDMzNDcwLWNhN2MtNDkxZS04YzBjLWQwOGY1OTdlZDEzMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFiYjdkZmUtOGEy\nZC00MjgxLTg2OTQtMzc5MzZhYzM1NWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESAo85GuJ1UJHdfLPB12PchcqGEeKVsmidRq6cTn5sfi3H5vBeLNE4Akl0dxJ\n1Ha3CMHNUT6NAffct0HJo6pPYKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIjg7SCL7vN1tLqp0WIekVdCCLWTMB8GA1UdIwQY\nMBaAFID07+IPliucPg2hYA82ENL+qqu2MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBcUGFG6Trk0W9NmtQ5lZHcP7BZfcBQmvkf\noVYN96XgJwIhANosLIzDxRf+vhc//ugWXjKkMhD4/jBKwCnuO9xx1VrU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaSBb0WtYIvqEEPpq2mfP/5OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmQzMzQ3MC1jYTdjLTQ5MWUtOGMwYy1kMDhmNTk3ZWQxMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlGDb9sjdmo8HCJDeAboD8dPJ9Q3hYpH8L1+Bwb4W1PVRG\nBlIx49LPQ34CEj/Oib8QQoT/PwxV2zRAkpQBZ7p7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgPTv4g+WK5w+DaFgDzYQ0v6q\nq7YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKgQjEu4uOziibWEFL2GxyPhcO3rbxsGhQUe3bDqAKY1AiAmD2+1NKg4\nsQINcxDVRoy0vR9702q2qqdECS476juwUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAX6glN3a9GaubewqRqgk/dU3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFiYjdkZmUtOGEyZC00MjgxLTg2OTQtMzc5MzZhYzM1NWU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmZiZDA1YzMtYzQwMC00ZDI4LWE0Y2ItYzFkNzc2YzMw\nMzcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw0DqgUFIzOcR9a2Zd4+Ri/ST\nEkgtidnShTH1aX1d7b2N0XRBW1xhETiPkxH5UvIie0RrrA582WXRlIcnqzLH/qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiODtIIvu83W0uqnRYh6RV0IItZMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCG16boCLUrnDio\nGv9pM2lZEGFdga/2PLCw4ejPKXpX5QIhAOUY5KyX5REN2XMx15ZGt15kKP4kwPx7\nXRNzQpkFgUt8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4870", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4870` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAc4Glca7RbqZM5QiUS2lbj+FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1MzNlMmNkLWYzYTYtNGU4ZS05NTA1LTM4MzhlMzdmYzc1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY1ZGIzMTktNjZl\nZS00ZGE1LTlhNjctNTNkOGRkZmRmYzcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExvVYS9CW4UnpCrqKfM4Uk15PYapFGZ5KsOtSOdISPR4nZY73ZXc6qbpA0mUg\nPvNvBeiR02mbyzBr5ZuxviRdxKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQYGP1K+jEP0veOcvKySqeS77flnDAfBgNVHSME\nGDAWgBTM5QvVTHIl+tt3WoZ0NikYjUCKQzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIExM5MfHDhyPyTA/u58tHPvAf7/wWQnd\nDrXTxgKQAU2lAiBzs3e2KhHBRbhR3JDARJA7bdAlJudKZb1LRjClAp/Z3g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARdujjRawat/DUVCzYi6YT5PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTMzZTJjZC1mM2E2LTRlOGUtOTUwNS0zODM4ZTM3ZmM3NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvJYE7NI6qBukA+do+V7unGjWbvP6oOag3SPbi7GIocV6o\nHhFgiaf5+1VvR5pcpfRL/Q8F+9hNNJBzpfF40Vrio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzOUL1UxyJfrbd1qGdDYpGI1A\nikMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMbV1avt2fZS2SxnIIgSKxoj/HnONaSNIE4sT5lKVNfMCIQDSeVTrP4U4\ndKiNclNd1Dx06gF3/mZaVECAgJCES2wU/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAX40Lceh/dvu0FLUp/ltepVBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY1ZGIzMTktNjZlZS00ZGE1LTlhNjctNTNkOGRkZmRmYzcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk1MWNjMGItYzg3Yi00ODNkLTk3ZWUtZTZhZDkzYzM1\nMGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXjE4Ned/5TD/3yOtC1Pe/ALG\nACRb3JXU813VnlhEAwlu6QZmxbzngAcK7tAncAzdqeofm0nWo+jNyPa2Jhhya6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGBj9SvoxD9L3jnLyskqnku+35ZwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDllQR65cE1626p\n3uAM5PU6KLfYkLENW8qxixPgvTYaYgIgbL/rT8LVCNIIlqDdI4JCulFCT0yCVE/S\nxx3V/FfL3Og=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4871", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4871` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATXIkQ1GgPWOxt2K7PVxB+mqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkZmIxZGUyLTU4NTAtNDQ5OC1hMzlkLWY2NjM3ZDNjOWM5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTYxMjJmMjctOTM4\nOC00YjFmLThhZDUtZjllYzZkZmE5YjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEohUmHYx8sueteEleomB8BmBv5BkRUrSXCmhmU89Jjo6cyxmdays8mZtJYxVL\n1PGkEYEnQRPM7NAlyOh2/n/1QaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiw359zy7j1xv/ykej5EELZ3nbxYwHwYDVR0j\nBBgwFoAUQCEq2kWOPGb8DD0xAlHAY+DC9HgwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiA7DfpdOSPeCUOU\nlQL0JtMXkBJCmDTkkRaqzFsCOrx3FgIhAOOQPsuq0uyDQEmR6WJvvprHWuZ1P7LN\nngeaXmsRfD8A\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXVyMsp6Cu/kxaCO41DHWE6PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGZiMWRlMi01ODUwLTQ0OTgtYTM5ZC1mNjYzN2QzYzljOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1Q9ueekc6PFXoMPnXEP8klO1iPcff5laszYloxwJptWI2\nxfNE6d6xX0rbjJTzQB3vXROnOLRlJciVfURCMPeRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQCEq2kWOPGb8DD0xAlHAY+DC\n9HgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPKdrgArW7uJf2xhX4nv+TauSEE50v5SQKXRNcL4Cqa8AiAQmMwFIsEK\na0IlWEQ+KsnUx6EaS2tBSOlB8WBpcysv1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZWnkZYsVmcfEJVLn9m6MAiNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTYxMjJmMjctOTM4OC00YjFmLThhZDUtZjllYzZkZmE5YjRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzEwZTQ1YTEtZDZiYi00YmQ0LWJkNjMtOGQzOWM2ZTBi\nM2M0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEe+ROom2R5VSpowHElGEPk1Ni\nJ9db7it6ORbPxwM6ieBR/mFekcqhU4DfT7LcXdCq0fP6dAWA9EEF2z4Tt5p1SaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiw359zy7j1xv/ykej5EELZ3nbxYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFnBQ78woyWO2tJJ\nsbc1LC7Jor1aqtQPUKE1lDZ7KLouAiAqsJ+sw/7ooZ+n9tSpYfYdhLOUApHW8ajS\nqLjYYJRDdA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4872", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4872` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAXJUABpAVpQBQvtEXgLszZbvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzZjQ2MDc0LWI3NjEtNGMxYS05NWE1LTljOWE1MzFhZDM3MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA5OTAzY2ItY2Nm\nOC00MTcyLThjNGUtNjgwMzIyMmEyNzg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK/Kvy7J7VZM3pM/JYNKajNj8oXlhpdsomHVOGKMwyuN/GVqgMJaPBN9PbSMX\npUvdodlfU7ZhXIR1t0lVbLy6V6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1jFFCDOm9ALeYL7mxyTkYzt3HoowHwYDVR0j\nBBgwFoAUQZtWYwQyIUiq6kWPa5up7StFSIswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBj3G57JxEipKOK\nltsCvLUZmRx7WJAl+w3CJE738Vay/gIhANiSy2C/4k/jYovNhqdzoVEwkKoJUVMI\nvDfKcqmtWJrX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfDn7VAV0MWWk/UHJDm1QUmqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nM2Y0NjA3NC1iNzYxLTRjMWEtOTVhNS05YzlhNTMxYWQzNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ05D9WfW1wD1CnuHuKQUQIK1ddxlyAiknKNZqsbvZY5eD8\nvLkxUaPFgbzxpK2kkrweDoXrRt22NWFDsxNptJs+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQZtWYwQyIUiq6kWPa5up7StF\nSIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOyoavICwJwxIAvq0UDDMBGReGH/N4XNjb2nFn2cBjMgAiA408u5OQvZ\nmPKxlwBdl3Umty3VDekiss98e08+l4O2lg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAdp2OJtE8saMthQ6+HwfyudcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA5OTAzY2ItY2NmOC00MTcyLThjNGUtNjgwMzIyMmEyNzg2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmY5ZTIwNTMtMjUzZi00Y2Y2LTk2NzEtMmE4NWQ0Y2Q4\nN2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6yiI9kl5BRqXlP/dVzPcyTqJ\nFKIRtRdaBebpHNkePyjUPd2Gfn4AXnix1/R4VcyU2y1m2PG1Qgg+SE5IgjiVdaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1jFFCDOm9ALeYL7mxyTkYzt3HoowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBZM8Lczty4bJGJ2\nSQzlknvDBs9r8nr8LCc8Cv01zdVEAiBx2gZ8+di647yS+ko9Tp1mNY+dcKi4lsDL\nkGD4zsw9aA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4873", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4873` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAVxKg1YTAs5rpfaSlQxDhsDBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0YWM0ZjYyLTQ4OWEtNDczZC1hMGFlLTYyMWRiY2Y2ZWQ4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY1NGRmNjAtMjI1\nMC00Yjg1LWI2ZTAtZDRmNjAzZjAzYTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa1an8k63pphXuU/AX57xD0LwYhXlQQBq4Jfq2PckxSZyeSNKgsjr4AQUtmcC\n90Tme/3GWxHxZWSh/xWHH4yoPaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt/wAk5OEma5yp1OH/ry7zBJv4gIwHwYDVR0j\nBBgwFoAUtQL3QwOf4pNr9CrDmI0sBEMVZSkwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA9X7HlJdrfu7OD6KOtqv3\n8D2cwxIk02051IfU3AVOwpwCIQCYnSCHMKlQ4jOui4myoIMHtPP/vXpwrxobD6fY\ndjc2DA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeO9cmcFU0lf7WChdl+8iKGGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGFjNGY2Mi00ODlhLTQ3M2QtYTBhZS02MjFkYmNmNmVkOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5XnWKbkEqVk+J4RBSTgvfdkmuflCBudujnFF7LHi89R4q\nHm9UsNtdvjcQM972PPJKv7Do9kyVM/NnQ0kE+QNGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtQL3QwOf4pNr9CrDmI0sBEMV\nZSkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP+9fWRF1+Em3oLhL8ifuOyz89j2mDmBD4hlWzZUiifICIQC5FCa4BZW6\n3X/8ZfavsqitBS644S7LEda2hBvVIfPZTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATGel9cxkgUP9Ok+Sq9pCl+fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY1NGRmNjAtMjI1MC00Yjg1LWI2ZTAtZDRmNjAzZjAzYTgzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmE3YjBlYmMtMGY1MS00YTJlLWEwZjEtYzA1OTIxNGNi\nNGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDchRwoS0ogfFHBDCbCkmBqyz\njR7iQFXl69wzF7FL8hI7HsP7diNrKwKpmSqE8xmILhbr5g/j7L4oZ8Lq9+i8PaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUt/wAk5OEma5yp1OH/ry7zBJv4gIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCId1esJ5/5Dkgg\nBModfDoKRbgFPrR6uM6hz1JckNpjxAIgSmMo82FZvfj7Rk7YOrTrjiJy6Gm79zvi\n7j+M/AhnzgU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4874", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4874` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAdXe15LvdXLHCRPPEG7E9X9qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1ZTIwMjRjLTVmODgtNDkxNy04OGZiLTg5NTBmZTVkNzhjYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJmNjFlYzItMGFk\nOC00NDI1LWE3MmQtNDMzZWY4NGRhZjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4kzVj9zjcEJuXe+mkusdMXWVv8LeYESUmLJ9/eHkdpPcDZfb8t2ooId5Kt69\nuaL4MXiCF4Nw6XRMcnj3mM8DCaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUam+auS54rMVE1f9wLGKqIRIyIyMwHwYDVR0j\nBBgwFoAUn35bXn5EExX8tkiNilKRd98ANqgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAiFhA\nl2uhMR+NKvlciNc5JXMq4guFQpoGZnwPU7k0ytkCIE+a2AFwdmH3xHgrtEvOUCD2\n4bzuO6jQIGoIVPgaFbVn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARTVRJ+i0AII53+yOgA3lY4VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNWUyMDI0Yy01Zjg4LTQ5MTctODhmYi04OTUwZmU1ZDc4Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8phcyI9sMjiiTDv7e6VhGSI1z15v46MfWrq9QZsl0qUvb\nz6rsm7+AwQXByXIsyRCLcKr9pDHmA61JecNDuv77o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn35bXn5EExX8tkiNilKRd98A\nNqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPPqHLCQDmH5el+IqV0heIt8eqfY1tZq8jjX2YvI/4J4AiEA9JDphwL1\n5tLF10xtIBHz/buJimgkR6U2N4JW2tPd2yI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAS21GYypAfjdtBh0gv1zRsu/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJmNjFlYzItMGFkOC00NDI1LWE3MmQtNDMzZWY4NGRhZjFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjMxZmRlNWQtNDE4OC00NjhhLWE0OWUtZDEzNDA0Yzgw\nYzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcS4ERllmFrD10p+iy026JEnR\nAWgWbFcyoTtjhwXJmVqQyDQeOL5UDMeYzP6ppT0gxdqsdF2qGNDDaMh/wFqk+aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUam+auS54rMVE1f9wLGKqIRIyIyMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIELHjFwVoa98TlVS\nJz6bejWqQWFe68/+JM139OpxwE9qAiBMznZaAqlBq5O4aNbbEuNNm8z5jA2WtNHQ\nd5A9XVMWCA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4875", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4875` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAbXmDuxf9NwpZ+q33mOi9hC7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2YmVmODkxLTVmMTAtNDJkMC04ZTFjLWE2NmY3YmI3YzNjYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmVhMzQ2MjYtNzcy\nMy00OTM5LWE0NWUtODQzNzI5Yzg5ZTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyoqB2/Y1QLJvF2q54V1i4mhvNvCqKfwbnnew8YaKN4jHRzVIS+jZLGgnvOXp\nqUruNubqEoVHXITPJVNmMfFTX6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUamW99cOAY0nwot5q8hh349xw3fgwHwYDVR0j\nBBgwFoAUeh0+lE67UhrdH7zY91nhgUVoMKEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAhsNM\niSwb0Ta/3nO39h9yZI2rjWCpFGgQU4VqfD0Bhm0CICcH83UjdHhoe8X15asBHXiR\n2hiYcQrgoYuPx5sWIUGB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbEqYNJyiuZdpI5NzAAeACMpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmJlZjg5MS01ZjEwLTQyZDAtOGUxYy1hNjZmN2JiN2MzY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9fHHo8zsmbaTFHbNsO9QdR65kylONazJS4WRTNbW+Lxti\nUCNAc8N7mOIYJxA5m6VfQWUMQepmn7mQLPLvoc9fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeh0+lE67UhrdH7zY91nhgUVo\nMKEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC/whvQXFdiQDXl48qXdvFQGHyiab6242+lBdsRekiJYCIDVaFrwZaLH1\n6Fc3uBIkYvCiDiZwY6Qk1eRHAfi/nBKA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAd8IIO1Zp0Z17BWDZhUK8yfdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmVhMzQ2MjYtNzcyMy00OTM5LWE0NWUtODQzNzI5Yzg5ZTRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWFiYmJkY2UtMDU1Yy00MWQyLTkxMmEtYzMzMGEwMDk5\nNjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMofpKrI5LlJcEpJHgRFb6mQJ\nF94th0KTwWAgccQoCJDCD96HAqfgSmPfHwy8Bx/cuLUlVtWyvELchsMoFkKopaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUamW99cOAY0nwot5q8hh349xw3fgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDMI/jL7i7Z9153\nGpSHnRq2apWdwIV+MSVZBqUQHuEL4QIhAJ1t55Q7NxO6GAsaWwN+s2p9ySqwF0dm\n+FHW7AaS86KN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4876", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4876` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYmtEBLqLrkdEwXxIK2fqRhgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwOGM0YTU3LTgyNTUtNDdlNy1iZTU4LTJhZGM1MWI1NGUwYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODc5MzIxYmMtMDM1\nZi00MzYzLThiM2YtYThiNmExZDk1OTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKYqrPmBSm4HO0VHM9913zYoMZrQeqZ6/3BIAKWlKsWusT+BsOOMbxjW7tQY4\nkxOYx6W9Llji1WzNFNDW0lpQyqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNxCGzClr3YUXlYy2aBAp0/x8lfXMB8GA1UdIwQY\nMBaAFF3oJDU+tYOQ/CrchlsO5YSGP+udMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAqUOaLSBBaCuSDjEd7hL2ClkAJbFMIxze\n5OSwOKU+BoQCIBzhzGfddjh0vWiau6PUqwj4g/WzcUqWevng+l9qP0nZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcc0gB165W08vwZgbIn58VAOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDhjNGE1Ny04MjU1LTQ3ZTctYmU1OC0yYWRjNTFiNTRlMGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQomzuZkSLavQSaBpekez6p9x5p9gF/wDZcpE/rdSLsxdzc\nz8DGo4BgbR8yVtY9kMj+mUoEBuMgif2Vgmg7QhMio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXegkNT61g5D8KtyGWw7lhIY/\n650wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPlVwe/chLfAnv8y1sO8IqQJ33kAafdMmprtnc7hIO5RAiAjgCTYonEG\nCvgJ4slyJ9PY8LcfXshr7WZfUMIHVj4p1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAagioiWkIpk9Az4U4ztGBZSTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODc5MzIxYmMtMDM1Zi00MzYzLThiM2YtYThiNmExZDk1OTUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTc0NDkzNTYtMmQ4Ni00ZTE5LWI3MWItNzViYTQ5Zjlm\nNmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9Oix0GAKBhu/0E7e2ZGfTOn1\nZv1stskqh1548b22wc7qizPVIonu3rWfzy6sfPQ2pjDcgl2zaNoEGkTsSXaoVqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3EIbMKWvdhReVjLZoECnT/HyV9cwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCV9LAhR4b7sN6E\nNO+/m4Ru3KtJw3uHshC65JbcnsjsHwIgU+Jq8qsBZllDJGGwodVgZ4VzbBh+7mde\noMH0RLxFEpU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4877", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4877` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAZDG7wedt+x1SRoyD6eXZhVlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZTExM2M3LWM2MWUtNDEyNi05Njg5LTc2M2VmMWUzOTEzMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJhNTQzNjEtZmRk\nZC00MDQxLTk4MjUtZDQ5ODIxYTQ2M2I1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8fAPz29R0a9cySAt4VzFJGAVt0b2aXO+q4obJlnksgaP3QFsYJco436K6vIW\n7YGbx9e394/NoUCau/Z1VF3YeqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlWDyULuaI6J9D+F/4GuP0pN0SAowHwYDVR0j\nBBgwFoAU/9/C1wMvM+9qBxKARLqFM4S0F74wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPpZ/ejbYPjj\nCBXzJcxSxz3ewn/TF95Orts8t3B9oJ4iAiEA6isEoJnOC0/9SsPQRU2c9xlqsK0r\n9leq/MaxfXSNxlY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV3N1FrYm74ZcZ4uCnE8oONqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGUxMTNjNy1jNjFlLTQxMjYtOTY4OS03NjNlZjFlMzkxMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATf5gl0ngPqDcLrJZnOlUcTL0kC/tfDzqNXzCJUY/Um+V21\nJ9qiYETwk6xlpXJAx8HeICJmZcEXkV7mYj+o0Aico2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/9/C1wMvM+9qBxKARLqFM4S0\nF74wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKZ7PwJcxzZ3w1sxRtZP3sAOlLdFR9/CmsYwGfMtoAtECIE0v1ltylpat\nOWEf+j9f8Ow6wd2cWvoIL3Xiwt8G3C5o\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASsh3UU7MpxKIR6gALrMNuEkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJhNTQzNjEtZmRkZC00MDQxLTk4MjUtZDQ5ODIxYTQ2M2I1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTg5N2VlMzctYjIzNS00MzA1LWFiYjYtZDAyZTBhOWI2\nOTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEogGu52JZYHMTrEU+syPsfXBi\n+1batS/woCavwjT44MKfyi4Jgs6BMQKPexls9/2/b/rKu4zyjgBpguXJuKKPaKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlWDyULuaI6J9D+F/4GuP0pN0SAowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQColHoRWg2pDOMg\nMNPwE0AUhhBopWQgmKB6PsEM6dTo+AIgcL/rI9dp5oMeRH3j649NSF8O55Q/jHNg\neTpKqn7l+NA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4878", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4878` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATZU921yrbS0Tj93eXS4RzFkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkNDdiMGQ4LTU2ZDUtNDJjZS1iZTdiLWE5MjAwMDhiZjZlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBkNTViYmUtZGJi\nMS00ZmJhLTg1MjUtMzgzN2EyOTI1YTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB19am0RlYVUwSocGWgW/hVaw7HI50UPOBnn1vl2exp9rxUDqNvIe79rZ0ENG\nOC5XMIVdcYO4mA4IoL50/LARmqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvWcdSKlymD9J6o3SPGnPFaBmqfUwHwYDVR0j\nBBgwFoAUdapwTniMnFWrhkjgKhmuQUmYO5cwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJtVAq1E9LZk\nz9TVfrOxG56wpGn5MLHOrgIIzcPydoRGAiBWpuCJUY4BMLTelifV32mbuverGp6C\n1vahnQs5Bim+1g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAReLB9+MoE9VQltUFKwiNXsKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDQ3YjBkOC01NmQ1LTQyY2UtYmU3Yi1hOTIwMDA4YmY2ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUWBjLE95LcpGtlk3u5TfTTiur30llW4JYfKe/VACG33Hp\nGyzUvwuzZkx6+zvs3q6Ld1BroiafFhp2uZG3dcByo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdapwTniMnFWrhkjgKhmuQUmY\nO5cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMj+IGBzlAW3XtWZdu7P+ErWc8JECDLj3gkBiYcyOqCfAiEA2Eg4coV4\nIee7jfzhDNq4TOSz4FHW4ZHZ9BD9kFVL3q8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAdpXRhxKdUNFPjylY11lhL8FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBkNTViYmUtZGJiMS00ZmJhLTg1MjUtMzgzN2EyOTI1YTgyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTFjNGZiNTgtMDZmYi00MmNiLWJhYmItZDg1MzMyY2M5\nMjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGc+mwr08KzonZaBzkAJbM2aH\nLBRcI5orzmWvE8stoy4QSL8TfkkBw8sPrq1/tZxYgE17gaaw4mLl81lLjyg7F6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvWcdSKlymD9J6o3SPGnPFaBmqfUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBDh6kuljlJWcDrn\nZP+EkGTJXeyib56+rpVLIpNiZ8utAiEA6QMbbukub19/JmZMw/J2Pj542L2Dhf3s\na28/K3+BExU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4879", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4879` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAY9x+6xi0VkzQL3rhrEsMSI/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjODEzMWE1LWVmNzUtNDIwMS1hZTExLTQ3OGNlOWE2NDY0YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVhOTg5ZDktOTBm\nYS00NzM1LWE1ZTgtMDliODdlODQwZWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1ALoTEx5AQ9+HvQs5HdOME6T+RBN+DlBzFxd6slRRVGdy/dAG6CuJzI7SQp2\nHPPd586odLgpQqI1+wLvSafJ2qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2FUKPvWrs3ZdJFmZa0unyjQa/uQwHwYDVR0j\nBBgwFoAUgf3fkKfy7AVlLNOMNiTJ8A5W5vEwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHSWY+kH0GMA\nSNwzzH5zH8zQi7T0uKPXEBstDfZ0yN+yAiBPrdT/VjaX/p4fmD2GmPIDlMwfq9fW\nsSWfLaNm/1pgmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaD7HvLw7L3z2qn+6fYVp/+TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzgxMzFhNS1lZjc1LTQyMDEtYWUxMS00NzhjZTlhNjQ2NGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0BS69yhwLzcrUA1AWSFa8TUwURwwOWN84+ZOvbw8nJJ0v\nt0wiy9o+RoxkqBdJAqUsN+TRCG6ftXEyOxGR1p9/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgf3fkKfy7AVlLNOMNiTJ8A5W\n5vEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANCVJQNLhjDDSUJ3z7vmlP3Pq36oBCDLX6w+3E9h2TIDAiEApZfCphl7\nd/54Vn2J+izLQt1nriBlqNdJMi3Z2SmaJ6Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbLVL5HqnQSAhFwLXNRy3kWnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVhOTg5ZDktOTBmYS00NzM1LWE1ZTgtMDliODdlODQwZWZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTQzMTU3MWYtZTdiMS00YWIxLWI4NjQtMmE2NDUwZjVi\nYzEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaaroCddVGxhzOd4Tjih0psTl\nMGRXfJWw/uSRsYizx1PGtVjVYmoZVfgMu2Qd+oitXHdQPUgsewkmoomoY57Rj6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2FUKPvWrs3ZdJFmZa0unyjQa/uQwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDZ0Q3brc6SHcu6z\n550BXs4bK/ZGkutsMDY2P+10ALXgAiEAkGWFWEalxKIB7Zlx2/qXt9/4/+lxot+y\nMTSb/CS9+7E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4880", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4880` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbFFa2ENgGwxX7/UMJBcZBAdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyNDNiODZhLTViZTEtNDUzOC04MWU5LTFhMjBiYWU3NjA2NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk5NGUwNWUtNzhi\nZC00NGQ1LThmNmUtOTgxMDllNTZkNTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2bazv/NRjWd/F6caj0UVOIsSFhSeFHyGsyuSjIrb5RIo7Zq9ArDx4eTLAnUj\nc9wwd5t9HnpJ7Mbkzrvj2r8mp6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA7JFlofxuZxTm3UGHia//RhuCGcwHwYDVR0j\nBBgwFoAUEGvIzBfK6lSWYzpcYNu3Y/cGTpgwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCvGF6bzQD7oNjPrZhAwX6d2Ff5mecRob8MszT+ez2NvgIhALyWGWcMLKuB\nHfiSKWriyue+CcadA/BEmcvfUd7wNL35\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT4uwgkearm8b4Xvi+hjrBTUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjQzYjg2YS01YmUxLTQ1MzgtODFlOS0xYTIwYmFlNzYwNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBqZWGY2UGxg7fFqezwirvkXTReRbwDyP4FIKUUmrpt11W\nk9tNipzxSlNpX+xsDDlsmEDmpE9zjkEAJZw84VCro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEGvIzBfK6lSWYzpcYNu3Y/cG\nTpgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWGQm1stJ+ef5r1Hl/HI1CM3sf1spFL7RA2peKrXfvuECIQC5A2CMpfgR\n4j7Yk1FGZ3VjLhTRpCRh0I7nPbpUnQvrZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAbkdhUuWnEyb7UF5hzHdLXLkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk5NGUwNWUtNzhiZC00NGQ1LThmNmUtOTgxMDllNTZkNTAyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjYwM2Q0ZjAtMzViNC00MWQ3LTgyOGQtN2U3NGQ2NGY0\nN2ExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfXEvIcch2A/ipSYRmQIyzjTa\nlFJ39UmO46dF8nWDMLD/G23UN4qxvvruxmER8n0j8/HAXP7lMUP6+FAi1z2yS6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA7JFlofxuZxTm3UGHia//RhuCGcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGJoBtnEIXwT+iD3\nerjXjmkMXlGtl0lvslau3dphNAvQAiAXtUmFZqDOkrn2oQhbH3Hd0YjNHiGHU99p\nKoLrpao84g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4881", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4881` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYgWCD0PxzhtXHyENXcpKC6fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxZjY1MjQ5LTA4YTYtNDI1ZC1hMTlmLTc0NTZmMTFhYjJkMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFiNDY5ZDktODU1\nNS00YzNlLWFmN2MtYmZiMjgxOWI5MGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkVq6dHbD2YTJ7y95cM6y+M0+eT9DnyH9RKNJLstiTmdY9K9HgumNw4vb1cmp\nbVrUAgEDsTSqeqSKzkYSTRwX7KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEtPdqz6zmsi/1VDB7tn901T52OswHwYDVR0j\nBBgwFoAUClr7NFEBPYofJzI4RFPHlt1tUZcwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEjpw5u1RPgJo5PL3J4pgVxwuPu0YEJAUNija89x9oMpAiBlP9L3d3Ewz+JT\nnBW6lQu1QItG0KHkJknb1sbKGD/9vA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWtDi8kR3PY/e1SV3x4yLAYTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWY2NTI0OS0wOGE2LTQyNWQtYTE5Zi03NDU2ZjExYWIyZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9rKOMp4hTSfEsTmJa7uVUmrLvsDGg9oV3yVW5hjq5OHTK\nEiehkA1xcAe2tnKGjfNnlwtu3Xjqv+e1RiJlHSfVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUClr7NFEBPYofJzI4RFPHlt1t\nUZcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK+yN+m6CXDZNBNFXtCNh3go7s63M6c+egnXqSdzlnFOAiANtOgv3Z+i\nIzQooviGyrTrqhWYY8JqqOg03Yt7efI46A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISASywVlz8+M8Ps1gRHbuYjiHdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFiNDY5ZDktODU1NS00YzNlLWFmN2MtYmZiMjgxOWI5MGRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQ1OGEyYmMtN2NlNi00YzdmLTlhODktMzdiZmEwMDc0\nMWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESVE1ijPbjo6vnvEpTSOVhdGu\nt3Mejjuqz5SLIknLBcoHXGNIOtgpFLzPTitRXHrnu6n8/7LzsodInsjlYRQOyaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEtPdqz6zmsi/1VDB7tn901T52OswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBcGRFmFYTPRPXzX\ne5zARGZv2Wv4RKPrihxu81LDRb9yAiA3Xi2fpNgiNqQ30U83YCaFBFEI5qIXhKjh\nlysm5PX5jw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4882", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4882` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISARSPPE6jHDLYMhR+k/5CVXv5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyNjdjOWEzLTcxMWQtNDUwZC1iY2U0LTVkOGY2YjY0NDZmZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNhMjJjY2MtMTkz\nZi00YjdkLTgwZDAtNGQxYjg3ODc3Mzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3+IhBEoCF1Ut9mdgXUj69CNy0fNN1fE/3wgv31UwI32FNJYc0c/6x9Zfv9HZ\n9EJQ602r3e06r4bTmS5UPmR5IqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX1gERHepCjOLhmbBHmxNTmAup8cwHwYDVR0j\nBBgwFoAUV54ZISREcvOpDyg6PCFnRkCNevUwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDC\n+UFIV2CNaH8M94zbyCtIZ9r5YDntLwsVBtGtsQnRgwIhAK/Z/nPkpwWBJmKxshXn\nQvvkZEiEHISLo478giqyG505\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdoMMAXNy1sKqmsBURLTFhVEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjY3YzlhMy03MTFkLTQ1MGQtYmNlNC01ZDhmNmI2NDQ2ZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDsRI1+asVCS4aY4dbt9GzdEzw+jFGqeVqCXiQHFClo2kt\nrO0PSJ5RWeumh8+a3YIZrZpWQcBrUocaq9H/CdFTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV54ZISREcvOpDyg6PCFnRkCN\nevUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIu/WeLVtT8UuVgCk83hlZk2nJpWyectlhDHwW8wM1gvAiBn5oZobo5X\nK19s1CuEav+3OiMB0NR828u++kPQk4ctuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQQbDW7Yn5Y3LbnSp5IKjimcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNhMjJjY2MtMTkzZi00YjdkLTgwZDAtNGQxYjg3ODc3Mzg4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTE4MDYwOTEtNGU4My00YWIwLWJmZTYtZjExNTExMjU1\nMmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVC0hQYY66OMtfc4Y//bbzfAq\nYSzGK/p8JJetIniXCXSjATOJHdrzEJbNVdlKS4FeTi1IzH0udq/7B8OPq4+HjqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUX1gERHepCjOLhmbBHmxNTmAup8cwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG1HRpGgKbit71hn\nWFEn2+VwKE0/UPcvU9Q/uh/YItdwAiEA2s3RvZuWD+JeH0OMQFeAFsadFiNi6KYp\n+8hVfa5VMiw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4883", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4883` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZn56S+Z5wxJXdW8AO/v5twJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjNmY4NTUxLTBlZDUtNGFiYS04MmJlLTQzZTE4NmM3OGUxNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA2NDViMTgtM2M3\nNi00N2M4LTk3ZDEtZTEyNTkwZDY5NTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ/bUSHhaufGhUEmxvhumTb862Wwz1eLSUYAKg9krM0SEgQPTXZdoWItlexcL\nT2jGh9oaDVxg2RoUyPC5B+cwPKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZZQf4gfqYWq6rrWO+CqWQSvttqUwHwYDVR0j\nBBgwFoAUy6AI3eqZAfUWycplmkbWDEvGNOQwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQD8oiIXlX1J6P+wDRkTDazf19wslPfoOAKv+z89lrpOqQIgYbaw\n1Th42gSpwziyifGB3ASbioIdnuxyrWITOJTEHxU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaf9BaXYcIYCvdN9/1FYAfpzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzZmODU1MS0wZWQ1LTRhYmEtODJiZS00M2UxODZjNzhlMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDpahjSv1OUlNU6dC11GbWEKQpQisHTTfdqeRRVKiyJUnR\n7J91g0HefaK4knuvLfj7v68YY1M/rEstnCsfFHvpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy6AI3eqZAfUWycplmkbWDEvG\nNOQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgS3qq1VcgCnFblGRFcCKaSysfDrWDS36jcNOG9u8kTy8CIHBJuOVwmcEf\nEoi1ztKg3ZHwxVob/roeN/CWIiuejiJP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQtxOac+P8vqC/+maPaO0DPKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA2NDViMTgtM2M3Ni00N2M4LTk3ZDEtZTEyNTkwZDY5NTZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWJiNGFlYzQtMjk1YS00MDQ4LTk0YjEtMjNjYWVkN2Y0\nY2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVM8ntMkwLKvEAB/o0vNSJXI2\n8tCgj7csnssLedWbhyBfqaQymH2d7+E/k31sDe8elP1hbQWH9C5iXXc/2Ig16aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZZQf4gfqYWq6rrWO+CqWQSvttqUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCID9B2xlkPgJlcxPF\nxRKPU0psipnmjxdCHOX+qKKXEHyQAiEAztkOk9FQ284iXzSIYKU4ksNOqtlPlur6\nWb5J43kIYQE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4884", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4884` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAWWxmQNhJSIsBPKeUSeB4TJ9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0MjIzMjg2LTFhN2YtNDRhOS05OTIwLThjOTIxNjZkZDQ2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFkMzNjN2ItMmEy\nNy00MWU3LWI4MTMtYjdiMjZjYzlhZmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtVuXt2BWExE90LQNKUj08aWxP2w8gKJEdguK1GlUi613Y2jI4mi+93wrx8QD\nGW5VfOUnrnIYqzR5o6xKh/ijFaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4OYz5Jg3WeX5xRQOgWsF9AqAWAUwHwYDVR0j\nBBgwFoAU7//Juh5Tx6s0KH61QYtKXYEDQlIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIBrttbHArrAozad4As6EUpMOxvl3uGDfvbhhJ0fGrcKqAiA1IiFA\njlQELCc8i1vy8oV18Cn9oj2OK+t/L+FHLH0BIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYcJD6E17hTOtrdKWRxf+hNNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDIyMzI4Ni0xYTdmLTQ0YTktOTkyMC04YzkyMTY2ZGQ0NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtgEQKqk/cvzY8OnbTsd8axsaeibr2HMCqN5+Tz+nYW+Jl\nqwsamzjU2T9hfMzr9ktBixn1/NqnDeDQtJcxXJexo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7//Juh5Tx6s0KH61QYtKXYED\nQlIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPXgZOt9C8geEH6fK/vdx8iXeLqMFqSii8PectFe0ebeAiBBOIOS5bzq\nnfaWM6UK+uwuMzMVYBup2jK/6rTjC2kPTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAWLpPQsdjD+10Rxwnzs+w4pyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFkMzNjN2ItMmEyNy00MWU3LWI4MTMtYjdiMjZjYzlhZmY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmE3MGNmMDktNTFhOS00NDAzLTg0ODItZTJkOWM2ZDg1\nM2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyDlQXLD9bbJyicyJ0lzdRHso\nSAyX8B8Ig05wObvKKDZvt6blJnbKYFvE+Z0STU3e8JtmZDrEId2BeZXcDJ4EMKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4OYz5Jg3WeX5xRQOgWsF9AqAWAUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCYUIVaOKBZPzUl\nn0eXrXERYEmTiF7kWAX+a4AN2Y9oZAIhAMZC+WvLq9WmIoHksTPXA3B6rVm+1dm5\n+gRZ9UjJCc8M\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4885", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4885` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWmm+tjjbMrqmkQ5pEpCX7v4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1OGMwOTYzLWE2MDYtNGI1MS1hNzkwLTQwZDg3YzQwN2MzNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk2ZTBjY2MtOTVj\nYi00MDdiLWE5NmQtNTEzNGJmZTg0NzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcRMK+UObo2rxTktsIndj5crBslMwnv6h03R0ArGp5XX2ES2Z69GrV4IiNei/\nEib4dHO9mE8B3wxRrUGT7xGqYaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKE76PdqkfY3323G3dDIjdspP9XpMB8GA1UdIwQY\nMBaAFPLE+A40+2c1QZ0dTS2Z7nsXdMwIMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAgQnM03lVgAY0XSWoahPxDaMZWnOMuWIB\nzrUWw3xkMY8CICXi7GAMI3tR+/1cVdWEJnxILY/fNSFwVrNGwnzkjfWV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaeeUPxIgn5Vrr2qmXOqZCSQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNThjMDk2My1hNjA2LTRiNTEtYTc5MC00MGQ4N2M0MDdjMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARp8zg4/7IPUTn1u8Pdi5tJrkz/qfgvNYZCCZZ4mG9e3w9j\nGdBtitfB+NgO68vCbUlYsn/1URLikDgrlECyQYACo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8sT4DjT7ZzVBnR1NLZnuexd0\nzAgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPG9MciQu3jGUOwl9OgmXc+HFw3E8PBeoboQRqLXMzUpAiAiNawu990g\nf4DBJBy9m8RMsPtcYe8wB2DYEwmOFR/9Vg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAbnic5O+1tnGvt+EG5WR9B9tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk2ZTBjY2MtOTVjYi00MDdiLWE5NmQtNTEzNGJmZTg0NzlkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTM3NWY2NzAtMTQwOS00MGUyLWFhM2EtMDFiMWJiNDEz\nMzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQhgniSG0+zXz3ybP+nydFWDv\njRvn1RqBfMV5ruSGaows9XARoV1E1aT/J/03/wlG5BpEc3DSyGZEHc4zEzGnsaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoTvo92qR9jffbcbd0MiN2yk/1ekwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCk9PtuzJZZQisB\nLQJWSgU5nF4CyG33pjz2qZ+w7vTMxQIhAIC46vS3hWRB6D+uFMmLo5nahhWdD6bQ\nQI2qS9beFdF2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4886", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4886` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQ0PNNLDkjOZ7pte6uV5GBHgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhOTFjYWYyLTU0MjktNGY3MC05ZGVkLWYwYzc5M2I3NTM1NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFmNzA0MGMtYzJi\nYS00ZjZjLWEyZTktM2QyZmVkMDI3ZDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm2zC30n6T4K1cIYVrovnjxzBS9irkdpjnOT1HzOM71BnWgRGwI8UoGTsfxpY\nCs3qnC2CzmHC6PObgYrnDyNHQaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAhj4/jMfqJfMMbhpwP+yLE+xZ9QwHwYDVR0j\nBBgwFoAUKvNEr0WawACHwUR3WWqQitwnbTMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMnCfyJoAk7y\nGEQg0zs/T6ITPItC8fuExCeCUvJZt3j+AiAP3BDSpFDaqF8uteXd/wCylX7Zv1Vz\n1CVrvdPvOj+8EA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAQ9Ricl7TYmcOmrAtq4FdAfdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTkxY2FmMi01NDI5LTRmNzAtOWRlZC1mMGM3OTNiNzUzNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiiJKNLug1fELyC36zTi2HCC6+6Zv4NwFFP2rjw8eV5Ijh\nKADf267QEEfIkIUaoTbSj5lOqD3hl3ocVVIqSxs+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKvNEr0WawACHwUR3WWqQitwn\nbTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIfT1mw6tBcMDBQD6uxuLDBUSvtQdFYJSudB+afCswMrwIgOnu19BRL859+\nURawCC7yq8Vl1xnDnBIJYoEeFtGhAZU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAeQXnIyBldKFtyjD8Inyo/TzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFmNzA0MGMtYzJiYS00ZjZjLWEyZTktM2QyZmVkMDI3ZDViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmE0OTlkYmQtNGJlNC00OGI2LWEwYjAtMjIyZDVhYjEz\nZTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpm0RS/egJcL5doykaxG2AI7E\n7h5PUH2w+MpQT4HbJSFFgaXLvvdVtVdSD5Od/WrACjwEKTvjtv6RiRLhZdn0LqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAhj4/jMfqJfMMbhpwP+yLE+xZ9QwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCmLlqyev0RgRd+\nUqKZqRQ9PZK4lAfuWsoYEk7CJ+M11gIhAJ5/aSUOzcFgSPiaMz7zPHEA7rGukW0q\njc8+4zlPtR/j\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4887", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4887` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAXNTz68tBEOQi2Ggq0pr+RC+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0YTAzNjE1LWZmMmEtNDY5ZC04ZGY3LWY1ZWI3NTQ5ZmU2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTAzZTAzODktNDcw\nMC00NzA2LTk3NGMtNmYzYzIyNTYzYjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPVtrhQIfADdAFNieQBp4kx00iGtQ+JM59Psjllu4c/yD4logzCClV6nv7yWz\nCERcNE8uMh7fGAt3IlNoyDWwy6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7owj/Vnzmp9j/n6hxsVgDBg6oc4wHwYDVR0j\nBBgwFoAUsrXW5I9RQuZJmQuzWRJQLg6WPjwwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJvQDza6bJAf\nnwGm7U3s69bbz1kXO3WjbuGAClrgS2nuAiEA2QgInc28onBYolxUKlEPYkPiQxUR\nrYZr4mSBpoBYUyY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQauMx5yHbqSfAcrmKestwqJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGEwMzYxNS1mZjJhLTQ2OWQtOGRmNy1mNWViNzU0OWZlNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkXHmds5S91d/GlY2wb6nP/+WjGs+nFv+ZJnbmVMkhXZiM\nplBQfEsYXKZvnde0D2mcdtBLaKfJQzvGkXhQDkmWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsrXW5I9RQuZJmQuzWRJQLg6W\nPjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIQjXSteiwNEj8q9k9/q71Gf+JUQmoNpV7XfTkmo5jp3AiEAp8o0XjKW\ntXSEU79f5j80HNq5T4iVCj8zYcH+wnyLDcc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZm2HK25wZzRpIO+8rWBYekbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTAzZTAzODktNDcwMC00NzA2LTk3NGMtNmYzYzIyNTYzYjU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTZhZDM1ODgtMWU5Ny00M2Y2LTk4NTItMzNmNjM5OTkx\nNjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn4iJk0Z/PkLpDTka9mS/b8f0\nSSmor9WNLR7DYG8KzUuzOl2aye/UzhBoljXEYx+0rf8m9/RopkQnXXDCP6XWlKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7owj/Vnzmp9j/n6hxsVgDBg6oc4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDwf+FJq4UOtLszE\nFxW3g4Jw9+NSV/FvM2ILl96reoZ9AiB0XE4ZKe6wiBHV8eRVVW4hPDfEAiHdGEkN\n8tdg3LZhdQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4888", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4888` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAfgpXaNxGbLHGPHcXXvLdrLoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyN2Q3NDM0LWUzMDctNDMwNC04Mjk3LTkzMGYxODZmY2RiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIxYTZlZTMtYjBh\nYy00NGQwLWJlMjEtODE5NDk4MGIwMGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9sRTaEG1/HJm8H6HRWfUXr1sYpo/lKDqTH8qb6Vbz3wsLdNJ3Z8l3Ic6kHqK\n6beUXPFKJstVqjWGqgSfUKDUK6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUktd/SSue+FxXfcJgEZroxX9gaxMwHwYDVR0j\nBBgwFoAUK93oRwG0lRl2d31sx41SOAGZNVowKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD3NB5XT8qa\nZHJ+FIQ5e4WdhIBbxvCMvMOLOaQ0d2RnmQIhAMVN81d4JpFGpjZLRRxZMGZAliu8\nSAJPe1wpUsExeuVV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeYmkLiKIkOQx7nU/8O13gdBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjdkNzQzNC1lMzA3LTQzMDQtODI5Ny05MzBmMTg2ZmNkYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS73Gxy6BTX+gmPp5wK9nWxRe+VfuupfNoOGF0vYjXtuDku\nP7YrQeeJip1vyXo0oaShcqEGWorkDH65nIjsvuE6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK93oRwG0lRl2d31sx41SOAGZ\nNVowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALPyb2FBRFeJ3Bg4WbgcVa0CjVoHfu0gWdLe/CwRYUJsAiEA5Tw/bNnj\nNR6Kj+Vh2TWb5ExkYnu6GXaqgD2UzTEMmE4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAXIbVPcueZmLwnb4kt2rEvZxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIxYTZlZTMtYjBhYy00NGQwLWJlMjEtODE5NDk4MGIwMGVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWEyOTg3YWYtODQ3OS00MzA1LWEwMDMtZGU0NzA4ZTVj\nMGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXoZ6QzKGVL54o+81KhNkX2AR\nsxqwMzZdiWo3jIYpAzz7kC3IZpHURBpHdtCMU7QJQvGK/zdR+Gxg/tnffQkGKqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUktd/SSue+FxXfcJgEZroxX9gaxMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICZVwoDEV0R43SfV\n4qNw1779PtJm4qP2mwZyPCHSxWcTAiBlRrk4st70TindtPfLICj1pWth2vYXAwNl\nANF0tE3gmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4889", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4889` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAf2Df8Wh2SbYIpRQau/lGcaQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzZDBkMTFiLWRlYzAtNDI5Yy1iYjcxLWQwZjcyODkxNDRhYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjcwNjBlMjYtMDRi\nYS00YTFlLWIxMjUtNzE1N2FiYjdjMmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+PYzNTWahy/nc0qIEaX17bKuz8+UYjW7EpSNMS+YbK+V7Jnlxg5xPi7asGcd\nJcTEkhelkkIY46n2SL26SMeOtKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpHqD0B4TNcmQwzPIehW8QP3BHOEwHwYDVR0j\nBBgwFoAUJfFlqIdWPaIsQHeyi9q2RxPCIqYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCi7jj+ZjbGPb4EvUhEjRyN8+uRsUWnaBvoeTclV/7O9gIgRGWtu2uAg7Fn\nXbq+otuUYxlTlogBwkQBzW2LlFgJPLE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUKilFO+LlurPSo7eWsI4omyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2QwZDExYi1kZWMwLTQyOWMtYmI3MS1kMGY3Mjg5MTQ0YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBgP5p4vjcAQwD1WBN4FQf5vVqByBz/Re+4+A032yeViLS\ni0QqLBBVWAbD+CvXYwoM0q9Xp3I8CBf+fhWiXy4Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJfFlqIdWPaIsQHeyi9q2RxPC\nIqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIf2XdvqD5Zj4yHttxU4dB96WLaNtDxNYKD3uXmBaXWQCIFe89rTmkAfH\nbdBbRQ7Wmr0jp6kK5fi2t7uPZF/QWZBm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAXUKk4Zb7CgFFMzSlejffs/wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjcwNjBlMjYtMDRiYS00YTFlLWIxMjUtNzE1N2FiYjdjMmI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWQzZmNjNzMtZjIzNS00ZDhkLTgxZWMtODc0YjJmNjli\nMDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoFC6is4vmb36CnAs4VNF6aLn\npSEeEtqYbhJc7Y56nGfNLGgu40tjtjFK0WurYTaJ8P8cnBXbY48spXEdmvdzwKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpHqD0B4TNcmQwzPIehW8QP3BHOEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDdTuUtkFphiKin\nhA1xUvAEFQNS/H8DrRH3SuKD4kBRvgIhAITIbyfOpoCrFBjmbZE+x/rkZfB5tNTf\n9zBDoTDqfwrZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4890", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4890` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAWyJabN3a+z3TUa2ntQyV8dMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmZTRmNWYxLWE1ZjktNDk3YS04MjQ1LTRiMDI5MTVmYTRlZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGEzMDJjODYtYzhl\nYi00MWIzLWIwYjItMDY1MTY1MDA5OGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/wxoFkHKRACiaosSd7mr3o0cXCNdMtWhxz2xBXT6YZsIWSXJoFo9EKiWhWNI\nuHseAcFu38dtkhqDVQ+KpVKvs6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE07zSe5r3kzFASxaC7UdEPhtzH8wHwYDVR0j\nBBgwFoAUHxBRyOcl4EDGa4EWPzapq3yPKrcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC17ZrA6s9eRbmC60yYp9AwqFZUEILJ0FrbpsgBrebDpQIhANE5MXKUS0SQ\nVumbK6RVG8/TVYpOYX3EgbnZTjDOBiyb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYp3jyoKHL/dQNOEXipEGhdfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmU0ZjVmMS1hNWY5LTQ5N2EtODI0NS00YjAyOTE1ZmE0ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTS0ynMn1HzNI9PjsyMCayczIIGOnsyzR+FzQ0tgfJXRWJ\nFwk6iLlaDbZPNo+s1uIJZEo94XGppI9lg+cZNRPmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHxBRyOcl4EDGa4EWPzapq3yP\nKrcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN3/MOXd4cxhFsr8vjT4j/nWuwpHagSCKqq0X+EoA9OoAiAj2ldQb3ZK\nk1SPyDE8zhlYHStOV4NOuQmePFjWtMv0ZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAdtL60xa7GoXYE0F8lfPxvohMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGEzMDJjODYtYzhlYi00MWIzLWIwYjItMDY1MTY1MDA5OGIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTFmMDNiNTYtNjIzNS00MjNlLWJkMTktYzk5ZDY0MGUy\nMzViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+Q7Rxy8drQO6kZykrvq9HU53\n4G1IXNtUK5xY0MtCZZPzTxdTwUI+EUWw9s+aGDJYSIeRhzMzLhNrae8RBkNZgqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE07zSe5r3kzFASxaC7UdEPhtzH8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFP6e2c/HwfA+ZSw\nllRiAE3qJGLrYjBINydUR/rf3SX4AiBcO568RMWl2hIlKDsm8vHLD0SVes4wV/rb\n6s9wCT1gUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4891", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4891` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAY5toWIp/+5a5+b8tZVT1XKlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3MGU3Y2YwLTc3NmEtNDBhYi04ZWRjLTE5MDJkMjUwMGIyMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk0NWRlODgtOWIx\nMS00ZmRjLWEzYzgtN2U0ZGYxZWJjOTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9UmHhiS5Epdu9v8SfL/u1ZZF5+E6xJ2Of5gMNnyz7KNvociWYxuBRnWED8Bz\n0aSNznQGV7h+NdG5Js/64W+8pqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTCxI9Fee8j7j59qqm7NU0sdXMAcwHwYDVR0j\nBBgwFoAUozHWI0F2nEGcU3w30QfWtzkwDGUwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDJ5\nbX/Wyl4bYEwHLSEHT+PNL5irfMgYiGqyBVQNswndAiBxBU2Khc1d6Y0Uak80ZXEB\nku5pZaqYGWDMxBBPdUhmpQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATSEFhic5RPLNYFqvJox7vilMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzBlN2NmMC03NzZhLTQwYWItOGVkYy0xOTAyZDI1MDBiMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGMhiTUPYhTsARki/IFGBFLUL9NVYmFJJeySqkmDYeuj6Z\ntExjPTHMyvBM+ibWiGDU4FbanKyGmFIDdgo/HMM1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUozHWI0F2nEGcU3w30QfWtzkw\nDGUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQdP2lAECJVQ2mm2Dtr9yG+y0je7t4CkHO2qHP+fI86gCIQDNcD489loz\np0Jq4bmCgqt5s/fwM/0PVPBDuLfKDQFSBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAUmAtsGA9PM+8Pi4qG7kM8iMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk0NWRlODgtOWIxMS00ZmRjLWEzYzgtN2U0ZGYxZWJjOTUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDhhYjc2ZDItNzk2ZS00MDk3LWExY2MtMzE5YTk0NjZj\nYzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5goW/7c1XBYvDguryJ2kIkNB\nOa7AdbmyHow73mqPkGmFDJMkdVnydhgfR8wXcLVVjUxmq+jYBFv3wgbXCHBVnqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTCxI9Fee8j7j59qqm7NU0sdXMAcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICFISx8CYGidx+7w\njFH2KW2e2N0OvSGpZkDelgfFY8fQAiEA4HMXR7MLNaagwf90QeLayK8mrJWQTYPA\noWC8a/ieG/s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4892", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4892` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAQn0C7DPt7cmztHeDYiD+LgDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ZTc3NWRjLWM4MzUtNDJkZC1hZDc0LTZlNjU5YzkwZmMxNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M3YmVjNTMtODlj\nMy00OTM5LThhMjktZjc1Y2ExZjFlODA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJjKOEInaGo3l1lQpSx3DMlVa0gqw9615bvlTzPCPjdK+Xzef1qgyTfed62Zg\nbWi4eyiheeLaVkYoTSU/XAG2J6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtCbQ/ouG2xA0cFbiPSpMVN/FnqIwHwYDVR0j\nBBgwFoAUVe97onuoL6Fxe0BaAGncHaqVKbswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC4eZyjO8XGL7gu1r46b2XXyLK4pQoZH4Uz/zOK37AurgIhAKJb\nD6qnJGCG1RhyVvE+Y5f0v4WjhZSTKvQg5UjAfsZg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASt3HVe6tx9+USqyTHkD7G6lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGU3NzVkYy1jODM1LTQyZGQtYWQ3NC02ZTY1OWM5MGZjMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmmwqT7ZhV4dxJXTqb/r5gogh5ERni4AfULIz8tfeHl8JF\nV6hke/GFluAno7hGJJXNaX3O+8LIEePc0kErAy1Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVe97onuoL6Fxe0BaAGncHaqV\nKbswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVrwP0cksODhhxZX0kTq37ou/uDCc2XG2IozQsHgNGzICIQCJylcyPTmk\n/WRr8YeYFIcULMBPOIES/4lQxyqeMJ0ZkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYhCMO3JxvyisxBeAv8+sZGvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M3YmVjNTMtODljMy00OTM5LThhMjktZjc1Y2ExZjFlODA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDE3OTZmZWMtZTY4Zi00MjAzLThhNjItOTQ1MzE5NmUy\nN2UyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtHugo3rUBOEDkWJfntBfQlEx\nSIKgls/SGMQJoIie5aNGb4gYoPUTv5ZrzIKg/qc3GLyUjjkJc3YMpl/ozXEIVqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtCbQ/ouG2xA0cFbiPSpMVN/FnqIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICStBw2pyiojEG7m\nolS9SDBMLzysESOMGVytdrA3JhmAAiBHTF6GgcWRd+NT70We698/LZCrEiYyBjQI\nTB9iDS/AdA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4893", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4893` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAXkzx5wY2fZkjnoXPcZkKvgdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNDM1YTNhLWRhNmItNDZjMC1iNTUxLWI0ZjI0YThhODI4NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzI4OWFmN2YtZGE0\nMC00YThmLThlZWYtNDIwNzJiNTc4MTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhWN85AnbuaCCMAY30XHrjy0ClHy4Cz6UgVniWx+/XzoOsWGervhvPgcAYSNx\nA+qEmtlMEZuJZSzc4mocr+9g3aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmzMSpwP2rsb+TAeo62bJC3EgDYwHwYDVR0j\nBBgwFoAU+EObPjYHkJXxaFGkjncR2snzmokwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIAov4+n7U5ipy8YKxAmT0SI+vJwgKhotl/FUEC2wNJi9AiB7Oo37\nHcyEU4Jg97g1DRNbsUGMgNNdJXGP+fDs+SAbaA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbjQYh8vnBDJ0GBKOy3NqkwxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTQzNWEzYS1kYTZiLTQ2YzAtYjU1MS1iNGYyNGE4YTgyODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0fY1zjl4uC2y+Rf2scajgrlCbH8pCTWm4XnDdgZHpbhvM\nIew38CrNKZOu+ltY6E3lwFAghu96QupBIftR8fUTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+EObPjYHkJXxaFGkjncR2snz\nmokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMdWRzqiGUdFk7iwsPWvB4oxKgl2u542im+CwD94HVZoAiAJdx5L0uLY\n05Ufw1DlyZk/bvX+dGQgOPhN66iCDXQa3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAfkiwi+YK7WBOrKh51M4w5ppMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzI4OWFmN2YtZGE0MC00YThmLThlZWYtNDIwNzJiNTc4MTVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjQ4YzQ2MjMtYzIxYy00ZWFiLWEzMGQtZWU3ZjBkMTU4\nZTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjIgHg6wY5DtG9SSAresYxG8E\nVeBW1W+bveWpwl5AUhsQhh2HXrILw5u9l8dMaAhiSjyPK4XEw9/pCPVD1inQDqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhmzMSpwP2rsb+TAeo62bJC3EgDYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEYTE9lCOrVBZiWs\npOdbfPf/HlPZC8XOLihD6nD6R4+SAiApB09GBof0xh88vdZkRbTFgyvu+STskhw3\nqP7/Cud8rQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4894", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4894` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYTPYUAe6Bp8Rjs4mtjd4pa/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzNWRlNzU3LWViZWYtNDExYS04N2E2LWVlZmE1YzdjOGRiYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQzYmNmMGMtMjQ2\nMy00YTg0LWI1MzktMGVlYWNhYzA5MjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENGR9LquibAqCtZVTKVMlatq6/LXVCRyhVSx5Xsr0+LO3WRfRb4WPGT+vxzRt\nc/KVlTym0SDfAdAT/4zXyAvfSqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTj2eUcDCSDT7Al0Q4ZGeiWBzIO2TAfBgNVHSME\nGDAWgBR3iUz6h9pIodXKaajqj8n3QYIczDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHuRenrL8LaUBtQB4abURs5kr0T6noCY\nWGIKz8o/D7BDAiEA2K7vep9GdqnqU72yVvcBtz50BxohtcDpXbVgE01bSf4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATPBEr5sf1lX+WyMt09ipJsEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzVkZTc1Ny1lYmVmLTQxMWEtODdhNi1lZWZhNWM3YzhkYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7HgmRAVxTS0gM7MYCZrkvPVmllUU3ETGjbnhv9tqIYCmE\nHo9tstnGeiY/sA6voq85jozAmup+BlD8Sxk9DKVdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd4lM+ofaSKHVymmo6o/J90GC\nHMwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMAc3UXQeaEPkhxJ6eXm/pfHwpjl6nnsxcDGl7mGenncAiEAuXl1yJCf\nOroCVA8hkGyBbFH9u5IJikIdXKQlRQQ3bZk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAfrCos3uRYJ/ON45IhGxU7DHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQzYmNmMGMtMjQ2My00YTg0LWI1MzktMGVlYWNhYzA5MjVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmM0NGVlYjItY2FkYi00NTgzLWFmYTktNWI5ZWFlYTUx\nYzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKqjtW8XgWOVbgpbXaL6kryIY\ndBd0hhBQDLYkEv7sQmi9jPg6yyu7VcCyJDdx60977HDSAb5DNc8YoVQ+jpgR0qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU49nlHAwkg0+wJdEOGRnolgcyDtkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC00Hv1rYN5N6LW\nZCh7Yg1HHdkBd/9OIM5PeJqFz/xIlAIhAM7zsj5fS5mR6mKBYL8aD8F6Pa42etyV\nzLZUrjlXxApm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4895", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4895` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAaTx/aUORKNkF0mB0i72YvFhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiNTgxY2QyLTNmZmMtNDE0My1iMTE2LTRkOGU3OTUwOTYzMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzcyMWFhMjAtMTJi\nYi00MTUzLThjMDQtNzI3N2Y3ZjExNWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnTu5ZLD2Pd4uzMXkNoVE6M90YUhCf81gX0vczgL/cSZ3f2zWzM5SgvqNCLDf\nSRmbU657oG2SiSAxJmXAixGHY6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+141PigIoyK717XsFfWJQwDqlgAwHwYDVR0j\nBBgwFoAU7YlG83wARDs7Z/x+56sIUo6kEOEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBU5cZFOuDaB\nDMlil0X7DNjrH7yrRT9p06yE3bD7154CAiAYvn81Nu124Ta5uyfqpgbDJHve94jD\nI07eQCV7foYHpw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUXX5Y4gcpB8Nn/IMWDoez8YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjU4MWNkMi0zZmZjLTQxNDMtYjExNi00ZDhlNzk1MDk2MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKGNi1YqqMvhULvi2kq28Bt6MORpc0S22y9YsJeD/e/BVx\nNtf6ee2KnjAGXGEJHUG89RxvRAUDRLtBopgtst5zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7YlG83wARDs7Z/x+56sIUo6k\nEOEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKiyw9zsN0wZHsu5bmZbjEKxPVlc9/Ee9KIfHr6ol8lHAiEAlhHgbHSw\nGHgd+dA2Ai222+ojl2Z0d5p3WOGDdVpc4Wo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISATnjzHKWuhyQ7V5vWk8+CHm+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzcyMWFhMjAtMTJiYi00MTUzLThjMDQtNzI3N2Y3ZjExNWI1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjUxMDE3YjgtODIxYS00YjBmLWEzOWUtMmM4ZGIxMGFl\nNzcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExR2VFlhlkp+WoN0Ayy03mrcD\nT1UG4mLUkM+x6vjlOrgS94VJdAAMfZWCnqZOdVHeumQyCY7Tg4Abc3t3IrPzu6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+141PigIoyK717XsFfWJQwDqlgAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAgj2a9v3UtWsCHX\nRTYi/SSfPGVqGaDXlzaNCDh+Z4slAiB0faT9yVKN7k9YWjsApphtDBbASxf3v/Yp\nt4gKU5+mFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4896", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4896` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAZnEp2bCBmmkoSDIrRIYJUvsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4YzdhY2Y5LWMzNTEtNDM3OS1iODQ5LTJjZDZmMjMxZDA1MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA2M2UyNzMtOTk5\nNC00MDllLWEzNDMtZTYwMjMxODBkMmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPYxzc/8nFfEOg7PVceOkScQBTzmumiGUaqJZbdQ/7axjqKeO+7n1Q9YCWtmo\nQTdWKdH7HiSINTK4/UoIzwwO4aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgg0hzuiXNzTMdAFDjyebc8Z1K84wHwYDVR0j\nBBgwFoAUA7+W8L1/q6uEd2+gEii1gMkaV+AwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDoD+ttnLcy\nCp4l+GhS0/3uXKz3k0cnAMjHXxANVhjryQIhAJTjgYoBVwaGVXCO3OsjzXFS7FIj\n95LPZWA1kkAgodO8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeHFgrVwOG39jSEGJjlf5CZHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGM3YWNmOS1jMzUxLTQzNzktYjg0OS0yY2Q2ZjIzMWQwNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgm9VRK2rVJn4favbEQGsXBWpuPyWsotO3raCY7z6wL6Bq\nBicqBoB7jbb88zA5cYWi09MUnnV7G2Y5txkhrxnvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA7+W8L1/q6uEd2+gEii1gMka\nV+AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfSD+W3KQwuYpEn7RyG/4atE876r/Z858Ttyg2EiKw7ACIFoylG9VEa8u\npeJ2R65h61AWljArmeslu5mJVJvZ8rmV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAcWuv+cuYhVc4HS8N0wQgsQEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA2M2UyNzMtOTk5NC00MDllLWEzNDMtZTYwMjMxODBkMmFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzViZTk1ZDgtMTAxOS00OTg5LWIwMzQtYTQ4OTdlNmRm\nYTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgMpZgR0TyIFjJJscPy82Dphi\nB6n9YKx6UbLKLv1mrpy5EUM+568RFIlvBPxN9ja29D+o31k7i1HMTl/7poY0jaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgg0hzuiXNzTMdAFDjyebc8Z1K84wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC2sop7RMv3Q2Sq\nReWVR16GMrEue8Ui6M9BG3MBg6CYygIgJYZ2b2xCdsV2qoAJKqj/KrKB7skj1rgs\nyewkOEsgtoU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4897", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4897` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAWtREYg7yz0xwIfwa7sf8M6hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyNWE1OTJkLWZkNjEtNGIzYS05MjZmLTA3ODJlNjQwNjA3ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFhY2YyYTUtYzI0\nMS00NjBhLWE5MjQtYjZlMTkwZTE4NmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeN+wwKzGp5VoNOzFLXHY2gz77fctvKcbKvv1j4qQcP314+QEl1E85x2x8pz7\nuZtUIk2cqy2l0s7RsaaaWDK3uaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwBi5Zz/trp/vLmlv17BGZnQpWjEwHwYDVR0j\nBBgwFoAUbX+KWNYn5ubEweFql6/wIyrVHvcwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBtmMEdQ01g\nD4KzNNug9HY/kip80oDVLTJGE6EFf8ankgIhALvI0QG87BV/GEMFI7n/xx1NeHk2\ngm1GrxJsPxv+mZer\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZngvO18yRHrw/g77adMjJT0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjVhNTkyZC1mZDYxLTRiM2EtOTI2Zi0wNzgyZTY0MDYwN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARo93yhWPrNQiDm5P9NATRrG34hYBf8b0Em2WUXYwNPgtlU\nGuM/IhGXuLYwcAezatRh6GoCbPNoNf7p2orE9KoKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbX+KWNYn5ubEweFql6/wIyrV\nHvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALnPanRIFpqFNz3QR7dlvrr3p0tdrA15DbRIXdOIWIFyAiBjOKWWSuW5\nYpiaDsFKUxmecpu0sBKjPnCTzjik6fUGDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAaWK8JEfKBG8WRK7UIbnuw+JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFhY2YyYTUtYzI0MS00NjBhLWE5MjQtYjZlMTkwZTE4NmEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTc5ZWM2YjctNzIyNi00ZTRhLWE3MjktMzZkZGMyNzI2\nMzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyhlazvYoKqluT8kIBjnk0Wcu\nsWWBX+uaCajX9EXhSkA2MwEZPrcFsOUyMRT4yD+VL7lbM8Ci5uHbV66rVajfsaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwBi5Zz/trp/vLmlv17BGZnQpWjEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCG6dMdla0aUEgx\nov91/1KzSj+gNefIun4C53/LDw4AwAIgUGndCR5heG8Nx0rNnjVmI3FvB9P1qGLu\nBNCVFo8Mt5k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4898", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4898` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASMSz3zPslgENN2hpu9fXONMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0ODkzNmY2LTljMWYtNGU2My05M2JhLWQ4NzA3Nzk3ODczODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTUxY2RlZjAtYjlk\nYi00ZjQwLWFhMzItNzk2ZGU2MjBjYTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1DEqal6EVi0xvVRkzluFrmTAgybrR7VOzXMu8nj1k79zBA+bURey2HB6IWVU\nTOGGoPcbgZvpzFXC2r/r/JgcZ6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWAEiEYa2QHp6v3Vg/UAV6EeJTWEwHwYDVR0j\nBBgwFoAUV13wMIqUt0UEDNOjyHp5rzqjqnQwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiA7WvXX1PBpl247mPOG7DNVsthzntYV5CbTRIz7saV+fQIhANCszY7i485F\nYyumeP3TDEH48KjLikE8pj6FKbyBYW4W\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe0KgYE57fcVDDbbEfAi1Y6TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDg5MzZmNi05YzFmLTRlNjMtOTNiYS1kODcwNzc5Nzg3MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJsj1UlTxCp92vCU/BtoJ6RY3dBAOGBC49OARqXBgUekEv\nxjgW1pNuIlJHIdBncNG4hi37rcm0OLFszp0h9JBpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV13wMIqUt0UEDNOjyHp5rzqj\nqnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWsjCK7XQMcDk1MOKJOcmoztN7QuuW/yWMHs6IKe6rqwCIQDEd4pJG2pm\nyMS2Ovn+0KEwnzQGqCs2ynNI5aBNgy7sbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZMQ+45tR2JDCF7LxA+1JnJnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTUxY2RlZjAtYjlkYi00ZjQwLWFhMzItNzk2ZGU2MjBjYTg1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjY3NTA0ZjMtMGNmNi00YjAzLThlMTQtOWIzYmEyMDQw\nZWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyAVDK1F+mb0roaJ6oXrueMgD\ncKv/lFnP3D6I6lMOZUGUozk8jro5ebZSc+m39TOWi8+zAPGDD1cnsFejai4BuaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWAEiEYa2QHp6v3Vg/UAV6EeJTWEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBmBz/3iXmhNEXhY\nRmy9HDJcBDD3HdqFmOopdJ7rHpaYAiAcNwYnGZt+pr4lYUlDI0cC/nVewIEiYyAs\ntLyzRHx9ow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4899", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4899` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAcsFmo8k6y7uA5sHbGo79wJdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNWFjODU3LTBlMzMtNDhhMC05YTRmLTA3Y2Y0M2ZhZGFiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmViMzkxOGItOGQw\nOC00MzQwLTgxOWUtM2VhMTU3YWExMzRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEizxht/adzgkEcXZRBIrLnb3RfwIxoNWiPAn/4KFYzOlbYtyUGUNtRbU066lZ\nqY6txsAUQZDvLsdD5aISuY1QT6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv6RXliyfFFRR4VfbyUpUB8SL7+YwHwYDVR0j\nBBgwFoAUPILp3c5WzPYmTYHmjNY8i2ZeuhcwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAyrRyaq/dMHlTzKcpReXTJfV+TVYkjwGXOw29/YznacQIgCBMGladVAgXW\nIAuq7Q400tA4SWhdSoQvug1w7PzK7Bk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARn2VZm0SLnwVk3tm/BkKhtFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTVhYzg1Ny0wZTMzLTQ4YTAtOWE0Zi0wN2NmNDNmYWRhYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoo0ZCKo5Qbzo0TSYurrVUSQuqZFAuXYwVgwa53zrjG6L2\ndQb8/IsJzzT2QF5A0YPz3qZcRMVPq/NA8U5QTKHLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPILp3c5WzPYmTYHmjNY8i2Ze\nuhcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOjFwJYVP7kGTu20fXdtgvwXH/G9CP/bME+5Y6uxHPoICIQC7NLXn/TvH\nyMA7g3hgjVfnNohfhGrYbQfwOwb4ITZ+Nw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAY2aHzX3kRaNNcEwbiPmsUtHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmViMzkxOGItOGQwOC00MzQwLTgxOWUtM2VhMTU3YWExMzRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDhjN2IyMzMtNGU3My00MWFmLWE3NzUtMzhjNWU4MWZj\nZjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE612X9ZqShAiy3g5pCOhkFnW0\nXbUnSex7AEJKkMJWobxccVl4Za6q0tY6rlIrZOqwqFQ8fjkM5gUgiFliurxyFaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUv6RXliyfFFRR4VfbyUpUB8SL7+YwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCwGmuhBl197U+/\n7VYyuK+BGrSzC7dqdoZSzYB9qrgG1AIgM8Tr/aPg3NwnsiTa9h1+ek0lTxWJsJ6R\nZY3rqswcBn8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4900", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4900` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAWnAbiAep+264aUkARJ2R2ovMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzYTRkNDZiLTMwMTktNDkxOS04NzZmLTQxZDVhNzA2YjYwMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI5MzhmNWQtZDJm\nZS00NTA0LWE1ODQtYjAxZWI1ODhkNGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI0L+m7jH3GkJXJsD5YsZ49e3XjkqIstjoMLXa/dDufjppFWsF+ulh6Dp846j\nisvObm8GDcYyJPE8HItS6qoURqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSQHhBFhMpNwTWvfEInLSk9IIbFcwHwYDVR0j\nBBgwFoAUlPwZz9gMyMaUTh7QUSXkHfPFqmkwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAF\nRi/R5/sc7ysQHJ0yy3tjtMywrPqfi1U5APGUj+3tXgIgVUR3D6R2szfEB+oM07m5\nf/gz+4JqMbt/trudMaTF3vA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU1fusydONn7f01Em4ryTPASMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2E0ZDQ2Yi0zMDE5LTQ5MTktODc2Zi00MWQ1YTcwNmI2MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToloRNwkRDFI6RToumWf2P+TRBHcVFEijAY8t4o31D4lXj\njPcw1IiaWVVcfARdUMAcT7yK7gJwdgax5tPSYhKno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlPwZz9gMyMaUTh7QUSXkHfPF\nqmkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU0+sZ28Uthw5/9bLYQHXe2bhEHv+dBDtBRbWyaJNIW4CIEiaIuO7ccBD\nHm5dloubZxiU/7ZhKjhwjg+3MFqKez7N\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISATlWGwhje0EKtCYCMpUAsdvLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI5MzhmNWQtZDJmZS00NTA0LWE1ODQtYjAxZWI1ODhkNGJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWJiNzM4ODQtZjk2OS00YzFlLTkyYjgtOTNiMWYwZWMx\nNDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvmONGyJ4ZXq1vTjghwfOndFa\nGXYQtciPFD+f9d7Q2kc/kWkYFR5H9r/ShgohCLxGMDK48SmPhxF2qeMuZ8QXyKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSQHhBFhMpNwTWvfEInLSk9IIbFcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDrOVL2J9/xMUk2\nHVL3hXVxPI54f48a5lDaP+YkOqdGzwIhAJ4dYo3jANOeivLfaM+aZfgdI6GtK6G+\nVPGha5UJLFI4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4901", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4901` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISATwDYB3AS038n3fXkuo1FhXXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhOTg2ZDNmLTdkZGEtNGE3Yi1hN2FlLTJiMWIyZGFkOTM5YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg4MzRhMjUtZGVl\nZC00MmRkLTg5MTAtZTFlMTg4OWE5ZWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqdoy78s7Q+4gL074Mu14gdBb0vBUgTWi2NNnc4xOibL+fOQELdeGu92nWmlq\nCVvBGDPWrDRwfjpbsNHfw6hG76OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZnNQFiVeUPTPX1ukp6FPs4itwcwwHwYDVR0j\nBBgwFoAUFLdQQsJnquSY2RUj//f/MGf/krEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiA2vshgyMvtflpIstSWcOvpTdjW3ynCTt9ZlBylSNKwJwIgW2So\nwtEJFsOh8s3pVKSN+SPNFAP+mbR4CNd29iXEHWI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfuN5mTdQ+I8MNcC5nuxCtyRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTk4NmQzZi03ZGRhLTRhN2ItYTdhZS0yYjFiMmRhZDkzOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEtlMdYLqhLqoWUVIYolyx3gxAhom+rhSX8fx1D88upOk0\nDqpRM4MmJaWwLU69OKeMmNseAmR1xUZnmbXFrJu7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFLdQQsJnquSY2RUj//f/MGf/\nkrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMN/VEb5xEBlMva8s/dRB52fRRn8+B8sFAnRoAHdSYBvAiEAn9U4dSHz\neuxLYshQ2DOgDu/BAvfN0DDddADIC1K3LJM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAb5XV9On9yd6IET1SYaUkeSWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg4MzRhMjUtZGVlZC00MmRkLTg5MTAtZTFlMTg4OWE5ZWMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmMwY2I3NzAtOGQzNy00NDdhLTlmMWEtMzg5OTEwNjE0\nMmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfeSlvElPo/FSKkkpDz3pVFuB\n9EO9qc1BEqbvnm/Iy0vN+wWQye6lL6/leyafNLSH0K3VvAPvKWnGPWn9VEVQ7aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZnNQFiVeUPTPX1ukp6FPs4itwcwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC+6czyAOmU7Ma/\nVk28pQ4O1DhEPK1DdxsrOBlEgZkLswIgGzirKSGUHIDSSdYf935ZfxRthxjG1UMt\nIP8Ll5fwP+o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4902", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4902` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAUka9O3cUbq77l5qHXVPCCBbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExNzc4YTBmLTBiZmYtNGZkOC1hMjZiLTcxZDYzNDMzZmE0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRlZTVmOGUtOWEy\nNS00YzI5LWI4MTYtYjIwZWNhODlhYzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaVrF/QQjPV8dbw/GK5CNZ1Kri1N69aD/V2GdH2vv/5d8R4UCBX8E9QCe7pyP\nKFSfaHRwjdIkZaacOmHqUi1EEqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB3BE9/WkDvaS5SSisVHsX6LvsxAwHwYDVR0j\nBBgwFoAUz8M8hz4p/KYIZKaavyfo57Ta5xwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA0jYqNbSIJ/jN+fwCPI0/mFx9r84X3PC7V/OvzuTFbnwCIAQQ\npkd5MOkm7B6BkzlBLNTF7pv4pM4jYtetUEKCQvaL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATto2ZOPHpRz819GLQ5VbhwGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTc3OGEwZi0wYmZmLTRmZDgtYTI2Yi03MWQ2MzQzM2ZhNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKp26ZmChSKU09w9c7+gWbBw3iAX7bJW7zuo0zd/soZOWf\nA/Btn+hAHdaS69pZwBPOUVCJCLGRR3M9qseQOmRDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz8M8hz4p/KYIZKaavyfo57Ta\n5xwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWOmK1rpN5N3ujC6fAKnJhZkyCNldhdwJXm+eIEez/loCIHkZcPrtfwvd\nHnHv+/2wQnDrIpJwJrEF2LyW9hLwRHze\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZ5/k5U/up7r//7iC1JGHuzTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRlZTVmOGUtOWEyNS00YzI5LWI4MTYtYjIwZWNhODlhYzVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTFmNDRjMjEtOGVkMi00OTY0LTlkMjEtMmQzMGU0MjVl\nZmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEluncPV3qBHxDcgt+GPld1P/S\n7UT9mjByYDC+i3EeO31u9iI8SkPVNvX6X+hB8I7WlM7yrQDUiX/QdSOddccze6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUB3BE9/WkDvaS5SSisVHsX6LvsxAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEDuNV4F/06ubWtC\nMRpD/5+UbL4qdvXKLtksSWik65MzAiBw85SkUaZIzkc/86q3hQjHfOuoerw6zLs4\nuBDKagTdVQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4903", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4903` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAS4OwBPW3hP55pWktzYAanaTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmOGViMjJiLWExMDEtNDljZS04YmFiLWMzNzQ5YmMxZGE2NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJmOGUzYjgtMWQ3\nYi00NzA5LWI4ZDUtYjUyYzcyODA1ODA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmEhnJhFDUn8UFWFOPO9UC/s+YBEbJjxcvmrU2gSQdM7HTQg2aQNob2mO/p81\nhdFU0YOtlS5F0f4sCoMdbO+vk6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjb5e5LALKzv8j7wXmtdqjCcyy3AwHwYDVR0j\nBBgwFoAUC3OXGK0eoaeUvn6CPsg3ahFwpDkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAjen/D6wLikEUr\n1M1NyM1G138nwNNWzlNE6rSTbifuxwIgYkBBViJChmoYKc7mdHpQR6BFqqfOfYns\nuMSW6MMxuSU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVMV10F3jBbHXlDSMQikjFJuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjhlYjIyYi1hMTAxLTQ5Y2UtOGJhYi1jMzc0OWJjMWRhNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqHaE/tsxuPXe21wWywKpb3cQALHu1ta9y+3rDozJvMmN9\n20Sc0MeXq/PbPkY44zfUdyzIZNv3RDAC7d09Tn9co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC3OXGK0eoaeUvn6CPsg3ahFw\npDkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJHJQ0Cus3kghlVgu8lMXe937YlcpaIeh+S4bDboV/XpAiAz1QdxkN2U\nEPmQjESDYLc5xvqY87bc9atMyIEQm31Qvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISARARmUii9ywje+SF2JcRZN98MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJmOGUzYjgtMWQ3Yi00NzA5LWI4ZDUtYjUyYzcyODA1ODA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQ2OTVjM2QtYzEwNS00NmU2LTlkYTgtNTcxOWMyNTU3\nZWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/eaGJeqZso19rJhsMepQ8DOb\nWH245ilNXPb5aiFxZbWu6L4RH6fyI7XSWkV8UK3jGQMF0xz9tJx3y2opsX4dRaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjb5e5LALKzv8j7wXmtdqjCcyy3AwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC1GfOfBxE+mKGG\nIazm0IsbXwOdTkIbuSj0W3Nmw4mZ7gIhAKRRl5SxqHo5tR6tMIShDWF1fNPKBaAF\ncAr+FddF29aO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4904", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4904` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAaWi70s/WAOFT128f8/isM5TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2NDNhODc4LTEzNDAtNDBmNy05NzkwLWY5YTAxYTY4MmM1NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RlMzY4M2YtYzE0\nYi00MzYzLTgyMjMtNzgyMTgyYmQ1OWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0yTCy659XBeZhSY8GZhq90IWBH1lSSkLxuPcts451ohINaIgy97sEhQEXaLM\nMmD2eu4C3aIVf5CfmVFhRNcV8qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeieXNzz0mgqUlCn13hNY2x6Cup0wHwYDVR0j\nBBgwFoAU8p0toPD7AFBATm2Klf5Iz3FYF5YwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCKk+ynlLCwacwGnJCrW9tW8+ahS2bvEYUt69BRrEb+RQIhAPaG7jq+NNIK\nNK7efuzMBCkvjDvTQS7aD4fDFTkRQCRR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQdpR6CPxhOWQd23gJjUOh4HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjQzYTg3OC0xMzQwLTQwZjctOTc5MC1mOWEwMWE2ODJjNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRHxgehJyYEKDLGbjzNOoaEKAihRSBAWAFdnT5BISaESde\nd1dQxUVTprU5NdblRmD8wU+yn38EZ3Uo2O2MZaSxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8p0toPD7AFBATm2Klf5Iz3FY\nF5YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDnNhBSSa1qzuDz3k7R9MRC+a3DYlVkVMZgHGEC7/OcACIQCqCjlAJOPX\ndaH+oIMuo2uIGtwNlkXKVUW7PWa4x/oBpg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAcKp54ebUiCUswadDCp3ojUsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RlMzY4M2YtYzE0Yi00MzYzLTgyMjMtNzgyMTgyYmQ1OWI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWFiMWJiZjUtZDQ1Ny00Njg4LTgyYmItY2UyNGNhMmJm\nN2JhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5hdd6kRtbzQLX9S8uc5/65v2\ndHL4xbpCO61XTP+Z3Uyx9VBTaBmN8wYiW5nT3LUiKc/ejzw1vdg0oaB1jV41LaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeieXNzz0mgqUlCn13hNY2x6Cup0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDJxLiIcGdnAEztJ\nLftYOBo4BAu0T3RtLutjXE/We1TaAiA3x7nWAkeI29znJI5nSqOvDLOsMbI0pbVL\nJLzLhTmJkw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4905", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4905` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZInoCiwwpzW51bhVBBg5E17MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmYzE0MTMzLTk3NjUtNDA4Zi1iMTNmLTRjMmEzNTI5MGQ4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMxZjY4NzUtY2Uz\nOC00NTZiLWIyNWQtYjkwMTc1YjMwNTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES1okIxsnbXgH5dy07m0GxEhC8n6TbbtTHlR66kf0k+RLmx5Xw7dyKa5+7OF3\n8AJVYHBl0We8h+JE6GtgWpplz6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAtoJGxN8ZU9pwXOkfntGi4ttnAgwHwYDVR0j\nBBgwFoAUJIAphqcga7Tw+5pUWrBWGuhoEkAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDgmUXPxjizaDs9y6kuwVcQO/QcRMu0GUlo5zBbIlLizAiEA0nA5geeeITQV\nKqaX+jlcQrs3nEVrtMcdz40zSvQ3X6s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATi6dcwP4dxVmRJAEYZyF7twMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZmMxNDEzMy05NzY1LTQwOGYtYjEzZi00YzJhMzUyOTBkOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPFGAJM2q/IxWCSpDktugQaFEZxAvyzSqsaQ1IZULz+JYB\nAdORKb7/hLM4JGrsqUWMaZC23+mjP4G2HRWEayt2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJIAphqcga7Tw+5pUWrBWGuho\nEkAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKCv53BlfuYEcNgBLDxFb30/sHJPxCC6xKwVGk1gExWfAiEA6AJkSD0h\ns9q6Zg3vOOuv46My7eVBmxOIFpk1P4NhtTw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZm2aZlrnW5AKbYWjLxAiKKsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMxZjY4NzUtY2UzOC00NTZiLWIyNWQtYjkwMTc1YjMwNTQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjg5ZWE5ZjctNzhkMy00Y2NlLTg4MmYtMDAwZWZjMzMy\nOTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZCFrLC4RKnvijTpzG8PwQvV7\nDitjPpycAFOB1k1BgvtmrGOyq7RhMtMhlAJ3knr1LGyipITpJRZmK3n2IajeWaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAtoJGxN8ZU9pwXOkfntGi4ttnAgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHo57PfAB7xxPPNq\noClcnb1G9cS+mGfnz/VBtFgbaOEGAiAG2XCj1clotwyjixeLcLNOW1pKsHGN5DmQ\nwEkCnxH7Sg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4906", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4906` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAWzfzoBG/zoLjjNqokLGBtr+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0YzgwNDA1LWU4YTEtNDE2YS04NzA2LWVjYzE1MWYxMTIyMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA2NzM4NGItYTMy\nNC00YmJkLWI3ZTMtNjJmZTIyNzdkOTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYCRDb9BQ4Rjmp6u5E23wWxRKSQaD5o/U4gMj2haI6NDJmnel9/48Sh4GNG/k\nGchboI6CI8hFjf9XPYwM25T/c6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGrTkAmC809TkpEeLr5066nddITowHwYDVR0j\nBBgwFoAUpaphG6q+YZfyM0J9Q/xpQSj8ToUwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBhhMREgDcyZK1o4NBQqT0RKpLH32kTBg+RWlXIR4fgsQIgbtCyOZe5iYUN\nr8sr4miLmF2L11raREOyBtx8mbcIqik=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWUw7l3faTv/jSOPXZO7Lgf+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGM4MDQwNS1lOGExLTQxNmEtODcwNi1lY2MxNTFmMTEyMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqJhbzwAYI7nOYIzpO3tuLXuIn6wPrKcnzdige6OPlho+W\n55gFvMGph/KXO80p0nIubVHORwwEItgQ8UJOHD18o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpaphG6q+YZfyM0J9Q/xpQSj8\nToUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOzpiNzyLZn3fhYYau0XHcusof4exixKY9t4yp5JQMiACIE5qWC+Uaqnn\nvYLIcfdW+Q+j6NttpuajYlPvqFyylaX8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAfMR4ENjnHBdNso+6jdmvabBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA2NzM4NGItYTMyNC00YmJkLWI3ZTMtNjJmZTIyNzdkOTE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGNhNmY0ZWEtNjNkNS00M2VlLWIxNDEtNDUzYjUxNDk4\nYWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKnIIiJPAMD2HnAoBq4s8CvcO\nUg0lmWBmkdTNCpvqjy0ojD5r2WSk5Bvve2LCf5Ngwl3IfF3vpVj950Z24rtUr6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGrTkAmC809TkpEeLr5066nddITowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFcNo+CKzvuxI0Yv\nAd5XvJ3wTp0BpXWFu2uH0N5kKjP7AiBtuSKpjjK1K5pNKmrQdoixI86Yxdc38eeP\nuJOcgQU8oQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4907", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4907` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAXKBWPfAsnw2s5AqwDX0j6BwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0YTM1M2IwLWJhNmMtNGNkYS04MGY5LTY5NDRiZDk0ZTk1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTExZjE3MDMtNzI0\nMC00NWExLWEyYzctZTI2M2Q4YTZlNTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm/hLOCglPeHR41J7QeELRnFD1FighpEHzzS/znbJqy6ByApb+zh5YAv+3xrF\nRjHfr9V/41qVAuZoVHYayxBIkaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVuyxoQDzJF9dDkRYxEYlQb06g0cwHwYDVR0j\nBBgwFoAUrmGjyZzTv1CYJ5g/zzk+qqmdj7IwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAJjkniVpzddbZElE0B/WP7F3Eu0eKdHkHnF2HKGfVA\nQQIgWaTkm3tQE7H+Rw1Dpl/4pNpmLkXiG8gqCuyxEgkpnFE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaNCDsxCc75Bkrpdfvu3ETLSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGEzNTNiMC1iYTZjLTRjZGEtODBmOS02OTQ0YmQ5NGU5NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJBc3gYwRvnIjTJH3Yo7TS0tbtDsdUcJubIHFQxE8b09jK\nu8RcH82h6HKlhCVybEYqGJGzDsDRGz/NfUlh1Ypco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrmGjyZzTv1CYJ5g/zzk+qqmd\nj7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTgOJFt9Bwt5HF+n9h2tbmzTdGrFUVzmFy4iWlAgw9fcCIHuGve9EQvYB\n1RCloNmvFLXVM4xQXw+pAyo7ftyOp3jS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISARLvbmw4Q6HuOv2HSMgORfoAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTExZjE3MDMtNzI0MC00NWExLWEyYzctZTI2M2Q4YTZlNTRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmIzMzM4NjAtN2ZkZC00MDRhLWJjYzEtODI1NmIzZDI2\nYjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKKD4ziJmvbe215d21jqKBDg7\nhImlSnkZrY0Xd63gwD3fSCbbnkiD8uUFuSoIsjtwXjDDBtWp6fW6egUIJeUMh6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVuyxoQDzJF9dDkRYxEYlQb06g0cwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCw11eFllPf/pz8\nfRBFu6IQDt0QLVfHZq2HRZuiu6DxwwIhANjbI2fyw/VLzA+zYOQGDygJ7A8zdor8\n+q/sIJfqvRWd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4908", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4908` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAaAokb1fmFXVC/2FZAVN0FnoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1ZDEwNzkzLWY5YjUtNGM0MS1iNDViLWRmNzhhNTliMzNjYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JlZTg1ZTItMWZl\nNi00NmJlLTk1MjMtYmU2NTY0ZGY3OWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELhSaAe/KxkaafIfU4Wzljj9es0zMjdw3rKn/R9QJgXNKa8cv+gKC8w3FAwkr\nHBHLWxJae/GsIH3yJLi8xt+2uKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfrYDF6EM6LVo+vJ0xQwE1c1e3TgwHwYDVR0j\nBBgwFoAUUZEOI8QuHZNkmxtwFDBsiqJqUAYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA2a40T1AR2pK8Iaols3DYlFN4ewoo3Kv4FHvPbBcV\nUFwCIGaPJDdTmPEZp9/d8k0hu0R9kw77Loqn8EJ/hBKxmd0s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQppIIQ/UozcTSPZ21ZTBxXpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWQxMDc5My1mOWI1LTRjNDEtYjQ1Yi1kZjc4YTU5YjMzY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV/vryceh0swPKMJYolYZbgwehZ8p096M9/TvYEN6eJKCP\nEVvst6Vk48aeC78Ibh1fFanVNcwNIrXhyJYqLAPNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUZEOI8QuHZNkmxtwFDBsiqJq\nUAYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUx+5dMubj6UUHN864FsiPJVsCSJtTa8deKIVtWgaIVQCIAe916z4ePop\nA8/xRmB/XYBZOYz+VOnJQhKdMkclqLlT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAXFFczR2RlKOnNIHKJlATmPnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JlZTg1ZTItMWZlNi00NmJlLTk1MjMtYmU2NTY0ZGY3OWRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTk1ODA0NjktMzVmNy00ZGY1LTg2ZjgtOTIxNzMzYThl\nZTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEF/tY1ueJNntZgDxsJJ8rXAz\ntCV9Nsy1PdI3w+lGbSIFaQ3I0nIrQ/Q5HC3CnOrC9pzLIJAMXn+LL8e0yLhVIaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfrYDF6EM6LVo+vJ0xQwE1c1e3TgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCQjniv06BDOR+P\nimQu21/8PfkEDBKiOyTFyqPlHyesDQIhAKK8a5uw0ExEvE6tWjrzFkPSX1FuyjOW\npUmKYrzAvsb0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4909", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4909` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISATzsb6cyx5CmOXUWc7J8rm/9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNGQ3MGJkLTY5ODEtNDEyMi05MWM5LWMwOTQyYzMxOGQxZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc3Y2QxZjYtN2Nh\nNy00YTg0LWFjMDAtOGQ1YzJhYzIxMTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/xjpaIbihfy9b/tXhGWFtCG/zcxRyo9NNXGsdwEjhM5S8JRIM/H2Nb/GOGvS\nJQtC1LcFBy4+P0QG2tNtCeaPtqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJZYd/4iSEgA3lTuvm4TN8/lIXCUwHwYDVR0j\nBBgwFoAUu+AeMIIbZGUJ9baBTMeYDDRXiocwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAjGkFr9bOap8TLCeQ4CbPeNmkFwidpU/IJT0GoA3ewy0CIQDk\nPg/EYs1t/d7mdFzTGTgVd9CHqWwubcFJ8fUCZobYCg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVmEmMzcVMdlUilPW3FGmVn4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzRkNzBiZC02OTgxLTQxMjItOTFjOS1jMDk0MmMzMThkMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx//91XoTkWtD4pJG8p1az0WCq6xX0Tkuh07jAaJ9HP3of\n/QKR/mlG3p7SJsAntoGV6TznhtSROC/bpy64VeGZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+AeMIIbZGUJ9baBTMeYDDRX\niocwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIOAWSXuglpWCpF+FvSatvtEvfIjcGYSlL+YywZkYDeNAiEAuCBfIAsu\nPwXtgjHL1VQIOtKojJGH+ep3E9pckhUIZxQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISASk0ToVf/4bX0zKi2a37UcIHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc3Y2QxZjYtN2NhNy00YTg0LWFjMDAtOGQ1YzJhYzIxMTg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOThkZGY0OWEtNWMwMS00MTZjLTg1ZWUtNTQ2OWU3ODgz\nODE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEppr/rlx6Bhy8Ff3cYhxNEeDb\nqpTtD/eLZGprws2mhDPtpK35edK5wJ68HfH3GLfYr9sk071HecrFXLNjtZ+UOKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJZYd/4iSEgA3lTuvm4TN8/lIXCUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFsUPY+nFub/UDQV\nJtY3iF3Arhi33GRRBFC85Fp8MqFLAiAe8h3mvwEhPWmtytfhLZJbOjqH+igRKkHJ\nxsoaztIKPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4910", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4910` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAaF1exR+0gkdON/vxrbYyzxRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5MWRlNTFiLTczNzAtNGUzOC04MDdlLTNlNjdjN2UwN2QwMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA5ZTVmOTctNmQw\nMC00MmNiLTlhZDgtNzZmMzc1ZTk1MTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK6Of8wgK3UToc32MxdYNg/a/uDEmXdRSwQ3lmUEustfSgxonknO+YjQW6R2Z\nPJ2VxINNCDqLDQFd1HR2iOeuyKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUctw68RZnqNj/0IzdaJRA/tziBYIwHwYDVR0j\nBBgwFoAUb8E6RHqrM+KI6cBpA/3OGXjffKMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiA1rq5hrSvS7Me6nV1V7aFnKj3SS26l5uu0\nFh35Vbr7XgIgWKYa25rudQVpIg2imIc5Hr9fJT4B2fGbAPexKpdB4Lw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWg/JFSTX9v7jitE1HyaAHxLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTFkZTUxYi03MzcwLTRlMzgtODA3ZS0zZTY3YzdlMDdkMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQETNeucMbAPc4Hkw7FBRI1nQ4DhxeIPLJD1j6804WzEWqn\nZvZDJUGWLZCkHoBS63UIkrAAj/Xr2oJqPh7STzCNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb8E6RHqrM+KI6cBpA/3OGXjf\nfKMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY6aDX3CswZNoa6N8Ouwr88BGXEKiXAQwE48js4CG8vcCID+pl1G/4nc3\neHEzOlPwGgmxa3Hl2bzMqyBspsjpnF8H\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAQ0VWudXS6GY+WHWnqXUk89QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA5ZTVmOTctNmQwMC00MmNiLTlhZDgtNzZmMzc1ZTk1MTkyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTZkMjljNDMtMmZiYy00ZGMyLWExNTYtYjU2NGQ4NzZi\nNDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVVGUwG3141/JnoSLhdz/DiqW\nC9yseHwNKLuCysqZXeLSUJRXDo8EdHt0bMvPb96HZIIOqSIz8YaFX8uDBRAOo6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUctw68RZnqNj/0IzdaJRA/tziBYIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIB5s0FYtltdMRTZn\nWxZAZVC9z3zInLujMyQMD8dYAYNwAiB4JDtatB4lWpabXsL4VnDjCk6UmWunYnYF\n0I5BphkS2A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4911", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4911` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdivLPBLeFFdAhYeLl+iBldOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljZDMyZTIwLTcwY2ItNDk3ZS1iZjQwLTRiZGM3ZGQwOWY3NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQwM2FlNDEtZDkw\nOC00ZTc5LWE1OTItN2M5NjE0ZjAyZjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtmjehqIkwbW/lvA2Zv3Io+1l8i5wjmfEz5nWidUQ4GfUrKbSyz652Y7R8EaI\ncSfuLb/4iYz7Ag1qrq9DWOp4zqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBUZekSDYD6wKGvdniYC8KCGci/MwHwYDVR0j\nBBgwFoAUJCZvS1pcQen3LoNENkyYUcnJNWAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAOxNnVIrJqmduaeXWPK4V+dEXUKuNHKhAu\nvB3mwvHUHAIhAI4BpDjRAa5oAKPW3XIWxxwB7FnwrGHkK5YPu30xnKou\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW/qqvADnpHDgYTIFcZsiz/CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nY2QzMmUyMC03MGNiLTQ5N2UtYmY0MC00YmRjN2RkMDlmNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOsLBNeQSWv5uIigfmIAGqkN+iibJYv1eGyVHjJlNIxil8\n8LxcKSMcWQ8cWjlHwjytvzctNfNvjpTbN3HDgMBSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJCZvS1pcQen3LoNENkyYUcnJ\nNWAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS4VUIamQy71rdPdXTvoWHDUPThUvwuffbNLpDZey6G4CIQCsuD1DJ/YM\nzrRNkQWi27hLGacLIfIUBXD+3s2FrDOr8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZnWUqnv3JuMAfh8eQZrQd2kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQwM2FlNDEtZDkwOC00ZTc5LWE1OTItN2M5NjE0ZjAyZjMzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJiY2ExMzktNWQxMi00NGUxLTk0NmItY2U5NjI3YTFi\nYTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEu3NPWgyZw6USwVsIUJxYXxis\nm4Psc3ftgKOkQqinvtfeertwUnHW9i1lJPuSpmGs7cIe2vqGZkxhxyCNN/KL4qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBUZekSDYD6wKGvdniYC8KCGci/MwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD1cBixB0PEmtyi\nzoxi+AZvouAd13eFxK7NQjHFhDgESAIgbMyfQ2wdi93txDWuCVAsD3hbzRDaQ04f\nlvfUEKnMju4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4912", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4912` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISASvY+WwuJsmI8Qxc5vkGZbqiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MTgxMzE1LTA2OTctNDU2ZS04MWEyLTEyMmU1ZTAyMWI4ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU5NjYwMWYtYWY5\nNy00NTUxLThhODQtYWRkNmQ4ZTA5MDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHTivoWS+ukXiFZ+3WxcnW48GTOmtGFGoavisoSzj+oIHh+tWONELD8+dVp5B\nKAPpoSyvau7/uslbaJwvbLOzFKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7i+MSJgSnqMe36WO+jAnx/iasbwwHwYDVR0j\nBBgwFoAUcUSa9OFJh1CKFx+mtDPHb/YtRN8wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEArh0Uwri4FbKO\nlEEmCtWuafC0tlA2uKJJ5rHmFZsPezUCIQC7oOL/LZT8yy1s4A72VI9fPPUzRL8T\nV7in10PGw/M/tA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUqSF3o4IC3S+ZsOoNUq+CjyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDE4MTMxNS0wNjk3LTQ1NmUtODFhMi0xMjJlNWUwMjFiODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiSGlaiJqFxV/9FsA8slCCWCp75K665QPr2YydaD9Ku24h\np8IQ2bQjuXos8+hkF9KU0KxjQWla0MDwbQPirkiWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcUSa9OFJh1CKFx+mtDPHb/Yt\nRN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMnAutUbj9OyE6KGYWri3ak3u1k0hlzxFQPQFx6WbvnTAiBkm//bc4EX\n/yRBrmPLYhvCdi+uqeLqwkoYCdrmOzuguQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAT2GhZMw8M1usPmAhNeAol+4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU5NjYwMWYtYWY5Ny00NTUxLThhODQtYWRkNmQ4ZTA5MDI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk5N2M3MTQtYzFkZS00M2ZiLWE3YjgtOWRmOWU4ZWVl\nM2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw9HHi1YMkFgaWifqvQYpGfCs\nrZ9UfJGn18ynTjMQIwZ6VxLxiKlBsJ6fHUF1cdTd+QP0XpJR+Fd/s3zS3qWvRKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7i+MSJgSnqMe36WO+jAnx/iasbwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBIrdvb48RnScXvF\nvhxvkQE7Kiq76W5VBkPRqupJGsRuAiEA1XxafjD5ZwoLyL3E29SHKWkQNgVK4Lk5\nYhUZwprMmJ8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4913", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4913` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAX3Tq2mMDwZV0yPZMG/oMsnHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxMDZiMmY2LTlmMGEtNDdiMi1iMmQyLWQwZWQwM2YzNTU4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU5Y2Y1OWMtNzg5\nNC00ZDk5LTgxNjYtNWE4OTQ4ZGU5OWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEldrrpAmvu9Edhp7p23z4FC/E5LKp2+5gSlLsFW6DhPXdFVOh5sJNjL+w1DIX\nEd6sctEx/Hf3tfOZMrxBvQC2WqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXn0LTSpMwnY0P13Hh0m4WigEcJowHwYDVR0j\nBBgwFoAUTli4a0cY2ZdMlTV6U4/oVPJNsN0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHNWh1wf7+pcKrRshIA2l4XM0Qk924xsM8FcTQr+X+URAiBTXxzbUX4DoNET\nDle2cT+7KmwbEHtl+R1n5n0yW9CIIw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATfmOI1HracwRTk06MFF1v0DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTA2YjJmNi05ZjBhLTQ3YjItYjJkMi1kMGVkMDNmMzU1OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARktS6SM/uQliu0MKWwzv5Xyg3ADDBwueMBbwVlfy6SCQqm\noGHmAgshoc8s8ariLauLt9y2If33AMIjdM2UzIapo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTli4a0cY2ZdMlTV6U4/oVPJN\nsN0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANG/g9jScO/wvqeusE7rgCwscD3eo7JGsgge88J/Q7pLAiEAtvO0T+Eh\ns+dREtWC3WWaDbAFu5fAAbIIvcwo9i7D/mw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISATPMqIDLw6/bRD0TOXtmv265MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU5Y2Y1OWMtNzg5NC00ZDk5LTgxNjYtNWE4OTQ4ZGU5OWY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2E1YjE2OGEtZWMyNS00YmIzLWIyZWEtNDQ3ZWIwYzY2\nMDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjMeEdsMXArqIxR8UR7lNUSYq\nXtglEOIVu/gfK/RaTuC2lPUH38Wau2DakiUa2gioL6+qcruAmTjmJWL3J09nOKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXn0LTSpMwnY0P13Hh0m4WigEcJowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCF1yMrO77ScfFq\ng6agnOngYFRDnp9zD3a1Y9Gf79v4eQIhANGxmIGrkuug0qKVsmfbkZSIhoffZnpK\nc0JKHp1/kSL5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4914", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4914` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVKUeYWwAXi3z52+f39tVkITMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5YWIzZWE5LWY5MDItNDFjNS1hZmI2LTcwOTBiODAzYjI2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQyM2E2ZTAtOWVm\nYy00YzJkLWFmYjAtOGU1YWUxODFiZDc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5FUb+a3LvgPuwggRP5Jqg34B1ITc4zTMSsJ5TdGjYahW+hcaw9WvLwXBGF4+\nY1sbeq1CtDB/n5X48RhWmWFROaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnjIdXHW/balVfDOXFmIqXcHkM7UwHwYDVR0j\nBBgwFoAUve8iByN4C3QyfQTrm+1605kq3eowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIG0c7SyMTHg7WMVXQ0HOW/7TN3h9oZqRV3icmzEOZGS7AiAyhPrarau1wMXm\nZCQ1UkQwvgfaFJJKzeNVxViYZufWTQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAThMIGbfjcb1j88kD6xj4mkxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWFiM2VhOS1mOTAyLTQxYzUtYWZiNi03MDkwYjgwM2IyNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeH7DrxovsOofPHTL+e/LFzHec60R9rAV/0uZ4WR0n7bZ7\nevYwMPNu1hwP46qPseUdBi8vzRjtODy8if2E98o1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUve8iByN4C3QyfQTrm+1605kq\n3eowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJygsCAlsrbTLeWfJbek0PqI0hls4sQOrg3A8AYjNP02AiEA3espJ5fu\nS+R+9Kd9zRjN5A0sadOwtBsAbmTCp7jbVVA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAWRsp6DxKcO+JYx85cz9dkzzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQyM2E2ZTAtOWVmYy00YzJkLWFmYjAtOGU1YWUxODFiZDc4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmI2YWVhMzgtMjZhMC00ZTc1LWJlYmYtZjlkN2Y2YzMx\nN2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa5dA5PweVzlgdLBqUTRRLyGo\ngZ4/92IL7i0A5a1c8Mnyj02OiuAxqDLLFlHiFATjoH/cWVzuj9OzRXj9pqljCKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnjIdXHW/balVfDOXFmIqXcHkM7UwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFhJUntG0O0dr/Q+\nz804fYoPSVvDgNVNZQm3GlRO082yAiEArjaT3wknp5bY5XpXV3xam6xZ/lIp8VeM\ndB60eVrXBCU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4915", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4915` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfwHj9RpH8CT5Q7zSMrELYWCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxMzk1ZjRmLTZkYTQtNGZiYS04MjU2LThiZDAwYzU0YjE2MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI5Mzc5NzctNTkz\nNi00ODk4LTk5YTQtYzc5NGRhYzkwMjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG/Mvcg/Td9IUjFzJuvpmicb9BEr19e0ZmzXIBNGVBI5HkJKmc7lc2/1n+/n0\nhYdDqjMVKSKaUDKXoXOCx2jE+aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7qF4c5FuzQ0tLuWdMxeXATxLi5AwHwYDVR0j\nBBgwFoAU5o82+QJERP3zNguc/uhy8pP6MscwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAzFdpyAyfXo0ht2fClO1m4v4scdO5TqlWUL6TamYH92oCICDA8+8jipN9\nh/Rmm8NMx7Iokoro4pN8Bl+ReFeU1udq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUO3S4GxydS+tH1r0kSJSQmrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTM5NWY0Zi02ZGE0LTRmYmEtODI1Ni04YmQwMGM1NGIxNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbph3DA5o1sSVvlKyuptuaktbinFTX56WGcpqlc2OUSKo0\nR8tZVzQGzMDPLFLObKZEu5eDCFGm50MbZmzDT9aso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5o82+QJERP3zNguc/uhy8pP6\nMscwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZPl3gZBhrIrahxWtyeXPlcJdN0TbRxRsyjmZD2VLSjgCIQCcrdxdkzHt\ndbq3r7q0rX4RS893TytlnR4S3+iIv++UsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAeTkZZEhimTSFdDnREXvtcfIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI5Mzc5NzctNTkzNi00ODk4LTk5YTQtYzc5NGRhYzkwMjBlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjlmNTZkN2ItYzY3Yi00YzdhLTk5OGUtODA4ZWRiNTA4\nMjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZVgrhr1N0fQLFnf0JQYZeTkD\nRCz2PvUBBZGh65dXq7v22ZnXGmvEG87TcAEiom5fshapNYTzf8GoeFvQ7JwCSqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7qF4c5FuzQ0tLuWdMxeXATxLi5AwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIA3FJCdOyn0fFjyf\n+3nlvSomyXXhSi3IL7QiUbEnsi6uAiEA2g+RwB/ERdO6rHRXMRE5sS8lJVA6Np3E\nCuE5EvJ1mSI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4916", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4916` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZ3aJHVHUA4o77yn8jz0oBuNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwYWVhODM0LWNmNzUtNDI1MS1iZTU2LTA1ZGQ4ODdhYjNhYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNmOTY0M2ItZDZi\nZS00M2UxLTgwMmEtMDQzOTEyZWRlYmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7h0IDkbn6f3eC/MhiKGZGng6fiXdv8cMqyeqAQjaS+zZHSpcdktxUxl8wgGo\niH8fc4ww5sGLxeOQPN+vWvz/IaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEfZHLgsGjkwk45qVDg2oYdzNjL4wHwYDVR0j\nBBgwFoAU3EI7oCTq27YxjG9SsI/55DSLbxYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBh88QQDScvDrfHoilseznRu+ofBaTGmXOkAmnOsUi+\n+QIhAK+UmqaGuiP4FInw5nu3dpSbIfSnYPTB3GQzK9zZtr5M\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaO2Yvhkz/hjfBlbwdth+M35MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGFlYTgzNC1jZjc1LTQyNTEtYmU1Ni0wNWRkODg3YWIzYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTKYeMwMz1QZI+GO8wodXBmh5VUW7Kn3TGjAa8PFQNar6f\nU20+3jYVRBpD5mU7LPNmOvJb6u7XmF0dHzpTi0+qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3EI7oCTq27YxjG9SsI/55DSL\nbxYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPQddizSCH0dwyDkzQgpXU7hBbNo6MjPfPuIBHSJuyV8AiEA/C6FJIKC\n3CZU5TFnWwPzwfCbRQhDIP7imecDUWQV6s0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISATMd0eYZ37YJo1nbzQCvBVhWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNmOTY0M2ItZDZiZS00M2UxLTgwMmEtMDQzOTEyZWRlYmY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODFkZjUwNDQtMmE3OC00NjNjLWJlMDktMWZmMjViN2U3\nZjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExBjbDi1KFs6TWfCbkT/BUZqe\nM4fe6KjJvxcP7hI8yi77mfc2C9+mHNbPcIc8EnHubUYYyLzFc8zUizhLhNCpHKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEfZHLgsGjkwk45qVDg2oYdzNjL4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGauCJuVYAzHzhQ0\ni/hkVQGumcI7Rme8nKUP2wXe+PK/AiAZhhqsjbfc5XZSqjjAUrIebtRIsvV6Cjtj\n3o8p8dSf+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4917", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4917` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAcW0AxtJhfHcG519AkBUOkLUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyMmQ0ZGNjLTMxMWEtNDQzOC1hZGM0LWY3MmU3M2JlMzY5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY5ODJiMTUtNDNl\nMS00Y2NiLWI4ZmEtYTRiMDUxYzEwNDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYnvzImg1IJmigXyjlgXWgOjBoCE1Z3Me90C48C3e+Qm9hm4q3S4v/rwqVQqj\nVWGkPzfqV+n37ctiShdrkbejfqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWDgpnrS9LOgvpF+AOUJZIchtqEgwHwYDVR0j\nBBgwFoAUWy6K9amZ/mDLQ97nleD+jMcee0YwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA+dzhGbZcZpWeg3Oh0jQiIDqsC6VKe/3Fr6fMpMxN\nPRUCIQDQucf/EetLqqaXIxTv2cwTmoqKF54ENoPTDa8AUoUekA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfvJRdxkzDYhkWtHWS1TyaBpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjJkNGRjYy0zMTFhLTQ0MzgtYWRjNC1mNzJlNzNiZTM2OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQquFMUarqZvNLHh0l/gPtQNr1ybnr5+EPPG0KZuYHxwYqj\nnziu35EzHZKe5a8F15FJ+KRPR3RKcTziFMPEJzy2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWy6K9amZ/mDLQ97nleD+jMce\ne0YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBxcmounXwrY/JQox95d2HySEKipcahEQCuU1v94zHRgCIC8b+phshDBT\n49OeFy9MyDZ+9zBf+7q3SH5CJkxDhzlR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfxRJcjyG1abZcufUJ3v+0qXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY5ODJiMTUtNDNlMS00Y2NiLWI4ZmEtYTRiMDUxYzEwNDVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmY2ODUzZmItZDhhNi00OWMwLTk4MWEtMGJmZjZiMTNi\nNDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs13TcSaKakk6OVV7/zFFvDAj\n+3cPWzhNXiqo685wX2ZCmBcyAEM3MgFvFU4SnAqoeqkB5rY64tdNtY0xxPP9+aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWDgpnrS9LOgvpF+AOUJZIchtqEgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBmT9x5wdukGryk6\nL/bO9QHnSWYMPx4OAbXbYzgEJFmeAiEAnoI7I5IJGatE5EWRAIBDA8nJhrY01Ysp\nTgAxhxgJkrM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4918", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4918` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAcpJB5h7ASc3LrpiAptiBgvxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkNDUzZjQwLTU1ZjMtNDU2NC05OGI4LWRiOTAxMTEwYWNjMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMyMDU5MjYtZDk1\nZi00MjdmLTlkYzUtYmJjMjY3ODdjMGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPMqqNEekXVDwF65oWtaud+wb/2wTboIjJiStxfW9EUq7d3wkWyr5lw2MHG2c\npXuLNAXEaA+GP3TlPyxU+0TRnaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUiRurNpqG+A5SF2PF2iRN+iavA8wHwYDVR0j\nBBgwFoAUVj4iRqwwfLI5xoZ2ALY+nq3EI48wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAmW268coqcG4ZXmiiSYLyawBY1A60Cu+F4VeJP474cXwIgIXtd\nXWebRDSj4qyah22DGSEwulggayGjzjUgmVbvKgM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeoNJcNNhEZh8cAQowa9INx8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDQ1M2Y0MC01NWYzLTQ1NjQtOThiOC1kYjkwMTExMGFjYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ21tW1cV9axAwf3HT9zuyxzCbT2k/+Fsu06E3YvD3zjc9W\ncn09RC3flA7x2/jjHQDdL51e86s05aoqICofSd+Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVj4iRqwwfLI5xoZ2ALY+nq3E\nI48wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXE2fTmH9yL9kdMw00CZMJE8Qyc+X1SnbKIpCYyghdEYCIE0OUVT5Hofj\n99GJHWLjtQezK9vKAXsSXQTOn49h4mm7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQ8VfXbo5NtY0Xvtk4a5XiuLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMyMDU5MjYtZDk1Zi00MjdmLTlkYzUtYmJjMjY3ODdjMGVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzE2N2EzZmUtYmYzMi00MzBhLWI1ZGItYzAzODljZTVh\nM2ZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOjhsVuiICCAb9c2ceGRNZlcY\n/goWcE5xDzMWEqh/DYCrkMQSbi5f1Tb0f9k/U5WtnT80XXMiTK13PYQ648uJ+qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUiRurNpqG+A5SF2PF2iRN+iavA8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCFHX2ot3QRurQ6\nGMA8CwpF0I4gDOdlgGzUtg3qUbRXlAIgdQt7syVorlaDUhLe5GTBgebcnItYCS7P\nzYposxU3/CY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4919", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4919` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZc8Xrjg69F/qfuMG5aatfDNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhNzlkMjE0LWQwMzctNDRhNi04YWJjLTY0NzY3MDQxNDU5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBmZWJkMmUtY2Zh\nYy00OGUzLWJmMDQtODNmOGM5ZjgyNTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWxwgX2UonucGOO5Q5LASp6m3UhhPX0D+14deTeKHHC+phTHP1HX1LEhB3Lx4\nCCGLJQrTekfvCic/9Ego6bztH6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxYy7YhBqG1fAqzqcImhwFh6orzYwHwYDVR0j\nBBgwFoAUajfzAHd+taKbokpRogmG9CjfBlkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA0S8W/WcDadY2xfS8FfCei7EpQddoHttZ\nvYxzpRJDJ8MCIBE0hGVeGulyb/2Tb3LnjG7t0e0FBtGOLRbPcTUQKgT8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdQLir1p5wTS8iu8Rd8hG+qsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTc5ZDIxNC1kMDM3LTQ0YTYtOGFiYy02NDc2NzA0MTQ1OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5PTjK6AaDhv3GL7rwNWWdfi9i0vzuKA9sKJ5odZxaauZU\ndVHb8JfmGuYqAz876Dvi7zfQSW8BF/XY/WaBcfZCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUajfzAHd+taKbokpRogmG9Cjf\nBlkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTn6cAa4q9cVtgczuL0CqM7mYgiyVDJ2lqNF7ZNJ6h24CIQCMfpnl5m1i\nTQBQpEkj37SMiXfNvLeuUlp0eNmO8IYKcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAejj37kwdgLJcV5SIrTnt6EfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBmZWJkMmUtY2ZhYy00OGUzLWJmMDQtODNmOGM5ZjgyNTBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDhhN2Q0YTgtMzYwYS00NTc4LWI4NTMtZTI5N2QyYWZi\nNzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE17PfKJJ988yi/A9I4MLHaipy\npJQjUVWkE1a+ckiphKwiuTDappTX9SQZLQAJfg6V57EJyrqJlvl9+o34gIIs+aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxYy7YhBqG1fAqzqcImhwFh6orzYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDx7YL18sn6pyVW\n9Ez1TON+LqT8RR2NMC1pFOnypoJIXAIhAMOKpwU3crFHGSdS5HDw/tcGBofezLy9\nNzhWhcHjTHZ+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4920", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4920` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAdf6VWBKhPFZEqN+u1vw+DG5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4YWZmOGQ5LTk5NzYtNGVhMS1iZjU5LWU1NjczNzBiMGUyNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdlNmEzOTktNWI1\nOS00MmVhLTkyMGEtZWEyZGFmMzkzZTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/L9QMlfrxRZVV5oRpNKESESkM8IXj0OhtdCZcIIi85KnZ82uEpIggdwFA+9J\nfHjZlcIIQlj4eEU3qYi0WwMPpaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8ov3NjEubbDNR/0CmwIXQF2rUrYwHwYDVR0j\nBBgwFoAUsMkU4a9jiB0RJAdWyiDRcAPKjUkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBDWEoglc89tGCi/qSNf2btQvjJI3qCdI5Y\n5DOWUCfswAIgElqYFUn89Q/m5QmPLdhAGuvj0b6kHFzdwInyYhiPewM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeGl8558j03HvQa0z/2TBPWnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOGFmZjhkOS05OTc2LTRlYTEtYmY1OS1lNTY3MzcwYjBlMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7FQIAEsoRgOqe8WzmlSUsEwnz6CMKv7dpOg/Bjqt06LpX\no8epeHASz3AR64xhNLwz5U6uGE2p9ISeA5gj8NMPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsMkU4a9jiB0RJAdWyiDRcAPK\njUkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPGZfhT6geI+bfpZ+JuhQNq/Y8P80yO59icKeQwgYAlBAiAp6ISFO/YK\nM1TYVOYq2sgyLGMDawXO/yea0fQ8yjSXlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAeVKPtv4E7ctVsoZr2p1w7o8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdlNmEzOTktNWI1OS00MmVhLTkyMGEtZWEyZGFmMzkzZTExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2RlMWNiNjgtZjQ0MS00OTZjLWJmMDItZDc2N2VjZmQw\nYWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdMrsthGxYZV+Xf6FQOFK2gKJ\nou2Kogm1nXEOTvdhrKkUqI74pM3hggRQGdKBu9WbyT4T562P7Q1k0hM3cRRicqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8ov3NjEubbDNR/0CmwIXQF2rUrYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEK4VKrhz/KkpT5y\nVLD3mZQZEnNvDqAX+Q2QFkREaOxgAiBeF27VuGHkeykS5/2HqF87T0N79X5+4bgV\nSuoyl5ad8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4921", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4921` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAfMoubvq2mjNxaaoMXwgJHtFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkYWJlYzdmLTk3MWEtNDFhZi1hZjg3LWUyMTM3MDk1ODY0MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBmOTc2NjgtZjY3\nOS00YmVjLTkzOTYtM2Y0NzExYWY0NTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/fPECjnIlmF0GGN+7cv4No7lzgGYMc8u6/DAXMZzgzXSdcZANgnNcGF9vOXQ\n2H1NhN7ZlCsqxdNjOSI7IZFEoqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvHSNquNAdXLFgjB0AUJdJVY6YxswHwYDVR0j\nBBgwFoAUJWfwRBkcts17wsFrhrzwlRJ2K7MwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCYo3L9S226LNcEekk9QQXUGcNo\n4k9Fo6+Jp3mCp1NOjwIhAPOhB7PB2GksZOF41GDnRBVDTvMCBDvsaXtLTsH4hEwn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbb7z74lRZ5GV1usW7wy9DCZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGFiZWM3Zi05NzFhLTQxYWYtYWY4Ny1lMjEzNzA5NTg2NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMXAxgxhpBFIwD5Iv8picNbf7tx6YD2HXDhYmuuODmyfeN\nxpec2M1qIuH6XJ8ID//rHXrDjRS2Ljn1lcOJVlGpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJWfwRBkcts17wsFrhrzwlRJ2\nK7MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTiYZXQ175/McZjKN/jGMO3qTFQFu5UN0aT9zKIVLW40CIQDODoa16ZlY\nrkHUcdK93Isx0/3QVEZSdz32/ntr6Y//Sw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAb8NuQ8hZigwM8/hrlrlHhfbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBmOTc2NjgtZjY3OS00YmVjLTkzOTYtM2Y0NzExYWY0NTljMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDIzN2I3YWQtZWY1NS00OTYyLWFiM2UtNDkzZjgxNWJk\nYmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQO76OMmkdCP7QmIwq7lORhrx\nUGlRSe/FIQII6ni8E/oum+/a0GS0xawpwIEWICEUoBAjIgooeWdoFmNFdDUBsaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvHSNquNAdXLFgjB0AUJdJVY6YxswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG0pH8GtCc+ul/Dc\nq+wogezowoQFlM2BX5djDMAaTgrKAiEA2vgTNcEv0Ue8FsgzTiZInQLb/t01Qtc1\nEf2dMl+Dz3Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4922", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4922` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAYtnD/RqjtH2rDNW3WiEgjczMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2NDhjZjc1LTI1ZjktNGUxNi04YjNkLWFkNmExY2VjOWUwYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJlNmU2N2EtNjJl\nOC00MDgxLWI3MzctYjRhMzMyMzQ4NmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBOsKKKl7LXGMEx9ZzmA7a2Z1aDWLmNroKb4gsKKUnZM6WluaxrErafzMgIeG\ndHmSeX6tMNoGLm9EnsvGapX/s6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPL783rikMVa/fns38hyLwUyJ5qowHwYDVR0j\nBBgwFoAUzZh5dlaaMuYpcvZ7+yTWCYJGBjMwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAI8VKBb3\ne857h/bjvT21mFkFGg0hmTx++WrNdnf1iRdJAiEAk6zpyhIx9iz6RdVQyZ9rCRKR\nhzNqKJSpOEba2wikiYk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARzmopI5s2rJDWTanS0gd+/sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjQ4Y2Y3NS0yNWY5LTRlMTYtOGIzZC1hZDZhMWNlYzllMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaQe94XoyfWh4u64ttdXoGsENjtZlylIGR+4Y0IjQoX6dy\no/eSDLUYFLxuHO7o4lVGD4L2zueKU6MG+5pXr+Aso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzZh5dlaaMuYpcvZ7+yTWCYJG\nBjMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOJssbJHY0SKg1Ctw65MudrBlhCnFJZokzSpdbrd5WQyAiBBpGnzvNSP\nm/BQwAGlAQEUK/uEuFLQPunT/CpvLXETJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAStNF7hUsNdsYP2sqP84KmGwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJlNmU2N2EtNjJlOC00MDgxLWI3MzctYjRhMzMyMzQ4NmE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjNkZTUyMWQtYjc2NS00ZDc0LWI4YzctNDU2OGFhYmE2\nMGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx6mGxK0GHpr429gpSUvk42zr\nkcL3uDgImLnyfAbkCZKhGNZWi8IfqxzgaK7FAc6Toc2kRCwJ8aLCW7ow5l0XvaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPL783rikMVa/fns38hyLwUyJ5qowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDE0nleEFVEbg8O\nqdwxvFfEb6bersn4ahGe5479ru2jTAIgcn4gaOngdsG5TP/f4JHr3i+9a1wIZfDU\nJAvdk4c137s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4923", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4923` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISATaBBFC9jW0TAY0Q+oA7p59oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMWY0Mjk1LTc0MTAtNDFmMi05MTQ5LTBlZjdmMWVhZTJjMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTYyZDNmOWItMmEx\nOS00YzJhLTlmZDEtNGRmYmIzMWE3YzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErTPa8TKM3HuGLHf9/Ff2L6Nx7CrTFL4kgAXd0wdST3qlCZ/2N/4mOAr1x49j\nAdfDe3fe0O5NPg86hhUuxCqzrKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpTibeW/BbEAj9NrQ9MNietf4NTUwHwYDVR0j\nBBgwFoAUmNI6g/lOH/0ELe93GGY9x22agpMwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgJNVoMieA\nC4yA3ZJBEQTJ2qyvUbLWT51833S/BDC7X7wCIQD120FR8VL8I3s/wraCJpsmfg9g\niKRkmDZnU3cdofmppQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfIU0hSNDYm7+M7NGx5t9GCiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTFmNDI5NS03NDEwLTQxZjItOTE0OS0wZWY3ZjFlYWUyYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARixx8KoxVILbNEGfbjYy6/7FqYlmhu0JuKXTLMnKH4EraE\nCypT86i4+jtt60ArUY+Lwpqq4MxrayNnQpL1b9sIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmNI6g/lOH/0ELe93GGY9x22a\ngpMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK6w5SVxZ+9BZKKbUrzjqqSyt9Qd974CxLNSRqM9B8T0AiBZ8u5DUXZ3\nL+r6necmajFSPYJ4v3Mq8ntNfEiGaZmvHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAdm5hHxrcwTe9ZrSWrcd8NYBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTYyZDNmOWItMmExOS00YzJhLTlmZDEtNGRmYmIzMWE3YzY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjhiZTY3MzQtZTAzOC00MGM2LWI0MDUtOTFmMDljZTZl\nNjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELLemGjKf6JvHsknl54eUO/Hq\nOLWNbRukWDdbvbekw6vaFjXOaO3RTXS8oT32QfSzck3B0LXkeIL/j43HFXN8JaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpTibeW/BbEAj9NrQ9MNietf4NTUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGk4tOqEm0leOyLO\naMUOA89V2lOkAvQ8vvnDl9zXO7SgAiEA2MoTHp5vX8MIxC+FCHltabSGlmqZUR9b\nkGHcPLq/Yss=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4924", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4924` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAejK28uD+6DhiPmoxk5qlmnZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5NTdkMjY2LTYxZGItNDVhYy1hZjdlLWExNWEzMDUwOWM4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJiOGExMTgtODdm\nMi00OWE3LWI1YjYtOGMwYjAzZDQ2MDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgZMZZbc5yFsNJTFOeIV3ZOqe+z79yqsqe99ADcMkNwCXN1Cvmv4rGyKk8VbQ\nITm0gDVCqdUrKhNGP+JPiYt1CaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/tCeZ6kcn/MKoCMIr7jCuRI/8t8wHwYDVR0j\nBBgwFoAUd8PRVQ+BDM/4e1Z93z7+6vcxGOswLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCJHOpv\nLyGdbdVG8Sv0aUoMmbc+Spxi3R5xcO/3AQVIQwIgeCW1Utc00Twt/Z+3Rhr/dSOC\nn1qbl5d+CXiLU5JeUR0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdtWGxv0F/B8EniSDCZgPOoNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTU3ZDI2Ni02MWRiLTQ1YWMtYWY3ZS1hMTVhMzA1MDljOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIhqSjuMn9sMuUl/BUKWNBhi95K/zQQUDDq+XjJITljU4z\nysOPh31zTbB/JtfHgfQ4FEDD689t4/ihu3RaynNxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd8PRVQ+BDM/4e1Z93z7+6vcx\nGOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC8PW9B1XDAGSmg/1ypdqXOByO5Rbrtjj4H/N3QyQBaMCIAnjBBtdKaxO\nnouUj3v10uW78ZM+7PaAwlDD1YrsqVJ9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAaVwXoOKVufjysu2IAWRvCKsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJiOGExMTgtODdmMi00OWE3LWI1YjYtOGMwYjAzZDQ2MDU3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTg0N2VmZWQtM2E4Yy00YjNjLThlZDYtY2ExZDU2NDE0\nMGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfn9eeiz10GrGRrb5MuLFxI3z\nVFE0IDoVxNmAZailx5Y/aG/PzaFqFtbc0EKZyYm4p/AtLDsxwy4GOuumIXPdiqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/tCeZ6kcn/MKoCMIr7jCuRI/8t8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICM/EAY7jxprG9Cv\n7bbQ3XQfeJNffDfU4PoVU2qXJnm+AiEAx7FJMXH7YWSAl69DoAC7/hGQbeqwSKCg\nP4If8BxuYIY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4925", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4925` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAVj8nCaL0tahRJaEr7x8zT7TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyNjliMWRlLTFkZTMtNGY2OC05ZDBlLTQwYTAyZTcxMGY4ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZkN2UzMzEtMTk2\nNy00YTUwLWE3MDMtZmUxMDlhNDU0MDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZCBNZrsyZ6t9mFpxXimlwCYJi2rP/hHS0m5afQ75CGO8dZrnDhivwNNqzc6E\nz2Ivan2TFEr5QhfsV4NuyvKImKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBqv8Th34T70J5DDm+TIsTZprTaswHwYDVR0j\nBBgwFoAU7RpufUqMDXVoYmZ73eL96aa4OrAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIEqhHmJ0/i/nns3gJkUWl9cPuLfa3rx0wMDJl7uHvBvFAiEAoEfZYKdw\n4d6bEoofII48vzaNaWAB+cjTfpo7QlL1Yg0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc8tp9oQOTRNuQ7k5SHxYCXsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjY5YjFkZS0xZGUzLTRmNjgtOWQwZS00MGEwMmU3MTBmODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyZqd6hc0ykenxXKvoChIlsJQXdcT49sHcSGtkdpTxm8YO\nTcM+TgnLHofPUmnrnyVM64cB6CqhrshWOVLjNS0jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7RpufUqMDXVoYmZ73eL96aa4\nOrAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM/bMzIq6J5Jjzg0MarjyopUGyW+8Lwbp8m8RjADWZE0CIAHNosBqosLv\n/HF1a3sK0AffZm38kRDMjN7YJ6bCvbZt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATburtXS+fjir/Y3abENK7C2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZkN2UzMzEtMTk2Ny00YTUwLWE3MDMtZmUxMDlhNDU0MDE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2RjMWQ5MTUtNmE0Ny00YTFiLWJlODMtMTQxM2IyZjNh\nNDVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtpzCSOas+DpggpInUMXxQ4E9\nXifnV7S4UuaN+Hf1QMeEl6aVT01GLttimIHq5eZcQyHEh49RB41FLkxgxjBzBKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBqv8Th34T70J5DDm+TIsTZprTaswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCSJs3bFR4LKhQL\nbUQ1mzE/U9m5y9NnDXMe/zMmNDhRMAIgOYUKNtzY6qt44X2NNkbdVL1OpjBHqwjl\n5C6gSpKE294=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4926", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4926` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAeJh5ttA8oK9yASOX4TES5WhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlMThjMWZiLWIyZWQtNDYwOS1hZDUyLTYyYTkzYmEzMGVkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M1ODUwYTktMDQ2\nMi00NjhlLTg1YWQtNzBjZjMwNjk0YTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKFyLbnO8Q0Mk56wQwQxfaSYyaSefGSujBn3EQMxOsOoJnm/yS9RgFJCnauzI\nw/bjzrKAzN6C5mxazcdaJtCVLqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk+Vjkj8xVRDRgWlntRquDi3CVaUwHwYDVR0j\nBBgwFoAU+L//q6QwmR3nbgN833MkX60f2i4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDT5Ya67GS7/7Kxm6k1KykBgbKC/0CDyvUAB5ny/D6KxAIhAPT1iw4h\nxiVZDPH3p89tSvhhbxt6y0h3jN6lnRRUYDGo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX04wZ1wCFDSlLNWXaHxdxYIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTE4YzFmYi1iMmVkLTQ2MDktYWQ1Mi02MmE5M2JhMzBlZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbzJ8JPVisFFsLdpIGyLVzDybPD3SZzsHdaBXswAcBzlyU\nbC6Y8cA4hLlwLm+BjUNLpp2Nb4glcYg3/KiINnBeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+L//q6QwmR3nbgN833MkX60f\n2i4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKKcdnqZH6u1+WpvWgH9af/fmBMtdqWAe6FtkSL4RZSLAiEAim9G5QhN\nWRcxUX/Cto9uIq5JK3RaHM0otoIekW2DuQA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAf46h7yapdoRihxByvUH4hIdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M1ODUwYTktMDQ2Mi00NjhlLTg1YWQtNzBjZjMwNjk0YTY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNThhZTA4ZWYtZWZmMy00ZDRhLTllZjctMjI2MDgzZDUz\nYzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfUw7rOyjLE1xIMcNyhdDMIOp\nYUhqsC/HQOaf5eCcPT5BW0fs6KuepHk92QXk0zrklIPlpjBfVDO+cWPHSWgd1aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUk+Vjkj8xVRDRgWlntRquDi3CVaUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIH3y0ujlJQQxLWYG\nEJtIuVFmGcSRMjpjhCs7Q7owp+05AiB/hm20DTYeFEl8uBAxquJaoQvNHeRCemBQ\ndzuT8J+uCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4927", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4927` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAaHtka6nuyTH03tcx8zcyErYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNzM3NWEwLTIyZGUtNDRlNC04MjBiLTAwMTJlYjVlY2JjZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBjYmRhNzEtODll\nMS00ZjJkLWEzMDUtYTc3MzE2NjVlZDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErFBxJtTz1JQQKc11o/mFYp5SYBPKke4ZUuksLjdH6RI/laweJQtnfXc/kspS\nupHJxH30sZoOPD3x6yZ1eJzR9aOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5WNfiGUh8IaTu/unLCjlaiBGcYAwHwYDVR0j\nBBgwFoAUp5ogs2I64gWonqXLgQeeJ38mo8cwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIHxR+lxQ1p7P5Akj7ZnY2eBs3AYbZh6lPHjxcLZVoWYiAiAzJ7M9fBBoej7Q7JNx\nnWfTKwih/0XoLdj6/LSh84/tXQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeVKvysX2GbDxZ08D7p3tAovMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjczNzVhMC0yMmRlLTQ0ZTQtODIwYi0wMDEyZWI1ZWNiY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4k9WQj3Wqtxwvntm1ZQcdTkyJlpjDIgJDHRfSmiQcbKC0\n3XPEHB/VYsfLyiI5mCGUvEhPwvII5i0OCeNyJomyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp5ogs2I64gWonqXLgQeeJ38m\no8cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBj3eL/XpMw6+2U/6boEGaCyPuRXzHp4gYmZFvuVByTgCIQCGndI29MuF\nXJMJmEa0JCTsSGs8o37iQqT8vh+KaEaPMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATkMl4c0SMEFyBwX9XPKVKBiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBjYmRhNzEtODllMS00ZjJkLWEzMDUtYTc3MzE2NjVlZDY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGVkY2MwZDUtMzkzNS00ODRiLWFmNzgtMjA4ZGYxOGNi\nODc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9s5rqXKAXMp5289XrUMJjq8v\nhhhHS+6E9dfolqEAm7E9PPv5UHNqjUJd2j7AO264ZN9Xf04nNSoMGsccKCBbFKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5WNfiGUh8IaTu/unLCjlaiBGcYAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFLqjl6uoiCe0JaL\nK33NdtFCPC4ceHbFjTnJ804l2ZmfAiEAljTAagNzlKrD12rAJWPHSg0+YSBoEuw/\nVd4lZye1UD0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4928", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4928` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAdSGeX/kNP7+yBhdmz1ZZIuvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxMTE0ZjYwLTU2YzQtNGZhMy1iMmExLTJjZjc1MGQ3MWQxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFmNTA5YjAtMDBm\nNS00NTIwLWI5NmItYWUxNWUzNmViMzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEknSOzOac4lFtWYeOu4n0xL6cR9qItTnN7RdthFkPxPBGALHnhIy15V6vt4oE\n6Vt0N8Jh2Zw52spp3swGV/G8ZqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpSiUbhsdZPj6N8o5+P/6qEbZCLswHwYDVR0j\nBBgwFoAUPBtNpUaS72S3U3yTBkDg2LJaOZAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCICcZjKz3Pyp08ZijuHmOxHFejmQYGTRK7fOHvAgxTiDvAiEA\njywa+k6/e7GXopzP/b77cQx/8fVttH/jOBJhPzNuQ7w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeG+JQXcvQjRSnBt3XhFIdJZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTExNGY2MC01NmM0LTRmYTMtYjJhMS0yY2Y3NTBkNzFkMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFvVpZdMsOeETiMcs82f16DoKy6fB4k7wTkhUGjJPo7Fiz\n0mkbzbx452Y+oDRfl34+JGjO49dx0hLr6E6OjwWyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPBtNpUaS72S3U3yTBkDg2LJa\nOZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbA0UTm3zVgp6Jm1TbtHx+orxeHUX9VdoT3sPv+yN1bsCIGFiDj5xi7Pi\nfxRiyu4TJ9/b8Ukm+RdaaknUOejv0Rl/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAeleEod+hgsc9XlJQufC+xLLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFmNTA5YjAtMDBmNS00NTIwLWI5NmItYWUxNWUzNmViMzJiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjc3ZjE0M2YtNWE4Ny00YmJjLWJjM2MtNTVlM2E3ODNm\nNDk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5IyxjxYlf8z+I3Z74AH11BiN\n1DLYwFxxClIPf2O6bS/0U6+L5UNZljyEvGl5VMMJEytasFko3g1NK2zXaR0Hp6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpSiUbhsdZPj6N8o5+P/6qEbZCLswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCVD/XlrepFMkm7\nWRX7FuQiB8nzKaHLYrKXcJz3zTzJQgIhAJbEuyKIGbmPMGm542oyKpRpwH4h0aUx\nSFk37v4/wwAx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4929", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4929` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZ3/38KojooiRTgKTdjQIYXKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhZTNhYjBlLTg4MWEtNDg0MC1iYTRiLWZhMzk1ODgwZDEyOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRhYzVjNGItYjhm\nZS00OWMwLWIwODItMDg4OTc4NTM0MWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+TJAzzSf05MTDyqTmpirz+YloyibfVKngM5eLl57Jdyd+rxxAK0Juj9Hbpih\n4QQzWF3lomVp7qwuK7DBvSZPsKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4CvnkuW+/j3HGEfQ/iSXi4uy16gwHwYDVR0j\nBBgwFoAUKTbl3ExM1ChVb/TCwaLqqTYgi3QwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIDs6S/wUlO3gt3SJVnATQZWZI1ZwTDj2O+14j7/JW0AEAiEA\nt/3QbvkOj8M1Nu0/sz2GLJYqmnIwyFSn9LfbsFzNyY0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeXm9IAb6/UaaT8eKHWcO93EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWUzYWIwZS04ODFhLTQ4NDAtYmE0Yi1mYTM5NTg4MGQxMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYRJ6Ce0S+1XjX2oZWN4XWGeNKrgI3auRrnymahDvFuaPT\niDtlPQXPp7kMBIUQg3pNuARncSXPm60jDhzL1rFCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKTbl3ExM1ChVb/TCwaLqqTYg\ni3QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANngFqDv4HaM05gztV3DE7X1lkKF+MfFoKOXVZ6I+WvpAiEAhUrImRvZ\na2wATGGHB+wDqfynr3MSWAVv4hQbKJoEi3k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAT02jbObAfMsr5Y21CEP9Z78MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRhYzVjNGItYjhmZS00OWMwLWIwODItMDg4OTc4NTM0MWFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGNjYmE4MWYtYWZkYy00OWFlLTlhMjQtYWRiOGMxNDNm\nYjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIdGcZR4JQ667J+XXv8uohUA+\n6xBfjImuCi5JeMivvuKpvXhU9QGYSTszNGyaMvz/vxKh2ru8lNIuknzF+W3u1qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4CvnkuW+/j3HGEfQ/iSXi4uy16gwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAl3JepeGB1tIlE4\nLl9tbtc+lezdsNR8oeoOlW1hgDDlAiAgiVDUhtQ9DmAnmApv673ptw4kTkOZzNVu\nmbOSZBGhOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4930", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4930` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdvfReO0MFI9U0bfsy9SGPn5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzMTM0NzFjLWNmM2QtNDIyYy05NjVlLTVhODU1MTY1ZDFlZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZkZTQ4MjEtYzRi\nZS00ZDgxLWI5MGEtNmJkZDBhODFjMTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJRRGgpznDmy/HGlWXb1zLPRsnWjk4eG8vv7IE42tCg6axx1SZieYTI7QDAjq\ne4WmCC8cGJjnKttTNknRDHisFqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2DXLDflE0dJxow1T2bUoBWgDG0AwHwYDVR0j\nBBgwFoAU25+k0Luzkr0/WdRprX5J8vwuo8YwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDS9qNNsaKv\nBbB0eksWsmTTMiUt32BVpsw6PoL5OvIGXQIgZqDoSbjGKzmH1fwJLCPs9uGSg8p0\ncbvgnfH9LuxVD9M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXxD99jZru4HKrSRV7y6+vdcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzEzNDcxYy1jZjNkLTQyMmMtOTY1ZS01YTg1NTE2NWQxZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9GUDh+HBYXx3b04mS4cKarPnbIfQcxuI0EmlIl42xpoSx\nQm0U9XPAQT/mMsC5QIGbXRooV8o9d8PUO8jxyzCMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU25+k0Luzkr0/WdRprX5J8vwu\no8YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJCNNF+9ce4eUIY1wvyUzkUm3nxMuEeUKCqEkPvjgh2eAiBzHhcCm/Ti\nop+KGtvCtuOidc6TlsubValrzXl+Yv9FZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAaNFGWIvQGCwuYYjQSEYzp6HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZkZTQ4MjEtYzRiZS00ZDgxLWI5MGEtNmJkZDBhODFjMTQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjBhYmU5YmYtM2Q2Mi00M2I0LWE3ZTYtODY0OGY4MzVj\nOTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMhocLObe36tu2X0pUkzXmgVv\nCJuRpKy9tRjbTiDA+ymqqTRGx4BqSIhqyyuN4CF9b1tiCCd8SXObqnuHpXBEdqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2DXLDflE0dJxow1T2bUoBWgDG0AwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDGYShNi0mVuXOw\nv8d6wII8pIvqA7eA41Rmjc70ZpZBrQIhAOckMhiDJu+69DX1u7x4dfdWBPyhx7dC\nlTE1wsaC7Jqn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4931", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4931` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAUy8s10fSn0FpYPNDkRWRoMrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNmMxZDM3LWVjZWItNDAxZi05NWUxLTRjY2YwMDM5NjJjMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ0ODZmOTgtYTZm\nOC00MTc1LTkyNTMtMmZjMTVhYWM2ZDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESTJcH3oFAeUnM9gLw3N8vDMR3NCBjNEbMgiQtAGOBrz0Z2nF/3dlCDnqGagd\nArWwQb0JhZfR+yMpdHlO1yLxsaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMSxp6FZxTzOBDWDQNWaBJEe8ni8wHwYDVR0j\nBBgwFoAUuvfJ9MMtfdKGv2H+agLdort90wQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAM/UTAIY2nnGHtk1ntMeVqnLSRV+E/AjekRsWKzYvOU4AiBiI5L0lz7N\no5g9nk76J5WU0ILzual/P5VJd6qjGRK4Jg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAck0RMyKAwjXXzrj5Q/hdjoiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzZjMWQzNy1lY2ViLTQwMWYtOTVlMS00Y2NmMDAzOTYyYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5y+JDjA2YEVXYt77hw1jSDYr0DgI0VAY6X18gGpXM5b31\n/lPui4pNECb7K3Yj7SkDmgcdBi7wHFtafPDb1935o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuvfJ9MMtfdKGv2H+agLdort9\n0wQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJjK6qnhhiFiPm5HAGKAjl5zdnnbWwjeUW2MYiZE7JehAiBDHB/zVduU\n158z6kaB642GCBgzUgFbPhLsQgfqBPXIng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAXfTwqlSpqb/LukNpqkdl58nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ0ODZmOTgtYTZmOC00MTc1LTkyNTMtMmZjMTVhYWM2ZDViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDcxNDg0ZjItYTAwNC00YTVkLThjZDItZmEzODlkZGE4\nMjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0LmVol8Mq5OWocsODMMbOLLL\nCfhIGoIwzC5ovm4K99bE4A/AlvqYZO1mGaDrKZJlSj7Lb+T1fF/iSjZQl02WsKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMSxp6FZxTzOBDWDQNWaBJEe8ni8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD0atcTA5JVcw1g\na50jqFQYZtQ3Koe8yBnuC8t81MlSAgIhAM4L7KEx+ThVaXAsPYYoizjcNEPOXxpU\n+XnHnqoNKELd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4932", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4932` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAd/314UrO89t7rb1/Nf24HGjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhN2VmYjI5LWM4YWMtNDNiMi1hMTk0LWNjMGEwZTc0NTZmYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUwZGUwNGQtMWU0\nMi00ODlhLThmYWUtODczNzZkOGU4ZDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUyoPhvH9L+E4uVhdIgLpRqjnYIjAMh6MUyNjawj38Ij1hbbD+ddT5VPd7mgF\n2q8auoFn7LHJQiG3AV3Zl30JDaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiPvDadjI6CaC8qC/+30suRPjhVwwHwYDVR0j\nBBgwFoAUL/qf0fJTaC2SEBSLoiPkvwlM2tcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgMgPICAJ83aYIe89997ZrOxlt2C8Ob9PZ73b74Vd42VMCIQDmetVMKayn\n74ag4JT1+zwyrdmwldO6bVV1a336sc5b3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaFotnxbgzOGEpHSglDWGXjtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTdlZmIyOS1jOGFjLTQzYjItYTE5NC1jYzBhMGU3NDU2ZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZE+UQd0W1z/0yFklQuCIzGKLEGtpS1TSWFNiGN1fRwPMy\n0yD9/4htHWUIwejBeubvLXU+eiseYL9eRaBkYPovo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL/qf0fJTaC2SEBSLoiPkvwlM\n2tcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYYFoAoGjvFT9CdQAa0Go1uFTv6y/b59PqaA0xOxDllkCIQCb2wq8Me1o\n5Z/jt1whdjpaxedF738SG33PWIlTBKNbVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISARJ/xjvEgIOEiyEZRXkiOEe5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUwZGUwNGQtMWU0Mi00ODlhLThmYWUtODczNzZkOGU4ZDM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGQ1YTQzNmMtNzQ1MC00Y2FmLTg1MTItYTMxMDNiMTI0\nNjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELlqFn89tWpDNAjHdPEDIwbgr\np7dbnP/cZBla8T7y8tksgUaHZ9yeLFZpVQ9/Pd7YaWTQBucXzgCdnhYSlHqJNKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiPvDadjI6CaC8qC/+30suRPjhVwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEcRSaHV9VBV6SIC\nyo1qGhbmhcO0y0n6JFF/2ZSYXq1bAiEAsQrll+Tx5oFijZ6Cor66HqeAosqYICH5\nLhnS7HoSRkc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4933", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4933` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAfDJwUkXvRYLTAtsx62qHACSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2OTBlMTQxLWYyNzEtNDQxYy1hMzE3LTcxNzE1YWEyOTA4NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRjMWRjYjgtYWRk\nZi00M2VmLThhYzItMGQwOGIwYTlkZmI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2iyhhWtuZ4cb0ry9cxJL+PcXEXoRlYq/egCjRySkuoAR4kH21Q6XhffiX6bl\nxH7gk/SxucfkQIi5KBOuB5cooKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAReLQk0lm6URJdyOAIuhgc1UODIwHwYDVR0j\nBBgwFoAUR9Af//QU+j5WMRhM9CQXKpDlNWgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIHVdMeBowinXbm1GpZtxLwBTMLLdpSXs4KUAgipTSc+qAiByDO7CfcmS\n7NLVS1QWnQUAz7O/PttygK6Os4STdrJDsg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU/yFo6t0imqudYUw7WdutVrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjkwZTE0MS1mMjcxLTQ0MWMtYTMxNy03MTcxNWFhMjkwODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8/JWVurtHpuLejV33EC2vB/tNZZgmN967uW3uCj8ZuxJ/\nkt/fXyJRA6L94kKj0MUrAN2Zdn2xDi2QVKqSAnSIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR9Af//QU+j5WMRhM9CQXKpDl\nNWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVi8IKVAM8sO7zUJ56TVZCiWx5UfDMIxxphdGkS8723kCIGZLM6+WItfV\nC9nB7c8cdWZ0fAL52kzu/sclvlBDvYnP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYaHwGqDxS9KII28PEghASnkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRjMWRjYjgtYWRkZi00M2VmLThhYzItMGQwOGIwYTlkZmI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWQ0ZDQxMWMtNzQ1NS00Y2NkLWE5NWItOTgxNGY3ZmM4\nZTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExsj9C2l9ZPz5IoYy+qAp9JH2\n7V9mComPzkPzaMYALtq2KwTHS6M7JRKesbxkANti34fQNnILM+xmXqrDIBfwV6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAReLQk0lm6URJdyOAIuhgc1UODIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCCt5sd7InFIv4b\nGHHk++3NMH9EAKvyQwz+V43kw7mmvQIgKdRcERwyo5RaEUWK3PoBeluzGnQl8kxy\nmS+0P/CdqNw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4934", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4934` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISATRRUmSzXAtqjMZOmnF4JYGyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0ZTJmOTczLTEzNDQtNGVmOS04NWM1LTZhMzg5OGNmYTBkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI4ZGJjZDYtYjYz\nNi00OWFiLWEyZDMtODk4NDYxNThhMTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/s1K0TUL9tjsjM1yqr1pvdWFrKWUySmeghK2cd8douJzIFuOfBt/fCUC8CG9\nViaoppYc5Q2wkBlJXwmcSi+m0aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6YJhuOfqUnmw4dC77KuYmHBdtV4wHwYDVR0j\nBBgwFoAUjbYnyxs7BKEdPx5UhJzsJFqymwMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHoR1UkPtxLMssAsPGM5Vw0Ii7lLyjY3Do+mRdqG\n/+hMAiEA7r/RGAKF9NIP7JXfPvKnpOELGHgGPhZfIbWNoMAO9RA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaPUPVM2IPlBV5EdwLtNrDQeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGUyZjk3My0xMzQ0LTRlZjktODVjNS02YTM4OThjZmEwZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwD1j77Q1qTm3tq5Gt4yKTD0p6zvCzr/yZb6Hee588HQaQ\nLSMOSt/6tyEFujo8tu8oqwLBFKs4NImuKSj0W2bHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjbYnyxs7BKEdPx5UhJzsJFqy\nmwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOi19JlhqIFpgLb6mhLcDpP8DzdiBImgKQBxn8I5vZ6PAiAnmduEypVq\nTvcF/G/ny6yIiRwmmiENf52lpmhtE4FaBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAYV60zHLmM6IFl1bitrR40nNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI4ZGJjZDYtYjYzNi00OWFiLWEyZDMtODk4NDYxNThhMTZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGZhN2Q2ZGMtMDhkMi00ODFkLWI1ZDctMmMwZjlmMTdm\nOGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdR+aNUCxlaqbOKQ98mouGelw\nlGcoyKQly+GYwfjXjkxZMmT5JiyDe0KOWYsipOaSR7dY0bqrAAoJ801wNj/6+6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6YJhuOfqUnmw4dC77KuYmHBdtV4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCxFN+kL+no/zwo\nnezLNh7qaIY7o46FZiWhruXEpGq8NgIhAKe1RCVkIfipzAdA5D/0BBDQAhsO0xPC\nJ2TPu6Q//ChE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4935", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4935` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAa9KgAJ9HMYQCgngK2D1ujDLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3ZmZiYzg0LWVkODMtNGRkZS1iY2I3LTgzMjA0MDg4MDAwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFhMDRhZDItNGI4\nMC00NmNhLWFkY2MtNmFkNzBiMTgyMjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhWZQu5S9trOctlVoEqswrJtwphcE0tQEnOEjTWdluM1q1ayS1WqcyDf4G6qn\nzG+Adte2N4vcklL8/IjzLVJZHaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo6jzsFETu3FPKnkUygxiiON3nXkwHwYDVR0j\nBBgwFoAUhKYg/0oBny1BamGGSPnc8DkSNwAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCZi7JK/tMen+e5rCLRC8PF5lOQNkIwIFmRIkAG\nWfexrQIgd8hpkikE+mlRKYSlrE/iZMSDD54Qj+sHUxBmbQf/Bl4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY0OQ6CUSdhrBwYHAbXEFs89MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2ZmYmM4NC1lZDgzLTRkZGUtYmNiNy04MzIwNDA4ODAwMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARl9++FKq+ToearI6wct3Tqk2y/HAvt8NqOWmnGpU0ZKq5z\nQBT4fyuDETg/jK5/JQsOb+D4fLgidvXvbJdaPz+yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhKYg/0oBny1BamGGSPnc8DkS\nNwAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI3j49qx7C46UI3+q7JVl4LEcAPyu+77D6U/liRjaO6kAiEArorGT4Q0\n3Vw04C6QvbGvksL7vXMX4UlTQljdwNoWCeE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAf4sDKqXx2oz6QcYbWvv5Nf6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFhMDRhZDItNGI4MC00NmNhLWFkY2MtNmFkNzBiMTgyMjVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWFkMmI3YjktMWJhMS00Njk4LWE3MjItOTJlNzlhYWU0\nZjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfWdxxkdc5L2ZVK/LgRqBTlrI\npRDG0YB00iIdenbJ5eZTuyFmuwvLyweAAn+dAT5Gr4uL7PsltQW4ySEvJt7LFaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUo6jzsFETu3FPKnkUygxiiON3nXkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCmxKRi5E8LQYyX\n85tDKdkWdnPE7mMHGU1IrUcQuhLKxwIhAMQuYGQ8iCUQsGZF+xO/rVKh6Oxw4CYL\njsHaCYLE/3xW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4936", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4936` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYEykTCjf8G+bODBedOl8kQmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NmE0ZGE3LTBmOGYtNDgwZi04NjNiLTU4OWI0ZWQ4YzZhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWI1ZTE2ZTEtODIw\nMi00NjBkLTlmM2YtN2I2OTViZWU4NzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJlwKD1r5sxL0PDt0DsF5u4+0xriFJOfN15riWRWCLxxX8NsakbI1esakmrYj\niELtbfBQZcpu4Jt7P2uVIsx0eKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSd/max0m+BIIGlr6OYkivrK1HVIwHwYDVR0j\nBBgwFoAUtacSm9PApqc3UL/klpERl4KVUvowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQD91Uvjv9i7JvN9XNj6YFb0BILFQxSdEQz7YmdR0F4QWgIg\nBpKhIqUawd6wehpd7tew513Iwrk2P0rUjS9q9MGNk1I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUS7tayhn+noCEWX7ZUXrtj5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDZhNGRhNy0wZjhmLTQ4MGYtODYzYi01ODliNGVkOGM2YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARd0GjwpUhsZeAMGCpTUjO52irUoMH+bOpEC1hgrNbyxz7P\nQnFciPM3Ist9NRQjpVYPsN/XmScCqYBJhpaDJpmMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtacSm9PApqc3UL/klpERl4KV\nUvowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH4EWAYpM+Mw47DqEs4Jq9563frEvXfsDz9RIxRvTwqoCIB2N9ZxX13Dc\n3h6vPgV3BetHi3jHA1icoPrRocC6QUFO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAddU7PkP/U8pxvoiMA0VF7zVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWI1ZTE2ZTEtODIwMi00NjBkLTlmM2YtN2I2OTViZWU4NzliMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGZkNWU0ODQtNzkwMC00ODBmLWE3NzQtMjg2MGRhZThk\nNTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEStQMPqPvA1JADWdgQq1E451R\nD2H3IsHBTSwdkYmbI6TFCoAipI+hZfyESggk1Y2qzuaiews/AMDJYcOTfvObu6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSd/max0m+BIIGlr6OYkivrK1HVIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCeblCLhH9NqVK1\n0vMa8nKO4XICLlaV58arRa5fdeRkwgIgJ+NzsQAo1fjj14lksjlzQntQ/0x3WsLh\nTlcIZ22V9HM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4937", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4937` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAaonGfanYte6Jfvdr1+D5HrCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YTc4ZTZkLTkyNTQtNDY1Yi1iOTE1LWNlZTQzYjVhYmExNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE5ZTZmYzQtOTRl\nYy00ZjhjLTlhM2ItYWU2YTk0OWFiMTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh7bLl6L+75bS0GKbepOtMd9BJfNgZw6yWscGv3kDIiOHlEBEoil35lJibSi5\nHTBH2F9VRX8OZLJab7fLkCbzlaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKXuXNLsKbLbZMwMwPtNapA9jnMMwHwYDVR0j\nBBgwFoAUv6uBdFGY9rvxiA1bv0H4069989UwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCkI0nN81EoDncrU3Hf0LrYRE/xyDpR\nxTL0fq5796y2CAIgDyZlUNncKkcT3/PCfwLAMhdFqEP3fZAo5N4lXErhiIE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUPYXnvkZmBgTpq0hvXYo9KuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWE3OGU2ZC05MjU0LTQ2NWItYjkxNS1jZWU0M2I1YWJhMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyxPD4ivMUjQwZ22q1Si384w9eKIIoTfzr3h/joWJe8Kbw\nsw6loHs2bfE8z89JtDou4V7mZ9HaJSPaUr2lMJG8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv6uBdFGY9rvxiA1bv0H40699\n89UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANMFviOnZU88CwRZvTliKw2L1Jhhx1svaDCmWX2M0ZoQAiBcPJkzuRD4\n5Gmlbyiawl52sWDYQvX7WFh2coG3aXbXGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYHZ89waFKqdyu/0KiDIdpVSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE5ZTZmYzQtOTRlYy00ZjhjLTlhM2ItYWU2YTk0OWFiMTVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzdlNjY0ZDktZWViMy00NWU4LTkwOTQtMzMyYTA4ZTky\nMmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETCKJYw7kziKIc8/5FR7twymN\nOzZp/5lfdJe0y502c2uEBo3up9Ja/3UVhxwDaHPGpW64GVTPY9s05LldBXLX2qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKXuXNLsKbLbZMwMwPtNapA9jnMMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCUKem5prEsUR+u\n7VaFD8LqdmCKZO9qRqGnkyr8n83DZwIgTmKyrYNpjDgU701Siz3h4YmrMOW6OKtz\n5LCvy1TtXrU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4938", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4938` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAdQuYTHAqqAKpGRoDa1ITiWaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxNGY0Y2U3LTNjNDctNGZmNi05MmY5LTRmNjYzMTVkM2FkYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI0M2RiYWMtNDkx\nMy00NjIzLTgyZTEtOTNiYTJjOGUyZjEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECqAlF3/Ed5eRZKWx4/7AFKv/8CmC+7N1VzT3yhJhtZT/TjL7KCFyhIr5y0/R\nc88LY9Le19e1YzD0R/JHClcfD6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ/uHViR1GHEAubHZV+K+3C/VRBowHwYDVR0j\nBBgwFoAUDDFZ4jCeT4Dhda+VdP8MuY96nHEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEb0yqjmlPwoWhn07QpzUFLSNTNdziMl\n/6JJRnTBKeZbAiEAoBsogGCGiChKEfbZWXgq5zfdxR9gH0i3PFPk6E0bQkM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATaNg2mr9Xh3d1Ki66gYg5KFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTRmNGNlNy0zYzQ3LTRmZjYtOTJmOS00ZjY2MzE1ZDNhZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT51FcoDtReDyVZ8U/m9ojxI2n+uKIKqtrffTfLsZID4Qeb\nq5+0NmK660s2b7M45k4zrEly6i2XFS3rYxRvtYg5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDDFZ4jCeT4Dhda+VdP8MuY96\nnHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWyFsoJnC6vh8xVaV2znsgGzF4dSQSQraW69htGsclNcCIAdybj6nRuIQ\nt5DDgNtqEYIcRV+pDQd/1kWu73jKYqzo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAdkePlmvu52tKHiJP166mMPpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI0M2RiYWMtNDkxMy00NjIzLTgyZTEtOTNiYTJjOGUyZjEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTU2ZjQ0MmEtYTgwMy00NWUxLTllYjgtMmU1OWNkNGQw\nYTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL+TZHGXT9FPSwso5fJYrMfpI\nZcV4djZx0lljAOIOy2akc0e2vaOCjO8q0byXqF4bt0gb8+cxBW0nCOqrEps9fqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ/uHViR1GHEAubHZV+K+3C/VRBowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICzIZiPSi8dQsC81\nBP4fTMihBh6HR2kKQ1R8ZCM8wEkDAiEA1QwCX/Ki2WqzEBeCaWnJr1OOM/D882No\naY4NPP1kr0U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4939", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4939` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASa3biTCK94oOZvH8WwdwBljMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhOWRhNzgzLWQyNzYtNGQxYS04M2VhLWMwNTJmODVhNTk0NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjcxM2JhODYtZWY1\nOC00MmExLWIxMTMtNzY0ZTA3YWU0ODJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY9N9laYEeL/87esOafqaoHCH0BdQilwahwwotNCw2o+0OH1+oFG5hACKvgRf\ns1AMM3RA8RTINHZnU8pUM6xBDqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM1PVSbXp3/84NnakBboj67ECXPowHwYDVR0j\nBBgwFoAUa7QDHjZZQHmU8BkANpvsmumeGKkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIChfrQqkrpjr\nnt1T8YEpUM3uvLI7rTCCBTf5Kc+GH/Q/AiEAyBTjN4ITmYHaIcHqz9aMi3amDY8l\nevVEhzDofGJdKYA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASoaviz9E1H0E9uYfOlr7LTcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTlkYTc4My1kMjc2LTRkMWEtODNlYS1jMDUyZjg1YTU5NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQakn9KWIJwCV5F8CHtcVxOR2fUy7gNjhSbP8hVbRkmb+9Q\nHzvFdJ6XIGVxjiSqaPvslldlwih8Ulja2WIphdVso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa7QDHjZZQHmU8BkANpvsmume\nGKkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNo0jxCqvphyD6ocjimgmHJRa54LJVIjZ4TJvlgy+7uUCIHbUj7SkE14U\nEAolzyWn8AV4oMM19HL+1AQkmDXAl7pt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAe1g9tqOwcs09oKDbzOHwxPGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjcxM2JhODYtZWY1OC00MmExLWIxMTMtNzY0ZTA3YWU0ODJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQ5ZDkxZWYtNTFiMy00OGI3LWJlOTAtMjA2Yjc5YWYz\nMzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4wtUWEZqUrqvCdd07C1+Atdf\nF5EQOrZo0/IinQlwwEaPLPhUhT+fGsfEdljzRFkoAC+ZO0dARpKBMOHFYDcELqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUM1PVSbXp3/84NnakBboj67ECXPowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICNqaRggybH3SyYT\nrxWgnrJk/Ezw1r1k5sXkfOUQMJFIAiAVMAEtb9Wzp86jg0hZ+CxxbQ4Q8aPophcu\n4JemNcuKPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4940", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4940` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAbZ5iELIvYCNhDEcytEPtI0QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlNGQ2OGQxLTZkODQtNDNkMC1hMTcyLWMwNmQ5MDA5NGM4NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmViNDljZjctOTMw\nNS00NWEzLThjODktZjZhYjk2YjlkY2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAvRtjWQJowc7VZMbSpwcPRLvFhd8GkHfuPos3m+kedNXgebH4mSn6tUjk/pD\nwAICjJekOjzWaqgPU0KSRfcWj6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+860S4qoH7CAA/Rnk7IBAfbfx60wHwYDVR0j\nBBgwFoAU63h2irffORfuy53913yfp/G0Z5owNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAK/7eSQ+m1C/KB62Z+lE/R0d+M+Ua/7TwqnTkCI/ijSOAiB7a30pLCWU\nmPgEzWC7i0LO/mY4mzFpksCKJUbsfmwhRg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV4QhqaPaNomr/ZfHucg7McAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTRkNjhkMS02ZDg0LTQzZDAtYTE3Mi1jMDZkOTAwOTRjODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvbPqnqQGQFzc4FffoPIKVaVWowUof+337PzGlUZIV3ihf\nDx0DG3rxa7fqVUWD51s5J0K2t0DN19IYuLl9GhZAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU63h2irffORfuy53913yfp/G0\nZ5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJnT4aKrmpFhgaqdilW6EnaSR4Ew//1FU1KhRiut5SAqAiEA/HdujUyS\nPI6ZNEGBdQom0P+8lJFgDPnUkHJKp1XoRe8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAX+sk3a5vdZiXdISgDlkLbF1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmViNDljZjctOTMwNS00NWEzLThjODktZjZhYjk2YjlkY2VmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGEwOTFlZjEtZTc3OS00MmZmLWI4ODQtZmM3MjY2ODRk\nYzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqkcYT6kx+rGpTlkHkQPpFZXR\n7Nm3vANS0N08GSz2mMrwln6jOykMbIOCkNwNkzpUEiBj/f4JPPAp8fxB83CLmqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+860S4qoH7CAA/Rnk7IBAfbfx60wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD6Kh/VmEbVwN8a\noPLW5208It+knMJsBYYhie/YTz97DQIgXjWhQ74M1plL1X7aKiBnsT3MVMWqfMPi\nM2MUEovKfIU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4941", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4941` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAac2zQ6pTImrK4HF0Pbk7dmvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwMDUyZTQzLTAxMjItNDZjMy1hYTdlLTU1OGVhY2Q2OGY4MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWVhNGUxNmYtY2Iz\nNC00ZDczLTgwYmMtMDRlNjY2ZDRkZWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/d5wdKn+cslStWpX+PM4unOm96dY/7Ws8hGEGa9hZLLDggHBvS8kRJPvj2GU\n9IBz0o2TSJyyK6FerkdIq+iAYaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzVfesoHhFldDAdSNhPnWTBBIua0wHwYDVR0j\nBBgwFoAUgktiVbb5lgFXmbdldeUb5ELwAVAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgWiiAi0z2M2S/RjYajaxsJYlU7IgxPy3hdDBlDrffAxcCIQD1kX2UeIJW\nvTUXosFgRxGr0Kbxx/27W5aE+8Xk00e2Wg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeApl/nc3kr2+owmkd15zo06MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDA1MmU0My0wMTIyLTQ2YzMtYWE3ZS01NThlYWNkNjhmODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAtAekHHTGxIPMc0EJHAVp64jtl/NyLvNc+dXbL4ofiTxB\nwICb5tUXY1QJ7wyLG22CQ/Ai1OPdJOOinyUrEHwJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgktiVbb5lgFXmbdldeUb5ELw\nAVAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANzhYWTfnb+J10AUenW7hkJRginEIl6al25ER480+/o+AiBaH0RZjIEJ\nnya3uHIYwzXx9XgdpFQwk+vdISzPXWFNgw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAcTiHo2PvVxVw7x4Mp/f9KqFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWVhNGUxNmYtY2IzNC00ZDczLTgwYmMtMDRlNjY2ZDRkZWEzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjhiNGU3YTAtMzRjYy00MWIwLTkzYmYtZjYxODRhNjEy\nNzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC1/9481hnhXQ2YzJI8/4NLZg\nfgBXQkFX6IY4ep6pB0t2I6fA6x3a1tjMVUwRXG5HcfLeKOGbytCE/1lvSge35aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzVfesoHhFldDAdSNhPnWTBBIua0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBcCJScr3AJcj3XW\nARTQOU5IAW3A+siVVDM9IZSWLQTZAiEAlJYZYzHI/TCeLYr/W8WIlHXzW03/RdAm\nR1UudF/EY1o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4942", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4942` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISATTYBZdkWhILVCh4jPaBpaWiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0MzU1MmYxLWNiNWUtNGI5Yi1hM2FlLTI3NDM0OWU4YWM3NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDYxMjZjZjctYTUy\nNS00NWExLTk5MzAtM2FhNjZiOTRiNWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFzVCmvJHdrkSqCskQezfeySUCumtkYBVe6TZKVmmiwd+Ef12lb21EEgWx3ql\nZbnRVIOoLmchFwDUMR2ac3k3rqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL960/KSmldis51tRzMifYHx+YbEwHwYDVR0j\nBBgwFoAUG4/j4sI5JxKzU7wdUJVuc9s1geowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDuST2ujfIOUckhAjqKPO6vRWJulMe/CLsxYTI4KQ8GPgIhAIIsGYWB\n/RVQxxLo1MIWH6TLIRSVNckIYOdMTaUJObTv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWIOY4xTHXy0v9SCwTTYg14uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDM1NTJmMS1jYjVlLTRiOWItYTNhZS0yNzQzNDllOGFjNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAST9yE9aCl0q+PfsranDDABw0ZuJSXdwfbrsdQEH046lG3l\nGlBakrSpkwDbs00eK2tY+753Y3PMXumZG1RD3PbNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG4/j4sI5JxKzU7wdUJVuc9s1\ngeowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQm8CliF4dBpg7knEgGQOsHl9krqEWzgcCoLb9isGYU4CIQDELvV6Uq3E\nmq3Gcc3NtpnlKMtZMEZHZYqqZY/+ZXz6vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAdZhFvf0RUle+yIN8YTQzOOHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDYxMjZjZjctYTUyNS00NWExLTk5MzAtM2FhNjZiOTRiNWQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmYwNmQ0MTMtNmExZC00OTQ3LTljYTAtZmY5NmZiNzA3\nMmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvOCZUpHNS1MufNb38H75BX6U\nYocLmITPXRi4l9oBFYyLOZPlMQOPADU1ST1Tcb4cRz/anT/O2GQTYeApIzCURaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUL960/KSmldis51tRzMifYHx+YbEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC01laQs94rL4cn\nxwaP7rhFP02UYkDhTEdqZTy/oUQ6HgIgO+q4hpvtEXhSBtrRDun/AswdXZcztUVL\nJaTmFPA/uVU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4943", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4943` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAaN/0L0sBvRpZxCRqq3Q2LRcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczZjc4M2VjLTA5ZmQtNDEwYi05MjcxLTI1YWVhNTgzZDliNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTE4NjVkNGItNjVi\nMi00ZDQ1LWE0NjYtMDcxYjRlYTczMDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzGQqlryDSfh6aCC8M2V+sR1nritp3VxBjqkcjEs2wWTcigMiol2IGwFjqVuj\nH+Kupvpa6l8BbqJe1zaMy4P3WaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1LUANjvoo2OUP6Mf3VX+9IXTAhcwHwYDVR0j\nBBgwFoAUNr08kVdblCF/jKwrd/uifntXmlQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHIc5B3GXroFMLYGVE65CwLvCEUJqqFQi/5DDW30\nWY2zAiEA2aD+1q7cCmRMYHrLMCCpD1lX60vWQ5Nd4RYoMpGj+KU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASpCQBadgSGJD+CRg5wmrvo4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2Y3ODNlYy0wOWZkLTQxMGItOTI3MS0yNWFlYTU4M2Q5YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6pERSB500gHWe9Lvpncc7VGrU23T/VO87DQSpxsZ3Zg3s\nrTgg1DiJEqw1k3PHF7oiN4hPQus+bcqYKN0SL5Ifo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNr08kVdblCF/jKwrd/uifntX\nmlQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJkMw/mPewVI1PP1rsYOerkUgYIhaACTiaOgD3ykYdk3AiEAl1cX5tWs\n78VvFroL2bvj6YBtcPOmeoL6N4pO5Xyr6mc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAce510q9FyQgAEmR7TsdGxepMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTE4NjVkNGItNjViMi00ZDQ1LWE0NjYtMDcxYjRlYTczMDAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmQ3NGZjYzAtMzQyMS00MjBlLTg2M2ItY2M5MmJmODA0\nZDM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2PgvU8oOL9dbDKycSA0fA0hI\ngXN1ZnIvNyYDF9ujAQTkVcZhXZFWPOkw4AHUPQZ0LW1UbbF9/UgkCri45eVdVKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1LUANjvoo2OUP6Mf3VX+9IXTAhcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDDmnibD1gHtHr+\ngT2913X6d5Z3jSYTpfkdFI01Np/TiwIhAMAXOMYYF/1qFqlXPTFDKY35aSX80+0l\nSqntRJNrWIhg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4944", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4944` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAU7qixnWB2KnFsYcSHpDXyoiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMDBhYjdjLWNhOGUtNDU5ZS1iMDE5LTcyOWI0NzEzODRkODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmVlOWVlMzEtZWI4\nZi00MWE3LThlM2ItNmE5OWM1NTU4Y2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfxQG1uwv+4fpGIWNLBL3SwdIN2F+58rvPw5gOhTsVDmbNzDc49LPaRshGOpZ\nQBtlGvh0TWxLAMI3Ibs4x5El+qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAyWOF2sq/v/hpSjrsxqP5UFG/KIwHwYDVR0j\nBBgwFoAUKrhEzb0YsSl2yP8q6MGIsZtUIJowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDqjuhvyKczVm7pFoyPdFnRU1EUwJYekoQTzUAZ\nEpq/kgIhANYMzj7tnSVO1p9jcvjE46J347sf0vOvThP8wsoztfaa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXG4nMSnHrQLuomD3FIEjjcXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDAwYWI3Yy1jYThlLTQ1OWUtYjAxOS03MjliNDcxMzg0ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEFSgPueCiWNSv6F5FJ0YXVsk4/z7P4NNpEpKwfPFhMVzw\n5Ym+SzIu7yex0z29BY44v7XfIeecbzSrG4ItLI2Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKrhEzb0YsSl2yP8q6MGIsZtU\nIJowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFIdczKXHapExJs/r6ZtlCyUSVL6o7CIYQ92Pe4WPNaQCICup61c/0f67\nL86AeuSJ4eVfVjKzJDqyY9F1wwFAq+GZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZJjL97/KS6VDXE4KOBDsZbyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmVlOWVlMzEtZWI4Zi00MWE3LThlM2ItNmE5OWM1NTU4Y2JkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDJiMDE3MTMtNGY0OC00ZDA4LTg5OGYtMDgxMmQ2OGE5\nMDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN9Blc80VlD3r3dETUQBuAEtb\nKELxH5Ii6nAxDwnBcB9W953PVHyOn+wSRzb8naycSykMUZ89BYnyY+g/ttaDBaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAyWOF2sq/v/hpSjrsxqP5UFG/KIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBlvT/yDkz7BOeGz\nuz2OAqgLou0tT40QyJ9g6EJ5T1oaAiAxyGkuX8Wc/i1ckUUswxQAZLHOBnyR6o2T\n8VUwwfC+Pg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4945", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4945` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAeyiwlpeQS0JnELDyTbwG0GiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwN2MzNmEzLWU1YmUtNDg1Ny1iZWMxLTVmOGY3MWU3YzE5NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ0ZmE3YjMtNDFl\nYS00Nzk2LWE0OGMtZWM5MzdmNWZkYjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2K4sTMJ6OhGBTCHm7YutlfWeVWkS/tTYbhRrN3rCdVERx3LslvPz9NfLWdwf\ny4hmR3Qb20Vt2GtI3znbbT9FjKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUchpAmy99p+B7CJ/NWxLFF7kaAPMwHwYDVR0j\nBBgwFoAUN7vFv+Y2m/fUJtN2OOrm9el8I5swPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDMe9/UAXfhZhjMS4oUFNtAEFa9RA2f+Q/Y+Ql312qMKAIg\nOd+jMlUl11IOz2duhRjsM/eOAIoyLQKUgKoIgneRu34=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVbY5G0BMH0FJADqQr51oIi9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDdjMzZhMy1lNWJlLTQ4NTctYmVjMS01ZjhmNzFlN2MxOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeMyXGMVdnXTHT77vEyQfkIewzH+0d4DVs3Nbd2+ldW+oe\nH6HbVyIJLw/UKcNbIriWbW7owjYv7tuE3GPxkZMjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN7vFv+Y2m/fUJtN2OOrm9el8\nI5swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPK1RUKXglkwaCFUvUov2yKaArDYONfYthCUQG/PmDaHAiAJ+yPEKpEY\nHvbgy3MIA+yWb+gDTahZdppG8404CXvOPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAe2bkoSfB7MGB7X5oJMPdk42MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ0ZmE3YjMtNDFlYS00Nzk2LWE0OGMtZWM5MzdmNWZkYjBlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjY5ZjVhMmUtNWFmOS00NzU1LTg2ZGEtYjA0ZjNiN2M1\nODdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVaDMRykCdZBeDM19+j6/ISbB\ntTkoiPqvWlf4Mobx4S/Bi9miRscMhLZfFal/qmdHHLQP8AXT3cKSjP0nBIYDqaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUchpAmy99p+B7CJ/NWxLFF7kaAPMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGojzA89U24Z6WoQ\nL1Y36caTNMgCku5RFb9ikLlYrE88AiBDDRFq7El2Z6gzAnrWqoryQ33DxeT4Zdiv\n5i5iViOTXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4946", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4946` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAXj8U9zi6K7qzlkaOVO5ybjNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhOTllMTM3LTE0YjgtNDE0NC1iYWMzLTM0NDE0MzExZDFkZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDIyMzg4ZjUtOGEz\nMC00YTViLThjN2QtMWNiODVjZTAyYTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcW5h37LmnezoCUi29fbgGpuae6YWMcLH7y4JeKZ8HphfnxPTO13fHblBC2Ik\nBfK2nE8IXYg9ECr87JXyGpy1BKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgvRs1pEci52/sy9Jul0Jv1a5GS4wHwYDVR0j\nBBgwFoAUnx+FWi6lZTSl22JdCe5iWJ7IYTwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDcmPgtyg8pf/PCIdrWwpsjl/xxUtk5\naIEqyeTtMTa4LAIgLB8RcgaO3GXmNqBPFmjJ1v5JEBMNlvWYa6SneFGepeY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASntgtWYqbJ4MnfsegSIlW/wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTk5ZTEzNy0xNGI4LTQxNDQtYmFjMy0zNDQxNDMxMWQxZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlTHQF2r2wf3m/Kdwp78VXlpK0/ZMGBJtOX8TWNIzuWljB\nrAoSP/UFpOvwEvIQAJd5d+dzmcERxBdbfn1WhSeYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnx+FWi6lZTSl22JdCe5iWJ7I\nYTwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL5DPkXFVlgBdn33sH9lfJNYJS8TiJwPJRIcMXFziOg5AiB+T5rsaGhk\nOjVLhcMCAKcZQuUAr61tBJ1aKeNQrL8bYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAcRX2Ssm8wGUaiEW9lmtNxzmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDIyMzg4ZjUtOGEzMC00YTViLThjN2QtMWNiODVjZTAyYTgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWI1MjU3YjUtMTYyNC00ODg0LTg0ZGMtYjE4MzgzYTIz\nMGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcts4WcapJEAF/YOd1WDBZx1J\nIqdVslmh1Sa8Dq671uT7XbqxQ+qWCS5LRzlfoR3B6OqSrzrptNgqrqm2G4EQD6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgvRs1pEci52/sy9Jul0Jv1a5GS4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFwStpJcwHKRa5C/\na71QJYFgeE3IR46EwdIKDwhBQPP6AiAv24D+4dqF+8HcSxYKpG0syyFjIfRJaPzS\nHT86Mjg7rg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4947", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4947` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfqtiqmZu1klIMT0Yqa+REHsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNmU1OTIyLTRkZmQtNGE5Ni04YzM5LTgzOGE3Njc1ZWE2MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVjMGEzN2EtOTRl\nOC00NDFmLWE0MTUtOGYwNDQyNjk3NmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYfBfXyptYyXVtovCjMeCC3DlM3ki1W+g8OaPzGQJrxS/cHDmJ943kOqelhN0\nlbJBR9CxQNDXgvcC/LORxzgKb6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Io7E9pOTCooyXgCf5e5nkG4vhgwHwYDVR0j\nBBgwFoAULXQodgPow6eUs9yrK2QIgAE+yFwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDwdAlsSk1K8OhrpS5//4B0iQrmZDLDY\nKDNUmDGEKsuMAiEAvyzIBxQUqzD2G1G4jW7qRko0tnIReQ5h895mXRKjtBo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASLpIShsCKh+DB7JHIwvCJmZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzZlNTkyMi00ZGZkLTRhOTYtOGMzOS04MzhhNzY3NWVhNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAqizdz2izscmVZx8f5whJbqw39L1gGGsJwVcrKU0q+ZfZ\n33OUWNvQZpoVdvVRtWaHfLqUPJZqCHVi65+CDltYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULXQodgPow6eUs9yrK2QIgAE+\nyFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaK5uqAbZDjf9/LKF335Bq4Bp51w1AJdMzHEYXKG2NrwCIQDnjEHgQHKh\n//Fx7diaVIaOXFJMaAJ3sNFZBNgBh5gEXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAQWrWkzkCfdcEyjDvLw7BT9mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVjMGEzN2EtOTRlOC00NDFmLWE0MTUtOGYwNDQyNjk3NmFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmVmNTE2NzctMmE1Ny00MmU5LWI1NjYtNjk1YTZkM2I0\nZjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9i39+0RtFBwkS026EdmpfiaB\nl0/lg/mSFSXRMFnOvpE71Z19cG+bGczdne4hD6xMJa4ZwUJ3j4EbY6+K355HMqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/Io7E9pOTCooyXgCf5e5nkG4vhgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGSwuYnjzItreiY+\nTd8LlFbo4el57d4x+WaN785TVPBJAiBU9Chr0ckky9nM8WJWG1jb0w5gbfG26TH+\npJUDBiFIkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4948", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4948` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAb5eI2oxw2cEPHonb7iBW00kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMzVhOWU4LWVmZjQtNDhmYS1iZDA2LTYyMDI2ODZjMTFlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg4NWM5NzYtZDQy\nNS00YzBkLTliMjYtZTk2MzgwYTVlZjBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPnatyCOpoXQYQAH0pX3amLovFC93+gs2cJm5/7odzcFpUZA1NpM5QHTW5Zci\n/kU1gRqFGJv5oETkodwqy2oRoqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJa7p136sFdkWZe4C92yFyZk/kl1MB8GA1UdIwQY\nMBaAFL2widPJU8Pp80Z6M0Cfc9q3sudRMAoGCCqGSM49BAMCA0cAMEQCIFNmPYsb\nVtoohtVZDgEkO4tMClaxN6CzQzdKhZgg62bwAiAgVmKpUf+YJkMAiRQ+cwsLLk6F\n0vu9dN2COHpcZYPi8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUMx3zifZCl0yYcLVYv0GWfRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjM1YTllOC1lZmY0LTQ4ZmEtYmQwNi02MjAyNjg2YzExZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASm1g9OX5NHTfqXnB63MAXUVbzzIBtP4/vEt9wcsl43gmKZ\npnFAso8UACPpz6/ln2me+WvsfWSJILpYmJz4RjJOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvbCJ08lTw+nzRnozQJ9z2rey\n51EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMTiA+5L8vMzu5gQLgXyVAS2ZCokS6n5S7o1R72okoV3AiAs+efOFAG4\nYKu6QMre6Nu4gHnc1JEViIc2GMPxF7gffw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISARXyP4A795NrmewsOHFRZHJ2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg4NWM5NzYtZDQyNS00YzBkLTliMjYtZTk2MzgwYTVlZjBhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGY1YjdhYWEtYjUxMi00NjI0LTliYWYtNjhhNDdlNDJj\nNzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpQ7z4nPlfnpuu8fCsWP+qN9g\ny/pje/eQv76h1KGvTeSBrY5Bcl/Vq68ZXdyB7/AI77hqthwBRKvjfMYUkYxyOaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlrunXfqwV2RZl7gL3bIXJmT+SXUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCG/9sH\nQNE97XHAb3xXzwQXIXzyWE5OXk54mKO3WJjWpQIhAN8yXFLzVbYCIE68REn53KmE\n9lpFSBcCiiRaX8qxA9S9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4949", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4949` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAV+ztP2gcU9gRT4/xwtQ38c2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxZjg1MjU1LWZlZGQtNGE1Ni05MDYxLTliNjI5NzdhZmJhZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWE1YTJiZTYtYjE4\nMi00MjcwLTg5NTUtMTEyZGEwNWJkNzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEpxJim6Q012E46OYXIIUtB4wZK32tToP9LWtcpGO7CAfTfts0hoNJ0s+bfIJ\nXA5ejjLVWpzfXEPjltNYsfnejaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLUqZYhulnvV8q+MYPxOmLvVZ0GdMB8GA1UdIwQY\nMBaAFKzPiLJ2tMxoygHP88+Gvgf6OfwTMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBHmxVMz/mvE/yqZAz/uJPq6Bs03gOYHq3y\n8/opaN/IHAIhAKED68tdJm4TUYoHBCbO/vJMNcAfd69bHWmSpMyz6J3/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdQRmYjl6r4tHGavafi4WKGJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWY4NTI1NS1mZWRkLTRhNTYtOTA2MS05YjYyOTc3YWZiYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt5AO7B8PTRR2Cai+G/b9s3MQEz/w91lWYBiA7glQX9/Yi\nW/m/dsWNOl1+Nll0SG0FhTX0lDuKRcJ8Mjm9tfLOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrM+Isna0zGjKAc/zz4a+B/o5\n/BMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANZeIs1lktCGFdzrpWUWg7q5fPuiEtCWHM7y50+tsKS2AiEAzeSJTxxf\nfR55aT9Go1aqy31BRjralZI3CyM6aOsGaFY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAahPsx+UnxKLfkOFe5SnKVKlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWE1YTJiZTYtYjE4Mi00MjcwLTg5NTUtMTEyZGEwNWJkNzAwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjIyNjA0OGUtMzYzNy00MDI0LThiMTktZDA5MDcwN2M0\nYzUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJtSi9vr7jT3O0mktCbZk9u7I\nWr0U13OvSjYY120GwIP1M66VlupBiO/hFBRRpdxh2oRwnFDDMKzicNBVQlBjBqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtSpliG6We9Xyr4xg/E6Yu9VnQZ0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCcVqty\nMYR1mrdt2TY/UV1ljS0/9rnWMIBHIm2GvO1DxAIhALfRvMBXP6Z0+q1yEySLMTq4\n1MiJN/ulNUDTDSfHdpQr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4950", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4950` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAScfndonUUtRky/Su/nr+epgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyY2NlNTBlLTg2YTEtNGUwMy1iNDgzLTlkYjQ1OWJmYTYxMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZkYWNkNGUtOTA3\nOC00NmNiLWI3NDUtMjMzNWExMjkwNjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/EQgy6ieXj2v3dyR/uUMfhqyG57mtJB8tMG8VONhC4GpOLkym6+Fli+OA76M\n2K9dS7Rcxu+UkMMGRaS4WanbXaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFB2IzOpz5AAAfndHeFxOtrGfzWm+MB8GA1UdIwQY\nMBaAFCHSFSloAbJUeqVyOkHraV4lNAzbMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiADkPWdb5Pd/DSXw3/FqcBVXDnLa6RfMFo/\nvcw+fOuQagIhAMYNSicUTEs185ra46u9VQRknSaIKZbhC81jfyOXEMtj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcxw9cHrFsOThqW0USH26bqQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmNjZTUwZS04NmExLTRlMDMtYjQ4My05ZGI0NTliZmE2MTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSUkdKdlaHSVs30ZYfHOjUv1IAKfxFbaxytYYUSCO0dRd6\nK8I2pIm6nVX4FlXTm6ilKQnDwVnTIa1ofIBCQOTTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIdIVKWgBslR6pXI6QetpXiU0\nDNswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJfYtUK1M1/c4QBtWMFrubm5F9jt1TENob5mOz7BrvG4CIAtY6Mqkvb8P\nPOAfFALAe1aBaZ/CamHd/4i2BuewVZQp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVOWx2imMJh4yRr53+s/LtYsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZkYWNkNGUtOTA3OC00NmNiLWI3NDUtMjMzNWExMjkwNjM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGE4N2Q0NzctNDg3Yy00M2Y5LWJkN2UtNmM3YzkyMGM5\nYWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA9wKqtTTY3MeQeZzlUhZkPDN\n/Nw5hu9sqINKWNjcrHcA1OJuzYUrIXxMe+ARbeqKFrFaTkpb7K5BC3cHYO+peaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHYjM6nPkAAB+d0d4XE62sZ/Nab4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD7HsXa\nLCBHlBgBhMZTD+U5aFs0a/ChlTKX3+ZHvhlArAIhAONf3s8hg3vQ44HsgOXvr6Xo\nzaPwDNhOWWiKsyYf4VAv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4951", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4951` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcIcbbltRyLYGKKVIwd05elLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5YzQzNjE0LWI2ZTYtNDYyNi1iODVkLWJjNjM0YTMzMWM1NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RiYmRjZTQtYmNh\nNy00MTIxLTg4YzUtNTgyMzBhMzU0MzE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuX6s1LDG3dvhFKLrcXkcGS3SSQrLxPsqDgTsmSz44t7KsttaKEprx7UP5keG\n6uZpVta0qNNyoZjzwplTUJfzY6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ3SfhYn5tL0w8fSKQsjWIF+Rj/WjAfBgNVHSME\nGDAWgBSJx8f7zWqs4jLRMX9TEfx3DGXkVjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCidsNbsOtx5aIqjTw+wEgS25+pr3QC\nThfLDaegH059cgIgGMgbRc1XiTg5i0EmLUgqERdwCTmE4l/q7pWHgRl1JHk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfv5dUA0k0vAt/kLNGk/Pz1UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWM0MzYxNC1iNmU2LTQ2MjYtYjg1ZC1iYzYzNGEzMzFjNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEHm7JEXd31d5EKPrR9Q8NusF8HyHgtaNqmixhCkIBXvqn\n0rvZ3NXq1WjS0aHrHjob5LjjYvSebQPe3vDWMb77o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUicfH+81qrOIy0TF/UxH8dwxl\n5FYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANII/4G6BISFzUgX3TUrMzvJ8DleIrI/EAm4aCnoS2XnAiEAnpKTrvGA\nYvVHZLNXXxFzOYnGanXOLxjInP3OOY0CWM4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXSSEJIL3L8xoQdi68nFJWIhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RiYmRjZTQtYmNhNy00MTIxLTg4YzUtNTgyMzBhMzU0MzE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODYzNjBmZWYtNjM0Yi00MDZmLWJiMjItZmMwZGJjYWFm\nZmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx9bEmG+/RlD1FCWgiPcXKZEs\naaOelu4iPVy9fMgRY2lxeE5bwNusDoBDcf9A+k/LVhxPQLO1BDXd+EocO2et0KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUN0n4WJ+bS9MPH0ikLI1iBfkY/1owIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDiUw+sX\noJb8yk3VGsEorMBPeSIlOfd4Q9+CwZfJozgBAiEA3A34OmDGLJx9lB0GCHLuxEL0\n+IE6sLUEQZ2eOujUifw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4952", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4952` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAY6t5EqcP8VhifjGNxOhnIKtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2YjNhZGRlLTc4ODItNGQyZS04ODgzLWQyM2NhNTdmNmNkNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA2MDQ5OWMtZmYy\nYy00YmJkLWI0NWYtNmE4NGFkNWNkNWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb0ezAUSrDYgrZoRpRtky2K6irCnmzdsMxy0rV3Rv+6hYk7JYZQIuhgHbUD2+\n5zyNPIeM3zxot0VCJsdWwIIrfKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx/oqeGCpWkGnrhd1lhAXfpUGlHIwHwYDVR0j\nBBgwFoAUMqGh9s2VQKc9RwCGblvHCf7zpbgwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiB44u1A3u4UBM2Z\nJIPVpaw9QXK4I6Wigbub3ytN36PvDAIgRmfdsfiGBBLftIZ9/IESF+zxxZj9OK3U\nmcWA9WrHoIs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU7MG7LEyCRqppVZGxZgXFtEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmIzYWRkZS03ODgyLTRkMmUtODg4My1kMjNjYTU3ZjZjZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfwF86LuLUdkAbIXz9yQMYM9LLkzPNH53/91Nj1IsI756S\nnUwhr05SCnG+bcyNH9kNkgh4W1L0kv+ZLOjaclO8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMqGh9s2VQKc9RwCGblvHCf7z\npbgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE7uH7h49ZlIQ4VdlTCIVsp3DoWpTMXdOnHv8/KF5tZACIQC0mGkRTHUQ\nZ9VAhqqHlOhmrej+3A5oeE1yMUz4k9L+Ow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAT2ebzSOkYk0P99ds/Vkz9I5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA2MDQ5OWMtZmYyYy00YmJkLWI0NWYtNmE4NGFkNWNkNWI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTI3M2QzODEtN2VhOS00MDg5LWEyOTItZWEzM2E4MmZm\nZWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgEi50TdxXhl442G+wlh4fU5d\neqnSp6pbW6HtvNTPjp8LvBCSVV4Oxtt/ZU763rp/dhrFsKLvyWLDjs+oix5NUqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUx/oqeGCpWkGnrhd1lhAXfpUGlHIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC3XYPB\nSYftea57sSOVxGHz1OV1vAkBZRJfQjK+rU1ysgIgXPxVhU4vvriBFAoU3uY6nKbx\n8c7BYimymaiq0YBuOv0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4953", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4953` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAQO7m6v4soNgLvQm9ENIt3E2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzYzFlNzU5LTE5Y2MtNGE4Ni1iZjI4LTgwZTExNzNhZWE1NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI4NjdmZmMtYTY4\nMS00NTlkLTgzN2QtNGNmZDA0NzE3MDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoOYKxCczdsssI6hDhjEur1uLHSNQLvG9vWPJrxdbzaFLritQkoLqBsDQnsnU\nJG7z9VGLe0mthKl0ZUEuqjN5RaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7QWscgeTevW3WitM44J64gPLLWkwHwYDVR0j\nBBgwFoAUAJVauzSqV1ahbzEeT0FMD+HIyOkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAvqjuOCCpqI4n9\nHsQgu9C/e8uS5uLSOj3nYAPeQU5kXwIgF8z7QwntMml0dgDKEJaBZXx4fQUelNIO\ngg35OVu28QQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc3fpn4YK/uCJrDWU9q5HdAiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2MxZTc1OS0xOWNjLTRhODYtYmYyOC04MGUxMTczYWVhNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBoIne865QXI9W+qq5oEjlcdDwpXvZfUTvlYcvcvK8Wy2P\n2fH505Xpxdoo6MmCfkfad0D0Jiv3j94zUGAYFvwoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAJVauzSqV1ahbzEeT0FMD+HI\nyOkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaxu1fDBHbSFap9AL6PmqYgYtkrkTIh6q826bjjZg/q4CIEdjiFHJX0P1\nTMP5bp+TBmVaV4moLmNh++N0Xfv1R3/z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQCOxj5atintuRQs7GqZ4XmNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI4NjdmZmMtYTY4MS00NTlkLTgzN2QtNGNmZDA0NzE3MDdiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzc5NjBlNmQtZjY1OC00ZTc0LTkwMWQtZjI1ODdkYzYx\nNWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfgvdNy/2Pwo1GMFn7Sx/E5At\n5kAbvpMJcnG6dKW1sBF/oSCiYntM79jVgvrV9eDRiYp8lsWZA1oZKPxRVgL4EqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7QWscgeTevW3WitM44J64gPLLWkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGYt/U+K\ntXh6VEKdeCVixfsj7S1hJHdEDIB012DbmqxKAiEA3F0xsshEiuWKy+p8/4dWxyhm\n//JTi7KXhlcraXWUllY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4954", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4954` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAf2J2JN+m4EeN4/eIvbWwlhsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1YzY3ZTRlLTY2ZTgtNDFkNy1iYTE5LTMwNWYwZTEwZDAzZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEzYzdmYTctYmM2\nYS00NGYyLWI0YzYtMjg5MzdjODhlZGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqDyx77XtOw/tFn80Ir5wXuaT47ELU3AeYFxM/jVGSuDYDrSGnIVzE4+wp9oI\nUAWDXH9ntCcKZ/vQxLFFgS7LoqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU5t22jo8RfzM7tPaYQrt2rhtVqYwHwYDVR0j\nBBgwFoAUCKnkULeYV3umB3/1fQxQuzlAcZ0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAt6NS3dAmyz4oXTCrRAaN\n+gF6Sj6NPHWwiMhOgXhbb0wCIQDnEfUTIiUVTkWhahW2jmG8cQggpERlwEU2Artt\n4C1p7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaBrSL7GuGGws0p0mCW+JYWGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWM2N2U0ZS02NmU4LTQxZDctYmExOS0zMDVmMGUxMGQwM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2aGxgkgRJdyrob8gYKu82d3GsgrRv7Z7Nb/OPKaV3sNe9\ngNfLNNtd4Ws9E9NtTp8otoibneqbAXYmQo1DEGKho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCKnkULeYV3umB3/1fQxQuzlA\ncZ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL/PmZEJKF+KBRmezwsYiKhv/y6O6IzOMbpJ7Vo7LlTDAiA3Lsv0r1eq\nN7E+3tYlhol98uD5lVrPc+ycZgCGJgCezQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXYYz9YBRwJBUnIwVegvq6UqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEzYzdmYTctYmM2YS00NGYyLWI0YzYtMjg5MzdjODhlZGQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmExMjA3ODAtMTc4MC00ZDdjLWJmZTgtMWJiZTM1NmE0\nMTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESGTjBsaelC8Cd+ez/Sjnv8Hy\n3xeRfXA+fpiFgAKLZ/OoFae8mjTwpxt6b08NWOJQXqrNHJScxB4LOtwxPJ1Sk6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU5t22jo8RfzM7tPaYQrt2rhtVqYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAXch4UD\nWuf9yopz/+PqRwSp94RdkhSqumxddUue36muAiBtMB6LEbph6ZD35A4sT10gAQr+\nnS70olI2fSKwzhtVnw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4955", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4955` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAU2cQxO3D9rb+FprIlLHsc1PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyYzBiOGUyLWY4MWItNDE1My1iOGRhLWFiYWExNjAzZmUwZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFjOTJiMzctZWE5\nYS00OWYxLWI3MGMtNjE0NTMxNDdjZTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ9KGn3CR6wcU1j9pQCDhsr4aeqdar6Zp7+OYQK1aDetrSYqJNstNanA2pR1a\n7Mj4wILynSaRr22LiUkJQ0LhX6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSnkfYGoVQpiEtdd3VmIaN37HTzMwHwYDVR0j\nBBgwFoAUD2G2NoCM1JA8rGInn+bVL+Ix16gwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA56Zr\nV/CZrO3lySj5qUkTvdb1IFnt+9NlODfVD+1b1S8CIBVW8dz0sSGywsZY3ohBMa2Y\nUQZopHCx1Mb+opsmIrcg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdbrTl6HnSEpCak6wuG0L/RXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmMwYjhlMi1mODFiLTQxNTMtYjhkYS1hYmFhMTYwM2ZlMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYDocsCBFBAUKJpy9/sap1h6CVd1KRPgpGAdrYaDXCCpfS\nahs3tHWJstF/2bxUKHmkvV3QbL9RmKMxfkB2r8SJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD2G2NoCM1JA8rGInn+bVL+Ix\n16gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJUghIBu3ME/3cqnKgdU47hFHbLAqPm2kzCJW6ifnwqcCIQCeUjyRSmP/\n+ZPAwNR+Ppj+u1b/FP+QpGdBUgTZxe2ZJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVQZvPohSKIu/nvAS+IACGumMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFjOTJiMzctZWE5YS00OWYxLWI3MGMtNjE0NTMxNDdjZTU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDkwZTYwNTQtNWVjOS00OWY0LWJkNjItNWI2NmQ1OWNm\nNWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEIG76Wyl4IV0ZvDH6Dl3J92t\nDOzlrMF1+B58rg4DE5793M5aHnIoqJrtLu2B+UmWkJJH3IQ5+jpfyKZ2ENjC3KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSnkfYGoVQpiEtdd3VmIaN37HTzMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGelFzvA\nQZR674nMnQnRwTBeAn/fXwr9Aazk44+VESaUAiEA8r5zouCTMCOzcwG5WpJf09jt\nocB9hKcQiY563TzZjjI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4956", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4956` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISARxrf35CVPXSgxrhwEyNlC4RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1NmQwZTU0LWU1ZjMtNDk1Zi05MGFlLTY0YzgzZjg5ODMyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODAxNzA1ZGEtNDgx\nMC00ZjkzLWFjOTItOGMxNjFlMWI0MmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvDadarUq9LS0CJ/ldoBJgx3MmEcSMKXcAwYvKNRGg9CvyTSGJ+I6m/0jw6uE\n4IkmIVRu7SbE4KC2PDj3pkbaL6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDP8Dhq9EN+dFHFuzs0ajvs6H2ycwHwYDVR0j\nBBgwFoAU+QDqN2CUSY0NfTiVdePjKZ2OKyQwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEApGRy\nRaEX+wxFGLyPLLHUziSgxMivy5PJRp3kOLDfJkcCIQDfTswfo3g/KP//0P33HVK+\nXbLMvIhK34t3k+gtotU2HQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQaezZgyZ4QqWdebpvkp4izOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTZkMGU1NC1lNWYzLTQ5NWYtOTBhZS02NGM4M2Y4OTgzMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToVSSRhm7/x1mI3gJStD85BodNz62nJmOVjQB2yxNlEi2Z\nwOZptTvOLsBbZg/o6EGd8Hrlgz5uSs2X/6/TlLyxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+QDqN2CUSY0NfTiVdePjKZ2O\nKyQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPJwm/s1vHn2unnfDQaHSqQARl/z1qrbY/N8n1s+TQdgCIHXJw8HVZfDb\nUaf+7v4DqJV5z2Lg+cTGvsk+SeYByCh5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZMTHPhgZeDndyLum+L4E398MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODAxNzA1ZGEtNDgxMC00ZjkzLWFjOTItOGMxNjFlMWI0MmYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmVjZTI0NmEtZDE4ZS00ZWNiLWE4MTgtYWM4YmNmNjcw\nMjBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyv28dHD2TO507FdAUTlxtykm\n64QzRMb7zeJp+tShfffJlGNH6hvDXMZJBQLo0XA7/l1/iV0A7YQ1dFYiITSnHqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDP8Dhq9EN+dFHFuzs0ajvs6H2ycwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDRIyPCI\nNcrBEkxMVJYVfa6GVc7xJtU5LFRB4qhS+fK7AiEA6nuFUATrz9Fz17SBz9cGfssa\n+RtEIx2ztv4eWen2t7o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4957", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4957` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcZoBV9W2HCZtwxQMA5yevkGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5YzI2ZGI2LTliMTQtNDE0Yy1hNGIwLWMzODNjNmZlODM1ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI1NjUxMGUtOTlj\nYS00OWYwLWIxOTgtNmM2MGYwODBkYjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3fHsladtgDrvVpKamFkGemka/xFDNrrcEHEM32qR8asOPxng0QsSsU0jcpI8\nLH9Ufxe1zap6Yf32BE8Lh4j69aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFG5rW0CoJQlpye8RFybWHMMs8wEuMB8GA1UdIwQY\nMBaAFIdWEhFHOW9weq/hawcglyXXStcHMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiB69JuhCrEY3mH4KxzQHiQGBvkO9R5vGFlS\n1mZbB0KZyQIhAPPhOKs2WYwI6WCZ2NafsYeS4MVfs7y/TfpSxr0oTu5V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARgBUDxPVNJJKrFFAWAinSReMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWMyNmRiNi05YjE0LTQxNGMtYTRiMC1jMzgzYzZmZTgzNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHP9uCVHj6/2cYgHK3E3Npq1Y09Z0Yc269VccpP51inAR8\n35D1QGSYpsMDtPtRQIWdvh+zTQ1WnsKA6Fz0AqELo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh1YSEUc5b3B6r+FrByCXJddK\n1wcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLK+y6SN9uKM28j5D70L8iT5Ud3TjiR9I74yTfl/AwcACIQCFPP6dDfUn\nsN8EdjSSPRWNGUz6tbonHXWGD5BKcpy8qw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARN4PoV8/R2deqHZl8D1CpEPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI1NjUxMGUtOTljYS00OWYwLWIxOTgtNmM2MGYwODBkYjRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzgxZTMxOTctMzEyMC00YmViLWJjODctMWVhNmMyOGMx\nYWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvvCdf5YpLi57Gf9w89LuDwIu\nQZ+hPAwTR955NZxZKqUyPo1aPyQfvIKJCKAgKEr+0RaWSWVJxUkXzUbaFJF1hKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbmtbQKglCWnJ7xEXJtYcwyzzAS4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFtnKihy\nPvVSyGjiQwiaL3Ub8jaoDLAqpd/YJfQQBVuEAiEAjcCGYSCqVPnaTP2NrLbeRx8y\nKU4oh9Kbf6BTNwKHCos=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4958", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4958` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAZPobcSEpmUsWMRY0TVZh6HrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmNDExZjA0LTk0YjUtNGI1MC05M2ZjLThkNDYzYjlmZDJjMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjIyNWIxNjQtMGU2\nZC00YWNmLTlkOTQtNzM1NmMwYTJjMzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6CeAbqS/LG2QRwFviaryDsHT+I6AuArPN7bOhDnEoDrE2bF4AKeUWe3IhiWd\nEdYA3BGNG78gq5bA2zzBa87nmKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzck6sYW6ZpxnOTpQfUKb86+y//EwHwYDVR0j\nBBgwFoAU1QELLBkZz/uww/RR7yNDOsA5KfEwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKizsUUV9Mcy\naTHmA18uOBACXYyN0l6AZv6D1iORHsPeAiB0eiMKxzuw72j5l3tfLBKWjICfD+aU\nXvFGEjhVj2XxKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaUAFekRWzy6FcM9GdRX5wNzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjQxMWYwNC05NGI1LTRiNTAtOTNmYy04ZDQ2M2I5ZmQyYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMMw86oEORSoruA/04er6l7qZ0Rpvc0ypyO5EQnelAFi5R\nYaYrzaueoXDLnWO3wCKzSP8VPuVDt3tKlKNFBqfWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1QELLBkZz/uww/RR7yNDOsA5\nKfEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK9RBhviofnnIt0+MQQUHl90FpDdN/oEr+wpGUiQ5z+DAiEA5UY6Co2A\nRuFL9rRtmOlXzlY6noYtlYJqX7l3Psjiv9w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAbJmnVWujPlsebLYLhlLKJj9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjIyNWIxNjQtMGU2ZC00YWNmLTlkOTQtNzM1NmMwYTJjMzc2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2NhMjc1OGUtNmNhMS00ZmI0LWJhYzgtZTQzZjIxOGQ0\nYTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEc9SdlM0EsxRiznZL4PAdlK90\nZTpu/bt8BnymTeV1v5OUByAWCxJjF3eWXQ7UlQM2nQwp+7mhVS2IDsMkeECwn6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzck6sYW6ZpxnOTpQfUKb86+y//EwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDlAIOg\n82zCZPKH7hXzrpqSszgMu37+X0NT2FzfTU0pVAIhAOWA6vG4BBaFYp8sJZS5vY6d\nLNGqRvrcGEJ96uwRdXoc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4959", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4959` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQy7oP7+XtrZ1VPv0d1bRsyPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4ZDUzMWY3LTc2ZmMtNDA2Yi1iMjkzLTU4NTdiMDRiODVhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjcxNzgzMWQtZDI0\nMy00YTA0LTg4YTktY2NmODhmYTFiMWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtWSiUNo0HTh8j5oSvsupNqkcJtb4bdM6p3Doe12Ozv28rFhhfzlgw/e7TCxY\nPULGSSqvupSu4JbNTGyKmch38aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5UWWL5PMrCTHHCM4IsM7utmnFIQwHwYDVR0j\nBBgwFoAU44zecGJZ+VwPPtZEy0zpQ5HtFAgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIS8YuPlt6qE\nNSv5YEg16PDmc4OSgfoi1Xm+/GAQKCyOAiBizWxv3RLiUAJxbXK44n0ct3hDSVSX\nbzWWRm7GBb04SA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASnbWJkpifkrlxzTDgR5frXaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGQ1MzFmNy03NmZjLTQwNmItYjI5My01ODU3YjA0Yjg1YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuGBRuNCShCOGKNdZDTtwfpzJHzgrtTmAWn8v4WkrtAmaA\nzxBl0BDXoG2dDvC3Ji7Ofur1vmfjv09g2OZsp0I2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU44zecGJZ+VwPPtZEy0zpQ5Ht\nFAgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcGzH9hCSitkwN/mxjzQfKzPjbLn4HrllvVNMhzYYzvICIFbUvD+Y9Ldd\noRUoPk/3PKcVvQYI5/cO/EZtqZDxBMWr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbMCACyrD1ZnhkPCXn9L3XMuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjcxNzgzMWQtZDI0My00YTA0LTg4YTktY2NmODhmYTFiMWM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2UxMWUxZjItMWJiNy00OGNhLWExMGYtZTZhMTU0MzA4\nYTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm8UCSxY2rN8oZ6rV109Z42tu\nRKvtW3tMsKAakPTaMSstMac4XZ9QKWaGNU+nXjmiG6VHaz5Bzf3fjlX/4GwqpKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5UWWL5PMrCTHHCM4IsM7utmnFIQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGK9DkHB\nF+V2kYSgW88XaUp7X4fVgfG9eYnHoHIPtQuRAiEAg9MqbHsd07XmJCR1yFzi8/Xr\nsi3OkA2/UJgO1Csl/yo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4960", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4960` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAe12NKgh8srCh6as/NT2j92MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1OTg3MDdhLTljMDgtNGM0NC04MTBlLTlkYmE3YmMzMTQyNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYzMWM3M2YtOWU0\nOC00OTlkLThhMWQtNjc2MzdhZTI5ZTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV5QbQDKu4yQ/cV/VpWJvtJBrPdCYj7n4G/8swYL904PAcyEmVgR53unTZIyI\nqVrk+cF7x6swkn59hKGwBaazS6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNGKY4cRwXZ2GE4Z+J/PKkGyEDpcwHwYDVR0j\nBBgwFoAUOSq5PG0aK0Nbni81NaFF2bx35tIwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDttPU6LcWX\nRFpYqfEF1Z4v41u5M6ZTarGAIFPmcryT+AIgfeHWWopo4qs+T5aMbhEqNaVk+gJW\nRuzy0f0ADI+oPDU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZYlGjDejIHJTRNQ5FM2x+EjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTk4NzA3YS05YzA4LTRjNDQtODEwZS05ZGJhN2JjMzE0MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQikoL57kAsFxGlsqqfiPXfpBIUadYijV1T8L7V3paLMXYr\nr5fZlMnJfiEAmpLKGpZBJv621TngUn+5Eu0ERGD9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOSq5PG0aK0Nbni81NaFF2bx3\n5tIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMZR1sMkeT6JR1d79SwDNsIeIuhOgM00QM7dI3qC1pbLAiBA1gyOetRd\n1PrDEjdR+ezyXQPtz56eOF0DRR0qgI7geg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAekEhMYeKOPmTEbaNSaj1/58MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYzMWM3M2YtOWU0OC00OTlkLThhMWQtNjc2MzdhZTI5ZTliMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTRkOTMzNGMtOGRiOC00ZmYzLWFhMGQtNjA3MTNmYjA2\nNjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcYt40XKPs1LS13DMcamMnNIk\n+7lnAR+eo9zaGYYFatDMmC9YKyXlSkGWiSx0g0/1jFdXc/AEmAvorT3pgo58BqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNGKY4cRwXZ2GE4Z+J/PKkGyEDpcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGWuLir6\n5sxLYATa95+FJqWP4d5E5qWhaiFlNsApwk23AiAlcZubUf/8nc+50J/6FcOHqdZZ\niIXcnU/7lI1Hq7CXkg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4961", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4961` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISARvHIKX6MMc7t6nSNL/PehYYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MTU0ODdlLTNkNTUtNDM1NS1iY2Y1LWY0ZmM0NGQyYjU3YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FmY2VhZDYtMDYw\nZi00MDIxLThhYzgtZTNkZjY4OTY1NjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEykTrAECcvTtLL3jlh7ewz8UPLHBsTm9MSnEYwuj0FTIf9fL8vV6w2P6hXWpI\ng+XsLb5W7F0dmgcnXeLo8J6RLKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmrVTDO82kLLX42Oz7QkFNlkgscwHwYDVR0j\nBBgwFoAUNz1OzAMhRcqGFqqs1XbYVTFs714wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDi75hQOIvs+tWgJ4E5sMybhhq0K2Zztx4Ov00ig40AoAiBLbFt9LmTsfcEV\nzlTJtl4tY4WR2myx2FcfNCNmDIto2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfb36L41iPuzPhyLUfWSXZKKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDE1NDg3ZS0zZDU1LTQzNTUtYmNmNS1mNGZjNDRkMmI1N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQp2MvtnFJ+bDjCA9BNOduyOQU2oKSo/dPLR/CkHe8DTkJE\nVuiagt2JUWtBubUcrGNOGiedui6/b0TFuJv4hvNjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNz1OzAMhRcqGFqqs1XbYVTFs\n714wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO2hdHAItu6yqL1ftbfW6iIbzMojfcba4nPZSq0F+UjbAiAS0vjUJT5V\niNDG92YxdOxksB9DFms6q6TTXocqAkGphg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVed5T0v9aUbDyUYDDcu+JAEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FmY2VhZDYtMDYwZi00MDIxLThhYzgtZTNkZjY4OTY1NjBiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2EzNTk1ODUtNGQ4ZS00NTk2LTg3NWUtMWRjOWI4NWFm\nZTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBzlRHLRbT3tV/ZxPWG6P5KJ5\n4X8qHQ6cD8Kc/+er4j4r8Ts9jJF7PHso/awdgy3ErLaPImVVxf2oPadPMzUcDaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhmrVTDO82kLLX42Oz7QkFNlkgscwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCiV613\n5nyCyMnYXERl2wOleBQ/HW1ZZ4gySzBp+MksMgIhAKcSyxIZb++8qs0bLnMVgPJf\nd9YPGAQG4liZGjWI9v5t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4962", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4962` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWPJfWwSDAgg6sZhluskEcY7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlOTBkNmM1LTAzYWQtNGNmYi1hNjEzLTAzN2Y4YjZhNzI0YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWI1NzEzOGYtZjU4\nNC00NjJlLWIxYTItY2FjYmNmN2I5MmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECaYrEs6rhzTNPnEANgfyw45p3xUziAcUXCjKAyoc9YZEKh9qrvjvB2tzQfGC\nPV5BEagLbh2TcBROqh9vVHPl/KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZJCRGAv1aOT036wwaun6Debz+7EwHwYDVR0j\nBBgwFoAUpHWnSsw7GFENfHo4ckJ4qURhd7UwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFV8CIo073CcE2gW7uJ4IHigI8grAlQk+GHGyAyaJfGQAiAA4ELm+9hE9k99\nJ7HBmNN0YtsODnU9TrHglZl0WVDLDw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbr7myZaec/46d9yPho+D2CQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTkwZDZjNS0wM2FkLTRjZmItYTYxMy0wMzdmOGI2YTcyNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDqxkSvyHnBNmZ9I1QmO1AyfCbYKKbM8N5O53jyJ98m4tm\nseVAfbQOvOg8Su18lZE9zbmGTI9LL7X0mbnOW3aeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpHWnSsw7GFENfHo4ckJ4qURh\nd7UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANrsE2eFRHqYsMhtbgsJzoMJn9cNSHvphm+J2APFCEy8AiEAg1qtYsQI\n867qsEYh9ZDRCa5VmKPvXBqGgI4GyKyKsNo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAX5WcPEwXFygEys6Xpcb6Dh1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWI1NzEzOGYtZjU4NC00NjJlLWIxYTItY2FjYmNmN2I5MmFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDNjNTBiMGQtYWNmZC00MmU3LTkxODItZDFlNGZlNDQ0\nNjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE211CfSNvotWal06iMueaILn+\nPY9lmR0HtmzVEMpuyLeuUn9x71ZpCydUf3EJSwOpt5s38k57OcgF+BGGjx+XNKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZJCRGAv1aOT036wwaun6Debz+7EwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC8jTGM\nItIR3u0I7EwI6Q0wtG0HrP7YqisEpu03hDh5CwIgRg04oWLdKr75aq/wUF8/QKwt\nx8GZTSZ3AsxoQuAyRPU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4963", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4963` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISARHK4KEt57B/B016x7ZfbKV+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwNjhkZTkyLTA3NDYtNDdmZS1hMjUwLTQzNWQ1ODc1MWQ0NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThhOGZhZTQtOWQ2\nMC00NmMzLTg2ODAtMGYxYmNmYWE0ZWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo9xSUB54YzpluoHUm4YgMGk/hV0Hg/1oc4DdWu3c0nQSGCRUBR7jaglEpfKO\n/gxsB/Wn6/9p3RWe0h8N4SRvWqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQdhvmdiZonYQan1SRuC7kFXBYR8wHwYDVR0j\nBBgwFoAUT9QvSvEN/Ht8KddA8s9iUd5S2q4wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCC\nOH4bDz3LfQkR+e5du7vvK1Gso3+w2nox3qq9HvrHYwIhAPJSwimjsdmMYQes+MOz\nazkqfRyd3FZLHMe7pCkSRUZN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATOSL4CeNVFVekIMB80psisYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDY4ZGU5Mi0wNzQ2LTQ3ZmUtYTI1MC00MzVkNTg3NTFkNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIaYzpkLNVnpyR5XONvp5A7KyZerlYxCOyLuh4uMHWToc3\nmh034nwczFnTXrJi/3jV6gpf/TgSoSgHpVn1lJSFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT9QvSvEN/Ht8KddA8s9iUd5S\n2q4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOJHHbWqap/dhGqnnaNEQXLskk5syPAjUXGRi6uZLB5DAiEA0vubJbY/\nwwvVnEeDyj6nlxweGCmahaKhODGXOudian0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAdG/ZNU32TCDCBiEesuErURzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThhOGZhZTQtOWQ2MC00NmMzLTg2ODAtMGYxYmNmYWE0ZWI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2NlNmIwNGYtYjJmYy00ODQ2LTkwZjItZjk1NjgwYzI2\nMWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAGUqhlxTfRGzsRC9YtG1AwjA\nQYUcFFTBvdCgbPZPXCnC/n8cUg6oQcN9GBlSPz2Ffhuy4yzyAorlpQscAGsGF6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQdhvmdiZonYQan1SRuC7kFXBYR8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQClqPpu\nekPPlgx+9gBZpgmtzBhKNGrXVSdV7rbJ6iep3gIhAPhxZNYLCOLbHnS0G2nL/ZHV\nFrRj92vMU/XM6Q6RKLqx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4964", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4964` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISARTLon8meLK0MAuDVbUWyeJRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4NjQ4M2M4LWY3MmUtNDdiMC1hMTE4LTU0NGEzM2E4Zjc2MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmMwM2NmMzUtZDdl\nMi00ZGJlLTg2NWEtNGFlY2JkMWUwMjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErLArevYqhXgY/LiEIvdG3ruqjWA1TwRRHTzUTdYAVDBL4RKKjzSjT1/Zf2Fx\niH+6OHrdMNna1frtU6yfvzKXgaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU71ZjsUMYkOrYfxy8rwLSNf8Fs0wHwYDVR0j\nBBgwFoAUUI7IhFsxGWGHiQuvLjBqgGPEe0gwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIAYHUBw49Xqshxut2og9m35Ne3t9oB1J2CkyYeaU7tOaAiEA1bNg\nBCLGe0I8yWWzgY/x2hYRRAuQRMuXz35ZLkNrIAA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb8PR17NaLsAraJg32KrPe8yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODY0ODNjOC1mNzJlLTQ3YjAtYTExOC01NDRhMzNhOGY3NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6A/8hW1YPUrSik72Cc8AHTt1ppHf4zlD9iCfytPcSgHzP\n4zhEQ0ef5crN5YgECndB3c6ql17qxYetWPAXyDwUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUI7IhFsxGWGHiQuvLjBqgGPE\ne0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDWjJS90ZL4wVSfH3UJrLskz+rK7Yp3VMOJ2kspQNgdICIBKOi8FHA7Z5\nnzaNOSD/tAq4h/f4UiYkArNBfOGhrj7k\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXD1Hklh1WiW/kVFWXxMalZ3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmMwM2NmMzUtZDdlMi00ZGJlLTg2NWEtNGFlY2JkMWUwMjFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTZhZDEzZDEtYjYzNC00ZGFjLThlZjQtZDljZGJmYzY1\nOWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV+sLUbq0DxvsGSnjHoNzCa49\nt4WyzbFDuKqxlk/m5/Fz208+Knx2tHptaMGPfEpCEXwEvwngMnzKUUwD6AkoRaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU71ZjsUMYkOrYfxy8rwLSNf8Fs0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIA6RsQ1X\nCroP+ioYiQl96FIofM/6zzUVL80psLPwCDTMAiAH7zl6WwmD8o8uqibk4M5mIXj0\nFYsvehQ5uART25oUaQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4965", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4965` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAeaZ4QhgoFBInmqUePhPA8PkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4YTRiZjZiLTM2YTAtNGI5Yy1hNjNiLWE3ZTMzNzFhMDE5YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNlNTdlOWQtNDVl\nMy00ZjU5LTkwNWQtNDk2N2FlMDQ5ZTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtZKqT04PK9W8UGK3+jSGAMqyMjDxKrRuWY1PJlJLAZgVj8r1hZUuh/YgCUn2\nW837G+T3NX6k/QbqHFrk1toEcqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAUvFnHEVP8LVYyRuVR4CBbLdUmwwHwYDVR0j\nBBgwFoAUphE1BLd75k5mrbWQ7nhkunhn0Z4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDCNmhHIoQPK6oJO3ST/ie79pD4EAnNAk2dz5Ggnj7/IQIhAJAu\nKUvqoq3dfR+Jyua8pMwRWdU3pSrmKslQZKvuxNTQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbDtmZwlV8HLm/C083LxvFPUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGE0YmY2Yi0zNmEwLTRiOWMtYTYzYi1hN2UzMzcxYTAxOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARonQP1FRY1nYI1i72Uc3dlzIbJd5QMgluN2nnrvMR4nSRo\n0TxgcpbkILjCvgcMN/H7n+8+2iH0QkbAe/uXj9eso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUphE1BLd75k5mrbWQ7nhkunhn\n0Z4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ6+Wv5dCCQk2MT/mzdUNevZ77WSWAX4uEpaaSG7skDwCIC63o5eADDs6\n+mLGuB4emyzgTrLMLdnaQtoBXjWF/8Ub\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAeux1xwYsnkmSLTVOuKSGLEMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNlNTdlOWQtNDVlMy00ZjU5LTkwNWQtNDk2N2FlMDQ5ZTgzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTU5MmMwMTYtMDAxMC00YTI2LTk1MjgtOWNlZjg1ZGUy\nNTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeB0XQesVvyWA/glY/vCSnIYg\nLwVoqMykSHetiBT79ojXmmLT4U7YP2lxpECaxzDpY09JCZIjSsdtcR3lLy88V6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAUvFnHEVP8LVYyRuVR4CBbLdUmwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIALrknSu\nC1sfGggtACfqnrs0vUDfoYdmK1k+lKCkdRATAiA15lsMtdzjSrhJvbJvSRJvjbOS\nP6abn15Rku5m+t1s6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4966", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4966` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVUya+7DsNXEXrvxDwLg6jyGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjZDVjOGZiLTdiZGQtNDNhZi05ZWRiLTBmYjVhYThhNGZmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFkMzFiOTctMzRh\nMy00N2VlLTgxNjItZGQ5Njg3OGFkOGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtxk5Q5iuGh8+5JLxC6P17HlB3MX0/QaxbKbTyzz3LK9YZz27cR5svRLa9pjg\nDaoEhAbMSZerXcMI1HjhBxVAa6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEaPax7gzIjHKAw26UjKCkvNrX+gMB8GA1UdIwQY\nMBaAFI1C1IU6c7iTC54s+6HdZBk0TEcXMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA14r5fybRQjNM380qlmwouhJbhrk7c7ndz\nIGY9wuSnbQIhAJliNNl/kKO2rsUveoHhmu2n2rrKzM1J5crZGlmfFIjI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcm3HYXfdRV5GaOLnwiBY0xdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2Q1YzhmYi03YmRkLTQzYWYtOWVkYi0wZmI1YWE4YTRmZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnpd4Luwqyl5aMVg7cSIZbXkfQ8TZVYifO8i7dtZpEAcVv\n4sIS9877eO9GvOv5PCLqVtftQCUWQZUQiXXtasD/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjULUhTpzuJMLniz7od1kGTRM\nRxcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJdpRtSDnKu/rIGSJefpN4WkXkALeT2/UuSn8MWNHDmnAiEAkle1xSmK\nOfiVmNgPXzed6jlhn1zK+CVCE2U09+tgIws=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAR3OsTdMetnc+3xhiV+1aXSSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFkMzFiOTctMzRhMy00N2VlLTgxNjItZGQ5Njg3OGFkOGFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTBjNGI1MDEtMzExMS00OGUwLWI2YTMtN2IxOTNiNTE5\nNzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+obqtT0qMjKHLq6K1C8aihlE\nM4DqILRyMsFsve+h/0CsR8LQRwPwWhDFqralmG+L/abisU6P53+ycUs/Xe0njKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURo9rHuDMiMcoDDbpSMoKS82tf6AwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDJNvPU8\ndiejo35YglWg9HbcW+1Etm8xsebmNgnqkskvAiEAvQFTwJ6lcCQtR4/eq4P5cALq\nE5rowc1zxCX6BEULENM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4967", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4967` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAf9nOyACwgfGf9+NUVHAjJNOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmMzJmMDdlLTU1MmYtNDRmOC1hZjJkLTQxN2NkMDIyMDJiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM5YWY3MTMtMTc1\nNS00MjZkLThjYzctZGRlNWVmYTJlYTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdBj5t44k+G8Euh9G5h+zWwiADd7lh+QUSqN9Z5H8ngvREB+n524iwQmYyxAv\nlrfRDzOjCU1S7WlngRQ1Z1quOaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhhMRQTnyrbl7N45ZKyKSEdxgUtEwHwYDVR0j\nBBgwFoAUdHo4G9nIk7wbkcZJmtuct/oi3kcwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJyuGQy4ReNT\nBrKIidHCAx0aZT+KMRyJZIb5pwuj5JrtAiEA8Jme+sdZM8nO8lPH+VGoAkUs8ABZ\nwS9YgO/AyamYUHA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASB085oy+3fIUjYJtqjeVgCOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjMyZjA3ZS01NTJmLTQ0ZjgtYWYyZC00MTdjZDAyMjAyYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR85yNgcutC3gFYSefQ+bQ/i+miatesHrv5x1lyHoqu6I2U\nUKsMfSB3uDPCGGzROqbTGgu+olpxPyMS4EqABLQBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdHo4G9nIk7wbkcZJmtuct/oi\n3kcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMmLpFk584yDRbDqhVZzHrdPvKLJr/Xsj1jgtOyFAPfcAiEA0n27of7K\nl81Vzcl/WS8sx3wyN/pE+BcmT0Y1bsXPyGg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARCxwcf73IpN+qJkCNaCL6ZuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM5YWY3MTMtMTc1NS00MjZkLThjYzctZGRlNWVmYTJlYTc4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDU0OTczM2ItZThiNi00NjNlLWExNTQtMTE1MmM3YTIx\nOThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdKcNEdTlqD1ly7kJ/SmffPoX\nolTplWszSr3Q+WTj34vceyjUYtFQIgx0ojeTN/1qmK6uYiDpHvX7yYRms0EynaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhhMRQTnyrbl7N45ZKyKSEdxgUtEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCO8a0v\n0qu2fcbTn8RW6vUY0rCgM9nVlrPjhCTjq6PjWQIgVcxD4pDA21jmLQI5E5t6X/2B\nSWvVvzyS55lb2KlHsTc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4968", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4968` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAYGmxK09f2y+M+pVN2wnOznUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkMjRjNDM0LWU1ZWEtNDM3ZC05MWY1LWQzODNiMjEwZDg0YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU2NjA5ODQtMDU0\nYy00Yjc4LTg0ZTgtMGQ5NzQ3ZDJkNzQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETf7h/sMjZC7lBazOVWEz6RbtzsVhNohacM9YZG3l7Oj/qjstkB49T8sKQz2k\niVc/Xc40QF+CuYDEaYAeoiwA6qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv9E5Iz9ImCiiINKjfg5ahKtBjMYwHwYDVR0j\nBBgwFoAUPYAjwPBbWGFEB2URMJGGHxAWUvUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMy6ufFf0jEp\naaN6f+ggHrMFr/n6ZhP/CBX6i3yMe+aFAiEAzMC1qYJgcxCPvBdh1THukx4M6Bj5\nXUmjATZDe9oAkAM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATGwtoalBJzscVNFAx6Dv5ByMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDI0YzQzNC1lNWVhLTQzN2QtOTFmNS1kMzgzYjIxMGQ4NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToiOCkVcqDJZ3lffzB2FzOD15KRrPRs6O/s5mfmmAa82mI\nGh+/FgAgSaxxYoW+9hvUxudsHXZHVvTB4ZhiwOJEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPYAjwPBbWGFEB2URMJGGHxAW\nUvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOJus0G9t4mJGJK976IhBRdtu/UpgnoxaTt31MEHyVnsCICs1EoykQeU2\nlC1v33oMbPku6k/XgDJUXkYdDnSq+2Qr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAaKc89An7yzWggtai3OvFdB3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU2NjA5ODQtMDU0Yy00Yjc4LTg0ZTgtMGQ5NzQ3ZDJkNzQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGI2N2I5ZWItMGJmMS00MDc2LWE0MTktOTA1MmRjN2E5\nMDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMTqdfyyxJ59CbQ75Jvogzps3\nk9dAPwyuKzNQiam2PowhsuZhz1mM9+wkcDCqITkWONme9nK/VvLEbXbdZA6zC6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUv9E5Iz9ImCiiINKjfg5ahKtBjMYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDaT+ncu\nG1YcoOd/CgjceGqKnKzrlYN4Obw35cgaLvOBAiBuJZ9beXZZt2WFdA+spoZwHymf\n11TMuQmZGImTCT3Hhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4969", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4969` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASTLfy67BtZW3Pr5G/jo/3lfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzYmRmNjgyLTRlZTUtNGMyMi05YTkwLTQ2ZDIwZDRjOGM5YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZmNGQ3YTAtOTUx\nYi00ZWNlLWJiNDEtMjJhNDljZTc5Nzc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpoYaHrkg5U2OUgALeZJ9u01tenWEdNPr9poIpWW6+RlRry4aYSb0PXFfEqV1\nLpyFA8yz38BT6Kykpn2ONc0ql6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnEF3S9dUI+kykucZWutwLD5IRuEwHwYDVR0j\nBBgwFoAUXwQ8f3TOgmHX5sr3Oi427snM8xowKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDQw9+OUTFL/\nmUoGtOsVItDC/XGRfJbNiwaKSaAfeKjzAiEA8EU7n7fx/qZ3xBf/pDUsJ46m9u8f\n0xVIZw3MhAEj6aE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZqOT3MBgpjZcUC6WFW4rZQYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2JkZjY4Mi00ZWU1LTRjMjItOWE5MC00NmQyMGQ0YzhjOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmy4AE1lMXzl3iakIiLbcrdXjLR9wpF05tqbot9lVawurz\nu3EdTSRYFI8dWyQU7c3IogVSRys8/2UpzWRz3Hfho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXwQ8f3TOgmHX5sr3Oi427snM\n8xowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTZGdQqUBLi5JO9Cm/17Nnux8gb8D8Qziqw/YRPRzSxgCIBlQAtOF3lLu\nSRiXW/l0MKzgSAWPO5pwhM8maCV9Czor\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdO3jK3uA96Ni9U5cO8KlqM9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZmNGQ3YTAtOTUxYi00ZWNlLWJiNDEtMjJhNDljZTc5Nzc1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjVjZjY5NzEtOTg2NC00MzdkLWEzYTAtZTU4N2UwMTk4\nMzExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+VEiZ9o77BixN21u2Nj+4xz7\nee9UKJg28LhsI6I7MhIJfDywf3NJ/O+futViRU7MLfMoEJ/1pXbhCvbyGN3YD6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnEF3S9dUI+kykucZWutwLD5IRuEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGFGn3Uz\nqB62PmYuW87OX8rzqzqM6lHCUJ+1Aozn/uxCAiEAvMzhql9xil1vt+1XU3kmEuJj\ncWxkzDGqsxDEDTepLVQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4970", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4970` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbotdOwpAfG/t0E7wHx0DgZ/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NGMzOGI4LTcyYjEtNDY1Yy1iMjM4LTM3YmMyNmZmZDkzNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA0N2ZmYjEtNTI0\nZS00M2VhLWE2YjUtN2NhMmRjZTFiZWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOJuoY3o/CMojF/EW+1vI7j51UcqAUkgF3zgml+qUEFoRaDaDTmRmBaOFqZZZ\nd4DDHvp6MDMJi6c9H94EYS4eDKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+S6nfXIEdj8FMX5g8PBZ039mqAgwHwYDVR0j\nBBgwFoAUMWL5FLnCs46t9NTTFfIUazCCCdYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIF4V8b52J7SO8FbEy/y3hgZ854YtbaAChGvMB1DivnmrAiAv5/5JUMWLMQJr\nMyJsv4KdKX4yvYbcTiyUq/2kXZQsSQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZs0TfcjPeRyKnpXkfr8tVbDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjRjMzhiOC03MmIxLTQ2NWMtYjIzOC0zN2JjMjZmZmQ5MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUpCjjmeHIHFVfh+MBMfzeKOiTxhzl8u2jJZw1l2na+vhs\nfcF3FdPAdAUOofqgrzDYQ21ha0J4AILWbJvkNAx7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMWL5FLnCs46t9NTTFfIUazCC\nCdYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMzZ2qjtVygvgdHp+OVRfW3UGQA2hlKwEmg+sQChoY0dAiAgYyduK9XN\n8F/hN9G9zSDW3jv7RU9CxBCwVV1bNRRI9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAV1VFBCqertF+LGB2VV4Z3/WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA0N2ZmYjEtNTI0ZS00M2VhLWE2YjUtN2NhMmRjZTFiZWI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzM4NGVhY2ItNjBiZC00MDgzLTg2Y2EtYjYyMzU2MzBi\nMDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELJjyt6MDd3dUQAcMlmCTcULK\ni5t61aQ31dw1IVCRJNBmlZVxo/BvOUj6Q8nus1Af2gl5CqGiXb/yhtDfcdLlf6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+S6nfXIEdj8FMX5g8PBZ039mqAgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIHiyjQO6\nt5t64F+rjWm/V0dJtpndmtldMcyVITzS65RoAiBsHHWw3IGuv8Zp4HNUmXcCEsjy\na82+2OeZq572amaZpA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4971", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4971` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYPG/uyVmNTf8dw3r7NX9DsPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5MTQzZWNjLTQ4YmQtNGJjMy05ZTg2LWJmN2VmNmViZGY4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjRhMDY2MTQtNzc2\nZC00YTE2LWFiYjMtZWY4ZmQyMzViMmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVYU3nWzAYzXV1XpITY86i42rBUKOwI1p13KM5Hvxv6cbgiJTaBv2KF7ZKrKl\nhubvEGZFuxEJrZvojzrsO79pDaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVJN4xS7vbt8oYkPtAGS3ajslpfQwHwYDVR0j\nBBgwFoAUgMt6rDx0+Lx5N95oWHYl8fjkhTQwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAJBceRFxceYH+Eb78vt3cytm4tni2XKk32ms4xov0N6AiBd7027dRLjKgWy\nfBRgxW+TF3G0GRBQeGjb/VKQfPibkg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVnBpLs0a3IYQX7Erfm1ElalMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTE0M2VjYy00OGJkLTRiYzMtOWU4Ni1iZjdlZjZlYmRmOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQN4vgXxMvW5to5qlWtabClaI80K8rpU0imT1sS7mY3nYd0\n2X+H4U5vqf+Al9w2dLWvniDj08SfTXm7EuNwtqeGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgMt6rDx0+Lx5N95oWHYl8fjk\nhTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMl3okkL95/48I1E0yMkO8L6h6eETc4bHHp9RRyFW3YHAiEAoDx2Q+qi\nTCKQ6sWvibQ/zMolV5KECOmB1Owvcsvd0nI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAehsGGySlVMSn0EkaG3RKg26MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjRhMDY2MTQtNzc2ZC00YTE2LWFiYjMtZWY4ZmQyMzViMmUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTllYzk4M2MtYmI1Yy00MmUxLWJiODEtNjdhN2Y5MzBm\nMDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExV5MFKEkCnltHSOrfIcSMHRU\nD62wIOBqKZ/hkJMF5/3SOExrz+btiSjd52kTy0T6sHdtEI45yZQy34fTHfl6yKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVJN4xS7vbt8oYkPtAGS3ajslpfQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDFLIE6\ngqswUup0CpT+qteuV/3SIUfl7FPOHkMXcyUunwIhANx1zcvYGfMYDfZldKMJJpEo\nM9acoUhsneZOaaJucDmP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4972", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4972` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAf8I+yTTbaaXUJ2bKynd6YYmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkN2UzYzY3LTE3MDYtNDJlNi04NTE4LWE5NTZmNjU3OTVhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTNmNjVjOWQtODQ3\nNy00ODM4LTk3MzktYWY5N2ZkZjA2NGExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExc24cyRVfqvMkUFZAi6o52x1Nw+5ISPYllZrb/9AcuX9TAAR2+fGT2u1vznv\naT/fYTASZP62RtXoCjBp9YYQB6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBiGzKp7Rwbt4Y+YC0Bs1ZQ91xmYwHwYDVR0j\nBBgwFoAULeQclABktjxEW2AG8NcQyocq+QswLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHsM\nGugQo9MrGz3lRNAYpMyKmswYfKZFzm1pahvRYQZzAiEAwCSRQZDtEetlgiOnutaY\nORwwit/9wRLCjNvEgw8Yh1s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASgPnbUs8Bs/aitywsn9FekbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDdlM2M2Ny0xNzA2LTQyZTYtODUxOC1hOTU2ZjY1Nzk1YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQF9IjgNFVEDDvbI/4ehwwtV7kcRZRiSk8Z39IEEuEaxnEk\nI4ffVRVUT4mQf7Hzm/3KR9EGfs91mYq5rVxhHJAko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULeQclABktjxEW2AG8NcQyocq\n+QswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMQ3Hy1rBZBbS3jyLK6F9+34zPQ3hioWWGLjesvWinEECIQDIVjQYd32t\nZla3rm+Wq0qMgMb47WJyXw+MsV5SN9CKMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQ4M7sF6RHJ/1JvZ8xDLFtw0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTNmNjVjOWQtODQ3Ny00ODM4LTk3MzktYWY5N2ZkZjA2NGExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjg0ZmNkYWUtNzcwYS00Mzk3LTljNjYtZWUzNzU3Yzlh\nNDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+L23b5QCcY5vgQXZZjSh7ZPJ\nHJeNMqCWLCY+vkwPDhsjW7Tzwp/k+GIpp2ek2aUcgSZTmrU5RgBM0BiMpyCLM6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBiGzKp7Rwbt4Y+YC0Bs1ZQ91xmYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD2Amp5\nZOo4oudvzYJs46ceMo8utoXAdTzpSFKYo9g+eAIgJRj2PDBWtzkRjASdSdY/8285\nEx52hDS+UiORKQCkZQo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4973", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4973` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAT/c9zGhf7R2nTYZ/msE2MOrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1MDBhYTU2LWYxZmQtNDQ5Ny04YTY4LWQ4MjVkMWVhZWE3MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmMwMDJhY2UtYmFl\nNy00ODFlLWE3MDYtZTVkZjkwZjE3ZjgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsiOA6Q/uXv+fOtYl7DNjbInbPJegvaPVwue53wyH2s1f5lETHe10W6USNiW1\nQCROD6NGxtILyiukjlVxxzFVRaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUml15Ayey/1fLgkSZxI5NJYvIVCYwHwYDVR0j\nBBgwFoAUBxl6qIUnWUTAaRmWPZri1KLSZp0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIEZPWjkOPXNP9DH0PE5KUiG328PEc1drkDraaIA0XBvkAiEAn0dJ\nNTKXpW3MjiuNClr+CHtVl47NBhLDH0AlIG7PZIY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXdmpbOtImzYU7/jMHdOXt8HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTAwYWE1Ni1mMWZkLTQ0OTctOGE2OC1kODI1ZDFlYWVhNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdoRnWw5Y8kxzoro3PM6L9TBvZlQ5X6Fl7QcFOCptAySfk\nOuj7/XKRd4X+1JX1dT46KMjSzWk4/Krth811IfXFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBxl6qIUnWUTAaRmWPZri1KLS\nZp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO8tOlrpQT6SLiPUV6o3ArWWoqnX49ycAXqM/vYARG08CIQDxxdH0amTr\nnXQgrim5ABlKBavmZxrtNfNKjChibO86fg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAYWzX4qC1QVSxYuZaetnGFsnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmMwMDJhY2UtYmFlNy00ODFlLWE3MDYtZTVkZjkwZjE3ZjgyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGNlZDFmNTctMDU3Ni00ZjViLTg2NDUtOTZhYmZjNzlm\nMjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqbBMb7WAP5hXg5Ze+D35ieeK\npnJV3w2Gj8gSZKpGxNX6sqSUGQ65EmCnqVWamyLbbWSIWmZ7FBAB9nMue1jE2qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUml15Ayey/1fLgkSZxI5NJYvIVCYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCy6Kpd\n/0dxabzZzI5AAn+J6etOPxUPWwtdGgDgrK58JQIhAPqISutpLi8glG89DoUgpwsr\nSPN+M2jRePuTsV2x2U80\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4974", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4974` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAV7zMvXqJSySCEGeLjHkK0LcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2NGFiYTViLWNkM2QtNDI0OS1iNjM0LTYzY2MyMjcwYzZlODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGUyODIyODAtOGZj\nZC00MDgzLWI2N2ItOWYxMTQzODI5ODE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzgOgaMsjPwltg8lTiMME74gP3SaZ/4SuwRhlokXVoFDkVF9ymETVr47MVfp2\nrnpdvo9Go3JYJfCUqf88/VoVXaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0MCQLmlgERaGycHFOPocvR2DqfMwHwYDVR0j\nBBgwFoAUrBuCMy+Sd1YHekEnTrvoGUlBdF0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGqN6SF91Z5OysHr7HaCgRntsXIbKCBKP/g8uXb0gViBAiAiflX0\n4d3hhKgcVsLPwSTwKvRsafSRcmtJMcQENTSlVQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZC0DCrB3Z42rS1XIZy9rlxvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjRhYmE1Yi1jZDNkLTQyNDktYjYzNC02M2NjMjI3MGM2ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYA5vyhPIqhhi5nIO04NDyAptjDp4jaAD5L5prV4qOIIjm\nQL0+yIWUKtkb1azmxDh6J7UL5ntO2VK7FXRvEWZHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrBuCMy+Sd1YHekEnTrvoGUlB\ndF0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJoQEKmcmsbeMS6qoOsKaQLRwLgDib7XxCxymDxbMqTECIQC8WmoMfgKM\nIkbL+g8SQOPw4bNRwMcpsUvGn1uXH18PUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAYgQk3ia1KQgO6ixkKKCI/g2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGUyODIyODAtOGZjZC00MDgzLWI2N2ItOWYxMTQzODI5ODE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjlmMTc2MjYtNjM3MC00NDI5LTk2ODktNDViMWY0OGZi\nYTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2kSdPGklNXPj7zkQAd6U2nlt\nRWMxpebQ0MjoOqbeBvs1KZYnQny4Z879ljEuxM6MUYNu7rkMp9oXskN4sHdfjqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0MCQLmlgERaGycHFOPocvR2DqfMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGrlY+dO\ncAtdeichbe8Hguxjkz+zbBqXKP0DDWdoIawJAiAFjnuXIIBjM4E2BR5xH4XVhSib\nycgJgpKXCXxPIhJX4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4975", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4975` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcyYUG6K55jXPe8M1tXCykKUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkY2IzYTlmLWExMTQtNGNjYy1hMGQ3LWViYTQxZWEzMzE5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFlNTU1ZjItNjA2\nNC00ODAzLTk3MTctNmY3MmNhZWI0NzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFuQGQz9fqhgMwRB7Duo2yfR7zYiyhhsNkeiH99OvVmegvRYHQwQIizb5pvXs\nu5j7YwjWuqAfQpIQ6DRlv+vDAKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRbUPh8GrKGTNJ8tNmhqKGhs0dLwDAfBgNVHSME\nGDAWgBQe1WrXUEHUGhCo7orfRcre+bX6XDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIE6FBT6e/t7dWRVYOuYaWDJI2eT5+ypz\nCXT55gVVhu/BAiEA14mBujOCEYRddX5Ld1hdBTsiJqAEFreWjO7EfnRtnzY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAazg7YjpB7dBEmAS3UeWil7LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGNiM2E5Zi1hMTE0LTRjY2MtYTBkNy1lYmE0MWVhMzMxOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfh822FZFvrVOYGCa0P2gcw4jLLIyavXlj0K+u+wBk7OPV\nn23Q0wXAcZwubmnOgilshNnPgjIOG+0k5GtdgD5Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHtVq11BB1BoQqO6K30XK3vm1\n+lwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLkeV0RoHPFMuE5MCpkdQM3hTsjxTnSDISGVzPS6NfSYCIGaRiHYjEVsv\nLfxwDw7SD+VJ5Q2NX3SUzk7IvOpvzTMv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQk87mDgN4suDYRoKXXlNlubMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFlNTU1ZjItNjA2NC00ODAzLTk3MTctNmY3MmNhZWI0NzI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWNjNDExYzMtMThiOS00Yjc5LWE4ODgtMDk1MDY1ZDQ4\nYWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECKD6+b8g6atQGz2Oq3fK1G4m\nwOgtwam5Yq69fvPYerH7Tc/iE9iucG4I7s0vNStrrvFCnQYRV7g8No4SAAjwaaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUW1D4fBqyhkzSfLTZoaihobNHS8AwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDEumtb\nX5Fb28gxbvbggpKDgCjIpBXfFdQs9uGtl8HB2gIgJthWjFfHKjaq3ODljb0FeNPM\n9SjXb+2/i0mPPyVwUKE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4976", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4976` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQ95Gxs5JbL0Pt9LZEIsP4RkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzMjFhZjFmLTQ2NGMtNDUyYy1hNzlhLThiMDU5MjUzYzFmMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ2YjYzZDgtNjQ2\nYy00MTI3LTkxZGEtZDM1NGY0NjAxN2FmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5p6Rl3WXkCxtNEHGLNm/JgLTg8o9D/MHeCGzAYXe0XzvbHxBi1hJ3dLSaZKR\nhtwZHa/2iHyZlwtyrkKWyrj8r6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjWMdtq7Sec9MR+2T9cU86NychCswHwYDVR0j\nBBgwFoAUT8s9pW2kFuIYtAmbsVyQt9oEKQAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCU+ZIkGllC\nWxvQQ+EAAKdxeHxRlJesZZ9bWILmjDFVAwIgJWnLeU3U3U78NS/wNGLdjQTVnkWv\nCBc4sAJCYd18iqc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVjumDABgXqsKwEi99CS+a2hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzIxYWYxZi00NjRjLTQ1MmMtYTc5YS04YjA1OTI1M2MxZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASl+2OQavFfhufa48Xd/JqxwdoZ93NW3mrMtdxlt7/4LMtk\nRXUHTkU6a/+Ew+ThGNE50kGNmsEQgBzkrALI+0e/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT8s9pW2kFuIYtAmbsVyQt9oE\nKQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNSUQO0Q5HkheWZ4vAty3LgdCoCUO+UY7nGlaQghHWuMCIFsSmX2aNGU2\n/Fy3fYau5Nc8JG2oYqsfwIZUIFFIXYqv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXT77hWAEpEV+lCbFLWoOS49MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ2YjYzZDgtNjQ2Yy00MTI3LTkxZGEtZDM1NGY0NjAxN2FmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTA0M2UyNjAtZDE2NC00NTAxLWI1ZmItY2ZlYjQ0NDI0\nMzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE51eKr0mpZVVvONOO9Rg8bEvM\n1MgV17XtLSc+GjNE/JJh0g7qTNpo2XvxR62aVlFxj+TNve5yKVumo3ncJl3ipKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjWMdtq7Sec9MR+2T9cU86NychCswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCDIQJC\nOC/I+yhKGElHDL5mvPxJg4G1cYZe3j2Z/U0CpAIgb8pBKVNvuBsJVZPLv+zx1rZc\nkt9zM/s5zKbBLD2TuMY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4977", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4977` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAe9MzGEtgnF8vwtGhTuNLkobMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMzlkZDNmLTMzZGYtNGNkYi05MzUwLTNjNzcwMDg4ZTFlMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmUyMGJjNTItZDU0\nMy00ZGI0LWE1NWMtOWMxMzMzMTVkZjEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETd8gl0t07epockHOogRfxDsYWBonmursrzE0dGeTzSCJKB4Ou87cVO/lIUKg\nhRz2QFsQzdzVBkvO6KRNZjRAhaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfitjt9WnHCCF/fPR5VOlEC4sb3cwHwYDVR0j\nBBgwFoAUgfkSWM2xO0+tCHMQPCuN6xIDfakwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCB1z1dhMNt\neaIMbsXncm52YsG2DJPIx4yuvZS9Xnjh2AIhAPFrwJ/vnArFiK/iTlltqjtROiIN\nth3/Go850sSyU9fm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYN+A9Blt5DUOnQX98fw9mw+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjM5ZGQzZi0zM2RmLTRjZGItOTM1MC0zYzc3MDA4OGUxZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThLmAOMeX38swAOYFfRbhAUE5N7rYprpUNyxJcRiiEPlhi\nZteSKwNVlm/5TGZuMdrN4PugLIbJeU8dbR0EpqnTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgfkSWM2xO0+tCHMQPCuN6xID\nfakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP74zm3kyAnAID84IPS27FwInGx1xrJEGgTiTms9pS9oCIH4AWToloDP5\nXnvNFns6dWqhFC9B+Fp2aH97orzSrcQx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAXzmderRUpl7sdfjOaDBOPEEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmUyMGJjNTItZDU0My00ZGI0LWE1NWMtOWMxMzMzMTVkZjEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY0NGU1M2EtOGQxZS00NjM3LTk0YjMtMjFkNTkxMTJl\nZTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKWFtJRQR/pfVFLm1FOrDyr5t\nhIhPUZf1teNqD2mWYjYGF0u4Taiy1KkmjrZFSHQk+qeQMVDPQqZOSYS8t+Sa+6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfitjt9WnHCCF/fPR5VOlEC4sb3cwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD2lvYk\nod5M/w6K96yUbhqxaPc/qoPcR4ldH1fG2ItnwgIhAP9xqs+kOb4ULL4iKCiSBq5r\nOXXu8AWYnNC8TzMhoH7E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4978", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4978` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISASzDAc8wprZZrIp9okrb2IKYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3MTk4YTUzLWE2YjMtNGU4My1iYTc1LTYwZmEzMDlhYWNmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRkOGViYWEtNGRi\nOS00ZmU4LWI4NDAtOWM4YjA3YTg1MGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF/O6Gokc1MoZPyKpqBvqwhJjApYq6PhKkZYRQZKX2JhY3S1pjZcDokhvI0BJ\ngkCS3QhYlfRv8y7hZq7wBL6lM6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIohwOM8/IMCPKVPv8818sHq2BDYwHwYDVR0j\nBBgwFoAUgj+FbhZ2f5tCn//0NiSeHmTBXmcwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAPj7fxKv0k\nMenvPSHg8B5PuxihX6F5l4KIQhIZ/wBn3wIgcaDIqsYJsCL3pMCNfUG54BIbfYWK\nRfA4zlNtr8qRJqM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYR+dDjuEsF6d/l+4m+3IuEdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzE5OGE1My1hNmIzLTRlODMtYmE3NS02MGZhMzA5YWFjZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASp/JIEUu7dLLBDMlXrWIaea4aXMe0ph7iz1DzG1QtK5oCF\nzAiptteZwjjKB73hQPFS12mYbT2wAVU0dQebDnYIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgj+FbhZ2f5tCn//0NiSeHmTB\nXmcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMcgspnilcftr1DHaa+RT7NXza54z4sDg6JMA7TwI/sQAiEAhwENuCy1\nyp5TE5EXdg4ayt9nzZnomNDnFBwAK+6W6p8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXyN17BUvkeEO+ihU2llgQluMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRkOGViYWEtNGRiOS00ZmU4LWI4NDAtOWM4YjA3YTg1MGZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzFkNGFlNWQtNjI0NC00MGE5LTk4NjgtZmIzZWJjZDNh\nZTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETJFIZCgg8LxA6GYEkMgwWBw9\n60cYxiXQjjhWKGO9gxEGho8MJvKMMuBPjrfL4WHeLDl6vRrWm4EQx6sUiO2PtKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIohwOM8/IMCPKVPv8818sHq2BDYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDhMAqb\nWXQo3D7UHnlXsVlIyqcHDMKc1vMrONHEJGuTowIgWyGTEfHPjNLsFrRo87E8mq5g\nTjz0y22Ww+zN+A5TPCM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4979", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4979` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASQQD1eeRQjRtuJvVGD5DyiZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlZGU3OWMyLWUzZjEtNDAzZi1iZjJiLWNmNDllODAwOTUzODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUwOTZhZWQtYTVk\nMy00YjRiLTlkMzktZjU5YjU5ODJmMjcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuhUnGvpW9TK5ajR3D/Wutz2fL6Mt6eyLNVbMGMIA7pbEPezG+g3i9LV0HA8F\nipiwhsKu91To24CW5iacvfIyyaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwFNddH7gWeKf1OY47EThmFMGqf0wHwYDVR0j\nBBgwFoAUY1micQOnwo/hOWuFgmksl1ZiWrwwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA8ZmNHCc9zg1NOGr1J2Xv9AM92M4mWugC6hHYvpgfXzoCIGGW5YfbSRv4\nEyBoq79iOeFJb3HMK5Sfq7S1XClE7nys\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdnClNPnCeb8NmckS2KOGrlcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWRlNzljMi1lM2YxLTQwM2YtYmYyYi1jZjQ5ZTgwMDk1MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYCab6PVNMacHtPutAxsIk7z3mqZOwh+FILNJneJPL3Tkg\nDu6sSZ5RLcHYtyF/6rjos1X/NsVyzrfsDb6ktf22o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY1micQOnwo/hOWuFgmksl1Zi\nWrwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALxDyVHh3+aFwqg3YLHZyIcKNN6wfJpO2/jxVM6hCn0CAiEA6nDBdiTo\nhjdMhpLkBfchgk31Eb2GLeEoKiB497Hy4QE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISATf28UOMOBhkKELZaqDfOd7OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUwOTZhZWQtYTVkMy00YjRiLTlkMzktZjU5YjU5ODJmMjcxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWMzZDI3MzMtZmU3Zi00YmUzLTgwOWItNGNlMjZjYjI0\nMDllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKrSe9kGTxo6EIoZPGnKSTKKa\nicAOET6fcIsKd+MvusUoVi3C2m3742nRo28b5zpawhL8TMHPVtjW8+bHGAkdn6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwFNddH7gWeKf1OY47EThmFMGqf0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD4ikF2\nZsG7f59lVEMdU0YlPGGYJzRHr3/T1+qQvQdzOwIhALAmXeUUmrXE45G9XK0juooF\ng7RukDbyTZAFueou3u9n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4980", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4980` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAR5yX6d/TL2H94Ug8WC6ObviMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4NGM2YzkxLTJhMzgtNGZiZC04MzllLTA5NmExMWFlZDcyZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjIyODkxOTQtYzNk\nYi00ZTYwLTljMGEtNGU2NjNlNzFkZGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqeshrMtVEOlOC1H8e+/fYVgPl6rzD0JBagLoofNi9ICSybl8hwwVCKdUjckY\n3qL8U61rJ3r/q3nJbXnVxCoyd6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+DLiUGdNqihGx9q8+CR0hMYVQnwwHwYDVR0j\nBBgwFoAUXe1agKbfcWmuL9PrHyXGh9zkJrYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA6W7wapl34QooI5OT+x5UNTUBQvSZyFGnJ69WK9pjFp8CIQDhCajsKLpB\nQcaofwlycsupz2rG+G8mXBaCks+SyvruIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAblnkPnHurpw5bear9mCwTGbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODRjNmM5MS0yYTM4LTRmYmQtODM5ZS0wOTZhMTFhZWQ3MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsRvJtRgXS62hMlTpoEv5AB+jEV+iKTtVA0KzGH2+7DL8Z\nBs8/LDYwmQWTiMZR+XrR0oomDJWNSLFfgJTsW1rpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXe1agKbfcWmuL9PrHyXGh9zk\nJrYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCimFqb5nuY5+yg9K8ARE0elAk+DrLobE7q9wnuiK+nECIDu06IlboWMY\nzTzRX195A3kIkWe9SV1uX8ADI2cB+OAh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARRIMgyGEagkfUAFwjQTKAcWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjIyODkxOTQtYzNkYi00ZTYwLTljMGEtNGU2NjNlNzFkZGRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDcxYjBhODItN2VhZi00ZWUxLWFiYmMtMGY0NDlkNzM5\nOGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx57bh9RexbslztJUKmHol7Ww\nehwoA9tbjReLc0BGlLfbtaBmv9WS5xAPUljVPsHCxWqWFPRJ64NUI9p0Nlqb26N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+DLiUGdNqihGx9q8+CR0hMYVQnwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCV9hw8\n/lO3thOyMjSzVXZg9bLsyMqaIls0nl6q3UuWegIgOhlDHvQQqr5lgLZR227Djswq\nGd9BqVF+rJ3JZ2nE0mU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4981", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4981` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAcDrCmsMM1bSW5STwXHChHtmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwNzkxMzg2LThmNWItNGZiYS05Y2E4LTU0NjZlNmE1ZGU5NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE3ZWJhODEtMTk2\nMi00MTRhLTgyYjYtZTNjNzVkMzJlMWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8pZbExoHKVVQLbyTjPxQd2UwUqNC6IvcqJPri5Bs2J9wnnrUCrV06qAl+Ldj\nuC243kQDU0V4BQ015DOhnN67WqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWdbDhBdOVBakQqDg8QwoyOFh0kwwHwYDVR0j\nBBgwFoAUtugmpREmrL0DgDHNreXJtBs4Qy4wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBw\nWYXP3I69mRz2nO/+Ua9CHnMGvqt17Ogb4uQiZcgttgIgaHKJSZv5hfWo2SlOqNF5\nqvpSuKwbgdB2fYfiq70ZWis=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcvTtYLGaoW1cFisxyB3cqV1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDc5MTM4Ni04ZjViLTRmYmEtOWNhOC01NDY2ZTZhNWRlOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwprvamavAbWHlYk11iiYMg8YMtgl6l9z71VvAmVkE5DZ0\n7CVdHPrxuoG16wGY/v1qABCWR6OWVSWL6YDJzCCTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtugmpREmrL0DgDHNreXJtBs4\nQy4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNPg12q0laMDymsA0zMDgj53KzbVNM4xTmcrvXljuPQQCIQDGrZZSpntJ\nLa3srtA9LXXcuolI0Qndwk/e0+uijSFLsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAa8UPUt1+iXWeys0mVCnx2IGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE3ZWJhODEtMTk2Mi00MTRhLTgyYjYtZTNjNzVkMzJlMWQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGMwYTYzYjAtMzcyNy00Njk1LWIyNDQtZWY5ZjYxOGU3\nNGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV1BmGx3lYVwg3w3m50nFKisr\nvysTO4oP2o0xSGZNXBUk+uNiKevhJj8EKeDXnQJ7Jp+AhxdXeE8b1boObtcIKqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWdbDhBdOVBakQqDg8QwoyOFh0kwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIC3f5UmL\nWGNSKcqTU1EKobTXWrwp9gujh5dUBBsZqCIgAiEApv0Z0UiD5eqCoDxFAuF9QEgT\nrW6syYFjyzMIBMOPp6E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4982", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4982` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAf5LrSNn4jZ3bjVe7IxSBsXsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiZTY1NDg1LTE5MzctNGJhYS05ZmI4LTUyZTk1ODQ5N2E2NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ5YWU0NDktMTE3\nMC00ZDNlLThhMWItNDYxZGUyNmMzZDJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuzsJSdE2YaNK2GyYcDw1I2hHTVZwbZUUlipkDFoEx8o+/35gQN72jqJ4nIxX\nyvlhufgNP/DJ2p/dTRgcIr6F86OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3SIijTGmj1ZO93X5ejpLHF3VlUwwHwYDVR0j\nBBgwFoAUq4a2pohSuQRo3pLAdwxQzWFiWh4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiAv567olE+UojFriNSFcuq7RzApL4BPU5/nMsI5BiwFuQIhALAR\nX20r52Lj3X3rlsjFuYTrcHrdZX6B0xcvpBQGOzFQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfvxACbiWbcGHFWcfSZikngkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmU2NTQ4NS0xOTM3LTRiYWEtOWZiOC01MmU5NTg0OTdhNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8yqHLpoaWqxsd/ga/SNfMqIzU5mWtz02VxLpcaePkfLTj\nKOpZwI+hdHaDNsqXg+8vXLAGqh1xl9E8hUtl+zYzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq4a2pohSuQRo3pLAdwxQzWFi\nWh4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALFxzKEWqDiy/lHDCWOO0Rq+PgCgRJPHHT3mVhQYiUFYAiEAuA8iLDd6\n4mctHNEwe17bhus0qSXdDdrdg2U9GFFv2nE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUrQKEDOot3B59gqaAlb/6anMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ5YWU0NDktMTE3MC00ZDNlLThhMWItNDYxZGUyNmMzZDJhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJiMzlmOWUtZThhNC00YjE4LWIzMDEtNWMzZTAyMzRm\nM2M0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEf/lgXHymmyT/WwQCM5lHrZX8\nXkh7SH40Tu6EXH08a+Le4nUdXuyT7pl+02rYRoG913TN0LhM4HpZY8vDH5lyIKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3SIijTGmj1ZO93X5ejpLHF3VlUwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC69/BF\nbtP+kZCZywp4IxJqbt0rgJ/sfspqH9SsqkxEBQIhAMzzjy1QQnu2iNfuZLNm8/I0\nHSB1Y5XPm7sKol4XN3tM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4983", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4983` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAbpkB7oZpvi6PYLnfz330Ao4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlNjJlODhkLTVhOGItNDg3Yi1hOWYxLWM2YTA1ZWMxY2E4YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU2NzRlMjItNGRj\nOS00MTU3LWE3NTItYjk4M2Q0NWU4ZTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENhuT5vGgmaRYwO97+eGtEwh3Cf30CLqpwVO5Yd3HNdxnBTCNUxqy4TxovigJ\nbLcuRobYEEr14BD+cieRpt4KB6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuqiXrWe+tl3EidRHypL+P0lzdtEwHwYDVR0j\nBBgwFoAUV8pG0GAr9oc1HpxNOSr6Vx0ufdwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiAJi4gs4RPBO7i+3s70ua2qt6TGRqm9rLtqoZZ9WFKTfAIhAJei\nyvyGh/nV0htmYL92mlNg5BWUWfJvFe1neyq4CAjG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZrgLjmfTxucfLraNSkLbtp9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTYyZTg4ZC01YThiLTQ4N2ItYTlmMS1jNmEwNWVjMWNhOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoVVmNxLPPCla+eaaWHHlVN5Nj8eGeQP0rAmPnDDNIJAFI\nYYoreuZM2YliaMaQaSW1lnyCH8uLO83nGNTS6zSyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV8pG0GAr9oc1HpxNOSr6Vx0u\nfdwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAW3GwI5/JUUHCFAzc1ng+hCGdJmW3/cYRr3hWwvjynwCIQCFHmCO6q/0\n7WmtfUfvBvczUdD5nVulTxp6G12MbGDteg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYwbu1E498HaM2Ml51RyhidgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU2NzRlMjItNGRjOS00MTU3LWE3NTItYjk4M2Q0NWU4ZTMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTI1ZWMzN2EtMTFjNS00NmZmLTkyMDMtNTMwMWQ0OGVi\nZDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXSiNb7jdr8xuUChjCrDv9MfD\nGPz6kjforxgEPlrzOq9VHObrDGtH33mv7TLLadXvtv/c5tWqJ3sOrpGbo8RNLKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuqiXrWe+tl3EidRHypL+P0lzdtEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIAbbwO+/\n2c5yPge8nNrZ4xOxva6ejajkiNn4tWa5uE69AiEAnzX5QsuKuiJ+6E8rc1++TAxI\nz+O2RkOwzfTfDGWlwas=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4984", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4984` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISASJSadrz0vSdcrBzFd+YibN/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkZTA2NmY2LTFkOGEtNDI4MS04NmRiLTcwMTg1NmMwZjA4ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFlYWNlYzQtMTEx\nMy00YzNlLTgwMmMtYzZhYTk0Zjk4ODExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIReek8cQe4UiaH7qiSICeQCq+MNEyqDVZNCysyg7wVEmX1LEJJ1CySnxLBwS\nBXlGPZViHnXVJhzEeau+Y+3GmKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9NPtyleHPKhTGadqZfZKdbQCr6swHwYDVR0j\nBBgwFoAUMEjoeLlig+cQ21BffF1r18xuMqgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAtGKbcfA5730e\nJRi2n+gpPQK7ILU+6+mdbTv1dg1CegQCIQDuPHgPlKHYyDhpC84MNkuSui031EGd\nHU+jMmkcrxiYrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAatY8kSwmwk/qSmFpjMwEdFJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGUwNjZmNi0xZDhhLTQyODEtODZkYi03MDE4NTZjMGYwOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNZIZ6qjlFcRfVkffVJ6c0fA5cOWkxUdKUQY+MKclyy3Jq\nzZ8baOmRTYlluFI/wY34o98dS1kKt9OMT9Q0w8qoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMEjoeLlig+cQ21BffF1r18xu\nMqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNS3KjL+Xk/B7hDbGPZavcq1b1IzepRpbUlrTTpXnmYwCIF2zzzk0xY7L\n8kkXs59nZtSTRCZ8v7v9K3O6b7NWTzP2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAdOW8W3FwA5xxnpCdEy0uDXXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFlYWNlYzQtMTExMy00YzNlLTgwMmMtYzZhYTk0Zjk4ODExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDYxZDYyZWItYzlmOC00MjE5LTllOWEtNzlmYTYzYzA1\nOTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEc9Klalhru5OjwhzRqSmxvqDL\nw+OqRtf5K6wEQoJ/nPjB6qz0YjwxkEOepyD+mqhvYDf+EvALUh0sgs0t3z2X9qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9NPtyleHPKhTGadqZfZKdbQCr6swIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC26+h3\nQfdg1fLqTxbvix8eROhj57Zf7jPocVYaJ4V7cgIhAJavfs7hyhZEjOolEixHt69j\nDl60bYHx2IjkUeUHPgRV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4985", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4985` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAamQ00zXh64wgGiDCYYJp4lKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjODRjNTU5LWM5MWItNDA3My1iZGU4LTk3MzMyNDhlZTk4ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY5Y2JjNjEtZDEx\nMi00YTc0LWFjYzgtODgwMTk0OGU1ZmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMDJigzw255GmR36U9/EvjXnIoFnXbrch1Ei3UqOl5bJBiJWGdG6wVWxb9j6J\nqKhwPiScTG/0hzFnTthovU+aOaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWIOiLvgcjGHt1IGLcm0wDsr2jZ0wHwYDVR0j\nBBgwFoAU+b4d9OLd/NWICRP/xX2oifePl2YwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDfJWUkX2n3Qt8gXp1mSt8OTZnBOC3WYDuJpuGzUO1N9wIhAO+e5zo4BAW6\noYID7fjcKs/cPFkWOti8QA2SVfCUm8af\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATuz0X+gTgbocOD3xvXJT2rqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzg0YzU1OS1jOTFiLTQwNzMtYmRlOC05NzMzMjQ4ZWU5OGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfFGkHhcHuatyvd6vwhvX+e4coOInYQ+hdisRvEWnWk82t\nk6TJ8ZhcWzNnbLTJnomN43m2s/w24IXGJnjKH7wYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+b4d9OLd/NWICRP/xX2oifeP\nl2YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIp3Fe4kB9SmA43q151WST8Dhkz6jwMnfsiNZBtYrUMKAiBct1sNp1ia\nMDuQF6JCZgTHJC5FGg3x5Su5OkXA9MMXAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAf6oqtB8G+dQfTyeHwmbtS6gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY5Y2JjNjEtZDExMi00YTc0LWFjYzgtODgwMTk0OGU1ZmYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTcyN2E2NDUtY2JhOC00OTBlLTkyOGQtOTkwMzBkNTEz\nMDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw0mQr33NM9eMzD8cu+p5nOB9\nFOsAT2wfjnkQolGUNseNnXvO4/pWjjVJADUpeOGrIdUOzpZL62VNJGDhH4XdRqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWIOiLvgcjGHt1IGLcm0wDsr2jZ0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBWOVPg3\n/y8xTIldW/PhW0Hau1FyaoPeFw0+bVh7dqBuAiEAlAf/NgxYic/K+/NQZ1gD1xcg\n3wJjzfFWzrJghWPDpDM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4986", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4986` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAX1q6qOf6n8liuFL/sIXTwKTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0ZTllMDc1LTYwNTctNDA0NC05MDkxLWUyMGVlMDhiYmU2MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ0MjRhMTctZmI4\nMy00ZDM2LWJmOTAtNzE2ZWNhYjE3ZGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkANUHJpKO1D/BT2ZcpmqejRqpEEOaYN0yKF0CNSyAMXj0TWX+Dx4gXBhUs36\n/dyLqMrokMA8Asarfcmy/D4U36OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEUm5MbWBNuc09mMoTZ86FdVXSUIwHwYDVR0j\nBBgwFoAU76IqKdE5SIbyGLVmZZnhweTdXp4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAcpRBBnZW/FHFRXhFgJHHNg7a9OL2fIchuI1aHfvw5sAiAFKjba1F9BcWbU\ne6kRPbdEbmKS1idAuHJ2l11X9Vk8GA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf4lxfJKcyTNDobCnFLyVWM0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGU5ZTA3NS02MDU3LTQwNDQtOTA5MS1lMjBlZTA4YmJlNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR30fGJFCs5Bym7eCJt0hKUw3apmOKeMGFa1/fD4EyB5wKw\nAiZwlE6xK9dX1wATAECeCpOWuZpnXeYb2rMi38RUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU76IqKdE5SIbyGLVmZZnhweTd\nXp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD3IJJL+suWhl6G6zLdt7qPwwXRKD3mGleUeEmEpQWogCIQCfZMydGNlK\n3bpK6G0BnreXHzn3sxDlMVmF/2RvwzbEMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAa5AOXd0lJPFiEPbb4auMYgdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ0MjRhMTctZmI4My00ZDM2LWJmOTAtNzE2ZWNhYjE3ZGJiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGVhMjlhN2EtNzY0ZC00NDE4LThlYmYtNzgxZjYzYWQz\nN2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAED5CVlotmZLXiUNSLtvHYNF6c\ny262dBmzBLJGVg+PIplSAFapPY+OA5lXzbNcjJfPPaBRePuqSNL+gGMdKBywKKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEUm5MbWBNuc09mMoTZ86FdVXSUIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDCbhdu\nXD1zGj9jkn/iQpEW64s2QIQCrHVNWQ5eXBKIEAIgMrsmOvmG/sQ5uB7jlbMwfzNb\nL/PQxbJKMNnveWIrHF4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4987", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4987` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISATSM/LceTRkleA2dGUiHxrOFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2OWMxOTViLTFiMGMtNGIwNi05NWQyLTYyMTQ0ZGFlNDEzMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNhNjJkYWItYWEw\nMi00MzVhLWIzNzMtZTFkM2JkZWRkNmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbhxSbUY8WXG5ErEv6ukKeEzZd5OML6u0HW/pgTMnvJozXIfrf7tQwkgzvrNh\nM3t+W0A2jaKJZ9O6a/fRK9a3eaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUceUraz25sEg1LZtzUd9wGbG2sHowHwYDVR0j\nBBgwFoAU1Xo4D8MlQEN5t1fiXo7EN3HoFhgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBdgDp1ftdQs+EgyGPK9Sdobx+BoF+COj6Kb9JFPtV6PwIhAOPVDLdo5g26\nw3NR4OYHuQ6+iuFBRiXiyuD/IQ+cKPPQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR9IjgoxwGi9NkZn4lLTu2HOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjljMTk1Yi0xYjBjLTRiMDYtOTVkMi02MjE0NGRhZTQxMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARALPEi9enJqmn76tu9C+nJb7WAYptHFSLK6HSoCDZo/PI8\nq4hTNKBegCmCV3Uk2ahATFnWrmYULF0ckR9EVOEzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Xo4D8MlQEN5t1fiXo7EN3Ho\nFhgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdQfO26QjlfIcyGT2DZ8SszaafYsJ26Mx9zH5W2HTLGoCIC0xjzB1ykUv\nOA/KEd1MdxDFACjPcpO/OAnurrXHf137\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAW/Nm5fh38Es+cbBRn8UkUS1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNhNjJkYWItYWEwMi00MzVhLWIzNzMtZTFkM2JkZWRkNmMyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTBlNzFjYjYtMDkzZi00Njk5LWE5MWYtZmIyYzkzZWU0\nZTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElYaOVaML5O5gUTfaBFsLRRNP\nF9uOZx4i2Rzen7e+QzGRMuhdtW1yIXMeygwlKVo7Dw2LbuIybAkAAO84VLevWKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUceUraz25sEg1LZtzUd9wGbG2sHowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIC68IskU\nwwg2FvG2tJ4KNfbs+LEzkQgfuHGm00p7tHeUAiAxfx7LsGW/HJFifQxwiDWEiLsD\nSyfYlwXQO/YWVWJOHg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4988", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4988` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAX+mdvCzTGCK+U4QpXd//VMeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjOTk3OWIyLTg1M2QtNDdlZC05YjZmLTY3MTFhODNkMDkzZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUxZGExNTctYWQx\nMC00YWFkLWJmZGEtNzNiNTBmNGIxOGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvJE9sMQrmqijOsWC5y5CjmIuakU6Pf7j4eiNjVeC7+GMdHsxlhZaKj3wWp+L\n1SUdRplhYLK/rgmGr8869FHiN6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4pgUgmHW5La43HaWhm/0R3wszx4wHwYDVR0j\nBBgwFoAUX5HJnU/rK0Z7zDnMV9/Sd2y3w3YwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBnf0/xNusA3NO5NXdepMcBUx0KmYhPe3L2MzJnF6Ra\nlQIhAPvAFEF/6W9CiVhvdZLyWRSplhrbg/QD8W3apOcZjyGb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARVsNMpnWItwq+lM2Ub/ZZFhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzk5NzliMi04NTNkLTQ3ZWQtOWI2Zi02NzExYTgzZDA5M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/VjcrYAKXfiOGKr1lBq0RfvcR3ZxsRLxgMfBcUcXlJzjz\ncL/Ihg0A5TmqrdHDPLDYaXIMXzy+q4rgqzC2zG3io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX5HJnU/rK0Z7zDnMV9/Sd2y3\nw3YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcos/JTXzHfegGXLtGM4gsob7fNyb43z4esX/s/AFAg0CIQCeERyG8Ee/\n0tCdDcp2zadE5Fpdkbn1RPkWw9u7fTIkdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAa2/gZcDnekLt1m4qfoFzfTTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUxZGExNTctYWQxMC00YWFkLWJmZGEtNzNiNTBmNGIxOGI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWI1YzBiNjctNGNmYS00MTcxLWE0YTMtZDZhMGVhZjc1\nYTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEu5MsGqr0hb0JkTDoAp8Xdys0\nlG7r2KGFpLfGzPxPSCD2CVdV+Ro+kD+O4Cr4MjFCV6qBNxM2wZB2x8Jor1nxe6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4pgUgmHW5La43HaWhm/0R3wszx4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC5BEBn\nDDhZ76k8xiWDiM1oZZDDD1fRRwRugRTeUI8ntgIgb4X/SvEzBBxd3qp8UXHcT8cd\nVx2EW6VyyAeHNzxVxXA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4989", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4989` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAdYfZuZvlccDJzM/HvIwMmhFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExNWJkOWNkLTkwMjQtNGY4Ny1hZjg3LWE2OGVhNjY3YWYwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE1YWYxZmItNjU2\nMi00YTYzLWExNGQtZmJiZDYwNDFhODNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+CA+0TXQgzibAX9+akK15EL4fH5wwdxSfa1AeeZDv0O5YrRVV+PDAgrKSyEu\nMnIZdmjoXJk9O7uzOuupNGDaRqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZOFThFdcU7oHm15lwvoQ54BDURkwHwYDVR0j\nBBgwFoAUB2asb8zzUXOX//SzneGyp1TF8FcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA5P6q02BWHoGQmkt+wLsGajrKjIDjO9fQEv1+z8cX\npiACIQD7q6YKoXgcUdpTSvP2VaAkTXt3kG7VaI81LtDxcNOfXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe5aSfgun3gG0Bqw4+VwtUEXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTViZDljZC05MDI0LTRmODctYWY4Ny1hNjhlYTY2N2FmMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmlQmEOSCkqCz23LswFNmYnxuHzRCjiyCfKg4wyRwB7OMh\n0HX1xTL4eeYiW7TfwlvXSesfNt032J0fcbSsZPR5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB2asb8zzUXOX//SzneGyp1TF\n8FcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKimEZcfIwPJ3A1mKc/XWS1skX/nWRIXKaMc4bDZN169AiAPHqbUHPur\nZy1GarDO8uJGL1rY0EzDIkIYqH97lE55dQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUoOHs6CxELh//QoaazavuWsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE1YWYxZmItNjU2Mi00YTYzLWExNGQtZmJiZDYwNDFhODNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmUyM2YxZmUtNDljZi00MTkxLWI0N2QtMjc1NzVhY2M4\nN2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFapnveTTiisq5UhW3fZQ3jWv\nWwKn2tCoarRIfUGBKJnPIGsUZ0jWHIRiIYuIjfFUEgTzYFNEOjvjr2fiMjFdJ6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZOFThFdcU7oHm15lwvoQ54BDURkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDAIq1i\nuGqNwHcIqK2HiqY6tFxKrdGxj0S+pm0ghx316gIhAPlFs4044LnrEjLlvpgxXBBo\nWxXfdyXjytsm8we0iqtU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4990", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4990` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAXpMYLigq8qDvIAGukDE4KgPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYTM2MjdjLTY4YWQtNDgyYi1iNTQ1LTkzZDEzYzhkY2UwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzU4ZWNkYTAtYzA2\nYS00NWExLTkyMjgtZGNmYzQ5MTAzZDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpFWlUT/LNz+fzzE/QWtVWcUGmfpbojhu0iglq5aT7zKKhg81zSIbKgYOVM2y\nLmaIJMUBaezr0NZX9VncQGisxqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfbnKyYnRfl7pM6fD5Mn6xgxmNrowHwYDVR0j\nBBgwFoAUXtNiXTNfzJ+tONoh/KGWot7E6CwwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA2gk4qUW93/xMPa3+iT9jkOu2E4O9Zp9D/kzadMScwEgCIAwu\n2n5Rkw+TJ+RTGAPoLLCrSUju5inNJe2JK9WurpZE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZimHQBdW0qNSvxEA+HUxI4iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmEzNjI3Yy02OGFkLTQ4MmItYjU0NS05M2QxM2M4ZGNlMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASynRwimgYRnloKNLqkDeM9jljXszZCX4vQVRnh7BwxLMCU\nyLlAgQph9t2okXgivR5eYchrFXzNRx0uEgu4v098o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXtNiXTNfzJ+tONoh/KGWot7E\n6CwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALwUhDWDMdyxipErDmRQLekqnIpBzHY0485ALcelEKM6AiBXEUdP4qp6\nhHURanfy+p0SIvoHbvlPkfr9ErcWmrmncw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdfpxuBxbUUTVc0ZAQ5oR25bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzU4ZWNkYTAtYzA2YS00NWExLTkyMjgtZGNmYzQ5MTAzZDNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTNlN2FlMzEtMDZiOS00M2NkLTliMzItYzdhNmZiMzM0\nZWYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUGWHXiqKoTUB6dCaE/CWGBt5\nkeBoa0kqFNrEJlSKZ1U3ahxDRwz+U8aWcEJosk+/Kd1Y+f/c1/kOY9LXzSRIVKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfbnKyYnRfl7pM6fD5Mn6xgxmNrowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDoZsNpd\nGEX3mlsOQRFhyPhQVb7EtoRujVyzBhlIkQtmAiEAlT63CdyzZx9/raur/SDLQyWQ\nFwB1SXcHao9FrlZhPYc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4991", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4991` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISATVgf7cuOVZj8r67MtnWkHQFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiYTBjYmNkLTFkNTgtNGZkMS05NDQ5LWJmNjBkMTRhMjhlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTg4M2MzNGQtZTJh\nNi00NGU2LTlkYmUtYTI4NzYzMmNlZDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEunb7ueo6IbfW2RSjR1Ym53qz36Mqf6gffeS+SRw2gHQ1/JOfWiBz1WGVtyWY\nt45fyxbGidiU8iGk4UUzqXtNc6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU22xZC3uCsKMYTZM7qzkp9OsCvTwwHwYDVR0j\nBBgwFoAUBr1BM2Z2blrgbl74MlacQPwf02UwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBZSXxcrenLrmm3VjiikXKx5ENtG52+Aipi\npYL+hczoFQIhAMnM0MMv8tjDF/A5bO8WBkJRfVnN5Et+xXWG5A5yw6/l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbq8Jd+LL3HKy+9cERGt6YyXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmEwY2JjZC0xZDU4LTRmZDEtOTQ0OS1iZjYwZDE0YTI4ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXdddAmDFbnzfHMUy44FXgBXnI0YizXmMddxxO4PaZPRAD\nJ+tkPxORGVljbJQrB9NxKpEDTDk6mHW0M/gsdV2Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBr1BM2Z2blrgbl74MlacQPwf\n02UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZlGwcjfqZaZH4KTVUJ/tGb1ai1y2igu4FE4RHfovmigCIA6BuRVCODwm\ni/FAa4fJyi7etTfQhvDw7D2nSRgx5mxQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAch/XYtkvUlJPGD7dCAEN8xLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTg4M2MzNGQtZTJhNi00NGU2LTlkYmUtYTI4NzYzMmNlZDg5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTIzNTM1MGQtMzFlMS00M2VkLTgwMzAtZmEzYjI4ZmEz\nZjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENnohw4FFsvr85cWZ5iXpYgax\n0+XcnNMehJukc27Bm8CYtWCTGeCDvpi5t+SaTSBYWa8URhpqrepZpr2FdTgrH6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU22xZC3uCsKMYTZM7qzkp9OsCvTwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCBvCwl\nhcdHuUeDgz31sQkrcIkyae8v5YwWDVcnxitr1wIhAK0JcZvStaX9aPZYuq4dav0j\nMk8ydbb4cUoe+L8BPtpM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4992", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4992` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAUFEbaGrd1mUt/k7LUl72pzAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxZjQ5OTQ0LTYwZGEtNDdjZC1iNDFhLTVmNTJhZDQzYjc0NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDMwMWIzYWMtOGFk\nNS00MmI4LWE5ZmEtZjA0Y2VhY2NjZGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE+cn7zf39PbUaa3F6Sm/2JvlMdhE/6pa8YhV4PAp4vPUaryuSkxuk8Ptiybi\n5elCwV/YSZIgDBEPDvdbbriijqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQIDeyH6CBEwFU1md5UJIdcXotNYwHwYDVR0j\nBBgwFoAUU2XONxusrSmVIM/oyNAwKh7pcRQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBAaZ8RAw6ePo85RF3XHJbbzfejMC+0AdzV\nhEyz8ihDYgIhAO7fVktq0Vm+lPBLBFAaU0OEnQvQtpEDua/b3rR8em6R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAer5xKKr1mt+PHMt1nvDgxSCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMWY0OTk0NC02MGRhLTQ3Y2QtYjQxYS01ZjUyYWQ0M2I3NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEbZasAKsRICrqg+ll6l3i+0JotdrQo4riycgP/VF7sYvv\nw/Spvi4cKjgGFEWsCO77n3pH0SgsfU5ozc423jgQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU2XONxusrSmVIM/oyNAwKh7p\ncRQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHpKFqxfJNxBEkaGdD2P/epLyx5XOMZWzUxtCZeOa+EgCIQCRHaDd2sak\n5Dsi/C9AYPgUdqHUfuzvLi4cfVFrMdGmjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAT2PU1zdrYqAwOhxf4f0lVFJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDMwMWIzYWMtOGFkNS00MmI4LWE5ZmEtZjA0Y2VhY2NjZGQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjUzNjM4ODktNGMwNy00ODZlLThlMDQtMTRiY2U1MGEy\nYTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEciVF0wjXAvFE6uQ+vjsOT5TS\nMXu0ludVUjZm1j7Q3znuMla0xzjcUK0GLrt1XKgZBEFL/Kzl5JrLh9Qj/PLUYKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQIDeyH6CBEwFU1md5UJIdcXotNYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGC0wZ9b\nP4MooVQZqHPMwy6CLNFGJdc8d+h1v5zQ5rJFAiEAs2jzjAFnkaeqCDBRFnIr7SHK\nNba/P8ICpQJBVwPP7Tg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4993", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4993` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAXkcizU6bwTcM3Zg8vbDZLyWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0MThjYTdiLTcwNmItNDMyMC04MjljLTI1ODIwYTE4YThlZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ2MGM4ZGMtNTlh\nZi00NGMwLTliNjAtNDg2OTkxNzNlZjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUb1ypeleIe+DLHTxEBgJJzcQXjFLls+dkyVoelJiNSEBxnTL2MUGhUaCj9ps\nc7Bw42riwFfRHcqLhRD5ICePz6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDmMVnD7mCEmuWXd3jIDXQp7cI+wwHwYDVR0j\nBBgwFoAUDmNI4doItpA2OLMlVVC9lX0physwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAimxjBNyDLv4t\nlUyl0uuuMbAZcTID7vuqcfvPEd8ueJMCIAdcYgBwvVh5sTsZtg49Jb18p2z9B2f1\nmX7ShaL6Gq+p\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW30ZbXnKzpNEkctWcsdeGkYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDE4Y2E3Yi03MDZiLTQzMjAtODI5Yy0yNTgyMGExOGE4ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlldAoQDkoMNc4SdLudHy2WMRG8Op00dXpnbaJgnIEJObt\nfcTchnLPwBhaDOBcoBKTwnSjZlk2M7tnAgs1RQAJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDmNI4doItpA2OLMlVVC9lX0p\nhyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLhfS4qwUiMh5rNkGZl+mcQCvXTxWsruX+mHDIVgxDTMCIHqtKM/CuZVY\nK+Y0kydSojwG7S7NRBhuduPxFkhxGW8K\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAWftx0q6/Tq/hOglntNkkpjwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ2MGM4ZGMtNTlhZi00NGMwLTliNjAtNDg2OTkxNzNlZjFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzEyNjFhMDEtNzJmMC00MDMyLTg0MmYtNWVkODFiZmQ3\nZjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeqSxn1nCrJjszh7Jsj4jetSh\nDrDg9dQVJiAjQ0L1Z2AElRDKCsXE+T8BTHGXzEWTs/Rt+4YjA1qm7Ngoe9bMiqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDmMVnD7mCEmuWXd3jIDXQp7cI+wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCwcf8N\n+nm4aXblP2KcENxwwBY+4AiWF4SPRuxCdxtqpwIhAPLJYn/fstfdLjzAhDTQhX4v\nTOIpP++O5NjtzIbiPNdd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4994", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4994` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfDGIACHmzjqQeb+IcBw7rAeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMmEyYjhmLTA4ODktNGEyNi04Mjg4LWUxMWU0YzQxZWQ1MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk5YzM3NmEtNTE0\nZS00Yjk3LTlmNTgtNDEyMzhhNWJkZmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzlE/qqJH15WmGv80A5PW2FeBWojYABXd3x/L9Ffo7htnGrr8Mjjpb1BIxf4v\nv5hsTgcPxHA6zdrrJoS71smmL6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Ubveco1b8yKeFPP5FwLt3CTZewwHwYDVR0j\nBBgwFoAU320Hd0D5ku4S14O3oGM+zLvPqJowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHywYl+R11cayeFAhMjqHJDyBU1b1H2toQ5EEGtKj58/AiBOCtlHyFwgrKxd\nR5nXoFNLFT03jd5BRMJO6f8Jofa8Gg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWXBoDb7w3jfrUPI96O6ZAqfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzJhMmI4Zi0wODg5LTRhMjYtODI4OC1lMTFlNGM0MWVkNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARC57jcT4U1beDh3uOFYOYC66LBs4lrfLrkPfHGtzTq0ezC\n9rizheliYrYiNoXsvQCosHOxpiXvRHlghbZ+AQ+eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU320Hd0D5ku4S14O3oGM+zLvP\nqJowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOwvnhDTZmS6KsnCkVmkE/SNsvfLOnJAWM4vdHmdjZ/xAiEA/iNysI4l\nd8ZnofxmD0AliOp2uxhOZ040MGQtjHFU2uQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAU3NnayGILk366PJ7zRLDLNaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk5YzM3NmEtNTE0ZS00Yjk3LTlmNTgtNDEyMzhhNWJkZmQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmVjZjNhODMtZmIyOS00ZTM4LWI5MmQtOTQ5OGZkNDdi\nZGMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwYBYj4mgakWPpwGgHdD7g1uG\npzsJMPMhzf2zFlU3q/SUA5mzaof1Q9adSnvEhn2fH/8fcPRNjCnK5ORNkBtgaqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7Ubveco1b8yKeFPP5FwLt3CTZewwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDF3Cqj\n525QlT6BJFqbecSvDB7ql1EpciYCW3TGtfPxRwIhAOKJ6StQsNSQl3tmADM95hJH\np2+ef+7QncfVlionQ2jW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4995", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4995` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATG6yOOlHFifQSNFNhyq6l2/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3YmJmOGYyLWZhYWUtNGY3OC1hYWFiLWM3NzRjM2UzM2U5NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQyOWM3MmItMmQw\nZC00YTRjLWFjNTYtYzE1OTQ5ZjE2MjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe6/r8CT+1wKMVlXyqrltJ/ei33NDncZEtSnB8N5unvaDtAUoVPGlIIaMPcIw\nEwA9XAdVVKuGIRNDQdBFosqlVaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsbyseCZa1pzRnN8r3RKbOvvY+SkwHwYDVR0j\nBBgwFoAUQZyTVM+5KNcsVyrMNwD76i/Y6ZUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDORuyw6tmRLt8n9Rn9G1fU0H5YMMSb8eg7a0RLR+9pcwIhAOw2MmbKw0q2\nmTBLcS+gsj4kAT0PpNJKiPIe7i+3x9rP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATWsDnCeA8v1xYLnDDY0/SGyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2JiZjhmMi1mYWFlLTRmNzgtYWFhYi1jNzc0YzNlMzNlOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsZuIgZdHt1BZ8l5lSHcKfd5s2Nc3jHcKJR47m0/7nRZF7\nwoZDRVrMRQwuxqbXgzs/fMcq27/vkYiHZzHfeIexo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQZyTVM+5KNcsVyrMNwD76i/Y\n6ZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIQ3MiUIWc4heVXHDi+/CyJEh28hKCe2pGj81zlXoQz/AiB6Ff8hrTcl\n9HIIElKIHihD06OSKah32QpR+vc5qN9isw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbdfgDjnByD4WuNcDmdoisUSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQyOWM3MmItMmQwZC00YTRjLWFjNTYtYzE1OTQ5ZjE2MjQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWFiZmIxNWYtYzZlYS00MTcxLWExYjgtYTRiMGE2MjI4\nOGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM0hkzwZDfpHQYmphi4cVjxPW\nQH2e7ZtPO6EAlpWSRsUT7SO3L2HyFXfLddudKm7lb8PXp/J1dIiqJ8q8X88+JKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsbyseCZa1pzRnN8r3RKbOvvY+SkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCdZ50/\nod/ax2ucUBb3qaGpo0keuIaDHnaaNHpp0KO/7QIgPx0bSI8ZmSBly/NAEuCZ6zhx\nwkG7PDJWS9aG5kjvv0A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4996", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4996` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYsYZfDYgqS4zRZZrEtu6ocxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZWYxOGUzLTliYWEtNGMyZC1hZmQ4LWEwYzg5NGIwZWMwYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdiYTZkMzMtN2I1\nYy00ZGU2LTlmNzAtZWIxZGU0MWY0ODFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAckTAyMVt7s7s9gnR16nTVetSSSioErdLTtnU8eJh/O37M+fwsjGooFqWKh8\nFBscRURxMF3J2SLpSxs2a0/YbaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwPf1al6mO8sdfz+bHmRVWPs9q60wHwYDVR0j\nBBgwFoAUHrhRwNyQZKxiPPTLIH2bBLtdxUswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA3CQDacHza9slgkT4SS3+6rhEDEXJbjJhJVUaY+O66YgCIGkNP9P2Va0f\nVhjhrddq7FOIzNHFTvnYwZNj5BBvs4P+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeSUgr96cZRSSe16zspmyD06MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2VmMThlMy05YmFhLTRjMmQtYWZkOC1hMGM4OTRiMGVjMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtRqovva3QvvT0AMQms+qdVmoOMvm2fTYebsERIjCW3fZe\nKQ74GjekbUv0UmjXFKrivfHMemunUn7XT6irtY5io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHrhRwNyQZKxiPPTLIH2bBLtd\nxUswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUTsAxIY4qNaEaApMHWF6k2M9/D+/wvonDXfYjhmphbsCIQDxH48demOt\nAyz08C6519aeFSUMAnS+EjC+BEVK7EUowQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATw5M26EpZXpuCtSA94lsACsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdiYTZkMzMtN2I1Yy00ZGU2LTlmNzAtZWIxZGU0MWY0ODFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTA5ZDE5ZTUtODgzMS00YTUyLWI3OGYtOTcyZWQ5OTE0\nNTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtgBDN0VF9BIuOdtZmyRaCSYT\nTnc1n66WQzfLrSCSkVQUMLsvHZ3+8n0uO3M/xCXka7JyJuRqxM2yVNRKx4u1yKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwPf1al6mO8sdfz+bHmRVWPs9q60wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGB3pexk\nDf10wzqF7nWbdL3M16BMSjIvjku5HA56EBpJAiEA83NPNSU4qETPkg94cA+oOd4y\noVOJ5v6pK1TNxVjKR0M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4997", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4997` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAaGLMqMsHQVJVe/b60Pmvt9gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMzY5NzBlLTIzZDYtNDE1Ni1iMjZmLWRjYTdhMTQ5MTg1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJhYzgxY2ItOWJj\nZS00YTVmLWI4OGUtMmFkOWI5NjhiODhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcznEhpWpwcGHixBXRgEtDozFalEYU0JaF64NHp68EuuA8heYnEkh4zu5UJSz\nv8LBetWkR5101XDYY2flhbTsUKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyZKBeV1vwnu/TvWBLXNJvqlQ3r8wHwYDVR0j\nBBgwFoAUkZjjpPkjmn8canDvxcVxOTFjg8EwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBEEigwDBAEzUlMq08mIEC0838u5tXN1amCqpM25Nv6\nkgIgX+6LurO3OCZahbzwjK7ZxM1vl25DTChb8KpkLkq/9Q4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYIexix++L/q7uEyir6WF9GqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzM2OTcwZS0yM2Q2LTQxNTYtYjI2Zi1kY2E3YTE0OTE4NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNK9J5tZxwbl2lzZbvC7aHWfQxX2RF5MjpMSttZyiMcPth\nyrBjANhtcPixeZzY1yAgCAlvnPcyntcaDSxMB1Qho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkZjjpPkjmn8canDvxcVxOTFj\ng8EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJeuTT+GXUVamCkJOP18BkLQFXOjWv9vc4gMulVLPPkAAiEAv6oZBgoK\nH2cC23D4h9Y+QA991+JNxRLgsoHrh7N/HSc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAZMxB9AXmQaOexYRQtfG546SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJhYzgxY2ItOWJjZS00YTVmLWI4OGUtMmFkOWI5NjhiODhjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjNjZTI5ZDktZmZlYy00YmJhLWE2MTMtOWUxOThlZDI4\nOGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETDLB+HBAPoMKc9maKCarS7kp\nVHHQ8qeQXkAowmLG2jhpvzm5mPI18XwkbWW0CLINAOJtSLf+zGyor5w40fycXKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyZKBeV1vwnu/TvWBLXNJvqlQ3r8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDHgA3x\nHpLootN81U2vrA8S8KrM2yksZ9L+RAXul143DAIhAO7cDP4FOg4ql6r9oOCZt/lb\ndPlG576qhLBhPKC18efV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4998", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4998` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAURgCzI8nEX/xg7Pr3V/rXUKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlOTQyZmY5LTA0N2UtNDI0Zi1hMzg1LWY1OTE0MzNjNWZmODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhjYzEyOTEtYjM3\nNS00YmEwLWFiMDItMjI2NzI5MDAyMzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5D5M4ZcHae2CGlTciGKMSTihNv36aQJKX6t9g0FRBO35S2uwiO6ALvbJKysZ\neOKVr4stMcEsPSbwDxawDYIvQ6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOwcgKbiFo+WUm9hQU9mpXcE11O4wHwYDVR0j\nBBgwFoAUv9kKQdPqCHpn0IEVhdE1F5LGdG8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiA1aAlco/XhUtZ94jY7GNdkD+WuVa4GRSOTU763MaCb\nJwIgIpTLNY0rAGb4w507Q3WGjWrJktFOPboT/vpB8J3CZwc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWTfJSGU6Yc2ficXbpsdXpoAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTk0MmZmOS0wNDdlLTQyNGYtYTM4NS1mNTkxNDMzYzVmZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0eFaJFRcMIBmw6RZQD3stEyX8cAQx6IJKnGHIIsCqCp5v\npNg+Zta3GTy6dRo6nCLbI9GXsrnL8sAEpIuJvjw/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv9kKQdPqCHpn0IEVhdE1F5LG\ndG8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgT7J6q9L2Ogygpd5ddYhdi71Li+9GWP6os1GOpXydn3MCIQDKBr29mxxw\nAOnCUBqQtvsuRJKzCldJLspzJwGFssS/Lw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXHgaFT/cI70P7M4fsHmxcOHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhjYzEyOTEtYjM3NS00YmEwLWFiMDItMjI2NzI5MDAyMzI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzU5M2Y2OTQtNTUxNi00NjhhLTk1ODctMTQxYjY0ZDQy\nYzgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6yD8ht5gtiHLYk0ebHCeewln\nvs7rtin7aCVoccDx3n9vivei6gg/Sr7VgRbUVKnd1o/3e3NQUnb/U+a5Sz+1X6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOwcgKbiFo+WUm9hQU9mpXcE11O4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDiXN1AQ\nejfo22iGtpLV3OjJKa73aXg6Nk6nfT8Y2RKZAiBdXos3rO0waScMfqbHaAN0t7wf\n2rAaMu3FjjGv/44NUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc4999", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4999` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVa7XcFXlN5yt3IYaMUgZWNcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NTUxODRlLWI3MWMtNDlhOC04YWZkLWZiYzVhODY5MDgwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQwODg2NGUtZDkx\nMi00MDI3LTk3NjMtNzRjMmJmZTNiYmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVgsV36PkKWt3xRwTQ8GIHLYO/D9n4NVP4W3q+t5RMpYFfa1/JplsiBWcxaiE\nK+WVoqCyvFhj6D7SOY7dVft86aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJjsoa6HnJAZRLX0uYmBvXbKxlzgwHwYDVR0j\nBBgwFoAUKtoVXXRASTQlu/yKz2ytPkbS8ZEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA/sevvkQmKoTknINrv3wnUo0QP0mdyirk+iR+F5dE4HcCIDoT\n8AlGXzV4DoVAqJqst7Y22H7EYwtWlNyEgou2uov4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa+eugEYTLMR6+IHrUHSogIbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODU1MTg0ZS1iNzFjLTQ5YTgtOGFmZC1mYmM1YTg2OTA4MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0FMqCja194wnP0kWsWFl2MDn+zDCWTnDvxLmG6wU0I/y8\n6AX5U55uE4s+FIhW3rm8ozn5p4uCWD5r4Kvwlbjso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKtoVXXRASTQlu/yKz2ytPkbS\n8ZEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANco4yqluSzdxB00W37UzC5KapK8cxIRBQo6HI7NCLjZAiAf/cbn4Njf\n3hTtOD8HBJItcLBsMPwxQ4oZT6VfdJwKRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUr80PSL0q6sRp0MtTC/7sU/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQwODg2NGUtZDkxMi00MDI3LTk3NjMtNzRjMmJmZTNiYmE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTk2ZjY1MWUtZjA5Mi00N2FiLWIyNDYtZmJkZTJlYjU0\nNWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE21gRMr44TAs1cGukGUqVgSnl\ngsZbxP/J0lYcGwVDya3BpdMmZuzfNJ2l7gXaFbLNkjSSujguFFvfOiUvvdVJG6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJjsoa6HnJAZRLX0uYmBvXbKxlzgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDYxPqi\nripSX+iRUzCBrMAzWmBAT5oHCSjU8wRv5rxYxwIgB/S2eMhFEOkq3YHVXVoLbZN9\n6wizQ+Iu+tQPQRgtWEU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5000", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5000` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARTmBXqmQCJfXvPYGLaL2u5wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5N2NmYWFjLWQzYWYtNGEzYS04NDczLTZiNTQ1ZjZhNzM4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk0NWZmY2MtNjUy\nOS00YmM4LThhMDMtZTdlMjhkZDgwOTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/mt1sGwriKhkLa+9kOEqjJXQH6PRUB0pV9RCd4KhHWWMPNmJQzOTtIFgzy3e\nSZNFdokjABtsox9BJIxQffwHYKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUrQ8/+nz43ngpAWc9ZfMREad2fowHwYDVR0j\nBBgwFoAUuinasnulm5dJQ4AUAVuyLlvOsUowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAu1ni1Ob/pHX4AcEWPeP2Ohni/Ctqjn0kv\nhAwj6TCn8gIhAMvW9FSpgvqd8Y+2Mxk5wMHZemueDP/Pl3wD0BzC7XZ3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQphuhn0Mbo84gPNIfTRRo4PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTdjZmFhYy1kM2FmLTRhM2EtODQ3My02YjU0NWY2YTczOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6rIdUu5IsUAdtbMDfRNDhzdyXEIvRbMg3kXkAUrN1DnF9\n5gHaRFMT6vLcYCzSKoW2IINxxEAzvwNIXrP2bF6go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuinasnulm5dJQ4AUAVuyLlvO\nsUowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKEcFNfIQPE8AcKv3keuYc1WFMNwhoLgFNaF3VwjJmQHAiBYOquujGhb\nJnY1+hYz3iUerje/DCpke12ZnYpp+paPdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWYK5N1pcFg2gVRm4i2Fn/yDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk0NWZmY2MtNjUyOS00YmM4LThhMDMtZTdlMjhkZDgwOTkxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjFlMmE5Y2MtOWFmNC00YWQ4LWIwNDMtZjA0NjllYmQ1\nNzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM2RjeQxi2I7z5lTPVZW5Nh0z\n+moxl7fILcfejrysO8F+BnAWaZSTgJ43FLa7UZTuqqSzxNTNMh0dXjwgQZXE/aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUrQ8/+nz43ngpAWc9ZfMREad2fowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBWcCxUL\nUXYbgIlfZoIJPhwQhRoGB060h+/xj0AUXlo1AiEAmXGI+UmSRBJksT4oRj7K0Fqp\nhnxTFz3udDIqUPEvStE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5001", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5001` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAZNt5IglNcgc4bSJvfDAJ6bdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwYzRiMDg2LTQzNGYtNDgxOS05YWJjLWE1NTQ0NjhlOGM4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRmOTRmMDQtZjU2\nYS00MDAwLWI1N2EtZjNkOGU4MTA1YWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg2CIA9ZnIrQZDrMFHDsf69hTchM/sYyRSftTPKrXwRPp8HT1e4bTBBGY72eD\nBaIcKWXs/cr0Vcp1GLeW3SQdQ6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6bjmtFxDa7e+EbIDnkPUNWiIQkEwHwYDVR0j\nBBgwFoAU6tZXu7J2Oa/nfm8UJcd82CbUD6QwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBhja/9RArUR8vWCmPXlklWJiJIlIPaQQB/\nxD6EI5YGEwIgP7R236dZlVlQCwIWyjwygaY1R6LZPBwcQub0IX7RMew=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARKLjhV1KkmvqAWONUEq3tMIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGM0YjA4Ni00MzRmLTQ4MTktOWFiYy1hNTU0NDY4ZThjOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToskOl3v1qAVY1qVeorlIOTCw1cyX6GQ2CfYw7myXsY1NN\n814Kq1FAjY8nkEmBkpdCVjvq3eKQ52L1zMEtpZZ7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6tZXu7J2Oa/nfm8UJcd82CbU\nD6QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfNpX0AbYzHbtCafNwgVOlO5Cnq0WV+jblBeX240rLPcCIFZJ+xEDt7Q7\nzgTu4s/8cEdzOjJwDgCp1lnfjUAuWUH1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAa3RC8EU1Qp/zRudPnm6QmdlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRmOTRmMDQtZjU2YS00MDAwLWI1N2EtZjNkOGU4MTA1YWUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjdiMzZhYzAtMjI2Mi00MDZmLThlNjQtZDM2OTIyNDk0\nODlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDpWi2SY4rSCD+IJl96P+wJXh\nRogI1mmzfN4dtQi5beubH5rib8Cccv2klRlrhtjHQm2yo7PTpJKojGE6Tq99UKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6bjmtFxDa7e+EbIDnkPUNWiIQkEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFRz6fh+\nPUC5raUMNvhQughSIxQ1w0GZnL3FS/1fkyTMAiEA6JrUVFr4LT1C+O/Slfgq18YA\nMVgmVPCiRwwuLODgL4E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5002", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5002` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAbuGxPg0Xuv2G4mI9rvvkDr7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlYmRjZGJjLTlhOGQtNGQ3MC05ZDExLWFhYTA1ZTY5OTZiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFhMTdjMDgtY2Nj\nZS00MTg5LTg3ZmMtM2M0Y2FhMDAxZmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELPCvjBH60ZoO6tukYw830gwIgU3pWlU3XQijci8hYz9pBYFlJtVjZ9Pjq/9A\nva0C22iFpYLiOUV7osvZN/jsy6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhef/OTtrT+LdIriVNcRn6ZMEGk4wHwYDVR0j\nBBgwFoAUpee+Il8Kz35slM92+rNPumejg9AwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDgw2N2nUwgQauP4YjdfJMGVWGa\nCaiGgGEWwwy0QmO0RgIhALAib4z6X2+BUa1pdejC0qkbIUFZ6J7blzPmYH1JSxt2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWHD0dxtEG16PyOFKUNKlGYxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZWJkY2RiYy05YThkLTRkNzAtOWQxMS1hYWEwNWU2OTk2YmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaBb+nj8jUuYhSp8kHEf+mK0s6buNDUPBv+//OCf7UWqr3\n8ZalaFmk9poi/D8cDG4C33vlSiG73mYjAzBrpJ63o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpee+Il8Kz35slM92+rNPumej\ng9AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMrBxrh5Nl+WZVDzj3YFa8NQ0hbEYEhvCmx8P9BBAlEMAiEAxp3FYRLS\nGorFUClokcMfjOaEax29eSljontIBSWuTg0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAafXOC31gLhmUYp8fFbvFHh9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFhMTdjMDgtY2NjZS00MTg5LTg3ZmMtM2M0Y2FhMDAxZmEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmIzMzVjYzYtODUzOC00OTM4LTg3YWQtYzE0YzAwNTU0\nOTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYckWgzySBRpVbkKcw+vVmbQv\nbnBtTu/c9YjoaxvycYzq9S0tctC424ctRmQd3RzobXGL5c850FnGsMBp6tl5QaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhef/OTtrT+LdIriVNcRn6ZMEGk4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAk8PUEd\nTpHCVCjFxJv9kTGov54TPx/csyWy6tzz00w9AiAogwiX6vMVASu5u54hHgXy/Hk5\nFezm9JUpYGAFw3Q4tg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5003", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5003` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAdHREbozhAmg0ckhcgaCsgxVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxYWIxOTY5LTZhYjEtNGMwMy1hZGI5LTczZDVjOGMwMzA0NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk1ZjJmMDUtNzNh\nMS00NzQ1LTgyMjgtMGE5MWIyM2VhOWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECyFY8kX+PBDWV5jzLL9kCXrvAeTtkK3HQQ91XvMwJkCou3WNLj3aBMcKr2Oh\nl6j43SYQo2kmobg0r7DyX8H7XaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUysBh88NXD2QDBeMnwO3+9ORaKokwHwYDVR0j\nBBgwFoAU/HFnI0erhW5WBIYSsoauB3FIV0UwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAN3BKID1\nO0UWkKs+hRXM2kRo1fFHf6naE/Cz2dvXqyf2AiEAuX1vVnnGGLVyPvuwxGQgZBZ9\nO6jI88+gHb1evS9t8NU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATvDHFuhJ0G9i9ryFyapZ0elMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWFiMTk2OS02YWIxLTRjMDMtYWRiOS03M2Q1YzhjMDMwNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvWt3Wfz0Li2ydoPNNoiKJUlZ65dD2XARSc/XhmrS/pcDU\nfFWzzCvXnrQbwvs+ud+DhWXbljbTuO/V0LnZmGO9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/HFnI0erhW5WBIYSsoauB3FI\nV0UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAORTn+pAqQBjhsxp4Cdu4TW9++27Xr19/je6khFtiDYQAiEAlZJMLWuo\nS8mnKizEFJ9HdhaBRlkyz9z/DKZhlEVFImE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVF2jEHgxP8VkEWDJjVkG35YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk1ZjJmMDUtNzNhMS00NzQ1LTgyMjgtMGE5MWIyM2VhOWMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDM4NjIzZDktZWQ0ZC00YTgyLThjZDAtN2U3NTdiZjc2\nODAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMPDjtxdKTupvupUs/xrEZjcm\njd5U9E2YZG/MrfAUEYGsgnP4wcXRQkR1X6+2kPU7ZHF1SFQPL2Phel8V1IOYIaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUysBh88NXD2QDBeMnwO3+9ORaKokwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGER3T+N\ndUi8gU+Ai1isnxIJ/a7rqFsi9aNGKbGA/AfuAiAkunKtFSWHd+acOrCeVmhKr+Pk\noZposL4h3SBgYTAxzg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5004", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5004` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAW+jgyV7HmRE2F+dB/D/kMjBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NzRiMDMxLWU3MmItNGI1NC05ZDUyLWUwZDNlODIyNjdhNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M5MDljNTUtZmY2\nOS00MWNmLTk4ZGUtZTkzYTJlYmUxNjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJLm9m3PrOLdgqIYjwWV3yRhYkHUS/W7ohWLEC6VkpCoMdbvodqg2wJaui+wf\n5z0O1WLg1RAktklRsCf/1Z3zyqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKqq5YJ5zRxbIT1feQBVZdwNCRGMwHwYDVR0j\nBBgwFoAUlu6qtA1V6fwVyn281BGhVzw0+B8wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgEO8UeBts\n9J3VWWg8YnjDGfP8p6w8aEtPlVMKK/nBiGYCIQCcncOJLiwMp4fsemAGYQAOKhwJ\nTcG4Ebot+dzZH38r3Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVFHeiN7OoUDJWdOaVeLb2t6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODc0YjAzMS1lNzJiLTRiNTQtOWQ1Mi1lMGQzZTgyMjY3YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEEhkKty0YSZW7ptYWgMdVskQXCMwgFuSr1kqnbjCZjjvx\nLqY/+WbTJamiDQeb+YhkUS3bpDyz7oViNDov7foYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlu6qtA1V6fwVyn281BGhVzw0\n+B8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYVHbpUU9ed6Vphx8ZjqodELPcX91jJfH+Fh+F77Gl0MCIQDddpgezxt8\n0ZMEGmkcyfpm50A+1IRS4lhwLRYn/eHv/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQKoi/9lSaS/oypajInzP2O5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M5MDljNTUtZmY2OS00MWNmLTk4ZGUtZTkzYTJlYmUxNjJkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWY2N2ZlYzAtMjc0Ny00YWEzLTgwM2MtMTM5YTY3NjBh\nMjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/XkKUWvssRsyreb5l7MS76PI\nDurqU4pNBV4CbBu6bmIaoFEWKlfj/U7P1pGcDqsJPsW1O3w8E5txCl3bmmUtBaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKqq5YJ5zRxbIT1feQBVZdwNCRGMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDqbaoh\n2okGl1ORD/SUq9Ym5+KOnHHHU/9w7MsrTQJ66gIgFo4SkZ01V4H52S6ZdEgz57Bl\nwiDJhqIi0KLTrE0yeL4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5005", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5005` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISASHpXEKaI6d85sYQckHjXOm0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNTM4YTFkLTcwZGQtNDgyZC04NTc3LWM2MjRjOWM0MGY0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE5ZTZjMWUtNGM5\nMy00ZDQwLTgwZTktMjgwZjMwNjk5OTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvUWcaMLqSckDuF+GaYbEU25VawtYqszIo7uCb5oYHqH1GCGO2zNHTJXOFbpf\ncH91FQ/AS7R2Sr50o1kAmcqmUqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEa0prYTtjBjRp9o008MkuVK7mecwHwYDVR0j\nBBgwFoAUBVoZz4f3GJcXXi5OuToUmUQ9o78wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAQzuHEc\n19t55cX+sNdaUPnunlhwCQnMzpVW1SHwCnV7AiEAg8vVI84rYXBjbIxYJzHglhaB\ncddhtCUymEAM2GzucrI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQvVPSYqTTg1Bhi4teAZ1j6yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjUzOGExZC03MGRkLTQ4MmQtODU3Ny1jNjI0YzljNDBmNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATViRdzvhdg51JbRkBTxZwGqE8VLowhRW6uL250CJiN2YfV\nAEK51hPVfkLHFzV0kIRW9ewzvX/HANIjHZnlRQhlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBVoZz4f3GJcXXi5OuToUmUQ9\no78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK7NewpeYorIOmXWAJtq5Ox4zIY+8jWE2ieAsPEDcelSAiEAgfZEe3P9\nmDs5PDj0utaYfz6eCSu+NtWaacWYhOQDgF0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdGvFEpIimc2flwVQOIr8zeSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE5ZTZjMWUtNGM5My00ZDQwLTgwZTktMjgwZjMwNjk5OTM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWJmMjFhZGUtMTFmNy00MWM5LTk3OTEtYTVhMzdlNDM1\nYmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQ68PuopK0U/yiFJh0bFakXJN\nrg9zwe2fZ6WbQdr7+PcNPC80uV8EqPOb7MEYghU1rQAvKuIfKUJ+r5mltnosTKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEa0prYTtjBjRp9o008MkuVK7mecwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDc4atE\nGeMF0MQMN6pdElmCiWVRWGkJBiDlzMibNvpRHAIgORCfrdn4NqhzmNjAbtnnMN1m\nJH3LFMo8eJydeJuWc04=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5006", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5006` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAfq1R5XUfmiHgmTT2KgzIcSMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5OTRhMTNhLTk3MzctNDNlZi05OTQ5LTU5OTMzNjVkNzcxMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJlOWNmNmUtMmFh\nZC00ZTIwLWJmZTUtYTM2Y2U0M2Q4ZDM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy4EXxbvrGqGL3R7KcggBAPcExD+CsFM4IWx4uTFelzbsUCLM+67VeEnCUV+V\nfdfmucwHALkfiJmsmWBJHCDueKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWLJEYG6bewsJQULzvXSvWHk1NogwHwYDVR0j\nBBgwFoAUyQ5qYTnWeR50jEHaN+JLI8hOsgUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCICAKzzk/JMnkc712+RIY7xvmHo+JEIQ8l1AM21z2IIdnAiEAgr7ZUxyN\nmzWFwKq1p49VBl/O18Hw7Z2xCu+PP/mxAgc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATOj2VJbwX5zsJAPIjynU8g/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTk0YTEzYS05NzM3LTQzZWYtOTk0OS01OTkzMzY1ZDc3MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATerHoI8q1nrNvdD4INtJd/7bkPrKlzlqC4Ly9eTL+OLcB+\npEfW7Mxv+1fq89vJLTOEQM4Ftj1VXrgKyKVEAA2yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyQ5qYTnWeR50jEHaN+JLI8hO\nsgUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALSzXZwtzopjqEMnfeDrLUosfjCjDoamPXqqwqLeXTmsAiBLC82d8y5P\n42OWDr9andlGTtVsLC/ALHpxjxY0DihAwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUFvTjCPyWOYYE7hP40cQXmGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJlOWNmNmUtMmFhZC00ZTIwLWJmZTUtYTM2Y2U0M2Q4ZDM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTUwZTY4YTItNzBmYS00OTdmLWI0NTItNDQwMGI3MThm\nYTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESmKpXLYkpMbAdDdgdqrnQf/A\n/xi6FoBYffHyL05ooxFh7S7tDfrJmK6nEkIHoM6lNGMSmtqKMyZo+YOnYaWdGqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWLJEYG6bewsJQULzvXSvWHk1NogwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCJz6g5\nH5pijmgCFzs1Niq8gHeqdzWIKifhWzzYLIwrUAIhAKv9Yl1aHhjQ71kN843q4mKJ\nQEtQEWl2qthUmRRrce7a\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5007", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5007` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAXM62mKXZ8J5Myy63fmn6+rnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5OThiNDdmLTUwY2EtNDBiMS04MjA1LTRjZmYxYzAyNTE1NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ0YWU1NmEtOGYx\nZC00NmRmLTk1OTUtZjVkYzhjYWFkNTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExj0E/eBgoG+Wqc5xbbfVAqPNnm7rG7u1bU5tv1p4eFlvUxqOVqPpbx7WjMhU\nrqQW8CMzxpsW9HSVwivlIvbKQKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY6IQhaBILIBop1GVS79qnLYzydkwHwYDVR0j\nBBgwFoAUl/0SSUe3haYgRKXftw+jFJk7y4owOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCFTz6cZKhPNIOm0qNuY2zw0A/NyXj3ZevrbqmlfMRFhwIhAOXPK1/J\neDMYHMsXGrDQh3Zr6s45ZClnQDXBGyIAjmgf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdenE0nEDags2l3RYD7E5nj9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTk4YjQ3Zi01MGNhLTQwYjEtODIwNS00Y2ZmMWMwMjUxNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZ+qRljBKsaDSzQataAnoXafdYIVMTqQVOfwvFvOJyIY7z\nHyaDS8K7FyQIlhoSvHKSWh0blMQX6Cyo5AWsvgdUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl/0SSUe3haYgRKXftw+jFJk7\ny4owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCSgpCJXOzrQTBtq0yQl8y+oH5vVWrzQCKJJ1gIzN1OsCIQCaRN7sg8WP\nvqQNotyBB7kjnbbR5dGKOntMNEECjXssBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWKNIvJcKKHNr/nqSlPXR4NXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ0YWU1NmEtOGYxZC00NmRmLTk1OTUtZjVkYzhjYWFkNTM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmViZTViYjQtNzI4NS00YmM4LWJjMTEtNmVkMzYwNzc5\nZTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAES4aREc352xbHQznlZrJ2kybK\np/+8Ke/ttikRe53eKUwey7Vvcz5xAassL4j5lIYVFTzKbhZ/5SQyJ+QlVw5BcaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY6IQhaBILIBop1GVS79qnLYzydkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDemNRn\nBlbLKrKlJfCvCskyHwIrVgzwYxbbqG6JgUkB/wIgT3B7cQp20AKe2G78Sk+49DLb\ny/5c5dJMRuOzVifx4bg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5008", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5008` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAUa0AirkKlQralCa1YRyOuYbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjOGRhNDIxLTNhYjUtNDIwMy05ZWVhLTFhZDkzYWQwZjMyMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE0NWJmZjUtMzFi\nZC00YzlhLWIyOGYtZjI4MjY2NWIyNGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJs6ljbP4gEb54L1opQIKzNuUPrnGfHbDq79ica0VIk6qfN4nRzcwL6GsvHWD\nZzEgQHzGYLOa21xkDDJvjm4CxKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYl5id4KW8vXbqWnhTR5LB1ZyLLIwHwYDVR0j\nBBgwFoAUXx1bpu4713VqbR2Zf8MuvE1QWDYwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIFZqwOR8JVhD43yisTKTdDMZGcMnEwHpKRJxS3Gt2En3AiBhs0hgwcrakWQ1lqmT\nMQFoHGEyqB+MyS5pMoPVj+/laA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaGPcDBt2ZSx7KXR2vUc7bFlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzhkYTQyMS0zYWI1LTQyMDMtOWVlYS0xYWQ5M2FkMGYzMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9NNIUw5ni8JEHMfD+LRFmZyzDHC3kQd1ps+iKpt65Bbr0\nWBQGHLWnM76lYZ5ypliB4fQ8sT4FAOqEa9LUprPvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXx1bpu4713VqbR2Zf8MuvE1Q\nWDYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcnxxI6zHSohkCUgluzJTa6IMvmX61R64Jpucb55od1ACICZKX9O5cG5i\nxgFRhTKf7lS+scj6lHeN1/BSUD9x+Pbf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfLmuMLRhvvuWRgGk/4R1vdAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE0NWJmZjUtMzFiZC00YzlhLWIyOGYtZjI4MjY2NWIyNGZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTg0ZmY4NzAtODVmNy00YmUxLWJhZGYtNjMxYmNkZmQx\nYzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoA+ZvQIMGfRxDjPDFwP8WSTy\nu8vRTQ7GVhkbffFEjHcHp1PvP5lCGSKTBM6n/GEmoyNXkNKFPstyV6O8dNgh/6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYl5id4KW8vXbqWnhTR5LB1ZyLLIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHjdfN3L\nmJ+q7ClzqP0rZSyh3HkPq6OLCf3CDeukD4mAAiEAkcSmRzr1h46Rt4Vt58kFLnf9\nrFoN2wIQZkesk5AELd0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5009", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5009` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAVwp1ALxG4oq4qiYm5w5wqHxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2M2JmM2QxLWQyOWYtNDY3Yy1hNTQ4LWYyYmE3NWQ2MzhkYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY0YWRjNGYtMzkz\nNS00MTM1LWJhMWMtNjM0YmMxYjQxMjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUFYDQ0k7dC47DBTyQbYcDrfVkbGylZtDjfoJyhp5Elpn4NEj/kOO13T/RFbw\nb0zD8SSPD+8qEadi9JnNePkqQKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURkzYzHQ7pSfr4/Xi3/Qna+OsodwwHwYDVR0j\nBBgwFoAUEx4aURuDAvzRZDqy83yRI/HJQYIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQC/2UJPU0+IobVGn4RNc5WHxdJqQI740fEpLT2j+yv11wIh\nAKCa3HynEb/pV55p2ZoN6nCnhE/qr9A862q+ANeacHH0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdpqlkm7VQn8nqqbeeNgBPo0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjNiZjNkMS1kMjlmLTQ2N2MtYTU0OC1mMmJhNzVkNjM4ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQn+cC/IclMgcErtksD5O+1lKObl+DD1MoE4NXM8eiKpH1h\nhXd/8/IWq/nTc7CSTCi3vm4mnLTIQqWR1RqQf33Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEx4aURuDAvzRZDqy83yRI/HJ\nQYIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaQkUDeOC1z+4chE4BhnKS/Hrh7LSK9/am6fE8ycd6RUCIQDDy30a5LC7\nzMASrZ67H6Yv919fD1GoXSJZO5xH/A5emw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQaPlkPk4Lob0dA6icmBjjf+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY0YWRjNGYtMzkzNS00MTM1LWJhMWMtNjM0YmMxYjQxMjUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDUzOWQwYmQtNmIzMS00NDVhLThkNDgtNzM1MDQzNTNh\nZmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsSF1+0J//Y4NOOWTh/OslCpN\nURKuK7TjoH4D9ssHF4Q4BTwCN1XnBte4GDpu9b9amUgWGdIkOk3W2wS7pgTXwqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURkzYzHQ7pSfr4/Xi3/Qna+OsodwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBFtR6t9\nGamz7HdUQ4UXY8p1HsU2+hnp8OfLTSqE3OldAiEAr2pVx+rPn+oFzBsPWVta+PpV\nYBHG/RIe+RHit+o/wr0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5010", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5010` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISASaK3Gae3CDcLM1v5uUJhtU2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlZjk0MjI3LWI2ODgtNDZlMS1iMGMzLWUyYjk5ZjJhMjYzZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRlMWRmNDItNzYw\nNS00NjA3LWFhMmItNjA1OTdiMWE4OWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaLwntXomLuFvs0zLyakBIg4lsxntntIS+OS6kiR3gtBEUtzZMGjNEkhUGqik\nWYxmOSCCenxqjkwnJ3WQrxuxQ6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUudVSW6qQxkWwDumnsyQIMoYsQJ0wHwYDVR0j\nBBgwFoAUSOaW+8ReKVV8HPCadWiVZFkcOHQwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCID7W6mCntE0AcJMWBduLm5FnmuQ0BbtD2Scv7kZVTi2yAiAQ\nJCtosy5VPXXLILKnRZB4gU80+fiAqO9lQw0jTtjwVw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZUd+htvvi5XEMJW5q7rnnouMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZWY5NDIyNy1iNjg4LTQ2ZTEtYjBjMy1lMmI5OWYyYTI2M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlxUgCqdiAnxLPov/Fze/vmM/VXhjpCL2mFrd2zbaDhyYp\nzAgcRZa0aDegrVMuMbF89UU7fWrCN0Nvp81h8nKMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSOaW+8ReKVV8HPCadWiVZFkc\nOHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeWsHLJ5iFsXhdL8f0uaHj3vJNncHGStzMQgDsOB7iqECIDEl9Vb4X1pB\na4zdWJfDwTLXZuq2zWmIad8QIzcNlup9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAToIDY38IWW8kXN9938HAOYxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRlMWRmNDItNzYwNS00NjA3LWFhMmItNjA1OTdiMWE4OWExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjFmZTA5OTAtNDRlMC00N2ExLWE3MWMtYmY3YzExZGY4\nYWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEse573RrFxQ830NDLWMWdnjAI\n6nBXnXkhvWM9rXVDdkR16IEzrFJvgG4n7CaRxHElmbmBBhBrSknrE90ntfFL7qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUudVSW6qQxkWwDumnsyQIMoYsQJ0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIAmTgDhq\nk3jtlgaEhpcnMCgaPa0drG/6YYOP7ixpH+uxAiEAl2m+hIMgHxlIqGprwyC/nlxK\n553A9h0ViipstpqYKmc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5011", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5011` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUpViEG1DN8/ZeFmNGsb0GhuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjMzM2MDQyLTIyMTEtNDA5Yi1hZDIwLTk5Y2EwYWQyNjU5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWE1OGNlYzgtYjc4\nZC00NzExLTk4YjAtYjJhN2E4YWVlZDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDEnXYuJ0r2IHXisE054cv4/liY5HAT0u7KxUuSy+ptssOPBRQWuEVrmVasHP\n5qJIslbUx0bq1JDwwv/V5Cus5aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs1D1HCV2tCeAhtRKiKCUAuIGFH8wHwYDVR0j\nBBgwFoAU/X91wXq/J6peaz25p04bZgt9fGIwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIERv3a4Ekaf5\nLggPQYS7GfOETn+JY+7In0XX8utL98omAiEA7TP05l6tF6qRBLjZlox7k38GAYQD\ncrW5fiGVOeSfKbk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAer8RYLfxMfP1312ZFJWI/2yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzMzNjA0Mi0yMjExLTQwOWItYWQyMC05OWNhMGFkMjY1OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATM2+dD/znC13GFff8ZSul6Z91sVIPi6iDyfqaXPcPZ2ovS\nVgFpTYdIqsmsklKJoKUf+VWP98g3UL56RB/wLgU9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/X91wXq/J6peaz25p04bZgt9\nfGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK7MLPRjc9/0Dj5NTtzXToCljv2ntogiY+22xIevKhGIAiEAw9u8Qd8h\nNTjQ8Za0I35YTR6tN8o+Byly0gOd/SwMhMs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASJDJcGzxE6ccW0+Y7jr0AO4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWE1OGNlYzgtYjc4ZC00NzExLTk4YjAtYjJhN2E4YWVlZDI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjY0MWI2MTQtZDdhMC00OTkwLWI4YWMtMGZkMzJjZjM5\nZDUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETh/AtmW3PWFxiBYp2Isj+tIC\n6/x6q8hOUQetWNsqoWiZ9iCwCuWY+MuONK5dFxhF9zvLuhTYNLSkbZ1+B0G6MqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUs1D1HCV2tCeAhtRKiKCUAuIGFH8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD6Y8ku\nDL7y2u0cLnoTs/P5RnkR/N/5WfbttoBV54dglAIhAKCtY+wfRb9/rWZzJTj7uGkL\nfxKgwJskJZ/DCwO9ibYm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5012", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5012` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAa45BfWlp7VDZrxnrnXBDQiNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyMGM1YmZjLTM1ZWItNDkyNi1hODFjLTZmNGNkZTEwZWU0ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGUxMjBkNTMtMmRk\nMy00ZjU1LWE1MGUtZWMxZTUwZjc0NzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdbHcuQfnsJdmPEP0vMJ5BL0uTj9WKc4KmicoeAF4VoFNlHN6MRtAV6MDu74l\nXGxNcl4KQcSnsSm0Q4Ed2MlMb6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkHPdJKjmIk9opblMc2u+Xwvz+u8wHwYDVR0j\nBBgwFoAUcBYVQn4NA9PaB3eKCWN8E52J53IwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgGy7ZOWP762LcXeRjkbGEL3In6qEYyPzi9XjDAOiIgdoCIFdrNdrKMbuK\nG782NIHmsfJVV1UkeYTX2giCPJ4yLOTp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd68ZWfZMZDeFWmWioD6Nn56MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjBjNWJmYy0zNWViLTQ5MjYtYTgxYy02ZjRjZGUxMGVlNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrB39lswTslVFjbLA+cE6G3WqJlfE4t/0XDLiFy1H+AnfT\n4gB6oNOOa5rSsu6r3Fh4/yOMTjNdeoo7n72gMOfNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcBYVQn4NA9PaB3eKCWN8E52J\n53IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaES5TvS5BFVMeRQKCCgfccZQ3x8HO6rbV0KJA15Tr1MCIGv8xgRe24fo\niyJGDllihw3Aj267xa34uSVkaE5hQhCe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWh6NZ35dLKhCBMCYoIfO4OmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGUxMjBkNTMtMmRkMy00ZjU1LWE1MGUtZWMxZTUwZjc0NzAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDc2MTI1ZjUtZmU5MC00YjIxLWE0MmEtMzlkOTc5MWNm\nOWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAdjwTeXz6X3oOahGz7ud1OgG\nMuqsC+td23iC7V4m71W9dzDpr0Z0nDJ6QtdzHo+jNThCcLfElu4Wv6JZrTLNJ6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkHPdJKjmIk9opblMc2u+Xwvz+u8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDknDB9M\nj+uQNKeUZ/YZSE2lp7wnB2ny2KTpP3tG3DrjAiEAuW7A7/6/b4NJ9c4WY96R1hmI\nEz3PClN4E2BYLdHoBf4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5013", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5013` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAS99Lx3+XJAOAhoAEI9jVNvvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiYWJjY2Y1LTJkMmEtNDczYS1hMmU2LTVlZWU4YTgwMTI3YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTg1M2U0OTQtNjI3\nYS00MDVmLWFhOWQtNDhmODI0OWMwMDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2Ifx46X+LYhr6MzUBWvwsgq3e43RsDrwC5I+ZRljfS9YRYhikDiwaMtD4TMY\npP7ilfKARfflOExr9aDytBG9HaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSNceElxUow7SCahvkWgqsqqx3R4wHwYDVR0j\nBBgwFoAUOgHMQlgjDxfLG6ZJ67oNpt8qGrQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgKO7mFTPjfMkMhwSKV79O7wjW0kGUWD70WySEManZ6cECICxZmAxqf2MW\n7R13yzD19bvw04pJIZ5kej/evLCAYxRF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUcRKZcRJCA7JDb/7rp2DG1OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmFiY2NmNS0yZDJhLTQ3M2EtYTJlNi01ZWVlOGE4MDEyN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbTY33lA3jHBh3R8sU3emDejJUjYaCj91LzbiKI8KkZ/q0\n3qEhf1MPXNq9zHpAZ9v0QCWRUiPPnwVi6xm+ICcWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOgHMQlgjDxfLG6ZJ67oNpt8q\nGrQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALx35MOA7fv44UmyUTg6UXM4HmFWE29ZQVZpNReleHSYAiAusNOIkpAB\n8xyGfQgTy4u398Zmq8YWRO6nZvjpECK6CQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAYGOaPD74YRDVccEcuW2del1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTg1M2U0OTQtNjI3YS00MDVmLWFhOWQtNDhmODI0OWMwMDIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2NkZTNmMWMtM2VlZS00M2VkLTkyNzgtZTc0YWMzYWY0\nZjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuWmE7hQiK+5Byv5oe+2CtngZ\nNrhl+XPuvFUKjuUkawviFoz/IqLEyYegbrXt6XLagef0hv8J4esFlaDFySeK4KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSNceElxUow7SCahvkWgqsqqx3R4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICU5fN3t\nsL5gR5BxCoX4oAcqZqLvC2dHvYNYyFi4wKMYAiB6MFzO1Jc5aNrlvY3HS7kMRHWB\ny6RqruyiLJl1M/xNhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5014", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5014` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISARj6Fo7A9kUB3I4qwOSVzmmcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkYjdiZTM2LTUzZmYtNDQxZS04YTUxLWU2MDRkMDBjZDQ3NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg4ZTViNjEtNDQ5\nMS00ZGU5LTkwMjQtZjkzYjJlNzhlNjU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqpgOid1f3BZf8+Zeok6DqDk558wLUJgm31Tdsqkh64SJMT4pEvx3S4UAiXt2\nJ5+rniN1/BMSxN6m6CatU6tGWqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTPSuBBihWKjRrGBaSW9qEBkD/tswHwYDVR0j\nBBgwFoAUSIHKRGUl6qQj4U6/kWF/luDeFKEwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCsQx/DgF4Xms3l2nDAaEl13VZKDC2OSN+KBrdeiKUzRgIhALDL6cyY\nH7x72kaDB5veIz39MsyauYA/6/7gLHmoE169\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcVSWxrqptPXDIJ9qK4GorR6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGI3YmUzNi01M2ZmLTQ0MWUtOGE1MS1lNjA0ZDAwY2Q0NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4X7jNb30wxiFUQ5nQSe1BFEAnABd5ihEYR7PUfxWJhgE+\nmZWRafZYARXingx7Inu08bqQQER6KB82Go+WWBPAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIHKRGUl6qQj4U6/kWF/luDe\nFKEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOhu9Sg0f1tJCJwkJRF8nb5QausFGmjyfhl43ssw2frqAiBu2zuMDyFI\nWY4e35/7Zp4vS3mW15P25QI969pWEVj9Mg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQgy0isP4nShqRmrqHVraSwsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg4ZTViNjEtNDQ5MS00ZGU5LTkwMjQtZjkzYjJlNzhlNjU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjUzMDNiOTEtNWM1Mi00NTFhLWEyN2UtM2IxMWUyMjdm\nN2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWfrKgBAh89SW1cPo34wl8nJF\nT3JW+mRrBTivDhxg6gA8UXiGuNHRjJX/FLo6K+EgjuoBEpfj8OU5mVjGXnatB6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTPSuBBihWKjRrGBaSW9qEBkD/tswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCo4a1m\nu7spZM9+CGvzp1jRx+mUJcAga1NgLwkqtqeUdwIhAMapysmkz1+jHpUvDVxXBZxN\nYcJul/dVy0KMPkEirYBw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5015", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5015` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAU1xL/KX51o5JMV2g2f8GZ75MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlMDJjOTg0LTExN2EtNDFlMy1hOTJhLTk1M2Q0OTI5ZmM1MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI0Mzk1MDQtZDNi\nNS00MDMzLWE0Y2UtN2Q1ZGUzOWI1M2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9BVV3phnQ6jjQxSh7KQpxLKxbIcdedV43ER8glpR0cLo9j/9BUcLUw6/GfwY\nOr1vyqoUDrd3Fsfl+nrtnw8rwKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqUZ8m94kZW06AjlOWFrQ6QZcuMEwHwYDVR0j\nBBgwFoAUrlyNqYiY75ofAAOIbCeNwJcisbIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCZWz1ruRYc3tU4JRL67ruWFI0kbr69Ord/Ivvy\n0Ax9MAIhANqH4sDmdXZJrN42dVdSqSpJEmDX1uxQfNp1vODK1K5f\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUJZ8pCW0jI51SVwaItV8jDKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTAyYzk4NC0xMTdhLTQxZTMtYTkyYS05NTNkNDkyOWZjNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfSUlqR7DeT/85dFvTt+YuUPnLGC7HzhoaGDPkqxZ2deMW\nJ0aYc0UA6rrYKZBnYad0iBFCNFP/kIZkAS5U9Wxso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrlyNqYiY75ofAAOIbCeNwJci\nsbIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ2waKfF90hQPT1HkSjiH9OyCqO78e2TXrJJBRYFwA8KAiEA/c8J2ng3\n6BL5lJBBiOFDsmVBpzCN7A+bCQzyFqwdYs4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdQEihnEh6QCZAKD5IxYXFx2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI0Mzk1MDQtZDNiNS00MDMzLWE0Y2UtN2Q1ZGUzOWI1M2RhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDBmYTRmNWEtOGY3Ny00Zjk5LWI0NDctNmQ5NjRmNzBm\nNTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsaaKDiwILDZ1faxH9D9UaR8J\nkcVQxY+12ffYTXvZFKY0UyzAbXFpxKNntbNBVJWycyP1oCNeaooxR41BeqVP0aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqUZ8m94kZW06AjlOWFrQ6QZcuMEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDAACRp\nafML7Qa9QkY/kKprRXgcN0Y9jBNUazMIamLNygIgP1/CJerTKAoeXZIwd0zE6YKG\nDITOOBiNmXetNtwMdp0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5016", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5016` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAc/uSpNnGTIBrXDBf3+2JSXpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiOWM4Y2YyLTFlYmItNGMzYy05N2M2LWViZmVhODIwODNmZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE0ODU4MzItMTJm\nOC00MWE5LTkzYjAtNzFmOWZlZmM3OTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm067RwMIzciXB6CyRt6SaMpPyliDJCiFbBRRpt2H4ZSkHGlxqVkVg2mOZeQY\nFjHy/W84rxlYJlcRlRzwdZhHLaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfvg+dObQEXU11xG/wbzZCVDdF+gwHwYDVR0j\nBBgwFoAUbsG1mmjPWHHxTPKU+afVX9gEciswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDQYtuBaKrhCmwdzuZGPThBBLC3d9DMWC3m8/ia\n4d1iOQIhAMtiVvR1PH1e/8eEOpRGeAguo+pY3ZQhx0XS2mk5fY9l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARbfaqNOGFSf2JHKOVHegBKlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjljOGNmMi0xZWJiLTRjM2MtOTdjNi1lYmZlYTgyMDgzZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwEWYaBlm1Wr6IX1DW2kwoL6dMFx9Monb57ZJrv603FdTv\nRlHZdJUAQY86oWO5hMCagspXrMaXMCIgpHrw0R3ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbsG1mmjPWHHxTPKU+afVX9gE\nciswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWkb+dROgck6HST3X57yvCd+VESL3+MI8khcw2R/pKskCIQDWmT4UccVB\nI5G3jlqKRFfbM1zxMSRt+iebgS2KNGCElQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAaxeDglPL9Xq7GWJbGRIHVwAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE0ODU4MzItMTJmOC00MWE5LTkzYjAtNzFmOWZlZmM3OTU0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjRmZjJlODktNmUwYi00YzU4LWEyMzMtZGU3Mzk0ZWIz\nYTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV2NRPSrl90CnvR6db2dY/dFE\nxOxNCadKV+0Q9F1lDiCGvkMQr/vjUu4SYBzzD2EbCUdlsxAlzSBKZwMd1f099KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfvg+dObQEXU11xG/wbzZCVDdF+gwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDqD1si\nIyU/dzOIMUA0GKKQfxoMH9EaScGLeAPCnOFVsAIhAPrNEQUaMRfGZcTMLeTzFpnx\nyISsEZSqgA8lE45qamhU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5017", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5017` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAQ1VC36Ouz+7UFW7/KS1WpDrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5MzZlNjAwLTdkMDAtNGNmMy1iOWZiLTQ5YjllMWJhNzA2ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFmMjMyNzUtYzc3\nMC00ODVlLWI2MGYtOTBmMjYwYjc4MjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaHV7laxvP6+0YRox0j5awWUroBC0Es2lG/1PtVlJklinTHQjelwg1ScHJEUE\nsOIbYaW7JGhYV8th1BNYwmVMzaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwN+WbXCZrYrcJxZMRMmH9HlHe0AwHwYDVR0j\nBBgwFoAUnVzS1Ki/48Itei5ag08n3uXXdAwwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIAmiTZZT8fEY543fqHteQnmQmGx9Ia88uctXIWkPYxfdAiBt\nTYp2aZy2W2BXJTln/Z2+tlTbeJAEzeeCZNfiIcG2BQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU5Hwqtx6f+ItLEdByrDZPRBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTM2ZTYwMC03ZDAwLTRjZjMtYjlmYi00OWI5ZTFiYTcwNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuN602YvQEZE78bxzP6ncB6MDq8Wr/a3Afyz2r2LtnKjrV\nK7DANEtCz3DaqHlaPX0TdlZxXQIrq02RLZ1NIa76o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnVzS1Ki/48Itei5ag08n3uXX\ndAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOMQ3vrFryTcx1vgDnmStkyxcDNzYGRqI95NuVtizba9AiAqIpgIcxXh\nr3zUh7sXiFDw2K+2a9tVXXwlwwYda5W5BA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXRzLRbwox4XC0roti95rRSzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFmMjMyNzUtYzc3MC00ODVlLWI2MGYtOTBmMjYwYjc4MjdiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTYxMTBhZmMtNDNiZS00YTVlLWE0ZGEtYjZlMjNkMjI5\nNTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEU4sHbAfyof1I5TZ47vVC/crE\nLekC4g78DUrPYAauC+e98HoSBARzwHBi8MPnujxWYe3zUTnBI/g1G+xoFde9oaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwN+WbXCZrYrcJxZMRMmH9HlHe0AwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCH0Liu9Pg\nTTokQw8v1/dmwruluZzzAM2guoelEpKaP7ICIQCY6FWaYzaWAwhtc4YKyTiM8Mr2\nyccoh9HnQV/hlfRD7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5018", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5018` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAfYlMw25s3rN/sxHsPdM4mA9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5ZmU1Yjg5LWZkNjItNDg0Mi1iZjMyLWFmM2UwOTVlNmIyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTEzYjlmZjYtODBj\nOC00MTk1LWE3MjItMWRjN2U2ODNiODg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA/W9t4+sMgxPFZqhxLADScjfAUV3d3z0ziuDyWo8R1Y9teKpoz68w11Y2IZL\nyJfySWxQpxXuUEYLzzPFMl1vaaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAOcpuWfjKgaSMMWliNfeOBLcc78wHwYDVR0j\nBBgwFoAUJjuhO2h7XrqXsvJrUlfHMDECza4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCF5SKKDtbrngCCmFoYJl+OIfuBQRs2\num5usVz+B0OfgQIhAOemlyzuNOKlkHAiHMComQSPl7wu6BAxkhYFmZwGIxV8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWGvyO10H9CagMxf/RoqugCWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWZlNWI4OS1mZDYyLTQ4NDItYmYzMi1hZjNlMDk1ZTZiMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATucln3jAMOs9WIHq+iyVc2RhiHCgR7nGN1SkvzouFGk41k\nrxxDiF+cY+CQuaUXW/VONZ7Fd1wiB8Fh28NjrLEfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJjuhO2h7XrqXsvJrUlfHMDEC\nza4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJPq9MkYjH7EbJKODyxb6dj4Uw5kczmhE/UKkNGoL/joCIHVHy/GNaOxK\nb91MZODj40gCXagImUzS1Fl+wxDxg/mq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWWsf28JVh0oOz7WyxXfBvATMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTEzYjlmZjYtODBjOC00MTk1LWE3MjItMWRjN2U2ODNiODg5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjRiNTAxNzYtNzBiMy00MmI4LTkxYjYtODgwY2RhODQ4\nMWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhO36PG1UGvKJYAXdkrDOVRr7\nW6v6qB+G2NoKhmRaHamZbwuSfaKQ0qZaif9kBkG5pPHjvQ+BQIVsuM/2ID0/DqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAOcpuWfjKgaSMMWliNfeOBLcc78wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC9d0Zx\nVZgWqzrI9dT3v0CmVs3Q1k2IJKHaZ5YbIlJIZgIgY1paxyFDVsNwAy25bZMbTmTn\n30fS7MF92iJmrjvL7JA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5019", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5019` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQXzE1lGEFNd+wYhklpSyeysMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxYjIzMWY5LWIwM2MtNGM0My1iNTcwLTU0MWQyNmZmZTM3NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjcwZWI5MTktY2Uy\nZC00NWFhLWE0ODItOTA0MDVkMTIwODc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEarzIsTCt4n8LjJpZfnxipakesedir5hgLV/eXETM/5jrNl1KbJHv9p0dYZuw\nUQETvWK+gpbd5oUcI5pQo/abOaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAz+SqyetwbT11OV0vOuGo0J9gKcwHwYDVR0j\nBBgwFoAUWHIbebp0DO/sTLxKI6tuulfC9I4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDFIzPDxWDKTLfAnE3fO7/viiDPpaJg\nfRZYUY4CbFS+ZQIgbx3L0Mecbuz6OW8xWC/gYqFtWiXv34arYdycbehqh6U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAckT9F1uPxjyTmZia/EEqcf3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWIyMzFmOS1iMDNjLTRjNDMtYjU3MC01NDFkMjZmZmUzNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqqFW9zqDuKLhHdaN88bc0g8BtfhS/ZUDPsLErsUkLl3f1\nxllAL/iDqG/LaR7ec8FVF3ZykBZtEXSgz9qNX/Yeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWHIbebp0DO/sTLxKI6tuulfC\n9I4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga9gs087kKKKvE0nLkBTaHWF75jD6zqkVZQPKFyBwgxMCIGEyKDGJTsI4\nOyBNZnPb2L87E5Ziqpwowgg5xDmsgL4X\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAc+FyVoPcx/nJLO8nKKWmS1AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjcwZWI5MTktY2UyZC00NWFhLWE0ODItOTA0MDVkMTIwODc2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTAzMDkyZGUtNmYxMS00ZWMzLWE1ZTktMDk0Yzk5MTIz\nMTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0YIdlWiJHNQ8iJGU2VzflZJ+\na+MNyuSJLXeuwMoo2MhElGzjuHMZsx9tBFcU/s3H/46cDntVllTcQmgyTLU1UqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAz+SqyetwbT11OV0vOuGo0J9gKcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGXyYSHS\nRFjPfMNa0YKyYmJBBVziClLFyP3GVnPfkMl1AiEA8Akr9AmK5lnLHFav7HslfwB4\nuyom4DMqaOewz2SXE80=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5020", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5020` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAU5AujMe25tWU2Ow0Xh+1fQHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzMzI3YTcwLTUzMTYtNGViNS05Yjc1LWIwZTE4MzA0MjgwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U5N2ZmYmUtMWY0\nMS00Y2Y0LWFjNWUtYTlhM2JlNWJkMjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYsct3bpL4N0heRNEr1UwD4gkewOTigcOO1dB2GQPVObZwQKcUiYMxvzL6xUc\n7W4uQrkCnCGWY8P5btD/5u1PaaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeOUBAOc/UFpZBa6BqmKLoR4oyzQwHwYDVR0j\nBBgwFoAU9zrh2d+bTZB6VjfTT4Nhs0yuVN4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC3MFJ52kcM\nBaA+fvbNNvCflo5wvSqmYsZ/gXP/9sVrCwIgZWQVyDDGxzFLr4c0H16LauBGUJNN\nkx+vmjTfMbz9rZU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcm5rpChpHZoA0UqDdt+0vkEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzMyN2E3MC01MzE2LTRlYjUtOWI3NS1iMGUxODMwNDI4MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLl2mX+R+oteczh1rDCHufoRbA+T4W4xB/eVowXSe3vNXm\nRFN/YpGFJt03OtHCib1yvXke7fMg11eXx2SYvtP6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9zrh2d+bTZB6VjfTT4Nhs0yu\nVN4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIpY6/Krfa2LRj86rwQ6OwnegIG4+puyGd8BGDIfMi6bAiBMqGhv8ymP\nM4EI2WI5eEspQzf9mZFr3JcRPdrQd0Ll4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbscGGPRbLGtcXb9oqth7gUOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U5N2ZmYmUtMWY0MS00Y2Y0LWFjNWUtYTlhM2JlNWJkMjZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzAwNDI3MGUtY2M0Yy00YWE3LWI1OTYtOTcwN2Q1OGYz\nNmYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBhEb5SohxBjK1RT84iFRezo9\n8Dtr5Fa6Q7K1xJZKbXnDtoKZLkh9BsuUYEQHJWwBT7tAzD9lILNU7OqAY2Q5VaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeOUBAOc/UFpZBa6BqmKLoR4oyzQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDCjHgN\nNnvooh6TJCtO34FbOuKhY+o3LbnErpQk//Z+2gIgUh2UZAgr6xQ9Thbs4DEVF2Yj\n+tCzzw7UqCaxxd4CBps=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5021", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5021` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAUaBznEv5PHXv4Bq22Erlx0lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1Y2NjZDMxLTA0MzctNDcxYi1hY2IxLTAzNDc4NGExMzdjOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU5ZGY5YTctYjhi\nNC00MmVlLWFjMGYtYWFjMjBkYzM4NDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4iv8KQ3frkEEtOXUUW1vMXk0Mer6Okw6FQHrauUMTNSzkAhh6HXoSlkCmZrO\npdJaQDpAsqipRqHLyqUQNrt5+6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt0NPUw1saenJiFfvqqHg2GqDeNkwHwYDVR0j\nBBgwFoAUWpPPvNfNZviH06TKPYryUX3+hkQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgSyUKHSIpHBF+6/YAbULSUWfRiyhTmh7zI+pgQ3rjmrMCIQD76NImKH5p\neiHRZJHQyQ7xneOYKGSoCfoD5D0krmF+jg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdaMAg1gtWzl9ldtM0sZr0KsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWNjY2QzMS0wNDM3LTQ3MWItYWNiMS0wMzQ3ODRhMTM3YzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATt9El6iWjTYSGC4DWtKtirE5YQ32P4EBgI9dtpN6fKxQDH\nvEQxH1gTTFpi7JcUoi55s+aBuQg2/qIiz2kyorzco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWpPPvNfNZviH06TKPYryUX3+\nhkQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMdXLB0LMT6fJYiN7xSHbkLA2MZQxrtBlaiI67ZRND6IAiEAm3lWGRsW\nl6L1nvUKj/Mzv00U1mmR04q2XgyLA0no5LE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUPyC5/ieXkKvq4WjRjChRyfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU5ZGY5YTctYjhiNC00MmVlLWFjMGYtYWFjMjBkYzM4NDcxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWNjNDJkZGUtMzgyZi00MmI4LWE4YjQtODM0M2I3YTcw\nOWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENDNfi1lUCaV+KeUvMTqH9Uwg\nOHmVvAvXO7BZRstdTsPIaKZeUS9a77WhZEo4AocLO4fJNZ1I1E1OmZ5z5+Bcp6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUt0NPUw1saenJiFfvqqHg2GqDeNkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD0ku35\n8rrIu1R5vVaaCfxve2pPJxAGk2ImsBfi/lIWBwIgYPNhIEbNyB21NLE7kTHsis8u\nk9zT3IoTHUjmNFtArkc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5022", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5022` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAaGfxFmtRkum6sgPiebBWoXzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2ZmNiNGUxLTdhYjgtNGRlYi1iMzZlLWJkNWUzZWU4N2ViOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI1MmExZmMtMTE1\nMi00ZTNlLWI4MjQtNDYyMmMzOWI4NTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEizRvpvBl82dY21itJQ56+3sKsOdB0wRC8XmnN9AkDSD6pUzK+8xRj8DoL6zb\nnPFEePmOu6c772O3VYPxVJOSN6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUstVSuXWXm6TzHa7BUmGygWCA0HQwHwYDVR0j\nBBgwFoAUAMrRsbkl7q4MOa9pGHVDK9bHT4QwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgFLbhXDzIMiGtKzuioxMIZ19eFA5LZaP1XrbLAt90h3MCIQCmtVSeaDa2\npiyXa4Ypugpws64+vabu186ztl5TAg+ZXQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWYnsBbDIavQtftoARvftJfgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmZjYjRlMS03YWI4LTRkZWItYjM2ZS1iZDVlM2VlODdlYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQG6MzfP+bAczCLITBfEVvArjdQtL8ptyk+piKD44qPGJIV\nGupQfqpephMy3G7wMjyda4i8fT0JOQlHOXBvnwGAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAMrRsbkl7q4MOa9pGHVDK9bH\nT4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfO5RNOsBWkwtJORQiUCwq7OfsQctYPv3qmKC037u6GECIGfumLvZkfyg\nywZpGTAn4nRt15EmZB09IvLCVujIc7bN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAS8ubpntJRkulUyQ4UhpiQ89MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI1MmExZmMtMTE1Mi00ZTNlLWI4MjQtNDYyMmMzOWI4NTBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjJmOGMwZWUtNmVkNy00ODM1LTkwNDQtOGU3ZTM1Yzkx\nMDI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAES2gSliVPhQv22wYrmbyKuN3f\nsAtZUTsU+LwCYqlBG1E2eGGDBZRFJEmJ+k67xv1tkvtLF88HxD9OQeaO3zkqhKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUstVSuXWXm6TzHa7BUmGygWCA0HQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGKs4I5M\nGFycyHSk/zWsmsPHJEztDufoKEBa8Qw0GrlqAiEAuRCInH0I2z/AdyxKoIIyIcXf\nHahHyTcXBS+YbFzoHZg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5023", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5023` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAb8GkQm+T7vjDIR3XcLH8j87MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwOGM4OTU5LTI4MzAtNDhhMS1hMDZlLWRhZWYyMDBjZGI1MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRiYjI0NjktZjAy\nMS00MTcwLTk0ZjgtMWViNjg5YzQxYmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/o/SfQwHDhr77LPTdPu34IcaGAZyPXHF4e5OToXlLVCGjFlmKRjIi2JMNVGE\nXhrZpJzaT09VEpp2bpYCjidUXqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0ZUZcRVlIncCzn4ZdjAYVYrnCBEwHwYDVR0j\nBBgwFoAUUO/1n6qcnCvE9/XxH2jKOrkJ9KUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCJy0mBX6aPL/60c5egB12smzhwAvxLMuWjnM3eNS6CfgIhAL3hUtXF\n9/BXJM7jGxFYupGFHEa83UxUvUUmSJQEfQDW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbbka1ujjo3QsYh994e1P1XLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDhjODk1OS0yODMwLTQ4YTEtYTA2ZS1kYWVmMjAwY2RiNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkvA6HTGRWqT1z6p2ew7mw4KvfJfUBCcQ4mY4r/KyVxVUF\n4jyyfU6k3kD0BE5Hk2oITeGCvVlEvWIlNifzXFFEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUO/1n6qcnCvE9/XxH2jKOrkJ\n9KUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPQkkKYl7t8Quo0g8Q9B516RmhpHQ3/PrqtBVj1IsA4UAiEA/+kYyC2f\nGDDUApoVOviB30pWr6C6id5MFHQa9qm5waY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVWdcXWpXZD9/oQfbOBKe06sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRiYjI0NjktZjAyMS00MTcwLTk0ZjgtMWViNjg5YzQxYmJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzVkYTUzNTEtY2UwZS00NTQzLTlmOTYtZTE5NDgxMmI3\nMzg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEefle62deuxTvs3BoWM71/R+r\nyN1e0AMMoAgf6COyZJspCPf7bb21mzIIjiT4mEPmWuIdJ8r3reH0zWV1IEwyiqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0ZUZcRVlIncCzn4ZdjAYVYrnCBEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGZ3UzUZ\neoLY+AbDmZF6iigm+sC7y4khFxvVPv9icMObAiEA4ZgJiaCtlUKw5Iynu0x95+fI\nAZ+0Rd+UKAmoo+fmwGQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5024", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5024` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAUo0Rc8rGQi1CFFDEliu5AOBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0MmRmYTA2LThhNzYtNDQ0My1hMzkxLWMyMWViOWUzYzc3YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUzM2RjNTYtMGMz\nOC00YTBkLTk0YWItYjQ4NTUwMDdlZWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO6VC4XvIRTCAmJxruycN21cLajPrUAWoNYh2lY95PREeQRduf8sNC2BjukY9\nRS7V6s2DtQbV7nNBCE1XJvjHvaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcTS1W3NOszKbhriZGU112YUsypswHwYDVR0j\nBBgwFoAUPgsG8p8oOD5b0txP6i2tAhHOQfIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIFLG049KYK2sF1LNrMy7s8LWeQZqaR4nz2LI08Au\nJix0AiAL8JTQ5B2vEiztD4nPZ/l04V0JIsOmvgmu8kQDt/Qstg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUiG4H/lzHaOMesYnUD6ELG4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDJkZmEwNi04YTc2LTQ0NDMtYTM5MS1jMjFlYjllM2M3N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR83hfJEv9BEtctc3pph8kS3bACIc7L2axvEhW4TT5L9/n8\nlulMx9dCS8BN87E0ObTLIV55KPjCvLKWT0QsCBwFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPgsG8p8oOD5b0txP6i2tAhHO\nQfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVeO4YdAhle2C5IIR0jQ0fwAyA1s3WN82O6laFGFTpjgCIQD5l3+og/4F\nnsGA4KI3lsmckU8ENYv3FfqysY8GK3UtUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASgAWPTmuCMQbgqPtYY/yuYFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUzM2RjNTYtMGMzOC00YTBkLTk0YWItYjQ4NTUwMDdlZWIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTAzYWYwYjAtZTJlOC00MzFkLWIxMzQtYzI0MDMxNmUx\nNDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECSsnwXMlP9VG1yD1IvOb7juH\n7g9DRDosQjAmx7nKqbTj7e5pAkwF4WYKF7QDgv+hqDuF6lymnhU5VijKI1HyH6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcTS1W3NOszKbhriZGU112YUsypswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIEMrYE+K\nnUxo2nBAg1j2qU1aT722fXK2+DLfB+nhirPXAiEA2hAQnQy9ECinpYzoQyTf74aj\n5yR3rj8AcvbvkdsZ648=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5025", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5025` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZFVfi6vyzravXnbvjUCad0NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0ZmYzMDE1LTZhZGYtNGQ2ZC05YzliLTJiMDQwYjlkZWVkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI4MzZjZGYtMDQ4\nNS00NzA3LThhNWYtMjBkMGU2ZTQ1YzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk3IoNlyeuEshJO202l8Yvdk//fu3XSzCzvIK5VsnPFEFQ03MxEAK59Vk4hKf\nk4KyKtvkPGIKfzz3Iri8SIvhBKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGO8lHxR2e6r3WSNrcyrIKOax43swHwYDVR0j\nBBgwFoAUSMgwky1ZzLfodYWebLfpOFI4UmIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCdudKaJ29O7MZyBgn8d/kPtlH+1RUwY0hY8+xR\np9LosgIgHtwtwcXLbV7dZELl5JhYEWZVErZsEfJaacF3PnAGejY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVKTL7ualGs8eQiCzxxD5VgsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGZmMzAxNS02YWRmLTRkNmQtOWM5Yi0yYjA0MGI5ZGVlZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQSSsQhkE7llF6jXgZCEpyZirw01UDsNkg8IqYQvk07QJD\n/3fayXN0Fh3+zO5UcqNWFA7brKImetcP2DadPOL0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSMgwky1ZzLfodYWebLfpOFI4\nUmIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVH+P0G6JnHY7z0P/KgkZs0CuAKy9lyymcQ2LC3VjYCkCIFSlOsGgOdse\n5ayakSXsqx6EFUEedlVmIcK1+cCtjs4y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUqlwEtFRAyWsn1chsQR38BgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI4MzZjZGYtMDQ4NS00NzA3LThhNWYtMjBkMGU2ZTQ1YzEzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTdhZWZhZDAtODgyNC00Yjk5LWE0MWEtNmJlMzA2ZWQz\nYTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXjIE85sTzT3iVlngo38kV4bt\ngAx18p3YI6ojKIzXVdiRUzJenU9KrYyvJZcSXxiHFu4li6bHL2Bp4qfuqjjNRqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGO8lHxR2e6r3WSNrcyrIKOax43swIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC81Kf5\nGgXs2jcJ6HTMphJxxl8tZl2EejHsafAN4smdBwIgIgKmCGq2iObJMyJadVDChRaW\nvxVFBcNIvfvFNuhEW0Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5026", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5026` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAXvpn1yypqnUGpeR1ekgGbGmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MzQ5NzkzLWI4NTctNGMwOS1hMjc4LTVmOTQzNDFlNjk0YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTRhYjUwZjUtNGEx\nYS00MzgzLWFmNmQtYWQ3Y2I3OTk5ZWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEegtW6WlSMoi4WirNtwJj2jy+pI0ZwzG+nj8gj6EpKFWpIqO9LHqofP0/HUhD\nwR6KEULx74xS/EGzrnouhJVio6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURDCQCHr6TRhfvAFAOTB8m5DdX0kwHwYDVR0j\nBBgwFoAUvlgruc43KqqxGLFJPZFN2tFk8KIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCtdHoyoNHY4RZET3bR6wUsvjg6UYyBG91TYiCJA07cJwIh\nALVgl2b5bkcJ8INYuIFpTAovFYhUDywPlfDtqbBx1TNb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeF7KzrGqZupvnj1IGiQiMEbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTM0OTc5My1iODU3LTRjMDktYTI3OC01Zjk0MzQxZTY5NGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlRKGBYXo6PnvSPxYD0gdYa5cSVDoT4eh6a9xKnBrG+xVt\nagMJg23KGv7ZmlSKaNc5uD51KOXIXloxHRQYFVg4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvlgruc43KqqxGLFJPZFN2tFk\n8KIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAODxUgUuJvdeuEJKomNsrJZ7+DuhTxqJWseuud9yuMlQAiAFCvgevFmW\nD3PDskGNe542UkJKQYaBpaITOLBNJdOhHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAagGaENnLeqTkvE1jfWDJ5ybMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTRhYjUwZjUtNGExYS00MzgzLWFmNmQtYWQ3Y2I3OTk5ZWRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmEyOGZjY2UtNjkzZC00MGM0LWI3YzktYjQ3NjMxY2Ex\nODFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4ucBHuhho75R8YPsCXhcs2MK\n0t6mD9aoO10oaZ0kQiGme6HbGNbY6oGhHvtalvEtO5LFswfjhkFMNhq0AAqgXaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURDCQCHr6TRhfvAFAOTB8m5DdX0kwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICNWaNCS\nBtyGEPDXcet4cnogDg6chYaOqu/aEXcm3SW/AiA22fcrspWOvSUsAsMz1v9i9neW\nR2RndTkq2LTeyRYLLQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5027", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5027` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAWSEuaBXdGiFWhDpOWyt0STgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiZmI5MDkwLWM5YTktNGFiYS1hOWJhLTA3Yjg0ZDBlNzdkMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdhMmJlYTItODNm\nMS00ZTRjLTgwZmItYzlhNDgxZTBhMTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5PK5vq/MYfGWuDIbw7yuPybWLZq6nxvqFVCXgiidF8x6YcBmZpCQPoPTyern\nF7FfhBa8qRntIpnZn/WX+pjOg6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzdMDfo5kjYvb6x1M/GWeWheyA10wHwYDVR0j\nBBgwFoAUQ6Z8JF9Ojqze2htfMFxib1c4vD4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCxSlNAEv0/lK1i8pu7uQs++bQvQ0x7\n+YmwGy0F1PuqDAIgLCxD2owtMYS6WQwN1CC3Xrd8RFrzFUeOGCPSOpopyLQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaGdlXjKmeAov2cRCwTOWDdfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmZiOTA5MC1jOWE5LTRhYmEtYTliYS0wN2I4NGQwZTc3ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcaSpdKWf2Dx4Cqu3aXMzjYQegD0vXIofksT8YnEq1Qz8p\n9qp8xTfOU7mM5sbtKlCCCosGyf1VwWJgvgwC0xB9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ6Z8JF9Ojqze2htfMFxib1c4\nvD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLEhpRxnmBO6dhVJF48lBUJF4Id0+JduQ4YKbibDuCtACIQCSWiuc5FOP\nHtAcety73IOKMKcuHB7GNnndq3YMRFDuiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXTDiSm9mC1d0oABmOI/ytvRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdhMmJlYTItODNmMS00ZTRjLTgwZmItYzlhNDgxZTBhMTIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGYwZWMwNmYtNzRjZS00OWU1LThjOWQtOGVjZjM0Yjg4\nOWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEI0xZ38ii7d0Zxn0HsHp9jtUm\nJh+LCvSLJoA4qn5zIOU8n/Pw+T0nNLuOqJXNNh+GrWKGJb0yWtwQgxSIRScBtqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzdMDfo5kjYvb6x1M/GWeWheyA10wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDD7JA8\nlEJ8xEVgRhMz8ob7YcVGlQgAhmNSQb+CjA5FTgIgWF6+WnHbJgAD3a/r2Qa5pYlP\nsQRqvhOFm8X3CkK4TAU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5028", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5028` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAR3uSdGwrpAhT2Zj3mt9YJVpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1MjAzMGNjLTI2NTgtNDMxZi05ZWQxLTEwM2IzNmE2MGE2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDliNTQwYjctMWJk\nMS00NTlkLTkwOGQtYTNhNjgzOTdiYzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI70h5hzkrQNfWpFSDzGKkn9sw1XWeMl8BcZKfLPmNn8wbRW08is8p6sE1R9n\noxuLrXaAeyNnrTyZ+b908Cef9qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3LYl20FhWYOiM2S4+hDP7x5lrQ4wHwYDVR0j\nBBgwFoAUky72KknR2A0gdkw6P8CcLuarcogwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAF8V5Xhe0ukWY9fDKtwvANjQjxMLJFr\noFPEUoOZJO7YAiAigESzE1ebcl4Xi4A+OZq4AniECnuSZov18ADFm7j0Tg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfYCliqZpSl8Remvb7LdZfGUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTIwMzBjYy0yNjU4LTQzMWYtOWVkMS0xMDNiMzZhNjBhNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTc1g/mdF+04mHmmeTujXoWg1pxPhUXXEaEb6YWzLFKFhA\nDWA/AUWXmmNVPFugKm2C8rrnw6jX/BXf1N095iZDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUky72KknR2A0gdkw6P8CcLuar\ncogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGUoGFa75sqIUbp+OX9snF1tFUD+lnIy9EwRuqk0GW3QCIB/l7tVexUPU\nKtWV3oI/IojGBJR0tCc895xB5SYhPyq2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAd0VpGH2d9BqhSbEVqvnzrpiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDliNTQwYjctMWJkMS00NTlkLTkwOGQtYTNhNjgzOTdiYzlmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTJkY2NjMDYtNzIxNy00NTJkLWE5NWYtMGVkYjQ1MmY5\nNmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ5rP0pyqY0CEmY4xBDPjJH7c\nbeSfsgXegEGbRmRqmwBkKwbSs4hTHxWiljgbmy1OkpM0rBF1FjdfD3gOIywGT6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3LYl20FhWYOiM2S4+hDP7x5lrQ4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDaxUAv\nvl/kMiDAhJX/yW06/XpOEnr0zw2aHKa4pfTRiQIhANXAU5B2dLuErPcXrYVMdNiE\noLNZozcH/6tCXhdpjMUB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5029", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5029` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQIxZ4B4XkOjk/OsGZ43p1jAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NTE0Yjk0LTBlZjYtNGZiZS04MDFhLThiOTljZWJjYTA1NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q0ZWFlMzgtNGQw\nYS00ZWIyLWI4MzYtYzQ1YWZkZjc4Mzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIWNw6AKOvaYxO6dEReqa5BSdnLgNTL+0zLGQrIGhTeBF57cUanXk/yFebIFj\nces1GiM3/lSmKXXOjkz0Ys+1FqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFI8ne9C4v1mGXuclNCefxDcGgos0MB8GA1UdIwQY\nMBaAFF6q8e216y2C+y5O7/Ldyj6xmuRsMAoGCCqGSM49BAMCA0kAMEYCIQDkMomt\ni0rP0HWZQivm1cUnirnznLUKszHzSxW7OTIXXwIhAKl4OGUfT09kLoLL6o22F0Rg\np5dwq4WBC5aIpP0Ar6po\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASu4VXsiii0pekVgCaySovbEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTUxNGI5NC0wZWY2LTRmYmUtODAxYS04Yjk5Y2ViY2EwNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShQv1ghTP6ewSkxKv0AB5jfI8kana/mILDMoVp9650OqS6\nPDfLW6kr2pvMgFUONjLp7D7rSyBePxflKXARrQQyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXqrx7bXrLYL7Lk7v8t3KPrGa\n5GwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTVavli20TjgqfE+oEcKAan8c/1M8pdmjT5QBcGOSoF8CIF81p70YH3Dl\npaVMaRQemtgY8nDYWuGkabVg6/T0ZVrM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAY168VGLbPY2sZWJWcTTC6arMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q0ZWFlMzgtNGQwYS00ZWIyLWI4MzYtYzQ1YWZkZjc4Mzk3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2EyN2VjM2EtN2VkZS00MTVlLTkzNWEtZTdmMzBmMmQ0\nZmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE84p9dMoZCWoisc1N4efCN7k1\nImlLxBmhyuIrVTS9kcqjBfzvBxeT4MWfSmVrQnBKa3N123iYwFDX+Luxb/Zyu6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjyd70Li/WYZe5yU0J5/ENwaCizQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDuegjQ\nguy2xOqzRg7jBsgjBYHMVkKLtZ+np54LRBsFRgIgYVxjvJeNyO3PpioytwJPGmJr\ne3YHvUzHDxfDZb9Wfcc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5030", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5030` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAcS8rUQKVWODGUNzgcpTFFHVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNTFmMDhlLTdlOGUtNGQyZC1hMTBhLWVmNTM4NmFhZDI4MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRhNjI5NzgtMDFi\nMC00YWM4LTljZjMtYzFhNmZlYWRlYjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ8CjAoBLpbGaKFLZs2O2yGFjT/KBsUZzQsQDCtnvEOVJz1BdjtdGeSGFwmXy\nlCRUNLKtFwmEjgzR7sqeRdpdoKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLsYN85hEIeJIRuNpaqjLulT+F8AMB8GA1UdIwQY\nMBaAFKVOnC7bydu9J5Ctaytx/a2v8ek9MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvQIX4FF9ssrgS9mlnwycg8AhxyTfjehM\nP06chMqjgaQCIQC0ejSAg+tpsjNpAzuUuy+GDk1KaxwuzMdHOcz2BRpX/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU+S2aQe3jdXpMW1+CGAN4JjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjUxZjA4ZS03ZThlLTRkMmQtYTEwYS1lZjUzODZhYWQyODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShs5nxO0uwBeQHMmZoRNhnB7BC8RZgmvWMU6FFYYFcIQBM\nkULONgR6w5bT4IY9n2J2waX0Rsv2/AbOa0WBPqyOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpU6cLtvJ270nkK1rK3H9ra/x\n6T0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO2Alv52eUXSt+3h/f/F1iGHqjRnlB2G/qaiLaiX51dGAiEAyj8Rc2yZ\nOfF/QOqwo2M5kP50b2vJqgZfP+UxSRgDUak=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQFu8KRtTc3xPzIAtRoSbG1rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRhNjI5NzgtMDFiMC00YWM4LTljZjMtYzFhNmZlYWRlYjZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2EyN2FlNjQtZGMxZC00OTQzLTk1YTUtMzRkMmVmOGUz\nNzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWOM8KZJw9CNaWNs4kYLTYxDa\n0TtT80tjwBqp1nYJF9qquEb4v6WJALRjHxaiY+7KTfw3hytTJn4pIR72WtvQPKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuxg3zmEQh4khG42lqqMu6VP4XwAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCXwhT4\nmvWgpikslX7/GU/dAAtdNIBn2BpC4ijwDWuCvwIga/Obf31H2gbfsMj7wuhEf1W8\nKjLFm3nJ6FZec0U/4qc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5031", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5031` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASbdDuLBM+24Hg2bRXQSKp14MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5MzI5MGNmLTk2YzQtNGZhOC04MDZkLWZkMWQ3MzJhOTY4MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2MyM2U3ZGEtZDM4\nYi00YmNkLWEzYjMtZmJmZjlkNjFjZmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf58+8ro0r69aY0iF2h5NzWr0P1b7R0OoVXoOvkYO1Vw0kTQerUalHQk6POb8\nNOAT8OFAlGktDgRBgTlTRPf1laN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEv2fYpZqVhpEFcvV+fhtMo9t4V7MB8GA1UdIwQY\nMBaAFOTd/0HfuwiyePFlXIYsv+EJ2LPyMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAtfM1ZIAqyWgMqUJZ7kpbHi3/WDx06Uwd\nz3N35cOCWtsCID+Cu9zVHlGxwxllSYJKVI3eUOzMot/rE0jzZyrXROmO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUCfpq6iJJ9X1zoEcIF0NUyqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTMyOTBjZi05NmM0LTRmYTgtODA2ZC1mZDFkNzMyYTk2ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKjporew+SSprU7q/N5jOcrnx4DCNxxIOerOGE1CoIVVH0\nkzmk9iatesSyGDVGBuQkGurKsiS/kbslJb19q7Fmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5N3/Qd+7CLJ48WVchiy/4QnY\ns/IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANN/rkumrJ/p9NVbDBX976MhXxBvygC4ghWYnre3KkpPAiBKhrMQUxc/\nCXXvnYf3HDuhwvVy6OkmeYQYX9ier0M9TQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXfK4rHBrOnKOfTVjT+c06+OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2MyM2U3ZGEtZDM4Yi00YmNkLWEzYjMtZmJmZjlkNjFjZmRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk1YTZhNjUtZjU1ZS00NGMzLTgyZmUtOWZiNjQ3NmU4\nMjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJwl5qEfTqGZ7UNHVFN1PKAJV\nJ0qqmVL1yMBiuBgmh4NbIorsSwK37hASaWpiBv8SGODYedGX9jlTl0Q+E//ynqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUS/Z9ilmpWGkQVy9X5+G0yj23hXswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAg8gx7/\nhI1CrCr1/hnbeHNus23EyOsrkVE/zteUr4BGAiB+y4x16tkIJCqcjxHDnhA7D5Ak\nzrXdzPazuLMsAFvxLQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5032", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5032` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAX1HyKs+7kTY1K9ENpAtpSw4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5MmQ1OTZjLTFlOWUtNDg4Yy1iN2M1LTNmOTdjMWY0NmYyNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDMxZDBlM2EtNTgy\nMC00MDI5LWJlMGYtOTdlNDQ3NTIyNzAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX5BCCQgH3/E1zV2aeMR3kaGu1I9EpJ9akp5ZQrVrckhnQaHyoA5vlqYDWa43\nu7XP1Vp34lFYhR9V3CL1okq1rKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTeOoY+OodGz3My0RkTBlWqEvl0vDAfBgNVHSME\nGDAWgBQ6wdTB7eZUleTLoR8XmXFs1zgYXjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCunaZCHEskv3AsfvGeZSGz5t+0SfuL\nLE2KGDFH6T0pWgIgVZGcdAr2UzYRlCG9nQyjbBVrcFrS5AjJO1occbhsoJk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbYhNBCNa05efrXSAt5jo2D7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTJkNTk2Yy0xZTllLTQ4OGMtYjdjNS0zZjk3YzFmNDZmMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREwmdAkSqyTALQqAtXLEZTIrC6TaU82bgzAS57kV1hBq/T\n0sLeuv17O/4uidqt6JszTV237Io7zhAvVXFAC3Ngo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOsHUwe3mVJXky6EfF5lxbNc4\nGF4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMeOQ/RvOou/4q++FKemU2aOGLsJk+9Dsqo2RXZT+b6pAiEAjJi0G5/4\nFFIZq3K9K5pdcoy+OTlZfFCUOXRv/E4S4OI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAebpyrFIFAbqvKBggTFzMOc2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDMxZDBlM2EtNTgyMC00MDI5LWJlMGYtOTdlNDQ3NTIyNzAyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmRiNTQ0NjUtZjE2Ni00NjI5LTg0NzUtNTVjYzliZTNi\nZThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfDuSyR88SI1ROtXGHqKGzTkz\nuTv3QQ0thpw2cpI5eWdkFfq9wcJ5n1qgVIBpyLaAoXNKi4AMsALTuCvrRnBmkqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3jqGPjqHRs9zMtEZEwZVqhL5dLwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIE1ay0D5\nb3NK4alu5ub2K4coDf57yrxv3a7VzjPpIGYDAiEAiyjNRcxov618BY6B+ZiSkKhn\n6i/4pHy7ACzsikX+LSM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5033", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5033` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAexCSS/MSWZUdea1sTg6zgdGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNzc1NjNiLTMzNzItNGI1ZS05YmQzLWY1YjMzYjcwZDYwZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODM4N2MzYjItNjgz\nZC00YjU4LTgzYTEtMzgwMmUxZThmNjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELXOfVPZaeOW4E1B2iEnZImX0lvWoGk/sol6X/elNLqDaaHjaeISizqcVwzpw\nsSB2EicEXv/NMRH5v3YVSMrv/KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+pELX0R2/vDqnWtrVCdHxjJZH4wHwYDVR0j\nBBgwFoAUEUT0vh65gTXqCaU7WLUpyeZEHJUwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAJ47KAaA7d9AR6\nywOmszEAVomclChp+XdTvER9vpVZJAIhAI/QmXQm+9r4K0UpQ8PW7QCsnWVRvpRd\nLs2jSYq2jaPB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfAy+9MMap9WfYRxjGr234IhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTc3NTYzYi0zMzcyLTRiNWUtOWJkMy1mNWIzM2I3MGQ2MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwG9v7zW8bWEM7FYv2f4lr7SBCpjpVvQWqBRSPdGGyWRoq\nJ9wFePSzJgP/MGS6nYwZe0HmIfghiaobzNFo3HaWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEUT0vh65gTXqCaU7WLUpyeZE\nHJUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEzjnXFy4mnJGQji7whF0JyaSASENxkLe/YEbe87JCVMCID6hRtKYXd3S\nA64zB36fddRR039OKFrzUVxFJ5e3pNt2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAdC59T/nw16holatQ3SirPr2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODM4N2MzYjItNjgzZC00YjU4LTgzYTEtMzgwMmUxZThmNjVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDM1YzIwNzctZTljYy00NTdiLWJmNGYtYWMzNzFmNTI1\nNjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8Ttt18GfCkDyZJi4BR264yKY\nFD7AP3CP+VHfUcMO52JoisAib9wlVfiVPWTcuGXVTBVHVzccoEejydlglerDuqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUl+pELX0R2/vDqnWtrVCdHxjJZH4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGiwlztP\nUml9ZFEynSYvc+KhHUQT10X0Br+z0E/vPGApAiAO1DteDex0mm6BZi4k5zRvtIQm\nYtKng2TseZ4UoTmpXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5034", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5034` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISASSnhk/5S+QZ4NT579STQlKFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNjE5ZDY1LTMzYjItNDhhNC05MzY5LTk4ZjUyMzk2M2E4ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM0NTcyYWQtYTI2\nYy00MWEyLTkxMGYtN2Q0NDUyOTA2ZTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbd1CP7WBX8n0BNTeQwZmGu1XIyMK8Fu40ptRB8ER0YPxa5sOZk10WI/N/5K9\nrTUcTNKFuIIlC+4Hrq9xa2RG36OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC1HrwgRLvAOcAlaUU12UfzhILZUwHwYDVR0j\nBBgwFoAUCUf8NkQVctFnbKHsT37LbSfmLEEwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA4TzMimBDRbpL\nf2qf5atsZ25seCqAyh0+tPhtQxxQW+YCIQC7LejK3JH81UCtq98N5jTnhn0lZc7Q\nuY/fk97jCrJXqw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcJ5UcClCxrTvM0We7oxT4e9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzYxOWQ2NS0zM2IyLTQ4YTQtOTM2OS05OGY1MjM5NjNhODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhf2208ofdLDjtYR3ksUdULs2uaYEvkZgi7UsN5/rVk0dC\nBbsHsS/pK7/MmSmSzwdKeBuf1efL09A6aZAtsqSmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCUf8NkQVctFnbKHsT37LbSfm\nLEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaUArc55p+fETswwn0sV/5qNus+/JPIBRATtnnddyN0ICIQCzvAte9Vtt\nSrkWoLlGL8g51gweSLdsWc8gKSaQLYAsng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXBXKhsy070/WXhVg3oHJYAiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM0NTcyYWQtYTI2Yy00MWEyLTkxMGYtN2Q0NDUyOTA2ZTY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYThhYmRiZDItY2VlZC00MTI4LWFhYzAtMDFlZjQ0ZWFj\nZjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpSzmqsNhN7GhYV0lUhqsPUoA\nNAshtTSgU+BATnirPetAWn++TfNpgNZR1rNWLbeyBpC+8csdHdlypNPnAgqnE6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC1HrwgRLvAOcAlaUU12UfzhILZUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIEAgzHhy\nQPxrJp7B7qdrOPYLJ0yhTsKW7l3siCJWLg4sAiBUtnNCTja0aJjDDvi2lvULUR3v\nfDumkOXk9l7yDv8fag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5035", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5035` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAUP5tIryVPsQYyHNkUkLtkDQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2MmNkZWI3LTg2YzYtNDQwOS1iOTI3LWExYzZlNjcyZjM5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJjZmIzNWUtMGM0\nNS00OGU5LTgyZjktZmVmYzYzYWM5M2U2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4EZ0QQQSZwCcKCLwlDx1avU0X2a1jFIEAMIHxCFNsOOkd1qooLMAo90+aHdl\nTvLuPa4NBX5IyYqDovQOeiECMKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuqwSnBsBOas1jSJ3RqyrrgQAOyEwHwYDVR0j\nBBgwFoAUGhde4ArSR70DFwSitAJI33ZrHKUwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAi4GxUzpKHLjCDhGzgCyM\n5McI+w6UK6pypN+x/V/l1xUCIDNUnu+5GIsxU+KFjf/0vkyrhuIJl1DS0TzCnhzi\n4evp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZq36aDcKwQegN6dbYqcTDsUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjJjZGViNy04NmM2LTQ0MDktYjkyNy1hMWM2ZTY3MmYzOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgWwgrDqUnkv+QlsDYv8OKEyk3EHR3giDwayhExheppMZp\ntGlDmhhvSB4b41VT5QnpdX1C+ppkPXXxsiG4wUxpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGhde4ArSR70DFwSitAJI33Zr\nHKUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLJbgViv7HcAMCtxl8jmZQCnjEL+sJQ0EnvKbSxgZ6bMCIQD5A5VeLkEP\n1O7yxvtzaX02jRLItngUA7NUmsoqhVvL3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAW7CXdN7+nZO5xJK/TbM7R+uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJjZmIzNWUtMGM0NS00OGU5LTgyZjktZmVmYzYzYWM5M2U2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzFhYTY0NDMtOGQwYS00MTBlLTk5OWItYTFmNTFjNDA2\nMzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDt6OvHIT4UWyNQLjPgWWGbl3\nRhhJu89z+8VMwX6Isy2E8/9LuvWlssRWBqLX4bMZGZvMDK4qXn0bIHzhrfpqa6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuqwSnBsBOas1jSJ3RqyrrgQAOyEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDCfJuR\nYL9hrg/yIxTjmwlBCBsD0QOb2MVfonIPN9eA8wIgOoUBsqCLtAm+2d3TpUtmxHhS\nq+lxoKTshtpKOaHPUVY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5036", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5036` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISATSEIab9dT9FmB4okCOmdVQfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzNzE4MTgyLTZhZWEtNDYzZi1iZDlkLTMyZjg2OGY1N2NkMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThhNGNjYzktYjM3\nZi00NTNiLWFmMjctM2FlMTYxOGJiNDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6O2lKRpL6i++dLMcdLy1txF0fq0rMQxvZNEa6IP2vgCE06Cl+YjWvnwVWWuF\nQ06heBb/XRF3fDeO5FL07RUe4aOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6w4KfEdO0qIV3qdDblzAN6Nj6ZMwHwYDVR0j\nBBgwFoAULZEN9LQ7/CJ7PYFP97UvJuQF8r0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAviBH\n+pHMq4U477funI+nbh4KtuqEcU4A5DVSrp7tcQkCIQCGsNElF3cY3IIScROTn2dj\nC/BNnlg+Heb6HNriZLMcKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbWw8Go3CmH29DsWczHAF2c0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzcxODE4Mi02YWVhLTQ2M2YtYmQ5ZC0zMmY4NjhmNTdjZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzjPN1woBKmsFEcIZtxHPTWlhpzYoLHhaFLsLKDz30xZJo\ndQyjIN9SFyGkPlBPaJ/q0qhngCZ3mdO8A2rS6T7To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULZEN9LQ7/CJ7PYFP97UvJuQF\n8r0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIO2PLUuhlgZ7dmLpt6c294OwOjG4+9TdfTy6sZ+gpa0AiA8m8GW8tlF\nt8N7FXrSUWXMWDNdWQCExgTrtSxJvHDJFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfzDw/agWQFRkVLymWNghYTCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThhNGNjYzktYjM3Zi00NTNiLWFmMjctM2FlMTYxOGJiNDkzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzU4MmQ4MTgtMjhiZC00NTg2LWI2YjAtMGNjMTUyMGM3\nYmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtT5ngXYBsNrIhaMWSjzJ+CPP\nhS9ByeVWnfmAW5/BeUnGrowgS84gFmBUALpjzyRMJXAZB9q7oEz5bh/bNoQroaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6w4KfEdO0qIV3qdDblzAN6Nj6ZMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIEL/jZfk\nT6WnC5h+xb4tCjYqwBTJmknophN6aUCCHWgNAiA38Rzg7kYLlXDWJUdAA4cjujDw\nzukdIti4WQlHrAHthg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5037", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5037` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAQLZvgbvCxBrodFekWt+ZTOrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjZjI4Y2FiLTg4MmEtNGRhMS04NjI3LThhYWIzMTY2MWE5YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJjM2I1YjQtZGU2\nYi00YzZlLTg1ZjMtOWY3MTExOGQxNDczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaCeEk9eWjq3ViDB0ePRJyCYgDv0K3abYS6JoAOnsQo4fOhOcXmabnwd2E4oU\nIigHQQkQ1bw6l9CHrLaIGipG2aOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwcJ3UpIuOS406nrknSnr95ujynswHwYDVR0j\nBBgwFoAUBbioJjvXmcx4kNqixJIUeW0QxkIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA5wTP\nCW5xv86YIh9l66KhwFeDkbO65kVktF2FQXrRkqACIDI9tjL0t+lKq3QKINgbB/Vj\nLtE0roaJXm2SjmZyF/ZL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbfKBwdwgr22xzXf7YE20b9eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2YyOGNhYi04ODJhLTRkYTEtODYyNy04YWFiMzE2NjFhOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDvJ4zmIWshPv3Tj8lHn/onGnvEx11HushIk2QiPj3JzHF\nnTdPcL/fkfyXlyDK/vElNzDH9ro0NJKEzNN8F6xqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBbioJjvXmcx4kNqixJIUeW0Q\nxkIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfVy8hScegDCzON0N8+SRCLAaAaLCtd5WQHOs0gTjGQECIFZr2mys2H4H\nbF75DCnh8pAGruQWV4dxx85gIcHG6gKR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWFL2ecuRmtlLp6LbFHy1GDTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJjM2I1YjQtZGU2Yi00YzZlLTg1ZjMtOWY3MTExOGQxNDczMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2FjMmVkZTctMTkyYy00OTMxLThlMGQtOWMwNzkzOGNi\nM2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7EqzgIml/F8H1LJiXBu0JStC\nyEIhDu1cchcs1nz5RUE4h+4MiEpqdTMEfClJZ0xds2ekfRycz8aY94FPj2iGmaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwcJ3UpIuOS406nrknSnr95ujynswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICtpAx/I\nnoPaIEh0X8Vus56lUsbnUjuVt/R8i3oSvRKaAiADnzQgbTGDy2lGORANgrT1MWm0\nihZSjY7+bxkI4ZYaUA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5038", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5038` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISARIdYYvswzV6ALDl+YAVqYHfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2YWNlZGFlLWExMWEtNDA1My1hNzlmLTExZDljMzc1Mjg1YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZmMTgxODMtZTdh\nYi00NTBmLWI5MmEtZTEzZDdiOWFjMDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXYu5E6KLGMoUx0hWySl9C2mBsT7HBmolsed5oyqz22tklbZ6XwlWqqHqind8\nC+8FInM6PRsAgeIvP8p7nrSNZ6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJ2E752MqoZLVrHRpTKEieMFIDk8MB8GA1UdIwQY\nMBaAFFDc0ff5aC5L+9RQuEZWZbFPqDW1MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBVZvwq16tmuGK33Jbee2JFcVeQhIV4shUC\nOyUOhdEBAQIgOkpLJTU3eiK0t2yWLG0I4wzz+pzv8RSQBAQuQo4tG+Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfbNaaLCNpKTiDMNHmOC1A1RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmFjZWRhZS1hMTFhLTQwNTMtYTc5Zi0xMWQ5YzM3NTI4NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWjZfvpW6dvFw/gUv5QdK5TRSAYVRRmX2qt6F6mKjZMlEi\nm4NKfcWekEH9L85ipCcrOsAYAdIhj/CHDiz+kvjno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUNzR9/loLkv71FC4RlZlsU+o\nNbUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANmmzMY29x0wx8xap4BpfA5P4g/ZlOvZHxcesy9T8GmtAiEAzI53Dl0s\n5tyPaQGvNJbhTMXtimgIrgW/kd4hTK34JD8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQ6H+vQal+jIsYUcGqFbqHZHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZmMTgxODMtZTdhYi00NTBmLWI5MmEtZTEzZDdiOWFjMDZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWZiZmJkMjAtZWRiOC00YzU1LTk2ZjItODU0OTI4MGE5\nYjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwCAqgpP7SsIRcKzrzKJgAK/6\noc8dvJ731B93/s/98Tau91lIFfR86AMw7EB2Sk5eB5oAL374pP3+sJMmd6e/bqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnYTvnYyqhktWsdGlMoSJ4wUgOTwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBGDidd1\nVKDO9ii0tYT6oo/1aUskxMCc6Z7hFCWpAIpXAiApUovIh++d32Y48496mMM7AJwa\nFgw4r6SEIKYi0JbsPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5039", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5039` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAX7lEdjZlQHdiHrCqNz1U6WmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxOTRhNjgyLWFjODUtNDYzNy04MDc4LTdkNjUxNGEwZjk4NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBmNGY4ZGYtNGMz\nMy00NDc2LTg2MTUtOTRlYmRkMTZkN2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGZMGD5ayY0yKegxkJKnQuOwSRJj6v1AeKErK7II554cjXG06mbXSZVqi7BrA\nTz51O4S59cgkmLq1o6cXlxHEcKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY8e1VcIzTr9nC0tii07SRLObnkgwHwYDVR0j\nBBgwFoAUudJO8FfER9q2bTxvOGiA9aKOe0QwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgTMVnC8a9DDeH\nkFkfoIGEP4ZIg86J1s9hSTIwIW0gYo4CIQCoulMkIuQ/ILSZ/ZHi8wSonlWd72EY\nIgKBLp+/wtM9dg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbh6cjG6pNC365wyDOAW5bU3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTk0YTY4Mi1hYzg1LTQ2MzctODA3OC03ZDY1MTRhMGY5ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTRKxTgm13CiASf/NLvmv2i1iTPzEQFxPQmJIRUJk7QYYV\ne8zZS6NBbP/Apwo/DyhTqKf07thpFgl5xsY5dN/wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUudJO8FfER9q2bTxvOGiA9aKO\ne0QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLv7+jrd2o2d2xriQydXzbRVTNrJndrUAHYpoPqn4+YUCIQDOLCLUdd1+\nDEx4Hj5JdeYa1AlVgy5EWfARBKT74OZ68g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAa1PNpTXZf5t+o0Cp/leMLZOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBmNGY4ZGYtNGMzMy00NDc2LTg2MTUtOTRlYmRkMTZkN2UxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNjNzA3OWYtMmJmMi00NTlkLWEzNjUtYzdjYThjNjY0\nNWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8LT1T8+Fla9fvmnkQMUxGCrZ\nVzs8f5Nh6VyIm+rj4AakxsLHYmJ/DbGudFeK+/RZacZI4xeJw3XayaRthDcnUqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY8e1VcIzTr9nC0tii07SRLObnkgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCTfDzN\nG6RMcsMrF7DZAyuNHfQ0iam3GA5ad4I8D9Q8+wIhAIlZaLL5fRcucZRT9XpuMfwV\n58zUMck6CNswZumvdL0m\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5040", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5040` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAYHnqSplUXV23lUyfNluXlJVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NjU1NDU0LTlkNzYtNDY2Ni1hOGY4LWU2NWUzZTlmM2JmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU0NzhiODQtODJj\nNy00NWYwLWE3MTctOTM3OThlMGZjNWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhL6dIMPXh83Lyui+gLvkJhOSH2iiplWxLjNN6DHNIbaE5wEmD67oQPSgAWpC\n2sBxX+kynEZTScMrQkTX680ty6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcIhzR3Z5BlL5iwoF3xkfBUQ5354wHwYDVR0j\nBBgwFoAUK3sXvk2MeE0JqDxvDzArbATQYUwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAO0BjuQLmYfF\nsSX8gO1ckBUHNjuzvlkkTqyaPFE5owbOAiA4jwXZdJQZFw44QSJd0irh8JoYDxoR\nBE2daI2smYmmnw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVdRFJAFUsnbo+/6iblN5w9hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTY1NTQ1NC05ZDc2LTQ2NjYtYThmOC1lNjVlM2U5ZjNiZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDQpNKKyxHGttAXuQgANT5Y5ImZuQYWd7SBTenXD3anMbU\n4NHVe6JUm0kRGsVTYaCZM+mQMAy2MHxO3UVjh4VPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK3sXvk2MeE0JqDxvDzArbATQ\nYUwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALv2dXWrkZJ9K6HK8tkSjF/4rO85Vf0oMN98PqjME5/CAiEAgX1phbi7\nTN0U9hVazE1OmFPzZDoyDc2DGQqfx8XSZZ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfWdTYlnm5z2ON5C13yx+al8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU0NzhiODQtODJjNy00NWYwLWE3MTctOTM3OThlMGZjNWYxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzBkNTU3YmItZDE0Ny00ODRmLWIzZDgtODQ0OGViYTkx\nNmRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERKrHzXopyBQeWCgjRNj+CAm/\nRo0o9ad/pV4iKB2BGP6YazpNz2H/1/ZswAOV6N3uTHM1SHsikQxSKySiXE27FaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcIhzR3Z5BlL5iwoF3xkfBUQ5354wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBKNl98c\nI19PTM5f5ac1I4qn6+uvh1astRVKY16cbFF5AiAkpbnoLv546Z0WWvvu4mRpla+3\njKElEC1foBMJlFxqWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5041", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5041` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVZKkJk4YE3V6IGOqVrK3IcNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhODczN2Q1LThlM2UtNGJmYi05ZmExLTdmMjNkOWQ3ODA3NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk1YWQ0NDAtN2Fi\nMi00MTljLTkxNmUtYTZmMTNkMTE4MDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc7Nd33Ge7sUyeoqcUJgrLU6B6TAciziYr/ORYxPrwsqiJuPY9mTrhJdmQbs9\nTFmiIQ+Plrr1EPFdNxTcygjmJqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuaFlArq5StPqPhg7QL+5cchSlvYwHwYDVR0j\nBBgwFoAUbHPM14xTVU+cfSFYGQQLhhvJhWgwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAss6wlV2FPp\nLzqS2e4A6zK1YZ0VwsbjPpqEDBpVGlvAAiEAzbnLVJIB81cjHen43vta9E0hxlOf\n5XxSQlDKGO42gWk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXboaiZZQEq0SbypCZ9972vSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTg3MzdkNS04ZTNlLTRiZmItOWZhMS03ZjIzZDlkNzgwNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwGlfuQIHIFkhpNIMHbieDFF+UVBnyOKvMmCZV10fMCR5Z\nnhOA5zzPZMwNMT4mSLBFX+boc6rumiG9Dx9qRnUEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbHPM14xTVU+cfSFYGQQLhhvJ\nhWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPhS0tkPa4QKcDse4Xphy6IFUAyOFxeHZUJAZmi3u/86AiEA4u8yitZ8\n1N4vEla11jxI5K3/UxX4ZRATGDjZUIsyghU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUpogPAxJHtB0jg7LoiKYNlIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk1YWQ0NDAtN2FiMi00MTljLTkxNmUtYTZmMTNkMTE4MDI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTMyNjIwYmItYjI2MS00NzdhLWFmODQtYTQ0NTRiZWU4\nYTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqXrFr1BBYZ+D4YWArepSXjWC\nv2AgieiaiD1BpRRfkYjQ7g4XIjbrqlnYNkGo7fgyW+iB0iMWoLqRPaODG7HmSqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuaFlArq5StPqPhg7QL+5cchSlvYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCrxSgK\noIhEbga9NalwoKfqkKXv6IzOaJ0HY6EYSBS5QgIhAM8RHVvV9+yTKDUuoVvPiyxj\nQHFt7vQ27+2oA2zNutk3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5042", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5042` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAT3xp0wUbjSvyiDQFEqpcAjRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllYTQ1ZjliLThjMWItNDQ1MS05NjRmLWM4MjlmM2VlMWJmZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBkMmYyOTgtY2Qw\nYS00YjBhLTg0YWMtZTJiYjYwMmQ5NTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESXB5akbZyUS/UQEGzULQ+jvBP9/AbHhW5fYUtCStgCRWwag8C1Vt7NSIlQro\ndB4kXHXuLoHTRMzNB6Ft/mb/76OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyNRldSquDvTPCt16uxZC4LKwlb0wHwYDVR0j\nBBgwFoAUawBmfaB5zwuxwIoPacw9qG4SSKIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC2u4C0ltW8/7xr6oOhgYOMRjHIcjt7jmcdvBQwPEqHrAIhAPgSX1L6VLjh\nIVa0dvRS1oVYna69CGE/b5sA7Aer1X1g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZNcacSuuKlapMiYenhUMyNgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWE0NWY5Yi04YzFiLTQ0NTEtOTY0Zi1jODI5ZjNlZTFiZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAWsrO3g7X/zpS47QaVIDQNij6evTTszyxGBA3JrAxa+/2\nWLdRZY3FvRR/QMtILnbRBndx8C5U63DQkNVkYL/ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUawBmfaB5zwuxwIoPacw9qG4S\nSKIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHD/Gp+ZY08McaLDu8p0hVRsdYY2EF4Pvt080eWndyDsCIA11b52kXOAL\nAVX+IX1iOJJg1vd2Fa0tmyrromkJeBWn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAStSwNu1/tPN8FhbxjNF/ipqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBkMmYyOTgtY2QwYS00YjBhLTg0YWMtZTJiYjYwMmQ5NTBhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzcxYWFlNmQtMDBjMy00NTU5LWI1NTctNTI2MzJiMDZh\nZjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEghxKmmLIRIz0uJZUe4Kp5xV2\nHs/5gUoWaDF2VXvA+UpjWKyZ4kpCFWBpJmS+gvkHl0nYiZ4h45d8FIM18gte/aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyNRldSquDvTPCt16uxZC4LKwlb0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDK+FNj\nOTb21JlmZ5P56GG9cea/Ld1N3bRy0aoucmjQ/wIgAryvW4K7C1pINAwD8bzRzEjB\nHjZ+2ED9ucxd3X+ota0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5043", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5043` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbszkUEkbYzH09K9JLKwIUncMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxMDg0YWVjLWQ1YzgtNDIyNC04ZmU1LWQ5ZDkxNTJkMmJmMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRiZWMwN2MtODhh\nYy00NTVmLTgwZjktZWRkYjQ5MzI4Y2VlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUpENLYj3Xt6Mses9XTLHbOT4+k/ccHMkqVhewJqLDluRDDQHzzquLF2YFqox\nPA8fJxXtpEZxWE6v0XPco7VyTqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfS6cx9IiAk41U3iHKZdcWSiA08QwHwYDVR0j\nBBgwFoAUdaUKbRTDHhZL/F4XSEuPqqE4BsQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEm6sV4T6MDI9+MHOhTeiC4CnHPGcVE/8AvELhGPUp0vAiAX7ahL5C/3TNb5\ni/VJBzFzOHo76BixhaQmBEYcFf+2pA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWCmR+JRlpJaKEy/vjqYomYaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTA4NGFlYy1kNWM4LTQyMjQtOGZlNS1kOWQ5MTUyZDJiZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThmQ3wh2kpJP944P3Q1gDvxpAchil92PQ31Y7iw5/Z0pIf\nw66KyhBdBVrh0uUijY+km+lueEh+1AjQkoXcZi6No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdaUKbRTDHhZL/F4XSEuPqqE4\nBsQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM54407ck85IlwY24is7ajPnUgU38Ou+e7u8i/ywY0xEAiAb7Hy2xJq7\nIrwrJkQPMkYu4ohiC9LFePjM0LELfedLsw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISATUgLNcdrdcPAu6HOuGFUDjvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRiZWMwN2MtODhhYy00NTVmLTgwZjktZWRkYjQ5MzI4Y2VlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzRhZjNhZjktMTgyNi00ZDZlLTk3NDUtNzM3MDk5ZjQ1\nNjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC628RAZDkNmxaAJY10Tj5oKF\naqQipHs1aXigd6fN2HQaye8C/HMs5LqjXXAVlkhwJwceYxz4mPVEjlqR9PMhr6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfS6cx9IiAk41U3iHKZdcWSiA08QwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHMl03D1\n20zKSfSdKFJ143ozfc9Db1BP/+Js5qExg9XZAiB2z4X5VFnzm5ZDEk54yhTfZJ9q\nJxDMAiWSg8byTVnB/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5044", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5044` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAQaOjM9LvLseMEze/nIKoOrPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMzQ3MTc3LTNhNjMtNDk1Yi04N2JmLTRkNjU1MDNkNDY0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBlOTQ3NDItY2Ix\nZS00M2QwLTg4NTEtZjg4MTM2YjU2ZWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqP1D1ekaw7/vPbZi3VfFGjLW0uOI0HkdfQF4qxzdh6V2orTyZOsIGOVx+eEw\n+euobd6UvqH6jvKYxIKPnbIke6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzOIVChAK0karFlMcCDs5xQUIiAgwHwYDVR0j\nBBgwFoAUzMQQ9tCKrx+ciaWY/ytFzCcLiN4wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDB\nNGzqqsxfAxq7zBnFyi5dLy/tXm+zPgH/E8Y0cGH1mgIhAPLjgSY0Ih4pNaZsGHRF\n+A8u8+X1fnG0zKV8KGZxCPRM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAREq3PDEiRsYc7ErR7rKYuB8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTM0NzE3Ny0zYTYzLTQ5NWItODdiZi00ZDY1NTAzZDQ2NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSaGz6nRkNVxDSRvk6iaJLx09XZUlWe9KnLl1emo5GAVxP\njgtk1O0pvDumnW5HMs5AcUxIs+l/Gfev2TxJLkWho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzMQQ9tCKrx+ciaWY/ytFzCcL\niN4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJALMocrFLKSbv3ts2/468r6xeFVZKQkJcVcLW2p1Xy0AiByjRlfm/Hd\niA1jKIBPKGa8FgLup01DG1YlKOj7x6xTkg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVgXMCZ3tSgZgr3OubGqDYKxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBlOTQ3NDItY2IxZS00M2QwLTg4NTEtZjg4MTM2YjU2ZWI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZlNDI3NjEtNmZmMy00YWZhLWEyYWUtZmIwNTE4ZTZk\nNDMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8/TpJoU9wYVPvc3fOjBO7AS8\nxAcM4mTKH3CItC2Mno51aUdkH6ow1u9Ieo2U/f2D9tQ5JF/afRGd4+kc0kfzcqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzOIVChAK0karFlMcCDs5xQUIiAgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCtENec\nKQeODvkUCIVDpuJksINVJ68par3bgSxYtT1t7AIhAJFIbw2+HLQmE526Hlc26IlX\ngXmJlGAxYmP/VJlQdFiu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5045", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5045` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWKsQzEeTW+VJu9ZaUt90vwnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwMGIzYjNjLTI3MzgtNDk4OS1iYWMxLWMzMTA0MTNmOTkzZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNjNDVhNjEtMDhi\nNS00YWRmLWE4MzYtOTAyZGQyNTA0MmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1od65e8fHKNLKRR8417J9tfs2Hr+1r4A+h8hhUdp82Rrk/MkUEs6EIu8Udzf\nPn5J4Tag52wVUQtsLD//N3tdQqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeZc0lyWohZI9rMp//rtjjh7K9YowHwYDVR0j\nBBgwFoAUyNQfT7CY8BIN5ORLoZ4WvxPEoGYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFtUD6XmBo65hhgRfsqrrRCPT72VGZzwqtaQi9kK+RbdAiEAzRJR\nIhrEVQQ56PeL3tocA/fvhGKSGwcpfkgnpIeVeqg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaEQJyj6aqCpTy5W0RN3bA/7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDBiM2IzYy0yNzM4LTQ5ODktYmFjMS1jMzEwNDEzZjk5M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJfR8inHk66xQk3Gj//ahhOA7sP3v6HdrVPQmkXL9P/1rW\n/CXOT4R1FZDTH890t5ASKy6iFfD1T8qIJftjQ6r7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyNQfT7CY8BIN5ORLoZ4WvxPE\noGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIwZALYWyRD0qtoM5qhnJu6hkO9i9bEHZ5LHaXBvZst4AiA/mar2uRAr\n+JAddv/v6aR6ddt6kE39+S3aT33cBGpGwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAWNe0jQXHd+kzz+JdohPf33QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNjNDVhNjEtMDhiNS00YWRmLWE4MzYtOTAyZGQyNTA0MmE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWZkMDNlOTUtNTYzOS00MDI3LWFiZWItNWViZDBhYTgx\nMWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEI4V8POxoTMZh+5FuTaoKGPr8\nkVAjvSQva5yBOzHnIpp4gPjf1LhYPGC4mf1m0gj0qI5XIDTQvyxPI+nl3yBVYqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeZc0lyWohZI9rMp//rtjjh7K9YowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDWfKeb\nhQSqDnA2gms7lIXTuIiXoU1S7GDX7QSa/SihswIhAK1UviYcV6wZ+/e3msZ6ovTX\nsoqmLwbHXKK0Ny4lXSb1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5046", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5046` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAem62TSkiKjlGCCol4pzdcx7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNmU1OTM3LWQ2MjUtNDJmMy04YTc4LTZkMDQ4NTRkZmU5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNmZmM4NzctYjhh\nZC00MGNkLTk0NmEtNTRkOGE4NWIxYWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZlJp1jDLf9/sTqyf8oADh+s1esVp4FGhlH5CKJLp39nObrxPhLOUzARvsCkT\nzs0tRq161h8RUBeNAQOGIrvoaKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqDa3y+yrsqd4X4kkin9qzA6NO4EwHwYDVR0j\nBBgwFoAU3a421ISSHjzz2fj8zjasU5sJOmYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIH2bgcLauNcxYaUhUCRq9l43pQk1pQbGMmc97zLdDC2zAiEArUdZ\nPR7JHKCHTI3ftzKpl69z3pL6Hwodd+VtENhSH70=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfVIZ33dBXaZRcryHf3h/DM/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjZlNTkzNy1kNjI1LTQyZjMtOGE3OC02ZDA0ODU0ZGZlOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3WnkbV7qd9hVrFbfGMV1NQYLJ6ql21qMBYpyZJ8tFdqml\n8IujKFbAq/kCieIqzM6p9dtt+yqnLEIbcVp9KR0ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3a421ISSHjzz2fj8zjasU5sJ\nOmYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALgkvUAdwXzHPnUh5OSKvhfT+WeDobdB7+ekdjZ9tf3XAiEAuMgK0uVF\neH1CuZaneNWScjjvNh/1jWUOnMuTj2ZKalA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASlpT0/wNYJl/mKAMHsLIT0sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNmZmM4NzctYjhhZC00MGNkLTk0NmEtNTRkOGE4NWIxYWIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2VkZDg1MWMtZmM4Yi00MTRiLTgxMjItNmQ2ZmIwMTEz\nZjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETy6PNUTIYFb2DPXZSk890KZ6\nhJJiSfgO/y0yLRnVjCLyw3PJhxA6xh9CSyRSGSq5KtzioliyHnWtWYtgaeb0Z6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqDa3y+yrsqd4X4kkin9qzA6NO4EwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFBNqtyS\ntG0/Y6GednLPuMYAWBopu0/CpFNrLh78PuZVAiEA2Ry+7tS02suC8BCyP5JRQgwp\nMXct7r/UfJpPJp3vnfU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5047", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5047` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISATPauS0PqPQNrWdsTjGeE6jaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzNjE2YzUzLTkyY2UtNDZkNS1hYzFlLTgzZmJlMGVjY2ZkYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThlYTIyYTgtZDZk\nMS00MTcyLTk2Y2MtNmM1NGI1MWM1OTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk2+V1JmOfwbKMPxXOG2Y6TsDWL3ksoI4rwcJL+C6Z0SesAesnSTYm5Fq5UbA\nu5RlTYYCavw9MB5DAyTW4xjvD6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKgruf6BnR8R+EBrTH8tTBhv/bXPMB8GA1UdIwQY\nMBaAFDVF8HuFYtj/e7oUpxJC4IxlXzIMMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAnyKdJ50Agtb7H0yzwOB9oKBBlzzh+FFp\n7LfZzAfopzgCIQC7STgLc/lDbpPBqZ6zmUzKaRVTjXJ4WnozrI+Yh3GY0Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVIquME1jpJcfyX7CipxaPvrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzYxNmM1My05MmNlLTQ2ZDUtYWMxZS04M2ZiZTBlY2NmZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQarwwDIBLH/tu+CZgu1dwjylaVKqFBy6s07JZgj0QRT/s/\naZWXV/Bpb4R5K+0aQTDR55fo1XKL4fJaOEhkBO73o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNUXwe4Vi2P97uhSnEkLgjGVf\nMgwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP7XpjCLkpDp7hZLdophqb77iIj8Eqe8op4vU6Xzu4e0CIF05nP/vY/n3\nD++CW3Iwo37UnMQ/SuToBW8bZQpkULIT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAW0fCLfNvFIcgAJlDXwyzUVlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThlYTIyYTgtZDZkMS00MTcyLTk2Y2MtNmM1NGI1MWM1OTZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWIxZTIyMDgtNzhkOC00MGViLTkxNzAtY2Y4MTBmZTRl\nZWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEUa6863yZ+Nz6XKPiFljLVry\nQ7T9MIr18QYZgYOjJsIJOkhQO+haCtBH9zSrkB4SdGzAXN38ak0zxhvvMiRIR6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqCu5/oGdHxH4QGtMfy1MGG/9tc8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIASgmGx/\nuML16e/trP3jh0pnJmk+ZVYn9X05tuuU0hZFAiBVt715wl8lM0zltxUi7sGigjoJ\nqXNFFwgm/ovZpGGOQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5048", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5048` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWO+MugyVocQnIQkT+2kiSsGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExNWEzYmNlLWY3YzAtNDAzMC04NGFhLTdiODA4MzliMzM3NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJiNDRlNjYtNDgy\nNy00YjUxLWE1YjItYzg3MGRlNDA3MTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk3jB5arxduABNvXAAqTOaUq/v4YbijiWNF90UP78h/6H8LguijHPzPemmt2S\n4lvbAKCTozUb5OpHY0+iU6SePKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0x2xpeolz20ySY3yZSRYVP19WV4wHwYDVR0j\nBBgwFoAUCbfxdzFLPMJh4tY1TRJFM740iZgwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANx4e2XH1/6w\noONmEwoPIXVH1JMYY2Xt1oygZkSnC8lvAiBOz/YsiaFEHyfeEJA/nsyXiG5sVSAU\nprurfpgZ6dgRKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcVXeefwJRl+ADKY8BVjsz/YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTVhM2JjZS1mN2MwLTQwMzAtODRhYS03YjgwODM5YjMzNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQMAQSGcm2zwPjn131+bRA9mCQ1IQHVWyOFJSYn4eScnQE\n8n+iG5C6Ws2mPRFpDlVlKErUFIwzPoV00M2VaZ3Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCbfxdzFLPMJh4tY1TRJFM740\niZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALUmD0jei4qxKiifAD3UeoedN10T0P0NJ3qWQnrVE/eFAiBpJxhlbxm7\nq9HHqPWp2eRxdK0N6X9JIMr0apvwGtIctg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYNfOK82U0UxfkwLifPwaH+tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJiNDRlNjYtNDgyNy00YjUxLWE1YjItYzg3MGRlNDA3MTJkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzViYzcwYTUtZDg5Yi00MmMxLTkwOWYtOTQ5NjliYTlm\nZDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESnIZn20RWeaJTc/liFlBcoeK\nymz/Gl/KPXNbZUjR7KWWrtsjR/39gZiKfzZsBWRKbxR9Hf3LOGmmndmoPIdrGqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0x2xpeolz20ySY3yZSRYVP19WV4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGOhfy0v\nsMiMJ9yP/SaQbnAqNokmZ7TELiEdW2cyHQHYAiEAjQkjtaKoK9Qz0S5RcqCf7dtN\n2G6NSrpBhUxemEvxbW8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5049", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5049` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAf+s/8HQqKBC9j/ILoquOXgTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhOWFkNTBiLTI3ZWUtNGUzNS1hN2Y4LTlkMGUzMjAyZDUxYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmZlOWEzMDMtODAw\nNC00MDRjLTgyMGUtZWZkMGY4ODEzNDRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcgBm5baLdtmDHC8dBoebMSfQnnyWAqHF8AUQMfNnU94sLlj1PMbnmwioGF+D\nKG+Ba2cxQPr3S0danl0CuUHFoqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA0NqHp4xeQr4fTxsSpCU2hBnbEkwHwYDVR0j\nBBgwFoAUMXrkj26EQUM7L3hsYiD0tEdlLo0wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMjfsD3mjY13\n6AQXDP1pQ8Ps9RYxjrzxl8o4//yXooYEAiA4l/YdZrLP2J9oPnifyIbRmrn94iwu\nYLTekOAMerjOOQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYz1DL7QD+DICvHx9cX2f9yVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTlhZDUwYi0yN2VlLTRlMzUtYTdmOC05ZDBlMzIwMmQ1MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARo4pJin+dDlps/B4YJDZyJGN341hB4OqYGnjnILntvJ5OS\nickNhJtImEK/mxPxhE/fnlZd6b+yS7+NeTacPh2Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMXrkj26EQUM7L3hsYiD0tEdl\nLo0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHiZ5WHI+Z7V6JnI5QR2bfMyie00mJAKeQMI+ubsFYvECIDsEj4SDVEpw\nyUQvWY7Aih+7t9ZB0KEIx22AKMnhdGlN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAXqWBRyn1fhn71mybXKzzHUMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmZlOWEzMDMtODAwNC00MDRjLTgyMGUtZWZkMGY4ODEzNDRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjBjY2Q2NDgtMWNiNy00Y2I3LWE0Y2MtZGY4YWZkMDEz\nMTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE96sitfdk1UHqCoPdRGlL6T+5\nl6IatCQ5nPjYcRPt3s62xjtjczKTeDQveUcuo1yeerqw8eaoznqNIiXhyPLAPqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA0NqHp4xeQr4fTxsSpCU2hBnbEkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCIvfwR\ndzpRgimc1BlImLyWw82pXzTRhPX2OEtXCDPwQwIhAPVr8a28m2WCyXJMlnwt+5kb\nmXGSKA1+ZyFrE0lrFvOU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5050", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5050` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZIYBDgudXr3bId0CS3XTHv3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjNjlhMTAxLTJkYWEtNGNjOC1hNDY1LThhYzcyNjFiMjU4ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2E3OTdmZTktN2U5\nMS00Njc3LWI2MjEtMzBkNGRmNWIyYjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyDAnRsuhtben8eEcSPiwScceHG19iVp61fc7VMPZUe6HgEvUWnjibdtknJom\n/a6LZdhbv/eJ3eVc4/GhJ9uHAqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5RBkHMoCz9nxolabBVSNS9jo7YUwHwYDVR0j\nBBgwFoAUlhtB7kY8oJwCl2tJ1EkeI1Te1kEwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICl0yApsJ/gz\nmhbeYadI/c0m64cszIWiI0TnRACpnpXQAiA+9a5USmnThowajvHZ3s/9exOJ69Fc\nEPe6Iywd8W25/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ3DnQU0b2MJBmuK3Hv/9gbOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzY5YTEwMS0yZGFhLTRjYzgtYTQ2NS04YWM3MjYxYjI1OGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ31MzpEuvPnWeSQ4ZWyDO0y9TTo7ftuNq2IqPG6xNDkncy\nm0niBqMJ6WKLMXiM8ZRI5CaVEZmHc0BSH/1lnQVyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlhtB7kY8oJwCl2tJ1EkeI1Te\n1kEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ+/9gcgOtRPDslTCq+0h9tLuk7kQlKHpn3J3YcPi+HwCIFFzV1hrqgS6\nUigCI1TrfLN0TnDHnGdf/7iyVB8hpR7a\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAaCnGsLKCDbXUpsCg/ZXqnM6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2E3OTdmZTktN2U5MS00Njc3LWI2MjEtMzBkNGRmNWIyYjkxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzBjZjAyOGQtOTllNi00NjU1LWIxZTUtMjgwZDdhNjEx\nNGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpxygc2KY2afLtRxb1qN8pQpJ\nUnygF9GcUhcK3nxv+r0iWEdw0fGiIPw+YvchDuSQgvllgz/eqGR34Ymywhn2XaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5RBkHMoCz9nxolabBVSNS9jo7YUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQC99vRs\nRVOpLJGqXM4cUbCGaLAsUsW57ksQa9UxBD5BJwIhAOgXyBgWqH/W6fpN37B6o79M\nHORWXeGoWOV0UtBKNOop\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5051", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5051` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISARo0u8SnEgphP+neceb62DEoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkZTRkMjg4LTQ3MDMtNDk3MC1iOGZkLWI1OTIwYTgzNjQ0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NjNmQ4MDctYWU4\nNy00ZWY1LWJhNzktMzBjZDEwNjMyMjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECsvnmOJ2cNAhHR2qbGCbsvNLxrV3XZguVxtQPDzpRqRr9oickE0LPZ4FnyZk\nrjjNEVaFUuBBuUVVWxt53gKBVKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzNEtudAM6efX5v7Pst9JRyXAIqUwHwYDVR0j\nBBgwFoAU+K8tGoEbpIIAmMsdtD28L4hPhV0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEygtIeT2WvyW9UGE8Tx/3mdlODUZahwxFiB4xKuZTILAiAgJJznS8Y2XedP\nay7hxv5MB6Ile71PY9tq6W5+f/2Qmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASiw6E7kyyPLWbdLQF8nMZ1JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGU0ZDI4OC00NzAzLTQ5NzAtYjhmZC1iNTkyMGE4MzY0NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAST2qKoU6TbSmZewCM6jYTBqmjwMeKcIq65pjW21ZvcwebO\n5yNn6InFba0SuFwtFcFIagE+eDL2cDFX2rnXQYEfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+K8tGoEbpIIAmMsdtD28L4hP\nhV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPshyyPpgQlGaTktz74Ab7+aql4cNX9pZktKKR/TlxcdAiEApd0fGuQl\no0Hg1+3YBQ42HADj+OFdrswDQBWkg0CE0gI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAeGxygnNEE0Htm5tscFnBNSHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NjNmQ4MDctYWU4Ny00ZWY1LWJhNzktMzBjZDEwNjMyMjNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTYzZjRjOGItOTFkZi00ZjQzLThhYWEtN2QxMTMxOWU1\nMWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8kHIHdXlNJFMWV2CCt4ju0/d\n0dmiSX6woTUj7ESmAa6h448vyDmKlDSqzIsxwcqOhTWAfrSHw/rftuOtTmGfa6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzNEtudAM6efX5v7Pst9JRyXAIqUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDTeo8B\nRoX1bEWYfeVVQhRbcTMLvZRtwUCvtVet0mW+fQIhAKC3RVVmYrH+p8LKeoU/++WF\nc6glxs4rcaeqH0mZ5Vsx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5052", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5052` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATu5603LYADfWI4VVxZehCK2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMzRiYmM1LTc4ZTQtNDc0NS04MmU3LWU0OWE3YTM0OGEzNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFlZWU0YmUtZDM3\nNy00ODBiLTkxMzUtOWIxNmVjN2YxMTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdcyZvdP2Z4V+yDRIWJL12otX9xOyEIbqWX6/dy2u4wxaW/X7DoscsPs8KFVx\n3asMTCVQSETabUZcYD9shXSf5qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaKJABS5sRK30koYUFomujr1KQ50wHwYDVR0j\nBBgwFoAUwLbXjDEgxybjLu2z8Q01mYUcJuAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICfHwuQzaK1iUY98LhLj6Yycmt3rFeDfoDDhGd04uJN0AiBufrCsQxgpOja+\nSMggbHo7YBjXSaCsn2KQR7+LSXQyEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYqSnfLiV9A6sj1SXyS/VJ0yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjM0YmJjNS03OGU0LTQ3NDUtODJlNy1lNDlhN2EzNDhhMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5KURseSlpaS+M7ZjwhNGeRvzumJq0E54CZpU1QLAmqqLJ\nZrELURmbwclaXCaLeoZMvlPg9H9SkjBr/nHBEHZqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwLbXjDEgxybjLu2z8Q01mYUc\nJuAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAIK0Kd0AFUiBnJyJAIM9yHNBL4wMWd3bphH3dKp/oycCIQC3g4YV7qBs\nN+s+VHoppsZu2tH46VufgVAlt1QdPgDGKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAX2V/Y4rCFEzmXS9ErrZvau2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFlZWU0YmUtZDM3Ny00ODBiLTkxMzUtOWIxNmVjN2YxMTkxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTdlMDJiNzYtZGZmYi00NmZlLWI4YzMtNjBmMDMxOThk\nMGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE9MxNfuANCFXvwsZbQILe3C2\nWkInQRH1skykgbsuu0XVFmtItvRTDgXwL2s5Zt6yqOODTBOMyyOSKo0RWqGDq6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaKJABS5sRK30koYUFomujr1KQ50wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCGeWPD\nGuTUhoNrYI4EETfoYN4FxwrB/RLxP/CpHeR7FwIhAMCwEnm9HXNxjbiKWJJ7y7RH\n3oKYj1bL1RXEqDiOi9nU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5053", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5053` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAcMLp70qoqSPIqni75E88kUWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3OTBhMzI4LWEwMzAtNGE1OC04YjBiLTY2ODA1NzMyMjVhMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NiYmQ5MTMtYTZi\nOC00MGY1LTgyODQtY2ExYjZiYTdmYjg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4QjKu8fyLGsky7LYH9VYPmTd09E6xFixrACuzv3g9u1PJpwK96LdbSgrPwXe\nMHCtQTUIKzwwd4Q3v+FIKIl9P6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL0LMObuYvQmimXEvU/OLp0kdvtAwHwYDVR0j\nBBgwFoAUO216YcV8ZFNqhEbwlLAkzdfQJTQwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHGB\nrfgbgLgD6pBkRMt9RIB4OWY5WJcQcrvWPA/DeFxfAiEA7N8mz/TnmoVxUkF2c4j5\n5Rj5rHxrdBP230KIAgRD1KU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASljHyqZsQ8w3ZvD7hWV5qvHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzkwYTMyOC1hMDMwLTRhNTgtOGIwYi02NjgwNTczMjI1YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJrLfHR1KOnNjDY1QT3ESwb7dqQVvC3G2D+QasiCsXt12A\nmuS4esNhIqCa6u3BzaeJk6h9iGzoUH2Klv3RdXxio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO216YcV8ZFNqhEbwlLAkzdfQ\nJTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPSnOVtIViDbcgziz7c4jVTSS2edtRTttOkiwey3g9gnAiAP0o2CDDkZ\nmti0x0SBzajY9Ux6ncPPUU9IEf8LuKkdyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfy5k2reFtQkuhSNmylrx4WqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NiYmQ5MTMtYTZiOC00MGY1LTgyODQtY2ExYjZiYTdmYjg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmVkYzE2MTQtZWUyNS00MDAyLWI3ODUtNGZhYmFkNDJi\nYTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsUj+dgDH6r4sVz5K8GImkfVf\n+D7886og1lrO+LWYOAxL1uRqZLNKSO7nUb7JkIx6HMaxLgdsi8Xx0ofFKZviuqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUL0LMObuYvQmimXEvU/OLp0kdvtAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICjh6BRU\nsTVnyzmay6YXRSRXUUAgY0xJ/CLWINkbfq2CAiAfXpzOSCI12IpLyrxD034ya6hu\nVP5cH0dLl5Z0QJcwOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5054", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5054` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAR9V84jKOsp4w1/HAYEXTx4VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExZWFjZGUyLTExZjItNGE3Yy1iZDczLTE2M2I3NzU0ODBhNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg0MTUxOWYtMTJh\nZi00Njc5LTkyMTgtZjE0ZTNmNDM4YjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa6h4br9wbH86fMI46pxMdiTnAcT4v+lOCHv8I9E2SGd5ja1lkD1CcqK7kh/o\nf/i5LUDBfK7h4mMACIiYh37x36OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURqMOqbpHEmnxGA0ePavezjYMqEwwHwYDVR0j\nBBgwFoAU1XeTMZ0oZIshOIuIZR2nfp+jxpYwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIB/fc5fb74tQF5aM/6JS/vas/EByiIM6iogVH+e5jprWAiEAk+Ol\nGTQg41qO4aR3pSFmcm+S1ayemnDMaqvXgIV2XXM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbujDdsc7qyGXvButWISqRtYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWVhY2RlMi0xMWYyLTRhN2MtYmQ3My0xNjNiNzc1NDgwYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbCo/rcWhDB55tKd03znlq1OiYHw4PkU3f0eyD6tE0pgL9\nP+tSxc66BjdvPPXpBMBGCfvQTc68QkCnkeDaVtYko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1XeTMZ0oZIshOIuIZR2nfp+j\nxpYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNcAylho40g95+MBtDav0SwqM2ywulXXae1c4bMPUws8CIFC7U415xER8\nv3jwfs+/doUnJWZEb65y562F6QoiERBk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVPvqkxmEnjyxLpt3E8sbjiFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg0MTUxOWYtMTJhZi00Njc5LTkyMTgtZjE0ZTNmNDM4YjA3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzA3MWVhMjItNmNkNS00OGM5LTk2NzgtODc0YmQ1NTA5\nOWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAET2z9EA3oJKDuPTPeODnKHD6b\nf01qAMmOI/oQoizbTVqvA5kv99gUScdkQz/SZ7VB57+wMkcP7MmxcOXYBR15g6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURqMOqbpHEmnxGA0ePavezjYMqEwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDuqY4B\nybyVbuijHVj0Jovj99t5+KqlkdZWxjT5m3l23wIgPvsql5ZcVHc+52+NDDACuDNZ\nYWDzE+h7OSA05qM7k+8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5055", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5055` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZKUBwPx8yH8rvIQi2q9Ff5zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmMmMwOWNhLTRlZjEtNGFmMy04ZmRiLTM0OGJlYjUzNGE3YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdjNDgwYzctZjcz\nMS00ZjU4LTk0NjYtZDViOTE1YTU0NTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhJkANuAyTnHhCQxqP8DAdYWTLirFUBBVVwxk/ivP3p6VqST0ZKyLZseylATG\nljpawbRdmPe0ueMjIHpf9vZ8kaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKx/Hu0V7LJpM+4K1WsHBUS0fI1cwHwYDVR0j\nBBgwFoAUF6AyswgXZ8NM44xslrZ8Ezn5iIIwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCE3jlfKTRC5ShBacyjUK4AKNsaP7mhEwd3UuoZARTOGgIgC50z\n/dd/H3e5cNcO2V+3ZN1JA8a1YD2kAZBt1Jc853I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY7tuFV6g1U0WgrM2pTDCWi9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjJjMDljYS00ZWYxLTRhZjMtOGZkYi0zNDhiZWI1MzRhN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2RGaWp+7+PzQR0CxBFTwMl5B1PddPs7QpGXy4LjZE1QxG\noITfBepZgBYTeCQZ5ay952+LLiYM3vmzhf7CGjgDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF6AyswgXZ8NM44xslrZ8Ezn5\niIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVZa0Y0HG4GgiY+p1364av44qJHW9UoxPfS/Y6GQWNIcCICEZQy+qln2E\n8LWY0GpzN3Vyke2yQdNCwKlNcbBK3IH2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWVfCEwjKIxGGMTx09uZfigbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdjNDgwYzctZjczMS00ZjU4LTk0NjYtZDViOTE1YTU0NTU0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNlODRjOTUtMGU2My00ZjgwLTg2MjMtODU1MzM2ZDk2\nZTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDGqqQGHU/kK8b3md+PgT2W9W\nIh80MgP62/kpAH0x9q9Dn0KrDgE0Y5EWljGdEBQBDTjS+97kMsHAX5/ZlV5cM6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKx/Hu0V7LJpM+4K1WsHBUS0fI1cwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIACKEaiM\n/2ChymbGyn1wy/L8pATHN7sFCWkFNiY3gLkOAiAxPThjJKG2c4vhcF4M8pIIOIni\nPYS9iXc4b3tJXLqBaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5056", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5056` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQ6hePHwnEAo1m+WB6JB62VMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3NGEzYzM1LWVmYTktNDc1YS05ZTI3LWE3OWJlYzZlYzU2NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThhZDI1NzItZWNi\nMy00ZTM2LWFjMzEtMDBmOTE1NDkxZTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE96eIplW/GVA3ffBMm02PZrSKOt/NI62TVDBnJyKPm5d5k77ehuLPSTT2G4xB\nm86zRY+86KpLfTIHBnK3Ek0PLqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSyyRHsytJO/os1JuX8PvvLdNkrtDAfBgNVHSME\nGDAWgBSnDK4ihIs6jdoJGUDM9NAT+Av2uzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCtKnxuoafM/KsiAtXlelwqdogCfHYY\nI137guIJN1owJAIgc/zLgLtqw3DpFLwm9CQ1cNONTTA9VP1wMea7RrelXr0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS0p/F5oJEgzvUVBoWLHejUfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzRhM2MzNS1lZmE5LTQ3NWEtOWUyNy1hNzliZWM2ZWM1NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDLyi9DNEMS8Z7snUJfAjxjLJkkhx2iEV/NR2Jm0hITQe+\nIUTLYjft7N/QuycqsjkoLxinJUH3CDYgw7rc8p9ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpwyuIoSLOo3aCRlAzPTQE/gL\n9rswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgepiry0HML2gBOlFATO1EN1PG8/+PIsK3s2WVMSNx/mICIAczLCa3fUig\nQudzJbPjpuH5hkd+uwrX+P8Ka2IfGIUC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcZ9PSpEdpLZmjxzamZ3uyRIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThhZDI1NzItZWNiMy00ZTM2LWFjMzEtMDBmOTE1NDkxZTVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGJlNjdmYmUtZjExYy00NmNlLTkwMWYtOGFiZWQ4ZDgz\nYWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEv/0SP6dEMHbACEmrFz3/y8/o\nlFFlmHpYIOjy7QvfEpoeMR8VlPpBeaBqEWcyHxwBIUwxpcst1ER0dRHxLO9Zy6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsskR7MrSTv6LNSbl/D77y3TZK7QwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDew1wC\nfeqkSntoZ8wIiBz8QNTKFNKHo9WHEIauQmri3AIgcMk2q+yHMsOY9w5CQZZ+nWCU\nYgakXgYeXEdzrIAgUdY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5057", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5057` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZwaxdi3C70PysTZaHzON7hzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkYzA1NDI5LWRmZmYtNDFkZC1hZWE4LWJkNWY2Njk0MTE1NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQzNWJmNDEtNzE3\nNC00MDc0LWE2NTEtODE3OWU5NzU4YTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk01hwKl6ocEwdENtAQzDXWy1XP8ukfRVKW+1Lbjkul1yUxhpBc/ROQdMbOHx\naXBeixkiKaDtyWHMvAMwCHL4oqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA6/qM+fLdOic8gV/ENT/PmmMdCEwHwYDVR0j\nBBgwFoAUtCngKsmPBeoHA+IQ5HEfJQup210wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIEm6sPwMpLD/\ngMF8ksy4+dhSmLgK879z2Mrg5oNLbgq+AiBVHQmfGsqK6YVEZ1WlYEBlsGBurjjZ\n+QS+M1H8ASdcnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARF2qrFVJ56KkZvEL7mT3la+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGMwNTQyOS1kZmZmLTQxZGQtYWVhOC1iZDVmNjY5NDExNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtqkIOV3DkYWWiprMV4bFAl9JXnEsJBPLHqhSQDWs26/ON\nsws548OtWHb5T9GLfndep7Tdb1ikf5jAnHyRznmTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtCngKsmPBeoHA+IQ5HEfJQup\n210wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOfTKzv7MS6Zs2eTY09DYy1K6U4zt1hNgFdQcX0tO2o8CIDvSJfIOGo50\nZlpK7nmH4jjbFCgMmJv4ugxTSqVxPVqY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATSLWhXw9HHo4ohq50MVkuPEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQzNWJmNDEtNzE3NC00MDc0LWE2NTEtODE3OWU5NzU4YTA3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzNmZTU0YjEtMmU0Ny00ZjlhLWJjNWMtMjE1YzRkM2M2\nOGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqR1hxPnNPQITcwalne4mfy1B\nQi2+9xjIIhB9KswDK9vcQa+MeUY4hG2FhObHOvx2MfwGkBYnNn27f8icj56eY6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA6/qM+fLdOic8gV/ENT/PmmMdCEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCID4DDQ5z\n87aa5NAoptzw/KTFkJakrX8ghKcq2JGzBy0gAiEA9G8KpNEG7H2ZM4ZCtRxUfcjv\n52oSXS5vXjXRTXutJQs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5058", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5058` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAanuJ4EyNdOyxUxqZr6n2Z63MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5NjdhZWYxLWQ1NzctNDUyMi1iMmYwLTA4MDM4Mzg0M2MxYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmVjOWI0ZWYtNGYx\nMy00MTY4LTlmYmEtYTljNTM1ZDJlMjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2hBFhG8OCrw5YHSp6dxsOWxTH+CLyG2rcrx9qKBIL0IJxWHnf2A5onuD5hK1\nm60ooVjdLX6WmaXfQ0CGvVq5NqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL3tZ5nRAJDLmjpFILfHBOgYiVAswHwYDVR0j\nBBgwFoAUb5pkdyVhaT+kfyu/POz4kLkdQy0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDk4O/3bGfk\nIJpbnRHWp7i/yedQy8TxxREIL+dbYsh8vwIhAJsA9NEBI+Y9pK0xE40NkrXafMVO\nVjez3RWk9+hcdkc5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZAMMBJwpTGEjbBZIl4P1Q+4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTY3YWVmMS1kNTc3LTQ1MjItYjJmMC0wODAzODM4NDNjMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3rMp1IPiJrJ7vGySqyIkU6jlXOTVjyz5Prm0LRxEKOo0O\n0M9C0vcm3wKkVGYKWxTEd7ELhh0x5KSNPPhsp1J1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb5pkdyVhaT+kfyu/POz4kLkd\nQy0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMY8syZAeQYmhJjLXmyaqUAkD1Rp/SVi+z7Hw2cvLwE+AiEA/iy9vw7i\nHtNZlxpbWS95huPRinToKCkMTckKoFRY8iE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfG2R4IMZtZa6hZ6b2MhseEPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmVjOWI0ZWYtNGYxMy00MTY4LTlmYmEtYTljNTM1ZDJlMjYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGQzYWE3MTEtODliZS00NjEzLWFjMDEtMjEwOWM3MjA0\nMDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsVojwxFAEtEFYyl+CGtD+7eZ\nJQgWO5sKq4SesFHmZsWnAGoMtcp0ZbF1BdDpnPLnTTAjusb+Te3nQbS78NobFaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUL3tZ5nRAJDLmjpFILfHBOgYiVAswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCRW2Oo\n06/ks1CgxedzNxBR2sHyLRNkgNX+d2M+mIY+ngIgdjKRSzfWPXAlLowY2s6CBiPp\nA4QeltH4TuZ1+oh40qo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5059", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5059` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAdgXh43RayKSPms9BAbAoRKHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwNDdmMmViLTc2Y2UtNDFlYi1hYzdiLWM2M2I1ZjkxODZmZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZjNmI4M2EtNjBl\nYi00MzJlLTg0YjgtMjg1MzU1YjA3NzNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaoYNkS/6vFdTPYuDtouh8Kto5lhV59iLMXspOPAfnWwAPMXIKk9QtqeGu7UY\nzLm6mZSX5/m8cFFv+zurGWcKgKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Wx/TRNYuEEAH5UF+oR5c17pvLkwHwYDVR0j\nBBgwFoAUVxrmvZyHLHGJnQQKmIAF80sbqQkwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAiEsdWbdE\njwaHpJCumG02eaVlnHQg6+CmxdGU9/pdgfcCIBMsYr53og0oAHEVtOcsIU0JjakK\nbKl9R7I2GmbuClfD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbwPuF7Z8+h1Zs3wwjDNMMsMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDQ3ZjJlYi03NmNlLTQxZWItYWM3Yi1jNjNiNWY5MTg2ZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGcjD9rnHam3b/56acEN1+w8ydgYMjzNT4dZoh1S2UBmJb\nwYUEDfUfbMaXXUAxPvg+YGpV26Q2PcMLvkpIRNX2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVxrmvZyHLHGJnQQKmIAF80sb\nqQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIge0b/Smi07x+ZwYSQUwZ1iFJ5AibgZiQ3cJOgw0vZzCUCIQDg/r5XW82O\nfWRCd4X2jU3rETQ4xQR0xLCGv052zqgkNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZ4ml1oHkWEu1FLwHrWpUphoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZjNmI4M2EtNjBlYi00MzJlLTg0YjgtMjg1MzU1YjA3NzNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODIxM2NlMTMtZDZmNy00ZmYxLTkwODUtOGU2YTcyZjM1\nMzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgcfXqOUBDkGc3hPztuJ4n97+\nmOhKTKCmSbt+MTU+nsu9pmQ6rA+0sSEOVk1xPy+8hZ8/IXqUfIGjyX6QdKBk7qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1Wx/TRNYuEEAH5UF+oR5c17pvLkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCGICRs\nGw/RhzZRlZbJIuk8L0CYhUn1jZ8l/+CFwyoFLgIgHin99oqRWpuQReEkUdk1IeV6\n4cN8Y66Ab0OgNoUSHeE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5060", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5060` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAQ1RHpkCKGCwWL8QxYH0IFJIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhNmU3ZWMwLTI0NzMtNDMyNC1iNGU1LTFhYTdjY2I3N2UyNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGViM2VkYWUtODVi\nMy00NjgxLTkzZDktOTEzNGE2NTM2YTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF6Pm9viKYf23eTnmbmgdk/z3LkRSsYQLRs/eQ1Z/0IAoAxSYwMxPZzZ1yOyd\njS5FYNSacF/mk/RgJd9SbszPDaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdQqON10VbJGKVlYUpJeQL51ql5EwHwYDVR0j\nBBgwFoAULP9URsGBCggdqZXcCFusaQRfASUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA1C5aLGvCWxFbY3XDp7qRjCHGxt9hBogLyUqzrdOrLuACIQDJJyFRzeba\n2oDNs4AVPG2wRK3GGzz0n9j2uBR6BvYNkw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfyltX1EPEgmD0LhOTP3qIF+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTZlN2VjMC0yNDczLTQzMjQtYjRlNS0xYWE3Y2NiNzdlMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQdhBApZYPF8sBMQOkbHoZk0RXB752BE2XRZT4lg22OmEL\n3jUy9ANBP4Cfhnhpi6PpvRl091fAokNFtSPAK2hmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULP9URsGBCggdqZXcCFusaQRf\nASUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc0Ne8jZNqf1TDx71Jg+fusZtLYUV9rZXVi93BhecP/kCIQC56suThH9J\nlqo3h+9yCJOeiZx6xUQE37OP5GbnHX+rnQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASDXnhRq+z3BlT7XVJX112zRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGViM2VkYWUtODViMy00NjgxLTkzZDktOTEzNGE2NTM2YTNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjFjNzM4NmItYTUyMC00ZjhlLTlhNjYtY2NjYTUzNTkw\nZDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqs5SFBTx3K3SDDFoB91ubo8f\nb11iP6RAAZT72matVZUhRCdK5j1sQ9CLuu2bbxhgdz/wQqSoE0TVmo7ZCOXqTqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdQqON10VbJGKVlYUpJeQL51ql5EwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDGQycG\n4qGnyK6Wz6W6w1SkrQd6ZLL0ycxQ43ydQmcZYgIhAOIHW62y2pdXfYKNpNv0C1Lh\n+Tuu7mQcqDEEHtEXyASz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5061", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5061` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAWaWH4lG9jx5yBH0zQQGLeeOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMTYwN2I3LTYxOTMtNDA2Ni1hN2QxLWY3MGIzMTI5M2RhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2IxNzIyZmItYTBi\nNS00ZjNhLWI1OTItMzIzZTNmYmFjMThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBbCEYml8lkNr6dEN8OyCaY+5eI5F+PweGZd58NPooDmsnedH9973pJSjN0ko\nUuqejX5Dg+TAMUHeZe00PH1+Q6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVKAJFzEO/vIyz8VrlhGcwg3JOVYwHwYDVR0j\nBBgwFoAUMdPlULH7mTl+vMY8MYCpzWS976AwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAjLLu4Oa6zVK04hsdhmS4HRXw0MpuIaN8C4UMhAAM3s4CIQC8sCvFk+aJ\nd/bHMYOLJnBojadA+QMJz6Q7VlJja/8pKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWnftypgWuGjYlFhvQ0Qev5FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDE2MDdiNy02MTkzLTQwNjYtYTdkMS1mNzBiMzEyOTNkYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASunKTIna/GSj1HsxVgjtFEeVDpYtUB8no8phqGWkynE8OB\n0GbDsDw8Lp2bw1qGx695+Q944YxEEjW/K1lWxpSlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMdPlULH7mTl+vMY8MYCpzWS9\n76AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPzd1CfdFjRMhbWEddYbLYlD6Yu7AEmMoOnrG8fwkOVrAiEA/0bX0d//\nUKnq7FLI44ec+3SYloxN0q/UWeoCfTXkpWg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAfkvH/Dqicxv0fEqcbPV6eomMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2IxNzIyZmItYTBiNS00ZjNhLWI1OTItMzIzZTNmYmFjMThkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWU0NTBkMWUtZmQ2Yi00ZGI0LWJkMjItNjBmM2QxODAw\nZWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElhozMTy3oHqAea6AicziDkXJ\nNcAMqSU0jLiJAPpraON6xK3NhTS7BTyMs1xdZ/eO9k+UYNsrU8uDZSNj9mNszKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVKAJFzEO/vIyz8VrlhGcwg3JOVYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQClLMU/\nheUfwSax3gCe7CCIpBt50wkB7UTeVWNSskpHsAIhAMTyOIPbfpR+kh3GNDGMU94g\nxJw93g5aXeZ+/IOGwufe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5062", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5062` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAduSl3UVrOINVW3rJzV0gcVtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4NzQ0YWUwLTFlNTktNDEzNy1hYWZkLWM0NTA2MjMxYmU5ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg5NGNhMWQtZGIw\nNi00YzcwLWJkMTMtMDY0ZGI1MzlhNjc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4NMH2Z6FpZFf9mBCkeroDxJ68aT4kNt+tyUdnvK/Keq2Jvwv3gp1ca3IfZNv\nThNrHnM84ZuXc1O/42nO2cbETaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrmAM4KHrcaCIxAqD5/VUPCVFNvIwHwYDVR0j\nBBgwFoAU1Xmg23FmKCD9rjlL8Pk3ikmwCSMwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n8m/IqbxeKxSzh/FgdZ9ZS0D6bneyTk0l2nlGw7U91aUCIC4AmgY25olljUVYX4ik\nkgr2YM0jDf1TXetJulSP75fr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdbUcOMhY2RilWJm4F1Qsp8XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODc0NGFlMC0xZTU5LTQxMzctYWFmZC1jNDUwNjIzMWJlOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARATFmuxKi3t00mezlyoLhNzU5CdY80QSpBGT1yj6SFSChE\ng96hJ+xj6HPd3ymqazfFAYu/4RoBvn2NIuoWKevjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Xmg23FmKCD9rjlL8Pk3ikmw\nCSMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIw4JoS36wiV1K8BKgfD8meyvm6EKYo9LZOLvj1lC2AjAiBrJzr6PP30\nPXtFci7ed+qconORmKzMP+vX/hnPz/S5rg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXieSP+3N/xG/FIh6lLma1rbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg5NGNhMWQtZGIwNi00YzcwLWJkMTMtMDY0ZGI1MzlhNjc0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmI2NzYwOTctYzE4Yi00MGUyLThhYWMtODFhZWFjNDgy\nMjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbCg74TwVSbfDhAQcl+N2QULI\nubjtky6HRMZFohivWx+KkM3WCE57dvr4cXVqaISYf5yfM4R8fUfPiks+BK+xZaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrmAM4KHrcaCIxAqD5/VUPCVFNvIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCRjiWH\nl2738URh9bCbs94GualC7mqFcolonjCJuKNTjgIgT6KGmXmrJeqYSg9s4FeJ25wO\nSWio/vEh1C6RpQvT7f4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5063", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5063` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARy2U5krx4DenUs6dxhxf8khMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzNGI0YWEwLWUwODctNGRlZi1hYjcyLTU4YTM0MWUxNTc1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkxODEyOTMtNjMz\nOC00ZTQ5LWEyMDEtN2NjYmJjNzYwN2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES4Hyj8gCmujIKcgEUmRTAAHO+656tkxjcHkJJGkPZkKqsNQuYgykUyjTHq9D\nQBS+SJ4JfAYHZogsmRI7LMa5MqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Vp6THboMub062GjDcNh4oSghPEwHwYDVR0j\nBBgwFoAUtWrcU10fy/CGW/7QyOVU8PI+1cEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA05D6CR7Wk2B9vXoby1ZJ5NuE+fgLjc+WIW0ElFJhk8oCIDrz\nE8kVrcyz84mkTy6L7WF1Qp0PqqvG+nksCZ7gXyFl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATBGcLEnJQ9VhfRuzOiBSa3RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzRiNGFhMC1lMDg3LTRkZWYtYWI3Mi01OGEzNDFlMTU3NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7ZbthQJRBZcQ2YX0lgIiPj/UfF54EETD4nFXFxht4k0Os\n8Rwch21ZuRRCbCZO+jFTMIsGX7N/uKXaYVonHCL4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtWrcU10fy/CGW/7QyOVU8PI+\n1cEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCMPAwgcjwZQYCwIbRL/cT5KjE1jG9qDFr1KyGZM80OcCIDjsN7/g6zjf\nRu8DL4hY2/Db8xMZRgnUNOppPGIfOFCL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAU2Cy9a4LWuX23qrFvYL9/y+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkxODEyOTMtNjMzOC00ZTQ5LWEyMDEtN2NjYmJjNzYwN2EwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWU0MjVjOWMtYzQxMC00YzAzLTk5OTEtNWRkMTI5ZWNk\nOTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkWwPVl/yz/hflBis5MFFQjbR\nTZDq/4UmQQh2HsR2EDafkgU0LL70bvHhCoi5Ah402fcTyx8Zcgmi8dB+WnMyX6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1Vp6THboMub062GjDcNh4oSghPEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCnDx+w\nxKd1vxrDhBerxG5jRMQvkHnzKmAOgAsZomfbTwIgOTftPyKA+YneaV6rs+ang4bp\na5N/jn8+XNygSjH1DUM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5064", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5064` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAV5cRRF1aLQqOgDZEZ5QutOTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2N2Y1YmU3LWVmZjctNDA4OC05MjRmLTEzMjNiZWU0MThkZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc0ZTMwMWUtOWYx\nZS00MGUxLTg3MjctMDcyNDNiOWRlODdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcp/mPqTSfhHTEaMABslrcyuUv49EgXiBQAkVGB6MlvmN4xWcAjVRfjqPGcjM\nKXoWhKM7JNfy2msTQyxTxeYDf6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrPCF5zP3+kfshtRIKN0fGPPEBX8wHwYDVR0j\nBBgwFoAUNyd1WjPuNQVu9Mk5GAPl8xRx05QwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiB5kLhNa1HUlvx5W98bkAzS692zC8A6UuciwxYqrx3PFgIhAL8m\nIrr2ucElXfv6/MDbJcNkrPUPARwh5dVBsGA2eg7O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATI2Bhr8RIWbFnXsGAWz5j4DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjdmNWJlNy1lZmY3LTQwODgtOTI0Zi0xMzIzYmVlNDE4ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNgVbhOHC1ZZM27c70BWkmw4JyZIe6OnN+P3U5jZCb5aqu\nn2qHinhzmRZyTUA+wbJu+l9vV6OctoUKRAQZZmpbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNyd1WjPuNQVu9Mk5GAPl8xRx\n05QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGCBnq5piriCb6MK6vBXmJ7j7nN80bp83i/YugsmxZQkCIDBvEqmU53fT\n/VsNRf4Ey6rJcG/4s2mIdvTyyu61TDFS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISARCXxmSTAy60PzpI2MkEqSjVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc0ZTMwMWUtOWYxZS00MGUxLTg3MjctMDcyNDNiOWRlODdkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODU0NzYwMzUtMDRjNS00NzJiLTllZjEtZDZjNTllZTdk\nNGEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo9Pli008AYTPWyhxYIQ6lcoe\nG3RY5uL3Ak08BRPOEUee5B+Acc2hjrIPu/UkihjrToSLDzh8XVcm+1usTycEPKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrPCF5zP3+kfshtRIKN0fGPPEBX8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDRbvHk\ne7Ezx2T4Q0EkXUnCFSQ+oYjiNoSBkjzYYxxU7QIhANJXdh56jq4TK/jaUsBCUBdp\nDuq5F4mrUjQZ60Nu8mfw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5065", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5065` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAUvvDEffujAzZqqKxjtx8+jTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlMjkzZDhmLThmNDctNDc4Yi1iOTc3LTQ5NTQzMGVmODdiNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ2MGM3YTctNmUz\nNC00ZWI5LThjNzUtN2Q0ZWVmM2Y0NzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECmxstwYzoFIX2jxKsldiKO/s6POyZVVJ2McolQCSXt4cyLyAWLc1JpTyE7Rd\nGkeyk1agwj6IzHFg2Eua2Hk9taOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWLM2Hb8EX6qke0DCpUZu6/lNCPgwHwYDVR0j\nBBgwFoAULnalkZHqNzUSJVBmEwVjnE2WmIwwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAhWu/OaDuUNL2\nT8tJuA8UrFrPwv8qJhsxN1rGrYtsRpcCIGAzgdx1mF8MKEBn++Xh+/LE1mneBRkE\nfd7MoBhhjAwD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQXKlARkovjc2Vc8zmkTBKV4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTI5M2Q4Zi04ZjQ3LTQ3OGItYjk3Ny00OTU0MzBlZjg3YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLfxVGmfzYPZJnpm1SmUJQUzfXzSFGWDZGC4PfmoDjCSVP\nR+UYRJQ9p0QIjllsjMScFp4fUqb577fbYNxktuQOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULnalkZHqNzUSJVBmEwVjnE2W\nmIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALx5v5BLg0x3N8tl+dblulfFXIZds5mjMk+dduW6HXBGAiBZCXLjFSHn\n6y++jvdi4JTnVIgADohQHS0lggbYgdYp6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASXHX6EfHoPBqRTZsRKA6ftgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ2MGM3YTctNmUzNC00ZWI5LThjNzUtN2Q0ZWVmM2Y0NzhlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTE3Y2UzN2EtNjBhZS00ODY3LWE5OWItMzU0OGI1ODIw\nNGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4Nny9wV3vGEaOJkJFb7FhAHh\nWmqgzc0aZ2/+RNWffcBITBPzpIYA+9Lpp6HPoKEYDksMvFI6XnGIVvqNDFDEU6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWLM2Hb8EX6qke0DCpUZu6/lNCPgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDVyAjd\nI+vKEJHpMmPsa8KcPHVmWAiwQRDr0J+9cL5s1QIhAP5F0clx2Qz60LpSNFo356pt\nRe9k05W1erQDb24lV8NA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5066", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5066` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAag6Lyy3uF5Eis3TEHKvQd/UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MDY5ODI2LWZhYTUtNDM4My1hMzNjLTQ1NjM3M2ZkNjFjYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmZmNTZlNDktNmVj\nOC00Mjk0LThmMGYtYjAyYTI2OWMyYWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECR8sVqdpvqKwC7a21YI82fmsnsY2vtLhyWK0k6BFD4AaXPVUg5uv0bOK60fG\ny2bM5jt5iNCjzgz4SZr1IvYJR6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQoz2lECeCEadSKMCDmjg+NLwf0UwHwYDVR0j\nBBgwFoAUARa/BPBnrAQby4F00pEsvqyzN3EwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCVsnT/Yq5tVxIIDBsiULe5yh/YfgjntXCCWSRxVS5kPQIhAJv/aw62FFhu\noSMyQCgDQABLlU20+8mZA04jA/NHwY0s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcc7xqcGhRrrEoHdHhJaUdzkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzA2OTgyNi1mYWE1LTQzODMtYTMzYy00NTYzNzNmZDYxY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPp4HGLuPpnq1Opy9jsVkRdJyI9GeHDm/nwgLOBhJxfCjZ\nA5RpqRzmNN9JnXcHDNfPXydyVR+vx0sPWn1bMsv9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUARa/BPBnrAQby4F00pEsvqyz\nN3EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPOiymHkeoz0kzBo5F7uBcH/66R/Ikb5lCAKiYSPtrqUCIB100UGrm0Mk\n2P82MPCVEz+U1AZLEvpPVr9yVQP2kNJ/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAeevvQaKgT+B5IQFq+ezJzudMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmZmNTZlNDktNmVjOC00Mjk0LThmMGYtYjAyYTI2OWMyYWZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTM1MzY3NzctNTY0My00OGExLWJjNzEtOGMxZThlYTA0\nNGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkDltN5NfrYuBYqLXj5MiRqU5\na37ep8LFhaLVblZti5Upqcvlu0tyJjc+xEHbH6jl9dcSsd4ZQctN035RgA6qH6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQoz2lECeCEadSKMCDmjg+NLwf0UwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCqQbLq\nPFHbueCCGtAQfeiKKE+JcHYQ51jA+VTPCmHvowIgSQURQdjmPH9dYIvbEYC0YDSz\nzXsfEwNO2zBPWjhllto=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5067", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5067` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQrjobLi2XELMzjLFXriWRqLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MmZiMWY0LWUzZmEtNDU5NC1hMjAwLTRkZWRmMGMyZjAxZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ1YTFjMjktMDYw\nYi00NGExLTllNmUtM2RlZDFmOGJjNDg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGtWWbCWGmLLLfQZcaRtqTNKm4zlewpHgy/+KiObfWY4LA+jeV9EcUUc5ZLjb\ndDHlsc7e/3s5J7zXFLvOBhO+gqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXEmN6r/pFArWJTfoz9DwM/0zcecwHwYDVR0j\nBBgwFoAU8fyPwKJsFyGAOG1nx7u3xtevvaIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCr4dI53naQwhg1HMs6JA+JWD3KqnJcqvaUjPSb6kzplQIgUOYVqo27Its9\nW1UrDCa+epWAf3G7jFvwaxYDnb8Ow+E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASKpJSKYeGRNpEVXaTAxyJ+WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDJmYjFmNC1lM2ZhLTQ1OTQtYTIwMC00ZGVkZjBjMmYwMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFA3dyGtjYhPZuTLPk2La+dNtaBCR/zC06+40FMRlQTyQl\nIO9hvBjjMoJ2yRmzoBM3OgC0ELmoXa/LO5V51uUco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8fyPwKJsFyGAOG1nx7u3xtev\nvaIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKBJNUcE5gZi5/72413wjTnGBuUGw9WCK4vEGEONw5O1AiA4SmHzzsve\nnjzfkgRm6yQeQ2XWuZhgiFZXEGZxSDPgvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAaQDvUXiZW76VtXteqmDoJepMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ1YTFjMjktMDYwYi00NGExLTllNmUtM2RlZDFmOGJjNDg4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGZjZGVlNWMtNjA5OS00ZWM5LThhOTMtZGQ5NjQ3NTdj\nZTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0f/o41yL6fJyqNwaEnBsVoMa\nplevVLJ79r2iCuuLWC6x/Ma+HZ1aAXiecnDF6vqjFlWUwLg9Qc8mhlXvsqoDqqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXEmN6r/pFArWJTfoz9DwM/0zcecwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQC+WsSg\ny0tB3HCsSjwvbuodhnfA1QYJ5BM8moSzRRAVzgIhAJpUeWlX6FDQeantkGB5/4qL\ncwIrL5WWdd0As4ASBk5t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5068", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5068` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAfn8HD0GXdT7uXDzH0s+dvYTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkNmI3ODE5LWI1MTktNGM2Zi05YzljLTAyYThjZTcxNDQ4MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RkODBhOTItODRk\nMC00YTJhLTgxM2MtNjZkYWExYjA1NmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDgPyxRPBQPdC3YYqcbRrS2IjlKKOevyfmS2MRX0fQFpqaS1rjzLeE92i8+hP\nt3ecnf/2rjd3QdAN6P5pQ5nA26OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiDZSFdb3V/XL3Lbjg4439VJhnQYwHwYDVR0j\nBBgwFoAUeSkLlbFUgNZ+DtKaZE54QAokdWkwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBXLvU1exFzufqFGK6wr3uE3TJLZceWyn7IYv7BIPYs5gIgByJmE9KLv+pi\n6JkclGPMRVGMr1z3m+tX+OWIDMbDoQg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAapTloN0SSdDcR8fgdiuCDWQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDZiNzgxOS1iNTE5LTRjNmYtOWM5Yy0wMmE4Y2U3MTQ0ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6lGyLwMKC0GR88N9y7Yj+tARZYwO/q6zIu/YIoKmbUHR6\nqT2QoWN0MUgJqNcJm6ELspbzZ+PRXbOjUvzhJvKLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeSkLlbFUgNZ+DtKaZE54QAok\ndWkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAQ9He4REeOcCl3EPtnAm3EWN5Zmtmp+EbDbzeJxy2mwCIQD/Ml9q/b03\nhNGNzzb5JQM8cwv/cQb6PswUetuPqQtkVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZbKRtLIKBsHFKYULsigvL4dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RkODBhOTItODRkMC00YTJhLTgxM2MtNjZkYWExYjA1NmIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGJjNmNjNzMtNjQ3OC00YTFmLTg3NTItY2Y1M2EwNzM3\nNGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIrwcIwHlOKU0GjWdcIFo1qJt\nFGoVo3mKWOoX6HOQhdXJz80MwZxXkgBkcg+tfMpGDe2UaehwCdKOwvS0atUxs6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiDZSFdb3V/XL3Lbjg4439VJhnQYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCtwXZ0\nHpm7pu60vCtqOALKjBrEZh1hZBjaw3d+GedATQIgCGBa5EAzrUVFAV72uYL0aUHZ\nFnh7UQrqj5Md+3lkws4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5069", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5069` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQSyo9WdlvRimIl+Wcffnvc/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhMGQ2NTZhLTE0YTUtNDlmMC05NGJjLTcxMTA2NTY2ZTdlNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY4ZjJhMTItZTY4\nNy00ZGYxLWE0ZWYtMjExOWVjM2IzYjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEysNItAd62QJa0FkhwfoILxbcj+7+xXTHJmsjySIQVb64oBXNY0y3KXg59GL7\ndeUn1R1u1jdFL/4ibHIeuhl4WaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNjDAsQi2PeWEO77onM8lsTI/wT4wHwYDVR0j\nBBgwFoAUZ3hX9mArfo8jK4nTpn2zcdre23owQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA16JBuCUwBaT/JfiuHYIGTWHFMSoLAeE9QinXjyyh\nseUCIFJ1Uf72KkTr1Ls8LKPEzyLIXVP8evrx9RJ2ptYMhQxR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAclQizR9g0gUW3viVnfu+CG8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTBkNjU2YS0xNGE1LTQ5ZjAtOTRiYy03MTEwNjU2NmU3ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ30c+6lymXytd4sNxDzPeRKUyiZyeybaRHMlWeYxVW3CIL\nn20VDE3/hjDZGooOy9gIlxyzks7bt90xZvYaq/jbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ3hX9mArfo8jK4nTpn2zcdre\n23owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMjgcEfh0WRvP955kgf1NIFizvfnlAHV/O4GMh+VjeDmAiEAjwdscc/1\nIt6v06YmqQAOne32XQLAYWp+NFEontYyMiw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQMM+FLfPLbQ102wpqNcTv8QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY4ZjJhMTItZTY4Ny00ZGYxLWE0ZWYtMjExOWVjM2IzYjc2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk5YTBmNzEtMzgyMC00MDI5LWI0ZDAtMTc2YmQ3ZGRi\nZDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGppf2hoCXe0483rKQUeP8Z8c\niAg/JMfAlMjP3uO29nRapiKxtBZyJVsBOhN/AJ+iPEMqf9UnnSRdF6fGHPZcfqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNjDAsQi2PeWEO77onM8lsTI/wT4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAOIAWhF\nqFVeBCEYQGq30371QfEzkSmiCdZPC+c+/y0+AiEAhbQDz6vR/JYZhiYnkWHHCNFq\ncN2h/H8AnM3EpFQKzwE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5070", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5070` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAfR2rp3iyV+pd+X4Qi96xvAqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YjM3NGFjLWIzNWUtNGFlOS04NmVmLWJlZjVmMGYxMTNkYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdlZDBhOTAtOTYy\nOS00M2FkLThjZDMtNDEwN2I1ZWE1MmMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElftYh0zjqnTcf601r/qnstmayqX+fYBMY3FPaYHSFlPbRRahVBGjh6wLzTHG\nrx+P9TlRG8pCXP1RvD/6Y5i7d6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaFTRMcU3cjeFBEOj+Rlrd7NZrmUwHwYDVR0j\nBBgwFoAU7pKSL6epsE0tghkGf1JAq02KXggwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA3zpNbcWInwPp1BCRBs/dj1zH+GNf9buq1SxwiIRS\n5ggCIC8uucYDwqhHDwdH7vmK/sGdp8iDZOYN4HsyZKE/HRyC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVexN/dZhYcjT5tpsNHApveOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWIzNzRhYy1iMzVlLTRhZTktODZlZi1iZWY1ZjBmMTEzZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQr6UJ4O67N0C3UbU79I+AiI2RZS+raCkNGGO3J9NVoQbG\nfTq9HzerpHUNiqXM4qULXIMnPfzLjCnjSJSR+UvNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7pKSL6epsE0tghkGf1JAq02K\nXggwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE+XB83G/sZMlBreLkhXQ/5YKtg3/8ud1Qdtx4axZKNMCIDQk5dZkTR3t\ndz9v49X9FFBb7pBMs5oxcgLIGJynA35M\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXlsD8c0h3bFBoUmWX6bIQLfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdlZDBhOTAtOTYyOS00M2FkLThjZDMtNDEwN2I1ZWE1MmMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWI4ODBhMzctNjhlMC00N2I1LThlMGQtZjBlMDk0NmQx\nYmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE129YU2aMMM2eD0RZeVZBMiIS\ncpS41xDtgCJzZGd4QUrg95lUyKTgveNG36wTpBmuVG0uVA+BSP5Mcdw6l4tsnqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaFTRMcU3cjeFBEOj+Rlrd7NZrmUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCPkFmW\nU8hn6KQBmOLohUjO50wTj1w9ABBmPJWVMcsS8AIgDqa3wmS95pxBWEeLWGNLhSmK\n0tO7sCHhvJvjLSKi/cI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5071", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5071` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAUrnwjgF1kJCNcr9Lpfry6yfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYWIxM2Q5LTUxMDItNDZjOC1iN2MyLWEzN2UxOTFiMjU4OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVjZDM1Y2ItOWRl\nNC00MWQ4LTk5MGQtZTE1MTgwMzZjM2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp09vgWa1D6LHHHj4Xd673v4v2RrF9mPjlZ4FpW6Ash7qrHJQLpu7I068ujPk\nikTnsNK1LXCEpB4IY+MEXhDB1qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXsJH5rIrzHkGpdBqbvtoGmfc5o8wHwYDVR0j\nBBgwFoAUeAEHEiDhi40yyL7kB+5ZraUoP7QwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAgyeKE81c7qHd7bAd8KCVi9rIVrDwwxChI7MWDanAVCkCIQC7\nBJ7RuxX9u4mViI3eDWGasjYwD4HIOMRoB7Ypf7Kf9A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX6iF9HaUpIUIo6PyeHfotDjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGFiMTNkOS01MTAyLTQ2YzgtYjdjMi1hMzdlMTkxYjI1ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYHScbYhB0IsCp42Jr4YjekA9SOsSdFeh7OdCrH1x5kr4j\nnBiKqHFlfLzIoJ4MFV+bWaKq5mWK8oKKpyIVyP6ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeAEHEiDhi40yyL7kB+5ZraUo\nP7QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU4382oEZRleFR1tCXrxwU+We+HNGFCNC5JmsFev26+sCIGMfCLbBlBVm\ntHxXPQgSJb0dYEgyXaSV0yFq8ZrHFTX5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZ+Lwmr5jMGEbGMKqQWc5POPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVjZDM1Y2ItOWRlNC00MWQ4LTk5MGQtZTE1MTgwMzZjM2YzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODM0OTExYjgtZDY0ZS00MmM3LTg1YjYtOTA3NDQwODgz\nYjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC99B0SZvcsGYTnsZuNPOthi6\nzzbwKoOrqCVuFz1h6PB/8Jj5Xfo7Mafjx/GyP99htL2jwMJlq3HLxflEpNi4yaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXsJH5rIrzHkGpdBqbvtoGmfc5o8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDAe5j0\n2HZGGWXYyJAt3wzWTPt8LUX1L83KXxsoo1YSRwIgEwSfgm2cUFNdh5Wfn+ZOZ4t0\n0hsOR93MFfh2A0WZWDM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5072", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5072` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAdU/JPRMmaqjQBxHXloZcTL5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3ZTVlOWQwLWQ1YjItNGU5MC1hN2NiLTZmMzU1NmY0ZTJiNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg0YmI5NzItOWE5\nNi00MTg3LTk2NWYtMTBjNTM1NmM1N2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWYCbO+GHEbecsdKAHVlimjs5pFamSSdTFWI9kz300UKXGre4Vyf2ZH0HHP2t\nm5VN90OlZdaEzGzRxht6f51VPKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv3WjMU6aXonq44EMKcbWFcDWrgEwHwYDVR0j\nBBgwFoAUoXaDND0GeJ5JU1C12BxEe77WRbQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAlp4Es//jO5lwRNMnDiIM5EIqEQu/AKDM\nXY/FYyuuxv0CIQCAn+R7/qjZSpfuv3HvLLhbmp0vzrauPNnrH7qc0tLQNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVXoJpVlMbwITPZKZdptuMoIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2U1ZTlkMC1kNWIyLTRlOTAtYTdjYi02ZjM1NTZmNGUyYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy3K8PnKemjxhiGA8reSZal4Bsrnb4kOqXqVnfwrweaEhY\nKpQqpX5TeI7RQnkcYpBJfkWT5dcJxEFrGu2UkUkyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoXaDND0GeJ5JU1C12BxEe77W\nRbQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPPpUJ8P9Apa1nCYHmKn0pU4e6JTch6oA5vm1oMcqIPDAiEAw5d+CShs\n9bUDEvnSZmxMcRLrqZ0VVvDDDIdBg1/hklo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARp/esehoM0wUc0lTSp+OJEnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg0YmI5NzItOWE5Ni00MTg3LTk2NWYtMTBjNTM1NmM1N2Y1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGI5MmZlZTgtMGRlMi00MTc0LWJhZjctOTJlYjdjZTUx\nMDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2HNV5IGZjoDqtGndkq9nDgf5\n7aMrkYiUCP5ceaWGlEQ9n8sLWyaBUZ5MC2hLWAHx2VPBpUvV6NF/OSE1UO52iaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUv3WjMU6aXonq44EMKcbWFcDWrgEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIF+JnJlp\n0APB16R1YGHxd1afZdrXQrwiQCKZMe1WHzHgAiEA4Ua7jcua0EC/Q+EAhJSh5Aj6\nqx3gO6yJ5nBN1jBgwks=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5073", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5073` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAatAAEetK5FWVbbwm//LGX4ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyNWNiMDM5LTIxZmItNGVjMS05YmZmLWI3YTJhZWQ1MGUxNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVjM2VjOGYtYzU0\nYS00MmQ5LTkwZTItMzI0Y2Q0MDJkMmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmeIKnPoIeIjs2zLLwvc/v1rXutQaanUQ12zpvQf96yr2rto7kv+UoqnT/taT\nXSpJsmuazUhSN4N+YGPebkjxRKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3JbiipynauEQ6pwIKpNZE0XEqCgwHwYDVR0j\nBBgwFoAU7ecM+AJk97d9kPdPpm5ABC9X/wkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAloYulu5XCyJ4GdWtJM1tzoegqYMEVHoe\nCMSuHcXjaeACIHQ0vy7DYFaNpEZ5kLTCVn/QxVc4tpn03PpPYXleUf0n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARrKav7Rfou4ryLE0f526BgsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjVjYjAzOS0yMWZiLTRlYzEtOWJmZi1iN2EyYWVkNTBlMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq5gK0ENqyENLlXgC9Wci4k9HBRQzOQhNI4bO2GbMCFqYB\n2axCm3cIYpXjqzstOY9VQIpOeEz0onftlEf0MwdZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ecM+AJk97d9kPdPpm5ABC9X\n/wkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOPTHzL04SvmBLnbrvjyKR7XZUXdMm/yIkU6rHcQUi1AAiAEAfh5IElT\n32/Nra8r0wbHOTw6NOgeKkWputWJ61KlYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAXqSmrYeBZJORQE+sh72WrbMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVjM2VjOGYtYzU0YS00MmQ5LTkwZTItMzI0Y2Q0MDJkMmFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDhiOTJjMzYtNDRmNC00NTFjLTljODItNjM3ZGQ4ZTZk\nNDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEomvrODnZSiDEEbnoMOjQWauU\nb00cHhkjPVGKruO2mhaV0n2PrSlWqjcDxj2bslovKSN1x4VJfMZdbz9zbPU686N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3JbiipynauEQ6pwIKpNZE0XEqCgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDEv+j3\nQtoEah4zjZjCD3kr/droRSnBGqygGIyZKt5SzAIhAOXEqHlB2xLI0OAxea2Z39Vo\n8fGAvpzdSmT12mIbL+VY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5074", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5074` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISASklovQ7nLnCQI1XLXBfCPnBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkZTJlNzg3LWEzZGEtNDE4OC04MzI2LWJjNzc3MGY2MmFkYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTAwYjkyMmItMGQy\nNy00ZThhLThhNDctNGE3OTllNTU4NTk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEybaruYeehw0icaCe3QdmfADQa1ldh3dUWHQ/vB0DgyCqPoKga288TqSVt5RJ\nQ+ujcxOTv3BwS6vaUzYS6wbiS6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTjC/JaYLId/LZPm0EEqLa4vbG3swHwYDVR0j\nBBgwFoAUnNpUn1HRRvtLqUZPuDwfX+ySkcgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA/CVFlN2T5hkK\nQyoTjNNGdAjl+SkAJRhw1s5u0GzQeXUCIQD6pPy9QHe5QLpfrrqReZY82VzHKyS5\ny6R/AFHStA01YQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARH7zx0WBxpR4wrVPmPaNkv1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGUyZTc4Ny1hM2RhLTQxODgtODMyNi1iYzc3NzBmNjJhZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTuCyFErwyEN9xiA5RcUgoAvlWCsbgSD6+ug7rJWhrMPQU\nWazXzVv8DfiesYjhfzKeiCE+aJLE5fo7nN6DUkmOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnNpUn1HRRvtLqUZPuDwfX+yS\nkcgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJTu6ojfUiUTmpL2O8AUhUPDQbF2zs9/qom40yweNkD/AiBrgfUqZjrK\n4fyuN5o/wbmSpP3HOvpm+NvTwSLaWA7kUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVucDMTh3njXfQcbsH+Mr7kaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTAwYjkyMmItMGQyNy00ZThhLThhNDctNGE3OTllNTU4NTk5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGYzNGYwYjctZTAwYi00YjcyLWFkY2YtMGFhM2RlN2Vj\nNTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr4KYeG+I/gAPAWqd4hdfdFot\nMUqmuH7oDSZ6xLvK+fm91uHJHkllqXyIvoIQIQZIr7mUK4DZ5Kokwt6IT2OqHqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTjC/JaYLId/LZPm0EEqLa4vbG3swIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIEMICEl7\nix4a7Fydai2NI93+BPLeGKO5GLcOuZWrzPE3AiEA2R/9Tmh79qlIZJNpNXYaNMoM\nrwEy+zl1mthY7wr0dnw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5075", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5075` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWbOHgBAiiDnkDrMmyZ0BXdTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiMDZlZDMyLTY1MTYtNGRiMS05NGQ0LTcwYzA3Y2E2ZGM2NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBjOTlkNjktZDlh\nZC00M2NmLWFlNmUtMjhhZDhkYzRlNWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3f/wb5o0AmeKxVQPIKPQ7sz7jyNNVSPCcKPT/L5ds65RnwsbcyQcf1j2b7/E\nBPT6+G6oJ7S8lCqdG/gtdToBDaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzUog4CAIDmltVKumaUXfVixe2HcwHwYDVR0j\nBBgwFoAU/3DAfgc2XWRHd2FmgzGwb65stDYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDjhCTlEqIce9lqGL/TsUrb1XYAO8/AiFbLQSIfDg/geQIgZMStg9Verk4s\nXxhAD7m7MSc2kxXTO2QA5+syD7TX6vA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX27ocajAC30ZCV43isiRfomMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjA2ZWQzMi02NTE2LTRkYjEtOTRkNC03MGMwN2NhNmRjNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxjoFw5MtA7mM2AKI9pRCb9Ata2+mGxkEbadt0NHE1VPUc\n6Lo21TSQRGrz4UMCi/UG6LOhjC7VKsOYF4aPsi4Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/3DAfgc2XWRHd2FmgzGwb65s\ntDYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGjYgdrUEVTUqZom160z2kJaO97V0D6tWGgoAxuuhJUUCIQDX+jb6rKQN\nD8cRggJJHKg2PmzdogP/xkuSpP041fwa0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATsM++pwAjP2X9KCYFLvmZsCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBjOTlkNjktZDlhZC00M2NmLWFlNmUtMjhhZDhkYzRlNWE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGIzYmNmNDEtNDdlNi00ZjAxLWJjYzQtYjYwMWQ4NzQx\nMTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZkOc43/lFN3e7WO7zxVj4Dsn\nvmXag4bBqE0QERmkBgNMl1LtUW2Ak8PHNfOda43fZRbQKSn/udsOpKra892BraN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzUog4CAIDmltVKumaUXfVixe2HcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCsjpp+\n8fvfNJjl/t4NBQJpK9obhNVjAYBzeVSgDlQnagIgF9K3tAsvMrtIw0hikyP9nyZc\nAyVetc2P5PQ+V1MbgUo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5076", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5076` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbxul6ix2HxuIZimQbp0D38+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4ZGJlNzhhLTU2ODItNGQ4OS05YmJmLTM3MTlhNjUxNmE3YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFlY2ZhNzktYTAx\nNy00NzRiLThjM2EtODQ5OTdkZGEwM2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPKRNXrvbvpc/e5aRAdxGNiRcOjYh36jgDryhfSuuv2Bi76sUx7hVhCuMJXhd\nPdzMmV0gf0slm5id/SPb72HbhKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcgzAB7Jn8iJLjpFWJ7M0TG+XNGswHwYDVR0j\nBBgwFoAUP2g3XLoetU8WwIJTe5eABUf9dlowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDdx8pLiWLA3AzPDOV7LBiE6r6yCR+ziZouijHRJOjGxwIgVzqI8APIMoY4\n9zRaVN2zC1QT1Qn6dIyrZM6Ght/BqZU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXTLTvqdreHjUTDkRWNMncZwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGRiZTc4YS01NjgyLTRkODktOWJiZi0zNzE5YTY1MTZhN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPmoDmutcOv4+usBa7gKoTh6Q+W0hZsEzs3a6MzgJQfu0n\nRt3N/tNXiiVkxfb2NkjKrG+5FYw3UCjRFVFDKFW9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP2g3XLoetU8WwIJTe5eABUf9\ndlowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ4LI540wCQACliMO7+cvxSgJTNPI0NDq91Z/cbXkAczAiEA+QdJfBl7\nJS24I56igwBHVZdd0ghZxMPO9cw93D8Xqqs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdXQ0PU5LPR4IJS9kGUos5KJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFlY2ZhNzktYTAxNy00NzRiLThjM2EtODQ5OTdkZGEwM2RkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWZhOWYwY2ItMWIwNy00NzdiLTg1MjctNGNhY2ViN2Zh\nYjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwa3NITtr/G2rdkkT3yFI5kog\nphl9c6OxTzX63YjtLSlzH6FjsodSR5m/L5WxC/Bhr4CEu8T16tRcKBrNjZdJrKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcgzAB7Jn8iJLjpFWJ7M0TG+XNGswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHxAAREy\nBWrQMzUdxbEYMxdEjjYuDrQYStWoTRU044zKAiEAyqgLcUpMvU/Ugbwrusc4+7od\nTrdUt9x3hDTXX0xSpwo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5077", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5077` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAV4iqjvNAKyc25DIDrCOGXmFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyZDdmZGQwLTg2YmYtNDZmZS05MjNkLTUyMGYwYmU3MmIxNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I2ZDM3ZjEtNGUx\nMi00MGM3LWI4Y2MtNjY2MTM0YWI4ZGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs269a3JYDrLutwE0ZE1f5v/u5fb379QqN3M29/jLLBpU/EeyS0hfEK/c6o0f\n5aCHNNMj7Hi3tq8StrMQ/pGgTqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUduEKicfiLBxolY2TCc3AHgA3UiswHwYDVR0j\nBBgwFoAUxXZEz6DthIHvXWXfF6Xvj6zbwR8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA32g7SmDyWW+ta5vUhg0uj5xSChx8QkI0+FLseY0cnVkCIQDdKG5HWRkN\no+cASV3Suct1NS/b3vPN/O1krOhj3qXpgw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWwoeKJplakKHgM9VKLDmQr9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmQ3ZmRkMC04NmJmLTQ2ZmUtOTIzZC01MjBmMGJlNzJiMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASS4/4uU+MpN8uO7junOz0lcWJ+7Y35PthsDcRYNMEtsFn8\nMgdP2sOGjAJMUqGJ3M1BZU68xqrSi23zqEg95Mb2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxXZEz6DthIHvXWXfF6Xvj6zb\nwR8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ+WmRVcz+jIFqNNiCysVEwjeSHjl+vz13G25yrBSt4cCICTGg8y5WPDf\nlLHveCLepMMrMERo8JZOgkxJq1vcs3Cc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAR3rYlkaRv21BhUOFPZ7BriUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I2ZDM3ZjEtNGUxMi00MGM3LWI4Y2MtNjY2MTM0YWI4ZGVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjk3ODcyNWMtOGM5OS00OWFlLWI5M2MtMWQ2NzBhZmQ2\nMTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBymm7LAd/JVK6PCgTfM5vjcx\nJfx5GVTUFV/kSTiripq7J9+acLMsvY/3s+xdx33QCNS3Zhsswi+tAYaJcw1cZqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUduEKicfiLBxolY2TCc3AHgA3UiswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCXaLQb\ntohjqe49QXLA700xKYzdMVPKSPTgafM3aPcbEwIgZUPAyVu7yrtESzwwriCILt/7\nK5UaBIj4rVZAjCUQHvw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5078", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5078` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAaHk57IMW68I0fNJffCr7PzIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2YTM3NDAzLTA4OWMtNDJhMi04ZDQwLTNhNTJmNWI5M2JhMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA5ZGRlMGItODRk\nNi00MDM5LTkyZjAtNDEwNDMzZjBjNDU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQG+ALf3q/CXw1w8AuNcHqjUMCfJQOpsnILe8UUilUnSt/L2/lY4wdsWPo+6A\nZ4DrtulRN0Zx7q0paoBqlqDL7aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIh6Qil0g0r/17tdNhODTC0XuIxAwHwYDVR0j\nBBgwFoAUTLJWCWpXrNU4tZHiV5vwgkPdp/YwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAyJ0kGka0S9E2D5TbycPbm3sXSOYugqcQrFLJYDec\nSp4CIBT2BIesBfANM24haIOBUTTNici7+xDmwvu+bWi792iQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfxBeN8BABupICg4c5ZlDLJ3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmEzNzQwMy0wODljLTQyYTItOGQ0MC0zYTUyZjViOTNiYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1TnduVy4+TEt6cHnAX/eo0kK7jITuhMNQ717MmHme+ZOD\npz/tmbPEd0dR4ezFxWK+FmkXrSTHRnAc4hbjN8Aeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTLJWCWpXrNU4tZHiV5vwgkPd\np/YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMDV6vKmFn8zj+68Hz4CIGyxbNONg8/V25njZZYUCdGEAiEAo00Gwm7e\nYrD5oX4dkScGdQzRghQ49xefb4YQuHnHmPU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASmB48iZM7LELQRC7/DyTg9EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA5ZGRlMGItODRkNi00MDM5LTkyZjAtNDEwNDMzZjBjNDU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODE1OGE4ZGMtZWIxNS00MWVmLThjZmItMTA3NWJlNTA4\nOTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaKa0YbIgBMFG1++tzTUJuQMf\noZfnk37hO8Mz9WS5jJdXS//31ZHlAnDDpO4UitbamRE0xjP6Cvf+Gtfalq5fb6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIh6Qil0g0r/17tdNhODTC0XuIxAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHHC6G8y\ntrpDnjh66ByB1YcYeeTgkQfSo8q+TJjsSVLqAiEA0nyDhLeMXVrGcFkPx8HViFSw\nrmXtbL9KYgSLCaQ7uHo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5079", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5079` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVUCND0eejFTDTuHPcRoKVScMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMmEyODNjLTAzOTMtNGIyYS1hNDk2LTBlZGE3ZDBiMThlZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJkYjE1OTMtZjZk\nNy00MGE1LWJlNTctNmIzZWI2Njc2OWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA9qlc+K5M5ZRIPvDQs3Zzxmi17GytHSoXtAxuzaObUDTEE6JouQVDOc6txDk\n5qbLK+0Vy05LT1KTaTl/UOj6YaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWd5+d40DLkjinJ6POCcgxXpRBuEwHwYDVR0j\nBBgwFoAUWvlpR9biEdK+x7taP2edP5XbIb4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiB8KfjcLspBYuMjgTAGnXFzPhYZuoG/uUBjy5emp4N2\nwgIhAPrXQDHAPQHT9r0fVfSYhe61N2F9l9CKeNot3U9vfFaX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYOIFhpp20p3UNey81tN8LxWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjJhMjgzYy0wMzkzLTRiMmEtYTQ5Ni0wZWRhN2QwYjE4ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhFfaPUztMJanCBqF3FBnybQZHH9jMRftHAG5Ksb/uGzNy\nwVLZM4w53BcXGl81cXmrJ9qfJGqaclyBkU9qd4pzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWvlpR9biEdK+x7taP2edP5Xb\nIb4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRmvTE2Ql1+4idgCk13yFZRYDecYFVkWQXP8t07GCKlsCIQCS0aukE/xN\ns8UCv1IACvoXdqZ5Ig6JenvQuut7tibMDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAdYj5d9Va9ZUjUPd4Zsx11rRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJkYjE1OTMtZjZkNy00MGE1LWJlNTctNmIzZWI2Njc2OWNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzdiYzA5ZGMtY2QzNy00YWQwLWI5OTQtNzcyNjlmOTNj\nODZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0VFATCVct3emTV2LbcbxbWcs\n4PiWDoCzMQrUggJozvM9yXwSdAkFN5PyOx7US3BSWaxSkKvqM9vhyEpLdy7KDqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWd5+d40DLkjinJ6POCcgxXpRBuEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIFjR0Ccm\nEJin3YJ/rNy3Rk27qn9JDJ4L5IrKDw0leRXBAiAxYNGXDkHesHo4rlvRwb41A4qN\nUnG+FdTe9lkIoPS56w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5080", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5080` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWM7eGTScekyDtVOF52AorgkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMTliZmE1LTRhZGMtNGI4MC1iOGNiLTE5ZWJhMTUzZGU2NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc1ZjNlODYtZTNl\nMy00NWFlLTk5NzYtNmJjYzYzOGE5YjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5m/pydDxnWCDpYq5P4rTVKdQNOsyTk9Q6tZbo45CkPUXnmfo65FEs9tAWREe\nYforMy4vNJsBV/C1ol/BK+RG76OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw4XgHlxj9zCA/oejZMLJLBOEovkwHwYDVR0j\nBBgwFoAUZk7OnQQL3+BA3BpwDukARvlTGlUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA6VG8eYlMwPfdrpiatLFu4n4OXJhkvDxm733OJBQ+DBICIAU0\nxmQjU2KbFrDKarKAl/5BlKUqWiZgKT5YZPUY8Y0O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ75dKzGcTC+tdmRfpt9BiMfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzE5YmZhNS00YWRjLTRiODAtYjhjYi0xOWViYTE1M2RlNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOGG1rOHGxWXfu2mO5ZKjPBBkSf0yq3AuUvGeNdV5+ciAh\noGgiBTxNSWxCQ+29gTYJyr76vZHnJvUdgatyOIOgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZk7OnQQL3+BA3BpwDukARvlT\nGlUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOlLdPCt1mmpuyu6WHSZ5QfVbQ1JZkHudmpbpkTAOpKwCIQDgQY6y+e8Q\n7AFCiOARzt7nD+HHdTKyf/dHeccluuAxEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUx5UfSe2RnPF1eHFrD4J0hGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc1ZjNlODYtZTNlMy00NWFlLTk5NzYtNmJjYzYzOGE5YjlmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzI3ZmUwODgtOTZlYS00OWY2LWE2ZGUtYWY4YmIzYmU5\nNDAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7B3zqYPpHWhFPz8AqXMua0Ss\norqeicLp/5BsC3+CUB+VAdZSBa1JcVMNZQdx5CbMy7Q+jRFijzFcuvtlZUM7oaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUw4XgHlxj9zCA/oejZMLJLBOEovkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDJjbMQ\ncZermPvRyQpVaVOSIcu7J3txZOSyZXEcRu7ECwIhAPA8AcfYwIhu+naaJ4Jbccct\n+rTuEbj0dwgAXB8Hu6qH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5081", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5081` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISATdfEbEzUiVeTH9TFpaLWDeBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5OTEwMTY1LWU2NmQtNDYxZS05NGZjLWEwZDM5NGY4ZTExMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjAzYTAzNDYtYWFl\nYS00MjY4LTk4NzItNThiZDYyNTYwZmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBfTF8MUmuMdZu+IE0tmvh3ipTA47i0bxHEDr/ZWzgXJZ45lZZSZr1QIIxFaN\nZl6sfxfCjaagEd73s0NPSJ3BFqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDigssyq1Df4kjCT3zSgveABDKXkwHwYDVR0j\nBBgwFoAUjlGHvzRuiKGvC3mMClmt8u5NFb0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBxmrZYvs2L2lzUOXLvB/AjYweyBuXXASPm\nZeLrPHE/rwIhANBXBcfE6AvhW7hC6PnSUHFEmpilnISd9BQY4wImYoZH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX5H8TfM428zcbawVaozgPs3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTkxMDE2NS1lNjZkLTQ2MWUtOTRmYy1hMGQzOTRmOGUxMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXGCzqfvoCAZGvRlGaE1TyIkQd0TWt6CSZvuSTceq96odd\nxdY5+HUapghzyCp+OMCaMi5xaW0/sK+n++AOAorCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjlGHvzRuiKGvC3mMClmt8u5N\nFb0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPjiiUeuy5dN9evPtkx8Hqaz1AccJPRN4bmI1WegfTejAiEAv9t7/8Ij\nhsf1LzLgIbFqfEGAvazVAg9XIiyOnE82EWY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAbkwAC2blJOgrTwSnqKgCHqIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjAzYTAzNDYtYWFlYS00MjY4LTk4NzItNThiZDYyNTYwZmE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDkwZTgzZjctNTc3NC00ZTNlLThlMjAtM2U3MjE5Y2U4\nMTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/KHt4fwAuRp3fo5qzOjsp/nQ\nC0+fS7GLJ2lAq12kRXdkPWbxzk0ASz2saGMfLxK1ulend0K8pT0twk0LPH4grqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDigssyq1Df4kjCT3zSgveABDKXkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHWGYnu8\ntciali3mBjkWadXm9IVD6WudNHofD4hobLn4AiAJjDHmsa9eQZqpvdQvkD+k1T7x\ncBVvWERgVI1eakuWUA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5082", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5082` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAVIZM8pIrjDaXP6y4d4WwVl1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0YjNjNzkwLTRiY2ItNGY3NC05YTRhLTM0ZWU4YjMwMjgxMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkyZjBkMDEtMTgw\nZS00OTZjLTg1MjEtYWI0MjhiNjc1N2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx8ZcmVFhuqmroEhLHsDJPCb79Ngk/gYmBZY9QP0qH9TG//Ekz90N3essG+tD\nBx29Gdwf6vmV4+t72WHhUt+0TaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURm7tsGtfjjZVzS6PzfuieNDHOdUwHwYDVR0j\nBBgwFoAUQce9QBnVIfcbGeEX5SzLef9t1IgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB4WXpZPAM7cA8pRCZAb8dHzMdJpWecbAfX\nFewjiHqBGwIgRrwn7N5L/lCzsf5JQ3TkveoM51UIRsUSda4lqq9v0kc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdyrBzVaI7KOIEY5N5NhTVQzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGIzYzc5MC00YmNiLTRmNzQtOWE0YS0zNGVlOGIzMDI4MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASE52jhq1hyaMau+bl+tCBerGlAQ3D3aeckqhnFtGu1RO8o\nrtp799AdkXNWDBr6qsh1lOpg5pXTZE6iks02+MYko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQce9QBnVIfcbGeEX5SzLef9t\n1IgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK+G2HH18uFAlunKOnU3x7TjFNEZ0NeH+VfsRE/A5ivvAiBTv3LCIuEI\nfH+e1b0XpGMOYDdYPxKeRjuLoxHBfrdQXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAR7TlONxPbPeGGaNL6ZudJ/lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkyZjBkMDEtMTgwZS00OTZjLTg1MjEtYWI0MjhiNjc1N2EwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2E5OGFlYTctZjQzYS00ZTNjLTk2ZjktOTQ2OTRlMmQz\nYjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETt5G+XTeBIA7afsKwzH4EYd/\nWgEw6Ap1Go14DJ7WcSmcd6oP3nUjwegRmMzdlwgVDiFHYExlgPjuTSCThq0PyKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURm7tsGtfjjZVzS6PzfuieNDHOdUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDt0kz7\njC9HuBkwf4oUwGE/YXMsL7JghxMVkw+kmXUtIwIgHn2qmusNaCF/7WY7WPlNtB6o\nnxG2/5wJWwDauJWPCy4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5083", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5083` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAefN2bRXiDbcYFkOk9Aym5A0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2MGI5YTI5LTY0YmEtNDY1OC1hZjJlLWE1YjMyNDdmZmRmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJiMzk2YTEtYTRk\nNS00MDFiLThiYzYtMjlmNmE4MjAyYzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOHiXRN6Q9klfO9ujVnrgI6xSp9RyiQmh96aRtZq5DTPEmJaFwp3kEL5F/SlW\nvg6j9LXyLzxyIS9B/LkTcR9SZ6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsgRf4dn40qY/ekhRGKn45pkqn04wHwYDVR0j\nBBgwFoAULKim49/n2W4bGdIGx7tjI/SD1KMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDE9+y4Y/SUJ4JEM3xxjtV74bX8\n3UEOdUW9eNHWxJ1VuQIgZNNWcUzARDH/LaYMvbWvPL5bSeH7e7iWHZelevGV76Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQyva4+OJ5tv6M4ioSY8lqj8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjBiOWEyOS02NGJhLTQ2NTgtYWYyZS1hNWIzMjQ3ZmZkZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAd42oTt5t69gEw1h0Zk5Ocx1doVhGKYxJEfUeWJ3paUgr\nPVe/gOKhGGPxuJsCOdqFi5LsEQNmX8+fFfkYrdoGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULKim49/n2W4bGdIGx7tjI/SD\n1KMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOJ/hqhW7vtbxcGyXIFDdx5bWGAohm4vzbMCSJA71yaIAiEAgzsL8laK\nI1P1/8IM3YTpnIqNl3voQ+G2EZJO/tGH/aU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdThgIp90Up8HUsvSKb88AFuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJiMzk2YTEtYTRkNS00MDFiLThiYzYtMjlmNmE4MjAyYzVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQwYTMxZmMtNDlkMS00OGJlLWE4ZWQtNTBiNzI2M2Nm\nZGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6iospvQJcf46xk6nlVXxUcmb\nQGjzlb0x0gNk+5p+NXa6CyiOYx1EOICaSBwAoSh11o5XsfQfSRF1Bus4y6ZF5qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsgRf4dn40qY/ekhRGKn45pkqn04wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDwg7Yr\nANlXh0FFGNpP60qcwZgn0nZICKTvc8ITTap8dgIgQOmyL2e/kxJ3kAfoPkN/UbNg\nU7AFWwpuUxI05FRY9pA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5084", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5084` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAdBEdm20eqQGlBrqWBQ6f354MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlOGVlZDIwLTQxZTItNDEwZi1iNWExLTVjZDI2YjgyMWRmMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJjZDRmYzEtZDUx\nNC00ODg5LThjODMtOGY4YmMwNDYxN2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQyswq54YLskFZ/9vnPJesJJjulOsft77vXLbLw9DHhy/sYEQSjPIyF8Vb1Ih\nfUXv/uX4JiGEo4xQj+lS4TDga6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkitv6LN/x+lXI4+io86nECgo4M0wHwYDVR0j\nBBgwFoAUMImtPrHS89GRmExuXjzIP4UYw0MwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAK3LTQdl\noH6o1ue0xmSUpEfSHjVIQL4hrNzD1iPG6cijAiEA8CfQ9T4WWvLHEBLT/nCqw+TS\nNG8HVFCIND3C57Ec70A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUrfvxB2RUpX3jSeGiJqquz5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZThlZWQyMC00MWUyLTQxMGYtYjVhMS01Y2QyNmI4MjFkZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFr8olI/85Tz+YyyV3f2v0V6TRYWwWMHS2gynkZPy7xnLp\neHfnDGN1AiqkLJtDgUq3ovqwv7ernsbdUYmNRnBMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMImtPrHS89GRmExuXjzIP4UY\nw0MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKAzBaQvRAoUGMpoLmNOg72Fyoah6XW16g0YfXzeq+mwAiAgM25F5vFk\nfRPFrhEjokHpfXNY17UrbDmJpJmM2WO3mA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAcsJB3NLbBj7uIG7BoNVZ5mAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJjZDRmYzEtZDUxNC00ODg5LThjODMtOGY4YmMwNDYxN2VhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTIxOWUyM2ItMWUxZi00YTIyLWE1MGQtZDAwYjg5Y2Jl\nMTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEe2pukhZ9w4LkVkkNOh4onqLI\n6/aAPj+NatzPd7i9ehnc07XC6INR0N99iKkORU5uI+tyBn2p14ccyVUV1hiGTqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkitv6LN/x+lXI4+io86nECgo4M0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAviPBIh\niXm7p3yEVOK+k0eQEx8npN/Hh1YMWHDf7TM0AiAnOsv2XSXM8W9MGYq+gpzh6RuT\ncD24geuHCIFFL7Yhtw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5085", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5085` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAROn+uo6J8xvbZjLW4Kuah3PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjZTJlNjA4LTBhOGItNDAwMi04NzI1LTNjZjFmNmE5MTMxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY1ZWQxZTktYzBm\nZS00MWExLTk2OTgtNjZkMmYzMGRjOWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2DB45CNgnecIcq+Sm2KmSvD4pmvoEb3y2kUQSZ4iFKTIr7BhZrnMf3YymRZ7\nPooLaLdtnlncplpPJ8Ia1/vH66OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn3NVuJBJIIltps20OspW5SNNxKQwHwYDVR0j\nBBgwFoAUa1KNbrnrQxLHMu22kT3sA6Xc9OswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJyoch69\nZwr/A8YnVP85ym2Roq8OeDBNCW6Q5FVcCM8PAiEA+RUo5humSmxzY3QWkLmJI1yr\nZJe4j9Hd2But0fTCzCk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARfbTk5QHWETQ38jxkM014X7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2UyZTYwOC0wYThiLTQwMDItODcyNS0zY2YxZjZhOTEzMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDI5jmR/Bilf7/fWPBskOTbPG8R6TplrgHUloVQUnpp0R0\nH6DipetuE9+aNBhYR8SLBxK3xIlxNdGBfjwtdOHGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa1KNbrnrQxLHMu22kT3sA6Xc\n9OswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMuH0NBGvW6k88li/rZw35+4nb32LJ1ab5xVdFouI7QbAiAL3g0eltl8\nzstb+YOPR15jb/+Y5ohTVXWDYe8kX6q8hQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATT3dYV7fPzjGKSOfzVhPbCDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY1ZWQxZTktYzBmZS00MWExLTk2OTgtNjZkMmYzMGRjOWM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2MyMmZmNmMtNTlhYy00MzcwLWFkNDYtYzVlMjMwYjU2\nNjEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEptHfZrHIV5JHXm/agoWrQN8m\nK0Aq9a/bu7AMoX4Is8OWX22SmMzIvZJpTwjNt5wBwm11wnNtfh/7JScoqsSrfKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn3NVuJBJIIltps20OspW5SNNxKQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCID/pdTFz\nRccs9O5zAjNFvK4E2a1ggfIjbklwKngqDkd3AiEAwzIaSwRgLXlFZJi5qTAHYJIK\n1eK4//b+CAXnFSwzqTs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5086", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5086` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAbUNQeXzNXpCw9al7DxUo5rZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmZTE5MGVmLTU0NTUtNDZmOS1hODM2LTUyM2JhYzQ4NjQ0ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI2OTQ3ZGEtNGQx\nYS00MWEyLWJmNTktYTExODA0MmM4OTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqvUB/zZdibTy4zMcMeBFPFOH7u4RrI25LXh73ivilFyjFFEKjkTyGyda4MhW\n13JG5IVnFYj8PtTMlaGZv6FcqqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfA36WTQlTbBXQ7gx8D3CQ37+zCkwHwYDVR0j\nBBgwFoAUBFJWvWToYufr4LjFhZp1zUuuFjowLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEQK1OcA\nZVWa4Vpb+zNaRpyou4MMDxnckPxnniP1KYxbAiEA579mgPcva6pRPRqbRj5s6CP/\nUbFAU7V8KofuaMzL9J4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV7QUYpDGpmPQExyz8yIrwMnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZmUxOTBlZi01NDU1LTQ2ZjktYTgzNi01MjNiYWM0ODY0NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlFzsFM8QnoigV2bMV+FODToPJe5CQCVM36zQjz1ln6lf9\nBT46h6zUeJpL6p4A7cHpq2leqIWPbkEOrEYpUccmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBFJWvWToYufr4LjFhZp1zUuu\nFjowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHAU8/BoQcfKjYRhsGmwHgn7crB/AHEVFsGK4plkGJXMCIQCZYyWWIzBE\nOv05kZOg1Hi/w8P1l6YmIDXsOv48xjp+fQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAafN/8+eAfkyeznQ9yYOdS5jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI2OTQ3ZGEtNGQxYS00MWEyLWJmNTktYTExODA0MmM4OTE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzE3OWFiNzAtOWFkNy00ZGY2LWI3Y2YtZWZjYmZlZDg1\nMmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPi8HzLv8qwGBG0P6z4YsIr4R\n8dS58oVx+mStuJTgieP3CtLEc9C2egHqdC5vr0293YKLjzJSpkNkVcBcJdVnlKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfA36WTQlTbBXQ7gx8D3CQ37+zCkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGV02PHk\nPZjn/mrihMdLmQPP/QjFaYg8jsoG+FJFFWJlAiApjF8WUxT50uhorcVteFXorYq0\nhtuae5qLdAl/DbZiuQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5087", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5087` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAV1Iurot8+YVMKQLh8WH1geRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1N2Q0YzE2LTgwNjItNDdmMS04YmUzLTEzYTE1YWRlNmU4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhlYzE1NGItZDE0\nMS00ZDE4LWE5ZWEtOGU1MGNkMDM4ODBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaRV39UGcajXLWNzRUzAL/rT3gUrH++31OELFZ4yUain7X2FXZegxcDfMWew9\nCuzafLc0oFk8feAyKqk5lIUoNaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvXOjsUIuic9zH2joRhcjVnO2qLIwHwYDVR0j\nBBgwFoAUkc0dR6hFmU8q8SdmJ1slzziIM3UwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCICReBuQW2pfmLVAz/18htmL4b7jxfE3AMhBeDsUs9UoRAiEA+fptnhtZ\nxsQ/1lZwVVoFSpgtUaWxBcmMEwp8TPi+oMk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeYXWAwj0R/qJTuEf4Dc8/pBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTdkNGMxNi04MDYyLTQ3ZjEtOGJlMy0xM2ExNWFkZTZlOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqw/R+n5Jn8a825SGP7qNPFNIv1n8G27Mg+TU7Jsm/p33D\nCJfpjqwVhX+T48/UVIw59fo+MEOwXUyI6Rrb+CHio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkc0dR6hFmU8q8SdmJ1slzziI\nM3UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKWrIjboo0d35UBxI25pXJHpahHOCdI+M4r+VSNWsnHjAiAPKLhcX1/6\nZiGfXEJGXQXaho/1TIln/WSn+iI3ZXYX7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAcEhP6wZqeWpVfMXgkCyWQeXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhlYzE1NGItZDE0MS00ZDE4LWE5ZWEtOGU1MGNkMDM4ODBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDVjODYwN2ItZjMwNi00YTNiLWJhYmUtYTM3NTgyMTE1\nM2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl6Dws2VJwiTTv18nHmMdTzzK\nEOm2EkFcAZFBV6eWPQT+AAp7yl/wr7O193ZQSCSUFMURbP+KL2C6gMPDSFRXuqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvXOjsUIuic9zH2joRhcjVnO2qLIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHSUoRl0\nQ9kz28Xs2DIYS+D6kpq4jNhP1rES9x9aGv6GAiBpxL3aa1tVv5CztJvX4ugTpZXw\njJmnM9R64wpli2auyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5088", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5088` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAd2LXrOnSl8/NfX87zJFRsS2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0Y2Q5NmE0LTY4YWEtNGE4Zi04YjEwLWNmZTg3NzBjM2RmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY3ZmJlN2EtN2Mw\nYy00MmUyLWI1MmYtZDA5YjhiMTQxMWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm7bzeDi/Mh+mv9evgpa3SkvcgvwGYkYTHW4ivz6lU7J+c6vPF9i4+jIsSMQP\nZYX7KV01T3Qjxll2UMOEI0TjU6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURXvFoPB+qLrfM1f55MHuf6PfJTkwHwYDVR0j\nBBgwFoAUpnx8yWcf6LR+wDYWFzgHyz0XgoQwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIDUsAwGs0lPG3Io6qfNu+eXjbDrlrdJR3yJfuYzAWYbUAiEA7O/flkgw\nzKsGzrQsR9QJK28zbhNOEVI30zyHAy4Sdvo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXRFKN3Gl3bf8btNG+01VdvFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGNkOTZhNC02OGFhLTRhOGYtOGIxMC1jZmU4NzcwYzNkZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHzdR3Iahaork8G7GxefoZq1QwZf0GfSL+iW0oftbjv/UN\n1K1gCi8m3ftFGN0yQvbW2ChM5MN63VPRYJdYPw5Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpnx8yWcf6LR+wDYWFzgHyz0X\ngoQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXDoQLbooDZd11kkb8MKKpLjaBLLzcYHeGhfMoqn6o1gCIEBuUxvfPWF5\nBDDlWbeaXgTc1Aua+4J94DJVXFafbtzZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWyBPbNjar24MO3pcO2NyX82MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY3ZmJlN2EtN2MwYy00MmUyLWI1MmYtZDA5YjhiMTQxMWQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjA2MmYzMTUtZWQwOC00YmY5LTlhODEtZTczNWZjM2Fm\nNDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJK5gDGYqRcZ92CfKdNsHX4oO\n96NySr2SPmRXGtfFpJoY02xW6S7VjOe22wHblthjbtczvseQduQZXRoSPawHp6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURXvFoPB+qLrfM1f55MHuf6PfJTkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAuxuHkM\n+ZEE5vjWSJsfJnJw9UPBEnvFAs6x138XfWAvAiEAu/RLjEco7feDRmk89dhHQgbR\n8xer614sX7fbLEMeAV0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5089", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5089` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAajp/3vdxVkmgoSwlWz7JPtWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxYTBkYmYzLTEwZTQtNDhkMC04ZDUzLWRmZjNiNjNlZGVlNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI0ZTc0NTgtNjMz\nNi00ZGViLWE4YmItZTI3MDlmYzJiMGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3xfCB/eWKFJzettyh1QnfFIACx/0ejNWHDgEczXUPOGL47RnOBSEd9rZkm05\nC3tcNuStiJLnNOyD0xmjlybz16OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ0zIkspPifIDA3WDoW81wJGrSIwwHwYDVR0j\nBBgwFoAUVbgg4LCE1LGdPZhTH2Nf0sT600owMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDxNF/mm3RULlRRNbPXRLfMclEr3npMh0ltER+HHimskgIgd7bSosSzjHeSGm5d\nBcuVbGZ+2iTxyOLXjuoOzPGCGlM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa64Cs8n6vcE/lcB1gCffJrPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWEwZGJmMy0xMGU0LTQ4ZDAtOGQ1My1kZmYzYjYzZWRlZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRzDSpaRJplGRV/POUhUIEeDuGqVaTi0DSgbKlcmwRnY09\nEAADRpRIoct4mUTF1eu2E5xz+HBF6L92I/YRrnzYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVbgg4LCE1LGdPZhTH2Nf0sT6\n00owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRiQKm3pABhegg8Y9HWMexy0XIXfPQana93QxxewV/t0CIQDP9MhpAOyT\ngLp/XltNpeGTYTExBK7nIzW3kFPXvq0GvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISASS+3MdUeAopKX50GreSoGpUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI0ZTc0NTgtNjMzNi00ZGViLWE4YmItZTI3MDlmYzJiMGQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzkyZjQ3NjEtODkyOC00OGRlLWI4N2EtMGM5ODFlNGQ1\nZGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoqK0kisdJKRdxTDDRMIRjB9A\nacm51U2/T8EN5TY1thKxZvnvL/bF+N5QH+dsm/18N9IF1XN39Bh0CGJOE4ilyqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ0zIkspPifIDA3WDoW81wJGrSIwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIG8cWUWw\npwHsDKymUfrN2gZOMkEa1fgK9Bq8j9yyenEZAiAYMIwtZVqiIZTHF0zyqgD+nSrl\n+qBbDLOWPYHV5GchJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5090", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5090` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVXdJf73d1pJwLNCTsZkgodsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhYmIzMWM3LTk2ODUtNGY3Yi1hYzYyLWU5YjM5NDZlY2QwMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFkYjU4MzItMmEx\nNy00NTEwLWJiNDEtOGYyYmRiYTE4YzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFbSEvSUQ48QfpE+uAnOQ95yvYW4x0IZvgEi+TagVxLxs8wdpwVcua3gUhdzd\nF5TW16cicXG+0IbBhjaS3MoNyaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURw5Phj12iVXuWEf7rLe5IYTqBaYwHwYDVR0j\nBBgwFoAUk/XpQ2FHCNLKHIV+aWetNrw2WwUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCb7qPTgVNdQbeM3bUidbLyuPzbFmyoD4JWwopqXCyTYwIg\nLDVLIrb44kNfEk7Iijqbb7qU6VmAzu/tzn/y7W2D5Zs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXujSYPVhtfxqwdlAwJs5yBsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWJiMzFjNy05Njg1LTRmN2ItYWM2Mi1lOWIzOTQ2ZWNkMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBa4BYE73CSOW6DNwG84x/HZrVpw7VHq8cmKsrIP0VU8dR\nQgPpZNEFcL+YLgrPY1YlaSSn4R8Y70bu68G19tJoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk/XpQ2FHCNLKHIV+aWetNrw2\nWwUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKwy295QEDoS+6fa5ghlphavWqxJISvF2QMrJvbJputyAiAj3hAstvFz\nIxhBPBJYZGxdVmhb+yP5aVOToJC9Kemwvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYdmkfknQnmA3TCLd4v9D03kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFkYjU4MzItMmExNy00NTEwLWJiNDEtOGYyYmRiYTE4YzY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGRiMGI3NjItNjk1ZS00ZDYxLWE4OGMtMDMzNjBhZmRh\nZjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtKBp+Uzcgxnia9hB37xCCf/+\n7RbI1V3JOfEIYo2FNy/kOz9G6j0t8kJtXqiGH+DK12rObpmLLPHkd6p5J2ltv6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURw5Phj12iVXuWEf7rLe5IYTqBaYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDh9tWE\nE5TnG3lT9lu/ONZlMWbHzRf3dQ2LZz79sYH1GAIgUqFMJPlHkWRLjHoN0fcdLzz3\nZQQzojrgqwBnxLqxbPA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5091", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5091` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISASiSFgK8pZyKcOmPot7iB4+fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1YTVlODM4LWI4YjYtNGMwMy1hMmVhLWY1OWU3OTJlMzUxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM3YjQyZTItOTBl\nMy00OGJjLWEzOGUtYWUyMDBiYjdjYjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhrH57PevqClNCeU7zazRXBVKW9VVQipSmjE4juYATbZoR/oitXxwkXlY3v3r\nEVhBI9TyRrOkURdStWgYRiAI6qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtXibMkO6xregucaiDBrKr7loAYgwHwYDVR0j\nBBgwFoAUmfyhv4qmwFM3lWqk79fk7azXB4EwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCvqO+Loc9zKUTtIEuFgg8LsbxCMu9kEjZD+fKLMG2rxgIh\nAMp/+8A+eJ0lCz2P+qLetUTOY71NPR2mWJLsyr/JVEiW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARA/vSwt1yPYNZRgUTjkdxywMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWE1ZTgzOC1iOGI2LTRjMDMtYTJlYS1mNTllNzkyZTM1MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKlksCCSIhkED8TDct4SQKcVNsZ/6scIvS2iQTGEXnj/9O\n55hbos66r8I3EYBemZBf+bVPOQhn+WMHITl9ewfDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmfyhv4qmwFM3lWqk79fk7azX\nB4EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUVP6/o5eIQoNWCQJLSpMxY8yGgJJD4K0e6Kz1CyQ1MoCIQD7uXofDf0m\nSvTxMXZvpPI+W+bKnanSJaobDfa6FII1Hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQft1vBS83lf5Khgp/drhIWZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM3YjQyZTItOTBlMy00OGJjLWEzOGUtYWUyMDBiYjdjYjVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmRiOTRlNDYtMGFkOS00NzgxLWJkNWMtMWNiZDZlYjAz\nNzdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXZYGbwvNEiOOMrdjxDoCANDq\nczuUnlDOgGUD64let4ImR+NIEZxgZ712kcQh8cBQs/OsnnsDUcFm2SIUCHfgPKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtXibMkO6xregucaiDBrKr7loAYgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCMHCX3\nVTmtSFCowj8i72YSVDqBEfK7Sfm5LoOeU8ugCwIhAKf9ke07j7uZkfcGfPjiepQe\nLMHfRqBZFUK26src+WX4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5092", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5092` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZV2KRJZ7T60o6KmR0s5q7EMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3NTZiOWM0LTQ2MWMtNGIyMC05MmQ5LTNiNDAxOTg3ZmRmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTNhODc5YjItYTkz\nMC00ZTQxLWFjYTUtOTg3YWUxMWRmNzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwIzKyDRN1YrxsLSYuUL+631acxPNByjHBsqg+8aGsnyefpfl845WPhXqthlX\nw4lIpEvMvOTqTFBQWwiPiyUNIaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6vVbPnoHrYf1TdFwSq2yimHAdkYwHwYDVR0j\nBBgwFoAUc3b4uwT6MsEuGkh4hoOh/5DtIwgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDL/6NZvwF4\nCHawZGVfCmcyXYD2jNqNsL5hBqcR+0AEnAIgM6P6f6wg2PrlvEHFk+aDtSBKeKxE\nLrGA/uiZUyYIcds=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWtyQHWrmvkmzHNXhRYxbL5GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzU2YjljNC00NjFjLTRiMjAtOTJkOS0zYjQwMTk4N2ZkZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUCXbDvOImDuiU0JeAjjZkAiiFJdiXehzIEa8BFXlLUZt1\nEjYnICqmF0NoGRrTp1kDDgyZko+lu9XBUM958tKQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc3b4uwT6MsEuGkh4hoOh/5Dt\nIwgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFYB6aX9FoakLNQxKNuRhJ65WpNN30e3r1DfPgz4iZrcCIGE3nlQqfAYB\npv4gU8j/JuQwZcM4A5Cx0RzbJlzfw0uB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAfNTHL3SGA5CTutA4HUVq/UIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTNhODc5YjItYTkzMC00ZTQxLWFjYTUtOTg3YWUxMWRmNzQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjY1ZmRlYWYtOGVhYy00YTI5LWE2MjUtNDQwYTYwMmFk\nMDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElBKdCtaJxP4KDpraKio0C6uS\nlfs9FeHzXxKRk/kObHmpW+CSTg0tIYSW3gu9bBFVxj9yjeph4ghA3+4br1DGF6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6vVbPnoHrYf1TdFwSq2yimHAdkYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDx5Y/e\nhnrLL6UMgDR7GpqkGsthI5l8ZuL+qMQFRh36BAIhAMKthTOQAesU8KqL2o5iWSAI\n83XjpzkP2A09cJ3zLZyt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5093", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5093` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAX7rvZxPByA6/rSFwK8JmFyIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxYjAzOTEzLTUzODAtNGRiMS05NWEwLWQ2NDI2M2FlMDZiNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAzYzllN2MtNmI0\nMi00YmNhLTgxZGYtY2UwYTg3NDdmYWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM5S3KnvQvt75+fsIuT3bhZaL1t77ziU1U6/fKhw0vz4Fm5sD445kY8f8Ysti\nDVgLuRawToC4gjTdCQUOPwPU/qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtIe9ib67HAIP56MjA4pwaMFwoOIwHwYDVR0j\nBBgwFoAUdN1tRAAX95Tg+46Tv9IO73XJJOwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAN+h19DhpWfhqmPZ8Ex7cVvp+hVjnE2ZnHpG+ehtbxF9AiA+8258t2tW\n7LDE1HoAsriFCZ1sZUPMVdjFnOdF/avxpw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbLc6rn/rQl5afRpYrpcCaZ+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWIwMzkxMy01MzgwLTRkYjEtOTVhMC1kNjQyNjNhZTA2YjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAAIicWHqaDNl5/xFkR8hT0g0getRtFs6BGa7ZqUjJs5yv\nFUKP+jk+9bJRA01g7nL/B0gcw4tXBV7u40bqbfI8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdN1tRAAX95Tg+46Tv9IO73XJ\nJOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYDmmU86RtH13ix7U/WUoV1t2RddxfbMaCjS1iuOKWPQCIQCDsKGTfTZO\n9x3FOA6xYvtmtJU1jtQGWtqKQzTKIITheA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAT9l5njexnQXOppNOGx3sO7nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAzYzllN2MtNmI0Mi00YmNhLTgxZGYtY2UwYTg3NDdmYWFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjcwN2M5ZDUtNDkyNy00MjEzLWEwMTEtOGZhZTQwN2M0\nYmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyCdbkRN+U7/Yflj5Aq7P2D/t\nA0SCOzT4Xean1vepymLKTYhAjzVNCF3DLyCVhzEae9vQb/Bsee9ApcUGHir0OaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtIe9ib67HAIP56MjA4pwaMFwoOIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIErpktMu\nnMg58GLScBrQ7YsZ6f2QdtrWu/z6XEOUVTA2AiEAo4CXqF68WbOiWS2oJuDsix04\n4GjdUj9WRVaIzZyY0sw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5094", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5094` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXHwAxzBjPd23B4ERj3QEegTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5Y2JhMGI0LTM3MjQtNDhhMi05Mjc0LWQxMWJkNmE3NGI4MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjljMzNkYmMtNzJj\nMi00NjZkLWFiNDAtZjlhNzBlYTc2ZWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBEJ7/FuBquCzAhvh9eJ5bv18B5KSUBpTlhxheIuNdvWFihQnIX8rFXZImHgI\nbR3wKFtWUgc5vCBMIsLdw3u6eKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtC9uCIzmRAuuZTG/H3ebqC5Z1LgwHwYDVR0j\nBBgwFoAUFJHPoP5KqLOV2XTfDKpZaLVlSPAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANmS/J2rKyAo/8cK/MBGeRi2sHhjvJOixi9jTPCcS+1+AiBKOgfRuJXf\nFq4aZ64H6zxGFg+Z9qI04WOvIgimwQr38Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVyNKP0aPY9uTd0SGTVjRbJsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWNiYTBiNC0zNzI0LTQ4YTItOTI3NC1kMTFiZDZhNzRiODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBTb7pwBN64e3M7JUeH/JkD44aHnkCv5lb+Y27MxNSMkyq\npYUGpHgVRodX6+raclsnIzBVosf/Uf3lXEvAXwslo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFJHPoP5KqLOV2XTfDKpZaLVl\nSPAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIEYCaJwZ/UqmDgBF5hmiP/mGQy3Bv5mElVHrgug31M7AiEAuQwUeLZp\nLc5n8wFLkXCrqRAeGJYvOIo66jvfXbQMMTU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaNz2BC2wC0qN0MZwiY553+fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjljMzNkYmMtNzJjMi00NjZkLWFiNDAtZjlhNzBlYTc2ZWFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDljNmU0YmUtZmJiYy00ZGRkLWE5OTAtYTZhZWJkNmZj\nNDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELeVD3vXvYmf3kaqJdjUIajs2\n2ty1hZyq5fUIBXQlUBzL0eMG4LtwFJKmsy4XHPbEDnoBbIJ0yIvUjs2p0l8QZqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtC9uCIzmRAuuZTG/H3ebqC5Z1LgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQC3Zw1C\najBpqFkFNJEBm/bKVrkpWTsDY0byrtJD1RwQDwIgS+fNb1r+qMdUu1M5jsFoM5JR\nxFNvgfNF+TbI6MuvCnE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5095", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5095` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAUXPCmieZ6/QdMqDOjYgLWTEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmMGE1YTZhLTc1NTQtNDEwNi04NGQ3LWVjYWNjMGMyNDhlNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFiMzg3YzEtNjQ4\nNi00MWQ3LTk3MWItZTZjODI0NWJhNzM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnrZGGzJeXJ0EJ0bIGU9ZlWhMjgz+qlqQh1vTbC/NBQMMnmqhNhaKouiBONu0\nby96apA9Le68Vvxyz/mAzbkXiaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaJ0VqV26UNcN4Inm8nF0v4pPQM0wHwYDVR0j\nBBgwFoAU5BJvHNyIsLTqFObCkl5tzutqxBwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDo2hH/8fZETwrRa6K7RnW/gxulFw0BNS6k0dzAiiBP5AIhAKT/Cdtw\nDjYTN6z6SECnkwNoCUlB26iAZDKQvQ7gkKyE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcZaBlhmF780JmXGsOiOfbZ/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjBhNWE2YS03NTU0LTQxMDYtODRkNy1lY2FjYzBjMjQ4ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASC+Havc6vjxOsWhjLdzGN7BIk0b2MYx11/OmuiNfdURfSX\nfq/+kaPlf4XfhQ0FL8w+y+sq1KEMX2s7SS6GvTGIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5BJvHNyIsLTqFObCkl5tzutq\nxBwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIQdptssb/Gw8kbTEVHARC44/71ZYSC/afjori+ku5skCIQC/gGMSHvJx\nRTV6FT9XUgEMsvg/ogJMj9nB9Jbm5ncaLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYV54MDNMJef+wnL3IgeR+t6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFiMzg3YzEtNjQ4Ni00MWQ3LTk3MWItZTZjODI0NWJhNzM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTZjZDI2NjgtMGE1YS00ZDEwLTljZTUtOTMyMWVlMzFm\nYzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqXF+qxwnFxqMqQ0P+SYJDprf\nsdfGCZ70A1jcXlLaQIY00P8uoeXvgJdL94B8teD7GNo6NA7Xmwa6mrOgkCZK0KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaJ0VqV26UNcN4Inm8nF0v4pPQM0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCJzVXp\nKcYlt40o7rPxcgV1awYyyZ7Oq981/kuGIG+uowIgXVixIoexkw0Q+5ToMaIpMDba\nfv3zvakXkOIMi5q1vnk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5096", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5096` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZb3hSBsFFkTK5ZP8UgROSX2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1NDhhMjAxLTA4ZWQtNDU5NC1hMTNmLTg3MTczNjAwODRhNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJmYTU5ODktZGE0\nYi00OTk5LWIwMzctOTg1ZTUzNDZkODNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU2L0CPjAFP8MTFH1BuyOqJdalTCazUT5GsqmOpaoKQzv6Tn2K0qDopoJ3kLo\n0eTov7EHp1rnOTqd7xkGGYBtX6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3iJplOQ9KPMEHzAVuFVhHWYO3/4wHwYDVR0j\nBBgwFoAU1eiOCiEAxIEW6HicDm0WW3PxEBYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDFVb2fSLjD02QXK8H7wXfCElKL0PQhTahyD+Bj\nqTdu4gIgTAtCoqf0NghmbR/V0DJl4QBmJB3JjMhwRAtikwEr5Qc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWsgG+ExyEXyj40jXUxuU9FhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTQ4YTIwMS0wOGVkLTQ1OTQtYTEzZi04NzE3MzYwMDg0YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqo8FeC1VRGaiCNcVoA7o9GLlGPIz+dt2m7vtfdPFjgMOw\nlCZ4JjEVxXjqktBif/GPdffbjDuxQFqP2a5IXxjqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1eiOCiEAxIEW6HicDm0WW3Px\nEBYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJRd3DIQssnEBUQewIlzEKvcIkv9X4o/SpAlfJ1oJjxSAiEA0T92sKNI\nOyKcffyGLJjma7Si7SlVC+dI2cTzUVEviDE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISARMk1kvLrnf+xconZL1DVwb+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJmYTU5ODktZGE0Yi00OTk5LWIwMzctOTg1ZTUzNDZkODNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWI5YTJlZDEtMTkwNi00MzhkLWE3MDMtZGRjODdlMTUz\nZGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB/++eQ5M7Lyt4Og8uq9KEXLK\nhMDODa2CElDF+xbwgev7fFKrpN8EZY1kmpJ4+6pxBWgELzrHK+SAMod3K7b7r6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3iJplOQ9KPMEHzAVuFVhHWYO3/4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIFORSkgt\nVRgDcNGcYKltFmwn4qpJTVrq+65RPn5QAEPbAiAHv94YG4FxXTgufE/BRECbnl8S\nShf62f+UnuGN2eHhtA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5097", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5097` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISARwYSFBNhATGpwz5rWtO1suKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmMmMyMmMwLTc5ZTYtNGU0Yy05MTBmLTJmOGNkZjlmM2YwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg4NTVjNzMtOGE2\nNS00MzY2LThiNDUtYmFmMDExY2RlM2I1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2gBGlUi0zw8/wSGLSuNsid8ILChXOyGAVFgDsfLJQUd5Ec/DRQP+LWEPDfko\nUmWH05Q/YfVnkF6TQTdk74RnIqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI7aUBC3c0SlAIeLTFBjb/nXHn98wHwYDVR0j\nBBgwFoAU0txlb+2wYyUTMnY8/TnXsgH1inMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGYkVm89reXv2UpGdLBjS4mnIqt5RazAEUOc+eDG\nylERAiEAlU6+UpVd89n/a5jqQBa7R8V325HctLQxkzuUBk8ExG4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY5JRjYeMPqipMgcpK4U5MuxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjJjMjJjMC03OWU2LTRlNGMtOTEwZi0yZjhjZGY5ZjNmMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUzYMJM2Sknml3eGEaPCWkRMohMQYInLHrDGnxPeJjcXnr\nhIq+Vj13ni28u3xvLdu8+be80uFTO2O7zOtdIbqno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0txlb+2wYyUTMnY8/TnXsgH1\ninMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ6fHJszudNbsKuA2x5CSjyCYaeoALGrxY6U0zgGFu8kCIQDM7FG8vJzW\n+0jck5N0y36rHrd0b/UAD5fkZZ6lUNJFNQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAbFUqKpOm/y2QbLNSyV6Ac27MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg4NTVjNzMtOGE2NS00MzY2LThiNDUtYmFmMDExY2RlM2I1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzk5NDdiNzktOThmNi00Mjk5LWI1NjktOTIwMzMzYjVi\nY2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyx89wc4VlBQJb881nu1D4Fop\nSBaduzlw5njqPHlf/B0oeTlGyt1JTgXDiyKnxB6bK1iyO4VL0P2O7XkgDgUMiqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUI7aUBC3c0SlAIeLTFBjb/nXHn98wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCeDiwx\n454u+RLeEv0GaNqNTHOOXMPkB+AabCQlhPDgZwIhAKPNhpF6T5e5ysc7JK99NLKU\nVKrhF/uifmC3u5S5gCVX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5098", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5098` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISASOfd6Dlr4smi2hiH8QsbfKIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmY2MzNGM0LTFhMTctNGI3Yi04NTIzLTJlNGY5MDQyZjZhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY2ZmM2NzItYWY0\nNy00MjY2LTg2MDAtOTZkNzRmOWFhNTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiXs4WTdrfXWi5Yh0S+Buuszbvph88ktRGHyqJOowjWOjnC1t6dIF7YyRReYC\nFxKquNkp3LS5Oa1NueLP65vKLKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMFb/6RE+N50Gkl7dcr+ezVKSOM0wHwYDVR0j\nBBgwFoAUm3CZOhTeXydpZx8d5ONFfCY6/k8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCGnNYRG86RSji2i2mg5w1znDwpU2o3wl5nWywD7q06UQIg\nGHdX7G2UcYl1zM2xzVXdhEiXizwsVaNytQ2RGO+dv8M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdjUzI/w2AT7T5VX7XrBjeQcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZmNjMzRjNC0xYTE3LTRiN2ItODUyMy0yZTRmOTA0MmY2YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqexdI9rZNtqUQusLXO/zP8SqEBmGmCLrXHjn5DggARHB0\na0WayhyveMs1TkRl/QnFif+U5c9ziMn1PAu6fA9mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm3CZOhTeXydpZx8d5ONFfCY6\n/k8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK3J4dRQGmZ2RY+2748ffab1Fh3tisLR78vHa2yoeTDRAiB+nkd3JSr0\nOu2EXXhQBUi4EJ72Hpu6sS+M2q3X0J6TdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVek/RB5q3y9GodFnjwd6thxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY2ZmM2NzItYWY0Ny00MjY2LTg2MDAtOTZkNzRmOWFhNTdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmIyNTczNjUtYjE4YS00M2JjLTkxMzYtZWUzMWFlN2Nk\nMzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQceOy3HdIeIHjqzqFS3hUI12\nJzXB+rS5x31kjB7ff97Cisev+ZN3DGi8oNSYP/hOuvbbFf7LSbS2IdiVrf94OKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMFb/6RE+N50Gkl7dcr+ezVKSOM0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDH/hR6\nZ0Vv4mCQYXsPgfGHetarGEEAnilz4hnO7KC1eQIgFuKtl20VNiI8EhjUzAeNcpnq\nNuP8+113Ca8r9zBuxUA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5099", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5099` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfMAyrja5cEIK7g0OvN3F4cOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlNzdmNjQ0LTEyNjEtNDA0MC1hM2RlLTM3NWZiZWZlZTE1MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODhkZGE5OGYtYjQw\nMS00Y2YzLWExZTctM2JhMmRmODUzZGZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEarUBI11dE3GVFCbW6kGO24bDyW0dmKTAt88xMXSsg4GoB/nRvP8RLgmIcfTl\nyg0rI6OHOhGFJnMSIdT2TCCkqqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0KwqUe/IQDM7o6Q3+eesQ2baOa4wHwYDVR0j\nBBgwFoAUOM66jQkPPIFUeqwe3rQGpCo+dTQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC914hF1NBH0ZpPvu1Qgnx3xxAxiuDV\nBhTPRBPPo8XCswIgN3BpBc8f/SsTmXM28PM0YQJ6JpXuLhOnDq1S++pKxAw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZYHVfLzP2WNNeIhRT7rur0cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTc3ZjY0NC0xMjYxLTQwNDAtYTNkZS0zNzVmYmVmZWUxNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvwMctVG6vBHB7+RGjp07ydLJ+WmY16W5SrTBl6W+ZvlqC\nclHj3eNdGoskFsEPYybPe0GCoK/nlW9c5ImZhGcko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOM66jQkPPIFUeqwe3rQGpCo+\ndTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL6MfKvbnLn0aq6Zg6DKhNF/RLg/2fCsbIQpY61cLeT3AiEA2OEAIXsr\nW8oOAYTDN2b1F6l2GADQreBWHiaHnzj1dA0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAd7nHWN5YblrkkJ4TsxzTDNDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODhkZGE5OGYtYjQwMS00Y2YzLWExZTctM2JhMmRmODUzZGZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjAwOTE4MjQtMWI2Ni00ODlhLTg2NjctMjIwYWNmMGI3\nZTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP/3Bed2zTN3ZI1cZrOpeKF54\naxMdMuuhtmagSAgptCAdWMDycqvNIx0aQoIXyzEP2DV3dJFTIuA2U+VFHH3t7qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0KwqUe/IQDM7o6Q3+eesQ2baOa4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDhLkB35\nqpj8M4mq3LpdiqIs/iuYX4NMnXL2dLlkS8rKAiEAq7wk+ftfWLZKrVZW8wzHmRQr\nNff8VnmxvMK9hg2gQPA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5100", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5100` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUg1klYH6MfV3AChWYzHWBb8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMWYxOTk4LWE2ZjUtNDg4ZC1hMmE3LTBkZjk0YmFiYWFmNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWVhYzNiNGUtNWFj\nZi00ZGQ1LTk4MGItZDM5MWM5N2Y0YzZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmjQRFyBZIOuZBW1F7e4Pp2wiep428jSkOykYz3icaPDjP/Z3ntGngvGZBeZ4\n6vHivk356QTgECMoG9+avXrG26OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1WxXGgDinVp12UBbha+Vm4BB4nEwHwYDVR0j\nBBgwFoAUWSW+oTpnaEuWeig6d8YxnUPCsGUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCnG40jXY+Sf6Mn3YVWiP4wLiB1+/33\nDckbGxSFzu1vgwIgR2yo/EWzBEP3YpUYxcrU73PU+GtHeRTq9p1oa88IrD4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUSU8YfzsGFIUs1OYM/PglDgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjFmMTk5OC1hNmY1LTQ4OGQtYTJhNy0wZGY5NGJhYmFhZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGlJUWk5dvtEfIH94Frzu0bBrYWZtqChjTYJNj3XnPCgSN\n37SIyip+bUPi3zOLlrflpKZQRJKZjOcfWybSk6D7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWSW+oTpnaEuWeig6d8YxnUPC\nsGUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIged/DwtpBExZNna4+VFM+/h69u3yhk+04m3qRkFlEQwgCIAyTh6aIp7PH\nCgSCG0a+5QpJhgEDqi5bUOaEMiJXc9uu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISARZKqlTMdx3r+12BOiZE0768MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWVhYzNiNGUtNWFjZi00ZGQ1LTk4MGItZDM5MWM5N2Y0YzZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWJkMmM4MzItYmY4Mi00Mzg2LWIzYjUtYjk5ZGI5NTli\nM2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8oV7aKXKs/QjsykcmDpd1zCg\n0V4OERjeLSCidv/3fIGtN8Frne91M1aT19aR68fw8dkRxIN875uZFEqcW06ynaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1WxXGgDinVp12UBbha+Vm4BB4nEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIF8pWeLr\n+v5uubSdqFi4AOdWscqddfLQ7dhLMpug4uLZAiBKZbHo2agqsnT81X3AxmMIWJVM\nw7HGSf/cNHGBUXLfvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5101", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5101` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWYnQ2urx8vx/LkNPrPbyrsgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxODgyZWMwLWZmYWYtNGZhYS1hMjFiLWRhMjQ3ODVlMWNhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRlOTY0OWItNzI1\nZC00YTM0LTliOWItMjc3MzU3MzYyZWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8iGEfX2GZah6ZrmhPTLpdMCzXGX2Kwxrt2l5I3fHk7JisXCIBHER3W1Cddx5\np+6Z0m5iAEnzG/cohXAYFuNJJaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0MwSYUBLXOBdN4IiSsuq+BXcspcwHwYDVR0j\nBBgwFoAU2sHW4ZywFrYVISAeNmc+OZa6NkYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBC9F33fxLdV\nDyyYIjKd4BQJEr4mkX3OCEXbzFxpBsLBAiEAzZ3nTH/voB5dJHknU7eRQuZlVJqs\nATQbpzkW7q2ft2k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVsGXOmITeYAyk+T2/M4nQJWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTg4MmVjMC1mZmFmLTRmYWEtYTIxYi1kYTI0Nzg1ZTFjYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpzZoE5CUkc4TKy4QqMqaMsR0h5VKuv4NTaiT9L+ypfBJ3\nHdVaqdBWda5tWsOv8yb0nu14j6RbjonSxBY1DgDpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2sHW4ZywFrYVISAeNmc+OZa6\nNkYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAk4LbFV1yRt5bzG3vO6EQDoztT8YIj9hoDubTLo8AokCIGLY5gl94Ekw\njc6V43AV0/nbV4Fsy14tmRDRU5z4n50C\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAa+aEa/ebraJgg+7s3CxpJgXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRlOTY0OWItNzI1ZC00YTM0LTliOWItMjc3MzU3MzYyZWY1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWU3ZGUwOWYtYzIzMi00ZGNkLTk1YzItZWNjODE5YTU3\nZmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIXY2ZFxMYvzhZKFOdb0clqlN\n5UL9ouhfAhv7q6IOihrvXyB3BXGI6yjdJHgwxAordcJ6U3K90z+KTA9T7x1OwqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0MwSYUBLXOBdN4IiSsuq+BXcspcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAQIJ0Yg\nvWeGQPQF/IysjK7P8xVmBB3j7+Y8EHLvC1kWAiBQaMrwDDg0ygYr0tSradlao327\nPl5i/oXUrIR0z/z2mw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5102", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5102` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAUVfmhcqG33Zvbly1IeSI3cgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4NDg5OTU2LWRlYzktNDAwOC05MTJiLTE1MGIwODhkMWM5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmYzYTAxN2EtZjk1\nNC00NWYwLTk0YTctOGFhOWJhNWQyOTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgmhU6s85F5lBTfyKWkYua9ai9mvGz8KRNIl/L2SRtXSYogW4yKMK0n+NBUPS\nT5PPKaNARhTwE/JFyO/uQmhie6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH94wHd8MeamMpbpf5UaBcbUUQ6YwHwYDVR0j\nBBgwFoAUUPoLPGJcb1Tw0ysHXD3TMWwAXzcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgbsxHSKbOsl25cfLJlU6PuoWQ8iRwMOYI8gWhAYLPikwCICZR/7DRzbNt\npFLFHqAFS3oOqDJiu8SwiUusY5HCgH2A\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUgLyEg+G9l0ypEYXxmf/9AjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODQ4OTk1Ni1kZWM5LTQwMDgtOTEyYi0xNTBiMDg4ZDFjOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxfnPf1VpwqDOgFm8Vv/5IR9bR2KRUbYkve+5HYjI+9Nz3\ncWQSJC+PlWiKACLKs3Ul/531Ca0HEnIJb4pAvsiAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUPoLPGJcb1Tw0ysHXD3TMWwA\nXzcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKFOtX4pZal4xZdKiiBrITiOIERcQjjhDLTdrcrb8wDIAiBNYXW7Gygd\nhzSW7IYmEoVdXRp6RBqPTeevZpdweyuyxg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAUyMX/4cBy+gGAT/ewNNJ39lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmYzYTAxN2EtZjk1NC00NWYwLTk0YTctOGFhOWJhNWQyOTMzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGI3MjZhYjYtODM5NC00YzVlLWI1MTYtYmQyYjRiY2Y3\nMDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEliw1HxaPmWmrWa8apWlUfXmu\nsbKfGalq62kL1wYv5pxqZE9Y1mB4qyvj9DnkXgqkLJIUSKjlF5L8kQoehQT2QqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH94wHd8MeamMpbpf5UaBcbUUQ6YwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAzXHcfR\nOMzJenXvqnTbRqXd0ot3HaYcp5oDyAglxwDlAiAX9riWT3506bHMhsX0DMf0g5l5\n77/9MuGX+9FrXh6xTg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5103", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5103` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAca3otHkBUzDwzEnLKetvTcCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjZTIwM2YzLTAxNjItNGVhOC04ZTRmLWQwZWVhNDM1YjYxYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBmMDE1MTUtNjI3\nNi00MzI4LWE5NzgtNGRkMGExMGY5NmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9PDMB7nebadCZImZ5W6yy86MWVtqhApzIORws5i9cAemzsq0nSgiF8Dq+brJ\na7Y9I449BhtnSQ0IzFQyI2RvNKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCtzKbQ4ZUJKM9QyWUsITIX8Ky6QwHwYDVR0j\nBBgwFoAU8lMvTX3fm/8mEa/W/lJTOtsYM3kwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAO0FDs5BktshU0/lWlbDhLRmOAE03EGGX40gjzSfD0rsAiEA85quY9K+\nbQQUetjoJ0khT3p0bBX+3feM7gM/OX8akgg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWSoxSnEJe/9uVTyEb6WrCIKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2UyMDNmMy0wMTYyLTRlYTgtOGU0Zi1kMGVlYTQzNWI2MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMjdOj6m3IQK7kmYS1R7qibCmGAb3isswJA3EfgBTDioq0\n8F6qzQ7Q5K4Xh6CEYvIJnn2QJphPQawUxpZv5kkOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8lMvTX3fm/8mEa/W/lJTOtsY\nM3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKEUUEnxQ6jCaiLx+NN4943EYPS4Mr7QCooLy6XEFX+kAiAROn8CUP1o\n0fo7ZBAsekEh6xJC89TUFS0QCB1roiYpgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISARN51IJtmQufE0CJPr3L9JqZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBmMDE1MTUtNjI3Ni00MzI4LWE5NzgtNGRkMGExMGY5NmQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ViMzJkODctOTMwYi00OTNmLWE5NGQtMTFhOWMzZTkx\nMzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEU+M2A+vHzZHx6tQnfkBlJK5U\nIUSjFK78ZuTnokNzP5f0/ufZab6mIQOQHU6KyftGqgTJsozO8+gk/d8zaQjEMKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCtzKbQ4ZUJKM9QyWUsITIX8Ky6QwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDgtl5f\nnKRwiUUihz09YphGKnZ+znFbXIdYibvb1g5eBAIhAMYgvjz1zd1uQ407HROpYTl6\nZR6ztgBX/4jgeWTyJUcN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5104", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5104` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAWEL4iHmVAP5ivUsT5TEhHEvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxZTk1NWRlLTdkYWQtNGIyNS04NDM3LTc3MzlmMjU4NWRmYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM5Y2U2M2UtYjQ0\nZi00OGEwLThlMTYtYWIwNjgzMGIyZjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExOwS+MipY2y4hE0y/qIAHmAySO3QHfGDemmQxZHmNy47sung2RpJdSwlSzeZ\n6ti+zrobNK7A8IGXVCPdqOHgwKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdgt/Qb/U/LsrifgH37pON5R9ymYwHwYDVR0j\nBBgwFoAUmRG3ME9xDBOcS+52GC2fI4LjWxswOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIAYMLSR3UZwlb+91RwaPzKyXVLVV9qH7/B0FC6Mu90QAAiEA72cSZoAE\nE7ao/lPXR+CooY+u6I1yAnS9CS7vMkbNqRA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXyQVe5xulG8MTSUxVJCIORUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWU5NTVkZS03ZGFkLTRiMjUtODQzNy03NzM5ZjI1ODVkZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT28R8GZ/kzMvh11VatKGVHiC78fMgYU2m9hWHlcqbRdF0q\n2wowecSKjSTt3OT+d9GEicfKGHsVVKzuTbIkbP+3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmRG3ME9xDBOcS+52GC2fI4Lj\nWxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT0WpF5UuCWhXNE6cd6Gt0RCcEDHd0fyTA3zpras92cYCIDGkuFjgz5mj\n3s4BVCS25FXn0BB8j7Y6iAxwBeDeeHEj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfyyFoYY6CBh1xc72VAAboknMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM5Y2U2M2UtYjQ0Zi00OGEwLThlMTYtYWIwNjgzMGIyZjQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjU4Y2U1NjEtMGZkOS00OGJkLWIxZmItYTM5ZmQwYWMw\nZTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl3O/29ezkiTBfrLxITtUDggq\nTNchstYMmzjxThUgtrhh6e35WCCcjwGzjWRjUYPPRl6wF6luYLmWB5BdXWWIBqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdgt/Qb/U/LsrifgH37pON5R9ymYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDcUsNh\n7Y7q5fyfIbNdjW/m1xDL4PeSg983LWQ6ujBDYQIgG7IARo+Csicksxh9e6/YRgZW\nG0f5M9OCg/vlJnbd++0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5105", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5105` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAWKR2A/POBKFcvfDLdBzZ7LbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhZjM3MDNkLWEyYWEtNDAxNy05NTQ3LTNkOWU1OTYxYzllNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZlM2VjOTYtMzA0\nOC00NDk3LTk2YjAtMDYyNWZkZDgwNDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJgEeDFj1uo26lgjuan+HxR97UTE9MExxwRK+rt3CI1l7SJXxUEhguz1FVsz0\nRpfMG1kkkyO+R6a+Oy/KeVzuEKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+k0iYo9lBCy2zkcNx7cqAcBoxiEwHwYDVR0j\nBBgwFoAUH3s9DKQV4uJ1Y9AzYkPcQRhOmOMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIEWgOwZHLKcZrWnWC9KYCqPvStG/HDjPII0sjHWh\nI33sAiEAw3zRfked2Z9eCTBej3eAwOmICN616iYFUmCPGHArmqg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATSEUMYjUHIpoeGQk74ZL0H1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWYzNzAzZC1hMmFhLTQwMTctOTU0Ny0zZDllNTk2MWM5ZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0aYeGAfFaIDF/W9mDYFCACVD86D8CJdH++Km+2Zm2bOyf\nA95pZi/ECDEUy86CKURcqex2p6t8MBbATrQ8kUaao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH3s9DKQV4uJ1Y9AzYkPcQRhO\nmOMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdUJ+Ia0iYD6MAEuXl/BLQT7m3mvWB0VXjpoRzUUXCsQCIQCWcLogyEgg\neq0QlAOuH0MFKmSP9q/XMeN1GGLJIuSyGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAb3gGG0CiBy477LbVgjPe6lLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZlM2VjOTYtMzA0OC00NDk3LTk2YjAtMDYyNWZkZDgwNDE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDJiNWMzMmMtMGJjZC00MDg5LWI0Y2ItMzBkYjE2NmFi\nM2IyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdd+KVnAWpqOUy8BBRronxruQ\ntnjhZwx6aI03LUbF64dYUMzBx6pF5EaDSZSi2zNfwLoKyTOmVFXuZYU9JA+tHaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+k0iYo9lBCy2zkcNx7cqAcBoxiEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFpoXsG6\ngVHQvnUwTUClTMtQCZaZ3atQMVTc3NnScWZjAiEAzH44arQ5BYyaVB3lK7Mxa2mW\nlYrQ7QtOhlteeMCs39w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5106", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5106` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQevU9Vh2vv4TojlxnURYXrdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwZTgxNTY2LTQ1YmYtNGU0OC05NmQ0LTE4OGQ1NWFkOTcyYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY0YzQyM2EtOWU4\nNS00OTE4LWI3NGQtMWFkYzk5NDNiMDQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu106fUoRW7BxMxOOwuOeobETnTn5dRz3W7J/tk4jEiXnym+6pFQFhr7cM50E\npighhy4czr/ltD0faCoBjmw7GaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1NwatWA6OGbm6oK8iDxj+C4u5PgwHwYDVR0j\nBBgwFoAUg00ubxKZFj9mT5PWBdRKssU487MwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHhd1TXO33YuHLMnMmi1QgPNs386jTHAZKmoPArF\no2DzAiEA7jKR+5bFZm1KbmhfSz1/yIaAQTh81YNvVgVzrIFOT0M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAckQciwPu2zx6NAUlg3MqJYJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGU4MTU2Ni00NWJmLTRlNDgtOTZkNC0xODhkNTVhZDk3MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmiTKdADtvuQhmQyTj6U9W5brDPCV8ruEjPAOp3MA/wZh2\n+qxnRp2/+Hg6rlDi3QdLrBRcjh3YWDyCt5SGMMibo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg00ubxKZFj9mT5PWBdRKssU4\n87MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDYFbYz2slFGytF8nPUGE4LiA9VD1ap9FcsjZBbR5/kECIQCkOJfZI5zO\nqsaKvKbwQIceE+KcppgZ3STW+Fsw10D4CQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfFGtS04D/EjtKZUC8e1FAUsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY0YzQyM2EtOWU4NS00OTE4LWI3NGQtMWFkYzk5NDNiMDQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmM4NDM1NTctOTkxOS00MjZkLTkxYzgtYTQzN2ZhMTdk\nMDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExTv6zqLXOJj8gAWgpgoEKu/g\ngI+Xq7LaiMPeJ8TvCmM4OnycwWVjmh1R+RIzGtE2lYMVmarzzvujmzjhC6yHUaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1NwatWA6OGbm6oK8iDxj+C4u5PgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCQ7NHR\n/iw+jtL/rPhNq71htcW8e6VcOP4dWWGJQFiJ+gIgKy1/RJ6FS1tv0Rt21QX4Ouse\n9lhlck136aiN2DWEI1Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5107", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5107` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAWKih/XJdZeIBECTFT2Ckb2WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhNDUzMGIyLTg0YzItNGM2YS1hZThiLTBlOTg5ZGEzNjkxODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGEwZjJjZTEtMGVl\nNy00NjZhLTg5NjgtZDA1M2U1ZThlOWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEouL/VEk6UiCa2UaUqVPHb4B+hyCOG2/uZ/UpCn6kkR3QHD0RrT6KK/kWikCf\n6vKhOzgFyn5J+mTPri6xIXJwo6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5w3qZdG33vnyId09oDkw955PdwcwHwYDVR0j\nBBgwFoAUZtoAhIBPVPcto+73m9Kc10B+OG8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIGzLH5LNuJOTBU8QGRpLzUQJh9CBXY5geplSASaSMg4UAiEA\nsc6aAdF5e8RsYr6VGu1Mk+pKq+I14xFy96a//KdGPpk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQZKlDSjoM0bEALZpCMaTly+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTQ1MzBiMi04NGMyLTRjNmEtYWU4Yi0wZTk4OWRhMzY5MTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARb01VQaWD1AuRNbzBlFkQex1Up7i+kUTzVajo4nZOoaN+x\nl76gndou8L3VXK4K0ku2/KYNzsIt6IKzAnGrffz5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZtoAhIBPVPcto+73m9Kc10B+\nOG8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXYBGtvTsi1Apj4cOpuaBZ+DKwoKPcJQfUEDkVHZJFNYCIANcPuYWjP5g\ncG0oG2LNKqGyBmHh6Za64P7UL903bq91\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAc/KH+grkamOABmH0hz7YPMTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGEwZjJjZTEtMGVlNy00NjZhLTg5NjgtZDA1M2U1ZThlOWVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDk0YzZmMDAtNjJiOS00N2M5LTgyNGEtNTgwMDgzMDc1\nZTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM/sMuqf7I9sMiN04qiqhimW4\nSzpfCUmzxV9oyp1XiwrQrYAedXecp6/U3lJTBc9V66hIOUUWmH5cNBZHYFvkjaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5w3qZdG33vnyId09oDkw955PdwcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHqAYHzD\n42sjai9VxveErIZdI229IWBrVxiHeXbrjS4TAiBrWFNLqn53/Bh2jgNJFtlsqH1V\n2IeMdUTwWs7ukhawKA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5108", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5108` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAaFhKG3qTYivzQQjDJcu1ctHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNjc0NWFjLWU5OTAtNDJjYi04Y2Q5LTVjMjM5MmJmYjE3YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTkxYmZmMTItZDI3\nMy00OGFiLWJkZDMtMzlmN2ZkN2I4YjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEySL3wTcDFZt70xJf0hk/vmX0MCuP25vJ4yHBtQU7xcwsG4fwOAHcL7HZ02rD\nDzslX8VZplG/loayXNTPgVdPT6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUi9ePvJ8NDOGjKmbQ9QnErNmf2MwHwYDVR0j\nBBgwFoAUWjUFD66vRRweBvwzkez53t+04VswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIH+2ju4HdngDYl4yDgO/OO4/hPpW+Mga\nqumWjCW5zGFQAiAe22kxv2k6j6oPUhjJR9WziEW81adrfVbe1AuU4NSqmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZKJUtczjLF6HcPByfQPAqJzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjY3NDVhYy1lOTkwLTQyY2ItOGNkOS01YzIzOTJiZmIxN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgA4+sO+dbRcDMcyEZprq0HRg76qe4rSZSf3Zvuee22T5U\nsuMZzGEdTExpTlXaGKkRZhVaLd0b4dWB/XSAezbAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWjUFD66vRRweBvwzkez53t+0\n4VswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdJLNA2KGAm7LSMMvtIH6RGwjPhXOnA3j3SLV9SHhiYECIDRdRNYeL6tz\nGvR/Rz+Di0JaBfLcuIl141cqqk5njSYb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAcVUEzuYoiTp1OZ+2g9jaeXxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTkxYmZmMTItZDI3My00OGFiLWJkZDMtMzlmN2ZkN2I4YjllMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzc2YTRlNWUtY2NiMS00MjE4LTk2OWQtMDk5MzE4YzA0\nNjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy8bKi9QPPpshJPN1A3W93o3r\n0+6cxiojtahkfUFrE4B4hmwmJ6v3+PE8nKxCD57hvK7u+Lhw5Z529iESWOf0oaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUi9ePvJ8NDOGjKmbQ9QnErNmf2MwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAZWS3uF\nMT1GaLg+kbkpMYSJp0K1i8o1KsF/7XE1L4ZoAiBrAweue7ZMRrGgb1Xsp9Njvi1x\nENJoKXBtPFJ4f3ozMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5109", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5109` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAbFR3SlIPzpXwedHBZhAWDKKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMjQ4M2ViLWFiMzYtNGViZS1hM2VlLTM2NjFiNmU3NDUzNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI4Y2FhNjItZmZl\nYi00NmQ0LTgyZDgtY2NmMzU1NWVjNmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENCHqeWh31jLdR+TLz6cccze5l32DdogKCbP3HKYI9v5jqCNA+h4rJrDuQYxr\n0f3MQFw/SjEnn7x/AayO0tn5mKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+3cXMpbmtipwufnC0fQXV6LGHbQwHwYDVR0j\nBBgwFoAUSPVs/FbFMWsbIMuTdPn5v5egs8cwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC3AJgvTz2fZhKXfPtb47ErJx5uebHT\nPSMS8B3fbuW1tAIhANRrnNxi6M+eyKqbMCjYyOQoz2MrwhJgVL9Mdv4Byp5c\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdVgsECzst2QKSkN1+fN2alJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjI0ODNlYi1hYjM2LTRlYmUtYTNlZS0zNjYxYjZlNzQ1MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjx17i3tawr/Fp2GgxuK+PeyfdLPui6ONJI62iGMUA8Gmw\neDVfHXOMFmwoQCO4zBAmxXfkKrtM4sF3DiJ73n3Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSPVs/FbFMWsbIMuTdPn5v5eg\ns8cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPBgDt3Fcr1eLkrzPm9EY6/j40aDcD2f3LdoEPwFi5CsCIBBkHK9dh1EW\nAgtbIlZKxFPSJpb1dG0k0jJuJnldDhSp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAUiYkYtbWlP6bKrCrCgTnM/fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI4Y2FhNjItZmZlYi00NmQ0LTgyZDgtY2NmMzU1NWVjNmUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODAwZDA0YjgtNzFjZS00YTUwLTkyNTUtN2Y3N2M2NjA1\nOWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHI5N3NiTUnx0qRK8m3htHmqW\nnYwjWTvlpKdr/1eg0KCgIBv2biOXHmClVNA5bT2+4XcnJnCHeYCzsh4xH23LNqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+3cXMpbmtipwufnC0fQXV6LGHbQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBRQbD4h\nuk6bVlDcxL3dgLOpU6EOQ5QsGQLg9g9ZvNLeAiAHNI1Q1S6hDsfoA3exTESk8zB5\nKQgzYOzUgrwLdQPhcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5110", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5110` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAUvru8mctPD4NRpUqwiysvO9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljOGU4ZDMzLTc1YWQtNGNjNC04OGM3LTAxODFkMWNkMjAxYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRhMmY0MTYtN2Uw\nNy00NmRjLTljMDItZTYzMDM4MWQ4ZTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC4L5PPVP774QzmVVv69Q0jfIu+IbF6yxh0uNvBztDYxFGnr0ATFj7gyQYoUv\nSta6d+u93GaY+xe+c7qwbiaLyKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMY2VnEWIc81Vau8p+uEY0YT5J70MB8GA1UdIwQY\nMBaAFJ2/o+Vhez06S2tLxQhl07Gs8GN9MAoGCCqGSM49BAMCA0cAMEQCIHLnGewc\nYJ/Lz1JipyGM5FTjy+sYT2rCsW9uzP6Sjv/GAiAqWaoe4ocF0GBC3Xg49/mFPrfl\nsX7KNJKcOLbkaaUV8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb1Z0wTln1RH+utL488HDUpLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzhlOGQzMy03NWFkLTRjYzQtODhjNy0wMTgxZDFjZDIwMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNEDwfevyOhlbIgfZAUlTdetZKmq7Vswqcf1k+RGSvAtes\naT/NSWoBhmryOhVyu3BupvjzbxWb8y8mSbBoP9cYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnb+j5WF7PTpLa0vFCGXTsazw\nY30wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOhWQC0I9PhT4l7EZi1DK9aOQxh5bLISbK107Z6LNeygCIFRhWJiEoVjp\nLLflwUUyhCVLPGhvUB+EifouAdir8smg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAX9m7tPMI377KHYH/JiFMzbqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRhMmY0MTYtN2UwNy00NmRjLTljMDItZTYzMDM4MWQ4ZTc0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDljNjllODll\nLTExY2QtNDQxOC1hM2RlLTBkNzdjYWFiZjYzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEAegHvpclwZEx5EfdeQhyEax0c6LWQcNaD4K9c1GspSGcvMiREgkBA6\nwOlJyLiK+0XHnCz5jMvHYko0a9YXQHejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMY2VnEW\nIc81Vau8p+uEY0YT5J70MAoGCCqGSM49BAMCA0gAMEUCIEetq0C6e4TxBlhKadaK\nyw0Sgfst3NBZNmMKY5guFU4CAiEAoyjLuCe622XwYzxLYxxu0qraIyELrq+L8plk\nQl7UjCc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5111", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5111` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVLmA1Sc7v1F4HtTlDzsPBZcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlZDEwMjViLTI0ZjUtNDFhZS04ZDU2LTY5YzZlZTZlZTNhYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTRjMTlkOTctZmMz\nZC00NDg2LWJlODktNmEyZDlmY2MzNzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk8YQuHS2mgk9SK8ZjJxRmvJ0litRXkCAbUZJP5xgu8PhlxaFQQzoyWeJUVVG\nPbhjoRQftr0lb9C9FSwO8CIJpKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOVNCLCZ8zqpgF9oU4Eg5CAQS7EhMB8GA1UdIwQY\nMBaAFDeyv1BExeKR1UCseiBD/3npMlX8MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3FSdwHJFOHaNcXXNmJT2RCn0C221pVE+\nGSUO+F+seTsCIHmaHVR7joDOKsMHOFitm+6Xby2HhPrxEEPC3Dh5gPO9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATHlQOW+s9cBPGPcLwdYr0VTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWQxMDI1Yi0yNGY1LTQxYWUtOGQ1Ni02OWM2ZWU2ZWUzYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYNaAZ7MJcm+qHDEtNiRmIZaLClQEzFEIPv/lZYp9ccb1K\nTBmMAEHyPBE0vRhA9wiQRtPDtI5rh+bCNC7sk5KUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN7K/UETF4pHVQKx6IEP/eeky\nVfwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKvNBAZFvUNaDBpb1Kboo50kp1JtimnujmAwnAq99zZkAiAFS78IVSya\nvBozU6DBMSVqIpVer7/7i9CE22GmyXwECw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAQFiPEco3IGjXoUi+/q611GRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTRjMTlkOTctZmMzZC00NDg2LWJlODktNmEyZDlmY2MzNzhlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM2Y2JmYmFi\nLTFiOGMtNDIzOC1hZGNkLTY1OTQ0YzY1ZWEwMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNZ3pY7E2IvKfZPlCQygpNwW4YlVuJihl7YvtibcvUikqq8ygDZZM6ls\n3O2hDVx6+UgSGHwAjMGfJwNZaZyRhi6jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOVNCLCZ\n8zqpgF9oU4Eg5CAQS7EhMAoGCCqGSM49BAMCA0cAMEQCIBw6b69CiVYewYqMlf88\nN+9e8v9jdrBW+ZI5FTQxxkGcAiBGBXEv+nm+/jX0d0ySgrOJw+BWlBgAEAu/qe4G\ngl1mwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5112", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5112` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAW0MWfS8CVRSKxenHIAR2jL+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NDMwMmRmLTI5YTItNGQzZS1hNzMwLTU4ZjYxYjQ0MzU1NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTYzNjlhZmItOTIx\nZC00MDllLThiYTEtZjM4ZjE1ZjczM2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETFGyskZqh72qhHjDo2SP5iDpjEpjzDOC34ejNZpdpFjPO7S6uGP39ZmSAtOs\nyIapcTCenBKuh1kav4IqigxCQaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFL1F0bkGf6q+sXkRumsEGAR0ArQ5MB8GA1UdIwQY\nMBaAFCqW/9aU3247p+zbbVnLBTDMrQC4MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEApJCNdpAtSGZAAorJpdjFxpP9B5U2iPvO\nGHGixnyg8e4CIQCT89/VRqbbsUIH9lEZbappZzoS6Ahb9lQLLLf97updCw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXV3lszqnHjdbKohGf1N5U4gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjQzMDJkZi0yOWEyLTRkM2UtYTczMC01OGY2MWI0NDM1NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRa4/tuqB5beF59zH29c/6EJGjs7mz1tp6/KMJGDsJe3Gk\nOUZUN6bpLISr5mjbm/IhZNWMokBzeuUbuIC05+Xuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKpb/1pTfbjun7NttWcsFMMyt\nALgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKsXCSgCY74lNHnDYyoBGjpyBaVCHZAjQ85DB4AhtGI4AiEAhIP4zVHa\nn2ZmiRCfl2jPpS41ZJ2CT16MqlAmfNwWovg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAQLdSKqUDY4pvmgiYnvfSnyxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTYzNjlhZmItOTIxZC00MDllLThiYTEtZjM4ZjE1ZjczM2JkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZiNDU2NmU4\nLTk4MjMtNDVlZC1hMmNlLTU3OTdjZjY4MGYzNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFvobDGI6jarScHVgTtl5Hbk8Yx8FVnC/Q/Pbz6zZX9JGV531nyxZk4d\nOEcxK8qqLffXbgPFMwGrn1W61A//0kajVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL1F0bkG\nf6q+sXkRumsEGAR0ArQ5MAoGCCqGSM49BAMCA0kAMEYCIQDkP+RTE6wBPd7vYRLu\nREH66TCnlOxrqxg3aBQ4cegkgwIhAI9Nq6YUiZdVfkh6EyfPDXLnk2qniqVcLRxL\noo3XuQhj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5113", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5113` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbaFe16xx1zJDZyRf4PjeEV1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0NWY3MzhjLWEzMmUtNDhkZC1hMGU2LTQxZjRiMGJkNTVlNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGUxNzU2ZjgtMjY4\nMC00NGY2LWFlMzgtOWQxNGIxOWJlZTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyDXPHsEBvxwOgRxt1FLHygDkExiCgNoxCsbTpMBNvCcJgtT41C7U1i0V6s3A\n9VYOw/9D+jfVXnIj6mlI9k0+sKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSFPqIJtaW3nzgYgrwCcVZctg4+OjAfBgNVHSME\nGDAWgBQh/pFrbhhVf2fghvTUIyAHkeNuizAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDUU44NV1pSkp5EfLtyC38DjJYb5rPU\nVPPAA14OXmZKBQIhANIcmuvnJY88+5oozOAf/ZyBGmXX4EHezJvYQM+Fm1Uy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWrsvKUwlgdI9qL4pcZbA5pRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDVmNzM4Yy1hMzJlLTQ4ZGQtYTBlNi00MWY0YjBiZDU1ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9//hWz6DJD3td7N3sCYvApV8L6iVJuiZZfbdZXy/XjIjd\nv+luO3UfiMIKo9d1ogLuszXH3DSY5tJ+Q6BTGkq3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIf6Ra24YVX9n4Ib01CMgB5Hj\nboswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ90wT+055gzwhmd4OGVMiAQ4BukivwQwyTAxmZPG9NMAiARCQndpAmJ\n9TbCjyciPs2DnVLEzNfB1UE5MRwFhw+J1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAQA5JNR2+TMkYIp5eFTdr8lcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGUxNzU2ZjgtMjY4MC00NGY2LWFlMzgtOWQxNGIxOWJlZTgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU1MTliODRk\nLTRkY2MtNDJjYy05YzUyLTI3N2FkZTE4YTVhYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDduvYn4uVkyMKGww4CbzJX2a+t4fA1wGq+kodwiUB+W8hlH/nGNeUsn\naChZxlw48I+Wa1ZUlY701P8HsJ+wA+CjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIU+ogm1\npbefOBiCvAJxVly2Dj46MAoGCCqGSM49BAMCA0kAMEYCIQCzp54wcz7zR//sLxfd\nlyAAarUVXVTc+8IVqSoXkyOhJQIhAIv9KcU08rugA2YCORrX8sUVJjx5kPgj0arY\nHXNuPple\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5114", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5114` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISASG7236Hj+hWeiggo4NlLPNnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhMWI0Nzk5LWJlZDMtNGRiOC1hZmVkLTM2ZTFiN2U0MWNhNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI2NjEwNzItNDZj\nZC00MTczLTk0ODAtNTg4YjZhOGM0MTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0RAZY/0J+ht0sM+hpLzDgciirnD2Jb1QqT1G3oc0/nwMGyUJSlY+TlJXr96z\nhgJyEv5DBX4JaXCSXt3nG0o8/KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnpPMblkzaTawDbRkHOBn3BXR+8owHwYDVR0j\nBBgwFoAUX0P3OzBGYbVBMyWI45AuHtO/LoYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAjTQ+rixCi3DY\nz4uZY1PhQ56embFyrUW8ytuNzpwDx3wCIQCp7E0aJLgwwivr4R+iU3umJHvW/vmr\n+5tNTvYHlJaiLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXPPEWHfVse/hTQfRsH5NO9pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTFiNDc5OS1iZWQzLTRkYjgtYWZlZC0zNmUxYjdlNDFjYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4RIr5m/smbB77cwMuS4ROiFxYfbL9M+LYVtUv78QZwXk3\nO1qPNu+2hg/OR21Cp+2vYduTlszEOfg2/OkkpOBPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX0P3OzBGYbVBMyWI45AuHtO/\nLoYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMXY0yJINFgsoU/1vVU3RDbdl0jg4ed/HHa6HD+a6ssfAiBhQkWVtouD\nbDIsP/uYqHWGtWq3yGtQJV8NepbPqN/Z/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAcQImkFxP/4GfdwLfRI3j62GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI2NjEwNzItNDZjZC00MTczLTk0ODAtNTg4YjZhOGM0MTUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVmZjQ4MGVm\nLTgzZWItNDQ0ZC05YTE0LWRlNGMwNTI3ZjIyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFEE/SzwZIbrZyDOhnipzQbyOii+m+QLz/h+SqrTXFZ60Q8WMGQeYk+E\n8Z4o0iLxIYykpG0R54546Fes5vC111yjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ6TzG5Z\nM2k2sA20ZBzgZ9wV0fvKMAoGCCqGSM49BAMCA0cAMEQCIFpZAJPCGgk5E6ZvTmWH\nipQLW+jd++Ok0xsAZIYghijTAiBg7j068jgR6JnS4NBZxou3i+Y8tK9wsN8QLK9B\ncnZVsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5115", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5115` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAY1qVcWFosuPxAK74d7+HZM8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyZTBiMDg5LTU5OWMtNDVmZi1hOGYxLTljYzc0M2E2YjQwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZhY2EwOWQtYTU4\nZC00NmI4LThmOTktMjYwM2E2ZjA0NTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKOAuu+Ji64bKa7oOdJdGediGtuIbVrhbeMV803nxdC6EPRLe7sDq6/LjbCcQ\nQnbD/c2er4ppxK9Ef2X4B+tl+aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURvjmuWpzUY5V3sP5o3RwRLDrrO4wHwYDVR0j\nBBgwFoAUaYBVyEpjZsIzH157o+zO/vFM3PQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA2qnBT8X2zXrE\nynTjDpODPZh8E+Xmo1Qx68eJ7rhCJa0CIEUmLLWnD80oRS5+bRcvBOUORrqoxHrd\nYV2bC5WOPpzI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASCs/MyUS951OIVJEE66fYzAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmUwYjA4OS01OTljLTQ1ZmYtYThmMS05Y2M3NDNhNmI0MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASg98ke1f85fucC9oAQ0LvzkgQXuphvODf7QKEnqf3f4x4F\nkzskWdHN69gLGwwhDnMWxp1InITAvxq9Xk++HUmvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaYBVyEpjZsIzH157o+zO/vFM\n3PQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQmQIIJdBaWg6r3k9jGsusAgIUCgh7F2hmUfGkwr63aECIHH23hhlAQzp\njzRbM+Ahpc2gl8CoeQ4ueBFTv6wDKzpd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISASoj5tRsuqRFg/RhrS2gZGT8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZhY2EwOWQtYTU4ZC00NmI4LThmOTktMjYwM2E2ZjA0NTlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJiN2MyZTcw\nLTVkYmQtNGIxMy1hMTJkLTA1NjJkNDY5ZjNiMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPXYldRwmGLUStjWfShZDrnetafLOF6nqUl9gZDSXrmWXGUgWo6HErao\n6et6IQVUJaLj6GxPCCZlGarthMR5erWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEb45rlq\nc1GOVd7D+aN0cESw66zuMAoGCCqGSM49BAMCA0cAMEQCIDAfWZwxLug3Wyl2fZ5S\nBSk0S7yC9737HudnBfNykPGDAiABW0VCkdKEPb4/m/bOI9wAVPcbflDg9Qhm0DEO\ns5Wirw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5116", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5116` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAan+UtEHqdzeSLc1M87Tu6HKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlYTI5MTZiLWI3NzItNDVkZC05ZWVhLWE4OTYyMzMxOWViYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRiYTgxYWQtOWI1\nNy00MDRiLThjYTMtYmE3OGRiNjM0MTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKrugAbgfv6qkFKC5SKAIvFGjLa3Om6w3fsRfhmidOWvDcDGN+hJ+vs8qFFrD\nqtNuvqYGH1IrB7Ie515KUhxM5aOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQiZ3kZ0iIrxxtPyqW1v6xGMhuOgwHwYDVR0j\nBBgwFoAU+biLVAnzQAfRCuW3MMzR17SueJkwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAni4b+mU9mIqQIBxMmHii\n6YcBWO8PWsTWxCSqvaCnBrECIHOLUOIsT62zXeLuBcQZZIruSwijjG2NAIL6JOIf\nNZIv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ1Vlq3Kdm8TgheUwxT7/TWjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWEyOTE2Yi1iNzcyLTQ1ZGQtOWVlYS1hODk2MjMzMTllYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScKlRfG8g/eTI0lW+wnh1mM8FGpZAxBnosvvQ6qvjk1QP5\nwq3BdCz5KiOAehw6qjBVJyhmwV7Kh7dVq94/nuLYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+biLVAnzQAfRCuW3MMzR17Su\neJkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIeQTAhNJmgoaOlz+P72iV6Hi/suSbaCKGd1OAoumSnOAiAOutOM61KQ\nK1U9vTcjuMIQBegVLmT1uG5vrhixXXSclA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAaGlk/X/O68UkgTfWDlAV4ixMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRiYTgxYWQtOWI1Ny00MDRiLThjYTMtYmE3OGRiNjM0MTJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFjMWI2M2Vl\nLWZjNDMtNDdlNC05MWY0LTc0MTljZWQ3YjMzNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ6BA6Wa77hOQvwHzS2396X7MoIuKofzgkfe4VffReYIT7RIze4imz5T\nD5GS5bnTPO+TIhtR2lUABRRXMJS+homjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEImd5Gd\nIiK8cbT8qltb+sRjIbjoMAoGCCqGSM49BAMCA0kAMEYCIQCTYrvN10XgGtpYBEe1\nxfd27AOTI20LmO6UvhiWEq699QIhAKEJD2NZpKOw7VrFhCrI+GRlFfRHsP7ZKvFl\nEsmDsXYI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5117", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5117` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAZWjcSGCIckJEbbKeKDqnHGDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3YjAzNzYwLTZkMjctNDYxOS04ZTk4LTVlYjc4NGFkMmM0YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM2NDU1NzctZDQz\nNC00ZjkzLThlYTctYmY4NGFkMzY1MWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFJG4k/G/T/nq4kMLo8NJs+EcTzKtPQOsDwihL4Hh6MSi+vD0GfU7YpfiZnGR\n8fnxkMbwfUubJuvItyOQ4Jp7oqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUphGZPrFsWXhrX0Wl4tVH6D35ymswHwYDVR0j\nBBgwFoAUKYYwf3E/+q1OJ9rqzqOR0ob/Y/4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBuT+uV\nJz9nUB6h7hUK/hzmGCl1a8yhOuVOTfkjK9/qUAIgfSVPsSW3pgsy8VT6iaeHFsE6\nVLth1dMKN0gnpHf5Hh8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZpvJtPN3rcjz6Mxi4xT9K/TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2IwMzc2MC02ZDI3LTQ2MTktOGU5OC01ZWI3ODRhZDJjNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQW9rRpPzEbab/q+x1erEybHZ3bKY4sffigJ3+wZ4kc/q+m\nbudJdCjZHs6OMPxaS6Dpd2eMzhLSfJmh6dHlU0v0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKYYwf3E/+q1OJ9rqzqOR0ob/\nY/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPMdETG8nDAO3XdrvY81me8AGgYZnbbxf6mIvpjavcUZAiEA3llVqj5Y\ne8QfDT4tsbJr/r2cixyLiq8x/bvIvcbWhBA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAZEn6Y846jw4SQH/UH4UJ+p3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM2NDU1NzctZDQzNC00ZjkzLThlYTctYmY4NGFkMzY1MWZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE3NjE3MzQy\nLTk1MTctNDY3MS04ZTlmLWY0OWMzODFhMjA1ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC1WNkQAE0LqOXrzJTSLQdHhSZuAFYaLX8U5XAUERLXQ5DIRBvdg4TNs\n4PWfS3q7R41ZVbEjGVHCGGvGRyOAkpWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKYRmT6x\nbFl4a19FpeLVR+g9+cprMAoGCCqGSM49BAMCA0gAMEUCIAR8DjMVg/50Ex/lNwNn\n7IZsxN+jTBrYN7EJJO75pcexAiEAzWjv5lv1bnq0DCgJc5PzKCew20/vsVOil8ZZ\n0KvtuYQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5118", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5118` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISASSQVRBpLfZWIApajRFYA1dQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlYjliMjIxLTMyNjgtNGI3ZC1iMTljLWNlNzdiYjBhNDY3NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTIwYzM2NDEtN2Y3\nMi00NmI4LWI5MjYtZTdjMDgwZTFjZDhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnrVdxWNX91yeTr6uKoCS/7gwa/D7jVxnoz6MXONOM+/kBHMbhRudM74n/hut\ntCeGP6ji8D+JYNiez390MDsXfaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyzqPR7vz0MufrDEIMPLRIH9TQEcwHwYDVR0j\nBBgwFoAUXFCv0fFPuUZ7JIxpzhj9Hwzcl64wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAnRZE\nVhspLhAeRu/BiBZkeUgWt5fp4zhE0C8jQN59LhQCIQDMHPHq0lPL9A+bjGgN05f8\nSKe0Zq8EXri/J4AXURh4LA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVjuofKWJEy49LaIa1RXGtPNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWI5YjIyMS0zMjY4LTRiN2QtYjE5Yy1jZTc3YmIwYTQ2NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhATwI4nil+FCHjl4V3PgjnOu3mG+TpM1YDAfqk1qeKkr9\nQr5wZcTin40kAyItc0wNdV/3SaeGH16RdgBPfZzho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXFCv0fFPuUZ7JIxpzhj9Hwzc\nl64wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANfZa8+f5nOnCiWOkcSxdVER0mIjYvH3gzoQRhsxzcdlAiEA6wUx0KMW\nJfKNyospTGsEIiShu/UHaAheQ/RAkpoYojo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAeLgmISKulhRsCaTdRMDmbVkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTIwYzM2NDEtN2Y3Mi00NmI4LWI5MjYtZTdjMDgwZTFjZDhkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFmMzYzYjhl\nLWMzYzktNDBjNy05NWIwLTU5NjNkMTRhMTc1NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH+Enzd9u658/DdIMPyIDJIB3Q8a7+cDxF5jNYKgG2Y4e7IPyIMofftA\ndkJONZVLVq+xoydM3WwGmy9ooAcPVDyjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMs6j0e7\n89DLn6wxCDDy0SB/U0BHMAoGCCqGSM49BAMCA0cAMEQCIExH6Mda8dGN0xBIX6lZ\ndbXNLsoPDDQK/ThJzzsRqSDJAiAdsddr+bf2tglipEGLSZfaZ6+Ebx8BrLaXWyKP\nnq7VgQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5119", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5119` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAetqhkaIq4jkzu27W9E2cKdbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1ZGIxYjRlLWFkNWUtNDdlYy1iMjM4LTI5ODgzZWMzOTI0NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E2OGQyMzktZDcx\nNy00NGFiLTkxNTEtNTFhZmU4YTAzYmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiRhGPPpOxNB52YFMZTm5b07Ww3/MhMNFVUwOV5p8hgVw9uFeYrbr5VdJ7i/I\nUcRFs92tECqkTC7qvyZjBQ3AZKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFETissYfK740FBs62ls+foie02BHMB8GA1UdIwQY\nMBaAFF1ZJl18OT5JUD/YL1fOi4zvrNHQMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAk4UMF9zXBv0o2RHb1Ew1Is0BGshNdDlrM\n25YByCgQtwIhAPyd9soDoukRJXCje8Z4GCOm3GBJVi5V3YMQyqBp6L7r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYFqQDLrSUk++rNxuJ1j9nuIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWRiMWI0ZS1hZDVlLTQ3ZWMtYjIzOC0yOTg4M2VjMzkyNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm3WXfe3AHg4q0rgJXn3uFu6b+yaeAdApklRUITlA9l6lg\ng/I2/1/+HMVcc99ekV3x5ecFuT9Onu3NroRB1gC2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXVkmXXw5PklQP9gvV86LjO+s\n0dAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMmKG1x9DsxaPEN5JHJAXd2qU8Eb013MjNLpOZs0PSq5AiAuTPnIkOOm\ny6uD/fr9w9MLge0rLsx6JHba+3B3/FoSDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAZlq/YdjYYTGIps3wJWqtWR+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E2OGQyMzktZDcxNy00NGFiLTkxNTEtNTFhZmU4YTAzYmVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFiYjEzYjE0\nLTJjN2YtNDFlZC05NGNmLWRkNmU5ZWQ1YmE0OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMM3XGrnBBlOKX27UVbqi1tpyR8T6XVNZfReTOV1YQMt8ACII+cKG8WZ\nLk1Nzw2ep04F//WczBWrt1Nd2D4eVbejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFETissYf\nK740FBs62ls+foie02BHMAoGCCqGSM49BAMCA0kAMEYCIQDag4qQkYmK3x4IVxWf\nJNG0xpNrOPhiXfMbmixeRP6UrQIhAMETI8kIqzrjVjC8mxVn6CtmUVQGYCJqv2N8\nGjZr6V8e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5120", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5120` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISART3Ay9IlymZ13S7Z5MXWFTMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmMzU0NTVmLWM5ZjItNGRhOS05NTM2LWZhMWJjNTVhNGIzZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg0MjQ2OGYtOWU0\nNS00Njc2LTlhZjgtMWFjNjE5YzY0YzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzBD3mt1MuC6EOW5zB+YZ2/BYA0uzd5S5q31XyOG2XHasXsHdJCozXrYiQM+0\n4xN3KXToQYLmlTl3X12p+P8JqKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsldNqs5lQjWQGNlbEWtQLqamM4QwHwYDVR0j\nBBgwFoAUMHoR3TT1AqAiuxfNPWR2bIVut0EwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgdyzH7+VL3/eX\nzA6aRc6czYww5OWvw5Aq0plFWdquqnsCIQD1MFdZDAquIUfKm3TiJaetRDRxXF5U\nTZ8dpY8dClDnpA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ8uc/w4akQQhgjYC8AVcn8tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjM1NDU1Zi1jOWYyLTRkYTktOTUzNi1mYTFiYzU1YTRiM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2wDBI/bU5DF2tnyi2ksl/phPRbDNt5U2W5BzYO4y8Btne\nNTKmoaI2Nb/9bvIfI1qdpxDniLZsefpWH5ZKTBLCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMHoR3TT1AqAiuxfNPWR2bIVu\nt0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPA3cgArRc2tvPZJU/rAFdnE9miiDtyDV0UyjPhcfqWlAiBafUWXijmC\npaPZHPzsW9lgA4vk9t9UbTdhwxeVi6CxHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISARy3PiZEicLqOTXWrugkbCMwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg0MjQ2OGYtOWU0NS00Njc2LTlhZjgtMWFjNjE5YzY0YzY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVjOGM0ZGM0\nLWFhODQtNDdjNy05MTQ0LTRkZTgxYzNkMjExNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMjjN5dbqyyLhgmcKkdP7U1juWQem9k1bVq5gTbEUde7wxVZ9J0U3x+j\nXIo9Pd4+eWbFvTMFDOORCJrSX8jz10qjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLJXTarO\nZUI1kBjZWxFrUC6mpjOEMAoGCCqGSM49BAMCA0gAMEUCIQCdihwFEg1bg+AtQ/vg\nyf5UQ9lVv4uz8MlqW27wJkUpwwIgNe3XED8z6Y4l2KQRaTJQ8GDWe7htktNQDUu6\nLztHk4U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5121", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5121` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARe/3iRCliWNje0ZR1cVdgT1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwNmUyMWI1LTZhZDktNDFlOS1hYTdkLTc3YWE2ODc3OTVhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJjMmQ0YWUtNDY4\nZi00MzBiLThkYWItMjMxMjZhNWVjOTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgaaXFRPWqZqAbUBephjrml+L0hONQe9v0JZGzmOk4IOARJMip2dFEk/Ux4RA\n0wMh/V9tsTlffaKEgQmNcrVQi6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCVlNLysnKy3ysabK5DlNLY8gezEwHwYDVR0j\nBBgwFoAUXT1QNmQXFrbdIwiWQ4H66+U6yI8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgJQ0+eiNnxd8x\nCH3ICH+0CBz7RL+Epn1eN/kLbZMHci8CIQDwEXZaTCaSZSP2XTd05Za9c42Je3tW\nQS6+aa8YWLFzvQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYmSl9d7q7rzyOmyHCH/vYTZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDZlMjFiNS02YWQ5LTQxZTktYWE3ZC03N2FhNjg3Nzk1YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJa4+UBaBChmoUYCToB3kVP/RkZGzyv71nGFcTB1Laq/Ac\ngx6dEnQRg3McWgPVHIgTJS+1oWz838FF8aGz9WvLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXT1QNmQXFrbdIwiWQ4H66+U6\nyI8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ4fX0o2zlv2FCcz6L6609cG8XHMeYEBi6KcJyOMB7Z9AiBpkw57iy3J\nz8pgTRPyas/d+vEDs6Au21dhsQNJV8FRFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISATTqGPK/JKdlEq9b3T2G8tjKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJjMmQ0YWUtNDY4Zi00MzBiLThkYWItMjMxMjZhNWVjOTY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcwMWU3NDhh\nLWI0OGQtNGQxNi1iYTdhLWJkMTQzYWRjZDZmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMu/HigNtEMDTDQXmM+AL7Xm15PzGKKZmvmOTES/3pM18Lh32ZyWvac6\neoM0O7PUaby4kNvAH+345j8AM+jcUjCjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAlZTS8r\nJyst8rGmyuQ5TS2PIHsxMAoGCCqGSM49BAMCA0gAMEUCIQC+UobAvuo1EgSMz8Y9\nZ+uelWmjW5Onk5MdbC+a2k9KUQIgJ342RTmLPGOw9gtE5IqXKWhGOAfumUDmm2Sh\nKGeho1s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5122", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5122` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAdXFuRhyOzGsGIfNbW5nxfL+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5NjA3NDk5LTFiMGMtNDc4YS04ODQ1LTkwMzgzMGJjNWZmMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE3MDRiZDItYjRi\nOS00NTM2LWI4OTUtN2ZlNDFmNmYzODYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwYoeGVb0a1URD0FiX31Uw/yE3w5hKUCuR7IBSh4di97/6XuGWCCghdZRYmJC\nAym03cNtimGfovG+KzkhjEeKgqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUdNtq+hBA0uTGgV6SAmBSG9aAgQwHwYDVR0j\nBBgwFoAUvUtzf1WbB+/jOh3muTjEBtkN9xMwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCyyYPexHGi\ncHK2HVYPHSzQMXItpS8+RXLlJvQpp7uplwIhALygOLFr2qTJvfKbTMjkPA+BmEmq\nK/q6NCt+FryBM9TK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWXZPfU5LgoGNr390gmsWGueMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTYwNzQ5OS0xYjBjLTQ3OGEtODg0NS05MDM4MzBiYzVmZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRsmqbwpHYtVOGsZ3YYgh/x7qtFRqnFWrkftuNKcNIuwBs\nEyx7M0dMJzAMDNdPo88b6cMuq+CBnoHyDf+Yybv2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvUtzf1WbB+/jOh3muTjEBtkN\n9xMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgckcJbSUqN7/hNntF++SGqmYT8cA9NHPmM04qB8qLahQCIQDRWX/5M17v\nigYYhzszGb6gFN9Byj7kZetb3x3YzmJDJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISATgEvoJ6Wee38Qrotp3qA2WzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE3MDRiZDItYjRiOS00NTM2LWI4OTUtN2ZlNDFmNmYzODYxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg2ZDIzNGU3\nLTZjNjQtNGUyMC1iMDRlLTgxNWRiMTMwYzU4MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNhJoN6jbPkOFvFTV94l0TuMzM54GUrce6Os21a5eK2mW0xNlewhTb9P\nAw6L9+fTUFuLCMckWDdKYrT7GCY2hk6jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFHTbavo\nQQNLkxoFekgJgUhvWgIEMAoGCCqGSM49BAMCA0cAMEQCIEiL2t4ITtzJScU1lRFA\nYQBAqs7uNSNtXzwxMmAg2GL7AiAFNQhl6VTZN6JVjP5pNkoqs+BiyCzsvPJ3Y+ij\nJGfccg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5123", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5123` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXLLpgGulJt1qonGpNC2Y4oKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiZDQ3OWZiLThkM2UtNDVjOC1hNjhhLWU1YjI3MWM3NzE4ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzViYmFkYzUtOTE3\nNC00Nzc1LWJjMGUtZDgwNWUzNTVkYTI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE160cpC2cBML9yghrdgeXwkuIM+dARxL/tqY6cxBxpJDeaYYGtQ+3Dnyv+bA6\n7PLDv4o0K4L3pSf6hM5UOX5nIaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUboLk5yFp5PIiAORnfcx6kIu/tGYwHwYDVR0j\nBBgwFoAU2ix34mqsxh999SAUNVtlT4ROSpEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDsDJeQA/rBBJ9RKpn06TLYJZqE6Q0W3sqG0zZmcBr70wIhAJRcVv61iYcr\n//QNzrujjdEfVRIbew/HnGwbQ6OOBb2G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaGR2tzSoWJ1nkA4xZiT7NI7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmQ0NzlmYi04ZDNlLTQ1YzgtYTY4YS1lNWIyNzFjNzcxODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASE9Yyt4zCgC3y/pBMEQRFO1Pu/9bbpcOb/q9oqCcLBlcsu\nawZHZh2as8+fJi2lZVQRnrBhFnPXWuGeXOQGob3ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2ix34mqsxh999SAUNVtlT4RO\nSpEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcBc3v36sxCEu0Dels4fgveGJqMN9sQ1DyHE3TD0Mz84CIACfLBweoZfv\n5fpVwSGERiQ+PSd2kkqMw95aQTfsxxfl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAf51H7aw8X548VW3fXLcdn58MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzViYmFkYzUtOTE3NC00Nzc1LWJjMGUtZDgwNWUzNTVkYTI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRjOTNmODhl\nLWI2NzUtNDAzNS04MWI3LWIyN2I0YzNiMDQ5YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJPgmmbCpF8BIzIV3PLXK/pO+s168HVEhW5jQ/k5RvtPajztDgUki0K0\niQNYVOJmIMk9Xx4AAf02m/Tcr1krM9mjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG6C5Och\naeTyIgDkZ33MepCLv7RmMAoGCCqGSM49BAMCA0cAMEQCIEchh0UVtkOwS2VJmV4P\nE9+EwbUXAFsryol8iyzAphRtAiAe1ob0OB9hkMxfx0E3H68E3HybcNvaWmUcd8yk\nQuI/NQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5124", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5124` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdgp8wYD/z8+9g8dxFbPpAYZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjZjhjNjNhLTE1YzQtNGZiMi1hZTg2LTNiNzBmZGY2MTQ2NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg5M2ViYmEtZjEy\nNC00ZTNhLTgxMDMtNjAxOGJhYTgwZGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKfZrLiR/ynvx+EdDabBc9rSxxXnS7k+Lvb0XTnQ0hNq+j4ShP7j9tehT7Dqd\nHDQwQkhhavnRLAbTMSdyEqyEIKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB3YEyc81ZilIdJlyu+yasHZY54swHwYDVR0j\nBBgwFoAU6rhRaLa3dGi9OQmYQXZqLZjh5XEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIQC1UhpQ7TIBb7D0s4/l5J3t9CQm2V7tae+KEA4shuLirwIffweFhaEDEeRS\n37nSnJhyEQRUOXoGSXalSnFItmc3TA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcX2PE2pno4FPulMDdB/aipAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2Y4YzYzYS0xNWM0LTRmYjItYWU4Ni0zYjcwZmRmNjE0NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuFGfSgQ8a9WjYtG86rwk8A3jRY1JoRRSw9OZU17u8J+++\nZxxyysDG0IrbfM0yol/7xEPk+KuAC/3fqlKFwjxvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6rhRaLa3dGi9OQmYQXZqLZjh\n5XEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTgJKbK4iVF54QUU1XCgbnSLpkJcLZ7Q4V1KKrKazYjMCIQC6ErDfX4+3\nSMLtMpL/XQ1MOwCTk4VVhxRZiiQ3PhcWqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAQ9vovWXQHAfYt0U27IuODA0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg5M2ViYmEtZjEyNC00ZTNhLTgxMDMtNjAxOGJhYTgwZGIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhhOGQ1NDM4\nLTczZDctNGMzNS1iYWYzLTg1OGFmYjdjODU2ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM3tMZt8bV9Ws2zo6FOr6H47Py89hjrPWa32SZFplVzf+5okfXk9QXVo\nf4DaO1plslYwplNxP5DGCDIQnt1ixdSjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAd2BMnP\nNWYpSHSZcrvsmrB2WOeLMAoGCCqGSM49BAMCA0cAMEQCIFyN8RWzDjVnNA5Cj62k\ns6ObatXeiCuYwY6ZTVOFTLq8AiBVW80wnyX/mVyHtQBMoa6e+6GXKbQsBunffSJ0\nPYNwQg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5125", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5125` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAegH62IL1d52g3/K0PsBkAutMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxNDQ3OTg5LTkwYzktNDk1YS04YWVjLTQ4Zjc4NTcyODM5YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI0OTliYTctOTRl\nNy00YWZhLWE2YjEtZGJlOWVkODdmMzZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFpJjwfDP/ffEt+wd6GhtdRPQh/E1uorFGJ6VMSXwbzP5l9wGsW6ABxBP4fMx\nQMS+3ytDQ4T8amIwfD7eeSqQ/aOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURGMu4a7v9c1A+H+xV61h2aZCS4EwHwYDVR0j\nBBgwFoAU7ZRpvkb7MwomDP7aAHjVPVfU2bcwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEY9\nwq1ZXJ3UMy1Lin/5dkXoFmXGMqTlI8P9ccIRwxgIAiEAiEsvZwx2BjLEhvMFM8AB\nYFz4t9VVajKJKQhj7DJLby0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAatLhtrGRWba57+IGfHcTwdcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTQ0Nzk4OS05MGM5LTQ5NWEtOGFlYy00OGY3ODU3MjgzOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTbAvaShLPsYw9PwdI6eglhfSU7YbNa3gJj9sXjqiGwQpZ\nHR5J3zAVLnOLGFrD3fmhjbUA1N5XLTa1w0JVxyAno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ZRpvkb7MwomDP7aAHjVPVfU\n2bcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQMGTMoK4nxPbOZqF5wJgQgQ6TyDETA8jgZERDQK7M20CIQDDxYJcJCJ9\nUDCsJwxADQEIFmbNm0V07Cj0BJrrAKDKfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAauhdWeB15gbvB3QBn4hLAf2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI0OTliYTctOTRlNy00YWZhLWE2YjEtZGJlOWVkODdmMzZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ3ZWMxODk5\nLTIzOTktNDIyYi1hOWQ3LTEyZTZkOWFkOTQzMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCjOZE8GV923qAmTIyfRgjF79GTecGwWU85AuCPr3Vv1qzWLhlJsX96k\nf8BegK8R5wAHSSdHL7DeSo6Mimy/0+yjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFERjLuGu\n7/XNQPh/sVetYdmmQkuBMAoGCCqGSM49BAMCA0gAMEUCIGZu2Wj1wFb5brVfZxxd\n3PtCeccOprx6Bad/OfKakusoAiEAyIj21U5/egPXPay9KPe0FXWivY1lOomuAd/C\n/vBmU3U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5126", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5126` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAXQ10Idg+uzQEgIeTo0eAxn8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwNzExYmM3LTkxZTQtNGNjOC1iN2YzLWIwNWU5ZDI0ZjgwYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWIyNDY2NWUtZmY3\nMy00NDJiLWJkMGQtZmFjZDA5Mzk1NGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERuX/hP0KEH36aNCJku8YBqYxUW4rM5/rpiBpZWfaCtcm2eufJP/KY1aH/Fiz\nnQuEpxMs1kBxm+7iP3XOuzBcYaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCx36oPikpKeXoUlxxcTW7bZkE4QwHwYDVR0j\nBBgwFoAUhDBHEmu/oRF05SZwwAgK9g/k0vkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBW5PrF/eeaJvHtpXwGexfU5mvk5a2i983p27xi+KjQKAiEA4GWg\n1feuqu2KP8SaCfz9KxImWxXoz27E9snNtgLGlq8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAThS9Ng44PISSLgN7zXY1h+oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDcxMWJjNy05MWU0LTRjYzgtYjdmMy1iMDVlOWQyNGY4MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR83fcD2hz0cWCoVI1BYG0MTAEeOx3NqlGitV9Y8j+V4tRj\nXKH1F/5oq8t3HtYgE+aAJWhcA5sjTMw9XgFqe/5Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhDBHEmu/oRF05SZwwAgK9g/k\n0vkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfd5DS4Jx8euaTRN+e+diKcZThto+PQESY+Z+tSdtejcCIQCXl78mgSXn\ne620JzHeiDboyZK5bEM/iuDkz1rZ4nBYAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAT1t4gTpTjyeS6IEUbu/+Dt/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWIyNDY2NWUtZmY3My00NDJiLWJkMGQtZmFjZDA5Mzk1NGY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNmN2VmOWMy\nLTVlM2ItNDZjNS05ZjgzLTIxYTFiZjExMWMxZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG3oWyyn3aZQPtiKVtNlxxrxurXLSdF3pT0ArBFFQZb9Vizwzf+Pe4O4\nWgsadbfzMD/8dFvo3WSERrurwyrMSq6jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAsd+qD4\npKSnl6FJccXE1u22ZBOEMAoGCCqGSM49BAMCA0gAMEUCIDYOdn9TgjCvnHupcBBt\n2N375im5++FvrQbTPo4Q8ZKnAiEAmUsWbh5NT/wS+zO7IgI+6pzKE3sTaaAaiv72\ncjZs0Yw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5127", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5127` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAeZYYeZ0sbhD2/gz5RDsXJ+xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ODRiZjNhLTQyY2YtNDY4MS1hODE1LTc3OTNhZGZkMmQxNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI4NzU5NzgtNzFm\nNS00Y2I3LTk0YWItZjc2ZDcwNzcxZGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE18URyye0RCY1pjmp5pTugxsQKFoNdIiUgG1seJUYOsq0+mjak2ktULn4HjkP\nQ4fi5qK0jNmeqBoqcB9PpNj8raOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvDmDYZrS7r+HVyU/IP0wnVx+WTwwHwYDVR0j\nBBgwFoAUqqh6nxS90muqFH5hF8zq6TrT1fIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFUPindLvW7Z9oHazoKm9z8D7EnFglMgHMggDLmaC0DMAiEAoayh\n/BkQP/NnhYH1RATmOYRdIuR0HgMLn9A08SRBIeQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ9kpRKWoxbrjf1Xdp1XL89SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODg0YmYzYS00MmNmLTQ2ODEtYTgxNS03NzkzYWRmZDJkMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsbfZe07cErAuInNlSTtzA5inyTBv5FyIQNCTTs0Du/PDV\nBJQKnvZdsNZUGQcyp5/E204f+S/av3BG5k3TRLj2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqqh6nxS90muqFH5hF8zq6TrT\n1fIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR1toAaCpkjfXsU1R040nYkF1EkiwDdecZBe1IEuz9FkCIBGoI7A7z/aC\nYxeoeZilUmQTAIuzn8ExuZvjTFrlYQcg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAQkmdYEZ+9B4Kew6fsKbrxwzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI4NzU5NzgtNzFmNS00Y2I3LTk0YWItZjc2ZDcwNzcxZGFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1OGRjYmY2\nLWFhNWUtNGQ1NC05ZDc0LTM2OTM3NmI5NjkzMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB/GD4UnijpCa6p8CmMlX0T4x/MUEwlPUWhT9xHuKmo1PnAi3cnQVcP2\nK1D10+qGJ1KaAIeXvNrW14g2k1kLH1ejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLw5g2Ga\n0u6/h1clPyD9MJ1cflk8MAoGCCqGSM49BAMCA0kAMEYCIQDD4FsDiXWyIvqsNL86\n5yC93q/+339tBW4cCeaLFu3YzAIhANYfJYLGFDCoaNISXSgJyzTjbem8n3JYQBkx\nP8tu0u+m\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5128", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5128` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcRtnoz3WGKysmNy88OPPi67MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5OGFjZjM2LTI1ZmUtNDZmNy1iYTk1LTVhMDc4ZjM0YWE2YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUyZmU5MzYtYmMw\nMC00MmNlLTkxMDUtNzFhZWY0MTc2NjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn0EUNneTz/vPmzji3Lstqj8W/FcWTMh8+vnp46+LgbCY7DQ0fz1qh7I5izUl\nzkRPeGIqTaaWo82TOmfQQX81ZaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEixUsz1GnK1xRtYnqjF+QWvckbgMB8GA1UdIwQY\nMBaAFJ2sFj/4+VPt8uBIXWCeONmxTrXbMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAnTDJKboMWuXkGh8o94AoieAT8PNxklyG\nTYWdcJ8uNDcCIFJOx+tV3bkOU2U/hSdgSyt4vJv/0m2+HvY+r7IqbN+A\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAarK0QqYgSZBzeX/66VQ0qTFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOThhY2YzNi0yNWZlLTQ2ZjctYmE5NS01YTA3OGYzNGFhNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1TITIohhsOjPMxYBZwL3ZHIRkpWRG2LDoJTCoDVd6gh3X\n6mZWSb8MDD1tkpF1HsV+2TbzYKJkjB5Rd1OqZs8So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnawWP/j5U+3y4EhdYJ442bFO\ntdswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHJW5FEVugTS5QEjXuebZYm46z/yeVI9EWuHXIabUyo8CIQCoP88MvaFV\n6a79MagLJKHFVbqu+/mJNnEPNQ4CfgSEYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAQpDqmSXMo4nXFfmDdBbXPhVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUyZmU5MzYtYmMwMC00MmNlLTkxMDUtNzFhZWY0MTc2NjcyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk1YWNiYmZk\nLTRlYzItNDhlYi05ZWVjLWNlYjkyYzMzODI4ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPwE/SFjm0hbwZcwnUU8nHaFx4/CBCyXZPSCqPe8D0y50mtlKNoBlyBn\nO3nTIWzQBuF+Pa56X9SGdTH7rFl4VdGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEixUsz1\nGnK1xRtYnqjF+QWvckbgMAoGCCqGSM49BAMCA0cAMEQCIB3KfuhmtykRi4d7mMP8\nDNxAnOTnSkHGJT8ngQAebeydAiAdV5zh++WFfou+9BO9ZwZFlO/eipQr5MM2GXyR\nNnZhbA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5129", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5129` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAWODrDHWj2m9FqTycuZdA/d3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxMDY5OGRlLTIyNGYtNGIyNi05ZGI0LTMzZmVhM2I5N2JhYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2QyMjUzMjgtZWI2\nMy00NTQzLThkZWEtYzUzNWU1MGIzNjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq4qvA8Yg53T1lc8xtExX7h3TaghfPgp5PqsQltrHagd4rbScFVrkDepcRlIp\npHfV9i9o8/yEQPUetjM2fLCYEaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmeEG9MriStAxOmDA6Mf483jVJgEwHwYDVR0j\nBBgwFoAUY/8Pcqp4zDjlmiXLKeR983eN/yEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAOFbhOjeZUZI\n6YW+SSXhA35Lp8yH7PgLchd5XRdZILOQAiEA4cB/3XQy3WAZ6Var2GsgWoLvl6AW\nNGczKObibK1zXrA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQS0Unje4ibhPJiL5ID8M/J0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTA2OThkZS0yMjRmLTRiMjYtOWRiNC0zM2ZlYTNiOTdiYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAAXtMOw8gHSJy/NRG/gsDLmnQLq5sOYfZ/Ow8Iq4K5iL/\nNUrH27y7RO3LOzek+MoRIabUKUsP/McHIpmU9CR5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY/8Pcqp4zDjlmiXLKeR983eN\n/yEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOiBiE6+I78zXWvp1gj5HX6i0/U7OHqfdwXEx3w1SrwbAiB99Web5TqM\nhGpVVgv/zITJ5/4y9iEsmXQMvtmrsWGoGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAQTUNGmovR13D3NK8JQGXmCxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2QyMjUzMjgtZWI2My00NTQzLThkZWEtYzUzNWU1MGIzNjAwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk3MDAwNzE5\nLTBlZmQtNGYxZC1hMjY1LWM2N2MyMWQyNmQzYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJF2CvEgjLq1HtVTx0F+ed1boL85V3IX5MDkghvoaNmG7vQIRlVLDJ1y\np9ljrWckPbnPpdW43F+QpsBYxeNYMFCjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJnhBvTK\n4krQMTpgwOjH+PN41SYBMAoGCCqGSM49BAMCA0cAMEQCICbjh8Rk0a/BUD4QVJq8\nu4nq4kRq0rz+54jfEmWDf5UhAiAfQdxlk0XXnlzHT7XiKYkZ5D8sjrglVDHo/AAM\nyasSHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5130", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5130` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAWH8PwyIvscz/d84/f6g7rfNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlMjljMDVlLTIyNTAtNDUyZS1iNThlLWRhNWI2MThhMjgwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRkNWY5NzgtNTMx\nZS00OTgzLWE2MWQtNDU2YTJiMDk4NjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDEzcMMTRYoGlQbHw9pj4ahmCDSGDUY08LJGBZkQqI+aNSWYM8H7q9IlcM1LB\nRHYuwCe5rRTPFwsd9mVlqmlY3qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvHgUjMOjEJmtCez7zYk7KZToL8EwHwYDVR0j\nBBgwFoAUNs9a8ov9uQV/6kEK1WwQJGExRB4wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIa1z6/d94um\n0Q8SWTQU9X6uis+fSlI0nQ2p2o36H/H+AiEAgTriS0skaO0SBoyqCVbs7di2gEz9\nOIH8ubQ8NUenkqI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWDt7RzJMPekX/3nqYaSoyCYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTI5YzA1ZS0yMjUwLTQ1MmUtYjU4ZS1kYTViNjE4YTI4MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuR1RJ5HZuRo24MoXv6ovAQQYqkEq3lCR7wkMAygIrMZyL\nUAFHexVTd/S4OoxKX5JSzSMcy/Sc1n00ebZz57l9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNs9a8ov9uQV/6kEK1WwQJGEx\nRB4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTy6Ul7KMody7v63nGM8afPW9aOkuDdIfPw7jjaSOz/MCIEjTfDqNeo5b\nBw540f6yDAKWCnjFdATZADyEhG005v1R\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAdOuiOX73U7Jz/rz/oYTXThwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRkNWY5NzgtNTMxZS00OTgzLWE2MWQtNDU2YTJiMDk4NjgxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg4YTcyYjhm\nLTJkMmUtNDE4ZS05YjExLWRiMGY0MWI5NWZkOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD2Vx55c8t9ni1C4TaUGPHZEyXemablwmdZH6W+P3GkFPlqtyW8G6H1W\n8pY50FYPo71PUOnD98gmdJFfe7X2Pc2jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLx4FIzD\noxCZrQns+82JOymU6C/BMAoGCCqGSM49BAMCA0kAMEYCIQDi3U/Ye6W2I4Jjv+15\nXixEkKyfVBXgfI0cLgzxA6yDhQIhAJYj7Ym0T92hejd/5JVrerYQ/9PVaG3fGSFD\nALYlQeJg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5131", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5131` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAQQ3hLoYx2edmMji6wL0ExHEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwZmYxOTg0LTY0ZGEtNDIwZC05Y2Q2LWQ4NmJlZjg4ZWRiZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBlNTFkM2MtNDAx\nOC00YTk0LWE4N2QtZDAzM2ZmYTRhOGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuZ7eNzS8xRbeQR5wgom0ow9AL6s3FwPAPlQFw+VG8pGWqC+L9kPt+16gLDuk\nrZP4zADDFaVZ0w71eTJ/dxQ8C6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCX8z79OP7YkFkUw+zvQRGSsHO28wHwYDVR0j\nBBgwFoAUNkgZFiQZTqObkp2QOALSLkUxXeYwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCb11sXVvvp\nv4STOIWMgbY8AjmRfIj4iWPeG8XhqvxnswIhAJRg9a8BKCSEbOYRU0dI0Fdo3Ao1\ndN4vwgOiGrzRBrZG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb2Ef0mVv82+BXw6G/9X7HQaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMGZmMTk4NC02NGRhLTQyMGQtOWNkNi1kODZiZWY4OGVkYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDHdZAMeSkzv7GmzUkEn86yNq2RGvtA9dbzXL8CeO5QNX9\nX+NDEvjPREfNwib89nYcShIT8raLjWV8a7o/W5i+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNkgZFiQZTqObkp2QOALSLkUx\nXeYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMic0K8pHHbjQalfQ/RdpG8SN1Ma1/YGiOg2RKUeZoT4CIQDGC0VVxfAA\nVI2AA818VT+WNqEUSNRoFhUOZP77fujgjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAYLdXlohTDf/keZkY8BKkCHyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBlNTFkM2MtNDAxOC00YTk0LWE4N2QtZDAzM2ZmYTRhOGY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZiYmQzMzYw\nLTJmN2ItNGY1MS05YmUyLTM0NmIwNmM3ZmU3YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIpLrlK7/HPG3PiLoWT/Wahe2015gQdcngZ7W5aZ6GwaNFvNuORpU0wM\nZDNmIm9Q0ZPlcK4k8L5NoyMmReDaJuqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAl/M+/T\nj+2JBZFMPs70ERkrBztvMAoGCCqGSM49BAMCA0gAMEUCIQD2X7CF5N8aeHs/7yYa\nxPHAXphJ+1aFUeB4MzNxXF4+zgIgC/7aQm0okqMqzSEJrEqIg+8S22ykjfgU94cA\nTGu0VsA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5132", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5132` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAc0+k8ZBIST+7IGmbAQQjjb7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3OWNlYWFmLTIzMWYtNDMyMC1iMGI1LWU5YTFhNmY5YTA1MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdjOTI2NzYtYjky\nMC00MjljLTg1NjgtYjM4ZWVkODhmOWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvtuBj3bvjSJSQaFjktFNuVcBHeSoGx5aDt9X9XTAkbMgct884RZtrGht9HLu\nhHLDJcs1eGbdwNQ0oQVqhjKUAKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCtBiRxczrxaArwPlhd1rgA/wO00wHwYDVR0j\nBBgwFoAUApZUOLnQHEDsVDR1KkKk429bNH8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDemXAZZiZ4uyInfgKybNl3UaqpEotqcehyLBeZzVFr4QIgH5biacjbOqcp\nTpC1AVHLnOqrd2v/s03mb8HYrSn6ue4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdyT26DqhYIyBwIxA2cXdokYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzljZWFhZi0yMzFmLTQzMjAtYjBiNS1lOWExYTZmOWEwNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsPX1nE5A6SLDThAJ4dzpMHNAh/fmiQIZ9xKuSb13aYKi2\nmL/2au/ng43UZxEauu7lsNnG1kEuRwhGuIB/Jj3ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUApZUOLnQHEDsVDR1KkKk429b\nNH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL0zIngvugixjoWkrpr4LJ/XgyWFqnMZ+iraSwqb+64sCIEKpMVD2C055\nl7uK0H5LGt7Z7mmqdsfxpzM/5+WGQ5my\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAZQCO6r9+u5v1aIJoC4zDKcyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdjOTI2NzYtYjkyMC00MjljLTg1NjgtYjM4ZWVkODhmOWQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1ZDBmYmJh\nLThhZDItNGIyNS04ODU5LTI0ZmM0ODRhYmFiYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL02PRoFdLKwNJyroE5t80dgtY7/qv6ksubhvsNriovHVQ4QZ5e2b3+N\nVSt8C3o+4j2tbQK+Uts+JvIZ4pYKyzSjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFArQYkcX\nM68WgK8D5YXda4AP8DtNMAoGCCqGSM49BAMCA0gAMEUCIASYYvyqzI/rHCGtyIrw\nFC9+prsZlcmaIltfPBOvtOtlAiEA2LzII8F2viCZaCJj0FJraZ/2LicVJvxK9r87\n4jv04tg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5133", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5133` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXyEjvkBX3ZQi7xkVLDqp5mnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxY2IxMTQzLTIzYmUtNGI4YS1iZDQzLWQ3YjY3Mjk4ZGYyNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgwN2NiOGMtY2Zk\nMC00ZTU2LWJkZmYtOWI5M2U4YjQyZTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERcwtUHwPQfK4SFHqmcJVs+z5kPz3gY5DE1I/HKlpOkQlNHmjPLSUsQmQnyV1\nIRMF/tOTLYBrQoKYOO7X4SjDA6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfOYFqzpUzHgv2FwgK9S+3Is5uLAwHwYDVR0j\nBBgwFoAUf6neFzrCgh4CtaLB3QjltnNtSPAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFiQbZi7S1wALeZXyxeqZipC/vJQ8MXmcFxCmYMm8clxAiEA/w8NBU8CpdGD\nKjjXXjGmLMRnvEEA+bqCsbeZzt++4tI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdYakzo/DEwtVelEIgmY67cBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWNiMTE0My0yM2JlLTRiOGEtYmQ0My1kN2I2NzI5OGRmMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEqpXM6fjzzvTGcjiPS9q9RTOoL2TXmhpFfbLx9JiM3+EO\n4PkaGUN/BTfbFh2EYt3+unFIBZHjjFLc6/RgpS2io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf6neFzrCgh4CtaLB3QjltnNt\nSPAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM+AVUA4JomNV/ixoHVX9c/s/QyzgytndEjgv0BetGUwAiEApHnP8C25\nUCm9AYwKyhBPs2lTKa4evlHu/6Mw8/HBhF4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAXV8vPfVJPMQjtxlmtABWOQ9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgwN2NiOGMtY2ZkMC00ZTU2LWJkZmYtOWI5M2U4YjQyZTAyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc3MGE3N2M5\nLTJjNjItNDEzYS1hZjY0LWQyY2Q0MjhmMzgwNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHf0VZv4ZbmdgbCaz5X3pA/DKw7tV2c1J/J+cgb2sRhGMXB9EaWb1N/g\nQN677XIs+VWBUgpOBiRH2rhrWNs2p/ejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHzmBas6\nVMx4L9hcICvUvtyLObiwMAoGCCqGSM49BAMCA0kAMEYCIQDhBhsonnV6FErOxyMU\nTQ2pQVhNM2UQ7qVRxNUSmWPkqgIhAJaxGAxvtS1ou9mBPzm3/8mNzBlu5NqeE2GU\nNdl4frUJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5134", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5134` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAeTV8BUKxJfE4dRrknBCaYeSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMzIxNDhkLTM5NGUtNDMzZS1iMGJjLTIxMjRkNmVmYzRlMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmVjYzBhODUtYzFh\nMi00YmY2LTgxN2MtNTI2OGY1YzRkNmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECCIgbhPplU6kzEB/up4F4T32xtVL4Qfh2l3kzSzXSsUnHnbnoEvl9T/6BkeE\n+n2RzTJmdSSPKwB1Io+/5pNBuqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGbzcqLo+Nm8DVJ78oWAAYCroGLcwHwYDVR0j\nBBgwFoAUN9sKC9aCZ/NgqvjFyQ+D/rYKPnEwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDS\nH+pxfa80HkzMYrlH1hExsbSECxVBaaAukfiO8hYfMwIhAL0DWChF7fVSOnpez3+V\nhiBpNfWI6vEX8UMhbCA0CmQv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa//C4g5m9KIXTaGeGDOla/UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDMyMTQ4ZC0zOTRlLTQzM2UtYjBiYy0yMTI0ZDZlZmM0ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPkyTHu9agsJIMjcuAAb1OSAydtUbwseYAE2NnqHuAk1pk\nI/G9FBuZKPe9wGGU+mPNIy0wuIF12uu5FO8n79B+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN9sKC9aCZ/NgqvjFyQ+D/rYK\nPnEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN++BvYsUS49a0m6hbnYieoQ6G8MfKdNxiMLJscRCuioCIBli3d+sYr83\nlNJV6z2HFdpCQfM5FUqCv83/hy6sSpV9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAeJ/AZZ8pQEd9hP+HG3cvw+OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmVjYzBhODUtYzFhMi00YmY2LTgxN2MtNTI2OGY1YzRkNmU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZmNThjNTM5\nLWYwZmItNDg5Zi1iNTAxLWJjYjU0MDkwODNmZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLyd0reNxJTnZ0bC4Xd92GEA46rm8AkuUEIrjmTsayc6GnVYkElimkRh\nIb3f0EcO8AhAJjeIDQjVtcA7Ujl6ElejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBm83Ki6\nPjZvA1Se/KFgAGAq6Bi3MAoGCCqGSM49BAMCA0gAMEUCIHOez22jr3jwWMTwJyQU\nI1ioXAD93D3SRuELuN+F7YibAiEAvg4WJAL3BG6I6mfzCLKDFVAi/g6J94Uzjx1j\nsnBbrvU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5135", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5135` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAZsk6/JhI8H6WmY32tcMwRsEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxZTJkNzQ1LTgzNmMtNDViMi1iMTk0LTNlMzFjZDFhOTViZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTYwYTg2ZjQtMDhl\nYi00NTI2LWE1ZGEtMDY0MmRhYWY0NjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1I6wBgI/Wg3wpeMLE1h608sAURqv0F9PnQ4wzhG7g1XfZGwxcJON8jPIpUFA\nOLXokh9/wkNTbp29HNq7MHyWp6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGPwtuazdqMxDlJW+g/VH5fZynvwwHwYDVR0j\nBBgwFoAUA3UX8P/l6jlGtahS4JVMbWHAVNkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDfMg1bYr9/ZmtB6BJLluR93dgEcggQpnFL0R69eWAT/AIhAKNW\nLyvhCNS1U6jsZqtYYSbmL20fwb+cBlkthjSaXTEM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZg9yIzgPxXwo+8cvrG5LL5xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWUyZDc0NS04MzZjLTQ1YjItYjE5NC0zZTMxY2QxYTk1YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZhRAp2Lei3+XJYPvfaBGV0oZPco7C0lA39cWf1Cfnl9H5\n5rkDkF+bYzwWP2Wch1RbD93hBbFcZhqnoCuyQb9ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA3UX8P/l6jlGtahS4JVMbWHA\nVNkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIzO7X4tFKYCwrQ/nU1r2bPMGFhsPjiWfkszRsCWpKtsAiAtWEIsUT17\nE5BIOR00hsF+WDo8FEZoM3fBMga+mKbvgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAYuRDSz8cxtITWouqFZd7a2zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTYwYTg2ZjQtMDhlYi00NTI2LWE1ZGEtMDY0MmRhYWY0NjE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY3NjcwYjUy\nLWFmNjgtNDFkZC04NmNhLTZlZjdmNmZiN2FmNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLRAAPFfcRIVO9F5tedlSDZ5K2dEbM/htlrndF/YedZJyxsze3SgKQCO\nH96b9xM0R7Re2mLxSfXGX9T9PskffbCjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBj8Lbms\n3ajMQ5SVvoP1R+X2cp78MAoGCCqGSM49BAMCA0gAMEUCIBlyeWoK3+MndirXYdgs\nMn/WYAxl1D750apNeD6yLMSnAiEA/0T0W+JkI7pRITpObt+fetPrmh0ExyaACo1v\nlAriEYs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5136", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5136` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAS01npUwwxCLKYWGGtAJL+/LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NzkzNzk0LTNiZDktNDk0Yy1hYjNkLTE0MTg1ZGY4NGM2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJkNWRkMDUtMzZi\nMS00ZTA0LWExZWItMTkzOGFkODI0YzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO8oF8hxVr5h7chwJhm7zMItzuiefkCeZ7qReXuewE/CwCcniejMcwyUhvU5S\nA5/90TCWTzaYF14sFKaeHzhDiqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ0miNs9nUrjt/Tb+J4BFMaFpeDowHwYDVR0j\nBBgwFoAULXzwKtjSppfnKP9vcCgLexgO2dAwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDNZOEGaLDZJlaEBncPX/lsQks/XBRoo7e5WM48OJN53wIhAOLQ\nag0YAodtbwdONIC56KvmfcbWe9WsBeJy+MJYBxMP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY8x+sreaz+Eii3N/5mhF6mOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzc5Mzc5NC0zYmQ5LTQ5NGMtYWIzZC0xNDE4NWRmODRjNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT141wARRZzrOm1WUbHSBVR2G19EsSQC4BRy49uq6F+HDNJ\nvSP3WWxSIX1gzp42+l7MKfEgqISgcv9shuXjC1puo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULXzwKtjSppfnKP9vcCgLexgO\n2dAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOMmEYVpVQiJi6QBgdJ6ZI98OncHOpGCwFchRUswa7DDAiBiaQ8WDpeW\nWUzXkNsZ+k1i7ULelKcbKmsxavMQd620sA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAUHZv82jtSQvlZ/WvzgLqxt0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJkNWRkMDUtMzZiMS00ZTA0LWExZWItMTkzOGFkODI0YzJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEyYmI3ZTZl\nLTVmY2QtNGMzYy1iMTAwLTczNWY5N2ZmMWYwMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEoSuO3iwlmc3TltqY9mN6A/9KjtU4EL9gw5M/dw9lTWrYxJiwWP4Cz9\nOlu8QxW0cD/yA7qUrm7X/MKUpiQ5khGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFENJojbP\nZ1K47f02/ieARTGhaXg6MAoGCCqGSM49BAMCA0kAMEYCIQD4kyCbk+peRyRtlo+T\nsWmRW40fc4SqzrEunu6PXMuQcwIhAJEolam4nwQ863V+tN1kofeN2Aq6Gjqddp3u\nGPljU/r/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5137", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5137` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAbtHMqOuRU9DWdAw0YRTegcoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmYzQ0MWVkLTRhZGQtNGQ1Yy05MTQ5LTZkMzE1NDNiNTNlODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ1NDMyMGUtMTJm\nZi00ZTQ5LWE3NDUtMzQwMzViYTMxMmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM6yKVcE3gm2uguvH6xJ41BB0xNV2kFNwNtmReWl8O0+rirJMOSN7aGW7Mv7j\nlFebGmdFA4Rr3kuq8BU6j93j8qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR0La8K3oG3n2WZxw3ap8suN8KIijAfBgNVHSME\nGDAWgBTa9wsPsSTAd8faxTn1pjVc5pTjYzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDDVAHigtkEezREtbiNJDr23x3spmxlO\nyGgq3qOS1FQMAiAUi/RzWATq4ji5O+sb/iqM1JQoWQju1wQ9roGXtFz75A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWX3RtMi+jBWSJ8809FKNZ6qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmM0NDFlZC00YWRkLTRkNWMtOTE0OS02ZDMxNTQzYjUzZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvayvBsptVm8REw8e98t+5WLPDz1oLe8IBdyFKnb1er1AL\nDBCIPvxFZo0IprC1zOv3rkFP/8/jfTwJONvz2ypro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2vcLD7EkwHfH2sU59aY1XOaU\n42MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP5JHt/srTsr287TAdwPY6yr4bNOboof5EkYcPprBNFgAiEA+bdqP3rg\nkfBAJG/vpayE2RKsvLM3mvg6u/p37kAl/ts=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAaPB/7WLlKb/4WyJpAyZFWw3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ1NDMyMGUtMTJmZi00ZTQ5LWE3NDUtMzQwMzViYTMxMmFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFmNDE4ZjVh\nLWM3N2YtNDE4NS1iZTJhLTAwZTQ4NDgxZGVmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH/D1gbKVGJ04j+5u4TJHi0pwaEJ/14/SxTNg/rml0rKh6obkZwLjZK7\nARzoZlnWdEhre34qxdEiXRbj6yr1gIGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHQtrwre\ngbefZZnHDdqnyy43woiKMAoGCCqGSM49BAMCA0cAMEQCICpCOFjpZq6fWXr/jOHb\n4XjkwdJlLBzivQLKF1uDAnciAiAKl5bqnXvq4V8KAvUlzaxhlu39UoAzWPc4yr+W\ndDyF9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5138", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5138` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISActOyHgHz4yJDCEwvxw3nqb/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwYTAyOWRkLWYyYzYtNDEyZS1hYjM4LTdkNDNjYjFiZmZhMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNhNTUyZjgtNGVi\nMC00OTFiLTliNzItZWMyOWUwZmMwZGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0eOW7l5pkRR+1NWUya3HkfSK733f6Sicq0TfI3knOZvfEe5uH4/xHC51egto\nmXcUvOFet2+7V8JMH+6XDFNDBKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsluZM09c0MizCil+1VF/oLYRmf8wHwYDVR0j\nBBgwFoAUUo789En3EmsNJwL7nE4b86OHA94wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDio1saIww4\nXCvzqpqXiGAg050/z4PqF52whhveJ2N8eAIgKcPY5/jAueTML6mFqYw0hZp+My0v\nXecxltjbRznmre4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARYUYYbQdzwdy2OR0kaGE72ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGEwMjlkZC1mMmM2LTQxMmUtYWIzOC03ZDQzY2IxYmZmYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjKJrHCLcFOVtnIZS9IzHDqQWMzLL33F+Z5ZjObB91Jic7\nGKkHuI0MfUdGWPEZKARjFNP5fUxVt+Ro3175L78qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUo789En3EmsNJwL7nE4b86OH\nA94wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCMxAGT1owanlhu1cKHJFbnOSMb5queblAhQT6dBrjv4CIQDLnofFYljZ\ncyJmxq2DP7n0mZIlAR/J4p2dh6/kmirChQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAQP1Mx4JypTEXRIhB8xoh+l9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNhNTUyZjgtNGViMC00OTFiLTliNzItZWMyOWUwZmMwZGMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGExM2YxYTQw\nLWY3YTctNDQzNC1hZTkxLTllY2MxYTQzNGNjNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLgOtaS86P+zETX/Q7/Qz1UrozOt/G1/qNLTrjL67ZXPjDqUABvTyX8N\nsHxwh0k0wv2YnsJCvRbLAx4xLrYq3OajVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLJbmTNP\nXNDIswopftVRf6C2EZn/MAoGCCqGSM49BAMCA0gAMEUCIDLbYhPUHXe3C+eoN6sF\n4T8epBW0Oa7mt6dzE4xjgWqKAiEAmmeIMio9w+/HfqaNPGjrantiRJnQa1HvAX5b\nG1FaQIY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5139", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5139` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAerUil5xSpW0Ohuyj+h17SsIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhYTQ4MmQ2LTI0MTEtNGUzZC1iYTlhLTdlZWZiNmZjMmJlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTIxMjgxNmItNzNi\nYS00MzhhLWE3ZTYtNDMzMTc3YjJhNjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESwmXyY7MDWLpq8b07xu2FkZ+4jdmAU8o8CmiizJkwNpcV7EoMb4/EVmGwXgA\npI2DPfVRJ/QLkrz6Bo38SsdRzaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKOBY/ke1BVr9wsSdOqTA9gQNJB8wHwYDVR0j\nBBgwFoAU3QyhldnGFkWS5pPXqk5PiJ6Er7IwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCICjjOYJtzgpr\nTnbsKdXCupOUFgBH1PdEUPtJup1kASYbAiEAxAJMqahV/6x3uPhHxItE3BhmDQxS\nXoGWlqq0ygbL0cI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ8ZpwvTZcPqbN+S0Qg/dmtQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWE0ODJkNi0yNDExLTRlM2QtYmE5YS03ZWVmYjZmYzJiZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHLEDftyEnzyyxKKRlGp9ib4ccjrE408LsuOSe3Pduqs7r\n5YN9UrAh2+cU37/s0cuIXMBojDC3w5CQORXCFdbfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3QyhldnGFkWS5pPXqk5PiJ6E\nr7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH4hmMMbSWHvNqwxy/HMM8TnYWty+L1kVoDdBBgvtusACIBlzSmcObGNf\nGkBwQgbfWNO0soJ+X2yQLya7cxgLRIDO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISASCjJmjkfZWP/Sk92HVkfIPwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTIxMjgxNmItNzNiYS00MzhhLWE3ZTYtNDMzMTc3YjJhNjdiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNiMTkzMWZh\nLTU4ZGUtNDg1Ni04NDQ2LTQ3ZWVhNmVlZmI2MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIqyIbsJLNw6j+CdxYXBAqcG19W5rCoG+gTwd3PztVqjny2rPS44MHp5\nMhOHOndhPxb+j6bc+oV/6QiD7QbU2IWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCjgWP5H\ntQVa/cLEnTqkwPYEDSQfMAoGCCqGSM49BAMCA0gAMEUCIQCg0ILA7RPrD7WWIZ3t\nVlIIvlwhh2utMuGU7gzTpBNbWgIgZ9jF34l73Ou0fYULDrlNKTEMT2SN+C3KXGun\n9K7JbIk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5140", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5140` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAfWVlYIRcSzMtU7IZvZT3RiZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2N2JjMDIxLTY5NDQtNDAzYi05Nzc5LThmMzAyYjVkOWQ1ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE0NjhhNGQtM2Fh\nNS00MGMzLThlNzctNTY0NTg1Y2YzMGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhSP723GRl1/fTPadqP/+i4nVPI14juVr7TTYrZG5TpMSym2lFRpqlUg9KSPT\n05v4O8gFrEi6Zs4DzKmk0nn9S6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAu20kVaXeDJnmxsMk4dHrV9O77gwHwYDVR0j\nBBgwFoAUeqm030mLVOJu0l37wWy9k8NXZD0wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBddRPYE0m6\nqsAssC5CoWugZHoyJV2PA6L6LBsF3nW1VgIhAPYYbILyiuqAYI6CblFJ1NJECGWr\ndydvyP//sZznx7rv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXkEJ9ecuqiWDGx7HXN8QEWXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjdiYzAyMS02OTQ0LTQwM2ItOTc3OS04ZjMwMmI1ZDlkNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNh10HJZ8Gsgv9+jBbfmSZCcCulOjE9Loj6KMUSZxpGAU+\nKfAxhxakMZbSXDOPzlytwWaXMI7QddyXI7XKUmV4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeqm030mLVOJu0l37wWy9k8NX\nZD0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANzBdy4+vfkngmjVEg1zYEi+dLXhcSBwjaJS5WQzvpc7AiBkj9tS+7qU\n8h6jFDkCuSsfNUWjFohq7ANfc51429ewCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAWibRIdycBhXl96yLjTKk7HBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE0NjhhNGQtM2FhNS00MGMzLThlNzctNTY0NTg1Y2YzMGUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI0NWMxMTc2\nLTdiNTgtNGZiZi05MDMxLTMzNmRmMjRhYzExYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEgPaDlmOuHbcaKFWuDW/u7WXAIJ30/+kjnY0xp2cgh47ftjLP9NCrGP\nROgz92zpWIaFXmt9qCAw+NSYhK7kQfijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFALttJFW\nl3gyZ5sbDJOHR61fTu+4MAoGCCqGSM49BAMCA0kAMEYCIQCzlTeXhTMabf+uKrBE\nAoA4TLDD5M8IOffKoDlXD0HLIwIhAJuz4BtFhfJzXXPcpEKE+WTei+zqgwZstIUw\nLlAAgzR3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5141", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5141` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISATq9cvMe0hBQ36cxyChwjgX9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3ZmExMWJmLTA4ZTUtNDA1My1iYjc2LTczNzE1MmM1ZGU1ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRiODA3M2QtNzQx\nMC00YWVmLWJjZWItMjEzMGYyMzQ1ZTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy2RnGWetI0GPKD6fRvoaKCxk8bOaONO4kyOcrDOq28IN5rW4OEqj6m0fHkaQ\n1a5LyUjUADh99gCZTsYwwlb/jqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUefuLxQWRlFCV+Ww4pzvRJae4TFswHwYDVR0j\nBBgwFoAULJR4NPVRkL33NP9IEheKrpRKpsgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA4jGmm9ucqbd79cntINxL0WhaRe4ZXM8qxfRMUwJFyuECIEIPy/L5vt/h\nkkt9agwPwKrv72s5F8hUI1/dmBZ34RKC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATCVh+jrXDllTBfNHExBLr+fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2ZhMTFiZi0wOGU1LTQwNTMtYmI3Ni03MzcxNTJjNWRlNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNspp0nt/Egrfm89W55VNV1EQVCcUFZrGXypjqCTV/tJSH\n/1KeihpkDINZZaWALm78TSSf45IWXoDikkXUPzZeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULJR4NPVRkL33NP9IEheKrpRK\npsgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI2rswW6L/DOE7t+UN5N4arRxTFAzqF2OmUduPXhn5zJAiEA8Ej7LI0b\nF2/1uRJKHjdvkCRjtzAqevZ5OPMHAv7jeHE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAcvUnze7EyjiqkCyneAx6PFIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRiODA3M2QtNzQxMC00YWVmLWJjZWItMjEzMGYyMzQ1ZTZmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUwNTM0NTll\nLTA2NWQtNDQzZS05Y2FiLThmNzlmNTQ0MjgyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJoP2V7rzrGC7loySNr7113bpkZNziosF1RbAFAEFB/gQD8SQukTolb7\nu5stPOsdAF4edks+htpek7Col0d9ypujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHn7i8UF\nkZRQlflsOKc70SWnuExbMAoGCCqGSM49BAMCA0gAMEUCIA+m30dOs3hba3H7yJC2\n3uva2cgYXnxJWKBGNR2MjoPjAiEAvNeceYZSqitTVaDVXzytq4r1rECnvL1HH0+D\nrBJz7Q0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5142", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5142` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISARGD4xCxcZ5kaMMKTGWGCgFhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMzkzZDZiLTU0NDAtNGJiYy1iMWJjLWRhZGYwNGVlNGJkYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc2ZGZiZjQtODc1\nZi00ZmUxLWJjMTMtNGE0OTZjMmI2M2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvi7OcXKmc/7QmfChBw/yxkfFkg1gNKj8JuimNDCdQ/ErD0rF70NAmgxwdRwy\nJ93ofjUW8/Xmel9svmUx4sgxFKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoQ/k9lcEiSoWg17uQhRcD0gYgbIwHwYDVR0j\nBBgwFoAU8/v97VpzTTd9lRzCz4A2PFzsH3cwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA35ZE0Vo6wTk5/cCnxctWTEsC3jfALufBtax9Mbsr74kCIEt2ScblJyM/\nqTr6uu2QGzHs6ANQ+PLG84jaJKvN59bS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdWewfthZwk/ou1epWnZD1sDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjM5M2Q2Yi01NDQwLTRiYmMtYjFiYy1kYWRmMDRlZTRiZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6vXvlqZFj0Gkc8EoUdOoFwwEJgsQp9M+LaOoVv5zBQ6Fi\nCM0NbHjnm9nmHvovvhHaOgm0fV/96OVwhgma55/ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8/v97VpzTTd9lRzCz4A2PFzs\nH3cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVAu1WdZ7cAxmfTB8qtqxS1Q2848a9XKfudT6Jk3FSfMCIQDWoE/dBgRA\nxnY+lylb3VFNcET9GZfU8D+qHmKZ5O+gYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAdmqs0SxccjUnoubZLJLCu3zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc2ZGZiZjQtODc1Zi00ZmUxLWJjMTMtNGE0OTZjMmI2M2Q1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYzNzc4NWI2\nLTEzMWMtNGE0OS1hMmJiLThhOTM0MThmODE1NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD31Iy5jabM7qRPxT3zzXcx9txrZ4rr2ubd9a9qjwk6hgP7v9G78gaS9\nV+dD138OXfbdMnHCtfjQzEf7R1PbpsijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKEP5PZX\nBIkqFoNe7kIUXA9IGIGyMAoGCCqGSM49BAMCA0cAMEQCIDR8OKsR8BSXZXupD8jJ\nLHS1lRkYEjCaCrokUwHsW6OVAiAkmayADSNIozSaWHwYWKOCW9ADIXbDUMAEthgT\nQBcvEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5143", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5143` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAQ0GMwnVvItzu7iNigjG6f4EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkNjIxM2VjLTgxOWItNDg1MS1hNGJmLWJjY2Y5ZTAxNThiNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU3NmJiNTYtMjVh\nZC00YWZlLWIxNmQtYzZmNjJlMjNkMGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5iRupZlYKP8TFu0WGed0xNvfmFbLbEznMIxh6lWHQ267Zl5q+mFf1tJwiB26\nYqR+hUHP21dEm/TajxNqL04nk6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqAW2DrA3ZP/slF6I2/9OXLaBSIkwHwYDVR0j\nBBgwFoAU4i+PAAVyW61eYZryFYkqGaJH8BswMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n9Ii9NFtpp4TGl8dTJES8iK/NwWX2M/dBwmNtxYCp5NcCIQDeq2q4QFH7FbS2sIz4\nnM9/RpsFsaV+81S2CmSHqj1WhQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASp86lAFaWJgJFvsVysJqpwUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDYyMTNlYy04MTliLTQ4NTEtYTRiZi1iY2NmOWUwMTU4YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTQKf+NXNzhrEwIKYm1Gm3mAHSVwDwNLeDig1UD50+nWQr\nWJbUgA8xWSZ4O+mfU9PNiftnkfolmtnKsZyTsR9zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4i+PAAVyW61eYZryFYkqGaJH\n8BswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMjIrUPIr+QV6ThTGp4Q289bExk+2GW86/mrQrOR8vW2AiA5syZCHIAC\nqk0RFe88Swr/0UYwPbAT2twoi10ibctnCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAWIVqkBLQ4bGmMALV/Cf8U09MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU3NmJiNTYtMjVhZC00YWZlLWIxNmQtYzZmNjJlMjNkMGIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM5MDQyZmYy\nLWQ0Y2MtNGIzMy04NzMxLTdkODYyYjE4Y2VhYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFI/NrGySDUOuRBlTvOgsTlixM1QCYi+Llqk4ZM/iMw96ZFrdiuoNZFH\nJ/A3ZhuaQbWkfTHxjAtWet1dAL5toXGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKgFtg6w\nN2T/7JReiNv/Tly2gUiJMAoGCCqGSM49BAMCA0cAMEQCIBaN3DmX7B+HdofDxC3I\nAMhV+/sV6ecpg8rpBqTfxSpZAiBT6aVfxD2aOY8imaQEig0HjU6vU56XMGVSPCFs\nvbHETA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5144", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5144` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAbbVlBoFgA1phUNCKTSN6E46MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4NjdhZWZmLTA3OTktNDgxYi04NmNhLWIxZjNlMmNlMDJlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGJiNTllMTctYWY0\nMC00MWM2LTg1NzYtYjkxNDU3YjFmZmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI6FtZealSSrK4ZR38YZN4J8RgwcUF5IxB69Bfi56N1sUGR/zqNNPZFYpE76l\nT/mO4PLwKYawXohsplDEFqVZYaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtVtDN2IX12ygRUTQzgPda9vg2nwwHwYDVR0j\nBBgwFoAUZsRx19k20r4lPlAYlciuVxCACxQwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAK7EH5OST1XwWMiDyLUMgkBbFqJerD81WteWHxlrSOjwIgHkus\nX3n3J/sKZbkse72+mdkIVVTewirspXeSVVlT4wU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV+PMOXVyvN/JdKYUHb5LzLDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODY3YWVmZi0wNzk5LTQ4MWItODZjYS1iMWYzZTJjZTAyZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8B+iDg2z1uouh2nXRADF4PVh7Cur1Y5RhTAxh1jWTpHmC\n1CahpK1w7RgoDJooSauzcjcesu5rrwN+BRluqJzMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZsRx19k20r4lPlAYlciuVxCA\nCxQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMRP1BLOwzdc9MgtoqICAJvDu0rZZ6bLE5+XWmI4uLOiAiAIObApxIum\n7CrV53te34lySy2vdjpdev3SqRp33E5tdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAaN/VZQ9YBc/C0Bby2dcjhAZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGJiNTllMTctYWY0MC00MWM2LTg1NzYtYjkxNDU3YjFmZmE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgzYThlNjg1\nLTAyMzAtNDI3Zi05OGQxLTZhMjY1ZmQ4MWJiYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJS8Lq/jAMfMGGxZq1MO/ZbyhXRK+EUGRmiQkK45VhWbAqFNAmNkD7xY\nLNcU5eKSsIfKe0i0+E1KZtuMKBWor/6jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLVbQzdi\nF9dsoEVE0M4D3Wvb4Np8MAoGCCqGSM49BAMCA0gAMEUCIQD4l15hg9mmdoq32TnF\n3YVc+QKVav5e4LKgv8+KaY6dTwIgJbKOkA3jy4kQvMLDBLFCOfTwPPwZS8GmVfqT\nWtDAI1U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5145", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5145` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAVNE9qtX3pJiiJ9cuWb7qO0nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlYjQzYWMzLTI2MWQtNDIzOC04YTA3LWQyZmU0OWY2NTljNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE3NDQ1ZDItMWQz\nZi00YjRiLWJhMjMtMzU0OWMwYzEyZjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV+BY7g4oWD9cCcp0gWCaPXwBRl4Z+s2LY/NeNyNkf/dw6LbxtNgB+fgrrTup\n4rDqzzienCCWzskjDTD/EkU0bKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFZRM4h+KC6ncsImG8RhCBjZ/9YQwHwYDVR0j\nBBgwFoAUMyqsDhgBYjuAXQzZ5OWD5ULf/lowPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAsJ7544tbcsBqK364iugH7X761+p74yBbIMW4KEFWuRcCIQCA\n8E1BS72juBQ4vaycMcOrRDfZlykWZ/fo7uDvP/Eogg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaG82Ry9hAZ7YzI/BFI126VuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWI0M2FjMy0yNjFkLTQyMzgtOGEwNy1kMmZlNDlmNjU5YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS86m1H9Jxqt0XmLxnPCDvnQXp5gN6KkaYn5PWJ3beZR+91\n/1zU1fQKB9s26dIhJd9N64Gx6SF2Nua7y/6VkJLFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMyqsDhgBYjuAXQzZ5OWD5ULf\n/lowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgERqQCykZguMQtdJmRYOe2NcvyB1/MQKRLdcCZf12C6QCIBveW3Xd2I3B\nYfiGJGyVKEcElCkOhnCIsoJAQ7mN+02P\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAXcBA2CI43ivykzbGCXDggeTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE3NDQ1ZDItMWQzZi00YjRiLWJhMjMtMzU0OWMwYzEyZjkzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM2ODJmY2Rh\nLTU1MmMtNDUyMS1hZTEyLWFjMzViNzJiOWM3ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLocqfKXm1Jhzt2OdRCWwoWllIjSjDA0xhSz9OdLWDl9BA6ad2dwdtp4\nHHj1hu6ZQ/a+dyLTR2BRQ6BKOwSxT/WjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBWUTOIf\nigup3LCJhvEYQgY2f/WEMAoGCCqGSM49BAMCA0gAMEUCIDkdb73Cu56c/sBaHQQg\nIFeOMNC4JL/E5n6h3RBWmJNsAiEAv4pbfNyPL9Qbzii3KhnGSSycUVONS2giBtSh\nEI4XrRI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5146", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5146` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAcp6v1KhC6pyY4hJFrneDemrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5Nzk1YjFhLTVmZTAtNDc2Zi05MmQ5LWVmMzM5YzUxM2I3MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTYzYWM1ZDAtNjBl\nZS00NzNiLTk2YTEtNmExMzZkZTdjNTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoaZpgxoHR1bfoWDgMiP2d435kjQjEb1Ie5XTx8PXKWfcI2W8mg1JjQxks6Y3\n+UW7Fq6i6j3Rf/dfLsrN4gUBL6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuTJmblHfefZ7h5+z48kPY+jEUuwwHwYDVR0j\nBBgwFoAUZy6twSVvuEtGUSG1pQbVzxpS5n8wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBnzNsl0ejAkjDX\n+73Wltc5iGNsyrmCCb6uRtoySEHYFAIhAOnjUeEnDoWhcoORQ+ILuqeNOjIfR+3E\nP3to6BDzW0Jc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa50dQ4I7wPQ62J9wnNJm9ndMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTc5NWIxYS01ZmUwLTQ3NmYtOTJkOS1lZjMzOWM1MTNiNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4T49cpFZUAji/Q7pWlgr2clYcoeIVso8G4Z2t4dAGreEb\nVa1stO+cXH22VBmPHpnMHLzITiRWRzDF00BpGxp1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZy6twSVvuEtGUSG1pQbVzxpS\n5n8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL8cPT6aX/Q3FcpyJOF9duopsMv8Vkzisc4CRFr05/bQAiB/l5bQ4p/1\niTqSP7eimERHDPT9NhRdMZ6xTdMJ61bxzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAUoxCnx8B3oKjPiEzo14Sa7vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTYzYWM1ZDAtNjBlZS00NzNiLTk2YTEtNmExMzZkZTdjNTA3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBiNTRiZjA4\nLWE2ZTgtNDg0Mi1iYmY1LThmYTVkZDNiMTg0NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLTf95jbG1K2wPeczLRqvOVnKFXdjrtAsGr696dSXMAL72wONWgPW2qR\nx6W5BazQaBC7YvIYYf78hutedI8wMtyjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLkyZm5R\n33n2e4efs+PJD2PoxFLsMAoGCCqGSM49BAMCA0cAMEQCICGLIxKY5SZfEIyfJ/UG\n6jyLb+37EcbgDLGNuusdYLoZAiBDWcI12KUZwkbRB1tL+gueR9aWz+tlJJlXZph4\nMVTFAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5147", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5147` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAat00LaFl50FIE8tOZ9ZoxFGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NjQwNmM4LWMyMjYtNGRiNi1hYjU3LTA4MDI5Y2NjNjgwMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U5MTU3YjMtMjUz\nYi00ZjlhLWIwYjgtZTI2MzgyNGYyZWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh+ZPKSHOQmxsGicIACSdzqWZLkCc2+Yx0MhGS5pLyQ0QTX8uGtevUiDDycLu\nH94J/HoJF6drqswVWX4ssQl1fKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBUvN5zSBO2HjKjYm5LTPtXI6ag8wHwYDVR0j\nBBgwFoAUbZ2LR0kYAD4HA+qNmc7pfZTP6jgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFQ3pF5xXWY74lgkPm2SfpsbXD5AqlE6CgwXF4/xGHRvAiEAu2xncd8rvrjg\nnmvLA8g5au7YzQ5iwYt25bTQh2AUttg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZuSdvdKJAvZ1IYOhwgvLN1vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTY0MDZjOC1jMjI2LTRkYjYtYWI1Ny0wODAyOWNjYzY4MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLt7+ipS/YGLIkfS6uEUb8bO7IDGNxY3XVaewJ+zU5FW6t\nVlasqyVTq/2eht6tX7iUlSZM3tMLCjoXzXbFliPfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbZ2LR0kYAD4HA+qNmc7pfZTP\n6jgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPMxye69uga7XTnHA4VE/tj7Aff5tvIrvSJNLucfqGF4AiEA5uS9Oi/E\ngj0fMUj/FpJ9vy/5dJfD///LRlg1tCiCEok=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAWEDjA5wkQ1EifqdYcaKC7ylMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U5MTU3YjMtMjUzYi00ZjlhLWIwYjgtZTI2MzgyNGYyZWVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNiMTMxYmY0\nLTAxMTMtNGY4MS1hODk0LTA4ZGMzMTI3NzMwNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM6Zi5gGEVhj14DtcuqkCCIkTiUkkTC1fHV+dli83SjGe0a+pShFtWLS\nrMthci+oA68vW0A9dLOIZ41ptGlEOMSjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAVLzec0\ngTth4yo2JuS0z7VyOmoPMAoGCCqGSM49BAMCA0cAMEQCIB7LYTXHrTzcU9R2Mudp\n/T1+spq/i+xTn7Q4qbwsbZkkAiAINfc9Rr+AR5DWay0za8Flyj091CRrYu2vYDuQ\neIvJpw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5148", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5148` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbxwEj6ep2bM/w8/PlYA0NNgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkMWU3OTYzLTFlMTMtNGFkNS05MGM5LTE2MGJhMDc0NTZhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2MwNmQ0OTEtN2M1\nYi00ZjNlLTk2OGMtMTgwMDZiYzRkMDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoqzLKimY686FFZbMeJUKwDOVzcFHOk5LCmEQT7xpI6jHSV5FsfaXP0N5/dWT\nU3/3gARUFf5JmrCMbodBlPVO+KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrwrDgUS8ZeCYnvctuBF1oj2ScwkwHwYDVR0j\nBBgwFoAU9T1CTZ7u5UrfgtRhJysb8Ph3JWcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIChb8U2+K+vjVcpuRJg4X3YfMFkJF3Ml5DoCaWAhLR/gAiA4TaZBN3Xy9DaW\nKjZJet7xWjU9x0XE6J2eQIgueETE7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZJDCSIJ7TohMCa5pZ0jqUwtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDFlNzk2My0xZTEzLTRhZDUtOTBjOS0xNjBiYTA3NDU2YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2FLsSVc3Owgy9kc7fQDKn+X9WXOcR/pxZbXj70vKmvnBM\ncrCicBD9FnW4rMUSbHIqI68FOrFnFBXKKfII2FwCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9T1CTZ7u5UrfgtRhJysb8Ph3\nJWcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVpDTLtWJCiHJ7exnLteV6CvGXVHexf4wDYBo20zsBwkCIDijsuaPmgbn\na6aZkiWV7k5Ng25JoxyndxpORDb9a4zH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAYKLJlyQ8+2I+/uEhcX16HCTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2MwNmQ0OTEtN2M1Yi00ZjNlLTk2OGMtMTgwMDZiYzRkMDE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMzMGY1MDhm\nLTQ0MGYtNGZjYi05YWMxLTVkNjA2NTdiNDExNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF0fkugyCyPwgtaXjgighP2KY3XvLoRXaMbuKiSSufOSqsSVIfgd8FeM\nZvWyTfrU12yPJPZmsFN5gJhbXYW7LU2jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK8Kw4FE\nvGXgmJ73LbgRdaI9knMJMAoGCCqGSM49BAMCA0gAMEUCIET81abP6NMGKSDmUEMY\nPCE+1duWx2tbYdwF1val65nbAiEAvSHYxK6C90VRb3cPChbllnEzZTXxM78VzCWd\n7gRbTLM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5149", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5149` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISATiGdWDLxLrZP6EBnRNNAl52MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiMjQzOTNkLTVhNDktNGM1MS05NjdhLWE3MDU5MGYwYmNhNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFkNWM3NzUtMmQ5\nOS00MjY1LTlmM2ItYmFmOWIyMzJhMDMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERV7h1RrsWae//rswRqCKHduPugQ/GyBaFACgT9Lcxl8FwQQrewElDHPN9PJ/\n3FqqADaFLXOK56+UTHr2+c3QvaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFs0Z1peDg/L3oJfEa6xZuGX1doowHwYDVR0j\nBBgwFoAUQbpCVQWZOjyo8AnAiJRbfVXjH2AwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA3PNR3AfLCGHH2LVt9HoIyBrW5v9WBEfgt0/sDzFfJCgCIQCxFp5VioUo\nVt4ay8CTEyZzJ26HHezQV7080DIJsgq4AA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT33Yjb9mnhuYuuKSbUaQuFvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjI0MzkzZC01YTQ5LTRjNTEtOTY3YS1hNzA1OTBmMGJjYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+/Q9u1hKEGfsR0f33QSkVsiE0ac6seevy5VT3EvSOoCZg\nxA3T/gf3pW0D3P2y83VEEh3f7frxnQPnITxHkn9Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQbpCVQWZOjyo8AnAiJRbfVXj\nH2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRyhns8fimVu646IphfkYQmB6G05zwBX/atcKUREFa/YCIQCSiDKcSYoq\no5aTO2q/QkteGLhOn2DgkciRcH7KOv3poQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAU1CbP7Y7JPqhNyryrjvxCMiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFkNWM3NzUtMmQ5OS00MjY1LTlmM2ItYmFmOWIyMzJhMDMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYyNWFlMDAz\nLTMwOGQtNGJkNi1hNzI5LTNkYzJlNGEyODkwODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJr48osfMxGRDn9NdhBk1n/7UCjItM51DCGr7Xplb1HEeGZxcKi74c7I\njcNihskREu+G9Onju6bmY1FnQKqHxVejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBbNGdaX\ng4Py96CXxGusWbhl9XaKMAoGCCqGSM49BAMCA0kAMEYCIQD5nxWVYq1xT326JCQ+\nuu1hZTV2I7PjLgT/VTOcZZpDMAIhAIYz7ARVp/AByAOaQQfxge42vKB0J+HQQ9SY\nyfmpEdYN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5150", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5150` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAcUIABwf15Bs6VXCOu9nMUUhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxODM2NjY3LTQ4MmEtNDAxYS05ZDNlLWY5ZTFlYWVhNmM5OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRkYzc1OTctNGY0\nNC00ZjlhLWFlMjMtY2EyMDQyNTA3NzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf3SrqlnY/q87RabwrQK1m3vX8j2fOFp5Jh/1y5C7EzopVb8xW7hGdcX5bdQs\nlZN3XWB7ZJErXUZ5yuIj1L16YaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBIPHW93VXJTn091WAeZYQVr5GFIwHwYDVR0j\nBBgwFoAUquEjyx92RRjxNrJLXdnaffbV9GEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAiPmRHkN8+ifjFIIgvaEBJPKEoSvJYWdQ3+Pii2OI\nIikCIQCMxaijGzF5QKdXSTBSJyiOrPYy0nd95tOzk54cxREv/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUxnh1bEagLLMsB5H5i8brMdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTgzNjY2Ny00ODJhLTQwMWEtOWQzZS1mOWUxZWFlYTZjOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNJbWnhZbMHPgLL1DnFwp0zNFIEg3T8rEcMAAZ/h0w6p8v\nlRHfmnUoULGG/U9utki8o9cRyP8uIMcHyGBZZauko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUquEjyx92RRjxNrJLXdnaffbV\n9GEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALQza0LPNpJSMXymqxKv6dU/V4LXcTgcYM446y6y+CD4AiBO3pDHFE0t\nwc4mC75XoHUeBT2TZh5E1pyRskHQuAoz1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAd9LBgsxo6V76PFB1CAr6/mUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRkYzc1OTctNGY0NC00ZjlhLWFlMjMtY2EyMDQyNTA3NzRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQyYmEyOGYy\nLTY4Y2QtNDIzZi1hODM3LTgzMDdkZDVjOGM4YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJHxsW2XOENBvG8FG5hBDogNoEtDiy1pBhtnTDKgcbay3VlQERch3SAV\n9HPrYUYJYDCL4b8cgWmYLLnAtqlJw+OjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFASDx1vd\n1VyU59PdVgHmWEFa+RhSMAoGCCqGSM49BAMCA0gAMEUCICvbPDY13lIeFD0hEBFP\nXYGew9MsS6fqAajHD5TwOxfDAiEA9dAauVFUHdcru+cJ9HiLDZ9gDol5dVHETq6K\ncMTr+IA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5151", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5151` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAWVS6EztWsmhGUnxkLvEtxc5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkMDAyZmZiLWRjOTQtNGU5Yi05NmU1LWNmZDAzYzdmNWNhMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA5MDk3NTYtYThm\nOC00NjMxLWEzZTYtZmJkMDQ5Y2JhNTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE27LMzp/QyF78HWOmzOQ0iqIbiaxXB00PjYM3gh55bh/aULwseVbqvPNSfUlS\nTtzkXPrUYd555k46aL5g4G1KNKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUyML4PYC+A7zJmOcrH+/fzkxFLUwHwYDVR0j\nBBgwFoAUt8yIAfG4oyNm3wM6dCeOg0VZS0EwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAzvq4M3wqYcFM4IFd74SLo2dS3uFyQlSgKyOqM5Om\nN/ICIQDJVfZ3bcwoVNGif8EIVpumBKuWJlFSK93ppcGLUYcklw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW9ZfCRAqHaJkO2LtftFQxLdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDAwMmZmYi1kYzk0LTRlOWItOTZlNS1jZmQwM2M3ZjVjYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6HA+wJJ2DDtEOzcJ0ocP9xnoX7GLAudlruSO2TbJnQZBH\n2wC/YFuLhNKN95JSmgVlW00eFDHUDNa5UGI46UAKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt8yIAfG4oyNm3wM6dCeOg0VZ\nS0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdoy1WpU5bVtEf0nYd65mzHJSYqdmmksbanUoS692lOsCIQD6OM3oaCfs\nGs2hbLgWZZRUsjdPP2gYzU7Pkwz/IjFDXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAYYFirQYv0tFYP7I0NgZGvDoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA5MDk3NTYtYThmOC00NjMxLWEzZTYtZmJkMDQ5Y2JhNTUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJlNGZkMzg1\nLTA1OTktNGFiOC1iZTZmLWM3NGE1Y2FmZjUyOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCe0PUp4/Ug10jezHPTm/xfMdMSTqrnKaDOLqbznlnecIdkt9JSSZKA0\nTnxEr/rmUnQ+MuGhndyIO9EGl6fOwxKjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFMjC+D2\nAvgO8yZjnKx/v385MRS1MAoGCCqGSM49BAMCA0gAMEUCIAatZlBwTJnRZoaf5j6m\nxMdJ1oMqVuXJMQp9cAS1Y29/AiEA9InIF9UfRxHVYWaqNdmOLjG4OSQuSaK6ssc3\n/OaLpRY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5152", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5152` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAfZjGByqNbIKFg7k91nz1cSXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlMDQzZDkzLTA3ZTMtNDhiZC05YzNkLWE0OGE4YmRhZWQ5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE5ZGUzYTAtMjQ5\nZC00OGUyLWJiYTQtOGZhMTJiMTY4ZTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHBbT7Sed8AYcI5fe+RPqnRnp3QElE764FvvrCZqbDJmQZDWSp3mfmU/zLnlT\n28VlUfavw9iHtaWrgSz+Jk59TKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7DPFC4QOLt+B+ok/7ZZ0/1HsXoYwHwYDVR0j\nBBgwFoAUN3eIWImmpNBbFe1El26Xh3nr6FUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiA5SxBeryFLpRh1XU9hwyTBiyBKYdksKeSi4Iu0AxK0NAIgKrBz\nyKbXJp/JhUqRFG86ELkK2D8Bo2VButDwdQizqcE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbEwhpe44FcVPHPoGncNMkvQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTA0M2Q5My0wN2UzLTQ4YmQtOWMzZC1hNDhhOGJkYWVkOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7CxapPEeFBqZo/z8agjkHbzeOMjY7rcT8Z1ugVWXgPx2R\nPzOFNrnlb5HltudkPWmWnOGuWo42J8+tw7Kt1Yr9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN3eIWImmpNBbFe1El26Xh3nr\n6FUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOSNEeTBrmffCe0JEzbnzUijWX/TJ1WDm7vigmqSUxJoCIQD9aWzZf1Kj\n4zCg0dGUNQHkvjWApb5I3Z0GtzuZ0CrLGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAZuCkZn2SeCDAByzX0OxXesFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE5ZGUzYTAtMjQ5ZC00OGUyLWJiYTQtOGZhMTJiMTY4ZTAwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3ZDVkYmMx\nLTkyNjItNDk3MC04ZWExLWIwZjYyOTBiZjFmZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDPG9kZ+rVA79QDD9BYJI5KmPFa67a3kMvJ2RCVl4an/XD0VpET096nC\n/9UX8aYVSijaIzZqFHHp4V3+Ag6ld22jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOwzxQuE\nDi7fgfqJP+2WdP9R7F6GMAoGCCqGSM49BAMCA0kAMEYCIQC/MkLgA+dzQoSLCQVU\nv3lxGGOIlbCs+tz6vhH9qa+K4QIhAMDj7Q4+TmEkHzK6oIq6cK4QqA2Gverioqmo\nXHSAZq3T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5153", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5153` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISATEtV9W8my46O0Ipki/VqxDtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyZjczYjdiLWU3ODktNGI0Ni04M2M1LWVlMmE3ZjAyMGVhMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDczN2I1ZTEtOGIy\nMS00NTdkLTkyZjMtNGFkNTJhZTllOGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIs0dfbZqj75zH1/AMLpPiOxFG4A0q04kxKu8Pztvr8NRlcIoKG8fUyeU8gAT\nfvTaGY0ORhd9dvQF25tkoFOyOqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnIdICNuS9XlpHjuUcI2IcfZGL+UwHwYDVR0j\nBBgwFoAU1BCxjwcPmuyuMTmVuv6R+oVmypQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAww0I+Y6UUtnM758D+a0maafHnu07uSPRu\nFRaOMNsd+QIhAP9DogU4iy8a1ueB39/c1bWLmNXDbEDL1A66jOzQuNmc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATj0t6RIEsFHJ1FZpYPInKhKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmY3M2I3Yi1lNzg5LTRiNDYtODNjNS1lZTJhN2YwMjBlYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk+or3jL6I+dYyZ82o9uSURWqQ1v2WzD6k314Cqubn4UWd\nbmjDRTUQTWDC2krCV6vglLzqHd9wFz9KCJAgE4Vco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1BCxjwcPmuyuMTmVuv6R+oVm\nypQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQZj2271vBw37d/9N0g6cEarKdKMAydJ+6dut4D9nH24CIHg+/6OO8qJP\nybfdXzP7e2zU8F9bC99ngLF7rJf4e4jr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISASGzRQQGL3Cb13MpyDqX02TkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDczN2I1ZTEtOGIyMS00NTdkLTkyZjMtNGFkNTJhZTllOGQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ2MGViOTM2\nLTQyZTctNGNlOC1hNzU1LWEzNTk2NTNkNGE0NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAsiIdwJf/AmrFjJStAQFhELlu6DrLgFgSPj3+/mkfb3A1xaf6r5SyUM\nLKHNFb4yS1kuFQbrMoBzQTI+uncnEGKjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJyHSAjb\nkvV5aR47lHCNiHH2Ri/lMAoGCCqGSM49BAMCA0kAMEYCIQD39ZAd8Moyphf/fDGA\nCZBW8uy8PJaT2IVkZl8F8oAJNwIhAKLJxeb8lQwy4nGWkrwXHZIKbqmD+gOd8kX5\nMqCsZ0LU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5154", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5154` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASAWIkSa4N2Y4fXljhkyPK8bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkOGFlMTI5LThiNDctNGZmNS1hMjBlLTIyOGUxM2Y4OWQ3NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU0NDU1MGEtYjhh\nNi00NWQ2LWI0YTgtNTQ0MDA4YmIwNzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzT5RoAUaINIPaT9mTb5qLADk5hEJrtGncMZ5mLw7gRgKZoAF/sT/UI6x7BCG\nCcLFHKFMCQ/buSGSjnL7vyneUaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQBjrFTp+u9YNX6qCFBLHRhFG8e4wHwYDVR0j\nBBgwFoAUNKA0gj1zyHy2Mi45tw7moBmW1Q8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBLRZuWX35roaYiNX0JLQ+F16dU+LqSXTb5\nYFlnLAUyqAIhAOoRBD0WpTnayJQPBJ2L9dC1y2TUCiMsHiM83t+UTTZK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQAdNI86f0rxx04su8fwPIR6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDhhZTEyOS04YjQ3LTRmZjUtYTIwZS0yMjhlMTNmODlkNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuR68smSXlROCeIwAcG5fVp8RuYk8TnwPDmP3qVW0Bs8de\nO6K1Z0+2L3yIY0DUbyf6VhGH2NDSsG8tYyBvfcxLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNKA0gj1zyHy2Mi45tw7moBmW\n1Q8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJKsmcbaUc4KRnw4t60mKRRiFOTSlUftPvB+UK/8se7xAiEAxEV/wrOF\nLQkz2xS47CFB5OoT+rSx+BZt1cQdpJxgz8s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAdrMprHffJj/Xy9XwhdguzSnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU0NDU1MGEtYjhhNi00NWQ2LWI0YTgtNTQ0MDA4YmIwNzJiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU0M2FiNGNh\nLTg2OGYtNDQzNS1iYzFkLWQ3YzQ1NDAzNWUxMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNbB0i/6e+iE3JsuYOc6i7tC3/RCvddVA11ptKzZ2SmNSSVcEzru5cim\nXkTU4kVlzBVBSuGqn1jTDR+52EvLv2ijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEAY6xU6\nfrvWDV+qghQSx0YRRvHuMAoGCCqGSM49BAMCA0cAMEQCIBNy1RDb8E7O+hzf/bIb\nBiFZOkpah/h7VRIQSiHRxqiOAiBFlsXLztd+iSvjaBGYBS8GkY6LdFWJi9IpMCF5\n/8FSXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5155", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5155` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAU1nd1dxO7XeIj/NrohAp6gRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3NDdhYmU2LWY0ZDgtNGU1ZS05N2NkLTJkNzFiYmJhNzhmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdiMDIwZTItYWEy\nMS00NGRhLTk2MTUtMzI2YjIzYjZhYWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoNSFl0GxRhP8o52g008dl2lRo02gFxo0q39oIWhpE5LsVqTVGRnyTbH/fEte\n1SjIdy/CIk0WDYcsurgCtcvSMaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW1xWSOGnfvgd1LTHsvCvGwfU0MAwHwYDVR0j\nBBgwFoAUehaBPL3jifcYVqlUt5EdKIT/HrEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBouWJlwWL/nG9G\n6P1omnxbWfOu5s+RZTo8cI2Y1ViQkgIhAOL+HSVSez1ZIyv9DjxO81PHOy+Szoz/\n9nRP8jRcPZcU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWLyGfnrmOdAFsaKkVkk5BfSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzQ3YWJlNi1mNGQ4LTRlNWUtOTdjZC0yZDcxYmJiYTc4ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASN+HF1dnp33WadWbnUedgawmaFEPvW8gQnyb2kjjFob60i\ni1NhT1fxyvr09oWKuJvlQDRkxVlN2Gib+3Ja0iIko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUehaBPL3jifcYVqlUt5EdKIT/\nHrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMXetJk245w+ChZtpFtbujDNlEqspy+U6bMTLrsATK+MAiBeUGdek23X\nZQ01Mxkdj7SqSxidsQsQCCDX0FJkxZUMTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAWyQW0nPDhxxjcwp97xQ1WeoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdiMDIwZTItYWEyMS00NGRhLTk2MTUtMzI2YjIzYjZhYWE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGExMDhiNWU3\nLTY0MzktNDVhNC1iMTg0LTY5ZWVjZGY4YWQ4MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD7ppOsC4trY1URzf4ilxtnCJjMLE3eN7eb3gn2ptSz94D1YasKY0TEb\ntTNfN9Nz8ewWiSe4L22jh1+V17BPcRWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFtcVkjh\np374HdS0x7LwrxsH1NDAMAoGCCqGSM49BAMCA0gAMEUCIHYtDVgEougqx8Yzhpcs\nCFeIKkXDWltqsGA8cJIEOtnXAiEA0OHyTzQGpdGjMqz/2BmT3WrzDNPjXX0imTcf\nSkMSP1A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5156", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5156` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAaORoDLu/27wlN8AFuPTfI0aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyODg1MGI1LWViMTgtNGRiZC05YjBhLTI0NzAyMzQ5NWJhMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA2ODY4M2QtMTM1\nMi00MjBiLWIyZGQtMjU2Y2ZhMTI0ZTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDdMCtl3J/96FIULWixWMUa268in78Nl4R7uJp+gBFq1inPGpkJ+an5m2uwLI\nWgCAeIAceHhNJ+odmJYxAxPGG6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiZYYjLpPC41tLonF7o/MYP/oF50wHwYDVR0j\nBBgwFoAUBqTaDCf83aGXI3swKSgpni3rjDMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBuYFFI+Ou5x/5HJhXJNmwtsSDTUOcJcXlXfLNJ++6FSAiBU7ruDcPysNtKZ\nzQqUXBFqDvnWK3yFQ7B16/dmoT8mfA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfOvVw5QC9XxTOAksFfxK8XoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjg4NTBiNS1lYjE4LTRkYmQtOWIwYS0yNDcwMjM0OTViYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLv99kE3kEpu1+0309j0TAWM+8WFTcscHVqI8K04zSWkdi\nDdoXCrZu/fyeLkzkf2CGraj5xxOh9iiBizVJqutbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBqTaDCf83aGXI3swKSgpni3r\njDMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJgh9Z8C37F+eclWD2+swMnGYij8AOiKO8espEusARv0CIFKU3G+QZR9Y\nlAGPBpcHw5z6HuEU/Yac2PQdtO/k0Omx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAdLvstgrys8g0JanDdFzKrYLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA2ODY4M2QtMTM1Mi00MjBiLWIyZGQtMjU2Y2ZhMTI0ZTI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI5ZTNmYjY1\nLTU1NzktNGIyYy05ODk2LTFkNTc2MDE0MzJkMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD2iOPeKMwCYEeBYFt1U7yR9FzlwRI16iY9haOIfCP3JbfM4219FyUJZ\nxhm5m7yhJXPRVO+e+qbAwDx3ycu3ZfSjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFImWGIy6\nTwuNbS6Jxe6PzGD/6BedMAoGCCqGSM49BAMCA0kAMEYCIQC5kU0R1wFNCRVRPkEc\nJjarihpXhx82awRyiHttkX1vsgIhAPMEz1sYVUXBULvy2MpHkb5zeBhiqXhwLubh\ndq01uMjx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5157", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5157` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVJv4oGQhlifK+UTCg08uC87MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlM2EzMTRjLTNjNmUtNGZkMi1iNmZhLWZkNDQ0OThkNDFkYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY4NjNiYTYtNWE3\nZS00ZDMzLWI2NDgtZjQ3NjFmNTg4Zjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJdbFfXXn4pqJ4q5qM3KQ53PmQqf49dAZD35jjTSftY1iVY0f/Jdws6jWOGor\nAMcP+Y/VxL18+ONVNVmWV9PeNaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKet93Gji/8LKD9OwRotPSeQzwB0wHwYDVR0j\nBBgwFoAUTP/tFSGN4Yg+s/HPxESoCzhy4PAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIExqMuuIKFNemvh1jQoZXK2RT22n0MOUf5q3EbQ3xN5QAiA4GMSO5kWx9937\nElQ4SBWtn6Q/+BcU/38T9aAolBW3YA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWRK8700Lda2Px2o/0dMwlXwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTNhMzE0Yy0zYzZlLTRmZDItYjZmYS1mZDQ0NDk4ZDQxZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHwZAJG/cethJ/8DIufYzCsmpeWMDfZxhLhc6q82Ju6FR1\nG5XJkb0LzU4hio5KuO1NnmhhfkJNNIzGB7iIXA+Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTP/tFSGN4Yg+s/HPxESoCzhy\n4PAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPEbm+k86b2R9O95xp0cuveeoBeNne2nXog9LVaR3OdoAiAOQn5Yq1C/\nHBuMOTddmvjMWmMX/3mxbzH248EgRHQHEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAeD7QC01WAtA7kA+ernrpceEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY4NjNiYTYtNWE3ZS00ZDMzLWI2NDgtZjQ3NjFmNTg4Zjg2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEyMDkxNDdh\nLWIxNjAtNGQ5Zi05YzgzLTk4YzJmZGRhMWUxODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMqcnIGpQKLu+qSNwhi9BouOUqPAt5lW1XfDbXZn+kyc6ZaLPS2/6qaV\nDlx6ZddFY3zSC0vyWYpQb5jKn0GkVNyjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCnrfdxo\n4v/Cyg/TsEaLT0nkM8AdMAoGCCqGSM49BAMCA0cAMEQCIFH6QgrEQGnJe1+vq82y\nDUXs7eOo1Z2g6qgAiR93ORzYAiAuzH0LLdd+gvCXTPlrmpmLTebV1kXqaXpiZaRp\nfbHTGg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5158", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5158` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfGMpG4KEG2Xau6Ltk1ek1bFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YTFiYzQ3LWRhOWMtNDgwYy1hNDcyLTg0NTA5MTU3YjIyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhlYWRiNGQtOWYz\nMy00NjExLTgzZDEtYmEzZTgzMjdmZTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGRilEMaGNCv1K60kNTCdEPufApQzaMUuyJg+b9VRH6Qp8DOs/JDdG3iq5xd4\nw4IEALSewRDu1NU4PFmE2L7QO6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmuhIli407Yoc4QyAnjlnaJgboSkwHwYDVR0j\nBBgwFoAUqXz6MNMLhtK7AA1+i3LVxInIPrswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAy9XklNVicyrgjx40dlrG8/PFyt9vvnC6W+P+OfgL088CICTKg6QwO2qv\n5UFeQ9TTDhcrdsF22GRR5Mellxu6d8AZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW6CS0JwkzdimJZ7FbGqcgqFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWExYmM0Ny1kYTljLTQ4MGMtYTQ3Mi04NDUwOTE1N2IyMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW0w612QLCoQApKHnkK1GlB4K4C1E1M1+xydnucpsnGYo1\nF8GLx4jS92bn7/z2P+umC1Jzp+M08VyLkWMXPaodo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqXz6MNMLhtK7AA1+i3LVxInI\nPrswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWqiuIgEfVMZyLQz4IVIayDWa97LewqVnYFTaEwhiGkwCIQDS6dvlnZTG\nAoP40gYj5fAdr2nquv2PeF2Yn8QFReIEVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAVfE6GFuJfAmc6xOGMTIH/x0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhlYWRiNGQtOWYzMy00NjExLTgzZDEtYmEzZTgzMjdmZTBlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU0ZDJlY2Q3\nLWJiOGEtNDk0Yi1hNjg3LTQxN2NlYmU5YmI4MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNeDtCoJWNJjMOz7KP0Oq+yZY8pr//PnKf7qPor7lXLkKEmmxHKxGCj6\nx18mIKAWf0Ec9AnmdK4yOiN8u8na3xmjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJroSJYu\nNO2KHOEMgJ45Z2iYG6EpMAoGCCqGSM49BAMCA0gAMEUCIQDe+jqm1jABGFVUH3ex\neuKhIPvHuMGAmnnaZ2BeTI5Y8QIgRotODGnkaUzgHhuEcpVJvt4pXRc0SHbVlvtj\nf46Sjg8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5159", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5159` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAeX7RqhCsDLB8Ix56cCER089MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkZWM4MTI1LTQxNGItNDg3NC1hZGJmLWNhNjNmOTBmM2MyZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU3YzY4MWQtYjUy\nMi00ZDEwLWE3N2UtMzQ2OWQzMGQwOGMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyGuvA23kVJjpa/aVIatrSP+oXMXdxfbclpE8p8OXxCxAZEcKE44L7aKVp0Hb\nugVB/j6FkLGIpy5pUHWOxq7JHaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc/JM33a8M1yc5wpy00ZQmkguoYQwHwYDVR0j\nBBgwFoAUxZslz+eR3CaOMGYMheoKOVoS9HowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA2JEQOAmlkY8LKZ6ZySH164OXF3nd2LI0fkulwzuk\nlW8CIQD3yoBYsEbqZMpI3mQ7y2/ZvppB9kESJVmnl5WzH4g+kQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVETnETz3EIljqloBnHEVCzMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGVjODEyNS00MTRiLTQ4NzQtYWRiZi1jYTYzZjkwZjNjMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFB611lG4a+E4MNqIp0xnIUBt90uOcHvwvzUEI6kA7+k+8\nnQnr8HsS6I370qK1avQaBkP26JRfYDHf4uLOpTMUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxZslz+eR3CaOMGYMheoKOVoS\n9HowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL8RwqAl2haMRaYRr3Ybv+3S9B1W/DicnMubbNZS1rTIAiAYq1/YfLAX\na8ztxEyAT9tdivy5Ldgrp0SMe0UNsDpXEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAX7AJBZaR2of4WBUIuysxcCOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU3YzY4MWQtYjUyMi00ZDEwLWE3N2UtMzQ2OWQzMGQwOGMyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY5YjMyMDM4\nLWM5OTItNGRlOS04MGExLTBjM2I2ZDU0MTJlYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI95H1/aE+GDFlUNprKJIuP/6KrZz2GhJ37UrNqunoA3K/J48xrjGuuI\n3USx7F53pCiiPy2Um6Dh2aaju7i4JhGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHPyTN92\nvDNcnOcKctNGUJpILqGEMAoGCCqGSM49BAMCA0kAMEYCIQC6JGRfZdx65jihFHHJ\nhmCr8k3VA6Cf5fSjyd856Qs1HwIhALqc348qW1E9fgyj8p7riWfYez5gfache4iW\nEnK37PGg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5160", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5160` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZbeEAp5hotHpDuHKdn5co07MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5NzMzMzQwLTIwZmYtNDY1MS04ZmQyLTcxOTNjNTgxYWU0ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFkOGI3NWEtNWEw\nZC00ZDc2LTljOWItYWY3ZDg1YTY3MmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENPCfWzUM5zqu5IyamfpRpMNS7YZE0+P2j5+69oGCY/jW29i/1X/ghIdeo8Yo\nx5OAmllSf7T3tbuv67CF+TynHqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0b/O9sux9PxqmvgzOZu0p8kl9VAwHwYDVR0j\nBBgwFoAUlyc1r7xlbpRTt3M80vep8NKX5cgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAwUKeoCkNOjbVzk2keZlg2kNnYFrb43h6ynZrVY5C\ngNcCIDwEHODVLpMhgxMbUEqc2kv/s3l8nPeUgW+y7hhyHcrk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXvGiVEpxtgpVigc7iTu5CMIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTczMzM0MC0yMGZmLTQ2NTEtOGZkMi03MTkzYzU4MWFlNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCP5WWSXD5fu7km4r0dI5nKKbpl6zKk0r7QsPx83m5ygbA\nS2IpElMPWv5MW9vK7VUaRDXO3AM555/7G+IdyT/Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlyc1r7xlbpRTt3M80vep8NKX\n5cgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIDRbrlgcyrTlMAEnjINRqnDi3ETRi4JYgkxAxhcrXMgAiEApmKk5lKP\nxopvLJ1dZkrv7OruVVr1V1yhCip/4lzrqZI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAbSdhAQ3I649Zzi664Rwtgt8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFkOGI3NWEtNWEwZC00ZDc2LTljOWItYWY3ZDg1YTY3MmYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI5OWMzMzQ2\nLWM4NDUtNDM3My1iYWVmLTkyYzA2NzAwNWVlZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGC1T2lQj//COaPDdzuoPcD3f4BUUy8S1Q5GT437Qxq4okqXyXZaqjXw\nsGTWGNxGSAKHylIPMQFaDRzV/sPk9nejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNG/zvbL\nsfT8apr4MzmbtKfJJfVQMAoGCCqGSM49BAMCA0kAMEYCIQDBGJun2TR9KKpmszBP\nF140U3gV1OSzTP2gEPQakAUElQIhANsJQrJctlrSdmfzY+D+A0ITKVaBsKv/jw/V\nibM7UuyC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5161", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5161` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAS2cvamkX+wNwoKXRaXRcFTSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5YWE5MTU3LTI0ZGItNDIyNC04ZTViLWFlNzkxZDAzOWU5NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjNmZGJlNDAtMmM0\nNi00ZDk3LTkzZmYtNzJjNDE0ZmFkODNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW3NK9E7dgS6Vuzaopwcn4Qc4IyRrANwh7aUTPgl43Eq1A3fFy/FSrb95k1R0\nd2QCE2YJeeqJLY89f0hgEjReDaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeOWzPGPiRyaREpy5zErerfZwxrgwHwYDVR0j\nBBgwFoAUQoE8NejvRa/9ioTJUA26erp9vEswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBZnhCL2uKTHjySX3k/Na6cr8t/BRF6yugtrrVz08GFhgIgceq8\nAFSguVkGc00P4PxaFOnCBLGx5eJhBhKge/5M3ps=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR7hfHOnq/YRaEIgREYGkynPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWFhOTE1Ny0yNGRiLTQyMjQtOGU1Yi1hZTc5MWQwMzllOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkyOTHHOpeBrabEcOUzwaHOG9E/0PYrLIWc5VWPBLue5aM\nqt6AKcngRfB8pnBOBuISxI9g91qtHomgqHkjJJkbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQoE8NejvRa/9ioTJUA26erp9\nvEswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPiAPINhAAFnYr46WSEJIYYfbS8eL1rcuL0vwZrlWILlAiEAw8ExfGt/\nV38QD6FmxwKGztV0aQQdiKuiA9kAkBn8M4E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAeV/063lu7tthIlfDT/Dv1KKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjNmZGJlNDAtMmM0Ni00ZDk3LTkzZmYtNzJjNDE0ZmFkODNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFjZjQxZmQy\nLTUxMjctNGYyYS1hODdkLTVmZmIwY2JjZDgwMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL/As62j7b4/9QEbxAEzW7E5IqTD7PtSkGl9Buo+w7EtJTMYMjJzPjII\ntOGAvv6KZ6aH7F3mNFbRSrIVe5uER+mjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHjlszxj\n4kcmkRKcucxK3q32cMa4MAoGCCqGSM49BAMCA0gAMEUCIEmf0oOiSYxiwkSNPxdW\nG/w/OgZLgUt6me0mw/Q4uIDaAiEA2+m0K6ENMNcJnl53D5BGpphdH6r4mqVcmOF7\nwxmOfsc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5162", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5162` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARIv5jJdu0Tto5xfeOvGLP/BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0MmIyOGZkLTY4M2UtNDRjNy1iZmE2LTIyOGU0ZDQ3NzE5MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFlMGEyZDMtMTli\nNC00MzJlLTg4MDQtODhlNDMyNWJiNDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENpB1m2EllTAIqffPnxrXeszfksKBOTG16cRcl8Hq65yQ8NXI6oGFuMdMAbAe\nd34eYxyfPSQrKWjnOKfYAE0g3qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTuw0Hpma+3H3GM5wj7GPpnh4yfIwHwYDVR0j\nBBgwFoAUVWSuzzJxVHLZbGr2i35jRp/q3+YwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBK06IU+PerBabGwilz0uu+Y1EvMeqV00bi\nTq5BBYqBuwIhAMIuox0vbXI2Nqldf6H1M6vDMfsDJ0XpE4RBlkpP+vwo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdCub3ZuyEoA/aX8bVnCHKBzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNDJiMjhmZC02ODNlLTQ0YzctYmZhNi0yMjhlNGQ0NzcxOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5mcS4Ir/Qdctqz1ABIucE1UyGMQLnTLhSM6A6F7lbNSdw\nYAOhTwpCl2fsu3xXPgynaVXeHQUiGemOsZT4Ybtuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVWSuzzJxVHLZbGr2i35jRp/q\n3+YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIzG1ijBUtEJq1xil4bMrA8wh3CK+MSc3XSujzz3/vWpAiAN1Nl3i5yv\njXTXNWUcxUGe1dAlaSJSumoPW18lbtF5Dw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAdEQ9SRM3rEwjhStELT5VQ8SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFlMGEyZDMtMTliNC00MzJlLTg4MDQtODhlNDMyNWJiNDQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg5MTVlNGE1\nLWI4OWQtNDUyMS1iOGYyLWJmYTkzYzg3MDRiMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFSyvojaEe7zDQyxA93wM8SOjivCojOAij3qcvSzHZi+w2GzXZxBAeXB\nCkVQp6MyYl9qErzYnTasA13WDPH3n9ujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE7sNB6Z\nmvtx9xjOcI+xj6Z4eMnyMAoGCCqGSM49BAMCA0kAMEYCIQCHj6ojUdES2mgRrWpq\nNvPfzGX9e8gDsFbIo8Uaj648GQIhANkCq2N6RPLb6Xh70StdgTdTCF0/V3jmMthJ\npVPfnTLf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5163", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5163` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAZwpeq6PYX9FjScGwFc8OhYlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmMzhkYWJhLTMzYTMtNGQ1OS05NjY2LTJhNTQ3YWFkZjI4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzEwNTA2ZTctMjdm\nOS00ZGE1LWJmYmItOThlNzdjNDZiZjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+hnyJMb6oFtxoIBU0ewIoQvtGz+JCoSFpq1YdSRYQRxwpxFISdc9n7CjJT7J\neIXuMzw4UFXsjAysXupdpgCl0aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKyDMAN3jtRPjXILdK79Gi8SODrQwHwYDVR0j\nBBgwFoAUlhuiJ5DA1zJK5ftRMoFbmfE7pO4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvX5S9j6M6BVAO8V2HQ/hKsjNSesg8yQ1\n6hLHmNNxY4sCIQD+QUrGPs5rXKxfAG6SytVv5T5tIBNSZWXKwpr6uovRVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARHG2yHYxLBwYoM5g7OXRU6KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjM4ZGFiYS0zM2EzLTRkNTktOTY2Ni0yYTU0N2FhZGYyOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+XjIxnw/sr5VjD/kz4XLCVED5fCT7RmAAu19bampa2ziL\n87qgACxygPgr02bVGS5LXrA01ZTJXfJxLbBLqldUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlhuiJ5DA1zJK5ftRMoFbmfE7\npO4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLKASSzhbq4VN5M4pzS+fMQ3ZHGJ0po3mwIQ2qOBbs44CICxmIdH7oPoC\n7en3mDdY3vV9ofuEH9eGNEXmO+xaJOkV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAdJssEcgqNk2ycQP6I/jaGRQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzEwNTA2ZTctMjdmOS00ZGE1LWJmYmItOThlNzdjNDZiZjViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDczMjk0Mjk1\nLWQ0M2UtNGM0Mi1iZTE0LWE5NThlNzg5ZWIzZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCozWYFFOzLY2wcwbJWsqwNaaxGLqdiLSewkIkZe8LCx9U4nxx0VLqe8\niCDA0nRRAyz8Ipr2UszUM+gP6UbClBejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCsgzADd\n47UT41yC3Su/RovEjg60MAoGCCqGSM49BAMCA0gAMEUCIQDcTtwLkSEZnUdUeTCJ\nEUIAV0iUWYW3OebdFMaISNAiiwIgYSECUQInuUbloJGx2qyDb6PvMVtFjvxmS1lj\nVvjMhfY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5164", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5164` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAXo/TkfmJl4qX/4AuTDT6qFKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhZjIyZGU5LTFlODYtNGUyZi04ODJlLTJjZTI1YWRlYWFhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFlNDRlOTAtM2Jk\nYi00MzZkLTg5MzUtZjNiYTE0MTBmZmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESmV9usVACD/iH2Q0GkMgqoE6AGJLOoXLc9PpTJDAktbeqDY2z2zia5NvqKJd\nnbmQPHZ+adfUbNEk4RhpUB/+XKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGYVCZOswf7SP67gqVinfZryb54UwHwYDVR0j\nBBgwFoAUgGcnYS76v+Hv6khaDzKQGx5s8GgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDmjN36X9IzgLJl4hQLhm+KrJ+C\niGt64RUTEglYDW+BbAIgDx4KuP23mipQScy4qUWlNbeiWi2O7VD9t259sJt8+gM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf12TJ6LJnBmL+FSp4enN57MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWYyMmRlOS0xZTg2LTRlMmYtODgyZS0yY2UyNWFkZWFhYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQE397j5I8ryzCO6KFLyOHUkru2A55g31QqR8tqk7S8JBZV\nNd02B5lEIWKvXyXkHT8HJbSSMOIdtZqIt1g5fFxEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgGcnYS76v+Hv6khaDzKQGx5s\n8GgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWsRl1scgzAyuWtRZqaYZAtcx7ZyRLnCMVTunk6GVQy0CIHFp4KgQNNjR\n03OhzHARkFIeyeQipFzin2SlweTU9RGh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAfV84F5i5P+xEliWXwwlNHqSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFlNDRlOTAtM2JkYi00MzZkLTg5MzUtZjNiYTE0MTBmZmI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM4M2ZjYTgw\nLTNjMTEtNDk1My05MTBjLTg1YjUyMjJkYTE1ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAUcVA2StToKdg/sM4EUSfikHyMLuxRiwzXyp07jsCQ945FMVo3dMZ4/\nCndQclw5Sp6MBGFgco8GewAon2GnsJajVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBmFQmTr\nMH+0j+u4KlYp32a8m+eFMAoGCCqGSM49BAMCA0cAMEQCIEfOT44lm0i5KTYweiJB\nD6kSmIHrCo8kd4Crio4CmMPUAiAHfjbeDx0TMWtWf6ECeA8U5Dh3qHQen9Sj+8iZ\nM6yfXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5165", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5165` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAZ93RRjdTbS5qAiQUSHSAWDLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNzM4YzllLWFlZTYtNDFlOC04ZGE2LWI1ZDU5YTY4YmExNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJiNWI3MDMtNDZh\nYi00ODhjLTg4MjAtYmVmZDUzOGRmMzcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENYuYRhcHMoc7ES51W5kNsZWsbQ8n8OJE0ZM2eqpiPvuDWo7vUfS+vu9FaWWd\n+9E+UZqvGsn67etNOabYgMe3O6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq5wFvSB+mSdw4I7ZtfsECldGq18wHwYDVR0j\nBBgwFoAUUN1M9DGYZvdL9ZhYHzYJuzYDHjUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPQcyYsE\n0svX8zojAsLeYynLlURek1ea8vbV406Ifjx/AiBmTtsK0a85SYRIuoRdFKYuF5jp\n275Ng9DZ34xO5nhCHw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZRgb6LKSA5ImZN076tKzTR9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTczOGM5ZS1hZWU2LTQxZTgtOGRhNi1iNWQ1OWE2OGJhMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXf2I2UZzMWJv2rSU4uy07v3cHeFuGWmsBptqVv6Zxf0+q\nj+kWGy1t+EQsxtFNUuJlXJlng1xfrdsVfNHXabH7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUN1M9DGYZvdL9ZhYHzYJuzYD\nHjUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMnCp/iOwlvbdsNILTjkzWsBuF60oBM4KIpA8XBoODQgAiEAw9C8tpmT\ncwR97prx6COd1o02slxwXhGeDmv3eMUeL4M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAS99GxrXKb51PCgcrgKMoMT5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJiNWI3MDMtNDZhYi00ODhjLTg4MjAtYmVmZDUzOGRmMzcxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYwZDhjYTkz\nLTcyNjctNDJhMi1iMGFlLThkOTI3MmY5ZjQ2YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNukcETWLxR+HJk2QfksZ8HVotOMtGNd9TcXt22X4iNjoS5Mb2EC3bjS\n8Uf4kWkFPGkSihuUAqHm1j/VY34glPWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKucBb0g\nfpkncOCO2bX7BApXRqtfMAoGCCqGSM49BAMCA0kAMEYCIQCqAs0rvQXPZZVrFFnk\nFRdlsw4wVuJSbQ2qVdVlspDIJwIhAIn+dbB+9j4HUumwb4f2A5FXSuZ9iq4mX9HJ\nYTlSH1/Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5166", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5166` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAUyRZVJOGA6j//ugjZ/mFyiUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjYjJhZThmLTFkOGYtNDNlYS1iZmM5LTdmMmRlY2MzMGE2MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJhNWFmNTItYzUz\nMy00MjE0LWE1NjktZmQ1NDNlZTgwOWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWhrN9YIP69CwI2m4oMUJrclqVjf84aFxpB8jFNRmKaWJe6asJOtjKzfVbABj\nfV7CTqclFuT2gPxMtvdQhM1muqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOAsyiRhalF9uc621BeLvU0hioqQwHwYDVR0j\nBBgwFoAUqwt0f3RqUkFHlNhqN+Rl/QZ3fX0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgA6m3O9RK\nMtGPuGM+g82lZZFqvNwU37QqkItAU+YeiWACIQCBcRGGeE+N8MKLE8Je6102Weyk\nRkUdSPvBBur1iVv53Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZRHUWYH6iSKE8cAtc9D8/iGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2IyYWU4Zi0xZDhmLTQzZWEtYmZjOS03ZjJkZWNjMzBhNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9KMa6vFNsgd+la2xB6RGoYMpivvqK4ymGYyG99ycptgd9\nXMTOMZg9DJM0928ousSu+anJqz4sQQRyZ4IjZc8Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqwt0f3RqUkFHlNhqN+Rl/QZ3\nfX0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKQE+IZxWeGtB1vSWPsuVayuC+s1c5cnC4Aun1hrNYbEAiEAqR+zYnpp\natv4JqcJnYz9eMhmZPQCVwmwWINRehva6pQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAVdL0crC4a2uGp+dzkIpZVvuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJhNWFmNTItYzUzMy00MjE0LWE1NjktZmQ1NDNlZTgwOWUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI1NDMxMmE5\nLWY0M2UtNDllYS04ODVkLTI3ZmRkOTgzMjlhZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLksa9DrceyPnDMKARdXkMGvGfDksCKDT3A2U6pkoGWB2GQa6N/GvPjx\nvzlIpxdy2gi1uTr/YvS/iIvUfRUW1cSjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDgLMokY\nWpRfbnOttQXi71NIYqKkMAoGCCqGSM49BAMCA0gAMEUCIQDolZxA50c7Wtd3opDR\nlyGhWqri/GlcCYvtuAWSHC6loAIgGuDVHv+iARuxggQWSw9q3mIyL7IOKZVLYOb5\nLFZF5m8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5167", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5167` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAQ2DleQwlC17U24mOhVvCIwGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhMGQ4YTU4LTg0ZmQtNDUxYi1hNjczLTJhZDAzMjZkODU4NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ4ODlmOWEtZjAz\nYS00Yjg0LWI3NTEtZThhMWNjZDg1MGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvBvJQHe1jYUU+Srujn80F4sjvOshSeFWTJiQjLp2iBot8wmdQLbjxwiyfxfw\nzwgSsgf6BFNIspUaLGe8VJNJpaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR+MD0C1ogu7VJSxwVC4fY706P9kwHwYDVR0j\nBBgwFoAUftXNDiLm7VbAQYsvfOVMx522olEwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD3+gB9\nOIURXoFprCvGhaZWEc5Zr0+wTlJfCSp3tdMeiAIhANgiLQHc1IBqqaBoyR9CpcYq\npmUL9hQ2UMrpSFcyLFfM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYK7YaavBNXHa7mUPU7Cgx41MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTBkOGE1OC04NGZkLTQ1MWItYTY3My0yYWQwMzI2ZDg1ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdKaM2ID1130tHhciN0i8vc33bRftN5nTMYolkJwYyAVXb\nXk+8dg32wrDvXcodTHn7Ovu2cALhZ4GuMsy/bPZMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUftXNDiLm7VbAQYsvfOVMx522\nolEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF5DRioKXLer1eLRBmu/DnqVTZ0DBJOtBgfC97ncpDWUCIQDm8k9aWfoZ\nB8Kbc5/UCYPbUD4+9kgqxIXLZreMPJgJ6g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAQE8mS3yy9/ojUFmyw4HhOLbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ4ODlmOWEtZjAzYS00Yjg0LWI3NTEtZThhMWNjZDg1MGMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJjMzc2MmM2\nLTQ4NDctNDIzMC1iMjNkLTljMmUyM2Q5Y2EwMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKq5bBWDn3ynebmaRZsRiEwdnsojM9KEO0I7Ulc11t4qEijoVAblKZQM\nj/kOTVNiahBovSbGIb+pwrYOK0pyYUijVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEfjA9At\naILu1SUscFQuH2O9Oj/ZMAoGCCqGSM49BAMCA0cAMEQCIA75lJOu2HY65RfWzteL\niZRM/yTePlp5UTAGHCXCvmxWAiAFyR4NW+PT7tFtq4jdFKLfWrYHE17SZwFwudgX\njmdoKg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5168", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5168` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAaDhmhcf8b9zeOAxZ0Klrg79MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyZGQyZTY1LTA0NGMtNDg1ZS1iYmRhLWNjZWRkYzE4MTAzZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTMyOGUwZTctY2E5\nZi00NzJjLTk0ZjctMzhkMzhhNjAzNjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX5SVzoQn4kS19M7t0Ch5RAdXzneAdHwiQWp14sEhvQq/QndFQvMDYfUoP4VE\nQemnk6ltzwOkFAHhslkSiPkYxKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU68sLuYzpo1RNNI54lZ7OaR8gcEUwHwYDVR0j\nBBgwFoAUCiqZ2Jdc3/ZrVcgRVIhsl2O46w4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDw35wNfPviORIpCpDe3bIfRM+fkwdrqk+fp4g8YxaAAgIgMSwo0J97\nuv0NdLfR/gCQmJjVOMOwv9zDQU55wSkJZiI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASXTS5UxuI+CcOwg3xkMZ5m1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmRkMmU2NS0wNDRjLTQ4NWUtYmJkYS1jY2VkZGMxODEwM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASERn2KcEZ7U4SNLDem7e5er4tLxkNtjvGbi640sDRmG72N\nB6kNI7A8+h2pe0Uwd7bbwj+WmfQc89QC/szDVqioo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCiqZ2Jdc3/ZrVcgRVIhsl2O4\n6w4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOWbXqwZ2uKG5Fb7Vh4tyWqGeFnlhNZmQG+Ua8RhJ4CICIFVpB+r2+gaj\n+BO4WawCkKDQMWtV2T+xUVcxQmUoloOT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAVCCvye9JrKOzhI1+VheL5nHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTMyOGUwZTctY2E5Zi00NzJjLTk0ZjctMzhkMzhhNjAzNjY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkyMTM1ZWU4\nLTAzODctNGM2Zi04ZTEwLTlhYjZhMmQ3MWRjZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN0pVLoq3DCj+DEHbp20v+gBmMOTCDuAcuQ6s91wYssVztE5oSwJonKj\n536YxM4PvSL7qqbvB+ERP28S2efegAujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOvLC7mM\n6aNUTTSOeJWezmkfIHBFMAoGCCqGSM49BAMCA0cAMEQCIGba4zHhx2grqfeMnPfH\nOR87Ckgg4vF1kTG+xNecAVnmAiBD9TUONZJfmX7xN+QJeJjT7GLhivULqnjRO31M\n/M0Yeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5169", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5169` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAa0YTP5Wo40JeiMoJsiBnPDvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4OWIzYTBkLTc3ODgtNGE5Yi1iNDc2LTYwNGY4ZTQ0ZTUzMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY1OTZjM2QtOGZh\nZS00ZTkzLTljZDMtOTEyOWE0YjAxMjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBOCjvrhTQ0GRVQqqLGs6Z3HaZBeZjKt+clFs7wigClq4FKsteNH7VeApaBCu\nRIMBidkflED53pSasPhktRKNY6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU3QyvGfYJ3I+GlLkhZYiPl1KHswwHwYDVR0j\nBBgwFoAUWm7ZE2wzsfUCKk0BgG4AXWarvZEwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIFaCSqb+ae3v82vA3HMlevqjwgqwLnTt1BqRsUr5T79tAiACGzn25OS0\nY2pO/J5OI7g2MIY18Fl5oTXeNwl+sOcrfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfWPW9WjK+O6EcVC0GGhnHE4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODliM2EwZC03Nzg4LTRhOWItYjQ3Ni02MDRmOGU0NGU1MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgHC2bBkAFt/X4KWoD8r/IpQk/qcGHkI1+qizwmvt6z1bH\nW2WLYJD3c6yBtjzCBf3cBhteowzIqqRmFHOn1Wmuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWm7ZE2wzsfUCKk0BgG4AXWar\nvZEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEsD1tM4k2gHH702SEw3xvhsbkUhb51oovAs/umhwhMkCIHfhEPq+UyLi\nFCuq5gzT+U/UyUkoCr7AqV1KZgACJIvC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISASZxj1HDANHuG3LkFvsKqrLeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY1OTZjM2QtOGZhZS00ZTkzLTljZDMtOTEyOWE0YjAxMjhjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM5OTk3NzE2\nLTk5MTQtNDIzNC1iZDExLWRiYzRjY2FiN2MyNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFl8AA31tXDlFG+7W56CiLze36GntVdZoNlAifscg5biBESNFdZHoE6e\nF7RjBcctwrdvAScgAkpFbn6YlLeoqjujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFN0Mrxn\n2CdyPhpS5IWWIj5dSh7MMAoGCCqGSM49BAMCA0gAMEUCIQD/fMv1zGccrA+GgDem\nsFy4YHDyHCwYRvx/DKuauNym+QIgTAYqmqp78a0vMFJ28o0hW28MdY3bFEjod0Up\neQLFvoE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5170", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5170` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAQLg5YZeC9dN1QrLZv+c/TEJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNjNiZjJmLTM0ZGUtNGFiYS1hMDU3LWQzYzFlNjQxZTg0ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ1NWM3YjktN2Rl\nMi00YzlmLWExMjgtNTBjNDE3YzM5MzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERULUqXwO9UQzBpiD6hl5330sUhTQKnuc59Xnrj1U71nq9rcDTeiQd5iQz/3T\nERqhTxhoJXWPA+M7gaXTnbmkvaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7w2OB3/4WK3zQW1VnomlGVZomekwHwYDVR0j\nBBgwFoAUJWqeOiDR920GUQ34QdmhobhZ+64wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQD9BRODDAuuHvAjMcUt1U8MSRzEk08U4wDBTb5aKcpq/AIgC+INvnWe06MNZF0i\nw6qiLOYDzFyQduLJ7ZjdZfzqFWY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdH9CA6ZaNrSutHAwH2jDom7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTYzYmYyZi0zNGRlLTRhYmEtYTA1Ny1kM2MxZTY0MWU4NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+f4DT2aaOe5yyJ/1b7V627pbn9VS5/caYX5pLova17MOI\nngDJvyfZu6TJm3UldmVGhIRYOfDzM+VjGuxiLZjyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJWqeOiDR920GUQ34QdmhobhZ\n+64wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM/5/8zl3ZfBymEPPtqzJ07yCJK8Pw+I2s3MbvzNhu5XAiBaYaAVO9W4\nwvWziGwxWlg3zeLCjAA7IAwaVSB8WdrA0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAcMxwXbUza8Npc/E5fljruzoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ1NWM3YjktN2RlMi00YzlmLWExMjgtNTBjNDE3YzM5MzUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYyMzZhMjEy\nLTgxMmQtNDE1NS04OTU2LWIxNWEwOTc2ZGVmNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFMV5D/NIL5c6cCqkN2PpElYTR8Z2kJuvXAATRohSn33GzbXVSxBH/5k\nbrUalpg209GPZicAqmwML2Cq7dUcUsCjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO8Njgd/\n+Fit80FtVZ6JpRlWaJnpMAoGCCqGSM49BAMCA0gAMEUCICzGNBvw4Zy6HWgYRIYg\n0uouoPcz+lwRM2upFPI5A7OwAiEAskJORLZwBc34Wt8LmnTYp3lLESpx/p3sKLEq\nCzl6DPY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5171", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5171` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcKvnjgPcgbXE35/Uds4bGbrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1OTljOTNjLTUzZmItNDBlYy1iMzA0LTY3ZGJlNDAwODExYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGIxMmZkZDYtYjEw\nOS00Y2E2LWI5ZjUtMTI5ZjQ0YmVlY2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgSYfCzVWgKal+jLndBn09986TJUv6JvWQeFLlNYxGR+hWpVyBBinejPumM3r\nkRBh3hUZGiJd2AiGrnfDM/9vkKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTl+JPUVUKVVSTOUrVY5os4SUOnYwHwYDVR0j\nBBgwFoAUgrSoqHi779U8JirEcVQe75czNLEwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDzkEvQZlfGwcoPY+3IqahTq6ioHtvz1EBDxLTH2kjlMAIg\nSQWl5RbRVz9XEwE3xB/313S3XRh5ZcWFodIF4IriIKk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQVTqw0ohXx07QshDPdbRT+0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTk5YzkzYy01M2ZiLTQwZWMtYjMwNC02N2RiZTQwMDgxMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7cctd6M36BiIbiJrRjSO5bszZM0iT+KeGN81ozg5AwlzO\nX/8+aUnRvhta8ABMJHv0y16Ph+TX8kmcIMiv+iM4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgrSoqHi779U8JirEcVQe75cz\nNLEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE3MNWVCrEJBubPCIDxdxRccbR3MQv3qaTmXqbgU8OQoCICykcn39JyWF\nSTwa1QGoZGZZV3zcdyVTrXHkPxAep07/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAXZMJZFS3TgiUUrhgGTC+wP+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGIxMmZkZDYtYjEwOS00Y2E2LWI5ZjUtMTI5ZjQ0YmVlY2I0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQwNWU3YzY3\nLTRjNWMtNDY5YS1iNzViLTg5OGY5MDliYmYzYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPla8W7nn0IH5XChpnlx8NOKM4LXgOGs/xXcfLlQqi+KmpbAvGTvM+N6\nl2ttN5r9uh9ZnCmrrT3mTf4pyGZt2TajVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE5fiT1F\nVClVUkzlK1WOaLOElDp2MAoGCCqGSM49BAMCA0cAMEQCIFsBROexpLS1mvHdTaVQ\nXBshbejKh3etSRwAwd3LMsO8AiB/yVu1/aLKgg+eWsP2jJtRdsb3OtFF+GSOwDeY\nTN1ejw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5172", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5172` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAX2j3xd71aixo1PGxWDMfCi/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwY2IwOTcxLTgzOGItNDc5Yy1hZjgxLWQ5ODM3ZDAyZWIxMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTliMDBlZjMtMDFj\nMi00ODRkLWFkZDAtMTcyMzViMTU3MDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF5y/2KTKOZXDJfnu8+uBWxXoi/d5A4DVx8SCOTanseqNbxbWbH9u3iK8ckna\nXzEthdDkIzCR3Czf7fpLdcLDEaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtefkMPSfwOEWC3XmtArk1TWgyEUwHwYDVR0j\nBBgwFoAUhJXom1NZfSS3Zd3Ictve8Jx+QoowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIGiCBsn6L/kDBayZkgkmuMWESpH+x8FvHH9Iza0jElz/AiEA\nmJXaAIuvpt+6t4C0nWA80WngyvLanZswTYpiPP1ZcMA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYBP51MnTb6nQtgA/YWFicFzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMGNiMDk3MS04MzhiLTQ3OWMtYWY4MS1kOTgzN2QwMmViMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJRITWoDAfeQMZ9sCtU53hvEvrwdG8fO+O99kG3yABSmoS\nITJpyYKa7PmcKdgyTHXGQqkWdSOSfJlZfVKPwZAdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhJXom1NZfSS3Zd3Ictve8Jx+\nQoowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTSEM0jfFqCEmixoWC3p0ro5so9xQVwFSt7cajHRAWmsCIDDKYuOXTBdf\nfc0QvuVTjUsE7jDHFx+qjJoYdaBTKRc0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAao32kAvisYSR3UUcEZub8VcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTliMDBlZjMtMDFjMi00ODRkLWFkZDAtMTcyMzViMTU3MDM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQxNmExMTQz\nLTE4MjctNDg1Zi1iZTc1LWFmOGIzNzdlNGU1MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOBekjxPgin4MGH86X1u7cgcVSmhW8HvIE1eeG8hdKQI4AdXUcSwH2TB\nMLeQu/d0tOoPPrbyLqsPgDdJkISo/5ujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLXn5DD0\nn8DhFgt15rQK5NU1oMhFMAoGCCqGSM49BAMCA0cAMEQCIGpxJi6qcm8fgZ8OvEZC\nb2HM+zndbF4cBkzkHZjvJBfoAiBFNGMT5SVeGz1t0G+ZIr3GH9WsQv4sOa5xB42B\novEbCA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5173", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5173` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVsDYVviTwf4Bf6tFH82ASnEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YjFmOWFmLTYxZjYtNGYxMC1iNDA2LTNmNWI2YzNiMDY0NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgyNDFlMTEtMGVl\nOC00YWRiLWI4NjItNzA5YWFlNzg1M2Y2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2pBVzaXyJpdj4DUp8oUSIAF7fajyxAGtuhjdadi/5etDjabWtu9OLfTNzyLo\nGu1z2dkWK4WksAwh88epWbsezKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi0eTPK3peN+SxrQgmSHyptS1Oo4wHwYDVR0j\nBBgwFoAUHH/P2jLre9HL9GD0b3lOBESJmD4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCVsNf0rirh\n7vPoO57AQvXagUkjbZaZ8fPlgZ9uP149+wIgGYRoJbgkj4uPSBHECyqiFqDzyGl7\nriWJnssuep8VQFQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUSJfofu2GCVMK1n4zOU95igMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGIxZjlhZi02MWY2LTRmMTAtYjQwNi0zZjViNmMzYjA2NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuelrkD3gC2UpIGdZxvRN+HicBeVu0YHKtrC/i1a8ogaP0\ncDOjDVQL9f8LomLTWz65yFJbvY1vYrE7G8RV414Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHH/P2jLre9HL9GD0b3lOBESJ\nmD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA7VW9C2ZhYLUfhvzT/sQ89pINIpYs/hULGTRWmUFVtoCIQDKjaTSv7Dw\nYk5+TklSX555MfO3/FVFrBs4oJln/kKYdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAXRt4Rug3ZLIbZgWD5LH8aX2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgyNDFlMTEtMGVlOC00YWRiLWI4NjItNzA5YWFlNzg1M2Y2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhjN2FkZWJk\nLTc2ZmQtNGIxNC04YmI5LTJmMWJhNTQ5Nzg5ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ8+bl9Cx8RILRaSveKiYXSLCqQYEyviFyUFBTUd6NuS4yUcxfRpCkG1\nxLMFqbR5ner/5+s6AUxjij4dHgXnhB2jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFItHkzyt\n6Xjfksa0IJkh8qbUtTqOMAoGCCqGSM49BAMCA0gAMEUCIBSrEkGVfa5+YxN2BEcc\nOjsdjAHlHy9yicgw0Uyvf8HCAiEA5wVhj6MqzAfP+acpLeq/PKNBXb9BppmXhXZY\nMb/2u+Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5174", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5174` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISASbSR9+qYmPS63kqvKpC4UHtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjZTA0MmI5LWM3ZDgtNGRmYS1iNGJjLTdhNTg1OTZiMjE5ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTliMTgwZmQtOTk3\nZi00ODE4LThjODgtZDljMmQ3YzQ5ZTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6v6lJug5uRegLHhbhLbyCMF8HGcwnVb/TO+qjVZtQl+X1Lv11pOXlmSiuTiF\nWla0SLv4j/iQIo3m6jcP5bENnaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY6zbai99+P/Y+aW8AzGhIq4fG8owHwYDVR0j\nBBgwFoAUbUISgrbbcsKIkH6+G3/3uFzIeHQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgMF2KX6TKIhPKHFmsr+gGDQGvEo0ugcUiYhlqTyljkFMCIQDSH3mK1gS2\n8PqM0/UGdDBN/1EqYzbCrZlZ7Bd8mUm8LQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbff4FXtAGWYTksio8sx3nmNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nY2UwNDJiOS1jN2Q4LTRkZmEtYjRiYy03YTU4NTk2YjIxOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTcgXDLy/nqQjiv4hRgp/m0mQyv/Ql8wJWmBG7SFYsgMeE\n/alAG8+tdXEjZEjV64LOpm7nNR55MuPeGY8l1StDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbUISgrbbcsKIkH6+G3/3uFzI\neHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQUxxs3KaHMHpEEFWjsc79ufTLdrallr/sYvWXK9pBAkCIQCF456I67Ki\nRjAQrCo9qSceDerQvU6Lqz5EE7JoUMe//w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAdfiqJS9s9E2t/7KEhLJ1InuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTliMTgwZmQtOTk3Zi00ODE4LThjODgtZDljMmQ3YzQ5ZTAyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM0MmRmMjAw\nLWY1ZGQtNDAyNS05NWMwLTRiNDU1YmZhYjNjOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPNo2sNeTix3SuD+Ly7jbQCXY6eIRsGmphiQMXYxnyQuVCMuEEG9Q/6V\nHHSMS5i/D4Hibmnfd8i6MkWziUAvJyWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGOs22ov\nffj/2PmlvAMxoSKuHxvKMAoGCCqGSM49BAMCA0cAMEQCIBjpoKSlrCb8E4HOFySB\nGD4rHbwPh4XoKotDhG+eeGGgAiBUATV0SEBWZaK7iDIOmOs8QMButC8or1nTzpGR\n20YxRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5175", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5175` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARaDJg8ZqCvSUJ1mhgQQopWWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkYTQxNDE4LTRhZGMtNDE0My04OGNiLTczNjU1MjA0YTg3NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjRkODJjNTQtZDcw\nNi00NWQxLWFlNDEtYTU0N2RlMzhkYTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5nD0s9nBPqkhsdBMRPlgPdSFVeeJlGGkFk0/+0Uif3cKrcJ+5dNKWyM3rhxA\nvjIzLtfUWiYxIhVHbgssl/wdjKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbVKc9I/wlvL66vq53eCxAuMd37AwHwYDVR0j\nBBgwFoAUSGSGlAbu3HTXIyNZDKiZRx+sAnowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAIELZfiDWRLwqqrPGM24uzoVEBymXCVVcgA30M8oV3X4AiBJgSogu4qZ\n1h5OFnDPXecrGrOWBQQzsI72oNecDQi6EA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd4BP8KVVhMolUdQrook/UXPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGE0MTQxOC00YWRjLTQxNDMtODhjYi03MzY1NTIwNGE4NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH0p/kcf4+8ArkKgW+yWT/uzu3857iNd3lJesqJsfwqWS3\nwVPXy1G/noMNBaCfFWmlUFycI+CuL/74WTwl18x4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSGSGlAbu3HTXIyNZDKiZRx+s\nAnowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKBy+bTDXQaT0bs0pBe8l7geutZEWs4hf1T3sBVtGsZIAiA6bYz45P1M\nn36nEbBrBVQnmQj6Bff6+rGumoUsLbsS/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAXhryTdZvfX30T5udSQlRNRCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjRkODJjNTQtZDcwNi00NWQxLWFlNDEtYTU0N2RlMzhkYTYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3Yjc1NWQw\nLTM3YjMtNDY4Yy1iMTI3LTU2YzdiYzhjNTJjZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEKP0SB3DPyYS+vnzqVnSqweP0MfN5bbb8EmewTfvLQcj5uJqLafToKR\nDS0brJOFz4OgdsrEnbDTQbBQVHa0XR+jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG1SnPSP\n8Jby+ur6ud3gsQLjHd+wMAoGCCqGSM49BAMCA0gAMEUCIQDCqOAwiBjVwwDc7Z71\nqadEzr7R0aHwYzPx8+r8HFF4HwIgVEU5OKtIK5Yv334GJipe2Rb1Nf5A/2US35gP\nJmF3jH4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5176", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5176` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAZ+N5pIqgj7ihpAlnY9KvzFhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyNzdkMGJiLWQyMzUtNDdiOS1iZjhjLWEzZTYxMDE4YWVjNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRlMzA5ZTEtNTk5\nMi00ZWNjLWFjZWItMTAwZWZjOTFjMmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy0WJGPfe8tddxn/d4CSZ2ZdJp4IyhZsKYhlPbzD9AZQSdvhZbZPuKMtfeCDh\noHKJtvSq17MVQuQEbK+mkTGfIKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt3OcstR2UCGv1uMUYpGjeZ3gFMAwHwYDVR0j\nBBgwFoAUEkHw3UuZVd7IDS5Y/kA1Y1846oMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCVJy8fnqIVWplzb3hKQvfTQ1QVIT/8TOHCVkR/BB9oDQIhAPh2XHBA\neQV/zCYoWC/mFlxrloGGA4tDPxApks/7Oo7U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZcinjLV2iewzSq3AP/p0lIkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjc3ZDBiYi1kMjM1LTQ3YjktYmY4Yy1hM2U2MTAxOGFlYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/fcLIbPwLmJMNFalaEfQx3tqJRWQ3x3hAsDA0nkG2v+3l\nkP4hgDETWXHss/Lh5AthWgmip2WeYl0YfniDzMEQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEkHw3UuZVd7IDS5Y/kA1Y184\n6oMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ3Y9q7cZ478oLxRFQ30vQS4P0YiesTAHkL8gdTbYIZICIFcus8XRALBj\nHGpZx2djyGJq6/r36OZX+aGLHXUadSNf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAVa2zbD+ScyWi9xUqdoV0EWiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRlMzA5ZTEtNTk5Mi00ZWNjLWFjZWItMTAwZWZjOTFjMmRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEzNGI2MjIy\nLTBlMTEtNDM0NS1hMTY3LTJhZGRiNGM2MzMwMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMZavvS5HEccpb8GkmqgmDPYVFnyIddil0n2pyFbzZ0+t2BDHU8aX6rP\nijgpF+QhwKj2Uyjgl2cH32XoMBXnk+mjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLdznLLU\ndlAhr9bjFGKRo3md4BTAMAoGCCqGSM49BAMCA0gAMEUCIDfA9Up1iHJMiknA7sVO\nzAZO+MG2ppETAiJqPDV/GYbyAiEAvASnq/D8FirZrdtIoDZW97DPneqghxhfm+tH\nQVzaBeE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5177", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5177` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAWFyySEYzh6VckXwRgCMHhCCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2MTQ4MmJjLWY5ZmUtNDIzMi05ZTkzLWY4ZWZlYzViYjg5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBhOTczYmYtN2Ji\nNy00MzdiLWI0ODAtZWQ5NjE2NDQwMTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqPcz9UIMVI4ZlIHuIRZW4j/15KcFbqGun24XC++AAkTUAuxT4N+QQEZ9vsAn\nCNZ1KwEzAq7t+zyGVtdaiAVs0aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNbh9qZhu1PDVfFmy3hal7O0pa9MwHwYDVR0j\nBBgwFoAUOc+/n9KBwQc5Fblt+dh8TqJoQi4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDHHWPnZQ8PTbXAvflBM0xqAPxt6l2t1z7GQpmP\nWPKcYgIhAOo5NoDvETJDhnGofZfIfOCpf6yQeNI04bdpJry/EVOP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd3Dv6nNwlnV/6YwF/BtTdnLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjE0ODJiYy1mOWZlLTQyMzItOWU5My1mOGVmZWM1YmI4OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV/lPVKSWMA6UkVSreKKKJh6+NnDKY7KpXijKC484pCUn5\nViFkc/47Q9JP5yInSZB1h95iWZJduQdEaKSwDC0Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOc+/n9KBwQc5Fblt+dh8TqJo\nQi4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZppsPLmt50Wl7X1sr3NyZ7pA/0OMy8BafB6axqfGSRYCIQCQjVdtk486\nQkppoECkgp9pIRd3Wv/nDUeYEDM7g4in6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAVDjuSTdHm+/zmHpbhIMKqsjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBhOTczYmYtN2JiNy00MzdiLWI0ODAtZWQ5NjE2NDQwMTlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJhMWYwZTNh\nLTgxZTYtNDc3Ny1iMzQyLWQ4OGE5N2Y1M2IxOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDEecD2lx22aYDhNTSFdoKGI2yAvz+g5fiG8Xa66cT6081bbK6IZUg+b\n1/3J7WOvT44sm1A2jI4BwGpZxH9wVKWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDW4famY\nbtTw1XxZst4WpeztKWvTMAoGCCqGSM49BAMCA0kAMEYCIQCB3HOd92p7Sq6rYmhw\n9b/wBqwW9Pe1ghWbx3a7eaTgdgIhALqQySZBcdUYpex/BpXkV+7DwwTxZ+kdkhnj\nKkfi4eRf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5178", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5178` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISASmyRN0+uzqSUyw+T7ytgD43MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1YzExZDRiLTVhMGYtNGQ4Yi1iMzllLTQzODcwMDJiMGE5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzEwYTFmMmQtMjRm\nMi00MTMyLWEyMDQtNGZmNTBkYWUzZmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN0DJUSyUhV2ISTS4Xgq4BJJF5AUT4Im25QSXyzeQtTbRueXjJBTyKzMZgWGv\ngCeRHY+FuUmVyNhEj02zmUBQoaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB1UWDzU52l8VrJEW0oPE3qfWbqYwHwYDVR0j\nBBgwFoAUkN0COasoKExUihSThCet0eLbNS0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDsuqZVL9AotRmpVck7rKKnShLhT3wT0o2lFeVR\nnDaACgIhANFNxu/S4yEQhajmFXd2wdxjp0V+8cAr0CRdNMhYmyKW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY9tmQJE1mbDeeQBOZM7eJupMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWMxMWQ0Yi01YTBmLTRkOGItYjM5ZS00Mzg3MDAyYjBhOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBy+n8nX2Sj8onkT0EotBpLGETz83Pzjh1hRM5SJVx8ZK/\nQifo0Pv+g7uC8bJiy2A7l6p6rTDt0dh9G4sPHRAVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkN0COasoKExUihSThCet0eLb\nNS0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN/VN+jI5ge/1nCjjo0JdP741N3pnFF1NxVAnVQAC6BJAiByrrnzXn4j\nw7uNiYG/OC1PUKAnCAq6bvbmKqo3MavtAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAejNYZyDWmgjv0GV1qn2SByzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzEwYTFmMmQtMjRmMi00MTMyLWEyMDQtNGZmNTBkYWUzZmRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcxMzg0M2Fk\nLWU2ZjUtNDYyZS1hZjYwLWYyYzg4ZTQ4MTJmOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBjC4RG4Q7vKP96FC7oBZR9pFUEPCkea8ajVtJ+8zWJFq+gue6X/TdWP\nrnlm6/4F079o6oVpITHjHd7cckzkPLOjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAdVFg81\nOdpfFayRFtKDxN6n1m6mMAoGCCqGSM49BAMCA0kAMEYCIQCxn3aRaDhse7aBqBaA\nh2Kan6ML3YttWiYM3kc/kBGlkAIhALzLi8moCDBrKWhcTmIQk+dukmQw0+GW4Trz\n11VA4Fuy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5179", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5179` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAXzdjJP54nkiLaM5QvNFoT6LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyYjU2MDE4LThiNDAtNDE1MC05MzMwLTRlMjA1YzUxMjYxZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDVlNmY3M2MtYTQ3\nMy00YWEzLWFlZjQtNzFkNzcyNTVmNmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAZi1xCJXbmNpp8HpISAfUsCgbKmy7cbHDyw3JJNQRIeIaDhaIMRMwpc7nbim\no9uOK76X5y7AP5ZU6fE+StqmB6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqFDumHuTfnArffJ6rH0Cix7P4TkwHwYDVR0j\nBBgwFoAUSb1lcMqq1oFfpg714F36g7sWC+wwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDi5T2FuAg8UUjBFM4eORDD3Lw25CzrGo0a7reNfr8DfwIh\nALjVaiafHDD5lB43Sov3nSOJhhwC4N0hqEdQEz+wtCiD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAelhMLLWeBnfdwoinElTmlzFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmI1NjAxOC04YjQwLTQxNTAtOTMzMC00ZTIwNWM1MTI2MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARt0cgHjM5ifuZOO4qz80kxg0NjgGnbe/Msb6FZry2TTFn+\nkZxvxL4yR+KiwY8PXTLBvstiiVG29TQSnDzCoLmto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSb1lcMqq1oFfpg714F36g7sW\nC+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN7ON3+YRhYwf+NLNicn3zVQfy0IYrwBhbx3GYO1+WUfAiEAgHACHsaH\n0GQizr5QIPwWIR3FPCXOxD0t5ftaMTsiERM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAR8/MxDiPmCL40dtpTCpiDCrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDVlNmY3M2MtYTQ3My00YWEzLWFlZjQtNzFkNzcyNTVmNmFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZjODY4NTMw\nLWZhMTEtNDMzZi05ZGEyLTljODVjNTg5N2U4YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJvoewA5sWC2LZxUEJSzkskWznOOmdcSMm3ULZBQZhLKrXDvg5g6dkPM\nvxD9XcyOlZkNg1z4dMJUUKVPwvp3HbWjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKhQ7ph7\nk35wK33yeqx9Aosez+E5MAoGCCqGSM49BAMCA0gAMEUCIBv7bVWjE6x8ormRcGko\nXl2w+S9LChN1rB+PTOx5sT6/AiEA/lJXfXj+rd2yIIYKNQJLp2lpQKeyEdJn9AD3\n5IREaNo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5180", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5180` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAfknBT4Olla1YQSKi3xXs6NtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwYmFjMWJjLWYxMzctNDk3ZC05OTM4LTE5ZTE0OGYwMDgwMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVlNmU5NDYtNjgx\nZi00MjhiLThlZjUtYzNjMjcyMzIzMzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6M+4Zadq/kIkBoQ1OdojNxmyVYHSO9IV7erUIjwhZHPqIDxNilqPMHj2FI79\nkpr4/hu58/McDou5xEh8IL18TaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbZgMEdKZYJAEQ81B8oiGzB5QnHMwHwYDVR0j\nBBgwFoAUB/yv6eaRhb6zUP58bI0zPsnpyA0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGpqiuIWkSJOmDsknBDarO9AU73oFS0X\new3JGf96n9IgAiALPJGKADlHr8xGCe41wypnaFPx7X5z/m1YZyJb6pxbHA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUmKDsA34h9f9EGx907tuoacMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGJhYzFiYy1mMTM3LTQ5N2QtOTkzOC0xOWUxNDhmMDA4MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8XbAy8mkC3ZW0zJQoqPqLiWLnFZoB7PzNp+WlZHt48uKg\n2GVjfDg/Z0t+XGPnBh43AIDfR+S3m8O5IhkTR/QWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB/yv6eaRhb6zUP58bI0zPsnp\nyA0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQxcal0hmnq58F/hWTBxRvUEXF0f2Ri5Ktftawsr22wYCIE118R1a4lfY\nUm/m0mujmOTLIqLDRH7RjLUCgisMi/ty\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAWBJF7z99bdFux0WUu2uHk8lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVlNmU5NDYtNjgxZi00MjhiLThlZjUtYzNjMjcyMzIzMzM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk5Y2Y2MDgy\nLTg3M2QtNDc5Mi1iMjIxLTRiYTViZTQzZWY1ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHU4yKXobdPexCsm51fKqFIMXxsbCMFt3OE7wAtEZD2xR80oqiwAVICO\n+HX/FYyUtmkZ11cpXSI5bgRAA5okHzGjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG2YDBHS\nmWCQBEPNQfKIhsweUJxzMAoGCCqGSM49BAMCA0cAMEQCIDf79yW2X3Xqz22TQ7oO\nAyeKKeC4u83Jb/8VWNm5NtqiAiBwmYxSk0XKai1jVrGk8QSVbf9PwRU7QB4Nun/W\n2Tq2aQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5181", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5181` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAUQ0vLY0J3po9L7RvI6bri5IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExNjA4Mjc0LWI5MmQtNGJjYi04YTJmLTBiYjNmYjNmZTFiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUyYzdhMjctNWU4\nZS00OTFiLTkyMTktMDZmNTJiMGQ0NTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsx52k8CikMFh4J0P3tBR0XFSIx1nROGYoBbBo0jr7GnORzqMmB9FAq7FzkO2\n+mkjV+cZaz1ODKLjeea433n1cKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiG2I5XIpYtgPKrSsqrqyusr5ywcwHwYDVR0j\nBBgwFoAU/jAij1gzFWW9WiY3ydGUkL9CvOAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCXs1WlzVSht/1TmyN0W6iLXO88KFPt\nYddFFTbQr5YliwIhAI2ZoB320hEjgfKWAznRgHNmzrtCRZQEAWhxRLMMI7eK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAexZ+Lkhxa2ijzqxsz1aoh6GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTYwODI3NC1iOTJkLTRiY2ItOGEyZi0wYmIzZmIzZmUxYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStoBIETzxL6RqUsBZw8854MxOdXUUf6n923SUWzRHIgTyy\nziInjZ58uwl47hxQfwxpUNfGU+rewRtxJ8Igs1NHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/jAij1gzFWW9WiY3ydGUkL9C\nvOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY859/RVjGM23XyVLYSLj+tC6deT7fi0brIwywyxWPO0CIDY2BcPxYb3/\nzvpHMNEzTborZEOZsghggvxKblTh/TXy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAQJJXAKAZ1MMTZnxWfrRZW4PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUyYzdhMjctNWU4ZS00OTFiLTkyMTktMDZmNTJiMGQ0NTAzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg4NzY5YjMw\nLTllMGEtNDNkNy1iNDNhLWRkZWJlZmMzNmM4NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPyVbzdJHsYf9lyVVcN9pX9cLGiArit6AFt+xY8YiKZ2LhXrUHaRJQ3H\ngbqNcgRC7W4ak70fUHfD4P91CsPXek6jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIhtiOVy\nKWLYDyq0rKq6srrK+csHMAoGCCqGSM49BAMCA0gAMEUCIDl5rQJdBTggv19HH1IY\nO7pJxGjsRVrd/pZzhN9t8l3pAiEA7uaAQS0xVeqbkg1KGwEyiBR6oxzmR4l8PPpZ\n0ak/VSI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5182", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5182` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWThyl+QGcTOdOhkSPGDTyAJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMTIzNTUzLWJkYTktNGFhZi04NzdkLTFhOWE0OTQwNWJlMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJhMTQ5ODQtYjFm\nNC00NmU3LWE4ZmUtMjg5NzQ5MTYyNTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuf6B/BN1AZl6ya6b4/bmg8hrifTalzb8WFntdZ8JLkndqYNASHiCoScWhJLx\nrAeAvDUdiGyJM9qkZC7cOXA9waOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU06GEEIPYiysxdNq/BUfmbzucxOAwHwYDVR0j\nBBgwFoAUO4lFb8yCG1pFqXq+GvTZhT1d3XswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDmSY9H0hSF\nF1Sg+mtAds5z7z4GxEhpSyXYPXy0oVbP4gIgE2w95Jp4muIHSGiQSw1WO8jDkfYA\nBVt6pS1oZTSnZk0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc35P7jKxfoaFCxwOGOURFdxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzEyMzU1My1iZGE5LTRhYWYtODc3ZC0xYTlhNDk0MDViZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmP/wPafUGfww2VxtKWjd5BDSi2CRo+Ioj7Taldq1y22qq\nFeRLoJ3ZTnZ09nbuqZVAl8F91Cb7WRfvn/6IO+wJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO4lFb8yCG1pFqXq+GvTZhT1d\n3XswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOsiE0hLW6Qu5XtmUqBzTxTGNLwOjLfh01ZLFDfJ8HJACIQC9+U8N0evA\nn/uz1G87wczUltgEfENvheVWg+0Ld7136Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAZZ0q8L2pSfco+x8Nz7zNm0kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJhMTQ5ODQtYjFmNC00NmU3LWE4ZmUtMjg5NzQ5MTYyNTIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIwY2UxZWFl\nLTYzYjMtNDIyMi1iYzllLTM3Y2I3NjUzZmZjYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCjpWXVNRVjxFq1TZ5qJsyvOiHdoItqb20p6LPRUs3ks68ma9052mIiJ\nNHaiL6vSeFBzcwOgPoLO6YOHO1hNNNmjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNOhhBCD\n2IsrMXTavwVH5m87nMTgMAoGCCqGSM49BAMCA0kAMEYCIQDin5Fx4XhDm76vCkhI\nb849V4Kf2Mg8aZSam3AtY7DliAIhAOdWQNrdQAXv2jx8/1RVv7tbxu5nngL+kSwj\nJeDlS6DQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5183", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5183` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISASpFR/HtfS/vckkfYiGvkul2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ODE0MjMyLTA4NTEtNDRhNS05NGQ4LTI3NmNhMzZjYTc3ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEyMjZkOTMtMGIy\nZi00ZjRlLWIxMDUtYzM0MjFlMTc0ZWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtG0Rer4YITkTT/9s6uH6wz+84t5EViKVeI8i74p4D+lFj2CFwR1T/eVotwni\nledLyVBwzMV11EK/gjOrDcKw8aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeL374fqcnROdZlMlPF2mdo9VfGkwHwYDVR0j\nBBgwFoAU7GGIi6mRZpPR6aouYxe5Meh0ajgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAP6fGCStIwi73d+2K2f7SQ8Vbrfqtd8PfBKVRfMXmpT5AiA1zqPJARlh\nNiZhiiSMnclBojV9f6jekQwrv55riOmdVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASwI+EumdVoTne7KyYvL+iMQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODgxNDIzMi0wODUxLTQ0YTUtOTRkOC0yNzZjYTM2Y2E3NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4pign4JAQQGj1u93Bh1feluhW1DGLGy9hPcnZGgwS3TNg\nURbqwoE0XHutquY5CGKQ5Z848sLdmKtKv63J3qqYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7GGIi6mRZpPR6aouYxe5Meh0\najgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMXIM3DnteZF/UKXqRRl2AxwsMlQS636/GXHLY5kBOjICIQC6f3+x3Pl8\nN8xtFEAxK+VopSXVbNMltFNE+jyhx9id9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbegAwIBAgISAca2CHTjsskuLIbTh525nkWWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEyMjZkOTMtMGIyZi00ZjRlLWIxMDUtYzM0MjFlMTc0ZWZmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBjYjU1Y2Fl\nLWUzZTktNGE4YS04ODU2LWZlMDc4YTgwMTRhMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFtIKga2Dbs7wk7juJxbIYYUgFPQcuWGRH4o+zC+Y5KABgAO9wE/p6Mu\nCtMWGMvzqMKzmY0W9YtgQ/HGBZG+4kqjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHi9++H6\nnJ0TnWZTJTxdpnaPVXxpMAoGCCqGSM49BAMCA0kAMEYCIQCNoMdWWwPU/xKK7ADW\nzXzpXb/oEs95YK9VunYQlJbZ+gIhAJS5LY0Muzht4j42GIKQ5yeZfBsFPu3pOIH4\nzF5ImSsw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5184", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5184` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAVNCVrt0uTMlQhoDX5fKNXnsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmZTRhYjcyLTg3MzQtNDU4MS04MTY3LTBhYzdjNjJjNmMwMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODczZTA5ODgtMGY0\nNC00NGE2LWFlZjYtMWFmYjUzZDMwMDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECkkhYo83Ze1g1AN3yI1QASvrYIaAkEVwVI/5GVAExr4PRSj2oZ++MTtrKsZF\n+Q/wVmANGpzkcnOPXsPvpKMqMKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUReuG4G9449S9W/dzO2jM+ENdNCwwHwYDVR0j\nBBgwFoAUhXl1QNS1/tYETZVKv2naprEj46QwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgfIILu/3Am4gU1ne8BSI3rhDxzQb/1vIBYgDqge7CCMgCIAmVWRvo6yRv\nxHKg2/Z+ZX35F7cwrUTWQKMkTYqUoJ+J\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf8Ph2FqLGkUrMbtKlSKEB5xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmU0YWI3Mi04NzM0LTQ1ODEtODE2Ny0wYWM3YzYyYzZjMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4uzaWUk16hsVpx2VYlJGYs7wXB1k3Xxhl/Q1lDpTEu+ko\nxRsr7PbhI8lpBSzC+Yax2ziPBMTM0dw+MQIOIIc4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhXl1QNS1/tYETZVKv2naprEj\n46QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGz7GUYuXSwTzpG+LQaLI0NzpyGjcCpi1r8S66IqvHisCIQCyVzfMJJz+\nrAZq4XIzpF6bdFEQOmHB9ohb352npyiiFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISARRbP0mXftG22+hxvtsliE0SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODczZTA5ODgtMGY0NC00NGE2LWFlZjYtMWFmYjUzZDMwMDQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkyMzExYmMw\nLTFhN2YtNDljNi1hMTc0LTM3OTBkYzk2Mzc5YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOANHRuvm5UZFoDaR8+JS+sV0r+dAOYMYvLiea2B6wxI8q84yDzmRnWb\nkQr9F+wZMrw9Ql6ys2D895U1MlVALgejVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEXrhuBv\neOPUvVv3cztozPhDXTQsMAoGCCqGSM49BAMCA0gAMEUCIB/e3pVI2RW8uryNBWUC\n73e01JdzamIF3AIb/9moQiqAAiEAwLVGgxKJbx+mne1DPqP1ywlBEASN9m+arpeX\nwJDiyME=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5185", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5185` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAeBRU8kITDe9qxAmLoZ4Cx53MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NmRiNjQxLWM1MTAtNGI1Mi04YjU3LWIxMWU3ZDI3MTQ0YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NlYzc0NTYtYzg2\nMi00YTAyLWI4ODEtZmE5YmQ5OGI1YzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWhXVfjOqE+NORj739jcdgsPO50ThFxXxHXvMqicVQIBsWLiqps0jo7Z9XO0s\nVE4fVsSv4Ll29msVpOHReFIyq6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr9G+mvEsOtwD/UOc0yg11HWDHJQwHwYDVR0j\nBBgwFoAUM5gPGnHW5AoCkBPujmY+t6Stz5MwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIAm3Ir5bB+dRw8j42XcilzrtWrGJGA5OlpncSNfzGwsQAiAVA/BuKzyv\nlS9gEa/Hwp2GwSsR/8QCzayVKTUvy7Zp7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWps1mMZGEb6qpSvJDv9qnA3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTZkYjY0MS1jNTEwLTRiNTItOGI1Ny1iMTFlN2QyNzE0NGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+tTHFP0YMopoU+ctrxa3BT0GCoHa4I5T1CdApE9Z83UZn\n0et1RhtFnSKmt8xJ+TpuYupxgdbi+blqjV1Sx0kEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM5gPGnHW5AoCkBPujmY+t6St\nz5MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMQMXRAUlkj63wymcWWEozhkQRkREN16MrA5kK53ClKZAiAMRXpqAC/r\nTfJo0D8nJiE8n9js1CHv22uSe1L/CmNsXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAYljGc4OBxyIASFMBQRneAa5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NlYzc0NTYtYzg2Mi00YTAyLWI4ODEtZmE5YmQ5OGI1YzIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEzMTIzY2E5\nLWE0MTMtNGEwNC1iZWMwLTdiYzg3YzMwM2QwNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPGL3+nQwS7suEZGoWPQV/GNMd1C+S/BlPjGqIxNmxBY5FeqPMbohZMM\n0GHoITTCap8jZ7GvBFH3GF+8+1DtoK+jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK/Rvprx\nLDrcA/1DnNMoNdR1gxyUMAoGCCqGSM49BAMCA0gAMEUCIQCCa5lHSGY1379xD2k4\nenrvbJrZwTY6X9WG2l285e7gSgIgcfbjBByWUYZokFTPlIa43IJvyLsJc4ViWMFT\nAK0ozFk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5186", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5186` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISATzK787efbDrX6mJBdvm301CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhYTFjODcyLWU3MmYtNGM0Zi1hMTEzLTQwYzRmYzFiMDg3MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU1N2ZiZDEtMTI0\nMS00N2FhLWI5NjUtYzQyYWUzNzI2YTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFi+VieT7FJbKXZ7u8nmY5/xH+zsNv1kiYCAnjsY631Oia0Tli5tbk3c0LtoT\nYJrusQbJ3AB897whJwjYd2dOyqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ/Xdl/Nv1fHLBK/5QOABsjaO2qMwHwYDVR0j\nBBgwFoAUfiBJwjcQ/Ap5vZIPknI/+CL5pX4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCyYAjhCvq/dBxwMD7dt12NtU1IUqUMlJMhhjJS\nYCTTBAIgKjWJkAYtRvYfNMa3EKh25SVEFeftqZsShjHrlteEAgQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd0ZwvozAZt1NwIhd15zFRRFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWExYzg3Mi1lNzJmLTRjNGYtYTExMy00MGM0ZmMxYjA4NzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQs9g6TjY+3JWtAbGPGv8zorU+viNsu/lF54dL6bF/HYW8O\nqQ4hzE8PE7BL4tSirRIngpRoASVb5U4aMzBAG19Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfiBJwjcQ/Ap5vZIPknI/+CL5\npX4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMx257BbLtIyVUsgT14kFrR/xiYLNpYQK8+EP6ahT2imAiEAvhmHU407\nQPMJYstyP0wB/dmxfTeyzY+5i3vC17cMktQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAcMvfavLVhkycrW11O5saUM8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU1N2ZiZDEtMTI0MS00N2FhLWI5NjUtYzQyYWUzNzI2YTY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFhNzVmODQ1\nLWRmZDctNDEwYy1hMTZjLWEzYmMwM2NhZTM5ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH1+HSedfP+PCTV2MjBBtNCmMDKOeIYaDixMwIddVmFEz3E8prYZ/l8U\n357fxzkJZC/uCE+sG9WySTBlHwQtv2GjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEP13Zfz\nb9XxywSv+UDgAbI2jtqjMAoGCCqGSM49BAMCA0cAMEQCIC2b1YUk7l4AWmhBVWfV\nJAB7tsQKmyMfPGhtwFAepFPcAiAqbWwjne0dcoiWR+JU7XDktRBS4vdqAAWYzfnc\nmyn9AA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5187", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5187` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAc+ALQoNQjsNZWc0U/V5LzbWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliZDBmM2JiLWVmZTUtNDY5OC04NzcxLWU4MDQ3MDMyOTg5OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE4ZjI1ZGUtMWJj\nYi00OWU1LWI3MDYtMTllNjI2MjdiY2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUuznt/GwSIgyDvvgcXBGKIaj64++9z9M06QaJvSGI979+KawHc5lsgDuum4s\nySASVnEDzyEVTB8q2Yg7hBNB66OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUERpLPnjq1Kn/2Qq/F90sJSQS/MEwHwYDVR0j\nBBgwFoAUDLB3H2ENAKCEZPhv31dRyUnU2zUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCdUsLUZLQjn0hhPghkHwd/u48SrUMQSvwgfixw\nMZcxfwIhALXMWS+Y+1DraIXoNQ6Hr7z+3xHbU+VWNQqEahM1SqCc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUlylpH4Q90vvckMRp8GkApDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmQwZjNiYi1lZmU1LTQ2OTgtODc3MS1lODA0NzAzMjk4OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkHqQQMJcO1Vw9VGYCop/j05TwlyI8drziGhQ/gREeYh7v\nNsvWWGLdrJ2cULghvFX6Wh4Epqg3uipGdgCRXzVwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDLB3H2ENAKCEZPhv31dRyUnU\n2zUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPyoVGscv5q5lCfApPNn4b+AYs4pi/O6ZAKKTZTRkmhmAiEAkCRAf4A0\nJ/yDHLD6w6TIm1YF1qryNH6k5r/J1+dZXms=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAbzUaZBiuN9Nl47xWVhQnnKNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE4ZjI1ZGUtMWJjYi00OWU1LWI3MDYtMTllNjI2MjdiY2ZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEyMzhlODJm\nLTc5M2MtNGNjMy04ZmE2LWI3ZTY2MjI1NjBkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP6GPRzMtWkmXAsyUNw+EtUpSaA4WEHsEXZFpHFSosa6S0V95PWZ/xve\ne6pQeJaVoZhpvI5qgu7BO7CMzqkKslajVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBEaSz54\n6tSp/9kKvxfdLCUkEvzBMAoGCCqGSM49BAMCA0cAMEQCIBjB/dEmzutaguWEZcg+\n5ObX/4DSUbhw+K6hQytrVUzMAiBVgci6aSn9vOuyVDloLdtPTydaJ4Rl13IstD2Z\nHIQw3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5188", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5188` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVKOSuhMSD6S0IoUnPs1XrovMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkNWQ1NTUyLTRjZjYtNGE3OS1hMWJkLTcxOWM0MmRiZDRiODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRiOTYzMjAtNjhl\nNi00YTkyLWJjYjItZmE3YWU2OWFjMzc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKMNmfDULcYbKPxkfOIKx8udsVVItOuzDG1mnynXwigWnsn3wxxmiwbbG6EPR\nWPzgLyCOlEYrFOwzMu1G7tBnT6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULzxNBQv6Gz90XhY7A/CYZkRhLOQwHwYDVR0j\nBBgwFoAUYH28lJJy6vCwEdCiC0d3IVc29RkwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCoXfwHOsOnNVXg6TNoGiLsD0Grxprnc0QQhRhq3eaVPwIg\nbDHTnZHxk44diSXb9rzaEidjrFpzvvT36fPzxd1F4m8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARIJ+ZR09ulKNV/i6Olas6PhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDVkNTU1Mi00Y2Y2LTRhNzktYTFiZC03MTljNDJkYmQ0YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRqkLft4PzPWh3k9YYwRIwiWeGc55o79if+9aEpRkQsUyI\nSNSL8XFTbOYOrjnj1y9JUyapIKu/Rhm+IsdYhUUOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYH28lJJy6vCwEdCiC0d3IVc2\n9RkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWyR63uoRnd9BdOo4IMbU5u8Fcw5RlKdeQ5IdoC7EqxUCIQC9+xATRP3h\nu8SDAmQraEav+FITh6cPWxFHIFc316fj4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISASRQHnSae+JEYQLpG4Mi+ai4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRiOTYzMjAtNjhlNi00YTkyLWJjYjItZmE3YWU2OWFjMzc1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3NTk1M2Rm\nLTQzODUtNGQ5OC05MzQ2LWNhN2Y0NWJjMDFmZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLexGJXLJWycIE6bR0yhoo5VI5e6v7SdlV7aA8lAcpZZG7yc3DcXxDUy\nmE/HhEgW++5YxL2mTtq8rpzRYactyRujVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC88TQUL\n+hs/dF4WOwPwmGZEYSzkMAoGCCqGSM49BAMCA0gAMEUCIQDo0ZtkiwRFf7KHEyen\nySFuOtvJqblD7eS+VGNboDVFNgIgVDL5/4oF+nWYnF/7OzNcGzg241S1Z2V4LoQE\n17mnYU0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5189", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5189` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATPxO0XA9tfPX3R7433UtMDlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4YzNhYTZlLWFiNTktNGFhYS1iNDY3LWFlZGJiNjJhM2M1ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE0MzIyNWUtOGE3\nNS00YmFkLWE0YjAtOGJmYjY4ZWI5NjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE3m5QvRP9BY4fsFFxmUJNSZo0TI5pUSM+wxMD3CX7P9vq49oU+wiyaeotG/u\nuBWHSkni2B4pOnl4eET2u/E6GqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY2xeSvsJI0DmkTLDKut4PLllXUowHwYDVR0j\nBBgwFoAUfIarvhuZ97X6b/Km9GPIi3ChT2IwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIFZ5HMMR5lUnbvmWdFqjb49zmne6kUzW\na3nT61ejk+n/AiEAuZ/0hHV9/m+N94ZNRinPIi6R4eZldy8BQQRXnJnPrdk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbtoLaHle22FNks3ibx1G0tWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGMzYWE2ZS1hYjU5LTRhYWEtYjQ2Ny1hZWRiYjYyYTNjNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASB+rPJ0dmPl57hm3gHE1ZNYIFlkfpdmVEAh5At9QGlovEy\nuIcPw6KxH73qddLny8xETfZMiXgUia/9peu7bZsbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfIarvhuZ97X6b/Km9GPIi3Ch\nT2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQYuXdwZciapjj7YMZglyF+BFNMaWoD7uEVL11WFmRkoCIQCEX7Mcy+nu\nbebYcMRIxbmVcxCBvYf6vqIw2kuCNdDULA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbegAwIBAgISAcgCDYKEVNClZ4LFfT4k7bpGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE0MzIyNWUtOGE3NS00YmFkLWE0YjAtOGJmYjY4ZWI5NjY1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhhNjkyZjli\nLTMyYjEtNDg1Yy1iZjZlLTUzM2IwMDg1MDBmOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDFSMCImJWQgUCbkiB6Dh3E+9zCx4d8wjV/t2GWmGWK403aRE4exPEzv\n3Cy6Fx1Y19zKUmuDP4F9hv1x4p0imQCjVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGNsXkr7\nCSNA5pEywyrreDy5ZV1KMAoGCCqGSM49BAMCA0cAMEQCIDbj55vvrh70Bvl2GTq/\noNltccezazxBkZ/6WC9NR8u1AiBLwxgUg4EGoudUVN1VrdVz6cJJFQ8N1t3v9/UI\nrJpnEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5190", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5190` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAVbKeuqrfcnkaqQ8wlwv1eZ4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMTczY2QyLWZiMjctNDBmMS1iMzI0LTg4ZGQyYjM3MmM4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNjY2IwODctMWYw\nNi00ZTMxLTliYWItNWMxNjI5OWRhMThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAIrZ/TdpovDPIDZqBv1J7J8B6ro7pC39jnefyRNdX/hTX70Ity5IC+F9HHPt\n/yCGfkA3Zo8joKxvcP1F921T8KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFWQkr37A04f4iSRApsHEjm2UGE4wHwYDVR0j\nBBgwFoAULscfZX9iJPU/8dwvqLJls2d8DlUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDR7yMhACwtuqCD7bojP4WXk409MeSa\nJ68dlx7AirtynQIhAKgkrSxtH1IquBYaXIwJ7nJ/5fG5TCCL+R09fN0BN4ND\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARtg32kl39Xr9RkXWC9E7jmdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjE3M2NkMi1mYjI3LTQwZjEtYjMyNC04OGRkMmIzNzJjOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARULXvOclOLu3ER9BrpxuamgeCWoEXkmmzvYHad38j+EDeO\n2p4aOAtWdcuFRZrvOPpsGGWDGkxChXzCXcXHmPc7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULscfZX9iJPU/8dwvqLJls2d8\nDlUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWANDQtTCHgv28ipb4i2TYXPIBSolhHzVpNocQVOCPpACIQCc3KDRSDTy\nrEtRPxJZoiwqG0acbHJm5JYT5y+SwDQRug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbegAwIBAgISAQPApxvOaiX1TmkwtLfNewKHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNjY2IwODctMWYwNi00ZTMxLTliYWItNWMxNjI5OWRhMThkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIwNGFmOWE4\nLTVmMDktNDkzZS04OGQwLWRkMTUxNjkyNjIwNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIx3CuLYplL9Q3trC0YmKVYP7eRZylmZWxJ3d8nRA3cX2lR9rCeP6Hfi\nT2zOLnZTqdmIYK4tP0QpfIq5fhwDGj2jVjBUMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBVkJK9+\nwNOH+IkkQKbBxI5tlBhOMAoGCCqGSM49BAMCA0gAMEUCIHpyCckk+ycFS56+8igP\n06+ZXWbRFCkIpLkKTWIHW6pZAiEA1ExhhfMKK42DKETGtuv6P9RPaMLLwSI901Rv\nlVGfLE0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5191", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5191` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVt8pkRPPno7Ou683UIjO6qhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNDkzYzg0LWM0MGMtNGM1ZS1hNGY1LTM1MTk4YTMyZmJjOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjAzZTllZGItZjE5\nMi00MmY0LTkyYmEtNThkZjI4ZmFmMjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtIGNAEnH3hbVW1KYtUk74HVSOwXtfrCiXpnTdcq545Aj26xNls4o9FtU/liS\ng6p9q33HSBXBSZ/DRfJuc7HZUqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJOQyB8H8mYoia4B2lWNy/7ZJuxUMB8GA1UdIwQY\nMBaAFG7LP/1cEDTNGo0Vz84zDAPnBz1NMAoGCCqGSM49BAMCA0gAMEUCIQCTFj1b\nj5bQRiUKqsv/3bHUP/pCXRoEmyHwuHrQirHvgwIgZp0Jjz5VYQOgMiPVRKTJZgkl\n1n/mr63LOJbMVbM/k30=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfcNV0y0/8EKPSSajtD0cU0gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDQ5M2M4NC1jNDBjLTRjNWUtYTRmNS0zNTE5OGEzMmZiYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt8q3CB7wVZJzC/Y1URzAk5D9UvYMfwJYyucDZe24zeo2o\nDbO//wo+dEUKPpfwDrvD6mNHU47+vK8dFNBJRxWwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbss//VwQNM0ajRXPzjMMA+cH\nPU0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALRthcNM+NsnO4f8A9rhDsRsh13BKytezb+i378jXXhOAiApa8E2r3bZ\nCTP8HMkreAu5t2fTfIINum7v7IIbK/KwvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAbuSSrXyXhC0y2K3dWwR3u5HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjAzZTllZGItZjE5Mi00MmY0LTkyYmEtNThkZjI4ZmFmMjk1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDExOGM2MDAz\nLTA0ZTItNDMxNy05ZTBkLTk2NzdlZjUwZDM1ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBQqdsBsdT/uQaDx7dOBgCMLY4EoHXa/ezyn0s5XdgR02CZzJtVr7Jg9\n7o7RMzH7TdDFuSq/KgHqqYTHbq4bQeOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJOQyB8H\n8mYoia4B2lWNy/7ZJuxUMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgRHf3JPzNKPOYi9VHt2nXGanmCXlSsbdognDz9EoSj54CIEmA/jAknyRqrcru\nVKa6oYKR5f/1NRaWE7A4K6evODPc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5192", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5192` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAUOAsqNw6KLA3/eJ5rLBQzw0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5YWUxYmVmLTBkMTQtNDg2NS1hMDQ3LTdlMmI5YTA0NGYyNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjkwYWNlNTctZWVk\nMi00MzhmLThhMmMtMzFjMDYxYjdmZDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErPsJd2sBV5+DwCtyDm0/xD7Y9K9SU+BOw8bboOqdsGRCWQibFh6wnofqixtk\n7raFbfs2abg/C8IAz46tDs1a3KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEsOe9fXT9Jw45crOZPqC6JcupmjMB8GA1UdIwQY\nMBaAFOYzQwMQam/ErrPa3P0hQIEfOijsMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAyRh+ykJzJVzNmC+5G+KuG+2+Z6AQS4s2K\n/0sLZip6RAIgPlhuhqhtfTvDsCRmh8TbGGmRsFU3Tjz/hZDniLApHl8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQBakW3Og1gt2jPOJZkiF+thMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWFlMWJlZi0wZDE0LTQ4NjUtYTA0Ny03ZTJiOWEwNDRmMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARe4SvD7AFlKR2ceLksbfHfWuLFAszGQnygEGOmF9kjbKsu\nVd+bjGVrPjwqL1wNQ33DhY/OvRSL3mZB3BqW6jaKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5jNDAxBqb8Sus9rc/SFAgR86\nKOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZa2WuMFoeIGcWBR4I8bpNImnvu2HuOOUlBEa7gdar+kCIARmAlJUT22j\nRn0d0a3h4DaN1XB5ILkdZye1rznPxKDk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAcgF28loBceFEuUCcD+gjqvDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjkwYWNlNTctZWVkMi00MzhmLThhMmMtMzFjMDYxYjdmZDRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGViZjA2MzVj\nLTI4NTYtNGUyYy04MmUyLTlmODQ3ZWJkOGQ1NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK3s3zqp3BxSrt1BLWSf1LJUHfxJEZFNujRUh6znyGKfjSswB0tvUvFn\nGav/dybxS1/e5XfJysYZXip+WcwYpnujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEsOe9fX\nT9Jw45crOZPqC6JcupmjMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAN/0NJDZrEaizNhYyCUKy6dx7N5MzFSA6o7gZpWYpKeeAiAGQWTelguapXfS\ny0vV7GRFB434iwvlFfUVDqLumifJCQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5193", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5193` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAR4LKnMZGWcviXzuu6BJZGtVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYWExYThmLTM4ZmItNGU2MS04MDY0LThlYWVkZmRiYjE1ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGViMjQ2MmMtZTgy\nMS00NTNjLTk0ZmMtYWY2OThiZmE4NmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiWWWPgAn3suJ9onov/0Dh7NNWAzDwdN2IwiLhkHEx7v+XajCqLwd5UcgpKWh\nm6q0FAwvWxQVNBb+4AdDYav/r6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKeKp3Q7XKle4LCboF9ma4kMdX0/MB8GA1UdIwQY\nMBaAFOMhyBd6P7HfX5yEtziZaSBVjuijMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBFrCVTWBktUhik7g7UC11POHRzMBkadDWz\n5qLwCXJz5QIhAPx/2wWMCFL41L7y6+NlylBwG6qE2nt++O275cIa4iTt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATBj3u4IbKvVf32zPDafsqnpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2FhMWE4Zi0zOGZiLTRlNjEtODA2NC04ZWFlZGZkYmIxNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvRS5dbBYROZIPvxzfbfa2MQjiUIeM/JPsinDU5ahAsav0\nd8GkvxOOOrkDnOPYkPQJN7NHLMZK9NTV06NsbqOdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4yHIF3o/sd9fnIS3OJlpIFWO\n6KMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGaQC1ElyPylHZrjo3cLscKatzYdkjQhHnr93PXKQ6lQCIQDRefs3M9VN\ngr5MZCtKG260nEJegquwwItUrqYaj0OLAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAbatScE1q1nGXr95/+P1tzPIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGViMjQ2MmMtZTgyMS00NTNjLTk0ZmMtYWY2OThiZmE4NmQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQzNjQ1NGE5\nLWZkNTAtNGVlMi04ZDZlLWQwYzZjODVkYjVkYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFQl48dYr9iBsin4RKPfRflFdYOGUYv47IJshQ8iNtAhsgvSvPWrD2J9\n57ym4sLfZABfcmGq9o65DLnEfbX1Hg2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKeKp3Q7\nXKle4LCboF9ma4kMdX0/MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAIENaR70MgcfYx1aIzDR+4ZgPWzrAclH078IQ5oXMWwcAiEAhMTLzHvzEuEy\nfESu+w1mimnOwD/GdCVFSMGUvQYVyy4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5194", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5194` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAUCtyw4qmeuCJdqTR4BrlTLDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5ZTM4MWFhLTIzZTktNDBiNi1hODEwLTg4NWZjZGJjNDRiMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RjMDFhODktMjk5\nYi00MDEyLThlMTktMjM2YmM3Y2VhNzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsGCHaV0JMuCo6WEqXA/LlwglIgg2Afs+8bKGp0sK6Db90K5+Yl4svquYWXee\n2t4gLnd6WnfyuXpTEtxExd9pTaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRm6GnHP6Q81qaJogpqoK4MO+bMyzAfBgNVHSME\nGDAWgBQy7itqEklRE4xWAH49Ff0REEiQajAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGqTqN4n+lbypu3MUtmN/a4Zud+789KE\nXNylbEgmc4f6AiBf0n2wyLpTNbgrPVPSlSWNqIevL+uvLpVnbHUsfbTwHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbyWo0PmG/2K1B3CKcERpgEtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWUzODFhYS0yM2U5LTQwYjYtYTgxMC04ODVmY2RiYzQ0YjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeqaiIHcN8X3X8OmMiwh2us9WIf3Ok5sCHXKKYm3HkOJAh\nTGl9+D7ETI0S3WQfrDWnPSqP8MIRP/hEADArifW5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMu4rahJJUROMVgB+PRX9ERBI\nkGowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJS00oPyQUK2p3mnOgIaBrpifW/hGwC4CL545ryZPSKYAiEAq5AVX8zg\nRJlJ+XjARGcp/u8fqTu+4nG2u5P/fXcti6s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAcrCMsNxbFhsuRDwoZcosqgLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RjMDFhODktMjk5Yi00MDEyLThlMTktMjM2YmM3Y2VhNzFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJhMWQ0OGYx\nLTVkNGYtNDE0Yi1hMGQyLTU2NWI1MmQyNWNlNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHeRYuGoznuqIfvYP2vgqU17PxfD43XvuUwlUQv9dTg4OC6uLFrzOSJd\nSAl0D8thHhH56LBic1XB9r7AX7wOdyGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGboacc/\npDzWpomiCmqgrgw75szLMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAIlj0bxXGjwUjwhi5Vnh5FcySraqndLsYt7Xqrv2vRgJAiAkMuc3Y9PrlRIz\nxKTXiRpAT6y46fF9+i5CAIx9gOzW7Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5195", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5195` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAeaL1dg4WnTRYcmN4YnhDiAZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxZjg5MjlhLWQ5ZmUtNGY2My04MDQ0LWYyMmU3NTY5ZTM3YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU2Nzc1OWQtMzZj\nOS00MTUzLTk3ZDYtMzQwOGE5N2MxZTIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDutbEtdJ0/lG70lpfa2JA7fhvsNHXLaLm1PpUUAGyZYVNW1axrBRpdj3lFpE\nRhk2qm7e6g1saBMZ2ZPYQoYE2aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+PiyS0+xrPGHHtpeac34BACMaC8wHwYDVR0j\nBBgwFoAUd8e5ph3NMVTAjEwKbu9zq9pO1ZQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBfrOPcQQmPbla7\nWb0R/eZzKteTXrSWy4LVx5y/ymFWgwIhAO739/wqlPeYimJjDRWGDZ5EkYdHszUr\nkDMedNcepdPx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASiqNvWagAqoJMNIHtShc28cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWY4OTI5YS1kOWZlLTRmNjMtODA0NC1mMjJlNzU2OWUzN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYZhcm3xu3hzCUX0NMmxnOvdDm31k9ZhiW6mnOIFxJD0X9\n/X2eXpmhYiqtBxNWzTk5vo5P/obEN7OxxlseU12Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd8e5ph3NMVTAjEwKbu9zq9pO\n1ZQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMoPZOksWFfBjYS10ie2OnDzRPn8qkWDuZHKFnU02b0tAiEAshTC29ja\n0qLtL175Ez1HEHsThTivh4sd0oiq2TOupb4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAYEVbTPlY6Z/eJAhG07Y4d1+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU2Nzc1OWQtMzZjOS00MTUzLTk3ZDYtMzQwOGE5N2MxZTIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZjMWQ2NTc2\nLWI2YjMtNGQ2NS04M2U0LTMwM2QzMTU0ZDQwZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAHLPdD85AZd2OQYd5nmGjKd4gOZF6qphnFTAKKkqPNLpb0X8enL1sP6\nJp7TwFskRNW43AsKDyS7AN5/l5+ocTKjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPj4sktP\nsazxhx7aXmnN+AQAjGgvMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgSzw/hjprEmzShyuBGwnEdhcekdG9DcYZ3TvqDPydBkECICop8gsAEke98VPX\nqKDSCVV9C4SZ2d3YiFoUL494drca\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5196", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5196` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAROOmc1ljrJIk+zHCrclstmNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwZWM5MWRkLTU5ZTItNGMzNy1iOGY5LTdmMzVkYTRiNWQxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBhZGZlZDYtNGU4\nNi00MWIzLTllZWUtMGU2MzZlYTY3ZGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqa9f/vrppGU9VeO1Xe4U7SWK9WGTQD0Jit2Ectu8C2hybCzf87HtzxGUlpvZ\nY2SzCJZPuUZ5gaEDQsumNTa2oaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmTQUV47z0TxlHExHwVVnG9vew2wwHwYDVR0j\nBBgwFoAUS76lrYj0+VvVmy/p0b/yDr7YhBAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAwNny0XXtZuzg\nisrjqTKT8mZTSUIa0/ox4RqnRUwWNIwCIQDn7mtBkU76E5EwkALkhtBkPdvM7HrA\nKo+NcDGxWo7kfA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV1WumRx09fTZM8NsQsVPerfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGVjOTFkZC01OWUyLTRjMzctYjhmOS03ZjM1ZGE0YjVkMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2ghwPpHMfUMzCFky0aqrmUDbrL6U8HDLENF38DFiTUkQj\ncdndWbi+PGC0VEaFag1UXElj1lJo0a7IcUyaUPdLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS76lrYj0+VvVmy/p0b/yDr7Y\nhBAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGDQoEQUxs88FJ+PjyKIPVegrauoUp5bfvOZ6p0EJLj8CIQDvMwIJQ6Zy\n5ueFEDnIMxzkPfiBmC1HZnV8D7h/MFtRzw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAbuPBkhcqV+ETmzN92doTTdWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBhZGZlZDYtNGU4Ni00MWIzLTllZWUtMGU2MzZlYTY3ZGUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcxY2Y1ZGFk\nLTJkMmEtNDM3Ny04NDU3LTVmOWRhMGQ0ZWIxMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAA1SikZTLCJs2eqe4wJiNYomvrNraCsA82XI02h8SaMWvFK43sXe4u7\n0zS+VDRIRtuOF20D+wVuHwwxxuVwYzajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJk0FFeO\n89E8ZRxMR8FVZxvb3sNsMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAOJC8AEPbbs1AX2Zj9yJuv7JQ6vDnkePYJVbxu2Gb2oXAiEA9VVC04I7yYD0\nzIKOyh/AcVEU1ebJcQ5iyxxqbj/u2xg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5197", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5197` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAbteKX95Gnz1Bmqj1ZPQcepLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2OTdjMDFiLWY2MGItNGFiNS05NjJiLTBjYTVkNmYwZTFhYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM3NjQyNTQtYmE1\nOS00ZmVlLWI0ZDItOTkxNjViMDg0N2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETKec0N5GO+EguTZSHb3vke4xpxCEiz++6xSGxle8UTnD6lGbKfQMyRVoeQ88\nqnLoLk46SjDr4f+qVJ3QqYv9SaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk42o/5tKU3qKd043ft8bbw9lZyIwHwYDVR0j\nBBgwFoAUdg1ruBixDheXKAv2HcORDgLb8XowIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA26XvTwGU99PY5Xqs3EFQ\n440ELjBvCFiX+bYPzTNhZg4CIQCweyiVsOz/okkEQPymPeIo8VDKmczNE3ki1wZG\nBbFlqg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAetVCE3OcVH4RsKruC8sxEKDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjk3YzAxYi1mNjBiLTRhYjUtOTYyYi0wY2E1ZDZmMGUxYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8XKyfG5bwu9ze48ox4lPXQMCANRTsUEHa47qylkBBjBjl\n9EM6hvlmkBo3mkrS4TG2c23ud9MOAFRX79aG7GuPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdg1ruBixDheXKAv2HcORDgLb\n8XowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIX4PU0AIv07OxCrZJx8JROCx3QDYHEGDa+vQDIDRsCZAiEAwC3HVPn5\naVxMMO4k9ZjMxxppEZM4IGX8yodCWAtaJJQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAUk5z/smVjcOyPd1RsWaZzEnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM3NjQyNTQtYmE1OS00ZmVlLWI0ZDItOTkxNjViMDg0N2M4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYwMmU3ZmRh\nLTNkYmItNDQyZi1iZWFhLWNhODc1NDU2YmRhNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBvI5vVD1hfKjYee2VGRMa7eVKDrEFe0D2HYjrs7Zw5Hmdj01zjxA8Bl\n1JT8xdJJ3QcmbisU0sic8vnrNHn7eUijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJONqP+b\nSlN6indON37fG28PZWciMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgSW7Bx6t9Rnh5XAO50fKZpnhYw4wqwOjew+mK+XxpxGkCIB/05kcrKZiF0Gr0\nnVCt1+SbN0He+vLLHoRBRml3qn4C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5198", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5198` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAWmZiVWadREC80Zytn40CDZoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZDgzN2YxLTk4OWEtNGQ4Mi1iNDgyLTgwYmQzNWQ1MWI2ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM2Njg2NGItZjk2\nOC00ZTcxLTg4MjEtZjg3NmM2ZWQ1NGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQyEfY0+PA0FgkouaVBQQCh5ieszeWiyp6RxHIWCnOW7FR2Tta59deigSliJ2\nobfXBg9d0votmCbHHKYtj20z1KOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyC5KSkQLgSkbhtdGYgCc+eqMFcEwHwYDVR0j\nBBgwFoAU6oh97Kjo/Ao/jgIeOPIFBS7tA+EwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA9wk8\nGH2BLsN4tQ2HLr3ph7MWC+x5o952bGsNQDiqQEcCIQDwf/D1YpF1gqSAoW028MYP\nKzxfSxtsQ9Qz4gnVyUjWfg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVCGrX6XUiJmtZmf70OG3Z5mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGQ4MzdmMS05ODlhLTRkODItYjQ4Mi04MGJkMzVkNTFiNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQe1FXX9lS6aEq0dfIicjHdn4tNLv7SBMeL0teAYUBGDihv\ny/ZEZSJV35ioTN83A1LOCTgdAu1BzHIf3IVZqMp5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6oh97Kjo/Ao/jgIeOPIFBS7t\nA+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANghWTWy9Hx8v04W3a1/FUoXD0XAzFyOU3Z3G31pJ/EkAiAZHBgVOsBE\nGeCmcj3Vu4D7As366V133B6Nt7YUcGe65A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAS61+s8esPLFZHF0v1R90gdHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM2Njg2NGItZjk2OC00ZTcxLTg4MjEtZjg3NmM2ZWQ1NGY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3ZWZmZjQx\nLTFmNDgtNGM4My04MDY4LTE3YjFlMjBjOTE1YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM9XfaBSA9VIZH79rclsrRO7yHPA9iXOv0FpkqOE+vN2Ove/dmxVGgnn\nL52vz+flidZn8IGh2KBvX3XmWbYK4s2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMguSkpE\nC4EpG4bXRmIAnPnqjBXBMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhALso0KHBg2pGw+p/8i2LYNlgorff4gnVyU+ftNuAQnrmAiBqCMnFvdyHcjjd\nkqo93wbVm/ycqLj8RoN0vIdYY76oBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5199", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5199` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISATkxNnHVLpLF6pimockYNFXaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMDIzMWNkLTkzMDgtNDg2Ny1hNTA2LTRmZjk2ZDQ5OGVhNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZiMzcwMjMtNDJh\nNS00ZTA2LWI2YzgtZWZkYjA0OWY1MTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc+HFvuqzbm0aFw1aypJjKHGnorTAEtzwwihhEhmAhcZdO612LmepCb6ImTFL\n/kJxXDEWEs+Dk6oMj34RrxAsaqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0PHqrUNM67i23uhHvBm2sKcVUzowHwYDVR0j\nBBgwFoAUhxxHG9ZaRIpyNtYwmlUvbmtR9y0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA9wZD\n8HkP1D4kKKjlRL0wB7qbCM//IRNup0d+wHlo2jICIQDSXjNdAXKfFwD7ecdpIU/H\nTKdi51SxKGbAq7po729HKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS0Ex48VekG3EI1Jx+7IehPvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzAyMzFjZC05MzA4LTQ4NjctYTUwNi00ZmY5NmQ0OThlYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLc89rTCbmgZrtn8SmlV9qgFQPzLkLHbXN0cGBWzPEhtnN\nyzJ+FRYD+cI5ZSP4HKI2N49oU5ia5orMVsc8SCeBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxxHG9ZaRIpyNtYwmlUvbmtR\n9y0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLLoaJiU1b+990teXWicUQ3uxlXveFQD9YOHYRc4cNysCIEZE5O+qZSeU\nEDIdrQZy2taEwi+SjT+N7mAbSf1p5D6g\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAe9i/lnpXiR0XOVl8neiYS+vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZiMzcwMjMtNDJhNS00ZTA2LWI2YzgtZWZkYjA0OWY1MTUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMwNTNkZmQx\nLWM5ZGUtNDI4NC04OTZlLWRkM2E5MmI0NDg0ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABImkDPHXrfFHZo/Z29uy2i6QPm54e6mV5RjOUp4QcZ1YWDZDv1jA3Sy3\n/c974d22fPTGbUAlk0w2e+BM5cmpd56jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNDx6q1D\nTOu4tt7oR7wZtrCnFVM6MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAKDAyFDTBLyrijsfqk4eqQ2gyol8rRHf6iO/4Zx5pau8AiEAzPV0gj74bYuD\nzDRynxuDesBi/VnsbIn/VYx6L1n2Gq4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5200", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5200` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdAtkQkeo7WwNf/wMJZa+cKMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2ZjRmZWU1LTQwMTAtNDk0NC1hYWFiLWM2N2RmOGI1ZTc5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE3ZjZmZTUtNDg2\nZC00MmM3LWE3MTktNjVkZjBlYzY4NmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEelpZsg4vfc+meJbsZ6W4wL48bjMOs/452Bd6sVonCdxYESov+A1beDSqHMyy\n73hOFlISawmp5CohsS3876jm8qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBT8kzH4jmUSUISHA6E/3D5bu/zGMB8GA1UdIwQY\nMBaAFN0IxLF+hznE/fivsfknzXS1boiHMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAkxr7plrDdbHZX+v/j7RtNvA1yZh8gSxn\nIDODn5WBCQ0CIArVQBtLA1/mVkimhBtRVHSnHQ9m9X8WFKY1YUxf2Nl0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd3IztL0FIH+8pLgoULRiK99MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmY0ZmVlNS00MDEwLTQ5NDQtYWFhYi1jNjdkZjhiNWU3OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDNSDBIcr2UCdbPgAiy4Fjzv9G5wqRY1xCMHVmFmC3xMb1\nSSENilIosG+oKaRmcWBeB65vLR6wvGHGNdJv/dTWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3QjEsX6HOcT9+K+x+SfNdLVu\niIcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOjoAbaFRsWczAYPg2wExmy8e38kbD7bOD/6lWc5f3jYAiEAua0FqQ8U\n1IN1QHiC4o1JJ7n2aT5yTUaxFubtQC4ohlg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAU5RcujoX5pSV4SM0QdACLZAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE3ZjZmZTUtNDg2ZC00MmM3LWE3MTktNjVkZjBlYzY4NmJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ4NzhmYzQ3\nLWM4MWQtNGU3ZS05ZjMwLWZhZjFjZTE0MDQ0NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHdpJLBCpEzS+lE9B5oe6LrYpYPNrctmVPVptrO9qmmfNJAYjVjUFlSp\n7EktWGpPL8wcDcghCWc9AnOl3XGLOsujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBT8kzH4\njmUSUISHA6E/3D5bu/zGMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgfXIGRHg79TXN26Yyo4EjY4ox92WDVp9pI6jOCtV2p94CIFsSdg6oZ6E+4pnq\nYD4evV37ChmalMF6qKZ67RcCFeCg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5201", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5201` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAUi8Z27EgLm5Lk2VsM9ElWm8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyMDAyMTU4LTU0YjgtNDUxMS1hMmJlLTIzYmY3MDllNWU1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRmZDNhODktNWUw\nNy00OGFmLWFiZDQtNzA3OWFjOTliZWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJMVKf3OwSiIsT4c8Odosp/5u2cbedtCC3Q5OstVOlGJMLf2lBRc+CLOYN0AS\nD86cfyfW31J6au92B8OAGoi4TKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3BET8ZrYtkALmX+OeZ8a3UcRZtUwHwYDVR0j\nBBgwFoAUo3mMH/R/pDxQOU/yoNnt4Dsy0sswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgcpIu42E/K4j7\nnaYG+cQ3U88iwOzTbXERijEftRT39DkCIHq56OcKW61cknAq2wiV4cni434SxvNy\nisODmf5Tck/h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf3R8hZLvTJ/DbUHksIRqoXLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjAwMjE1OC01NGI4LTQ1MTEtYTJiZS0yM2JmNzA5ZTVlNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIQHud9FBRt8Ig0OcAXSRxnqFxs+REucnvFjjuJqCsw8l0\ngZa7mwXQcYo1nFtxq8SG2PEs92Y8WAmLAx0GGPA6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo3mMH/R/pDxQOU/yoNnt4Dsy\n0sswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMAo2zF8zl1gspBo5GWkop5OXc4HsKxMJQ4knPXI0Z6gAiA/+SGhs+UP\ndfTz7t2wqY12a0PkmHWX/WY/1q4cMaZSCg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAadRI2S5/4jMFrKOs/paOsyWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRmZDNhODktNWUwNy00OGFmLWFiZDQtNzA3OWFjOTliZWYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdlMzAzYmE1\nLTIxYTktNDU1OS1iYmQ1LWFlYzMyYzIyZDdjMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDPxHSVq465QI+Mm/KcTPCuxjKnyf6wncJhFJ89J9JHOfAeScvnFCN9p\n+NuefNH4NKq0NHYFLe2NCexOA+Nch0CjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNwRE/Ga\n2LZAC5l/jnmfGt1HEWbVMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAP58NMd+at7jMM0mF9JJHzgqE2sfEZKQBglBOBpKM6B0AiEAivNVsFKz8z6X\nQA1l6BZn9hTdFjHxc//6x16R8KSr1J0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5202", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5202` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAXFYPgqGO9NXXwpCCBjoKxb8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViOGZjNDVjLTdjY2MtNDIwMy04MDBmLTU0OTA2YThiNmJlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjIyYzY2YzAtNmFh\nYy00M2EwLWFjZTEtNDIxYjNmOTgxYzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECD5cVu4KKCgPLnYqwRuDTJvL+PmQQUrFMNwf1zNK1AW+lu4NGBKcXGgHRU/o\nvix3JjURYjOpEw9lvxYezvINIKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyhTyQdY0Q4cqOMMKVC+cy+L9wGUwHwYDVR0j\nBBgwFoAUXd6HQ0CkTii64XvUx2QMLDbOEpUwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgU+rupDlms+b/\ngePUwqfFXd8qo5UsZXkxL1s7ZlPjoH0CICYPhDkX/D3x0aogEIBQkXPw+ssWEdqx\nan2OXxszsuFU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUG/kUqmkTy9CYhUxkwJHxWrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjhmYzQ1Yy03Y2NjLTQyMDMtODAwZi01NDkwNmE4YjZiZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW1vi1FxGKayhbFz9vNsYjoqV38HRrsttjcBqYmC905oUQ\nO8kIX91fNX38xJiqSUMk7xzK7t93XFe4b4sI6Tluo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXd6HQ0CkTii64XvUx2QMLDbO\nEpUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALtFkAVifP0ZdgMu78y1gY4w5OZZWDxetfxcuyvog1UQAiBMhEF21nwJ\nmhUbp2iETWYWzQX28SQuPHtGsAJhWqzmRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAZl7jYKcFl79mVBCQUQzkoGRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjIyYzY2YzAtNmFhYy00M2EwLWFjZTEtNDIxYjNmOTgxYzNjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQxYWZjNmI3\nLTdmNzItNDY5YS04NDc5LWEzM2JmODliYjVlYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCoryHA/dGy0urhASWGroI6Bvp17JPMSPUJi3/GtKMvqXLIF2SMfpmRO\ncs89SLplpGq+cOTFtraEQFwP0Xq1Or+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMoU8kHW\nNEOHKjjDClQvnMvi/cBlMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAMOoGc+UCtfsV6+LOeIPQ+F/13RNnOyRCnjddKdQUWRcAiEAu6pSvx1AYb59\nrZ1/Q29w9nMFYJIA27nGz3EWce7jwdk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5203", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5203` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAeZBsYENVn2jd9XzClNL7lTqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MmEyMmJiLWM5NzEtNGQxZS04Yjk4LTczYzdhYmE5NmI3ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk5Nzc1ZDgtNzY2\nOC00Mjc3LTlmODctYjY5OTU2ODk2N2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvfvwPF6mWJ13Rh0CBu4gDy6HIDgUlD9RoonTEDS8yUA1yy8EN8dcWNWHfXU8\nLgZ8JdV3sqP3eveZRWKfbQNjfqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcELtUdOcHgNe0pkNAEJHwrTky4UwHwYDVR0j\nBBgwFoAUoYrgKPlmsjWkQyu72BVh/ICicMswKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICseD3qDPs3y\n1DVV2B5J5fXh/hT/Vv93CYq7U4jcrXqzAiEA/6Xlg9qbQlfS7+E4RkUlftkAQAQ7\nceKXCylE47k+Uk8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaJ9IN85pxA3wpvDWX3SWuz0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTJhMjJiYi1jOTcxLTRkMWUtOGI5OC03M2M3YWJhOTZiN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9zniQnY1Y0m+PHk8WNdGlQAmGVMd7hzij5f/SlCxFOIg2\nSVoOYASPrAvnMIuqBUPBUZb/EjbAnfxwWwcIJrnFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoYrgKPlmsjWkQyu72BVh/ICi\ncMswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX3iblFYU/ajy3urFt2T83WD9BnjW7PW9uDaCe/E4eOMCIQDBy+9IzVto\nH6iR1DDGBFCoLo5Z0xV0xs/f56prWQ2nJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAaPGvitJP6kIjU5jaqn45fHMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk5Nzc1ZDgtNzY2OC00Mjc3LTlmODctYjY5OTU2ODk2N2RkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNmNjU4MjZi\nLTE4YTMtNDhjNC04NmY5LTZmOGJjMDMzNGY1YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF/oYnapVWV1zDczEmONiv2zxE5hS8Wj6ZwWnnZXX1di/G5VJ1eMHlzK\nRmRSwTJ5NnL3CzTaRDV9JLIsfM2zbcejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHBC7VHT\nnB4DXtKZDQBCR8K05MuFMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgNaYQQE0+04p3oEHyLizdfzhjnRaHnilK9KZFDOKA66QCIFWYspR0HOlzOrtI\nok/aHLPyTw+MmilKw2gyuHiPxW0n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5204", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5204` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAX3ZJYkFnSdD1cAPyqxL3hJOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5MjdlZTM0LTUyZjEtNDBjMC05NjFiLTU0YTEzOGFkMTI0MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU1YWJlYTgtNWJl\nNi00NDY3LTlmMTAtZGIxZjNhZGFiMTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEItsU+str9yPRY4/qVS9k6a1jXgkGCMd2pjS3Klefcez9Er77BllrfOg87gu1\n5C1MVYlEMR58hUWO91NTaS0ggaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh6ehm7dMCIdntJ1Ap10YyKtpq0swHwYDVR0j\nBBgwFoAUOhBZSZqJN+ZIpHRpxxNUcvo9i6UwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIB0Ip7JrzCrkVDb5p6dbckmfay0PO0FdPjAL18fdD/zGAiBpf/mbUYgsAjx4\nvbUCXNVdFXFm5fp8bYbTI66ooVbakg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVs9d2mP+b5oarYyrxxc10lwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTI3ZWUzNC01MmYxLTQwYzAtOTYxYi01NGExMzhhZDEyNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+4ABYCji3W4/Z038aHEC4mAmGmR7N18yVnjqQiWj8wpzb\nSQ/gqB+wf3xAx1HVLT7Rg2198DmXwZ+6AaRIWi8Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOhBZSZqJN+ZIpHRpxxNUcvo9\ni6UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMLNB9gPE2299I41xC6SNDaCitG38Ekdmd0cqHHYO1VfAiAYLaTOY0j9\niX1ihWFJRdzkvJ+EO+sw3FK22ZZB66ZR8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISARPNQXh+VQ0Y2zqJMKF2ZzYeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU1YWJlYTgtNWJlNi00NDY3LTlmMTAtZGIxZjNhZGFiMTk2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkNTFkMDlj\nLTJmZDQtNGE5Yi1iMWUzLTM5YjA2NGQxNWQ4ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLMuCi7yk/CGqCnwUrHmYhlO5Yjg2CQfDn2hBOxgPrBKkPhlIIwtI2wG\nl2mOXwltPQEnvUGmomqWSG5IUGxDEzOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIenoZu3\nTAiHZ7SdQKddGMiraatLMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgSHUQGjMccKslHwjagfMVeA7DcGKcf0dm0gfSuSmlIrICIHcBNzGpwEn9Ofow\n8JcCqGf7wS4mQlR9R9KcaHK9Nw4R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5205", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5205` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAT8H18Fy5yZRowZZ++eMkX/4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4OTYxY2JlLWU0NWMtNDlhNC04Y2Y4LTg1ZjlkMTQ2OTZjMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFkNmUxYzUtNTA1\nMy00OTU5LThiMWQtMWI0YzYzOTRkOGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfPUdu3SoqO9TN9oe0a8vNs58wisalEjTe/nxuCSqnVdH9xr4UFdLpEzXjF6t\n9a4PSYOEFeP1+oH5XOMyvnJnbaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU4xm6MdfWBIHjNXnjzBMb6KmwTMwHwYDVR0j\nBBgwFoAUZWSZcjIe2Uc06OLm1pyJkajyCMkwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCXcUfHoa9N99jV6yPX/ppSYVAWFrx1WnulgSPiQpfEIQIhAI8mTdi9ulZI\nlrhUobEAhs1K/keOZsuThGvgfthWXFOP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVVexZAL3lUrZu6i+7afLt6VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODk2MWNiZS1lNDVjLTQ5YTQtOGNmOC04NWY5ZDE0Njk2YzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk++Ae8KTZjzYBQgrbHmRzeEjp0H8MbntVkH9u000UXyuf\nxk/JqU9E1/0LtZ8U8dvpSdwEPZ+HKHLPzjyMxCPEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZWSZcjIe2Uc06OLm1pyJkajy\nCMkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPW5WYTrVYRgLAFi3rzkghf24LVp68EPDk3qp5HUUlI/AiEAj6pp10v9\n2NNM26OOJXKjRriOxjYnVhUk9GG1SbZpivs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAZ6y/VS7Dbduc+T4uA5PFSbYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFkNmUxYzUtNTA1My00OTU5LThiMWQtMWI0YzYzOTRkOGY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNhYjNlNDkz\nLThhNmEtNGU5OC04MDMyLTc4YmNhN2U5MWEzODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPl9eQH3gDIVla7DBfb5QwDrRYvVEOg/gBQ1oqCV2fe7MDS/MQtBCGsG\ntw/q/KwRx5iEeldyt0lnnLlUvZ4WSlijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFOMZujH\nX1gSB4zV548wTG+ipsEzMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAP8NHJ2z6vTSndr8p05Qr01OiFPD3hs19T/N1EZm5OyDAiAULMTLggdgbZsg\ngMDPDDHbRwhZYXfsTmVZURChxFOteg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5206", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5206` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAV4aO5r/qPcIS/CwVlX7kYcAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzZDE5OTg1LWM2YzEtNGQ0NS04Y2YxLTkyZDUyMzk4ZjlhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjMzNDViZTMtNDI4\nZC00NDJjLTgzMzgtYjk1M2VmZWVhZWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZPqUnoKzBR3hWZBpEiCasRfPsHbOtKSAqm9zOuZHjFAlUht2i+c5B7CTPek0\nqZRlgTNlRpFsGtq+KcPCGntAaKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwmtPdYCQ3mMMa1ymOUREqfC8uEQwHwYDVR0j\nBBgwFoAUkWWVXr/nRjZ0nNhHE8MKVOGWx0gwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHvK\nvEdp5N1qqYvoS8y84r4cKF1OAzK58oOPzzCyc6nEAiBPcEA6UdgeI15+xy8+FXT/\n03/rXQEqKNvBoF7LMDEACA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUukoyu1V5FgZ01fvUM9qoZDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2QxOTk4NS1jNmMxLTRkNDUtOGNmMS05MmQ1MjM5OGY5YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVrfvB8GPsD1E99rMzvVsttI9rldNjQ7yovqnfWWc8jeB+\ntYW27oLs6A+eivF+SZ9WLFJeLbqIFq+PGqQWEn2To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkWWVXr/nRjZ0nNhHE8MKVOGW\nx0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALgzc+AVsRByNf8TNl2wv+GfBra/EliSBtuM7P2Gfdb4AiAWt2wwXT+K\nX+0uomd2+0TbAOeX+kHKUqoHaqTOg0aZ+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAYLW7NpBZcyNHBKgHbZk4mGFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjMzNDViZTMtNDI4ZC00NDJjLTgzMzgtYjk1M2VmZWVhZWI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU3YjRjNWQ1\nLTE0YmItNGQ1Yy1hZDQ5LTFlMTM5NTA3NDdlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDxUXRDrIJQcdB6ztseuaib6xlGMDAbEcuQNr6oiLZMENXzAW5j+dtr+\n8wj94ws08MxN/ypgqGo/pZmb1EhxlT6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMJrT3WA\nkN5jDGtcpjlERKnwvLhEMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgE6Ij9TxYXjwxxMHXDZmYJlitytKEUNWm0o7e0k/QygYCIQDtvz/RjGsrWZZY\n8eYvmyn7AfCjpyc99XcQpSzhWNe5cQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5207", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5207` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAZhy5PvcpTm2H65hdPla2zBzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ODU0ZmUzLTMzZTktNDZmYS1iM2E2LTAxMDBjZmQ3N2I1MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFjZjUwZDMtNjUx\nYy00NjBjLWE2OTItNGM0OTY0ZDE2NmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHPvcLq14EMJfo8I1O8pxXPMi43pufJxO9ahs140W9ucE3e1NQy38pCcXshVn\n3kipWpWctu7Hq2i32YI6T20wBqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq8VFNuqSxHSraXz0OTsMiPjrba8wHwYDVR0j\nBBgwFoAUcGAEWiIuI8totmO1u+CC/FERMGgwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFu3/wBf7L85bIoOMWJxReHKikLMq1cwGgt566ajkRmZAiBTo+pS\nUILfV3SArEA5FPnN4f67PWoWiqyVSDcoIqMa4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaX/eb5PG9v/b4pY0wfw1IStMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDg1NGZlMy0zM2U5LTQ2ZmEtYjNhNi0wMTAwY2ZkNzdiNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqXuqKPu2/Dz/L77L5zRTkAwVeHf0CqIBpcznhcLEwL9qn\nevWaJGPUEgty9ThV9bugpa6WTxBrYt447xJSVZOno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcGAEWiIuI8totmO1u+CC/FER\nMGgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPlqxnYkOKlorLlMioP2yNo2CkhC9iqsXAKnJH27JFfoAiEAk+hz7GLo\nXCfE9FW0dmGUt8mjO6OL1mcJtrlGL8Liz3c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAcFcZG9oPhLhhmNeJSfk0TzuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFjZjUwZDMtNjUxYy00NjBjLWE2OTItNGM0OTY0ZDE2NmEzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlkNmYwZmQy\nLTg0MTctNGIxMi1iNjFmLThjYjQ1NzdmYzM5ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNrJlUPTJvG4yiU7ht/1krUktftdplWDOGX3aJyPKUTYewOcjEu3PmSA\n0bo2DGKhk01gbX6mu5lOwyHuM7pe1KyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKvFRTbq\nksR0q2l89Dk7DIj4622vMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgHnEYU4ny/hAEkcpQr6xwiFkwGLWAgJ7nmzNig3e3N6QCIQC3bTKF48+yUetK\nbsg8XvDR0aw5t1FN+KgSPPWlMan21Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5208", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5208` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAeSeru7zcgyskiyk/slXKCFUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiZDRhN2QzLTI5MDAtNDI1MC1hMDgxLTQ0Zjg1NDgzZGJiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzMzMTc1MjYtNmFm\nMC00OTY2LWI4ZTktNWI3ZWM5MWNjMTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENsENTKOWHAXndrpsRDm87LIklujHzRE1Dg5YARZKQKqBqLXnXkIVf4qZ26hk\ntT9pLCvUolzmaNrnG1c3zCOvZaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUegm58f/qx0uDrNuMFbA12xQ4HoYwHwYDVR0j\nBBgwFoAUOGdDwJAk2q23GXS5hWN2smpU48cwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIG13UOyRGE9/wwd3wjGcPLN0dgfDhZdZbtpYBEddDgMTAiEAkSS2\naDXseu1YvDhbBMr7y2wRToJzqjtckoibVo+at8E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVzlNVQUPcT0mMZCFlNj2pJFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmQ0YTdkMy0yOTAwLTQyNTAtYTA4MS00NGY4NTQ4M2RiYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLSOROX6uy3cYJLsrxho/lcWPzKxtrCZB6eMMsQXSK17+e\nW4dtpsNtoPMVwVXO+prF7rIY9bhM/1GmN5SD87aAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOGdDwJAk2q23GXS5hWN2smpU\n48cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPg3EIwF/3/b+qYx+KubO9FcUjmi13kAQY4unPTCzgEmAiEA+u1aMnAe\nOFwGt6rCW3+beianLO/x+L+LEJQkBiK7ckQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAVQY8I2f+H1f7SJhdjzJQ3tVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzMzMTc1MjYtNmFmMC00OTY2LWI4ZTktNWI3ZWM5MWNjMTZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNkMjU5OGRl\nLWVlMzUtNDU2Yi1iZjMyLWVlZTU5OTQwNjk5NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEGCUak/9LVuV8GgVXGmv8cY8XbKYehtJ6n+9HrjOCNleMePyS/yr9wt\nWh4NCIeB92FYO137tG3Zxy2wOyfdyB6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHoJufH/\n6sdLg6zbjBWwNdsUOB6GMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAOyNAN5FyPgc1pXm31wnnzAy1q8Z6UthNH4L0vspmVahAiAbrp0ZEiOuuEsp\nKDdnK/luIdVzpm4ytOjW7eibbZJpqg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5209", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5209` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAdi+G7afLAO74N/KuZaaoqFgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MjBjNjNkLTg4NmQtNGZiZS04ZTBhLWExZGY1MGE4ZTc2ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk3OTA4M2QtMDQ2\nOC00OWM5LTgzODItNjA5ZDU0MTUzYmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1oOklL5ESPdy3F6JbAI5y3WU50SewltGmCBMKd//dyfMW+3ZZPgYxRC7mdRj\nUlxufRtFYhuDlo7u148A4FhceaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOzgvkwYJK5nlT+5PsleLcL24o9AMB8GA1UdIwQY\nMBaAFICCPD5WnCkDI224omRC579q7IYeMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA62Ek2ADlW9KRFpyxy9TP57S7o1Q3Ol/b\n0XpcM9T7Y44CIQCbrBQCjlaImH89hV97JvhtWPcPs/ugXJV3wLQLQ926lw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcNobgB8UI2beE+dJs9N/8vMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODIwYzYzZC04ODZkLTRmYmUtOGUwYS1hMWRmNTBhOGU3NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLMur1JZ5cHs8rDWdqkiN6sdkKhwgkXbJcOqWMyYBSon/m\nzxdlScgL2MKxOiTwdQS4sVoK3oadSZK/SNTIfGSoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgII8PlacKQMjbbiiZELnv2rs\nhh4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANiuD0k1QfzAPq6qX3X1FimJxUt3rHMIAGQ63G94VIyTAiEA9TsjQxbh\ndA99CRdYNre62As6Su5UDBaX+6kTDL43uF4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISARq3jS64PqfXkMXQnXnxhDigMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk3OTA4M2QtMDQ2OC00OWM5LTgzODItNjA5ZDU0MTUzYmUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk5MTQ0OTkw\nLTBiNDQtNGRhNS04ZDJiLWQ2M2ViMGJhNGJlMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKPy0kxIi/wK1F8P+GCG3fWgai+9GaVecpfu1+jEXzvwrI/7gILUFX2c\nfyQM4ntSIxIeNQatqVI72eS30XishoGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOzgvkwY\nJK5nlT+5PsleLcL24o9AMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAIRkt8xAEmEnMMRkEjNnpFk4Bt6BWFrT7fwwjJ7pdj09AiEAlU2+lpPG3H2O\nKG+d84knbTA/RBWs4qvn2E8ABQ+NM1k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5210", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5210` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAcNhbafpxXrCBsCNUxRP22rPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmZWU1MWYzLTgyYjEtNDdlNC1hZWMwLWVlZTA5MWFmMTI1MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFhZmQ3YTAtNTcz\nMC00ZGE5LTg3OTMtMmI2MDZkZmNlZjE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExve4OpKZ1BGiqn4lNcXk0LtfIHtGaGjldulbwNdfp3w6bcuIdWFly23Yf8eY\nrqylbgPuWO0uenvs8M85+hbL6qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa+yG/dSgZe4ZMaTLD60G86YAQyMwHwYDVR0j\nBBgwFoAUanOCwIqgsvkoJ9Ge2NjSuMyq0ikwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKCkHU+lfFp2\nOWuYDnw79BT32nkD8uXVWli+TE6cdYamAiAf6DPOqw512jKubXxO6qV/sBcow7Fe\nzBxQhb/iRrm5Bg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXpXZfFV7gHyjAPeHLg/cHbcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZmVlNTFmMy04MmIxLTQ3ZTQtYWVjMC1lZWUwOTFhZjEyNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLoVEu1tcYsyTQbRebHIfGw82CnIIcf6Qq/DFQBJaAdsQ6\nDlwDJsh1Wz92ee8bGcxm+B4HdDTeYHuFbJ2AALnho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUanOCwIqgsvkoJ9Ge2NjSuMyq\n0ikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXG3afdQ7BIb7LTZUWEb4WlmiUXibjTjT+HSSL4txwpUCIFQoRYvY84/e\nlq08d0cnFAEiGabDOaglp3Guc9dNoDU1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISATVcxeP+V+2DZM82bVC3fkWRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFhZmQ3YTAtNTczMC00ZGE5LTg3OTMtMmI2MDZkZmNlZjE1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc4MTI5MTlm\nLTA4ODItNGNjZC1hODE5LWNiYzVlNjViODBlZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFXQrT0y3B97nSIHb6nGrZ3VfxmIc/6jew0+JkIFN//kcRMDLq+Idckq\nrdhEHnzzX+g+5qitn2wJVxZ3iHsrG9mjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGvshv3U\noGXuGTGkyw+tBvOmAEMjMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgaFKFoDVfoO432eWkFDQGEUtCV5QW142XlRsYPCKHQrsCIQDPDcOGUXKt2YUw\nZlTYpM3q+E8sDA5JP1jPKCZh2xtZAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5211", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5211` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAQKM8tl35RhJBtLz34qtlf63MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2ZDU2NGVmLTBhZTgtNDY5NS1hOTVjLTIzM2I4ZDYxOTVhMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJmYTg3MmItYjM4\nNy00YTQyLThkM2YtMmQyZGM1YTQwMzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd56eXahG34umwTtmznUFPmJe1h7uXZ64wNa6SO/QSkQ8DeBrhyGc0xnQNitn\nVZFPlEUDjn4jVIojOUuTGlshIKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURYBfXBk0/h3BiFKWyCR5rtH+CrYwHwYDVR0j\nBBgwFoAUK5f/+XRiqG9X5Tktum61RawotUQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgdoV8Rk3g2UXj\nAZkGTsmwASJ+tvCqNUG0PpTxNLTONLsCIFNf2nWHCLrXRbkJVa1yj1ckR7C9DVOh\nM7bXudUbbnN3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATeh9wjJX0HhKqCvZ+m6cndYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNmQ1NjRlZi0wYWU4LTQ2OTUtYTk1Yy0yMzNiOGQ2MTk1YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+A2KzBJhxZ1dvqLpY4ahONm/71Wn7RxE0/sKcIsX4XiUX\nmY8ULUnRHyVqUsDMhtupBDgtpC/T4YA2jWok1Vkno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK5f/+XRiqG9X5Tktum61Rawo\ntUQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZInaIk9Sd93YDDXNFsmVMIJHgKZNdV+EMmd8jEY2lc0CIQC6mEOLzhfj\npE0WKPSC9+cTB4fwLY/jsEstsxLrAG08kQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAdCpKlqZ6CfwzA/IVL/jRI/qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJmYTg3MmItYjM4Ny00YTQyLThkM2YtMmQyZGM1YTQwMzJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZkYzIzYjY1\nLTRjN2UtNGEyNy1hMGUyLWZhMjU1Yzc0MTk4MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIxWXTOl1g50yiru1RojNZ4a2tyKCaaSdmdlOb8ay7ysGkBmg222rFOT\nvcCV8KSvc2Zj04jozI4C2BhasOK8xIyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEWAX1wZ\nNP4dwYhSlsgkea7R/gq2MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAOelOurMR0/GUec/VLKPDd88iNkkc0Sm2opI9ebkefmEAiEAyM4HC2Y35wlX\nBgaoZYVtUBVM7VEv+fkEDp8LRck/kTg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5212", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5212` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVEbUKno4ZhrHIGMQhgUigUnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5M2Y5MjlkLTFhMGUtNDAxMi04ODY3LTcxYTVlMTk3N2U1NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDljM2Q4YTktMjk4\nMi00ZWY3LTljNjItZmUyZjVmMWE2NWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENvV8QzUExK5yj/7+c6M6V4TR50A6eqFl26TtR38sOgtd/KNlFcp4fgNAlhP3\nVLl9wk/c39eWP0+PVhlrBQyBgKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtMshb3bk+YJu/swUr98pNlxZ7XYwHwYDVR0j\nBBgwFoAUyvB+WH120m4XzbdzQ7ce2RH3fhUwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCOLfuubzC4\ngxkfMEKsIJ01LLAjVsnN+12R9sME3/SLNwIgNdjDD6lq0KK/0zf5SYcB7yNJEdgy\nTcOj5ZEZM6aRN/s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe7Q2LHiOw1NGkadSl0fsOFOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTNmOTI5ZC0xYTBlLTQwMTItODg2Ny03MWE1ZTE5NzdlNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASP/6pmNHpyQ7V5sK0PN+bZIZxmXD6ctn69p+ruZoheW2Do\nkCUmoxV2kSkJZoHqRKsZCoAsToJN+PJG5KRMuDeRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyvB+WH120m4XzbdzQ7ce2RH3\nfhUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH6aUPyLiHL7T9tEMAvQF1ZqMBlLqplHHcz6rA0jzcxoCIB/0BamoDsdp\ndlRPrfly+U7du6JGCUuZ2vM4t7qik2fH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAea2x7o389VifQTPEhSq1zghMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDljM2Q4YTktMjk4Mi00ZWY3LTljNjItZmUyZjVmMWE2NWI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI2N2EyZGVi\nLTI2ZGItNDljOC1hMDE1LTMzY2E3YTEwMTBjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOmaIbvHFBeqZNDDxkORmipGF15uqCo8k3fnmJgEGle64P00iv0uv/J+\nNImcVKcVchsybRwO2VVYU8HWeDXyOx+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLTLIW92\n5PmCbv7MFK/fKTZcWe12MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgI5ZRcQGH2+YETn1Rx5NSNzkKth7Z2tO3M3et98EGTb0CIF8Z+nQ1T1nBxhpf\nqMkfl0n3PMcORT0Z904vYpnhG/4D\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5213", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5213` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAd/M6u+e1g0Kx374H0ZL3S1GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1YjNkMjExLWNiYTAtNDIxZS1iNWM1LTBhNGFmYWNlNDc5ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFkNjQ5MWQtZDQ0\nMy00YWRhLWEzYjQtNGZmZTJmOGU2MGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELxGoulP8A6Djytx9IRrX08i9AA+00yUsiZPmz1miBOufdep4e/znHGiEMwME\nHC3vIZKgKx7WHQRrgIrqBywBRaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUse+IeYs2VeYwOt1wA4+4Peo/zucwHwYDVR0j\nBBgwFoAUU3BwU2ZcOSC4b1vYmqQBD0k+TJYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCq6LcAXi1jrHCAeCp/t8R12/Eef13moYKiZ6VTIrINkgIhANff8EL9KoTh\nLUvEHB+ox9T+HTMivZWOJRxYKeJ8nlT6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVod5VSzPHRmtlCS/HOuCq+WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWIzZDIxMS1jYmEwLTQyMWUtYjVjNS0wYTRhZmFjZTQ3OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoKlU9CQagvRHAoLutH6NXsKfab9Cj6kq9WbnG69LjqGL/\nVo1nGm1hz0mslKAw8LxKlel8uqbTr4iAHxedYblho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU3BwU2ZcOSC4b1vYmqQBD0k+\nTJYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIKiJ4/pkNt++a9c5HfMit5kKf7bVhI+jHHzjPcMZx4RAiEAzSZWFY5v\nfav/CwjrA4agBVE7D4wnzVsLuhMNWx7qNeU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAbKvK7wMQOy98Ur3OAYLpCh/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFkNjQ5MWQtZDQ0My00YWRhLWEzYjQtNGZmZTJmOGU2MGJmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBhMjRjMjZm\nLTZiNmYtNGQ0Mi1iM2EyLWRjM2FkYzc1NTk4MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOVjRjiKkp3DDDR1ad7S/B7pB+awZFntngkrI1Sdk8/D1ZOOtktvKtJg\n1D5hxuQY+0mnZOY7xJPkydjQwUWj/aqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLHviHmL\nNlXmMDrdcAOPuD3qP87nMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgTfwjyS2GC0kOepdeUQpMO3cHrrMdrd9V1M/Uj1xx96kCIH3VQZMlr7I+h92/\njvfGyV1z5T3gdp2JFlfN+INnc0QH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5214", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5214` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAarqGyOM9utPUO9ORKKXlWrJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3YzcwZGFlLWIxODktNDJjNy1hZTFlLTM5MzUzZjBjZTc4OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjllZDYwZTgtNTU0\nNy00ZDVhLWIwMTMtMmFhMmVlMzVkMTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERoJMBiSnO7LFhrgRUHJ+zM56PY+pHZ9OjdyLPZYguwc9qVyHBSKlnh6QEfVA\nR3bndqU8ACnK6ZRddUdszewuLaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc6i4W9OS2iqCatoHmfWAd1UY3OAwHwYDVR0j\nBBgwFoAUpURsUbIx8YdajfOE5uOUdYsySGswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDivIzCqbTEU8dyp+K0NI2xgoQONSv1QXjseabLSmKqCQIgJ+rDiIJEzrfl\n3JvA/y/RwuT8YZYSg2p6REhnBz08P0s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcPFdntRTPxImGMrrSbNZwY1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2M3MGRhZS1iMTg5LTQyYzctYWUxZS0zOTM1M2YwY2U3ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxyDF0IQbmjMgToXPuu+4NRQ1bRTKB5KGXbatt/BPvnyWW\nv3qDIzpd+aGGl6idmJ753Sj6O+++YKNuAkUjMRhlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpURsUbIx8YdajfOE5uOUdYsy\nSGswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANx6w8vWTQl9hBZFonX9tnL1zZ991c2XM1msKhf5jrrZAiEAnvKjLur+\nd0YZUUJ4uS8vgy7n1sH0NeSoRvQfONBzr5U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAWIBeEK+MRr9HQPlnr3EfEsZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjllZDYwZTgtNTU0Ny00ZDVhLWIwMTMtMmFhMmVlMzVkMTNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMyOTA4ZDEx\nLTUwZmMtNDkyNC1hYjBkLTU4MGExNTE1Yjg5NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLK092JVr2zq5CbK/xFadtbyyVuX/cd4KK933a4GKruUWQzHrmmHzyqc\nvJq9S9FWf8dCiTQs3dXEpvZorPG4VsqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHOouFvT\nktoqgmraB5n1gHdVGNzgMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAK7Vli71VticsxTVxc7w6xp40VhaoL7rcDB64dsnYti7AiEA7Oe2C9zW7lcO\nmThs7pkjb6w9EcA4B5C1W6e/+O9cFWs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5215", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5215` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAZ/Etss9Vi84ca6dH4qITXS7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1MTJlNzRiLTdkZDAtNGMzMy1iMGI4LWEzMzVkYWMyZWQ5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE4MTA5ZWYtY2Zk\nMC00M2E3LTliNjQtNmI5YTRmNzhiODVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERVNg7MgDMAnKLvxfzMVfnG317kbEkpzNArC8CfJeWntZwMhboufJjQRpX/Tj\nyFp9q4bk3tO1lsibMYA63mpRBaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyYmgsVjfOrs5Nd3egM5Soaa2kX4wHwYDVR0j\nBBgwFoAU7E+4fzqCa/YLuoediKEb3obglZAwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEGs\nz5S74xUOixJMW+Q1QAMlte1d4f9y+Ww+rhNo0H80AiBpl5xBFe0FLFTh43clG5Ow\n42saZUZJQ01IQPpyUGaWfw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQWTHiiNBgcdXBaWUenC3KEtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTEyZTc0Yi03ZGQwLTRjMzMtYjBiOC1hMzM1ZGFjMmVkOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsjbtAmAjmQzclpK0UNJAUFT6PBs2oswODs9mGt7+rI/MC\nzZ0IH2RAWMUvd+4Njuyz1rV1S9n9wUUpqxd34Z9ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7E+4fzqCa/YLuoediKEb3obg\nlZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGnQnotZJ1LqkkWUBB+TEzaHbHcD9U2ayhNl9TISJrJ4CIQD/ZIK3NEtO\ni8c7xN1B3L0FxTFytqK7oTbkpRChb4rPkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISATX1x2M/0lyG86y1Qk31jYCeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE4MTA5ZWYtY2ZkMC00M2E3LTliNjQtNmI5YTRmNzhiODVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZhMzlmMTU4\nLTE5NGQtNGI2Zi05NTQ1LTAyMzc4OWNhYzI1ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHKsAe8DptXS++Lyi+cwTcD5Beqj1AdCkwTdbhFq9a15X4UeCigFmWWZ\nV3/g82AlJe0jsumTlhGVpRNsisFie/GjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMmJoLFY\n3zq7OTXd3oDOUqGmtpF+MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgE6yEZjZpIQyn9ppTyz5aQ+DLXHulXIrtVylNf4iV1HQCIB4uk9jhNvMvl2BV\n1Ay9qQpycAVbHMNmubZg07hzbh8U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5216", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5216` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAS0qkVzfz77kpPCPGLKGBBzAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmOTZjM2YzLWU1ZTEtNDk1Ny1hNzIxLTNjNDg2OGExYmVkMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhhODU3NmEtNDEw\nMC00OGEzLWIzM2EtOThmMWI0ZThjZWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFUs8v9QVyq1J9ZrpiaHsBtLc+GMQS4GY1ld5LwSbkf9dD0HL73uLu2SdpEg5\n4CRcDgw1Z8CT2HnxureT4b+12KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTF1aPUKuLumgIzzApb4gg17rr80wHwYDVR0j\nBBgwFoAUqO0dKAVA+pl7SQ+BBf2AfQq9B48wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQD8b1HDON1130fvg4k0E3x6APWv3uXFJDZqkzdFlIFSyAIgFFW0\n3hn2YDcpaXPVDynBOb232DVLFsEpP3RbtPMtqOI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVQqvDPzH4L1Wjnl0CEhlfVxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjk2YzNmMy1lNWUxLTQ5NTctYTcyMS0zYzQ4NjhhMWJlZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNhDxCLv3wXXeLKrfYTRDOdH9vsToE8J2zRGH7IXZScviW\nKAFrVljylVajlMKroU+wPVCOnvBFU/iMlERz1YGQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqO0dKAVA+pl7SQ+BBf2AfQq9\nB48wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZAkPmJBCAQAeXQPySla1dHZUNhWI++NfRQpxi0kFJ+YCIQCLbZYldhaR\n70csy2igzC1YZy8Vmp2nUFCEy27+AFtSRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARO0TqtYO8kG3jnUB/XC/AvhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhhODU3NmEtNDEwMC00OGEzLWIzM2EtOThmMWI0ZThjZWNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMxNzY2NGIx\nLWFkN2QtNGJjZi04ZDIzLThmMGY1Nzg2NzM2MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLvPoKgq2WgI5JnHOvJ5ousjxgdZlCzBFHAvrmtAbhY4IUbzeWqkA6FR\nJe1QO+d21PGvbrek+jQwWItSy9td0EyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFExdWj1C\nri7poCM8wKW+IINe66/NMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgeNfuPh2GZh9trjFEujvU93xz3IQHRzFNtaBtHh8HgycCIQC9vOp5Zek/eJ3k\nhF2McyMl5OnJnZQUvPuOB1NsHo7G6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5217", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5217` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAdt4ATWDGqONubBbPcmYEJRwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjMTQ0ODQ5LWNmOTQtNGQzYi05NGUwLTJlY2ExMmNjZDA2MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjlhNDg0OTUtNjcw\nNC00Y2FhLTkxY2ItY2JjNDBhYjJmYWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOaSpX/TJbDGxKKPsHk74L45Ksv7G3DSAEmWL2rfBdhfVvn7T9zMvHjRyDwUv\n4pDAKxQVqWr2hC+uXOzJ3cwXDaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjsXhyNlaCENzB8UZ5+OKLv26B+gwHwYDVR0j\nBBgwFoAURZ9/Y/AzGNixoi+8o5s6ZQTEXZAwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFUbjfKDRG4y+ic41s0FI/oRsVDj+fmzgnj5giiW415oAiEAizzU\nlxorb2skrhMOBC6fEyUs2ao4bY8yo4PEtWQ1FnE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaTlVVCoanXR22/mSTo23nm4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzE0NDg0OS1jZjk0LTRkM2ItOTRlMC0yZWNhMTJjY2QwNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCSCLk+HurcBNjIq/KN22DoxbES2W4b4DE1k+XRav7xdm+\nHUkmv4HqWrOm40W4qtRhx0SDCookQ2gW+iwwnbQEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURZ9/Y/AzGNixoi+8o5s6ZQTE\nXZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJALabtQtqGp33IWm5aNlQuYt7P+O9D2wXbrCqRq6v/SAiB/iavyDiNc\nIE++qy3BWtjGKI5nRetFsHlVT8a4kHJI8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAURiu0/MLHnw9+piEOp2CfwQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjlhNDg0OTUtNjcwNC00Y2FhLTkxY2ItY2JjNDBhYjJmYWIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU2NzhjOGIy\nLTM5M2QtNDA3MC05YTVmLTBjMTBjNjI4NDk5NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH1dEm4iIoU8I3bC0WeJyS5L/G9ON+tpLA63NMrUsTgZEDiSvN6SITbw\ninDTWuGQMZWR9aXljEygQhA0v9KsmDOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI7F4cjZ\nWghDcwfFGefjii79ugfoMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgSA76vxwefcW/iZhCiy08i3rdMP1zlDlN/Rcf0sHTL3kCIQCa0X8wO6fUMAZ4\nMtFYHS/XK74Xs1g32gxaoDuPiUOY5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5218", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5218` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISASlqZfLYsMjoW+6IdeKVlJVoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhODNiZTZiLTFhMjktNDc0Yy1iOGVjLTk3MDFkNzE1MmFkMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU1ZmMyM2MtYzhj\nOS00ZmNjLTk3MzEtZjA2YTkyY2U2YjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE05NQoI6nS89cvBgoy+9S5KHEtXQcLBVt3C55ZmTz4JDELklpTUUyIIvPJdMc\n7PV3WeD1JKUEq38dJ1un904rP6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQFMIsD9tNkn8JhDkYFzsKDsO2C6TAfBgNVHSME\nGDAWgBTF6mMuOPdJ3LAJyfLW2DpeQpge0jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDaT1ccJYwBZUefhaeA4osWKi6Sc2vG\nMQUPmWEQ1yI+XAIhAKg79FGMt2xMROMeikPcClSggE1JE7fVel+drbfAiGkV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVybyPmOxnyxbo/fNVSua7kdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTgzYmU2Yi0xYTI5LTQ3NGMtYjhlYy05NzAxZDcxNTJhZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEv2TGiasSSTmDNmyWNCG008L+S3J9ZnDwM3hdQMJqiCS4\nvqDFkVXxR7Dvla6z8maMKBejhO01+1VHOopa01fbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxepjLjj3SdywCcny1tg6XkKY\nHtIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOqbIDTSidPEj5ed1DYYWjr6s3nEMGQqQmOtT/MoQcnzAiBUwO40DdU/\nr2UxcPVaDLZANA1ZlDXj/nH9wsEBZSu3vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAXHJ/jjxSXQg9xpphG2Gm1NiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU1ZmMyM2MtYzhjOS00ZmNjLTk3MzEtZjA2YTkyY2U2YjAwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3ZDI4ZmVk\nLTEwYWUtNDNkOS04Yjg1LTE3OTY5OGM0ZmFmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPfOtu+XGM19bFFvh/ffwuZZzQeuafHO9WE/i3/OHhAS/Al6biuF9BF6\nc/0HpNj9qpH5DQ6km2ZQ1PdkX8vT/JCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAUwiwP2\n02SfwmEORgXOwoOw7YLpMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgHvLlmA36Iho+SCY4OmlHEnhay8EURgIAPe1lVFXLtlUCIGhImoVTOhSJOSLu\nASB2vd5yOhgvivJrR7Fkz7yR/Jzp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5219", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5219` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAc+/gnCWi3wFfGo6Yyp2rMBGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3YWJjMTg3LTQ0OGYtNDE5Yi05MjZhLTNlOWM2Y2I5M2Q1MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRmYjk2NjctOWJj\nYS00MmMxLWIxMWYtNTZlZDc4MmM3N2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZEcL5ThnomreCghfh9ZiG5d++SBA4dmf0C0tmEwwSUL+T9TRByDOb9hgjEN5\nKAm7jUzcMNm30cpGwMYeXS1jrqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Ai8m/lQIYwxman5BAp4sf5f7KEwHwYDVR0j\nBBgwFoAUL/i6pcA8Ly+hZNGpKgNiFsdIfMEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDwl4L0XcFQ\nlKuaM+UUYklnCDaSpi3I1iEh6bSGHqNLdAIhAOswFYlBvBWwmUQiLsa7e1uTO4Gb\n6Kk8h4TgJ1bOmuAk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVLxv+Y6jbOTlCwxzfI9OXkKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2FiYzE4Ny00NDhmLTQxOWItOTI2YS0zZTljNmNiOTNkNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPROCkNkTllZrGZTmSRZSZlQ88unDm7zryqm/GZHL9NNWU\n2BlcB+F2qEtoDKRDghk38m6p81BdH3FsJqhwgrJeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL/i6pcA8Ly+hZNGpKgNiFsdI\nfMEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN2w3Xr9T7hfQ9AR/NRJ/MWshrYqISy8iPB2daprSmU3AiB5WiiPY9E7\n0l5u0augE1nbsylSi08k1VjWuDIhVKnAkA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAb613/SYiPw8oRHefoefdF9hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRmYjk2NjctOWJjYS00MmMxLWIxMWYtNTZlZDc4MmM3N2MyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBhYWI1YmM4\nLTdlYzktNGJmYy1hYjU3LWRmYWJjYTczMGYzYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKck13aDRtbZqeBcD0rpbnN7YsA4KaeTl2OuoFZmM5OXNDxwNO82On20\n7txEidW7ag4fwN7y3NMyq8NdnFIUY1CjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPwIvJv5\nUCGMMZmp+QQKeLH+X+yhMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJgRr6lo9JOzBTBJgWcmpPBcTGWPqVl/AnMavP+R5IWfAiEAhfkWaj2qxWjD\nIuzUPaWFJljiM5Lfka3KAx0nO3Cxhbk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5220", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5220` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAS6tlwtxoPxZ1YHsraLpondtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiYzk0NWI0LThkMTEtNDMwNS05OThhLTc3Y2UxMGM1M2ExNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M2OTQ1MzAtM2Qx\nZC00MmJmLTk1ZjQtYTllYTcxZDRiMDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiA2Vf6HkB4giC26lZgu5lMtqKYoJA11ckVy/Rb3AoBx9dVsvQb2xZoUINY7T\nrLdF3mtr7UhpKWfuE2aAOhr5d6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULvZ2P6TJZ0dl9zpLW46PmXfTKhMwHwYDVR0j\nBBgwFoAUtJHyRyT1mZ0nb4NVGYBkim6qd1owKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD5Rj4PqJJa\nX74vs6tioHsTMzjS1uB8oXRqypFgQtQAUAIhAIglNhX5u3Scnb3IPCXS1tnJIo6a\nKa92G+R3i9UTCl3/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbtHVe3QeFQKmw7r/kSLNWQmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmM5NDViNC04ZDExLTQzMDUtOTk4YS03N2NlMTBjNTNhMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+pZDku0YYMNImAlrUyXNcjNaYMF+iHjtpLuOgJe3UadcL\nJUbp73Lqgy0aTkt0jugylw1ICerFY8B6OwAR3qNNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtJHyRyT1mZ0nb4NVGYBkim6q\nd1owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALUFE+1bL6PaBgCVuuTW7YWemxQuAnr+E0ylD1o4wgBrAiEAzb5OiYEw\nEjsnrl3HGGyTXekcMl2C0vKpVv3Kd/YX+ig=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAYX2vjliZN26zGnvgP+2gJxYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M2OTQ1MzAtM2QxZC00MmJmLTk1ZjQtYTllYTcxZDRiMDBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ3YjFiNWVk\nLTNhZTctNDYyYi1iMzNlLTcwOGM0MTM4MjViZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN4LoKqt9vmaPTiv8y4PT7mzqvJZ4ihn3GBCjexlW6LDMDXAPJc6bPOR\nUrMS7u7CP2u04Vovt59YkTNcMk+JY9mjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC72dj+k\nyWdHZfc6S1uOj5l30yoTMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgcCU8BcOOKjibSIkQl3pbRLlkVy7TNn00AIjL7zWfG5YCIQDQZLxhztQwgknT\nHg0rXTlvdlQzjYciKBsy3N65WeSjhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5221", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5221` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAQ/+m9nFKlMoHwz+TKxJ4h08MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwMGFhMWZlLTY0MzgtNGQyOC04ODQyLTk5N2VjODkzMDk5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmI4ZmI3MjctODMz\nMS00ZmYzLWI3YTAtOTFkODRlMjg3MzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFkM0ZkYV0zC/sFQmTL+xgMBBpszCtuJ21BAbqCkaRr75gOJqAb6aJrPpWv4k\nVzKVNXdjqbwzkFQRhzPOwJmjqqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFdZtEfQSz7A0qjajZrGRz1JyhaQwHwYDVR0j\nBBgwFoAUq5ghChnh7lUA0Q/nxMzM6sygt5MwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAHpcU0Wi3c\nLShcsGY+9DehZJxOIN1Se4oQezXJ3wR53QIhAKGpZsZ7Xo4t9IWqZ/1pvhnlooBV\n1hwkFHNlG/zIGwXr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWPmoXAOItrrHLNsj7+usKymMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDBhYTFmZS02NDM4LTRkMjgtODg0Mi05OTdlYzg5MzA5OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhgRq4B7nOq6Mht8cU6s8TTbfwdJmCIEPBixnXlBUeDrGN\neSawnPr3UDhuhndXcyzY/H27iCjJAsONyfTkCz6Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq5ghChnh7lUA0Q/nxMzM6syg\nt5MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJeEvZEdQAmV8neYiX80d+jLceIw/ns/AVVGqMdx2Zl3AiEAhgSpSClU\nn+Z79BybBs2YpRJOZGDAWGE4Dqwqevk11YE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAdBc2GZUD8rpqGna2jtlhekHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmI4ZmI3MjctODMzMS00ZmYzLWI3YTAtOTFkODRlMjg3MzE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVkNWE2OWJi\nLTg2NWUtNDcxNC04YzRlLTljMDFlYjFlZGNiNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCBbUPSrTXrrmzLt0ZJC8TlN5dWHNbBTvGpCFI23oIpa6BZvwq5qvwIX\nFKcEaPKiHZcJN/FgLqs/aKQo3+SjC5GjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBXWbRH0\nEs+wNKo2o2axkc9ScoWkMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgAQnMuEvrX4Hd3UWxbjvIQaF9l4NFgEUHDYog0c7bqSUCIQCyhhDhx56QcUzO\ngRyoplrzLz479jn7yftogaVtthHM+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5222", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5222` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAXKrWSjI6GuBvs+PsxxnwAMeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmOGNmMGE1LTNmYWEtNDU1NS1iNDlmLTJlZGIyN2JiZGYyNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDViNDJmMzItMWUy\nNC00MmU4LWFmMDctNDdkMTliMzI4ZDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkB2bNeNDpjyrEfXq2odDPbxBtztAVOvTDYHWCsgZS/EthqFrGurbZgYBF9VW\nIjmbabMs6fUCySGcbLjwmWHYyaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYzp//1BB8+mNQ1CM2eTfwBNb88QwHwYDVR0j\nBBgwFoAUo/VeTUWntrHEbrY3yXd0VbqYD7EwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAySid79r3iadFeftfk0sktIPprICoLV0TSFZOCXazH7MCIQDdTdGcFYPQ\nhOjZVsU+H1q5yCni5F8ZfEnI8p4a/4UcmA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfIkghmWK3pDkTB5pZJ8cNxgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjhjZjBhNS0zZmFhLTQ1NTUtYjQ5Zi0yZWRiMjdiYmRmMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASf7Zf9PRhznwOPyL1TEKdXHyH/ORCXnyWlLI3vXM/dscrN\nM8T1/FPQDaVvHf5J4N7nrdS9O8lNckuevdO6Zckko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo/VeTUWntrHEbrY3yXd0VbqY\nD7EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ71lq6l1ESmbKCCgg28yG1Ccc39nIWFkwDwmM8r9sXECIQD4frzD03qk\nrgzXNYA54nxH8MWWH9N3+12DPsmi1s9LYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbc25FU9q79UnxUTmP6PvnrzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDViNDJmMzItMWUyNC00MmU4LWFmMDctNDdkMTliMzI4ZDQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlhNjI4YWIx\nLWU3ZDctNGRmNS04NGMyLWQ5OWIwNzA0ZjY3YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ8juEhmLVtOXGe7LHLHjeCGYuMz3JjnH8TEwbWzx9KRu+CaxMtRRrQy\nFSH+k3Gwyqobk9tMaZ59RKrvY2O6eMOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGM6f/9Q\nQfPpjUNQjNnk38ATW/PEMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAKG68f0veoYcQj/pNmFX+RGpMGg/+3k2MDuobGd5BgdaAiAWQTrUfffGBl7Q\nI9tAppW4RIOC1cGl3G3EVuL99tpObw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5223", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5223` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbBUQJXwY04o4Bb3oao90/OQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzNDk4MmE5LWE3ZmItNDkxNC1hMjNiLTk0NDMzZjU0YWQ2NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhkMWI3OGItMTU2\nZC00OGJmLThjODctZmFjYmY4NjA4NjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA3l7b0uJXuFvsJZSZpgcrG0vD1i9P2dlOnECO28UYFFdJWhGyRWPd69EovF0\niDQBMO0OkRSEWM5cRO+zpOD1+qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQtxreHWIEG+FHzshUz6cSGBEEI8wHwYDVR0j\nBBgwFoAUu1KQhfCCuJhp/JqtwUR+Z3nGOOgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAFhZupwn4lwrfRD9K5aJ9thY0hBjzcHCG3s5ZeesKsiwIhAM7hG4oilncu\nsJvMAfDuSqfYSaUS5Iy6ywiXp4QDzaNF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU3TyOczj82ItcEhpwrqyJo8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzQ5ODJhOS1hN2ZiLTQ5MTQtYTIzYi05NDQzM2Y1NGFkNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlyekZT3501iPNqUIUUjUSw0k8JWVC+TiYG67W/8v0kcjw\ntLn0VevZzTYlVLqCMQL780oZOSOWTq4H5gPOeiNWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu1KQhfCCuJhp/JqtwUR+Z3nG\nOOgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZT1gpF7+81+FZIzxWDSGYiaHUiLgDfAWDypYKkZ6Wq8CIQCBhXb1ewWv\nEJqw35tYzbl4AD6+gQUgT8Q1GG0Zj47TUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAdtCRmSYbbw+N2OPBqFzDra7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhkMWI3OGItMTU2ZC00OGJmLThjODctZmFjYmY4NjA4NjE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk2ODhhODMw\nLTQxNmItNDEwYy04NzhjLWE1MjU1M2UxNTM1NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFQ3/BTk4+OmYTEqbINrdsZlkb4Mo3PQ7XdTj7aSphandKA/gnv2w6zU\nubMnjdxng2sRe0OQqlRyM1rvGkbz3zGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFELca3h1\niBBvhR87IVM+nEhgRBCPMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAN2Oaw2GJkOY9vXQS5L1aAWoMycKUv5tvsYA+FL61ANDAiEAwDWutOuEF0hY\nTl9eXfxB1aP7d5YFispJMn6awl78TYI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5224", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5224` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAVeqmDkI/exHyd4V6FcXzsL4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyZWFmOGY0LTdiNzktNDIzMC1hMDgxLWMyMTQ3NmE2NWE3ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ViYzZlNmMtZTNl\nNC00ZmVjLTlhNWEtMjMxODU0NjEwMWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/rCJO2edh7SnEap53Y/r3J51Xs4AfwQARAYIVaYGkbXg920ul2nBpzxoBvBB\nal1VvJdUxvE+ciGrtrLDwrJr9KOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6VpsbtcYBIf+RjHPNsNy0l/5/q8wHwYDVR0j\nBBgwFoAUGVg0F9uhylin40d1qnpGE2bXGtIwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n7NQEkdMgMTZdZhwqU3tfKkjedkNWAhZYvlBnhWUQZbQCICgua/DN49EmKH39VlNZ\nhWxC+dttLOLkXkhD0Qzmg0MZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV0lGahZEAIuQR+Duho8uAeqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmVhZjhmNC03Yjc5LTQyMzAtYTA4MS1jMjE0NzZhNjVhN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATo8fsis/8FgnpjAMVa47DeAC6Ec1dzmwhpuMUE9ZeHouZ3\n5vmaiXCfKvte3rSUqBFGCLDkt06sfi1fhoWTOKkZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGVg0F9uhylin40d1qnpGE2bX\nGtIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMzkNCjRXPwQEb2Wq/5McYp4dUjZ/v4vzGrTJ8v5CFeMCIAk4BiGME3GU\nJknvhN2a04bBzRcYW4RcJRRX3/MBUPXk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAfd5KDir6RZ5AtWGY4A0XuxCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ViYzZlNmMtZTNlNC00ZmVjLTlhNWEtMjMxODU0NjEwMWNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNmZjAzM2U5\nLTM2OWYtNGJlNS1iMWNkLWEwZDI5MTc5NjdkODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP0cjA09edYCj+iGY8hHXMbSwi8AV5avPTZpE0LTphkM03crFOXvpYcu\nnCT8shl9N9AU42knU+XwfLXDJdOk8NmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOlabG7X\nGASH/kYxzzbDctJf+f6vMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgcI69YZZz4tk8bD4gb579Jwx0qaNIck0cRL7EmbUbzRkCIEAARDpPJ2jbQ7yM\nX9997fx/32wFihsKJefKQhbYc+3y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5225", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5225` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAbGp/5RsoKMSY6xTjFVEAFK/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5YWU4NmQwLTJiNzYtNDEyMy1hZGZkLTNkMzA4ZGUxY2I3YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzM4NzY2ZGEtYjVk\nYS00YTBkLThkZjktYjEzNmFjN2RlN2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy1+0YgMYCOGlzsPJwxpx5MyA0hPFu5XH96ECMzOEhy8hSwpLdVMgIoW2hYEU\n+M0zZ3YF/Jj6Fd9xUVx5QGOycqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxSdRZ2RJf8qn92co7x96uIDT858wHwYDVR0j\nBBgwFoAUcF1F+NFEX9bAwczKDO7iiAxpa3EwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA1WbOCIfod5y2Xq+jDZudz19/KEkLr1+Haj5Khgv4d+YCIA5z\nJ0KvQeLjZ8Cgw/hf6xE+d4nxJHnS4Y3q/ioPNxPu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATgFnBT9MMOyLCN/u6+4LHlTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWFlODZkMC0yYjc2LTQxMjMtYWRmZC0zZDMwOGRlMWNiN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcq1ZNkUysHe4a5d9s30pEeHDEt4SrwyDQEeF2vDWQ0h/H\niO5Gjx1NQtA3u7LhDAfGNVOXimRDNul85yZqwXU4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcF1F+NFEX9bAwczKDO7iiAxp\na3EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKyRDQAn+lDxkK2heAw7aS6InPSdI3mHzbllhN6a7NMUCIQDTjbwDJd5z\niRl+7CcbsXVKhGYQWP4PeCTGy5LMsIrxvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAQGHrGAxURbvw+X2bTiXJAhuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzM4NzY2ZGEtYjVkYS00YTBkLThkZjktYjEzNmFjN2RlN2MyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZiNTc5MTU2\nLWI0NDAtNGJhZS04NGQxLWNmMzU1ZjNhY2ExOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA1blBJD6obgeY1fmLwRvxmMjZvlUiXQaJzqYE7VSxTjOePo1kWwxPhs\n7cPHbZufRStg4Sg5snbp78dxlWenZIujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMUnUWdk\nSX/Kp/dnKO8feriA0/OfMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAKwiFwFf7O94MXRApj/cMEBiIXVxAcp4IW+nxnaSIOsmAiAyMgwgKxmSR2Ct\ndJZswfWZgsJcrWyxzPFV+ABIbpY0tA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5226", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5226` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASixVAuBwB3/z6UKz+VxK1IsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5YjkxY2MzLTU1OGUtNDhiYy1iOTU5LTVkZjM0YWM4NzNiMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZlN2M1NDItZDk4\nOS00YWFhLTg3YzAtZTgzOWM2ZDI3NGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJm8+8l89cvIhZSBLNH4iFCu/z3ZWtXtBRf7N/vs0b8qfqL+KfdO27rIyqZBx\naQ2PAaaxg/eWT9JBDSh/mplgA6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxUjwtBnF9BU8r9OSI4prvsQAK34wHwYDVR0j\nBBgwFoAUz3T+LgsYtqlGngNseQ8TQyXMsP0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAsHPCAjxG5ylZO5AXEb9gjkqWFFn05dmKysFwTYrXZuECIG2h\nZ7NXImi3eRDdvBTjykHY6KmMjHVPl8Ptl+976AQO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc+kASRsVjeqrByLzQVoTSA0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWI5MWNjMy01NThlLTQ4YmMtYjk1OS01ZGYzNGFjODczYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8D+0GdppIzb8sScmjdjtwMxbWy70iwWcYN9mmMBoq9yAA\nVYLYQQmyC7K89XOnIsSWRufDN+c+WmkEobs6Ilvpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz3T+LgsYtqlGngNseQ8TQyXM\nsP0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK3oBMzLc9WVojlHxmCDGIAJIMg8ZFYHJ2kgzgJR4SmuAiEA0kXIl6bG\n8/Otx1wTGBv5SpH0dAXB7aRbOUXxYFsl4Ic=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAR1k5/FLdKFSA/QCu9Xhu12kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZlN2M1NDItZDk4OS00YWFhLTg3YzAtZTgzOWM2ZDI3NGRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNhYjJkYWEw\nLTI3ZDQtNDVhMy1hNDI1LWY5ZDNlMDllNWM0MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHbgA3Q3oOuKK6JoGWUy6l1XAMq4kVMKZs2gk/9IWQe77YWBhVXXQxn7\n0XM5ujyH9T3wjiODa7fFNz3+dXXDARejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMVI8LQZ\nxfQVPK/TkiOKa77EACt+MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJC/Ev3LHzKeOzyeQN6bOnOkVgdyMlccOWs+VnMKUzNVAiBLyE1Pe7NrM1Gi\nvaXy1/lbMyk/Ndw1EcBSJrzZON7BjA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5227", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5227` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWoRrXIAtnoinwLcYGCx5BuYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2N2ExN2EzLTJmZjktNDhhYS1iZTQwLWQ3NTA5NjA0NjQ1ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZlNWVmYTktNmRk\nOS00MmY0LWE1OTQtZWRmMWQyODlmZmUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETLzUbD/sHk1+AY4yBjZrDW49nzsn3/pZGl7HZoB2kXXGjyrauO5W0OgXEA85\nd6z8vGsGXRTnhX3V0JzwJhI/xKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpVyzMWYCmW2EaSc5rerKX336C+UwHwYDVR0j\nBBgwFoAUHGU54sl+cbD4DCnIlNpKkKTk9QgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBOl1et1q7YRU72\nqwYC0kdQAH+IulrZN3C2USkbijiFcwIhAINPl3rkTig6X051j32i5Ax7x4wAqoVa\nlXt3K2tdcfPZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWiWbe11CJbS3/ZDLcyB0QStMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjdhMTdhMy0yZmY5LTQ4YWEtYmU0MC1kNzUwOTYwNDY0NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWuxeuW4yNHenXVxhrar14FmGUxzPYHaxtGkNQJm2Bunui\nawe4w/9pvevTA+Ngnn91ph2ouDK9GLP6AzuF7IeUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHGU54sl+cbD4DCnIlNpKkKTk\n9QgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKe6zsyNQ98HVVeExb5BvKjmVmkklrW/Uxy5XgC6UIA4CIQD4HfN6O8bD\n+G6Gw+IMq+GAlZTKHCIQmh3BI2Im+JrcKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAd72tuN9rPhuCGBbH4HV2gwNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZlNWVmYTktNmRkOS00MmY0LWE1OTQtZWRmMWQyODlmZmUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDllNDk4YzY2\nLWYzODMtNGU4Ni1iNDMzLWU0NmQzNjg5NmFhNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLYt19Hblunu9TceNkll0pk3bO6UB6rwwGrJP4Fw4Lf0ukpBaoZ9+pPB\nDj2MpCUXXMp/EtJLLbtRTlkKRDeRWwOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKVcszFm\nAplthGknOa3qyl99+gvlMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgAe/7xsBJX7pkivsIKrqN1mmGiTYqgJf7iizMnx3hNIMCIQCLz9gx16j1wIQp\nUyR1/rxN+CdMHDLWLYqPkLuVYvfFlw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5228", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5228` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbcyABpei5vcIDBgYD2A1/qlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmZmZlNmE5LWNjOWEtNGExMy1iZmJiLWVjZjlkYWFkMWIzMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQyZGU0NmMtMmNj\nMS00MzQ4LWIzNmUtMTU4OTlhMjcxZGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3UMB2yW86ScNHjz9D+yTMagZWmk8TIJW5NcgXWOq4QITfnAA5r/JnMVrqRFM\nVJnZdei3iVLJuqkAK3U93ovbF6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpp+Ac3ySRl+Bbfnmj7SYHGrb18kwHwYDVR0j\nBBgwFoAUc7Fj09qdoa9S0Ocp8bDnQxhY4SwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIC0In5+0syVCuehneAQQZ3RVvhMQz5A6P+mVPoRsdyKyAiBiYrKp0OazvWqc\n5Im3zD4zikx3R3xwiovjZXAUgcLWWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATTL4ODCkbQJtKo8S6pbbC6aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmZmZTZhOS1jYzlhLTRhMTMtYmZiYi1lY2Y5ZGFhZDFiMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiYhLAjfuNRVQXPzGqxztLv43uhrZ2qNFh6YxO/sfbtgHS\n3uKV4j6b71BcY8jPtlRCXBiHDrzWGUxmOp9RyHpqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc7Fj09qdoa9S0Ocp8bDnQxhY\n4SwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO9kmco8U7/v+Q7ZQqtctky1quJkXZX9G2quq3AXgbyeAiEA49dAmjRn\nyBBY9lXUJbiFEotw0mpvwCqOS+gIWWbn5N4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARrRmL6k/1/mB1QtTiqeabOnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQyZGU0NmMtMmNjMS00MzQ4LWIzNmUtMTU4OTlhMjcxZGZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1ZTllYWMy\nLWNlYmEtNGY0My1hYzZlLTkyMWFjNzgzOTkxMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKOWMpHeAVnCLc4lplfh+hshDwmewaqgmzUI3hTCz2jZXQ+5AfHCrKnL\n8pNYo4yXOhVDQiEpcGh9pfYJbSrnt1mjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKafgHN8\nkkZfgW355o+0mBxq29fJMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhANYmw2VkbhL9zB+KccoSkTvRZTo8aaZWWANvNokQeZsqAiBjK2hnaNJE8Ztu\niruHa3oN6GA9ybZBOvzy/AjuY0EmjA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5229", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5229` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAabxHfB5QUh9/6ItSR7WPPH8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiZTk0ZjgwLWI0YTMtNGQyNC1iZDc0LTc0NWZlNzM5NjlkNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU0N2Q2M2MtMmNi\nOC00M2EzLTlmOGUtNzc2N2VlYzc4YWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcl4XhpJIy2ZzTHT70mZO401fgvhRi50MamEQelVFtmZyylcc7gU5rPtxNtfu\nMTgVgyRcEe8CbOtKchkNaph746OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgtItMY/kYcPmpuH6tMOzPwksRvEwHwYDVR0j\nBBgwFoAUSkTZtc5JzGUBGpNTr7C9lG/uJK8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDPZQcYCixHNkHi0qnkqtKGHTOMtvvRwayfd4LgIYtXvAIgLZxKAgZhv8PV\nUXFVyDHQJoNJdt5edl15bsA3YsBfI9o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaarKyTeVGeaYLU34foYPM5hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmU5NGY4MC1iNGEzLTRkMjQtYmQ3NC03NDVmZTczOTY5ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzFCsI+/7KUY8iJfaFJwPyt9YkEE+JqpJLzOpqehpoaxKO\nck/rkEQg+JleQw2P+IPqJl4dkVZlDtD+cjzLSQaco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSkTZtc5JzGUBGpNTr7C9lG/u\nJK8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALNJwZJCNp0C1tWhUrouot0oXdya4Z7TiefS8YUOTDMXAiByV4px7Lrb\ndEJkJQD0JpC5TjqirDrqg5KaK2QRLq7CQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAfbB31JgrPOSMBoEBJ+UdtHRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU0N2Q2M2MtMmNiOC00M2EzLTlmOGUtNzc2N2VlYzc4YWVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhjNDU4MWFi\nLTdiM2YtNGU2ZC05NWJiLWVlZmQ2YWZmNjM5MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNtsCXSToqvyq/ZGB0QlRwH+5uTr9ZM/oP6tnGBJlnfFK8lh5zkB+18J\nzn1XhkHhvtpAK+GiuRY7W2Dgc+35XC2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFILSLTGP\n5GHD5qbh+rTDsz8JLEbxMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAL1mAbTJnjDXJ1YYWB/aOKIcsMsa3rTu0ysZ7WhavhvWAiB4GZ88OvEvsSL7\nWiG8l5mHeHlkMk8UKGEhC7ND0Jp0Pw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5230", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5230` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYej+lpwfn6Zng93dtG21ZLJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlYTk1MmQ2LTVkNjYtNDU1NS04NGI1LTMyOGU0MDliNDczMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGZiOGI0OGEtY2Ni\nYy00MDRlLWIxMzctZTNmY2FmMzNkMWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs5spmoNomKOEKd4Nnl20CZ5kga5Hz5tiaG7iRLYsqSchC9S/ENQN1eXPJYxj\nuE3udJ6MQ8rXwq+0Eg2oS4DttKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZA96IAiN2fhr1fBQvMJXsmH/etUwHwYDVR0j\nBBgwFoAUKnnRUI6JESUd3ANHZEVurwSNcfowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAxiqUe1mFIv4vopbA9c82/jns7Jl1j5wmIsW15tbx8v4CIDEg4CqjreXG\nlDPR/zxJnhI6J7nWhCRcSaSVX7MXpumh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc/iw4Tvz7ieHtZdddJ7QTq2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWE5NTJkNi01ZDY2LTQ1NTUtODRiNS0zMjhlNDA5YjQ3MzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7ef7cFPEj6PhCPKQXs6igzSxd33XixDMforZmRUj1W8YP\nRZcuvLR3cmlr9AD/gfs0PFG0Vx2It6n9wzGRjSF0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKnnRUI6JESUd3ANHZEVurwSN\ncfowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALtUzE5h+kaDsR8uyekRCtsQjkWq3Mj1LQJ9p+OdK5h0AiEA50sf1sIB\n6qz1nRZkQr00+KsGWJWuQOZLJzXr9n2iwEs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAXDqXRrl7AfBWNjMhrNG2JKUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGZiOGI0OGEtY2NiYy00MDRlLWIxMzctZTNmY2FmMzNkMWUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAzNGRhYzMz\nLTNkYTEtNDNjNC05OWNmLWVmODQyNDI0M2Q4NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHJMoOMrLLSMPKsCX8qeIbcdUmrbW6CpfI4h5p+QDoae7rO4izPx3ok7\nEPjd20PS7bbOBj8Acg11461sjb+CrKGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGQPeiAI\njdn4a9XwULzCV7Jh/3rVMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhALwpvAE0ixwK57XSaKft/r4curC77U5P0AYXhAdweLF2AiEA2zto9AakFl8l\nUeVgYAf60mIK/hXUl+f9JbFFYKT+rko=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5231", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5231` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISARVG6dfVI3myxrqEQlJ4cQx9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYTg5ZTczLWI5ODMtNGY0MC05NDdjLWZjMTdlYzI2NzIyNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZjN2RkNmUtMjY1\nMi00N2VmLWI1ZmYtY2NkOTlhNmIyMjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZj/aA7EAAxgi121SrGbGeOeTV6WUvRBJEUDzEadt/GBQIhPHQX+jvv1zbLes\n5QKGGwRZ/hf35LXjW7+O8A5e9KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnNm+7gvmFRili36v1SrRdzFNbOcwHwYDVR0j\nBBgwFoAUQqNtklVI1gDx3wYNqh9mdwW9xKgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAu/9DVKjftkcyVMFy6Y1bFRrQ7s4lKVEr1fTC2AH/\nSb0CIEuq8e+sPNXg0wzn8ksabU/ioBYsiATDx+Z8HQToiwmD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZjxA9ODGkwd2oc2iFIb6WiJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2E4OWU3My1iOTgzLTRmNDAtOTQ3Yy1mYzE3ZWMyNjcyMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6bgafbnzsj3bF5ROP+4AXRtotGOa7ZBUUJYXWyagzNGzt\ned3a8XuG8HpUfe025pOsrg9EihzN6mLqLqE/XPh5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQqNtklVI1gDx3wYNqh9mdwW9\nxKgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgREzvWPSmhwxxT5FJFDGnpzhqZtRTgJTGd88F39uTsyICIQCPaZkdpaap\n4MIl8K3Wl/8oo8uXhb2PgOWdtLzSVM/Rlw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISATAJT85bgVD7PjBjIC4jLyOxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZjN2RkNmUtMjY1Mi00N2VmLWI1ZmYtY2NkOTlhNmIyMjEzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE4MDA0MWQ5\nLThhOGItNGEyMy05YzJmLWMzMjkyY2ZmODZmZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIkWGP23z8Bh9T7w3EjyJ4ed2LBSD+gNRog/ZSltsNAn3xNmSicbdwX4\n7+U/99Qxlw/EAobabVbfY/5CQxTpczejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJzZvu4L\n5hUYpYt+r9Uq0XcxTWznMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgM53YOKEUOyFE3UQfHs3khxwbXsHjFPYZwgolPQ5xeK0CIQDCIUGexwGS3QDT\n41deV/KZODS+PtMs4I5IKPHsUl47xA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5232", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5232` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQ6UHl6thbWsYBb6+wIpr/ZvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlYmQ2M2MyLWFlZDItNGFmYi04NjZmLTA1NjU4ZmVjZWY0MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQwNmQ2NGYtOGQ2\nNy00N2RhLTk5NmEtNWJkY2JhZTVmYWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEkp2a8Vv0jwo6TU7TBXQ8isi0+/QFYyg/mApQnAySLUARzEp8YzAgna4zMbR\nB9xnWgAjbYuNWkDaVlxs3iT6V6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtF08h6MsDmG+2a1cqUjt7Nz7Oo4wHwYDVR0j\nBBgwFoAUmJhkrdGYtz/dnP1tGgrB56zE4OwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAhiZJm8casCH8v6NA0QCvxklrUoEO2rolRo1qQ2wV\nDLkCIGUS20AVEuq8AvebkxinWSkiWUby2249CU96cu15T6ot\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASWuxgo5vb7+ebw0d+i6VoJ/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWJkNjNjMi1hZWQyLTRhZmItODY2Zi0wNTY1OGZlY2VmNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbCqn5KYQdbrHtOX/3EHzptq0qJLEQUQvFl1hGnvZN47za\nVY/AA/fr0K3FCr+TBruzVTsVWzRdMPPKKdBX186No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmJhkrdGYtz/dnP1tGgrB56zE\n4OwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO+mhCJYAz7f26kEqFst9aBvsrG8vmWW7PSD7DQGA+3rAiEAkXOY/bIn\nZO3Qzq6OY3hR0dmqK9zYvpTnV0aZskxdYoo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAcIZNozpIN3u+tnvtrWYEPLMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQwNmQ2NGYtOGQ2Ny00N2RhLTk5NmEtNWJkY2JhZTVmYWVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEyNWM0ZWRk\nLWJhNmQtNDVkMS05YjQzLTFlZDgwNzUwNTJiMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLUAqYX8LJjomMhpyJAYBhSe0UceQ2LzUO9fmK4Zqyl5NTT04mzUaMym\nDTeFZB9S2LtDSMefGbIHPy3Muz8b5Q6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLRdPIej\nLA5hvtmtXKlI7ezc+zqOMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgfB8O48dKramaZGRR39F4B9+9UZRBN7bfuOhhNlvtUPYCIQDBuYR9u683ENYe\nNs0o6g91J9fhRQ9KJ/AEQgCTd5ge4Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5233", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5233` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWUFOQOduLE6X7Mq5k8c9OutMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3NTAyZTlhLWMwMzMtNGI5NS05YTBiLWExZTA3Mjc0MTU5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQxMmNkNzgtYzEy\nMy00Zjg0LWIwOWMtMTAyMDhiYWVjYzA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6/nnLxeuUQqM7ZTlZECwV7maslaVOGEsnVOjypXc0oETnUnis5hTE+w3SujU\n02O2BRFHIRIHwZw0izDkOL/CgaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXJSfJzO3+TYqPb++ZYrXuR3Y7ncwHwYDVR0j\nBBgwFoAUGQ3ZhXPx86Atx9lVR/Sl5BURh+owPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBeXre1dY7dbd7dLW0iiAMBB5KzWAhtZb2l/h8Oi58TrgIhAMxd\nUpB0ANmpz09/I8V5oiqJSErIqPuw+GOLibjrQ4ZB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVRP53DIaEetrJhwoJaYKAEKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzUwMmU5YS1jMDMzLTRiOTUtOWEwYi1hMWUwNzI3NDE1OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/nV0k8j+GdxMM+Vmg0On6sSQmGDIb3kaNGb8ntQyJ3MeM\nUKuGmE/ZtCbkn473wAxdakIYTtV0A0825NQvGQFyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGQ3ZhXPx86Atx9lVR/Sl5BUR\nh+owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ5UC+e/cW0TphH8b8utQDpWI4pyP4yHcDRwZaAJxru6AiEAiyUOmVC6\n8Xc/HlxrJRMx85Q3l/pGruMZYy5Lnsnyges=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAZjBq6hwBlH1z7yl05vn60roMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQxMmNkNzgtYzEyMy00Zjg0LWIwOWMtMTAyMDhiYWVjYzA4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIyMzg5MWQy\nLWFmZjItNDk3MC1iYjlkLWQ3ZjU5MTk2ZGNiZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKhWqjAbzINv8VNqv/apslT3q50ToDHqD977on18yzpQup0VSaL9nVJj\n7iz+kmA8YqnO9hsX3EE550i1HPJdD/WjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFyUnycz\nt/k2Kj2/vmWK17kd2O53MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJ1/Hbri2zTrBoe8OjypS5A32DslRZxLD/T8fpJIg5PSAiEAwinZI9DHge8P\nxxLosItkSdhHHAyttE1Y/PE5YN7nwfc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5234", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5234` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAXXVhNyLoBprxU+94Mr/d7PuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlNDY4ZWY4LTA0ZjItNGVjYi1hODAxLWRiNDc1NmQxZTZmNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhlZjUzZDctYmI1\nNy00ZTI4LTkyNTgtZTFjYzVhNjA1Nzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtp6LCOszFxcQY87N8gsYLbf8bglTzKdC2B+e+DuVdXAksc9rTn3wf28ezIVZ\nGloZguvXLPNcm5d8ZAOtyZfyraOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDxIHYscf+mvuqlkIsWmrNiDBMaIwHwYDVR0j\nBBgwFoAUefHhmsqm7zJSH1nHyxValXPjzwgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAgElE1P0NdDElnr4MWmHrJIKGR92onHoL\nRtBHOaoo5A4CIQD3vPxrgW/d6k1DmRsm2VMqLjIs9XrFQeXrIeYRb1jWXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARVnBx5A2M+zBlJYlPrO7FU0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTQ2OGVmOC0wNGYyLTRlY2ItYTgwMS1kYjQ3NTZkMWU2ZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKludD4nThZTWvieBWSoQ18r/UAUBnDksckQ18Zac4n0ce\nbNXiaSf+4JM2NVZfqtilhAEKP+NYOyJCpqMWUUCzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUefHhmsqm7zJSH1nHyxValXPj\nzwgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYZ9NoI+IoOXEUgyWvk3fwjLzWocAJ22iKyREBlAyUwsCIQDmNo0The60\nSbHnLio+cvX9SJnjHre4If7iu5SXndcPvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAejQodr/HCe5adWDxuCGQ/rVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhlZjUzZDctYmI1Ny00ZTI4LTkyNTgtZTFjYzVhNjA1Nzk3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNiOGQ4OGQy\nLTUwYmEtNDg1NS04NmRjLTU2OTlmNzVmZGY4MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH+RpI8yRzMNViTvCvP+EXhes0zvnhku14MkN39eNt0DvxzZJOZdOcSy\nYpn1KD5nTeT5XwTEYc8gRnYLGko0pkWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFA8SB2LH\nH/pr7qpZCLFpqzYgwTGiMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJPwsgc8WH9H3BZQoaRsyTK0sR1hnpnbidEEzCEvGYRbAiBRkoYgMRzDCQOA\nFzZozK7Z/+535T5XfoLF6s/knoPxPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5235", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5235` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVMqSl8PgYQrzqNNs3p/feAtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMzYxNWI5LTdjMDgtNDBlYy1hNjlkLWE3ZTJlNGNkYzNkODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI2MjUyYzAtZGM0\nNi00OTllLTlkMTAtNzEzYjEyMzVkMWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEixi9duUTtR/8hjTmwfCY0NWi1xMz8DsGJuA96fYI5Bep9cBXgkMGExn1c97x\nOMfvfU9PtBZNV7vWuKQm0iJlSqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Zf+zLoGmP+rTTMLItZavPeZ7b4wHwYDVR0j\nBBgwFoAUcX2EZGRVj1l3pIGOiqtJ+4XN44cwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAt1WJCnqC4OujVAnQNu9gvtwuMOTYy6+x\nzkatreqXgQECIAxy2CAnW9lf/rA5wiByXi4DJOwx3I9+w4nRuOPP9HcU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASZ0Y/645Dn5q0olMdBvzPc4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDM2MTViOS03YzA4LTQwZWMtYTY5ZC1hN2UyZTRjZGMzZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMJcBz83wpi9guQaFkqVHTAlXNUTF10abUfe508mm2ZcI7\nbUHOUmr6egxVkMboeCifIWOGqsgHWV7K4SUm8CZwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcX2EZGRVj1l3pIGOiqtJ+4XN\n44cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTwM+SyE6Ezhzj2S5739c8XOXaeY+GelX7q0W7hxk0JkCIA4Zc/ncYKws\niRYA7LIovI50JYbdFbRn5614vT3K0Wwr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAUys7jmM0/XW2PkSCuBLQ1N6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI2MjUyYzAtZGM0Ni00OTllLTlkMTAtNzEzYjEyMzVkMWViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZlMGRmMzEy\nLTZmY2UtNGI4NS1hNGFlLTdhNDU0MjA5ZmQ2MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHiwmmCtHnScoMyxjPQn7ht98vPFN0RILv26fZJeR4VDhizTqpwjb3GV\nQFvGPY/U0uydU5xjW90HK4DPmFh50B+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNWX/sy6\nBpj/q00zCyLWWrz3me2+MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAI985nFIxF6YZjjwjGjT44ITrR5XzTzLeMGJpzrSNKMRAiEAof25RGoIeoe/\nLK1jiHo9V5PYl6KLGyZTiyddWTLl2hw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5236", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5236` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbKPPs+ikO/cgYsDP2rJVdivMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiMDc2N2EyLTM0ZGMtNGQzZi1iNjA2LWE1MmVkYTczOGI2MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZkMjZiNjktYzQ1\nZS00Mjk2LWJiNWYtM2MwNzcxYjg5YjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQJDzz3ZrNrsEhfQcvBIcZ2hcya5KSCJg7HaJ2xwHUVxfxtyz1tIouRB0burf\nZ2ccuLCTFLCUgGFbbn4mvzFnXKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF0ir8rxer8trczJg2oEF6wOcJLIwHwYDVR0j\nBBgwFoAUsZWlmvfD/ndfoOPxn+zrzVMaS7wwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA0jOEOQHtLy7+\nYaWvOnOeCzAyZUY0pKSG3Y1ldgKuWIECIDd+OnDMYF4fA68w4y8kh2hXLPho9XOc\n2F21AeKg8gwO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARLeuxYZDRZOuuekQH5/3P6NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjA3NjdhMi0zNGRjLTRkM2YtYjYwNi1hNTJlZGE3MzhiNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuUeGdmPjxSNHQTqeLmVP1SiX0qovJUHd0HXRCCnln7mu3\njciUAOOzAdQBB15c+pbJ4zgqxmVM6zbKdrkjlVLOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsZWlmvfD/ndfoOPxn+zrzVMa\nS7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO0iWlx1dNK0nkJbRwYRS9f1sOWMaKEzhCkxn3o+KIAQAiBqo0juuRHp\nKAxD8BDNtcFjWzZxPk590Lh4M30DIY4rjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARDSj96Yl9phjDfTxEsdrkleMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZkMjZiNjktYzQ1ZS00Mjk2LWJiNWYtM2MwNzcxYjg5YjUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJjOTNiMmM4\nLTM1YmQtNDIzMS05Yjk5LWJmYjA2OThhODcwMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLhKmo3Es6Kg9TN2bszGT9oYhTeFE+Qps6NM8Szidbhwy4cOiKyrJnrD\nZ5LSsl3MwPr5KTOjtTaqPzF/KaYzT5CjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBdIq/K8\nXq/La3MyYNqBBesDnCSyMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhANlhQQdZxAAbZye0wzo5bnArFzyPY+JTdiBzj9gwkb37AiBRlTs4sUH0myLI\n2xBxqAFkz5k535aM9LwthmtcFPjYeQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5237", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5237` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATFihWWjUM7f2EtqVRn5ScXDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmNmNiNTQ3LTAyNjMtNDM2MC04ODdjLWEzNzIzNGM1MTFmMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM4MWRhZWYtZmQz\nMC00ODYxLThmMmUtZjNhNjBmZmZlZjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE53i3z+gCIJppC7LVXyhzXoO046BRb4+PHKYhpKDw9cLTc6TyIdUl+DHBxcKy\ngZ02GqBsDGGfqqc1Hbh9Og5GMaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8CAr8mDQL/X1yj01AdDXregfSBMwHwYDVR0j\nBBgwFoAUGVMegdcQI3jwzo437e3ym53K3FowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDuzF9ink4QrpjSTVZvrt5ZN3eccv51HGBx4Tl1R4aoTAiEAwRLkhUeo4PJ4\ntcKRuLLx48aMyAXY5JktvVYcTxnANxI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWy6RNL3BjzSyYfPR19pJdPvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjZjYjU0Ny0wMjYzLTQzNjAtODg3Yy1hMzcyMzRjNTExZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUZPPc/rr11cac1aM6byKB3qScb4kKdm6OraIrp/RAmnsG\nFeOrKQkwRkqvp5O8P9X2wFrDHbN9ZcTl5+hZhSCZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGVMegdcQI3jwzo437e3ym53K\n3FowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGRjTzmpk3DtNoEeeynpmGLguN8FdpkgHvl/RHkP97a0CIFpyRrl2CkKd\ny8kpV5CAZYrVySWZqfQivQDypnLmYDrm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAeh4F3Xvy9WZu5B5TeSiieacMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM4MWRhZWYtZmQzMC00ODYxLThmMmUtZjNhNjBmZmZlZjQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQzOWU1NzFk\nLTdiZjEtNGE1Ny05NTg5LWEwZmNmYTUzNTc4ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPmC8MaU8lAcRRsYMfKnZft2lCV1G6pKqHjwF3ms7hhhTcq4GTmSHjwz\nWYpd5X0oIQR3lXETvYzYoBktLj3gUoujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPAgK/Jg\n0C/19co9NQHQ163oH0gTMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAPG0YHMd/a2iuljrqNhNMBOzEtfGB0ghQuplCsW+L7nPAiAakCzpkwS/52Vk\nQCzVrAgcRVFixqdSJzQe7RO1IcVQxQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5238", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5238` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcGb/uP+yl67Gc4WN6rZ4+zzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwMDBjOTNlLTc3MmItNDgwMi1hNTg4LWRkMGI3NWQ2ZmM4MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA4YmE5Y2EtYjE3\nNS00NGYyLWE2ZDItYmZlYjRkMzNjNzhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg4h7q5f10sv0oK3hEA+8+22KNsIswg9CSgV94EfxOS/ADV+o4ACyj7ztqt95\nMDty/cd7sUKGp05f1iXU+TXgFqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBN7z6fOUe40v35IbOfMpsQDWho0wHwYDVR0j\nBBgwFoAUFNHvUfhYhMXQeBvgCGCBLhP1EjkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCadTdFEHfg/DvFCHAvVuPuKxxkJDu88lTsOcqVmQElpAIhAIJG0rR0gZiO\noDf3hPgimBRTe9CGX7Im8u61LQuJBEtG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWd+KU6iRoNJTrbtgGlC9ShxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDAwYzkzZS03NzJiLTQ4MDItYTU4OC1kZDBiNzVkNmZjODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLe4nVHj9aLJlsiPXs6KVka6JmcK0umVOIdkARjixXpPFO\n/0I3TZz+2QNWn1RH/W3XeNUetk1NHOBs5hXGekF/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFNHvUfhYhMXQeBvgCGCBLhP1\nEjkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSRJuf80K5L+iUfpBJv/xGHV1BaHF8vv5XH59iP1RTrgCIEvXOxRgENbJ\nnB69zZxKCWm5S5bx8kTqgKEeKU9uRyo5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAXPMJFP4zgXMv4h++8LaV02YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA4YmE5Y2EtYjE3NS00NGYyLWE2ZDItYmZlYjRkMzNjNzhhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ4YTE2ZWE0\nLTRhNjAtNGMxYS05Y2IyLTA2NGZlZjljZWYzMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLw2jWJQZo/t4iQByE/ASzdkdhqMQkDwSfWSFMMD6nYHLOeOL6jVlgu9\nToLdDdxJ+dfjX9oWc7LAT38XdL0JspajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFATe8+nz\nlHuNL9+SGznzKbEA1oaNMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhALZr+p0CmbAOhfR4vHosaYewkj7bsGBqZEu9lBXQX+BqAiEA9dUk9lwFLGev\n/Oqgx/s9i2cylFUnABL1Mt7zj1A5WSQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5239", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5239` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAQX3chHT/9JlpLqlHd9i2BcaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5N2E0MmUzLWEwODAtNGQ5Mi1iOWU4LTBiMmMxMjk1MmNhYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM0MWM5OTQtNjcy\nNy00YTdkLTlmM2EtMmQxZmQwOTI0YjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzZ6qPThsosVjsjoBGX+LeMNt6CkdPyaC2LApf0T5OMjs9cpGb0teaQeflAYW\nFwgJmAYF7zWoHkteCJJtxYbj5qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIWWsp6CHK+mUJ2x1Hctu/vcCMR8wHwYDVR0j\nBBgwFoAUahDbF4SkPNiUNb89UAfu+T2P5NswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAiqdJ8M88N4jf+gM0wJV64/g0QOCNFRnWEmSwsqPe2p0CIQC/PlzT5lrG\njFpSPdKKxZPDVa5vRPW7zI8kFRKRz83DVw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAehzw8sN41fdkpZvYx9eoetDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTdhNDJlMy1hMDgwLTRkOTItYjllOC0wYjJjMTI5NTJjYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVmHWgoMQf4zQDovf/2o+GF1WP5kq9Z8w6B9AvK3kAxGzY\n3ZIKo5q5AYHjNbqQmbgqwHaijV1kBewDi82ysdCHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUahDbF4SkPNiUNb89UAfu+T2P\n5NswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANNAZvjGFVPzTGCyshI8rF7Zb3LlChcNqY/Gw/Vc/t4VAiEAig/sPzZf\nXLsw1ECivUKlHR3gNJd7yeBYm82Z+tuqv/Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAZud8wjlrnw5aHKOy++og+sIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM0MWM5OTQtNjcyNy00YTdkLTlmM2EtMmQxZmQwOTI0YjAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFkNWM5NmRm\nLWQ0YzMtNDQ1Yi1hMDE2LWI1M2MzMTRiODJkOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABElc1zp5/LbzxsZH+h9njksfxxjemnehIpt6qAvTMNgtjXm49yO61vp/\n9YRTT6r4hyP55iynBVKFM0MoJtJNwGujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCFlrKeg\nhyvplCdsdR3Lbv73AjEfMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAOAFTCVCz5Kt/Uywxral4hltlDGebFxC9XPn6UUcfIGoAiEAib17GV6MdKJY\nQV1JuN7N0vOoHYHafE1mrhBcD1VC+Ww=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5240", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5240` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAVTJsM8Ipag0KRh0URpDcaBpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5YzUzOWQ0LWI3MDItNGNiYi04MGNmLTgyNDEwNzY0M2JkODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODhlMDhkNWQtYTRh\nYi00ZGZlLThhNjktZjQ1MDU2NTZlNzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKhkfE3q5EHVzTOTbGunTo4QxeJeNqJTt/SvGUmctaHbOwpjz5k5jXNuLST4j\n9+fq3j87g4ru9cUPJDAAsdOsraOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo+ckioLzVWWLJwNeBLfu2r0H/wkwHwYDVR0j\nBBgwFoAUTL2oB2jBoGwNm8EWzNnowR4SFAwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAseb6IvM5TgGsBcBZliRomuSuJG83sHKsQAYza9BFD\noQIgTIpjDivC1WDazqX0ML6oMjh6cckEB6Oc+qorQnSnKck=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZmKMJXx6CadUUg1ZZ0+Lc7xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWM1MzlkNC1iNzAyLTRjYmItODBjZi04MjQxMDc2NDNiZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNknQJRRSvndPyDu7e7uEdRBJy/sQmJxXS4J5NTZY2YR9a\nPFNuX96j7+e9lG9nNC3De7rE3uyP9/ixoIPGRXSyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTL2oB2jBoGwNm8EWzNnowR4S\nFAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO40cN9bvp1oqXeYSo2IjOFzXlsRW77dxZEdilFw6mYbAiEAxiMPlGPD\nIeVCoAfuc6JcmTZBjX5SMJExZ1OBbzjnBJw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAY7wIywoWI7fGTlTbHoo2oVmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODhlMDhkNWQtYTRhYi00ZGZlLThhNjktZjQ1MDU2NTZlNzRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVmNTFmY2Qy\nLWYzNTItNDdmZC1hOGExLTliZWRhZmQzOGUxYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO4F6m+DKPhLOpRIGW+pAV1n0+eKN4n5dzFX1N74QayzzkeHdYHUW3iS\nYDWi8Hh77kvy16BRbBIo2Up/NHNddNCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKPnJIqC\n81VliycDXgS37tq9B/8JMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgSQtSt6Dvuzs9KosCBnXaf16eyXR6Q7Iy/04cW4ueIwACIAL/8yXX4hAA2i0n\nBTcUZP5eOtE5CLjeym9VjQcJhDCz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5241", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5241` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASCnyMbO+tx5qgNjQeBra3U4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4OTA2Y2E0LTQzZjUtNDExMC05ZWNjLTcxOTI0ZWM2NzBjMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGJiMWVmMzEtNTU0\nZS00ODQzLTlkMmUtZDI1MzA3YTFkNWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6n5Bf13m8z4vJh44vMllD5Qs5xQqZ8xlygIcDC0nxg/R9pvPR+6/fCJnDqNd\nIeu2I6UZORL0ujCU+fw4nxLfe6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOk80xhk5DNcMHW5j3ifcxzQSCcAwHwYDVR0j\nBBgwFoAU7PXdGsu1s+tOzWkLT2ALGblko5YwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBVO14REZV7Fz+jQoEWEfmI2q/Xa6JSxHHaP4fUxBx7\nfQIhAPnSkmKt3hmjsFBeoWZBgZmxE2hdrGldxeAvrFSmqJnu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUfn4GoM5QswJc9mzzFGMPXWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODkwNmNhNC00M2Y1LTQxMTAtOWVjYy03MTkyNGVjNjcwYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjefAgEoleq3WeLkut14lB7Nvhcr6Azn1dCa0kvacGV1U4\ntRP3Tdumd2dUVBnqpUFfyVDAzB+wvVlRHhlXHiybo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7PXdGsu1s+tOzWkLT2ALGblk\no5YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFAnGxcphWL69WLaxBMxr4FuTOE1S+6/6fVsG+Z/pm9YCIANQJXXztFiK\nmbLwLxpuy7EbpExc+EC/lz//hvhJClBs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAVC8EkAaKgxul7lgg1XOwu3nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGJiMWVmMzEtNTU0ZS00ODQzLTlkMmUtZDI1MzA3YTFkNWEzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI2M2IyYTJj\nLTU1NmYtNGNjNy1hNGY4LTIwMDcyZDNhMjdlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKIZHhs05UPPkxu5Vo48I+BmuOwHlHk2tIMzWFIVSNVUb6Vz5WkPx+v9\nJSb9cEhcsapQbFOiZr4KS+73yayPntajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDpPNMYZ\nOQzXDB1uY94n3Mc0EgnAMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgcwzrh5ihypq7UHPjUc/8jP5m693oZztvsGsYAE5CYnkCIQD2h1YPyqsmxent\ni1HXLc13/tnXxFVJqTOIAbbDq1/GTg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5242", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5242` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAY4Ir3lZqbBPWLWYuJrr+784MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NWEyNGM4LTQzMGEtNGRmYy1iMDI1LTk4ZDJkY2Q2ZjJjYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU1YzI4YTYtMzRm\nOS00ZGQ4LTg3ZDgtZTE5NTk1Y2UxM2ViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8UlXP4zsdYoMVSrFdXd7zn4Cl5HBAQc0trf0ZkU+++uiuvcUiBRNbD1n/w/a\nUgAG9v5PpUe9mfygpMNHPwBV66OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUelMfgQxICj13ROO1i83a2NAqjpwwHwYDVR0j\nBBgwFoAUHSiqDEygtIB/EbxDJ1QrgWOURdEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAEgo1rvgU7gq6kJUWTCAhLTAW2vFGtVmM2WjBeGkqOYwIgGu+i\njpbSKKyC2wsp8eUrLoHsK9Smlh2TFNKbijWtOqM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYiCHQ+POTJ1hmGQTCSRRFJIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODVhMjRjOC00MzBhLTRkZmMtYjAyNS05OGQyZGNkNmYyY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXtYnMaGTEzIqFXvazgjQCnk7ILaE8+poVgvXp1lmbbMxz\ngX7slBo/QNvV1YR4k4E6uAApv1kNUQNJLwPTpfauo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHSiqDEygtIB/EbxDJ1QrgWOU\nRdEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR8S9P3vyBpn/clh2yvm7Cnz8e7t/kRwyrTLrCK8MDwsCIG9nRXOH4ksW\n1d8SEP4wYujU2N4bHoJLPBjhFdyJcB+t\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAfSRs0FIbkCZJgaINtfi+mbGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU1YzI4YTYtMzRmOS00ZGQ4LTg3ZDgtZTE5NTk1Y2UxM2ViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcyY2ZkZWE5\nLTVkMDQtNGI3ZC04MjQ2LWU5NGNmMTA3NmMwZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMZwJvgyP9GcHRzkBTS01rv+Bx4kpm4MGfEuAWUOcxfz/CLMhn4DO4rw\nDu7nTNFofQcWw71Gaw76Rykcr/NUHfujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHpTH4EM\nSAo9d0TjtYvN2tjQKo6cMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgW9V5O4dj/TK1eSa1r1ZipTaCGk+EERwbSxeSpxIbCOsCIBXcurLeDRUDFrHj\nk6Q6gdS607kp5tzFa8jBV88MYbFp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5243", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5243` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATsoI6oFs5ZLmDMudv3AbyzeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4MWUyNDdjLTAwNzctNDQwNy1hOGQ3LTEzNDg0NzRjYmNmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE3YzY0N2YtMTNi\nMS00NjM5LTgyNTctMTA4MDk0ODgyZDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcsi0vd20MsacDC/GWIIivXOtaTIcLm/JHwpi/SiZoDuKE8f4r7WZcSjDDen2\n1XqWdI361F06Yo7rjSU0b0tV56OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1sL3MLRHHsX2IgSX+ORdZisVGA8wHwYDVR0j\nBBgwFoAUZk8TNzEEHEVCFMfNT47HHUHKXzMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAmFza9KAsSXlreCjbOOekZ/LML+pzKw58V\nWAsbhCzgXgIgU9/E3PTofEjO1hF0rUjaJGYjioOn0F5VAquGYTN86uI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVWDa+BUX5/9FQFVGkBEj3E3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODFlMjQ3Yy0wMDc3LTQ0MDctYThkNy0xMzQ4NDc0Y2JjZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtH4CU/GvKLR14x2SfjPzeWXryIQix4MD3UId8M1hpqrQm\nmGtrbOekOEb7bUvyH6d3vJPAiAP0vNOoAvXhQqTMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZk8TNzEEHEVCFMfNT47HHUHK\nXzMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCRa9oJihz6TcgGwJqwMiFskrjSe/h/nfn+KAWMzS/iICIAgqfrFtVg+p\nvtI75nILmrRbLGKZaN79ls/H4Kqyg4C6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAapBMWL7FvehN4r6euW/1L/BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE3YzY0N2YtMTNiMS00NjM5LTgyNTctMTA4MDk0ODgyZDRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI5YzdlYjBl\nLTc1NGUtNDFiNi1iOGEzLTlkM2Y4MDZhZjExMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIITLfKoCw9vIm4MILDXPNkvTyJV+QuVTU1MYwujOrt0PfcWYy7GTL+y\nf+JXF9MaxLOaI8i3RxDeoyB0NuFq8gCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNbC9zC0\nRx7F9iIEl/jkXWYrFRgPMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJ5kk2YCMWdjOy4a8ll9RWkNu2WVBJiyjBlBNBNekVIvAiAR6/yjNCrKJpfe\nXE0BFfnAfzjk+KlJnF3u899RaSQc3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5244", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5244` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAUTRaU7PQJhKFOw7k3L7OJz4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwN2RkMmNmLWE4NGUtNGI5ZC05N2E4LTkwZDc5Mzc1YzZmYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTJmMzc1OGUtMjk3\nNC00ODFlLWE4OGQtNGYzNTA0ZmQ5NDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDQJUjnmDFeM2rJd7nLHmRh0W21LNPnYoznNvSeFZNqM2DlC8kGPiydJ2vxBa\nAYcnrvwT72TyZG7VTxHNSqW9yKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG15Nh/3gVxH4lWnoATvAvyPYgPAwHwYDVR0j\nBBgwFoAUSSRO2tQqS/qDws9+P7VpIpunu+AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAv+8Rk+xOs/Qju6zpB6t39OBSHdspxxO9\n/7vDMZVD5AACIACMlZlxAueNt4eWB8g+AMEIQnLZtcSYPDlmB/YKlOA2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAasd5od0R2je16A3G/e2aoLIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDdkZDJjZi1hODRlLTRiOWQtOTdhOC05MGQ3OTM3NWM2ZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATASYchoy7ks/IIvEVqBiD/0SpZkZDs7ZtnZuWWnMnGFwRD\nYT5wKEccszfqq00/b1BteE87BfZgz45iDNZsCGg2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSSRO2tQqS/qDws9+P7VpIpun\nu+AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPoFivIt5kffsqx2+FWeU1jpJADhDQfvPZXEKEjiKw9RAiEA9MPzCS8B\nN5icvwpL9OtnQ21SDnXM/yvpztfD6MSmoCk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAUURA83tKhyFnwH1REGsn6qZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTJmMzc1OGUtMjk3NC00ODFlLWE4OGQtNGYzNTA0ZmQ5NDYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQwMjZlMDQ3\nLTJhYzAtNGJmMi04NzM2LTc0MmNlM2E2ZWQwZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD0087ro+NHqHjAzz1UJvWcDxsqU2ZkX25NQuxVWfUdKmOmyskWOE3Q9\nYjXcBzIWZ6iHKeI6nyvY//KpfyHP46OjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBteTYf9\n4FcR+JVp6AE7wL8j2IDwMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgPhfhEzGI34fTFxpUAth6pweKc7STXUQxhzoDBMYqUPsCIB2qfcD2clsmlH/Z\nNvML/hOUF/fT9ZqO5Wan7fXf7CfF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5245", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5245` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISATc2L4L4TtcUl5l0q6wIRWazMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZjBjZGRkLTgzMjgtNDI0MC1iZjBmLWFlYTNmYjNlZTI5OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAwNWU1NDYtOGEx\nOC00NTk0LTgyNzYtZmVlODNjNjk4Y2RjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAm7m4JfYQ3jrmjcdI3920VzX2RjjSCbF5D5WmeiTTw34DjsF+kNBu86XQVaf\ntr7sBwXjYLaiqR5nEbCzmji0HKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5FlUh6bLQ/42/XRseX9JdjEwLZgwHwYDVR0j\nBBgwFoAUog1xkfP08zG7NerRXrj5m2T4v44wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGnaGCnssJzD8gWrP+pVf5hBx3LQ\n6Cz+Sjf+4VhsVzTNAiB6nQ8axDMu8ppO7jUEXUwThKHEnAzJ2YOmoG9B7VlG/A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbe7dgHykNc7+p7fLn1gnQGIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGYwY2RkZC04MzI4LTQyNDAtYmYwZi1hZWEzZmIzZWUyOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKJIAI0aK6svcazpkDl8qOMMStxmVnJlALydtyXfKc9c5+\noBLrmpMlpSoUrBvaTxwQf/gCo8VvZWfPuDIlk+ICo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUog1xkfP08zG7NerRXrj5m2T4\nv44wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFyVsoZKpiZ8QSUYCHBQx89PRFmwNYCcnhnvF1VwwjE4CIDovzXOx/9Kl\nUVXoPQckL6rm8534gbcK4QXh4ufIHE+D\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAd1XXFoB/l1z+BouYx49iVxkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAwNWU1NDYtOGExOC00NTk0LTgyNzYtZmVlODNjNjk4Y2RjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY1YTJhMmQ3\nLTI4YmMtNGI0ZS1iMWJjLTMwYjFlMmYxOWZkZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA4FV/8WNSymE/ebfkRoYxacuZRDkRCBIBKzQryikReMbfbKxsUUgDXf\nM+aZcc26w4ZfZuAa3eLE7mUBC/fY4mCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFORZVIem\ny0P+Nv10bHl/SXYxMC2YMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAPMHY3A7kpAMSavZqTI1O+jYw+uQyqyb3aA8zybmmKsfAiEAxrvtpchth65a\ndABTvfFT6cG88RORykJ5doxfYV/JG80=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5246", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5246` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAdhEfdhBO0Ve7yoUwtvzFYFaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2OGFkNTM2LTA5MmYtNDBmYS04OWRjLWRkMjYyYjkyZjIwOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI4ZmQ4NGItYmM2\nMS00NDRmLWExODUtY2RkMGJmNGNkZWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFyDcnP1roTQExd7dHPSWlmuE0EYVuiyelEyxtGDkUnVthNp32+kQP4KnlcdC\nUieSU+X9GS/rQKc7XyRSSsCV+6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6AYkEqpYAQBGc9x2n1am+rIiu+cwHwYDVR0j\nBBgwFoAUIoy02rMB9+AvtftugcsasnwIVMowKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIziOZd/\niygYkoF8a7OJC2u/vbyMl/bUCvUMPb5KeGOAAiA6c2qTKliHfBrRZ6vR3fgaNVfG\n8KRYPutF4cpBqMvm6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb9wJy0i/1UNqAvd948KlvyQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjhhZDUzNi0wOTJmLTQwZmEtODlkYy1kZDI2MmI5MmYyMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0ocma5Jv2Zdbyp4lfuF93Y+MHXSFmyKmbvKXcnULCgmBJ\n8m05NdAjMj9xlJGfJUnNKdJDexv3vDRQZczNpk13o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIoy02rMB9+AvtftugcsasnwI\nVMowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALyulWJEMRbog6PEiSWkqkeHaSoNVFx33QGb95Yzj7d1AiBnH4M+z6i4\nZzKyOxwlVOXJgreP8Re3MvVgPx1YSdGeXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAQlyyG3SMCoT4OEFjtWwyWAuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI4ZmQ4NGItYmM2MS00NDRmLWExODUtY2RkMGJmNGNkZWRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdlYmIyMjlk\nLWEyNjAtNGI3OS04NjhiLTIxZDE4Mzc2ODA5NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH22OTDZtIt8f0JBqQR+gDfKmzNjrAdCSz8pcv/vaMuxfxekzDsetS/j\nhjIqyEinvKFcHLhgZd9gr5CcaVT+zQCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOgGJBKq\nWAEARnPcdp9WpvqyIrvnMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgB3tAnHY6/xvdPrkdYePUBRvOR1Nvg/zNbTG25Q1KfmUCIAK6BPOkuX3kmF8E\nyyv7ZKRfM0ChH1Q6TKfvNHtcYmez\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5247", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5247` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAdkjW/UTMb2kEPIXDhOLrxT/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MmUwOWQwLWU1NWQtNDA3YS04Y2UzLTE2NGFiMTEyMzZhNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU2YTUwMTAtYjQx\nMy00MDY4LThmOTYtMWNlYjZlOWQ1MGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+s2dIoFWBPoThTVdCmw4K9VHeLg48gRnW+gAboMrUfKW+hVNUTLUaEtXFk5w\n9LepUxIOW3jr17bNLmAFX+/ctaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOqvb9c/+xK6MTDLeRMpt8lAY1gwHwYDVR0j\nBBgwFoAUrIriS2CmRe66kpJ5pY4uWzqQMbYwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgEmU8WfgT\nrzX/AQ5Jq3LIs2pIB8ICvV2A1bQON+B6yToCIQCkulpEMU7GnDj+r9Bd+wQumaZ7\nKaAFH8uiacCnHamJaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfGBdKX4z7FNY1eLli4arAfZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODJlMDlkMC1lNTVkLTQwN2EtOGNlMy0xNjRhYjExMjM2YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnt/9MAcQfdtdHCYscmf6SQfkWuHm+R94dWpc4hS0PP3m7\nJ12fUmPYZiKdrA5yMvAAtZOxxhj2TXv3oeIRTeLCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrIriS2CmRe66kpJ5pY4uWzqQ\nMbYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVkP9i6YtPLXBuynNS0lkM14G9GEQTcZ9xhBR6Yr6QpYCIQCFBzEDaDQe\nyjhb9kVV483yVUJSgT7223TEzUamu97dIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAeDooE+EH6e/smD7K6SjqSKLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU2YTUwMTAtYjQxMy00MDY4LThmOTYtMWNlYjZlOWQ1MGIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVjOGM3N2E0\nLTliNmYtNDJiNS1iYjNjLTBkMzNiZGUxN2QwYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDE2n4FbA9XajcsEPVJy+kJPeKrD72hOOKCbAMRNWCtGx8BQYjhD92vP\nhWTROHaiXDMObtKNO4rkP4+h3u/mKTmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKTqr2/X\nP/sSujEwy3kTKbfJQGNYMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgI5zpYM5ByJTxx4NGdiqp2zv7njkEWurLtbzFo9Uv6w4CIHc/SmzyTzblCld3\nk3jBUPU24GGFCf2zwX9s3TPdRjxW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5248", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5248` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAV32mzR4jWA5/A/g5iK1GR4ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiYWRlMDM0LTM2NzAtNDVlOC1hNDZkLTQ3NmJkMDIyMTI2OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U5MjY2MjctMDAx\nZS00MTNlLTkyMjktODc1MzM4NzBmOTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEONTL0g7YieuqPLs14hfeVOlC4tHAEKD9MSgJMRAXbL8DjXyJvcOrCIEqIasW\nWDxQxUCPkmxi7FwUK4/YDH35aqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJrb9P5hUm8c9jrWSAlJmsRE5JYMwHwYDVR0j\nBBgwFoAUEA0dfmNDXIq6GRY6hKu/eSeZ9A8wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEF4i80T\n6OfOy/JEdsgII9HP8lL85ygbzCkhDa+ZhK0lAiAfVE5qAA4QV3O46PC00VYy9GUW\nZj/Kz4NB2Bcy02VMWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYQ2dNSfQoeDpHFdrvcYTjY9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmFkZTAzNC0zNjcwLTQ1ZTgtYTQ2ZC00NzZiZDAyMjEyNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJFTwoiSntvbStGhw8dTrg0TbPvaQLEMYeTMKtHYN7EvRy\nnTZzHDgLFAfDnEmDIAV1hPEQ2kEpAyzBQnmVaU6ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEA0dfmNDXIq6GRY6hKu/eSeZ\n9A8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTn9WDLFkH/V9ETj5lgyg9Gm1Sr1YQultRd7fP90syncCIH4UWzszGokY\nEEbArSPy+ckL8sltiSIOqXxfHWwj1hZF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAZyIL9BzHzS2bmklSbcbkxtcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U5MjY2MjctMDAxZS00MTNlLTkyMjktODc1MzM4NzBmOTg1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE0NjQ4NTU2\nLTk4N2YtNDIyZi1hN2MzLWEyNDgxNTdkZmUzZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHtdiMM0bTX7ZD1ws5f8+yoljNVMts1VQmeuRepzXFLdaWcGA/ZR4r4m\nvy1udok1XmmgMxGV0dtOWhughgNw/sOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCa2/T+Y\nVJvHPY61kgJSZrEROSWDMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgblXsyfhaxHSp9KbsS6tJkqNG9fpEcxd+DkQqXj62wj4CIQCfA+2kxqnPcSUR\nP+XWib31hx4GXJnK8Scb4WyisM043g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5249", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5249` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAe8HRSlEziCnUjZs5piJIqh2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3Mjg2YTQxLWY1MTktNDc2MS1iZTg4LTNhYzY3OWM1NzVkYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVhMmYzMDgtOWMx\nNy00MzBhLWFhNWMtOTU4YTZhOTIzMTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6x2p7DXKgAzutyWOcrVaByoAA230ebx7c+z7mZFniPx/X8jnRV9Hy0vCweao\nLLgC4CwZ3YDOXE6FLlfyNI3MZKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfhlbGyDNj9dQ1uGxXHpSkpCOcBMwHwYDVR0j\nBBgwFoAUev/TAvaFs8P5kWQXtSqmCpQrT+kwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIEJAHgYcJB1Hxv8VDTQOrJatVgdRrv/0MLzRASsD+SKuAiATavgkADMk\nStfXbuPFBq8NoAlKiCRWqcGe6iJQtUz7UA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZUMspjGIR4Hhckq8NVWGgPGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzI4NmE0MS1mNTE5LTQ3NjEtYmU4OC0zYWM2NzljNTc1ZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlFt8LNJ/NRhya5CvkSk48eaeQcU14fjjZQDMByqLPud8J\n/GLb14H91k2TAMELynGl0mv/7+Ie38PiWQUnq6cKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUev/TAvaFs8P5kWQXtSqmCpQr\nT+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVshex8jgIFKX14VzDpcoalZOW1R0Q0ii8wKm3L2AW0QCIGiprZ8/HEos\nsHI6GYnmVVZZhWFCOrRbkUxP7WxsiM0a\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAQh3K8GbuDvqHn64mQDUmYVkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVhMmYzMDgtOWMxNy00MzBhLWFhNWMtOTU4YTZhOTIzMTk2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZkNDk0YTM5\nLWNiYjEtNDEyMi05ZTQ0LTg0NDUzMzRhOTBkYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCvivo5G6/atRWyNGwn4xKpVB3MUwj+Wekud9sTxXsZx0VDgDDv7Wc+/\n9+plh0UdIkuDfGWt3U14MBELZ18zNgCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH4ZWxsg\nzY/XUNbhsVx6UpKQjnATMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAI/oEZsmKl0CHizQ6GjBfrbzJU+GJTMxLz4Czz5xYanfAiEAqcUW41YaYEPh\nVisSoKKlDsxkd8+L/LNh9nnjWP8L6Hs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5250", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5250` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAaeGz9nIxCRLmV00GiT6Cr5eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4YzZiNDRmLTZlZjMtNDJiMC04Mjk3LTExMGQ2NWMwZDA2NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI3MzhmY2MtM2Jm\nYi00NmRlLTllYjYtMjA0OGE4MzcxYWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeP8J9zuilYgpor3+QjR2xfN6GZg8gVIkhazkRM7FhmLhIkWbf6lZ+xZTrEde\ncRcmeRhhD3SAieEK+v9rVRP8paOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwcSwj0nhZj4wMaiXg74Uob5/K/0wHwYDVR0j\nBBgwFoAU7oiCwIcPcmFoKeBvNaNLGVS9xOwwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQC8tvvx/KMzVFFjxnssAMuw+E8Jz1BySPqEZ/qCOsiUkwIhAIa3Q2mV\n5Lw4RPszzBb5CNmd/RJmGJaah3yyEUprFMhG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdtAWbNlIpH3oDUWsUB4XOK5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOGM2YjQ0Zi02ZWYzLTQyYjAtODI5Ny0xMTBkNjVjMGQwNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQd/CLD/k/iCIOeg10iy6yOLYBDIVrApUrpSKF5f+0Ut6cm\n1PJa1Rla0Sa73o4FV6Uq4NgHHpMDS5073trK1O3Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7oiCwIcPcmFoKeBvNaNLGVS9\nxOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAKA7efigaZu4s+23WlcIFI86kI9be5l24UdVkyyGa10IAh9SPp8uLafN\n1Dtt2ytzKpEPWYlHy2c6bu+JSQI287lw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAfGqY/xsQNGU/d1HKm+E2LyLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI3MzhmY2MtM2JmYi00NmRlLTllYjYtMjA0OGE4MzcxYWU0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdlOTJhYWY3\nLTMzOWMtNGQxZi1hYWU1LWU4ZmVjNGU5ZWJkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLVWmLLjKLsz/Ke+kqPIU5AbnxA+PJYokFuaOOWm6UTOeYXMozOyMyGU\nCeL0DGYQzGhsGdcGNKnJaONvcoOuVemjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMHEsI9J\n4WY+MDGol4O+FKG+fyv9MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhALqrfUdlC05fy4HYEfSQD5iY0M0yWl0+S4VjaEs1bbPpAiEAyT2CwOPQV/Wf\n4o22v2kiJJMuf9CrhE8VyoFluLZVGPE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5251", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5251` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAQPxvAkdJgta4nYKdqjyXcEJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2OTQwMDJlLWIyMmUtNDczZS1iMTBkLTM1ZDBiN2E0ODYyMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I4NWE3NDAtZDRm\nMC00YTYxLWI2NWYtMjhhNThjOTUyMTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx0VL5wj8QrglmvWpyl1ZPmG/WddJbgiN6/3XsuaJlqpk/OKsVQ/rQJYZ9j/K\nwkD2z73zEGXtxH3JFJEBbdBICKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlJhIR89TWtrkeItz9IMvVuGK4WswHwYDVR0j\nBBgwFoAU4iyzjDCNGJ3bElfTRLVI5mEBSH8wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIHGn5YyaOt/6n8ZBPDYuCN6fPL5WTtmmhcblvvu/YCtXAiEAiIg3FV0Qo7E8nBpL\neUf/EGeFwOhuGtFnYVkXAvEpLlM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa2aN2I66SBbIerZGBVqngtZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjk0MDAyZS1iMjJlLTQ3M2UtYjEwZC0zNWQwYjdhNDg2MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoCLUYHODCtfVikQfrAHIheFxGqpwrMttQbID/s4TDNhzz\nu4WWurbFgXHLrwcSNpqU+Bltv8PlcKbZbzqLZtUro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4iyzjDCNGJ3bElfTRLVI5mEB\nSH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKNXCo5eh/VlzIAwCzBBaObLl+9wTApZApkmPAqyit0mAiBSgHBKc8Dx\nBCDwCrc/eqd75izxb1MB3YQwypSGnM1d2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAXNjQtKX5N99dFhpGWbI+HtZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I4NWE3NDAtZDRmMC00YTYxLWI2NWYtMjhhNThjOTUyMTM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcwNGY4NTIw\nLTI4YzgtNDJhMy1iN2RlLTFmOGQ3NGUzNWI0ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFYuRKkROEVq176sz2qywife8VfHV1teM+w0lGcEpC3ys6NbyLLXOa+c\nYUFNTVZvIFFdjM+KrWkitLFZI/hfUC2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJSYSEfP\nU1ra5HiLc/SDL1bhiuFrMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhALHih41Z/6oW9C7V+TqRRpzjqudjjvYEV6qYRvCEOCeNAiEA8p15eEw0lUES\nArUWlSZi1hDXHKJ6f8F/SXeo09Mplc4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5252", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5252` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISATp7khp1qdl3QeheYmEjNx6nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MmYyZDk3LWM2YTQtNDM5YS1hOGYzLTliMDdiYjA4OTUyYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhmZmIxODktZTFk\nNy00N2QyLWEwMTItZjZmZjM4Njc3NDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbavucf/5NzBAsxk/dAUQTP6j2neRXGuujvNNYqN7hTZ5n+DTq5JxzeGVmfgQ\ncY7A2/EhyN9Ey2HAZ6VDeqDKN6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw/RlAFKOfiIsf80wZdATVgcQOG4wHwYDVR0j\nBBgwFoAUH/iBfwjoVHT6zvcC9TwiYHOyxu0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDd9ij3t9vq36tg8EFx5V5eLqK3+1DMvssGe/e4RAUtVwIh\nAMk4SVf74JetYgcgq0HISaHbkieMNzIQ4GMwgw2mAiFW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYF9bV4+J+vRz1ftHUkGua0XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTJmMmQ5Ny1jNmE0LTQzOWEtYThmMy05YjA3YmIwODk1MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRymgUqjBtzHnE2FC40TMWwXHtWuVqhvvzz6wZgZZE9ZlT\nJezBX01SYNW2kS+IAQoJenLwUIUBDoD09p16US/Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH/iBfwjoVHT6zvcC9TwiYHOy\nxu0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKuh8O/rvHlS3xBz7vOU/huZnrriiv5rXPrzoQ7g6ZQtAiEA1zUcBT7j\ndwlMjdBi4uxzkp42ZzdXtoOF4KdWb+D+2m0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAYdt39WMZVH4TwA/qx6iE5MUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhmZmIxODktZTFkNy00N2QyLWEwMTItZjZmZjM4Njc3NDc3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE3NTYwMmVh\nLTM1NmMtNDViNi1iZjRjLWYzMWMzM2RhOTg4MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMP3/L16WrSUmB1HnLazKhkYPVi7O71+htO17GdrXPaX7qiN1WZ1pUml\nSTM3msQOkPLRBTVecvpTWY3vcruu01ejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMP0ZQBS\njn4iLH/NMGXQE1YHEDhuMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgSplZnustDSFSC1bQF96c2mM2+tQpkOtNNRYj4jeqm90CIQDnPgk6oZSVSAuQ\nsAJpxlODGsgd0Cuuf4GwEfo76MAoVQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5253", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5253` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAaDNVRzDpR4O0ioqkLCV1q3bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwMzQwNDgyLWMwMWUtNGE0MS1iMjMyLTEwZDA5MzZjMWY1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWE5ZWQ0MDUtODY5\nNi00Mzg2LWFlNGYtODZiMTQwNjQ4YTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ/pRZjcYKINC/wWSFM+UKI8Bm8YKR6o9arKWmi2HBvbRu87kGy+xn+mF/JA7\nPBnG70Jv0bErWA5qjjDb5iJY7aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpcNkJPhkxRBqWdDJ05dmf6dTWL0wHwYDVR0j\nBBgwFoAUti40/BSLd8NuuPrWE5lGVrwEJHswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIG8c+Ud9FPtYH64/07uZoIV80kqvn843BzlJ7/AJU7NkAiBI\nBVJd5oRIZMOMS0zDea//RSTw1mBY6Hc27hPvXIKzXA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAflqFwouhPZZIOY+aC8mzAU1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDM0MDQ4Mi1jMDFlLTRhNDEtYjIzMi0xMGQwOTM2YzFmNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARs3cbRR+0sg9ahTaF1whW7lhiKggzhLaFKWw0NcA/C84YA\nEKx3kOBjwvakaIX/j+nM0YnbpaxV9eEnKDl7kPbio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUti40/BSLd8NuuPrWE5lGVrwE\nJHswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPa4orsRzWmF8fK969a/y5QPOiQ8qNeSKxRMj1zWr9+4CICCJjx6n1/GV\nLwIISiAezjO15CflTDekvPOtMmsL1ocT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISASEI0Kj32B7Oip5vb59Qg/CXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWE5ZWQ0MDUtODY5Ni00Mzg2LWFlNGYtODZiMTQwNjQ4YTAzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUzYTYyODkw\nLWRhYmYtNDJmNC1iNGQwLWRmZDJmZTlkMDUzZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFI6U0mEMJoQiFwgGT8MZ+7I29EyJ6R0RCytrpNwrt+O/+RiYRTfWwfD\nzu+X5ZrZlUPtsEs8BPsSkxnPgcxIgvWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKXDZCT4\nZMUQalnQydOXZn+nU1i9MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgFzsxStTkp0Gpw0zaqlkv8pGZNAgtQK0SPykaIUiLI/oCIQDaGODsvFo/TUag\nCbgfbDeREmYFpGxhTMmOLQDM6+vWzw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5254", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5254` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZirv7fSdkJzooGE+Q6+9MqJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzOWFmZjExLWIzZGYtNDRlNC1iMTMzLWQyZDM5Y2YzZmU0NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFhNmY0NjEtODEz\nMy00NmI0LThjYzYtMTNlMDRlOTBkNmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk9asEqu7VpF+88My/EvISwQSCPOdkGUx+Lo2jFjcd4n4lKa8OVl4ZFxlnluT\nTYWTPUwj7j1+WjsHGbHRCVXbRaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpQaOwcY+BcYyddQMxL4G4P3ip2gwHwYDVR0j\nBBgwFoAUrovnK2cyYjtIB23IfEqGYvAmsFIwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAHjWd27M3Re\n0KgSiQC+T147FS8/eMgOGJv8mps9jNuMAiEAuelfzZvL3vj9cGl+wMPgxNtDfnl/\nbnOH+KiP4y+AWXs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXP2cbQCTJDpyrtILaJFo/eUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzlhZmYxMS1iM2RmLTQ0ZTQtYjEzMy1kMmQzOWNmM2ZlNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOB2zNIDWNdogtHFozTlfbRgGZ33cy93OjjhRP7D9qQU0u\noRwDn+BrNhKnXnTCfOFx6hm4KZCmi06JrFgo+tTEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrovnK2cyYjtIB23IfEqGYvAm\nsFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMRT7M/IEbocGQ/yAr4TqDpTICgAr/o+Jh1LmVAxbT0CAiAhsFYUfKbz\ni25LK1SLtWjX/Tnae6NrCIFV+EpczE1sbQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAT4JUPmr2AeL8FJVAzQPvRPEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFhNmY0NjEtODEzMy00NmI0LThjYzYtMTNlMDRlOTBkNmViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE0MTM2ZWRi\nLTNjNmItNGFjYy1iYWY2LWY3N2VkNGIyYWY4NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC/0t1L105U44vVNzOrJqU0XhZKjOym0YuqTA1668Sjo/qCLFcEgiCjA\nwKfuzpfEZ11yQB0KlQ98ACztXxo6q1mjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKUGjsHG\nPgXGMnXUDMS+BuD94qdoMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgDs9jxk1ngUY03W7zjULaBzji8sg81GDtQ9q12lzzdcYCIQCcHh3Lbn2d4BNO\nlG5k7z/qJ0bZVgmYUxLUoSgjV0o1tw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5255", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5255` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAYMZuJlFV8cpslCkpYl1FNwhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjYTI1M2JjLWMyODAtNDE3Zi05ZWU0LTZlMWQxOGNjNDAwNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjgzMWZjYmUtYjhi\nOS00NmFlLWE0MDEtZDk1OWY2OTk0MDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi0KYQTYcOBdZqa3HfTD4dmQMfDpNR87Zm8TTZLh/ZVHWkbCxFovmI1XzqgG4\naZTUWyYm4mkBKlFr68bEqwXwHKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU85X2qFGor59C5QhxOUkNgB1uK/owHwYDVR0j\nBBgwFoAUqlUkaD9T5cnlMwYl0TPoRS9f8WAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANyC46+DrSJHbgSG7sSm/0xSuhhe0D9BMVcaifsCai+3AiEAlFJntsIH\n4aQ2mLr+Ox+BJr27t0AGdSLQnj4r9Vn8nhI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ15ZJihWZNAHqecyXZWYNZnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2EyNTNiYy1jMjgwLTQxN2YtOWVlNC02ZTFkMThjYzQwMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzFXJ6xaWvzGD4z3uIGSsolxR7FXOZKEESUV5eUx/1w8Um\n5KBcugL/cYOwiLVNoorCY5LSfgtUQ0lyAZLyc4sYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqlUkaD9T5cnlMwYl0TPoRS9f\n8WAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX8JokFywOSEF1XIoPCqc7OYuyJHhaqsTaeGOeuRP+TMCIQC4u0Qx5Y5d\nvKEcdfifjkyBnHw8051CKLTzC0T1Yixx3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAZq1jXtCp0jgfB0xSHUgCi9vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjgzMWZjYmUtYjhiOS00NmFlLWE0MDEtZDk1OWY2OTk0MDk3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNhMmQwNTE0\nLWRlMDMtNDQ4Ny1hNGNjLTI1ZjI0OGE1ZTMyMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFvi8rAB9qFybWTBvZurixdP+CDpushqTUVqiWt15FjEXNuSQ6loemOD\nH+U6B6ANQIl8TNNzbq8EfwlxbBCSiDqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPOV9qhR\nqK+fQuUIcTlJDYAdbiv6MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAITw7G0AagRZr0aokYGQ4Mfz0G9nY3uazdwJixGtNXXAAiEApTMHXnBD549x\nsSGaot/de+qpWF/bbEKBLVI+2VfVKGU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5256", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5256` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAeQf+aOeHjhLXOLmVSaE+CZoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZWYzOTMyLTJmN2QtNGNiNC1iZjA3LWI1MDVmMTc5OGQ2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdlMWVmZWEtYWMx\nMi00MjkxLWE0NDUtMzkyY2FmYzllZTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELWnpUumMlkWaboPsI6F6k7b2g224dnsH95B9oJlP/adfkoPFOxg/WiZcr4dt\nae3GcxF3UhE58NuSuFxkyHOp+aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZytAA28INTp5q4qG50mw6Jt4CaIwHwYDVR0j\nBBgwFoAUrH6Iyeyfnh0Njcqu07YaUdGDYNMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAMYFk5fl79jjhLZjELwfUXWJmUFIJtkqdzFnrtMlCnIyAiEA3DH9hh2e\nY+S9vnzDdndi2iy8MsEt+ox7JFo++q0L7mU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWl5sBktIPvTnQ6vXplHlnodMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWVmMzkzMi0yZjdkLTRjYjQtYmYwNy1iNTA1ZjE3OThkNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhVu/bMCuGzg9Ouj98X3WgMPlINDwjdDIc40bGpSAJKbDa\nXWgD1HtLATR9bqIiotNM1t9Gca5CZ78KiTE+Hcxso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrH6Iyeyfnh0Njcqu07YaUdGD\nYNMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANY8lCZH4FoWr/lIbrRd31PuMByFk3HFzkCqQD55q+kpAiB0bh7go1Un\n9QaMYa9cc0kwy7VxyjoT4obyAJI6Ur654A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAQVBNJRFv/NgA0rKGt027FFDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdlMWVmZWEtYWMxMi00MjkxLWE0NDUtMzkyY2FmYzllZTc2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk2YjU3NzY1\nLWRkZjYtNDUxYi05MWM5LWE3MTUyNGEwMjFiZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLFrU1Rrc7gRAoHZCsitO5q5N6bzwXtI3VdG7cBjRAmno+FSUa7QS4Mj\nzoumXdkuQ/E9lnikrRhstnIm/BvEyJOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGcrQANv\nCDU6eauKhudJsOibeAmiMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgcqyESySGaP3+YZQulXJsj1Wo11Ltk1o1Tx4mP1N5/7YCICgCm1mTzp4iz5kd\n0amuqY5e4RBKoYQ5C56qPeFn/STS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5257", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5257` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAUw+Fnc1Btw5/ufmcCFSxmocMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNTg4M2E2LTk5MjUtNDA1OC1iOTVmLTZjYzkyM2ZlYjVmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY5YjI5MzctYTFl\nMS00MzgxLTllZTYtZjQ5OGMzOTdlZTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOYHP4g/yJ0Uv9Wy0Nyjkmoj1B+DTJZYK+dCg4VV4XdeE8NFwVrL4qGtD83ts\nwtjukqfijvOTR7PeJ5FFyHNeh6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU01jd4KEn/jysB4MhNItCYr1dFgcwHwYDVR0j\nBBgwFoAUx068aP8yNhrwTNu5u8gIgNrS/nYwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCICAZyYGS1/rgG88xaV/ZQIDkD558BtoX6FBS+F2ZEW52AiAK78c8dXni\niAQuFRzJMlC5mNSMvAq29rwcjU+XJUBSfg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVZPVArjBUVf8RTawJTurKcBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTU4ODNhNi05OTI1LTQwNTgtYjk1Zi02Y2M5MjNmZWI1ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtizfI0rztF1zgAKXq8e6GS6fOgRb/OfYxhtLaxfM3cadv\nuuid5ZxhMQCLloOIvJEh99TNsvHQRel3Y4k9fqMPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx068aP8yNhrwTNu5u8gIgNrS\n/nYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW19r3eZDF7IjY7VS6YJL7XLg8djEbjMFqiAeU7ec2vYCIHqDk5q7wZRO\nr0yzhVMJ0VKvSOUKxEx3kkWXe5uXf/qX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAejImwDD+fzTqHgXToaXaPN3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY5YjI5MzctYTFlMS00MzgxLTllZTYtZjQ5OGMzOTdlZTJmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVlNWRhYjg2\nLTQyYWQtNGVkOC1iOGNjLTBlN2FlYmUxZDBiYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBUw0szS64Qako4vE/3FYSyu8xzvxYUs0+FE3o+g6X7t4JF8EupRpgUn\ntOvbmoPFnFNAeDn4qwFzCkTFU614djqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNNY3eCh\nJ/48rAeDITSLQmK9XRYHMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAIg9PapXvbd0/OT6+uqFs5I2Yb/2/AWg982eHlJC5dxbAiEAptJviEBnRHo8\nPdGOxjhU1qHHtH+eOa4+sgaLokZWaHM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5258", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5258` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAWhFXL2MGY8N0lks8c96NCcCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMzZmNTI1LThiMzktNDZmYy1iMWJmLTljMTU3ZmExZjk5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY0MWVhMDUtMzFl\nOC00ZjJhLWI1MGQtZmQ2OTUwOGY0OGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVKc21h5//uGAFbluZEzE4DR4wyAEVvVmJXAyg/Plt74dYG1cCKaN1JjeQF+X\nDdkU96eesqtGh+6sZjzprix0qaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS2iMMTKYQK5i/V+pqD7Is8u/Le4wHwYDVR0j\nBBgwFoAUoPBHH5pyj0ZTrbDoES6Ju2ym2YEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC3BSoK91vKUAMzVfs2NtU0GJ9LLrI+qw9e36IA\n9w6OIQIgKUfHwiCSKqCqmuy4WLDAVVv1gbsLB+xLOKJ7YRIN31Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATctswtP7tYpqhex+rhZl4SSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzM2ZjUyNS04YjM5LTQ2ZmMtYjFiZi05YzE1N2ZhMWY5OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATz0+yBH0Iq1XRFSmkMs3m3sFav+x7VEHrdJlGuU0FVTswe\nOVHT+QIl52AS6sBmkRDu197v8TjUCNYh2B2XpPgLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoPBHH5pyj0ZTrbDoES6Ju2ym\n2YEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJG92yjZQPuzrZ0EgFZMI/KBImYzcpoQhWYHULHStXUvAiEA9dqXfDkq\nmsQ/VNymTDKR+iPVck1K5768DnA8dbdF468=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAV+ZI84gSR8u4ZDc4Vlx/E+iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY0MWVhMDUtMzFlOC00ZjJhLWI1MGQtZmQ2OTUwOGY0OGYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUwNGFjZDgx\nLWY0NzktNDU5Zi04MjVjLTBkMzliZWEwNWMxYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH+OpgPe7nzhnvOElJs7PZlKXDV6ooEMSpUCJQp6DzaAoO0sy1rFQPbm\nxdtatDGjYxomZnq5F1Z68hFB7NHW2bOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEtojDEy\nmECuYv1fqag+yLPLvy3uMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJvnyQznLAat8zES/0TcgRnPyriepa2rlkR1HB/DJ875AiAJMcAQLKjuClGf\nOiSqSlLpFSM7qrPsN/Fm7ALY8evEzA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5259", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5259` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAWVOzjkpi2OgOnEO1pWGFGIMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZmUzNDJmLTZjMWYtNDg5YS1hNzNkLWE1ZjQ4NzAzODJlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRlMzAzOTYtZTBj\nZC00OTQ3LWJlYWYtY2RmNjU0Mjg0YzhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1NAMoruIMiQo8aoIFmj1KOYou5nfOAewqyfVoSJitcrt57utRJzbAFyoA0WU\nBi0Qzy33Hoeu4kKE6zE58YeU36OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC3f+Kr4i4gdk8VwgjHbZsWfr1M4wHwYDVR0j\nBBgwFoAU+pGhdT6lyUhUO8pNXgtHTHmQe7IwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC3dKJ5diCcky+1x8fYAIzrQeXUx8OQHE8NMcpe\nBFm71gIhAIVMbD9aoabibgyo7f+xmLqmZtWP/FMFC6YX0pv4+HJt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfPf/0VVJxGep/J9fzeUTkdnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmZlMzQyZi02YzFmLTQ4OWEtYTczZC1hNWY0ODcwMzgyZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJEOGHxfCsTJp1WITTiBOwRYjO2aT8RMzIJ6stto9EgWUY\nEoRWkSN9MyaUR3VCkuLiuZws2vc2PaU8+UEPAav9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+pGhdT6lyUhUO8pNXgtHTHmQ\ne7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcil0cVj1QvPzvYf2qI6bmb5k/A1q3l1902/u/8oDp90CIETD+eAju7P/\nlgBfrJdaTny46UIhqHSwnj6x97CILM0k\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAZXd979uQ4lqViRXgHZwfBjmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRlMzAzOTYtZTBjZC00OTQ3LWJlYWYtY2RmNjU0Mjg0YzhkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdkMWU4Yzcx\nLTA2ODMtNDljMC1hY2NkLWJiZDE1NjBkZmIxNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBICyrPWp9FH57B1JB8Nw8ucB4YclFojmxTjq+ZSiP8DiSbi1SYEZPSm\nZaIEjflbvyw4v0pc+Df5gSYjWaiPRkajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAt3/iq+\nIuIHZPFcIIx22bFn69TOMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgaGCJAvpV2xtJv5L5EE3ec/Bgsg0Nk2xGC0yPJpjLqmUCIQCycEIkJpk8uk9A\n6HxcFklk0TCAR52n8t5fGpWrw4WaoA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5260", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5260` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAQTeK5qTpeEFNjzxTe04uP3/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NTRjZmNhLTQ3YTMtNDQ4MC1hZjk2LWUwMTViNGUyNDk3OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBhZmY0YzktOTc4\nZS00ODQxLThiOTQtZGE5YWQwYWExODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+HJoXQuWDX3fYKvXwyAewTqDhTMBorq7BNua/bUr1QEFIZOHIFxrTe476B3S\nYbjpFlywhN2vBWYkkeFHbwNq16OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI01icp8zFmSHBCintNxYxqCeVxswHwYDVR0j\nBBgwFoAU4zvbCZvGaSMdvr8iHvBheqmqK7owPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIBdP3Cf6vKhxH1PpS+DGHi9VCVIZtNpM4iI704DpFSZlAiBr\nvuzz2/GBnwm5gynPH8iZN2yaukwfj7H1drWs3GA0/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS8e/Euh4UbYwgXDbY2CIoVXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzU0Y2ZjYS00N2EzLTQ0ODAtYWY5Ni1lMDE1YjRlMjQ5NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASM8st60xSafgEBBr46i95/hQNxs7a12bEYzoCkly44D/Sp\nsUR4PIKGl6nW1vuDghS2CNABhjVeMyJBB0cyX3F9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4zvbCZvGaSMdvr8iHvBheqmq\nK7owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANwFgCQGh7DiKLbqOtgp3w/HhIgdjd1bvT6TeASqpeJSAiAL5MKatui+\neYcLtwCPho9fnQt65oJ+Nr0/V0+4B94yBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAWNoPEuVNax9Y6zW1TpSSX1RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBhZmY0YzktOTc4ZS00ODQxLThiOTQtZGE5YWQwYWExODI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRlYjdjNzk2\nLTMzZWUtNGJlOS1iNzY2LTllY2JlZjk4NDQ0ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIVyfm/weGpFYt0HcFoe52cyqdfVjpZXkTSQhO7oTl1mWkDiDl6uC+ME\nI4m0JlY6nlQPTJacJzoKwBvEEuEVn46jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCNNYnKf\nMxZkhwQop7TcWMagnlcbMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgUkp9bsDLDIU/NxmtCBRNHBWrimMIAt44jQhixmfRhQoCIGM7Ekc8lJVYaeL9\nyboMpoiKKm8SWF7aeXTaBmUKNvKz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5261", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5261` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAVgq92YbGbK8l1uU+ZkItEHXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4MjY3MzkzLWM2ZmYtNDJhOS05OWJmLTQ3MzJhN2FiODRjMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZmMDhmNmItYzM4\nZS00OWUyLWJkNTUtZDI1NGY0ZjA5MDMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErSKBZsxTR4WK7FY43QxdkboBNQH0g9D8EA7UC4zWTtXWc3g4zZnIyAULD3KQ\naGq2IlGGNL974tqYzJjCV2D2WaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtglwvufOogzLRlL/Yo+3DUUU+i0wHwYDVR0j\nBBgwFoAUjsdDL3aaHnHoxOwk0GNn3IsP5PAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC/3lT+woWiXAncccTWd+npEEt4TaRv\nLC6Nxz5jgg+IAAIhAPZsCEs4zmaHE80ynWGWH27vU0h9/wy6aA1GZmA+J2kR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdGKiUGpPFw3S/TtMd7TmANwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODI2NzM5My1jNmZmLTQyYTktOTliZi00NzMyYTdhYjg0YzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6FLk94drHEUpiw59jdiy+TIzbAUWO6dm6DDbJmk3aEWra\nHr6rQ9yNhMTAqtlEqY7s/FjbJy1CpRmDKh/bCE1io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjsdDL3aaHnHoxOwk0GNn3IsP\n5PAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKYrn2no9vL6U/VkHDx120+vJTvafYA4MPc2Hvj51ZWuAiEAu4UP/Qci\nJkoVB5TLtn8eM6PS1tGRxGzBI8sfqxynTMk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAXC5l1GKiPhok5CSZjD3jkS+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZmMDhmNmItYzM4ZS00OWUyLWJkNTUtZDI1NGY0ZjA5MDMyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFiOWY3OGVh\nLWI4YjQtNGMxZC1hNzBjLTRjYzNlNmU1ZWRiZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEwk8osvgegLW229wZwJJ6rtucF6r+CUtQr/xdfqNYkayZVXIgvP6ziM\n3LaxWedyM2Fq7W0KnMvv58R9YXXCdQyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLYJcL7n\nzqIMy0ZS/2KPtw1FFPotMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgZL03UEqSCJX0VFnrSkFVpARThpNRAbkoLpaN6RTXTZ8CIBB6QNvxAKYgiIsU\n3CuGQa8FCUS1Gl1LE9L/46MerKVA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5262", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5262` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVMT1AcdYkwMi2kkjVvs+eYsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwY2MwZTBiLWIwMzItNDRlMS05MWJlLWRkZDZhMjczZTUxZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk1ODdkODMtYzY3\nMC00OTkzLTkxYzgtYzI0NzcxOTUwNTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsH+vnvOvktawhgMfRjIdl09SmE0FaykxB8hJ5HfkSdaadi04EQsxEm1WqEkp\nA2JQAaL4uVc9nk9b0arBn6/6RaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHmsNTakaGikkVxF6iOGyyyK2k7UwHwYDVR0j\nBBgwFoAUCuDUjwprdYuy61/b+YKr2VsQMQIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBdnczqAxBELsP1i3StNTj8I9Djp2S6d\n9e6i3/dGTKz/AiEAjuMdrHPFdAZpiL20ga3wN37xtdHRnICXI6ezoxMSGew=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASeQkIFKPSDt3MrlEoda4CrKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGNjMGUwYi1iMDMyLTQ0ZTEtOTFiZS1kZGQ2YTI3M2U1MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2751Zp8DxzQArcPrSXfXp/q2ImSCmhHjmUFnGnAqZE1Z8\nxBjjsHJIyR6Zt5IvgdFCkhDaBvv9pt+2Bk4jkiuRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCuDUjwprdYuy61/b+YKr2VsQ\nMQIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKyuEyckwrMW6DX4/mWrO+UJgfcHV74e26FCmwNa9mOICIATAzHD+uP0P\n4PH/fOj+BRisfp7UMgGizXOONRiB3PHl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAZ9z2n4nqa/EQPLHcz/46zH0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk1ODdkODMtYzY3MC00OTkzLTkxYzgtYzI0NzcxOTUwNTY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJiYzAzZTVl\nLTNiZTQtNDQxZC1iN2EwLWExMGZlNTRkZWMyNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEk/vm8a/ScZMyuBJVN5bFPdpnEbpuMytmtqffAOdnb7wbc55QFkJDMC\nOupSzqmYOQmQk9Vn+zUqlLCESxp56UKjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB5rDU2p\nGhopJFcReojhsssitpO1MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhAIXs1fZDOsMq2H4Dph/ZJac1suNm2eGH3RKq5etCe4elAiAIBeN85AtjHcf7\nGJPaqsunhEzIwAaipSMBUInN1WRJKQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5263", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5263` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAeOfkxHuQsTcYDd/x42ZHSs5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhYzhmOWI5LWQ5ZTktNDg4YS05NGE2LTMwMTMyMTRhNDAzYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUxOTNiNGYtMTM5\nYi00MzQxLTliODYtMjU5NGE2YmIxZWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqjoT9YuPWNu2ruqXHLHaBhuEDadN4NA2wbFLzQjG69Fr/0bS1xEakYCH2oAB\n5JwuPzXrO5lQlLHLHxItjGtWsKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtOlG7G7vG9uFigWm9mbLjpMQ1xcwHwYDVR0j\nBBgwFoAUKWGSOMjA7ljjhT2o+O1209tWdIAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDK2SKYukm9\nmWhqlbJaNXbSzB8Tayu/PkCzx4+Dger+XAIgQ29d7/EmApwnplspxTrBv0zyzNQJ\niTHnObdPQ+RrEuQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdnwXivbcpNcPPap8okAtsykMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWM4ZjliOS1kOWU5LTQ4OGEtOTRhNi0zMDEzMjE0YTQwM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+DbBrweqO7ycozl05SM9LwqHR23KEpo3gAVVeVVns8PLr\ncT4sTw9+i3Eb8yRXCp0befvvFPx25snjxWcD1+Nno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKWGSOMjA7ljjhT2o+O1209tW\ndIAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW3eVietjrjAewTLJtRkwpoqtfhBVdbk3rWqJxJJEo8gCIF72H0zfZTph\n+nDlk/YBUxCJbqogs9yopKH64njXBwbk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAdw3/vsZ7q1Yt8MjlfzXddSvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUxOTNiNGYtMTM5Yi00MzQxLTliODYtMjU5NGE2YmIxZWE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU4Mjk0NDQ4\nLWQ4ZDItNDQ2MC1iMDk0LTU4MzFmNGU3MzA3MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLoNmjZ9WQQzqVDVkzFj/8zTZ1E9tbMb26pDullFtcmKkAD4hyu05/9E\nx7gWtZWnKy3IUcFIoPnjDyAKYh1Q55WjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLTpRuxu\n7xvbhYoFpvZmy46TENcXMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgZxRLkm1L9EId/p1VMfLTjyqyN3uaMnghLmR1Lp2ZHc8CIHpTXLRTp5SrHlgZ\n9ua/p5WmR6oIlttq4Voj8jUL9x63\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5264", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5264` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZdR65Tw7/B1WcEw5bRorqsiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhZGQxMDZiLTJhY2MtNGU1Ni1iNmE5LWUyZGM3ZjhiNzRiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzlmOTQ2MzEtMDU0\nYy00ODA0LTgyMzYtZDdkYTQ3NTk4YWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/gnz4GVjRSamG60LVha33+c6NlgZMgCiMnRvVEKub4+ZaEudNjn2VMJ6O1TI\ndbbAdzXWDFZC9Wh2P6eDj7Bnl6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Nbq24BOOgvJdkDiLK1szG4Min0wHwYDVR0j\nBBgwFoAUVDaiQA4wM7Jysj4j9O5++dL4EK0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgGnP8/GZopVoJKYlALQM4QVJqNGrQK3eXJ6yNG1bGwAMCIQDPX6a+Zclt\ntVl4EJgjYnt4ELhlZuP1xqQtYmKBuX1gUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYB82DlE7g+Mq29/wO/AH1e6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWRkMTA2Yi0yYWNjLTRlNTYtYjZhOS1lMmRjN2Y4Yjc0YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARavDfL3CCsQfDBEmdWdZV+Gs6lKLpPg0wxCxxEIJyjOjre\nICxqiucWfsLVuhqwxjiG26qW5jna9BhjKDWuOiFBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVDaiQA4wM7Jysj4j9O5++dL4\nEK0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANKHiiZwzWTGnLGmZRrYkTwfpdfDkRd0JB6lN9BedCSbAiEAp5L8rq8/\noeZk59GxxDWAoMBEvQE8GINpirMs9U9DfAw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAW5KdTDsyGe5N+C/9tAWd40HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzlmOTQ2MzEtMDU0Yy00ODA0LTgyMzYtZDdkYTQ3NTk4YWJmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIyNDY3NmI2\nLTNlOTItNGJlYi1hM2JkLTk1ZmNlOTAwMWQ4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBJvEUfeKJDLqyKSR06XND9LCJxQU05R1TtEezGYTyIfW4jLdDaZQNJQ\nQuswvOPk9kO4982KiOnlxbOMKdrOuA2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOzW6tuA\nTjoLyXZA4iytbMxuDIp9MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhALt5a5iTnoKTco3wX3xD56IBP8Qlb2gjnFXoGoJJnUiYAiASYGLdi5hkT37W\ne6Es41+oheho8KiMiw9Cwu4hpZds6g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5265", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5265` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISATFxu6gN0EbknF2K6EtiWBM5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzODBlYzM2LWQzYWUtNGNmMS04OWM1LWM3MWNkMWVmYzYxYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE0YTM2MWYtMzdi\nNi00OGRkLWE5ZDktODcwNjE4Mzc4MmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7gQbTmYJtJ8ttFgHcRLpTjAAuff8XL+47uWcZHkC1IjD26yQSKxTDiky4F9A\nJ17Uw7X0rTqXolfFxhz4C9GiCaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGEOVGbZBiC1UFrZQbiVVFxNvt1MwHwYDVR0j\nBBgwFoAUruC/wtsHtVC+eVbaB+iWBKgq+BowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgZxBjFL1rK25R286oqRdAXvjXS5hlt/Y8fPis96if7wQCIFRfLdVYIjA+\n7mhAY2oymWpDaxgbQSYzzFR70dK5edOF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARr0rceiZNZFblStmyLrUburMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzgwZWMzNi1kM2FlLTRjZjEtODljNS1jNzFjZDFlZmM2MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeU6kxCK+ic5Eopr9Q24gYhKoiIIyAqVDO3cBG6vxXGlOK\nwXvLI/+3JTrnUTlwgDFolpYX2HZKimFxRlPcRIzro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUruC/wtsHtVC+eVbaB+iWBKgq\n+BowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWGVATdPpP73+zkFDpUVRJOcTHH+6gz8Sqba2MsKqWqYCIF7o/f5F1dlx\nUOGW/bFPp5wnvtRh97pSnG5AFQC938Rn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAa2GKoaNEJHJND7IR+AiIuEfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE0YTM2MWYtMzdiNi00OGRkLWE5ZDktODcwNjE4Mzc4MmVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNhYTZjZWQz\nLWYwZjgtNGZlNC1iZGM5LTk5YzA2NGRjY2RjMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGzPEM0zpbHQnaeVF/5k7xw6LGZxU0OnIVY7D/KHTfkl/Y7R10+MOCPR\nFgCAor4q7O7F9YLbjJ3FJRdzd+bUBHKjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBhDlRm2\nQYgtVBa2UG4lVRcTb7dTMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSQAw\nRgIhAL7aTuI0g50Lclcb2xHA8m5evSvhbZMNQ2z5vYOq4SNKAiEAnnpE1i4/zm8W\nCjr+i9PlRl9gXvkWxcvkQN/PvS1Jqog=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5266", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5266` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISATveV4XKH66e8Bg8yf3JMIsQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkNTZhN2ZiLTIxN2ItNDA2NC04YWI3LTk2ZjQ5ZTUzY2E5MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNkNzk1YmMtNzIx\nNi00YmVkLWEzNTMtNjYwM2U1MDY0Yjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPdwh2SHl6mDMczZ9E4vhZT4JqkeDYstknyM7LkFFp273R3U24xXJRMYxXmup\noUJXk0qQkkaPh8UniQCwSPwwqqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9T5JSJw8glb+kP1HWgRzU/B6egAwHwYDVR0j\nBBgwFoAU7Hs1lLe6So6cJcrKaYovzmfFJEQwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQD+4eaWHocj9nTb8XS0tZmhwXmQ5q/m4W/0lbmLxHP34gIhAPa1mmNw\nuPafr6H7UgrOyqzLJ3A1HcyC9k//XGbKIa5F\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa63ht76/5bBn/2WFPWpyn1FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDU2YTdmYi0yMTdiLTQwNjQtOGFiNy05NmY0OWU1M2NhOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpxY3ay3MXeI/RlLJCwOzQMxowbepuUbes9nTxh3uJg5+h\nwJewEcG5fozCXnofJiBR0/SdrK6cRDkxLQZxVZmmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Hs1lLe6So6cJcrKaYovzmfF\nJEQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNexE4JHo1xvkqKXvYxRWzzzVSlwSEGv1nakmGiqyekACIQCtl2socrC4\nj6cUM9zCXKe49VxR8OBlyiP1IoFsNtdNDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAaPSyVCKBF1Z2/bGgt6k7Z9SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNkNzk1YmMtNzIxNi00YmVkLWEzNTMtNjYwM2U1MDY0Yjg5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI1Nzg4MGIx\nLWRlZjEtNDRjMi05N2Q5LWViM2Y4MGQ1OThiODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDt/TOu1pd2zd29dVMTvZ4rtODqfH4I1pYIfH2EnymR5/Ymj1UvlvdLr\nuvPEGYbi6y9dpWGhOmD+6ILKnaY8kDajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPU+SUic\nPIJW/pD9R1oEc1PwenoAMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgKqGzKRBSJRGJ6f3BtW8FAJOHvMHf95d2dD4KgwU2a/cCIQDAM2me4mN5wO9N\nDf6Wh2/IXau4Pu3n/7WHYmtSTt+XHw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5267", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5267` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAbpwEmDuFXhUWJYNHWVwUEFoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxMGM4NGZlLTE2NDQtNDNhNS1iOTgzLWQ0ODAwY2RjZWNjZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZhMDJkNjAtM2My\nMi00YWYxLThjNTgtNTk5Nzk2Njg0NmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgG/I8YHZ7jqmM01reZFDGjZsicVYjQwqxJpV4dtnfOlTR7W1PF40DDZV2U6l\nnJFo0TRsKxS2ezcCBpf0Rr2D2aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7gbRVaA9XvreIjtFRorH9WlbXiYwHwYDVR0j\nBBgwFoAULziCJjjTYNxfP6/ka4mCwXxvZIQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCb+P2decK9pDzB0ZeM/XqghmIvbWCNhtGPEAnx\nrqomnQIgTs/REcLQowRK7kwkIYjzN8A8/GNBDwWSE1xILcPmq2A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf+bUR8y6lW+aWfZ3PJT8/V3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTBjODRmZS0xNjQ0LTQzYTUtYjk4My1kNDgwMGNkY2VjY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI48kBzVAbmDurCMx8pZqK2qaDsjnYnzi4fuLhfHo0aK1g\nZnXNpyPsfXCt9PIjbHynvO9XAH39bohFkYF4pzoWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULziCJjjTYNxfP6/ka4mCwXxv\nZIQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJKF8w2zTIINO+oh93njblLm2x0IVa/OM3uLEupRNk1nAiAUh6LpUFK4\nqOBFj+MlzJxKpg054ehvdMmL0WBK0lNjnA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbigi569sqUowU0tx/e2F7tmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZhMDJkNjAtM2MyMi00YWYxLThjNTgtNTk5Nzk2Njg0NmQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY5Y2RmOTZk\nLWU3MzktNGI0Ny05NTMzLThhNmM3ODI0NmNmNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLyOgQnGRYotopP7fIGxN1FEnDmNZdDd7H5pcypexCS8FEqeLBOko3/G\nlSVplX5wZwpSJWB1e9AlALMI8NvPLWajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO4G0VWg\nPV763iI7RUaKx/VpW14mMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhALDWYdJFMqO57nr6zKhFMmd1mpsvkPZbL/nKscQq8j8QAiAzAbW0kDoJ3U35\nn/l0T3SGGefO24+4BOctT2w+XdjR8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5268", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5268` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAR7WkSItEoSOhyhci286aGFdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4NDY2N2U2LWVlZjQtNGJiZC05MjRjLTZmNTYxZWVlNzFlMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzIwNGQ4ZjgtYWFk\nMC00ZTE4LTgzZWUtYTc5ODlmMzk3ZDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyWrfiiJY08eeVjOa+sb9msTcBKYtVtMD7ZGmjRpiSyCu2nTBdInnm//pk6C1\nRHTh/2NCpsCVPYwkYJp2hnbXR6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfsQ64jT6jfIplqr+OHUrLA09rHcwHwYDVR0j\nBBgwFoAUpwKtI+c1xFOlf+RXhTWm1i9J8JAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC78vOp3g7rDkxXtOAzQEQaInuscS4eqpJxNzFe\n148DWAIgW4dr1lk5ZFjcGIliwjPdn7W+T9FU1SJqvkvuvTK6Tk0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc4Rt2AS7WSk61Hz+LX6/nDDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODQ2NjdlNi1lZWY0LTRiYmQtOTI0Yy02ZjU2MWVlZTcxZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASA0Bh4GVtmKBegZpm+AjvS6A96gJFFqxZmMCKI2Yo8i+F3\nKotxOl45K9mMJ6tkqVqoCcoU66eMsU9sPR9884q8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpwKtI+c1xFOlf+RXhTWm1i9J\n8JAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOc2z4FWK4kAMGMaZYhUHOouNmm/WQ6zVtdY21PTMvl+AiEArlveQwpF\ndznlWmFgTQma6nn8kQYiZQeku20VDsh8YxE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAaBfTH6FB3xd3Z3eCakcDDm+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzIwNGQ4ZjgtYWFkMC00ZTE4LTgzZWUtYTc5ODlmMzk3ZDdiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4MGVmNjdj\nLThkMjAtNDg2ZS05NTdkLTE0NGVjMzE0NGQyNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPVk6Bg8mfXP5pG1BqxjxuQRWI8IjbxkWnLOjKfB0JFuS3FTQ5EqVxN2\ng0rLH054rhMXWcoKbwK/2RKs5RyBGZOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH7EOuI0\n+o3yKZaq/jh1KywNPax3MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgexCUYz5T6B1/E9VFsGxi2ZDVn1ph049ig0n4yJZZ5XACIH724ltyD8QJySLp\nMbtZcxlNpoJ6hFL7eA/wh9nBXyGP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5269", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5269` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISATPdWyxN5+jq+j7yA5YwP5EDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjZmY5NWM5LTc4ZjUtNGE5MS1iMzZlLTRhMjU5NTFlYTRhMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVlNTY5ZjktYTE1\nMS00NzAyLTlhNjEtYTBhZTU3MDIzZWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM6ktrvOtL8+aBr+TNPo01lx9j5MnsLy8596md2Th86M2/v4OuhyCrsQHSctd\nTIILBDxTlzASwjAbrRwRmj5o26OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdEvEjuU323iLRxCmIptUEkr82MEwHwYDVR0j\nBBgwFoAU5a9J5dqJRsEMK34q0XlCnG/SCLowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCeDd8svDIzx6yODSCDM4u4mG6Pzra5uqZdCovxvYHtmAIh\nAI54MyAno3pxCjCUpi3DD/ZLdVPVSc2gAMMxDuC2vCjT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfgYaixzRckZLJvPatjV6hIVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2ZmOTVjOS03OGY1LTRhOTEtYjM2ZS00YTI1OTUxZWE0YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyKTY17ZuySyIRRa0vCpNKNJgvfyJXvDiV4HEHetuMBbGQ\nZim6k/rHGVQLG//MLAaA0qiN2QdfJnVkecfbFl13o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5a9J5dqJRsEMK34q0XlCnG/S\nCLowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPClCP4P1uRnSN1O8/N3Cz6TTuDEUf3xPFqKFNK4hirUAiEA5JR/mWGj\ndWhU+ik1bcJPFAf+TQvDN5A3rv6ERSlPCbs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAXrqmZ/RQZm0Mw6RniL7ehT0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVlNTY5ZjktYTE1MS00NzAyLTlhNjEtYTBhZTU3MDIzZWIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM3ZDQ4MDk5\nLTY5MmMtNDBmNS1hNjFiLTVmM2IwOGM2NjZlNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF+Tuyit/TuYWgrEOA1C4lXsq/LlJo4CyE7x4K4Yup/Eex+ToXkfqpac\nLyqVg6087DvR6TZw4IH7BvsCCHmQljijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHRLxI7l\nN9t4i0cQpiKbVBJK/NjBMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDRwAw\nRAIgeLHhl8SJosV5epJEMe1aKtc9oNBgcxqDuSEw/p75GwoCIDaN4jy4TA2w7RnE\nEm1efPGOl5joL8E+gN2plVhSyhUr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5270", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5270` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZhQyzGyWp2NseevEL5Jm+RzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5ZmM3MjUzLTVmYzctNDU1Ni05OGI2LWM4ZTdiZjdmN2M5NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNmMTJkN2QtMTk3\nOC00YzMwLTk3MGQtYzIwODFiMzIyOGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELidpa6OLQjiiE2kFm1CMifYSTmYOH9Ic20a/Nc5rrtKwbBZni/MV0u0ImGh0\nFvIYYdwYGG0cl2jj3uzbbKvr66OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9B21yipxaKJb9HN/mZ+eaoq3kNkwHwYDVR0j\nBBgwFoAU4T5HuId4ZVoxK7fHzido+QZutKcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCLEMCM6589lE79eaQj68BfrpDpzZqH\nr8e7tmfAQCzU8QIgIi/ttV7189tXPIhWhD3+wdUA4Kc9dMM4Q+TNgvHQiLo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQtsh5EbQmczx7kSJTQHApATMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWZjNzI1My01ZmM3LTQ1NTYtOThiNi1jOGU3YmY3ZjdjOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5xUQ+bVi+g/6VtExXTA1vnuRWiLvlvMBWfptB0QXWC6hm\n2KmmpkrM1H9VFX1+tdkxqcd5nFIEFnro+f/xzSGjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4T5HuId4ZVoxK7fHzido+QZu\ntKcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPezFVwOUY9C7TZHvbvrpvot204fk2f99oeuiGP/gJlcCIDdjzGZqZ/SN\nzOYZD4PYTWAFbj78MeotzkPLzk4Kw0WT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAZsSjrkzH03wl3q+prvRnWXKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNmMTJkN2QtMTk3OC00YzMwLTk3MGQtYzIwODFiMzIyOGEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBmMTk3OWVl\nLTBmYWUtNDEzMS05YjNiLTJlZDU1N2Q2NjFhNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBOXbm+7M91DA42srMOhPlFxC3WoE2Yy7ahmJkvN87o/5hKvuEZ3vwMO\nye41P5RrVxcJe6/jKZWdwOH+U4H7112jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPQdtcoq\ncWiiW/Rzf5mfnmqKt5DZMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIgI58TqSoBezHqZ84D7omm27cxt+1Ph4TIbSRxSkRDk/MCIQCnbBHbykKcNd1S\nvdphVVTd6+S/TNKYMBAIN4ev323kOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5271", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5271` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAdpiThmxXh2DJTAvvWNcWLvfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwMTYwY2IzLThkNWUtNDdmMi05M2UzLWNlODcwN2I0OWIwZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE4ZGY5ZmEtZDRl\nMy00ZDhiLWI5YmMtNDRjNDVhMTk0M2U3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIflZvSCkSAFACKmNKSF9zpcP0YTDd75C9Z+3cFrDKlqw9Ea/jazOcD6wSA+W\nMqP7OYQYORfLQnAUC/wmuFA5tKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNwK1FOj2AAlG4Yj/S5OymgkotrEwHwYDVR0j\nBBgwFoAU9ps4RL9mSwN36ngLcsZg1qJ0Br8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCKoKWopBdMUbm+mM03R/20lGQXeukh\n0FuCHRZ83oTBigIhAL+bAC9GIOgFIsg688JS+R6H3Ppp6V3XudyQyGypCxQR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXyKB6PUC3yavTCVo0eWrWycMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDE2MGNiMy04ZDVlLTQ3ZjItOTNlMy1jZTg3MDdiNDliMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcCgzp5S8sYiZyGbVIE8FlnOy9imdwlsnangxidgFnam4F\nGVjLzo5skhVhN23/1R9JuTBOc+nNB/30ZCu4fw0po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ps4RL9mSwN36ngLcsZg1qJ0\nBr8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIeum48XVsJCAqVnJDOj2nY9rur02VSyDepuAn4yeuKkCIQCUTONi7Vf6\nu31mww+eoKLIEGtNLed1WAEA9OciKdmwBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAaVdfTxiur/2nSIUxBKRl2Q5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE4ZGY5ZmEtZDRlMy00ZDhiLWI5YmMtNDRjNDVhMTk0M2U3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA5NGMxZDA1\nLWJlMmMtNGU4ZS1hODYxLWE3ZGM0NzA0MDc0MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDJ9cU7ArQ0UK7i+x8blt/RLGmbXT2jiE1mq2E7BAjNOfgMDEsmbxNSO\nqv69cskpgNl9UioVeEN4u76pYJmoSdejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDcCtRTo\n9gAJRuGI/0uTspoJKLaxMA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZIzj0EAwIDSAAw\nRQIhALnHyjEasHqcpU377zh2nsDJK6PoOQXU/EldcKg0ndwsAiA3AB4nyYBMS416\nwgwdzmHJXcuEGoHGMwA93j447A8eBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5272", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5272` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWcY88BLu2SPlT6dRdwIjjTdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2NGE1Y2Y1LTQwNTktNDRmZS04YjZhLWNhYzUzNTM3OTE2YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE1OGUyMmEtZDRl\nNC00NTM3LWFhZDgtODYwMjM0ZGJjMzQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqrYV1C7qj9li8bJWJ30N8QQ3CA+svYPBBCt8f40UCUWoZhfzhhuXfvFB0v6A\n7cdq/6+QEjVHwJ/p2uutiv8wzaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNqMcLxGVOsfqJpxs6ylT6/5RjBDMB8GA1UdIwQY\nMBaAFDDFLIoP4IxKP28aT8ujhfwLe6B+MAoGCCqGSM49BAMCA0gAMEUCIG+y28Yg\noX1wdQqZA/qYDvzvBfm+SRI4TgEeudOuWTdUAiEA6jswLLh3s6es8MJe6hqvI/qK\nf5OAH4N+efB+ZE8ql50=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXtNsXwwYY8mhBxG8+rOCw2pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjRhNWNmNS00MDU5LTQ0ZmUtOGI2YS1jYWM1MzUzNzkxNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMDSRgQE2Kg46qysnBhDx/Sk4evnGjtAMrGTsoNTpfmlPn\nzNXGE5CZZw2thh64WIuALReX2y9rdiMSNhdu0n4Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMMUsig/gjEo/bxpPy6OF/At7\noH4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJz/qZrQzPLCOtGY8pOeihllBMHHdJvBxYLtZWHCcbPUAiEAmBnJADdC\n6VmAvO0n+sBVf8EBtB3syyNmrWKJoF9QvhI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAd2zkner9u7TO6tRJrcVVrA/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE1OGUyMmEtZDRlNC00NTM3LWFhZDgtODYwMjM0ZGJjMzQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNjODljZTVi\nLTE5NmItNDM4Ni05ZTJjLWQ5NTYwNjBhMThkZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPaLEYO3D52mSD0PBWOhN46/UjMFKigAoNsvk3eMBXsbgF1aO3j9ETty\ngR4EoisGv6nClEKYnRQcZLUpP1G+eIyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNqMcLxG\nVOsfqJpxs6ylT6/5RjBDMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgXmW4RWx/+LJS4cp3Omiz643n5m1Ch3LfLrsobr5szO8CIF55VTnnEIdTGYRx\nl/QjHMK7JI/AD9HijnjY5pvNBaUC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5273", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5273` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATS0zJngzgo31Ksyhi72HlNFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1MjhlMWYyLWUzNjktNDQzMC04MWJkLTNiZmQ4YmM4MGUzYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM0NDIwZGQtOTE1\nOC00MWM3LWJkM2MtMzA2MjUwZWFmZDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENuJTH58Fk842lWwMPHNz+qWrXbKUmU2W2d5HVgdvBcp3eD2Gm0dvmpNzq/aa\nnidwhjECvqaq/9gJBZVdBpksWqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLsfS7wLfYV7zT27W0uRc7rAYjPqMB8GA1UdIwQY\nMBaAFJeqeoNbgEjYHaLC0NR6UGy57paFMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBJc1B7ilfM/a8Bu+mW7UTrDxaiLpf5GLp6\nuKw8hQ8jCAIhAKxy3+LVyzvBV6WUFf7golB4D+FM9OJNy2Gz/BswPoUq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARRoJ3QzSrsaCyypq2YfLaVPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTI4ZTFmMi1lMzY5LTQ0MzAtODFiZC0zYmZkOGJjODBlM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaED+v40fw/+Kyq1DbDAdQftzUQmzUOYj1KdOh6yIXk7cq\nFekn6iDSUHzYemz8LGnXZFETRe8ozCMRVRqh6nASo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl6p6g1uASNgdosLQ1HpQbLnu\nloUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPb15VLTmU6DTHzFz3WOLewfaFqQtd4fbe/UZ4cKM+EQCIAdpp9pgR6OK\nY5InaIlgJ60w+hcjz0a7aAy1ttW4YyzE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAU+wUKw7g4E6wftDGyN0ZIIPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM0NDIwZGQtOTE1OC00MWM3LWJkM2MtMzA2MjUwZWFmZDhjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJiMzc0ODNl\nLTRkY2MtNDM2Yi05OTNlLWNiNjMyNWI5YzQzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLeaLzlm8yJhcBaVK7cyXr9QrindINegmZLEtgoTqZs1TVLl8V2i4iOo\nxW/R8jGwWYIgVO3KgI3rLRllDLcsjw6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLsfS7wL\nfYV7zT27W0uRc7rAYjPqMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhANyk0KqqfYZh7NitYVYj8PtNXNPNki3me00+1UNqa3lNAiAZxIm3YDWW5BA9\noCvEWU2aOIFZJ1tV5nPYlkJOI1Fbcg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5274", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5274` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaO6CXUhUdB5p8z+cw9iq/CxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyZmVkYjYyLTJkZDQtNGU2Yy04YjM2LTFhNjM2ZGE0ZTM1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM4MTUzMzktZTk3\nYS00Y2NlLTg3ZWMtMmM0YzU2MzBmNDI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGthZwTwPSARJdVnODYWGtVRxzSGZ1USv91Ddv5KIr62LTxqEh1+SpFLRU3xo\nW5xVdk//3lRG5dDUGdshAQ80t6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEgEC5ORWVfSl5hXr2TAp0wJwwUHMB8GA1UdIwQY\nMBaAFMC7+ady/a2lPbYaHuHpOhoFJ0H2MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAzi12Ms4WbzWHOhRGd6WGxqimzO20yQ+hf\nLkI9R9JOPAIhAJHIT/IOrgRbi0h9UnTI0Bee/abCAyrSICePLQ8RPbnq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfoMwzWoiQvZNdLcUoWK4eOEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmZlZGI2Mi0yZGQ0LTRlNmMtOGIzNi0xYTYzNmRhNGUzNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT06ZIMn69D0nxPJ1cSlVxTsQgAqey+4x8/WJyQek+7eaK2\n1tRmf1fzlWquRJAB8SzwRkdVU8i8G2E5YQugz5pzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwLv5p3L9raU9thoe4ek6GgUn\nQfYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYO9HvZqyEE2DB1svu2HttedGeagcIAo54N0KoBCxwPoCIQCS2ur8gnfZ\ndkKQUmAcbhzfPwSI28CCC9qwYsgg/XQJnA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAdr3VtBqSNO9qwiNLPqpv/wQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM4MTUzMzktZTk3YS00Y2NlLTg3ZWMtMmM0YzU2MzBmNDI1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNlMzhjMTUx\nLTNmNjctNGE3Mi05YzZlLTE0YTMyZDFjMDY4NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCD2hOzBSPpDzCIHMmO7mo8ilHWKXhJD6cwR9THi1yjlWiHity5bTqyr\nSNQPMaQYmmsfQEcdnSzhC+4CU5sOeqejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEgEC5OR\nWVfSl5hXr2TAp0wJwwUHMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJZ/8ibcqNJO4PSU+ybm3Bvk/qLH4K62zwbzve+VZS/XAiEAtQ+2UwyaYRI7\nAdudP03Pxx1wYnUj7hD3A0xig00yw6I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5275", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5275` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATUqL1myiyuPPGBYJd9KpwjUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjY2NhMmViLWMwMGItNGQ4OC04OGUwLTFmYjMyZDY4NmYwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVhOTBmZjUtMmVl\nYS00YzliLTg0ZTktZmNmMWE4OGNlNTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERTxEGpfNsY39jBUMhkuSjdaPX36ZaN4dMxJEA1pz7XI/amt1Hwv+rfsWPg/p\nkvKd0IjPM1VRx2RSjYSbNMBJIKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTvWxPs/hEO6R+xhhz7snBPH22XvDAfBgNVHSME\nGDAWgBRz7DX/y9ESk2O19ckSb2bU5jgn8TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFiTgQ/rjp60uCHDKJ5/GeUyIcoUIljX\n28mBcyuPmrtwAiEA/gkAhieTKTXN/13vreLwpCLMI6/Mhw/xD1LnQeGfsn8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAda8du7QV+f3LBtL1HwyAzGnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2NjYTJlYi1jMDBiLTRkODgtODhlMC0xZmIzMmQ2ODZmMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2zTLiWnMyV5fvmCmW64MgIWXAx+28vW0wcx2rxDmcXYfd\nT0RMZhbkXO2EPdbCWrQKSZ6u/Q64YBfMybAU60kyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc+w1/8vREpNjtfXJEm9m1OY4\nJ/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALdwZTidIJKGznMWkYVw6wXiA/tVNI/HHAV9PgnbpahwAiEAjKZJc82X\nD9AHNYPMJwai/e5VY7DEO9O3l08I6AdJgXE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAeoiPSbx9wS/aBC8QdGUf2K4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVhOTBmZjUtMmVlYS00YzliLTg0ZTktZmNmMWE4OGNlNTE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ3OTEyZGYx\nLTIzOTUtNDY3MS05ZDRlLTY3ZGUzMDQ4MDgxYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKisyz09GVf7ymENpha1db9wb22WHanlEyoZj+dIJZEhKyW+tYMRuhkH\nBhwZjSrWg49ZsLmNtrh/qGl09+cRwcajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO9bE+z+\nEQ7pH7GGHPuycE8fbZe8MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJV6dynn0RUlSUnzTZB4HCRgVXl0IzsSSLNLRSJAqHaZAiEAxGshU+SxkDCG\nM0KZuSnvgkuC92ZnP1PNOKqZSE/JwwQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5276", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5276` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAdIGZGI0qoSegJCgZW+Rj/cvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhNDFjYjVlLWRhNTYtNDNiOS1hOTI5LWY3ZDI0ZThiNmEyNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDVkZTIzMGItOGI5\nNS00Nzg0LThjZTgtMWJhZjIwNjllYjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkpC8t7+bbOnR6XTnEmTsJrFO+t+TqpfUGF0eDgAE/qZIxa3PvgZ+x5AiODKS\nq/d56KVyJeRm4ruAZOQOEcfVr6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6GRI6+ZBcLTDb4HxsCud1mw3ZlAwHwYDVR0j\nBBgwFoAUa+Av9SXWdXHKd/YGQLXfejcJPK4wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBnv+73VfnpZ1cD\nqdMop6qYmIXrVnp65sWA6vr/56kYiQIhAIKRiYGLNyk9M6iCaNqvTQpCdKEESpTw\nKbUSWstBk/Ji\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXHdrHo0RoQYpxTTFU3dJpwRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTQxY2I1ZS1kYTU2LTQzYjktYTkyOS1mN2QyNGU4YjZhMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzDyNkhFIuKvuTQpCnWWcCAJiRTZzejCcvQIX2Xnp3nQEJ\nij03pkzjk//iVrYEeSmZ1GYSX+IyzEC0lE9zFroko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa+Av9SXWdXHKd/YGQLXfejcJ\nPK4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIganmo/VKudcpQl3I2PJZUd5J1lFJI4HJ4amTh9FqgUmwCIQCHutagUA4r\nt+AN5gsSD7GSu/e1dtoq+Bnx/W7TXl1OvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAcAWDapLNWPOLkS0D+lKnS4aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDVkZTIzMGItOGI5NS00Nzg0LThjZTgtMWJhZjIwNjllYjAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc2MTQ0YTdi\nLTA2NjEtNDBmZC04MGU2LTIyNzdjNWE3YTk1MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCwTSmqtmWI+JdkbXWaq3mriUa8gdnBDihaM6daUzZVn/di7OSvvSjby\nvM8hNPkUfBBhvuXcjrU8ptADTZIvUrOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOhkSOvm\nQXC0w2+B8bArndZsN2ZQMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJ2la7s/uyX7bA8PpN7znM37if6IN+WpLN6sZK5VqLkfAiEAlKuwF3XrHHo/\nu7FHGqm7DysGGE6hCv1it3X/yPDU2Tc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5277", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5277` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAYXIyNnkSvZyCBCo2SHaTrENMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0M2MyMzI1LWM3NzgtNDY2OS1hZmM5LWY2N2FiNmQ3NDU1NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FkMmFlZmYtMzM2\nYS00MDg4LTk1NTUtNjc0Y2NhYmMxZTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvDDBCoiEXycLgZISwXDwdc1JqcDh+krdDPPI8GnyqhqTUM4s7NjsxegVSYFr\n8aoJaJ4lC0aMwtw7x/ZYCRmWOqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA/HAqlegyI3edvaMChtQtWf2+hkwHwYDVR0j\nBBgwFoAUqMgn9HJ2AH/qOIKsncKCWp4ySoQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAz19LCBkLZTXw\nwa56o3uq3T9SILofNbT6xuykg8rH+XMCIQChcP/i3leBDZAQzA1Bj5L+l0/3weB4\nsnLg5BIJLILayQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAboPraOscekpooFShbIFZDqVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDNjMjMyNS1jNzc4LTQ2NjktYWZjOS1mNjdhYjZkNzQ1NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9HqA0V7qnBasD421fHVO1TPF1nU0Zut/XG9bN698PbIqu\n+tB91HZf3jhLYcSFu/T1fCACbWOSHUmQFXW+LiRUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqMgn9HJ2AH/qOIKsncKCWp4y\nSoQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMRCLHtKeS3O7G19Q1u1I21gaEM3/Gq+4Nk1W51WXeiXAiEAuC8MJyUm\naGwjQNwW9Hsgz5Dq0lwXOK+H3HP9KrY3dBw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAaI85bnL3peg2r3XK19Qral/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FkMmFlZmYtMzM2YS00MDg4LTk1NTUtNjc0Y2NhYmMxZTA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU1NDZmMDlh\nLTRmOGItNGU3OS04ODAyLTEyNDQ5OGFmYWE4YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNcMeGdVNy7xF4N7zkANdn+y3qXuPbi+GgZopGvcXkAPe/ocDSNZOX5B\nZ/E1r9sI0fngQzIjamnSCZatULW9VmGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAPxwKpX\noMiN3nb2jAobULVn9voZMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgQAWKUVKV2xtTmbNJP7mNDX94lWMCTGKrN1jHPkY/FwYCIErRi4pNVSUJI6jK\nrCNyTjLGEJdlbVcHNNkmo6xkn+m/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5278", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5278` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAbqOgb5+ySEXYmjVK/Kn2q+nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzNDE2Njc3LWQ4ZGUtNGM2YS04OWI2LWRlMzNmYTQwNzg2NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgxOWQ0ODgtMmRm\nZS00ZTVmLWJmMDEtZmY0ZjUzZjY3NzdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEnueczLuoUHMKRP3mHqA3uqsYuRNra8poQ2s5EuIZN8YoU1xZAad4pKG/lK1\nqe1DRIQVfxmq7zUfIGL2Qi+zKaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5pXgLV7bbsPt0++/Cdl5KLWUrHowHwYDVR0j\nBBgwFoAUAZbwa10Q9e+kn9q/ttr0Cn3LwQAwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAmrVLJGxtY7+Wk5GMHHOt\nCK2pi3NtTt9yJa36nxTiKcsCIBgeWx7PRfgmmp2Yq+CpGZGeoKszSAde6GMLmbZQ\n4WtB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAajr4wpCCVbTwMXgns+5QQE+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzQxNjY3Ny1kOGRlLTRjNmEtODliNi1kZTMzZmE0MDc4NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgy0QyXK7fuyoK7vE1K26l8uT3pL10BQE18RpmiH6ZXtx0\nXw0+1MXlq0+biohrFPDLcCIDzT/xN6LWkDsWJsMFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAZbwa10Q9e+kn9q/ttr0Cn3L\nwQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANYKGIzk/KsG1pR2Ktp3RQi4hhc6axLqFujYnvByS/PzAiB3OPyIzvSc\niwFD3VSMl3k6TD0IWOrB7UIC8FADQSD+Hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISARAz8O4yhKehpun3KmCyD46YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgxOWQ0ODgtMmRmZS00ZTVmLWJmMDEtZmY0ZjUzZjY3NzdkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhYmE4NzU1\nLTE4MDgtNDgyMC1hYWUzLTlmNTRiMjdmM2YzNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH+a7+w5qew/zQO5wMHjZhZZ8CVZa754azPGugXwpp/h3Q2TJAYDUGOx\n4Gz9gmobfM9oDNUowuuwLqdhnPg7IsijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOaV4C1e\n227D7dPvvwnZeSi1lKx6MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhANzKjTRuLKzvQKQqqbQs/9chauwocmm3CDe6mmisv0ydAiEA0byJg5uOWqCb\nCtKEIQpdpYTn2ZfV+E6wGO0rri7ty/4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5279", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5279` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISARutyAM1Ahnc6YolKyRuH10hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiNmI4OTYxLWIxZTEtNDI2OS05OGUyLWMxZGUzMDdhZjRmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjgxYTc5YjQtNTY5\nZS00Njk4LWJjMDYtYjJlNTY4MzMyZjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM0SO1cq/+EttzpOa4zh4RHBJ+FAGfwm7JUCWJ92e7JhudaJSy+qUR3t/zG39\nKYmMgsYc9gxoVDH9mmvQvyoJyqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4zJX2le2QtLBnGhbGQ+dqmqvt+kwHwYDVR0j\nBBgwFoAUPE4A3DFVSO68VmshZGaL6IwZTfQwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAlpDK\nt4eBC8mL7NMiiksbWFpoZZ0i6gM33FHiSn/D7AICIQCEtFcc9r8j7jiyJQ3GKzRu\nGfcR2UkFqHukdJbUcx3u4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcHrgpWHnkdGDFp4VtU53xmUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjZiODk2MS1iMWUxLTQyNjktOThlMi1jMWRlMzA3YWY0ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmOmGfRAoAEbEDKm9WEcz9IidZ1BUCLtWExwjVrgJ9ZuJq\nK28a2MRtn7KBmm4eNwy2UtXFexxTO4NkvjkT4RO0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPE4A3DFVSO68VmshZGaL6IwZ\nTfQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI+TbqlbrQo3+pMoxHU3Vre4pW5RQXH2pc4okcmqz9a3AiAgef5EcsFE\npuk5PJ/1ZGHCZEVYXCEP4RDk+eavV9tv9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAenujWLwZ0GkSBLdf4uP3WMjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjgxYTc5YjQtNTY5ZS00Njk4LWJjMDYtYjJlNTY4MzMyZjFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhOTUxYTBk\nLWVlZWMtNDIyMC04NTRiLWYyZTc3ODcxM2Y3ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB4aV4C2fhDVzBRo6fywhbDMROW9PvTeza7Fd5Zp8S2rbrukLrZb3kla\n6hOO/RtymWulVCTlJzlptTMaX+hq33KjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOMyV9pX\ntkLSwZxoWxkPnapqr7fpMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJT3kDw2IV48fK4fUU8R162E01tD1PMC3qitKF8CNql2AiEAgQrlWFBiIQiU\n1d6mcvm1cvV1jcn0Vzw8WNhl9kb5JFw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5280", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5280` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAT1EhbFzFov2TKtqz6f1zUSvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MzBmYjAyLTY2MWMtNDQzYy05NWQ2LWU5YThmMDg1OGUxNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDczNmU1NjYtNjNj\nNC00ZTcxLWE5OWYtODMwMTQ0OTViZWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETebToM+g7YoeIB2QAzI7V1GCcSPTTWH4ZkYoCRunHZRNwQI7+4kejQdwPDSW\n/movBq17CAD7BPHPUc4qv85olKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeJvl0wcA1muY1yqxBi6rlt4yfEswHwYDVR0j\nBBgwFoAU0gmom31E8iyr4L9xMjpOVpSfQrUwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB3O4Br\ngohGhBk1T3ogJC10En986963zOqyiGu5rQzLfgIhAOT2QVF1d67hH4mpSOp+Rn1s\nki5f/PVVOMqBCyJ1NGz+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVhnJRcLERQh5v33SrM4RhnIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzMwZmIwMi02NjFjLTQ0M2MtOTVkNi1lOWE4ZjA4NThlMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvFGekZ6MSEeUK9istFXSWeSxo9iCWVDobQweZCaUxNE98\nW/tE9U6fpQxgGlDICQl1aM/TYrUzIUmWxPkgf6kIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0gmom31E8iyr4L9xMjpOVpSf\nQrUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMyrtaQmDIzf7F3jUl9GZjCd11U/SAEwEdeJ5cV0cJH5AiEApFrFPKXW\nisj60lgSoaZDN0S36IzWTwbV+TDUUTz/TMM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAQrJLsBKFKFtbDGku2+5sv0EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDczNmU1NjYtNjNjNC00ZTcxLWE5OWYtODMwMTQ0OTViZWIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkYTM1ZTk0\nLTAyNWItNGRkNi1iYTMxLWJjMDM3MjE5NjRiOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFd1il7RsbTtPU72voc5HWO2Aiu+FbrzIcwPDX8bGQ/AzC2D96FLsVbT\nv35RC7rV7Z+EE0MVaV5GD4U5bMSXr7KjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHib5dMH\nANZrmNcqsQYuq5beMnxLMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgLU+tqMkUTY6F7aJ+gNllYpCdI30DZME0MEhK9Agxt1YCIQDlYcjixMgKCG2c\np53YQTfWPzqAway5ZywbCJcbO9yiew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5281", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5281` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAWcQckbqyUN9uR2gmp+CE9pgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MTZjN2U4LWE1ODMtNDRiYS1hNzY0LTZmNjg5MWRlMjMzMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUwZGE4YWEtNWY5\nNy00NDk2LTkyMTItMzY5ZDQ0ZjY0ZWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGLD4Z89Qn++LXmhOLn7MB4kQt8kk1ioJYUtePtiIaXGmCpSO5eEhJybdBTDq\nTqtMUbP6nLF/u8F4UWlcA44u0qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPPnoJ8kn78bM56s0z00468aQHp9MB8GA1UdIwQY\nMBaAFDw1ZlBytCKMnjlvY7j1AZ4dbGtdMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAg78PTaaS8SUr3PwRtfKdqJrcKAGvSq9d\neBoflOsB7tsCIQCEXd7sf6GQWmrY8CfxWcZVRGx4QMZY+YBSKNttUhAocA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR+Jxp4WU/8XE5ZAqqWnaEyiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODE2YzdlOC1hNTgzLTQ0YmEtYTc2NC02ZjY4OTFkZTIzMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARh04HVKybyJs2hDfNfmlkmntPzaAgCj0+72awkPYoDq6i4\nK5iH+qTHqFH2Us31Y/45kH9/ClomXJtKkx7N66UFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPDVmUHK0IoyeOW9juPUBnh1s\na10wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALx7/C5dPzAfqvWmFWCYllkzv7Hr2K7hPIH4TLwLy4waAiEAv02j613N\nAiIQUVSWByYQ09aUtHSVULPieWmFMCPvzUI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAY5NQ+amMVO/9k7qoZrYe1myMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUwZGE4YWEtNWY5Ny00NDk2LTkyMTItMzY5ZDQ0ZjY0ZWE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVhMGU1MDMz\nLTZiYTEtNDI3OS1iZDU2LTBkZjY4NWEyYzBkMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ03i8Vba8zq/BGHB756RAJu0XdBUxY+qQNVQ83eK6E0FyaJNxouNqNn\nzW6ftWBjN1v0vvi+eRgFWxf05NM0qNyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPPnoJ8k\nn78bM56s0z00468aQHp9MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAI0CFbFzuSuiopQ24sdjFWsu5h0MHA8I5VxQZAZSWAFtAiBQtSRYsY3n8Ews\nLjK9/9CF8ZqA8pgXml81yTFtLtkYPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5282", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5282` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAVYIaZEYAZMQ1wESaYoMAu4kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiZmYwMGU2LTAxYzMtNDNjZS1iYzFkLWYwZmRhNDZlMWY4NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM2NmZlYWMtYjcy\nYy00MWU1LThlNzgtYmRjOGZiOTZjNDc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpZNJaZrAu17LCCmyRscdro8QuDM14O4c0eV/iZWNHEQMyvvpJ/h1JdZzbZgT\nyYHWwbI6wzrr0U4eP6S2WVRFIqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIuwTg3e8rlGG+VOvqpWk9Ms6VscwHwYDVR0j\nBBgwFoAUVSCfwvQjhJE2D1Zc74Wd4HbwNiwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIzQwYSM7ZjV\nH6rudwxq81xkPufn8E/kgpSk4QWX6ReNAiEAtdpLqbA1yp3q8nkF6pBFRt5zSHaa\nFNwXX+2axIrrUf8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVSH4AbIekxp3HWN+wtsnsvXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmZmMDBlNi0wMWMzLTQzY2UtYmMxZC1mMGZkYTQ2ZTFmODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEPnqLWybnYTN3W7xLRar4MW7Z/hI/wzFKSkVZXMJkGqFt\n1JmNVUW5J/eil5wzDk9w48gJtvxiYNDctJBx2yqVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVSCfwvQjhJE2D1Zc74Wd4Hbw\nNiwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYp3kypBnTjXGPLA2GMLZbtlpr4EHRynhoFmgJPa1BsUCIQCoX/vqm0ak\nJVaGYNQKUdHk+2DlPMCrrSk2A9Wd3ZeeiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAZzAZ3tqlxN4RlCNi0IMUz90MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM2NmZlYWMtYjcyYy00MWU1LThlNzgtYmRjOGZiOTZjNDc4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIxNTZhM2Y4\nLTA1OTYtNDdhMy1hYTA5LWIwNTcyZmYzMWUyNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIp/o71djdjUM3mdBm4fd8jSsoQ/f7b874wIylHXQJOp8WTXMSHpAwxp\nqHfY0KT1a4Gof9XQMzq/8JenIujxtiWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCLsE4N3\nvK5RhvlTr6qVpPTLOlbHMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgYrBBgs9v2FBodBR6FZ5e1tEaRS+pRIV9GOA1uLnBMPoCIQD9FirAl4tpJYxR\nqJET67ksyuLupNxDJu4f9YJTu5g1CA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5283", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5283` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAXEwNYYznbkPRbBB8XYUYcVcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjOGE3NTVmLTFjNTgtNDNiMy04MzI4LTllOGZlYmMxMjllNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQyMTc0YWEtZGZj\nOS00MTJmLThkMTQtMTg5MTkxOWI5ZWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj0BoKas/K0QRU98x6w+zxAJJPyV7KfKf3oPliOjCB0a3+PLgdGVLDfr1XEfM\nbiZMfbRVR1V/wfXsXWC9raGTd6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaHtg9/IIxYo472dhbC10NyjvLCQwHwYDVR0j\nBBgwFoAUT8HJXFPaGuDWXmGxRGlwGl0I0HQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANtPg1LOxKKu\nerRDC0PRMPHSm1QvfIt+TWJkSRCJkwTDAiEAy1pGXQ94Y78XS0lFImpT8nEGgRWX\nYyoXslQ7VPgsvKI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARLZs/9CWiHGGxPWhlSZLHa5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzhhNzU1Zi0xYzU4LTQzYjMtODMyOC05ZThmZWJjMTI5ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJ906zmsCi+jjcg85i3cvlPJKmgYMAZRO/KFykUWQvUoMb\nLZir+T4ct987SgSVr2bObyQ2oN74nUgWVVA46Uffo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT8HJXFPaGuDWXmGxRGlwGl0I\n0HQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbETCMNmpkL3Z+px1qttejuieS7DBApSx0oFF43mZG/ACIQDTY01GHFqM\nDyzGgZpg/wEhV+Qm1oNxuRm1/If8+oZJNQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAZovZXKmsdKFEw1+k6T/KDTXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQyMTc0YWEtZGZjOS00MTJmLThkMTQtMTg5MTkxOWI5ZWNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZmZmQyNTU3\nLTk5ZmEtNDE3Ni1iMGE1LTkyMDlhZTk4MDgxMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE/3kWy/TPg6701YZY4BUPdXni7XQOfcJ4FcRUYC0LrTrH0d6uzZU0s0\nhLa7QW4TnwXhD2luP6oUc5Hz+Id8rOCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGh7YPfy\nCMWKOO9nYWwtdDco7ywkMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgV96pLKzc4ujJgJ/Vi9FLMuPrOPKGxw5kHxC1jFX6uyICIEcsXg9NQqhlsI/M\nD2uu4c/zHbAAGd9bv2MPu3sVPCqN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5284", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5284` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcojMDrrENcgZH9gKyMjz/TdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiYzRlYmM4LWQxNmItNDhiYS1iMDZkLTE0MjliNjc0NDE1NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE0OTE2MmYtMTE0\nOC00YTM1LWFmYjQtMDMyN2U3MDJmY2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBXSHpgo8E/wCzxbH1m2rLLc4E+SjVHdguHzek4I2Y5nI6+zGQ2dXGgSLKP7F\n/NkAol4gENF43KUu304Mgv1oXqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrOK4uYEsCCw9scbHiDVq3O4G7SswHwYDVR0j\nBBgwFoAUMfhbyrFAJkk/LgFAmrtMYKV0nnYwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDF1EhNcCVU\nkKWf2DCUb5Q/skg1Y8diGwXpEQ8gNhys/gIhAKuyowhHYDJlMoINYAsNomlH019T\nB8p18TQEw2J8q0CR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaYphGwg+Cdnb/eHBcxbk+KcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmM0ZWJjOC1kMTZiLTQ4YmEtYjA2ZC0xNDI5YjY3NDQxNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmqkUFHsn5Z2KVO1GGFSz3Sn815rdNiB2h/GqlyktrejfV\nYXaOYJDihndg+lyd057ywB3MMZL64HK0p2+ZYFXWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMfhbyrFAJkk/LgFAmrtMYKV0\nnnYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJuGpyqQNafAjxqO8X3/VGx27pOOaAi4Qx6iNY2lvHbyAiEAzuoYiFGj\neIyKhqO/jD0q+x3gxYtRwA34Et/uoJWbmWs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAQ02Ta9r2IWDD4LaqvbAe426MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE0OTE2MmYtMTE0OC00YTM1LWFmYjQtMDMyN2U3MDJmY2NiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBiZmZlNzYw\nLWNkYmMtNDc3MS1iNDVkLTFjYzE3OGNhNDg1YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAC5BlWKIkW+fkjWAuxqElGbzL1G/pkwYjNt/p6iFdQBD+LEx5wfYGvI\n6sUd1CfTOZQrpO9BPSI2BUTgD9Z9+gejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKziuLmB\nLAgsPbHGx4g1atzuBu0rMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhALvw82sNnT3zaIkaDlg3izZAZbDP4ZcIFsm3IE3gsB8tAiEA5OGbLsm0CdNF\ngoOD1S09mliyqfQXUEG/1HK7f2Gq2ak=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5285", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5285` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdSMGcJNqZvKjrRO1eFQXlCqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MWQzNWZjLTJhZWEtNDJlYy1iZWRhLWJhZjE5NDkzNGE2MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI0NDlmZDctNzJk\nMi00ZTc2LThmNTMtYmI4Mjk4NDhmMTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnsBrqhktQ/t+FueCoplbzKoSchUa/p/u7ftWEsQX9hzCsZajmmXsePNmTnw/\nt6mKZd2+dpa6hrjDpF2sNn7azKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiiDxZzTr2a9sAj/xwl0mxRkUi0swHwYDVR0j\nBBgwFoAUQh8MxUp+UK+hRta2b5HKH8hy36YwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDqP9CUsFiHgwJxknga9zhZ2hH1UU3KLMGQ2RAIesc/FwIhAPcw4rmmD8BZ\nFn6wBLUBa7wbkInh7vWp3xE6w5ALXp/C\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcLww4BHgOqdE51QIbWrK/jYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTFkMzVmYy0yYWVhLTQyZWMtYmVkYS1iYWYxOTQ5MzRhNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0cNnhRePIL9dsnCplkX8UhjgiBXo/NbxPwreN/f3g+tj2\nbMsGWr+7lMH9Xs2pzeS4xH3CW8Q+uApoIhfbZdNwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQh8MxUp+UK+hRta2b5HKH8hy\n36YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUpaaGwNgANERNdJMuTYoNNf/7VB+NwPOjc2p85C1VBcCIBtnpDlbY7uM\nicEZqEqo3WkAnfuKHWk/yD37Z+W7O/zX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAeNK2mVj9O6lJYUdRL02bUi9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI0NDlmZDctNzJkMi00ZTc2LThmNTMtYmI4Mjk4NDhmMTNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc0ZjQ3NDk3\nLTA5ZjMtNGE2NS1hYmUyLThjNjYxYWY5ZmYxOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAiVGXxZ/oc4VS9LOJQ9f48R66fKZVRccPJItoEgKFMoaEko/kFDkEwj\nGs0qnomSh0ntnLy8RbCKKBSSpFHs7DyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIog8Wc0\n69mvbAI/8cJdJsUZFItLMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhANywUi8cyIwL4kwe9NN/krrVFi3gas6SJN+BMAUUpvn6AiEAt3jbRPwm7Xfb\nbGDQb93NiSi0bMZgU+lMBAkgG726XSE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5286", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5286` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUzcilBEJxyWQbpnaxbwbPdNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlZTAzZWU5LTZkMzItNDQ1My1iNjMyLTQzNTk1ZWFjNTBiMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIyMjM0YTAtNWEw\nNC00ZTljLThkOGYtNzk2YjEwMzBlYTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH6VcXE622zwrwed1mIlKL9uSPTSyF1GZQW8oBmfkI6IYf+8nQ3V/Ezk11GN3\nTa2uelyl1fPFir2xLXqFdJqRUqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Sk2YT3eW72WaVpfTjhXniuoNpowHwYDVR0j\nBBgwFoAUyAEQUmPq9J1RXG4wehQwvJrzz2wwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICSVLy6Zy0HRW6aaGBkwpUfhW0KRwHwQC7RUU9qaORFiAiEA17Yz/7gGMpjX\nwI5o8dtA3U61HayGHj6s0nH5RIr7HXk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX0UDEHX8/tjTnHn2MEvDz81MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWUwM2VlOS02ZDMyLTQ0NTMtYjYzMi00MzU5NWVhYzUwYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMiPhmulr85qGP3QXnyfZyvE9Htozcsb/no4DxVkjTgw++\nxvqutyCHB5gUd42fEjiRYqZKcVTNPVWkp1pa2u2eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyAEQUmPq9J1RXG4wehQwvJrz\nz2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZYjyRY/pogNlcbNZtyMqFsaomtejsrbN3Gu7/p86nFwCIEQidgAc3wn2\nVaFdDeTWBaQPU3hyf7GJmmqhlp8qqIXH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAYNNwUKVwEN1useo9JWL9tRpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIyMjM0YTAtNWEwNC00ZTljLThkOGYtNzk2YjEwMzBlYTVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ2NWIyMzQz\nLTFhZmItNGM2Ni05NmZkLTU0OWFlMTRlMmE1MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHSDUQcGILcq/K6RBmBvjPmyea5pr3nadeMICPAPg+S+996KVUdRQZmr\nrhAgG0LdWU4dbvwLKZs0vusYs17Pn1qjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOkpNmE9\n3lu9lmlaX044V54rqDaaMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgVWkWkcbYsb3qj4jlMURtsL0fw9h+hGl/tUscUBvC9oACIQC6JWaWuklBzgcl\nHZ1wclT0E9p4SbEwMDPs7CsTbGpnPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5287", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5287` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAU0wEMUQsQLZgToxZL0FvK7sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNTFmZjgwLWM5OWEtNDdjOC05MDNkLTRhMWZiMTNkOWU5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmEzODUyM2ItODIx\nOS00NjUzLTk5NzMtYzVjZGUxODU0ZTJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEImEiaBQxQNaraIiXliNlJ2o+X8YVG0PZrHnhBa1gJ9lrFBkF1yceioDwR6z0\nF3HqLJDRM0i7BFdgVz0Vu0RQKKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNOwDWScUP10sglUoIn/TU4ZEi3UwHwYDVR0j\nBBgwFoAUt91vuomHG/6PduaMQYphH1fLbGkwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBsI\nNekHrn4QTVIAmukfKC0ukOuWaQSKCy87ktXsTgjwAiEAiCxZZDdeenUOAmX9jZD7\nICRftC0426RFU0odLDRXkMI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdQ9+x4X8JUwGGr+SGGYWesRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjUxZmY4MC1jOTlhLTQ3YzgtOTAzZC00YTFmYjEzZDllOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2DEqmvkhTZGqR98eyL2nFja5QoxCaoSx108bB5RI8MDHU\nw2ayfwRIaEl20a6wWmLukCUrqYFbGXmVsVbQPU1Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt91vuomHG/6PduaMQYphH1fL\nbGkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX9M5wgHOj+d+sZ/tDAUbQa09riPzlJRDN8Gh3SB810ECIQD4vhdyKg4k\nIZql0IxaSPkxW4fA7rp9jziH4eZBSDXNLw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAb+dq+WubNWAf3Hs1EyMAwuEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmEzODUyM2ItODIxOS00NjUzLTk5NzMtYzVjZGUxODU0ZTJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU4ODE1MWNi\nLWNhYzMtNDM2My04YzJjLTgzZjNlNzY5N2RjZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLR8J9bjGgWK89L4xxum6G5oZcqfCBoS0zT+cs/gPkA5AgnbbUVK3Z3e\n5Fi8hUqcWmiXXhrJweXqsIXc5tz1eIqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDTsA1kn\nFD9dLIJVKCJ/01OGRIt1MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAMVVYCuXTJqfrMiK4FJT7zPBp4TgrDvR1vHYdqyLku8tAiB+Klp9IdINMPIk\nuO/Dagw2tCbKV4FmOyuaaCEMGjngAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5288", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5288` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUkhuOpcQDX+2FFPs4gf69eEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NGUyZjU0LTU4ZmYtNDQ3Ny1hMTQ1LWJhMmNhOGZkNzMyYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTYwZDU3YTgtNWI2\nZS00ODYyLWIxODYtNjdlM2Y5Njc5NmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExKAKhNeVtTeahPkNNfX5RzBPS9KY8l5pQ1jXFhqXGFt4RbIJx762rloFMeqz\nf9OYP2fffNlrRVLP0YTebt5X/KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn6RRrhnEijBR3i2LEhJ25X0OnY0wHwYDVR0j\nBBgwFoAUms/b90UZ2Vvc/3VomlzbZhxOuIgwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCCF4Wu9RHLx/jwLzcArNhm7kZVsb5hWygu1UvsyGoICwIhAN5n\nSiD4oRj58RFJAXdkWUNzJ0leJqh4J7XyPNb4trsJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASnpLGyJnILkAdBRIfHYw3IhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzRlMmY1NC01OGZmLTQ0NzctYTE0NS1iYTJjYThmZDczMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4cbsmMszOOJPj9wzfZDvm8et+RYQnsbaXQEopoiARkiKo\nZJB2A+xidcC0YAXHxHLLbFIzpQvnwEIrpoXXwmg7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUms/b90UZ2Vvc/3VomlzbZhxO\nuIgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMW8PAqtWoxiiR3O2uqhSzLLE5pgd0sgx5Pu3wRADFnYCIQCK2Jh/2Jgr\n6E3qhLXGPxzXBtlQ5sdwxf3Qid14nv2CPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAQCFmdWWLsPlq8wLVfYhKNlsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTYwZDU3YTgtNWI2ZS00ODYyLWIxODYtNjdlM2Y5Njc5NmFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFhMjI2OWY2\nLTM4MDAtNGM3NC05NGI4LTIxNzk1MTVhMjdkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPpI5OViEznPlhiqQ98UpgfCS9eKL9bzQJdworV5goEs8Q+j8vnEiUwu\n1c+V+HywGFkqkAMM2Ax77fwCMcIYHH6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ+kUa4Z\nxIowUd4tixISduV9Dp2NMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgEU+/HbtLM5vCtkcQjGFyXZgOL/u+ay7/Irf5EKBqKVsCIQDclYPgt4CLn1wy\nNY5f1fKdw8oB8q1a8YLawDdVhCc7aw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5289", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5289` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAeib1cvsrLto7syXF7FhXAEsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwYmYzNjc0LTJmYWItNDM3NS1hYWQzLWFkZGI4MTAzODI1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM2ZTE2MmYtNjI0\nMC00MTM5LTlkZTUtMzliZWY2ZmEwN2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMwahma6OW3BUSaajTK+GOqhaxkmkZTdtTa7+BnY3LjF66rVzoY9+VKOYrlF2\nFghOK9z5cs32lMA+S6RaGHxdXqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+uWQIS736H9X7meKSbYw1WkthP0wHwYDVR0j\nBBgwFoAU1VeNhc/bachgdwtUkVw3j4rTupcwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFp1neLzZHmhofZ7/hzMunMKJvCGa5hPsiqltFc8w/jhAiEA7Ybz\nnnal1XU0BV99lcnzxNnMcj6uHPBpq6+j/7v//yI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQwOSTV+nhUMc7c68QwkSfk6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMGJmMzY3NC0yZmFiLTQzNzUtYWFkMy1hZGRiODEwMzgyNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREfq5GyeZKfoabkDq2v8b/3jAARn6tkexJY0VMlCZ7x7TH\nR3APQBjN+jJV2p6aKo1spVYHY6yoOhP7hTVGFBmjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1VeNhc/bachgdwtUkVw3j4rT\nupcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgS4ckoboTsc1KsD7q6Ki+eiA+Jo4smm3rL4rFxRC9xgYCIEvClQsy8wG7\n4p9Gzl/21I00WHZGCLBFT2+shFbsd11/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISATCz8nH8Dlc4Q0vWMXk3oH5/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM2ZTE2MmYtNjI0MC00MTM5LTlkZTUtMzliZWY2ZmEwN2MxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU5ZmUxZGJh\nLTRmZjgtNGU2MS1iZGI3LTA3YTUyZWFlNGEwNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNdSY9zj48Wh8yrlMDZg6aMVJnWg4seSgQEuJuGNwnv71SxvUJ63gk7E\nSkP+VXrDIaTDGr8vEbCQV1r6fV4i4cajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPrlkCEu\n9+h/V+5nikm2MNVpLYT9MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgUehsRIA0YHt1RQiScg1M5hO+7+GBwFTd1MsXcVxpOYUCIQCSB/t1iTnFV6SN\nXG8+99fxfQ6Uyqx5/9rm45rL63f3Qg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5290", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5290` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVVPCyqEvEMQ6jgIq7gaqpiyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjZGI3NzRhLTFiNjktNGNmOS04MTQ3LTFiNzY3NWM4NzdlZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM4ZDJhYzktMzEy\nNi00YTc1LWE0ZDAtODU0ZDFjZjljN2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3GCVA7V2ucLcWJva1sFUPI+aKW4pmcYsyscNopJMNc2lVZtY72F2xP/XyGuC\nSea+UQEVhVoBYB2bMIyG/FTuBqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOskNtIjZysYptAZIQtDu58GXwVhMB8GA1UdIwQY\nMBaAFCefFXL1PEAm6vhYH4wUFj+EfPCTMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiADtFCNVukd59ivUOwuXL6NNCQpjA0nQKvW\nW9SjnLGDjgIgVzUMVP5Bm4DXrzf/VtmwNRP0TxUGBwyuVClG6+PoorU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdi8nkZ5fHxNMfKQP8p2fuB1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2RiNzc0YS0xYjY5LTRjZjktODE0Ny0xYjc2NzVjODc3ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAiH7dXRBrWQvkSsWuKd0rNvR6w+45Q9MVXgeEmaC2f9W/\n7Q4tMgMOdsfsco/w+6GSwEN4vKJzHzY3iRvrBJKSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ58VcvU8QCbq+FgfjBQWP4R8\n8JMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIj5SPyImDqFGy98ios8a9P2riPDygZ0N0JHl8YNvxWcCIQDWisOqNls9\nKguzaWxeIKTSKtetGeD4myq9IKgBdUrnYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAaYc9Y67UIqgSQilmDzutRnaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM4ZDJhYzktMzEyNi00YTc1LWE0ZDAtODU0ZDFjZjljN2MxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU1MTljMWY2\nLTIwMTgtNGZiOC04MTllLWFkNjg2YzNkMDBkYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK8oQrZROpOvexzpkT64IOQkspw/Of9nW3RbRf5wRU5fXTOXBjDxF+rI\nhg+HJjiRJUOh8bCOXl53+sMEl0wr0hmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOskNtIj\nZysYptAZIQtDu58GXwVhMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgTAChw1hwY1ce6/nEVTntsu3e0RFctAVFZxYIosKSc+MCIFDBLbzRyHJyG8JZ\nsevQ9JRKwJt2wcPJfNG8fW2z+34e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5291", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5291` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASQ+o6vVhqa/5biBuZ8r6z/rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkMGEzMTZjLTZmNDAtNGQwYS1iZDEwLWVlMTAxMGFhZTQ4MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQzMDJhMGItYzAw\nMS00MDFhLTg2ODQtYWI1MDhlMjk4YTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgLFIlJLly9ARxoRn446UsDsCdc7FmEKCl6Q64Bby0gItwEVjwT7pF9Q64D0C\nd7Ydp6tgk9jZPoiQRKwbAqtZKKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiEqx+IiM5ANdqtrBWTWyFC7UACcwHwYDVR0j\nBBgwFoAUBBhfwXhS/0dTtKhPigVZmGoUhEcwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKb28UMf9yRA\nAQtm2TbEJrBB1h6NinnLIeP9N/6BybGZAiBfS3yyOiKJ5shysPlVK3lywPovhHXJ\nNzcLf7zBgfZg1g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVA6VFbnBUo5UT0+Qn9ANULtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDBhMzE2Yy02ZjQwLTRkMGEtYmQxMC1lZTEwMTBhYWU0ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR75PMqmtXoc4qL5NPi4Sgbl5iXoCJshlfsJchEC1I5TYaZ\n4jwsTJ7ITzg76rxNlCXzwxEUbDnKPSvF7jMuBG3xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBBhfwXhS/0dTtKhPigVZmGoU\nhEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQTfwRvr3lckDoaiHvh2ztiwGH1XrdSmsUxqZqdV5CtECIQCDnEschwRF\nGWXcxdGfX62OlX0sbCs2xFH0tIC/V/ticQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAfayflOBFLxkKgsSL5ajUg4BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQzMDJhMGItYzAwMS00MDFhLTg2ODQtYWI1MDhlMjk4YTg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNiNTljYThh\nLTZhY2MtNGE3Yi1hMDAwLWJlMmFiM2RkZmNkNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDWajXia0f/iQr1bExe9zlOB5oJidToLNrH8FpmzkW0B9Xf/XtToZeip\n2GBXVo8eLAqcANbRz26AArypFbXe0TyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIhKsfiI\njOQDXarawVk1shQu1AAnMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgBEjZ8lJxSL+aful1Q18v8NFfRQOqMBGHAvBqvtgnYxICIQDc/dTzLlcjIOab\nFFX5nPaCGGCPHzxfOAz4YnvBvpKoxg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5292", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5292` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAYSN0LzGyeR9EpJR80mL+7KYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZjM2ZTJkLThlMWMtNGFhYi04OTY5LTU0MWY1N2M0YWEzNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQyMGRlMzktYTQz\nYy00NjRlLThhNDgtOTYxYzdjN2MyNmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnC3xU2YKagoF8NyEvLroGGBFBgKNzF4IYFhHY61wVRHtPJ/0SM83qgna0EnI\nhvfV+g9nR7Q/r2FaWbehHchjy6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKVvwI4D9ToxOWMSPwO0SquZDDQ4wHwYDVR0j\nBBgwFoAUKSIng4tZJNX7y2Awl6+9VFYrL1AwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgRcimiA8+k39B\nRSIv1xAwmze5bqagtI0COWbOpZArsUsCIQDlWHMBoLueKlycidBDS1/tmvDPC/If\nYY6TK8oCgnOt/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcqjT4tI8NHZm+kR9xbuBQWEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmYzNmUyZC04ZTFjLTRhYWItODk2OS01NDFmNTdjNGFhMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQM6DrYqyLOkVmlmis0ZkE03cL6StGDBbvgoRXrqGO2R0tr\n/mOySJo6I9hlfsuLevuxtf6NaMHfmun/Une1gDVHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKSIng4tZJNX7y2Awl6+9VFYr\nL1AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgakj/FqWi/+Y4OQMrmMMYAP+UefLLpJfIzpDCzdjcorUCIQCqsdjENmeK\nmJelwhqdbkM+vGjuguRfNT3Gw42Nen4bNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAeQNJtAx2sUNiTNjQnUOMD0AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQyMGRlMzktYTQzYy00NjRlLThhNDgtOTYxYzdjN2MyNmQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDliMzNkNWYz\nLTBmNWItNDg5My1iZTA1LTA0YzA4ZTZmOGZjNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFJFvG+XCZVuT6dW6fioXEmf4IWhZ7kFnZ9+ZELtFL7ORDjkwmwmnsIg\nYfW9jRXnp+Uwn5+4MU8RV3InAGIGGhGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFClb8COA\n/U6MTljEj8DtEqrmQw0OMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhANs5waHD/bBK0UL+Zo5BIndUXPv1ujK9WseRyMGYz1CuAiBEphBZQacVd8sY\nhpOdZfkM0FOmp82M+4KJBSSU4UP9Tg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5293", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5293` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAbY9lPa2uRWC8fTm5rdYlnwcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhZTkzMzNhLTQ0ZGMtNGUwZi04ZDE0LTY5YjcwNTc5NzJjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVlYWM3MmYtMjEw\nNi00NjM2LWFlYWUtN2I5YTY0YTMxYTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfgqqZfcV03rdcUYqsRu7LmFuiHBmSfgrGoQrW8p8zoPTpuPVwdkexQEIpCzN\n94E55h2634a4w+s3oU1juvztG6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCq/gVkyuKBPxVeK9keXpzDWVAhowHwYDVR0j\nBBgwFoAUV0CkAfrj7hpuvsGwV57ag3Jic+UwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC47oUA3xQv\nKHxvJiqNWjaWIExaIALdIQexmHysEy1B/AIhAIICeWapDR7v1MjTYPOMRA+SwIEp\nGctuBt7c4TSxa01N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUwoEDWPuL+WCchkNjC7pYhGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWU5MzMzYS00NGRjLTRlMGYtOGQxNC02OWI3MDU3OTcyYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJH4NeuPYkfjgLiEC/5xnW5KvxaQ7BTYKQ5ubTcKAa1o1j\n7c5h9g27QSIgTBraMKlYotAmnQ9RijJPAfa9PbvTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV0CkAfrj7hpuvsGwV57ag3Ji\nc+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaqidb41qUKMPdSrm4ymobjHWGh06EpIAX8dONoz0a0ECIG1m0W49G53k\nI8zneFs+gKQoAhtZm+MGUN7NPJUF4t1T\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAUf3ysX8piuLYY3aYXp/jD6QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVlYWM3MmYtMjEwNi00NjM2LWFlYWUtN2I5YTY0YTMxYTFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE2Y2M2M2Ex\nLTU5ZTgtNGZlMC1iZmVkLWQxYTVmNGM0MjhlYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOnOosj4wLEOG/pnggYHookOPZtgepTZnocjsn6Fx5FfW+j7/Hz3QD2I\nlhZFfafrx9khI0A9ie05Jm5crUltPBOjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAqv4FZM\nrigT8VXivZHl6cw1lQIaMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgFhpaU2Elb4eCc4c9lZ/qvPYUW7rp2nNL64znA2uzcJICIEnGgeMpXq6J1RLb\nphd2zVuFA/vKA3geZ7rIRpuQuJqz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5294", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5294` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVWDQdyAN7piYyLM6cWfZy3QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzNGM2MDgyLTFjZmUtNDIxNi1hMzQwLWQzOTgzMDA5M2Q4ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNhNDI2NTMtNmNm\nNS00OGE0LTgzM2ItNTZmNjhiNjk4ZWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErakGi5ts+LmRKL/VfxLAXnpUXYfVkoutrIgevJRaRYMHqiMgdEJypxVUk0F7\nGTs1nFXgjikFrY1HK5CEGx/3oaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU316zbmu8tmBl6Ft2Q4RloJnHf/IwHwYDVR0j\nBBgwFoAUsduvsMbmtXRkqdSLZr+ghhIgYcEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDq1goMN9B1zzhUPRfnCDiVqIAFXkYWcqhDq2cUimrdJwIhAL5y47RxSnel\nyixPj+TAV8egzY1YADesO2/g4CHFYTMZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUSNsrviBK3xtQv3Y3XLTdCnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzRjNjA4Mi0xY2ZlLTQyMTYtYTM0MC1kMzk4MzAwOTNkOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIkjlTnXtNbmPC7EsyPazxHcIfvAsWJMAdLxZujrcVGR6l\nWbjF2KHbEJH9yMiVu5hoFlQ0LS6jYZF4kxdzGBHko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsduvsMbmtXRkqdSLZr+ghhIg\nYcEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcVEbZlfHCLjXPiZPSwUKnis2IKm+tXs3jJpRzaiI1GUCIEyOTOdEamhN\nF3wPob+mlKDx+73oth3J4ISelVIDcCgw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAXi0m8hCNlPV2KJWbnip8lv6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNhNDI2NTMtNmNmNS00OGE0LTgzM2ItNTZmNjhiNjk4ZWIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFiYzllZjI5\nLWVmNWMtNGExMS05NmRiLTYzNWFmNWIxYjZlMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOuqlbm8Z+pKqpJHTBi0rRZrSOFGgkiKgPGdE7DsvGzTOjlmfzzFyFEe\nSPonJTSHA2BIVOurjQtmMC16bnR4X9SjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN9es25r\nvLZgZehbdkOEZaCZx3/yMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAPG1SVJSK/5grAIK6zPxPcCn6HnzUtZfI63Z5eQu3bhKAiAUxxqaO0G1QGeR\nCAhbgCp3XqlCsrjKI4Fv8dr4/7As+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5295", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5295` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQt/JtgVFtFW/zDFZUklROpVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZjlhZmVhLWViYjctNDM4Mi1hMDIyLTIzYjBlYjNlM2YwNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRhMDc1MmItMmNh\nOS00YWE3LTk5MDktYzM5M2Q5MWQwMjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjKjt1TSppXqKd/uQ00uuD45FlcDUwsgXRTR5IeLsE5SkyA5GrjgNKotfs2i4\niTbkTXqh8RPrSGKclNxXl3rbdqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/ngvy+TlVO8Yo6j2D0VEjE68P6UwHwYDVR0j\nBBgwFoAUAw+fVlOmwl4rmheml/2gwz7qob4wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDP/kTLbrxfrXIksLcPi7FRy0xyQ3qYWVTh3KkNZakwoAiEA0hBuBF8at/X7\ncduhSMqUJ+nvVYP1zvFW8UkV59caSbI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARhLjqEXNN7+B+GVCr13v9klMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWY5YWZlYS1lYmI3LTQzODItYTAyMi0yM2IwZWIzZTNmMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ197tVeMF2XVGq6Zw0dz/WC0LTFOB14wtpE6ILjXwNLlhZ\nRrv3nlM8NnxnLlRwSZBHgUZlquPW1Zq2R78BBFlgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAw+fVlOmwl4rmheml/2gwz7q\nob4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdX2goPQz5INXjb2Vn4hfS6EifPdwxwkYfijKs9T5KbQCIQDbqAYR3dyW\nB51+bBib5QVH8uuEzlDvsgACQJRJMJ9sjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAdOHXtfu3QbqOucK/3lJ4HLeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRhMDc1MmItMmNhOS00YWE3LTk5MDktYzM5M2Q5MWQwMjcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM2ZjIyOGE5\nLTRhMTAtNDI5NS1hNWY3LWMzZTZmMjkxMWZkMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCj5z6y+JANpZUqOIbWNsT58LBd6maIPY/sDClSAo6NDHgrQd6rdfpQP\npCelUhdbDsW8zbes5tXmwS9L65gQZa2jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP54L8vk\n5VTvGKOo9g9FRIxOvD+lMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgM6s1hTqKcwmNar3KFG6nYn7eB3TpUjEUoKODtCSD70QCIQCWUuCNKEiVkpg1\nVNqdUzVP9DLLEC1fOOPb0ezvzZUNRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5296", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5296` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAQNidDAjpdvIJZber3ss97zZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMzZiZTY4LWJlZjctNDA0NS05ZTI4LTUxZTQ3NDUxZjNkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFiMWJlMGEtNDZi\nZS00ZGVkLWE0NzYtZTNlNDAzYjhmYzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnzubW72ZpCqpPWlUfgOKme+zk15D0igPU13kDrhBJM8Y4dCE16gmLwYrod+L\nFZ2Oa6GU54dOqNSvtG8QrBUiZqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUebTpbALNkklULEBrW96r64/wKygwHwYDVR0j\nBBgwFoAU54B5MKckYSiTj0JMJ6837qvN5KUwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDX\n4ynSugnZNfWZ/E4EZabEt3K93hH+42JqVUl7V7KG6wIgR1CR5yt9G2wY5WoyPRPi\nugXHVs0aZWMPqFaacNFQGpk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeywILB4otJ34uv24JTqiJw3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjM2YmU2OC1iZWY3LTQwNDUtOWUyOC01MWU0NzQ1MWYzZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnUq7+XQoQuXGmnpOJT+ZrBOpsfUKxycS8mPnS9Bbm7ynZ\nbgUNgGBXrAp/cixSNNwj7vgKtambaCDBb7i56fIco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU54B5MKckYSiTj0JMJ6837qvN\n5KUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJyML7GKL/JyDliMPU9sUmpXaYfxlzMJG06eEy7GeyDUAiEA40GtUvvo\nNS2kO1ejHJUtC7cNYJP2wuIMB0cLaXrPzGc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAUxBlXBDioNLLA7pVe+MCzpvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFiMWJlMGEtNDZiZS00ZGVkLWE0NzYtZTNlNDAzYjhmYzQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ4NmRjNDJm\nLTgxZTgtNGJjMy1hOWE5LTY1YmJhZGNjZTZlOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDR120tIglD1yU5V7oWcZg6swxQ9bqCVWa6UcKkMjWztJElPGLlirOm2\nB0dYE1B8WVEYGV1Pr5m7EouMAl5/dFGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHm06WwC\nzZJJVCxAa1veq+uP8CsoMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgeYY57pz3uRs3tLMQCHd/zKPKHcaD4ts1FNvfxxHlMJQCICTSWG/ELEMhkTWB\nZHKjbZt0Wo2Pmfp455BN15IY6uGI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5297", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5297` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAcBy9+notNMe3plpwZcsg3fAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhZjQyMGM4LTNkZWMtNGIwOC1iMjNjLTBkOTc1YzJiNzcxZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjVlZjAwY2EtYjg1\nZC00MTUzLWI4NzItYzg1ZTYyZDBjYjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZBg/KS4UzX6sEyKympfJlanTlL37aHNxL7o1nKYg5UTcljaNxiCf6z1IZS5u\nHvKB194UjX4X0Q2Bfva1xsEyR6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhS+RuRuLOGFsbs6clqNwwwjnmbswHwYDVR0j\nBBgwFoAUMhBS2Lk77mOWK8JCyynOstFbLkMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIDTZCZa+PWNYcCrz2fhPvK44C1DAuhJz4q49yNvmJIXOAiBt7Hfo\nH/oJI3Q/RhEm60HOd7iQUMFPm3SSROO0it1gug==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT2qch4qTxRVB7cfZidbfL0VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWY0MjBjOC0zZGVjLTRiMDgtYjIzYy0wZDk3NWMyYjc3MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZAhkTA4JT69WNpJgWJYV6ft+6a1kzS/SQ9lgvehazU5K2\nagQSP1HwqVZC8Na9auKMhd1sm50WKwhMzAcQR/J9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMhBS2Lk77mOWK8JCyynOstFb\nLkMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJBJmxU0Zmat9x5WxYAFnH2reFr6QgFltAxfQkvGNIEaAiB0YzYeIgRA\nlw90nFuPC4V93N+q9G7D65rIX5+GPJ9iXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAVeLCLLgqJ4H9xb4rGKp6axcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjVlZjAwY2EtYjg1ZC00MTUzLWI4NzItYzg1ZTYyZDBjYjMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJmOGYzNTc5\nLTQwYzQtNGYyZS1iMTA3LTJlMTMwOTY3ODQ5YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNcNBdyA+C8Li5iKTlzhzmFXTqF++9/9361a1mXeXh6UOmKMo2Q19PEF\nnLAYRBNI48+SQ5pl0G2StSYgxoWd4BmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIUvkbkb\nizhhbG7OnJajcMMI55m7MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAKrtPaWqIzS8ZM6mLaW535txleWV46Nj7KGEoJCvOGdRAiBKFD+WpmQqvpEd\nlU6dRy2p5BJAfi/HT/1uWBhvmlro8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5298", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5298` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAc08CzucLkwBXM4B/Nio3u/wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlODM0NTA3LTljNGMtNGFlMS04NGE5LTcwNzNjMmFkODIxZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBkMDliYjYtOTYw\nNS00ZjAzLThiM2YtM2MxYWJkOTExM2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3iDWS3l4BRSgRbGmNwZa1yKYdu/p4WyRMI08mPxXXQQHyTjEBJo1ldNx1UMo\n6HP0FXm4eaaVF2zNdIMMvIIiBqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqw033SMoYmzZb6BjDjywvzA+5yowHwYDVR0j\nBBgwFoAURHAY3y6Fsy/yV+lqsRYCp+uJFPUwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDCPTG3EaEXnJJSdv1E1GR5AYsB3YaRYcaNsa2er2ZWyQIgblQO\nuV54ZwV9rLGN3t+y7Jb/l9q+ufquXzP7jHfI0v0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAclRCGtyl4MZB3vaLnUwRc1PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTgzNDUwNy05YzRjLTRhZTEtODRhOS03MDczYzJhZDgyMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiKKKC6wD2abfeOEa2hpiHgOh78r/mGMGoLekC5+G0VdgP\nGcyaulgKRapyZ1jr8pejbR0zEEGgAWGhXrfZFHfso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURHAY3y6Fsy/yV+lqsRYCp+uJ\nFPUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRRYvMKuSfSt+eCDHsn4uCvD7JLolVSDNW15wLrolS6ECIHA0SrdmPIVn\nC7G8q2oNyVHz0V5QQ/qZW6bIlrniJ5Yd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAWRuQZlchRdCkAyeQJgecsYwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBkMDliYjYtOTYwNS00ZjAzLThiM2YtM2MxYWJkOTExM2JkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAzMWI0ZWJl\nLWYwYzYtNDkzZC1iNzgzLTBmNWQ4Zjk5NzVmMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP1xRe2zZIWhrBa3YAQh28EAyMqO3PzQKSzogQk2FYlwb5aaQAG8L0Ot\nAhRfz5H4PeVsY+6hMsWvasMONfV7PGijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKsNN90j\nKGJs2W+gYw48sL8wPucqMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgc6jo2JOrQoSb7VuTw9tfIckNXoxZIBbJ4TZvt6QaXWcCIGDRD6ltj85a1Lcn\nEUpnhh2fqd77PAJlABIrsV+XOLI+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5299", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5299` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAYSShQeapAh6DM3kWr/RW0WdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmZjcwZGYwLTY2OTgtNDFjYS05ODY0LTA3ZjczODcyOWI3YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA4MTgzN2EtZDBl\nZC00NGVmLWFjNjQtMGJiMTYyZDY2YzVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiSuzot790XkC5T8dLgWEsiIsoBocG5tvr+s9F+g9kql9etIeBD4c8PCsus+A\nAUYyAjpXBkco3g3XFXMRoHFKzaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSS0o4dyQ9+meCwl9ng28giKbFAFDAfBgNVHSME\nGDAWgBSohJYsvcirltjGdRRz5Yp6QKwaNTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC/ym6NZ7uSuhKHtCllUiGVX5Yrg4A1\nGlRynzg0+LqN4wIhAJqWsrykZa5uFa6EFtMB5OIPLANTwvRfYSzooGsY3fWK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaV7frAGMELwu7+X1NDhZ0itMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZmY3MGRmMC02Njk4LTQxY2EtOTg2NC0wN2Y3Mzg3MjliN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsyzWzmFFtR2hRgZcwEr1bsNoWcOIZtV2gAKVDrqVM7dI7\nFadpnHEgqRNFHqfHSzOd0hSIdhjnIgfd79CgTUZpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqISWLL3Iq5bYxnUUc+WKekCs\nGjUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0pZD1Ei+2BBC98bianr6RmUYCOmUDe7whRyBDpmOWmAiAUZs/bfnka\nDCjH5oDgIvgTaAqS0qrtWODXJQO4gP+cmA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISATbSVcsMtO5da4/Izs2OSi9lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA4MTgzN2EtZDBlZC00NGVmLWFjNjQtMGJiMTYyZDY2YzVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIzMjNkYTc4\nLTA2NWMtNGU5My1hMWI1LTdkNzBhMjBkMDRiMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLqD88eKG39zn/m7+pYbMtCQg04W4n9l90gAEyiUqQ0WiFzTrq5LV62P\n9tPSluywTQ7Kn6gGwW9PeF8cyzfsFoijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJLSjh3J\nD36Z4LCX2eDbyCIpsUAUMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAJW4Cpjifq3dl7T4i5c0jI38tfTGZKR/gfEgzRzbfRV0AiAxn33mo/Gp2uZ3\nIiFtiFf3R54nMbYLkVRc+Oj2HrLIwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5300", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5300` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQOfeCnEqthDbF5FERntiJPbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxOTYyYzUxLWY2MzItNGYyNS05M2JmLTViZmIzOWU0ZjBlNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM1Y2RlMDItOWI1\nYS00MGIwLTg5NTQtNDk2YjNmZjcyNWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjNKcXsbnYeSpbFKKHRpQp+MvPZhO9Hh8Nndto9P/F4UcicdM3yojHjucRisb\nIEBXL/QpjxX4YzlCIyozzrDoRKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQOU9b1BahVi2M5WJXY+1PgKN3YEwHwYDVR0j\nBBgwFoAUWlgH2Gr/IhcW4RRRGPbCc+ztnB8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDHEEd2ixY8\nX3bVX3O+nf63zK1X3YylNoBJ30ViFQVTKQIgTkA54PQb5uv9n/zKbzJfbQXaPVIg\nzYjQ7GOpz8762/g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeFRkDZboBGcakj2G8rcJlPbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTk2MmM1MS1mNjMyLTRmMjUtOTNiZi01YmZiMzllNGYwZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQq0CwefQBF4ZDjD/tFTWY9zId5szKLrOYQuQdcHtLW6PA+\nsrZXXxGRWRYokTtBhDnjSn6AKTt1N8PgDPuPEqEOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWlgH2Gr/IhcW4RRRGPbCc+zt\nnB8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFjXf7Mz/S7MB1rj3T7anZlC/3O+GcVxn4TKr0EOHsBACIC8sqVW4zIgZ\nKqx9Zu1f2cGfPrWb1hHMbPoRs2biuxX3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAa8Gg3bk4FSpItwY+5WLlLWzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM1Y2RlMDItOWI1YS00MGIwLTg5NTQtNDk2YjNmZjcyNWE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZkOTZjMzQz\nLTJhNTEtNDVmZi1iYzc1LWRlMTJiODUyNzNkZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB9CdUvfa4Gn5blNeQ1crHZwDk9+y2lLyFE63c6iKhBcgKPuVdAMwXOt\nCVF7Sf7HNv+h+T7Py1FytdlTKcQb10GjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEDlPW9Q\nWoVYtjOViV2PtT4Cjd2BMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAIjkaS6KhdSBEflVSrIBiLQt5NSGIlK+JhvqpgHjwWLUAiAA4nFpoWvkm4nN\ngaxd1nVb2YMWlF+hojqU83H/disj9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5301", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5301` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVikQJv7k6uVdTzDh2W4RlQzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNDlmMDBlLTA0NWUtNDk0Yy1iNzY4LWZhNGI0YzNjMTAwZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc5NjcxZWItN2Mz\nZi00YWVjLWFhMTgtM2Y5MmJlNjQzN2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd0o4LwFZatcwcIOeXhF3YgB/wbg/bVQzjaOeAOrtH0JEu8MF/tAJhO/vu2DV\nGPNW3z1kyWKEP5dtpHXVSh72+qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWYhbf68Vx3rdpAR8/5jo5TF17P4wHwYDVR0j\nBBgwFoAUjbvGmGk311yKM2zT6YN4Bb3dhl4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCEZW4OO0z4\noQxie/W3TLTpU8BqkO15EI9BgxGx5lgIrwIgX79zWjleTmDPMFwoX6rkoMWtFHpV\nTxonb1h2rJezUNM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXUJvqRycGqOAFDkz8I5EOlPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjQ5ZjAwZS0wNDVlLTQ5NGMtYjc2OC1mYTRiNGMzYzEwMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtkU9+1iIv4xX5WQSsr9c4V3YNHwjp7rTe3VrH8HazCt1r\nm7j4ZuaMPTb2G1i5cAC9tsUHy4iNyTjzBWvCShd4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjbvGmGk311yKM2zT6YN4Bb3d\nhl4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZOntJRpzi+VcIW2ITklmSiOcq70RlMaTgovOP7IY9YcCIHpzLN/KiruV\n9BpeofDDcxaI/V5L+NV1VC+PaZwmCvsx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARLNqyBfJu5lykOOVylOC9ZsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc5NjcxZWItN2MzZi00YWVjLWFhMTgtM2Y5MmJlNjQzN2I0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhOWFmYzgw\nLWJmOWQtNDhjYS1hMjE3LWY0NDM5YzljY2U2MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCIFU+FJpo9wnyPMAtgaRLoCzpxe3fyzNdlrUNzuxq4mmK2aENrLLApB\nn1EfDzL2XoJ8PbJofdsu+Gvte33k/DCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFmIW3+v\nFcd63aQEfP+Y6OUxdez+MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgYaHTkBdJJIw9b+rI/mGofFB4CHxBrY4OC7qRdcLT35MCIQCF/hHreJihjA7P\n1lq1uMsJBfHFatrsJlVw7H3ciwDVPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5302", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5302` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAcfgJoNa1tIt+9JM8Px+8oedMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzZTczYTI4LTdiZGUtNDJlYi04ZmFlLTZiNWViNzJhOWUxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRmOTJmZjYtMGM1\nYS00MWIyLWIxNWYtNDY5YzAyNjM1MGM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8rsZKWnjhPBDyU15ZOw6yG5LFPkZmA26BIhp+ZY2f+ZlW0BHiVRTXYzzJSjd\nfJ6A3VoV6d11fCHg77eTUeEkeqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeFw4JuB4Cm2g2gfyvIkPHJHE1lAwHwYDVR0j\nBBgwFoAUBX8dNz6RbjaUJ8wXXU4yF2UnitMwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEA1GRxIfdm\nbF3OpqtasDB1qpY31h1X1eGVYvH0tqfCcMUCIQCtWpQF3orfw3cbXROLfrPc67fg\nLiBWdcK+Oef/TlOSWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATO36q6HON3a6AUQx7bIBKhOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2U3M2EyOC03YmRlLTQyZWItOGZhZS02YjVlYjcyYTllMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR35kW6tpC+UOM17K9qZ8vP+2HDtWglR2aU2RQN+QF79flw\nuM5Wws1ESiDuxU8nrP35jeKb6eLfZ4+gHHthm2Azo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBX8dNz6RbjaUJ8wXXU4yF2Un\nitMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBmvQj3/uJfH4pKPhUejQMxxLCyCr2IkW0vgvODOvH90CIQC23CT68zfl\nRmg1QXXPt13pb+AzwEUR6O3KHf1Cwpu/kw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISARgHl3WEmaYfUVmMefCVYWx6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRmOTJmZjYtMGM1YS00MWIyLWIxNWYtNDY5YzAyNjM1MGM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRmNTg2YWY0\nLWZmMjUtNGE5Zi1hOTNkLTc4ZTNmMTdjOWYwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE8ZG5eqi7M81QRLRSxnxc0x79MY4jo7K8KLs5pFYYnB1vQ7D2E+INnq\nScnitMuKKzZuigmAPryooqMBVt+bC2CjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHhcOCbg\neAptoNoH8ryJDxyRxNZQMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgc1YZEu1OwpFA/yA49ZXU6Rbb08gCO+NPZ8Zi/fK0A8sCIQCYIkvuMevMI/gD\noQBsZdSE3BoEisUDovommHcE01qIYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5303", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5303` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYo2FsW+TWyCQOKbhN+9hJ4jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4YmFhOWQ3LWYzZTItNDNjMC05MzJmLWZhOWU4NWEzNzZmMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWEwOWMxMjAtYTQ3\nMi00M2QwLWJiYzMtYWZlZDY2N2E0MWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEFTuZEDUjXbNYJmVeZjFcnW4KVYjsIo0WzyLZ+yllb+kvGCynIEQ2dbSK3zv\nz0aJyrPUHMhT8iNiMojukeJ136OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOoUb9Rm0AG9B46bOJUXm6/ZESwwHwYDVR0j\nBBgwFoAUPztlHSNxp4G2D8az9j+wsFHSveowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA0gx6+vLTnOPQCm8E+VfWwt4OutvNnmQJhmqOxvhhWW4CIGOvK061dD2M\neGJXT2pPMvx+gHXAMasNuVNnygXj/HO+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWf7httwBQ/neKB7/q6c++ifMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGJhYTlkNy1mM2UyLTQzYzAtOTMyZi1mYTllODVhMzc2ZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5NW0PtBSXaNz8bHtm3AmxlZd2lZ6/pdnwD9Zm6EuG+qK/\nRnVlSAyiWmAhyUVuMkhpWHxBTLaR9XBnjcnhFVUoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPztlHSNxp4G2D8az9j+wsFHS\nveowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE3ki2RTZlnOb0MeK9DuBxKIQYxWRwoxXxfcBM/MLhCsCIHXfpOJbgHRB\nRX5caYUVnHHA0HXBbHiYtH2dsOlFAJ1p\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAexVib6/wugQcSYkoF8LwokWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWEwOWMxMjAtYTQ3Mi00M2QwLWJiYzMtYWZlZDY2N2E0MWZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY5Zjc3ZTNj\nLWRiNzYtNDVjZC1hNjY3LTA2MDRkNWZlNWM2NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABETqVnWdD1HrgjkUiPt/oU667MeHY2/oVKZp230wvpIZbNZOmHGjgxP0\ngBO75DSpBSa/r/wM6o6wk3kv0l5y+OGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKTqFG/U\nZtABvQeOmziVF5uv2REsMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhANE+KGFAHOn8qCbeC3ytjPL97bPHgSYhAquBDdBimx5WAiAcRXJkxoYrEkbg\nGyAFtpq9hgU1q+s+S9zCaCwRrIo2iA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5304", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5304` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAdJpvTfVmGj937/BswxUkTsNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkMzc0YTJlLTBlNmItNDg5My1hNDM4LTBlNjRiOWE5ZGJlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTMzMDJiNzQtMTUy\nYS00NTI3LWJiOTAtMTI0ZTVjYjVmNWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeLda+iAInhP+Pn9+L8En6F03Cp6YWP1Z2NYewZzKq6rFrCyJ4EJIguP4vSIv\nWoSsBBET9xgJxSNQEW+ZSdBYUKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU67m7oPYpm4xcYlilLEu8pNrePT4wHwYDVR0j\nBBgwFoAUj+Y/ZYumOjK8IoWo6bIQG1Jib9MwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA0FwTBaO5abW6/qn+4FFkhNP2OtM+0IiRJG0IFednZ3UCIQDxwlKHgSe2\nZNbd96/AgIIEhZVG2O2/fHfqrOpV6Yg9Nw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAazNKWol80+62IaFwW38rj9/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDM3NGEyZS0wZTZiLTQ4OTMtYTQzOC0wZTY0YjlhOWRiZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeHmncUDJjZOsI3WAUvomM3FBkgVKlJLVP+aHkpr/ACa4i\nBE0JGcAirbtnC4WZsiHMepzXCrTctu/8HCFvCH2Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj+Y/ZYumOjK8IoWo6bIQG1Ji\nb9MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANmJXOQDg+t0VMnU99GAslU7PNlSUkdzA/YHEs+FVD4pAiBXYVVfe+/u\nl1Vrde/ElB0KyuSV498EEKTP2az93cTVXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAZivBzTfyvEPDtFmYtL+aoguMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTMzMDJiNzQtMTUyYS00NTI3LWJiOTAtMTI0ZTVjYjVmNWNjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1OWE1ODNh\nLWNjOWItNDRiMC1hOWMyLTBkZmNmNjRkMWZkYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFpplP6soCfHHCLIvLMwctFeZAgqoxxqUBqti4Zj8eRpoOa1J0JLwmQz\nhnWVi4oSWxcQ3gHrNynY+9uJvW72LGyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOu5u6D2\nKZuMXGJYpSxLvKTa3j0+MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgEyQWlPL1igB0zjUKOZVDxzPImVSA01rItXR85nGnLdECIGi5+6UekJIy4zk1\nWByjj4oXL4Hx4kEldTBoDSoGrg2z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5305", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5305` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAXwrqyr/PMv5F8MsqCItN0E0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MGQ1ZDA3LWJlNDMtNGMyNi05OWZmLWY4ZjM2Yjc1OTg3YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjViNWJiZTUtNzRh\nYS00ZDc4LTgwYTMtOWFlOGIxNWRkNTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXMAtCnz++ylMVDMsGUM61KzXmnk3s4abBXwcq8JtcZLEg/8t/PqBOo8Q7vGG\nWgS41wRdOv2FMdy5gugEPMrU66OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmYLXTCF9B7mcEl3F9lm/3Xj5s/QwHwYDVR0j\nBBgwFoAUPI+v/mvjJJNIJD2D4aou7z7aoZMwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\nxLFByneKl7H8ZPBDKEZ29NRADP+D25kfKS3+CCdAMQwCICQkLGqItIxt/aE3nzMm\nmQjjisxOEm74nFxnDw+DstAB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXulAWLaljQIuB1CoGIEei3BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjBkNWQwNy1iZTQzLTRjMjYtOTlmZi1mOGYzNmI3NTk4N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCKjtyYwyjohB+y5TQzEjJj0xxlkA7URA6ysHUZ4He63/h\ntklvuSHKIdqyng8B8QOBOJWDC2sEjxsjpQppsp9Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPI+v/mvjJJNIJD2D4aou7z7a\noZMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgX/0KwnNtOv4vmfcntv5PffbDDTI4L1NX5+UEVDdqFQECIGSLkSuN4IoD\nZ+mg/qKDhKtMvHrKSDqeG6izxBlOsBT0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAQMz5enmbhoQSAgXctHXB4HhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjViNWJiZTUtNzRhYS00ZDc4LTgwYTMtOWFlOGIxNWRkNTkwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhNzI0ZWEz\nLTdjYmUtNDQxMC04MTQ0LTkxNjQ1ZmZiYWNhMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDMCAUe9ZhhaHR+rEFvd6msJKtKUbYm0EWJzKVeRf2a0hxfpmGRTpStx\n9lbERbzsucmXJB+EBkvJKSxtrIaO4rCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJmC10wh\nfQe5nBJdxfZZv914+bP0MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJKHJtsc0x16K2TcYyBzvYe44mBOd0KzyVWf0pX9t/leAiEA1a35jp5pQlpU\njcUfJgMdIR09Cruzp7gigXymHnRDN0M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5306", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5306` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISASY+NLFOFBfQG3xN8GaIHp2BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4NDE2YzVkLTEzMDctNGIzMy04MWVmLTEyOGFmMDgzYjllNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNlYTA2MWEtMjk0\nNC00MmE1LTljZWYtOGViN2IxNTVjMjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXOeqRp5yAFUOBwISIKLwG71q/Na1vDqB2MzU7hD5nqvEJR7ZrBlCdTn14jCA\nJDrtnwHLQxUsug1dLGK8oDDQw6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGG6BnPKtEnnXk36vLiF1bHJcPp8wHwYDVR0j\nBBgwFoAU3Y4Oa7y1FgmNkhMibs1EZepwSvYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAslbVTegF8lKre9zEYFB7ceQeaqpI/W7cVVlB6MUo0D4CIQDQ\nxlK/2U6Op3C1YST9Km7ORpVvKvsJjmozn6rwdj8tew==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYmx/3dOBOs8Xv4tCpA1pdjqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODQxNmM1ZC0xMzA3LTRiMzMtODFlZi0xMjhhZjA4M2I5ZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbz9LQi19OJPKH+Of16PWIkRJiXAI2E590xriFHqu0xOyi\n224hiLyGtz2eU8+a2w7B2mkp39cOOz3MZw3MWvnGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Y4Oa7y1FgmNkhMibs1EZepw\nSvYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOrFmHlQSRV6BYRCjN6XRzVg3v9I6C65XuHiXwEROzoDAiEAtxkgSyN1\npKXogXryZAZzscNztBkMoXb2GFQBrXhqUlo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAdGciYhTUl+IHI3Wf/OsPmKWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNlYTA2MWEtMjk0NC00MmE1LTljZWYtOGViN2IxNTVjMjNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZjOGNlYzg3\nLTVjMTYtNGNkNi1hODA4LTRjMTBmNGY1MzA2ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCVb2fWz6pUPO6GZ5CpOmPbUgbgaC3kZj2WbJkpsyVUS/srjPUu9E26B\n+QYUY5SVDSM2RQ3RyBAKeHlV/F+Qk/WjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBhugZzy\nrRJ515N+ry4hdWxyXD6fMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhANUJRVX4WaJvmEYbL1oVLnjEntwfI3ePJ1Q7qlXMkY55AiEAkyOJnGH/8lMF\nofcGk5EKzbPeqUDLrK9aOL0cO+8rq60=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5307", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5307` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQ5FVditI8qGYVQ8ekLnpxBvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmMzdkMGEzLTUwNTUtNDZiMS04NzE0LWU0MWQwYWM5M2I5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgwNzE5ZDktMTBj\nNy00N2M2LThkYWQtNGVkYWU0ZDFmOWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFxSJDgrEZKlYuO94DFapXl14bbT5mgPPMcD5zd8AygGeJEUzBJmijqw+oNFn\nzSGPKwjL82XYgODzOV4w17/+wKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1lNP7gSfDkwAlLipPsg6BFtibEIwHwYDVR0j\nBBgwFoAUGKrZvcFmSTawn0joURpLcQcKotUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA6bE0k/nLF+cwicagQtHR2lpHIS42zV/Clcv/us5WNBMCIBol\nbf2R/DMoObOz1X/NlxmqCfQGC8Zwm/S2Rd3i358R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARRoKPBcKZkKIFMPwuKb8vPzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjM3ZDBhMy01MDU1LTQ2YjEtODcxNC1lNDFkMGFjOTNiOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT608OnbjD1q9tnYkW39jDIlj53DBSl8bqwaP9ovsI8aFlP\nV/6cuA98RL+P+K03djfVmeiZvF2C7b+ID1E09ZT1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGKrZvcFmSTawn0joURpLcQcK\notUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIEshuasZVC/OmdseW2PT2KRiTsmhxlSK20hT3wahVSwAiBlW3HFKTQd\n51QbP1nKBEW5bT866hQM35jA22Q2IZTCoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAfXs9Bn4QNQu+ej1X1ePXEvJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgwNzE5ZDktMTBjNy00N2M2LThkYWQtNGVkYWU0ZDFmOWQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhYWExNWIz\nLWZjYjYtNGZhZC1iMTAwLWIxY2Q3MDYyMDc4NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLJHEyEiZV+TAnWxWCCHiQfhvNHj72uVxlQFM2HOt2FJCdn0cfcO89OS\navgUAU5q1IuPgJIWh1tIphm0UP9L0V+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNZTT+4E\nnw5MAJS4qT7IOgRbYmxCMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhALLU3B7ssrfeNFc/QxPIBEFveJ3gYzqqmuM6EOc9SmYyAiEAvl2uQ3Opmbim\n5XjLyJ54lqr+cmn2CPErN+VbwNC08gg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5308", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5308` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbe96pd2ecjm86fIw9C8hx0VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNmI0ZmNhLTA0YzUtNDliNi1hZjVhLWMzMTMzODE1ZWQyMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTMxNmNhNzEtOWYw\nMC00MDM3LWFjOTYtYTM1MGVmOTdiNzJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmmE7qSEcMfM2JWCDuKSAvhKJ2gP+C0dIeKfG79j+myhyjmDeNLv88Kt4kHtZ\nez7X0HO4bsVlGFemqpPnOjuVMqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUizv4pS/Mnotp9ZFSQ3LOCLZOUNQwHwYDVR0j\nBBgwFoAUlX3fPLU/Xnt6Qd/JuX8YpMeBe+wwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBYx5URksv4+YwB\no6geXO4JjBwZQYnXm982XYqq8i2dlwIhAMoi2U9uy4QnBgrSgTQLPwDXLG2gsCqi\nRBcMSsmgMdh6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAe+YpPR6jh4BTq4tuqIgR4lfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTZiNGZjYS0wNGM1LTQ5YjYtYWY1YS1jMzEzMzgxNWVkMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4hLCz8MfIzCVajO5FhiHo8p4AaaXt2H2KTNMaRcPLWFOI\nargwAhQE0Lvg0/xo66p1Hm3RGMgbQClzoA+7LM/1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlX3fPLU/Xnt6Qd/JuX8YpMeB\ne+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIgLGLCfD50CAApHbCRsVofVEk+eExlmkNWMkHHFSP8JX0CHzddcfCbX2AB\n+nG0VVT+9ygleLHRqbgJlKiizdKY68s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAbA/VON1AJtG6V3geAb7WW+NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTMxNmNhNzEtOWYwMC00MDM3LWFjOTYtYTM1MGVmOTdiNzJhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM3MzNhZmY3\nLTUzMGUtNGY4Mi04MmIzLTBlMTgwMGFjNWJmODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABATOjAB1Ose6XEAXj8vnCP6MKbx+wjZplhL00kX5dCrzxSxtKISybGPr\nDay+HrLcmi7bJ22dvV2CRYqM13ZCvOejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIs7+KUv\nzJ6LafWRUkNyzgi2TlDUMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAJv5jJJmNceaXww7cm1N0KmMtFeADDGlxzX8/HSHwTslAiEA9vjpa8Hftrdb\n0jUG2UoN2QgnzpXA/qAwsnM8JRyafLA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5309", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5309` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfrcRlImJBNsacwoFl839th/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwYmYzMmIxLWVjNGEtNDg4My04ZDRjLTkwNDVkMGUyNjk5OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU1OGIxNGYtN2E2\nMi00ZDI2LWI2NmMtZjM4ZDdmMmEwZmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtiMM1/gbyBfEAFbvdWDAPw0+sm2AUjKi4lPGDq9HbcpeT7eDrzt4Y65jbOru\nZPOnkrjO4KeHUxwBm2BpE4LzB6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU4Y5J2pp4Z/53YHNP6pIR5GGMaAwHwYDVR0j\nBBgwFoAU2WtmFWNyC6+rebOvmLsCFNkkerswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD2eil1ZtorvZbM3bx2H8UXRpqPhGOMhemER8N+hlsE/gIgLWnZJVEX/HXx\nga/Se24GBpdLFLQGFz+MH3t2poipdKo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX3viLSsAwuYQFiyRAlVlNJeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGJmMzJiMS1lYzRhLTQ4ODMtOGQ0Yy05MDQ1ZDBlMjY5OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASG/U9XVHSDMSAzNAASSzltNfFHQoAlabXf4d4O2n3RUn8C\nr9mJ+inPFsWvoEj9JYB4DRBq+E/qpO75pJbJyM/yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2WtmFWNyC6+rebOvmLsCFNkk\nerswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMGE+0taNRl6NEoCkYy5uiMZ3SLDb3I+LS/DHfNPuC6sAiEA6Bca0g51\n4j+TJMfFVoUpsr+OJ144zY+VAaIBzlb8RyE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAfv42WcgGPRanFRxBCvvgkCfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU1OGIxNGYtN2E2Mi00ZDI2LWI2NmMtZjM4ZDdmMmEwZmJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY5NDBkOWVj\nLWUwN2EtNDA5My04MzI4LTU1OGZhMzFhODI0NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCv1FwDd4wpgtlzsa60V7IWCcJ26hn7H9DI6Pdsckc6BToB7d1LpIT3T\nPexv1WRLDrH9lS7X+N+dyf8EoXquh0CjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFOGOSdq\naeGf+d2BzT+qSEeRhjGgMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgU4jCmEINaoU1yHU8U6sTpLezJtOMaKcxlmXVIZojXJoCIBDGnwZWsYaQ3Qdq\nYPzhu+NKHJVnaY3gQXEvCVMw8qrg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5310", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5310` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASGp2pZHzkvxEyzOrzbEKSj5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0YzdkYWNlLTM1NjYtNGIyYS1hMWQ3LWYzNTk2ODZiMmE0MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlkYzI5ODYtODdi\nMC00NThkLWIzOGMtMTVkNGI3NzlkZGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEChc4B1JTIvHCFvvsYj+eavIIWiKR4oUR7XFP4/lp5NE3heVdFxMLx56Bj611\njDWMElR8Qz/GYKwitrL35hyIcaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4xo0ligUW7R1YH+hDH0JddpWvLIwHwYDVR0j\nBBgwFoAUMgQzqCnsGL3KDzTOFL9xlnncE4swNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCwEgWTs5gTFJ3fMZkWQRI9yyKxY18oQS4j4KtNFUpMrQIhAIW9y+V11ojs\nvwx4VsfTswb2gywxoDKawN28fOHZh5t5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAadp2zyCbD07zrDuP8Xk8IHbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGM3ZGFjZS0zNTY2LTRiMmEtYTFkNy1mMzU5Njg2YjJhNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTkrtGGsYhQ1sTFLaL6yHZNPJiitFJWxquL7y++VPDmzQj\nXzWUBxAYvRI5S5kKPlVYsN0TCJZm3vrcM44mNpHho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMgQzqCnsGL3KDzTOFL9xlnnc\nE4swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHKcWn53KjNtq+px49dboldkp2KUDxDIb5zd7wtiY0ssCIH4OTFTPwmQN\npEgFZAwfB6SjCAOYlJVaknl4tqXrd0wD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAeXPZB1Hh/0lmf/dFDHKTBUfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlkYzI5ODYtODdiMC00NThkLWIzOGMtMTVkNGI3NzlkZGM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhOWU4MzFi\nLTcxMjgtNDFmYS1hZmZkLTJiOTVkMWVmOTdkODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBfx0oKNqNi7E12w8g49/VDEdTi5qs65UQOwBUCQoUiaTyqUyAfzYOpl\nPvtovLiXV7AeTukl6aGssN5lucsvw9yjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOMaNJYo\nFFu0dWB/oQx9CXXaVryyMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgLOlpUuVL/z40Twu5ojiKkO8EjGO1fWysgJrh7aiD6uoCIQC1ijB/Qa8+9v/Z\ngIst2cpu7aQ9OO0L+RiIYAtrwqREFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5311", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5311` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISARYsQL/IVNkNFaYU8gV6aMpwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjOWRiZThlLWFmNmEtNGQ3Yi1hOGU3LTU1NTkxYTEwZTk4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM3NDM3NTAtY2Vm\nMy00NTU3LWI3NjYtYzI5M2ZiNjRjMzFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6r+5WpSzHrdU8SZU7ezmFeKJGTBmezPdTYHfnZVLSbySM0CH3alOexKKWDOv\nILxinJU/gyBtwXuYIKGIFQHMX6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw75hXg/F42+fiVZA+T4uuEhWXa4wHwYDVR0j\nBBgwFoAUpPcG0Gf3CUmLyFAC5uqZB8BGxGQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBJOvrO0fLfdaZSWse6D2f4yhgAc8M8tkZFSB8E0FlUmgIgQlil8m3bTj2N\nBlO2BaHYUtraGzr3/XHsZOgMHyUWR8c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdCaGomb0fjKiHXSBjif4Ib3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzlkYmU4ZS1hZjZhLTRkN2ItYThlNy01NTU5MWExMGU5OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/fIBRFL5745WXbt+P8wF4pSEl4TCIr7x7/rbMw7oVlUQ5\nGWuIG+wNYRAVeUq5l4q+hEEbZOwzB58vamYyoJb4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpPcG0Gf3CUmLyFAC5uqZB8BG\nxGQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHsEYP6SOOO3PYk538CSwhYgdW412OrUZefxZ+kNKdD4CIQC4MJFdukZk\nIpfPvpWMOuR/cGzZevDuCxEMlGTtzTxGYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAWvaT0B/pRSRYLtygXU79nuLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM3NDM3NTAtY2VmMy00NTU3LWI3NjYtYzI5M2ZiNjRjMzFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE2NTdjMDky\nLTg2NjktNDQzYi05NTI1LTJiY2RlMGRjMDNkMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOe/mMP+8Mfrs/buTb1UwgD40e9ofiUlF9x4xC3zHSbPs507BvIJGGtH\nHSWEyC2jJlq0eVhpxKKmhdMHMUDlqyqjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMO+YV4P\nxeNvn4lWQPk+LrhIVl2uMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgQrbrvOCMHwdCyNy5LgNG8LnsrnGDr5Z9CXqoNUZJTaECIQDh/EQc4fe4ytId\nur5w6zWWJny8CRysSX0ESwp09WtYsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5312", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5312` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAaJgHIkxW+ojLO55xrrc0vfFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1MTI1MGI5LThkMGYtNGMzZi05NDkwLTBhYTQ2NTRkN2M2ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA2YzAzYzAtNDVl\nZC00ZmVmLTg2N2MtNDhkMTc5YjQwYjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPitDxQ4KLdZuaeFHrPCmSP6d/lFZRilMnPV6iuzvOOMd3yhLmZI99CplMyyi\nZeW+zaT6lgwvlhrrbHghIh3B16OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOf8wcOzlIl9+dU07cCtFxkwzkNcwHwYDVR0j\nBBgwFoAU803dcV54dmU06jEa77ZqhXPz3T8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiADl/MIm30bLf06p5hzBhqk7vaN9ZqtwT8gCScgUzxm\n5gIgZaotj40c7MhKVa/8pxqns34dHMpKOiUHHu3NxOrwXrw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARuJ6ZD/y21JCSpzyTovZ2oFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTEyNTBiOS04ZDBmLTRjM2YtOTQ5MC0wYWE0NjU0ZDdjNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFohTBpcMCd+bVsERcQ5IAujv/ezg0vPyAl37fJ+h6Smte\nKxXX6tr66NN3rXaZUEeptbYXzxQn74ln3TeRl6YMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU803dcV54dmU06jEa77ZqhXPz\n3T8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJCE9SJEXaNawWHhpL+ojfv6NzrVjE9SwtIMsUNudGF+AiA6IEXjoL11\nkZk+y+cxW+4bXRX1jyu/ar2tdaZyb7c6dQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAbouAcDRV4/H9s1Vfou1aG/mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA2YzAzYzAtNDVlZC00ZmVmLTg2N2MtNDhkMTc5YjQwYjYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkZDk0Zjk1\nLTE0YjEtNDgwOC1iMWJiLTZhNWEzYjk4MGI5NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABByLnM07obE65qhr6lEpRQPpf3J/TYnquy/bVlr2S177+onpRxRazwFW\nd/u91Icslq4ZiYP/AcLtMFtbpHJGoxyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDn/MHDs\n5SJffnVNO3ArRcZMM5DXMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgF+r7Pd7+Ya8MoP1XW/KRmCUxH34q2cJ6lycbjx8q/pQCIGOpxBY+OPUokpA5\nHk7xL/m/t2yHwT95rNq6l9yrKJH2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5313", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5313` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVOKQg3UaU48pb+squ1QQ9iLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYTI4OTY1LWFmNDEtNDA1Zi05ZGU1LWZmMTU1NmUxOWViMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQwZWIyZmYtM2M4\nZS00YzRkLTk4MWUtYjgwOTNkMzQ0Yzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE26iYyKOrI0ZVSjkW7GOpB8Kf1yJUCkA5waPpPEcviBLAQn8KJidlEZBF5HRs\nqrYIKNjH/ajR83tjuyoDx9jxV6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgHWclPJwWj5BYfO8BHtMsRPQ8l8wHwYDVR0j\nBBgwFoAUOd5P0Z400/hyNoh0bIiyg2IoQ8AwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAigXh0V8v/sb5fQN7FKlSfI/eJjhoDFszoTYkPUNq1\n3wIhAPWDqEmzr8yeiJVnzrqugb3qipn2Ihq0QpkFe8BnnwBz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWG20bG3xyvGOSKA7gbGsepRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWEyODk2NS1hZjQxLTQwNWYtOWRlNS1mZjE1NTZlMTllYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiPLqR7khQzbJs1t60WBf7Y9XJ1Om0nmceQc6Z8OgKv5oc\nQpGTO4SVLBXYwRvKFgWbScLwvYnorcInnAiEJKmAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOd5P0Z400/hyNoh0bIiyg2Io\nQ8AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcknrZq2LETD6/84wyb4/nklc+FYMcIdkfdQvydSAx0QCIQCQiXrJL6EN\nuJpzsPfjc+Zp/I/hzXxWJBSYr8vmlI+4jA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAY/SosMGT+09uMLtBEjvbkLYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQwZWIyZmYtM2M4ZS00YzRkLTk4MWUtYjgwOTNkMzQ0Yzc2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhkYjcyYzdj\nLWQ0YjEtNDg3NC04ZTU2LWI2MzBlOTI2ZWZhYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABILWjPwCYu4uoGgkVyXjLhrZRMlVou+3eMAf3FtAh4KBXlCT0c++ZDq/\nqN7FYxYMFUyi3f4voys4qsj9XzGjRWujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIB1nJTy\ncFo+QWHzvAR7TLET0PJfMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgJkkw8vt8zzK3h7gpUH9skIu9GBGwl0y74XnavQFqVVsCICA+s3w6tb1WLt4w\n7ntd3GF+DvXO0RybxzibGY+4Chd6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5314", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5314` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAfsS4xWNb18aoa0FLtSfFrL9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ZjFiNzVkLWUwYTMtNDVjMi1iZGM3LTNhMTk3ODFlNWJjYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQyMjE0Y2QtODM2\nNi00YmJlLTg5NmItZGFkZDNjMmI0MDQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5QQ66xNv/TfqhGQhHl8tnR3eonCm3rYuYTgb2EtqceZyXCbX0fj0E87B8G/u\nTANPApRJe9rzWx4oJxZSjMdXvaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1wsHBaUR9+mo+6mAv121kjUPkDAwHwYDVR0j\nBBgwFoAUPgtsOMIw3jLnexjI1nTGaih8sFEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAloVVT4zM1o99Av347laoLLSIr/L5PdeSCwjDwgFELboCIQCm\nsWY31UX9dMphkhPnUoCqoOAUM8XWTi4cY83/Fz8DSA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU3PC6OMA4P2IY0Qq+WP66HHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGYxYjc1ZC1lMGEzLTQ1YzItYmRjNy0zYTE5NzgxZTViY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyrWtA3PW5mxvkEq+K71JqTfmawRQ+badNX87Rv7h8lQNK\nZrZLaTFq1WssWJZq5QHR5YcmwpUvL2akWWF74as/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPgtsOMIw3jLnexjI1nTGaih8\nsFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANDAw3wTbYGcHmF7yndxhT8NnScvsOIQ7ksSZ9Ymo05NAiEA+oW7fm/E\nuvfWpvN5ZCTEoe5ePIdfIXYB0b7NUNydPaA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAbVSQLEyN+gjVGxL7R5yqMrsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQyMjE0Y2QtODM2Ni00YmJlLTg5NmItZGFkZDNjMmI0MDQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEyNTNjNDg3\nLWM4MWQtNDk2MC05OGUwLTM0OGQxOTA1YWE5ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJD7VoF2iv5eyOe18RFHnUjZtooWohc/eEWjwEdar30KeC0uqFqw8FxT\nAskGu5NRarLxQT/qC239W+IoCy+gDSijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNcLBwWl\nEffpqPupgL9dtZI1D5AwMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAMUluou3l9pW28YqPMeotf3+SksQUawdsSjLS6IjMArFAiEAiHBFi40Tejnd\nwGSuw9tBgVOeUZRtj1IztaoA5ssdpws=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5315", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5315` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAWxjarwRO/fXAnij/b0oJ38/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMGExMTY4LTk1YmYtNDgxNy1hOTM5LWExODAwNzljNmE3ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGZmMmVkMDMtOTdj\nYS00ZGI1LTgzNDAtMWYwNWFiNDY5MjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBmyAeI4xZrFcjCaKGyuQ67gHIs5aqMr9LsrOAkbFvE//JBtOiwIrFlEzjJ0Q\nHTHxvspHEN7ZxICDMXR6/93uQaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlAQMvBjgTTFhbM/6cQxzwLSRNwcwHwYDVR0j\nBBgwFoAUBMsaEy+bukHljL/ll8sn9apEmEMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBocUfAmdWC0etg8v0YYjMEKCE3RAn5Jld4\nwzAP+GBb4wIhAM35K82LWwb8y5097ocu5KJbDeecrCMg/aZaSDybHy0H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAainvc+GNh1L6wm9rdezhln4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjBhMTE2OC05NWJmLTQ4MTctYTkzOS1hMTgwMDc5YzZhN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrdkxzE0orUGDtRFkkKnllMBUM+ng2XCtMZgYo+TFf1dQk\ngqsHPQj83PdFdTYIAEX1qT9EnRbSzzJMuZcSInpNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBMsaEy+bukHljL/ll8sn9apE\nmEMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJL6aOs2gbzwG8+GUqsA6oONPcEiij2Vo3i9DUUBCqprAiEA3k628xvh\nmr3rMznv3+G/e+Lk+OyoYaqn4nw81QnrWgQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAeh2ZKYG4d3UQxRrY5bjKnKUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGZmMmVkMDMtOTdjYS00ZGI1LTgzNDAtMWYwNWFiNDY5MjZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ1MmYwM2Y0\nLWM3Y2QtNDcxNS05NjAzLTE4NjNjZDBiOWZiZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLlc7bdLcOY8DPhYi7B6GZ0ZQlWCyOnGU32P6seu9c3aMvvu8GrVH8n2\nFcV0GEFXULP1UZjIEnGXvnjidXOU1lSjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJQEDLwY\n4E0xYWzP+nEMc8C0kTcHMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgLrNdRJXUl3VNYUtYnwJKGEEGBusgBqlq4Ub5XqxOYs8CIQDtovVzJOOIoV+U\nosKvWxUNK9rlVpDlxX/chRr5/B+NSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5316", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5316` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISARhHB6oKVWHtORyQVQr03D+3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1MjY3ZWYyLWE5M2EtNDkyZC1iMDBjLTBlYmE3ODdiYWRjOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRhMWNiMWEtMWFj\nZi00YzA5LTliYTMtN2IxZWM4NzI5YWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiPG3WlwOEzdRgR2NvRQWcdHX16LGPGDmH8Vi6XZ4yCF7cLN6kc9EZ1TTeF51\nc4LpYuyCpU0igC89CYj6WBmNG6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUea7t5g1M6BHIDjlOcGupIIIL1PowHwYDVR0j\nBBgwFoAUQE6YzVsmmpZVfYfnUHyaQxnMtnQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA2ZLnwydTAclu4ODO7waXFw04y8H//JsG\nWIXHuY1MW28CIQDc9rbkO+nF8Bf2qoXT3aSAMn6wa/6/bO9Jrl3vNY+Pwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVxGFrYftLPLFYrMofokK0fHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTI2N2VmMi1hOTNhLTQ5MmQtYjAwYy0wZWJhNzg3YmFkYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIdMZpaf6d0Ynh4uBZbXx+q2rXKHDdJofPANT6ZE/2tfeN\nyi88acN4Ay7IdKgiK30x8LrUvqCtpHHp1RSttox8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQE6YzVsmmpZVfYfnUHyaQxnM\ntnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJI9AVVgE3P2eiBjj4IYiiY8GD7sIiVo8OaAYFkLNcwxAiEA6gVv6s4q\nbTbINwVN8rfRIwypoLSCt7dFX+XuPm8SDsM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISARE7ZlXdblyx9Vp6HN7GYbHJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRhMWNiMWEtMWFjZi00YzA5LTliYTMtN2IxZWM4NzI5YWE1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1ZTBmMGU1\nLWU0NjctNDk4ZC05ZTA1LWM2N2RkYjkzZDNjOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGuZjAn4Hgpy0AyTPIpHDfLfj/zKs3rHId3Ej/BOCHFZWCZgPaMObNVD\nkY7g75ngMZJOL6yBg5m/L6a1zNiaOkejZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHmu7eYN\nTOgRyA45TnBrqSCCC9T6MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgHaknbFvl8F02ypuhsFyuZt1bH1TjBKZrUhz1qflKsl8CIClG2OrkVttlZgVt\ng2qPs6oLdilS+M+ss9j9WMZBXfyH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5317", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5317` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWboYfeqZyyK3vWn265aLbK6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwYzE3MTU1LWE2MjctNDc5NS04MjhjLWY0YmM5NjVjZWQyNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJlMzBkMjAtMzc5\nZC00NDliLWIxYzAtODAwOTg3NDY2N2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhO9nKgST63j2jAkRLkAsrruFEuombOA+CdklPhYzUFrRz0ZX3G+5QeaNrXJf\nNHlE/lFJ5loqfnLV7e04wgUH+KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN9D6aegO69N8tdsD0WQoTgPVc8gwHwYDVR0j\nBBgwFoAUO/sY78Kga5FNAXnNO8Z8pyYeZM0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB+sDDNMUngnC7t\n6y8GZT1F5PNaZ/yOAXUOeRfYhw245wIhAILRKfvkWI1SG9VKdpe9y5+IYGAiGV8H\nP/AmPCktGty5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAejdwlsFioracyvy3z2LtU6NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGMxNzE1NS1hNjI3LTQ3OTUtODI4Yy1mNGJjOTY1Y2VkMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIZoISS0q48/+9GpPNspXNOu73nvDhzlkUpSQhWj+pSWP+\nHBQxVdwYczJ0TpgHJJEW2mbbJRnXzqMZu6Mw9E+Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO/sY78Kga5FNAXnNO8Z8pyYe\nZM0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPgPicKJf+tt+5/B4smMNEwnUnOpSs7Mzoa1RLN7Z65gCIEMDPy0knITX\n/zcUvqyp/YOIsVKJsyPvrQdVbWoJboo0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAc2voLmq+LFsWsItarRmwrY9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJlMzBkMjAtMzc5ZC00NDliLWIxYzAtODAwOTg3NDY2N2VkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDljMTZjY2Nk\nLTM0ODItNGJkNi1iYjg1LTJmMTg2ODJjNWY1ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNmacI5mL+gWB3n6YoZA9ITullbJ4T11gNxRPTXwbuWnxoIl39Cj0GO+\nVwt11a7JD3580F1HUmPFWqviXbfuFsujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDfQ+mno\nDuvTfLXbA9FkKE4D1XPIMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAOeFZ5jLpsKC/oRQiBNND+f3v8SB8sw0AITBv0CV8kf5AiAaBAjdqTgEwYvJ\n9akEHO/J/NZbbHOE3yoCVhTmwcHnrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5318", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5318` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbLcXxBj+pwPyFjH4UNk51y5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjYTYwYWMzLWM2NjgtNDQ3YS04MmNmLThmNmNlY2E2NTM0NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTgyYmZjYWMtYjgy\nMy00MDBjLTlmOTAtNzRkZGVlMDY5M2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnnnH38wd+AyV7C92E5rLYJqqxXBYBVQ6r+uPUO7wBr19LxTM+BYXmwbCqR7o\n8m9+2wVUfPagInz242t8bW2tfaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPWP9TbTX25C/lkq3gt3zeaVVNSUwHwYDVR0j\nBBgwFoAU2NFq4qnfqVT6ZpnrPfVMHqGIf4QwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDWBf4+AA5o6aJjiqHIebcAk4+PrQCLw1cOBMt4CQjXJQIgcy9qdWJ3IiSc\n2jmrxh0J5c6SOBGNVlolPdNbxtuM1E4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYnWURZmiNQ+WUwleygW+p8eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2E2MGFjMy1jNjY4LTQ0N2EtODJjZi04ZjZjZWNhNjUzNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcMTgP8xcIaMEK97nXhImZYbqaPHRB1nlONqG1PkVyUj7a\nlVUAC1uXW1UrI6okzH1bTo7WPBAkhBrvffMHL7E3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2NFq4qnfqVT6ZpnrPfVMHqGI\nf4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOy57boq8AywtkV6Cq6GsephgToH4pxIbd1JtYXusk1xAiAqC7gsQUJ5\nLICMAIWwGjgG62l8TpwYaTaeLEqo3oGJXQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAVJ46Jb3dr3EmmW6JMTC7QQIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTgyYmZjYWMtYjgyMy00MDBjLTlmOTAtNzRkZGVlMDY5M2QyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVkNmM0YWQ2\nLTZjZGEtNDljYi1hYTY3LTQ1YzdmMzg0NWEzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN5qalkxAcTje7814h4qtWt/J7Sb/OefmyqSodaZMiIs6lz5gCgSeDYt\nhS8KgsnQJtXyv2Eotpf8KLdy6rHk6wyjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD1j/U20\n19uQv5ZKt4Ld83mlVTUlMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgL7tn3AgHoaODiq1mvMYJneEx+ezjQKgwoUUIdydWb7ICIQCUkqRLLmI8xDAF\nXsekf/tYfjGPHK5vBU4fEern4SFP6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5319", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5319` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARQ2lZz7y0cCwrLbx5gPhEeKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiZmVhYWE4LTQ0ZTktNDQyZC04MGE0LTc5ODg3YjRkODUyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY3ZTQ2YWUtNmZl\nYy00NzY3LWI3YmUtNTViZjc1ZjE5ZGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI7LyWEF57oWtlMRTwTtJl95EpepCjSpEPmF5dciDa3SHgCYUU6lieD0ahBO0\n/YBbOtsBOIke9Nctn2XEdleTTqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbz4NnQmuulGajsyEtG8wP4U5gBIwHwYDVR0j\nBBgwFoAUbHh11sLNt01KzOYxpKLp3tWLyjUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIC7cbdQCfowWRSVL64oA+yukyNf2gMob6ioS0MkzyB3+AiEA2PHGvd0VdS7x\n5vVAfIr7usGPXrdH3uwNoGUE5aq4Yso=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZAZTGLDP5AGcBnAQQP2Cz0/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmZlYWFhOC00NGU5LTQ0MmQtODBhNC03OTg4N2I0ZDg1MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0rpKEj3oe68pfDqoC50p2jnW9BKInpNm0V1XJ9/689qBU\n2pXwCKodgS2xxzS06l1D0jRwgYkT0zklcTHT5Q4Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbHh11sLNt01KzOYxpKLp3tWL\nyjUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP94DVKHGAgqIfof2WLXO2i67Vkn/FNsVUefrzbbKwZ+AiAlS4y1nM6Q\nN5nEF+0rHD5/rV7nDPps/9FOS0Y33FHfgw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAeOt0tmBnjmwid9m82JdJVg3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY3ZTQ2YWUtNmZlYy00NzY3LWI3YmUtNTViZjc1ZjE5ZGJiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRiNGI4MGEx\nLTEzOTAtNGRiMC1hYTlmLWU4NjdhYTAxNzA1OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJoBlkgO7wpk+6Ek7mL6iGm9smtRrV8osemTP4123UQR7+Jdxs30R6Vd\nj29ULXIDCauLNqhslFGS3yKGbK985UujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG8+DZ0J\nrrpRmo7MhLRvMD+FOYASMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgKB28lVF2Fz9AtHYvv6O7OOlOSRli0qIn/FVelcmKcKwCIQC7NAUtuQfOE1Ok\np1LEr/pn1QbkGZ/g+noPeZz8HjZ2ew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5320", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5320` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASHpETbLi76mb8jM0MkrfUb+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMTU5MTBjLTZmMzktNDRlNy04NGFiLWQ2NTc3OTM5ZWEwNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI2MzhhMGUtZjE1\nZS00MTRhLWI3YjAtOGQxNDdjYjNmMTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqWdHeNeskL9HqCBaocnj27s7Kc5p9PWpSUFpjOlwgckEpIOj6tQGp2QDoxAB\n4MlUoORL3L6W17fHpD2aq8S1SaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSM1KlSxenUM8SeNPFrDjQ87JeRcwHwYDVR0j\nBBgwFoAU5LRLVhAjG6snH12gUiDvp7RaFa0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA1/iz/TO42lGQmRSkCWHcBExCKl9elyjy475uhY80JT0CIGC6mkZSyJy8\nOZJG07rD1+kt44Q58059ApeYnu46fKau\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATwhauhhox+Hz8cD9sUbWvNkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTE1OTEwYy02ZjM5LTQ0ZTctODRhYi1kNjU3NzkzOWVhMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVedpxqysTtqM3r7A2rX4CcY+zkMeLK5SDn+R1A53hVCfs\n0hWcO9oo6g179Bp/kr8mg8pKPmUVl7wpa33tpdC5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5LRLVhAjG6snH12gUiDvp7Ra\nFa0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd/kYDSOBdp431tuIYGvmBhexKIH7ew6xCfHKAD19RScCIDmYGqXc7ZhO\nZThStwJUtqZPRSXsOsh6leEQHwupFV8t\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAQtA0fdAFzh8QxwRYCMCeC3sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI2MzhhMGUtZjE1ZS00MTRhLWI3YjAtOGQxNDdjYjNmMTY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBhOTgzZDA1\nLWY4YzUtNDVlMS1hYmY5LWQxNzBhOTg0Yzg5MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIOu0+kF3PjEVh9qE75WMiLpSQxSnknz5mNBaGWB8QGSUujqCjSySykd\nhChjY3Se2ZYBlviqtLE5BygSxC22kPujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEjNSpUs\nXp1DPEnjTxaw40POyXkXMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgfUbD9fFbq7wfOCwNasWSsCFRKDA2HXTTmrSHjmF0unACIQCFpPkb1CskFukq\nsyoMKqGF1L9F67ABZWzGOxErXo+zKA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5321", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5321` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcjBIWZVxnrKBTyPuitpBrq7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0Nzc4ODM5LWFhMmMtNDcwYi04MDczLWYxNDJkMGI0NGY5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg0ZWU3MDQtYmMw\nMy00YzE3LTlhMmMtNzFjNDE0NWRhODQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENYH34BA8oBgFnzHpKCMICPOjZYxpSFVtDIWAx4AZguyrM8lO53ckBCISD8VY\nPanxiLGGgvpA954P3MlRe8o3TaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbzeT023DIGofPCKzHGDL/dkjiukwHwYDVR0j\nBBgwFoAUi/D0lV6ci/8qPJUQKCI1RS2YfNcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiA5F7Y5qjwpXpIPKvhooWW1ldiRPfzi2r4FP9EjvsT0\n4gIhAN2uQJz6MzdJwtHnxaeMU6k3opgSRgmugVFdyPwpUw9l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc8GM3JcmRn3ZK+i5bJwBy3CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDc3ODgzOS1hYTJjLTQ3MGItODA3My1mMTQyZDBiNDRmOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARb0enJfsMvAvd2PxttL07v4/DupbEZutKoA6bCppl9URbJ\ne6V9qgI5tsQS38SzKGsG/IEWt+SQg3cQSWnvtzDbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi/D0lV6ci/8qPJUQKCI1RS2Y\nfNcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMhA8vedh7wXUowH1NDm87nEubcDv4vxUA41DEu/PUuxAiEAj0FtoRXe\nMsPXwovqpDtH74HPHgINDYjNDiorH19qzKg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAb163XR/MugaEQjJgfMgITgdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg0ZWU3MDQtYmMwMy00YzE3LTlhMmMtNzFjNDE0NWRhODQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3ZTQ2ZDEw\nLTJhMDItNDBkYS1iN2VhLTlmNmMzZjdiNjU0NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBx4tuJTtL7U61YKemPuLq5mxufzW0BABRjy1ni3UzW/4kbuBX84UtLY\neKl2dExNf3qtDIsxaW5/FGVEVcGw0DijZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG83k9Nt\nwyBqHzwisxxgy/3ZI4rpMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgVkXO2sfU3X6JNL/b/LIzvLxgfqaP0cqRjzAuvW250nQCIQCjN3rY14bSl3wo\njK8nVAq6heRvAJagGTjtK8C7hlDhjA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5322", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5322` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAVl2+iANBJn66+5YaAhdNa/4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiMzBjNTI4LTk0OGUtNDM0Ni1hZWIyLTAxODQ1YjNhY2NjYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmM0MjYyNTEtODY3\nMy00NTNiLTgxZjItNWM3OWExYWM3YTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZBd6jpVo82nvzL0QIP7EEq8HASNxU/i3932AHCTTfU1nqESbNQ9KtjuoCtfI\nMFlb5CbBEe+G9bZpurq7JBE3PqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+xWHVocU6IDV1WeK2p9FcrY4mUwHwYDVR0j\nBBgwFoAU0Jl3dkT+t6FX8EWm7HAmNFt9D+swQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBx9cynhFo+lDESOi8HYM9fM6dvAcU8uBtL63p8FSjv\nGQIgcBfORC7o9hgie6IwZn3gexPTiIAspGfI3F2aQ+k3Z3U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfuR9dwEw3KZWjYz08ofZOOuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjMwYzUyOC05NDhlLTQzNDYtYWViMi0wMTg0NWIzYWNjY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuaY0+loXqESf8qLvjnaBTyPC6pQ3KPNLwuOLX72yaJSak\n9XAtkHbQ1eI92tWNiy3UIDJJFJXOUChmmBMmx5sJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Jl3dkT+t6FX8EWm7HAmNFt9\nD+swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB1RXjeYOBrwLORLmjFUYqXqq0p5UpRrelzfFd5hJhlgCIBbsOMqZEhku\nGWemp7ycpm+bepKSv8NocTyUd4EtGdGt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAcPeaUYzjh92/k9OI4y5AmagMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmM0MjYyNTEtODY3My00NTNiLTgxZjItNWM3OWExYWM3YTcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc3NjVjNTI5\nLWE1YzEtNDgwYS04YTVmLWNlNTcyZTUwMzg0NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOGdSBBGxWZ14vYXlZjMLIwoNQKYgezjkR47jwzxFAcoBlG7w9SVFx9v\n5l5KKIOockmvhyosGbjLq+1o8LlHxxWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJvsVh1a\nHFOiA1dVnitqfRXK2OJlMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgN21kCeGEWcRvQFkQOwcmdhQ+E/NLTpcBHwS4tTyP7hQCIC2Xh6gNOr+vyAH0\nbu/QXm7qU26aaZpgkGF/KP7ZAKLr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5323", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5323` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVEKFNzVCmLebqyDfY5bqeUNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5ZjIxNzI2LWI1ZmYtNGY2Yy1iZjExLTY1ZGFhOGE4YzNhZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBkZmUzYTktMzQ5\nNS00ZmJhLTlhZjQtZTAyYjQ5NGJmYjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/6CW5RnRa+wwoLaImjZz9i1Eu2UiEIBWzeS5QQu54JRj3m00S1gdE0Mr5IYP\nzU7+ZPuBBUUUij4UFclPHuO6fKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpdjpsxFxArSRR2toSRdsZ3PATn8wHwYDVR0j\nBBgwFoAUlGDgsBfZFSsLsgQqQJJZLdoQEuswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAqMsERvQXG/mQA7YltfO9SO2Q/zEzrMZUVQeVj1ISxOECIDq0\nJtZNQl3z4i4O/AlIa2UGiwV5AWRVxhKIkKye2p3X\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ569aM7aLd9xaju1nS/fVhnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWYyMTcyNi1iNWZmLTRmNmMtYmYxMS02NWRhYThhOGMzYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGA3aaFbsOGfkron84+E32H9jT/nKi/mxG3QNCKRmV8sLW\nKP1qWW9z3X0MxuSVm3eVUHNZ01GWEJufXPs03pcIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlGDgsBfZFSsLsgQqQJJZLdoQ\nEuswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKWk6QFQLVjT25C2FUA1vbdGDZ3i0swT4N3hQMO73zedAiEAus3byJz2\nPmeLJfp+I0xx+Q0VOsOqgrkQf/5HXFQ9CRU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAb4KJhEWoxKtHiBP5wWx4JK1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBkZmUzYTktMzQ5NS00ZmJhLTlhZjQtZTAyYjQ5NGJmYjk5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE3ZmU1MWU5\nLTMxOTEtNDI4OS1hZmU2LTY0ZTQ5N2EzZTZmODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAA+Oyu5axYzPHi8RbH9fSl6wdaKmuumThE5+xAnoLna6hbSrHzGPzj6\nfxzQcIX4ybqLH8UxRSqHZStnRxeVO7qjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKXY6bMR\ncQK0kUdraEkXbGdzwE5/MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAMGznaE1TQNUehf1JfdUO30wB5GuECoRWgrwiwqY/IeiAiEAjlAREAl2c0bX\nbIV2qLvw4WWrp2bEdf7G5N8l6rYon9Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5324", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5324` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAZTTHP0yStIkEvzpPmQXKDtiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2NmE3ZGFlLTk3NjAtNDM4ZC1iNGMzLWI1NzFlMjI2ZDcxYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZhMjI5NjAtZWVi\nMy00ZjA3LWE2N2UtZTBkODA4MGI5MmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMhdaJ5D06Xpp1Q1px1Y/XF0jzTi39dlurgmx5cHebOiCEi8JXXZlFLguX15H\n/Ademl26a+yIV1rQDVCQ0AgkmaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOBCiHW+pRSaszj8MVYhUoBcnl4MwHwYDVR0j\nBBgwFoAUsFKm6WoTz4zV47kAIkf+JBdQeI8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBHt8SkX6hJPX/3mySeomMwbDUwwMVq+rrl\nULuk2FwJlQIgHgt6dCOikKeRzkv93Ia+9nd1wpio9AjF6MpgtVxS1aM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUs0Q7QlbCxLv16N2dxQZmI0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjZhN2RhZS05NzYwLTQzOGQtYjRjMy1iNTcxZTIyNmQ3MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASP944VBmfbYA7YbmM7wfTcz/LEu+kBSxV9t2RrNKHYVo2Y\nFgaWOmwSIiqks3AY5A3ojQIiNAnQaHZI1nWW86WTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsFKm6WoTz4zV47kAIkf+JBdQ\neI8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTh5Inx/6blOPYOI3cG0pwTIkZ2ld9bOh2olE5roYCZUCIBHWWlJxgwni\nHhwVP7REkoXn8YwDoYlkwJO1OoMz5zwz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISATUHgTQNJ4DG3H/Q+TA/d1JyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZhMjI5NjAtZWViMy00ZjA3LWE2N2UtZTBkODA4MGI5MmZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA1M2Y2MDE3\nLWQ5NDgtNDQxYi05NjM2LTMyOWM3MjRiZTdiMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM+rdZSKNGKcInq/o1RO/Tl9N8VGTIjdDJGDqWuZK3sIRxLQZZ7TdWdg\nWdmC+BIRcnCyq4CtP7hoAcu82LeGD/SjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDgQoh1v\nqUUmrM4/DFWIVKAXJ5eDMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgL5IPzsItTkC8hKAUMfmcDdXHdza+to0F3Pqph6Ky9AACID+3NC3ibI2KLGpI\n8vMNvEy2yaFwlYDWCK99Oz8PiHXa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5325", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5325` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAXVFYv+UZHVPHAHcgtougIppMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyZjgxY2JlLTNkNWItNGUwOS1iNTM1LThmYzMwOWZmNGY5MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFkZWY4YWUtMjQw\nZi00NTA1LTliOGYtNDVhMGY5ZTIyMTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmCCaona5qm4VQVChB6Dw7+vvsO4i81WwYnm6ya/al9YXNE6aasQxgp+1Eb1r\ncPFQRHDBb3qkS77jeVf6fsTloKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxttKOjwSATTKg0k7WtcVK+FwlMwHwYDVR0j\nBBgwFoAUJdSoCORRk//TO5r8en7H4gtzPokwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBnhzzsH6pLvD5mcqXUVUB3ecuYifchcjd2\nr/WmNWx7XgIgBME3hP+bHbG7nLNbJpTnXJwp/jU8m003bCbpdkoRAgE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYLCGzDe7U1r8GE15kpxYe3LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmY4MWNiZS0zZDViLTRlMDktYjUzNS04ZmMzMDlmZjRmOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwF4DJtpAsyTzvlemK6Lt7YiWB18sK28I9aEzzi+t+aosl\naXTEHPSYOQzhIDENB31dJW+dSlMzxRf1pCcssNi3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJdSoCORRk//TO5r8en7H4gtz\nPokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIs8nmrRjyl6zzfXTnYUuhz4oSV3h7r+FupEAy6CaFF2AiAhQdC0UAYo\nUFp5dWuZMXGuy8QzAG96Hm2FSNiCgq1Ilg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAUIYeu6QDhKSY+SzOp+vr4hgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFkZWY4YWUtMjQwZi00NTA1LTliOGYtNDVhMGY5ZTIyMTZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRkNDg2YmU2\nLTc5NTAtNDQ2MS05ZGQwLTA1MTJmYzNlMzhkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE36EMAs9nzctWDQVqEnIGH9LwTTx60Mkb81zRjcMdpHtC1iBQfUii4O\nI7DE+/htg5H7MnY6Or2weg8reAMZoHajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIcbbSjo\n8EgE0yoNJO1rXFSvhcJTMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAI5JRaMXs4VKNFwHz3k+X3aEkjDQzyiKggTFjv9k8V3vAiApinu7Q6tdzrbq\nvzHpoDn1AcZOg2MbGP6Yme64fppE1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5326", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5326` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAUHOHbZaRxBnNvw9Wj+c9smVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxOGJhMzhhLTM3MjctNDEwYS1iMmMwLTllODliZjExNjVhMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhmZTY3MjAtMjZk\nMi00MGQwLWI5YzMtZWFlZmIyMTEyYWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+8nsMDm8XWnjcLkITivigrpuC8rZuTA5H7zkYK188li7Br5k7j9rqXLvre8W\nhmXoH/VfsEhLf4AxpHVFKOoX2KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURYi3tj7ozwTKvuH1TaWKY7qwttIwHwYDVR0j\nBBgwFoAU8+zFO8wmDz9hlandSo23P1UmeSYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHv6tkHg3yhDUws/ys6VERZ/Fjqq\nYFo/NCC2fhvAdmP0AiEAmBL/EvRferYXC5wu/Q81VgJPPNUnSCWnugciEPZcY2M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc1sLIQym0ngPpnDMWudkdGoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMThiYTM4YS0zNzI3LTQxMGEtYjJjMC05ZTg5YmYxMTY1YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1LgX948HFkwegPsEAupe08d/XeW+RPCPAPKoWny2U/f4Y\nzLnPh5EZx0LOLALjzL2mjgXCrkqGMDKUyVRdCKW2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8+zFO8wmDz9hlandSo23P1Um\neSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQLZ8olffCLmagKujI8xSxTSJ/kyXNF3TH8d3dxoMkCoCIBu1so6r79Po\nK8htwbZ2NnRf9IDbhFMOuFn/oZV87jn8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAbyED/yDV7wvHL0/1UWrBrthMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhmZTY3MjAtMjZkMi00MGQwLWI5YzMtZWFlZmIyMTEyYWQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIzMmExMzAy\nLTI0ZWEtNDBhNS1iZjc0LTk4ZWU4ZjhkOWJmYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPe4zgDf+2s/i58WD8sbd0yqjFoPRVLfzuB/I40CGXRMMojhy9q2uVGi\niqF5ntiP+3g4IZHtKRLI2ySkoLQCmgWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEWIt7Y+\n6M8Eyr7h9U2limO6sLbSMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAO3XQR3svk4sOGScuN+4+5BiiS2lQw6xO+VqZB5pBXu3AiEAiKoelGlNskkY\nXoHNlIUj4sNXEgbquHuCCaN+l1y+TxQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5327", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5327` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISASIwGkW1dcU8je/oLDQcFcGvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNzZkMDM5LTE5ODgtNGVmMS05YzA5LTFjOWU3ZDEzM2ZiNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU1ZDZjZWYtMzM1\nNy00NTg2LWFhNTUtN2UwYzRhODc5MDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8G7fodan9rkehZxahr2Kedlwx4K3bbMbyfo32UF6LcIgOt/VC5IOjcNw26cv\nwXJUxCl3CBZRl/U9RFcg8uYObKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWxL5UMn9Noblaq7qeZD23Fw6OjkwHwYDVR0j\nBBgwFoAUlvsflVH2eaYvWugN9xEgWSHCQ5QwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKLwSpu4C\nRIZK225kayXKvi3RU6S+BLz/ncPLotb3xusCIQDgDQZzlqFC3L/XGy2UBfSgnvvj\nd3+efvg02WLFyhbPQw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZXjWCE6XTqrcjrtirMwSroPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjc2ZDAzOS0xOTg4LTRlZjEtOWMwOS0xYzllN2QxMzNmYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAsWEE79R6OrlmSpsRhW6eYaW9s33ha7p1QhkDvKH2aRD+\nTWtab5Wxnh5ac3fSncghBQfeXficWuUnDsl94DS+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlvsflVH2eaYvWugN9xEgWSHC\nQ5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXoZMjyNU/SooebLz4N8lG5Zxo4fdp90uCxIkXOlAVXMCIBWh5qIxyLqi\n82yUaCNQo91fpqRvWeBO5YCekkccAQYt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAafRoIvdqAE3AIgZnBMoW7WpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU1ZDZjZWYtMzM1Ny00NTg2LWFhNTUtN2UwYzRhODc5MDg2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE3ZjNhMzU4\nLTI1ZTYtNGVhNi1hNmFkLTc0MTk2YjQ4M2I4NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOgYwQad3ttWtQ6tnwtceMGgmPuf0x3CsBen4wQeHacQTVllhR0K16Lb\nXyZXmIB1k/w2bmYh/HFWs9sz+zTUFBSjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFsS+VDJ\n/TaG5Wqu6nmQ9txcOjo5MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAMwKL1OYtbvKsgHmuVgZxmF2jWT5N8BbiFXfdEDLAq58AiEA2XY/ku0v+9B7\n+8sZ7tC3Xh1xaMlHWVUL21AmK3iuUeE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5328", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5328` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAUfDbb6BXDTDDyXSKoaEhbe2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5M2MxYjYzLTkwYjAtNDM0Yy1hYjE3LTkyOWZmMzJjOWMyMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTIxY2M4MzItZGE1\nYS00ZmRmLWJjYWMtMGRhZTZiZjJhZmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd53hZKgFq2/zUKZNFSjwoRo9TBgptrNNy6GIw42F+Rv/PI+HuUGujyx0hCRg\nkP+yQpPVICRecH/XJt9N8emwGqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqHaaPxe1l0d8iJUk8yBkBOO4iu0wHwYDVR0j\nBBgwFoAUA31t83z1TDFJstjOg7UzsCqc4rgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgOF5rnnK/\nVb2axuDpEc3K6fAEszn++PnN34UXWisUwsoCIQC3IGZL1rt+WPPYU1EWUsrYXK1L\nxPKyOYd58cRS1vfRMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYf4g57B+E5hliXhcGCLwr7MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTNjMWI2My05MGIwLTQzNGMtYWIxNy05MjlmZjMyYzljMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLuaIUNi0eX4gHqwV3Z2KKniflTKD6w6M0WWeZyUSL8Yy8\nvQVHVYW3OIV4XOQfrMubS4LhHLo8Q08ZmQRjzX0do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA31t83z1TDFJstjOg7UzsCqc\n4rgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHaUZrUibOjHnjqQFg7IUjWMVaKXIjk/DOguEFpjrqwICIC6jl1wVdqY/\n7FwxkMo+OIHT6qMuM2ftvqYRqev2XNmT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAQIo+xXqaAJ7GzL5JkIQ6TfiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTIxY2M4MzItZGE1YS00ZmRmLWJjYWMtMGRhZTZiZjJhZmVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ2NjA1YTRm\nLTRiMWUtNDgzZC05NjlmLTEyMzI2NDIyYmNmYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE1JMLAUXL4yOWPlbGR5peSh6rF/CvOM637trVFgDFC/DFDj6sYymN6I\nBD8zbJxdqPnSTeMKDf9QbBGE/6xyyzujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKh2mj8X\ntZdHfIiVJPMgZATjuIrtMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgGvIy9VxvZw1ITTFlEJ5xfFAfK2NjwvnBm9yxiNOseD4CIGra4qSwC+MTLE2Q\ndT5rdGw6q0crIrdxVVLIlaMcpsk+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5329", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5329` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAa8Vy+AAmLnpa9kkkAFkx77tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzZjkzMGRhLTIyMTEtNDBjNS1hMWI0LTkzMzdlM2Y3NTUwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzMwZTYyZDYtY2I3\nOS00N2VlLWI4OTAtMWI5NDQ0ZjQzOGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2rq+tKTcE5eY9CTVO+dQRd7NDqg+TqOsOKLiC4I8oKMZe2Nje+O754E5wZPW\nU64BM2kriURXjXJQNpOecRIVoKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqrYFaRBL09fKGYVWpMn2NkAVJokwHwYDVR0j\nBBgwFoAU8te62gIpwKSEyBqLfj9yZ72LNjwwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDA01Ps\nNhdbPjlxRc3L0bV4k0tzDPWO+lo9kQ+sDBZZYAIgRmKLpdpMSkGtyLAOmYH5H/H4\ncoa08GhdBuQ3vkzxU0Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUJfGfYCdb59cvyvkZ0BCKh/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2Y5MzBkYS0yMjExLTQwYzUtYTFiNC05MzM3ZTNmNzU1MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9YaVVV4UxeY//nOSVWM4gPWz34X3/RRjnxRbZy6LULGYl\nX8jCvkkQs5IG4sRowSJ3MgeQB7Xhckmohk+jWCfko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8te62gIpwKSEyBqLfj9yZ72L\nNjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVnlu90TgKusRE/XDeQMDEhjqKC0oMDo9Ji+AsWqWJ5gCIQDP12kE54yV\ngjc58v1jQ3zpBm31VpTlADDF+fMLcA94DQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAefgMzate76gJHVReqGVbRI7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzMwZTYyZDYtY2I3OS00N2VlLWI4OTAtMWI5NDQ0ZjQzOGZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY5NDI2OWY2\nLThiODctNDczMS04ZDJjLWM2NDZmODY0MjI5NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJtw9VfWKWw8gBbJKwJN9uEiamEQKkyYBUwl87icyHg6VoeUnI3mobp8\n4qHVVtnPZ8hYVVi71zM7bYwjynxZOdmjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKq2BWkQ\nS9PXyhmFVqTJ9jZAFSaJMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAM8bhyjoWtwZwxDAN9AXJPRnAlECqxoPKCfEpjB5xFzrAiB3mAUe17yd7cvi\nLHpZ8zNOdbHj6qQG+XmO9fEH4GWoyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5330", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5330` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAQ7UPN1d1KGYJU10wjt6VGYAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzODYzOGUxLTVlZDgtNDg3MC1hN2VjLTA1YzYwNzA4OTA1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTgwMTg3OTQtYTBj\nNi00OTA2LWJlNjEtMzg0MzZmNmQ3ZjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEflS/syVYod7Yow5T5ySYixM71DxO4rpVZZl3rsw7Qr1FHz7GZHj3h3g0YbUZ\n2eS0HcfQPsmXN+vwQjheO0GANKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtSAMpLMlXV1gxvOlt2YgQhG4GkswHwYDVR0j\nBBgwFoAUyRWpPbawhSVQO2LJd5Jvhy5lwNswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQD2Xk6TWO6eVNIoa7LeHfsd6fCzww34E1F7hvkiIIkjWAIhAO9KPAIz\nIeG4nKHs4+69V9ms1csSYcuoXmfWXfjQ8zVC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXIAOqMRSzVmRz1fJdAOFiVWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzg2MzhlMS01ZWQ4LTQ4NzAtYTdlYy0wNWM2MDcwODkwNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSPR8gXMyW1R19jZGWId49aMNpK3g527K+p+ujpvXQkIzT\n1zMjlb7CbKZ7YHlh/R/QaSVAT1tlZXJijC3AvN0qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyRWpPbawhSVQO2LJd5Jvhy5l\nwNswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALmiBoVXORWgQhDa6AmqzNY0lwZ4nRm8j4HCnPkI4cE2AiBzmTlRH7Ob\nxkGP6VHUAZuCBZ9NUt1rVCZ50Zpx9tRTUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAYzcTfKSJLAVN0GMVXKZYtlQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTgwMTg3OTQtYTBjNi00OTA2LWJlNjEtMzg0MzZmNmQ3ZjViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQwOThmZDQ2\nLTUzNmMtNDYxNy04YTliLTljM2RiMmI1ZWU5ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLH9E7qevbcRYdra25+zjFjkjksGE6XqtKBrSD6HIDAsk6e28FX6teSG\nInFwUnyAtSBrWerweWuVMbSfbTNaZIWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLUgDKSz\nJV1dYMbzpbdmIEIRuBpLMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgIoXMaohBy8eOAE4jqTVFnDn59dwur7byoquFfi32mpoCIQDpTR0e9dZB1JVG\nyrO3QuikSI19I+6ioXEEBXE2IRoToA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5331", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5331` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAba68tqcnrKdE4o80CiV0oy/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NGJiMTljLWM2NjMtNDllYS1iN2ZjLWM5MmY1ZjhiZTZkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJlNjI2MTgtYmJi\nOS00YTE1LWI0NjItNmI2ZmM0MGU1YWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2gt4ECf+/Ufzrpq8AMYLcksn24NjC2DXUSS0cunTHMySNQtSXkVtZKFnLt+l\nNvqY2rb74qrCEgE7uNedtnlwkaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFHuquhmu7iHzUVgUbxJyOrrYTpowHwYDVR0j\nBBgwFoAUDBJHM2cKu6Z1kxzuIvYXfIiqs0EwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDgcqR9gvTlWOBtlLppwGJfjSzzPQulIUYEHQECPmv+IAIhALGyvGJn\nzdKq1FIe+wJQHJm4D2uu5eZq9m12xw7ZR6Ul\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASbl96pGRqpsIqOA7et94ay6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDRiYjE5Yy1jNjYzLTQ5ZWEtYjdmYy1jOTJmNWY4YmU2ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShDC2r+3RPQbmuDefCPy6u2WK6wVV5qVqeuI4GergjTx7G\niitUZwWfrdSuupl8QLEZgiW6WqRxT+sscP4rphS3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDBJHM2cKu6Z1kxzuIvYXfIiq\ns0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOQcQ6pSjBdjEfSZvSEx38/mZ5fchbUpkYYkCd5M6TQZAiEA3F9MDo6T\nvCbMYi/0SdcdYOxEbfU4e3pSZaycM2YhNTY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAUQJVbgudmL7pR4gC8Z3izPKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJlNjI2MTgtYmJiOS00YTE1LWI0NjItNmI2ZmM0MGU1YWRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4Y2U4OTQ2\nLTFjYTUtNDY4OC04MzI1LWVjNTRmZjNmZGU1MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC8k7MQNsAnXlmsq6DBDE2t9XHZf4daIBKOyCioIlyUx8jCiv6R5duA8\nid8sEpm5+3pgluga8PIbp6+y7GO22xujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBR7qroZ\nru4h81FYFG8Scjq62E6aMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgIa8abm1uQJ/Ie9lUHmAr9Sb06DmmIZyd7U/uMPMUuGQCIE6DRXWe/iuOxloV\nxCyi4Na2tZ8J6NCesojyijEFOFxh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5332", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5332` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAWC8P6ZKFgHh+o8TgZHprx5bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwMDUzNDg3LTM1YjctNDZjNy04YTQyLTczMGZkYTMwMmU3YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGUzMTNhNWItMDAx\nNC00YmI1LWJhMDMtNDJmNDg3M2Q1MDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH529tFTJGCKGYFgzg03L+uI6OmsPZYy6fup6jzDDnUNBBBuE5ZNX/ZyVfCnF\n+SzgljCV6Lf2HtEq/BXBLMNegqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvqZxORY5gMkOPRmbkUAMkIdi0JYwHwYDVR0j\nBBgwFoAUXo1G6s7exofNDBwL2snb9Ahg/lswMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIF24A3QmkrlUoYnLv08oMCEe8asyo1mliQn6OEvpoWk7AiBYBHt/aC9hX+xFhm7K\nNYqCgYTfUywOQZhGAXADoSVXXQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATvjvvySnCBqTaSM3a/G7ueTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDA1MzQ4Ny0zNWI3LTQ2YzctOGE0Mi03MzBmZGEzMDJlN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrslaum57Cus42jRn7yVn0mAjBd9Eg+dACE2siD3DvyGat\nRQ2qsvrWnhX/P4WagvapqRDMHfzgSTtZkpvKxWxAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXo1G6s7exofNDBwL2snb9Ahg\n/lswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL72ca+IK6Yqq7vp7/BWEPnaZDS8JdT1CX1axVGPh1zPAiEAqCCBHxOt\nvrGV0ZmdJWPgh0daonVZPaJ6S8mgIgsoBv4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISATBl3HOOPIlnJcy6XdLsZuhfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGUzMTNhNWItMDAxNC00YmI1LWJhMDMtNDJmNDg3M2Q1MDgxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMyMDJkYTE4\nLTlhNTYtNDMwNi05NmRlLWM1OWMwYzhhYjNhMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFX94wB5LHyTfZvYZ0oFgKT22zNcyfHUAIv0ZUYcL1xWjfRP2IqdoWtM\nxT7ZZTd0xFr7wY1uPjYPbmmenJLqoFujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL6mcTkW\nOYDJDj0Zm5FADJCHYtCWMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAPm6USwpCPsqjaiT2DlymcH+ai5omQ7bcB/bEdAx8E5YAiAiR664gkfEWKKr\nOL/ZvkzJhKLDRIlfRyAO2nwftfMSLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5333", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5333` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAWqQ8LdZVtX/XfLfdw2zhjzoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzZWU4OWM3LTgyNTMtNDJlNy1iNmI1LWUzMTc0OGI3MDJlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTAyNTAwOTAtODZk\nMy00MTE3LTk0YzktY2Q2ZDU5ZDZkZjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDxOdHh9ONuEHRKHy++X2ptx0CABVeJbAvZV2qm68FCvK8ZOoy4NN0nX3SrIf\nAXMsEroYAkHMdCPD8KnsWmkLxqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVMc7yQtJAcVxXRpXM1FAyoYNCd8wHwYDVR0j\nBBgwFoAU/zgaEeVB11xRAwTrk0OnGCLKlTIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIAbOzlJksB89oOmXg9b7j6Gk8lONsY0OKtcNYHDU+lCZAiAo\nWE0LyTrui4lJP9pCnyB6nBh7x4+oSA/mOARmgdaATA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQjFQo9AmDDYPwn8qKNrMqdPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2VlODljNy04MjUzLTQyZTctYjZiNS1lMzE3NDhiNzAyZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdOBoOzQ1m4kHbXC1o2NpwSZhGx5BjQKfWK7s0Ek2NIw6l\nSRYlyyoQUS8rieJRNXZRp41dz9ingsbCcbHh9JsPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/zgaEeVB11xRAwTrk0OnGCLK\nlTIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPiDwGR4Q9XQGlFgRDX6D13W4o+0JuZicJ+7vZCmphe7AiBNv9pu+S//\nDz5OVydvrDhCXiFmgZDDwHhG84SGhFnV5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAWQbB9turE66+fk55t9mil7NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTAyNTAwOTAtODZkMy00MTE3LTk0YzktY2Q2ZDU5ZDZkZjA4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJkNGUyZjIw\nLTdhYmItNDNiYS1iMjM4LTI5NjY0MjZjZjNmYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEXiIGMHb9aNV0JXdUJN6G/2KtTz1SVVSzZ8Qjp5H4qWXSgFeZ5QyfVu\nS6NswTdbeMg7ofphbyIcyOsMbL+BE8qjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFTHO8kL\nSQHFcV0aVzNRQMqGDQnfMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAIH9qQuoOT1cs1/5+KexFJa17gej0ZK6aivc4jXl178GAiAbv85vN6eRPkm0\nV8s7rVWVkfbjWWfoObEH7j4bkKeD/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5334", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5334` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISASn6nQVCfBj+jpIw/gNGloreMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiOTJjMDUwLTFjYmYtNDM0NS1hNDE0LTdlZDZmYjNiNGExNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFkZjI4NGQtNjJk\nNy00MGY3LWI2YWEtMzc2YmFjNWJjMTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM8PdpGLNSqJ7an/5MPGT8iXmYawoVxAoWYiJh8wp/0Ai5m4RBY852Q9ZCK5z\ny+DaLOXn3B9E4tC2LdU8FKGhR6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS8xMTzcUrPA/qAQNw6E6v88VG80wHwYDVR0j\nBBgwFoAUkslS2rDS8KES7DdWjs3d0cIfNyswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIF+LavWRM7U1u3mBUviSQAy6kc1pFfw7UaM/gI666OavAiEA\npQFAGyeT2FHdH3GRgyNdg6Os7w6fnzXt87IZBllhiOk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaV4/qWF0Wo5nTeH/7WaFa3GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjkyYzA1MC0xY2JmLTQzNDUtYTQxNC03ZWQ2ZmIzYjRhMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQu6wqVcW3D/EY8FOOqHTy/EsJmhhwyhi7dJKqKzplI746+\nQRsEmwuReq/nj/qZiM3fM5IfkiwgTM+Lcprkk5A8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkslS2rDS8KES7DdWjs3d0cIf\nNyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOIOpmkuVDHtXL045LgT49yq43xy4bjLJFlS+2iQleY1AiEAj/N2UVQ2\nToWyMEytFYSg84VGBmS/5NTi0whvA/cqTmg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbVKOsM3sPIMFuj0Vd0DJgJvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFkZjI4NGQtNjJkNy00MGY3LWI2YWEtMzc2YmFjNWJjMTFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcyYTFkN2U5\nLTM5ODEtNGYyYS05YzYxLWRiYjMyNTM1ZjJmMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMNxmzgNbuadnZDqWmEePNgh6zYB7+gJ/ZqFafvcr4ObABbZAXDtnPqx\niPJMKAhn2hN/WJ5BzJ6aAnDqi61hIaWjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEvMTE83\nFKzwP6gEDcOhOr/PFRvNMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgMTzsTM4WYN7Hn859EQG3r7QHYsBDh4ZF62d5BNvJWCUCIQCDanDum5PfdQ0o\nxCnwX2nScxQrKeLakzYfEAMTeeoz3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5335", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5335` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYIDwOBxz7boDC7T1VxcJWyMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5YjQ5NmUyLWRlZGQtNDVjMS1iMTRmLTAwMzIxOTJhNTY2ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzkzZGY5NGQtNTli\nYi00N2FjLWI4MTQtOGY4ODRjMTc0OTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUHTzQ2sMSFzBxUrFJjok/w7RRDl3H1SwHJ1Ouxvn4i/TxFz5zP1o1NsbhGKb\nETbbAzfmvL8T/aSZcG5in6WbfaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUft5z0DpRD+v55jQ+E/KervT7P7MwHwYDVR0j\nBBgwFoAU4kpJa/+Nhs63s7rKe2X0PXPFO7gwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIH6pIb4ia+YT\nnxK9UU8oh9W0CG+C7Sc2c/OxxqWEXDiEAiBybH270ngU7AfegT1j7vfc2JEXuTiz\n/5R3/qnoNRFT+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaVM4ZdhY1n6tRer81NKhjXAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWI0OTZlMi1kZWRkLTQ1YzEtYjE0Zi0wMDMyMTkyYTU2NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcutQL/KDhhzYFtx+E2noEwMtVNwr3j2i4WC1ipNe69Rmc\ndBn9qL4x4rvMsRnzXwkyKU0quqeQ9ofUT/S80FmNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4kpJa/+Nhs63s7rKe2X0PXPF\nO7gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJlps4Rfj18ceEybWkzmsuRXuM/c+unGsB0nOtlqEycaAiEAkbLW/55s\nQzlmufzHUkn1956aU/E/vQx0pzuev/D2bjU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAT62wg3K+F1fd/HyO6QucaGjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzkzZGY5NGQtNTliYi00N2FjLWI4MTQtOGY4ODRjMTc0OTgzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNmZWY1ZGVl\nLWNhODItNDA0YS04OGUwLWU0ODIxZjRiY2YzZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPuAfEYrLY+f+rake+i3GIEYGCHjyOXHHeyfnXAQ35mJceWNdOR6sXxJ\naidE1IrsqF51o3n12wzEk6U70LAQbkSjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH7ec9A6\nUQ/r+eY0PhPynq70+z+zMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgYdwvvA1kpka5ax4VZVbG6FzAQPQYR1qbcvE8QSI6NpICIQDUtyj/r+zv4843\nBrEH/tBGM6tUdaJ4cM4T7a9x0/jkDg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5336", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5336` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQLPxUySViaH+sBykh5ImF98MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZmVkYjZjLWUxMzItNGNlNi1iNzI1LWY5NDBmM2ZjMmY2NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjcwNzUzZjUtOWM1\nMS00YTdiLWI3YzctMmE5MzAxOGE1MTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWPsQJ6g5MEC4mncqxJmZ5CCGR9iGySJ7elHGQlB6nY0QvcoHnTiyvu4V8fuT\nexH+eSa0K77o3lWz6F/mZfZgf6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUio89BbGnSbQTDEhc226oQ5JQ0lkwHwYDVR0j\nBBgwFoAUXXoh2gJcSss7SLWn5+PNWsKlMAEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhALkpTipqWjEfA5m63ETC02CQfhn4bgUp/1gyc6gf2aoWAiBaPx1jo6Q0\nhl5yi/X3TZW8sAi/UfE083til24u9hBtLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS8qTXCGH97M29gu1p1xtTidMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGZlZGI2Yy1lMTMyLTRjZTYtYjcyNS1mOTQwZjNmYzJmNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8bJRiL10BP/l4+su5C4ga2vFsOFST4TniELZITlE4GIqG\nbQB5WMnMo9zEJZCoYaqz5RT/WoVhfpfQPgOJ/gSmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXXoh2gJcSss7SLWn5+PNWsKl\nMAEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKp/t1nkL3RYzQq7wMz1zeShH4C6do9iQsbqmuf5l26iAiEAiaYe9iW2\nvaFg1zRuKh/WxeexHAprWL8AxDB+VkqGxl4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAU6JkPsQ++DOAKQ6d5ky6dXJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjcwNzUzZjUtOWM1MS00YTdiLWI3YzctMmE5MzAxOGE1MTgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE5MzY2NWY3\nLTliOTQtNGZiOS05NTk3LTYyMzU3ZWYwYzM5ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCyhXAaCVOephS3VeITeg/OzAheHzDU6+jO0pyasXpzNX9D6uw//V0/Q\nKQeWEdDDNB5fbF1erhyq2KSUJB2B2VCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIqPPQWx\np0m0EwxIXNtuqEOSUNJZMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgZMNGC2CuXRyEK4UQSMr8UhH04lqFbX2i1pbRCL17SEsCIQCVt9cjnKH/cFM6\nA06U4T/YhIg6hV1U8Wq1fLaUedKrtw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5337", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5337` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISATgiUJ3QpuWZt6susgEjLCHMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1MjM1ODcxLTlhNDUtNDBjMi1hNTAzLWY4MDUxZGE1MjI0YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDgyNTQ5OWItMDE5\nYS00MjY2LThiOTAtZGNlMDAxN2U0NDZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExHJljuDoqldyFI1tq7iT/2ez13G6cOBTNmiryS60Lg/zeeOb064M5Ys2QoOb\nm32SPChRD4xxZi995GMJ3m1btaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnYp2MaEiiCXiCwO0gzCQihsxIxQwHwYDVR0j\nBBgwFoAUvUEqlPqeA1WB3mIdOgUslhBEbpswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgVQkGTpO8+ejADScrNMyCiyMNBey0H+TfBCqGrGjuuZQCIE54IGpcWsLv\nbyzipvK4JwAU7fyqOz86yTlKtyiN9YvP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeaUSAiLdkjqMGAw0KoHoeW6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTIzNTg3MS05YTQ1LTQwYzItYTUwMy1mODA1MWRhNTIyNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0NfxM5ZlpCvKSckN40vGjMKuHZhlu2U3AWD1DieA+DKME\n44Aiwl9sKFVzbf7HTLJfzZehN/jILGY38Qrpjh3Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvUEqlPqeA1WB3mIdOgUslhBE\nbpswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfPkGBJW8pSmqqXAAb5rdvxb3rFCIWDsQ3Zo+X1z6v9cCIBy+cnCFhVy4\nnWkOfxHKRBLF1upsvU7Xez/Gi+6h85dC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAbFeoGe2ERv8CFyX+0sLI6qJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDgyNTQ5OWItMDE5YS00MjY2LThiOTAtZGNlMDAxN2U0NDZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI2NDdiNzhh\nLTI3ODgtNDNiYy04NjM4LTU2MDMyMmU5MWY0NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCYX4aIyQnJBS9A+VsgYlYyXv6h903xTXKqrBxRhF2p8s0zq044Duhn/\nJDHjwKRjoC98QLm7pOgaoFWgeMZgRS+jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ2KdjGh\nIogl4gsDtIMwkIobMSMUMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAM+m8CZwd0elENz0y+kWsRFhmUTnD7WR95950l3FWdTYAiEAlSOmzssRx6+d\njixvzIHtjpSwzKIl/a+NO87pMBf9/hg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5338", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5338` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAXDkuWCx2VPH4uFefeG4E4/SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhOGIyMDVhLWUxYWMtNGJlOS04NGI4LWU5MWI5OTE3ZGI3YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQ2YWQzZGItNjg1\nNS00MmVlLTllYzAtOTQyMmY5Zjk2ZmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELN6Pvn7nNWWQmrT+SfOnV01tfrPa9CC5FtvcKZ/Iub6WC/dT+6lyVI+cfPjM\n09eUhsTMPkIlsJmuNFz9/dmKnKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVsJSNmkWdtnHyU8fPiz5lxRc10kwHwYDVR0j\nBBgwFoAUzfqTycALjtXIk6xSjg43zBa52uIwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIDcslpcs3ZtQU//kOLz7EiMG8DRd0AELzW1yOJwCGM4RAiEA5/9KlI15\nFWkQbmRRoj4umMx17lfQ3A3xu7G/MFajLK8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbJWNLT6Z9Rp0MZwC0zrRgyYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYThiMjA1YS1lMWFjLTRiZTktODRiOC1lOTFiOTkxN2RiN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq/QPgoVgX0sfq4qt82BXY0kGf7y5L74LFfBfQ1uGa7ZHF\nZPvYnfA3PbMU88ipzuPAnxpRu1uQ8vmdqG7SdYG6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzfqTycALjtXIk6xSjg43zBa5\n2uIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJe3d8d6i852/sBtibpU/dNszrjFqqZOgS4yNL+fd74AAiAYQDox3wh0\nhkNo5V3Wt30+bMw9IAL+ClXv7QNJsg9UWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAY7nSJMupuR1Au9kWqI7D87LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQ2YWQzZGItNjg1NS00MmVlLTllYzAtOTQyMmY5Zjk2ZmIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMxMTJlNThm\nLWNhYjYtNDNhNi05YjEzLWMzOWUyNzU3ZTFjNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK5jVSlNs0CZS2lG1VWla/T4zwxYlbZZ3idaMTGkcdNDIZeJwcgorSLl\nv+fPgpxdMr3JNd2UapbubhwKf8s1zkajZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFbCUjZp\nFnbZx8lPHz4s+ZcUXNdJMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgSF98Xcs84RkVmUEC6g6j9A2YYGZLx3foBmozqbKM17cCIQCfGd39J+sZkpT0\nFvPcsMzYedrc1tZjdYJ+gsL9NUOcsQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5339", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5339` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQLwp6rVJUtA3nA1osCenAAJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5OTFkYWNhLTliM2ItNDU5Yi04NGE2LWIwZmExOGFlNDMwZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM4MDMyMWItMjBk\nMC00OGJiLTg2YWEtYzU5YTE2ZWY4YTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBeTnrnEEN3Dkx9hOGBJolNpEn9V3p3Yrfpap7KPwygJ3W5NTYpCNRCUG8Df2\nXic9vBbOR39lZyqFEsDSQMl7e6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtZ8jaEJVaOcN2YFreb1wyqk4McwwHwYDVR0j\nBBgwFoAUJP+ShQMPtYWjqGV1gguT3FaaWPUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIEDh3rluqS4GDKRMqOI9XQ10r4UTmNgWd5L6S2Qw\nJ/F4AiEAmmRryyE0FsZ47QI1YLSRKUPqYvpn1vtwckE0oaKgbds=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaSieK9ALZRAyXk99JtjRPkBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTkxZGFjYS05YjNiLTQ1OWItODRhNi1iMGZhMThhZTQzMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/kYMigXU9F9RQaauqVqng2BF9oJ+gkIDhvo+J4hV6NLT/\nhaQ7wMjqETUIxxFELCGJD55uojAkmY7cxlKBJ6A/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJP+ShQMPtYWjqGV1gguT3Faa\nWPUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIAPr+QnKfw5HabHPnj33itiVPvizQYITjHM/9Dh3WBZAiEAig2WZwel\npAHoUmIHBh/TCIG1jjzWlJyRF5VecK95MhQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAfzWJ4ItaeD57+DuuZJMaNaVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM4MDMyMWItMjBkMC00OGJiLTg2YWEtYzU5YTE2ZWY4YTYxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEwMWYwYzdm\nLTJkY2QtNDk0NS1iMGM0LTc0NzAzZTBjMTJiNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKA7+Ctp6MnF6UCaPUz1sYKKncR6EMpgqkP/aF4kKdIn6kdMDpxVXMM0\nkFtX9Yh0b2PPmp1tzMYz9W3uptY0QkCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLWfI2hC\nVWjnDdmBa3m9cMqpODHMMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAIbWa6RBAV7gTSYyoF31f6yg4GwOEcD/D6JqYxESUDA3AiBeVvYxsC8PG5AV\nEApDQIYlut4h76P4+peW06FZkeKW2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5340", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5340` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUF2P+bTpI8aMBhCCWqrQRtaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0ZTU1YzhlLTJlNmEtNDg4Zi05YjNlLWUyNWU5YzAzYTViNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ2Njk3NjEtZTQ4\nYS00NDNjLTliNWUtYjUxMjFjZjE1NDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz89j23cWqNeccFPMT5sappkuZPtN6g51rPYaXhVyJU+hMytluxGE9k51+e2n\nq27HLi0VNI8uTp6WxoyWpzuNFaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiXRIUX3/3hniyOGIirY6cpZoeVIwHwYDVR0j\nBBgwFoAUQFDXXKoKoJLz5/PG0r5VdaYEvfMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC1goyoyPBMtJtEb1fHpzHZGRAIJ/MoVtRVVPlc\nCUTHcQIgZ5j+Wn/b8uV3sCcauPtccVIynkEt+jVVWu834R+XqYc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ8oTiHk2AkXCDuhfYs05tALMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGU1NWM4ZS0yZTZhLTQ4OGYtOWIzZS1lMjVlOWMwM2E1YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQil0smQ2D51IryIpHHOYwLxKKljaMgRSu70dcYreNCLOjI\nQsgkgKRQR0A2TB4CSQ6wMr7odiJNOgFdV1FWwG0vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQFDXXKoKoJLz5/PG0r5VdaYE\nvfMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI1Q1B+Lh0TPXPAyPXaxtE+wL7u1yQN9mbme+A9dXmjvAiAb46M7RHDr\ng5t9SxI5zpHTwQOJOnS+1xNdNgxD9XqlDQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAb5skPcLecu1XPCstRPcRJ8AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ2Njk3NjEtZTQ4YS00NDNjLTliNWUtYjUxMjFjZjE1NDUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBhYjhjODJl\nLWU2NjktNDg4Ni1hMjNkLWFiZWEzYmJmMzhkMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJxkZSzkGnbV1535F2nl3mZrjD0xGFGiZEDuKEpHE7H9fwD9I5CBoGSy\n/+VFSW7DTqAlCXH+QRV95ztRp+6d+emjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIl0SFF9\n/94Z4sjhiIq2OnKWaHlSMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAIIliZQYD/o9m8AS+0IXTZiEkGtZFPNtyzCCSdu2juKWAiASZj2ab8HC/PtX\nzr+ptCuVs0ZYQRbW1PJ0v2VliqiqDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5341", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5341` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAdqQISH4UEoXGR/Tjhzk677DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMmVlNmFkLThmMzYtNDIwOC04YmFlLWRkMDNkMmM5NGVlZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI1ZWNiZmQtMmY1\nOS00ODg1LWJiODMtNTNmOTBhMjc2OGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEil7ie123vEbNCacsaVO91E5dYkMaVKJpOxbSITqhDrOGtF8KXNH5LjC8RMVt\nQE8/2NFi9KN+C2LJE1mOywUoDKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2I4MuRV3+e+G64txujsqTqM+KKIwHwYDVR0j\nBBgwFoAU6H9SPAtJaCKFmCcGdL5NdXbenEUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIH4GUP6eWkB2a/JzBUKtZWIHBwfYRt17ajQSz5RJ6ugOAiA5\nuu71VkxM4qeh/sOJEds4913kagmcrVY/RpfVR6XdMQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASa+MVsNv769scgC16NjidxfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDJlZTZhZC04ZjM2LTQyMDgtOGJhZS1kZDAzZDJjOTRlZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR72lLnaP8O4V8NmpmLy7UxL105DVUKk8Igt1veZrZYXE/0\nA3KIPgn3xF7Hy//YCYQ65ip2yGZMIiyu7f5wkwl8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6H9SPAtJaCKFmCcGdL5NdXbe\nnEUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAId6NjU18yffaBlFWUUyakJzUs1LNNBa2qwH4DhgixvLAiBWxWotId3o\nqL4NLXPV9P6iKAUefdXzr5/n51oPz0Vv6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAQlSEGlUnPv5tGK7c8a5/7wXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI1ZWNiZmQtMmY1OS00ODg1LWJiODMtNTNmOTBhMjc2OGQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQzZGM2Njgw\nLWZlYzYtNGEwZC04NzI4LTAyOTRkYjQzMGY1NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOkhCL2uE99EnATMxy7QLcVxnrJCEFYApPKgjREmLv1NViJCMWorE/6H\n3TJe03jLB2IfO5iwMLzrhN0wADSLj/KjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNiODLkV\nd/nvhuuLcbo7Kk6jPiiiMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAOW/nZiaTkf3RoaR0PIj2efzYNfc2I8DtG962YNBwoZSAiBtPkxEItZFaYWJ\nZtlNlPxdrANqweIIj2TR6hs5/q5O/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5342", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5342` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAeW8kUgHI2Byk19TaqnNrGUqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMWFiMmNlLTRhZmUtNGM1YS05ZWYzLWVjODBiMDAwNDE1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc0NDFjOTctNzMz\nMS00Y2IzLThlMDYtYjBiNTc1YzlkMTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErNdzQPBDnRXnHjRkwFP0K35Ffba7PSF68GNAzV3e4FEReRmCckgN8xJZfkZY\nncJMIb6ozt/mwliXLjjz1ogswKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcv80NUDOyEeNGJX3krJt8A7aXq8wHwYDVR0j\nBBgwFoAUYcVO5cblJyIADwq2FUpeOBgJvWowSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC598dxAZ8GVzCn5PEMB2fdggaNWkZO\nAzfDrMbLZ9DVbgIgS5Fuuv8Zukbn2tnTETFU7H0y4Tm0dVto4EgRw+cZDFA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVmptLI2tjuVzujBJPnzLobzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjFhYjJjZS00YWZlLTRjNWEtOWVmMy1lYzgwYjAwMDQxNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtuH5o/eQuVbwmEAeVknhQJFc6mimoBbAg0NxpqPfxDEik\n5NJzfs8Ax6ZF1D2awghlOqBfMo2v20mb0x+IFJL0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYcVO5cblJyIADwq2FUpeOBgJ\nvWowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeCf8+ptjJudiUTLlDw7IH+9eoCDUfefiRBr8DxMs+EoCIQDMbvPIAb+J\nL3723JxtWs3VkHe3YhFGj0xC0rLT7vftbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAYM+lRoJM+VTAtLGp+xwSGN+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc0NDFjOTctNzMzMS00Y2IzLThlMDYtYjBiNTc1YzlkMTJmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQzNjY4YzMw\nLTIzZDMtNGVhYy05NDdjLTBhZDllZjMxNDY1NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDJdIYFsygdl3C9X1KTI4R+4YiE+x1eiBGlRIQKgt5JlL+pvrUvyqKVL\nR0Q0f92k45xFGZ6CXt+/7KwBLwTkQZ6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHL/NDVA\nzshHjRiV95KybfAO2l6vMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhALfYQ/vlaoc5orP1zsE9pxNa4YJQuLBI7TwxnF5UlWgLAiEAh6Qw9Lzqk0qP\nKch1VJSxUQCxTnT+xtzX7bITBen2YjM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5343", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5343` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAc15jjbJy970qzmE9g6FfSBYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhNzZhYmJhLTBiNGItNDc4ZC04ZjNkLWUwZDRhZTQ2NGM5YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UxZGFmMDQtNDlk\nOC00N2NkLWFiMTgtMDc0YWE2NmQ1MWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7N9VLS6XJmCU709PEOe51VCc8Wr7KzPhkf+FWYO+LtOiYqmX1axnoxPHBsO7\npA673rNzSL8J5vaIGeHo81o0G6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUttTUI/rZi56EcdAAKshsBztZWngwHwYDVR0j\nBBgwFoAU/IuYRrxrObr8ySNdPFNzpS7ZKKAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBI285pZhQIsyV/tnSiBTHTRr6FeZBpH\n8WCWxEzT8W+2AiEAkmx8vEyBxuaIMnNvWXVzSew/OcDirl2K8FtTy7kmsaQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQdI6uTxknvKThoXoB6gyjXVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTc2YWJiYS0wYjRiLTQ3OGQtOGYzZC1lMGQ0YWU0NjRjOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlis137SmF2q1qP9JPk6MMlxsNrTDYIiMu8S39z5MReu5t\nfBG+en7+C7a6W2QPlMJMh8oJkKfjDpaJdZ0p5nGco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/IuYRrxrObr8ySNdPFNzpS7Z\nKKAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANcPFUItB5Qv00CKQ6p5w3mT9COjBQ9e7EnTTrGb7TRhAiAxNWPGLAAW\njDSJ9dP5n2AHCxLLE8OaqoS3dxYBJzYi8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAY5Q6TKHY+p0aFEBP1NY9V+tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UxZGFmMDQtNDlkOC00N2NkLWFiMTgtMDc0YWE2NmQ1MWJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4YzAwNTUy\nLTdhYTMtNDk3Yi1hMTQ2LTlkYzk4Mzg2YWVlZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDIYv+OQCfxOItX3dsOe34r/19kLSLY2TuifcyHeGUqAnfYFl4NJ8xvY\nJu5jSX2TfBFo1m3FKzvkyFvHixvYQoSjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLbU1CP6\n2YuehHHQACrIbAc7WVp4MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhALqJmkOmu5t9laTY6usGWeaTCdczyyisEm8kWaZR0HKiAiEAprxopZRY4XBS\nag5xYUL44QueSzrHnfShVk/OrJooCG0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5344", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5344` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARnmYWFSv8wqCmeOFjjVulg6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiZDU4ZjE1LTI1YWEtNDEyYi1hNGM0LTk3ZDQ4NWI5ZTJiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJhZDQwZWQtYzgy\nNy00ZDI1LWFhMTQtYmUwMDFhYzU5MGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERv1hcewtM5KdR93B9+Lhwqv6PNo5iw6Sb3TGWhe4Dy5lTXDPON+zvZeCW2xe\nbT96XqrYlHhUq1d3XtM51yy5MqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWu97cJKwBvU9JazCppWVxux0dfwwHwYDVR0j\nBBgwFoAUJiYXGNqX+wEs6Mm4g/Rstfo1HFkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDwUhwFI+Xk\nPxaxO4sGV8DeUmo8ZUr+Zk15+/QbmqzCIgIges21Uxa9vtMVTu8o+0hyhVeeF0Qx\nMOOqWJVQIv1JLCw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATd3QvPjxoWy9GFJ5txRqkwqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmQ1OGYxNS0yNWFhLTQxMmItYTRjNC05N2Q0ODViOWUyYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEZ/e1asP3UIpoUpoAe1UqGaxbP4JlCLD8AYBvbjqWmKZl\nr6Zhjtr9QjDlr7dqb1zVbhYLRc7L2XNBHeCswVRCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJiYXGNqX+wEs6Mm4g/Rstfo1\nHFkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOsLBoRt86JuRbF2mK7TMPPhXvAzdZM+/eMUl4aT/SMAAiBco1eXCYkg\n6ldvw2IcxVC1lHxVwHraxA4JWNABRgePwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcigAwIBAgISAQmQ9o36NG3a50Ev1uTDx4mOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJhZDQwZWQtYzgyNy00ZDI1LWFhMTQtYmUwMDFhYzU5MGI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQyN2RjZWE1\nLTlhYzUtNDVmNC1iYTI2LTk0ZTljNjQ3ZjMzMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFyL4oAGE6J3ZF7w9zZThd072Y/XL85fUlAg2bsOCOmIhkMgLFe5RDyQ\n8Fj4Z3KovuDU7FQROrXjarjMJbz/mZ6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFrve3CS\nsAb1PSWswqaVlcbsdHX8MA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSQAw\nRgIhAIrEViOiFrGkQUkMCGiEc4ABZZrWEV1EnXvNyGIx5wkmAiEA3mFqZKpdalpx\n9YwHCWZm8Ik3ciNJq/c26cCoRBOFd1U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5345", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5345` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARaM1MwG2c5Erl81OlLmVyYAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1OTI5OTNlLTZlMTItNDM2NC05ODk0LWQ4ZjgyYzkxMjBjYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzYzZDcyYzEtNjA4\nMi00ZTc3LWEzMWYtNmMzNGNhM2E3ZTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELuAOe1Ph0/1Xr2aJsK+laSIWH2pBPqzt5N9zbU8vp5G9iZOJeAavDD/vqIIW\nEy2Nk4vPSqDDDPErV/83Gli0xaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsCg3iS8P7kr/PoWTu4Mzm0YiDxwwHwYDVR0j\nBBgwFoAUtbE+es7G2dfmxrqxNgUjQkgNYR0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgXoQpvlMwKTznQiyAnQpN7wbeTQnb+QG0+qiNmwcredACIQDptqkBNxAf\ny45S5NLu8aYaGEYG9AA3oeyx9980W5GXng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATLHXj/8CNpc28vBpxcnnU+qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTkyOTkzZS02ZTEyLTQzNjQtOTg5NC1kOGY4MmM5MTIwY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASI4jbXHSIbp4V3mauPKSSVV5DW1S7kM1q3a1iwGZ35d4y1\nYXgkCICOqUmSJb08UUx8JxcVD3DU9WqSNLu+f1Gzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtbE+es7G2dfmxrqxNgUjQkgN\nYR0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTwehzZ4dvfNFreFkcQoxiiN3owszFLIjkIaaC3E/wSYCICkYi1zhRNX0\nP7pOmN4lfpzcDzWQ89ZTlBcw0U/9iH47\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAeuJdAyOqLSc5ghJrxJcv9q/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzYzZDcyYzEtNjA4Mi00ZTc3LWEzMWYtNmMzNGNhM2E3ZTJhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQxNzI4OTg0\nLTMwNjgtNDU0Yy1iM2Q0LWQzYzQxMjQ1OGQ5ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB9HNFfIyv0hfilCbMPBo3N/TjvpzB+BQC15v4L0YV2exMgLhXUbG+71\nOJxFNhfe1fK5a3PIMZEllx4BEnhs9A6jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLAoN4kv\nD+5K/z6Fk7uDM5tGIg8cMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAKqAAnj5B6WR3uy571QoxFEiPbNKeEPX+ouZSyhut5EaAiBsjts0KEZa7c2B\n/0o25KlOR2H85/E7MWwZtF4wBGueCA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5346", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5346` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXgJoc5ufkailMtyjyYf5VFfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NmVkZTU4LWY3NzctNGMyYi1iNmZhLWExOGNmODdmOGU5MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcwNThkZGItYjU0\nYi00YzI3LWJjNDItYmQ2YmZhYjlmNzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE44/heTydZjxMzL8RAxKTFKEXWf/aHHzWH1J2koIax2TLIlvp8IoUbB16Ox7n\n8wAMP61mXbe42dGNWJFmgHdwiKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6aEZlt0vM1t5dEgGTTg9JX32h44wHwYDVR0j\nBBgwFoAUqfqh23WUMJziRO+vQEys1i7LXG8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgP0j8IZeD6U8SO88WFMty4GNNcIClOPJfc6p6vZ/KaO0CIQCwJm7eDcIn\n0pddUwfkHaomFXkoMMwAXNPO2r5Af9wnBA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAefOpovWpYJl4M9F7aL9DNZSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDZlZGU1OC1mNzc3LTRjMmItYjZmYS1hMThjZjg3ZjhlOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASs4Dhnvm7MzKKOghD2HFqNDtMz+wjH9SjWR0umI8gkH8+3\nt1vHvYITy9gCBCPp8i0o5hp1B/yFIDJmOL/bWo6ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqfqh23WUMJziRO+vQEys1i7L\nXG8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL4/1shBYRfBJd2/FAoOSdL6/o932+Wrrol0WOYhIEp0AiBp3QzCpHEO\nECWP5gs/GZHqMItG9BuA2ZpsFNvDa096YA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAR2la1KqxfHBLFo1I3yfsKDgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcwNThkZGItYjU0Yi00YzI3LWJjNDItYmQ2YmZhYjlmNzlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQxYzkxMGY3\nLTgzYTUtNDNmZC1hMTczLTU0ZWU3MDE4ZGNhMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAl3cu6q2nFN2zI8OgYp2BPSsTpqbkuxMHlKHykEpzvc+RRmzsIXhNp2\nOruxSJpiwCLbt8+o8ydh3tk2HIj3M9GjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOmhGZbd\nLzNbeXRIBk04PSV99oeOMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgZme7i6M4aJoWbRbMLOOmhWmt3vnpzupdB//RBLZ9pSACIQC9tafmkUaInMs2\n9+wEkt7i8P0Kgny3896uf3FCaFMwog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5347", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5347` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAW5Ar888BqMMG0GW20OndXRLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMjExMWY2LWQyMDktNDZhZS1iNjcwLTFhYzI2OGYwZDAyNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M0N2Q3ZjItMmE5\nOS00MGEzLWJmMWMtODI1ZDU0NTU1ZGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtowHv6RoUhNdNc82M7Mcd4PPidi0iFeAMfZH6Q6nDVBpUPiim2BQVYkzzXqu\nPjgBzoEKfB39vG0sj8OYqOzV2KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQHfKer+fA3ImP1kOrPlsRLqoQAwwHwYDVR0j\nBBgwFoAUuCL8/r0qQew+u8eS5To5psflw5QwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQD+ILSYakXOnFweaoxLevqwfmn4EQtWy1OdQoYEsZJF7QIhAKUphurA\nAg+dyXEBKeJgNt1pGpahOYFqUprAoRGf27Ax\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR2JsA8MI1zW3ECgk39Zq87zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzIxMTFmNi1kMjA5LTQ2YWUtYjY3MC0xYWMyNjhmMGQwMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrsACh06IqVHsG2eOlZN2znLUIwX85Uq+jQ313zvDceXlR\n1BWiMacj+tsmj28dyOBRtpzNhcOUNUfykT0xLg1po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuCL8/r0qQew+u8eS5To5psfl\nw5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW3wsx+owhu6GZnr4QF0Efew6tmQz+6UE0eaHqPO5NLECIQCO4J8+hPUp\nryjNMWkS8DaBzUClp8hYzyYFj92+849KBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAWMD8asorLksC/mTVW339QRRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M0N2Q3ZjItMmE5OS00MGEzLWJmMWMtODI1ZDU0NTU1ZGIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhhYTk4YTVk\nLTVjMzQtNGYxOS1hYzBlLTQ5OGMzYzYwZWEzYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDlig0yLiE6bcuSrW4lYVxkuCO3+2/z0q6qVs8Qar2cBfyDSameyMtTL\nrTsdDzUWGHoppEwBq+roCI1+hHCWG9KjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEB3ynq/\nnwNyJj9ZDqz5bES6qEAMMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgdbjegkKDL/+j98fTMCTbfMoIg2ic6UywXgWGsLtZJ/kCIQDWDhcKFmRc83B1\nm9clSqAR7WHy6kMsapXTYeri21UdzQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5348", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5348` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAV1QjN58Sy2UDfBQs3tr522cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2NWUxMzEwLTg5MjgtNDY4Mi05MDFjLTA1Y2M2ZjFjZDljNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRlMzZhMWYtNjJj\nNi00Njc3LWI3NGYtMmUyODA3NmNmNWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAh4wvtpQYUtjDp1lWBqitB7u+E7UIGVNiSpR+HGueohUdM2JESeFwgUjdOT+\n0N4TxYFtqXio5TxA35ZROMaauaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtAo0dQZqWf8epJzzkW/NVFfNclswHwYDVR0j\nBBgwFoAUjUe4/ThDYT+cl3iEfSL6oJtbq2IwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIG2wnmxQUUH1lKzdmf+OOkQIfkSW5u9vVdULcHCL\nO+utAiEA18MIo8LH7OJzzkCTrfEFmTATnPZbCk2e8H9PH4Y+lgo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXoChWDFKOvBPdcpqIKEVkWtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjVlMTMxMC04OTI4LTQ2ODItOTAxYy0wNWNjNmYxY2Q5YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2jgJlElwwIOTlRwWPP6u/eeYwDDsQWR5HtHfM/Goz2Hdd\nOB3ericOYWnez5CxGOmObVxwH57NuP5tvVboUVbJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjUe4/ThDYT+cl3iEfSL6oJtb\nq2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKW0GWs5Ln3cWez+R94g8y/0XQWsRPKDb6/ZD1+cwr9kCIQD5PehnBITN\n7i07VFBeXdNpmfW6kXcJAXoxy87mZPCSFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICITCCAcigAwIBAgISAWehptvebu5NuFjDxVrqgT4MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRlMzZhMWYtNjJjNi00Njc3LWI3NGYtMmUyODA3NmNmNWEzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3ZTZjMDFk\nLTQ2ZTEtNGQwNi05YTVlLWRlNmY0Yjg3YmExNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMBdl/w9xB18IlCId93tvRpNFibW7rRvOs4DWzPxXn594J3q8Uq1jEiT\n3LELbpu6in1JkFmxG+DWQtjCImTgfgCjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLQKNHUG\naln/HqSc85FvzVRXzXJbMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDRwAw\nRAIgV65uiwvf4Wt40NE6ZCkcet8jB+Uq0Gv+PaMYu5xTCg0CIHzRR/by3UiFNTfb\nlNljvZ6pKEXDy+uHxG/f119syxF6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5349", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5349` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAduyrM3yBDJoP4ApnhzbpxfPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhMTUwNmE2LTAzYzYtNDM3MC04NTc1LTk4OThhMGU5ZDZkMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODljM2UwYTctOWQ2\nYS00Y2Q0LWIwN2QtODNjMzBhMmM1ZDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvFSlEU28aaiwlMn4MW5UAQsXtdNqoqCYqGvuTz9rTI92A64p3/6sVHleP1Og\nIFzyga3ixCatqXWfPCaaopbGi6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnN9CzJKrK+WQoN3pscClNzzc/90wHwYDVR0j\nBBgwFoAUlhHscw3htseFSpiOftjTQPKL6SkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIHZoF7AponXUAJ1FDfMSjokiUcjzZuTqSMOgzeez\nc5/YAiAY7BsAQSPHXgO7gH7wuEckeIQCr5qaMd8R1qqUZRt1zg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWZGAW0VZuc3+80gbVow5RztMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTE1MDZhNi0wM2M2LTQzNzAtODU3NS05ODk4YTBlOWQ2ZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtM20FcGwJtxWceQzaeAuJMu/eDnbF1uNsZ5rv1lNt1xhi\n2sD7xlIg0f7W+VVq8L5Q7+fmG2CE+nI9VOej/NUPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlhHscw3htseFSpiOftjTQPKL\n6SkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIlHoWxQqlGJYr3csg0m4BmHZeFgV/x+LUuarZ0OzdEiAiEAwzJ7HYY3\nuGpwBkqQj70GIJp5biqSW3JjuaL9TN/FHjA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbS707UQ4/C6luPhFdE3ASNLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODljM2UwYTctOWQ2YS00Y2Q0LWIwN2QtODNjMzBhMmM1ZDg5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY1MmUwZTU3\nLWRkNGMtNDBhZC1iMTVlLTUzOGM0ZDg3NjJmNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNpCbwVCCCh8FzvUdhmhrLCYIJNNCyRS5uEAFXwTza4ZCiTxBM7DN7RM\nfjtfosbBs6D7dz2ogLEVpW/Zk6EER/OjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJzfQsyS\nqyvlkKDd6bHApTc83P/dMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIgMo09x4DPuhUh9J12AM8MKvdBMsAiLrq9SsSqvY5RTqcCIQCFIypD3itBm+oG\nTLkvZ/jr9usfoBxhidvRQvs1k0DO5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5350", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5350` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAV6ccsXJ6Li1qM+X3MGuTZ7eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ODZkMjkyLTk2YWQtNDUzNi1iOWQ4LTY2ZDZiNzRkOTVjNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ExNGMxNDctNjBh\nZS00ZDU1LWIwMTUtMzRiZjNkOTZhZDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGs1Ow/SCJC/sJ2e2reOW4GzH26HgLZ1V9zQPKgZvC39UrilTPhBWZXVjHMqU\n3rRpOsTwzQ0WgtU/uBDEnqJFH6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgK4HTewjMVQR3VZKCZHX44NlN7AwHwYDVR0j\nBBgwFoAUMQ4cTvuVBBRN0sF3TKq/j73RHaowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIFAwFZQbrAFJSwsXXpOdl4OauCWTfxpgNjBaevxT+lgbAiEA\njAfNhiclJPL8yglTxWVyOAii4S/Trvlw9inTkeR5+jI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARfeXpuwC8Ld8X/leGBX/z7QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTg2ZDI5Mi05NmFkLTQ1MzYtYjlkOC02NmQ2Yjc0ZDk1YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJl6buK2eaK3CJF0n6FSVCgjJWLpC+9LKSLk/N+yEMD2H7\n98nTl/21kq+POAtad9RqxHWOgfTTarnLdDbs4ol2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMQ4cTvuVBBRN0sF3TKq/j73R\nHaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDBzXysqYqARnJIQ5GEVoa2QceURjW0IRpgOjPMBal0oCIBKG+uV79oqr\nLcVcGIGmrQsLyEYlwKCYmtQ0LtMoT4Wm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAZm+qx8cNEmXpE0d207sUd9uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ExNGMxNDctNjBhZS00ZDU1LWIwMTUtMzRiZjNkOTZhZDkxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNhODQwYzE2\nLWVlNDQtNDZmMC04ZmIwLTM4YmNmOGZiNDQ2YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPPmF7NEeN0LWRO7X+2jUpJb+KBrHtG9fFmaQc7PRGA8WGS5LIJoI/i5\nox3UIAMClPRjFvPFuZwTyYyMVFYsV+ujZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFICuB03s\nIzFUEd1WSgmR1+ODZTewMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAOxAM7TtdrEYMeFqD9/bpfKx1Ia42pRGH/WH0NRnetPLAiAlhrr9PHLWzMKy\nxtEq320YlCgD2+vamwTlHAj+jwWdMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5351", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5351` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAaqtSY5TR++YWZw4vJ319vzBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkOGM4YzdkLWE3NWItNGIzNC04NTRmLWI0Y2UwNjNmYjEyYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI5ZWI4ZjUtNTU3\nYi00YWY4LThkNDQtODkwNjNlYTIyNmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELxTU7+nWYEIDY183fMHSLZilkPGnZDMoc6BNM9mwLsCsCDFwPBIdpNcGVKUd\nJBhxM+gye19yjqdTlg4Ee/DNSqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyJhvBg4EkEsOw1R0mTmlaII++y8wHwYDVR0j\nBBgwFoAUgViP1ATGVLMKrqCSTmX6PWywMf0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDQnxlt4S3ZHn/V8CWArUrv27LsrbWh\nYLRWEFOUyc2XMgIhAORmdrzlpe2ljy4Jz4LEpagXKQukrhjNJsxtxgEjlY5e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaz2wOJaL//2wghCGM237Z2GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDhjOGM3ZC1hNzViLTRiMzQtODU0Zi1iNGNlMDYzZmIxMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdqpvszy1jJCJPPfz8amQDhfjGsAGQn3efG9g4QmFWL4tF\nM0HsukFD9+qiKS+ptJG4XQoOAkwhKl5iM91drW4Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgViP1ATGVLMKrqCSTmX6PWyw\nMf0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNrlrxDtPheOikoPu0UIWaA5x4eYMhWMlYTD0WcrfSugCIQDK6XSea4a7\nrOiC/xFOxec4YP1ZI4Hm7P+igt+1LWgFDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAbpb+32pOPTWBmefwgiy2nDxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI5ZWI4ZjUtNTU3Yi00YWY4LThkNDQtODkwNjNlYTIyNmIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE1ZDA0OTc3\nLWY5NjUtNDJmNC1iMjgzLTM1NDYwYmFhZDk5ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAKBs+O0BoZXN4Tsjj2GT8f9Xnw+XGtU1N3Mr5AAxCgJiCd5H92jhthK\nkm8v+OTvfCyayjFr7+hgz9QD1InXC62jZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMiYbwYO\nBJBLDsNUdJk5pWiCPvsvMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAK9ALYukee/JVIZsMekiv2RxgDiTrUPI4bPY/QoLtBqJAiB23N7bSu0Tyr0C\nwZHUGm/IWR683B9/L+DtZP6HfUxaow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5352", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5352` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAY2x6pAMQsEAfVN7MCf4YcRzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4Nzc2YzAxLTgyY2UtNGVkMS05ZTkwLTNmN2U4YmYwZTIzNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM5NGUyOGQtMjFl\nYS00ZDZjLWEwYTQtODhjNzIzMWUzYWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBR3qfZOvIlJqzpLKdlK3QHexxhNRe0ZGxzXHQ5vSAvXKVvjmtAxUVzet+FaT\nqAqKvEBBqIM5U3DJnhKQ5HP206OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt87e+GdJ5O9rkpKaPKFw8zV80RAwHwYDVR0j\nBBgwFoAUFJoTKXl4duMhffKt21tUvAx8KtwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD31RiGdZaHnokOoKqLHbexrvGnF+62\nin2M4UsUJltrUwIhANYK3/Nf37Bf9baDjbKbqg8YxVsBueNMUmMa7pPMrNaD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATtL2JX3PoCmiW4Xt0lYySRYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODc3NmMwMS04MmNlLTRlZDEtOWU5MC0zZjdlOGJmMGUyMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHoQySkoQUHe5Yu/n1uOuHH5sqwONev7KdD+TqBYv9DY/C\nQ5XNZAwxwoY2mKOu2aLuwLCBXzppJ4mpPdEgaHQMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFJoTKXl4duMhffKt21tUvAx8\nKtwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGsd1h5ltEdQJr+BBElLoloFWJ5Uxe249rqAz6lfeDokCIQD9MCtffjer\nqLzVJywgzKGqSMWSAtVPc2tm1P+SAg2sQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcigAwIBAgISAWlh1SGcGdjW5evI3hj/SXcEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM5NGUyOGQtMjFlYS00ZDZjLWEwYTQtODhjNzIzMWUzYWU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQxMGJlZDEx\nLTVjZjktNDBkNi04NWFjLTM3YzIwMmUzMWExMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGFSpVjKLyd8T+O7P+BLOAOTDx3At6DRCLKL3l9NRz9feXtHUw6U7/Ps\nWiDZ9BWJ3sQII0d3C9jdx4ykRpQBaCGjZzBlMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLfO3vhn\nSeTva5KSmjyhcPM1fNEQMA8GA1UdEQQIMAaHBAEBAQEwCgYIKoZIzj0EAwIDSAAw\nRQIhAKcp/O2B1SYUN55s3PWSys+IqkRE4YyEhiwJuOLIYvMZAiBNKwz2zUStZsJM\nGFd9tpMVbggQsSv88GspuIwA56hv/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5353", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5353` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASvRmkdKM6xZsJyiO9ICUtJoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0OTA3NzJkLTdiODctNDg3My05NzIzLTQ2NmEzYWM2M2E3ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYyYjI5N2MtNWZl\nYS00ZjEzLWExZDgtNTBiYTlkNDAxNGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpSA2mIJlvenypdIh/O53WjpCEWd5yjfG6gnhZM32LX+H8gsLZZ2IQd+L5Yep\nElLC/NePgAaFBgyqgmBdfhWyTKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFF9AjKYY4cMAs53uTqjxVb2AUMQsMB8GA1UdIwQY\nMBaAFAPkxaMnoMw44QeBgozzFecgp/zUMAoGCCqGSM49BAMCA0gAMEUCIQDRnLc/\nKEx5+k0m1O5hqrkce6ixuLB9utSMfdNXlz4sMgIgE434msZ5TmreFOJiSsq8tdg7\nL+6KZp/URt4AAmp+WSg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXzbXzIGx1so0vBdkWmiAUu3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDkwNzcyZC03Yjg3LTQ4NzMtOTcyMy00NjZhM2FjNjNhN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3377OGWjOKr8xOe8V45RNNdutC36Tg20XgoSxuiE4NAWz\ndO13GB2o4EMQj+xQLTUtTllzavNm9noXiaKcZ7w0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA+TFoyegzDjhB4GCjPMV5yCn\n/NQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJzM3wPzA9RuUD7L6l05QziNYF16NTBc4mBFjufsbZLoCIH8COu2PO6Gb\nryPDbAEsHhg9x37yToZrJ8BP+jPgSlcr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISARnC7zGvscLPLAODOVn9f32WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYyYjI5N2MtNWZlYS00ZjEzLWExZDgtNTBiYTlkNDAxNGE1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkwNThhMjcx\nLWExYzEtNDM4Mi1hMzJjLTY1N2QyN2M3NmNkMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABApA+H/peDXW79qrRVoEqG3dyCMe5uluf8Nwx/SowLH+NiXch/ZOE1Xp\n4jfzV4EmWYh37udI4rDSIXJpHJXL4rijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF9AjKYY\n4cMAs53uTqjxVb2AUMQsMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIFDPoot/gEwfqpgHERQwbk0flHvipbPphw5raTSkZnPXAiEA\n036ZlJgA1nP1ugsW5C2Xf9fd+vSTCrCPESGpjJf1Bzw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5354", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5354` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAV/P+I9DvbIU0GXJhsbiSWlnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhNWM3MjJhLTgyZjktNGVhNC04NmQxLTliM2VjYmIxNGUzNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY0MDk1ODgtNGQ0\nOS00YzNmLWFiMjktYTkwMTdiNzhlZjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBawQEUUo7jmyWBCZUnVYPbw4lAz91I2N8GaXTLpBo9AJMcMKyQQpsGx46iOq\nWq2GKpG5WwGrde09YftPSq0NN6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLTZbG+UMCWXRNQDYYdZIxDxvGEVMB8GA1UdIwQY\nMBaAFEuolIAt90UZmnAEgp/E1Ensa85MMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAzkk/sHMy/50Vc7F6EuAptEtw6E9hltEj\n+YWzAo2X4vYCIQCl8gDDWgaPoCHonzKL0NLe2YoYOh5r8qNpq/Qoid7+KA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAci03QEJZoNA1vK6zyV/jIOXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTVjNzIyYS04MmY5LTRlYTQtODZkMS05YjNlY2JiMTRlMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwGiC7Dm+uVrRlB1FPFXFCkJXqnMmLcJ1IEAWXPXP1JBpq\nSxEz4sze3F5LM4C1lbG5BjYUJGdMo1FDQt/68kTdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS6iUgC33RRmacASCn8TUSexr\nzkwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKLRwpFF8JPUeV+hHd6OWN97APc+0JZvF9Nk3AdBWzNqAiBXFy6DHNCa\nLlAZZ2UcofKBYbz8XeCUcxuudREe5F3j2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAeD137bdl5XrwTihxzYxSLDtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY0MDk1ODgtNGQ0OS00YzNmLWFiMjktYTkwMTdiNzhlZjEzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFjMDg2ODNh\nLWIxMjgtNDkzOC1hZDAzLThmYzBiYmY5MDhhODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE1FkhAsrYa5Fhk4bcDX4I1MBDaBoOl2v4WASOAcs85QooMVGtUo7Ai0\n+q6bC960k1HapGFDFE8oQ1TcDJ+85e+jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLTZbG+U\nMCWXRNQDYYdZIxDxvGEVMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQD4FXODroBgOOoTvPeKNittqhIJWieXaUxG/FMQzzCttQIg\nZ+WpMYPO4YyzDGibhWGAh6hRQi7kvoHM67m+llxlcpU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5355", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5355` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUdV+P72hZDmobvUWDZyROa0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMTQwYzY3LWQ5ZmEtNGRhOC1hNmUyLTM3ZmYxYzA5N2YwMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzYxNTk5NjAtZTVj\nMC00YWJmLTkwZTUtOTcxNTMzYmUzNDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0uH+2/Yh5venobzhzU036HAdbLPJWe1so4diYnfqH03yaOdxT4wsCuoG8vi5\ntnMq6xD28p9eS8pR+7oqP33+B6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFP548TeF9o2lmvqLQoQY11SzprWMB8GA1UdIwQY\nMBaAFE7MqTDgHGqLNwZIjSz47cq+F8izMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA80WsA4z/E6OL4t5bjPLD3uPVWqHpfn91L\n1JS86ooMYQIhAI98RUN3ys6cz71yCEWB0gBbB+sGvpoPEq6CtBOzwfzy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW3O7uvjsMtJ5xeVlv1aRLu/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDE0MGM2Ny1kOWZhLTRkYTgtYTZlMi0zN2ZmMWMwOTdmMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfZxI59q/wBdRDvP2ftKmpbXSBqzY8S/YlUrl0z/rXKA4Y\nzXtcL7Kc6WasnuzPIa/mcNcgckIgm5q4yRknZ8cEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTsypMOAcaos3BkiNLPjtyr4X\nyLMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJnFyyzolfGO4mZcxl3D+sk6b3MmsumNATc0nSJTG0OpAiEAneKjL0Qc\nGkkD52FBmtkCKJh3GEyFW5hOuZM5VPi30lg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISATH7tdU+gwRcFQgFmcOtnZOlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzYxNTk5NjAtZTVjMC00YWJmLTkwZTUtOTcxNTMzYmUzNDVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4YWQxZWNl\nLTAzNWEtNGEzNC05YjM0LWRmOTk5OGQyNWM0OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB6+Iomip48yU+w1VzjhJe5TLQqk7lHYnSGBhvXN6igedXMxSXxiXZCk\nS/ghz6G1H+9DAuGe9WzrMCo4aoLTtTGjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFP548Te\nF9o2lmvqLQoQY11SzprWMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIAeB7sB8HohHl0KX5YkVyUcE0CquyYT4k+IDlwooF12DAiBa\nf7o7i1rU4geX22Lb/2o2d/6M0VfX+xn9DorWVAEVRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5356", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5356` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATWZQFrrL0JCUH9aGi4URyssMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3ZTQ0N2NmLTkxYWEtNGQwOS1hM2NlLTZkMmI0ZjZkYzg5OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ5ZjQyMmItYjIz\nZi00ZTE3LTk0YTgtM2MwNTJkMGRiYmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZUWZmztCRd2nAINQ95Qnu0hGye9u46nUj7afJ8yubYy+dWLIRs68xAQTMetW\nxw9enSVYczwHEFaLYmT+vFzUnaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTxTFzVs8HM1hLoI80scsH3KFUrMjAfBgNVHSME\nGDAWgBTB8DtIAKnTSajPIjnyt31rYN7/uzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFmW0cfgFrD+E5YlHUl2+31TgFW2yh4Y\nGupHYE0av8LlAiEAuEttAwztXwGkIVRlw3lEE5j50cNmYHr7BxYtR+DlTJ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYPNEtbrBgww68rldJvGK2e7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2U0NDdjZi05MWFhLTRkMDktYTNjZS02ZDJiNGY2ZGM4OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPZsvOzbaJsR64YHzFD5esqiKQOeAUrspeZN7VPeZciXqd\n4cnFRQll7dt/cx+4bV3Q+i0ijxyS7zSPCYLlfDYUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwfA7SACp00mozyI58rd9a2De\n/7swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ8//HDxqpOiShMtrQmMrNV86ktHzoIkZ+IPposVY6/MCIBLF5dXP4oTV\nCFd6fNh5yA5mNB53SN6XNlEsu5hNz7dX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAcvnyUVJ6k7WN/7fI6cO3ttWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ5ZjQyMmItYjIzZi00ZTE3LTk0YTgtM2MwNTJkMGRiYmQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY0YmI3ZGIz\nLTBmOTAtNDdhZS1iMjcwLWE0OTUwNGEwMjA1ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGeyelcMsImJGutJKtTL+XZa59spGbZrfdiGMTTMCKUBEhjSHJLB1U7a\nbR1/hKfIZDNPL/mPGlz3Ssvgluw8n62jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPFMXNWz\nwczWEugjzSxywfcoVSsyMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIFOOJUXnajCj3JC5hNWJdT1XxufhJz0TGbCr/edzxg4JAiBO\nrZEl0drEoGBUh9n1uRbcXwMkq+qGB5x4TxgcMIrd9w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5357", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5357` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAdZ5CNsnBMYj8/BPO9TsusE9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkNzNmMTc0LWFiNTQtNGQwMy1iMzdiLThhMTAxOWY5MjBjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNlMDAyNWQtOTA1\nNi00N2IwLTgyNWQtN2NlNjY0MWNiYmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzgzsCySDkLEFEqu4Mt4gfVCM8BTckNXBunrrS8hB/rKWtkaBOcXhUYIl/ktL\nPpwN4MFvu4MD8QhrkTDagypZg6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbvhZk1b6j8ONZHQsQT50JvxnndswHwYDVR0j\nBBgwFoAUOXHAaTLg+Y6OzzaZI60zfreP8ZswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAh9SuI8JfzemDcXn\nupesl7wk4wGLEnK5a8akWPz0k8MpAiEA7H8qD5qCTVNV0anxSqTArMx0GTe6DE9F\nThxrDevBZ1M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcRrsExXsvhygG18CXsazTVYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDczZjE3NC1hYjU0LTRkMDMtYjM3Yi04YTEwMTlmOTIwYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxGlyJnNxQXVS9ZoIYFZIHTPrODxBrDjwpTeN82FPI7udK\nqsa2OLCfnOYFzBaL3Pho3ft8c8CgceY7dQCV5V9Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOXHAaTLg+Y6OzzaZI60zfreP\n8ZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALAq+LyBeFTOo+AULr4XjjIn9jRi/kLYg9xn0TlfRFFTAiBD3My5svW9\nbmExs0btCVAtbGUaIQQFAfngr5UGg26kFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAYj8cpR5NedUioNB3Q4rkcm+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNlMDAyNWQtOTA1Ni00N2IwLTgyNWQtN2NlNjY0MWNiYmIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGMwZjU0YzMz\nLWQxODAtNGM2Zi1iNTI4LTUxYmQyZmJmMDNkZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABANvrJQV+X8d8DwW89t82y81AckTFdRDSjc8JONAoCjIjyYhTiNC9x6/\nkVXaZo7G9986LAyFoiOiEUViQM8nSVqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG74WZNW\n+o/DjWR0LEE+dCb8Z53bMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCLHpJNFaBSKtNljqX+pdYySKKoAXCKto1hyKI19GdHPgIh\nAOd3ItM2u4F74jyJw6KIMoCFeHUCNsUZF/5/euIloXSa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5358", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5358` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAYF77zWYI4WspeFDDp12pw88MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhZjZmYjI5LWJhOGEtNDU3Mi1hMTc4LWVlYWFkYjVlMDUzMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzIxYWY2MDMtNmEw\nNS00YmE4LWEyYjYtNjc4YTkxMmQ4MjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoVVQxV5qKUCFLGdVbsH5os5HRmf7v4Fa2isuVvL8nLfEUwgjM/sOXyxKYbMX\nQz87vOoRLfsq8AbtNhC5WvkfraOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnuL79YaIN1eyG2zjwQH0u55fqrkwHwYDVR0j\nBBgwFoAUh7gKnQvyurRqjVowItLX6HkkoZowJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBXIhbZ/02lHxRM\nRp1bhcyo32IwV4B/nXANaeEVU+LpewIhANLUA9FSouDReQZns10/h2Fdeio7Wv4a\nJxOUijheoIoD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXQco3C+6cuK609kqIF5DCLaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWY2ZmIyOS1iYThhLTQ1NzItYTE3OC1lZWFhZGI1ZTA1MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOrytK+QwcRYvcHKZ1IeiegcurZhQXxKxlx9ivpvEOb0H4\n1D2SvGiGVrmWyt3w0KNsiQDhxF9r08e//xmZ1TZFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh7gKnQvyurRqjVowItLX6Hkk\noZowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcqK1MEL15gXwYf6/IQ9fCO9T3FodHCQa/dwqOmlPyecCIQC8Uh8bXjVz\n2Iq4YLcuLYPDQts0HPxVBGb8FJXWP2DM+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAedu5qPe5SBIDEUpbKNhgonJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzIxYWY2MDMtNmEwNS00YmE4LWEyYjYtNjc4YTkxMmQ4MjlmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhjOWQ1OTNm\nLTM3NDktNDdmZC04YmUwLTBhOTdlY2M2ZDU3OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBjp/SDTiN8rLxokaTRwWPI7391HQbI17KMgvpO92Gj2oZ1LqvgssErQ\n4OFePtIAmSrRSaa2B1q5B6X6UXJMT56jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ7i+/WG\niDdXshts48EB9LueX6q5MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCyk1aUc1h181vPphX9cIU3nNDXFSwiN6twY+RAKc0ZUwIh\nAMlrFUoKb4Cy9/9q/RpQrnIt10YqD8gumbfss4xW4u2H\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5359", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5359` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAeXq3+qPZosa08dNjH39ffpGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczODQxZTNkLWQ5ZTYtNGM2Mi04ZDBiLTk0MGVkZDE1NTVhYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM1MjBlNTQtZjU1\nNC00NzdmLTg1MjEtMDI5N2U4MTk0NGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUGwq6CoM4qzlLM0Qyt0FEz0mXqfyhWC82rBftutrwzJyCPOH0Etzh8bnEKwK\nnmiNVooyWJKEa8KbNr7xpLiXGqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCz4pYXPoqkHfC2jf3AYaQcgqMe4wHwYDVR0j\nBBgwFoAUQGHvzuNeHh0OQ8N1f7H6xPOsloMwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAgy5WgChJzmrklseQ1X2g7\nbpsyiq5jRjHUfK3bsthSpAIgLJa2tdzO9yxDdQeGceRjPG/l8XkHS7AMaMHfQ4hu\nqdw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATnz/+/YDZ4LVeMIhRHdQRzWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzg0MWUzZC1kOWU2LTRjNjItOGQwYi05NDBlZGQxNTU1YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/4QwP5RPrHoDj7CBr7xeJJRXhXYN+FC6Qu75Wl+Lkn4Rf\nkdy+2E8Lnkvea+ucKtDtF2GyproYNnRYfQgUiZY4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQGHvzuNeHh0OQ8N1f7H6xPOs\nloMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdeAu3MssakGBPBIyHG2lBgWXzvlgbef9/bCogbX2te4CID/q233WXevJ\nPqNRHA0VopVITYqW08eb1QHnBByhjYoa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAcfVLFHxlv9njoXLj2wjRgiqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM1MjBlNTQtZjU1NC00NzdmLTg1MjEtMDI5N2U4MTk0NGJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDExMTk1ZjQz\nLTI2MTctNDY3YS1iYzA3LWE3MmRjYmFlMjA4MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKaPtuqlwfq3cX3xRmfs7eMN/HnZbAgfLeezKRa+O+YFPYizdecwy2kT\n6yiAet0Kg04kuYfGZyhvGL7FKY5wzrCjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAs+KWFz\n6KpB3wto39wGGkHIKjHuMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCICzRD6+8wPxVk7/+EnqXG/jCZO4ZQQvrMlGl/cGTFMzyAiAF\nJpJNOegdPCJf/gWrOE/p3uF0nL+cKNAnTfAjbxr+Gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5360", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5360` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAdOOzlq28zLRYgaWS7XtISIFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljOTcyOTIyLTRkZmQtNGJjYS1hYTBjLTBiMWEyMzdlYjg3NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmUzNGI4ODEtZWU5\nYi00ZTUwLTlhNGEtNjhiYzY1ODBmMTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5hLsj1oVEXxaCCilAOQptQ3sFu6BeEtyPYn9aji1NmbyabFdiC/xPc3Ci9eh\nwwgmyi5Q4yXs7v9ALoYqSzbceaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9WnGxgOeFmtPEeGW+eFs3lDju+kwHwYDVR0j\nBBgwFoAUSlLJuJvpPmceYOfxkaWu6HMozpgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiB/Ax64\n/6PKOOt9l5+kIJuTPdvWMFDQLB6ceMpTL4hzBQIhAJ6y6pEN2uz1M0KohK3jXd0q\niJY3Acau166Iswj80okx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUoMp7CvjCR8LG1eyFhwU931MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzk3MjkyMi00ZGZkLTRiY2EtYWEwYy0wYjFhMjM3ZWI4NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEsUsycujMx7RqJREmzVMai8yPcAgwc8ZUsC+iErCA/orf\nAuURkxgGGDK+CVgzj75PuZEOcTuyy5cDonbWLUrto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSlLJuJvpPmceYOfxkaWu6HMo\nzpgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOS21S8g+ys/7N9Spy7SffMh1Owm6O1QWHxs+9Mj61zCAiAnuAr/76SV\nNvPnopL8SuoDCjyNPd8XimBe5A8L9mgrig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAdAcHgGZe17qd7iqknANFJXFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmUzNGI4ODEtZWU5Yi00ZTUwLTlhNGEtNjhiYzY1ODBmMTVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQzZDg1ZTZj\nLWRjMDMtNDhmOC1hNTgxLWM2NGI0ZjQ1YTg1NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKqEVlIzpzN6k/1yQ5gWSP7wZ5UkomlYDWm+G5pH1kUMZmthCJ9W/6cD\nRS7DJRAbNtoMTfS1tdR+xRvSMRP/4zKjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPVpxsYD\nnhZrTxHhlvnhbN5Q47vpMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQD7Rw4yoO0xkjugxhi33xWwiqbQ0QCJaO8W4I44l/L69wIg\nHAF4MUTSyzhCjbZJx70OhBRQRPt49w/g1MZKWeDo4Ys=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5361", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5361` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAWMNwitkx8Mo+fvKP21xI4A1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MjkwYzdkLTNlZGMtNGNkYi04ZTI2LTJhMDNkZmVjZDU2MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQyMzEwOTAtMzFm\nZC00NzJhLWI1YWUtYjM2NGU3MjU3MzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELkayXApiH18OI+VyEZ/UlFvG26rv6xzfP7OiyWaVezFIsN28SA8wEf4Zp6J1\nSmOgUdnKXG+zbNAHLhuaDYdi5qOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJwHaehEH7gBWphnOMYgf6jz/Yh0wHwYDVR0j\nBBgwFoAU59VKP4DM73Chm5L1i7PIRBQJepEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA9b8p\nOTE+xfKWkHg80iGTfg5nWU0XbMIRqDrjKKG1V1MCIGLHmnf330Biv/6j8co69Zga\n5OcFBmdufiMRgQrId2wn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASUMuoNOxvhihS6GDcMV2xdqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODI5MGM3ZC0zZWRjLTRjZGItOGUyNi0yYTAzZGZlY2Q1NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWc1Ikg3jsiAU8UhV5EOtTCRKZT6CxllvuwRliMRl74AnU\nv6V9P6aT8UONBpE0OlF1SFct4wpkuGVCmo1J/NBao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU59VKP4DM73Chm5L1i7PIRBQJ\nepEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHW3z1Lx3Dzo+YINws2nDriqDYVk4EXLjP46ox8U6D6wCIDdvfkJY9pd3\nteVANbCXlbqyOXOCzkuzXkXRZzQz7v6A\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdKgAwIBAgISAfD50masmdmJMHUvpl/A5JKNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQyMzEwOTAtMzFmZC00NzJhLWI1YWUtYjM2NGU3MjU3MzVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI1NGQzNDBk\nLWNiZjQtNGI5Yy05MmY2LWVmYzNjY2Y0MDk4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC4ul/8lBpqG4NPMMmC3deBaLJ0if9et7+CJP0L6GSvkmftFYtQpDHFa\nJ9AOTMpaHllZQTzEs2n9KapZTKMZ15mjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCcB2noR\nB+4AVqYZzjGIH+o8/2IdMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0YAMEMCIG7mJg8LjRlS6Y6Q2pY+I8KPyGBu4H1rRt6Sm2nPImN4Ah8i\nLpqhaQ97Sf/F+qxqLc7YNjce8ZFUC+fY5uphi7Es\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5362", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5362` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATGLu9VOz4M5ukXuUJ5RFb0tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NGI2NzMyLWE3ZTUtNGYxYS1hMmUzLTdmNDllMjM0ZjQ2MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY0NGEzZGItNWI5\nNC00MmEyLThmYTQtMGI1MDZhNDVlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDC3XKRrDy0Vxe+VfmVZ/jOR1ekdSHF6oq3Tx0e7br9EqVo4kzxzwoRu2Mfp4\nqf45Y1Nx0VQqN5weW1fMrLfTk6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGkRa1Kl0st2blJQ2IgI/nJTGSoeMB8GA1UdIwQY\nMBaAFBQBzWZC6jFxf/sQsyOltMIusJXiMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA0/KV+spla9rUk/aRQq8D36RAObPwiBGl\nkqVt6oRZpX4CIHAk0AjKMGwn+vwDT4mtODW9M+anDNTZQHV4O4fnAzOC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAS+5DAmeBa6XdLurIlMgCJxXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTRiNjczMi1hN2U1LTRmMWEtYTJlMy03ZjQ5ZTIzNGY0NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLE1z+51dTMKVxFtdq0lSAkCUXUOThmFwDJ7RqyOGNgtgX\nnhjfwX/45nBdjFqZ9jqBNc5QCLJlOxUKgRrXNJebo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFAHNZkLqMXF/+xCzI6W0wi6w\nleIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIfMK2d9lRILEu7LWL9PVYYjfZsVJAXwdwCKrcmaFyLbgIgCce5YrYE9rEi\noEoBiQAehHjxxFE3g/RU1nubXwr0ssw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVrc/acWcd3VXMLt1V9vLGQdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY0NGEzZGItNWI5NC00MmEyLThmYTQtMGI1MDZhNDVlNTk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5YzBiNDFj\nLTQ3ODQtNGU1OS05YzU3LWYyZDE1NWYyOTYzNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLwqrqTMCTIzRk3N/fICY5WB5nLxslbXe0O28Dc58/Jr1hWv3nELIjAa\nL5WyfeDUlD1yaHaOd88MmO4kL5/csLijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGkRa1Kl\n0st2blJQ2IgI/nJTGSoeMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQD+SMA1Hvq8SBJ4UijuTg7RlYsNYoEWC951S3RGsKtdJwIh\nAIaf/M2/5UMeImCjc1KsNgRCxJ4+6esYVwrxfPRcfSL/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5363", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5363` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASNxj1o5HGRGgR1Yn5ToSeuIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyZjc4NDg0LTlmN2EtNGJjYS04YmVlLWZlMGI0ZTU1MWMwNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU3YWFhMWYtYjFj\nMC00OTBmLTg5MzUtNTI5Y2M5OGY1M2U2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOcKjp29ioR9e6tdWd3QWdS/kUoaBM7Y85TSun8MLwKyNX60yiRXXy51nrSnG\n0TtTtavU5bPRQxHfJvg7B3U3L6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT49ZBOQxJC6KbJALRcdWR1MYnYMwHwYDVR0j\nBBgwFoAUC0OeBhZO9EzGBUO0jZD1FngcA/UwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOq33XP7Rk3p\ns0EQSPs1a+9N2t5K1X0dSCszicplWXJHAiAgkJPj3afl9v9V/RUkACoQW7dibkq1\nHxsSfcGO29QhVQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaL/Oh+YyfbAMCG6jPbwKFMyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmY3ODQ4NC05ZjdhLTRiY2EtOGJlZS1mZTBiNGU1NTFjMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYaQsHBgo6r9i55yUb/jm7G0Sug3AMP3br/jcktoPwHj2N\nfpgzza5wNKttDQUbUIU8AarQ0nzSCIB6EeWi8/Llo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC0OeBhZO9EzGBUO0jZD1Fngc\nA/UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL2az8eZwTNWx6JcGHEeclIF08Eh2X4Ky2z4z0iY5ykrAiAp2XjqasRf\nd07p1B+v8YAHwKLWS8cpKNMLuavDk4ZMSQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAaYc3KK39qG3Wo4e1TE4pqWeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU3YWFhMWYtYjFjMC00OTBmLTg5MzUtNTI5Y2M5OGY1M2U2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJlNjViMzEy\nLWUwMzctNGI0NS04YjBmLTM4ZTEzNDMwNzcwZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMTFguJBuXBcpp9TLgo/IKAXB07yR9PyoTLDLNma3xkbeiq9pVHo1elS\n90nsd+wDkpGxVcYezerv8maZiU6ZZ8ajcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE+PWQTk\nMSQuimyQC0XHVkdTGJ2DMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIGlME38zQDtWsjYZTxoR0I4slnkZ7siYiT0nfcofvV4JAiB9\ng9h+QPsW3scDwy3ZDzBCOmexJEUj5euOFWht/jnHFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5364", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5364` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISATowROcmhVYuj/sFJ+kW5X3uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkNGFhMTZiLWI0NjktNDQ4ZS05MDNlLWM0MjM3ZDM1MWM0YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRjZGFlYTgtNTVm\nZS00ODNiLWJiYzUtNDZmNDk5OTQyMDFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEb4nxXiqI+hzWcIElqtBHjbFpVBz6fpdKLaIeI/Y+QZQFNx5M3Fi2N1IMlfg\nvwSkcwDvDQEM6+2bUYgzfP5Ph6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUewt+kCeIQONtSCafVd2csp4zLQ8wHwYDVR0j\nBBgwFoAUJSzJFeB0jGf4v4mINt+ifWQ8U0UwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAKP4JAb73RfE\nsdtD5UOxhjEVUfjaEQ7sDzFDNbKpwWrOAiEAsRp1ZujAS5AEZ+o/SioDt42LrObX\nFXSCDRBW4kKoPTY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU609COfTjQDsPf+aiIFpoRLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDRhYTE2Yi1iNDY5LTQ0OGUtOTAzZS1jNDIzN2QzNTFjNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnTJ7FwcoBcCguwvgoJDUKEO9YUUx8GhSCvey46+CUshS5\nF7kETnx8cTGXjRfc4jhNsSC8Gp4CXogdtMRIN78no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJSzJFeB0jGf4v4mINt+ifWQ8\nU0UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMEsdPTjoJlMdbnpn+n8x08hHI0qmdMFDrnZZvtRD3/kAiEAnnb3QBC8\nb6oxxrHccTKxAD4V9hPXtGfVG3o3b2pFyv0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAS9RrGx11jBKJtlLUEjXrhWeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRjZGFlYTgtNTVmZS00ODNiLWJiYzUtNDZmNDk5OTQyMDFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDViNDZjMTJh\nLWY0ODctNDUwZS1iMzcxLTdkMjAyOWViZDg4NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPF57l1iZFe+cPhzlqAuSIYwY281p7ftVWZt+owx1Xi64cv6ZBOW2D3L\nqWuqm6H7ZfDyQHKgB5BxgZsxoioDABqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHsLfpAn\niEDjbUgmn1XdnLKeMy0PMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIE2p5X9D93TBz4aGN9jreI3kkZwOqb0g5QMyO44RxG9MAiAH\nF02ppcAPi8hlxlXswFScfW/zZldJU+MTSBitYNPP+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5365", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5365` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfxKd8a06Rnhhtht2fz8GKkeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjNGVmNzlhLTVhMjAtNGZjZi05MDQzLWZlZDk3MTU3NjViYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc3Y2Q2ZDEtZGVi\nNy00NTBkLTg2YWMtZDYwYzdhMWFmNDM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtmiy3XpPiS6n/+GSHxX8hG+NwcgZWI5X2am2eZTL1+fa9InQhpniHWXAw4Yw\n2p1iAPktnFE7xcOWJiud055V8aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuLUlyTFCvSIhrwn4X0DFMxVSV7AwHwYDVR0j\nBBgwFoAUhjyjZdQMpPOzLhGfj1GnlsiB03YwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDbkBJOX/LAJ\nDWI/v9oiz3StCQTWlZXiKU6T99fK3wXfAiAm6aaArun85HgPy94IBcJget0995tq\nGHA0uR5F5LjAdQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVEpRO+zWPEGDj7VG8Rr3n4uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzRlZjc5YS01YTIwLTRmY2YtOTA0My1mZWQ5NzE1NzY1YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgbdKLd0QXFo1Xz4NyqB8ztUm3uKgyOgxp+GrjDWUbA8LM\nV4wFn3MzpT6vIebgdM9fNOCTcxCxuVxZrLLUvcGHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhjyjZdQMpPOzLhGfj1GnlsiB\n03YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPlgGBD2VgNN6p7sTkxkzedaZjTNH/ntIpYm4li6RO65AiEAwtvcnrdo\nnbGk8OlSisu0sdQHqZlfagY1UtL8pTyZDRo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAcov5tDf1+rJymp2qLIFR0k2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc3Y2Q2ZDEtZGViNy00NTBkLTg2YWMtZDYwYzdhMWFmNDM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVhZjAzY2Nl\nLTY2NGYtNGIxYS05OTYyLTBhNDE4OWUwNTNiZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKlFT81GMCPMaqc55uirp6EVpoHy2iJz4REdqIIZRJQLYFOHAk+sSPVh\nbDFB4sag52tEu3PglYkpLD76ZErya52jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLi1Jckx\nQr0iIa8J+F9AxTMVUlewMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIHwfZ1ZAiJ3qQ+Uf18dunM967/34q3Mg6ZwF9EnBuw04AiAV\ntLYd6X78UYyQc03+y9Bh99M0CJNDIyiFzM43m7tWhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5366", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5366` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAT7Ht5Yfrt4racBjFrNk0KWoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3MDM3NjFhLTA0NDAtNDQ4Yy1hZTFhLTk1NTQwZGZjM2MxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ0OWUxZGEtY2Vh\nNy00YzlhLTkwY2MtZGMyNDI1NTJmNTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESnk0gPokZhzz21kdVCrdT8iyqxgSGb7wSqLGfc954qtwuu+Zx0i9qSI6TOjc\n6NbNu8jGYK7iI3AhVpsxoT9+GqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULuQ12lF6bhJQRzDtHERHaQA+rwAwHwYDVR0j\nBBgwFoAUm9KGoySksrk3XLF8Fn2E2vJU+eowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD2BZBQ9/QB2dvDCM5X2biEvFzgl58NmgDeVzIhLKPeaAIhAIVh7q9ne6rS\nvKdlGnQGU2UA6OpqhmUJO3G3/QZP6egY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaZ3oQ3DuBDFJwN+AhIGE0aZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzAzNzYxYS0wNDQwLTQ0OGMtYWUxYS05NTU0MGRmYzNjMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxd2i7m/CpuM5HB++Zt9y3igFXzJiQ0cYeFS++bKHw0wPd\nwSnM+aYNYPLyNQWxmAuQn2MrAFRK7Eiq/9Z8H0Mjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm9KGoySksrk3XLF8Fn2E2vJU\n+eowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLIi4HLrKpMq5kVomAYEO9dNXaHz28hdAPRmBcSBr8ucCIG2AMa8Oh2p6\nfmFMsMh+lebRMPCgI9A8TpcoYw4kfSfj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISARScPf49+yQ5IBEylXPjGtLqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ0OWUxZGEtY2VhNy00YzlhLTkwY2MtZGMyNDI1NTJmNTY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJiOGJiMmZj\nLWUyNGUtNDlkZi1hODIyLTZhNjNiODIwZDkzNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI7N971ZL3gyYu0rrIku8hQ8IK4aW71tqkNDVaiGNbgUL0s7zBCthDFW\nMI2ks04rglI6pIucfTevtIS1X9a+UzOjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC7kNdpR\nem4SUEcw7RxER2kAPq8AMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIAwHsKjdHRsd5gwOdDI5GhLmtXkzhGjvbw6i9um3054YAiEA\n+kfQRPRWqon/WOHaQJBDk17nZMp+/v2XkLSR6LHkndQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5367", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5367` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeHuwUmHKK4KDynMpkqWI4/UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllZjA1ZGFiLWFkOWMtNGY0Yi05NGY4LWY0ZjFhMGVjNWM1NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFmOTFmNjMtOTBh\nMS00YzUzLTg1M2QtZTcxNWY4Yjk1NDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjZuMwUsNRnx+4xS3cbbr1D4we3XjWa0MmAZgks8yO8V4/Bvivt6dL0uHroWI\nRYzKhJ4phrJyVOe5qONdd20AVqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmSJ13i277ofqIX80JPORb0KSx88wHwYDVR0j\nBBgwFoAUawRYAJM1Bcx06wqudaEnU33CiJ0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDcQ5tOG1ZehKiJOFNGTsUHmYRIvjDWbeM7pxj1kzR11gIgU3DUfMjxLYKN\neol19CAIDKHejyFYynPwUoP74WkcZD4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATRryEzJlG0a2+Ia5U4NLBtCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWYwNWRhYi1hZDljLTRmNGItOTRmOC1mNGYxYTBlYzVjNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2R2//F6u0C5oofb3nUt2sBRbjRep0f0FYI1Sdb+FykDUI\nqiGIG//is006ANMAxpnHTWw9MIBA74CsFwiz5q6Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUawRYAJM1Bcx06wqudaEnU33C\niJ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANwPbMMbIulxPECFQiA+LytRAfOtfnh8PCpuIithgVN+AiEA6Z1FTwN+\njjCKkNsTVy3UAd5r8ALjlC5UBSKBd8JC2cE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAYgv+IUiND2s9206IC2ZLK3AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFmOTFmNjMtOTBhMS00YzUzLTg1M2QtZTcxNWY4Yjk1NDdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhlNWJhM2Zi\nLWNmYTMtNGU1NS1iZjMyLWYyMDc5NDQwODk2NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNvqDfhdGIfzI3pE774ItvqhtmhMXPb34zPPs+6UQz2zm/PfFffmpzEU\n5+M98TFTu7qSvSsBih+l76zbbHmXxB6jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJkidd4t\nu+6H6iF/NCTzkW9CksfPMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQC6TTbJgvDSwvfv7pWXSw29Hg9FqGYO305BwP7eNfu8NQIh\nAKwDvFAt31GXunQ76nFkPsSymnPrmtjBWLGuPD9nWyim\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5368", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5368` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAe8twlkJIWW7t+lYNrX+2JYOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5ZDY0YWM0LTAxZTctNGMyZS1hOWQ5LTk1N2UzNmVkMDllOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY0ZWVmMjMtMTg3\nZS00YWJmLWE3MjUtZjgwZmJiM2Y2MjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXz0dFtyilubIYN8IweMHG9TNU+gvmjo3GktOJuOqueEtdUl8CHP8id5vru+D\ncwfzNpxkpoSIa3sIMu83MLt+l6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoG5MecIcgY2zP14bukYP1Esah/MwHwYDVR0j\nBBgwFoAUXRnfTwbi1lujIHLKnvApO8U49xwwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDm9\nVRmGyuDEZ22wf9zn6C4eZGvU0nBjxqjYGB1M95LWAiEA7kbfqlAeGEXm1mlrvub6\nT2FfVZzFHvqIxqJyDvoQVqU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ82CJDV0BaSxV5VL06fAFkyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWQ2NGFjNC0wMWU3LTRjMmUtYTlkOS05NTdlMzZlZDA5ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/m42vv8+rqwKSNpGqmD/ZngShWS8lpIvvd9I6crkResCw\nGwo2D9iRXdUXQ24UII+xUsvSNu8GOemxzaA2Xmx4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXRnfTwbi1lujIHLKnvApO8U4\n9xwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIJyImHT0N2SX8KgV2hhKih/zquM1xwvnDX/AzX9GmjoAiEAkT+VeRFt\nhz3A4rzPKQsoySfaQA/lQj09z5zE2NqpIQM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAW8ZoJWYkGEddpQPYeKimKEVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY0ZWVmMjMtMTg3ZS00YWJmLWE3MjUtZjgwZmJiM2Y2MjgxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBiYjM1Mzkz\nLTViZmMtNGY3Ni05MzRiLWYyN2NiZGM2M2I1ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFXvlhPC2jljCN7KbuYx+qTzbzlulBYAQMJZMnbUB5K0loUGK7ZMSARh\nTfpDzh9h5gV9937TdWI9njEL6gZrb1WjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKBuTHnC\nHIGNsz9eG7pGD9RLGofzMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDWRXkt/1+nQW5qnfc92aSeEy+/iE5eCalmWAz0daG7mgIh\nAOFB2ja20GURniRTLITyS+a1WnN8xMSVt7gA5DkoWICX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5369", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5369` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcHM1KPiK8p40cT0LksTHfQYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhNjM1MjA2LTllNDMtNDcwZC04NTJmLWNiMjM3YzM4YzAxNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDVmZjcwY2UtY2Ni\nMi00NmVjLWJjY2ItZmVhZDA0MGY1NjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiG5ojYjITQ2Zfge8Z5eQCSVMsdNY11wHcpJHiWFfb+/8S/xif2xEaKWqJtQB\n3XRFnC9PHH3FBARO26WhP/PsKaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtjaaaAVKeONqU0GJhlIMzigsXX8wHwYDVR0j\nBBgwFoAUejIfOns5RRhQuhN7i3ya3Pzd5yAwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFcNsCxhelGMZtEJGnTsRqQ3xc/jPB6Yij1F+MWpFvcBAiEA3ikF\nduqihfHgp6rpjwa6XLFyEqC5Ui1p19jQBn5vjOs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcvY4iTb2EhDKTjs41NoFkVsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTYzNTIwNi05ZTQzLTQ3MGQtODUyZi1jYjIzN2MzOGMwMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm5+j0wR4+/RgxtWSzTMyvtlZMVJHVHHa4L6eTbh89LI1u\nFH8aAYKA7oLvBsLG2FX3REAmu5t/NM1pspAwCAaTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUejIfOns5RRhQuhN7i3ya3Pzd\n5yAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANmHq+dA2uX/6l2iMN4dHM291IZSiLg2boIBwpZKOdgLAiEA0Ss6ewUu\nE//Fqme4HgwdlIS9kRXzA10su9455oO6Ve8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAT3suHURlqBU58XSVU5lIm/cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDVmZjcwY2UtY2NiMi00NmVjLWJjY2ItZmVhZDA0MGY1NjVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE3ZmY0NWI3\nLTYyZDAtNDI3NC04MTE4LWUxMWE3YjU1MjUxMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCNCtZJqrwuwiUDXvDFZ8ert+Gzf5Wj/0FBwA2K9YAGtUtDzbHAg87OU\nD8V3zSx5bibpmOztzJ8Je2JLMYQWB9ujcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLY2mmgF\nSnjjalNBiYZSDM4oLF1/MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDkYC+gSJp3HC18CTjBZmRfCnRl42ySSbEinyRaVWt1BQIh\nAPEAHBvnc6QHd9PadB7ritoddGYHgJk3reQ6xcKWD0Dy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5370", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5370` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWSEdXxgivmj1X9Jy4OAGyMJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxNjAzYzE0LTM4Y2QtNGJkMi05NWM3LTA5MDYyNWIyNTUwODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDVlNmRmODktNDkz\nYy00YTdiLTg5ZWYtZmE2ZmQ4NTk4YzVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEug63Wo45hLvWXFlvD7KEwtIvCX+JOryysw3ySfpkwjUs2GEe//pAOtjytT0e\nh9VWEDH6WYXieVSCU1Q4juFDFaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnxAeM7+SrfVmTOdjrBNvkhLSfBEwHwYDVR0j\nBBgwFoAU94u/SGC0aByEXt1o+XZ6P56bDLowOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIACNoHlSCeujMk8pUS0YTcdka9MLafR6Z7kXRozvC34/AiEA8Bzq\nSSpSDqGsddWDPO2cFlJ4gYQgZF3sFlJ4vNyi1Ww=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT36i8Fxh60jCTsq59PmggakMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTYwM2MxNC0zOGNkLTRiZDItOTVjNy0wOTA2MjViMjU1MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnKJq5XiOo4HxIJB+iztzpAjCNcbDqphA0eC1vGOEOcjno\nqP4tu64izVbYDanOg0zDNtL4M625Zd+WL1YVCyZHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU94u/SGC0aByEXt1o+XZ6P56b\nDLowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPpCK4c9LkLQnpwvUURHBjA3c+l+OmaOvHqntKgJmLRXAiBgtFcHojp4\nNcEyeG/6Ojg3AFcG2ZdjjZip5tLjE53jRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAen20EBlyjemBiIJ6M3uxa/fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDVlNmRmODktNDkzYy00YTdiLTg5ZWYtZmE2ZmQ4NTk4YzVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5ZTRkNTlh\nLTIwZTctNDg2ZC1hZWU0LTEzNTkzNGUyZDVhNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCeKZ08DqdFw6TMpMaVtK5Hf+eZMT38+KmcNeuxJo8XhB6Dt1PZ8uMHS\nXHa9S4uz+Q0cWYPpJ3c4eJGWzSk2xAKjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ8QHjO/\nkq31ZkznY6wTb5IS0nwRMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIDWHqsuLgdc39YrSdiSLNIvUfI6tpUAuSdiPP1Lzn5MQAiEA\n4gwuJkj9UaKvs9x+5/KouJNRYfWQr3KYnICy1dwi9yo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5371", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5371` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATLJ66t5cmIEM1VhK4pjOcpFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzNDg1ZDhkLTQyOGMtNDcwZC1hNmFkLTViODVjNzZmYTQzYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTE1OTgxNTUtOTFk\nZS00NjgzLTk2NzgtZTRiNjY1M2EwZjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUX0RSN4xawN1cn1ROjtB1s7aXBwK4/RlX2LRawddlp2C8tLcfew0SqEQ0d24\n+OOrQxNtowgJi0ojjg+00PqN56N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEu6Xv6SdFt5KaZvtc0Hp8qK6csYMB8GA1UdIwQY\nMBaAFN/DbhKeGxrwGzhTCspZxqB2QMuUMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiADe9yjY7N8YdAfKAAfjRwT7J4H82dvp1LU\nsj+BB5SSYAIhAO4j4y8qa6xv1G/QR9NnybK2cn5N/9TBcxwCCz8MXMWe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR4S5mD9fg9SWwGMg9n7Qi5xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzQ4NWQ4ZC00MjhjLTQ3MGQtYTZhZC01Yjg1Yzc2ZmE0M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDRtLn0kWEIwIOXJgJnAR9RFupTxr6Lmx3Tc4bpjFXyhH4\nM5j6D7N1s4GboLAQYrJLRg5g9gTtbHaj3X1QyF2eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU38NuEp4bGvAbOFMKylnGoHZA\ny5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK0PrmjGWwjmH3R3H5Kz5ymNxCfDLf9dKbxVmC3kQdjYCIErp6mqM3yNK\nxARqTI+4yxqGP5fOR987Rdz1vOkWdwIw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAdilxCArBvc08ilpgSddnbC2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTE1OTgxNTUtOTFkZS00NjgzLTk2NzgtZTRiNjY1M2EwZjQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhNmFkZDMx\nLWQzNzQtNDVjNC04NDE5LTRlNjU3NmNlNmYzODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHQY53UJZCsmadQ+POC2XvuvVVCP9Eo/cKE88XrfJKQYtZdonKaalv4D\nX2RP+dvbJ/5Zde2RQc4bnyIXwi7Fv1SjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEu6Xv6S\ndFt5KaZvtc0Hp8qK6csYMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQC38bSr1u16bZDK7hJeDNh/cPe8cK8GZqBZm/Auf6QzzgIg\nCeP6Fq73TbqboU9mXvocouzgefiKipXrcyOZ08nNAUU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5372", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5372` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISARvhEs7bjvjAaNz7DMLPmxU6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhM2M3Mzc1LWYwN2ItNDIxZC05ZmI2LWU2NzkyMjhiNTE0NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBjN2NlYjEtMzEx\nMi00OTljLWExMzUtZjU1MTI5YWQwZjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBYVUUktcHQcKIH1mFDidUc0AXJ4CM3Fyp2aJrjrd4QdpR5bw16z0DstUfhwA\nguot5jdRDLP8t/BBhvKvWq7u5qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuhGZVodpGtwUsEoJKwogb+TES2QwHwYDVR0j\nBBgwFoAUCbs7HvlzOO50/0d+RQoDrdmxgoMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMcW+KebIdPY\nDy1aCUnVUPUEw1sD8NAhIUVZ7LIJYRt8AiEAzdVC/Xb4PtTz5ORW/Cf3CYnwpKko\nF/NOUwe1G2XcG6s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdfz8pQBiFP5/bTjX0vjabPeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTNjNzM3NS1mMDdiLTQyMWQtOWZiNi1lNjc5MjI4YjUxNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeDdESxxNBVtew0/7i/VaFISQlTpYoTibMezj9lX2/7tmi\n6wYkypV8SXfQ+yNdFpNmTOJ63QqHAmtFHQWQ4Wm6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCbs7HvlzOO50/0d+RQoDrdmx\ngoMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfZn5mGxEn7ymPnNH6Q0i4PSMBYG7ZpkaC1KODE9hmfsCIFxpMkShlocG\ngBKIvajSgjJhK1a8V7pzhR7ZJyas2fps\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXsUe+FbmXD0bNMjjabbauasMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBjN2NlYjEtMzExMi00OTljLWExMzUtZjU1MTI5YWQwZjI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE1OGZmZWY1\nLWEzNmEtNDMzNy1iODIxLTkzMGM1ZjdhZmYyNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEmdHD6Qu//P8mnx5QWsLUbJyoklvk79mxtCvafv0s3Ow3L8bXks5Kj+\nQSoZGjcT9PLmbDe2OuS+clsZCvUX79+jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLoRmVaH\naRrcFLBKCSsKIG/kxEtkMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDpER99DNIeeI77BTesWUvNG5yyvP5ganSQgVYgbmpZrQIg\nVibWnAWzpveLJfUHOpvpeRtaVK1fjF3hOXvrpghB83U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5373", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5373` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAYdNFDawkqGf9OjFUlHGflzIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4ZDA3YTZmLWUzZDUtNDFmNi1iZjcwLWM4NDYxYjUxM2FlMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI1MWFjZGEtYzVk\nZi00Y2RjLTgzNWMtMTJhZGVhOThiMWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzHE5dNWRSREVaR1bJ3XQvuBWadIYoM3OmjSBnTfKVtEEip5dm4VqjKZKGRBt\nZ6uZsrOoEVKqDdnLlxwIofcke6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZPWGBnLUM664Py3ZycLP0HyHMUQwHwYDVR0j\nBBgwFoAUhxcQEX2OZfmc26X3wJ8qEZHjRQIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgNLe5FQFkgHQY\nw1bycZwpSHKb4lKhs7Lp5nmya6+A3WwCIHiWCI5fBwckdqLLEzcgS4um8AiveWdg\nz1brDV9zXk59\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbB9/i6bO5XDcqdtnfBplygLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOGQwN2E2Zi1lM2Q1LTQxZjYtYmY3MC1jODQ2MWI1MTNhZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQF32CAvGeDPVKw79BXF0PmLzh/8yLWonUaA/iaGYlmmbXe\nTPKyaZtOSW/lqQ8Axduy1hi7WNrXdFvK6flvJZzgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxcQEX2OZfmc26X3wJ8qEZHj\nRQIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANlalI/2XLA1hWClzzEOstu3EoVjLc6rRydh3Cax2qLiAiBgnFk63yzT\n1/9UEwq18BpX/Sh5JhcRQ/YFZr4j//51uQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAZEz3PO2z3BLYvoivoIFDjtpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI1MWFjZGEtYzVkZi00Y2RjLTgzNWMtMTJhZGVhOThiMWRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc5NjQ1ZTEz\nLWEwNDEtNGZhMC05YzQxLTA0YmE5ZTkyNjI3ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOdIDC5UYGD+7lxvu+4FMDsNq9oryVP7EeazpWoeD9dR2wZJdFBcyr+N\noTxexMNf/VA2xHAgfeVMIj34PFNyvvqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGT1hgZy\n1DOuuD8t2cnCz9B8hzFEMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIF0P8Uop2E9e7+yHshe+82XMqtAZq7azXO3Gs2Qh0G1yAiBw\n6zSmq6uABqdcvx+UcuDx4Ix3qsvWPd+Hul4B4YG1uw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5374", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5374` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWUkal+xUcqoVlt2KXbfToSeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZGU3NTRhLTYyNjgtNDE1NS04MWQwLWE3NDk3OGUxNTMxYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE3NjhiZjAtOWZl\nYi00ODg4LThlNTAtNGNjOGRmMDIzY2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7z1aUDFULjwEqCwv9D+QRR9V4Gc2Bww3C+gXHgMvIll02zgsQuW+iij36O+P\no63a+GGRdAeM8dKElvNpudDwVaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk7+fUZv2aY6IsYmd/H+whaEn/XowHwYDVR0j\nBBgwFoAUnC56NATFO8OIFLeeAtP2/oirrBAwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICnGkYBU6h4i\nJ/uSb3WW+UWVDwRhYwaB6UlxXx41GQ9eAiBPdXHD5fp3k53hxqWNSWRXNtnkBuzO\nycwyIu56/HK7hw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY1Qay0Fs66DWu/SxSU5OUgEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWRlNzU0YS02MjY4LTQxNTUtODFkMC1hNzQ5NzhlMTUzMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcqfgUG+tF8+VUiBkFrCLoTPdw4VQuBZyc8BmJjZrnSlXJ\nyFAWDXw25PNjEEYpgNCHy/Ghy7XxWZcim7JahgDco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnC56NATFO8OIFLeeAtP2/oir\nrBAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMtpbdN6rwKPghDEUBFBDk9ayY6ibTn8RbPdO9/WKuQUCIQDEXEaQR7EN\n/k1h0IimBuOsBog1TDpFIxp6Dxhykdt+YA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAYoi6T44IcweYtIjjKfV9T/qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE3NjhiZjAtOWZlYi00ODg4LThlNTAtNGNjOGRmMDIzY2EyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAxNDdmN2I4\nLWQ3M2QtNGYxZS1iZDU3LTAyNTVhNmJlZDBmYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGMwGK/xqPbgHWNqyboJmpIfbbJbG9kCRa53UQ1pXIijDfluGYd8BG3k\nX4wQtKaCfMPAloDauxygoOgiGT1MI1ijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJO/n1Gb\n9mmOiLGJnfx/sIWhJ/16MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIFXTiSXaJ/2Tpn6eyfyfRyLNWLgI5+nckE3xT/REpt/YAiA6\nrzlJnfSXZ3gC3KvVVkaNzv9UffNNq8cSthrYwqkINw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5375", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5375` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAb5bDcXv2CD0bp4G28EtHI8PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0YTUwOTM5LWFhZDgtNGQwNS05YjNhLTk0NWY0OTRhZTFkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFkZWYyYzUtZTIw\nNy00ZmM2LWExODMtODFkYWJhYzA0Zjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmH5Gwjh1P0Eu1zYgOad7+ziDzimHn0m1JwoEu8fujo4WeBqSZ96XiOMM/zsP\n+NINUIXZLqdO6iUj3FOPmzil+aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsiIw62ShgbiApnKzSbmCOHqvxhUwHwYDVR0j\nBBgwFoAUwHfxPk9XDNDJ7LEYfVnxHRrXOpcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDs3F7j1bHBcr9UQvc9I5CrRVR7QwkpbvPAzA2hY015FQIgba5roSk4s5LP\nMNCbmbhlE7U9qnx3DwGtRxWT3N9TWPc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZa73Xq9AMd/SY0X+xtBmu3LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGE1MDkzOS1hYWQ4LTRkMDUtOWIzYS05NDVmNDk0YWUxZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvrTCe8/LVMjdoT6KrS7ZBYJAVmRKBtf8GkJi+ekt4rtk4\nwTPtRBbyiuDng/G05SF6tX+AbvyY143cFjxs1gfwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwHfxPk9XDNDJ7LEYfVnxHRrX\nOpcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgImx0cQAMpJYG/I+nrKofBagnjhqOBdLg0BJpsnkGD4UCIB15i6FpFwvc\n85yAWuUbvaIooS8/Mh4yPBzBX0N4N2AT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATVgbeQK3OosNOcjrNdD9WEPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFkZWYyYzUtZTIwNy00ZmM2LWExODMtODFkYWJhYzA0Zjk1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkODhkMDZh\nLTZhMjEtNGQ5NC04MmY2LWE1YTU2OTIwMDc4ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDDE0rRDelcoNrgyKTJlq6pH9my3qSsqeCgTEbjcE4UUZsVYBroMHAwS\nEYooSKmgaMe9UzJVXpZaNtTAbqGTA8SjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLIiMOtk\noYG4gKZys0m5gjh6r8YVMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIHF7whM71ZQQeWoZ81LPikdYQYxKBouo7cWrqo5UseQVAiEA\npxNp2qq31Vld0gp+FENRxpYkCBBsmUp3ghbDArqNZ5k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5376", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5376` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAf+gwmKln5+HjU9XgLHOQTk2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0Nzc5OGVkLWIzMDAtNDc5ZC05NDQyLWUwMTdlODgzNTQ0ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzlkZGVjOTMtYzZh\nNC00ZDY3LWFiMGQtMzllNzAxMTI2ODkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzeQJMk/yiKGdpGVUFB0pKWf6RL4VAwg9Ro0xWctTvmFTayxMFX0X/EAVp0ip\ncSxP4OzQn6k293yDt6jQ6e9TBaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlQld4ArpuEvqTlIAMOSIOHF56fQwHwYDVR0j\nBBgwFoAUE13ooHc/c3PiIa7brp9asCBzLOgwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGIwzX5SOMpqLwKEmpqMinDsWBf1xoRROA6A3U/tOaktAiEAs0NTKHLP7hHh\n4v9TVEjqncijSrJaYR9zz3gr/zQZDFs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATfnYr+9QcjzTYIYF4JCZrdVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDc3OThlZC1iMzAwLTQ3OWQtOTQ0Mi1lMDE3ZTg4MzU0NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxJ4GNO7iiHr1mymbVIZTuVsDb3PVK2JuK1ksiqlmpX9u5\nS9bKgvLa2gkTWyiJghVxSMnp/EquvGRUaxgxvssno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE13ooHc/c3PiIa7brp9asCBz\nLOgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYXDQatFIdInrTL3/6Ct/0pTw0JH4Pj2k71FVZbEp95QCIHP8iHRyAO+6\nIxtWyCGASfj0BIkee/M61E4b1wnBkGt8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQxvHL2xgpUh0AhND5BuIJ5bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzlkZGVjOTMtYzZhNC00ZDY3LWFiMGQtMzllNzAxMTI2ODkwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY1MjY2MzE5\nLWI4YzctNDRiYS1iYzViLTI5YWFhYWU4ZmNlMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA4J56sXQKAkHfZHQ/mf5gNo6XEj9ScuWhKBX2zcI748ANK7W0U6oifq\n+OcVwqZcyjks5DnF5dCcffyXFdgIXI+jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJUJXeAK\n6bhL6k5SADDkiDhxeen0MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCpMXbxDXe3Sj1mAV7wyPZq+dYN2tfao6Fx9kH66BluxgIg\nW6OQjIAhrzgLr1Kj8rlOy2QtEXEczw+z6q8qc3tEHls=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5377", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5377` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAcCU2h+lJjFAtxHewuEuWbD/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzM2NjOGM3LWQxNmUtNGM4Mi04ODM2LTlhNjBkYTkwNzIwMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM0NjE1ZTctZGY1\nMS00YmM0LWJkNjItYjNhM2YyZDg1NTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEREVysMu1HLq0iiA8KdZn8yjqHD4Ymha0ySZIC1+5ccEBdGf3tDvKCLErS3A5\nDlvW20F+r6pd8sR9hRB4tqPfP6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Oi9/Oo1LOSN63SW4P/P5dPloVswHwYDVR0j\nBBgwFoAUWQ08eVVIKsEHYpURDILWG7IrUfowLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIApz\nA3evlDv7d9u+a9pNhbZJ+UTwZohWzXQyW8w7M3qbAiEA6hjnq6iC2G9wsn1rWLID\nMOLJ1biS/6nTmHb92lJylCA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAev//uB+a5XPGl+CSTWCDOuYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzNjYzhjNy1kMTZlLTRjODItODgzNi05YTYwZGE5MDcyMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmuar5Hv/8L9VWR6P7B7vjkOQAhmTdHw/mw/tsUuZxC4T1\n18u/k1uAjJYVhP8oVamY6/G+4wNL7nCCguuYzlCzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWQ08eVVIKsEHYpURDILWG7Ir\nUfowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALak/GV2qH9aeFYycAlcUzQ3zjPNDIq9Anb66rcrk8iKAiBuTy8p6POp\niQcHPh95kzzjIeDAvi+zoAFt6SxKBcZrhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAV6t3zVHgG8vDwwMMCUVJ929MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM0NjE1ZTctZGY1MS00YmM0LWJkNjItYjNhM2YyZDg1NTQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEyYWE4NTdh\nLTYyMmItNGM0MS1hMzA5LTUxZDE0NDEwZTdhYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLlXa/KyHke/UU5iiSaR5Z2AzexoyTU9vdZZDaeKaFvOvXgq2/XNJNm9\nOKxduBrqpKsCTdrtb8m14ZX2xjMYBLOjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFODovfzq\nNSzkjet0luD/z+XT5aFbMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDx1mErRlJ+F+wQvKMkKQlvlU7VRaBbmlTq0vLMLqiMlQIh\nALdqZzgXNmLl8yhEUAL+gLtf6ZUlBdl1VZwEdvg8E9eU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5378", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5378` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAaQbTuQx7aVwqDeafRmykvK7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3NGNhMDcxLTZkMGUtNGI4Yy04MzZiLTgyMDM4MmI2OTE5MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNhZTMzMDUtZDJm\nNi00YjIzLWEyY2UtYjE0MmYwM2IzZmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMYyB3cxKq52nGVjzS+S7GMRu9z96KrvBC0HivgASKWDRiEUZwNR3kgka/Yai\nkQqp69ylSNjnWOPeJy/MKWyKB6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFF5Sqmh/pWwd9QPde72/J6Yz/BswHwYDVR0j\nBBgwFoAUP6FtRamfllijaDyBhh64cGgxQ6AwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIA+SMWLWj8tdvmrLaHyEhLbiLO6ImKevfmHxRFgy5wdeAiEAsYVN\nGrVjO3qHktd3vCgWPoth+nV+joV4MjeNxEFq6UM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcuqhhZmD6/kZDvdwuqNrHtpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzRjYTA3MS02ZDBlLTRiOGMtODM2Yi04MjAzODJiNjkxOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsTIAeVz0Qp/4BcG6oio7wzTxEslwCVZaPqQa2m22pmAsK\nffalHHv3MK96huY6j/b5m98i0ZSV7JyNpib88N+No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP6FtRamfllijaDyBhh64cGgx\nQ6AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP1A4MJWoJRQAvx1/6Dwd7qHR/QpKzQKsGUsyHwM2xi1AiEA5hwNyT7E\n4d6y6/xpS2K0Ncyb2U1A2XIcNRBd4HUUBCY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAdc9LtRGL47iENJP3w0w+5oNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNhZTMzMDUtZDJmNi00YjIzLWEyY2UtYjE0MmYwM2IzZmRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZlZmFkZDZk\nLTYxOWUtNGU2OS1iMjI2LTZkODlkZjNjNjhjMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGJ7le+3OD2Eq+oIPExbp195oiweZLU1mGaC/FVtY6ap/nrn9jHxPgog\nfgQB/KUAMg3Wh89I9VaT9+qmNViinsejcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBReUqpo\nf6VsHfUD3Xu9vyemM/wbMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIA3O85eNYdymysmsx3WqiHKu1a/GLkMHdBSn3HhqaJ8TAiEA\nzlqLoRggy4Hxr8B6d9HaeZVYP7hPORU4rAgrfc9XM0o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5379", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5379` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcnKohsc618ypLHjRl3/9Ku3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ZTEzNGU5LWVhYzktNDY0Yy1iYjNiLTYyZDhjOGNhNjVjMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQyMDgyMGQtNmJi\nNy00ZmJiLWE2ODctMGJiMWM2NTNjMzYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIY+PWR0m11bx8pzD07KEQP8IsRhbjHf0sbnGMHPJL7qyrOQ94JexKPw3n38k\n0YM4DGoeZzkfqkj5VHomfsFtMqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmw92i3A7+roitsmFh2EALCJ4P1wwHwYDVR0j\nBBgwFoAU4h/rBw7vVZxcGVbUqrRudT83W/YwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIHfPp1N5rfyfA48VJ2GRJZVeGRfENEv6AwYCboVlLM6/AiEA05ki\nfghv9ZH90GsFRQvLgvUk93/QL1JqP7audYqsaJg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcsiT0oPcqK30lEiqzXCIufOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWUxMzRlOS1lYWM5LTQ2NGMtYmIzYi02MmQ4YzhjYTY1YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJQt7+kJPbGCsNJQQHZJLrcmSx27t+K2xMf2PAChJKWGCr\np213JDXll7Qx6TOujsSjMTYs6IXPlxjkxBCZcA0/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4h/rBw7vVZxcGVbUqrRudT83\nW/YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALVRNyDBTfht5Tkf0WAMayKgEjxGtyEfkh73jgMS3VB/AiEAunzUhbvn\ncSMnW1oVfQFkbqIwkthj78Q9XNDJR+TNcHI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZbDEf7o1eN7y05vMDEf0t/BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQyMDgyMGQtNmJiNy00ZmJiLWE2ODctMGJiMWM2NTNjMzYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY2MDY0ZDY4\nLWIxMGUtNGIxMC05MWU3LTYyYzE5MDYyNGVlMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDiZLMhjsc9i2MpAu6ZlGJH8DZ8hlnUdzRvoc3UqtZvpieCUD1Xh1BJJ\n4ECMEUOYy0mL3863RjKVGi9yysE8QJCjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJsPdotw\nO/q6IrbJhYdhACwieD9cMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIAkIVpJQjiab2Kes1ORRxB/Gk5Xj8P9BIusV6BbGNZ6XAiEA\njpAWHrw0HppHcN8v9MWOxli2Znyhw0f47dF8M+4P46w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5380", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5380` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAb4h9lSNhaguYHKG2rpDOYsuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4MWNkZTJiLWY2ZDktNGQxMS05ZjQ0LTI0Y2M2ZjNkMDNmMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNjZmY3YjctNWIz\nYy00N2JlLTkzZmQtNTQzZjM3NmE4MjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL1j8x/OiL4+FZRmy6S7gK0txGppB7Wiv7RY57EUzjfT1hHnqCBb6iBnJq16X\n+VnJ6hybVFVulag3QpVpgPQ4baOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR7SlhLW2NGYpPoTgaHV1Dyb4vXnDAfBgNVHSME\nGDAWgBRKUH/b3aptnt2ir16PC4lKs0+OvTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIB2aCtSyA+CYUEB1b2otisAfO/r3UkWy\nnwQXmWIbu18DAiBpWUbNl1EBa+ZrG2d2i4Z0kHBYiB4nc8OCvxEHVYr7fQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXoeXG77aHAqGJM0kdAmQERAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODFjZGUyYi1mNmQ5LTRkMTEtOWY0NC0yNGNjNmYzZDAzZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/xfe1IMsc82p89GdZWK0nhnNRTj90z9QdmGyJuoUSoMDh\n1h2DrlFx1UiSgqwmgHeDfsoaku/Vgjz5YLqTkoJAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSlB/292qbZ7doq9ejwuJSrNP\njr0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJJ6fSkJFaa/2VXff5zrlmMtpY1MNuf65f8jELt30P89AiAKCewnZDFL\noim2GsbrnOu9+Hv4Jd+lwRPRw8I7EKjYRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAauVbSPQfc1XrjtL2+hBHxcoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNjZmY3YjctNWIzYy00N2JlLTkzZmQtNTQzZjM3NmE4MjRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI0ZTllMjJh\nLWJlNWEtNDkzMy05MjMyLWFkMzQ2ZmRlYjAzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPT7X8L6cEFT1v0QS8Cw7DohhzHgaCoE1ixRICOMfW0YxpfphMzV56Ky\ngPTlVschGAeDIDaCtJO138VBEyy+RyGjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHtKWEtb\nY0Zik+hOBodXUPJvi9ecMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDGB6wV1vKG+MaJ/KOrXIf2K0VBRTWgZUhafXwx3K8j+wIg\ncH3gvdjvaqg2VzFP6Axz5NSNCZ/ednOMWwrJ6gJFX0o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5381", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5381` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZGnj7/p7Eg2jZIX99muaZusMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3M2EzMWJhLWRlOWYtNGEwMy1hMjNhLWRiM2U5ZjM3ODQzOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmVjMWVlMTYtYWRi\nOC00YjVhLWEwYTItZjBiNTMxZjEzZTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELgXFMTVnUgWK4ytuLZ03wY+gJI9t6LU1uLXgJTUI9sK4YSZQ4PrfNvrAudxL\nNOdjVlwZFSK/XOjX0gkofkh9L6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNI8LfaiWdt/HRZEsyjZH6WuAlY0wHwYDVR0j\nBBgwFoAU397f6tTYBNwU8X1yL99mOdnAHqEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCwekn+Ij3x\n8KRx3IG/7Fa/ETNTURQuiaOFHQtmNj1NMAIgLms433rMX8qHyuw6PctD8ID3Q56j\npUBIluJnGe8S4GU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYt1OvtDgw2nqLDZSrKiuyvJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzNhMzFiYS1kZTlmLTRhMDMtYTIzYS1kYjNlOWYzNzg0MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLMURmSKp2QM5KLsrjgzOxJqKtuPq2iWqBJQFPbOUhxyl0\nMRtESrmgqFaqDnV2lNP/SlQLXrVQAZWIFcUYIt/co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU397f6tTYBNwU8X1yL99mOdnA\nHqEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALrrEgb0zTEEb4luGOfq5OMdizHzoapUDxslVQ8gI4c7AiEA1IJYGAfn\nTbarl84vw+1VoDkVX+kc42nlY6c3WRRBlGU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAc33rIiyMFMVOGMT7+628XsKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmVjMWVlMTYtYWRiOC00YjVhLWEwYTItZjBiNTMxZjEzZTZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkxMmI0NjEx\nLWFiMzktNDljOC1hYWYyLWU2ZTI2OGRmZTdjNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFXmjHxZqJc4BPJKKDEpd1E1p/hVjgtMQGubgw03KuUb/ZU2EdF2a0Zf\nYw7OQsqXmvAivp+4WUEXL2yHPxYRcDmjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDSPC32o\nlnbfx0WRLMo2R+lrgJWNMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDP5ObfbCfLXbSc7P+Ks5A47PubPdgjVMEPm4QNl/vf1wIg\nfNFximaIAThJeYzc21ZCwpcMxLztYTXhvhoQcwL0/y8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5382", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5382` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUD6X0eKq+MvzR4WBC7oDTX4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyYzc2ZGExLTQ4MGUtNGIzYy05ODAxLTc1ZWQ1NWE5ODgxYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk1NDkzM2UtOTVj\nNi00MDFhLTk5YmMtNzEyODBhYzE3MzhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzrPwFeLj3g8yngAN39SV1e75t6vW/ygj/RdzIwWSJrrOiUlakRjRMJUPJ35o\n83EYjmorRzkNk0CWN1h8xlA+B6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURfzeNKANIYSJGTMuW7yraCIoAPgwHwYDVR0j\nBBgwFoAUsz4HxsH0+7G42gQ8qDOFJX2x0jIwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDkU/IItUHK\np7u502LDeSJSVFtuJNzpkD/LtgPbN/LXzgIgO6wVbZ0SSuO4ZkeabsqRr5uBHSsw\na98kx9JxAZP+3EM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX3eonfQk2Cxr1TCY6fPWIS6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmM3NmRhMS00ODBlLTRiM2MtOTgwMS03NWVkNTVhOTg4MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4jbuq+5COzQYHnweftWwKYU9vEOk2zMXrvbpEvQbOiTLX\nqrBrrl71z5uI7EHLOxlZg30H0nkIRtS/CYORp7CSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsz4HxsH0+7G42gQ8qDOFJX2x\n0jIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPGV7ZWTe44f1PFwDuMfye8KA3flCmZ1JNkLNP9hHBAkCIBgoUdflPzkD\nb39RMuCUpifrEkB4O+K0b+2AngL8Ilc+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAT4vSqdb+kWZmS5GW/ESjG7dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk1NDkzM2UtOTVjNi00MDFhLTk5YmMtNzEyODBhYzE3MzhjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMzZDY3Yjk1\nLTg2ODctNDIxMi04MjBlLTMwNDE1OGJhZWIyNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOrt/5jNMAKunXCT1rMZlYlIcu6PJYFUOiDODUjspKBQufvy+wFjHtRT\nin81Aw1bMcu3+ZwQJ9jkM0ezdhQxBPWjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEX83jSg\nDSGEiRkzLlu8q2giKAD4MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDvAu86mCtkX0JYmO9K1sOLYfQJJFYtoAOKZn3ECFD6ZAIh\nAOhKj6CNiKqspso68CcVgmx47RieHlRFiZ8xvLXBXzCw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5383", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5383` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAXULzGCYzevrKjIsJOPQz9eDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2NWViMjQ2LTNjYTgtNDlhMy1hNmQ2LTc4YTU1ZTEzYTQxZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzE3NDI2OTAtZmFl\nZC00YWNhLTkzNzItMzM3MGUyNzNiYjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPUbRDbRliTayzESOhw+je61qdlvXIDaVE+23rPKoCYcsoETRNA17ldOw62G6\nEqMhyzejjcL4IHjo5qQZkN9/XqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcowu4EUEUCpcWVJBJCCKpY/acgMwHwYDVR0j\nBBgwFoAUeD/YCj6TFlsvgfMFkv9ttKo7ZcMwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBL8E4qVJin\nMU9qoBX3eg8By3Swxom1aTeZfbhlFbP8TQIgarbzCUzNbPDrPypv+coDftCg0HBF\nvNnJ+MubrBOd2Jc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdEKm4Elh5jVl9P/0C28zLa+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjVlYjI0Ni0zY2E4LTQ5YTMtYTZkNi03OGE1NWUxM2E0MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxzBDfWZCJAaMQyUcNrcWd12Ul96aA1iOo2R7RsrqA2VOL\nYNe3stveckvTV/cwHxFJwcYRJFgCv2u0akAQFCbto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeD/YCj6TFlsvgfMFkv9ttKo7\nZcMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH6R8Sb/W+RnPbk4uBs1Mc1uxAyGao6GMhYr16NJ0SDYCIQDIuciDr8dH\nYZh0ahlRcDnN57nQo5lQstpHEJ2v5a9x5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAdxSWd6fLXh41Yh1QFHsc/sEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzE3NDI2OTAtZmFlZC00YWNhLTkzNzItMzM3MGUyNzNiYjkxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM2OTc4NDVl\nLWIyMjktNDAyOS04OGI2LWZjYTlhZTY5ZjgyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOoYJhJ776DD8rKsEruv+xv1qL3FN1DCNHhVtVw0t/Xq3y/TEDKxGZt8\n+t2b1r0O1iP07Ya/+r5KFpqH+T1v4VCjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHKMLuBF\nBFAqXFlSQSQgiqWP2nIDMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQC2mEBcclf9fifkQmyghhTLNyrkDeorsWD6teLq1XzrYAIh\nALg8OnazAixRf+YZKlkq2DS3AGVESzJTcHAI4AnFu3rj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5384", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5384` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISASLwwvv9+WolVfJNlBRaq85TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMWRmOTUzLWZhODItNDEzYi1hNWNkLWYzNGI4MWU3ZDAzZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ4OTBkYWMtNGNi\nMy00MzYwLWE4MGItYWFjNWUwMjQxNWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMUDqwn8dhmsb2kUetcwXUWT9PBVLE8Ps9/MPgeeSYTVRwTi3eak6/f28yPB1\nkiRIaDc4Vl0vd2aHAtjm3OjYZaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Ua8elfVUdY1JRzKr0LsrPDBhPswHwYDVR0j\nBBgwFoAUR7yJBg55XYDxwf1LqUw9MufydTUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiAyClPC48aNrI5Pai5iDtrGSeZQXE4+MCIAp0n8jl5PDgIgdW6yaIJGZMSL\nVC1t12HOFuyvay1llkNXkw6N63NKeAc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbYAG5/wTKp8/VMkqJkcHCeNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjFkZjk1My1mYTgyLTQxM2ItYTVjZC1mMzRiODFlN2QwM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzNnUFErP6+EfFDErinIQJDybkslqO8es4QlTtPvcfUMsi\nI6Rzeh6vwcuIY2MIzZdVi2AT9rx9rAamVe/ce92go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR7yJBg55XYDxwf1LqUw9Mufy\ndTUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK241Zzp+fVc7e5f0tdV0f2s86pTMvFFjMKlczHwl4xtAiBonyzzTBmX\ntVqiepvmgdUn2x3u+KRNmaBvdu+UlnAs3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZBEDYUfZIPWv0MRp877gauTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ4OTBkYWMtNGNiMy00MzYwLWE4MGItYWFjNWUwMjQxNWRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDViYzlkZTY1\nLWU2ZWItNGYyMy1iYzIwLTlhMTRhNGVmMGJlZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFxR9kiSwtYBi397e2lpPBeMSTdvsRV1CV2RK5oNnsI7JIeNB2bW2tf+\nqyLZ8UjWlIzNcoL5I6h/8qErMej6sVujcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPFGvHpX\n1VHWNSUcyq9C7KzwwYT7MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCvTc8+EqQBjknQ1PAZ9tUu1xC4zIrStrPnxGN7UfPHfwIg\nYakqn8fsYc6MUhoYt+gzLbpT/jkA2JUnqqLWPvmU0UM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5385", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5385` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdPP9pXUouiF09XkJUKrWo/5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3OGUwMmJiLWI0MjgtNDUzYS1iMmVmLWNmNWYwYjNiZjBkNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZmMDlkOGUtMjQ3\nNi00ZGU2LThlYzgtMWVhODIzMjNhNThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+V2UZWXdsLXdiqygt8JNdpzudE1yLSkVAXMkPaoT618eBxTvmlOzWwb+rMnc\nc9QVga+75Qfb2rCil4RrtKh/6qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI35mUJU2EyXHQK1zh9KJd2bAP5YwHwYDVR0j\nBBgwFoAU0fztcUStI5fOYlM8LElIt0dwy5cwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAXi9TKpKZqhCOpar86pzftJakR+gIwnrcug4+ibpWv+AIhANdztuLScU8P\nuIw5LXT0HPAIT1ndRddAvtRYzG4BgL4V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXyIGh7ouvay/2aKFaRpyWfTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzhlMDJiYi1iNDI4LTQ1M2EtYjJlZi1jZjVmMGIzYmYwZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsBBbXH8wAhAyMLARud+1Wiff0U3l+pLw0K/hc6ClblpKb\naRonp1MggXuIXE3oMFywbJU1yddgjPc7QgjWL8w8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0fztcUStI5fOYlM8LElIt0dw\ny5cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPezDtdIrQQu4R54FsWnU035sJr3D5AopGLmQH5YLQGQAiBYrMSxK3k0\nSqcO7naZiF534pCSGxIl0gg83du24Htw2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAZMuP9ZIt1SHoUfCV6Q+7toaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZmMDlkOGUtMjQ3Ni00ZGU2LThlYzgtMWVhODIzMjNhNThmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3MWIyNTZh\nLTY3MTgtNDI0OC1iM2UwLWZmZThhN2QwMmNiNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHzmbA0PVDU88SrybHPZcE2gLmNBw8q1QKbALiy5aeXJAdmybYYVfMAL\nptety6oW0yW+eDLoiZBxLXqJk9OCtOGjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCN+ZlCV\nNhMlx0Ctc4fSiXdmwD+WMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIHC+3uis/v/M9/hxxqbIB2Y3UJVHOd/6WStWm4Ww0honAiBQ\ndEmY1Wek35GzG+dVop2Y7YMzP5nnahC8EdknZnOchQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5386", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5386` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAR4ojx/w9NiOc/QZhSj3kfnLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1YzIyNGI4LTU2ZGEtNDc3MC1hZGExLWM4NDE5NDA4ZTYwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNhNTRhY2MtMTYx\nYS00ODg5LWJhYjgtYzAwYTI5MDdjN2RmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERvnR+21EcIoP57bqTHJ2KxwD4qos+rhUc4D0/MpSTuNUQdFyOiVNGWO5hklg\nUP+ipELVbjCp/wf18yynRQNjwKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+N0z0vaO22/GG14HX2GT/akz8P8wHwYDVR0j\nBBgwFoAURGkSfdiGol5B8d6yh414ogacHqwwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n0Lcn1+zhSK/VlWdJlB5TRnh86w9715SNZ3/6xEahIKICIQDR26zvthN74rZVjFAU\nLtwfrRHELEihCGot57Mow9CGuw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZoHj/EfB3/TSh3xiBpCd01AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWMyMjRiOC01NmRhLTQ3NzAtYWRhMS1jODQxOTQwOGU2MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4THfud70djPoswZ76bA+DdAjHLOjANVr1JcZTVKQwL7FX\nJbLWO30CUl2vu2LiRb4qBpUTF++lOI693R4o27rYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURGkSfdiGol5B8d6yh414ogac\nHqwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB0jsxPlPckP2I5FHCGTAHZxDo0W44mxbNkRJqENcH5MCIQCFX6WCzKiH\nMkTkze3wLfQDbGhlVQL2VH4khMabLPWdCg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAWJCxzeQeFU73/SkkuwEh+gUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNhNTRhY2MtMTYxYS00ODg5LWJhYjgtYzAwYTI5MDdjN2RmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU0NjJlOWZm\nLWEzMGMtNDFiZS04NzUwLTc0NTA2Njk4NzM3NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBqIdLYt9yMyD4p7MBZcGTS9Zg2gdezDXw3jVtp/1JLEVCXjo172Wci7\nkvC6rvu9XlabF5FWolFzqVhnczxtCFWjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPjdM9L2\njttvxhteB19hk/2pM/D/MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQD5M4m2kUrwHxZ/anTOtkLiVLkqUIgtF/mtU36XmymSkgIh\nAPt15AfuKV+N3lU5SqPC85yB+cxKvDzXOQz120UeU+iA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5387", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5387` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAcpSksGqQlgBXwo6IPMv6MitMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZDI3MzY1LWE2YmMtNDFjMC04NWM5LWI5NGVlMzZiM2Q5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFiNmJhNmEtYmEz\nYi00MGIzLTg5NGYtYTMwMDZiZDUwMDk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5rAW8IXVvRK8sdwCzpINnhI5W7utl6ADlNPuhy300gvfsILFv/a1gfHJMOIz\nFMlDfdPFAbDAZ04XFYRuEHxpNaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmbWcZ2UY+/T+t0DwF6TKKjhd5NcwHwYDVR0j\nBBgwFoAUv6o9cav9UFUbiAxeBPVhBtJg0BswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA2jQjf+zbu9DWG+SRdHxtSGhtgr4pkloF5cjBG32CklQCIFyt\nsuiDcT5mUbfRKJGwD9Na2uEKQa4TOmeFe3wUcN42\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbHeaCpQWgBwXU1vQ+gOk8wzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmQyNzM2NS1hNmJjLTQxYzAtODVjOS1iOTRlZTM2YjNkOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlYd4IL0WvliZl/w+2diyc7y0ARD69tnVkKXzArZq8kxPX\n5e/f8B42/3/WC+GBNl6jEsOgPpOZsz5D2obHDCgVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv6o9cav9UFUbiAxeBPVhBtJg\n0BswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOB2RGZsTapmwcLKq/hk0/FYA+mV3ErAeRcxlnEGVXbTAiEAlb+t3cnI\nhbapkL/NUGG0t4K5Gn8jtFiMYHhjUDDWH9o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWXkiack1kVxZNWr3Wpc3OHMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFiNmJhNmEtYmEzYi00MGIzLTg5NGYtYTMwMDZiZDUwMDk2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg0YmI0NGVh\nLTkwYmYtNDU2MS04YzYxLTNjM2NlNTljNjk1NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAC5ZLUTgOfsXTtT9DLxQyse/kQRbsRqBIfkU+jWAjlFC1ZDzokvx3vg\n8hY7PMI1ld0taImNKOiiLPenjeXSSXyjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJm1nGdl\nGPv0/rdA8Bekyio4XeTXMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDk5KSjoIokVv3Hfs+3fECb+SfIbEqntwuGymFvszjSOgIg\nS/WdJ72PEBrhTHqb+4ClJ/vn00PGIjfdI8t7nJBNqR0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5388", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5388` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAcdrsa7qwOFWqHqhKgrtoOZ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMTZmMDhmLTE5OWUtNDg3My04YjYwLTc5NzFmY2UyZjk5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E4OWUyZGMtOGUx\nYi00Y2I1LWJkNmMtY2I4NzUyOTNkYWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPO0uAOemFE3fMPNatHJyXYFr3mrM82sRR/AW3vXYIJjP0qG5431qK/xUP234\nfsdHI8ZfZmThWiplBbpoFxQ8qKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWjNWaBFSa83MwuHSN1brU1UaYuMwHwYDVR0j\nBBgwFoAUJyV+YDErWNS+WNeqfDTy0zmAO2owPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBxFcJFjwiwPUcz0rXwfqsH4BoqaShJBRE0Xkx8qotBRQIgKlNX\nrmqsokP2F1ZMxdy+29qlL6DQKwA8uofg80vDmTo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdZkaJF3xRbCizYau6xRlTHVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDE2ZjA4Zi0xOTllLTQ4NzMtOGI2MC03OTcxZmNlMmY5OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRe8iHKgyE2sE6KlgBCgZ6O+PfGVNc6H9XqgFCA0D9iFqb\n7IwRt5/1c8/3nHbG7JIARl19WU30C4hkRUwvUEGvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJyV+YDErWNS+WNeqfDTy0zmA\nO2owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGer+QXuxaBPIjUqqwx8+rAvMoTQ+kySjhkk7k4No8ycCICJBEjW0OPZT\nhvYosu7LDxk7Yaln2NoFi+kmpKmH1A5O\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAVDU/0zGzwAevz2mzvJzziVzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E4OWUyZGMtOGUxYi00Y2I1LWJkNmMtY2I4NzUyOTNkYWViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY4NWI5YTk1\nLTc5MDktNDRmOS05ZDFlLWM2NDE2MGI5YTM2YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB38tbb7eqOigj0TA485NAtnAWCGsKY5jyz16ZJ2Xu2S0nnfn31RG9NI\nrtuGm2OvxZqbuS3zMrPdSBSyRcmNmTujcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFozVmgR\nUmvNzMLh0jdW61NVGmLjMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIFkCVvwiQt2ELaAa3OpStZ8z15sp6Gge+9uJEJSb+hNmAiAY\n6PrCWb5omSNPyCwrmeyAPJ6r8E1zEG+KrlWeGsyYfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5389", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5389` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAUaGjEXPmyCKAVlJv1/5MBLSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2MTI3OTE5LWRhNmYtNDc2ZS05YTA1LTQyNTJmMmIxYTI0ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzliMGVkYjgtYjQ1\nNS00Y2MxLWJjZDctOTU2NjAyZDY3NGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu1359JJBc0AQwcixKIZFoWxkWzSABpJRMFXME4shnjOq2QIjpGsi/BNK79CY\nnnsDPKZN3DQCeY8R+QOYrCYvaKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4H0485uEdyDt25lGXsOAV4JwiwAwHwYDVR0j\nBBgwFoAUWxrDHV+aHjyKOOpr1cqSBjlZmyswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBMlaqzTIwMEZ8E\nqkMJr9roqhkD/2PGO4Q7cL7LHyszzwIgeRxuvKOzMXcXCvlvc7KlDGmJHNXVZUNR\nMF5M7T/aFc8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdvAQa1EftUmRDzVjMg+4d8cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjEyNzkxOS1kYTZmLTQ3NmUtOWEwNS00MjUyZjJiMWEyNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQf7cmtHCbctH77MDcu4Y78tySjhjZy8GUt43CAwgI2CeRr\ngHL6VlyGcvU1MeN2G/zOECSxGqAwBWQNOMqOKSvoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWxrDHV+aHjyKOOpr1cqSBjlZ\nmyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK1IOELnz3M3fHyO+TAzLjljyolPrNDHKWdu7KG2F14lAiAuhFjIj2nf\n+VzOsDn6u4RF5+asy0oKRIntj7LmMhe3NQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATFXW6jzWWIKEDi19IsFmIZ9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzliMGVkYjgtYjQ1NS00Y2MxLWJjZDctOTU2NjAyZDY3NGQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUyOTQzNTVi\nLTIwZjgtNDg4Ni1iYjNiLTZhMWQ0YjgyMGE4YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIQH5vncjvLJ/u8Ugh5r66vpJZUwGtcQRepLFJPKbPLdYgjwZOd/pYk3\nGqXeeA69hTXxJeVjfUYLxwZ9Uj7cE/CjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOB9OPOb\nhHcg7duZRl7DgFeCcIsAMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIBgowBR92FdsKE1vEgU03rKDGIBCnTdNXXmmaVIfqBvgAiEA\n46B4cCxcNEHhK3/jofG++x0LytK+M5wKZd3dzxSESf0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5390", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5390` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVDVMWCKv4nTLSQlwdBOTLFeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxYjJmOWM1LWZjZWItNDM1Zi1iNzhhLWYwNWQ0YTAyZTQyZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFjMzZlNzUtMzI2\nYi00ZWIzLTg5YTQtNjM2MjgyMzczZDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0T2MUiZwmSe3nxTZfeyE3E9pPa8ZIuwYM4F97fnQnMODRow+zSfFeIzxyxvQ\nDbTtxomTIalycXE0Ee9QM6vkcKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5jLyQcJ9L70xoQ2yxX7NdT0pvikwHwYDVR0j\nBBgwFoAUGtkHLOoa5fiEjX0IrREFDWH3LIswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAiIYilJ0ZRLuVqnaOkOToVFSJHsNtmHFd1MqRLJolRbAiAonvse1Irddh1N\nLiFRmBBVc97taUK2AzFZihk0TYp0cA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARrolObR4KBdbo3Eq6pJjt5jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWIyZjljNS1mY2ViLTQzNWYtYjc4YS1mMDVkNGEwMmU0MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSWIR7J2a8G/u15KQaZn22usOqQxHI6BwkiGbOHe78grP2\ntG3pF6gcq0PaSrh/n1VGY3ng2oonkEBeVvXJoj0go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGtkHLOoa5fiEjX0IrREFDWH3\nLIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbvvwAnEFYO9DZ1JD6bwcuL642GHtO5M9wwJLcjB8uW4CIHnInWI4osRY\nmA/wWXObLe/xHm+G2qHrzRzifduUOiGw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXm0QAwS3xPAZVxZ2LPhxOZ0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFjMzZlNzUtMzI2Yi00ZWIzLTg5YTQtNjM2MjgyMzczZDBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1OWUxOGEx\nLTc2MTUtNGQ2ZC1iZDVlLTEwNzI3YjdhZjdmNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN13RhXCPDHReYJamFPlr1gO4nvlKmsCX+hPEOUjPTqCjCp1Ze3uWcvJ\nC3AOoul5oCsrizvk2Z7MWtQlXHiwLByjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOYy8kHC\nfS+9MaENssV+zXU9Kb4pMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCzbyeRlOhD+Re3fYXDrDXvZ/Q9zN+412ClYJALjE3H7wIg\nXOzt72J/AQDP+wgM7DW3ylyo8DJTfPXy65G+uFTD2/k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5391", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5391` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAa0anGfw51urpHQmi54zjbsKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzOWUxNTE5LTlhOGMtNGRjYy1iODViLTA2YWNiYzU5NGU5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIxNTMyMzctNWY5\nMy00NjJmLTlkMWItNzBhOTc2MGYwN2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE98fTV9akMIOBDzFcBXOEeD6XcD59FqzzqveRHy8Gb02UuPQX/HUX2KmJwlXf\nGr9J24yseJ0tF8KIIPkqzxgBDaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL5Z6kpG9/YwD4RGAtA2aa74hqyQwHwYDVR0j\nBBgwFoAUkj/xrpdj0MNEpSYcvXZfgCLyWFYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHeN1Vm+7uVEd/PtCTAk/X+G7LroNOxkeNLiqHMXnFrsAiAEYyE0niV3qPXb\ncgBTBCLHGz7Lb9X69zL1/cVzCne+9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT2zVnLIXIEIU8njJyv2i6iNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzllMTUxOS05YThjLTRkY2MtYjg1Yi0wNmFjYmM1OTRlOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8nzjENPD1VBeYYnZ557pFGo9sHY4qInCOY+dcppSBU/TO\nUjDkFgA2130+UD6YjMdmBbGB51eIaobusVBoi7ePo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkj/xrpdj0MNEpSYcvXZfgCLy\nWFYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf3dFEUnc+RIhg7wnJ0rp5WHT3DealXTSnRe9g1O1nLQCIG7+LKmLyh7i\n7MlBcHsqgNVg9zX2VjpVXnSl/E5fqffw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISASShor6Yy7EQig+DO8KYwqHOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIxNTMyMzctNWY5My00NjJmLTlkMWItNzBhOTc2MGYwN2RkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM3YWI3MTQ2\nLWU2N2ItNDQ2Ny1hZDljLTBiZDkyMTI4MTVlNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJxMHMG/DFF8WyRtKvqyevo/L+0p2cMWkEltcUHR+IPsPSZRFVXoayFQ\n+ceVvqpkhu4II5naPoEG8fYf+46IApSjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC+WepKR\nvf2MA+ERgLQNmmu+IaskMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCxIein/3nmx7fFqvM2j3IAzX5E7mQGuTiBJf6BeE325wIh\nAJgx6BDQYQG59z9Cw2J/I20/YBEMD3ZFW/cOXCuwTCy0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5392", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5392` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQRBVZM7WHVWakH/FPk2vybZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhYzBiNDhmLWI0NzMtNDI0ZC05NDY1LTNlMjdmMDU5NGFlZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU1ODMzNDAtNDVk\nMy00MWJlLWIwYWMtNGM5NjRiODVjYTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn5GVzKG+04/5XAR69qtO6EV9p3aB5nP/vZogasJGLLWJLdL96IuCLfXV7RZo\nRQcu9KaLIoMu9Y1MCzZQ3oEHLqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfmTiXBMSvf+bgwwHIzhG2GjiJ7QwHwYDVR0j\nBBgwFoAUQEOJhwJj8R5wRxK2ozDINsEIw+0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBnh+WWwkE2YFuzbdF81FX+3lepKL+PzxPrirbB9ZajPAIhAIhsJRkQ5OUH\n7dd083J+QatAbcaiAwM877C6y6VBiq9V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAciMr8lINFyqCdzF5hYKTcg5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWMwYjQ4Zi1iNDczLTQyNGQtOTQ2NS0zZTI3ZjA1OTRhZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9cbHiFqZqcZABweHG2a//ki0p2CF6dRnNgpvbeU7+alpX\nmMypILlnO7BCYXsNtrnBspUwJ3iRoyLq6w+hWDa5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQEOJhwJj8R5wRxK2ozDINsEI\nw+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALYjk+isIJvaRBO+3WFkA1Edp7y0Fnjy2NCv5Qi+0K+sAiEAuVtT4RK9\nxzyHmnMbcLkwT9O4EAmUTu1skvtM4S046m8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAZFiRDW7u3Pe3DukWTF5ezupMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU1ODMzNDAtNDVkMy00MWJlLWIwYWMtNGM5NjRiODVjYTEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDViMWYwODEx\nLTJmMWQtNGU4Yy04NDQzLTA2MzdjMWE0OTQwOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH43FiKSZSlQOx1xHSFlKgWZ+WGvZ1HCsG1RjIVGMVBXyr47rGeFRKOR\necU2EJjN/m3Dgvk1IAUhwBhCOnXoPEajcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH5k4lwT\nEr3/m4MMByM4Rtho4ie0MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCICJ/UQcZR8XJBzM4rjrzBIE1APL5QbmkREYgFIqdbzwzAiBB\no589Yvv8DSq6AQXpHaDgltn0F6WGExHrqLDWEEyYeA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5393", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5393` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAaA7FpYhuQDe7v8km2L0XYsfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyZDc2ZThhLTBjNWYtNGZmNi05ZTQ4LTczOTkyM2IzMjAyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThiYzdjYWMtNzNk\nOC00MGNkLThmZmUtNjZlOWY5ZDAyNjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECX0OZA+K3shg4zjq9XGn/YuaLUvRENGxIlnQ6QKVuJCZmhbuuJei7g0sFRcY\nQMbowgLuK1XjlhM2uGa2lDsezqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMwC9ok/zl+3FDEpKCCJEVyU/yOswHwYDVR0j\nBBgwFoAUwhu3XJc56uQnMUenQ7ncAfZLkXgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiASlbAacmesxKujKkGl7EGrzDRvkyfGMSeoW7Y9/zUC\newIgMrCkjT5opIWLE2elC42UEQG85YhNgMXvyFwADukJ7O8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASTQtIusb9qCeI8SGewYXkHgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmQ3NmU4YS0wYzVmLTRmZjYtOWU0OC03Mzk5MjNiMzIwMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1ehbtS2UIOoQFxWHqmZZVRZs4dvSkYybXJdrm3YK1SKvo\nldhd7QySylYRzhiQ24XGyzkFqO40qFhcoH5oj9Eoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwhu3XJc56uQnMUenQ7ncAfZL\nkXgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH2VbSFC2HmENs+vfXKRs0gdA3gSqYKK2mY5TJcHcc9sCIQDimecxRJ6T\nO7cO6dO/3ULB9X/HGNc57LGj0RRCGcAXWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAcgvSuO8u5zJLOrbkcapKygGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThiYzdjYWMtNzNkOC00MGNkLThmZmUtNjZlOWY5ZDAyNjAwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY5NDMyZmMw\nLTA0ZWUtNDUwOS05ZDZiLWIyN2QyY2MyYjQzMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIz1JZpj80B/VeGWAqn1guv7yWR9H1B8XCDYi5PM5Je0ACW6kZ8BnMr+\nZkGIONMavRAfSxmnsZwmCdoaXFfqCQmjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDMAvaJP\n85ftxQxKSggiRFclP8jrMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCeZxIT7cN2x3dcEXx19il5j5jTlIpfoaRPc0PBI1dDWQIh\nAIWz+4cxvQk2n5GfCPytnIQzbEz+9GY223awZr8kw02I\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5394", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5394` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAQC7G1YCYmoq6Q23KBYCRIVCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmNDI1YzY5LWJkNGEtNDY1NC05MmMyLTk5NTM2ZTFiYmNkMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y4ODE0NDQtMjc2\nMC00ZWViLWE3ODgtOWQ4ZTg4ZWJhMzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER5k4avhPTrOAfHH+qZ5eRDMLZoV08R2X7kvoV8GfUb9yWS8CFH2o51UhpgRn\n8/Kv5LEr8skQI5/xNXd30nktXqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1SRLPdgdYMbTnxprFy8nfOXQUXswHwYDVR0j\nBBgwFoAUDAalP6jm4dAsFuu0/s5f7RFDYDIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBFk7CtT73/pqvcgEeK1b195Gp8r0UF1pIE1c6aCHX3\nMgIgN28JOKM9fOKfjhsppw0+XLqzWkTFc41ZLrd0RwV/w4w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ1ag08K9aVtuRG20Hdws0xiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjQyNWM2OS1iZDRhLTQ2NTQtOTJjMi05OTUzNmUxYmJjZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXMy0O573LVvBo/HceVUGip9P2S8opkXap0vbFUKHijNbw\neJb1JKF0Oprl5RhAZooT0ewE9HUymiJwwN7yQO1/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDAalP6jm4dAsFuu0/s5f7RFD\nYDIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNyRw+yjWsvo2a4ApKWe8V4FQy0KBztwv6L/Otofa1MQCIFPvjfj+X4qo\nwwE409RaaLx1UbrzWEH9hMOyHEBh9b2F\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfXp4Ab3MuxtO8SYheGb9/izMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y4ODE0NDQtMjc2MC00ZWViLWE3ODgtOWQ4ZTg4ZWJhMzZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU2ZjJiODMz\nLTNjNmYtNGQxOC1hMGUzLTI5MzM5YzQ0ZTI1ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNtKcFMWPjCR/q9Gs9ADHeFsWHA06f6AmV1TyUC0qRYffDVCaCYLRCY0\njKPBHIfYQ9VXMfYTuDOKrmdzsBZqjJejcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNUkSz3Y\nHWDG058aaxcvJ3zl0FF7MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCMaHOVDQRDby1bxsr4R6IYTGXuLGPQHY8BtLZoNnLQBwIg\nD69PdqpZ5r40EsySbcjSPSgsSDji7G+jobBQw8Qx/34=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5395", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5395` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAbr85yTOF/dEYdTsZrBUGyaRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzYTc1ZjI0LTU3OTUtNDNlZC04ZThlLTk4Y2VhZTY5NjlhOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODIzODcwZGQtM2Iz\nYS00Yzc5LTlhYjctY2M2ZDI5NjQ1NGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC0itHqx12m9Vuh6P1Wx5ViDYvmHPX/kbukqm6xYm2jV7QLr0typYFkUIDMQs\nFnRgWNPT5r9IAC75JaES7z4jjKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3yfx9kfngKwqXEJn5my+4TIZ/gowHwYDVR0j\nBBgwFoAUhvNRaDJsSHc1SW+Vrd9RWBFspBUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAv5PyNMW3SGFHaPGXeeG9qxX/8Yl0mU7YVFuOH6spr7cCIQCS\neK4+bVheUIuC/7nqr2MxtVHwOxSEelsi1gMwliWofQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATKxzrqh3nadPhAje+cNokIPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2E3NWYyNC01Nzk1LTQzZWQtOGU4ZS05OGNlYWU2OTY5YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxD6OHwFLmlYKYpnho0gz3jWTu5DDUhzW7GjJjjyVMDJJY\no8/lELKTRM91DK/4izyixdAgq1db/tLeOVD9oOVLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhvNRaDJsSHc1SW+Vrd9RWBFs\npBUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA5/4bpvloQP7qYIWcTL72wPrQST1QvuOB7RGWvMycncCIQDADWFoMZJP\n47kpGR0z7mARZ1XwvJkKFZJWia91bE3kQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAYWE2eYLY7fu1Cya1rET5ySIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODIzODcwZGQtM2IzYS00Yzc5LTlhYjctY2M2ZDI5NjQ1NGI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJhMWQ4OTY3\nLTE0ZGEtNDdiYS1iZDRhLWEwZGMyN2IzOTVkYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAGWg2N6VgH21FQ1aK/g5ZggUEIDnp1yNzQGM1igpHTxAF7CHuf7a7Bb\n0n3nZ2T0omPI0jwujWJEvCx+GpRbUCijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN8n8fZH\n54CsKlxCZ+ZsvuEyGf4KMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCBhYNkUTRU8qvd6ZxVpCCZZt6hggf9+QjyXLi8ZdXVUgIg\nWUM05YSVudmGKj5n93Fyq3HPUPdoeTWUpYDFyARXQoQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5396", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5396` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdTTobpRI4VHw1YMp6o6ZrAgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzOTEwYzk2LWM1MzgtNDU2Ny05ODUxLTQ0MTJhZDVlZWU4MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVmMzJhMDktOWI0\nNy00NTVhLWI3MjctNjViNDc1ZDBmYWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER7Mvh3SSP6eBS8sDS2NbGRzgwrcR3W5GNAkWctGCQwwvYBfhjIkiPcnP5yP5\nBucQ1bWqWib4o8SYEqNea2aufaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK2bNsgNsA22fPVYJOwUYok5UOhwwHwYDVR0j\nBBgwFoAU9kEUxqOpP65QRHFZWXq08lr0d/MwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBLl1qVNM7fwCH0yyC39YGqMR7RZDsDhEI8\nx4H4lTt4GgIhAOquoxF9paUbbuT6l52cnqOyXcT/aj2K7QwdgqHmTCOD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbWepzdhBt+gqCNRJCbcev1hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzkxMGM5Ni1jNTM4LTQ1NjctOTg1MS00NDEyYWQ1ZWVlODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlGE4kg0pCtITkIwjkcvmq3iMLYUTR2c6M8Lfd/M7GztYg\nsEqWz0H3Ak4qpLlySwAd6vsYnaljmFY/hphNddomo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9kEUxqOpP65QRHFZWXq08lr0\nd/MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI7zAmYxEa6QlyC9mJdkfy+h7FMpXGgE1uwwmP2rg/NWAiAYJqux6pFZ\nRJ3Onck3Kek0wbNewhwgSDNKQLWq6BupNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAdFmmFd7pUO+QaFRC6NBH2xWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVmMzJhMDktOWI0Ny00NTVhLWI3MjctNjViNDc1ZDBmYWVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhmY2UwMWVi\nLTFhNzYtNDgzMy1hODE1LWJlZjE1NTgxNjQ1MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJn4/EVp0SqiahACoJT+yb1MAzK8LrpIHlZ/zmTgVPKBcTgIyAIYnZNY\nh4XQckQEVo+J8/9uMnz3YA+CiMmfmXejcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCtmzbID\nbANtnz1WCTsFGKJOVDocMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDOH+NX8UkqrNioD/lDowMbqgdGuPXHq61c+x6RL9oQvQIh\nALP/9w+G7gLoZuDz3f2ZqtaEevtuKOeP5cHNUf93aql6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5397", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5397` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAfuooDrqSiaQNeQKblU+RBHeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYmQxNzA2LTI5NTMtNGIxZi04YmZjLTlmM2IxODM4NjI2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJlNjRmZDAtOTE3\nNy00ZTdmLWEyMTgtODk3MTFiNGU5ZjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEucqS0GegOVon1+sJh7d/H4XJLxNQnETYfn4jFO4lk8UV1rsBVeHBRGUBeHJz\nZKGlu84Nv6tzQEiKbsaheODWCqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaMo9rTeR1P+lSpVGSlGi36tpJw0wHwYDVR0j\nBBgwFoAUD5XB7/21BGE+xKtjrppu23L0Tb4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBNEZdub23/Yhm2bGcqHuok+eqCHIVOJCEn\neNwSCslNFgIgY/WlLkhzu+Ji3Nd5s6NFEkzbavQzPA+xtloO9iLbWg0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVR3G6eADbI1UppE3Nr7VIkwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmJkMTcwNi0yOTUzLTRiMWYtOGJmYy05ZjNiMTgzODYyNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuhv/O3JBgW6oRMBXS2qbZQR8EsQRgwRnyvJ1jeJbM2flm\n3MFawa8o9qPBBV62XN3rnm3kKfsXv0qrVX2zErHlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD5XB7/21BGE+xKtjrppu23L0\nTb4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPd1zswevlQw5gJBcuC0u/tUhXhc0/bl/AykhTAdsoC0CIQCIinfNw9fU\nnPBpXmGb8/5D1bgRX5YF/bWPen9P7POQYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAa0+Q7+Gg4ukx4KkB33hmKz3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJlNjRmZDAtOTE3Ny00ZTdmLWEyMTgtODk3MTFiNGU5ZjI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyNzhlZWE5\nLWEyYmMtNGU5NC1iYmVjLTgxNmI2MzdiMzhjNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG3EZVbqyarHZ4JGihh5iWrXAoxpogKwrnkcNx6ZgNsq0CDvdp9yJbKq\naHg182uYx2xmaqV5NXktEtVbXFlTQDGjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGjKPa03\nkdT/pUqVRkpRot+raScNMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCed9FHmTShGR+9ZUc/Z2/yypbiadLV7iqWKd+BOJHaXAIh\nAKRGsc9fr+rOnsjs1iBiTodVu0Owql322bRaSqQwux46\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5398", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5398` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATqsC1sAIleWM5+WL5xv18QAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmNjBjNjRjLWE4ZTktNDJiNi05YjJjLTA4ZWRhMDdmZDQ4NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E1MWI4MjctZDBm\nMy00NzgwLWIwYjItMmJkNzdlNzY4YjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESyLhcZ0EHicrxEJnFZvTntEyxBkItjXBM8I1FKSVNVI2uNnhQJWLWURQX9uF\nzf4KgWvsEHA5C/g80DLigYbwO6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyjlJD3j2gCjMRoOeZf5f0y3MtMwwHwYDVR0j\nBBgwFoAUb8g++Q/9cfIFHdMWK4YopvrNRLUwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiANLGEeYV1bn2Bo\nqU+XUur484Gymo5vAGEkKLrkkxkeqAIhAIAyzTn885ZVHRDtsKi/n65BJrGZg7Rc\nfSVHwz85jBR6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZQWtYCUv+8/J6NGxSY9iit8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjYwYzY0Yy1hOGU5LTQyYjYtOWIyYy0wOGVkYTA3ZmQ0ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGt+pdRqURgm2RYO9yuy4pCe5xHD++ptPls5sl5GSAkmB7\n6s5pVoWRh2YgGgUFKXhjT5pqmNCkpwM1EW0wVKqRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb8g++Q/9cfIFHdMWK4YopvrN\nRLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCdnlGsXomE8Wh5Nuk46FnMawrl4tV7n26XL3dTF01UwCIE7N/esfuNI5\nDHv4Q4v1nWWrv2GviogW6VAhkTzF1PEU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAXPhgZmV3cAcRCIF+dyTu8LsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E1MWI4MjctZDBmMy00NzgwLWIwYjItMmJkNzdlNzY4YjlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRlMTU4MWI3\nLWY1MzUtNDRhYy04MmVhLTY2OWU2ZjE4OWM3YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIXHwHgZ3EgfQp4hpmek6z8biC17EOYwpr3X3fQSqcijtSZWtymUw1ur\n/KcRuFsPcUZ6zMyFzgJIL1HjaL+Z45ujcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMo5SQ94\n9oAozEaDnmX+X9MtzLTMMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDQOsQPQ4UpC6/riBGLAsLDpIdB7m/QACFrdGdYAyYZhwIh\nAIoPxddiBELw/3HcfEmA1CJ25WtO0qViVY4ZZWX+VzQ7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5399", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5399` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAQlO0smT1nq9rXQ2o9+0V1f1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYTlmMDY3LThjNjQtNDdlNi1iN2IzLWZkYjdmYzYzMzI0ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE2NWUwMmUtZDNl\nZC00NjQ2LWFlNDYtNDE1NmZhZTk4NGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzh/0xLenNpPsP/edjRKobgEzTUjxmlAO5qu0hI7GctZy4iNs4vJa9Njqo4HO\nmqmfws+MMrGs+BMDPWDa9Xb7hqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiJNALZJTZ+owX7tMwuOGtXRpvKMwHwYDVR0j\nBBgwFoAUi3YPqP4y1omD4RqXOcOPcmfYr3wwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCTVnMokKwu5Ao1medZXo3fVPWhc+5E6ik99NYz2AesjgIhAIkJy/TaFJKe\nPJDvYKX9wqKbwLCGjKz5V1ZzsKMDdHCk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS+sJ9oK8SZMEaf81y2glHI2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2E5ZjA2Ny04YzY0LTQ3ZTYtYjdiMy1mZGI3ZmM2MzMyNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/k1MRuOzbLcZoMJGFeWC+8mptC84agicP7EJKBPlsUjBi\ncxfmk/y6W08NOU4FSOgstnaRdWkp9BUINPWsfyx7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi3YPqP4y1omD4RqXOcOPcmfY\nr3wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL3GTCXxPBFFvImWkI0sY/vCqSE6pVh8FXyQaD1ecW9ZAiAYoU862DMM\nLPsvlFUfqp6SZr7i2/UGsRyFFsO371EySg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAU+FarIztO/6VtlI9G+/NjQKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE2NWUwMmUtZDNlZC00NjQ2LWFlNDYtNDE1NmZhZTk4NGQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE3NmRiYWQy\nLWMyZDgtNDhjYS04ZDAzLWMzNmFkM2U1YWEyOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH0rn5+o/vZj7xXQTWyk/os9KkXKHEpB/ZWiaGVIZrqMRTEIDHauy19l\naAYpDsHb54tQbpLhLnrqWGI9wqlTrGqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIiTQC2S\nU2fqMF+7TMLjhrV0abyjMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCj20Cu89iaytZ176oP1A29qM1wr/KCTYONSQGxaSH+FgIg\nOq+B/r+lp99wS+vETe2RDHGAu1PFeZiJTDt9CuuV6SA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5400", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5400` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAW3Z2aak+goMYoH+J10B8mXnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZGFkYTFkLWYzNTItNGUyNC04MmEyLTk1YzEzOTM4MmEwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY0NTIwNjEtMzM5\nOC00YWVkLTlhMDgtMzVmM2JhN2IwZjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUornekjeAOsYOqjcpGWaOUzqTmMQ5gfeJ7BqGIaH3WvafRQ6BwoYhHuuLb6X\nTjMEeqpnq5euoPtoVa/SEkK6e6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ4AAgyAidLghSRZM8MtfKFeZPwAwHwYDVR0j\nBBgwFoAUhDqGUburTU5h6o8yEtfy6eUbWegwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGClYuMP5ypFKTt+BJZKBtIVz7GZqgYdaTou+bwf24K7AiEAgD7XYikfPdf5\n/37P3xgJDgkrE3CH8zPvaT1mi1C39ws=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXVwAfZSnua40z6lBUfHm3QeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWRhZGExZC1mMzUyLTRlMjQtODJhMi05NWMxMzkzODJhMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAMhjoSNATqlhweQVm2Hikql6ZrCJKKxMYI6YUzX+DqiQQ\nZWufvORYVc9cH0GFaewALHFIJmzDIcGdET5zexjXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhDqGUburTU5h6o8yEtfy6eUb\nWegwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga2c+CWfP3CHtuVn5ZpNX31lSbOnJYJS4OxJHWCPXLB8CIAWcWHcCkic2\n9jXFH3BuSqaNyBq8nzyE1HL1s58siQxX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbsjTFOEF36cgeDsUpg1uot0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY0NTIwNjEtMzM5OC00YWVkLTlhMDgtMzVmM2JhN2IwZjM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIxYzYzNTgy\nLTlmNTAtNDA4MS05MTI0LWRmNGZhZmQzNjQ2OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABORjJLIo/LIPSdTA7gY4DzfAII49iQ6MvnrN8qJv6zcQ9FlQqPqqx/sw\nbbEjBoVjpmINZwTr5azLprjKuGD86WGjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGeAAIMg\nInS4IUkWTPDLXyhXmT8AMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCWi1jdB+z9f4B4/2dJWU/0dAVVHBmsNNeQo8iIySsTOgIg\nGQJEkE0cVnBr8oI8qnIYBiWVX2+CG9w/kNW4dQqPw6o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5401", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5401` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAa53BgHJwnqh7k0jDmAl1tHWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkZDc4YjI4LTg5MjQtNGUyZi1hYTExLTU1NjcxMmZlOWQ1ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQzODViMTEtNzk2\nOS00YjM1LTgxZjUtODk5YWFhYTRlZTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExw3wZVF7X3T1D60yzczCCPWoBGJFxTjtMzFpY1YpeEzbypL0195XrK0HyzLW\nFbNFRWHHUNd5aCaRlW3VpZrANqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQv8TBFTpG//GeedSZ8nUzwKYwYMwHwYDVR0j\nBBgwFoAUYFdaqgF8jjPwQCVMOXSyMFMsHwMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAp9o7atjlSLZJ3EpqD3cPniTaThfOAqYHiBtc36467GACIHuBmrYkXOIf\nVCQwZnMICujqJPsC/YntLaLUOSrkDgV1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS8oKtP5xFTA3je/Viwl2/zKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGQ3OGIyOC04OTI0LTRlMmYtYWExMS01NTY3MTJmZTlkNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkR0qD4zFlmsEugmg1QT4L0Vym0uy06MHbw9jlrpRfmmqz\nXocLcozI6DB39JYGHVEZrhO/QNF+VoQ8cqQJug1Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYFdaqgF8jjPwQCVMOXSyMFMs\nHwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOhsrXT3lKEsefM4Wii1uDM/4lt2oS70AFhIUCLWq5pTAiEAh7zT9QJP\n2E1iA6WJzuyFEPq/jwix/09oR2KRFTrLc7o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAa1gdWt485jq/6a2mkY6sFI0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQzODViMTEtNzk2OS00YjM1LTgxZjUtODk5YWFhYTRlZTFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFiMjMwNDY1\nLTU1MDQtNDVjNC1iZGE1LWUxOWE3MTk2ODBmMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAVh99EmMY++5aBSvZtZMPJUnQxK/7RmRXr1xi0ISjw6ItvC4obofEkt\ncBjZHjLDKfqRLP4dVH/tJB1u8sy2+gajcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEL/EwRU\n6Rv/xnnnUmfJ1M8CmMGDMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCmkSxgqCRaD/XIyB61AS469zXNMiRMArKzyVbcJx8aMwIg\nW/io4hy8lxoUy+qY45DJxYib8NSTwBbp9QlAz7Gh+c8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5402", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5402` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISATdJb2Ne4uhESUbVXIaVSFQpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNDQzNzE3LWYyZTktNGMzYi1hYjcwLTFjYjY4ZDc2NjE0YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA2ZmI1NmItYTY0\nYS00YmFlLWIzOWYtNzQ0MGEyZDI0ZDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXhsfD0kc4kbQOY+6l+NraDUUGq+dddHce5ipr+ej6cUtpEz+DKhsQIohKzqv\n75qrd10svWsB+wj1Xnc3AL9nRaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpZ+SNKdQti37N2zwJ1ZUaHQwKCQwHwYDVR0j\nBBgwFoAUJA3MwEALq9WbeaxSZ5wsXrn0kKgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA+Ny434Lc1V5jjTeAnVs2EmTjhrxRCnSHP9KEPX/q\nRFwCIE3gTFdMnEvtVHNGbvuV2SuRedPfddXpvVoG8js38NQP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY5Aqf2kemHM/D1hwcg9LXXeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjQ0MzcxNy1mMmU5LTRjM2ItYWI3MC0xY2I2OGQ3NjYxNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+X4lendY23FvmSRI6mSVxL/Vyl1fN4zVf9WGGVEbjkhX/\nsh03WrjzEIIMt5K4ssnrWSAHLR0Ot+Szj8NYMvlIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJA3MwEALq9WbeaxSZ5wsXrn0\nkKgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKQwptjzIxrV1DuFmBIIXjTCgmRLYJGRy0ktkeeH8+y3AiAzxT2zHt32\nQ/M+bgybxU8Zret9gXW5ypddqu2FymXUeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAfnpnM5nlzsth68k51jmCOl0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA2ZmI1NmItYTY0YS00YmFlLWIzOWYtNzQ0MGEyZDI0ZDJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI4YjJmM2Yw\nLWU1ZGEtNDhjYi04MWEwLTRkMDYzYmRkMDE0NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE34MNeiI0RjP7O6ZL+q9x2vLvoksPp47qAQYvSTb0ekf8pUmmNOItAj\nS8xOuP4LBYwH62N0DZlIMj3RNaGWRmGjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKWfkjSn\nULYt+zds8CdWVGh0MCgkMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDdhE3Mu5l/eDJtAQh2CKea6w6Eybj2YxV0SNtHNFM+AAIh\nAOfbtBXKQ3CyMjDKlsqaMYSGE2fAnRsQRbEilO5mIZmq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5403", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5403` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAdubK2C7W1za9+t1YUq5vtqiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0ZDlmMzgwLTdiNzYtNDYxMS1iNTFlLTY0MTkwZjE2NzZiODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA3ZWNkMzctYjA2\nNC00ZDdiLTg3ZDgtZjI0ZDJkYzYwMjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4XDaRZZH0pmfE8nV5uwy7ZKmE7Q+uQkTsnyB4LaI4XW/XiS9f9PuLTHTaRFG\nNs5v+n28kIdrPE3nuKo+HRs1nKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0ggCyt16INvyB3ajH79iD/5wgm8wHwYDVR0j\nBBgwFoAUQBzREIZVHYzLsoHLuDep8822e3cwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiB9yJv5Nx/XMHl2454KLeOjARRjdq1wip1ha0Ca5VCw\nEgIhANBeu1NKpcWCQjpg0WiLkYtrNfF7y580n1WzMSmvuJPv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW6UaLdS8QwJmkc7z1lMcyq6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGQ5ZjM4MC03Yjc2LTQ2MTEtYjUxZS02NDE5MGYxNjc2YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrnD3ZWg/UTAuI501hjmSXirOmXEfQxC+XvKEaI0qSK2VO\nRrf8IIRu4WiDQI0j8uh0thuUTMnuzGlQ9cOLJ0WSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQBzREIZVHYzLsoHLuDep8822\ne3cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIWRpgPcjwwkmzVY2sEmXUowxmRsc6G7SAe+yILGsw1ECIQDyROAAY5tb\n79oxc9+9bQQ7ECFcE7Rf2/mZjnU2KABJnQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAdte5tOpg6owaqAo2XbZ9lifMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA3ZWNkMzctYjA2NC00ZDdiLTg3ZDgtZjI0ZDJkYzYwMjk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk0ZTBjNTMy\nLTNhZjctNDg2OC04NWM3LWI2OWY3ODUyZWI4MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKJv5YzGereL2R95TDM3N1vNPixwwiHl7yUK6nI948BGMQ/Ad9gwNyEe\n4nk53NKI3Mu05kYjCQQ4a9CJVmqfN62jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNIIAsrd\neiDb8gd2ox+/Yg/+cIJvMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIGKrGYYYx5zC8h+3J0cJWrDx1LphXNmuSaWFIDET2pxqAiAP\njzF1gp6b/dId5ytTB+dLdP1vjQUd+86sQS4vD4F9tQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5404", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5404` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAZObsDxLbZ6TjmA35x6dP2TFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwYmEyNjM4LThlYzYtNDk1MS1iYzMyLTE5ZDc4YjhhMDA4MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDUyYzRhMGUtMTA3\nOS00MDUxLWEwZmMtODlkNzYyNmM3ZDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq8+eZrs1dog5tdCNLQNHuPGsxRRkJzCYzlfyN7cTiQ+mRFs0qB7OkGZZbyjp\n3Xmx6cwUbWy2VsUiH824zxdgDaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoQNr++Dpcvx/zPzPha0k/nltI3swHwYDVR0j\nBBgwFoAUS2ySR0NA719eQeVF8s37nYmkAH8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBGxJy9EG3F0RU8sVP1EhvrxmbNqSxdrA631v9QnUCxtQIgcgxL\nWGVBzc31DmXO/cAdL4MGvSk8SRvevOACBd8v1ng=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbfFGjQJkJ7b9sU/0jpeQvetMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMGJhMjYzOC04ZWM2LTQ5NTEtYmMzMi0xOWQ3OGI4YTAwODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcx6HynSUGJ3qNniuyOnxNzxdpd0++s6NhEuLhS6jllHEF\n9pmz4Tu7a0/qEdFQ12vuMDuWHOllcu0Q7NhqD9Avo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS2ySR0NA719eQeVF8s37nYmk\nAH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMx10bBEcl/m6xW7HvnU3x2Gn7vyYhLJm56M2aTXwe52AiAkzDEnnHyp\nWukxISsPlK9oKviQQWu94lXws2eHrCqg4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAf+o3gSmX/0fmM5w+ZyqCdxpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDUyYzRhMGUtMTA3OS00MDUxLWEwZmMtODlkNzYyNmM3ZDY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBkY2FlZWY4\nLTg5Y2QtNGVkMi05ZTNjLTRkYThhZTQwNjE2ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBvV6sTcwF4L6PWaInYnJ72lnyfAGdHTn07cV+KV/SkXn4XDLbBIrbfL\n8Uus2AIRhpEPDXhvM10I61W5MKQKzwCjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKEDa/vg\n6XL8f8z8z4WtJP55bSN7MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIHfVBRFKVLQtBjJQWsPI95xaf5yEd3QY1ImWI2AFHFbMAiAa\ngXC5zNkYlnAvGwXJO8LCWfCVkFiaYeKmPE/XMTlzLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5405", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5405` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAQquroTm+X2R9Jt2p1mJxBKpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ZGNmODI0LTFkN2EtNDk4Ny1iMzY1LTljMmQwZTc3MTZmYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdkZDc1ZTAtY2Yy\nZC00ZWJmLTk5MzItMzNhYjI0YmJkMzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6+G8b3OEUg+gSxvjWej5ci3/xl9iOnBRHLu821bBlsw1HXxCJ4DXh4fZSQ1o\n12x961XwGEA/9raMZ3EBTc+8LqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkzCtVozIHz14LPzSxqI2GK7jL88wHwYDVR0j\nBBgwFoAUm0joWDN/4jQ3fJljJmpB9kOMN6AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA/RpPOO44wF7rPHD2QWNTkjBJc6v65IXq\n+eHHTEr21kcCIQD8ZkM3jVx1mCz8StN/2nxsh30OV3vy878nuLiyOZKFAQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdpQDbF/sCkN8YSi0wPFNKgEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWRjZjgyNC0xZDdhLTQ5ODctYjM2NS05YzJkMGU3NzE2ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+I1JbrDJyWmojqyJXWnwCq/2uDI+4Md+rjZ3mJXEI9myG\nmL2rnwIfDrpmMlHhgj7Gl6zn5Y72E0iHwkMp2F8Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm0joWDN/4jQ3fJljJmpB9kOM\nN6AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVEHI5EpJJveCT+vqkektA4Wc/1+KKCXoFrBbG2FXUpYCIQD5POoD7kOP\nX9o4yAYbn3lCC03pGnFpt4x+gP45k/mtMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISARxBWhE4eqq/zTbzcd4bmYNCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdkZDc1ZTAtY2YyZC00ZWJmLTk5MzItMzNhYjI0YmJkMzY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQyZGU5NTgz\nLWU1MjMtNDE2My1iNGNlLWEwNDBkYmJmMTY1ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEtp7S4Xo5LZ2W5K/ZQeEROha4cuglQ2qNcVhI4sfhMwEN7NvygbJp+6\ny/E7rkwCWx/Cyil8ADXU6qzAmz5I5zqjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJMwrVaM\nyB89eCz80saiNhiu4y/PMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDhplmarN1daBF18mPNx2ffOdhj5XANO/j/MnMsrjG6BgIh\nAKb8JIMzjGqOJQY9xsb+/eWMZgpefYKBixIqQ8dIZ/IG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5406", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5406` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAd8cVt/BgMLwhzroGtTOO5s7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0YWIzZjhhLTY4MDAtNDgwNC1iNTVhLTYzZDFhZmUxM2Y5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJmYjU5YWMtNTJj\nZC00MTMyLWI0ZWEtNTU5ZDk1OTcxNmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM/WcVRS+c5/Sp8M7bEzCW6Z8jOBXjfmGN15VPk52L0XQzQnosUiIQ2LPF2jj\n66sTGfTKM+BYl+TN6hbQ6OPZNaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoSuB1fhYZ6ltMoSx/plvqTlzkRgwHwYDVR0j\nBBgwFoAUDcplELm57wiAlq+fYGosxYAVji8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAfmWx7MhkEQwWx3XRCzxpXaW3qYoFPepp/\nu3vzo1DyTwIhANjMwLF1QVVRWTDcgIQz6Lrf0au2XZKcqWeSeI1Gejna\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXKqkOpQa5dLd4C9Y7WxPGIDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGFiM2Y4YS02ODAwLTQ4MDQtYjU1YS02M2QxYWZlMTNmOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzPTSG/ArP2dgW7sj7EyL3iK3scJuhnXWY1tQgwt0yT8Eh\npK6U34+HPG/+pw9BXk6EBqFBIZs4LRuf+0SEuFs2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDcplELm57wiAlq+fYGosxYAV\nji8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANKdGU/FNVfCYog17bN061ADfyuEIM83pBCndeCZ2vJ2AiEA8wDjukUZ\nKDv2XEZsZqfBq3UkYHvcrIVYodCnzMZ9qsA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVxADALD1ADUc1F2N0OBdeXWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJmYjU5YWMtNTJjZC00MTMyLWI0ZWEtNTU5ZDk1OTcxNmYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE2Zjk3MDMz\nLTY2YzYtNGFkYy05ZGUxLTA3YTdmY2RhODczNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKFw80kvM7TSS4Xo2++VA4Iw/F5+ngxdgEIHAsdA67SPxFhgtH2lDuRQ\nm4foTAZQMi2okRoG30E5ZSpCDvoAMJ6jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKErgdX4\nWGepbTKEsf6Zb6k5c5EYMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDFDwVqq6oQbVCWJjd7TlFZEJVHU4RbqsICRXi5NlMVdgIh\nAMLrqeRJwTNjBSR+k88nQgrfkUQyd1qPweQUVWeRPLXn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5407", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5407` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAX+PeKvyH7wQxUUPLMGQTl7uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjODc2MWYzLThkNmItNDZkOC1iY2U3LTEwZTU2NDQ2MGFkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcyMTcxMmQtOTgy\nNS00MTRiLWFlZDctMmZjZTM2Y2VjNjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEADlxMnHBJMrxtcoZvmWgFUBw6zCy2VpELQ7kIumNFKne8mWNVg7grqLq6RAm\ndv1s7CpPhJvkWakLyRkzjXL8RKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYvrRUFYl2/97N/1rnC7nrMWiPqowHwYDVR0j\nBBgwFoAUJAeNlXo48wNpC47JlQNW1GH6+qAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCa/Tq3MHn4QTEm0d8YwLpa435Q\ndgqXSFBwLhzFnh2pcAIhAJOARo81fMadlv+d7oH9gwTsAT7Aw8INn0tHusAyWsRv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARnCyIXcLxqFDCullpcjX2WjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzg3NjFmMy04ZDZiLTQ2ZDgtYmNlNy0xMGU1NjQ0NjBhZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjw0Qc/UjdRZsaMB9ShUCPQ3QAG5/YwpCHyuWXDQ9oVGIJ\n2LbSXpoN2gfBeB3fprjs7RGCRFeX23go8B9NIDqmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJAeNlXo48wNpC47JlQNW1GH6\n+qAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWxIccLASTM7rkcvMRWckEbvdst73STUG6ZPhF24HGMsCIQCvQGUC/kBx\nwbdKbPGp4dT1d+ciP/aDH+dDZ2xneFMl6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQa5HLRlk+++M85ELIOZhFB2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcyMTcxMmQtOTgyNS00MTRiLWFlZDctMmZjZTM2Y2VjNjc4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEwMzhiMTgy\nLTRmNGMtNDcwYS05MmZjLTgyNDJjYmYwYWM4NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOnBJNQ37Pso1NP1eThHJn9IoWI9fMpM6v9CogZplG0Qnpic2um5PgvT\n+92/uhdcQcnBEH55uGpAoWy0F0G3y0qjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGL60VBW\nJdv/ezf9a5wu56zFoj6qMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDdPk0sqFc5VA7I0WxwlrxUpLFPtHc32x/N8HHNDxhimAIg\nRi87OfFqe6gfCEnjgR7bWH2xVndm+e+nxK1vYbpGfbo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5408", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5408` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAXLCz2/ANKtA+t1XPXW0aDBsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyMDA2OTU5LTQzZjgtNDY2MC04NGYzLTBlNWYxN2I2NWJlMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODc4YmY3YTUtZmU2\nOS00YWY4LWI2NGItMzg0NjRhYmExZTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7XJZNuyWCHGaVmCIhRmUoY04+qeGl1bbzaKB0YKHmMzp5HXt7LPrhuGDTl4r\nJMz7ixCZQaBDmjsxik5C8Sg8rqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8aoQwPkZYs3VRK/nNxhhQbnmyv8wHwYDVR0j\nBBgwFoAU7BKMcLG7S7YsTphQg7QfohLTeM0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgA2FKJaHL\nZtgztACeICRfCIgA9BZCIQ9Z+V5qb+AvyxcCIQDO7OrBwyl2UmH7RDMnSJ6NC6mE\nl8PXKaMthnEiOX1UTw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU10QrXZSMEaVbG4Itt1nm6nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjAwNjk1OS00M2Y4LTQ2NjAtODRmMy0wZTVmMTdiNjViZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLHNhC4nN5Oe7ObGtlMuLFivzrQbzINSqNkJZUpANELJQF\n9GBrZNdC5NVin6xNXWRtOoV4Sbkef3g0ZeTwB5Aqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7BKMcLG7S7YsTphQg7QfohLT\neM0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYL4X/XI85SAsRHAJzk6jeXjyVTfQDOrLLjsyLUWAcGwCIBFTeiek73jY\nUUMrbr9nblffQ3on8B8zxftggIwJh9DT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAdilKTZE0Be3IaHpIZfPtvW7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODc4YmY3YTUtZmU2OS00YWY4LWI2NGItMzg0NjRhYmExZTBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNhNTY2ZmU2\nLTM3NjgtNDc0NC04ZjU0LTFkYmVkODA4MTZkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKWVf4QFQpzOn6vo0Uw8Wqv1Q7wN2rufxDhdfNFcYp8r5Q6cOkkH24zZ\n8vf7OvzozqBK3HiMDSCbXSpBYlRFnamjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPGqEMD5\nGWLN1USv5zcYYUG55sr/MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIGTPYygPr7U1E+DyvDW2YB52iJU2Mq0RNYZeCY0cH6H6AiEA\ntzuhxIYzgxgm3W7424yg/lz4Qgmiyh0D0WXWX6xFOp4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5409", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5409` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAXraTUi+a9Bl9qcA6nBDreUsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNzk3MjRiLWQ2MTAtNDNhNi04NjdjLWQ0MmE3MWE1MGVlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJiNzU3NjgtNjI4\nNi00Yjk2LWE4MzctNzNmOWU5OTYwZGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvCUnxeZe6g4HoisDUYWUF94isXigKq6k6dH6cw9KAO7UxS8vOPXLPDERLc3b\nLJArysUye89xJNQ8xgTe+ARJnaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2JOmjr7dVuN/1E6OvAXNQKsZuN4wHwYDVR0j\nBBgwFoAUwMKsFEOZvWuDHjZb48mUmF/brlMwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgGqEqtS11\nkrKQCl8fAYWZ+kZtYzWfH+3Eyt5/qaLm4L8CIAb6JgDkRC0Yq/Air6qPjW0PFJhZ\nghGwFMOdXbprSOX6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZcTcU+XoxCx3euoCmbbZEE/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTc5NzI0Yi1kNjEwLTQzYTYtODY3Yy1kNDJhNzFhNTBlZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6eVTSE58PESwk0nT1Y9k+dzdmP0Rs99OvTdaFCdjdCJyG\nBDwk7+cgF70gQWGG5efj6T5cAKhFZwb+cbDKgkSXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwMKsFEOZvWuDHjZb48mUmF/b\nrlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMxMoH7H/4OjERvqqCeB40kIwMSlcRBiqQ1l5yPS2+36AiEAuJJhWp7J\nYfNtwfVE2QeiruPl5PszMPwQERo4UGEcBEc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUtuevlqs9omoRVZay5JpbNlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJiNzU3NjgtNjI4Ni00Yjk2LWE4MzctNzNmOWU5OTYwZGU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFmZWMzNTQ3\nLWM5ZDUtNDI2Ny05ZmEzLTJhMjY4MjczODJlYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNZiPPBwtjFW3V0Nh0FucnJXSXVzPmDgJ7F4eAdPdY4sJHAGaKlIfE8u\nMAPy58wRD7YZDz62BRjQ4VtYlkbTsySjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNiTpo6+\n3Vbjf9ROjrwFzUCrGbjeMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCP2NAR8PlVbPSuXl7gjN3zQJVVVu8+ySzVAT6rbkIk+gIg\nJbtd4GBvzg/0qSNnzy2WZB0lYJcElVVagCMS78untwY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5410", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5410` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAbo8QNKOwgby8NdU5CttyyPfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxOWVmYjQ3LTQxN2QtNGJjNS05ZDUzLWMzNmYzYzgxYmM4YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY2MDQ2OWMtN2Rm\nOC00ZTBmLWE1ZGEtZDA4OTQyMTJhY2JjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/zqnNDpid1BOgiKqhKpjkqoydylngxXxtab4LCP0AyH7fKrgQODXssN+PnPi\n4nFgDiny5T3rdekdNQSwS8MHD6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy/g/dttcf90plhQ5o04xT+gZFz8wHwYDVR0j\nBBgwFoAUSCcZ2gm428f64k7sUGURBFZmC2AwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHL24kOW\nKIbN/ivVbH+0SiuMbZIImnFktecIQRd4YffkAiEAs5fPV6E2alKLL38psa3l6MVJ\nLDCP+DwzrzL9TtCfGtM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf+sp9qIDfSMvTQT4Q0sqNX1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTllZmI0Ny00MTdkLTRiYzUtOWQ1My1jMzZmM2M4MWJjOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9NLuxzLA3DdRXKOVlj7HOkWHRzVdJ6AodwdcZ3UZIVrAb\nn+733KTo8rbJzIaLOukN+9uyWkDfcUfVIxegk3Gno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSCcZ2gm428f64k7sUGURBFZm\nC2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBRGpP2aizGSEZLx2RNh31ywwDst058wjeNYshkK1hXECIFNzxv6iCw26\nQ3ITXA8VfFSdsFhHJH9j+wg7/zrTfP/P\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAU7Wd6PGSKWz2QvofHlv6sphMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY2MDQ2OWMtN2RmOC00ZTBmLWE1ZGEtZDA4OTQyMTJhY2JjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE1YTkzMjQ2\nLWZiMWItNDk5ZS05ZGExLWYzYWE3YjRkZGJlZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEJOJ1+vFKmWW2a88zM07llKxLsb3v8VYKkq+TeGwTwDPGacdTk82elO\nISyeEYKzhaRfm5OCW6yjHEOnpF+4kZyjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMv4P3bb\nXH/dKZYUOaNOMU/oGRc/MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDQbSnCqycvvz0uRFZHuzx1cYQ4RM/Wk01qnPEzF7RCxAIg\nTHL45As9q6PtkFkUDj3HSNLPIHr3+FenZzKsE9r7MUk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5411", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5411` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARGlDxS2RXwmYqkbAIf7wOROMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZjIwODZmLWQ1ODItNDk5ZS1hY2U5LTIzNzg3ZTk2MjUyMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDUwYmE2YWYtNjg0\nMS00MWM0LWI3YzEtYTdlN2U2OGEyMjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVaMUsrGQv6zpFqXdadTIN+7JnY+rTkaZlxWcOvfeMgCSBOOY3Qex8wJYDDle\nN9J5Zdryu8CDeyrpW7aJa6Er66OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/NXXhbiUvHiygwL/0mtyfGIV5oUwHwYDVR0j\nBBgwFoAUJpz08GbaYYF7luEfmBkfK/56yyIwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIFuJD8BRZgfWKJeKgLp7Wtuy0OCCOFDHJbTUcH0TdXlFAiEA6L5WMGvc\nUmEKwIL+6sQj3Lp8nmUfh1AzTu1xnpTOsng=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASL/xiaEgxZJXHZbQPl2WtCBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmYyMDg2Zi1kNTgyLTQ5OWUtYWNlOS0yMzc4N2U5NjI1MjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASite5OU3HIgbn9hg6O6zjnKT53fdi3IWUsEWOwCQVYIMRb\n2A/X/yErw5jcWG5IdY31Vm3qmRpXJHpXTvJSz+zKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJpz08GbaYYF7luEfmBkfK/56\nyyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJFvP7KQxErrIALLwx8bg09djASXzxwiC9IMo2D/+V0XAiEA4TZbeDQT\nydCUtv7/lzsK5f8uUCsiOk2GuyIZlcAGJiY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAZdeI1ic6chqezE6mUkHPVyPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDUwYmE2YWYtNjg0MS00MWM0LWI3YzEtYTdlN2U2OGEyMjI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEzZjljZDYw\nLTI3NTMtNDc1My1hODUyLTcyZTU3MjE1NzFjYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCVBXwj8v9NCyzFKXH9nlYIvJVw2HLai6kMG7BXL3k6C60BFFAWYfkc+\nfHV3Tt9TpzBCFIJZ78v24Gp7yC4wl2ujcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPzV14W4\nlLx4soMC/9JrcnxiFeaFMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIG7CWlC8F5G4/WIR915QdP1Cfv4Opf3TdKjRfkQnb7RSAiBh\ndptOgFzpZJcQVceIAU+gEbgwzFVsYMddYv2S1yJjmQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5412", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5412` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAdKo62XUW3u7RckJWb75scXkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlNzE0YWNjLWEwOTAtNGQ0Mi04NWVlLTY4ZDFmNzZiMGIxZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmExYjljZTItNGI0\nMi00OTk3LWFkZWYtNTlkMzcxYjgyNzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElNboucY8ktrMwf0NPdNQkpVALldZhjOlpetbskmNManpCxDuzpvnodqc089f\nNqoY4+IfqXvogNQyFmx3MEU+sKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF0+LeN3p/d3+2QMQ7Rh8vGqpLt0wHwYDVR0j\nBBgwFoAUXKQ/WXOvvzj60kh0E3dqcsyxCDIwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDbuKyCnNQwRytNXxQRd3mkhEaQWH3aGGJQA43t8ErZTQIhAJCS+7NA\nbr+DZ80Q8zXGmFqi89/Q/0DUqsl7asoEytaZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARgMZiTHCf9jl7iRJjT0ghDvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTcxNGFjYy1hMDkwLTRkNDItODVlZS02OGQxZjc2YjBiMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXqg2cREacYr+0OJfrnXDNDS/9PQeKnPLTm58v2XK/ExA2\nVI36y586MZY0lrNuQP1U82bLyco6Mjd+OjXUHj1Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXKQ/WXOvvzj60kh0E3dqcsyx\nCDIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgb/L+pq8cE85V/1py/WmyCHzm67bgbwvMu9rMSybU3fsCIQDcZecHyBew\nnFKulMXhoRR0xyBJRzVwdXnrfsXX4PGt/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAeQvg6ddk957Am29m/vIqLRDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmExYjljZTItNGI0Mi00OTk3LWFkZWYtNTlkMzcxYjgyNzM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFmMDI1NTRk\nLTJkZGMtNDg3Yi1iY2ViLWM1NDRmYjI1MDMyYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHHktUk0oTb13CsPAiQHefjt4AB0OgRVrgU2yGKYQbU+YY4N7iVeYnAS\nr/2Jl4sQhA297/jGhiofTThbPqFgTaejcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBdPi3jd\n6f3d/tkDEO0YfLxqqS7dMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDiG7IN10+tWVxckhldKfGjAbWx34XuUhyV/Q3T5hOPpgIg\nTYcSolzcPkCV/Wo3pPrLcQ05QFz3e3YFhtT0LVnRIio=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5413", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5413` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAQ1Q2F93thnKALtbQ2l4389BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxOTVmODYzLWI0ZGQtNDNmZi05NzM2LTFlYWVmMmUxZjE4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTViOTVjYzktZWQy\nZC00NDc4LTlhZWEtOTNkY2ExMWU2NjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgdf8oKIPrSa/SrogOS8yRQBFIi7v4HvsFQ8YFyGYwgc3i9tHfcXC0/3zuyX7\nzwpnYfvP0ie9rVGIWRe3Pi6WU6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/wOxHMA6D2l41268O86FOKXnBmswHwYDVR0j\nBBgwFoAUjbu8tmaL1iDrrdLLJkDKJYZPDPYwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIBFoeKG6C6LKhqvMh/em/aKicpKpxW8kwjzipub3DJUJAiEAx/kIMkgKaB9EdlG9\nlJjZ/KQrIi+A3+l0UJm7l+H3bsE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATQ7lSm/h1xz1MbpHH4C1QqdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTk1Zjg2My1iNGRkLTQzZmYtOTczNi0xZWFlZjJlMWYxOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATv/VKhBEQRiLxUGfpGStZkqUQzmDFR9c7a93+sH+Fvzm+s\nhdbiM18/Qt8xggTqVox0zshqCYQBS5DS5MMtAJ3bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjbu8tmaL1iDrrdLLJkDKJYZP\nDPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeWtA1aEYTuU5neDD5/zslFerTGDu3rWcnPTbgX5Ohz4CIQC/96qt1Jq1\nojqnVm0c7PD2NLbG0dPjzVsN6oGWg2PdHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAScKwjnypPHnfHJuq/aN32grMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTViOTVjYzktZWQyZC00NDc4LTlhZWEtOTNkY2ExMWU2NjMzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU4ZTMwZGIw\nLWExNjgtNGIwNC1iOWI3LTZkYzA2YjQ2NThkNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCy4T28R8LuXn4crNlZgGt3WOU62v+P/C+Q/Z5npuMTNVDpC7kznsqRV\nUsV0N15WzqblOFHukKaEyAFsYxpizjSjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP8DsRzA\nOg9peNduvDvOhTil5wZrMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIHDpj3guWbirrqWCguSWq42vMB/zNG9aQWnZKqtduB4gAiBx\nkTYhaqxvmR8+cxN1tYEMUamhTN807Z8AyjlpDKdN/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5414", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5414` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAS/rHv1WWWniflvQe/Vf8DDyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2ZGViMGRjLTFmN2YtNGIwOC04ZGYzLWYyZjgyYzM4ZGViNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjliYmQ4MGMtM2Mz\nNi00YjQ5LWI3MjMtMGExNzU0MGVjMjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ2DcREv9IJsZDyY/ZzxJ+ffososfjAN+x3kkcLLGHuclSbWNlywAkkhnC1xS\n5REymKFLH1doIQGBoRAIosGbjqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMb1OW4gvwV5Hzn6uCwLeVne1HnAwHwYDVR0j\nBBgwFoAU56KpnjDAtibZT0nfJH9OXCSol/gwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIAIcNCKbrYQ+Ctl2bQVQl7jLSSOcpG5/Vt/gIa8CfRC9AiEA\n5O/yhbNMLiFBu1it0Rf3FDABJBo//CpKtDtLwYrunzY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATR0Sm4kl/gkJWF4Z1Bspf0OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmRlYjBkYy0xZjdmLTRiMDgtOGRmMy1mMmY4MmMzOGRlYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2v2dcPShzAYsTfz6TG8RjhU5fL8n0rcC3f3/Zao5lw2Iy\nvy3SHLICUOQwoVgopr9TrkUljPDb3QMjsB5VGLXso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU56KpnjDAtibZT0nfJH9OXCSo\nl/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKorquW3iDwu/Clbuu6+ABlLHSAxyi+aEn83ychQo6n5AiEAtif/hq6B\n4EhAvJuXt79WwcvMLD2KZryToaiDXyqr39M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAauNip67LKcinnLbLijpBFmjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjliYmQ4MGMtM2MzNi00YjQ5LWI3MjMtMGExNzU0MGVjMjczMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdlNTMxZTY5\nLTk2MGYtNDM5Yy1iYjRhLTJmNWVlN2Y5NGU1NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMwWQiIilyMV+8uhjdGmj7TZSt5EBYMd9o632C9yTGfst/Zz9y9y+XHx\nU5Lhsh5MY6Zp8V0mXkj2PVBPOKZKT6WjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDG9TluI\nL8FeR85+rgsC3lZ3tR5wMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDoG1VlwdJP/+0Je56vEeUZk5VZknmZwZGl8hqswkpx8AIh\nAPq+ue+gOEs1B47SXs6jF96wCy8sWAHAMDwOjSuDkDxz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5415", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5415` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAdJq5At6xu25cjGL23FSZUauMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNjAyOWE3LWQyZWYtNGQ0Zi05NjAyLWVkZmRmNDRlMTI3NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTZjMzJhZjktMGZm\nNC00NzgyLTgxYzEtMDE4YzM1NjIwNGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbpM+6153EVFFUDHRk+g11xoxLvCDBCnHEzHs+bXLaooJiuIKAj0IoXRN9CA6\nvHovc/BJJbxBLisIX0lw7jrH56OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU6/zg+IgwE+ITGtuk8LZYIi4szEwHwYDVR0j\nBBgwFoAUxqnUZAEMQjq+Z2Z0xUfXfqN5LKwwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIDn9q6ImTD87dACx3tWVrYkCXWHR5hzIeg/l1p9mff/gAiBO\n+nF/OJ/SgeDFFVK8x9+gQUdJit39BpphD0juWFV4CA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU8aU1cFRvjyIhVTqprDZle4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTYwMjlhNy1kMmVmLTRkNGYtOTYwMi1lZGZkZjQ0ZTEyNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH0q1yiYy/lQsmpHo6qNnl9OsmWny1yUp6J+3HQ39sq04v\nytyj9hWo9Qk8RFg7U5CAAQw14+P/aewdw10kdibVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxqnUZAEMQjq+Z2Z0xUfXfqN5\nLKwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANoXx5ymOh/h8Xteaqy4ebUuD2kMiKGqa5MrvtihBWJuAiAxlDrHOsPf\nvgnFSu/pnQ1JXGitQGbmkJKH3FRvrJ+9dA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbdJ304gN7mcfZhe5x6JMWlZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTZjMzJhZjktMGZmNC00NzgyLTgxYzEtMDE4YzM1NjIwNGEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU0ZmQ2Y2Y2\nLTliZDAtNDFjZi1hMzE0LTJkZTE5ODA2MTlhNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP085QjZIwJIa1783jIQoQHoNEqqsqWSzG9Q+L27xrhOyuHaY+KH9vnR\nJBU8IysDThkIRsyv9+mSVXU0kEhL5RGjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFOv84Pi\nIMBPiExrbpPC2WCIuLMxMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQChAZSaYffFELHgRWH+HyQ4dC7Y96hNlXR9nGnPZYbaIAIg\nfBRngkhLdwTmBbzrPAnnGw7VAFftENS9Ssqd2j2mnpc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5416", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5416` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXqzkzjCPtIHeb2exWjIZ87nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0ZjNmOTdmLWRhOTEtNDQxOC04YzY1LTlkMDdlMTk2MWEwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E1YjRhODAtYzRi\nZS00MDYxLTljM2YtNmEzZmNlN2YxYTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZAKIWvq2XduQZnrFCwp0W8mw2pAiUEeNNsiaZJkYsqdjjyaeqmUIsLlbDEIJ\nRveDReicTTjaFcuJm7vLscn+z6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIrzAzoF++vo9zxyWd9KAjEYF4w8wHwYDVR0j\nBBgwFoAUhL7nntqOo2y9IAOr66qmK2tdrP8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCFM4UH4SJ3\nW7dWwIdWUfPEpF4diHGY0EDLAKoxX+aGKwIgbF6KtyHASmG0gOiX94qOIcih0Tz2\n9aDhCX2dhqhZMuQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT3x9mIXp5Vg3njspnMnYFpMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGYzZjk3Zi1kYTkxLTQ0MTgtOGM2NS05ZDA3ZTE5NjFhMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASO8rAv8stA+MkLc/4v6scaqLbweklYX6Nvgh/L9Iut/Fgj\nvhoWR8k0g7RdnIyMZVp0ukSSF89rBodEV6Lej7hHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhL7nntqOo2y9IAOr66qmK2td\nrP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJiHQnAm5CiZYUyk0CM18KFgqr5PBg4s6mIqUXv7rx1/AiEAwLJt1w35\n2n0T/Yg2epmSvVFWMPspzCdt5/0YWFgJf6Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAcQCEmyU2I7CMOs88hPyOViOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E1YjRhODAtYzRiZS00MDYxLTljM2YtNmEzZmNlN2YxYTRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMzMWUzMjJm\nLTQxMjYtNDkzNS1iMzg0LTI2OThiZDI2M2RiYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOTQ0CzQPxsJcfYI59/xjOJBprWdy73Fh9L3+Q+hY4ayGdeVXpxPC3Y1\nFC+eWWIheFsAjXIbPWgTJjjBqUv7k1ijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCK8wM6B\nfvr6Pc8clnfSgIxGBeMPMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIE+fu2Hct2tzTH4rwn9UUlJ6SJWh4J/mubaeCll6DSq4AiEA\nl4+JCH9GGlR4a17RI/gjx84T0AwQ5sKYlbTQLXM7xR8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5417", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5417` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAa7gx7oijqAIi2szuBkAWdG0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyMzllNWEzLTc1NTQtNGU0ZC1hNGNkLWViMDhjZDQ1NDc5OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgyNjVhMGMtNGE3\nZi00NjcwLWIwY2YtOTA2YTUwNGNjMWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBSfPPHgqVQhhYIF8VommjO0vCqV8Tq1uJL2k8bkKxxxfyTJs6hUf3UOSTiLD\nikJFF8/mUfVemUIo7vPwcHjSTqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTuvDs1j8Av2vYWDQrIIZwB3dV4wwHwYDVR0j\nBBgwFoAUdl56xNE7Z0IbnyqwXq92mxghqv4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgClaq8ecpzl/GSAHD5QyN5a2A/McGtmRZMJJGYsSCHmcCIFef0+CbIHgP\nMPHui0u2UcSOjnTanEkvYZEVN6Xv5ezE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARtLUioVEG24bMJi4QyV8rWWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjM5ZTVhMy03NTU0LTRlNGQtYTRjZC1lYjA4Y2Q0NTQ3OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGO6+smrSMyXV1AK1kugalrH2EDhBA/Pc0KSQf3HmFZYtk\nsblrLTE4JJIISbUg5V6qmcq8c+byjo3hdQf9X+Yao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdl56xNE7Z0IbnyqwXq92mxgh\nqv4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN2VI9aiUaAhy5XA2QYYaRXZs5jMoUCKJPFOINztCfsMAiAZfYCvILhA\ntFNewq/s99iAwrHhD8u0KmrSK3FZ+zj/hQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAYu8z/Yk8E7fWC7z8xkUVMlfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgyNjVhMGMtNGE3Zi00NjcwLWIwY2YtOTA2YTUwNGNjMWUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU3ZmIwYzIy\nLTI2Y2YtNDhmYy1hYWU5LWNmYTcwYTliYWEwMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABClQhkFjA2b48WDtl4OkFnkUqeIE0N2URExZL6onfHtUPI51oj+MoQ3W\n70oDlxZRFoIHiYc6pHtJ/NEfzsqGQiOjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE7rw7NY\n/AL9r2Fg0KyCGcAd3VeMMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCo/7+kObaXM21f5FO3ZHAOd/dO+2ufdjY8So7S0PwvUAIh\nAMCNbSwC8pI4HdAdlenhqM3ZPPAiivOidbcer033yVau\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5418", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5418` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAZKy5e5+hG/JVQ/NXQf03GzTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MTRmZmUwLTY2YmMtNDA3Ni05ZjA0LTgxZDUxZmJmOTIxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjRkODk0MWItOTky\nMi00YjVjLTk1NTEtZDM3ZGU1ZTZlNTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Jk1S0DvVOlZ3Zbeyy/6cXwu4Tb92InD07K42PXMeaSI4ZE26/2XkhyFLnxj\n8WzVAs5EQQS3CcQNjxsGGlPsdKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8CBFYsVUDSqqK3YoyzQQuvgBkJUwHwYDVR0j\nBBgwFoAUGz4r3JUbkFooKz4ql3Kx0yKtHVMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgXF/sy0MN7/Pb+GGJiRyvf/SP2PTpDp3Xbm0NBOkUSQ4CIGz0nOcpti+A\nDnAvmYG49ajlIj0FyQCt1cTV/kbTDLo+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAde1fvm24sdM7aWAmRPEhhSGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDE0ZmZlMC02NmJjLTQwNzYtOWYwNC04MWQ1MWZiZjkyMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd7CNJd8gWBQpxmj8TJaIvar+JsoIAZYXyGFalgGaoG/Q3\nOLkDRXJyvVvvkhlIcGG6Jxi1sRlmt/DBB+NASItjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGz4r3JUbkFooKz4ql3Kx0yKt\nHVMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLOQzOIYPHfA5dpuHE3HhAVB1KyGETdnBNT6FuxfbyAICIHocwQVDUKuF\nasBFDOGG3MFPHuzcEkge8J8hHTHgeiLH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAYxzDYBHFmuVvkouzymps83UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjRkODk0MWItOTkyMi00YjVjLTk1NTEtZDM3ZGU1ZTZlNTEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU2YTE3YzQ3\nLTc1ZjEtNGViMC1hYjc5LTUxYjFjYTg5YjIxOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMmtok6Lu9iSaQNS8UUrWOa/iaDe74TdqkP3Wj8AOFURJ8+EtTxLTokv\nDUhPCzDnv/Sf4eLq3okespVxSDr01p2jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPAgRWLF\nVA0qqit2KMs0ELr4AZCVMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCehcIygtznpnOUaOBMRuYRuOdKnS2N3olQ8ApErSTE3gIg\nKzqG1q08MSJFOF1go3ZED7hm6OL+Ij/flnQt3707gJM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5419", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5419` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdxRs6sBFOKs3/alA+okfHF5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyMWVhNzVkLTIyNmQtNDQyNC04OWMxLTRiMGY4ZWU5ZjI1ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhlZTBmMDMtYjBl\nYy00ODAzLWJjY2EtNzg5NzkzMzkwNzNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu9cAUn1W8G61caoYqgkqSXiHW5+tWaoV6z+BmAzZu1oDlD/YeFlfkvqVS56j\nQCc7lEagfvJQsrnWVlr0yBMhKKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYFR6P9B3wFC5jyCYOx3mJSMN3bgwHwYDVR0j\nBBgwFoAUbrUHBz5fmwbmVSKagYQ8zU/bu+owOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIHavf0u7/+jKNPh2cbS76tk+9ntTh7HQN7f1YSAAqVflAiEAyuZRFsuH\ngN4n7Tn/OGv5tcCtG50y7qQxsYOLfHVCtzQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfMBVYrsgo8kJhXGPbRfBnhRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjFlYTc1ZC0yMjZkLTQ0MjQtODljMS00YjBmOGVlOWYyNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxICAoWjxd57r/WS+zQGysXwnVpaDK6aWva3T5CMyReblo\nqKKKyYf1i+cdhZFw/frRpuM2vPOCtCCCoK/cp0vpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbrUHBz5fmwbmVSKagYQ8zU/b\nu+owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIGNevjSV6IAGQG9Jx4trTPHAO0ejVTwBrUWPu8s+dqsAiB9RMgzWI+d\nTsRiHeTdWNWmo1MSapPbHJ7h2rrGZbIsBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAUKaQBxwdbx9zEagTflzAErgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhlZTBmMDMtYjBlYy00ODAzLWJjY2EtNzg5NzkzMzkwNzNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVhOGEwN2Rk\nLWM2OTQtNDkxMy1iYzNmLWU4ZmZiMmJhMTQxMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGm6YCp8v1C+sk6trSGbnDD8mFZuOsevlYNhbMnaRJuvt34kjy/w7qQP\nTQy9QZY8plzcs+NPs9RyZcAQRS3PUNmjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGBUej/Q\nd8BQuY8gmDsd5iUjDd24MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIAev05ibWnU237jKcAtJqMeOoi5Kkq9ZLF6U9XhtV7BGAiB2\nccly35ok+k1uWkQcPUN4w7cOLlgob0E1If+AlSRxDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5420", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5420` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAdFmJWlAb2XLYJ3l/32YmgFZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMGRjYWIyLWIyMWQtNDkwMy05YjJmLWVkYjU3MjFmZDJkOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDMyODFkMmYtMzkx\nZi00ZWNkLThmMzYtNDkzYTUwMGYxYTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW2jWKMgfRZLfLhJs74hGf8nicg8SAoZ1isNkA0m8t/oSkTOOcIbgJr5OuRX3\nSqlRco9UzyioSIUgwjmlN1oZwaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKvTsqHG+/P2lbTk5twdXAaHRh1wwHwYDVR0j\nBBgwFoAUGPP8vm7QF24tGgWXv36+HKW9c5IwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIActS1Eg0E+6ZR1u2/eGKBQklIENY5HScsxvol9k\nTmsXAiEA54Cq/OruPLryJvyqvnj1hTgYL3xkhRJGTY0FLZ+VQSM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeza0Zl7t68IGdLn1uG422U1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTBkY2FiMi1iMjFkLTQ5MDMtOWIyZi1lZGI1NzIxZmQyZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwZDoNnJ6QOLGxyUIN7a95pPHbfL6eeXaqJG+vBl1qkxbQ\nWQKoI852CaUK4W1oCQosdSWUNDvMs9/N883mBTp1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGPP8vm7QF24tGgWXv36+HKW9\nc5IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP+eBKb8jrefCd3uYhoOXXmg3T5+lMyV04p3Y5YU2212AiEAyTQ4NSBG\nSZLEIF7m6HKDZYk5LnMuFjSe6oF4xl/blMg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISARNg8XoBIZXWRuDRBkQSK5GwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDMyODFkMmYtMzkxZi00ZWNkLThmMzYtNDkzYTUwMGYxYTc4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhhNTQ3OWUz\nLTU2Y2UtNDBhNy1hY2QxLTZlMTZlMTVkODZjYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABICyvWPjVGAAoEWDJ1DvT4qV1bRFTn/IlMsOHkKF3YiPbVzvQb1unfa3\nL4PKCwxwEezp3d8+d6Nx9i/C1/tMhtijcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCr07Khx\nvvz9pW05ObcHVwGh0YdcMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIEiYIxlzzmbtagbdI1Sdy1+ACW2fC2WyZcNDyL6ObeJrAiAl\nVk8CF7vgTJo27Ueh67+9c7y5tWA2cXJD6t1sU4GCmg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5421", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5421` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAYEWARDzOqh9HhGaCvGn8Cl/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5OGExMTFhLTA4ODgtNDQ4MS1hZTc0LTU2MmFkODQ5NTJkNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYyY2RiYjUtYjE0\nMi00NTk1LWE4OGYtNmZhNmQwOGY2NTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIOqRwjLnYiGo/TSncULgA88I7Q9EzN8ZyjxXFvktCA0AwO1snooPVwvUCSM3\n6MNcctd1EukBOpl2YO+Xsx5yraOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJifKqA1oxvqalzrARjy+S9c827wwHwYDVR0j\nBBgwFoAU5rj9caqoP8fsCR679jZWnmnTN6EwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD5bQATTWKqp12Gk4I0nVOeflS5hMAlwC15dVGU\nK8JdEQIgX6AT6n5Pnr90RVeOQ9B/n0ItV6H1wnN4GhJgKPpRAKc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYS7MO6I/upX641CFp7oNv5gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOThhMTExYS0wODg4LTQ0ODEtYWU3NC01NjJhZDg0OTUyZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARblUb7Pi/GKd4tKjt82fR4y8WCCNp8ltSl5UCkew1zG5EV\nXc4s+pKrYvFgvbdQN9Hw7UDC33BbQknhF+v5rRRvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5rj9caqoP8fsCR679jZWnmnT\nN6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJCeeeNaSclK5pJBUXaGBcMGz8Jc9/abtsB+Kw8L9HbTAiEAsGFx4j4i\nNkLyWK9UwL4gPpg9B6YuXKajfKjEq7v2wkw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAXqe1cVdJJqU2avnHOYiSsnqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYyY2RiYjUtYjE0Mi00NTk1LWE4OGYtNmZhNmQwOGY2NTUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU2YTkyOWE0\nLTYyZWQtNGFiYS05ZmE2LTcxNjBjNmFlYTQyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIkyZTEFIovRN9Y8g+KdrCmxfxIXYJcqmB16mRBV5dAsD9H2kwo6u4dB\njn8VSLf7eX3JJEZjPNQESFlhL+0Hjf+jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCYnyqgN\naMb6mpc6wEY8vkvXPNu8MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIFBFP3PQ04aARgnXMOhibKevgbEKqqRYDtg8/AYlPvRkAiAY\nRgMxHwp1TszT0ZHu0QJgvZCLd/9zupfP+opY2DlWwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5422", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5422` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAcMWt4U2ptaWMlUOce0Vrb5tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4ZTExZTI3LTFhZDYtNDQxMy1iODk1LTUzMjg3MmFjYTNiNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWYxMWFlZDYtNmQz\nMS00NTNjLWJjYWMtZGRiZjk3ZWMzNjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoAty6D/3D16TkuAnLVHTeGCeFGKRTZ1SPNd6yaUy6BjkPvczyb7d8Ovk2aTH\nhVZ1E/HiKagc4sXa4JZNffFkGaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/b03F4YeySRNjzNsZGdbcD0grIYwHwYDVR0j\nBBgwFoAU/onDJtMCEDhFstiTjOshNho1xL0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCetLyjxRulSRDoeac+OeQXNEhY2xU1+QDMaGBEC3DuNQIh\nANQ1HtTizZX83d3QzuxcO1jtuFRrQlnRVZQ2Dz3zQs3V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVvA6NpEFF6owAXgK/8DDacsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGUxMWUyNy0xYWQ2LTQ0MTMtYjg5NS01MzI4NzJhY2EzYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqezr/KMyY+Z/cdz9UBPQee64eUi3MCiUGDQ5uKBp2ZzVi\nX2RCsTzo54qv5NqLobhukClmOnKFN4hQ9lOK0N0Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/onDJtMCEDhFstiTjOshNho1\nxL0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRd/NWQgIWO8Bu5fCrML3tclvUjp6udpBuieQS6Rlw9ECIDSOM3RxQRk9\nb3rSm1Y+Bhc2bo2AXSxypnOOo9L0HXAu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISARIrp2BtGAExrkvU2bYxG2ryMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWYxMWFlZDYtNmQzMS00NTNjLWJjYWMtZGRiZjk3ZWMzNjg0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhMDQxYjcz\nLTE4ZmMtNDVhOS1iYjY1LTNjOTUyOWEyNjkxODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF0gvKTAt6m5aUyANoUO0+h+StihGXRQIApKy62hhybwOQAlKjdMsyqN\nxnpkIgCwveL+e4uQKkuW8aspmo7UGcmjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP29NxeG\nHskkTY8zbGRnW3A9IKyGMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQCDe5hYkTEOVMRym9PECjjRKHEi96K1knlTuroUl5CrjgIh\nANV8/jT1hVXMceFxUdL/GaHrBj6/uJYO6E/NeMHSE5og\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5423", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5423` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAUkvYZ4J/OFz1k0pQLfco0ecMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyOTlhMDE5LWFkNjEtNDNhMi04ZmRiLWIwMmQ3Zjk3NTcwMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRhMGE2OGItZGE0\nMC00NWRjLThjOGEtNzJiYjY2MDc3ZDFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEthTy9reHjq/sbC/EVojpBSDTl06FvmpqoTHZ1pSIhQqk6D3mDWC9XBuhnuvR\nc6GcPMWcwEjfqRMTlv7kDhIX2KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEeG65A5bn9as4+otOZpHTONjvScwHwYDVR0j\nBBgwFoAUtHBCwAkpUQMQH6UOG1gKuf6uh0MwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGjcvC+68iq15CrHH24AaSWhDhoxhCBy\nZin7sJ05HGj2AiAHsG1+vEWZPzayV2TJR5dhWnQ09FLK4Zj2qBW/1VzbiQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVvC+iGSGGrfaaERueEnOt/eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjk5YTAxOS1hZDYxLTQzYTItOGZkYi1iMDJkN2Y5NzU3MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJ4QtHyXnAIT4NO25PIaZ2X8cbGnjiYv6p8isgEMLsBl/L\nwsr6iAh2EdO3dJ6M+R7wtA9PYHNXQ9KRScIcJHdXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtHBCwAkpUQMQH6UOG1gKuf6u\nh0MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMknwiwTuUe8oB40+mhhh2HrxSIs/T7PxPgP0MWUvmUuAiEAgn1nc5Wt\nHUpVWB1yL3u6opQtvQKf+9Rfoq7pRis15co=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbMEppdISQV46olr8+ExMf9dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRhMGE2OGItZGE0MC00NWRjLThjOGEtNzJiYjY2MDc3ZDFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNlMzY0N2Zj\nLTJlZTMtNDRkNC1iODRiLThjYTRjNDUxMmNjMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHrscXQtvIfeP/RVidvgXY7J27+ZBPE4QzcPhwsZ7x3PQl3wiO5ougd8\nUuxvzriuvtB72PBA/3BadcCpEG/FrFyjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBHhuuQO\nW5/WrOPqLTmaR0zjY70nMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQDp7GoSyAEyzfMZ7k/adjyH0kmVh9F8KnHm0Fczble11wIg\nOkGdLIexqwKxwXN1igjMdMjh9Y5/2vI0cAiJ7BaPZag=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5424", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5424` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVZozgLIxC8eFBJ2mEv7jLI8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkYWExYzJlLTUzNzUtNDEzZi04YTZkLTYwZTg0ZDFmMGRlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjgwZWIxNDAtNzEx\nMS00ODkxLWE5ZjItNWRkOTJlMzIyYjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE77abjE5R38Y+oJTMpC8Oble5wHxRu1xP2NSykLxNzIr10vS8VhQBIbqpwm3W\nEzYuN9TfUbvY7B9em2ld+MkfM6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULqLDpTH4jE1BvKemWq2b4ZrWl8wwHwYDVR0j\nBBgwFoAUsFKGbZQhe6uzm8y3o8MmKve8nEEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGgHTzOxqk5qhPgkriNIyJJDeYHKtPNR\nk1urBn5ZHnpDAiEAqXXgWF3ik+UPynpLtKSGnWIh7/YuBIOIohOij1MHRlE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeNqek5jwi/7DnC/u8uMmwXKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGFhMWMyZS01Mzc1LTQxM2YtOGE2ZC02MGU4NGQxZjBkZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmUXLQVUsY4ACCMOiyWWgdBVO5z231D3x8ELsfIWL/LyA6\na1YRHCQtl+qCxl6xIW64yBmRZ64XeYivBAAiwsObo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsFKGbZQhe6uzm8y3o8MmKve8\nnEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK9+SqQkvC2QL34BA4qotSe/S1Q2CDTm2Ags3Yg1s7M+AiALjLIXfx/Y\nAhAp5THumsXr7Tl2lyeHYzQI/w0MtIeX5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAcgRCvvHog9BHxgglUsm+e21MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjgwZWIxNDAtNzExMS00ODkxLWE5ZjItNWRkOTJlMzIyYjkxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhkOTBiMDZh\nLTAzMzAtNDBkYS1iY2IxLTZlNmUxNGI4OGRlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE2raVVjCAqhKbpsBPzYclEXEwloRa1bkz78dXD0BkJh1j+m+hgSXgkx\ne2tWTEmNQllUo0TkMO66/EmZcNb+PEejcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFC6iw6Ux\n+IxNQbynplqtm+Ga1pfMMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIFXT2IeHhaItc2TZ9Qs2CPLYXchH36yosqyBa3mtXM76AiBm\nTjj347D5/ioDVUlKLwQK0mTEH3l2+qokDnNGcxDD9A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5425", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5425` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASu8uEo/y9IWC9t4E8DxzS52MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5ZmM4YzE2LTZhMTMtNGUxMi1hMDRiLWFhOTY1MGZiYWI1MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI2ZjY1MmItNWRj\nMy00Y2ExLTg4ODEtY2VlM2Y2MDlkYzBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoIhDVoqJ+IE3JTOYr5cA+L+pD5PVXY1w/yU1LVOo/bx7ti29FflmG34RUonw\nBSiVTcULAbgRGA7tcwyDQryjJaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoD7nToILtALfAQbWyrn5S6ZkpzwwHwYDVR0j\nBBgwFoAU2cGoGBST6tBxFhQE+wbzAAT7IOwwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDgtYpoKadC\nLO9tHDzXY3Qu0l1kB0scHZ1DbO0IREM17gIhAL+2UBdKItcOMBYH2u3ELpsOLFWW\n8XTRJMHYEgvsyL4S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVr3bozRDpe2BePj80iI+SMqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWZjOGMxNi02YTEzLTRlMTItYTA0Yi1hYTk2NTBmYmFiNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjaro3pzKK/sH3fS7A5Z60y9ooL1UjKtZQP8jbH3C/HQ1o\nl4NxbIWQCiu/CVFUXPd3yehxrWJNj4KT8dmIPYVUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2cGoGBST6tBxFhQE+wbzAAT7\nIOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJOZHCXvtt3d0Vh8WZh13+O82dA/RZeufRwCu8D8BcwtAiAR2g2C1KU1\nNRNusUN0CbRMFN69+KPTxxjfDuzeSWZaDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAR1nkQZCxVHHgN1wCGo7Q7U6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI2ZjY1MmItNWRjMy00Y2ExLTg4ODEtY2VlM2Y2MDlkYzBiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJhY2JlYjBk\nLTYxYjgtNDBhNC04ZjUzLTZhYjJiNDgxZWFmOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL2oPeGyoT8BG825Snv12DZxWIDkoLiUrSwG0cBTNGVRM5CQUwjXj6Uh\nDxerOWBRx7MYpj5WQ4eSkagWhcDdYrSjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKA+506C\nC7QC3wEG1sq5+UumZKc8MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCIGHd43eGtCuNhFSQGBcF7gM4r32vmG/enJcwQDYk9/rBAiAK\nPCDv/VYbP/ueRQPlU+sI1bNqvLj/bxvUpTEg01vzrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5426", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5426` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARYQ8dOQ6JlXMX5HtowMga8fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlNjE5NWJlLTk4N2QtNGU0MC05ODI2LWZlZTBjNmM4NmZmODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQyOTYzNzAtNTMy\nNi00MmI5LThmODYtNmIwMzg4NWM1OGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENFqEU0hoFtzBFvZM4+DbjxtAHNFzSNBtijQ6DzoGiOPPEOgo9GqKZP+103Ot\nxQHkceu59QXTrJ3GquICRw2uAKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBuBxYlgfvs6qpQcKcq1JWA/G2zYwHwYDVR0j\nBBgwFoAUvHRL9KLeZVVH63ilD0uYDekPFhYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAK0wJoFGaQWZlPSHYvD2+KJCOou2l7qGhxHk9dg/JOk/AiAUKV60x9vN\nRuaRlTOhFRTK5NCod2f9cWpn5TXXzaSO8g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYdP7UtM58Q+h5P+aDWk/4PFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTYxOTViZS05ODdkLTRlNDAtOTgyNi1mZWUwYzZjODZmZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk3iVmxybYXvkpuLwwj/glCLVGbQoLdLmL/Kb0TeR+ulj9\nuGzoENrqpcOZnoYQqfD9YbO4IKxiQK5eurZnTAHWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvHRL9KLeZVVH63ilD0uYDekP\nFhYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGDL1SX84mCqkDRKWHG51sgnj967t1qTT+4ZmisFdkbECICQL5aLGPVk9\nuGgPncdNaS2NzE/YxcP1ueoAiXrhsd3G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISASQ1veBwphao6tFHKcmRO77PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQyOTYzNzAtNTMyNi00MmI5LThmODYtNmIwMzg4NWM1OGNjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZjZDZlNWRj\nLWFkOTYtNGM0My04ZjhjLTdjODk3YWFkOWI0YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFjGgmAdn10OKuzQcRqTcZzy1dXRuDp1Q9/LdkBQzbWZSoaW7qG0Tryq\n2hn6Qwad+b0c3xAlqGaBXYOSR+AT2/6jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAbgcWJY\nH77OqqUHCnKtSVgPxts2MBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0cAMEQCID6/1hVYkvoSAOOukQY6gk+knZhHnj4dFjtxqrqmx4MTAiBr\nUFxDcK1liogmuIF0IR1F442ComoARsoyk0zoVVecbA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5427", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5427` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAbtlY+d7Miy0376ztGSbQwCJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ODE5NTVmLWRlOGQtNDQ3ZS1hNWU3LWRjNGQxZTg2YjY2MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRkYzg1NWItNDI2\nOS00M2ZhLTk1MGItOTM4YWEyOWJkYzdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdFaOd8OHN51yqPshiT+31Jo4TmtHFjHZwOtU9FpVQ4wA/27T/Mca2KvkriEL\n20eJWNhuXdPGkRXvVHmOH91hu6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ/5JwrRdsZT7UVp/7dCp+D7P0GcwHwYDVR0j\nBBgwFoAULMYTnK/eUbmgVrVP5N+mdY4y7RcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAMF/rUDsrlWfHds6Lj8BOzVtuAnvH8RVECzREhc8zyMYAiEAwP16Ko7T\nlKAhtDapa+fHJMoJjXxRari+jEAuNUCmoAw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdDDLmDkdwdoHDjQ6GGs9RQnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTgxOTU1Zi1kZThkLTQ0N2UtYTVlNy1kYzRkMWU4NmI2NjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGdun6zHzbgA+pxxC7cnqsTyYQM6Jqi/fgPgwn+u6uGohB\nX4mvjSgqxeVxY97XYPUPFW2Qk+3d2gOXYhWNT3Ano2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULMYTnK/eUbmgVrVP5N+mdY4y\n7RcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJBgb/V79wxo7wR5hWqImJc3PaGWbdg/hskHEyKqyclnAiEAtSS+dGKi\nYL+rjWxSSIwqkJELwdaUEexXYMacFJxqIGo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVDoZO1tyhcp3Wz+j8LPMbfkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRkYzg1NWItNDI2OS00M2ZhLTk1MGItOTM4YWEyOWJkYzdhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAzZjkxM2Ex\nLTY2N2QtNGRhNy1iMDBmLWJiMTU2ZWU4ZTM2YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP0N7eEHsnyKW8O4or5S6Jvg7nE0ywJkhrMb7hloG03Xe5vPMt27d2zj\nJ6+wyj1AAMw4+dS6eZ82xWjAeycjbXmjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEP+ScK0\nXbGU+1Faf+3Qqfg+z9BnMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIFMxlHfouEkrJFCWUhiKN0iZXiCS1LlTKqNL3676rf0UAiEA\num1k5BYkYKfKe9xQR1VgOjTRzHAKPu/ehSB8xeGtVuk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5428", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5428` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISASmCZdi9jyFO7yDPGjku+mKeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjM2NmODUwLWFmMjktNGIzYy1iMjZmLWE0YTdhYjc5NDE1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEzZDMzMzctZmE2\nZC00ODllLWE5ZmMtYWI4YjM4OGZjYjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8yGdpcjkP1747NjI+BJPCVwyqhILeziaCFQNDXiTcEST97OSsPapOaj8XZBe\nykQOMPTacfNdO3OiOUqMson6UaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCo1nuTeJuT8SCmeNrqFpIVU6IAswHwYDVR0j\nBBgwFoAUUNYx5/o0hCN8z0Kf4BndNfO7SK8wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIDdOHlixeYPkIs//rjEoeBIdDyUSOcOzjOvzD6qFGuKKAiEAi8bS3Ndh\nQllH6ISmsf3V1urstmAbGY5MUzVv+Qr+2ik=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYBpz87IDQR1y8JtXt55Qm4vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzNjZjg1MC1hZjI5LTRiM2MtYjI2Zi1hNGE3YWI3OTQxNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUmaLBqZMskqKPiAZoBAzkropyOzKFRFlor+X70/KjNZVZ\nlqRIdXwXOccuHhxL84gjHgRxhR8oo8QwoTPp5xLPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUNYx5/o0hCN8z0Kf4BndNfO7\nSK8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdEr5K6NXjXwi6kcTmVQ5ercp3uJejCHGcq4yRF5nakYCIDQO3dePTVbi\nBTMG7srbbstY84d2seeKS0gdUgmoBLcK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAbMSP5kbiMgVm90lDdJAts4HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEzZDMzMzctZmE2ZC00ODllLWE5ZmMtYWI4YjM4OGZjYjA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFhNWE0ZDdi\nLWM4ODQtNDA5Zi1hZmVjLWJkMzgwNDFkMjk0MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN9NwqvPF3BHcCWp750r1py2LoHKyK6VHNnbiPCUohI6Ad0zyIcmQoTD\nzelSXFNO+qL5K8aDrNBpasUPDWsCBRSjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAqNZ7k3\nibk/Egpnja6haSFVOiALMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQD2Mdg2b+V0BHVXB0gd1MN24CGFb7YLbmPI/+MzZFvW7AIh\nAJPYbpkk4FiShRWr6f0f+booirl8Cs3rQ9tkZzcaoGww\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5429", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5429` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAcaTGq5EFKdopx4Pl1kzqCffMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2ZWNlYWI4LTc0MDMtNDg5ZS1hMTExLTZmZDkyMTQ5YWIyNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFiNDI1YzYtYTAw\nMy00NjYwLWIyZjktZDYzNjZlM2YyNmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0XucZVt59AO4BkfQYso9GT0YGcRUq05g0LyBo3LUPUVs/VUuB980F4bcDuMZ\nVgLfx20lYQ3iIYQ62r0HI51gL6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaUwQ/fpQo6KFAqaJyLc+f8jnwKAwHwYDVR0j\nBBgwFoAUthsMKDfbI4yybsSIWYRxBmP2qEcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCcCUWKjx3Dj3wrutOiGmvmQvm6P1QWcI6CXrpX\nOyIgcQIgNPGBdVsf2kBwkAp3wOZEF7qJ2fjtlsYdmnF0eh++EEQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeRBnu5XnxymYNKOM4ysD3QDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmVjZWFiOC03NDAzLTQ4OWUtYTExMS02ZmQ5MjE0OWFiMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQogCPCRgMcvAYH2inyGTmxzLuTIcw2eCP9k6EVvjMbuCcG\nfLIqYdoRmc3b1bNwZkufW8LeDK1zVpYrcKSIMNamo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUthsMKDfbI4yybsSIWYRxBmP2\nqEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANb2AO4DMoPyA8mSQpRx5L59Q/WEZi5Bc7MrWWXFNq4/AiAa9WgsHw1l\nIJ3hF2iovolHROqNiAFvwFPtKMNbmyTrGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUBAiHeCnqT96Ktff+t3KTNbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFiNDI1YzYtYTAwMy00NjYwLWIyZjktZDYzNjZlM2YyNmI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ2MjI2Nzk5\nLTgzNTktNDRjYi05NjMwLTRiMzNiYmY5YTNiMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHhPtdJ1J1jN5Tse/iKzEkY/yc36n/3bRVTgXkVpYxkyy6G9GFPuXnMG\nkSxpG4WBVwF0QK/qdcWSbeaGswnIxpmjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGlMEP36\nUKOihQKmici3Pn/I58CgMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIDu7u0OOIPnXpVAVJLcsk1hXKDNDhBoBgZ6ve4oV/TklAiEA\nix/78kYdXp8qg/5NRGQ7X2ranWAIQRkjdxTbSUCHI94=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5430", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5430` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAUN80jNla9li2rM3gc5Ak1l8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2OTA5YWZlLTY0YzQtNGMxYi1iYjU5LWNkNjlkNWNlMTM1OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmIyZmI4ZWYtMDFi\nNy00YjRkLTgwNWYtMjRmYzRkMjU5Yjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA9b06C51hYx12KSTveearHLLYpKB3CMIB8o7y0fGl7v1trq2CseHAW1E6FuG\nzQnK4/ocEUTTNdQaez/ti94EF6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURuDsQdA+gq0JgV4T6MaBjaIoggQwHwYDVR0j\nBBgwFoAUIugPZznB14uA7MfLJ7mz5f+Nq94wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCxKvcmC1Fv6yXZPYj8b1B1drFEKAj47Y8xk63t\nRAybawIhAJw7Jvmfuu7Zj0od4roGxTvh43LJ5yHzbIvpgoYkZvqG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaN8b0Qdw+bLC8rMTPLlGZmwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjkwOWFmZS02NGM0LTRjMWItYmI1OS1jZDY5ZDVjZTEzNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLRvS2f/dGQL4ZUwf+TquJ9utgRDfIuq2G+ALAGlQA0lhi\n3p6Uv5zWLEOhUQ/MpmBLiNVl4X0wVIUj2iR1d5uCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIugPZznB14uA7MfLJ7mz5f+N\nq94wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNlxT+cgxJQ+gjCLlzJuKo60c/xJndLNRS2lVgEjWcygCIDNwiDA8znzW\nJOI5StUkw1gqjVImQyOyxWYksXq5YgQA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAepX0TVCMoaOvOciFJ8kWT2KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmIyZmI4ZWYtMDFiNy00YjRkLTgwNWYtMjRmYzRkMjU5Yjk5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUwNmM1Y2Ji\nLTkxMTAtNDVhNC1iNmVmLTgyM2ZmOGE5MzRlYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHCYr6x+gSY6HJ5I085by76e1pwcCF3EV387nyOUUzhQnHdeTfrRb4zd\nBsJ9e9vg7Y9wWrbc5Clsd26CunR2EYajcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEbg7EHQ\nPoKtCYFeE+jGgY2iKIIEMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIDpy0Msgz2MGs6fWP4auKsreMB26FCtYeOleDEyTKDJmAiEA\nx+Vm/mY454oF7x1pJg6QAQ1niJthwXYTQhJuxHvykSw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5431", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5431` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAQHFHiF4MwuRH3Rqw79mwR5dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiNjMyZGVkLWI2ZTAtNGY3MC04NjBhLWIzOGUzMWQxYTkzNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU5ZDQ3YjEtMGYz\nZS00M2NjLTgyYTEtZWIzNWZmOWU4NzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZMNnMQb4Tbnzb384mvPcEDr7mtNLG1V1yGYOk1uT6nxTdubt8CfkAl1Zaawr\n0SL1LP5b34k/btHywA9njxFzEqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr8RoUWV+f0k0tCmjK5lxY33yoKkwHwYDVR0j\nBBgwFoAU+TOr7rJts6jti+g6L4CCmBpmbiAwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDODnoY+ggYHQVJ1T7eZLDHrHUe19Cr9KG3bssMrdZOXwIg\nWj1P4MfaUjgLVE7+UXulSC0gdXKMY17TvWMR0/ytcys=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeLX3pyPWwQ0KHqTwRm7HZpsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjYzMmRlZC1iNmUwLTRmNzAtODYwYS1iMzhlMzFkMWE5MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkw0oXTK1oKZMAyPUCP+3wSZR7OQnfT49n2QtUqPp0KZ4P\niBrmop9fJkINzPKAvCp4Sm/FjXNsGelJ2dxWsF0Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+TOr7rJts6jti+g6L4CCmBpm\nbiAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKTCAHDAcwuJFP5Evd12kX/PGrdG/DJCDqBBEz5iOAjDAiEA1vGp7CSm\nuhRblflkRrRREf+Gvi6Bc8bVdWOgE2rBrYY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUekUljGh1SUtq6tS91b4O5FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU5ZDQ3YjEtMGYzZS00M2NjLTgyYTEtZWIzNWZmOWU4NzUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyMzI3ZmU3\nLWY1NDAtNGJiYi05ZGQ2LWY3OTRlYjAwNjY1MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDXqGh0860jyvmnUfvW8ZS8gpDwRCkeqBj4I1s7eCd5V5zSFedcEVcd/\nbru+TD9po87XypqMEm6ns2D+owQhYUmjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK/EaFFl\nfn9JNLQpoyuZcWN98qCpMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIHwuJAlyZOMtlRNS9fRvBVBkxBXS4NGRqh48Im5JXEx3AiEA\ng1uq9Hwog+7TnJUFZHvLw5a3WgM36H4sLrtkxJsCJG8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5432", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5432` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQZZzgeICb2xkTg/+dHbUkj3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhZGVjYjIxLWNiYWUtNDE2Zi1hNGIyLWIxZmU3YzViMzI3YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg1OWFjN2UtYTU2\nNC00YmFjLWFjNTMtMGJjYTQxZDNlMzUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEctR7MXRi8mvceOo9U6MKssy0lgtfZz8E+zpk75wRH/krIIdkfS1uK5iLmftt\nRFVFwa5B0TrcGDdfFwhJv83uQqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURumx+JQpx/uRrBFoGBLwM/spnZMwHwYDVR0j\nBBgwFoAUFbwZIqV7KBCtYj6zTCX6LZ0lZM8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIATFn/lPEzwRm4pByyBHazZF5aVMNm+s\nCBptJUYgR93OAiEAqktG8JClKX7QMt2qDIO/U7hk6UfXsSlm7UEcjtA7oaU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX5beBZPEgwQ8qCgnjP/9ydcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWRlY2IyMS1jYmFlLTQxNmYtYTRiMi1iMWZlN2M1YjMyN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbCKl2j2YJQU0KfMb26BAZ43Un7OXaLpGsML148y34BcdU\nMaEZcuj95yBFYMFZ3icr3MbTAPLyXYmiyqVYhPJzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFbwZIqV7KBCtYj6zTCX6LZ0l\nZM8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK5w5uk8FkGgqTcits0Sw2rl+Gq7UgG3kn74mfOpneawCIQDIOfWEMgek\nS4qk/hlzVYCYx79b/LLw5R5Sfv/mcuR0tw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAYGWCkkbpGA8IqpM2GxtkZkiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg1OWFjN2UtYTU2NC00YmFjLWFjNTMtMGJjYTQxZDNlMzUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcwOGMxNDM2\nLWYwNGEtNDRmMi05ZWYzLTQ0YjZlNzY3MmQxMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIkDyD4bFSzdT65Ep2dKYE3GZLwNXuRpxHteQGVQyteQFskYO3jfBRAC\nZz/a1yQz2zlm7oZxRmkxynPPemOeci+jcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEbpsfiU\nKcf7kawRaBgS8DP7KZ2TMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0kAMEYCIQDsF7+/zUNcHlITpRtDTM1544glmgxwISxHbR9fZqz7hAIh\nAPGGOjVhKchWucPElkqWcXAjqUmR67isK4bI0Zwvr/dk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5433", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5433` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISARxEfGBrM/urJQh/9faxMxeNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiOWZiMzA4LTg1ZDgtNDdlNi04ZDQxLTlhOTdkYjg0M2FmZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJjZTVjNGItZDQ1\nZS00MGRiLWE2MzctMzIwOTAyODQ1MzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo5LSh2F5Pq6veM1KdtfVY8yyHL3oYcmH5rFae5t5ZmD5UAK6QRpuBKIltfhz\nifC/39lnDYBV6gnZ3fCdnQvV6qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp0uNyw7uEkAEhscBpac5TP4qqS8wHwYDVR0j\nBBgwFoAUlyfXE48swJtpOU8pySrmy7w6nvQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCNv9M32FEmzabJXJL17DQblqy+c+8k\nbhmRdF7+Iu/B9gIgZ4gciNin/LIIZSHXHmTbnDLYunuJASYfeIpuYanbI1g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQzz4nMgXclQ03gWLjjudcMtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjlmYjMwOC04NWQ4LTQ3ZTYtOGQ0MS05YTk3ZGI4NDNhZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQX6mZgTuOcVDzOZjjjhaZcxCmdgdb0EcOi8SAAtC3DhKRS\n8lkxEXI2QRrIJx8lw+4SiJpbxHg1jcehMBRgIJyZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlyfXE48swJtpOU8pySrmy7w6\nnvQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWH1v7T3DDoWk8v3P4uHW5BuSGRqMWTcfx1P3n4AV0SICIQCB6yko3x0V\nVlr/OxBO6RQX0DIwP3/2DOM91CdYtuoDAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbFz7kDwGGouX4jSuLN1e4NVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJjZTVjNGItZDQ1ZS00MGRiLWE2MzctMzIwOTAyODQ1MzE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQyYzg5ZGUz\nLTQ4YmMtNDM5NS04N2RkLTA3ZTlkZTcxZWEwNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABExGspBe4Tu0EgdayPDJBC4imQBPj+2O0isgaO5PWp8l0V1xY9koGqaV\nn/E/p1aLSHtAk1PMHVhhvuJSsD16ZHKjcTBvMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKdLjcsO\n7hJABIbHAaWnOUz+KqkvMBkGA1UdEQQSMBCCDnRlc3QubG9jYWxob3N0MAoGCCqG\nSM49BAMCA0gAMEUCIQCMaymHNVzELL+xavsvq6ZisYx3wzVeB0RB0qIHIbNqMQIg\nQhNNNbldtoqUGCAOuXIraYtfAgXWiEk4mwEOaOVMMvg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5434", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5434` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfJVrKki4HJjGpRrHyTVK+F4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2YzQ4ZjRiLWY0ZWEtNDI3OS05OTI4LTkzODk2N2JmYjIyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQzMDhiZmQtNGVk\nZi00NDc2LWI3ODYtZjhlMjlhMWYyMTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0KTz3917MDuOqYL1LPW444bex00r4E50L2vpin6vfHpup1a/FafplaKjpF8w\nXJrfkja3uZEs9IQKfnDcnhqTZaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEkONF3DIKfi3MG1E9eV11gssNZ+MB8GA1UdIwQY\nMBaAFFHf8ZZFIKyL+Mfxzw3VPfnZ1gsYMAoGCCqGSM49BAMCA0cAMEQCIDYi7uCT\n3NwBBgsn/Q+wgUSMUcRA8XBzHLLGVWfEEiEeAiBGQveKWObanJKF9zGBB0k0usK9\nF06wvMcIGfBmblTnsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYUM7YLiPfz+9xtXWxeQ3bdUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmM0OGY0Yi1mNGVhLTQyNzktOTkyOC05Mzg5NjdiZmIyMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCxiv1aGlSIPYvEqVMNdgaWuQE/sUEESulJ8YMWmdEmwM0\nKdgEXsy01wdalaHr4iu1l2J8RwnyUOuOZZdo3CYoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUd/xlkUgrIv4x/HPDdU9+dnW\nCxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIuzEd/W5B5QYxO2mn3HaMLHFzk79TI20O2sIJp4KYFxAiAvmcXuUbBo\nneBlsPN3MT5siEC2BLRIbh4MflkhCT1i4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAXyLyVtaTmPANsUZjly0JuIcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQzMDhiZmQtNGVkZi00NDc2LWI3ODYtZjhlMjlhMWYyMTc4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZhOWQyZmZj\nLWE0NzktNGI5Ny1hZDYyLTMyYzUxOTliOGEyNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD7UyX2AbDRr2bdKcC+7r7iSAoIDw1A9RegHvy/7wMyNkpYoUSN23lYA\nfwvOYuSHljCwhD63AwwPvvFxEakr1hOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEkONF3D\nIKfi3MG1E9eV11gssNZ+MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIBYrusQYsf7FCnAwozunFON6QzQxbgKGyZpeEoNv\nMy1yAiAnR+VzPSyOeCAM2fhOAC7oiu3V4M3bX6xKo9xgE1V7UA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5435", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5435` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfiqRDocLWURiJ6zw6atFl9KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1MTRiY2I5LTY4NzYtNGJiOS04MjI5LTQ0MGNkYWYyZDVlNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQxMmEyYjQtZjgz\nOS00YTRjLWFlZWUtNWQ0YjQzY2UxNDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcgIyN7W1XQs22a8gwraHViZ38DWuaKImM87Wf7/twynio8HEo0tqLyQSwCp2\nkHd4lrEuct5VdZt6Txj+stSh0aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEi3T4MvGaEPtf386DtfWIYHCWC8MB8GA1UdIwQY\nMBaAFIwij31FPBdAylGGN5NxTpYVjeCKMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAYIjEQlb+G4ZV5ZI1dnTyZyu++xKakJi1D\nBWGTXKz6JwIhANwoTtHhXW0zZljfhkR3e6mxqnZTUVrwr8H2w0+RrJEt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeekC2nhL/SvFga6cV+rbS1XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTE0YmNiOS02ODc2LTRiYjktODIyOS00NDBjZGFmMmQ1ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu4clM+ehLHDOa9aGPF5m+FSm5mjrGV6FUavFTc9Ny2yqD\nEN4eb0nd7KO+gSP9wXs841UM+9/HYyt3U8rDX1xMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjCKPfUU8F0DKUYY3k3FOlhWN\n4IowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCDGkA1CQ0rtRrTKt8wc6gpjlgCtSX6X6rU4DZeiJ6GICIQDUtmiidSp8\nFVcd0lRQV1ZjKVD+0b2/jByKBCCRBK+jrA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAWd/33rPunIFd8gCcpBFxeNyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQxMmEyYjQtZjgzOS00YTRjLWFlZWUtNWQ0YjQzY2UxNDRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM1YjIzODRl\nLWMwMjAtNGQwZS05MzdlLTVlZjgwY2QxYWY4MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJPDBNqDSh0u10+I+i4PUjxhnxvCjWniQGodiLwYdLeHxf6Lm9WLq8k+\n/h8QBnZmPUg2LaDHT4Zj1iZDsqLCwvajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEi3T4Mv\nGaEPtf386DtfWIYHCWC8MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCICUWAxdw4vI1SPRr+5nAkprmQBdS+GAPfUJrqGYa\nK60IAiBG63kqznabnihgbLoE98u1LC8jiqfch9k2GIXN9/AoAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5436", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5436` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAdU+s1CaDocUu85oL8YqOkIOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ZmFlYzU1LTMyYmUtNDM3MC04MDRkLTFkMDQzOWY0ZDA2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTcyM2U1ZDYtMmM0\nNC00NDZkLTliZWItODM2ODEwMDAzYjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwy7PIlAlw/JjQJpYDOtYnmmFpfNqe8stTICJC0S+i8V0UKNVqfHbKLX+Sz7Q\nfKNfiHfeUOuCXJfWvUGQEV9EwaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKnkD4Ry0BJGw2euUdl83ZdMCwAlMB8GA1UdIwQY\nMBaAFOdmnxJgThLXu9mFJb1mgu09LrmvMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA4s3o0s+MwAsa971RlH7BjYLHc6yXtu59\nJHrTizLwjCYCIQDB8bpveDoDgQpi1z+P6J/8gp8eZJMVp7De8lgBZF+LQA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWSYmJikyIkLTnWSzkT9Mps+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWZhZWM1NS0zMmJlLTQzNzAtODA0ZC0xZDA0MzlmNGQwNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRjgcCE/03NVAUkluORQrBMf3iAn6qWHa/q1+mQP+4/J3+\nlSBXn6JjSS9PUq+uMOkw5YEHYYO4NIzgme9WvVfRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU52afEmBOEte72YUlvWaC7T0u\nua8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJBej1koLhM3OvTFgiijZngc3VX51f9/JrMnPmx6xPmlAiA+LBvHszEK\nw8by/Mu2i8jug7IQ+LXJPLqlRVkmqjxReg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAW/37C3z6DOdQR2vs2R1vvLMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTcyM2U1ZDYtMmM0NC00NDZkLTliZWItODM2ODEwMDAzYjQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgwNTQ2NTdk\nLTUyODgtNGQzNy1hOGQ5LTQyNTZiMzQ0ZjEwZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNq7y+tlNmXJp44k5tBGWngomDj7jUyJvT0iQF7Z5Oi/FH4MwZxMF/vJ\nmL8fsAXIb/dQ9AD9FqTAcpV6Idi1g3KjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKnkD4Ry\n0BJGw2euUdl83ZdMCwAlMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDgFA5YtaUctk1ICFjc8Gdb9zKjfbu4OCGhxfTo\nHLBS/gIhANuezyd4/2Ev0UKCQQpEFocnCGphq6qzr3juzfVexGXp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5437", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5437` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAexav3kNGa0NUQX4nLlbNxz5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjMjBkZDdjLWU2MDgtNDRkMi05MWU1LWY0NDdlMWZiOTk3YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjczYjdkMTQtMjIy\nOC00OGNjLWExZDYtYmUwODM0NGYzNDA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUb+RYIaWCwGHsAlii/3aD1THoujO17yudRjTPhc8SD/auBEDomVZgrNBFx2t\nrIDyskrUzf+MLPdh01UWdhKmU6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSMmBpRIi+XdqgO58CaMt6u/XS2hzAfBgNVHSME\nGDAWgBRk0uAwqQJWnGeSoipbnvrSwmcp0DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCiRs5n0k3rSOqWKrAfMYFOrOxwMV3U\nzSj6VdAzs9RkzwIge5TkL9caq1VGgTaM7061KrLFVTB2BlUo0O2BC02Xg9w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYYwpDvXcPXLkKZjAPZGnvyCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzIwZGQ3Yy1lNjA4LTQ0ZDItOTFlNS1mNDQ3ZTFmYjk5N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSCxrps8L7fPvdFh2uRjclq5R/WixwePA4x7pYYoLseyZ6\n+RORCe1IAm5b+fWsxLHz0d3H8UGVm7o53/11HzONo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZNLgMKkCVpxnkqIqW5760sJn\nKdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKmK27yqQpChDj913kRLVrHvquXusRPXscW9D14exPqmAiAyxZEV8quC\n7GHY5Q/H+rKEf38gcgba26QE7zqIBQlI0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAWp/dhAA9lvbAUYFgkjr7tRYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjczYjdkMTQtMjIyOC00OGNjLWExZDYtYmUwODM0NGYzNDA2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMxMTk3NmEx\nLTgxMDgtNDJlYi1hM2U5LTE1OTVhYjA1ZmM0NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKrxcO3AlCcZzOHNw0VK250wOANYiwlI+SO3GcfAJ1MV2TCD7rNh1rWj\nIqUfVIUkNR4mkc5SqTUlUVsq5OFs1c+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIyYGlEi\nL5d2qA7nwJoy3q79dLaHMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCTfvBhd/7MHoWipzFayosnFn17moGHLBHQLHEe\nK2C1wAIgHBP0BNXMmcy/pi1tvYWQEl1Vc8krAbZbqFF/jv3HLc4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5438", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5438` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAblAGyvAhlAiQVKk7QCrnR0GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlMWQ5ZDk5LWY4ZmUtNGMxOC05OGRkLTQ2ODQxMjFmNGQ3MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk1YzY0MTctZTAy\nZS00YTczLWIyMWUtNjk4ZGE2ODBiMjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbmbnBxnfo9cIIPNYlgntJB+hJ5CHzL7Dd1ydZvNgUlUVnbpY7uhYVGmr6Bsi\nnc0cS5tpiZwYa1C36QTp1bKLwKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwf/0AKtbaEqFMfevz76SzKfiGxcwHwYDVR0j\nBBgwFoAUKchVrKZnOupcPMa0FZHVD7QSoO0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAkYKN0m6zuIzt\ng4NMJz80T74N42sfmT+B1jX7MHrPuSACIQCYbQBXLXy3GOImhBM2DArjpNlcNMEQ\nUtT0FCfu1mVLTQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ0YnQuLpqHyjuMdlfXNhAdbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTFkOWQ5OS1mOGZlLTRjMTgtOThkZC00Njg0MTIxZjRkNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsRUikOZO4zS098/qGNxPnckj1oWJXppx7kAFnaoDeHyfW\nieBY4XuQRPDOVbHk8G8+rlQV6aQD4NOmsLCgzquDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKchVrKZnOupcPMa0FZHVD7QS\noO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANN9BRnKkTJdmymLn7VOR1zTv3Najxpn8pDOJ3Rim+EiAiEAsFIuGdqB\n0JrSOc88aY7mAXVKZduL7LvconIz7bwPQp4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAbbpjZRrvfPcuilG2eq25ICYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk1YzY0MTctZTAyZS00YTczLWIyMWUtNjk4ZGE2ODBiMjcyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNmYmFjMmFl\nLWNkOTItNDg1Zi1iMTk2LTkxNDUzNDc4ZDU0OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGpKAEP5ktp5fSfs56qssPxdqUgcu/UwSRdmumN3S5pBi3VwdggoE8bb\nZi1JRcaBXu+h7TWk7lvD7QD+5/TmKQqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMH/9ACr\nW2hKhTH3r8++ksyn4hsXMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDw3V/yrua4yHXyXECTSoA+FB2DDX6K6SVWhWUW\nZrs0RQIhANjUKSYrcM4oktT/Gyb6UbH+1m/OUeQhvIy7+B+46DvS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5439", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5439` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAaFYQu5z33Svj/X/OgtrsAn2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1NmQ5YjI5LTEwZDktNDlmOC05NWYxLTlmNDZiMWNkY2FlYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTlhMzIyNDAtN2Rh\nZS00YTdjLWIzN2ItM2RmNGYyZTdhOTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH1TcM6QfdlUkXTpT7Gywb9oG+B4Go3qpR7AAfs8eFRiTM6O4Lh4jJhTJQTvq\nSXxB1xrV+XyuWX1zj/lhhajlr6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXrRPuIlbJr5qE8vnKqL/W0vkH7owHwYDVR0j\nBBgwFoAUZ/QNGqLeE1DoYjXAe8jl3lQvOqEwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAxZrCOKR5m7DHA\nwZy6Ai1aPIHHrZ0KrOzL/nQ5qE+FtAIhAJOSJhWhffuFkcIgNumNNomWkJIgFfk4\nLopsf1eQSPi4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYCzQTIJ4iwEXsdVXbit7W8NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTZkOWIyOS0xMGQ5LTQ5ZjgtOTVmMS05ZjQ2YjFjZGNhZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjTjpEpw5AcY3yIhcVnzl07CV5dHnXaxWJQkhUcafIqZ7s\n6hq9py+yN8t5Chgzub7qVHd95GNHgIYRRM2deC/no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ/QNGqLeE1DoYjXAe8jl3lQv\nOqEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfapOAMUKsFr8blj4txXb/ulGBye259xyHgFBl/N9yh0CIQDVrMl77m8Y\n0tq6iArm1EoJgkp6mFqDTpG6g3vkzPrlHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAc+BzgOjwrmYGib7PpSQWD8BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTlhMzIyNDAtN2RhZS00YTdjLWIzN2ItM2RmNGYyZTdhOTRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRjNDg2OTYy\nLTU5YzktNDBlYS04ZTA1LTdhMzlkNGI5MDVmYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIlom3UIDNyW58+tTpPTDU21eBPZ36qrcPSPEOG06q+eBde/V7X7Peyc\nRO9dL810w+Jvc9S4wYj7rMpL5i+fDTmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF60T7iJ\nWya+ahPL5yqi/1tL5B+6MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIBGapN7n9tDXY1oU1FWQP6HOLlHxg/OTU39DZypL\nOrGyAiEAlrYUmcl2Wzmsv9MFdJaampta5EnlMGAETqnOuq+2BQc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5440", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5440` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAUk2IUTZjmj6Q2P95Kv42YOyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5OTY0MzcyLWI0MzctNGM2Ny04NDU4LWJmYTNmZjhjNTI5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk3YWRiOWQtZThk\nNS00NzhlLThiNGMtYWFmOThlMmJiMDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm9bhP3M/+oBNAxdltbjdMFqM5RJEYdz+jVO4AoVE9NMyGmuq9UyWB5URQx2l\nNPaR7lVdKdOcELB7ir3eSVNPXaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgbf8sqTZ/cm2s+xfHndzAH9wUNYwHwYDVR0j\nBBgwFoAUgrIt1RkyzEH100a6n8cmmZK/qlcwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAhnIhrFBhU5UAFMUZ+xk2\nD9GZv+BU3wlS5FngcFjBS00CIQCg6dU7764LlqcBehJYKSmFmbVmMR66wVblHpkL\nOs9nyw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaWB4d2ZZai7AYFUP0ZLzotaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTk2NDM3Mi1iNDM3LTRjNjctODQ1OC1iZmEzZmY4YzUyOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfxLvoh1JR6utX/7CYzQa271bSyaSKtutPBl8WV2AmGx5d\nwG5S3MYSO+FmhwhAG+xa6UPK2UVgJe7oBENs4vZHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgrIt1RkyzEH100a6n8cmmZK/\nqlcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANbMnkl+AgMQnPwEEH2LNUUGDj5k4trHf+GoF9tiSsPzAiBT5fPW/Mqq\nFBDWgEaI+z/XQMftHHv21FLGWq2WqN1vuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAYw6Dww9LBuS9uINl9Sod/xqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk3YWRiOWQtZThkNS00NzhlLThiNGMtYWFmOThlMmJiMDFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQwNzgwOWNj\nLThhNTQtNGE5MC04YTYyLTNmNTUwZjgzYmZlYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOCD7dQyyknkQA6NP+irRSXIgvhHOhm0m8zVmWg4G6r467scslCPG9xq\nEjshVMlWmsLELsOqcock+v1tZNHibIqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIG3/LKk\n2f3JtrPsXx53cwB/cFDWMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCICykYo1SxnfDhkIn4dign0Wt3WU2swiqlEHuvBgN\nLlPgAiBXR1SoKeEg9inrFvZarUGGN0KCIdN2T2AtVT6+zbYf6g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5441", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5441` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAUsAUKPUaDCX0F4vg7OQWGekMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMjE2ODdhLTVjYzgtNDkyNS04YTliLWY2NGY3YzZhNDZkNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRiZmRkZmQtNDcx\nYi00OTg3LTkyNDQtNjA0NGNiYWIxOGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG1nYmHrzxXJyjCcp0WkhWFQFo9idW0t8x4H4uqAt0xlOn0pggbwHc/2m/Wnk\nXeqgRCdsevtlaSbCBGQm+ApFGKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcKF5oQQ06/yVQfnrBX0u1FsbZAAwHwYDVR0j\nBBgwFoAUrs0A++IykSVEKp8Hm75IyRucknAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiB3+ak7\nGATLq/GuWL60wN+1TjOs0ZiqS1CAmlYeABJVIwIhANPQOKD1Dmx2jIG/hp+4TyE6\nuV0051kKwAO9D5uR2+M5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ86VSQBst80OF4IcDo8zp0eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzIxNjg3YS01Y2M4LTQ5MjUtOGE5Yi1mNjRmN2M2YTQ2ZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpuiEt7x9QCjzoUCtBmwipm64sNgCybCTaJilhP8VLCYN0\n5Y3uTjZJb30pNg8vTzHtq1g9jjBLr1J9VXDbEfNpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrs0A++IykSVEKp8Hm75IyRuc\nknAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPukxpMUH8Rm/vNcSInn5SUs9KFmmCMmIEUHQN42ddLiAiA7xcYkzjy2\ntJ71LGOMrVaOyYa3nrwoZmGthbVB9MQOCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAcqzF2VU1DLTeN8dJN6umyAYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRiZmRkZmQtNDcxYi00OTg3LTkyNDQtNjA0NGNiYWIxOGUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNiN2M0Njli\nLWMwM2QtNGNhZS1iMjZmLTUwMzc3NGNkODNiOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJmK7U/F1oPvEuBIyQKmDUb57rSgC8bw1yeaMOVaXAjAh+F34VMKtpq3\nialulNJWbr9P1Qez1y1dIuMGKy/OK5+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHCheaEE\nNOv8lUH56wV9LtRbG2QAMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCtE/2P4GLFIzbBmX2VXoMO11y+tElPUCPrOG4Y\nyqEu5gIhAMj0QGN0TrWzJ8Waj+eefvnznP6dUcUl8OiDbDp0Fz2l\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5442", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5442` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAUpamtw6BegjENKRZMKazoqRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5MzllMjYxLTE2MzItNDVmYy05N2M5LTZlMWE2YjUzMDAxMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEwMTdlNGItZTRh\nMi00YjA4LWE4NWUtYzAwODZlYWU1ODdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcjACrp+9j72kwqiIDnQSbr9jyTZtqbTSqKa4LKNjlTwvR1vUsNDl5YUydRlE\nTvqJvDUsu4Gvr9IQNweh8bLn76OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8BK/iPf89OPnoVyVm/8I7QLOSWkwHwYDVR0j\nBBgwFoAUTXX/drjtl5sv09O5oyskYnWz1Z0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAn6bD\n4bAYA5n1ORXFa9F51rBC+HKwyKUR/P/ZSGIC5K0CIFSWXx4kWDm7rGdnSgLWZ8pS\n5swcjee+/Slrteszx3Qi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATcX+qyed3ohpWev7367GtSWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTM5ZTI2MS0xNjMyLTQ1ZmMtOTdjOS02ZTFhNmI1MzAwMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwv82l9vU/djt0/JCpPAW9f+jwHFHKskzZznJSyYS3HMIz\nrs8upT6RTwXAIqKtSDZtDFsNvOjU4RNsa18hdSdVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTXX/drjtl5sv09O5oyskYnWz\n1Z0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfBXnlwPvixRbmIYPo40b3q+U8mxVE8R5hAJ9xzPWWdoCIApObdjbc85H\nkqsMEcSTAGDUCUfXTFp2lLx38u79izh9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAX3dNT19VZ8fS8Tz1MOMRv7AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEwMTdlNGItZTRhMi00YjA4LWE4NWUtYzAwODZlYWU1ODdhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQwNDhiNDJh\nLTc1MmMtNDZiZC1iYWJkLTQyZjVhMzIwYmFlNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO1CtAAeVKh0DVzEdibkn6ETcJJ0UYiwoacur5kEZC7cRw/Rp56vGXZ9\nBQNElphh0kqNKoE6vMIH/z/PNL4/Y9ujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPASv4j3\n/PTj56FclZv/CO0CzklpMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIEyBdOWCjrzUmkTn3kZK2Yt1fwyR3Pk6CaqgYFat\nlMTwAiAaxA74FxsVXrMkSC3kcM4j4WrdnGHiwq0MEMOPRAsSmg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5443", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5443` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAaV6XBwGexLn5TfetZZ5J+RvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiZmY3Mzk3LTNkN2MtNDRiZS1iZWIzLWMzYmJmZWJhYWI4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjYwODRjNDQtYmUw\nYi00NDQ5LTk5NTMtZjdmOThjNmEwYzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEURbJQZSlOXjUw4DqwPw3rbH7ALJXqJmFozP4Q98vwk576iOFjyvrxdo0S3iH\nmjbi5PDb7OpbTrgYHSzq+uXJp6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKe9GMU6yKW3rzJ4C1bgz4mlCDNyMB8GA1UdIwQY\nMBaAFMplQZVijANeKK9DHd3jED8gHv4WMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAKzf+j57Qop+VrcONAFbJg9W0hDfYZpELB\noix7jh/OVAIgSukSLqaNOaqNnCVmcvE7J47WRHezZYvIqxspiG275bs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWIGgMWQ8lSzZ56uHhqGNRHvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmZmNzM5Ny0zZDdjLTQ0YmUtYmViMy1jM2JiZmViYWFiOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgYpuU7zHVSx471pGhii36a4ltEnfECwnTlQ3xk8b9KTYW\n0vje2qO8svJAv1T4DFLwAcDkykvwlSYj9dWbFUQdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUymVBlWKMA14or0Md3eMQPyAe\n/hYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMC9q2wXzwv5WztfGv5PEQsDmtI9ePnHxzXiN/fGuykICIDMQmd9xeHuz\nQIDcgn6x6cgT0DZeE9QeoGTQcyxh9Og6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISATFvH/iB60NBA7L35RU3if/sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjYwODRjNDQtYmUwYi00NDQ5LTk5NTMtZjdmOThjNmEwYzAwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVhMTM3Y2Uz\nLTI3NjUtNGMwNS05MmU1LTg4ZDg4N2YxNDhiNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCxkjvARZHJ3ICWd49P5Q9/MqiiItlJOwlkTjGphMP1RIt8Q2dZ9tbrd\nC10BBXGKKWb4Z4sRjMxPWsgXB1PtkRWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKe9GMU6\nyKW3rzJ4C1bgz4mlCDNyMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDQfOh9/c/fKHcRzcriWpuuJPfOMCXubHV4yHUi\nASe77gIhANcxCQrAN/mqxlmOKVE5EyGklByUd4UPY+GQwZRFoxRF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5444", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5444` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAa8qusysgDm2obo646iZVFq8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3YjJmMGEzLTllMjgtNDE4Ni05MDVjLTQ3MzliN2ZiOWRiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE3ODA5OWEtZGI4\nMi00YjIwLWE1ZDItMDBhMmJlMGRjM2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqSWy8RcvjI8+ychKAqh75XpmKlceKv7EiPrSf9ocXM1EOeUL7PbQRyz4b1ov\nJzkW2UswwgCIzeHUhxL/UL1Jc6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUijLKrA20pfYr9UkCySb7U7jdeWMwHwYDVR0j\nBBgwFoAU6eX3vLLxWaOZz1fTsNkNe3y4sSUwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgShlQUyUDrpKG\nKVnsTJOA0mwRp5uj4ccq5SZnPtpRW30CIQDvrzuXuVN/ei6jB02uQgjlDCIDUS7a\n9rHGQxmxn20MSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASt+A1agXZRZJNM/1pxK0w1yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2IyZjBhMy05ZTI4LTQxODYtOTA1Yy00NzM5YjdmYjlkYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQyQVZKrfmZyVKOV92vnycukI4OJyF23Fb068JJhc0ZEPQ\n2sYdpwMawW3cHpg53yyPQpRXQ5wFl1/RnPNGEy1Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6eX3vLLxWaOZz1fTsNkNe3y4\nsSUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOxtxQxxuvFiMGbvLQXX6mLI51gffNsuIJR+sCe5LApsCIB+Iahf2gC7w\nx4oZH2V/b2ESJZMMUc3mhPWsB/NIbBDa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAeeGKRItIh5b2B6zGXbs/3v+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE3ODA5OWEtZGI4Mi00YjIwLWE1ZDItMDBhMmJlMGRjM2E5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYzMjQ0Yzk5\nLTkzOTMtNDgwZS05NTdmLTkyNmFjZmQwMmQ5YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF3/7Db20ZcJo8zRxmiRGmASapx0U3OfQ12sAhUKTT5tgAJOTPTQdVjQ\ny2cAgsa3s7IaCoH5JRaadiDvzXwDQ/KjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIoyyqwN\ntKX2K/VJAskm+1O43XljMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIG7F73KpINbCnS9J25QACVFeGsPmW4K53putEo6i\n99v+AiBda7ymx5w/xJy1T1hs50KXAvO+t0M37kC0s0/JhkIJ9w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5445", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5445` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAWk9CEOBhpWlkNAzHilOA6FwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YTUzNzJjLTk4MGQtNGM4OS04YWVhLThkZDEyNTk4MDc3NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDkzMjU5MzQtNWQy\nMi00OWVlLWJlOTMtNTBjZjhmOTQ0MTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsWNL/0Jqtf+Yikn7MGDl382RCIDZkNQxUR1zP/4CVOchv97ZD1WfQGHko5XP\nj9yKgH17DrMZ9hl76qiIFtRbsqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxwMUXfHNxJX3SCHCuA5UsZzjaUQwHwYDVR0j\nBBgwFoAUpvOBt+upSG0tX2y19aPUs3ofwlAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgNKTEuuaMphl0\nWFv9z/6+TpPD4Hp1ROw3n9AMg/CoUL0CIHSO/iLGh7aiZFHJf9LSr2Mwhg96Qcoi\ndbMikAuMw+Y5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAegdFO6fWieZT6XT6gVL94/DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWE1MzcyYy05ODBkLTRjODktOGFlYS04ZGQxMjU5ODA3NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATX1xw8DOkV0Q4ov80LcM/BqduF0A7x9w3VBWZpqc4YqprP\nj666wP2h1GBv6GJNWE8XFwuDTaZRy2RqQ0qtADPko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpvOBt+upSG0tX2y19aPUs3of\nwlAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPxz8zL+hGDrhr5+j7Rd3BWBVi1zeRHdtqwzmW2DJ+oRAiBku6ncEJjF\n3q0ieSdDCrEN+MN8aWR3Tp8gxzpSP7QvNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAdnp5clDVXKi/DHiNo/OXXopMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDkzMjU5MzQtNWQyMi00OWVlLWJlOTMtNTBjZjhmOTQ0MTExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBlNjFkZTI4\nLTEyMTQtNDRjZS1hODVhLTE3MzJjZTExNTNlOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMf0cQ6bViavvi5U9coyDFLl8bsCr3hILZxzUTK3EutjObPuK+/noZBf\nBVxe0olrrbsqxn55FOxwm+NfvB3zDk+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMcDFF3x\nzcSV90ghwrgOVLGc42lEMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCICXeQa26YDVXpesDuKd+/GFoIARgKcmJoICriPU9\n79C2AiB7Di3shh3QXoZw9jk896XU1DaHR87aUyvPNiL+vngGFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5446", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5446` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAUcYdOmpHJgm2PL3KaJdrDruMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZGJkOWI2LThiZDItNDFlNS05MDUyLThlMGNkNjVjMzJhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZmYjNhOWMtZDhj\nMi00NzljLTliOTctOWFlOTgwOTViYWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZCf7yZvjFFRrt6g1Lb6S4fpN29I/VX6Hjy8BQxAoOoPzwluukVkX1uO224sA\nLUv8BEb50jjFFW28U4EOwDcY9qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUelcDZEd4ZV4LEulWrqL9Z1FufVIwHwYDVR0j\nBBgwFoAUuzE93ny6bsamjKqXzMI+1BI1k9IwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFzRuNwkfJOE\nffVxLilk85q8+a796zPtmYK/g364xwH3AiAc72TInPsyG879XiRBSRVXXvZKK5K9\nYY5pasLowkzKxg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY0HrovtInR78Jto5316fNOjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGRiZDliNi04YmQyLTQxZTUtOTA1Mi04ZTBjZDY1YzMyYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9sZE+qQArWSJIidli7hMDdIIY91d6YWMstUXjv8Bj2cfc\nSPIGgxGxkZySnrRXvYUbKWwdNswEtB746cCmeXRdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuzE93ny6bsamjKqXzMI+1BI1\nk9IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdPup0d14BJ/7kx8UC0chZ4UVJ1cW2XXiyn1bL4lZSnMCIQCLp5eqfnP8\ncN1mGHKqDkOn12fOWVr3czBkjEVVh4U76Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAUt/hSGJay+TG5OgaCQQTLGVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZmYjNhOWMtZDhjMi00NzljLTliOTctOWFlOTgwOTViYWIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJkOTJjZTk4\nLTlkZTItNDU5MS04ODVhLWEyNDU3OGNkYTNhOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG1SEm4x7fgiKJaM/12Ny7FXMD9V8KPm9zTaYN+tmGiBYYlQ5IRxpp+y\nM0QPTwF30YE80t7sfYugkExMU4hhfiujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHpXA2RH\neGVeCxLpVq6i/WdRbn1SMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDqNqYtRnR++UITJEAzICsLEUavAsDD02CLeyJF\naSi63AIhAPdBHgpulHNTPB3Uwj+Rx5R6iON00hPrHPGRE5xgmoQt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5447", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5447` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYiM5HX6SxlK7DMQPDMRL/CMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxN2ZhMTcwLTY3OWEtNGZjNC04MjVkLTJjMGVjMjgzZWIzMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUyZDhhOTUtNWE4\nYi00ZWEzLTg0NzgtYjE1Y2E3ZjUzZGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7JP1Ggvkw3OWElaOlo46SOb+8pDjiXqpctnXQSGrclo+5/xFhKGiyV4R0rXL\nomtb7ZclbXpGvh9asRCEOMtsKaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBALTtt4y7i+mTGbEXPyP8/YqgwUwHwYDVR0j\nBBgwFoAUt4E6GQlMYLvJgVVnzLgF+rNYEFwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDTDUQM1a5XQqddJUdEoVo9gVMkfwjAhhp1yy5Vjs7drAiAdM1Kedz3VvLa2\nN/39QWaXX1ze1CkQTPZxaygK/Ls2YA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaGGNd8yHaBAVt+ygcYv6wTYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTdmYTE3MC02NzlhLTRmYzQtODI1ZC0yYzBlYzI4M2ViMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQstkFAxn8GfyQrJ1YD7/R7b9aBvU4FdchIUZg6fLIoTMLR\nDV9oBvooAKlgXl5Lct4NUt4Ba41gJL3SeaFrkK/wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt4E6GQlMYLvJgVVnzLgF+rNY\nEFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANjlPWMCw0owvJhBs50ui2yEe7Nhin2gCl6uB+rTJX38AiBQsehraFNZ\nyh9ixHsI9sRSRGAYO3YN83I6Cf/9opj0zw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAYv0gHG5we8J9CYlZ3zQKqlfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUyZDhhOTUtNWE4Yi00ZWEzLTg0NzgtYjE1Y2E3ZjUzZGUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgyOWMxZjgz\nLTQ5MmUtNDIyMC05YzI0LTJjZDcwODE3NjZkMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHbsG0yGVXcdz7bu3UYoQc56pYAW1yGMaWrsmiu7gHLz5fU0Stto1khR\nLGSqb2ubVrpTNZRnmhWI1Y99iU1xvkqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAQC07be\nMu4vpkxmxFz8j/P2KoMFMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIHxGTtktmdqJR4OseguYkQRQzgzjtF1NNJ2GAL39\nQTfPAiEA3HYjs1bVOObnqGXxpqAzAEijOjmBpJ8nVTp413HRf4M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5448", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5448` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAc+ShW9PKmbKUmgAxCRV6WAqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZDYwYmNlLTkzZTAtNDg3NS04MDRjLWFiZjFjNDA4ZmY5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJhODA2NTctZmE5\nYy00YmRiLWE3ZTAtOTQ1ZTMyN2JhODBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA3VKzNpCx/HpnmuMxcQO+3awVduibofL7W0C+s/HPCVQaArXNVbx2FX/t/5A\nT21Rp0/5E+DIkZzwt6dEZESVEKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEXS2DEu9onC9iPVi8lvAB2vwSHwwHwYDVR0j\nBBgwFoAURDp9b1L+jz4WhmuPjMHwjD55P+kwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEtMfdFHe91uMfnEq7+IMbDNgcSflvLY7LbG6s3R4XNaAiEA0K+qCKiVjqKe\nUeXoQm2wiP9hIOzB4bWntxFtzXgKiVs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATEOsn4OEVxUIwAmbLu0zAdcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmQ2MGJjZS05M2UwLTQ4NzUtODA0Yy1hYmYxYzQwOGZmOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBf63vZnUvmQFG+DAfUcdhnB7APe5jeZEW7rL/PP/2A65s\nlX0gATgxmYPhYK8v+0FpTIvdKn5QTlkNauaQjpT7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURDp9b1L+jz4WhmuPjMHwjD55\nP+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP7waEzXXWA8MxRPveZOghITRb4EMPQisTPQMlrPEsu0AiBPdPn0hL/0\na6KQuLpHp4nyrQNfIGqOIqjhKSV1pF0PFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAUO/8aCRSsWdXCge179MuxCAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJhODA2NTctZmE5Yy00YmRiLWE3ZTAtOTQ1ZTMyN2JhODBmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY2OWEyYjJh\nLTcwZmMtNDQ4OC04OTQzLWRkOGQ4MmM2YjEyYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJhs0L7efHLJyZJSi9GTVGHHJ8ptUq/Qd3AVpJvgWAw7gkRm8FrwkqfH\n25vTL51gzdJI5W2/rKE9oIWrMd2R3SOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBF0tgxL\nvaJwvYj1YvJbwAdr8Eh8MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCIUqwxTJ4LOGUW59dYU8bAO5QoM0lDmdE0O8q8\nQRufpwIgJ0tjdcJCoyzWklzHDOHoAxzf3/975kJs/0XMfm84Z6Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5449", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5449` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAWKVkcCijEFtUx0WN+sCADy5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjZGUyMDBiLTFjMzgtNGQzMS05ZTMzLTBjMTY0ZTJlNDIyNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQyNjdmMTQtOGQ1\nZS00NTFjLTk3ZTEtZmMzMzFmODRmNzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzTntJvkSLUHC4I98+L7l+RLpCmYC1pPI2Fjv7ysTLQ3f8rUGbl0OHVguahG3\nZwl36D7FRBzl0cX9iYb5NgSvx6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1CQ9fCIkte68HVlQ2F6AIViUsDgwHwYDVR0j\nBBgwFoAULIXk071qLp1L7aBT75a3C6HQ0fowLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDn\nN6AJ3EOABqXVEaMg6v6OFHOORPe/gvxrzsC7Dp1hzgIhAK1rEBpnY+pIh79XV25S\n9HTaClrTWC6I1TFLBw+EQst8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAenFzGuHLKgqrRtVXtft97eUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2RlMjAwYi0xYzM4LTRkMzEtOWUzMy0wYzE2NGUyZTQyMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYYyqMBgsYuKm/NaYJ2zCapnNDO2Tcvu5VwiGKjaogMMDl\nCH713JVWrHxdJVFzNTFbz1YMr4ESnmmtW96znzRgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULIXk071qLp1L7aBT75a3C6HQ\n0fowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMjzxrZ4kI9ulLcHSjOaq7aN64Y8jCT741DcZQLKTEtIAiArxG1qGZt9\ncPGag3wMvD6t8CqvcZ/SG2M8ximiw6arPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAUaNkGfwE0v5E3IpRKGnbtxNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQyNjdmMTQtOGQ1ZS00NTFjLTk3ZTEtZmMzMzFmODRmNzUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZmNDY5MDhk\nLTBlZTAtNDEyMy1hYTM4LWY4Nzc0YWRjN2IxNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG2UnlAG657Ce7jKhk5Agyu4Ney1dEHuxWCQlOq5Es4JoTF9ZusuTHZz\n/gsfPPgEkBvHDDDSWedVFGbjekcBScGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNQkPXwi\nJLXuvB1ZUNhegCFYlLA4MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIH55b2yHGQlm0daM6xRMXlMirB6JHDEyxIp4TUe+\n712ZAiBeA/DnbyR2vEXjyqNlGwniItIG6PUE8crnSNaNr+A50A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5450", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5450` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISASnV1lXsvP7cxGfunsfkHE3/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyZjE2ZjY3LTU1MmQtNDllNS1hMTBkLWFiOWUzMWNkOWQ4ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc4YzMyYzItMGQ3\nZS00YjdiLTkxODAtYzM2YTEwOTU5Y2JhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELxNqt/a7r/0+UtI9zTzwgZ7i9vVYS++OxHvxJNEszytdecPlFhKphSJ0Pp01\n4GmZA6mT7Aakb3ukFJppy2UDC6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHthwqBON6c/UcnfWVA40TJIsZnwwHwYDVR0j\nBBgwFoAUOnIPvqLUuppC2fF13uHEIXA53WEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEc5F7DDCGzM9ZMNLSukBjD/7SzFQPPiYKWni+rsx0AnAiBOk7Tb\nd0f1qnpTAa7NHS2y4MK3N2s/0NTThd4m/Dnu5g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUwVaAXBaLwT4UarA6FyEjoeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmYxNmY2Ny01NTJkLTQ5ZTUtYTEwZC1hYjllMzFjZDlkOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCPwQVAJvdy272MeEbAyipPkr6TF3pvQkvXITBTypUVIXW\nJNxZIQo3dut7uMoPzYoaxnqELFWk2CU3rxCbuAIlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOnIPvqLUuppC2fF13uHEIXA5\n3WEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRdNFyCH6iKSu6mkPT+uYSnmO6BfmVrkMCi97Jx21ED4CIFgc60IjafC6\noPTMjYCWE3MIFQq1oLVwQzEMmsFRQsWs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAVFSVnuvWc0xPNj54h3zE9bnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc4YzMyYzItMGQ3ZS00YjdiLTkxODAtYzM2YTEwOTU5Y2JhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ0YWEwMzA5\nLWJhM2YtNDRmMi05MzIyLTgyNWE4YTU3M2E1MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH79iX/8ZQ5Q14GGG18ieZU7H4HjESC+FRU3CKmmwUQ3F5SoRjM19Z4e\nJNPNcc56YXa4PzTQkrxI3FOdUwwXki6jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB7YcKgT\njenP1HJ31lQONEySLGZ8MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIBINoWEUimWDFsaLiOBcVBzujnF4niTIXdnWwV5N\nUnlcAiEAye8yByxMhhOWfFmaaOoqIhmsWuofuXpEAn12PbAU9C0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5451", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5451` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISASLd9mfZOY0A/COrytILJJqRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmYjE0YjI3LWZlMDItNDNmMS1hNjkwLTZiZWY1NjA3ZGY3ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzYxMjdiNTUtYWVj\nNy00MDg4LWI4NmUtNmMwOTRhNjA4YTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE/PcfSu9unTamivmWZw8l+anM4DKH4hy5AkVkKOPa+ie5eBlgcER6PpSsz/X\n4BDtERCoWWD349J5qKV5kuci06OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQAHNuI1KOfybRnfEvnbFFlDpFPgwHwYDVR0j\nBBgwFoAUcPE1VUuvFcFAPq7zVt4dxKPcbzswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC9ALPh6cDAq2cFCnfmOQ5R6GJzPG5SjZc6HDpaIB9YzwIhAMg3\nt4KNy88fwGpIllDuW5O4aIT9absU5jnmSmneUy2o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXm5UE8d3yg+VMRf9aswp/53MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmIxNGIyNy1mZTAyLTQzZjEtYTY5MC02YmVmNTYwN2RmN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHwkMiFbLJL60GI8oF3jyvB882P40rdfdoe9aA1QcLyPJQ\nA+Mblo0y2RFolC2tmY+uFGrJZ8i4o6CzCwYlGK8Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcPE1VUuvFcFAPq7zVt4dxKPc\nbzswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTQmF9V41WVyElFXMPnikuzOOUDzGU34gkZCdVqIdrPsCIQC+zRWMQOMc\nIdpS9JA6wPr45SmQqFlhLQFtOCsZeFiacA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAdhVEvsZTHc/ccS6j+gUj9ItMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzYxMjdiNTUtYWVjNy00MDg4LWI4NmUtNmMwOTRhNjA4YTQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhhNjg2NzJk\nLTk1YjEtNDY0OC04MTEzLThhMmJkYTMxYzBjOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNinxcyG6xw4aYB9a4XDBtKC42sp1ZOo8BPlnCABclZ9ShcvDyCqbY/f\nRXROxXQie/qdyxAs35gyK/b51wgW9sGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEABzbiN\nSjn8m0Z3xL52xRZQ6RT4MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIH+jUXMZaxgueScuF0eJOPfg7I4sdBWAJvDiqGcB\nUVgfAiBRIcZOJlDqVqTjJQQOFd2aN6/llZJIvw0WLzKsQX+wUA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5452", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5452` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISARkryggCIqX9aJaMEQhKCMntMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkMzMyYmU5LTNhMzItNDJkYS04ZDBiLTkwZWRkNGE2OTQzOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYxM2RhM2QtMTE4\nZS00YmI3LTk2MGYtNjdiY2U0ZjFlYjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvIDjaSEqWi/vivahD2mojEn1gI71qOA2PfDXzhWluVbS7oJbkApsjBY9Va1T\nb6/c1qsMIvz9UHhPwE/55P06naN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJIccwO+wjSrIqOTs9KIC57L1GtbMB8GA1UdIwQY\nMBaAFDcOWzg7exe/EqDGxORM6qN9TxdmMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAqyHX5LEJ9y1+LMLHrlA8uuzerfZHObKes\n1OYod6QDoQIhAIeT8cGSVzKJsXV9GZnXQhQ0/7a3tImBKV7l3oAcqJ1Q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISASkwcEGoeI4ztCkJJYx3BcdKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDMzMmJlOS0zYTMyLTQyZGEtOGQwYi05MGVkZDRhNjk0MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREelNjIKn705sj5bEf8jj9uGoh3NxlUQBt3fjIMIM5FwFA\nVHEUmoRnISdUq1JEyarSXJv/3FIn6vvh97PwdwUlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNw5bODt7F78SoMbE5Ezqo31P\nF2YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIfdAEkOUDFGiIvql4JFt7WC4cZhzh7JrJbBAHKaQfH4wIgXm2aK5SQb96o\nTPJKgHl92uwR7oAJoRafjb8jbHfyKiA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAVlUeiGmkP/h0qnGF6c3WS5oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYxM2RhM2QtMTE4ZS00YmI3LTk2MGYtNjdiY2U0ZjFlYjhhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY0MzFiNjdk\nLTlhYWEtNGYzNi1iNmY0LTlhNDY2NGRlYjkzOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMYXoGRrj9UZiaRYVKHrbYWa2de7SJpg6wAIUeC3aT6ULQkkykb/0iQ5\nvRYJQzNxJIu89IEOceu8v+VYRhhvLPyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJIccwO+\nwjSrIqOTs9KIC57L1GtbMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIDCIZOhDgBfyAp5201VioXP+glVRKH7u41ZntvjF\nNVFnAiBnQti1Uwzv1JjpQga9LafV8d4Km6tf9HOk1TFG96XxMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5453", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5453` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAYMDpUXEOT36JH45cEi6nvozMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNWNlYTNmLTUwMzEtNGMwNC05ZTNhLTgyZTgyNmU1NzMxYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNlYjZmODctY2Qx\nMy00YjdjLTg1ZjktMTQ1MTBiNjM1YzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpaxL8S2RM5jpK/Luuvq0GpM7BvP7Qk4Ms8XSFGemS1qddT6+Qj1CalkIDdMn\n289IMbr2I8ua+DXIxqV8CpkxU6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF9HMGgmgKLaO7/p+epOf4UHwWKUwHwYDVR0j\nBBgwFoAUKqu31eAiQ89CjxZDw0YvUbhDPkEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAOmvUvF66kLe\n3k35a9amU9nqjNQO/1TPg8eMYRFY9ORfAiEAt+YiRXH8dY6Lr1gW6es8NPherUhB\nW+xLAoZjpBAKe5E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfhMs1caEfPPgZE9aHNT0g4YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTVjZWEzZi01MDMxLTRjMDQtOWUzYS04MmU4MjZlNTczMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKbSURm6ogSYki6xUHOPeWStlkXVlJKTg1HDQKhSj8hpuH\n4dAk9o+G/bazSq3rC1BAyiU4h5B3rKTw5kl8omgdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKqu31eAiQ89CjxZDw0YvUbhD\nPkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMFkkfj5Fudl4RBzT/f2ApwkXanLWe2RpVuxl1wY5NCGAiEAqvgWa9Ev\nt0/Fu3L/FTxj+tUR0ngTb7L0kvQOxVK8qdc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAdpixVTKF0Rlks+R8LAm/mxPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNlYjZmODctY2QxMy00YjdjLTg1ZjktMTQ1MTBiNjM1YzkwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDliNGI2MWYw\nLTk0NWYtNGQ0OC1iN2ZmLWI4ZDE5OWFkNDUzYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKFcLre2Xjr+6Kol+yNpV1UOYdwGtbC+p5HVoAlpsc4YUWiJd9xBX6cW\n5ffxQz9heIrZPHoXmI2eQkpoJzF9dxWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBfRzBoJ\noCi2ju/6fnqTn+FB8FilMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQC8oO37iFW7/OrfPKRUJond26J3O/cktduOpQJp\n4Ox1ZwIhAM3V/aSIhlvFYwiXc9Iy3FwB4fi3N4cNi+vus3x2zEQJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5454", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5454` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAWVYSmgBM2lfG5OlNsvL0n9XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyODlmZDg3LTZjODMtNDBiMC04ZTNlLTlhMDI4MTEyNjE0OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk1YzE4NzktMGUx\nOC00NjRmLTlkNTMtYWUxOGUxMjMyYmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC9SnURWofX6XImhnnBZvqboOjPuUEReuEnfbtqfSymr+IZZjeGNlyIYx1xsp\nIuYG8HmgL+CPsqFGZ4B8xr2vZqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzq4RjChMP8nUEtyaUwqEiR5yruowHwYDVR0j\nBBgwFoAU/i59gySqhMNsNvJ0LdpJWdn7I9AwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMfT4MFrbBRA\noX8ORTX+D7NDJ1/aOnOJu6u+RuqPZADyAiEA437QGHasdfnxnWDinYHKKMd4nqgB\nIWK+OtmVbsjIxO8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUjIppQysjeSk4FhbwDkM9k7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjg5ZmQ4Ny02YzgzLTQwYjAtOGUzZS05YTAyODExMjYxNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4BaHlJF2Oc28HJRQeVfLCzZuurEAQ1ZVZWDbrePWibSdD\nLhRbm1eMhUbE4ljDQx2vSgUrVOn0IM0gqUR4/Xtso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/i59gySqhMNsNvJ0LdpJWdn7\nI9AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMiZc5m6LbW3AP1/bFIFz0yqYhLu57ly/liSC0iXFLNkAiEAnWTGTiRu\nyeh2PzdEr6DWE3UVXXQeuh6q0Dtk78AT7Gk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdXLCDi9/XepXNKpflbXSXCLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk1YzE4NzktMGUxOC00NjRmLTlkNTMtYWUxOGUxMjMyYmIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRlNDcxZTVj\nLTU2OTYtNGY4Yy04YzZiLWU1Yzg4YWM2OGRmZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMB5zHLT+2LUJbHIlxhNjHGN5t2SRgo/+iURiEVVln8gV6r8Q69x3D5d\nvHp3rEjCWX3pszxBXX9KcCqR+1RlaDSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM6uEYwo\nTD/J1BLcmlMKhIkecq7qMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIBj1zP5LSLM/PeWVSgZ4CcamrZvmeeA0WbDR825Z\ncTlZAiEArEpVlfQTYkcYFGAXwcI0ivAf1FEP0/CQ/aPg77pWxq8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5455", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5455` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISASu0QGCppey8bUsiinugdxQWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhMTQ4MzhlLWE2MmUtNGMwOS04MTdiLTExMzE2Njg4ZWU1NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI3N2MyNjgtZjgz\nNC00YTFhLThlYjItZGYwOTk5N2Q2NWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwTr9zKCVh0dyheX175K2YuCVB9hhaDsOB5HhyvyAYO1r3R2+1TCbbBFQ+qBN\nbWV9MhLs4MmMU5AKDoiN5Vdb8KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg7bJpgUz+CRixjlG15E0Anxbx7gwHwYDVR0j\nBBgwFoAUcWP5+M/7BQtwNuHk9rrd1nMhtOMwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIF/5eLAiThQw\noSRSwHKayI6lj9/ilnsS7siL4T1v01cEAiA46oXafzdY0sPnX+7TyLCtQU2hellb\nTAKaGDT7qEEjyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR9jb3C+0dreFE9P/vAwduSzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTE0ODM4ZS1hNjJlLTRjMDktODE3Yi0xMTMxNjY4OGVlNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOX/qX4QWoFjtejgnwE0tpdsLeM/04ludKKfOJvTXfgHFr\naEiS3+ndPyZJK6Sb2rbHV7KJ5pQG5DHU6rbI/15Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcWP5+M/7BQtwNuHk9rrd1nMh\ntOMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK73qH6KLjVtvZ1xzYx1Z6XheNk51rCsa32oCgcbQMAmAiEAlOKu/V0X\nFjHsKxjlVFtyhX/ZSIPVxxIQs1RS9DrGSyY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXZP8A/yGmkU/4z4OspRyav3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI3N2MyNjgtZjgzNC00YTFhLThlYjItZGYwOTk5N2Q2NWY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3M2Y5ZGNi\nLWI1YWMtNDMxOC1iOTE4LWRiNDUxZDU2ZDYzYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHqRByB8kSDJrjr72MfYN0pQh80hRdBkxyJZxz68OZtyFgHpNCESEhOk\njAnkdmRAh69tpC4F0ZghT2cAxKrqjgmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIO2yaYF\nM/gkYsY5RteRNAJ8W8e4MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIEUR9hQQ/zNSUgXUZCcjV1dXmQPTiwuvwQ9PGp4w\nUDvVAiEAl7jbfgRst65iaHxolrr/RPka6Bu9ETTv9YQIhVnRJFw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5456", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5456` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdEed11yJn5XvP4OvoquzlmZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5OTM0YWVhLTU3MTEtNGUxYy04NmRiLTNkM2E1NTQwZTFlNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk0OWNiMjEtMTNj\nOC00OTI2LTgwYzYtMGUyOGFmNjQzMTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFbDh78zSCMfEUyCNkgXpmN9ydnjGcS14XMbGRBLEdqiMGaxJcuSg7JUDd6L6\nNLpbUyvoRiDdkMahCMZf23K3DKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUczxEwnbhWcpXoYoo1drccWAowu0wHwYDVR0j\nBBgwFoAUZRtJQxQ8KmlnFgPP1PUJZ27AR6YwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFi0eF4cIQkh6eavETu8nHbC19qIROIBCUydBXjUnkZQAiEAxCMFaziPN6IM\nfZHOEK0w6dxKNPLybt6PsQZ92L8Fo4o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUCGLGICbRX+Ek0OSKh0jBfpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTkzNGFlYS01NzExLTRlMWMtODZkYi0zZDNhNTU0MGUxZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATftYPBHDjr0CDktpuqLvGnhXEKD6Vt+tpIYpd64FR1d/t0\nbPOss4dbiDIvP8ZZk0JMiHuY3oY9g9Io58QNv+pyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZRtJQxQ8KmlnFgPP1PUJZ27A\nR6YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWgKuCxM9xrW8FJ5O2RHBIiD/jqPE4h5nrKvzgAJCIX0CIE64VgD5JH1P\nRI8k57U4SNRcXv6sgEylvlabepvQvogG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAZUlronvvd0ogsr4GNK85+f/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk0OWNiMjEtMTNjOC00OTI2LTgwYzYtMGUyOGFmNjQzMTYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYyMjc1Yjdj\nLTE1MTItNGQ3OC05OWY3LTgzNDU3ODdlZTIzZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOW6kOOVAYTHmxtyV+ZcDFrR9OLLo4cOABre07uP7XUzFlopKS8l5pP2\nXg8A70wHCNwCEJd8JsLL7WsmVbvhySujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHM8RMJ2\n4VnKV6GKKNXa3HFgKMLtMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQDQjuqYDmVxgk/JlkdI3x4XUV7HzJA1sVTfNBDN\n74SX+AIgKuETndg7RcDWjXui4yhKUaD/9NGDpRZpAlC7gTW2oBI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5457", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5457` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcdO5tNyuf5V5uT0mH8P11hbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3NWY2Y2Y3LTZkMTgtNGI2MC04YzZjLTZjMzUxN2VjZTlhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzM2MzgxZmItNjRl\nMS00ODI3LWFlOGEtMDNmMDExMTBlZGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6oe54du9umMyf4cgR0CaIvy+TAMIov1jHXUxNr7I78UbPwBNY6eGxKEHvI8e\nLCJrKONM09ttijJkVokRA/RWDKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxYS5/6JRyKc1L1LljH7lE5PknsQwHwYDVR0j\nBBgwFoAU8Ag6ietZxXimX+UBsmoRQ6diJSswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDf/1zCvi0q5gmJKagc+90SBbtJONrZvGjP+anh5foc7QIhANuC9lYL1x5t\niDOYl6sKjDT11g4DBf1wqXRrkitdd20x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ90cLsv965S604tiaHdyj/aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzVmNmNmNy02ZDE4LTRiNjAtOGM2Yy02YzM1MTdlY2U5YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXXlCDKIZa87p1WKDcpLIB3OmXnPyH/DTOCaYPohagC2rI\n2ZaTRiDEljSmjjL41paD9wu2N5XhSgh1Y5MRS4kio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Ag6ietZxXimX+UBsmoRQ6di\nJSswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN+CNl2vCz/Kq46cwRpyg1cLI3K9yl15SzrG73AEFSP5AiA5TtpKNFry\ntNstJoaEae1WsyEi8sy+JbtSipxlpIkT9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAexXPebwFzcYoFrMwWbp7IKoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzM2MzgxZmItNjRlMS00ODI3LWFlOGEtMDNmMDExMTBlZGY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE4OTRhNzFl\nLTVhZmQtNDUzYy1iZjcwLTVlNjljZmUzYjA4YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ3fYWji3JUCMRn7sUU0i7bPmPQOAEjtHQlTSOCt7N4dAkYzwZF48ko9\nW9UonxmSu434OdrRpO86ZSjR42Alm72jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMWEuf+i\nUcinNS9S5Yx+5ROT5J7EMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIAZ4kBaXp+Qzh5qvhpIlBskXwOomAmK9HJTilbxu\nTrfSAiEAuVWsFOsDAg6uThnDxJ16MU75NjG1f2XBXWO1Ub5cIWU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5458", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5458` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAWDqR3rkulqfmqvz+ntQfJrJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1YmIxZDVjLTZkNTEtNDdjMy05NjFjLWYwYjYxYTY4MWQxODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE2MDE0YjctMGVl\nMy00MWNlLTk3MWItNTExYjRlMWJjMjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf8XAYuilZg5VshTkyeIc3DJoTFYL+N53Ewq8DtJbIV4FyxSYy1TJLCtmmula\n6hbRnd5Xs2NsRa1gmRaFxw4WxaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUimJ6FbZNbZQ/PDCSVoJKRc56hvswHwYDVR0j\nBBgwFoAU+iyEqGbL+kezIYlaWTNXzrX3qpkwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCX\nXrpRlFuchAOfpAQ7kxy9hXnlzX0BmT+fW61mMCnXIwIgZO6dh+MWSfyLKW9hmfXU\n+KpiSTtSPgnFbEbouocwFP4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUzzAj2s6Ce7BtiaI/1UVmeSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWJiMWQ1Yy02ZDUxLTQ3YzMtOTYxYy1mMGI2MWE2ODFkMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8fP7T49GrFzWqcJJmEHRT4vD9/JFZFMZifDO/jjcKNYwk\nvx1Dqcnmaz1VjI0r48QkimPH4g0h4bAdb1q0UZlTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+iyEqGbL+kezIYlaWTNXzrX3\nqpkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKVfZQfewbahhH3Jw72OvYnWANOEA/33y+KTRTHVXICMAiEA40LMd1mE\nUG6OHh36RpuUoCC9WAkkHSa3SwqDalVfBzA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAZnh7kw47tjMpI43afF5Gka7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE2MDE0YjctMGVlMy00MWNlLTk3MWItNTExYjRlMWJjMjRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNjNDEzNWFj\nLTVhMmMtNDNmYy04ZTY0LTdjMzRkYmZhYzI1NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ6wGocejD/SwXUbQjtb5Kfuf9QJ3FRsNNi+M8+UIso06380wki0+aZO\nkHYttzEyEwFeK2pmi1rq31pigVN8JCqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIpiehW2\nTW2UPzwwklaCSkXOeob7MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIC2sVXKBAGM5LMmAsz0BlTKH4xDBDr8CevqENXix\nghegAiAnn0Td9lPAs+NT60237sR856gnpm/JiqMazLXG2P3Hlg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5459", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5459` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAVm/DgHHeyZoC4kHSFncwYWbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyMjBkNWM0LTMwNTQtNDRhYi05NmJmLTAxOWVjYTJkMjMzOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTJkMzYyYmEtYmIx\nMi00ZmQzLTlmNTktZjNkMGFjNmE3ZjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB8eMk7Z7bEAq7E7QDfNniv1dOtsL8/fD3UMza+TNTCfOBrti+bRCKDTOytZo\ng4l/AhNvgz7ePjVCON0Xuuxt1qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN6X4LwbCjZnMRKv5lszQicgAP98wHwYDVR0j\nBBgwFoAUeaz6y0ue6c1m2Ng4P3Ydgux06YQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDsY4zKLIwupkbbtszrJanopkIwAVssaCevbOyZs9R03QIhAOCe\n5nwwWtUmSTG/ThJnmiwH4l2lzvgxa7f7hk4RSFdn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfniI48WbwY4D+40UHq8Y+EHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjIwZDVjNC0zMDU0LTQ0YWItOTZiZi0wMTllY2EyZDIzMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfbE2kyW/cuYw1JCXAl/hzsGVOg/TAQF3vXPX30WBKpwHq\n/GBVXRfeA3VvMuDapuXIQi75mdErqKGYcyhkB0t4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeaz6y0ue6c1m2Ng4P3Ydgux0\n6YQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDX0YvaJB4gTfHoZrlLWwd5GPIctqs5ZwEqFqsrlkqQkCIQD4B6f64F4P\nLjJ2b4/AbxLJZAsIZiKhGXQLIPgRuVEhfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAfhcG3m0GIiaDZ7jn26c2+LDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTJkMzYyYmEtYmIxMi00ZmQzLTlmNTktZjNkMGFjNmE3ZjI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM4YTMwZTVl\nLTdkZGEtNGFhZS1hYTg0LTM1YzQxZGZiZWM0NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFzXivoejTK8cL6S+cQwBDTmYfBVjxzqmavGhN8HC0DDIkdck2SC8jpu\n/0HHeeL+ali6JEc9w6FJ0TWntkod+vujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDel+C8G\nwo2ZzESr+ZbM0InIAD/fMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCID0ZtTcLUd6lKUK+NYSAPTMDkeA+FhbRQ0/P/Opu\nqeIbAiAFWQheJlkbyqVeu1zMbsjQgYmOfzanmpZxVCHZ7j25YA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5460", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5460` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAfpmdldKK2Q+RJKUvEvA6AhtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NDU1NDEwLWFjZWItNDVlNy1hYjZlLTVkZDk5N2Q3YzU0NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA4ZmRjOGUtM2M4\nOS00MzYwLWExYWUtM2I5YmUwOGIwMDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvelsE5Adx7rgp88Cah/2OzLtXBgnb9xmcB9yaw2o95ph1qkkvWrqecl4FjIB\n21AswZ72NW3vAfQpbZbKQekYaqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYdcEfJIux12OkDU8Tud0guW6ZNEwHwYDVR0j\nBBgwFoAUEJdBQbtV/ygETUda7t8MRUfLSM4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCwru1qMdYeDTWW36LGqg8E0bctjKnZ5brY7cNAtiWw1AIgDmK+\nXtMxEHdgt6dbn7Zchg0txX0iaJvnDXuXcYNSnPY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaYPCWv+6Lzo+f7sOys4MXJQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODQ1NTQxMC1hY2ViLTQ1ZTctYWI2ZS01ZGQ5OTdkN2M1NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASb8aZDOxd6OYWQrpG0v3bj1Cu6LdFe/7L+Jy1gfIJIn89+\nb7vptTYRyXvrQ/poXw92tl1B4kqrQzLz7ulCjRP6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEJdBQbtV/ygETUda7t8MRUfL\nSM4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN51AsehGpHd+l1SXEOicvA58s4XvcB70QyVnti1Hn/QAiAOUel9qaq0\nac0p55fRWwL/dSEknEb5Iqj0GA7vwCbIWA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdigAwIBAgISAfLRReWOD0zvdGY1dS13vhznMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA4ZmRjOGUtM2M4OS00MzYwLWExYWUtM2I5YmUwOGIwMDcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI3MmU3OWVj\nLTI0MWUtNDhmZi1iMjQ4LTJiMjVlZDU0Nzc5OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKnUIJfITlL/JW6yywl0xhhOQPN56wkC6sJUCclMribsAStoYNA8TnXU\n8b0L6ANbeo5t3wGj8GVgwlWeSvaMFM2jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGHXBHyS\nLsddjpA1PE7ndILlumTRMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0YAMEMCIAmQm+er1s5gJBRyXZ/KuD6FOpfnAQIQATKZJrfI\nBV6hAh9MgE727muiXMpIIPOFY9kDHmGOY+8JJGEvtuZdVu4c\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5461", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5461` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAT19x/jWPdSCN2LftgPws9vKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4ODQ0YzFiLWQzMjQtNDBkMS05MDJmLTI5MzliMWM5NTUwOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFjNDRjYWItNDM1\nZS00ZDI1LWExODItMDdjZDFiNmYwOWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuxRDheG2znJbADbWYDWpJ4pkrV9Wpa1UFmWvfZdEzwWvyfqBsv/bmnOTVSKK\ntLDMV6tBBfmV1dbgFUlHKx5KRKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSXa0lTsk1zcEaEMdQFRDRZbuloCTAfBgNVHSME\nGDAWgBQemjc2pawPEM7LY9UEl6dVVGZ22jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCNFpgClWDl1nfclEhjkegBP4vP2ERw\n4d/BwsuUnHQC4QIgbpPuugXiebfisrtmxpU5jKz/PPmCRFiwYzRi+HVFze4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfKPYfzy3WuHTKv3kiQRC9GzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODg0NGMxYi1kMzI0LTQwZDEtOTAyZi0yOTM5YjFjOTU1MDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMN79/6T1LUrvQiNXavfD5T9UcO2yFRDpARwdHiF/5KQjS\nGsTbBRaIENl9oY0d4oB9KfZtFsPJZv4lTPLpheiUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHpo3NqWsDxDOy2PVBJenVVRm\ndtowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIJ5BY9hlnUtNnz9N9t6gdvnYx153CeAMUOGPYVECxOcCIQCP1SHRIWq/\nICanJemDVZ/95J6bRdUGaq+FxYgxLJwxTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISATuQOpkYE6ZzwO6biWgdGpOBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFjNDRjYWItNDM1ZS00ZDI1LWExODItMDdjZDFiNmYwOWRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE3M2Y5NWU5\nLTYyNzEtNGZjNy1hNzlmLWNhZDBmZWRkNmNlOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHe/6CtpSQgn+pQCQ1zz0QbwKmxX05qLjS33aKQfzI1Y4CyzUTqx5zot\nuYXFFIT8AuN7omRw0PYQwLFfEY5h+HKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJdrSVOy\nTXNwRoQx1AVENFlu6WgJMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCpsT6GF6v4YLmffhz6HpAsK+4XT2Krg7epjGdN\nZPLE6gIgfoR8Kh7lJxxxhjKTIw/TJz/4qVQzYyu5cq+tXMQDN0c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5462", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5462` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYK9Te9AQ+fwFXxp33GCO9IYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhZWE5NzJmLTVhYzEtNDhlOC05YTllLWEzM2VjYjRhZmQ3MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRlMTIwNGYtMTA0\nNi00MTZkLTk4OTgtNzlhNDBjMzM5ZDUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0+kHnrTwPg1+FFDQz891pMjtid77Fru/0/vPRw+58Fy6Xewc+/VpVvUPwjAC\n93Sr+0Vzqb1VXfvMvPxUSgg0fKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPuKVMvgZAHy+am7vC3nOtd+TwGkwHwYDVR0j\nBBgwFoAUbWyjo3Q8KQsRqcUULvodKjgsmoMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCon9PzxLZy\nL6McKrH7V3yYkVo/M93NrBL1fxkpU3lklgIgS0BK8/b/OwwOamoqWUsKD1tsBoiY\nNLtdD2G+Zbr/YhI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWHmWbTN4UKAKAi6dFGWPm+TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWVhOTcyZi01YWMxLTQ4ZTgtOWE5ZS1hMzNlY2I0YWZkNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDBsM1JJHe2iF+cOhqjX6d5mixJ8R31ATm7fYWbS4Ja1g7\nmhpBUbnK6pVdBCplnemcY8L/uD98m0R0EmGOT7aJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbWyjo3Q8KQsRqcUULvodKjgs\nmoMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaSeis2b5puhv9tRkRfV7bHpCrYlPMkVsTMvOM28UNywCIQC1Doa5z9QL\nTOIJnc9j4pR0tNSOzjNC2ZovKeeKr64wZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAfRUPvYKH/Ex6o8qTg0sc9r1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRlMTIwNGYtMTA0Ni00MTZkLTk4OTgtNzlhNDBjMzM5ZDUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM4NWYzZWJk\nLWY3MTgtNDRhNS05YmJkLTY0YjQ2MGM3ZDY3ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD3Zmk9qMKOOQGyDNRrgrHrRax7A178U/8gcVcp7x0arL4kSu7jggObZ\n4QZnj9kkYHVYJ7zUvfTQBfCEIf9uQxejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD7ilTL4\nGQB8vmpu7wt5zrXfk8BpMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCICJVOnlX+fGXd+Aozs12TDtOx3fYet3GR0hFsW9h\nIH80AiEAjlEHnNp5//P/g7I+GQ4eidZZmDcaVhR14eS23bSb0J0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5463", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5463` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARR+YIHOW//Yd3XEIbfRJNuJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjZGJkNTliLTUwZTUtNDRlNy05MTdiLWQ2M2M1NmI1ZWFjZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMyMzdlMjAtMDBi\nZi00MDZiLWE5ZTgtNzE3NDIyZjBhNTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENvr3zG7S5W7gBjO281ZN8hzdnbgZ9ysdb+ynlfHGqsrZ5tm4PGf7jgmHampj\neqjAkGKoku4402tQNUycsAPqSaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJBr+31GSuEwcPd0qAYPHt0uGNJ8wHwYDVR0j\nBBgwFoAUE9vf6XNEUJ0UYcKEH7bChaOCLXEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIFxKpjY+6LPr\nv1fWjnIAdY0IVXt7UqvSogcGBiQFsMKDAiEAgdJ1Wld8JZGk5xy3R6GwzSu28xMs\noD2LpZSJFSvdhzg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATx3U17lQFQgWX8XRGQaG81/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2RiZDU5Yi01MGU1LTQ0ZTctOTE3Yi1kNjNjNTZiNWVhY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuAEBRb8kfittkgiw0XINowuPsIQm6GcOiSRlPTiSMvLr5\neLgu7ptFjtMUQM9JGPHDFhqY/L6Lx/7bPHb9Gp9Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE9vf6XNEUJ0UYcKEH7bChaOC\nLXEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOlRnx8DgaQ1/bWiZfyOL840iZu04j2Cxpoe0BOJfkXzAiA2TQimFye5\np5fw8NkS+9LSh+sL3QxzlgVQFQ45KBoM6g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXnIS1ru9bbIfTZo8iVAsDNNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMyMzdlMjAtMDBiZi00MDZiLWE5ZTgtNzE3NDIyZjBhNTZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRiNGZkNWJj\nLWNlYjItNGEwNS04MzdkLTAxOTA0ODU4NDllZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHesV8QHzNXqzywrhswav+PJC0x/nKivCGvp/e4OSiJJcTD+hrp1SthE\n2lEf7rXbbaEMMVhuZnplbR0KhK5ETM2jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCQa/t9R\nkrhMHD3dKgGDx7dLhjSfMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQDTfwwiPSJs0KAHIBOzjGxHLDDXuzByJ31I3eDY\nVKtn8wIgfCeVI8OwSJ52dCEbizFbOjt1jEEQlZSRsQepp2Qvg70=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5464", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5464` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAfOmlhRmavOXGngTd365nIyIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3NDYxMDMzLTVmZGUtNGViZi1hMWYxLWVhODU0NGNjZGY3ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQxNzFkNDAtODZk\nYy00Nzk5LThkNmQtMDA3ZWQ5ODRiMDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErhKVEfylxNp2QVUA/Vn4yrQVylPhV3AiP755Ut3vJIxWVHF4giCEatYPdwVC\n+RDyR7s8/lnMfVQ3yxmXTIsed6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFThU8OfWraueWSXXRjJ6rDxtkCUwHwYDVR0j\nBBgwFoAU8fsOmuppGIaUNBAY6ULczY5hPMgwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiA7FfwHNfgm\n6ez5vDqS/9qUqOh++YbYLWlIh4pnNJhQdwIhAK+838Nc/TR7OymTe71aBA6UYQBP\nkZF3BteoBwcLFIF0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXj5n8cj7NcMPko+bmZ2I3VmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzQ2MTAzMy01ZmRlLTRlYmYtYTFmMS1lYTg1NDRjY2RmN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARje8AeHU5zHrHzlTDbTS1sP8cDJIUy6mw4hZbTWVgiapQa\npV5mVaWC4dc1yVnLBvddstcBEYzPu3pChgd8aAXgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8fsOmuppGIaUNBAY6ULczY5h\nPMgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALkTP2gTHOjiIdLUsgrArwEMhiPzkOCXwJygc2f8cFcZAiEAtAwQfrAz\naOfknde/OiNI4n+Cuefgg2s6z07ou37gvLg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAQYiyU+CpyZZwj5yKwaDwyASMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQxNzFkNDAtODZkYy00Nzk5LThkNmQtMDA3ZWQ5ODRiMDg2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNhODVhNWQ1\nLTMyMjUtNGNjMy04MmM3LWIxMWY4OWNhMTZjYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMpp/BowwY5EZ8JqpqNUpWbqtBW/r4yoaaVW4LZ+YttxiTwcD3t3U/1F\nPd7MpR6ddMEN9brtuHQ3BBEFstgEOsCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBU4VPDn\n1q2rnlkl10Yyeqw8bZAlMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDjjwwxNxEKkpQifYnQEIpVGapGV9gaHtkaAqD1\nojESYQIhAOmdfkFhDScOuVdEZgP98DKj+GTEZfYILDyAMqWIG4+A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5465", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5465` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZY1/zOnPz3MQWtGsQI2UN3EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkMTM1Njc5LTAwMDAtNGZhMC1hMTNhLTkyYjk3NTAyZTdmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTEwZGVkOTYtNDJi\nZi00MzRhLWFmMWItY2NhZjJlMDg5YmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl+dRFT/a3dIQil0zkhKbAhuWkNd3SyURFi5J6rTFzI1okDsuX8eS3Kd05VNI\nSU+iIJJDNoCfvjDBtC10rEVP6KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY0tjWsnONN9i3W0MRwOgkaZxkTowHwYDVR0j\nBBgwFoAUeEgA0E6yRFpzCx+HcyO3x3DwqA4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiBGnr5iD9eD/5z7/x7m70PB5fcK2dqxZrKIjBEodJuGlgIgSqPYN0WU7K4g\n8yTD7ClO/pvr3rFDnNSeeWw8gDE+aNs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVMCLQzNG3mAJ0VCvvbWXYvwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDEzNTY3OS0wMDAwLTRmYTAtYTEzYS05MmI5NzUwMmU3ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASygI09t/RonmnUWSUao2mZK+1F6HM3Ktro3vs3caw9LwRy\nUFjhYG60yywdrOxSMzfwpoT3sKiUXlicXtyuscNWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeEgA0E6yRFpzCx+HcyO3x3Dw\nqA4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgb1rwbhtZdHAFCDs1FJNh3lp2uIecY8ehllUGj+gYQyQCIQDEq6ws8pZf\noQ5mM0T8Yp6/2uWh9O3dNTGoM9Am7HMrrA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISARseqAsUBzOZxh5GFPd0ju1qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTEwZGVkOTYtNDJiZi00MzRhLWFmMWItY2NhZjJlMDg5YmYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE4YjBkNzVj\nLTZiMzYtNGI5MS1iNzdkLTQxNzA5ZjY3MzMzNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLejJS2JQie/1ABAgPn/jtpicoC/OQmE/QKHuPor0Tvq3mAVGGHECgsW\nzuPnqEkiCVhoUo3txaPaTset5FuMIzqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGNLY1rJ\nzjTfYt1tDEcDoJGmcZE6MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCO/juAeJpQH9LuWpSN3/6GgnMWug3wwZj+BHiH\nFCeQHQIhAOoLGNK1KobnXZ33TiCQFARgmOxQTDOGg5fdfiZLJPpf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5466", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5466` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAR5AGtJqMr0Mdz5r8ppC7C18MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMjRiNmJmLTQwNTktNDIyZC04ODJiLTRhYWYyN2ViMmZjMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ2YzIwZjQtZjYz\nOC00MzE5LTlkMDMtMTc3MjgxMTk5MTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUCjzFU8retc8wUAIshWVCZavsQ1BwHZt+0mid3IWZFZcgOE3OFDjI6Fm5yJ3\nEYcRe4PJceHR5bzZ5D+C4eZbuqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Rpvd+ydo3lcdQwkl1bBREbJIj4wHwYDVR0j\nBBgwFoAUV19fg3jnkf4bGmhW2zydqW0a7HYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEApwaoHV0maD0jpEC0IY0fxmxPAPCz5VNbJnUkUN48jqQCICMVouTIOyGn\nwxXRJtrvRinLTXewDriI10duA2TyyrcD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe5JnJo5bjmpU6zLCIw7EHW5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDI0YjZiZi00MDU5LTQyMmQtODgyYi00YWFmMjdlYjJmYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgH7t+Qpdrh5+7BKOnPxgyYwVbb6t+KqEwffu04kEoLJ2H\nTb8lQPVT3e9nWxKtGVauphLTtatX2hZo3YTDBwlUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV19fg3jnkf4bGmhW2zydqW0a\n7HYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKqqT+2/suYDRDmoskSgbIK6uWhvhrEjxTQVWJPGtBo8CICTaoTh5tFuC\nJkjdaqD+GJCtbmG7DR2lDXaZP/8tgYc3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAS/KyVHfkLze0sLK1SscXAKkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ2YzIwZjQtZjYzOC00MzE5LTlkMDMtMTc3MjgxMTk5MTQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4OWRmNDIx\nLTAwZjQtNGM3Ni1iNDhjLTIxZDJmMjQ2NjFmZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAmw0cErn+wxkplO8K2+ZGW6SlKYHooFGSwx+fdbhiO+eolRf/IC1DM4\nOffeAtnGsoKpBisc1xytIe8yEyUCwJGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOkab3fs\nnaN5XHUMJJdWwURGySI+MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQDOLLtrXa6qLAid0tpOYLyrya7/Ty0TrW/p/2Yg\n3iNaiQIgJHqYJMl1CxAP51SY+FXUrIwmkM8xY8Oz7dJYVRtqTAU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5467", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5467` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAa9ivSiMJxRabfF5kv93BLvTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzMDJkNWY5LWQzOWMtNDM1NS1hMzNkLWE3MTRjYWI3MDkwZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDIwOGM0NDItYTZm\nZS00MDEwLWJjNjgtZTgzODBjZTE0NzRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf2gQ9k/sbr6tZSgyiBBSiF8rI+fIys5dnBZHxh+xR7Ho3phikOGEY84idz/p\n51xe0g7aO1XcHWF7k5koEfoJh6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsHCVkB+LhCPO6qHgrbSMi2TM+q0wHwYDVR0j\nBBgwFoAUfiOzMvWdn6GecjjM9FX0tlu4LL0wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiA2\n9qE+ltoWyqnWGHoMepHC/LYYbrLuKC1JxpPzJ4ftSQIhAK+kgI008IMe7XAhhQnS\naJijNU4iEYI4tqUqFx2Iigwh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAahGuq4LbVI89eoqvG5835yIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzAyZDVmOS1kMzljLTQzNTUtYTMzZC1hNzE0Y2FiNzA5MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS48hBgMK6DuyShXffmupNepkUZGzgz+jCcmTDPRsGtUx4P\ncwvjIYen9ifWljAf5FxQSJXkuMgsAOXX4lQdvJFNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfiOzMvWdn6GecjjM9FX0tlu4\nLL0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfXCc7nrCYukS4+m8BECUUBo9bBO8952d3q8Sy54+Cg8CIQD0sXL57j/s\nmuB0QUpi9yIB12ijjsaX18U/Agj9kyo22g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAeXYSWO6Fw+igxQYfCboUaixMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDIwOGM0NDItYTZmZS00MDEwLWJjNjgtZTgzODBjZTE0NzRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAxNWU4MzJk\nLWNkNTYtNDBmMS05OTQ2LTNlNmY1MTA2ODg3NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOwFI+etzv9JC4fQFNrq+TBxfnyIaWdHGnvCvcRW4kTzj1peHqkjBeON\nj/NKZTMvS+gCzfKEGe4sgAgzwzwnyrOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLBwlZAf\ni4Qjzuqh4K20jItkzPqtMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCID1+byP/4c/1cPONEd5pd2po0iv4QLzjeKMBKUMk\nkCv1AiEAtiwy4M/ikXIJ3+aF2J/zrkj0F3IeBHewpa4aIDvqiqI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5468", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5468` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASDOsLxfHduHsfMKqAj0ZcQ6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5MmVmYzQ0LWEwYzItNDY2MS1iNDFlLWMwMzI3N2M5MTY5OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJlZjYyOTYtZWI4\nZi00MWQ3LTk4ZjAtOTE0YzgyOTA2NGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5tJqiClow/ji3P76v7Cfho5lvJ3HlF9DCxcQrJbWTFgZ+mlMc87qm6b9j0vy\nFLGTgGkyMZ73fxKlDJyfqzzBwKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUptCJJ3R4ccw1vMDw67MQ3xzfh50wHwYDVR0j\nBBgwFoAU1WdW2FLrd+/8EAc3lMKH52bi4C0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAwSQBiv63nBtEwOuVtgMFhCAc3BAgw8yQSiixKyKGyNkCICRD\nCWDJNgJdpTtW8QpFBDXY0Oehtax34fmpexkb9owU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbwbUlNrkFky2A18uaPq5Nt3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTJlZmM0NC1hMGMyLTQ2NjEtYjQxZS1jMDMyNzdjOTE2OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARETqPOpM5egldJXO4mBObVKG5H5Mo3OaYLhkT0Eec6gK3B\nihli2hLJIqV+JJ0OXHpZ9vrDZINnX1HUIvkbsAp9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1WdW2FLrd+/8EAc3lMKH52bi\n4C0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIH+pj9CWbVJItBK2qT7n71v7SJ7MJNdHecO4TOPSEBECIBHMivkK0Vm+\nZmA3+G8kebCFiBYYPK41ITpRk9na5sB0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAa3m8LQqv6UoPgoIKdQXdOclMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJlZjYyOTYtZWI4Zi00MWQ3LTk4ZjAtOTE0YzgyOTA2NGZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk5ZTU1ZTcy\nLTVlZDMtNGUxMC1iZTA5LTdlY2RkN2Q3ZDMzODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDBzb5nqiO+SE4Hs/FlfQxyOiVc9ux1Yc6KZyTy2ARwnwM4wmwbz+8U8\nQ44C9b7HxRt5kQfFA5hEwWtCwRH0j/ejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKbQiSd0\neHHMNbzA8OuzEN8c34edMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIBz0D6vfY9cSRvVhbcpDAAaZPyaJHM87vnY8bsee\nkTgrAiEA7p79IRKMxJ4ceYloQeudGc7e9+9jJiMQquZtLZjbXuE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5469", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5469` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQ9J4AhukGcB+3uQe0wGPm7MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiZjc2M2JjLTIzYzAtNGRmMS05NmNlLTg4YTMxMzdhMTc2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFkMjY3NDUtOGQx\nNy00NTNjLWI1ZjctNWE2YWNjYzViMWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe2WENRdpUmeDj22HaYBpz15uZ8ChriDPXssCtOZbxj6MibjbXTHh6QXw6nsJ\nFFHV0lFhlAJIK5EApHF8+6BQa6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCu2gbyiB+U7q0rziMZRJy9jiWFIwHwYDVR0j\nBBgwFoAUv9soxKixNqdXyH+i7giduLK195swPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAsALoUvHFqTmWdWt435GQIE7bTThb70eSQY845gFGCnwCIBkE\ndPUOLg+gaAShgsz/6jRkbNsKf+5XCa1ODdoylxi4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARuwF1pfyUO6bMulLGN88YaVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmY3NjNiYy0yM2MwLTRkZjEtOTZjZS04OGEzMTM3YTE3NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdOz2H/5wcMEJlnJUOu/cIr+v/vxOawYp4r3YDmAFpLSTe\nzRnEbJ+q1O8DAHaGJ/7FX6g5dG62wDOfLFKpH497o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv9soxKixNqdXyH+i7giduLK1\n95swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANBKSEI0Pq92p3vj+5snEdbRvHwIoHxyQOu5EknhY3wwAiAROPvSNMFl\neyE0ujr/FrsjRxnssJBrcXXUTaDJET9jjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAfs20sFYu+oBhA3bkVLxuGnhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFkMjY3NDUtOGQxNy00NTNjLWI1ZjctNWE2YWNjYzViMWY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYxZjRjMjNm\nLTdjNzItNDMxNC1iNWM2LTBlOWRjN2U4MDVhNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIIpHOME7Zja2bCAWUjFklRmprvQ7Jj8rlJYwDUM1WkweL63KD8zvsJJ\nh6TQ3uPa27sCEs4C5SVCHhX8JamoooWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFArtoG8o\ngflO6tK84jGUScvY4lhSMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCgK9MOpum6XjYRlTiYcYa7j8V+ce0etOW5NPB7\nJD3W/AIhALFc09P8GdQYjjW+TRCu8xtcvovB6vo5cpjD8S54jBGl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5470", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5470` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAdMDkY+62AGwfs/m60D/PR3EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxNzE3NmI0LWQyYWMtNDI5Zi04NDI3LTkxMTcyNzFiNjQwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVjNzgxMTYtYWNh\nOS00YzRkLWExN2MtZjU1NjBjMTM2ZmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESOWzm0SrbVyylr9sY2nSg9vN9bng8ComUl4BF7Oak3tkHObMvF4mR9FlDvlX\njsckOWx/f1sV/atBTLfBuTN9hqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhW3JjGqgrXQuszkfEXPcK1HwDh4wHwYDVR0j\nBBgwFoAUR+4F87d8UwEBDNXUnh2Cb55JVHYwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBMoIDgiyTUWiDz\n8wm82SAg0nZY4dJRzWDpdkmxWsv4YgIgfRObrTNcPcKBt3MMpDRq8HE0KXgBrwMj\n8qwPOertcUA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXmvVVnLedDxm97240tOS8t7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTcxNzZiNC1kMmFjLTQyOWYtODQyNy05MTE3MjcxYjY0MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoif2u19DPhThpzVX9XJZlviyt6QxdGDhnGfjw4YunzbTC\nSJ8I/DUEiwmq7RcHTxNoMsDSHAS89ACLvGu6tw/Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR+4F87d8UwEBDNXUnh2Cb55J\nVHYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ8FU26P/8tXSL87/gQ5MMUNlwcJCnX8FbcJPTk25nzMCIQDod8UxQlLo\nLQ2Ab6C09ClrfSO/QjgAbVGN2DXJvbZ10w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAaKYOuMY85TZ36IOYkhXXq9tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVjNzgxMTYtYWNhOS00YzRkLWExN2MtZjU1NjBjMTM2ZmM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJkMWI4NDUz\nLTQ3M2ItNGRlZS1iMjg1LTA1MjhhZjU1ZGMzNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM6lAjek/lrQYeIZ+1oSjY2UBBj8WWlIM760OeJHyGcMHd8nqDDQ0seb\nHWZvl0U0Bkgq5wqamQtz9db2+p6enBCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIVtyYxq\noK10LrM5HxFz3CtR8A4eMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIAlNFLM+8K/Zh3RjUMEQZrTz+f7PWffcPlcS8kT5\ntO33AiEAzwf7IKn/hrfoif92cy+fSZ8HTOb6Ibj54PMsofmrKk0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5471", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5471` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASwm+Xp25GXZO17MWjbinSDrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3ZDhhMzQyLTBjMzQtNGQxNy04MzdjLWNlZjNkZDIxMWZjYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI3ODNkNDUtYjAw\nYy00YWI3LWJiZjctN2RmNDQ3NThiN2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdhbUfccQGF3oab34VGOrZ4s6ARDcoTUrN1D/AJqZYN9iWrjK1DqZA7rn8DdX\nWJPECLZnzFc/U2xxsASfpatHBKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/DtITYxo5CLKk0KNgsRxcnmUWoMwHwYDVR0j\nBBgwFoAUn36h3BQMA1zMqE2nmO0J1Fxc5BQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCr3tE0uLmzZ4NxXwweQBlrvec+28ADVD5gKxNZX7BK5gIga7jpzxOL6ZRS\nCEl9evPl+VhiqtamLvV3l72+Mh2w9JM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAerTy/OrAvnijg1IxhD9MVRoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2Q4YTM0Mi0wYzM0LTRkMTctODM3Yy1jZWYzZGQyMTFmY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjSd7v7DoIPKdgkrm5l9egmeSIq4+6mV56hy5I0HszY8ui\njw9HhoRY7sFMTu0qGFfNczHx5M73eqAj4cgb0cP6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn36h3BQMA1zMqE2nmO0J1Fxc\n5BQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIpz8gnFLLvcD2NlSFHscILFw1mQnEvNkq3MgsRULFlkAiEAiGkcCqQx\n3jummtoU7btrg5a2YVIS+qcTqb1rvrxkQh0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdzoubHmMeq19PWywvRrNBzgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI3ODNkNDUtYjAwYy00YWI3LWJiZjctN2RmNDQ3NThiN2Y5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFlN2NmNWM5\nLTQ3YjAtNGU3Yi1iNjE3LTc2YTUyMDhhMDE5NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNOZT/oGaXKE/LRG0fxVLN2ZRiwUfXm+p0f+EM1dpZOSh/Ra3Li3v6u9\n3fs5wRV4iMcK+d6j6iGsJqPyMuP0BYCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPw7SE2M\naOQiypNCjYLEcXJ5lFqDMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIAw5b7HDuoOx+xmG7zUewlWFVOZ0YkCbL8gQZBr7\nhso2AiEA1m3O+TNFWGLeU10/qff+1YJH2B/d+0TVErvWqVZEgXo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5472", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5472` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfWIF0ICU6Bz38n4sBzhJGvnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyYjU4Y2VmLTIwNjUtNGM4Ni1iNjM5LWZhZmRjNTk2ZTJmNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk4ZWU0ZTQtMGI3\nNS00M2QxLTg2ZTEtZjZjNjJhZGIzYTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElmMDam/Jm857ngrfarYizDszrT+k5hH7OmNIDBhwL2ln6w91bOZ6bfREDF1T\nN0d+ts05mysW01r3h730OUnKX6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz9wPTlzESM12EWvg2LQJy3yvi8IwHwYDVR0j\nBBgwFoAU4qD5TXfxvzM89rIs1yq9S2MjMqgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIH9XrpCnHjl5AX+sVCA0zLYPAR0d9fWB/5X1sBcvCQs5AiANPMyc0m7nSNwx\nPyDtbVkjPRq398RW0pZfWo6dmFT9hQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcrs7kdsboHOLlVRyjGnR1x8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmI1OGNlZi0yMDY1LTRjODYtYjYzOS1mYWZkYzU5NmUyZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYGoSRxfEDP4jGy7ijLq0cWztQg2R/bsWV1M5/slPnrfWr\nH4rYv7qc9TY/ber4yVGFzmPEAKUgrboyz5/6Wd6uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4qD5TXfxvzM89rIs1yq9S2Mj\nMqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGpP0PJCgMMQWgJWx2zIGun8wa+Qsah4hdWUv3JB9XtACIQDUME6RD+Lr\nNFfYH3gAGDK4Ko6r73NE2k6Tn1iVZT/95w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdXQUnmGhLlitvu9IDv0ymyUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk4ZWU0ZTQtMGI3NS00M2QxLTg2ZTEtZjZjNjJhZGIzYTM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJhZTk2NDM3\nLWYxYTMtNDg4Ni05MGFmLTBlYTM0ZGVlYzMyMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFVf0HYh2fbLALo73CPAPrQey1S7VjP5k2whrG5ox45qpVaTP4gsr4Dj\nLKLNvbBGDxgiAaG0Leh6SWjO5R2R9e+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM/cD05c\nxEjNdhFr4Ni0Cct8r4vCMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQDwN+ZYSwujNzZQ8UYuk+VdPu/qZBFYMZPKcuM5\nf627jQIgE+Q+E4IqnQX8zsgaSk43QOve6R+hkc2saewI/kY/S/A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5473", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5473` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAd9Dkl3Q+JVPZcbrhab0dSB6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwYjY4YmUyLTAyZTMtNGQ5OS05ZmY1LWQyOGExNDU3NWEyMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI0NDFlMzctNDdh\nNy00ZmUzLWFjZmEtYWNjMjAyMjY4ZDk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtETZr+hn7PqDH6wYHNw5wNvrNK1PcDxQa3M6JTsZ8AYwfF9xizm2GvV/aSjF\n+U76EGpI4Jbpj9irjEdngzYbLqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4lrWe57IOOuWLB8DH4fHdYn2O54wHwYDVR0j\nBBgwFoAUZULtThGxk77S5cvQqKdjjHUkR38wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiB3mDNBmBzmHgfXzdFzPBFlVQ5x5UWiwEIs0EeWIm9oDwIhALOF9+rYyeV3\nhT7FtZXD2PdTdvqTHKYOkJhaQyXf/3CN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAegfLFbpcxD75gL8nBstOe/cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMGI2OGJlMi0wMmUzLTRkOTktOWZmNS1kMjhhMTQ1NzVhMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeZg6/fN6tZFJg2a0MYNkcEhgjD8Zh19E8q3T1lif8vxpe\nHkZ7dr7C/0S7jBeJEWsdMHttSxOa+cliBfSbzIxio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZULtThGxk77S5cvQqKdjjHUk\nR38wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAosBk2TikJhWWp+Vhncjy7zJxiSCasAJZSg8xp3GWrACIQCeRyvW5KvB\n/q2o4Nqd4OMQx9vcP2BbocU9O8I5CFrKRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXxwwd6/sGUc2fps3WYGLlvgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI0NDFlMzctNDdhNy00ZmUzLWFjZmEtYWNjMjAyMjY4ZDk2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVkZGUwMjBl\nLTYwZGQtNDcyMC1iZDkyLTQyMjM2YzhkZjY5ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB6ApwWNfKGTAAFUA6sAlG/L/GAN41Q4ZE0QRauH3JuYMKWcKaKc36ge\nm31YhEOvwpu8xhaSYqiTsSkx6EP+XqmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOJa1nue\nyDjrliwfAx+Hx3WJ9jueMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCHDK0jyFHpSHMJN7YTmbYLLradg4X7x1sVz2ar\nijiHbgIgB5DePmB6sYdho/F8Km2d/vTAm9X59Q1YkCSa0bnBp0M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5474", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5474` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAfi73b9BjNPLhQRYDNKNpGaQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2OTk4ZWExLTE3NjUtNDRiMy04ZjUzLTI4MzYwZjU1NTU2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJjZTA2ZDQtNjYz\nMC00MGJjLTk1YTItNTI4N2ZhMTk2ODM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKa9NLoI5b8ty+oyML5ncB90rmjbcBNIl6b2k17li5NxvdYyvNPQ9bRG4xTue\n6YNqXth92DtKmMRI9QY0bqBv96OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7XwoqWrRZlU8faftpV/zCFVO3VowHwYDVR0j\nBBgwFoAUctjluEl6GRI6M0eWvJeCqi1H080wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA0AKHba0eJuHqi1Tzw9ncx+3cb3RcSigvqKTo1PjT\n7QgCID50EMg3FTfo3wo+9Cxp1tFrbYqY/6IvnxVTEYSMIXT0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ96PxK/Zuj2xmWLz9VTlqZkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjk5OGVhMS0xNzY1LTQ0YjMtOGY1My0yODM2MGY1NTU1NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe/jap+YJ5RGqhLgGYey81ZtTkLpdrWHNbTe6bqee7aAr7\nsVHsph7aXbPORti+u0HAlJyYuEbzR83i5KjNNFNXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUctjluEl6GRI6M0eWvJeCqi1H\n080wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO+SXMNbGEpSLomR681VkULWiHluQNWj1L31jr1a8HDDAiEA4ca5NJhH\n06vYcrRt12qB4noYxRz8x29rUm8WG4q1VUQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAce8rds8I7hUAfdS9v8n3mKeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJjZTA2ZDQtNjYzMC00MGJjLTk1YTItNTI4N2ZhMTk2ODM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZkYTg5YzVj\nLTY3YmUtNDRjZS1iNDQ2LWU0NTVmMTljMmNhMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIUUBIotBlEq/5LuOlnUcVd5+vfyOK333VbEH8ddPQmkD/yeXd6sPmfa\nxixX1dcTQukNbsEoSbh4JBDBLDyWvjqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO18KKlq\n0WZVPH2n7aVf8whVTt1aMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIDh6GqmLIxT1I35tWsPsCXYOXdzRwR3DJ72Zw5BY\nZmr1AiAsxRJOyFDyNwO0VutxMgsAoH9VNU+9tr87bLP0WrKC8A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5475", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5475` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAYdh0e7zSjlryBq2+23dvkGzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3Mzg5ZGEzLWJjNmYtNDk4Ni04M2Y0LTQ3M2M1YzdlODk4MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFiNjE5MDItMjBl\nZi00OTg4LTkzYWYtNTY3NjY4MGM1YmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn9rdxEbMU7eHYSGrV+AZ7FY7Nh1YoBKgXB9fXB5X2+qMYDFqMfEwB8U77hZL\nOtnSwUFP5jDgoytbbrxt3UplD6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVxYR7t6j54X0s5ie8E8X78RP0mEwHwYDVR0j\nBBgwFoAUVYpQ9Kh9pRuiYOFy6szgsljNBqwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAdAgFrdyRWTOgqF5LzSG2glMNnYNLJ1Gqk2NJ/6Qta\nNgIgF22A1nbRNhIelSW3YGNdiPU3S1eELSkDp81veCcMu+8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcKEZgLQcudDg1LGUBtuHDJ7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzM4OWRhMy1iYzZmLTQ5ODYtODNmNC00NzNjNWM3ZTg5ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0U8SrVtkoHdjl3PtLoSTFJtMCHzfZ/kjSOrXlW4bLyMfy\n2D3KO1vSNQDdApybFrs02dZpYvzuf8On3FW8x7XOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVYpQ9Kh9pRuiYOFy6szgsljN\nBqwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUriNt9VxNlJ1fhLbKwWs5S9v66LRBEBTeHvlwNnknW4CIHBr3A6m5ZyC\nngjyQ9mjtg31Yc5Upou7u56+w7rqBqQU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAUi6hAZZffCLRX1tvnfgjgLYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFiNjE5MDItMjBlZi00OTg4LTkzYWYtNTY3NjY4MGM1YmI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE4MTBhZjIz\nLTA0ZjktNGUwNy04NDE5LTRhYmUzZjZjYTQ3NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCdVCUAtpERWHkh2ULgjQoiC5Dctew10YvX/RiMA1IIiqF6WeJ+JLVv0\n005BUjJki4sCmVKAnCxfij1ocCQ+sc+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFcWEe7e\no+eF9LOYnvBPF+/ET9JhMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIHUO/W6DEkfJPj+NXov4SFVtmBjBf9xN6Fua/5/b\nQOJBAiA/9X4FkX0ZizhrFzoH6Uy2PnUXt5OKkp+VBBe5vRtZhQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5476", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5476` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARsPNE/NB9uPhDPSRQzbqZfnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0NDBjMzE4LWRmZjktNGFhYy1hMDM0LTI4YTA2Y2Q2ZTI0ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlmNDg3ZTgtZjNm\nZS00ZTYxLTgzMjAtZGJiYzMwOGMxZjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcQ4UnYaluycQ2+f/H7cdxlHiZMxSlZHN2yxESQgjZYncYuUP5g2egEdfeaGL\nGaYS/Wk4tk7GD7eVXEJlpYCw56OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUteGKm7lS2pEKyuHaCbZiNcXR3JkwHwYDVR0j\nBBgwFoAUQaiVeCsRlWPwDC9JrIhrmnrqYJkwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAnb89rHhhf1bVPZTAv0TDX80OmmjAojvEmhIRl3t1AZkCIF5B\nsVe1j1NRVubE41n6xc0Im89hNk3tAQ2Py9Oqnsj2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeL0H1uJK5zbYk5b7zbHMJjVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDQwYzMxOC1kZmY5LTRhYWMtYTAzNC0yOGEwNmNkNmUyNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlK392N514sceA0neXvr7Ro43ecCrwDRhghkVwmYCmbODE\nUQoC+2F3vSs1fQLo0yUb6R3T3mi3wmwFHM4HRRVno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQaiVeCsRlWPwDC9JrIhrmnrq\nYJkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPC2lbcwo3/1YNcWbo4eSfQHeBxmDBbojm3MCsAWGD2NAiEAsINRS/qX\nyWu5NRY2a9eph6lqV0drprwi1RjLmtBtbI0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAWEn1+WmqXZMH2TovhthwPPtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlmNDg3ZTgtZjNmZS00ZTYxLTgzMjAtZGJiYzMwOGMxZjUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1ZDQ2Njky\nLTY2NWYtNDY3ZC1hZWQ5LWUxMDBkMDE0ZjYzMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGRSkb517UqzLccYa6QzpF29rjw0rzcWlfeitNWB3lo0LaCBJC9Fm1hP\ntJAAI+5cEy5XVKyfuuYR5gU3woYQZdqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLXhipu5\nUtqRCsrh2gm2YjXF0dyZMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIDAxP0hdjGR+BFZmJeb8zyrNVeJokkQpqLskoeqG\nUUy9AiBi9fVGezt2mw9SmLlPkrEeRrYK7t1bgPyUoIArDsYxFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5477", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5477` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISASTv7USXSpoeKs06/vMnYL0rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwMzZkOGJmLWY2OWQtNGMxZC04MWYwLTQ5MjIwZmZlM2JhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFlODZiMzgtM2Ey\nYi00OGYyLWFkZWMtOWIzOTI4NWY4OGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeOoBfXlhI0gS7ZCaah9od0EfSQOsppFK351wBVXdhgXBRlvFYPdrlpVs+EaN\n3zv9RnLyYH2qa0WSez8IPPxI3aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU42GweHfMge5VpDrRMussNDL3gygwHwYDVR0j\nBBgwFoAUoT/doEjuS1qT4yEvbBQtuSbURygwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA7OwnDbcuTnbVFbg776wgaGYQzzyM4r6G\nZGBgL51GT/ICIQDAyj6BjhS4JrkhXjK9+vaa6GJEiCFHYEL7/2f8QRLr6g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWr/72Eom9SfruKyCuy1GtIrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDM2ZDhiZi1mNjlkLTRjMWQtODFmMC00OTIyMGZmZTNiYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqLVW1NLHvEgHVpfCbM1G17qFRFxdv43uFOz/smJ/gjS3B\nN9NX0RdkN96CsLwYrnoVVk61GwJM0ZmsABIqC1sdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoT/doEjuS1qT4yEvbBQtuSbU\nRygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM7swDhA0gBTWLG1Znyh9arqokcrVTHTVcXtBYIOXEp4AiANfD46Ad4H\nHNRdfwjKRmEp9PUbHf+6u0GifCPXK6Z5Tw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAaO7SemDR/dVeqlH8x+YEcexMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFlODZiMzgtM2EyYi00OGYyLWFkZWMtOWIzOTI4NWY4OGE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ4ZGJkM2Uw\nLTk5YTYtNGY0Ni1iZmJiLTIwNGI1NDExNGRjZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDKcvN4qgoTGcV9oLJ0K7ICsAqmJyHIdhjPQzbl4EByWgV1lu4vrJkbr\nvdRQyxG23ZOp0FSDqaUuiyxWuGAp16mjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFONhsHh3\nzIHuVaQ60TLrLDQy94MoMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQDOrWnspMsPNY+hrxSDMQJLcEUEkLioHBpe0QO8\nXwmxWgIgOeI/t4VzcB80q+xL6e2/sGdtDenI+ytj/+LA8ztusF4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5478", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5478` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASpLBC+c/YwrKtpbD3rOn70+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiMmNjNWQ3LWE2NDYtNGI3ZC05MDIyLTBlMzY5NzExNTg3MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg2MThhODEtMDll\nYi00NzI0LTkxMDQtMDI5NGI1YmZkYTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDAzlI57E3+PFNv3JXR0QqRtvdBIoVLKck2BeQsEyNxPBC5za3tDs9//N9XlB\n/0Z+dtmKTLJ7OwTLcwLnvvJKUaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4TXLk8S2wZp5k/8xo0NkCfVBvYAwHwYDVR0j\nBBgwFoAUsX0eOe7CibDYyt2bi9tQ4cdr4qgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAqmJiwSPn3sHBtLJqpEzkirJRJEYXr8JD\n8+wv0MxGIpQCIGEoKqMjUthyF2uTg4O1QRsTQxL2dPe3vWUc6QflTr8O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZqX/O+JGjAF3yI8Gm3gRf49MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjJjYzVkNy1hNjQ2LTRiN2QtOTAyMi0wZTM2OTcxMTU4NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQq0NWF8wtMADKouVrAZC213yIr6x1NgOHpxxUILE0sK7c7\nQmd2lH5eLT8fRKrHlphOPz3Tsezk1ilJCdMK7eEzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsX0eOe7CibDYyt2bi9tQ4cdr\n4qgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfuVXX7i9UmKDUFjNTVf+RQccD+qAopwoh8HLeeNqQ28CIQDko2R2nFGQ\nQ3cU27txLG2nWdVWsEhTie4DjjY+5kBVPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAWC4tSZHkBJQ649ysV5DwTy/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg2MThhODEtMDllYi00NzI0LTkxMDQtMDI5NGI1YmZkYTc5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE3YTYzZWEw\nLWU0YWEtNGU0Yy04NDM1LWQ1MTAyMDg2ODhjODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFKkH3gi/Kzln0IVCnZ5MNl2OdRuOUVzO6DY2o4LtdZWTP1g62TaiiWJ\nIADA5yF4RI2uOkKjXrVy0tSHqCBSTiCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOE1y5PE\ntsGaeZP/MaNDZAn1Qb2AMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIHaq+d2pZWJ4y/BxWI3sNIAUUinubInTA8awmoTV\nMmYJAiA76dldujxwv3kCh1phowKjwYZO3vAFZhJovgvEPPfKIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5479", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5479` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAen6xkOOyA8Y6VnItweLTSBQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmN2NhMDU4LTc4NDUtNDc5ZS1hN2Y2LTNjYWVmYTE1YzJkMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNmMTBlNmUtNjA2\nNC00Yjg1LWI3YTctNTkxOTk0NjVlNGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkv5gwqEFTl4aL7EDRpXS7LFT91pjSDiYp3iAQi60IBUWEOogWT5WkA9sdYXz\nJcWLXgR30aFAWUyMB2PH7ZUgL6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDQpU3c2zi/aIiTgxRKS1dxJrysQwHwYDVR0j\nBBgwFoAUXpsySyHs2yb5gNW6Fl7FzJJI9ZMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAsMN6GlH6gDDU\n8P2YPUGlHBhftlQiYectJ90TJI4dg3ICIQCBBFDBxo2HkjPEMv2LDYE5o0u3k/Je\nXERCj80tcJdisQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVQq4yete3z/2TzErdOydvauMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjdjYTA1OC03ODQ1LTQ3OWUtYTdmNi0zY2FlZmExNWMyZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATM1SzJnFlJ6397AbLbwWIt63JcsKyYpBKAJlpD41s6+Kpe\nZMKlpXbqIOdcDs7Gtuy86IUQFSvAdhC6fMGW3xsco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXpsySyHs2yb5gNW6Fl7FzJJI\n9ZMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLLxQFkdN8LwpOZDB9TWsoX0EIJlVwgfSHfTRf49iVKcCIHBZH9S108Pk\niBwqokn36Ps6F6lBQELI2ZpbAMOvjTkG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAd9oW6+G/c8w4NdrGTxxymxMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNmMTBlNmUtNjA2NC00Yjg1LWI3YTctNTkxOTk0NjVlNGVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFjN2JhZmM0\nLWI4OWItNDgxMC04NzA5LWIyYTBmZWYxY2M5YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNM/X0ZgR4gOwfDLaSwWzQs6mvuZaOaFcQFcvHZqDeLOUKK5x6HM5iqz\nITwgxMvcb8w/bJkCMpx1OF/VcdfDy4+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFA0KVN3N\ns4v2iIk4MUSktXcSa8rEMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDF8rgSCTxol0W1+W0v5cH7kFKf0b8QsMoRvLDy\nSjzovQIhAJi7QiRmqiA2UBNFoKAwvFMZdU84SZHWdEe3zOWPTa7L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5480", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5480` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQAs+PVSuCeeCWICYPX4N4/eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1NjljMTRjLWY2ZDYtNGQ4ZS1hMTVlLTM5YTdiNmE4NzA5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBkMWY1MTYtNzAy\nMC00MjNhLWJhNzgtNjUyNzkxMGQwZjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPKYtYjVeayZc7DT0E5VqfjvJr4SB1v8HTQzMOMRl5PwLwCnNjsAXjG1Ko47s\nB091WAbzcYM//AbbS+XT1ySPCqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4UUoX5FqNNGjRPTzKHiRlwPicgQwHwYDVR0j\nBBgwFoAUZh/0acqPm9TIOg4D1oHPAiY9Fr8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAXhA1oOUUZGQaiC/2XDI+AETvhfMQ3wQSP26mSTQsxTAiEA2kXr4/oBf//0\n4WwsfB57XLziFzEU96dy15vVsikO39w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdHB0NrxZEJ14CN0yE723RjgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTY5YzE0Yy1mNmQ2LTRkOGUtYTE1ZS0zOWE3YjZhODcwOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRppzUwZek+3urX8SPAdJcvqG71mD+Hf51oyv7ILf8pTa9\nz1bhOkB1hZOEzBZXDrJ5RhxxhkDfVnF3Wlhk80/Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZh/0acqPm9TIOg4D1oHPAiY9\nFr8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMZAjsELo0E8v4CtGQNZrbFl3rhauY/i8FK7T4QxMfn2AiA1sZVtJIo4\nWh+jaz4J47w0uUFCb6gSqtL4tYb7vcRDjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISASoVP0y4rcAy2QzPMQk4JWnIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBkMWY1MTYtNzAyMC00MjNhLWJhNzgtNjUyNzkxMGQwZjQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRkN2ExZGY1\nLWYzMTItNGQyMC05MThjLWIyYzk0ZDQyNDY3YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBSi9i9N0rkm149SJtNtSZisPLigw4/GZBVEQvHh7jRISrBmijTG8Bfn\nEGRRXRnAoAE55c+XB4bWrAksxSh2owKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOFFKF+R\najTRo0T08yh4kZcD4nIEMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIDqgehCf53ZyupeLMYHu27wDRdUO0ZhLALhj2lsj\nSNj3AiEA94RzALVMEj7jxe7pfxQ69m/p8etTH3zcv1MsnqMzAGg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5481", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5481` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAUrPbNX9co2l3rsV2JOBQJRLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1MWY5ZjI0LWQxZjEtNDY1NC04ZTRmLTQzODRmZDNhODIxODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTUxZDNmM2QtNzBj\nNi00MmZlLTk1MTktYWIzZDc1Y2VhODI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYHIKIzeAErHks9Dj7I67cMqJAPlKpxyTHtCUY1JF7fgj0FV1xuuDc+IBosBp\nZhhQ5MvQ1WJxnc9cmjM8Zdpdg6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB4bDEE4TDxHLGBp5eVDpKHsht+kwHwYDVR0j\nBBgwFoAU6eKXkgrLSnDCYma/CftFx26edQgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICVDwSN6anXMGJ3Uw/dTY2m2Kac5QL1N9Fs3vTrICHLEAiBvw4Xmufnqwxd6\nBeIJRifyjMB6EoLVAELh6Jfi3LsBUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATxs12UhpgTQoKiScHs5ImYsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTFmOWYyNC1kMWYxLTQ2NTQtOGU0Zi00Mzg0ZmQzYTgyMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrgFOv6Lg/S5xmVrnDOlbodQM/+Ahj8hP2wi9ZZmjoeE9J\n1PPb1uyR/O1uNGlCmvMWhGiF8wTRgBHEoegiQTDxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6eKXkgrLSnDCYma/CftFx26e\ndQgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY07H8TIyyeOOmwF/sRnciQkbOpp8FLpYpumF+qjqPcsCIQCJcqvus1Vg\n7PCd8jzkN3A+pw7QN5SQRnRK1mUc/jgp7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAbXbP256fmsRdSaqt42qyo3ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTUxZDNmM2QtNzBjNi00MmZlLTk1MTktYWIzZDc1Y2VhODI5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEwNjcxZTUw\nLWJkNTMtNDZkNC04Mzg0LWE0ODYyODk2MTllZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAmuoSZahCY4/7CJ3n/0xnJkFAJjfAmFs6eFDFLVAdfO1ksXzpefpMmc\nfKEbt/vkssdq1U01JQi2A0EhXF0LpJGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAeGwxBO\nEw8RyxgaeXlQ6Sh7IbfpMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQC76SacyM8t+n0gWgVd5z/fwwBxUzAOSett3CdY\nD5pLngIgbLQB255MpYzKForK4sy+6CDTH+umofBMDCyBb14i3fw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5482", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5482` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISARzJaJEZVE0pNUwW1fPsP0PmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiMjhkOTVjLWVhZmQtNDYxOC05ZjkwLTFhZjAzZTQxMjU2ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk2NmQ5YzYtOGQ4\nNC00YzFiLWE2NDUtZjE5Y2QxOTgwYmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM4s0OUJsZIitOJv2w09FGRqod1wiPriXIT7cIELu26JY8MN807sz5iOiMQvI\n9/GLuCgfMpFYAK20jsicYOXZYKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH2bPuWTdhLJJ059tol9mzFRArPcwHwYDVR0j\nBBgwFoAUnePGSXVkVhFdDgckYgwforeGETMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA2cTTk5IIOSoVT437FqEo4PlW+QXtcqY2F0rb9D28ovACIQCIjUnjfbRm\nfkp3xFQvfYDuyClRhQsV5IYhZZMjcqoOBg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASzWYC7DJ53f1BhZc5uxr/iwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjI4ZDk1Yy1lYWZkLTQ2MTgtOWY5MC0xYWYwM2U0MTI1NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrzjoisLyB+NA8JyDCCMdIFc6LADOAX7b+dGVsIB0qHsTV\nZSAThqAkbyxaOAIbA1r17I/4uaicRtIJdzL06bdNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnePGSXVkVhFdDgckYgwforeG\nETMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMav60AuoVQfQy6jIRH7Va19iZR2EZfo2mkFUXb66raXAiBggnV3T2/A\nLiGhKmpARo8D3+XMKDXTscsPx+PmSBugtA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISASjxzKzBAmcD8dIf2oAVbEn3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk2NmQ5YzYtOGQ4NC00YzFiLWE2NDUtZjE5Y2QxOTgwYmM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkxNTI1Njcx\nLTAwNzgtNDdkNC1hMzlmLTkwZDQ2N2M4MDI1NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDb4pYxVN4rBfpd/nRlpd1y3U138hzy/QAcdBE0vHyDMx68133P3t4QH\nV41Ksx72kHlDJwHFmku+P9If6nwrua+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB9mz7lk\n3YSySdOfbaJfZsxUQKz3MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDzkNPhcxCz5c3z6uc3sbm2cgfNKHOXMAIqkCkp\nzI3JdwIhAM8razyze1dn1s+YGuKsKR5BeqGtVQpKz0Sql6SernAW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5483", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5483` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISATqdlGSVXyAr1N/5fNvJ7JnkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkOTg2MmE4LTFjODYtNDRlYy1hYTY4LTQzYzJkMTY5NTEzNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI5ZjIwMDAtMDZj\nMS00ZDNjLWFmMjQtZmUyMzJlZDQ2YTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExvfkMCoFyVMX9ga8xTkkSwQEFiqX4cfxK7MGkBDrjHfa2cPpg44wjKKjEgKa\nX04vRw+NP/kZslFHU1yv5BptPKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2V9avsAL/P9zFcgZ29j5e5bTw+YwHwYDVR0j\nBBgwFoAUkhng2sIelvze0neOBNJcz5PNTQ8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAmb+15jGO6/HkMB7k+GzJE0l67CA4wXR3urJM+OZZy\nPQIhAMuh9C8BKwSM7o70/ITvzgJgKPFp9I3cYs1ftDeYGwbF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY7Ufh0zUlnxxeqY5zgP/KWtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDk4NjJhOC0xYzg2LTQ0ZWMtYWE2OC00M2MyZDE2OTUxMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARt8jTqhFpsQbTHOivxpgHa+ZRvPvf8WLW/jT5zxCO8pMQS\nWs8YGDM+AiTymdabW0++Sv4QFg6Hp1ZrgW5IAYz5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkhng2sIelvze0neOBNJcz5PN\nTQ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAJAzt7IBW3XwfTxM1Ltu47A9exxSddR5//33xpPkiIkCIQCZ5uhHthpv\nYmWfThgftfHS/B5Y8PsW0GaivMeLYx7y8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAf8DcGXNbHooJ7gGfG6hEGgVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI5ZjIwMDAtMDZjMS00ZDNjLWFmMjQtZmUyMzJlZDQ2YTVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3NzA4YmUw\nLTRmMDEtNGQzNC1iMDE0LTZhYTVjYjhhY2NkZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKs6UcbDBXCf+pqHYSG6zpASLWqJI9pnv7rcHFFHB/NhNeZaHz7MIQhY\nF1mwhh6KrcHtFj6Ld0NXTTjg0f8zp2ejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNlfWr7A\nC/z/cxXIGdvY+XuW08PmMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQC0VZUqq3pEkY5hk9/OsEr6EV3mqgy4yyrW3nJ9\nQA0pmwIhAMxPgAUgaIaL/xIUwqHMjy36Zc0zWd4pm7atJh9ysacq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5484", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5484` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAWReoWn6ScSPjPFaiTUCUiixMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwZTg4YjdiLTZiOTItNGNmMS1iOGU3LWI0MjBkMThmNDViMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJiZGRjZGEtZDU5\nYS00NzJlLWEzOWYtYzNmMmZlNTU4YjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXiCm/d6yWQxxcQc9b5LZI7yjtdH8SSKH678z+RUXbw7QVcxaWazwcasWCqIy\nfJsGlKtrREqLyT1Eu8mxPRdCi6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUidqDeL8CYsYH+o2Cos4MjF/irxYwHwYDVR0j\nBBgwFoAU3z8RAzJxoxQSf+NwRvRVaUmiCIIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAK4xZIO11JAL7/LdXXN/MMwnAvpJWxAExLHxdy4Kqv\n2AIgC1Kq52A3CQXjZeZnCCFOAeCT2Fv3JeLWhRu/DBBxfag=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARqbTrhfWBamtuEFcfT3ctSWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGU4OGI3Yi02YjkyLTRjZjEtYjhlNy1iNDIwZDE4ZjQ1YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPEpUSTGl6zvzUfknq/U9AAUTtJxkbY1y0GgE5ne4SvHQx\nOfeA42bQI6RHUhtlQFlmIim3ykllh5aOI+cZjUb2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3z8RAzJxoxQSf+NwRvRVaUmi\nCIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM2KwurKPZjLI+zAFINoBVRxcSWb6Jr2Nfdxy7hO0ZHICIQCpg1UnWVWS\nNGAmXDl4SOeFgK/SXNnJsIIZLHE/zhp6zg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAc+B+FDeqgZKAV8RyW13IB2LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJiZGRjZGEtZDU5YS00NzJlLWEzOWYtYzNmMmZlNTU4YjMyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI1NTVjNDRi\nLTZjNDQtNGIxMS05YmY4LWUzOGY3NGU2ZjZhYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABESH1xeh7y+ahKY/4nNv8xQimLdkommRdiRN9tg1pCWHUJjRw+zk4q5N\ngntLLFNSwh2b8fe0kwoUHTO6uVC42fyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFInag3i/\nAmLGB/qNgqLODIxf4q8WMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQC6PZnqfRLk59Lax8R2Nm7Wj2FCzoHBYrl//m4E\nj182hgIgBScSu+l5yBpRaxoLcrYsjP0yM4hS6HZHjoAS0q+PhPw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5485", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5485` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAYo+mbTSQVFqyNe9SIw8LX/jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4OWZkNTYxLTZiZDQtNGUwZC1hODc4LThjMmYwNjgxYjM1ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODllMzk0MTEtODAx\nZi00ODhmLTg2MWYtYTgxOWJjMzk1OGNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0s2CmG2gCsbj0QbRbg2ySqxoZNQfjRNHurG2I7nqnTwjA2quNF4oFKCE+CJE\nCvznAjOkmIj/aEzcHeNZD5WzQ6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK34X91D2bRjMUl5J7cKMI4InTtkwHwYDVR0j\nBBgwFoAU0QnkTRvfrfmSnIh0mPO8ux+6KYQwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBI0iG39wllktBZStbgifTwvyS76O5hzeVKiJU0ROkTfgIgc1mQ\n7pBHIdrz+COFcx9Jy7ehMyrMyhLo0yWL5hdqiBI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcMWnbBwOcP7SC8vYlSl0yOKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODlmZDU2MS02YmQ0LTRlMGQtYTg3OC04YzJmMDY4MWIzNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNohZwzLVM/zE3EbI0k2NIAYgNXgQiSQ664vJtH3IWxm5e\nSsn0xYs+4tMJN/MUgynZZ1TKTw/gjQJaIW4q86bqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0QnkTRvfrfmSnIh0mPO8ux+6\nKYQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXgrb6Mol6x1dTYg6O3vhuCLxEHUkgcLZyH2Ie5hv0J0CIF02DE6m87LJ\nMfLg4ONUv66Wn5GaRdC1DAEekpnXxMxI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISARJwpWvtGxuuWOSA4uyumqHcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODllMzk0MTEtODAxZi00ODhmLTg2MWYtYTgxOWJjMzk1OGNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI0YWRmYTk3\nLTkzYzctNDQzNi1hYWM1LTljZjE1OTIwZjAyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJbpjrYwo5DxpoKLm05yNMM9vrT9SWEKs4DZWf3O9tBdYaxY7jXatC2y\njPvHaMZMV1yuSu93IqX7kEVW+cRCzKqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCt+F/dQ\n9m0YzFJeSe3CjCOCJ07ZMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIEVZVuCVjJ5h4GUrnu8k87i3icM+HjPuUyX7wsj4\nZoJ7AiEA3izWr6cq6B5mkPmQozsCC6AW0P7Irg793a5WYREtUZk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5486", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5486` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAe3OhcjrSntuU6sr+ukZNH77MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3NjUwYmFiLTIwOTgtNDZjOS05YTU0LWE5ZDMyMDQ1NTk0MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNkMWU4N2ItMGY2\nMy00YzVjLTljM2QtMjIzZWNiOTZhZjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI9MyLQf7R9YOBBfcm9wGWMTvzyPlJYFqzJhmF3BM/Pzgoubiw1U/W1BhbZpw\nzEpx3XtWKfl9AK4jOKCtjjZZvaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU06Z9tVnd2PdRGglFN4o23sIMueowHwYDVR0j\nBBgwFoAUooWfvv/sSD/V6RFdThysNQx8FzkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA5AUeDqerBOBbjIG8vWKVtG870rgeyJF8\nyiYtxWVlAzECIAjWowspBuanCg9vNjwnqX1Zko4u4q4CnH2i9H4SwgVA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe2bzw/rj/bC/4ccgPGP1GIqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzY1MGJhYi0yMDk4LTQ2YzktOWE1NC1hOWQzMjA0NTU5NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0gqcBJTmLXuk1jqW8jO1QdbZCl9o9Xw/YPzWJjfn8J/yc\ncmsWtxbCh20e5rvZrz3p35yGozjwQNeH0bW0/4a5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUooWfvv/sSD/V6RFdThysNQx8\nFzkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLC92//hcGSDh9fTwuRMmytI1Wm1QSgtW2kTLggY7QHYCIEzVtbg5mKna\nS1vtj66HGsM3vxMKeTbtyzN4xWDTIPuI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXvrBjkmBynAA61VCktTrYCcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNkMWU4N2ItMGY2My00YzVjLTljM2QtMjIzZWNiOTZhZjc5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1YTQ3MjBk\nLTA3MTYtNDA2YS05YTUyLTVjZmVjMjg4MDFlOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCP1A0snzrSHbyJYAVxk+Gdcb2axW294LuqmP95cM8pPLRngvgHRyxef\nCipMmixWT2OtQsoIy4oguDjpAIsN3RujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNOmfbVZ\n3dj3URoJRTeKNt7CDLnqMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIGn/Yzsje5a29xBalv3pkh9WHsALjzBPPSfdGo2q\nVVMcAiEAmSpGO50q2jZQh0c9+F2O5kKktPMrLbyNHQbCs7iGgog=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5487", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5487` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXHu+4iWDg5+KnyHKXv247g3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzNTBhMzQxLTkxY2UtNDhiNS05OTkzLThkNzg3ZTk4ZDQyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRkZjEyZjQtZDU4\nZC00ZDM0LWExMTEtMTdmMTBlYzM1MmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcNP9cb79bIDX9j1Lr7ujc5RakLHGteJ56rBJN4aBezwz0GoPQa3tDgDx81Ot\nv8UnJaKdHOPFSZGtknWx3wZPsKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiPdz7YA933Cm/7iB4kfWVOj3wIQwHwYDVR0j\nBBgwFoAUlc40OYLmqdjF2lGQjJ8GutlOYEMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAw8t6CZn0O+cihp/DyuKYFI1iHSRbAtLc+\nqhd72HKaFAIhAOsIvZH52Fvxpb6p68cnD7XD7Hj+ElmbI3c9oOYCz/cp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUkpkOzDbWdmF4xHVu1CBdIZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzUwYTM0MS05MWNlLTQ4YjUtOTk5My04ZDc4N2U5OGQ0MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5Ro9la2B/esN0y5XvjWty+FZwR590xY4pAEegQgGWcjwf\n5+c2DeQwU+EmMpdbr0LwE93cDgmitC8Al9Xgs5d3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlc40OYLmqdjF2lGQjJ8GutlO\nYEMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM86ygu5jkakfAvmIIbShPwZYkTYKq+dq3EOJKr2GUHlAiEAv2kxNz77\nj96mf5HekjTEVesVjWbHnQQCgTswr6oPpdI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAcXfmGWy5r/mbxnX8xQw7oBNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRkZjEyZjQtZDU4ZC00ZDM0LWExMTEtMTdmMTBlYzM1MmI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc5MTc4ZTRi\nLWUwNTAtNDg2OS05M2JiLTgyYjExZDkzNmY4MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKOu+J6uYMqkYHO/YzglwvFhsmGN/9co1k/bdLgTc5eusFIg0e274IGU\n22P5b0jmeXJUjk7uei0Ik2osWgaoZUqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIj3c+2A\nPd9wpv+4geJH1lTo98CEMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIE+23WgvIQFX8NjQh2mBcpYSN0E0cFXhSsIl/NQN\nz4B6AiB4AjMhGotAJBi+o97qHdMnAP4ZExbtCHE9QEhQZmn/gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5488", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5488` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAcuk1ZhDC+4Eoyv/Z0UYX/CGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2ZTVhZjg2LTZlZTktNGIxYy04MjBjLWQ5NWE0NTUyNjNhNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlhZDliNWMtMWNl\nZC00NWUzLWI0MWQtOTYwZDRmZjc3NDg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnQky3OA2Rq/kynBGv0QHc5JxP3muXi25WLXuJeKIiQGgfLWQvJC28wNf8gxu\n7TqVNRu534xcOjviIjCO9FEF4aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM2teY4uQbukdAvtBdMV8UrA5FAkwHwYDVR0j\nBBgwFoAU9eGcp3JGw0TToracaKGsG45jH0UwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD+aw7GhVDQ0HBq7aVg1X6OFxT5\nkzKNLCtCeP95gVPclQIhAKltUCSTtnyj3LTb8no4i3eHkvGGiJDmz0Mh55wtpcFg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaooAMB3MaDmLRAxmo9JxztXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNmU1YWY4Ni02ZWU5LTRiMWMtODIwYy1kOTVhNDU1MjYzYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgox/eEqN6v1zqLXRyqjTrvtTSKl8ROGVEmhp/y61vzSRx\nG2AOX2yCazH51tdp+p9TBMwWPhAROjfjbyF5X5rEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9eGcp3JGw0TToracaKGsG45j\nH0UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdXrsSOU35+JC5UVRDfBDLXmKrVA9HVOiVfZFj+36R7YCIQDgu847/Gz6\nJOPztLTa4x35K4bpLfKV89c3ewj/QzhHiA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAerNuq9QRFppjKK3BnWhK8l6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlhZDliNWMtMWNlZC00NWUzLWI0MWQtOTYwZDRmZjc3NDg4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRkYWIwYjM3\nLTg1MmUtNGU4Zi05MjE0LTMyZjk3NzI4NjRlMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG2HRTujoSpWKZuKeUkdvQ4aVpvzk9tSUQUJpMi2A7QDPYizBAi5TwT6\n1GO8L0/XNW1eeGq5gOnwh8Q1LuFqAMyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDNrXmOL\nkG7pHQL7QXTFfFKwORQJMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCVXgCBMohWjjjNJreNHSa/JGCoIGugKPZyFnO7\nQLkULAIgK6P7pYl9YufneciEcM6jUIITFrx9UhyAiRGz/oL1nGo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5489", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5489` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAd2aVF6sdby2JmfSwXzR8RZjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkYWI3ZWRjLTdiMTQtNDIyYi1hYTM5LWY5ZGIwYzY1OWVkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWIzYTNhODctYTM2\nNi00Y2YwLThlMzEtOWMxNWI0NTUxMjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKwVduz47/BqMh5Z4noITOxmqXf0dYdLCegr+4Jr+fBMn2nuQmNavae1uPuWj\nf6Y6XoZFAq59ai9ZjvMr45pVsaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFPIygZ8S8pDaSSV1a1bAAPznWewwHwYDVR0j\nBBgwFoAUjkhUguXVXEAgT9Xm7Dl2mYzDQqUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJsmkl6h\nqxMTmYKdWrPGe2tc/80eQjqNGGJlZp+TttFrAiAc4IqPAmZLZejCloGzzSgfSfU2\n9bkY7UQBNu5U+G220g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ36eHUS6nc2aZwEBdAgTo6QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGFiN2VkYy03YjE0LTQyMmItYWEzOS1mOWRiMGM2NTllZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTqdFN/LvuBRiqBR3Xc5C3BGDSUIfX9FRvOCuXNJE6EfED\nI4ImEMXNuyZBFkdqlwk79oujXvAJk4nTUh05KazVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjkhUguXVXEAgT9Xm7Dl2mYzD\nQqUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaBhFBqDpfFJ/V7QaOFJGveeE78LiAmxT6H2kBAMbkuACIDzsqMFWTyv8\nv6FIIWYumjzl3xTTBgfVS/rMaZbFNjx4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISASjClfOuH7ds4bPAE8vVKzQuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWIzYTNhODctYTM2Ni00Y2YwLThlMzEtOWMxNWI0NTUxMjgzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1MGVkYWEy\nLTZhNDktNDg3ZS04Y2JhLTY2YjFkYzIzMGU4ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLrBL8hiyy9iFsuckYPG8qQXFBeZ4l8dhtKosgpuwt08n7b35dUG8PSr\nSPwp7BBmwfdfvGu/hxlBLznQn4g4V+2jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBTyMoGf\nEvKQ2kkldWtWwAD851nsMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCoH2HRCRgItpdMnkf11BcwK95I2ZVM+IoY7UWc\nTku+5gIgPtFYn7kUtknTevlS8N8GSFSPsHu/UIF0CaaDNqAQTC8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5490", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5490` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAf8aDN5kpT/VT+yl0XeBcB5WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MjM0NGRiLTNlOWQtNGQ5Zi1hNmNmLTYwOTEzYTdjOTIyNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJhOTdjOTEtNTkz\nMS00OWNjLWI1MGQtMWJhMWJjYjhkZjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv/1mol67aEcWx5x4nJ0HTSwt/dQtS4RtdD0tVCWhciocTXVwNNIR2FQMzNWQ\nQ8KmLtR/sYu0BSEKp9A8705HcqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXMRQnSRFHnw9oAzso3r2XEydcLYwHwYDVR0j\nBBgwFoAUEoGQB+pkzor09FceYwHvQAfZlmEwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgOY375K10\n+oRpEVFmwnXhJ+xwXTnpBX5/8Qfj6G08/EcCIHVfgdttgbxA/BVmBmMtJj6b2oRv\nU+nFRziHt3NTldxW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQbg2BReG32LWYAcXyjPilxnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODIzNDRkYi0zZTlkLTRkOWYtYTZjZi02MDkxM2E3YzkyMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZPKEQnHoQPTOm9iLQ/9WCADsqPlbsGxestuc1iZigZ1Yi\nfNiQhuMeRxGHZn5cyZPYtAUGzXHzgloKuvXUNIBGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEoGQB+pkzor09FceYwHvQAfZ\nlmEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALnPbgRRBrsFoIsEZdnb78ia9Y+DKhg/4P1lx+BUTxWhAiAFehRFmllD\nfslwdomgt164/dtl6JIysZakOwoYrhxRiA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISARu1AGmY+73MNdIQ0GrCMo3nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJhOTdjOTEtNTkzMS00OWNjLWI1MGQtMWJhMWJjYjhkZjRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFlYzY1MTM2\nLTY4MzAtNGZkYS04NDIxLTQzMmVkZjM0OWZlNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOeykejFBIeuNh5jvsq/cKiTnJ2RbYU+JXtCJwrgdkNCRk9crIw14QLw\n+uZCcos3veNBvzJB13oTVCeGnCy/zj+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFzEUJ0k\nRR58PaAM7KN69lxMnXC2MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIGLwyFLuLulKt43ZfI1nqjpo9PVWBRRC0OEGhX+I\nSKr/AiEA32Xk3srM0pRCqy9/BzjXbi/xICiDBXU3VJbG9A95YKY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5491", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5491` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAZG4P7+hY+Ot/EoDYUDtCd34MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliOGIyYTAxLWZkNTktNDRiMy1iNjI2LTg0Yzc2N2Y4ZmViYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY1MmNmOGEtMTM2\nNy00ZWIyLWE4ZjAtYzZmZDE5OTQyODI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbqgL5p+VBaF/+IMIBv19GoFkwH+5aQ4c+LS6xGrrlfQr0BlPh0rlzIqxnFnY\nEDaBZJiqmTvFRlFk5PHSSHUnZKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb/QC0Qf3AwcAHexayFHlm/XLHGYwHwYDVR0j\nBBgwFoAU/T2JLcc9tHXd13BwvKchtFXX/rAwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCID3zckDg\nTzz5LsEYjnMFXTM6Or885mEhoBj3c6k46e8LAiBPixPlQHeWvRK4wjECpGv7Wtgo\nLPsdMX+DxsGq6KGWlQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYV/mnDQC+65J9sOW/swvuBSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjhiMmEwMS1mZDU5LTQ0YjMtYjYyNi04NGM3NjdmOGZlYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3o9AZu4o8GWsbI15MHgdysptRfALt7VT1KJbu/fMktyLr\ns+8pgbU/RANfmPoenrtMAr4jTcortEPCrRYn4d0to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/T2JLcc9tHXd13BwvKchtFXX\n/rAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN6C+M3zrIdp+KaSTrJlA1tB9sxQcI2DuaQOLUkX3qBrAiEAsrxhCAKK\np4EHr8sCye+P5r9ROg/hIArQAZfKh8lAShc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAfeRpD2fp+BDgnweksu7CPbrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY1MmNmOGEtMTM2Ny00ZWIyLWE4ZjAtYzZmZDE5OTQyODI5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI2MTFiZGVk\nLTVmMGEtNDdhMi05MDY2LWFiOTExMWEzYzVjNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOlgiavMfFH/irFV9xfujWqfj520XO8bbvgmjdlMXwoLxoDP+VcBbUYf\nHuGIOxzq5i0Iuzbg/1g/H3ljEMT5JvWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG/0AtEH\n9wMHAB3sWshR5Zv1yxxmMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDo1lsL2bOPl/TYjoluqBx27kHB/DWsiGZIlzCo\ndD+nxgIhAPh6ypowXnmvwTMFQFB4RsA5Sn9dOaTCGucbrvpL097q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5492", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5492` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAVbngtOzqDgjWQdyn93YQhK6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmNTk0OTIyLTBjODUtNDgxZi05OTRhLTE3NDk3MjA0MzcxYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhmNWQxODQtYzVh\nNy00OWIzLTkxYzgtM2VhODQyYmUxMzIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDh8MGd3gZDWlcGKxRrm83zqCOawwxy1Ik+GWgSdwTe+izWpnijjj0iRis6Da\nKi64GltZekYid/ynvBaWj4xruqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzzAHKxwaYkJUcKrjJyvI7nKWi6wwHwYDVR0j\nBBgwFoAUCT5P3tzIqY5xS0JyW2EclZ52Xp4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDfOfDCI+3sGY6Cc1xNCukjBNlmwddTnf3yD0lJ762foQIhAIpwdV94\nbW6GRPtfAs62/V/mJ25uHCOv/j5WGg/tDEB5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZCu9+HsCfCv2eSqC6vmL6DGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjU5NDkyMi0wYzg1LTQ4MWYtOTk0YS0xNzQ5NzIwNDM3MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQD8gXYtcrIBdeZU3elYTu4flZNtYBgI2lC9+wEBRF0t6/\nE67yQO1CB1Bv5cMhVqS/oo59gvEVrvEVQZ2zk7V1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCT5P3tzIqY5xS0JyW2EclZ52\nXp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGqCGMOLjg4TzfQXM66S+H773dcBpwYeQe9tTWGcWCBcCIQC0oUcZ9a9u\n1v43okDJVAS2c61FAt6p7Bve77gDQu6i/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAR6YWHFUSM312EcvRD7xeg+tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhmNWQxODQtYzVhNy00OWIzLTkxYzgtM2VhODQyYmUxMzIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE0OTU1MjRi\nLTVhMzgtNDcxYy1hNzNkLWE3NDEwODQ1NjhkMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMEewadBb2j5Hm2IOHwRvreRg26gaybed3D/hA2up29ewVVAzwRxuzoh\nzLWszYYj9NovxGYzhrCbtsA1iEB2fOyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM8wBysc\nGmJCVHCq4ycryO5ylousMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIGogJ1JVODy/SR4gOYiqnRJIBbCzWKau6ZC5SLiM\nFF8RAiEAl3j5NDFjm2QBidtXeW4IciQC0JQsDrPuwy7ys6WlfNc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5493", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5493` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAe6vvJcUvQqKMb6tv5eMKwTIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ZGM1MDM4LTg0NDMtNDIzMC04M2Q3LWM4MTFiN2Y1MjA5NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFmNWE2NGItNDc0\nNS00MzdmLWEyYWItNDc0MWM5MzYyZjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERQsIf/sJ3Qp5ig2WU+W+dAZORfy55+egFffrrCVS1va1O8NSUy+jnrKKPH/l\n8URTLhuJIrE3G6EGAblcWuoz/KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUh+/coWPlj/msyYJcnkuGwdW4FQwHwYDVR0j\nBBgwFoAUolQq6psrwjgRVq2Nbfa9Nnw02CIwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIAuHO0xLSsWoYk2VWC33YmWXB47dw9qiJdJpAFaKjnNtAiBU002gIi0n\n6ZURM05Y3zEFsJudfeQLisP5ic4bQFrQag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARK26iMP/jSB+/oasc6IVQhSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWRjNTAzOC04NDQzLTQyMzAtODNkNy1jODExYjdmNTIwOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlRKSu09beMM9u2UKN8BxYKb7VErPAnv2wkjodxOzLPP83\nucnkvhflYpB/Xj67yt0JsoyYJjyIiIY780MTFRfuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUolQq6psrwjgRVq2Nbfa9Nnw0\n2CIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALTQbLuQqCZ1yahFGvrirOEC/2sbmHk0CzLxPNHMAYt6AiAsMPi+gIXb\nyt6NW5Fo31Bx70axheHsnAsaTv+TpLwp3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAVErq8mO+PoPeCpYXW9eHnXMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFmNWE2NGItNDc0NS00MzdmLWEyYWItNDc0MWM5MzYyZjRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQzYjVkYzJi\nLTg0ZDUtNGNmNi1iNTRlLTA5Y2ZlN2QyNWVkMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBTI0A/qlCEt8p74vUZ2XXui97hyx0xtu4wZ6DaV/oIskuJPq35/VNhK\nto5gtYWE8RlR4naRUYvmEdFQh59sgjujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFIfv3KF\nj5Y/5rMmCXJ5LhsHVuBUMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCQdqZQ7YPwyD4WJ6+IHSM4EySGfLIfdhy+6aVp\nYsNCggIgQ/FyQnuvfkh8EjEggdbGakkYvpVcDjto4fDLZXd+eF0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5494", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5494` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAdab3oJUH/h6yxfEzP7ihqW6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhYWMzMWVlLTNjMDEtNGRmNS1hMGE3LTJjZTEzMGVmYjFlMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU0ZmU5YzMtZTY3\nZi00NTBiLWJmMTMtZWQ1NzYxOTg2MmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElIcFzvn+OiXDUCdJUexPk4jdMH9fNkqkvVAqxbg93brbak5Fq1z7xY/a9QDt\nukYt2WzCmc46mNcfcNCYiFF2taOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvpnL4hgs2t66Mt/B1BmNxnVv+howHwYDVR0j\nBBgwFoAUSJbQhK4IA2sUCq4KtkAck1uwTEIwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIBapVtjbVz0cKXXi3S7WYkTQeUX5QtfRnUwftfuqs9JlAiEAvMpV9QDXEHAT2Z4e\n/BSen+wU01pYYUsbBPmmKCFTZiA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAawcPbdtbYkeHou49YwHR883MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWFjMzFlZS0zYzAxLTRkZjUtYTBhNy0yY2UxMzBlZmIxZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7SOF8DAyYOmWrn5Nl2bhrInbfygWsqQ1N+0xaSK7aGmrm\nZkIFk3ZTcmal6qdO7IiCVk0HiU8wCy29ev0uWyiuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSJbQhK4IA2sUCq4KtkAck1uw\nTEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI9EAgvJhSGROpQD8eK+porcjQ4bs3SDgeKxuaxapWpIAiBuOXH/tups\nCI/1GkCKyO7Du++VZmcKlPCwNxySQXekRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAZdxQMaWfhzLEmze6h6jS3wmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU0ZmU5YzMtZTY3Zi00NTBiLWJmMTMtZWQ1NzYxOTg2MmViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg1OWVlNWRl\nLTUxZjEtNDUzYy05MGJlLTczZTdlNzBjOGMyZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLD1zlKNr3vYRjxfZbUThVxo47BwUjd2PZ6SsbkgCNqEw7Ynm1ygObml\nliIpYyJHDNArYStMKMGT1tr3XKR/qfyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL6Zy+IY\nLNreujLfwdQZjcZ1b/oaMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIFA1GAXtSLFd4ELUk4BFCo7vzcxXiGTQ7FHTz7w3\nRP7HAiEAhIQwAOx70893LN5rWwq8J0k40z49C+cl5ivFtvxp9a0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5495", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5495` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAefCgmh975uiDDt5bgX5VR7FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NDM2MDUzLWQzZjEtNDM2Yi04ZjhkLTE2ZDg2YzE4OGRmODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWYwNDQ3MzktNDky\nMC00MjQxLWJlZGItYjg0ZDZmMmU3ZDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa0FbWJYemhiE+Z2VDczYwRcWSEJdsKmBlnd/8m0ThT0RvotVoOkAk1DiGjpT\nU45hIs8nkecxGi5ZcFwLzIMjl6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFZmj63xfmPkJjccpoeZU6BGfVkkwHwYDVR0j\nBBgwFoAUzGKU8iNZDTg4iO/lZ8dVbu/7VXQwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQC4O2xGP91H5W0sHqveD0Wo3GR+A+3tprsnMVDJtS1zAQIg\nDLZ5RbK+KPk2ab94jhUNL13aQVkIVyx5Pt5fCDqBo4w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc8eBPcWQ/Z12JVTtJ3oqsIbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDQzNjA1My1kM2YxLTQzNmItOGY4ZC0xNmQ4NmMxODhkZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxMNjEcEYjnDaJCaUNBbGo89gtgzyakjSMr8NRk9qHRFgt\nyLFzMSmFhuvxIN7cDLhm6gXnwKW7rJvFb+T6K5Dto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzGKU8iNZDTg4iO/lZ8dVbu/7\nVXQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALwO/BbDkTUdoSNc2BYnJZrbNFjUgrqFRVUcB1GCx2LdAiBmGCUCG6+/\nIH5Y9R9PoGP6Q2HPK8TCETbGd48cM3vcQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAZdPEPbRWTKh1ECKadf5tKDoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWYwNDQ3MzktNDkyMC00MjQxLWJlZGItYjg0ZDZmMmU3ZDUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcyZTA1YzM2\nLTFjMmQtNDZmNC1iYjI2LTdhYTZmYzZiOTgwMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFyiQ18PMSRwcxKOXKTRFfWumFBkkTXgDLG2+4LKUDDr5mWxkJBADae4\nYbdHrlpBT1IvBwehDJrxyTPpVcR676qjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBWZo+t8\nX5j5CY3HKaHmVOgRn1ZJMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQDs7n7yBR+6mcESoPRndpIekn80BSewDtppv5+Q\ng3sUCgIhAPj78KAOFIk2zSrFI9avV0u0n25Emv/CEiTYggb01kEE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5496", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5496` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAUhLqKkcd16dD0vMtLQaJN4XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNzMyOWI3LTg4OWEtNDA3ZC04YzczLTBmMmUxNTI3ZjQxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmEzMzk2ZGItNTI1\nYi00Nzg3LTgwYjMtNzE3ZGI4ZTcxYmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFpkUSF6srkwxJVZ5H/ghbHNG8JlPPtoBuXSZU6QdSCvCWzwnLvTrH6NOlyIa\nyiU9/TzcuHxzrqzMgQls1+Puw6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU59PG3oMncXifPTqBwW6JhgmySikwHwYDVR0j\nBBgwFoAUqmD72Shr8d/OQYdYmPEwnDXnbe0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIDHQlDBLjeMvNvYBoahGzTVTm/U0n9fqs2yhBm1ijGsAAiAO\nsFH7JSuQAMEuEvz8ACrrMUmB13AuCGy1wEk6XMKl3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR8fu2lI0Antbf/br6Z47qIYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzczMjliNy04ODlhLTQwN2QtOGM3My0wZjJlMTUyN2Y0MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQp3iA8Cjn6P0ImY60TkF7fL7FDeI3QVroWZO+1anwBRyAv\nGg+DLbeBjJ5bWMG57Y7S9eh7KaOWxKMyT06Na0qno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqmD72Shr8d/OQYdYmPEwnDXn\nbe0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKRQ1CNGEUB87Af9OwLEHiCCvGT7i952a9/UIkofYoT8CIQDPhSgUIsF0\n0oodwO6OvRUZWRrKle+I/Pth9FO6wpwqNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAUxUv/Vq+2ltBwyQz5YRnpPaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmEzMzk2ZGItNTI1Yi00Nzg3LTgwYjMtNzE3ZGI4ZTcxYmI1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY5MzUzZWM2\nLTMyYzYtNDY1OC1hY2FhLTljMjQ1ZWUyOGRjNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK4MA32+7yEDuZAItF7KAIOo3pK+31rL5cLQX5CZv54lrI+6wUTA4JZy\n4fnKMZFGAaN5nwCNOYZozT87D3w4gxSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOfTxt6D\nJ3F4nz06gcFuiYYJskopMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCID6/ZCKRzvqm9w108GAbD0LH/8jK/mAHrnhNBgxq\nqeVEAiAH8V5pGritYo6zrTI0GpNYsPYiEfrPVSgvBls75yuOEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5497", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5497` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAb125vTo5Fz6/LktrM0Qb4y9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNmJkMzkwLTA4ZGUtNDIwMC1hOWMxLTEzZTVjZWQ3MjI0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBiZGI2YWYtYTZl\nNS00NDc4LTk3YTMtZGE0M2EzMTFjNTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaQRYJRW88fJcCLhDrujIt69yurkgSiSIktv3cshokqrXD1efuXdgKJJQeRd3\nn48d8BGWpk2L/fFCnkFHH3wdS6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkUscQjCTnsytU5LL3IXx7VvllcYwHwYDVR0j\nBBgwFoAUoxyl6+jhWx1oaRd86/fKUKlykzswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC8Y7pICK++\nEWyzrT1sgZo0YKYtknQZhVQEpxpTV2ygowIhAOicplvmka1QjRWf/G9mkREi5aOI\n1oxBWrk4Vj/MMIjf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAec6Duwj3C1k0Ppuq7R8b613MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjZiZDM5MC0wOGRlLTQyMDAtYTljMS0xM2U1Y2VkNzIyNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSiiGVCCeX/9JHIBpQiqKMUUJ8F3KGtnnIYdKbP1DEXNqJ\nnqMjMwUYv95j1TNzRJl4+nAqJKDmfXytOFhYPHeeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoxyl6+jhWx1oaRd86/fKUKly\nkzswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDJGPFv/uS8yGH3ku8Rj3lnYT30uX+qJWCYP2boWY7e8CIQC5KnM2p9Vc\nciTbHFEYAiC49wHD4rjG0eX+PnN2XqbQtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAUL9nVUqALgxTJ0XH0R3FwRLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBiZGI2YWYtYTZlNS00NDc4LTk3YTMtZGE0M2EzMTFjNTQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUxOWI3Y2Nm\nLTg1NTAtNDUzOC05ZTZkLWFhYWMyYmQ0MTIzMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKL7S/QkJVwMtn01PIO/Yw9WCoXvRMavinpJSKJTUmW1MYtpmzxEc3aI\n1rrnG4WYYlFsjLG5DeigcIIEQL2H9gmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJFLHEIw\nk57MrVOSy9yF8e1b5ZXGMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCe8me9boWqRT4V8aAoAw/aviPY1DBUkPnE/2xx\nqBhp2AIhAKNKHhURrk5M0tgGzesUnCMz63I285d+ea3xOIkBBjsn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5498", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5498` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARCfTqhEu/c3DDLmXGbO6mquMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjNDBhZDgwLTcyM2MtNDliMC1hZjFiLWM1NThkOTk5MzU1NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk3N2E4YTMtYmE4\nOC00MzljLWFiMTYtYWFlNWRlYjc0YWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHXyA+XXr2et1rhP8Rr22/DdGzqbp7r5xiGxuGSoYJVbXRivc6qxv/ejvJk2C\nwUWmn3l35TDHKOdyFLEvLq1xUaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgtBkxGYXNAzwXoHlB084BpSqF5swHwYDVR0j\nBBgwFoAU3e6R1mkNjlMTPxh5U6an4fTZdYcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgNY1ITY6/0c/xqgo3nOGuWBsfBn4P46PhPtXENLVQn3ECIQDS5xmOqXPE\nxMjEdelIPuRvPCA2l8eVjPKYTEkSe0RPKA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS05dhGnQhLyIorZSa4XFoK6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzQwYWQ4MC03MjNjLTQ5YjAtYWYxYi1jNTU4ZDk5OTM1NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1p6BxWvStogvePKI193ngfQn9F+p5TMzck8ObGulMeEQ1\n87N0ycz3L0hNkHOXLiUcpSH9Ja7PxjtEccQQIXBAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3e6R1mkNjlMTPxh5U6an4fTZ\ndYcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVSO5Iq5BlL9KuxKgvUKsnquoc9Ev776ugO892YZ4hmsCIQD4eaRrYFni\n6ztFzrHmLa0jaGQnKDCc3SqzL4EmiubOqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdigAwIBAgISAdeqFXtaQxZFNnWT4RuJU/dMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk3N2E4YTMtYmE4OC00MzljLWFiMTYtYWFlNWRlYjc0YWRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNmOTI4Mjdl\nLTE4MTAtNDY4MC1iYjJlLTQwNTU5MWQzNDdmMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPw3qnO9sWqr/ktfJdJAJImpOdlA5r1AXmqdIJWpvHZfAz9dQjkabfFd\nyBWRwYIitoWuZ68eGAMX9FAspJXPa2ujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFILQZMRm\nFzQM8F6B5QdPOAaUqhebMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0YAMEMCHxEUaErSEf/x1CMgmJ8A57cHDmMCIRJkdwxFBPN5\nZBICIEK0nknyPiFqzr+IAlvSkQL/WnqrKFAE/aoOlhqkCVmW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5499", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5499` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAZRE3SDA0P5x2YyvcgWX8lV5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5N2JmMjQ1LTIzNmMtNGZhZi1hMTI2LWUxMThmMjI2ZGRjNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ2MjRjYmYtM2Ri\nMS00MWMxLTllNTEtY2U0YmExZDgwNGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjiO1sA8t5BA9u94l2oyuha7zi6IjoK2xlv5JjBktMoothkF+ZtlAEjgtosXo\nQ5GMy+xjSg4FuyOtLAJHGtiak6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxXj2WNuwtgJzU/EH569dQGtQ7FUwHwYDVR0j\nBBgwFoAUN7m7ObOWqtKpOHIVdVrd8n8K4+YwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJVf8zjO6g4jym+FVwzQgkkg+2X2psSvyuSXg27n4YVUAiEA34AbrcsM\najORijXx8q6qBA2+HYpExt596aC5OcVwfXQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfuwHE8dSzIZTWaNWYCDORcnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTdiZjI0NS0yMzZjLTRmYWYtYTEyNi1lMTE4ZjIyNmRkYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASK9JfS6dsaO2Fzf+bSPTprvLvLZGgAZMecAdBLQA8aPqaP\nLxIl6j5DMEH/UzNHDqZEMXMtvU3fgVkmT8pAC6uto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN7m7ObOWqtKpOHIVdVrd8n8K\n4+YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK8mfAkg9WBdbyloo6PCM2Aca3Kj7HUOVIVhlt/tcmW7AiAilKGBNPFE\nl40TJ61x2IumwTsRsxhTbVf7DBOUZ70wRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAVzDSYGFIt8VnVbUbPlkSR97MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ2MjRjYmYtM2RiMS00MWMxLTllNTEtY2U0YmExZDgwNGE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGViMmI5YTkz\nLWY1ZjAtNDdkOC04MDQxLTRhMTc4YjM3ZWUwNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOlchAd8k56Lz+bRADR/XXNOH4R86TuMXWR/ts3vEDKiRSe/YFHXaslh\nI5Qplzz4c0zCSu+1MVp78kOIsUhynDajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMV49ljb\nsLYCc1PxB+evXUBrUOxVMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIEOBHUHCYuMImem6dHTRf6YW6GzBYZPupaR9jMS8\nRmPKAiAckP+XuwE+0UbhE0z0DSAclWF3PCk3/Ssw3Wqc+TdGig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5500", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5500` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAfNe+TQey3vPAM9GFj9aIVsRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiY2U2Yjk5LTRiYjktNDQ2ZS04NDM5LTE5Y2E3YTY4YmFmODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTUxYjZmMTAtMmVk\nOC00YmViLWEzZGUtNmJmMmQzNjk2ZjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH6bLgUuWlSggFyqfqXDw1pHNhUpTgqHLr/YQiseBEgSWbAy/ZNaasvhGgyBu\n/+12S7lgFIika+YqZfvh/MjdEKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkAOChSxZR4j5UoQOyvwrIxORUyYwHwYDVR0j\nBBgwFoAUdohBfFAHA2Ceyu5SDfn7ASSbq8gwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCXawpMY7ETfyyQw5nFBYi2XsNgVpel42bdhCS5afWUGwIhAJIBcx7z\n6lUM4uaA4YZNKbGqNDLmisDdPKE2q2KS0bWJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVxt75sKYvvJg2y4UKSzaoMKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmNlNmI5OS00YmI5LTQ0NmUtODQzOS0xOWNhN2E2OGJhZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASE4ClbfxKpnqaF595C+bJh8wTfGS3TnUlPF2jRPZFbWl7N\nMTG73aEP/MlSQ8vhr2XT6mcMn34uh3Vy74BXwAmRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdohBfFAHA2Ceyu5SDfn7ASSb\nq8gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ5NBauZPzKDLYeJwwhli4Ik+Ej7VifsodgPzVRtFMXECIQDOY2rMIOEp\nK69NyFBZF8Lf4LjE+bnLFmkj9LbaUtruKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAakNtfbZ5Yo8NLGQLSWBa0B8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTUxYjZmMTAtMmVkOC00YmViLWEzZGUtNmJmMmQzNjk2ZjUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE2MGVkMDY2\nLWEwMjItNDc0Yy05MWU4LTg2MDU5ZDgxOWM1MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAvHZqwnuFW3u7slqn0HusmrJlXkc/O2zjmxDjnWeDOqT4/X6KWlf5zI\nLdBV0P1E5gmYX3dSQfsP3J3EGSfJvFOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJADgoUs\nWUeI+VKEDsr8KyMTkVMmMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIBohBdZ3isZVHHYrY3uSDl36iQs/N96liH8tpneF\nLFCXAiEAkm+F0u0D17ORt725lNQ4qQLt0uX5PizMA+2/pH0mY3c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5501", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5501` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISARgGrSFS/bVlmqWrg+MRd/OsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZDNhOWMyLTZkOWQtNDkwMi05YzJlLTBlNmVhM2E2MDc2MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjYyMjA3MmUtZjk5\nNS00MGZkLTgzYmQtNGY5ZDgzMTRmZTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7QM/HkZ9Af8JSArD88/2VxnfzX5fb1ZLKtB6eBvBEP8AZ75OoPqzz97Y3u4+\nG2xaGPRIUM+IcPBQeIo+7n4/FaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhV9MJqyu7Er2nx2L8ywuS8emj74wHwYDVR0j\nBBgwFoAUeYXfdhtFTZiNP+c06gOrLsQ7o20wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCIELNI9jUJ6t2MXha22yeU3MlU5aqTdJbqUkjM\nTqSqTgIgAXs0TN86YiHDNwR0n0/betDKqxomTdqLy3W6AUvQSec=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcoN1PieMvYeluYhvtFw1fFeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGQzYTljMi02ZDlkLTQ5MDItOWMyZS0wZTZlYTNhNjA3NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRCRAI0I+LQEPYuDd6oOwCNoJ2NA7ShTuiXKf1qLzRrlal\nxhJ/yGuGKKGrc8ksjBH74vbtC+eyioTE84LidBIgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeYXfdhtFTZiNP+c06gOrLsQ7\no20wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgO2TiyOxIOt/ouuX9Qch/iQLhQlQMjxjz9/jp/sL0XTUCIGiDB+G4LZZj\nJIRq9THEWvs0gnMAbi/C2SQQD8rxmj1L\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAQZsQEChpyPEP+FTRFeuC0LDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjYyMjA3MmUtZjk5NS00MGZkLTgzYmQtNGY5ZDgzMTRmZTNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVlOTg3ZjBi\nLTAyOWEtNGUxZi04ZjY4LWU2MjlhYWUzMGI5NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH+NsxZ91zsVjVLmrmvuawpfzHBTVpUuJBL1fnnDEHKiGYeiIPalecOu\nMeHbTYjQgyYw3fZl8v7ZexiG/va78hyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIVfTCas\nruxK9p8di/MsLkvHpo++MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCaw6hg18H9DwvTTnfW3HRPnocOjJJiQxFlvykT\n15xFQAIgbiK7Fqtln3qgrZTditMJDjA7C/9f1Jd6GLYscIEinmA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5502", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5502` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAbROHyIpURW/6NQihVokAkAHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2MmRjOGIyLWE5N2YtNGZjNi1hYTBiLWM4ZmY3Zjc0Mjc3ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY3NTQ2YWItZWJj\nNi00OTY1LWE4ZjctMjBmOGE1NTczZjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtk8hH6WXoSqhfMocaXFbBIPeWq8FO0U5S3Sx0f6BF4mjBgA+vMn41Mk4+LMA\nRGb9SYHNrw6JkiWy70mxWD7CbqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAcCYPx0nqgRrDRbZfo61pbhhf7swHwYDVR0j\nBBgwFoAUExFUIv6ZmBGOovXBYMNOw4+tNp0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIARBpqH30ko3wEa++KaWCHj2VrFyiqU7THh78Lhe\nBJEFAiEA3/RK83fuSep3aqhPRQDdYRPXYyBkmbkLl5FwQvLOpTo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYu3RhYNObcJ1Aa8q2qwXF4kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjJkYzhiMi1hOTdmLTRmYzYtYWEwYi1jOGZmN2Y3NDI3NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQugsg7UTf9GsJaEJckxqIxV/dPMOYEdEa7rYEVMz6NGuGX\nBw/eDZptKprzh29vlImgXykC0K1I31nXk+nQZqNNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUExFUIv6ZmBGOovXBYMNOw4+t\nNp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZGtQr/RNEOEWSZVsdKMe8KqlwXcowHD2Lojq8UmXKUACIQCbT3L8MavG\n10x3RcvOTJUuYoi/OqeN2eO2s8dhkycPZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISATIEr4BM+eD+Mc5cD2KfBDmyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY3NTQ2YWItZWJjNi00OTY1LWE4ZjctMjBmOGE1NTczZjRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE5ZGVhNTYw\nLTU3ODEtNDlmYy05OTc1LWZiOWI2NmI3Yzk0ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH21er5LlSI8waYHRvjrvO0SV4YMyDUiHcD5mflVecq/318SQgNV2iXt\nFRgDAgxYLS/mB1d2Sm71ktgBX0jmaISjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAHAmD8d\nJ6oEaw0W2X6OtaW4YX+7MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIFtdR/hFHjQxXBOajODPlj8uNrChp0nzH0nhT9lL\n5tQyAiEA4VW1+d9cY0UAuPnHqKXP9svc7HTfMpTS89onv5eHodM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5503", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5503` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYbyWng9Lrhzdn4SZhKCBjGVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwYTRkYzIyLTk1YTMtNDMxYS05MWExLWVlMDZhZmFjNTQxMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJlOGIyNjctMDRh\nZC00NDQyLWFjYjYtNTU2ZTM2YzkzNjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE3sWMKz4ytt7jmKDYGZdnvi8cserYw7mCuvjBX5+c5ATFKOHgXeXpuDj4BVY\niuPMQOZbGQVuUg3r9vLxVBTQR6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2gKkqeISXq2zRfqhYc+EvD9SXnkwHwYDVR0j\nBBgwFoAUBj9hvmKUvaAiV/6opLFBTDfz9agwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQD/w8O1139Hc2v2JB9h0aENWL23p73c2C1OCvCevAy32gIg\nQwhkbS6vcx7UIMojMCjC82YyZDE4oGnRIeZfXK8Muxo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdHzXwEHFdW50ifflnK56X5+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMGE0ZGMyMi05NWEzLTQzMWEtOTFhMS1lZTA2YWZhYzU0MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKAom6CnpP0i4Rr7JU08JJpgR7WexJgXAm/UaBxVakXekm\n69xndypEsVnkouVENqwSjtOKt66oF2JatFEDN/Z3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBj9hvmKUvaAiV/6opLFBTDfz\n9agwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANyI9II6dMaGWRKXRS0OXkmG7qvxYVFmZHxNRkYFNQu+AiEA4/WjSWC7\nP/WbaLmrj81/p8TTTYobZ122aayHHM7eYQ8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAS5kog7UUiGFfnDpcL2bJlKKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJlOGIyNjctMDRhZC00NDQyLWFjYjYtNTU2ZTM2YzkzNjMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRlYTI2OWQ2\nLTAzMTQtNDc0Mi1hZjZiLTJhMzk4NTgwNzMxNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGAuZyV1OVpabe2GZBgJgiDP8MHD9QJIwEMUFmOpBMugP4RWa3xuOUJe\nsWRkA+Al+TzBRmhOSoiIlij9Xn8RC3ujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNoCpKni\nEl6ts0X6oWHPhLw/Ul55MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCkQZvq3/bY9MoC198bbAYOq5okKf0NEMJqNkI9\nVBYXVgIhAKJ1etftqgEYL2YTLCj5dRYWJ/g2uaEbITFs840xd0Rp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5504", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5504` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAdN/o9hUNWiv4nGXhlECZrhRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3ZTM0NTRlLWI2ZGMtNGEzZC04MGE4LTFiMWVjMDYxYzkyYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc0OTM2MmYtMGE1\nYi00OGVmLTlhMGEtOGVlNzQxZGRmZTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyUdVbXzKDsbxSkv+X1kDyney4HoAUs+2+iMdHPGd8llDFoSfZE93SKbkKmQ2\nOLe2coizy+yRGUGrKRUjrOjMU6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCa6z7vv5PES4IcbtkAcrd4e8b/swHwYDVR0j\nBBgwFoAUYI+jLEx6Y8c7w4SzJt/UIKwJ6nkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDfy0eGzN5FPANf0N2cnv2zyHNfySaU\nbOS9D6hCaWkc4gIhAOO2QwaB21/UYZ4qMUUNYoxbhDVl6niGlVH+2Urq5lmv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd4RN6Oe+gBePYOT0DNaqm66MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2UzNDU0ZS1iNmRjLTRhM2QtODBhOC0xYjFlYzA2MWM5MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYvxIO0Ye0fKuJdXNE6LGPgRf1DvhO6ZrBwiIDaDFt34Xe\n/LYi1G/dxMslnMe47R6Npq/1GbIQBFFbRY91kSgTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYI+jLEx6Y8c7w4SzJt/UIKwJ\n6nkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI/hnCDVT+QHdt7lJzxg6Z+5+bk0apFu7jZnD164pN0QAiAb7ynyiExl\ntRn0f7OnephlHhyk1nznHegesg9loL+88g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAfCxFDiCHYZ0XN2nONTnEfoSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc0OTM2MmYtMGE1Yi00OGVmLTlhMGEtOGVlNzQxZGRmZTBiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA0N2Q4N2Vj\nLWM0ZTctNDg3OC1hNTFjLWYzNjNkYTVhYWY3ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIgc3KjvL3M7RXk8aDeK8u2HiMcmDslxuNgt0EtTmR4YvGegaKpu5P50\nHF/JPij3r/llf3TaYJ1iFiKijmdCQWujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAmus+77\n+TxEuCHG7ZAHK3eHvG/7MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCIGDS1usy5LS8+F5ZhjI3+k7be86hxWmSM1B7eDuy\nqN64AiBbS3GqrbdS4Dgbi/JRGjuYS8gPH1br+2/VGNUecIhFyg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5505", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5505` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfSvgtkHVa0fR1XMOIboZ0HqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlNzEyN2ExLTZiNjItNDA4Ny05N2Y3LWE4NmJkZDkwMjg1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZiNTE4ZjgtOGNk\nNS00Yzc2LTkxNGEtZWQ2NWY1YmJlNTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3y9bx4/55tmw1mI2IGxTcP9fEAWOHdH6rQ9zmD85/aN3bBehAHfcAa5sOEB0\n+cJGN8R8JPCH5ZtES0yXYe0YQKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC+7NKaJFn051mpuaY72S/UhzR8AwHwYDVR0j\nBBgwFoAUMemKYWHarVDJXTXfJ2SAntn0ueUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDji3+NASmt8cfFP4RY7+WbDbnWKOrE\n6krGSlUKQESDygIgO811ZqXOHvXqaQM0zJIs6Nl9u4n6uEVOjaq32lhLwB0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcsZr7+cWYaQ0+AMGMfGSmx0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTcxMjdhMS02YjYyLTQwODctOTdmNy1hODZiZGQ5MDI4NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQS64usjZTLZVRnyfE17iFWhYQYxsfAHb27cA6/ASB+sZuE\nen5c79C9Qs5yVZRPq+pRKKL6zIU6n65ItMZM0MMUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMemKYWHarVDJXTXfJ2SAntn0\nueUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAuJd4MJLmrB0F74oxX7DWgf/AV0Pm6Q73pN9s3m2szoCIQD96KhVCSJX\nFGB5JQoQQ/akQqGcmsyVemWIof6EvrIotw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISATQkhQnvNRqtMTWYSBHg9rPnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZiNTE4ZjgtOGNkNS00Yzc2LTkxNGEtZWQ2NWY1YmJlNTYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI3NDA0MjM5\nLTQyZjMtNGE1My04MzNmLWVjM2I2MzNjZmFlODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEbgSEgTMcxwihRC8mHkTkMXPhrr30Fd7NKPs6Zr5mD+vy7ucDdsGSvF\nH8uw6Swkw7IAosS02uAnprjj2FlhXTejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAvuzSmi\nRZ9OdZqbmmO9kv1Ic0fAMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCb1NUrQj2VHUTl7QNv6iNkanUEPCBPeXQ6dRoV\nHJDR5QIhAPNQ7SkrNaiGKDHZaFIF2x3L/NuCZdUX5amzy1rN1LWb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5506", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5506` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWxhpFiVMLAfw5SblM0SmBD2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiZTdlYjBjLTZhMjAtNGMyZC05N2MxLTFjZDgwZDBkNDc5NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWE2ODYzNTktZTdm\nNS00MTRhLTg3YTQtYzgxNmIxODc0ZjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe78WhHm+AqdxQfeI5DspKGiXmdfZcgXQg6b/2J74jEHq5PIGVjPJ5lGN09ng\nTSkRXQkCB2D9SRF4vXwZu/JFuKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqYi5Etu27Re8j3Xlis7buS6BUg8wHwYDVR0j\nBBgwFoAU9aL10FBWCUgD7KxEsv15CFdOjt0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCID/cKcByj1Sl\nyVfweKXaSLhaq5jNsOnyDT7h+E/j6Be4AiBXFntyr7Tl0dDDACCUNoyj2YVCe4lU\nDGtz5Arjr6CA1A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATRZbdWC2erth/dzl1GMmJQiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmU3ZWIwYy02YTIwLTRjMmQtOTdjMS0xY2Q4MGQwZDQ3OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGVLk6VuFDy4tYq8o/s5jyC1qHyZ585f3ma9sQRfjVU3zq\nm0dVGFT2n0HcM5mCoY6dw9BHXY+qaDEuGQ18r8Z5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9aL10FBWCUgD7KxEsv15CFdO\njt0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIo/ZZ74YsNM571CCVHCeOVc4JYHvEtaxh9MpNwbXhLsCIQCZ5Di3h03u\n+3TEfGL9ahza9KbZgTCTUx/8VQCl/p0kFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAQ9PLk5K1/ZkWAM/95EncLerMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWE2ODYzNTktZTdmNS00MTRhLTg3YTQtYzgxNmIxODc0ZjdmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBhNjZkN2Rl\nLTUzYjktNDY2Ny05M2RiLTlmZmJlNDM5ZTczYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJRUk6iadAPH5aOZfGBYzQElj40NwzMFlPlgtiyLTGcdkkAQxBnC3diw\nwCUXHZGowlq+m8kWEHjb4xSG/neTIHGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKmIuRLb\ntu0XvI915YrO27kugVIPMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIFZrIJjElK3TUpipWDvia4Y5+pgvIw6PUJoXcWms\nRpKgAiEA7lsNuCZZ4/DwJTOk6mUuiAtUEihkMMi+VealsQF1XIc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5507", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5507` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAdnAErFTYcQIUdyO+FKXmEu/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0MzQ4MTA0LTYzYWMtNGI0Ni05MWFiLWNmYWIyYzZkMmVlYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGY0Mjk3MGQtYTdk\nYS00ZDdiLTlkMDAtOGQ5NDY2ZjhhZGU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXHjjl8SDOcPkaDyqzuf7pCxmOtCOJsVPPyvxG1s2VwpR3HJ6ZBYEMBjaQMoL\nXqHRKiL2frsGawddW9lMDg/GB6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd1Ur0oTrnJ+WIj4kYcqMJ77FDaAwHwYDVR0j\nBBgwFoAU6KD1gWcwoX2lVbjoFs4AwgyL++MwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgCBm9X0oPm/DKTzmzNY1PJ5V7EL2PhEylMDvu5CxZxXcCIQDYpb1k2L5j\nv0TKc3FOVh3XhrGVVpoue/MDjpeRz1k8jA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcr+28cfW6cdSJW0Nd+TM5nUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDM0ODEwNC02M2FjLTRiNDYtOTFhYi1jZmFiMmM2ZDJlZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNovR8fLAn/FLAzLbhG5+u0rMnFlssrhKm/n6eGHEfHVG1\nk5yTc+b7sLc8NTt0GmmITcVQ+YBQREg5uhJmMSwno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6KD1gWcwoX2lVbjoFs4AwgyL\n++MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALjF8CTFmnuj/tE0ygGOVuSIgRTzSh3B34A861YxamrpAiEAzL5zk9gW\n0MALRvekl0WWLwsun7nIi7Xu53kzAfGabrI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAZFt5Xqdg6v5W1SAnuUfhKeGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGY0Mjk3MGQtYTdkYS00ZDdiLTlkMDAtOGQ5NDY2ZjhhZGU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYzOGIxNTc3\nLWM5MmItNGUzYy05YjRkLWIzNmZjODQwN2E1YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHwQWRE7RIKOwNCtk4hUf/HFBmAbYBbnI1KlXft2JvL10CVOOAPG2Std\n5XzhCJBXSCRiBmznINXSLOLCsIfMmDOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHdVK9KE\n65yfliI+JGHKjCe+xQ2gMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIDwDVGXQeMCyITJRsaIrkV2VpIXib+O3s5qCOKZ7\nOiYVAiEA4UA5QuNDkdYpW3SWN8gpRTGkbMQjplTS63BlMQcp0Nw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5508", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5508` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAQBiZOeGc06k15+upIAFSs+HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwMmFiNTRmLTQ2M2UtNGRmZC04YzA2LTViZmE3ZDZmZDFiNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q1MTg0YmEtMDM0\nZi00YzFiLThkODktYmNiMzhiMGI4N2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKOUgViNxysOvSazv3qNTYHcr4OfneF0A4jOS4D9RESNsHPj9fAc2cfbP3jyK\nZBtBf1AUvYFEI2IsvZb99i3FpqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzeJ9VRXMRmMB+vNbGMQceapEz68wHwYDVR0j\nBBgwFoAUbGOYG2pAPDHOrhn18cef1Bc2L4gwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgIGA71HLRKSyGDAwYOAsRLOdzis62wEbdkv6aL5YGzdkCIGvnyZG9jrib\n5GqePQaOGrhvVOR9qnoS0LB3T0/2rMJn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZqzaaHeGuE7UsnzKCbN8LD/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDJhYjU0Zi00NjNlLTRkZmQtOGMwNi01YmZhN2Q2ZmQxYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR66d4q3aTrIiRw7tEWQcCIbCSOJ5UQAd5IFOwfIUXXcjnl\nsjVc8SIDezNz4RDGTfJDKvXsaqylSAxHgKkbcw18o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbGOYG2pAPDHOrhn18cef1Bc2\nL4gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOaQRBIS2ApFT45TdiMFhJNROc8vX89hXsjuPArobAc9AiEAzTfrLAAk\nWUy1r022aW9VfjOGTUw8AZYkQ9r7GuSi9IY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAfPKb31ygXCU0Qux+P+nBTFWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q1MTg0YmEtMDM0Zi00YzFiLThkODktYmNiMzhiMGI4N2E1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZiY2UzZGEx\nLWU3ZjctNDIzMC05NDIxLTAzM2VlN2NjYThkMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFh1bV4lHsdjxOHVF26hqVU4eLmgBk4gCZBmLvcSRXWJfDvzyCyE2RHG\nfs+9o0kBX1bpvZqOgGvmHDuHW0f8nVCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM3ifVUV\nzEZjAfrzWxjEHHmqRM+vMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQC9yP4iL2qVrzd4aZsSCsgU3nFvTTBiAXCjvPzN\nQTpFtQIhAP4Yp8+LR2HHF9Khfl2ADaNNa73WSJgN4aWuLQIA0Bp/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5509", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5509` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAVThnoegKdq7xijW7N2yZ18FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1M2E5YTMzLTQ5ZDctNDAxNC1hNWZhLTQ4OGEyZDcxM2YzMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM0Njg2MTAtZWRm\nYS00YTIzLWFiMzQtYTQ4YTM1ZmFiNWYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZE2WHhDmHqYUg717Bki7tO9WH6nWpA/W12/fGprr5Jul6CQA1Sj3Rjlro4OB\nLVfAF1tWTMlclKa851gtP+Py5KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp5mdHaZUGuPKepfZOcn3vSL0Q0wwHwYDVR0j\nBBgwFoAU0xeQ8iieNBj5ehJ8wcKYZ0jRj0gwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICdIMnfYtQDfvg3aj1eUUV13rJwEeuprIe8iOwHBOZCGAiEAkpn/g2rU\nnt0tmXqyfbIbHKNRVndqUGG3yE/Wf0ldPJM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWiqAgeEfHXW7fRpS+9mfW75MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTNhOWEzMy00OWQ3LTQwMTQtYTVmYS00ODhhMmQ3MTNmMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnLidlN8ULvTUurfF3/W9Itbt3fkgvbfKw/rrg1lCtABQT\ndE0MPbMQDqCUzSKftkibvemNSbuiV8Sh0LHGPXdqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0xeQ8iieNBj5ehJ8wcKYZ0jR\nj0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTGYz1fttEvwmpYMmZEmPw9N6OwNSbycC8fzyADFL8B8CIFK/NnZzI1TZ\n3n3/5GaE6XtdnTPvI0dFGrKbkmWNfbDa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAcp45jwGi15O6YFhND0xSo+mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM0Njg2MTAtZWRmYS00YTIzLWFiMzQtYTQ4YTM1ZmFiNWYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5NjgzMmEx\nLTk5ZWEtNDA2Ny1iOTQyLTdkYmY0NzNkY2I4MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAWNf5bVOZsu18tKc3pAFe/i4b8amFkBNqqsuWDMhlBxPLwhs2ibGYM+\nGUnRvQYGuhE3IMkrLy7Ba1pGZ94STQ6jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKeZnR2m\nVBrjynqX2TnJ970i9ENMMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQCGNtL0jJTGlSLoCD5QkjOPbeUU92L5VsbxnZgE\n/aJ2JwIgO7pjQhIyGlAVrWuD3qV4kzuBRpfPMwR18N0O3Q0ybnI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5510", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5510` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAcIMX63sY7rCu5u24RFEfF/fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlN2EwMmQ3LTE0NGUtNGM5Yi05ZGY5LWVmN2IxZGU4ZDFlZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ3MzM4MTktNDNk\nNS00NTljLTljZDAtMGViN2E5NzczOGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkv8l0Hz0mReBvnGiGO+lXD5NeND4Sg6wZgDHfObfd6Z8f+058QcgybVHy2We\ngUNqa7Yn1W9R9GI6G6MavvKnlqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjQK5xW8uPvQ01fQE0b9wF5OjldowHwYDVR0j\nBBgwFoAU08RHtmbwb3eCUJwhDnxeNLPjGNcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBOC3+wdPpMPJyNjf8MH1iB1HIOfRi5DUWZjnvj9\nMkcqAiA9jRDhHvZeAoHbJe++hJ55eSByQZk+EbHAaST9AKo+Lw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU6gUZEUPjE51wzkEW3pM+4BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTdhMDJkNy0xNDRlLTRjOWItOWRmOS1lZjdiMWRlOGQxZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATu5QlTbAL891xQdAle60gzvozuBJt+tjpLv04SzY0qwNE+\nyxXJJ8zC7v+6vt+wBigqyzibVwm7x129v3OK4O81o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU08RHtmbwb3eCUJwhDnxeNLPj\nGNcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALzA//iB5v36qqy56j9BjaH+5W8y1zo4WJiv6TrO/K3OAiAmZZkHdePi\n3gCDpApVCo+RXMmUBPgqL0oCrxLeaLPdWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAbigJQh/TEZlJdL3bv6WJyqBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ3MzM4MTktNDNkNS00NTljLTljZDAtMGViN2E5NzczOGNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYyNmNlNzYx\nLTNlODktNDIzNy1hMTM1LWYxZTI4MjU1MzJmZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOdLhUfgjfnJ6GYvMLp15DiPy70oJk4NvwkI/0AoPLgbhGj1/Wa9g/21\nb/IpnC8w3CBALfEc+j06DfvtXS/NLEGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI0CucVv\nLj70NNX0BNG/cBeTo5XaMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0kAMEYCIQCE/kHGeikytPRSlFK9cK5RPxOlHaUdQD2jd8oW\nFIq3aQIhAI6jcCV0X/uLI3YASNA9i1MnTAJalrCjxKYcEeK+cVHW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5511", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5511` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAeEFs6Izomg7zdv44zrhuurSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1YmYwNmVkLTI0MjEtNGIzMS05MzRlLWQ3ZWVjOTMyNThlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc2NDJmOTgtYzM1\nYi00ZDc2LWE0NDktYTliZjI0NzRhNjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEivdDTns2ZBGzVEfAJlzhvIZtMtML2TWKsENzS7angv4w1jAZlc/H1ng6d/pg\nVaVc3UCJLmeu5STJ+ija13X/PaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUALv12CbPNf0QN6iQkCEwfMBG5QUwHwYDVR0j\nBBgwFoAU2fZsmkG+s37i4TPQ6vLHZyYQpBYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIDDhF3sekVhiSb6GUXh0ndBkmfxrlWQKukuTXW9K\nLOanAiA6LPKIabH7AUu2cuYHSsV6INdfWvzSR1nKg82f+0qXcQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAQOTuVFr/WYZwTnVC+miFFnvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWJmMDZlZC0yNDIxLTRiMzEtOTM0ZS1kN2VlYzkzMjU4ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+h7tnFTs6rH1dzsRIdrA5IqzXC0GG9sG4q5mVmzsMpTXO\n6sdgXTj24nUGiqESSvY886BnBYVMw/4on4pBruz3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2fZsmkG+s37i4TPQ6vLHZyYQ\npBYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIfN4JqIx41+uZU7bERlHiR41OFz/P3zznV27SyaHqH+wIgIeZpwNBUxWSF\nXQyBB3ukn4nkdZSNRWdZ5F7sSDJVQgo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAd+SA51Rj6l6UHioKTX1GATtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc2NDJmOTgtYzM1Yi00ZDc2LWE0NDktYTliZjI0NzRhNjkxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY5NjVkN2Yx\nLWI5Y2YtNGY2Zi1hOGI2LWI2NmM3YWQ3ODVjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF5YrkYF55zcqQz2zaRHzD1emGxthdxcxuJ9jqkGl9exABElktheEnBO\nvEPi82w07q9mUlcWrRvGWFm3C1VPQCajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAC79dgm\nzzX9EDeokJAhMHzARuUFMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIQDQd+XcUkaviV5uBoFgJWy1y3VhL3o4GOY97aeo\nNqxO4AIgEjPAjjOZDiAA38JTVbe4aEbROFnd0XGDDXnocM79OHo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5512", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5512` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVOTNaOkql7SX8mkwIOfuGdDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MWU0ZmY4LTllNTQtNDg2OS05MmI1LTFmNzdiOTljOGZjMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTgyMmYzNGYtYmFi\nZC00Mjg0LTk1MWMtMmE5NjY4NzllOWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFixgCmagrChOnaOaY+7Vy9kZayRQ5EDX7oiFwgVfBNwjPY4uwY6vDB5TbqG/\nQOrgXmoLqavUbcBwaSGcgNpniqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV41h8VqIXGVdHIM5u5HI7IrEsGMwHwYDVR0j\nBBgwFoAUalzKj+tHllBagbgqZn431X/VJ+0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIFBTETMsllZLaqieHrSooMsDG5wk6nOH9J8dPWVEep+/AiEA\nkCbTdld28toXaD8dvO6qV0dbVbaS0VOgelYUxg9Acic=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcldPFaNagYv5CFjGIb0t4VAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODFlNGZmOC05ZTU0LTQ4NjktOTJiNS0xZjc3Yjk5YzhmYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRjTRJd1PtBgTiRZW8i3WZWnxViDg4ZBnsQKFnx7Eylc1N\nJgw5Mri7LvWKX9M42zIUIz7jqx8xAAF4sRhhMVLpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUalzKj+tHllBagbgqZn431X/V\nJ+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPHfenCJahcoSScCWoNG+Oaz/Y6ArkpmJnmyR+UDe+fsAiEAgPOXva2B\nhQSApY9JvUypJU2Dm5C6Ihq1I783zX+3dJo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAa+xWe3iDzL87kBLeCLuLlEGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTgyMmYzNGYtYmFiZC00Mjg0LTk1MWMtMmE5NjY4NzllOWZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGYzMDMxOGQz\nLTk0YWMtNDlkMi1iZDMzLTI5ZjIyYWQ1YTY4YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDtRirX+eQfTxxd+pnpWaCEsn54VxQtKQzH+U2bMKSLUpqOo8J00cXur\nvE7FkAbntydFFZmbHtF7wmbMe+Nz3kqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFeNYfFa\niFxlXRyDObuRyOyKxLBjMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCICrsmlT3M7BIgvesmCz1PzLUrI8CVzrxBlNVffRB\nAbvNAiAtGLdduvO+vEI8Z39MEsXBosR6gAUdmZ7unDNrjgA2Xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5513", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5513` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAe5dZm5BviUTr/4vEXZClPmZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNjBjNDc3LTExZTQtNDExMC04NDAxLTJjMGQ5NzkzMzZiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRmNGE0YjEtNzI4\nMy00ZWI4LWIyMDktZmMxZDVkYjkzNmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc8/Jlv+gn+JfpUR/MLLmNYR4P8AoK2aUBSyu0Ucz/rJOglFhK3oNMANehrbi\n35AGjOCLVYdMISzYsCk/YdrzmKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/wyyQKM0UH4kJOiXF9obKMPjkMgwHwYDVR0j\nBBgwFoAUXEJpiLFM5tk4tr9e9ucoLu5KBj0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDpwtbRSQnAeoYbCet2Z6V9nMFJZSfG\nG8N1sElnke2fqwIhAIoQO8FoEUV4ao9339tdHCa1yIbKVl22fC8lGZ0mWwid\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT0HO1j/bxYcAPpJoHHZ2p2NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTYwYzQ3Ny0xMWU0LTQxMTAtODQwMS0yYzBkOTc5MzM2YmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgNNmgGC2+HR9+6bVbzt2uBhaavM8rfV0MeY1qDJrmI2nL\ngvHVDHX6H/qz8+FKUnQfUVeUkoDBTY9zSYG8YTwho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXEJpiLFM5tk4tr9e9ucoLu5K\nBj0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANvcyWOUrLrDBnL5qIu3kzpXUz8GruAh9YvheX/A1NZ+AiEA+hWQcz+o\n9Md+d0Dy9mcDIdilrRLjPi19NdlUC4fgSlY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISASqpQiQdwG4iYM22D3CcDJ2OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRmNGE0YjEtNzI4My00ZWI4LWIyMDktZmMxZDVkYjkzNmM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU4OWYyZGE5\nLWFlZDgtNDdmZS05NmIzLTFlOGNmZWVlM2U4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIYPxfKezEnxnwvkZdbzRBFp0t68IRFJqTl7/E3UmdmpHzrSTHf/gbkI\nnA2MNXjWPHA/0dxE7or1ly1rNA8iwRijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP8MskCj\nNFB+JCTolxfaGyjD45DIMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0cAMEQCICWqGvgoxhuBL5PppVQSGQKwIFPRDYMm3vaT6ulQ\nsb+rAiAxvCCSi+nynP7fXLC2XVNtkTCO5+itd/X/HNlBzPmpeQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5514", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5514` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAeH8H7u2GdD32UeOqMvSbSC0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3OTgyYzEyLTAyODQtNDQ4Zi1hMWUwLWRkZDk2MGFlNTgzODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQyNGJlMDUtN2M3\nMS00OTU3LWE5ZTctYjE4N2ZjMGUwNjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0xmZbN8dDYXH0IsK+Au+aVrejS/jdmm+pousUeeRwvsV0rrJzuz5G7qksb8s\nRdHcSkIAOFtVtQQomwiWd87dAaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI7ycE75fZ+x8UmOkWACYUgZZaFkwHwYDVR0j\nBBgwFoAU6Y7nPBtJJXmjNj950RUIniy6WhIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCICBWIcjg9RgrdJI+sUZ0Udn/uYjsROnf\nJtjnLyv2BjvfAiEA1pBq4ThSJN26d5a9M7x3M5gHwXbFxE7TDZzxCovCWZ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ74X9AobpTxF2CgJSx2E8haMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzk4MmMxMi0wMjg0LTQ0OGYtYTFlMC1kZGQ5NjBhZTU4MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATor83AHGYT2VlqEKd07v9aLzfoigL0rRHzuMiN2Z6mYxkP\n0GUfUCOrXgK7PgChLDOdbLHGGKXmH4E/bzFJtbobo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Y7nPBtJJXmjNj950RUIniy6\nWhIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJe7v9NRW82oKpScrz3a4R8npS66ukje1fCVWFKs4PexAiBk/QOn9f+q\nx6gIJJphYZQcnRzoOqBMA+2Jnl3Q6SxY1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAcLEAmMkruybKJB9tuMsc2nRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQyNGJlMDUtN2M3MS00OTU3LWE5ZTctYjE4N2ZjMGUwNjlkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY2YzJhNzRk\nLWE3YTUtNDNiYy05OWYzLWUyOGM4NjlkYTQ4MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGpbG+PNWQeXmajyr/UECTLL5CCsc7CQnTs4k4aqmyRKZKR+yYRWdB0V\nq0CuIt+3Y5WdRIlfUW8Eo/Pz3UkcLYmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCO8nBO+\nX2fsfFJjpFgAmFIGWWhZMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwR/AAAB\nMAoGCCqGSM49BAMCA0gAMEUCIFD97xs7sJmRXHFFJbXaoRtpK81z6U0h048Gqvsu\ncyNwAiEA8mPybTDqoz4wfChhppYK5UEo509MurDStllQx+tkHQE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5515", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5515` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbjv1fWcGpmKjb5S3kDay5VPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwYmI5YzM2LWFlOWEtNDk1Ny04ODZlLWE2YTQ4NmJkNmY2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzlkNDYwZGYtYjZj\nMi00ZWFiLWJlMjItODU0YzJhZjU4OGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHKlxhsHzGb48kqIwIP8XxgTEWEsg0zkWVzcQHJBC8YZ+XbpiBd39iZYcXQ1W\nx3Lz4+10QZr3be7IvThbMaqL0aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOcgfUxL6tDcLKCS6fE1FfxRCIogMB8GA1UdIwQY\nMBaAFCVr1CtLGqbLZ9j5p7r+Gk8FSDkGMAoGCCqGSM49BAMCA0gAMEUCIB2Mh+u4\n+uoTJVW9WFsxMRd7YRdi7PtvjdekJY7sD2xQAiEAmfoxznnWWk2nUZsYBm84+aTM\nz2u6JQyuaZKnO3iBDJQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASE42zv7JrAQnzw9bb+AQnR7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMGJiOWMzNi1hZTlhLTQ5NTctODg2ZS1hNmE0ODZiZDZmNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQe5VnYFiSTmpDmTSg1SuXWw8sF9Oohwn6k7h1bk5apVqHZ\nU4kiQ+xumAQlxY1Op5jHZXzE/3w2fq4OsoUGPknpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJWvUK0sapstn2Pmnuv4aTwVI\nOQYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANUWiWZnkKFIVARSSPioiI0JOg798GlZoF1zz4HFT1z7AiBSG2ei/i+H\nrW4y3bTf/IPttwsybcA7qY+8zJ7Osz5xgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAVd5NQ2XfWeVdfN2KA9RB2bAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzlkNDYwZGYtYjZjMi00ZWFiLWJlMjItODU0YzJhZjU4OGVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEyODg0YTc0\nLTQ0NDMtNDllNS05MmYzLTU1NjRiNTc2NzQ5MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPGqttmp5FL4OPFP0hrEv6/jzkqW0De5jto30nELIbLZz3ePpAoiftGV\n4hciWJITsu08w7Bs6NHIoQQNyggOOfujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOcgfUxL\n6tDcLKCS6fE1FfxRCIogMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIEJbnQE4EL7CDnQwxHEbLDLwpy4SuR3x2BatSiBS\nnLUhAiEA5uEka6v4OB3zGQbnr5EAHO+IODhO+Ll0AYw3/UwMVHs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5516", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5516` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdZYs6Hcu6B4Z9yJThGe5FvTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmMDFiMWJiLTVhYTYtNDY3Zi05M2YzLTM0OGVjMTBkYWM5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg1MTRkNzktNWEy\nMC00MmYzLTk4NjUtYmY0N2Y2YTIwMDJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED1b3pvTYuuL2c5/gR7M4EfnPYwbZQFa0cMmEl1Iys5aUVBNr/4WQsrNXaaZy\n6AsrZC0y5lWroAtsvsJuQRLVUKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBi4Myr+HSpKGPOlX/JuBQiGoFAXMB8GA1UdIwQY\nMBaAFJwfyv3mwfFFM5LfrPJHVcvoSKowMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAslcSQKOpPzpoJsOCw/1D3qaQZlcz31eAp\np52P2CiU/AIhAOPMLpIJB+zAvpppEZ9vOqi/vMyPoKFRqruanvjUmGLz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZHY+gPT48EJwmOjMep+c0teMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjAxYjFiYi01YWE2LTQ2N2YtOTNmMy0zNDhlYzEwZGFjOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfISieq8dzWgKfJE7Y4ZxR+5YWNnvDBnR7mUHNbCVAzYC2\nj42PHyRO7lDgxpej3e0CGApj3088znuExxq4IRnFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnB/K/ebB8UUzkt+s8kdVy+hI\nqjAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYTUcOQvWreVeKKgOzCGqvl83loYJl0T0RHt/b6xNqOYCIQDrAOx6RFnO\nXVDRJs5ACagi8spQZc/3RAvaeUXbx+E7vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAQhQ6v7O5cTuTv5bFxDhkSVtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg1MTRkNzktNWEyMC00MmYzLTk4NjUtYmY0N2Y2YTIwMDJkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFjZWFiN2Yz\nLTA3OTAtNGI3Yy1iZTczLWRhNzY4MzRkOGNmOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEV5LAnBiXrBIZBfwT0aTovZCpYDGJkQQm8vAThzBpOwVOCapA90BpVG\nOw4qzJdmeWrCiHE/B+gmbgEgUuLb/eOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBi4Myr+\nHSpKGPOlX/JuBQiGoFAXMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCB0i4lYE7cl8oK4QAgkQO+ntOHAdXdlRpBkOXf\n3xpfZwIgOIaaAX2tnOc/ue8SIjge3Z2hVAtpcvrxhCDnEImVY8k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5517", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5517` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISATSF3mrFKrFTNe4Iv5w7F1smMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNTFjM2Q2LWRhOTItNDYyOS1hNGVjLTgxNzY4MjZhMWZlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJkYzM2NTUtNDNh\nZC00NTFiLTk4OWYtNTRmNjAyMzFkYzRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVNhv5h2H/AWhCEsMg7wu00FY8d9Hhf4KfXDQYCHv0jRZWFVDVpXa4jrpXUo8\nd1bmnU9BUaDOwdIqxh1BCAuUX6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFA7XX3OECJzltDpaPloog53gI+cOMB8GA1UdIwQY\nMBaAFPzfVCqm2T1o1t0uRi8ft6IKfC15MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA/nGmQxd/Shzx7w9cBnCZDhziGP1TExov\nBubJtpDOtQkCIQCRDbMLutSf9/eUEOV7W1w5xDskZ2ed0ISpkje8Q1N+HQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY3axCqLuY2YKBmO5lYFsX6PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTUxYzNkNi1kYTkyLTQ2MjktYTRlYy04MTc2ODI2YTFmZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARg6zwyzG4n8A453ldRFg5sD2HA+lFYUj3BPaQqVv5x9CVN\n2cYI4dadZrk2WiqrGbv9T3fT9K+llRoHkN6fpLG9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/N9UKqbZPWjW3S5GLx+3ogp8\nLXkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP3+XNQSIKcnHcnytIv+1PwFv/kNMj9GYTE+nC0zObXtAiAtuZ08tFNN\nsITX+x++rHxU/vLNAmF4zUHxcSX80tRHSQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAfqcbDmuV0enS8EU4YW6HqA8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJkYzM2NTUtNDNhZC00NTFiLTk4OWYtNTRmNjAyMzFkYzRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUyZWI0MTY3\nLWRjMmUtNGE0ZS04OTBiLTMxYWIyNzllYTY2NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ1pVN/ujRHD0jHNhef8tJ6EsTt3MuhtcjmBeuQ4m+U9P/OlD9d/i1gN\nBncP/jTgMbZQEKO5XTVQxsFvrGrIsGmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFA7XX3OE\nCJzltDpaPloog53gI+cOMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCICN4XAR5DLgFJb6UARu9flRuPCx36m8u5486d+4h\nDw32AiEAh9SRRXM46aPeAWO04a1p2z2Mo76DtOEnYqfmZvqEUQc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5518", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5518` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAakPS53qR6moW+d428LJiOV6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzYTU3ZjdjLTQzMTUtNGE2Zi1hOTdlLTY3YzFiZmM2NmI1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjlhNzA2MzAtZGQx\nMi00MTliLWFlMzQtN2Y5Nzk4YTVhYzUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo277SUfsM7TNTUcuEaLjW9lj2CBoSysy1Grm77XV9KC0v85NY1R2FhZwroHg\nEo2wVO5OdL4CLaab/Mh/e/24F6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSEPriXKYbPScQ+aNG+5blBU+xggDAfBgNVHSME\nGDAWgBRNBVROYb/hkvO2RGKpDc7YRx21ezAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDaBWqJSHeMrBrLvKDk1Eg/E770aExi\nVt7H1LXCnOQWOAIhAN5/bTjM9vrWk9UUQn8bjHuIaO0uNT9p8jcrSaNVawE7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbJuod80vU0p71PX7XO0QCmXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2E1N2Y3Yy00MzE1LTRhNmYtYTk3ZS02N2MxYmZjNjZiNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMeDP5slDg9++kgdq8HkiuZdesIvw+FJQqVSG2SQ3tyCdT\nWA7bC/wTxa1u57ReECvBEWZ6QaB3385Lajqj87xGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTQVUTmG/4ZLztkRiqQ3O2Ecd\ntXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKduKrjt8l9VbTlTrme6DUrk/rFMkkmlej4yjfqhllRdAiEA6VhBB0nD\n4Yqjq5t64eoYGMK9pqfTXMB3nFvI1rM97tM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAfdOYggd1vC7lD9bCeMN1FSAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjlhNzA2MzAtZGQxMi00MTliLWFlMzQtN2Y5Nzk4YTVhYzUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdjNzQ2YTQ5\nLWVhOTItNGQyNC05NjJlLTlkOWQ1NzJlYmVmMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJhALcV1bugqaMQN9KEvvhgjVNdGgI68qcPPsnahK9FIHubrN6bLRBpc\nt7X3Mro5IPgwa4SvgIt7DbAfDqC0uFujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIQ+uJcp\nhs9JxD5o0b7luUFT7GCAMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIH0qYn9fqF30VMtH/thnQIHNxKbFe5B1Q+3QMI+j\nMb7cAiEAx9+3xl4RAv9NfYj8dHdUXGXqq7LGQp+H1hy0wQrrVWM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5519", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5519` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAcPSSgPwTpBjOS+gcBFQQ2J3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjMzE1NTM1LWRhMGYtNDhmNC1hMTY1LTY2MzNhNzU0YTU2ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM0ODBkODYtMDY1\nNi00ZGJiLTkyYzAtYTczZmE2NmI4YzM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhh85yRfhcV1J4YB98AD7C/NbDbYBTxTJSWgPvWdWBM49QLlSfP3q+mEJe90Y\nTDAzeD58uPp6xcOlb4f9m9XB16OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrXgYODSybPUtH7BklIkLUV/O8rIwHwYDVR0j\nBBgwFoAUkP1+Z26bj5oz1ms99B0oO1sfbGkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAn+c5VTGRkfMM\nb56ZR/6basutxWhqxGBMRJlwG6826rsCICgNLdz/Tq0h80fuYJmiRBju5UnZ+5GB\nmZQqQlg9s0pT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARQW7FK+XnBOtMPdXSglM2QrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzMxNTUzNS1kYTBmLTQ4ZjQtYTE2NS02NjMzYTc1NGE1NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUXeS8lD/HNq+AuU7Iq3Jvae6L3vcyWSbt5sdavL5pIUDb\nbSjAcC1KrMPqWvXZhidsr4ZxVrU/W79oYcUbcG7No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkP1+Z26bj5oz1ms99B0oO1sf\nbGkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXYlc9vbSREMiPbAx4VEahasOiF1/zpLp8C4m8X42wHQCIQDHWPT5G5yY\nDN+WHJODZgBMZ1Yykm3D7K7xlARlMkHU4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAWekvEDFtIBlHrxW4R2Wcz1iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM0ODBkODYtMDY1Ni00ZGJiLTkyYzAtYTczZmE2NmI4YzM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE4ZWU2MDI0\nLTkzOGYtNGIzYS1iOGZhLWEzOWMyZjNlMDYwZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAUKBcNOspk4D1vOSrNFAqVA+EYVbmsKQ8KccEmM5tYiLvGzuc0h6xfq\nbOHkqkwU1ZMoTXKoM7PbBoVVeMk6w0SjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK14GDg0\nsmz1LR+wZJSJC1FfzvKyMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIAedrqhtpCzbFmLvUTrAVx87gNvaAFOFP2lOcV9A\ngrygAiEAzUiMDBAmqwRNZoDpx+UAvPfNdseCgECW4jO24ChsBRc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5520", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5520` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAUk7e+w9+gakn2Vkwm5+cRJ4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwMWNjM2M3LTMwNTktNDE3ZC05MzYxLTFlYTAzZGIyOTQyNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQwMTI2YmEtYzc5\nYS00ZDlmLThlY2UtODBlYWU4MWMxZmMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM6rYgFs/dToqDJOYRot7Wih8J6x5vxbfgLgGTRWhYgnYf/bvURit9KUiX22K\nfgxEzXYVZp1MQh8bwcgTSKdI5aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUglvig7i87v0vThvh74rnuWrC6aAwHwYDVR0j\nBBgwFoAU/k4qUjnA+dlrcPUJrQu4KOLQzEEwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAtBtu4yb9L1lK\nd4j7XvxKm1rwrnVNHguJ9nv+DZj3PM0CIGkZI7ucIym0ey9qHq0IH/gnXClAtro9\nKa/kczrdaxC0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeciFSNv2OVBXNw/wO/SyQhzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDFjYzNjNy0zMDU5LTQxN2QtOTM2MS0xZWEwM2RiMjk0MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzTZ4h0LeBj0s90pMgy8bxdicbS/fHTipauuKJ/UgY30eV\nvU2w6aTjTJRz6wL/ml504l6KQm3U8CzUJrDrpz7Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/k4qUjnA+dlrcPUJrQu4KOLQ\nzEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMAWNWUSLReLwVLkN+0juOhgZ1uc3MuCoCYhcPTtDgNMCIAXBtnieC69y\nw2+3hQu6rjYCncbqeem2kWoYfQl8azjr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISARrQGbnFhHrAMALjE+mfJLzuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQwMTI2YmEtYzc5YS00ZDlmLThlY2UtODBlYWU4MWMxZmMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI1MGI1ZjQ5\nLWM1YWYtNDQzNS1iN2QyLTViMjQ1ODQ5MjA3ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEO1p5dBqK4hq/sHfSNkDOhJVnSPfq0RRoTW+V/fngTDwSLHedPkZtHd\njlHSnprshHO/Doa0bnBL4KB7HGvBdPOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIJb4oO4\nvO79L04b4e+K57lqwumgMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIFcVkqTXN520sgSEN/alvJD/EjuSIVCnynxaiBj3\ntNEcAiBZ2cSs/kf46S70+dOPSkj3Vckpj8Fii/kBTNL/IbbrRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5521", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5521` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAeD+VpjovQ8aZRwyNI1t1/0XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1Y2QwMjAxLTk3NGUtNDRjNi1hMzE2LTc5MjQ4MTg2NjdiZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRkMzg2ZGUtY2Nl\nYy00NjAyLTk3NjAtZmM5ZmQ1Y2ZiNmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtvSxCHTsl3pFvwaVAsu6jf76zfIpoV1YhOkKxrM98527RVBNEtNQ9yyw0iUr\nTGoPH4VO7FFx8tSc5GCOAqkgF6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU51Vb09WYf5tszDTI9x7BO9PO1CYwHwYDVR0j\nBBgwFoAUNptQA646U0BBSUdF1TJUvU5grAMwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAuedxLj5IoQR7JO1dZacu\nJeRUeIYUwXNLWCZ6DjQoid0CIEY4ToELMOearz8isvSvJSKMh336vJOp3k2yog/v\nm+WC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaZJ2MCZn7kkEJoT1R2NtmbSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWNkMDIwMS05NzRlLTQ0YzYtYTMxNi03OTI0ODE4NjY3YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwPf/Vrx8EpQOiPhjcSMxcqZbJKsZUfX8k3MkTx/J5qHYZ\nz8Z9Fsn0ZfiO/T9LzbmNdjBXKNplfWZeuk1lVhPMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNptQA646U0BBSUdF1TJUvU5g\nrAMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOXBQ3YG0mO6E0azLYcs9UPiVwJX1RiYAm7AetJrirGTAiEA3hUrmRV5\naAoAi117XOj8ufHnV9hGzzt1UqR3sNqAqvo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISARoO9wyOCfohTx3NDmCa1UgxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRkMzg2ZGUtY2NlYy00NjAyLTk3NjAtZmM5ZmQ1Y2ZiNmZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA1YTUwZGRi\nLTVjNWQtNDBiMi05NDczLTZlMWEzZDY5OTc5MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF7l0hBj1vssLKO+w1MKBQpmvx4QBwrjyx83mxgU871axYSG3eJvV9ZV\nw2myLvJSP/eVBNLUf0TO+mTa+pqoP3+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOdVW9PV\nmH+bbMw0yPcewTvTztQmMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQD0y2+nmFlnI2sYLxP1gNiAFbC4mVmIFocYXHLI\nkjj/FgIgDZVyJR+glGwEck8sEfmWex0wgcSiWWEkVCZhdH2JBFU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5522", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5522` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAawsbwK3XbwkThsB8Newk91+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5ZGUwNmI4LWZkODktNDZkMS1hNjZkLTQ2YTY3NGI2ZDM4YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZlODNjZjItOWRi\nOC00OTA1LThjMjctMzVmNWQ4ZDBiNjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx0CfOpJcKhoqjjqeHBEy4qsx2bpJr0bFOsctQUCkGb6wIUhSfUeyBczTn8pz\n7ak7VXksj3o0+tqzDdKMf8S8MKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaW6ZaLTwJCotaSjgLpoNQkbpegowHwYDVR0j\nBBgwFoAU8bBnrgmbwNi5eHg3OlN9lePq6NowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBBA7BN\nGM9UjCGW1mmCSb/H5d1z7iHwHlKQ25IUog3NcQIgZ3EygoSMhV5Oc3tS6rn1S2Dl\n6yxVUiIFhpKwWDTYeUU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbNznvYSp1CW6Z+nwKQ8XeUpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWRlMDZiOC1mZDg5LTQ2ZDEtYTY2ZC00NmE2NzRiNmQzOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXdMvFKDb5SUAFXksZVSP1qomY+Fcdjt7TytcPkpvzQ46c\nf9+XzYG86fA4VxRn8XKnUosihPRqvuCidZPc6Hruo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8bBnrgmbwNi5eHg3OlN9lePq\n6NowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK2NjStkXJofhw1oBKYUXI8Efl4oSiV17TNz4GgAMkpYCIAn90oDkQeAg\n/Vgir2d6LkyVySE8/2Ia3BEKbsYJScOt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdWykMJJJj3TwDJEYwaX0tQWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZlODNjZjItOWRiOC00OTA1LThjMjctMzVmNWQ4ZDBiNjRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM4ZjJjODE2\nLTA1NDUtNDFiMy04OTY2LTM4NjdmNDNhYThmMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCiyxeIiqf0t3RsFhONGYw68GR8iRL2zRoXH88ITV7Wpi3P+rwXUEJmk\nYXe9/LbxKkZKlU4d0nX6ma+k+jAdGkSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGlumWi0\n8CQqLWko4C6aDUJG6XoKMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDSRqN38wr+6E44DQzrKMLTTGsNepFPzpbe3Eia\nmdWGhQIgdIe7T53A/vjGyt8pjl0dEMbxh38Jr1KEeFxTDti7Jxc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5523", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5523` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAdhTpuCPvjUi9lfjRTSGBM6MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhNzFlYTdiLWFmNmYtNGMxNS04ZjkwLWVkODZhNGI1ZmVmZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVmNTk0ZGYtYjFi\nOC00NWI3LTljZjgtMTM3MTZjOTk5YTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr/RU/dEb7WG0LrlMHakbMk+dLAkNPvZ77oowMJLMnbuibhvNqLtG3MCyCHOY\nqmiKQlUrVSp6+ATcLZQVWCHANaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYItdEKn4onIk6TrqK4UQsckbsewwHwYDVR0j\nBBgwFoAUQ6LVmOs1/RhH0cOX0URPyGM1qvUwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiB1nkzf\nC6/Ua1p/TSWYzC77DkXL0rF0s+8PpiWMCHRfxQIgSWh8My/j37agFhTy/K3nH61a\nbs7PfGm0DEWzy5lMRRU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQuwTvmn5UlHjWu53FaWtLY0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTcxZWE3Yi1hZjZmLTRjMTUtOGY5MC1lZDg2YTRiNWZlZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVOTDGiXlvqkK4qHSKfiLtGEtoUqq4J2Vrqwywc/NbRKLG\nawF48cslPrUJNZK1w4DL1g74LfG3aw1NdiKXIkpLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ6LVmOs1/RhH0cOX0URPyGM1\nqvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLzVG6FvcweuHtKOZkGgpj0BSHhZsVlhMCiY2KxDudWECIByaahW0iJRy\nOSkJbz5YuhNf7de2N+leXcH7J7L/kwk4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAWauNwReVNW09RMj8k8JNeBOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVmNTk0ZGYtYjFiOC00NWI3LTljZjgtMTM3MTZjOTk5YTIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgwZmJjMjQ0\nLTEyYTktNDVmNy05ZWYzLTlmYTc5MWIzY2I0ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIkGKYk6pfUIcrvzMM2qKHZf/9u5+3a22c2DWv/NgNMfGiHGmgGRENYl\n7BzH6IfZifHTKHqI6jQThBriD91tpHujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGCLXRCp\n+KJyJOk66iuFELHJG7HsMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDMYm4eP10ecpFquR5osMSl+pzOoRAB7+8KBQe7\nNt8t5QIhALRCv4HWmhQTqkv1QUQxjW0nGsZdmmoI19BA9DgFbZsJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5524", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5524` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAevbDcnmeRW7bMZfbY8Y0FmUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ZGI1MjJjLTA0YmEtNDE0MS04YjFiLWUxMDUyYWM1YWMzNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE2YjkyZWYtNzU1\nNC00YWEwLWEyOTAtNzg2M2RkNDEwMDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOySkbA7zu7pf9l7Pmd5C0u8PfN1d9DBsKVfLSyAgPQIjCD3i/yDUgVRD9l/z\nOf6pTZd/OhukAje/urWCyPKEEKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCUUZfcDQtnxlZEhcaJce2Y7/jcYMB8GA1UdIwQY\nMBaAFPtRow9dBrcA9CaN1cWBfMFbOajZMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAW2gLKP4Yp0wEDtYNsXPpZ9YS7pPNviwL5\nKteDip+r9QIhAP3HE0u8qlGYU6UWctS7NOECGuJu/QJbe5pZg918jzqf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVknTKbdpr/msvggVz9b20exMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWRiNTIyYy0wNGJhLTQxNDEtOGIxYi1lMTA1MmFjNWFjMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkxRjr1AsqMaBmwO/Qdbth9D8NVRkz+ck0aoLZl/HSfEfZ\nVpIEvqka/w5koV6P1YSbV/qq8MLPmwKv8n8YU1UOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+1GjD10GtwD0Jo3VxYF8wVs5\nqNkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIrUG8zyxSUUk43KNKzf9+JIu4EJFkcHTfau9Uq6oLPOAiEA4gO9uTyl\nGUi6USJZ6Yy+OU48aPgOyqeLrhMTKCXKJuo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAY/IWF1jIreAKyhr39iWzEUhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE2YjkyZWYtNzU1NC00YWEwLWEyOTAtNzg2M2RkNDEwMDcyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM2YTlhNjgz\nLWFmYmUtNDExZi05OTMxLTRiMjViOGYyMTUwNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHNPR9YlpSpPo67RZ1lKILQ204P5mpb/QWfvuIHlXyH/EJXtKkRLHHcr\nK52ECXCuPnQ40F5q4riCiPuYBjfGIfqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCUUZfcD\nQtnxlZEhcaJce2Y7/jcYMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDfGjoI0qY/0BYRt5RJy/29ezsVvO7l9/sfONrY\n9YJ3vQIgIZ0Pol+VpXMrCEG2Eg7slU2D54OthkcubkF7tqPqsao=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5525", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5525` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAf4LHaCU8aVt/dicb7QaI9xiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiOWM4NjdiLThlNTAtNDU5NS1iODQ0LTY5NDIyYTgxN2MzNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBkZjBkMmItYTU3\nYy00Y2M1LThjYTQtNjA4ZjNjYTUwZjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELl4eYT5H0wkGZBOg1wBx7GKzzxqHxP2TBFsRYcMk2rXNcZYnTj2MUAs4eE8C\nke4kD4N8dESqGSTjKrP5/82dKqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX+nfOxlLWNBpLXGRd00WmkWdzPcwHwYDVR0j\nBBgwFoAUa4vWT17A8sWBKnEHi+YkU9+BlVEwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgcdcwIez3D1sg\nFGDxKTwh0Dbi3eah8k3Wm0SXGlLJ2m4CIQC0PLAvgUeZZw1AKSeyhHvpUpyc5dKe\nMIWGkC7Zec6psA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQFoRX3EXAVk6GYBxyDTTji4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjljODY3Yi04ZTUwLTQ1OTUtYjg0NC02OTQyMmE4MTdjMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTTCN3Zl+uzB7oZK8agMOqx/f0+Rq9i8eUUXymWmzcun8e\nUWqQQBEjl1pSZn/w+kOx9au2vYFMF+gx4/ffSyico2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa4vWT17A8sWBKnEHi+YkU9+B\nlVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWsQq8A2QL9UzQM/8rpgTaEPH5e5mfdhiSpcBxRN+VfUCIQCbPwMimRmh\nsU7Q2cNez4cZJlXFzZ12wUQMTwjK8oV1MA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAXSq8kn8tm2LRzB6UIAodSu2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBkZjBkMmItYTU3Yy00Y2M1LThjYTQtNjA4ZjNjYTUwZjQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY2OGU3ZDlk\nLWU2MWItNDk3Ni05NDYyLWExZjg5ODNjZDA1MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDtHBQry57dxbqcERiEpcxtpBCfZsx98Wg8r0CNqwAoJJ3DxQUjXShmH\nWZANhOzCyhPFDa1OQmuMX3kPTjGD63KjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF/p3zsZ\nS1jQaS1xkXdNFppFncz3MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDreOqAXmNxtRbaIsUK/OeMQpdiDK0hve7KTnDN\nKunS4AIhAMbaPxJUwOfv4lNINx3+c0p2b6FgX45wEx6HqUNsVrpl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5526", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5526` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVGMYroBNsQvGrgUHMUmsl/fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkNjQ0NjcwLWVjNjEtNDcwYi1iYmMzLTY4NzAxY2U1OWY4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgyYjA4YTEtZWMw\nNC00NTA1LTg3YWEtODZlMmNmNjliMjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE40+QEbDvQKZaCsTyGw4eW8w6oV8PrFBc6ikDNi7HZnTqHT6h7TfeLydcR5qn\nW9m3E7lzmZtJ4VGp+Jz+1utK+KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWGLPYCQp5u2OH0m3/TSMqcnX50UwHwYDVR0j\nBBgwFoAUPsLds/vucPQLRp+933dta7L6QDcwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJnjyk2icJYt\nGOTJwWtMhMcf2DdjZ3JkFWjD8olNru28AiAy+VSA4pWfsbcRAqzd81/utb55/FUP\nObQJG7BbEikulw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa6N9kavJjcK7UkXC2DqNGENMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDY0NDY3MC1lYzYxLTQ3MGItYmJjMy02ODcwMWNlNTlmOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzOQKW0OsuAe/L/H7mkLZJPrAfnMHMlkKz6pJE8BHb4ePy\nc2ip950kgjPHDPYuNxT9WDHkIt3QKBVtgvMrjMUFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPsLds/vucPQLRp+933dta7L6\nQDcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK3GAaAdzPNB82eOSTlbIuHntoDCM+3831fI+KrLNmmuAiEAuP6K9DKL\n1EK3UGgJboS+HJIqIzlLX9w+2UxRETRAUBY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAX+M7bBAh47L2XwPhquwZWwfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgyYjA4YTEtZWMwNC00NTA1LTg3YWEtODZlMmNmNjliMjMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU2MzgxOGZm\nLTM2NmQtNDE3MS04NTAwLWJlOWM0NmFhNWFjMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDl1zrKMTiw+4DJxMQ1DBTIL5miz8jnUbYSldQLqNa/kzxRiFxWgg2tr\nFQ3v2XROmmdhyr/JqxFlLXSV6yU2p2qjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFhiz2Ak\nKebtjh9Jt/00jKnJ1+dFMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDIblhPUaVlnJXG66yCdcQIXJcESf9GZF0ujjVT\nP95CNQIhAJ2yie/8pUGWFUxjNkTF/dyTCxKjmaHx1HhNnVhhFcUV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5527", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5527` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATEIonrxMQrmNAfJBb1ibzAAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MzYxYmRhLTllOTAtNDM4OC05NGFjLTg1MGEzYmZjYmRkZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc1MDg0YjktYjQx\nNC00Mjk5LThjZmMtMzM3YTIyYjUwZjg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpUkIMajdXuvKIi4Hq/sN8MK49A29+2CL+9WJiB0JDstrxt7eTB2H8i9BmB2y\nxIwk7n3J2ugmLNeY61vnsbdM9KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNFA+uqoX2fhPgx0OumVOSLNUuKAwHwYDVR0j\nBBgwFoAU9WolhS54gEN5JKxUA6rgkInR+nYwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC1+9TibC8Z\nLyuItPIslIA1aahoE9l7J4lU9Nr3sTAezgIgPZQZD2mzF3+89nLjYsq4n/ooLiat\npyztygKjSPIzd04=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVwZXGGl9R05nRO/XDrk5HhPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODM2MWJkYS05ZTkwLTQzODgtOTRhYy04NTBhM2JmY2JkZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6qiBFfVmomhWE1TqCwlB7OCRsic334P8R8OWstGnh77dz\nSGT3P2y7X9KF5iLIwVYTw73sBOX9L70Pn1QFNTLPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9WolhS54gEN5JKxUA6rgkInR\n+nYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANVQh6UW2JMFUx/B7PM1wRXLM8CxaRzD3PgaCv+8uOufAiEAuNIOtLSL\nqnIwHQmzG7bsioBval5SUIKRKc5OWqb5yrY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXevAC9iIdSNNNEsEOxZLwwkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc1MDg0YjktYjQxNC00Mjk5LThjZmMtMzM3YTIyYjUwZjg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk4OWEzNjI3\nLTNhNmQtNGNiMC05M2VjLTljZTIwMWJkODVhNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIEc+A1idKxLtWz4PFfR9klzXs88CHAyY/7PPUrtBHHwf6ix0zifUwsT\n+89olGhCTsycA0GO7XkjjRbUAImZV4ajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDRQPrqq\nF9n4T4MdDrplTkizVLigMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIEHyc+61cPqfn55RdmPlutB6mlsBOmb2KYWyTiff\nMt9yAiEA1QfDEhTCccx+PZj3mC3mnbDKB0PwyfDWMnM6rT2VGGk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5528", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5528` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYN9naCXCo5cOEG55qix/YJTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhNGNhZmVjLTE1Y2EtNGE2Mi1iODBhLTQ2ZjQwY2U2OTZiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUxMTc2ZjctYTc3\nNC00NzVkLThjNDAtMDFiYmU3MjhiMjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyTTuG2O/4rnxk73KMI75fv61DOD4xM5MqdzbWvHQl1BnZYuX3zQzokjLThoL\nuild1NlnbfeGa9woQkxAJ8DddqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZPFpWTNFCdu2e671/Tya8CTnxeIwHwYDVR0j\nBBgwFoAUrPHgcp4uaQsAT1BqZHye57OYkwEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCTI31NG5c62sno9UV91h5pIf1z4S8CvrGHz1pJ3+4jJwIgUcmUu93kXXJH\nTWNJSveptUwHfSYVHVcZWbRTiAWqUko=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYxxfbYc5DlPWyPpRHLGg1vUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTRjYWZlYy0xNWNhLTRhNjItYjgwYS00NmY0MGNlNjk2YmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFC4iKW9VMXw86U+5o7vhph220eB2CGUpulr23taRc1Xiq\njoyQr/ors7OhQm+h5HaWxjvqBXQNUWYTPwj65fAqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrPHgcp4uaQsAT1BqZHye57OY\nkwEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOLHnOUiZfXPzdsU7IBhkaRcvJzF6n+hks6PEbsU9doEAiEAgAWmk1Qn\nLbzIXgZnqjpX6znCt3UTHKZ6W0pmzjlwgno=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAQmpdm7aQNoO1KuFRTeNTo/HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUxMTc2ZjctYTc3NC00NzVkLThjNDAtMDFiYmU3MjhiMjU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJiNzRhYzRk\nLTkxMjUtNDgzOS1iYTQ5LTI2MmE4YjZlNjFjZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBti/EF/aJghT4+McFaZoHxQbJxo03qdq1qwo1XRl4SDda0yJiQ7KWy7\nsP0l2Ry4cIKkIn7DbQ2UJzYnDxGso8OjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGTxaVkz\nRQnbtnuu9f08mvAk58XiMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCYUfaS6vrdP+L5iFh4xYa8KxM3geYX3WWL+0/C\n7o5kPwIgAsdtkP763FimGqwzRdjeQf1KiVFVAKELsi4GACE6+w0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5529", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5529` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaVsLRnB9W/zGj49vJ3SUMg2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxODc5ZDM1LWQxY2YtNGYxNi1iYjVjLTJkODI1YTY1ZWU4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI0MzQxYzUtNGQ1\nMi00ZDE2LWEwOWMtYzg1ZGE3MTQwY2FmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3UvJ1Mh1ZSkB/Frnxj1q0qtWIQf3tRQYOZnDOHMotcWkbKHeg5GWoPl27J7J\n3cO2odMjUJDfwElYcbw55WLlIaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl/n4mEVWeELnVbCwORmMew7wwDEwHwYDVR0j\nBBgwFoAUNeS8+ip4QqSY/mAoNEWPf+4J8lcwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCWWa8s+kBDEaZOC1b1oIcxgJjhrredeTgI68S74Esw8gIgdMDyLSBKOP1t\n3rAXVBnY0xn508qaD33qD5yWczoJ0Qk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaAgmDgvpq6lRb4JtzyGEI/5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTg3OWQzNS1kMWNmLTRmMTYtYmI1Yy0yZDgyNWE2NWVlOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQrsK1xrzjgCU4MbxviWane0anwqX/JxAV/AMCbDasiL0F\nH1I0mZEih0iSgRql+8tYDKFbTbMxgP2OOQWIHZEdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNeS8+ip4QqSY/mAoNEWPf+4J\n8lcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVgX1nV5ZAF2mlXMukPKhMif38UM98I2OG4V+cCawn+sCIQDgoy/fwvfr\nb9QW4E62cjcMHh2DGsMdDGtdoCpsU+L6Cg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAX0sh4p8l/JQa2q78sHyQzrdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI0MzQxYzUtNGQ1Mi00ZDE2LWEwOWMtYzg1ZGE3MTQwY2FmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhlMDkxY2Uy\nLWY1N2MtNGI0ZS1iN2M0LWRlM2JhNTlkMjJmOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLdFpQWfqZE3lM0xxnh5yk41lR0D1bO6CoTql6cS1Jesbv3juXsrCJGG\nJzJSBh21JjewegBZFemxZzSztfd/1pSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJf5+JhF\nVnhC51WwsDkZjHsO8MAxMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIGvbiwd+C6/GNy/V6m/InrOyGsZxK6LErPI9EMLD\n6CEWAiEAhPwcbvRzyvhMe7v96+H7kB4iLvj4PTksUHOVN604tYc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5530", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5530` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISATOJp0hh7fVYQ+qQ87X/uStrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwOTRhZTA0LTVhNWEtNGViMS04OGU4LWU5NTQyMjk1NGM3NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmMxYmE4OGYtZDg2\nZi00YzRhLWJlOWUtZmI0OGNjYjhkOTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPk1tig636GD/fSteUxHDXyK+Vlt5aDpLl3GpzdwSWCkEH3qVmRHueqRxngCZ\nwet8/jikFyDFpCNinP4kCO/s36OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa1JhFoYgVDp6xpelxx4jyzXjwOkwHwYDVR0j\nBBgwFoAUTJbwsNhlF4BPw6s119nbsOfyzNgwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDs\nSbHIpvYg9D0VnSA/12SZWzRX+AxhU7QjZN63FiqrWQIgC6tlK97JlJfl7GZPe+S0\nRfZI0dQ0wA6saebj68RbKpc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASSRVGvxvD4nfH5U3HclL+2uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDk0YWUwNC01YTVhLTRlYjEtODhlOC1lOTU0MjI5NTRjNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+R+z9zgpGUIvVCN2c/jt58xJNOtw73R4XqvfE/9rKmxzT\n0FOCIrw+mc2g3TsKTWoctbIpq5SLsdDuyhSvDw/Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTJbwsNhlF4BPw6s119nbsOfy\nzNgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALgETlSO72aJSMwUh9kqU2OIFMN3qW9/w+jGs0DhkXzrAiB+UL1JVpw3\non2qR3SPvuM8ns6PGKw+eEtWohMUDKc21Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAVIpjJm2WUjaO6dAaqMd1L48MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmMxYmE4OGYtZDg2Zi00YzRhLWJlOWUtZmI0OGNjYjhkOTE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ3ZDY5MGIy\nLWYwOGItNDAwNy04YTk4LTEwZDI0NDIwMjEzYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMHrxzLUZBYWV8OJPOfhiZ3kwN27pI1yzfZYJAAj32LdEMJQWhpgPEi+\n7lbI5F/RaOmVPUE0R3mw5DZ7bXQj6AqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGtSYRaG\nIFQ6esaXpcceI8s148DpMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIEBE5Ek31btDiz270vBfKl+y1GHClLtLZ3DjsgXC\nnYSdAiEAqNhzkAcB/s0CedB1d6kXsPGSOq5WBzGwZaR97MP8t3g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5531", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5531` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAeyuSyNEOku7hUgluYdtTF0XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwY2UzZDA2LWUxNTktNDQxOC1hYzc0LTY3N2MyNzc2YzlkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFlMTg4M2MtMmQx\nMy00ZGY4LTlhYmQtNDJjZjY0MjAyNzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFX4PDqU/msDQBbMyTfmtdqti3T1eGjluGpUkpJ5fa0inC7V2gpjRKA8pDygZ\n+GuoNTgSR+2+CAf3QkV0CIYVWaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpd6djcDchk9hS6PZxbmWBooLXMIwHwYDVR0j\nBBgwFoAURxlaV7ylnvmCEc0G93TsfCHn1HMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDc0KcmEUUBtdZv4MoNyfGE+Asmdw1p16gU99nQo/tnigIhAIZ7\nWu+0uqYJsqOTMDx/KU37fM1S0dtOy9HmX5sqbYWx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcgbknhG27Nt5TH18FfrEruvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMGNlM2QwNi1lMTU5LTQ0MTgtYWM3NC02NzdjMjc3NmM5ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQM7bpGb2x5GXYBkdul8FYUAT0AnP6y0Q8CSryfBKOTIUX4\neb8f9wEKIw3RHELidpic7Rz/hmd4nIkVpHtYkmdPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURxlaV7ylnvmCEc0G93TsfCHn\n1HMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANn1VM3CXUZ9H50q0BY/pZWUIuwlp7bDhORripeBRTWqAiBG6XmIQa2m\nS6PaeQFxy+M/8zis40DpS2SZLAYIEpbhhw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAfNw+AeidGRO0P4CeHKBO5ztMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFlMTg4M2MtMmQxMy00ZGY4LTlhYmQtNDJjZjY0MjAyNzkxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVkNDhhZjYz\nLTk4ZDgtNGRmOC04MDBjLWFjNDViZGMwMzhmMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOBtDUr9aC/Alrq3T0yIObldlhI0Kg0V7fceGiWuGca1npFIYSHILKaF\nTFTFI7kWiIpdpkrSx98UDbq6qbJ73WCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKXenY3A\n3IZPYUuj2cW5lgaKC1zCMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQD3m0/xwYr+e/ndh1GxTs3ynabOQ8K9fUEQN/pC\nAwpKnQIgSeDvFMODBUoPsXMVbAUiFbHu9GLlRdcaqtVfGfuQP5g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5532", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5532` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWpE++Mll8h6QJFA511JH1jMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkZGE1NTY5LTdhNDctNDRjNy1hNzA4LTU5ZjgyZmEzYzBiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkwNDIxNmUtMWY5\nZi00NjIwLTgzNTctYjA5ZmZmMDdhNDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHDBhRnQhP3eVPE0VJ2ZHfmCBo67GoPu+rBiK5OstZ/obmUA525QuYkyw0QGd\nawQTquDRm27kP/QmZKE+5lE+U6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnOxUy9sVONMW6qxF1rF+wTPkIaMwHwYDVR0j\nBBgwFoAUFEiIoE1e4/gY+4ZB+F1hv0/Ktp0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIEsovLcPxWjZFlzcDzdZOvvyLrNMTqNkc0D6R0tKILVmAiEA3d1M\nF+mQPZX04DLHylSW8u3IBeXsYGlU1sLeMuFh5Mk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATnAAjX4GeLT1nwdSIDetFK2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGRhNTU2OS03YTQ3LTQ0YzctYTcwOC01OWY4MmZhM2MwYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYfNil8UsDz6c8wOd+ewFkvoPs9n6ARzb/Y9uEUYuGn7AG\nSP7/l4hccvYf4z976UprxcAZJk2Xg9LoGatf4mNVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFEiIoE1e4/gY+4ZB+F1hv0/K\ntp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKiuD/olnuu9unj/9nBfAxsYyJyW+tHhfzDyz4W8v1r6AiB6GKuQdRJh\nXnbABXrK/WBOE/zSkl/PDWMIc2oN2kzwPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISATPwMGWyO3u3lC7jHBMCUtx3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkwNDIxNmUtMWY5Zi00NjIwLTgzNTctYjA5ZmZmMDdhNDYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGViNjBjZTQx\nLTY4YjEtNDc3NC05NWI2LTdlYjFhYmZmOGY2YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLyGFyEccwE8FFzhTEhjbPGK4RA4LVwtbPSiUIYI2qlTRIpKSQU5xmEC\nRi5bSVjexVvXJpiHA3befsPpNHlXwHCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJzsVMvb\nFTjTFuqsRdaxfsEz5CGjMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDMsC1o/tjxm3DTlLvvaJtqZ0mrzAEeavpjZs6Q\nmTY2KwIhAJr6SUCPBV5Z1i5NFJSIFV9NenOFjPhlMCMDAuCt1bRc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5533", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5533` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAVNzeQmhJx5ufkMceUGyqFg8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NzU2ZGVmLWRhMjctNGRlZS1iNTg0LWY5MGM5ZTFiMWFiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBiZjFjOTAtOWJj\nMy00ODBiLTk5OTAtMjQ1MzBhODBhYjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3q5DmMiJNm/J5nHuREe/CQdpdvqrKuA3pukVv5HOLH5di6TB05C14+cFJUKb\ng5wAUkxzlzDUqu0yGfdivuJVxaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMg6/xFN8zt42nWo3cIywg2maQgiMB8GA1UdIwQY\nMBaAFGBJuYISZPcscAhta0kfq/oImkrXMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA8hW8qpkmU9yOkKfMaJqj9RxsBVB6NLb+\nC7bIcfp5nHgCIQDsb8pHW+2O1yiStXK+yXU8rOI4T4bWUZV3USd6afgF2Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZkGWs3WkYGYl9eXOEfuvei7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODc1NmRlZi1kYTI3LTRkZWUtYjU4NC1mOTBjOWUxYjFhYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDdQVB75U7Fu5B8S4OSoeWW0mKHxPd929cvoTuelc0NjyK\nI94qwi6X0iO65c7hqhL0WFp/gbefAeIVjgsdZu9Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYEm5ghJk9yxwCG1rSR+r+gia\nStcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDRRwlaLtiH9TitSKe/4hsDTmh7ireuplNfirQ65Vi1QCIDrqVX25ERVu\noOnWigB9A30tBvFLqUzJkR4rXr1tXIbO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAQur/Z1WN2z3G6H6kiBJNBYsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBiZjFjOTAtOWJjMy00ODBiLTk5OTAtMjQ1MzBhODBhYjQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNiZTU0MDkw\nLTljZjgtNDUxZi05YmQ0LTU5NjcxNmMxNDA0NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOCT1WJLEqsUOhzAPhw0NpN1hhPlIQtTKfT7E3JB2w8zBHE7AUc5ONUF\n43w4DPpMUw3Afe8+esREgK/onuMvIpujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMg6/xFN\n8zt42nWo3cIywg2maQgiMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQD75jnv9yaKSVvBzpv/2SSfeN7DgsQpurI2b6/3\nJLQgVQIgeGmisiPQ88uGCGoNeTeqLrW1mVfFMuoXxfR7stmetik=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5534", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5534` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAfOs4TbeS5Jt4Ye4Z3k0JJ50MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZThlZDQ5LTllNjgtNGI5MC1iOGM5LTcxZGJmYTkwYmVhYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWEyNzZlZDQtZmFi\nYy00NjY1LTg1NDUtOGNjMjkzNzFiZjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVF0+Y2s3ke/7Us5aNH8DXb6rlXc5PdtIERKBQY9WvgtdyP3A9+HhwaT0xAf9\nqkYmXL0xreVjYvdjc5Jr6h048qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKRZorY+xZ+ZoAQSVqW2K972P8iAwHwYDVR0j\nBBgwFoAUN7GXburnQ4NfvoTpavIdLScDgUswKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgI61y8HoaAfJW\nVGEqMj0hd9lvws9SiwjxRBAk2WtsTlsCIBwvb+kM/CBmHLU+l9aN6MNEz79aeUeq\nrvMjOIiehQB2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcBwQWdbymyRZMAjxwwtn6XlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmU4ZWQ0OS05ZTY4LTRiOTAtYjhjOS03MWRiZmE5MGJlYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7oOYh0poo9fGFClpF9mquTK7Fw7uLCfWZ1aPi2qdOLxO1\ncD99rPboEp6IeHsHAPq4Bqrb5acU63L5hj6OeNSpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN7GXburnQ4NfvoTpavIdLScD\ngUswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOwKPCB5OulqKh2buT7PeLAaBhoQwopeCQ0Ozck1PKTjAiBLp6yAxa7g\nSRqVV2wFvkPHJaufQI5dTu/x53rTtuuCfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAbEeh6eCbBabuniBHt0emkHUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWEyNzZlZDQtZmFiYy00NjY1LTg1NDUtOGNjMjkzNzFiZjVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk2OWM5ZjI4\nLTYwODUtNDAwMC05ZmJiLTlhNDQwMmFiNDk5NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNUL4WHz2oppXIOBHAim8/j6w5ZHQ6zX5fbC6EVJEq2lvHyP82CVtu4O\n5QqJJj/TTVIQCtc0b0IQKTY5muOruX+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCkWaK2P\nsWfmaAEElaltive9j/IgMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIBw4LzKzQVy98IIpNhq5WwyW03Thn932Q3duXzwc\nL0N6AiBzDAMF6VKarGNkLOda9hFW5R/BcCvXjURlyDsSu8/a2A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5535", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5535` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAVonjFnZEplBz4v5+dmZHTvJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzNWY3Nzc1LTgwY2YtNGU4Yi1hMjYwLTMxNzkyZmIzNjJlYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg4NGY2N2MtZjQ0\nZC00NmZlLThjNmQtZDI0YjE1OTcwOWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEENSRpbgZLWoWtaoLbZGBeTJ6LQNw38sowKeIrEjR3BdFreweRBCILpJDYVYV\nekmucQjpn7ExZEb1ZV1A7AuUQ6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2dyr9tXth/1Cilv4iwPlzTp9ozUwHwYDVR0j\nBBgwFoAUEojygD05p+2/75UFnDgKjffAfvUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIge3o4pMnSFcTN\nl6u83q0k4RVcG/hoBvQAcfWq9+Wufk4CIA3NwT+eHwHm3ikWY3SQXJhmIxH7NdlS\noITOSIZNbMFL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcHP0ECm33GJrSPgEvjF6jILMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzVmNzc3NS04MGNmLTRlOGItYTI2MC0zMTc5MmZiMzYyZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmS1vY0jzlHmn5xyjGVdhupQ9JPaHhu53cnFYe9vsmruRa\nWSWoF17k81Tm3uQXs/h9PDkbhce5cvZ5UMScpxkbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEojygD05p+2/75UFnDgKjffA\nfvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPagLClANBZzhyto1JCsvJY5fbcNW9f0uxsKcW241NdMCIQDH7EOnDQF9\nB/We495iyR4nzEn5EO5DJg6VoWilbEgsjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAflucQ9JYHeaT//mjidPgMW+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg4NGY2N2MtZjQ0ZC00NmZlLThjNmQtZDI0YjE1OTcwOWY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU0ODhmNTE4\nLWE3ZDEtNGJjZS1hNzRlLWNiNzU2NWQwZWU5YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKAy6cJh+IG1efi4DGtbef6oh3AcZHKWB+T0GHbnNu07jHTGN/zDn+93\n08NMmGX+PuJ+A8O52/CEu3xtyJnaGWWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNncq/bV\n7Yf9Qopb+IsD5c06faM1MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCMHw1tJ0G3m/xSS9xWrEmFStEVqCL6LCxnhwIm\nJN5zkAIgXpJ58QYTQhLa6WYaqeyfQ8VN3fQOVh3s3Q1LtFBji20=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5536", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5536` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAQoW6+c8xsmYAIKXnp9J750cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2ZDRjZWQ4LTA1MGMtNDcxZC04ZTA3LTFhZGY4ZWJlZjZjMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY2Y2VlNDgtYTk4\nOS00NjlmLWI5NTItOTc0MjE5NzE1NmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuFdilAAmTHSSf6i3vsCUxzmYW7wnCNGA8WzXgA2jUm0cflIioX4g5YKHRbA0\npWdtJao4dKtZ2/oCt5k0tjQYoaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVTP2fgUlI9UzU4q2PAoTXga7gWIwHwYDVR0j\nBBgwFoAU4v5/dRqNj0dcuuVF2VzBKfthBPYwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBQxiOFAtJ0s\n0wCZC17k5Cf6BLkQbywVs9ME4d7s/EQ0AiA2YUIF43wwi78/y8tPurI5cMSz/gYv\nAx64jBro+vwVsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaHDjAeuRKxfJw5hFKnVQywdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmQ0Y2VkOC0wNTBjLTQ3MWQtOGUwNy0xYWRmOGViZWY2YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPcuwTmKxEWnhfRu+QLIBdLqeMRDK5YPH4TN2U5WoCL3Vq\npH5ZSWL3q64JaJKaVPMK59qGFZSKWYA6GT6cm5XRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4v5/dRqNj0dcuuVF2VzBKfth\nBPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcuOLkqvJ6nBN58B8jff4E/0JfDaro8mQRl1ISFtAPqACIF9mfRWqMcTn\nvIEiPQur3N5I9eh9+XEeEIusqjom4hOz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAbtJLY+Tmhvd/etCqMSrChaEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY2Y2VlNDgtYTk4OS00NjlmLWI5NTItOTc0MjE5NzE1NmZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkyNmMzNDA0\nLTZkMDAtNDY0My1hMDE4LWFmMTI0MWViYjVjYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPJlSGdkIcfjdJ8G4rF766JOHonOMj71WVlhhT1yLCI4E9rWUvvlt+FU\nb8zck96l4pIPDUl7Uh+ftK7gv2Xd9kOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFUz9n4F\nJSPVM1OKtjwKE14Gu4FiMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCICygbCF+Bj+2N1MFqD8v1vD45OgqWcuEC9jFTbSO\n8y99AiEA200nQ4LbCO3+qMcSd0JphqK2d23Dfy9affBS6gT02uA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5537", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5537` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQ4aWMSmsA2i8XXhaCFX8GikMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyN2ZkZmQ3LTc1OGMtNDVkMC05NDk1LWE1MjM1M2ZhYjdhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWE1ZjNkZjAtNjU0\nNi00MDcwLWI3MGYtN2NhY2Q5ZWQ4NDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWObwmW4yWNhbcR8vPoeLT0/7XDkRU9qzhJnRUbjKrIMsLKmez7Sx0ymC8wxR\neq5lHl9FTnkeK5nILpqjRZr/36OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQTcaQvUke+2IxBRkXGiwTkZRrW8wHwYDVR0j\nBBgwFoAUB//4ojrUXdeGxmNySiU3JZ83eaUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCr74fvyyC1EG8fK3bjcILIyOR0K94aVVNEVxiExBYZwwIgDz6bCShgO1VT\nXTNqPaSZyXCBoYtQ7Qvx5JVIvgRcfns=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfVui8O+RfnxHEQAUejngf5dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjdmZGZkNy03NThjLTQ1ZDAtOTQ5NS1hNTIzNTNmYWI3YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7GvXjJFj6/uyUi0Suxj/1wiLJpqQhTJAIjbuKRceNPoKY\nosdp4PR/QX/gO6USRU9iwjucXGJWLIP2MGuUPZ6ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB//4ojrUXdeGxmNySiU3JZ83\neaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge+JKX4OIXb/nnZ/6qzekUScpXud3cBLN4sR08Fg60VoCIEm6uNCdmm++\nfV3h6TqRAzblAo3Aczi0QgS++5yTIQ1R\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISATDzxn/5sqTg+bRgBHp0Giq8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWE1ZjNkZjAtNjU0Ni00MDcwLWI3MGYtN2NhY2Q5ZWQ4NDcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI3ZjlhNDNm\nLWI3ZGUtNDg3My04ZWJhLWU0YzI4ODAzOGMwMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAOTBchcO10/f+V/5vTLIcCc5EHpBSS4h1HHtZO3cPpPTrBFQYtpovBH\nSVEfi0vj9YakRgxUrLSq/nglpExlMV+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEE3GkL1\nJHvtiMQUZFxosE5GUa1vMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCHWCfCZ+A7zN+s/L5bXgi0W5zqxdMiZSJKQvfe\nGixU3AIgJz+cArjY6IGiSpNGRWHJG6/YVEN9qJvSfg2lj3E5WXY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5538", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5538` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASgEvQgCQ89yRoV4cfhdN2XfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzZmU5M2NiLTg5MjYtNGFjOC05YWI4LTY4NjBmZmU2M2I4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUyY2Q5YjQtM2Vh\nNC00YjIyLTg3YzUtMjZjYzg1MTY4MjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs51dQdZWjHwr0IIEFA2/VkcJxyjbNxwiOYUm1ChvZORSfxnIha56WH0etWsB\ndXPzpknKee7Vt4X/ILoSEslLAqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsUrBXgHK7dabWW9uFWVjfdg2bqIwHwYDVR0j\nBBgwFoAU53e1xpUsPFcC3uYlqOKOsg3GVUgwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFJgCA3vFhhLJherEGzvpJfrqXEtXLAg3eeUhiwkJcF2AiEAwmnEnBRdRc/b\n05LU9JWhux1p4c2g9upF+jJjsUXH78I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf+4Bjijn7jFsgXlF7LOtR3TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2ZlOTNjYi04OTI2LTRhYzgtOWFiOC02ODYwZmZlNjNiOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6gwNRlSIyWW97yUZi9p2NZ1i4RmmYZDZyfzdJefVHpJH+\ndfzr/QcUcFsRCUt3HOWpmw98O498x5OuFXHTuReho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU53e1xpUsPFcC3uYlqOKOsg3G\nVUgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKkTYbv0EmrJLvzRN87fhrM+LSSQAxtUY45sdu+JkKQQCIG2Oz3mib49a\nzr+rGi36XuLK/F03jw+IUB42nqOvjmN8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAS2iRFEUqHCunCcP/cDC6igVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUyY2Q5YjQtM2VhNC00YjIyLTg3YzUtMjZjYzg1MTY4MjY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE4OTA0YmY0\nLTVkMWUtNGYzOS1iNDAwLTg2MzI4NTQwNjY2OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNrjecS9eNQoZuASKKZ38dpK28LGcUiLMeOU4YGWembEbkb0dTXKMkYy\n1+wRlAJ0eFaHVAE/yVj9E3UR7zVER92jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLFKwV4B\nyu3Wm1lvbhVlY33YNm6iMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDEroo7JRs8NBEFnWbtn+mCltyeVUBrEea9YXQJ\n3qphcwIgH6dBHfXVmDV8yFOtdg6CAp42KDhjyasf3Y0D4ZW7EX4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5539", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5539` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAbSkyOTq/FN47lZCPsH3h+z9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlOTM1ZWEwLTk0NmUtNGM2Yy1hMjQyLWJjMzdlMWNlMmM0YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZlOTY2ZWQtNGE2\nZi00NGIzLThlYTQtNDE2YWY2Y2NlYzZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4aoQgW5r+P+ZroLXaLKLJVxiiM9eEJdtCFGkGBUd7KUHN8g6j53BgRHE33h/\nOjJNbQ/b7hdTZ/L1GFeK4MF77qOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbHI30DO4Esb8GXDxztfKBEAiuSMwHwYDVR0j\nBBgwFoAUFok3/t+PRPLLIGoAJfQyNJnEnP4wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC/\nU7Qz2sWPM4mcJKqU7yjtl848gpteLXqAOelA6IBjZQIga94Sk2mtzD4f1AOPiwSs\ndzGC/rHpHnpIZWF1d4khZ7s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcNiEKZTbfGjHZes7Lsh02l6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTkzNWVhMC05NDZlLTRjNmMtYTI0Mi1iYzM3ZTFjZTJjNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFDiIUcZJCtm/XjozJjfISpJMFw9TJrIDbCZnPnnsekcCm\nNBNDOFnceM25AuRz3Bbx86/AtHqQ6H5v/EYWcFPUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFok3/t+PRPLLIGoAJfQyNJnE\nnP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDq5Kf6+Pjyab7D1JTd8QFsh9KMAnUAQ2Go5cmc8MT60CIEJX5Quwj+dm\nn1f5qOcjQ+KA6E1ma6BLAHrEmyy3F+SX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAdv5cg8wiQP4NIzRdjoRHrIQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZlOTY2ZWQtNGE2Zi00NGIzLThlYTQtNDE2YWY2Y2NlYzZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg5NDdkYTc1\nLWRmOTYtNDJjMC05ZTY0LTFhYmM1ZjlmNTI5NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKJ3sw9ZbssQwHKA+ZoNsRq//vUtekGYAEkGQqyHY5Idllm7ghmIdzdk\nxBLgt+4R9JfEWeSUiUhJvS3r6VOx5jWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGxyN9Az\nuBLG/Blw8c7XygRAIrkjMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIDIBE7rYb+EL2Gn848IVLBVYuc6MIetMPhGDtTp/\nDGbgAiBYs9zfOwZt8nV1Y3Bmch/O5Y8DL/dat0e6jPHu6guUkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5540", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5540` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISARqDUUE1g1+ZP+d/JotzxXf/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhNzVlMTIxLTE2ZjItNGI0Zi1iNzViLWI5NGVkODFjNjMzMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNhYmNmMzQtN2I4\nNi00OGEzLTg4ZGMtNjk5NzIwODIwMDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+3tSQyIwM+PI6ElZo/UJ2K+k3gqLXPZ7Qko7j0WmiBSu2LCmhyjBjWxm5pe0\nfVjSyh2CHjBD6hYjHO8LuT2J2aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWe01/6OZLBqo5IPhq/EAqQPM3+4wHwYDVR0j\nBBgwFoAU5HxjenqMCmuplUYSFRkifuqHD38wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCVRR2w4PA1NcDCKTPOgsJbS1NXAEECkbceXYe9RV6CjgIhALa4\nxYNO4vvbCg0L5ZjT554In1dmBRyRGXRTw9qj0g6P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfqjX6VImXFWvxX+T4RCL2W6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTc1ZTEyMS0xNmYyLTRiNGYtYjc1Yi1iOTRlZDgxYzYzMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFCqFJ8y0gWulIWhXwmLZoXwlCwibBSWdzslO7YHziDRfJ\n/Izm/6TZzcP6pknnB+/Vb3gaC8TagpK8xABm1sZOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5HxjenqMCmuplUYSFRkifuqH\nD38wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM0O4U8AjZyloNUYOGW1QmKXfpNBxz2BZfOqxYdWDq87AiEAjnA9T1bV\n/2+EhaNBX3TvU2zAi4t5NPCzZDQ2w4EJ01M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAVWvfcoPujfp6UX4rC+c/PtOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNhYmNmMzQtN2I4Ni00OGEzLTg4ZGMtNjk5NzIwODIwMDM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFmMDNhOTI0\nLWRjZjYtNDMzYi1hZTJiLTAxZGMzYTgwY2MxNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDt9f9RNc9AOzGqsUZTnEZ5Qs7zI4gWu/yBbaqt45d4UxRuwGkJH7Wf+\nqZ/qdm5F9vzT8QRm/1/PjNH4My9L4eGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFntNf+j\nmSwaqOSD4avxAKkDzN/uMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIHgyTlpLR3nIaJKNbXtl3b8piPqHGKh2ErQoPC0Y\nbuLNAiALbstUileXlBoDQb/sbRGnRw58QWOcUcPA+Nl6fH4OIA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5541", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5541` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAbrCrpUdmSxwm0n+xgwXd5BXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3MWE1ZmRjLWUyZDMtNGM3OS1iNjQxLWM2MjlkYTdlNGRlYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM2MTNlOWYtOGRl\nNy00ZTFmLWE2NDYtOTUwM2QwZjRjOGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOKfpUV/0E3ThypfhUAkArxg3Za5rt3JlfWbJrM6s4Exd0Mgg0GJlUSEln5to\n+uH+bbzUc3gNC6iQmdLnMw4SlqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfS848lOvj0n+ya2hl9AUNDYC/jswHwYDVR0j\nBBgwFoAUW5KwQjE/VPNkTQsbtDjWLVWg16gwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHQe0t3Foq8A6BXBk+phbvg5CgHdq2MoI5jEl+UtL4FzAiB08Erc\nDc3KluhIS+NGQHZZ0QteYgQJHhVWSrT+exrgwA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfoU3nNg9jQbPAEZalDGWRAWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzFhNWZkYy1lMmQzLTRjNzktYjY0MS1jNjI5ZGE3ZTRkZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQG5hiGJj9D7HxSXgehcmY9ybrzuF/MRQGYsi7vzx2hH1Gp\ncbCg9dYMeUphQmaV8kTK3dbK6yMv6+h18eP8KDAfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW5KwQjE/VPNkTQsbtDjWLVWg\n16gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfYYxc6tkilk8wS/VfiWEd7q1ZiZ51Bb/WV0q0WtWOaoCIAmHaBI67h5E\nswhEJwMVOboNTy81XV8eDDxZIBAYwyPX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXWL4pp4kLtF0Ennb1gt4ivpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM2MTNlOWYtOGRlNy00ZTFmLWE2NDYtOTUwM2QwZjRjOGJkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZjYTRmZjZj\nLWYzNTktNGFlZC1hZjU0LTQ3OGM4ZjNiZjZmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLolppTZYwyXMnJFm6dbu2b0i6JzkXR5VNnZ+d8dEjaCexzNCiI2xH3e\n9z0T8sFLl1nisGGvO+stkKI+AL/uzLOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH0vOPJT\nr49J/smtoZfQFDQ2Av47MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIFR1Udh7TqTAXUt2I87N+kOzqQIz5978Obs01q74\nMJHzAiEAthy/iVJyr1bXF/m0JVn7q4LXxy8N1WTVWXpcIgiJGfU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5542", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5542` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAacpiaCmhf7n5lBYKIAOOZc4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViNmIxMjZmLThkY2ItNDljOC05YmEzLWNmODdmZmYxMDBlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIwNjdlZjUtZjlj\nYS00MmFjLTgxNzEtY2UwNGFmNTI3ZjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdr5JgLhZhCCc1FisijZSLWGTJL9QdEhnpZlvdMJco4vEQMcFGm4xOs2/+yay\neyj3YKOl3Tz+IkHuDZ3QkOf/o6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRw7e5VbEZAmOeBNBr3Z0A34mAWFTAfBgNVHSME\nGDAWgBS7aoS6NrdvDODKnHXB76s3GekHrzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDIFnrEpHhjQRk9ANqvxA9o83ddBe36\nWQwbn9wdd1x2kAIhAI7lveLCdbc51MevgrR6IwdXtx4ZcYy8QL4nTwB9y2+Z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdeU+aoeaX8pa0uuR3zoEN1oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjZiMTI2Zi04ZGNiLTQ5YzgtOWJhMy1jZjg3ZmZmMTAwZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFqgDdqFJfIUZPnrAv889E4gSYKGijtbE8g8vdsmDLgK1K\npUD2406INajM8rvDlE9VztnzTIorvV2CTt9jfAIwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu2qEuja3bwzgypx1we+rNxnp\nB68wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANkUPTNIKvkiL70FWzLOXa37kr/dnbsP041SWf0eBfoZAiEAxIXo/6Si\nV2/NFJf8xFACopTr0rFSfv+suqx/lbE2YJ8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAcn5nOutk4YpLR72EEoYI0xUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIwNjdlZjUtZjljYS00MmFjLTgxNzEtY2UwNGFmNTI3ZjdiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNlNzdmYWI4\nLWU5YzUtNDVkMi04OWU5LTRjZTIyN2RlMGIyZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGd8a1tbXZJGU9EUeUXBPYJTwo8oFX6nS6LqqR2fVLp/QbnpM6exHB6D\n152fZsINGzbWeijmmzxB68m/gDYXmV2jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHDt7lVs\nRkCY54E0GvdnQDfiYBYVMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDGgy7TDYvqkFkA/ngFgEx2HNcam39UPkKZhbSv\n+yjbbgIgGvT26c0Ci8+0Bdjxb/a1j+ZLEmAZgFMvNIMCQmn8Ywk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5543", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5543` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUeAirZ4pc09WOkB5fQcuIpDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiMjc4YWNlLWI5ZGItNGI1Ni04Y2E2LWFhMWJmODkyYWEyNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDIwMDcxNjctODQ0\nNC00MDdmLWIwMzQtNGFmZDNlZDRjZDQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDzGvlLKlM/8t6wMH2KnsLYBvJZmJM714gQjv0dEF/DQa6XHpeC5HbrAYecxn\nAurD4ZWIBZN1xblpim/CRQgzlaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqaGJfxAHxashgChtS9mBV9K6iaQwHwYDVR0j\nBBgwFoAUi6JtE2R9/+Cqb1AB9hth+B3L6MUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCFuDeNI/dJ\n0bM2vGXJ25AMnRSYvS/na7chJY1UIspV/AIgd6aHzkyu95mfQbg1/uk/pLL2ZaBJ\nl3B+rogCU4TaX+k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe4Mag6XUR4M4PN1E3rRc8knMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjI3OGFjZS1iOWRiLTRiNTYtOGNhNi1hYTFiZjg5MmFhMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRlp7uEQ048AAdZ4kv+Qc4Sce0/Q2M7P3WBGknGZryruPU\nCy8wDj3g5z9VoRXG62x1TUc9nPGwpgHS4l5uZ/Dfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi6JtE2R9/+Cqb1AB9hth+B3L\n6MUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZkkBcUviwiqFFaB0sXpRhthW3g98SD7xDimsCVDr1X4CIHu7NYPXLTX0\nkLZt0sDzkmw2emxVHV+DWq7knVva09Rh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAWG0Gd+l2Kt+nANASu4Oox8dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDIwMDcxNjctODQ0NC00MDdmLWIwMzQtNGFmZDNlZDRjZDQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY3NWQzYjk1\nLTcxMWMtNDY1ZC1iNjA2LWJiN2EzZTJlNGM0ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK/hBjcu0FquQOHRSRqOVFsKnUUKJrcwsc5k1i6AqdpvXPL9Kl1ZsBzt\nc/qpAgqq7y6u46hCtGJpSOWbASJmTJyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKmhiX8Q\nB8WrIYAobUvZgVfSuomkMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQD0AqA7HIJdl7RMJ6HCh67He93yH88Ja8/Jx2oS\nbFh1TgIgMfMVF6UxUCITPm+7FYt8B2CNeB2OBD9yJEDr0AU4DFE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5544", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5544` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAQ5huEfYZ12YoLh7pQ3Sjvd8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiZTNmZjFiLWY5MGItNGZlZi04ZDg1LTc4MDhmOTdiNDc2YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNkYzBjYzUtMzQ2\nYS00MWFjLWE2MjYtMGQ3ZDdlMmVlNjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENrUyjCIndYOged5+nLqpJGObzkNhOFGdH1K0OUGjKF2DN/c/ywVg7IWUpfSn\n0lIHtsOwtbn0CT/nyCxrzsVnG6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1I2j+zYg45dX3CirYyoWHU6v/2IwHwYDVR0j\nBBgwFoAUZgP2vQQR78PJdij4zRV4lUy7vQswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAvxkQ4VUOm9\nZsn1aEPKvsRL/G5HedsvtxuI2w8ImpFEAiAUEXYbNOAgk+BO4bqm25Ebacy5ap6A\nCs8D6Y0hakfVyQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbpKmrzFryxPdDDzFHwwEOdQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmUzZmYxYi1mOTBiLTRmZWYtOGQ4NS03ODA4Zjk3YjQ3NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXK6FMUM4iy/fHYczTn/95lNU1p/vcBWgEATKatdOc00X4\npGJS5G+aBuxV+ZkrnhSxBhsUd6v1j/7qBNZhEFvfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZgP2vQQR78PJdij4zRV4lUy7\nvQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPWA1lWmTSRmBrXeV/0O5isqWc2Bi6q3zRqym45a9yzGAiEAjZAhwvys\n5Kge2R7uc//2AVZKyQzxQvkJ3F4t3IWL1O0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAcoY1cKeUVu7eGW3DlzYppIrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNkYzBjYzUtMzQ2YS00MWFjLWE2MjYtMGQ3ZDdlMmVlNjI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU3Njk2NzI4\nLTVmOGQtNDM5NC1iNmJhLTc0ZTlmODlhMTIwYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM/ARq3gZI7HCmvSB546LGZiU4SKtOcp4f7VvouGizSzzAaBa3cdvW8w\nR87z7vqtfD07VHNRxCBuUBLBOJHCbOWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNSNo/s2\nIOOXV9woq2MqFh1Or/9iMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIADXhUIraTWgn4wcD70ZzYD9nqroveAZ8tbuqjWp\ns6aPAiEAhLLfn2uNtzQprDJm/COJ4zHSmfKbpm5VpHhd5Ma/QII=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5545", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5545` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAdGaYQN2z0WgQ1DPjybiYAZrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MWJlNWU1LTEwOTEtNDVlMC1iNDVhLTUyZThmNjA5NDVkODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRkY2Y5YTQtZDFm\nYS00MTgxLThiYmQtMmNiM2QyNzAwMTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6BW8Bohd9QKSSASM7Xe7aG8mPDidZIyymcDLfatsTQjBwNFFOA6hQ6OLcYwn\niXMqa2lPWJ+tVoH8rjvkGmoL6aOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1dG60W/zU8gK2+9HQ5VVfsgqvXgwHwYDVR0j\nBBgwFoAUq4tB+iaiLD+GlXwbhpDWQdYOsSUwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAsygBXJ2f\n92mc4YB1z2Gr31SDt4qI/FwI0OZ7Oi7TFiwCIQCSMzhwX9J/JcwgmUBqYARQADjh\n/z9PD3MCcRH5LdXGSQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYjxOr0uOGqL16U3g6e/0sjiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODFiZTVlNS0xMDkxLTQ1ZTAtYjQ1YS01MmU4ZjYwOTQ1ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScY0Ebr7O9WyuNPEUs8lnlOQwiy/KqOBhOfD55zeWtbGXG\nCZUtnZ6SWkZMoJEhR/ex56yCHLJgKb1t5g+4hkBqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq4tB+iaiLD+GlXwbhpDWQdYO\nsSUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPkcahoWTF3HKQBnmwrSPjWZLPTxzB6JK2oATQTSIORQCICrPIVVgNkhu\n4FOC8CQ3IvtxjECQioBCA3iDJTsqAiQw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISATx1YhTGPA7fziDskeYqBDb5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRkY2Y5YTQtZDFmYS00MTgxLThiYmQtMmNiM2QyNzAwMTQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ4ZGQyZWJh\nLTJjNmItNDE5NC04ZTg4LTU2ZmI0OTVjNTZhZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHweUDgLSCj03Qf5FNY+ua/I+6NatqzoNGcnKnTjY9nXKQqutm8HTaHs\nYsAyj00aUY6g+lxU7PGraW3gq7en8vmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNXRutFv\n81PICtvvR0OVVX7IKr14MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCF2xz+vz0NKEMo93HzfaYLRf4aDFeR/APrAuQ4\nDTc+VgIgcmJK3uA3cgI7M5BVT+rQRINgm96EiZ8EsRAqmEPJH1U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5546", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5546` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISARKwPwPmnljiRZZ53Bwhkb5CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1YzUyZGU1LTEzODktNDljMS04YThjLWQ4OTIxNmRiZGVhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NhMzIyYjgtMDIw\nYS00MmUxLWFhYjctNGZjYjk3ODAxMmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVliBmX18D/cY88RYOLExLoPXXB4gIgEyJZ6cfDAa4HWQaGVpU+lDafuQGsMQ\n3Fxu1BLh4xD/4Q7xy9+e/bhngKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAoovmJaWDSEGZJB++a0zkDCA3tUwHwYDVR0j\nBBgwFoAUUDWj+QPqoMRCTSA9502YMjB9pjQwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiBg66YR2ug0PhP9SUCmy7MFSs2KjlF5fnIMOtHCzT4ZnAIhAIIhgZD55z33\nJAiGVb+AnlgIYp1EVj6KgwC1IeHNEr25\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcVd3l0giK1lqpHh8whVKHwoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWM1MmRlNS0xMzg5LTQ5YzEtOGE4Yy1kODkyMTZkYmRlYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkCY2mwIwDm95ywbVRpPYsyCcoWwHQrFmzjT9YG6OdUPkb\nBX7Bt9mG8djuGQU36L1hdhirzv69KfVkQhlED9MYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUDWj+QPqoMRCTSA9502YMjB9\npjQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO3RsRRbNi6hyZiQaz6qfavalHxH+aE0VAZowXUaukR4CIQDYOmWILuny\nebPhFkE5OiVvZulKJQa6JOuK4/SNlxYvzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAXjuuJ8w6dlIw1ecriCd1rA6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NhMzIyYjgtMDIwYS00MmUxLWFhYjctNGZjYjk3ODAxMmFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU2YWEyY2Q0\nLTEzMjctNGFhMC05MmFkLTVhMTVhNGI3NzJlYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAmyon1qU041GYyiPSPcTh8A/UwhxRVuSv+p3FhpwRd49rsTpMk6P/sr\nzWgtb2A3relnz57mM7wDQqirS0SuD3yjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAKKL5iW\nlg0hBmSQfvmtM5AwgN7VMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDQCe3lTgzN016DoSA27P4eDwHcbrNxLp//XV9o\nOTwP4QIhAODZ8YgNq/u87XhOAFW6Lf+QwIQFgDm0xHKDf7JmD1hy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5547", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5547` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZ4g8C3sTR1Mrcv93XG7rGU+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5NWVhNGRiLTQ5MjUtNGMyOS05MDYxLWE4ZDkxNTAxMDQ5MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzFjODhkNTctOTdl\nNy00ZmNhLWJmY2UtMTMyYmQ4ZGUwMDFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQbVmKmzp98MeQlB7cDvwBJNoVqVQW6//DaJJlaq+E+KixwcP9v4VVPNfs76W\n5OlwmAcEcwfPxjgDCpOZqv8GcaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0X1LfTRT6nd5NPmJVltF/wxTT04wHwYDVR0j\nBBgwFoAUb4ItAi2IIU9hKgBrgXqXTitC2J8wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiBKquWjhWvRgjNRA2/3i5w8JA7dCkbptL3Zouw879MFBgIgBzaFxmCOA+/s\nWDnQ6OZc7uy1/ywkcgUZSqfEmD5NDdU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQll1kaXZipMDZIAO2qec+dmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTVlYTRkYi00OTI1LTRjMjktOTA2MS1hOGQ5MTUwMTA0OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZrbYTn5eI4DXjvGskAgLW8bb44SEJYErpOQMg1rVyR1oC\nlDW2q0sPUt5r2SOuRWsza3FT+mhmj5N1QD2fzJZyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb4ItAi2IIU9hKgBrgXqXTitC\n2J8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOL4N6Kn7e6D48CAbpoMOR4tyd1DtAecYLZ4taVsy/qoCIQCClt8yYMGa\nz269IAM8+DxUsfR5Flx0f/nWNrzBQJunJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXcCBPZN+iBxYryIf5qN0xQoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzFjODhkNTctOTdlNy00ZmNhLWJmY2UtMTMyYmQ4ZGUwMDFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI0NDgyZmZm\nLTY0YzktNDU0Yy05YmMyLTIzZWZhNmUzYWZlNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAY1W6mTGA7RU+VWhm0DL1cYx1hUDtpDxdzaoFVGb8DTxsbyqKQC7w4E\ntpUWinrGw19bC2Fut4m+IdtErHpCwLujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNF9S300\nU+p3eTT5iVZbRf8MU09OMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCoNlYG2gWHjQSrScrJYIdaOgrQULcxqvabSxOb\n7Q16dAIgfEbrrUYHRjZhfB71ur2+jpA4p+KahnmAP+X5RSnrjNw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5548", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5548` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAWKqluP0M9UA7PMyJo3okAgnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiNTcyODFlLWJlMjgtNGVhOC1iYzlmLWQzNjk3MTA4YzkzNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTM3MzAzNzgtMTli\nNi00YzRiLWFhZjEtODRmZTIxMjQyOGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHqypGXVfW1M0EEj0pM9ArvprCVkCuO9Vf6R4V9nZl7g4Da9NoGPZ3Sq3Zzcg\nlTdvcWMqhbUSqvOeJq7U++iP16OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO9NbY6V9hqAZVxuJ/mcT5JHcjB0wHwYDVR0j\nBBgwFoAUMJDY8z1QVzXfSefFGKmhyS+Mk54wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAV\nYrLDg3w0qUzM7p/FpagMTjODLLu7G4LSVfQvmuSiLwIgWWYV8eHt7mTyHzhUXReA\nF4qFEerf3muIv5qKeP3lrLk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUyFAHuKBxQgiVesZ1uSfPuiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjU3MjgxZS1iZTI4LTRlYTgtYmM5Zi1kMzY5NzEwOGM5MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoN65p348ur8uERk9dnVnzZAG2TyrZPQ5tprRsclwo0n1m\np6sWXXW1UxKuF+Ko+kk95DIJ38jjtNxpwFauNjLFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMJDY8z1QVzXfSefFGKmhyS+M\nk54wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXCfHv8Zf9yV5bpROJGGR4xoaunSXe7xn8tNvN/hY3CICIQCAw4PbuFzO\n/baYOqTRsJOUskTFUeFwPXnj8D0VSm1tUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAYr3Q67uDl+AUGNrmNgcpZvZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTM3MzAzNzgtMTliNi00YzRiLWFhZjEtODRmZTIxMjQyOGE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlmYWQ1NTk2\nLTdhODctNGUxYS1hMjc3LWNlY2QwOWQ2MTNhMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMGO7TOeHO93ZgopINKVmmDCbsisd5RfAZrkjCydqLz0xNioFJYyuzda\nFRBDZQJOuCWRIPwdY7jpLh8peAA6OoSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDvTW2Ol\nfYagGVcbif5nE+SR3IwdMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQC10NuabbLCWDigp160fpHKbarJWI7qXgW48OqJ\npkupkQIge6EHkRQ78td631Vvqi9iGORdXEPKts89agLOjwUuL30=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5549", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5549` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAdxLnUM4o7IZ5IDofem2aibKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5YzgzZjNiLWExNmUtNGE3YS1hM2NmLWE0OTdiY2QxYWI1OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE2ZmU3ZTMtYjk5\nMi00ZDdmLWFlNzgtNDE5MTdmNTNhZTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE77n2KWpWwXl4LxSKfK278zcH67AojH8ERCN2lMbksC7RnDgNBtcv37L8lcy4\nQHN4YjhuOzoZajDvkbbMJBVtnKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUbL9uBy/NEwi9wpCa4jb5Jf0r3swHwYDVR0j\nBBgwFoAUOqGJc1Eca0+pd6UXzmhOcCkLkdgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAtKrwQBCOnkDmq6jBtxAZ7xTtfyQ0nlHtu4dLJaGNQIwIgXtwv\nmdXli1mY+xp8UJAjRPTAjbgMyC+wRLjy3FHtOws=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVyORskqQNfx8J8G/TtNhmFQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWM4M2YzYi1hMTZlLTRhN2EtYTNjZi1hNDk3YmNkMWFiNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWsYs55Fl8ZKUhBP419oHFFmGT0PmPYP1KMfymW52kqRys\nCHorTzBoPu2N+lIkMsg1HQ+PFSbYeFi9+JkKf0IKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOqGJc1Eca0+pd6UXzmhOcCkL\nkdgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAItEyM5Qgh+O2YdMvUGagho9zAR6dged6Lbaj0cqOYVyAiBwvNwNrF7S\nRKk75dA22Kt+E7nKkw2kagUtuz0O0in/Hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAUjyNwdXZipaUQMb+R4KalZ4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE2ZmU3ZTMtYjk5Mi00ZDdmLWFlNzgtNDE5MTdmNTNhZTAwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU3NTUwMGNk\nLTlmMjctNGFhNC1hYTBjLTUxZGM3NzFiMTJlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDolncpCR0Fz6Z++HPWgiCUFqrilWfxrrjCbmpxFiRFJKvMt/9lesc7W\nlpSeFiehj7iVkQjbT8g5Zd97bb1c9l6jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFGy/bgc\nvzRMIvcKQmuI2+SX9K97MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIDIx+37Bng/+ZHmgsUBvuUQkAlM1pWiVXxzdC0OW\nT4IuAiEA7+rtQ/SmvYSIN8/pymEdj8dEz1hBwDBnv99PW6pF/+g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5550", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5550` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAanLW6gW2D2HMvWoX1Ol0HQFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkZTUzMzIxLTJiNGMtNDNjNy05YzYxLTRiMTZhOWE4NmZkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQwNGE4MGUtMDY1\nYS00ZDRjLWFlNTYtM2QxNzVjNjJiODY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfzVgEEwmzI52Us/PumyTNa35Y3Qh3BuckueL9/lBKv9pYfAa1qxZewsVVfMc\nIrrQIbbVJAU+CP10zG86Atjv5qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZP1BjpgRAgsDYZ2v2Ww1WPG42YgwHwYDVR0j\nBBgwFoAUcm79zlPIOGOrwKEL7Ae1IovjZS8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiAnPoeG/TU1TFdAd1F2FEveMx4BFP4U5Ld3SCrRaWkIvwIhAIsC\n/qLHLoqCIEUED+Yug4pY699AYOmgbxMrsC0MUc+k\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfYqIV96uBlFYnEiM5sKpT2EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGU1MzMyMS0yYjRjLTQzYzctOWM2MS00YjE2YTlhODZmZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+Cwfy3dlu5MwLPlvAcdDyd+QPNVz9+Cjrrt49jetmzqpI\n/QGs2Nyrfa3chHRmeMlq6Cy85oN1QgVuMyJEX621o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcm79zlPIOGOrwKEL7Ae1Iovj\nZS8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ/qRK02sIlI7bDB9/W972A6uZmTHZJ88E8SvwVG01TVAiBn0UbcdpTd\nHwL3NkdsZtG99e6iyVnDXx7/HhpxZgnUpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAdgD1L3sqP2aEMLDwJaEPXf2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQwNGE4MGUtMDY1YS00ZDRjLWFlNTYtM2QxNzVjNjJiODY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMxOTY3ZDU1\nLTQ5ZjAtNGY3NS1iNTE2LWZkNmMyZWIyN2MzZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG/pWzPoFFxWy/sYGdXDkfMiKM1QafBsGFOx49Ss9j8pZqw8GFwXk2y2\np+5v2l6o3+KDwF87t6MNtJI+pkida7WjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGT9QY6Y\nEQILA2Gdr9lsNVjxuNmIMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIGOj/sOsJFgnc40ERRQj24e8DM1Rf3uOEz/qTLr+\nElvAAiAdxYbC9ksH4I+fHpBS5VJIz3aSGfW/xEjuJZ6+IR6L1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5551", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5551` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISASoLORw2GVc9ygmEGWFXzURnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkMmMyY2FkLWIwY2QtNDNhOC1hNDJhLWVhMzQ3ZTRjZDQ5NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWU4ZWU4ZTktOTc3\nYi00NzgzLWI3Y2QtODFmYTA1ZTM1YjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ1owhKdqW5VDxLZuWTzYJFPNos+4kixq7+7njEd0eBuF0RrRWhssbzv249Wa\n35a4vqoLkd+XMEHAgyluBs+fSaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk8NAJ/FLjEJqpqZltIWE2wYA9hYwHwYDVR0j\nBBgwFoAUtjrYeihilvq8bZy70h/KSaKvgu0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA5srtabApCDAj\n5HJDU6D/zLRoYxOg64hXhuZoqobTckUCIQDEABJZ3H+FuW9H4ipLraE/EhkRFU3A\nv7v3ShqGi62TSw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU8PEeuIq/q7Z+pruF3n+szzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDJjMmNhZC1iMGNkLTQzYTgtYTQyYS1lYTM0N2U0Y2Q0OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvdKhoCFUYI9hu+HYOQm8Fcqq4RjgwlA2x2WCoKT1kQsrn\n7OAZL2ywd7rslrPlryVvOF+3Do7cXDf2OzofJtoHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtjrYeihilvq8bZy70h/KSaKv\ngu0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJKg+Va7vJh4f7eN8U71ypLtdfgJ7DDma0s7ZPdrDIJNAiEAjHYvk2PO\nLFLbC73y0RiDO3mZo/skIhO0ckFm+zkZhkE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAUBi9Gbg3bMOoZphvnK3IEDkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWU4ZWU4ZTktOTc3Yi00NzgzLWI3Y2QtODFmYTA1ZTM1YjZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYyNzUzZDky\nLWYyYWMtNDJlMC05NGQ3LWUzYTk1ODQwMDFiMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA8cQ2dI058WHjMdSVHwYKqF8oaxmsOYilsr3Gtb/MDgksU5gmWWMT6G\nE/mCX6+LM22UGSZ0kPa6tbUx8JIQ0eejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJPDQCfx\nS4xCaqamZbSFhNsGAPYWMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIHqbCTjcoYsfdUsh3OZM0gy+X1eSM2hTT3gnWnaF\nqbuNAiB/Z8oN3pG5ag/GLwjKT+lWIPh9QS701Z5pBD8t5/FpWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5552", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5552` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdBoeGAjLHblr0L718wO4mqFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0YWUwNGJkLTMwOGItNDY5Zi05MmQ0LWJhOGFhMGVhYjQxMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E0MDJjMzgtMzFk\nNC00NGM2LWI3MzEtNjg4Y2MxNzNlYzU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJkHqJlG3/ZEJjogyZWV8U2qlgdTrnTPb1PHtw7e+TNnJ7Qpfchp6YtI6SyVx\ndGwhp6Wv+x2jHsZ8Ua36GxwdF6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeZKtT/UqcFR1w0XMCp1JYLFObP8wHwYDVR0j\nBBgwFoAU1fS6hCfgEZAhJJVmUlmD7+Ebrz4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICphe93mbPgMX8L3HkfKDt0ErgoxQb654E1nVbq81717AiAXY7b0zyI0NzNT\nNjbKAVJaEvKwmwRms4aUQjxP2ydWmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYbN3/9EOlP4xr6uwFouE+1BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGFlMDRiZC0zMDhiLTQ2OWYtOTJkNC1iYThhYTBlYWI0MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDIqbZ9rO7L0beAytgkIHKG4+MFn6X1Bpr7H+wI7V0RW5O\npTa8paxR3zBaiVqQHaL+2HYT5wtW5aN99lgXYGoKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1fS6hCfgEZAhJJVmUlmD7+Eb\nrz4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHbFKXQ2lCXPOOGWv+F/qEkdVfI/LGnU3yoT7gqF3Ot4CIBJv8QRPm8v9\nio8xGhUw3jJbvVPi142NEs8x9h6qcqWX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISATTGAIAIyuE/tkZylWzqZ/6sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E0MDJjMzgtMzFkNC00NGM2LWI3MzEtNjg4Y2MxNzNlYzU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyZTRhNGVk\nLTlhMGMtNGE3NS05YmMzLTFhZWI3YTE2MDM4ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF+nUPT114xhBYYezRP2RpZXINkKpH/ztUAvKaB0gieugh4Ts/hRAQ42\nPUWblmJFrTWsX3lbm4RUn8z/mTEQTWmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHmSrU/1\nKnBUdcNFzAqdSWCxTmz/MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCLKEvQJxx3hzmT1RGumCdQG2EgsY473hJMpf0p\nHRhmEQIhAMEaoLs+FRulQBXSOIMTq4LW9bLjVbO7JN/vL1CtOaqF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5553", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5553` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXavnt3vxSqqIUaCNa1bN1IhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NGEwYzU4LWFlN2ItNDM5Yy1hNjk4LTk3NDUxOTkwYmY1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FhY2ZlOTktNWM0\nNS00ZjVhLTk3M2EtNzM4MDE2ZTViMDY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBmY5z0xv9JR9EnocStbUNO8C1QLa08q7tP0OI+FvakiA266TCwWXVYvtNMnn\nrFU6T3r1faoEasmcFtMzAUAxvqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwho9bwr6X8C79L0r2EDHfclw2kswHwYDVR0j\nBBgwFoAUP+GteNJ/Ld6vuQUFFMi0bka1P2owNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDsXcAbADSEkMggtvrronBmgrMY3EtkoHzod5p56AbnzwIgLNCeK5jIKPXK\ntOdseAsUSXL9YbLAGOWOO/p/kCf8z3I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQOxShASnfPSuDKVysnxg6H1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDRhMGM1OC1hZTdiLTQzOWMtYTY5OC05NzQ1MTk5MGJmNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhlWZLghV6Zsye/mEPCDFntcG7reb5e5zhhuS0qwPKXbJ3\nv42zJEgTgV1DP3ocm2PxB7PMyqsftjHxPNGmysBko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP+GteNJ/Ld6vuQUFFMi0bka1\nP2owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJnctb3c7vMDdOs9GzGu39O7q/Ibjmo17ash3NB7Hi1ECIQD8TpROroJl\n46EzM9eFCqFzhXQN6VBkeErT3pD5i05QbQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAaD4OaisjG69hviAfU7p/BU3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FhY2ZlOTktNWM0NS00ZjVhLTk3M2EtNzM4MDE2ZTViMDY1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ1ZThlOTJl\nLWQ0ZTctNDcyNi04NzkwLWE0MTgxZjhiYmRjYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFZykDkTl1HkiwYfPeqKZsP0yTefkYOa1U5eiCwSc+Pfdc3L2qOyhAHW\namKAc2vJkoLdDnKGFd7KVnS77W4J1yqjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMIaPW8K\n+l/Au/S9K9hAx33JcNpLMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDGl7l0fe3nSNmah/9WOBcyoTDByYiuW8VEFywH\nbSgcvgIhAKgzRa1V8MQjGwbq0bJlxrmBg5og+s69TqmnA6fYBge2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5554", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5554` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdpEhtn1uMXBMb3gcAftdE8QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxMjA0MzU1LWFhMGUtNDFjMy1hNTFiLWJjMzI0ZGI2MmRkMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTg2OTZkMzctODNk\nYS00NDg4LThjY2ItMGY2MzUyYWY2YTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES02dIVRsZyO+/oQOKwkk39oiExtMxgjPUGHqgnsTwc2NnTjVGYfhPJODLsUp\nyfX778/D9/y97jx4mAI1fXEntKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5FotfP/Z1lbUYYtmNu/HG6sSDWUwHwYDVR0j\nBBgwFoAUW8DeZwXC5fTVQSwSfdxOmjlpMNgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA5AL9n4J93CaLr7gPRRVbW0M4GTDJJuykFSjqtgF7oTsCIGjxUksrLxeO\n3LUs7FKGL9z/S8TfS7PyIupznQnAvgKR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZNqUXUs7ck7wyWNPeEJBCNLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTIwNDM1NS1hYTBlLTQxYzMtYTUxYi1iYzMyNGRiNjJkZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbBeFvR30uSBZf6GYJTdRcLOs0fqxZEdehPxQGg2pRahz7\n1Ja+AYDg8/pMN0GZlbh/JbgWacpGhqU52OG8KzWgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW8DeZwXC5fTVQSwSfdxOmjlp\nMNgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPZ7jXh16wVthgxrR8de9rEfAe4SteaJQzpWgULlMDw8CIFPDCz5GlALI\n61RoZ/dsIZSHbOGDLgGQ9AjBGvbyFZp5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAXnBKBEV9CSaD1AH92AIqrWCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTg2OTZkMzctODNkYS00NDg4LThjY2ItMGY2MzUyYWY2YTdhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI0Nzg4NTQ5\nLWM0ZmMtNDU5OC1iOTY2LTU0MDQ5NTMzZDU2NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPEyCSdSUzDqXrsF8bDq7j+JCwrye1FQCevkQWdNeoWhjq/tof4kKTrD\nD4YKwh5rleYyNAMMkBYBGyZF5gHOR4+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFORaLXz/\n2dZW1GGLZjbvxxurEg1lMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIDF6cEneM75tovMpVTBLW77BHyx9Xx/dYnyPbRn4\nDFtFAiALBJMlKD/T2eoy4SoERX6t6e6RFmNyv5dyVrzXAkB/Xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5555", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5555` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAbrcHKYu1wpH5Fxx7Pgn7QGLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMTkwMDcyLTI3ODYtNDBkMi04NWM5LTY0ZjcwYjA2MjAxMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcyYTVhNzctZjcy\nZC00ZjJmLTk5NzctMmU3MTlhZjZiM2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE79P7hQbiD7GhXZrrWq9VjBxnRVdcXuC9I+uspcYALZgiCMrxqEkd1khINYh0\nLq4rvWJhYF7jocwxWV3BJpOxpqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU287FWhd1khlEWKSSqG1Na022GgMwHwYDVR0j\nBBgwFoAUq+jeZvrAxT/5tj/jkDEwKcAKcWMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBsK7Gzlsi3/1KDMR4e18nAFno930a9pT+SHdvoR7XI\nxAIga98FtSRXvWbjiXvbkqqq2+8EWyACk6MsdXqlGy3LO+Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWKas0ig3nNtg1Nf/n4j8O7CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTE5MDA3Mi0yNzg2LTQwZDItODVjOS02NGY3MGIwNjIwMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASD7wfHyvRruR97WLO/J0b5dUM/3d2cMVvDitjhdGuO+NnJ\nsI8sswjepsEjfaDxoGbyfka0DKhakf6nZEG77XGlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq+jeZvrAxT/5tj/jkDEwKcAK\ncWMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOfg9s1nIy6o3/62C+qVk2T6i48/ahp+7RiC+zrc7R6gAiEAksYNxtU2\nxhLJB+RMf6jBH1meqTdzxvRRisjUdWCIQZY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISATREx1REwUVWGHbG7JrvJIelMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcyYTVhNzctZjcyZC00ZjJmLTk5NzctMmU3MTlhZjZiM2M1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcwOTE2ZTYx\nLTdlZjQtNGE4NS1iMTIyLWE4ZGFiNjQ3ODhkYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKTMFESZKUHst79m79EizbV2po2AysOJfADDHBIeZcrzWEpu8/9FPC3y\n3Cu2HIb+Qrgw9g+Fg+PjDYNDxdqrmUmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNvOxVoX\ndZIZRFikkqhtTWtNthoDMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIEYvd4HJrIUEYAsRLdA0eOBG68ngaMMLbZ4607SX\n5EjyAiARUKc0fa0wO9EsSZ2/d11UkTXGyns2wXlx/h2yW4yg1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5556", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5556` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAb0RpRs//wluNdTx9CIrqfbOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViZDc5NjdhLTA5YjgtNGJiMy05ZWViLTExODUwMzJlZjhjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDllNTE3ZTAtNDM3\nNC00NzIyLWI0OTQtZjA4OWQ2MGNiNzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmygTkegzRoGuSyw8MQWClA1j5c9GYM6u6Qa1tta/h2JGwbVNdZRsdPdOKr3I\npIG71gzIcwlUAdoIYQ+9FquGg6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV9kouh/SjEHlWydKK02DyycjztcwHwYDVR0j\nBBgwFoAUJnBlPM0jV4mFkVYt81zSBIsD7U0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA0rYatdwzKG5FsEN3vTA1y9hhN2mOAcbBcY3Hic2k\na10CIGajBHcLU2RrdokGcZHM1kcvdqLpHWi5Hgsid0jBLuGR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXZCm1h0sHFMqlAKsppt3nI7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmQ3OTY3YS0wOWI4LTRiYjMtOWVlYi0xMTg1MDMyZWY4YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPVXnTxKzU1WKviBqoa1gvt9C8MHNcNO85m03WNxvcqPGx\n2195LRT8NCfZC1izmkzO1a9D3/2j2unLV0mVq+J9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJnBlPM0jV4mFkVYt81zSBIsD\n7U0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRKTKbfWK8+3q23P/n23D/u6R2r6OHWuSiB0+3JfgbsUCIQCNmPitJOPZ\nY4LxPvKt3UAgQO8QmuwYS5qX/O0UhfKM/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAYIFU+PQGML5RDeSZZtlnuzeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDllNTE3ZTAtNDM3NC00NzIyLWI0OTQtZjA4OWQ2MGNiNzhiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZjZmYzYzY5\nLTY0NDUtNGM3ZS1hZWUzLTlhNTBhYTA3YjcwYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNLuzugr/8PENn3nxf+6OV4JTMEx5uHzxY2w5dRqx90+fDmn5VutCJ0I\nmd8OnVE5xiT07CiDQdw9rCgpAmntSqyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFfZKLof\n0oxB5VsnSitNg8snI87XMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCbjIHU+dY7R82zVrhni+XhJjNEwINf6HJ8oAAv\n2jaewwIhANfx335B2UXqnsgGabR2/o2xIExKSRlBoWEKp2d54+4D\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5557", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5557` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZYLnaRHPxInfcOnSn4W3vjaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlNzZkYzBlLWM3YjctNDU5Ny1iMDg4LWVhODRkMTliOGFhZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZlNTI1NTgtNGY1\nNy00YmUzLTkzNmMtMTc4NWY2YzZkMTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOxKqAW4/RlSzii/rhPk14MtwCnO31BltyWjExi62M9Aa4HoOuRUvBWSzT2Xg\nfIWhzNE9lNCtsM6iNT7lkJW7D6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbYd54kJYBcMAurimuoLhZPQeHSkwHwYDVR0j\nBBgwFoAUvfIcyLQ3pvTIlmwpCE3adRmyR70wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAh/p0wSIVCtcNbQ+nSP/qEy8ewfTQqL76LFczhWhJ3UACIAm1\nSq9Sa0VdzahYjNFbFOtzdV1+oKYQUY/fl6yATfQh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXKit6fRulMAzsD5T2lYRyDjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTc2ZGMwZS1jN2I3LTQ1OTctYjA4OC1lYTg0ZDE5YjhhYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+HrPAefUH3erXzzqdhIyakfqfTf+J2CeCniUDfH1opZ+J\nx2cX/C6+IDqhI1XsqW+8g5vdOl4tMIC7+pRXqTeGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvfIcyLQ3pvTIlmwpCE3adRmy\nR70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXz/ntDhdtxk4+tahyl6FD4+UqRahHN878gtpmmBZKeYCIQCa6nVGvh1b\n/yHYbA5+y9bYwehUN2/+7MknJBgLLecPFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISATwgSzrHc2cNfv090sbGpBHYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZlNTI1NTgtNGY1Ny00YmUzLTkzNmMtMTc4NWY2YzZkMTU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZiMzljMzUx\nLTRhYzktNDYwNC1hNzJhLWQ3ZTNjM2E5NDhmYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK8pcr+76D1lO4PG3ZwWl8HZmK6tu1wmn4V9S4sKI4dAvSmjzkH71uet\n3T0ZUExbohGDgZaoz3rlGubgF6ulORujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG2HeeJC\nWAXDALq4prqC4WT0Hh0pMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQC9OWH2RMxBc2wxwBfYR2IsJm42zI6sNWsE99Qd\nuDSVlgIhAICoHNX6YxT8qgLpT5cUaHl9w1pLvMA5Nzp590xeGXlm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5558", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5558` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZ1wozbFwW1110/6jqeR+/eZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZGNmZWNiLWU1NjAtNDEyZi05MDk2LTNiNDM1ODFjNTZhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTNkMzg1YzUtNGJl\nMS00NGRhLTg1YWYtNGRjNzBlZjljMmRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc2xLSE2Dtb81crP65SPFvCZOVZUAxbTq6PU448BwQX0WCDrkUAsQB+sAkLjk\nky6omh6bdx7PrrsmzGISmKWX36OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfmojgTfr9V9EpsyqxMr0hd6jEnkwHwYDVR0j\nBBgwFoAUVmITtjA4fp+H2YV9uEsZu9kBWyEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAtu+rxhdyMUcMhKF4AGxrfH22BVr5VMez\nH8IoYVPf/rkCIFhqF7bVMXAw2gyQo0+3BMH2fHqNWOAR8aZ+3Ygw9E70\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeh+vZP1dVmkFYx3uhBQajoYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWRjZmVjYi1lNTYwLTQxMmYtOTA5Ni0zYjQzNTgxYzU2YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW3iJgAfT/uo8dRD821mmIdJcDKKvvEHn9EmVFO2KzLui0\nFpjAVTeDcz4xc/3++iJaOQDWKbGgALrl/hu75MsYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVmITtjA4fp+H2YV9uEsZu9kB\nWyEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJszzexND0umtg1FjgEK6HyYsOZjvWcRF3OdQ02Xop2nAiEA08Fz3jgu\n5K7PW2M4XD8w8jVINmfL+NR4D/rkaH7pbo8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAS/tOWC7IA3xAwKUh8Np2UX8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTNkMzg1YzUtNGJlMS00NGRhLTg1YWYtNGRjNzBlZjljMmRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNlODBiNTg2\nLTA0NTEtNGZlYy1hYTVkLTBhZjE2Mzc1MmU1NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL56ytphDdMYJtXW5ARVplrodB4dg0P2hI1Tm6RNuY6B0FfPO6Mr9DW0\nbYtuVRu3ZqY6vyeHwiyJnFx9v0pHBvOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH5qI4E3\n6/VfRKbMqsTK9IXeoxJ5MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCc6/mtCGw0y0FZd7weEMMq7Z3RlAfYKpdoO/Pk\n7oN30gIgLhftQFSl2Y2q6aYgxXuu/mQqwNUObHk7g5o39eSg0jk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5559", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5559` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAbsAO6j1WQToeKqFmEef1JABMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiM2NkN2JlLWI3MjYtNGY2My05Mjc5LTdlY2M2ZWNiMzQ1YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDM1NDg4MGQtZTgz\nMi00NDRiLWFlMmItMDJhZDE0ZTFmNjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiZWzau6EDziTlBWGy5Ldj4neU4yMacqYCqf3msTog+g9ygazKPl8TTN+jdtP\nj6O2UdiPGBbCn60XzHFbuw4suKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYknWsirznkZqlJfDfbtUrKQL/SMwHwYDVR0j\nBBgwFoAUsUoR4lLG1WxJmC77xTwtTyjB3YEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAxEHv9B5m+P9NJVWRTVwzde9tFMj2F3Tm\nu4tZSSKzhJQCIQCwQGGppJ2Q9ziHC75QDjhAT+SUNRSiAGdeSEBtZ68yQg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQwm72C4FF4hjWVYn0PSOkm4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjNjZDdiZS1iNzI2LTRmNjMtOTI3OS03ZWNjNmVjYjM0NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQG1perBRX/nEBm/hNStRTJrGKTu/ECwGPNtJH8HOjyUPrT\nY7SCvoYCvZOqH/GzH24iZ1dn9oYdqwxHI89ZqAoHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsUoR4lLG1WxJmC77xTwtTyjB\n3YEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUKMU9z33tXyR2orUDongsqF36ZBi4y+0C7OYjR2vnFcCIBtuwAzBq8pY\nArf9mBg+VQK4Xk/bsVechYkrZMmRQuqq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAerqV9/6yOCqwRUlDBxUUulzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDM1NDg4MGQtZTgzMi00NDRiLWFlMmItMDJhZDE0ZTFmNjFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI1ZmIwNjA0\nLTkwNGMtNGEyMi1iMzRkLWM0M2Y1ZTA4MDRmNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOHvTsLpYbAwLRk7Vd1iD5u1mp5I7owzAVagM6/4xrEbaWZZWwJom7e3\nAqkCNYNWoSxg+0hMrUVov+66aka5rjyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGJJ1rIq\n855GapSXw327VKykC/0jMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIBwy24DMyrnOUuB1TuVvGeTzNlYf440oNT8HLDBy\nyCKiAiA6tyBeLzd/jt06pMjs93xEszrz2aBFdqNowmsaHT9q8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5560", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5560` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAawIokUNgRNLtchuzZqqMMcGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMDg0MjM0LTM5NjQtNDBiZi04YzNlLWE0YTU5Y2E0NjllMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZjOTYyMWUtMjRm\nZC00NjM4LWFjZjktOWYzNWU4N2MyNjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsdO+R+rA6BozX1QN4kf5fnHu/JLwM+NA9nyive94nZpFkdes1tNHvG3dWtp7\ncMVNu5zG+9RVz91K4eiiESsHJqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhiMwXSWzTzQhwC8OwQidknIxA7MwHwYDVR0j\nBBgwFoAUty3a0rB6na2G+Ix/H6jFlYRunUAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA+2T/PsJArnd6\nCQQwlAtpaqLvqqijOxh5k7hTFAMHw2kCIEEdjmU+XJWC7u6H9LR9ASuLmtgR0L80\nwjs/uNBlCzEg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdLPW62pNd1xymqQybg1XhZAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDA4NDIzNC0zOTY0LTQwYmYtOGMzZS1hNGE1OWNhNDY5ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT23FTlkdOeGVS5azrMG2hoUJDHSpCIid9rNvhN/jV9kOqw\nIlLJup42RzHgIP/QADZkwTW1s8G7dVJOpPdJMTQao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUty3a0rB6na2G+Ix/H6jFlYRu\nnUAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALLa30T2zOJaWvUDYAl9bjvNUqly6OyY9uYDW6NHzVN6AiEAvemZXPCH\nNxhNufU0nIsOCCwPMFOzzdxTLxKCz9k/jr0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISASGqqaCHIXxCL/p4o5qPT+0kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZjOTYyMWUtMjRmZC00NjM4LWFjZjktOWYzNWU4N2MyNjUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEzYjcxMWNl\nLWY3ZTEtNGEzYi05MWM5LWU4YTVkODEyOTA2YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABExNs9tdX7KVskKJyQHK938NcFV+c+kE2vgP/qVrSZ7LLS/8+r8+RTQu\nCWgoMhez5JGGWRa9HKGg3tP/1fAxNvujdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIYjMF0l\ns080IcAvDsEInZJyMQOzMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDBKBISbtw7JhkbhY6tQDddVNSYC++kIzMRCYFY\nydLEYwIhAJHiEY8jhkVIS8JFs4h8iMzabHifJatM1I5JZO8fhkSu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5561", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5561` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbi+E3J/lCn0z/kQj1mzd9e7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlZTkxOTJjLTE5Y2EtNDA1ZS04MTNkLWZmM2VkZTI1MmUxMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk3MzNmODAtODY4\nMC00ZDJiLTgxMjQtMTE4OWVlYTAxMDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE83rVhiB8U3LhwyCBwfx3PzyMMWpYY0lEB7vV84u3C1jZzwqQhKG7Slgqc07q\nKz3aLCdiLXXvNxWmj4BolhALuqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5asc+vBJFilYHMLa0lcTDWPsA6gwHwYDVR0j\nBBgwFoAUplWfrlh3TnMj9Z/F2wojcAgQ/fwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCD6CfuTXA9rwRGggUlzUrA9dcM/9NyR9U/x2xlFJ3OPAIhAMI6a3pPKvMq\nhcp2PIoWxDUKFY4goArL7jmdEr95azmQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZH426p5Bc2OtkgnIKKyJYThMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZWU5MTkyYy0xOWNhLTQwNWUtODEzZC1mZjNlZGUyNTJlMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+02pZtADya9ZRShljA5jnUydpIUcoviFQRz9V7O9T/eQ0\nrr2w1X0AtGt5xjHQeRD8eeviEsbs1Y4RbI2b8leIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUplWfrlh3TnMj9Z/F2wojcAgQ\n/fwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ22DWKmfHRg8/Y1RxBq4fxwyf0WEx8On7lc1/KhamH8AiEAhzqsFCTW\nCI+hgxvdMtIKXkL1xYtDFyqiO+RWAY5lrq0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAePzBSSVQNSLT1cXZ9hb5Ni/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk3MzNmODAtODY4MC00ZDJiLTgxMjQtMTE4OWVlYTAxMDU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUzZTNhNDM0\nLTYzYjktNGUxOC1hYzk2LWEzYTFjOTZlMzNhMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKSmTMWLzcUxp0NipWQ1u3C6ec9/+bQ5/bqefQ8Gr4/I2dmTWWY2hJTA\nCwzxezaoztHtBoLDFViqoTTjWdBY2kejdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOWrHPrw\nSRYpWBzC2tJXEw1j7AOoMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIEIVXbzXp1JsATd3ZkFFsN29udSmX1Uqc2a7+1Z8\nfLvDAiEA3StHq+g82lAzkaEKcOnKPSQ+c0zreXZ529t7XbbjUEQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5562", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5562` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcnF/To6WxrKwNZvhnqiW3eaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwNWJiYWYwLTcxZDktNDUyOC1iODYyLTgxMWQyMjI5OTU2NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg4NzUyODEtNDE3\nOC00YWM5LTg2Y2QtZTI1YmZlMWVlYmU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH3j788JuUHaD7Zv3Z1UNTFQaGKGjCa6zFhR18SZmPEZ7uB+fDJc9Sr3OAQ4i\nGfYwhAFxv7CkBApgvTeqPOOH8aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUebCbRgg6q7josCRd48fnkp/ZblUwHwYDVR0j\nBBgwFoAUuNWyU3FPY4xNc4IGxlRdL24+yjIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCJa2a3gMf81b0JPlaKRHT/hWg3Gesq353Yb7i+KUzezgIhAMiKjox2NqYJ\nctCAhH/+AHGOHMuRalZUeKP8Rb3JZyA5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQNZ3bOk61340eh/6HY5s3hcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDViYmFmMC03MWQ5LTQ1MjgtYjg2Mi04MTFkMjIyOTk1NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpC8s38QwG2qmIrwozYpAAnoNVVHecCylTb85WvETjTKtn\nfwKxNMCzQTwTpIPOmL2X5w9dwLYX/yHCVr+7Oda/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuNWyU3FPY4xNc4IGxlRdL24+\nyjIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUm43Lhm3Y3Wszy33J3NyuhFwnWfFL+09QpCoH8SRNgACIGIqF00NlCdm\ny1aILq7xBMQroYcElYXSMckzaNqHpwV1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAYbD4lAbbk7AlxGe0U/aZd1eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg4NzUyODEtNDE3OC00YWM5LTg2Y2QtZTI1YmZlMWVlYmU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFhODM4ZmU4\nLWU5ODAtNDI2Mi05NGUyLTUxOGVhMzNkMzhiNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFi6rJKjuf2C8Rd/9ztPoVh7pl5CAJ/p8AZkxruTeEhwsdpdwRVMhNC9\nrnjkoXhEeJ2zLqus7tMuD/pMUXwI+jyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHmwm0YI\nOqu46LAkXePH55Kf2W5VMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIFPxAdjT9pGTI/9x3URNqAv8W/1dyOxjP6ZQtfYQ\nhytIAiEApUUL2e+dRysnrqecRXbOE+K59onUQaKhJrJA9w6RPs4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5563", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5563` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAeBrT+OkchyltnGfzMyl5jzHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmZjI5ODc4LWFhNTEtNGIwNi1iMWQ1LWU0YzczZDUwN2Y5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVmNDcyNWUtNDdl\nZi00M2Q0LWFjOTYtOGQxNTc4MmYyZjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwnVsdASizEUPQwD+XlQpDAh+Zeg9ks04APuyU34Z136dSg/zIXWkv4LBV7AV\nZsIK+z0CmuEDDQ1oprIOBih72aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcap76r6YRrc6nJk9fu4Fm8/enr4wHwYDVR0j\nBBgwFoAUMUW16dbjfsVoldrUR7/vTIGzITowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAi9DiRWeTNCX7w8Dbogeql/789PsTIW32jWm2tQZZXogIgOBLa5RseHJ09\nzdEuA1M3aYRQo7d/1kA0IAw9iBcmWO8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ1GwBcwm5mLyi/mqQVALdZZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmYyOTg3OC1hYTUxLTRiMDYtYjFkNS1lNGM3M2Q1MDdmOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJJefGS+qCJzDKQcSUt6O+qQ2gljOYEwfAwz8MJAOteWlF\nqmRk0CUvdsJfKkTebiWnf1c+9gy2nchrEXBgHdhTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMUW16dbjfsVoldrUR7/vTIGz\nITowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJCi1xhuWUAoAIgW5oeh4ktrthIAg1YudjYXzCVPmRv/AiEA4CEWyMId\n3VPuvTF7PBSqkzR9y/4tRl2Ig6V4kAuT1Xw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAWcsY/fiZWYxFUH7P373XoSCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVmNDcyNWUtNDdlZi00M2Q0LWFjOTYtOGQxNTc4MmYyZjI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFmYmVlNzA3\nLWM4ZDYtNGIzOS05YzkwLTY5MmFkZTI5Mzc5MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNb3+eVnaQckI7DEtMASA216iDcVJlLGROM6tzPaxbLTpe/qZM44GMC7\ntnEpzPNPHs4Pu+Bgnv/N7ssyz2hSiX+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHGqe+q+\nmEa3OpyZPX7uBZvP3p6+MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCoYlGAQBYJyJFaFDah5JUDlWvSPjrfNjGTKW16\nZt7vRgIhAI+OA4cdD7zkV+fFtB6qVwzVO3zhk6ErJBEl8ASktoip\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5564", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5564` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZ02FKm0XoKgG+nNWkO7zXswMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3NTJkN2ZmLTRlODAtNGYwNy05NzJkLTIzNWFkMDRlYTFkODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZhMDNhOTMtN2My\nZi00YjQ4LWEzYjctYjVkYTY3OGNjODBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZbAfDiM3xZcKyfeWwfz8XJruQ+KsXyTZ6z1loM4JktdpEwb/b62kJFtf3lkL\n37Ze1xs7fAEw2AKkHPLxdD6YQKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyIgaKOD/3RkQ7j3R+SqVhKk3LmIwHwYDVR0j\nBBgwFoAU2cl+VfjB4rJ7pIcn3JGdG8RCCLgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA4gEgeTxOaeo0nJ2as6noXoAnBAh2kYp1K4p/ljId\nL6ECIA6QXvKrEQrWdOUCCy29e8EmVS7R5wvzl389HWFFXqzk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaBzP7DvL6INkgPViOel0tOWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzUyZDdmZi00ZTgwLTRmMDctOTcyZC0yMzVhZDA0ZWExZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUYPZBiNPojkXte+Z4jiwXI8MZbbLtCr8Atdxncd++ja5A\n8MGZFvL/r9RUVQLuvxCCjLSTvkhqLqTldm59ZMXHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2cl+VfjB4rJ7pIcn3JGdG8RC\nCLgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVSeXNXRadyfiHkWe+JdIPfr1UDQ3uWULZPFuxnjwKCECIQCgPgdGEsQY\nINRcctcm7p+Bdn363ncac6YedTa2yn7gNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAVWbtuMim0q/71pAwECatvRkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZhMDNhOTMtN2MyZi00YjQ4LWEzYjctYjVkYTY3OGNjODBiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRmOTQ2ZjE2\nLTJkNTMtNGM2Yy1iYzYzLTczOGZmMTM5ZWFkYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJrADDxxyXJe9PIWg/ynxBEN9VSeP42QNLEBcCCTyRYBGh60hxRtt7lj\nvdDimiujB0e0KmLR99Egq3ZOZfsXesmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMiIGijg\n/90ZEO490fkqlYSpNy5iMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIGr54UmNQN6980aT7YxuHLY+YGYFUwjB9tfqAiMi\nq5nOAiADJe7Xj2JY/02ZnxZTeiITrsWED9NMARYC4OvA83nLMw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5565", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5565` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAVBB4mnTY/+Uy4SbjhJMwJOrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNzZmNWM0LWI0ZDUtNGE5ZC05YmZhLTc2MzhlOTJkOWE4NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE2ODU0NzQtYjU2\nYi00YzE1LTg4NjItN2U1NjAwZTE3YTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo+Skl8vqtLpI3zOvocd5xELO+7GYME3G1ZWOYhzMOwBdHcOFmeU+XUt7etQg\nm7sAWgmIWS6ykN3FrcBbVKmy26OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ2O9W+hbnZaRWi/T4Iap3tFdxSgwHwYDVR0j\nBBgwFoAUdWtNu0RAGtPOZ7vnIfF+TPdQah0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiADCxPiQg/o5hem2zaap5Ud61P+ggFU5s9YdAPdN+Vp\newIgeL66JQ6FNpnzuy6gmrGRL8zNcQCzO0Qtx3aHwD5t3Do=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZhT+zoiX/BLevcxyPpB0NdCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzc2ZjVjNC1iNGQ1LTRhOWQtOWJmYS03NjM4ZTkyZDlhODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHY7ltJo3Iga5GpJOOcXU14+i5FDdReRieHRrlRsFULM40\nsamxsjxtIsFlv+UC29LTLfYzvld0Ln1ITRmqg4zXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdWtNu0RAGtPOZ7vnIfF+TPdQ\nah0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP3kSM/q2cqweb2uh6uGJMVqqvsnxDeUADdLJnWMZA8QAiEAz4obaJNb\n8LSfONd7HlJ0hXajNbBJe1wFkvPXSEa3z/s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAYgkdTQb/A2W8Z9fkYpMvIXTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE2ODU0NzQtYjU2Yi00YzE1LTg4NjItN2U1NjAwZTE3YTg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE2YTQ5OTk2\nLTgxNGYtNDhiZi04Mzg2LTA5ZGViNWM3OGJlNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNN0KFM+0IhbDDIj/GhAewwz8uIW4aqokY3eYL3vXqR5lWpJKn6BoGKt\nZ6BqdKlYLvnU12nbKUS1y5nUdoCJTXyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGdjvVvo\nW52WkVov0+CGqd7RXcUoMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIHo4pXCcyZdPzpXgFfPpboEoNtttvBCl755ihND0\n8aTSAiEApYMxrm1Q2q6hqXFyERfsFfcJ/J33RJhlZvS8CpN1b2M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5566", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5566` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAWU+5DLhAhnGrk0eqYhnWZUMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyYjAwZWRiLTVmZGEtNDYxNi04YTc3LWUyNmI5ZTA5YWUwOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYyZjBlMDYtOTQ5\nYS00NjBhLTg5YzItNzhmMzk2ZWU0MGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8Qi0gHPc4Ql96ZO12n77jBSJAfvjXx2T76TWyjI0mewGQR9v/mTvAKVlfHmM\n8oNZMtgEdOsJkt5JZKsu4ZYdMqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBs+/ofddsQqwBDffSgSreqCEZJQwHwYDVR0j\nBBgwFoAUpOhmCnt4t1gFatJ9iu1p4865w7AwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAmRRUpZoL5RNpB9WVM8clLzEQUKlKqaoC6ZT5h/5u1OkCIQDG\nwERgrHdoSObb4fHlAVsN6J1rVtUkqGZXzAgN2ajwkg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXrwUan+QShTV36CNnRojpOuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmIwMGVkYi01ZmRhLTQ2MTYtOGE3Ny1lMjZiOWUwOWFlMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdYZEhQavPW53OZCSlyQxcIK6+kkaGkpmMlXWpXmW0rVPs\ntf376/Wy8RZsgxN1ILnGQh6OicfLqH3sYyBKz2d+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOhmCnt4t1gFatJ9iu1p4865\nw7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOlfZO0bzZqjqC0SnIPyB4SNNVInnD9UNY2e00adJJL9AiAhvsI7mAU/\njSP98XNju9plUe4wHo2q9ep3c8Rc5M1hIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAcou79vBLBvLtLTTfw5dZGtYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYyZjBlMDYtOTQ5YS00NjBhLTg5YzItNzhmMzk2ZWU0MGM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg5NzQ0ZWQ2\nLTQ3NzktNDc5Ni05ZDdlLTA4YjBiYTk3ZGVmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJLi4q378jG30jbIU+cflEEKQ+A0EmQZ9HzcJrWggmF5c/k0rUAzFyvF\nKgr56KRVa5zREvLxG4CQ+25mgNIv7xmjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAbPv6H3\nXbEKsAQ330oEq3qghGSUMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIGcmh9K63tBgRE0YmZQ4ycULH1TYInSaWpsNn64n\nepdJAiByPDA8Z3Eb3MOzL6oJfTo51JsuJ5KV/tE2a30ZJgWgxQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5567", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5567` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAR+M9scqJzfjzjFcd7xwZXAUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZTNmNTE3LWU2ZWItNGYwMC05MTM0LTA4NjhmMWQ0NWNjNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkzZDRmZTMtOGY3\nNC00YTRlLTljMGEtZTg0NTNkYTQ4ZTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaBBryYu2zA6Lr/lP3go7niwT10VeRMDBRXfJcbDNf7s9OdS7T3fA1sq7/xLr\nO+BsBuQrSuybFRydRH1x7KXqlqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1olz9evyFAwp9DWqNaA93ZftrdcwHwYDVR0j\nBBgwFoAUUSyl5vdrMBAe26BTGftOuIu0WUYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAmkp2LzdNPYyVxeOFknQcEsVKTsrvtNwi\nLOQHktUivwMCIHzsumGc7EB4UcxLHf0Yxln5vJmt2gKxx937AIgJQ18C\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAefF2gQluKMl6ECVeGBA6U6cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWUzZjUxNy1lNmViLTRmMDAtOTEzNC0wODY4ZjFkNDVjYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNtejvRZTwcEFrTv9v4vb77tSsNb099YNJ+DKxK1DfLUIK\nIVGXfoOc7grZey/od8Nh/VAInjkPM+b3o8NqJxOyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUSyl5vdrMBAe26BTGftOuIu0\nWUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC+OF5rdyEY8frNXOAzJKb4Om3gNWRBTNJs4uwLmxQGsCIQDNVf4nrcZv\nqtXx+Nw3gblBB2kll1tDACEXm98/X2R77Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAfrTCckMR4kUdNnAm/oiECYFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkzZDRmZTMtOGY3NC00YTRlLTljMGEtZTg0NTNkYTQ4ZTlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY3OWZiNmUz\nLWFhNmMtNDVmZi05YzRiLTY0NWMwMTRkNGVkMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGGy95dagUM32fZAIgm9XPP+0bAPpc/c2Ny3P1i7eVAaT+DI/zIP+hiE\n9iSZePXxdcrZUJrt5jCjaf730Pjjl52jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNaJc/Xr\n8hQMKfQ1qjWgPd2X7a3XMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCg+LHkQ9wsrT1Y78JaQEAV2E8BsTT6fBZUKwND\nkqThEgIgErqsvbTilJTgBUYdoEOh1NEahiHZ0MNLQsIt+37CcjY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5568", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5568` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAT8lcrphZfBDjtMT5T8Ef6TLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViYjQwMzgzLWIyNmMtNDU2Mi04MGM1LTE0NWY3OGU4MTYxZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI2ZmM1OWEtOGQ1\nZi00MDU4LTlmYTQtNjM2Mjc2YjQ4MTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhCE9s+y3TiJqrrrDfIXHkQh89n+G87r+z/Fmx5oXLQtl6kEjyhyDu0gQE1M9\nh+QFnYN1whBiBbQ4xjswaLJhsKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Fw4uW2o9uZvLZSn29PHzMi1DlowHwYDVR0j\nBBgwFoAUfNj0/Xy8qhOstcbWRYjNsDT/YLswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAhKl8RO/Ui1ZoXB9aPENmnO00ZLq5j8Vn\ncHT30JhnRk0CIHB9CCi7x1ppBtXCryyXvkxVyNRAfMjwDyqAoOoa8zLW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAef3jVCytFeJGuYEvhosouu9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmI0MDM4My1iMjZjLTQ1NjItODBjNS0xNDVmNzhlODE2MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7z1KFYY6cI0kvyJUxcavHdnN/y2/TV2o94G0RPnowBOdL\nifjLC7ZW4wav3cI/1U5/vBxC9gIyBrsSJHfWiNoFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfNj0/Xy8qhOstcbWRYjNsDT/\nYLswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJfysBuE+mPJ8tP/UywghhrgFFBNqa17zbQhDiKkXIK5AiBJiOsdfCcr\nD1Bb1BOfN0Hx4RTQQap1C4efHLdAy47fgw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAYfdC9V2LTaxL/ImR4cCgJHJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI2ZmM1OWEtOGQ1Zi00MDU4LTlmYTQtNjM2Mjc2YjQ4MTVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ3MWQ5ODc2\nLTJjZmYtNGNmOC05MjBlLWI1MmE3MTljNGI2MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMtaL9OpYpyNFAYHMeY/osM2Vx68unIDrB3u47g0c9UCm+RpeO9EJCR8\n6yjjL0k4gSoT3NzVPC2GdH2hiakBmt+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPBcOLlt\nqPbmby2Up9vTx8zItQ5aMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQCM1JZ5QjWN+KqMFWzgZmCuWZSTuUaWZPBsJu27\ndPRRXAIgIGl2A+BD3pxafFGCwsCC2y3Vr/zDkg9lHNTyzP3YX9Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5569", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5569` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAc07d0+Puhhh8bQp1oBHClnkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2MTJmY2Y0LWFkYjQtNGUxNi05ZDU2LTNkNzAzNTMzNGY1ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNkNmFiM2MtZGQ5\nMS00MWNkLTgyOTMtOTcxYWE2NDE4MDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnTbjJJp586uVUY8ktrGae7coikxLHqydZ5gNM988o5NAUNKGRwqSY4JG7Mwd\nuREtnDlSXzzJI/AuWUrBuR7dvKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfqiFL8jIpLqmW0VHQ6RoFbRTDt4wHwYDVR0j\nBBgwFoAUxraq4RNGFB/3I1DMlYujOCjIrc8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCXEWRhi9uRiC6EEwAXwNhCyKme\n44EN04zjoDOShI5FZwIgXwSx5gf+7PpPHclHoTJsTleoSaEZBjFBQlBZXrchPx8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd8OHbIfTnHmGEVG7iGLm3+lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjEyZmNmNC1hZGI0LTRlMTYtOWQ1Ni0zZDcwMzUzMzRmNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtzsoRvFEAGK7Wa+xrom81qrG0lZorA8I/g19FeBSWyfT6\nnZStiPOwOSSLCCVVt73LS7FqcVYfWEBDsxSrroSlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxraq4RNGFB/3I1DMlYujOCjI\nrc8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKXNOyu+GuEhHvN0ZdcmDjrIyctK8+LbP0I61ey6IKB3AiAMayPTPM9N\neM4eV03Phsks6HKb5EUi7fNfTSJzjFymow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAWoGpT430Rztf/27fa0EYc8LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNkNmFiM2MtZGQ5MS00MWNkLTgyOTMtOTcxYWE2NDE4MDdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUwZDlmYjE3\nLTUxZjktNGU3OS1hMGNjLTJmNTFkY2U2MzFmMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLGnU0H1m02ZE3cK2IFYEmHe1MZIPsdxwTz4Cfnj3VmgVLxQVkRgC+Hx\nJ3po4ZgiknhQKKKOH0+JbCGjFVhaj6OjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH6ohS/I\nyKS6pltFR0OkaBW0Uw7eMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCIr84yOE5k6yAwvb6btgUHpy5z4vxVsgkCBEJ4\nBFzjNgIhAK1dSEmM5dkJpc0TWGfPNav0LjX/Z+HG215raCBRyIy7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5570", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5570` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAcc0wv5a08BWYxCe3f+xtGDtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhZjJiYjEwLWJjY2EtNDE5Ny1hYTNhLThkZjI4MDc5MTk4MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTMxN2M2YzMtZGE5\nMC00YjU0LTgwMWItMjBkYTUyYjlkNTIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELBdFRleXK/4bGvRIYNdRU3hSHxSPeELf6+GvM3XrG2ugTbZBO4KSmtKAHrpB\nIWPAJXKk9gDXa+ov9Bta4XDgKaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA4Nm1uuVmZ9OKYll4KgyxyhK0ikwHwYDVR0j\nBBgwFoAU0SHmfM+8C7h2YyD8B8z/U49C2zwwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAI3TFwLv\n3jAycSN/lxMdGegqgrd8VR1ouzyF/C1WtBosAiEAjQnTM0tzbHtb4FY6ezYg7ZSN\nalSyuxfnJnQq2LQptCM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARZWoPxnK/F0ra2EZI8GBXQhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWYyYmIxMC1iY2NhLTQxOTctYWEzYS04ZGYyODA3OTE5ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkMO2Njv60T0CwkJY8qsebR/Hcc0gUVS5BkibS/tDNz9fW\nbAd0pz8f0/jducOfltKtlPB6EHAhBfNR103PXrG/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0SHmfM+8C7h2YyD8B8z/U49C\n2zwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANG0W5QWH6nfQM00ztxizBG2dks1Z5qLaqQWATyThq6PAiEAoZgE5mtE\n74VLm+E01w1AYLPz3T3hROSmGLCLvQOUiKk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAd66dNTUc/62oWOY119RstIAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTMxN2M2YzMtZGE5MC00YjU0LTgwMWItMjBkYTUyYjlkNTIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNkNTczNTU1\nLWVmZGMtNGUzMS1iMzE5LTFlMDFjMDY2ZGI3MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHtc/MrBrbf4b4FrS+BqGaNqAfB5R4aNHRW29iOHzDRnt8qHqvZ1zx4G\nBQA50Mj6uukBYmWXx+/vBELDFD2uu8WjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAODZtbr\nlZmfTimJZeCoMscoStIpMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIAqbadKPfIkCFQonjVERBYBKXXaDLMOlJXWEROIz\ncEbfAiA+1J3txkCYUNsvzOWz/Z/CJTR7ed0h/CK4UlKJw4FLCg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5571", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5571` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAWARExxV9I4QovogFtWFPIY3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhYTg1MDgyLTU1MGEtNDk1Ny1iZDgzLTcyYjY4NDliYWU1ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgzODZmNGEtN2Jj\nOS00MzBhLThhMjgtMTZlZGE2ZDk4YTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj0oEqtq/yrMG6XyJb0OV5b9nPJM/RNASTxOr1zuv5CwTh2iHhsCJqqybS6k/\nMyz8BoIbALgEg8TdXx1jNlJABKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUriSQuqK3HcQ02KemkKvp7MXVg5UwHwYDVR0j\nBBgwFoAUzRVscsdfcy4zzOxvZAImMakvz38wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKGYw/74W\nsHyCTZ9vkWRv9+k7lxuS7FeMPcnIV5UWjtUCIQCeAK+xpkQ97nnmi5QZ7cWi6gMp\nwqmq1MEzZpYgeBBsew==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATyfJIRw56ea4maSlIFyC1JFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWE4NTA4Mi01NTBhLTQ5NTctYmQ4My03MmI2ODQ5YmFlNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAST3ir5bbhtgggf7LDjcjEN/IeLOsMYVChEMSF38TJOzAVx\nLnHtI7oyB7aYPQMU0pi/y1PH5X/UhrQUJh2uDTgTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzRVscsdfcy4zzOxvZAImMakv\nz38wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFTbkaxCrPgixdg6w6TG5JQm3xEEQD+aImQgBbCo3bmwCIQDd/N6OI2aC\n1oTQhtl6Qm5cjNbn4DHGAdmTIv6cHAN8yA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAWShxKsSTnBfFJLwIq1PQ9pNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgzODZmNGEtN2JjOS00MzBhLThhMjgtMTZlZGE2ZDk4YTI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRlZWRkYmMy\nLTdjOTEtNGVkNC05MWVhLTQ0NTQ3ODViYTBiNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEMwldh757I2ZH08f4kddZYhYQaUJy5Fayf1m3WkvCRiRV5aOzpYv23N\nxLcI8W/w1O3nXqtVbQY6qqAD0OzMGDGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK4kkLqi\ntx3ENNinppCr6ezF1YOVMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQD4TR1+QgTbNqMF27sfOQRMDpIzaOwdKTFltg31\n9UHXJgIgbd7+WRNH6/0G0isMp7YCvGsvXMUYKrUvWy8jJt+bIQE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5572", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5572` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAQ3ZdMGhCTxKdAQ7zpnXmlLMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NzIzZTAyLTFlMTctNDEzNi05M2YwLWZiN2M1Y2EyZmYwYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNiMWFhMjYtNGE4\nOC00MTg5LWI1NjQtM2QyMTRhMDU4ZDJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZN2BoOWdBjF/gegxeUze0qLqyWOLUbDTS4/l6PJdx0FI7MsgdyCUR+IjlLRZ\nepJ6I597ZDD9M7RrCuSiXNtTyKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5e+gIkDFi2jksj90ZhKuG0ciFEEwHwYDVR0j\nBBgwFoAUYajHgmTidn1H+Oj0dcNO+74FkfUwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCxvYlt\nY/N++Q+is1e/zVXzU+F7jNeQapO4/Fyn5SSIfwIhAPRQAtR0GyPLUHgF2A8r+nJl\n4zYwGpt3M7kDMpv9MY6F\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU8aZNjz+1mxb36Rq2fRMRIAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjcyM2UwMi0xZTE3LTQxMzYtOTNmMC1mYjdjNWNhMmZmMGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATL7UOvDGT+jiO9pB7CLXCnkiOdFkszZKmRbFsYVjMqqN9r\nhgFOG/2ME3tPL2aJh7lwcYsli5rrhKm9Ur8mbAH0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYajHgmTidn1H+Oj0dcNO+74F\nkfUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALJ4B910bCqj8YVW2dS8OtC1Z7QhACobL3iiC1Tf3cZ1AiAHEuRrKfbD\nWc4NR1nDjMB36DHeLySwazlknGEzTidxkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAbL3XwgrvNjvi99se9xpN6p3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNiMWFhMjYtNGE4OC00MTg5LWI1NjQtM2QyMTRhMDU4ZDJiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyZWMzMWQy\nLWEwYWMtNDQ2Ny05ZmYzLWI2NWVhYTczMWE1ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHTCuZyImeGwwEWYznsACUQd5lxinLa/BG5at7fCNYO2UM3wTSjK3MxX\nHZ4VO/C/IkHExsM2/tdxx4ApX/BrOiijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOXvoCJA\nxYto5LI/dGYSrhtHIhRBMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIGBRBwoOGU+78nD0ep+HjtN8baMXm2w+ukamL+Xo\n5uWKAiEA9JuRZgt1fTdu/i6TWDYWeW+DM/P24Xz/X/v/mN0Jwew=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5573", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5573` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAZg714Rg0NG152cejKYdZ9Q2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0M2Q0NTUwLWVlYzMtNDVhYy1hNGUyLThjNjhjOTg0NmQ4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAzMjJlOTYtOGQw\nZC00NGM5LTk5MTktZDViZDI0YmY2OTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2SxN4MWmosxSqHiM4Ju/1QI5jMyVvoomWMC6sUhnGzDqhtLzm7dXADE/pdRG\nsvBKCzRdYt1ImOvRcRMhFckSm6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuMCVIaVSYxqRfNpHOMi36mcDCV4wHwYDVR0j\nBBgwFoAUuouGOSTEX/8hBtd6NvkE4PCDqAUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDaiIDTWHmOi/hbGvqx8Z71EizjwOI3+RDLPFaEOt0sRAIhALfW7/cI\n8wMGi9CZd9sjt10A+Y+t4ic14BD4QxIH4Atp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS+WtejvugmwoO+7psSKVz0zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDNkNDU1MC1lZWMzLTQ1YWMtYTRlMi04YzY4Yzk4NDZkOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYj214eR34vJgPDCD+83Y2XBOQox3hInY1Y6IdJUoo8fBI\nQMDDPzyZzGbupKeNgYVHw99iP+f8ETBgJo3TbgJYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuouGOSTEX/8hBtd6NvkE4PCD\nqAUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALuBSgIKa5RLCkeWSKyPx5qxS0P1hOmxTo8uGnRF4KjbAiBr2VUPRrj5\nl04O9bkW40tlOf1chayDBsO8/GEDQewo0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAS6oH4x4rJeg3MN9LmvemvQaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAzMjJlOTYtOGQwZC00NGM5LTk5MTktZDViZDI0YmY2OTQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA0MmM3Yjhm\nLWIyMzgtNDQzZi04MDQ4LTI1ZGVjNzA3YmMwMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGsYp5IuD1VtNYjAZn4hucVMB8pxwejofCO4OQ21scNo+/wsArdbqqL5\n2jI3IwWEf7SKFht0zXfpaxvQcWeV132jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLjAlSGl\nUmMakXzaRzjIt+pnAwleMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDLAxLV22fNhOhHRfnqaLzBxp/PBsqDwn1NgW67\n1QSNMAIgBNqkOE+1UaA7Ge2She+KmsA0LGi3Ylj0AQEy2Fl8ve8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5574", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5574` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAasLeWyNvMIIx985pbbvxWQ3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmMmM1Y2YyLTlkZDAtNDBlNC1iYjVhLTY5MzRiNWUzZDVlMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ3ZThmZDEtODUx\nZi00MzEzLWFhMDUtZGY2YjhjNDU2ODdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuBIi1mQiUVmA4v55JpT/RQoqqk7KM15/pYoORJS7aL6ofYiVkvx5I2drJ3SF\n0tJ1r7UmhdzB8vUz7nIVP4AOr6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTPdxBWjNehWH7cTyW3I/jFn18RQwHwYDVR0j\nBBgwFoAUkx5hdrClj5VoeQUcY7XDxBQApmowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDjxuKZgXAH3NoJtDNZsESYC/FZKtxcBOQ0UsdlxEqDFQIgN7wrYynY\nxZFQOHh4VItcQyPd1uKgGhZO/YmhecVRYRw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASaKJYmDdxROTcPc3TagR/+0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjJjNWNmMi05ZGQwLTQwZTQtYmI1YS02OTM0YjVlM2Q1ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrUdIGPSeSbwHS5Uu1MQJe/aUHYashbRvV8zusWY1rhdbW\n6bP/sTq/r3TVNnVTLRzZNkYJj+YeVz9tQBYWCuvio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkx5hdrClj5VoeQUcY7XDxBQA\npmowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHDdCkHfEHyWyrYT5mbSUUYB/2SWVCfhjE6FqOJnL/y0CIQDVSQ3hl6yO\nf4FDmZiKDqQnf7a6XZO12ZiVacobwyW6NA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISATfEYsfKFGOP+aJQUljP/WpFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ3ZThmZDEtODUxZi00MzEzLWFhMDUtZGY2YjhjNDU2ODdjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNkMjdhNTdh\nLTZiNDEtNDNkNC05Y2VkLTMwMDM0NjQwYjgzMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGmHJsZxzq5eCMwYRq9n/cIDq9fxB4rSOwAmoylGgKoSCcOBvTL2AHjH\nOSvZ3vAwuEX/xm8l0oQWmc1azc/eiMyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEz3cQVo\nzXoVh+3E8ltyP4xZ9fEUMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIF2QqFyVX+Pa77/R65AyowjjjcbIZq0k+4Nf74Tv\nAJMDAiEA7xeclNfdAPguLJGzY1CFwSxUnvc4aQIEM87Yl+U0g3M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5575", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5575` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAe3oSkryjhorI2QuOZWg0FcUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhYzc5MjZiLTI1NzctNGMyNy04ZDQ3LTQxNGI4YjJkYTMyMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYyN2UzMzEtMzEx\nNi00NzFmLWFmYjQtYTJhYmY3N2ZiNjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETOKZG4j4COTf8dkuvQFOJpGkCmdzFZ+tERQtj46ah3S1KlfMmLt4BF4yn1qj\nOpzMX9ti6v7JvlYWFp+FuvzmoKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsm+ZLBHdk0fqFuthuSNxx7tJsJ4wHwYDVR0j\nBBgwFoAUdoDdNRBBbltAlNR8OTACU3x3CMYwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIHmiKq9Ejv4lIsE0lIAKOqLrKbgqsZvAF1rWQw9XjEjmAiEA2CIp0p89fH7QPIgE\nq8j0hhIUQSZb6pH7L8RhBUs0RY0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXmfb8FQ6RMho9vHQmTAMhNPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWM3OTI2Yi0yNTc3LTRjMjctOGQ0Ny00MTRiOGIyZGEzMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATt2auW2A3tDzdRcC60Hyf37qbHJ6AJUBCcniDa6MOvNo3y\ngiGjoWyB9VEE5vUqmRo46mL3/pz7GVA+tfERTiu1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdoDdNRBBbltAlNR8OTACU3x3\nCMYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRh88la+jmBoAVcVT3RQ5Jt3sAFAn7TvfrtVmiZ97UqICIGGdzxk3gthL\nKoCoAIUtPRYUa7hznwAQ9cUe/hBC8jLJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAeC+FcsOaELfpI4fCvgVgtXMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYyN2UzMzEtMzExNi00NzFmLWFmYjQtYTJhYmY3N2ZiNjM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNjZWRiYWI5\nLWJkMTEtNDdjZC04OTQxLTVjNTUzZGVkMDdlODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPLf4OSitVcvpzrlixCgjRbZms6kr3kPcQ17WA52VLBAhZ9kspDr31VT\nJvfTja1AgBsPSVPfNS4KXUD4ILKJ/x6jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLJvmSwR\n3ZNH6hbrYbkjcce7SbCeMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDjDFNiRIQDQDa32NQoV8qfcD4spevXgOstUH9Y\nK0L91wIhAMn59BIlFeiqTzE/MsrA7+ITtroYJttUUGTt/3RZrYup\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5576", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5576` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAc2o8ZXw8D1dLckhDxPNQmcEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0MDk5MjBiLWUwMTMtNDk0Ni1iMDg3LTQyMmM1NTU5NmJkNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTEwZTUzYTktMmFi\nZi00YzgxLWI3MjUtMDQ1MGZkOTJmNTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgTog1IldkgIwCM2yDNHo6guxzESXOxFRzvfwuUdmeEXEQrNkOOxNcHycpbkO\nJ81UHzP9y4LSotFWBucOYaJWGaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG+b1w/2vjiaiQjjA3E2mwzQSk60wHwYDVR0j\nBBgwFoAUzVg0p8/KfeVD0ER0pocKM/bNWCMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIE3IUvWTGozo53KmNhjAQ16lu167NWZ2mwUvGlqylbXqAiBU\ne3An/54IgWyL1QgoYvBjsfYzk51ncGUlKzi7vBWPew==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf9dkp7G9RGdk/GkvIxCnmgqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDA5OTIwYi1lMDEzLTQ5NDYtYjA4Ny00MjJjNTU1OTZiZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARO3bSYkjouNYGWqe7AL7XsyA/kuLTlbnKFKeoqGExIwhhb\nKloYDKbolOvWqSFhckWSaejwBARmiLVgDuHxu1EVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzVg0p8/KfeVD0ER0pocKM/bN\nWCMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIja/HakDCuGvCTsfszJOiAnLUXb5emSbB5+FITnUsQVAiEAuxbAbhNb\nvwBdkWb0iCtF6rF1wKFmk8JZ+AB0ji3F6jc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAfqdDzl44BHX7HCX9olvqC9MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTEwZTUzYTktMmFiZi00YzgxLWI3MjUtMDQ1MGZkOTJmNTQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDcwNzkwZjU1\nLTliZjAtNDMyYi1hNWMwLWI1MGJhMzNmZTNiNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCdC416Wd9RS1kUGY4ivihf6ibQ7QH+9BvUn9RZGnrBXkSbIUFPzZbgm\nppQEtklOLZG/jNtVuK31f24N4vCd2pOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBvm9cP9\nr44mokI4wNxNpsM0EpOtMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQD5FYPItwQ8Mf2X0RcvEzvRvFviS9l+AGgA/YSI\n72qdiQIhAJ9jaDMALwA4c4aI/fEUynEhjT8tucGA3xWb3w6LjBMf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5577", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5577` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAZEUlpaTwTpzchAQemaOSIDWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxZTllZDNjLTZiNmItNDExYS05MTU4LTQ3ZmU3NmM4MzRlODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ1YTBkNWYtNzhi\nZi00NTMyLThiZDMtNjc3ZWJlMGNjMmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEWpiNB5L3ioAo+y+ruHMkcYWXs1LM1iO49lTIA8xWXhmN8VEcw8FFGof7sE1\nutDDNlieczUISEugVt8fr/b1MKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfA/dA7hMaXu46r3pAbneYExt06wwHwYDVR0j\nBBgwFoAURrbigzH6kIdNgkJWW1OOWw5DEucwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIGRtVJs8I0D3dvj58n5X4x8uDoFiDkWkgb/aWz32ZFAyAiBi\nDsfk9mDFiyYx7zYbhhjTl5N6b+xkC2GSOWMUxxp0lA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQXJXEZX83qMc7jggoEpVcIUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWU5ZWQzYy02YjZiLTQxMWEtOTE1OC00N2ZlNzZjODM0ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9DxfV1VQ15/xWucxiDrtUKxXHXTIpydMtsMOWXaL/Yz5D\nA9dtX79CG2STWAN3ZkFqhnotTirWWLzxgB4YA4Uko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURrbigzH6kIdNgkJWW1OOWw5D\nEucwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALPQnvTzT7CW+nheMxq85ZPqlpfgjE5JHwiBAYjNQbS5AiEAtmYmdJmJ\nMKQuML1U7mSwbhkahdFvKyDRyaUFOnDxfSg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAdu9w2+1Coo4A6v8pqXK7rcVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ1YTBkNWYtNzhiZi00NTMyLThiZDMtNjc3ZWJlMGNjMmVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBmOWQ5NjFl\nLTNlMDgtNDYzOC04ZjcwLTMzMzJmYWJhZDYxZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMgcRK7Va4M4rYwodhbq55z+KOyE2vag6IJXgds9q0zwyEfGtHFu3enM\n7pQklvV5unUILldLaPONtKc+ve+FbwajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHwP3QO4\nTGl7uOq96QG53mBMbdOsMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIHle6q+P9XblRGurvboXucV6SIJlrJp13WyO5v/D\nMFgYAiEApAGOWPMdSj5bFqKl2YGoeD7QLjfQodfTIwYKANa/6LY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5578", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5578` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAW+UiaePP1SklDJOto+SjXbyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2YWQ5ZTNlLThjNzAtNDAxNC1hOTgxLWUyMDdlNGUzZWY5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDg4YzhmODYtNmVk\nNy00ZjFiLThlOGMtMWEyMDVhZmNkOGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG1b/u6NyPIe88Kp1gNqokaupgRZV+2pZAph4tfyDOogFhReVndt7hixeDUdV\nNiRWfWt56wApsmSGHiopnbyAWKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Gluk9TYBDS3KUUZIDWUj9F4QpgwHwYDVR0j\nBBgwFoAUXR8GKIg2kUQu5kfWit2/Fld6b74wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIFWVFvFqcF/a\nQVe+3ZSKBmOJiKUsJBX0pwXZMdo1PCgJAiEAi64pkw0PyO3QIqs0rPe2N1jNk4mC\ng2HnePuhDQZG848=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATMmgMN68d3j77/6pArTyfnhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmFkOWUzZS04YzcwLTQwMTQtYTk4MS1lMjA3ZTRlM2VmOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNf6bvADMiqR1qifJ3N8EOp9kKo1DgmVqqqgTCuzZZ6L2x\nusrUyRbzyE+DJ0THIuwMcgmN4EVcXVWjtryeOmDvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXR8GKIg2kUQu5kfWit2/Fld6\nb74wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHJToVuEn7+Y8UNhxKqhJ/vWBFhjMQqKWCzOuh44xG8MCIQCjXuMxoZeE\naSA5mLXjzz4gKcxexNwDlG4mJCwsl8IMXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXWsArvBs9wXGhhBM582aST3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDg4YzhmODYtNmVkNy00ZjFiLThlOGMtMWEyMDVhZmNkOGQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE1OGJkY2E1\nLTRiMDEtNDQ0Ni1hM2M2LWQ1MjI1NzBkNzk3ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABILBOpxisfGBj8yEUYb3l9f6u0Hg23vCTnGl1rpGoqZjq/QAm6aaxQkT\nOOX+Cb44timWYDDqCZq35RlOFlpKDs+jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPBpbpPU\n2AQ0tylFGSA1lI/ReEKYMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDRe9iMMa4h1NbEsBgpxYjQUzY1plHZ/Yk4+zhQ\nwhx3tgIgK8UsG5qorhiZXEJZe72UqhTq/yAxKfICLfeF9D8rhfs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5579", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5579` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAaaFm1S7GbaxK+9vxHwsAiqlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlODg2ZTZiLWMyNjAtNDU2NC04NzIzLWE4NWI1YmQ3Y2I3ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJjMjZiYzctNmM2\nZi00MzMzLThlYzktNTI5NTFhYjYxODA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEen+5pxg90NhTxrrNVAgYG4uCaCdMejhlW8dkXp2xh8ZyYMeggz7ZF/k7KLjd\nhGzH4wZP8JRB3HenQ+vCG6cdGaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMmod0Dyw+bVhyi6SyviKyW2kbF8wHwYDVR0j\nBBgwFoAUf47IxoEvgf4lJrdCIB1wY9x4a2EwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgckMIdSqITlfqs6PzDfGaYgg1QtIN72+GRgwzxUp/s7oCIQCZ2RkVXZIL\nnxhouoA2j3R/OHqXGcDwLMJL+0wZZR0RCg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXM2sNrj+6XFI6SAAHhUVlaDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTg4NmU2Yi1jMjYwLTQ1NjQtODcyMy1hODViNWJkN2NiN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2e6qWdEmhyZTv1Ggy+frmYJzmf0X6Mc/EpfsCttaK8qSO\nrdz56r5wFDGlz8V4IwDsHROFSPFaLnYzTylKHXfho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf47IxoEvgf4lJrdCIB1wY9x4\na2EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJOVo2E6wvzABhrryJUogenGR7EKkIKMqL93azwkBlMTAiA5RAPTYfeX\ns6Qq4eDODaLDH1WzrZ5r/xxv5lHr/KaTvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAcmoME+VOkcVfNIo78sKmziSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJjMjZiYzctNmM2Zi00MzMzLThlYzktNTI5NTFhYjYxODA1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE4ZTk3MjRm\nLTlhZGQtNDUyNi1iY2M0LTJiMjk1NGIzNzg5MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKdFP7kDrO/lEZalqv0FbgodWFZAKEdBFxYofo2zbyQcmGpAfZsw3dA4\nWi6bDqGhiGRWTAPzP0cpZdSxcpL82lOjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDJqHdA8\nsPm1Ycouksr4isltpGxfMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDw1uRg80MTCaVWSAJLMzJeU9iAFJOUH57DLXiH\n34zCqgIgUeNItz9m2S/XLzAGzy4HJ6aBAQ9XNX18ixn7x7sHUxk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5580", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5580` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQ4CCvDqTHC3KiCUwag+ZnBXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MDZmOWIxLTgwNTItNGNiMi05OGQ1LTM0YzI4ZjVjMGM5NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2MxYjVmOWMtYTUw\nMi00YzAzLThlMzMtNzhhNGNkNDZjMDhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUiuEsa9iWKFw8X5REaC8sP98/Oqmz+47DpQcYBvjH2qwzCKr5x533vjCvYts\np3BtUlhYSaaSIv64agPkPq5lS6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGtIyV7uxtr3kWUaV3mnJJFF0LQcwHwYDVR0j\nBBgwFoAUzpNKHl5rAU4zvXUBGz79PcQqiYEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANnY/1VmKD1+xXCgPj/8/UFVw3sseLBNxlnq4D7ydNCMAiAurmvQfZId\nMGamKTf9/JFtxdyKTsXxWL11iE6V24vf7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdZICOe1B0P3hBkT+SR/WKyEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODA2ZjliMS04MDUyLTRjYjItOThkNS0zNGMyOGY1YzBjOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKzN8fOk/+/rBp8IPnMWs/CjvQIVA4sKm8a25fG3obxSlZ\nV+MJVCmob6W1P1WP+VN1Ha2e086HAhI7a9+VkwiXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzpNKHl5rAU4zvXUBGz79PcQq\niYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcLd9DvSQlNaRmHfGSyAp+cJmivMZIHksoy/M5vQ1uVACIGf9kdkh14ab\nITeXoQgchf19xBoZ+GdSZA/vvmNWoqEx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISASja5HwaOEgXCsJPZVJnGRpuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2MxYjVmOWMtYTUwMi00YzAzLThlMzMtNzhhNGNkNDZjMDhmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRmMWIxZDcz\nLTU0ZjctNDBjNi04MTQ5LTQwMzYzZWJmNjBhOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA/4s9KH5us/w8uLjJBYhMpTNTNTMxjg+gKgIaXfobTWEd+lqsPglUDA\naFjm9AaFnk7KeFAFApqXwn93PodyoW2jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBrSMle7\nsba95FlGld5pySRRdC0HMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQC3j/0CNDZn0xAgHZiHJeYQQW6eM/etYXo1A7+A\nQaU83gIgBOtK2paLcBVhb7b/dhK5Gy463DXZgUfA5GsfBY2xKyA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5581", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5581` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAZzZZnrxe7qb9oRvK04fLFuPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhMmY1NDhlLTU2OGEtNDRjNS1iNDRiLWZlYTMzMmJmMjc5MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFjY2VkNzEtNzNl\nNy00M2YxLTkxZDYtZTdhZmJiOGU2ZDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjZcG1iYtx+2077NS+dMY4lyUK1DHKLRrfRTuDNMghUPFtOpq9xB6BWSmXLOJ\nH+lJQE3FXZ3Q3Bek08uycpezhaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnxdZHDlUpxf0cgtxYMuD2+x1STgwHwYDVR0j\nBBgwFoAUVLHulN1BbmVqFEHxn0362gCnoeAwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDu34LU9Q9HMQr7fckDNhfdQFY61WATcFZEiUG6UkE4+gIhAN1asIj4\npk0aatBG4gg3fEZb+5rI/m+5gsWco3aAONhP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdNUfTpnEpRI4qnHVKFPI/OzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTJmNTQ4ZS01NjhhLTQ0YzUtYjQ0Yi1mZWEzMzJiZjI3OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaRHRdFlxST8j6eLAGo7Khq2DIYVuU7MJgFu/w9Jtjz4hV\nN5Wyh+QM76EKPyS8D3tufge0LCnW2DA04QkCIeemo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVLHulN1BbmVqFEHxn0362gCn\noeAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKr5SB758OInZUoRreZdILmF0bbd9DZfmbWrl6F39VWwCIDFeKfz83H9K\n32DbKDl02RUP8OMH7aODpTRa3fojigvR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAbFYZeUzcsddXwc4XfX6Bgt4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFjY2VkNzEtNzNlNy00M2YxLTkxZDYtZTdhZmJiOGU2ZDliMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4NzNjNmI0\nLWYzZjMtNDQ4OS1iZWQ1LTU0Yzk4NGNmZTZlZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJg4Yflg0HWyhpVATBl3gDapKTYFvqvLOer4oFUfKXH1ydutNtmH9T5j\nqUK65MArutCOr75Wruz6BVaLmSJ8rPyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJ8XWRw5\nVKcX9HILcWDLg9vsdUk4MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIG/lVcgCpi03gRfwPxm8Zzj5FKL5qc40SfDddvJv\nZ/uSAiATS5cSKTqG5qZnDmSZMLe3zrbbwNGl6erlfh4dYDCW4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5582", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5582` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAZRsl33FbK86odZp9loPVDAmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNDgxZjA5LWY3NWUtNGYxMS1iYzgwLWE1YzY1ZTdlYTc1NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQzOTY4M2MtODkx\nYi00NzBiLTljYTktODgxZjNjZjI3ZjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWCAYzd6eKF/tlQzvSM6jF7jX5ODzndibA6gYIrE3JYKdSRwWp6847gRzeJkQ\nRKLrFgzlDkGFvMkwK4FHdYguLKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOIPt7+kdLhhhtk6td6ETF/CxDeswHwYDVR0j\nBBgwFoAUhU3oNzJNso2EbLBLVQ8TzNgnGvswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCWydv9EgyAqRcbLntu82SE1kNC5PYBeb7j/nEz\ntjC1rwIhAPUMYLWHH9dJrfVH7krPBlIpAjv0nIqN8XDSQmyqXlI+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAedMsbLIVSifT/SIRruIc+kgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTQ4MWYwOS1mNzVlLTRmMTEtYmM4MC1hNWM2NWU3ZWE3NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQc99DDHHLjgO80XIZKFUCZc7Q6tvKGVQSPPrYNfXDOt222\nk/olvX0nKWWJuspJiWOTMGf9Lpa/e7eTdd4m6i36o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhU3oNzJNso2EbLBLVQ8TzNgn\nGvswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPt8hEo3xxyOIEjJUjov6uFpRRzEapvDI7qNHzlIXsOMAiA5JYeoVPyv\nFyroI0GsGGEBLz4Azd3l6qVfK8Y0j9hSKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAQuU5cHIWBPs8ZDMn0XyIpPwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQzOTY4M2MtODkxYi00NzBiLTljYTktODgxZjNjZjI3ZjA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI1NTRiMmRk\nLTg4MmQtNDJhNy05N2VhLTE3MmEwMWJmZmRkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHxd8qXuUV/9/RKobKCtIw6ADSflEXxN3JBdEuqa/iJ4CeTN9myDKceU\nJP0M35HCUyndurY2SQPaehwlQ8HcmAijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDiD7e/p\nHS4YYbZOrXehExfwsQ3rMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIESEyaeezkKuOvDFnmz9QDwOxP65dcaOgG3CxRQ4\nS8wLAiEA/QpO0/ONrWsntVkc/fIRIisVABlhR2hmaddD/GguibA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5583", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5583` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAVoX/lLiotEtczI8WdKchGMKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlYjc0NGU0LWY0ODctNDQ3Yi1hMzcxLWNlMGU4ZDA4MDMxODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjIxMzJhOGYtMzI4\nMC00MjA2LWIyMGQtMDhmMDcxYjM4ZWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2myWsDCxMGzGWd1vpj5y7W1QAgbkKgFM0D0AFw1LL5TTeAJ7qEc+4TclDDSz\n3oLCv8cuicK0gjHgrNs164Ow0qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBJ2rN4Q99TmFiodW+KCD7HKxajMwHwYDVR0j\nBBgwFoAUT/FPuv6gu2NwULLjWij4zGodgLwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC8GJFMPdO5NQvaMbqCbC1nBT3k3/1I6ARU9Cvk\n56bs/gIhALTWyBWwegCscDB/cOgyLyvFY5KMuKak3sAL44yvqnqU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVCdbPrqaU/eTIWzxd51DT2UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZWI3NDRlNC1mNDg3LTQ0N2ItYTM3MS1jZTBlOGQwODAzMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5hIQok+uIKh0fX1zxeEICV7Gve/b4Qh2DdmKEQ5wykERv\nA1YgbwsZD6Uu5gDzBl3YKGIWCWWRjH+0ad7kL0l8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT/FPuv6gu2NwULLjWij4zGod\ngLwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMCsMScekRS88JF7hs+r79IAUsAKfsWGwuYZz9oaLYowAiAR8YDKPUrv\n5xLI0pO4Fpn8aA09OJYIkUuV07MRV/pPxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAa/wST7NtbJ8zyeO5Y7TnLo6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjIxMzJhOGYtMzI4MC00MjA2LWIyMGQtMDhmMDcxYjM4ZWQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFmMjcxOGNj\nLTNiZjAtNDNmNy1hMTgyLTEwOTI1NDRhYmI1MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA7KKPXNdyI1OpjgCdPdpAe3ELUp87orfbuXf5lriGVor2mAHIjdUjhM\nky2nYd4Q0aGflbStr5xSbmpXqwIFbHajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFASdqzeE\nPfU5hYqHVvigg+xysWozMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCxlMGn5GHWfH1E7K8J2Kp/iUb/kpZrQrP6zMVT\nP4AshgIhAKdo+d7FiDeoJy9p3eWrvFBnwft6T751O9NX5upM0HlW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5584", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5584` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAbkNOVRAqBGhydTI4D2NVfWEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YTU0MmU2LWJjODktNGQ5My04YmQ4LTgyYWRlMmExYWEwMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJhMDcwYTQtZWY1\nZC00NDlhLWEzNjItZTZkY2U1N2M5NDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcI32AgQLKte2l2YDduG8YVa/WuGM3Ii2Bop5CN79k7r4EJScvWZjVCsdg6kQ\nbN6IBern8Rd3hgwhrQ4+ArbUlaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSpffQEgyRajcfJT9LvxC1ddtJ6UwHwYDVR0j\nBBgwFoAUN/a0ZasFEQfaJh8xGU745xfr6nYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIE7KdZ3KHR4rjFyeQZbAsp0E1y/PDBNNl6t3H55BpWe5AiEA\n16KbXfXlKKEiLwC+RXu2DabpnJVsLYNMwsXsi8i5q70=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS+V08uuRSVhGTZKRlKyN6DPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWE1NDJlNi1iYzg5LTRkOTMtOGJkOC04MmFkZTJhMWFhMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkUuo/xZrS+6OD84a+YHTPR87PfJudHe8QlbG9qzQbaAZB\nCu5flUykbcUsc4bB6Fms23EMCC2AYgn3TB0Cqr9Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN/a0ZasFEQfaJh8xGU745xfr\n6nYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIAu7aBkyuL8q9lImhzwqmEm8ILiEVuQzbnIaxknTpsdAiEApY2ZeVNq\nCgK50K60GKs4Oktlw3wW32eSCRzhpEgrTGw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAUic+S8wE6GJ3v5RckPZBmvWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJhMDcwYTQtZWY1ZC00NDlhLWEzNjItZTZkY2U1N2M5NDU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZjNzk1MjM2\nLWExNDUtNDAxYi1iYWFkLTdmOWZjZjhhMDdmZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMqKLcrjmIuKyuh5d+hbPA9wvr5JjnzrYJrrGQsrsfpkOTD874zZqk3S\n2rJo448b3whdRdlk+kfYSSCAzMlxhSSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEqX30BI\nMkWo3HyU/S78QtXXbSelMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDNNy3OKSLVHmzT8uKcREqgB+Sa0CL7roVh5ce4\nKse0yQIhALM5HGlFppFcE7RJENM17N3c65du1YQx6vpAg/oBHNKH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5585", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5585` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAfnhbrhKI+U0x/ZoaDXDE1aLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMGZmMzA4LTRjMTMtNDA1My1hOWE2LTllYjhkZmVmOTRkMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGZmMTljMTAtNGI3\nNi00OTAyLThlNzAtOTNhNDJjNTgzMmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO/sUIwMjwRn7OYv5fWzAbW0SUtLj5+CNe9T7+lIbDH4fsjH7x81JAtif/1Ws\nScAfI1bIf7Sv9bSN9hXtOrRFC6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzh4lUp9mzUe/drNp2V1q24Q6lG8wHwYDVR0j\nBBgwFoAUyY5Pd4RYC3kn7QXdcETF8iE0Uq0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIFd9o1RWaQDJGIhShIoeu1pdMUmXC1Xk\nXR/Ex5DjzLr+AiAtNxlI5HzPQfrZoZDdLaNHzYu1xduJnGyp7BP6PV6ZlA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ/WYi6GlErINUdN1w0bUYqmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzBmZjMwOC00YzEzLTQwNTMtYTlhNi05ZWI4ZGZlZjk0ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKbTs+eNo78YZbhJfT4/JC2oBwSXBfFpglttKmKpjaMxSk\nekWqC5J8zbmrNc9WAmQTYJHrwpOw1J1okkw6u++qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyY5Pd4RYC3kn7QXdcETF8iE0\nUq0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANhKphV9iAZrIL35zIuFO43pqi462RbK4CwwoHYSe/iRAiEAqleVdl7T\nZc9VZwSniLetKBTVYSEA0WPPg8YnDDJ3YZ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAac9AloSWWQDIN0vMIpq6fW+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGZmMTljMTAtNGI3Ni00OTAyLThlNzAtOTNhNDJjNTgzMmExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU5YzNhYjM2\nLTcwZGUtNDQ1NS04N2Q4LTZiNmNmZjgyZmEwNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNCcGav67YK2H5cMCHWg25khF37Ri02X+jppe91cGiTtSsgQuP62aqIP\nJ9TIXgVp4bg5MdJ83AHk7r7BDJ/rpfSjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM4eJVKf\nZs1Hv3azadldatuEOpRvMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIQDgryi73TnPTJQ/xLjivH4iYHDz6fRysV+uG4Oe\ntHomBgIgaEYHQiMLBnAn6x/guMaXPTrnouXPYuUHn2Y97uFlPD0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5586", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5586` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAb7HrsAVdMAJU4uuypAFDvH6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmMjk3ZjZlLTFiMGYtNGM0Yi05MGQ4LWI5YWZhZmEwMTVkZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQyNjUxNzItZTVm\nMS00OTRmLWFkMGMtNDg4MzczNjhiNDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzvCsMYfmCjYI8saImsA5daDPji9w04ucgre00nTQDanucs8Rl+50vFGyVNjg\nbetcio9DRtupSTQjoAUYplpF26OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiK9+0gs+R1SoSPvKk+1xrJZ6WBYwHwYDVR0j\nBBgwFoAU/I+Wfx36SmYywzPfPta+AHJOpw4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIH+MrLjpk2M7rMJD1fAJVXgJRvvTWNt3\nt9cRTGw/8BenAiB5vfsg5tplQ/LBdC8oqMYZv6nMh++obDC1eaTnua0GzA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR7OgX1rzROF4mVnmHo8gwxBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjI5N2Y2ZS0xYjBmLTRjNGItOTBkOC1iOWFmYWZhMDE1ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9zVG8KACi66QvQz7J0GQLSCJsPILJLy4nnaHGz2emClGL\n5qdB/7UbDHt0mpqDnBBeDojDC0A343Up3u+Hlq+8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/I+Wfx36SmYywzPfPta+AHJO\npw4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPe2Vg2XPUhh7WYyqGkDYub6tSyNVNfpteAbrJT0B8OxAiAj+NQKcLFj\nd0mxNLrhcMF0cgFKZoSdJ65pjzC7HmK9OA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAXIoq+pS7wgzcs7AKWlkV+YtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQyNjUxNzItZTVmMS00OTRmLWFkMGMtNDg4MzczNjhiNDlkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMwNjBkMGMz\nLTYyOGQtNDExYi1hMWI0LWE5YTFkMzljNDEwZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBnyMfFNKTmFu5o6Z2h8wQyesIqFtDB1OqX611rcjbzZCEMQ0EY8vpMU\nPRg0U8W1FLyYl3x0UU7xzFBM3fPq9vWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIivftIL\nPkdUqEj7ypPtcayWelgWMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIBfVusygdPgkzl+TCUB97mQ5C/9ks818ipjBfYRE\n5g5tAiEAgbHZ7X6YrF+jnZtHFi3BDyosQpDEoHA9XVhehl9Qt5c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5587", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5587` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVN2ElnikIvJ+7lq+lfuKiYZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNDA4NmE0LTc3MTUtNDI4My1iOTZiLTNjZGMyNDViYzg2ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTExYzQ0MDMtNzg1\nYy00MjdhLThmYjUtNGU3MzE1OGE1ZWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0s7lfePPsEvgRko6JlW+aUjShelP/lUY/apJZocV88lyOxJW+Ck7J4NnnJWX\noYjI8P5QwCMBO42sSkOB4NQDraOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZRbCoXVSFtEElVjbZbOq5Umk/eUwHwYDVR0j\nBBgwFoAUghAN/ZH8jJ+PwXLT4u1XkkX2jMYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHTUy1L9A3A7\nVCwhkKX+7XEbit5CdoouyOryn1kVlcFQAiEAm/i/h1eztJiN5QhYR1g8bl7aaZu4\nU8yFhV8dyT9XOoo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVntF28T4CmCu21ehAkqmLjwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzQwODZhNC03NzE1LTQyODMtYjk2Yi0zY2RjMjQ1YmM4NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1JESWncccFIeA4296FGNYbhu/edjSPyslFbKhXEK9QyoV\nZaAyypLNgh7Z+11z83iziswXe7UoeLZu3Xg9Buheo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUghAN/ZH8jJ+PwXLT4u1XkkX2\njMYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKSsa5SDmZhaxwN21Rn/3Tj2smv744lMLDLzn6/FPQiwCIH0tGjMQs5QC\nMncrjuBSyjjtsj+rbJVXMLYvN7anrXMq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAT60gO+J1yTlWK1vet8D5LO0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTExYzQ0MDMtNzg1Yy00MjdhLThmYjUtNGU3MzE1OGE1ZWVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRhNzU0ODhh\nLTJjOGUtNDM4Yi04OGNjLTg3NGMyYTUwYWY3NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ9ve+xdzETZMvFwATluT9s+Mo4622AixR4ubnUhLPTKp9HIEl7EOKes\n7c0QHeNJmdtwT+xxG0mAk2DSgOdShhWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGUWwqF1\nUhbRBJVY22WzquVJpP3lMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIGdj6YAm7x6/3HCosPqBFXzKD8F83VKw0+dgafNe\nNwXaAiBkGaUQwXyrgBFE5WpzDGFjkdOnCtDJgO8gf05kLR31Dw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5588", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5588` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZJNTlAu4Knxb0jnKze7aOe6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0YjA3NDA0LWZjZjAtNDc4NS1iM2ZmLWNkNjMxZTgwZmY2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg0MDc0NzctYjdi\nNS00YTc1LWJkN2YtNmZlOWRhM2RkZWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENfONd6NVhmRxiD/9Tf7IjgYnjbJefwXVBKY8EXPeBj4gJxBCZZrNXuZe+aSt\nxHR23/mtrIBBwJ5mmq0hOQA/sqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR3ddlh3AMr+kzspyxUGkpazhKRAwHwYDVR0j\nBBgwFoAUvV5531Msi5mK9LBbUph/3f8wHZwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgWenYNqQ3ubUK739BvXeRe32jT/Z0LCpSuVxP2PekIoICIQDHTaoq0afQ\nnquM9x/zYQzrc4buLhbufGmppYG6nQIhLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAekhpobicnoa+VNP7+jjUEQSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGIwNzQwNC1mY2YwLTQ3ODUtYjNmZi1jZDYzMWU4MGZmNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2fWhsKCvh8UF7EDRNoi7SIH/7IRW53siQ4PGBk/wl8NK1\nqf4v9qrhdd9h/RJFqLLfsYcoIJvYOd33WkXyU2SQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvV5531Msi5mK9LBbUph/3f8w\nHZwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMy+mmOgyWB8g6N20kAF1wNIVkEtNiZztG0Ref/Br/qmAiEAscuvWslf\nrd6RjvbvncCOD68jyYTQUXgsFBSDt629/bQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISAbENdDH9smOHkkH3aw8JSu2aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg0MDc0NzctYjdiNS00YTc1LWJkN2YtNmZlOWRhM2RkZWIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA0MWNjNDgw\nLWY5NDQtNGNiZS1iMzg4LTAxN2YzYzMwMjY5YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNcTYOHS4Tmm+G8PlcOgKLFrnFpqEsXRmvbNGH+275mAsc/1egYjU2+v\ngx7v0R87yfDATxhYq4eJuDkUv5k9CQWjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEd3XZYd\nwDK/pM7KcsVBpKWs4SkQMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIEy7Zlkszwvc11WMSBgagbU7nuRjE6931wawDTvA\nwz6FAiB3HEa95ttcz4/iuBzQTrYPaR42Mp80WwlthDmaCDacHg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5589", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5589` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAZGC5ykOcKJ7gD3iGYEAN4IhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0NzEyODhhLWEwZTgtNGUxZS1iYjRjLTZlOTAxYWU2OWQ2NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U5MjViM2YtNDUy\nMi00YWJkLTgxZGEtMzVmZWNjOGJmZTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnPaiWkmomUGnuIto/i5Hht4CgJbxczwaioVjmYxX2ZP2GCcom6G1LEXpdMLy\nw8RosTMdOj3th9UO6HeaYi9EEaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKAd1bc/3Tt58jpWEWThjEw5UtbgwHwYDVR0j\nBBgwFoAUgUNX8WefFhpWNIYaeU8XmDUNme0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAOso++jqkCcGB+zEta3TRQG+y0SiUTRjOjIbmKyGgCSFAiEA2gyduKS3\nsu4jw9NcUo19RFGLd43HWs7Cjz+iLjykuwA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ/vf88Ecwqt7eb++t2+dKSXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDcxMjg4YS1hMGU4LTRlMWUtYmI0Yy02ZTkwMWFlNjlkNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9+Up9rzmqKD9c0FPLzOojFsMZw5DNfnzKez3ply4SlhE3\nlRNIbgPBAaPEb4JJjnJ9CxyK/kyURZo4CSIVqaYjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgUNX8WefFhpWNIYaeU8XmDUN\nme0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKU4hRlSEV44j0chN+dVIOnMm2WkhcBlnXg8ZjCE3XwnAiEAnfC/mO1E\niGC4v07nVOJ4dloJSp4eeuYW5tz60DWItmo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAbA+sAW9ZhqBPRbmTiEDPg6NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U5MjViM2YtNDUyMi00YWJkLTgxZGEtMzVmZWNjOGJmZTY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQxNmEwMmIw\nLTQ2YzEtNDJhMi04NGQyLWFiMjlkNTRjMmYyMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBxLlGy9T9mZFggrakmzo87jfRWXin0tl0N4r4iVT/eOThzr7eaiMDlr\nKGzaAKU1j5AQ+orvlBnupurkTg04JoCjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCgHdW3P\n907efI6VhFk4YxMOVLW4MB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCB7AUVPxwI5WpBGIoj1U9NMmT54kuCDCCgRok6\nCiyM9wIhAL4J44GtHsdj1UtgQhkhcdOC6AapBCy4ZwHeC2rWcib9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5590", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5590` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAX066Ttc0qZNu835jdZgE5vIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZDA2MDY4LTM5ZmEtNDkxZC1hM2U5LWJmZTk4Mjc1NDMwOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzYxYTU4YjctZTc0\nNi00YzE1LWE1YTItZWU0YTA0MzJhOTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcvg3xjJn+QaFxhruoAJWVfpuvcNw2kDmVfiBq21iJac5CRN01pwqtJ305zQd\nDUCbvYfoOKpFceMRkEqEUNzggqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0XyuNWXE4bpvec3tQR0DwqRQD5AwHwYDVR0j\nBBgwFoAUm/NLK+yHgz3tHuP8xzy51l2+yO8wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIE1mNeCCvC5Sl8Ednrk8ywGwOUDaJqAX+6AlDLHKy+B1AiEA8hNtUjqE\ncnaV4rWqEJnX9LcRw71iFAf56mEjqwibjUU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9nMDHkOhQ8Wki2+TcWh/lRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWQwNjA2OC0zOWZhLTQ5MWQtYTNlOS1iZmU5ODI3NTQzMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBDe1b8Kug6fMh4eg72Vix3hjyFQ+J5Stcyfn9l5aMxeIS\nu1kUrNWqmRmZ6lTQd3EHmzxNblk8hV4xAQNMeAmQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm/NLK+yHgz3tHuP8xzy51l2+\nyO8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVFnHuLmZpLxWZgufF95a4PbeyvEoknq6RTW3GfdEfhUCIQDLPkAxsHYn\nH530biw/+vMy0yW+AfeWqv4Ho+Mw0DjGBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAd1jEV590wZbU04kcvl8YxBMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzYxYTU4YjctZTc0Ni00YzE1LWE1YTItZWU0YTA0MzJhOTBmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3YzRlMGI2\nLWQzYTYtNDZiNi1hZWZiLTVkNmZlOGI1NWUwOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOCBl+ES9CW6pxUZVWxHA6CbWZXFaBz+AqaMoX50yVUwtUJNHaQSwwJe\ni0c6EhRNQIMF1W41vcGn2eXEJfZwP4ijdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNF8rjVl\nxOG6b3nN7UEdA8KkUA+QMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQCHI8bMNmVXGwe4XUO7zPwmZ9BXisDYlLfGH13q\nLfDDEgIhAKLt9UFKqVElzOeR6IS09KF2On2yHWElgoMhdbnbBhfA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5591", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5591` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAQR3UjvOkM5Xflig4YKhb5ghMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4OTg5YjZmLWFkYmYtNDM1Mi04NDZiLWMyMDIxNWY3Mjk5MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg0MDA2NGEtOTdl\nOS00OGZkLWJhYjMtZDIzOWE5Y2IzOGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0QPCQxpbhLgyMVOA8Xtt0Dk2sepyPpLjD6iNpYNS61wHckvAChlUIR1lnqNg\nyJs3d2ezt9k34XxddyO8ZUiRWKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVVTmnkWA2OMYxeRzQ/TK8bSUoAkwHwYDVR0j\nBBgwFoAUCkuEh6J6R4nDqtMY7F4m9rQ3E0QwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICS6QOriJFqUMfMfNqeFdiP5nvDw+T/AOE7f7iLv\nSItGAiAZKYhjzsIikQabV97vlQHWhMDlZswEtAqggHKxmjFwrQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASgKUrEZrMIf32z5Q/o5n6//MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODk4OWI2Zi1hZGJmLTQzNTItODQ2Yi1jMjAyMTVmNzI5OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+VE1+N/PIJKDcsNaa6GimTnALyvOHc6azToF1M9BcoiFo\nIbvdB7SzpB8SoMLj2d8QHN1gtI93Ij9XYAWZc5KSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCkuEh6J6R4nDqtMY7F4m9rQ3\nE0QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANl6bN+LOofgt/rWAbIzEuW+wWqiH4W49sKZfg5aBLBwAiEA17UYxQr7\n5HJirSy4UNGalUc3+zYV2v7/jHZKhH0s2M4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdigAwIBAgISAUpxtv+XJlxYc1ggU7W6hWytMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg0MDA2NGEtOTdlOS00OGZkLWJhYjMtZDIzOWE5Y2IzOGE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5MDlkYjZm\nLTAxYTQtNDYzMy04MzY5LTgyOTcyODYwMzQzYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEHANq7y0e6tUyQ1iGMLs0SzHlp2Yx0OLkWbBrezYt0/1Vh655dvTMA+\n0IxvOiXnlvDmiMeszNZRU4FDVooBDeajdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFVU5p5F\ngNjjGMXkc0P0yvG0lKAJMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0gAMEUCIBe5suu3u2Q03KbWfhj+Snfjcg09KuaPNGaH0BAh\n+1GeAiEAkUTD4cZx42UTd6ou+V97b1Kigen8Y2/uNvX1mrulqTo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5592", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5592` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAWv/hoNqQOVmkKveUDoKqGjnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZWExZjQ3LTVjYTMtNGRjZi1iZjUyLTdjZDBmMmNkZjI5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNjMjg1ZGItNzY2\nNy00MGE0LWI1ZGMtODY0MmY4YmQ3MDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt/dHhRXseYziC3WStA8OXXRwrH26cDylBQIp7SDxfFb60q6Muy1hhkI5Hwbe\nCs0LG2nInq7k3QYMIEe48mOYZKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8SOi0zSgDX1TSkPzr/Mpgw2fM+UwHwYDVR0j\nBBgwFoAUlx2I0jfbW0FPiPKHqEa9mHJVNdYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCrM/glEN2QV8GAw2x1LIFlouVptHo7dZtw/Fsn\n1I+VxgIhALvrxxRW9XsdpEkYKS17L66qgZG/hinhXaobhRM0KrE1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb5Xs8GaJSoj8JpbDsXGnTTLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmVhMWY0Ny01Y2EzLTRkY2YtYmY1Mi03Y2QwZjJjZGYyOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnas8J7nPiVcEY+qpURKgD6ypq2XQBJBst4Uj6SO/PZz1i\nbbb/h48CbI1bqjGpAjQaso79eNbPWoijYm3RDr2po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlx2I0jfbW0FPiPKHqEa9mHJV\nNdYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK1FBNvXV3CMAp7BT7bL1MCouFYmDbkFFW1PlTsn0bqeAiBwUMJVP6YY\nd7E2zzPnMo4HDJ+ywqV/dn5IkyD8qIkvrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAadeJi6VjP48J3A4mISfzz3TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNjMjg1ZGItNzY2Ny00MGE0LWI1ZGMtODY0MmY4YmQ3MDRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRkMmRlOGVh\nLWQ2OWMtNDNiYi1hYmRmLTI0YTEwOGIyMWNjZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOeUTIDr6Ube8qcm0k68VbPIAzJuCjlKlJX6e0FTB2ImiEsoz7AToBUP\nYEPi5Bo25yq6bdaAOl7AbmnznirmO36jdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPEjotM0\noA19U0pD86/zKYMNnzPlMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQC4LGYEV32u/86YhieII1Dbc7ep5OdASVZvO1sx\nwhTufAIhAKKP3qXsT1JZUqaHKQuhcMEncQioLC/dYmSrkhGBjD/L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5593", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5593` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISATLM/J/eMCtcJwpXbiV8VZzqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMTBlODEzLTM5ZTYtNDhkZi1iNmI1LWQ5MmJjZGFjZjcyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA5YWEzZGQtZjhj\nMC00Yzc2LWFlZTUtMzE3ZGM3MjhhMGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwMz6cvls38evYP9bslkQnRp/tJdwBrG9Gb5jHYp583s96ZuUDm0F1LmjVqkF\n8+6Mm8cNNQjGXZwZfAd0ujpDPKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrDJlqCMY5SRv3kIqxgs5cKeA47AwHwYDVR0j\nBBgwFoAU764limiGRKnHGZHTeAUNQoEe44wwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQClzdVf8EYBEcVckdkxd5drzVa7+vTQYnyhGyhr5HcHmAIg\nD4sxJSTgjafbcdnxLfySlbaC9BPlXQIaeFi4z+k7ayg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfkygpxoq5sAxYFedAPz2wuoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDEwZTgxMy0zOWU2LTQ4ZGYtYjZiNS1kOTJiY2RhY2Y3MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPYNspWB8Rmmn9AzUFWJhxBsSsf8Q5twqIK33k9+9YhJJD\n9yBihK9IE5uI5R/IBcvrNPlsfF1YcBtC9pzUmrb+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU764limiGRKnHGZHTeAUNQoEe\n44wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN9XEZAhaQNSKeVLqQv08gVeIK7uSPo2bYneqTPWjaPnAiEA3REBL1ZS\n11vspXq287k6Vx9qNX/Qw3qVHqHXKDcDa18=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAd8bXd87KpjAbNnT53sKIw4jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA5YWEzZGQtZjhjMC00Yzc2LWFlZTUtMzE3ZGM3MjhhMGZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDViMTcyZmJk\nLWFhZDYtNGUwYi1iOWY1LTIwODdjNTRmZjgxNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCQRnnUy+zyWL64pNgkwZ7DCzAt1eKBIWsEkHJ5zG/82GlejN/qeinQb\n14m1PKmzPqpv+KQgxmyqImTou2vuDuGjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKwyZagj\nGOUkb95CKsYLOXCngOOwMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDMnJNsKILBpuJOpL3zbO1wiJQCgFkdwJ1G9cVt\nM2uXbwIhAIMc1Iu0aGYIO5HJ4TakFE2iOpJW05tYrwtR9qwV0Cxt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5594", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5594` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAWYKsUUwSMXMkE+GmtxfhHHVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1MjI4NTMyLTBlZWQtNGMxYS1hZDlkLTc1NTE4NTUzOGRlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRmMTg0ZmQtMWM2\nNi00ZDUyLTg5M2QtYThlYzJjOTYzMzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEizf1p/ZgBrC5Da48CKxcloc1FMfp0pX5CXgg2yb5EcGgh3ZrIWxBEMsShRCR\nE+b4V2WG+NUbw9sjeR+Dzanb1KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUudhhdUNwOAXv0uTf7hT2WtbwtpswHwYDVR0j\nBBgwFoAUX3EnXzaBgciyfKC38OvhzKdipB4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIC4fm81ctsKsl9D7kkcf3SRNHjyZN9WD\nVVQr3CJphHwpAiEA6m3BngiAzk8iTtDoBUHCQoUxAHEUFCYbw5HG+BH0M3s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeMvYESyUrZOgYvwQw68OZOxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTIyODUzMi0wZWVkLTRjMWEtYWQ5ZC03NTUxODU1MzhkZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASx763Io/Avqq05PMVmyuj2QIcoUzqYPGZx0KX2xcXWkBX8\nBzOaNFlBoTlAY27CqqeDPlgKGwrs9sX4O8IyZv0ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX3EnXzaBgciyfKC38OvhzKdi\npB4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWVP62XwFRPMqhgY00zl807lO7XaeXdRny/3/xZsfWk8CIQDdk4PXWlAD\nF0+Yb2oky8wBTjW2wFG6UvFvZiHpLQoMAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMTCCAdigAwIBAgISATiGsc1GNZhd88IyzAC4JffjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRmMTg0ZmQtMWM2Ni00ZDUyLTg5M2QtYThlYzJjOTYzMzBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc1MmEzZTIw\nLTdhMzItNDNlMS05MTRiLWU5NzA5ZmFkNjhlMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHR6WZa4TpnfOWk/QVW99rPaaSSO39eUA29GpYVyjVBKILkTbYATV0mU\nVQQ7tGmQe4ljGKW42GJFp37qRSm3jcKjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLnYYXVD\ncDgF79Lk3+4U9lrW8LabMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0cAMEQCIGVnlT5JQ9sChBAJv0GXhcqs27e50wLOiJcml9dC\nVvBEAiAXjx3F3sOWABzerQ2+bdpuNzqDv0hHTr9SlAW+j78Vvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5595", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5595` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAW7n5/IfLpPtGz4wcWevUbocMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3YTFkYzZkLTllNDItNDgxZS05OTcyLTA1NjU2MTlhMGIwYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNkNThiNzYtYTYz\nMy00YzQzLWFjMTYtODVmN2I0YzBmZjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeKI3MD/t/KS9ALvju2s7PKckl3JbmwTiRzaj+CVy242DQEephS0nZInS/DZa\nMmIfzw3Qv+KDbfvNQ3n29ma+daOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfBkdVMsVMc+EaOAdNtIBKgm9Hg4wHwYDVR0j\nBBgwFoAUIoQ1i1A83/k2WNA5cIgszxhfUjEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIG3WKERHk7Ndp7UPQR0WYpvew0iTx6K5\ne3Pe5iprpBIXAiAagmlH5cvgqJcVFqin0N7zaLSc3fhzcKnhf7BfM++Ruw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaW+1IeBt8a+zLdEyRMlELEkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2ExZGM2ZC05ZTQyLTQ4MWUtOTk3Mi0wNTY1NjE5YTBiMGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdoww+eNUkp4ukiph2yMj4s0G/KJ3QpWh2YG5IUVPazBj+\nD24J1l61CHxZVbfR9ue9A3zUHouS/Sel0Q2KHYiMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIoQ1i1A83/k2WNA5cIgszxhf\nUjEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKjYFZ4SakjsxxEilFriBjF+JAqy0rI2RANKrsdZrT+KAiBCotlSuPdC\nd3j1lMeuchdu4DwC1F0fUqNWjDvTkzdS+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdigAwIBAgISAT2gTBHiIe2N46qrJa2q44aKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNkNThiNzYtYTYzMy00YzQzLWFjMTYtODVmN2I0YzBmZjQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJkZjZmODc4\nLTIzY2ItNDY3Mi04ODAzLTRmYTg4MzM1NTk5OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNMF1UbHzGklVefysDoPjepuaPfBJROo61t/bFELueMfNv0B06UOVgFf\npuNE9W59lTuga6f5uTNZg3OmDUt6dZyjdzB1MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHwZHVTL\nFTHPhGjgHTbSASoJvR4OMB8GA1UdEQQYMBaCDnRlc3QubG9jYWxob3N0hwQBAQEB\nMAoGCCqGSM49BAMCA0kAMEYCIQDAJrfBMPUS9zWGTxEElX2vqJaZhBQKoyAvD/tg\nTly7+QIhAJty3FhfvqMlLnaR+i93UsqUtwySzh/raYSuw05ipGOr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5596", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5596` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAS1rQ/T7UxEZQgpB6/KDh0iMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MTU5N2Y0LWNkMzUtNDQ1Mi04NWE1LWQ1YmE1MWQwOTMyMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE2ZDkyNjEtOGVh\nYy00NDVhLTllY2QtNjQ5ZDFiYjYwOGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZgQAhK80RW/b43Wqr/p35LYzfpVbwZf6tvq3ofGTD2x9UfwM+Y3E0KSAz5NN\nl/N5RhjHEa9BkLNMzMWlQ3+Y3qNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDWmPAcjTf2fbeI4k+C44awWCgLzMB8GA1UdIwQY\nMBaAFIBfd3ZWgUdEB4/GHeG5mtajPv3gMAoGCCqGSM49BAMCA0gAMEUCIQC85mO3\nMi1a/g4K3Kl3vqu9G0Aj67zhetEwAunmX94skQIgbl7+ZIdjPyQ55DFWg/gXLqnK\n5whL9xhCHz8Hii4xP5g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX3fGJy3JL5aSBq7HMcnaFRvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODE1OTdmNC1jZDM1LTQ0NTItODVhNS1kNWJhNTFkMDkzMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASa8LZ1n8qzdR2ZZgrPxplBLDU7Y1PGryxo0tdLrdkcUAuT\nFr4gZvYa8+EUtYAHjJa4MHbCGtBdzlGsdiL7c3Bwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgF93dlaBR0QHj8Yd4bma1qM+\n/eAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWFzRuUlw177dbTMJ3kmehVf60z705sdK2Ca5lAzMUz0CIQCnaG3VSrlu\nHARWqrodDBaGc8HIim8ztnAlKpkxQn4lGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdqVu20TtS6Xe732J+CryWj5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE2ZDkyNjEtOGVhYy00NDVhLTllY2QtNjQ5ZDFiYjYwOGZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE5ZWZjZDg3\nLTQ2ZDUtNDlkOS1iZTlhLWU3ODA4YTI1ZTlhNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHWP2VqJ58cpjmGB3aZ8j4bKrO2jv2lRyeLhKGD8zmIBrzdzsB9gGHnp\nl4g1gWJiv+grS+hJois1/Q1lTLaUElijcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDWmPAcj\nTf2fbeI4k+C44awWCgLzMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEA1tlrs6d7Des8cxC9jbgs42swSJFl7cO4wZ6eZdNAYCUC\nIAT2ba18QvNnThw1YLBdRMQJhNieCpwBk8zl+UzcVWPl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5597", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5597` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQrNJNbQYFU65vHGy4zdCIAoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhODNjMjBhLTM4OGEtNDBiNy04ZjJjLWI2ZDkyODRjMmY3ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRiZjBiYTYtMDVm\nNi00N2IwLTliNmYtYTBkYjMwNTRkZTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqPMGeUa9zVayFym/MnZ3dnPx5c03eaEw+nUIpeC7vV7EQyrUEP5hqMdcJwks\nnw/YaS4a5ZX1I3d0yKkWVRBPN6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEJQXbF0d5zrosek6IN0ywibGfFsMB8GA1UdIwQY\nMBaAFIIAnWKU1tLM4V1GJ1U8JBJY6AaLMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAyzGg8Xl+nX4UamqRd1RdhHpiGD2sgO7R\nRIf2PYb+KD4CIH2q/gxchlZa75WJBi0IOLyw38I74Sa1G+QpVH9ciROV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATWoylzGObIOen9KI85+jHTfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTgzYzIwYS0zODhhLTQwYjctOGYyYy1iNmQ5Mjg0YzJmNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2fYIyaoChj5PQ43frqVbQ4sj9bD0PLOYzE5s1+t8zXCt4\nZzV5AuefoFF3+1zLDVVvU5c0EvlGKZYhn2N9mr/lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUggCdYpTW0szhXUYnVTwkEljo\nBoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKZZT8OjuH62d1MDkWNvXSK3lfQRW1xVhnaum8TTCAgnAiA5tqzW4N0k\nkaDUBT+tKWGTb1sRtjh+PllBQsgo9/iQHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAcFWzDcR0f/FtQpPzicVR8dmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRiZjBiYTYtMDVmNi00N2IwLTliNmYtYTBkYjMwNTRkZTY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk0NjcxMGU2\nLWM4ODQtNDg3Ny1hZWQ0LTVjNzUwNmU4NTU2NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC4xuf/+9VTg+0/kMbqlru8ZHRJCECMotKU39B8s/ZiY2hfCDRcQzqwx\n8MIlH4F0Fdl/zzp4mpgkxWK6Z+RJT0GjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEJQXbF0\nd5zrosek6IN0ywibGfFsMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA2yGOymoyJ8i2o+umJVbotIQ4T155HCuNpcrmI0Rs5RMC\nIQDvwgQJiOTfiYgmkYyyNIWzA2qc21TrWAb3bQ+G3I4zGw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5598", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5598` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAcXsv3snqtCZSCx0wktDecuRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3MjI4MTNjLWMyMGItNDA5OC1hNWM5LTY4MjkzNjQ5NWRmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI5MTNhZGMtOGJi\nNS00YTI0LTliOTYtNjJlMDdmMjc1YzU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ8yIb8PRpWXgxWWoD+xMFYNH7xMWZu+da/YL5eVgYis8LTfdt2QB/Y5zvUU2\nb6KUPoA1TsPrCx7dWcHBDD/c86N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOSxaMTJVJqHiLnvk3nIDRSShWMjMB8GA1UdIwQY\nMBaAFCetnCo+/Zs5Pd3fx0e5rzwqD+trMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAjoyxi2mepwQ6IA3GhgHrI5kjSqWGG2h+\nEoaLjKPudrkCIQDby4OLnC725y7p6IyjZFTDIHmcCMoeFwwwu/3M8uHBLg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe/TpiphTiJPW4KDAmzRd79AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzIyODEzYy1jMjBiLTQwOTgtYTVjOS02ODI5MzY0OTVkZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVneX1Vktn4+4EPMhPoeftGYQpFWQ6x1/fzZ+ewUgWlOIG\npqAPps95xB1W8QgGdvEedo1rrGa0ji+KUwh4N4vWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ62cKj79mzk93d/HR7mvPCoP\n62swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOR9R0yzXowxnADLEYWqfOnkoodCtyK6U4gd86KA5A3oAiB7Lc0DMiOi\npcmRq3EcNwgN8tTp2u490O74lyAmuw07lw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAcyZ6yyaxqeXmIZblpyU19TXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI5MTNhZGMtOGJiNS00YTI0LTliOTYtNjJlMDdmMjc1YzU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI3YWJjMmM4\nLWVkYmMtNDViOC05OTg4LTljYTBkZWVlMTU1NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC3fOnnb/mABox78y1ZUE3TyDZ3eTAbTOQgjv19IcbApUCo3RQeD8nee\nPmQ880v2BMWhC9MnQfrDNCQosr/fbuOjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOSxaMTJ\nVJqHiLnvk3nIDRSShWMjMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAJ0AQg7DWKnmTU/QpOTz1TfqxL36gHw5eBaPP3gW9uNgIg\nXQj1oGiyjiTvWKCHBkTYwABstZ2fc8cUix2WjDE8E2s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5599", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5599` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAQ8+9mImCynZ9Y1IY02t5Sz0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmNTZhZDdhLTk1NzUtNDc0NC05YjNkLTY4OGFmZDg1Y2JiOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFiZDE5YWUtYmIz\nZS00MjVmLWFkODMtYWI5MjlhOTRjNGU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9yztSfHq68Ryz+HIlDitL2vthID71Lbpvgpb0bIPWp0xRnlCtqKgyxCTcmi1\nLJvbZDDQS5HelvgDvpjujYADxKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTCsmUOQnMCb84Xf+CJ8o2bwCjqlDAfBgNVHSME\nGDAWgBQynu4x1TCQg4ajGXcj91WKbogMbjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCfN2XVnOHCag4Tjp6Pgy6DVvvSuEqu\nBPXNTSjRyjvJZwIhAPA8Hu//F1I37slTPsJkQTzyoIBmR+k5vt+H5ruhdFio\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVdwAznmbPWaJpbVGYrfK2cQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjU2YWQ3YS05NTc1LTQ3NDQtOWIzZC02ODhhZmQ4NWNiYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoS8MsXOXD+2NEl+O8acucJer5VQiQUlR74OM0aJZpLiHV\neuqfvC55oj2Wp+KBOt7yW+htlbAdcICZShLc0foWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMp7uMdUwkIOGoxl3I/dVim6I\nDG4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXs+PpshYqQyan3u7pP6YKhgr45/2d1BjDSdraJDmBR8CIFp7KfrsRa+Z\nyYAyLxDqDpcNePNScVZku3aDP00jHaib\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUoSbJSj/BidC5jThYvCKz5uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFiZDE5YWUtYmIzZS00MjVmLWFkODMtYWI5MjlhOTRjNGU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU2ZGMyYmYx\nLWM2NzctNGFlOC05NTY2LTdkYzg4OGIwYzcyODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIzXWg1hui1EN2iUbSFyfMAThPM2awRk2+3YTKrqouxMdjOHVzFT9qz+\nWCEfGhJvpqBRdnnqoP46wgxNAgjYbOOjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMKyZQ5C\ncwJvzhd/4InyjZvAKOqUMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBEvwpr5VLK2JOuNjE68j/e46+42JLCFDxQbmQs2PvuQgIh\nALZ7vYwIFndwiatpfw8vufH1R30IgHpqsK/ANq9bjpD1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5600", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5600` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAR7K8Du/SAY8iR0S9AGZoJTcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMmM0MjU0LTY4ZmUtNGU5OS1iOWY4LTczNjFhNDM4ZTYwYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NiNjAzNTctMTgz\nOS00YWUyLThkZjYtNzcyNzM0ZjAyMDJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4jku94r4HaunwuMcB5bPbHF1NYbo6S4Qa4ra0X0ZWkFhU2W/Z9ITIC2Hn8qW\nUzXTnnYfrLPbpBMvOYkhRZ+/1KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU89kdn90kmG6uB7SjylhU5OlVvcQwHwYDVR0j\nBBgwFoAUGhzwwTFGHEUK4Jf21p5ICOPVrnQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA45IOXEcsJeuC\nBAfqF5EBqahf417f3RuppGYpzfped9ACIQC6V0SXmRC8tqm6qHS6PzZ6pKPyNdbR\nKom1k21xNyhwdg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASOo5FeOApYZXGcrw1PZyf9AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDJjNDI1NC02OGZlLTRlOTktYjlmOC03MzYxYTQzOGU2MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWhu52C6BGaCBV3JxvczyHXMbUGz72Q9XZ4htEgYMbKOSK\ntDa6DInQwqkCvXcOLuYAAFmCU4s2CccSfy9LkwOzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGhzwwTFGHEUK4Jf21p5ICOPV\nrnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVTLuZRFQOm6vL1JOoe7yIVxQpQS737qUHamKCU2oq/YCIQDYq5VyKOOy\nD4g16TPF3b4EyBe4Ob12CGKE9CPncfQj1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAWW5XDnzsUBc8hcOQa626CrrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NiNjAzNTctMTgzOS00YWUyLThkZjYtNzcyNzM0ZjAyMDJhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU0OGI4MmU3\nLWFkYTctNDJhNS04ZmE3LTU2YWE1NjlmZDYyNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPZ6cbG07kzQyRNt1pKCJmO6bnStbA5TClqIus3iWzMA6oZc6AuK/v4V\nCLw7zoX0kSksBitZtMfzSgRApIC7QhyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPPZHZ/d\nJJhurge0o8pYVOTpVb3EMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBZxV0oKMOGck7N/YgQnJPduZbzDzfcSGZVFKUtuj0cvwIg\nOY+qc9hBi6QKC/R4WYBXjv1QsZrcxmchXCTgwdtJ3VI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5601", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5601` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAXfp9oowgP7CyOwhPj0KuoniMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4YzYwZDRlLWE4ODgtNDQ0ZS1iYmUwLTQ5NmVkOTQ1NWRmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA2ZTlhYmEtODNl\nZS00NmUzLWFkZDAtZTdmODIwNjIzMDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMpLTGhi9B6fG10A/ByrJfY06eKT3/IiSSoOWPmkroDjgM9L65uCvx4ee/TUb\nNmwkvGNlcfdap81O630lYqLvL6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMDCPSmJHDAyy9UB49ushtg5964gwHwYDVR0j\nBBgwFoAUWq3/IDZBrIXFeOpxvzjkeduVuwYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAf2HSI/gopYFhQ\nW8CZJ3iIGa/NgOJEqTT2PyRorkTeVAIgC2VU4vH9onDK7E66Rcon44f4+wm4d68W\n7BiJF9E9Nkk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdSlQfOZik8mYpYZnbdLOZoaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGM2MGQ0ZS1hODg4LTQ0NGUtYmJlMC00OTZlZDk0NTVkZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjwJIim4FieS7EUXuGg165CIwz3eH8AhRvvAlfQhciBzho\nGMXqq8Cf+0F+GjW4Frx+wtW0jWIeooUOXs57+Tw3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWq3/IDZBrIXFeOpxvzjkeduV\nuwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUaGNjLgKL39+xVWCnklsYm+YsmsIWmikIQmG9x57kHcCIQC6OomxC/iP\nDfx8YtKv+ouesCnYpnxBUoWTsP85c6Tfog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfU+9x/CiB9JP8TnFPlUo3yJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA2ZTlhYmEtODNlZS00NmUzLWFkZDAtZTdmODIwNjIzMDkyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgzYTNhMTEz\nLWFkY2MtNGYzMS1iNWJmLWQ0OWM1ZDFhNDNhNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFshtFUzfUHfi6JCMfXEc8qz8ULI4QIU3lfYX8/NALZsue2S6sNERpD4\n2u1L6r3zoIa9fPw4oL+os5pnEdAw5M+jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDAwj0pi\nRwwMsvVAePbrIbYOfeuIMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAa6yg8Cl1mNLXU74M0+awVlvtO5R+6zwaAz6vDyPUh7gIg\nYthmMIQVmN/S2AuBQy3iZVQ3lvI3XO+oyc6iA11V1qE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5602", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5602` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAYNsY+CjWF8FTSTVH1rhGq6MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjYTZmODU5LTQ5ZDUtNGQ1Ny05NjgxLTIyMzRiMjIwY2E4OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRiZjUxNjAtMjBi\nNi00NzYzLTgzNWItYzc3ZTM1ODcyYTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELclt0JX7WQbQRG4V9LaqUzqMdUAx4+4xg3lH0TrsCFQMQ1nItvLW+w4B0yTX\nIOoCSBWKqWbEhaHbBQQSDK9DdqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdB1Z9W1NZqG+jxGEX07T2zQEeMgwHwYDVR0j\nBBgwFoAUUaQqQ6lQORPqbkIpQq4QwnAWnKcwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAu9uRwJJHS2CrhA/uKb9j\nsEVTlByDnmLTyIBFEzSjJd4CIDK0UmLkRVJGl43Estg33H+kzkoIODjxqL2iSfSa\n3O2e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR3xcUYu/Za2RZFe1IWkPi2dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2E2Zjg1OS00OWQ1LTRkNTctOTY4MS0yMjM0YjIyMGNhODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScdCyNuByOhauPSaTqir3vaeU483EbAWetASRmiY3PjV5Q\nc7vC7DkDWPIBfZLvUaknSX/jhLaayMQ7IR+Yfpsxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUaQqQ6lQORPqbkIpQq4QwnAW\nnKcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJwIfjT0XR7kHX3ob1sI63o9rEY0kp9WP9fbCO27groGAiBwzivUd0Lh\nGPDcGoJF+1fui6ZlwmnpcYrel5ci704Kpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAf5iD6qX5eVLpt040DIUMk4WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRiZjUxNjAtMjBiNi00NzYzLTgzNWItYzc3ZTM1ODcyYTBlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE2MmFlMjJm\nLWNjNmEtNGQxMy1hYzY4LWE0YmMyNWJlZWMxMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH6uYRnOEr3EN1znMK9ECQKLcJzJskom7oPAa4ptlH2x7v3Q2ejsx+8u\nP6AYxsfbDqNODMjKg3IZWyug62TOHVajcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHQdWfVt\nTWahvo8RhF9O09s0BHjIMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiB8I2kSWTmoUe6T/9hVgUVtGCKr98bw4vzACsoB5OWPzgIh\nAL/CxMjjO5kqNMrz8g1rEK9HoMlfuCrIEZlenbEhgWZJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5603", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5603` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAUJeaXSSLFuX0+6VelSUgzUuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4NzE1ZDM2LWQwMjYtNDFjNS1hOTZhLTY2OWM4NWNjMTFjNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmMwZDMyYjEtODg0\nZC00ZGQzLWExYjYtOWJmYTYyMGE1MzhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEitmCwVsHg01ZnrD3y6HhV+uyuGkQYdHnb07NjYKy7g4jHbM64MohJHXP4f8G\n7acYpjZPvO3WR4N857dwZjST3aOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjF9vBGuQytDxNNA5rJ/DDL+SHdowHwYDVR0j\nBBgwFoAU9PlSaUV20YQUioRtvgCG6a8h1aMwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAj90w\nG43/mYbpOZ6QoK1nJUSW1idp4sdq2f/c4kTb5ywCIFqCcyx8pacg4wk3FyXSgnfW\nM6KW/QFOyYPZrxJtz56l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQLoBP5p6PxlxghswUMKWUQVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODcxNWQzNi1kMDI2LTQxYzUtYTk2YS02NjljODVjYzExYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqwUHdCF7gzH8w7HGpEmv6rPbPuvFFKXL4n2rjdYa+fKBk\nI3d6UFT9XPahQd4/HrrlbpGWYG23CrQvoG8WGlmao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9PlSaUV20YQUioRtvgCG6a8h\n1aMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANzHehEHxOUecKhyJZ8+pTgFTeX0pg9evh/RdGI+WCsVAiAINYFIwOiG\nYRlUL6rf9eNPWwoBgsZEX0iaCnSrGCNbow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfeyLY0/zcJeXHKwGseJ3pyTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmMwZDMyYjEtODg0ZC00ZGQzLWExYjYtOWJmYTYyMGE1MzhkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM5ZGQ0NmJl\nLWViZWQtNDJmYy1iODkyLWZkOWY4MzM2MzhmNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCO4QTswFJumErk3wk2NCoxdg3sEqA0e3HSGrwKe2SHFBmcocYJwuCc7\nBnoJXTgoVtv52HtLGo3PxvMOyqo6E+OjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIxfbwRr\nkMrQ8TTQOayfwwy/kh3aMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBtU9f0NrpJQfKapU+68E/+i0t+eLX4ZTskWnNH8Pm4PQIg\nfcCoSM8MqOMxa5uqU/4VCLgmvj0AUbC77/5H5kyTWaI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5604", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5604` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAcZ6IA2jtcunQlr4ru19Nd6YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZWY4ZDliLWMyOWItNDMxOS05MzczLWFhZTE5ODM2ZjMzNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUxODA1OWQtMGQz\nNi00ODRjLWE2YzctOTgyNzAwNjRhY2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEybccJRU2XeVjKOeg8weJbpjcYdqbBYQzC7W5eXuXBo9Mlp8LSZpDyGT/sN50\n6KF9yCs3WUgYQFxRfml18qUyQaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUblYZVqYzGfwzAuLP2AqvOIn7rnQwHwYDVR0j\nBBgwFoAUT+5WHoYdB1LUyPHBxUfe8aPymeIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAhnXN\nRAfEcm2Jw7QWBEFQHVFB6zsoxuHG/bfDa3ie6k8CICcKp2UaLXNF6O1HmG0wSXxi\nz1tsgxIz/Na4WK2OxUAN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf2Nk9NRVf3ZdmchDzugTsWXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWVmOGQ5Yi1jMjliLTQzMTktOTM3My1hYWUxOTgzNmYzMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3nSWo4CLJjs0DPJ7b3HPIZ4R5mQvrhzuBkZsgPfO516Jr\nOAwp1aVxLkum94IRdY0AF+rp28Oq0p3FwG//wkhio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT+5WHoYdB1LUyPHBxUfe8aPy\nmeIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANO2W2jIRyXkpV2VLT/Z0IcQbMcOzhUGGXX2VVLxkQXrAiAMEDkOo4rE\n9Ed1BYCaRUgkXOY86VW4Q4TnyoDPeMMtLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASGlPTnfs8Nv4hXGpH42Pz9/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUxODA1OWQtMGQzNi00ODRjLWE2YzctOTgyNzAwNjRhY2VhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhhN2FkOGRl\nLTc3MDYtNDJlZC05YjYwLWJlZTViMjEwMDU1YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE932As2derRFqU/gLEHu6B1BQxqvzv86DuBMwWCVsz2GgeKn0JrlFfG\njKn8M+iCdqW1aIbGAxYeGVWWZuzlLdyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG5WGVam\nMxn8MwLiz9gKrziJ+650MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAiTURPcuuuKPQHLQ4d3c+z/F6fglrDgyiujVsjMjvh5wC\nIQDyzHBYA7CdCFk6UNtQO1mgQOdWrbe9vZr+253/g0IW7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5605", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5605` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAS/019XsPwweif137O4Wjep/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYWQyOTJmLWYwZTEtNGRkNC04MjI5LTQxYjAwYzZmYWFjMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU0MGU2NjUtYmEy\nZS00NzZjLTkzY2QtMzRmN2JiMzQ5Mzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEli5jnIp9iOgMXrgE1WJItObTNvrAs2Eo0aPV1jIREJukKfWUuVI3tPMQWudO\ncNWJA+/zllsrlghUVCgEYyAHkqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLdO8QdEzZLdtyIbWZ3AlNGNo4dyMB8GA1UdIwQY\nMBaAFNtP6C3rv5RHg/XwlFtr4VrxJsONMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAq855YWP0jga5iSZxh7IH/fgsWvXMEGPtB\nTZRH/Ktv4AIgFjk1pylh4YvLM8sKul5BN2ofqLHixTeKuW8fTvvLeBk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASVRhmw8XOCSs1aHRVZHIaZzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2FkMjkyZi1mMGUxLTRkZDQtODIyOS00MWIwMGM2ZmFhYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+RwhdEN35fQ48PV4iBIa3kzAFW+lbc3n5UwRzulYSXKtI\nauktAhOobh1FE3K2X9V9y2sZ2enpqM2gQ8IuorNUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU20/oLeu/lEeD9fCUW2vhWvEm\nw40wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO51+XznkiOo2kXyzDsGgfQZN3CaV4TTNWOgyzAmKbmgAiAyV7fdSuHh\nSLVnlqEsxQWTDtfrEg2ca9XetillbQSbxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASTErAtAN34fYgNSC4dYdA1KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU0MGU2NjUtYmEyZS00NzZjLTkzY2QtMzRmN2JiMzQ5Mzc4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA2YTFiNmRh\nLTVjYzMtNDI5Mi04ZmEyLTE4YTRhNjBlM2ExZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEZGe9n6GO8xXkMNZ49f7WaBDAZfvkq3FdbQw807g+7sNZUDTwXm2/r3\nH/qjG3vyKf3+WYs6aTA4PQ1F0oQutEmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLdO8QdE\nzZLdtyIbWZ3AlNGNo4dyMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAqdizTo4z+XcSf9qzEbjQqSlPKFVQQcfisdf2dqZWNnsC\nIEyORNuvkszMhQg4gWwXvW5jipEmt1//XexS2+MheVnt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5606", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5606` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAYjbCcNS4FftBXB0tp+1HA4zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2ZGI4MDNiLTFkNjYtNDg4My05NTdjLWYyODgyZGRkM2M4NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzIzYzk3YWYtNWE0\nYi00NDRlLTk2MmItMzBmY2M5NDFkN2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERXwIShXFdNv2/7RqIgUwYz9BJxxQEzqqWD/d95yZKpRzgYi6sjZSi21R6B2R\nfP1Kl6h+pHESmWKpK4B6KlRonKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPEnX8Fp53tFfi+eKZT7td/faWLUwHwYDVR0j\nBBgwFoAU4iQlkm/vCBYd8Y3j7HYhF5RMNl8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgAXeXFcSPrSLA\nreH+DSQCh0UKhxU20BBXIkhH29IKS1kCIBkS87SWmaHvUr/Ha07CAiBMNr0mxg0j\nviJwUGxoAvNe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVz3y7IOpTjxbLwmUTAnT2p/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmRiODAzYi0xZDY2LTQ4ODMtOTU3Yy1mMjg4MmRkZDNjODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/1v6I9en/XnP/OeTrzcwyb70K5kVPQJ/KNgiQVpn8qglz\n3bkxHpVuBH4u2TY0etx6uK7tBf/l1QTtzywSR5tio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4iQlkm/vCBYd8Y3j7HYhF5RM\nNl8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgScZ9CMTrUSg/2DbLgQSoLqptHz7gwPOJul3DCH78YPICICP3Z4FoRg6W\n7+ooki8ETHgVB4TI2PjWRXpXrjj7So7Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAWgvp638V0dNTIwvd2WUerfDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzIzYzk3YWYtNWE0Yi00NDRlLTk2MmItMzBmY2M5NDFkN2YxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU4NmNiZmI3\nLWFkODctNDdlZS1iM2QyLWMzOTIwYTU0Mjc5YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIgXAIW0b2X43bcUXsP1yjYQtVDRSl7QV4NuhMz3rAEtbFwp5ajow8Cw\nJ2eVfgmNfCdIZJCmEigeqAu+Jbeq9WmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDxJ1/Ba\ned7RX4vnimU+7Xf32li1MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA4o7Vmz9B/Dmuf3E3WeecQWDO0MRoKKuohdOeUYphyyoC\nIQDNQugHtiiugH+yXu7BJnLp3kiENUVanbbdBw6Ttrhu3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5607", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5607` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAQpV62RKTagAkoVuyZBWeU/VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyNmMyZjQzLWU0MmEtNGJlNS1iYjJjLWQyYjZlZGM0ZDRjYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQwOTY1ZGUtYTYw\nZC00OGZlLThhYzYtOGVlMmI3YmIwNmRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkHdjDHTes3ZZHMpjuaueHOIzRlKXSz3OQDq0c/vVoCYqeplgl0XwSbPlsIel\n28R0XBufqBc5bkfOzT9UsPglfaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhijSHo3l8H+3VuH5UA6c/FDypVEwHwYDVR0j\nBBgwFoAUEmv/e6szUQg1B9Nx4+IoaFvbgbswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgV/boWNELUTuI\nfsAByP6a8zWYo5qAJ0ek9dUK0Wbk15gCIHnJ89NTArUVSnvQEyDm9VGoHk36vF9r\nj7VRdDjvBuW3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARr7ml/Cf86BhEdPcxLI4baUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjZjMmY0My1lNDJhLTRiZTUtYmIyYy1kMmI2ZWRjNGQ0Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGA64E6J0N/RD0PP4WzJjRROAXjx3dDc7QR8k6hJCIF9nO\nOmCTButmbTOXrBH4j5VBEk2qdRP68KgP1Nu06jnYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEmv/e6szUQg1B9Nx4+IoaFvb\ngbswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMPQlavpkwUfRA/o0GMytH/3C/fSRQhtyKjLSHtq11q2AiA9UEg1Uv2m\ndfLSCzpyUDCHLT+wcbdDyB9r1dW61QCYxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAX9C7pANCRsZX1Y0Y4Kx7HXzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQwOTY1ZGUtYTYwZC00OGZlLThhYzYtOGVlMmI3YmIwNmRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZkY2QxODhl\nLTY5YWQtNDIyMy05MGNmLWVjMDhlNDA0NWE4YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABARCVEhechK5Nz9aZ9viKzk0Q32i+Tp0UfNpYR4D33zwmcSHOaqLVEAX\nvN3wwDm4MNm4zAp7LrFOzw+kxqUVaoSjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIYo0h6N\n5fB/t1bh+VAOnPxQ8qVRMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEArGJ0NRVvzDNOaOhH9impulS5OeILBrnKkoG/NsTdjo4C\nIHwCZZfaSZtrFQslNi6Sdw1C3DkfzoGg8Hj89HilIlpk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5608", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5608` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAV/SWn91a9+vIcycYCUg93pKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmNDk3NzgyLTA3MjktNGEwYi1hYzM4LTQ4OTg4NmZmOTc5YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUzMmIzMTctZGI5\nOC00MmQ3LThlY2YtZjAwZjZkMTUyYTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc6Gc7ZQDXjgg1psXpcr0Vj0jSXiU62qmdb3O3oD3PiO119ARPaBJmAWoUs/O\ndbmrAbHExO5whG2bBO347rdUaKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdv6JWgNEKeW5j9icCpGH0pzs1H4wHwYDVR0j\nBBgwFoAUbqhkb0yxSt/rVWde4Afuql4L4y4wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD7/roaTvpm\n4tW5GxJBhJKpkGqDtmo6+OsE0vDQ3u89mQIgaU9BT45VlJguJK+71VQ54Vs/LK49\nQF1MgFqkNqSxN1c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR/zgbvxYI4uoJ0uo7Q0sN2RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjQ5Nzc4Mi0wNzI5LTRhMGItYWMzOC00ODk4ODZmZjk3OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfPIhL5yaU9zvsgHAFppoB7qejsK9LOeIYk07wjeziyBBK\nkr9JHEITpHIayCF7hwHV5wtDzCeC2qYm8ws+QfYXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbqhkb0yxSt/rVWde4Afuql4L\n4y4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFqbRjvef5CFcDlPkTjQUjYIUFmSvtZgIy0tmD0CG9+wCIQCKsxHfTgfF\nFD1YEHCS7te76qkOozf42/CcULWw3vto8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQIPr8yRyc4bXLXpx1CCS8nmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUzMmIzMTctZGI5OC00MmQ3LThlY2YtZjAwZjZkMTUyYTZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE5Y2NkYmU5\nLWJkOTYtNDFiMy05Zjc3LTllYzM4YTBjN2U4ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK5aRpBZ6JravFefnThRCmLH8D4ZxLjQektlPLsQl3scpuvH9uXpxIMB\nG0CxiJVrO+EnY9jwtQWP9CfTd92w462jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHb+iVoD\nRCnluY/YnAqRh9Kc7NR+MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAgU9hMLthCPBvdneJsjjf72LYNCaWOPUthGynujSqP4QC\nIQC9tS3rc4GWVshitdGxH3HyP2zF2eBy5vgDwQcGG7TDgg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5609", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5609` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAahbuEQRlun0+9E/AoGXjOXRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4OTVlMDY0LWNjZmEtNDRlNy1hMWFjLTk2ZTZkMmY3N2NmYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY1NGVkODUtYTVh\nNC00Zjg4LWJlMmItMjZiYjNhZTVmZjZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET4EuaLjx8Xe26b24G9MuICXBozcAOT0MuLOHKqXd6sRvPDpibcD7H8kcO/E8\nwPJRxWbMnyXEN4kfvv7QEI0cyKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvzB7z10zFxVm55awq2+QtCd/BkgwHwYDVR0j\nBBgwFoAU3d8f0CWO5RW9j7WUeXX2Tk5jiMAwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICPsbvPInIESeFPwDwDdWd3yyZcqkMTjiZWFktbVOKMBAiEAztdFOHQP1JoX\n0awjDOQhZJYt5mUzxd74J5V1TrO0ljQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd6xyUlOKYj+HQOOQb0oBZIYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODk1ZTA2NC1jY2ZhLTQ0ZTctYTFhYy05NmU2ZDJmNzdjZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwsF+BMwfO2nV78M8C47RTRRVyAN/6E8fhPFZgQXSJHsb6\njg6hfFu+Ha7HkZ8zKTY8p5984GHThpkDO/bPNW/xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3d8f0CWO5RW9j7WUeXX2Tk5j\niMAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOGoa8jnofz55tAryCWVhe3G0oj+uEiUdCEzyuc2bQbqAiEA9twc8XPG\nwaVTaEFsmdjYR3jeDnU4X2U2HYF3xSxXGFs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZiEwwHrAjebvdQF14vkdNFFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY1NGVkODUtYTVhNC00Zjg4LWJlMmItMjZiYjNhZTVmZjZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVhN2M2NTdj\nLTdiNGYtNDNhOC1hYmJhLTgyODEyMDhjNDQyNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGZLNta5h/Wu4EChF52QWY0Zyv40x1vA0f7Unnrwy+DQzaddiV+Uc+/8\n4e1VXxim9g9qZf5c6oUddkESmzLDI4qjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFL8we89d\nMxcVZueWsKtvkLQnfwZIMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAghmd5gFUe5RK2PQg3xCJB8aHanjk30zgQ2uQBm/+6tQC\nICauh37uQfc+S4qZ57N3IT09/s1BQaAg9CF7CMVZdCf5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5610", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5610` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdKA93VpF9wJEQWjsSg+Q/oNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MjdmOTk4LTVlNGItNDMwMy1iZGY0LTM5NGQxMWNiMDgxZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBjODBjNjAtMWU2\nOC00MjI5LWIxMmUtYzdkNTBmNjA1Mzk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8VUC49HpkyecLxblcMKMdMPQpKbF51TxRMTa735dij9pt3RJ/v1FmtADQK/v\nPHC7LJWq1Krb/HuiPr9UWn089aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxh7ZKGav8QcupKQ3PNT7rNb11xowHwYDVR0j\nBBgwFoAUruXJO17PsavXVFp/Rhi3S3Si4UowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCYtDbppmgYTxRaW+qL9GcSG2Qv3a135ipwcPrTWm+TBQIhAMVTFuQXg1dH\n3PLIzQsjNaxrKdeBSFFK2mvGkZaHRDes\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQKLAzNqUOBJaPrjLgQ/lIlIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTI3Zjk5OC01ZTRiLTQzMDMtYmRmNC0zOTRkMTFjYjA4MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQP4f3m0oPdy8HVWwtebEPX4AekUi5nLmkhlKBm6MHJ/Ifm\nhoOe+W36rRoSh4REpOCem6U8sL/SSeTKO36V3t2+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUruXJO17PsavXVFp/Rhi3S3Si\n4UowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIvqXZudj5osEcMOyIVLV2iYxhNqc0umfe8MMVSlwk3JAiAW5mRZ5tmZ\neWwO7LJJoJ/bbyhFETuLHqU75ECZhQm94g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARVYXcbYo5YG13lxzJyohEdUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBjODBjNjAtMWU2OC00MjI5LWIxMmUtYzdkNTBmNjA1Mzk5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk1MmU1ZTE5\nLWU1MmUtNGY4NS1hOTMzLTY1OTJkNzUxOGJhYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBUtZlFL4mWwWFwx30fRyqZiootPr2Rcd4UlX9R9FbIvPhiq3DypXNAz\n5kJd/p5mKpfkOv7fkOwqhkIIsthWrkqjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMYe2Shm\nr/EHLqSkNzzU+6zW9dcaMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBRGmpNtYVe6IAZnrRwnpRFvn1JB0XyIR+qWwsb6JAtewIh\nAPdRveStLaX/GQatQXiGzoIbqTu001/CE3f+6QGRLrRo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5611", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5611` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISARXB26UGaJXJrsJgVFqgo9CPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MThjOWVkLWY1M2EtNDE2YS1iZGNlLTAyYWMyOTQ4ZTVlMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMwZGRlZWUtYzhh\nMC00NjA5LWJjNjEtNGI2YjZlOWRjMzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaSlDPe0B7YuJ4hBTIBFjJdy/GIgTrRl9MPGlvqBtTDxU9GaL4alKnX8zpnhJ\nRwd37kTetucGAplpaDOppGf82qOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcfVE+Y0NV5IDIHoc6e5984h/RcgwHwYDVR0j\nBBgwFoAUXXFiU/C3lCbml+UUx696xXgt4X0wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDd\nzVLdCw4PFguUPc75sckkFt3PyP0HhqZInEhpavypwQIgMSQIBF8PZKRdwZTxNRxn\nwm6BVqTvRybowB1FJwVeeA8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfxQilub5tdO8h/S5UnPVpeyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzE4YzllZC1mNTNhLTQxNmEtYmRjZS0wMmFjMjk0OGU1ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQD8821BB4bWtsalefcE5+tF61NfH6g+Uk1D+Sm4vDFk2XQ\n+Qf8Jjd6mTpxgMcUiQ69Bi5X7YOo3ncF+ozWhq/Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXXFiU/C3lCbml+UUx696xXgt\n4X0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX93BZLCKwDiZTgAHJaBXR0a996iS5iF2gEmbec0seL8CIQCOesgps/RB\ngOm/axOVKPvYwKsnvr4Ot0dlX7MlweUIuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAaA+f9fuEm6wg6giYKBcHU50MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMwZGRlZWUtYzhhMC00NjA5LWJjNjEtNGI2YjZlOWRjMzAwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY3NmU1ZjAx\nLWM0NzgtNGM4MS04ZDAyLTZkMDc1MWRkN2JjYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO6Lazy2nffYNpvNqTCiYGd8F1XPlM1jFOP1PKMa+VBXqv5oQQDOoErD\nNSenhDQJShRgOscLuRFWzsX3dmWpEFyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHH1RPmN\nDVeSAyB6HOnuffOIf0XIMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAz1Fq7MdlqRboUicL6rFuOdFTl0R+C/VtbSIz0zz7KXMC\nIQDvxiGJ+6LJHfsyA6DNtwDjXHItX34GC+lgMbmFRCcQLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5612", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5612` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAZoY2/PY35aTweVJm0tWqU9wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmYWRlNmYyLWEzODgtNDMzNy04MmU5LTgzNTc4ZWRiMjg5MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjIyZGY3NTItNjJl\nZi00YzNlLWE0NTYtMmVhZjBmMmVjZDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFryjxtOldhPls5b83TXwy5MJByg/xtJ9vEfFOLhMgA4WHffoS0DTcEAqnry1\nuuCYafV50ZJs1f27Z/GmtoePkKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwDg1j1SUoOO/yUUKVygm2rpi+nUwHwYDVR0j\nBBgwFoAU6O5MmqUva0lOxbEa9KSlC8ZsuTowOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIBY2dCfX1P8f75H79+B0XXtByJzDkKjg3ppQ61+XzWy1AiAz5Bhc\n/gW4TJICH/YaW1cCusUZ16NzpcQiUpUkkaRoqg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUyBTxupkvHLHPFdCsEzhIqwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmFkZTZmMi1hMzg4LTQzMzctODJlOS04MzU3OGVkYjI4OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrLV2Y7plhzZW/mescGa68ltalwS6BVFEsHDOnRFHgXOgR\nqyqYvVAvCFx2I8ygDhoeJSuM9LHX6wFQoVQN/tmLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6O5MmqUva0lOxbEa9KSlC8Zs\nuTowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbsO5LYFTZ79oQYZjsgcUb7Gq/wxkDcyAOSMlbOhz9e0CIQCS3coR5Uit\nuhPzubMYx0+p73XAxEEOTrgY/RZn1MKtUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASmKxclsVMOTs5UNbkWGFZ0+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjIyZGY3NTItNjJlZi00YzNlLWE0NTYtMmVhZjBmMmVjZDVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJmNjU5NjBj\nLTI4MzYtNDdjOC04NzU2LTQxOTZhZjg1NDQyMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA6X8htOzbNhGguTkjZtRjcrpqlMQgZON3xoANt5ntiMSMTHCf7D/Vdh\nCEdXp9m53X+YZx32wR1Q/82f/z8P2m2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMA4NY9U\nlKDjv8lFClcoJtq6Yvp1MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAoeLOu+KSDbS7SxvU8aHpHMGWet7b3WXUAbBhDyCTWK4C\nIQCHOgacsJtyQZn06khpkKN0ZEWxXtoPRFDAkDGs6hdkSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5613", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5613` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAb/Yxv8mDUdWwqdfU0yFRRfgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZWRiODNiLTBkODItNDM5NC05YTc0LTJkYjY2MDc4NGU4MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRmMzhkNjktNDJj\nMC00OGM3LTllYjEtMDYxNmZhNDNlN2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/vZ63EIV+g/V6/dpD8sIKiw/yy4eY72oLBjSmIm8NBVKIX0xwq4h4Ss5fY0c\n61fCmDs5Fgec+HAXY0conTLhX6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAf5sRuF+6HRRUBQ4m8ZQ7jSzUZ8wHwYDVR0j\nBBgwFoAUgVPbgKHtZ0vOtBhbmwMobpWGsrEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIETIz0R+Sv+6z4nCLwrUrCWqpFxrqrRgrSbwzAPWXW8dAiBGBlYy\nPKcQggNdFn0816+WpKom9rptMBT4lvqdWdlMbw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXkyPaiZu6yLGjV1KswjJboxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2VkYjgzYi0wZDgyLTQzOTQtOWE3NC0yZGI2NjA3ODRlODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9lav5D6tzmsuxwDbP8WT7fWoUFH9/UzBrVSWth4u8atlc\nxEd4MfUZthTqZW4C9dvLXfBLutdSixD2hCeEkVRho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgVPbgKHtZ0vOtBhbmwMobpWG\nsrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAI8BSh6P/OxapO50nG2UlBU6yCz04yrEdGbBTCNjWrz1Ah9XDlzLcwtn\nDI3Qw0USFdKcCwvasJF7z5WMUBl0DrsM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWX0U9WfZ9AwwLZM7LqIodJLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRmMzhkNjktNDJjMC00OGM3LTllYjEtMDYxNmZhNDNlN2E5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhhNWE5ZDNi\nLTRmNjgtNGE4Yi05NTMwLTAzYjA0ODA4M2NmNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBeHDrBOakq2jBcRB1gQSw7H81RiM6tYt9JUg8mMuQ+OP6iJQnO25A4k\nX+Mef1Q6APZtCBz1x2HQ/LekjYlsTcujcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAH+bEbh\nfuh0UVAUOJvGUO40s1GfMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAm/xcSEGYz4/c3+06HKZqr2SX7oGcv24yWMBhI7zPDLEC\nIE3kGyEGe5Sjo0m/CGsosiUGk2iK1MywElySFdFVsZ98\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5614", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5614` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXK6ceSkB0ynTXljTXFBmJEsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0MGIyMzE0LWJlMGEtNGQ5MS05YTE5LWUwOGQ0ZGQzM2VkNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlmMTg1MmMtY2Nm\nNy00NDExLTgwMTItNWIyYjYyNTgyOTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7jvEmFVFvJHzzDYYLbywFu1VmUukd7ZCl8Tqhk1rmisWkfZj4LL7pOmCS2m+\ngqrwaJGIBcqVpymhJfGJmt6JRqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAT0dWRkp1R+EJohD5CI5b/0HXGzMB8GA1UdIwQY\nMBaAFAPWGI1NtdTAPwZQRLAvmc0NKjvnMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAnkNXNMjt37Yf5kiTnsQ5R/t+wCbSZM5i\ngycF5DjQufICICglRuDSR33ajOORXDXMO6m/G/Wp/zOvJPTbEXuAOlKC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZHxcGl67XiOmUWqLyTSKwOQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDBiMjMxNC1iZTBhLTRkOTEtOWExOS1lMDhkNGRkMzNlZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAST+LJLHWYr7m7TxZXKj74njLXBS+moiNy08DNaZ/arzo6H\nHtQm8XpV3vdd96tEX7JJv4HWxOMnlR7ljWWQEmKlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA9YYjU211MA/BlBEsC+ZzQ0q\nO+cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVND4MHwq4i+xvzT7N3BAKaoMOAipbCCx4bcz9JNic4YCIQDEVVJ6ykvq\n22pj0AatZoBzrW/0WRHfKNKhQci5EcTLPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISARq1Q7o321x2N0RLyksohtgoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlmMTg1MmMtY2NmNy00NDExLTgwMTItNWIyYjYyNTgyOTQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhmZmIwOGNk\nLTZkMzItNGM2NS1hODlkLWY0NDU3OTE2ZTNhYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNrO83OijoIKLO+lwvGsu8p5uWydHRRZtiXKut1qeGOQRjhAglmjSK+3\nocPODPrrjUoCymC3t0E554ztuZWVnS6jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAT0dWRk\np1R+EJohD5CI5b/0HXGzMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAqW16NQTC8OiwnN5ddlvaw3uysZBJiENsM5q5T4q6HdMC\nIQD369PZGJ0oMphAGThJNSelTP0Shc+1fOs1dyA+wqS82w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5615", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5615` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAfqYyL8x/d78TUfmNbo1mNz2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzMTY2ODQyLTdjM2MtNGI4MS1iNjdiLWViOWYwYjU0ZDYzMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE4YTE0MjUtNGVh\nNi00ZDIwLTlhZTEtNGFlNTdiMjU3M2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGMgLySlI9KmJ6a0XLfiGb/5oQ3jBIvKAmpykYXr00qZ6GgZxgLXMUVwTR73j\nYeRym9QHjynIVzm5qBpv0pBHl6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaf+vm61P3QhVEtIwRXMsinzfeK0wHwYDVR0j\nBBgwFoAUJV27Ed2B6Shyr5hifBuAJAUmEN8wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMhw1dTMQEjZ\nz1CvSJV+EBZqlc6jycg5JiS9JSiKEwUKAiEAhShnmHG66TFeSfDWlQUs0ArLFLlM\nBPYcb8SoeCLksQ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVqjUyfMVKdxYU0MDCdvF+6DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzE2Njg0Mi03YzNjLTRiODEtYjY3Yi1lYjlmMGI1NGQ2MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0cXQ/bDCzu6O2LhG2QtsrkY0D9IFfopBuzZ0pBawkqjCA\ndinG3F0RCKDErOAMyMT988MgRSyDglzg1a1eweS3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJV27Ed2B6Shyr5hifBuAJAUm\nEN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMn3OlbRyTqbNg9kw9qXtEpY0/zJ1Jc9xmIDkpmGyOMPAiBKewW4WPr9\neZYu6eettp/uEUBVnTNcYI+9Aku9JYDifg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAceRrpxAa9n7Ebt2xZFaYTGEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE4YTE0MjUtNGVhNi00ZDIwLTlhZTEtNGFlNTdiMjU3M2UzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBkYmQ4ZTRm\nLTg4YWQtNDZmMy04Y2ZhLTFhZWFiM2Y4NmFlMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPPmSaBOWAtUXHO3Y3lVrpPf7G+VB8OI40+Pj0ROUKoupUMERjljt7SS\ntTU7rDZlDXHv96qVxiyQSQdXnIjI0Y6jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGn/r5ut\nT90IVRLSMEVzLIp833itMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBLsVEznHx/2+hrf314prOIryzsm7pO1LOcdtavWEY7ggIg\nU+0TmVuWW/ZUSbaRENYSmAPVRnZg5bd67rxGM/nxtlY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5616", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5616` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAUZx/To5jiRjRjpVpaQcwRVqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNjQ4Zjg3LTg1ZWEtNDlmMy04YzFmLTkyNGQ0Y2M2OThhNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQxOTA4OWItOTE1\nMC00N2ViLTg2MmMtYTQ0Y2ZlZWQ0YTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6tKDDnWS835pR2pNe1OugK+sWJNhYtBj4sEo6LAGHLHktk8tBRcUhqI+VX9A\nTFLirnJMbhzsNoObigqzQSZK9qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTgrt4of+Y1dPMwwTPogunwYGpvcwHwYDVR0j\nBBgwFoAUWvgJWiytgP0J3sqziE4sR22bgVEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALssOcc/Xz3K\nm2qJuxAvudCLY8a2qJqskJ7fZ3HTh1ISAiAWw8sGQklpHnHk2XCc0Gz4hFc5AlMl\n/ZRYUsHsR8a6rA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbkE3545/IscQvtVkqMbKdadMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjY0OGY4Ny04NWVhLTQ5ZjMtOGMxZi05MjRkNGNjNjk4YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdRWhjMyijGEQumWFDz2buTFxfKej6MmNFrh8enfmqDoop\njAZ7gAx8mN+9a7PgdnNGS9rGpgwUr6bhEC/zKf4wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWvgJWiytgP0J3sqziE4sR22b\ngVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCRGf+kdHzMK82nXZ5ltHIaIFAfVH/+IOqT14IZLKTdICIB3W4pbS4+zH\nD3BS/K7df6BUal2YUnYmb7bijFSTmF07\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATHA0VQQeJymUPUs0gWCb/ijMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQxOTA4OWItOTE1MC00N2ViLTg2MmMtYTQ0Y2ZlZWQ0YTkzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBjNzFkN2Ey\nLTNmOGEtNDE2YS05OTgwLTZmZWEzNjk5ZWJjZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE5TaROiuxhKw4BrVckLINT3smoM4cKDdcRkNYur2HkSI+znTTrmybAh\n0icYxCH0gquMiDpt4aJMNBKnXJc31WCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE4K7eKH\n/mNXTzMMEz6ILp8GBqb3MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA0ENy2k8vjLXAiefI7+f88p3J99vCEFhTiEv9WyGtJ98C\nIQCGCHqJcVfvUQysy+p/1CR4xk1mjSqaSi5bNovYRzseoA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5617", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5617` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZUbxL/nBNfLxWn2zYANcm8tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxNDQwYzNlLTk1NjktNDgyMy1hMjVmLTg4NjZkNTdmMmRkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZhMDYzOWMtMzk0\nOS00NjI5LThlNDMtMjM5OTc0NGZhYWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElxVneiDV/4py2xdEWyEVjzzArebxvzGRNDvNbKv22+EocrqouMxv/rmChDr+\nOcoTcSKGlYnzaVu5l+JhUjBQtaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKtm2ReUADwoRiI9ALBmVmU8qoFowHwYDVR0j\nBBgwFoAUNX6If5ub4LI0m2WbHx+5nwRwfi4wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBChcghRIMAJ\nUoHzNa7casAeSVQ3Vx++mZ2RaFl0L8HqAiADJKOBhI867AuLkGC/l7xWrWlhPdBe\nGEwR/GtD2azPgg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcUwSz0LpbPNurFXXluZM5CUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTQ0MGMzZS05NTY5LTQ4MjMtYTI1Zi04ODY2ZDU3ZjJkZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoznOQWeQhP9Vsb6uEuX6ybAankaSIw6SNh7moFeLwmkEp\nl+zTAazUGRdyoeoBZEWP0vUn9XHwz6FsABjPuQ96o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNX6If5ub4LI0m2WbHx+5nwRw\nfi4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSXr5+Hx0mT8xdaSNdM475FOkM6VzRma0KBKOws4vpMUCIBxRt7Q8+rYu\nKJk7EV9J22MEkkkVQH6d6wy3v9st+OV+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAa8XQlv1d2s9m8UT0rV7ii/GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZhMDYzOWMtMzk0OS00NjI5LThlNDMtMjM5OTc0NGZhYWZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE5ZjZmZWU0\nLTk2YTQtNDFjMC05ZjFmLTAzZDczMjNhNjMzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJuZaxODgrOatvlDYd9DuawtFHNlvN0zFc6eBDENZ+Nw2r3g6tjyiSmF\nX8oioj7xe+G8oF3ShTP7q9r6pGa6GYujcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCrZtkXl\nAA8KEYiPQCwZlZlPKqBaMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiA5OxL4b3R3lHDFdeG9DWD45rG4Yun8pvHj88FkZE2QsQIh\nAPDpVZHaYlHesg/VizfFLV6+FF0gFeFo88IYE31zqXY4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5618", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5618` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbvBy4MiGsTYLofp8nPgy0AQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjNzlmYTM4LTU4MTUtNDQ2Ny04YTgyLTg5YmQ3YzlkMzkzODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QxNjY3OWYtYTgw\nMC00YzU1LTkzNTMtNGI3ZDdhYmMwOTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELrSOdSeQpEDleOoTPMY+BUjjYYXI7LchteAzsbHIt6qKN5jAdGE3yOGiEuUo\nZjF9I1EzZMJmCGCB+vc8Ehn60aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU43JICwbRz0pmRPsruoGVTDAobSowHwYDVR0j\nBBgwFoAUZw4Mi+S7fV/khduUMaF9F2IJZbswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHzK1bkEA0UKhMCmLsmPNJ0rsh+n+H57unrt3qoSHag3AiAXgOROzg0ZKL4H\npzKcogmYfZkgOjaIrck0pbonQkIbow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb2GogB0W7ifa0rUiE6BlGInMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzc5ZmEzOC01ODE1LTQ0NjctOGE4Mi04OWJkN2M5ZDM5MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0P8IBD0ha0sJaRzH0UUSgpQyUiUJGIdJ/YLrXiR01q+Ru\nbbmvgng8YRkVvgELL3igYTjSNyLa7huJFYtVX+9yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZw4Mi+S7fV/khduUMaF9F2IJ\nZbswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMByLj3XkAEzFaiF2uk1I3hn5HBHpKFNXZXr5oWp3sHSAiBvYDKQfr0x\nyGW+z3dt2qImEqCnr+xufB2TvUFvcGfwLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZs1VlUx2MjVE3ezHkAU64uNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QxNjY3OWYtYTgwMC00YzU1LTkzNTMtNGI3ZDdhYmMwOTY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJjYTM2OTk3\nLTYxOTUtNDc1ZC1hODhhLTljMDIwOTgwOTAyNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGC2fpdarQKZzACM1KNFnO2KZqMN1ZmT+ItTCIBq0AaMFCawbaY5+jQk\nccHb/eT6WaAnFuKVQRSuzfj9Ue/HgtmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFONySAsG\n0c9KZkT7K7qBlUwwKG0qMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBZQmn2zyyQntlMDoNqS28anVeZTKfnyAcURHDDLHrfNQIg\nU0K8cfDuTqWCd+Ueq9x4yvtplnRBVIKnBV66ZAOAqEw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5619", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5619` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVdJNwABvKIMyorj3NKsi9vNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNDBmMWYwLTQwZjMtNDViYi1hZTkzLTI5MTk4NDAwOWFiOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWI0NGRhNTAtOTI0\nOC00NTgwLTlkNWQtNTRhYzA1ODdlOThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq0uJxwRwAUUiBYabG08URDWXXps/XoxKvx/4IaxD0zthW5e3mDXonLXtO2Wg\n//PbSBwQoxx7Q9phWYFtTW9la6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEZ/fk7nbtJW6wxSqKnDQyahiW5swHwYDVR0j\nBBgwFoAUEWK76XN3JM512i9rzu7Ghd6/cxswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCTap78zqkZSdk+Fb1VClfCwvv2/tRU/z+Vjjl4Tj0CiQIhAKOxb3vSFEbj\nfeu+S3WD1s7o5O/NG9GF9i6GOfPITsph\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe6bcaLNo5RderCFJ9s4/sVIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjQwZjFmMC00MGYzLTQ1YmItYWU5My0yOTE5ODQwMDlhYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROfthHuRSdiEhFL768zunDxlTSWBMCFsPiVcF3tCuN/GKJ\n5v4gujqRn+/7Xrw+QafZCKuswKZJpu7RVakYtdN6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEWK76XN3JM512i9rzu7Ghd6/\ncxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM533MrjJayJ2h72NHHYbZixhzaWpp3z/6D0t269uh5dAiBbt16Uvh5p\n1Hq2ZLHkP9APnPdPkGQbFBYFgqIEx0ektw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAVlKiI89uDIcQ6H1dY/6vr5qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWI0NGRhNTAtOTI0OC00NTgwLTlkNWQtNTRhYzA1ODdlOThlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU0ZTQwNDVk\nLWM1MTUtNDg3MC04ZDRiLTJlNDAzMjkzYmM3MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAKCgKCLEdqobOnfqJ/Hbnmi8L6rmM6YVchX3UJ0AHHi4MUkGzv26Sq6\nGsCS7CQhpoGOEoA8MuBspdd8Bh4bfQijcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBGf35O5\n27SVusMUqipw0MmoYlubMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA5EWUwX354f0IIP5t6Vr9qZwaakmxUg1Q6q99lwVb+0EC\nIQCFtdvLmTf39QQWPmfVrVS7AQnrWqttHx+zINqnss3hTw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5620", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5620` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAVdIToBmfzGnQ1h9EIFVYFK6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1MmQ0MTY2LTFhOGMtNGFmNC05YzUwLWMzOTYzZTI3ODY4NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhmNGMyMDktMjFm\nMy00ZWRjLTgzNjUtZjU4NTcyY2RhYTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjFLfj5Kow82RwER94eS1Vy2DtmsHWKNvCNammYE95rdIxj8RPtmtX22Ed0DQ\nYeBnFn3b7mDeltcy7MoUZkx3haOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU85/Oi1yzvbvuMHWmFKRaVXuDtcgwHwYDVR0j\nBBgwFoAU2Zjlyp0Gj3/6wcHT8gGK67D7XbowLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCT\nS8PsAWQ5wS43BheCOeNUu2iG0t3D2NFCBF8DuQuQCwIhAIDhJS/j9rnTyygwsdeZ\nvwpPEM9uc+nDL6xtE00ZrvUB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX/vZxqFp1/flWvZhxR58SDeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTJkNDE2Ni0xYThjLTRhZjQtOWM1MC1jMzk2M2UyNzg2ODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkXnpoxCrRQ7RwfxeD8DO5SDarOIZrvMCba9Wlwwl1j7gj\nzFquWXyqAfLn6Iimk0/BzmYGHbW2WT8mMDXmlT6No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Zjlyp0Gj3/6wcHT8gGK67D7\nXbowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPQWv/GWl4zZ1I7n0uCmWXaZCFedjonwJbcz5vsHwt85AiB515LguHBX\nZAkJrzEuLniAF7x9Xvx8vmO7fiGuOjqZvw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARTZpmmbD3iMCc9YqhNsr0YJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhmNGMyMDktMjFmMy00ZWRjLTgzNjUtZjU4NTcyY2RhYTc3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk3NjhkYzQ0\nLWNkZDEtNGY2Ny1hMzU3LTJhMDM4ZjZhMDRmMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGlLuszebHCC0wCXAjK9NyIhTFiIJBYrd5yoC4E28xv/zsmQCLa2HRXG\nxR/bfJtgTYCEb29FMWKE6+FnkfDtEA2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPOfzotc\ns7277jB1phSkWlV7g7XIMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiEAo+JLivbF8UVLj/FxNOndqMRtokwHHOiR2lNak69am9YC\nH0sV705lMhdUPnDEq/sKMgThcFi9Uq0Wuth8z1uwnYo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5621", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5621` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAUext54geRelNpnDfPvgW07FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwOGI2NjY5LTE5MWYtNDcxZS1iOGE4LTNhYjdmMzUwNGQzMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2YxNjNhYTAtMDZi\nMC00NzAyLTliZjktNGUwOGRmZjg4ZGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQR5ZQBYu7zS+flI7vWpWVvIR8xPGOiaYSh1H1L3QXqqRGUCKISGTpfTWpZAT\nPALnfW80I3T2aAgbZy8aqHWCrqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMX7ESWFG7wvbLAscDikM/XuUnzUwHwYDVR0j\nBBgwFoAUUeH+pQwCfn7rKb4uXDruNVBX1hwwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCID5wO1nkCagLd/rMBNhwj5mEvPdY99AmAxREK6GBdIQAAiEA7rYf\n+ejCbZC4Ckwm+5FGqwtFAZ12uSC0IeOjc7o6iLw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc2o04RJxNZfqS0GMAZYmE1aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDhiNjY2OS0xOTFmLTQ3MWUtYjhhOC0zYWI3ZjM1MDRkMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4UVe7brZxOo6QFlmrAQlgwwwUZIgeoK6x/gfjmqWyB2Dl\nD7sv4hi4Tpida1JuhwebhW750JMTNQ/Ttk67lUHho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUeH+pQwCfn7rKb4uXDruNVBX\n1hwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOl55wGkmp2l10SZ5hi7TWeV5omQmzydbSMQe2v58P8WAiApWSrMV/DY\nnPfI6Jg4v0j4MyXGYg2anPMFog0TFyWXsw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAVRunu+65OdkdcrCvzaU9D4AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2YxNjNhYTAtMDZiMC00NzAyLTliZjktNGUwOGRmZjg4ZGE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVlYmJlYzNm\nLTZmYWItNDE3ZS04YTE3LTJhNTEwMTk2MzE5MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJI/PBj3AxdErf9cHZxsfeqwOIfvbJq4aMvnhbByCd3gqqgNtJe+B2on\nWO8NZReyYS82j36EpY88guHLmahPxuOjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDF+xElh\nRu8L2ywLHA4pDP17lJ81MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiB1hilriVSJxOq+vr8UxmKd7/K/DEblSaHDO3/qLkEfHQIg\nc6z+FRKxhHYPfcuBX/lHjByXGGzLeK54O5BZKwOrJR0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5622", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5622` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAe1Hq/duDOXEb1ZfiDcXFA+kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiMTlhNjc4LWIxZmUtNDNiOS04NjlmLTBjNzg2ZDY5NDY1NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE4ZjNjMzAtODdi\nOS00OWI5LWE5MGUtYTVjODVkNGJhMjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/4MkvSY9EYJD4uW9AhFunbEQO1wQdT9iOss7G6tn5fQBjAqWMM+VNYrvU/UN\nsk9WcjJW9P0YunnDIA5+S+ktT6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULHUaCJavEjaraeg+XsKUgJgUWmYwHwYDVR0j\nBBgwFoAUW9VlonZTUZwA5FsAW1XLqpBS0IwwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGLeQQOZarvZ5cZ1jT12vYOAKY6ejyy/zGoYEHGh/xt6AiAMoRWQ\nvpBNvh883VlempCSd4boAW/QCbLdDsl37qvGXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb0X3HbLj5cTCFpjQjWYlS13MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjE5YTY3OC1iMWZlLTQzYjktODY5Zi0wYzc4NmQ2OTQ2NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjOqmdxqaA1ZqEYZsBQRWyGfo02MPNzukeJoKNpX4QBpbK\n/ZQV63qyFRozD8UUxmQyjlon0D0jZl3TagxeJYuyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW9VlonZTUZwA5FsAW1XLqpBS\n0IwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJgJ7Eo1Uk5ExKpfQzcgQznaQ5duVxy6A2gn1jd9YduUCIQD/banukoia\nmPJRf2E1pVlfGttoUOZPUSILS0TPRy+vZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAWOHIn9bchPDKtxrJMdH9YzvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE4ZjNjMzAtODdiOS00OWI5LWE5MGUtYTVjODVkNGJhMjIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZjNzM5MTJj\nLWRiNGEtNGVlOS05OTFlLWExYTVlM2JjZWQ5ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN+ULx2wlGZgFGpp6aiGiFozZhK5mPyNyuxW0mZMExwxx+W1LEuhGrvr\n79BXPDT+j1PuHKBDpMSJjWPodbXaMEajcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCx1GgiW\nrxI2q2noPl7ClICYFFpmMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAPPY2Wqbg89emup9wg0UGaOqxaATdblIjYknNUK5l1zgIg\nU+97PsQ/s0ieThmgtAP6uEBKPHT9cmFib++/hAzMgXk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5623", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5623` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAVtI+nxZ7uSmuaZ2Tytq/6fqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxYWViYjNjLTFhZjItNDVlOC05NjNmLWY4MTM3YTU5MDhhMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjgwNDFjNTgtZjZm\nOC00NWFmLWIyNWMtODBkYjYyYWE2ZjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7l+vvGOLpZsuKIYk83ZY8um841GlTk8vNP1+SWoeQSopbxWZgFll233rz/uu\nS+DhGJ176VnSCXL+3FLEP5R+JqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR3RNkTWhidI27jAbOIbui89Wrj6TAfBgNVHSME\nGDAWgBQX+M71OoH/xuIwcnEbdQvjYsHPmzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCv5eEqMEgU92pMzvDTTpnCXcq4nxh6\nXBrqMiESt+9b5AIhAJUxfBE64JZtGpuWycjeNoFqgoHM1EFQDUezsHhjN7Ql\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQyCkw/f2ezkJFEPO6bSs/IxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWFlYmIzYy0xYWYyLTQ1ZTgtOTYzZi1mODEzN2E1OTA4YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMGr5RARkbzoTT7DMdIwOdg6j6q/fluHbxbngHjI/J4i97\nRLRHFSd5JP9wI+1PSieTWxNNr4P87e+FTG3KaoDbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF/jO9TqB/8biMHJxG3UL42LB\nz5swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeS20MFvb/xpglsiwCas1q/ndN6I0hVHA7+6jiIbcQlYCIQCX2Hlv1hde\ndRkS8IeaowKrbDDBe24KStQIkEXJ+bVsKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAf2SHY56sakbK/z79mi40edTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjgwNDFjNTgtZjZmOC00NWFmLWIyNWMtODBkYjYyYWE2ZjMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY2MjBmNTNk\nLTk1MDUtNGI3My04ZDcxLWQyOWYyZTJlYmI3YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJCIimFfVyVUAd4cSXgFwnomdWE7M4NUzISks8rlNOoi35IiQyKzoxdb\ncklsBalcxPc5RlkH/tg6e6Yf2rv/pEyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHdE2RNa\nGJ0jbuMBs4hu6Lz1auPpMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAf1qTkKKCHYqxgtuxP3afkWS64a6f52Hphb8iYi5Vq1gIh\nAOKX2f0H/14GsgoVrSbauRfw8UB8u2aslI5FzK7m4M8m\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5624", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5624` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISASiGVL5gktosoPUnvp9lJfdoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5NjViM2NkLTZjNjQtNDhjNy05MzA5LWQ1MmI4NTk3NzAwZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRmODAxM2UtYzU0\nYi00NDI4LWE4ZDUtZThhYjAyYjUyZTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKhHH7b9ai8odq06i5/RYrJVsXlXZAPLdzi4bxJW7Fu4mDf03rNLCiIj60f1A\n7NDCh6GUgBvheeLcxm6bF2Mo+qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9VqGl35gEkhki8DZUUtU202Mh5QwHwYDVR0j\nBBgwFoAUU5TEwTEDCWedR7ssH1uJWLNMz7MwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICxu9yzPvUqI\ncQ9PnBXV0SZuQhdaM67UDxZGwEy5WpSbAiBUyMiD2cEdd8Q9UWgqfU8JFDeylHrT\nPOcO8HtTldANIQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX1gGaloEP5v2P58CWqcaxZuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTY1YjNjZC02YzY0LTQ4YzctOTMwOS1kNTJiODU5NzcwMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4uyL2deL9IF3uNpMwNAWZjL1VHVFF3RzODB8njkemhQMH\n9M9/ljM5kyWno2vWSQrlIqxaJH+EzEprPQ48F/5Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU5TEwTEDCWedR7ssH1uJWLNM\nz7MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGZWmEw33wQEtI7kv4dTK229eT+53dS4D3PIpYV+sLh0CIDtodkQ+ZohU\nlD+AVTB1S84uHgMQRlG6CeBmayB2vSWn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASZjhBF+2mEu5hWOJc0ehYGcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRmODAxM2UtYzU0Yi00NDI4LWE4ZDUtZThhYjAyYjUyZTUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRlNTBjZTgw\nLTI5M2MtNDAxNy1hNjRhLTQ2YTQwNzdhNzU1MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAzkWBXIf+wp1qgHgIssnsIiIKo3Ss+lN0GB8sUz/dBtdWzbeY71jN3a\nGcJWMZkAFcXQxhLS8TAcrNjuo+408qujcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPVahpd+\nYBJIZIvA2VFLVNtNjIeUMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiB5iA/IqnxuJV1CGZQnZEH6b5YIX8m+b3RujrcIRPO1VgIg\nPbuRjXAjEXmFckXgIALPplV9io889clTd63odWyCy+8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5625", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5625` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAWfYTgpvGNeofT09mfToR71RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2MTM3Mzc1LTcyMmMtNGM4MS1hY2I3LTVjMjY2MmM2MDBmZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY0Y2E5Y2ItZTdh\nYy00OGMwLWE1ZjktOWZjMGM2NzIyMTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECwNvouEnGkliNT2QcCs4tmRY6FiacuYJCHZO/GfZ5nW33dLgPFlmgkGoOAbb\ngjTIkshf0XdP6LDEOw11VMoU86OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSMyr5D5ijYdh7NAWxmYowbt26FowHwYDVR0j\nBBgwFoAUrdTEbI0TyOW0LOqzOxJOfWQnfHAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCA2xO7dtTK\nTbnpTpdcR3QNtHzL4KRphmVoA3Ti9FnENQIhAO5fY2+KvSduGlL/W13bouIThkTE\nhqRh35T8gcCTfqln\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf2PVE5bk9JnTdjokBOUlvDgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjEzNzM3NS03MjJjLTRjODEtYWNiNy01YzI2NjJjNjAwZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJafyjLAI0RawnIX2Cn+ezqYiJc4JwCPcLPPLPMD4gj3XS\nQt7OTHtAUEy12MUFAoXC/qqNg3d6F2uRyZVEQ5upo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrdTEbI0TyOW0LOqzOxJOfWQn\nfHAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKy01M8PedU30Nka8Ik01bmRyHrlfra0y/4BX7Idmk5wAiEAnScNglUT\nO42FHR2wRP/gvsm1evCSS9y8ez1IosByiJI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZ1wxDYO9pgJjPmFlHoOWtGKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY0Y2E5Y2ItZTdhYy00OGMwLWE1ZjktOWZjMGM2NzIyMTEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ0NzNiMTJm\nLTk0MzEtNGZhZS04NGMyLTFjMjg3YmUxNmM3ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIQbGyKSjqdbImUOKmDo5vFObV+4v+YScdQ8bX7EhJU/11UScS8eNoNQ\ngdscDM7LlODTjtrZzrd6FatdUHywWu6jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEjMq+Q+\nYo2HYezQFsZmKMG7duhaMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBr8av391bNyryZdv/v3Ap6PDk7sRmq8MuZKC1Ig5xWCgIh\nAJ3iRTThOMyS3Cq8IwGVwHsZ1Yf0bbnQN/hEYU2kb8NQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5626", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5626` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAbc7V0KwqM3TM+xfm0O3r1EVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhNzdmNTZmLWE1NjktNGMyMi1iMTU1LTlkOWZiMDY0NWVmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTNmYjhjMTItMmRl\nNS00ZDc0LWE4OTUtM2UzZTU4ZTg5N2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESOg3Fbmvm0K9eU0sriBEFtfiG0If/DcoMTFDy4J7O1vYYJs+NQ15xA+NpO0k\nTSPjWp7QUhCLE7lEGwsPVDsdGqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkwC00ft6JbIhrFJajIsRP8e/R3wwHwYDVR0j\nBBgwFoAUmWxP/nES/esPdU0IuQtZ5oDgn8QwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA5U6DHsp9\nnKgXV1TIaZldQCfqZg1k/JaZTE2o3IqsDiUCIDfPqFd18JjOsyXOe3e4lMs52h4T\nn0c3cAfgjrSVDGlg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARCrEY7dK3JuoubHAn3ZSOsoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTc3ZjU2Zi1hNTY5LTRjMjItYjE1NS05ZDlmYjA2NDVlZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvghJ0kGj13op26E/vHtLpLbmoTOzdoMgu7pekiDcv21dW\nzoSBQ/AqZnCKVr1KhnuitaioWomTBWglFJwFkb5Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmWxP/nES/esPdU0IuQtZ5oDg\nn8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMll5ELvNo+INE+7VCzW+eMJ4D6odVxe8pm59I12Gdk/AiATHnarKamK\n0N9Sz2LEgTSnEg8IIXR0PKe2Bd/cyoHKtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAaO3BizqK8G66/PrqZoTKkhEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTNmYjhjMTItMmRlNS00ZDc0LWE4OTUtM2UzZTU4ZTg5N2NhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgxYWI5YjBk\nLTg3MmItNDY5YS1iYTRjLTIzZmM5NDFiZWU3ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE8DU/TcbzikzRgD0Odc7kSp7N9vnew+H/Kc1z9xjvZX7v6Rt16RMrIk\nt7AaWZUzStFMoHls8e6pMmeMOcQ/L6CjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJMAtNH7\neiWyIaxSWoyLET/Hv0d8MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAlSwA3O1RA/7QNWCHVWy6ghLT/Hz5AHIosiL8FPgX69wC\nIQCv9tH2ARyhoCd0JCx60l1eZ7uCf4uHWPw/gQiQQevWIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5627", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5627` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAV6295iSIZz58IM08/raf63RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjYTc5OWU0LTIzYTEtNDI2ZS1iODY4LThiZDlkYzgwNGM2MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGEyNDI0ZDMtMDU1\nMy00YjM3LTg3OTAtZDE4NDM2YjMzNzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPCIo4Pv9ItUgl0w+IkABRdWsZwNcaTbodtA0vwqMKIXeORx/zt3ZaJIJYD0K\nisNWHFPtFJ3wN2pcIyH5T3HESKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlWprHbvhQo1Ds+g3b6EsXZ60z7cwHwYDVR0j\nBBgwFoAUgokaIjwslqjrqFk14daZW+R03PgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAkDLDEDYAkffhKFBMG3W+854lxq4r92uAgtxLh0DPmeMCIQDfvnIfqCVV\n2lxISu2jil4VqhHvXnIfKEULxazd0DHNiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAeVhDQq0CLHIeqam9aQaBUtmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2E3OTllNC0yM2ExLTQyNmUtYjg2OC04YmQ5ZGM4MDRjNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATATglrODxEpsjm74NpyD4ZP8tYCdG2NcjyOwRWiBHgpM17\ndl/UuIwRJke0G3YtmJJFRL6B7xF1unb66wUYx+Xto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgokaIjwslqjrqFk14daZW+R0\n3PgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIgf2zpI459b3TD7Ir4m7hjAqU1kTEc0lBmqfInbzoyIVECH1mcvZk4A/sG\nrInVvlOMCtMvCbfbO0+wmPJYSQA/K3E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWibWA1RRAAGv/6dDYzw98f7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGEyNDI0ZDMtMDU1My00YjM3LTg3OTAtZDE4NDM2YjMzNzRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFkNWVkNDU5\nLWM5MTItNGFmMS04NGE1LTAwNjE5YmE0M2IyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFmIX6Ub+e66uELhhBKTQV8f/K81HrHMsrKqH1ux3HIwWsq3em6MnePG\nh3u+HX++QVR8CtWpVex3WzjjUCcAjgejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJVqax27\n4UKNQ7PoN2+hLF2etM+3MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAz5jGjfQLrqe4gZeqOwTBhotHCCEmAGKIsbpJ0fqNru4C\nIEY3af3/6wynkuE4FC7DNcRz/dU5Aax1djhJbsyMoRUw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5628", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5628` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAWFsaUeuBX5yCi6Gi8upDNhfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2ZjY5N2M4LTdhYzUtNDdjMi1iYmMxLTFlMmU1YjA4NTFiMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUwZjgxM2MtMGZk\nNC00NjNkLTk2ZmYtNTczNmZhNDk2YzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEareOdyQCRQVvYehHAYELkMagPhCEAIlGGxJjc4tAI4gzNwaj6jc7RgUtCUOn\nBzEbqGQSdAuvREHRXywJ1EWKN6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtJ1mM6f2zRQqiEi+5fowo+TCJFQwHwYDVR0j\nBBgwFoAU1VKLep/UhaFDcwyV7RzpS+7NZ9kwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAkl2QELh2YlD/gYVqrn7tq4AMhyCCFxvT05YpOqTgzpwCIFCIf0RmdxUz\nm5wwayJYESibtOPJOwjiBqdns7culBUz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATdYGTT6w/HPjnAM0TWp6UJAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNmY2OTdjOC03YWM1LTQ3YzItYmJjMS0xZTJlNWIwODUxYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+TsLm8qr4UEEC7eKCTBHJlU3hei/MOMG5mV4rlC6nGlZw\nGgDtu0qQ4fjhurAhA4+iB+dQK0HCs1cbL+YPGnojo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1VKLep/UhaFDcwyV7RzpS+7N\nZ9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbZgKGeAt54fqb5op5HrIJgexPNi9kpXVnhK4kETtCnUCIQDrya+rXfxK\nWjwJRlcgZOsWXCb3mXxPjdptqakcMAJiJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfYvPLqEesttZgA6NiLuFaiwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUwZjgxM2MtMGZkNC00NjNkLTk2ZmYtNTczNmZhNDk2YzA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGViNTdjYTM5\nLTg0ODQtNDdkNi1hNjI2LWUwNDgzODQzMzA1YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKyEo3qzpJyDJSlUMqc8KirJU6J972tcQXZNlOChu8XjJ3uRPoI/Y7LM\nxREPJ6Hv1Fw5FpCo7xSbd8DhEOGKdCejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLSdZjOn\n9s0UKohIvuX6MKPkwiRUMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAQTh5tc+Sla1A/vPW21aVtxsbBqLpuGvRLZcjrdmU3kwIh\nAJ1XG4d6TNCYXbfF3cfE0Abs2EEcbcAfS7UumV98bJBu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5629", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5629` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISARH4IghggZbIEH8zRMrX3q+bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwMjYwYWFmLTEwMDktNDI1Ni04MTE2LTUxYTRlNTU0NDBkNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFiZTJiYjItMjlk\nZC00MTc4LWJlNWQtOWE3ODE5NzBkZjY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEavtFdTobSp09nwk6AkQhHN82fRjfWf1Dg5S8CSEK6SqtLqzK8aptjt6Sb2E5\nJVwkY5G1jDDiczzzQ7FPGwi9waOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe/soGQofoIyJxn3UVsgmwISaMqEwHwYDVR0j\nBBgwFoAUrjNlIcTcu+syQ16mkafZFYVvFR0wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiA3\nM9A0UQD9cpXyWVpfaB1WbOQgzABchaciuFeUFdbE1AIgQ2tIWSYvyNQbxwEUGPrV\nq9pTbvSRW6ttMse3Yr0ve6g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVzCbGB3xsQcQ68A53NY0Je8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDI2MGFhZi0xMDA5LTQyNTYtODExNi01MWE0ZTU1NDQwZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAyUJ8DbE2hiaNdVdhUUuFOUhkRsr6MfbtTTa74roMydHA\nupSiEfkU/u4f6ROwlMoqQI29XNMSmgEYMWEeInHNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrjNlIcTcu+syQ16mkafZFYVv\nFR0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP1NG5eGq37550uFgXbtkRugJjnSmfobpb2aE74Cbr0pAiAc/UWtFiR8\nWa5LbOSsAtKSz9bT8dk2lDWrX6Y9wmEuEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUU6z/AFSWT4Z2y/jkibTT6FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFiZTJiYjItMjlkZC00MTc4LWJlNWQtOWE3ODE5NzBkZjY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZkYzBlNDlh\nLThhZTUtNDJjMi1iM2EzLTk5YWYzOWUwOGVlNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMXO0k6clXyazagFKsQ6o54akxi+oO1/lGPTzkQBPtoxFMMfhh630Qum\nnEbbA3RAQ1S+QsuHcP68g8XLhUEKqn6jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHv7KBkK\nH6CMicZ91FbIJsCEmjKhMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAkLnx/3dPZjw6XH0jlA1aLwKbxsDeXG09nHnP/dIl1IwIh\nAOxi74HEmMDaWc+MpWRbqiv+MTxxqdFp05usSsxiLQuK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5630", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5630` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAftCf71thmdVOvCWs/RvDmgZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyZmUxMjk0LWMwNTgtNGNlNi05OTk5LWNmNTg2ZjZhM2VmMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNkYTAyMGMtNDc2\nYS00ZjY3LWIxZmEtZTc0MDNmODA1NTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPl5cbMuOA3LjSjRF0yQYTpvATG/gGgHs9jMMMsAAFwbg1Kw99Ni++L86Qbf3\nW0NhumlpFFVy5zO9i0JqZuYVeqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtCg5AMAdj7skcTftlPisC8QoZYEwHwYDVR0j\nBBgwFoAUtUVQvfhMDAnqnoKCKnSWCFPspH4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiAXxAkPkPBr80YDxHTKWqGrJKJAHgzEFZqOdUXUWxEGQwIhAL9T\n9dti3lsESY6V/duqHYkg4q+9NROWhCn1cnqaqwS1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQl6e9drmia314/crjrTYi5SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmZlMTI5NC1jMDU4LTRjZTYtOTk5OS1jZjU4NmY2YTNlZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0RfibMq0dCTNCJaeRBQc4AeG3qfzR07r16Ln/h38dftOj\nBGnKuClWizZPgMQon8W3fq4nbD8UyNIugjvveUImo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtUVQvfhMDAnqnoKCKnSWCFPs\npH4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL51ooe4e7aW7UN8clTm/9gKPl45QBsymusX2zhxJgJkAiAGrj2KRO4C\nY16k5nGCZRltqddW8T1Bgi39kV/vHoJ4Cg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASb1afU8D4PW3Wb2OYgkg2LVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNkYTAyMGMtNDc2YS00ZjY3LWIxZmEtZTc0MDNmODA1NTg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU4MzQzYzcz\nLWQ1YmQtNDU4NC1iNDA3LTBlZWMyZWQ2YThiMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDxAS2878J4yVZfeQGtapU+PQkPJKVySWnHbcnkJ4AzNkDPZsXsqYiWu\nsny5cC3+zYXasV3DxPzzUQiyvzWdrHCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLQoOQDA\nHY+7JHE37ZT4rAvEKGWBMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA9ICeTpahWWJPW+zAPmsvO9sAgOnj1TziSBrRardUH8MC\nIQDSHCTgGD9Qo6ffUF6uC9TDCouqOCV7Ej2AKia+LI3bPg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5631", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5631` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISARjqk6otsuev+bVmgegCWYSjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhMWNkMWYwLTE1MGMtNDNjZi04Y2UwLTJhZGIwYTUxYTE1OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQxNDdkNjYtOGUy\nMy00MTQzLTgwZjgtNjcyMWExMDdiMGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEclpg+kjhM6Xuob//67j4cifx1crmCMVuGQyQ5mA+fRdVksDXPTzzNgE/Kglt\nSL46THW4KjqvF1oFFrustSuNpqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ84LAZK++cgfHFBPJ0Y34FQesVcwHwYDVR0j\nBBgwFoAUFMKbtLD8gNNP4lb5L6/sl/aq0UMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA/qpb8U76zQsTG81L1QYvKzKnApARTf5D1mQw6WGqVbgCIQDL\n9lNwS4+eUXH9F1qOVKJ3HbY0y0AvcOonoJ4VmZvIxg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAULOOTdLP810iz/Uerpz2zJLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTFjZDFmMC0xNTBjLTQzY2YtOGNlMC0yYWRiMGE1MWExNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkGqZFedKYmpjr62zXHN4UUp21EMqcK/522bmdWALUePJn\npnZCVt73wwybn2QBrEVEPDBV93W95bQvVG99D8gDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFMKbtLD8gNNP4lb5L6/sl/aq\n0UMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPOslFAPkC3bazRzYYdjGWb6j4o2YCDgajbX32tYZgIIAiAs/zcm+dUz\nf9/3cqwBbwqjoISFKHG7uJaqh1uSRn3E4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAazr+C/8+a2S2g1WosGLXGhLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQxNDdkNjYtOGUyMy00MTQzLTgwZjgtNjcyMWExMDdiMGU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJhMzIyMTk5\nLWYyYmItNGYwOC1iZTIxLTM4Yjk1YTk3ZTU3ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDNTOEa6jpqj/IKpMyqV1SyfOKOTiVfh38HJuWa4d2AylHqp3F3xqYiC\nUoY+xBG0uPPcHWZRt8Yh5i0oVz9N78ejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEPOCwGS\nvvnIHxxQTydGN+BUHrFXMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAimwCQz0CnceoDmkZYpdhm7Kf8YSS3ImLo3cYAwrrH1kC\nIQDzx2ABlRmdaHAUFq/WWrUH8kWW9NfYaK7qnt/CFvSZ5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5632", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5632` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbaETwH//aQX0UroHWOvmAz+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjYmNmMWEzLTdjYmMtNDg1MS04ZDhhLWJhODgzMGI1YjhkODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNiZTc4NDYtMTc1\nOS00ZWVjLWE3ZTQtMmVlMzljNDE5MzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQPLh4/HVIzF4CrrDppVaVhFjKAeii9/JGKMatF3eB62sfKGsnc9zhxVs4WOO\nuDO+xRCtnCHR+P0TcABQAg23nqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2w6SIiEzWw+yR8uYRFT4Qux8tFUwHwYDVR0j\nBBgwFoAUuCHGMx9FVTonthaAA07ZnK9xkLAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAs8dJbbf8DmBgU\nZtoo4lbzbBXlpOZcXKwZwmsAtvSifAIhALt6MOY7CH+b40NNoEWk6ZnzlbIEQi4S\nSR4h6MlOgYyk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARJ9YNVbOxvJj8jPhB6iG+fIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2JjZjFhMy03Y2JjLTQ4NTEtOGQ4YS1iYTg4MzBiNWI4ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVxRAbT+qq0wH9Dh+3dzs2VrYAIDz9RkM8aXI/uWobHazS\n/0AOk/jMVjZSt8cmeWNK89XIVYC7lw33hPeMjZn1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuCHGMx9FVTonthaAA07ZnK9x\nkLAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdo7sU3/zWojFKu0Apel3e8vrelYVJ6EIHienQMnenUECIQCrh3mLo5Yr\nVgkEzwp4Q1yekHVMgvsgwHpxiwo0byIbmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVPU9DkkjfmXzs+EDMz2yjr1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNiZTc4NDYtMTc1OS00ZWVjLWE3ZTQtMmVlMzljNDE5MzhlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1YWI3ZWJi\nLWViY2YtNGQ4My1hZGZhLWM4NDJkOTg2NTlhODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOtqDHW4ZrooIOLig5QVxjqxM0tNbsR1cSNSsvUOwE+Y6xRCdUr2oxs9\noeQsiqXJqiCztIRr5CtP5w/FyPSGpFCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNsOkiIh\nM1sPskfLmERU+ELsfLRVMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEA54otmfCDJxxBbvjutCxtt4FGoeczJS0c3n4vWOGJLNcC\nIBK89bvsuva61ktRTBwWeI4PSpD5qRcKzptnNNSkkKSh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5633", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5633` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASvMouoZSfr/2IrJOnW2CMchMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NzEwN2IzLWU0YjMtNDg0Mi1hZTY1LWQ1MmU0M2VhMDhlZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWU0YWNmNjItYjdm\nOC00MTFkLTkzMWUtNmQzMjBiM2I3NWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENCqw54DIWX7XrtQeSNR3PrPTc9+mnlYrBjQxIWo17iKv9souXpRk/7sNApOE\ng7ByBlEkrjM6lNRsFjIJydXK36OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQf2135XS3cYbLwXjz2qFB61oRn4wHwYDVR0j\nBBgwFoAUIgetcQbLf6SpOAvqTuk+wEUctxkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC/Bmu4+3LW49b/xJfO2r5q3sAP2tj7T36ECbNdEsKixAIgWYCicQvgvV62\nazCHr+k6xRdDbJn6cInhieBr3dor0kM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXekgDyGvU0uSfECPm7FsiM4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTcxMDdiMy1lNGIzLTQ4NDItYWU2NS1kNTJlNDNlYTA4ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHvE+vX7STMy9jD046lrLQlI24ITpvR6PmkOuIlktZU9Hw\nITNN+5nQDjGm3r9UOObBqWYU3zROXS5BWBRjqppoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIgetcQbLf6SpOAvqTuk+wEUc\ntxkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJieHcy8XJv39M0CGQqdtw1BsLinE3YkvtC3TN3Ct+TQAiEAtb4yGq4q\nzASKHSJvIe0KJDOk7wEkgFe/29+FwIYVnI0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAXnmGnjTmNhuA4QD/u69HUavMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWU0YWNmNjItYjdmOC00MTFkLTkzMWUtNmQzMjBiM2I3NWM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVlOGY3Nzdh\nLWY1OGUtNDY4Yy1iYTdjLWNmYWFlMDc3ZmNiODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKudn9sCbt7H4TJJNBiKy4ZjwY+lzqkJWumWiTeaKaYcZMhmagSHxxsI\nRrtC62sJQKxAI5hZCtbv9amWbprP5ROjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEH9td+V\n0t3GGy8F489qhQetaEZ+MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAiH0Yr1ognrrKdLtDEHepfWkbh1l81jM2VQm2GWM/KiQC\nIQDnxA8HtPfWsNFYQJvMLcQE/FifPxSraCRYl3x+2boYbg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5634", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5634` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVrrJtDg1R3sHd7TQWdNhUi3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzZTdjNjkzLWQyMTMtNDc3MS1iMWQxLTlmNWNlMWE0NzAwZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjYzNTY1MWQtNzZk\nOC00YzJlLTk1M2MtOTU1NGE5NGE5ZGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE30CgYe5V206YjEQvN2ZqvZA/FfYJZXGsKUqcggHNm3KxFveIIj2sGA8P8bvt\nQgzbp+SHUSStPCTozqjdKcLbmKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULM33R0jqwFjDKC/nYvooKpE3A/owHwYDVR0j\nBBgwFoAUTzKz49XA9hVZbaYjji4OO635QyowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD1xmIHBOSYQYrDR7eAN9FwLHcwDEXQfigDDSES7/+8mQIhAMUA5oijq7lP\nHoIryiZfLwzNC4jVfT7ATnKCMGmPVFfP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYjp13Rv+hNAzLPmYqD2Vzz0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2U3YzY5My1kMjEzLTQ3NzEtYjFkMS05ZjVjZTFhNDcwMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBEJqtLG5K/A+uZunAoC3xW6NZ+0z7UZ8+/MFkaHbGCZ1s\n06cPsvO8lR/E1SeUmaAA2f+Vk2F/p1rCFoM0MthBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTzKz49XA9hVZbaYjji4OO635\nQyowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKzgFJ2qXoiCqkfaZyeKm5oweF93syMFQ0cDmFfNUDbYAiACQD380H9I\nYF5cZriMEzi8JGTeYN/pCXwTuGvjlhHIKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQO2nGty1iKJLzJtLKKfyfFBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjYzNTY1MWQtNzZkOC00YzJlLTk1M2MtOTU1NGE5NGE5ZGM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMyYzJmZGZh\nLWRmYzYtNDBlYi1iNTA4LTQxYjk2NjA4OGZkZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFek6AXuIynesuSWczBeebuAn0LkFJdCCbjWv0bQSsmZpGpqXKj3Kbd/\n2clZAa2Q8HUy7dOZCDswHFzlybRq9zSjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCzN90dI\n6sBYwygv52L6KCqRNwP6MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAwBCYt3SroVqBN87+havmyLs1ltpxMbo/6XJUaR4HGjYC\nIQDwjm2naINZlPEYHylb+A/kjFNiUQMbDZuxZjis5B+QyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5635", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5635` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAXgCJIaAug85NqyI2mW/8PUDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlODc0MjRkLWViNmYtNDBmMi1iN2NjLTQ5ZTczOWY5YTgzOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRjYWRmODgtNGY0\nYS00Yzc3LWExZmMtZmZhMTcyMmYxMjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+EBL1o9oCRiEshNaJGX8FDuj5poNeScjLtc0qfJ5aMr4DZjIoJn7QmAAfT54\nVbT+C00PUe3AuRIutviOG7B2sKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz5qRvDbCYUdlKfJsLfx46u2O7UgwHwYDVR0j\nBBgwFoAUbOxQ3IsqtFd/3ckox0ecfDoFg3AwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiABNYFb+vt0QDEg7+1DsQUOzJUb6zwc59i3IBf23pgFgQIgFx1XZ6FvVidC\nODelPsVFrp2bTDpAC6DbtkVJPxThl2s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfCAVuOs50zlavsreWDmuh/JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTg3NDI0ZC1lYjZmLTQwZjItYjdjYy00OWU3MzlmOWE4MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+4/nU9jAtFlKODsQyTd4cfOEDc96dM9BbyuHHKHlbbTWE\n3QCdmv+uDJgCgCbtNf6Uf+s0AQPjU52f7GMWzolKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbOxQ3IsqtFd/3ckox0ecfDoF\ng3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALZgMnRNNUlcGqrNTbXQA09qQ6Bzm+kta+Dak623Y0fbAiEAn5i+cMN4\nOzJH6wl4BHJOO5904CxARUeADIO0OBSPINs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAcDRYrlr9IEj9V16BvKUfmTpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRjYWRmODgtNGY0YS00Yzc3LWExZmMtZmZhMTcyMmYxMjRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc0NzU0MjM1\nLTMxZWUtNDM0NC05YWE3LTAxNDA0YTQxMjEyNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBvPJpOm8RiF+ss6NVMRRI0jZYfQRBYzKuTFLK4MwIjNcnZYu4Gxw08h\nN+9AhYdsQXUfjywEpyaeqnoP62wqF9CjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM+akbw2\nwmFHZSnybC38eOrtju1IMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAtTP0yz+grhO6rzzlN8Fcng5ZIldlkYivTGIFl2sxHlgIh\nANLS+NjN1vakWsTKmXsbf+tLRn05IQGvYoM//LdL/yWu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5636", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5636` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAShVYSmc2zFsPstAPgiYiDm8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiNmVjM2VhLTcxYTItNDFlMC1hMGVhLTFkN2MxOGE3N2NlYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UwNGI5ZjktMGEw\nYy00OWYyLWFlNjctZGFiMzEzMDU4MzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPqadhGDSi+xZtLlPQjXg+F2SuUzSVyagpj6kbB8z/3oDkqSGZpnWSLN3Sucs\nu3WmVUKdx84bQf5gdjwExP1HsKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEAJcX361JiTHp6qcpjmwgQDIyrYwHwYDVR0j\nBBgwFoAUtu254c6dbV80+PJPuKQ6bei8WgowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAiUMqyXL8IUeINzOVfByyajfoD1pN1ETqCKEDFtIx\ntU0CIQDRt/bxeEQck8Tjg/1cTtoXRq3exjfFcAjjBb5AiwLEQg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVb9DdG+6wA3MG4+9SnNQPOiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjZlYzNlYS03MWEyLTQxZTAtYTBlYS0xZDdjMThhNzdjZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATo6FyNa4GHG779zsaTFDBOFRtG29IPYzyfy2VGP2dWVPx3\ny+XHKX9gGZVTZy27ArmK+wXp5aGqUULWf6P0MGGko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtu254c6dbV80+PJPuKQ6bei8\nWgowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK38FwMtL1l14Pirz0xhT9weQtBQIdgkby9AriavNi+yAiEA7xvRHhN1\nJB0FsdZ5kqrvWSAafj/f3KBZ/eoGRDVioI8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZdjaC79Rpi6uqNhVqgtF4D3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UwNGI5ZjktMGEwYy00OWYyLWFlNjctZGFiMzEzMDU4MzU3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNjYTgxOTJk\nLWZhOTEtNGMzOS1iMTAxLWQxNWZlOTFhOGE0ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKtw3bblFZTo/bCm48A2EEpIb2xurCU9WeAUWJtftqXUoRO+hB8yFrbj\n7InwVmQgwdTnDDROXGYJAQRTXIbeopejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBACXF9+\ntSYkx6eqnKY5sIEAyMq2MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA4YAH1FoE4jkCW58JBJ9JA9c5bGtsh+CUaV6bPAOP6XoC\nIQDVX4ylHBOQIMMYZZUXufPvTMiWTodCKvFdTHrnwZgOWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5637", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5637` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAdmFNpBDAOSvisW9M7Og4PqYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzNmYyZDM3LTI5OTYtNGIxMi1iMmI2LWUzZGU3MmFjZTdkMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGEzNGU5NjUtZjg5\nYy00NjlmLWE3ZDUtNzZhNWRiMzllYmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1OtcKc4HCfiGgudnuw3uAJbuBOl6cgcb30q0OEeyoRANvRO+fp+KdvYmooIS\nstnTttzbYbnOnk+FfzcuExh0LaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdDVgwQmYBxX1EImI7CDKtI8uSmcwHwYDVR0j\nBBgwFoAUjCC8PasXl3eCeEYWmm/MhLpDI2UwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAuqKajz16qFVEzAO/s+a21Yu09VB436/1TvjQcQjrE\ngAIgP8SqFWFMeG2+XoOX1XrslW3vRVyOoPlK3JJgJArfYn0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARceeKyOIoEttmMu22yVtVUlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzZmMmQzNy0yOTk2LTRiMTItYjJiNi1lM2RlNzJhY2U3ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThHpTTcxvKo9qObD+riDSPF9tYETAkE0yAD3Hyxi/l934g\nzfM64e3xDSUXuEFZ97EI5BVRErmBqTZApccoaF0+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjCC8PasXl3eCeEYWmm/MhLpD\nI2UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKoIjFDe98XL88LCk4/2wLEVcXKSfiVDPrir9vDgSCoAAiAf1YpLEje1\nfWq7nmkgoTydYj//Lr8ZzdGmhR/tC2jLPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASjS8+ocWZNlZeAdmBUFaxkhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGEzNGU5NjUtZjg5Yy00NjlmLWE3ZDUtNzZhNWRiMzllYmIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZlNzA3MTJk\nLTM0OGUtNDIwMS1hN2Q2LTUxNzAxM2Q0Y2EzNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIdI6A0okUqw0PzAiKkynW0RVs7paDJwvZMs/AcyAshnPk6+26iauXxd\nRXDmvYzuRPqGnxbFDvDOVA2baJR8MLKjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHQ1YMEJ\nmAcV9RCJiOwgyrSPLkpnMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAnjTPFnMQDiG7KM85oUfIO8RhZ4i+BisBflshimsRHAgC\nIHCbJ6r5xh7V6a3tIqctPoB/Df1PIwisgTJRHkzwBNRb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5638", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5638` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISATUbnWv+ZmrRRDXelwXCaJqTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhMWE4M2Q3LTRhYzctNDE4Mi04ZmNhLWVlYjhmZmQwZDA5ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBhNzRhZTgtYjM2\nNC00NmJkLWEyZWQtYTM0NmU2NTNjMWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc4/8tUAWOHa7P3BGrPt74qAuQIPpN4ZkyAotI3vLYDcdN05zNdPojddbeW45\n4FTCeV80uKsS6lLWV1+Srxnv0qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfq9N9TOPwonU3/sMooqucuJtARowHwYDVR0j\nBBgwFoAU6LTGOqt3d8p7MLXSFtig0B705L4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAvdbsDF/D1DSKpZkHvKQpZwkS7v4GJQgdGYtPNTTXVyQIgTUcg\nB2RmWzqQnQ7vn+995LkF433r1yUM+xx3xsRRm1w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaSlzg0RXo8Vk/Y4zsEuPMJgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTFhODNkNy00YWM3LTQxODItOGZjYS1lZWI4ZmZkMGQwOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNTvx55e1FIjTKUAcwzjCEKdyVfaM/QG2UCY0BvdnSFfrE\n3VvjCijJMf7sc2F5j9xjhej4nB+lgb1Kbk/o4KWRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6LTGOqt3d8p7MLXSFtig0B70\n5L4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANpE/ExKMXP3yDXj/ejHIrMu138tNEkUIU0HmMycYN/yAiASHhlWNWkf\nIuenv1CUdAzAVhMwtoClm09oGg51rsPTTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAad8QOriG/5tJZwHvEnZqiyAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBhNzRhZTgtYjM2NC00NmJkLWEyZWQtYTM0NmU2NTNjMWZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBiZDk2ZmFl\nLWVkM2MtNDYwOC04YmM5LWUzZTEzN2RkYWYwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLQwWjSlD7kwHc22WGixlKoHF6yP+jCJAwcQweV7DlSNQrtltYeFvMPM\nez2CYOKr0v1W0HBXlCYAR+ymipMMN8ejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH6vTfUz\nj8KJ1N/7DKKKrnLibQEaMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA8P79Viuu9lxa73EsugQNEUr1fOlk1eT8WhW36RR8X1sC\nIQCoHQe6JgREILw/LMWFRncTM3wQ1H51/YPXCQV8KuWsuw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5639", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5639` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARU8BbripT24qaTYlCbPrG+CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4ODQ3ZmQxLTRkYTItNDY3NC04YmUzLTAzNDIxZDZiYzEyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk4MDA4NmEtYjFl\nZS00YjQ0LTgzMGUtNzc2YjcyZmE4NmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyB67PvnCmfyFE6oJOPNzgROSV7kFckDqwVUyMmeHsRAvl7HGFdQ/Oh90YR+O\n+AJDiyyVkSFBDmY7kul308nsL6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUreeqUHoohuqR3Qo1vPxPo5R1pkswHwYDVR0j\nBBgwFoAU3Cfe5I42Zw4rsytVsgFxXL2XldkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBhyF5f64WNI06p2abxlTCct4QpQ7jK3icr\nq7IxMP86WgIhAK7KM9gPxDucQNTQBFc8GMiMQQ8jkKC/AGgi1pj0mUJl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeeN6vFfY++aO6Ws/31Dv0UDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODg0N2ZkMS00ZGEyLTQ2NzQtOGJlMy0wMzQyMWQ2YmMxMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARa8XXk9wT6KSQ/+Bd50TbU+G/+ec1TPM5CS2oI0OKOpJJ+\nP+6QkT9Z2wEyZFYGZIIhXwZlR+088mzhJHjDYnlto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Cfe5I42Zw4rsytVsgFxXL2X\nldkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU2yXOikv5IjBi+PwIiRWjEUCrTbkNMv95lzryUbzMzkCIQCLW4sImRhj\nApq5DBW0Ch59MhjKo1hFMwo4bTVcxBMiGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAU08gbxnysSuX62mnN2q7YZOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk4MDA4NmEtYjFlZS00YjQ0LTgzMGUtNzc2YjcyZmE4NmQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRiZWZkNTFm\nLTIzZDUtNDI4My05M2IxLWNjMTYwNjBiNmUwYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP5h3SQUdPlZbxWst1X3hYx06P4JvRpu9wVMl+P8s/bHcmqGDGa8O7IO\nNgFqEnklCX07Q4otfgwXrdbhAwHeBcCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK3nqlB6\nKIbqkd0KNbz8T6OUdaZLMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAh27pXDhgFpqzk1OfpmZAzh88FgBmBrZGvmk4UF4XPsoC\nIQDbx5Fr+CeokmtyBlS3v4WHIMuMhAdwMCRd1abw5JtCCQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5640", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5640` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAZAQKilMOtFwXcH9+9xOYbfAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMjBhYzFiLTcxNGMtNDg0Ni1hNDk3LTI2NGM3YjIyODcxYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMwNzgzOWItYmIw\nOC00M2U2LWEyNjktODRlMjVlYmYwY2JiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIH/B6CT+gXgReZfkb0dpS3JPXgWGOWFsFw9A8wqBVtXyJwCqlFUtfKZOIUHP\ndgZma9yDafIGmsWhCpY6xR/CVqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHBFqdRnkj6LS0nAuQjagcfzZ9z0wHwYDVR0j\nBBgwFoAUpt+axdbK0IynduFq3IlTaqRcLvgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB50fs7ekSCvgd5KXDm0lbkv3koCXDgfkzQ\n7EF6kRTxPAIgO24fUjlseu+bnQjoZU2KmjKubO6pzvv++3G/VD69HMc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATHSPR9m+hwKb7sQOe6TK1+JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDIwYWMxYi03MTRjLTQ4NDYtYTQ5Ny0yNjRjN2IyMjg3MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUhhvF7UZ3l9NFatJwoy44Vks/6OiylsrwYda/iQidZqFB\nB90UAKejA3rbTl1Y5+v+P2llM6b5EntWYdXLk3zBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpt+axdbK0IynduFq3IlTaqRc\nLvgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALYOQif/6gHZehuqEN2FktUk5ns7BvboRptfGaJ61JtbAiB6wdG0lr7/\n3RVuMCrWV+3VA8C60hJrH6oCMW/qm3L21g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAailZ4QhVQpl3hEbv3/UNjyoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMwNzgzOWItYmIwOC00M2U2LWEyNjktODRlMjVlYmYwY2JiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQxNTJiODYy\nLWI5MWEtNDM3My1iZDM3LWUxNjlhNGU1YmRjODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE5MGn+oapvNxp2sIk3Je7JY7yhDCBB2PP4Plmv/vnQ6b8v7/pH7G8u3\nH2zlCTWbkLxfTB6zW0LawBP78sz68IyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBwRanUZ\n5I+i0tJwLkI2oHH82fc9MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAo6/cry6YJoFnPpdqAhNMzurz+YCvVStzQDv0yG2hCfsC\nIQCVMMNLRvtT9yBas1qkps1wV5fPLpBiIDBWYmNEhp78qw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5641", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5641` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARBlehSRkOTfd3mIlA1MLiDCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwNjRiY2E1LWJiMzktNDMxNC04OTY0LTlhNWI5MjA5MmI2YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgxY2Q5ZGQtN2Mw\nYS00ZWUyLThlZDQtZTJiODViMDkxZTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhBwlEnvAq1bysG1tJ0EBunlBvT3ttt7hCaRxC/kMCHziZr698E78j9ROArCr\nxalrTseo62OqXdjM1BEDS6p2sKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7FTQDPPDK7s4dKj+3ZYjI4Kdj4QwHwYDVR0j\nBBgwFoAU+dGpvvzW75r+7kmwDG60R5YEhJgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEApC6/FlVxt9aZ\nJCgJHsSmPpUkLF/iRFIOPV3QGa8M4lwCICMuwTCkKnlRzpR7WmiZkT9FANDGlPjF\nE8LugEekd9Se\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXlnHmsIhjJAI+JSEkNLil+2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDY0YmNhNS1iYjM5LTQzMTQtODk2NC05YTViOTIwOTJiNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScWb/5eZaQqoVY3cY2cik0rgRBPFchmEYtqyNRG4h74afp\nlV0XZWk22go4HG3Gn/rF9hKJ0/YVthjviuhiVvIRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+dGpvvzW75r+7kmwDG60R5YE\nhJgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAId8Qc4/3eaFP210ywCC/lXTSXUoTaHrk6lM2q5UKGSMAiEA9bdMFmSh\nIgWHKLQrZEvtrfeEbCnA2eYu6jg8CthvKfs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAUFCh4NT0uM227leacksVQxnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgxY2Q5ZGQtN2MwYS00ZWUyLThlZDQtZTJiODViMDkxZTczMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyYjExMTli\nLTJkYTQtNDcyZi1hMjk4LTdkNjVlYmI5NjljNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL1WAOQvL9tO0w+xlcxCRso1ba8iadq2RRXnbF6Eq+iZku8okR2v9N0m\nbY8S/wLck3T0vQHhj9c4/ekO2NFrA6CjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOxU0Azz\nwyu7OHSo/t2WIyOCnY+EMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAiOli1HSyTUcCSIGU9Ywa3Tyy2awfVBrC5hvCAQ7VWPQIg\nbJhKuDr9nff8V9qggZOwNWyshzXlF5d0wfh9uUWXoS0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5642", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5642` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAV7KsyE3Akop/lkgsjFfMBSVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkODE5MTQ4LTZlMDQtNDViOS04NjU0LTU4OGM5MTM3Y2Q1MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNjMGExMmEtZDgz\nYi00NzRjLWFlYTMtMzJiNmYyMmIwYjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6UOBp+u86jbRw2HpVHHoDsPXcKlvvJvydPpfH2UA+TvDk/vFis2HYi28giDN\n25waBAYnvSGt054Oe+BpqELqdKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgv9duwiKI5GY1ZbeohCehEeAhfkwHwYDVR0j\nBBgwFoAUdVumEY2wD6HcLvrH9fMEksSKil0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIA6RyBRuhFw5mM2sx0l84Va7MktauPEEMnniNuWL2l5wAiEA4mrFJSHLBl7E\nNXpzUezAhPmxXxNEd1Kbf4kw5bGyjxY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASx4jjQy5u+N2oyPzPZ2I2zyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDgxOTE0OC02ZTA0LTQ1YjktODY1NC01ODhjOTEzN2NkNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVbehHebMShqINvYlPtesUoliVs+oe6T8a/3CrHuDzNV2B\n5yu+xQDo65cFUgW2Ke20esbLfLpZUd0FRCmDpZqqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdVumEY2wD6HcLvrH9fMEksSK\nil0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVBFPIF3CD1XhMO6dbooPHddpZ5zv2uQdSFte5E/9avcCIQCDM1yyXigV\nqgfTS0X65lJxpzj1aYYuKa8EHIpp6XPBOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAaZUH+qA82tipz0SRY9q39SaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNjMGExMmEtZDgzYi00NzRjLWFlYTMtMzJiNmYyMmIwYjg5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJhOWFhN2E2\nLWExYTItNGM5Ny04OTViLWZkMzE2MmQyYjA4ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGwjfRC/Saq3FpoliGjfx+8jOcOBncCvkVHtjtQLCBJthyOouvs+OtXA\njFh9VgDMuIOCMlC3rFAMh5/WDLrJJimjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIL/XbsI\niiORmNWW3qIQnoRHgIX5MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBBjVS0Z1fY3QeniW+m9IcrLfmwJ62O7chc17ndBESsRwIg\nGUcv50Lc4mRhE4m4KQ9+fZnfOQ1MIjnplXqF/82lSwc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5643", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5643` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAT6dLT1hceiRhLIPqPuMMApKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhODZjODg5LWIyMWYtNGQwMC05MWNiLTc0ZDJkNDhjZGM5MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE1MjAzNjYtZjVm\nNS00MzczLTgzZDQtOGI2NjIyZjRiNjVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGPOPV5wJqlEatUf6dZw8D72lcJcY/Q9TcnR27ugNJ8ZmnPjAK+SdBHDeVcDD\n1to12a3laknaly/v//YUR6FR56OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyDvDL9OQFI8Eu0y0wz3ab8qofSgwHwYDVR0j\nBBgwFoAUmVu5TPpG4/byGzZAvlPGK78kWUgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC6RZU2wPWRG/t9QvDjrgmiRYYr0POZmZAis7GFVDZXmwIhAJaCeO1qoVbX\nbKSk8B12Bu+6qAV93SN9jlckZZ7ZYl7g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf2epLormVKPz+UDfRhaRFi5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTg2Yzg4OS1iMjFmLTRkMDAtOTFjYi03NGQyZDQ4Y2RjOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgU0XG/U7iWIejrz5P0SnY3rdTQN0ETyML9ZDnPOr2FFvW\nrPhkxTsBi2QtQUJUwnjrRvIvm4X2J+Tlmz6G4p8Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmVu5TPpG4/byGzZAvlPGK78k\nWUgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY4WOtHCax5XQc5Gdcnh/0u+9GptOpqxFTS2W6hD0s+8CIFgvi2EoRHd/\nxEObR+6k26IrqI37k8moJLSf7dRz2t9P\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdg4JaPaEL7bh+Uyqlyq741qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE1MjAzNjYtZjVmNS00MzczLTgzZDQtOGI2NjIyZjRiNjVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEwNTgyYjlh\nLTU5ZDUtNDcwZi05MGQ2LWI3Yzk2OGUzZTdkNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP/LFlMrLnPOsBgghqkYUY+cWePi98EA+vJCYfdA0WeqWOwkugQAKCmb\nqJLYQVbC2FGmTECGuTXlLKkfVjI3a8CjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMg7wy/T\nkBSPBLtMtMM92m/KqH0oMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBxxYv0m3TlaZZvH4YJT3tO7TVRvHygIUnXqRNDhus2vwIg\nAsGXgfsUkTh7EVFVFvNCsIwNXg6RZDbtJzQJh7lvjwA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5644", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5644` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAUJ5UeJJWeN3x0TF8MEjSfioMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyZjM2MGU3LTlhYzEtNDIwNC1iYWJlLTMwMjk3ZjM2ZWIyMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU5YmM4ZGYtOWQ0\nMy00M2U1LTk1ZTctNzFhMTc1ZWQxOTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8t8meEt09yFZPImU/wu/caxyCzD5iqyDvbWdk1P8w8Q6H70zWp/9wZP1YmqR\nbpOEJrUxn1CulBJSq7v7p3VPfqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC01lDqafgwUlude8RKSnJYgemrIwHwYDVR0j\nBBgwFoAUUSqL9AL3cVE0upZV42NW/Ee7hkEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBu+Lqe75E3aIhaKK6y0QUp6U922X7B1nZStsFOxulYgAIhAL6Fz7iIni3d\nvAeiNq3th59T98DMlpvJDaSJ3q54ni8n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZUfXnOi33sGmPwaM3fqraoxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmYzNjBlNy05YWMxLTQyMDQtYmFiZS0zMDI5N2YzNmViMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRZX7rYcNK4v4DiJE8UgBVrYMAxMycDjCHR1HLM5Qq+8B6\n9shNRcz+koZt5D0njecFzMtQ2opheqGu4Jp2qPn2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUSqL9AL3cVE0upZV42NW/Ee7\nhkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKExzY7NI4TStaYHr+3kx4PFsgw/oOUMA9NROjJOZW2UCICTVvn2dM1KT\nv9VMoCj0HhIYAdrA+13CKlICayNuWKll\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXFNKQIuNdh6lff2w/VMmXiWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU5YmM4ZGYtOWQ0My00M2U1LTk1ZTctNzFhMTc1ZWQxOTJiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhiNzk4NzAy\nLTA4MmUtNDc2Yi04YWIwLWEzMGMxMjgyNWQ3YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLHIZJPYgbRUalr5Rxjygnoq4EBSvcopzdYGAHP9RoyVD8GGdhRNdfG3\nxeWEVg/bMhSInXLZCQ8ycg6Xi0E6+DCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAtNZQ6m\nn4MFJbnXvESkpyWIHpqyMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAQannUCRUKzI90nlB+K5zNHpUycx7+TyQUHeZFnKNmygIh\nAJ+ei9V0g0X6rnLkLTpTLc0c2pOv6H3Z9TB0wUwblz6X\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5645", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5645` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAZIsQeE7/B1mtVJ2iCqxQRhoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMGQ1NzkzLWIxNmMtNDIwZi1hMWMzLTcwZDEyNzExM2M0MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWI0ZWQyMzAtODky\nZi00Y2I2LWJlNDMtODBjM2FiMjY0ZDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpvYQjmzt+yuKcC3bMC921GzMSU0GGcioBMFXUfAcw8+dEIp60w1EkkVBm94N\nFKcAPkkI9X/hT9g3BsWa1HavpKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUToIoAfewl0Y+9Fsf89RTbHtmD34wHwYDVR0j\nBBgwFoAUr+RBWaAoW73m5Zfzs9tX91aLDRYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA3u+YbsbbEb9OQ2dyb9bBkr3xPPfxBuqv5DWryJfu\n78wCIQDNKA15w/tCs/2ZvnhBH4cmRVAdpucYGtIw5tNGEeAzwA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS71TnQv0bKP+HmvZtDetnNsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjBkNTc5My1iMTZjLTQyMGYtYTFjMy03MGQxMjcxMTNjNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmkE3+couojLJG2Ox3Yvc5Pqhfe9fmB8Gy5pn/V+z4/Zmk\nxqi4Xj8eqCfltx4W6oXzWZ7P2deW+n2G3F3abD1ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr+RBWaAoW73m5Zfzs9tX91aL\nDRYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVi8KOd+vLXWRzEEb3A3IkuMSZiXv8nMH8dJeLyOR92cCID+l96x/Gj7h\n23tJDUSP6/Yx17WGwY4NPRH5r3LpNLNt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAbGqA5XBhuqTF7vRgj2GjCOoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWI0ZWQyMzAtODkyZi00Y2I2LWJlNDMtODBjM2FiMjY0ZDAwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU0YzE3Y2U3\nLTM1ZDItNDg4Yy05Yzg2LTg5MjM2Mjc0ZWFiYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBMIytnSYDWXvN7DWTZKPp5vmMPgRovHkzX/43bVesGYDTh60pCF45ln\nuoHHy9feL0MUgzzhs0MXVMdAlaVlpzujcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE6CKAH3\nsJdGPvRbH/PUU2x7Zg9+MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiB+bDtaI6D8JqJw989Mt1bjqf7BlZgq0w53i7buewVgigIg\nTJQiLXU2NmDftUI87w+hO9DXzCaBSMan4UpYO1h5bTA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5646", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5646` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAUAt0Jg6bpXRyEO0LDJ0ChsdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwOTczYmFmLTE4ZjQtNGFlZi1iYmQxLWY2N2JjMWMyYWVhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM2YjdiMDAtNzVj\nZi00MDFhLTk5MmYtZjRlMmMxM2E1Njk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElGvvYeXd7KQyLZGqqBwNhKe2T/bOhVIrWJXOq09INh40T6b0cpgbP+RMkeB3\n8UtDmJzx0M+W1W5d0BhkeXk7c6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh6Jh7kb026TjetJk+v2oD4LvimMwHwYDVR0j\nBBgwFoAURIpCN3M5m/ofk0Tlx75Vmp/vFM4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAm6tDlx/xsqSOFHll4d9Cp6LbvwWQnjkcMT4ODd4n\nP5oCIQCUq32g0EhKCk6XBfomObzyHZHBwEgrc1Pyh0GBHm8dUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW4Rd3qVfryHHodw4BYrdIl2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDk3M2JhZi0xOGY0LTRhZWYtYmJkMS1mNjdiYzFjMmFlYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSUPVSHtMhjsg0G9VQyOZtmOF5KAb6CAgCPR1oqeEP5WaO\nDjTEczpvdAep2TTdMm0dqCgF8unYbjK0IqX962rno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURIpCN3M5m/ofk0Tlx75Vmp/v\nFM4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ+X74v0jWOGd48p0TunW9tPOBmB5KQKOuMeoQKurfMXAiEAmHB6+y7X\nirSLfHcG4V92O5RJp/ENzURYoomvhF+vTOs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAeczoaYYS63C4WA0oj0/fLi+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM2YjdiMDAtNzVjZi00MDFhLTk5MmYtZjRlMmMxM2E1Njk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA4MjQxZDE0\nLThlMGUtNDdlMy1hMzcyLWFkMjQzZjA3Y2RkYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIQCxjfTIXUHq8p5E1dpe/AcSupJ+phMRmVtE1e9+bENEOdu/oqiUadZ\n4UXCGd0Bov7HY9G8FFZKLutP01Mntt6jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIeiYe5G\n9Nuk43rSZPr9qA+C74pjMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAPayyA/fwfn6OPQr5949aTIhT9CFVvN1mqc9jjxVpCygIg\nWi5tHFZaXZMQK7ZjuMrxiyO7Jaq1kpuCGLaaZG0j7ok=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5647", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5647` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAUr4JXSrnIolSKsMOr0P3FBaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwNTg5MDEzLTRhMjgtNDgxOC05YWRiLWQ2OGYyZjhiNzVjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMzYmQwYTMtMmVi\nZi00NzZkLWE1NmYtZmNkNzVjMGE4MDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzEFtH1p3O9+FsgN4FkuLjyB/wQkkESLlFkRohlC5dUlGCF36gP6YIlIDcDwH\nPT5HeOoVXOdKfL83fi5Bf92w+aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQk5CJstb2O+wVRF56VxOM0KTR10wHwYDVR0j\nBBgwFoAUsvVy/74jIi1pCRb/QG877s6PnUQwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAkKrNfKfyIZNnuG4oOippFh1zWW8zhU5Ic/ciUU4yB84CIAdE\nKjnXQEkn1VyllaRzDmzSxSI1b0wadCMh4f8s7uVn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWIyctgAGSuFQi2EM77Bx+H+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDU4OTAxMy00YTI4LTQ4MTgtOWFkYi1kNjhmMmY4Yjc1YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVYedZgl+4C7KDdcjVj05y1UJN07e9ltPzGfbpgn3The43\n1KasnT+j1Vq4vs8L4257jeBY8y557ZUclIYXNOVWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsvVy/74jIi1pCRb/QG877s6P\nnUQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVQ3qcv07sMbr92D6HxONOK429ADIYu0ow5s4hwxZMlUCIAW8a2ApDMg0\njwacyMmvVWSftdj3jdEp/57nOGxYOcEI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAemFueKPJ2E/MmW+M4H5Y5RwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMzYmQwYTMtMmViZi00NzZkLWE1NmYtZmNkNzVjMGE4MDU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIyZTBlZDc4\nLTViNmUtNDRmYS1iYjdlLTZhNzhkNDI0OGE3YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL8ugBEhEoEJcq4NF9jHOO1V4XUFNXbWS+xpJ9kBaDZxyl8XWNkJvTPi\nDEO1anAetnUsRz3vq4EGKKNpVK9yb/2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEJOQibL\nW9jvsFUReelcTjNCk0ddMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAgWlgX/4ARIY8Gp08zHaKff3r9HMUK1au/kR3R17N4GgC\nIQCi9KWIZK52RjqPNzBoFNMtQoUkCQ04M5Rrtw3Xa6/DsQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5648", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5648` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQF/fcEJlyPURideo5mR2IiSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5NzA0MjEwLWQxMWMtNGMwZi04YWUzLWMxNzQxODUwYTNjOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU4ZTJlNGQtYmY5\nOS00NTgwLTkzNDgtNTJjMGQ1MGI0NjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESNbYomYm/7k2uac3AecNMssZ+/wDJGbp6wlE7OjxKjybyJHnueC5uZRKGuG8\nuUwyKbChGizsUXlsfgzSx7nh8KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyAKvfK93rqSH/UA7P7K5kMbr5KswHwYDVR0j\nBBgwFoAU5dPorY1J8r38ouSJA2tAKCH88fkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3WX6/JTuv16rTKbPZJ9UHeQyKtgGA6bR\n24fCwiBoE8MCIFy3cxb149Qbxw+C+xUoXcTGNDfdlU/VzxPixG07/HnE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdUs64Pwgv3NXGxXetkKNWpnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTcwNDIxMC1kMTFjLTRjMGYtOGFlMy1jMTc0MTg1MGEzYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzSnGyukR6P5//q9ikXLfwYO2yKPltJpW39+371AMCJuw6\nkD9CquZ8UYsHChTNHGI+sA8DUbpVU+ckTc+l+zy7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5dPorY1J8r38ouSJA2tAKCH8\n8fkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJGHIBa9qwXyiR6OWXuOOKhfZ6k/ovywbgNmSCZWIABAAiBIQB6C48dd\nliX+K25xkY2KBCI3qEl0D582OyURZZod5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWHqC/9+98+3hcPnNQRkN0wyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU4ZTJlNGQtYmY5OS00NTgwLTkzNDgtNTJjMGQ1MGI0NjMyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBmODQ2MzY2\nLTc2ZTYtNGJmZS1hN2FmLTFkNDdmN2E4M2IxOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPcBzcXh/i6Yb/6uyNU1UmNY57cQcyiIMUF+YMfbOre43RqRHMLHsysI\nWYptvgLYSdBGVtzU/BXFAuTcCknYJnmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMgCr3yv\nd66kh/1AOz+yuZDG6+SrMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEA2TIkRIjBuNVVvF8cXFHGKhyE9c4moCqOXYuVv/sb7OgC\nIA+tthT/fEtXVBwm7Fl8wnXMSryejLMuhvHp2UQI/Lv+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5649", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5649` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAS/EJjNamIQucnUDmQKM+30JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlNGFlMDE1LTYzYWYtNDM1NC05NjRjLTI4NTc3MmU3ZDY4MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2VkMTI2NGItMjEw\nYS00OTI5LTg1ZGYtZGRmZDQ2MWJlYjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIEP+4XZ9mcIzxytbVtG9kbixHx47qHe9w1/W5gjLl5JKiecnduXa4Mydsmfc\n6On/EWi0AeCK8h3f0jABPWzSi6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7D1Rbr26Ez5fYyS4biRF6ZSZVncwHwYDVR0j\nBBgwFoAUyqeqxIOyuQku9AGBteiFflivHiEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAjoOgpWRymnOUqBCYjkABLAM3SQk/LmPe\nukTF7xSK7foCIF7SbJswiDdYrnfVUBWLWWi4gYldjjHXRti9XpV/FKpe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYIGgL+EiaH8/kFmxxKiuEClMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTRhZTAxNS02M2FmLTQzNTQtOTY0Yy0yODU3NzJlN2Q2ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAIsxkzWhFnrGJkTevgKZy49TAYpsFHEHm63Z3OuBwUTsS\nMPj7sZuCz9lD4Bbl7aSAVi69jPlh42bP8Vq2fPxPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyqeqxIOyuQku9AGBteiFfliv\nHiEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHBUK63V6BChDiY66rmsh/DqjWa1FdJ5LcbN6NLj9/lgCIB8LJ03Fki/O\n+FcyOdKqGsVooqVph7qO7rgz0PubBX3o\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAegFjov1ke/rGCYaY/S01tDCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2VkMTI2NGItMjEwYS00OTI5LTg1ZGYtZGRmZDQ2MWJlYjIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ1MmM2OTli\nLTVmOTYtNDZiOS1hMDJiLWEyNjFjZjM2Y2E2MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMLFF8HY0RMX7ICoUDegxFEPwiRGBIe3mQPUd108ct7N45+dRYdv/Xxz\nbfhu71iyhx3NPZlocz/rnuoxbuIBUc2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOw9UW69\nuhM+X2MkuG4kRemUmVZ3MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAgirlYoEq2IXfCdNFMgXtbmgYYo1i9iejsS0UD4KCkcMC\nIDzvMGCrBhXkI0J8gHIUS7nC/j7c0e2NZyF6iqB+05Zu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5650", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5650` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAXBa3OlHV18teNQ8zP4YKVZ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiYWNlYmFhLWJmMjMtNDNiMC1iYTdjLTM0NTYwNmUxOWU1NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDlkNmY3OWItNTU3\nNC00Y2YwLTkxNzktZDYyNTRkNmE1NzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPWC6uMEHuk5yi9Oe9AdvL4FuaZJVgQd2TUhHmM5ENNCBVeTpDU14pF8Oq0rT\nYfGkCWuy5Y4dc627ZWVKOFlFQqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0FkmkRKX/sG/uiyjsptO1HdTfc4wHwYDVR0j\nBBgwFoAU/bf1nzwxX3VMWfRYgHL68sYEiFIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGGvBx/Bl1K8LuDFRpS1tHYKi5Nb\ntV7v2MxiEHfLjffJAiEAxHQZF0xo/9kjYUojsabZfOA8CBX8eZgtdeq2uYcRsaA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWxQY6NULH16Gq6Vp/xLTiU6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmFjZWJhYS1iZjIzLTQzYjAtYmE3Yy0zNDU2MDZlMTllNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQL3cMgTIVNCGdURrwxlPjCSVMbJBUQDXjkCY3jjaosfGQp\n0fnRj99Oml+0MZWVdP4k7hkWWY9Q6NxNWn8ueap5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/bf1nzwxX3VMWfRYgHL68sYE\niFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPT858bQ2SnCC4SIPLVG9dSf95np/dKPwfo9KgCPO6reAiEA2hMpCT5i\ncq8cMCyUOscyp8HJxwG0ZXe5XjzhJ5c3qLA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZZRIgCwytuzDwSY9DOMp9DwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDlkNmY3OWItNTU3NC00Y2YwLTkxNzktZDYyNTRkNmE1NzZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUwNWQzMTg3\nLTVkMDctNDczOS1iZTQzLTJlZTcwNDY2YzZiODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEHt8R8qjbTla2sAV0QxTHul4tHg+Xs+I3IlYYr6zs19hk6+hvm+1NE5\nKSyVOPg63Ss4tah5/zNIx+aV/QqfYEyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNBZJpES\nl/7Bv7oso7KbTtR3U33OMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiB2nOl8CDNNTEzOT+cRIivM8/f5/eHz4BPtaAk2cTvsNgIh\nAOLb3Vi9XzN+8BjkkzqecLiEA7oqddVZyWoTxeCCyajv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5651", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5651` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAUSG+J7GSwuEMGAkHvw3/PvLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NmEyZmI4LWY3M2UtNDU3OS05NGQ3LWM1MzE5YmEwZDIyZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJmZTQ3MTktZDU4\nMy00ODg5LWJjMTMtM2U2OTY3MTEyOTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf+lfsozeRaXsbTLkx48Osx5fiCVEc+gh8e1y3W9HSVn9lRufk4k0YGyfI/QT\nccZm22ZPtclJHGqoYawi6vQFgqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/bsLA92kHspFTn+fCqRzS4V72wcwHwYDVR0j\nBBgwFoAUKqytW80tlLjJiNOH1eSIi7l60JYwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgJ3rJd9zq\nrSoyECbtifRajShUb8jakgWjdGXIZ5jGNcICIQDL3f9TF3Jl7/L7UnqZRLQ/rez7\n13qp6kI41gTrX/tFmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZRvOmW5q2TciSuwQYBlfNafMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDZhMmZiOC1mNzNlLTQ1NzktOTRkNy1jNTMxOWJhMGQyMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgXpb1WPX1qaSAI3/DGJoUAQrLJxDw0mV5wnP5P/Od6mTX\nY8zle5LO973gAluPBTNv2pJE1lRXeJuhTmP8tpb0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKqytW80tlLjJiNOH1eSIi7l6\n0JYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL1KZgya9ZhUVCVQSXdz1XkHEH5kgjUcuxUtRaKybfqhAiAukKiikAeQ\nABLQQJOsMIvv8oUa+5By91VvLD8+J0ubRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATy5SDBflnNvnxb6IUxPqzSsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJmZTQ3MTktZDU4My00ODg5LWJjMTMtM2U2OTY3MTEyOTk2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhmZTE1MzJi\nLWZkYTctNGJlNy05MzhmLWIzZTY4ODVmNzkyNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM+fzInOiOEwEZJ86YLZcjT9bSBvtjq2BJdFszUYq8Zbb6ll1LKaGiZj\nYHuMGBkIOccPj87av/OlzAPgrVZ7o6qjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP27CwPd\npB7KRU5/nwqkc0uFe9sHMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAkqC4DkTQzobgO6BZ/jVJEl5D1k1sAzIR7L6YpxwjIdgC\nIQDtkna538SiVH2zKU7Ba8sgCY9oOU5Z/eH2RKE6q90oHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5652", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5652` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAaZ94xFdFJM1TH/sVkrag8LBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmMWRmN2Y0LTI0OTMtNDcwNC1hZTA5LTJjOTc1ZGFmZWM1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQwYmM1YWMtY2E2\nZi00MmFkLTg4MmEtN2M1MzU2YzA3ZWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzo4oqphgBez6KsUQt7Uu8H3/Kd3Zxa0PnwLm8wJbYr+6YRX3oYDlRDYq+1I6\n9zKxAf0z3EUT3IupXUbccsuS56OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb4sq40xVSd7eSofIrlGAXLiZVyUwHwYDVR0j\nBBgwFoAUtw0/mVtpTgkH5kzqPTynu9yFh8wwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAL9kSESc\nAKz/qtTIQtxoCA4D+dy0ZbzfJ0rvYq2XFuRgAiBs3cYCskVRyYtEemHm+4o/5DmA\n6Ye+INnjhkZK4ei3pw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXI7pdGeDDlrZrlXg+MQzWHXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjFkZjdmNC0yNDkzLTQ3MDQtYWUwOS0yYzk3NWRhZmVjNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+lhlSBBEWnNbG+Y3oFBRxGL4327uQYFAbSMbf2fi2CATK\nPayfYcVe1Xu3P9xPYldRjQfThCYtdKDB2Fh15mVFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtw0/mVtpTgkH5kzqPTynu9yF\nh8wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgafPOwVQD7YJKKoTJAK5n+HUdQDpfRDfWLjL7BKxosikCIB1ymteH6XZc\n1GjXPlsBe93hS/IMzYZnJeTuKHWqYA1U\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdKu3cOF/YRTDRmh12QEoLFFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQwYmM1YWMtY2E2Zi00MmFkLTg4MmEtN2M1MzU2YzA3ZWIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE2YjVmNGQ4\nLWNmOTAtNDllNS05OGMzLTBkNjcxNzIxNjc2ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ4roJYvgTRvgNgJKaStluGWvNxQ2n88O3UIsThN01did09agDe57rkl\nL9ZVNP6/GiS/r1nrkJlS3pOolQB+Ay+jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG+LKuNM\nVUne3kqHyK5RgFy4mVclMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAg3eBhmYzxbzNnJP7EIg08nF/xKdAT7uWUeLBukIBeMQC\nIGh/GMMhdQhmw2QWLmqvFkCepveUKtbUsPgCC9XJGLTi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5653", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5653` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAa3u4Y1eytewTrROtrugC4iZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxYjE2YzdhLThmNDctNDY3MC1hMzUxLTQxOWEwNzNlZjVkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhmODc3ZGYtNDBi\nYi00ZmY5LWEyZjMtODU0NTQ5ZmYzODA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWMRwJBYBtT8iP+Mcz8vYuQPf9tLq28NG9eMoOINL20IHrICqrCOykobP9V3O\neFXjsElh4cYZ9V5ZcXIKcULdCaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFArCtAifFZ8LtqyREpuEiI59hbAwHwYDVR0j\nBBgwFoAUDV4xBZxnp4PSPgRFM8asqzI6+hAwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDq9HSj\nDT6LmT30+cNnX6JrvWxDbYqbYRPNo4c67IOkogIgWN+GuBRxR2hmOpBJs35YelMX\n0sr4JQ1lczsnqJdlQqU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXX6ehoo7lNrW/SbSqIK4BjuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWIxNmM3YS04ZjQ3LTQ2NzAtYTM1MS00MTlhMDczZWY1ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8YlUa5amlza5TVljWwzqIDzOcEDfQ7ZvaHsh2hh0Kumz8\n07Ots7zCE0bvUe+Mj2sJfprLkn0xeboxj1bO4ZI7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDV4xBZxnp4PSPgRFM8asqzI6\n+hAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBHnPnHROkQ6xrw8fDB82FmKs1xrphY+QJkeufyw6uTACIDL1uFtUXajx\nmx9OFHsPytzgyJe3pmijrgRXojJM9Zrk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAcXgPJsBR0lZeVAwWpv8I4dqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhmODc3ZGYtNDBiYi00ZmY5LWEyZjMtODU0NTQ5ZmYzODA4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ0NWU0MzE1\nLTZkMWUtNGFkYy1iYTlmLTg1YTAxMTk3MzkyNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCecv3qNvHU5n5elBUrLTssdKQ8OOV1dwdI4xEYc6vk8pmvU76COU3Eg\nYvpjb9J+7dnoAPpmsCqh0SBQfBXICfyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBQKwrQI\nnxWfC7askRKbhIiOfYWwMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA8O6HX97dRC/4ZbVAdQ1rUKKBClEnw4GGfzGzu/7F7JAC\nIQCemUM0+b0jOw39gV/fChlTvZDT9KGYmC0CerWEazGDSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5654", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5654` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISASj9473iV6YLPSodybcaF3RxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1NWI1ZDlhLWEyNzYtNGU3OC05MzdkLWMxZWEyNzRkYzA0ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFkZjRlZjQtYTVk\nNS00MDk2LThkMTctMjk1M2U5ZDZlYzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4eO6swAKNkddmESgiQh43qzafKySKuvLEu4WavB5/pGjbZMDtu2UtVKEYkpR\ndek9LA8LoMnII71gXzcBukspZKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwSCCx80IWVIO7vtXhr0G5DSWXxYwHwYDVR0j\nBBgwFoAUD1bRVfe+dNrGDqjbXyjaju9CvQAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCICHMt9huoLKuY6ZYPXUHrN2T+p02/JEKXZGxm+iH8CiaAiB4dtplAgVn\n7bGZ3hKI4LVEuSsESSxBHTOgPSECtkwRJA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWlZgo+n0bGdsNxFMNy7Tn2nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTViNWQ5YS1hMjc2LTRlNzgtOTM3ZC1jMWVhMjc0ZGMwNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASF1ZWYLP1BchOLqHIdV6iBXxyVfL2c1Crwr2ex0RvvY8Ne\n/bfFc6viL29TXU3I4LWxat9UQUueRpy+VFlPt0CKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD1bRVfe+dNrGDqjbXyjaju9C\nvQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKRXdSciWZtFaDdBaRt2DhV8NRCYFGK5tkcGizhjSuE5AiBgqzuZhV14\nQnnyBAwqUOiDszCPziyoZK6cCctG9S0z4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAVEVM3WLkfY/SMfd9nTLpWG9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFkZjRlZjQtYTVkNS00MDk2LThkMTctMjk1M2U5ZDZlYzc2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQzYTc0ZTRl\nLTljZWQtNDUwMC05MjkxLTRkNjMyNDQ5ODMwYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBdrWE/QK7RcgltAvr/ExbppdFiUMWY+5c2YFUpDB61hX6/ZuuBYy+LO\n63MJxUmBVDn/o1GrJLdxEDDSXH1/aEWjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMEggsfN\nCFlSDu77V4a9BuQ0ll8WMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAbGQwPV/hyqt/JNqxJI0Rfteo70E1PfbrCPFGFlHrFEQIg\nRRvN6fYjft5/aq8aIz6k17Z+feKIH7As9vHO9lYTxSY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5655", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5655` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISATs8+miobhlWDj7fKy9JaAy/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViNDYzYzA2LWZjMzMtNDYwNS05NDIxLTU5MGQ5NmUzOGQ3MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGIwMDNjYTctYjdj\nZS00Y2FkLWE4ZWUtNTBlNGQwMTcyNGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErSpq2j7FNtB2TVgdQp/QCVvKgLRZt1Yunf3kAPw/rWenDeQziEdwUkDxmXKa\n2wlV4JWDndPPvNZiP9XC7+Y5i6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Hts/q1ZQXpzeL3pDVPhTl/j2eMwHwYDVR0j\nBBgwFoAUFpDT5eFg+WimlUCBkFNE+33xZp8wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIDS0v3LPD7SCzDv4EPKXedv1RKzj66b+e//IA1g4t1+hAiBpUKuSWcT7\n9U+Bc+J+eN8G4ofgXFnMl1oKb4ttO2U3kQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAemTB1mpmLFR59UjXceXdU6YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjQ2M2MwNi1mYzMzLTQ2MDUtOTQyMS01OTBkOTZlMzhkNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2/XZjsJ6kMRBWJfKS4i5dwT5ITHAnC79iB2Fuj5YRMS+w\nYmZ1XA34oSJjL/sqL/hF3Az2mWTa01UMwwFNOXPXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFpDT5eFg+WimlUCBkFNE+33x\nZp8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH+kvHkDBTt0Qrkmwr9Ryl22uvQcjl2DKoBPgNfJwPNYCIQDv/4fcogey\n9cwikE8h9+p0g+47rzURS7qFq3tk7bORXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZf92rgNNOMLeP1hC9vZ2pz4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGIwMDNjYTctYjdjZS00Y2FkLWE4ZWUtNTBlNGQwMTcyNGUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNiNTMwYWFj\nLTU0MTMtNGFkOS1iODc4LTU0MDliNjJkMGJiMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHRrQyL6b33rB+v0sMntcOSdHM/NapPrMoGIwdWJH3DifccDybdYbZQO\nxHMTGCENif8jykQhqn62QwK6i4H+DZOjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOh7bP6t\nWUF6c3i96Q1T4U5f49njMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAthKjp7ZYKkkm088M5LjJJFcA9djq0Q+q+myJtl8h3xQIg\nXsG4RMWvjCFejFh5LxJ9NqsVZlxxiSCDZ6NeYPHLV+I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5656", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5656` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISARYb2hsv4cCwWamLvhK9HgtwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMGFkOWZiLTZhYzEtNDg0Yy05ZDQ3LTljMzBkYjRmYjY2OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc3YjgyYTctNmVi\nNi00MTc3LTgwZjEtYmYxZDMwOWUzM2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmBrlvufzgtNhYsD14c8JIer1u+TS93RNAMkTDxi7qPEfHphNS4fPrsI75gy6\nQ46pp0JKsNocoN7lxUgZpyAPZKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgu71uFUs/AiHMusfHLcC1iriSZswHwYDVR0j\nBBgwFoAU+ZUnLGkhWnRiOCur6k5tkts8MOUwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIF+ZVa1abD49jJGU9BA1BlaCw6ZhxApd1Xut5+Ly/bwAAiA7P8YW7BeI3V8H9T+x\nsarHyX+t044MoStmES3r9XR00w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdT3/AyvAOBSk1SZrOjzdLUwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzBhZDlmYi02YWMxLTQ4NGMtOWQ0Ny05YzMwZGI0ZmI2NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdRAEjlR0xaJhAoBVs7n29eYnr1g0Y3Hagaev41WCxZAPI\nSxWsQYWsfk40Qwgxgz474iSw+eHqa+wt9upgOkyVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+ZUnLGkhWnRiOCur6k5tkts8\nMOUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgApYr2AQhh1/O9H/nMe1m28LeOeImQVTs0KHqDAxxwS4CIB0OBk2MKReq\nN7MrzpdTkhpg/QWpx2GbAA9WkJXajX1v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAd8ST9PEcoDznosZl6+TgBnwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc3YjgyYTctNmViNi00MTc3LTgwZjEtYmYxZDMwOWUzM2JlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlkYTQ5Mjgy\nLTI5YjUtNDIzNS1iOWRlLWZjYTZmY2ViYTJhMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABN+S78boU1gOS/b7AMDbjjfSl9d+9GJ+0u37vojeGrTKnM3tp9pa98KW\n7BfL+xL4+itRmypbPokVFTx5Ylei4M2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFILu9bhV\nLPwIhzLrHxy3AtYq4kmbMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA9LImdqbFF7+W6KoscBzChEuTLZrOaTnfPrmiW0k64hsC\nIQC96975CTfz61ahAdGtZaUlfuSawTp6/tvt0lOoNtKVBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5657", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5657` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISATBsAOpsuhzeHD1fcQpiUKFLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxOGQyYTA1LWZiMmEtNGQyYS05NDEyLTFlODU1ODAzMWJkYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM1NWM4MDQtZGM1\nYi00NjVkLTk3Y2MtNGFjNDcxZmE4MWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvOuK6698RtcyxvuQcvG9Akj46lRMEe2ZMJuEXlSqGxLB22efVnCXakV/z8Ft\nXURni1h6O7YeSWUD1OmFErPReKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkvboL3OqTqZ3v7yjCJKA6ZIAKJswHwYDVR0j\nBBgwFoAU5L4wtM8afgXRko+oVr5C2U6soKwwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCKki/ozKnn8l4WnCmJZhCiAIfQHPEBVS/JRXf/OC96vAIh\nAICbPSslt5SVUzpBPZUd+QKvMrgRuD2LLq0OvnjFtN2u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVvNQLpGjAfO/AvOHm1a4HN3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMThkMmEwNS1mYjJhLTRkMmEtOTQxMi0xZTg1NTgwMzFiZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFn5YBZkCkjgHJphCoRyo+YgH3L/Q1WL79KJf6zPVxA3PT\nd0U2rOZolu/FHfCNnBmlQOH5qQ0nSJDCt2+esMFuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5L4wtM8afgXRko+oVr5C2U6s\noKwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcWl5/LoKA/S+v0cCpcicy0y7JxTSC7vKQvZqDdQKG7MCIQCyHT18wnpq\nqyV6g+KjiuFOePx59DyfToeEUBuChV4K1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAabCE3myAitdlybl+e5F60PoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM1NWM4MDQtZGM1Yi00NjVkLTk3Y2MtNGFjNDcxZmE4MWRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEwYWU3ZDkz\nLTRlMTgtNGY0Zi1iMjhkLWI1Y2M2NzhmMjI3OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAKJbEdcZ7INGZPrVOsoD2ECDOY0yyS9YzS5v11bj1XDWAL2LKNgmL34\nhNvGG4SjVEUIbFGG+GV6yCI8sDG/JeSjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJL26C9z\nqk6md7+8owiSgOmSACibMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBQhWeGznmB6JIf7gHXzT6w3dSSIAxvtytgC/ZULkDvjwIh\nAPoa48bNUB46HeVdHtEush3yjO2ijJIfGuBbGxyTyhIT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5658", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5658` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAesz0TkSAUeEq39zfUwNFO0BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiOTIzZGQwLTMzNTAtNGNkMi1hZTRiLTgzZmEyOWE1NTk2ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ2ZGJjZjktY2Fi\nOS00ZDYyLTkyNDYtNmZlMTEzMDg2MjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOi8BxKELx4Pt7CiWwxX05nZLIU145uRQk3WwoO7+5UCVizQ+aIchwP8Rh6gN\ns1YNG5nru4gxss/tEsggQYdA+qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkE/4iDogHCrZ5ZY3D94cTmcMl/IwHwYDVR0j\nBBgwFoAUJ2b9ExwN/d2m21Jdt5lT5aUGVrAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIGRSagVN7QJXI0tazGz9vjkdR7TW01ifgAP7StiCZwnTAiBD\nxDlh1mFcSTTus/AD/Cc9iyPGONt0UgIcdEpRT/eavg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYmjPjgiNWZSY32FTznGuw1YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjkyM2RkMC0zMzUwLTRjZDItYWU0Yi04M2ZhMjlhNTU5NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6MHECCGKMKtVhS+A1UZtxSjokFGa40bgJl4imtBWwny3Z\nnIH7t+1/ypdQcguzDj5Nc7PqT7q8bxQgt6U39yoxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ2b9ExwN/d2m21Jdt5lT5aUG\nVrAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOyk9iSQMuy2j2CsX6FF8yXWZdiYEDQj15eSOT+uZzvqAiEA5xV4K2BI\n3mGBz+KbDDUTk/4W2L9znoxyjLjO8O81sPM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZqSZHLGzibGFTF0XVvIFK+2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ2ZGJjZjktY2FiOS00ZDYyLTkyNDYtNmZlMTEzMDg2MjMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGVmZGM5MGEy\nLWE3MzQtNDMzMC1hMzdhLWY0MzYzOTZlNjVhNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOrrJOq20FupbmGhqODxeefsb0IhD6mkUB7aeYpW5V1dmPIzCNGnZ5hz\n2hiRqDBfynIiN7/y1FKOkt7c5C8KfwWjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJBP+Ig6\nIBwq2eWWNw/eHE5nDJfyMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAhfbgPFBrQ3vn0+d9OLhqTfI0zEBh9wS0I+VjhQWzj40C\nIQDIDG9OToxt6X12VGMJyxaomcrZEQOmbKmedk77UAdz1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5659", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5659` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISASqMzzN6N/3rmTSFKTPK93GRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YzM5MGY3LTQyOWMtNGRjMi1iODJkLTMwNDdjNTUwMDE2MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RkMTljMTYtNzgy\nYi00ZWU0LWI2MjItY2VkMDRkNjFmOGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM8zpkm00pE++oDhNjpHhBmOlFQWhbabVpJpmrVWNt9HE7vDadnfxZOcJlXuS\nu2NOxcFsqpABzItKOoAAvV4ik6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxSREttJlo67Cu1lh7LtOEuxAfqQwHwYDVR0j\nBBgwFoAUBXfcbR36NKjG2hhRphiTaYgyjYowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGhy3JRUCwvf\nFyLWkF1brQ6pd2Mzwbx5TiUpNwL5gWESAiBrGezzrfu/6FNqOz+PIM1+o4xY+Y7w\nx46NMwWr8O2HAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaDQkM43s5SLF7Ol0SBcVTJNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWMzOTBmNy00MjljLTRkYzItYjgyZC0zMDQ3YzU1MDAxNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiwch2SGrupPTDqimQqRg0NQ7ylKWwpg+Izspa/vB0wKtq\nrxz1GtEJy9iVFR9RD5IR4useCzo+lqWGnTyqA7DEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBXfcbR36NKjG2hhRphiTaYgy\njYowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHVv2CjFbq5GLhZgv7TX/zG73Mmhs919tK+sCIyxGzZ0CIQCuKsURQa0i\ntsbFbvjOWywkYkAazq5PJ2ToIYV2SM9Qaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAcpu0Desij25Ihsw7jbUm1IRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RkMTljMTYtNzgyYi00ZWU0LWI2MjItY2VkMDRkNjFmOGU0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE2MzFiNGRm\nLWZmOTgtNGM0Yi05YjNkLTIyZDE5OGY5YzQ0ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAE/oEMGJFzH91DM6564oHnbXNGvEE+NMIZhZVfdiernSzeqTG7QtrFc\n9GcXKx7BOjHSnFR8zRnff6sBg1Y0bz+jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMUkRLbS\nZaOuwrtZYey7ThLsQH6kMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBm9Wn1242uUuJAohHVJ3eMBd53hOmK2vVEPYT7GX1TlwIg\nY3GCBh4yT5Gcl+KDjTRiffArMvxN2lAi5TKWUsyW3TI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5660", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5660` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQKY9bNwcuQVmBGN3YYP7CRkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwY2RjYmUyLTE0MzktNGEzZi1iM2I4LTBlOWI0MzQxNGVhMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVlMTAwOGQtZDcx\nZi00MDY1LThjMTktZGEzMWQ3YzAwOWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPFgZQKhbkp4i6ZIhChmeaPVK8rD0cD1wioMVlk4UGCaDqmZogZjP7idUK7XG\nLH7QX6aU5WNOXabnHzDogEivDKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5VfjVyc/Y2p1k0rRNR3axXyIp7owHwYDVR0j\nBBgwFoAUFWSbTNQ4loo0DzuM2ErVyvMTKLowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANIOnRsuvZt9r+6CXHpeCAWR2RpN5XGKx8TFrjEd/g9sAiBOy2dzDAAX\nCB/b2Co1GMvd8T21tME3YdZgzw5roT5LKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZkHmt1SajiwJ47RgFyvFtiqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGNkY2JlMi0xNDM5LTRhM2YtYjNiOC0wZTliNDM0MTRlYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQB6RqdcRZydCrPatFgXUsJgWWOhhfDrpM+yKtW5EpNhFAj\nMBvkto1m5hfZGgXw4rwRrSeYh5hjWBruToodb5nfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFWSbTNQ4loo0DzuM2ErVyvMT\nKLowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKmMOg96SVr2YNOMC4Uu8LBddHSodvuYwAl/6dztca7uAiEAhL4xtOho\nglYZCKvqrBSUJyugl6LmHUYuEEXamWI/mT8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXxDaYgv4eDX7MnOfMS6TKo/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVlMTAwOGQtZDcxZi00MDY1LThjMTktZGEzMWQ3YzAwOWQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY1OTRmZjVh\nLTU4ZTktNDU3MS05YjZhLTRhZWE5YzY0ZGYzNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGpOlVABCfZswVKGfLLzfjVMln7n3byGQtzHlQxZ1XCKzIye4Z8csJCG\ni4mbMiLNJgK9dnAInm/4VQNO5u40UIejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOVX41cn\nP2NqdZNK0TUd2sV8iKe6MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiB1bEHTY70v2KwZwOZC2fUw2160ZcY2uBATSV5UTH0mAwIh\nAPZQarspTCiRolideh9cbzbc7f6D6SdWUIld9bfJ5Ag8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5661", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5661` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAfXVhShYwIqjL61bzOUEK5t7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3ZmZiNzBkLWRiYTktNDM1YS05MzhiLWMzZDJhYzZhNDA1NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDYxYjA0MzMtNDA3\nOS00MzVmLTkxMzktODdiMGIxYmM4YWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKLEtV7ckC6NK18dhb9w/XdDCqb9yYnt8kEw8/p6vDjpnlyWAIHWyMMFuPwb3\n4nKdTJ2aTJwzTbre4zNwBCdPnaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEZQbSi6DF0eS6nOsxqEri1KkHyowHwYDVR0j\nBBgwFoAUAYvZnN0ayXouKFcrvZc+3OmkXI0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJ+8lJEtWtud/H3k0U9UJ/xd+TGAWYJrF+uNSzdJx737AiEAkwqRTAz9\n2esGjokV7Tk4WG0nUDHffiTYtSSByPL3alU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcHecIsAfdeyfkaMeGEk7LATMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2ZmYjcwZC1kYmE5LTQzNWEtOTM4Yi1jM2QyYWM2YTQwNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYpkllb1hd07u6GVbNivHJNYA1ORCrMwH+ObK1zRWOIa9A\nyYYVYTskPIS+g19g6xdae2KlM+fUsmI8KkDkz8H6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAYvZnN0ayXouKFcrvZc+3Omk\nXI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHzccr/468dZVMe1t7Fw+LYRfZxI1IKiOVa7NVYEWqkcCIQDFQexsC3Ni\nnGjsRUyIW6do9jITFkTuFBxXQCRJyfCtRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAbKzvHg6QeGfUNMLV343bJuOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDYxYjA0MzMtNDA3OS00MzVmLTkxMzktODdiMGIxYmM4YWU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ2OTljZjc3\nLWY3ZTYtNDhlYi05MWQ2LTdmNzMyYWVmZjM3MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB7oD6K5f//9H85vTpbZmTsV0MO0qd4OxZEiBpTEvFrV9N46EodZmSH9\neBovzgs9DTJWBiQOWQhADu1NUqRTFqejcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBGUG0ou\ngxdHkupzrMahK4tSpB8qMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBo0PprYJZxNC+FARCzXb6Tt/zAh2okE5fDjigeLpPB6gIg\ncAbCpUVWePRPHJGPL9fZqzJ2NouGZOBU6Tmr3MTvm90=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5662", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5662` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISATK1ImloeZzD3ETgQPtjeuwyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViY2VlYjA1LTkxNDctNGRlOS04NGNhLWZkYTEyMTVhYWM1MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFhZDU1Y2ItOTYz\nMi00MGI3LTg1NzItMzI1ZGI2ZDQ3MmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV4Dty1Yu+zd9ME3nVPyFNIHABsGY2TnEPcbCn819IWCR5mew+48/nB8rfgCr\n326v2sNgyTV26NcVJc7OLUIthaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFiOgEhHMnQNkPC6WUqVG0rb6jFwwHwYDVR0j\nBBgwFoAUhim+5hGtqu6HZuczpf/cTQ3zPQ4wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBCaPsmGnAIJzkkQU/ZM0pf2x7Si6l6nB5juiHSErAuSAiANzTRJToy9\nyeW0pYkIwkfrIaJprb2yA2ZRMVysyxL/jg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXPMgNKuizFBqdnctOm98PPFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmNlZWIwNS05MTQ3LTRkZTktODRjYS1mZGExMjE1YWFjNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbCeUMotrk6lYsi5FlUOp60oX7NrSKEOJgP2A3sdO6PH1e\ns4XAr5lhK17Cnk0C57rTvuV3K4OB5K1ZnTaXIHBqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhim+5hGtqu6HZuczpf/cTQ3z\nPQ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOM/m6IsJ5ur8vQZQPlGsQlMoFyZouUbp9K4TkAkZmGqAiAZYBoebKlk\nEXzldiupvtaOwzsh6rhpppoySVxBbDQxXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXcabKb051/HjjCDWp99KITRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFhZDU1Y2ItOTYzMi00MGI3LTg1NzItMzI1ZGI2ZDQ3MmFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA5YmMxNjgx\nLWJlYTAtNDg1Mi1hNTdlLTE2MzQ0ZjkwMDg1ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA1L5C3cowOjH2swGvtkTw7qVlSsEfwO1iJ6F/ZK/qiQfKs0h1LoQuNJ\ndnYeJaZzcYXxvZyF1/ietkWHsPrPHMyjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBYjoBIR\nzJ0DZDwullKlRtK2+oxcMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAkmr2tgZ3xtzVAy1gPhZjz0B+1aXYft72YVgeUaU7xMkC\nICRbHW8F1e4C6Tl8vRnd4DSLcLqlkLR0qXuJihFg5vnA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5663", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5663` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAbc7zEIPgfeXPgrMhmXVIlupMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyNGI5MDlmLWJkZDAtNDQxZS1hNmY3LTVlMjRkZDliYWM0NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk2ZGNkY2ItZWEz\nZS00Y2U3LTg5OTMtYTYyZmRlNTFlMGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Lnr07V0Euer7qyh/o0rstQgfChdutL2bpv5LVODx/OyAlzxdlI6HDwrlRjP\nrsWBxoEmNSVgXLr49jJkCh7zrqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsFudBzNw5WV0ZcFJil/2gXR50SUwHwYDVR0j\nBBgwFoAUv6+HQM7pKJorRvgV38381dC9vm4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDfdKwCzciqkJzQQtiKJk+oZSIaxudazgULjGpm\nOGvG+wIgAU6csAMdXueg+qaGedagv09/LFBI0u74f/QJYAbfgBI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQuZZCMBn1gvsPgI/5IwrL7NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjRiOTA5Zi1iZGQwLTQ0MWUtYTZmNy01ZTI0ZGQ5YmFjNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATA8q9eiye4OYlwoDs8biTCplEvTdQFPCIbXGFk7F9dZwho\ndsRoTucvYF1/X/fnaGdTud4eLuOIF4kj6pmzHCzTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv6+HQM7pKJorRvgV38381dC9\nvm4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSfyKiKYilp72WU3MH3LAArxoiY2N3TjQS9cGhR0laUECIQCGMxkFTwhm\nGlJ4f7iOz1f9+Fu2E4j76yeyBqDXbsfl7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARiU2EG181dU/jTrWRPQDhMdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk2ZGNkY2ItZWEzZS00Y2U3LTg5OTMtYTYyZmRlNTFlMGYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNlMDdhYjcx\nLTJmM2QtNDJlMS04OGEzLTliNTg1Mjk2MmRjNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKtyyddsaR9aWF9E88/QSTXT/2Ip4IjZ/E5c6VFYAE2gTaUQ9uEOUmCi\nmKVJpvqdwjUo3ohlWBXPLdWzhkOJ9yKjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLBbnQcz\ncOVldGXBSYpf9oF0edElMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAoJbTcotYsOjmAF0cH7r12okIhegaFmseIL9Ogom/MEUC\nICOWdWPRPSZvdE79Cw1Tj1Lqu2Td8NmYorCrtejVHP7l\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5664", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5664` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAe/1q+Jd3gHgi7LlpPMANNP7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlY2I4NzJhLTgwOWEtNDg4Ny1hZDM1LTYzZDljOGM0ODcxYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU3YmZmYTctMjAw\nNC00MGIwLThmZWItMWE3NWIzZmUzOTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP8fd3HS8kAOgBOuPJxRxbBYB+iYvnfhXppwGkO0owkt13k5oV0tFwoMYz3Pg\nxQEGvu7Cu7qJhGvU7uJXBwb6FaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU83PbdUg7mfKBPiBRA8Qh9Rx3+pAwHwYDVR0j\nBBgwFoAU5WRZE6E2twVGX/cISnamSgMyCccwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIF2ParingJSaxCryKvjAuMDhJN/js5uVZJ82Ftnp\n4PnFAiEAt0YZc6DVMQ2dWocnQ86JgN8+6+xb+sTYPaBD1NmBy3Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY0O0Iq5IBG2VhCwYMqNX7FsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWNiODcyYS04MDlhLTQ4ODctYWQzNS02M2Q5YzhjNDg3MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ11G5v2QmXa5QOlZ2j3//q/xR2XvjeveGFZdBu5zukWjqF\nyisuO0TehixYzwHlip97T5kzYnnVnwJmDC7xB6AWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5WRZE6E2twVGX/cISnamSgMy\nCccwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANWLJF4MTq9DEbSGIUtD+A162ZSyurtHCY+HeWhLH93/AiAI5Kprp9VB\nhiP/5xhcprTlDD/IvlpvwxZFtV/j3oyipg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATsNC+NMwopiCHZYwRC04JHgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU3YmZmYTctMjAwNC00MGIwLThmZWItMWE3NWIzZmUzOTc0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhNzRiNWMz\nLWY2NTQtNGRlZi1iMGVmLTZhZTE5MDJjZmE1NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOrR6CNO5iXIbRRQHUVh5xMtERctcagAEOUmclD3yXs+wbnI9PXpkBMb\nWHno8nLg4Efu+0vzGligMsK1ZU4QsnujcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPNz23VI\nO5nygT4gUQPEIfUcd/qQMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAt8cR56Syftooxvljg0jSpnkXXr5VwULqMsL9eEbBl08C\nIGdu4KIZj1eyQSmEzQ9JA/cWpt1eCd/SN6TjZZiHuYeh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5665", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5665` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISASSkSH2GNQJ3NNBgpKvHLVVpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3OWVlMTQ0LThkOGItNGE4My05MGU4LTBiMjQ2OTVlNjlmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA3OTJhYTYtODk5\nMC00ZmFkLTg2NGEtMTBlMzEyN2EyMTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsYQOJKU3u2dw/9Iu6QbTiYF2RhD66Pjv283w7TEn+5Uip0uNhfaTVYHsuvN9\np35BN+KVEpOMoksId5nf3+LL0qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPovJUE9kw3IBUJKDeskudJig2hEwHwYDVR0j\nBBgwFoAUQ1bZYr4HIN6tJYAhWHF5G6A0cacwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIANHoKq82ljViMdTdRYsiz8F4s2rHRYMT0Uk3WTHk52MAiAJ\nLPGhYCmWQ1JvE8eg8QzTLq0AbNOLjLGOq3Ms5K9wiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQT0WofSevHg6IU3EnTzXA6cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzllZTE0NC04ZDhiLTRhODMtOTBlOC0wYjI0Njk1ZTY5ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARF3p+sDdwk88MytG+Exr0aVIapQm8rcC7a7TnaUWSRBND1\n1Qm9aVnAeOh1b0Ca8lAJY5SEL3nhm00MLhXYE4Kdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ1bZYr4HIN6tJYAhWHF5G6A0\ncacwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALSH406fjtc9FyRAaHmbylPmBBAg1+9usNunjr0P8E2SAiEAhC3TsQ1c\nPmxwIXSpBCsPB9Db02Aj1Z2Rp3FftE9rvvM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAcnD7t1Kuk0z8bYS/Gq6GlTDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA3OTJhYTYtODk5MC00ZmFkLTg2NGEtMTBlMzEyN2EyMTAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAwNjgwNDI1\nLTEzNWItNDkyNi1iNGJkLTMwMGZhNGFhMWVjZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBzZt11tQjGYUyYTkh8Yir6wKXYF6u1AspPkF+DtTdSO/+LNz/LWE8cL\ng9V1EplLFxigPRrTtoWGlTptA91mf0CjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD6LyVBP\nZMNyAVCSg3rJLnSYoNoRMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBLSlmJMe9FBdDQlFVzJielW/JIktH0K0CtTv9q7q9EFgIg\ncfrKrMDwM0DvyVjoDumgkEFMA2TzOzm/40ZkTD/4snc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5666", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5666` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQJb5mrdyabMZ59oQuJaHzR0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4ZThkMTYxLWZhZDQtNDI1My04OWI3LThmOTM0N2IxM2ZhNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JkODI1ZmQtYjQx\nOC00NTczLThlMTUtYWI3M2YyMzA3ODE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgt7RRbcxtEIIZWTmFnfWG/1MdVWn+gYu1YbtH1VG/gb598GI9H03dLbxEnzv\nnFRiYeO97HubCmPMK3/bET97s6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFzCwBTT+CUnqHlFs4yh63iIxQp8wHwYDVR0j\nBBgwFoAUprKRkiht+PbgsFpe9qJm6NB3+PwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDBgpbdj16tuDv3s9sFC2qYCkWyigzzU\nijpnlvRrj7rZAiEA1NGREUrOEQiyuAGDPyx0TekCZSzd1NfgEW21jiNRprE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcqos34Q7qE1j34/MXQ2gfRxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOGU4ZDE2MS1mYWQ0LTQyNTMtODliNy04ZjkzNDdiMTNmYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXiQb4PeF2l6IESDEZt3tC7cinaHrLOgaUGcM3Pk24WdHQ\na2Dpm4vMtJ5QWb4jlPmoHwbsXCzlKXa17JrWkgN4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUprKRkiht+PbgsFpe9qJm6NB3\n+PwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ0hfSN5b5+iXPA5a8fG/bWU717ER8YmSkvVw8vCkwLACIAiMKdmq6kDP\nhBSY+h4ppXbcUtNi1/UsCeOgT9q+mX4t\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdOgAwIBAgISAeupNbOZy962Uh2IMWMXYzMsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JkODI1ZmQtYjQxOC00NTczLThlMTUtYWI3M2YyMzA3ODE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNlYmFmNWRm\nLTRmZmQtNDVlYy05ZjVkLTIxNzYwYWE3YWZmODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLx/SUPdzUiKSqnAX7dVMDEP/+vsZ3CVYnYo7zywhyFvLroDeKvODPHh\nSOXfQPtEgeanRmh4zOKylR8ltm0dHUGjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBcwsAU0\n/glJ6h5RbOMoet4iMUKfMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNGADBDAiB+sEY6A1rbTzoxVmXYzsNBhCu+Rh7aioh59lV8i0KJ+AIf\nPWDnHsw3CAKESzy1hZUzdEZgm4F90VTQHIv3C4baVQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5667", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5667` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAbew0XKRjsh4jod8T4eo+AYcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNTU0NWVkLTAzNDAtNDQ5Yi05NTQ2LWEyMjFmYWQ3NjE0YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM0MmJkNTQtOTNl\nZi00MzYwLTk2MmItZWFhMWM3ZDhlOTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUvmBedx3iYu0zZkF1eBvwBqQsMhGLwqshTvcRuZLlZG9aAgPM4oXNLVqi1iZ\nOc+y9rkODgDp42B3RODpsk0cnKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB+U78RPFukikfVDZlKmBN7v6MsswHwYDVR0j\nBBgwFoAU1nIoQUVDetKMsyMbe7C5iRvht3kwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIBg12tscvZmzWn2r5g5l4jXl3XHw5MQb\nS1u3Trl4FNHrAiBtfseuAw87vMxeM7uiJ2D5cr+H0cX8XzHaMElR9zhiNg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARifcsAV7c1gbD5DqKVEuzWbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzU1NDVlZC0wMzQwLTQ0OWItOTU0Ni1hMjIxZmFkNzYxNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjv0Xa6uanKp67JaP42TbBWNeSYQN2B1qvituzxC6n0Muh\n3jQrcXkSBQkXtWWME8wLNzG46Bjp166UzrpRX3Jjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1nIoQUVDetKMsyMbe7C5iRvh\nt3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMmuoWe5pJgre8IyKKz8wVDFD/ng8A5+8pMHwkN3ULOcAiEAkYcsCza6\nuAjv5jBhbwexycGvABoBZwyf7N/dTf3JdLs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZ/BQAHcVi+eLyZ3vaSJIy6YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM0MmJkNTQtOTNlZi00MzYwLTk2MmItZWFhMWM3ZDhlOTM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk3NGI5YzJj\nLWQ5NTYtNDEyMy04ODZiLTc4OGE1NTc2OWY3NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCyK2jndcLoJh/C4Jo6znpgoE9iKoWA2ezz9uSVXABoJhrSNHiXCLzFx\nMMeQdcZhcKaH+ji1MntaDd770jMVDI2jcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAflO/ET\nxbpIpH1Q2ZSpgTe7+jLLMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAQk+PNFrgkbJmrVVWUcG/u5AploBXc3K7H46EiO8mq4AIg\nDxmxXkQwpu2uju1e84Pb9AcbIiM9mMRea35F3gOK+Fg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5668", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5668` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYrVQDroEbJN/Lm3ApuxStvkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5OGZhNjQ1LWQ4MTYtNDcyZS04YWU5LTBjYTI4MWQxOWM1NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODIxY2IzZDItNWUx\nMy00ZDMzLWI4NjctMTZkNjA2N2E4YzIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL7q2aQNA8Wgdf8wF4WhlTlhWqls9eLlP5SzS4qEw1lMDjY+xnU9c/9t4IjKb\nSy5dGxx5h1MJrCEd5l1E1C4zUKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGCKxgAtVL2QJjo+D/ubXcRrwH14wHwYDVR0j\nBBgwFoAUhSqG+Se00LhFow/1Q/1KQvyhHgcwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCvVjVH7nBJ\nwcQC9o6seg9VpmmUfUP4m4KS8EczyAaSdAIgazXOxSsoS41TZyCGenG/W8/O4GRc\nqbfjgmlg1jONGVM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdzqVdu+ERSxs3uwNQ7iwNqeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOThmYTY0NS1kODE2LTQ3MmUtOGFlOS0wY2EyODFkMTljNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSfZPThaRAk5pnCISDs3Qd023PXGND9Z8vtStOzegonW7S\nkotLxxeRr1ciuDFQyuQFpsb7o8x3vDy+RqJXzT4Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhSqG+Se00LhFow/1Q/1KQvyh\nHgcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKFKR73rGYyb1bWh2fNdjenQ7eopSFa6IHF0SD9EZMggCIGD2bigfDFtR\njZDve2r/fJwOGQ/h6cKn/ShqCXcK18JZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARZgE28V+WWvPjiw1cEqHKm4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODIxY2IzZDItNWUxMy00ZDMzLWI4NjctMTZkNjA2N2E4YzIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFhZWNkMDQ5\nLWVlNmUtNDhkMi1iM2ZkLTJjMGRkNjJiNWFiMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDnzGH4D7trRN3Dl1b+sxQ7Hy/K4qGuKkkZNxWNvjo1nSNorYkuQz7jW\nF+pAPfm7mAXBwv4ExFo+pb2z5nGWVtGjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBgisYAL\nVS9kCY6Pg/7m13Ea8B9eMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiBxTm82Pv/mMaikycve1NVIJikRQkPuUYNVuF+FKz+7ewIg\nccaDa6sB+b6vD8T15jO3kZ3JxnOfQVs5D0ZFRZxOYEg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5669", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5669` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAalBEO8P1rDO0gY3BQlKXbvJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1MGJlNjg1LTY0OGMtNDM1My1hZjQzLThmNGYzNzVkOTZiZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRhZGI2NTMtMTY1\nMy00ODQzLWJlODYtNTAwNWM4NGVhZGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtQrTNFyg59Kw4d488Cq2NcSqDRFi6OAOrS7WZCz6Z672xjS4rWU658BCOFIK\nPPK8bdDCGkJhHA4JyPI6woRxXKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdK0FVLSlvPImXhLA7jXgV/ArbmYwHwYDVR0j\nBBgwFoAUu99DcHAH7taNwGfvZ6FzRfBXEIIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgfViDKjCStN0DGEqLfb45e0ilkyrkee1ypyx+JqYmrLcCIQCc/1QLZneq\nTlpIM2rJvcRJoDRW5PHuWSlVhxLX2zn9fg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAerUk0rnI67kAVUwxCFur925MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTBiZTY4NS02NDhjLTQzNTMtYWY0My04ZjRmMzc1ZDk2YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQU5XTwVZ58Y/PqZMgOENoKtj80cSiCbHa2evODPSpjaONG\n6Jr1qDrIZKgH05rA0M5KARrJt8NHx44VOWclN60do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu99DcHAH7taNwGfvZ6FzRfBX\nEIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgR+WClMZdOgtLiP6dz7Ox6jaDl6ZD/mT8OCQRNiKvrAECIQC2E66aFT2H\ncSbDnBxN6vmNAxwpdzKC3r6D47wKDrb1Fg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATrMqTPpldmNNd+LUQbNQNUIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRhZGI2NTMtMTY1My00ODQzLWJlODYtNTAwNWM4NGVhZGU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUxNmVhNDky\nLThlMDktNGY2Yi04NzAxLTgyNWNlNDI1ZWJjZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFM8/W5kRYcWWFXWm1fY8L44h9im48H79KK7XLInDzRJljyq9UCmFfhX\n0mis/eGZ8clM3ip7MGF7VBbrjQnemeCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHStBVS0\npbzyJl4SwO414FfwK25mMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiBO+uAy2gpJQrf7I0E8jkfHDZU9zhU78lEj9I3hN4irBQIh\nAKE3ccwlA5GB/Xj+RRjBja5LVgPTtJTWtiCJsaNYA3zE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5670", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5670` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAcJRWfNzDAWlNI5TTH0Zz7naMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiZmJiZWRkLTA0NTItNDUyMC1iMTBjLWIxYjMxYTI1ZTM2YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWI5MGYzMzYtNjU0\nYS00M2Y3LWFlNDgtOGY2MzJjYjE5ZGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEerFEOQRYPx+yGTJWFzVSU29BH9NfbKUbF8whUQfH6RJVkQNBSVxidpJUa9DV\nryEZbvvCgWAn5/jIUfo9IKAlQaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvFdLT2qWZvELOnq6gk1Ejtyxk2UwHwYDVR0j\nBBgwFoAU8TQk3ZyuaFABTr09m2eL3bvjnMwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANAaDLG0DgZYW0pRc+FA5ku+1zD9BfFNXZEXXl62+KH2AiEAsTOXDiZr\n2wQWlhPlCaRznrMDuluOGm0gPRRzQLL70IA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATyTE1N6SLmTJ3srCicdCWVTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmZiYmVkZC0wNDUyLTQ1MjAtYjEwYy1iMWIzMWEyNWUzNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATglKjA/uQhC/VVE7SYzvwa1efh3maIxPURHqt/lmxxLyjD\n2qHdzfbQ3815y18OFqFmYresDESJY93vUHPCcaXro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8TQk3ZyuaFABTr09m2eL3bvj\nnMwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJDAR/YnCJ0RHpL4xPBvAV/px54K8GkIwbHZ2IhKpB7vAiEA8PgYcqVc\nZVfI/G/bwPiQqk1+U9E6w3oXhhZITuTWvec=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAUc0MMzsERKgQ2qhALidqLKBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWI5MGYzMzYtNjU0YS00M2Y3LWFlNDgtOGY2MzJjYjE5ZGUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY2ZDM2ZTNm\nLTY5ZjAtNGIxOS1iYmMzLTkxN2IxZDUxYTkyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFaUWPzivDhBoWWbR8cbLlf+FUg8P4DtQOdJFCjXQ49b0C4fFBP1QUCA\nMZjWqwPYNl01LT2HxQBXfyNoKSVUZXmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLxXS09q\nlmbxCzp6uoJNRI7csZNlMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAh8Sf17mwedpkxm8J6Z8ypey6g+xwVadCuC06n/MuFHIAiEA\n0SL07Mx8g/x4J1hcDjL6P8tDc7yAo4MAapqQtFrE40Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5671", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5671` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAepBaTvg6URx9aLev/GAyLVFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MzJmYTEyLTY2YTAtNDExYS1iZTA2LTYwZTY0M2EzMTFmYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGM0YmRmYmEtYjA3\nNC00ZmI0LWFjZTEtYTVhMGE2N2JkZjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkmLa+/2PHyboQqOKzug3XOZTVQ7wT36fgoMG+h4OQAbZJHJ89Yz8f+MHO98E\nhRwicUh/vjvCVKHjgYK/JQqd9qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtmDRlA+rE0yyPPTgtfkKBLmVboIwHwYDVR0j\nBBgwFoAUwyNy5JvpaiT6yDqCGlibRexUloAwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBN3XwxcyVTMiZb5FLHnNdd4O6ack3KL58TOAVwScxNoAiBQJwlpi8BV\nQdrGiPe7ccpRn2uHA3GvTnrmaCoEiQ+maA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUClqdVB1ymHZfldZMzu0NNuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTMyZmExMi02NmEwLTQxMWEtYmUwNi02MGU2NDNhMzExZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLkQKsY1kr/cpaxVd71IbwFzVMeHg7Z+9HvEBgjNbpvhVn\niJS7uqri9g77l6LY/Yu5ypPKKZ1tmIKHGhLgGn9Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwyNy5JvpaiT6yDqCGlibRexU\nloAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXuN3DEDsPFrb6yDy2IN6GqaLj4d1IX3bWydUKAHmUGECIQCHpUbWeRBs\nF0cnxtzFmDdqBe0K0ew6GV+K0yQc4vbwZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAVM36ByFUgh4BlaCIk+Le5TiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGM0YmRmYmEtYjA3NC00ZmI0LWFjZTEtYTVhMGE2N2JkZjQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVjZDk3OWJi\nLTM2OWQtNDEzZS1hZTAwLWEzZDk1NTVhYWNjNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJgy/KS3QUHxxTR4KinV5QvZCww2Pd/slesHAjC86SUo8OW/771CZN5C\nKWibiSEQ+F54f3jrFwY3TZqSvOMVHxSjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLZg0ZQP\nqxNMsjz04LX5CgS5lW6CMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEA68WL01PnOlfpfYjl6SqZZ8T0g5/KOL2n94VeAx4sUfoC\nIQCHCiHljYAnXB5ZotviJsQTuFkb2VZRe78U4CjtmFugJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5672", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5672` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAXmontSAIVAby536XFx7arGhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhNDRhMjAzLWJjMzItNDQzZS1iMjAyLTRlNGUzNTJmOTk3MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQyZmRmZGUtNDRi\nNi00MTAyLTg4MzAtMGY4NjgyNjc1ZTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwaX2QDMzGdCa6HGs+wAobJTtxt64A6W9tKpetd52P37+uA/y7+QVjtFdmLZI\nN8kMYKNTJ13MKjyQyw95WP2pt6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyYgAcAuG03DplqNY3KZfEUN6IU4wHwYDVR0j\nBBgwFoAUM/yJKIoc5KAi44cKYy8xUVj8UPMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIG0XKS5XCTAsqnZddi35EH8f65/YHpO8thLRTHIW\n/FeNAiEAxVGQkqm5TCBqS4gueySJZSFoMmE6spjjglOD9ZMkHn0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYTKsHuvumF0QmxyMMxLAG2RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTQ0YTIwMy1iYzMyLTQ0M2UtYjIwMi00ZTRlMzUyZjk5NzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkQPqSkUnOt1KYwm0WJ9z13Vjw9d+Ix0J24uKFsBgdLCD+\nsBe81cAVSh+yEoJPFOXQ8zonJaQrtc6Um+In6chRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM/yJKIoc5KAi44cKYy8xUVj8\nUPMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP0OvdagVFaifSvjc2f1LL0Mjd5i6uL4uEAXoinZZhuUCIQCW7jqlhkj6\nZCyTIZGRkFuVRTpR4egQpQFqcSGuT62+8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQV1OkZiG/Iw7ubn79Gbko9JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQyZmRmZGUtNDRiNi00MTAyLTg4MzAtMGY4NjgyNjc1ZTYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRjNDAwNjNi\nLWJhNWEtNGExZC05MDdiLWQ2OWNmZmFiZjgxYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJLyV9dDmHywSdoAKdRrZfz1/U+tASJZA0VAbAnqeX23QGmp1YCP25GI\na9ad5oYqDtFDKa1hXii9GfwxU2oxbRmjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMmIAHAL\nhtNw6ZajWNymXxFDeiFOMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiEAvGA1pBpxJTUwGfqEqtZz/i61utC1/in0DlPUNUdOexQC\nIDnu0uQv/tIXfHfjG8MUVgaDv3BGXhTLDHCj31mBgqMK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5673", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5673` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUerC9DfQTXAZpduL2OLeGciMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiMThlYTI3LWM2MDUtNGZjYS05YzExLTUzNzRmNzlhMWJjMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjgyNWQ3MDQtODQ4\nOS00OTdlLWIwYWYtOThhYWRmOTAzZTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzcbCpXjOph4sZQBR0dGIQcTvzbj3TQE5nCIqUEcIrCDBr6p0AL738NfUPjhb\nqSj90esW1BI7egRug8m43/w5eKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3yPxrL9jKImfBz2C8JXSnuJH1xAwHwYDVR0j\nBBgwFoAUqzekBWDKnLSrxlr+qVekTxxmbrcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDMWdIC1CG3ESbWzPwmZltjrnPbC63FQtstwJ6S\nnmIgqwIgJD2ZIDfm3wrpxkcqXAV0YRrUWKYHisancmlkPtLNeXY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWgrKagvdGLndecof519EfzcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjE4ZWEyNy1jNjA1LTRmY2EtOWMxMS01Mzc0Zjc5YTFiYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhGeGLn3KbwXKrwg+0GwWEUHotN6XYTL8qLssSHepQN/rR\nZrh//3jctOUYoeH3sOXvnFIZ1rqXdhnJj85SdeKJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqzekBWDKnLSrxlr+qVekTxxm\nbrcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMjbR4/EVhs6sLmgIhXzqHAeBe1MjQS+5F+PUAAozhwkCIQCbc4dSJXD8\nVDhhnrtJaKaAg0VRm4TFSts6THv27DQOhg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAcZ02bCLfZ7EwYa1mcfpxJeGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjgyNWQ3MDQtODQ4OS00OTdlLWIwYWYtOThhYWRmOTAzZTQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDlmOWY3M2Q0\nLWY1YzktNDUwYi1hYjFjLWEzOGUzNGI4M2E2MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMuBGbCA/GteI9npzbzKQG4bK10m6LtSE4HSPWDow+w2JMyv88R27GgS\naWycNeE3/4GGFW/oHTbxvvQ5E7JmyeSjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN8j8ay/\nYyiJnwc9gvCV0p7iR9cQMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiB8EPStq3fysnRHXdswvMR0i/q9B7sfteiBGfCnbUHxeAIg\nYK1DT0NvbVKiZyKnPktfLGyY/SP4US6ZFv9PDJZ7uDg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5674", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5674` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYF7nZtWIVRSzHdfdZH2Y03oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxMTRiNDgyLThjMWYtNGYxNS04ZGQ3LTliOGM5MjBhYjU1MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE1NzMwZjItMjI4\nYS00YzcyLWE3YzgtNDA1MWQ2ZmYxNWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj95SPmsJr/h3KoP5M5LJx/wUGHoPDHsP/vjeuQ5/K0sptZ96+FG1ZAj9+bTZ\nyOCknf+/C62IcdeH78ishG4LTaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBAbuhAEofvkPdVcnMJDkIr+fmvQwHwYDVR0j\nBBgwFoAU9OracSOS7Td0OM+sLW+EjTTJQuMwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCICIu9hWEQtBmF3GnmgbkiU4mqnFLTRdrskrIpiAxZFNZAiEA\nlXK/sDCREaPSNbUyHSicY+NFQitFv2Js14IxOK2kAqE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbkiJmziUkx9VgPS6QxYvB/TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTE0YjQ4Mi04YzFmLTRmMTUtOGRkNy05YjhjOTIwYWI1NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUYSb0aq2kXOBcliZ6zst05mbY73QVn3tiUjIuSeR8dCF0\nsvMopAxJUtNEu1fRTa/cTA3noK3W2f6wHK3mErFBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9OracSOS7Td0OM+sLW+EjTTJ\nQuMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIgCs0SNZmmfo0JjZB51NkHuDPLMYNFC6MPHCf34YB4gAiEAmktQ18q2\nab42hDvdYzgRipIUKmMFATznPwLY1/mbgxs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAaioqC0nauiePMhDaf5AVt0aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE1NzMwZjItMjI4YS00YzcyLWE3YzgtNDA1MWQ2ZmYxNWRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY5NjM5NDcw\nLTlkYjQtNDNiMC05ZDY0LWQ5MzY0NjI1MTIxNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLkKSdsOgZcTQ53pRswo0mVdsJ6xjWlyHn8/pcTHc93fpspgO5msndRY\nBlN9osUyH1nmaF3pNQGUt0mIXiT1U0KjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAQG7oQB\nKH75D3VXJzCQ5CK/n5r0MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNIADBFAiAgEMgrS51AVnjZC4jZQiPsUKisGFxK5QXSYj1FYnMfMQIh\nAIY9vqcJG5M+Gp0S3QtWmcgQbFfwN2p4Fw8oJc4rk4uz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5675", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5675` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAWlShayOZqCEDcPyWUYrUFZoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxOTFiYmQxLWRlNGYtNDI0My04ZmY5LTExZDlkOThjM2ExNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmUzZjllYWEtOWQy\nNC00NTk1LTgzZTYtMzM4ZDdhNTU4YTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeEbcqU6Mt8cICkdhFjHx8QpXpJ302YHVDstYJ5fTwnNAq3n6w5csk77gyn9S\nEVZ//wSMTwd1GwO8KjGPKqBGg6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUps+QLj9L7E7s5rfjBZkCsUA77OQwHwYDVR0j\nBBgwFoAUyYKCQaVva7UZaBYSBu/7Ys/sI/QwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCrdWNsN1tYkew2aZcO7mj1x6uIZ78q\n/0xhhYoqivY5FQIhAN2j+naOyVgi/J0kFJEBfbzMStX7Nj7lWw+lTnHSKC4W\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYHmCiUZdB6pZ/WUTzm2WtjoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTkxYmJkMS1kZTRmLTQyNDMtOGZmOS0xMWQ5ZDk4YzNhMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCuDwG0icgT2kWC4UZIxExlea1+pvQeBjNPhvAfrCTUZTx\nvoFd14OzcsEqQrEzDKRGkSm7I0Mp4EHkej1aqpPRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyYKCQaVva7UZaBYSBu/7Ys/s\nI/QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVu3B8GGc0XhTq/2oHE3IHQlt4AFRw2rVJAJCw4KkkewCIQD08gnzkOzZ\nDupiume5M4wJzM3Il1Ym2w0gAvpej5SuIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAXcPjKFhFjgvcjVYR+p0nEXJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmUzZjllYWEtOWQyNC00NTk1LTgzZTYtMzM4ZDdhNTU4YTYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ5ZmMzYzU5\nLWI0ZjgtNDAwYi04OWMzLTc3NTg3MTRjMjQ3YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLFo2n9emrnk60jjyj7y2Z+4J+kxOrL18En6OqPvcpAKV6ybegH3Rt7/\nV3oflVmj+bMOUk3/xkzM74S8oEgJTfCjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKbPkC4/\nS+xO7Oa34wWZArFAO+zkMBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNHADBEAiAzJbQta5SHZ6C0rloIRsAklaAPGWIRr7mHjSEg/QX5nQIg\nMv9gsKU5Bp1jHRcxMrXs8HkJ9vZK59GUxWh+DEcQPR0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5676", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5676` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISARG8HBZJ/HQlLqLUrxALfxFOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NzhmYjY5LWFkZDMtNDRmOC05OGU0LTU4N2YwZjk1OWZkMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQzMjkwNjEtY2Mw\nMi00ZWY5LWJiM2UtMGFhZGY5ZDczMjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEZo4G6VQO/E6/ZlP4wvLczwnRu5mAXn7rqhKJ+YVNq1Dwy7YSVJyLqYUrkB6\nlnJUE47GhkcXRkvoAlpe4Iz9z6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpbuZFu6Gqk3Rh57exXEGMIqF0jUwHwYDVR0j\nBBgwFoAU1KVzLULFsot0oFohbkhpHLyZNsQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC15dWZzFyqxwRWJQEneJUNNlUrvNRT\nlABDT+od6wC2yQIhAMGsvRKWuN6i01KF+UrtrAwbRFoNq7nlVT3hvQddxHZ9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZlM4Yj9M/1lw8/3XV8c50SfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODc4ZmI2OS1hZGQzLTQ0ZjgtOThlNC01ODdmMGY5NTlmZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPC++ulB5meh9Ix3qQYYde7QP8R+U9gAzYq3bAb7q9NEmr\nb2XOuVhQzTDOJOi4rUYbZUyGya5HGvORTy2TjsuSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1KVzLULFsot0oFohbkhpHLyZ\nNsQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIU0xUMR0u+2y+NClXK1GjA9TZaNH0RgYfPza3QDf1KDAiAldEXmpOT7\nd9kPG9D8xP5cWSGBtVXRxxV98YmVf2hpww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAUPFY2Woy0xIFmhq3QTaVNLyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQzMjkwNjEtY2MwMi00ZWY5LWJiM2UtMGFhZGY5ZDczMjYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRhOTQwNWFj\nLWIwMGItNDMzMy1iM2UwLWQxNDE0YmZhYjVmYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIl+RXSGpHYQAFDKg2SRUb2bAbb1HqcCorBB3GzgT0SGUFaOwScpQknK\n3pdFFUVDH4LT1GMoLNtXsB55K9ULwxKjcjBwMA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKW7mRbu\nhqpN0Yee3sVxBjCKhdI1MBoGA1UdEQQTMBGCD2JhZC5leGFtcGxlLmNvbTAKBggq\nhkjOPQQDAgNJADBGAiEAlN/x0beYniVERWfdv+JkYXDKHF4mXBYdqpx8K3PX4I4C\nIQCiALMuMzKWr6orf8G8Rf8k6gR1zDe9jE5ZTHPqZOlDNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5677", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5677` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdPgqH/Apzb/OdHE1VGXTLnAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwMWFjYzkwLTc4ZjEtNDlhOC05ZmViLTMyYmFmNjZiN2NlYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzMxYWY1ODItMGU5\nNy00MmUxLTllZmEtZWY2YmE2MThkMGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaSjSm6UuJNr6NgYg4j+f6GGaqgPqbYob/DPy6MRFFKlovTc7QlBMvB5tsLwY\nNlq0jEOexl/RDQgbK9hiVSys+KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGUpQfB2yY/ZnVZd1ram1uM10u4RMB8GA1UdIwQY\nMBaAFBuddx2/6c+jvktG8+mG5Cs/Tpk+MAoGCCqGSM49BAMCA0gAMEUCIByqobJG\n3BiuataFewtQkyyJZ64eX1L/QlqePFfxyBo+AiEAzLVDx4mFMHPoZMQDIxKRme7X\n/oBUI5+ttQey5GCgvhk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcKKmhhM7Mjt2NVjPFfVCFiTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDFhY2M5MC03OGYxLTQ5YTgtOWZlYi0zMmJhZjY2YjdjZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARggJevJ+Aan//TvNHGzr+zd2l31wKsc25TF6jrOjvv8Zh/\nZDNOpxLjCUu71LT5+MAfOWDwxZ6VTs7bcHsoRz1Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG513Hb/pz6O+S0bz6YbkKz9O\nmT4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANEKAbpqAobx4H6+7mKbcc4uPiadoIS3tDYutkW42srmAiAJx/lMwmt+\n/SKUL+t+LfSvx8XA1ae9mCZWeMpF61sjNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAePHlSrGe86uIdCiLTk3reYVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzMxYWY1ODItMGU5Ny00MmUxLTllZmEtZWY2YmE2MThkMGEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJmNjAzMmNj\nLTBhOTQtNDlmZi1hOGE2LTZlZDE5MDFmYzMxYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGn3jjpOdK56mxGDeWiH2mdYyLI/cmiicihLGvlSVgUYSv5ba0YpwJsk\njG6U7Ni+3NdYCrwVHucjU/tY17R0WrujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGUpQfB2\nyY/ZnVZd1ram1uM10u4RMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAq7Petbc21zBmNvnjT9BSVprP5TYbjIzfBP6C\nP22NSsECIQDQBsR/13T8RU0Ij17ZiBEMLIpaUIepcxxIjbeOIRNcBQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5678", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5678` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAWSAsP9vIeTdrOq4VzG3fJwaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhZjdjYjljLTc4MGYtNDI0OS1iNDkyLTczOGNiOGJmMTZhYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVjYmVmMGYtNTdk\nMC00ZGJjLWExYjUtMDFjMzQwZGM0NjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6/GRws+nQwpTaYXB+TnHgehKEE5pMnzCJqNxShc+ePwptleJdduh8y6csfGu\nH77mpNcqON5QhnnsilhhlnbllqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFE5KgegSrRLI6OQE1gGWviTLwwASMB8GA1UdIwQY\nMBaAFP23Op/xPBTHojTE2L/9SgXgL6fiMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAhNvK7EPZGuJoGlbHjaP1ZXympXrnKr7s\nzMycmTCqEuUCIQCu/YUVBtQ/EICmDrO3juclgZx0Y3uRGUGyVDtaZQ8uog==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATGNUc7ZlhlC1a5jSF7mcZCNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWY3Y2I5Yy03ODBmLTQyNDktYjQ5Mi03MzhjYjhiZjE2YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ85FjL8II5iRyaD5LFwo7LMswE1+JHf1SO1+jpoEEUGzDY\njE6ACYoBlqocl6exqRnjiKr392GgWkPvdgGt2wPto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/bc6n/E8FMeiNMTYv/1KBeAv\np+IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT9jdG/27ND/FnCocAAwFUAgmSikfYK/BKkwOHQmBy7QCIHCqzJ7jZPse\nhyBQQ3E0KT3n+4/AE0JJKGXCm4XsN+8C\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcEdmoPY4ARMMZCuVaFAhMFZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVjYmVmMGYtNTdkMC00ZGJjLWExYjUtMDFjMzQwZGM0NjU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRiOTEzNjhi\nLTczZTAtNGQxOS04NzdhLTQ4M2ZkNmQzMDAyYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFxfRFSHJdMdeAuNnTi7fZJ1JFEqlaRsNJ3bIv9WHctmjivKOoifB2Yx\nX2vgdqWlAGGxXbzGyPnOC4QHHhIYXzmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE5KgegS\nrRLI6OQE1gGWviTLwwASMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAmCEDF2Dten1fPoaiBMx58drJosTH9vlEmGgy4\nYjq5tgIhALtz/4jzLNmDd0Aijp0dyZp9zhOldb9vOOAcVS1kUGBg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5679", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5679` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAU8QZiODHtYs9KQh8MWYPzLJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzZjZjNjI0LTAyZWYtNDgzMy1iNjMxLWI2MDhiMGNiMzFkMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU4ZWQxMDItMDU5\nZS00MTQzLTliZTctOThhN2NmMmVlZWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDCwinmnGBh6O0f2YJld5Pz6IhGiqRH5CtO6eyiTvUWVag1MCa9aDRBf8RG6P\n931NyPtjc9HjKkjxZscXwIB3IqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOnQ91Aa6l07S3pJ09ygPrk4hAcsMB8GA1UdIwQY\nMBaAFMorxRLe3LHe0zk2ZwkVBseTUqC/MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA+8D5vyrwjclmP+aY49xfVLEZBjgfrjO4\n64HW78rH7PQCIFQwMVu4DuILoAM/SOM7Dy2w++RPKXrHfKYsUpjvGI3B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY7b6AZ16LWA5Pvf48RnDXDLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2Y2YzYyNC0wMmVmLTQ4MzMtYjYzMS1iNjA4YjBjYjMxZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6L8eNpWOtWc8ixx8VKJMX0wyu6T+n/2RgH6NSdSYlwYv2\ngstmgOehRz30fHjUqUKPEAlD0tC4C+Gxnv0FFH2no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyivFEt7csd7TOTZnCRUGx5NS\noL8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIQQV9bhMyz6n3cFaD76cBJCeY/hKxxg4BQGlJHR9rBrAiA3/b3xvJOy\nuAHxoxRflE1l9YJfGvjfhHPvWrdGwTB/qw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAUna2rU9Bd2nvQz91nIn3MdxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU4ZWQxMDItMDU5ZS00MTQzLTliZTctOThhN2NmMmVlZWVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUwYjZlNmM1\nLTI5NTEtNDQwNy04YzU0LTk0MGFkODFmZDEwNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAYQYUK1NSSdql0QGGSflDWYuYtL3mBIeJbc4TGR2hPer9XiYQUBFEjc\nPvCrr/Ymo7AXxr9zl9c2g42RGXM4mzijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOnQ91Aa\n6l07S3pJ09ygPrk4hAcsMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEApsxn/SK3UxqrMoexTY352b0brlBOz3pZws14\nOgD1kMgCIQCM6xTsOhB3pTCNqDjWu6W+OpajYFBmpV5YxtyGlY4hwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5680", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5680` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYIndZYloLZLLPSh7K5j1jdrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllMWU4NWZjLTMxMjEtNGRjMC05OTNiLWQ3YmYyMGM5ZDY0ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRkNGVkOTYtYzk2\nYy00N2IyLTk1YzItZGQ3NWI3YjgyZTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtoXa0h7FMjnRp2QvO64yTV2QdWUgbQbkxllLM10+kkJt4HD9BYxF0qNPwuSu\nK61UTZb7NxcqCQ3p64U17KakJqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTISsOmEOjW5+eZAwB30tIS3FF6eDAfBgNVHSME\nGDAWgBSWljc/I0n7jXb7syK/yTxrzn4+tjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCs/H7cnV8NkdrqIfL8mvRFUlJOLQtg\nDXsaAayV0g6ErwIgN3GoPgSMkTGScvqbOXP+/AbkxiIrlcYnegC9W6ZpWQY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ++Xi7G1M7HGEI+ObTe3dtLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTFlODVmYy0zMTIxLTRkYzAtOTkzYi1kN2JmMjBjOWQ2NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVIgCYcdRrw38SvhWJIBkB+YyEd42bUbpMHaxRIa1gqBvH\nxgH1tLH6iKro6wvL6LE93bEO/odQpR/fEnHNFNTdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlpY3PyNJ+412+7Miv8k8a85+\nPrYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKVGdw66pQlHKGOU6WGeSMZEZNaK/tRUXa1gzlkj1k2fAiEAukG8E4G3\nnO7KU6X4mbnUlosTzMrX0ELum+WuvwlwLSQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeT0FrMqpQlhVROu1zwvSwiOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRkNGVkOTYtYzk2Yy00N2IyLTk1YzItZGQ3NWI3YjgyZTVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNlNWMyMDQ1\nLTdmYmEtNDAwOS1hNTgwLTVhNjMyMzczNDRhYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE+j/d+P8ouODZJksUwvoxQlxdbqNTYsZ/xoU1tYjCn0rkkfxK9jCTu9\nnKJsLeETEAtdOgr6ka4efmaItj7l47+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMhKw6YQ\n6Nbn55kDAHfS0hLcUXp4MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiB+aD166+8IhqPUqRorLmm0FnWlU7/4h5yjDOt9\nkAHGOQIhANx1hIthtAJ5Jt3W8BQTzZU4+ZRiXpPKmwjkFnDdqXy+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5681", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5681` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAf3c1HgRUGwNJlM8E7h1rtW0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmYTAzZDUwLTNiOTAtNDI3Mi1iODlkLTFmNzU2OTk5NGNhOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJhMzc5YWQtZjFh\nMy00NWNjLThhY2MtMDVjYWM3MjhlYjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECYqtp9nuYArLEdSE2qePFT8KpDnKIm2TnW7ifB+IGMFLjFPtFzTDpYP99BIt\nXUAbuwc59+M8SjfUiDxIzf76ZqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY92V3LmcJ7WeWKURXRe9QkdUuJMwHwYDVR0j\nBBgwFoAUKG1dE6AHE9F2sjWPxACQIauYMREwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAhs+v/mfJqrju\n6bMItuIfXJT0vPpxex+Q7riIdAPpGbwCICiZZULvwNY9EwjW3JHalRO5vd8ki2RO\nRm7t2vz7Y8DI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVf5TXxSzqnoRNsOQlTLu7y3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmEwM2Q1MC0zYjkwLTQyNzItYjg5ZC0xZjc1Njk5OTRjYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgP3c0dJNbn+d/RWQAjxQOH9BjWjTKUjfDc5/HVzCeAmLW\nYRJDN+SMK2aQQBCXvWOz4r9eVyGvUbp7xQU1IMUso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKG1dE6AHE9F2sjWPxACQIauY\nMREwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJSFSDuJYc7Jbsue7lnQo/5uSAU4S38mEIQGaiksyOoRAiBRPOBJHjZM\nmVB1NmGeXkaU+dojJrtjDBDlX44wmGbbWA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATco828NXNLhDPGqEf3/SG5QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJhMzc5YWQtZjFhMy00NWNjLThhY2MtMDVjYWM3MjhlYjdmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA3OTY3YWNm\nLTY3YmItNGEwZi1iYjgxLTRlNTkyNTZmMmNjODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJJqW19FN/2aZLVjTdcPuWjfmHNl/BzRHUHiLPkTw7gaYtgw3lWNBoFv\nff7k9+WLT2RJW/GywZTaw5t5C2ljKeejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGPdldy5\nnCe1nlilEV0XvUJHVLiTMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAOWgUOkcbnFAdzT+av475CVPdtNQe6qmPSslsy\nq1imTQIgHxAGciK7onB5G8Soha2KVYivdRUfZHdv7os3noa15kg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5682", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5682` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAdFJk/cmSliyjDlysCaAW1FjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwNTQwYzdjLTQwZmQtNGVmNS1hNmVkLWQyZTNhYzQxNDU2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzcxMGUwNmItNzY1\nMi00ZTU5LTljZGUtZDI3OWEzZTU3Zjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa/gD3keZVHRlHnmUYtZjF862SrgD3jPt3zTtiRvTIcRtShTk5s1V1+ct7/Ad\n0jDFYkyHneZClpGqpjvLW+KTxaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3gHygi+LlYYJM365S4XsaOUOKTYwHwYDVR0j\nBBgwFoAUB6pqIcKy1IOL1F7LVOty3Pj4BewwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBOv71+ObbSAIw6\nvM+et8aCvFbgp/L5hmL47QIChYSVpgIhAIvdOJrTZYBEuFzcASZou9q3pOQsHt6r\n2nCq44Bh6j89\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWQgJqumoAHdV88f0xZ4vAUdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDU0MGM3Yy00MGZkLTRlZjUtYTZlZC1kMmUzYWM0MTQ1NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTuHrcdmWPHCpKe12hC/BPvNTtHa41O53QDyLZhWGCF77S\njg61E+VUCa6OpCP3JE9f3T3DlKgPUvhjfD+laCgno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB6pqIcKy1IOL1F7LVOty3Pj4\nBewwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANRshYGwacP6wQE8GscNg1RgD1UayloX7vrV3lurH5O5AiEA7lW9Mt8w\nD3IuqlO+MfxQ6ZBCfhmAw7OjtS6ipBgLIy8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXAcio8W8+ykPl0/JHTBGfqOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzcxMGUwNmItNzY1Mi00ZTU5LTljZGUtZDI3OWEzZTU3Zjg1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFmOWYyOGYy\nLTNjMDUtNDhkNi1iYWU1LTY1ODY3ODBmM2U5MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCNHa74JM/d+NCNyJW/YQi2o/SNiFtZhyawYx0HWniPl5pnUjRsSy7e1\n5QEpU4HSgYzn96TcFEGud0JX1Bj9iNmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN4B8oIv\ni5WGCTN+uUuF7GjlDik2MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA5Dq41lfx+5pQuxQ5zBGOMjmEX6QYPP76XCzJ\nRd3JBOECIQCyYmfPUCQyn1N5KbHyyZ7kqGVcPn+LXZxwVOiiILsa2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5683", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5683` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAYx6tKDjTFm8uVAgACw1pXOdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmNmQxNWNlLWE4YzctNDgwOS04MzJiLWRmYjA4MzYxN2UyZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM2NWMyNzAtYjZk\nOS00ZGYwLWJiYjItYjQ3MWVlMGUyM2U3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZpS9MOenYFTX3fDGg7eLWXK8cqomiYshpktKh8mcrR4b8/4iSBJLGBbenkT/\n2FKB9h7QB7w9Yoyx4Q8Mf1KdRqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsue85iMoAlg6BBDO2u5GDCF/AWUwHwYDVR0j\nBBgwFoAUEzF+8sIxBY6mIdQry6hHBYuNoy0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA9mM7+PyE+/YB9PL/OSQc\nB8B55X/RSec1gSkT7wji6g4CIQDSjoR4FZs0XOCQGzR656yK+qVIUrd7llNouchJ\nVV8y0w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASAH8Bqgnk4fa/7FLiNAXaukMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjZkMTVjZS1hOGM3LTQ4MDktODMyYi1kZmIwODM2MTdlMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATv0PXitYB8qdqm9TBYb2wLgtFQDNWKQnCRgxjrF0IzZnEk\njkeY3PxAP4BGBP++gj79A5xE2XYMNKJwEY2wTNvDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEzF+8sIxBY6mIdQry6hHBYuN\noy0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfpSLUIDpKjLm9YnMGSvDrj+XSYn3lwL8jRdkRCucnkkCICtfMXhtkBM+\nl9vZuFH4Iy/VNf6YyLBPnsSSTsQFsM3L\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZ5urBKscQuqhl9pTQ07sZsNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM2NWMyNzAtYjZkOS00ZGYwLWJiYjItYjQ3MWVlMGUyM2U3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ0NDYxYzI0\nLTc4ZDctNDRmMC04NGE2LTgzN2NiOTFiYjZkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAMk2WZRSTmeZCe3n4mQo9/jJWVSBj+ATiHii53YYXUQJKVCQmAj4nd7\nEuNjvaqGCCADmYgacJ+UzSP9BSdBreyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLLnvOYj\nKAJYOgQQztruRgwhfwFlMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAlJ74hNvYZlD3Yeu4idoPJiRfr/huTevoJZWOM\nkHmZJgIgW5k6Xv7o/F+iE01dICEp4lOiIiOEFX8dtRW9bxEdjJ0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5684", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5684` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfGgAwIBAgISAXbqQYiKzNfmkxNOHgn6kY/jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2YzE2ZDk5LTAzOGYtNDZhOS1iOWU5LWM0OWQ4ZDVhYjUyNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmYzZWQ4ZWEtOGY1\nYS00ZGQ1LTg3NDQtMWE5OGM2MTdlMTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbCHN7kwRGvAu58OI3VkCCMt3FruqxRKqKBwjySbIyJUPi8HNGVLvqpeFq6vA\nZgkS4XVtRoaakQFKbk0yCaF5OqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhnQo0GAwFt3L+JqAChs+G9B0QlAwHwYDVR0j\nBBgwFoAUM8aD2Crm8V+fho4ySQcyYC9j+DkwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNGADBDAh8Dko53\nC1BFAl5xwZsP2FrJUjRqTePlosM31YE4zdQ8AiAC6nt1/0P+dMZgbc2PvCX9rdJZ\nIWL1OkWi1sVdX7HhkA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX4GMJRV1EANaKkCMjk7SRq1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmMxNmQ5OS0wMzhmLTQ2YTktYjllOS1jNDlkOGQ1YWI1MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvBGUuXnXgAx9v48KD3CYbkvW5lu7rEcHsVpLngOyV+vHt\n18acy5B9nru49NwTltnKyFKbDGV+ugHKDp9O049ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM8aD2Crm8V+fho4ySQcyYC9j\n+DkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPvVCGynhHbs+fjb5iQHghn6S4QeGKY0TpPLmfhBMjyUAiEAlyshsjFI\nFOucB3eI1obvCPcJtA0HTZrgsJBgGK21cgg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZ5qo2Yu8m1s7xBTUmKT3VHMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmYzZWQ4ZWEtOGY1YS00ZGQ1LTg3NDQtMWE5OGM2MTdlMTQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgxOTcyOTYy\nLWNiNjAtNGQ4MS04YjNjLWM4ODE3NDE2YjY3YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHEu3rTHoUDRM8Y/5ZioPWWNWMrL/+eRQLeZHOTtRkAPUfYKZLrWJPKo\nGA3i8eAL8Q2oCexKR6MlTCJ9MZeqooWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIZ0KNBg\nMBbdy/iagAobPhvQdEJQMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA4366wXyfc0j2YclZdxR0qVkY6mxzLbX7GeiI\nyn4LER4CIEFcceuES+3JNwIKrqs9LPywysw7WliDHF2zfPf9R5s4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5685", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5685` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAbsjxT4ZtbJDhwPgL7mKBSfJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NjliNDA5LWMzZTAtNDU2NC04OGRkLTk3NTNkMWE0YjhiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzIzMTNkODEtYzM0\nMC00ODVjLWE1YTItNDlhZTk4NWFmNzk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy56qIqO/sidjjQvWARznew8EE1WsB/dWWNh1WB9APkTYON4Sb9qw/1AmU2n7\nc1pLQf/24ELZUGIZHvDaATgvF6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuMC+XGUKHrLNCmctXifEScuYEjwwHwYDVR0j\nBBgwFoAUnjnQ0A1jacI9SF4XF6+cn3HyhrowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA+HBL\nh2oW8VjfgqJgxlviUz1j6me/HPVH8hOeX+NPg3kCIC7XCWdS341wmNeU2z9Sy/LH\nnetH9v/WfX3OpptXlxpv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdgW5m6kfWvtkZq02qv6Y+YwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDY5YjQwOS1jM2UwLTQ1NjQtODhkZC05NzUzZDFhNGI4YmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThsDzihEMj7bYq8ksubETkhq5ysJWY91bUrCsWvghPfdgO\nn2NnESW3Ipw42fvs6n1LgB3G8gmiraLoi2BQI6kZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnjnQ0A1jacI9SF4XF6+cn3Hy\nhrowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIdYSFCVu+fVwiC4jQeZTQnUlArKxWs8jcEC/oM2pEMKAiArqFw0PTgF\niXLr8ZKfaB9u5AVq1/+ZeP47SzP1NTptEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbHpkQXWKRKcEFm0FwOB3PPyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzIzMTNkODEtYzM0MC00ODVjLWE1YTItNDlhZTk4NWFmNzk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA2Nzk5NzU2\nLWNhOGQtNGRiYS1hOTg2LTg5NmE0YWM2OTg4MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE+OKgDOPNmozvsylYn1SOH9pFaouz5u5NBp6Y5sBS+adpkQ9IQWk5xM\nQssoOiaPNVuFg00hnrvuvH0pjHwWfzejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLjAvlxl\nCh6yzQpnLV4nxEnLmBI8MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiB7OE4/Xr6lWLf3RfPNjFwygjAgkcRunlGLPyyh\nMXsCpwIgQOCUvRZz287TrYRhyqKZdgY0Me2x/0Gk9H2QuhPqzAw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5686", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5686` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISARK5O7jo1x3fJZY9jRMXDLW6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MTY3OTYwLTI1NDQtNDU2YS05MDgzLTJlZGRmM2EzNGJjNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJiMWI4ODAtNjc4\nNy00NmVmLWJjMWYtNGFjOTFkNDBjOTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9mRLfc/ed5K/RGh1vRFL4YOL3+s0VrzUxL3Jq8LOZcpkgTcQLg5J6ehZLM1A\nNUr3Gfc+ZAbsr9yA6Sbl8FkIu6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPnN/8cHti+u6k5THfRC5FjQ+XihMB8GA1UdIwQY\nMBaAFDEifZW478zM45TVa0wFnUD/LNZyMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBwaKC5onbg349SDsR+Hz+2A4MZhdbb56B3\nv9SKZEZ1JgIgG3wNcmLBsMgtGwvWg3o8EnlArKcV77B2T6jW5C1Fpig=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZS+1L7/Ns0hFYyOPyglJnFIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODE2Nzk2MC0yNTQ0LTQ1NmEtOTA4My0yZWRkZjNhMzRiYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJNvGk5nqyh3e/iLikdEuTLVsLROA7UoLatFpwcb0UBZML\n0AgPsg/RBfUkP8X9XHX5AVoVVHg96OrSDQ1nl4IZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMSJ9lbjvzMzjlNVrTAWdQP8s\n1nIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMoZ0mSKZwArOKXyTg4UzkuvEroDjvu7gr5gWOoih15TAiB73j4pHhmF\nfNCrow23jmLlDhtSHuPPt9oHZpdrqKN3NA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAe9LOALZp6FoMSQokjOdMSzTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJiMWI4ODAtNjc4Ny00NmVmLWJjMWYtNGFjOTFkNDBjOTQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3MmY5YjM0\nLTc0YmMtNGNkYS1iNDQzLTQzNzg2MTU0MzQwNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNuL49Yubl4JHbI5Z37NhkGDZ6/1j8lkWiTNTtJn0y4q6hRVkdyPzau7\nbAzAmonaOUuMwNuNP47r3UuZ8vztXNGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPnN/8cH\nti+u6k5THfRC5FjQ+XihMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA6CSNivRE8ZypKeLK6VM6eQuDys1trt/ADTLA\n1LJ1lmECIAf8cN6VVRLLpwacJJ2WRRfMFElgvGKAZxNyxmCp3ELF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5687", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5687` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAeAYWO+VncW6EMhQfGP9i16gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiMmIyY2QyLWI1MzMtNGM5Ni05NTQ1LTJjMmUxN2M1ZDE3NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJmZTkwMmYtNWEy\nNC00NzQ0LWI1YWQtYTM4YWI3ZGYyOWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErJfGfXz9uU6dElj1KrD4PYL9Q6kAUk2v3NlTxc7OyIVKy0rvUa4ddfgmrHxh\nm3uI8z+vm5AyLT4S3cZ6pi6cJKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6XJgFXeobvSAJyiiAfyZHg7FkykwHwYDVR0j\nBBgwFoAULW6imqjv5WPCcJq8pftVtHoBypgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAI0uXvs11VUP\nBDEzglU+fruc5iP5MmIKwkjclkSB4aq2AiAVAwLBUbgenkBk7VehUHkjxElJ6n0E\niEAvAD7SABy4MQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVlrJQFoYeRDQ3CJ0T5UghzNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjJiMmNkMi1iNTMzLTRjOTYtOTU0NS0yYzJlMTdjNWQxNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuoNk8aX4h+YTstTjqqIMlw7rVwjSg+gZtcbKBYm+25CbO\n2Q3L9KXk0okB39YRZyf88KzRpyFHIuEBBtGfOSJBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULW6imqjv5WPCcJq8pftVtHoB\nypgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZihF+LABdbHbNJtdRJ0U2EsaXlxurxxvQF0Jh8LR4p0CIQCCe+Be75tp\nFpGE8MLQ2T9ji2IVBG3FygVOZvq6tB6v9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaw/+xUcLqRtXRlkDLPK0BCcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJmZTkwMmYtNWEyNC00NzQ0LWI1YWQtYTM4YWI3ZGYyOWIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM4MzIzNWUw\nLTA3YjgtNDdiNi05MjE3LTEwMjQwMzQ2Mjc4ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKQJN/O8mBHESJd1lkJgwcehCBZDWv4+XboHzO8X9KwV1IKqY4FyDokq\nIb/OFHoWMEed9b3TvlLIPZYFRGde6AOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOlyYBV3\nqG70gCcoogH8mR4OxZMpMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAi5WuehOMt3VybUNFJq8CqBioC+PDN5lQ8Mq7\nAxpqPmsCIA0sNUZKl+AazJyLvSqqVvUQe9oZsao7pGg2VJwmKYUL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5688", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5688` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWI6dR+frWQ1RGRYaKeIC0Q0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMjVjN2ViLTA3ZDgtNGFiMy05NGNlLWIzY2YyOWYwZmViNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYwMGU3ZWItODUx\nYi00NTFmLWJiZWUtNzI3ZDAxMjBhNGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuREYtzhJPZqmLET1vKeOVV0Bb7M8k9+aKFP0b/rM4qTi9bMDHpYa+FOWhW2P\nvHKkhvRFZYQDy7XFuDsWNPxGCqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzRHYIs8Ilc65A35GJX3rj80tJvQwHwYDVR0j\nBBgwFoAUYZ8WfSY1hUYlKNww7c3kXZcW1U4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgTqEDQQx1AADm\n2WVHe0qg4Je2p0VX62KLIYZVqcN+5jICIQCiu/B3hKC33ppVDT22Vhpx9LEo59wy\nf6N7W7QlrVT1eQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYjzmHumeQ6NgBEzJu90wG82MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjI1YzdlYi0wN2Q4LTRhYjMtOTRjZS1iM2NmMjlmMGZlYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQHC7ctlxYKsYHVC7KV1dm+uerzDh+VHxGPk6CISKjYrWs\nC4EiWRpCLZf3pj56PLaVBNxYQu6uTm4g1KJQcwaQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYZ8WfSY1hUYlKNww7c3kXZcW\n1U4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOlFuf7lzApk2B8arw270FCXugDm+5tKs+ySqZ5NeCYaAiAgvTwkqVLA\njOgI7xYfKVhucR5VAwCEeTgTjKVeHypG+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAVgBnpvrU6nbTx/Pj4nTZroGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYwMGU3ZWItODUxYi00NTFmLWJiZWUtNzI3ZDAxMjBhNGUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEzNDNkN2E0\nLWIxNTItNGY4OS04MzUxLTc1MGM2ZjE4YTVjOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI+iPd3qJexb5xeWAJnA6Vb45YGKyR6rby6Aukd5S/uKc1kHmWGVAyy+\nCrag3rj+0/z+OAHiF3cQWkH/JYT2MVqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM0R2CLP\nCJXOuQN+RiV964/NLSb0MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAnNLuOJhCrPblK9WB61zEtDk9xNawMnq/Dq2Py\n9NarHAIgQRwPVGV20t9YZcVMWxJl+eUZ/vh5rObE8y7WzkVXvlg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5689", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5689` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAQSLiHAVDgpjhjGCSzankwoFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwYjQyNTZjLWM0ZGEtNDYxNi04ZTBkLTMyMDNhYTcyZjI5NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY3MmM4MmMtMjEx\nYy00MWY0LTgyYzktOGUyZmE1YzVmMzk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE31GAJdjjTX0M9OLOsKZajyee0HsJX8/qdsVAXXQDBqMXezJ0y26o8s87GsZL\nyJT+hOYvsjeiKBqDVxdm1neKzqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3lhBX5yt404mf/N6U6uasH9kMXAwHwYDVR0j\nBBgwFoAUQhAOZSpO1bkPVe+JPOvtMgI395IwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAC0s56GlakB\nYZIHxSH8cm6U+7+HVMk+O9RMA+6sb71NAiB68SlxIL4ycPSLWdZlvXgsKIkmMN8V\nnJEoNnK25P72MA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZl6QK6GSMgtRCEddnfKxzE0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGI0MjU2Yy1jNGRhLTQ2MTYtOGUwZC0zMjAzYWE3MmYyOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARb3JA8bz3GnSKAgqz4zmSJhS9qdgW/Vig6DUAfqt3EPM/y\nstS5fRNyHYT5I2Xhr11kLYSqdl0w3eofI8k+vB2qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQhAOZSpO1bkPVe+JPOvtMgI3\n95IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA7x7qpcInM2t4eSEAWdWSMubX5K5RLx7a9IwdDz2AloCIDMPWVssR9IO\nLjHnF7rl9/xzyeBS6LsB15FLrYNDsMs0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAfFIWuk47j+xKCutwqH2qNEaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY3MmM4MmMtMjExYy00MWY0LTgyYzktOGUyZmE1YzVmMzk2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVmMzA2NDZk\nLTYwYWQtNDNjZC05N2JiLTRjNWY4MzVjNGUzMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEZXl5tNjguqh/nUztfWaYVMWMKkRaCQJYGJ1t4tSr09bKObN4yluK+j\nEoa+X3Dmoc26ceLiPaNAWQ9Zxpf8Az+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN5YQV+c\nreNOJn/zelOrmrB/ZDFwMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAaau1EUru4OPtivPoQRY9Ko425mUrd7HyIZm/8\nvguyzwIgY2zuh/i/k5oTxWv0T4rlm7lM8Zcw2+N4bNG/W6/KB6I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5690", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5690` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfd5VKlxZvBrm+BRI+6esUuuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMWYzZmMzLTAyOTctNGFhNy04NDFlLTdhZGFjNDY0MDFiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FlYmNlNWYtNTIy\nZi00ZjY1LTg5YWYtZDNlNGY4NWM3M2IwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENI/Y8WfzTcAhJSWNE4ZXVHgbv8HJC/IL2G/XoFDHmwDB7Ed/chGzyocZBGga\nYJpO0l0a1vmK2nl5HtLzTqC+laOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdgWQEatIcBNsWeo6MONmco8MFjUwHwYDVR0j\nBBgwFoAUaa1LSi74qFI195SxHFS5qkZR8+gwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAL/SC5l5bxEaNCx4ZeEWzmws47EOFqdm1MNtht6P4qfAiEA3iDnPJux7dEW\nWi/hDMWLUZa0P/lGxuZUFw49bYMkFOs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfxzujMKezeKt2qiO4Ce450mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjFmM2ZjMy0wMjk3LTRhYTctODQxZS03YWRhYzQ2NDAxYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATY1JT60QMihYzoBJ1V0+aOyFXo4VwWeHdzj4TIXXJxo6NU\n3zLKOV9Ux3mkcPRcoT5PkfyTESudHZgEuptPz0H1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaa1LSi74qFI195SxHFS5qkZR\n8+gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN2FOx2hqKDe4RUFPxg0h5iffV+nZmVK580tWyyNZEupAiBvK3SneP+l\nUIpzZZMphrDU0wPFRsQsE2k5xvIMpYiA7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbFcg/JBpi6sQ9eZKipuaa60MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FlYmNlNWYtNTIyZi00ZjY1LTg5YWYtZDNlNGY4NWM3M2IwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ4ZTEzMmI1\nLTEwYjUtNDA1NS1hZmFhLTVlZDIzN2JhOTQyMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFqtJ+rB/09PQYr0Tggp5CU63rrRjY8T4KI2SuSRAkm89PWCkk9sxmEF\n/FiqO7JSY6zBWpNxaZjc7zEMQJ/D7wmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHYFkBGr\nSHATbFnqOjDjZnKPDBY1MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAiKnMcgjwLgMG6zgpfSmGOi5Lt7yjC4gLpNl1\nq/D40aoCIAD5KmGisuz107iSqlEhYB2jjHOYMZq5rrG6tLoMescQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5691", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5691` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVAmIulHKnlXZANls3/OymhgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwOTE4OTQ2LTkzZjUtNDhhMS04ZDM0LTUyMzU2ZmJiYmU5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q5ODM3MTktM2Yx\nMi00YzE0LWI0NDgtYzFmNTYwYzgyZmRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK+1wKrnv7as8L24TBYMMMmQkyglDwDUyXYgevEBplIhTnoZs3QtSij3Tpj0y\n7F52AlWvFZFT55ZZt+nEq01wjKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9o5+jX/giehWIS9KZ0ePS1so3+AwHwYDVR0j\nBBgwFoAUUwL+h/rZG4B58FmBRBMQ+RJH+dAwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIC+/6KxBDKng+bwIL1/uHmzBdMEVD49fpLSebLm7l/E/AiEAxWdRgncngMBw\nmFeM3PppC4jOGMpcz/bvO7gxDVWXMDg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe5rsAMl7/dP8pcwqfIX1nuHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDkxODk0Ni05M2Y1LTQ4YTEtOGQzNC01MjM1NmZiYmJlOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS9uOmIGy9lidY+7q3dzXdDNBeB210/Zoafd4Sl4rUfdeN\nvxXyWNs8KAsOpjOooA7+vD00HyU/qt9xcqLv73Yio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUwL+h/rZG4B58FmBRBMQ+RJH\n+dAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOjGFJAqRGgP+tUDK+SMzc5PsaYyaErzi3hHS1rDI2v4AiEAkJC439Y+\nIe/FWzLq3UzAVZAtfM6PrAWIkneMqfH0XVw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAW29nd3Hy6jZOMjUXzMnij9WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q5ODM3MTktM2YxMi00YzE0LWI0NDgtYzFmNTYwYzgyZmRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdjNjg5N2Y4\nLTgyZTUtNGRmNy1iYjQ5LTkzYmU2MzdiOTUzOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDkdBPWvs02v2anMHC1cJKHKGUFe8tPjdHg+mB9TNcbFSVNAvNoTY/Lq\nIJFpP3Cf8TULLlvqrXzeSeeWip/hf2+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPaOfo1/\n4InoViEvSmdHj0tbKN/gMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAjxAKXOS0CgJhmZ1rKgbmQLshBLYuujfm04Os\nNe2PdnkCIQCCR0B01Tu0fEzGGvJ2dLQfQLkf8K0UfXY2X1BzfpgaYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5692", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5692` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAY9MDIX2le3t/VN6NRMuBzJDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzNzlkMDFhLWJiYmMtNGNlMi1iYTVkLWVmZjczNjQ4YzRhNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI3M2UzMmUtMzFh\nYi00OGExLWFiNWItZDgzZDk2NDhlZDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFBlsqR1PMQiNwQ5qFShkAlhL9vZtrHAvc+8bHg55C+RavrMCNQBVjgAIvda6\nAagqbMZ0A0KZSK9qQ/tPwkEMXKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgKiG6y03KD3uaWrnq1i4N1Og4AYwHwYDVR0j\nBBgwFoAU8+T5wFJ74uYzaLtBMA0ekhDVjN0wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIF2X\nJq3lfG30fD7xdKiJH1BqM8kEVkQaVu7KtRCw1X1FAiB6n8xF0+YG+uw0dV0XywBD\noE1AZpSEuk83c/TUC7Uy9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdOplFTQZGyF1KFJ/bFJgyjaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzc5ZDAxYS1iYmJjLTRjZTItYmE1ZC1lZmY3MzY0OGM0YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkg0ASB28dsO3Zu0BAXaQwyaxOwmp//KnPMhINB9okRS6Q\nMbx/pBtNGo9UlHLwBUJDHug84VQKlbYBMDaBKc4+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8+T5wFJ74uYzaLtBMA0ekhDV\njN0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWAcz75QBSbsES8fRQiqHqs0WHE+KWTxrXS6Hj4/M5fUCIQDDi2x3v37y\nGSkT3sOhB/GMlj6sQEB8312FLdVE92uSrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQjGY7hoaEDjpqYG0Ftya1WDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI3M2UzMmUtMzFhYi00OGExLWFiNWItZDgzZDk2NDhlZDI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBjZDI4YzY5\nLWYzNGYtNGUzOS05MDMwLTM0N2U2YWUwYzk5YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEjETTSNMXTzVCCKUKo03D6HJ7LSekEQIvsRIop57SlVkvEK+FnY+QNW\nXW+GjPEr5uIoy/tcg8E53SjX2gw01m6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFICohust\nNyg97mlq56tYuDdToOAGMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA0wj9pW8LV43OUvz0TV7qjdiKluVmTaaGFpFF\n3ZLOp1cCIF40w6/yIhTS5/p2qQ8D2sR4t4w0oUGFjSwQVXGV7VZB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5693", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5693` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAX9tRLzzUbpEEgrh6sv7GoSgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NDA1NDI0LTRkZDYtNDczYi1iODdlLTUxZDYzMGRhY2U1ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM4ZTY3NmYtZGEz\nMy00MTFhLThhY2EtMDE3YWU1ODMxZGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEljvo88nT4nSKfdk/65n8JXely6C5A7hzPf2n20tmanz5Ek0dUhS6kScpc0CZ\nozC9ZUVZqb+5qYxFW9kMXBXSYqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjuAYaNBM5xTu/0wVh2Vxs6MSDe4wHwYDVR0j\nBBgwFoAUnfHeJ2F3w6juk+DtG2HIykAvdAUwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIG/bC6XGIFCVvPM/LyTjnpNaegQbw+IXAx5SeCStjcxRAiB1VyrK\nKV9VhWVwA7k2nl0w6iO1J8dJFNeBUmrslgRxwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQzfRs7XbAGcFV1SZzeK7GMpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODQwNTQyNC00ZGQ2LTQ3M2ItYjg3ZS01MWQ2MzBkYWNlNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVzXQ9R21kUNsJPckNBA2t1ma3iOorHT/2CF7jiSA901Um\nw+3buk0/G8YZCo7I0maOT4IbYtFXepjstasxpRJ5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnfHeJ2F3w6juk+DtG2HIykAv\ndAUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZZG5TJUQHcuczBCl8YyLKufQgchjNs9sUdzZnvJoPaECIQCbo2DT+Dvv\nrbGeJK9JWtXN9+iLc/xmf8deGY9GK6YR1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAYdAiXER9gtW7XI/CGw/UYBPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM4ZTY3NmYtZGEzMy00MTFhLThhY2EtMDE3YWU1ODMxZGU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk4N2Q5MmJm\nLWY3YzgtNDUwOC1iZWE5LWYzNmZhODBiZjBkMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKdhY70hahAf+1u/iZmwjBZWr/KrVsJw+oQVpAWA55b8aWo41UISudpa\ny6MIUst20vvbgiNmkC0bVQ6ewJy9kD2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI7gGGjQ\nTOcU7v9MFYdlcbOjEg3uMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBmeXL6znGhvEn37mtkQBrdtxhS3D03mCkQu9fW\nP7IZmwIgZHX5Lsie8QfIwsw6kd4mGL3V17UTDIp6YQYwtboSnps=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5694", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5694` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAURRWu/or+MykhmGFb1sbs8MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyZmJlNDM0LTk3YzktNDA4Yy05ZGUwLTNhZjdiYTQxMDJiNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZmNDI0NzctNmU1\nZC00Y2IzLTgxNGMtOTc2Yjg1NGRjYTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE508niSgC/Cv3TSerAVSVHO8GYyeuwsn1Awfbrq7+sE3LegYIoy3XOYWrrcL8\nZYkq6ImzgdO4S6XUuqN547LI3qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU07fcCT+ZSrNuuWnycXLhrZ5PC5IwHwYDVR0j\nBBgwFoAUaeeYAHJ6OfD0XhW2EOUnPDubj2MwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEWYwMMq8ZQ3pfKHB2PyqJ6gtlaNokk/9ww9d0Oqd+joAiBDV+Jm\n91av4C96p3P0wYdAKvyEEbJhcOmhdk0gd8GGGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU0K+4EXjqd+IYSZoy33M2Y4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmZiZTQzNC05N2M5LTQwOGMtOWRlMC0zYWY3YmE0MTAyYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwCsBKL8SKvWoddA0e7AdyioYp98iOLw8yXAYGJZ875Qmt\nlHjL19rYcgvQRzBg4lFnlGpbZsQ69awYuf0Yvfnko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaeeYAHJ6OfD0XhW2EOUnPDub\nj2MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANedsYPew5dmfU6q5XNwpOCSqp2fSQoXrpq/IMh+GMeGAiEA1XeNPpGu\nOo/bCf25eoqK9fnNCGV7GS473pjxyxTaxeE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAX6ZA1IL1Xn7cncW6i7jXKZ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZmNDI0NzctNmU1ZC00Y2IzLTgxNGMtOTc2Yjg1NGRjYTFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM0ZWM1NDA2\nLTVjYzUtNDJiZS05YmYzLWRkYmYwNTFlNzEyMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBLUWdSjOmUZ/YSWf2JrxBHzle10QVITQNEa+AdFEym5XzjWL4zTR7b0\nm1QDkG8nG5xQuuLOQWubM3lxailKaJejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNO33Ak/\nmUqzbrlp8nFy4a2eTwuSMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA4L43rVwc2g3AaW8T6AqLf2IuWCVg0PXi2/ss\nJektXBICICn4u/HWVmEq6TtYfW9C/qADqbaJzWUZ0hk0sU0e8rvJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5695", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5695` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAboLbx+0VAglUNCulBY5iooLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlYzBkNDM3LTg2NDctNGY1My1iZDQ4LTVlNDQwNTM0MDJlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk3MTY3ZGEtZTRm\nNi00NDUxLTgwN2ItMjkyNTI3YjI4MzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7hHHFGqo8EBeiREQ2bTX22KR8d7N00w6Y46lVqYo8UQECZn0EDuA7v7G8ewu\nMzWhwBvDbi4ZO+uPO1uxPL3FwqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLL5TxCeBUKuUtM2xvrmFCz3zHGNMB8GA1UdIwQY\nMBaAFCT9xfgFY1ebaefES8qRVjMyNBfnMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAlfFENdBhTUiwm3btt1H4xQzea0l+ZJDX\nevfkmiUz+A0CIQDaTIkHUw1oBV5GQBkdBEvRzwJS9kSrqVNldud5sVuM8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARpng2vyPpXRaMD0UEPt3uVcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWMwZDQzNy04NjQ3LTRmNTMtYmQ0OC01ZTQ0MDUzNDAyZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/InRtfmedsT0ChRb82txB7AWi4SHSML1voDlEWM79onjC\nrWHjVmd85y1dUy+zaGjRyETHREPVd2LukD0CBaxEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJP3F+AVjV5tp58RLypFWMzI0\nF+cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJl+d8RxDBTfm8iN8NXZ8WTynix2y/+Uhjt4lJxsGqIwAiA52GQe/HyE\nue/udUg7HUQZ/DaFl+i9rNmNo+BlomjptQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXNjbu5Csi7VDAaHI2cqjsNZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk3MTY3ZGEtZTRmNi00NDUxLTgwN2ItMjkyNTI3YjI4MzQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY2YWE4ZTVi\nLWMyMDItNDBlZC1hNTM0LTE5MWFkNjgyNzU0OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB2c84KIoWOiMV5Ks7gcOgU5D39SM+XnM0yr/+Ba86E3b5S9zO4H7kfz\nCuB62Xkaf/cTxc0SsuFF9b2PzaGQ+majeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLL5TxCe\nBUKuUtM2xvrmFCz3zHGNMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAx+6NSlCXVjJaIPIFZ1HnVsKMFiEsCRFXe+J0\n48EHJpYCIQC/g0Wb3IqhpWWEPsHEBChbdxday+J8SFGyYXyXlk/QHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5696", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5696` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISARm1nA4eKtOUomSeLZGC0bLAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1MDI0OTM4LTE2YzktNDJiYi1hNzFiLWVhNDI5NmM4Y2U0NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzk1YjhjMTAtZDdj\nNy00MTI5LWFlYmMtOWUyMzliMWUyMzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgx2jmdNNzc+oqI64n6vMEp48aRQXvLucen2jtH+EfVPWLVdGiggFebnbN5ct\naCXhGIfES0EWemPF3bFwIDlsxqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjym0vvzTGbWXL8UPEIi8Bd8d5oowHwYDVR0j\nBBgwFoAUMnRFjeFlrWWtObQuRRpd++mUiWYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgX47Doeyxd3y6\n02Y25D9pHK8TLeLGJCv2k+63ylxHLTkCIDrNJJ8QcBHYDmIomfY+MXKmzAygFvQt\n/8Gk7E+x8YKh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUuuM4ezcp378dUOCFuMY334MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTAyNDkzOC0xNmM5LTQyYmItYTcxYi1lYTQyOTZjOGNlNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS845D2SYAcjE5b/LyA2NvSIgcEky6rSW0KavV+ozPAxEJm\n5Ye8VGe+fGpfZ1LhNV8HhY0BLdPLuJL2X/2IyQgpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMnRFjeFlrWWtObQuRRpd++mU\niWYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ39TWlmaJ6mr8941HyVV2e40CbJJImYlPbNmqzS9jvlAiEAofesZaul\nn49Tr8wNs2cptR0BDmEpASu0M402QVSxlDA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAQ3WNOKGT2TRYWQUVmryWgBIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzk1YjhjMTAtZDdjNy00MTI5LWFlYmMtOWUyMzliMWUyMzU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAyMzFlOTQx\nLTg4NjUtNGM0YS1hYjZlLTJiYTQ3MmMzY2M5NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCI+v5TSw+2ajBoXmUec1TJhckNXiURjm5fY/l7IUy3ihj59SuqGHnu9\nWFNh8PfKthosUoQ8kNIY0FCvqK5ss5KjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI8ptL78\n0xm1ly/FDxCIvAXfHeaKMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA6VRwsPw0hXE58QBQGqu9ghitkszx9J/eyfnk\n8lHlRj8CIQCFWzi0IVGY3Q0x/a3CE7eSh/7UUVEbpOwrZVmdn0FCYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5697", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5697` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAX8sSox1KlNNWV6GYo/MUPvgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5MjNjOTg0LTYzZDMtNDBjMi1hMWYxLTdjN2EwYzZlZWVjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWVmODgxYzgtMWJk\nMy00MGFlLThiYTctMDUzZGU1ZmQ0YjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1lz14YXgn0WOj0v2N7PPcRuwMjXz9lZWrCkAiBubeql+98Hbw54TJsLKB1iz\ndDtkB/SRoFqfpM7ShedvvlH7EKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYX9QtzJWFAbWqhBg6CO5ZWLreZMwHwYDVR0j\nBBgwFoAUKTMKD8fYPwhR6+8QOOG/VM9ZxWMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgApNZ4zOZccIt\nGq9MRtnGFJ9CIZlscmirsqlzwOY3yIYCIQDx6oD4ddV0SQqV3UhwrwHbED/3CIYj\npz6hnXeu1B0Omw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf8Q5rg7In175VH8OFuyrhT8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTIzYzk4NC02M2QzLTQwYzItYTFmMS03YzdhMGM2ZWVlYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaAoC6RoeQ/f+h896y+17dkFCpuZ12mTmNKQT+g7W6cuU5\nfZ2X979uW3U6fo5FDgcy9cgMzMJOPpObC6G29dYro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKTMKD8fYPwhR6+8QOOG/VM9Z\nxWMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALoOKKFYOmEQ5QXdl5/HqDJyEV4U4Zt6KKkPaFptUTK+AiBVeGpuXLhH\nn1tB6LfTFNxwlAP3tEZVP/Vg7BvCDdZMrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISASG9MX1SOzvufybueXE8AGlMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWVmODgxYzgtMWJkMy00MGFlLThiYTctMDUzZGU1ZmQ0YjFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNiZmU1Njk3\nLTk2MjYtNGVkMS05ZmQwLTJjNzlmZDZjMTU5MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP5QTO/oJSx8x99MXqLy4PrxQ0xao5sMmTbyRLzGwG8mHZdsGpvWV72n\nHcnjUwWDw3tx5Xg1qZOrBowxTvCjlC6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGF/ULcy\nVhQG1qoQYOgjuWVi63mTMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA2ZYDkN0DF86Q6bVdv+70KvlayF9U5ZvXUdWd\nnJ1bR/kCIQCbZiM21dq/FIBtx7d7uHUZjnBLrJDxhsHMhszroDwdJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5698", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5698` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAZhbb942/NrsuRwrWCps5kptMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlMzg2MTlmLTRkMmUtNGY3ZS05OWRlLTk5MzZmMTFjN2UxMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM3ODgwZDEtODEx\nNC00MWQ3LTgxMGEtMDVmODI1ZDIxMmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELCgsRlew3vlfTEssCG2WctC5NMOZ3S0rQZdAvLOmJbb0fXTWO50hwUCKBAZO\nQqeAXOI7acydMbQlmKrCTfOKDqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1FsgbiipOK/G7T+HuSVT72RnasEwHwYDVR0j\nBBgwFoAU+ktbnG0h7UUzT2duWaYfrlLjqjMwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDMJqt3Ovf0\n3/D2P5JNOxozl5FjbU5BMEyke3HkIXPRCgIhAJlfV/PGoIIyUk0CpPMs9LAzcfxA\nebN/9x2rOCOSZju+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR8d0YrdYxQ13Eacv1+Q9NoDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTM4NjE5Zi00ZDJlLTRmN2UtOTlkZS05OTM2ZjExYzdlMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqGh+I3m+vwyeiueAV/S/ewmL+DEgbEogcT/oYSlOtD3PB\nzAaWmU31v6ynoVo17oMNOcyLC99fo0kICeonF9iRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+ktbnG0h7UUzT2duWaYfrlLj\nqjMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdMQj3++Nrbb2XTXvxAigFPCW/Wl9rVtMUEtpsXbTXnoCIHE7F1+5HylB\nVfeN84NN9OOT7SXdF72eXVRVFlPaKh5R\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWbJzeFal5zg35ElbAihZdFJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM3ODgwZDEtODExNC00MWQ3LTgxMGEtMDVmODI1ZDIxMmRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGM4ZGU5MjE5\nLTY2OWItNGU4YS1iYjgzLWQzZWI0NTRjOTYwZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPEe0y0s8nBiXDE/dKFHtuevyEs58soNDcrjnFYORxpONZZq6RDd+rsx\ni9hQKvY11JaEjfU83RO45iexOKcst/ejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNRbIG4o\nqTivxu0/h7klU+9kZ2rBMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBLDm/0/RYJlH0OreAxChV8q8uHYhqPByZEHjP9\nVbeDCAIhAIBIp/0jLy/KD4Vc6wowu5sZWtPQf08hWkTybnfTyv9s\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5699", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5699` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeCUZsZL2qEQJBJ//HRrXtGpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwNDIzZDU4LWViYzItNGIwNC1iOGQwLWZiYThmNzJjNTdhZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFkYWI5NDYtZGI4\nNS00MDljLWFhZDktODEwY2FlZjJkMWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnqZiDqsmTmBhsHM7lRlyJv99YHeo9/POVe5BWSiX+kfhxlQcasPgDWH3TyI1\nz8PZpb8yKkf1rj27yNj3K081AqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdSH4H5J1Pt6Qa0KCOsj7yvgD9uowHwYDVR0j\nBBgwFoAUisa0Z6ZTiHdNXK0pIpvFTUjHR4MwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBRidKW5JyqRBY9dWOzmdZSwrCDpooX/J31rU4mVPpZjAiANDoo7gfW6JKS6\nTKRNXM0u0UTXZeeTr9osIV8H9PxcHw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVFGN7U/8fPVRRznhGNJ2bKIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDQyM2Q1OC1lYmMyLTRiMDQtYjhkMC1mYmE4ZjcyYzU3YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATesi/Pu3zL+dndIhr6fYVKcUyJg2fnYCAQEG11+3vBlA+e\nzDz+gkwhHH6e8ZP6OCcssOYkzUmPKHf4KsRi0d4Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUisa0Z6ZTiHdNXK0pIpvFTUjH\nR4MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANRS2XwaYDz9dFsx2Q/CEDPG/0E+ixNtDEJcUuwYYWBiAiEAwjnd/eSn\nhtrnbju7B9JrZB5Vp27i5CNdV5cKL69AxrE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISATjFiPbUbGILk5Rpv6Gsf0ZEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFkYWI5NDYtZGI4NS00MDljLWFhZDktODEwY2FlZjJkMWRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY3ODhjYTEx\nLWU2NmQtNGNlMS05YTZmLThmOGViNjYzOTNkZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFjpOP7l4TY9QSmNQJ60hQcwmpdMdAq4S3CYNCusdt6ofOKILmGuV4W0\nswuzY1cpWI+jxhxXoyGTe3rSDqOKMEajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHUh+B+S\ndT7ekGtCgjrI+8r4A/bqMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAtf6gxSsPVmteisfztOmkmBRRxyh88lYLLbAK\n7pQvP0ICIQCOuUE8ZvKx/CAC92yREdSa8m6umdFybodHbc6guB4Ltw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5700", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5700` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZRhbrPOlCxw4Hi+TfqJl4nWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiNTQyMDU3LWQ2YzMtNDY1NC05ZGE2LWRmOTQwNmI4ZGMyOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUyMzgwMGYtYjJj\nMy00Yjk3LTk2NjctZjU4ZWQxMDhjOWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfTlXqayDrjzxDCDCEAdWteG5TGClzvfeP2NF3KxoN73nID535xT8iNEybTZW\nTTa+YK8LjUsUO3QSZKVlIuk4nKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeUl5mwU7Bo5t3DUonjrl37HsakAwHwYDVR0j\nBBgwFoAU53U2MQYafwXE+R4oSM1DSc9hfrIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCAPzj2K99sPhMyFpJ0kWdOv4TAdBevcUa8H6P2B66KpwIhAP3BMLY+qCQk\nUdMQZyRH4R/9lxaLTeZd0Zck/67y/qft\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARMl10xuN3sqCHBC2aIf7kvmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjU0MjA1Ny1kNmMzLTQ2NTQtOWRhNi1kZjk0MDZiOGRjMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaRCIvfbsOsm7KgFGtdXJY3pSWfAzRq+sSLj3OlsJHzwel\nYA9jjffhsET+GhDe+n3hdp45WB6Wg7uJj0aJbU83o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU53U2MQYafwXE+R4oSM1DSc9h\nfrIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIge5mdPvg6A5j5xTJlfGkDgQp+ESb2ND/Uh0cD5JzwxK4CIQCs/etNqJnq\nxyhuaRpreGHlz9Mcx8JLKskUe5T1re/cNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAbp4BlLW4q5E6Xk2J0gG53TuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUyMzgwMGYtYjJjMy00Yjk3LTk2NjctZjU4ZWQxMDhjOWUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFhNzM5Mjgy\nLWRhMmMtNDY0Zi1hMTE3LTJiMmI3MTEwNmRkZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJoiCfTLn7kcn+rtVvJp0qYdC7Uyd5CyvBJhTgpDjBA/WxsUVmEp6Nx0\nZVaOse7wXTimK5THezfDZICqw29D4LajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHlJeZsF\nOwaObdw1KJ465d+x7GpAMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAoWqoA7K+jo7YL0KkLKCyu38PD+Hw3HfiAoE+\nJduo420CIQCZmBJoAQR401ldqkKrxFQrkpdW2q5WJXoLBSbPaBageg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5701", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5701` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAUbC6CnXP6/NFxwKFlJnD8lqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhZWY2YzgwLWFlZjktNDQwMi1iN2ZhLWFkMGZkMDRkYTQ3OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q3ZWM3NjItYmQz\nNS00ZGRmLWE2NzgtZWYzN2U5ZTU5NjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEODtPLASc5nAY3OoJ09IDu+FlB7fwoV9dv/5ROL8SwMRRc0SikEYVYcXrAMDw\nU+FNQ9SWoesAr1EP9N3mbRf4yqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC3TLMYGe+GbFbf6+lpvOGp2FrXQwHwYDVR0j\nBBgwFoAUBRQN90xRN1B2mv57oHGUxUIk52YwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDg\nVg4RTMzp9WiK0x1UIrUb/DGjdxi7KVwRMO8GB+S3/AIhANnTCwo33yJ0pJdoVIvc\nJYCkHimUKXebDmXZlFsOaD38\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ44LOG8+2jTYdyM83vSvo84MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWVmNmM4MC1hZWY5LTQ0MDItYjdmYS1hZDBmZDA0ZGE0NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASg4B06SrU/ADRSzEMc5FsCV2KHi0LvJB6raNbwxNlLT+C5\ngUxvNaCqDOuC14//NDIiFtzcf+PnNUQ46NyGW1Evo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBRQN90xRN1B2mv57oHGUxUIk\n52YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIQBLgGY8OL14YToK77gBKXlq0q+/ID94TJ1SLfoZ0QaAiBIOfzN206Q\n1EKLpGhxqf/hFQanJhwat5pyct0Qrq0Lzw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQdUNnZj5wDWRSCAKXplfiZDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q3ZWM3NjItYmQzNS00ZGRmLWE2NzgtZWYzN2U5ZTU5NjQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFkNWZiZWZj\nLWMyYzItNGU4Ny1hNTEyLTgxZjZkNGQzYWRhYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDmJ9vJyztpTK1Dmt5meL1yHwQIz48gr1UMe+wbjYfL6fTJdxFqG2Yic\nNo7VT3f4Yclj/9faIHFIoVDMV76mbAWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAt0yzGB\nnvhmxW3+vpabzhqdha10MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAlTuf8abGDEKmnkEkLvEkjf/guUH5L5AZMMry\nT9kSE+YCIFv9xADQVuznErhkIAtfXavmakekdduPeoaEMzVurCc/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5702", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5702` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAb7RnISeXzFQTki1rjj/65u4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2MjJlMjAxLTc5YmUtNDMxMS1hNTY4LTBmZmJjOTRlZWYyYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFjYzhjMTctMzQz\nOC00NTk2LWE4MjMtODdjMTRkNTc1YTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbTS3/lQqWncvFIv5Y7lk5n+O0+vNAkY0Ersmg3v3iolNB8UKpg6OIOTjy+XW\nogPbe3MFlIEYvaYJv5OIoQFY7aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDmymUJpAAo/yh3du1cZ65pSp4UYwHwYDVR0j\nBBgwFoAUmGR1lW1DvlxAHXNwX2HUGd+urXkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDkjt/hvVyIN/m7s3sfVzH+OLWO5GDfSskaYdIq0aMEoQIgESmF\nX0yqTgNoJTwn9fl13zcwo3923wzaUMUe5uwk7B8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWKkkBzCgR4fPOKfHp77z6/0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjIyZTIwMS03OWJlLTQzMTEtYTU2OC0wZmZiYzk0ZWVmMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnjWoN50zKRUx6qgnsgAdSaf/sbL6bqoaFAsTsCC2DCenM\n+Q33rfN250fHsoqi7XoZczlQbjYs9Yh4/ZCZGlRxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmGR1lW1DvlxAHXNwX2HUGd+u\nrXkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI5u4cK6gbrFx3ItqhkhquPGzJK4rnmC0CVcfGlSL9pVAiEA+otR7873\n22GwJBhyvjpUIcxoh+PX8/v16UnJcFUshRA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAd2fBdwyfDvG2XGxTuexR88XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFjYzhjMTctMzQzOC00NTk2LWE4MjMtODdjMTRkNTc1YTcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZiNjU3Mjdl\nLWI2ZjgtNDA3Yi05MjZlLWFhNWE4ZWRhZDAyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNqQJ1Dz8BkHE2C7DZcuKNKGNkYkuey/cJRwhlVJNxihNXE10ejQ53P7\nC31ZZSv3O7ZmFrxwx6JTVNukmyaUDwyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFA5splCa\nQAKP8od3btXGeuaUqeFGMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAdWbeTI6YczIMaDZfpquM+aXJbaGjwjaUPObtu\nPI0uhAIgcL+qmUd55lf8Pjm+f2yk/t3RfrgEYh2uAcpGFDP20Fg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5703", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5703` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAch73rRPLZjJ7j8Gvs4G3pORMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhZTJjZjY3LTcyYjEtNGEwYS1hNTVkLWJjZTNmNzVmMDIzODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTEwM2VhZTUtMTg2\nMy00MjBiLTg4MzUtY2MwNjg2Njg0MzNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwcEKhC/h39x/fw32AbZH62wz09WfKF6n11pi90ck7NklT/srY57qQ6ljlob+\noLbVjJdj5rlXGpusciVzxkl6rKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3y+sPdvILAPXQjNg7Pk+5f4NsMMwHwYDVR0j\nBBgwFoAUG1n6t1hfbGlwHd8rLFVke9JKXEowOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQD3r+uKOHGQtVztOX9Hjd6sju8u1mw1rc3pQ1poY9tmuAIhANDG\nS67fr+4oAxvCldyf4akxeYgIPAPXvxxU4TH3f/+H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb919qlkJ8Zdva5cY+kIdFbMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWUyY2Y2Ny03MmIxLTRhMGEtYTU1ZC1iY2UzZjc1ZjAyMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQA+Efcy953N6/47FSIg5SRC42Xsdkbhb+bRgTUMUN46Rnr\nmW8jW1VTQ5iootQcm/0WVcoVDS3qW7jr56nH2IWbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG1n6t1hfbGlwHd8rLFVke9JK\nXEowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc/V7OGm/ctCgT+kc0O033M9v+SKih7JoXtUZW7mRyNkCIQDLwA3f2svb\nDBD7av4kKPTHxMGtkmcxW7kY4AjHkR5tjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARVyiyKWJHHNzsT8Jw0k9+hsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTEwM2VhZTUtMTg2My00MjBiLTg4MzUtY2MwNjg2Njg0MzNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQyMTZkNzFi\nLTEyZGEtNGE2My04ODBlLWJmMzFkMzZmN2RhMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNv3hrS/8hOc46jokrM5Y9KxFNeg8egpPGos9k3efyw+389UkgfQ+Qxf\np8OwKoPezR7WmNKRK+2012NSoM0tM2ejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN8vrD3b\nyCwD10IzYOz5PuX+DbDDMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAOyiBf7Js8eKZtOd8JBBMCrdS0EeeavQC62/Rz\nUJT8tgIhAPQun9vQ5XlKbfqbUFnzgtDzOOUmuch989UBghN0bPLw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5704", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5704` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAZIN8Iyi3dIhs+xfcv6UF740MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyNzc0ZTlkLWRkZDYtNDQ4NS04MWM2LWUzNzMzZjIyZmM3YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI3MTNiZTItM2Iy\nMS00Y2QyLWFiOTEtODJkNmNkNjNkMjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGxkag/MEc85kYc2DtUp5krN/WptPshzg3aU6Y3N/Sb1djYlTI68FSmwG85Bd\nTtnqyWaq+fg2BRsDccRBTtjUe6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ+R3k0/qyg2ld7d1DSo6k/26cBETAfBgNVHSME\nGDAWgBTUSoWrX7hmZgaWF8DpQTZiaauCvTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBa+zVcjXzptKDUlRf5ITNxACykz3gut\njsQA0Lsf5L0gAiBPx7oekon/C5YLREaiPGcY+8/ur5SpPXsY2cEKGwBMQQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdWajePjzpdLL++rsgV4Ke/lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjc3NGU5ZC1kZGQ2LTQ0ODUtODFjNi1lMzczM2YyMmZjN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6bEyUj4sKvjTa9mpQnjLmLy++MCZjBUi23AEBtOxUfQxm\nNVlf0AqTPgpivRMm9n4KIDFVzOz0Q4zyRs+uhZhmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1EqFq1+4ZmYGlhfA6UE2Ymmr\ngr0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAInUYhslaUiKXIwO9fThAL8FGQaOrXwyWlXLjyDsYkasAiAj6Xt+xIwd\n4BOcKImKTdR1dSFsIqd2hOiHZsSSGQSiYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAQrWi92S+oCAqi4QZ5HsKk3GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI3MTNiZTItM2IyMS00Y2QyLWFiOTEtODJkNmNkNjNkMjVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMwYTVhMjhk\nLTM1YTUtNGZhMC1hYWNlLTJhNTQ0ODY3ZWYwOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM7EdtLdSNMnYU10DRmVuTXQjifDEc+g9pOPHrE33xCXOfM8bzqU03Pn\nsre6EsqtLoZriGMP+bC90kDOhgG/Fa6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD5HeTT+\nrKDaV3t3UNKjqT/bpwERMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAmkl7Ev234ToylMhamf7A7eJ18BTkoVSiKW5qw\nsqe4VgIgPw1tb1ftjzMwgQ6YXKa/s7nK+gsS4oy6ibCn32v4cxw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5705", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5705` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISARIxUhUnHVreoFeopnDORNEWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwMGRhODBiLTQwZDAtNGJiMi04ZTJmLTU3YTFjNWRmOWJhZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg0Y2NlMDEtZDgz\nMy00NGUzLThkOTgtMThjNDk1OWIxZWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHUTVn67axUvwwd90l/pPvFe2WvHNJVoLHgutZa3jvNSFEC4sp+buS76QH6CG\nC8aciICw1saP5WoEGhyydrPSpaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaxSZbam2+VH8vwUEivZ85z7/IIwwHwYDVR0j\nBBgwFoAUgEyUjlutF4to4Qq46rtWkbSjbbAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDfEThlNvfp\n0pZjZ6pQn+PI5vxa6zGTUMgMdYvac9RzDAIhAMuRlLpBPAe/fdz4OyY1vWvtq7+E\nIxM3CrIY1ZvGQ5CI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQAjAgkBN4ktg8mGH+U9Qj1nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDBkYTgwYi00MGQwLTRiYjItOGUyZi01N2ExYzVkZjliYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQl6EiPSZVZrpMTv6u3IB+iPqvSwV/IHyK/g4OkAAAPZJU9\nUvykmG4nKsyEqRvAryt5MlcYgKExkL4fDuKDfARVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgEyUjlutF4to4Qq46rtWkbSj\nbbAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJt9L+tF+tdr+VtkMetFPnwdolW2a5ILw2LIwZld13ZwCIQCNGL3L56Q1\nbWE/hcvWCEiwl5WZf3REEQRgOiFNNlrsjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAasGWxvP4Rv8SDzjQupK+Rp4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg0Y2NlMDEtZDgzMy00NGUzLThkOTgtMThjNDk1OWIxZWNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFjOTIxMjk1\nLTg3NjUtNDc5MC05YmYzLTI3ZjBkYTk5ZmJkNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEQQm0yOyI1dLXx+mVn1GnfC0T4H2iMVaaISGReBF2pkRVc4TsVNNbYM\nAL2uVduMgu9v0q+XQ1At1bU2g2mDpZOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGsUmW2p\ntvlR/L8FBIr2fOc+/yCMMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA+GyEDUYkPf5/oAz/ldBx2GZb5Ct0Q598bdjQ\nDeaJkU4CIQD448Ij+Etf7i9Ha5z0ZoX3X4mCQGeNMYPeehJC1kFZSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5706", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5706` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbAE/oQjJiR1RMHgrshAJRwyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhZWE2MzhlLWMxOTctNDJmZC05ZjA5LTU2Y2I3YmJjYTgwMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBkYzQ0ZGQtM2Jk\nNC00Y2Q2LTk0MDUtZWRmODVjNDljNDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEROI2nNU2tOArFf40iwcCntD03qlGxFycr6/xmIi+ZtRb7FJeIh0/vGdGCqCW\nvZBi9x8uZMtpyCn6dXabrG6056OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCIJIrpnFCVGElLNvXJ5UJXqCMekwHwYDVR0j\nBBgwFoAUTnMjWU+MeB6+OcRbycN62/mO7c8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIA5XL4sPDuNC\n0iHRbbjXb+1F04yaM59zpmoExFK8FyiwAiEA3UO0hEPRDKBxb7TFgzpy31CMvzO1\nU30hPAjaHVr4Xe0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXTohIy9MO2/coYvMquLk7w4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWVhNjM4ZS1jMTk3LTQyZmQtOWYwOS01NmNiN2JiY2E4MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbncmDlQT+fzuwUbm5/9kyFg6r2la3aH7NKmRfyZa0MF4t\n4xEuDs+POsh3F5Guk0tz29wG5DLAtaZsunJEQZvgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTnMjWU+MeB6+OcRbycN62/mO\n7c8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIAAN0cnz/YTdrvmbd//rHDI2NXbYBI8uqcnbcnC1neACIQCCUX7xQIf8\nL6GXrz5fkTs1bngY/dckKBaei0+G/xrqSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAbCJUft1xInScCtG+COx69VVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBkYzQ0ZGQtM2JkNC00Y2Q2LTk0MDUtZWRmODVjNDljNDA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAzODUyMDE0\nLWVkZWMtNGUxMS04ZDlmLTM3ZjgwZDNhODZkMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJQMw01l9GhxvG/oTpA92Zdp0emvmI1u4U5qqIF0mCGuTMR5USb7Ale1\nEoB49tpaTI26FG2e3xwMbV2tM0ruFoyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAiCSK6Z\nxQlRhJSzb1yeVCV6gjHpMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA3LCYAXVcu+4Cky0ELkfj66ICnSqvpOYwlxXQ\nZZgiaNoCIQDppE2bQTdUoMfQZFtpP9QixMbKAnGyLaVuGhwtidZllg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5707", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5707` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAVdyWjDtzEXqA0x4B2u1ctoYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4NzJhMmM5LWE2NWItNDgxZi04ZTk3LTY4MzVmMTQxYjg5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYzOGRkNGItM2Iz\nNC00YjNiLWJlNzAtMjQ2ZjQ0ZTk4YzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+ZUfFnHFg9T0lTt0sK7FDEJR7WCcL8BCnrSPwKlPT+CIvgOHo+AFyRlk+Fd2\n70JLDn4JL9H2POXG5lpgq2RR6aOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbSrUj7cr18e7BNr3w4g6XkNKzRcwHwYDVR0j\nBBgwFoAUMpmcVl0NbZZ4ZJrWHXH+HTQdJvMwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBPYxfVJHVx\no4wcBHQM5VBO99qATmMseeliCyH54hDIoAIgFhgNvL7GHkUvHpDmYWlbA1+te2AY\n89fTIgYZuAzEIGs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQNR1WAIAacmb4VxNnv2+uWdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODcyYTJjOS1hNjViLTQ4MWYtOGU5Ny02ODM1ZjE0MWI4OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvka9eWU85nIKtvNRQSoU7WoV6NL7bjZI9aIoeiJDlGbRr\nxgNoElm4JsW+8sbD9QEcUT3QUH6mSwXZBui4ggB1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMpmcVl0NbZZ4ZJrWHXH+HTQd\nJvMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALWp8UVlBYznh2gHow4lfLNBGyDDIUQRntFnpSyXJ+tjAiBkMz/dYV7P\nxTT4Plpmt7IdwV2yJdy/yUH7wibm1QbgZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAadIq3Kh0eVKPbg7KasEB7KsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYzOGRkNGItM2IzNC00YjNiLWJlNzAtMjQ2ZjQ0ZTk4YzYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQzOTdmZjE2\nLTM1ZTEtNDMxMS1hYzZhLTQ5OTA4ZDllYmI4ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFtQSowKSuILDTuqWT72rOFzWVubqvoOd1lfoZC9ryqh3YzUCM1bwoXG\n7ztjJ3lCuraJGei8fINRU8NgCXTpsqKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG0q1I+3\nK9fHuwTa98OIOl5DSs0XMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAiyMiJ91mdEZSrEE74OGh+6YWEIb2VHTjpmZw\n851Qgo8CIE8TrkyiGAozrNFTghQhXeKeWj9z2Qw4i9Lo0QWu9T2j\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5708", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5708` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAbxnOHKYjuHU72xPtbS+UhQ+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwMzVmZDc2LWQ3MjAtNDRhZi1iYWFjLTFkYzg0MGMzNTczNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc3MTQ1MjgtMWJl\nMS00ZGNlLWJhYmQtZGRhNTNmNGNhZjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9iWhUp/+xdg2iQFxBDAke63HeFRzmE1JnbXR5k9doUx16siYutJsJyNhwvJo\nDvX8xxrbnX9UerH8Mip31s3KdKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhlTtSsrPzzLcB9wzmhOXD1rLsgAwHwYDVR0j\nBBgwFoAU16+QBtD8GqNzxQccGjLFyfPCDyIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA7wDR8UyyNuVz1Ft8AWbC4dozzQOn8j8DVz/Bv7Es86cCIQCw1InQkLeL\nHv/+jpeJ3ujTBMQ7y1e6q7nLQTJ98QiJUg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUVdJ9B7SgLv/P49BGIorXsxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDM1ZmQ3Ni1kNzIwLTQ0YWYtYmFhYy0xZGM4NDBjMzU3MzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIRFEZKl5L7jeqsKP1gJqtENSB1ikKDqxMa3EuGrW0540a\nmMc1yf+zSLIcY+OYCtJT+OlWwUfMLTg3L544Kpf1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU16+QBtD8GqNzxQccGjLFyfPC\nDyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKMZMQAhQi7Zastd1NpHl+VLDKNoJ+JGPCaMhmPap0NeAiAIck3VDmqN\nIPumvzakiDi0ay/hhGKQYIKoYEypAVZYcg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASZ2R1qy6cjLNZ9MiJQdkUz1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc3MTQ1MjgtMWJlMS00ZGNlLWJhYmQtZGRhNTNmNGNhZjAzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDIxOGNhYzI0\nLWM2YTctNDBmOS1iMjM3LTI3NGQ1MDczZmU2NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCj6vDZ0/4Odopo5VsK4DCXLjvbaJ2h4d0GmESBCY/zIMCiqh6sh4NKv\nFtPl7uwMqMa1Y4LXEsDkRZroEI22w9mjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIZU7UrK\nz88y3AfcM5oTlw9ay7IAMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAtS/9abKrWfnySu/8RcSo0Jyd2LxyVwOs7UgL\nNz1uKzwCIH4ErISo3WnqD7jT8sC0j/ceUTopeAS5cJQ7npS4oU8k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5709", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5709` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZ378hwlg14iBuQOEowuF6X6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmOWYxMjBhLTkxZDQtNGNiOS05MDBlLTZkY2IzNGVmZWNkYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RiZjc1ZTgtYzA3\nZS00OTExLTk4NWMtNWRhMzA4YmVjYThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX0U5H9qZ132SVSDgeeLn8hL7XFK0PYBqge9b8tDLGIr5WEYVy7EP7N2Zlv4m\n2Pz67u3J2Iksm/BJphpzmFtOqKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqyKLHhKN7SVC+G6lHw1ZcPKBNTQwHwYDVR0j\nBBgwFoAUhifTIkYKDIzv2M1oMIMLVjfN5I4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiBai7rNjStfoT7PFpDNg24qR+Y4b1ooPPk6xojWHWtxLAIgOWe3op148Fc5\nF/jXXWyYU1hBN1f/8f+IBU7QXzpA2UM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfIVmVL8IjCQay7oRcehwFtpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjlmMTIwYS05MWQ0LTRjYjktOTAwZS02ZGNiMzRlZmVjZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7dpL+Nz1o5gJpQz69loDmS0XGkXMDmyxeOidbARcQmYNR\nEhIBVG1Vujus7QPy9TRcPXgm/ZJgxu+XnEN9VQxbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhifTIkYKDIzv2M1oMIMLVjfN\n5I4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL5frXS+z+Eglz22JGHpOA3mOciE0/xn6EGNGMKWWVE7AiBAHSgtBjBe\nAW1kVrEVM7QEIbdmNmVxTSSAoa4iLtASQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbgg/AKemGcBSQ7hPOkFEn34MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RiZjc1ZTgtYzA3ZS00OTExLTk4NWMtNWRhMzA4YmVjYThlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRiMWM1MmZm\nLWIzODgtNGVlMC1iYzYwLTUzY2YzZmYyZGI2YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPHsX/G6XLr/ARCK/WDVRLpsQzRNMonvzaZN6QC0fua5ctXXfpOmCNgI\nsXwkv+M4TAxFu224DAMEjuIzey7y2SijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKsiix4S\nje0lQvhupR8NWXDygTU0MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAJB3NBy0uFTalH/IzDDUDzKEXhbv9WUMOQrZmG\n/VmCLwIhAL0HtfkIwe6Yl9xic+AVv2EPmOVN9EC6YzTcGJg8I+Gx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5710", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5710` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAWVj5/DYZ1BkZCXZ1njlQ9PHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMDAyMTQ1LTcxNzYtNDY3Yi04NjZiLWEyNzNiYzk5NDJlYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzk0MDI2OTItZWZm\nMC00MzIwLWE3MzktMWM1MjZiYjY0M2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBgmCa1Er59vWyw1sNl1gE0q0ZsuGIn09+Ooc5GmVVhVKKx4AghiQdf5+CHzC\nJVDkLjZHzm3ZWo8SES/krKcRD6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzW1gKdQAmCM+vObgpE21tQyR5S4wHwYDVR0j\nBBgwFoAUYBMTgfVZ2YHk7R0f8JUc7YK4Az0wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBq\nZRhndG0K0hqIrGUoSQe6iGeAdhj4M4kAf4zfZeKsYAIgOhQBORZX74lzAEwgh4jn\n5R2P0Z3myxAXN3+1Y3Bqj4E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY7SR6WBH8GDj8lV4TbHWWXnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzAwMjE0NS03MTc2LTQ2N2ItODY2Yi1hMjczYmM5OTQyZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAQuiZ/zN4+UgARGXtmXgsLIQMkUkz/M8g8ndazqTs0ARk\nH8dHXQ7A0lYu75Bd9XQ3x9dPGyVOTK4aGKbo9V02o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYBMTgfVZ2YHk7R0f8JUc7YK4\nAz0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeQI8lMR9mItNb8sFJZHgX0nceO7XLTheWHNLcDmRkDACIQDO0lhMLoMI\ne/AG5alnAXfU14UG5pJ4QrdbbYKxbEZG/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAX8D6RjRSGe2jwxCeugL0fM6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzk0MDI2OTItZWZmMC00MzIwLWE3MzktMWM1MjZiYjY0M2NiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQzOGEyMTI5\nLTBiNzAtNDBhYS05Y2RlLTNkMjlmYjc0NzM0NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE7JclFxgO4Atvzou721Z7o5JqsxZJDUMEBKjmNLinjC1kjFHTvhaelQ\nvdskV3GS9yF7sbl8iqxYARhdXDkuO+CjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM1tYCnU\nAJgjPrzm4KRNtbUMkeUuMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAvJ3/je7HOkwMlIKg85/Dt8nkikfgWNuhbdfI\nbYe4Y/ECIAix9pi3NMgQi6L5O+FSDVnz0RNcvlKWIjPh+ZwUx39a\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5711", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5711` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAe3dhq9flXY7mDdNT02mLNrhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMTM1NmMwLWMxNGQtNDFlMi1hZjU0LTRjNTNmNmZiNzcxNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzlhY2ZjY2ItMTk4\nNy00ZTU2LTljYjEtOTg1MGYzMDNiMDA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE4xkeF+e3wQpsKgA/54cqg23pwk7S7YuPaUAa5vu2pzh6h4tQCDz/FzG9Yoy\n6uA2nrBAxbPn51EnFaw16kViMaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN5MW53DaGmHiMrk0d4uQybCfBKYwHwYDVR0j\nBBgwFoAUDI4OTBizFRJ3ZTtLEokEiCVIlVIwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiB7TgXa4IF5g+b6bbGVW4MyMJ9B72wMKanqfQ33/EIjzAIgDBlb\n0f9mvG00Z55HnqWDsAQTgvdPIkBWk/mGKEGxHwU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUW1uUpDhIGdV6LJsxQsRiFAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzEzNTZjMC1jMTRkLTQxZTItYWY1NC00YzUzZjZmYjc3MTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiZA6rxgZsfhxDla2JLZkUPvaziBRE7OUa+Dtqq4PqweAJ\ne8oWatcDt1cBJ+6z4GuC6ffKTyQhzMYVdbozQ+JHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDI4OTBizFRJ3ZTtLEokEiCVI\nlVIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgacWTSKMrGTNxfuTsobSmXm2jhTOsiWhJdTXilE6xpQwCIQCG09TiESZj\n4ttre8dzrSPaK4kYsmrTOC0ABCB8kvYvWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISASIV9Zwg0Wh0XOPGQpfAf6iYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzlhY2ZjY2ItMTk4Ny00ZTU2LTljYjEtOTg1MGYzMDNiMDA2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI5YjY0ZDY1\nLTJjZTgtNDc3NS05MDUwLTY3ODVlODNjZWM4YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABF9VE7iYS0w+tf9BYmWpOgNnVHGfxOkqODFuhTZIP8zc6GDacYb2p58i\nXCVrcSCVVzq48XaliVnR+l9trvXlQJGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDeTFudw\n2hph4jK5NHeLkMmwnwSmMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAnaBmRPOylX2xnceVPFVGVx0sT7d+zlOyXFv0\nxbGV96kCIQD2FGosmAWclljzugnBs0B1ec/obiw8bWSNtlGrU3LBOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5712", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5712` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQdmBc7aEGbV0uePW2v4J4mxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MGRkYmVlLTllNDgtNGFjOS1iYjM5LWJiNjgzNmFiYjM1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWEzMjdkMGMtOTM5\nYy00MGNlLWJlYjgtOWI4M2I4MDkxNzRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQAt3ky6Eg7M4rmGMFFcFoN4La2w9S0X3hhvRHUTdXEY9eeaz9vBO6G8Mrntl\nn4xw/E9eIZptx8sDExAem1vEAaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfUlKQH48oPQGKKek1I/VPBbXBscwHwYDVR0j\nBBgwFoAUMfD8DA37X7C8Ayp1C/hyFaPT1yEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiARz2IZ8aZYYmt3XG7gJmkPVmpnussb+j5+PWdtLtoxOQIhALZa\nmp3GN9hM9qSfZK2nYrJJZc7ndKJz0Tm9MAMzCbVS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARJxzYwtaosBHw7aoQzP9uGxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTBkZGJlZS05ZTQ4LTRhYzktYmIzOS1iYjY4MzZhYmIzNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyXvtH/7HH+Oz3/PjlOavAZg6i2Efv0icghY6N/rTu/8Cw\nBSbqgr/EJeeDK3bXvgohaA32ETlYODTEhzzEA0yUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMfD8DA37X7C8Ayp1C/hyFaPT\n1yEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOBRsWPBD3BXR8nsBaJTbguN363WYydX7TwrCsfaQ/MiAiANW5LXGLMX\nzDAIeM61KZZYAFXR7uwwYywple+ICpMdBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAZM4JvfePFq9kXGlUAAfh/APMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWEzMjdkMGMtOTM5Yy00MGNlLWJlYjgtOWI4M2I4MDkxNzRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQzNmFjMDMx\nLTg3MmUtNDI1YS04NTZjLTA2YTYyMDk5MjQ2MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC7U4py/TamPfawcbl3Kl/5QahpZCeu3ENQM2Z/5w4XwrOQTSiKHlj2B\nfbEhZ5UdKZ36GqVNoTKjpx3BBi5WUTajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH1JSkB+\nPKD0BiinpNSP1TwW1wbHMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAqwSZI41edg+kIBFrROQAtAdn3osLfRZ6OgHZ\nwejpBh4CIQDyh38uA7gEwv70vG58tyGZBi20bXKr2lpaql3Zo1+BTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5713", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5713` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISARRg6VUIyDWBPdKY9pKnlb57MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0YzkyZDY2LTZkZGEtNDk0OC04M2FlLWM5MmNjMTI0YWVmODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NjZDExYWQtNWJj\nNy00OWVhLTg3YTYtZWU2N2UzMmJhNjM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEalkCTLUtmLYfVlgBuZUBzc8KtLLzKlVC7eDCIT4IxxLFkBsNSW3DrX/Dt5z/\nPNuLcMLsX1bW5/uw0lKrLH4ZUqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXnmcqB4HXpaMP6mAVriBRholb34wHwYDVR0j\nBBgwFoAUd8pCmMn2Gg3Ra+H8e38Vtw/KjdQwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAuTgnStLK9rzb\ntTRz/lG8K6sFkeCSciG1gQnnL3xNo7UCIQDZZb87XYs/5SZUnM8oORTeYmQkneKD\nulWx6FGwRhRpQA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVJHPBSl9/AvIYMpHXREUlUoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGM5MmQ2Ni02ZGRhLTQ5NDgtODNhZS1jOTJjYzEyNGFlZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPXWcG5O2uNyyDZQi/4Gk3BMmjxxNEqCkLKvoz8t73gYfE\nCAR56YAxq6+5OaXd6nz0Dv152+Tg5/iYuMHhnOcvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd8pCmMn2Gg3Ra+H8e38Vtw/K\njdQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMzU2sD8woWPRleAEww5aHy1iror0+zG50dNHs6cpqjICIQCSVXBFk58e\nK4Dv8quZhTLZBFYT2aA4GSWqzR+k+fYPFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAczcTq5Yp05FVa3z78DbJ28oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NjZDExYWQtNWJjNy00OWVhLTg3YTYtZWU2N2UzMmJhNjM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA0ZjdhYjRm\nLTdjN2QtNGZhOC04ODcxLTBlYzRmYjBhZDhjYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOq7LlKr+EctjXNHXxhJG+sb/wXftA9BF1YllXkNS+5xGpj0HXRTa/l3\n/sEtbNzaAro+OVseqNRBL7nGgwfUTfWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF55nKge\nB16WjD+pgFa4gUYaJW9+MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA1yQ6TZJoaYhIaq61h6oaKQaGskcdHFq9QKlpe\nH4F2zgIgFTQ1frCNJq3VN//jJmcae3UEUvt9XJWF0kludP7/fzM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5714", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5714` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVYdRjNaMXC0qlQPEiq2xKR6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0YTEzZmRmLTM0ZGEtNDAzNy05OGNkLWRmMzMzZjM4ZmMyZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODkxZDVhNTMtMGI1\nNy00YmQ1LWJhYjgtYmEzMTIxODQxMjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEadKFN4iE7B8xPa0BDnBHmV/v4NPZvS/ckVYsrdCNLz0BKOOhH7tCrGlQhVoN\nYe+E0bvVncRACxALNdmHKTG6y6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8qP5Y3EnR++SLnlmDxEVQjBKgRwwHwYDVR0j\nBBgwFoAUjTQ6rZ2jrcHNosv0XIwi/DdVdpswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDToyJKEIuvWN50RDvM6vHZxgEDm/yebUwESDGThEcDvgIgbwCcrRNcBW8t\nolk+CFDM6rXpP1IY8CWOt+Ft3YhVizE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWREJJXi71dGvEZ1tHeiGEuxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGExM2ZkZi0zNGRhLTQwMzctOThjZC1kZjMzM2YzOGZjMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbC6fLmEqLy7ziM5+E8tK5yO75AslZUA+Ba3PMg0WqrGn+\nVnbsYWghgRlS/S1YKuC6tvxaC2rstmFy2BmgbwjBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjTQ6rZ2jrcHNosv0XIwi/DdV\ndpswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALj2kceFEHxsQAs9kmVYFrZ/iRZqjKVu6ut63a9W9KWfAiBuVTWNUD+2\nex5iBtGk9oSkRyqIuN4EYsPzcUyK8TVeUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAURS6X0EnVdWulIIf6XZa44kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODkxZDVhNTMtMGI1Ny00YmQ1LWJhYjgtYmEzMTIxODQxMjAzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFlZWRhM2Fi\nLWQ1NjUtNDIzNC04NTE0LTZmODI1MWE3ZTUyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNjPN2d9RNokFp6Q+S7pxZ5LzgI0vdTZfbI9wY2Nh1ph17HBZa7dNPM2\n++qUQw+r/OKHLqO+qEGotMByUfQv/EmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPKj+WNx\nJ0fvki55Zg8RFUIwSoEcMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAp7BJsp7UsFkzuL80fViEwRq4GqYsGH4jVysa\nr54q424CICGCklw+EenMsUjbBe9sZIcyVg9/1/AsRCSk8NFNrKnW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5715", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5715` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbvVWaOy30OYdpVkESV7mITVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllMmZmZDlmLTBjNDMtNDAwMy04MWI1LTk1YjM4YjdjZmE3ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWU5MTk2ZmItYzRm\nMS00ZTA3LWE4NjItNTBkNTc1MGVhNmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvFs0Udm8PFLdP31UuBMI7pmU1UBS0sicoQeuT2REyNJTAtMoMyTQQ60baP3R\nWnCuDQb4T+G5b30Z8tDXha4vrKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB01cANcYnEO/kRvcQxIkKrsJj5UwHwYDVR0j\nBBgwFoAUC4csy6SyohzpbVXyorwJZmZqn8gwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCxlJPXOmmEt58IpySYshD6Byld9dAIRQxBmF1lW1ucWAIhAL1KZXNYbGRw\nvtSt6u9YVEvilctistcQDvB0BA+lJb1R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASxTm/aoGdx+34mTyIU019muMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTJmZmQ5Zi0wYzQzLTQwMDMtODFiNS05NWIzOGI3Y2ZhN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGSGC8eIb2FJbdvfkZTv0GRQCunYp4rpi5P1eTIeVpvZ6G\nDvdIDLI1b3t84rAv82NdYAOPC0MY5+LA5VE70Syto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC4csy6SyohzpbVXyorwJZmZq\nn8gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZs64Gsa/hocu5jcruidfJ5fwK3WicEgP/8RnxJLoYJECIQCvvhUIBHX4\nSWgxcrE4B6pDw78yEEtAXHqzdwlRtLT7WQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAYg/B0Ie/5L3+Wn/hkIiq9OwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWU5MTk2ZmItYzRmMS00ZTA3LWE4NjItNTBkNTc1MGVhNmQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUwZTI2MjU0\nLTkwYzEtNDU2ZS1hNmRiLTA0ZmYwN2U1MTQyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC3h0CKr4XgW2UCQ0tBda8XVZLDASFCyyBbUr6F8C7iEK5wfm9Givw/v\nj+aonbp6X4kPMorFSTq6BafoM9ca3ImjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAdNXADX\nGJxDv5Eb3EMSJCq7CY+VMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA6Vd63M0Zn/EouFWBWgnLSBl8WUdYbXv753sY\nXPMVClACIQDT0/ft+CZQAt9miyfFTJZ0Z7t2ja+GBg13g006gyGqMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5716", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5716` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfzP/pxOBXtcC2RZWjhXOGbvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjODIyNDVmLWE4MzItNDExMC04ODQ3LWY5OGJkMjk4ZDkwMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2IwZTc3NjQtNjc3\nZS00NGZkLWI2N2ItNTFmZjY1ZGM0NWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzkzGZWbxPlL5WPJyNHwxItpWzNdTFrvgDSg5CP1c7+Qm46JQsOsRoCZx9QT5\nr52UxRfowGXLCLm203vQgX4xB6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbsbzStuSfRKzfnYbzv9LqRPTE2swHwYDVR0j\nBBgwFoAUBbMuxUZII2L4SX+Cx3hL9aL0iUAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAu9t3Ufn3HjA36DcmX+T6Uitqs1NfN9x5bz0OiO8SuS8CIDkm2uEfQeiu\nzw840Kz0m0f1YpcjYlWRsXsn2u/czzlg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfMHy7maCS9CAcCerP8Wpk8CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzgyMjQ1Zi1hODMyLTQxMTAtODg0Ny1mOThiZDI5OGQ5MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXlpicRyDoL3KksTQr4McEysd2rRKd2U7JWyQ/TWSTsV56\nGKe/7OAMaPs/gjyjylMylmRtzsNMFII8eDgWhpNwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBbMuxUZII2L4SX+Cx3hL9aL0\niUAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK+GUtaMxPedbjpXWHkb/PlfnGaaJqj8LTrryudlpKNpAiEA1KejosiY\nvpAAvr/pY/4N7rA4YbMb9OVZRL5Z95W3wyM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAT/XubLMJl+GRCyOXbnoNZstMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2IwZTc3NjQtNjc3ZS00NGZkLWI2N2ItNTFmZjY1ZGM0NWFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU3YTE4MTcy\nLWYyMzUtNDAwZC05NjU4LWU3YTk4YmI4NTg2MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFOnDhrHeGk7mdIW9cPDNI9bk+3v/N8VW2LCFCM/0RLNYMYkJYo1Rx4B\nfq1FaBnpmBPs7c59hcE7p64kGc9Rf8GjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFG7G80rb\nkn0Ss352G87/S6kT0xNrMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAkmVQSdSSgdMATg6fo+OD2qeiV4WIVDUWaJsR\nZAAXxykCIHTwH0LXA6QS/cIzyl/TAqQOtauebBrSNP2gdSAJnkTu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5717", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5717` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVn+nvtLf0R7IIWqvi4FPQHBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjOTc1YjczLTUxNTYtNDAzYi04ZTUyLTA0ZDNlMzljODcxNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYzOWQ4YmYtNTMy\nYi00NGUyLWI4NDUtYWUzMjJhYWYzNDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvMPxQVUPnIGUJ+XxGxVPAvaAoRHsWpC6qC7Dbr8CDT2BBQ/7Tgl1tsZuCWcs\n0N4ypYcD7qNHTBJtqiFBhbuTP6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAod/C+RSJoAV+L5fAqDvbs8ruBswHwYDVR0j\nBBgwFoAUH5wxLk4xuwKnf3vTUJHuxsxC8AEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiB/owZuJg8Yi+FuAK/lXKAga+y001gO/vNrBScYtGQ8\nXAIhANDolC7h6Xiz4yQRfWWQaA2Doh97No8IFyxhf1QrTNKF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbkifKXR5JfXUd0xip+WHNN5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzk3NWI3My01MTU2LTQwM2ItOGU1Mi0wNGQzZTM5Yzg3MTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjMwAofucldW1X/crxEJee2tKlVbFz7snN16/vUDfhnGsK\nWTr9Yh1lQFFx3k7+mepV2o15uJuZRk3xLL/CTBWpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH5wxLk4xuwKnf3vTUJHuxsxC\n8AEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJUm4+lcWxVgALQ2VbjrC89Zg9YQdfL5+0uYd4qBxvw4CIQCKwVIRPLKE\ndAObpfVji9QRgdieke9VhpIyEfulXQXqeg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAX4ybLohC5jVe/76xTWem7lhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYzOWQ4YmYtNTMyYi00NGUyLWI4NDUtYWUzMjJhYWYzNDAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU1NDk4M2Mx\nLTg3N2YtNGYyZS1iOGY3LTUwNDZmZmEzYTViOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIsEdjnaVGcYQvVpaV49kCGTTzs9PqMKpLDqZTK4g0bpdwuyHIwZ3JDh\n8jV/6YwWvJjolhP/8p9kmWjjV5EhdfWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAKHfwvk\nUiaAFfi+XwKg727PK7gbMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA6Zp1vCwwM+Y+jAwjUgf03svr7Viix0v7HUwH\n3w6kuT4CIQCfTyEwczBzz12NVD3ENdztPCop+FVIbXy8NaR6r95Q/A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5718", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5718` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQmzAt2tzxiyjUEdIfCIs1slMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzOWI1NDQyLTM3ZDItNDkwOS04ZDM0LTMzYWVkYzFmYmJlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJlMjE0NzgtNDRi\nMC00NzRlLWJkMzgtNjU3OGUxNGVmYmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZuoaRf1yVwWo+FgUJKlseaKngVw0EBNj3OURxuVAkfinlL/B0NLNBL9uWX87\nVygpOJucTiioC10r984rpIM//aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4o0O4vMcwSc2+u/O7ZkQN8mhOaYwHwYDVR0j\nBBgwFoAUTw/K0BFMERjy2kTe65o9/HFDpk8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAgH+p3rb3A3GjsNWrnFzTbFKpSP11pGN3XQeTh6kCr\nfgIhALuSjXAfp4zXnDwPeRJODdkl9Q9sVYt1OEGXZ9eCSxly\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc5ew1V5pwRaeu+nM+GUvYGTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzliNTQ0Mi0zN2QyLTQ5MDktOGQzNC0zM2FlZGMxZmJiZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxezVNaBAIzko64m5rF0C44/o0hHJ5+pLpdcolbvyaNBox\nzQriC2GKg8HhsLyxkGKc4hf8VurZ9yfgf7KC0QXeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTw/K0BFMERjy2kTe65o9/HFD\npk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRbrM0xSL2egECOqWaOzTlO1ULWH+2hAKs9xaXy5zQjcCIDFgjmok9lui\nf5QlUmiuoPgQHaiZiogZuakZDFteSf72\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAUcaS+G/cqX+lzDRo92vO6frMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJlMjE0NzgtNDRiMC00NzRlLWJkMzgtNjU3OGUxNGVmYmMzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ1YmZiZTUx\nLThhNmItNGU1My1hYjQzLTMyNDEzMjA2NzgxMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFy+cUlLsw2g28FPlZs4v5rsj0xQxUgRRaAf8jw9Jh5+R+Q6xzOO3s9j\nZIM7EPh9CquHJGkpligWbDcFbWEzAN+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOKNDuLz\nHMEnNvrvzu2ZEDfJoTmmMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBHae5G0yZ/sIkLx4gUreImIj4ggamdVRtkB4bO\nrasNyQIgBpZuKgQS8AYiBld5T+l2TFnVqwPCqrbHRZSPlYPoSEg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5719", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5719` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAZ2G3YPlHrRRwhNE//WYmu6sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4Yzc2Y2VhLWY4OWEtNDg1My05NzY0LWY0ODEyNzNjOWZmOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJkY2ZiNGItMDhk\nOC00NTg1LWE4ZGMtNGRlM2E4ZGQ1ODU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET2MHPeUeVRCvN7or6WxRo2JuoBAImmJFLLCWFKassjNhF6tkvC5/y/b3CN77\nEUCintH19/gkERoZjNGq4N0ICaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmSI7QqwiZbri9Nc5nVG5Gi3ipcYwHwYDVR0j\nBBgwFoAUE2m3PsVjotWcrzcoYnNsS1ijiY0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAIr96Vc4d8jSasZ0Cwf7Gp9vlTdA9frGeLDHVs4SBa7wIgdtC5\n724+88yj7Wasp5LAI3S/FoKEX7CX0kJJE53ColI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUH9AMykE/DQbhYcVaiNJ3UeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGM3NmNlYS1mODlhLTQ4NTMtOTc2NC1mNDgxMjczYzlmZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnbmdAd+jRJ5m6JwX4f4+UzCzA4hCo6oRaN6zbwQIau+lT\nLZ2sdtGXxOPoWcFOOeLKN4GjCt3/5io6DS7mhEaho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE2m3PsVjotWcrzcoYnNsS1ij\niY0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKtDfeCMPXUj2sHIWBxO99ga8Vj+KUYjrOekrKSQ5zu1AiEAkt9UKnFY\nBZcPjBt5SNYcJ4Zwk/LU4mtzXkXawlrNogI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATUo6oz0GUaea5qFH6bO8ljKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJkY2ZiNGItMDhkOC00NTg1LWE4ZGMtNGRlM2E4ZGQ1ODU0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY0ZTVlYWNh\nLTI4ZGUtNGU5MS04ZTk4LTlmNGQ1ZDM0ZmE4YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNZDqY9FUMvsBNiFmIYUmazVMNB50kbXTYPi+LykaYVsmOrJ2VzBefKg\nZxLZ1bc1dhBn/UPBm2U+B/4bA3zCeCWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJkiO0Ks\nImW64vTXOZ1RuRot4qXGMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBvkDIh3sFQCM5b7+alWaYUp4C+UtDEW4E+Ud0e\noxYp3QIhAPcPuKgfV8XIDPRVHS8i2+5jrbOVoIbLr8k1G+su5+tj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5720", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5720` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdFj/n0Pz6B/m9EHM8dNDcfQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1MzBkYzFlLTA1M2EtNGEzYy1iMmFkLTdjMDk2Y2I0NmIyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JmODcwNjAtOTgy\nOS00ZmI4LTljZDYtYzE3MTY0NTM2YjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeMfVmhNonvFV19KIr/eUxEynW3rLQaMS7bLmHVX/7XkXMIiK0FahZ5Kh2PzE\nSh/lbd5VGkkZO4Csy0mK9OX0VaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGGdWhuMKKJvzV9O0MESwVo4NIlUwHwYDVR0j\nBBgwFoAUOAPNzoP49jajk/0ccaD6/OhGviswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAuq6/3hpVclhTXAwHAGGeal1da26w0sXj\ngBwVY4hvI08CIE3fWCiqCg1gX+EXC8j1+XGx00J31Q/W9555Lpt+65rS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfakCu+S7w6Kx67I+UFTvKGAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTMwZGMxZS0wNTNhLTRhM2MtYjJhZC03YzA5NmNiNDZiMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDHdKsnFlqGgensm2T45oclhWdK+V/tDdHIDt0t9GyvTbt\nhU4I83IQT0dnvPiDAMR32kBLISIR6PAkxPeqJSlIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOAPNzoP49jajk/0ccaD6/OhG\nviswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMXNlN6OHdICgAfc3Oz0AQMGgZMQUpIa+L42FMGB6RqBAiAyuwQ5yLOn\nlcxO0x5xStDFYpaCtjHQmLnPmIQB6hlOlA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUH4Xvhd4J3Ut/blXqkt/QcxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JmODcwNjAtOTgyOS00ZmI4LTljZDYtYzE3MTY0NTM2YjAyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNjZWRiNzU2\nLTg4YmMtNGMwZS1iZTBkLTdmMTRjNjhjZWJlNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMoh8DMdbR2RF7uC7Ba9JhpXFSei+1RCJ4gSfK32jjGhVJb72pQRfI3Q\nQ1YnYB0n5FYjIr5izBJkCcLP8RPKH2GjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBhnVobj\nCiib81fTtDBEsFaODSJVMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAqn8iFBsAl9ogyaS10eb7SCN5bYmXNJxHPJH3\ncJ6bztsCIGR8MTmi/j3AWU3uMy2/dmPrqVfhsTPQp1sxHy809kE1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5721", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5721` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAYcy1bUDxbrL/NHo9oN+4itIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjN2Q3MDlkLWJhOTgtNDJlNS1hZjIwLWYwMTNlMGYwMTA1OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTllZWUxNTItMmZl\nMy00OWQ0LWFjNWYtYjI4MTA4MTVlNGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESrjZYXKZKyWL4A7902SaUafU8hQJZHLZuOpVa15QWkOWvaNU1XSmLHqKvKTM\n+rwzudf5Spe6er2KipnJJPssF6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUfYpIRcx+2c4mYa60B47P8uc2CkwHwYDVR0j\nBBgwFoAUBxdHSgb/zjLDOKPAR/x61aDxpeYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB+25RW0MDTUqMmAmdpKfw1QNBBQdXN6Nk5\nSSwnjkp0xQIgHSMMaIyKQvBo+tutuRijzebKJqC3eji5JBC7IjaKEAg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARWQ7y6hKgN6TUx1qllTl9CBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzdkNzA5ZC1iYTk4LTQyZTUtYWYyMC1mMDEzZTBmMDEwNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATi3cz1Mh5niOgS70Gg+OfOKViT1LS+PrMGDJXHRf0QV52j\nQ3IYnQoL35rTRna51HnqSpzupq6vunEvuBun7tkKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBxdHSgb/zjLDOKPAR/x61aDx\npeYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIx8AC0puYuhQVb2zLO4kreMMUWznf3H6fdhPxlYRWZdAiA6fbbNH9Ir\ngXakmvR/st9qxXfvnILs6oV39m/gHxwEIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaRgJyRxH/WA0TPL2hSSafQOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTllZWUxNTItMmZlMy00OWQ0LWFjNWYtYjI4MTA4MTVlNGIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYyNDc3Mjkz\nLTRhZWQtNGZjMy1iN2Y4LTQ5YjZhYTY3YmU4ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNoGBTP7AQsXt0pXRuDWsYMwu70vno3sR+4YHVA4+rfgWDbc2Vl3Or0O\ndXCJVKppTyObbwCY8IMBnxk7azigJROjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFH2KSEX\nMftnOJmGutAeOz/LnNgpMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA9Dino181iuO3N5lRm7Z2BoEtB+AG8IjVLA0v\nWESaQdUCIH6qu/ReiHPJ4WL8X23+WtjDbpufuK0IvnztpjbDxYl4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5722", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5722` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfak4nMPIXhmfLbaQkO+qcMRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmNzhhYmEwLTNiMTQtNDRhYS1hMjNiLWJlMDdlOGFlMGE3ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhhMzdhYTItZTIw\nMi00YTYyLWE3ZGMtMGQzZWJmN2NjNTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6TAQL0e+/WnrB+tu1N/CKc7MnUoHOcqcDaUR+VuBZiifx/V+JDioiXsvx0HO\n1j5GGeqvgMMheBOvau0xiGcATaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPQdrBHw+Bubf3zYyGPPxG34oq88wHwYDVR0j\nBBgwFoAUDICHCIAeQPIm+t0wabxSRTpvq8MwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAlu2QsBXzCXzG\nbEA9fhT67CqnpLO7h3/yEUY2Qwy2CNkCIGQDxwFLUss7vDBLaXq6fpqh24foNuek\nS5F2bEScPOMn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAagda4iZ0domGEM3qeWvt963MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjc4YWJhMC0zYjE0LTQ0YWEtYTIzYi1iZTA3ZThhZTBhN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASksKRKtyBwGaiEC60uKetAR7zbhpg3yoy5IsKmt751WcvR\n5JIcQhKX8fb5LNFUk52glcSdxL/2L5+h+TTpA9hgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDICHCIAeQPIm+t0wabxSRTpv\nq8MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGL0gUkdMXsJFBNwAOcqAzgKRFLEq0LI5xGvjnkV8ALACIHxMtIWZUnYc\nSUPlXfY9YdbtYVxB9ffWedRX8G5gthHc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARPUNBDh/auw/PkB8VzuvzVxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhhMzdhYTItZTIwMi00YTYyLWE3ZGMtMGQzZWJmN2NjNTQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc1ZjQzZTEx\nLTU4NDItNDdkZi05YjlhLTNiOTJmZTBiZWY0NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPW9yx3oqNLALZcS//ALRVyeeQ6/ukpAFrhN3jqu3gYyZZPxSnTeQIxy\n5PTFseeyGNiXykxBqH0sZYqGgEMDn/SjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD0HawR8\nPgbm3982Mhjz8Rt+KKvPMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAnLBSpAmSwbYuqCHFRSwYLq5o68BFE4PQ6Z+fb\nI3XMjAIhALVqMFDtbzXlw6t8Z3LoFw8NqVTw9McBT2LVV8wtuheZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5723", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5723` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAT/QS8pBy3tfKWezUwhIgoXMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4ZTVmNWYxLTY2YTMtNDE4YS04NmVjLTUzNDRhNTVhYWYwMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzEwNWNhMDktZjdh\nMC00Y2I4LWI3NTEtNTI5ZGE2MGU0OTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEndTRY9sanyldIBzpVvaMrPC6R9UHgrYFC3U3ss7dHjcBu32+Pyk5RBChQSNB\ntu9RKaV+AGnvL92w+O7CJ6YFR6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJRCz31d59ptwOxdCVf802aivMPkwHwYDVR0j\nBBgwFoAUvgAjEuOdm4Ni+8QbRSDSf+CDrm4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDNGQ7OHde2iKXCyc9pHQ99VbzPUAR1F94Nt4PPbjt12AiEAjCkhkKGUXGKh\n28ZQA4JtF0OrnCRrWbk7qQMuNymUV3U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT/oI3PDdKW8UvQCCMz8S+mVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGU1ZjVmMS02NmEzLTQxOGEtODZlYy01MzQ0YTU1YWFmMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2Q9+wrzUNMlYM8nkRTvV6wPG/DXutV9+MizU7Wrhb7zTa\nRtypOj5bHG5w1vMpWwp84NIIiRtwP1i8KKVsoFVvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvgAjEuOdm4Ni+8QbRSDSf+CD\nrm4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaPsArtyQZkpDfHopLECgsfdFN+dOpdkYN0IVIqjhBvACIQC/8U4Fz+gr\nj7Pi+noAiEc3bppXpBuEDQJ/Jp7Juqs3jg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAW6HXj6p+iG/PNy3IBeJeMtPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzEwNWNhMDktZjdhMC00Y2I4LWI3NTEtNTI5ZGE2MGU0OTRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI2YjQ4N2Yz\nLWIwOWQtNDlkZS1hYjQ4LTkwNDc3YmNiNDM3NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEkBSo/51Ayvhz2DjQJEuXzm7w9g1F3GyLZsr2tYVWI0p1dhhjfgL6jU\nGpuG3h82pCeXD5H6ouxmGKED7fQ2rpCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCUQs99X\nefabcDsXQlX/NNmorzD5MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAlamRam/nz24xRYg3ncJLlv0go0izKcRNEPgF\n74XYcbUCIFEUEwrSPSkQpOekOe6ed27z97NnZZk8gpYjOVd+Gi9h\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5724", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5724` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASQAWRkpPnGCB+btl5EQX/tsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1ZjUwN2RkLTYyNmUtNGFlZS1iMmZjLTBlN2QwYjk0NjA0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUzYmYyNDgtMzBi\nZS00MThiLTk5YzctNTg5MWRiMmE3NTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELPmLmD33uT8JrjJ9RNoUoEnagIncgFC5LrFN4y6MCozmtrNR4T5cq79ywVYj\nYxNcoVOMTffSXq0tAWnPSB+XLKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKy9DczWN/84Dlg5FDWFguvF76lMwHwYDVR0j\nBBgwFoAUNEuimWz+trZVPlQ5rNCUOolE/iswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC/hIa1/jWMQ/L8I36mWi7ngvwTvPX4h/SGW96HnPSGZgIgOGpbThFdF1gB\ni3ihV24lkGs1d0ggZMGURfGYV02NMpw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc7qpulNWYBkqXy3cO3J0FYdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWY1MDdkZC02MjZlLTRhZWUtYjJmYy0wZTdkMGI5NDYwNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATexxFgBPm+mBfjY4D40XTw7QvRnlLDsaG7eeM+sWorNcrv\nNwHZF9LYvS7QxbeDfIIz+Zk/539/mPGmhL8/7qLTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNEuimWz+trZVPlQ5rNCUOolE\n/iswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcSt/QW5zKj+ZHXhhLnqzV+1gy52iETcx6a/x7G/uNlICIDxFkKQFhnNS\nCxz5Z5LNzpMXPvEooRa1Zcv3cU8egFYg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcGwWqoNm/Ba9V7Gx9ukemPLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUzYmYyNDgtMzBiZS00MThiLTk5YzctNTg5MWRiMmE3NTUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAzYWY2NzQ5\nLWUxOTgtNGY0YS04NmMxLWU3OTQ4ZTUwNGVhYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGNVgMv4qx6ymuUo57vOtgRmhbiEWFZOGzcCnFo1c46JERpUaq4kJ1nC\nbV1Lx6psC2iCXzGp+iwjHGz/CMQUBsmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCsvQ3M1\njf/OA5YORQ1hYLrxe+pTMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAx10q6+qz+iOQhxC52Q6VXA0sTLaBNIz6NGmc\njO2fG5gCIHDNJP+6lDDdlT+O9f/XpXGyWq2mkBTi6Gi7g3iN6an6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5725", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5725` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZn5qAvOoOz2597rK+joDr13MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwOGI3NWZhLTljNTEtNDdmYi04ZjYwLWFiMTEzYTdlYjIyZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVkYWM5N2ItY2Vk\nMC00MTBlLThlMTYtNDE1MWI5MjM2YzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpfhGRFb2hCkk+6nhWRb6EuYXAAXdCpPNoUYKFTzBxrawUyIRXW+l6PetQr38\nCM5EwV746LFCz/Xkymvy69WS6KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPu3pOINc2srYHglDoOdrgoKSg/cwHwYDVR0j\nBBgwFoAUiu9cFfCzQkfy88BygXKUEWFYaIgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA3ndrOlxV+z6fNoOCqzwX588phoo6GEz/Q+mRTnsXdUcCIDNJLtWGsyll\nmT5HaNejfiL5RIs5MGbdXOghnmBOLzgP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAabe99Z669DPdBKrM0Hp9Bt7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDhiNzVmYS05YzUxLTQ3ZmItOGY2MC1hYjExM2E3ZWIyMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQ3AEp8OXmucGAFPLqpIif70g3NJOCSvlktw6Q0RBAO2SR\nOX5DrfTfYJ/mlxO+4SJktrQU+QP6QwQmqj5PGG65o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiu9cFfCzQkfy88BygXKUEWFY\naIgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGhwFY0e0dNEuyb+nY1dnXEKtEAetwb8nJFvBtiERYdcCIAFJ5o2svJLS\nvL/uJdlTJ+YeFRb9kFLadt4o7+fNmV6U\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeOjRYmLHwlWsDnYyPfPzno0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVkYWM5N2ItY2VkMC00MTBlLThlMTYtNDE1MWI5MjM2YzkzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNiNzI0OTk4\nLTk5YzQtNGEwNC1hYWY2LTY3OTFmMTU4MzI0MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNEv+SYUkHQKw6XSq8r9ZTXsnr3usljwZ3CN2T21Z82YTv/zYcTtcFUK\n+Yipctbm/9CaJubledK3vRU7B2huA0GjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFD7t6TiD\nXNrK2B4JQ6Dna4KCkoP3MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBbKie8hRn0zMGHTsDF4yXs1dc3cUA/Lix7enoT\noJyC7QIhAJxiBwWrr73dRm1rPgs4JLLG3jptxG0k6owkNU0gQU3N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5726", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5726` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISARJ8I44jN1cd0EI9WjthbIsEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjMzFmZmM3LTg4NDMtNDNmZi1iZTVmLTI5NDg2ZTkxNWRhNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmI1ZmFiOWMtZGVj\nNC00ZDg1LWJkYWQtMTVlYzQ1NjkwNDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyPbMrzXy4FDQxTzKoNcZsdnzYKXFIYN04UnlYLQxVFlshWK6lAm+dmC8XDwb\nHAfCeOJU3jooedkGrLqCemmfDKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMMWkvrGr7JumNoc4OTulBURz6ncwHwYDVR0j\nBBgwFoAUh4/BtEcynBgr/7ygyNZf19yDH9UwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAh8JCy8lAIrMo8Th6ZzwC3DagYjY8Beth5kd2ef5Pp+R\nAiEAoZ6Koq9gVcusyWDB/ki40wptiH0xSVqN3fq12wTk2/U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZjyu6OgKacN7ra5702mgDYmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzMxZmZjNy04ODQzLTQzZmYtYmU1Zi0yOTQ4NmU5MTVkYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv9ZLSdIqeLia2Rh3mE/+h6hVBLnRG95lT97e6VMy9D1EV\neK+eDgb+KDwnDTND9P9ic1/J7JFSRsTV3FS8IX+so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh4/BtEcynBgr/7ygyNZf19yD\nH9UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMrkpBSbQgzs+y3tE8v29jXF5p/8CTvhaPuFC+/lxG50AiAAo+5cqb7y\nJegPchi9YskEZodbi2eJYUoc6mVCAfQ4pw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaSB8gAsQK7l4tOqDFM9L1E4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmI1ZmFiOWMtZGVjNC00ZDg1LWJkYWQtMTVlYzQ1NjkwNDQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk3YzU0Y2Rj\nLWZiNWUtNDNjMi05NWMxLTAyYThmMjJjOTVjMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBMNFnN3GGHH0BK//zz7lOh/yg+ovZ/7Jpc9XwPf6qLk3R0aFvk3/DVP\nr/ENLT8+qRnmUkxqZHm0EuGevfmrkPujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDDFpL6x\nq+ybpjaHODk7pQVEc+p3MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBMROkH2ybMWjTiha6M7T6mas9wVB3FVkVApE2H\n+ZJVCAIhAPm5+qvHsaaqYdbMiLamt09EEevuh93S6iJ5OkL9MPY3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5727", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5727` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAStpIM3LxBvciT0cBAdpgC5UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxOWI4ZjY2LTM0MzAtNGQxYi1iZGRjLTdjYzg2NjBkODIzODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk1MjFkYTctZTQ2\nNi00YTVlLTkxYzUtOGE1NWE5MWJiYzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErTSVoi3vnQkFpuTD33cyxvAOhrhmwLtLaJd2bxb8K2slex1JRZmcNIyDuK9Z\nfEAC0aRTaiNFQOQBcZIt5uzIiKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQpSitB5J0rY05hnEpgTkRdQHNokwHwYDVR0j\nBBgwFoAUtwJ13/srGI0n2C3uKk+OYH9bky0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAhLdJHCTGiPMyPn78kJ5i0P5DE8ZXfit/DKflb8bq\nxJgCIQDmVbf8BlT7PHh+OQc/PJ/AEUEfOh7L6JXR609suaDfMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXKaLa8feQ8Kddd8dMLT8KGLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTliOGY2Ni0zNDMwLTRkMWItYmRkYy03Y2M4NjYwZDgyMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARva4i7+9ovm4c59kTnxpDrIPsECeTb6xKK0fG979v9fOU7\n2BX3LbigC5oOhJZNQ4MA1QtIOjrxbcTzsDLDrwdao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtwJ13/srGI0n2C3uKk+OYH9b\nky0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAId8imGs1EGJ4uutLDfGbrxFXbPKcauG9jVbFdH+eyI6AiEA4Q0g+jta\nDVz0XYkVVlaAhHUlDGMm83+VGKVKdpi6AYQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAY74lQ2DDnXyhyL/noUZ04JzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk1MjFkYTctZTQ2Ni00YTVlLTkxYzUtOGE1NWE5MWJiYzg4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRkM2ZjYmNj\nLTEwNWQtNDM4Ny1iOGU1LTc3YjFiMTRjYzExZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHpjStqcT3M0ARR1D3Ddr3MbfkJcXREcuhIn+0V+OJ6hEbwlK3oP9IE/\naaFbjHGxjRLs+loU92WFiydTQ04El1OjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEKUorQe\nSdK2NOYZxKYE5EXUBzaJMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiA8kFtqQlXN3KlUxQT7tuow+tD+r+LK3lbP5kvK\n+2Gd9gIhAJKFecS2d9OlmRKiDrXzHBlO/6n7yCOXBMv5T/TqRt/u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5728", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5728` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYTVgpVLHK0qr+yZkPLVZZmnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1ZGVhNWYwLTMxNjAtNGQwYi1hZGEyLTFmNjdmY2ExYmQ3ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBmODM0ZDMtZDZm\nZS00NWI2LWJhYTYtOTU5NDQ3MThmZWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExxV7lnS0Sk3VnY0/laCLmUZ2IThz6EFkSQ5oF1tOVYgFE0I3IRFa9DOiAteG\nmTHqap86Ev/lbU9SdW7UBGkyeqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiLH2kTx3HQyB5TgCCgqQj9nPne0wHwYDVR0j\nBBgwFoAUfElxWqIvSZrVKNXgFyrfmRQuUPEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAoeW4VzayNuTbUMqdmZM3eisL9TJTQyIHRuA/ZGS5e1gIhAO6k\nWgK5qUuTJPqkcBECMpvepoJxj3pxF/Mrx/GlAEkb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASThIayVrcctDRLNVr0qiYMuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNWRlYTVmMC0zMTYwLTRkMGItYWRhMi0xZjY3ZmNhMWJkN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXZvO2FqpkuoKsHFYqePNXRCRzAb1RtTVN+LUaEqOKHfua\n31Z4V23vLTH/KjnalHh5qbdpkAnqTWvjfJM7InBNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfElxWqIvSZrVKNXgFyrfmRQu\nUPEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN5rf69vU3BC3XFQmjqczGNj89GaM44jWRvci0vkROz7AiBiuPpJvBK0\nUJYFMNkrduHg9wmkaZ7K++zSa8rtB69iyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAbI8usIdZigdFI841lHooH9nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBmODM0ZDMtZDZmZS00NWI2LWJhYTYtOTU5NDQ3MThmZWUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI2NTQ2MTcy\nLTliMDgtNDMxNi05MGMyLWM2ZDZiN2M3MTU2YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB1+iB8UuHoZNN08IW/LQRwtSjYO12pcUpDCgqblYj10Je/YXcDd0Vwt\nG7T4MPXC6oFlonfR3oL2beO5N0OxH0ijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIix9pE8\ndx0MgeU4AgoKkI/Zz53tMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAzZvjI0FfT0abuKP+H66KTv9Sn6DZ03Use1me\nZ8UY8zECIQDa/02601qnGrtP0FInWdPYJ3WsqNvxO9GXMojQMAJJdA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5729", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5729` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAVMUFIrYK2vyXbbJicwLEmJmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkNzdlOWU1LTlmZjAtNDY1OS1iZWVkLWQ0NTA5MzE5Y2NmZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg5MGJhMWUtYjc3\nMC00ZTVjLWFkOGEtZGMyMjA1MDY2Y2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEloWXB0eOEEoCf0C9ioFGn9APVcbTDI+w7hoiw5DstMfqYCUpnzRNf0FeWGtD\nlUkRC2PK885pQ4coB40WQxPe+aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmjy4Y0dvSS7zKcmGMBcIbXFdixowHwYDVR0j\nBBgwFoAUYZ6F72dfDHapZwDaHaD26lvBIuEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAiXrmcr6D0XLOA066VUnyH9zEkXS7zdDj\neUHVB9//T78CIQDip/4FtvTc/TZmnZylKQXawbNISCjN2Lq/tpGhPKzyPg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQQyiTAEIE9gU2qwQkWEmDhbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDc3ZTllNS05ZmYwLTQ2NTktYmVlZC1kNDUwOTMxOWNjZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBZUxgiINWuc7CPXvSt03QiXJRkfpTloDxCxWshcxBInQ9\nRy+A5atKJtKQfltdeQpmFmM4QXIVO/BRS7wjgGQko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYZ6F72dfDHapZwDaHaD26lvB\nIuEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOCi1T0Msx4OC4Qrs5qU5lroC2BFx0iYEcHuV6x6PNRMAiAdtR9Ymtt/\nkZwyWxO2zu4NpR5+8j6XMcbGi0GHACeZ0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAf0Esf+74be3PTgcLKEQC8zAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg5MGJhMWUtYjc3MC00ZTVjLWFkOGEtZGMyMjA1MDY2Y2RkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ5ZDNhN2Rh\nLWFhNDYtNDg5Ny1iNTg0LTJjY2ZkMDg2MTM2OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGeicj1KKqvAXX4ngoQf4NABxivtuHi8PQnzZ4oip7GoudE8WOLIO3do\nGVSTS5TghwuDlpaswChv+DYg1aquGaijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJo8uGNH\nb0ku8ynJhjAXCG1xXYsaMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAjXCiYeUSxNschOsK3G7Yewbhp6aBmxLOWd4e\nRTfjyeMCIEar93Mol7ck4ZwykG5fW7qqjzWaYo4pUcNytN3r6GPL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5730", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5730` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVwHs5PFNXcpOpqLq5tz/FGUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0MzA4YzYxLWRkZjItNDBlZS05NzM4LTAwYzE5MGNjODdjNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZmOTcyMjktYjBl\nYS00ZmMwLThmNWEtYjdkYmU5NGQ3ZGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzuTutA+EqflQ/CewRhvizHxVYPxyxDbSFqW7ER4wMGQ0R0SWX9keyB/PYaBB\n2JqJ+2to4bK1B5EuSNTZIV6d8qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyiRnQ/iAODQP5cojb4YRqHCLzX0wHwYDVR0j\nBBgwFoAURvFIpS3w+vvhWBXu15bTDqRowRMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiB4jgxkxoI/Sd00nnz7vs1999OYMYq4N+zU\nDmtnuR+jPgIhAP2ay6BwQLYA8nJm8MhvR/GnaPGH+og8ojoZ77xJTSYc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU6j8/jnW/GT/Rhn7aEQ/nRAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDMwOGM2MS1kZGYyLTQwZWUtOTczOC0wMGMxOTBjYzg3YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2S1pgSBShdmARuNAmR2tyv/8EZzMF1kyjKOiEa94wJyDN\ntIAhrUQn5VOMtQkB9crrREfUUEW4a5uUGe/VCsk2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURvFIpS3w+vvhWBXu15bTDqRo\nwRMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBRA8cs6w+8urzVuu+ekXlwPlFfpQP4kAnVRboPlsYV8CIQDZxblH1MZX\nkv4sqVSGqAbz7KDw2D7qNgtyctKVvNUk9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAcyoCSorODCJJBFmSPg6PxgmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZmOTcyMjktYjBlYS00ZmMwLThmNWEtYjdkYmU5NGQ3ZGIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI3MjE3NTRk\nLWY0YmQtNGYyNC1hYTYxLTY1ODM1YTVjNzU2ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFTRVJwgtZ51F90uFn2mePC+m3C7AocCOIScTegzkVfOdvz5GeCkdvIw\nn7VnQqtzx49iE7cAEay8iVZl11t3s6CjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMokZ0P4\ngDg0D+XKI2+GEahwi819MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBhjQkaSBhwAaQTIoNMMCxinBCYDz2IojqpUhfv\nfSY0uAIgDijYvFcMTk/+mVOXFNZq8CdDcPVSfDmcmp2e7f9pSAc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5731", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5731` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAXiA74OFs2sPRnhI7wDgEX5jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1MGU0MGJkLTdkZjEtNGI4MS05NmM1LTA5NDAxMDhhZTFhZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkwMGJhZTQtOTAy\nYS00MjUzLTllNjctNzRhZjc4MzRiMGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERbvQ85LJcH95RfyAJA+XQaA4o4qRTR3UKnjuVDFMnoHv9cNWiK4Ly+jJQi6B\nFOkx/8MoFzQ8/Qy+FJDkKBenqKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7hL6bpbGt8fP8xpCB5ZZzDSYBecwHwYDVR0j\nBBgwFoAUmXsXl4uh5aqIsgS3o6wmVfJJtZEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDTLp1vCC7pUFpWtLqMxZoZKQ03\nmaqS1UEbc12pNJvy+AIgaodxDtTeqO3kLrgtiYcqDPvmckQ1jKhpphIoIs7jx8s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVlg6VCuiyV+IJZNFB51pi7cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTBlNDBiZC03ZGYxLTRiODEtOTZjNS0wOTQwMTA4YWUxYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyOiaqePavITqHprLwIjT7v5Pw5g4mWv1nYjQMBBKqp7O4\nN8aB7U0/Iw1YH285DniMrR637zkHyw3wzSHdAcgto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmXsXl4uh5aqIsgS3o6wmVfJJ\ntZEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHE77h2QgX78do2Fq6TIa5JcHdJVmiYNCsCsFx4CwlBkCIECTC2ekCf6y\nqtsKFYyVItGSl/lN5uHXX6uxIqfQCJaS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYX7+4gGx2ZLV5VsJjBS6eBTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkwMGJhZTQtOTAyYS00MjUzLTllNjctNzRhZjc4MzRiMGZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE0ODg0ZDYz\nLTlmODgtNGFiNC04MzQ4LTJjYmMyMDBjZjQyMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLWECTnTamvw8lDyi5Y6xBK8AFCu0u583kY/I8tPbwvxUAcmUXwhsFI6\nTfYQCsiIeVcci+dlAwZqUGouqQVqttejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO4S+m6W\nxrfHz/MaQgeWWcw0mAXnMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA1rTeg/Yvs7scnA2OlDHCfVl4YOIU95CUNTRw\nDcOaJ9kCICo/Ypb+bQmVVHfvpIzEHCzDJRKVHhBfXfJx9StLs6c0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5732", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5732` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAT6fMn3ZAL0P3IoOZ8mnXbU2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNTA1NTJiLTg0MjctNGE2YS1hODA1LWI5YWQ1NjA4NTg4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY2OGE4ZDctMzY2\nNy00ZmUyLTkyOWMtNDcwODJmMmQ2ODBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXHH4600mKHgrsoqwR7HFlpPCXtjhn/LxuXMKiLPUsV4AaxX6TgnUx6+byCT0\n/XHLgE97CcrNz+llHH+Uiw8JeqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwQQv30YqCLiRQX0sNVQNcEE1TwgwHwYDVR0j\nBBgwFoAU32jw9aX33kdYBsx07H1tkoq4UFQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgI1TO8D9v\n6EZ5Aqivfq87D7AqMnwXzFkOet0JC409ATkCIGCloa1AccgqXtZC62yej/IsOwmn\nniM0WlFha9NdJHtA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAclfcIplY9njVCo6D7mhl+YzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTUwNTUyYi04NDI3LTRhNmEtYTgwNS1iOWFkNTYwODU4OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCht94BoS2QMFo0EM2/RjFtfr9cedEWjdgMicl7r22C3Jq\nExuYm9+Qs7FV9wgO1Mqe/+DJ4dnPfcMH7Yy4ZkLKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU32jw9aX33kdYBsx07H1tkoq4\nUFQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHvheVuCUXD0+9VepQWno+hQQqq9vq3jgYDOf8X8QgxcCIQCN5fz3fx3G\ndtUaLfMRWutlX01aSsAooIvlpmhop2fy6g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARKPN8YVOEVfUV8p/uGMZ3sDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY2OGE4ZDctMzY2Ny00ZmUyLTkyOWMtNDcwODJmMmQ2ODBiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUyZjc4NzM4\nLTAwYmYtNDM0MC1hNDlhLTBiYzlhODk4NjU3YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL5RU04FbgbD4X8QtZ3IK0xUxJdo5n+WVpNLKkxbZ5yDy62qUbCzTppM\nim39xRqVzKbvMp2V6/gRtCT+6zkUgdCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMEEL99G\nKgi4kUF9LDVUDXBBNU8IMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA6e14r69nkAWysDXFIQWWYPbavqSvBPR5nHaw\nVAqQFS0CIHo1viSrQXz4As9vPHNv53Hqdspdr3sAOCEWZU3/u4L5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5733", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5733` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAWLiHhOslRUY6597cIiB8rQRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyOTJhYzM3LWIwYmItNGY0Ni1iZjkxLTBiM2VlZmM2M2M2ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVlYzQ1OWMtZWMz\nYy00NzZmLWFlZTAtZmM2NzBlZDY5NzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKncns/5EbQKoIpabEvEA31TG8NSBAZiPBNpAEIGWZk0extGx2PEjafOHfbpO\nLOTeoHX0gRlYrt612EYMX1jR2qOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs5OPjYGYjI7ah3fHaDxUU7nrmqMwHwYDVR0j\nBBgwFoAUpKbxGSut2G+vroL/F0o4n19VKdswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgJRk3cbWT\nLZwXMIM7SR59xtNlmpuRQGFJ6rm1oa/Hw8ICIQClPUH1y3OV0QwUlCyQEbl22Qjj\n21MRi5xKjTUoMBVHrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAapqoQ1sUjG9t4pOGlVO3AJ2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjkyYWMzNy1iMGJiLTRmNDYtYmY5MS0wYjNlZWZjNjNjNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ83q2Aj24db+DFCWOAqnSkYDj99MrVu7s6zu/KS3qf4zIu\nUsDGeYa/RKxqbtxnlHb7/FLKtn6L42xlrA7v7Ct+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpKbxGSut2G+vroL/F0o4n19V\nKdswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMYLNAmfLpBYbw5uQjg1ruk27+7rqzQqQTQ2bfRDntoZAiAErqoL6tnz\nod0pI0vtmdGA4SITWB/KvRqrea3wfLUk1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISARPHRDT1iRReAQ5conks+CyMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVlYzQ1OWMtZWMzYy00NzZmLWFlZTAtZmM2NzBlZDY5NzIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNkYTM2YTU3\nLWYwNDAtNGNlNi05MDBkLWE3YjMzODUzMTc0NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFkmaV4LNGTiThzHX/XaAc1Ll0asIyAOqLYeWZt7hJ48He7JL5I3Ogme\nGimOPORfgNNSLkW0mCLjdrmo9lGa64GjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLOTj42B\nmIyO2od3x2g8VFO565qjMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA+K1uj6u5fJcXrzOA4fFv40gPZ/jhzJwD3LvO\nyk2S6OwCIQD45ZZZoEoXhxqkee7/Jr37m7JopQ2R6+ZvoDX317xUoA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5734", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5734` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAdCIwD3GuDKyOFIjQTii6NoAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzNmNhM2JhLTYxMjYtNDYyYS05NzUxLTk0NTg1ZGUwYTcwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGJlMGE3YmYtZjhk\nYS00YWFlLWI1MDgtODkzMmRmYTk1YzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElyJjuzB+3ZRUBW48VKH66OXzsjXpdQquOLWjQwddtCB9hrxar0i6EYMKNQJF\nNZrXOrOKD/jfF2kmUUcLZV7KI6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMf5Bmjk39yhQRsUnbqOEspHv3AMwHwYDVR0j\nBBgwFoAU/ViTyFqpSHFD9b6bQ9OApdeubdwwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIENhZoy3\nbX+YIk2Iv8VgWTwGNmsDd67Hae3CED1P3wpeAiBmrsIoTXttrpT+vbyp74hivdPe\nOlAfgxhbVnYYRxMB9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeHdBtT92iavLIDDsrb883oyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzZjYTNiYS02MTI2LTQ2MmEtOTc1MS05NDU4NWRlMGE3MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATE4xUJUi2ctUrwShswKFZI1Go7vxg4Z+7ugkmPhtNhWXEZ\nfbSgUpW/D9zMVgOnNBBlDSAsNam323pg7m4lNpdJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/ViTyFqpSHFD9b6bQ9OApdeu\nbdwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKq7BA5RPUU+UC91x06n0e+5rjJEjIVuv5nhyZbXfMBgCIBpl8h/y96Cb\nSyLxXUNyfR5WrUNXkxH8dPc/w3BJly+m\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZqJX5JK1y1FNKaN7a/dnZkIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGJlMGE3YmYtZjhkYS00YWFlLWI1MDgtODkzMmRmYTk1YzJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY2OGFhNTFm\nLWNjMmYtNDYwNS05ODRjLTZhNzk2NTc0NTc3MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBqStHwxVgdbemHxM5EhQ88hKvjicQI0NLTM0U6MEsmsOuHrD518L44f\nX4tBH98ELhPRtqmIbOPw++zJKNFbXfOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDH+QZo5\nN/coUEbFJ26jhLKR79wDMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBR96XsU/vAnH6rOGtR0J1H+xh901fq4LzPo5VO\noWlBygIgC9zCcegx+/x1m61UKXSONhvCGQQLhtqSgIDXIFxgoNM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5735", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5735` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAVmvK/7lMGlI8glwKG3qCFKBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwMmMyNjllLWEzZDEtNGI3NC04MWVmLWE3NGUwN2Q4NWQyNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTllYjNhZDEtNWJl\nNi00MmVhLTgwNmUtNTFjNzA2MGQyYzQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeKRSWzpqdcaq97vkeRcR96rE9V3Vf1uuixUguaXpPKxn2bCA3CYbnV861kks\nggaqpZ9PmqgiOhG3+hwKPM2Kc6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHlvkCVmuzf6J61Am7Hwj3kdtAdAwHwYDVR0j\nBBgwFoAU71jYyjXG9dCKYY6WdR3A5y9+VrUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQD3e/PbNhdhhcCIutu/FolRsVNFQ/jf2/oK+xWhwgEbvwIhANF2NzE9\nTFpfG1g2lMo+C//urjJNsd7yhqD0ltXCOvyY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATEBCgDTxCnGo6zXReEBI/Z+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDJjMjY5ZS1hM2QxLTRiNzQtODFlZi1hNzRlMDdkODVkMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQy2TBdI4UafsDtR7Gy4Lg/QAMwGBhbn3ZonhCAeiaWfbc4\nNvkaM9yHlTKMd23l+3nCMFSZxcXInjkXZ9CNS8TUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU71jYyjXG9dCKYY6WdR3A5y9+\nVrUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFQ4LZtwP64bwCvOS4IfugRCVppgDMVhw01EGmIXH2PsCIHysVyRjilSR\nOyFNOiuSt3kK0tsZRELsS1G9Jay50hwG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVXuU5hZq2MzgFafWsEvVn5XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTllYjNhZDEtNWJlNi00MmVhLTgwNmUtNTFjNzA2MGQyYzQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRjNDhiNTMw\nLTk1ZWEtNDZjNi04ZDI5LTQ3ZGNjZDVhNjA0YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAJ6QshxeO081TRt2Uh7+D7hng9NppA/IkWyW5Ri0oRB8Qeum4+xoc/x\nn9Uv3q4FKSoIEJpOqNdPapV+vz2Q7bajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFB5b5AlZ\nrs3+ietQJux8I95HbQHQMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAslGn9zVA5eEFilw0OCeYVQA1R/utuMk62i4FJ\nOXHJYgIhAJ/CoYbeLvWt78l8cjQJzraG2RGv+wler7D6vp2EHaOc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5736", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5736` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISARnQp0MsjsD7AX5CqfBCDixDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMmM2MDM0LTIxNGYtNDQ0OS05ZTdlLWJiOGJhNWVjNmFmMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQxMWVlNDctOTA2\nMy00ZmI1LTg3NTktZGVmMTdjNjY2MzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhs7jPekcngAHZvND5T+MS2h0grtbb5XJLuZdHKpotXVZYlVDM94Aw71L6i5d\nbmp6lS6yI+RhX98VQnzshOftEqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrxZSVQxvThQ7OapEbuqEOZPfhYQwHwYDVR0j\nBBgwFoAUnUnkaqrIgwsNXUDFcXn4XeCifyswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDdWQWubFs6GHoxIaU7Mn89IztWOycS4ODYVRVZjc8ZhAIhAOL4NCyz\nY0ddXbW8onYBs85o3xbi6vamxHz66jqRmztA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZAab+eIAIKYULk0AMVvz4UvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjJjNjAzNC0yMTRmLTQ0NDktOWU3ZS1iYjhiYTVlYzZhZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARD/ej3TkmR7xTM4Tw2/hSuLju6RcOpv2ZLwglSTmCU5o8a\nRNo5ODBqocQ6XbRXZShIQLyIUaP/KRa6AZl/Tlvro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnUnkaqrIgwsNXUDFcXn4XeCi\nfyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANWO39yuobiuNGhNqW9aVdTZ/6XPLiAjTxrLET7H0MwXAiA4RAEbFJOE\nDYOk7i8EjdrFQI7MLFAT6jGc/phS7AYLRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAUEqgi08iEwmCqwzH7YngT5kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQxMWVlNDctOTA2My00ZmI1LTg3NTktZGVmMTdjNjY2MzlmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY1NmNiMGRk\nLTUyNTQtNDM3Ny05MjIwLTM5NzY3MGU0MmFjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEzJNgLL1xVjnCOI0qzJhWUu9tM5Z8pJcLbpsPvKL6nQ/ZTEkxajA1vg\ndDLfgGyHvSd6NFhZ4RuoGiMWAORujhmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK8WUlUM\nb04UOzmqRG7qhDmT34WEMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBdzNlZ06lYLTnRgcgKp8ks+ZoSD7RfLNC5C6tq\nDKiSCgIgWBXElsibAawMeo9IZgxZFENRmIcyT8S4eMO18R9J4Q4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5737", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5737` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAe7WiKi3xCzmGcZ6/W/aXQF2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMGE0ODNlLWY4MzQtNDlhZi1iMjNlLWMyOTc0ZjVmMjllODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJiOGVkZDQtYWI5\nNC00M2ExLWFhOTUtYzZlZjUwODc4N2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE80rFJSv/NirlqisAx6RMIC1lywo8g0bdYwpzQ4CAw2gGNUXU1jpDqGr0WbqZ\nwjMdz7Nn3pFAvuWp1YRxOuEDo6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbBmOcd9LEFCTrjQL8My6C3ShWPYwHwYDVR0j\nBBgwFoAUny1aSFe6XLW+EW8huMVVcvwyhiIwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQCn+Ogk4NznVYH8mbLYPOL1DwbpTgOxhzKvLFkRL6Q24QIhANySDhj7hLUKl6K4\nisgHRGLaqnczWFUhRCrAETabPadd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXu9BEuqsij95jLwljNI2v3nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzBhNDgzZS1mODM0LTQ5YWYtYjIzZS1jMjk3NGY1ZjI5ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRQxAWMoU5IdVrMGCHroZXfO5tVZ9do64/kfCicIqGa3XI\nPIoev8lbQ5ImibbQ8Mh+EZqtLBvYsm0KS98f4cBgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUny1aSFe6XLW+EW8huMVVcvwy\nhiIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKR8Exgnp80ZoWBd/3xRUrchyLc0EkuUXOVADpmr9EhwAiEAoHHpwPuS\nXXguMLB2FnOIQJadY1t/u522t/dFymv+QaM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAU9WROPZ4oYkgFXotrLWzKsDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJiOGVkZDQtYWI5NC00M2ExLWFhOTUtYzZlZjUwODc4N2RkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVmNWI2M2Zl\nLTczYjMtNGFhZi1hYTUwLWZjNWE1YjBjMDExMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGcRY6mam5BEmm0hNF96W9tcpXd3iXfyn7iGr+JjRj2U2BzNYpPg8Wu3\nuxwACFakGs/uA7OkuuBEq+F7L7tZ1+6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGwZjnHf\nSxBQk640C/DMugt0oVj2MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA1AVeWjd4ezu73gJYCIe7A4uodsbb9Ah3kUByD\nuuyMvQIgKW0Mz98cwjMJJQ+PkMlCr1M1Vvpzr6IWdWl1/TD/AJw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5738", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5738` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISASMPwiAnnCGeKProX/JgQ1tiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyNzYzN2NiLWVhY2MtNDcxMi04NDZjLWQwOTAxODhjNzNmMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUzYjg3ZWEtOWQ5\nNS00MDhmLWI3NmQtOWNhM2Q1NThjYWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7hRC9u7NG3GHXzT4wkL7cXtGZa0uWIULlWNIVa+gF55WO4P+BFsP6S+TAsMd\nUifTB4Qsfg2wjQxxc+6RN6T6vKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURrcEtbTkpvenDcCKXU3dfFnyI88wHwYDVR0j\nBBgwFoAUKObDDAafgza3y00IGfRlzqjd7ewwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIGcMiaYj6IjGM3dcUtIamP/NRKJKuOInhTwUAnE6N1HvAiAN\ndJYC8x5C7lcm1IcudHuBuACztDBo4HPvssM/eVjZAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZvyrtbzLwPQzD7850xMnN35MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjc2MzdjYi1lYWNjLTQ3MTItODQ2Yy1kMDkwMTg4YzczZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqJYkrWocJynpmjuSVTD4bL7JbqvEScItqm2dlvvQnQ4sw\nXTxeaetqNvzSsqzRmtRbgABTd1lAOM25/sWCVD5lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKObDDAafgza3y00IGfRlzqjd\n7ewwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdSiXf7EW6elNrWZ8v5d/A6T83k7IwQZb40znYkIWerQCIC+5Ib2f0RuT\n7ZYA1M6MLtQTeVZSM2KXb9CN8oGcRI+r\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAYJvVRRrwWBI/jGhygTpmvveMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUzYjg3ZWEtOWQ5NS00MDhmLWI3NmQtOWNhM2Q1NThjYWViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYzZDI5Yjk2\nLTJmNjYtNGYwYy05YTU5LTIwNzZjZmRkODQ5ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEO1xHtmNOzCJtK6L3Nhez42m6gfOUwDKpjunpTylnaEg77usK3gtIjs\n66Jj/s8S0CxnLZ/Vhnj19TTc1vkgF1ejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEa3BLW0\n5Kb3pw3Ail1N3XxZ8iPPMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiB9rbPMYVQcqrLpd2YN4UZUIOH5TpgZNcjAAc8O\npO/iQQIgLmtqtxLI/tImHBdSrVpppbCCyUy5h3w+snIFwLY3yiE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5739", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5739` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAVzRmLJyh8/VfhAm9gFrRyp1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlOGZkYTJkLTlhYmMtNGVkMC05Y2FjLTMyODZkYjU4ZTc5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ2MTk4NGEtYWIw\nYS00NTgwLWIzMTQtNjI0NTUzODFhYTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Pn7OQ9t0/kwVT+2cz1r6hwSYS9BFi6F5MpnI5kzk3OhVDk6sIodIVDhrQXA\nsZbooI0XcMBdG125PRGMJubsBqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUenEKUX6bAVvhYBE3qSi5dEnyboowHwYDVR0j\nBBgwFoAU8PNZJtygsPwouqDokawkRoGUJuowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIHZUTXDoBsl/dei6W+k1qcRL7RH/MA9wAOGswLqkHcTjAiBM\nWORt32/j8/d0RpZz9hn7k9AjaMVIl334Wnx+JDDGYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQk0orAOYzAI0Y+WriusFEfOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZThmZGEyZC05YWJjLTRlZDAtOWNhYy0zMjg2ZGI1OGU3OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlx8WQY/42fUtrQkr3FbK0nsb6HazoX/h+74LogLIG2F+M\n4pa+u5GJDoXrxl2nRj3SWyM/PEQprhk67QCt3rfto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8PNZJtygsPwouqDokawkRoGU\nJuowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA39WEoqH2lJt08xxl+xpJRqxz9MWzI3Nt04meeu5PZECIQCQ6BGByryh\n9/Rof9royJv08gYZwDcwPL8VaqGHBPviVw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaQV4B64zvzzITAQKRQKJxChMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ2MTk4NGEtYWIwYS00NTgwLWIzMTQtNjI0NTUzODFhYTM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBiNzY3MTZl\nLWU1ZjMtNGMzMy1iNGM2LThkY2IyYzUzZjI5MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHmcQK5ggyjmxEkRJzmVb9uFWIb1GMe+h/af/rBUEw01pjr9fM+LoI8d\n4+0fRCcuth0Q/dyeJtJcNGWMMz6CsPOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHpxClF+\nmwFb4WARN6kouXRJ8m6KMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAmCtpJRh1yV2v8mmOvY02BMNboP/XFV7SxM+V\nOs/7Ak4CIDCExPsSDUfw/Yjd1hRJ27RcZj2wke3RppK/B0Wm3kYq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5740", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5740` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXGiBGk0si0StRyLTLdymVQHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3N2FjNTQ0LWEzYmYtNDY2Mi04ZDhhLWVlNTM2NDVjOGI1MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWI1MTE2NTgtNTA2\nMC00NGRjLTgyYzctY2QxNjY3NmIxMDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaln4TqgfXaYJspM6EdOK7wKuprgC9mGPVlEvwee4GoBMXhdNKw8SkO66I3vH\njjZjgrg1A+QknLICwLixDmIi9KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9L22bE6gwA0UYKndo2o7VJ7B+jwwHwYDVR0j\nBBgwFoAUlW3dPYeCZDpqRc0qctnvgTuYk3AwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHXD8Y83wY1v\nV2fC0gR0rgM5Y/CLDEUBdwiVwtq2QnNtAiEAlhpsQOeRwt1ggOLswlwXC3xl4qqN\ni+ECKAWJkQEGDJ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVRU3oczRZ25QRkYFcIIO93+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzdhYzU0NC1hM2JmLTQ2NjItOGQ4YS1lZTUzNjQ1YzhiNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTV6gNt+1biXzwV//LCQz3KM2Pxz3v1ozLyMAykRmn22vb\nHipk3Es29PoBcIzrgkO1ExMxS9aK8fdXdNjrmETao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlW3dPYeCZDpqRc0qctnvgTuY\nk3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJipJORZoXsARIFV9Kx7XU5jrN3MlDfP68dByzHQyt5JAiEAwxAJI7z7\njrfXV2wQ/VtTfaFyOIxH/gMd3YhbEZJ5pXU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAc94dw4lMJU0ci7d2LQdHT2uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWI1MTE2NTgtNTA2MC00NGRjLTgyYzctY2QxNjY3NmIxMDNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQyZmM0MDMw\nLWQ2YzAtNDYyYS1iZjhjLTk3YTc3ZmRlMTI2NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCrGWMCw2g2QjYXh/znqp1BJJL5dTCZ+IzS7PlDJOUjgz9uX+/JIQmYG\nF6JQhltW99HdhsX42q4l7rnKri8rccCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPS9tmxO\noMANFGCp3aNqO1Sewfo8MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAY+afk6HVB+KRXDXEv5qnB7BuXXctBI5aft013\nCtzFAgIgT8fHjqaG1EZ/Yqj9C6O/45cg+EQWyz0hrb+O8L8oK6c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5741", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5741` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXZrHPutu0YHqriJoVSLMebLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyZGI3Y2JiLTE5YjctNDNiYS04NWNkLWI2OGMyNDNhMGFhYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTEwZjU5ZGYtZWIz\nZi00Y2E5LTkxZGQtMTZjZTgyNmY4M2I2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBilOlikV1lF5JmBUNGejPQBoyAkh/hD1oOIhmPmfTgw7Ef+eTucGwIFuFaod\nPACHiGLfJZxtWCaebdQEzuvyhqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU31zKsr2g74C2FX79qmtwb5ppl0kwHwYDVR0j\nBBgwFoAULplYlIvRqbfl+WVdW+/LV3FxGXIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgWhLh4KFm+NO1X7Zuy4Oo4IxeOvb1aBTEhTJCwtUktjMCIQCf2l2G6aAE\n8Gbs4gm6tOeQCFY0Oe72T1ZPhtw5pAGx8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfUpgB4UdGORPwWXAL7TcD36MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmRiN2NiYi0xOWI3LTQzYmEtODVjZC1iNjhjMjQzYTBhYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVN2JY7m5qlyUCs2KaOdgsQshzWEAeF0eyoY6fbM9JpqkW\nU5MynBuv7+NQWubMABmPL2CJmO5l6q/3Qzfb6kCHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULplYlIvRqbfl+WVdW+/LV3Fx\nGXIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYS2mS0WueV+3x/KbcoWLB1g9k5uQVPJqu5bQYoPwu2sCIGbSE3w6ckwt\nINVNnnYgqxDOvLNXDFuIBoYYx7ejrIY6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAQCSrvxyiaN36ZP10PdLOxL5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTEwZjU5ZGYtZWIzZi00Y2E5LTkxZGQtMTZjZTgyNmY4M2I2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEyOTZiMjg1\nLTY0MDAtNDQ5Yy04ZGE3LTlhNjMyMTJjZTcwOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEtNYMHlHGxA/C7rCR8v3B1OJliGawUEawijmM/rHoqu6GtSQ6aOxd3P\nJI25LKlZZgZYyl9gkDZFGdbB2EF4zHmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN9cyrK9\noO+AthV+/aprcG+aaZdJMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAjovY7ol7lNyhi8bBTYZYHVUrZYn8FUC2tWdz\nVd27KJECIQCYJAQp5p0UTpoNTze4zPR8mY/DryIM86kELj2N8YsINg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5742", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5742` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAQ2P7yapLoGFJef9Dmixjw2bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkNzAxNDRiLTc2MTYtNGMzMC05NTE4LTM4NWI3ZDgyZTFlZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzU1NWM2MGYtNTFh\nYy00YzE4LWE0ZTgtZTY2NGEyNmFiMjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg1m78Mp/BNYSOgHdexVjYy5IdcCEGpKiYS62KIEv9Ujpi/CC0jKUWyAX/IpL\ncMHMDs7HWxv9CXwzxM+/dGDHf6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZaHqI/HvyEVWo8uEcF//rPsWu5EwHwYDVR0j\nBBgwFoAU1Qc1lJg8KtKW8Gdt9qeVNYQgi2EwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgGZRLrjE2ubfT87IYq4bjgop7KBZ/uptwxRCwtf4CTiECICqGOF87aRZB\njN6VUCUXvIOKMw/ixQq7BMRw6rrCVxiX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAamnphCObaFSLqmK7robtJfsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDcwMTQ0Yi03NjE2LTRjMzAtOTUxOC0zODViN2Q4MmUxZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1NlTpdcB+TPQvPbVizMtlOppL+Xt7YirkOJEy9MxFdjWC\n5DpiGFo45j/HNfawNJLsmeJ16tKXgUol3Bcdy6lTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Qc1lJg8KtKW8Gdt9qeVNYQg\ni2EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEY260jppyO2MlUgjJfMMuVqkOfoWy22BbDMA+s+h3+QCIQCI9uphs875\nQrWZXPLuqyAYSjzbkGqC36Ue4j29XJjCUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXduOe7Y/thfr9fiihZIpslKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzU1NWM2MGYtNTFhYy00YzE4LWE0ZTgtZTY2NGEyNmFiMjhhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkwNGUwZmY0\nLWY2ODgtNDVmNi05YzUzLWUxYjJmNzdjMmFlYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPCYuHUc0TjjVDilD+N74VXL+4Y0zyfus/t8xZSemAQ0JH+g4InlYFjp\nQFrHOxAAn97F9AV8KHavb29NhpTyUVCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGWh6iPx\n78hFVqPLhHBf/6z7FruRMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA8XgaYoMJEFEEZ+ei2O2qyukOyL/7T1aFnu25\n4tYWq10CIQCD/fm7/Y4kS88xwfLdmCwog34ALef8gmXho7qn3M4Ajg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5743", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5743` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAdXBSAaVa7b5JvdovOypDhMqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0NTAyZWMyLTc2Y2MtNGNjOC04YjBlLWY1M2VjODFmMThjNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE2NjcwNjktMWRh\nYi00ODQ1LWEyMzMtOTI1YjY2ODA4N2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB0219sdKeMVOiwi+SJL+UWPlUoTZe1TEts1BX/LdQWj/N8biZaxtoY/qdZSD\nF+6H+hnjpZeirHN/c2NJwwKSrKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCIt2kQ7feD3Ib5ZPOwyV7MKfCIkwHwYDVR0j\nBBgwFoAUaJMwf5E9RYFMqYwNKPfKPmgNzAkwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBjPfP1VQuRa5Ut1BkfID1R0dvz7nhFiEy/2Y408fXsBAiBD93l0zlbb\nWwWY8jFv+je0cU8opgXpQhbT16WuVyzIBQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbI7yDwG18hXC874EXt6GzMRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDUwMmVjMi03NmNjLTRjYzgtOGIwZS1mNTNlYzgxZjE4YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyOHIFvGh0sUyFz8LJqKYqA9+4oF0py82eVeRTgq06R0Ed\n0mGUg6S/q9+PhD1rnnubOvWADvwTjk9rtNR6qBjbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaJMwf5E9RYFMqYwNKPfKPmgN\nzAkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKnASrNtiTuPl6+PVrbsqxbTaN/YxyEFcmQJlB6RO98NAiASJP1a4HYZ\nNOH0ZXzbt1bKWcExATjrg7+KwT/+VV1Hnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAa95he+es7JxA/vjlvMD0QdBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE2NjcwNjktMWRhYi00ODQ1LWEyMzMtOTI1YjY2ODA4N2Y5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRiODg3YTJk\nLTJiNTMtNGQ2Yi1iZjBkLTIzMWNmMjFhMDk2YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFX2VXtyBWez3fia4wOc4irWlXkE+kaKGAaQD6bneS8yGG5hDLSBxbOI\nJ9Nh5oeJ1TJ3PmEXOiNzSTxYCwwoBkKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAiLdpEO\n33g9yG+WTzsMlezCnwiJMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA8nQuBA5x7/TSH6QIYvUr4TEcd+Kl+sVo2GrF\ncy/kXlwCIC5vctUncKDJKM8keFyhn1v9m6HG3otbPBUK/Ok37laT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5744", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5744` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAcW2/7VpTM3gICllPLE5FWi+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlZTZmYWM0LTM3YjUtNDIwMC05MDY2LTY0ZmE5OWQ2YzlkMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjMyZWY1MGQtYWQ0\nMi00MDBiLThmNjctZTkzZDg4YTU2YzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjHMHMV4zVnjLmFlkD6xq7XCfTzceJFj2gjZSuEjJPO1wY4KrfIGoHbRCiryz\nbKaQp+snYtVJuGcaJXsRL8sKQ6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU359tKUoJfpcsklHCkYD1JpShz94wHwYDVR0j\nBBgwFoAUSHkcvH8K6zcq5aq/g+MjTuPig78wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDhOucCnygTXKqnAZLbHs9mPB7l3+BSx03JNl8k\nKscg7wIgWatPUp6faxfdYYJOAb87tVQWYBttP5O+zbBCGklQ8TU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAah0FYN30zEEO51uEQev56k8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWU2ZmFjNC0zN2I1LTQyMDAtOTA2Ni02NGZhOTlkNmM5ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATs3jXIhP/Zg86jk3cPCwqSc4YOr84bGZFt8/WzDLPYaHix\nZm9LR/f4MVuF8s5ITpp8My1ezH0IsyprIbezi2YZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSHkcvH8K6zcq5aq/g+MjTuPi\ng78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAhXUwHdbQIZk8SZ+ABAcoYw8UqDu2pEOk1E7nbVS7I8CIEnVBpK6l3pg\nJWv4Nb22hInfpE8rJNOBQ8fBEq6qVKdR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAb/WTOPNDhN7tWua3aw5g8OxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjMyZWY1MGQtYWQ0Mi00MDBiLThmNjctZTkzZDg4YTU2YzM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE4YWQ5MDk5\nLTlmM2QtNDY2Yy04YjM2LTEzYjNjM2VlMTFiODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNaFEQ6GpQ7zzglobMGWw/UIFtbLnWhYMZlt8dShDU1FSS7JCoTN2Axg\nymysdb3w309+qiNhxx8IanqzkLKpN+SjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN+fbSlK\nCX6XLJJRwpGA9SaUoc/eMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAgNxcBoNQGURfXRfOa1kkAnGANGFCfbZJMyAI3\n41vu6AIgYjw/lv2gCaLE9Kq9RV8Cemcn3Fs5fuA9lCVZpicYRLc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5745", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5745` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISARoiV6q+logp8cxHkEUfK9TlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlZDZkMmExLWU5ZGEtNGY3ZS05YjkxLTVlZjYxNzRiNzM0OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU3ZmVjYmEtZTFh\nZC00NTI0LWE5MmMtZGY5NWFkODY5NmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmtNoDjXAWETJojAqn4zgIG78rrjNA8/LpBzC+kBnaGcEZq3NSG0GvxWFqMNE\n4PhgqFTT1mASB6esJlKrDsIj56OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjKsycFqiyIdn5/8oHJQ1LfWvWSIwHwYDVR0j\nBBgwFoAUZdTq8Ribg4JGVKIOXQpB3c1oP08wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCLuIELDhr8dI3qZ8fx7E7lyXpuQrlgKzO4pRJU\niTm57AIhAIY7xYkfSWSYD6Vi8ox4L1iL7dD1DIoAClVUYknofhRs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASbIYxVnIgekO9wcV9wvOSeWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWQ2ZDJhMS1lOWRhLTRmN2UtOWI5MS01ZWY2MTc0YjczNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdBr3dfREtJLDVqvdbkyibBay1rR8VJyiN+PqY52cEkOhA\nz0iKaxsOoS9167/nnSJWbxdlpOwVoCwgfAEB8sIvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZdTq8Ribg4JGVKIOXQpB3c1o\nP08wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFPce9XNRqlWm32RPZwtfKR8ZfTYGF0/pw0jhcUK5S30CIAPRJFMgDWjt\neQ73eyhcxY9a38qcmqoW0j0Vrd7Zq+e1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWzGuZ5Eo27S8fRosGuFiOXTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU3ZmVjYmEtZTFhZC00NTI0LWE5MmMtZGY5NWFkODY5NmIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI1MmJmNTM3\nLWNiZTAtNDlkZC1hMjQzLTM5ZWIyNTY0YzQ0MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAnC06l+6CBWtUXK4JHo22ZOJh+ueWBGtOd4UJEsjQTDTNGjh8AMxQbX\n2pKEgf6yZf1AUMl41gzl/JeTH3Qur76jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIyrMnBa\nosiHZ+f/KByUNS31r1kiMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiABjHM9ry6mmv/MsCR19lDdzApMIiLbtNGtxI5r\nB9wkjAIhAPAM6OBNc3Uq6D+y/4kcWHvUdazdyGyK07EOooujH12y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5746", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5746` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAT8sNSyZFO8unbS4OHKC/a8wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4NDA0MWRhLTUxMDAtNDFmZC04M2I5LTViNTFjYWM0NTg2ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJmMzg0NTctYmI3\nZi00ODU2LWJjOTYtMzQ0ZWI2NGRiZDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBCH/8ObGovD7x4OfH+QU3umVp0e0S0cwLu1fpHxiro9nsm71DkGTzeG9ODBZ\nINvKcaH5ESAi1pi5IhLXiQEhjqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy0pBpgNDv2FZ5NhSASvK7Ra30ewwHwYDVR0j\nBBgwFoAU6q0AS/m24kwNXs0wH11Ez96cEhswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIGmdd/dQs9a29OfMGMbT7MuYnZWUBr6RBSwSW04z+sZ2AiBC\nNCyGAycyqhYXmp4crOle3EMw1V46e92Xf3ZZaaq0Dg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUd+UDfUhBDVu6Gf+JbsTFzGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODQwNDFkYS01MTAwLTQxZmQtODNiOS01YjUxY2FjNDU4NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSdBZvl5FUWD/cxH3HNpdUkoT+g5TUsQFG2F0V7RuKJtnA\n+4to4G7mlCrR12GoPaZNJAO9kS10lgs8JCN50Ks6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6q0AS/m24kwNXs0wH11Ez96c\nEhswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga3in7apyUMbGlSdhEXZE4jWULnXeIWJMR1swuRXP5VICIFYUO7hz/Ro5\nfvf3cjAMSCH2yD/YuMfwoPmyeClAei1v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAQQlSq0+GanjHDj4e4v55sfuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJmMzg0NTctYmI3Zi00ODU2LWJjOTYtMzQ0ZWI2NGRiZDdjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDMzMjA4OTNm\nLWViYzQtNDUxNC1iZTQ2LTE5M2ZhZDVkMWVkMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGn27FWEcK1W1yGMkdvE1iGl/R6O/R0gzVVONZomBeFCC+rDxGAF3chD\nwJyzab3QEVvGCb7dN4ZuiGQqcqsfJgajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMtKQaYD\nQ79hWeTYUgEryu0Wt9HsMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA9Wp9IZfawkc2Akso7feoaUzdHzhfkU8VGC9P\n/xqdn+4CIQD4w4YLDLIO8y/ReKD/Fcx8IrXQe37ZVcnnE3z94KEh2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5747", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5747` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZFj7LzUAcjPvw6m+5zDc3QQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YTMxMzUzLTg0MjQtNGU0OC05MzMwLTM5MTdiYWJlZjY0ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQyZjVjMmItYTdj\nZi00ODQ3LTliYmMtNWZlNWE4NGQzMmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELZifo+MCwqGwJ1kukkolK6x5Vb+60GYGmW3fu06AuNVqwYQAAk/ckNQfb1gG\nGaiS3fQdU7l/eLFgkfkgjZ+PO6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW2dZgB7YS31u2q7vQeIstGrDUlIwHwYDVR0j\nBBgwFoAUSLRt34oBzO2ptU2f2I6xddPxMtUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCrVjgbuwo8Q9NNZWg1mqNU24N7puaD\nyFFAdPJp+q7sxgIgYNov0LAPe3HuiduABcGwEaUyXABRgtadRo5UTLu86ow=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf54CsuDsLpgUjTv9NukPdpZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2EzMTM1My04NDI0LTRlNDgtOTMzMC0zOTE3YmFiZWY2NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy1yylcWHHiaTcMCM4wEAlbK7fgyB1OaxJV9x/AK48XQum\nrgbefXGiF1woSMG2LIXsSMBzLyW7mX3bVLCFZar2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSLRt34oBzO2ptU2f2I6xddPx\nMtUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKVyqLgZnT8BeT8fv7a3RZLrQCwRlwi9iEc+NUSSx5uoAiByci0i8p3E\ndSZ5lWn94tzm0G1cCOruxVGHfay3RY2kMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQAfopW1F+ZkEkmqoYSpt/zuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQyZjVjMmItYTdjZi00ODQ3LTliYmMtNWZlNWE4NGQzMmEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhlNGMwNzkw\nLTRjY2ItNGQyMS04NTFmLTA0YTY2Yjk4Y2ZkMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLjy2/40Gno84xZpHjlSR1UrOk1IaoRYBDJnNbmc/6VBRhFF8Kk6M7Ql\nNlDOs6R8Hi5Tgt9wY9q+uF5hf7sIgZOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFtnWYAe\n2Et9btqu70HiLLRqw1JSMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAu113B6N6GgylG06IAo0vB565TuGG7W9D3YdiF\noz/BywIhALft3Jc227lwjubVUtiqXKN47Hr92axAGiEgF5Gc653+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5748", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5748` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAYgLSgJycbwJaBtRTxkjgOEoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YWE0Y2RhLWFjZDgtNGQ3Yi1iNmZkLTQ3ZmI3MjU1Y2NjZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDIwMzRjNGUtOGFl\nMS00NTUyLTg3MWYtZWY1ZTJiY2JkNjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaUa47Gp0Y5j47xy+L4aqezBps9YyOjnziWa4xR9cuZIBKoR8pjyfQakqkKxk\n4sez6WBF75MMwnDoTGpXdUlzPaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4N498lm0e0ndoweI3MEo38pSDNYwHwYDVR0j\nBBgwFoAUnfJJ/c6H2vkYHyOoXotRlmzaM+AwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDaT48q8PLezBqr5z9NmnAYeT/SSBPl\ns/HyI633HYrokgIhAPNukQGoYrOqUXaX3sniydHrNr+PnRnrln0wtAd/0g03\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASJRhymocOqdTQ79hQs2p69kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWFhNGNkYS1hY2Q4LTRkN2ItYjZmZC00N2ZiNzI1NWNjY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0LhyOoeimN8GpJJPIG39zkSHo/zJsvkHN3zSjDsop2x6V\nMKCoKNMxG9p5N8REr/em16OEGKSdCQ9AHhZ5/5ezo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnfJJ/c6H2vkYHyOoXotRlmza\nM+AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfXURf1EPsJZBk1M5gTwrmIz5kSjjI0MaD+9I+yhUxFsCIQCRyaACUuP/\nr0A8V7IYAibgfIut0aYI5FWpbXnuJfsbEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAV5TKwLS2olIV9zH2MD2wgEqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDIwMzRjNGUtOGFlMS00NTUyLTg3MWYtZWY1ZTJiY2JkNjI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdjOTgxMzRl\nLTk3ODktNGIxNC1iNzNkLTA4NTA1MjcyYmUwNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHAal/Q9NKhJ8i9h3vVhSDE7XQQQv2SJ2ytSkPAr8Nxcr+ZzQsLWZl92\nxki9jc7nSUC521mlR7eRhEMUIXiHuaWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFODePfJZ\ntHtJ3aMHiNzBKN/KUgzWMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiB/pVYBS3nfmoIZGloJSQTuHg0EAWPZ2atyueJV\nJfGyVgIhAN6jZBzMTQd09M02BJbbKoyK2XOvutlJRAVNDJ187Hwi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5749", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5749` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVhAHS7VXTz/CjvbIsDfIiT0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MWFlZjIzLTQ2MzgtNDg0Yy04ZjQxLTNhYWFhNDg3Mzc3MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDFkOGVjMDItZDE5\nZS00YzZiLTlmMWYtMTRiMDI1MTBmYjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Nyv04BzhHXehsP9qP/Ej2xhP7Kuz5LF7akuIx8dnNl0Wje6P0hbrBRgH5Gi\n3W0QXmEUitL0O0bjRHaXLxvqeqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUItwvf6gU6Rc0X2+DXQyq4yioT5AwHwYDVR0j\nBBgwFoAUuUs7k4DAMPKqISeRmlyeiG6ec68wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBD5e4jyC1e8\nPKeQkWrINtcBOIwzaxOKhyAhxOciJLbOAiEAi5WQuzw500qEEcz4RhqXiCn/MMHN\nc/RwmuzF8+hrQ0o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV7x7P3JNWsBcfkvcppYQb6NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzFhZWYyMy00NjM4LTQ4NGMtOGY0MS0zYWFhYTQ4NzM3NzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARU8AlK3YMZSR1xPF9e7aJ8NXI3Ak25/QiV3lon4P6se5rq\nZU/Hw7GsQumYmMSr344vvLacQbc2eEFnOu71n8EHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuUs7k4DAMPKqISeRmlyeiG6e\nc68wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgap5qkxLuM1jukDbJ4S1b+OUX79euU2//THqrGkrp004CIG3OJye1Xfx6\nd9TZ0nGz5ruLfzs/imkr9NZlGbpUevfS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAfOW9D+jYaLTn7B4Ums0icW9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDFkOGVjMDItZDE5ZS00YzZiLTlmMWYtMTRiMDI1MTBmYjliMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVlMmYxMGRh\nLWZiZGUtNDYyMC04YWExLTU3ODljYmQwZjUwZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA/TB4YBywxywPPSKebAQ6rOXvebtRBjCewtZoNA0UnJezAefEE2G0fN\nphfIjBQRfLVN9F0HkRspsaG1FKdEkhujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCLcL3+o\nFOkXNF9vg10MquMoqE+QMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBgEM8FkKR22/iJQ7KEKAYisDKe27gZSStrSISI\nIcqBWgIgbzx2QU87AH0ozvolJ/rcpbTz6YDKA+m1hoGHYcM8YIQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5750", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5750` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAfIWZgLs1DIAFp/nv5cRkSA5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NWU1MWViLTM5N2UtNDA5YS05MjM1LTU3ZTMzMmQzMDFlYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY4OWYwMGQtODYw\nNS00N2VlLWEwNjQtNzk5MzNmYTAxYmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED5STKzxvOcuQ8o/cFvxWr5Jvx6qrCnN/7CoReJofZBzM2CK/UNjG7ge0855Z\nSIQTaCvWemqMLCBJwgFlenIAmaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrsJVEQ+PX9j9Tm4EGUsHRrpTdSUwHwYDVR0j\nBBgwFoAUfVkWAljtMlgmH5EQvS34B3NqpUAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgXdQOlcfqhBYckrzxFYm3phwlt2Xdb5C7eipkXRk0Zg4CIHBRPQ99GCuC\nIXufyEtcxUfhOIewCDVQvK3l02T1cW+n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfSsFLr1Sg8cYiCoNSUuVE21MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTVlNTFlYi0zOTdlLTQwOWEtOTIzNS01N2UzMzJkMzAxZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQkERDg3Xlx4umsifvfBH5pZXAZPLFxdonsXbpOTqjYqdK\nxnR6ZGSRnSaIlcK+gZZ+Zksqfo4eIWOsEFUMJZ0+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfVkWAljtMlgmH5EQvS34B3Nq\npUAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW8QFYIsXPP6/sjWDW9ybT2uM4/BFQj/fZEKwfPyFJBUCIQDxS4RNXX+t\nCTHIYN8jT8qspszKZM7CxH7U8OPdIEOsOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWFHnSAzYaO4OBiZkFZKA19hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY4OWYwMGQtODYwNS00N2VlLWEwNjQtNzk5MzNmYTAxYmIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUwMGM1ZWMx\nLTBhODMtNDcwMS05OWQ0LWFmNzAzMmFkZTc3MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFEFqSoviOGszgV9gumAsWAoGR5WWjmV7ApsUjAO8n9Y9IIpJ4sC1AVr\n1ji7pNfmRPyEfXpbWFRhjkveThu57pqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK7CVREP\nj1/Y/U5uBBlLB0a6U3UlMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBllu4T8RWGFqVsE35LQwnWDnQjRSedVy32w3Iv\nsOMWDAIhAJD7UylHBV007pVMT1nUE19AOlo+ylXOraNMbEgrz6qz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5751", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5751` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAdswNWIubl+eGG38iSZB35LAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmZTRhMzY1LWZkMGMtNDYwZC1iYTBjLWEzNDFhZTgwZDQ1NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2E2NDRkY2YtOTg3\nMy00YWY2LTk4MGQtN2JmN2FkMGI1ZDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEghfAoAS4yHR6v24yqh9pJw0zN4yw2RFypulP7OJNgHm6l+Z8sNDSNTkNSPmr\na6RhwPLBFpHRlUAvb7PoThyf6KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+gc5sVTEBGftcsj9HSDvDZQrHcIwHwYDVR0j\nBBgwFoAUwtRiWo5pC7mCFNJQnqv2potN2RIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgCmzikZAIp5tkGxkZSkswNeFPrilieTmWN+Ti6Fb3xRYCIFvxA3bZsApl\nGerauZz3ujSWDQoxLiCzPJ4RmpSYCJlu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYZaaR681rqeoHkfp5rZwr9dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZmU0YTM2NS1mZDBjLTQ2MGQtYmEwYy1hMzQxYWU4MGQ0NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPU0pQ859PubNEvwBRtzJx2SVq4dZ6+EJJCpcAKL3veIEu\nl0KRVshS7srImKqgWYXAIPurffNCped48Ujji5r4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwtRiWo5pC7mCFNJQnqv2potN\n2RIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJrtVuTz/PsBlOV7QURzNPL3PRxNpkGaOHfjwtwlXFnPAiEA+MBR11xK\nP2DYnhyX8kL2xHJ69xaJVRmfJB4zCYwWc08=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATfuG3qMiLkeDJwxzqledhWBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2E2NDRkY2YtOTg3My00YWY2LTk4MGQtN2JmN2FkMGI1ZDE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM5ZDQ3Y2I1\nLWExNmYtNDQzZC1hNmVjLTZjMzJmOTcyN2M3NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO477CB4p5GZtROD/hh2/4iWpKrYXH23L3rZXxX1wKDjodDpxX1IwuNI\n0RzLtH4H1HMCOzduQVaZldezFkEJ0M2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPoHObFU\nxARn7XLI/R0g7w2UKx3CMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAjzCGE9PyeGLQe9m8uNxfrkC+0wPoNw6svbPG\nOC8BNzsCIB9THstInhnuysAb084596lyjuh2CA0pl1JNymd4xpjx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5752", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5752` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAU7/MmfHHZ92GbsEUs3BHZuQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkMTQ0MGQwLWQwYTAtNDZiNi1hZmIyLTE4Njc1NmJlNjkyOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRiZDkyNWMtYWNi\nMi00MzYzLTg1NGEtMjY0NTMwNDEzM2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE0PCVW3C0K3Po63i1LjyfbOW/W3QEfhlrmAaRzGbYBKSnGHAtTnpzQUS4B5j\nrw7SFiLIr1glW1YoyulWRpEAEKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFElq6/ZnGL4CibybFFYSAMwy7FIwHwYDVR0j\nBBgwFoAUI/KElNx/qtQIQc3EsCj23N9uqfcwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIHUEH1oI1pjCOoIXfTm5axrkNK/YwAbDLsa5RgYMuRcaAiEA7LJePvhs\nGh0mo+lKKMgVAI3MhSNIhg/cId5CjwoNukg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT3dvkBcNPaH1NrleLuj95UfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDE0NDBkMC1kMGEwLTQ2YjYtYWZiMi0xODY3NTZiZTY5MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQz4Gx+EAzuXDw4XvNVkDjPJ1wvNQqaQWgHEvmX0G1tHR92\nWeOKekPj2fWDEk90PiH+/4yh27lTWRARq3hxwNEbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI/KElNx/qtQIQc3EsCj23N9u\nqfcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPgO6RqpGD5t6Gv4MIzSLzc9tw3wSCXiNFqri0EnHycIAiEAyi7/ftiW\nqZbaY6TaVvn2lq9LiWTs/Of93MyZ2Ad5JMo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAarIBBW7kTrRE0fBsFOvAttZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRiZDkyNWMtYWNiMi00MzYzLTg1NGEtMjY0NTMwNDEzM2U5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE1MTk2MzE4\nLWRlNWQtNGNhZS1hOTAwLWM2MWIyNjk3ZTFmOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMwkHd468+FwvFgHlf0gIpcNuc90D7dS0FcErvdkfOYoB54nYgCtSuZi\n4kcPcVH6JiQeLOoNyn59Dj/Vyz4KPc+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBRJauv2\nZxi+Aom8mxRWEgDMMuxSMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAaMPMQJrJYSvWExIDoJho1/PjSVpbXuOXcMqTk\na/Db+AIgJ5A9TDF8ab9kjI7EHm3rBXWRC8MulrWKAaHcqiZfalU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5753", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5753` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAey7K1FGNMbpKk3ZrJYEBL22MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmN2ZlYmEwLTkyNzEtNGYyYi05MmM0LTRiZjJhY2M1NGUzNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U2MzQxNmYtZWMw\nOS00NThjLTkxYzEtZmUwNTE3MmQ0OGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbV+IoxmhX1Fmc5QBonLyeLnqoch+IBPD3W89+tJWzGPAJc4jQc5QiziQeEXA\nlD1y42Ja42l34IUZmSej6H0RsaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURTxI9HnGjQyZdhXXFiHtZ84PhQIwHwYDVR0j\nBBgwFoAULSvZt8Owd3ewevSawJNCNXPrIDowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIAk86wFssHg8qIM3iarhUaUrSnON4hU161VsxxqG\neGUlAiB4YuRDyfpSW7UqvPVtqMBGA8YW8ZcVgh/ZZrVDpjy6gA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfwUMplox6T72PSha78N2EGPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjdmZWJhMC05MjcxLTRmMmItOTJjNC00YmYyYWNjNTRlMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS249yt730Ts/1aoVkGvCAT2Pag/Y1BsvNi4qOatXMfARIb\nGI/1/mhqsevO7X9ZqkSeq9ViJwA39L7XJhGuV75So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULSvZt8Owd3ewevSawJNCNXPr\nIDowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOC5r1TiQt++3kJ3iPak/iTs2IORcIswGaPyVL1xZSZCAiEA8q708/Vf\nebv+TFpBxhrIslO/qsm6tNE0L/QUJcFgfmU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATqU9876eJH/ARBIrJQOC4NvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U2MzQxNmYtZWMwOS00NThjLTkxYzEtZmUwNTE3MmQ0OGQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUwZjgyNjJh\nLTU1Y2QtNDM1Yi1hNDAwLTU2Y2JkZDJlNTQ4NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPQ8vNvtKKe7F9kRghHU0Yg1lTkhQRzGWVlv29QWAZiymZYs+hpz0Jfa\noVX0zlOWjEURwbj+CAYjwAKonX5B4TKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEU8SPR5\nxo0MmXYV1xYh7WfOD4UCMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA7KlWOQxXTZuU8xSCRF42a2Jr27tDZOgfIbD03\nuC2jNgIgfUi02vWEbw4ms2LNMMP8R/OiGY4Xmn6ifgRf2HSPprU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5754", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5754` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAREuUlqH1AK3VmtBySW/xNQ6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjOTM1M2RmLWNhMDgtNGZiOS1hYzJhLTRhNGE4ZGRiMDk1ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTVjYzJhZDItYmJj\nMy00YTBjLTgzNTgtMTEwYjczMmQzMTI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENKUcRPmp1CkqwG+RMBdY/bgZVSDzJug2r5Q2WRjEei7P6EHby71IpOV5f+Dt\nqmNxrSOula6GRHWJhU6QVu+LtKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi2kDlzNkgi3Zk/zi5QcJ4+QFPdQwHwYDVR0j\nBBgwFoAUql1ZhJ5wjd2A6CNrE8DrM7soD0owRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDLNMfffQbgqd0QfmWic9SVhmE50Rlb+9X/y5hw\ner8oqQIhAPk9xtJR09A+Jw8gDYmHuZAKEBiPcNd4Z6ngdNJZJZtx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWCJmBxZB+yhHTczJo91rFxmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzkzNTNkZi1jYTA4LTRmYjktYWMyYS00YTRhOGRkYjA5NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpi6dOVDWvgnjuA/r941E4TYpD4MB/wS9t5m7ltEExHd/M\njTUldQJSMVLmprNbBsix0UTDytmwuCyZYSPVpw+Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUql1ZhJ5wjd2A6CNrE8DrM7so\nD0owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKGzXV9nG2+Ja/wCwedOqUItAWkU8z30VP0+ihJMjuC3AiBbbl9Y0m7S\nNyZn3eWFq2LEvEYq4CtQepiB8LrukG3DPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAedY0DvIPDynmtM20Tqtc6uIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTVjYzJhZDItYmJjMy00YTBjLTgzNTgtMTEwYjczMmQzMTI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDliN2IwMTQ2\nLTM1YjYtNDgyZi1iMGY2LTRlYzVhNWRmYjNmYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOY0PfAZ5ZV3awOr4W/79kweLC82cSl8DUABjROFkLOsZedsM2Q8XUgb\nZhoX8oGJluFVXosg5YgSkInkcDRitf+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFItpA5cz\nZIIt2ZP84uUHCePkBT3UMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAyP0bqv4CBJ2PotPrgmIIOvUzifa/9V/I2rqU\ns90ZTXECIQDvZqNBCbildFVJlbJwQu1wP7Edxr4aRbcAlivHL8SdeQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5755", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5755` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAQSVfzQN91Z8NlpUU9p99YG5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZjhmNzU4LTI4ZjYtNDhjNi04MjMzLTExOTY5MWM5NTA5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDIyYzM3ZjgtOTUx\nMy00YjA3LWJlZGItNmY0ODkwNGY3NTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEebhkbtZVVbhZtOAI1mlamuIKQ+ecC6SKxba3+GWBpk5GVJR0NT+aViHvrZQo\nFa0Zf1laUs4qJtkdBp38I9qBb6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3wEQ+diAt6k64wmpVL5C1D/zPyYwHwYDVR0j\nBBgwFoAUE3GZXg+lunAh9eVIMlx5Q3JYeyEwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIDiVMlKaTgwfsDbRaN7tD5wOtjDWiKkIOdRmlpwrREz6AiBC\nQSEzLk4kYZgw/A3+/0gKtS8p5n0VfwGaZvhMbjgt3g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfoXWQfjkMKzEHas4XvH8wWGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGY4Zjc1OC0yOGY2LTQ4YzYtODIzMy0xMTk2OTFjOTUwOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWtnf7DlcTJS5/IOwqlpjmS4rnVYelfQVNCy44pofygwZH\nzmXpQRqFIZY0kMbOZvJfVtcsOGFvSzc/S+GSsN7vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE3GZXg+lunAh9eVIMlx5Q3JY\neyEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKb86cwADbMQoPr3unH7g/nrZlNjGodrnK+Shh/t8PKWAiAGIXzouGAb\n+ghHZyq/5ZHcUuoYMvL1oJdvZt10roQCag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARd9PFcGiBH7d7NQkndXNeiHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDIyYzM3ZjgtOTUxMy00YjA3LWJlZGItNmY0ODkwNGY3NTgxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNiOWM5NmJj\nLTVhYjItNDUwYi1hZDBmLTIyMWQ2NWI0MzQ3MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHMziVSnzGN7OxrBBZO5NgGtdAOb+6P7AZiwh4W3yfvRSjUaUMYVGkQ+\nB40MH9v6IaDSabD2xTvxDfrYM3gLkumjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN8BEPnY\ngLepOuMJqVS+QtQ/8z8mMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAzes53Wf6g/fpg3LXflsm5Fv3SRZOiUA+SaQX\n/F9vvQICIFa+aNfFF6xPQ0iNAWMjXy8nzY9BCPLFwcuhoOHWYVQV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5756", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5756` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATQqK3orckoua6iM2idEKxpdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MjRhZGExLTViZjMtNDNjNS1hZDAyLTE5MjRmZTY3NjFiMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ5ODcwMWItY2Y3\nNy00NDUzLWFkNTMtZDliZjVhZmZiZGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUhqP9V7TMs+/TdhcejzTAtHRybaqpFMsks03Ook105KvXyV2fcrLd5Zn6fx0\nqjX3XbNP4LKlDIwPo1V3ze2jGqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMDT6pS067NM5YBhx9a+ANr5FLocwHwYDVR0j\nBBgwFoAUZ2rzSqIsX4qhdQgIUlHGmIMZIOswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCI2gcPF9jgqgZeqXfV4vLMT0PeCQv+\n58M10wGjW98zdAIgXShf9eMCDMpueLmna6BlhUiguSQCDEZuqbhuXtp01Z4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYhNGrj6HS972rsVKBVH1m2AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDI0YWRhMS01YmYzLTQzYzUtYWQwMi0xOTI0ZmU2NzYxYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQOEr1csvLQksGLIEdV85Q5veODo9Jgvv2i1b4sF3jedEq\ndwN0xqKd1d1QTkoh3I6YWZM19WdGDerWpV465Gxwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ2rzSqIsX4qhdQgIUlHGmIMZ\nIOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAITodHlVf3XA+E+Ci+RK8Cy2ToLbM2Is54zmzjIvUj6hAiAMlRsE8Acq\nghNC7qv+SpaAt0IyCznYOyFAmh1LqDIqlA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAXSHppYvoW5hm5O5Q90LVUVrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ5ODcwMWItY2Y3Ny00NDUzLWFkNTMtZDliZjVhZmZiZGQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUyMTM1MDA3\nLTEyYjItNDExNi04YmM2LWRhODY1YTMzOGFhZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFwUBpsrKBmF6KhLbos8Dx24ugCA2/Waf3wiVWsAGd+pLZQC2rC284Ge\nw8VraR2BbQmdchDZEFm6aG9Ed5oFfPOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDA0+qUt\nOuzTOWAYcfWvgDa+RS6HMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAi4VNtiGsY5nWXBWDGtSH2Xj5zWc7LHBenE7P\ntkftv4UCIFlITUyypzSYTGdKQKihX8lCaNyuPt1orP3poS5eZ1Z2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5757", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5757` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbCdTXsYn/JQE+HKC6Lp/OxKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0M2Q0NmRmLWNmMWEtNDYwZS05YjI5LWY3M2Q0OTMxMjEzNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg2ZGMwZDEtY2Y4\nYi00YjRkLTllODMtYTE2NGI5NmQwM2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI5KMbwT5H1DIE5zMRYa8P5v9iHt9keC0zN6eoSfiTsJLxA38B1OMO4x3QOgS\nPPclOomkzMO7AE5SaOmNkQMiyKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU23LwTeAGFvJvEEwNx/qdPBpQ1LIwHwYDVR0j\nBBgwFoAUMc5XKG9mM1gCo471xUhgwmPL858wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDqoT4e8/eoCHlkiD3JVJIAlOqmPB2J\n40I55zDyo+pTrQIgHExOmzl159kcmJwp1VP6UVjaHpL0ZTRsNU1RrmrPR+8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcICpyfZmUtUnCVFr41DOR9fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDNkNDZkZi1jZjFhLTQ2MGUtOWIyOS1mNzNkNDkzMTIxMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHjMncebl0mTEEwdGmAW1SLmlR+F1xEsAMyiBExPJyjea4\n9bV+IvInhhzJ0AqZvKXO4aZcYbzB+FFP4Aq2v9LPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMc5XKG9mM1gCo471xUhgwmPL\n858wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOk75gDTjlm+n5sgw11pa94MD8xlo5axcGQTZrsJyFH4AiEA0qKKL8Ys\ngD4ntzqpV/UCGfZMJE4ktUyK6qjRlPzevUI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAWXRModaYrCa9SNueNoS3SN9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg2ZGMwZDEtY2Y4Yi00YjRkLTllODMtYTE2NGI5NmQwM2I4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI1MmU0MDI3\nLTY3YTQtNDRmYS04MjAwLWEyYjFlOTc3MGI3YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEbbmOiGGhn1CWrscViwUramJVtMF6Ipr5S95NBwuad7ATNo3YJ8gzJz\ncHQhzegKAR6fP0Lt68a2z4qM7xoT3yKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNty8E3g\nBhbybxBMDcf6nTwaUNSyMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAu47okY18C1jEppsHh99+faRkSqHW/GDDaeRX\nrzlkEBACIQCC3tkyym4zgbTe95/+cSvc6prd9buYj69gUM8XaDCMTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5758", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5758` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISATllJGUo7Md9ULJid9ehlEVTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlYzBlMmFmLTZlMjctNDM0NS04Y2RjLTc2ZDhmY2YwMDk5MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmYxN2JjYzQtNWNi\nYy00OTQ4LWE2ZGUtNWMxYTNjMmU5M2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmqiaPsDiIP37H+Kkjw+KZG5kkIYDBy9LQBIff6dsgiG+icVM2fKGS2CnjEMg\nmn3Oqof0lB8vNvVMA75ZpY8AF6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFK3eVdbWWDmyJNSyFrJGvyXJnCxeMB8GA1UdIwQY\nMBaAFGeV6mm7KwBe9sEmDCh67F/j2hgOMAoGCCqGSM49BAMCA0cAMEQCIESbohfB\niqf+HLNSz7PV+IYGeF7vgYRceIODRIMuaGdiAiAmgeqTF8wZSHY9s59MHG13Hzt/\ng0h3zDQ1yHVuzH9MzA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZcNiA+Vd91p81/V8VwGURC4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWMwZTJhZi02ZTI3LTQzNDUtOGNkYy03NmQ4ZmNmMDA5OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRv+SyOk0aVeZ0xdbCOxdjH+Zp2joWuvqXt6tqED0EgqZB\n696aGib1IrUCDav62gv86wn0wxVH9olJi5/nEIU8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ5XqabsrAF72wSYMKHrsX+Pa\nGA4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALNu7TobgB0j+1VOpOIymN0R1cVoLR6mRRf9xcW7fOzAAiA2Ehc/zp0O\nSXvr+XC+JFm+CJaiEQVyvJmWuGMcJs9FBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAflqMV8f5NKS9anQHDN1JEw5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmYxN2JjYzQtNWNiYy00OTQ4LWE2ZGUtNWMxYTNjMmU5M2E5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGZkMzJhMzQ5\nLTRiMGYtNGI5My04MjI2LTM1MjJjMTZkMDFiZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO1W/gYe5/+d/ONwLsmP8Fwi52eUo1xiU/IjbBOxyBHBW97ZnpsVaqIw\nX78xUvC4EINE/njTzmIqK2KCzC+2vYejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK3eVdbW\nWDmyJNSyFrJGvyXJnCxeMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA3poF4QDe5kIPfbTSGdCasnZSiwNdI61Z4YPf\nx3vyJFACIDo5slvsbT3UdM7JZEJmz510KZWCYif+k0jpdWvbq6wj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5759", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5759` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAWam1bvCoH3Y34o92TJuxNj8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2MTA1YzYyLTc5NWQtNDYxZS1iYTJlLWNhZDhmNWFiZjdkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE4ZTRkNzEtMTc1\nNS00OGMyLTkwYmItOTdkMzA2N2FjMjIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEPXtt06wyjdBTqPbTmZF/UAg/uhM0L2FDsNSqT1TArXNHiFnZjPbE/X9ThTT\nyfeu+j77X6YHFZCJ4IBgky4cjqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKG5mRwthxtssCcDk/RXxO0mRgg5MB8GA1UdIwQY\nMBaAFE7BoicNwmbx3KJo0uEq/dW6+rzSMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA0JPjDJtL1alV+mNrUkJpP4MxJBU08HOc\nqQAND216mPoCIQDOy6leJxH7DhNIRlsxDJg0RkM1H8SzwjUoCaJJ2HXbIQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaaAqBVswzbIOh+LXtdXcQTzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjEwNWM2Mi03OTVkLTQ2MWUtYmEyZS1jYWQ4ZjVhYmY3ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGHMssgRPKV33b+Ij7gkBvLqYYnPP7B8ZXVTHTjRICKU7g\n138bUwCr/UfZaQSVFUERWgHssYnAkb2dnF5zK5Mdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTsGiJw3CZvHcomjS4Sr91br6\nvNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfsroyKWUWvQ6UFWLoFTfNVp8ns7gMa18U3KWytARKOYCICCc2TTp05Rz\nwXaUWvkNc0fYQfV4375+8crA5TSEu32I\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAb0OFxO0Ofiz8YP9QCqguX/RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE4ZTRkNzEtMTc1NS00OGMyLTkwYmItOTdkMzA2N2FjMjIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGRmZTJkMzMy\nLTdiMmEtNDU3My05MzViLTU1ODc1MjQyYWZlZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLodOUiG3mKDUI5aUJCZj5SJVQY43Gf02a6tOLZMnX8xHdq1gYvzbhTF\nLEOIxz3gJi4EXodF+rfFuprWIiNjuPqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKG5mRwt\nhxtssCcDk/RXxO0mRgg5MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA9jgt6XqFLXNsqZ54/YiQKLcQLKt68HCXY/6T\nV98k+t0CIF5Bpw6kjyrSfCYhKhiv8bIRySq0+yEg3bw5NswxaVx0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5760", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5760` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAdU2AtOWRTFWrD53u0JUoXvxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkZWVjMjVmLTQzNzctNGJjZC04NTRhLTg4OTM4MWIyOGRlMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJiZGU5ODUtMDU2\nYS00MzUyLThkMTgtZTUzMjRlM2FmZDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7fpaY9TgaC5B1wXeju92eerCpR5A9rEI+I7ONl9aWj2xxOGhMd+zbsQHGOhT\nvoeBWrXCbjPjMAUJB1ldhuIIMaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIzN6S4dyFPMYy/lAkn1TdYlZ0xdMB8GA1UdIwQY\nMBaAFNGKNmLhNr9+WF9wgBI9y1wsgM/fMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAsxRN/MzrlEucAOcSW2ZeNpa47NX8svO1V\nVXAULgX0rgIgekWknESn1q+bUjbMy+NR3WA5FSs81t4/RKtwuKGFVVs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVmvAKbi7g1sc9tE9a6N+dz/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGVlYzI1Zi00Mzc3LTRiY2QtODU0YS04ODkzODFiMjhkZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShIaOS6y9iOH/TaB63I2/dx1B4/Dda/wMcwHjnC9vxk3lq\nTgok2WYXlcqxTGH/sYjSmuk73XIomEzLPc1SHKyBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Yo2YuE2v35YX3CAEj3LXCyA\nz98wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEZ2c2zwUHxBIMQxT+ZpcnLaQALu5oesrfYHnDpBncJECIA73vYgbQlx+\nNLpEsXj36NtY7SOFuHO5LZZCV+XLl8yJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASUHB95uuNYv8d0h5BtWdwyFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJiZGU5ODUtMDU2YS00MzUyLThkMTgtZTUzMjRlM2FmZDFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQwMDU2YTg1\nLTM3Y2MtNDc5Zi1iYzM5LTk3ODg0Zjc0NjhhNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAOsEwl7CJyUdLGakdneFM6gx8D5o/0axAmkR8Xg5wcESQDR1WC6SDBa\nUWC99tNxeqU5v8GS39qJGVEE9bNgu0CjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIzN6S4d\nyFPMYy/lAkn1TdYlZ0xdMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBLRjbRHotKGa1p+gvSvgeH9ml6Y7mA63dpkiAF\nOUIqbAIhAN3Bl7L0JX6CejNsnV724iq5HE0BzYSmBD0SQyx+wmhs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5761", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5761` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYTblCrafX2L8oD71qPWp+WSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkN2Q4YzM3LTk0MDctNDcxYS04M2Q0LTliZmRhYzFmNzAxYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk4MmUzZTUtNWM4\nYS00YzhhLWIxZmEtNTMyN2EzZWM0ZjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7MuLpI0YVHmXA1WK/ev36o8j4tqs2IhHSFKS7BHJ5CGY86ChpcDpGnmdwIl6\nVs2Aa8evlxkduwDk4E7y8HqLuKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRa2lHtPzDbR12LH+JOJEFyVuEafTAfBgNVHSME\nGDAWgBQbC/zVvzIkZjL0CM0Hf3/Avlr3WTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDs3Tup57loCWRDCCzWTk4kNDrT85Tbc\nzZWDGIOHY7OLAiArJhWqtpxSgg10NcvsJFOP7oWIryN0kGJYPGdjlhF1jw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUzzvNCIzh3oWnZNbuTTUQshMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDdkOGMzNy05NDA3LTQ3MWEtODNkNC05YmZkYWMxZjcwMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbc/BLTO0+d4oTSB4AjsB/k9S/DK00o4AO5+g98wJPms53\n0iG5yFLpd5Co3S9L7T6gJbfgRYJqwG1JKRjyQGCuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGwv81b8yJGYy9AjNB39/wL5a\n91kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANWbHYFM0XwkXCEacfN47Gp1M0fgC+MhRvU4VJV7mx1RAiBnl9hk4vwv\na+ly5+JCVbAHqAYF5aB8iRpNhT4MhtR5Sg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATbk/bs2Is5XWkPXekb3/j6BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk4MmUzZTUtNWM4YS00YzhhLWIxZmEtNTMyN2EzZWM0ZjU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVlZTUwZGFj\nLTdjMzMtNDMxOS05MTVjLTFlNWZhOGE4NTFmMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABB4GXq/Mdbp71gmOlLblDuyftZMuWCjqHES+vZ5THShsBZfzZB0Hf9P7\nI8Sn5RS2o6hyDaFohUFvmF4AbalKPDGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFraUe0/\nMNtHXYsf4k4kQXJW4Rp9MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAJsjIDSTwJByl128E4roy7b2CKo6dpy5TTLzms\ndaglygIgRIEwHtRhj+Qg58XEspgHkPVPA3RVjEvo+dHehFInWtg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5762", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5762` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARBsVbTSVDdvGuK7aieNA1XmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyZGI0ZmY0LTNhMjUtNDA5MS05M2I5LTcxNmZmYTRkMmMzNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYzYjg0YmQtNzQ2\nMC00YjYwLTkxMmUtNDJmNzdkNGRjZjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc2rwvXuA32zSrCEyTO4uHjEttFb82WDY5qUp0GkZ6WFcso9+T8wC6y1gs9P2\nY/NlBzPWyABnGmAMA3wkP/5b86OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlCXdYtgsDgULhDdodQL54+1VWcwwHwYDVR0j\nBBgwFoAUyaPzscG8bGEmj5WBGJcaPfRxjkEwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiArimwSWa0XV/4H\nXx72nxxFf+EmGDREIJR4z+A/l38W6gIhAJDc1UbjEP9VNGErtsmZFhZV9wujyf/g\ndnvh73Nk7GEJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbL0vixNkNFKuOwsaZPgNiMVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmRiNGZmNC0zYTI1LTQwOTEtOTNiOS03MTZmZmE0ZDJjMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjKpvm+G2Ro4GW3ojLCsoAf1704h1et6cUf8idCKaUvf9v\nrUocfmJqziuEKRmEUo3zApylCieFaQxMrLGkDckoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyaPzscG8bGEmj5WBGJcaPfRx\njkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga8pC/y4RarGjYijJ50NUsbjRbvxazUNJNI30wqx7F8oCIGLLVTkCAuHX\nPJ8XhAx//tG06nLaoCwYJub41GbewWE2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAV6w6d+xK4gyDjXZ8lUkX3HAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYzYjg0YmQtNzQ2MC00YjYwLTkxMmUtNDJmNzdkNGRjZjY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3YTA2OWU4\nLWFhODMtNGZjNi05ZWUxLTcxOTdiNjgyY2Y3YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEkOIMwW10S561zsGgk0WVsDSLOiKYjycdkTteaLYYlzSPkH6hVV534y\n4oPpdh4lnEqnMIg95fGsJui3uR6Px02jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJQl3WLY\nLA4FC4Q3aHUC+ePtVVnMMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEApblmutzU6timvzvetlb0JKhxejB5uuTEGgjd\nUuK6qTwCIQCgCqQfJ3C2kdV0nJLynv4wLzTNY5MUHQ5GJySPYiHrHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5763", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5763` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZUevhY/+rFVxnIUg0TP+zhNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMzMyYjdlLWE0MGItNGUwYy1iMGVhLWMzN2NjM2U2OWUwODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdhZDIyN2UtZmY5\nYy00ZTBkLWJkMDctNzEyOWRiMzNjZmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm61C1g4qVXRB0b7XJjooY2gtt1HuTsy3xYuKkFModVse/d8l8GhByUXSFXn/\n6dil38vHOLcr5hwnvcte6VsudqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQRHgGXirw665TcOv6kQEQG4VTaUwHwYDVR0j\nBBgwFoAUBsslKS+MyLdGNh5KMEswpSO86+UwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBjQg3DQ+mWfVPr\nwWnVd7nTkSVwXsDlhc4NzJxaK+Y7KAIhAMVBdty3UM2J2am3yqszk4EHxtA1QbTw\n8qnF7fZ4ZMDq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdd7XdaAEmJGAeOcK81/dcljMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzMzMmI3ZS1hNDBiLTRlMGMtYjBlYS1jMzdjYzNlNjllMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCzUBQgo9Fm8xLTqdpF+gLII4q/khh/uyTCkS5t8ZTBI9u\nE0lVBpb92TYiAiyFYqb4XKirFTCPWTLyhD4aJbGso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBsslKS+MyLdGNh5KMEswpSO8\n6+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK3hNoip+XV1x3MSR7pvBCWisDmhuZovU8ZGPsCWh59oAiBis1qsHBLw\nLjgPX3Cy6l8sBJdlB3AJPdo5UExzE6L34Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATqHFZnODfEvZEgNUvaPiwcSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdhZDIyN2UtZmY5Yy00ZTBkLWJkMDctNzEyOWRiMzNjZmI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFkMTVkN2Zk\nLWJhNjEtNDUyNS05OWZjLWZkMGI3ZWUwNzNhNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLCpV3tRs9vbyv2Ph8jVROyR9wtboR5SUIt7JudHo5+jsTadjyCIUeSM\nG88oXDBiMtXErc0ojgMISlW/A/O4CcSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEER4Bl4\nq8OuuU3Dr+pEBEBuFU2lMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBLyuMrg6O8xfn8Ys5J5XDa5Y3ETL6WxZYqUJdE\niE7w0AIhAMcVAmtkOuQX6Vkgs5QXzHCSTJgw8mC9KkjcO8jLHAEQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5764", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5764` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAcflvjWnmx5jKeyDw1wWaRqhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1Y2RhMGZlLWFkODUtNDU1Yi05NTI3LTY5MjY2ZWU1M2M4NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU4MDc0MjctNDA2\nYi00NWI5LWJiNWYtNDcwNmMwY2M0YTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGeq4rzUeFhRJlnoceP4mZNU8Oe8ROid2l8Hr0rAqJpkM96A3SgNF9lvsPS/Q\nAKAtuwlVMKEAhyPO97bUtRvDD6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpzoaN8KNSrv6B/8fLQhxuMQfEYkwHwYDVR0j\nBBgwFoAUNBDy+gynYxYtzeKobLxeGvFkowkwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAXd4dI6CJjFHFJYFZ5l0DY\n9af04y6cvYOhWmV0M36XRAIgF2TnfwuaCHn8Jpe1AfXwIMlrGNN5AiTYLYYrMmxd\npSw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfavLDQ5igm+8A7vVsUCXqcAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWNkYTBmZS1hZDg1LTQ1NWItOTUyNy02OTI2NmVlNTNjODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASB+TwtUa+tPEVDO+u11Xh3jrzTPWAaEJQYqIwpTS7CrGhL\n26YHcuAnUwC4MPA8q+jpRjJEsX3torn5aNMlba4Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNBDy+gynYxYtzeKobLxeGvFk\nowkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKiWqSJcKmZMl0Akcw9+si6wizeQNiiiIcNRb7lSs7QtAiBNXN6625A7\nJyZz0W/KMWN9FTLjZ79WCa5eqjcMpK3DVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAQLp6Rdvg8HV5038PmzTOKbWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU4MDc0MjctNDA2Yi00NWI5LWJiNWYtNDcwNmMwY2M0YTFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA1YTAwYzk2\nLTU3ZjktNDQ3NC1hYWYyLTlkODE3YzdlM2Y5ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNdo+bZcqMVMuhBhWmN5K0R6xKnYytOAKfSljGBZHNlre5c+5h79psJa\nw/HLzYKA4MaDsbYHjCgtgKFm7d8exoijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKc6GjfC\njUq7+gf/Hy0IcbjEHxGJMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBuHsraS3OARAoE5vemq5P/mfFIQ/ov2sJ/uNr/\nRYbEiQIgCXzLY7tW7cs0rP8rep+/6Y4hnGwtbSnsKtPpZWZw3ZA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5765", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5765` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAd851B/sLoRDq5DSfErWxC6YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhYTRmYWFhLTE2YzQtNGZkYS1iMjRhLTI2YTM0ZjYwMTc5MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZjNmJjNTQtODUx\nYy00OGMxLThjODQtMjExY2VkOGU3ZWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkjFE288HcA1Z7QFmJoSNC4Y3r/1HnMXbK9DAae1gI+1Q0FUPtPTCbwvNTwqZ\n///sw2CnwjSNR07Ct12F9dFk2KOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZM5hgIJCLtOcGEgfo1Qsw9ifd9IwHwYDVR0j\nBBgwFoAUfwtshT4HVbuCC26B8eTZyu2Fn+EwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBgzLNf\ndTna/AR40FSLoVnKCzD6PqAdoO7qv9lE2OIgigIgDKFKFI+yzy9NtmVwUDZmfeP/\nuSUhkfUdC6OWFgFRK5k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfPUghSdn3xRgQt6hFK0LnPnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWE0ZmFhYS0xNmM0LTRmZGEtYjI0YS0yNmEzNGY2MDE3OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvvzUwkjPZl3PTDMwivJYh+On/25lQI2i99axDb4RtAVGN\nGkCRdqd1ikfO5s7pPtalsJ//a7u3dlPi3M5CtC0uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfwtshT4HVbuCC26B8eTZyu2F\nn+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVRuc+NBehqPmOZ4r3/cGkjUVYEP8YzKTeh94mMyewKMCIQD+2qA6T5/o\nVwBC2P5A8IngWMB2IqM8WZuaQG9K3b1jhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUhMpdhuwtdE7/7AqXfe6nWfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZjNmJjNTQtODUxYy00OGMxLThjODQtMjExY2VkOGU3ZWQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJmMWQ3YzA1\nLWYzNzMtNDAxNy05MTk2LWM4YjM3YmU2OTAyMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABO7o7jZPB4xhPcahJE4gjUGd96XP2WQtGqKOyPpENkxuSyc0MIY/YQY3\nxk3HQAj+cGe+Q1EjdZwT42Qi14L00u6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGTOYYCC\nQi7TnBhIH6NULMPYn3fSMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAluyE0UC03nM8M79yrIpEAtkrajqBRGB9UX6r\nkT4J27cCIBZNMVC/TbJiIJwVkcgrKN3Zs1jqtKVyaXeT4suNxXnb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5766", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5766` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAcb2C3qpm2LtHNPI16aTJCWBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2OGU3N2MxLWM3MWEtNDAwYi1iZjQzLTRjMmNhZDZjMTU2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY4MDg4YjktNzcw\nNy00MGI0LWI5OTItNjc4ZDg0ODI5MGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEl831EymizuAhff2xAx0hP75x4JgmHYjj/bE0EzfPBhEvDNAzEnR+jj3rgx6\nsCfiOZpAdOt1/bT4XfyZNZ3faKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUK5gDUf+dGBFmYfOnphRJQTqYzEwHwYDVR0j\nBBgwFoAUS8lBMND+KJ57evaPMtdewsfwkb8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAnrmq\n5Ujc6wchn4ICT0V9IO5pb6pz/qy5jCcnoaWcG/cCIFQudDHiQ3Md1z3O+nqqlm93\nlPDBQKt49FCzlkR+ILD3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUYd8cKhan5W6uleA1Enl2L0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjhlNzdjMS1jNzFhLTQwMGItYmY0My00YzJjYWQ2YzE1NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJ5/aEY0wqm5LcvZOr1FmHmWxZUpJe8pXWlcmDV8c7aMTG\nTw4DDBNRh5WQAvM0zw+wfK/26gozUXOUtmog7eoWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS8lBMND+KJ57evaPMtdewsfw\nkb8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALLu6cymBAgxx7MaXaRpkCdQXfHmw5tN7E7RCQcLSNifAiAjN4DbDNfW\nli9HsoFbrNxkT/AJ58BUK05YMp0hoqxRwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZAZbrnfmV7fb1hjDYxhOYD7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY4MDg4YjktNzcwNy00MGI0LWI5OTItNjc4ZDg0ODI5MGFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkMTc0YmM4\nLWRiZjQtNGZhMi05ZTg3LWEzYzQ1ZjNjNzM3NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIC3CMc3IEJGfFZU55Ag54ruf42asN9tCkls2RvZSOrtsmjeZo5P/SCk\nBjVVn+GF2lihIUKg0wqcizzIRzjv10qjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFCuYA1H\n/nRgRZmHzp6YUSUE6mMxMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBl7+Uf/Q/JdSBmqHYK6STOhfCVcZfhiGNXleKI\nLgGAoAIgZjnfe+K38XLDJhG4MxSRXporPtg3IwRmcjZa3oEBdQM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5767", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5767` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZiQ45bcG44vW2j4NgYgtdarMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkZmEyMDMyLTgxYWQtNDBhMS04MTZlLWY3ODQzZGQ2NTNiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRlYmY0NGItZGRl\nMy00OThhLWFmNTUtNGVjNWY5ZmZjYTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENJxidzO37VsOf1AQ99FozV2lEPYnMO1P2JSjZMdphgly0hgtpAPqfeXd7eOB\nJ56Hj1pkT1JqGhdvbTbvkd/Mm6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGACj6yAFNIA4lYjZht6V/qMNdXdMB8GA1UdIwQY\nMBaAFCVZZt9CkF6d8T9Y2Y6K3DbeYeZFMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAyDsSv5MjFnQ+CVpoC1xPMxa3VeCdJJPG\nJB7U44bVfJECIQDCGQB7oX8rJ3JxgZMHQA5x4i1sZSI16NO/L64fa8/aiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT/kThxhVxJF3NtHtD0EUqauMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGZhMjAzMi04MWFkLTQwYTEtODE2ZS1mNzg0M2RkNjUzYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATapXRb6gDoHGdIk32U+Ge5jrL7kl9UQtXmcmLvHGRXwKws\npPKuaX1Z3FxhDPj7Z8B2N5eHE9X4xRCdTVEBMnYko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJVlm30KQXp3xP1jZjorcNt5h\n5kUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKLFUPiELLo3RyGxi//cZibkNPMdwol/OBvuSuaf71yBAiEA0KTrU709\n7sET/5QfUoLWM4wuv/HbXwXwvNlnYRGVqKI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcB2X5qC98vmjXX4yUhaztL5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRlYmY0NGItZGRlMy00OThhLWFmNTUtNGVjNWY5ZmZjYTM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJhNDllZjdh\nLWZiYmEtNDljNC04MzY3LTk1M2EwZWQzZWJmNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJeuVpxGlqXBQVwx5D4zSx7bLUNb1THn5H5I7XIOL2iZN5KWPF7ao8ot\nzXKU/Su7GqZBMsjIvN06awTWWuqQCrSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGACj6yA\nFNIA4lYjZht6V/qMNdXdMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAwWK4vOYFhgt/JHt3cFNOvELyYX8IaXFF08Ju\nG3jXB10CIBZ+0sfqhpW3U2tN8KdraCYG+/gzKGANMhnph5vv0Fiy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5768", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5768` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWiP58ZK+VTYL6EW586cf1XFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhZjRmZmM1LTkzNTAtNDE3Mi04MmNmLWJjNWU5ZTJlNTk5MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRlMjlhYWYtYWI2\nMi00ZjNhLTg5MzAtYWM3ZjkyNjdmMDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErCrM9mn1S1BqLduLmuFQ5dInYj+l2gN1yrwD22hYbEJ0ER8y6YdmjkgUO8P9\noxFTUVKYMcZOeJmGcnZ1ipBfS6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5uf6JWM+9VufLUwT8LCSQaJdm3AwHwYDVR0j\nBBgwFoAUbTEowLS9CwS7XGVLMhD0GQZ/zP4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALhtUpOLxPRj\nQ0aqV3fuNyapVvjTMJI0+N9CK3j9aOlOAiBtzytvzsctCnPDmxnE5baCup1pjQ/d\nz/9mL2sypofU6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbc3Jt/VVcoOr9YZI8w6ulRMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWY0ZmZjNS05MzUwLTQxNzItODJjZi1iYzVlOWUyZTU5OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwyGf3gb+8FpYQWiXTfGF9kW0o2P4+7eWkl6yiIg+87q4/\n+iA2saSwhg/a36N5JPwkHD50bv+DoMcrItxnTyE7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbTEowLS9CwS7XGVLMhD0GQZ/\nzP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMGIhb2fh2K6igdiOmqJI3iYmF58gEl1eBAIR9SnMtAjAiBfrNfiQjNG\nc7i5o12fIdCwMnUmzLqxRr2t2le5V3A3OA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVaIAaCCnIwP3BBitUaCMDOWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRlMjlhYWYtYWI2Mi00ZjNhLTg5MzAtYWM3ZjkyNjdmMDQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI4ZTY1OTNi\nLTdkZDQtNDIyMy1hNzdmLWFhOTFlODU5YWQyMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLxUh/Hwvy9YbWXcfL/aerzCTtviVPx8PEZvMLxtF0S9PkugLmz9XpVh\nCTUDaNo/CnprVZDnLJnZ/qZblWyxxmOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFObn+iVj\nPvVbny1ME/CwkkGiXZtwMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBK8OCy7j9p5QGYro7b9qNLo1XVpAMAqq32Jnhg\n6Mya6QIhAMAjMSxQ/5CRt8FIOZM5g79yiU7wN4y40XfnZShFAWHP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5769", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5769` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAS/J6+36cVKmijEv/2IVM7dYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyYzEzOGZjLWJiMGItNDZjZC1iZWEyLTIyMTgwNDI4MGNhMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZhZmMwMDQtYmFj\nOS00NTUwLWFhMTEtZjA0MTQ0YTBiODhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6aumjPTVtRQlxlb2d9VzKoWzfoBLdRxej8K+ByHpmjw7od9nd7z4N72f+m6s\n+KqvoHnkScSyaR08pydIFqBcf6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrmllFwDnADs6F2djc63MPC/+TrgwHwYDVR0j\nBBgwFoAUqTYFUbyI+A/nWBUMdZeB/0CV5jAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIjwB63cjVtJ\nV1YrxcTBo8KUCZH9vAzI3vcVrA0FA4g7AiEAj817YFGbavn0RvDedwhAj9NFC6WR\nM3k7uNsuh6u4KPk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfeWKjHB8ChAxNrfHUY5DKdTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmMxMzhmYy1iYjBiLTQ2Y2QtYmVhMi0yMjE4MDQyODBjYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7l46tEbAEqo/8Cj1kzbS0QcVVUY8afgPE0n4+IT7xwrGJ\nejtxBrcg1k8ODQx8KLvmgbpaQWY/Y8vr7h9GIEHQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqTYFUbyI+A/nWBUMdZeB/0CV\n5jAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFbroGDHDJ/JJmzZwKkOL95U8EwYmpFYVCh5RtsukAL0CIBxbU49x+HZ8\nOuoZJzXgq2ZgS+RCczO0dU+DDZi2yvZL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAQUMMFqTHnkMjIcGSxr+5b7MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZhZmMwMDQtYmFjOS00NTUwLWFhMTEtZjA0MTQ0YTBiODhkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFiZGRhMzQ4\nLWZiYjYtNGUxZC1hNzU2LWM5ODZhYjMzNDkyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMk4ZwvBajaDDK2IVg0m5s6uWBjMU4nb81yxoCwf3Egs53LVff52DCQl\ns+FQzDlCExYzNEqRQqDQyLqgG3d9woSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFK5pZRcA\n5wA7OhdnY3OtzDwv/k64MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAAqh0/cOiTmAFKcqXv/32X/PIJe+0WTwNPrNxQ\nFNI+BQIgS+Hk8iTjHOeYem3+yVtR6XCy4rfdMN+7HYQCQ0DB8BI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5770", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5770` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAb4mt3OxgDHW9dFLZTrpJKn3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyNTI2YzM2LTI5NDAtNDJiZC1iOTM0LTQ3MWFlODQzODI0NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQyNDEwMTItMjky\nMy00YzRmLTliYzQtMjNhNmU2NmYwMmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk1iySdp4ZgeoX54R8wJ4BikA0xgjtnZr7zxojxNQat9szK2N1F/+y2N0USnK\n8YrF+gJiPUF8ttsMJkUjDiJbQaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWm3QxApUArJLB7HwOPDrbj4XSjcwHwYDVR0j\nBBgwFoAUDfHLzflAV7iNsfTtN6Rm/5kBrLQwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIESBB4zn2q+/\nvgwiuIvvZR2eCnZxX8B6hSsXkM0shGjSAiEA2p/drilSxdribPgaAzYcYvEy2Cb9\nKuhLuE9Olgl1XJg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR8p7MijP0CuhGZpCzyWmwezMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjUyNmMzNi0yOTQwLTQyYmQtYjkzNC00NzFhZTg0MzgyNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCROh9Wjx3Wrg36tuMtdzkE4JY+7bQLgvNUFUz+TWywyu5\n8iwYkj2rkYx2txQfMhw36WRL6lcWbYfMOQWW7JMho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDfHLzflAV7iNsfTtN6Rm/5kB\nrLQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM3kQ/cdevk9bu50EWV8HB1ao/d8s8/JOs6rlzL1n1zGAiEAxs2UQn+d\nQx93DxPHbCm/+YQbhxLxArG83paZ/FvH5l4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWMd5Ta4DSwSUlYdnl9Rm0V8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQyNDEwMTItMjkyMy00YzRmLTliYzQtMjNhNmU2NmYwMmVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBhYzFkNjQ3\nLTJiMjItNDFiMy05NTdlLWNhYWYwZGUwMmYyZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCYUJxWjXN5zWMrt23Wqcl3NqOFtU5xnOuBjVIMDV+Yhh8VoDrWRXf7j\nzV2TuOFF5zwYj+OoSDJx7G7SxpIYotyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFpt0MQK\nVAKySwex8Djw624+F0o3MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBk0cdPJtr/+4GYea+zxdX0xBOxf7hiBNoiRPdE\nHygIYgIhAOl9OJFRkbFlue648+mdlAzB6mPHqOPCspBrVr4gZ+5K\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5771", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5771` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWDKvlJpXlp6GRTtrpBstxB0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0ZTM5M2U0LTI5MDctNGUxOC04MWNhLTU4NjBjNWE4MDRmMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU4MWQ2NzYtZDRj\nYy00MGNhLWIxNDktNmYwMmNhMzI4YWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP4SUomUkpXD8h8Pqsj6BudCXaCiU2rjZOsblKv0tFiRaGITb7HJyXi/r1EIU\niCwUZ3pjrfKfYtv5pGtd4WdNa6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeyX/h7yzDl81Jm+uuzXTeH9aB30wHwYDVR0j\nBBgwFoAU4BZ9IomXycI/jK1bhojdOtuTWc0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCmivzJc8/+kdmpXzT25USQSJTHA6Q4lf3F4CeDJotFXAIgBAnucER8rw9u\nzNo1oD441DCVA2R5yp+mxgBT0DIPcC4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfIow2L9RYtJIKgwyrn9EPbKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGUzOTNlNC0yOTA3LTRlMTgtODFjYS01ODYwYzVhODA0ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQr3RnRXKmyVxwEkRPjJFY87AI6IU9ktPzkl+8UcssBQlxs\n88eWSGRyG1c+GTZ0doO6dfYal6Cs3SKvBbY0xqPmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4BZ9IomXycI/jK1bhojdOtuT\nWc0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALHwFILizPnolWIcS/38LZXdkVHWX+CIE6FLL2f8j1nWAiEAhZmHJQUq\n9WS2SBrwdIIq0pLMEeqeChmnOGjnSFb1yeg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfgTui0P+NbFt8H/aaZ6vVGMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU4MWQ2NzYtZDRjYy00MGNhLWIxNDktNmYwMmNhMzI4YWEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNhMDdjZGVk\nLTI0YTEtNDU1OS05MGY0LWQzNGVlODlhNGEyMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLi1c3EY64SF2kjWd9/vXDFQCyb8TUwNa+tYKU5J9sBWoKFVN0dmt6k1\n/5G01OVD0PxVdtgpTcUHVs9W4To4dqSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHsl/4e8\nsw5fNSZvrrs103h/Wgd9MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA+PydgYdvJJQcChu8+3NiUph10CTNZKEC5CIU\ns6U6v6ECIHQf/G+4WA4Xp20S7vDhHW7eWiyATdmOXJ085NGso2v8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5772", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5772` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdpGue5/bcKU5CIOc6MvCCeaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MTMzYTQyLTExYzgtNDBmMi1iMDc0LWRiNjc1MGE2YTQ4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU3ZTE1MmMtMzRj\nNC00ZmEzLTlhZjktM2Y4YjA2MjM4ZDQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjywTy17z5mUZJ+BiMmudSOZpXhh1Cy7yK4rxLrkmdkSzCNNC1CKK2w+h5kP0\nSGv+82usRo1N1dAz8xWe9t3qJqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhbLpzGv9WmJ2PgqkQglHoHtF8m0wHwYDVR0j\nBBgwFoAUO2EZDr1QWQcEwB4lwQeywXtFXX4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD36PJIE1NaJlAkcCzsCRSztHM2GqFZ00sgibXa8xz6AQIgATv1NXbtbAxG\noQg1KQGdWMbSdBBELRd4I5F4lfW4sWA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAedf82Aq/rFQDbkjLsWkEOC6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzEzM2E0Mi0xMWM4LTQwZjItYjA3NC1kYjY3NTBhNmE0OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREGW9AeJPKM8Df8+M9frGdbWPgFtF/JZ+Vz9kc+29QV89P\n5kN4qUbvP4VWPBynuxMdiD6MfutVB++OrWS51wBVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO2EZDr1QWQcEwB4lwQeywXtF\nXX4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKtvBtSTMH/oDXvGpbERDgApXbq+wQji446BWi6FziUUCIADvdLVY1/nT\noT+ASEGLZdQ5Yloi9R/62GWA5hckH3S5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAXbIZxbg7bNcQwVex06W+3+3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU3ZTE1MmMtMzRjNC00ZmEzLTlhZjktM2Y4YjA2MjM4ZDQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGExOWZhYzAz\nLTU0YTYtNDg0MC1iNDY2LWM3ZmNiNjMyNjRmMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABInMm7ZqaaR0eC+R4K/EE8PeEkx/fK3GWyi+MJZ3hVkaGhRgGMuRgmxD\nAJ2sRlJLpk7HsJlhaAl4vvs7AKYQWhWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIWy6cxr\n/Vpidj4KpEIJR6B7RfJtMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBH4f6GUIl+gLGh/RCwwDCUd3731dji9R18DUft\n2iPJuwIhAPoPDfkq+APmYmDU3Q/iIiqiHrajJaoUO2Bd74AEztsy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5773", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5773` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAQnpDp2hd/4QWT/qY2jpZLIOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NjJjZTBhLTIzZjQtNDgwYS1hYjQ1LTg2NWQzYTJkMWMxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE1NmFiMWYtOWZm\nMC00YzQ2LTlmNmEtM2RmMDZlOGI5Y2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEltPwTTmA5tMrDf4/hQmP22oK4v2bn6tlfM2l5yE01AjtrFmxCUceZ7j1t7hQ\nn3leucPU3pZR99ziq4mh0FS5w6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU314wFa710M4ZKJw54epOA+bpEcowHwYDVR0j\nBBgwFoAUp9Nla9w72+EjELhyGWitvrFcWgcwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBDC\nFT7yKqxKA2OhDsLas2eL+ZUJaEVaMMJR34y/fohGAiB7eq07ooFroBu4LKoiwbpK\nd7sU24DU/jcX1n4yhsgn6g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfXdhQZWOqDwtp1u32qMKcl0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDYyY2UwYS0yM2Y0LTQ4MGEtYWI0NS04NjVkM2EyZDFjMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcD53y6Ab8Hvj/+sOpksmWdATFx8WgLkYjVrlkb20VaXSZ\nwgDVe2CUQ2DecHtk4R2OfEz1J0jx6vRt5tBirV5no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp9Nla9w72+EjELhyGWitvrFc\nWgcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOpoMFqjxeHzCcmJI5oLrPqQMpQZqlY9kSxRftYcEeJVAiABrWFU8f6C\nW/lbbjxEvkdo51qEFK4iAYbb2iWhE6SshQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWp1yuka34H4i2XEga2+scwMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE1NmFiMWYtOWZmMC00YzQ2LTlmNmEtM2RmMDZlOGI5Y2YyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRmMDU3YzZj\nLWNkZmQtNDEwZC04ZDE3LTZjNjU3NTM0MWQ1OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLVUf+5XjwOyhM6bqSMT9Hqw/LFIcifLrMq291JVj4iDlNimppYvJ5ms\nAecCCHoRzhGXLugWPK15tq5y2fvNeqqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN9eMBWu\n9dDOGSicOeHqTgPm6RHKMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAzjvOHkwnzdIpCoo4wH5U3h2qU/N8H8540Fd0\nahYPHtoCIErkeXfa/5lYyUa6/Hfd4uDYg8oIrzqLdysXXA8/FsMk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5774", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5774` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISASyRI7f0FXwhQ5Lso4xGcN8CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmOWI2MGUzLWJkYmMtNDUxZS1hNTM5LTZlNDIwZjZmZDI1ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjExYzNjODUtOTM5\nMi00ZjVmLWI2NTQtODI0ODg0NmZhNTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBuu8OBe1109UEAymUvIYEnrbPqcngBcWmnu/r9Ln95Ii4kPpxBkDaXps6M6Q\nsiIUSaffdqE5nBXuC5d2dxL61KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2zCpsAfLqk7SqLUTnDPQkfi6bEYwHwYDVR0j\nBBgwFoAUuR8i/v+qUf1Wo+BIxcyJZo6rPbQwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIAOzkcyiGJnGLkJRVvwnlRlt8uTYWT2kOMeltYYo5/RKAiB7f0fO\n97LUC7bXM6gTjdf14mDnMy16mToS3cb1hmkxWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATsy4td06RJlC5SqJw+8snELMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjliNjBlMy1iZGJjLTQ1MWUtYTUzOS02ZTQyMGY2ZmQyNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1wyn6yX5Tzefo1zGtgN9d2K3J/L4DhoOPo9xfFd3H1W0C\nj/C3irQ5FbWCpfitgsy052MgqS+udIHvK6ZEOWZeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuR8i/v+qUf1Wo+BIxcyJZo6r\nPbQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL9X2YR2QJhUl931tH/Iz7bco+6hzaUqVy64E/AHg9xtAiAcj58PD0cX\nmjA+ScJ2uFs4oDCrm2w0TlZyd0zTxIYALA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAUiEhkcwcQXm8ZAtKviYk7JSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjExYzNjODUtOTM5Mi00ZjVmLWI2NTQtODI0ODg0NmZhNTcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEzM2Y3YTIw\nLWFlM2EtNGIwZS1hYjNlLTg4MDYwNjA5NDNlNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHOWhFzIlCm8TkzvvP4l+JrK7ltLlUQFU8hWxSiYd16Et+6gL/nk8dd5\nPzdQAhTDYenpSX0+lbkdhrVA3gjYmSOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNswqbAH\ny6pO0qi1E5wz0JH4umxGMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA5RdsnG7oQsewRSjc8QVtej7rE7yWxAaRThFW\n6vMhU84CIQDDLloqS4uGRCxhV1IM0bwUlK4ymS1Pgvkv24UPLSnsPw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5775", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5775` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAXIZ7JanrlJfLsW0rzsZ4t2/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3NjhiMWM5LTA0ZDMtNDUyMi04MzFhLWVlYmQwMWM5OThhMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ3NGI1NmYtMzQw\nMC00MDE3LTgxMDItZjVhMDllNTI1ZDM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEonzWmX9DfbqHFa8AOYA2bOSXXRjgg+PMwAm8oeLVMUA7Jkp8cjV9Dk1Fk0Un\nskgQPwlhnqquzXj7xAFY3aDtsqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWUHXYD7b00nRX34/SLMDz3GxSqEwHwYDVR0j\nBBgwFoAU8SZ/LWRSUxzFCG0P47Krjlkb7XMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDcH/w8PasT1QLLwDHxG1S4CTuGPoTjLUt3jgEHEF2MxAIgQ9oW\noD1CBJBjBuYXREJG8k6DeU6pdNnpOGx9p00Z7bk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVsuhC8V6tz9Q95NxubGOczOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzY4YjFjOS0wNGQzLTQ1MjItODMxYS1lZWJkMDFjOTk4YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgxPYGQTR6829tq07qkPbOMFVLPBofM6Mm2MGvLx8YCzF6\n4TW6IqBp78+VO//UuLZ/2nEAU5QX8rKMNXTebVqTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8SZ/LWRSUxzFCG0P47Krjlkb\n7XMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM3IyQ/KY8D58LAq2/2jo9+PResARJXZGQwBbgUQI8ChAiEA3PS+8UC5\ngcaNiyW2nzxdZfPP5BEijod0A5HpbYwjvaE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAUc11v5hHV1JDJvAmiR+bVnkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ3NGI1NmYtMzQwMC00MDE3LTgxMDItZjVhMDllNTI1ZDM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg3NWEwZTBh\nLWIwODctNGFlZi1hYjc4LTYyMGZlYzk1NDk4ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG2jCDf7Jl9hZ3U9HxBsQd1Ajun25OU/PXnzwT4XodAWWJX3m0/90OWr\n2L9Rh7VIvYoD10PFyca8uJz639Gl+DijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFlB12A+\n29NJ0V9+P0izA89xsUqhMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAy4jYOou3qzq+g0XXdtfWWxjhpuKNIi2g7I7c\nA/HKrtMCIQD+xgoihSqldgxUKmwSV/0L8XSEfhNY/peTBDORtD64ow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5776", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5776` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAdQK8gq+QJIMWQuOAkDWJvltMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmYjA3M2FmLTViOTctNGJhMi1hNDA2LTg4NTU5ODNlMTBmODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdkMjMwOTYtNjcw\nZC00ZjQzLWFlN2EtNjkwZjM2YzY3NTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKUptreggWvqroO1UH9GLSC2LwcYoYY516IGfXB2+XdmPNLizvJh3jwjkmcd+\n7KRBrgimXDO17RETAmOqOhy8hKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFsJwiIgWwwC0UigThcqPc+wCwZZMB8GA1UdIwQY\nMBaAFGQjBGYWqa7xcjCOQTO4ROtDXBmzMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBQZyfA39kKWjrosAVqlXxsLbthUvIbuCFL\n5tTbueTyjQIgI0gCUBM4cPABCDvEtPBecreuAmq3qpiKgRvQ88qWciE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVHBfMLjCjmMakdIGtQx9ydGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmIwNzNhZi01Yjk3LTRiYTItYTQwNi04ODU1OTgzZTEwZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmBShU4KAsPOn4IJS8W1S+zIIpc6jGUddDrcQrINjGTWPS\nkOHE+mWvUF/wNEpCuA6m3S4hm46rOa1U7qU/6opMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZCMEZhaprvFyMI5BM7hE60Nc\nGbMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYM9QOdB7aAlX7NdxiajxlhkoUjgZtHy9qItbrGbkSr4CIFddkZPNdzqJ\nNthaB4Q1iTVJjD0TXleVgZanjrmeHyf+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUGYsF8uvLP7Ifn+B+7FGk0oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdkMjMwOTYtNjcwZC00ZjQzLWFlN2EtNjkwZjM2YzY3NTY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGIzZDQ2YmZh\nLWE2ZGYtNDk5Ny1iZmMwLWY5MWQ0YjhmOWFiNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA1hrlyT1d6pIh6vKMkqFTbv+AOqBi0SyiYRjAw575O9GGaRukYb9+RE\nAUI558J9M8NsmaEFio+01odIhD3MUBCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFsJwiIg\nWwwC0UigThcqPc+wCwZZMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAoH86uphG6nUHW1fvteA7sipHHPTVQfCF5Bf5\ntNhccscCIFMKOkvjbrQmxtNyeDInANM80GAFOs2ldS42fveb4Si0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5777", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5777` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAe4V6PZ65SE+QRDK58JWBKRTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyMzVkYzJmLTg3ZmEtNDI5Ni1iMDk2LTNiMjYwZDZlYjYxYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk5NWJiY2MtY2U2\nMi00MTA0LWIzNzctYjJhNDIyYTk5MmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEglgqy67v9RgEdj4iorBKWHhJlz5ThRW2f9ktg5xVMYAX7h8boKta3gJJFIt1\n92UfmlfbwN5h4YaZXns2ICevEqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiIqUzNlY0RVJqRMCFqxoMCNwyd4wHwYDVR0j\nBBgwFoAU4xoXzByS/nS6ZDbxFIMBseEXqt8wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMJfgh6tHbS5\nOwAtji39jkCEKU+nzcien29qZmf915PoAiEAh9md1fpM/IVjt6w21lyqL9wBflVa\n5h6DupsvucProb0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAerxzfxszOYI5R7rfcwx+EZgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjM1ZGMyZi04N2ZhLTQyOTYtYjA5Ni0zYjI2MGQ2ZWI2MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCjrwVWoRXPLOzbRhAOhW8phGpnwUrlMWFd1S9l6KTWHEi\nxoYsOeErt+/qkU8BGwkxMTvhShQSv2vQYuRBsi6go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4xoXzByS/nS6ZDbxFIMBseEX\nqt8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKLLtH4sdHReLFWKZDZ/PxLPOVnMMQE+UAk9GNoVJVIBAiAMATRd53ps\n3SeqwqqyA/Xz1dY27dbfIVhuw8U4LhNkEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISARnzKAje7cqHU8jqhgl637IhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk5NWJiY2MtY2U2Mi00MTA0LWIzNzctYjJhNDIyYTk5MmNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDA2NTU2YzFh\nLTA2NjQtNDkxYS1iNTlkLTlkZDQwZGU4ZjQ5ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMzE56dyNzXgYW0hTce/Ldem5SpOx00GssNtY/vOQfxr5UvnanqAhNFe\n0I4695iuYYIMDP5BWws9cSnzawvsURejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIiKlMzZ\nWNEVSakTAhasaDAjcMneMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA/9aIjrZCdpi+rR0F2PSPNxGq20DuOnvSl+Du\nixXkEWoCIQD/HbR7/erk9fbdXfGgZg8u384+Ic8zbBvsomNA6/AWyw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5778", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5778` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAWGZiPz41vWwsmfntP/xaMdcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiMTE3ZGI3LTZhMDYtNGE4OS1iNmUxLTRkZTAwMGU3YTY0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkyZDA2NDktN2I4\nOC00YzJkLWE0YWMtOWRmOGUyOThlOTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyWyqVkTF6IWJZ63m/aCUHFewiVLmkQXc3UrEklxss123yR+xa7DAjdzsD05M\njkPuWIiL2cRI0LX8O36L5tzTe6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnOpgf+qDNmTYERhumP4mnzU21lAwHwYDVR0j\nBBgwFoAUWX2CY6qShjp9sXA17mUFTilhbsUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgB2DS5cm5N8Ir\nKnkFJwOnQgFfvBCf6B9DUlzfN7WYoSICID/z/fmVy+9QS8AW4WrVVhsMIyYvGK+m\n65QlZ5Vgw20N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVSkuoNl0uzAOtQ5M2CYViO0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjExN2RiNy02YTA2LTRhODktYjZlMS00ZGUwMDBlN2E2NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcA5fQZJEU/4C9OIbdMjKIT/sVuNWeWMCBT8AMEZEaLxOF\nr9c3tSopN3TZ870FXH0F1RcVoTA2SqMXTCDm4fyQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWX2CY6qShjp9sXA17mUFTilh\nbsUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANDlWLEQ1mNiSxugbML4cBmW9vimqjaojWsi0CgwCpmZAiEAhFXXxRGk\nVnK1fLt+ZxL1WxVwliJKNDr/QxKFFXsyS7E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeAMhQ8R/JdATNALr6W0Rl4VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkyZDA2NDktN2I4OC00YzJkLWE0YWMtOWRmOGUyOThlOTMzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE5NjllYmMz\nLWZlYTQtNDg2ZS04ZmVhLTI5ZDE0MGQ2M2RhMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDNcX0iT3GpIitOEje/xuo92oleQu+RVijFP0S+NPRhUNsvlprrZQZ2W\n7wfqxQztMTSfgunzcGrygmsknC66K3SjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJzqYH/q\ngzZk2BEYbpj+Jp81NtZQMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAp3ERgnQGcLVfTAKkie96uwBZMS9ARGVL8E7l\nWK4C0BkCIFSFvp/XJXqtSPrNhU8AgKf/eAVt1rfygKGT4aTTnHmS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5779", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5779` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbvcWckYWrLi3F+CmWazMHrAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkNDA4MDk3LWRmZGUtNGEzOC1hMjg0LWMwYmE0M2E5NzBmOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhjNTBlNzEtYWY2\nMS00YmZiLTliOTgtNjE2NDgxOWZlZGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWaJHezx1y+a3M545MrxYl1wjlp0dWTu+2fmrngdNX3bvc/v74F64cCkvkScB\nCSVZQc9OJssidUkAIt7kBc777qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq1uK0dxBHEjO8wgizpi1I5JDv38wHwYDVR0j\nBBgwFoAUPvW6IrLyn957ky0ZLvmKad8Ppd8wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEE6q/q0Z/kV\nkYL+WKOhLoMbGx+hZw8PyVaYftCUZbP7AiEAjrNqEgBCge3Z9rBvOa2cDVlf4BNV\nUMc0aCoRAGZVW5M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYAFLeDljhxQCXDSYAgFHQN+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDQwODA5Ny1kZmRlLTRhMzgtYTI4NC1jMGJhNDNhOTcwZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeguJFVomFk++5xPQiLzMd4fxbwEoNwbjej942YnvTC9Qh\nRsVsGJnTGq7zz/oYLrHOEiGGynLE5x0Dw8kqpVYXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPvW6IrLyn957ky0ZLvmKad8P\npd8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOB51yFQHYJq8vmbKxbNrCGWKRo8YXlWGKtshufgeENrAiEA3YEFEHFk\nQ8LEKb9QdNWRv+76Nrm+eb7zdGU1L9XLr34=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYSUVHf2IMmKE4Nyluw9AtvbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhjNTBlNzEtYWY2MS00YmZiLTliOTgtNjE2NDgxOWZlZGQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdhNTQ3MzU2\nLTVmNTktNGU1MC1iNjNlLTQ1OGU0M2NjODU5YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA4Fh8OxDwuBVBY+cr9gTpVN6YYgHeXRDvqYorkVU+nis1fjzmTAgUDe\nUoYUk8hLFdWYO4tAPglbTftpm2A42gOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKtbitHc\nQRxIzvMIIs6YtSOSQ79/MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA7ZT2snuEDnUulzg+QHs5sKCPqrCQj/op6urg\nSUpT2GYCIBaLjD5DGJ0++iKIsvX2ZG4KjKAyjzO9zdB6S2ZZIklB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5780", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5780` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZeMG0YxClphX7kI9l66rbDkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkZDRkMDI2LWE2MzYtNGU2OS05NzAyLTY3YTY4ZGU1OGNjZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWYwNWUxNzgtMDEz\nYS00MjIzLTkzNzUtODhiZTZmMmYzYzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERczLCd6J9VDBmvW4ZXV2Cjf5a5FdNE8YwWjxgs+XKQ/EwiK8NAJantYYRdxI\netQrPiJclf08BXxc8+GAZRcYuqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpBIy9hn2RprPqUHv7EQ9a5eFzMcwHwYDVR0j\nBBgwFoAUFbb5bC9kxnis7xlZ+XoNo4S7SwAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD+Nwmvs+w9tXQcC5c09foKrryvqRPtTRT1WjW4X0kQEwIhAPKoM9CDwHa/\nPWSRusnSdglu29m/huZMFlJToeraydvK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYo8JiXBxBSiWlJcB/2MwN5KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGQ0ZDAyNi1hNjM2LTRlNjktOTcwMi02N2E2OGRlNThjY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwrlv3X6Pr1GxRutiJlypkidkXi+abVMG8nhqg7vNnjIxJ\nLySJQBQNA+3H4w4lMLWXX3So8F4J5KQxTNF4XlXpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFbb5bC9kxnis7xlZ+XoNo4S7\nSwAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMM2E+VrGUJdSbskLwJT6CZx1ET9Evu5KgI0qSRzvk6kAiBqAXio2bxm\nuqRXVAPgtnv/EcGjlAkS5cNk8zMCsplxAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISASUDcZgq9LKsQhHpwmY01SxZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWYwNWUxNzgtMDEzYS00MjIzLTkzNzUtODhiZTZmMmYzYzE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY2NDExOTUx\nLTExMDYtNGEzZi1iZTQ5LWY5NDAzMDc1Y2ZkYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOob8JKJcFfZbUOcD8eUNRWT6qVmvdH066pNic5yaT+ruG1+YXxoN+Xc\nVMfJMlwx4tWP53jP2MTsBT5ddpIy3x6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKQSMvYZ\n9kaaz6lB7+xEPWuXhczHMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA0V3G1ro8uW10IT/IOd3oubN4ymsJIhtCid8t\nb5Xl3JgCIQC/DEU5T/mcTBYrOLMOVNLRSupHffPRl/Apq28WafNk/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5781", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5781` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWmoGQWGxLVGDe/lpZA28K0DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1ZDM3ZmY5LTYzYTMtNGUxOS04NzFhLTc0MjVjZmQyOTY1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM2MWNmMDItNmE3\nMy00YmRmLWI3ZGMtZGM2NDQyMDNiZWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr6t87YWjWMtGyBNr8dRTPmFfsrvmVCLG0a8ilnSpHBz5vDzruZU+KYThnbUo\nLj4HLDFIJQBj4tbq+jwqb+vIc6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDriDrZpqDgcDnViNiF1QjYSzThMwHwYDVR0j\nBBgwFoAU44gMO6qZxdcHgPELbuEFXVWlejYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDAGaizfctmqZHegESZrKoonDq4ivmWD/zKv9a1Ow4O6gIgN2wTrUw0I3lv\nXXIq/Cd6tOfWp+vKN227SxQW8mv+x7I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfoIGKU8D+sI2csDpEX7g7VHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWQzN2ZmOS02M2EzLTRlMTktODcxYS03NDI1Y2ZkMjk2NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR44nGchel0UMsmkOGoR0EO+zvVH4WNYmposF1PttiHxguT\n1ZaRmUnuSqkBoHLa1Aa8IseyGRNTEYTI0wcoOeT9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU44gMO6qZxdcHgPELbuEFXVWl\nejYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJa8W2KRA1Do8u0H5hqY4TrPVPh2CjPbrawGvS5PgqwzAiBjbgmtXiL+\nqucsvLHpdIMnsEE7L75SO4EAKCKvFeyUpA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdig0bIMTPQiAAhQPdSVZ+srMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM2MWNmMDItNmE3My00YmRmLWI3ZGMtZGM2NDQyMDNiZWY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNhNDI4ZDdi\nLTE1ZjAtNDI3OC04YTg3LTgyMmFmNjdmZWFlNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBmx/OkdN1jaX/kO6iftEKz4rTXelPlm08K4qD3htCVPIhBWMwcZcLNQ\nnSqNkBsG+9fLUzcBKHIhVc7ipIJHlO6jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFA64g62a\nag4HA51YjYhdUI2Es04TMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBkOwKNJZJ7iJRkyJcVOCmNoRpEju/EBBqq4Iup\nCKD6JAIhAOzzBfyMTos71AJuxv/5mWYyXfQwGXdkdz2bW3nLYqWZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5782", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5782` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAShVCoI4VJmVikUlV96O37VcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxZTNkZDVlLTA5NjctNGYzZC05ODMyLTU4MTAyYjkzYzNmNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZlMDhlMDEtNWVk\nMS00NzUxLWFkMDgtN2ZlMTQ5ZDQ3ZWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaBBVL4vNvoyid4GkMkFo2IOaBy9FxVXpXX/YUwYqxsUg/VHp0IW5cQrlzAA9\nvC4Pe6WljEp0aO5xAlfEWEyfgaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXMmQ/yt03i2iD2ht3UGnwqkh7XswHwYDVR0j\nBBgwFoAUSCjdUk6kfSPXDYJqx5DJ7ONBJu4wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHE4\nOmBEnU5OtQJezKTkXoikdCslBopmqRxOvEJ5HcPuAiAnK/4/mgq8R1s3gik20OLQ\nazrB7ixwksXKCoHhqCny2g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfiGNWCOb2sexejvFCoImVjxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWUzZGQ1ZS0wOTY3LTRmM2QtOTgzMi01ODEwMmI5M2MzZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYwV4gvmP2s4QuPJwKJom23alL2wia0ygj6rB+qoH0AbnB\neDDghFF8WA/uiIeHVHmpP5djePrt2SDv0t1Y45zso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSCjdUk6kfSPXDYJqx5DJ7ONB\nJu4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgepLOz2taUtYbJbVm2FG0GbF2xWSK5CNTadf363jojQECIE1MDH8RZRp3\nJiD4AsIuPUS14u1RKOG8oBqSN9G/HlC6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISARQAEatVkAgSfo4gSCb0xHpTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZlMDhlMDEtNWVkMS00NzUxLWFkMDgtN2ZlMTQ5ZDQ3ZWZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk3ZjJjYzQ4\nLTcyZTAtNDdjNi1hMDAxLTllMjdhM2JjYTJmNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEkrR6deU4qSm/1EXGZK0Lwl/HQYxDdYlXDOL7LTTbTwWnbT9YlEtat+\nkm+QIywq1ufsIagwnNPVErZpFBSF7gqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFzJkP8r\ndN4tog9obd1Bp8KpIe17MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBg7LbFAJ2eGsSP72wk69RxsaZof6mstcN0Kwa5\n69X6AgIgKJFiuWIdhJaS0+fQuxFtM2IoYNIjoUmQq9LePISZn6A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5783", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5783` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAeHx37J+CLcjRjVc6QNjqJLaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1MDExNDEyLTMzMjMtNDcwZi1hODNhLTVmODQ5MTMzZWViMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjgxYjBiYzgtMWU0\nZS00OGE5LTg3NTAtZjMyY2E3Yzc5ZTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK5Ntu/RucyHYWwmuMeoSMbqUgLzZCKVu4Rkk06FXW+LqiaD4nke1suZrmPiu\nFfopic/z2E3a/eOkZVpnmEPIz6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX8MIZtTlus6S3uc6e7TIYaP4EMMwHwYDVR0j\nBBgwFoAUoY+B2feiKRjORqwfkUooEGtCSdMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIBk0BO0bfGSC+b/ptItq1rJAmbGNAh6KLQgV+yh1LRkzAiA2tIuf\nCpP6jTu2CFj55Qe67re2rJaJhoKWxqSpzZvUGQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUE4wE+Ehnh7a1OY7NvrY/zOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTAxMTQxMi0zMzIzLTQ3MGYtYTgzYS01Zjg0OTEzM2VlYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATc5CzMvVowhoDjYogxUldzE3J36joQJWKrQKlkzspiwEni\nRt9aC+HNEjMHvz2sSSUva22j5HMQ0YZ9fcXFO285o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoY+B2feiKRjORqwfkUooEGtC\nSdMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHeN4Hk2dOJiawY4mPiud43tmOWGI4lVZECd2t9Dbc2sCIQC8wUATiYeq\n3gWnvz12tOa/vDh4EjNGpQ87bqEKTG86QA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQa3Ew2VT9oUOws1JLcvisjsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjgxYjBiYzgtMWU0ZS00OGE5LTg3NTAtZjMyY2E3Yzc5ZTA2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDc4YjgyMmY4\nLWUyNGItNDM4Ny05MWU4LTFlYWYyMjU4YTcwMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH+UTEX+xE8YGW7tFFOSHTyt+cC/oHnWFJaJcybgiAKo46xydCsVHjqv\n8r6dHO3UQa6EPKqnzN3eCnXNmDNh36ujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF/DCGbU\n5brOkt7nOnu0yGGj+BDDMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA9gAZQFdsP9idxv0J2458lQA5Er7x31eq/StN\nL6cNQW8CIFyk0dRacy51CmhBb/Rtab4OhJnG1iEmoA6+bygbwpO4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5784", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5784` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAYzGejO7BnjJAOwpl3W9Jn0XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzNTI3M2RmLTM4YmItNGZiNC04Mzg3LWU0ZjljMmEwYWU1ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZmNTY3MmEtNWJh\nMS00MDAzLWE3ZjQtNGQ0MDk4NjEwY2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkPnwyZ39HOuB7ChPx34zyWhVW3Bbz/sA3CmvpQGCRzfvee1WiwGaGesHB7Z4\n3fe7lUzoQT2q3a6nZqF3+lE7d6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUon8HGQIrklGwotbbaY1u+AGCjS0wHwYDVR0j\nBBgwFoAUJ42SpStRaViLpn4eyme17xcz1tQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC1qLdLe/viG/sa6l0rNmMGUKg3MKzm2zI/kC082rB9HAIhAIhp\nX3BZ5M6LU0xluiGKSgFAUGi8HbOKv8H/Y3RmKzAS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbcC4mTam8acn3CdJ0zsAYZkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzUyNzNkZi0zOGJiLTRmYjQtODM4Ny1lNGY5YzJhMGFlNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7ATEOx4A3pVckAurJL2YC2DQ226Fm1zS6/HsoGJx+i/pz\nJy/1r8x8my3X5tTIYtWSgT/eMfX4+LcNLiyc+alDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ42SpStRaViLpn4eyme17xcz\n1tQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJFfZV01Om4FbQlSdgw9c+qnb9ZEr0fgrEgDnI1qroWKAiEA+NSevbHS\nYg78mCBi238dXJ123fmGphWEy2HOQ/Mr37A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAUvF7M0aYAMIUaVzoMHhB/hIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZmNTY3MmEtNWJhMS00MDAzLWE3ZjQtNGQ0MDk4NjEwY2Q4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDVkOGRmNTg2\nLTZmNWEtNDIyNC04ODZmLTE1NjBiNGY1ZDYxOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPWmATIS8g3hIC6vzbccs3AY8Oaugvu/xhqCSxTKo9WcGaGolYAljznD\nCaOrZTZZuC6DsCkqR2Uu34/ZFjmT4FKjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKJ/BxkC\nK5JRsKLW22mNbvgBgo0tMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAi9eR3ZHkqszkmVlapBolGIdkUh0D8MwqjDVK\nDflFfk0CIQC/plipOKdzXeZnya6K8Pp5wgzfZkZCZXxXwIfosXAhTg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5785", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5785` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbqPv1g5Mw+eFA9fRJ17ibgvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyYzQxYjc4LTQ0YjUtNDAyOS1hMDFmLWUxNWE4ZjFmNjVhYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRkZGJjODQtOTYx\nYy00YTVkLWI5ODctMzNmMGM5NzllMzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcD8SSNiGGiwKJWIO1Y/+nHsvbEEui5pIo15CjKQRlWfX11Ilm20nHmHPP4CD\ngZCQJo9gGB5hN9EfNszXm6acH6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQhhUqIzRWt8ctzaw9zLWd5ILSSUjAfBgNVHSME\nGDAWgBRm+9LXabw4FwnCOOYReKtT+Ch7PTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC27Md4OwCpql3wM5zfEG73vcy3A7Ox\nUJPmTiD+WC+MCAIhAL3SgaJp/6Se5xejMnR5OG9hfAkmBNnXyED68SpIPFgb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAULyhKivikRfPSPHxLrWsxX2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmM0MWI3OC00NGI1LTQwMjktYTAxZi1lMTVhOGYxZjY1YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCnGvkIl8fhETs7iaHK62tZXPhzPjIGaO0y6feb1LWJDRD\nx7wxQjdl8rhansISDwFdyp+wxNfDxIVbxs464ocEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZvvS12m8OBcJwjjmEXirU/go\nez0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANkZX3Sa5IpuG52efftx14qJ3h/sFJCO4xf+vjcpjs7TAiEAwWQ6lBVS\n9uridJx3jaPFYBJrabcKOCBVDZnUhttcy5Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdk5TsnVk9Q1Zu1CGuhWWxoPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRkZGJjODQtOTYxYy00YTVkLWI5ODctMzNmMGM5NzllMzZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBmM2QxMTA1\nLTAwODktNDY4Mi05NDMwLTk4Zjk3MGNkOTc0OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCRIfk3FEOt/Lcnj0ryHvJqkkJ771ZXwaZDDFCsvylesTWg1RCrgzu7e\nuJYOow3NE1RbwJnMivizesGvkrEmbFijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCGFSojN\nFa3xy3NrD3MtZ3kgtJJSMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBaTk/0IdCb+a3b73Gkg5BCL3aMf47NGAHnhjVl\nX+6WeAIhALJSQQnm5VRmbbNd+dRLm08UMEwQOZUORNBU2lfmyN/M\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5786", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5786` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAbjjYHdoI/B6eHCSbBxzzB5FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViNjc5M2M3LTQyYjItNDhlNS04OWNjLWJkMDE4MTg0MzU3MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFkMjAwODMtZTZi\nMS00YTlkLTk3ZGEtYmQ5ZTkwZGMxOTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm9lJeC7/rRDgvJmcTpGo6zugjl11sg6t7nUI+7ev2JjH/yYf6o/M6HrrlgE6\niJ1uDRXB/JWC5HAK3+yNg+0w5qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlQ1y3LGmxTctx5X189EF94Rn8mcwHwYDVR0j\nBBgwFoAUz43HK8ZYA7F+AzEe0NoputOURU8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIAznBLTw7Ow8\nhV8139qHh93T0oZh/Z6/3t6Mk0FIidGSAiB+5fUFiuInxFbvZ8ewTXx0sGAtQ4jJ\n6ZouTwyBkmmgSA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfQIQChObznqHMAQ20B6fyvDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjY3OTNjNy00MmIyLTQ4ZTUtODljYy1iZDAxODE4NDM1NzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/0clOpH8tvtAp6cnsArAyoE/URV+qV8NpPlMpcqK/uxuA\n2W3sP8cJt3ENPvgs5/SZ8trsJ0DQnO71pONv2l6To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz43HK8ZYA7F+AzEe0NoputOU\nRU8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALgUEVfkOIHPCKYMi7BiGw64BYiFFgPMxn6UhLdelBahAiEA2YEBkwln\n35B66wd0e2hqU4qpxIR4hjjohmrp0u7HBl8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdj86shE+Nw0JZkzIDUa8AqPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFkMjAwODMtZTZiMS00YTlkLTk3ZGEtYmQ5ZTkwZGMxOTZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQwMTk0NjMz\nLTI3ODItNDVmZi04MzM1LTRmZGU2NDMwYWFjMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJmbFT4YZAEViVMncQbRsjLViV3D2Rz7TTSgwrGApt1UXIJhE1XVSVS+\nhX1QR6ZtiTVijaIipUAY0qs9Vafr9oCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJUNctyx\npsU3LceV9fPRBfeEZ/JnMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA2ayiVwR3paV43VafVK1Rl9HuJtSypDw8CaTB\nfG7ScswCIG9yCF06WyMMmOl0G+SUnUisyDN6AFCYWppAvA916+xo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5787", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5787` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAcJPV+VjwO0w0YHWL6WDTUKBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5Zjc2NzMyLTYwYWMtNDg4Mi04ODU3LTIwODgyNWVhYjIzYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg4YjczM2YtMjgx\nMC00NDQzLWI1NTQtNTYxYTdmM2E3NzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe9qZSf78oCAId3h52iXBSwWu8rwU6qchF3/KFgZLPH2oKcf9do/fXrZlyo/e\nLhlMbamKmeZSnSEE7eef6Vw6qaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoGFhQeqFTwPUHCvMcprrnYFk0d0wHwYDVR0j\nBBgwFoAUDrobvyXOYPbTKKJL1eZSx7lzLTQwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIBk8yW35SRKJ\n2Yoxe1w4IhCcZEp9qoUgIWp6r1t1LMJvAiB1II96Wr+O6jNuL5eNCJbSIGIYuKmS\nY27qAko4wRYF9A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUolSBK7N7DsRezYr/yZ7cOvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOWY3NjczMi02MGFjLTQ4ODItODg1Ny0yMDg4MjVlYWIyM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyRcNT7BMUGhFI2G3evUOSOz97XZfm+n7rQgNb0ODkfZRz\nVmOTDlFHDMnYE0i7pbD20gD9VEMLVJBYErpR0Mdto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDrobvyXOYPbTKKJL1eZSx7lz\nLTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALLmWC1DCuComx7NCRRoWMleFzjmgBa/x9FBSJXlRLf/AiEA2Mrv9PMM\nzp+37XSYBJq2PDxxFvpRzZuCIGdUUJKGM+s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATapwneVAtKabe+6fjcnZrzzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg4YjczM2YtMjgxMC00NDQzLWI1NTQtNTYxYTdmM2E3NzQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNkMjA0NmVj\nLTc0OWQtNDVjOC1hOGE5LWIxNzA4OTgwYmMzOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC7wAQ+ZeozgbnCTaBf81IwatEoAFj3QNyezsMSaNjGiYZpKC4zXed+e\nKdum30ASG7Vj1OqEvzDlrafDal2eHUSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKBhYUHq\nhU8D1BwrzHKa652BZNHdMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBzUcMJWOihZKpG9Ij/xhpXWfqYeAitGDumBYfo\nFo2UJwIhAPI3G7R2BHzyQOIpo1ABFI6jR8JpsmbNNy/Q21UaCf1N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5788", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5788` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAWyxt8pxvPd5n+ou17arBiQJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5Yjg3ZDMyLWM4ZGQtNDAyNy1iYmJmLTJkMmQ2MDczYWI4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVlNmQ5MzUtZTY5\nZi00Y2UxLThjYjAtYmI4ZjI0YWVlMTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5dpIRdfYwUSZEvbUmGuGzEB0vcFBsZCKI5Gal5hmULLCAe50B1e4LXoaKyp0\nPV3cRwOjAvrnAXJoAM/gZJcJzKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz3U+fbUGNgdVsL3CVoceaoY3Dx0wHwYDVR0j\nBBgwFoAU2ZWgGKScU5d6DH3lD/bqyOh7glQwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA1IWKFDTl\niPZUK8p+e89M5ZLUszMQ4PWgyw242818NLMCIB+HyYjHPOAxVle0MvmjS8nGmE0t\nk8HqBhdOjRThL8p0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARvqDNS5CK6TTeRftIwfxG7FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWI4N2QzMi1jOGRkLTQwMjctYmJiZi0yZDJkNjA3M2FiOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwgJqNSD9igCuZ+d2mY4KeY31BO4WOLCALKd6GCcmEzi5G\noGUl8ZCzS+WOckmNqfH8b5q90jo2MEtf5KZP8gtIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2ZWgGKScU5d6DH3lD/bqyOh7\nglQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYLuDJjbTreCjqaiFQG+Ifu5nkGrEEIJ5nUFbhdYVskACIAMFzO5mKU8v\nMWSYUGjvgCRYjVbciqvvQu+t8br7RXEB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQLmExajYUu0ER6d67k7gkJfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVlNmQ5MzUtZTY5Zi00Y2UxLThjYjAtYmI4ZjI0YWVlMTJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDg2ZDdiMjZh\nLTg4YTUtNGI1MS04MTk3LTY4ZDQ3YmJjNGRmODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMI9KFQ3xjjINiQxHBpYZrKYEbWevjqdsn2Ly+Zq6/eDJ/aih/L4qAn/\naLKwvN0Xadk3vVezCoW/+6kXYyRm9vijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM91Pn21\nBjYHVbC9wlaHHmqGNw8dMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAx7AB6Jmqm4QY5z+xQRl7f9sp9qFvHnVnCksc\nNzBSCLICIAnrfu33VaDGkrbTVNA9UlZXVS/ScL3Ek2o2uqbsHFHt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5789", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5789` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAT/sBMy5N/1i9Er6O/h2wjxyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1NmEzZjdlLWJjYzEtNDRlYy05NmE1LTk2ZjhjMzM0MjQ5YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJkNmJjMzktMmNh\nZS00MDliLTgwYjItMTYxOGI0ZjY4ODgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJi7SK7MVRaKFaxrQeSCnj6isc2d+NSxpw0HE+GpHn2kX8nLR38r30bAYz416\nNy+MebvkDFD2qpjsRrTcAuGjIaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2AiR0KeT676QOHxHsnTog9fkcAowHwYDVR0j\nBBgwFoAUjDdJK7ZD+oO0AKeOYFkI/B/8M+EwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiB4MfAZ/VdoX46UY5acvu8TEJ75GPuwPJsx6aVVD5pP2wIhAPQi+ddcfuNj\nnhHm2d/KyV5znUNBDxA7GjfUmRyFRsID\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARur3YUt5WN774IrAu3twICGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTZhM2Y3ZS1iY2MxLTQ0ZWMtOTZhNS05NmY4YzMzNDI0OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfqWmmoXpHjUAEgzvPEFkA9KGeyOqFdMW3FSpuSFviYHXY\nd11pn1hvoinQAacL+48Pcd/vkbdPaAfaiUoBDAbdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjDdJK7ZD+oO0AKeOYFkI/B/8\nM+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdqlKiJv5DHc+kNkvk4z7t3JO+HBPjinG/aCXAOGqrHQCIG0z7G1HwotO\nWPtDlhQIXH1ghpFjyO6oJqlvnAOfWatn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaVrX9/00hO5kXUhi+PLy3JAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJkNmJjMzktMmNhZS00MDliLTgwYjItMTYxOGI0ZjY4ODgyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhmNzZhYmUy\nLTI2YzEtNDU1Mi1iZGFmLWU5NjhhOTA2YmJmZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKyMRauTmbEw16H8BgPJl88TxjyBg0rLAUJkkSKF+B2TYL3yveyPQNnO\nXbw3tKQt7iRlrRTtX8XZwykEZhUehySjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNgIkdCn\nk+u+kDh8R7J06IPX5HAKMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBKFNyVVEfJwyDYHvEudxKB4tliqX++nlu4LLh/\nOI00iAIhAMHmkptuzffXoKvigA//jGlqgdF3F5IbWB4qvpKzyl5X\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5790", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5790` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVTNVol+BomvWpYDXf4CbYwsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1M2EyMGY0LThkODktNGQxNC1iNmEzLWI0Mjg1ZmQ3MDU0YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNjODU0MmEtYTE3\nZC00M2MyLWFkZWMtNzgyMzg4MjFlOTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBoxX3MPeDIc03orh++zJvDZX3LirY/hYsAoh05gJya8X5IyMZ4OPnImQ/H7b\nzZznat5UWly1hi65UgKVbNuUhaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQkjwhTupEOGnALRQ1Khyammc2y0wHwYDVR0j\nBBgwFoAUFycQz7y+HK441CY+6OGZm2awcoowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAUwROBsjpninvCGzbbaDZfeU/iu9mZK0NT0RQAHDqEAQIhAKGhlX/pmN79\nrSu2Ce+oP3g7xtVuESL2w3glkyrpmjpL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZv9k9UK9jy+Uo3HJBhBrCwFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTNhMjBmNC04ZDg5LTRkMTQtYjZhMy1iNDI4NWZkNzA1NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUwP6vu0jHrhrPxDeKVTULuyBSVoej1rBW9dXpep7jehLP\n4t+V08B5gAMjBaMxLzUHTxJ9c4s3JemPPllPNQLBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFycQz7y+HK441CY+6OGZm2aw\ncoowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMMJc0etUkCuq3NdaH6/BW6C8x70LFHCfjrChmSM8m9mAiEA5O6K/5wt\n7fgLeSijlZa+76UGv5ALoWsEPfrVMOU5h9M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASlGHtb03AwtCeTesyLjY2l4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNjODU0MmEtYTE3ZC00M2MyLWFkZWMtNzgyMzg4MjFlOTI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY2ZmRjYjk2\nLTY0MDAtNGFiYS1hMmEyLTk2NzE5NWZiODQ4ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHDI0xjtfU8skQUTuIOqFKt0favezc4L444I+ztX1zI0aY7UStwmlRdV\nTkxrzJ0u6ShVs/XpL7FrNsesUuVwfQijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEJI8IU7\nqRDhpwC0UNSocmppnNstMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA5jH1YZ7fV2yzdeSzM1V8umYIBYvsHazaUnMI\nhqxzvikCIDVbAPk90r/GtCgM6QwiBE13n0m/HPdcjnEKLZXtOSKR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5791", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5791` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAYUl4kC/J0prs6W78ntgRLcrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzMmJkZTllLTc1N2UtNDM2OS04NjI1LWVmZDVmZDIyNWZkMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM5NGQ4NTAtZGU0\nOS00OWUwLTlhYTQtNmIyZWNiYjI3MWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2AWXTewCLcpEz3zNYNdnlvsldxscDhvxFLDE46krV9h8K7BfRQbqRSXPJk1Y\n6jRQXeLlc82aPzV3O4oMD7vyT6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Gblt2w1T9g0l8BUOPmpWKunbGYwHwYDVR0j\nBBgwFoAUBd0Adut+J1xo5oRGoFKYiCHck70wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAe\niHMB1knjfgT9I6mYs3XvXP2fKyNqDjVqI12paBiRFQIgTVOobytXhabmD+3f0wsn\nEnP8lKzBh+PUV77q/qckVtc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcuwxD+HBumI2Z8HDVBdTpAjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzJiZGU5ZS03NTdlLTQzNjktODYyNS1lZmQ1ZmQyMjVmZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbSwZdY83f5/sIE8rgJw16dLrb1k3/qwqfzflpKdlj7Fia\nTpru+7LObWd2eRYsJx8VdLTHlUOspyBg9Ob12Qqgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBd0Adut+J1xo5oRGoFKYiCHc\nk70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHQraRfFGM/xql0NmpS2kHOfi+UoXWQv007oeuAf2nBgCIQCvlxzQ7TQ6\nyqCemCfe7hidU6d1dDJwq+g/JC0YZcRqFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASmUM40npL7VTAnRBfwdmJQ5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM5NGQ4NTAtZGU0OS00OWUwLTlhYTQtNmIyZWNiYjI3MWNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQ0MmNlMjA4\nLWI0ZmEtNGU3ZC05MDVmLWYxMjVhYjhlNDEyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKg4c/LQ3GMzPiBIzSsR5vQRaSicwct3jPKZkhVyWjBlj4zC3X58S3DM\nC4dfE4HXDQEIEbDp9lVXzDKtZ/tx7WijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNRm5bds\nNU/YNJfAVDj5qVirp2xmMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAq/fVzv8ZPP1Csvx/3HUSoFc2c4MQSQaxGbXvB\nXnjDVQIhAL2/4II5FMhaDtddKZA/2x+9VvtUYi7/4mq7hmHsZIZ7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5792", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5792` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISATJ/xnvw5eHfJa9GGhk7YKM3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2ODhjODM2LTFjMmMtNDQyYS1hMzZjLWE0NWQxNDE2ODBlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJmYWEyNTctMGU0\nOC00ZDRkLWEzZWQtZjM0N2IyZGQzYzZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3zkIQBUDvebLE+jTanX7ZlsZe9duLvx+Et1y8YpMOP8kaCVaENjDLx60i/g7\ncJunTXibDurq7nbO/JD3w0m/G6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5sjiQI1weprLQbFXVBDpP5cPqywwHwYDVR0j\nBBgwFoAU8dnHPJZbOk5Fw/5MtYy/0GLC5EkwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAyI0ThH6OSrG6C3viC/On7fcFBQYCqZPWWnXcioP4+swCIQDz\ntPavhch+J8ro17w38U21HbZWKX+gxowubTQ7R6VwIg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdMGJz/Nru3cJQSzE3Zn3YYZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjg4YzgzNi0xYzJjLTQ0MmEtYTM2Yy1hNDVkMTQxNjgwZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxfa1uIU/OZ8xdeIGuEiElIjtZWKu89MVXljSqF3C3QedU\nPxtlWPOUv1xTOAv2o6EVq/nfSc+3eeTsIXbSrEq2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8dnHPJZbOk5Fw/5MtYy/0GLC\n5EkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB5YBsENyYwphGed4fvLF2swZw155ZRngQu1JeVfT02kCIQDprwu++tW9\nJc7ndfMI4I04IgiQhmWLEEYjsZHvPWSHbA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfwUNcy4ZcqgelTW/22uWe51MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJmYWEyNTctMGU0OC00ZDRkLWEzZWQtZjM0N2IyZGQzYzZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGQzMTllMmE1\nLTkwNjEtNDJiNS1hNmQ5LTUyYjQxYmI1YTk4OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNe5+51ofXQ3ofUdOBT5YVvaoxU8of/X2QkuBhF8DhjM03kdK5Na6b0T\nB9OR3Za8XqAzfRK4iXIri9epJ2JZDVSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFObI4kCN\ncHqay0GxV1QQ6T+XD6ssMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBqJWuM2qb3YayhG/UgcF5GcCnbkzvXQ03LmfL0\nfcNtZAIhAPK9QReFf4dLYOmUkq2vo1vsZ1kIQBZMwQ/mOIorqhqW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5793", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5793` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAaoRAqch6M65pMkBOFDwZCOhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViOTFiNmFlLWVjMTItNGY0Yy05ZmVjLWY5YzViZDY4NWFjMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y5NDVjZjktYjM3\nZC00YzJkLWEyN2QtYmU2NDI5YzI3NWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV+ica21KLTR1L2UOwi7/W5mF/V7fxD71peYhNbDoi+ZqAsJjNX+u0FLn8+S1\nsgRWCZmiOypRe2M6i5ApNVcLKKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6yW4PiLrrYMhuHmbz5gXbXDqKCkwHwYDVR0j\nBBgwFoAUlM6VTvq0H3e+FSaQ6/dzzQ6y2mIwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAlBLV1n7R1LLZEpK4afF68t6wcrGcbNU9Or32iuo2fBkCIQC9\nFA1BVayiig2qq9S7M4I95XN/9DH61LnSqRA3c2SEIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWpWDGLulrfGbQywguqzGp9bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjkxYjZhZS1lYzEyLTRmNGMtOWZlYy1mOWM1YmQ2ODVhYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUx6BrvwcR2opfTX4L6TJUYgvCMt8Tj2vPBp4TdFpkEiXY\nAYlPjM/HRBDujokGbvNqNCDNy9qUmzHrCWPc+a7uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlM6VTvq0H3e+FSaQ6/dzzQ6y\n2mIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQgc8T5A8soCeEDdm4f3zxqMtHQK06/vjdQo4tFaEBoUCIGPKI8sgUxQJ\nQaJ5xtKFyZ507wGiE4jlOPTqgWYSnXCE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAShvke5dzoudCJzgVPcIDcvTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y5NDVjZjktYjM3ZC00YzJkLWEyN2QtYmU2NDI5YzI3NWVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFjMGVlOTUw\nLTY3MmItNDQ4Yi04ZGFiLWUyNDY5NzdlMTg0YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABP5ouVxYsn1v/twJpixNi5e65k2Hc8rmitCtJ2xwq9W2PwMiywJ9uEwA\nmu5pPPa564pkEFE18ONgZ7rndc6ewMmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOsluD4i\n662DIbh5m8+YF21w6igpMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAeZvgqPyc9s79gNcfEbZ6rO2YKHrXLAL3CJDXZ\nP2ndngIhAM/gegyzwp9vP/HrXZmKtAUXxe6dnk8q/uC0PR7H/JOn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5794", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5794` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfy+OxfQnt6PQztr79Mjw+ZQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlZTM3YjgyLWVhZWQtNDliZS1iNmRhLTc1N2IzMGYyZjIxNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM4ZmRhYTMtNWJl\nMy00NGNiLWJhZjAtZDYyMDFjNWQ0NGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVbTEHUmyTiygm557tqOL9HPF6hKLUP11/FJIYd4dLoscIjrxgAAbqnpOxvef\na/sAy9gh7Ui8NnM07+tFGimotqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmM3QAaBQN2du5USrDTiOasv9EpUwHwYDVR0j\nBBgwFoAUkUP3wumsrNGi8hbatNjQ0iO4WpUwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAn6CSKqzSwrCC\n2xdzFTHJUEzy2itsZoRs0H4dIsdUNMICIAe3JcQxG1xlLL4/WJEPIIfY6QgRkEu/\nX7EclBylrDVx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfBYF2q8qr7cWYJ5t7aHadNJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWUzN2I4Mi1lYWVkLTQ5YmUtYjZkYS03NTdiMzBmMmYyMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgK+wtTPYv2CLXIgDQOa1zJTYTcH9Q+RT4isboTBUck+z1\nPoptvc2hLU77ips/lo1DITkdjAlD15F1IefA4T5ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkUP3wumsrNGi8hbatNjQ0iO4\nWpUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANDPcQG6yzY6LX16jxxrTqMgYfoYJZF6wTidhS4fQxTZAiEAue/23rs6\nwj+ynBnEbPtSj18ulFQiAGlBSNHB6/bFeg0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAVai7s/ZRv/8OGlFGHjD+3NBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM4ZmRhYTMtNWJlMy00NGNiLWJhZjAtZDYyMDFjNWQ0NGI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGE2NjI1Zjll\nLWY5ODktNGY1Yy04MDNjLWE5MmJjYWYzNzUwNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG694V7aWwEqy+zGECwFtxWat8e/dUzj9Vb1MChmN68wvxD/gpQRSFoY\nDxNwqRNecIESq5rlz1n1B7wBTRRN8dWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJjN0AGg\nUDdnbuVEqw04jmrL/RKVMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBi4m24hU/dVdtFTyADIjTGKMpO3VlkEpvwwwLn\ndbCAggIgMMUwkw1gSTCJI+2fexLTkkNn/1xnE99iW1ANemtsmEM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5795", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5795` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbvTAVBao+QmYE+5RQlrXesXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzZGZjYTllLTAxODUtNDY5OC04YjIyLTYwNTIwZDE4NGU2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMzNjRmZWMtYWNi\nZi00NzUwLWE5ZjUtMTZjOGY0NzI5Y2UyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+1Iyifj3v2l/PeaNZNa+W6cKrL03dBvcX2BBTo1qMAgk/kGTkUGcSxcfMmV0\nPQyYAqQsNB3FALbmwzawo4x8SaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc74zPqwn3x3jLmmE/lKxouag3+QwHwYDVR0j\nBBgwFoAUfH21F4tcMDdTeZvGBM69z0tkQxowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICTM2xBphtdHAstZdkAjSFf7uUlM0OiI/0yjVH+B1+BHAiEA2JS8Zt9wj+Is\n3LZiB1eCETcjOHtcPGt1d0TFLR+oHn8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQYzt2+SqKqIMU5lpcSwS1aPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2RmY2E5ZS0wMTg1LTQ2OTgtOGIyMi02MDUyMGQxODRlNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToQEJharMlzVEDFKlzZ9qYCprjo654CPKxiOtWDs012jr7\nQdOoRvHVJyYNuqL0ec8hna8a9bVJWaR7ApAXCbsjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfH21F4tcMDdTeZvGBM69z0tk\nQxowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOYmILUB7MevIG2+RvArms/Q2dKYPwp9KgzDf0jV9HFDAiEAr1YYGpSc\n1DtPDYBCAs+mRr56zf1S4Wzt/7q0hbOlwak=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISASWfrJLfcRagi1p12lpjfKhiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMzNjRmZWMtYWNiZi00NzUwLWE5ZjUtMTZjOGY0NzI5Y2UyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGNmNDc2NDc1\nLTVmZTQtNGI4My04ZmI2LWNhNTg4NmYxOWZjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABE+ypl/D7jvhW5r45AwbmTbzoete/M/T2dy7WXvQoWTmCuJ+6kQbaavY\nC+JeOvEYmtr4jDS7BpjebYgztmUyCHajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHO+Mz6s\nJ98d4y5phP5SsaLmoN/kMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA1rSu+BLMm6gpzu5l04H9qU713cdkxMG+5E/5\nWpNzIjUCIQCNYr2/wMReDRbkXI+CPKJ7FKPVs5ffeq2W8JpEfFGkIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5796", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5796` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeXhHVdKb8O7d4ClTKqDk/ovMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzMGRmMWE4LWQ5NGYtNGJiYS04OWNjLWU5ZmE2YTM0MzViNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE5ZjljNzEtNTcz\nMy00NWQ3LWFmZWItOTUxNzgyNGVkZDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKWrJzK8kIHaRMWX8Ya8tv/pL7j+tVUxIij+FYc5ruNO45e9nW6WF1o9Z5jjF\nOd+VP1pJi3HLF6jANCwvToR5z6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzh7vnebJRbEG8cdTp+xVFRHY2sQwHwYDVR0j\nBBgwFoAUq110Q3VjWMlPEmY/vy1+GHn54d0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFvIGiFpcG7Ecvubrm+Xx1cGEJiiAdRB6hbX0RHpCRxjAiEA+MoA62pBZsUT\nOAkIIyG91YSCB4X8BfxIBpaAjGVnCOM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXgrFx2ePoj+x7W0CRgP8a5mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzBkZjFhOC1kOTRmLTRiYmEtODljYy1lOWZhNmEzNDM1YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZin5Wv9XbdqdEmr9YRqqMwosLBVS6JL6yVjG8Muh3kSaA\nRcRe7UTQ4xQcXXs3hCoh+4ipEz3OtZEGNJMMsDyJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq110Q3VjWMlPEmY/vy1+GHn5\n4d0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCHSHVcQbG4mFgdkdETeCM1tMlQhPLCE5P+n2rCO3hu8CIQCNrByFt1sf\nhCkkKxaR3W1374KeAdzClfM5McJwaGDEAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZvqNp39Yw0CWsqjwOxJ0cBEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE5ZjljNzEtNTczMy00NWQ3LWFmZWItOTUxNzgyNGVkZDNjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDljYjNlNTRm\nLWFhNzUtNDMwMC05NjFlLWMzMWM5Njc0YjczMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMMEBMPr4wOp0WqnxKjqDs92LUUMf6iEE/tKqqb73Njf02TGxIIGc3zv\n2lFHPpYKyZ0412QGQ48mtiMmld7yfGejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFM4e753m\nyUWxBvHHU6fsVRUR2NrEMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiB5rmAmP2MjVnWBZlsXgIIIWXjYigrSslx2VB2K\nyQNlCQIhAP3q953pWQkuux0mEBGcdbwlErNw1+KaTk0cXFjHOxcJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5797", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5797` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAQf9li8vI6R2+Msl3W1R/L6vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyNDJiZGRhLThiZGItNDg3YS1iYjZhLTU3YjE4MmRkMGZmNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRlZDNkZGUtYmNl\nNy00ODM3LWJjNjQtMTZjMDc4N2VmZGQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE81g1R8Aa3rEXh2TB9v33aaEkl4ezo2L2awFcOxwcbjHD3WB+0pjaGjXx9iyo\nQ9088WvzstZ2OsUVGxcPPivQAaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOT6mP5OVaPtY7ofDiaMUP2f+H9YwHwYDVR0j\nBBgwFoAUzvH55iLErh4+fcEKnDHyiscvmbMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBnaQ0phdz9T7mlAdGdVLRiGUCLJWVDZniiCOSGIx8RbgIgerggP0od4P4T\nzi01QTKp9cJQF2Cf/rPHyBsSH8BuApY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcBD+GzITrhZA2kEKMoRi5v+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjQyYmRkYS04YmRiLTQ4N2EtYmI2YS01N2IxODJkZDBmZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARw3ed6GgVkG/K9yMZ7do26aFajnMSRvcs8WNhCsFMIJ4d7\nZyuuf+rV09JcpfDS5xotV/63HaDs2Dk5sXCvAMF7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzvH55iLErh4+fcEKnDHyiscv\nmbMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMRVxH9bB3eYmgra7WJuHF3zD2+aCkr2LGKsiC9AmJH4CIQDIBqb28Zve\nrYSrQTUHmTQ1ncJkZ1CYN+K4qHMa7bjeZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdn3Tdsibl/iTSm40gb+5c9qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRlZDNkZGUtYmNlNy00ODM3LWJjNjQtMTZjMDc4N2VmZGQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDBhYzI3NTIw\nLTIxMGMtNDMyZC1iMDQwLWVhNDVlOTI4NDJiMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC+G0ZAOXqE7pLxogD7XIq8P9OOIrynECDZSVJKRN2gHML0KoNor6oh6\nfpsyQbsHUhn8SpdXvnuZVeBTqbszp/ijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDk+pj+T\nlWj7WO6Hw4mjFD9n/h/WMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBlSPwMXcQf8ZkTkY3nYy4/ajiEbHOpcGUtDHb8\n+aZxmgIgBcukUnWUA2vmxazwyF619uOAjk5eRSV3boCDZRI55jg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5798", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5798` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAffvsHhthGwjLMVm/f6W2wIVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3MDg2ZThkLTFhMDAtNDg1Mi1iODc2LTFlYjE5ZGRiYzk2MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ4ZjYzZjktNzUz\nOC00MTNjLTg5MjgtMjAwMDg5Y2QzZjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESLuF3fZKv0D7MVylMZWhDCx8UegmdNt3u6x/u4oBkYPXOLt6xiqxvUsgsoQw\naBC/PoQVTNUGm+KSFY6ymfhXC6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI8aXBOsq22VQPlxEu6CCmwPDB/wwHwYDVR0j\nBBgwFoAUylZtkDhNl8BqHpW/i7R1CcbUx+kwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAleNOS+JJbTBR+SyNvKdn55LFb4RU/SYiPcRH4Ox2\niS0CIQCB/cScuCUzAH4X02yLBu0rrPVnwBBLztm+6fAIH18yHA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVLMhdVX81zM/JdsHmL+ZvW9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzA4NmU4ZC0xYTAwLTQ4NTItYjg3Ni0xZWIxOWRkYmM5NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJTGWL2TLMCM7LshkBLfx0XqpB25WrrlTZ5ei6XhRiIbDM\n3i+/Ymwetzj90q3UOsX65Y3EG1HQddRPsvDOcJDxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylZtkDhNl8BqHpW/i7R1CcbU\nx+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKUuV/NhZR+OJw99m7WSKwvjqTKyvtG0R+HljhHFa9ofAiEA/4Q+GLzR\nDElF9xugjfFPfflnbjcWaSR2fdrq5ZIUzAo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZxMGUgMjUg9l0WPSF3i8sGMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ4ZjYzZjktNzUzOC00MTNjLTg5MjgtMjAwMDg5Y2QzZjlmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDgwMzFmYzEw\nLTAxNmItNDFlZi1iYjEzLWY0OTZkNWRmYzFlYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIXHpG8tQqfR7CdYCewI+wqkU+rzSR1cTNe3XjRO7zks9FFQ+lzrf/Nn\nyXBl8Faq46jerLIBwqo6i1uF4zftYdqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCPGlwTr\nKttlUD5cRLuggpsDwwf8MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAmJ0GgKG0Ts8pMrrg/GsVQky0bP9WGf/ICQlwr\nr49Y2gIgEL96dgKNYfanj0zhLpFu1JpnOOIBbU3pr+qVoaxhHRM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5799", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5799` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAUx+3ZEE1DDhBBjvZMT99332MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyZWRlYTBhLWQ3NTMtNDY5Zi1iZjAwLTEzMWU3ZDc4MDAxYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDcwZjY3NTktYmQx\nZi00NTI5LThjMzgtNGVlMzBlNDQ4YmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE10PhKofKy+ju/3K4JY9LwKPAuNkHf1lwrBi9DwqPimI1bVbReGTAQeL3tyS1\nSoPbsEtUBkkHc2cSDBdiwru3G6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIodfcWdsPjgAFdFmOezNgr42IeUwHwYDVR0j\nBBgwFoAUhQ7oGyvUYEmgI2SXl7hYlte2lcYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAl3ikQcOMzMUZyKyvKkPCKCqWLFl/NAB8TfblWoN2\nPbsCIQDjh2nM22UQN/6/e1B+TwJvab5qadr1iddxDwriMmxZvg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeTG6jItR1MXkXeXNHzWNUUXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmVkZWEwYS1kNzUzLTQ2OWYtYmYwMC0xMzFlN2Q3ODAwMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS33rmymsD4h575uoc0mr8JE8GEnOfKMV78g2ngmV9MQUby\nTHFYdtJafxzTDhz1KSANiVSTCKAyj9KFxCm4RvQto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhQ7oGyvUYEmgI2SXl7hYlte2\nlcYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDCu0Koksy/A59KcHHBqnDM0KBkRYBaZpXv31aW3fIvkCIFtW76zae61x\n2F1GIzTvix4Ry9f+a/QNFPevPaGBiRka\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAXuCQGRCEIMlrisfa1dLhUQFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDcwZjY3NTktYmQxZi00NTI5LThjMzgtNGVlMzBlNDQ4YmRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGY2NDI1Mjhm\nLWFkYmYtNGZhYS05YjlmLWRkZTBiNmUzZTNhYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGSNZ4FOOGRQLgp72XuRd2wJAYdBj0WWEzeLQ2lmLWGKYdu23zO2wb/p\nOYLNpmKerVu38u/zULbz9+CVMaZ+qCSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCKHX3Fn\nbD44ABXRZjnszYK+NiHlMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAE4UpvLE+o0XYwtGQA+gR5+1+h4c+RH+p3LGMP\nDo0MkQIhAOFfSzzj7unlc+l+UkhQLuCKdR0JHvwtOGebG4Rbyqt/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5800", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5800` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAc36HAWh8f8q3dCNwZdh+BjoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2ZDVkNjQyLTY0OTItNDhjZS04NmI0LTE4ZjViNThmMDY0ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk2ZTdlNmUtNTcw\nNC00YTAyLTg5OTQtM2Q3Mjg4NDk4Y2ZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWVRyY+fDMffAwy9+penA7sNPkgQN1zU143TcM8zelcGsIGhvGkf+STPCuhe1\nxXQC92CAqFyw0iWdZv4DPDSfl6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkyioLg4WbeSe9LjPzmd3psf3188wHwYDVR0j\nBBgwFoAU/VblBQktzaBMf0CCAOUQnjSiSD8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiB0W3CALg3Zfig/j2N0P1rIsLv3exvpmZjWzUz5mLjwVQIhAIra\nKWPCCd6TZkG6qJaJ0kJg+FpZsBS1YFoJSWlMjU9I\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAemD9i6Omlf08CWyT7SoxxdsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmQ1ZDY0Mi02NDkyLTQ4Y2UtODZiNC0xOGY1YjU4ZjA2NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0oCBLr40vfvOd1lxf6wTpCnFhRRL2U+YoRZDABZSBtHFv\nHFUJOsT0W4exgUo8b4sjDNcElAC6rJfV2rmUFbU0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/VblBQktzaBMf0CCAOUQnjSi\nSD8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOxNRpu+BVf1099rVX/+ORIGqrE1bLymxYdznnI8XVcxAiEAlpKK91N9\ntKFfnB7xyKjynmtVYplNAPzMLPsMZz2Vf9s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATsJ85wCdxpkMDvm3p56mvqsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk2ZTdlNmUtNTcwNC00YTAyLTg5OTQtM2Q3Mjg4NDk4Y2ZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJkMTlhNmRl\nLTE5OTAtNDA4Yy1hMWMzLTRmZDljN2ZlMjM0NDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDPZTPBP3IoAxi1+4/xA+UixH8UZxJGtQk8hbUeBjcp7ZmQ84S3wjtnP\n76qZLifjTHe8GZl+if0FRgUogjVVF/WjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJMoqC4O\nFm3knvS4z85nd6bH99fPMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA2f8CwJIHbVMgsVXRrovUBXgk12zrEchTV3l7\nvBluqhACICvwvs1WzmXtRUDkdCMiZnpbcKh4xEFNYmPizYs+M8DS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5801", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5801` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASpG3a4yvDP0gvprOUwn/C1fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwYjEwMzNmLWFjZDQtNGEwZC1iNWYyLWZjMDE0YWI4MjdkMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY4MWIzM2QtMjY5\nMi00ZmFhLThjZjAtZWEzMzc5OWQ5Y2Y0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXDkByfBC+en0/7rwrdOrw5sRXOcj7C9hIWihCSt2jfPM/hjYEOuGWMD2Eezk\nZYMkeUbeq2bWEnMYMHN7V26mBaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8S1g3LIvefo0/kclSuTgztuBgvcwHwYDVR0j\nBBgwFoAUyPDs7LZJ1tufOUHFubpqmE3WSRcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBHPunyFKIXy2etrQP7x+awTAvXG+iWfiOy\nGmv7UZVMpgIhAN4OeKwsqz4BXR2mzl3tolMTjQHr727ldxQHjA0ejlay\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbKb7yeH3EZ+Z4u0289dVjFLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMGIxMDMzZi1hY2Q0LTRhMGQtYjVmMi1mYzAxNGFiODI3ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmq3D0L8W3QpiIdcirVHhN9h2FwUHUaQj/49PkLcVbuFXL\nyjSg/AEGK80da6FB1ZS7vTujnoKXKXANkP3uMwyXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyPDs7LZJ1tufOUHFubpqmE3W\nSRcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL3e4ZRs8Ld5emSI0gZas6VODunuroB0XY/5vMWiQQ4FAiEA6gAJZsrP\nhW74GONOpcrNBkY8m+FG3IWj22Jopw3+Oro=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAXc4yamNMBYoukC7to/OErJ7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY4MWIzM2QtMjY5Mi00ZmFhLThjZjAtZWEzMzc5OWQ5Y2Y0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNkNTk1M2Fk\nLWE3OTMtNDU3NS05NjhhLWY1YTY0Y2Y0MzQ0ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABIJ/NoVLL/bWKpiW6m0d/AoG70I2t485KVpwmOVv2yQ4hPp1O1d5JVHm\n1IY07QNtSPidopwGehOoo/TM+kc8nEajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPEtYNyy\nL3n6NP5HJUrk4M7bgYL3MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBXffIVIEY5BPa2lo0lOA+c7U69cj/7iCHoNb7/\nceHS/wIgcu1rMGUEr+F//40Aaz2OlOEEQ4Qmlk6WZE783npqVrM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5802", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5802` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAR95WJFa5rmjguO4ZWIpkiySMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjOTUzZTViLWFkNjgtNGJiZi1hZTQ2LTEzNzU0YjllMGUyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM1NzVkYjUtNzRh\nOC00MDk4LWE0NjgtZDViNzY1NWQxZmQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM2fcWMd1MAkU+P/66EIYOwLUIcwVey5PNvHHwJOymNkLfcErFwNJIOrON16n\n0oQPDy7hNNCRJYHQjMVP3FCWfKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfm2EWF7hvOBrPdHExYbKBNgt7PowHwYDVR0j\nBBgwFoAU76mZvRagU8zKw3PoR7/VkihmZ8wwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAiE1RyE7vNUNwPEoJQ/Vtm/gbmYVBQG+6\nUzUlA22HiM0CIQC0P72BRB7/4/ZpUnE2tDCQiZpP1Q/CidGYwOb65kNwtA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcMoaZrJOiNJRLn1+21XngrbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzk1M2U1Yi1hZDY4LTRiYmYtYWU0Ni0xMzc1NGI5ZTBlMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrjeKsKLe0Asthtiv1EuElNzCFWkHTiGbE/UDeg8/MhkZz\n0tYjQZyyVNLyisYvnH+ylknE1z4DLT4/rEhY5078o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU76mZvRagU8zKw3PoR7/Vkihm\nZ8wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXRLdwWm8WdyuvjGYDDmaWxrdwVQ6eih8olg/LIivZ94CIQCmOAjQbzVn\ni18s09355krPubtJdc/7y+1Fug1HIYJi7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAVBDghZIwS8PRdZQixjiQLA6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM1NzVkYjUtNzRhOC00MDk4LWE0NjgtZDViNzY1NWQxZmQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM0NTgzMTVk\nLTVhMjctNDBhYy04OGYzLTIxNGFhYWYyODJmOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGVgPzVVaKAdTt8yyDbe0Jm6jQqlYeKi6TvKeUvq70Hi/Ao4VxOk2K7V\n8g4e+h1JEHLAswjNDEmvK7UNoMkU5Z+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFH5thFhe\n4bzgaz3RxMWGygTYLez6MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBRw3ydvx4WND4yv857KQkwiWgXQ4CP8WIQPu/q\nJ10M4AIgE2Ly3WxB8pnq4HLGfGbR3C4izfrqj7Qxnvt4Ludx2I0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5803", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5803` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISASLTb08DYA+d2VuoITYLgm0tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2YWEyNjAxLTViZTEtNDdlOS05ZGY1LTZjZjgzMmIxOTNhYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFiN2UwMjgtOGJl\nYy00ZTAzLTllMGQtMTNlZjU0OTZhNmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEibOGniI0GcAZnDuMdeIJSfdHmHWMSLIty6+8XsDz0dYSq5lv0/2P15Ek0Tks\n7thFoHheAe27c8+VlMwu7Zy186OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+HdG6aUIKPGZBeTjb46rjGrU7cYwHwYDVR0j\nBBgwFoAUzmTALsxvyRi38EsfEFesP00NzN8wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA8eR29AkKetnR\nVUh6nO5Xj/NT7vFBCFnOWC+4KgIscz0CIQD/l2TTAwUxLkxdRv+xU2fdsGJxvCM8\njqKlpb+eLAT4gg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZFpZof/d+iT92BWGLVPLXu+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmFhMjYwMS01YmUxLTQ3ZTktOWRmNS02Y2Y4MzJiMTkzYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIsKxCw/4QZFhj1EFD7pifqA2d+rl+MN5QGaxzoqOvQYJI\nFOGj7+CeYp0o5qvuf1c7amwy3ACTbXYiWhocSEoco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzmTALsxvyRi38EsfEFesP00N\nzN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEXmwYHoAIvahcFSimjlOJFvCzd1V4xKmMtw2XCp9wz8CIQCZX00HxkZ0\nfob7Incvg/MnWS8jgrk3H1yV/famLFdPAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZjPg1/hWEdw9GA603+LifbhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFiN2UwMjgtOGJlYy00ZTAzLTllMGQtMTNlZjU0OTZhNmMyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFjZjRlYTQ5\nLWNkOTgtNGZkNy05NDE4LTc4MDJmYTFhMWRiYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNzUxK/m4B28S2N2BwMbJBO88NjQymBYt2Bpby5kizlXpKCRugwBdyuM\nipIM7/+sYiyymVvV7ubyAXkrIvRpEKajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPh3Ruml\nCCjxmQXk42+Oq4xq1O3GMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAv7C5xR4jB063P0YbVWayH01/Xsmq1/IqLQ+L\nMvWpTPgCIEcUQemzLCLRjLOenLPs38SFimwa7xIjz+FRf/imMx3j\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5804", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5804` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAeuXNgBLHdqcy3ohTEtS7X5LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjYTUzZTIyLWE0ZjQtNDdiZi1hMWUzLWMxODQ5NjgzZTg5YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDAxYmQ4OWItNGI2\nMS00OWY2LWE2OWItNzdkMDdjMDJhZmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEigtw8ZyCvd9QOrX46UVBnFyeQtXJpuBLK+KT74p8NujXMwEFod2rTh4F2KeX\nyxF6b6mW4DirvLHnO9nFUsCM6qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFYwrz76H31sNZPF4T1q/gr8OLI0wHwYDVR0j\nBBgwFoAUxX0tEf0gzOel77L0cGLw87+qDRwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDql3wyp/TgmVLCX9T9HAlgvORtoAIgLtwzD4Ac2KJTaQIhAJZReN5nFE+F\n+Q+lk/sUAloqy7fNT9XBu9SFofpWPy75\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARwaXUSL1Rjwa93OzEUVE/kqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2E1M2UyMi1hNGY0LTQ3YmYtYTFlMy1jMTg0OTY4M2U4OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATioPB1XGoOiU3rsUa1rcxoVZgFmRAp/Xo6wG5uRitMapPc\nOeINyj9zVoRikIihtNXyDru2oJT66HN483JM+0E2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxX0tEf0gzOel77L0cGLw87+q\nDRwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAORFNz8CoyLH880JRTGNb5J6yvhHKX+LdJ7Ur/uo7F4/AiAzrjPYIeUF\nkkx1fuoHKXrQrG/hmAAIOLLTmosL6smPKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAU9GsoohPK/mkrtnYrA8sx/CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDAxYmQ4OWItNGI2MS00OWY2LWE2OWItNzdkMDdjMDJhZmIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJlYTEyNWQ0\nLTVlYjctNDkzMi1hMTM2LTE5MmVjYTc3NTUxNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABA9M/1Y86Hw4C+MJsWfVLd0olAG5VFpQA2NB+PvAnSjpp/bu54boEzl2\nl0HR2EHDctAMArt9u8BHuYNN8Cmr/ymjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBWMK8++\nh99bDWTxeE9av4K/DiyNMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAyC/3Kk20jlJFbSIkMSyHX6gBOKv1ZhydYUGE\nKzR1eeYCIQDkIrmHj8m4n9zDCVfcVQI/nuEpj150XLZ9vqNCsISQnQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5805", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5805` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWwDOXhgSObetEN53PHpFvdlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlMDBkNjRmLTkwMzUtNDJlYi1iN2NjLTY2ZThlNDgzNzE4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI5NGZlZGEtMDM3\nYy00MTUxLWE3NzQtNGFhZGFjZGEyMTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESV8XaoxrixypzJT1o7QWWvDobYm47HeyM0DT8vHVMtgtMMI7CDfvBN6Agcd2\nTxCe3L8bE2BVkmjrmobb33tJAaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcuLEIYWKQGhtMDi3OjD//wCZW5IwHwYDVR0j\nBBgwFoAUsaBrMn2VQZv+ZAXc7y9YW0tFGdwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFsMDU7Vjr3Pmv1o+8/wLG1sEUIiNbuYu89xDMt/he+2AiEAxxmXRtqvUQqB\nghhek+VK79hPtma0lbstc9cXyQ1xXUQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYo8GVNQvXKi0ksVA0CN1CrsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTAwZDY0Zi05MDM1LTQyZWItYjdjYy02NmU4ZTQ4MzcxOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATREBzy4D6DiaD5TbKnvNW7oKF7L2lSQUhB145hBvMLXJnf\nSiAibzMnzyUb3ZIeITCHwMZKMhjLh+UaUwEYd3Bpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsaBrMn2VQZv+ZAXc7y9YW0tF\nGdwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIm8PhJdveATeMIdKYlr1gUUN1lD0+m099r41dcVxCRXAiEA4Cshw0pa\n4AMzoBYldjeeU1Oy/V18GfkWlfvmcV9J5I4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZAddRyCm1VcWDZE06LLUoAlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI5NGZlZGEtMDM3Yy00MTUxLWE3NzQtNGFhZGFjZGEyMTgxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDFjZDc1OTBm\nLTc0Y2UtNDhkNC04ODg3LTcyNGMwNGE0ZmY5ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKt03jPKFRkErFJIJdxbQa9vNc/08aLukxP9c/ZzCZgKUiywTPc/jQhl\nyYIcrdTKqwhcPY56ACa64iYbC18mRRajeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHLixCGF\nikBobTA4tzow//8AmVuSMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBzVSM+WpHy+OfGksIt8ekJ35IgL7Rh2j8GtJSp\nos1CQgIhAImZnWKCyR1UO4iAwYwaRNHR3Ri5mGNKNIaPUCf47n1Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5806", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5806` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZVW9+4qS55x82C9HwQ4eYNmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2MTQ2Nzg1LTYyN2UtNDViMi05OGRkLTgyZmJhYzM2YjBiODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNjNWE1NDItZGE3\nZC00YzIwLWI4ODQtODg4MzZkNWEwNjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4bymkUqAiC+p37vLY92nOEF6v993bGw6GEoohnKAOMlzeTrSgs3IQRsuEQT1\ns+sPufvCm03UCIGh7JsrSOrVv6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdBLEoubM0/Lbro4Qhc6flGl/iWkwHwYDVR0j\nBBgwFoAUtFCHKEj41eKq5j99s+D5YS6RFC0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAwdsqrbb0qWjRIEDBNa+7Rw89YeiHeSCAaXHzLhB1/SgIhAL4YI56Q14P7\nlG0KXdiJR3d/Ifja/NB1O4C9Z8bravBk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASos7il6NhJU/eYBZt1B1+11MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjE0Njc4NS02MjdlLTQ1YjItOThkZC04MmZiYWMzNmIwYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsyGOOBBN3QulCYs/K7RlJh0WPr2GMLn5ZxReAYIq00HUp\npWRjZSbcOgG2cKtpyf5Cm7PsvYeZjPqoJPNIjZ8co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtFCHKEj41eKq5j99s+D5YS6R\nFC0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcP/mlv0wQU1HjbmKrXx6Ij+t+elNeDIktQ/81hQ1hMUCIBxGPZWCpjxF\n7ZKb2f8edi23LOfOnVaH2KGfKOLcZ8WD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbt4sScIKmrnUNNW4jNvpdYSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNjNWE1NDItZGE3ZC00YzIwLWI4ODQtODg4MzZkNWEwNjdkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM2ZjcyMGFm\nLTJhOTMtNDViMS05NWE2LTljMDZjNzljZGY3OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOBfDjLBGDEl/YQyhkFttcEZkKJlkdwxDsqZTHEoHemdrVSCWj+Liogm\nvvJbZ/sa1Lclhndbs1fqZ10VRXD2566jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHQSxKLm\nzNPy266OEIXOn5Rpf4lpMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAh5Wu9200hRQb5gKRSKBwOeIudhFv5hZle5yF\nzg0aDo4CIDX/NLQUbgAAQ9SRbwVoZ+8fnBBA6+oYJyXm82385Mm1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5807", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5807` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAUkkSo8A9qLjLwZyGtdIqRWCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZWRkN2Y2LTlhODEtNDc4ZC1hZWI1LWNhMDllOWY4OTQ5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjcyOTA4M2ItZWU1\nMC00ZDMzLThlMGMtZDFiZDNkOTZkZWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEupHRYdGLSO8vYO1gdND0p7GX/+UT1mzIn3EA/cofZ/xwlw8VX5cIotE0tMbG\njyknOCxmQraOuxzTE6hvKmOrjKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAkEukIbaqK9EjUvAbHf2Ue+KGTQwHwYDVR0j\nBBgwFoAUNBtQsIpPi5WsBnMChqhDlObFmEowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAoR0N4h7n2cIZO2yfK+izbfY+TVyYlQ184bD435DK\nKzcCIQCWvk6QKD6+wbqQVKDXxOiCkSGY6uSvaXgRnI+bLYn1zA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARUYJij0H7ipaP/SRwJetTWRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmVkZDdmNi05YTgxLTQ3OGQtYWViNS1jYTA5ZTlmODk0OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqSfOJk7oSXYbmacmKI1DX5DPG3e6KowTTcq2lrWuSflOK\nX03XG5TtuZ38bU0//0CarU5rtu36sQ0OpWwuDjFso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNBtQsIpPi5WsBnMChqhDlObF\nmEowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJwjXHSbCMlMGn4SDdv0A3eU+X/RyLOMOHLrKh6NzlZwCIEtygS3hQGuv\nEhfPb4xBmfWCnLSmtxshSXp0VqmfolVG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaS9w6tlJnaXbCETGZy+KIo7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjcyOTA4M2ItZWU1MC00ZDMzLThlMGMtZDFiZDNkOTZkZWVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDJkZWNmNDBl\nLWUxYWItNGU2ZS05ZDYyLWRmMGJkNTQ1ZWYwNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC6QvOcyLldNqQDzShiMY9K04kb/dJATDWqqDjiUiaxmd/tFHlq/tdjg\noBiawMhPa2bps4n1kbAZZ9PBBNeqyvqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAJBLpCG\n2qivRI1LwGx39lHvihk0MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiA8RCBg4gi/cmT6N1XF1oGIAMo7Zb35yzz4aJnL\nhzOG8gIhAKmUUygCuTzV7bmorb6VyNLJvbislmE9c4wYKI7iK3KU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5808", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5808` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAeiNu0r+7ec9IkB7mDAzK0H+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmNzE1MjhhLTdiZmYtNDA0MC1hNjkwLTVkODE3NTljOTZiNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDc5MWMzYmQtNzk3\nZi00YmM0LWE4NWItYjZmNWEzNmFkNGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExLc7HXAGRiEXjLzZRC6idLwJTkWQrlsxr9wXgH9y7hShMqvv1LROH+TzchGs\nN94ySvKP7/OiF9xCC/dullrH86OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBy4rC5dXnkyWcg3PkfqNb5suPCMwHwYDVR0j\nBBgwFoAUFwb52JNB3Zho5/Clbjh8llLyid0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAxf3G04n3QVbwviJe75LwV0NScFFP0fIeLy1x8Zg7\nLqMCICeVTWRmePSq0c175xjgwe0dKHmSo4Fr01ZhydgsAc7i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdOoUGjeaf5VESl2jBxBOt9hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjcxNTI4YS03YmZmLTQwNDAtYTY5MC01ZDgxNzU5Yzk2YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi1RqZ+vLWdyCsrHGd1tf/Ut8ZP69deYzKO+QY9snWgAeu\nyc2iXnf3c05NS5BvbzT05P0fESLQOMbB0xdsu7RNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFwb52JNB3Zho5/Clbjh8llLy\nid0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIsuIDwZ/DPT64fQ+4B7kvgdmNEn+EivHfIEZBIZJU0NAiBxx6QGTJyb\nlCuUwa/JdzyLAG2azm3bIfUTs/TY4DxA8w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASuPrsClpTXXXwAL5ZX6CKs7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDc5MWMzYmQtNzk3Zi00YmM0LWE4NWItYjZmNWEzNmFkNGU3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDI5ZmUwYjM3\nLTA0NGMtNDE3Mi05OThhLTk4NDIxYTBjZWQ2NjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNJTLuHq8ZuqjMLgbSmvDGnUzybVMOyZYOjO4AHwicxlama+72VkEWPO\nIyQN5CBlT4jscKsaBDkgl4I/39R4d12jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAcuKwuX\nV55MlnINz5H6jW+bLjwjMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiA0vbpQCfAH4YHT189HPk+Q0/PwV4uu6PMQMohJ\nOmynbgIhANKaULoWqbTAdxWmZxMLun2zTm69Wx4o7s5ob9KBmJPL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5809", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5809` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAdQXafIjLUJdDU1utjsr8sUnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2ZWFhZWMyLTVjMTctNGIyZC1iYmJjLWFkNTA5ZGRiMmI1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODY2N2I5YmQtMzM4\nYS00ZTcwLThiY2EtNDJjYWU1Yzk4MTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuZbbVIrGM4J/WnppQC1G5YA09iv0AUgwZHZ3oIN0FUHJNGfOjpw4I2zIlCeW\nm9fK6xXNNNovaqKaSpLkTMSlN6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhPEw+v3OWtZrmRbKU/sD/UgEGWEwHwYDVR0j\nBBgwFoAUwK0NR9dC4qH9ngPrAHpRyXXxjy8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiATwuYC9yy3WyHNcP5uPy+mE0+CV7vWXHI+KFez7OWUlwIgMgWl\nEbTi24lO2uyUtjjMAaED6mdivI6P+a64pfy+P7Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb31r2ZDv93ixAqeJzBblukrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmVhYWVjMi01YzE3LTRiMmQtYmJiYy1hZDUwOWRkYjJiNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgo7HwKXVRGr59CjfAp0dQlAmubdB8Em1cV+Vn9MjR+mLf\nS1N+NfshBU0jRWWfKX8DtuVEvEheeVs8EZULdntdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwK0NR9dC4qH9ngPrAHpRyXXx\njy8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPvbCnKRHA7xnw5We45AEWKb0nc8BLrkFrr/0GH7vBaIAiEA5I3eLeK5\nGtmGqLjKoVBLxyCCyrB5sjAJf+t7czIg+9g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfrT0DKailERJTgYrKajqdTTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODY2N2I5YmQtMzM4YS00ZTcwLThiY2EtNDJjYWU1Yzk4MTQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDdkZjdiNGZk\nLTdhYWMtNGMyOS1iZmRjLWFmNmUxNjg2MDAxMjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM0iCeD4ge0oxFkgiDtwbwTUm0fMZDWZYdNvd10zV3oGnZxx3vjgzCQH\nyJ9z99zOb/N+HolxwE7bt2cldzmt0XejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFITxMPr9\nzlrWa5kWylP7A/1IBBlhMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAzXC4MJTkq/Q1FbtxH+wxUoKOGdScfz94uYdyP\neLJPUgIhAKkILB2qe7B5cfg9jUjlmIpEu7ep6zZa/tufBGNEMIoE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5810", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5810` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQ1FyXua+fmOT1mZb9yMKsPlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjNDJiNTAxLWZmZDktNDlmMC1iNWZiLTI1NWQ4YzlmMTc1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U1NWU0N2EtOTRk\nOS00ODY0LTg4NTItNDFhZjI1YTM0MmI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELxx6bPmlQAhI5oFoH3dKmYYJns2IXgFgxCR6qe3MS+zEVZj+PQ64zyiMIu5K\nyjYjEhH/Q5e/wQ/xZ6CpEEdjFaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyWdftLgpFhcxA3foWdoJNtagZAIwHwYDVR0j\nBBgwFoAU+y8Ochjt4lXTRbuusYh5jeq13gcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA41MoYt6iKq8LlTdpEJk3mp9mZagu/im9\nCDu2QSlRaC4CIENYerIFM39bqJ1y3GsJtbnGuLp5ROkpreIh+hmBPrwP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUAfIl88hBzh2Ld7OlZWy4x3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzQyYjUwMS1mZmQ5LTQ5ZjAtYjVmYi0yNTVkOGM5ZjE3NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQfSOa9PxW8T7PmKpyorbYp2GCm6DFXquyWLcbCMZmoMXy\nO+wvOl+GxLhCwwKkTTZtmMZKuNf2vTQ2I4CQ8Y0Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+y8Ochjt4lXTRbuusYh5jeq1\n3gcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA6YFWrtMX0uJD7cCuRThAiA9UYrWGk0GS0V3e4nL5goCIQDd1t9LVHKE\nC7AVhorzTyMikINtVG2L7PC+rngHkbRlQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAS5/3HOZHcc48uYgJa6LHWZHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U1NWU0N2EtOTRkOS00ODY0LTg4NTItNDFhZjI1YTM0MmI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGEzMWZmZjkw\nLTJkMTItNGQ3Ny1iMTA3LTZhMzNhZmJjMGM3YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFkgdIXPJFunByMLZ/bhyguxFbhqj0gzV35VwqFhE4w05Q18enzj2ciy\nk4lLPzz8in5um+tYOo6AQ8I21Pw0jiqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMlnX7S4\nKRYXMQN36FnaCTbWoGQCMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAiQh62rpqCL+/qpIh3vFz5cBCzoevJ8BVoa3f\n8lMQLU0CIQD9BPN4d2wuZ6gspCNIEgLku+guJ+9wwYwvQCGzi1X17A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5811", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5811` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAQkBWV+sLzgpgFMMM0SRd8MZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiMzdjNmQwLWE2NDUtNGI2ZC04MDE4LTYzZDFmZmViNzA4MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZmNTAwOGMtMzQ2\nMy00NTM1LWFjYTktYzUyN2Y3ZWY5NzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn0b7I9ILDiqyoOn9v0xunVUpHylG6gsNEEWhBOuBAgx98onvHnYqb7A+QzHC\nGCmEQhdOGXAkJxRpLriOzFfhxqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsKCa3ne0rHd1ltgNTTy2vdVoIucwHwYDVR0j\nBBgwFoAUAVucRVbF2Mosq80KHVGE/hm+uiQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA4cEJEWXr1MUN61ot4q+NIXL8XGbKOmf5\njqk1VCB6DkYCIQDUI4PdgA0vazhI9CpEoOpCyA7VMCVSvlJf/9CF7GvFxg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATNBd3WiP56ijC9H0DPW0sHuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjM3YzZkMC1hNjQ1LTRiNmQtODAxOC02M2QxZmZlYjcwODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHTmrjpP39beJQ06tIm1O3s66nO2qvLjOGMwkYhTzhGLoz\nK+OznMDqNNz49BlpBptJiSl2TWd9sy1+OcoFrE8Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAVucRVbF2Mosq80KHVGE/hm+\nuiQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPRWjgqJ8p84iKQfcX/Ng660UEMx3Rv2Z+jLuqLv3Ez8AiASi/50vJRu\nLJXx4V9uANpruv11AR1DrkjP78nYIr6O1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAWaHd/sDWQbdowKDd7cyviSpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZmNTAwOGMtMzQ2My00NTM1LWFjYTktYzUyN2Y3ZWY5NzliMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM0NDE4Y2Ey\nLWI0MjYtNGUzYi1hNDExLWEyMmUxZDNkYTI0ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL01Ql8qVdLqtqD3rLoHlQubjgjr0fKDzw6/aS/C1E/fwR81uwJE2SOo\nHNQM4PIkizsCtreJfjNRR0gFQm7UeSujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLCgmt53\ntKx3dZbYDU08tr3VaCLnMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA6mTS+fzn/CUN1TG9Ij3VKYxQxEhaF/FiCmTF\nQQuY7JECIQCVZLN/zWtpVJGPofOkgf3sAQKPSFBqW/zpAcea7aJqcQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5812", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5812` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAY7LdRVh/9+OBPAasyHMVQEFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5ZDZjZDMyLWQ5MGItNDAxNS1hZDVhLTc4Y2FlOGZiODk2ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhkODc2NDYtNWEy\nOS00MDE4LWFhNmUtMGFiNDYzYTkwZTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiujkI63qFe8telHOkEC3k710ZzzjeVWYPVFNrlcqTeOZmZ2J0sgSllEeQHRJ\n3gRMdvBEVMRqiDADZi/m7AYCL6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfM9PjzgSls8/ultqt35tkS7NxAcwHwYDVR0j\nBBgwFoAUU4C2TOjczsKx1ybdlA+gOO9AxPAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIF6BR7EaSuNvtHnTalQ6pMhaYjnd\nK8PZnqqL7JJo/02wAiAPnN7dprFlcbiut0U8u8L6XVf6jLqkyB1v5djrs0TH8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaTN/i7jdgE4K6NivUdGyoX5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWQ2Y2QzMi1kOTBiLTQwMTUtYWQ1YS03OGNhZThmYjg5NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARi/VyZaMiOPuQ1isPJP9/qNG1FM10FJ6atLvMSbRJNaFW6\nCUW/Vq6fZDWabG+tnHxG6hUFgNK+/jWksku6DZgLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU4C2TOjczsKx1ybdlA+gOO9A\nxPAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc6ZnwgA2n8VYldFQGt1qwl6t+wyP4gsfXuzyUP6X1OACIH5WZValv6hp\nj0GxiuJEYAyV7VbmJkk4v/5bijCg9zNV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAT1LRzmIgRTG2DbOF7i/wfgPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhkODc2NDYtNWEyOS00MDE4LWFhNmUtMGFiNDYzYTkwZTE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDU0MTI0MDhj\nLWViNzgtNDc0MS04MDI1LTM0NTBmMDcwNWViMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLQA4CppCBfRQRvvKcbhh5+petWT2/jLM3GbVNrz1WfrTucNxxJIBM2R\nBXMb5SxXMNoaCkZmA8qxH2LSWRVigwGjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHzPT484\nEpbPP7pbard+bZEuzcQHMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAvEwHBk6cmXxNd7uPkhwm9TSq4+oucENERFHbi\nT5F++wIgdlSFYyJC6PDw6s1iIwA7z+ZcEYs9ldPH6ppZvkbuogw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5813", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5813` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAQpKNRUky1wWaGwLZ9HC/GgDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxZjdiZTE5LTU3Y2EtNDJkNi04M2JmLTgwNjBhMTZjY2MwMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI5ZWM1ODktMDZl\nNS00NzYxLWE3NTktNmU2OTVjYTU4NzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX9B/xd1H3qK8FpsvAWL2RtsR3eU+jR9HE4URQeepQ0ONCKZcCpm63xyVoKjA\nGTGaUBP5t0z9qOw4VyJrLLDQ66OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtTqSAtzUenXFfXD8tivzM7DaG+UwHwYDVR0j\nBBgwFoAUm+L6//oaapHTSuDb/T6hH27ak+wwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgA7WQHMYh\n8QlDIpF9cBkt89RCdKOLs7pitfgd36nghacCIQD6kvEz0jdTt2PqeSulvZTeu3jb\n6lWCVhkM9E1TVxLQYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVtG+nz0Ek+W27m9Mo7emxYjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMWY3YmUxOS01N2NhLTQyZDYtODNiZi04MDYwYTE2Y2NjMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoI/krNh1e4vy15o7NoBwjZqT89jhhG3lkEy5Jnw6Na1oO\ntTXM/mXqT34kco5p8ysmFs70n7fAdzioZF9KhCQUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+L6//oaapHTSuDb/T6hH27a\nk+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG6ZflkJzuSbHdaCjiU/qLheMY3puXo08rPgZayqi080CIQD9K38GVXR+\ngP2/qh6W0FGlePCb79x2CO60sZD/O6DoSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASJ8mByRut7FCj29hH5S2byKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI5ZWM1ODktMDZlNS00NzYxLWE3NTktNmU2OTVjYTU4NzY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDNhZTU1YTFk\nLTMyY2EtNDU5ZC05MjQ1LTBlZmUzNDEzMjkzOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKNihPSMGAC4mdmdEeNYs0rr6G6znbBYxo4ddPicPpw3nCOaYQI7tjc2\nXeJNDTFya5PcZXjTrDB/kStSbGPJVhyjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLU6kgLc\n1Hp1xX1w/LYr8zOw2hvlMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiB+7JRLJBd7URjUMldzIRLWGkq8OKrrNRw6oNCX\nzMNw8QIhALZ+oobE6Wbqv6KVk2t8044JrjGBDopJlqQRgXUBqhlc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5814", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5814` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISASEZ7RwwftHMmTo7z7FmSxDkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyMjExMzIyLWM0OGItNDBmZS1hOTA0LTdiNjI4YTNmZjczODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI1ZDAyOTEtMjRh\nNy00MWU4LWI5ODItODM4NzQ5NmEzNzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOStb7m8hKZyKMZNV4fX9UJSm0F2yz1xdaSTn2SCAaitt6++Vdb0st8NzjhiN\noSQZLsDbphKTA/pVFe9teuonyKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC+ZINOG/pB3o8Th9EIOiekDTGJUwHwYDVR0j\nBBgwFoAUqixqm9OOJszTOWgQnN1CXHe5wJswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhALwCNr2d\n6j7XkefSb5RLXikVQUBEprVaxcViSVJZJOBuAiEAwBSeaVk845xSNInfsJtNLxxn\ncFR8y9OlcqHRkfrwcy4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU/EkGIlCwq+ei/gQO+r/qVJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjIxMTMyMi1jNDhiLTQwZmUtYTkwNC03YjYyOGEzZmY3MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/R/iuPSqX+nQe4wSNgQrBMqOb4muKlJDZkK5Kaqm4+gcA\nsWa9e5SjR4RObFN2hUJnwHtTEWh1a4BdkqQ2L6BDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqixqm9OOJszTOWgQnN1CXHe5\nwJswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOO4t8vHkV/8c6vpoOljIZKzF54INoJ9uDP1AjMQMj0nAiAHegbJcNwA\nNFRX3CNsY6Iq/nxkYm64jPFNrEctt7l5vQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZzU8VIXbi3aDj/hyL82pw7xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI1ZDAyOTEtMjRhNy00MWU4LWI5ODItODM4NzQ5NmEzNzQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDE1Mzc4NTBl\nLTBlYTktNDU3YS1iYmYwLWM0ZGRhMTY1MmE5ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJLpJQ9u6551hqCc00tdQj+07KhQJoatQW8y3/U/mqpx1z8PyCRI8fmB\neCPjoG06He5mSdQ0Z8Tavj//WoPwrHWjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAvmSDTh\nv6Qd6PE4fRCDonpA0xiVMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiABfGTGxwYCTa+IW+Ti+729iYmLmwnclcyxu44D\na1Vv6wIgBqYHdS5FML82W0tHfMVl6EBq7o8+NPDOqJ5V3MpHPco=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5815", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5815` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAbfQkH4vB5+RI0TOtjm82pssMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNGVhNmE3LWI2ODItNDJlYy1iNjA1LTU4OTZmZGU5NTk1NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjYwMjVhZTAtYjA2\nZC00ZjA5LTg2MTMtYWMyZGM4NzkzYzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4CV6r+g+AjDEz/UJ3ORv0+Hv1rTD3l9b0FWzyv/2PLVhW8AvBd0EPjkVt0EH\n30+Ua14CssqngGzIZIwDolJ1hqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/c3St+nhkYdQznp1yubhpgJYvTAwHwYDVR0j\nBBgwFoAUQgYyQuK2pkkDEIDn3OOVEfLAOikwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGh8gwcu\nH9WBVdKPtTQYWkk5vLoCTaURUtSGH7mDwkbvAiBX+y0+uXZKK47iCGE+N/2oUkLV\nrnlLWgCPmmoi4NexrQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfFDhluiKWhd2w7LvHUudw6nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDRlYTZhNy1iNjgyLTQyZWMtYjYwNS01ODk2ZmRlOTU5NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkDUwIUPVNqNdgXolIj+EdGaZBrZxEA4FSlXRYHpBia0Xj\nCKHFcOo4y+WcwUkeeFVzQhBCgmaq/MZ9HH9Q//Zpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQgYyQuK2pkkDEIDn3OOVEfLA\nOikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK2ZNXUe9C5rcGkz/4BzNYsNxtizAsTdRHdMvH5ya/tGAiEAlw3XuJHv\n5zCtyeSllsTr3XNp55ciQcwIewGf71aCrCk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISASZ5px0GNNZqomQ8R3gRiO8CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjYwMjVhZTAtYjA2ZC00ZjA5LTg2MTMtYWMyZGM4NzkzYzQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDYxMWFiMjcy\nLTM0NDktNDZhOC04NTQzLWEzYWVhZTFjNjVjMDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLJOYyubWTEcokHFmzEVffFSywvPQJPU8D7O73lP0QefX5q7O23E1brj\nNE+1DU8FyczRMPbycIpCCxZ8jINpMVOjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP3N0rfp\n4ZGHUM56dcrm4aYCWL0wMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiB4xBKKZpzijOayYkltxvtqhsvSVH5bTrZXFJ6+\ndQcXVQIgXl7yIsrW2N3ZSIdSiWnqntd9136d9bLI805r+gFl9Lk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5816", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5816` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQpp0AQcJtilvLZjtNRMRLYAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmNDQwYWM0LTM2NDctNDI1Yy04YTk0LTY2ZGExM2ZmMGY1YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdlOTNlNzQtZGQz\nMy00Zjk1LTk5OGEtNGU5MjM2OTkzMWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+5LSJVDFoIGpWPb9i/UTZoNktWJlXzk5Q8NFkkyBIi20BavrKlTW1zq8iclH\nk5LrlAwEnqT4q3lSUgVf6uuTpqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI5YFs9k8v69Ep4SVZuCr1kX7i68wHwYDVR0j\nBBgwFoAU4CaZC+GjaoKbQG0m/jtl7K787KgwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCGbDTSNQ/CLOq8J/X3klxccHiAMh1cCFWRAMnkLcnlCgIga0+aLzuY\nvSBWdVN/nINhkA9P7LldNBg5ITWpyqYmfvg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe3WoFSkJ+61JlJAyu999FMsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjQ0MGFjNC0zNjQ3LTQyNWMtOGE5NC02NmRhMTNmZjBmNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5qitYAS65tyMvU/QOADiKn1UYoZE87Y+TBFoYtnJbW3dW\nAoEkglIZ3u0iwjDEg4kTjZfA+USiXUk2pGKi1/40o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4CaZC+GjaoKbQG0m/jtl7K78\n7KgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKc6TYjNaxloEOIfXtn4wkvtb4Wy8Wh8tk50jK+vdB4HAiEAySSbkv84\nS+3+3vFoLwhIXAxD2daAAEpOIJeyAdEVetM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaZsTa9LIvxcFtDFiaBNqv0fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdlOTNlNzQtZGQzMy00Zjk1LTk5OGEtNGU5MjM2OTkzMWM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZkNGE4ZDhi\nLTBjZDAtNGNhMy05Mjg4LWE0NDBhN2YyZDEzYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKPju3vcVInZdMHDhrLRLlt1E3/BciEGNS62T0vG8kOTFEFUvTtFgTJe\ndUe5u0UvMKK6ccBBSYJ1i+yceGgXR1qjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCOWBbPZ\nPL+vRKeElWbgq9ZF+4uvMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAUN4HykG8+ix2ov8NojCyxcIsCctgB138nzPrV\npt9awAIhAJVnjegOSU+B/lSz9PVrVgZmPtqhjzXJRYK2iI+JLQJB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5817", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5817` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAfzHrFZmORUcVXxabfy/pCtyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyM2M4NTI3LTE5MzEtNDQyZS04ZGQ1LWE1ZjA0MzFhMjA3NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU3MmNhMDYtZDJj\nMC00NzlhLWI3ZDQtZDM3MjI3ODNiM2ZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdIvlco1C4hzdwFWKjGr4ogu5NjJKNDthptw9msB47pZ8CkJRCCzL36hy3kHP\ns4eZBhoQMu4aVlqJyLQAGz+ql6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ0PRGPu2aXLdFopZ8BUUZoNMCMowHwYDVR0j\nBBgwFoAUKqPw2KGJ1++eaoz+E2G1JdOVJ+cwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDiasRK6U5Hq0iB/hwLMIPvnXSzmVlJjedcyhUSzm3zgQIhAIUpxZrB\nl6kaGyBhElneW8+DFbzw95vIUGHSf2SDgPXJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfP360Fck8fXCNLvUVAxq0kHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjNjODUyNy0xOTMxLTQ0MmUtOGRkNS1hNWYwNDMxYTIwNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOxybvmLcvvcrhtVcwzHJbf2BHrpe1kndUcC3fOerlrW4D\n/vOeG0lFVlfIYul90KvbiULfX5Q5xPBwWlOFD0TEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKqPw2KGJ1++eaoz+E2G1JdOV\nJ+cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMnZDq/i34Bwb2U0EH0tv1RJKbm7f8pu1f99D9eyaaNSAiEAt78rvc1A\npkejfNEJkuXlug/3hCqe8o5TSVjPStx7Fow=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcLTocR+Y4lFGHQ8W6r3HoLbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU3MmNhMDYtZDJjMC00NzlhLWI3ZDQtZDM3MjI3ODNiM2ZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY2M2U3YjQ0\nLTJhMjYtNDE5MS05ZjA0LTk0NWFmMDBhYTYzMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOhAc/AiYbyIMcxettvPRovYBz1XU95NWUV8pxG4zBCj/ehV6f1hnnTA\nhyXtjcwbgmZtJMml5FDGA8bCxles7ESjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGdD0Rj7\ntmly3RaKWfAVFGaDTAjKMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAnOCuaYftwZ0HghaPJmTiaBFvqtLrmDZivGA3\n2USwoaMCICSOadtyxlbHbuWcYOep+EPYkEHtjLXZeD/4NxG/bVPG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5818", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5818` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAfNKicYWo4QAB4dpbYbnDuIcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2YWM2YzU1LTgwMmMtNDk3Zi1hZGQxLTFjYTg2ODI3ZGZjZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFhY2I3NWEtNGY5\nMy00MDQ2LThhOGMtYjRiN2Y4NDFhNTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZnjurA2aL0r0nQxmShWLuylONeEXgh0jyk52CpiAJx0XmPfSUPhG8LedALvZ\nQy3PsvflTfnlhowaCQp52n5TH6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdH8I+iwW/q8Pokc4Piie8GfTHYwwHwYDVR0j\nBBgwFoAUaKtzNxOp7Y0N9IoY9ErBmdRi9EQwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nICkHFlL4dt3c5vs3clbsMH0kHNSXOOKrPawzcjUGyD5/AiEApPUOu8fvVdTY8kyc\ndx7eeUnYAbNWaHDwpM13R8B6hUU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARo+IhrQGxyCUmZ8RXDxR+PtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmFjNmM1NS04MDJjLTQ5N2YtYWRkMS0xY2E4NjgyN2RmY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/j+Phgw9SKoZ0evcAu6adm6mRIhxyGI70uLavxCo+/il5\npw/F2+6gWkXSA2zc4W4LoIf32RYvuAf9iKZPG9hmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaKtzNxOp7Y0N9IoY9ErBmdRi\n9EQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANgW323d4jgJA4x0B4KAS685jsu/l2jnF+RcjlEw4ixIAiEAjSQd6tR4\nO8ZpxepmU8ECTLticNVQvLC6SgTHPiUeT2Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVtbVZyc85NAGbFwIbEmRqxrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFhY2I3NWEtNGY5My00MDQ2LThhOGMtYjRiN2Y4NDFhNTNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI2NTRhMDcw\nLWU0MjMtNDVmOS1hMjc4LWI2ODViZjE0ODI0MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEgfyVTpl0rtFLF6fQBSMLgz9o8buMdBYYeCTCfMIud8t6IUSykpXEeg\nTJPrBc3cRZ5sZlBJud9BwIoh3aQAFHCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHR/CPos\nFv6vD6JHOD4onvBn0x2MMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAwXk1mzLrdNSaOp8nfVVLhZMZ/ZW2tvQbtaLz\nXMnhPCgCIDLH5CK8eTX9jL8ZetA5D5VAEraO8sFAuVarIouzjzLM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5819", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5819` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAam0s1dASsYr1oQzSxXGxjZlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkZWRhZjgzLWFmMjgtNGQwMC1iZjUwLWIwNjg2OTQ1YmJmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ2YzM4N2YtOTAy\nZS00OWU2LWIxOTMtZTY5ZjMzZGM1NjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz2cA58pmFEOI6ltdBkBqzbzVPohPEL9hDuth37XejvjjkhMjUsxgpzmq4H/L\nTqOD7BIqfvMPsMNYrM4UxErhdKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxH6KyoylgrYncnnDPcqRrJIIdGswHwYDVR0j\nBBgwFoAUaQW+hAYK2hH4wxQWRRGq9cYd2WEwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDjG+TGE59aaeAqaWob4vB8mhBCv1+E4NQS07QNBeh1wAIg\nPHc8d/EYnVVUFizt97yB/mA7a3t6QOSOFIeEPYs6fuE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASzkjmui7555Ib2HVI4R5mrKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGVkYWY4My1hZjI4LTRkMDAtYmY1MC1iMDY4Njk0NWJiZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7JutmH7fxogbYvoyUY2laKsXCepAFGgZHiGcPCjsAq+oD\n9V9mWtYurWvvsoY6H9+VR8DEvVua41BaJ392tm9po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaQW+hAYK2hH4wxQWRRGq9cYd\n2WEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIvMqPe51mBEmvIBmIcxFWn03MvhXGowH7yWnPVHEn3vAiAbrTu+rZmC\nm+KfO2hSNNX9rsre9m574Eox1PcwnRJiVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQix3Uh/DZwJTDu70X3jUj6KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ2YzM4N2YtOTAyZS00OWU2LWIxOTMtZTY5ZjMzZGM1NjU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDkxY2ZhNWY0\nLWJkYjEtNGUxYy1hYmRkLTY4MzE3NmMwYjFhNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFPFrCYJ0BtiOjzKQMyQ7+orni7qjiF1DL9/UAeFFcXYgFqTAf9N1xeO\nxW1GT530EpfSnnpsUikijNYkr9819SSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMR+isqM\npYK2J3J5wz3KkaySCHRrMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAuGEWdW+Bl1I/0tePvpXoc3dCqLFAqse8Oqsv\nQ64XgxQCIHiuvtfa5RBjwu9NqPScIsROURNpHxMAafEU1oarao7r\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5820", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5820` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAQ+ZqsNeMljBmb3x1NxU8fEDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiZjRkNDZkLTE3ZjktNDJjYi1iMGY0LTE4OTU0ZDM0MzlkYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTUyYjhjNzktZWU0\nOS00NGI1LThiZTktYjdhZGE3N2U1OGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz9r+LCiXj/2hrQcKyTlAnulIB4pr+tT0bglIei54OLGQ17lekANA5HFQODRj\nwSrHozeLB2menvCwVEIQeoDM8qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy4PhtsICwmuayBSwpoNPGYexo4QwHwYDVR0j\nBBgwFoAUc+jB/DbG/tt5oPcT47a0K14l1NgwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQD2kMRQGyLGiNC+S4fOuyzNfLzTK8nF3c8k9s+zQXo5PAIh\nAJ5Uop6qNitF2bDCZXD/qg0zpQqcoIasm2oYDA5adggp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX4ZUvz7hTAS9X+n2oK6d5d0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmY0ZDQ2ZC0xN2Y5LTQyY2ItYjBmNC0xODk1NGQzNDM5ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSseNFYbVyX7DDZb7kGnw81Qt8XdamPVdXIR1vjfehA7YP\n2tTLTnKOv8gqfVrMWK0SoUGxbPH8lkhtlXNY1qREo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc+jB/DbG/tt5oPcT47a0K14l\n1NgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD0P2H/iJDkc6HZwOhkd1GHgcqcKtqe7CS/B5YvzYyKwCIQCjf7jvFOYx\nCWERDvpgbU2v/Ms4iZy3UZaHKU2Sy/ePkg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQPYXdbm8L+gRdyBVC3loAi8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTUyYjhjNzktZWU0OS00NGI1LThiZTktYjdhZGE3N2U1OGFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZjY2EwZDU3\nLTkzNjAtNDQzMS1hMzQxLWFjNjhiN2I1Mjg4NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLf1hptfV1OltrrB2gQozeJ7GGaDixzd5RAho0UiieUcHa0jth5Ie2oD\nZcZ7HK+Buxcb9XwD8PLaQXzCLihOf3qjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMuD4bbC\nAsJrmsgUsKaDTxmHsaOEMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBaLcLsrw8dNUIs1nnsr8mAP2/tkO5ursRyJbwz\nmuu/QwIhAKnBsv5noGA9CcVdcuiRvY/T618EcMa+njdDe/pbdNB+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5821", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5821` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXYAdncIg1dI4yhu9belSGUjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5MGNjZjQwLTBiMTItNDk2Ni04ZGRiLTQ0MDA1YWMwMjIzODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM4YjkxNDctMjEx\nZC00YTE1LTgwM2QtMTFhNmE1ZGMzZDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbTDoseAgvoZCmDMxbh91biGGtZh5jqTN/PeZQZXqoYINnDfjP06UjU7QfLyf\nt9XtUOPT3mXKx2zBvZJlQlTagqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4rGerZU2EUcS8lWzNzYyuSz+tQwwHwYDVR0j\nBBgwFoAU5QJwci5uaUOHZr8KjU1lOkF810QwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGolbbrN44tb\n8lXLh/TB0a3w/MPK/eFytXvXKM024LPIAiEAkZD/vdrj3RXvoCnnx46Pj8wedxD5\nB0qepQW/b+JSuqI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfvZTnMX29CJ6CrQ/ivka/pVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTBjY2Y0MC0wYjEyLTQ5NjYtOGRkYi00NDAwNWFjMDIyMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/iJfgBPwsnxxJ8f9Dvug46zQDZlBQik7kOifGHH+ZhnKL\nN342XnVgexrzWo/lobhgihEETufsC+QgzRs4XWvSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5QJwci5uaUOHZr8KjU1lOkF8\n10QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPEH8hWU6a2d7d11KbI+NXVvwCC3arEdX46vvS2yWH5nAiAIJDRkSEZ+\niFhjeJ9ndy1TmRQEtgeTduY4TE81OF/L5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAf66Y/bG4ji0uo8ztgJaFoGdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM4YjkxNDctMjExZC00YTE1LTgwM2QtMTFhNmE1ZGMzZDNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3MGI5MDAy\nLWZmMjYtNDAxZS04MDc2LTdkYjFkYjdmM2QyYTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAqgf1wrhAqtf7oesZ//7hJnVm8lxi42vvOOA4z+VceuGr3fL44J5A0x\nfv2yZAYeBjKqqyihhJgIFQVuiSjQf2ujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOKxnq2V\nNhFHEvJVszc2Mrks/rUMMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBWPqMiitAK90rWIa+5QftCxYv0PRbtrB3dfNzc\n8bEmeAIhAJ7qOrrNhahzkJCwMZ7BY14ST7qYgBl32dH4IEjq8aWy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5822", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5822` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAYFDRbVCnb+pCP1eQuIiKCAGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjMmFiOTNiLTIyZTUtNGNlYi05MTc5LTI3ZGYwZmRlOTE3NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQxZDAwYmItNTI4\nMC00MDA3LWIxYTEtYzEwNmNiZWM3OGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtKp5S04oHaa1vp3vNlCOzRMz310lwPdmglOagI05HhsJe18OkuhWLVzYmRM+\n2i0i3VRO3x/TLb+0VHqgPnjxCaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOqsfEhfKNPOiVrZMEbo3JjlmoV8wHwYDVR0j\nBBgwFoAUfT9J8XjHzDgUYDKr25q32vVPxlMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAI+jCSeoCv7dx8QAvtIvD1yUghQMai5tQDs3ikiVA5Z/AiEA5XPaQy+j\nS5TkIbOSJPd1MoPRlWV3upCLgOngEJq7Awc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe5Gae+bj92aHAk1EWTlGzZ8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzJhYjkzYi0yMmU1LTRjZWItOTE3OS0yN2RmMGZkZTkxNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/1VttxzeOPwxVYUQ61vzLT88NO4GNfcTKW45KgYAW7Gmp\nxnTasD7G3TZD0OttG765i/hhTaPSL2/wY654wWsOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfT9J8XjHzDgUYDKr25q32vVP\nxlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRjDLrqMGWOD+lKI2qYcyJAJkiHg29z9/Rz+lYGtmDb8CIHrdOYeEjnTH\nIfYjXMFFfuFaRPKkMrrINmi0ArqBv/ry\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAeX7gEpVjFRetZpPtw1MOcI3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQxZDAwYmItNTI4MC00MDA3LWIxYTEtYzEwNmNiZWM3OGE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGUyMzU4N2U5\nLTQ0YzctNDg1YS1iYjZiLTFmNGVkMjFiMzIxMzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEnhSvxTqrCLJQPUYTPzozPnnBj41Ww3KQAXpKfe3W3PKShDLqpgk0Nv\n2zr5lNp0K0OPSPXlqw2BTW8/oDUe5CijeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDqrHxIX\nyjTzola2TBG6NyY5ZqFfMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEArCgPUAuIqNkRzVbvS8ydjRjhadk4vOQbniBA\nR2toYp0CIQDzLhlj8v0Xu8C5k1DDhZcc0S8H80afWG5PJCEcQdXSbg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5823", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5823` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAZrg9A1bonYfZykQhNFowNqdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZDcxNjI3LWIxYjEtNDU1Mi1hOWU3LTU1ZjM2YmVlODAzMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNkYWVjMmQtMzU5\nMi00NDgyLTg3YjUtYmM3MDk1ZjIzYWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEse35B48I+xV0ezGHi07qAKfb+1ntu3WMxUBkEbLa7FXQktvIWdSarWuyWTtI\ncTh0Jgwx+S41pHD3UryDxrRMEKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrKuIp8i6F8qFkwMz9C/QMEXrWmYwHwYDVR0j\nBBgwFoAUEg0bAVfURAdHDBclQTK+jkgL8DQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgRPtyU610fhxUqmGxz6yCdhmm6pLFFiOE/aA3yqdjuwYCIHtS2amC0KTk\n4z0KYFGp4OOoEIw5IiF62J2n3wqPV8aB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeBu/eltZ2VfgdId0gi9cR6tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWQ3MTYyNy1iMWIxLTQ1NTItYTllNy01NWYzNmJlZTgwMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ391LxHs2GtiN2fKGa6VJV7NlXtk4+gnouvMQLCPJ5Nmag\nGzHeE63DkT16JWWaPJzVtmGeXC5++y546WPDrpbro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEg0bAVfURAdHDBclQTK+jkgL\n8DQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA63owJ/u/HpGuSh84T9WM+CHCCsu9PYXIJ7B4/dhCPYCIQDis1fIgjBb\npcxei+SitnG9X3zPsL3SYa3gHKeGKOhKhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAX5V1sGtr8t+hjf8oPZl9ZphMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNkYWVjMmQtMzU5Mi00NDgyLTg3YjUtYmM3MDk1ZjIzYWZmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFiNWZjZTUx\nLTNhNzYtNGYxMC1iOTFmLTRiNTZjZTZkNzU5NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABH37B3/fcsn4Eot+2UVLz6uN86enZPFLydNJFq51NRvP/t34stW55ZE4\ngZGmJZBr+yGSRQHjDvAyU7hqRwbu/vSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKyriKfI\nuhfKhZMDM/Qv0DBF61pmMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBA4pkZOkUDpbYb8tyNh2WiwbdHJwXwSiHDYHaQ\nf9wRRgIhAJf9Btjt1J4e2OLAVaqPB1surjpgyFWPF24TLa4w0BC4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5824", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5824` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAQ3QyAN2Ix90lsz1/j4jCkw+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjYWMyZjlhLTRjMjItNGVhMy05ZTMxLTIyOWZmZGZlMTA2MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNhNTViYzUtYTlm\nMC00ODI3LWI0YWMtNzBhYWRiMDIzY2QzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEq4+er6mC2WbCqKgGF+qr3Nz4lAclVTbXNaBy24Re2fX+lhbdQ5usbUfOlXu\nKQSQ7k7OGAsvdtHFNQk0faaLLaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV2S7c7dxrvUkfrPfyhsT300pbSIwHwYDVR0j\nBBgwFoAUi37D7Mlwx+gSbS4kdQWhPipoVRUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIFq2in9BxsE3RMfwbLmZLUa/FjDl2NMf0vc5D/ja6dOSAiAQhnVzNVYB\nNqKTJP+ITCleVosyuNdrjuPBTxSOcL+onA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT6qHtplyb5kqofbwsvNreXaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2FjMmY5YS00YzIyLTRlYTMtOWUzMS0yMjlmZmRmZTEwNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXVQ7tqU8P8QoI6sOtNyY+ux2mWUk0CgC+A9n+WqI4CryH\nPVAc83EmqCLmRHqdzlO00V/qOPT3n0i3fLYQgwRIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi37D7Mlwx+gSbS4kdQWhPipo\nVRUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIOlPZ+pcRtqImkYXyRgHfiDNo5U5ClStwXyIF4XI4B4CIQC8Eu6VD5nh\nfdqnLqAwH9m5pXz3vSo3URZM6JOP6TOWow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISARFiC/WXkxWG7feUWNaaqHM1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNhNTViYzUtYTlmMC00ODI3LWI0YWMtNzBhYWRiMDIzY2QzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDliZDk3ZTZi\nLTc0ZTgtNDljNC1hOGNmLTYwMGQyNjg5NjMwNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMR6EnIaJn7lB9rOVFj8RmM0foJGDQ+BxWOhTW37WsbclzgaBLRBkHgH\nsEnOBXfjPA08gNKip2Ag8+fHWK96aVCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFdku3O3\nca71JH6z38obE99NKW0iMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBMlQQYme+zc7DawUA7w14TF6MX0bFjDRSsJvND\ncHlQXQIgZzBbYy8Jh18VMEsFlZt35x/qv7F6482e8YyxmO/ivGw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5825", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5825` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAYb0Zr6RSonUsY2u70PvyZzOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwYTU5NTI3LWI3MmMtNGE5Zi04YTUwLWVhNzZlMjFjNjBkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAwODhkY2YtN2Uy\nZC00MWFjLTk3YTgtMjQ5YzI2OTJjYTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpyEsUT0snze5WHpHpCM1vwqHRdGrHggMiUdVFeRww3Ys6tLCOo0/UXYZkUAh\nwZG6m18s1ebL4GlYdcs2ig2mwqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6kOFwsoSKJYp2sJP3AKeSTE+BicwHwYDVR0j\nBBgwFoAUdoWyyi69ZCbUezI6hwIn+Oh0Ga4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC3l6sstS/y0vFlElbBtN1cSGErlkXr5s+6Ral9\neR0+ngIhAPuzYMDAlRxSKAvcej+7ztlY+PtfAPP59D9hscxCUDKy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeYGtS9X6VjEhkN2Pv01ZA0BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGE1OTUyNy1iNzJjLTRhOWYtOGE1MC1lYTc2ZTIxYzYwZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6kwQxDFU8Wr7NvpBQOvPB+2hxibgG0/+xkvNfDTDqDc56\nZ6YHlSqDJnCNLA0UamBL+eLMaFBShTfunlgDVx+jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdoWyyi69ZCbUezI6hwIn+Oh0\nGa4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTNZumghst55mMEdlRGSqTtV4nX/KMO5McOuAezp6Fq8CIHjDSXyzQZ7D\n9chZ8CufgBAbKU6KPr/U/BqZAtzelgJG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYCph612B0GGnsqhuT9Vi2+rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAwODhkY2YtN2UyZC00MWFjLTk3YTgtMjQ5YzI2OTJjYTljMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDAxYzdjOWY5\nLTlhZjUtNDQ2Ny1iN2JkLWZmZDQ5NzRiYjY2YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDPFtl2l+2gMJVC4gbEEI7aEBAy3b/N7UwkymGs+9YqdmdR3aFFNMMnq\nkEHuKJuwCsHpnCmErcuUY++f+OHhC2+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOpDhcLK\nEiiWKdrCT9wCnkkxPgYnMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAy/pfBSERxBR5mvd7b/ChaEXnqQRTmljdML00\nyWeU1D4CIEy8EbLtwEpUPsPgDVb5M9CgupCfwJvpdF0S4T1an/Oo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5826", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5826` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAU7qh1BjfLToHDt69LYABQVhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NDhjZDY1LTA5NDQtNGM0Mi1hZjliLWI5NDc4YjNlNDY1MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIwNzlhYTktYzAz\nYy00NDkyLWJjZjgtOWIzNTk5NTU2OGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwIt7K1BlIJa7aN1t8NED5/zagXZz8CZ23pcReVVP4uSsfl3It1HmGOAGE/Tr\nO/gPzLZA2wcHs8kDAdqEMs7hiqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9VAjw+FAUaN2exaAqSpCGvLJmtUwHwYDVR0j\nBBgwFoAUSMHapkn6yMoIVgZ1rluywLnSM1MwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCTKrQeXMrZCaMCCtvqifzqsAlRnNgQq+W6svax\nD2BikAIhAJCjkqfBGYrJ5VGXYxstWavxGDnvRi0zccAwVpyNDzN6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdkWET55sNac4jVj62YmQL3jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDQ4Y2Q2NS0wOTQ0LTRjNDItYWY5Yi1iOTQ3OGIzZTQ2NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKwIAye72l5OF9skI5YLODe9h2vit6N+DVkDN4NSkeU6SP\n+ZMMM/dS0zzozUZAHOmgb0mt/rgS/X5aOUyN6lmAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSMHapkn6yMoIVgZ1rluywLnS\nM1MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNJtwHDywvSztYObxkpvL1yJLTff02/IxzGl9NNLzxaYCIQDvWNlxExUU\n1Js+vNYZNsW1jmTxPJU+aD3Rdc6P+GX/VA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAY14+NoCyxz3INl1sJ+Wev37MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIwNzlhYTktYzAzYy00NDkyLWJjZjgtOWIzNTk5NTU2OGUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGU1OTQ2ZTA2\nLWFkZTMtNGVmMi05YzRiLTVhZTk0MTBhMWJmODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMDPtG6skp5B+gWeec28GZ9umFNYZapOEdty2jjX2nmJky352PwUl/ta\nsanjRpA65rnTtSaG5dGMXoHdXO3gTTujeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPVQI8Ph\nQFGjdnsWgKkqQhryyZrVMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAyxJE8/4jSlc4gHm74MPbC3Wvmysozxt+Q14y\nwjAz0ZUCIHsIEMwRKE6ra9kYMqM9cGGViroLOE2TnvtQvfh4DGd8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5827", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5827` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISARUKHDOBviDPg5+yGwo8JSCZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxZTNmZDRhLWUwMTItNGE5OS05MGQxLWMyZTAwODNlZjBiMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJiMTFkZWQtMDM5\nYi00MDAzLWFhYzgtZTNkMTRmNzQ3ZDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETJfMzfAWIij8l/5ssLMoYalIbYKq2v+3TzfuNMqlacxyBkBHNhrQQq2nug6M\ngLTcqnXq0yW26fUL3jGqd0f0MaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhZqQ7nfVizAA8NRxFp9IxNY22f0wHwYDVR0j\nBBgwFoAUsckVvBln1tWqSb4YuN70nRJ6PMYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCT1RdY02WgOLZOcUQyurHbqxRyLnZccKexIdmyKp3FqQIg\nDozLWWS58HDkMXM94d19gpI6DYUPSaOt2213QO/30Mw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQM6zWffJWV+zgMFfWR7CJzOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMWUzZmQ0YS1lMDEyLTRhOTktOTBkMS1jMmUwMDgzZWYwYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQh/Lia60H4nm37ahwBlGqKyrcn3jJGRaZUxQdAnBdDrPAY\ntqRFzEgUkjkYCj60vJeGzqBp4uaMOdj/s7HJs3xLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsckVvBln1tWqSb4YuN70nRJ6\nPMYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPWaJ7EtTdWsNJzvRcASCmsjMYqJNbbQZY20mCpmCBK4CIFC4p47c85mB\ns2GinWGMdvZArBaOCKnYefOO5a+vJnX1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAXEPsDsvVMOIQclf6BBxNRauMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJiMTFkZWQtMDM5Yi00MDAzLWFhYzgtZTNkMTRmNzQ3ZDkwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDY3MGJmNWNh\nLThjZjQtNDk2Mi1hNTdiLTMzNTBhNjNlODdiNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCiuOlrGUr3a4I6Fy/H/KPtz+r+9WZSJ520+sPsXFIovTvnajqs1Dj2I\naqO+JLqgTPRt75NEshmQT5C0C0I0rNSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIWakO53\n1YswAPDUcRafSMTWNtn9MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBJuKsKiHEj6Mj/WFbcW2116j+GwGEWwwS+UHfJ\nCU8JewIgMprG0YVWDW39RDHQIy6b4GagcJMs9QCrJ7C8FZEloC8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5828", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5828` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZNMAcNzxdQRkaRpgcRKBypfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1OGU2NWI3LWFhMzQtNGJiOS05YWIxLTNmOTdlYWVjNDNmNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjljMGZhZWMtNDlk\nNC00ZjJlLWFmMzctNWZhZDk2ODY3OTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb2z4oKnkwtokvZAuMaOtSDSoBFF5hHRPkLKvAIUTx3LxdHGte7FN4XaXD6j7\nDBBu1Jwr4n/AmC+TrLQ4o22Aj6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgoNLALpV7VzHF8DbWTMbzDcS0RYwHwYDVR0j\nBBgwFoAUIgSNSVe4meyadVsNTpOyfdpRzuQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGnTGmWTt8FH+/fXyk3SJkXQJ/B7oIBJ\nMdG67AyLO97wAiEAzUDLxc3n97l6lLO7Kd6d4W5bc2fxtSdNNKBLttv6ovA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd1Zw4f8HXPuhWYBPwkfGMi5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNThlNjViNy1hYTM0LTRiYjktOWFiMS0zZjk3ZWFlYzQzZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASL3wPHlMbQxTDz9OJ38dTaKwl7BhufR2hH57rYpL023NJx\ndk6zYdpyCUOQtur4T8LiKavukoWD/cvVjNUFOGQGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIgSNSVe4meyadVsNTpOyfdpR\nzuQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPpAwHGaHhLe7BsKrzX5Ec81ZbmIw6Y3ktogdax5lyMaAiEAkkT2wcTG\nywWvpjyEwPGLPQ5w9d/t1gn0S+7Lope+HCY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcMzbC1HFeedQ5nYvMe3f0IeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjljMGZhZWMtNDlkNC00ZjJlLWFmMzctNWZhZDk2ODY3OTVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDhiMWZhMjUz\nLWRkNjgtNDQ5NS1iZDU3LTRmMmNkZmRjZjk5OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOrRy+Cwx1p3l5yVDCptCfxainPNmjG2ZBCxTELDfbVggAokty+halqE\n02QuC2OHjwPbhIyVwve1Ol5TRfLzEiCjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFIKDSwC6\nVe1cxxfA21kzG8w3EtEWMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBnydLTc9OzYG3FMTG4VZeI2HbsDJwOeJMWc9Cg\nYojRHQIhAJH0yEO0AWfxv297dSf4SUC3mjL6yfOGEBMVx+afMLWb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5829", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5829` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAb7+1uCPGZiFgC4++1ZqsM3YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkZjFjYzEyLTQwMzktNDFjNC1hOTQ4LWVlZjdiMTQ2ZThlZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTYyN2VhMTQtZDgw\nOS00MDM5LTg2NGEtZjdlOWVhNDMxZTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3Rpx1VxKgiy5Ps39ExBZEh3ugERjoJN7XlsSN+IB8BNiGzyDQYE2dA38zjg0\n9hcD7KtUX9WtQAe6RCvs9411BqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpbv11/EmeK3i9zH5HohHWcqbX+gwHwYDVR0j\nBBgwFoAUIkhXKBD/rc8tJ+3gC337CltK4iEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCHPfQOU8RaxhW8Y+VurXYHbfQilEYz\n+gRnjutlvaZFjAIhANO4wPtna/KdyoZX2NEULouXt7WTtMCetVNraAESRrUR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQp4fw3OUYH2ereJTLRU4qhTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGYxY2MxMi00MDM5LTQxYzQtYTk0OC1lZWY3YjE0NmU4ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5rZlnlqG4hKFrIeDHGbmqVvRlw6oIDqbdUoolEsy/oeGq\nmfDgbObbJUSEWJNVx7mOi+gvoWzyTLXFRzbk1ERyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIkhXKBD/rc8tJ+3gC337CltK\n4iEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV0IlRh4SlAPNGemHTF0AVfaoJJI29Foy6KzL3Y/t6IgCIQDaCv5wDerg\ngXh2CW1nUY6ybpAS+FlqrJa3eK/qHj1I6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAfPHQrVZpkqdNIb+aRKFPaUOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTYyN2VhMTQtZDgwOS00MDM5LTg2NGEtZjdlOWVhNDMxZTU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDEwZjU2YzIz\nLWM3MDYtNDNjYi05MGI0LWQxMjQ4YjNmNzE0MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFIOFCwFURH+wtyxrj/FMUT5UKBPDPvPdaFFmfQMLsfVmNPY+F+EqPeE\nOMT8mNA615MtJLcT8QPQ2eytyXRdACejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKW79dfx\nJnit4vcx+R6IR1nKm1/oMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAv/KezFMXJdim1+CoeL/uPna8sUWIUXZsStk2\nguZ/qkMCIQCV679OD0h5ENH30auqqP0GSrrXpAoptMGM/blFggyd4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5830", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5830` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAS/oPmRjWpNXOkW+yHrNgHy2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1MTVmOWNmLTVhM2EtNGMxYS1iOGY0LTljYjBlYTBlZDkzYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjkzMTNlZTItOTY2\nYy00YmNjLWE1OTctODQ0MDM3MDAyZWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcv1flJxSw0nQPvhLxrJlwW84ZjRlYN1mucL/Qd1z43pBYCVW0A4CinE22NaG\niSsZ1yn6OUxsbKK5wdOfa72KFqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7sogRG52/ejpz4t5fPIesAgwpQ0wHwYDVR0j\nBBgwFoAU9Y8OXLWoQcsJ6FtdFvij+NOymqkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGsqICQG6T5q\n6uYoj1XTZdxE7Zzzkl1JnaY/UJWgZMyEAiEArHZuxemkNjlD9UVZysMysAL9vuQ1\nlRQL6q+h5LW5MGA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZAINqE5xNR3hS1kNK0WAjN5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTE1ZjljZi01YTNhLTRjMWEtYjhmNC05Y2IwZWEwZWQ5M2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvN+2vVT7AI1rDovgAnU13XMwGKKyd+rarbCD9jHm3Y93y\nYzEtyxq1BVPBSb8J9JQvQBoqwMqS/vrVH3SKkQIZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Y8OXLWoQcsJ6FtdFvij+NOy\nmqkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBIumc9BhX9onxktLi/nhWS9io2qZ/aOrv4DWaiYkRLUCIC0zD7wUhoHE\nLhEgo5DamQrrqNnepncHvwGvBzUFKyFi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISASl86/EoJfVAVqHfvBK969ItMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjkzMTNlZTItOTY2Yy00YmNjLWE1OTctODQ0MDM3MDAyZWQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDM3MTc4NWUw\nLTdiMTktNDg0MC1hMGM2LTljZDBmZWEzOTMzZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBbE2z2ezz/N9oHuXYYHPd3+H60BW/za+WnH1xQovbGF1EXMjD9wH7kS\nqIUsRW3gqoqtr7qxVv+paEShQhbblmmjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFO7KIERu\ndv3o6c+LeXzyHrAIMKUNMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAoJFQ1Kc9jmZyKTLIssH7uM9BbsVh3Jg+VACQ\np1JqRacCIQC1qCN6MvSMv1DHm0tsBgBQcuIGoSlE3fuDovERqEa6nA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5831", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5831` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAbYP1OGyUXEV5qT4NOCBw81FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNTMxY2E2LTY2MmYtNDEzOC04YjZkLWNjNzA0MzBiMGM5OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA3NTZkYzMtNWVj\nOS00NWMwLWIxM2YtNzlmZDQ2OWNlZWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL5mb6e9yZp7IhGgMYRg5URL21gS0ZLUHXLLg0fAFneTThJ7IQJXHUDIG3AGB\nbK2ZYHnINkElUrGQh9AZU2V196OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrK4M8quGAYeUfVc63OFdZbAwEkswHwYDVR0j\nBBgwFoAUDl7ep1KRO4pHOlLBwNaA5rAPnxswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgCi31x5FRw65UyPxYBPfHNrDyJ4QYCD8W9XTEWtp7IVUCICQ4GESBgSU2\nP1kszkzQPCi6TsYcl/vKVhZ3y/3kiKcs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARmo8Z3sCUvQ/ukKkz/I1tCuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTUzMWNhNi02NjJmLTQxMzgtOGI2ZC1jYzcwNDMwYjBjOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASglU24wc9WsT26OkY0aq+ix98xK3NNzL+wGuKTlwcpGPgj\nXR1GuWDP61Ggaq6GVKZll5Si3XYicwxQoh4I67J/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDl7ep1KRO4pHOlLBwNaA5rAP\nnxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZmZWWo5FHI9VzRYhy2vn6t2Wxw3CQYUcuxz8B8uZIQICIFEOzgJcxOAH\n+CSDRV3k5x8a2KTa0I6pIb0IrFq2v0BO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAY3pEJ/StM4iPBWtn+1A+xa0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA3NTZkYzMtNWVjOS00NWMwLWIxM2YtNzlmZDQ2OWNlZWM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDk4ZjliMzMw\nLWQ4ZmQtNGZhYS05M2IyLTM1OTA4MGM5ZWY2MjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC3JZT8UAacnaftud67/XVo8yKea86NYsTq9zUkATcO70YJ82EP5hJOd\nlobOnXWVz1WVAIkj2eyyQX05Jd0tjGSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKyuDPKr\nhgGHlH1XOtzhXWWwMBJLMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA+4XuCgP8ChinmtegnFDST2bhgzHFPlLnbkrZ\nXxjUcYkCIQDZSyHQlCcgcbdLYeMfgjvYEWOUGZnmne2ey0ONMAC29Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5832", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5832` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAYvNUiskkI/EnGQ1Mw9X8QLgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhYjhhNzA3LWU1NjctNDQ4NS05NGNlLWFkNzA5Mjk4MzU0NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTliYjhhZWEtYmUw\nOS00YWIyLTkzNDUtNjM4ZjkzNDI4MzMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYseuFe3i+Ur3OQiKoYhlQhdxUg/PcGWZGOoyGolfOFP3Rqrhm804+BL5wWe4\nNY69NufD5R7MFVC/GtFKyX04PKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXegfEYgDme+75zusi49J/42YR0AwHwYDVR0j\nBBgwFoAUfiB9oOaNgzT1JuhKR/A0VWTuYmEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJuEpZvPWt91Z/7g/jKYmHS9eAO68NqoYpKV/PQniirXAiAMkmCEJpzK\nnP9h3rqGNwVnKWaE+9KDSmhHzQ7g3+w68g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW+mfoPLrdqeJ4tKZ/pHFeQSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWI4YTcwNy1lNTY3LTQ0ODUtOTRjZS1hZDcwOTI5ODM1NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOxvpRrEt+WyMRnwEkVYzlgG2l84hP2rozx5T//2bmbGd4\nwCYCus5gO4MNSnJ8g51sUyKXmqk+R7j9u6KvZyJyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfiB9oOaNgzT1JuhKR/A0VWTu\nYmEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ53XIOTpvbs1QKS2juwQ4yI9oUVrEd8HegYJ6ZXFjz0CIBeRO0p2tKKO\ncKyoh5tQXNwoId4HMOI6zC/gfu2nl4wX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWUa5GudogBZXN5appu5MXUDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTliYjhhZWEtYmUwOS00YWIyLTkzNDUtNjM4ZjkzNDI4MzMzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGFlMmRlZTJk\nLWVkYjYtNDNhOS05NGI4LWI0Yzg4MDIwNDVmOTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMCEHASNbBxnsPFADYljePYBu93pQDi8r4RACAeT1StZbQiqeII+8RsE\n8JA1aMP5wRL80LgYAQ5vsIVmSCwuvA+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF3oHxGI\nA5nvu+c7rIuPSf+NmEdAMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAwBwOjnSAcYWbBE20K0kQpoPQUTvo5fj+z0zon\nym/kegIhAIOF/wGJYDT2m9An51CV0JfEmWiQu8Bj0GR9ezS7lQsl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5833", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5833` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAd/qlDOAq8duNiBUaGmKfIP0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxZDBiMGM1LWY3MGUtNGI0My1hMTY1LWY3ZDg1MmYwZTE5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIyZThmYzQtMjQ2\nMS00ODJmLWFkMDEtYzJiMDU0MTg3YjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjDtiGblXuD5QZ7ytQh/KkoVn8M4hVSAQE8IcaupnMsr+kU3iFzp4/U9HbeVi\n+fMU+w0zXO0NkwtQCm4SbMeuLaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJZ5L73vPvYGIAw8gfPMUtvUMqFEwHwYDVR0j\nBBgwFoAUKycMytp0pC0B9LdmFrBYfI5jG7AwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIFYs2GYe5URz1Tr8sb0XT47UPgzzNDrCzgcAnJT2EDicAiEA4pFXPBHZ\njYkq78h9CJDVTxT1g3GHCSYfngxT9oMLTuA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUZjVeix0fpwDGAL05Mq8pEwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWQwYjBjNS1mNzBlLTRiNDMtYTE2NS1mN2Q4NTJmMGUxOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTkXOypHpEXtjhzw/V2jcQgmFNWF4RdCO6nrTZnIGi0WGg\n/TxIm0ispwyucm2ZYPbwFRT62Nc4BPgbIkNhT57Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKycMytp0pC0B9LdmFrBYfI5j\nG7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIbcFU+lsMl5o7o0ZG/JmA6SL+L7XAy1MX73jVtVkwYACICCTwWSGPnnS\nb3mjip91wYD5HKbxkQyqCOBv6pjFcO/a\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAa3tlKaq6M7iw1HHMSw4kRl7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIyZThmYzQtMjQ2MS00ODJmLWFkMDEtYzJiMDU0MTg3YjE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDQ5ZDVhNDRh\nLWRmYWMtNDdlMC04NDhhLWE1MTRjOTM5M2QyZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABL3zdj59FbRvNnYJi7axpXXChVmxmDLbpkxodpydDJRSZPk+xu2M/WmK\nO4Q1nAwaeUxXEF8Wd4kE6pcMRCRRO+ejeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCWeS+97\nz72BiAMPIHzzFLb1DKhRMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAt7JLzS6uJCeOMWfl11JTo/RR51GfDQe8nC9wS\nPs3WigIgY+s0TAgVRhkND0tUDvHt2EOf6i+0/QVjPq8KkNJawB0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5834", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5834` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAaMPpIE6MZbgKVYW7Yw1GDN/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMzcyZWZkLWYxMjQtNDU0My1iYTE1LTgxZTRkMDFlN2Q4YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjIzMzZkMjYtMzY5\nNC00OWIzLTllMzctMmZiMmNmZDJmYjhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKbrmpuo7R33pxRMno/HOVeIjwdopMp1m55dZoC3dZKyZldKarCy09F9t+bHC\nTT6RG/PdpZ0gLEnb54wIIkJ0LaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUwqYy3EXSqKcLO0yB/fJDyfjf74wHwYDVR0j\nBBgwFoAUiUQJhWKlvXSgg5gwErP2UBJZnFMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIDjb+b5XREO4Wmqzq0W/9w1Oq3nOxvJQNAllSLyY\nJfoLAiBEw6hL6CVuLL7MY2Ox1X1azNMOk7Cv3L+Rlm7tFh9sfw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAabLN63xAyebbVbLizlvmXp8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTM3MmVmZC1mMTI0LTQ1NDMtYmExNS04MWU0ZDAxZTdkOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9YXGaulxd3VXkq6tMTiCGPPhDamE+VeMdE9ryw49OgWcD\nUWhb4hDcqTN+Eo9CeQpUaEgbdsuqToeGwgsESKmAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiUQJhWKlvXSgg5gwErP2UBJZ\nnFMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLdyxtA6OmyEjQ+KdE72/23jsctYF0uwrq1FoaIA1x+4CIQCS8dmaIUjV\noNjV1hbWLgKObV/WEAgMw6jB6FLNFic5Hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAT9tZ7HVzJeYRS0JauS7hGJ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjIzMzZkMjYtMzY5NC00OWIzLTllMzctMmZiMmNmZDJmYjhkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDZkY2FiNmFm\nLTUyMmYtNDE1Yi1iNmQxLWZhODRlZTYyYTk2ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABHC7auEf71atMQ8qyoTRe7mdfKVbpIJDOJzuRs0Wzua9t04kEMuqTPaa\nFr1/TiTcWCITqbUzdFL1PQll3dC4MX+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFMKmMtx\nF0qinCztMgf3yQ8n43++MCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBPUYD8Ws4dKrIRj/J/vbcc/WZIDfvEHnT7F44L\nAHFC4gIgfUYnr5uYtiLM7atmW+N0elK4hu0gWA0UXstE2/MQP/c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5835", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5835` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUDx2DL/4t7c9vkLA2ZmHfQRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkZDE1ODNkLWRkZmEtNDJiZS04NGI2LTdlMDc4NzBlNWFhMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU2YjA4ZTQtYmZi\nMS00YmE5LTliZDctOTBkZTM2MTg5ZmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0iVBxD12zHAGvIBN/VHVO4/C9pvDe88XnURI16LZxMJn3oYDvLAHE6WDs00a\nCu2Rbbah63HewrDDqOfvUAJWZ6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZjhadRnUbu5fcR+LbJQES2tsme0wHwYDVR0j\nBBgwFoAUFyiEXqvVinH77cf8uH/DtGce7b4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDLPnzkzVV32O6YK/Szws5v1hujUv/r7ivh3rCC\nazSF6QIgJBEh8PiZr1DLjFRkilKdQmV0tFjH+12PRiFX7JI3wDk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATXIhkON6IoOEEGYosEzyAMsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGQxNTgzZC1kZGZhLTQyYmUtODRiNi03ZTA3ODcwZTVhYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNBynNMBDQh2txYqEc9jbRjD0tvBOKHIEJ1JLa8K9b5BpK\nMC97B/2sfDwQkI+V9lg1rJwRuNe1p9fyeoLgvdCZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFyiEXqvVinH77cf8uH/DtGce\n7b4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIpGD91cu60apqxLWUATUf2AFTW0UE6M7GknAH+K2VxdAiB7n50pYsQ9\n4WIkLictPxWQqsbV7XEtGzmJQJ7wyUWT+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbel9SZtvbBDsy6sITi6fXAXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU2YjA4ZTQtYmZiMS00YmE5LTliZDctOTBkZTM2MTg5ZmY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDUzZDIxNGJj\nLWQ4MWUtNGI1My1hZThlLWYzYjNjMjU1NmZkYzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABG+Hv4Ikb5tQOXQ5B3KJjCXpzHRGQbPLkZVObB8pc2B3aT/hStGSItC9\n+g4f7UccrGulRUhZDWk2E/eCZ9vaLoqjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGY4WnUZ\n1G7uX3Efi2yUBEtrbJntMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBaceeNl6IPwg7DLEVtuoghAD0+nH/U+yAvHiuS\nYxeCXAIgL1mM7puI4MMZcYZq5mims/EX9E9yVz7GJMIcCytfXfk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5836", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5836` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAWSA0KC8LnOY4JfU4ozTd3sfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3YmQyZWE2LThhMDItNDFkYS04M2E3LTU1YzZlNmI0NzkzNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTlhOWY5NjMtNDdh\nMi00NjFmLWI0N2YtZjRjMGE2Y2UxMjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1/AfSiGwv7L5cfhvGcrQjNaBDBH9XI1pjB9Xm246l13cz2qd91YeQjapV/kH\nM7YwYsVTwDVKGLYROkq6lHULa6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfDQJCybRkjbXFnipokr8H38qvxQwHwYDVR0j\nBBgwFoAUaZeLbISqRwYx5wc2NZ/tY988rMwwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCtgzyamoH/OTlZuGQXNMGlaaQD5ZTtPaf3JcwJS0EPoAIg\nelzOTKL9tWva+LDzBr78R9huEjPBa5pMVusBGYhYl5s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVAC39zOM+6DBYKWIUMdfhrbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2JkMmVhNi04YTAyLTQxZGEtODNhNy01NWM2ZTZiNDc5MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATM1eLK5nCbrMZouocytMPZugDgNXy4Yi2pad2X2jgmJM+R\nyds2oe9ngp2YkWt27OFoBx2DtyhPN6a+GhhbJeLko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaZeLbISqRwYx5wc2NZ/tY988\nrMwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOpGM/jZ/nmUG9xKAeNSYclfin3YdcNPVYP3d5268IbKAiEAqC+kEyiZ\nV0Tbaf61fbalFBQr6ZHZrpRrX7S1hB5oW14=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZcZvZgKdWhDIiS5cgfqpsHBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTlhOWY5NjMtNDdhMi00NjFmLWI0N2YtZjRjMGE2Y2UxMjQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJDRhMmIwY2Q3\nLTQxMDYtNDIyYi04ZGNhLTU1MGFiMWRmODY1YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNjrBlILsKLBiGhc71w25kFCn83gz7O0W96HEfYB/Jtw+oZ4ZIo3AdZZ\niLVobmg4bJMvIhSb/ntnAkGwPQaKF1+jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHw0CQsm\n0ZI21xZ4qaJK/B9/Kr8UMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBnG3Wz1l9ZLtCCVY5aMMlW7s6AOiXWdYI/97F2\nEd7a5AIhANGlWlbkNMTM4zyr9Gz8NSEXTAaRSjF0EsJ3R0l83MDM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5837", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5837` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAR9OzomSym5H4EXqFn5dznCfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ODQ3ZDRkLTk0MzEtNDM2Zi04N2UxLWMxOTFiNjRhMmNkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2MxMjA5YmItOThl\nYy00ZTQwLTliMWEtNzA1Nzc2ZDY0NTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3+sBuaHKd0vWHn5WgHCiLWDID99kw0IOpT3+/YZkf2EDYVBNsakuagjxd/R7\nD8y/DYCV9VyYM6xOtfF4I4wRh6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFwYtvB7mOK2LDmVtG7LlmrIq53EwHwYDVR0j\nBBgwFoAUH/rhqXgH4vWvoGpt/3ZARKqkLqQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCYcr2RIYENxyjM/d497HbFk+uN748+\nrTyjxqsLR+pBpgIgAbMC7ezXDUbdQ03ExpPMZUp7hyhIaWdnnvjBJqbZMJY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR+XlROxv0ur5j3M560+r6wNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzg0N2Q0ZC05NDMxLTQzNmYtODdlMS1jMTkxYjY0YTJjZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHtC/UsIYviiF4zAWqutfvm9Ds6aXwHO2efCY9vs/4phzm\n0j3O27VEqqUxxzeOXq8aQuqLHLbpvNZANQPbEC/io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH/rhqXgH4vWvoGpt/3ZARKqk\nLqQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY0k1yAQQejiy8WoAyqwVduA5cxm2tyQ83oU7GgNbBD8CIFXt/W7o9X6Z\nSDeXVwEdiCXd7/B2EWbz0L+La2dyDYb2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAaHEsLksumIIRz0mHyRl958IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2MxMjA5YmItOThlYy00ZTQwLTliMWEtNzA1Nzc2ZDY0NTFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGJmNGMxMjlk\nLWU2ZTEtNDFhYi04OWVhLWM2OThjYWJkNDM4YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABLSKJV+M/jttf70EjFknsX8iYl0PVjGzsZZn8vcSAphIbIzDjayhaCnk\n8HGxKl+1v83WYYaT6vGqhE2uFhSoXdSjeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBcGLbwe\n5jitiw5lbRuy5ZqyKudxMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAzPuxdDmUjf6bRQAIzdajwnwItlIodO3dI0d9\nPJYAfW0CIQCj1/OSHM9/NnJWNZk21KIJeotJGHdKajlcGcvMr0eo8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5838", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5838` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVNr+XlN+iCinepwxE6A3u5KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2MWM0YWM4LWRmYmQtNGFjZi1iZjFhLWE4ODIyYzY4NTRkODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTcwNDhhYmQtYTFh\nYS00NzM0LThiMDYtMjM0ZDMzNDE4NGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1EQNIfFit855UdZPMMjHx/c+jDKOvPaGkYf/EMj0FnriInK1m++1CDSmjCsT\nIGmI63TI2f1hxeacTHK2ynD9GqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaEjM1hr3GwiX2MFLYRSIbJY1LW4wHwYDVR0j\nBBgwFoAUNnmbeBjbz9S9ZxdcHKM99p56fWgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHYu9t3BSHOfqvqdMG+88sZp9HYnMz8Q\nDS4M9IkK1Eq0AiEA9fv/B6QLiio1KGLj6qpo5fYwf0+rPaJzXSJeDGRNfeM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcnBONuvrvs0g530O3tgXw8gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjFjNGFjOC1kZmJkLTRhY2YtYmYxYS1hODgyMmM2ODU0ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATD6GeVV7k4gCULvKZhR2drBCX5rb8GmIvdfVUdpICTa3DE\ncxL2lX7Jk/q/Ex2O+grKZA3TF6+YhsCD5m213bszo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNnmbeBjbz9S9ZxdcHKM99p56\nfWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbh0o5fi3r8A7chCKnUrYUVtmUAcGnyjFIgqpwdsJaEgCIQCS8JMrogW5\nbYjsiidfs6fTk0kOOwy1Y4b5WCHnsdpvFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATJahPn8T3OZRi8ArA6Yh5B/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTcwNDhhYmQtYTFhYS00NzM0LThiMDYtMjM0ZDMzNDE4NGI1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYDEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEXMBUGA1UEAxMOdGVzdC5sb2NhbGhvc3QxLTArBgNVBAUTJGI5OWM1N2Fi\nLTg3YmMtNGJkNS04Y2FlLTg5N2Y2OGY1ZDc2OTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKDpMXEIKcGQ1RvB4y4kq2QLQjDnlGj3hXkndsiXuLhPi4OMgMw7Uf1o\nDgrd9anlrsWMc2p2YOgtTSGGGd+9qu2jeDB2MA4GA1UdDwEB/wQEAwIHgDATBgNV\nHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGhIzNYa\n9xsIl9jBS2EUiGyWNS1uMCAGA1UdEQQZMBeCD2JhZC5leGFtcGxlLmNvbYcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiA4QCp9IxA4V+c/4Gn3RzGNNUW3Y05ObH1d/IgP\niINN5gIhANxyGZtmcuke+/HZDAGVfiTVGb8f3aRRlEwSZhy99/5E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5839", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5839` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfmbzSLZ6CH/z11UWtJ2FMOmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxZmFmNzVjLTk2YTMtNGI3YS1hNjBmLWE2YTExYmJiOTQyNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJhZWE5NDMtMWQ4\nMC00ZmU1LWEzOTMtNDFiMTUxMjI3OWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ1HIrr5WEocaf7wF17DbgpW8AhR8KCk9NGQg9BUiV4F2OG035Use9uoIu0WJ\nVd0jTo0QRTct7kgZ4+aoEsJPqqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCb5vneRGKoa9EPBBARudvAIKc5KMB8GA1UdIwQY\nMBaAFFaELTIO91TctuQSOFqQukxy611MMAoGCCqGSM49BAMCA0gAMEUCIESotsZi\ncg8TlmMhE1PYHe92ao9aJLKfckmg+/8+qc56AiEAkAsYBiT+8yNTASUFFMwbBTQd\n5yl5KSBn0fLodG2zLcI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY4mtMbxOXGwRTBFHLFrlx0hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWZhZjc1Yy05NmEzLTRiN2EtYTYwZi1hNmExMWJiYjk0MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRzXMog/bbNZG5R4sbyE4rkhzfjlv7MxI52ZLd4DxmxM2Z\n4RYd+UnwD9d9w1u7gcbywdCgIG9tJ8jL0+enIRk7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVoQtMg73VNy25BI4WpC6THLr\nXUwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALZFescs4+rnNhElrAB8lmw4GVpGoYVhOwXs6C9KziccAiAmuOjSF2VC\nnb4xcAJyAJExXjtS/bjBXUDYasl22zrNCg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAWXc3IXV7n4TCwxYk0U/wBtyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJhZWE5NDMtMWQ4MC00ZmU1LWEzOTMtNDFiMTUxMjI3OWE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MGYzYmI2\nMy03MWE2LTQ0MjYtOWVhNC1lNWYyMWFiNDBkZTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQOa0p0mhDjMOmTK6YyRiJ9zM0kU/GygRviO310EEhB+y/3YachCPMx\nov0PiuC4j0Cmxh2JTZr4XNtEIdGlW9Bwo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQm+b53\nkRiqGvRDwQQEbnbwCCnOSjAKBggqhkjOPQQDAgNIADBFAiEApmC49ZaFk/Tpa2yC\nVtqGKa3ixflbDef4TgnwBC4hna8CIGaBCnQXGVwUOk3bpis2gWnGpVYUe2Rr32ZK\nMR8YwcPc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5840", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5840` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbHNvFRMT+7xtpKtmyqP3D3yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwZTBiYjNmLThlNTEtNGM3YS1iYzYzLTE4MDNmYTcwZDllZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRhOTQ3ZjktZTg2\nOC00NTkxLThmOTctMmQ4MjgyOGE5NGMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/m9GNuuoXIOTafLGeJWFBvvVV8cwxicKRcn2a4n1CrPmdTSbw4+vJHTIfiTx\nHe9nZ+SOfrefNpKecLeZvJEDDaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDOdZN2dkMpdjnjgzDqRRvVWdx4ZMB8GA1UdIwQY\nMBaAFIVCdSwyp98QovHgA//jfD9UoZzCMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAj5R6LN0LrCrnXINo4wGjnkkKo1HMQMS3K\nR2IoFN90cwIhAMIFUD7Kqy/7kmK2EKhAjTLv7KihgjZZ6/JNR49JGW80\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUFSublSjxkShD/3yKp3k+5HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGUwYmIzZi04ZTUxLTRjN2EtYmM2My0xODAzZmE3MGQ5ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARa88rE6qN6sTDV2+DXFNCTPTtAxLBrobK5o9q4MQeFkEA0\nz44e9WXvuo2UUdSqjFtkr3mQRo/hbQdnlJoZczKmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhUJ1LDKn3xCi8eAD/+N8P1Sh\nnMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMOLKWDdlmv5dCIDksnuexGClnUorFdsC+I6eVbQsmEzAiEArVu92vt6\ncbAgch+yWrMSveGKxqRiaPj3nWw6iMZ9V/w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAYjj3WNxUfD2kiX6nlxf9qYzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRhOTQ3ZjktZTg2OC00NTkxLThmOTctMmQ4MjgyOGE5NGMyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YjViZjAz\nOC00MzQ3LTRmZGMtYmFkNC0yNjJlZGE0YTU3NWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ5hkRkNQFMjMBtUICHUmKaFwVKXtrUVIHJ5ylGnAQtFWjg9Jj9lCRj\npDuU/OOtc9EhX1qyt32/PlBwKT47z5C1o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQznWTd\nnZDKXY544Mw6kUb1VnceGTAKBggqhkjOPQQDAgNJADBGAiEAhtf+bpzjd5KV6MbH\n5LAfSPHFE7SDuediNgj6CHZ8BDUCIQC5Wk5OM5AbOE0kiWmKaj2ABolG/ze6Yl/R\nVQGCGraJ2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5841", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5841` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXu/35DAgjLOm+ohXHjXI0UvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxNGEyYWYwLWZiZTgtNDE0MC05ZDgzLTA2OTFhZTg1NGU5NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM4YjY2MzYtNmM3\nMy00YTk4LTg2YmItMDQ0MDYwNzY1MDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpdIFopXo7SHNWfXSuD2fq1WFsDDpNQQxGp+TZKwES4xTHlPnV3hqxWBHLzHa\nE4I7XiS7uNq55sbVfHg0DO7+V6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJ6d+ZrSsB3acXpYApSDYBOq+NLeMB8GA1UdIwQY\nMBaAFOM/fb+vomvjGbAwZl9JkAZmVWc0MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAvsfDGLjK/oH8FtCyhQGBEEjHcihhq6S8\n9mNgDZAAEU4CIGCSZrl5nAqO3aDYZk/AogdWjKbT+HZooBrqWBUYhSYF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASZYW5fPN7LoF2vxaXxBsqnZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTRhMmFmMC1mYmU4LTQxNDAtOWQ4My0wNjkxYWU4NTRlOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcqNAfq69PL1FkyTB8ArDmstD4L/X/wQxEaPqsVL04rY+A\nifRB4PlUa1H8gJESDuG3qwUik1K/phMnz5VmYSmGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4z99v6+ia+MZsDBmX0mQBmZV\nZzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcFEcDNhbvBi6+KS07XChrM+c14Ms2sSzh7aTU2aAmwYCIQDaU4I+gWSo\nfvNIH8bszdmd+VwfYSbC6lLc2GfAXRaxMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAeueEaQVbML0Jtbiu3F5gC1QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM4YjY2MzYtNmM3My00YTk4LTg2YmItMDQ0MDYwNzY1MDk4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZmFjMzhm\nMC0yMDViLTRlMTItOTBmMC03NmZhNmUyYmQ1Y2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQdJXCY6j7TsauiyGg+4FXECUu1Bj/xtJ/Fy3UEtqXrNhIQ7AVfb7qm\n89PMtPWWGOOtrRc8b4amjBnrftKTrwXVo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSenfma\n0rAd2nF6WAKUg2ATqvjS3jAKBggqhkjOPQQDAgNIADBFAiEAmRb7PzU0G+A4RUN6\nyv4NKY3BbKXGHudGk/tldzt8PoECICwALASZY8c26gPaM1mGk1VX9dOPewu2HCCh\n6FFqN79+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5842", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5842` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAfHxNOlP8wdB9VbiGzJ0XBl+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhZjVmNmY2LWYzNDItNDU0YS1hYzYwLTU3NWY1NTZkMjFkYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTczMjliNmEtYzUw\nMS00NTJjLWJiZGQtMDI5OGRhN2I5OGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED1SnqR1sqPqxzK1Mfu4eOzhol5Ii8I/ff9DejpK0zMwIGjAT85Z2R9XhqkmX\ni+x7h2sizwvAiuBUf7jg1e5FP6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTZDYFP8WwdeqqW18BAXOnqaqidNTAfBgNVHSME\nGDAWgBRCX23AXtsd9QWZx4YAlVNnuOOKDDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQChh4PZJ0qQavzUvH40Deyu7GNAg8tf\ncJ+la/N9M/Ri5QIgQLOoePRKU0bWrESD0T+uXIfV/MM/jKIeVXM7V+s7iho=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS1hmA2LHcsZ4/rgT/XZE2piMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWY1ZjZmNi1mMzQyLTQ1NGEtYWM2MC01NzVmNTU2ZDIxZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgD97gKM/Zt/v7ZedDqp772jq9J7xZ+Xrc/XP+4qWSX7zc\nMgbLbG+WxzgQD1mvHC/DWLdPfIkzkMoxqTYYiLQgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQl9twF7bHfUFmceGAJVTZ7jj\nigwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbXSEeWv/WZbMCD7qQWbK2hTHM3yeLFoMb0Ueh4EVsOUCIB+E84SoYV6S\nkEEAl/7DG7jemRoqAtgRb6MNzMF0MtP4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAfvhK54zSpK7xTNWabSeNg/8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTczMjliNmEtYzUwMS00NTJjLWJiZGQtMDI5OGRhN2I5OGM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMjA5MGFm\nOS03MmVjLTRiMzMtYmQyZS00ZmNiMjgwN2I1NDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQO36tC6zVeHhjYYYwpxLr+gy3pBi9XdDbMSwL+hhuThnMv23Qs4/fT\ndkE3MWxRn1v7FuJRPcQwBa4GHop/Z8lgo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTZDYFP\n8WwdeqqW18BAXOnqaqidNTAKBggqhkjOPQQDAgNIADBFAiEA1tPvLYju1qhhf9i5\noe1Rw1feQ5Dc0PKCpoEJAokXD1UCIDp6zDmCJPVQ0XtoOLU3u97J6eN3riYfsVrs\nh8lVeogi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5843", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5843` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWIxW1nPHCpkFiS3jvZvR9ncMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0ZTg0YWFkLWM1YjYtNDI3Yi1hMDQ0LTIzMDdmNDIzYjY1ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZiODcwY2QtMmRl\nMS00Y2QzLTgwZDAtOTRmNzgyZGY3ZDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUf4OlEl+Konu+e1a3FcD/g8lEXFReyQfNj8haTCeeiNNhE95ZMiHwBgGaWl6\n2hvzipr63RtzULXgYqdXFAM0qaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjtvL/uHKxy0R6D5XJu/kx6EL42YwHwYDVR0j\nBBgwFoAUfFiP87Nd/90vbpPQYCAcRmCdCZIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiADI3QHNOauNhFU\nKbTl7ZTuJ5JJsnNaUbpa/4VicwJhhwIhANytV1ZlYGSg/B1uh1eWMYVnxcTKl9I7\nSjWo00jqXGg8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS+6GK8EsAPVn3y6hek4G+75MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGU4NGFhZC1jNWI2LTQyN2ItYTA0NC0yMzA3ZjQyM2I2NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATM3bAYYybOXQHWfpXweMWfYZbpdoStcKKWsv1EDcI7r4XZ\ncFSTEiv9FkqX5W0nbXGsYISajI8cBALh+HFDj/i3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfFiP87Nd/90vbpPQYCAcRmCd\nCZIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIGlR0/Zhmn8NWpLZ1tnaCUrh4/YoUxAfXpZrw2EF1YqAiEAgidEv8BL\nSplrPsPVdkwZn3kz24WuqxkJQarbtUvSzCk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISASNi5aw0O34qCT0+ZTMvH2uOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZiODcwY2QtMmRlMS00Y2QzLTgwZDAtOTRmNzgyZGY3ZDc3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZGQ1MjEw\nZi1hMGQ4LTRkNjMtOGE4YS02NWNiYTM2MjJmMjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARkWu0M7uji8gcZeRblYin7JFmGJhx4TnOTdiZJjWsBIBDdQHQcPkkk\n1JoE3sKNQwZyjdUN/K7cAGh5x5/mVo74o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSO28v+\n4crHLRHoPlcm7+THoQvjZjAKBggqhkjOPQQDAgNHADBEAiAyaiC4HDVJwf4vpLVz\nnxh170gey0jTEB81SMmik/D2EgIgeeMPRS3UT7l0gdutpscu4uwVUvWYyi02mU5y\nNiPLcXI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5844", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5844` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAcnvCAPZAKlNPEmy5gtiGigfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkNTZmZTVhLWMzZmYtNDU3OS1iODA0LTM1ZTdlYzE3Yjc3YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFiNmEwNzUtNDYw\nZC00OWU2LWFjZWItMzMxMzMxZWUyM2I2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa+NHN+HdpaRxB/VED7hr6lwlmOUdyKsDXu1y0d4lmGWaPjrDayATmDy/5Ig6\nkiALm1/PI1fbM7Vy7AnmbtFKkqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUIUPoQ/OZuvpWGr+fsNd1paftM8wHwYDVR0j\nBBgwFoAU6eBdzuMppCCKfOzIr8n6R6Zl9yMwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAZezsi89Z0kJJX\nLfNPn3TMQeTETznDxhau+zS8lnMdJAIhAKzp2B16GxONC/52obFzgOjfD/zlZxuk\nsIdm4ki2WBYP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa8568MdkPSDUNdHW9hQx8gAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDU2ZmU1YS1jM2ZmLTQ1NzktYjgwNC0zNWU3ZWMxN2I3N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASijwVxM6v7eJuTsDlk6ayfYR02FoCwj9LVtqVW7R86xifR\n991+9eDz7GnIRHr482RFNjmxCvjVbN7OX83qyaUCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6eBdzuMppCCKfOzIr8n6R6Zl\n9yMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZC7FOSwulfZR+GN8+qvBVKueI49hWOtWseRWdz0lLRQCIGb1hFWU81T4\nh74YfP4BH/bpu5FVTYZ3N461qVgINQ7Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAW2dQ5wVZvF4/x0oLWsoRYw9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFiNmEwNzUtNDYwZC00OWU2LWFjZWItMzMxMzMxZWUyM2I2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNjNhOGQ5\nZC1kNTAyLTQxYWUtOWVkYS0yZmM4NDAxYTU5NDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASIO5m4WjIYyGh+7ToWaqjneRq51KlCTBXoPr8iwjHStQcWihw/AgUg\nZqJLyPI12JjZeSHLVxsjW5EP/FoHR0CWo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQhQ+h\nD85m6+lYav5+w13Wlp+0zzAKBggqhkjOPQQDAgNJADBGAiEAl/RUcrEti+NUdSVH\noMze8ySA+ND9imsuixjtbNPJ3McCIQCxAx68MPlqysp2GjahkwIRwUbWt2r1tU04\nKaTFrrzzpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5845", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5845` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAdFqt2DQXBA3uot87VurrVlkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyNmE2Zjg2LTBlNTUtNGY3MC05NzlhLWU3MDhhNTE0MjVmYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJiYWZmNTItNTM5\nNi00ODYzLTg1MzAtOWRlNDQ4Y2RiOGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX4xQ/PyMADzsOnCZvpGF2W0KBpfiNQu/HTfN+ti5xvDGgrluK0l2ctLO2Jgt\nJLFQ76wZWK+Q5Iy2PSkNF9fz9KOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTHdTgqydpjS9WjqGcJYuvSq+fUQwHwYDVR0j\nBBgwFoAU+BIRIhGgmKHZI4Zi7Ee+UORrXHswIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA4IRbFxANWhbyzz82Qz1V\n7Sw+fQc25ohydHPGcvsRXcwCIQDMyP2e8Fsjotg6TVHZyp53W4PdG20tB6nQHVlT\ncYCCCw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVgApwTx/yElb3QP2Btja+Z4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjZhNmY4Ni0wZTU1LTRmNzAtOTc5YS1lNzA4YTUxNDI1ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARf/y2/F5RjIbVo55mTMyCfLJLufmGMVmBOPWj8aSFw8Li2\naQO+kW29KGifXSuo0IWE2KutzE1UnmnJeAK9n2Mso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+BIRIhGgmKHZI4Zi7Ee+UORr\nXHswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM6F+IlYMza7ZaCz28i2pbOby4jx21S6dOuFDK7uqTxTAiEAgJ/Z1tJD\n3bvNmnvv3czibrXipboeEPA9QmDCVuntTPU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAQpqYi+Tr2RhVdeBxxuzaaHlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJiYWZmNTItNTM5Ni00ODYzLTg1MzAtOWRlNDQ4Y2RiOGVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYmNlZDRk\nZC05ODAyLTRiOGYtODE3Ni0wZDgyNzE0YTExYjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS+NiSXpJoo3DVAcqhUCCEsICCEwZYusvpL2yOnNqb4UPsD+587N/Ve\nveTc52QdMjM8+7hnz9CjRw6RfCGg08lNo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRMd1OC\nrJ2mNL1aOoZwli69Kr59RDAKBggqhkjOPQQDAgNHADBEAiBuVZQMCJh5A3ceD83m\nXNjigYnMoUXP8bXDRZyHiHLStQIgbbX532qq8BTo4RUiyKDmKWSOnUZ5dYKRR3TR\nEvzUVqM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5846", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5846` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAWVEpFnkiYxmDJnggJQ+EC4wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZjc2NmFiLWFkOTEtNDMxMS04Nzk4LTkxODlkZTMyMTY2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU2Njc3MDAtM2Fk\nMC00NTNkLWEzYTQtNGViNjkwY2EwMjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMEaCcw4w3ONa3mG09tLrpQrrN9Ru2seE1oVaSSpyR3pPjLn02TE7E/nVz4DQ\nl+Ypj1J4lFykxGpdP7/PPW3ZnqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDnOAwLydyGLtlIQ7r9Sk57/uQC4wHwYDVR0j\nBBgwFoAUy8EL22rphg5ylSBSZ5HAq1xOOakwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBgDdCW\njhJ74DTlUMCS1eKjzzypUaaVD4j/VRUT4BPZFwIgWkqAq07LgJ6ToUb9Q9m/Si4e\nOaUs3pghN5rgAlfIVrA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdQ3pWOuAIUJ2KW8oz+ujVAgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWY3NjZhYi1hZDkxLTQzMTEtODc5OC05MTg5ZGUzMjE2NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRxGHGFDs7IGRTlxL92Y5S/kQ5hpI5Y3qOfhtIP56dXW6I\nc6qDNpYkeK5Nzww9zOKJQ27pf+28kDGlNH73PDM1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy8EL22rphg5ylSBSZ5HAq1xO\nOakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYJc0laMfyPuKjYrIZQkRfenQXdMgGcJSytgKyfz4kKACIGcs+oeInPkD\nMCKzDlrpL8JzPM9Yh3cQ/NN5C7GVUm9e\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAXJPYkZNF1lidDC9S7fKCNSWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU2Njc3MDAtM2FkMC00NTNkLWEzYTQtNGViNjkwY2EwMjhiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmM2MzNGIw\nYi1hMDMzLTQ3MTQtYTJhZS1iYjJlMjA0MjliNTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARn1Op0CR0AVsMW/Aa1d52m/SUg6RLEXwu1UTP6WLq3lTjDBTTUQ2+k\nm1eM8KyYqxdy0E6Syh1klEHmilvkJZMoo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQOc4DA\nvJ3IYu2UhDuv1KTnv+5ALjAKBggqhkjOPQQDAgNJADBGAiEAyefNux5e6SP6nE4d\nCphtVnRtHwhFzUwT/7l0F6pFBdACIQDjWwiUMEgPppdDeyhYEtb0DpkYBqMXq/zx\nWGr4LbfInA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5847", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5847` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAdG1gaSOBSi1rLHQRXZcHsrjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyNjIzODY2LTdmODEtNGMyNi04YTQ3LWYyMmZiZGRmOTZkYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc1NmI0YjUtNTRh\nNS00ZjAzLThhN2QtMmUxOGY4MGM5ZTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiIznoxLPZW5aI9uqM94T8rKZEd1a2Ou/0Zu7sgJ8sUHpioq3vU6oBb6+BUvu\nbyOpLaY+tdgQ+5eimrPxS8oMZaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUplansW10Sp1Yts0g1vwkfM3pzX8wHwYDVR0j\nBBgwFoAUPji49kjmdZQDQYf+kzqk07zRGlkwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAgGt7\nUeQgVBrEco7WhnVhdF6sQwpQOQQOedlAb0yEzIwCIHpQ+fSEJ70/wnl4o04b8JPQ\nM1R6Y++eTWcluEdkZY6u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfDmC1UbsQz0MhCtVjr83G3HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjYyMzg2Ni03ZjgxLTRjMjYtOGE0Ny1mMjJmYmRkZjk2ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmahw+GTP3RVkiC9t3U/E8HkcOMrmMxPYrBjAb8NLuAQ3G\n/PudDfvpxydJ4ChQepXoyJ2j+4x/VOHD3o/BPKo0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPji49kjmdZQDQYf+kzqk07zR\nGlkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXY8glQ2nyJD5+TBzSIOFZZSMoFJF9l71LmvwXsLF5w0CICkv+6UovyAa\nTuVWMrQi3QjPFVOkm6EOnBp96//uzVGq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAbei/84ZGTe+imaiMico4jNkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc1NmI0YjUtNTRhNS00ZjAzLThhN2QtMmUxOGY4MGM5ZTMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzODA3ZDQ1\nYi0xYjJhLTQzNDMtYWVkNC05YWM5N2E4OGM5N2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS2WXEJeO+5Q2GvGeZzPmovg+nHn1t866lazrVHQUBZVbrNGj7UQCTM\nat0RtaPR2fgV2kH4mgXl8EuXyfzFZzTZo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmVqex\nbXRKnVi2zSDW/CR8zenNfzAKBggqhkjOPQQDAgNJADBGAiEA0rz1OwZhgFx0kpEm\nB1Q/b/y1ujN+juu4u27hVDPt5QMCIQCLyvMUm0mq0FejWv9F3E6015ob96YW6lI+\nLE0/Dmf6Zg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5848", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5848` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdyZuAnIIUudHDWYbk0E3ctbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjMzI0YjBkLTFlZDUtNDUwYi1iMWZhLTNlMmJhZjE2ODg0ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU2OWQ4NjctNjI1\nMS00MTg1LWEyYjYtODViODgyNmNmZjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKHyUnh+JBKGV4aN7qymNFyosIxliIHc5tVhWu8IHMyCJYT1kntXpWuJkSQ7D\nbNb475sgSLBCvFM0gPKJhVD/9aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOwIhFMGQATqXf82euUuR3/gstlkMB8GA1UdIwQY\nMBaAFNRABEdI+WTcrqZXpGb/+697lV3lMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAr7omhRac5xgxl0taT4NlYZvKCCmRY7vK\n4pa7BxU4e6YCIEpadg4Da40vCQLgdfxebdpN4LSH9VwtPsBOF65GzmCn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQa596AsCIugROZgrvNMvLHrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzMyNGIwZC0xZWQ1LTQ1MGItYjFmYS0zZTJiYWYxNjg4NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASX0lYREjSLiovc1Vus0Z3jxNQtmXsxHxE4eND2JuX/ekf6\no15T1oLcjC0sYrtHPjSC2DIF/wSFvcV/Z0/PWCg+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1EAER0j5ZNyuplekZv/7r3uV\nXeUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOOF8FWNCr4n47NTdoSpykhO6cPE8cwB3MvTQHWDVxomAiEAzu1Jd52m\nVbuwFvF1tNm0SQOBHxKcYWDTs9M+qdGoLgw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAUU1qJjKLsuFEuu+4WMtbeS7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU2OWQ4NjctNjI1MS00MTg1LWEyYjYtODViODgyNmNmZjk2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyY2E4Mzcz\nYi05ZmU3LTQ3YmUtYjA1OS0xYTE5OGIxY2FlNjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATnRualFs7LlEJJPdW+Ylx4kilDmmThVv5MzSzBCj3STgs+nu00FGXc\nD+64ADFXODSE/LZHZFRd5uSpXWQHZxULo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTsCIRT\nBkAE6l3/NnrlLkd/4LLZZDAKBggqhkjOPQQDAgNIADBFAiEA4VNmJnGs8zzFFzYF\nw7mw5xg/9af552czfQamz+/i8B8CIFrvBkSLvQfZOf9LEcqGSIMOY9x5FAHMEPaG\nqxnAxi2d\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5849", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5849` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQ5C8EFEvkLIKZYKzIpFGGLpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3YWU4ZjQ5LTk1OGYtNDU0Ni1iODBlLTQ4MTRkOTc1ODljODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzllZjBkYjEtZmNi\nMy00YTE3LWFkNzYtY2M3ZWVjMjk0NjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnhc0xNTGOCNBykDjSFVu427wF7dgMOs7mYcf48TdGjvVDFcyd+1EdoTwRdoI\nJ4P+/PLO0VvtjRREYrvijSxDc6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtkqmAF9RjhA0ffswsUojUZwRFh0wHwYDVR0j\nBBgwFoAUons9PoWj4OxvVhbkLTPR7ICTzSQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgfeMS+wcoEhZc\n8ihtAjjSpd69jiX6GCQZm1WSvePzkrsCIQDxetag8SOnE1Y74cgikyd4gT0wmY+m\nJ6fxllZ1b+6Nzw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASvch8GyHxnwbHJNLdlRpubOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2FlOGY0OS05NThmLTQ1NDYtYjgwZS00ODE0ZDk3NTg5YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASx88rWOi5ExR/Xi1ODyBT6MnuQ7Fav2N9VrIP6HQn2q73R\nVu4HGkIzURxsiRdBQrnInFt39T6V1y8pgs6KU2v4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUons9PoWj4OxvVhbkLTPR7ICT\nzSQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANb/vfSqCFl/gblXmU5CQmG9L2y31Lug3gyHj8R7FUO3AiBnvduEW8/F\nrH8zJ8KH95ilSAb+nACGAcakxUQd4nzkyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAc2BljhLdQZV+skqqXpCMJi4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzllZjBkYjEtZmNiMy00YTE3LWFkNzYtY2M3ZWVjMjk0NjgxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMTViNDM3\nZS03MWMzLTQwYjAtOWIyZi1lNDFlMDE4MzI5ZDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASK1rhWMQiEpk8BrQjpp972GhHTnHVtvi/AkFdfq/qG8oe5aeDKt2R8\n7p726iTxnpgFaoXOJ8RK46zVS7Idkr7uo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS2SqYA\nX1GOEDR9+zCxSiNRnBEWHTAKBggqhkjOPQQDAgNHADBEAiAfRoNPJVKxaHwTaT1q\nduJhWbfFJfYT+2pC27/VSS67LQIgYJ10O8xfRbkTpKt+0PHI0Gb9vc+9OvD3jKbr\n//LvrG4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5850", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5850` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAYUi9NuzuUn09cAW31QO6l1HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyZDg0YmU3LWE4NjEtNDVmNy1iYmVmLThlNGIxZDgzNWZjZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZjMTMxNWEtYmQw\nMi00N2ExLThmNGUtYjRlZTQ0ZDNmZmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQFmaqnqpR+iryNEVIPSyuuDSeA16G4Edx5HZfwSQBDP0L33PMirKdfp91CpX\ns+lnyhZ46BGnLEL6PX0exvEXKqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR2l5d9X3YcWrQnFJ/qc+p1C7vrEwHwYDVR0j\nBBgwFoAU/mk+LDy5uda6S6EiXCWle5ZMVF8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAICSKpOxaqCL\nylSAxluW+/jaXysxb3be/4x9MUZy6WOJAiA74m9ntr2gLyTCW7uQkJu8QDhMIEhL\nZo7XIGCGCG9/JA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWzRJYz3nOV0F9EvGWvKDX8FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmQ4NGJlNy1hODYxLTQ1ZjctYmJlZi04ZTRiMWQ4MzVmY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7eIYD56uSPemA5dBT21IkGiPBMVYDZ+J75uDG4nPKjFvp\nIBnUMPnS4DKObXJ9KVtXahWbpbpXAJrp6SY+pKndo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/mk+LDy5uda6S6EiXCWle5ZM\nVF8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgebFPv2rhHjq0s9UbtsUm52xV82RySVYdaMnVr1cJmxACICI0MaEFoP2c\nE2U4D7kmlmS/kc6i8kHIXkyGsPgabs8d\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAWxT89B1DDpMXubHkUM3R+4XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZjMTMxNWEtYmQwMi00N2ExLThmNGUtYjRlZTQ0ZDNmZmI5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MmYyNTdl\nMy03OTA3LTRhZDItYTU1Ny1jZDI5ODVjMTM3YzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASvYuh3TGkMldS7kzlX+AedJmY1LBisFV6EpqYWZStBJkryh20p/4WZ\nkNSe7Avn6NzmttEI4d+JBxP2bwjVpeLco1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHaXl3\n1fdhxatCcUn+pz6nULu+sTAKBggqhkjOPQQDAgNIADBFAiBhAG+j36qygjU83jxs\nK1qCY8Qgm2EmJ3SlvFC/GIGgjAIhAMKvy/r9PpCfWi4SGncUycGqIyo2SB8B3Wq4\nZdElJxil\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5851", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5851` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXpOBqkLy14X/8Kz6FRL0H8yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0MGVmOWI5LWIxZTgtNGVkMy05MDY3LTI4YzJlMWJhMzZmZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWI1ZjYyOWEtMGNh\nZC00ZjFkLTkzNjAtMmNlYjFhYzhiYzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtimzoM4+ww9sVbQUOiCsH0fr9DKeLqMvzVqhYNWVl7abbpvTGnzdNSCps0Dm\n6LOk/IWT47nwdMpJCH92Wyy40qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB4/gqY7Rrp8y9EVHuHu5H/7/H1EwHwYDVR0j\nBBgwFoAUsaGod7jIMxrK++E8hZ9JpLKtKcgwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDjcV57XQti\nrJ9B0r3JK0GRaifT8LIoZ5MKMHxeJWlmDgIgC2xAfNcdLBk09H8iSSigbxU5xldA\nZMMqrBa0dY5wApI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYypULhmnb53n9AefmyRe72jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDBlZjliOS1iMWU4LTRlZDMtOTA2Ny0yOGMyZTFiYTM2ZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmhjXlv3Nf0FWEROFU9xzav3W5wuGCSRhzyh+OLaKvQgOu\nX0M9MZdyTTw7QFL3Ooz8o8rAexbo0YAexMlWdgOso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsaGod7jIMxrK++E8hZ9JpLKt\nKcgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN7aurAQyKOWDWnFrawm9Tvj16xBpdU7xooeGqwjORjmAiAx3nrzUVvc\nJYfmKAaB5ZVHoJ7RvMW6IwGRwnzqjlo3uw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISARr4npseqNUtK9LPYjP4jYKeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWI1ZjYyOWEtMGNhZC00ZjFkLTkzNjAtMmNlYjFhYzhiYzlkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYmQzZGY0\nYy00NmQ1LTQ3YjAtYjE2YS05ZmM5MWVjNWQ1ZDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARz11X/2Biai1Ne1sY1Nuck5u9IOQ+q6FpGZh0e7WcKhBFjvryC+79j\nCw1S51zyKzBXgI336xk+4rOt2YAPmNuRo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQHj+Cp\njtGunzL0RUe4e7kf/v8fUTAKBggqhkjOPQQDAgNHADBEAiA8twshVFcX69i97UTY\n4OgF121PntR+tALNoRkFsCVMJAIgdfVk28oES/WuZLYKnCpIYhDNtsroBGxWgQtR\nI9n5cZc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5852", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5852` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWRW/GkqL74J9FsQOl4W4+opMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ZjMxZTgwLTNiM2MtNDkzNS1hZjY4LTkzNTcwMjI4Njk0MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTgwNjcxZDUtYWMw\nMy00NWVmLWJmODYtNmY0OGUwMTNmNjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEofUGWwSNz/4e/loR4VrI4l8rf0eT0s0vQzVS89JOsAraNGCU40GGFSJfVREy\nN+vRpxCqtezknjMCyWsqKkg4XKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2LPQDR4uZ/DGrEI6xsD0UUc3A2EwHwYDVR0j\nBBgwFoAUwcZKYc4WbtetXjI7zrhF7iDINtcwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDDwdvbo9Sv+kEfhIstGedmmITbq9+399o9xBdcqaRKxgIgJX6Me2ExIq50\n4onJmyofYJ8SYy+EO4Z8QBWw6mg1wTM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWTcZPES/w1T8kHYESlE64gLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWYzMWU4MC0zYjNjLTQ5MzUtYWY2OC05MzU3MDIyODY5NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzMsgbXGnqbkb7mUnHNjYnmD5n2bELKr6LezOw2NVduc2s\n9uu0+6Bb2F0X1m84mZWRY0HL+Ppw/MurQUVR/kuwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwcZKYc4WbtetXjI7zrhF7iDI\nNtcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJEA+JISzETPbmiS0pONGrPSuZ3Hv5bTD+YHS0Zsh6yoCIQDqhpwT06Ol\n2wK/i86Sz/sz/LDGAMt+aYQWGx96laW8SQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAWR5Vr0PdisfrmpjWK63gIJhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTgwNjcxZDUtYWMwMy00NWVmLWJmODYtNmY0OGUwMTNmNjE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNTQ1MmEx\nMS1kMmQ3LTRmNWEtYTZhZC0zMGZkNGM5M2QzNDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR4A4nPQXkHFmd2qyN/xFSE4RoIRgnjSDJujI820OolAQGnhSi1JTs5\n8QwbrMbqLViVZpr1yTrKn8/g0C4NK76Io1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYs9AN\nHi5n8MasQjrGwPRRRzcDYTAKBggqhkjOPQQDAgNHADBEAiBEC7UiKviiLNJ3Nm8M\njAiiL1etV8hX9FIynApHERDOZwIgQtpIAQW8yLo/B2Q4MqEQLm3hhRy31qPYw76b\nH8G1a6c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5853", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5853` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdYUEJJ4964NZMKZQZHoUqe0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyYThmMmNjLWNmY2YtNDc5Mi04OTVmLTQyMWZkMDk5YWVjZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjczODg5MGMtMGJm\nNS00NDJlLTgzMTgtMGEwYzYxZjNhMDhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdNoiXjic19elkLvhBjCkCiJuleWSbM10FAX4WcVMoQVREAWnUjlDEtWBZ6yO\nPdhe/hCqSzYGuSEHDULbEJfUEaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0I+nml7AykXLjyJzzxBLs89AST4wHwYDVR0j\nBBgwFoAUQyUv7IowkyjSKKQUi0P4Et1eAnIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC7kLrLyiHJnXzUaxyhUh6ybdZITrjEZ7UJJairxk2W4wIhALkgHg6DmeLR\nIiYR/c/XeSmnDOg/t3+3MVptlZ95+qdb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVZO8CIYT9LmwAPc5nhe29hmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmE4ZjJjYy1jZmNmLTQ3OTItODk1Zi00MjFmZDA5OWFlY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvFJTjlRmizgUuyiytCbl6Eg5UPI78yH4aHFaBIbEvz/47\nelqZyy6UV+jvsNkkIj10MFiNXqphIBI25g3QqFYko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQyUv7IowkyjSKKQUi0P4Et1e\nAnIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLvDwrt8IxepDaDncHyWkq61sUhcBnnl/XjuO7o7iUXoCIBgPQyna09Qo\nxNldZ+8+3KJHuwT3iD43gvheGy74SRxI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAcIwMmHapWDQ+rO4q4qYWD2yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjczODg5MGMtMGJmNS00NDJlLTgzMTgtMGEwYzYxZjNhMDhkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5OTE0NWZj\nZi1jMmY0LTQyZDktYTA0YS1hMzdjMDJlYTljOWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR6oAQFPMiYO9754l8nxQ84QAFZPuXzPCYn1xvhM8aKsDxE80OdMDyi\nAJHZvW0kYqF8/alGUyDW9cVt3LSgdQU+o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQj6ea\nXsDKRcuPInPPEEuzz0BJPjAKBggqhkjOPQQDAgNIADBFAiBh8iWDsQyPN8nkDe9C\n7Nzoii2COd+gqVUL2MQH/YNolAIhAMo3nF0s9WHt8M9rmEmOs1dzAOT3d7TRuARy\n7W2IBdKV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5854", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5854` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAfU6ZUJLt6pgRTbDB+elBI5ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3YzFjZjA4LWFmMDMtNDhlOS04YjhkLWRhZjNhODg3YTAzNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q0ZWE5ODEtYWZm\nOC00OWNiLTkyZDItNTI5NGQ2OTBlOWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPNQZqKkoNtk4AMhfP+l2zH5gih+R9e0933kTF2IhfNJpVs+qjoV592G+4j6i\n9qLttZz0EWgrFQsb/K8gZltqSqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU5egf+Qv2lJQQ/s8wN3wluGhgLowHwYDVR0j\nBBgwFoAUYvYBUdV6N2edZZC66SCgnf7cuI0wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIB1U\nntRfje2Z4oY7PORN2dEUAyNcDOSgNsqRmrFfokNpAiEAnMxsd5Ek4rIDv17jGjYs\n5NJaA5Bw6bvWwcR5X2cKnCI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUhYfAL0rmCDWqmXcuG8q2K3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2MxY2YwOC1hZjAzLTQ4ZTktOGI4ZC1kYWYzYTg4N2EwMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBcmLJCwY2napLrUzuKI7Paue/w3QRIQrtfnDLixOQX0ar\noKJSgskz3Qb3WSmvgO4UD2Gf9adu4Tnl9F53+lCAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYvYBUdV6N2edZZC66SCgnf7c\nuI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCROV2Sw/1/CWcoCXLAP3lt6KQ5vCAuSeasBGboBU0I8CIQCNgFZUrWWt\niXxcPELMbED18q702CTanpgZstS/GVCWTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAfK5jUGScvLX7FRpi/2EqtEJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q0ZWE5ODEtYWZmOC00OWNiLTkyZDItNTI5NGQ2OTBlOWFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZmY3MWQx\nYy04NGFiLTRmNGQtOGUyYy02YWM5YWM2ZmE2MjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATINHElptbpP9PpzFz+iJdTNIpbku4JSWJ00Qbu6tGOwxX0L8bp8g6Z\nFedIooHR8zj3rFMs3NS7lPR4Ohi5Borwo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTl6B/\n5C/aUlBD+zzA3fCW4aGAujAKBggqhkjOPQQDAgNHADBEAiA+im1cgL4uJdvvsFiq\nADw9zff/KkNcRMXjoCxvbBWJYwIgMVbkwPmMTEfETlioGZ9P1l8BvRSJYtB8Urwm\nG6Me/fQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5855", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5855` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcDmLZ3juwdguvsupXyo7qm/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxYjlhN2M2LWNkYTEtNDllNi1hYmU0LTYwZThjYTU2NWI5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJhMTBhODgtOTkx\nNC00MWE2LWJiMTMtNzFhMTFiYjBjYmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHJCKuSKt5rz5wIW1PAInPKwuJR1wqDqwICnO8vkUFpSdrN3n1uUbT2pBzAdO\ny10wG3BsQXcdwN/DmhwOQg1KuKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNl+idkGNOB6eIslTX+B/na+k+XYwHwYDVR0j\nBBgwFoAUm/Hxz4Q6k127YjeCetaAR2exV98wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDogvQLbnPUnTqTb952py5E1tXnRHu/6iTWpDpBtQJCaAIgGBJn\nf8JnDSB7W/tJmUtVGjguS1P1bVfM8+r94XowZu8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZGj6M1L4L7Fib93qOTvY8KSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWI5YTdjNi1jZGExLTQ5ZTYtYWJlNC02MGU4Y2E1NjViOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiiWrVq0/AOeTE9TdlbyFDL6J+c1ieopCFSRL5JdmpihXr\nbWlpjJUslQfZd4F0ZV7Qc9P3r/U5h5ARnRSTk8pJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm/Hxz4Q6k127YjeCetaAR2ex\nV98wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKVm2CDV6yIWz9Ffl+vrsKjTZonedwFkXbVYHxeaV63YAiAosABnW6KH\nfTossxQQ5GtpCYkeCsc8qngOZ3un2zzVvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAXzxFhCQP8U8RjB+oMU+M/WWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJhMTBhODgtOTkxNC00MWE2LWJiMTMtNzFhMTFiYjBjYmNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NTY2Yzc3\nNy0yMDM4LTQ5ZGUtODQyZS1hM2IyYjc4NTAzNmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARDZnTS6JSmE49Nw+JxxNqvOadwfNiVJcYrdFw7T/o/01fA8SeSjOwE\nmto4+Bwex9TiO7zaYNzJlvdxmnulBCYYo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ2X6J2\nQY04Hp4iyVNf4H+dr6T5djAKBggqhkjOPQQDAgNJADBGAiEA7SVLdZCV78YDJlc1\nx6JDLUCRWjSUBYev6RNlAi179wsCIQC+Ju1402ANcQUt0GNXVjrT03xZjPOr2CM+\ngBkXpoyZMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5856", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5856` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVroQMhCwfE4PMdIk2c+GlgKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhNTY1NTNlLTQwZmItNGJmYi1iOWRjLTQ0YTM2NTlmOTA3MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI3MzYzNTctMDAx\nOC00OTcxLTkxOTUtZTE2MWI3ZTRkZjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOqCWTpbF7615cIqJbpCs/HEkqaQrZ1ouyWhdIaIwNFK+eplnnfF+K3pfOrYt\nEspnNScRSwebfxFVqlMjJV4yWKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj/j36u1E3yaMfzZFGpAia6AHHWQwHwYDVR0j\nBBgwFoAUX/j5CT4+v0M47DA1BCjoRFkqP6gwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCXtDxr3gZIVpyo6UGnW44g79DtC8yZEeHAERfSzCwKnwIgDAjX\nL7Kq9q7xHqimjDzt2B2+VH7NWKwbTd5wnuTcDYU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfeW/7+p4MvUKN3f0RZL/YDAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTU2NTUzZS00MGZiLTRiZmItYjlkYy00NGEzNjU5ZjkwNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiCSbcKQ2jc0N7iOXJUvSE7Nvn0Na8vRAwBf1l14e/LGFz\n89bj/QC4Ptyaaoh1f+3GDepwruBoWALJxZLfkGT4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX/j5CT4+v0M47DA1BCjoRFkq\nP6gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUskZ2qS3EkmgLyEbLpq6PcgXdQUytwy8spHqPSLPKpACIGO1JPsfaPFm\nx7WhzdDDdAzZdfl15gIbVSGGer1uTDRb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAYDMXCpbMpJzePhJojWTQJSoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI3MzYzNTctMDAxOC00OTcxLTkxOTUtZTE2MWI3ZTRkZjZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NGFhMzAw\nYi0wNmU4LTRmMDYtOWNlMC04MzJiNWJiZGE1ZjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR0lLu2N1FeMtgtVK6zhW8Q+p1azfG6ELZiv/ccCgf46iNCCz9mxeEI\nvJJpmhJQLLj+iJlTf+8kLCUK+EIPFtIio1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSP+Pfq\n7UTfJox/NkUakCJroAcdZDAKBggqhkjOPQQDAgNIADBFAiEAofWnHrQK8DsPvf0a\nFMy3oLVcRF5qHAWKLfZtn0md7RkCICzglllpB7UezNzBDRyPaSKfqfIwTKLuvoGt\nW6dceAFe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5857", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5857` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAS/45nyagF3V3XWVW6fKSJDDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0OGQ2NDYxLWEyNTctNDFkNy05YmFmLTk3ODQxODA1ZDg5MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE3Njk2MTktYTc2\nOS00N2FjLWE1MjItNTMzMzZjZmVjNTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKn2DDSRY44umzS3z/Kh9Wp6LUe5CFYHRe4PfZOblSCj4eY+sOvHjI8Uicq3w\nLI1S5tWI+l158OF3BnoN9NUME6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFK0ImWuc563rsqkOKMAf96XHoI8uMB8GA1UdIwQY\nMBaAFHogRyR+Fg5A/skkb7kYL9tAgWv4MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAgksan1nAboF9IUialWQB4A71Zi4u3Kia\nYXhwxJVveXECIAWwXmADCOr+IM6HpgEjTk2P2YmvZFnTBDMTnB9Etl7m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATAk/Z8Hw9mMXeyK1T5KEkQ4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDhkNjQ2MS1hMjU3LTQxZDctOWJhZi05Nzg0MTgwNWQ4OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXrLnsnKvONnfD4dHLLYQyn5W32zG5d8to4CQEgG7ku1QT\nic3+vg/RBU8NcKvT4qjgLOxMZKNKBPk+OeS3ZtFto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeiBHJH4WDkD+ySRvuRgv20CB\na/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPxW1BpOyJj4WEoTlbn+LzROKq3eMGTSrD1Sx2SkMSw3AiA2mmu3boNE\nHPr4G1K+C3KZrYXfAdgcnwyJlehM9/izXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAYHmMmlPJruFWtxqzWVlI1bmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE3Njk2MTktYTc2OS00N2FjLWE1MjItNTMzMzZjZmVjNTliMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMjE5NjA4\nZi1iMmM1LTQ1YTYtOTMzMS1hNDk3YzhiMTNlODcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASGNIfbxOnTsUtLstGBYXQkO4iIa59SkyoCEMSqr30GXs/y4sUtWJ+K\n+8SAc/maVXFFp03PhWmI4eRRv5RdXW8Xo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBStCJlr\nnOet67KpDijAH/elx6CPLjAKBggqhkjOPQQDAgNHADBEAiAUNIFl6owOGs13JHFk\n2wqArVRcpfODDKfTgBUnl6rpBgIgRis5o50SlM9SIEpHm0EH7L+rKyFyDwhzdcL1\nk+/KiAA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5858", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5858` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAYQN7ZK+kLu9YUXsW5cm94diMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkNjY2ZTVhLWFhZWQtNGZkNi1iMGVlLWE5M2FiMzEzY2UwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYxMjA4YjctYWI4\nZS00Y2QwLWEyN2MtNTRmNjJlOWViN2EzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEefde7Afm+EDsYz7SawcgisJyoWVwZnaLQN99PTGGVF8wyMgCu+hZczOXjZBy\nwH1tm1rl2IjQYMPkEgQHDeHJgqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvlAYXDljwShbbqJOFIGFByhCTrAwHwYDVR0j\nBBgwFoAU5ifwxT9MZtzxq8cT2555eNcdPe4wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgc3qMapc4nkj2\nirefZ67LoQ/SNUpjOEPWVhVqmZ7eGIMCIQDF3HOmZvGOCUIVD3KcDizQCEWLv76V\nTftSRltts4jXmw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYGCbSDrHnhfEnH60l52UgysMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDY2NmU1YS1hYWVkLTRmZDYtYjBlZS1hOTNhYjMxM2NlMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARup7OBlm/gtj3je22uwe8No1cEyuuS8nCD9slv4+ncNJeI\nRnzx0wr8/T5TjDberf3ObEswEsWXd0+NQSuUvCdmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5ifwxT9MZtzxq8cT2555eNcd\nPe4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKObds7a7eq0wceGLIYixDt59GlNvbxwLrJIkRl/9WspAiEA1BSeQT0K\nHSU/v2KCTF3Feo7Agh/b0bymtG3RP1xIqCQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAYVtFqg7mS4BCYH4JvUdXhaNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYxMjA4YjctYWI4ZS00Y2QwLWEyN2MtNTRmNjJlOWViN2EzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NmU5Y2Mz\nMC1iMjAyLTQxMTctYjY5YS02MGRhZTc1YTFiMzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS3ngCmvMQKyzJ9Z3NCZJFscfNBo8MmD3CLZk4TBx4zDuUaA7SAqUTi\nhzyYOqz00a5xrb3+IHps8mliwUvXLxubo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+UBhc\nOWPBKFtuok4UgYUHKEJOsDAKBggqhkjOPQQDAgNIADBFAiEA412GgjM6R3s0ZQOI\nZGJZFd1zw0hD+wYYZhhXWSh840YCIB641cdeDK7WLj/LVu68qwT9kmvjEa6ogD7E\nYivSY2T/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5859", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5859` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAf6UXDHDePHprDW6dtPql5pQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5ZTYwYzIwLWUzY2ItNGE5ZS1iMzI3LTkwN2FmMGQwY2VhMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIxOTAzMzAtMTdm\nOC00MDQyLWFlMmQtMzhlZjM4YjFjN2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcg+MVUbCyzeylZO/Bi3z5jYaLK8A3AmlG1kpR1c29dHoo084aT556T9BnaVO\ni221uKHuGYGkUIWLRkb3lYe/EqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+0gjVE+5KOr0Eoa0MQK2ypBXuoUwHwYDVR0j\nBBgwFoAUzPBfbk9DrcjF3Zw6YouD5s4KanwwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIOJGbXhaKIi\n/YtIpmgTpwgfchy/vMsw7jrXU+r5rYcrAiEAi8ZHAM9QKfy38US11jTCm/Oo/v5Z\nAXQxRDG/hXrI0zU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeil0JkpOHd+AcxjVIRLCPopMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOWU2MGMyMC1lM2NiLTRhOWUtYjMyNy05MDdhZjBkMGNlYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlvZ7YjCvwWXoH13448Xn5/NF3HWjv+scG+hUlPH1Dc4BF\n5q/oFUuEh2aXKtdlmTqWeH2ku8Enhq3RXIKC5VzZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzPBfbk9DrcjF3Zw6YouD5s4K\nanwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALdVxz7EG0FUpcMYux7vBqsSn9Qd8pitXqcbl6ptCJZkAiBSdcxHI6A5\nI6qqEhg3RS2gEpKsIMMyyHpitKfFif4Q7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAVmP7m9Dh3arzxFq6n7auJOaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIxOTAzMzAtMTdmOC00MDQyLWFlMmQtMzhlZjM4YjFjN2NmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MTBlMDAy\nMy0yYzg1LTQzOWUtYTQ0MC1kNTMzMjAwNTJkOWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARZh/JucynMc9e9MfzimUJZshHETMMhV72tnoZGXr0M2B+FwHoxKjKL\nMpCkod6j4FZchyeM7AYqHuuJqZbkRp9jo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT7SCNU\nT7ko6vQShrQxArbKkFe6hTAKBggqhkjOPQQDAgNHADBEAiAGjvctsbA+yGq8NJqN\nhtUXa6UkQ6yxiVNgHk7tgsEWuQIgI3koXJuk6onmIfglrcNuMo+cDgnMJ8PyMfPE\ni9u2Q/A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5860", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5860` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcZP9tfkzPchuMx7lsExPSMOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwMzJhMzYyLWZjMmItNDQ2NS1hNzAwLWJhNzE3OWIwMGNhMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RlOTg3NGQtYWI0\nNy00YjQ3LTk3OWUtYjFmOWJhZDUzODhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE68Fj5DEsK1BNC127BTQAakZG2YHbR03qSJsPeSdhzNbg6ZjdPD1u/w9+mMKf\nuMXvTBB5emi08L766wBtTX1Od6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZqXgN10g27edjzHrRpDexGie9zUwHwYDVR0j\nBBgwFoAUAExlLzy2o2rWlkJuaRW7wR1UwfYwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA55cbbeNgXK\n1MBXDrtzj9XSOlOpPK7CMzWSvBOrvaqhAiEAmQNG4up5C9Ynl+0VpU76HDj9yWz7\nsl+jWrZI80BvAx4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAREv0O1pigwD/VNf3yei+097MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDMyYTM2Mi1mYzJiLTQ0NjUtYTcwMC1iYTcxNzliMDBjYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOiRuJYPhw3WaICXFD90cOdnmHvQRa1e55IGrawooBd58k\nCmIG8aaw2NDmxwP+DB0MynlMaxsOkZHRUp2pQ+0ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAExlLzy2o2rWlkJuaRW7wR1U\nwfYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfNpOFkDlrB4mjBvrGCI99DS3QlLzUmQXGeXT5+t5eB0CICYYCYwUuyrk\n7JxX+uNwb0RNoxqcOxG0WsZQB4wDViyD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAR+I1zxAoMS/1N+3HiFKWMraMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RlOTg3NGQtYWI0Ny00YjQ3LTk3OWUtYjFmOWJhZDUzODhlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MWVmYjk5\nZC0yNzRmLTRlOTAtOTgwYi1iMTRiZGZjMmEzNGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS5A0vWC/wICHTmdCD9VQ346kzss5cXaWf/JB+g+32QgUqv6eR1ytll\nMtDf4bKS2E2SKUO8zqLAcFyuvum0ZKHio1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmpeA3\nXSDbt52PMetGkN7EaJ73NTAKBggqhkjOPQQDAgNHADBEAiBLXSQTmCHEXKiG3G2i\niFGe3kU2yEt2faDmq/3H3Dm+3AIgbuhvDXYUwAM9P5vR/QWn8+7vqsOqJL+ESDxo\nYZACMew=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5861", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5861` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYRlPQJ4gVKM1VJk/90qGrytMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkZDBmY2U0LWNiZTYtNDYyMS1iZjQ5LTU1ZWYwYTVhODgyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJiNTc4YjktMjFl\nNy00MDQ0LTkwMTEtMDE3OWMyYTU0NzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8qZuN5psvWi0paHCfdq9aBcWTHFm/TBbr5WRgUTSazSB5rXJ3UajKyO0VrTc\nyOPRKFmFQwKOdpcuZGnYi+ctqaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+MHaqkPRotTPG/ec+fdR2SbV0e8wHwYDVR0j\nBBgwFoAUzKpYbi+gilCcG6JqGZimewiNAjYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD6Q4i47W6xuI9wFaxfLr+DUbZCxF1e2IME8dP1aWdAvgIgZC0FPI3xriAk\nzDDFM/5X/3E/g1novXIMGfbCCFljSJM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUAVvlmMfXzrgBgNmRPFcEb3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGQwZmNlNC1jYmU2LTQ2MjEtYmY0OS01NWVmMGE1YTg4MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrjU7lzN+tFisVk2ENSAvgtFC3TpE6pYsSabPRO/EkGnle\nK1jwXsrE//+1RCyJT1Xra5fx4Brj/dycT1bZknexo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzKpYbi+gilCcG6JqGZimewiN\nAjYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCtNlviwLDXQ6SF5FRLSrnDjPfTY1qXLYsP+Lgwj9drUCIHalC0cwiyGh\npMu0UPNxGg0cQMNAIwL447aRqWSuVCyt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISATYTQW1PuLt+qTEmETGElErCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJiNTc4YjktMjFlNy00MDQ0LTkwMTEtMDE3OWMyYTU0NzU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NjliMzI3\nNi1mMTQ1LTQ5ZWQtYTUxNC02MWYxZjVlNjA4MDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATXnbTLZNTVe1MwSS0/uiyey4omUpZurmGylbiFdqSftnG3t7ZeRS6k\nk4LMavpKEKXHPaQ6WhcLsF/Y3H+haX+qo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4wdqq\nQ9Gi1M8b95z591HZJtXR7zAKBggqhkjOPQQDAgNIADBFAiEArNaQsPpqQX5OSsyK\nRphhtNaaL06XOy7pkgTeak0FuzACIFmO3v8KRkQViT8hvmVJoS8eEh3GPmc4A1aY\nida0fmNr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5862", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5862` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYNuCHNSzFpAWoqvDRFcZ9UrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5NTJiOGVkLWEyNGYtNDAxMy1iOWVjLTNkYzlkOGE5NDYyZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JiZGUyMmYtZTdm\nMS00ZGI3LWEwYzItNDI1NTVjYTQ1MzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8XtxuVkES4ofIYhFwkuw+qJWyd+GSFCVgBbqGBwptUQuVoBD9ezwR/1SpTEM\nkBmeA3em5cEle8QM5dUJVkVlIKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq4XLae2fuswF/f1kAH5hp9BxabYwHwYDVR0j\nBBgwFoAUCuB4K34XXZvVzIM3+p9+cSyAvfswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCyxdwhvr5bEpgpvuGqHoK3B4bCepZYA1vqS+UvjqoRpQIgMrPLOxIEufgK\nwfukgKr1cMeH/Ygo0NvMSwRFFzpgKzk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWsdN44RlMB6dzQ61XXssd6qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTUyYjhlZC1hMjRmLTQwMTMtYjllYy0zZGM5ZDhhOTQ2MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIejqm0imb6UL/pUvHS5AOHXPBsb22euw+Rw8DRpOs1B3w\n1Dea+XyCniJ1dHb8wvPhRZAblCDrLPMEeu2GyMpWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCuB4K34XXZvVzIM3+p9+cSyA\nvfswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIcpnpEY/bDye0uQE3KOXY2dfPmHml2a6oIHvl/jifOlAiEApCCgsscq\n3IRbk6SNc6hU2yylMw1wBjVi3Ss3dxZf9TY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAd6IUtQtlZ1KCWuirMud8MU8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JiZGUyMmYtZTdmMS00ZGI3LWEwYzItNDI1NTVjYTQ1MzNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZGQ3YTI3\nMS0zOTdjLTQyNWEtOGJlMS1lYWU5OGE2YjE3NjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ97FbDYfSuvDlns5i7mQudPiQY2I9O5pewNH2GpL3vQ00zyg9dyxqq\nXYaSkQH7Nj1BQzTiTv0D6smiojtBMNvko1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSrhctp\n7Z+6zAX9/WQAfmGn0HFptjAKBggqhkjOPQQDAgNHADBEAiA4uJqQzQrezq9ixhwR\nWmEmFdc6zDyF0s8pJJ3SbVTb1QIgUhJ+XbrynlgwPJLEAtsH7eVbNAwLnzX01oPH\nUAJbgKg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5863", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5863` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAT89lrzSB2NXJG4UUMXxJbsXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NjNiM2E4LWJkNDctNDVhNy05ZmU4LWJjYzZlMzMxY2NhNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTUwMmRkZGEtMDUx\nNy00ZDY1LWJiNWQtOTEzZWM4NGNjYTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEduHAbDBTl796BXlrZI5MlqveWFJDOFKL9ZwA0dOFLuWm8K9iaKlJx0hupkpO\nSfQxnjFtWDZo4pGzO1cU3w3BwqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNr0afKMdLDtpSj72HTsTxW2reGowHwYDVR0j\nBBgwFoAUBIZmozrioOYisH7L8R+eWPk3SkYwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD/\nOQtXJtXWodlOeGlOy5PXFBO9KUYQd438V8Do9K4nZQIhALWU8F7JODCmzTfsNrFX\naFjmjsAVOBN6NFYluLlQdovU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR849uezVhacybDAspmIAGYzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTYzYjNhOC1iZDQ3LTQ1YTctOWZlOC1iY2M2ZTMzMWNjYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5GQRb1ULMQev8/oQ+ZisXVhOEw7JtWLpk6da48UCBjt9s\nEEcskj0yuEySgvOcDXV+U+jEh87TSiHETDkdQEbko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBIZmozrioOYisH7L8R+eWPk3\nSkYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ6/qLiY6aCeRKFCLEZM+SA8MdsTCgEFSQ7EvJvlsjtkCIQCghZDPiB54\nAdMKxuN96cq85AgPSIYZcqo/epVvG+fQOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAeRmkKPgvW4UZ4PUIH/8/mZXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTUwMmRkZGEtMDUxNy00ZDY1LWJiNWQtOTEzZWM4NGNjYTA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YTNlYjli\nNS05MjQ5LTQxY2MtYWVhNi1jMWU0ZTA3NGY1MzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARgs/pIyPRiIJ03vHiDs4pVdbvDch+Yu2G0vZrgLgLW5FhLnTEtdL6b\nN+RoiC+wnljISEJtPjQI43zJ1PpHOdrpo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ2vRp8\nox0sO2lKPvYdOxPFbat4ajAKBggqhkjOPQQDAgNIADBFAiAXJ0o+oO4qjIVXkuOU\n3UDIKchFspSihKE/fo2gc/WWMAIhAMFQ21p2IstMuxi7gCqn8iWG+VXbXXyQaNWd\nyyfagulM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5864", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5864` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAWNf4YzuCFyWv3Dwz5PciLFpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1YmYwOGY5LTU3N2UtNDNkMi05ZDQ5LTk1NTRmMmRiMzM2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFhOTYwY2YtNDRj\nNC00NzgyLWE1YjgtMzM2Mjc3ZWQ4NWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmZKy3S4yIloTsdOrF2vc6PYSBknrXvxFwnt+HbIJ0/Sl5ZHPrfID+sQix+it\nX6Z3veg2UyZOxNvLmc5fwz7h26OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeAF2cpYXXCWbp5mJIl+IR2H0WnMwHwYDVR0j\nBBgwFoAUub9ikZFVjdDOh1fTlORJutXMLb4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCbhR2xwey4/4QzpjpXpFMgEINNdwOR43Y2qzAyiuxdlQIhAP2N\nusHVw0S1cGeHI9ePZdgnFv7z9ZfUPhVVlKq6TdE5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd6TJNxysiYhbt/P6+wooTlqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWJmMDhmOS01NzdlLTQzZDItOWQ0OS05NTU0ZjJkYjMzNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcTqqwKhe580pSwQblTyG2Mt+JDrFeWd3NnyyfbeKLmsHQ\n68mVIXzrVKYjLDe7DJ/+gQ82VwcGNp31+2jvyDaVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUub9ikZFVjdDOh1fTlORJutXM\nLb4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFGbLOALH1MQO7bPzI8jDfOoAwhqwyP3PWan6AtUvbSoCIQDh31tFTDBE\nhCCFMM/weVS4dNU5/zO87n+8bfM/gOhFkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAXn0MoBTlPu0sOlvAspk9Us3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFhOTYwY2YtNDRjNC00NzgyLWE1YjgtMzM2Mjc3ZWQ4NWM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYWY2OTc4\nMS1jNTY1LTQ4ZTYtYTBkZi03YTZjZGE1MzkxZWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASZnSxytv+pfNCtgQDSM8/h413c47qVMy9NPb81xSGqKqpk4V5ac/Hg\nxeUOWtvtZJeNulSadqOdrvRbtEWum3+no1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4AXZy\nlhdcJZunmYkiX4hHYfRaczAKBggqhkjOPQQDAgNJADBGAiEA6Z0czde61Eu6lKZf\nJuMwOVee/V9KqKZnkAvGWX6ZD5oCIQCguwYjtbWPd4mvFdV8hvgVhh6tW3MtF47X\n5mKFuBEgQw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5865", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5865` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVyHdkQ94+EIdivmetNi8RMnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1OWM1ZmM2LThiMjktNGVjMC1iYmI2LWQxOGMxMTU0YTNjOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU2YWEwZDEtZDZh\nNy00MWU0LWE1MTctNjJiMWRlYjllNGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW5L2PWZwLMmZbD2YArxLwoxRJAHeh5NKgLcxmZpoQqBG0DYiE49uC1PT22uQ\n2gtOpVb7K8NGa/9brtFZWq3HdKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcIvpsyCqvu7PvhKBVGA3/fpz8QEwHwYDVR0j\nBBgwFoAUiZsG9C83Dvci4isVk1MxZc+dRgQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCID8dx0bgQnfT/jCczqYtKxti1LG4EtTsCNOcac4vYtGVAiEAmbCd\ns5wdVkH7j2BKa137SSccKpKmkOO+BNIfjC68U2k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQGGUMoiHkUa2fybkzFgaxSnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTljNWZjNi04YjI5LTRlYzAtYmJiNi1kMThjMTE1NGEzYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBWgAPtPdYJKdafD2PnB+Mm0GNTiaZpdmK0Up0EaPaXCuS\n0EFI8H54dpVYEu5QbPJJlmShqi4hzIiUEPoNUxsUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiZsG9C83Dvci4isVk1MxZc+d\nRgQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbDs7aQd3F5w0en/59E3B1RGo4qTZ00K6NLQYp/H3E0ECIEwoO+D38+Hw\n/0T81RMw0OfeRjJONjllEwYI7LeePlZH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAf7E4tDmGMeqA/bBxwssJ9+/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU2YWEwZDEtZDZhNy00MWU0LWE1MTctNjJiMWRlYjllNGViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZjU3NTQz\nZC1jNWQ4LTRmNzUtODM2My1hOWY1NzUyYTEwMWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQQWwdFKoxh2lvEueGuAWGRUEMeBmvD9JUqcmxZUxZMY89dpvJlPkXu\nvSfaOV7fdCAuGarjYK6aXXnHt6P5jQIto1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwi+mz\nIKq+7s++EoFUYDf9+nPxATAKBggqhkjOPQQDAgNJADBGAiEA4+6b/hPVoAe94dLJ\nuSHUBDbW6cSaKaUzynxCXdWfTUkCIQCKq5MsQo+ngT+iS2Ps3mBTJ5SztedSOhyj\nGRzVUFDREQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5866", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5866` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASgE8leL4t5X6HKGr7Rpk8pBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmYmYxNzE4LTg1MjktNDRjZi05MzM2LWFhYTYwZTIxMGVhOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjliMmRhZTEtMzBl\nYi00NzY2LTgxMDAtMDM5ZmM0ODViM2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGofaIMrI01N4POJb9KOWJCh46FSd/68KxCWmDedAkKHQ52eic8WuVwN04Q/g\nnLCt2AWeyPl1G+sAlm1n+OyVeKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTZVF7A0Pt0fpKSSFQ9SB4TqolERTAfBgNVHSME\nGDAWgBQu+fH0fIA/SNC0sjYzp3KwI+4BqTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCZxm6qer1Xy3WDQeSECFFZacbxRLtq\nTOjM6hl/WPW9JAIgIluM5zTIHzN4Z/p3e5CbKcnDTGzM70wzby0sorVkuSc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV0cR2re37FzLj5iGDz9/BPpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZmJmMTcxOC04NTI5LTQ0Y2YtOTMzNi1hYWE2MGUyMTBlYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS91rhfVvSgCZlUWazZ/+oLxJ0gB/oQiT+mbU6RO5CJVfJi\nejXTLfRVbrKOFRldYkuuKY0bxr6vEmOtsi9T2UyZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULvnx9HyAP0jQtLI2M6dysCPu\nAakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKsCCJodTwSxRIhLOQtCMK3QdS2mDlhtoAxcfq14KfR+AiBl86i/+tcC\nCe0i/b/VIvtAiQDKlf498emRQSgahn7uew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAVXzCPzu19TRgzmewZb3k7zDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjliMmRhZTEtMzBlYi00NzY2LTgxMDAtMDM5ZmM0ODViM2VmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZGE5OGUw\nZS1jOWEwLTRiMzgtOTQ1ZS1hNGYyNTYzZThiYTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATX0jlAjt6hzhZoeHAgWetSTEIiLf8qD6b1j7l2Ek5jci1sVecNMWun\nANwtMi6yL0TRXWcTmvUriKaVL9jtN/jeo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTZVF7A\n0Pt0fpKSSFQ9SB4TqolERTAKBggqhkjOPQQDAgNIADBFAiEAz8/G9DsCMRGBqgXI\n+vi96RoFs9gNaR9ey2lkIlY8lokCIEQGXvqGBhaQp21m73vbXOAEPD0qOXDgbHn2\nVBe2Dola\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5867", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5867` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAe2gAwIBAgISAUGHnOgsuTPy6heu3z4+oJ79MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4MmU2Yzg1LTU3NTAtNGU1Yi05ZjMxLTFiYmE0MzcxMjc3NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU5YjBiNWYtMTIz\nYS00YjhmLWEzN2QtZGYxMWRhOGZiMDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8mR3/adhsRpNsCbexCp0Zdc2gfQOaj/B0dlDiko7BIdA9K91miOq42V9JrGX\nGg0yL5JZKoIfyZhVJaN7FbHECKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzC7ixs+HPH3RnQSeky6YgOhF90YwHwYDVR0j\nBBgwFoAUTvzsBPPUut4VbYisPApyv48aGOMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0YAMEMCIDOjB/uEYMI2\n8oDdCSvB69Y2qiHi/cp51LdPBQsmjEP/Ah8HDx6C2I09JFj6V+OtEnOE6cchHxB+\nObR3Jlo13oX4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ3BvkS1Le2RjdGlfumihCRUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODJlNmM4NS01NzUwLTRlNWItOWYzMS0xYmJhNDM3MTI3NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQL4FstNwqjpj8v+bBfSH7SIFT6i0FdcRYdengcwtUgUzTP\nXM4Wx/ffb6pPoqQzjPiQDoUz1qJC90IjwhOu+Fv/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTvzsBPPUut4VbYisPApyv48a\nGOMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZNRZOFK9tynRwkn7XAmh3/zhQGd4zuydHm7xikRZMAkCIQDcaWTkDwC7\nQUVAu0KVSxjxtfT+hwjmYEbknGtr6rEBNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAd0oxpmEHpsm9JgIn0ylZMU5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU5YjBiNWYtMTIzYS00YjhmLWEzN2QtZGYxMWRhOGZiMDNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MGUwZTI5\nNS00NGEwLTQ3NDQtYTQ5OS05ZjE2OGRhNzI5ZGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASqOIH2eIDLrLqUuj26/b1hDoWevff9mRZkzGvmDkpI8PPW40N+MADM\nV+KS9iAZ+RvbwtkXHY9HF++cP1KjBo60o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMLuLG\nz4c8fdGdBJ6TLpiA6EX3RjAKBggqhkjOPQQDAgNIADBFAiAs7sVUGc8ywixRLLF/\nVKpyUR5R6VJwhSzxjUyWFe4XBAIhAO1YQ+wr4i6NXvQ1MEG9/DzfjYxk8DuzubwC\nWa84Hkmf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5868", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5868` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAfX/sGjTwC7vOWq0m78TvIfvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMjViOWE3LTc3ZGUtNDIyOC05MDA4LTE5NDRmNDM4MmViZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU1ZGYxMWMtYjU1\nZC00M2IyLWEzODctZTNhY2Y3NzNlZDEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbf8XpYIbU/DTRk8qEwzpNR80LnDyPIQEiZoQtlcrsFY1G45vlKY/tJKZh7Si\nZM1RlRXJmVc1SjJENwwO7sip+qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUacyM2Sy3BYsU9QwyQNXdacaHOq4wHwYDVR0j\nBBgwFoAUwDn0icMAMiAseGixDEYIoKMoO0cwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCIqPW+CX0o\nFXeRsrRERxUiDGEGxPc3OTnvJi9LWD1l2AIgNJwFi2jKUpGn03v/V1uvGdAmic2M\nAWXKoy5XwYtRZpA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdTAH8pmc/Zf/LLmCEFWW6/iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDI1YjlhNy03N2RlLTQyMjgtOTAwOC0xOTQ0ZjQzODJlYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOCJIkSPtMgPpGrWr4hGRucLMbDpLeN0GueGZcwlqPHWWo\nymntM6OsVLw1fc9NhsXCNOSJmWE2TPOyBrBlEPoho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwDn0icMAMiAseGixDEYIoKMo\nO0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANvFYpgqDTSR0AeW2UdZQrcr8BeVVRrl7uw70mVeSOW0AiB3tq316yE+\nioh2H+Wu5kj4Q0TVvxcIM8Vv8bTRsutZfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAdixqvoC1WEJ5+KGWXMugsG7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU1ZGYxMWMtYjU1ZC00M2IyLWEzODctZTNhY2Y3NzNlZDEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YTI5ZTBi\nYi0zMWJmLTQxN2MtODQyZC04MjgwZjE5MDg4OWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARpoPpUhvfXnf1ktyOWFcg/6WiKAXRIcMgoCi9/6z4/EXbkxl/zdNWg\nEGdlUEJ/cqSwyDjsSNmSDcCxcY7lg4r5o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRpzIzZ\nLLcFixT1DDJA1d1pxoc6rjAKBggqhkjOPQQDAgNHADBEAiBkpMijFaKvCbovR4CH\nhhUKv4YeESRPAGiUPeDK1vZRNwIgCybToR/7/AuOZlzz5HL+WuRQBrgCLt4Q8U1m\nNYqq7Ag=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5869", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5869` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAc/a7mARbvGE1s839Pk2Pt1xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1NTM2MzAyLTU0YzYtNDg1Ni1hNmVkLWFjNjFmYjM2ZDhkMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDExYTBlZWMtMWQ5\nMi00YTgwLWI1M2EtYjk2ZTRjYWQyM2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQzZonHQ1NGvlB1Tdl5R4SFJqXBGl6dn6jhC72uvjl0bKAoDpcFTl2/TmeXaM\nYb1aiyWj1mL4UpNGdAzvxG6eEKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQc6Ld0tqI5Rum/DMRardkdxDTVIwHwYDVR0j\nBBgwFoAUMzDxF7oAsUpQPqpnW5YpSlQ6dBUwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAIYqC/vZ7Q\nkGiBE4KuYPrW4sll07iEEcIbF2CUoR9WAAIgKZpyORW7fk8mz8foqMJafIdR+qMI\nvomAObu2fTJuwQQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYiI3dlJGGRP7X+N7h5l+ll1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTUzNjMwMi01NGM2LTQ4NTYtYTZlZC1hYzYxZmIzNmQ4ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFMo4xf+07B5VTFhey+Ic20V5n1mBUjVV3X/2eBebefz/v\n1Hvwl7o/2eYYAsbyM4GmsRX7P0FIU8qXVwSuk8w7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMzDxF7oAsUpQPqpnW5YpSlQ6\ndBUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIETTK5UbLyGCo/ERedcIjxKpuQ91RSnZIMq/rG/WiyjAiEA56mFwc0k\nCZ1uBT3Y9pcjRTV0r3FY/uDUBPB6RZS7TBY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAS495Nzq/iqjtLxNl6EIs3o6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDExYTBlZWMtMWQ5Mi00YTgwLWI1M2EtYjk2ZTRjYWQyM2NmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1Y2QzMjUy\nNy1jZjg1LTRiOTgtYWMzNy0xMThkNDAzMThhZjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARKq35+T33Vy9kbDmuE8UQN1+82ya48Bx/nfblv/OadaT8aJPWArqyk\nYMa3QAU7P01FgFNaDweZwtY3V1c9/5iIo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBzot3\nS2ojlG6b8MxFqt2R3ENNUjAKBggqhkjOPQQDAgNIADBFAiA1opZ1YLLvEmk8gLJt\no/ekVVE2WizLfIZxDpix8ZqutQIhAPw8wkcSbuuY92B/EUa7hHpKNTPwvTKipwAK\n/pgMlciU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5870", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5870` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISASeGkMbNAVZYqWPgFqAKN0rMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlZDBiNDdkLWYyYWUtNGVjZi04ODA2LWM3NjA3NDNlNDVkNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE3YTcwZmEtY2Vi\nZS00YWM5LTgwNDUtNmQyMjkwOTFhMmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE91aEVfa/j1ge74OOOauF8kyx3Cj+/KZrCyMmd1Vt2m5rqGEkUOxePELlDVbW\ncZ2UlZhJi+14Z/Nkf3sA7leRU6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXgJ+Qz3Ib4XqUAnxBQlyKmbgbmcwHwYDVR0j\nBBgwFoAU5yfNxpOkOlctK/xQ+/uknKAY0AEwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiAc1chqwdzRtEtqxP4uWBm9G8GHGHpbTyZQqppFdTBGhQIgaOZcUEk4pEE4\n5twBUaYelddLelXDxUbb49SXrr9BvuA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdSnNtu9Be2dvMqRN/TXLuX6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWQwYjQ3ZC1mMmFlLTRlY2YtODgwNi1jNzYwNzQzZTQ1ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHNrInmTENDQolH8NEEp23CLb9Z8irg4cHudf56bJiJQ82\nF/fX/7QRUxF6JG6xcDy9Xal+jPZJPPX3qXyv6xBko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5yfNxpOkOlctK/xQ+/uknKAY\n0AEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKWzWMyTG9rCbwf3lgohGU9CTrjwwWnk/rC1Ra8VqvZNAiAN13vRA6Ry\nQ3l38TtIWsouEbB6KKAbwSS4yq1lWh17KQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAZU6/1/hoExPDchb6SUQf/X0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE3YTcwZmEtY2ViZS00YWM5LTgwNDUtNmQyMjkwOTFhMmVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZDM3YWUz\nOS1hYWMwLTQxZTEtYWE0Yi0xNTA5NWFjNTNiODAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQp9hDJQGQq+/0eF8Nmsa+KLEf5G10yOu6v7zJYml81rOmY72ZvynJy\nIroBK0gwAKi4awwa8jWee3qRu911z8lJo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBReAn5D\nPchvhepQCfEFCXIqZuBuZzAKBggqhkjOPQQDAgNJADBGAiEA0l7NCsjauAVV3vuU\nLQc+MSnnRr+Mzk4Y/f2BjGfSeRQCIQDLsumTIFDXlgzSY7RMtijGWboZDr0U69EP\nsX/oxUSOAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5871", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5871` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAQiEOk5j7/kQPm2OtKRP6D/0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5NmIxMGVhLWY2NWEtNDhlNy05MjYzLWQ3MDAwM2I4Y2JhNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDllZDhiNjYtNDhh\nZS00OGFkLTg1YjUtZGVhNjA2MWUzYzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh6KOfYWJm4ZqI52COc4KgPsTpGCrNqbD8C/AJKraDNDDyIAMmOv84uS7EDwf\n6yLRQu1RvaePgEF2eeEb4A+NdaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbyvxzSETqfCX7LfHWUdMses8guAwHwYDVR0j\nBBgwFoAUReQn+msAG1ix9yW77oN5fIZJAGwwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAEBK8Jq0gbhM3iu6UYLt+A4ysRI91EL/ot+7JzoVz3pQIgHskrFFEapCuX\nPChvE4gkizvqJ0lndXluYt9y5I+EiyM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQyDxLBNKCs09mfdugKd0ZB/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTZiMTBlYS1mNjVhLTQ4ZTctOTI2My1kNzAwMDNiOGNiYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLvV2HElhGvm5u1wZqJeXrzVq8gPV4g0KqiG6BC32mouyH\n34bHZes7+U+iZI5yHsTRiqSXtTxF6JPBNsvielgAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUReQn+msAG1ix9yW77oN5fIZJ\nAGwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf0WhLVX/cg1cgPccvwROopqph7pRSpR258L7K9q7kXgCIBwxU5gDkF29\nDlPsWQ8qnv5fzlF/uMNM72Dlv4U90BWv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAd/0KPKgWMFM3ijMuMWU1WRqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDllZDhiNjYtNDhhZS00OGFkLTg1YjUtZGVhNjA2MWUzYzUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhN2FiYjUw\nNS1mOTViLTQ4OGEtOWVhNi0wYzFhYjZhOTZiNzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASiCwiy68tuoXVDH5eBYEoQ1ZSU3h+5ootOMn94yFgmL6FYTwpedLcX\n8pmzWQ2Y7AEiVKOgf70HHJKyl3oc1KoRo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvK/HN\nIROp8Jfst8dZR0yx6zyC4DAKBggqhkjOPQQDAgNIADBFAiEA1+pTGC+GKil7aYIW\n3t6Or9DEl6eLxCZJ0zzZOdKrC3ACIH5H/qiswsZz7aJdVoIvk4AWuIngGG+fuyiw\nnQ60Gfx8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5872", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5872` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAWiEVBnhmtQNNWYIqA7oWEFrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2ZGFhZjFmLTY2MmQtNDZjNC1iY2UyLTEwZWQ4NzRjMDNkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FlZTE1ZGQtOGZh\nMS00OTVkLWJhYzEtNWVlZmQzMjkzYzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERFGDF5uZWVU1aQRHnzKrWvHt5phZN4UtPqwGQcb2IZXwY2DShvJiYkOC0/Rm\n/vU3jiAfdvsLUyP+4/AmTyuj5qOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Sdiwd/OeQMdKg/vIrbNwN+0q7gwHwYDVR0j\nBBgwFoAUH8TO0nj7RvPuJM6RqaXH92NKeLQwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiB4\nIKSkwQR//ALwPV+flk/C8HrABM0gsJeA0VN78WnvGwIhAOE1sZFr8KbkVqSZNhGs\nbo/HCP/lfOejKOewowfQrZQ7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZmP8m/mDEj+XJ0bvum45FBtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmRhYWYxZi02NjJkLTQ2YzQtYmNlMi0xMGVkODc0YzAzZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASr1bldsNhxiAvzKM6t9LaqbaySDU3Pzng0rS5TZ3CTkvW3\nhJlkNpL74lwTsfkR3ano6Ug3Bru6id6sZnfrnS3Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH8TO0nj7RvPuJM6RqaXH92NK\neLQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOqfBjSZD683qyokqwJc8XWhwedi2Ry21LWcZqv2BqybAiAZu3leiZAw\nJYE2ySHs/KWWEUsQARbUjUnzmBK1liVhPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAdDb+4kDNqry3fYs7OdxxpjfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FlZTE1ZGQtOGZhMS00OTVkLWJhYzEtNWVlZmQzMjkzYzIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMTA4Nzc2\nNy1mZDA2LTQ1NWQtOTVhNi01MzA5MDg3YTQ5YmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASl5/KldBf9yVSa1FznquCV3FaiQP28N5HO2nonY6MBkGRqalrW++hO\ngniERgFmKgR5mkxj9OJiyL5F6xc41s4Ao1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTdJ2LB\n3855Ax0qD+8its3A37SruDAKBggqhkjOPQQDAgNIADBFAiEAxGA0F948c02NGyQM\nIkgF2fzJOUFOSsgbIf6c6rr+rV4CIBxslvIxDk+x5maA6NBlNg31VvKy1nXIHQYd\n+e0pEIH7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5873", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5873` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAUaIVOWqNfqSkcSnmVLMIA6UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwZjc5OGU3LWE4ZDQtNDhmMC05ODY3LTY3ODUzMTRhYjlmYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM4YzA3NmYtZGYx\nYS00ZjcyLWJmNGMtYjNhZGVlZTRkZDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBtiESPyi6qdmJMp5Spg1IQNgkPMV45TUMNKjxEv6GaiQLixLLJu48dxghbVE\nNN4zUPaxK/oDx/fF4pb2kq7TcaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHsZWVCB6WMcrufWts6+SITP3YnwwHwYDVR0j\nBBgwFoAUPe7YEfOQNE+IwAMuymOzHp+XlAMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA33JIp30DWOHXQZcJBKZQVGE6croKtmYppM7yMIjHCjkCIQD7\nD4ox8JrdeSJSFmIL6pjSEVPLC9iH13cDMBeOdrT0gQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa5z6RUg8YPqFDZHurw4hs1CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGY3OThlNy1hOGQ0LTQ4ZjAtOTg2Ny02Nzg1MzE0YWI5ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARICdL3VOwUBWSbYaNtTOclBQoFTWZeEGwBA070SABrvF9n\nCqEZ1g1Ac4R7V8GDyRUnG21bm0cJUTud/A/JXWKOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPe7YEfOQNE+IwAMuymOzHp+X\nlAMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ+VwgVRFk4NxtA6axui3FLCO/ES8JqJhH1kpM4+UmSqAiBUldQzYlwR\nWWGza2u7nGIIKNO5vhfiY6VOUU8nQeF21Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAZUe9iLjwHaJkUq2JAkWZ4aPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM4YzA3NmYtZGYxYS00ZjcyLWJmNGMtYjNhZGVlZTRkZDY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMTc1Y2Q1\nMC1hODYxLTQwN2QtODJlYy1mMDBkMGY3ZmI5MDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS5MlvjP/c0kC+xCrSIs/kmt1DC11suu7Ozozx8VPhw83U/ehN8v7U0\nn+Xu2/y6lOS7Dgf9Rkw8l3QtZxdmJd+3o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQexlZU\nIHpYxyu59a2zr5IhM/difDAKBggqhkjOPQQDAgNJADBGAiEA+tugYP2rU3ap8fNR\nS3BySMtfYbEu5Hix6OwvTwwlxCgCIQCzTnw8sfgPByPQDlWIHhSeImTiyocxBpWr\nOwlneCI/zw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5874", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5874` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAU9cfUVQELc59uwII4YhMUwRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhOGI3NDdmLTQwZTgtNDQyZi1hMDY2LTk4YzEzMDAwMGIxMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg4YmYwZDctMzZh\nOS00YTlmLWFmMWMtZDk5NzQzNmQxMGVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0eX9/mTbb0jBp0fuOCL2YwxUUT051ck0H2LN/g7CgDNJmMR2/wBneRdhUin/\ngoTEmvYvbpP2bAlqdED6VX/CoKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJT9jRa/rMMa0JPf6V6jqfpFwkhQwHwYDVR0j\nBBgwFoAUR9jsYlwDD7hAPukI+1qsVAn+LXswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAlWxPIrulXVlX2zuBUmkQHf1AZ8Owd6YJTwGDzSwBlb0CIQDM\nUvgNNqpfStaoLhvdZ5t2A7cENrCY4xlG5E3Ctt3dFg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQIf8um+QtiY+oHLRBjQ8AtdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYThiNzQ3Zi00MGU4LTQ0MmYtYTA2Ni05OGMxMzAwMDBiMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+S8uwZqbtelQHhgfj2vdIX08zKArapVYFMHIRuOKhQAwb\nDDZbyxU5szKYTP8F+HYldDXEQ3COCxAH9uBY2S4vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR9jsYlwDD7hAPukI+1qsVAn+\nLXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKATdBWH90ddMc+1MrTGRhTeXGzuaBX7MXxmA0oCqgn4AiEA6oFc9xVf\nZzjkCY3Ymbp36fJACvbexty/kBaZ5RxXOq0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISASvBe3F9rSHeF+zWYwzJij8zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg4YmYwZDctMzZhOS00YTlmLWFmMWMtZDk5NzQzNmQxMGVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZGE0Mjlk\nOS04YmQ5LTQ5OTktYTY2OC0zYmUxNmFmZTMwMDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASEsHutM7O2e1hOS8HUbY7alEAq9iE5vfkFuQlRSr9pearyBNL+54l8\n+COEMm7vAFJrjZ+2GCWi0ePLM8QtZTwco1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQlP2NF\nr+swxrQk9/pXqOp+kXCSFDAKBggqhkjOPQQDAgNIADBFAiEAlAvx8/Zy4EhOw042\nALRN2F3y8IBsJh701A+OlPCgEPUCIAa4m92gDuIu7jFnShAZAeT8skuz6IK7R0Sk\nGSi5+7iB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5875", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5875` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAcCzDHC8De/Wbwnb54A16gOdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0Y2VmNWY0LWVmMDQtNDZkNy1hMjFiLThjMzM3Y2I0MjYwYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ0MTFiYmItYzA2\nNS00M2FiLTg1ZTktZmU4ZWIwNGNhN2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqcQMKmVWv5yLfNGnd+eeAfZr8tQ4BBcR4/f1nRrwJQto9vaN6s9jI+GcpDEp\nypg+QJEIRbY/fxUJtLCHXTBea6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfY9uuAqgJ+euE2oe3a7DWctK0d0wHwYDVR0j\nBBgwFoAU2rIqJBLMyxcEMPxBXqpZufgrzX8wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAm6WlA3WH+0Ht\nDG/ywH8fqB/QSNeGwJ8juVkn7eKCVDACIQDxKDOgYmITir3hott8b55UHft6DIPT\nVgcOmGvShwAbvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZTwlzr6lDXJVFdDH+pJ+EIoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGNlZjVmNC1lZjA0LTQ2ZDctYTIxYi04YzMzN2NiNDI2MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR97mkYL7C7k8ayLYyx+tRE6TOIeNdAVNVJYA+cEyEFKtDy\nD3LuP6yHVMfdN27Xe19Ota8MK/EwU5F58wFvU6H1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2rIqJBLMyxcEMPxBXqpZufgr\nzX8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPjJztq6vZ+HPboIBj+Y2G7NOS6c5Ewk+dcTvKDMhjKxAiBlPLIs2EXT\noiedibDG+wiE5XAz4krGzUR/JH8f/zURlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAQgR2OpxvGF1tClWdazeY6AiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ0MTFiYmItYzA2NS00M2FiLTg1ZTktZmU4ZWIwNGNhN2E4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNzBmMmNk\nYS0zYzhlLTRiMjMtOWI3MS1hNzlkMTAzMDk1ODAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASrCEE3KgQqRHifEPCcjCpMyygF4Z731ysG/VxIdGg/XIh6yDMnBiUx\nB6qevHS6Jm8M1/K7EJjJCM6ol4etyjwGo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9j264\nCqAn564Tah7drsNZy0rR3TAKBggqhkjOPQQDAgNIADBFAiBjNEbh+I0XjRJkLpBk\nm2GHXi/y8Nr5DhJZ6u1JYzDlswIhAIdSsPVHFFuYlDKM/+pdnZuRO/xaYapmO4nf\niJlnmkfM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5876", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5876` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVtBL+wx5etJCGgfWot3TXbwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhMWQ1MjAzLTAxMzItNGVjMy05NjEyLWJiYjQxZDNhNjBmMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTAxNzY4YTAtNjFl\nNy00YTFiLWI2ODYtNmJmMGY1NGE5ZWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWbqNm0kokBoqA2d9sejk7KOIRw2LAGhF85qXL5Ry0TR5Rnf+DGzfFbP9WAW0\nSZfwVwv6vZg8cCFsHnfwmZTy0qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaon+TaTIb4L6hYQJPG9GRwl0lKswHwYDVR0j\nBBgwFoAUnXhX+P5vPOChu5vwmaZXl8ut5bswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC6zoq4ZRiWN7OF/2UDHWFceDDkdJn3M2JTqLYl38zyiQIgS5sXfINtm6AG\nTc0sMF7qp4dOBSqxyX7aNbd6ydlQi8w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXnD+tb6MzNAk0DAPpMm17wjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTFkNTIwMy0wMTMyLTRlYzMtOTYxMi1iYmI0MWQzYTYwZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiaBStvuwS9WyeoHs/VvBYx+r8LhTAFzOuJ4ysc8qKGEMP\nbVlbRCnDH7dyHMzvJYuWdgCO8kJRsUoPBJUH53awo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnXhX+P5vPOChu5vwmaZXl8ut\n5bswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANik3ZgS8J9Yb0RIwGpDgYIiFGVKp2rTBtl1Rn9meVNfAiEA8IrLQ2p7\nmchBVaIWJ3b4bahkqJ7A/AMuuT1ICVzre9w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAZ4fzM+EjbTOFK5F8XXI6AUzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTAxNzY4YTAtNjFlNy00YTFiLWI2ODYtNmJmMGY1NGE5ZWE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NDA3MDRm\nOC05MzdjLTRiZTctODJjZi00ZjUxNzRjYjkxODgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQOQPJF6hVjvzQqpdlrQalwJ6Oe2z6KnRoPqZZshydpufrm/IU5Gk3b\n5bXbAmFUcQ/6tObm1wJzTo+zrXXQqidBo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqif5N\npMhvgvqFhAk8b0ZHCXSUqzAKBggqhkjOPQQDAgNHADBEAiAJduqZ08F4f/kAUqXE\nV71S3FhG9zX9HVIzyTW7RYI18QIgXUg7U8elsnpHAnOvH2NeeK73IWbINAKo2YK8\nvpyiwA4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5877", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5877` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAXertBmEzMLWPw8GH3jF/e7sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNGFhNjFiLTgzNWYtNGVkNS04OWM4LWIzM2FkZTg5Y2YyZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY3NDM2ZTMtZGM1\nMC00ZmY3LThmNjAtMDQxY2JiYjY4Y2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvmpYppB7HiJUPYE5jHCSB6XzvoqF6/bTC5zqgvMvKN4JnLp+qbFSTL6QiaAU\nNzIQUWOdiHaLzs1J6vyZYCknXaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2vGwOn6qXb+nYwmcRE/JcD6DPyMwHwYDVR0j\nBBgwFoAUa8SmsZEqw2XxF3IXorkNGL55FkEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIB1MfUvlFsOS6u9MKO5DSyTnVVQ4P5gy5pinoIWDPUlqAiApK9dzT8xOgpON\n3PVxoCOZ8bowFbSlmKjPokA+CSRQ5A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaLafKrKntEPOy2hsi6tFpkFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjRhYTYxYi04MzVmLTRlZDUtODljOC1iMzNhZGU4OWNmMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8tAmXJbdkJsxIgk6WV+LZPFjdqdICWKK45YB4CN9/bVwQ\nCdAs+LBz3KVoDbqo8sGDBoytUO+w6i72amdhzbnJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa8SmsZEqw2XxF3IXorkNGL55\nFkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSKYSGFEt2zsQ7CXiaZu2knC8U9aK+SXtEMFqc29m+3cCIQCxKaZcNAi2\njbhoe0P3uXnvnbyAmB6rcqgnHSgKMTUf7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISATxLNhbk6r0Y0do12qG+rd01MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY3NDM2ZTMtZGM1MC00ZmY3LThmNjAtMDQxY2JiYjY4Y2E3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMDg4Y2Q0\nMS03YTZjLTRmYzktYmZhYy1kODc5YzA4ZGRlMGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQekaDB0zFjubZzHWtxX8ine7HWEjz1BeQM2NsZXueyhWYBJhBPznCf\nGezzcGjItEsLpNiVjIXh6SYU0VTuTolao1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTa8bA6\nfqpdv6djCZxET8lwPoM/IzAKBggqhkjOPQQDAgNHADBEAiBpp09sgQr/3kO9Pb7B\nS25TjnFIh1rnb+AO6KbGx1ARoQIgeSr96KUVZJb00C2ShHXa0FwrljkqgZC0ELya\naJzfwLE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5878", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5878` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAZgRU2rC7GPAx1d5K8do9ri4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmOTVjMWQ4LTU5MjctNGExYS1iZTQ4LTczYTljNjZlOTBiMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg1NmVhNjQtYmZi\nMS00MGEwLTg5ZmItZWZmYjVkZDllOGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOUbcJylYgENQ7nk5NTZj4/fQJVMG9Zgo3twfDeFZoXeCW2XwTyz5iDmthG6N\nIX/00Nf12GPw7jeqwrnMGykOS6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfx/Osqczt75J8uYtrabhUyN9xQUwHwYDVR0j\nBBgwFoAUSZKp2yVtv6G5vWHdyWlZLKbCFsgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA9t3Bi+uZ4ZzpA0W8MbMH1yG1BwMH6OGEVrviuDwU/t8CIQDO232buTdU\nEckC3tmSIigf0Rh+25IlNXsg1UUjumVX7g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAanA2endIdNoglGh+CkyoQRrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjk1YzFkOC01OTI3LTRhMWEtYmU0OC03M2E5YzY2ZTkwYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgOuHW/LX1lGFDr8ycpqXxyyba1nmRkNm50tqJVPJfrOqZ\nCAr/T1Ef1z/Ix3EWsHMnsafNh8Bm0fHavElnKr1Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSZKp2yVtv6G5vWHdyWlZLKbC\nFsgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKCgsk+zrXyG1VVDuSoBQIHz5oJw2AuSHUck48+qIE5rAiEAuBX3fpsY\nuQVzY8X5g11LMGMKcE4Ya0KlVcSP+OYFAM8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAZ1uUp6JKmIlcxKRqOumG4f9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg1NmVhNjQtYmZiMS00MGEwLTg5ZmItZWZmYjVkZDllOGViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMTkwYmE5\nZi04NDExLTQ5YTYtYjQ0OC00NWQ5NmY3NzJiZmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASEitn9ljypYrsBi+LZqfM0Dw663hdCX0Kao/Nce+KUZ70dwJWmEr7H\nfqvUTWiPb2+Vsv8DbAtQj6UPV7wkxfAKo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/H86y\npzO3vkny5i2tpuFTI33FBTAKBggqhkjOPQQDAgNIADBFAiApZqlZlxZMnzbQWjpj\nkmFJU5HpbZFDAZQ8bvnEX5QilgIhAKtDtoY+FspTCbYfyTfIi6gzewBP6fuHBRsn\nzdfuAuLY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5879", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5879` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAZUKvHQYuS6EYko1vNmOQ7ZIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4MmFkODg4LTVkOGEtNDExYi1hYmUzLTVhN2QxMjQ5ZDE2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGVlMzUxZWMtMDk1\nYi00MzVjLWEzYTEtYjFhMTA2MzZkMmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5bKxW5e4JEMFPFcN+CSAIkhJL+/UeCPW6zC+62CDh4kbLpccA9/YarIOLLXX\nRNd2P3rT6xBbmXbYmVxAhnsJ86OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUivk2CxwY8bLSL5qE/TnVCuF+ATQwHwYDVR0j\nBBgwFoAUszANcPmS9nOBsNgrdHTQulu7WSEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBEYQ+RggkIoo2/OG4MVI8Nr4j8UtDCvJ1wkcGmMubl\nxAIgHw/kUD4fRJFZ/8shDmHvtdTHrXfQrICUr+aqifNZweo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZJMKgbXW+23U+jhiax4ZDpkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODJhZDg4OC01ZDhhLTQxMWItYWJlMy01YTdkMTI0OWQxNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMdQn8089I+bguVeZ7BBbJo4uabXZxaiDFTLKFdOcRryOV\nA+2GXOSRxvKXFw7ZNUvMTiuSZLoo7xHZo68MZNtWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUszANcPmS9nOBsNgrdHTQulu7\nWSEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT/S6mD9BQvBGLH+lun4sIGEQDAAGu6bUwXvFGOcCl8sCICOaX3pqG7Sh\nYT0t1FbcXwVrVk/UdgSI84EEklE4Eyuv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAUExtEAnB+EPkI11GyRX3vsKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGVlMzUxZWMtMDk1Yi00MzVjLWEzYTEtYjFhMTA2MzZkMmRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MTI5OGY1\nYi02MGUxLTRjMTAtOTEyYy1lYzJmYjFiMTBkYmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATG7QxRBFhc61L7rzNyzcS9Cz/bIYiuLPCffPTqOUdUPT9mPmaHrQiV\n4KS73sMCgOkmV9pnBatEZv+3e9ZCgwIpo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSK+TYL\nHBjxstIvmoT9OdUK4X4BNDAKBggqhkjOPQQDAgNHADBEAiAnZzPXi3L2V5u2PWVJ\n/JY888SO9MWwhE0qTGoW7E4rKgIgOUl56hJj8ow13LM1vNaKCPpX9dGhLovhowNF\nc3zHGBU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5880", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5880` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAQwWzShxg03KQJgKkuB1qiWrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNDQzYTIwLWU3NmMtNDg5ZS1iOGJiLTI4Mzg4ODM2MzFiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ1NTliMWMtNjgw\nYy00ZWExLWFjMDgtZjhjYzA5OTY4ZTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELbba0Bz3RVSfSuH4XC2Yaynt3mYZJpVQ8ltHY9+caB0XnT5WWFJsUQHHukKb\nzNoxLhM3az1CJUrycuujryq3yqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNYB9Kh8OhPRfah2mUo+LXEaA/LMwHwYDVR0j\nBBgwFoAUDyeJxiTyUSwM2z3sUUecIJB1ZUowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiA0QiIratfj6OhWFQGarBxSmRS3PGPPNnQwcGMjjJGa\ngAIgRQh8d/PQr/vIL33fpShu3lGc7PbXbjPgh5vl5k4pUZk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWwF43TCjVGCZQ/ShyWXJbuSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzQ0M2EyMC1lNzZjLTQ4OWUtYjhiYi0yODM4ODgzNjMxYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATD5Qj4qT6eYTYeFqG82BtOzWuISFZCjtwuQx093o0sspeS\nqCnOtmHjHQdIJ9nNDH/IjOuB25+8PDf//Pq9HfFyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDyeJxiTyUSwM2z3sUUecIJB1\nZUowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbsMMaKJb9V9oUJYNJDueE4A8MWdtQeGulTB7WPhEJ84CIQDCb382I/3L\nrGJHnoGUjrdu/N/V5vn0+oJhmLT5nqAQ6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAcnEym7dzq79xP8gSpSxFSyYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ1NTliMWMtNjgwYy00ZWExLWFjMDgtZjhjYzA5OTY4ZTU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YzQyNWEw\nMS1iMzlhLTQxZGQtYTdiMy1mNzcyODNkYWI2MTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQaCK6RD1V/Q70jmxOq5Mw0rIINzIW7CRrjlutnMuMq1K7dBW+esjGo\nQkrOo1ShVNi11rvUWAMsyTQI2dueME95o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ1gH0q\nHw6E9F9qHaZSj4tcRoD8szAKBggqhkjOPQQDAgNHADBEAiAqMOfznsbHpetXJHio\nzeuibNp/ZKWr6yazxbHCDdLkEwIgGjbPimEPDdk3hyPZZrU7uCQiU8BArAgVCJWO\nuSK12mI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5881", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5881` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARbEdd6gmtQrnuJoQPNSPojtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYWM2YzVmLWMzNTUtNDdmNC1hMGNiLTdmM2ZhZTU2NjUxYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYyZjE4YmQtNTE1\nZi00ZDk5LTlhOTctNDE0NTczMDcyOTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVsxGzzuxCNEZ4L/nfIXGFDKKJZTkbmhQ7pr8RyE++7tvRDSECU+9cziEr/76\nYBgeVZItuF1ChfCXN1d8zmewoqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2GiPKbOULIntIV074rG1LFWIbEgwHwYDVR0j\nBBgwFoAUtSTlIMkg4DRDdWmUavtApX/mkTwwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAnHjLkSun8GxDVcszga/PVzmOnsrr/XUpSqMzZu+DBEsCIDvF\nPcVPS47GtxUX6WPgd9/ETxzDLQR3JY2sr+S/GcE5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZKMW62VwHFK6YkjlJ1hFaNuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGFjNmM1Zi1jMzU1LTQ3ZjQtYTBjYi03ZjNmYWU1NjY1MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9FvfpA2Khvbnzv1YLTNUck64AlKYWvCbYWdhMRW27sU6k\nJ7/7gLp5NbtO4tJeXV1k5bRjX+bQSLFNvE9MoRueo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtSTlIMkg4DRDdWmUavtApX/m\nkTwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHK+CteqX6Uw7IskFGiv9j8QMfq0C8QbUZRV54oi3GgICIQCjLcXIv1vL\nJ/Zb9Xn1H3oSv+YGxNCSQatQXg6N/BMJjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAbkswtdNT85LRiKDsAv4AgsSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYyZjE4YmQtNTE1Zi00ZDk5LTlhOTctNDE0NTczMDcyOTgzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5YmIzNzMy\nOC1lYTI1LTRkMWEtOGI1Ni0zZTUwODhlYzZmNTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARoLcsrNIp+SicrIykeuh8nfRqhbCIeUwO2aSCzVQ73xThy3Y9YLhE/\nsstKoHkmlLXaTpIkhFL06wc1TPVz+UQ0o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYaI8p\ns5Qsie0hXTvisbUsVYhsSDAKBggqhkjOPQQDAgNIADBFAiAvCmBA7lP3DZv4I5Ol\nQDulKmTkVPRj+sPiNNedqNUpEQIhAKHF2OZoOdaFqS8VBodGrWs5f7kLOYVMNiF/\n3apVYu7X\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5882", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5882` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAUO1XngBL5i02suT1VbEERMEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3NGUxY2QzLTdhNmUtNDVkNC05MjU5LTE1MjE3OWJkYTVhMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY0MWUxMjItOGQ0\nOC00OWUzLTk3MDItZDNiZjE0MGIwMGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJYPrIejxmWz08PNQFfrdoIgFE5KXhi7DCtj96M+UcvhRbL9Zkoyya49k3Mnb\nblcZSJk84RXy5WTqOO8c4b07J6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEWI4V8fhmqaTkDcOufR85jKjq3wwHwYDVR0j\nBBgwFoAUe4RFxNDKhohcIvVvGDZc+fC3Q0gwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBbDiAB1KMP4Vaq7sK9oXrge2uI6KI7mGxu\nUNa8QxvC7AIhAOZ5sUHd7FIwq0KITO4WCpiS+SjY3ONg1KW0cUV/R+Td\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZmodKqhRl3OvXHIm6bsgXOAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzRlMWNkMy03YTZlLTQ1ZDQtOTI1OS0xNTIxNzliZGE1YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5nkaKabBR+qBa0p145px8y+2ztB4JTNpcHbf/gzkd+k7V\n8O9XPHjWt5buKi2GF3blOAgjEh0C17Cisx3BaE7ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe4RFxNDKhohcIvVvGDZc+fC3\nQ0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaR88g5u6AKAQeiC/8uv2DOG2EMVcnEjYRDrLmG0QRigCIF/lFmC3DyDC\ndJEGM2n+mc+V2gnw4NPS8oThGcFNnlvP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISASBiwvHz6ydIMwHVP8s865mgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY0MWUxMjItOGQ0OC00OWUzLTk3MDItZDNiZjE0MGIwMGU0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMmU0YjIz\nMC1iYzVjLTRkMWYtODhhOS05NTc4NzgxOTQxYmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATtaBhOlWK611jFfnT/Z4h4wetfFL2T1F5FbnPSoABupscCV3NW6gBb\nWLXzoFOfnKhX9MK7t/mPFWB4/MEsag1no1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQRYjhX\nx+GappOQNw659HzmMqOrfDAKBggqhkjOPQQDAgNIADBFAiAr2hRdM6DLrQi7BDpo\n/FtKTU7rfZk3K3VhC3kLjWxA0AIhAKh93f9VucxBSBwL3pTwaKzh2T0WmqA1NBmG\npSKo6/Sf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5883", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5883` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAQyFZmK4SlWiwcC/5Oj+PLwIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNzc0ZTFmLTg2ODYtNDI3ZC1iZTEwLWYxOTdiZWNiYjNkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGY1ZDAxMDItZjg1\nOC00MDI2LWFjOTgtMGRiOTg1NTkzYjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeMBeGBGk+zovwatacUuZRzJ4xCiSXRaet0AOUe7gtFRJEEF+k8r/BdODWLej\nl7KZJNH+mUNPYs9k8woz4RQ0L6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxiyZkhyj8GJQcLn8Iej+u8YSdKgwHwYDVR0j\nBBgwFoAUVbCXMil2YBgGl79H1VPkV83Ue8QwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA2I9HaoZbtSguJ2Ht08uiDlxju7S6BewXl\nJxo9agvQGAIge1xkDV4FcWPLPfAKjCqPrc5q428nWIgtu6oSnaLcXQ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXeMegEwdX77XnOeuXHMfxZuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTc3NGUxZi04Njg2LTQyN2QtYmUxMC1mMTk3YmVjYmIzZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxbShyUPLSwH5B0jumoZvSLeV0kH+qIoANA7RrkbTmdQab\nNaS09b4QOnXiPVgscArdBrRplEq2jxzl3xfddel0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVbCXMil2YBgGl79H1VPkV83U\ne8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKoD9iF3VHN33o5olLVCEeeVj9vwpQEh5Ysfzt3tWuoDAiB7rt/WyODv\nmugGiRzuXBNAIZaO47W/IZO+3JLdM/SvSA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAX7vHNVb+Qo98fCwyVNn8y4EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGY1ZDAxMDItZjg1OC00MDI2LWFjOTgtMGRiOTg1NTkzYjk1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNmE3NGI1\nZS02ZWQ5LTQ4ZTktYmU2Ny1jOWZhOGZiZDk2MGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQN12cEew7g8YbCDBzszsyJgMTr9RgGRDK836E4T5UmsjsotrT6vmg/\nZbdN4cr9H9MD7o48Zve0fUcQbbqU9vjno1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTGLJmS\nHKPwYlBwufwh6P67xhJ0qDAKBggqhkjOPQQDAgNJADBGAiEAykFPxpxE2I+4k+Kd\ntMDBIlQYZBRb6epZ1juD/SIFOPoCIQD8+yix/6bbttDe+p+LD4XxZD9M6ZGzSNCp\nYgct+GnSPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5884", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5884` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAUqOWUYmpWuUdBfGeHfkYwvAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwYzE1NTg1LTNlMmYtNDFjZC05MzdjLThhOTczYzFjYzM5MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU0M2IyNTYtZWE4\nZi00YjUzLTk3ODQtOWY2YTVkYzNhNmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJCpdGn1nko6blgy5yE4kOfDglfKzPbgR3DFvAkVTmX99joCDw5PVqi4zo7Lt\n0rB999/8trEE/wMiGFJR7vIvpaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU10ZDoopbHwbxlPotj4coEuTlpCgwHwYDVR0j\nBBgwFoAUfx0XoWaMmjIB6I3llGUVPfUqYsMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAkgX+MaW4gRUT\nMRgkwhYumBqVXQmyon1bOd5yLCU9vEMCIQCFLeNVxoj7TA8RqxL9JjB3dVgFTlzf\nJmnqBdzr4Sf2kg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeY83uBLrATCiZ4NWmYXB6F/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGMxNTU4NS0zZTJmLTQxY2QtOTM3Yy04YTk3M2MxY2MzOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyxdsRkWvYr/FR/og5amiIFt6ouCgkmzZI+vRJQhU7MHS3\nU9hW3MsUcwBFPpJANXgdWmiNfxs+JgZnWxHaFIlfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfx0XoWaMmjIB6I3llGUVPfUq\nYsMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNWAcHw1c6VDM5pSfopLD3DWEvazNgnHiIeCV4Y1PycsCIQCVSfAn1DHZ\nBhHoqdVhEBPKIbBzE4k3lkMpEVgRA+2dHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAfNUnen5pPInhtL/2RfzXYKJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU0M2IyNTYtZWE4Zi00YjUzLTk3ODQtOWY2YTVkYzNhNmRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYWI2NmRk\nNi03ODI3LTRkZmQtYWM3OC00OTdhMTlhMDM3YzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQzGmKPFoxpR77TQ6DjGpHsmHajJ/YO+31Knp6YLgXWapAg715553/A\n4CTrRihGvHRB2GcImtz5UG46vIRl94Pyo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXRkOi\nilsfBvGU+i2PhygS5OWkKDAKBggqhkjOPQQDAgNIADBFAiEAqGn3MZTiE6C4FpEm\nRg8sZ+O3r5lZWNphqCPkKWQDSKACIGL1MVWcmb4zck8RnTFSO6z6Qas5n7EsANen\nikhF1r2M\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5885", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5885` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAf9zz87CMbWx4X7CDplFw35mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZTc5ZGZjLWM2MjAtNDU0ZC04Mzk1LTljNTRkZWI4OGIwMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTczNDAyNzgtMmZl\nMS00NjAwLThiYzktNTM4YWQ4YjI4ZTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjTZESEcVBpR5XitEn9E6YVuuJugGy8R7O9HU0U4srxXsxfGYzJgRPVhcneB3\n/H/i4jYzwtewACEzHbRyHUF1YKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1fiOCxqIaT3xLvT7H2pc3PrYz04wHwYDVR0j\nBBgwFoAU6sWeLIFYGp7u7xEfIw8Jgp3ixlQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDoN/nahvQmFTyrJoRR2yb+ORFc6fXNzerlKEQnYpo/bAiBdS5DieB69Uhi7\nfM18ArO8xYNYEse1z+RjXOKQK3u+Og==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ5VWzGn/tG8v9nVhgooo3tUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmU3OWRmYy1jNjIwLTQ1NGQtODM5NS05YzU0ZGViODhiMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQz0BOHLnHVS75A/G5kXXQOUjoCVy907bPpXPF9lDcPyT/x\nMyKhfXj5VF3WYaNyV086QFB/hYnbmJK1Vdw9TgF0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6sWeLIFYGp7u7xEfIw8Jgp3i\nxlQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZHOB9on/WyDGopx6EeRyTWO8xLXuKTg1MxY+4lJZJC8CIEGKH4fNkfa6\n9p8PaDUY2kMoovZNeOPxMAAcKaedtOdv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAfF1Xm0mX9bLGB0gJN3jsRIPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTczNDAyNzgtMmZlMS00NjAwLThiYzktNTM4YWQ4YjI4ZTg5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkN2FjMmQy\nYy0yZDYzLTQ4NTktODk2MC00ODJmZjQwZmQ4MGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARYengEDkLX/ptVknlS3kS1cVfOtDGvM9tPNL7u69yJA0WXrQ7Sd4SE\nx9t2gSRJw0d0TUucrJGNRKy7tBUdCmgNo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTV+I4L\nGohpPfEu9Psfalzc+tjPTjAKBggqhkjOPQQDAgNHADBEAiA7XVbnyT8DHHb8590h\n4pI/FdOKXsCIaP6gLghzAl6gwQIgTGmUDrtASaqpP6MDRq7NM9KPvOa79x5MYgVe\nEBbv6xU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5886", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5886` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdtJztCKhIQ1rKIkcZsU3vp9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMWFjNDMxLWU3OWUtNGY0OC04NzJlLTFmMzYzMDBmYTIyNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcxZjFiYjQtMzE5\nZS00NTVlLTliMDctZDRlNGI3NmMyYmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM86P53kaHSHlbSKo38ApvpdE36ILfv4DQUnQG6EN238+ZuBVIaN/EuG3jSOx\nu0e/QuXKCn8/uZKIq3Q3AvvVt6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMOau3Pp1OrBJrIej5IX/QyaP/HcwHwYDVR0j\nBBgwFoAUmyAwJcBmoNZvkBcLELTY6FH5JrYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFh74cQuiXF3epcFou4+QrEg59U+AvbrppAASZekYDVEAiBf13hY2v/72+pN\n/oDaJgQiUn3/AJTB292HdlEKa6/zQA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUjBQVIDwT0b9xLyUJK73ZXyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzFhYzQzMS1lNzllLTRmNDgtODcyZS0xZjM2MzAwZmEyMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6Uujr9+chOCY+KuDxIZAia8MnWOh5ADEIVGvsVlfQxRq1\n0TLMzLoJc3isR8xqsLEM78qJFiwdGy24RFqJI1aeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmyAwJcBmoNZvkBcLELTY6FH5\nJrYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE5TRH62kdmaPt6DV2gaj4TpHXQnfAbjiSHuHmsUcVSMCIQCGbTlDmJJx\n6nyrucszFR5tGJPnziSA/tHOFqD0EGSlFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAemzCydApKBNR77QQLzjnMMrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcxZjFiYjQtMzE5ZS00NTVlLTliMDctZDRlNGI3NmMyYmEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMmI3NTMx\nYy03N2YwLTQyNjItYjU1MC02M2VlMTc1NjFhMjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARjxA4IjmDo/Rk8vrXPgPjP6WsFs+RzSUMyql73PxBcX9wKBsFv4ZoW\nXzXCaKtdu19iJ35unDfVmQMYurx5awBZo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQw5q7c\n+nU6sEmsh6Pkhf9DJo/8dzAKBggqhkjOPQQDAgNJADBGAiEAvIbtaNvkb5W7UtPk\nAOE5kwCbYkM5aP2kIWFgaNygltQCIQDx5C+Jq8Ydf7jXiQ6nTAZs3MgssVEGzLIZ\nIM6y4De28A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5887", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5887` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAd6Rr9G8NxCTI/j3A4I+Lo3RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwYzNlNThjLWM4MTItNDlmYS05ZjRhLTM0ZjBlZjA4ZmJmMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNhZDNhMDUtYTgw\nOS00NjM1LWFmNWUtOTdjNjQzYjgwNTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERYEIekSFa4y+Fw/F31DXkihOePFEtNL9/hYakUE/OuTE19UegWrCYf/iwmrp\nv7yeZJujKA53ZeJGzZsoWAZZqqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqNNfs129B2s4mLRyrWHtwai55W0wHwYDVR0j\nBBgwFoAUZA5a5XT39reHjGVKuhUWZ83CHDwwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAwwLDcTPd1gy7b7fF11DHbiydKLYqdA2oU0dbNrQ7+vYCIQC2pj5F5mKR\nPn3rtb1N2U+1A7r3eSE8G2Pw+3nLavNJEg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR5yNDUMaV/Rwp15hur9d5fGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMGMzZTU4Yy1jODEyLTQ5ZmEtOWY0YS0zNGYwZWYwOGZiZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTzerkpoPddFqdvsUzYSqXs36ah8WKz4gwaNwst1KPUuOE\n04q6CMh1rxOmIj8YRwBD7h7kmpLRxY7gwBEpQg3Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZA5a5XT39reHjGVKuhUWZ83C\nHDwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAT8PQHeAZh+U6NMuiKVVlf+lmE4G99ZU8noUZdj9I4cCIEIFIKQUO/8s\nyDucKeLbZz92ztyOJJDvX17Y2ZFd0zAh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISARslULpRAimbWDupI50WhSrQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNhZDNhMDUtYTgwOS00NjM1LWFmNWUtOTdjNjQzYjgwNTlkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NWU2ODFm\nYS1iODliLTQ2MjEtYTdkMy1lOGU3OTU5ODdjMDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARzYjQPBGCfSaV0uYRn9fvmwv+aCtiyYqdWlRRPbSQy/DP+akK5ifpp\nDh9GE4n8smIHuRMQYK31lci2nD6oR5sto1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSo01+z\nXb0HaziYtHKtYe3BqLnlbTAKBggqhkjOPQQDAgNJADBGAiEA1J5nRV9WYNEWbZad\nsxGHwnAtNWPx781lhNLwqp+NplkCIQCm2+y8/+WypNQ81bS9fW90/Fq32zApKT5Y\nnJuCtmN0Xw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5888", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5888` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAaexA8OeDgbaUxR253nGR3LgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlMWNmZjYwLWRiYWYtNGMxNC1iNDJjLWE5NjNmNjliMTdjZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ0NTkzOTktMzg5\nYS00OTY4LTkxMzQtOTc5ZDVjOTA5N2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/TW90xWseX3FudusML8bgjPI8sBVIP0OvGq04opJQo1mM7pMs3t1jINyAwvB\nE2feZ9KPUBobEbASjBGniCUBuqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFrr2A92ns3/TsI/Vt5g4rXNx8gYwHwYDVR0j\nBBgwFoAU1ZUSWq4P6PZlIl1U9mm5axvv3RswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEArpuFy2DX44204/79LDMbGxH5L9oTG4biQBG+dtlw\nIeUCIDhjRgqs3YRrC20VgQYvQALU2Spyc76c3LkUOPIcQzDP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQO6Igy7chEKSPwaEQhC3G4lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTFjZmY2MC1kYmFmLTRjMTQtYjQyYy1hOTYzZjY5YjE3Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBABm8d59eTPzKSZRi74rX/nuYclz3kiNFWCamN5NDPRA/\nHzt2neRSSRNSmxgsYNOflPGMcO3Vzg9QAJg2pdaQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1ZUSWq4P6PZlIl1U9mm5axvv\n3RswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALvZrlJKX7GXY5Nwi1nay/tjrrCLpcjODWinAB3ti5FzAiBKK+oOtfIA\ngHFUnzg7CBc8irWiqb0LghRlzaGRdycWbA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAeDJ/534VGg3rFg1p6s9RO0OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ0NTkzOTktMzg5YS00OTY4LTkxMzQtOTc5ZDVjOTA5N2JkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZmU4NDM3\nMC1jNWMzLTQ4M2UtODY3Yi0yYTc2MDE4MmIwMzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQK3Ld6NzbdkLaBJ6T5Qbj14UiJP2llS82uVROTghhCnpK7oHJtMLvJ\nFumAx3fiTfRX/d8bwsH0L4fhSlHW+YPFo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQWuvYD\n3aezf9Owj9W3mDitc3HyBjAKBggqhkjOPQQDAgNIADBFAiEAnUb9qdxlj4z7edA9\nB5ldyd4xLCwaWwNd6auFzDtb508CIA8951XALWdBZZztD505zXmWSEmJxyCU7Jhe\nwQ8osgYK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5889", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5889` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVyvIZLIxDvigC1uXAbE5ZO+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5MGU5ODZjLTY0YTQtNGJiNS05Y2I3LTAyNmU5MDAyYWYyMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODM0ODM3YzQtMzJl\nYS00M2M0LWJhMjUtMmFlNWNkNTA4YTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwMrvmrLEvGWK70YHrf4UgBGavDezrAfzOHom5+dU05oVVqfPMmlPldAxm6U1\nzzo05aauKZ0+MQuGe46n6UCdBaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzo4OBrPyZ9A5vV8ZKPxYrXzmMWUwHwYDVR0j\nBBgwFoAUStPXHqs/NLRzb/S3VERc+y2jV4UwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBxudtJvpL8jbjtWqAdoUhWCmQVF1h5PqoWSITBhnjq\nbwIhALBSHvc2TQY0rY8hhXBsVoZFgE8VN/PQX8+rFw3/j4Zy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY5uoh8PLr3frE2IriVvE6jTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTBlOTg2Yy02NGE0LTRiYjUtOWNiNy0wMjZlOTAwMmFmMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYPPBcuBLMDfW9HLq/pscmGgvo9tilP3A7bS4t/tdB3Rrh\nVN14CldTL/NzPrmV4yXdEtzHrTUyGNPWDpWGXhYio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUStPXHqs/NLRzb/S3VERc+y2j\nV4UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgd/eJgONOu+KH688XpJq+agqGEi0XBAOLSBrlUxu5PO4CIQDBx2M5+3wM\n/qdVCYo6InPaU/4q1esLPo26vyIavhV+2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAaLY06PBdeQAhr4AbHCLq/paMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODM0ODM3YzQtMzJlYS00M2M0LWJhMjUtMmFlNWNkNTA4YTkyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ZjEyMTFl\nMS01ZTQ0LTQ5OGMtOGUyOC01NjE0OGNmZGU0MGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQGqjIxsCRbq07jmdKkwHaNgoFcKStUkcHNdJyP+ZgegZ4uDa52CfEz\nG+Wmmxvlv0ySRrp3LVkGFJVhzIar+nJMo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOjg4G\ns/Jn0Dm9Xxko/FitfOYxZTAKBggqhkjOPQQDAgNIADBFAiAXhivfAJDpkpgwNTnp\ni2uPAU8VdGl2p2tgj0V7mHEv7wIhANVSnmu20GlrSJzBsnWX+l8nPUWgYRXVIoWj\n0zGfmZry\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5890", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5890` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAXQucHYizIed5ObjFsklLQ7EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2NGQyMzE1LTNkMGQtNGEyOS1hYTY2LWI4MjA2NzY5YmRmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzEwZDI2YmMtODZm\nZS00MzA3LWJhZjMtMDcwMWRiYTE5Yjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4vkF8UAbAkmueQ/ZEWpOAxsER3eLTuSEY+A1zxTvelwK0J3KPi8KQ6g6EziZ\nSJ9JZqzSuwx6sGPOC/xgT7N9l6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI2aB5YnNWCmsf64PtAToTZOi2zgwHwYDVR0j\nBBgwFoAUNKgs9S0qxVpOVMgZl/CHlcYsVrgwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAiIXNS1bviuhXKynLLApY0BlK/J4sKwGcW4JkmuvYmpgCIFpn\nt3Y8uNPXuIpYt5y3slkJLW0hv13Hzy7DM+zFlyyO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfJrk7TNSb+yf+02iyfeE8+3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjRkMjMxNS0zZDBkLTRhMjktYWE2Ni1iODIwNjc2OWJkZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXzpeM0p0RlAvWLx1ke0aPiwP8A1vrTlRpedXtssGxagsI\noPe9qrMM3UFr9j6A95OeeLZuSzYjWFziv9QeVfSSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNKgs9S0qxVpOVMgZl/CHlcYs\nVrgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMSjgId7f+SUI8LoAzfFUZwop90OXWZNp+nCKbuqCgttAiEA1dvtcnX/\nk6fH3GJkn3c5G9wyc+dTngPns3VLxgiwVvA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAVgP43NKbaQwh6w8yCN3OcAAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzEwZDI2YmMtODZmZS00MzA3LWJhZjMtMDcwMWRiYTE5Yjc2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjOGRjNjhh\nMC0xOTI0LTRlM2MtOTc4ZS00OWFjOWNmOTBmMjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATx6PScrHEGNuGTAmzwH/A+zZIMR7GYPsA0/POsNwGo4JEhbR7i2vu7\nzdwQ1ljbTN8jr0nj0XDDib7ctLWjmNAko1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQjZoHl\nic1YKax/rg+0BOhNk6LbODAKBggqhkjOPQQDAgNIADBFAiB+91V2wKeXg7Pc+ZCZ\nxu+HaXvyiAUZJkiIjToPTL0dTAIhAMUI9A2IATxhRTq7QTTYWTO/S5Ul8mV6KF+7\nPwnvvwvO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5891", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5891` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQ51sVxpwNSAirQOwI6Xh+/sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3YWVlMWRiLTRjMDEtNDU1Yy05MWY4LTQ4ZjEwMTkwMDBkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVkMjFmMGYtNWRk\nMC00MTZhLWI3ZDgtNTAwN2MyNDg1ZWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhHxorZJEegZC4uZAJej3lnGW9hS2tuTYZ0GZL8I9QNaXO2T3iA79zubbP+0n\n0MR63gH3nU/loswD6dDXWJ1NRqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Eqe4J0d1yMjg7IjiWd6w8Kl4AEwHwYDVR0j\nBBgwFoAUBeZCw++Hkmub/VknFNTYjNEu1w4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAndNYMwORAVjROgYkbVbm90PA4s/oNuyn\nhEmkA1XLZXkCIE/BmBoDtGq1X0KI7F/liluFnIW1AvE1o0N3EAkTmoBa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQz+wz8JvAqDwseMmn2GBUxIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2FlZTFkYi00YzAxLTQ1NWMtOTFmOC00OGYxMDE5MDAwZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlACK9qhMBRf/JNTRdAq1MWF0VmXOtUUKPyS/F7jDBKM4X\nitYET7H6/tP5Ht9Nru8dcZ4ffDrHhGJhXxIlf0pco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBeZCw++Hkmub/VknFNTYjNEu\n1w4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeLmr3yL1C0OpW8fAtnBtGycBXAsOwXr5aPpd1yTBfjoCIBj6S1nzX3s5\nXpj7Rxr4lX+hy2c+aspJBYvL2t7QE+4t\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAca8F7+49/Pf1PhEUtvXujHHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVkMjFmMGYtNWRkMC00MTZhLWI3ZDgtNTAwN2MyNDg1ZWM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNzJhZGQy\nMy03ZWMzLTQ0NGUtYjdkMy1kZGM5MTEyMmM4YmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+/xM5H7x2VUU4QFmTvuwrGRg7CXQJ9ll1imPr6Je+6+pi8xmlmZO6\nWp6R8BaDQJFiwDfvLU68ntobfCu6dPk/o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4Sp7g\nnR3XIyODsiOJZ3rDwqXgATAKBggqhkjOPQQDAgNIADBFAiBOA65ywiMM+KJ6KLay\n4Ih9fLWDz6tgysqG1xi9pOTujQIhANJu2cFh6/NjxtsEFq5XxBq3NBeddaYLy+du\nMcnTIY3+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5892", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5892` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAeoWox+Mun3vU4TQRmx5MLHXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkMDhmMTcwLWQxYWQtNGFlNC05NDE5LThkOTYyZDYwMWRlMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRjNjRiY2EtN2E1\nYS00ZjAzLWI0N2QtMGM5ZmJhMGEyMjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqhsqtGwxe8Zw+WMAhK8U3uV9zV5lx6n/tpnNcwvkQmP6dO1FPnxiaL/F1Sgf\n9AsYtfmIh/uA+DkSlR9AuzE2DKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkd2pYRIOK7+DZL/4wNmdXBMt0zowHwYDVR0j\nBBgwFoAUBxJtMGf54iR5j/HhT04gtc0lDtswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBUJEqHxh/uOqOfgt9UG57CxVbIdo8n/8OU\nsu5sDd01xAIhAM/oZFkeWYjsxPjIAHUK9Pwk6beZjWPakSry4kJv/Cqu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb6AAHsqYXJu8WRe1ApIGbEBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDA4ZjE3MC1kMWFkLTRhZTQtOTQxOS04ZDk2MmQ2MDFkZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5NTgQ+xP6KmUjkFwpKxkuH5JJj3ZABdzEeEtY562nAS5V\noMeh0wY/qj+yfOtnW7rCClUcN8Yhb7GIdjCGsf7Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBxJtMGf54iR5j/HhT04gtc0l\nDtswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDaNgI5Qcy1ppUeK5vKTpUaCyLQNlXUUW741wpnHntxgCIQCwq6qg6nEx\n5qwrdT7k3jivVptlvJhzvdopGMMPcfqFTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAa9Nlp00Grlso8Yww7/c/T04MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRjNjRiY2EtN2E1YS00ZjAzLWI0N2QtMGM5ZmJhMGEyMjI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZmFjMmMy\nOC0zYWY1LTRlMzUtOWI5NS1kMjQ3YzM3NWZmMmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASxmEwQ7RX9xoA7RaQsulQIjWrOiMg9YAEjrPsOC8ltWybwd12c6mj7\nfiHUyvkmL09AW3+pf0Ri2F8SzssE8noso1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSR3alh\nEg4rv4Nkv/jA2Z1cEy3TOjAKBggqhkjOPQQDAgNIADBFAiEA9cR7/ZnmI3G08Xw4\npVUKnwE42zlUSJh6NYfZWXy948YCIDlT7Ckg//f9GYZGD3gqkNQjhPd8u4B5GI7i\n5aWdKEGz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5893", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5893` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAXbNzX+hbr3O/T/He9zUtUvZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4MmFlOWRiLTA5OTAtNDQwMi1iNWNjLTNlMDFlZTY2YjBhOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM2ZWNjZjQtOGY3\nOC00ZTUwLTkyMzMtMGNkNmE5YTIxNzgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwpeLeyJxdy6kZ63mjhiwnZw9NNyGIt1k9sG00bsrYj5//Ll8Uj6GHNzIiLKP\njxUuFJz4nflrlAUc86kxTMJVz6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvFI3DxyVuo19lYctnx2etJX06kcwHwYDVR0j\nBBgwFoAURONHryZPZ5J4ak0tsC+6gRx+/vkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC2ZPNAMpWAcG+30fQVUKkOd/kq\nstIha/KURBNyKcu/8AIhAJKNKLkplX3Wsm0cV0D8Z9daJTnmFxVYKmPoH6KBI75v\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT09eusTf59tNj49Fh7cD1ozMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODJhZTlkYi0wOTkwLTQ0MDItYjVjYy0zZTAxZWU2NmIwYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxSEnEJcoi8LRXDXt+zAg6gVcYPlBfFvIaqaAt2p41E5oS\nyPBEQAhIUo+26yW6RD7wJN7MD62IpwSE5us9ELqoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURONHryZPZ5J4ak0tsC+6gRx+\n/vkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfWtxT23+pgs3Fstm7ftenzsLcaGo9b1kNY76qC4GiDwCIDaH/7+3P43f\ndTWyEOX8YphlrxHsP3DPLVNI3GfxoEgL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISARESO4CUlw2Qt9FoOBtyDMz0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM2ZWNjZjQtOGY3OC00ZTUwLTkyMzMtMGNkNmE5YTIxNzgyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NDJjM2Yw\nMC1jOTYyLTQyYzctOGFiMC0yNzA4OWNlYjAzYjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASSngGetVhCGvL280qFck8mvCrUcR+hyTS1gF5OJBMEwwBHqdo26+Zn\nSG+53Qdq9VXV1k3pSqgELGJ7mg7Nkgpio1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8UjcP\nHJW6jX2Vhy2fHZ60lfTqRzAKBggqhkjOPQQDAgNIADBFAiEA3AEAKQfoCbafFddB\nctjqQLB49aReO4QB9rXVauaD/fsCID7eE4Sp9SRbTCA4aRRnz6YT9LP5cnIuyx2m\n1o8rwX5w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5894", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5894` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAUpW5S9fuAQ2wPL9bt3DSfuWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNDIyZGJmLThkNmEtNDdiZS1hZmQ4LWEzNTI1ZGM0ZDY5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NmZWRmYjItOGVj\nYi00YzY0LTg2YjQtZTEwMGM2YThhMjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk5TplRw5AWg8V9dIHD+T2Eb4jVmxPUeE6Qytc4DebIjIxAS5sUvyfwDyYCKx\njFVkILVfT34qRezghYPrWF/2JqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoYYziMtcopQrCgj0sqepqJWiAowwHwYDVR0j\nBBgwFoAUMy2YeJ8e0ZkMxG/nraRKm4hu8bgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJ6mIfcr\nCg6XJKI42Z2PMxrPQj4y00rfXv0Zvhn+8hKDAiEAml3Av+jDIMflnjdF4GSXAmc0\n31bXUNEFGDFAR6OsPQg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUHtIm0wU8axWz9r2NoJj+H9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjQyMmRiZi04ZDZhLTQ3YmUtYWZkOC1hMzUyNWRjNGQ2OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfAk5qFKZxOcN8dKgKWG2869V7jU6UPflA1aTH9RiE/NKZ\nwdvkB1K3XcaxJe9c1EpBDA1XTf9WFxL/sOjAOWblo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMy2YeJ8e0ZkMxG/nraRKm4hu\n8bgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeZsVb6gKg/9wJmWlvyOvZw93E/cpYs7TSr4mqNbn8WYCICie/WFh2lg1\nLEMWdJ2BDPEX/K4ncICSukT61bBby9Vo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISATK5Kgd7awWZyBl9ATx3M5eNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NmZWRmYjItOGVjYi00YzY0LTg2YjQtZTEwMGM2YThhMjRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NmUxYjkw\nMS1jYzE0LTQ0NWQtYWY3MS1jMjgyZDE1ZDJmMmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATYiIaBhUtJkAdJG+JlhL+H7k8A1RwK3vnr4ZRgW52is+Ix/R+rHAgo\nbRUa1hGEBZohCLTl9k32oIPAmNl0QpFvo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBShhjOI\ny1yilCsKCPSyp6molaICjDAKBggqhkjOPQQDAgNIADBFAiAZj+W41Gv9BxsTlYdC\noojqWSidij9ONnNmppRYDmAGZwIhAMvmlBhswAewo0Pk8s4tlmDJsnTjL0IE+Kua\nAA3q2j9H\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5895", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5895` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAXV9755Qo8Jos7Olj7iFkTUSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0OTM1YTU0LWM3NzUtNDgwMC1iMWM0LTVkYjU1MzZiMDJjZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA4Y2EzZDctYjUz\nMy00MGY3LWE4NzMtNWI0N2ZkYzNmYzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeueoY9zgDj01JbxKz/hG/Qb8cYiTVOOpIaU+bC17W81pTE4ObQLHCmckNaf3\nywAUGxfhjH/Xgex+OfcoUYhOV6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPtf42gPEea3Fbjxno0xP2e4wuLkwHwYDVR0j\nBBgwFoAUS/cg/mspGn+USsFjU9M5+2YAAFQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAI0FGoSm\nCPFS3ZK7twXJFfbm37ombLiTpMFdkX1o9CaQAiEAoa8m4nVDasOzP0lveB97c5FZ\nAlX7jgaKqitmNWYx1Fg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXZyiYPur79Dvd1uP2ybRbXoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDkzNWE1NC1jNzc1LTQ4MDAtYjFjNC01ZGI1NTM2YjAyY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMqqfuQZpDkLUZz9XdOcZVJFc+Ly90M0EvCChb5oYdyjTg\nozOMPn7uHDlFcsuixaHtyUlGYp0HBaU5LY8mDjJfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS/cg/mspGn+USsFjU9M5+2YA\nAFQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANFXrG5Fobi6oviV/OUJIHpqB1lBOm2PyseTY4NYdpINAiBHUX7jgPa2\nLcrKzCHUvvf5iJ22yoqZUR75Wgl/Q1TaWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAX6TIQIxn/KjTPhsAZYuFXs8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA4Y2EzZDctYjUzMy00MGY3LWE4NzMtNWI0N2ZkYzNmYzY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZGQ4N2Mw\nYS1hYjk0LTQ2OWMtYTYwMS04M2I0Yzk0NjllZTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQP2ZjGn4NFuVSjPgCCHkMyvis6vqoQ2SokZE9dS5MYpdK/9DF3ozHz\nYDoSTjysbXI1KQJ9uMiudWeJNGbmBbXQo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ+1/ja\nA8R5rcVuPGejTE/Z7jC4uTAKBggqhkjOPQQDAgNIADBFAiAiPoEu2wXVDBUo+Zno\nDpsVw+CGvKhMltSJMS8B2Kut4gIhAJaaSERcA9tAfY4x912Iv+2O8o1iYGyJJjKa\n1KVrjrnf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5896", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5896` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAbs0OmNBeg1pLfh+kZobeExUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmMTE0MzI2LTNlYzgtNDU4OC1iM2NlLWZmZTNmZTI1YTlkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UxY2FmMmItY2Ez\nNS00ZDM4LWJjMzQtZGY3MTQ2YTQ0MzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYtEqJTL1CNH1cCiUl/NJzAC7BlLfFmOdT/4lU+sIDlNbPPdbF8dkyHqBFl8y\nq3of5mKQxlcHK/Y99KLOd0mZyaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURlCZzP/+5R5Iupx3qi68S0YZhQ4wHwYDVR0j\nBBgwFoAUUdHf0rwKOGUwxbVmb68r6TmGsqswLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFWkT8PO\n9q7qs4VL3Kon3Ip4Sg2itV2MFlnM5ny2QtGzAiArr1CfWP/AKVYvnlIgqAn72seJ\nfFID0+5pPGcczXrx5w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS2gHt4TS+LM7g+NZ+VYAOPcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjExNDMyNi0zZWM4LTQ1ODgtYjNjZS1mZmUzZmUyNWE5ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStTqDdkLI4fs4rHX+xfSGXJHlP/Q2GkmhKgNNeP7huvL9F\nfM1xRtVvFB3ec/0UquAItOFs4RYHQi6u+KEtrfWLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUdHf0rwKOGUwxbVmb68r6TmG\nsqswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS4L3jezE/L7VxEb2W0wmWl0r7jqxnFMj86AoRksOoVICIQCVnl9zIxQV\neOycPm3eVcihbVipf5ISPXMm3oHbmVKifQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAUU+fy/i1v7o7n/MU1GSeIxLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UxY2FmMmItY2EzNS00ZDM4LWJjMzQtZGY3MTQ2YTQ0MzMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNmU5ZDlj\nNS0yNmE2LTRlOTMtYjAwNi1iMDExNTg3YjJhOGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQi79LVY/hXbBsMOG87QMVWu28cHhdTz26YRc0+BoB/HmNZgzi3Mu2S\nkuE9eqtsbUHuf3sfHeSsqeE4u6MmbZQKo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGUJnM\n//7lHki6nHeqLrxLRhmFDjAKBggqhkjOPQQDAgNIADBFAiBMgLlxoCjFLnIA7HmR\nN7YdqmX/Hsn8rtyYqg1rwh4Y3gIhAObkBu4qJxfzFjQ/70gJz0kb4zZFTRd4dZTt\nB7pKaDN0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5897", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5897` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAbvvlUgwVv6zHXKMZELyqEQKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3YTM5Yzc1LWE3YjUtNDkxOS1iMjRjLWZmMjlhNjA0YjA1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FhMWY4OWUtMTQ3\nMC00Yjc5LWI3Y2UtZjdiNTBlNTdhOGNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5VOBt1RkCnzKiFgkPtZAUVUePoD/tIYwHKf0n1RgCB/iwmVW7bMsDvQhEwm3\n8EM6LoBKEkl3oF5m6dL4vggjaaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPRqd/ps59vltdLKhxScBtRtWVdMwHwYDVR0j\nBBgwFoAUhbIuMoQQkwLIQa1eE5kbnfu4/bUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCYIzc4/72PZIuQoUGJQgfEo4Wa9xwLRxqIFooXPNxqNAIgRdWE2Wig\nEQlQ6nAcq3TLRrqCbgFJd7EdFh7CJH9xPmw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASoz6hGNXvicR6yz2K910Gv9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2EzOWM3NS1hN2I1LTQ5MTktYjI0Yy1mZjI5YTYwNGIwNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATr62g44N9ZWCwCh5pQKqr/TT98ppBdD4c6D0A0XFLM1+N5\nikqPNcuAUsZCUmrpcboUlYPBtOZHMAcKSvxylafwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhbIuMoQQkwLIQa1eE5kbnfu4\n/bUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN/sh631gxpiLRtW7QI9eqzLukxXp++DnZJzoaAIw6ykAiBuxnhmRCKM\naNA3ffZjkBkdCLJ3NrQadSuEG3c1M+fiAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAc/VoVIuvpBrnJHzJil1Gsz2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FhMWY4OWUtMTQ3MC00Yjc5LWI3Y2UtZjdiNTBlNTdhOGNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MGYxY2Nk\nNy0yMmEwLTQwMGUtOTM5ZS04ZjcyNDUzMDFiYTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARQIC6TK9dPhN2SUaZYmpRJD6iUTfA4Y+z4zbVvLqAYSAQRIenmUTmb\nHBTXi8s78FuFD79a/lU5Og5s3lfQUzQso1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9Gp3+\nmzn2+W10sqHFJwG1G1ZV0zAKBggqhkjOPQQDAgNHADBEAiAXJhJ4c7FvdChTkR57\nyDWATemZ80Bu8qaxe4HCZduhLQIgZDDMR9LzdhIHyLIwmz38s6j+2J0IdiH8du6v\nWpnruNE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5898", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5898` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAZXgAugh03MGQ+ZD8dP3MPmLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1NTA4MmZlLTM0NTctNGNhMC1hMDgzLWQ4MTA1MDFiYTIwZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTgwNmUxN2MtNzUx\nMC00ZjhjLWJmMTUtZTU3MWVhMTQ0YmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAMtXSqd1iHrK1oYiOf579D95YtBslAVOj0MPp4N5M6j5V3YoloGm0ac9FjxT\ndmajDO8JaOUlhuOjxy3vQLiOXaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhUcq6+2ZQM8oaCpBWah4XJw0420wHwYDVR0j\nBBgwFoAUp6m5ALC6VksBThhAd8QKse/NsgowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIADA/PYFk8Yv+MnDzmuvDix48Shb157cxTMX9Ztc80ucAiBrlkGU3sz0\nNfiW+MeTr+VGsDE4q9nDDxhemi0v17C9Nw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY/gN0mFoOJ5UDQbJGHJcfv1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTUwODJmZS0zNDU3LTRjYTAtYTA4My1kODEwNTAxYmEyMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWuCXcRU7LPdVCErC3kbDJsV8FuWmw4E/lnr2fXjp5yAga\n1/G2gpLQKPDIzQ2xAxIDnnMkA9mkKxpBorLT0DUAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp6m5ALC6VksBThhAd8QKse/N\nsgowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKNwUmWCH1g2hO3nobwPjYxOg05679zEHnffpIcwJzidAiAwQAG5oU+d\nL2GBRxpZepiMZtQ2VR+0bfTAW4WTHBbP0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISATMyN5wyheud9eJIqmkT6OwZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTgwNmUxN2MtNzUxMC00ZjhjLWJmMTUtZTU3MWVhMTQ0YmEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMmQ0Y2Ey\nZS0xYzNjLTQ2YzAtYjIxZS1iN2EwOTcwNGI0Y2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATNy2CtJt+bC3vBwEAbW1iHF7aAmHWnAdllWOjyN1Jrwq3A3Vn6Rkaw\nOiyVpRumtiE8jY1ct4b6GjL2sZAt6IZio1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFRyrr\n7ZlAzyhoKkFZqHhcnDTjbTAKBggqhkjOPQQDAgNIADBFAiEA58qHqf7g8P8erR2V\nStm2ESamfHckxS8AWs2OH/f+OQACIGyyIs5slqbx+vV7JamnBq871cyaRf0/WcJ/\nlG0c4BNV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5899", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5899` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISATm7sbtOC2RN6uq7LLLvh5V4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmODQ2YmY1LTNkNjEtNDIyMS04YmQ2LWJiY2VlZjk1MjBjNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRkMzVmYzEtNTVj\nNy00N2RhLWI1MTAtOTMzMDZkMmFlNGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgbbLXxmIHRK9zqHJJuzbdz8VL1Nyfx0pzxP43wY0x3M8meY8OtZfozyNhOYM\nj0q+uT6/NkYxop/Ka50DNq3azaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfYjHPk+64Xjw79xvKuRAVkwmOS4wHwYDVR0j\nBBgwFoAU2UfXK7LmAitqhOM5kwFAK48P8TkwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIE9gWAcxTleNKMaZ2JnL9yIl69RMrJLFNIXRM7NiP67BAiEAz90CTpSzV1uDHFw5\nbljN2BfWiWv5RWtrxRXHCfR315w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfRQ2RB5LHP+G2wl5NVvuJjQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjg0NmJmNS0zZDYxLTQyMjEtOGJkNi1iYmNlZWY5NTIwYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCXNwPaJAUh4FqYPfz4V3Yu/7bPjsOjdwW6EtIaCMUREqi\nFGuvWE7Sm4uM9frUhvSHgz3n+CbmcConLMmvssHXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2UfXK7LmAitqhOM5kwFAK48P\n8TkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYK7sEsCnScj5mT8lNoz9jNhRQEXDOyb1Vce/j/yl9wwCIBDjlExh/N78\n/P82UbJun5eoieSY4yhy8oy9NKXsyBcc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAYCt4wmmBZ5Av4ZZQO0Je4YmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRkMzVmYzEtNTVjNy00N2RhLWI1MTAtOTMzMDZkMmFlNGFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4M2M3ZWZi\nYi1kMTJiLTQ0N2QtODk3Yy0yYzE5MWUxZjNjZDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQPQ8BC01nkrwwRtnQAJGzNU5vC6OsxSlTHGWH+pIm1mzlq31ifd2+f\nvyr0+c9GfvdyTTo+0dNeRDEC+a2ICI9eo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9iMc+\nT7rhePDv3G8q5EBWTCY5LjAKBggqhkjOPQQDAgNJADBGAiEAoy/WdJLk1myFiGpB\nCx6Y1x2FOMJ0iZxDPXpc2HmUFngCIQCB4+3yVtHjC+U8/Yh+5Tx17yhtUfL9TANX\nRl5anKJFYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5900", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5900` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAT/HhIwhxigMPVS3O0u4oaXdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhYzRlMGY0LTQ4NmMtNDUyZC05NGUyLWNjMTgzZDViYzFlZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjkzNjc4NTktN2U1\nMy00ZGJiLWFjMjUtMzMyYmY5ZDE5ZmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7La6Gke/Wwp/vHR+e2jw/22If7RLRbQ1b9yuMf3ZGEWDp+8+3P9IEn1ztems\nKD8rPA4FFg/ePvrRgpaJzt5tzKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjtL5ygkaEvHRzux39yxYHVxjnOowHwYDVR0j\nBBgwFoAU43BHlqOlEN+Adfm1e2qL7DsJencwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCaT4JQS1oTUna24NOWMzy4KsXk6dRC0jjeGEZpY9j/agIg\ncOZRt3C4X6fZON9ZH7nEeFEktfi8aWolRt9O1omIwgs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWJpbiMJUmp4Gtss6RvoIO8aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWM0ZTBmNC00ODZjLTQ1MmQtOTRlMi1jYzE4M2Q1YmMxZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVuZ+/QPQNgxJ6ce+14S1hbhh+bpdp2OCgDVAI7cd7qUPr\nHeBeJXNlGOEcFU5wYT/8scotAKiWct3ibDLHvWP0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU43BHlqOlEN+Adfm1e2qL7DsJ\nencwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDBibgy1lpYcRkrc3dk/iTUH03V+PKteN+dtW6qzIe/cCIQDrFP7Ubpzr\nIRLJ1Iis1kNUfz6Pmt6XxRb3tojGoqO0mg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISARbDKcbbxxIogkCCN9fYtjLCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjkzNjc4NTktN2U1My00ZGJiLWFjMjUtMzMyYmY5ZDE5ZmM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MWM5ZTA0\nMi05NmJkLTRiMmEtOGY4ZC1hMTU2M2YxYjFiZTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASVT6DA6uFjX7UP8u4gs+ZYEqEH+bZqUdOBNEVHahz0WO2WSMOf5WO6\nPmhLj5LMGTpq3evozp/Wv6Qz+npgfcEPo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSO0vnK\nCRoS8dHO7Hf3LFgdXGOc6jAKBggqhkjOPQQDAgNHADBEAiBfnW9TJ4P0PThNkBbG\nMndCD+eGHcatR7P5CKwWCaEMbAIgdLK4dzpcnV9Mt1cyqQPmQfIJMiArWixX/UKe\n0aArb1M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5901", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5901` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUeD3TnSRQX8tku7H7KDBv8QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyYTJkMDIzLTk2MTUtNGY5NC1hNDNjLTg1OTQ3MjU5MWEwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZlZjQ2MjgtZGQ0\nYS00ZTlkLTkzMjItYWQ5MmY0OWUzYzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfXJE5dBCkm4Id57QGXPa3dqrVqahcBm8nl9FAA8WlS9U6Fs0jFijPLYXHTda\nlEQkWnEiDJESqeqXykjK/2gtX6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2FPm8cn74ScbRrU0Rn7V3bsJaOIwHwYDVR0j\nBBgwFoAU36vgzD1nKH4aMlINQR1nLXWJH6wwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIDc55wPt5WZeOugWm1BOtPozGwM7OIreo/2oFmg9mxFRAiEA\n4KwRdrQ89hcRFEb0LEfNxAcYyBZBRbxbw5ql77UzQ9g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQR21pLnLOjKcMrbqv/b4yflMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmEyZDAyMy05NjE1LTRmOTQtYTQzYy04NTk0NzI1OTFhMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5O38UMpM0y4Cz0L3xbe7/29W0iAb4RZUMzEu1vwRBQfUD\nG/9QL03YeiKmEZRA6V8g5WjYQeIMQpu18W9P2iyVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU36vgzD1nKH4aMlINQR1nLXWJ\nH6wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDLIYrym9gShoSHExYo2E/5mzKAKX+Dkfgh1uUMPzsusCIDkwfM33lv0K\nH1GoAqLiW4wWq0+54uASHsC7dNC4ko4s\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAWyDOJMoecYdhsqW2BYJvKGGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZlZjQ2MjgtZGQ0YS00ZTlkLTkzMjItYWQ5MmY0OWUzYzEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZGY3NTU4\nMS1jZTZlLTRjYzYtOGE5MS04NDY2MzgwY2E2NTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQpqvRr4a9wRB7vo+sTF+VADPw+bfBTCTIEzrWQYxEGkCzunVYKmFQh\nvafHkxXHJZtnX1Dee52Q1HG9EuBH5+Mfo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYU+bx\nyfvhJxtGtTRGftXduwlo4jAKBggqhkjOPQQDAgNIADBFAiAiK+CjC38C4BIPWyoE\n1DHgrq2MTi38+Ttql/61PTf+5QIhAKRrJOjn/o/5or4CtcoWG3IhbyhpnRckybuN\n3H5p+0n6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5902", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5902` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZkL+kB/Z1uRoFTlPiDVMC06MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkN2IzMmJjLTFkMWMtNDFmMS1hMDcyLTBmNGIzY2QzMmJhMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I4YTU3MzUtNzQ4\nNi00OTZhLWJhNDYtNjYyODNjNDAyYzQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3EwzCbIluv/921KgdVpYqgT3+mBGQ33uQdRQYjLcySK/UxXk2KabdM1WjFSO\ne5Hfw9RrdH7X9O4pJlCAAtJPUaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkjDoGXPdHAHDcjHeU8C8Qfqd3e8wHwYDVR0j\nBBgwFoAUbAmcM02dmOSol8+UP8JaATt6QzQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIG9cnqAQnMB6\ncz/lYj9h9x8qVzORHJHRD2SArL7OotjPAiEA2SpPgj7zJvJ7+GYPk5PIGRHQFKP/\nykaGB+cXnnWbwLY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAafgrcl73RqzHTjzv9KUYg/LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDdiMzJiYy0xZDFjLTQxZjEtYTA3Mi0wZjRiM2NkMzJiYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0gAvll74JXE3SrZRFi+1liVGixZ7CUZXNMxc3MqKlmVTJ\nGZQWtFF6IO7gOCkNmAwV6wbV+jwhz5bEe0Vzs0RNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbAmcM02dmOSol8+UP8JaATt6\nQzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNbV7OUiqRs26AfYldes+spVssM8ZjY5zlBIE6sPGcLQCIAikK+ArSi2P\nUM5ywhKIGHGGxhZVk3beW9cdCdu+Ixfi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAZD+JY5+paD0VfnH28rcX5ihMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I4YTU3MzUtNzQ4Ni00OTZhLWJhNDYtNjYyODNjNDAyYzQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZTAyMDM4\nNi1jNDllLTRlNzctOTI0Yy1hYjhlMGNmMjg4OTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATLkMI18tgElbAxVmkoItNGV2UNPfyTz/ryYZImMv+RuLILkYePihOz\njx08+CXAuYoj4VKMivQvgiGQS55asoSeo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSSMOgZ\nc90cAcNyMd5TwLxB+p3d7zAKBggqhkjOPQQDAgNHADBEAiAo9lC4QYHUcypwETHZ\n8TNWiV1gZWWL2b6gd9wkyzbNiAIgEfTocjv7aJ6xfwGLEF9O4iNQpc/K8SHZ79pO\nGpeDS2w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5903", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5903` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAa3doXa3mykC7pQSXMVnaCUyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyMDMwNDRhLTBlMTctNDE0MC1hNTc4LWJhODg5ZWM4ZGQ5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDZkZmYwMzQtMTUz\nMS00M2EzLWIyNzQtN2ZlZWQ2YjU4MDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES3MhzFvRctDtN8xuy5a3G/IuaSak2BQXpHQYuJjZTjZCBlzM98tEJTOKZsYE\nvIJwawwtd152Em7dkYLys48Jn6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUetioDaIlyGXZbeCd7Q6lJ8+/gkowHwYDVR0j\nBBgwFoAULV7cdEbH6HmVQ0x5Xs858vPAi5QwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgLjTsm1bi7TmGdRnq9txW+mj/PGaCe9NpjFXWRYSA/x0CIG5/nmxo+0Sd\n3ms1mECwG1eKne2aV9/m6wFkxqn9oFcP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdu7xtHxY9jGA3+1fLxHy2D6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjAzMDQ0YS0wZTE3LTQxNDAtYTU3OC1iYTg4OWVjOGRkOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHkrTkKsv78S9KZlpH0IWdz62Om7RQ6dbWNjTwGFICFjfe\n12Asc3WIQKRHp+5vsc46sBmG7xBR/LDiAE2yz6r9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULV7cdEbH6HmVQ0x5Xs858vPA\ni5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ3Nlx1LXmDn+CYbm8IthcVD+MvvXpWhBcIX4kKQ1e/lAiA0rweG688b\ntqr1Y9WiL9DJkxd7MLKnNKwihKGnm8y/ZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAYX1/WLNNffRbD9AY4drokAnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDZkZmYwMzQtMTUzMS00M2EzLWIyNzQtN2ZlZWQ2YjU4MDg0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMzYyYmRj\nYS02NzA1LTQxNzUtYTExNS01YWY1ZjY1YzZiMzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR1WoPFeTyvDFKd1rZHFG2ay4Z77OcnkhRqC16grIBjH5lKKYwU1zdB\nDUHJS3wdLUPm+ZxJkpvdUa0++6x3ubJEo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR62KgN\noiXIZdlt4J3tDqUnz7+CSjAKBggqhkjOPQQDAgNIADBFAiEAniSKyKsryUBlzHgp\nnv+DxxCYgZ04mU9dVJPzZGlyaqECIAs+5LOZMAM9PQic+b7NiE5wSWQH9W1Vzl7Z\ntgHQxWoq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5904", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5904` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAbNtzeXVzXbOpa2tfgW+sp/DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ZmYyNGZiLWY5ODktNGNlMS1iOWNlLThmMzY0ZTY2NTkzMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI3NWIxZDUtNDA1\nYS00MmJmLTk5NjEtNzhhMmI3YjRmMWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO6Iui/ONb4kq8bbBrhzRcKlXF59ccKkS7b6TfWp4QlAU5lG+QR1SwyyGg9r3\nZ2eoEdvuW4Ld/TtC9hvyYrrwK6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMKYhlLmjVoGL+q4ViOBwHncQU44wHwYDVR0j\nBBgwFoAUwkoWIBu9i1jB0p8i4/lo3ily1X4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJ08A+I5TXHkuTN46pKEMISZ6VMpTAMNVLpJkUHaN8GgAiBupVYVIYaI\n98YqsbXCbl67cgl/9idjmCDGJ+vY+3O5dw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASt6flI3v3dqaiLNhYWouvIBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2ZmMjRmYi1mOTg5LTRjZTEtYjljZS04ZjM2NGU2NjU5MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQY98TKaljqPtSVRPbupjyD0P6BTi5PlXeIvI7dUUMBnDT1\nqwLTIasmo6VJpzeiFfnwTej+ZppV8Zs65JPuLKC7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwkoWIBu9i1jB0p8i4/lo3ily\n1X4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUzMW/6NDLr/6KsyicsmNOTJX1BKjJ9TR3lveeqwRxFsCICYHP6fBmn5k\nm7SecsPU24WDLyUdbTexAvn1ixr4RwMt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISATeZw27liDa9k1RhrFaYJxX3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI3NWIxZDUtNDA1YS00MmJmLTk5NjEtNzhhMmI3YjRmMWIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZTNjNDY5\nOC1iMGJiLTQ5MTItYTc3Yi01MzQxMDU2OTdlYjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ4y4zT1hMTTYLfPdnv+1VIiY26Ql3v5BahbpeQhC+mKToctBcHkMzQ\nxe8CGKFgSFQBQLF20ZGxgjvGutRywknFo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQwpiGU\nuaNWgYv6rhWI4HAedxBTjjAKBggqhkjOPQQDAgNIADBFAiBOw4C1zmsm2QhbjzjK\njtWcOzsSHCVs8ayg2EyIYKbT9AIhAKdoGmnCqHWr9FPbP091eSGaqDoBwL2DEqUx\nP8gStjIb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5905", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5905` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAWCO1veDyzUswIHCEqtH1hBHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1OWQwNmUwLTlkYTUtNDEwZC05Mjc1LWJjNjMxOTgwMDZmODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYwODRhNGUtYTZm\nMC00ZTA0LWJjYjQtZjYwN2ExOTMwYzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE34tEtIzmDDAiqt/N01fRpvUQ6pJWC2eLMY9CsGOXxQgvnSmREMNcOxq6hnvr\nUHg5nByn4c66kC0xSs55+fPToqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSa0aGu2dToouLMFaQLr9zDGbj7gwHwYDVR0j\nBBgwFoAUV1RuCl8BefwFCWPYbCxmWC8KSs8wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCq3g+C31f1zyMbtWnVk4gWD3DzRe5WeS9KmyLfcpnp8AIhANR4JsGS\nIdWkHiWwcPzT6vGmyDXKo52opplooYrGTD6o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQq7ag395U1VD1X4oXgiGViNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTlkMDZlMC05ZGE1LTQxMGQtOTI3NS1iYzYzMTk4MDA2ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNmhaPRPmarDktc5SgrKli+oOxJec9psBBoWFLue2JvFxx\n1Hm1l8tHeTcfcl/s93EeS/rVHlWskPn5qw8HjvZlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV1RuCl8BefwFCWPYbCxmWC8K\nSs8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZMRgGniu/lJ2ZGvoTjUlsb9DKn0z7u+6oNM9mO24vYUCIQCnpiHvJgAl\nTs4kfSUijsZbNAdXeP/uO8t//RowGw6CzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAba9iM7CZ75zyS0UvQjHO2B3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYwODRhNGUtYTZmMC00ZTA0LWJjYjQtZjYwN2ExOTMwYzY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2OTRmOWIz\nZS1mZDg4LTQ2NzMtYjQ2NS05NTExODA5MjE4ZDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATWwuCwpQkfvQRnUV5qFJLso7tYOB9ImtS6EmLZsvx5ZeJUWz+Rap2C\nNs2tnhqZ7bPBvpI92f6NTfAb7t3GLYBho1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJrRoa\n7Z1Oii4swVpAuv3MMZuPuDAKBggqhkjOPQQDAgNJADBGAiEA4LqTW8551XORQ+5/\nxRb70D+QDPdQLsiMZtvD9cLgc/wCIQDivVjOM7y0KDr+q1/Ij5soTVvEoz/R3kdL\nz3GERHzI2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5906", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5906` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUHK3Vvv0kUg23B3giIg8xF6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyODA4NjFhLTFlMzUtNDg2Mi1iOTI1LTI1ZjFmMDczYzYyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFhYWY0MWYtN2Zj\nZi00Mjc0LTg5ZDUtZDZmNWZiNDk2NGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa/E13dBuHp582bSJVAmUB/U9hx/1hHKwhbvYTbHJJ3DMOKNE1AmJoFTqS3xJ\n2lOXtmsCuznIjVL7IoRjeauaNaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE1R/mY8Bn6wXkTLg3WT21N4Qy7owHwYDVR0j\nBBgwFoAUfqKPezcClqtkSP8jr+Tujyf69p8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCICn4g1QHZ2BjfvtHtkoWpiTEHGdj4HahvNVRg0hR\nYYnnAiEAwQfplBomyvDGlOktrcLsYN0OonXv+p9bm3U0+dpIYkE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATQ0PGwGLPjO0+ortg7LcrW4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjgwODYxYS0xZTM1LTQ4NjItYjkyNS0yNWYxZjA3M2M2MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrF+Fa/Nnzb99tYdcWyn1QgSlah4H8ewyKkRcBWT1wkSwZ\nOZ0iyQewXskVhn7jQ/vFT07BmDSZRytsMy3Xd+ijo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfqKPezcClqtkSP8jr+Tujyf6\n9p8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO/PzFy2GLwoYvoOQMn24RxmJ03NikswA166HwzprGjFAiEAyC7jnTnx\n4qr9lsioyfcdt/00s1PEDwY2XLZT6ac7lAk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAUy4XdMWQBy45FXIwtBPHXeYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFhYWY0MWYtN2ZjZi00Mjc0LTg5ZDUtZDZmNWZiNDk2NGQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZDEwZmYw\nOS03YTI0LTQ3ODQtOGUxZi04NDk4M2M1MmRlMTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQwqcfrHGyEUN9oYYmSuKoaRkpHlQDGkuhrV9PkrAN9fsfSXIHMCzhB\nxuNItFyAOQGgS0dWBc60uS/AEEgev+vto1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQTVH+Z\njwGfrBeRMuDdZPbU3hDLujAKBggqhkjOPQQDAgNIADBFAiArwftzlaQeTUOeKsQy\nC+K2tpVRC4/zz3d8uezlA7WWhQIhAOs9ofm4/geAWf5slktXRsU1iqego60O2e8m\nXwTD3A7W\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5907", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5907` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAet0U4SfzM4zY/4IIoXLjPY0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxOTZjNjQ3LWJkOTYtNGI0MC1hMTJjLWUyZTViNWY3NDNkMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M1YzkzZTItZGVi\nOC00NDhhLWE0NDMtOGQ3ODcwOTVlZjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWlJXJbKMblOeWRE/bgwKxAoPt26rqxRgeL5dmJZMGdhWzpuATzTkZCLRZfdy\ncPTp/LJKQgqZh9mdk+Wd2qF5N6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzGRKW090E90z6KOx0H4FBGC2np8wHwYDVR0j\nBBgwFoAUcA0wGthF3eoEBWGeocJl8Natv0cwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDdxqIG9jss/zguYFbRIF5+OSk2sRrJZ8bvVC34i\nW9m+AiEAu7WCwBCSCx412JpMa2SEjoZH2oMyH0UX/UGluVeMwPU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQJIGLcachj0MW19kx7BpwHdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTk2YzY0Ny1iZDk2LTRiNDAtYTEyYy1lMmU1YjVmNzQzZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIj1IpFxwRVIB0f68uw/edGZxqykPAXUEmQZ/d6xn7orRI\n6TXZ4glFi5iZ20wP3oYV/ZjSzKRS7g+9O2adzR9Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcA0wGthF3eoEBWGeocJl8Nat\nv0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCEvihgnv6uhgdxVzS9xAeuJ4Ds9Z5qB2sSDQ6Ms9G0kCIQDioOnqf0KB\nQzkRrxMK71ZxW3pg8+xEKC9kPzDiQf7eDQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAT/LI6nGykjJJOkwcc4/06IyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M1YzkzZTItZGViOC00NDhhLWE0NDMtOGQ3ODcwOTVlZjVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZGRiOTM2\nYS1jMTdiLTRjM2YtOTllZS03YWVkMTVkMjhkODEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ3Ynm2ab7H1RB/pOVAvffu9m+Cj2fCmYWziJc4dmZ+hCm5Ram0ZSaZ\nW+jKB5oDX6NshMTuuLdj2LvIL1csadlGo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMZEpb\nT3QT3TPoo7HQfgUEYLaenzAKBggqhkjOPQQDAgNJADBGAiEA9eJwFUUm+mscrqlx\n/3NHMylSX2UzJr2zuWUm2kZ3mq8CIQCRWeNCIiF3LCySMotqWadzTsT2abFI7h2B\nbKoXAowDJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5908", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5908` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAdcaVYWRQ8ZozyZx9uusj/YzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyZTljYjExLTlhYmMtNGY0NS04NGQwLTk3MmFjNWE3MTI1MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM3YzkyOGUtYTJi\nNi00NTZlLWJkYmYtMDJlZWM3YmM0YTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE57OqSITlee4i6AsLMcBDS9bePD+peyfJoxMuKDMRH8afDntOS2ht2FKiIrbh\nECoNO3XlWm8MVcfZCa2MLpktC6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxb/m0O4XvFXAy0LKJOAE2UIbnZkwHwYDVR0j\nBBgwFoAUXQ9mH1AoSNSDkKhQsqsXdoP8l/wwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDTxRwJHLG1BB/O7VdJUDqnxqxjMaQtabbNQasIcuahVgIh\nAM7Jj3HUHwigEwc6gQ/WQQKQ/NY/OAwDDKZUMkFCUceB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYpF/6eNOU1ZxGZIwkUfr2KNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmU5Y2IxMS05YWJjLTRmNDUtODRkMC05NzJhYzVhNzEyNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCb/DezKp5G+byX8FMalzNULeP5lEl5KA2UHQIpbQziY7h\n/z0o9x+Y1fNOQrtcC4yoiNttyliJ6lN0M+82h3y0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXQ9mH1AoSNSDkKhQsqsXdoP8\nl/wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMxrtVC0WHyomA89QOBvVJE1fCuonnhbBcsHk56EuWwcAiAkFLRW800A\nE9LrVjJHvaQDox/SfjXxQKRrZUySwKfDAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAfY9LFZmBJAJMtBE4u+lZV0LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM3YzkyOGUtYTJiNi00NTZlLWJkYmYtMDJlZWM3YmM0YTEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OTViOGVi\nYS01MjIxLTQ0NjgtOTkyMi01Yjk3MmE0MWMyODgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASr/WSDr6zAHNU7aQXIAAXK8Vw/xkP0Z8E7imdYKQC3kBJ5O1P6FmON\nnCiYJIM/ysE2fN/QqNDwk4YJAULx3qh2o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTFv+bQ\n7he8VcDLQsok4ATZQhudmTAKBggqhkjOPQQDAgNHADBEAiBabdwHL12aeeB0twQn\nQFHwqyOyskl9yD1aiqfdHnXZwAIgBb4AkkbYjKvuS/5osMzJul9+Y5s+nKVWs6Bm\nDSJ0VVs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5909", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5909` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQpFagkG8x9Xf/mrBeDrfUJzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MTk1OThlLTk5MzMtNGUyZS05ZGJiLTAzMzM2ZTZiYjliNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU0N2IzZjktMDI0\nMS00ZTIzLWI2ZDYtYTQ3ODQ3ZWUzYWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED7XXhi5qHs8gtc3PbUQ1KA2tMK1VgbDfQb8fNpJdD7svtbyNYXvJXP8g0hpB\nwvWPiY5JIzJBzFvFvZJxJdfCLaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3inQ3C3hrY2GUyiyqzsdZIIgQpUwHwYDVR0j\nBBgwFoAUVBe13hxc+SsA/kxZmfBS19TIJvkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIA1ZjR/jQrDx1uFtvRLaMLU7w4Rj5zc1\njw/Y6Q3GyaV5AiBXKIVEgniVzxDWRk5E/u6s3xw5X824I7d4LvEHdySAXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXl79C9g45tvadrblnRXxssIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjE5NTk4ZS05OTMzLTRlMmUtOWRiYi0wMzMzNmU2YmI5YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYnH2BFhFpga1yG0U8eOnvPNf+wnn/Ig4V6posFLOfCvAb\nrwji6lI46gdZSpOb5ml2NO90RuDKdKC/AXz0dMsGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVBe13hxc+SsA/kxZmfBS19TI\nJvkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaa+MQcT+lsmq6lRa/bWfl6YbSG0IsENN+RdwRfYzNm4CIQDnp19X4UaV\n5szfeg7rGQKrDa3c/PK38pVFqW2KhPV+dA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISATR1qTpRiblCdiZKsGwIJYENMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU0N2IzZjktMDI0MS00ZTIzLWI2ZDYtYTQ3ODQ3ZWUzYWIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMTgzNTRi\nMC00NDA3LTQ1ZWQtODdhYi00ZWZlYTk4ZjNhZGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATBfXrHHYidOkMp0hEVxnYrv7fSvzE1sOpM29R2pagooX+FmruYvE3k\nTNr0yo88/FiiQLDNSk1qqCWyCd7HvwwKo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTeKdDc\nLeGtjYZTKLKrOx1kgiBClTAKBggqhkjOPQQDAgNIADBFAiEA/3QawPJLcTAD8Wyq\nfRWrOomj3rXPNDEDPzciaKc2H/ICICAdjiXzIaZapS3fDJvzrIQn4XYl0mATA7qU\nlotsQUkS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5910", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5910` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISASA9NtP2cObB2+//ey1mOqyHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlMzg4ZDNjLTNjZWQtNGYwMC1iMGYzLTc1YmU1ZDJiMWRiZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNmNDhjMzYtZTkw\nOC00NTk5LWI3MjItZTYxOTlkODMzNjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErQrzqEUXEh5ux5ch5vprn7jCDNqLQgZovK3AEXGpxHyK/SrYhFtLYDSHztOw\nj9qyAclMiMx6d07ULOYn+CudDqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj5KXxnRfgGRIn8ZEY/8nBH4H3S0wHwYDVR0j\nBBgwFoAUwORZcfyPSFu07rey1iAyHAz1goUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIDSoBiIJTlh3URpkSS2humR+zzNb6iCd\n7aeL327SmgUqAiBgVIPIUfZLDjen+91NcC+nIA08Xa9oBTmPglmk0NcJGQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdUQAwnOZzFK3ZW17iWxjTjRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTM4OGQzYy0zY2VkLTRmMDAtYjBmMy03NWJlNWQyYjFkYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyBvrFXG0Wz1Q8Rf6EAsGaJ+CdSgj74rAqpFxyy+/0D7Au\nfOGZRYedi3lRqyQzZzxv/4m1Scu2+yj4oIxGy4Vko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwORZcfyPSFu07rey1iAyHAz1\ngoUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOo6hMb7eSTmFAHJWKi/BOpV2sd5PB/EPScg5AdH9l+ZAiAO6/RRuycX\n87+3mfko4dskQ9+PGQ5RhmLKYpU9cnIE1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAVeFbK95EF39pcldEq2gci7dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNmNDhjMzYtZTkwOC00NTk5LWI3MjItZTYxOTlkODMzNjYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNTk3YTZi\nNi0wODNlLTQ2NWQtYjAwYi1hYjBhNzMwNTMyZjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT1dGvmsRSS6lLI/SWVi/xkSJKJZ6qCG9udE2Skp34MdWmNF5sBf4RZ\nXP7I0VTb03x8hhkNhWXTWtY+/jnyu6pyo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPkpfG\ndF+AZEifxkRj/ycEfgfdLTAKBggqhkjOPQQDAgNIADBFAiEAj2M73evVWNmBfGiU\n3lnQo4FQ3OVSZ9J7UztOenLvxiQCIAQdH6gR8wzN6mCKgEVQUw+pw/gb9XRBqr9n\nOZ5yo3Ue\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5911", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5911` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAVxNG7o/O3LK9v9p7HLynWl8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmNDAxZDk5LThkNTEtNDVmYi04MjQ3LTcxN2I0ZDNhNGE4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRlYTI3MGYtMzY3\nNi00YjdjLWIwNjctYzlhY2ZmOTk4MjJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBnboKLQDyVo/aj+Yhkg7EMa1qoeKhRzJXUOcv3Bfb+fNtRR/rYV4JC6HkI3l\nLPCqSkK7VtOQbaKY6htEjroyl6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKMuepxsVmccsPEARUIWoKwCdm9EwHwYDVR0j\nBBgwFoAUe2slxadH3z78oTOETL82cW2qqcswKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCICNbbni8FfjU\nzYheKWk6BJNlaa/vmA9GhBthDUZM/F0LAiACKtnC+vYJeiECCtkQM734SAB/2Ta2\nO67gtTvaO6GQXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAetTeK6aSWAfg9Y5I4/H01tZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjQwMWQ5OS04ZDUxLTQ1ZmItODI0Ny03MTdiNGQzYTRhOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBVYpndkpmtoiE9h8iKu5zWRdo+9qpi5NYZ7ddiYIIuWcI\n83PhPft1ZIfXGzKSwolHLCLkOmNDzk86ro20DVhBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe2slxadH3z78oTOETL82cW2q\nqcswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMttz5V4tGOHrNzWeMLp2W5WF8GXwJA9UYGuOiYmHG+mAiEA1A3cGY6M\n+5xZAQ9gBLj/IrPUo+v2kb0WxPa/EERxZEA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISATIRkSl+K9Z86R0ndC4Nf7qAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRlYTI3MGYtMzY3Ni00YjdjLWIwNjctYzlhY2ZmOTk4MjJiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzN2NmODcx\nMC0yZDhhLTRkNDctYTEyNC04OGQ1MzA3OTc5ZWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATWXYwQt2+zjTtUNpQn4AfwOIn7m6YpXFOAZAvvjjPw5/9d1Z/DZW6j\nJfoElx9bjU9oIjEPw2QeNpx5e8L7nau5o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQoy56n\nGxWZxyw8QBFQhagrAJ2b0TAKBggqhkjOPQQDAgNJADBGAiEAvsfT0iYJcnyLQMFr\nB9hEsAPKXLcf6qeqdc2E2ae93uACIQCotlnqyhTUjxfqQyM/iSqpQ1t35/r0nS+c\nddbEVgbARQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5912", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5912` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAQUWcTcYhN+Un323CcgXOT6+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZWRhYTkyLTkyZDMtNDNmOS05NTNkLTI4MjBiODdiNGNiODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFmYzU3OTEtMDFl\nNi00NmUwLWExZmMtMjg4OWUxOGFmODhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOE7IYAxDM/FC245wnUwmDSzc/5MzsuWRYh6tdxpIoAy8PvzbA7lg6rWwI+Wf\nQtyzHAOFdbq4XLL7c9S5FlG0kaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURTmgt3E1TuPDId2cbFXwPR8VSHwwHwYDVR0j\nBBgwFoAU12AFhaouL5jUMzivNFdSkksvt/IwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgVnMRdhIn/KT8zCQS0Lc5vNoFprLz+LiFih8l65IecPcCIGYGzbE+as+m\nMQS4Orr6ZRO/wW+nvVCRaZKU4CRMl5Yc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZIrnysO3iuMseaCzQZFQ0i2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmVkYWE5Mi05MmQzLTQzZjktOTUzZC0yODIwYjg3YjRjYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6VyrhNyxgRbnHDJiG8erut35H/7dcbcq7IazqPlNRZGx6\nBABNCtfqHpdMLcR6sh1OzIc3ts54S/6GOOSXkO6jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU12AFhaouL5jUMzivNFdSkksv\nt/IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ4Q8QMjavJB14+019zciNH9pV4HE3rJjPZTP/he8nwuAiAZJC/j3hYs\ngtNhY0DmRQZ4O5chgkS9V6Mt9NTHI2pGWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAcV7xonVIrVGuiZpQJ0ne/hYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFmYzU3OTEtMDFlNi00NmUwLWExZmMtMjg4OWUxOGFmODhkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNGFiNWI1\nMC03ZDM0LTQwNGItYWMxMi03MWVjZmZjNGQyZTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASAO/YOqJTJPva16oUD43JZN7fCvdGzxFe0A4VIXQQSAIiK2hLYVJdH\nhUp+9bL1YzfcUG0IZ5+pvtmrlLowKJVNo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFOaC3\ncTVO48Mh3ZxsVfA9HxVIfDAKBggqhkjOPQQDAgNIADBFAiBJJRJPRYX/1+mMWm1g\njYytPDYqZFwRhIKRU7BNVQuSlQIhAKvEGwDRNyWdr3/ekX5gChva7dF8aVhoSn7s\njCtVEyZN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5913", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5913` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAf9B6RRpq448nArWwq4WFaf4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyMWUxZWVjLWEzZjgtNDhhYi04YWZiLWE3NjZmOGQ4YjBlZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRmMDJmZWItNjVi\nYS00MWVkLWJhZTEtYWJlNjYyM2VmMjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUlmj9pxGnw7O2GFAr4QYgaOXs1Wv8pXRn6EMeI5sW5E2f+d1oBtFVKOmaJ3U\n59/fODLX7Tcn1gaHjAfvIb/ZVaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzssnThNP533MAHw2KeWsKO/5aSkwHwYDVR0j\nBBgwFoAUPVBcE2pdtSNCTsS1aXq0/Wy981kwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgW9NTs49kzw59tIJ6MyHdHlrx/LysGIQ8YRC77xIkE4kCICQ81A0CSvxl\nzXR1MJTb05fMftmheQPuo0gZ7lP6YraA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASkJSxkZiGl/AW3y0h/YZy3aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjFlMWVlYy1hM2Y4LTQ4YWItOGFmYi1hNzY2ZjhkOGIwZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBnZ371x+Hfi5E8wbJARR/UQNjfz1NWwnkIVoKGuS7NsEb\nYDCnmsUV1fkL/np+tzY43T6DEtWavYgKiSO5HqMTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPVBcE2pdtSNCTsS1aXq0/Wy9\n81kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJhxR/WbUU8jC5zLR7n3dgW/o7n/W28VSAJGsTyYLnm4AiAcFis6Sa/N\n3qEn79VPo9OnhWN9HjB+1DkySCObqZAnqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAX1vAS+QtKKM2GRFFoeNn704MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRmMDJmZWItNjViYS00MWVkLWJhZTEtYWJlNjYyM2VmMjNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MzYxYjA1\nMS05ZTQyLTRjY2ItODhiZi1hMmY5YmFkNzE5OWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASH3fWXh9ccJoVe1fEYEeU8Xd5Z9yh5eevy1JEHYSrP5SMa2p3P/tVK\n2Kuz4B20Lmy5fcaWU0Cr+P+jDefQnfp/o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOyydO\nE0/nfcwAfDYp5awo7/lpKTAKBggqhkjOPQQDAgNJADBGAiEAsz3b2IkP2qya+gFt\nrKUjlvSJMT2tDczz/Jjvr/erE3YCIQC7brX36EPFcDgbrwkaPD93sbBJ0aJufKnf\nsl7aacssbg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5914", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5914` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAaRWcv8L+gDKxoxXXa3AcWHxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyMzZhMzViLTZmMWUtNGVjZC05YTQ1LTI3NzUzYmU3YWI0YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ1NWYwNTQtYThl\nOS00ZjE1LTk2MzctNWM3YTc1ZjI5MzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcHFRYEbyw2bT1jYwohjIO5qqFOToft8yyEfd72L1aywCG8typHdMM6BMYP8H\n7nXAAH7SSR1ObOQYq9ss4A7OGKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi884WzmNFhO+lRaJAeTqWdarlmEwHwYDVR0j\nBBgwFoAU8Vzm22JrnjegGBB/kp1Ycm3gJlgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBlStncoK08zx8Q2uby+Umv1uAdemZGb9uYW5k+K5X5/AiBy3tkqbaI6\nPoQFZXm3hwSRAHek83L4PnreHIe1zcPalQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeEJPBn7+KBuEUf8ScmK8AN/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjM2YTM1Yi02ZjFlLTRlY2QtOWE0NS0yNzc1M2JlN2FiNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATR++vMKZoOIQS9BSqcQ7dt2myzhbqDxQuMEJUG8Psj7SDe\nqUyQOY3leITFdHW+CxK01nlrGy8GZmDDkz9+iO4do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Vzm22JrnjegGBB/kp1Ycm3g\nJlgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMS/ZPgIqsSXJWmrAvWqacBRClCJEV7z5cK2gZSGzqxCAiEApSsnrGbL\nfC8fZIdkyIJAzVzbpdyGgZ/swsD7tF9SNyw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbigAwIBAgISAU66hfP9ApiEoZWKiLOr60+aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ1NWYwNTQtYThlOS00ZjE1LTk2MzctNWM3YTc1ZjI5MzUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNjFhNjAw\nMS04NjA2LTQ4OTMtOTYwNC00ZjhkYmVmOTgxOGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARwGRbE2t5Q8TvDR6ned6GUTWkhXtH1e7iUezN8rLdOPjIfzYzKvXYp\nahAq3PYVm7DA7/53x0WRVMWRr67nJQNpo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLzzhb\nOY0WE76VFokB5OpZ1quWYTAKBggqhkjOPQQDAgNJADBGAiEAlL3b4EYVVXJV9JyN\nGN6wmecI+RpoZ1uD0yapa41zuqUCIQCSsmYBwfy65/JXXj/IbaTFom2CwIN/JS0e\n+QejUs5pbw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5915", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5915` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAZPPj3fu5wM5s+Fh0XjINGOpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NmRlYTQ5LWNkYTctNDcwMi1hYzU2LTc1MDQxZjY3MjhmNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYyZGY3YzAtMThj\nMi00Y2I3LWI3ZjAtNjQ5NzAyYzI4MmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwSn7iC2a9EYEq8vsVfiu/RX/dFPKOKRQzoXJebON8WjFXGZGEj8vuLBlP4+N\noPrTTcg3pBqcaaZb/+xajQsfNqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmmxDenbufsNXKrllMPyLFpR4pLIwHwYDVR0j\nBBgwFoAUL2/cyyFDXLmyh9poKLMXTZoixccwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCF25NyOf/yrRvD4h/1Q524u52Z541xepXiITmF\nkcIpsgIhALdPJLhvnhEVLsLiOr0YMOos7T9M3PtmPD/kebKj7DHe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYe935zXiVrHnhRImLQbZ1zJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjZkZWE0OS1jZGE3LTQ3MDItYWM1Ni03NTA0MWY2NzI4ZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLIv35X0YpJI8k4Jt+gqYZ3P8tXgCuLDtS0CQe/QQL70DL\nthsKESYDm1CwMC3vAvAVTtd73RiS7HoGGxPjopoDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL2/cyyFDXLmyh9poKLMXTZoi\nxccwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD5XgLzLyP5JRJTatsiBEYjHLgpf2b91baBRu+CBRV9ACIQDNoz64K0o1\nfSSUGV7uzvGM7OrhonM2rG7/GMPzwso9iA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAQRHu2yaMLjD4jj/P7rKp7SbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYyZGY3YzAtMThjMi00Y2I3LWI3ZjAtNjQ5NzAyYzI4MmQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MjA5MjMw\nYS03ZjIyLTQ5NTQtYTE0MC1kNDVhMDJiYjY5ZmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR+SVJNKqCN1Kbn8GJVGV8UVOMCn93hpdRWvdRygrTrIC6xnD1MhHaX\n/GvOGJ4v2RwwChIeOASe+6/6MMiSQi0bo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSabEN6\ndu5+w1cquWUw/IsWlHiksjAKBggqhkjOPQQDAgNIADBFAiEA29QD4mVfsByl+1e+\nsyYL1zV2EgoxO8DxREMoVn7kC48CIFj47C43fljEceLDisa4ywmoGWre84IrioHb\nqrHA2BeJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5916", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5916` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAfStVYw5QcJGwwdcWJL/Sp1iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMmZjNGJiLWI5YzUtNDc3My05ZTUzLWZmZjU5ZmYyMGFhZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTE4NDYyN2ItZmQx\nYy00MjQ4LTg0MGItMDA4YTgyZjAyZjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+shq4krfyWn2ufIRoP6q+6YoZqpzPAw03eqQYW4sFbrH1l878nAWksjU67AV\nxng3RgJY/vez+RCqcihGng9DeaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7bUD6seHVs7WCqwzxhubVcyfJ1gwHwYDVR0j\nBBgwFoAU8pu+c2FgQEi1Ir7jKAAv+y1MiPQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDUG/wbpwpcL8d4cERLcsPp19iZfldLCdOG6eSh\nDzwCtAIgJN8kJoKIigYOm7xK71aQyR38cNwetM5I7ZkeLNp0q7g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZdF3jrsUFdGGQO41UBwJYd9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDJmYzRiYi1iOWM1LTQ3NzMtOWU1My1mZmY1OWZmMjBhYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS54R0Sm8RkxY3n5li8/DCbCGJfiFustuQE0tmOFuY1Q6Pn\nhsQSszvGidXCzxaQn/rmZn/h98pU8ZFQFjWA5FN9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8pu+c2FgQEi1Ir7jKAAv+y1M\niPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC3r5a+v1pvj3Z1DkOHf4h+v4Vit/hHtZErmfFuSf7JACIHlMNyQGMIAa\nuRA5wSu6yQQh600BuPF4UngIWz60a6H3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAVjSlO5cR5QdqxdKcGVj3xMpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTE4NDYyN2ItZmQxYy00MjQ4LTg0MGItMDA4YTgyZjAyZjc3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYjcyOGFi\nOC04YzhjLTQ4OWMtODNhMC04ZTVmMjQ2ZGI2M2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQQ3pStF6Coyd3d8LvTqhAI7veJoltBoZM6EmAerG9rul1jyu9Zn4i0\n3M8fj1G51Ol4Ak4ZbC+2lHZMlna74vHTo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTttQPq\nx4dWztYKrDPGG5tVzJ8nWDAKBggqhkjOPQQDAgNIADBFAiEA1UPN80Kgl5VGVd82\nVE3LfKkq5c9V36P7y9+J6NFZTl4CIG7vtPNuJvzixYAaINzGXVb9LT334SfkXrGb\nbzesEaSW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5917", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5917` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAfX6AK2VAtMyg6W3aqO6Jp9QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzNGFkZTkxLTg4NDktNDE0Yy05MDA1LWM4MDQ3ODdhMGNiMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBhMzhlZjEtNGVk\nMC00NDgyLTk0OWEtNTBkMzZiNzE1ZmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE39+poj1f11qVKCqhv9pj1qcyiqj9H2PQO8Xe5wrU4Q89wPIJVjLz9w1sLAeE\nCz/6jZdOK9QfxNPUQC4OaE35BqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+weJ6wgX16JJRPqxnuW16InSaX0wHwYDVR0j\nBBgwFoAUuYfRtlpprHrt3BdouL769yxwEt0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCICZ/KTOnxu4TpaF5u750aQcFjvAZWQVT3OLYNCStE7wfAiEA\n60zFNRE/E8ivcW6i7i7EmqPF6QrU9QCDWxQddW9ZFiA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUCDwdn5D2mgrcDnYysEs6uuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzRhZGU5MS04ODQ5LTQxNGMtOTAwNS1jODA0Nzg3YTBjYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/u51jRljTSZXhszj5efNHiTtjeswgc1R3VKVCKgymCP9d\nJ55a5L5H48vEMxpS0N9pTLrFdnEJBPfydox4ztT6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuYfRtlpprHrt3BdouL769yxw\nEt0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANMkTPvs2rvUoV16erx2pglZTs7d0K1vmTxKq77xxhYAAiBmJ+bFp8F/\nEYZM7avBeD6oy+zcldC4D11uxhcbHFn75g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAQ/VIFtQQChvN9AURlvv6O2GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBhMzhlZjEtNGVkMC00NDgyLTk0OWEtNTBkMzZiNzE1ZmFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZDc3OWMw\nNS0xNmJkLTQwYWMtYTlkYS1kMGNiODgyYmJiNmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARqcMRE99b0/nihS+w2emClK7mbbO7UCaLeL0RJ87cif+JxRSIDlTMJ\ngxhEuq1e7L8L0AvXMI77sC+VmhZ8OvVxo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT7B4nr\nCBfXoklE+rGe5bXoidJpfTAKBggqhkjOPQQDAgNHADBEAiAkyCpatp5pfzGCzE1u\n8WdQqO0WtTOruaybC+CFmdpUPAIgKxRVi2bY/IS11nBNMSEOnbvatPjAFNv0HfFA\nZLAl0VE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5918", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5918` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAS7FXjpnYZOkvaYRAVDnFw/hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkMzQ0YTc1LWRlNDMtNDFkMy1hYjhhLTIyYzlmY2NkYjc0NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRjZjQzZmMtNTNi\nZi00M2Q3LTllZjEtYmYzNjg0MDRlMjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu2WFl5c/hrfN3rpFgt5pDe2riiEd5zs3y8UzmtoXAnTneGRYrnHB53cDgCzS\nJHl5yNwrnxZUIt0OQSRUlYDT6KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUysuE2TWk1IcjeHIVEd9c429p2VUwHwYDVR0j\nBBgwFoAUVSG6UkAcorkj4PI9Oe9A3Qh+2IkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCM6vYnEY2OpzyS5aULMwvK3DdKUVwL\nNys7ht6l/1tW2QIgIg832J54Dpj8i6eOhakja0mnyckQF8tCTNwk1haWqX4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfSEoULPGe6aqUlFl8DGufbHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDM0NGE3NS1kZTQzLTQxZDMtYWI4YS0yMmM5ZmNjZGI3NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiNoPWjXEidX+gcxnfDk9PDlu+xUCCHEkDDn2PjZbJgr6U\n99z6h1/pYXl6DOfaRe6vQlxT9W1IMFN+azaNuyRCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVSG6UkAcorkj4PI9Oe9A3Qh+\n2IkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHqsP6hpWqxiDCrow+e9TOI8en7Y5i0NuYxnmsPpWkZkCIE/QIrjFqyP5\ndnhjo3PBzfUeWkBL+zWCx+tggFAWNlrK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAb8kImzl2imz43UJ0ma6OFnHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRjZjQzZmMtNTNiZi00M2Q3LTllZjEtYmYzNjg0MDRlMjFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYzgxN2Vi\nOC05NzMyLTQ0MTMtOWRhMS03NzFhMDYyYzFmNDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATgJAaYGL4dzRibPY6WgR/z7OTOVr8kPJtPFrTRAXmS6KWsGN6p2XoX\nxnPnPD4bko78Fr5WEJDKwEUdGf0kk7hXo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKy4TZ\nNaTUhyN4chUR31zjb2nZVTAKBggqhkjOPQQDAgNHADBEAiBBzZ+0U8s9wCCFlBx7\nLtHBy71x4Klk5upkom1hRi6a2AIgKZldxe48VH3sWFGwI/BEO5nN5HsqCL2fff2H\nq0MaRFc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5919", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5919` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVsQCDc5gdXD1HotT3vjXWMBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmMDIxZWZlLWM1MGMtNGU1NS1hNmVkLWIxYjg3YmU5MjA2MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTUyMjg2NmEtYWFh\nYS00M2E0LWEwMTEtMDJmMzUwMWU2MGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2RaA+plkcE/M/iY/DBNOztrH5Q66bNBXsr+E/3YTVlypYM1z0baJjrW0wdwu\nmEecPMzyN/Bgfr9Q90Y1tkIYCaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAFd1gjXIokr2CKX+p4KhSYLDDtgwHwYDVR0j\nBBgwFoAUUJ3BIUGIt11DqhnnIJwPXHqvbPAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDHJHw7Qt/xrFTdiQwefUYcZDV7bhvN\nokRuCLv5UBYm0QIgMWiOl1sBCXPYrhMDIaY0pGrL7s0k1oesJljNLzSTFw4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWoTcGCTkcsThXhOduBhQssaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjAyMWVmZS1jNTBjLTRlNTUtYTZlZC1iMWI4N2JlOTIwNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzsWF5o70Az0m6BOMJN1+JqopMaTajEkYLIoqjjUicPqmu\ncOfFMNo4VZlvt8gUWx8Yooewihc8mce747SDGcRPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUJ3BIUGIt11DqhnnIJwPXHqv\nbPAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgevQknXf7OuwjO7SptmMIikhYv2E4z9NxMayflh71PKcCIQC99+ZLJhiV\n/Uh4fWz7luOtR5B2aDNQn6PiJ1mTcRcjBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbigAwIBAgISAUf34ITlrl94Mccr1N1dlrPPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTUyMjg2NmEtYWFhYS00M2E0LWEwMTEtMDJmMzUwMWU2MGY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMmY1ODdk\nYy1lMGJjLTRlMjAtOWQ3Ny0zNmI5Y2Y0ZjhkOTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARufV/eZ+2+a2Qcpa+kDB5thuxikJ/9reT0+8mPKpcLKacTnBsDRjFF\nU92I+S8m1+SJtGbBgkhjr3x24Kuep519o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAV3WC\nNciiSvYIpf6ngqFJgsMO2DAKBggqhkjOPQQDAgNIADBFAiAIseeocfoQacvOjp/B\nMA0tn4ZH99amh1UtSibG0Y8+aAIhAOO5ypCXDiE4yOI1ATcxEa/eM1EgUwjLCerW\nNfRMmkWK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5920", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5920` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASoC2UfHz0ZhDSg9QpbKn/ftMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxOWZkZWZkLTA4YTMtNGRlNy1hNmNlLTU0ZjFkNjM1MjIxNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZlZjlhZjAtODBj\nNy00Zjg3LTg2ZWYtNmY1YjUzZDE1OGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/BFeenhIpk2phmFpm3jxSvYcFbABLzhcFh67Ns4HHtbgv+iQhNI93kqRstt0\na99I6icclod06KA7j0CPsh+itaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJRLIR+NWrMDL6Da4cPBEUx6etwuMB8GA1UdIwQY\nMBaAFGl1SmOESCHFUiEX8dw1otXKywGRMAoGCCqGSM49BAMCA0gAMEUCIQDWmyv1\nAh9I61LQunZ2KjJ4hK8NORCNZxQKE378CaonEAIgacR1wfG5oKJZqF3VOZiOtX1x\nLRGPhC3rAS54a7vglrU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVGCTmFzXCBP9n6rNVUNEIR5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTlmZGVmZC0wOGEzLTRkZTctYTZjZS01NGYxZDYzNTIyMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQecN3vdoUwiMMT/ph8q9lMCOA3WTHkIwtibZ8NH8ugIEFF\nxRhohBI1kJoA2W4g92RoPTtSOQe7sqyHt9saolwOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaXVKY4RIIcVSIRfx3DWi1crL\nAZEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOgqAWyLIzPBPfvE4cfzucsoBrZAcPme2SrT3h34TNXhAiBzPxYxpF4m\n+pLBZvmI+0+sLHI6HvcE6uO1nigu/n8JQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAf9rXErZOZq4OkxZzWd7bvoiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZlZjlhZjAtODBjNy00Zjg3LTg2ZWYtNmY1YjUzZDE1OGM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OTIwY2Vm\nMi01ZGRkLTRkNjUtYmE3ZS1lYjRjMDhiMjhkZDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARbM2CznoMPVGr/Iphpgpl3kFWRp/WEgMnUdRh6fW2KWHm795oF2z2N\n4heCd1Hg5fBee0CJVEmaa0UtdzORuVmOo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSUSyEf\njVqzAy+g2uHDwRFMenrcLjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDJn7IktV3BqA2EgIu3GkJVuedxBevFhhfJrh/J7KL06AIgeiiDbfH+7TuP\nZfClXFrNRn0GEIUHsxyl6k5LI45H4K4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5921", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5921` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAXLuXwnI/VVJzWw8cu2Yz2l5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4YTE0MDUzLTNlMTAtNGZlMy05NGQxLWQxNWRhMjczOWIyYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk1ZGE0NzctMDdi\nZS00YTY1LWEzYTItNTE0ZTJlNjM1MGJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGJOwGExUcusOmjO1Pepgs1/Pcmydvkjlt/nN8Q5IvMpggu9WUHCDLCJbZ2hU\n1eGf5sDzvmIQCDEUC8thSQvDmqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFI8Y6q3pFKPBAfKtkQMAbK2DNiRUMB8GA1UdIwQY\nMBaAFHEf6OCtqDokqz0se8vV1moax2q3MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBf+ZQJ6TmFo0X92gncJSTAo4fRNykYM6ep\ntdvBvwCTUgIgW+ObqS4TQm1RIuqr732Xh0BGf9b9+rwkxv9+TyF+ask=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUyzU9TuHMiiVycu3ZEgWBsMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGExNDA1My0zZTEwLTRmZTMtOTRkMS1kMTVkYTI3MzliMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRsNwUUb/SxeQbGAXYxJ0g51D/Tv5lYFPktZb9A6CsCOeU\nWwNk55YSiFHOEcZtzEj6YaigNMiaxpqlpOGGUKzeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcR/o4K2oOiSrPSx7y9XWahrH\narcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALBt0DmbiEW7V93O4ra0qbQ9DU4cVKev+TowuBogclgjAiEAkpWR73PL\nNIDV9CWaQY5Pp4tpnidQhKDFdTcnOIak+SM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAbhzuFqlpM+C5ogS1zQP0CtpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk1ZGE0NzctMDdiZS00YTY1LWEzYTItNTE0ZTJlNjM1MGJhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NzdiOGI4\nOS00OTZhLTQxZWEtYmIxMS01NWVjZjk1MWU1M2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARAUaeljubI3JQAZF3epDhc0emFSkYwCCS3TUD23MSjYbU3MXwcJHJy\nShV1Uz2ujckhT7bR+3MBaunQVIx7/Hdro2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPGOqt\n6RSjwQHyrZEDAGytgzYkVDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIE0XB9ffEeef0hmgrNeTSC+llgoVA88VMnEESpWG5Sr6AiEA7mjJS0qUJApb\ngTMHl9lAdBSVrjnwLoazCc5WtAKxOt8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5922", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5922` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZTllFJPH5RQTYQfE1+Kjo98MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3ZDBkMjgyLTkzMmItNDJkMS1hNTZkLTk3OGFkNmVmMzhiNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJiMGZjYjMtYzJk\nZC00YjNiLWI1YzAtOWM2ZjU3YWJhNmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX0kVdpb5wWhljUD8iw2tKACIC31WIZ/KKMWGuidDolJijeWav2ist7eSgkgY\nXjL7Ml+uscZpB3UlZ1V9WbjIHaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFM9j1nLr6QyZchP08kILMVJeLd30MB8GA1UdIwQY\nMBaAFFLwCcCl3JOXDBmhPB+YojrBdddSMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBaL4oTkuuXA5/Nm+/crfo80OeodCjF/nD8\nbT7sNm2ZowIgMVtEr6/7ys9R4OINCkEjNnOva8/GWb79pkR6kC55haY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc9RIo07acWNWI5GvW98JCjwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2QwZDI4Mi05MzJiLTQyZDEtYTU2ZC05NzhhZDZlZjM4YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/c9jp4XitiszVWJFbymwlIU4HGhUluRssdPdclpEMJx7i\nXjaJesgE8o6jmJWF2uYhbQ5I9gUlpesjlWP9WxmTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUvAJwKXck5cMGaE8H5iiOsF1\n11IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO5EQuTFGkuIVQietIFsotKE+SeDzlVzf3ehDptT5/4ACIQD0gjuDpCga\nD7kcRjeXhlGFd7Q0KprmVrBc/4EJKCzKag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAfZZZ75x1zieSDqIfQ2QdLVOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJiMGZjYjMtYzJkZC00YjNiLWI1YzAtOWM2ZjU3YWJhNmUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNTY0MDZl\nYS01M2ZmLTQ0NTMtYmJmMC1hMjM3ZTI0NmEzYzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQTioT6FSZ+uyQSe4TpVasSH7m3cEViznN4AAB82oWxBiR4ZaAwDjgd\ngJwnOJrKSnqYgKt2Hn5ROucCTmx3kXvPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTPY9Zy\n6+kMmXIT9PJCCzFSXi3d9DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDBE2KvBTLeOWKFK2wbdWJBIuq+pnMCWl3/FLzHOpcalwIgRdAgsh4faVEM\n3uhQmHoNpRJUEbep+bcukQrbxBek5pw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5923", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5923` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAS/hxWE4HUKQTAjr/O9bLgvUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExZTU1N2I2LTVhODQtNDJkMi04MWE2LWUxNDM4MDNiOGZjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA5Nzk2NTMtYjI5\nNy00MWQyLWE3YWYtMGJmMGFhZmFhYmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3x6QEKk7Y2iurOLFoB+Nru+rrrEQORz0ycWundpSBYDGPtFz+nvaEMZzMlC9\njToZJeIlCYnFHJQlI/EyfZrxJ6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR3+hPRXC/8LNu3yiKXb97CuHh7KzAfBgNVHSME\nGDAWgBSFa3SubgU6/3XZvozHSHd2Ajm5XDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCEMuApV0KKqj8Y3jvyRbx7L30lNURM\n/rApR4CMT4IVhQIhALxGuzqzW2TSoeXCPlC0m3x6LLlbm1bExOrGPWZf4KwQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb0n07e5S4HKcrT50NXRjxnyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWU1NTdiNi01YTg0LTQyZDItODFhNi1lMTQzODAzYjhmYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQktl39nJPNpYIqTWResy5LQhol4qivE86GxFT0dmkauz2y\n9cqLsTKFX+NOyyK9EwCpchOtZlSmnGJE+NtZExKYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhWt0rm4FOv912b6Mx0h3dgI5\nuVwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZFjiuyqU4hnJoszmq93fKKPUonMUEtDZPrbt7ZaTAKMCIG5kfY0Sn/++\nuADllUeSgz3lVGhCFbttrq5MGuXL/LVK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAapofiu1z7MdzqH96LK6VpQcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA5Nzk2NTMtYjI5Ny00MWQyLWE3YWYtMGJmMGFhZmFhYmY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMzNkZTFk\nYi0yYzc0LTRhYjYtODhlMC1mMjNjOTA3ZTNjMWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATuC17N+C10BRf6tAHdbkyvyA7gnrsqT5gSOhWWPtqXvYT7dxCMIARt\nmQrfNK1AIO2QDqMXbY1IQRj6yMk3bMUno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR3+hPR\nXC/8LNu3yiKXb97CuHh7KzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCICcSgca02uoa9LHkChGZ8Rr9XcCBO2Xur1M8Yhzo3VUaAiAIfONJfkTW/fZt\nJJLdJaItc3z4h2TGE1tnusEVjuzJJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5924", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5924` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAdLUkh8edPJeiEPNhXjUIKydMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyOGE4ZDgwLTcwYzEtNDk5Ni1iOGI0LWMwZmM0ZDY5OTYzZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM2OTY4NzUtOTA3\nYy00ZDc3LWI5NDctZGY2NDc4MmE2Njc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5aKVr/dpRYadbvWcXFrR1mNk/m9ByBCpgzOZMA6HzF4xekiMbqSBvLL/AUYn\n+hKutrfHs5ugpQadBKSKnk/O+6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOLjzpmumBC4WvCZn4b3JbZsCMBgwHwYDVR0j\nBBgwFoAUrUOE/24KfqOfMSBdnWt9HYjrgwkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAwRSmJL3zynxD3\nHc7Wvxu0OnyP4aE1Hd9WDDnPlKjD3AIhAIG5056br1jFFqinb5EQydHKxJSHZKCE\nqtN201p5f2i0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW8mMRsybJB8U8AN8/rj2N/CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjhhOGQ4MC03MGMxLTQ5OTYtYjhiNC1jMGZjNGQ2OTk2M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6gzkoA34mPIdEqOqDT9NSKxLNhluqkIJBIu0NEyM1xUVL\nHtFyXmt7jAMky2Nx16lLTtcyJKNNhqdHGJDXvZKco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrUOE/24KfqOfMSBdnWt9HYjr\ngwkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG7CB22SlFQSV7yxJZQ2C0XTdvdSx8+RtPtTRhAgQySoCIQDLvEkM/DLq\nVU5POsb6bVa/y3qRoOAseZG1/VK7PIVpZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISARZWHPEqIHqkoLbO9v64EwE0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM2OTY4NzUtOTA3Yy00ZDc3LWI5NDctZGY2NDc4MmE2Njc2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YTAxNjg4\nNS0zNjNmLTQ5NTAtOWFkNi1mYmRhYzVkYzQxZWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQSvAjS4ehtyb/r9E+9Z7z9igOtv7QqVhi3vbe/j5COgAKYT3pg5i1Q\n+0MpT/YDicfFYN3nVkP0apJCVyMMtyIdo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4uPOm\na6YELha8JmfhvcltmwIwGDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDQiqAiho58aZ0lH0R5/RHTITKO+8w7lB0eA4hKQvb+BwIhAJv2DMkwYN1w\nvs8z4lKHgnl8NUWAz00RcPbJ1paKGJJY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5925", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5925` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASOPB+DvnxjW+y5SX/ZKu2DBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyNDZjZDlmLWM0MGItNGYxNy05NGI1LWRlYzEzNTdjYmJiNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThmMzY5NWYtZGRl\nZi00YTQwLWI3NzAtOGQ0MTdkOTA4MTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzOq9G/YAURYk/f99IcYTC3BM3NVH4bPaNWUkHveyF30YtJ0OVlUYppn+ANOj\n7GGW0hy1WyN6X4Xj7RZLpfRXfKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs7XshJyWslRJmoeGDGJJPvyH2YIwHwYDVR0j\nBBgwFoAU5MzB3rujmd60qDNsCTkj0Y7sZk8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA0iDbF5Vj5C+H\nK0BSlyNf3ne677ygL1w1RNWRTvKfNqACIBwAu4fqCsnLRHqeGXe5KtnfnuxXemqO\nY6es1UKvwrdx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZTfq69m0GFSnHyvziyQkb76MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjQ2Y2Q5Zi1jNDBiLTRmMTctOTRiNS1kZWMxMzU3Y2JiYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPsFpbe5BFkHO1rg0c98YgHCzOPa13x7HRjH5ftceLQO0W\nxp3Qt8cT0MoJZGkFbz+3GCK6R4xRXFlOgBDM8lLao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5MzB3rujmd60qDNsCTkj0Y7s\nZk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALBTMZ/SKOwZCm6ZpMKo/vFjjwF0lONovGEpyQbok4mZAiEA6YCmfI3g\nw/m0knmVmYLfnXE9rUdt76hKSIyWTZeYcKM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISASBS40b81IFF1G3+vaTB9K+/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThmMzY5NWYtZGRlZi00YTQwLWI3NzAtOGQ0MTdkOTA4MTVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjODQyNDYz\nNy1mNGRmLTQ0ZTctYjY3MC01ZmQ4YmU0YzZkYjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASsuKuAvxEw7yyd6iKgmSfaEZ0XVYDbdW+hJBru/wYlWStfLSBjAuGz\nZZwOX/51HysgQE6lNOtgbUDCwWCPOWzFo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSzteyE\nnJayVEmah4YMYkk+/IfZgjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCICVvht17gULaQ9VXbFjUDwHvbF1vELBJ64YgF/AWCfcTAiA7ty5h2fWBMwBO\nzUpu8lPKAKtBja+9CijUcADXntNpvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5926", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5926` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAfYIOKth9vviOZfBILTBT1obMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxN2M2YmU1LTgxMDUtNGQ5Mi04ODllLTRlMjkwYWQ1YjRjYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZlZTM5NTQtNWEx\nYi00N2I2LThlZGMtNWFkYmEyOWIyODE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj/73TMHy63rMXBDjEqrV/z7t2vsRXvAFumDLFR8ogtY3By4Vbyv3ALRIfUr/\nPtDlGdir23hGlZnC/q20ftLy9aOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcbe5fI6XQZKoalj/lFpSIRk/IxcwHwYDVR0j\nBBgwFoAUe7pARsSML8ZIYzCTOSUQNgzaQ00wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA1CsYaeG+sp+9d/vXjlvn\ne6J/4GEObLAe7DEJ2vWOS2oCICIUlfNIXpdmVHeJvwpDMtLzthHf49WOwYuDb79d\ng2mA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeEydPMwa+QE5AVPwXNBanGKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTdjNmJlNS04MTA1LTRkOTItODg5ZS00ZTI5MGFkNWI0Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIPU1rZ4czmV7cULT9/lyzeN9YBonq20pglh9cL5jYT/12\nrtdWlP5Sh3BvnifPHtIbZadtUo4KRjeVgXHmW8lyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe7pARsSML8ZIYzCTOSUQNgza\nQ00wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge/imYhBGoEQID37rHIqp2yXFdTY2zV1scNTtIiDmzp4CIEUBU1nzaYj6\nVBq6VmlOKIpvaAW1ZWu4HFVT7cMUZ8RV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAWpdy3lmA7mVIx5j/TT329WNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZlZTM5NTQtNWExYi00N2I2LThlZGMtNWFkYmEyOWIyODE1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YzU5YmEx\nMC1mNGE2LTRjZmItYTE3Mi0wNWI3OTEzNDQ4ODEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR4ZDxpUiz3kQnDSfkRx6Lfun3GOCF890mbTu8+vEvvbo8wvaPH+Mb7\nNv2YPAtHVr4XtidRf+kzOe+4VSGYcZ2Zo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxt7l8\njpdBkqhqWP+UWlIhGT8jFzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCYnQKV7KoNOVMLgVq20T88s9jW4leh2gGNNh5l6OHB3AIhAK7gZQljcUti\nX5P+Bw3Al+H4z6tc4re+PRY4kbocT3Av\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5927", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5927` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAQnbSPHCTNUZPStW1MdGK5qvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyZWExNTI2LTc2MGEtNDQzOS1hOTNjLTg0YzBhNzMwMzY5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM4OTVkMWItODU2\nZS00YjA4LWIzNzEtZTQ2MzdlYzU4ZjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXDXdzjYhxdZDt+zTCWoKzpTkneD09lpD5XP8VxfwuPkUAio1XdKt+Os7n+zI\n/MEM6uRMwW+XgpL6y/MCLVJXQKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUee46poePDZUSdg4KmjckL52FNZkwHwYDVR0j\nBBgwFoAUhdboUZjoj4nnuXsS727FQC1ZBwowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAo4XT\nnTSM7XC+8Fqk7XBMxsclaNvoI+zTbl+O31BFAwsCIDUqGm5pR43dP5QnT7cKmifT\nNJKlSP7iIirYd5o1yylt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQWcHcueLqGtqX7JE7+2vFXBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmVhMTUyNi03NjBhLTQ0MzktYTkzYy04NGMwYTczMDM2OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4RV3KVrymiEUtVEwj7dYpbFVrmmD4lufPHdxenISQJLnZ\nJKeQWFrFnhcEeoEcEwO2m/lY+8mMDN80Lo+UJAK2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhdboUZjoj4nnuXsS727FQC1Z\nBwowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIoaA7KbRxFulW3FnmB9hhB12hefkDsTo/9ay9ujzeNIAiBSxh2amjEU\nI2F+nI495VU4sPuRO5yoGnNO+u4lAlR1DQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAW9krxHUUL8KenRsU29ZELKIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM4OTVkMWItODU2ZS00YjA4LWIzNzEtZTQ2MzdlYzU4ZjA2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MGJkYzk0\nYi1kOGYyLTQ1MWMtOWJlMi0yZGZjYWVhZTJkOGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASj5VDT8HbtNrVYdC0kqsiQknaHeMQLDDOdAMWXNEm2kSPSu6ySogRs\nMNb8DJH2mbXfHEYuEuMe1PZXaSCsL6eWo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR57jqm\nh48NlRJ2DgqaNyQvnYU1mTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCe3cyBEBHSpFRsaJn54FMo8qMAvFEWQDZ5pKD4fOjaewIhAPQb9OJ9DubO\nAIICJozb9qfuBg5K+dCYoBvXUlqcvREk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5928", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5928` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAaKTnDKsfeixy7CyzHcaiHTrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0MjQyNzM4LTljZTAtNDE0Yi1iOWVlLTA3ZjcxMDQ5OGQwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTFmZTEwY2UtMjAz\nYi00ZTZlLWI2ZWMtNDllN2FhYzE1OTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW7geE69w9uY9FHTGpzGg/fFYHB2EB0gDB2Mj6fJ0MibkNxFJtKeehLygbLPd\nB5rOkODrwanJN1OmOZyYPTkCYKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaLXzBrVaW+qmQlqvVQ8OeCZuwC0wHwYDVR0j\nBBgwFoAUuW+XSQx8YJwwHy/EDZkENRqLBMowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAOUN22\nYyS9WnNJb/yg4Vht8nQTAduEjdqRSauMxsb/TgIhAPaFSfcd3qZ34Kz5IAefWcKz\nQXai/wne9gsVlLcSiMKw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW8muDYzyPrUcQtfkK8nrdEtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDI0MjczOC05Y2UwLTQxNGItYjllZS0wN2Y3MTA0OThkMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdj/03aOjPcv3m2UkNtKXs41f4sk0Gs9cRoWFbDhizVcf0\nhrO7z40lc/oogQCD4IGsvGisQ93OE/8iIiFz7X18o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuW+XSQx8YJwwHy/EDZkENRqL\nBMowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMXcaWP59udwRN+YNMh7QkLImT470dkEjhv/BftVyCLACIQDDcxYlURPZ\nPgH0ZXVHeIIJ3cN0zvx4G6NW/EPKxQxeJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAfl3ylL7bEqaVI6daF+JZzCwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTFmZTEwY2UtMjAzYi00ZTZlLWI2ZWMtNDllN2FhYzE1OTc0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZTgyM2Zk\nOS1iZjAyLTQzNjMtOWVjMy1mZWU1MmJkZWU2YjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASeUEGxN+vIzGyg+hpX59zThHwNeHcuDHFtxe+b+BN4cD7DvD7YYsOG\njatJ6S3vUUNFOt/jaFbiNmkayGn3aAvEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRotfMG\ntVpb6qZCWq9VDw54Jm7ALTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDXFuy6ZUNAB5oujZqcvJYjkPYScTPf1uvi9hryIr1M1AIhALtZXVNsEuEa\nyOrWPyBLEgptLAPWQSD8aPKRp2HV4cxQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5929", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5929` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQkljVwdI+4jI2aJ4W8w5szeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MDc3NjMwLTU5OTQtNGVhNS04ZGIyLTYwNDI0NWNiNjBkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBmZDgwNWUtY2Q2\nYy00MDJjLWExMjgtMmQyYTM5ZmY4MGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDrs0btX5FkWTfTDExrPR/Z2aNETFVdhnRhk9tRB+AopNNxWORyQ0yJ7illTc\neJhHsy6fKfulddus5muxWyBu8KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBSObcJMn0wPX/5NovOJ+hvuTvIbMB8GA1UdIwQY\nMBaAFN0LX1ubLUpAG5AuW3xjqak8Ws4VMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA4Ci2nzhZ+yOqDEOa+9BEXZnx+9ECw7Mg\nhsw6TRL2Y4UCIATCdrJ6ooeybr5CEtZKeRnARksI2U5XipA0gHQJdfV2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXHXjSO1HyWyWG/xiiu0zWoJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTA3NzYzMC01OTk0LTRlYTUtOGRiMi02MDQyNDVjYjYwZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnQv7+st3/epSVllExymtnQWFjJgNsxAerqQbwxF5uZ+Xr\nvga8bopNOFHI9c5GvOkrlnOmVkDgUF7KAu1GKBhgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3QtfW5stSkAbkC5bfGOpqTxa\nzhUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLIytX1rrWnIUJLx2NOk5IMGJndyfWJydlVFdnjhGvpkCIBcEhKHGb3pL\nllMlMaff+TZypOtzXeGkZK7orMoFfpMU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAR7xAOHD1VOSvGWLIm8Rt17wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBmZDgwNWUtY2Q2Yy00MDJjLWExMjgtMmQyYTM5ZmY4MGQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MmU0M2E1\nNy1iM2M0LTRjYjEtOGMyZC0zNDIxOGNmM2FlN2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASXvOXzaWkNQuPgXRyAMPuHYPI14iDJgdJkwUuOwLGYENWpq9uxiZHm\ncFoZ67YyrQGtD2CLUVzugNLsWkC+dlZho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQUjm3C\nTJ9MD1/+TaLzifob7k7yGzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIHvAZPjQ8wpgdzID4KxX1UFaPLbk7ME4mOrN+OX4YY8mAiBTzfHUVSoLRF7A\nIoc8c8OIlTJ2fTqJY+CHssLtggFsQA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5930", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5930` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAa2AJBPUrmNUN+cNULf2oWTWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZWRmMGM5LWY5NDAtNDU0Mi1hM2Y5LWMxNmViYTYzOTA1ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWEwM2QwM2YtMDRi\nYi00MjE3LThjZDYtODU2MzBmMzRlNGVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuJSQ58xkuKOSbJlOztOGVhBMfFyzjTHtIPxhvWY3eEyN9V3PzcVahXwb4/Ez\nHEAxkIzae1EvRzRWOKzjTIn+XaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3UrPex+1OrFOtNa18YKHGSzVA2IwHwYDVR0j\nBBgwFoAUpHPMolV6A+obrSXveJQsls1YCCcwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgEuthijQstgIo\nYqdfnPpdTykcK6l+hWhmIutx2FcCo4wCIQDZNm4/71dnfrWhNW+rRicyPgQqu/lN\nFHOuepyeJtdqgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAauvdTpcIA/Xwqn/UbxzqtERMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmVkZjBjOS1mOTQwLTQ1NDItYTNmOS1jMTZlYmE2MzkwNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkk6YrjQ6nqwIQ7any/ZbSVqdWse535FHEXuv8T1+pgg+M\n6YQHAM7uah4W45JSnJtePSHWEu533+4z3r3mIV8bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpHPMolV6A+obrSXveJQsls1Y\nCCcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI0jqX5trjNNCbBILsnB571rPajG5SZQZhMuJ6tuTtnMCIFweGjxULrb0\neLzTvP+4jGFAMA6YHy9r29zketZTfv9S\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISATHrHqpvcO4VPnNYFqhGLfq2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWEwM2QwM2YtMDRiYi00MjE3LThjZDYtODU2MzBmMzRlNGVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYWRkZTFj\nNC02ZmZjLTQ5Y2ItYTNiMS03MGM0NjBjMzgwM2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQN8kndm869LRpC5azoJvj6lW2LuYtHkdCJE3JkRLkAm9HJLlK5xisf\nE9nFRxMOTK4SMw38X0+YtY9P+128LqRNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTdSs97\nH7U6sU601rXxgocZLNUDYjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIBIgO2dn7TyiNPwd/daTuBxJIsQ666qdTdqqu9+drxfkAiA5dUCUDAO/Sxtl\nVwM6RsFwWHPCtxFlZJ7Q2KjZiaZ6jQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5931", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5931` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAYqfrMCIotM1rcnA+r+1mbq9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4Njc2OTUxLWJkZDEtNDg3Yy1iNTA3LWZkNGQ3YjRhNjNiNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzYwYzcwNDgtMzQw\nYS00YWJhLWFmY2EtNTIyZWVmZTg4ZmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElb1xz8r+5N6wFOwBlR+2RPpcux+HiN1KfPM4k5AOIdohYVSnjFILtsr5rNaL\nE9R3z2AimIyktfJ90F//1QA/baOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWlu2Zo5z2B2vQDThQZv4H4+crbkwHwYDVR0j\nBBgwFoAUQATFJY7O35Om36MtRqPpMSDkyrowKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIhc92Fq9gt5\ntB4e610A6OaaCidueBmOu+GztfjTM3kyAiAyh6OQdN1VN4Pm7KBpUS6ICDSXm+Uq\neJwubM1zs1VAAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAahiIRTv3MC6zDDZEuMocl6CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODY3Njk1MS1iZGQxLTQ4N2MtYjUwNy1mZDRkN2I0YTYzYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH/HB0zi7DdEM5C8r0FgVL0mr+BEMYkkMYzTO0sRYIZKwO\ns9qIutjRlMuO3LN7a9i9mRZSSCYq66t07NaSoEfpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQATFJY7O35Om36MtRqPpMSDk\nyrowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPB7vaAngd7Y1rXumigXbyV79ErTdnvpuha7pmxUCbDLAiAwW2A6i/5S\nkUIMhyzqviVqcAst9LDVGx7/0sCuG8LhOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAYrL2a0doW9b+bwtCzW8a5FxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzYwYzcwNDgtMzQwYS00YWJhLWFmY2EtNTIyZWVmZTg4ZmIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNDQ0ZDBk\nNC1lNzEyLTQ5NmUtYThjMS1kN2E5NzY2ODFmYzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ1h7hVG7uoPdK0aYOCUNFK+/ACe/j9WZDOD7dJQxJkxSmPnTzaUoTM\nZwvLvDycIf4EAFX5Bb8d1LV6X+w8AjsEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRaW7Zm\njnPYHa9ANOFBm/gfj5ytuTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCoAYcQ1+U3voVflYnG8qsQyDtTDpcZwnIoWUG99G25PwIhAM/hdBfrOKp2\n/4xQ1QU3++aGZ7HLWHZ+EUX4hMHHKCR0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5932", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5932` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAfBsjANS4kl9CQ6w7loWJmboMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmZDQyN2JhLTA1YzktNDk4NS05MGQ4LTdlOGE2ZDE4NmE4ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg5ZjYzZTMtYmZi\nOC00MzVjLWE3YzQtMzQyZGE4MDYxOTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbaaIK6jKJvgC2PpjyzXsJTtRQ+vDd5viRHptFtFvb2CbfparqEyxoVmYMVzK\nOjkRqm1KPrHOt55qBJAvFfUSwqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMzSHBauA5/DgohdNgvgyL/FEthIwHwYDVR0j\nBBgwFoAUYLmz+EKW1V6p9PIUnVKsqAtcqEwwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCFDoJAssgJ\neJEPZ42c7hOygPVFaThgMxOhPfffsncMuwIhAKmWE5ndRVVrHFEfz0GZwcP1lUVf\nEsFhuKpX4TY2A+45\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVJK0PjXs7bB31lJYIEaQXd2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmQ0MjdiYS0wNWM5LTQ5ODUtOTBkOC03ZThhNmQxODZhOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0ESP2UbMVxqyqBUcAgsI92MxiLGgQakZ8mI1pY3JVbdrt\n//Lm2MzRzYo/71jydl9SE06p56VgOLIdFswcrkh/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYLmz+EKW1V6p9PIUnVKsqAtc\nqEwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMfhbPxNk8WprM+swhV0mWYs3vjDG/DZfEAOw4mkToKDAiBoMStH4mmK\nDDznzkrQoulNPTS3LiF/9E1nhfL5/AONGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAY7DU65A7Xr3SW6nR89nZOPiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg5ZjYzZTMtYmZiOC00MzVjLWE3YzQtMzQyZGE4MDYxOTI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MWIyYTk2\nYS0xMGQxLTRmMGYtYmFlMy1hNDU2MWU4ZDAzNWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATw4EJzLcQRSWLkxFqJ+MBinoV2ZfxOzdq4Q3Mz9V9Lt4j8VTE621WO\nIVlqDX9BSrP9fHASlKGd2i1sOVOJKy6zo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzNIcF\nq4Dn8OCiF02C+DIv8US2EjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCICt1c35ykdgqtqVcMZrLjVS6Spk+XMYOiXenTW2vCNsPAiEAkgpkmNhSAHyj\nVAi2eJ1o7OCCeS6wfI6gMHFwMQK3UKo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5933", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5933` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAfGN0Q6SztZyVH8sd59f0rPtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1MWMxNjRiLTEyOWEtNDNkYS1iYzYxLTczOTEwMmE2M2E0ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjIxZTQwYWUtYjkw\nOC00ZmMwLWFjN2UtYjFmMzAwNjYwZThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/3cV/cMCR3lKjE8u6YUB0VhYRk8rYw0Rd2cUnki+/10C81vqkM7uV+eQsNQM\nmQqS9qvwut+7m2XUYTEidf8cvKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkN2BrwoCa4Bhy41GvhPjLTlCq+UwHwYDVR0j\nBBgwFoAUDTufKBwHQWLVWpdtee2H3RQbCHMwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCbdIc2XLBI9ZR/+Sna+RSOv+dJgApdgpYQxtcWYJuvkgIhAN2z/5lNsO8L\nrpQ83MeATekzoi0G4ktHCuFHsBAjk/v7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWsV4A9HzcLICULMRX5u+k/oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTFjMTY0Yi0xMjlhLTQzZGEtYmM2MS03MzkxMDJhNjNhNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWCY2ZOIOymuuPNrf+Ej6ZSptGGU7C/pPE3N/g7tIYKovq\nixwYTrO2qCLWQ7I70PvyaKbaHlVAuGd77EjqVzQjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDTufKBwHQWLVWpdtee2H3RQb\nCHMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIvDgIX+2Vy95pdzmTKJ6lraIqSfvOccwDFYlT6uw7YYAiA0c3Q14QpU\nT2hWWFQrWFjterpOJTr5Nj9xmJE9Ex9WPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAfi8fOmtcYxXG+7SOnW4HUIZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjIxZTQwYWUtYjkwOC00ZmMwLWFjN2UtYjFmMzAwNjYwZThmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZDRiNjNi\nNi1iZjAwLTRiMzMtODc0Yy1lNTkxYjc0YmI5YjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASN6E3fMsws8IMbCoYaaZLxOGSwE51w4EDPFnZEWn4EtsW0vMb/K501\nZRkvcaLuoyp6tFJ4ux2T6nz784MxL7eUo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSQ3YGv\nCgJrgGHLjUa+E+MtOUKr5TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQC05exfcuLUc+YXwzchwqI3XMVM2SHe+TEVIz9FcggO6gIgCiGm3vxWO2bP\n0Zt9omMQkJuGPvN2wY6SYw11/91kNL0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5934", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5934` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXcI+ys8BpViubus68Cp7JsCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzNTY0YjJkLWJmNWUtNDBkMS1iYWQ2LTRlMzFlNDBiYzMwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJlZGE4NmYtMzM1\nMy00NDQ3LWFmOWMtYWJjMTZjNzg1Mjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnIEUvzPuhiKC5BrOMervY+l1dr7ps1pSyVVOAsNkAH3EeScK6EF+FvdwoiKh\nIKU2pVhl4mKoiaXaa6L0zu2MCaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrdLaETotIp6YKk5au4TQMN9DGmwwHwYDVR0j\nBBgwFoAUurdimymiCMov0U6U1CKKbjjk4nwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICMwNbhJCiN7mh5inca8VTc79N36W07ljr//4MLK6r/PAiEA4XROa2Uom26i\na2x63emAmrxGSlcaDQR7Jn/QdIdvDrU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS1GFUntAVZ5QbnhQXJbIQohMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzU2NGIyZC1iZjVlLTQwZDEtYmFkNi00ZTMxZTQwYmMzMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5g0mGEsQn0xnrKDAkvH28c54IkPajnCjsU8pU83qEOW6N\n56WgZa92iBUC8IHPLDqhV+JdT8z5vyxSf5dcRlEco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUurdimymiCMov0U6U1CKKbjjk\n4nwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG5m4YumC0ToPQROJKn4j6aITMaF8nAcNCOLSLmW85lgCIQDkhrDA99Gh\nPETgdR6vb/KxWggjk3IDvNc0UV3EGK/evg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAYJdtNXZyYAyTHT0/XILleeMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJlZGE4NmYtMzM1My00NDQ3LWFmOWMtYWJjMTZjNzg1Mjc3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MTZlNWEx\nOS0xNzVjLTRlZTYtYWRkNC01Njk4OWU0MjRlMjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQM04dbw8pmbfazIU+s5Njy0kposjdRCPbmPPtHLycDyMVy4oMi5yab\ncJXIt3ZOpJnbQ07qUlhMpegt+UotjF4Oo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSt0toR\nOi0inpgqTlq7hNAw30MabDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIFlMvzprKXKGahg2KM/xPHo83yIWE2MWU7U+73yimBF1AiEAqlXyqBT5wFbr\nYFm6c26lXJJFVSaQPzfgjvNW7o4z+3o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5935", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5935` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAXXELv3PtAqwTiG1hxReJ/5jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2ZDhmOTI4LWE1NzMtNGY0ZC1hMWE2LThlODM0YmQ0NmUwYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM2YzhkZTItZTVh\nNC00NzE1LWIxMzktMWFkMzViMDI0YWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEztl5P+IOF4QRq18dUeQPwrNtdh/xuiri/uda1Q75eh04horXqK5sl0Ax7a5h\n464ragSmk9vwKs1hi4QKUXzWW6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlI+uyaPsrK8BuGUTtYYsh3coefkwHwYDVR0j\nBBgwFoAU262A6Df3g0FeIAdP9Kss0gaWh7wwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCg\nbEaHSHOp17bZvDCeIYyiCi7tRm4HnEn8WPBy5CrJsQIhALMfxF1OyMjiu11rH13M\nbsBbI2Zv28O/awvYnA8U8h1/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZwDgNoJfuR1bWx/xU5hBmdpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmQ4ZjkyOC1hNTczLTRmNGQtYTFhNi04ZTgzNGJkNDZlMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfNwOWf1Rx79qFBJ6XhnC7CiC42T1tYK4yclvLY0cM+m68\ng+VpAUxcY5cGMFLkIBFNcMJ2r/VuoUdxrPfRKpFLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU262A6Df3g0FeIAdP9Kss0gaW\nh7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEsExkrH9JOEw/DFCd0R8YHyM0rKZptN7mZWA8CXv/yYCIA468bPji/Tg\neY7wQ1pVrbLYwWIq3bxeucrFyOE0JKnP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAY+hIoWm+Hhd7HGI1u5t1OJhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM2YzhkZTItZTVhNC00NzE1LWIxMzktMWFkMzViMDI0YWFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYmE5YjRh\nYy01ZmI2LTQxOTQtYjRjNC1hZTNhMTRiNWMyMDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS/FySzMQXqmKVJ5HgGYc3TNDC+5vEQTlmtftC1MI0lLn2A+JMoiQX3\n0fhHnHpo3XeSnMyoqz6FeemhiiCA3FV9o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSUj67J\no+ysrwG4ZRO1hiyHdyh5+TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIHTgy6hIt34wVBpnYIvfTuO0HtdoeJVlJdEZkdcoZBdnAiBmlq5Vur3N5r5k\nkQ1LlFVKl6NTvEw/S6QfRdC5caDBwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5936", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5936` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZNwDvA9HScE7rs91rdA46RFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwODYwNTRiLTI1MWUtNDA5OC04ZTk5LWE5YzgwMDU1MjhjZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2EyNjk0MmQtYzgz\nNi00MmIzLWE4NjQtZTUwNzExYzY5OWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyEw/e8A3IcXRulU0btnsTvz0YBSYmoa5sBGbt/KvC9aoadqiSZtgLJCkHYYv\nCgp9/3M/N9gszPRvEy1wUvYUA6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmeXgt+KyuF5u7kOczfMRWL+vChUwHwYDVR0j\nBBgwFoAUdvA/+dZekJ8JVMPGlSd0kvunHu0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDlhcRGJvaU+LEoB3t6ZuNdu36Y8pPdiwaX5kE18cdzYAIgW+dM\nzHkpF1rc6/MdlSLYChLC3P1ELtjy8ajh4Ij26YQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYemFE6vxJZbrXn3NpmNg3LVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDg2MDU0Yi0yNTFlLTQwOTgtOGU5OS1hOWM4MDA1NTI4Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuKJ+Kt9223t2QrL+9iVmd3NIsPY3zrWQLvLiaJpx4WCdl\nN4Ar/gny55UTVxsLRrhIaOmvC+CEE7xevcolIDBHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdvA/+dZekJ8JVMPGlSd0kvun\nHu0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANYuhgmQ76rJB6NvhyWvsPPCp6RlrVPlBqPrTAS4SeKRAiAXodDJIEQT\nVXqrnOSn1fKApP6muyc38RqPLi53Xj+hLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAaZRFNH1ZadrEYKqlVkGgPIqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2EyNjk0MmQtYzgzNi00MmIzLWE4NjQtZTUwNzExYzY5OWY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZTJiNDJh\nMy01MjNkLTRiOTEtOTUyOS04M2Y0NWJmOTI2MDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARpbFrWqQgc1FECk6bFdGc83yHT0SnLgq/ku878LIc6aOUZJbN7IdUd\nXzau4kG0YyluKhKjZMduaLrsLF9b/3sno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZ5eC3\n4rK4Xm7uQ5zN8xFYv68KFTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIEpRn5vb2khOLZI9gHbWX8EDhiHI2cMxM3PCDRitqC9jAiA30ntEQC5W0wEO\nUlJOk+eyvzGiiAUAgFSJnLgw+o6wOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5937", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5937` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAdzN9I3XWxWRXjKKhBA7ljq6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyNzljMDU0LTkwYzUtNDFmMi1hNDg2LWM2OTZiMDU3NTk5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAyNTc4NDgtMjdl\nYy00NzVlLWE3YTktMjRhNGRmNDNmZmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh849skdzMY3Shu8bSa7Ue5TWlbI42TtU5dfecHRQTvK2TYMEjOGirp4gEEEo\nw+7uOCsldCFRr60g4bWCvEqbsaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWsRkT/W+rbq7BiYW8BnKJ4LKujIwHwYDVR0j\nBBgwFoAUxPNDbbiFyNzHOFIjwuoobgm7kWwwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDb3jrBQL378dN4hN7iNjn/pUfjGJryI/nqn3qzLHe1RwIgPdMP\nAaDeuhIxc6aOqY1PL07oJ0GJCySrOVzB60oM28U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX8ae5vh9fyb0RUszIu2IsKAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjc5YzA1NC05MGM1LTQxZjItYTQ4Ni1jNjk2YjA1NzU5OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYEG7aBMQa+5+X90NLHHgS8JK9P9xssCz19JdroEG+u4Zf\nrfdpfdA/ESZsduq8CaMVtnYlwHAW+Au8gmIOJLWmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxPNDbbiFyNzHOFIjwuoobgm7\nkWwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL9AEHH+q0ILt0DXqudg41vCY4Yz81u6/KFw4OkbcuHwCIE82MVbmfc5P\nc0TZvFVOvo+NedqbuM6IswiqXRLwW90J\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAY8dQGUgMOujJ7NwCYF4p2vmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAyNTc4NDgtMjdlYy00NzVlLWE3YTktMjRhNGRmNDNmZmY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0YjcwOGRm\nNS1hMzcwLTQxY2QtYjBiNS0wZjc3MDYzYmJiNGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATriambILx3yjFqtsZ/sw1GVMF2vaMzZNGhrf5gYtvPsAemuiK0ADx4\nBQ3ye2KBvtatnnbhP3iUayAZlMAyAZCFo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRaxGRP\n9b6tursGJhbwGcongsq6MjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDhYF+/24J/vFliNypDfrXDlZhW50qW0tM/drajZzQr/wIhANI7HbR/SYjC\neXUtYU/JbPItJ+qbLcuoReeItab7j9lF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5938", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5938` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZER36eqU9AIzXAwgNi4V7N0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlYzJmOTJiLTIxNzctNDYzNS1hNjdjLTAwZTJiYzQ5OTlhOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQzNmUzNTQtODhm\nMC00YjY1LWI1NWEtZmUzMDYzYTk2NzllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyAV01V425vZFe3IHXZHSstOC2XIO0sVa8tSk5N40ASFpxPUhP+dPPl+0JSnu\nPp3kd6Sn1zAA1woIsYi/t1AwsaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGIwwo1rYldeB9tfPV6WQg/XVeOOMB8GA1UdIwQY\nMBaAFHccm7bBcuT8Y6t6G9xT2Ga7WI/AMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAjJqzeh2U1L/B8A4pkQjWcZq/HPLsAurN\nmofdcq8IAIECIBWbDt5a1yjjTw3fRTo1mVEJutPD7jf63c1C2FIHppN+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWACOXS//83iOzmM0vF6RrOjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZWMyZjkyYi0yMTc3LTQ2MzUtYTY3Yy0wMGUyYmM0OTk5YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASko8eBalBWJwv4R9P8+H8FS1oR1fiCf8j4MgVai1qNf6Nq\nt5yZkchQRKFEljC8nhWAhhW2mv+FyT5iWaNDgShqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdxybtsFy5Pxjq3ob3FPYZrtY\nj8AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM2vZ7HmlvgoRCZcAbdLXvrSGT7wMoqjpt4034CjpghACIBNKTC8SYkVD\niZyJWtONKIot22QXQNAQxZRq50si774E\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISARZgk3g0zdhM3U8XgD6FnJ53MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQzNmUzNTQtODhmMC00YjY1LWI1NWEtZmUzMDYzYTk2NzllMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YzIzZjNl\nZS1lNjQyLTRiMjEtOGNiZi0xMmEzMWEzMWJhNTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQKaDqH2gTHbwA6t9D9IOOjd43HnNGlr7w5tKMP3eYOF5b26aY38Me4\n128ljfMBjq+RT7x+/ed76paTFALDj/n7o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRiMMKN\na2JXXgfbXz1elkIP11XjjjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIEbj9+FnLqBm8Est5u1myrCnOBqQEXJD/bWKDciKR6KAAiEAlI6f6rCaPqLK\ndvL7bx+j8dORQX/VqZqSudsb/2U3GeA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5939", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5939` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbhIs4wxWNwxzQy/yk5dcDf7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZGEwOWFmLWRmODAtNGZjNC04YWZkLTdkZGY1MzcxZDE4NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYxM2I2MjAtMjZh\nMi00YmI0LWE4YWQtNjFhYjc2ZDJmYzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6vOr1KEkU/dPLa0Cf19UhsnP4KV8aSdQaX4/I0rqUo7LsmhwimyAyWggrb3g\n5moQGx9LfmFJeIEDiLhFQvdOkKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjZrhsRoh9aEiZHnspqhpMJat08AwHwYDVR0j\nBBgwFoAUwT2/IL300y6SARK2dilK3jQs2b0wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAItWiwrmkKdr\nJAIPpzHIBo0VwciKm9K4bBN/+FyM/4GUAiAvZUHPB8Eg0Q/cNTMseYtsYqk5e3LH\nIrBxSNBFfU2+6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVsjK75unKG/Qfp19wpGp/ziMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWRhMDlhZi1kZjgwLTRmYzQtOGFmZC03ZGRmNTM3MWQxODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS38RUeOJooyUaQPVKzzXJE7BaLNt+vfCQWnKFqkJh7wudI\nlxKm0KZLDYpLdrgcsVif3hu6Nt2wY6X2r3lys9ZJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwT2/IL300y6SARK2dilK3jQs\n2b0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGPhYSOUn943+RG7bXYHGE9QnNrOwl/t8njIMWAURKhMCIFS86k81Nvzh\nvWKuWmQ3eZnCKCbMGb+to6M4t3dpttxv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAefqShsIu19pmpjJN4KPUOHpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYxM2I2MjAtMjZhMi00YmI0LWE4YWQtNjFhYjc2ZDJmYzEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYzYwNzgw\nMC0xN2IwLTQ4ZTctOTE4My00ZDQ0NTcyOTE5ZmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASnBk8nnMp9ROeKaSpR1qm78UbPyJnrbKNYEXZnh233k8G/tj57PBOn\nSk2VTcyX01vaJc41CB4BdZ+rtJKx2kYeo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSNmuGx\nGiH1oSJkeeymqGkwlq3TwDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCnjv/CvfeorjpLRhB2lGKjEfKwlyu6K57r+AsV6sCzZgIhAMo7t/X1WOnc\nsLpPzVNfMNazUGAG1XtRxTBBH/waugIq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5940", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5940` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAelRJ0vTY+8nUFMSye65uBEMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmODIyMGM0LTQ0ZmQtNDFiMi1hM2MwLTYzNjRjNzkzYjZlZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA0NjZmYWItNWQ3\nZi00NWUwLWExZDItYzdjNWZlYWFkNjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4MJ2RsbV+EbgQf2YZ8Yjt/A6t6tx38Y2gp2A7pmTMoPg9jeOQZk1usxOPQ7y\nsUal2oj85MrRfhjLLxF9lV5oPqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG/sjUtLFm3kKb1+IIRCGJfJmz5wwHwYDVR0j\nBBgwFoAUlKeCW/FM4GSJMxFW3uWContMYIIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgCf2SBqIpK/x+\nlx4Gdt1lfCYIF09srquy5ypTvby9UOcCIQChggEMgI+R6+UCltnkHTva+vsyIW9O\nuQyZs1q4oIvq4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARBx5VLsIMrhgbr7AOEWHaNpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjgyMjBjNC00NGZkLTQxYjItYTNjMC02MzY0Yzc5M2I2ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxtxoxlsBRLIO3lwtluRCSQMQrSgzXiGFMryQ55ghB9qud\nKsVIofeoWs7pZWeHdKmg/CExXzJCxZN7DHKOlZzTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlKeCW/FM4GSJMxFW3uWContM\nYIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOqb/bDHcR1dMUrlT3OPN1TtvQ5JzVg367CUim+cpW2fAiEAvXOmNzl5\nSK9lpdUFVjRuJiKkt3SNfOh5OQijWpsekq8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAQveW8YTFSfihLrbYxD50bCUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA0NjZmYWItNWQ3Zi00NWUwLWExZDItYzdjNWZlYWFkNjM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyOGViOTg0\nMy0zNDYyLTQyMDgtOTNlNC1hN2E0Nzg5NDdlODMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATokOC0xrGb7GdsTns/aWp6UxWDset9v0xF2YlLK4iQYwo4UxbnHtoA\njJWp/E0idEufqFJgKr5BsQ8O9nT5x/tYo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQb+yNS\n0sWbeQpvX4ghEIYl8mbPnDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQCZpq4GUspAXlLgeO+wnWLet1Dh/kTKf/NBZfkUOjxGEwIgYu18FFh2MRsJ\nbOFTLOkr2Xyloy0WeKYVhe0l96t1K9k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5941", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5941` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAasWIGCA9ocRWNjaJ060swsDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4ODJjNWQyLTcxYjEtNGUyMC1iNTg4LWM3MThlZTA4Mzg0NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZkNzJiNTYtOThm\nYS00YjUwLWFiZDgtZjA3MDhhMmI3NTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+14ct9pxQt3WWi8FWh24PDZrUdSoNKJVp9YPcPUEE/bBYRCEVSrRhFIT++Hp\nddA5w3SqlWTcbK6vg4p55Q2RaKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu2TYXFnNoX0ZUGqIhIgKQdQybT8wHwYDVR0j\nBBgwFoAUFdxOXNvBoBjLWifhj2DprHvoumgwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBALLj91Dmgw\nmzaPIYEewZzKRo31Gw7oUfejXvhEqbzsAiEA9k56GVUQ6OIe726UTuVBn/tpd+14\nzRdy6c3NppnrZW8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf00qdp6OjQ5cYT+fZimq4hOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODgyYzVkMi03MWIxLTRlMjAtYjU4OC1jNzE4ZWUwODM4NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQG+H+XKFvrE2KCHTe5GdSaJQi3cdLR83zmAg4247pkIgpV\naUwYrOxnLFmpyhbOMxUWeGymn11IGMedZuHT2LqMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFdxOXNvBoBjLWifhj2DprHvo\numgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPeZYgHS29/MBVxwpKm3xOEnsWpaftu/WHKJodMbhnWQAiEAjd2BN6Ls\n0EqVqkQTZ4xovvypegtIpCiYFWOi95HnnQ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAZbG5KILPxzj2B1TBJ0yO/VqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZkNzJiNTYtOThmYS00YjUwLWFiZDgtZjA3MDhhMmI3NTRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNjY1NThl\nMC1jMmQ0LTQ1ZTctYmIwYy1iOTc3M2YxYTYzYmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARGe8iaxlcSY6SvWpP/c4maikpuaioIpIaFLCDu0A2QsYDU+BPp2mKI\nhOVMhjdohqlGw1GjF1V0WZ6OknLAPRyAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7ZNhc\nWc2hfRlQaoiEiApB1DJtPzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDAM6qeiN3zOcZ2No2lS6ZG3oeTP/mAYW2ItNUnXNgbfwIhAL7l9WsRySd/\nF7ksaICYm6HRzs6J8tLlM7uWaZjZAKxr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5942", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5942` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfIrhJF1Bq0bVOjrKKxlutbJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlZmQ2NDgyLTM3ZDktNDRjNy05ZDdhLTViYTg4NGIxOGFkMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ0YTFhN2UtMTQy\nYi00ZjZmLWFmNWUtNDI4NmJjYjhjZjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ9AQ01UDUcd3VGXdIfYLSc9auaxMOM3gp73LzH/U5WSTFNhAoBHBsdoQUgEw\nf9+bSta1ZOMJqQugWZWXDQKp1qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhWm5CcG714SMKwgDEorTr/cRnFQwHwYDVR0j\nBBgwFoAUa20HZpOheyhqOSgB3O2kgRoqHY8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGVq4ntkALkMsewQ3xBO4QQjA7DBpTc5olPgs4e9jaNwAiAL6ErEmjJdt89g\nUSeSZ/0/vkIEoUT5ThznhnUFJmnzow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASJaavctEAhyVJ9UEK5FGJUYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWZkNjQ4Mi0zN2Q5LTQ0YzctOWQ3YS01YmE4ODRiMThhZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwxQUEkmAskoTj2REecArKfgbRxXr1HYAWEKMAbz0ToVFB\nnD9kfVK0uyzhkimO79W9gk9ul7kBy+9KExLEMJmqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa20HZpOheyhqOSgB3O2kgRoq\nHY8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLXUHG0EnRZhCbtO3tOHWwr+WNEZE1o7PYDQM6W+Vv3oCIFZlhGcSdePm\ncsc3+SiifIdj5f2uclnXbBI436sJ/XBm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAbgLg5SswIt32PYwJWEMRPH8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ0YTFhN2UtMTQyYi00ZjZmLWFmNWUtNDI4NmJjYjhjZjcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMWE5MWU1\nNy1hMzE3LTRmZjctODc3Yi1jNTJkNmE5ZDljMzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATiuzZh5SH151TsO3Dv6L6uU6wNIL+RM6B/973fGnPq/APeDtMLX45c\nFl+TcqUdgyOLePF4R199gRMhDXI3rkxho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFabkJ\nwbvXhIwrCAMSitOv9xGcVDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCV8KEBSILjQf37KkrvpfhxPcloAMTtQjYq/A3yNdQjiAIhAJax2aL+njpX\nL1cVOk3CetSAz93Zz7NH0wXjII1HUfzN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5943", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5943` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARWTLDeo9l5P4mrMpXb+es+AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwYWU2MzdlLWMxMzgtNGQ0MC1hMjA2LTlkMDc2NjM3ZDI0NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJkZWM1OTktYjBl\nYS00NWU3LWEyMmEtMTVmMTY0ZTU0NmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHPcHVr3XA+MIpkvTM9Kj0X+VD2Wib7v7/csnmhv+Zol+ITtLo/VslzaQt/Ga\nYp/qHhAHZjuxjQKn9GgXu37CX6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdCkUGo0IC1mCxSlIf/YKochuWxMwHwYDVR0j\nBBgwFoAU2N/Yqi5YiQQhUwhPTkXIJ8x4w/EwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDrxEdihJ2db/tRWnjeLClXifE2jnyeDfNw6Cuu3BthtwIge3t9f7efRl5u\n12YZXgjgXdda2+lwuqd6bFprNs4/zOs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXlN2W2Yo85QL2HhOHw3bXweMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGFlNjM3ZS1jMTM4LTRkNDAtYTIwNi05ZDA3NjYzN2QyNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQrl7T7utgWraNYoPUnwiVYyCb2b9oAZ/iQhCg14io4PjU\nX6m+xUTZd2UWCQNRjTWOeCGTt246z20y5sfAAqbGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2N/Yqi5YiQQhUwhPTkXIJ8x4\nw/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJGYJB3FwecPw/ZliZ2chnA9pD0sse+kPTSbWqykOQlmAiBgXNKjos2x\nEE599PQQ+0ysFNXzVtm78eMH8aoCNYt8GQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAfiYvhl2PO2/OGFs5LOqZyabMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJkZWM1OTktYjBlYS00NWU3LWEyMmEtMTVmMTY0ZTU0NmM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YjZmMDBh\nMC0wYjRhLTRiMjAtYTIzYi00MWM3MzNjZTM3ODYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATzDyvMlESi1SwZF3Le6AT/WPfMzpyECNSXaRs9z7nfrjMbmf9nIjzD\nVouT4q8oejfUcA414t3y+HJU2174FTdko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0KRQa\njQgLWYLFKUh/9gqhyG5bEzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIGHGDeT0ct7SnwOfvWrq8K+bYyf9hOOT5fA5MWob632RAiEAzsZGxPhX1fh1\nH1FoMI9MR3LFgregttLtKRpaH2Lj+4Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5944", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5944` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAYUXc5ZtfeDqk3+BzUSsLeugMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5YzEzZjk5LWY0YTItNDExMS1hMzE1LTkwNmNlZmRjOGUxNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGExOGFhMTQtMThk\nYi00MjA0LWI3MTEtMzgwNTBiZDEyYmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXWxKkoquk9/YlWG1Fv6oFhSEHTuGa6gHg1RXGFkHheNQSmJ7BblT55FZjS+I\n4BQFju/9YrVf+XbcxARXzx+t56OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzZddyslIkMbNd/YBUC9L43D27WswHwYDVR0j\nBBgwFoAUqTLm8uDS0TJJKZiZnondjk+GMswwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCZ\n4cf7znjvuPgvV5HwpQMlTjZCJvGEinKIZjuoRvM/OgIhAO9VIQFUhe36KLeamFy7\n5dfwFQUtWEqDt04+OqDjyrBO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcv/LpMtv/jHEdouMaMEksWTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWMxM2Y5OS1mNGEyLTQxMTEtYTMxNS05MDZjZWZkYzhlMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPrgvDaFAKIQ3aKfZ0ZcpkX74bIFaHAagzrrF6LwoAI2ch\nFS9PV5nj6ZhBYJ3KspnSZkzLn8u/Sp7qSeSP+stQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqTLm8uDS0TJJKZiZnondjk+G\nMswwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJQUqiAoI87eE9I8knECDejSBr9KseJwGoay3Gdy8Rr2AiEAiafNqYKB\nF/Im9sPqA7A8cW2L5U3YlhjJGj2ITVlknao=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAXjRuKNgt+BmkhpligD9/Eo9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGExOGFhMTQtMThkYi00MjA0LWI3MTEtMzgwNTBiZDEyYmFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMmI1NDQ5\nNi1kNjFlLTQ2OTAtOWM5OC0wNzk4NTYxNmFhNzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQnVZGUT0MoE/5OWexAlU3TfZhK8wcGxtW3dscca5z7UBHiSOHSDIYf\n49NRK62YnNq9LxauDEDWUF/HWjoXDhB7o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTNl13K\nyUiQxs139gFQL0vjcPbtazAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIF4Lbph8E6INNzXJ12PFKMRjF6SFCeE6+49EnWtr6digAiBFKN+BBdb7l5p1\nIDcrtN8MzaS7wxSQVZBJK7Fp7fO4pQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5945", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5945` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUEOifGoPSpooWLPN/pPDzdZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiZmExNzM1LTI4MTMtNDMzMi1iMjAyLTM5MDRiMDdhOTIyNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIyZjdkNDYtM2Yx\nNC00ZmVjLTkxMTktOGFjMDZmOTQ1MzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYcDNZQvxqSvKAImXXNe+8eUrpK6y9YTIffXxfrgrbZNafqOGqBH3VA7mGne5\n/zuonHjLeaHaGeDN/d/IGw6IE6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOM9p6Kb2XfGRZYVPeG46jAd69LkwHwYDVR0j\nBBgwFoAUbOg210V/DUJCW0LlYF4FuH2XHfYwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC/j+HeD0zeRQoS5XZ9gGh1/vyDybpyeq/jCKWpcDy1CwIhALBS\nSVogCgL4Fsuh63IF4AlwYp0KbNb0WGgbnM3+zJHv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQTFTRBWXBA0W6D0+cOg0q6aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmZhMTczNS0yODEzLTQzMzItYjIwMi0zOTA0YjA3YTkyMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATysJny8BOGchLudTh31a/+XeEv+rQeH7RJrqtLBDSQ9FmO\nFt27X7fbEBcRQ0DNeZ2hwUM/grjyqh1Dzl9fzPXao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbOg210V/DUJCW0LlYF4FuH2X\nHfYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWhWrTaulNBH3FPoCTonImEVQ8wslzhzCm+zQM/DcR6oCIQDPwH9R3CvA\njFvzjFLx/tFDqNdQyz1ySYKAfR79HdCfOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAWCn5PPl3dMBnH4FRtOXsrFkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIyZjdkNDYtM2YxNC00ZmVjLTkxMTktOGFjMDZmOTQ1MzBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YjE3NTdh\nNS1jMTg1LTQzMzMtYWZmNC0zMmUxNDMxYjE1YjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARAJS8lu4hw2nJ83SVIwEmixtDON7berblJl3NUq9XnPIMGJ7dWueO9\nIvMgEggPF7TM/SvJSAJLBQqSBxnSoJwMo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4z2no\npvZd8ZFlhU94bjqMB3r0uTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQD34sXvdJ0o0/r89DUVhOB2IlXXGp3MtDuzNZkMg3hWegIgBrcEhik0Cq3t\nJmF71gSUF/T31Or+fBv+QFo3sodYn/o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5946", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5946` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATpiWzxZN453WkaBPSBpMhPYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MjFlYWE3LTYxZGQtNDZlZi05OWI2LWNlNTk0ODJjOTBmNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM1ZmZkZGQtOTVk\nMi00ZDc3LWEzZWEtOTM2NGFlYTkzMjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZDW+/SI0al6pru21fzS+L+/6QSMN4UmVW/hXnAgrUz1iDLrqAGwpOA3sw+vy\n1PkPnJ9P/D0FmcvLDku6PsGjn6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU2V3RKh4V+GfQBDoyvRhmRxnshkwHwYDVR0j\nBBgwFoAURJ1fbJv4dYid2GYi5V+KUW7oBD8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIC5ugfuUCCCNjm5JwyVyywj0uFLiDJ9X1/fwAedpP9SiAiEA3ZWc\nKu1IR75SyDfG7qwZ4NuB5K6QJjGolpQPLEksUP4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeOt3j691f0OBPWyIlsN+34TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTIxZWFhNy02MWRkLTQ2ZWYtOTliNi1jZTU5NDgyYzkwZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqowI+NRTiC9WQNWd0dvMj+75QTquEMwlex/3eK0hW3FC9\nfw4BnAHoesOtEuo0RaAkAyi1/Vf9FESEHnfu3bayo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURJ1fbJv4dYid2GYi5V+KUW7o\nBD8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNqDZTmtejS+MZ/K7vb2Xo6SHJ/pA+h3914PCky2LQB8CIDhgVXZRC/Jq\nwmiPrztnFnlKWpmRrwbS8kAax6U7iqLl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISATK0vqVkAboq/5uNinBmT8YxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM1ZmZkZGQtOTVkMi00ZDc3LWEzZWEtOTM2NGFlYTkzMjJmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYWY4ZTMz\nMi1mMzAzLTQ2MzItYWY4ZC1kMzg0MTY3NTA5MDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQuNVUYY9Lmmx7/JFfD2o+5JKcxcbXLLxupQ3muRoXE/9CKrfdjukD8\nGXGNu7uKd5rdSyGWfv7p604aLp4VX7Qpo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTZXdE\nqHhX4Z9AEOjK9GGZHGeyGTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCICpfGV8PVJm1n3H/LHL5fVhDHA9c1nVG1g9x7b2tsJplAiEA2C4DI09T7Fia\ny8GcGuJaUxG15lM9kc/Lw5nypcE99BE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5947", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5947` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQ8/cdqldhE05UAR7G+g3juBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxMzFmNjhmLTVlN2ItNDFmNC04MDY4LTkyMmYyZTliNTlkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRjYjU5MWEtNjg5\nOS00Mzc3LTlmMzQtZjI5ZGM3Njc4ZDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETv7Wct0HXGU5VJAq/OVInlpaxQzibnbpZDHMFYXezaN3rmqzv/Fnfa4048Z7\nbu/ahVI/EXktd2h7WyzDADCmMaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSnCf4cdq84Y3z1PEXrwoKBXmdZ/TAfBgNVHSME\nGDAWgBQtqdx+3jLPkxIJ+QzuXYInps1PJTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDXERS2xr2040572M0y0SvuLAgWLpux\nmyvzhd0s+BQfzQIgCPB/x6oKAecndbDf120aQ75JxlEmkN4pRrsMUSV8n0g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAajbNTOc+bB6nC2L5cLgnrJGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTMxZjY4Zi01ZTdiLTQxZjQtODA2OC05MjJmMmU5YjU5ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASod30pobKVrgXZpTFYwyzONq1zD5iJfJLJR1oFOUReGUjX\nkp2ULS9J59goHY3POtQMJ6CcOfX1JLhvmcHdo9QUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULancft4yz5MSCfkM7l2CJ6bN\nTyUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALnGznbZgZ+RrurPn0FVmdZLlJyRvhtQfIXmI1fCVAKqAiEAhPBo/cNW\nGLzBRXqXvz/HiMJnIGsgnEgbEoQ8wSS26Jc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAe5jEabYbSRndtbqE0S9SIrWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRjYjU5MWEtNjg5OS00Mzc3LTlmMzQtZjI5ZGM3Njc4ZDYxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZGQyNTRl\nMS04MTE4LTRmNTEtOTYxOS1hMDYwMTJlNTBhMzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+ZD/Qnz1H/gXvp1RK+HJEMJPxkQRp80TrtBz/pBzyyBOOfylv0MxU\n2huEc2aftpS6Kvl7UuT0eOLI6WJRB3cEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnCf4c\ndq84Y3z1PEXrwoKBXmdZ/TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCICaUlmrbhQqwn7fucq2GRj4i7NJGzCsvdrsH0+LNJiD5AiEAhJqNo5WbeLig\niSiwhdGzsbrPyXMXodGYwuJDMlKvBcc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5948", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5948` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAUvx97GqjeXYZwFs+Z7CjHJyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyZGU4NGVmLWYzNWItNGM3Yi04Y2NmLTAxZTliNDE3MDNhMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGYyNzhmNmQtOTY2\nNy00M2NkLTk2MWItMTRkNjU2Mjg2OWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWvjkubLD+UAEfGEgg6mtxpH8VBUoBPvvGKA0UOjkj7S3Lymqsm/3D8KKz8Yv\nQAhBwprngivGFdoulL7pyWfrpqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxsDTELm+qVimoyEytRdg+bTo5OAwHwYDVR0j\nBBgwFoAUUkFvsrigiGC0d0mtm4u85G/gTk8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC5k+4kWNpO\n+aHQJ3+879i4T0a9P7OD+1PmeFOeZGralwIhAMjfCZbdwf22jtaWXgpjjHzFmDCo\nkjWbfKzP56oJMnP2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb9bUTl+SvUB68ENHTXn1mDVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmRlODRlZi1mMzViLTRjN2ItOGNjZi0wMWU5YjQxNzAzYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwQijj3UepDznNJp81ms2/nP7vWDGyaJ/0imKK/M2mMNcJ\nQD24FofwHaE0Ea6r3lCzQ6fXBmjFg+AcgeiygesSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUkFvsrigiGC0d0mtm4u85G/g\nTk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIJ0yI16h90nJ79H3Ce0NBB5ch0ZQHQR68Y74NxgxaKbAiBZSE+I/BnA\nq1B0EGFFKuLTre5Kx3taegOVhyj+lJiA/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAa+NFTvKTmsF4jbo9rY22H2FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGYyNzhmNmQtOTY2Ny00M2NkLTk2MWItMTRkNjU2Mjg2OWQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMzFhNWUx\nYS1iZWU4LTQ5ZDctYmU3MS05MjcyNDM4YTAyMzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS+jq5HNj/IT1praoPGh+uvQIGgEhPTTrMG6MXxGvsy+/shLLRW0nTH\nYU/knBiL+zdEpEfeJ1nRvRfMrL+fbMifo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTGwNMQ\nub6pWKajITK1F2D5tOjk4DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIDibV1b69x5cV+EE03DH3kRAmnZFQpTGbx5wyaPRIKsEAiA0qfE8GZIeALbx\nxsMfp8auxeqpgLne4Lj4qcoV8Lwp+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5949", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5949` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWB8o/2q7OF0nGJYjsDj0GKcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3NzI5NDNiLWE4MjctNDQ5MC1iY2Q1LTBjZmU0NTc2YmMwYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMyN2Q5MzItZTQw\nNC00NDNmLTg4YWEtOTNiZjRjNjU5YmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWyavSSTCrcxrm00/hilUevkKsk9mcKihxNGBJDGjmbv2oRWd4iKAi0+eNhhM\nSEl5QivyJPhEvSlXjhc7mg5jJKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNeP+ZoNc8/Bs8T9siHxal23O6k0wHwYDVR0j\nBBgwFoAUFbMvZTJw494ourMqTGJIEP7loQ8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGxItptMKp4W\ndXcr97+0hCS2AYqjHexkLRhkmTJ5uFF2AiANC0oF3qVz7EV5mvBXoDH60aKFUWrM\nUYIzVMTFRlOUsw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASY2EPMArP31dwd9sQJPDyo8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzcyOTQzYi1hODI3LTQ0OTAtYmNkNS0wY2ZlNDU3NmJjMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqmDxE13cI4gdd+X6A3/mmPRa40IojEwiSu1YvwfV6slCI\n8z93Tq6HkVk6A/8jqv2cmYDS5W66Y30/5n7KJz/Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFbMvZTJw494ourMqTGJIEP7l\noQ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM5dI5DiHPJOuVmdL9LeD7f0xRWsE77kLL7urSSn5fsKAiEA9Ulrg9Uv\nU7p6NG1rjaL/i1CwuqwVfaIFimjDdUtENBY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAf/yXZrkuAT+CWFlqaSCSQyeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMyN2Q5MzItZTQwNC00NDNmLTg4YWEtOTNiZjRjNjU5YmUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MTBhOGZk\nYi02ODUyLTRhMzMtODE1OC1iNTgwMjNmMzQ4ZDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASbqc+YFGnZqYyybb/Se3CX4LBCc198Jw6N4IoUs5C6/fx82fqTXut3\nlELz3T3kcaO0wZGkdhq7r0f82FKI81J3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ14/5m\ng1zz8GzxP2yIfFqXbc7qTTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIBRbpCNx9Tk8xGd0xtGlVFfjnIGkpdH+LhALdTW/95DLAiEAr7M+c8dWQSoU\n29TLJSM1XwKq9j99GR/YACRQLjrw+uc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5950", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5950` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAY+WHC7hbuJlAgQSwUvh1STgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2Njk5ODlhLTBhNTgtNGQxYy1iMzRmLWJiMDg3OWViODVmNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFmODI2ZGUtYTlh\nNi00MjYyLWJiNDMtNWRjMDFlN2ExODNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1stpIA/YCI/ZHtS4ImEeK3Na6MDMs3xnQ0htBWkip6CWLZdBUFnznso9TMQf\n3cnVDD/4mixo8BgQUbV+i4478KOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz5UgGSKid8Us88cvhfrly2WWtiMwHwYDVR0j\nBBgwFoAUFqRosVYDzBeMr8k2B7K8aFMc2sEwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAzgpvo+ko\nPlzv+poB+iT6Ngf5bqbdFqpUJALUl990yvICICMtxAiuDYRf5eru1ZCAMwWTzWcW\nl+FejchtiEg3Tiyx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYoLn0u3X2HqiRjieF24jkytMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjY5OTg5YS0wYTU4LTRkMWMtYjM0Zi1iYjA4NzllYjg1ZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9r1ExhtDDOa/sEOkf8d0w3u5pV4XyfY5WTygCyB7fdAgU\nDXS7y/6YixMrdh1B3atpFG0l3MUnJ5r/wa6SlqDao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFqRosVYDzBeMr8k2B7K8aFMc\n2sEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOJsQ05bisFe7W1hg9XIqb57Q46/oxbyJeh1+zS217nCAiEAxNeTvWbX\nLTZhJKxN8F9uSjK8jtCUWcy6bZrLDMO/DJQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAfILy7biVVhSlFspTJ/iWEykMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFmODI2ZGUtYTlhNi00MjYyLWJiNDMtNWRjMDFlN2ExODNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YjhmNmEx\nNS00NDFmLTRjZmUtOGQxMC03YjZiYTYyMWZmOWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS2HXcv8LwhilvRquI1+KpZ30fc0lYeFhOWWpaIJZ0rwz0c9zXNaX+F\nvv6sXN9svyAuxPPNe2o72lYpRGHI9inho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTPlSAZ\nIqJ3xSzzxy+F+uXLZZa2IzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIFU33/VSsAxw1VdmE9uac1FjeAr4S2fz2ChplKNxSUhjAiBaEElclEn/vq3n\nwwtyPUZqc+qAexzElG+A3ndIYt1VhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5951", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5951` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAbr3kw74fQafodpVXcxLBt4FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0YzcxYjA4LTFkMjEtNDkwNy05ODZhLWZiYmRmYmIzOTFhNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWI5YTc0ZDQtZWE1\nNC00Mjc5LTkwNzktMTAxYmJmYTFlOTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKVQ2adz/y2VxHIN6h/34ziWQ2fHy4p3du2aMeNJYiD0qbSsGN3BRiVd9CosP\n1mEpgSuic3sWbY+Nw+3pTO2V/6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhosjPoidwP/+NMuzbntRGV48rwowHwYDVR0j\nBBgwFoAU1XT3hY9KPklmscdDYBpYois+Zp8wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiAnacw2bU4/JVVg8TrJJDkbFLbwVxxJ5UkK5JB+1lYCWQIgDBndS3S05c0a\nC/58u7XA0oFs0j4gRYN0/pWtHx/SNXw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATRyrEU8xKYA3nENzEpgVVYUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGM3MWIwOC0xZDIxLTQ5MDctOTg2YS1mYmJkZmJiMzkxYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASy7tqnar54Kydo2RQ/iYKS0MRRxSPg8iPAZ6hYOKjLY0he\ny9HnzR/CHLRNf2rAxGQdiDdWwLvu4749Vxk0tpdco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1XT3hY9KPklmscdDYBpYois+\nZp8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMfql8dLcLAYUof5QYOiLJM0ntvpCGhpiau81VsW0LyyAiBVq4LYUhu6\nhaoKDUYnjLvZENh1OUIdfEKAXCX9nW2jHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAfODSUOkKvXSy7HOz72gq2VKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWI5YTc0ZDQtZWE1NC00Mjc5LTkwNzktMTAxYmJmYTFlOTg2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZGIyZTIy\nZi1jYzdkLTRkZGMtYTU2OS02MTk1MTE5NjVlMGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASvFQrp4RFD80I4atDDnmpQ3kMKnErGVAfnIqm7u35+HTwXLkAcAACc\nbgGgkUwBLf9zUsLQsHwWuHgb7YfOV59to2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSGiyM+\niJ3A//40y7Nue1EZXjyvCjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIDRtoqGVaryMRcwXohvzQhbjh3weQNAlmRUPk055KEEFAiBn1XVeP7jxR+PE\nJd9peBae5CQlqbmebwE+ExT4uZ6hWg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5952", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5952` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASizxf3RWHl/sphbXLPIoai8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5OGViNTY2LTRlY2UtNDQ3MS04ODE0LTRmMWNjYWM3YTUxNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIyNGFiZDctYmVj\nYi00ODQxLWFkNzQtYTE4NjY5YWU2ZmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERp3ysoEDN97DZltkEupUGg/LO1iMtQyDtBj73PZJPWtXJrH0DRNJhwjd8Atx\nabIdBs012Kcrjl15QqxnQZsT86OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlBPyUT9scRmg46aRVi5EVVOB6FYwHwYDVR0j\nBBgwFoAUsZBq2uhl5mlwD25JD7AqWjzk7dAwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBUDMRMkTXK6TtHnMEa8duDRFxBE5ySirEmNafFryAI5wIhANBS3lzzrAyx\ntbDLxuxjX3ZciuW9r5NRE4SclvQAG6v/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbMuCDeNQdNvFEvpLdTDIVu3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOThlYjU2Ni00ZWNlLTQ0NzEtODgxNC00ZjFjY2FjN2E1MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq3HNAKOcw8aEbIdcqg31EG4jh3uUUhRl1FeRrKgd1pZ2r\nMjDCqRJiAKcKD+Ep+ftolb/osmP7v97CrbOr+OPQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsZBq2uhl5mlwD25JD7AqWjzk\n7dAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ0yhp+XFecj9mzKaXdmiotSfKdezt8oLUgoXAmo4fq0AiEAuo/6TTk/\nH8vM8rocWohMcWkx9uKALcuUnicsXO7os0A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAb/6tf7h5BoDGpKWEEGXd5jkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIyNGFiZDctYmVjYi00ODQxLWFkNzQtYTE4NjY5YWU2ZmIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZDU5NjNj\nNS02NjA4LTQ4YzUtOGYyZC0xNDEzMTA5YjQzNDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARaF5RlRbX1/k8qhlq7+/HAucqeEZo2cyJcUwUSTuGK/mbmWh2gyOm6\nf6akMeYSo3ZoJyQHUNj3Lp6/L8h+Rok1o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSUE/JR\nP2xxGaDjppFWLkRVU4HoVjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCLe0K4YO1lZkb2nCVckkQnQnQtEBDPjlJJNqKdKs7ougIhAM7uxraeqFlx\nDQ6t3R5d7FbZlJwFCnsqLRKL05do6rhD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5953", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5953` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAQxPUe0jfjnVbVbaOKxm1ml6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNmVkNDAxLWY0MTktNDU4NS04NTk2LTYxYzEzMTkxOTQxMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQzMWRkNWUtMjRl\nZi00YTE4LWJkMmQtYzJkZmY1ZmM5MTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBUE5F8PDBcZ3V5DuZBb8iIjUq/gnWXHQ5TWUwnZhkcIcOrOyUa+NpDrbD6lF\nWxJ4X5fIl6niIfEpvxzgYnZYtaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkZCjMJHd3e68sCWqHKkT93VubKMwHwYDVR0j\nBBgwFoAUVc19QN+n94Ha5zvPkLfy+cL4hogwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAJ\n/XCogpmq1CBYRfwXNRn1fv7AzIuQ4WdBAboxnAXKGgIhAMoQb+KDcILmFdcG4Dyc\nLL4oVZf7KR4r19/LxQ9KUOoe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT820/7pjypGp7eXIodRTc4hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTZlZDQwMS1mNDE5LTQ1ODUtODU5Ni02MWMxMzE5MTk0MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYlHz7ov5LSqG7dRektG1JSR1cLME1bjiFDGQsbCU3+CyW\nm5hRSFWyhNCyfOrKyeSwd+5xuKuBtvG/sulbl+gzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVc19QN+n94Ha5zvPkLfy+cL4\nhogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXJRUi2aqtxeb6n+g7Hul/ngxTyKxJ1gxqJIbGbC0HWQCIQDJ4+OKDlke\n3s1XJtJgJnJizX3idkS49HDRpSADb7tqkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAQ1x8WNhjzzz+NDJEnlJTBd9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQzMWRkNWUtMjRlZi00YTE4LWJkMmQtYzJkZmY1ZmM5MTNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NmVhYjdh\nMS00MmNjLTQwNTQtOWU0ZS1iZWIxOWNlYzhjNzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQrULEjdMPP9K88pscCvJDsbIVRzCCtLf24TDCNLsuq10zwPuh3pVgP\n+iRpAZunIhc/dWvjS/1CsNA5wUw5r9Ako2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSRkKMw\nkd3d7rywJaocqRP3dW5sozAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQC+49kTmFj4DleNeLm29JExMF9OLfsaMLE7d3dnKgZGPAIgIdUHT2myjOvn\nsIKysEll48riAhfHBkNjQ2yXChlhIu8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5954", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5954` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASkZq+lJZudDOxiGKYy3XjI4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyY2VkNjU2LWIxZTgtNDViYS1hNmExLTdmNzcwZjUwN2U2OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQyMmJiY2UtZmYw\nMi00MGQxLTg0YWUtMTQyMjUwMzU0YzJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXRDJ7cY1i0qG7Ti+P/Y1hBNLRjsz4Tqkj/bnz25SEbaj1fMyrdhDZ09SGoBY\nbb2oIQnPZU840bu3k2coRG6r0qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnkSbnszvN8XET0nQFcZIRQv4vf8wHwYDVR0j\nBBgwFoAU64JnJ9t8pXfjEBrj3AVbdP++zJkwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiAV0EDoHjwDYhZhIOmdZT4j85akF1D68/gbabmot6t/0AIhAMPQ\nHtaHmt1Pv/15eLvqR5YEEa9h2UKTo9WMCYxhKuuF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWjSJ3VG3iGXkBI7ymAViTk4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmNlZDY1Ni1iMWU4LTQ1YmEtYTZhMS03Zjc3MGY1MDdlNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7IqafvBJEXPnhhhMfKjtNlcNvnwR10KjQBDGYBML2CJvm\nLEbGioDk4g8slrOB/MDeEc5aM0s4mT9fHomsXIuWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU64JnJ9t8pXfjEBrj3AVbdP++\nzJkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJmT7AEJrN6PG8IRT+vqK+3vm3D2kLY0hOnrq93K/ihGAiAfCTvEvefF\nGHthDDecyZ0N6tNle3ydXpllzlIWMI12Bw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAYsrtWBxnBuDKBFMfujWH7VGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQyMmJiY2UtZmYwMi00MGQxLTg0YWUtMTQyMjUwMzU0YzJhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NjhkYzJl\nZS05MjFjLTRjN2MtOGI0Yy02NDI2YWY4ZGJjMDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASNpfTiyYhXIhrPElcamVReF741NYlaYZcV6b/AOLRD0+b8YfGCmyRW\nrwdHLhMYIiIzmdBAx7LmyyswL7S19Gjco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSeRJue\nzO83xcRPSdAVxkhFC/i9/zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIDMir3ccZz+LrFyZSiVLSQkfKmpcaAUDGPAKVCB91lkmAiBfMUlFO/TmLCMD\njB4ZYCOnYD6cthfKYY1g7uLuDnEdrg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5955", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5955` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAfGBeIat5wLB2b6oQuAyFt6xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZWQ4NjZjLTZhMzAtNDI5MC1iNmM2LWExODVmMDlkYjBiMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE1YjczMzUtNWUx\nNS00NDI5LWE1NDgtYTNjY2U5MDlmMmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElCOa5sRsFfh5qc1bHzNAm8HGCX0zId6+AW2Wkb8I/BGn9815lea/g0Tazxlr\ncYfMf0jxhsN5OfeYuwmxfk45/aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+jTnM5DobYFvgx7JU6QVRjODTpUwHwYDVR0j\nBBgwFoAUj//sy8O5OW8ATzIs9wDiVkteUCswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiB4sfYLCGkdIeWMAnRd74SPUGOokhAExWWEw0FdF2V0UAIhAL2g\nmjlDH8N/jtHKj1Y4Eu8b+b6MUXJCX790Sl9Y96j/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU/MD2hfPGbQAAoPLQnLy+/6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2VkODY2Yy02YTMwLTQyOTAtYjZjNi1hMTg1ZjA5ZGIwYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATi7s2po+x3BSf7D/ioaRgOaVCiCqYv2o76/w4QO9IBdPpw\ns8CWPUu5u4ogbYY75aBG7UqAMXB2YupyrB7XJE5Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj//sy8O5OW8ATzIs9wDiVkte\nUCswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIv55dTJWtJuDkHEqL+Ivz5Iv0SY7x4TTgvumJKRKPZsCIFwRYQ3+kjKW\nnudLX0KqALsFzPMYxIpjN3NGeccxji/5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZ649xN/jLexrsfQ+j0wU07LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE1YjczMzUtNWUxNS00NDI5LWE1NDgtYTNjY2U5MDlmMmQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMmY3OWRm\nMy1hYzIyLTQ4NjEtYWJjZC1hN2MyZDQyNWUwNmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARFXBsxmDF2kvfFJy9LPuFSys3o/rBofr9FXfrOeS9kcxWVtV5YRA0c\nhOkJmUPCEX+z4SNVCZrlHH5GlEs830y+o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT6NOcz\nkOhtgW+DHslTpBVGM4NOlTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCICqODe+KiPaww77HL6RNW2bLGbdDFrQNBin5BjZi/mgOAiEAp2fbB2aeAlVq\nSF9/O3pstptuOuvT528bAGoD+KWPoyY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5956", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5956` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAdGidNfyRul0mE6o/JdD3x79MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmOWRhYzI3LTgyZTItNGUxOS1iZmJhLTdmMWQ2MGQ0OTdmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjcxY2JiN2YtN2Iz\nMS00NDY5LWEyYzgtNDcxNTdmNzNiYzQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl2Q8112xWCu2Dwq7G6FU5fLB5LImenOF0T5h0zHZpNXMbxzFzEpVWF8irIfy\nOk4rdbjlmGo063T5uFWCmjW/EKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVk+g2W6af6uosyQn5qLNlBCJxdswHwYDVR0j\nBBgwFoAUu3mI0qFerknOtSvO3f4LrUiIZrIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAzQekG/0n1AMD\nNBPRD5QGHUhl3e+oV5nyK94E49FsXcYCIQDuxdbtSWSb4J73QMRcjkI3YrylCx5d\n2uUyaJGdBhjtuw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbTfVaSsg4etJcArv7X+gwL0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjlkYWMyNy04MmUyLTRlMTktYmZiYS03ZjFkNjBkNDk3ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATshq5i/+B2J3b5/RRlhhFL4TxKa29LCm7wU8s+ioDCtX2W\n0CyRdio8r8j/+cZnYEOPiCLITcHhFe2cfIGVL+B9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu3mI0qFerknOtSvO3f4LrUiI\nZrIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM9l1nAABRwdieTjor456j+orrRZaff33KPCEhURPXS4AiAnuw+dU0xo\nO0hhiDsKD2WmRsgQY8+hTuLEAwqCl3FxWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAfW4zKVKnWFxSVVxQasWJVjzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjcxY2JiN2YtN2IzMS00NDY5LWEyYzgtNDcxNTdmNzNiYzQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZmJlZmVl\nOS1kYThmLTRlOTktYWEwMC01NDNiYzk4MzI5MjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARCza/slfO16cfOZzlTvlqpnzinHoHHL5mczwK7bELDF54DYhUWLtLR\noCzjW+nFElwPpPe4+a/0O0adWKnWoaxGo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWT6DZ\nbpp/q6izJCfmos2UEInF2zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQCFtyE1T3AIQiBsGzOn87bM3roaRA0+mX2gSrG+mHI2NwIgLiITfR0ZD8dS\n6V24734/x1CiADrWcsH3yfd+Zrk01nM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5957", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5957` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeATvjWkHvXv00KOqc+zfrm1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMGI5YjgyLWU3YTAtNGZkMy1iNWY3LTBiYjEwZmIxMjQ0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTliZTJiN2EtOWNk\nZi00YjVhLWEyYWItZDExYzUwODkyNGY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+yzhD4BCmp9ojVDkWTR7Q+5sNsRFsvEcPPyrzHhayT/HVfzGKoQF+huAp36A\nkgVANFElE1P7tCcIARzG1JtacqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE19y+uYGrADX0UJ6sTAmsJM2EbswHwYDVR0j\nBBgwFoAU7KXFFmJE2fRQGfHMeLo1d4ZXKMcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGq85ONiOjt82YYvoAlbo9xoVQ3am6UifLBnnsjacJSHAiBUblbvvbxjaPYO\n+wZlUXWwrFYPzMs4EBd3fib3Tbai9A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYAK3VXXQFJp+dX/GhJkipUxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjBiOWI4Mi1lN2EwLTRmZDMtYjVmNy0wYmIxMGZiMTI0NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUPmKg57LumBNcVNYD3BUgLvA184dIi800RT+8qJSuS8LK\n3WL5x7JzxjpoetVhzBYeFe0KDuS0GTOZznD31T39o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7KXFFmJE2fRQGfHMeLo1d4ZX\nKMcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJPrzRDgOnlILkUaZbGpuImZIGsUJnlfXzkDyIjZ8exGAiAQlVKLRqbM\n0zwNSe0+0ZtH0TbVBzclE/Intuk8/wV/0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISARbVNoBsTWuvMHqi16Hf0/q3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTliZTJiN2EtOWNkZi00YjVhLWEyYWItZDExYzUwODkyNGY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNTcxYzY5\nMC0wMDE4LTQ4MDEtYWZmNS04YzFhYjFlOTg0YmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQegIKTiKll0BmwlRS5uB0auA/fAYTeD9gbDCnt0X4h1CxQHnuPZPtn\ncDHblCgQeGQze0fJCQfKffmhz8XjAFmTo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQTX3L6\n5gasANfRQnqxMCawkzYRuzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDCAWO50fQK/nxlK8bpMvQIYu7AJkBgn5/c9pqbbQk4rwIgEFheo6oWwsBT\nPK8udkqd/q26svYowXd2Zg5Q8FWeYXE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5958", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5958` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAaTyoiLB5aNcMHF/VHs0B1t9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NDc1ZGFlLWIwZjktNDdkNy04YjUwLWI1ZDUyZWU4M2IxNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhiNGUyZGMtOTdj\nYy00ODJlLWI2ZGUtMzcwY2UzMzM0NWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl7FOxdiXQzI6IWIqofnVKCxwJlx4RtdrW+II07wZAfacB5M7Sxc67yjbl6hr\nVNK4UzE3ccFibdKzLUKcwOa/1aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9dyIVieXYkg4lgRS5awYQjQNHzIwHwYDVR0j\nBBgwFoAUK5fPH7Z5qySD2VtRSdCiVTFpMnQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEQtBDmEoPmoIjxYZdOtHB7P3gIJvmULkitdVfZ4Ru1oAiAasVQ38SEXSGhL\nJiYruIqwdqCSiK9+qV6MAhBWAWdcPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaw+j1tC8BZoXWYwspupQUIrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjQ3NWRhZS1iMGY5LTQ3ZDctOGI1MC1iNWQ1MmVlODNiMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+cqASujXZ22Vv8yGWqnfYNO1ud7W1qFrkTF4z7fZ18MR7\nF9VkP0pW1IHn5gIn8eOr2qH7zi6fIES3OpSsLF1qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK5fPH7Z5qySD2VtRSdCiVTFp\nMnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOhFSyURtW6L9wFMZjoMtWApLb3R3lT1fg1UmC0UKQkCAiEApHFX2HHm\nzg4+QagGGKboYb9jqITu1CNznCyzycttpYk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAXpsgt7jFUTrfJOt/x+Xq83qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhiNGUyZGMtOTdjYy00ODJlLWI2ZGUtMzcwY2UzMzM0NWQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZWY3Zjk3\nOC0zNTFmLTRjNmQtOTJmMC1hNDdhOTAyZTI3YzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS4Fv4pxSXiwnsdJBPcZeQU8qIPbA8scXchc8EG/F7RIllDoGRAdyvD\nBjSC+tGiqRZAEUq82wUpd5ry2rm+vAQso2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT13IhW\nJ5diSDiWBFLlrBhCNA0fMjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCMnXhqn56aefQpk7xgOoyKNgEpSsnuFqN/Pra3l4AuzAIhAKEw1eDMUxXe\nmev/chr8Mhdr6WK7YVLEJJSk8dtj/JQ7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5959", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5959` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdNoz5zQeUhq6htY3MDYNgDdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1M2E0ZDUwLWRjZjctNDQ2NC1hZDE3LWUzZWZmNTc0ZWQxODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGY0YzU4ZjktNDJl\nNC00YjIwLWFhOGEtMjVhZTk4YWFkOTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf1QvUUustpp4+v079WZWBe1RPn2jmnigb0cLkFyfCdaR8og2Z/DZNA+InHBL\nmVuek2dkFX/yQU3VpuFLCfh8n6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7PAHwPcE14gUi72RLxKfw8tAHDEwHwYDVR0j\nBBgwFoAUP4aVWRUuQT3O9duTnEKKvvEVdZQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA6L7m/95u6G5F1rEhYHS5FUIN/+owTcWIt9ryIiBepFgCIEKrQX3lHM5Z\nTkAbin/vr89Va8i8u+u5tLxLoZyfWKac\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARbPJUul/Rz5ppSLhE5HR4a2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTNhNGQ1MC1kY2Y3LTQ0NjQtYWQxNy1lM2VmZjU3NGVkMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5QLjxBCAdxOmgeSCrE9bvZL9r9+Xpt3ln7by0Gzi6Oqqi\nxlS/jZPcPbPJiH3njs/2++EICfK1hXW4wuf5c3mko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP4aVWRUuQT3O9duTnEKKvvEV\ndZQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQXYmOs+ZnEt1mvYPyRQrK6UCyGd1snX+BYpwSPVT0j8CIGPbDTxRDzPE\nqQQ8T6sM9j/FwHULrmVwQX6OS5dTsX+L\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAQyvPt1JV3LdUjUMyV3eUTpLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGY0YzU4ZjktNDJlNC00YjIwLWFhOGEtMjVhZTk4YWFkOTkwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMTJmOTRm\nZC04NjBlLTQ5MTktOTNhOS1iZmY4MTIwYjE4NDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATAbqhyFWPm+tginSdnfbYapoLXt0CbWyi8kXs5Nq9Sr0JJTuxLLv3P\nlU1yXDb5v5yVWuSVrW5VkhkNrAu2pTNco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTs8AfA\n9wTXiBSLvZEvEp/Dy0AcMTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQC4hwDppbryhM1kLeLANfz/mkTe/KujqZoh0jiQ9U1zBAIhAOf2JdUAXCyz\nT4Jf/IDqzQluh5q06+zYx1KVYTIFN8+s\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5960", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5960` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASEcrucO+lrMsJktPhVnne9eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwYjExYWUyLTE0ZTYtNGFkOC1hOTE5LWMwNDQyN2JlZjZhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU3NzRmYTEtMjFi\nZi00NmQ4LTk4ZDAtNjUwYWNlY2ZkNWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpD3AyEqKkzFg+QfxM1sikrPYybyqprLkKIMY66Clo1b9FgtFRzgpAVigRQih\nRloVapK/eM6wfa9OpQaBrOd5iaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9uB2mQjOmmZn6+C9O80ijnsH6k4wHwYDVR0j\nBBgwFoAU99HIoifz8GkKJADn1kV4gkdGj+QwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAqMIVPDlwGFDc6/GM/7v+Za7j+xfOurudHvqiNmh9\nZ3ECIGdNJi57LCXV65wOslcnc57zJYOQ14aIo+dG+5rUKb8O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWFuHRBkzGt8+pX2G/Ak5RIxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGIxMWFlMi0xNGU2LTRhZDgtYTkxOS1jMDQ0MjdiZWY2YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy+dR2n2aIfJf+GkyqBKi9aUfzMyQhw7oRdxyzkZ94N1+M\n5gpJDuWyhbBxxBttoQmcQE8yCPlX6LwdCCTpDBIFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU99HIoifz8GkKJADn1kV4gkdG\nj+QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKgOF+SmYH6wgnWjH9lmfjyiGGfksEA7da46dVR9APaHAiBCp0EbU0sp\nEWEk3K0J+ofFbfF548tMXdW6dVjLFDCmHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAcbjgONzfl8rsyUViPG+7u6OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU3NzRmYTEtMjFiZi00NmQ4LTk4ZDAtNjUwYWNlY2ZkNWEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MjcyODky\nMS03MTVlLTRkMzUtYmI4MC0zMzYxZTg1NzhjZmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR9VP/gHqd8P3mexMQpaenaFQ9EfkA9nYF39ms7xEojMcQCsIP54RKR\nruO89aLzd62RvoZvmzbrQk8wMYsYtVn7o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT24HaZ\nCM6aZmfr4L07zSKOewfqTjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDKpG3heNNbIKMTcEyMmCXLQXvTxP4rbR6FZ0D0Eif3hwIgH5RJoJ+wjLq9\nrgWbPuQ5yyeHBNuzoQ9ops2jMWqwa4U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5961", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5961` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXtl4A43Orb0hldvdOw3s6lqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1NjM4YjEyLWVhYzYtNDRjNS1iZDAzLTExZGNmZmFmMWM4OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk4MWUyOWQtMzA2\nZS00YTAwLTk3NGYtZDE4MjNiNjVlZDA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkWRP8goynkZnl7DRSFsKdiciWoWwY7t2XOiqRZCuWMmU5lBl0/r8XrgAQan9\nBnaMAY2299gC/ZzBrAHkqJCkFKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJoAu8Iy8MmrzsYlxdCmtLGCUrYowHwYDVR0j\nBBgwFoAUYu8R4dE9pYWUmnaoZmCl7QA4vc0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiByta8yK5CRDjM0zzQ3hPIRZHyN5gh3ofgdd8dJ3884\nfAIhAI80j4ObMoXTZsJXAFReEnkTUlpd/O9TmhfY/avjE38K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVQo3uIA4Xr8u/JDsa9KrdrmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTYzOGIxMi1lYWM2LTQ0YzUtYmQwMy0xMWRjZmZhZjFjODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUzAkaVZxGzEbKWHPsdcsLGqB8IASjx4KJDORx+s6moFVS\nXnOdpl17WCYh2YASALqHtZamkGNjUU3DdqErvWPWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYu8R4dE9pYWUmnaoZmCl7QA4\nvc0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLZb0VEzG8jzd6XAyQpIHG99fwkBUzLk/ABrRenpnP6UCIFEaBmarejyS\nhLp94Buxqn909bUbQz+qEtL3e70KwkEO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAYAdjHsK4jRacEp5Vy7rCxxrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk4MWUyOWQtMzA2ZS00YTAwLTk3NGYtZDE4MjNiNjVlZDA3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjOGQwM2U5\nOC00ZGVkLTRiMmQtYTgwYS1jN2Y4MTM3YmQ1NTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQZuB7A34QZsTSzGUTEJwBiktMHeYSGNP58oOiqpAY0E55edOuJT2nx\nGF7DTz1hZR47RwtDEEuo+CfOs6u/SdJDo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQmgC7w\njLwyavOxiXF0Ka0sYJStijAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQC1h5BHl6X9ZDpB6KNHb9EV7K9zGxbC4j7Y0QEAIeynmgIgTVy+J4HknG4A\nd6SOrpbVEZoeQPwKeCeEMo6wCS6gE9A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5962", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5962` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISASfI839av/dyrogmhcTE37qrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMWViNDUxLTgwYmEtNDE1OC04NGMxLTU2YTNlOWU1MWMwOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJlNjVlN2MtOGQx\nZC00Nzk1LThiZWYtODViY2ZmOTc3NjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBtG0bnIJFTgh+IAMvIZIJanPtR5drAwEV2QEkwuMRGxwik9FY5/3e8Qc28G1\ns2xOZ+jbDgHwMZmO7qQuwjDQa6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzMhlED7BV8O0GX+B0Jup/VuUX5IwHwYDVR0j\nBBgwFoAU8rULXtTZbRsI1m1OO7UqhvnHdq4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAdPm5urdYbGsjRyI+EfXY9+YnFE4ZhSc0ZaoDnYlt6/QIgCilE\nOIZ8u4vj9repT58EpmQQxjajUx6d/9CN6qZAA2Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASEZqM1rpZavbuEO5l6KWUmrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDFlYjQ1MS04MGJhLTQxNTgtODRjMS01NmEzZTllNTFjMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6edqyWGQYP5tniecYXRuOws90nHkKJcfrwpJ5ylVidwk2\n2smsRFcOSBvVgh/ktjzr3reQpN1u0FpJcDRnzp12o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8rULXtTZbRsI1m1OO7UqhvnH\ndq4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFvXCtQKM8hmUVrO2U4k7cXu75XFW1LFpZayazzjfTFkCIQDlbAYAV2F6\nfJcnZuSskwL+RlFlfh5FkV0c58mcE/A2NA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISARP7DiMGi8LmX3k3NxRO0HeiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJlNjVlN2MtOGQxZC00Nzk1LThiZWYtODViY2ZmOTc3NjJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjOWNkNGVh\nYi1jYzcxLTQ0ZTktYmMzOS1mYTliOGNhOGY3ZDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASMEdipjKtERwx7+DwH46wfHUVy/tuY8oT1MaiDhk9EJ0R7NYUvb4H4\npNV4pxI0efM1YIGAYVa4ObkjdMCNSRZso2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMyGUQ\nPsFXw7QZf4HQm6n9W5RfkjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDQm2Hcy/WUhgw4Dr25azocEJDe/pVspU3GO4cdI4jEHQIhANO0nDoHHF9Z\neU06wG52Y1oX2hNNABI9a/S0keAJkG0M\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5963", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5963` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZuHDDdAai1+6Yn+8GkiRA3OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiZmZkNTIzLTQ5YjYtNGNkMy1iNGE5LTJhZmM5OGI1NjYzNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmYyZGNmODgtNDY2\nOC00MjFkLWFhNmMtMzMzZjBiMGFmY2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeruHiO9Ov4xqyNu0/QmlQVx0bf2Pc+ghY65eDrzZMuZhVgEmisoh+MaCm4Vn\nNrWOpMO6aSjwObmE2/s7Z/Tx6KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcfF8yo8xbGWC+6j1jwhQpCshUfgwHwYDVR0j\nBBgwFoAUisef9Y3cWYWYQSzXE+ZnMUpT3Y4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAoxiTexh2bsYNQz2AmSk1FYdnxJ/t5IrH\nMwOMDAFZmp8CICMKBKHJaEwDFf67gZoeRNsc0GS2FbdpgMItnia10Hv8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU21Xp0Yau8X2RtNTrVimaWfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmZmZDUyMy00OWI2LTRjZDMtYjRhOS0yYWZjOThiNTY2MzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATf2eZigtODdpW8pvTdyIdiXFVl88XWBLlVMJ7mc36goryx\niFUq9707HQllmQO1fO/AQ+127G1nVPRWcXIb0Jhwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUisef9Y3cWYWYQSzXE+ZnMUpT\n3Y4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEC+rhzj1DIXSh+6ApvRww8stbSsOZ+337bst8EYRjTACIDpYlCiBygyB\nDHV+tA74dBMIv1XtrHTkb8+GEuSwCkG4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAfPWsJMY8TLZ6KylOTNt817wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmYyZGNmODgtNDY2OC00MjFkLWFhNmMtMzMzZjBiMGFmY2NlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNWQ5Y2Qy\nNi02ZjY0LTQwMGEtYTA5YS0wOWQxY2FlN2YwMjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARAsIm+kgSyrWz9vSAVdEx+ZQgGf9oQb/mA4E+peSjNp90GgFPFMzSU\nTvucLNf7sPSnELlbRV4ae/w3MmTQVVHeo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRx8XzK\njzFsZYL7qPWPCFCkKyFR+DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQC5EBeob8/BCy+3fV1eJje9PJ2bebGienFdMmNRY6YpgQIgCd3adG5GknRX\n8O8L2x+wh49Pwb40FLd12fMMwb1+JCU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5964", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5964` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAXQLdI8RuEX0ERMcrORNc1E6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlZDE2NTc0LTA2YjMtNDI5NS1hZjc5LTM4NTBhM2FlMTUyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMzZTdlMWItNzMy\nOS00ZjE2LTlkOWItNzFhYmY3YTdmNGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECbe0iXG7qjJRIqhivTivu/hRPC04G7mAbsv3IU6zbeOdW49R3926W09vVpuq\nwMUGcGLQ8h/Hc+78u61KEPX7eaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6h/a4d3O2M9azxHdb/i1BKF2hIQwHwYDVR0j\nBBgwFoAUibk/mqkAcxdMHxHnIo33q5rNrOowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA9oRtU+Ll/CQ6q4WUt4kdSnUmYn6yQDGcW\nhOMLQ2FHNgIgNJtTNTD84j/pHn3M9KTeQ0lo8KXvJNQRCvCe0gGzHW4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAanLg8c/qSyZqt97ZNWHPaxZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWQxNjU3NC0wNmIzLTQyOTUtYWY3OS0zODUwYTNhZTE1MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcTwBxuQkEuLyxB/UOe1t7LKxrHC5fknXgbrAp430vRusj\ntm58SqpbfqPSMAJ+IOr9e/WgmcBtDZS6d9oWIILBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUibk/mqkAcxdMHxHnIo33q5rN\nrOowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPc2omQmo7L9xecyMSFf44uGmH2HUfCYJYpymlqxbmhZAiEApDbfLlgL\nOsD8DWTiPzsImJzg6emNAJUs67tHaHZ5bBc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISATrHIRy0FDzP1FDsGot8WUhGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMzZTdlMWItNzMyOS00ZjE2LTlkOWItNzFhYmY3YTdmNGVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZTRhNTJj\nNC04NWQ5LTQ1ZjctOTVhNC0xNWYxMjZmZjdkMTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQvdRlG8MDy3vt38vbsbc/VKhpw/NaC3C63tQgp3AbLKxEIaYHMeYv8\nXDhNKEe5eHDcfaqqgtM/SNcbtvIGJy5Qo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTqH9rh\n3c7Yz1rPEd1v+LUEoXaEhDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQC0YrBaV3lKwPbQjEDepV90bbMtX6HWwDXUdWJ/gF3WRAIhANLo7bO2DPWx\nnZBMVA2NnkwII1cfBzDnQg6YNSckC8xV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5965", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5965` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAZTvB6OBm8Dp1NZcDnhw5VlSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMjA1NzY4LWRhMzAtNGY3Zi1iZDg3LWVmMzdlNzlkYzQxZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk5ZTcyMWEtOTUy\nOC00ZmU4LTkwNDctNzYzOGE0YTM5ZTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl2fT+OLechuS9081T2/nXcLg6FJ1kNS0BkIVz2kmO/yuVsPMQ7B2WtptJNqr\nNH5NQINkQFB8oYL1Nr7X/S5I4KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKVPNqUJ4a8FRfEwt6W/14h3u33QwHwYDVR0j\nBBgwFoAUDKdfcKU6LVGnD8g2wzwedDV1oCcwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA9A0ypH745JEz\n9sog9pryfhfds3wYW6oBDN1gjnFlcMUCIQDIBpiDM2npdHokLLuZCFd+bBOEfFU6\nxwbWF/QOfU9SRA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATXJtn1b6ZeNDqCDGHU0/JDAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzIwNTc2OC1kYTMwLTRmN2YtYmQ4Ny1lZjM3ZTc5ZGM0MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIElpLMnUBoUI+eqEC+xmHJj4SAnz/L8HFlxl5VMYi5ELv\nKI/BQ67aJiVcGCdpTK64WSCPjl3N9tAuliUsyY2Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDKdfcKU6LVGnD8g2wzwedDV1\noCcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN1UEJxo/d+F8YhcI8USLgu1Vmz4FjNaREtvgznJLoZ8AiBq0sMRT/DD\ngIFsrfWNDC9hY3ycjZimjzhENZFojNsYGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISATmw479Y0s2qiheoQITrnBOnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk5ZTcyMWEtOTUyOC00ZmU4LTkwNDctNzYzOGE0YTM5ZTQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNGM0NmI4\nYy02M2FjLTQwNjItYjc4MC1jMzk1MjJhZjNhY2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ3TbZmIManZtVg5ccOCpWbqBn6m4aoVWk+FRosKdH+s0SMNFCDLhZt\nES6rnfb58wWRyMvKASu7MfKEr20bP7Mjo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQpU82p\nQnhrwVF8TC3pb/XiHe7fdDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIAfmzPdlho+zkGEmVwD5b729fpFjd6UszOLDTCCX6pAtAiBB7tawHcpM5KKg\nkJ8GttOT7zConOwJGqnVgoxI35g+1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5966", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5966` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAertxcqf+RMXyMS+ViCZCiLoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzZDViOWEzLTBmNzktNDE1Yy05YWZhLWRmZGQ5ZmE0ZjdjYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJjNzhmMmYtYjBm\nOS00NzNiLWFiNGYtNWZiZGQ0YjkxZjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWVsPGCzUUNLZZZ29XcaFKrMb2xRw7g9+7OuaR4dRbu3ThhycH52dtdRSXqI6\nUuUAEcpb4vHmzF/2CfcnHo7O56OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJkNqO4sNKBaLynkGgMw9hrjHn4IwHwYDVR0j\nBBgwFoAUBFWEGxw5j1LZkwJruQWGTLumsQgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD+lINwjQt97WOHO31OTw2Rxu2r8SA6qMO6DfF+UsvB0wIgMpQdSTeigi0R\nFPuCfZU7gtusXN/LTn/IBDQQnHhrToQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVbegstf7UfO++zy5h2WyYDOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2Q1YjlhMy0wZjc5LTQxNWMtOWFmYS1kZmRkOWZhNGY3Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNmmSlIOSJ3/rdd3V25eYFWJ0ybiC2KRAqU5+5Xb913z6J\nK9a/MqBXciPEQ28PWju/Wk6r2wzsoZnFbdE1p8cyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBFWEGxw5j1LZkwJruQWGTLum\nsQgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD+IkJBuhiZoJOoNoY7vaEtLUiWb+MKUZn7h3akS163oCIHn3vi/1Kd3e\njKLgRszF9PrzralDrENqJeWb2YHvLLVn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAYqBh4xZ2V7Ucgl6JY3F++85MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJjNzhmMmYtYjBmOS00NzNiLWFiNGYtNWZiZGQ0YjkxZjMyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNWFhYWJm\nZi00ZTRlLTQyODYtYmYzYi1kYzliNmU5YTE2OGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASE/+NkUo6ce4Cte3uowo20D8paLzAHVhlcZzJtW0+XWoy8BWe7M5xy\nYqRPTXZGN0QbxKUgICz3ElJi+M8Siynno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQmQ2o7\niw0oFovKeQaAzD2GuMefgjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDFQ+ylNRWRf0WeusOHQxLF4BlE00JaADdKk0jJ5LHC0AIgcN6wA+6CJCLL\nVMa3oXP5hAJrDpAe8VHApmmC5ktox6k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5967", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5967` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbj53aoxuEb/IgmLnEpNWvrVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5YmZjNTcwLWI4NzktNDQyNC1iZDI4LTU4NDQ1NmVjNGE0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU3MzE2NTgtZjVj\nNS00ZjIyLWEzYzItNTE5MTE1NGU4ODIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt6XAcWmjcPcSo0YW1nAY/xpW2SLjBLcwgoakWCcZ4scpJtMlLtSxagebXDmd\njh0dPkVrSBXLgr94sXCvvOKpVaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUzmqBRJaMSdDbcA52foKyWy0QRQwHwYDVR0j\nBBgwFoAUqOxPjJ20aBdHlUQGdHtx1AmST0IwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGwlmGgkHvprovImRoh6ukNl9EhY85L7uU1AW2tmrKIJAiB9P6tApXdTY0yR\n7N3b9kDpBl5NMMLwz+TfsefmQ9T9xg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfNHha0fdQATNoCgY/Tvy3wyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWJmYzU3MC1iODc5LTQ0MjQtYmQyOC01ODQ0NTZlYzRhNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASI9uvP7JHnZ95Y8vn1nLkpYtduwtBCp5cAy9gb6Ej7DAPk\np8xUnUrVGk82MtbUYsIDInHiOP3VNyzpPW5FP2p1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqOxPjJ20aBdHlUQGdHtx1AmS\nT0IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOAM8wYNEYPU39sp1DWfH87yrB9xg6rcNSuI2XbLFDpvAiEA8q1WKzIs\nE+fbF0GzfduXTwedPH41ADIY0FmOfgoNQYM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAdg8id6ws2Qxr2GVsaTgB55CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU3MzE2NTgtZjVjNS00ZjIyLWEzYzItNTE5MTE1NGU4ODIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMjc3NjJk\nYy0zN2ExLTQ5ZmMtOWVjYy0zMzY3YzEwMzJhNTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQVxyK+9V9HFMmFbHtKSrCxVVViwzGJAIZUbYplJ837CWw4Lb9HV5Bs\nlEHREvbIJYTfgqMP4AEi3nGPGNzxIBggo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTOaoF\nEloxJ0NtwDnZ+grJbLRBFDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDdJnFYhNDer7dRUACHU9yifJiwFQX57OK2pdNJICAdXAIhAIriaQk5wOUd\nSNyzz4eCH4zICJoacblf+77Xe1/UCad4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5968", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5968` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISARu1Z7qSqLANwAbdgRyLLMa1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhODFlMWM4LTY3ODMtNDMwMC04OWQ4LTMyOTFhYTIzOTg4MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQzYWY3ZDMtNzBk\nYS00YWI2LWI0ODktMGI0YTQzMjM4MjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfMuy64goFmUMRiB7uFB8FqvslkJTseEUDnpPSL8ZTtC111pDVdo0ax+HGHgd\npUVbmSSp/c31BJVUcpb/WQ/6c6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKg+5PXUPssJSbNZzkUTmWPfNE1wwHwYDVR0j\nBBgwFoAUjsVyQgtzt1HpDaKxuUawWi6/umIwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAREBJz2gGm1Fv19UWXxNcWD637OpJND4sBUBdHXNBd/wIhAJ3hTWsWEYlG\nJOsBd7zlUXgSqn2B+9X4lXf1z2lsfe2u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdkuoOMaWs1WFrmld16aVWNkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTgxZTFjOC02NzgzLTQzMDAtODlkOC0zMjkxYWEyMzk4ODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdyhX79WW9vgc05+5jNcCo3ZMULLCNpfEE/ZTjaFa5GJtk\nhp3/aGb/1wOj5z9dGfSeEGhfdwPBbAkyo8ZF4Hdko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjsVyQgtzt1HpDaKxuUawWi6/\numIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOTEtBvqSz8BuTJy5WfFUEDVpr8drZOer6sj8GyJ9llZAiEA9iX28RFZ\nhH7E0CNEeyk1VfmMOGov5BeoLrsL5VEumRo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZ7RqF63cacDutw9veIPxY4cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQzYWY3ZDMtNzBkYS00YWI2LWI0ODktMGI0YTQzMjM4MjcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NTZmNTg5\nYy04ZjRiLTQ4ZTItYWU2Ny05ZGZhNWE5MTVkNTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQkGjILl28AtscBTu2Q2es5I4zcZW8VhEpKvGAaLomj/69DZ3ytXgY3\nGygzMeMwSbt8yoDQKReThS0v3H5lF0lfo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQqD7k9\ndQ+ywlJs1nORROZY980TXDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDz1396L+BIQ6xupz+9SFxLPMXHss3ISqLcnwlCVRB6ewIgVTh4MhshopZw\neHVENT9eo+eKJb8rwYtta3FFJPnDZgs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5969", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5969` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASP9rT28yzcLYuunrZwqoyfUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4YjllODYzLTJkMWYtNDc2Ni04MjhkLWRmY2M4M2Q4MDY1MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIwNjdhYzktNTFh\nNi00OTEyLTk1NzktMWU3NWY3NGJjMGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE12rp0NmCx3SoEaX+7lbF+sfCf9Jr8EaqnGnQ+/gw6bSwHUs9a3IFMGHuJ4Hw\ndC1xa9pRfPHoCVLzaIYaTU6eTaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeZrySfEpAMs15W0biCwYMKYgVTIwHwYDVR0j\nBBgwFoAU7MFuj4gfuUteIcpzOds8cWREzO0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAjdjMY7acF5Xc5dW98d+EMnTJGFlxmcnuYGzzTqeJ\nBQwCIBlxeMP1XfPWFdlLVgzdjfeQgdm8vNIYFcifkM+IU6mZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX4Q9D4JBfJqVkdgbkZSenMxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGI5ZTg2My0yZDFmLTQ3NjYtODI4ZC1kZmNjODNkODA2NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9DHn77UBKCaUjqEajhDM31bLlD6LuoqWFJwBsOnF7+gxj\n+cdbkodCSkD9vJtpm2YazyNtsOaevZPi0fwOuBdNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7MFuj4gfuUteIcpzOds8cWRE\nzO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPrZUwl0dNvpcPFyant4ikptBm7TiM1pqe8qe9tBqseaAiEAmmu0+ljr\nlpwvMzhDWD9UvM2QrhIKe1ZUX8zN5RkUc1M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISASYYSPEpAxNU7yzy0/eIsrmSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIwNjdhYzktNTFhNi00OTEyLTk1NzktMWU3NWY3NGJjMGJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMzlkYzFi\nZS0xNzYzLTRmNDEtYmUxYy01Y2JiMzJiZDQwODkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARO1BfQUnpSDmwPdyYFWN9+TF43tM1FTiWJ8z1idosfFJF+Ye/rZRt2\nRe5AMhBQmfsvSzX5mqbeOWslQJ69G8M2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5mvJJ\n8SkAyzXlbRuILBgwpiBVMjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCFXdK+dBtgeOtO4Fvdf8KhiJqzjB5fUnPsGwLCLbbb5QIhAI4D4QfoE4KG\nNxxnhVp/PZXl5ReHtd6Tg2nzkpsKAHjA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5970", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5970` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAZUINPPwpAKszurYATuQrCsEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ZDE5MjUyLTZhNzctNDhkZC05ZmE0LWZmOGU1MWUwODFiOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFmM2VjNTAtNWNj\nYi00NGQ4LThlM2EtNTQ0NDAwMzMxMTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdE6QYbMXz+o1LNiIZGscsBQlipSkAP9tA1fVML76hMr7ABbQ4JUR06V8AXMe\nNqlAjvx/NrzMS6b4zmp8j8UTiKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV7pTPoXVbUenN3Ke+idSZayZBtcwHwYDVR0j\nBBgwFoAUrvK/R2fXeZqI0eCvS/ah7+8ckxQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAGHgaiNqywQUtozV4w3WeoOEFMTCwmFyxqZGylIM7c\nGgIgaXsSJWtFjhB6PsS8VWuYcAFSs+bajBUdOT9bCeDs3uI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWVGe0qcLyplytBMOfdz6TXmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWQxOTI1Mi02YTc3LTQ4ZGQtOWZhNC1mZjhlNTFlMDgxYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbiQzjDq0hJB0drVIRop970wNYVY8AwHXYHNpV2kPWCAwf\n77GHIgHUISl4QhvHzQ8Y5u/lxnUDud3IihC7/IgVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrvK/R2fXeZqI0eCvS/ah7+8c\nkxQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOs90Ex/PPooYk1wcG8tHlzAQibilQRz1BqjbzLUJx+oAiEAgNcMk6tG\nJrT1AZhIK/Xr1oWRivjP31XuKJIEr9GREHo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAQVEt5JTC1jwvSBDCoHsL8TJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFmM2VjNTAtNWNjYi00NGQ4LThlM2EtNTQ0NDAwMzMxMTllMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZjBiMTEx\nNC0yNThiLTRhYjctOWJlZS01ODI1OTk2YzM3ZGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQtfKZnUQ+52J5QTDhUJbdKA8uQYiqmmsa7hYP0SZsiTvVwExovnMyB\nUlXlgIQTuagik1oppPquAxMD6KU3+F3ao2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRXulM+\nhdVtR6c3cp76J1JlrJkG1zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIFYvmY5CEyXvSAk7xz6Z4ypjiF1eg/2l9W3t/epi3BACAiEAndc/kKbXQLqt\nJ10kUO0ZTR0XJQjWo7S0QjZV2GHfdS8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5971", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5971` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISARjYUtSH1yNZIxHFpiCV0Pr2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNzJiOTEzLTMyN2UtNGVkNi05MmE3LWM1MGE3MDA4MDY0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM2NWRkYWMtNmI1\nMC00ZTFiLWE5N2YtMjkyNmMwYTlkOTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESqo8GVcyM4bZgE7i2RIitSJX5KXJHxsUS/o+PdobMZdplayr+tO5hIxBMcfY\n4MFov8RpPnamFq/lHnU3U6WC6KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpBiEpbLPjH3EVU8RT+0asFNqkqEwHwYDVR0j\nBBgwFoAUAwWll+YiJfrduLe5tS+7SrN4r/MwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBNaM1jXwNmMGydAQnX44RfFYSsT82IacLCErzPckJ8jwIgPQIg\nrHtU0ksF4w/S4vtQ2T45qSeKKR5KqfsmLBr60Bc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZWVEKOhRhrUyWmo85X8yF0TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjcyYjkxMy0zMjdlLTRlZDYtOTJhNy1jNTBhNzAwODA2NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReFqu3xCPxFESD7m4xBLfLtbGYwQXbbC9PnsIJNRgu9B9V\n9tt+Aa3m9ZSfA3U+9Y1Ds+j5t9DuEp7yXDxmitVmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAwWll+YiJfrduLe5tS+7SrN4\nr/MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIaswn3v9l5k0UxG5tRW6uG/2DdIX1DwjBwzFOWzzBMACIQDe7ZYPIXvL\nyJwnDgRjskuFeiKDNhBr2s6VlVKX5A4RPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISATiyPGJcZ2SYTX4pHBRzEWrzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM2NWRkYWMtNmI1MC00ZTFiLWE5N2YtMjkyNmMwYTlkOTdkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMGI5NzEz\nNC04Y2ViLTRlMDAtOWFiNS1hODM3MGQwODYwMGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARXhFh2Mt7W4NkGH0uRn7x73hTvt+ccyPShma+MmgqgpH5KR/IzQzzn\n9dP3e/lvnLypz1ySN9R9nSBoNSMsrAhAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSkGISl\nss+MfcRVTxFP7RqwU2qSoTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIBnd+GCFNTSO6BZaTzm4CK6CgJuefrwoZP1gOrAqCjvbAiBr9tLSghX9Vxw6\nm25WLCgp8s4WMm0TlLqIbeggs1/kmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5972", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5972` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAdYjYVNFj7dpBJcRMbw3copsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NzdiMDE4LTgyM2MtNDJkMS1hMTdmLWE2Nzg3NTEwZjFkMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRiNWZlZjYtZTEx\nZi00MjVlLTg1NGQtMmFhYjc2Y2ZjYTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExh37YAz4+6Ibxj327NbUjW2EGIR1IUV8twpalPAMCkxywypxy11OwkkObVRt\n/1yC3SVrAcZX0/na2Sjh0SNZCKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2/u7THW5qB4E7b4pW4aKnlu2aEAwHwYDVR0j\nBBgwFoAUSm/6vzB2Ya3x9qPzt+dZu9MRQ5IwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB2YIlBcm4puKDUlbHL46qZ9jiSUk1REUkm\nkGsv4u7fdgIgf9hPZ2V4K7gIPrQg6Potgq7TrkLjtK65ZOt9/9pHyq0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU4iNz+kc+BVs4LnbIxIluSrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDc3YjAxOC04MjNjLTQyZDEtYTE3Zi1hNjc4NzUxMGYxZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUdU3ySZKoIeLaU5p6Xgm5tWyZeChcWHxVqOu/n2Y6KfFs\nsY9CMwR9YLZk8awsdAi/1M675I5ubz8gx1PgFEv5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSm/6vzB2Ya3x9qPzt+dZu9MR\nQ5IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOQlsyXGjSJJwA39z8e3WCAFtIQlDCtH8Pdk57ec4baIAiEA5Dy10sJY\nLtEON7x8KKZTtv98jlD+P8LM4BB/d9yFwAw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAWVcThAVi+2cP36lkDlKMz6vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRiNWZlZjYtZTExZi00MjVlLTg1NGQtMmFhYjc2Y2ZjYTY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZTI3NGEy\nZS1iNDY2LTQ0NTYtODZlMC1hNzEyNDdkN2MzMmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7yGGfMjUFqA6x9+Tm6iBtsmC8kkcZeLcs3Llk9zHtAi922050lqv1\n08jqXy6urZv13ya7AaSDMRFwoMzlDxuMo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTb+7tM\ndbmoHgTtvilbhoqeW7ZoQDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIAw66A9YIMn0W2es1I5x0bE+4wIKbF2zrmjXfBnIvtJLAiBkxqnO4ftzjaLg\nHZDKydDytU4KW3yRJp1EQX/be1eVKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5973", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5973` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdYwdsBsriNUbAD5WJF63ZL+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjNzhhMmZiLWJhYTAtNGM5MC1iOTIxLTA1MmY3MTdiYjhhOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTRiYjk4YmUtY2Y4\nZS00MWVhLWE1YTYtY2E2YzQxM2I4MDJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyY5spBkIzw6kL8Rk0ZnNvQsy6qSf5UTwNU4xabYm6OkFGd67pNr7RZ3pUo+Y\nsmNef08mfYNDyo3kXCe9RKapnaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWOJlRwtNLFjW8VYah2LcvbALdEgwHwYDVR0j\nBBgwFoAU2bPF5kppkIpm1v2imEEgIxUBtnIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA472ZhOffbGyuTm9kJ00l7IB/fs12Ey/Ry\n+IQdfU1T7gIhAI90zPrr1Sh7WQhSzUVyVkklG27X6rN/2yj7lwY9vFv3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYWugywfxiCNBjHdimuUnoBZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzc4YTJmYi1iYWEwLTRjOTAtYjkyMS0wNTJmNzE3YmI4YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjzwrDZ2rPJGdgtHYHDT0T2ulLvQTY8rMTk0YyPfZpdJFJ\ngq++fCHKJ9oZ9OrcNTZINlfVa0UASEPpPmxavA0vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2bPF5kppkIpm1v2imEEgIxUB\ntnIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJC94Lucr9bXoNIA/u6YthGHY7dAg6V8SGzwfYzahRgdAiBUFeS3fRSK\nw+jxCvzQEosBfaexxxQMqB1TOib+ZOzEpg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAYfIjRULW0NA0c47Y5SwBZxmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTRiYjk4YmUtY2Y4ZS00MWVhLWE1YTYtY2E2YzQxM2I4MDJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0M2VkNjA2\nYy1mMjQ4LTQ5YjAtOGU4Yy05YmNkZDY3ODJlMTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASM1cc0SUfVj2ubfQLwXY3maV1IwT0KC1GtO/V1KKv3WnEYG8qF2ELo\noNkM+0iUZabk49HbBRSBGr7bPbUshmJvo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRY4mVH\nC00sWNbxVhqHYty9sAt0SDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIG/9dNQz0U+xVCkolmc2no69/F/kAWGuVU2M1bEd6PveAiBZ67BcpxCY1OLu\n7/Y3+Eur7ZNlH4Huls2ts1Fmk2uZ2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5974", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5974` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAa/XWVTo0uiffK0gj9ZJNEr2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkZDIxNTc4LWYzZWYtNDc2OC1hODg0LTIzODVjMzUzNzhiMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTAxMTYzNjMtZGRi\nNy00NzJhLWFkYWUtZDQ3OTZlMDYwZWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqLYACHZbhEQVbh7itE1BG9IDg/gJVl5VH7tSoyr3EquNqN8RZrhbDwDN150b\nHs9ctVM0UszTL26kDflgUsu3N6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5lsVqxivkDwsv/5T3UBTDRFW15MwHwYDVR0j\nBBgwFoAUeFajYaHfq7de9j7Q0WyPKt5awl4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDfUb0zhXbJv/0fuIBdlX0yM/8T\nL0m8ihQUitZvTA1kCAIgcLWsPEEM3be8mI7yd8XLDu5lH6wYpVkSfNqwBSzFT0s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUciLUcmsaoBlQOop6eLt7jeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGQyMTU3OC1mM2VmLTQ3NjgtYTg4NC0yMzg1YzM1Mzc4YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgHY7VzBqP1krtDorLLko9pd8Z+dSrwIXb8oDDYasDrILF\nSo6j+Tt+0pueqDbbdSW/tyc1dF99ommLG1ZfDGpco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeFajYaHfq7de9j7Q0WyPKt5a\nwl4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYGaQN07bWRUp3+zxBJr0ayjiDH+P6pwgNdHlOqEVmEgCIAIMhnPSYhKB\ng4dGRMjSi79F5O1PLl4sFeLaYPnZZE+r\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAT5A3h9yeK0TKSPP60lrTxOOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTAxMTYzNjMtZGRiNy00NzJhLWFkYWUtZDQ3OTZlMDYwZWYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMGYzZDY1\nMS05Yjk3LTQ2YzYtOTdkNC0wNjcyOWZkMWE0NzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR3ZyPQBxGF74XF07K7diqSi8bhl09lBYHpC1OU2s9A/iyo+2o0NxYg\n8dvBnnQrPvuj9EZY7n/FcQ2KgAfvAvSFo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTmWxWr\nGK+QPCy//lPdQFMNEVbXkzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDJhwSj3Pcdg71cDxS3aK6VIvMUzNjO6MFeIbvKGPWqIAIgZUcC71pVmnoL\nkpBx2mO5MKB1dNynffUtlZ/IQirMXnc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5975", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5975` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAe5oFp39fzfKykhEsZADEEQaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3MmRiYzQ4LTdmYjctNGU5Zi1iZTY0LTEzN2E3MjY0ODQ2ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJiY2ZiYzctNTIy\nMS00YjI5LTgwZjYtZmE1MzNhNWJmZTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVYlKLPhvBkZ4XxQLjP7c6SdG2iUj7YlD/d04SyfcYSxoPRDBdtpCsPQgO7g+\nyhve3VQCWpeK9Foo7F6P9xHq+aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5DqX0Ra7xKPv7WazB9F7GM84Cw0wHwYDVR0j\nBBgwFoAUd2FQTl1WNWpmcRTc/IfB8whcYm0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgQdB3I9Ml\nPJYvUqesbC93X0P/+EWx6iigtBHeaTuKKZQCIGXqcYrO/36ycJpdbrgWIBSJtXbL\nG3D6q3t6bM8NE811\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVyfhVF3wtNzyBJtWiJGsca2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzJkYmM0OC03ZmI3LTRlOWYtYmU2NC0xMzdhNzI2NDg0NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYpDAemtSO2uDrtMUBiu5DxqA6YtyKT2FBXkAxKvkng1UZ\nIIXKyWF7lb7UAQktAcE0N60WEE4EYvl7JUps4fB2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd2FQTl1WNWpmcRTc/IfB8whc\nYm0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANZC991f+V3C0tOW7R55XkIjTOH5kIk6/LCCI5rBTIebAiEAofyhQ8YX\nXXLb46QMi8ZmNzt4ICI8sI/jc4zyxtrZYjk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAcUn5LHmchcctSt4okMa3cJuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJiY2ZiYzctNTIyMS00YjI5LTgwZjYtZmE1MzNhNWJmZTUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ZTA3MzNj\nOS1lZDQ1LTRjZmUtYmJmNi02MDYxMDE1YzJiODUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATB8921Z4xaXkwrPyx984xLrARjZYu7E9xQWlIAhictGsjDJlp3kLMI\nClc+UdisH8gpOYrGW5eaZ3PlrBYftSAro2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTkOpfR\nFrvEo+/tZrMH0XsYzzgLDTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIHnhH2OWcrqhH0mxrf+ml1Css7O0B0gx+eqR80eCnGs5AiEA/S9eUDM/ZKQl\nnbTTGwzimtmXbEAzp4E59KlrR2py22s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5976", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5976` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISARhEjFBFSm+8wqwq6egQZMT/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZjcxOWE4LTU2MmEtNDY2NS05YjEwLWUwZWI3MWRmYTQ4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM3MzM1NjktMTA5\nOC00M2I5LTg2ZTktNGI2YWFhOTA2YjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP/u2fPhILehbYgtWOE1Yl+B5CQ/6DmJFQt4IlfpTYLChP/77A8KKQAnJDzgp\n4rmcfZB88Pi2sLladpLf9+rIAKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9I7hHRN1D2+niglz2V2VYYJPvjkwHwYDVR0j\nBBgwFoAUUYz05mQrIYpoWNLfDGjmpQ5+j0swKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgDCLLBrN7\np/5u0rGCwsoeex8vt1oD+IONrcSxsuRZ1AcCIAj/GCbxbQRbR003Ovv7c7lNUYLH\nYpWxAE37T1IBG9NA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAas1dbfue85vm/1osfcLcIYjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWY3MTlhOC01NjJhLTQ2NjUtOWIxMC1lMGViNzFkZmE0OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7gNVahGejvcBAmz7rclyK8FEKiP8Ym6/AjgcvoXAHAns7\nuDRJ3vCsZg7FAFmm+KKvfXj14pM+G0KpHGB6PELao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUYz05mQrIYpoWNLfDGjmpQ5+\nj0swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM2trB1yf1ehr+YHkh8JrCi9Lc+RLix92b7NrI/a9WyYCIC8zbCpFkpzL\nXygY9pABSNRjUHEZePBBOPQ+fT58Go3O\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAXryPOzboOEDLydcfzOsJFj1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM3MzM1NjktMTA5OC00M2I5LTg2ZTktNGI2YWFhOTA2YjdhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZTNiNjFj\nNC0zOTM2LTRhYzYtYWMxMy1mZjdmMmZkNjA0NjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASVUrdVy373IxaunOrMHK4g1r+bqfceaul3snrncws38gV6PhP1t32W\nSGxORvlJDmRGjOra6uVpjrDChHDD9SRRo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT0juEd\nE3UPb6eKCXPZXZVhgk++OTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIFUwaB9OV/du15Usd/rvG0FKBk0OK/QJeEcw6MawkEuHAiA1TQziFjasyWBm\n/CzTItkXTpPqmg6T0hVhME6aO3+nsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5977", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5977` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAVZtlyyQKTqRsSHkphpHua07MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmODJkZDkwLTRiMGYtNGFkMS04MDYzLWQyNDE4NTBlMGJkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTMxNjRlNWMtZjI0\nNi00ZWQ2LTkwMzUtMDIxMWYyZGUyODhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHHvWa9guq8RweQS5jGAn2WRvmaZXx9ESAJOX59UyIiTM8IVcynzrjNZFAD2X\nDSHQZCIvNdOWMy46y1UVVNDqm6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHJAL4V/5B4od4m7Y9zcgDRjDRpQwHwYDVR0j\nBBgwFoAUuuJ2dvbDt//qwOYEKPbciji1fS0wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHteAC3w\nAka1CMrKPLnlBJhuwk99oZDfEMAm0REniyxeAiAzhdFaH7+Bi4v9R8aVpgDNk5qV\ntfSKg69IwQc+X4QbqA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWTD/hEkDF4kaN+UtE68UY6tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjgyZGQ5MC00YjBmLTRhZDEtODA2My1kMjQxODUwZTBiZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQG2ENeZveM2aWSShyk8fxkjajDQhV+jzXSb3e/Ic+fyzKy\nFAN7shiEEu7OpPKXme6h5x08MzsIld8Bn8OP8hbto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuuJ2dvbDt//qwOYEKPbciji1\nfS0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKo4uUcfiKwe5g7YeYGp4N+pg8Z1Eh/Am3YlHA3u2sWLAiBomxoRNj44\nKr/BGLemw9sj3uaSd6Fcrz76odvr1c+0Sg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAfUvJNAYiuvszm6CpByFsf92MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTMxNjRlNWMtZjI0Ni00ZWQ2LTkwMzUtMDIxMWYyZGUyODhiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYTNhZmY3\nNS0wOTcxLTRlNDEtODk3NS02NjRjNjM2NDVhZTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARKWVpHXKs0/frQcKnbQPaOIYPjNbuxRt3PwhbQRNIomz5gDQdU9pnD\nviGmFDtyivxkZYZSEYU7Z6q5EMIuN+EAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQckAvh\nX/kHih3ibtj3NyANGMNGlDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQC6as7/DiHNeHaYZQ1zDL+WrSf6pf+i6850RNuun5VmhQIgF4ofgFg9zmpA\nZcG2zGVp94K42uA0ql5eLZe1dzNDbI8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5978", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5978` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARM1dJ4uDEZY7+MTqisrkzUWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2OTU5NjJmLTQzMjktNDI3ZS1iOTg4LTUxYzFmMmIyZDg1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkwZmI2M2QtMTE1\nYS00NjViLWE0MmYtMzMzOWE3ZTRlNWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkASamS4kSMxzBXNXKTqUTZ8WNzJWt6nuN9EITTzX1hjjvAAYaami2a/vVZKs\nGSE3EfNMugn6SOzRWU8jkyjhpKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDdR/FoJ62kKGhr5pHkq63yD85NcwHwYDVR0j\nBBgwFoAU1v4+IxwJmvsLgTFjvGeCtzjULZowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCICNaYK91jyghxlhnyYjEPp5qt1ZaydH9FDhd584VnWwoAiEA0va5Vzlr\nsPs1Oxuv3/HFWeiHLEDPS1XSPJ8NWlDTbzU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaSFNoty+99aTzSO8IKX+MISMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjk1OTYyZi00MzI5LTQyN2UtYjk4OC01MWMxZjJiMmQ4NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8i4IAJgMj29AruODLyTLLWp682OqvwlEJm+9Kv7Vt9pDg\nUN+RomGpMlmOrc9/y7zic62DDAc5t1GNSuOfuXqWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1v4+IxwJmvsLgTFjvGeCtzjU\nLZowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG1YVAX/69dqvVcogH7tP3S+T4RH25mcZgbKSXN/YHsMCIF6ePiiHHUH6\nVUX7ElMti7uIXHyDfEnT+sQ0oxmIZjku\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAVC1++xVZnCnpI9ey3ngwXQyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkwZmI2M2QtMTE1YS00NjViLWE0MmYtMzMzOWE3ZTRlNWU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMGM2YTdm\nMC05OTQ5LTRiOTUtYmE1Yi1kMmE3YzQ0M2MyYzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAREZGmfeeV4tD5bAifju3m1d7t8unEALN8BpjeuedfoQF03kGC/qU8h\nJZkQPAQ6pPM1niuiG7BLJdjB6O4Zwndwo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQN1H8W\ngnraQoaGvmkeSrrfIPzk1zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCID/P4iWV8Bl3tYQsfJpJuXPF4rNR/grv7gdRgG83uij0AiBkyZYg2jRp6wwU\n6oioGDY3/9ORWqZQxpq3u4ocnXJmvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5979", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5979` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAW4D5oI+lsVoebTDjMhp5xNEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViZmRmMGU0LTVmYWEtNGU5Mi05ZmY2LTllZjdiYThkYmZjODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RhZGRlMmMtNTk2\nZS00MTM5LWFlYzktZDhmYTVkN2E0OTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa0Xg6BcHKMBK3q0FcANHsPnudrdW0CnG+0fZO4MgIMb327lRklsGkYLNIJKp\n6yAVQ79Dp+0ibY4Qoje++LM2IKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvOVZetZZrsYmVJ5EU5OSkmZp5QwwHwYDVR0j\nBBgwFoAUT9qVoDb3rPiKVhPfMrvPe44b23gwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCRKiUdss3m0qAbUZ6U/HMA/Jx9lkZO5OMKHxOv4ouIogIhANFH19PZ\n8s3R/+VnDxxJCGU7TFhRRUrv3PiVJ2mKPhUz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUYUGeJ9w3CgIRqCqbZSi74/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmZkZjBlNC01ZmFhLTRlOTItOWZmNi05ZWY3YmE4ZGJmYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6Sm31nnlF8UjHrJQNbRlZRm/m8Fe5Aa9HMI5nx7uE1ibc\nAyq73tyHzNteTXAaPoRAxmCRQXaq2f3+1DR7Bho/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT9qVoDb3rPiKVhPfMrvPe44b\n23gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHOsWvMjGtNOakpG2Lu4MbboYYfp3l6ohet509E02jJ0CICQZhihY+VjI\nlHj6rDyDSNGCF4JvZEjdfOj1hkI44kbP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAczqab2loUHqJUFAPiFgZa0aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RhZGRlMmMtNTk2ZS00MTM5LWFlYzktZDhmYTVkN2E0OTEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4N2RhNDAy\nMS05MzE4LTQyNzItOTYxMy1kNmYzYzI2ZjdiNDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARknhhFAIPmjJFZZXGwwcxdIltTtS7vyiB29VsW4nVLSk5eVoYF6nIo\neBqMPylgNmJpk1Hy8HrOU9UxMRpoyYuoo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS85Vl6\n1lmuxiZUnkRTk5KSZmnlDDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDxJVHQFkCCa8jxc9T3N3CI6PLCEGbyG5zxsDVYa9mANAIgQDwYQVkJT03A\nq+oXQwEtZ2ShdZVoay7rB6wXK1d1Qw4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5980", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5980` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISASkVinaIAiMRA2cTAWlkLjbdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyYzBjZGJmLTAyNWQtNDA5YS1hNTNiLTg5YjlmMGFjMzE4NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWE4YjYxNWYtOWUz\nZC00MjRkLWFmY2UtN2M0M2MyNWYwZGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0pS3RDlaXN5rI/DFBw4ZJhjr80rsz80NgWBSDexW56p4kF9L6zXbL+/poMy5\ndjgkCOiuqcMsOFsGEMulbbUnyKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU90TfWY5cA8fQRwCz0gKxr2e8vTUwHwYDVR0j\nBBgwFoAU/XGo3T6dX9JLOzcZVN1f6tipn8cwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIFa++gfdc0TTtdPhXVm2Lz0oh5sbB8UHge/TQ33VtjEpAiA45UJghkUQblIdqOq2\nve8YTiAaqa0Ii64FwbTaBQp4+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaiwTeIImVL+GC+gUcbZcLttMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmMwY2RiZi0wMjVkLTQwOWEtYTUzYi04OWI5ZjBhYzMxODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnxtdIZ/7yyVNlzWaVJi/ot7pnV4eTaulkZbLzLYNHvxvb\n1q8DJqdvOeJsEYDungGcxe21BO7YeU0aqG+4JJC1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/XGo3T6dX9JLOzcZVN1f6tip\nn8cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANBfautKB7CvbkmuZQK4fDo2/BDMbk0RhvhSQRqej8+ZAiEAsOo988+3\n8S3m9DcFNBpGf/yjZM1GvyeL5YIQUQYlHns=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAY3Id1eR2koOLIzq+liz9BfMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWE4YjYxNWYtOWUzZC00MjRkLWFmY2UtN2M0M2MyNWYwZGJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNDFiOGI4\nMS0wN2NkLTRhMjMtYjI5NS0xMTcxOTZkMzc4ZmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQtV9bxnuu4icPBrOUgslcCgK9LB+ViEt5evikmvMR+9kHNsTNd6r6M\nAtwiEJiY0oMQmEr3NIDXvcjqTKmzZ1Zio2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3RN9Z\njlwDx9BHALPSArGvZ7y9NTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCbbAv0of28umO2lX2kASokLm0kiavjRPaMzdQP7/lGfQIhAIxO+G+hO08d\nnCKyh5UTBpOt79RJ6WmzS055MEJWHapU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5981", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5981` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAZwlZrYHOtMaVD/3H3Rvg8BmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3NDdkNjg5LTRmZGEtNDI3MS1iODQ3LTYzZDlmNGIzNThhYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDEzYjg2NTItMzkz\nZC00MjJmLTgwNmEtMTkxMmNiNGRiODA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDUQHQBLTTOg+PCYMw4kDg1E3x7dlq4K+D4V0ZmC5wP+M7lQZXB6yfNxmmDWN\nGIpl4UuuxyUew3bYJ9PuU6aS9aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDvAE1sdSxvtfojA+eY6nU4/CIOQwHwYDVR0j\nBBgwFoAUDYgwOwWTfBgCHCVcIXJqDpje5AcwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCZ0aUa11tonPKAYiAd/zdOtQ88jrJXAHJejokzcv8SKAIh\nAOIwcsc8ScqMX6RVFMLnTgic+UZNsd0eZkpRocdMqg5b\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUJn0k+WewUAhISG4uXxEuXKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzQ3ZDY4OS00ZmRhLTQyNzEtYjg0Ny02M2Q5ZjRiMzU4YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIezMcA6wG/b7tItFNha2OIpPBTC/P2ECKyNEb9Ob2Y7SD\n/uPr0Z6CD2uxKZfu5GffbIpzdCB9a1Y0cXAnjWdso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDYgwOwWTfBgCHCVcIXJqDpje\n5AcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJaK6jtPrJS2ccDUloMJ19+pUIr31jQ5yRaI/MRz+ppGAiEA+W01zJd8\n6ex7lOxCBpNouVvsRl4UjHEOKARi81FMhn4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAdECUxLHWVqYfpYO1Ei1FRQPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDEzYjg2NTItMzkzZC00MjJmLTgwNmEtMTkxMmNiNGRiODA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4Nzc1MTk0\nNS1mYjE2LTRiZTItODc3ZC02MTZhZWU5OTcyZGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATbb+xUizOxNcqLFuTQY09RiW8J7YSes+DMFZl8c5NSdPaSoZaNYAzF\n8/GOETI8UvnHgZk3l8UflDJyZb7kp3oEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQO8ATW\nx1LG+1+iMD55jqdTj8Ig5DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCICth9xwIpTzG5rfJgzm02DruvNc0lhYbUNWaGgTXJ8ewAiALi8ulFeMyzIR6\n3GbjiAmy9p18jCFbwymhk3zsUwRvXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5982", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5982` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAetscifhbYHWvFYk4cU6Kq5QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzYzRjMTA3LTU1MDQtNDBkZS05NjJjLWY0NzRhYWVkNDUxNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDExNjk4NTItYzI2\nZC00NTExLThmMTEtNTg0ODI0ZGE4MDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc2RjeVm039flQxtZv8CPgxQqc0devtg6Tg1wH/EnhDEDqtWLTzfGCl/1pQkG\n543FenPkONh19Hjx+3XaxQ83haOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeEpy+ORRgIQ7tRPv19P1xiY+neswHwYDVR0j\nBBgwFoAUTnnCVSQQC20fIhNBJE6dpxmQ4GUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIEHC/5oxcT/ZMa1UdaFaBY/ipZmNeYH6IAOoF6CRvQ+FAiEA\n2mQRVQloNfHc1R9v9FaQfPO4Z2ZEgbCWPQ6wteRximk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT56b6MttGPtSy0fdFF4X48mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nM2M0YzEwNy01NTA0LTQwZGUtOTYyYy1mNDc0YWFlZDQ1MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOomKLB19xsDcm+84ZFT2GsOCVv3Z3/1sCOEBafC4KRfni\n8VDdgrxkEKydakKWRVynADEzQDSdaDilGwHMt5Yzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTnnCVSQQC20fIhNBJE6dpxmQ\n4GUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVtTAZNPVWV+F7sNyfSMNE5h9JkWhzQk0S+kRVSjTDiMCIQDVi0pivtaA\nydCe1ijzE8vSSuFtEE2FT1Msi13FffPC+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAYhMMeZXLMmXz1UfbJNDUz2TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDExNjk4NTItYzI2ZC00NTExLThmMTEtNTg0ODI0ZGE4MDE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMDJiZTky\nMy1kYjdhLTQzMDktODc2MC01YWFmZmJhYTFhOWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT5D3IotMHmbraPEqd2bYS3URDYKqtZWz+92vMS5AFS+SHqwl+xexzh\n6VLKboBsImkkPauXxKvsEaeSWs2CdL3Wo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4SnL4\n5FGAhDu1E+/X0/XGJj6d6zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIGL4ysxv9M46OmM2Ki4m6pMC9ddw6d9gtyIVb1QKPJwFAiBkxbKplz7IZUXg\nvVrPyQC4ORW+1fHxafogJjE8GQoOXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5983", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5983` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAcKeu3ABR/xwpnhv129uT+v3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyZTBhYTM3LWJiNDgtNDE0Zi05MjNmLWEyYjlhZWJiNDJhNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzFlZTVlN2EtMDVj\nMC00NjE5LTgxNzktY2QyZDIyMTZkMjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1ayMUDWS3ItyuUbpTgXqtG8GAvLRNYDsLkunfbM3ovi8HwDRR2pfbh6YgbZr\n2DK7zR4lmUnnqEWFbRO+kvAIuqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa/9U3GPgnzAt0RuTx0R3Dt3q8aYwHwYDVR0j\nBBgwFoAUX2h8UZhTNYxQJVo/mzM10k2an6EwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCID7oUWUyJYwA\n+GtDDhLoysRnDrN4G/p9YD/62Cq5CxEUAiBnGyJP620iGvDWD/YKuREFr4L6ycwD\ngmUIUYVzMtULCQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVyd1uZliiMyzzn9OiAhiyfsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmUwYWEzNy1iYjQ4LTQxNGYtOTIzZi1hMmI5YWViYjQyYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJC9/YNgfyL6KLJ2Sfm9joP7e9fB9OqRRwAo65LVdcGs5s\nNa/CvAL3FqQc/rwRhCvf5c6dJ+Gt9WpwqokN3jzIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX2h8UZhTNYxQJVo/mzM10k2a\nn6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALOxKuvIDs6faxnRcr3+VmPupFOjhtqXkzeYckeT4Op/AiEAqYpofHSG\n+FAU+ifNl6UFOCJyAb8OWN+MMkUHujKH+1M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAYgvegT7aEz/fX2Kg/Rkzr4XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzFlZTVlN2EtMDVjMC00NjE5LTgxNzktY2QyZDIyMTZkMjliMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMjg0Zjhk\nMy02OGJiLTRiMzUtODlmNi1iNjdjZmM0YTEzMzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7C/+Dura1eF7vy9nXPWWsfuNQs3oOh22ndA3msDr5xwNf3QlNxtXh\n4KfdZ6Dl1hZqoR/1jm0zD0twnJI85Omqo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRr/1Tc\nY+CfMC3RG5PHRHcO3erxpjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCWuDmcUB1b6HqFaKJc4GgWzYaut8QGGVjvuVJGMzGP3wIhAJLi9qEhwOhe\nJ31ir4AF2RhnqDNdf7uUeOU4JeI06O/8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5984", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5984` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAfvGayCNKEIFxxDGFc6AQYJ+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMmM1ZTEzLTQ2MzAtNDdhNC05ZjNlLWYyODM2NTg1MjkzOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQ0YzM1N2YtYTI5\nZi00Y2RhLWI0NTMtZjVlZDA0NmM3ZjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE89pWXtu/LnW1BM1gQKQx6CQAy1rmx8OvPStdXFbQowSwdeJ451WMfjL7Gc4j\nBqXd61Z/WaleM9lDS1Ey/dGS36OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUYeHQ0vR7Jtwwjjyydt2N0bfW6EwHwYDVR0j\nBBgwFoAUSoodK/Eqk6RBjh8U33Pc9WPEu1EwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgGQy6iaPmGmoLpHwDckHTWO4piXTuiG4s9rt1/R6yyogCIALT9mNs+Rx5\nsGbplamPNdywRCiA6I5wTJfW+17tm9dx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWwif2MXvCSfBMZkJ/iXbatHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTJjNWUxMy00NjMwLTQ3YTQtOWYzZS1mMjgzNjU4NTI5MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSx6+DtKy4EO9SVC3nOWW/pTSZ26BQhb85WTibMFklqdW1\nx7QZ/7DXx0NjXnfiunQS3cjY4YqFhGUczxfdGRuPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSoodK/Eqk6RBjh8U33Pc9WPE\nu1EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTJJJa4kLH/Aq6oL/W6g1S7cL+wxyGNX65pU+0tQ9UNwCIQD6f4gmOzMI\n4J/LzntA1E9aRjbibZ1rt56K2xksCavz3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAaQ/V++R8aqPEYSDFP27oxkyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQ0YzM1N2YtYTI5Zi00Y2RhLWI0NTMtZjVlZDA0NmM3ZjQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZDU4ZDM2\nMS04YWRjLTQyYWItOGQwZi04NTIzNzJmMWE4MTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASTwBDk6osdrzZUDma0ZIGMdhgt9vqfwP9wgN4R9Lk6QlzOQCPSOyc1\nMGTGQuTJ6OQn/6zg3obB4qrjdslhVqNSo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRRh4dD\nS9Hsm3DCOPLJ23Y3Rt9boTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIAbPOX2lhcKkpIfBOW0Jx1iSRS8V4YRMdHjSCFA2F85DAiEAuX9TXK2Hvcj6\ntmeOJFgW7wnAjNr8oy/Y/m3PYLhLem8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5985", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5985` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQwqEzMJua5Z4EeUAnOXkvMTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1YzI3ZGQ1LTY3MzAtNGMxOS04Mzg0LTY1OTZjOWRlN2E3OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDg4MzM2OWQtMzM3\nMy00YmM2LWJjNzctM2Y3MTJjYTk4ZjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9LfSzQ1V7TgKWOfh8kmxiruaNukhsHnkonGzb6JK3zXtTkfJatNBQKj7zZ51\nxoU6wdBWBXDPfTAxRqC/JPFTKqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZx6AGxuIZlsozz5cGsDotDlIaVcwHwYDVR0j\nBBgwFoAUrX3c98rweDuOwf70Hwi3i3mRwdowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgXk5fhe0FSOrGLXqtKhErLNhoSQ7+lHTXV7GoiA8kJAQCIQC1ihnsDhI0\n40hKgoHSS4jmeTD9zn41on1szzu3Fs1aCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQRBwAfrtGZwvx0diKpkGD3KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWMyN2RkNS02NzMwLTRjMTktODM4NC02NTk2YzlkZTdhNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEuSuKi+IzfCtsJLG/pMUqGMS4HXKolsMAC2vXoUhluBCx\nNNsPkcLzcJghmoC+I720UQ0/8p7ps3mvJe1WyPzno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrX3c98rweDuOwf70Hwi3i3mR\nwdowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeflnQgwwLWE3OZdSDlyqODH5na6UjHtKITj6DbgWzcwCIQCYoYUJaFs3\nJGAqx4bQmtqmjIXVTiNtIp39E2WYDTGj4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAYSEF6eMJsEkzoxQSy4ah786MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDg4MzM2OWQtMzM3My00YmM2LWJjNzctM2Y3MTJjYTk4ZjdiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMWIwNjAz\nZi01NGVhLTQyZWMtYWM3My02YmYyNGExMDMzYjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASjHEXUt+z0dxBecpAoog5jDx3diH+5cEaNkprCkA7zocSF+YRhA67B\n9hWSRi6W5NPBj3X22M1cyzrJLSR/wwT2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRnHoAb\nG4hmWyjPPlwawOi0OUhpVzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDVyR+450mRapa/ZbLEFr9Zusl3GnoFar9REU6q7TONeQIhAJDXoJ79Z/bU\npNvhbGtmnl5i1OtArpFshppjSegurguy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5986", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5986` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAVU7WG8gyBdjokchCgymBAftMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMjRiOGZjLWEwNGItNGFmMC1hZmNjLWE1YmFkMDYxMmQyYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE2Y2MzYTItMTk0\nMS00ZjM0LWJhMmQtMmNiOGExOGJmNjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9arCYqXeWicY3g8SyWndAl6CufjDNkse1KH4RuOnvN9w6p04K3cK1VIBcN59\nRkPzFU5jKJ8c78s7EoaRPcD326OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8YF7KhiQmICrwq3TvW2wwnSk1yowHwYDVR0j\nBBgwFoAUB7stpASTU0TS2WaD94CdJR/Q0CowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIEMKkG9+NQGH0GcOj03RRTlAH0WIL4xlNkDyj4qPsSlYAiBcmZGO4bod\nfPCFa8Hos/5Z7d8vUJmiaqzWAwiXdHkl6g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWka50ttwkYLKNRbbtB521CmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTI0YjhmYy1hMDRiLTRhZjAtYWZjYy1hNWJhZDA2MTJkMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6JFG+CV/G/zoRtgFSZGK3V1Nyltic+FLSmPlcS9Qwwbd8\nIVpnAeoSc5WVPIQ21JBO/soHiOqmrdhlpsPx6wj4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB7stpASTU0TS2WaD94CdJR/Q\n0CowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANsI5Z8B7YQ0VW1qtv5fulOL4W7kkRZOTP2PvJxFfLWFAiB0GHuuA7Pz\nT2aXXc01fG3CQV29oBx9ZubCG5i+tJl2Tw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAcFhoYz+RclaqLHRllCCbvndMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE2Y2MzYTItMTk0MS00ZjM0LWJhMmQtMmNiOGExOGJmNjAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNjRjODRi\nYS1iNWJhLTRjM2QtYmQ3Yi1hOTEzNDM1ZGMxMTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATjRH2Vi94VbbaYM0OuTrqMLTmVNqxUAK40GmRqtEwQE5I+7RDlpVzt\ntn6z1IEiQtDszxrFPxPfnvQBqBDZg4ulo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTxgXsq\nGJCYgKvCrdO9bbDCdKTXKjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQDXAlnYxiT6xnTusT+FCKNUqQVgPYKHTpk1D6n6RhpdkwIhAPxfkGSfa5GF\nhoyT3wPNBOBSpkAef0G4keVHR+i2gSgP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5987", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5987` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAV06hGu8sRNBuLftZkgae2EUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4ZjE0ZDBjLThkM2YtNGI2Mi1hOWZmLTkwZGU0ODNkYjAxMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE4OTgwMGMtOWM1\nZi00NWIwLTg5MzYtYjM1MDc3OWM4MTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnwPEQ0BZyFWMI/Df4+MHqu2depRUCZ1/TVMDhSC/lDK2bMvjLXJm59IwkR2T\nMhLRBORMc6VogeuhIlmAbJNAE6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVfjiNtTUbb3Ujinp0TGowbUtWGkwHwYDVR0j\nBBgwFoAULOigLrYIZ6BXVMRpMCeIB4IO6towRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIBpck1kmlYcLIATWamPys1lw3PEWmkepDD/Erozr\nIh9TAiEAkL1O+3fMn11Q+TCRuuBS/mWKMGdlD6MaCXgnCLMamqk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW6KXZ4H6M6eSfH7+LD/1hnjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGYxNGQwYy04ZDNmLTRiNjItYTlmZi05MGRlNDgzZGIwMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhDq6rzAOjyC5KEd3z9JUPpDBh2YsNGmcC9FyROw1xfcB0\nsoTY9afq2ZxLHO986OXwydURb4J5XeAY6SU0Fn2ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULOigLrYIZ6BXVMRpMCeIB4IO\n6towHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ3crJGxp3Qp/m5wNO+udJitSMRIx8XI1yb1v0Gn3fEMAiAA5eWEerwu\n8yQQELfVe5BfB0TuN68twp3cy35f0XgABA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAWdlI1T1bGoPLnVTB9cH088VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE4OTgwMGMtOWM1Zi00NWIwLTg5MzYtYjM1MDc3OWM4MTliMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZTc3NzFh\nNS1mYjExLTRjMDAtODdmYi1jNTQ4M2JjMzQxNTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9ixLTGhThOewlFs/j5svbZLm1sP9+fnFADgIGXrvYA3CQtGuYBfgZ\n05FoR07K85lUIt7+jJEGLn58W1Hp+62Ao2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRV+OI2\n1NRtvdSOKenRMajBtS1YaTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQC32OVLWrXiWMWWl8QgGLmxO36hdg9b8irLOBimHCE0fgIgToBw2GzxELKa\nkglcqVz3GaFem38AM0W2m5GVrSinBKw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5988", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5988` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAflNhmsEGQ30kaqq86NSRtzWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNjA0NDdjLWNhNDMtNDFiZi04ZTk4LWY0YThkYzkwMjI1ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM1MDJjOTctNTQy\nOS00MzE3LWIwNTktNDIyZmQzOThkZDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE33TgX2iAqlQ7ciLM55Z/9HabMoTMN/kX82TmrDdI0Fza3Botd5j/9RfPpl8X\n5RLKjGi/V/0ZaGFhBBrY+s2uL6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5UHHyaE10ksZJyVaC5uUmV4LOLcwHwYDVR0j\nBBgwFoAUg+vnJec7Zk2Wnh+OxNh4FAvuk3MwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCk5LGFdW0Kd1R5FwbxciitIYOO7aT5P2dBwzJ3\nhpeLTwIgayfkic4OPcoeLQ5yxGIX4SNU/Tfhn0lMNVW+oAiPrX8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXOJ9SYFBOQ+tsye5LavhDbNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTYwNDQ3Yy1jYTQzLTQxYmYtOGU5OC1mNGE4ZGM5MDIyNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATS3PV7Opv6xYYJPr1m335mlJCpXpG7INAAvtO81ShOuAJw\nLMksc5XNQy5DypuUkGjfyGeqix2mna2+A8glkbzWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg+vnJec7Zk2Wnh+OxNh4FAvu\nk3MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIqmKToj8k8YpXQix/3lu08ynstxHGwZrXDeh43sOph3AiEA+qUHmPY5\nNlIFd9p6qOEKwnJPpUAZ0UsaZDm8lKQqSgg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAQx9qnNJLA4okOIG4w+DYrN1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM1MDJjOTctNTQyOS00MzE3LWIwNTktNDIyZmQzOThkZDcyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YzJkYWY1\nOS02M2Q0LTQ0NjAtOGNiMS03YjFiNjNiZjA3ODcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATl7PhMqWzaZBRbtL6pMVcNN02i9XtiwZrr6b6b7N8atXTfwRaOXpeJ\nXimQ8MPI4xhfkvJLPHMrbIvY9bPI7bnio2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTlQcfJ\noTXSSxknJVoLm5SZXgs4tzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIA/DS+6zF3le0anBfvZwCzVHYLCiczmOFb+nJc5h4dgTAiB/nFLw7eyMIARc\npZOQSbs+uPoD+crtW1R54CCTBDZoSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5989", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5989` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAbc0oRinmG5aCwB5K6jaURP0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1NDU2MTY2LTUzNzQtNDEzOS1hMGZkLThiYTRlMzExNDMwNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI1MWFhOTgtNGZk\nMi00MmY2LWIwNGUtYmFlNzY0NWI5NjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEua+BGEK6qAyigcLAeKyes3rDQHXsThZp3iGXnGhvEMHalQTNHmUE6GxYhn21\nh141fN3kAUpyCByc6wjAHWn6J6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr8xeX0SuRlfAKsS7aFPvau+vLm0wHwYDVR0j\nBBgwFoAUsT0qC3OYqEUsSy3Fq1q6YfkxL6owPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCID+aP2IDytsGC9X8fJ/2ffm12X3Q2B5qV5tHtxrtOaRQAiBp\nin5aVheXb1KE7jyV2Vro4wAfSCnUTaCUSPog5gypeQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa8kKSUHYXsfZWTTbquRVNkGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTQ1NjE2Ni01Mzc0LTQxMzktYTBmZC04YmE0ZTMxMTQzMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQizRsLqKR1RgZvUDP3/fL6ovIevzXvg4Nbp9LteuiEh2Mo\nLazO70XZNzRLtz2MOwObm8vgz5oX4AGlHHnre7yuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsT0qC3OYqEUsSy3Fq1q6Yfkx\nL6owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHiEbmpIgZNTLxyr7djlxKOsdI28GlZcdjeJJyx4wdgcCIA8bWAxTmxNm\n2B5Fj+7zS0fzCuHY769B8sxdreaJ6IkF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAaP5Az87Es1f+GlSJzCbjVCmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI1MWFhOTgtNGZkMi00MmY2LWIwNGUtYmFlNzY0NWI5NjI1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYzQwYWM4\nZi01ZGE1LTQ4ZjctODI0MC0zYmMyNTU5NzVlZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQbAbUoIEJkSIyskxmAx7gYnp1UFgJWWFikmuLKYceThPHSuXTgfrC9\n6EItdhSQ3EjYK37LuZ7CZz0MUp5urlj0o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSvzF5f\nRK5GV8AqxLtoU+9q768ubTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIFJNuJK1XkmFLVopGSzjnRNqtTEuk5KnHNEmQ+yzwXdvAiAwDKc8NKSsTM2P\nXrInBl8hN0DbZfsiWKBG1SYJ1BZwTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5990", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5990` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAS7nS6nzk2Q2LwjPZ6vm++tqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiODFiNWQ0LWE0OWYtNGFiNC04M2U5LWFkYTU2MTAxNmJhMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgzYjcxY2ItNWZj\nMi00NGZmLTg2NjMtNDM3NjdiOTc4ZGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED7dQ6a7O/j5du2XLLO8evbW2Hcs3Qn8peJZDKf7s05hFAqexZv7yjsVqlixy\nbwjvcrNgvLgbeFfbNbGP4ZuFFKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVZB67fIu0YyykNsKBsfZrTYniVswHwYDVR0j\nBBgwFoAUoYgcCtDSIb4MT1I0GCpvxv5vingwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDVq0eViha7bGQDQ24tmIVd9TYrw5fl\nUhEtfCKg2iqMjAIhAJW4q3xZ8ID4YyrAIkJlNKEWebTUi5g9qUELRe9axg/C\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY1fRzpfAmYLFBVt5Ty3eXZAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjgxYjVkNC1hNDlmLTRhYjQtODNlOS1hZGE1NjEwMTZiYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBCwpXFhOLfspzHt2Sqrk672zdUks7awJf2fCQlGwlgbhO\nR/c2v4TkSL0C/gXbwl4s2XatdxlD5I4xRCPZYUQJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoYgcCtDSIb4MT1I0GCpvxv5v\ningwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXAwvGcVHV5i7R7maaD8AV4VC5GjqvOpupU5g4G5LXlYCIC2rlWvDm5mJ\nZKLUCUxtBnJMsYrU+jmGNnTmWnKe1zPN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAU67leejDVGV0wuA9nmoio7gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgzYjcxY2ItNWZjMi00NGZmLTg2NjMtNDM3NjdiOTc4ZGZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ODBlMTIz\nNi00NTI1LTQ0NzMtOWY3ZC04OTcxMTdmYjUxNzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQFLqoEetd9rrFOQxl7ELF4yKkvEKMCSZNWsOAJJABDJKOZ6+v8iMHE\nVWgtuxIQYDeF7FvG5uqb7aKrc10T2Onfo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVkHrt\n8i7RjLKQ2woGx9mtNieJWzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIFnZ+0joWf4nPBSeOMvv2j6XrGoKklkjz3kRJDjkk3u+AiEA+UwmFPrspJA4\nXU7x+ssa7vABy42gHuwb5QPavmpQ9+o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5991", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5991` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfxUPBvNwSXDmCp47n46xiHbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlOWJlZWUwLTg0YWMtNDNhMC04YTkxLWY5YzQ4NjA4MDc2OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NmZGIzNTYtMDI2\nNi00MDNmLTg2YjAtZDkxOGQ3YzM2ZjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEExqzPka8llBicETEimjRZs72EPBl/pJ3/LtXeIBSvnk5gQmNl440/swFCby\nEYjvGDbfm3+QEwsjf47NXPrWBqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU67Jg8O0YMavMIyZVsr64nr8sBFowHwYDVR0j\nBBgwFoAU06Zk5a1Oy1p1q8cb086aigk16qMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBy8X/kYXPtR5oUsZRtvPz68fZQc4B+i\nw+VoBoUP1xbRAiEAkYp7CnOChG0382w0BJHjrOQMQFE7ObXtGGyG+fub0GY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASdw5HjZHPRE+eNMqjOBzOBBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTliZWVlMC04NGFjLTQzYTAtOGE5MS1mOWM0ODYwODA3NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlM8sXP7xzClQw4YQZsFfOwEi5l4GJcbQmv+iFFG/8njs2\nVcQgMgkk6Mi820bPxrk9u6gXYzFqWcsWMvDYic6po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU06Zk5a1Oy1p1q8cb086aigk1\n6qMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP3N6C7onvEQCKZIF/uhnfrB5sLhR2XUvaJx0msgW9P5AiEAkYLYwjaT\nQ/LaT2D1xieTczXK/5PsZaQQEeKvFJPA5uo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAU8KakgP4mBR4BZYRgjwwzTvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NmZGIzNTYtMDI2Ni00MDNmLTg2YjAtZDkxOGQ3YzM2ZjE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ODk0ODk1\nYS1kMWJhLTRjYmItOTk3Ny0zOGJmY2IwNmI1YTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQQZTsO8bqrlnEmqjre22uzAZLo2zHk+Rl2PRv7zQ01Jaonp7Y3H2Kb\nKd1p2kNCMWvFztf58NBC2SYh9QzMXa3eo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTrsmDw\n7Rgxq8wjJlWyvrievywEWjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCO2bUQNN0tez+f7bnA5khvOX1wCGSiNGj4hGAH07r6pgIhAKM8Qfg+dZNs\ndsxFln0jJJP/gHSdp4aB+lCv3oHdO69K\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5992", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5992` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAQR26+mqI/W0sHMnuO29IPMLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhNzk5ZWUwLTJiMDQtNGU3NS04MTRlLTJiYWQ4YjE0Y2JmZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJlM2M0ZTItZTVk\nMS00N2VlLWEwNzEtN2MyZDIwMjBiNzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsGiV1NYOKJV/z35g9eeJTM6omvIhAhHL3mEHRFtjQGuOiwzZ8MnBiEpyLlaL\nqkAnhIfgBgcNF48HUN/zj56jb6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJdUbKDD1oErjKuZLbLa/SoNZuFUwHwYDVR0j\nBBgwFoAUjbb+Z3fQbdin0ubFG4craiB8Qn0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCZcyIWac/d\nqFEuz2hHohHoIhZKXp/pgkLfzDjfPlzbNAIhAPbJprzQavJUg437gOUTH3jGv7MP\nd0HGQ5DmyAC4rzqv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfKAEQw2XxD1Wx+naAkofgzcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTc5OWVlMC0yYjA0LTRlNzUtODE0ZS0yYmFkOGIxNGNiZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWdfimkbaaupS1OSiyf20bQnfEDnRQ8Qojioo6siK74wvi\nR9NzecvUW0KT18pRX0Ut6di8jwzWvA/8Cv7KDuglo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjbb+Z3fQbdin0ubFG4craiB8\nQn0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMwmAr3Qff+z6SMB6b3aR/LRHXsVK/vVL/gX33oVwb64CIFvNq8V5N9vI\nZ94q2qunyY+ACudIdQsl3zPYG5huXayW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAXuOapotI7qySP8Z76GWz1JjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJlM2M0ZTItZTVkMS00N2VlLWEwNzEtN2MyZDIwMjBiNzBlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNTRhMGYw\nYS0yY2M1LTRiYTktYmEyZC03ZDBjOTVkZDc1MmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQzzvyTQkWFvmLmXPMXdUKCD4fL3kpfnbbPqwbXIoAtLLtLToqMgBvR\nr0pc78Euhgol5qBrUwQtg0nQYVcixsgVo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQl1Rso\nMPWgSuMq5ktstr9Kg1m4VTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCICBnaNXsS0O7iCsPyzu19N9DWjHht6nrfnIA9J3EDA69AiEAqSMnj93p8Hbl\nP4djrzkEIZ7iQMv4RBL4wnGokhma0/c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5993", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5993` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAbpa483URVJpJrvDLGHg1SomMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3N2E1MTA0LWFjNTktNDJmOC05MGNlLTc2MWFkNjliYWE0NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI1YWE5OTItMGNl\nMC00NDIxLWFmYWYtZGY4MDkzNTNjNDQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER5bJi0D7irVuh6+uiISFSENsznYGF0YuLXJUDL3HlRSYhhg/2nsghCFF8LoZ\n91YLK9xtjpIS2XaUoHrom0Nk36OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsHwrw3+UYVjjqIri6C6setpP5X0wHwYDVR0j\nBBgwFoAUEA8bKNlWD7PzHcclID9wxGVJg60wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAMfR8rr60MU/jdAgQzjl7cuEILWCzbaGKoj49QUvTaGRAiEA8gK1ith1\nbejkN1QI46+g08iO+gRxdHkXyvpzyMeegko=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAczXrUJZUW6aUGjMTyIPTFbTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzdhNTEwNC1hYzU5LTQyZjgtOTBjZS03NjFhZDY5YmFhNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6fVGygtbkRg0wiUqfrCYr9gGQGE+7D4EWPjEQqrkdTbB/\nv44LBB/yLQC+3KT4uffqz+wqG5OpgxWgj0NolQggo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEA8bKNlWD7PzHcclID9wxGVJ\ng60wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJPORWH1DsBJ7iDcNnEwFSu3XJaJiSzcZRyteubFkV0HAiAsZkPJgbNA\nvzT9+y+lsE18vPlzTiYF1QVtUCyBhqP+MQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAReQ+yngKEa+lTx/eFMeeZ1tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI1YWE5OTItMGNlMC00NDIxLWFmYWYtZGY4MDkzNTNjNDQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMTgxMDVj\nMC05MzI1LTQ3MGUtOTA0ZC1iNDBlYmJhMThmNWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARxjuPILmNhf2zhDu952Nm0MgjvxzTJsHwe9UZubbW5EO4yOV1KOe4Y\nZUEUBAeQpStUaje4JHNyaPvjhRkfSL4wo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSwfCvD\nf5RhWOOoiuLoLqx62k/lfTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kA\nMEYCIQCyH1ddhZ1yZHCKCwMfsOPcpdo5AgERKJbIbLKtqqbniQIhAP/6it0ZIZFy\nKwVVpNICN0txpm5Twi5xc02ZEiuk6CFm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5994", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5994` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAf2ZTs8wVO2VESOWopqhw77UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNzU3MmZmLTU2MGItNDgzMi04YmJmLTFmYzllZGJlZTJmMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTAxNDE4OWEtZWNi\nMy00YTVkLWI2NmQtN2I2YWEwM2E2ZDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmkhhA5G/mlFshsdXTYX69XEApNSHtzER4eV3Uf0LGPSwokfIZtubEs9OV6fT\nICrDrIMWxAih/itnGq3WOymkvqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUegZjMuRs/tKTm/fVW2rYxgvaAW4wHwYDVR0j\nBBgwFoAUUrRVP7LBebPI5zIkFPYsv0+GsOYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJCxpy54bBMegPCqj7/waCQL2sDxiaJ/ko+cpoiTlBiLAiAR5tqkNRcW\nj8IJSsuZgfxdcvjuXLJ6mUR5ihJo28gLAQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQJjIpKiGhF782Z8Yb8YfQMcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTc1NzJmZi01NjBiLTQ4MzItOGJiZi0xZmM5ZWRiZWUyZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnxZKbJLbJS7+OhS28Ev0eiNIIaWblwtpMwZH1Y8EZCX/n\nhJY+JDtQMiZbYi1Z4G131jF5zpdbWmxy5bkJJtcTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUrRVP7LBebPI5zIkFPYsv0+G\nsOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgajmSujwlHrGvkUs2DqhKKC/AjCCT4LuTrstT4DhVNMACIQDO4EjgSRk9\nHoCiNyvtiUGnwY3ED94ZSB0DLsZ5BvBocg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISASYSvABDXrfbn69YQYlaHqugMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTAxNDE4OWEtZWNiMy00YTVkLWI2NmQtN2I2YWEwM2E2ZDZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiOGNlZmYw\nMS05YmVjLTQxMTMtYTNiZS0zNWJhZGZiZjEzYzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARDtr/ugekqQGK4gHDf/Jh/p/jBt/NNqKqd+p+O+7/Tfcr7SRX9QgSK\ndbWFm0fNTHH0UQzkNo5uBO1SpX5B8+RAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6BmMy\n5Gz+0pOb99VbatjGC9oBbjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIQDTDbBhc/K2SSRbblUiMB5C9CuGQpgYVnTK7sUfVWU+BwIgOSeyvXBVzhXf\nlr7Ygtu/LntO5EiZo1uyWbfOcUdvpyM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5995", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5995` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAf5IdiPNT7Zc/a+JPXvd79thMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmYWM4YTI0LTNhOTktNGVkOC1iMzhiLWM3MDU5OTk4OWU2YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZlNDNkNjUtZmY0\nZC00NjVkLWE0NzItNmRlNjMzNGUyMDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExRa2xbJMKrufW3u9+iLlyUlKc7VnDNalOT6RpCUuI5F0PoSN37JtK/5sXe2u\nuT9bMunQ5kGfDMghTxHJEzwzkKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Ax0ZdEcHAeMfJ3DpSJv+hmBMGAwHwYDVR0j\nBBgwFoAUYN3GbOPvFX2mnL8k7t7CY2Xx2aEwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIDdgocRDSy+9wUCw64A+F/GWBIaZ0yj+BeHJJbHj4BWIAiBI9jzFlbdX\nbsC01O8uHWQ18MXNg65T+49uyTadRLrQWQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWQz07uulGWDo898NsMO4YU+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmFjOGEyNC0zYTk5LTRlZDgtYjM4Yi1jNzA1OTk5ODllNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROLX1vYNx+c1k5W2suwnMJCbDTmBgMsMQw9L++lNNCbnxS\nDBWR/PBUBCBQYRnB92b7g517d0KxhgFfbAeeUD08o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYN3GbOPvFX2mnL8k7t7CY2Xx\n2aEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPTOmz0w9ljbFFsMYZqZ0oSVL4P1XRvsK1dcoqBqaaOeAiEAn2uq05BN\n44jKgfIvxgYtFUyuTwVyXKvFm85+X8B0VCA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAW8a7PmhQNX/N/e/tBiZqzwUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZlNDNkNjUtZmY0ZC00NjVkLWE0NzItNmRlNjMzNGUyMDE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3N2Y2NTE5\nOS1iYzU4LTQ2NzUtYmQxMy1jMjFmZWNmYTA4MWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATNWGvn6lCX34NHYrW/3OS6TZ0bn5qvGg3ffcagyF6P0uU/sEe4tzDv\nXzFWXq8ofYhWbnzpigxnq8cW4z2U2NvWo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTcDHRl\n0RwcB4x8ncOlIm/6GYEwYDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIEHoRG/8kNWvhGGBjE8vw8A4aNmtB4nChG2WpR/q3vIUAiEA3pwueBNZ8Ksn\nNDNaERpAcyuCCCDDqMO8Io5BMgWZ3LE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5996", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5996` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZbwgygDd4RibzGP+rvh76DAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3YjdhMjhhLTU1ZjktNGMwMy05ZDQyLTQwOTlmNzRkM2E3ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJiY2MxYWMtNjVl\nYS00OGViLTg3YzQtOWY1OGQ0YWU3NWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYKPO85CWTqFLyCfzW6dtZbGUKNC90rA9JbVF1tZwW9fcKExZHMHZ9MEFmvAp\ncfPCXYy3bnookyp7gmNQgsnE66OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdCYuc6QfXNJj1DSnqU7WfY/WGSIwHwYDVR0j\nBBgwFoAUxWgtOeC1c3ZrKy9q/4CInXK0SVowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDaxqd2e2sG7fxUiXypWuUZj/uk3U3ezKCNuz26\nrfXYOgIgIK9coMvVOkhtDs7PkU7Yws/0mNea2q67YkJQdRBlQ7s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcsJCvK3lB6g3s8RQnL0E/bcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2I3YTI4YS01NWY5LTRjMDMtOWQ0Mi00MDk5Zjc0ZDNhN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASISJ0Xaz0Y/ToUGp/xK55gqAtmX+gb7mG4MbniWHMqRvpJ\nMdBgp4DV1er0JS9Wfg5Vjc4FrHe32h2S1Z+XPopho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxWgtOeC1c3ZrKy9q/4CInXK0\nSVowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgarytQxVhHPa+FJVbJcGi+ymfbYQEoRnPwVI99dKdfC0CIDJsFZwVmk6T\nUYjm/49VU0Y/qGMAudaXMP8/nCvqPgs4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAY6TuZb75EoU1m8cTAlPSNHXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJiY2MxYWMtNjVlYS00OGViLTg3YzQtOWY1OGQ0YWU3NWI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYWQzMDI0\nMC03ZTk5LTQ5MjMtOGE0NS03ODYzNDc5NzM5OWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASGdQoD+W7qlL/6iqXNcijDn/YC5mJjA0wots9AF6uqZDhAR/DhHLzy\ninkDtwuK7zoZ17DrxNojE2ctIbs0XR6jo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0Ji5z\npB9c0mPUNKepTtZ9j9YZIjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIBjV+xmFOikINud7PizpLix6HPreD/pld7hjNIyKW2tWAiEAmVirGDxbk/kF\n4LGggpNK2sh3yWfVmEG+e10tilx+/As=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5997", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5997` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZHzeApIs3DZTTFnpeZAxCq8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3M2JhMjFmLTUyMmItNDZiNy1hN2JlLTk4MmZjYjBjNjFmYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZlNDkzMTktNGI4\nMS00YzM3LTkyMGUtZmU1ZTIwOTg1NmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPWCpN5i7Zo/t8DfUsWYlj3LHDIsXFN25yBgmAcIKG+WLcOixF26oimYnHzXy\nJO6RIvgxPoAo2kbXsexhTqsN/6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4HLGsHkisY1l0gkNj5/NkwbNnXwwHwYDVR0j\nBBgwFoAU5cRSjRvoV6/sNVq/bRTsLBV/wfIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGbUUuJLNa6OzLPLuogZs8JK/AOr/jEohq8S25/g\n9ohzAiEAl+BA0aSoG9wDezSwDlNAOBuJFRQMVG7qb0Fa0rfU1Js=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfVYyrVyc4dujroLjM5WUb72MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzNiYTIxZi01MjJiLTQ2YjctYTdiZS05ODJmY2IwYzYxZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARThCw3RQaCPsSMo++hAxYzbhDKcoJjV51N7oLGFN95xW9j\np0RJNiYcubAZK/GBUX9Jg4wq6eAqsh4Zoiuw5lfso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5cRSjRvoV6/sNVq/bRTsLBV/\nwfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXYMpfGZu6evyfLgeKacU4Dl/VywN8dDHR7se3viMWooCIQDJGf+mQRzK\nP8JBupBPvCmp0RGUT2abGnE7afmPWvD+HA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAYl2lIlbWY4iXuvetELVzGprMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZlNDkzMTktNGI4MS00YzM3LTkyMGUtZmU1ZTIwOTg1NmVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkY2Q1MDg2\nMi0yMmU2LTRkYjItYjBmNy1mMDYyNzhiMzI4OGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARX3i8OCYg6yOYRcjCF0uULsrVnX3IyFAIEdLh60zjtmmfV/lDaOze/\nasnEjYztV/FayjG5J/OG1YaZCR7/kTuto2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTgcsaw\neSKxjWXSCQ2Pn82TBs2dfDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCIAR87jEfNOz0k/6VUhySwIvSh44yLMwcz0RdJI4BQJwmAiEA+5C534QInZlb\nN8D07/3jcDjpWfBa458MmDc8RAbTRmY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5998", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5998` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAV0OA/CFTaumrNUJ+o4GXdP9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmNzBiZWQzLTViZjktNGJkNy04MGViLWYzN2JlZjUzNTE1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA5ZTAwOTQtNTAx\nNC00ZjYzLTkxYTktNTA1YzA5YmJkZmU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN4yUVpF0DO6gmvzhGHWBX1yLU3TbEj7Wkwoy76JlUH7rNuX9V/JtzCt4AzQO\n1b+h2By8El7Ng9eByslWpkerl6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/CqI7yGvLtYuBdi7JBqHRdmAO98wHwYDVR0j\nBBgwFoAUt/3zl4YJIhHJsWKa/N1oAmENhQswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQClUOs33EkJPxEXohBJ+s1ysMoa3tiDmf4Fl65Y1TTDjQIh\nAOwHtmnh8o1ctouZE3FnWapT4cXtemRNPWIeUCvM1wlg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfVREWO9jG+XWIVJtkZi59YFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjcwYmVkMy01YmY5LTRiZDctODBlYi1mMzdiZWY1MzUxNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZG0jieGbQevpzNhw48MF2WTBwxLqtM/KTbf8OLVqA4l0E\niFOt+zfJg/odOzwRdCqdAN2hREKJAQvCDuj+1KQAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt/3zl4YJIhHJsWKa/N1oAmEN\nhQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgASoVE3fP083A7yqT85sZbVBff3OzdudoyyuWqOMNF6YCIQCy9+s91+9N\nsAfmrW99EyfKsUlLIpFzxppuCNRxFhr6eg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAcP8M1ZfxbioHBZWbGHJH5KrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA5ZTAwOTQtNTAxNC00ZjYzLTkxYTktNTA1YzA5YmJkZmU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZDJhMDU5\nMC1iZWY5LTQ0MTQtODIzYS1iMjAwMDdhNDA0OTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT5FOog2BX4lVZw/NVC9kb/Kg4TP3RGgqtXQwanALxD2zP332ApDX2j\nB5mKZ79R5ThvrK863/lTUOH0PH25+FsYo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT8Kojv\nIa8u1i4F2LskGodF2YA73zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIFReehDgz+gXMxdkABExTZKS0FdwHkTMaBrjSADd1lUKAiAPvobJkaUM47/j\nO1nQYbWdhDtX0WCpkbCBYh0sGiOevg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc5999", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5999` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQN42OGX/VOsM/6bV6jZbnbcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5ZDI1ZmI4LTQyYzctNGNkZi05ZThiLTUxMDMyNjdlYTQ2MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThkMjFjZGMtMzdm\nMy00NGU5LWFjZTgtNjI4MTlkODc5NDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFP4t2l9vn5obR6a/LUVr7Dl2SOOXgcmQ/jXbBaz0DQ3ScB7rg/4mWENCUIf5\nZodAN61GOuR2h3b0pzAYhGsdNaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Wc6h0Rl5k2yxH7NA/pBJtUeGwMwHwYDVR0j\nBBgwFoAUfcOyOfHDBuno3yAjbF6q4VfAI0owSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIE+1UYyj70krG063CWWTD+7DCHO/jFV1\nshai13fMSbsAAiABou87OUANwLkiYf6n5PjpvXXg+pYDtYMTQODE8ljViQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARP2eg38yJ7+K8uA8JYo9Xa9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOWQyNWZiOC00MmM3LTRjZGYtOWU4Yi01MTAzMjY3ZWE0NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCFWYWjO6ZR4hZoPXKsyKfKTTrac+PFj280oGdq+o+p0rw\nbVbipoiUBG0Km2v1t3R9YeKGEZQKHFUYHgxmchkgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfcOyOfHDBuno3yAjbF6q4VfA\nI0owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCQcGDy4dmaR1rquEYFXiVBkwy6XGGPH3+rP5ddpvJzECIGbsutb7UmVn\n9wZ52QwdvBxR4oN6X8CKQajPlFuNCIrV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAZOjBSKZQIEgU2imuhBDjjP/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThkMjFjZGMtMzdmMy00NGU5LWFjZTgtNjI4MTlkODc5NDQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMDYyOWZj\nOC00MDZkLTRlMjgtYmQ0MS1lZTk5MTVhOTZhODkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQoMBFG8QFKlyaXeJq/sWMXaU1veMl0w+0O3gokN8u/KqFvvqrHZlSg\n9zwLpQIzCXUn3QxamcSbbyHrDMecsTVAo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVZzqH\nRGXmTbLEfs0D+kEm1R4bAzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cA\nMEQCIAxPHOiZDXIARGYDTF16cRItpsuBhelNfsjwCtESOk73AiAP+qQ2+WOhxLOt\noqF+HXNWAijgdyipNv7y6d/oJpVPNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6000", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6000` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAdDAg6LsII5HB/njV5S2IrQVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxMTMxZjk3LTU0YzYtNDYxNi05MTM2LWNhZTI0MWU0ODAxOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU2NDNmNGQtMzBm\nZi00ZDU2LTk0MGUtMDI4YjIxYzUzNjc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJNLzEUcT8zUwbnZG/pzb531s8hiZmiXTLXuwvCmcikqe9hJXnc5N2Nsmcp+u\n8zO5R141lM7BbAeslXL/GM35qaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWZkLCcP6o3STnfYQBn87/OIKl7swHwYDVR0j\nBBgwFoAUNFX/m8wMxc7Pyrl8nCF4friM8sgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGsaooS+GADVG6KTkz+Todh2N7UcgMmy\n6PfiDSj+g021AiA1msl5Y/b+zMb3rrctzBXXe2lZoY86zsMGaZ7yUJtq6g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVIAAJl7LQpO76BpQzax1NAbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTEzMWY5Ny01NGM2LTQ2MTYtOTEzNi1jYWUyNDFlNDgwMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQW30iVHR8ZR1dhtsrF/l8JNGBvc5hKg2ANsDtUmS5uafgU\nQxkaerMUR8/qWGduF7O0MRipCzdedUjXXJ4Qq47wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNFX/m8wMxc7Pyrl8nCF4friM\n8sgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRiI7jV9IuGA22+Y9zBPdRco9GNXhtzxxu9fK5H+G0qQCIQD4Dh11GVUj\nPZcJ0VGTrUfyQp404/mw9+Ok97YUed/O2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAXKo2Waah89Uov1xPRapSeVHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU2NDNmNGQtMzBmZi00ZDU2LTk0MGUtMDI4YjIxYzUzNjc0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2M2Q1NDZi\nMS01ZTk3LTQ3ZmUtOTU4MC1lMjJjOTkyN2RmZGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATh7ao5t0dh8nw19UAsFrQHd5e7cCoqnOJqRPNQ3YAsHaDddh/mIBUR\n65BtvJsiGkOkQeU4h9g7gLQ/DT8eVm16o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZmQsJ\nw/qjdJOd9hAGfzv84gqXuzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gA\nMEUCICwChzKoy0DaBuC1TKwD7nt4NXhoIi1tFXeS/JySpQE0AiEA0QdYMoadbXum\nzXkbpBQ3b9LHwweqHbCA/4+Z7vhZXY4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6001", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6001` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAau2/DdMLW8P/N2dEGdupIvyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzMTUxMmE4LTI1ZjctNDIxNS1hMTAzLWUyNjNlMjIyMGVjZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2EwY2IyNTMtYjVj\nYy00YTRmLWI0MTUtZmI2MjhjMzM0ZWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEllU8YQPFgzlpRpwY2uBZgqqeTUzFnouhoGVfG2FV/nEFZp5T4Ke5fNMU8kY2\n5TX3LeJZttnwzXskqU2AH11OZ6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFoWt1YhTHKLB8iQhulX566NnNw6MB8GA1UdIwQY\nMBaAFCndM0qL+Myh0BVvP19Sk0kFQoO+MAoGCCqGSM49BAMCA0gAMEUCIBdp944E\nSTa3BB7eYSezO+itLdfrjBG3cBlvI4HoYoSnAiEA1ucccOmXYCfPZNcapLPjQuGd\nMbS1/Qx9SFo0SZlvmuM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa+CG7L4mbvcjzArMV1SkLqsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzE1MTJhOC0yNWY3LTQyMTUtYTEwMy1lMjYzZTIyMjBlY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZ35Bp4ZTtRJMtM6eUg5ZVufjvlVOk/crCfyfKxHmH7BCX\nr+zY2pC8chHJygfpfZ5mppaDwkRtXANksxA4/pc5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKd0zSov4zKHQFW8/X1KTSQVC\ng74wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMyEvylLtjv+s7IAz/MFZuVcSz/TNVEyRs+/kpM8uwFCAiBuvD0nEAtr\nFiP+yV8Y3in44cp2ZI8DX4nW78OatfKQhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAdigjJupdNrWgJXuuhDgLqSTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2EwY2IyNTMtYjVjYy00YTRmLWI0MTUtZmI2MjhjMzM0ZWY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMmIwZjNi\nYy1hNjBjLTRjZjMtYWQ0Yy02Y2EzOTBmYmJjYzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS79p39+Z6YWxQxsT5C7OiF6zh6jnidyMUz8GnvmlJ+lFqtJNHNNzYy\nEl/Q1Z5/l1h+pSQllrlOFdWPjRCmT0FWo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRaFrdW\nIUxyiwfIkIbpV+eujZzcOjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIA5FMt7d7oPKUY5HXRNFoDQPk+WBO2IVlr3LZ1+wUSoMAiEAmfwcicPpGioC\n2DVkNwS0R0Gl9uZUf8qCG458I9iDBdE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6002", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6002` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdv1xiu+ZZsN8xvYbdNKaf3PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzZGZiZGRlLWU5YTgtNGU3NS05Y2Q2LWRmYmE4NTRkYmQzMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMzYTBlZDEtYmRl\nNC00OWUyLWJmOGQtZDdlMDY2OTllMzk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWUN/tpWEwBBf4O4lMuE1zV3XTWABKwg1bo9ShyUVUE/8xJr9i2Tch2mFutZO\nZeTB1CbwM7vyZAT+rKI3LP99taN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIU/osn59ILoMphMX9m5wnSnPYNQMB8GA1UdIwQY\nMBaAFLwXrZzj1+iqTRjxtQjYspsnZjIkMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAw6pQs/TouLt9CiiufPW/v3waIpEIyXcjD\nsHNlBJHbBgIhAKUIlxzCH3t+u7+wn4l/UlBTKaxfvcMiblH0zFq3pXrM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWl4YbZ3utuCgOh/F3amF/IFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nM2RmYmRkZS1lOWE4LTRlNzUtOWNkNi1kZmJhODU0ZGJkMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEWE5qhTkCyByiPAaZ+sUSKtktvYpm6mISzDpl2U2QzvM2\nzWPnYhyOdFsY29HeriSmzNN6MpJEEMx0GiCDZoGqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvBetnOPX6KpNGPG1CNiymydm\nMiQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMgF+hpUXDDANMxXbKqtc8qxWmxWI0wWgTH248Ae99WwAiEAjw8jtmFh\nGVMfkcySD56LxFT2tjV5vQNTp9mHJuPsuXM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISATJo/47JR++zXIhJceNbMVdrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMzYTBlZDEtYmRlNC00OWUyLWJmOGQtZDdlMDY2OTllMzk5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZjAyMDE5\nMC1jZjU2LTRkZDgtOTA5Ny1iM2FlMGFmOTQ1OWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATDbokkuV6emKsHxoB8misRLndiGB+Ywz2+vVLa/9GEWV9XleQ735Sf\nzbWVE3nf+piCho71GUB7MK3LMiTNkl8Do2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFP6LJ\n+fSC6DKYTF/ZucJ0pz2DUDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQC6AR8QIy2DiP5Udwvm8MNrsjlMS2e3PMVKp6OAvBoA+AIhAOinQaSAo/bi\nJp4wtGifOXvNY07r1GLc5iDW+FE26LVL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6003", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6003` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAWVtr1rioYkTN8NT8s9ARvS9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYWZiZGRkLTFhMzEtNDYyMC04N2FkLTFmYzIwOTM2MTE5ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY1OWJiZTMtZTc2\nYS00NmVmLWE1MjUtNTM2YzllMTgzMzRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETRLJDZvViBgLWqqxE/HkV1RoBJCCjM7DVg7jR+VxmijiZoBnqHtMi7H64+5M\n/ko5ejjqsg1DgyKQvvtfztKRgaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFE0yXcmR94aLmGPeyghCIaMKnSSYMB8GA1UdIwQY\nMBaAFL4bk4Yfvpu0M0FuCMuz/W5QHM/TMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAbPlRRgFerMpMV/CcVeTXhBZsnHD6cCaih\nL5mJqh13mQIgf3QZS3gLFd+CI8ZLNfSKGlQyL0DOWNQiP5+j7PmTiGg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVB25J/2VRDRcUjclrJUf/dWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmFmYmRkZC0xYTMxLTQ2MjAtODdhZC0xZmMyMDkzNjExOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSVtW35MtXt4hsvKho0/g7cxzDuVOPngYyBplhA2PU8l6b\nlUP6FneDlXXS2fqvvNSsu9r36Z+jnjg/gMo4fBdWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvhuThh++m7QzQW4Iy7P9blAc\nz9MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKctzxJKhKLgtevIsKOMPNHjPJB15C63FcXin4d5UZD7AiEArysCqHcw\nvL+q1D4GQlnEVcF2Zf15DKHSybxedIc74RE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAYdkFjUBYzu1OBpApIOevUThMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY1OWJiZTMtZTc2YS00NmVmLWE1MjUtNTM2YzllMTgzMzRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZDVhZmVk\nMC0zMTY4LTRjY2YtODc2Mi00YjBhOTBhMzNmNDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQjEZ+AwKv2jMt4TBgZugasL4rGVJBLiKt+J3zaajIwX4IqpkRBi5q9\nEn3plwV8Kygk8KmxjrdeE/eR14PzsOeCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNMl3J\nkfeGi5hj3soIQiGjCp0kmDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIAI5W3eAVAaQPFTTyGgj/bw1LrXCgbEwPE7haDmQruscAiEAv/Yw0BPwFCTE\nYMOoMjkk7EWKBkCrjXNv1AvIdyHvVJw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6004", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6004` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdxs1tiEzZT1spqMmiEyZ2kgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlODg2MTBjLWJjNDItNGUxZS1iYjc1LWJlYjU5ZmE4ZjBkYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA3MDhiNzgtN2I3\nMS00MjlmLWEzNTItYWE0MDkxN2U5ZjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnGg9gAfStzIbUHFd210wasLVnSiIwy2y+StRnmR/Cqp88yTi/zZJ++JGsXL8\nKxLBnEfY90fZILeJ9XRvqv7n66OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSQhINxZufVOuyIFN1BU3baexkl0DAfBgNVHSME\nGDAWgBRS1ua0BaElCbslyoLV0YCBM29EwjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDAJZAuCgr6vZ7QzAyzzFZCWB/C3C6q\n4xyWo7KRYtUZmgIgQP5aD1YwYlKv0ooMkvINzPeb8jvRpfE9sdGdzkzjTnM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe1YjdmVwN9Nmbcu1/RgIXtFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTg4NjEwYy1iYzQyLTRlMWUtYmI3NS1iZWI1OWZhOGYwZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiP4s5I1CG3zBv6z4GDdW5sHkn5YLxnOrwdFlA5BQmZ3Kt\nTgihHxfFztapoVs1tc4+FAKyl+3goAr/mCqpuPNeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUtbmtAWhJQm7JcqC1dGAgTNv\nRMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMOg85tp7ghs8UqrQAItFyTcb6GkNcRH4YJnANOX8iOeAiEAmQvACqZm\nOnkaO+SMUlmME0io6nci/ACd74qfY2n5838=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAcsbub398zVmUotnSjqO23dLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA3MDhiNzgtN2I3MS00MjlmLWEzNTItYWE0MDkxN2U5ZjIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YTE5OTcy\nZS1jY2MxLTQ4ZjUtYjk3MS0wZmVlZGQyYWEwMTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARowstylMTFbFhRboqqWI6/tulKzdmKTuqmnoU/dBIF2thYoL0wgMOQ\nCaTzuPQsF6lQDL6BVL2uGdtl8FZ2LVCio2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSQhINx\nZufVOuyIFN1BU3baexkl0DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCICHS4LBTWHCBdI3HpTFLE1aerRT8YlqTa7OYUfWIYswWAiBEtv4ct7mmHWiH\nZqNZ0QyS+/7A4zciaPPFySLrvkXrLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6005", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6005` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAZulvC/1vNrIARo/jJXoqcJDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzMGQ4OTU3LTAzMWUtNGYyNC1hNzk3LTU0ODVkNDljYjgwZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFkYTU5MDItOWIw\nYy00NmU4LWFkYWYtNTgyM2EwNmI1MzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyOJLfpW819KqIpO3E0PfLusSvpz/kvsKRViYmryDtJ63Vl5sz6f3P6gl0o2V\n6xZ2bhdqYTXB8uOxU9bFVKqX+KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWdUsj7FQtDOTpHP5VSziLk6M+dowHwYDVR0j\nBBgwFoAUddc/+cHVG7RzxaQ1eshMjGg6dYUwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEArYc1Al2it1Ir\nFOV37y8MDuVGTdeaJWcPYS/22pZYZRsCIQCXE9Ix7RzeR3uToA9DWyOjHqBc8Qmk\nnmnt5KIyS2UUtw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUUVZDzzUCkEGdtcwWgcuCZmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzBkODk1Ny0wMzFlLTRmMjQtYTc5Ny01NDg1ZDQ5Y2I4MGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeh/73dH8OH7WVmJdXFTfG+nPojxA2LVzlmPbj8ph9PQwH\nYnxeoxl8Phkz/MMwUjmdSF6FWc8HxVDxltNBcNQJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUddc/+cHVG7RzxaQ1eshMjGg6\ndYUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKT9iKCsZkcyWID17kTezhX4+ZwPkUztP0XqsmmxNGYLAiBRodmd5D2f\np+AmrpY2Lde7cHRa3NYrfTJk6RjY1UmWDQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAZJumNenISzcEZRjogcj/vNXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFkYTU5MDItOWIwYy00NmU4LWFkYWYtNTgyM2EwNmI1MzM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjN2I5NTRm\nNS0zMmJlLTQxZTAtOTlmMi03ODIxMDdlNWYxMzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASUnwFaNrEG/tRq7aX3c+3HrSyNFMOio0q+VGYiy51qL1GmgU/msAnG\npN/0ANcyOHRrWAR72oIVpmMtf7Lq5mSso2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZ1SyP\nsVC0M5Okc/lVLOIuToz52jAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDKdopMtmfMR8ogxwMaa41xlNQxDGC/rcvsAnlUseRllwIhAJ1gTSW4Y/uf\ndMtbUBnGgd2jgpQWK+I5ppaSGe04TT5e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6006", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6006` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZTioOaEECHJWqitXXSOxqzfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1YmRhZjRmLTRkOTctNGQzMS1hYWU4LTMyMGE4MTEyYzk3OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzMyODJiMTMtYTkz\nYi00ZWU5LWFiNGUtMWU1MmNkMWRmNzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfjBgOQBGAD7insK8sUNeyLMLWPOLqsTqebYNvKbsblMGP5AI0vztxaRZsFr1\no+hAGQAr9rfStjiqP3HQzAdw2aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw7TDr2cRu87fiWVNOisXdSwpcSAwHwYDVR0j\nBBgwFoAUSir08S/RVwuPJs1NGx3p4WJmFQ4wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB1CW/RHI1cVOWb\n3AcrFEbtI1/hEMmTXJ0Bno3fiL/zCgIhAN27JEgPfvARqcDI6TssxZRrqc1bxxj9\nP+Y+yd+936eH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbiNBbfkx44Nvh0YvN2mcM5vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWJkYWY0Zi00ZDk3LTRkMzEtYWFlOC0zMjBhODExMmM5NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQj+3vfbuqKq9ynik1mUaQHf95/16ruFQ+KqxN1EPdtxUgE\nlRaIhrheZZ4OqPu/F6w+By2jJx4BLwAQvFW5EeLDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSir08S/RVwuPJs1NGx3p4WJm\nFQ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD+JXh5gnj0e70fOqubUtMz4feoAMhmzS8F1reHB0fe0CIQDoy+NJyHTK\n1h8YhpAoe3rkhWJyy08ofVEAkJKI73YZdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAU9lA0D3TlGZcMa0uwh7Yf9kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzMyODJiMTMtYTkzYi00ZWU5LWFiNGUtMWU1MmNkMWRmNzVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMDVmN2Ey\nMC02ODAwLTRjOTctODZmOC0xNDk5ODMwODJhZDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARHeCpr8ST3FftpkeCSRhoEAbJfkJE5XGGy26PQib73+SIZtE2oLJkd\nAflqUo6HQxQawHq1mN/D5q7oMal0j0C4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDtMOv\nZxG7zt+JZU06Kxd1LClxIDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQC1VhZ/PpRQOX5I6/aOebxb+ADD9rgrZ2mFMmPsTH8qtgIgCtadjH6/DEaC\nSptw5V0PcPBmtpuIpsEXlz+E205Lji4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6007", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6007` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAYQyl5lqx01TJCqJeC/syl4lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMjVmMjQ4LTFmOTItNGVjOC05MzM2LTY5N2JmNjMxNzM0MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI5OWVjNGMtNDBi\nNS00NDliLWE2ZTEtODVjOTFlMjAyOWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1kEQUSBh4qlGFZqmWJRHd8LDhh11KMDOFu3bYc+Fq8821mNezfjpRnVVJGGU\nfIj0LX20UwdBfD4edwGcXWwwqaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd+nwo3PbcHybu3K+h0zzxm78bDUwHwYDVR0j\nBBgwFoAU+YT5DD7GImCKMPnISXJ3VxvGpX4wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA/lvxIVOtKFzIZ9y2UYCr\nw11GZoT+DB0F5l7ETXA9E0oCICWaSo3v+T5K5rsWot25jcCO2zN6F/ZJ0X7vrZWJ\nfVA0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdYC8aBKdz4e8npBhLdFA4CrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDI1ZjI0OC0xZjkyLTRlYzgtOTMzNi02OTdiZjYzMTczNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIkthGPbdEsl+q1HoKAqA5q9M7J/s/pUMRkj67K8rAIzST\n8igG/oBJkAfjuhrtg65ASYsreHhNN9t385SN228Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+YT5DD7GImCKMPnISXJ3VxvG\npX4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVtlRp/5bgfzQVLChotQ5uNKnYkMnMlpIyqE3FA5cyj8CIQD9CnxlQgCi\nzwV/V4NI7dphHPGb8Wiw7dWCq9wb1QydGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAbW7xrsAjLQ2hbijCrgJ4stUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI5OWVjNGMtNDBiNS00NDliLWE2ZTEtODVjOTFlMjAyOWYxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0YjgwYWVk\nNS1lYzRhLTRiOTItOWE1MC0yYmI1ODQ5OWNhNjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR4y9n5Oam83+loqw2gwTkxVFglIOcHOYS2uU+n1FZNT9AEcitEH81s\n6gD3rrEQz6IjtISy6oE2F/+lQLNIAbvuo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR36fCj\nc9twfJu7cr6HTPPGbvxsNTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDXDPx/noJrWyE9BKJsHv58SD+Z4VAh9Icl3Y+CMX28ngIgJcDge9ZrvDD7\no6O1XyVRFHCcTvTDQxTkdL6jJq5pjZo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6008", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6008` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAVGsME4WZOWOUSvvRA0Qh4NuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyOTIxMjAyLWJjMTgtNDdmYi1hMDA2LTc3OWI0MGJmNmFlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzE3NTM2NjgtYTYw\nZi00MzMxLWI3NGItNDk0MjFhYmNjY2FjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGqD8F0iX7zhNFO9Wyzpvugyb4WZstDXc65oAuvGXUb7QpITXK8XqZd5mDDQm\nWbSNU+RE2QTRZPYz964dsRdDXKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI6m0TkLitlzJHxyDas9LgU5KTnMwHwYDVR0j\nBBgwFoAUH3dnEyvTXlhrEirrA0VaFlj+aF8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiA2F23t\nbxt/2cInm8zFa/MyeEZbJ+ylFRQ5/knvlRNptAIhALmdM9OCfToFG6rlWYFIrK5i\njIDb9V21aUFPq14Uh+9s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb+FvRM+KnLvFDEnlYbB63MHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjkyMTIwMi1iYzE4LTQ3ZmItYTAwNi03NzliNDBiZjZhZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0G59eiRbDvV8tap/N5142NsJHverrsShaSmxDrUwlIcF0\nUk81Xcu/DItpU0MPgEBjD95GzHU9I1Zrp5ekMwbBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH3dnEyvTXlhrEirrA0VaFlj+\naF8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK8XWlF0hDzqqXesrIkFFrCi5mHSNFRhue8VEY+nqem5AiB8bftOfPk6\nuYVgIICCBvpdepKiNtyDvJFuQSX4SxQPNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAQ4OyKFgSbF5y2ZpRnAFbQArMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzE3NTM2NjgtYTYwZi00MzMxLWI3NGItNDk0MjFhYmNjY2FjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNjg1NzRl\nZC1hMWFhLTRiMDktOWZmNS0zMTJiMmY0MjRkMGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASZ6CxaxJ4NfLkc/UT84ICqnO29O3MG3YcLQC6wmhZjG19REq8F/xTh\n8GIKghtpzmsZlwo3gYWCbpecxAvhflAYo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQjqbRO\nQuK2XMkfHINqz0uBTkpOczAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQD33pm/vze3gricI2UQ//jYMAyZ8MHb231Qc03yEPeVYQIhAKSaBAR2Ebyd\nhe1S7PYjz1MVHUVWzBkXfGDx+8PBJ1iF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6009", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6009` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAVK/M3mvfzOdcHsD0AKU5LX3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5YzMzZGY3LTc3MDktNDcxNC04MTE1LTRlNjIxMzQyN2MyMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhiMjdlMzUtOTg2\nNS00ZTliLWFkMjUtYjNiMTFkZmUzZTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ2j3LS93gW2BAQ6sizM/htfgkoYDR0pXHlao6y1+3hDzHyNBz1/6sMbf5gqT\nj2r7jYi5kuLV2s72OBxuxetCFKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQYvLp1vc7kcL8Ww1g8LE1LK/kyswHwYDVR0j\nBBgwFoAUfPIsG82Vv03jsaEegBGtb+c/1uIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA3Gr9\nX7qwori2f3ACGfgO4vN1u4TQiDhqJFEb6B0bkjYCIQDRqPBMDXknY4UPPZ0/CIhK\n2adahkA5KQ+MUVaAawhycg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAax6Kuwi1+TWZQKb6FmNURKUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWMzM2RmNy03NzA5LTQ3MTQtODExNS00ZTYyMTM0MjdjMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOFNI3aJJLQlLk3PndXCscQHSRhqrt7JwPmCiAJa1zgbWf\n7w3PfnhZcJsuBaR8AlmAhYuu9Mqpb+5n9oyNdV+to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfPIsG82Vv03jsaEegBGtb+c/\n1uIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOH0eu1cqclw7ssosqEpDGAIORnMdvRcRoIq0rOrSMUgAiEAuzyaK7Cd\nk0VFYcXD0i1T42JJEzXzYtCsyyHCsA9GVPk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAVc0tRpxaWs3IyE01wXmLMFJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhiMjdlMzUtOTg2NS00ZTliLWFkMjUtYjNiMTFkZmUzZTRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YWYzNjY0\nYS0yYTNiLTQ1NzYtOTIyZi1hZTc3YjlmYzViNjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR0kKHY+/uxTQeL3nkGQ5oWVO7lZW+t+Iw5iWvs/JmwawKlWeLR6brP\nuSWIi40gPTFrUW5IdIEOireFbthOhdvUo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBi8un\nW9zuRwvxbDWDwsTUsr+TKzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCICa4V7ygHm009CP+/CcgnI79ILovJLhLw/FjF6AffthIAiAncI+wx5s0Sn39\npOFu7UvnV8oXTSPJ914aT/qG4YSYCg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6010", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6010` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdyzCw4K9P8tUkMWdvRqE6LmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlYWY1MTQxLTMwYjEtNDE0MC04ZDA0LWU1MzhjNjU3NDE3OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODEzOTMyMmItZjJh\nMi00MmU0LTgwNDctNjU2NmQyMmYyMjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuWdV/Ct52hLShL6NWsqm7EMTtI5IT7e0qVnQT5EutdqligOmRYh94ZhdAUoj\n029AOwu0HU1IBQQ09bu/Dm+x3qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDOKlBq8C6CoVXtJ9/Tcxk6EuJ5tMB8GA1UdIwQY\nMBaAFP4aQr0Ipux21omsXJPTqJ4lnPKcMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA862BKu6YrCv6lKGmu5HwSDK4IA+t3lDY\nfEcwC36JE0wCIA67ZEuYD15RFCBU8XZXDdSj+NA5cw7Z0MeP5o8OZbRe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYc2aeCUU7SVv7U2UHqrVtHDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWFmNTE0MS0zMGIxLTQxNDAtOGQwNC1lNTM4YzY1NzQxNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScaUwSzepV6R+Tk5twwXwiVfDn1eSmKsPvudKx/tuLocDH\nOhub4ZUYWUTQcomZ+NX34iXrSNoiZPfsbocY58NPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/hpCvQim7HbWiaxck9OoniWc\n8pwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIkifwwLcfTb4QMkezM11colIUpX2ixotH2A5h2vqJnvAiAYfO+TJ3D9\nLmAuQcQNIfQlmapHmS0sqphGk6ap2Z/bqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAU9lP7/Q51GXduJtmyZJ/kvOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODEzOTMyMmItZjJhMi00MmU0LTgwNDctNjU2NmQyMmYyMjY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NDM3NzA1\nZS1lNzQ5LTRkMDQtOTUyMS1iMDgzODEwZDdlMTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATWSWO3qeFQdNEMxfEkQS+5e2MBrNti9lscdyw1rjMTLyQiUNNf/N3J\nWTV7bxAscEvPgiMNPTbAiF+oaYpUazgko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzipQa\nvAugqFV7Sff03MZOhLiebTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIA4TSstoCGFfJfK4/DdpnMjnkBEy+brYBluzgwu3f2JGAiBLYPrRK0bt1luV\n+APsLFKTUGCYj3GLb9ipA0+/h7xfSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6011", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6011` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbTgypcDfV3eUpM0Nsjam6aiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzOTZiMTc4LTM3M2YtNDUxOS04ZWQ5LWYwNDA5NDk1YTc1ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjIwZTEzYWMtZGJm\nMi00ZTMzLWIwOGMtNzNjNDQ1NzVkYjg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW9uQoejqkD+fLZ8tBbm3QSUhOWifJTXPpqRdnBQL0bFFkQCm8t7H/j/4t9Qp\nvZcf+U691CPXPf0HaTN4mvIFcKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBd1y3Pd9qHk7utGuukknZzJs5XIwHwYDVR0j\nBBgwFoAUd8gQY1vbMLaPnv6mLMXdEBl9EogwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKQjz0SreQ0d3\nystwjmqmdbfH2tZPJBausk2MQx/h0/YCIQCtWVmzL71ia89FURvc6Hg/fa+ADAbx\ndQ785SV1z8v4RQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASs2/jTDd3GAf/SepRJOKFrsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzk2YjE3OC0zNzNmLTQ1MTktOGVkOS1mMDQwOTQ5NWE3NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbedAO2T51WtF1ghw7lYgBp73y7lapMMWBTK8MqIpsqafb\n1hcaYlnY1x4Bu9cb+AXS9Vl884SD0EsgIg3rYDgso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd8gQY1vbMLaPnv6mLMXdEBl9\nEogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOON1dHQ43V3s9cFSAfbwQsPKyqQyQcXhCQtPO3BMrJJAiBEWC/KdMuw\n0b53jA0oaPY6BHU4XpzrDm6ME5sEgUWHFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAVcIFHJg1SJP4RSMV4nwy6iiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjIwZTEzYWMtZGJmMi00ZTMzLWIwOGMtNzNjNDQ1NzVkYjg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZjViYjM0\nMi03NjMwLTQ5MDgtYTRmMS0xYjJjOWJkMmM2ZWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARTFlqJ0PEFHQlhGbouhTDBd4tP/5WuMpb9GtMx7y2lQ3Dsw8De6Gtl\nZwKT9it9VSbcG24DUQY3n8ettdFLArtWo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQF3XLc\n932oeTu60a66SSdnMmzlcjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQD/glruqtc7SnWN4kJLadcwVWIux8xgmDZclmds+Id3xAIgGmE1CEI99k5I\npqYpscJ2KtJd64J0L7arzOBx84JHi8g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6012", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6012` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAdlT6vIv0yX2IingdQdAoS4dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYjg4MDM2LWI1MjYtNDViOC1hMTJkLTE1YzZhNWI1Mjc4YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJiOGYwYzktMjZm\nOC00Y2IwLWI1MmItZDc5NjhlNWU3NGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF0hBf2KzU68DFY3ENdudHRpKPG32DvxVyJDXg8a7e13J6gAMB/9NJpRjnMiw\nu7WwDSIL2lt0al60314BsxcRQKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDNMW1N5r399k8J/TNEGq9kpiVQMwHwYDVR0j\nBBgwFoAU7Nok64T9RBZA4xMc2k+yMGCBDq8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgTKEXHQJxiGld\nw+Vvcs3aM+ubI0DADSGfv0neGbSyfWYCIHxLreEKjgJxqYWAfFzL6Woj7dDRSfEB\nPD0tD90z42Ag\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeSvgcslD+U6O5zcMfxDC7P/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmI4ODAzNi1iNTI2LTQ1YjgtYTEyZC0xNWM2YTViNTI3OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiMEmUSIQPYGRI+Jy/uQM4IMtZWKdPNnpHhO9+pi6Vkm0K\n2gYIy3ESTp7Mx6EIQcAVUdfBeYmDLqTLZzzlI0X6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Nok64T9RBZA4xMc2k+yMGCB\nDq8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPh32kuGzi8UpqALDsX3G+CVkU+XxBMFagWTCu5ePZ6QCIEOhbth/3G6d\ndYRaNqydfbHJ9Ilc7gF9iMjFrXPGsWY1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAXSdoA/ucAZS14xxVKIE5NqaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJiOGYwYzktMjZmOC00Y2IwLWI1MmItZDc5NjhlNWU3NGQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2OGQ4ZjQ0\nNy0xN2E4LTQ2OTktYWYwZS00NGNmYWY1MjFiM2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARHgXNA5AvepgKY6ej6HbHCTTa1Bjb5Kd91zLCtZsb2b5wgSNrwZ313\n6RwsaXXbYYZBwqcg7ccdbnvXGH1SHtC2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQM0xbU\n3mvf32Twn9M0Qar2SmJVAzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIFJX9gCffMU6tN4/t7PistabbRfWYwDf/kYq23MOg+ojAiAbea2Gq7WCF0W0\nEZrcIQBRKI6Q1MHuVM4zeLE7Li9ILA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6013", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6013` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISARHeMVZ1MCSNbcTgAXNJPpB0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjYzEwNzNhLTU2NDUtNGE4NS1hMGRkLTZlZThiNGUxMTk5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I0ZGM4ZmUtNmRi\nMi00Yjk2LTkwNTUtMWUxNDE1YWRiOWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMIoYqa56jjSo7ckXZBB4D+PI59l9okoKzOrj05/kfyjaViB022VM/TihHQNx\nS4gUz/Nudmu2HRsqnEgEj1PN+6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU06WO1SQiq+KQFuDK7bQoTWSWY7MwHwYDVR0j\nBBgwFoAU2XEyIuAZWUrtS6bklckuLgeecxgwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIG/RU8dThoXP\nvJrQwcSV+Akv4pIjpmsA0EVMSIP05HnVAiBP9i7m57oX682ahmv0GG5yvQxmEAIT\nQzDTNmYUSrkDMg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfRnTKVq+s4m54CCtoy9pnB1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2MxMDczYS01NjQ1LTRhODUtYTBkZC02ZWU4YjRlMTE5OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARf1aCt0ZQMrIJhHLs1Iawculh0wyHqVVBTTyseCgGE2PNE\n6I+VeDPfcygIilk3hYO7WkMcndafMANndddZA/lKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2XEyIuAZWUrtS6bklckuLgee\ncxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQgM/0lt2MCj5WpvEPZpQepSWzzaHKBqx1wtJkufyDHwCIDCy+iKlXnFe\n+Y38teXs/9wRHYeZKyS7CmmqiZAnvujQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAe6TwC0G8yfpkx6jq9JcQzffMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I0ZGM4ZmUtNmRiMi00Yjk2LTkwNTUtMWUxNDE1YWRiOWJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZTg3ZWIy\nOS02NThlLTQxZDItOWY4OC1mNzhkY2YzNjNjZjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATGRZ22i/D5eUoCY6Ujmac7IUn7uRO/xScAvlJ053R1spmhPARUv+mN\njLl4PqnCjv/NVor0kiyOIm+gRmgKcdfRo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTTpY7V\nJCKr4pAW4MrttChNZJZjszAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIEUGD2GE/AaQbh2ct/cDH+duhjE4itLze/DoSuzg+E7iAiEA2SCmPfshJPzh\neRq0eo6OTP6VL/OyVYDYbG8yH87n8Ps=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6014", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6014` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfaps1ehxnbBIhInkmxShq7xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyNGVkMTYwLWRiN2UtNDkxYy1iNTAyLTI0NzNjMzZjNGZiYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTIyMjRiZjMtZjBl\nYy00MmQxLTg4ZmYtZTk0ZmIwNWU5OTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESra1KN7ZJs/35TMBUIGbs9nQrR+isJApWqiC4QXWRN817GM5+J1qyte/Z1qS\n6R7whNuvz2yvZXFQYMYBxhPAVKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTS8hx6KcsZ0IqJzkFjXc+rg8MnYwHwYDVR0j\nBBgwFoAUW6bq7GcSSDBBjSoDa3AKG5DnSk8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHoT7eVLIWd/xBCjvnXvKq9vnc9qUPvT8j4QAKaUF6O4AiEA/+aI2EBr1bKr\n9hxd4KqWsE6U0YzmVJHfN0DG1VpMGRU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ+JIAiYwJdJhSl3brbuZ2YSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjRlZDE2MC1kYjdlLTQ5MWMtYjUwMi0yNDczYzM2YzRmYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR78xrPRWQm5D+DERIL1YmopVJzlUBX7JEwGGLM1uaFk2yH\nrxIiomuYmPfgX61Fs86vkX8iNYSAzOxEeAMSY6gao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW6bq7GcSSDBBjSoDa3AKG5Dn\nSk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdZft++1fxDW/RsGcinAHCLueVw3yergXDRfWQATdzAwCIQC9KfDFFu6W\n7ODmlasGkLZNJ/xrpEqkBRIClxnmznS1Gg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAXNJ/HXNDFpwBosRNFOrQhzJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTIyMjRiZjMtZjBlYy00MmQxLTg4ZmYtZTk0ZmIwNWU5OTJkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NTA4MWRm\nNC02NTdmLTRhMjgtOGU4Mi04ZDVmYzA3NDExZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAThb/GloYLhluduclDEaDNqjB5hQKn5mMQkbuy9CsFQv9TN1zg+TUkM\nnH+GsbYiZfCdt3oXggOk0o6+HmjT77xho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNLyHH\nopyxnQionOQWNdz6uDwydjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIGQYUO+buCjKciv+l3qGVqxOYNn/DtDL5i1wiMb17+0CAiEAgGzWv2njTkcQ\nGMCgUgXr2PqCbiSmlkisOQY4fZkZ278=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6015", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6015` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAaGydjaiNm0v39VhhEePOKaTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5ODRhYTA5LTc3NDQtNDYwOS05MzBmLTI4NGM2ZDM3ZjQ1NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTEzNjI3ZDctMjlj\nYS00ODYyLThhOGUtNTk1MDU4MjVmZGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPmYdapO0i/dmme3lk9c/614ciEkpc3gkuH8rOO/w7Alfe+hM9iQegqx2tQHv\n38iOewT+CrdBn6kwki55xRcHo6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+PKh8tMssVBz+9RQ3ffIlV8UJ6cwHwYDVR0j\nBBgwFoAUfPrvoAVF6CDIDwKxQ1Fk8yZKBL4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHN7xTAkKI/BC+n0VNb5Xv9HjQjrcp1dKyXsJQSoLgxVAiBHugoxsms1YGXp\nKViw9BvPBDRKhplYZDAtIi+E3yObUg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcaPGZn2I+mMD3wMzpgJUyZ/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTg0YWEwOS03NzQ0LTQ2MDktOTMwZi0yODRjNmQzN2Y0NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR46p7zJUPh0VdW5z5a6vv3Ku73eHP6DDNJleyBBHxqtZQ8\nMqyD+EjtNofuYS81zY9D8OMgeVKXm6pi6juOSS+Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfPrvoAVF6CDIDwKxQ1Fk8yZK\nBL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANmW5kCG1xbXsXgvbyTj6zo5AaoBl7R0YcVCWoorqlNcAiEA8OpXMnyo\nDtvt7stfr+vyY/76vWJTKv+4F2D4zcvLbDg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAZkilhaWB5o1y1QYweX7k1zvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTEzNjI3ZDctMjljYS00ODYyLThhOGUtNTk1MDU4MjVmZGQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OWQ5MmU3\nZi1hNGJkLTQ1ZGEtYTUxYi0xZDRlNmEyOWVlOGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATp4EBmnfX1iL2qudhiRKw3TDg8/q9IJnnpAvlNHrZfq6EkGXi43ZHO\nUA1zQyUAE0/7LXw5uoQ4FisyPDWbRyC/o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT48qHy\n0yyxUHP71FDd98iVXxQnpzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIBt/Ni99fdllYQ8OXPubL9S5oMVh/yoc9rZaTSv9buIkAiAdkAPjH1hZo2+b\nLREPL5D9EKrWz4spmjqiqxNdlaZxFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6016", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6016` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAeUy6TjvMXaz4KA0MCuJ47oPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZGRkOWFiLTQ0ZTMtNDU5Zi05M2VhLTA5ODMwYzhjMTFhZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmI5YTNjYWMtOWUw\nYi00ZGQ4LWExNWEtY2RkYzI2MjUyOWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE19BEMHqAr8ZZTLDlKbn14Gf8NSCwtbusbjpT8STbpmwPneu9rCa12KK24059\n5AQGXdOzr+PQTzZLL5vmdVBaFaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf4NRUhuMhbB+bakYjB3O73xg/SIwHwYDVR0j\nBBgwFoAUBOonIaXa18QvBquJ3RdLjB7lhSswLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFa1\nFWsSM49pm0PdrJ7QMnt2qN7vz/DpHutD2dY0A2/KAiEA8avoesVagBan+eSyHuvc\n9Ws5gLntYmiBngZfFJ7Hrj8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAddXuGgnw+lrdzG7ToxMW8jnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmRkZDlhYi00NGUzLTQ1OWYtOTNlYS0wOTgzMGM4YzExYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGnzNd+q54TBgUVMJH/ppvxRWXSucQ4hsr39cogCm0oae3\nsybD/LyepBNWq/XYBqZFWf1F/JutoWhC3N2XXxs9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBOonIaXa18QvBquJ3RdLjB7l\nhSswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSfvjQO3IyBZK+QC7M0VS8+sPq5R5QwNPErDtXrM1bTICIFc8x7rQirN+\nuRYmBVoMXLEya/f+6aICOygfFPIJPGyQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAZu/uFPtLNXEGqpxIiVT+fqFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmI5YTNjYWMtOWUwYi00ZGQ4LWExNWEtY2RkYzI2MjUyOWU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMTNmNGJj\nNi03YjIyLTQ4NDktYjg3ZC00NmZlYTYxZmVkMzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQg0ow/necasyJF/9GOui03C76VcChf+b/AXMRmPb6kEZ5cHAl7RUpK\nW+tIivZEkzrniHl5lTnN7rrKJjxV+Tb0o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/g1FS\nG4yFsH5tqRiMHc7vfGD9IjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDfyjzLnCp9QNPhHvqiBbW1BqklS///7IFBy8Oe5OI4nQIhANlpPNUOGSj9\nyY6gqryWdBZAKmw/q3Hm1AVY8/bHqxys\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6017", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6017` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAR258dbZ3uoNPoNACv8NQ9VQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1ODNjYzJhLThhYWUtNGZiZi04MDQ1LWE2ZjRjNjM5Zjc2OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI3ODRiMDctN2U0\nNC00MmQ2LTk5MDUtYjRlNzkzMTJlOWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKKL1GjSQ0ts+LY5wL4iD6CZr6u+Lmzd8T+PtNLSJ31j1/pi2SvbMMEMVLx5f\nRfH/P6BLeSqpJ5UdQ4GRSELW3qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhcyFmf4oR1xadd7DCcOZZvnG7iswHwYDVR0j\nBBgwFoAU182kXgIhB8J1S+gxFBD46//pdn4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC6bYKVHSYE/VUxHHm7+tR3vISH7eMTLS318mASp4EUXgIhAJ/j\nEXcDMxJCkW1acC9+M21WlhQHVAwmrbeyRHDZHT0V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWQjTHikC7WIGCjOkO8n2JF/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTgzY2MyYS04YWFlLTRmYmYtODA0NS1hNmY0YzYzOWY3NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbSAY3+xZ1P5FLq4MeUYgL/AVprELTRiLzabhDYWi8K3zo\n4ZtpIgKkmt0ePDFwuiT/ftmCzun33BAm3s62GOUQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU182kXgIhB8J1S+gxFBD46//p\ndn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAICroeGGWhgnEOFd8HrBPX0gr71oTiUMXIYeETG31q+yAiBUWLAMEkNf\nbfyomKw4sOvtdTvqVjrSP/iPcUAjWOq+cw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAcR4B+mZTkGbW9DxXCG3tR8gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI3ODRiMDctN2U0NC00MmQ2LTk5MDUtYjRlNzkzMTJlOWUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZWRkMjYw\nZi00N2RlLTQ0NzMtYWQ4ZC0zMWM2ODEzOGZhZWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARj0aZSUI7XhFV5F17v5+uO0k/6omZ3hFEDmvmobMIy775AkozfZRDV\nw776R75Oi5jOXIhVRv9TsFr0dwopzIe5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFzIWZ\n/ihHXFp13sMJw5lm+cbuKzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIDTjUgNwD4TULgix9nvKazbeBmnmjLTIBsmUI8JOf9stAiBxk5SrzrtO+ow3\nqIfd8s5s7pn3h6+EFfIt8NSAlxzlvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6018", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6018` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAUfEeP2x4KUKbt+Blef/w2EMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhMDZlNmFmLWYwYzItNDU3Ni1iNDk0LWFjMjgzOTI1ZDliZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTczNDc0NjgtZmQw\nZi00ZmQxLTliMWMtMWJmYTA2OTU1MTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnnE+Ic6+qw/6c0oEoq26tR1f24nX3BDi2t5ptl98HBQJyhQo494wi+x4b5Ty\nLas+WHF8kUgB1a1mKzpxehWvtqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Z9vS72FoVXA2XTzGhaKwdCEDhEwHwYDVR0j\nBBgwFoAUnojOupPmrrHcqBdfPfowXCSZkoMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGJ91POC5hzdQZ5uIdg9aher/+CyyZZc/IlX2H2SWuc8AiBCHCA9\n97lU0j7za8ztBZoMy4JeOFMx3PpQFVbL446V/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV0+txmIQAs7g7AhSnUrcePpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTA2ZTZhZi1mMGMyLTQ1NzYtYjQ5NC1hYzI4MzkyNWQ5YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4ftPLpMq74rGTfnMquG7NvKzm0JEZw7+3+c0HcgAB0imA\n8y4/gMVCOompCy0QoTWdFTfuRJScoz4eluD2misYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnojOupPmrrHcqBdfPfowXCSZ\nkoMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOphxslxB0stJDqkVCo+0+nwpQzmOW/gaJvwowHswk6UCIQCjFLCqjBHS\n3rOFZ21KIa7yipdVY6+HtBW2W66nVRFhhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAThde1rC6xTJFDUpigsyXCm5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTczNDc0NjgtZmQwZi00ZmQxLTliMWMtMWJmYTA2OTU1MTU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMTUzOTdl\nZi1kZGYwLTQzZmItODU0Ny0xMTU0OGI0NTIwNGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARX8jdIdBrlym/bfRgZnklPhMQ6V3H+RmxFy5vyxmM6hNLY7sfqjWPc\nTUiY2RXSomFOPOma9SsWfUAOiaGoNLA2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTpn29L\nvYWhVcDZdPMaForB0IQOETAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIAUZbjBsx1tvB4YISluBU1h0sjSL9lXl7/mcLy3IErnPAiEAuDPeiFDR5hdu\nWY1hWTFoWy3GxIzmmYbS/8AU1oQ9F/U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6019", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6019` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAdxK9BrLpa3GaSSl7jufTZfCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4ZjAwOWJmLWY0ZjAtNDUwMi05ODU2LTViMDlhZmRjNWFjODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q2ZmRhYTYtNzcw\nNC00OGIyLThhN2YtNGJhY2U1NmQxNWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0XUyOqSkWG7elLkcNrMQLek3TaWQws9gPPjka4j5eQV+8Ng3TXUXiYMc0pnC\nmBSh4Oylf0+c6Yc3x9KdL7zM16N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAgKFtBj7BxQhTDIx4WU+uFnprG2MB8GA1UdIwQY\nMBaAFOAW6oLJr+nxg4Yik995qSdjoaGCMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA0ZwRtHfRc56mD3CZOhZ5SrcbIQLr21OXs\nr3Azg0MfawIgGcpp5FIL5XGgYuQKENdUSTJoaN8ao7BSRX9ryKkORUU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATgf/pHL3jkhjnfIGpV+dFLBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOGYwMDliZi1mNGYwLTQ1MDItOTg1Ni01YjA5YWZkYzVhYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkk7uy4O0ixYQORqW2n7k5IXGOF2peRuXLQM+oaetcwwLi\npk0ugRsi3VULbzKwYvPfX0PAE/fzaeh3yBjwuf18o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Bbqgsmv6fGDhiKT33mpJ2Oh\noYIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge90nMY8IylOCewJl6u41VKeBWhKiwydLV8T4+2KIqJwCIFvc1i5R7we7\nSFjdDXJ94YyS3aITbQM+22PkRHGOlOtb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAR2SZZE2/3K1BC/oZ6AG43b9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q2ZmRhYTYtNzcwNC00OGIyLThhN2YtNGJhY2U1NmQxNWVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNDEyYjRj\nNS0wNWUyLTQwNjMtYWE2ZC04NTFhYmQ1OWFmOWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9Dc6Kq9652ZQrWNh9vxjUYoKro6ueC9D4LgwF7TrI785Hsj+OCL4T\nvivem5GMrDG0iKUCN0NCLPt3YGBPxld3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQIChbQ\nY+wcUIUwyMeFlPrhZ6axtjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIA+9ZfltEtsFOsWC5EjeGVwnyhcE96W/fUs0qQmgGdBaAiEA3Ypx1ybVHuHE\n6cteiVsWJ1LCM/MKBsh8QwkD17wdc4U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6020", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6020` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAX/xpJSDSF3Od1sPUAhqx/ZLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0ZTkxNzg4LTczYjMtNDg2ZS05YWNiLWIwMDhhZTM3ZjA4ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQ5OWUyM2UtOTZk\nNC00NjdhLWJjMGUtMzU1YzVkMzBjNWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmm5JkCcypZ4VKZhrKMoPsfuysf9bb1B/hRfDkpUDzLviPwdjaiDpnnypOAzn\nYjQGl/F5rq7oKLv2gVjPUC3roqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY/J87WdWLKIPkFMwn0bsk/Ot4RQwHwYDVR0j\nBBgwFoAURCl4fYw19R8L9Z/mfJeiV57i6yAwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgQwD1ElCNIdtR\nXWsIj6TrN8Oc0MWH3KSqnrvlmyBZYeoCIDI4Pv3Gb3JopUmJad+fACBaaWNVabAU\nhXpytjn49ng6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZeL51wUbAS7bYdj6FHRVm2yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGU5MTc4OC03M2IzLTQ4NmUtOWFjYi1iMDA4YWUzN2YwODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxjTVlIu047HPWCQNhvyeuzl6/mSFHILKEjl4IijZdP8Uo\npDyG7BdRna1b574/0LWh3vpZO64K2wbN3HLHocDfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURCl4fYw19R8L9Z/mfJeiV57i\n6yAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX4WPyu+W+diz9OxwY5/JGPOkFwxBSgTnKFMYa1K+d9YCIQDjw/aeSchO\nMzK0pXueCGEo0WY0UtYhsjkLnKRQJXk9Zg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAWq5xua+hsPIarhlcrpqBtNhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQ5OWUyM2UtOTZkNC00NjdhLWJjMGUtMzU1YzVkMzBjNWYxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NWY3MjQx\nNC00YTI4LTQ3ODYtOGZhMC1iOTlhODQ5NTNlN2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARIOlR64s0rxQe/rptIeOGweXdRC4+xwnZHtZa1pD9ZN2gdJOfEYBUQ\nAAHtIQKPfbHNFcVmWaUxdMqfbaIhA1Xmo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRj8nzt\nZ1Ysog+QUzCfRuyT863hFDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIAQi/8yAzMkObUNAXIiQLdWRsJzXuEVYx2dRTifnG6tTAiBtjQFVDd+T1+j8\nFDJs6KUmMc3j0s1h1yuDZHwBfl1tRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6021", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6021` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAfM3KTXagIUtB9V5mEb1IamSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiMmQwOWY3LWM0MDUtNDc4Yi04YzMzLTFlYmE5MjY2ZTI1YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y5YjIwMTktMTNj\nMS00OTcwLWI5MDEtZDFlYWM2YTQyZjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtvcWVZTJjdP0VblxiKKpSc67EU9TgmGFkXyBk+zVYtqyUl4xsDcTw3C7QtDJ\neqtBVP2EHgpuqRAmUGLwC2LvKqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ/KixAJMYERiGuO+RSnZbToV13IwHwYDVR0j\nBBgwFoAUg24Pg7ktYZT42yNS1uz1ENmAFaEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOyr84NBdAU4\nqOLzzrt6tN99r/3DhU9EumUNjnPxrHg6AiAqWZK35DzUnFIpvYNRikARxwLfpOBW\n5bY7iCY/itRlCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcr73OI1QOQWGrRg8453mSxAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjJkMDlmNy1jNDA1LTQ3OGItOGMzMy0xZWJhOTI2NmUyNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjZAvGAt70sRU5lCdri2Lt9TQdA1OCEqaKekNa6VzYeK1f\n+7V50OtNg+qsBiJonV1+HTcTOjj9Sc76Rd5Fgq0fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg24Pg7ktYZT42yNS1uz1ENmA\nFaEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOGv3faJsWhlizK8oMEpxJYQuwoyg30fhiE3vmlAEc8PAiEA3OH73bh4\nR7O9iJ/YYTTGnQjrs2ZkHOB/0FCUzBTwo/o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAaoUxpSPnYLKz2WrTiBIQHOCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y5YjIwMTktMTNjMS00OTcwLWI5MDEtZDFlYWM2YTQyZjQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZTM0NjFh\nYi03NjZmLTRkZjQtYTNlOS0xYzgxMjNmMTlkOTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASay9z476Hh1fN7M0+qV6sHN5se1T/hahKFCMqb1WsCVqW/cZ2v2D22\n22ai/RK5WG+nLPJZBkiBQQ1BagEm3tiDo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRn8qLE\nAkxgRGIa475FKdltOhXXcjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDhbIDkEuJfo1ZrxX3WLQCOzOeU3+Nptlld6qCBrmxDSgIhALO2BxAzTH8+\n/2Nkf0ahBhw27wbD3zeSoktmXkudA5DW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6022", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6022` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISARqG9sKRNU6aIEK169NTXIPyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkM2NkM2ZiLWNkZWUtNGVkNS1hM2IwLWUxYWMxZjc5YjJhZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAwMjFiNzYtMzdl\nNy00ZmQ3LTkwOTQtY2EzMTBmNTc3NDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDTDJ8ENcEKUAeF7KSjdpfcoZZc9HKme3sXHwOoax2DdCznhgpovHF6T9PgzG\nMotUsIPLdRoUxextwaD7MXSaCaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk6sOyCy0ZSuWLSRLSFIGtbB7AMkwHwYDVR0j\nBBgwFoAUJCdxs1LyFnfsfF+EmEmQSeOudnowKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDcE3IllMXM\noP/3Mqq2ky7vIRVqNcYqX/m6hNMXYkmpRgIhAN/qhcMgJdo54qfusNMZuEaIGzQf\nU02jXCJpSelPB+HO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW8QEUurnnAkMeAiRA6AFP/xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDNjZDNmYi1jZGVlLTRlZDUtYTNiMC1lMWFjMWY3OWIyYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxk6N1rVtQZFVed9nh2q8vpGutqiwB3Kgdd7oLD+BeYib1\n7ief0JYhL06qrZSM4p+9o06O9OfAGcqQ+67JBpHAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJCdxs1LyFnfsfF+EmEmQSeOu\ndnowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRJRscJOsD0Vms1CaWwCAYJfH334BueQAvnX7XR6ZNnICIDiPXjoX1fC2\njxaErNzD5H+E2/0Bn9kUEzipUfM33qfk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAbQoYPAQIJ7T2w2nbop4JxFvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAwMjFiNzYtMzdlNy00ZmQ3LTkwOTQtY2EzMTBmNTc3NDU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NzVjZTJk\nYS1kNGZhLTQ2MjEtYTQ2MS1lNmM3ZDFkNDJlZWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT2xqoYORpPJuNJNPRkR21LazxeigGeD++RcZwCMLWOETZmj3WwQz3b\nl9tH3GIAptrzPWCGpPnXSt3Pu9TSQ6D+o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSTqw7I\nLLRlK5YtJEtIUga1sHsAyTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCvTbTpU3GSjd02Xv1Tiyiz8PBhcSlFhVmngJrZo5L18AIhANI1R73PNcd+\nmU/2jvn9G3bZngEZr3nNTYMub08fschi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6023", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6023` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAV9IrB9QJ7E2jrEcBj2DJxXfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2ZmNiNDI0LWM4YjMtNGIyYS1iMGI2LTU0YTdjNjI0ZDgzZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIyOTMwYzgtMzMz\nNy00NzNiLWJmZjgtNDI4YzZlOWEwOTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+bZYIW6oZWgbmqBr6MN1dRfcbbnWBPJl3hD0KJe39kNtBsCbQ/VhgjFwG5Py\nuduT2qLEjLiB41KRI7EwChOVHKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeGPXGCJxjsiajFE7wKviV3bu/JYwHwYDVR0j\nBBgwFoAUMhwxBBscL0NdzecRcQfQKJ/sBw8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDGwHMSdC28hsMW36VZ/4UkT40JUkoPBauFN+Buy8X3pQIgdH+fiTYREhZV\n05c2CpNuB69FYAVil7ZPcItShvRXkKo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASrOgj8hLPR4CNg1YOSThZZdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNmZjYjQyNC1jOGIzLTRiMmEtYjBiNi01NGE3YzYyNGQ4M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATe55HYffr66z6tY8EQvi/sh8N3Lwecch1aY4wUhMpzHm+Z\noIkVAaZ8dgkg0/doe89cvzbWtmkrht4JHLMUF2Fro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMhwxBBscL0NdzecRcQfQKJ/s\nBw8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJfN2FsuCrGCwc3Roouemn9DZXpKRyWPrFS5+CRIiuJUAiEAsMYjN/J0\nOFrjwK9T7LefR3HLNaIfUlV6AQ/b/eNKwyc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAdXDAXQsyPBuqf+oTKVgFiRiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIyOTMwYzgtMzMzNy00NzNiLWJmZjgtNDI4YzZlOWEwOTkwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OTliNWQ5\nYi0xODQzLTRjNjgtOTg4Mi00Njg1ZDZjOWEzMjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATT1dqOl1JzXJzplD4Xxty6OVefHH02+rH+gOPCAIY7yxlqpBUC4sJy\n2U1n2FKPDiQdU1AEZFUblVvWTEn2NDOuo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4Y9cY\nInGOyJqMUTvAq+JXdu78ljAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIC3yOxI6096to3sihDYW0neCZA5lxicS6H/JK0rEKMeHAiA4SO1eTKsoNHtC\nwAnjkDNPyLwXLO3uV7PLacvquyFcmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6024", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6024` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAa+n7orrKJecVxGtT8IFLKk2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4ZWIzNzYxLTRjMGUtNGMwYi1iMTY1LTBlZTgzYjIwYTVmYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQyNGIxNTAtMjVk\nMC00MjU4LTk4YmQtNmE3MWQ2NTFmYjgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEijAfqUZvB42rZAfop2PQJ8CmVosZYrniQgtFZ3tCteY06zsp+/MTgJl4zTnr\nZ6JXIgUTdgWygSuTzYnLGRsht6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUze1AAJ835ur4T4LrPr5IsLV6i18wHwYDVR0j\nBBgwFoAUwYV1CfINxeFOp054Vo36qWw5DhYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDYNJLAOxEfzhkh3jCRudEuFkggPi4/7KjMvvxy/vV2ewIgHstWtZ04TO+H\n17zS5pfUSEw7VW4Y1m/qqPqxvWoXIBE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATpb7MVqy0ZvCtunBKyTp9NZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGViMzc2MS00YzBlLTRjMGItYjE2NS0wZWU4M2IyMGE1ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4xPWwQXV9Kp4US8YFaZtfgdYjIZSjqkYrcZqvcKUX7r9b\n1c3X+fZMJLmEoPai4mp+19MOvHRDl9gpH0Ft6IYFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwYV1CfINxeFOp054Vo36qWw5\nDhYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIYoA1rxx7di0Se1s4aLKh+Enwc98nMPdMT+bcVB1djAAiASJanuIK4N\nydCf5P21g2UIZaDs2mgaYuf3mdEoP5RvgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAcw1Nzp2q0GktUlVPLn+OxSAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQyNGIxNTAtMjVkMC00MjU4LTk4YmQtNmE3MWQ2NTFmYjgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNjA0ZThj\nYy0xYTEzLTRkMDgtYTRhMi1iMmZkYTZhMjdlMGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASBJX9FI5rAXMXiAM+/2IFq1koJNKRVjmdkH/TZ48aPETzRb//4oPqE\nvb9q2PQlV6X2GKX6LOMSbmBXIi+AL0Xdo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTN7UAA\nnzfm6vhPgus+vkiwtXqLXzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIC6OkYY0CnXbkPoZdCkwm1vkZjSRUaLKMn+uukHgCCEwAiAT89E4O421JB0t\ntMqgPGLaQbWhu3KrxRH6C1/V8hzMsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6025", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6025` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAaem+Se3FedbzVO5kS0U80lVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMTUyOTUyLWJhY2EtNDNjMC1hNmMzLTYyMWFjMmI5ZjdhOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIzZTY5N2ItYzBm\nOS00Y2Y1LWIxNDktNjcwOGZmZWQ3NjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9zTJvR+LEnF4X63iHTfbdp2EXKjF5l3U5tPBIpRr+gO4JiJyFIQKdGAVa41m\nN27LU/lr+KKUJKpfttiYJyMVPKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURkXig6Iecp5iJHBdFEtrwZlv2uAwHwYDVR0j\nBBgwFoAUsn49mS5dP2zggRhhA5nfe1yRSb0wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDS\n3940YIWy1bl1r+cf5GbDKWTWCYl7laGLQKA3By7k6wIgHnDoaIv1KXD/Zh9eTPvG\nxlclGMmDT0gbNfrTRAr8nBs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWymAxiiy0jAbceCC9o6QZ8CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDE1Mjk1Mi1iYWNhLTQzYzAtYTZjMy02MjFhYzJiOWY3YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvAxrNTD+jAp47H0QD/IXq92vVmZ4+KEpiMy4PE0k6bxBG\ni4xsPj+lNQM7z9eQVCe5l0zLeNc16yUM2jSVZcpeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsn49mS5dP2zggRhhA5nfe1yR\nSb0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOT+KTmfZceO3JvSsbegvCVH+rl1SqiOciqgU0USxGnfAiBVZXZFU3Ir\ncPWpQAg+ncEfcd6KMKOZImt7j3y38TJrDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISARNNM24ugcf8m27V0MWLUI85MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIzZTY5N2ItYzBmOS00Y2Y1LWIxNDktNjcwOGZmZWQ3NjU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MWMzMDRj\nMi03MTE1LTRlNDgtYmNkNy1jMzI4OTFmMDhhMDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARGIDrt9RfU8bpsjGKprMOOYs8MZC9n133mzADha0FscrJ7A4oLCssR\nxtX0vxDQkDLXdnzXDrbzru9UafyRYLmzo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGReKD\noh5ynmIkcF0US2vBmW/a4DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIGw1pLM2/OdXMQM57YP9MDzOhLJxCbagf48nUYbeh3w5AiEAtFvtORl6qE4n\nKuNHf30RDqwrLvqUaTzs/QahvaqZ43Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6026", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6026` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAYRJ8R7yOyvCC4ONVIcu30IRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4OWJjNTZkLTdhZGEtNDgzYS05NmRjLTBjNTAyMzE1ZDQ5NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA0ZDA5NzgtNjkz\nMS00ZDQwLWE4YzItNGE4OGQ1YWE1OGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEogAtPidsDBy52n4HdpJ8FMpkAN5eIPdaBgvhO4//DVxA+iF5Xp3Qbdboc0Os\nl5ILiOTnI2xPUqDDvI2Ar5ayfaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy/UvcdmwZZdyB2cMsvxUidSe6AwwHwYDVR0j\nBBgwFoAUsJBHIBOD8O/b0ztyAMwd1lZslk8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGd9VWmxt1IFfh3Bov06j8ACLxGjundh7nI1pUy1PdmeAiBzyt8n\nOScTysmbG1L3NUlcrBikHVfW1/xxsvMaAYLE+w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ9r3/CEjD6qJyN1QArm+rrVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODliYzU2ZC03YWRhLTQ4M2EtOTZkYy0wYzUwMjMxNWQ0OTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHbM4AWEMoNP0Q3f7z3HxfNdJ87LZVQzkoI43Ss2u+YkuN\n05VnAZ3epfeHrnE2xa5oQ0OwPn0R09nqKKftqpLBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsJBHIBOD8O/b0ztyAMwd1lZs\nlk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSaWLxak9mxZrnL8OrTZshyaUohFroQQf2DcoiAl+9+gCICQh2kxGRNDG\ns7NvOR/erUoQPFDZUyj9fNZCqO40NxPs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAVgch4BbA4PZ057+xCPZpF7HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA0ZDA5NzgtNjkzMS00ZDQwLWE4YzItNGE4OGQ1YWE1OGNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNjkwMzhj\nYy1iZTc0LTRhYmEtYTdjYS0yNjA1YzVjMWYzNGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ83YQsoF/2iUHzzA/k1z1Db2w75w9DiUAKGeXUslbRgvf9OPjFBmcf\nNh0cPTL8vygydEZiucutftZLkQ3BFa+yo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTL9S9x\n2bBll3IHZwyy/FSJ1J7oDDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIHJ02UFtIYT0jC3o+yk8YJja9D/oC0SH3vD6mo57wb7RAiEAhBF3Sgrtz83e\n/02eoHstpdXsqUR9KxBaeKN15vscEMg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6027", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6027` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAbxu1FUD5L4hw+zwMzYNEVDhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxZmM1NDU1LWUyYzgtNGNlZS1iYjRkLTVkZjZiZjU5Nzk5YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA1ZGZkMWMtN2U0\nMi00ZjliLTgzYjAtZWVhNjJlZjFmMTBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb7CeQPYb0w9WIrQ065PT4mLUv4BGVf+1UIaeATdTrM607EvUWV0AbyOzU/M0\nBeK3RK08hZieEWCcYwysL+vUrqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO7mLhOaTjjKAP8fRvDtUTkkB2sIwHwYDVR0j\nBBgwFoAUVGmPTI3D26znsKWQT7Oq//Hha/EwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBY8drxeBr5SgC8jIB2o45N2YSZw3nITdEpKeH5NQOE1AiEA+b17\npXZV+nsmRDkfVMyMRBX9kU0iol/TUs49t/FzumU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUw7HnEnYd4me6cAhEh/HDWoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWZjNTQ1NS1lMmM4LTRjZWUtYmI0ZC01ZGY2YmY1OTc5OWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUUvG7UTc/TABjRou+OdZS7i/jPPHtJKQ0aGIWa/x4hvJd\ng7bVult6fBOhyQp7Jz3mzViQxkhlMub4APS0hxnco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVGmPTI3D26znsKWQT7Oq//Hh\na/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVxs7q+lEraNbSU+syPTQT8eZrT4CxzHmraf63LOoDpICIQCrq2gQIlm7\nH33GnbrWVcz3OSqJpjL5TzrZOEof/SKoJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAbr5kWH40x3ypkDti25Rqm5pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA1ZGZkMWMtN2U0Mi00ZjliLTgzYjAtZWVhNjJlZjFmMTBkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MzNlZjZm\nYy04NjhlLTRkOTQtYTM4Zi01YTE0N2ZlZGZkYmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARNGDXZkVcCPZhYbMbIBfGLPxSnueBmdg9uh5CLwnr4Y5iDYxgKZneS\n7D0VOlF03z++K3fOdrl1kxEAoc7URGnuo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ7uYuE\n5pOOMoA/x9G8O1ROSQHawjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIBHVEvkrg3FHxkvlrmqqIJiwblpbg959B/1AwvzZ0lbaAiB3BA2DXDvXxMOA\nabqKV8iOZrzz4MtXG4MQyNBTrpQsaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6028", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6028` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAUb6vQejpQ4TzvAwrobgeCwOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjZTRkNGI1LTRjYTgtNDNjZC05YmQ5LTFiYTRiNGJiNjljOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ0YzBiOGItM2Rm\nMy00ZDllLThkNmYtMjczODQwYTI0MmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsTIONN/daJlFCPctYyl14L7kxFs+d4lsIgrIdjP8YvIhVVhHuYgZbsMTD6HR\nTLJWiSix7UlsenOULlNgztlnGKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQLKDrGcs3PWG/QMfbxQBaTmhFHqTAfBgNVHSME\nGDAWgBTtf5Z4m7woC9/6n81X2T1GuJudDTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAO3xx72xEgMv0CQWmebcVA0SkZFj65G\nO7JhzKNz+DMmAiAgJ2Ngez7y5PJNt++Waq3YvqRXLpbvjJ1l2rHb2FZ/Ng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXyML36geuUygwRwC6ROtKybMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2U0ZDRiNS00Y2E4LTQzY2QtOWJkOS0xYmE0YjRiYjY5YzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrJN9QOGlvZ9w3M23CXfGb25AUubBpgpVhsGaLIkZhbdcx\nYOOkRwas4Q00Lqk68+tmcXYVmR42+acCnnUANBsTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7X+WeJu8KAvf+p/NV9k9Rrib\nnQ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaDol009DHkLZ692fE2CpvQSxw4eRbqMCdey/L7SBS4wCIQCIMZXvDSHn\nCO2hIJn50DP4q6MlqTpEAQwv1y40TqTfjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISASpyQerOgOaUjpaJ5+6JQMbWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ0YzBiOGItM2RmMy00ZDllLThkNmYtMjczODQwYTI0MmI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MTE1YjU3\nZC1jZjYxLTQxODgtOGVlOC0xNGY0OTYwNjEyMGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATiLJlOerLFfqqftxRK4isPcv8FXvuTAcWLdFcF00Iyw/dWAcP/u9jT\nqhJ73rUJb18izhnToA3d3C2b5nCCm7zTo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQLKDrG\ncs3PWG/QMfbxQBaTmhFHqTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCDBOqDf3hx+tTv8NZ9CyvdJ7mVUlsleygJ658j2eWwjQIhALvt+lNyA+Ei\nraVd076bpmvkMHgpWzdbLTJosChOooZ1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6029", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6029` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARVNBjFgBJ4b4a7bLYsXUBELMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmYmU0ZWI0LWY2YjctNGNjNi1iZmEyLTQxMDEzYjkwM2M4MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWM3MWVlNGQtNzBh\nNS00NWI4LTk2NjktMzRjZDBiN2UzMGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELpgu9eMREnDjDAQ+2uSir16/Wz2VNsZ/yO6Qj2felEE6JL9WIiAmffCQYM4L\nNY5vSSZt6XxOcmyvcE2PP40fmqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVQohCef0GF7Be/2HdcWfQp54ViswHwYDVR0j\nBBgwFoAUmUKI4Bn//cYTHNTt1lGnKzeD9jIwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCANkIjOUU9\n4Dj2hxAn4NgAVcfNg81+E/zO9teWYUSs2gIgAbWo3Ysq9RkKJeN+jerHAJ3852hk\nDTB9AX291qMIkb0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfBqO0ZbRdpirUDAk/KQ/g0QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZmJlNGViNC1mNmI3LTRjYzYtYmZhMi00MTAxM2I5MDNjODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQReZ/Ya0i7SoCe2mcvWgnqppDekiJbigelKV1GLWKvdQIa\nAkRGkSBIq4/RTj+O+OCNVL69FI8nznwIp8Em7ZcIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmUKI4Bn//cYTHNTt1lGnKzeD\n9jIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANle95ifON0enachT9YaxDT79NbaKMiDmYm7dLEskgnuAiEApeTVqmDR\n8JwlNsveWmP/LeD9CiqIzhqMH8VvX1dNdUM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISATdG53DFOSZpaOqVKWS45K3uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWM3MWVlNGQtNzBhNS00NWI4LTk2NjktMzRjZDBiN2UzMGVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMDQ2ZDkw\nNC1jMjU2LTRiYzctODIwNS0yNzRlNWNjYjUyMmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQfrL1mIUUMgXfPzl8KW5YjQw5xG9JAkekw/Y0ASCBDYqmQN/dUbooe\nmqVhr51IR7UyU8sP6JXKDVeJvlaDbnRMo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVCiEJ\n5/QYXsF7/Yd1xZ9CnnhWKzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIFu0jFxgVdQjiiJuCY9/83Y37xmfrgsD6eRNnU5/DYvZAiEA5QVOq7Jhs4qk\n+q9MPtcucQ2JkegkDZ463fbRBtODF94=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6030", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6030` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATVHfk7oN5Xsg+eUTeW5qfNNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0Y2FkMzNlLWE3YmUtNGYzMy1iMzk0LTY0ZGQ1ZmIyOGNiOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRkZDA4ZDItYzQw\nNS00YjllLWE0YzUtNWUzNWY3NDMyMDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh+woqldzWG5CHeorQx1+QWh/CnygxKJEZN+y4V3Xbn8PbePbid6vvMIfXYVi\nvtHCW9Cg019gmR2sJYrP8EbbrKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzXZqQ11+zZVdzGAkdnHTROi7oiswHwYDVR0j\nBBgwFoAUjg30+MBOv4jhmPZM3uVpSjbnJjgwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIA9wAVGHe8GD\nnGgLRc+VOHbNxTNKSfVzdUJa0OvO2MQiAiEAk6+k5ZNqYgi5qea3YMPhbgMgO/p6\nr9Flvl8IY1Q/Sx4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfVVW5gMLKNDcP4sxJqMzxEkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGNhZDMzZS1hN2JlLTRmMzMtYjM5NC02NGRkNWZiMjhjYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0dqjMC2l1246w3J0EBL0eW4C1CcvPSdXKV6JRbHPxH4ZB\neYt32Npvv6+8PfCJ9RZabEctWEoGxtdAe7z4HoEto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjg30+MBOv4jhmPZM3uVpSjbn\nJjgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALqxswdV5WHDOtKOmr3i06/VpPohST6B/icykwuF1mlpAiEAjcNi2ff2\nEKR9poc7xVKvntDCePtTM2wkywrcNSARwPQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAU0lLB9Ghdt80jmj65Iajr6vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRkZDA4ZDItYzQwNS00YjllLWE0YzUtNWUzNWY3NDMyMDk3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNDQ3MmZh\nMy00MmQ5LTQ0YjktOGVmZC1jOGJhZGZjZDE0YWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATejcF7Ux4BGcVGYoCvgjm+l8z//22BlBPOc3PfPjtiMJrYWJRDJ02f\n9iVFeJZlbakFGSwn9QjE9+++W7nR7fw5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTNdmpD\nXX7NlV3MYCR2cdNE6LuiKzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIDek+mtF0JJs7D1qDP9g8+ep3M3aw1mDc3b9V1K49LHWAiBX3a2LTj4iaeD2\nAQUjvyYNtSexCIcQrgKHHvNmeR31Ew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6031", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6031` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAYdv7/8NxjjJCiE0DgjxXOjaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2NmEzYTUzLWMyOTYtNGEyZC05MDkwLTQ0M2FhYTA3ZDc1NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg5MTYzMTAtNGFm\nZi00N2M0LTk1OWEtYjI2NWRjNGNkODVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDSq5DvccUHcdHZcnldc0ccqqwQeudpTICnO1HZJd/fZ54GUkcNA4lwM8Q1mH\n2Dmrk7pUtIhmyObq+pbVuyJZ+6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylJrcAZdjJ3TRCas5pYl1yoJDPIwHwYDVR0j\nBBgwFoAUdIHXaZqScqkSVvkuM+xqMeBn4HQwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA/WrqSimT\n7qb0ejoozhoZospCnEzaXwA99puZmSqnBAoCIFF8coL4t6j3H91wWmSYLjfBTOwE\npo3krxvai/NhbJMH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdsVNnZH+VwioWNqE9DJvmUcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjZhM2E1My1jMjk2LTRhMmQtOTA5MC00NDNhYWEwN2Q3NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIK60wG4UEdXMhjxFuCx729yIzH5iBLrQvFMoXquoChofV\nvBeW3drmWTC4raExjoOAvasmvlc837vHNnbM8b8Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdIHXaZqScqkSVvkuM+xqMeBn\n4HQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIpmZXswlxh/XSvbX5hE5Mvk1/DNECgr+MtAmMgjof40AiEAtf///Apx\nQJMo6E9/DBHp2BpKSI7qdhvfn0sbaxmkXBs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAR14JfTwDWocq2rmfHO2m2hVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg5MTYzMTAtNGFmZi00N2M0LTk1OWEtYjI2NWRjNGNkODVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyM2E4ZTE0\nZC1kYzhkLTRhOTItYTFhYi0wZWNjODhmYjBlZTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATZdVbxbhOukmzAyiFiNT4tDIDpfO4jXtC6fXPAclt2FDS/wM3NV06J\noIUvrURTj0YPx7qdhOvamx7flPmYc3Zco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKUmtw\nBl2MndNEJqzmliXXKgkM8jAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQD/gpsbzpLFxTBEntl7odae6iaK+DK4OwA52MDD0I29mwIgR/mMNsT61IuF\nHNYMIj4z8WVryVECGk1ZSLJQUJpla5Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6032", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6032` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAeDZPLgs7K4NsdJElYCbti4lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzMjJmYWZkLTc3NjEtNGIyMS05ZThmLTM3ZGNhMWI0MTg2MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzI1YzFmNTAtMjg1\nNy00OTgwLTk4NDYtYTIzNTdkYjU5NzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJnji6oGMlQ8VAT71mkw09JHJj6n6wF/H9DojkzHFd2oY09dPEufnP1xREDBh\nvp8Gx0f6SaItX4a7Zt3af+Y9yKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0JDCgZc74c+q1C/PLoBv3eC6cYEwHwYDVR0j\nBBgwFoAUzSxU55XqJXzmggqD5+y6/UHW6igwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAt5jnhtLLHt1h9QXvTP9F4qSrEkqynhkI+rmyYXnQPmgCIG+jJcnT/1M7\n2imr9nmfVoPOLFHSDydBOv6pnjdntfIA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVwkNxRXdFf7YkboVlvJ/VBmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzIyZmFmZC03NzYxLTRiMjEtOWU4Zi0zN2RjYTFiNDE4NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb3pYeqY6xIv30Z8I19aCoMCnth9yOTeYqpm1rewIx1fs7\ndXUzJL5FkqDmy3bLpjNwn1CkmUESnucR04piH/KUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzSxU55XqJXzmggqD5+y6/UHW\n6igwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQdpZ0NvtzphJ/A5umkcR2S0nHOdJlOMbDbtAyk6LRXoCIDBJDBp+iMcT\ny7mK8WVxkXegLCta3AE+wXSV2EXSMrYW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAeZq+78dVKl+9fP5Jlmtho8MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzI1YzFmNTAtMjg1Ny00OTgwLTk4NDYtYTIzNTdkYjU5NzM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNmVlMmI5\nYS04MDg0LTQ0N2QtODY2MS1iNWQzOWM5YTc4MzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR5p/twkfKeKCtde3k1oeJ8SBHIrbOAOoWubVLryK5FpKiC8lwPeMfE\nznn0AFyKgaZg1GDGe20zEt4tiVcUOo/Qo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQkMKB\nlzvhz6rUL88ugG/d4LpxgTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIHK3UyZtR+sNiND3qwrydTNHhujqn2MMzaLu8tqEJkwfAiAUWhBgqrwcNqOr\n/cITsUoVagZ8CyLtgLDebtnuQqKpUg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6033", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6033` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAdi1z8J0fvx0CR2dIZX7d6fUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwZjEyYTI2LTYyZDItNDcxYi1iYzVmLTVkYjhlZTQyMTVlNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA4MDI5NTUtMGMz\nNy00MWI3LWEwZWItMjBjOTM5Mzk0NTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDN7XwGt6MnPjBttuaWcPFG7wEk38fdE5Hw1TBPKuKIX8NtrYTkl49bOE0mMj\nSuCi94UUq2q0EgfeoVQgAOUc6aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+K68kGkRqmZjDLpGS6GKvqjq1xAwHwYDVR0j\nBBgwFoAUVlQUdk1V3Jf5+FFzQV+uSj6uLJYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA7uZuhe137ZWA1O1ykEn6mlRM5wAAm13H0rqvRPfWLkoCIQD7yDCw1Bqh\nsXwMaQ9MhCqE4Oc5Krz1DNyG3GPGpsvYFg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQq0vDcntF2Q8RFOmZ6ZbEyqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMGYxMmEyNi02MmQyLTQ3MWItYmM1Zi01ZGI4ZWU0MjE1ZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOMcorVO7PdrB4eCE5By/EuGvlRbOU0XN18bCaPtL0kVPP\nG3m86woT+zqxfdPNLKqZjrtfb88WsPNAiWCDK6jCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVlQUdk1V3Jf5+FFzQV+uSj6u\nLJYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN36jqy5EYPynIzIZuy9U5C//pKXrT633ombw7tv51jZAiEAzOuYVEvu\nmyePYqBsZuiMp0WCIdpcVuH/ecTjlnHEdFQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAT2iLwLl7tOQbNnFh2y06o9sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA4MDI5NTUtMGMzNy00MWI3LWEwZWItMjBjOTM5Mzk0NTMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYTNiMGM2\nYS1mNzc4LTQ4MWYtOGViOS1hNzlmMGM4ODg0OWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASd/5iI2Rit1PxF5p5i2gnML4AOQuH9CICew/TjCmgf46eZasaqZpn7\n9UctULSFMPCef0+BUdoSBhOhRSyYEyS9o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4rryQ\naRGqZmMMukZLoYq+qOrXEDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCID/1EFvbaOr4P4V4FwQMphCrma1p4VFMbrnmy2JtJ8vZAiBGR6t+LxLLnu9N\ncYCZfRG8aCnnoXj/uBP40JTkjb8Xqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6034", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6034` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISASh1e0IlRBz557ZDHonq6dIbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmZGYyNTI5LTRmNGQtNGM2NC05MmJhLTJlMWMwNGU0ZDc5MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZjMjRlMjMtYWYw\nOC00NGQwLWFlNjQtYTQ5MGIxMGUzYjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEa08uRMLoZo7cMYlrx74qcsRQLqA4NXoI0JRBybmXVjVJl43Pjdzi5UpqPP5\n+IHTmvlLjtT8He0MFlA1cmkwTKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtozXyp8jCqncKLB+IF3JDc8cBw4wHwYDVR0j\nBBgwFoAUMiT6JfJX6A49HF5fpjaailr4X2EwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\no4o4dlqmoBnYKQDIVeyaz5FtnEMKkzjYElCOdDvBLmECIQDoHPelebaxALKBvlCD\nLwAWCOhZJyszKzQR9E1Yw43rHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQILdw3vsv/MLM6fD85OEGr6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmRmMjUyOS00ZjRkLTRjNjQtOTJiYS0yZTFjMDRlNGQ3OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkQlvBKjJ9kpsmY9ZmNHVIePfSeeNhO2RCfORxYio0dd3V\n7P7aQzFo3YMKyC/lqCxL47nvU7fuLcEydSWgMTpeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMiT6JfJX6A49HF5fpjaailr4\nX2EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM2aNFYye8PuqhmNBVdJZPYK19gIuDOwCBxOi7pqFm/2AiAvAFFqZ+1n\nU4wRJg4YQ68TSzMLPXmH05r3NdI2MVmcog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAW81HjXkAr+LXB3GPmyYi3UxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZjMjRlMjMtYWYwOC00NGQwLWFlNjQtYTQ5MGIxMGUzYjc5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNGEwZDdk\nYi1kN2E5LTQ5ZTYtOTMxNS1iOGQ5Y2FkZjBkMGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARUjPU9Bmm8KcTeyN2njX1l1EFCqBrXVfozUwV0KeZxenyg26vncf/6\nzH9hUaWHmgcVIF5osA0IK1Z8P2OvJuq6o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS2jNfK\nnyMKqdwosH4gXckNzxwHDjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDB0OgdK6KpdE5eRRaBaEBFj4ixzsbQqHwrdPABImhc1wIgcznbGhI1Wrbj\nSSKgvEIzuwMG3+VKMQ2KPXEsQA/ADKs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6035", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6035` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAYH7txKEw8nGnlXXdgO7lK3YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlMzZiOWExLTg0ZTYtNDdlNy1hMmZjLWQxOTc5ZDM5MzM3NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE3NjA3YjEtODIw\nNS00NGZjLWFhMTUtNGE2OTEwMTdkZTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfX+3e+8SJzAt83txuJPw5hyTzJODtvsUub3vdMrnckIXjBAaZ0KsjeYoS1Uj\nlzws3hgqgiXP36vjB0uxZyqIfKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6bvJeBnaDPgn7wJPMJmq2mq1tUQwHwYDVR0j\nBBgwFoAU27+APz6P0Tmdujf2cTCkeluwGlMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAMnNDA3AoZ/VD8fFnQuHzdrCqBSs9W6HVzEZXfjXl5BwIgWkwf\nS9Z4Vi49L3QMVMKWFyl2r68x33omITxxkfDLTgQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATEhdc+L/2jYnPWbwrmMd2ufMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTM2YjlhMS04NGU2LTQ3ZTctYTJmYy1kMTk3OWQzOTMzNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQu4YC/YBtxiUtY/eEIanZd6unOM6RtBu3LRSm+Sthcb+LB\nfTGhj7Z3IE8bVZI5r4QDOcTj9Uy9Y/nh8VTg5BRuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU27+APz6P0Tmdujf2cTCkeluw\nGlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIsusfauCZUOo3Lci9K6k4Ah7fO7bG8Md5q2KZY+t9orAiEA6+asnbE0\nq/9ig6sxt1C/sTjQD0G6Q4ONmkPLMeKWo98=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAWaEdIXqN/v/KGouJbLKGPDLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE3NjA3YjEtODIwNS00NGZjLWFhMTUtNGE2OTEwMTdkZTg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMjQ2NzE5\nMy0xNjcwLTQxODQtYjdhZS00Y2RkYmNiMzhhY2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASnA+N5Ycl57sdNTEjtM0JuzpU7Zf6QEKOwQ92miEuPLa4KU9PCXjXe\nS4M/QzfhVMLtc7e9ZRIwlMcB7hMRkH3ho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTpu8l4\nGdoM+CfvAk8wmaraarW1RDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCHPrM5Y8aQTE4reOnZb373QE3qyWIPvk3gUnrQ3e2G0QIhAMllQ6S3bscA\ntSOsSikqsq6a4/Zg2wwRh8p6F28czLkB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6036", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6036` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAare1/1TB1eUBM3KZuuCCZaPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2MmVkZTFjLWE5NWMtNDhhYS04YjhlLTc0MGY0MTFlZmQ2MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA0YTA1ZWUtMTcw\nZi00Mzc3LTg3NTQtZjdjYzBiYWIxMTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzL3gEDyLTJXTAzvlVkEBBd4gznmUjDPUdA8TABvLx1W7ggN9QwBDxnBV/jY+\nifw5yvNQTqCv0cYKtcY7lV67ZqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEeEJdKptaY1yV2BrnNUV2SfF1uEwHwYDVR0j\nBBgwFoAU6nBsZE3Db0BH4TfNRJWtTeiBCvowPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiB4Q543aAweRUS5cUwkWOLm6dEt8xvnezGDVu7XFQyDmgIgCUFA\n60HK9K1yRhZZwzhFGyPhRmQbwbhfBGVaACgIdBs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbNiyj/G0JDRDBx8dTg3r23xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjJlZGUxYy1hOTVjLTQ4YWEtOGI4ZS03NDBmNDExZWZkNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHWgcZyUwcpxkwdeLOVBP+/WWyvuCqw+J0/p6wXPtlJG6w\nhh/cO9PPYOzyx9zmavmhBUNJ9cWvrLBQ6s8Fjn6Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6nBsZE3Db0BH4TfNRJWtTeiB\nCvowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIxWA6rMUtlvGO8ZOh0FT2EIr0pm1NEcbC4sQoHu20jYCIE8oFKlMvrbv\nRc8LYU2sULhtDsv8cFGmfFOANdAuQds/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAQvVhsIMd3TKuNPu+K1chn3dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA0YTA1ZWUtMTcwZi00Mzc3LTg3NTQtZjdjYzBiYWIxMTE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MTJiOWQw\nMy03MTJiLTRhNTMtOTRjYi1hZjc0Y2NiNjdkNTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQNyrqyoySD1v4k1k4kHIO6wg6rpXHTIf+h1X7BKoTs1/J1bVev6bkq\n8cGrbopDSRwW3BZiV0ND355Rbd8DdvLho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQR4Ql0\nqm1pjXJXYGuc1RXZJ8XW4TAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIBfQ4njpNxt+PLkedUQAZz4JU8hj31SPeaStGUT1Xo4gAiA6YIZ5lNcO/d+x\ntLWRYk9AeD1Ahkd6bKbISJXT+o0Brg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6037", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6037` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAViXa/E/AcJkoffAAHs30jzUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2OTQ0MTM5LTQ2ODQtNGIwMi1iMWM1LWMyM2IwMTQ1Yzc4YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUxNjQ0ZjAtODNh\nYS00MTI3LWJmZDctZGY0Mzg2MmE3ZWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0cXgEx8B09diJ7UXpidTo/arIFW/V/djVEwsVi6H3Syvk0wqip+LVw/kZ/Cn\nRPiEmjd9Vn2UKiq50XKiyGTOpqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUekG2iNlrU08ObzeUvj3yKZIldSswHwYDVR0j\nBBgwFoAUgc64IBYjq1cBaRZoRMHSSX+4GFYwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA/MaMM0hyLsdc\n0ggpEfl57PmdD8JW/K9o1eF2B8FA7IcCIQDaYDz2iknTJgjvlmplL488bwDIZxS+\n2SP9XE74jaUnvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQRI3/YMBe7hGz57G/DbBqQXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjk0NDEzOS00Njg0LTRiMDItYjFjNS1jMjNiMDE0NWM3OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdCiKzQgZ4y0cJzqXqp4uMy6fHQOLBKRY7J4tmvragWKwN\nGT0Z5VfN9dLOjHA70+WutLwTJCX7/+mxwV7ofDzzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgc64IBYjq1cBaRZoRMHSSX+4\nGFYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJKKOlB5N5pKnEPzyhxSY4dUb30BIqBQ4xFhdvRvwY2NAiEA4ZoO2/3h\nuU6PqxC23kEJ6voYqPrqpPEWRNuOD9SFX08=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAd+ZkmYEKz55esedpccpxRXfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUxNjQ0ZjAtODNhYS00MTI3LWJmZDctZGY0Mzg2MmE3ZWVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYmFlNmI4\nMS0yY2Y4LTRhZmItYjE0MC1iYjFhZGRiOTNmNjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATvP7qGwD1AlqNQo5a8WsEk7Mw7azTZglr67WdQfNYT7o5JZLp1ZgGl\nNex+JqflVr4B+uTPH+lCB1qqALcNZHoQo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6QbaI\n2WtTTw5vN5S+PfIpkiV1KzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIEjaK6wt4cKJILW7lg5DUNEZJ83KVOgDxVgheVNtRfdXAiBJx5yo8QNqJBmJ\nlUingCSQndUtEJYyfFb0MGFq0euyJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6038", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6038` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVpg9ZccUFRqzrEUfdtkOyDgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1OTdlYTg3LTVmYjgtNGEzNi1hNTBiLTFmOGQxYWRhYmFjMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUyZjA0OWEtOGVj\nMS00ZWEzLTg2OWQtMTFlY2E4ODBhNzA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEdrbZyOkNPJ3q9ABo7CPxUDbpdN9L6fA8T/qbJ/Y9I+CGtI2NehDhDkkdWhv\ncaE1YoYRTbOn2wjZQZ1ae7sQ46OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHaqHZ+pebM8LMitK+qd9OyaUmgowHwYDVR0j\nBBgwFoAULwVTes2zUY+cuy2MR+csBRSxyIwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCMlpdmUkOYCZhgN6n9J7GxKnRmz0IPknShjTRQgWoeiwIhAL+SVKytOrV2\nCx/Tfra7fndGkQ6/25w4l1manHNk7RXv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWZVQnh7ApkH7m+nRY4YugvBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTk3ZWE4Ny01ZmI4LTRhMzYtYTUwYi0xZjhkMWFkYWJhYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2mun27ybk55vDewvNAVCZVFbqYj56RwpPIN3ryjmMPRUr\nRgHtAdo1CSI9NiRu0+MKn+0UABH08aR3GJbmZepeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULwVTes2zUY+cuy2MR+csBRSx\nyIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaXjAsKV6cKFqnNvO1JNN8MVOK2W9xSG1NPJPTf9X+ZUCIQD1AZAxm+bw\nxUdaHhKjmA9VFejE9ySZSyzlZHAM52f3ZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAY2vL0nx5wRDJl7GF6N3IR6rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUyZjA0OWEtOGVjMS00ZWEzLTg2OWQtMTFlY2E4ODBhNzA4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZDgzNDRk\nMy1jOWUwLTQzZmQtODQwZi03OGY1NDA1OGYwOGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASZ+GgLa1kJNRIdpHs4E7DZB+STk1f/u6XQllrhJc/4V34uSht8DO01\nEQ+k4pZ2vT/QSJo2LYJhwv9F8u+yXaxso2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQdqodn\n6l5szwsyK0r6p307JpSaCjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIAzGcx8QgSjeGVajdlKd/8luUShYQoTxN1WRoJ8ZmZMdAiEAwRVOOOXKDYji\n7D8cH90CJCrAdmld9g+P/bA5zsSQ6c0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6039", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6039` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdoVd8mR5QF1YeS+dTv8wyusMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyMTUyODY5LTcxOTUtNDIwNC1hMGE3LTdjMzQyZWFmYTliZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNhNWQ4MDMtMjk5\nZS00ZGE1LTg1ZWItM2NjNDFjMjJlMTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqin5s6zsJcBRskDisJ5ImfEGmvHLLLv0WJxcJBhpmqqNW2oNU14L+fcoHUP3\nBUX4pCLW147elhju3nF+zGCxB6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa7oPY0GDDAwaEeN4Dm5UGBSf/yowHwYDVR0j\nBBgwFoAUOL65A/8+LcvaRf6CJz3erFqnxuMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFYaMoMbTLd//NcY4Q/gUQ3DuqkvLLq1IiX+SHpjf799AiBYZq8AmFjCrZow\njmZ5S1unqdQ5w4atNdh0a1Vz/82IwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaxVTXgm78MGdDujuWHrjU7mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjE1Mjg2OS03MTk1LTQyMDQtYTBhNy03YzM0MmVhZmE5YmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARs0IqYmgzuM3y+uh74fzB7hI9vjG64WwpAKkEFbEUDJgte\n3DMeY4FA4yyEFhhQDWIIlWjE4NGyKcd6rgz1lNtMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOL65A/8+LcvaRf6CJz3erFqn\nxuMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQoxvkFeuqYYAgX9vFXycHezRfdghFLdRH1WUdvV66woCIBl+YKxCbiWt\nsCgylZgVVXTQv3s7YHaSGilduw82/j3s\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAViQ+kCQhfXGlVhUO7CYI44hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNhNWQ4MDMtMjk5ZS00ZGE1LTg1ZWItM2NjNDFjMjJlMTFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNzAzMTBj\nMC1hZTc0LTQ2YmUtYmNkZS1jNDhjNDAzOGE3ZGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT3eHdBvucExjBVIVSxMkMqTfZj3XtY77QmwQBuXdDfft3L5aWZNpnt\nBV4PuVVYj2YvT4O82mBv9ktpOsv9Orleo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRrug9j\nQYMMDBoR43gOblQYFJ//KjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCfLtpccxeO6u5F5tg71PH9Ig9+P1DHQtpFfIa/eB9wtgIgfg/40DNIryaj\nbKbT7aUHL/fJ8Bdp2Iehgo0RMwbetZo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6040", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6040` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAfvuTt7TVRqebGhNvZPW6WSMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZmZiZjNjLWZiYWUtNDZlOC04MDYzLThiMDRjYTBmYjNjOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM1MDc1MWQtMTUx\nOC00NmYyLThiYTctZGQyZDBmMDg0N2MzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErrZRKHa1vgGGNVN02zavWk8ugywZbdFzi3l56GwKu7MSTZLPvQfHjhqMLya4\nTueg6YGC82Knn85nDyhJBBi0U6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcq7o5sKQNf3LJ+6BZ4RpEZUnCv8wHwYDVR0j\nBBgwFoAU8yfC48LV1PsCmX/PFiFLnO7hLdkwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAnWBGTonaYCZlBq3BhmtQdw7TiIktusXkfkbciOIpmwsCIQDS+MLrUqhG\n+sbmSMus/XP2VmvQeNQAQ4ks3+YD8YWC+g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQO6UolQorYprMseXJBTe/BHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGZmYmYzYy1mYmFlLTQ2ZTgtODA2My04YjA0Y2EwZmIzYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwQl80QOQTQRkhyzTUU7zgu+g2NX6Dgq9eRZ0PLSbQYbOk\nmX+Usiw3Un2zwO835mfLZcIAuKx3RUsaZpij0YIJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8yfC48LV1PsCmX/PFiFLnO7h\nLdkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXBC6PS8mMTkgYzzwMAXPbUj5ajMc6WCPaDP7F5efHI8CIQDT5+SR8kW4\nwafVGDlImjOpL9GX46fIXxaL34r3jnClLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAYUuKemCtDBg0YZ4kraKqnGaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM1MDc1MWQtMTUxOC00NmYyLThiYTctZGQyZDBmMDg0N2MzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlODU3MDlh\nMC1hNzk2LTQ2NDktYTZkMi00ZTZhMjIxYzhkOWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAStJk+5f2z842e39Y5OGmly6VdcM0kNa1TN7jLzqoQNAo/ZRbcry/Xu\nWL8D6J5E/ltcr5Wp8cfPfSSzTN4w+WbDo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRyrujm\nwpA1/csn7oFnhGkRlScK/zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIDaPaToguIOUr6SVIL3rRfKWVIDDcZfzBOpDcRqmToxVAiBZJt8J/dYcHcAQ\n1SDmoRFQK2HqbZqFPlP7xB7+xHsQFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6041", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6041` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcFuZZW7cHfP1ZvO30dCLE4FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNTlkNDczLWUxMzktNDEwNi04ZDNhLWY4Y2E0NGNiODQyNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM5NThjZmUtYTEy\nYi00YWE2LWI5MDAtYThjNGE1NDE1NTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJo7RwFcFi6yiKNAkWIGukHiYcqjNPC+jdP3HLxAi8ugtvN1FfgMaG4Y/pbVt\nkMBmE1ggB5h9LB7kSWyVi8I9nKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/lPx+WvF2EEQZpFCaRGxkrE0dkwwHwYDVR0j\nBBgwFoAUlst0TXCleLsnwJyTFgpSqccaRcMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAB1e9/WERASuDMK0frfmutEkvSkbk0fuRj2Td2Xfpo\nqAIhANNf6ZdYEiiOpWCCzEbm58prD5cNrsOTqxlp+NXIzkZ8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe0mdIferHxDP6MCH7DLs1IvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDU5ZDQ3My1lMTM5LTQxMDYtOGQzYS1mOGNhNDRjYjg0MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiWTWamDJc7gm0VC+ruP2Lsq25JBnBwUUe5wDuPsdmgz7g\n8x7+S9b3rDQcUsz/rUHxk9EYngIO6vm4QIfyYiPao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlst0TXCleLsnwJyTFgpSqcca\nRcMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKVxC+ybcenQvKvIgj99SuvYjKhEzaj2O8/W2WSdU4UEAiB5gW9+OgRj\n9UGNnvn53sM7N4a9sWI7OEe2UxAEbT0UoQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAe3S5cvVu5xVgAi0K40W7l6/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM5NThjZmUtYTEyYi00YWE2LWI5MDAtYThjNGE1NDE1NTExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNDQyOTE4\nZC03YTAyLTRkMDEtYTAyOS1mMTAyMzlhZDdjYzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATYcnEpVwVPIiNqptVTEjfwaWdcsB0uqD0pApPQ8bD56Fvxs+4Fr+Sq\naRIYC3wVI/Ijk8Yf2ZC/lTtvA69HCyNIo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+U/H5\na8XYQRBmkUJpEbGSsTR2TDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIFmsZQ7V1Rckm4Duw0eb8/pZhKg3JR/E2Sx9vr4cKermAiEA403Ok3fkLK5c\nOfqbEBsRfFHqASAC/jkcFXdJ+6yuE68=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6042", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6042` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAdV5LY6QPkBfFn3h6MsOu5gXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmYjQ5OTljLTFhZWQtNGEzMS04YWViLWI2YmExYjc0Y2Q2NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMxMDQ2NWQtNzlm\nZS00YzMzLWJiMDktMjk0NzNkNDhjMjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbGIwYEdCydCIbtz3C/749Ix2m+bi3NCSTGdzsB/kkAZeril+UguNgivtOGNN\nq89IepXL7qYrhVh8j54OUMA0Z6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZSya9+frkHwW7NDvl6FIAXLO8KEwHwYDVR0j\nBBgwFoAU9paXdtT8Ua0bH2G8g/mdNpbeGFEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAIBK4TkzOMvjeIfQlmpoaCFz1WXebkgRcpr4xr71/G\n7gIgFwYJuIC3B138FrUYsMLn7eB+J65UqxsDBwArp9Eg7h4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQNWhF6bo2SgRpDLfAxad7UoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZmI0OTk5Yy0xYWVkLTRhMzEtOGFlYi1iNmJhMWI3NGNkNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnIOQCmyCmDOcKidnulzmAW7OOfFkCOzmZvIZdmWYbvLBz\n0DT/CYO5bslctYbVBnm+5icT1oGIUP9MLjH0QMNro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9paXdtT8Ua0bH2G8g/mdNpbe\nGFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIfmXxQBkd/G9BBSp71HRi6TMQBobke6UrgtoyPeKKkoCIHw5f7L3qfRz\n2/piJGIVxbkTwxDzjNbSjv1wC0ejk474\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAQQzk+hTokIXA6lphnnlojoLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMxMDQ2NWQtNzlmZS00YzMzLWJiMDktMjk0NzNkNDhjMjlkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMzIwN2M1\nZC04NGJiLTQ5YzgtYmEyYi0yZGRhN2MzYjUwZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARIynZj17Ij0qww1WPhKSR6fCoGaD3Kml3TeAR7f39/dCgRqFzelbRK\nYVWvcFR5ejBEC8CpocJkPb2Tx5ZrzdEho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRlLJr3\n5+uQfBbs0O+XoUgBcs7woTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDR0np3WAtC7ZO3Hmm2XyXbt4qYW+QjPKseq3rt1XXjEgIhAJnJ9SKQsGO9\ni51xsnaqZDsmijt+wGRNagM632LblnPg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6043", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6043` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAUuQNPPi3MHD4cJ6BDUAK7giMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjODcyYTZkLWQwYWQtNGU3Yy05YTBkLTVjZmY3YmZmYjk0MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFkNzg3ZTAtY2M5\nZS00YjFlLWE2OWEtNjcwYWUwY2QyOTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExYqEABhlwxOMZI9n2uPX7OCzKgZ/gNtv89z23pPnJPRjROcXggvaB4jqCnRR\nBhqbj6chgfOCLB01jZBGIL/cQaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ohf7Mj+AE5iW62v/Ppt43WjnFAwHwYDVR0j\nBBgwFoAU0PxE3/lXzFyLyUrq/F75PszvNCMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAUaguAYRRUNAIrrkqKvIO86vf124cpHFB7mzM2ad3A6wIgObn8\nq41Rv4BVFM7iqMQvkBSPY+9rAi0y2yW/bFtcWQ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQQ2Ssf/Fgom7hZA1V67bW1BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzg3MmE2ZC1kMGFkLTRlN2MtOWEwZC01Y2ZmN2JmZmI5NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIwsQsBYkTCR0HcyrMZtWL8YTAIy6QG3QuaY24HEh7GyeS\nHeAaKOAVJzAmIt12IGz3aLP7g5sFGVVbmVHGG581o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0PxE3/lXzFyLyUrq/F75Pszv\nNCMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOLy+SVLS5psSFrK4RTiPHGurIBoEATZmOWEu5a6XenVAiBUZpeS0NuG\nfpKAHL1Ikh9vTafSA4m80HR4563uX4zpqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAboaPJkea2hz+tcPiIkx+GfKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFkNzg3ZTAtY2M5ZS00YjFlLWE2OWEtNjcwYWUwY2QyOTk3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OWFkZjA0\nNi1lODNjLTRmM2MtODEwYS04NmU2NjA5NjQzZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARbyO1aPV+UcFTgub6BbJ/ID/7cMfrYBQfo2MgLlZi4ARGFrOWTLmuI\n2ErjZymQ5TM1RPoJE+Y+O3c/e+Nwfa48o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTuiF/s\nyP4ATmJbra/8+m3jdaOcUDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIG9GOcNtpxzJ7locMM4I7LaZXQgbMRLZ3zfo6A3XqYxbAiEAl2BIOndYyEJV\n0OaVcYrY+wPMz+0/6u8X0mmqhYYJJK0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6044", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6044` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAWq/+HuYa4ZR9ubOHnU1SrHXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhMzhhMGE5LTdlNjMtNDgzOS05ZGQwLTczZjA2MjllNWEzNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTljYjE0MjAtODFm\nYy00M2JlLTk5MzYtMWVkMDNjZGQzZjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiAGA6Zwz8G3FxCZtJyXZOlLi1EI3lrH0RJF/poLBnt+RE+f8oBfHdXERFlWz\nqrnCTiwNP4pv9+L5iFDPzYX7pqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcgvZbFHl4ZJ1pKuLUtXQzohgMKAwHwYDVR0j\nBBgwFoAUgKPSn/lP/Mkzx4YvEperHqNeKnAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBWid4L+oPTpJvj9ZCGk1eqG0+NGCPXOgPQ\nCfGH8U3JNgIhAPrR5bGZEwGQRHy/rwuIzmN98e/ctoGFBXONa1NtTYFQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASr2Wjb4cDSeiZL6SYc4bAxnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTM4YTBhOS03ZTYzLTQ4MzktOWRkMC03M2YwNjI5ZTVhMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQwGbsDXBD2CkwV9bt+mn0csZG4tVFLkXNFodQko8LFyyV\npcUOQ+Z3hmm1gS5tHqx5QPJ86GxD+pYlfl+w+e3Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgKPSn/lP/Mkzx4YvEperHqNe\nKnAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPzWW8GlzJ5XEym2CVCAALObCl+JT4/vACHJBrEtYefTAiBbyQG0sYa4\nG6tAoQaux5vKY9J2OJV145PeDCYdXML5pg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAYsFaolkJZP7+YbGVjQKKgdlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTljYjE0MjAtODFmYy00M2JlLTk5MzYtMWVkMDNjZGQzZjRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZmM0MDFh\nNS1lN2MwLTQyOTctOGE2Zi04Y2ZiMWY4MjljNDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASD3MvWS44Rh2yv547g06VCLmFx02gsO2BtHX6SlnkSIFZGh4j31GPV\nEOha9fM1Of0egaICYMqlXR675qu8iRLCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRyC9ls\nUeXhknWkq4tS1dDOiGAwoDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCFj2sFjl0f4p80NZSCCbuPryebRhZPusZoi99mP7sqUAIhANuA1gjG1B53\nhtd6RXgNoJo9J25V0wwuedPR85cLVH4C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6045", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6045` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAaSqAczQAJX5u3/OaYiVEHAiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2YmViNGY3LTU1MGUtNDViNC04NTliLTBhOGQ2NjBjNDBiOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZjN2EzNDQtMzA5\nYy00Y2Q4LWJhMzUtNGU0OWY4NThmNzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOFr7U/OIgthdbfJef89/sSV497G1ZQ96qTWLsBLLccyhYMt9vZ+DhU02VJfk\n+yptDIz66+cmr+RTDhc/I7tIsaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCyjNXdq0Qex2HFbt9Bo+goZP6TEwHwYDVR0j\nBBgwFoAUBNcQ7neLRNjF49z0gWzOaBasGwcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiANKM0x35dKMmi6b5e465hKucJv6rd6hanr\n8EXlMlt2qgIgPcZqKd1YBje2DInr6wM5Hi3lVwmzK9unH0bM1p5+WVw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY0fW56aO4pSxcZmsDW6timDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmJlYjRmNy01NTBlLTQ1YjQtODU5Yi0wYThkNjYwYzQwYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQD2bvwCKmS9Z3LZiFsvNcD5FlotrjRVUPpuPmwHbECBZzl\nGy3jDOYQXF8GstX/UkJd/3x9KsRFV7II1q8Xt9F6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBNcQ7neLRNjF49z0gWzOaBas\nGwcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUnb0IinBRWYEyqXjaaOnoWGen2/SDGh1xJD+oFM1JS8CIQC981X8mcRB\nkDPwNYqGu2l8qM+ST+MJiUrwa73S6Y0Bnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAWDXuPMmo0km5qa0AdrmzF7QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZjN2EzNDQtMzA5Yy00Y2Q4LWJhMzUtNGU0OWY4NThmNzlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNzc2NjBk\nZC1kNDdkLTQzOTctYmExZS1mODViZTMxOGM1N2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARBe5EIQTr6t6RJCTJdDV3+TDW8MUtiK9sWc67SoXum1WWgdi/LfgV6\nel3UPEFBeXvlyil2o4dbC1BQYmydjBjSo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQLKM1d\n2rRB7HYcVu30Gj6Chk/pMTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCKIizK0IKnKl/srDhJGJjhU+HR9V4B7XS72rq3Cw3xwAIhAID6SKk9eW++\n4YE3RHJ+cWi5V28r9Kn96X4NhwbLuZYE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6046", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6046` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARnFRGZnOdKO4QOixu+/5shZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmYjY5MmRhLWFkZTYtNDMxOS1hMjc2LTY4NTMyYmVjY2IwMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZmMjgzODktYTQ0\nMS00NTk0LTgzODctODVhOTA1Yjk5MzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9qvQxmzNm6qqRjrYwwr+EgKvm0vF3kddjHIwOigUqqE8tGeUV0kG5Z8BXHRs\nGBLorgF6z8KmiWruaqx2CM1FMqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdWfzAY4mosIkiCiAxXm8QfVxk5wwHwYDVR0j\nBBgwFoAU1/zCdvGUByf6dkYMrq5a0681Dg4wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBMFcW2j3na2/jY\neq2L60vt9JkjmA0jHQZVNpkvXTJWiAIhAPiMZrTBFTD+1tHlNcLoKQWzU7wGobMC\nWNEhmrhJqmRb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbKwwSh8bQXb1kAPPMmibrVIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZmI2OTJkYS1hZGU2LTQzMTktYTI3Ni02ODUzMmJlY2NiMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHS+4bak5ybSn8f5GbKWyVgWdmA5syrsqn8szGGO1VZ0OS\noevQ0g+29ITSeVi9I+V544jksVteEmDPjCGeZN7wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1/zCdvGUByf6dkYMrq5a0681\nDg4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaJ+unl51k5Z9NiO6apeAp22rRB5srHZABUQxE8NrFQICIBm0Nm19L6yP\nGZJ63pLnS9ysYOZnQJiV365u2dsJvXd7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAW69qokKSfJjNux5hf+/rqVoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZmMjgzODktYTQ0MS00NTk0LTgzODctODVhOTA1Yjk5MzY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhM2FhZDc0\nOS02ZmMyLTQ3NmEtOWVmNC1iOGY4NzNkMzUyOGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAREbNqot8y87PjYPu+clPNdLEKjDeF4ZAPzwMsDTj/FnEK9AgzIs10i\n6CkhZt74ZZI3IA5a31bJkajcTl3XToNZo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1Z/MB\njiaiwiSIKIDFebxB9XGTnDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIAoKtZJ2QB67ee4vedjz62lLaWxl+0s9oU0iXshVClnUAiEAhiZI07CgpSz0\nXiRJIYHgpdIIQXpgTFD/Ijnms2+wkZA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6047", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6047` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdCuCCMz6/ofGohceJOuVdfuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkMjA4ZjgwLThiY2EtNDRkMi1hMmZiLTJkYzlhNDY4YjJiYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk3YzRmZjUtMzVk\nNC00NDk4LThkZWYtOTBlNjdhMjIzZjdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEehHi4mumUqIe/XYX8oWmMrUl7sK6V+I7NFj21a/V+mULPA/oKwJX/lTUaNcq\ntHLzMcbDqu5xyGusNATalor49aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWfUMyB4OU5SxntlwsHjYFDHQuaowHwYDVR0j\nBBgwFoAU4v8wkCUR2RCC5TXkKGBOjdzsd3QwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDdIcjn7+24EQUYnLCLfXlIWDcqN41dgBmrdDLItDdkwwIhAMi7vAFG7Mtg\nSFnhv9lcCVJqbZ0rUWUAS+asm4kuwSwJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYFkd77RPAETk4oG8EeDTN5BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDIwOGY4MC04YmNhLTQ0ZDItYTJmYi0yZGM5YTQ2OGIyYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/arECLwxCDW43gqfK/k7/SgUnQhw8ENJQ8nUC+pkwXzgh\n/NaxK7ZmRU5DlvmYGUPhsozCa0xgJx4T9UjcGSoio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4v8wkCUR2RCC5TXkKGBOjdzs\nd3QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKX0z799x71tKo2nvEtBMOk6qF3aUqD+Qld+rE/OK7PkAiA2pQm3fWY6\nrH1JYoc5MUheEtjCHo45T2GJznEbNTafNQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAdwrl11k83f76YwOCKdYz4DLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk3YzRmZjUtMzVkNC00NDk4LThkZWYtOTBlNjdhMjIzZjdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4N2U0M2Q5\nNy1iNGI0LTQyNGYtYjVjMC05NjkxMzA4MjMyNGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASdzPMy4xHoI7SwUtNHY2Mzgpj6ZnbghNUKcB0A9zwQJgdWsJaVGGZU\nfYIDEndZETchAfbPn7bpKIDz3QNWLFmTo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZ9QzI\nHg5TlLGe2XCweNgUMdC5qjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIHMRoCjb+XJvb66RRSgzaOltuPjaJDqD/jztgieWmNEVAiEA0pbbpK8G4XoF\nliu7k8uQ+GnGLhHicSppsI4FkI14lCA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6048", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6048` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAac1f2tcfQo6ovCphxUvYKacMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxNzIzYmJiLTU0NWEtNGJlZC05NjExLTA0ZDA3NTJmNDVkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFlOGRjZjItZWU4\nNS00NjRhLWI3ZTctY2UzYWE2YzQ0OTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDyLSu2/8lFdtrKfJU7PeOgbl879Eo0mYYPQCkNZvCHX+GFyvYPt896cqcxpc\n7sQY+mtrJvC1WVH3BuKj0LteZqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUao+DSgAM46xHT2f4DlPW1g1R56AwHwYDVR0j\nBBgwFoAUCJ/HE6MUfwn1W5vnNr9ZwtrZzhYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDUwELDosJbMOrT2pj/bguClhORYiYb4PqXSZ8S/HFaFQIhAN0J+VBih1cD\nqea3s/SjwodOjZm18paLj1BbzdO59gG3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWObD3AnrSthDRR6Q566+0ZtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTcyM2JiYi01NDVhLTRiZWQtOTYxMS0wNGQwNzUyZjQ1ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJEXqanxjXqc93CVNPtKFDxhL89UcV5Z3iu+RG3sOMI8bf\nQZ4gDV7IdPDxkdZpgbIWdTQm1D/ffNaEh6NRR5tXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCJ/HE6MUfwn1W5vnNr9ZwtrZ\nzhYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN9tTYAjuW3EsW/+2maW+LvDyVKj+UaOKpOPOPKBNCSQCIQDH+WTHdo7V\nmUSrOLvOUklySsVHaHNl+QD08cB7eyjjcg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAfEDm4dBIphQsircWad3bhkAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFlOGRjZjItZWU4NS00NjRhLWI3ZTctY2UzYWE2YzQ0OTFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYzIwYTJi\nOS01NGI3LTRmMDAtYmMxZS0zMDlkZGY2NmZiMzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATO+3V4ncnZfc4nrUaWh4cBABbSsloMRqNxVo+F4dI86fJOqj+Hyt5A\nDJo0vmYnix6Iwta3rwYa2BoobABTMGhxo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqj4NK\nAAzjrEdPZ/gOU9bWDVHnoDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIFTALKAxm0hcpEI6WL2717tlvyBr1x89oJwZYpoy1lV5AiA3myH7tvtoSo+6\nZGcY6o+TERnpPL+naXkX6a9+yem0Cw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6049", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6049` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbktX+09nXhcFlwaXvhJdGbAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzMDYzZGNmLTlhZGQtNDBmNy04Y2E4LTBlNDM5Njk4YTgwYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIzNzRjY2UtYzMz\nMS00YjAyLWEwNjAtY2JlZjRiNDhmYzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8QjTy1VWoyIzH6Bf2IA3KEDvgAW58MUt2aed0WQbPbv86XCGK5TDXNhbaxUs\n7GcYszTIxfdr1yAsXdF7H6XP6KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrdUUpanE8NGSkWUVZpoJJMDTDZ0wHwYDVR0j\nBBgwFoAUHTjzDYWOx7nqdJ4aSsy6TCEDsV8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA2B4pNVKOJaPLsLzkbZJ+nz7oonxVEMl87OvTDtv0h+8CIDJoknkDTVs9\ng8xCCSRLddBnWKccrl957dZdzcBWW0R4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcCKx0Lazqi1W90SB8zMY8tYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzA2M2RjZi05YWRkLTQwZjctOGNhOC0wZTQzOTY5OGE4MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmVOez7SenuKav62Pj0gv3PjP6oEAYwwLVpBkv8mEL7bMy\n17OpgCUShnwPUSfMuO+F76kzFUChTTUr6CT9LkcLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHTjzDYWOx7nqdJ4aSsy6TCED\nsV8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRLAteC0VP3HpdfqzpuhlRgRImqnPZbE0coq8s7+O2N0CIDMnUQMGqGbv\n6FA66lvhg3B6kU5q2VTRN5hSfVJqL2H4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAYV1u02CYn43UcgJQkBY7TZqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIzNzRjY2UtYzMzMS00YjAyLWEwNjAtY2JlZjRiNDhmYzkwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNDQ3NmZk\nYi0zNjhkLTQwZjUtOWQwNi0xMzhhODM2ODA5MDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQBVz5QkqYqw0QZBBNHy/23DkeePbk2nMGLxrq/cRCTUA8eatSfRlLy\nWivDWSNcjhnq4pVj2gKK3ObMduFySkWIo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSt1RSl\nqcTw0ZKRZRVmmgkkwNMNnTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDM7wUFooE8Z3am8LHvZarmGVGtE2JicwHhMZxpnaFRmQIgaGclWfs2aC/I\ndSCyrgb4SQVfrgRGUA17x9scPYeiQj8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6050", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6050` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAfHWIO6UR8OFFw6Rm+7x46+9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiNjg2Y2M3LThlYWItNDRjMi05NzMwLTNmMTVkNDY1NjNiYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZlM2JiYzktNTk2\nOC00MTJlLWJmZDEtMzUwMmE5YzE4ZGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiUB8fijwHhU2PkSBNpvSZy42bbDzp67vbeYKpbelqq2L+7pxUVvNU1fw1EbS\nuQmPaWLdtdqxVIkQm2Gx1XdUMKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSFKDFmKwR5iLiuoVhAZaLKUsJ1gwHwYDVR0j\nBBgwFoAUgIWJmYCEAkHXTMCQyUevZFjpMWcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAw04KLbvNAIupCaoX7E0aiz3SMuVYwWlUuH1Hjxbk\nTHsCIQDh0px6JS/0inABdE7KoItTLBzB+NmxQEqNt07/abWsyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZsujaGbvyxbWism3W9xCXnLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjY4NmNjNy04ZWFiLTQ0YzItOTczMC0zZjE1ZDQ2NTYzYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMAIoQtzGD5MVvM44MWLtOJ1UGHx0y+0HoTIQTrXiwEvtE\nPYuJ/p/a09tXSyEV3PDSnT/l5OZk2Uw8NnrS9kEno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgIWJmYCEAkHXTMCQyUevZFjp\nMWcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOEF9yVAUyHkXJBH6XE9A3UUolg0XQ8D79TuCXjmbbcYAiA4JXgjcBCz\ndr1A2+RyvBldEqyxI4cKEMKIiZsSvHeUYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAXb+lYVWrljPRH1LpGGx9drtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZlM2JiYzktNTk2OC00MTJlLWJmZDEtMzUwMmE5YzE4ZGY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MWMxOTg4\nOC1mZmU3LTQ2MTItYWE5My0yYzkzODI1ZTNkODAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9JgAf3JdRrBwSImvx/bVvn0fuOrMCYwvQKZT2PWNKdDUKrR6COsGh\nZ9rioJ1yVRZCohGpgbq6FxdCw8KiBxRoo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRIUoMW\nYrBHmIuK6hWEBlospSwnWDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIH4vM65O7bDke/WQjTUToWvvYyHVAuszS6DMUowgpJrUAiEAy+RY3lDczmJD\n/Iwc+J/VAdGomdPxoD/uxlJEDPRShHw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6051", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6051` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUlFMUeSXjlahpHn5/zdw7NyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NzM1Yjk4LWFlMTUtNGRkYi04MmZjLWQyZDkwZjIxZTM3NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRjMjQyNTEtYmZl\nMS00Yjc1LTljZDEtNjYxMTcyOGY3ODhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE00ZADhhwYjm5XTgesY61FEH4Ij9ogzhQCjn5uNZ+CCKFi/NKM8BkdVq4GrLW\nTYVbBP8xn0mATEtMp57RbOahM6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU46BP6sXgohna/gLKAdZkaSQonG0wHwYDVR0j\nBBgwFoAU5LXBHkpejkqZXeznf/toepeWLqcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAn01dg0TiT3sOkUxyvPZigE7+pXziElXpKbEbxbMKO\nEwIhAJPc4esjThvcKxlvblew9DfiLQJg5sKlbusyAXs2YWm7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaDZrHIrPZCtPlPvLOvqh+dqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTczNWI5OC1hZTE1LTRkZGItODJmYy1kMmQ5MGYyMWUzNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4u2zqu9ZDqwFf3rv/Kp6aJjRsj8tZkTbOqWxLJSu/YQfI\n18+cXtfP0U+rJ3JFC324Pub3FL3GhRAF55NqKoQjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5LXBHkpejkqZXeznf/toepeW\nLqcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPBlJwKe5t743TYhsvfBiNNhstn0WXm7oWr4NDHOBkeuAiBP8HbcODiX\nVs0W5XJnwZHoD4x03AOOG0pzER3bfCViNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISATB2rCf9Gtlr5QjB02gb7tKPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRjMjQyNTEtYmZlMS00Yjc1LTljZDEtNjYxMTcyOGY3ODhhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNWYwNWE3\nZC1hMmIwLTQxZjYtYWMzYi1hMWRjNTI1M2I3ODcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASgvNw+QbSVnN90ryPlglZekdj21dAT39LlhVC+QXpyd7YbWzbjojhU\nIzksNTdfsIRUMWbq8C5WAjIopTRnPuY9o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjoE/q\nxeCiGdr+AsoB1mRpJCicbTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDw+leF/pKbeB4UnsuYpcumLh81rhZkdeTyodFDkS+hnAIgTPkODOmar2xR\nTqnI40SPRtDFvmxRRn0Rg2mYgV9V54s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6052", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6052` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYNLT36h1I1iomD/2Dm++mbdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlOWQ0MDYyLTUwYWItNDY4OS1iYTE0LTIzYzJiNWYzNDA4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZhNDhlMjQtOGFj\nNC00OGFjLWFkN2QtMGQ3YThmNjM5OTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Fg54v54WGueq7w+VWkX3CBVlL40TaVOLRaeVoXj98n4zwMvkQ6BkTx0/UPm\nmgmzk7LJIGRn789wirvzG3SUaaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHwKkPtxYZint4Wfe+no/aUYxFlAwHwYDVR0j\nBBgwFoAUe+C/D8BP73ivU6HhED9RSaX9nKYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA0m9oBQNWUgD+R7XpStAXbqFVjqFMY5lrz+qLbho1ycgIhALop\noi6ssumd8AZlaqZvIqZ3Sr2+fHD8bhnjO0gz/POu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZSLa67HRJ8gGkD9psWPaiPGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTlkNDA2Mi01MGFiLTQ2ODktYmExNC0yM2MyYjVmMzQwOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKRXniYeWhbHyyUQ91I0YW6l2TWiiZl7/61M3Hznx56Nb0\nKjfOfZdNTSdn7X21R8UuHryYYzDqG1g+I93QR/Ago2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe+C/D8BP73ivU6HhED9RSaX9\nnKYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRHiT6l/SA3GF8ijv8tJxyw5C+2WDAalV/dxhkkUBA+ACIBLLcEFwEn6Y\ngEswuv429UVWAi7/ctLjtcBHmVbmpFrD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAfEbfxLR3wlLlFwK8o4U79ZRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZhNDhlMjQtOGFjNC00OGFjLWFkN2QtMGQ3YThmNjM5OTNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1N2I0YjYy\nYS03ZDFmLTRhMGUtODA3My1mZmI1YmMzZTAyYjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQFT+8Gk+XuHI1oAvHJYyt5yE24uoA9X6fQMTE7FNOe/gjM9mpaclmp\njYj7lSUe0QNakI+aa2n98Sc79R5EHBV4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQfAqQ+\n3FhmKe3hZ976ej9pRjEWUDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQD37hJjzdzqyNRltgEcwaL/XR6eUaK+PeQjl3G46y98cgIhAL9NAW6+9pSS\neNgGJK9s18YWyp1bDgFE+eSOsecc6/MM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6053", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6053` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQLyPe1L0Gy9LKLGwEHbJkZcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2ODhhNTAzLWIyOGUtNGZjNC1iYTdiLTgzOWJhNTdjMTUzZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNkMTY0MGUtZGQw\nOC00MDVmLWI4NjYtZDM2ZGRjNGMzYmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEiZmzojkds3S3epGnBUxwyKBLxNP0T5AQjaC8IeX17OsKRyJMNKFEzusqHqV\n/Epfh5cGYGuoV8pQLp5aVHrKFKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvz9PVj5Dox9AY88H+P80L7WPAewwHwYDVR0j\nBBgwFoAURbQXOc9/2ZRUS5rZp8A31/tkVKgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAtd5UE89iNfpnVoqoUV5KReg4L+4ojqa7\nqnGd/NnwyoICIFWpOjWwLbDtax1mk3vKh3mu0HwDQxoQ5yo3DYa7vTO9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWdDZ2p/h+DoMZ9jTRddxFGZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjg4YTUwMy1iMjhlLTRmYzQtYmE3Yi04MzliYTU3YzE1M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxx7RhfjFpGryOt7D9yIfAfiid9UKo2bZmw7eWSb26d1NV\na+UnBHPMmrO8ya62vfzL+3fukjjXxV/UeD7P3C33o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURbQXOc9/2ZRUS5rZp8A31/tk\nVKgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMiMRmsi9zFW3ydwgPApec9spOb15fW2fakY0NnC/yvSAiEAmynNqgGR\n/GEYQZWv6kBRA+Bcci2ua0qa0QUcJ49AN9I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAUP/o9IZYlIJzYox3HOmw3o5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNkMTY0MGUtZGQwOC00MDVmLWI4NjYtZDM2ZGRjNGMzYmJkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZTVhMDUx\nOC0yMzJhLTQwMGUtODQ0OS05ZjEwYjNlY2ZkZTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS/iqV/GESnYtNRYgZJA4yLCOFYqbM5Ai2o0HMZSaf4lwXMk3WH2dQT\n+2YA302IPi9LJILNrqve/+65BDHDyhtco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS/P09W\nPkOjH0Bjzwf4/zQvtY8B7DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCcT5h1fHkb4ky8r9V+NLmAVS9Cx3T/et4yngCSBsEmiAIhAMVeoLHBRm4q\naXB7qsw/qB/gFbgiRWEvznF1gWleRL3z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6054", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6054` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISATDXXtgf75ebl4yeBNCcMhW+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNTFhMGUyLWExODEtNDVlNy05OTFjLWYyYmVmYmQzODM2MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWEyN2ZhODYtNDJj\nMC00NTMwLTgyYTUtZjA2NjFiODdhMDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErL5V/DQlwD8K5QkJIy0MRY7FkJV8oK9t+LhVq6O3JqSAS8J7NI+NonAvmSqu\ndxnFoSG+aOFUi2b2/dcPJwk4IqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ePxrD+OKoaTONBeY+hXdJRpcJQwHwYDVR0j\nBBgwFoAUsQeeS7xk8xi82P6AjEJgPNA3T9swSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAyUeve5lGrd3OdkRKu5Uq8stNbfsaGIiP\n2+hDeGeraLkCIDBarwvskgzbIwmSXV82johd9H4kUE35cyd5eWNU0Xca\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU7XpmYCHTlmoMAL/RtinYwtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTUxYTBlMi1hMTgxLTQ1ZTctOTkxYy1mMmJlZmJkMzgzNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ37GujQSxtUTVSxWZaSTDY2vVmfMdiAFv9JdBunWHQZnuj\nMMan8JLHXv9eGE75K7mdjLRD/xu74b/P2ojaKZl5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsQeeS7xk8xi82P6AjEJgPNA3\nT9swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXqcsPCvsJ/IfYgwYwXjNkyqP9X2y1yf600wBfh7nNvoCIFSGSedlpYHP\ncD76H6uetN8OxtU3B8i4SN9rnqqZdaAv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAXYSote6IaH2eNoDpCSu02/2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWEyN2ZhODYtNDJjMC00NTMwLTgyYTUtZjA2NjFiODdhMDViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MDY3YmRl\nNS0yY2ViLTRkYzMtYTk2Mi0xMjBkM2JkYjAwYTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATBF+p9FipmU9zteJpNWa+sz1Z8fKmGwxiXxwvjY7QJXNcyCIO3t5lf\n5FBqhDRuV7jINGpMX5tJX/athFIsP76Io2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTd4/Gs\nP44qhpM40F5j6Fd0lGlwlDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCpYQCfzGjvbsa/2EvAT3JfOYp9a6Z9s1foYNIzBO3PVQIgWTkX2gP8JqTm\nnS4oWlS2Yr6kzWgtIuo/nwNWdAkkDYU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6055", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6055` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAWfbuVffLSTw3WGLXRHm5WVJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5OGIxMDhkLTg5ODYtNDg3ZC05MTNjLTQ5NmIwM2ZmOTlmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk2NDcxYWYtYWQx\nMy00ODg0LTk3MTctMGFlYjQyYTYzN2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuW8FlRa0lSl6RxStGRpmzkdZzKOnjQBHE6C4bQ8rTEe3bnXQHnP5bXM78/jD\npQYiZNGwldq23kiyXpy5h02wt6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyT5wZth1ZASPoy3SBUXve3xuYq4wHwYDVR0j\nBBgwFoAUaHrGaMvVLAO8pVuT1hXKF2PJ8qcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDuFt3Rdqwa7OgSmBi3p4V8WD2f\nfWRvlOwRIGF8dbdO0wIhAI8dMUNnBBc//1i/Pz2lsvIOVbYwEfWGgyCP3T9xY8MK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXcSOISKOChGdl03Sp1QpWqpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOThiMTA4ZC04OTg2LTQ4N2QtOTEzYy00OTZiMDNmZjk5ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSjlUC1bhUDSErWn1PN7kf6+u4zKOfqqpLBESlOu4dAFzM\nuS+Z2UTp74ADvhgnD9IfKkMfYThT2nNbx6Lb/uRRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaHrGaMvVLAO8pVuT1hXKF2PJ\n8qcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANVTyLd/tR5w8jogL2qikDtlNixNcri3MwdVuTvugQ75AiEA2HZZLNzP\numl1rBPTmi3p8Ab3tZUXqX6j0NpzuZTM3xI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISATVJF5YO1hzUlJZF4KDh3avoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk2NDcxYWYtYWQxMy00ODg0LTk3MTctMGFlYjQyYTYzN2VhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NmFiODJm\nYy05OTkzLTRhMmMtYTk0ZS1mOTQ3MDZmMDczNjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATJTreXWQhOe2Jr1HtJ1X0bY1wTzxjrrBE6i7h+8eFhQ5ywbSYguFzY\nKZV36UQMFTlXOioQFYzysGoWC+wmMpYKo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTJPnBm\n2HVkBI+jLdIFRe97fG5irjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCjKARX6CO7yEjb9bBolrh3S/XpiP26A8IGNqdSWQ+RIgIhALtqGIfbMGhF\nWVKHH94i0jRjLFUava5eAnr+ViqrAuWs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6056", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6056` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAREqFGaDvKxS9wPgb8VQNOqcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0ODM0MjRjLWI0ZWItNGUxOC05MjAyLTIzY2E0YWE3YmRhMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2YzZTRkMGEtMzJj\nZi00Y2NlLWFiZjUtY2IzNWQ3ZmQwZjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUWO17GEtCHdtLN3jUGNaUl5H73FrANb2ugF9v1rP0fpePf8I2RcVnTLrn4ao\n7D6prshqcVJ9LXPKmh6v/xZeVqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKt8+Ef5snh3Zc7G7GzuBaKH8sgswHwYDVR0j\nBBgwFoAUzxOZaEcFcthIoY9x11gKg69lwlYwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgVHxVQnHG\nqHxyrVUy1EKI8/KeJrcwNYb2qd3mUjzi1TMCIQDRD2gkLZs9D0sMKaTJ0A7bqozy\nSBrIF2BXbpEF5116hg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATi4U/xlpQXox5KlG1fUZqXSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDgzNDI0Yy1iNGViLTRlMTgtOTIwMi0yM2NhNGFhN2JkYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOJP8i0q297GcPhrW7g72Oqb3ffpPpnB14ERFJgLDUx7Hb\nyD2VN97g8DyrqYUpsOGUNRyCJKEgc+g/f7W4NXSUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzxOZaEcFcthIoY9x11gKg69l\nwlYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANQ/6TpRiWWk2Er1h4vFkK44pvhdO5VBLVUl4lOk5XWsAiB6YMEKoYpj\neY7DvhfsN+YfNmcR0e379HDQJYPUWwlIug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAbrx51apIBdNPCqIsmecH+XzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2YzZTRkMGEtMzJjZi00Y2NlLWFiZjUtY2IzNWQ3ZmQwZjFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZWU1OGQz\nMS0yMWIxLTQwOTQtOTE0ZC1lMDNhMjFkMmYwNmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQbl6OVyQ9FEac41Mu4HV69ZTeUZLNS+d0wI8/TOCAZFD9BaQIk0xWw\nVf1Vgplr6vk982ZLRumHFlQRYUk8Ousko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQq3z4R\n/myeHdlzsbsbO4FoofyyCzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDe5RsN9K29ehtL0NtZzLQFxSqWS1V1NyWAhPdrDCFZkgIgJrAAX/SkIc6N\n+IR+wq4FEKMx7Yfs2/+NkqlSHiP2d2c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6057", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6057` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAdIpchsN6dCW+bneeauUgGpJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwYWExN2YwLWY3ZDktNDhlNC04YjNhLWQ2NGMyYWQ0NmJmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdlZTdjMDAtNTQ1\nYi00YTY5LWFkMjItMmExNDEzNDY2N2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4GfD6xRBsDdbRgDo5Xx+rFFZQg9Lrz+omGnCYcahdwG8hmd0ttCMTQFl93El\ncN0+VJrWcn9hKaMXN3WZ4WOMx6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuUHOQiGK1cH9Ict07EM6bHd9PLkwHwYDVR0j\nBBgwFoAUasFeqQ699SG6cYsdLuwilShKr7gwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgK9S2kZUI\nxIvfOeajpMBVwgahJIdnAAITOaFs0f7H4bICIC1CPP7m29WZYtiyxi1BVMkH3/4p\nLcZn2AAkSuZj070+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVlAtRXpg+Qct/yQeBGm7UNRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGFhMTdmMC1mN2Q5LTQ4ZTQtOGIzYS1kNjRjMmFkNDZiZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdDydZJrRtWdn2q5DV5dBKVJYwh/mT/YhE5bgnBUO4NL/B\nE+5bO6JpaLtuxyhWP4xEgwNzSop4QI+gaF9xh8Lvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUasFeqQ699SG6cYsdLuwilShK\nr7gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANHlzGu6jel0g5QQsE4D7k9c/sFBoBHCc5XYaBkgR1o2AiBT0H+jyLKx\nyiDob0znN2AGMUV5owevyuz+OGoZaZADfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAduv+dRfFC4hugwYr7AEOHrtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdlZTdjMDAtNTQ1Yi00YTY5LWFkMjItMmExNDEzNDY2N2QwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNzFhZjU0\nNS1lZjRkLTRlZWMtYmRjYi0xN2I2MTZhMTdmOTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQvG2pxCZP+RButXo4ULLrPAlRmW+4GkYnomL1DFCICQWdXJikQPc21\nJbidXKQF7HyUE1HyZK04j5PoUQ+IaDFoo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5Qc5C\nIYrVwf0hy3TsQzpsd308uTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCZMwfumj0TfHPVMkFKig3OtZwjYKR+GVa+J9GfwNVuuQIhAIpjlAmHMBTq\nN1p96PBxnxudJakXky0mYEyx/B21zc1s\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6058", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6058` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISATBUk+7oPZ6H9qa7AojxIOrBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkZjExNDI0LTNiMDQtNDIyMi1hNDM3LTFhYTEwMDFjMzJmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAyMjgzOTMtZTI2\nYy00NGU2LWE5MGMtOWU2ZjMxZWJjZjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi2xrfRasN5YkuhEoFaBo37/GAQ7YVB5vXKWC/gBsKCUocP5pCi8shw6ZGF2S\nL7TfFUvACPfutIleukiSrdWx7aOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoEwnU89wsqvoWpncjxD818O6MxQwHwYDVR0j\nBBgwFoAUvDbhVpCNRH4rNqZIkdyLeRRS5IYwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBeDgiqF\nL3wQmQEUSjtMUQrb/eM7oR19oELFzLJjKG4eAiEApO3WffYdezKDQ4L1JRm7hgiP\nsm3Okan+f/c4W8IIcZY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbFdUhRBFhEsLlk0i9g0c++ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGYxMTQyNC0zYjA0LTQyMjItYTQzNy0xYWExMDAxYzMyZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATozjv+LnUhSjamBe2oJDASujIATdpt0YKT//3GYIDS6nJR\nbsUCSyNnnRuLsZar+FvVGAzpHojrDjPmLZ5Hwurro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvDbhVpCNRH4rNqZIkdyLeRRS\n5IYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPnHGUwUp/aM3h35EvKQSD78g1Bk0Zcy7hNKxKq5JCbtAiEAmzdpQhuY\nlJ5HDy3wa6yW7mDkFjSGCK46tZjYWt7dOeA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAa9pADbjl/0LdKOF1vDrcfDWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAyMjgzOTMtZTI2Yy00NGU2LWE5MGMtOWU2ZjMxZWJjZjRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzOTYzNTRm\nMS1iNzBjLTRjZjItOWExZi03NDljZjFiNmFlMTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATW0yjnf0ZpyYi47vGA9WyuInZESi8lmdJqQE1ztv4Ir0Ch7LC8ac1P\nWKd7nvRJYg/LK+QwgYPov8wh9KwtMSBgo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgTCdT\nz3Cyq+hamdyPEPzXw7ozFDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDOaEhvA6x9PUY/FnUifwt6/vcCCs0Qppxnu8DiKrmeEAIgan6POtVRH7rg\nQ86AFYXUsmagtH2b6qlyAiHKTYcWn2s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6059", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6059` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQjf5ei5D4yZuXcq9/FxUqffMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwMzYyMjQ0LWVhZTItNGEwOC05MTM2LTQ3MmI0NmYxMWIwYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmJjOGRiYTctYjdk\nYS00NTE4LWE3ZGYtYjI3YzFmZDQ5MDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQsc41ILjkDRX/TilkGRIdFEkBZ5wi69cp13os2+hWpI5N7d8G0fMH9zMLJra\nbFUc+msNGfPMRmUWCAs2gHCRPqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdHjHgFi6tGkijGfmbDFfSVjXGO8wHwYDVR0j\nBBgwFoAUegbqHTNw41w4V6oPRyy4tBahavYwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIAuotWPZvnGxvzBvuHAQieL8rVw+hVDG2H4X9mJA7UnBAiEA2Wg9P67s\nCGY52rMynHxeI9xq1b8p2mOcOYu0yXY80FQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ1X/21PhjE0l8MU7cy1TUkAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDM2MjI0NC1lYWUyLTRhMDgtOTEzNi00NzJiNDZmMTFiMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgDLA9CzGkhoJ4l79r6bje2l3yRNMs1dILmJWz2e7tW+gn\n0nzNYCvx+W8JI/hXJ8vi0YdVZq7QHH6ANGHXGBl4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUegbqHTNw41w4V6oPRyy4tBah\navYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANb3i3HF8CUUkQd/Tby0koO+rUpA9ZGdYhAQN5sY1UVdAiEAj4Bb5G9y\nHD7VQEyAS365/1sW5IgXRAaYs5C0PF8n058=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISATAHM2+82EOxSWP8XF4vUOnMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmJjOGRiYTctYjdkYS00NTE4LWE3ZGYtYjI3YzFmZDQ5MDE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNzJjZmRh\nNS03ZDBhLTRjYTctOGY5NS1lY2I0MGI0ZGY1M2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT4a/HfZDTTyvIgJmySTCTU424h7oWajUOvXjpEtsyd5SiekPSUUhKf\n6RW3Wsp4sEFm0WlKm/z2zGtmwCnOcVlJo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0eMeA\nWLq0aSKMZ+ZsMV9JWNcY7zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCICy+UzSoMd9kkHqTm0El/UUzcWfK2R5qxrbDybiEdwNdAiEAhuB875DAqYkJ\nE7TOe3tLLmoOVin9fqSsK6mpK7i7tTs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6060", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6060` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdDqSWEWyVcd43G7PuXQU1aNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlNzA1NTYyLTNmOTAtNDlhZC05ZmZhLTNhODVkNDZiYjIzMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNhMTYyNmItMGYx\nNy00NDIwLWExZGMtNWY1N2Y4MTU3NTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7IycoHmn2d5rvbivqApa2oFNKYlBw2s80dZQ/LJjavbEluQa3LW4+PYVgJcH\nPu7qS0rjRL7ZS0T7GCCyQd2pr6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVUSA2T1GNosgYG0hsDyzykYrEzEwHwYDVR0j\nBBgwFoAU6X1xKB6Azx/CwIktyX4JdCv+rikwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIBeLuBcjA2EbAE1e1N1RF2l8iAd91UXZgEM5zDKTJiGrAiEAi2X7r2o7\neE+R0hvXWvvOpSkzTjjiS7dsr79jU/KoJQI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdjex0zvLMsfI9r52B4cdk4+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTcwNTU2Mi0zZjkwLTQ5YWQtOWZmYS0zYTg1ZDQ2YmIyMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsJmqe5Bu0+XPx3CAGboSVUIp3Lfseljdkym+LA0LoNSR9\ntsSFt7LJOcsL8vaiNYTnNOCzfCnVli3WLva56zGAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6X1xKB6Azx/CwIktyX4JdCv+\nrikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOeghtNwtqB2IgJuQ3wszBRMmkl7EAvZHyKFu9lfuSYbAiEA5IRtpe/V\nrqEeDon5hb7Bx9VO5r974+nM19uXOae92TA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZ+oejAW6FTefoLt2TIhX0qAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNhMTYyNmItMGYxNy00NDIwLWExZGMtNWY1N2Y4MTU3NTkzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNTA5M2Rh\nYi1jMWE2LTQxMTctYjhmMy1kYWQ2ZDAyMTQwY2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATWwnr3TjmJhyx4GzpnK850PxFyelZZ9ZnyAjLYj9rOYqSnFQv2qVDO\n7PI7it+D06LPgMBDev02+JHsr2dgH/2Jo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVRIDZ\nPUY2iyBgbSGwPLPKRisTMTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCA4pI7dzj0TixSPvVT2xBXrDcuwyORSY6TxfCksFlTxwIgaVdeS0zIwPEe\nxAHe4ro3DfRM0Vomjc8+J7IammqS7m4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6061", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6061` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAXjiec7QsCm4KiI+wybwRpIIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiNGUyYWRkLTA4MzQtNDJlMS05NTMwLTY0ODUwN2ZiNTQ3YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBhZjU5NjctMDQ5\nNy00M2RkLTkyNGMtMjM2ZjYyNjc4YWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0P8nxxnbNrdYi32rRnfgH1iNGMt4ur8BrRXV3dkHA28P7afM3qIPdEmJ9eYC\nLss5+jXP1HB7FD8/VWmuMCXs0KOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm638dZuBKSKvBiucFVowBEF7JYEwHwYDVR0j\nBBgwFoAUxwkv5V+gOqJ6Xh7VsDzkVCMieCMwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIG5TMSN7he0BkAZSEAkdoEDxCdHJkHUqe7DqQPYtlmT9AiBG0cgt/i+7sYQCuOuh\nQ6GFIL7RsqjGHPOLfn9Fo5fS3Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVTFCyhV9olqEwTNjy+bJMvSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjRlMmFkZC0wODM0LTQyZTEtOTUzMC02NDg1MDdmYjU0N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARA3tJ+V8B4pRuNaNlcAEJQUIKsmyhk1GuXnrX8X3FJrANI\nqDWHVByl5TK+fW1hng20hy2fHkiKYrIbFp9rciL+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxwkv5V+gOqJ6Xh7VsDzkVCMi\neCMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKcusYBGNOVheI5c/lw7URtGh6bC6zDvMtfbhtkWyd7jAiA5FcXIxQML\nQDhLdX+PtQYFMPfVIii3EwPl/tHl5RCgQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAW2GkLyhCAlQWTtzsFuxI7XrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBhZjU5NjctMDQ5Ny00M2RkLTkyNGMtMjM2ZjYyNjc4YWZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4N2U2NGYz\nZS0zYjNhLTRiYmItOGYxOC04MjA2MWIwOThjMjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS8ZGIEYKyHAPHmlVoFPOhh4ismnflL7dE7F/iqwrhw2L2XViFq8Mp7\naVi8LjK5U178YleKpplKEAkadqOpDj6Fo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSbrfx1\nm4EpIq8GK5wVWjAEQXslgTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCfMyUKb30FKWrtNM4hR3CHsy1EvTbP1XWZO2ajMRnuvgIhANIUnhsCZvKO\nwy0TyCcGB3khA/lN4Qrz9Gqa0ybxiB63\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6062", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6062` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAQG5G9wMBHszkW3tQqQsDg5CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwZjg5MzY1LTgwYmMtNDdiOC1hZGYxLWIwNDQ2MGY0OTcyZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWE5ZTAwMTUtOTI4\nZS00NTRhLThlN2ItMmRjNzk5MmFkZmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYbymntVCAUKLBDZdsfdQ5ANlUD392iwSb8N8+veTZ/Vu5yEh1vTF7S2ZJ1Gp\n9r3iB+1b/pcZxVZAEOG+2leX6KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoF1eQqQ/Rmjds068jUKXTqbW9gIwHwYDVR0j\nBBgwFoAUdR4/wxN6LOm+QEuVEdqwa1rIIOwwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCICHzZWv5X/X/h0B1vZ09Ydod51b2NvIATiP6b1MqADPXAiEA\n0QmzqF3r1uVZbBuoPtKC1mBmdfXzeogsw9R6vxjLC6s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZtUZf4bdsw7iFyNW1QUawuqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGY4OTM2NS04MGJjLTQ3YjgtYWRmMS1iMDQ0NjBmNDk3MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrvEJK4/NAQOA6CZaaOIjvwF7ITlGTpFP82I1QwN/50PP7\nmLiKlFp9cU+TuiYvJX9KqOgXW+LrJK9u688GBPM3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdR4/wxN6LOm+QEuVEdqwa1rI\nIOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMJO5VXf3VN1PrvO/8kzZR2Opun0C7JX1wTX6M1plac0AiBFjFrEivrG\nk1lGBliNEsGSxoFCDtRsfHd1ahVSYyVhDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAdXu+DgYEouk0XaT0kHpbu20MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWE5ZTAwMTUtOTI4ZS00NTRhLThlN2ItMmRjNzk5MmFkZmQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhOThjMDlj\nNy03M2U1LTQyNTctODNlMy01Y2ZiMzk5YmUzNmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQHyXyicJoGvGzC990LcqPKti8YZSscJZiqvDJOJYZpbTnWvumOCG9v\n3q0nbXnQCktIvC0To0m5C9SMMV/lcb3So2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgXV5C\npD9GaN2zTryNQpdOptb2AjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQD+AtX8/uQHHs9ucLtChWqjTHQ1S/PFb+OXToeOrgyhQwIhAK/GjRStCnHr\nn2n9DS0ZMdnp/8bOPCxIqBRP9pBO+R66\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6063", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6063` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAQ7kTFrj4PScqCdX81O+ALSHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwZjBjNTk1LTljNDQtNDMwNi05MGZiLWZjMTZhMzVhMjQwZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY1ZTU1MWMtMzk4\nNC00YTEzLTg2OTYtZTM4NTE5NGQyY2UwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENlnfFa/iYlMH1uICqjrRuMHUNYYqRBC2+NppOpEp3p/nIdZp4BFlo/EKsYFo\njwAM+T7/WBo6ePgHSK5F6qqCHaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWONWromFoGtCRHOqTEp4WLGvS7EwHwYDVR0j\nBBgwFoAUJCxfajEMrzpXDquVDIGkcZjRkoUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIHodtrvBDp7kP/1tdxM+S89MWS1DiA0sZ3DDbBtCMesOAiEA\nmdj4EetQRtvxJ4yaUu5UoiYR2aYu+U0Hy9xj2eAb2dI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXvg8ukb9UpNHRNNmHFiR5t5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGYwYzU5NS05YzQ0LTQzMDYtOTBmYi1mYzE2YTM1YTI0MGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVeuKQtOoz8dlpboAkHhqdEo7PBUjkZlQUsebWA1b75ROF\nlinOc9p77mKfraiF5r4sxjPRfadp5rloHceQNIPEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJCxfajEMrzpXDquVDIGkcZjR\nkoUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKclyKpYFOSQEwcnS45ZlX8Sgj8UhkS137SqcAfNjK8aAiEAq/wTm5PS\nx7OB7vGOuK62rqgLgzWEL/BJyg1G+SviLdM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAZ8KEWpmcy08WotN02eWG+0AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY1ZTU1MWMtMzk4NC00YTEzLTg2OTYtZTM4NTE5NGQyY2UwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OGMwNzVk\nZC1hMWZlLTRkNjEtOGZkNS05ZGNlZWZjOWZlMDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT4n5igrHWdlQCDZyWUdfXLv/59F5rjPEbH17WMB4Mfdt9CU9+WOgs/\nD2Gi7CsWrxdGXG7OAykSn7Rnj1r8Pn3No2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRY41au\niYWga0JEc6pMSnhYsa9LsTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDtoIvxOM0+Jayq4PRhxGEkVciDu65cHHEKK81zpzgNYQIgTekc5N3eYJ78\nr3RHXibU2shQl1lwe9TfsKAAKkToGEc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6064", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6064` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZhJIULPg8u9AijcuXDFDFuVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NDhmZjYwLWM4ODItNGZhMS05NTI1LTY0M2MwOTM5YTZhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk4Mjk3Y2MtNDkw\nYy00M2M4LWJhMjYtMGE1NzUyMDMzYzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqQgQfbPMpYRs7N27aIgcnKg3jjsqC6UGqm/kf1JTAQIU0bMJVqkv9xRPm2mh\nRsYmKBa4W9QBBC8sJEj0DJ98Y6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO8nAoSVxH3cQXDT9MyJAN5mljOcwHwYDVR0j\nBBgwFoAU1iohXSh7ocnlFWLoP1YaSdty4J0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICq+9pvXxIzm\nbt0TOzD28hwmtYHXHLVAfi661kAW7n+kAiByeT4WUZATrNjDz8mCxJhhty+TNXmv\nO/dZjhoWtn7E3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAccsVj1ebth3a7npupi40izMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjQ4ZmY2MC1jODgyLTRmYTEtOTUyNS02NDNjMDkzOWE2YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASi71mIZL51jQ+ab72EDVSTBpFBE3o6h4Im4LOnmVKK4Q2X\nanVLW+JMj7Xt5VeAlELKxV4iUUXtx7RdBuzGjlZZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1iohXSh7ocnlFWLoP1YaSdty\n4J0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE3ucvC8gPKrWGeIHczDD1KLXsKOrGudEtuw5gSk4lucCIQDD/QWA546R\nPzYEzb0mYlgzDdwU3H0iWPbctmCEu7QQ7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAVlMIjBfbaIt3zOBx2+n0vsmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk4Mjk3Y2MtNDkwYy00M2M4LWJhMjYtMGE1NzUyMDMzYzc4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZWU4ZTUz\nNi1kNTk4LTRmZmEtOWY1MC0wNWRiOWFiYzY0MjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATVjf9crU91kxxdmGAd3eu5ut+tIR833CcnU/YaHkXPOKZ++KmposGD\nqFqbs6a+q8ts1YQ21SHeYiFVW3pKZRUHo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ7ycCh\nJXEfdxBcNP0zIkA3maWM5zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIAGIZco8eRjvV1+m1q/vCi1/4WRSMxqP9wYxbi+0yh2IAiAyLOIn4R4cOWkM\nbU1BIgyP3tf5/ELvXLCJ7WG3Jyw7Kw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6065", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6065` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAf3E/+yz9R244RHfF9qdOVNGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyOThjMGNlLTA5NTktNDBjZi1iNzNkLWQ0OTk1ZjVmNTZiZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNhZDAwNTctNzk2\nOC00ZGVkLTkxMTktZGJlNGMzYjQ5YTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtHvJe2yfSngqh4SSfJAcIaL67xRNc3+6T6onNkp5CVMrXmjJgGQ51Ctomdyq\ncUbrccdwWBmOdxwi6KDhJ0x3t6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1zT0LTC9jfOq1FLjYrM2PmuF5iIwHwYDVR0j\nBBgwFoAUQYyNV86fhrYbm2NJrOSYlND8f/0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMREdbYQWow0Brc1x0C7+LS25uMa4654EqgU/hEL67olAiAU5PuLrvcR\no5lJhD+9dMzw7hHD4+SkfvIplGk76EF/NA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQvDecuyl5G68v9W2Ime9PnPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjk4YzBjZS0wOTU5LTQwY2YtYjczZC1kNDk5NWY1ZjU2YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1QTuPPCVGWY4f6a98yx5PjOKzJaCjvm2WmT4kwStqGD70\nb0tre9RUXvAUqzZM+fzW3P7HrwDGWIBrhRq5NaP2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQYyNV86fhrYbm2NJrOSYlND8\nf/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEiOqdEYgO+KUYZcx2DghlFjHtHhVo2j6PzJct5E6lcICIQC4ZI2ACG02\ngHgcfvFYik4PNg85MRVc7bqCO0qeMoYmPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISASOL2XAkpuIqdz8iAR5d9eLrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNhZDAwNTctNzk2OC00ZGVkLTkxMTktZGJlNGMzYjQ5YTBmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNWY0YjNk\nYi1iMDI1LTRjYzAtOWZiNC00ZDdhYTM2NDhlODUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQWPl4fVrbIR/Aq/XwalMTq++vaEFvtMt/11wqFQgPy0As/PLlpnhP2\nvQb1B54sGoyjnq1kvuX+0+nYatzwQYP6o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXNPQt\nML2N86rUUuNiszY+a4XmIjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCg6mUaJA4aQ1FZJ6bwGbqJVAg5HZ1ltHg56LwTYliIMQIgAMCNwiypm5nD\nWTCd2PaNjZ0zTrfhaM4M3qF6Aozrc4E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6066", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6066` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQJbhD4HakjagN9E7A0AymgqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3MDA3MGY4LTNiNGQtNGRkOS1hN2ExLWU4Zjk2MmNkOTI3MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg4YjI4YmItZTYx\nNi00MDZjLWE1NTUtNzMwNGJiODU0OTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp2aEmKTDmnYKcex2ZlpEiLzogrlr5XUMT1L0QsTo212X9LCHuMShXVf0ho8P\nOYIlQFMLslVTL8+9DNNoiJyrV6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvREu+ql2ZHoYyqTRMAJafpjVnYAwHwYDVR0j\nBBgwFoAU3Ez5iHvZlO7hNjr4vxFmio/qsf0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIRo0xIt1mt0fb8fP4SmrvqdzhAsjHg8A3ltPa0y0ZsCAiEAljju7Y18\nKx0cnQaCy5KwZfdSkVTQMw+3vv55v4m/IrI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUsqV5t2JQBePBFPFlKxgEuUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzAwNzBmOC0zYjRkLTRkZDktYTdhMS1lOGY5NjJjZDkyNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4RA1SsS3Tut/vNhTfyWd6PAGCUjioj65F1PsbBCfFX+7f\nk8KpKkbv/lfsc9n4mX2as8lUVlzMqGRomrSW8Qx1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Ez5iHvZlO7hNjr4vxFmio/q\nsf0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL1qSJdQTASWGJG/25DpzDrekq61TAdNLXRCUob/lmHqAiEAr7+Mp06o\npidCRGXYoWSbuiWYfRAhIXil0fTEObQFE18=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAXSKQnaLajFpTOlENHhub8zmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg4YjI4YmItZTYxNi00MDZjLWE1NTUtNzMwNGJiODU0OTUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYmIzYmYw\nYy03MjJiLTQwM2MtODU0Ni1mZjA4MzZmOTU3YTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATuB8RbYSAoxnDcnE10nxz6NiSbdWst+ccTebAWzEYl4RKOsVDM6oy0\n87xEFkSEtyNH/NTT2NOl8u7aDKUgsOyeo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9ES76\nqXZkehjKpNEwAlp+mNWdgDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDuGhT61u1LCh4uS/C/1mTUDIH3Q05vcMZcx25nhVHgPQIhAM0mn/7uu7m5\nH0Dup79b9j/tlTF14VZVj4s5SFyAIvS1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6067", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6067` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUiGfLoyo5iJRQ3I9rB4d7f5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMjM4NmM1LWZmOGUtNGYxOC05Mjc0LTllZmRhN2EyNTVlZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFiNGVlOTgtNGQ3\nMC00NWFkLTg2ZTItNGM3YzE0Y2FkYWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEilkx7OjTKQSKBMQMGcAz/kodP2b/BizlYiE7L2RKBbrzO/omSZC8gL5ef2M1\nIODQZEbS8kCBERrp7bYR0N+Kp6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9jLTWMV3UE1nBDWkpXCQ9vlJoSAwHwYDVR0j\nBBgwFoAUv3PgGFuY++TtwcZ/DheR84WVSIgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDI37i0HFFwoFsQLcdjkzK+wraqYCl1hLmSl0yxG1/+ggIgWvbOctgr\nkILBcJDdNb6jBPEimgQ4FaK8PuD9wpd90CU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWMyM98hD+ASe+W6h3MHAKBCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjIzODZjNS1mZjhlLTRmMTgtOTI3NC05ZWZkYTdhMjU1ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS792rAjd7E1gqhEQ2V0Cu1WqMWnSmQlE4m0SBrZtN2bKgh\nD5KXljbPqu+Z1dBgC0WmoETKEdOalmepFv9jB6C2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv3PgGFuY++TtwcZ/DheR84WV\nSIgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPqXRPEzNBNliWD/uzytKO9HNE+VpHqn4wht6ePIzmz1AiEA451xvG1t\nWHjyFOKT4mKyWnTLEUWK+syEIP/0NsotUh8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAfkrYtv1dTbF7OR5d1FB2oKdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFiNGVlOTgtNGQ3MC00NWFkLTg2ZTItNGM3YzE0Y2FkYWJiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjOGU3Yzdj\nMC01OGEyLTQ0NmItYWQ5OS1lMWJhOTczNDYxZDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATvVY18hREyzB0G3pkiBZbhEcjdJ+CGC+82dEDo1MTHOoy0UXjzkGBC\nPLuFgvLPS8M2a2YmzOhCtQRJboz4LMLHo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT2MtNY\nxXdQTWcENaSlcJD2+UmhIDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIHTPJoDegtRaEwMYZ2HQaskxThlK4XRDSViWJ/yAa+cIAiApvPvTRWwdeBkS\nyFbSvV5WPRjSf1ViMPZJkPF0UiajfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6068", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6068` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAQJs4r8vxy9FrXPZz5hQYZX2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0YjdlNTAxLWU3OTEtNDVlMy1hNWMyLTdkYTkyM2FlN2M3OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQwNWVkMjMtNzY3\nNi00YzNiLTg5OTgtY2RlN2Q0MDczYTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjrycniAEqWHa8m9z1cR6s4EI24KcHyTJTcYerrDU32ROuiQZ3dhboW6O/eND\nt2JivImuBDoXb2IiPSgSWjPTz6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiRd4kK8EovrnnyOrxpEOlSPALbswHwYDVR0j\nBBgwFoAU2hYpVQ2D2c2R+Q7dWoTRGL61bvEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDKXnjyxoKlgZNTpC8kPmoGigoo9K13aIOAyEqV\n60lCjwIhAPqudLloHJCH0N7xtHfxpTNnv82KVQ7STJVyhBFOy8SQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeJsZp1am70BoPnCXUD49j7XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGI3ZTUwMS1lNzkxLTQ1ZTMtYTVjMi03ZGE5MjNhZTdjNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATm+Ud9dQjooPyGsmbwyEgkKPFZ/CYasylQVz8Hjz+r+zrC\nfpjFc2rCxq26Jk2s5Colyeg2OkjVwzwr/FE2WDNJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2hYpVQ2D2c2R+Q7dWoTRGL61\nbvEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPZVwswNPdukdpgPzP77FMOKTA/nql7eod2ddKfZvvDgAiBJqDB94Vwn\nU3XTOxCiyut7pyqXs9BTAbAIGbKocmfhGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAWdKh8R+kszNlGteOfD5qR/ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQwNWVkMjMtNzY3Ni00YzNiLTg5OTgtY2RlN2Q0MDczYTk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5OGUyYjIy\nMy1jY2VmLTRlMmUtYjIxZS0yZWE2MjA0OGQ3NDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATBfcgI3W4CMp3ieuX3c0R82CC4+WIJwVCaBN9SQ939D4I6VOPPVxFy\nVi14S9Uvo2vnL4QVP3qjwOWS6WymyySho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSJF3iQ\nrwSi+uefI6vGkQ6VI8AtuzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQDPtDagDAQCMhApqj/Ngzl85MVOWiuvXKbFBFcZdyXpxgIgK4GjZc/Q7Dhx\n0WcxbEk1magxDz8gcflEsU1qfZ4jAe4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6069", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6069` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAVHH96NpU5BIE1zIp4n+iXqcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkZjczNTI5LTllZDYtNDM1Ny1iYTYzLWE0ZGE5OTkyYTExZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRkYTA5ZjEtNzEx\nOS00OTIxLWI4MDMtYzg3YTJmMDgxMTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESs+RMAdKIXKrTA79NKnAR6C9X2ZXM/MYE6c75rrTF5JoAxh9nSqJkFxhNITC\n1Cp76vd2cbcCIqdqvxrJeZn9QaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCwxgWh8vnFrQ4ZuqW4q/SZaiNAMwHwYDVR0j\nBBgwFoAUokhG5q1y+PulKbFZkJK4x/2zD1QwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDE27bpYh5UqJXx4WcPQJpz+g0HDIAXV+Jyq/+o\nUDt/OgIhAMpJf8sV/AW3wu3SgL3BrzElOXzdVkCdRvtDJnNcVrcz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZKUKkN4ECIMEv0jDZOWe4PeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGY3MzUyOS05ZWQ2LTQzNTctYmE2My1hNGRhOTk5MmExMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQj4U+2OPxcusU+hfLuQ1khZza2N0eWL8Waf4rhJCQw39v8\nPigcpp4kFp4QmLJG4atoMOM5TcAOrZXudrdcJ3K1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUokhG5q1y+PulKbFZkJK4x/2z\nD1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAObPP42NgRFIq65UkgyXTByvLjIR6kCTR9Smo6RuKwNsAiEAsqw9T2cv\nBdTxazDcYDQOPjPLqP375WQvLe+RquqVzB8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAaZYWP7QkS+tuN0bMMBsSsdwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRkYTA5ZjEtNzExOS00OTIxLWI4MDMtYzg3YTJmMDgxMTk3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNWQ4ODFj\nNy03NTViLTQ2NmQtOTY1OC01MjM5ZmJhMDFjODcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQvvI9gtgfqA2NUiQR8N+GjEqiFE0ckeFxpZM383Oa2WMde4WbGc3cN\nQ7v9vAnjOVZ5IGsF1tBwy2rYaAZm+lcao2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQLDGBa\nHy+cWtDhm6pbir9JlqI0AzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIQCm9xCiA42AmW80yO1H9WQIC216i8ovmhWlw685ZaVj2QIgBnGB3o6EYiww\nQz/siPYMzLy2QW4xowtUXWZqYB0znLE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6070", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6070` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAWCQorxITnXrjSrM2pF90DSUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhNTZmZWQ1LTY3NDItNDcyNC1hMjNiLWZlZTc1NDQ5NWZhMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQwZTYzNDQtMDU0\nMS00NmM2LTk0NjgtYWRmYjVjNDIzMzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH3+nAYJbHStsht5zk3SmUeZJkXCSHFaK3Z+3Lldcdwrrr6uWRsehi5MMPmIP\npJi8kfbU211AxahHEHTl1NVde6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU376wqxEWeHGpsKMNreBkOCNl5oMwHwYDVR0j\nBBgwFoAUgarg/wXG5ckLonWjQNdAF4BQGVwwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIFbbemnZ9c3tjFQArFc+U33UHQjhZMLjWRqGumeGWNWAAiEA\n6jvvxaTN30Lh+pXTIiq8dabowQXA+x/4PGZI8e5nsKw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUOBx3rrK1QqmQnZ/8ZM8rWEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTU2ZmVkNS02NzQyLTQ3MjQtYTIzYi1mZWU3NTQ0OTVmYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpPXlRDelCD3Wbf4vUDqhnr3SVPvwTzWpRSiUslXx7EQoF\nPCXbxQas0X/YmyZrcsFM+nLATrty0Gapz4UYSSIVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgarg/wXG5ckLonWjQNdAF4BQ\nGVwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIbeQ/O53LkwUspo+NbqhFyVJu9OVIJcljoBh5awcr+PAiEAud8cqVpG\nGnRd7m2rB21J3bDLPo3wtbc/fyXEmOTj65g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAR5qNWWTXuGh3HOh0vUUhx8WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQwZTYzNDQtMDU0MS00NmM2LTk0NjgtYWRmYjVjNDIzMzk4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMDBlM2M5\nMi1hYjYxLTQ2OGYtOGM5ZS0zZDg4OWQwZjI5YjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASKYW3jrwWNJOjggxU012fNyU3jRFATPI/totaWnYCiDEiY72n5mwJr\ntNb2GnCwnqyLPugbf81sif8Fm6hbWdGEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfvrCr\nERZ4camwow2t4GQ4I2XmgzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIANFUT40LjgE8IX1KihRAM3UUaFs+PNTspS/yTI78C9JAiEA2JS/wVc3Zny+\n7SWJByqX5E7MvfbYGEJBFa1noE1iXOo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6071", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6071` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAf4Nn3IiI/JrP6H3JLTxnQ5dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjZDg5OTJkLTI2ZWEtNDZhOS1iNzE0LWRhY2JmYzIxNDE0NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIzMjBjYjItOTky\nNi00YzU5LWFkZWMtYjA3OTcyYzBjZGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1P8ryvnqW+obbD8+kTloj0YKlumeCazYrpWVhxTyZU9HGTSqBw/KicjrqXFE\nThzDFgeUC49SKhRe1KNXFOiD3qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJuog2ITrD7U3u40sElVRwhb/ecswHwYDVR0j\nBBgwFoAUewjJjIXz88IrDbKgvk0TB8BYkDgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCJ2vieAYtYyLEL9r1yFzsa2HJRmu/X\n4EQ4F//P7EgtjQIhAKgOD9Rid2ONFWaX/vYteMD3XlKMfY5L6JAA/nj5ogkk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZHsLzR+V2UNr1X5UcvInY+WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2Q4OTkyZC0yNmVhLTQ2YTktYjcxNC1kYWNiZmMyMTQxNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXR8Kg0I8/cav+JoWoOVpc9lVi4/+j9CunztixFk6qg5tk\ncO0xTQWiIbADArvoG1cG4LdA+by8IqJb36Lsofpso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUewjJjIXz88IrDbKgvk0TB8BY\nkDgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga8slpE36ViU28di8aPD69hkk90RmVyv7Mkj4JrqfNuUCIFJR16nCnULh\n75rZkyjtJ5FMhr9YUS3kBjMVgm8vgiF5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISATpgkedH34WWQd+SRLtfP22ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIzMjBjYjItOTkyNi00YzU5LWFkZWMtYjA3OTcyYzBjZGQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZWM3ODY2\nYi05ZTMxLTQ3OTItOGRiNy00MzhlOWVmMDlhZWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASV+/s2LTmWkmA4k3O03O+oPnRJ1kXYNNXj3S9xKKnRBuCK9dPNWFZG\nDJPH1Srfy5iQ9zDCXry3k1DRd/NQBqIbo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQm6iDY\nhOsPtTe7jSwSVVHCFv95yzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCID0Qd5kvOTdfw2d24uusK+cYhla4f/IDgxzrf6Tj43OVAiEAx+WX3CTJLYCi\nBUJeY/RXA3TmvKG5tnJBxRKUVQs86wM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6072", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6072` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAeSecG9EvL+u097hh8ruVCArMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NjRlNmY3LTI2MjktNGFjNi04NGNlLTk1ZTk0NGNjZTBlODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY4NTYxNDQtYWFl\nYS00OTk0LTk5YWMtYmI3YTJlYmI2ZjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaFE9uhVisupA95/j5DJ90DqXK46gPGRI3BMSNms1TRDg4U+Ee0WIZFyvUeVt\n5Rw/Q5JH3juqSmNnt3nrtIXvzqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyaXD2puwoXrIoC9SS2EquFJvKMcwHwYDVR0j\nBBgwFoAUQCuQu4JR9LI+MCvKOsz8fqxX98QwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBKCNuw/E1FlPE7ubzgUx2Zvq9J/CZjy\na0G/29QRzvpWAiEAuljeGlewh7aS+pH20tCbFQq2I123oEt5lY5Wu6NAm34=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdIhz/+IB/IruR4U+AEYJ6BDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDY0ZTZmNy0yNjI5LTRhYzYtODRjZS05NWU5NDRjY2UwZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT57WCUw7zljwG2eBQDXr86lSH1WFhJY09fVpe/myJogfAl\n6x5Or/q+lbyvzWdpDGroZlyltlXTsMuxjV7pN2+8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQCuQu4JR9LI+MCvKOsz8fqxX\n98QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANX+I3fPTa0ETNts8pg9pPGKjfgxGBN3BPwRBit/KpgsAiEA6eeW4t5i\nePUwbuziHVZogAVJ1qBKNIK6hCTQo2q9DqM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAfzF5C35PW3N3NedohLhdvhwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY4NTYxNDQtYWFlYS00OTk0LTk5YWMtYmI3YTJlYmI2ZjRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YzE0YTUy\nOS1hYTY4LTQ4OGQtYjc1OS1kYjQ3ZGE5ZGJjNTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR4k0Ef3vfj2oS+kQjtSq2TFIggsQI+lasqE3DkknFK0guEBJ85RKyb\nl+vtN6rOwilyZQqz4e6zUhJ0REForCHmo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTJpcPa\nm7ChesigL1JLYSq4Um8oxzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCeL6D8Jn7fD/FvmswemRTuM4uzPbo7VCCI0s9biXdlUQIhALxTx18wU/s9\nAM/RKHnEZAk8K2YURwsDbFxwstkXjfGD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6073", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6073` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYnGKQO8GqxFzCtbVFQoBfexMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiOTUwMzU0LTE4MTUtNGNlMC1hMDMxLTNmYzcxY2Q5ZjEyNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM4YjhjNGYtZjgz\nYS00NDBiLTlkZmItZTJjNzAzYmY1ZTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAa65ExjIjthpGVRlc7d/cg47U99PMSky96lRgg7Ij1ERR/znVRYZONzHdUr+\nZrMUFiTntdtrQUHIsG17cx/LlqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8gqALSh9bSaSQdBpKulMTJmrtgYwHwYDVR0j\nBBgwFoAUw8B8DdUG5GyJnpj7qROrIP6udIAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIC14tBVypgFt\nox9ILvumHsIsuHt5sfBpa+0wlvjQ6gQfAiEAn6CZ6+j6UDH1N+TmjVzf0quBPxA9\noukC8aKBF0+2jno=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUfFQGlxtQ9a/FbLYAToPXkUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjk1MDM1NC0xODE1LTRjZTAtYTAzMS0zZmM3MWNkOWYxMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ675AWwxat9lFckKSEaugQdmXgJngxmAi2I3MYUdRW5o3g\nVSDMPQ5hMXuVQ1BU765R/ooRqT1oU8xjawZcvGrYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw8B8DdUG5GyJnpj7qROrIP6u\ndIAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOO7/7yE7IX0ZO4DkgwtDsdQsw+o+VJ0LGwbkE26MpX3AiAkbdbvI9vG\nA7DVnxfNtf3nT9FE+IK9+rgb6ksC1t8x7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAUC4yoNCUdR904fvfn2ri4cmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM4YjhjNGYtZjgzYS00NDBiLTlkZmItZTJjNzAzYmY1ZTEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNTg5NjM4\nMy01YTJjLTQ0NmUtODM3ZS0yNzkyZTRjMTk0MDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARfHUZwkNCbDIb0LexKma9m5qQBLzigiV8Q+1igIUQgxvICOaTI6Dy2\n8uC+ob4cqqWnO7AWXXa/p3fm0cFnkMr+o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyCoAt\nKH1tJpJB0Gkq6UxMmau2BjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCICXBVvReeRAV4bx/IToHWeRdr9TZtQ2T6NapAbBncufjAiEAxTzDPvfOddHc\nGIRbA/tcZ8kDpfH2n2BUzQVhmOZ/8l4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6074", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6074` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAX4v8doyCJ6GxPlxD19+s91zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiMTFmMDkwLWFlMDktNDYzOC05YWM3LTk0YTYxYTJmNTQ5YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA4MjRhNWYtYmQ2\nYi00ZmVlLWEwZTgtZTk4Njc2NDQ1Yjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELhzX2fBQ6OkE6zYGqgktKcdzouQP2lfzdyNtIBWvTCP+WhoBw0nuIfwzeCv4\nsdAimQbCCPVxRvzHxh4MjpauaaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3d410g0qUJ1ThIBNGdtW//3RtEMwHwYDVR0j\nBBgwFoAUFWKPI5UieEEsi+Y5kVFQ1V+Lbb8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAOIYI+97hgK7hy8jXkeCWIjStX0mogg9s5K1yn4zThkOAiBbohezNqyI\nOjE8yfO/hb+QNN2ImPCuMgwLiqLdoovOKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATrGs9MWOc7LmwafQt5plovVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjExZjA5MC1hZTA5LTQ2MzgtOWFjNy05NGE2MWEyZjU0OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARu9hnPniduuXo5/w6qmSW4XvBtw4G7pb6cSp5b0YzYoz8W\ng13r4ZYHWEqKy0J5hU3YLJqrnT770nmQiVMGnR2bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFWKPI5UieEEsi+Y5kVFQ1V+L\nbb8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALZfHWW3xneGTq/sAhNxqzedGLwqeV7GhWY7vKf9LBuyAiEAqZ5J82hw\nOXJ9mGB0zJU5Tec3SJ0yfuRij4YZw1fBGwI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAWDkQtGnRLZWtgP5PrW5G7JyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA4MjRhNWYtYmQ2Yi00ZmVlLWEwZTgtZTk4Njc2NDQ1Yjk1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZDFkZDg1\nZC04ZmYzLTQwNjEtYTEwMS1jOTA0YzVlNDUxZTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASCZV7gvWfLC39bfa0z8XHqa80cuYu2xyLfaCk4GLWIHIxsrqyUR+4u\nIf7mUJ83Ki+MqLZgSPPQH/ng7T4uYvcSo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTd3jXS\nDSpQnVOEgE0Z21b//dG0QzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDmrF/oAbkt1nh40ZmTTFW3AAZtXXf075K+W7ydqNXv3wIhALW0JvB50Gn0\ntqw+pz3M+y9QkbrRNPjQWRg26EzBxyx2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6075", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6075` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAYXr9S+94CMIoVVEq2fmry7TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmZDMwZTJkLTZhNjYtNDBkZC05MzJkLTQ3OTBiMGUwYzZjMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzFkOTcwYWYtNmRj\nZi00MmQwLTk4NzQtNThhY2ZlYjhjNTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETgsDLYh+YcIinW8WAs70mm0vOByxauaCda8AbrqTba87FJ29e2Q4Zh+jNElL\nJ6geCDYfYCEvo3Ge2DruIjEmBKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpzJwm4A7yKNNbzsvZ48vlOIZUsIwHwYDVR0j\nBBgwFoAUCoBNrtRpyx8MWy/INszrzIhZvhwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgPTRdVSdGwZaGgSUwdPZmfsXsavplr4Y5+7igRCuh45cCIBF4IYpy9IRO\n7xxtSGVqWrnLRyFifrIZVsjgNAvMZBgO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVyq/gTKqGKvXZncZrfpigW4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmQzMGUyZC02YTY2LTQwZGQtOTMyZC00NzkwYjBlMGM2YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHQyKDoAh4Ilyp83yM4bXd9JZOwF7LmsW6KJb21lzLnZEy\nE/TeBE//0sAYxaeIU7fKMcd3IBkq8EcXytpgqcT5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCoBNrtRpyx8MWy/INszrzIhZ\nvhwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI/lz1//EOFbo1mCqBZLUNlDug8M3f1LfwP10IqeCXBeAiEAhtG6LLU+\nGS9DCqwjZxVzzIDhaLdmnhQ0NAMAf8eXb0I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAdkHyIGO3SjtUKhMWLyO5372MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzFkOTcwYWYtNmRjZi00MmQwLTk4NzQtNThhY2ZlYjhjNTdjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYjNkNzgz\nOS1hOTc1LTRlMDgtYjE5NC1lZjE2OGVjYjcxZGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR4sW0w0o6yzuQLvjhlP/QrzNoPYQyExx9UxgLphTnkBnWPaE3xuzbt\noYqg+3izUP0UW0O2Y7/w4cPMInSzkUmPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnMnCb\ngDvIo01vOy9njy+U4hlSwjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQCmXQ3IUE24mD7yPERshKbDPNtMTT25yFLK0pM1DlQFJQIhAJx7zffg56X7\naa/ibzZTGHW7G1oM4sUlAdlVemiz6/76\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6076", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6076` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAV4RLqE8er8ldkfZuF+2AwCdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ODhiMGNjLTQ1N2YtNDJhYS05ZmY1LTk1Y2ExYWZjOTQyYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ1M2VhZDEtM2U5\nZi00YjU1LTlhYTItYjYyZjRkOTE3Mjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV7IjMxD4Bi8sm4LmR/kfGdjmTAHzt6aSz3FoNnJ5/T9kGo7abhMKz7lqOwoT\n2+boj2mHJM8k7yC0MN0XuiMpJqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSP5nyvCQK0lbeLlz/u+lo8OsIxkwHwYDVR0j\nBBgwFoAUuhzMsS/fjxXb6MjxLQnZEQwBIpowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIHasAncbaTJ3KA+ZcuV69bWu67msMreuWYjWIScXosY0AiBnpzDxr0zW\nZlq4MiNstcSYd6jfVxasC/Eu9WiPrZ1D6w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW5HDeBTB17vbqw4EySXvkfYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODg4YjBjYy00NTdmLTQyYWEtOWZmNS05NWNhMWFmYzk0MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnr8oDOU1M/HDNP+UGMd6045cO95bSn9uMQZkfkaGhSHr9\nkJFjq8wVOSKYwAFYSPq3l9+/R13U3EeZIKnIptNho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuhzMsS/fjxXb6MjxLQnZEQwB\nIpowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI28K/auI1/oUAlW6QO3b6gCZNnMGmgtW+m/r6EatUfBAiBd/WiaVQeU\n7JOudAosaN+JaItcc0g8svSP4Fu89BI87Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAVYnkDHlq7bgPrCNcatGLTGKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ1M2VhZDEtM2U5Zi00YjU1LTlhYTItYjYyZjRkOTE3Mjg2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZjcxZWZj\nYS00NWQ1LTQ2M2YtYTM1MC0yY2IwOTdjMGE1NjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARuwN+NNTKytow6Vk8sTlApIfyKBFB0opiZD9TQOX22Z0cj46fotpSM\nSIbwGrulb0aeqZ7Fo0aBx+Ii/5mqCxBGo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRI/mfK\n8JArSVt4uXP+76Wjw6wjGTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIE6wUFquYsk5dSBGp70jgG48piCYBAxi0QDveiyQ4BGBAiAhVHnws/j8WMpl\n6+LIaa8/ZMNegIqSPaLwYmzIIHcjTw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6077", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6077` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISASp9H9qa8NTTMRUlfFgABvshMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwNjYwYmEwLWM2ZjEtNDgyMy05MmFmLTQ4ZWM2OTVmNTQ4NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdmYmEzN2UtYTdl\nNS00ZmQwLWJkYmQtZWNkMWM0OWYzYmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyj7JNQFZ6fU4/tzE0DiBaE7RDIwMwBojqR/vyGEqS3OaKj69AgVtrPF2QmI9\n/ljT68hYCypYmI5m5ITDPyY7OKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjIAxOH+1WE6nKutPFeO5QRmRxzcwHwYDVR0j\nBBgwFoAU+5OW5QpVxzwOsVO6S9JPp45PSa8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIHt5RgBIjWaAyr8PgcIBYF+/dff1/JeOtZ1tgPmZ\nmP7VAiACLPzD+TfTtDQD1ty6BH/nuTR4XMB4DhgkKCVKokFqAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAduVwLnrX8c1+ZdS8cRg0yqIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDY2MGJhMC1jNmYxLTQ4MjMtOTJhZi00OGVjNjk1ZjU0ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYV6rjY9N0SnZyMM79di3mgiDTJssUarB+L0pT7hDStQj8\n29elliA8cxZ2sqjaXgCP07C1bAMTPtWF8VSl+VDso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+5OW5QpVxzwOsVO6S9JPp45P\nSa8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKc+ojdiExQ9wNsQGoR1BXNYIq7ssqqmaJnIAiKvyNu8AiB7ErDyTM36\nIV2Aa/Yr5ValkSsEY2FVJeqKi0b9/g2rHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAaNML0zJ0EuuzIeyvBoHv3VaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdmYmEzN2UtYTdlNS00ZmQwLWJkYmQtZWNkMWM0OWYzYmZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMzYwNTlk\nYi1jZmIxLTQzYzEtOTRlNi1jZjUzZDJmZGVkMzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATtVQPM3qTOB9BOB7l6RDEuhL0ciVvTuZ1ldRC9CRIolY2PcppW3fV/\nAwB4435KrZVuqKcgw0uN6/hzguQQ2ZHeo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMgDE4\nf7VYTqcq608V47lBGZHHNzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIC0slzGd0faXjOIp7GlCq0g4Cf3ZJhOWKNmYK6jFH2pZAiEAleCp5reB696L\n56qDV6lqPap5wQr/g+1o0tifB0N/VaI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6078", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6078` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQNjdkTFb87ZJd8D6kJpXvFmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwYThjOGI0LTBmNGEtNDJlYi04NmE2LWMzMTcwY2M3MWRjZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMyMGU5OTItNTdk\nYS00NWU4LTgxMjUtOTI2MGQ2NTVhOTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPSuUrGB2cBwH/m7bBaOfi8ZbpVGU7Crrm+Fkjua4rAfXJpA/AXGxSpbgWnPD\nKDOnh7QROnIls7DYEXpMmQ2CCKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHTAIrp+/nGBiRdEuHBd3Jc5K/m4wHwYDVR0j\nBBgwFoAUdX7IPPotkVO7VV/fsXqghTt9A9YwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDmtotR+fGioTGgmKPWbKGziZ/IaYQmDWwRIKbOc\njiZNAiEA1sj6fRdUQJphIbet27kTbbOhLFt85dtVeSbBE1mReJY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR6zKVA0QVQ1xdgb79ljx/BSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGE4YzhiNC0wZjRhLTQyZWItODZhNi1jMzE3MGNjNzFkY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPZ1EYNjVgz83XzLgFdTIu/R3nEBdz5cDuqfCNvczOgWgW\nS+sYBpspU+jU5fmlHze6xaqpZVMxa7bvt2poWtzXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdX7IPPotkVO7VV/fsXqghTt9\nA9YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO+sI5s56MrICCwUgTjrbRxhzSyEj4vlQaxgSqo0T1A6AiB24ueaNRGk\nDyGRMgfRWt3xeIGaenoeTtV88bShJVtabw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAcpTDYYn5YQMjIe1KhHjiQ4RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMyMGU5OTItNTdkYS00NWU4LTgxMjUtOTI2MGQ2NTVhOTU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NGUxZWUz\nMi1lMGYwLTQ5M2YtOTBlNi0zYWQxNjI2NzI1ZGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQB1OimfirO7PB/yOexCAjW63rmVYPe8As828MVbTZBIpm9v7vo7i1N\nSy4SLK/WLgT/cyNiuXfp0hTJRUEjnQWko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQdMAiu\nn7+cYGJF0S4cF3clzkr+bjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIFVo4iSrPX8vRvTcFLzW8gX8N4nIMMYA+l0GnO0ZR1uVAiBeRTSdZFUUZdS2\nCqyXoTOZdPTifs1OL9/S3A1d554d8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6079", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6079` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZ31EXuQvYqao8LPTF72wUOwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMDBmYjhlLTlkZWItNDgzNC1hYTNhLWU2NjUyZWEyMzc3YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmIyNzhlN2UtNTkx\nMC00ZTE4LThhODUtYjRiYjUxM2E5Mjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVpWG4bjia7K16f4JeNw2mXpSmz6c8qNtTdVJwvdREDwPuJmLi5XZ7ErpH3cP\n7mjEQzdJF6K5R4i3Yh9+GF3RPqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBvvgadjiJzIbKD9BFELHIhskje0wHwYDVR0j\nBBgwFoAUeprCNe2/03DG+X27wHsVSzIqkDswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCMPz5Bp7fC6teakhdKeWxL+Md1S+Ec2QuZ7Kg0xMG6EwIg\naHu3z8nSY3YkEgA//sg2F/nic1RKPIeFGwxOLlesR4k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVeSO8/9/AUyQeY0mchAZ8OFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTAwZmI4ZS05ZGViLTQ4MzQtYWEzYS1lNjY1MmVhMjM3N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTYhJh6ERLEO/tfQIwBJR9c+hqEeTTWEu+BOQATDaWU1sS\nf8jSBmxlT4WOntQO5elzGTck8yd8w7JbFPGwK+TZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeprCNe2/03DG+X27wHsVSzIq\nkDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdomkAMcS3V2SY7GUKS7Awbu7yB8PasdAjqssCHP6SQ8CIQCrBoNL7o0+\nLvsPfu4T8/kh6M3TrPXSPQZtyjxmKCt2fA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIzCCAcmgAwIBAgISAaQgEyW6Xet6L4+8Zr/X7OqgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmIyNzhlN2UtNTkxMC00ZTE4LThhODUtYjRiYjUxM2E5Mjg2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1M2IxOGMx\nYy00ZGM1LTQwMjktYTU0OC03NmIwN2JlMjBkYjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT/tZ0lwvJycXmyBceY80ZDAwfJzBCZLwbr+5pPflASPqHGeGGrBReB\n7uugKh0ifWRovZl9FpJNNRCLe6PS4cLQo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQG++Bp\n2OInMhsoP0EUQsciGySN7TAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gA\nMEUCIA5sS2NubJ8d8/rYkLWlUVz5mQ/4MjDV1ocn5qFQMAjfAiEAs/ybQziD3R+W\nGFnXQ8woJhMFdUQdOTW2yvv5qNpVl8I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6080", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6080` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAchGXgwzg2zJ0i88LcK38aXvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczZjU4MmMyLTc3NzQtNDM0OS05NmRiLWMzNzQ5ZjFjOGVjZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjUwMzg1YTMtYjNh\nMy00YTFhLWE2MTQtOGU3Y2JjZWMyMDRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVZnEkrXd/Fy5PjGV17U0mlKOUXpzUHNimZBI9knLt63ZzNrCV+q3iWAVLWJe\nLbVLcptFBbJ4eOpdmmNdBeB9O6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4AxEXdUdzneuAFwb6d7k4CXICM8wHwYDVR0j\nBBgwFoAUObEiursOejLPkXEi0baNIa2ryaYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIDm3qZzhuKuqUQloBB1hXmyMeJCJ6J0m\n5Lba07U+vE6MAiABaFd63NWcUp3nCj+Hznc3W+4TuBRnzFNkPnleF8AgfA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVme5zgXfDffsyomrPWOZjYbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2Y1ODJjMi03Nzc0LTQzNDktOTZkYi1jMzc0OWYxYzhlY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1bR6oWRoqEb4gPW/ds100CTMK3thiYjm2JojrzlB+dAz0\nnbhKIAzVwS7A6D7h0l/GorqPIsOt47eQAnxmVfD+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUObEiursOejLPkXEi0baNIa2r\nyaYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHp6R2rBW64PVjUL6rHZb1JOuldBWL9DCV0YRwh85sfoCIQCk26pbkDib\nvx7sSPt8fgBKYMsonDyyDCUyNVZ3Gi44dw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAcGEV3s02tQBKbv6Z2RJExNzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjUwMzg1YTMtYjNhMy00YTFhLWE2MTQtOGU3Y2JjZWMyMDRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYjY2ZWJi\nZC03NDNlLTQ1YzEtOGFiNS0zYzcxZTEyNmUzMDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQRifcs0FK9c/5w0WLNVOmffVev8E9Mnr6og+9Gid9QVfszGBGt2Qb9\nmcfuMBUMsi4TCFintIPlHerefLMTEA0Bo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTgDERd\n1R3Od64AXBvp3uTgJcgIzzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cA\nMEQCIEOQVmJEHfPpwI0Ct2DBQ41KWFyY+78uvrt/xSxkyFfXAiBdL7vsewwmLlP/\nmiBb/J6LHMmRIRx98JhyZtmztHL3Gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6081", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6081` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZIwZthaJlTj4EQ0vSEi7JGOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMzRkZmU4LWY3MWQtNGEwNi1iOGMzLTliMDFiZGM3OWVmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRmN2JjNzUtNzRl\nNS00ZGZiLTllNTAtNzRjZDViMGQxMWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWpquVQmgRSqDMa/CwAWlX/3INeN3o/e8JN8qdQ19JNkEGjpDD4wCJhcsylHU\n6FZvyCCbaWJz2a430jrmKJhBrqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUijhU7xCDChvsmpJ+ZcWnb+3cSPEwHwYDVR0j\nBBgwFoAU79fd2lRKtgY/eJNHyBM+CX5zyg8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDxTsqjM3PTZt0lizFJbkkDEf3gdyOW\nXMguuH5iHLWqsgIgaM14SEP9K0NttjXfODTw5/52NzlqZa8xFFW/x0AfSHk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVAAIVGlGUVEDKPs8FXEAwNXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjM0ZGZlOC1mNzFkLTRhMDYtYjhjMy05YjAxYmRjNzllZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARudwTWK99fFfeUIzXrLYLGv8HAuCFUhmxiuN0yqCMLap1F\nVZcej7gosYR1+MbREyLmARWOVx4zoEgfy+/+PWGDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU79fd2lRKtgY/eJNHyBM+CX5z\nyg8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANRHAwNtwsN9hLcsId5r1cdiY5sax1BaQOtw8fdYbQV4AiEA+L5Nh48e\n83Uuwiy1Jod4KCy23NLV6eNzzV6WBkaMDtQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcmgAwIBAgISAeO9oVxeydM7V5A/ZfEnUcFRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRmN2JjNzUtNzRlNS00ZGZiLTllNTAtNzRjZDViMGQxMWQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MDMwNWZm\nOC1kYjFiLTRkMzYtODM1OC01OWU0NjEzZjU1MDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASEB7tvrJ54GE8LwHXEa8bQUkXiKN3Jy6EUy3imdge/6LJymB9RJxp9\ne9biziL9UGEIHloVAizAs+kkr9yqmhAfo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSKOFTv\nEIMKG+yakn5lxadv7dxI8TAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kA\nMEYCIQDSPL+rmnNwb226izfRF3MO8iyWUjwcsI+9Rfbze3cr/gIhAN8/92TaNtyg\n5uxLDfb5FzLXDbr1qce5X59ekXNQPzwW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6082", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6082` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAe7hdoT5xB/h2vCaW1oN8RNpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ODEzYTBkLWJmYTItNGE2Ni05ZjY0LWVlZTRkYzMwNDNmZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNiY2YzMWUtZDMz\nZC00MzA1LWFjYzgtZjBkMDMxMmVhOGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqqKLk+/WW/5KppveManCLniK1Mkstuk+PjouxBNgWN72NtOR4YHbqGw05BVK\nfwwv96WbQdCsr/r6TzLBnsDtzKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJDr9kjPw7EmMz5rrup0bMGftdBdMB8GA1UdIwQY\nMBaAFLL8qN6FGTpXge7+uzsnNjts70ORMAoGCCqGSM49BAMCA0gAMEUCIAcAmtEs\nffN3zOQD/cC/1lPvGgQkf21vb9uVOUqT1l2NAiEA4nNfyUgJ1m0YvKep7zI071gh\nIGBot1/Tx/loD3GnyN0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXnP/wOnUHPEARSvruPbYzjCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTgxM2EwZC1iZmEyLTRhNjYtOWY2NC1lZWU0ZGMzMDQzZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATivG3gOdJwKtBuIyq1pyA+8lmGYYLGwf8+SHK1TmfW4wPz\ntEJL0azEfgPQSb1Wd7GaggZOWVxn1viq64cQjXD1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsvyo3oUZOleB7v67Oyc2O2zv\nQ5EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIudaHDS3RS0j5LY9xYb1MWe5KNwUQuiKxS6zn5xVt0xAiA8Bx8f3SrN\nGevQfEB8kVzjAX9wjaPTjrYiGWoCtoTf9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAR6kkyAaHQJDnAkVg1rgmmntMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNiY2YzMWUtZDMzZC00MzA1LWFjYzgtZjBkMDMxMmVhOGM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNzNjZWY0\nNi1iMTcwLTQ1YjMtOGZiMS05MzU3ZTAwNWQ4NmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARa+G3zUJS75g6z7J6lf3oF4KHn4tsnl85MSFNAqFYT3X2AOdPgnABw\nMf0mOYnqE/cKp78XckxeE9V38jqdcsCko3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSQ6/ZI\nz8OxJjM+a67qdGzBn7XQXTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAQdECtxiIdj/7S7yOkl5s0p3lz4YfTfar/PthoKmq0hAIh\nALbOQLigXgkloQoruuXn+uuXBqwvi0xjKT+iz9or0pUQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6083", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6083` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISASotAzaSc/hJEyUbipl4/q7MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzNDkzYjQzLTM3MzEtNGFjNS05N2JlLWI0ODBkMTc4MzQ4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdlYmQwNzEtMWE2\nMi00NTkxLWFjNzctZmU4ZjgwYTNmOGJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeyngqChu7zALBYOOD6iXFaEDpp49c14eDfoTTf0Nsbtqf9PoxBnU0XtywTbS\nNUU20om8C4t1ZlS40M3Mv/PfqKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCwbGKFTa6zQvbvfm8dyG5CvhY+wMB8GA1UdIwQY\nMBaAFOF/QtaVdypZQ7hNWPyhIYn3q825MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAqECHS3AgUQDgamTdTUN24NLXxh8wW1J9\nbPcO2900h8ECIQCPrVXY3+raP9sDG2immn3163rY0g2AhgYMFwtdkqbwGA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQdMCbrNhfjYxyP2nUD/CrzbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzQ5M2I0My0zNzMxLTRhYzUtOTdiZS1iNDgwZDE3ODM0OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOgOCI2oCtxXC2r+y/iNLxeBP2/iGYnDuFUajP/YtKMrVg\nD1A0cgL44XCRmECYpLVFUSVwzujJ8DrYJ4DnnHdfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4X9C1pV3KllDuE1Y/KEhifer\nzbkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKbMi89VARuB/31EC0cwYQHDeMBBJ7suEya2iDPfdzNTAiB7P7Li06X+\nuiKPK44JhAkyj2jKR1tXCLO0UvpqdIomUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAWKAg5I1uXAIcmnzDWATvY6IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdlYmQwNzEtMWE2Mi00NTkxLWFjNzctZmU4ZjgwYTNmOGJhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MzJhNDE2\nMC05NTI4LTRhZjAtOWVhYS1lMmFiZDFkNzVlNjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASCD7XXmOsAUMgW+AHvmgLCmH4JAgUym4Wsqm5PdVjCGwEvJ+juUan1\n9WiLYuCOjQlAjYdC7wNMwgayqouQaKR+o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQsGxih\nU2us0L2735vHchuQr4WPsDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiAPWKYMWqRN5/BDoIJ24lzIYVpu8kvRIPUPGjSqo4HFjAIg\nYfO0C7ZemGOu/WUkk1KvUxY8KmrwEypU6Zu3zGBN5Sg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6084", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6084` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaujf3e5UJUV2BVYRbtsEtIzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2MjAzNDg5LTczMTUtNDBkOC1hMjg0LTY5OThkZDg3OGUxZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE0N2NkYjUtNGQ3\nOC00NGMxLThjNTktMDgyNjhjNzFmOTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExHrVgirUcGSmxpHrAYTW6kcTgyB/12TefQ4D7rYw3ixeRN1550CMyOiGO3Ie\nT8Iqmho9gCG6kIPnPKekTKWw9aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFD3y4Y3o6HK6t5+BS1yZ38Q+J6GHMB8GA1UdIwQY\nMBaAFHV95TVlDDNJrX28zT4L5wK4CHgdMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA5gxWKVFYIGRfXwMR+kG4n1yK/i/emhdd\nH7IqAe/kbQcCIHOZZxLX0STqYj9yS3U4cTmLpHeiKiKFASK2Jw38KVD7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaprtpUWH46tPR9ldNgY1ARqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjIwMzQ4OS03MzE1LTQwZDgtYTI4NC02OTk4ZGQ4NzhlMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+SVVrWz0QiussIDGVClOTKWiLiZaXK3R6/vSyaQqNuMyR\n4XXSn2ZMjXKXj7ISuHuJqj+utXLrDJkoCWh4xNxPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdX3lNWUMM0mtfbzNPgvnArgI\neB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVZIx3SYYQcmpitkq9aian+HJ78djW7PzEcOGuE1EO3MCIFNFOgl0PJHq\nyoaG0iIm27IUrQeRliFcowDeItVUc4Ug\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAX4UJWF7mA5EdZ2NM+tcpTjNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE0N2NkYjUtNGQ3OC00NGMxLThjNTktMDgyNjhjNzFmOTgzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YzA1YWUw\nMS1mYmYzLTQ5NDctOTBmZi0xOTQ3OTM2ZTVlZDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+yu2NsOqbTbcSP421YWGaZEU9G26sZ6g+ZAmlXPqQxPD0Zt6D89t5\nvlsOeUuH90s1Q0ZZZ07EaOFR/nuK0obLo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ98uGN\n6OhyurefgUtcmd/EPiehhzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBUQ+uN+ERP+rti9QHVC/bMMBkk7ovEM3PZs5bLWYWuewIg\nLtzGocmFMO5TDi7MO6g6MJrFPL5UAKJJEFVSVSW2Dng=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6085", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6085` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVGNR7vPSu2X+gqLgf/Kh82WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNGNiZTVkLTBkZmQtNDIwZS1iNzM2LTUwZWVjZTAzZDhiNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU2ZTExNTQtYzNl\nNi00YWQxLWJjZGUtM2YyNzkyYWU3MmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/GCkYta/8dwN98fglcXpntmG3q93uGg8WeYtU77PH4DP/Xk7lQpOYW497B5h\ndOZl0dkPVl+sqp4mbqvE/cNeTqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRVxD6Gu7fwWFFpK0Zx1JvSL8BoSTAfBgNVHSME\nGDAWgBRiiNpCn4Y/F16DmXIL/Ql+Km2e0jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDV5Ig9oiWMjomUvZKN19SNs/QoCFPX\neTbeRm7zPa5y6wIgf1ckT+CfQdNn5BOtF1YGrcckE+Sb9zCp6Wv05Zt5AlE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASRMrzB61cQLbeFwTltuI/LMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTRjYmU1ZC0wZGZkLTQyMGUtYjczNi01MGVlY2UwM2Q4YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASitodxhhd4JrqlQQpfFFzGNiiMkRlVJFxuVEWXEDzZrlpV\nNpfssKAMMfejb8tHPxdo/rqcnKngEYdtKoAU6/4Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYojaQp+GPxdeg5lyC/0Jfipt\nntIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc3DQBgorst5Q+7IRBTz3eMs4GYZkMniOmSdwLX9It04CIQD0T560ubZz\nS7ccGCcW7MsU9kwhIllq4+BOGmYSlpZ2bw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATqDYxJ+V/Hnz0VqjLzXbMctMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU2ZTExNTQtYzNlNi00YWQxLWJjZGUtM2YyNzkyYWU3MmY1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZTYxY2Ez\nYi02YWQyLTQ1MTgtODc4Yy00ZGUwNjViMmM3ZmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQpjAbuTgKN+GFbxD6Q3CXAGdMgnaylC26OgTIXGa1yIC551JAYwGLL\n2ToExIeLCtjQh+hdYm4ewz3dfGX/X8L6o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVxD6G\nu7fwWFFpK0Zx1JvSL8BoSTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAxzy8wQl5brIPL3qMR70nldiWOuw6LSe7J7qBlrNRxNwC\nIQCN1OjMhaduZ7ZbbD1IaE08lbTjUna/sHudCWfIJJyl5Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6086", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6086` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWk1ZLoaE8GFxtTsfTVMj46HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlNzFiMjkzLTViZTItNDc1ZC05MmFkLTJiYWE1YTczMWVkNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg2ZWNhZTYtYjZk\nZi00MmRmLWE4YzMtOTQ3MWEyOWMxM2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe3GOlldQZ0WcVSE3bHNlLg9qhAUIUOfMQzwRw+i5tqRDbmuc86sWaJLgQEjR\nS/8gTbKAc1p1r31so7Aoj3PWEaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8kB8nKveENu0FYDXtK1L/SKUagkwHwYDVR0j\nBBgwFoAUkJTM/hKqGKl2J+TIbRm29ziTYAEwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAQvzYCucr7sFwe\n7wWUnEKd8cRfh32Iiv+8TJiu2FhOwQIhAPu1gg2FK1nIg8iac/e7bcHc4N7qoxdr\notSnS8hkrH59\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWXM/UpYApVTSkGtcxIYA7ayMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTcxYjI5My01YmUyLTQ3NWQtOTJhZC0yYmFhNWE3MzFlZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9A7JpyLniefwSiAGLvaTTWqdSIueTshN/u7N1mFosfv68\nWHksaJro7uLFs9dxJDEsr7lVz1SKvz9DkwwEYMK3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkJTM/hKqGKl2J+TIbRm29ziT\nYAEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJzF2M3qQhURltuwehazOHOThpLuWbG0NoaAXavvwfaVAiEAqv+7kSJY\nAljCgv/dUae2XTRWrZ2Sg0m3R9hAC+6sedQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAU1p7SfcrWcY4wcUtiEu39LGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg2ZWNhZTYtYjZkZi00MmRmLWE4YzMtOTQ3MWEyOWMxM2E2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwY2YzMjU1\nNi00MTFkLTQyOGYtYjkyZS0wZTI0MzY3NjBlNzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQayqAUOiqwn61VLrYsH4+FpG7tnZMcXRXca5RWeZ3wVXPwaUaXnG5J\n08mhb7kBfilXGxfAsusy/oPjHXsXlpwQo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyQHyc\nq94Q27QVgNe0rUv9IpRqCTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAxfqfQJdDYaDKn8/mXftdocnlDvG5qHnDYBqnyhYGtLgIh\nANGbIy0s0vYhUXUCmOpYm2fTFKoCbah8L1cAYkYJxIks\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6087", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6087` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAeWTmb5z+VTdCMm/Cm0OU/YPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNjg4MGM2LWU4NDMtNDhhNC1iMDM5LWQzYTEwMDRkNTg0NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTMwNTQzOGQtYmQ1\nMC00OGY3LWEzZGEtZWFkNjg4YmEwZTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7YtUbUQmuJso5d3hSJjuiImbYtM5pVTFZXQbHOTEKSBTAYYxvO+REhIWgs0O\nJtD5PTUxRLkA33mHypHLvZwRxaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTcA9Izwy/ijHxoCq7oFT1+2JqqAwHwYDVR0j\nBBgwFoAU3kklll8KaYga/+WKJZTTDejE3GQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA1cIWZBuwPyQY\n7ZJxeuw5JjwDJLdJXbfea6lvx/MLCW4CIQCNSeLWlhN2h7Su6mXfE/qxaWqlDr6V\nI7+7JDdOkycisQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcb9o1xTWnEp53zHJWyjoS6AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjY4ODBjNi1lODQzLTQ4YTQtYjAzOS1kM2ExMDA0ZDU4NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKqxMEjWIvjeGExni7EH2hnOsPkl7FsuiUpLd/Zal4En6R\niEQa5KFK5bIxiximvsx2uP0YRihiTlEI8CO90Zf3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3kklll8KaYga/+WKJZTTDejE\n3GQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALbE7ZtDWWSNf7AbuaK1r8T5+9TaoOplSk9MOcnYIukwAiEA8PTzQTgt\nPn857zj+7qAeX4QZCT0LsVxfL/vYl5jVLPA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATpQ6OE8JID8Yf1tMoXHq2zRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTMwNTQzOGQtYmQ1MC00OGY3LWEzZGEtZWFkNjg4YmEwZTk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MDg4Yzdk\nNS05ZmRjLTQyZTktYWIxZC1jNmJjMGJjYjkxOGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT4BjvmPgFBaYjl4zSdKhNh8kdqMOqzIfFouBaAbOwr4SuedGTdrX2h\no5IdIZLrCI7npdHX+CgVtt+xrBVA/epco3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNwD0j\nPDL+KMfGgKrugVPX7YmqoDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBDGL/aeX84BxXMAurDcbS5kHtdW6f2tuHo5hzByi7C+wIh\nANSJYPyRRTyV4eKrtF9wcvbo3APhDPFo0gJt1gBhm+Ub\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6088", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6088` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISATwfS53Tk1T7dB41ANfAFLGSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0NTFjYWQ5LTg4MmItNGUxMy1hYmU3LWI4OWIwODEyNWE5MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVkNWQ4OWMtYmU4\nNy00OGY0LTk0MDMtZmUzZjg3MGYwNzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECbLGpIW66V9xJhvRMWtv2/7QldPyNQRoHd2iVpaYU8thpFwmgdp3Lb49Lf2v\nMq9Gp8FykQg2N8D4T3deRuT0uKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULFZb1oGB5xcGrYq8xCrjKH2waFIwHwYDVR0j\nBBgwFoAUFn4x88nDRB6p94bE2mWpqM/cD5gwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBFuZ8+SxlsJ2K3x0p/FV1f\nX19mAWxpZ1slxa8Ws9HgZAIhANYf40JHO/Dg151te6d1KfvHfmCujW/nQtxTUUQo\nomAj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb3FsEpFoA1PAnlER76AmnYnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDUxY2FkOS04ODJiLTRlMTMtYWJlNy1iODliMDgxMjVhOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyjr4T1YlnAvpNxWTLHMmIkmB/J6hH8e43oEjakXAqP78R\nYJAEyN2MpZkbZCdDXrhCiTVjeZ2zGtmo78aeejYuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFn4x88nDRB6p94bE2mWpqM/c\nD5gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC4wPxQ4rnoSNYYyfRNhK4PYEod0FY+auEStm83LDLkYCIDtxQwMrX533\nfj/g5HfcEj+D8SgW3R/dFDT1btwZ9QVU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAV5LiHjNxPWHTV63v7RuMJ0CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVkNWQ4OWMtYmU4Ny00OGY0LTk0MDMtZmUzZjg3MGYwNzY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4OGU1NTg0\nMC1hOWFkLTRmNjgtODBiZi00NmQ1MDk4NDFhY2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ8ky/eQZmfPVXlGQg+PnDM8vnu6cdE7T/N/VF+xuZeoSHVH/Gnu5lC\nAfVMYUcNTYKfb1wCKTJw0SP7zzIiZ83mo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQsVlvW\ngYHnFwatirzEKuMofbBoUjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBVgYrGnR0230B94k51yZAzWotL4A/fzpXK3FfJM8GXHwIh\nAK9GQaa0YPZDE5I0fL3cvwszxeI+nivD72m0zvthLiKS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6089", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6089` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAQvEhZvqdKo/7q/o2J9Le6djMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2Y2E4MjJlLThkNGItNGI2Zi1iY2IxLTZkYjgzM2QwZWI3NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYwMDk3NGEtZmFm\nZi00MmY4LWIwZTctOWMxN2YyYjk3Mjg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE48jfEs0OfaKM4Ry7xludQCjjd5mM5cpmemx8cbF/SZEgbFx6Xnh45hVjt8ky\n4YY5ZaI7W5JcIECU5v1PH6cjW6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM2Lw/+3nCCDs0+uxRkI/vAPAiEgwHwYDVR0j\nBBgwFoAUX3GumOVZj6pE+J01Jzo3jCc5tSAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAj+4x\nthj4qEkCWGrSN5eEA83kc0E//I+4dRHN+X4Wsx8CIQDumuUiprOHXb0nbeNlR7wB\nwbAnuKZcYWekOCTUYPA8Sw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeXytUqw4abveQfe8MPPpB6tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmNhODIyZS04ZDRiLTRiNmYtYmNiMS02ZGI4MzNkMGViNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7sHuNIK8Wf+qAPCsvWsKnbZts1cEBobjC/sthaDnhlr19\nPkrSpww9XaoQHnzjWcQPfK6mFh+F8oJlk2/dABBTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX3GumOVZj6pE+J01Jzo3jCc5\ntSAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMBrP1eBlPYNGWEPnMnP/svmGVzTMlqs05b3yxvAs/TwAiEAjOk1Dh8i\nlDGg4chyCXonGDbqv59fN+lY2Vj0yDUtgzU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAU74i/2LRusU3QygAHK8aRESMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYwMDk3NGEtZmFmZi00MmY4LWIwZTctOWMxN2YyYjk3Mjg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZjAxYTU4\nMC0wMmUyLTQ5ZDMtYjc0NS05NmY0YmVhMjE0ODkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARmvH4Su4OpA5eanzGs/IlWlzI0iUgcMcF20fHPBx6eQ2KSNRf8TrNf\n+uCUwjpgQeL4cvFueODIe2xoZkGt4BCZo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzYvD/\n7ecIIOzT67FGQj+8A8CISDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA30Rpgfsic3RQVGSdk7HC9wJL2FGqg4ellF48jb5SH/wC\nIBOoWQzfvoP0yncoTfWDuSRJQeoY4+29YzOVm/sWnfp+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6090", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6090` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAfML86GBb5rHYglRUsuAQ7BIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzN2UwMTk4LTQ2MWQtNGZmZC04ZjRiLWRjZjBlZGQ5NDMzYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY0ZDJiNTEtMzE3\nYS00MTJiLThhODItYTE4ZGEyZjAzYTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVYNdbP5DC4UwOwfwDNnmXVIpY3ZTFJUAVedQWhR3CSguInk9W/mJ6svE7egJ\nVseJwFmhluruy54TmkJsi54seKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIxl4UJ5Z1CXjog/K5S3Dif21c5swHwYDVR0j\nBBgwFoAUJTpNDveomEDydCIIJRvH/3FmnlYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAjmAD\nRdo1hkaUuz6DUbJKXhq3719gfqGm8BNNhrofWvECIBpkuROgfhuvknwcknQ+kZnL\nuvcotb1DU0YxQkQlqZfO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUJQFkzB8DQt9PaPGJus0TmDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzdlMDE5OC00NjFkLTRmZmQtOGY0Yi1kY2YwZWRkOTQzM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdVPqpbHQoA+7uB9gVoDQIcEe4P6SHWvOjqB6U5HfdcARp\nMiXv32uK62Ox+EmUwfy4Mj3B6+qLVEpJjtSjqWq6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJTpNDveomEDydCIIJRvH/3Fm\nnlYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdnsV2DfTVtz8mA3Rpebkl2NB5po5Kht7CwuWI7IlTY4CIQDpOQNTHLP0\njTiPg40/4TRRdc/mYNUKvhx65pnQX6ySLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAc4EqQzdRU6PZeb0AOAkCj82MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY0ZDJiNTEtMzE3YS00MTJiLThhODItYTE4ZGEyZjAzYTU3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMzE3NmFl\nYy1hNTkxLTQ0YjYtODhmZC0zZWZmOWM3ZjNhYTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATm5q6nT86i6CDughGqP9TYymxBbMKQgQq9d5203jxmn11kbWAVz4u4\n6QjIryFLpPNS/jSbJ/wv2+/2OObaJck0o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQjGXhQ\nnlnUJeOiD8rlLcOJ/bVzmzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiAKcCrXJ0+pk8yMxak8rx+y9d72K3C44Y7md3atjqtXgQIg\nR/gfBmIwlRH+SYxWl8zL4i0GSnT1I/5Q6UOOEwFMY24=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6091", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6091` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATLkn0BcrBcN7/OXFtDgRvo5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzMDVhYTZjLThmOTYtNGY2Yi1hODc5LTI5M2M2ODg5YzAyZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGY4MmM5YmMtNmQ4\nZS00OWZlLWE3OGEtZWNkOTE4NTI3NjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErf3qYXOOppoKdgmxGywlCX1cV0/YUiS8SUI8Cj77iFyuTffFBhS+CkUC1xZC\n+UxpHzYhKPE3S9yXKpVbkrPxl6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEwnln5BK7funkkrJdRtnJ9Fm011MB8GA1UdIwQY\nMBaAFEvEA5RyXuX8OECUMdvEGaCXenxCMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA5HH+fEWeRv6QjddaRo7+eOmThUnZ02Oh\nW3zk6EqfAlgCIGUPBpPlOT799kMHXqYWZ+jCWFx6m8DkrtOCnzyemF+2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfvv9X/FKlLvukWIiOst/dYyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzA1YWE2Yy04Zjk2LTRmNmItYTg3OS0yOTNjNjg4OWMwMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnbYVdLQKdvfxo413IJkzDhXVYOOq2kHy3EM77unH0d8ST\ny0+rPwrzpc+nRhsvCoB5QEsMwKZhny2TnSW6xFvxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS8QDlHJe5fw4QJQx28QZoJd6\nfEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAObOr7809V1WUA+M0rhNJJfad3zSSN4S8BPPDVwT/lhUAiEA1fJmGIHT\nimgo7hl5C8Sawp8U9YHepwxh8pzfzi290Xk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWlwM2x4Dw2BkeWROskJ3jqeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGY4MmM5YmMtNmQ4ZS00OWZlLWE3OGEtZWNkOTE4NTI3NjVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YTFkNzQz\nNC0zNDVkLTRiNTgtYjAxZi0zZDE5ZGJkZTZlOTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQRSoOeFrLoLmH9vxA9dqO19RmuPrBiF3P4iLsU2o8p5br7y99Zv5k2\n2szZyYApTjg7pLFoGvtn2CZmgq+luHxEo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRMJ5Z+\nQSu37p5JKyXUbZyfRZtNdTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA3zkjd4lKGAcq7p2z1CwD+tJUOV7t9ql9F7t7Inw0IXsC\nIB0MwI0Tlbndx44Tdgfsoe2VLm2Oxy6k5p80iKtiaGT5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6092", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6092` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAXCx2iocn44RoKK+ioGNKN9pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlYzBmMmE2LWIzZmQtNDlhNC05OTdhLTMzOTFlZDhiMzQ5NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDllNzk4MmItY2Qy\nMy00NjVjLTk2NmItODNlZjU2OGZmZTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4A7t6UX4xAEnSTtjG6SbEuR23oJQ6wXiqWtQEgeV/HBfoPnXU8iQ0iXFB9tC\nrDZuomZ+LH6+adjANtHLYO/CcaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUboYFxmNOqv07qYZohd71rkvOz+YwHwYDVR0j\nBBgwFoAUoI/ZYGcgykL5scZbwASHW0SAUcEwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKkaA8OlITsv\nSGAaqCKRBXGNQDJ5i4eceiOsJ+uWKXGcAiAEPPd3Eoj53hsvG1ACIdGOKcQHzzXd\n8x6pr4laPBZx2Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATSXX8is/L1g5m8hXlGFHTBPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWMwZjJhNi1iM2ZkLTQ5YTQtOTk3YS0zMzkxZWQ4YjM0OTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMPomWg3al2YCCKRzJtWA4BL3tf9ULCw1XXOIeIB6Ta+UN\nhlcdRaItv/L4XJ2v424spIPnCXSg/eBfI19uzjOio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoI/ZYGcgykL5scZbwASHW0SA\nUcEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRU+c6kFI3pFXq2NMlo+i5icotcTZt2/UcDkiQcj+pxICIHcMKQHwK2bz\nolIf90QPfKqWtA6YnVNPjsooBO77Z7MH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAQtrSB0qbeRAYa6ZCazNhQX4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDllNzk4MmItY2QyMy00NjVjLTk2NmItODNlZjU2OGZmZTM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlODRiM2Yz\nMC1hZTkxLTQ5YTMtYjZiNi04ZWRiODVjZGI1ZTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQreftxrs51zm0Up3AAUNA5hG9TXS0fJVAtq5KLmATL1iBHBOWxHQS/\n/s8GAsIFNimN2i+3Rasx/ySjkib9xY9zo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRuhgXG\nY06q/TuphmiF3vWuS87P5jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiA+mT9aqMx1bAW+Wv9VbCFWsYkr17YdexMtfU/AmVXN0QIg\nKXBazELG7klKTJIoYyU+O9eAy073HmIlkDxAMLb3Uf8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6093", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6093` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAWJNusG/KFQ3CyWUtb73T/+aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMDEyMGFhLTc3OGMtNGIxZS1iMGE0LTNjOWMzMWU3MWQ4MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU0YjA5ZTQtMDhj\nNi00MDZkLWE5OWEtZGNjNTRkZTNmMjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2WfljEp8ibddHwkWhS/NgnsXrqoz7XXSZu2f9Z5EbAWRzdGEktK3mY+4zNth\npAvJc5WPqCexefebvRJFhJYFi6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe1SWmQLB75M9FnSXtApbTmcn87MwHwYDVR0j\nBBgwFoAUi/hgcVa1dLOFp8d1YiT9PSAZNu4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgGjQaQiDJLFsP\n8Vm6PBxmenE8cfX6idq/47GY2hOswcoCIBFu2dZJYzitliWnApAlYfmAmqgdzrdm\nUoGBcOljQK0y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcz+z67O8t1I2dssIkVIF62oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjAxMjBhYS03NzhjLTRiMWUtYjBhNC0zYzljMzFlNzFkODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV3eVFDlnH4Igm2xl4WA0rO7F1upFJkAGxjmlzKi9BddVx\ndhVbqRm2P/g1qUeTEu1wOa9kfc16q2lbvoPHe479o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi/hgcVa1dLOFp8d1YiT9PSAZ\nNu4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYgV9l7iVJAIhov/BUzEVNYVFjxi9NoEwRS/tmdbzx/oCIFMuDQQMw0et\nN3wHubX0Zp3FgZgaWQ7kDx+dKx3U9XCl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfD2gqYTBaQlDrzWdmLetARdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU0YjA5ZTQtMDhjNi00MDZkLWE5OWEtZGNjNTRkZTNmMjdkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZGZhOTJl\nNi1hMmM0LTQ1MjQtODIxNS1lOThiY2E1YjEzMmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARsJb2KvzZPoLCOTkC5dJKgcKSBt/s8ypooNLjeOwbOtEzoLMAK+d2Y\nN9RtGJSZ0UhHUJkClyk6GIrbVTWsmt8Wo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR7VJaZ\nAsHvkz0WdJe0CltOZyfzszAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBP70BvtWAxHCn5mrvHmPpilS4hdxF18fK4kLYzCzhqrQIh\nAOfnh+UvslYD6FH7nCSPQJuJxmbBwHKpcX7N+/T6xYO2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6094", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6094` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAeGlTbEnjx7FUNhK9YF17vkaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4MzQ1Y2MyLTJhZjAtNDkzYi1iYjE1LTRhNGIzMmY2Njg2NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDYzZmE0MzctNWU5\nMi00NjA3LTg4YzEtNWUyMDc1ZTk5NWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoBWFEEXsAhrByQO5F7fZHCKmsujl6lvUAobWWJQLjzBgZmuERCvSm+lceA17\nN0/gMkub6mxyV/SQASM47JAmbqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpojZbAbyJ+Mf02VgdVXnmkAFzlYwHwYDVR0j\nBBgwFoAU/SzDozQ0LznOaoXkQ/+oKfhb/iAwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGQ609WSYqiJ\nwA3YipKlt5B9IGqQLQFK+GMsdOQ/b3laAiEAxwMO0LJ6ipaACn29YYrzqYgJ6Vrs\nW+hq0+Ck/zYYxr4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQtbAY6uqY2k7DIaLR6/otLKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODM0NWNjMi0yYWYwLTQ5M2ItYmIxNS00YTRiMzJmNjY4NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAxjWhzbH7ZUjkp4jYylihUIpd5DMOKB/MfN/rowGGELXp\nANkd/H6eNyOwjw8iLP0SYMIYPCuFZIfxvWgu3Q5vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/SzDozQ0LznOaoXkQ/+oKfhb\n/iAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOogPRrYgfGlKrl5utBDaGjnOwF9Xw1sCIqgtADA61NhAiB1oLDjxB6j\nggpL0/qT6SNcvC5R5b1WAYEtRXtQUiMNdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISARkb4kmSXTOv6+LarN5HOXbSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDYzZmE0MzctNWU5Mi00NjA3LTg4YzEtNWUyMDc1ZTk5NWNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjM2E0NDQx\nZC0wOTMwLTQ5ZTktYjRlMS00MjliMWJmZDU4YTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARG+YB/WX79jYbpYiMvcry1OsGNCIHyYag8JcRKnj1eajP39vFQ/uTC\nn7gXYYoU6ITGYAgNKiheDqOA7Nr7eQ9To3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmiNls\nBvIn4x/TZWB1VeeaQAXOVjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAmMZdX6vv365p6yHNoXEcGk0TxxT/6KcN+299e24kzDkC\nIQCD1QLRfUYRYfaZd2nIGJLT6dGQPCDBS8il2ozI8ixwCA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6095", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6095` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQoZ6MLrNXuauvMrXogSWaNvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNDg5NWQ3LWY3MGUtNGFjNy1hOTA4LWYzOGVkNGZlNGMyMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdlNGFjNmEtZGU2\nZi00OTc5LWFjNzItMjQ2NWE3Y2U3Y2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeKcaxid7ueAiw1RnajVfXuWSI7bmhNpXj8g8DFmqCrPYHThewXXNxm69+lFQ\n0EVNfqiM5G+jEqCprEMsE/9zk6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Pf4K4nLYyJgT4VwSJSPpsH3O5swHwYDVR0j\nBBgwFoAU6v7KaNxyO1/W/d8m5aEK4BTVWhIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEQv10IU31JcAwGhE8DYDJJgCdRClbmra3hezNxMg156AiAs0GPij2DUZnog\nOXPK8vw4LvxBzpaa3jH0ig4P6+Lz4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATuSJhjmjCNq9fIlRh5Xcl6pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDQ4OTVkNy1mNzBlLTRhYzctYTkwOC1mMzhlZDRmZTRjMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfN3R2Odhvzxl0MGkkxpR81mySSDIpby4OeYoRL1MK2LKc\nxTgC07AyRdVYndIFcjTN/JbJX4LfdggQl3xgP5aQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6v7KaNxyO1/W/d8m5aEK4BTV\nWhIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMrucFJc44/R2UVGNawECgolxewJ15uUJTcmX6j6TogdAiAR17LuK9UB\n9JGLKjbePCIRlSa72Wl303kTS7xzSjkg4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAX9yeW6mwDGEz1eJafB80QZIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdlNGFjNmEtZGU2Zi00OTc5LWFjNzItMjQ2NWE3Y2U3Y2M1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZjhiNTdj\nZi1iNDUyLTQwNTAtYjM2My1jNWM0YmYwNDJmMjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARYErbfQzm3cPcctIsaim+LtlKAyyCn8TDHHQME4vWo4Lm4QP3NQmZO\nQjANleJ0Dh5RXAiotZk8HdAzc7cYUtQRo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT49/gr\nictjImBPhXBIlI+mwfc7mzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiAyn+Zeaagk5ZAU/xmT9bMs3UI1jwj5bdSKcLFUxKMaqwIg\nJn0eFfGt581PETKd4wdk6JYhbVwG6NffznMCv38GoVw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6096", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6096` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYgHUBMuVCuwyNtzHgUZLHjlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3ZTMyYTNiLTdjMjctNGUyZS05NDNkLTk1MTg1Mzg5NTQ4MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUzZDJhNzUtZWMx\nMi00N2IxLThlNjUtM2UwNDZmYzkwMzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU/VYrBAIRK+rIc25fOvemOGrSVSZSuezxZs8kqFZK0wafF5z1CJKsHkvb0eU\nr+fybYYHeSSY7ShRZGsZNBWhCKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn5EausmuY6n+R3rRU1UtztXamA0wHwYDVR0j\nBBgwFoAUzFLjEAvfkxQstEfBVB69Kaq6VDUwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCWDLawE5Byn8S12njHDdFMizI3KtlNFCRjeWYMqyy3tAIgQ5Wy67+G22xx\nrYcmAL4octiSjyk3WiLZFmUCRVtxvh4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAQCJ1+wuOJ2gQ9SXHst2k0ONMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2UzMmEzYi03YzI3LTRlMmUtOTQzZC05NTE4NTM4OTU0ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlPWyNORvJXvP2uPOb1sa+593CuUXcax1U33qJJUaCIx+y\nqOwpY4JVOhH1dx8tudz+lLPraUsLrn6xk8YiarL+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzFLjEAvfkxQstEfBVB69Kaq6\nVDUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIgYxebRrZyaqRzv1da2yzMzbD7rVACRFYPuFza3PaUoqgCH0l5vL2hcRCn\noANRgB/JHdR1E7iGgT/CfHFoJdBTeQI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAYsPUzFENlHKkoZvt4UugBVBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUzZDJhNzUtZWMxMi00N2IxLThlNjUtM2UwNDZmYzkwMzk3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMmY5Yzg5\nMC04ZDJkLTQ5NWYtYjI0MS01ODFjMTJhMWRkNDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATqgysxGZ9cvJQIzw7L2bNp8QlTJlzyFvDN/nItjcH1eVuly8suEgvk\n9/ncFJUTXv1UlV2YS/zD9wuGigjgljBbo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSfkRq6\nya5jqf5HetFTVS3O1dqYDTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA4FU4NeQ0ddLGz6sWY2mpqtzwCTQl9lYVqd10sjBOLtAC\nIQCrPKNYLtUyJvRZKqxpxpbXLc1PEeL2PCs7mBaXtNLzlw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6097", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6097` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISATFpOkVyyCt8Hji+WuItrrHcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNTEwZDE0LTNmYTMtNDliZC1hNGY3LWU4ZjZkNDQ4YWYzMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZjODM1ZWUtOTM4\nMy00YmU3LWFkOGItNThmNjRmOTg4ZWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdbp7qW/nzaoVkf7JrK/t4egeA0OlyjA15ejHeu5kjNrlpa0CI+MVHA5qDrTi\nvQK3EP97EpYXnkDN0NXS2mWSX6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2aanjIaX6WfI6DiFVRJd0Yr/EfwwHwYDVR0j\nBBgwFoAU4JC6QBUQJEo7WhAP2WSP3IjsdPkwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD8\n7GZ8OKPtLEqp38gicpkEOexsanlGwYI5f1lNRs9fFQIhAMirfkk2UnRoP7vJblpA\nUe4aOgjZ6ATth/bOTuCJwg/k\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfN3Pd0VwHJtUEoLCJrYx7cDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTUxMGQxNC0zZmEzLTQ5YmQtYTRmNy1lOGY2ZDQ0OGFmMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJZEbnP8/vCzb6CkV/kC1NqV62vJ76csExD/NBGgNwvml7\nzdNmJjoq7j7P6fduAiZt+dHs0elvc8jWLNNg/D+vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4JC6QBUQJEo7WhAP2WSP3Ijs\ndPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKPjLuBGngGxV8dyMoKDcYJion8nEOR7wPM+/bLRLsU3AiEA9zAltYXB\n2IgkWjmx3JhB9xamVhfyfoH+rDBsyHAzPAM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAejKTsF+pn/7OL/np5D+k5jlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZjODM1ZWUtOTM4My00YmU3LWFkOGItNThmNjRmOTg4ZWFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZDExM2Nj\nNi1hMDUyLTRhOWItOGJjNy0wYWMyMTRkYWQ4N2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARN4RYeTj0Hx2Qix1XzBp8AccrqXZkTaY2hCFa0OxorFSDBiZ9GTdQH\n8jEXIsdg6TgdjfyvF4WdPZ6pV/lrgFDbo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTZpqeM\nhpfpZ8joOIVVEl3Riv8R/DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBjDzyeYONedrioxApmgTRW1cojGlUnLtxFmEOd644hQgIg\nZyDhiSDYmLzR8ZzuS1+arTk3ThVxY0cbcE7BdF/HE80=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6098", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6098` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAYGZyoZjKyw3LyOD8qpT4eosMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5MjM4YWQ4LWQ2OTItNDgzZS05ZmE4LThjN2UwNDE3ODU4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGVjNzAzYmEtYTRl\nYi00MTVhLWE0YjItMTdhNTc2NzliODIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgk2JeLGt+tzTgMuoC51tbz32CBD7HCnKcayStxxdcnEHy3tVVY22dwWCl6mv\nurAfDoJ0hAQHlWqo++Jb2wM3yKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPePqWm25wP5lhEDD0uKjydGnC3kwHwYDVR0j\nBBgwFoAUSAQQ4olnVq/7J2hbbLBIywd/exMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICW95tr2K2odh4yHg9LYxSQD7+7g60N6kcYBj9I55bqiAiBI18bA\nc2KfNpid7QPls12Oc8qwqk52GPFZ4/yYhSyBXA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcOn+CFba9tZxkZCwUF/9DF4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTIzOGFkOC1kNjkyLTQ4M2UtOWZhOC04YzdlMDQxNzg1OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTmR3osiuc5Bk1hdGX+i3SGgtngKXo/Vc1mP9WrPp0ldnG\nY4AsUOlZ6ZPdrmzozUkASxh1cDprR4yHLRnqfTqZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSAQQ4olnVq/7J2hbbLBIywd/\nexMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgejttDt4CApX5WT2t/UJXuqiWGBI/2vxEwf72wCGMKq4CIHCZ1X5fteIY\nElULxpeIDdHQc1BrfPtqcjKjbZg1kCwu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbae18iXbwDzmyMdKRtBq1uaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGVjNzAzYmEtYTRlYi00MTVhLWE0YjItMTdhNTc2NzliODIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MDQxMzQx\nNS0wZmQzLTQyYzAtOTdkOC02YzUxZjA5ZDNkNTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQu699a1M5UTdk8nQ4LcxAQHpvHgEx9V5qRC/paSnjkLYbE46NKlkUn\n5ynGNfTTr03hcJQVneIf1r8gw1jHRR6do3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ94+pa\nbbnA/mWEQMPS4qPJ0acLeTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAH5m6+eph3DidxNRiL03wBc8paA24SFZ+BNM/FjSE36gIh\nAP7Ao8YyrlCY0t6AL46NELhxslwQ4Tc7T+I65+YYumA+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6099", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6099` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYvsrHzyLQJEdYSubsH7L8q3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxNmFlNzA4LWY3NzUtNDUwNy1iMWVjLTg0NjA2MjhmMjk0MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NkY2Y2YzItOWUx\nNS00MTE2LWJhMjQtMmRhOGM5NTI4MGY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtSMf2dDYNLqmiXRx2oMsM75c5EFOJq73Pq//vQGuVCB6Nf+wy5ggAIyqCVcb\n5D15NGKuvS8lXI1QK02SuAwFf6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK5tWfbnuTohQFwhSqG06R/VpGvkwHwYDVR0j\nBBgwFoAUcFnQ9W3Sx9PUV1hcjYYH761lH4wwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDw/856XxPyalF8astXIcM8l2EUBV6XYWDSruaoQ/QF/QIgcYN+\nJMPkIiCMcO/QZmyKzC/e5rgf2jwNn0ADzYPNzos=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc7jp+FIrhaWG3XzOQ5xocuBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTZhZTcwOC1mNzc1LTQ1MDctYjFlYy04NDYwNjI4ZjI5NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9YSD7MDo02n0bu0jmtMyDnhv11cbdjYFOqqZHvoN56ZQP\n8wcwzHE1X6i1srXcKuKowa11WNM31cb4xQX5Vt0uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcFnQ9W3Sx9PUV1hcjYYH761l\nH4wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgb13JWKS5ZrzvMz3rokdmPPnCKPurT3fC7gNfRqEnrzACIQCQtk4D9aLz\nzBX7wD6Gz/1mgv8ehPQloINeDW3OD14lRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQqTUYs6U7l/YA2p9tlfU5UwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NkY2Y2YzItOWUxNS00MTE2LWJhMjQtMmRhOGM5NTI4MGY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwOTc0ZjNj\nYy0yNGM0LTQyMGEtYTYxZi01ZjE1MTUwOGE0MWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS8d7R7qHxbmCthP7/pwXpl09cXWrxQm2VZNMYKYHOfj58BbAjZUt60\nssq98tdlNOlsgET/+zp14YsgRZCx2EKlo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrm1Z9\nue5OiFAXCFKobTpH9Wka+TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiA/UXHluBVc6NUnOMp3Q/mkPfZ0kQDTIOpG7AyKK2UHWwIh\nALUmhaLwK8A42985DwgLRtHXu2QK18nJzDTnp362yfzB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6100", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6100` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAUfMe+0sMAWIgA7K5WPZ4nsyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3YWY3NzBkLWZmNzgtNGE3Yi05Yjk3LTEwOTYyY2RkNDEwOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFlODUwNDctODYw\nZC00YjEwLTg0NmEtZjM2ODcyZTU3YTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa/Zo4ppN4f2lOh8w7Xj9SBsPCs1KT57CDjF9Z+vEc2GSEjINvhXHHLlzjjF3\nvSuEbTl9faUXobXnbA4IFQV/AKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFB8FUPHbSY4aeuDhIoixt59/7etsMB8GA1UdIwQY\nMBaAFH4TUeIQnw+eSWZBNl2vn6DXbNjhMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAyEo7a5dFNwM2spKMO2JJkEt8ounvgvud\nEJtRyTUHI/8CIQDCLqxvAzZ0lkg+74khsflkVf8O2wAG9v3p21OtQJfpaw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQFSUFFEkHOaN6TL+4jxWD6OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2FmNzcwZC1mZjc4LTRhN2ItOWI5Ny0xMDk2MmNkZDQxMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMkaIDRctaX8BqwqoxcOaW5KOxE8sYuQYrjPvFEAx3B07y\nzMFYa19qWAc1lzBPQrB85G3pIX+io/chuLnE9JJAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfhNR4hCfD55JZkE2Xa+foNds\n2OEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBa1MPNXQ4lRKrFp6SJ4GZ+YJ1f/XwgCIpVpmnUcpltkCIDKtr3RhYYVY\n2Afpue6qB0vwuZnxOaqzQo2aQvpteKcb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAacGcOh8ZpoVMFg9Lao4Ea/4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFlODUwNDctODYwZC00YjEwLTg0NmEtZjM2ODcyZTU3YTAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OWE4ZTY4\nYS1jMWI0LTRlMDgtYjFiMi1hM2FmM2NlNTY2ODUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQRYrOi0PvDRbkpXWSPSPZKUViBvFq8g6IkLnKEzVkLVUHpgFTsPGnl\ncyZ5QaUxCeVF3tQiS1Br1gwtq3+UUM+No3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQfBVDx\n20mOGnrg4SKIsbeff+3rbDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBynHjDRhmqpCuwFmnUeN9m3bIh3BjozJVH1JRZHaY4UwIg\nJFFBVHUzuHtIIuDHXJ1SyU8HJYBRGyypw2FQfB8ugFc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6101", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6101` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAdKHecyIMICRjEioEhgqprSVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YTRkNjcwLTVlZGUtNDMzMC1hMDZhLTg0Y2RiM2JhODk0ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNiZTkwNzctYWY1\nNy00NThkLTlhMmUtNWEyZmUyMzJhYWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9wSItzFmjDDisy5Z6gK5RxjoDZcdggZK5++dvebVMd8H7LNjCPaTUKgANm8m\n0CazKAG9aVL0uA4Ne0QUkQyVB6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULS7Umb9iqK9sN6lvsQ0fw4q8pgcwHwYDVR0j\nBBgwFoAUoull76wnHLrQIvYQEQ9L4VP8hFUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgDVxJQCfv9srQ\nOqSADkSNELKnf/ho8yZkM/WdClHixhECIF6fZinoxHwQ5hI0OaCRrFmj/azZV2y8\nKdx07RjVkWLf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVsUBrWzKPEUoALy5mIHieVYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2E0ZDY3MC01ZWRlLTQzMzAtYTA2YS04NGNkYjNiYTg5NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcm+79bY9x9JafN4qbbAz4DSCIaTYd6D69ivzpXmim1XQK\nOcxzi6gDDGwr46+i16jbnZ0nuJ1u0C/9oau8Is8lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoull76wnHLrQIvYQEQ9L4VP8\nhFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKIUdH3EB3T+jB7iy/1HSmQWxp0CNV33NIMfqaTljyAiAiEAkEtfJ2DJ\nxdx5AosyeU3Xh7cnCkssLFTZYDoO6t1Pg84=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAayndPEq5FGhQHE5duUY2DPXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNiZTkwNzctYWY1Ny00NThkLTlhMmUtNWEyZmUyMzJhYWE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMjljYjQ0\nMi0wMjAzLTRiOGYtOGE1MC0xMWEwNGQxNmVmOGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQgzPbiB/VS4DlybbwgZ64Zflm4PbpMuCHYrcjMC6rXiRLJOaggA3EN\nDBVlcuTcCEiGogk35F08B3HjAp1Lc+dxo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQtLtSZ\nv2Kor2w3qW+xDR/DirymBzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAlhdcp+m/GMwbCE6LNe6EdYbZQg9Lsr5+UkKXPMt3QDQC\nIQCPOyJTKwVzWlA5L9iggDHWmGHccONjaxp044o+TE1A/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6102", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6102` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVaUllSconvWs6u5rfZGNOKTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiNjMwNzM1LTAwN2MtNDQ5OC05MzI1LWI4ZTVhMDJmZjIxNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU0ZjRhMWMtYWJk\nOS00ODdhLThiMGQtMTNjYjY2ZmMzMTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEymn0fr0Z+ds0gnwjnRa3edmAPwY3NlzS/DyQzuuBYgqPop39JMEslZv/R2wd\n9xvsVO1HHe33IfOTpchF6Cjc1KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDLh2rA6Avrcm6/5+1/VhE7+i/S8wHwYDVR0j\nBBgwFoAUnEjbK6VIrNiWT/QxkfBJUNeR2pswKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgXhIs+KbAd4AU\nkYhitttGJuXgCc0798GZEhfHHeHg1eYCIQDbtJc44vmOp34tIb3e2+pMFu/8zZz7\nTU6dTUx6dQdfDw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU0dif4GNMPnIzVP3o+pkg73MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjYzMDczNS0wMDdjLTQ0OTgtOTMyNS1iOGU1YTAyZmYyMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASa6C+OKrL8ROyFqkF3ODiquwojp/l4up605V5vX/b7QzdE\ne7FSS95QZW3r08Gje2a/SFH6WdjDolgpseZkMqWwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnEjbK6VIrNiWT/QxkfBJUNeR\n2pswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGfBi0j0rKpQKs/SgJJflYYMnEWO1XQiWKyOg77YamHoCIGs+SV380JqY\nHKnNCSKTI+bNDmuSjzJSFeAB5zYvoWCG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAWd3R5vMU5tTeDt/e2KT5T6MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU0ZjRhMWMtYWJkOS00ODdhLThiMGQtMTNjYjY2ZmMzMTMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NjRhNTNl\nYi01MDA1LTQ0MjUtYmFlYy1mNjYzZDdlNmViNjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASOOxqdunAhRd/27tuZxbjpc96qccjaXXLPlsnx7jpn1zlv0XLtAUhI\n1sLnDTYVTxT3nsAVlHrh3AROAXtFPCtZo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQMuHas\nDoC+tybr/n7X9WETv6L9LzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBFrtL6ydvdGZsU5TN5/1B3Dj9DRNqZSMlKlvXV59NpHQIg\nO9e7nOTnYCrCvXq4ktLILeYV2iwQ6Rzpx9h9llztANo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6103", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6103` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARtO3s3eV1OZdo+p/Y4dGye0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNmE4NWM2LTVhMDYtNDc4MC1hZDBiLTg5MTdhZTVhNDZlYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThhZDM1MGMtY2Zk\nOC00MjJiLWE3NDAtYzMzNjA1M2JhYzIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn3UvAt4pEXyq8b8+CA5c55oMyF/J4NIXDbfnn3r/aGJlDTjgBXXffE3GhoyR\nTw815LzzIiatyNClhc57/c8JmaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlCQfU1J5PRf46bbi/KQBDDJDRcMwHwYDVR0j\nBBgwFoAUxFEGGPDFSu1ALZTutGtX/M4OEQ4wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDLLYJFXrvi\nx/jXJVeB0qCphlYO+ofmued5BA/8ttPQXgIgBsa/RKa7cOnI2VPtC18WHY/RvB0M\nFezktCpYJVITK1Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARDIQmjmzs89Q+5e/Pl4R8u0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjZhODVjNi01YTA2LTQ3ODAtYWQwYi04OTE3YWU1YTQ2ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATd5lMlzFrjJY6D2eHGjy250N4j5afu+ZmxqM0y82GxypO7\nrgfsp12eGxh3poUkSupfYVTOq7lCsC0ZyxlR8TWEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxFEGGPDFSu1ALZTutGtX/M4O\nEQ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMd+ZASO/nQKs/WtS2iCBPSW70m/fZs72aTMB9uxFWx4AiABo4WrJN+0\nmdMWHTIH2A8JE/Itb0flbbqu+PTPoWa4eA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAe6TBKMjprZfwYN6cuKOT7mnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThhZDM1MGMtY2ZkOC00MjJiLWE3NDAtYzMzNjA1M2JhYzIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZWUzYzRk\nNi0wZDk2LTQxZjEtYTkwMy1mZGI1MzgzMTY2N2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARbqhJ/BsAvrWxKFWap+19++1/UShTzdKVBEofZ/vZyPy/3pYhFtjZ4\nO/BB9Ea59fbYcoUxo4/++eLO9tB/B7Joo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSUJB9T\nUnk9F/jptuL8pAEMMkNFwzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAuiAm+5h+vAoXLUDV9GDg7c3rxM1MO/AjnQOtdVYmOM0C\nIQDWdcQDZrNT8w6r5Udrx33Aec2x4wnARe7MrAZpNAT93w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6104", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6104` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcDsS2tkR2ahlEOmn/C06M4oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlZGY5YmNjLTA2M2ItNDY1OC04NTFmLTYwNTRjZTAyZWNjZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzkwMzQ5ZTctYThj\nMi00ZDhlLTg5Y2ItZmIwZDU5ODFkYzM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEacwzRl3ccZojgw7t+2xmQ3GkXznq60TG6nMUpsAzY1C25XBtXzRjv7HIYRui\nTBgizYoFVGzsl+op75mOCW29jqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXUmyxkpfn/G+xfqbv3hxzx7HtxcwHwYDVR0j\nBBgwFoAUwdqZK07gJ2G7s5gDRcpELLaxgEUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFKgRmvYo5CJOwfwVjuKFLFq+aKGxQ8FOQPJUGWGxPWWAiEAtCWh1AKizvwn\n3B11l5orT85vf4Fvag/ddBIZKudlEec=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVVaZd/r2I+33hnaBbangi1DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWRmOWJjYy0wNjNiLTQ2NTgtODUxZi02MDU0Y2UwMmVjY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjvTLZRmkcxFbqEnDgV6qKb7PUSWDOc6yvyCedooy7wLWd\n/Ytey31gGu0mFSvSpOiGJWaawe1jumxwckl91I7Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwdqZK07gJ2G7s5gDRcpELLax\ngEUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIOW0G6MYe52VHISNbaMr62a6F77RxikNZvBsls7juz4AiA6yJxHaYXl\nUQpHBAoCi9fUMaNqMpWpxG/0GQ3ChsNZPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdB4dXrYdn/6Alp9zvtE/f1EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzkwMzQ5ZTctYThjMi00ZDhlLTg5Y2ItZmIwZDU5ODFkYzM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwOTdlMjZh\nZi02OTMxLTQ0M2QtOGMwZS02NmUzYTJlMmFhNGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASloRy5oe/+XCDQxQE6QGOHwlMzZdrYYQJTdFyaoz2B0Q7KVMPmSNu0\nvzbosWaVW56O2w91SWvZp09Ah6EIv80so3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdSbLG\nSl+f8b7F+pu/eHHPHse3FzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiANjr/ALK+r4Cr9g7smw+Xdaj3o2GZZMSzUDpUxMF/uUgIh\nAMzAGKor+fHvvonK1r6mIhu6cpn0H5ptc0LGT9gCvE6N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6105", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6105` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWvz1OfxBguHgQiIex3vvsf2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlNTY0ZGY0LTZmZGMtNDIzYi05OGIyLTkzZDU2ZTg3ODdkZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFlOWFlZjUtNWRi\nNS00ZmM3LWFkOTUtYWM0MGFhYmU4ODc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBKfhUamLPmAf42yMhYQT27G8CP4MO5zCXpKwKXBHjW1p3D3t0+WXZcKva3/w\nysgmcrZ+tvewppYM47Y7onNe06OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUynQWUx9bPFMnlrID0lFXaZQSpVAwHwYDVR0j\nBBgwFoAURplnMEMeP03taFRBu051VuWleDAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIE1MiOKBak9HnaN4v4aXmdrukc+rSo/wHjy9XctaGSF5AiB8nJHcqRdLZBee\nCDek8hTiI52v8yGmcYWUMh6brVI75A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ84sg6gLf6rTD13EB5I/3bQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTU2NGRmNC02ZmRjLTQyM2ItOThiMi05M2Q1NmU4Nzg3ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDV41cLyJBJOkoHqta42obKWr5DtHnXpF5t6ufmETCbemy\njJ+IVJEPs/Srmr7qMzxun2yZEbSe+V0Ilr+dQXrqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURplnMEMeP03taFRBu051VuWl\neDAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYMkNbeRoE4wOF4SS/Kk02Sv6rvcXjMr04areVGQ6B9MCIA8qcZSO/gi+\nMgGhhCSs52t12ZKlCkVUVuKiIY5Ec5s0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdJpMS0QIoJl4SoS25TWEqvaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFlOWFlZjUtNWRiNS00ZmM3LWFkOTUtYWM0MGFhYmU4ODc5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYTRjNDAz\nMS02NmNhLTQ4MGEtODFkNi04OWYzYjdiMmUwODgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQiEh4BVtkLWb2q834fRwgduTPU1+XPUXi/pTcmKz0SqO3DAneCkPiT\n6Vx3HGLaR8SjuMcjNif0qEDU//YNSI+Ho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKdBZT\nH1s8UyeWsgPSUVdplBKlUDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAg20Oi62MmDzSHc6VBRBkMhEMgDzYrkRK2bkgUF8ZdeEC\nIDORduuFJNnDabj758BU71A2lS8FPtpn9s+dcBO24b0E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6106", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6106` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAYAZH6+s7bX2kRMeLzyirgQdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4ZTdhMTU0LWM5ZjAtNDE5My1iYzljLTU1NjAzYTBiYTIwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2YyYTNlMWQtNjYw\nNi00NTEzLWExYTEtNmQ3OWRjZWIzODQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYpp13UGkH+torstIyUivon4HdMbkq1Ga/ER3yq+JtmkrIXYkqd9xYf53MlTY\nhgoAhSA1eooDEqs2x6rsS6HWPqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW6aFEJ5tmKogkkR9x3EwAa5vLPMwHwYDVR0j\nBBgwFoAUGFEVWZlB5rA2I3EjAgP2Npi2POcwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIB/C\n5uIWUcRB3wq9H3i3nCQKLHmb9NNAwHd9glxPwN/QAiAsPSE6y1nenbk96bvLjtBq\naJHQdxKs0hVkKNeGwYFT6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS1lTgAvEx4tF6VKjiB+RS3DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOGU3YTE1NC1jOWYwLTQxOTMtYmM5Yy01NTYwM2EwYmEyMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhAtYOq5mxVIxCQuCTRxhmKCJ1D+Vk1x9W/oo290kpX343\nNVFD3owiJDfyUNiy+ea5cYqcaaoBL5XlmFTjhqqoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGFEVWZlB5rA2I3EjAgP2Npi2\nPOcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIj4I8392+gO2fJTpAmf5LxmDBTXjCZi1b5+0nbQu54sCIGXzXbmH72aj\nZafP6m/n2MltZXOYK5IYUbIRstB16s8O\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAcROvHheUY0K4odbahMdWhtOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2YyYTNlMWQtNjYwNi00NTEzLWExYTEtNmQ3OWRjZWIzODQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZGZmYjdi\nZS04ZTZlLTRjOGUtYmNlMC0yNDczMDAwZDg1N2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATHQU7WaMwh6X0w7AQ2nmlxciwZoZy4LePbGYPYH3VZ2jgZP0l9jXSh\nGosO/GA9o6+W1Uk0KD+y7dLEPfz2lcmUo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRbpoUQ\nnm2YqiCSRH3HcTABrm8s8zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA6d5+OgFWwzNma+wcx+O5DpWdSAnf+6iboT1DsN9OsaQC\nIHkWpmMWkMPPLwfTqS49dTuqA39UYntFnARmtnO8w4EG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6107", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6107` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISATh4JE+3KRoEx5SSKmXgRRV1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNGIwMDI3LTJkYzItNDI0OC04NDZlLWVmZGZhZWFlOTFmMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU4ZDE4NjQtNTdm\nZC00NTg2LWFjMWEtY2QyYzYyZDc3NjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBJLYNW67VanNAT5eWvHU9mRUpCKZRZTuiOCCyalPbAYx7/hn61MYY0R0GwCb\nUjfPbO84lBPdE/4gJSM7roj+Q6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2KSVBCD7j9oM7DsldarGblevxZIwHwYDVR0j\nBBgwFoAUBiAYn74+PucdoHOsxp3QynacORQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDWRohxPq3xLc+B7dFvpffUmmKPWFYxnorAe/sRkDkYjgIhAI+C\npIzfe4RkSbR5UOjtvoUimCsIvFsMthnS+MfYRvSW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaj5s+mQGHkyJ1Zzi29JQNanMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTRiMDAyNy0yZGMyLTQyNDgtODQ2ZS1lZmRmYWVhZTkxZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPYrTuHUJ9nA5tP54oOjZd+V69jgTJKFzjlYFxfHyMNfn0\nU0XwvGKQV6Z8JI58tIDtHR3thP/U9u4hB6IPiHIho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBiAYn74+PucdoHOsxp3Qynac\nORQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPfVM7ka2PDKU7tVOTnup3NmfSSsphoFkSPSPjJVNl78CIDxqmcR2o1jP\nTLtM6wEhJbIrmlmzZ7QrcANPj3QlFTH8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAfZo3yym16esFBnKXmsoryguMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU4ZDE4NjQtNTdmZC00NTg2LWFjMWEtY2QyYzYyZDc3NjI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMjY1Yzhl\nNy1jYzljLTQ3ZDMtYTc3NC0wMTMxNGM0N2UyZTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS+7DJOyCRIpliMbv1KBq/7/NBpMg16B8TpNfC3qQpSWB8xLF3wAGLx\n8+ICig6BnwUY59tYObhFHXx48k0pS/eko3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYpJUE\nIPuP2gzsOyV1qsZuV6/FkjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEApi20Bs9eQfVCznhQTtE6f7vCvE8a3vip3p31HLw5T10C\nIQDBgZL2xtwokZH/te3aFgrrkeF3x7MqjxmlIOdExekiGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6108", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6108` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAaU5Ln+24KJJ0c3XO+DmxTUvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwMTliMjJiLWZiNjMtNDRlOS04Y2NiLWZlNTY3ZDVkNDEzODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUwMzM5Y2EtNDMz\nMi00NDZhLThkYmUtMTJhOTdiMjU5YjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZAvTG5M3YkGAq4ZAE6JNZIN5aCbPYu7QG25mr4f52Mvxc7ASezxHIGEfgNpB\nDIJxUBZSVAb855dlX9DIUc1iU6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbSC3LE+TJimyvIw+EmWh1vHJI08wHwYDVR0j\nBBgwFoAUg5dQZb7VTun6S3kaQf2+u5HQ0VowOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCKZrb7CJ6+LeqcRj1UiyiOKQ8ccktZ6Cc6c06mpVyXeQIgTtfR\nBlmfqCWJhg+qTfapDms36NcxTfUgCVebOV/mW0M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAezLd7diaJaonKvtQin/8+1NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDE5YjIyYi1mYjYzLTQ0ZTktOGNjYi1mZTU2N2Q1ZDQxMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQq4qncthr4hwG5HTyIVy9Q/Hi+4PU6LCj7ww9iGDC7KG5w\nNZktO2q11NeLkhx04+LxC25jRpM5oJK0XG9H1yuRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg5dQZb7VTun6S3kaQf2+u5HQ\n0VowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOAgKRB1ZwElAMMAVmmiPr/O20CCm5THJfkfwuwCiEiCAiEAtsy8qWx5\noGLEHfNLcrs0HJmcZamMtZFN23VUqZX7NnU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVxXssFsWJbquUX+vfz9dUqnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUwMzM5Y2EtNDMzMi00NDZhLThkYmUtMTJhOTdiMjU5YjhiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYjNhNThk\nNC0wNTRmLTQwOWItOWE2MS02NDM0ZGZhYWI5YjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQvbg8oC0hwbWcrep/XVxTkiqLzyeCPf0hruJKl+P1ir66g/A6Ex8SU\nhenHsjyeAukaMdx3yc4aOUbQQoMPUZzWo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRtILcs\nT5MmKbK8jD4SZaHW8ckjTzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAzG7WhWliHzw1LSFxE0habGr8NLNneHmiElMBlukP9ZUC\nIFzKJ3ZIYKFVjp/nNWpnvfuYQNFWIV8Pn3YBgv9mylPm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6109", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6109` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAW+eKLVznbEgsltRy1oX/WVHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2ZTE2MDBkLTdmOWItNGJhYS05NmJiLTQ4Nzk1MGM1NTNjODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQzNGI5MmMtYmU5\nNy00MGNlLTlmNzQtYWI4YjZjZTNmYWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbNqi3EZluzZ+bntuZKAPV6gjhVcIylzw5d2sp9+wjwfMlvy1ptsrgQ6SH8wX\njRiKLF3ERD6Hia1ELy9NeEKpeKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRGvab6N7Jm1GPVF5cdCCuK/Jtk2jAfBgNVHSME\nGDAWgBSjpwJg9+L+HMkEiqi0ffgjCQ8d/jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDxdD/Dm3PQqKAbh+WahEcK9t477JdS\nti7kdD34nzfq+wIgQVxpFPONIBruS/rgLqVvEougwbIjWTPlrZTlkX3OFo8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUGND4vWAG9qz9jWLsgzRw5mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNmUxNjAwZC03ZjliLTRiYWEtOTZiYi00ODc5NTBjNTUzYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUpm8VM+VoRjr8rM92L/I7aR1D/y/xeInRyO8p+GdUS3al\nJJGxDhwJ7HB2K3MSoGCd03+tqZ5szNlBXeCLlCFDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo6cCYPfi/hzJBIqotH34IwkP\nHf4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbxIecAU8kvCk1YWE2HdWmXcPR/xMAqkKQyVctw1r/+QCIQCIUVPu5Lgb\nXmEMck6H2Whw5fO2YMf8nAFUT5zx0eb59A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUNG/mZ0FdB7Ze6TyOc00KwoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQzNGI5MmMtYmU5Ny00MGNlLTlmNzQtYWI4YjZjZTNmYWEwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYjZmMzVj\nMy0zMTM3LTQ2NmYtOGRlOS00OGNhOGMwZjg0NDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARo3noVC5Ka5jOTDJa73y+BCf+PCTdpnGnS92nEbQMhcZsXg5K0ttx6\nDXKpiO11iUi2HGix0wdpJuVpgvFC2hmho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGvab6\nN7Jm1GPVF5cdCCuK/Jtk2jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBL16RoGtPh2pXDamInZYxuTwi+mwAY201cctQ9a+FSfwIh\nAIxUGJLN+eaQMSYjWJy7u/GW5c9/o/zJSVyvAyqqYbd7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6110", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6110` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAb8+TMC9JHZkXafFcwDYL4zxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkMDdmYmMyLWY1MDQtNDNlOC04MjA5LTI1NTdmMjQyZTkwMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEwNDk0M2YtMWQy\nOC00Y2U5LWFlMTYtOGJmNDQ3MGM0N2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyEXP0FjaV2ftV4FPpdytrg8XxzDV+0FQprHEESoUi7rgP9Ru8J8OoceT9eyv\nqiFxbTBabG9q6SwPjUDRGmBDdaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSl5qLisXdkOx/p25t3+1yUitZAUwHwYDVR0j\nBBgwFoAUSQSpzXpiaCmB/jTetOBTr7Hyf0MwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCICjbNiNQWVFb\nz6VHok3FTUw9ZTXQ8nkjDVs/8ZjLu1ocAiEA6yVMq5jRkrfQgL9JFf6wLs02EQQ/\n+ZOBHJ9OzQDoNn0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARDEY624PCWLBCyNshJzPnp7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDA3ZmJjMi1mNTA0LTQzZTgtODIwOS0yNTU3ZjI0MmU5MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKRXUalC7Y4wSLEHCeYXJE99HaUR4E7bdsOEveQhR1WAhy\ntJbbX8Qzj7WbKGPdAz9TpDHK3KyVl6qdVad4G5Dro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSQSpzXpiaCmB/jTetOBTr7Hy\nf0MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBucLUwG2DEhnE0bGTtYkogWlvNXX38ZzfsjtmxChS3YCIQDiW7641XEi\n1/NMIntUDMHMFaMptTOD1R0MJz/KswS5VQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASUeFJvoesSzcDH8VUpKpot2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEwNDk0M2YtMWQyOC00Y2U5LWFlMTYtOGJmNDQ3MGM0N2NiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZWI1YzZm\nOC05ODQ2LTQ5NjgtOGQ0NC04YTEzZDI5N2JlYjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAShp0gsVWn6H1iOIz4OFf/9d+kHKkhWk0j03J9NjxGoqtNpfTSE447c\niZCtUJhrDZHI1rtf2mpbNvO2LEL8JBjho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKXmou\nKxd2Q7H+nbm3f7XJSK1kBTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiA0zkbNpp2R2+LX6bsO8XxUKyna3sGZ61r+2R9twrGAbQIg\nBcEPtHpOB8b3rrgxYiJNF+nND11o84lKJ6f7uBAY27k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6111", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6111` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUuzzmD6FPO4u56XoPIy4UZ0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMDQ1OGIxLTViMTYtNGIxOS1iYjU3LTYzOGY4NTE2NDk2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUyZGNjMTktMjlh\nMS00ZThjLTg4MWItMGU3YzlhNTMxZDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMhInKUhSrsaddiTh0zAnVxbOpokCuu+nL7K5JtPKgNCgFMa0hwXFxC0Cwtrs\nYxyZ6Ub1tf7BCByI114DtxgZg6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZKA28gTTdn0NgIqKnGnmSmjVPAYwHwYDVR0j\nBBgwFoAUG34JhgrrIjkvUGnOA1jsAn9GSH4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIH7vkL9r47sr\nB5cGODx/zbeYD2uQwN/MGGSXQ61XHsRDAiEA1hSh0tel8AHOJEKSHoZcchk9Z9Z2\nrVXa47KnatwkTs8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWXtLMv76Q3iJUrg/a05xuQzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjA0NThiMS01YjE2LTRiMTktYmI1Ny02MzhmODUxNjQ5NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6DHbx9S86wXgx/ZyvVuK/c4OtZu9n9i/NwklIEo6RkZmm\nJYi9f2OAGvH6ajcWQM7NmFSznDmAxpTyHYCS4+Ejo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG34JhgrrIjkvUGnOA1jsAn9G\nSH4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD+fypKP+4naTNRiTH5C4fKhUPRvLK2tFVqSdj8LyexECIFfzE7/tuokI\nsRHIzu4QNqndmN0yzdXuCHD381Lp4EJS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISATrZWbVxESgR5GJn0zd/85f0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUyZGNjMTktMjlhMS00ZThjLTg4MWItMGU3YzlhNTMxZDg2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMGEwNDQ5\nYS0yYTNiLTRiNGUtYjU3OC05NjMyZjcwNTU4OTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ0ph+j41agiTC0Y6lZh+a/w+X58s106Gd2OLH2KjvovlOnmmgSNLU/\nJxzILopxaHuDyQQRh7IUxP7v7vEn8PqBo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRkoDby\nBNN2fQ2AioqcaeZKaNU8BjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiB5QKxcvhV/uP1KiViAqrPFNRDgi2Hi5uefu22yzXXqawIg\nAomXqG6nNYIdhogYIFOwZm7+wLRD9OtqzB139zr/+Gg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6112", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6112` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAc5S0Z28FL3iYYzDETszF2CBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjYjE3ZGMyLTRmN2MtNDQ3Yi05ZjRkLWYyZGM5N2EwOTI1ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzlkZWViYzItYjBi\nZC00NDU2LWFmYTgtYjdlMGQ2MDYxYmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdApyuqSlecTKS7DFfck+ulfVNRsqMZo3vvitdLECmm+8tjAdOKP2ctkozauT\nDRcE8K3oCfHPxvezGpzb09FfhKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdBpStOlyzRA5Eg85prekvzgjzagwHwYDVR0j\nBBgwFoAUVZpt6Ul3Y7ZfgVHh50Wu5WhCbYEwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAoaH9Pi78\n72UY+Btx97bobGxtaMjdet9DhyaD6bfEHK8CIQCBUDA+QNaOK4GHf42NcGKSKZQd\n+K/P+sWVW2q8jbdR9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATDlQkOVwI2foluTOyl6Ct6SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2IxN2RjMi00ZjdjLTQ0N2ItOWY0ZC1mMmRjOTdhMDkyNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcWWnPqABXANZECKxABQyh4McKaVvuDD+Sys2Gn6gu2vSy\nyy/gAHIH2gnscEUYmY2D7ivbHguLQoVIIu4K8/9do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVZpt6Ul3Y7ZfgVHh50Wu5WhC\nbYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJiHlY9P1fkZ9083jtQlFnht68K/wu0/Wyg2fZjbVmrfAiEAqLwoH2QL\nPN95kA5K9MPbShFBUU+OwlP8pzmbTloEkBo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARBrPrFmRM53O6gV+Xwq4rqxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzlkZWViYzItYjBiZC00NDU2LWFmYTgtYjdlMGQ2MDYxYmUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MTEyODYx\nNi0yMDMxLTQzZjUtOGRhYS1iOGE4YWY5YThmNzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATnMA6ICSS/E2nUWO/P94KqdqVimI4RyTKAz/cr/SNn92/LVtv/t+sL\nUwpEH7D6R0jT5uAhe3oQ7+FEKG+Ec0TTo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0GlK0\n6XLNEDkSDzmmt6S/OCPNqDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiA1NfggFpnmBAO53h3ccBhAbBuMTVuuAyfEPCBQfFCOdAIh\nAOY9Ck+gqS8mx/AVr/0hXNyq2moJBsJuKcxBF9hn35Lw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6113", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6113` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZG31TFDLalcQxbsaICkOCJYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3ODE0YzMxLTMwNTAtNGUxNy1iZjg2LTlmNmNmNWNjNWFiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2YzNGFjYTAtNzRl\nZC00YjM5LTgzODQtYzIzN2Y1MjQzMTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8+JygcE/BV4VV3sBR3jpVcPobZYOwYE6+L8Rf/4jSnx/CqNOt+osxWp+J9cy\nlx3aIrufO4/GuuZoYAPXGLOJQKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPSdr3Mr10IjVnTp2pGp0T9ZYdH8wHwYDVR0j\nBBgwFoAUbfTkSDhmy7jh5BaehZ9my0fJOl0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiB2MD2j4zhYICNNXElBt62QKtiT+2uKDZP0nXGNl+hAFgIgDaKrk+4IVbnh\nR21FVpeiM7DXgHb0dk+cBDczBkVmTpI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZwCwnRDaKx0nvA3+F/Yq8irMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzgxNGMzMS0zMDUwLTRlMTctYmY4Ni05ZjZjZjVjYzVhYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6nXh3AFcyByhF5HGv0CaQUOcKSIqLTmqgUqDkNJ75RzCp\nyIYY1nu4KVAGve6yjIwu4NcUwfOdtxMMPCGdmSWlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbfTkSDhmy7jh5BaehZ9my0fJ\nOl0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKy70AR0I2JwpXrrZz4TsRg1GK9a+UJKYHgOm3st7jsZAiEAv9ABBuAu\nm0DzkXxiS0tU9/L4UNhwMdjOOmQLxBgWf5I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAf2TIWXQWyhGokH5ffAa5QrwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2YzNGFjYTAtNzRlZC00YjM5LTgzODQtYzIzN2Y1MjQzMTMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMThjNjlm\nMi03MTgxLTRlMDktYThhMC1iYjk4ZjI1MDYzNDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASfxK9ZNXJa3EfxEAn8HwFohwh0QPD2OPQhn9lMgslsb6c0lM43RWl9\nAFsKIdklwQE/a8F0qV1sqgTbFllYfTDCo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9J2vc\nyvXQiNWdOnakanRP1lh0fzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiB6tDNlbDwVnGn038XgrXw7mcXNj8CNCrZsjCJAkRaTGAIg\nW59ibvoYSOi7wAwxPXEAE7jMZaJVLe47XBoqDDV1lTs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6114", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6114` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAbxjMmm2TWTxRYCD3Xd2vHk/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MGU3YTVmLWI3ODktNDQ3NC05MDY3LTE2MzkxZjNlZTk3NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhhYWQyNjMtM2I0\nZS00OTk5LTkzZDktNzliYWI5NGY4ZTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/+Preu3krxNi8HL9EYrD2bbh3m3PzQ0s1H4OX1nrTeVqOPOwwg8zWok2JLjN\nvcFsqYJYVpwKz/fxX/9X418gbKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfjVU+NXUE0W50gZWstN/w1Xm8OQwHwYDVR0j\nBBgwFoAUdjE1BhTlpHv+FWs8CVf9/hU4wsUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAoiks0GXEU1rFlTscFRavIFNmyMcYeEVGke5mbvD3V+wIgGNny/tYP2w1e\nJulDkEp/DA7t2636SXFoneZH7DTjl3A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdqOl6CRdyrHyo6fcDsJK0bwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjBlN2E1Zi1iNzg5LTQ0NzQtOTA2Ny0xNjM5MWYzZWU5NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4YQbL/UqYtMXWt/4HNEZ//1KWa7cDs/qITbc7Ra7bGlIt\nIKnFdQpie7zyibv4TO/F05pbkmjzkwW87FdwnUkTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdjE1BhTlpHv+FWs8CVf9/hU4\nwsUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYUywqsanzzuR0kInAOaIitvdiatcpB07vK55xXAXKlYCIQCkh9MmrPTe\nDW+Q+aPZE5bprvuOXFb/UoAhCi/gWSvQow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUZXeOHo6Dp3pgzSQHtuAGtfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhhYWQyNjMtM2I0ZS00OTk5LTkzZDktNzliYWI5NGY4ZTg0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYjYyMTEw\nOC03OTM3LTQzMGEtOGFhOS0zMzExMjgyMzU3MzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ6ORrIBStYoWY+V4k9KEaAW+ClQQzFqVV2uwIww2bFK+9lzrWXRHaw\naRVpbi+FP63aK3nDSRYY871+2Er85G7Jo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+NVT4\n1dQTRbnSBlay03/DVebw5DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiA+4a85X3uL9yFVNpEsmM85BRUbeUqzZZnYJh1SyMUdugIh\nAI2aGKKsyy8G2u+Jtbh7OLeFOmgcFOKe2M7vTmctHpOd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6115", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6115` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAXTijdKKh9/RIiYFIn/+nQx+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyOTNmNjZjLWEwYzYtNDQ3NS05YjM5LTMwYTJiMmZhMWZhYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRkNTFmNzAtMDBm\nZS00MzI1LWIzMDUtM2E3Y2RkNThhZWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbAmwVNgf99KjjKvLhhPib4fhsCD/bWxjDesuW/byQzS7a/zwxwNsFomXM6xM\nOeA7SePvTGS9BXP7x6j2aNCEZ6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKxvOQhwFQO2z8o2e5uAmuZ466eowHwYDVR0j\nBBgwFoAU3ODC/OEYS+c8F0GsSbgPXdipEh4wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\ngGCspi45QF/tgxSP5wRZtO0cDbZ3zIkdawN2p/fzCdECIFUydJ9LDoyqVtV38XOr\nCybrEuJwa3DCxwk3COJbdlfA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcFILT7SGnKGy+4Zwhg0Xge2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjkzZjY2Yy1hMGM2LTQ0NzUtOWIzOS0zMGEyYjJmYTFmYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhhlkCFw7UFC1lFhwa9V40jfmxDQQgruT8ZOHyJGWcD8Fc\ntNroy4Rr0ALUMZStGeKHAlFhhPKBRYXRarvAWbIQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ODC/OEYS+c8F0GsSbgPXdip\nEh4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEo4Qzit0bSLO4gxvhaNYwj2t4DqNDFbbS2x2StuRGJsCIQDsg4ifciu8\nUtmJtCucbtj24fuCPWeD4E77GbtRYvvyyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfG0cGVxkVtBFpT8OBYS0pGiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRkNTFmNzAtMDBmZS00MzI1LWIzMDUtM2E3Y2RkNThhZWYxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYTY5NjA4\nYy04ZDIxLTRkNTctYjAzMi00OTc5Mzc2MzI0MTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQkOgkxBacVV1aAkkLSn2FEt8anTtuit6cPBW02BhapuKVpY9Y50mI2\nhBrkppcPkkj10VzU9/hIFOyeTs4b754Jo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrG85C\nHAVA7bPyjZ7m4Ca5njrp6jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAjFhgWLCugTkrmL2UmE8yXemLb0CmNW3OKvgtN5MlfIgIh\nAJzvGr5fWJA+ZV+I9CPabD9vcrcvcyN1Rur7vQcS92mm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6116", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6116` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAfnuMf2DknHtOKfM/IEdfIURMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZDA0Y2JkLTg0MzAtNGE1Ni1hNjk1LTVhOTFjYTllOWVhNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM1NjRlYWMtMTRh\nZS00Y2IwLWIxMGUtMTA0YzBiZWZjZGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4Ilt5Hgw2BYh6LhnYKrGZDr/ClZkyjxKnK9ez4IfPuglAGnqjAaMPOjUdRij\nB4iu9KzP0d/rSBnyCYYk+lbmD6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYk7GCO3EbOyNo1cLqH0risPwaSMwHwYDVR0j\nBBgwFoAU+oZ8VWQM2FGKZL1v6l3c7BxHQ0MwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA5ytvAE1HV4HSD8ebwjGSX9G98UTONVkWnDTaRsZTng4CID/p\n300/F4f7DurJPxAOPy37E36g1fyXP4BRHuyxE0tu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZgkUkJ6bBjxgs49TeHH/akYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmQwNGNiZC04NDMwLTRhNTYtYTY5NS01YTkxY2E5ZTllYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzHN99Xcx+0VwSGwnD5Tag53zrEb62AW0Tsc7B7Gb/2xxP\nj2Vj8y5zB+A0idShHSM9YvjBe2q2tuTfF2JMJjMKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+oZ8VWQM2FGKZL1v6l3c7BxH\nQ0MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGv/954vMFjdvIa6QhFkbNU2gtMSZFVkxyjElppiynO4CIQDu2QYJVa3B\nPOBCQTeAxjp2dFTDbZ8lfwoEqcrjvC3VsQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAUf1S8r3SRdv80t+vHFA3NUbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM1NjRlYWMtMTRhZS00Y2IwLWIxMGUtMTA0YzBiZWZjZGY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMTAyMDRl\nMi1hZTFlLTRkYjQtYTI0NC1kYTQ5NDcyYTNlYjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARJl7D+XePFjX1sGGmKsOE3R0SAOIspGmm3Ivp9Kfh+YTwSMij0HZf3\nAY4zIAHn/oNjtV2GMUCvbHpXJXaPvyz5o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRiTsYI\n7cRs7I2jVwuofSuKw/BpIzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAlL1cYlqWHNGae77i6M08jveqDmD1pPehRu6olwy6Fk4C\nIQCJWOF8DMYmuB/mn+SjLo88pGr6jarTex+UyZgcMGa5qg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6117", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6117` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZjL4ODksJZASOh0HA5vSfprMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiNDc0MjJiLTZjNDAtNDIzNS1hNjM4LTg5M2EwMTcyOTg0MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA3M2YwZTctMDA2\nNS00M2UwLWIyMjItYWJiZTkwMDI4ZmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkezQgDQ7Kg7pHHsOTLycf3TNll07mxw56hpmYypOuYI8GT+4El22ykby9ekJ\nMZQoLnn/eTO0gTwqOj3/TKpINKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeGK1tZKb944WTP4sHZZRINv9JOEwHwYDVR0j\nBBgwFoAUWt+YAt2P+rQMmbbusuBtAEei1SswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiA85T/14C5U7nE1iLYOc1dhZnkcHdF0f5LMQ9NS2GLp/AIhALSe\nilq6E3iYC2EXLLquUHL5giit9JHZYzCJCQ5MZxzF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASRs18wyEoyKJ9x75xpInhBGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjQ3NDIyYi02YzQwLTQyMzUtYTYzOC04OTNhMDE3Mjk4NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZ5uVX9ta9lWnAilSC8s5UVCVd3Z0n0HZLEXEmfwzAgdkg\nn8JLuCa0vtnTC8Cp347IEQXEmYch4pV7zkzG7Fa7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWt+YAt2P+rQMmbbusuBtAEei\n1SswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBQbTWIkspkecCkzGuxiGOk8SjOchYRFKUlX/WQ/N0roCIAdYLq299u/F\nWpPWH9xEAx0OMHC7Y7iWldwCkr8LWH4f\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAdgQ7fM90L8+cXCCXImd7Cm3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA3M2YwZTctMDA2NS00M2UwLWIyMjItYWJiZTkwMDI4ZmFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNjJhYTZl\nYy1lY2Y1LTRmY2QtOTQ1MC02ZmQ4M2FiZGFmZjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARa+bfNk0YmQmwpBreyksBpmHn8LMHKr6PceZl+u7b4qQ0+/rwjQiwh\nU5LMe09lSKp5cMdCZQ7zq7Ydls39dfR/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4YrW1\nkpv3jhZM/iwdllEg2/0k4TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAqx5oEcgkSsSma3SCauc0SvOwRgBOyXZsbKwtXZvUSuEC\nIQD2Dbj1gcOzwC2BCEr2B96Pk0eANoIKh1I3bERVrIeSdQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6118", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6118` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASN0SYITuKupvO0yuUA1IDSwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3ODA4YjNhLWU1NzctNDkxMC1hODc1LTg0N2RkOGI2ZDE0YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJjNzQ3ZWMtZDE5\nYi00YWVlLWFmZmMtOTdlMjk4ZmM5MGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8PUICCgiADUZz+2/mDFIonVLZVjU1KFXU2GY+ikrUsJkTR8p3F1UYk6/Ghgs\nWJ+rQJsbHVhThk6mPuD5Y1hfsKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIpHQDUR+FQuIoOYuHOGwuHTx4rcwHwYDVR0j\nBBgwFoAUqtHskpL1e7SNhsnwb/8291IbwrcwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBEBVR4yVsX9MVL\nbNV+D9YYGAXdKd2qEVuQZs0D1jZTZAIhAIj3ACImvLzBTIL/+YPbJwr+7duLyAoA\nJMmY0jWOArwX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVzLnOBlKg2TSASTVTrmgnNcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzgwOGIzYS1lNTc3LTQ5MTAtYTg3NS04NDdkZDhiNmQxNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3X7p/w6oSyGpUgEw2xmyhUBa8kO5snIkuc1GMmICMn+bs\nfiy43l6UoWpxguUgMduV1i4TA6VD81iSOnGBvcygo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqtHskpL1e7SNhsnwb/8291Ib\nwrcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPmq+y02XfsWoEKrV4EZQYoQSuVC7ThTzYFK71Wr9F6LAiEAvDWajEhw\ni2A8b718wMvqOpflrJ1OX98AWkDFgDTAXz0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATTR4T92/x9q8XCDvsv1Z2e9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJjNzQ3ZWMtZDE5Yi00YWVlLWFmZmMtOTdlMjk4ZmM5MGI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjOTM3YWQy\nOS03NjJkLTRiOTYtODAxMi01YmI1MDI2ZDkyYmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT8xm/dLY1YerydG/hjn3iwRscdLg++mFIQS+D9Zc0bxyJiFMIK3zMh\nmoQxIEEyx/BM7qjhw0fNffij7TPtb8l6o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQikdAN\nRH4VC4ig5i4c4bC4dPHitzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAtuUcKS8iwkNklngyyIpVgB5vEXIBN+gz31XrXZiXv3QC\nIQCcmcUELeeDUx48SwcKyT5IudUlX1Vd1TmRPrWk4jtRcg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6119", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6119` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWRW//E2PthYoEL6wO/pGziSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhZGRkOTc5LWMyMTgtNDRiYi05ZGE2LTFjMDAzYmQ5YTVmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDZjMWY4ZDQtYTI1\nOC00YTBhLWJlZjktYWM2MmFkZTA4MjgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE09CqZU/gaWbNClf5cHSnn7bD/3Qzmspyag+mtBrQmP4rmHj7QD80d+iB+Vmh\njR/OE53u562cekc+og5HC/1qAaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhF5UN/z6htimfs0JPLtsJw34fIswHwYDVR0j\nBBgwFoAUEjiRe5LhKL0qSMNhFAxWX4Va4bkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCItxvti4r6a3Kbp6pHXMLdKCfgvit0ANNRcuV2eKut6gIgNwYWSc7Bv6aA\nRQhRrFoC4lHyX9u7Q27YglIUFtAX+08=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYEWw2mZAECq/4yaaTaPdsHXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWRkZDk3OS1jMjE4LTQ0YmItOWRhNi0xYzAwM2JkOWE1ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3D/s3gjWSh6hjKejixb68GDXg7KX/9RAXPsplmo0E4FRQ\nKRG6HxEdU3uP+KD4mE7kwPin1adhAVq0C2f5DsRvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEjiRe5LhKL0qSMNhFAxWX4Va\n4bkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJBflG4wKYYQzvxJA6MobsArQ6UFGSvj2TAzTitJyr5xAiABYEEURmPv\nINBZx+/weNTVlNpTRWSK1wrHSXp1QCIWGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAW+blNS3W2OMgZOAYgooJNw3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDZjMWY4ZDQtYTI1OC00YTBhLWJlZjktYWM2MmFkZTA4MjgyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MjVmNzhh\nMi03NDJlLTQ4YzEtODllOS0yNmI3M2U4MzUzNGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASd02Yqx7mysxppRQ4/DHI65bzhhJN0RhMZo65o/Lcq5CDHws3RyJtC\nY5kzEiRjdrZB2JIUVYXksjSY+o8dRyFQo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSEXlQ3\n/PqG2KZ+zQk8u2wnDfh8izAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBA1uUINWciy+g3pa5I2DwYkCFATEOa5PdJM9+0TtuahwIh\nALWTxDowJX4KPksWFDuWzmYx3JmrPwF8/kC+U9Ee96ce\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6120", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6120` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAS+p6MxMJWDyHs5V2denPJ9kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2OGE4OGQ5LWM2NGQtNDMyYy1iOTlkLTE5NTIzZGJlZmVhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZlYTViYWEtYzU4\nMi00OTIyLWFkNTctZGI5NTc0NmViOTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZCGqmteFSJ1AzFbNeZ5lYHeu+FIVMuTaNfpogrQpFc6Rb9AW0+1XL4nLNw2T\nQyZRMnyeeKf72QSFp7shI3x1t6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUww5lM7H/qxp8+VKDr8tE+55ODfkwHwYDVR0j\nBBgwFoAUf4i1IRNk0/NYqP51/dK40XvBQnwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDqVpgRLNYmKEMrjGtTV9Eo3kOFfrixUVqI4TenSHoPpAiBQF5DtVRizB8g3\nsY+jiqi+YqLS2narLNPu3flYZFFfEw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcwNn2FfDzGKwcYtEGX/QHTmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjhhODhkOS1jNjRkLTQzMmMtYjk5ZC0xOTUyM2RiZWZlYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFsCv3hOlEKrAJKupDM0k3i/R+H3D3uAlcVwmhTnHrkI12\n8ApF7ClpeRms7wPWDOtP5oYfCuLvfiYKLvOn7J+Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf4i1IRNk0/NYqP51/dK40XvB\nQnwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXyhfEFO52PEhceLOnegPHKpy8TiE9YsrGbAoYHb/wvUCIGOxBxEw4RKt\nIML37qg2UpmDvI5Mnx8xdEqaskd9cU8i\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQkwveh9QhnrGOMfuuCq2GyZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZlYTViYWEtYzU4Mi00OTIyLWFkNTctZGI5NTc0NmViOTZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZmYzNTA3\nYS0xZGQzLTQ1YTgtYWFhOS02MGQyY2Y0NzZiOGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATR9vQgf0VOdfUOsZSNuew1MMtQZ05MAoRIIn9m63Viv9mxmTvHa977\nFvNnKY0x1+kHP6PjvuO4miuoFwky+Agao3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDDmUz\nsf+rGnz5UoOvy0T7nk4N+TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAvxgSKD9MsR5hoVVozxbnbu7zCSp0YUdiqK2LwAJn/5oC\nIQD1DwMgk8B8JoMhNKT8+PZQBaoc/iQ/PgSAFy1kFQ9NkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6121", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6121` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAWD+3vgRWnMuRLC5y/CouQCtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzYWQ0YWVhLWI0ZGUtNDY1Ni1iMzE1LTJiNmYyNDljZjZlMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWI0YjVhN2MtZGI1\nOS00MzQ5LThiMTgtMmU0NTIxMWM1MThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECYR9TCzqBAid54vTn5tfMn9QwJtsrCtZ5/X3Recn1m9hQWp7e6uxYTKdjCJr\nrkQnM5bzL8it1dLn8VldCiYx96OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy1qisPGte81WrPycNuX/3zBQfd8wHwYDVR0j\nBBgwFoAUzgBxejk3RYen09RyTuMZaxRsKX0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAnvmDgZ2Ih9tbxoc2d5iRwDZUt4BEc/c5WoFdIkTvp4wCIALZdhXX7rj9\nmVkf9kwHO2B38LMO/s3waJhtZcQF+pbI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAabdKe34AHhjJfnWqr/4WAOoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2FkNGFlYS1iNGRlLTQ2NTYtYjMxNS0yYjZmMjQ5Y2Y2ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyeOkkopHXapkpT5Y4VpbvjJ0pzMeh3RQRyXxAz8MLW2bQ\nbzqUYSOSMF+xv6Di3AsjHgwPE6E248gkNEkmAzBPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzgBxejk3RYen09RyTuMZaxRs\nKX0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDQH3fHRhFacnw2Y7KbSKyNi+/ompTr25g+vVa8FkqD8CIQCCwcXUtSlb\nO6A42nkrWAnkobW/3lBMoZKoL1rg0tMefA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARErcnVE7UHS7r4lNUImUPZeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWI0YjVhN2MtZGI1OS00MzQ5LThiMTgtMmU0NTIxMWM1MThkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZDMzNDFh\nMy0xNzI2LTRiZTctYjFmNy03NWIxOWY4OGI4ZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS6MvizHcHmCbRVqHOM9xENE1vnENJgodM1YXG+eYP9GoSQr8aVpoef\np2+xLZpWAwT3RiiM9+ZdYDYnrzaFJO3oo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTLWqKw\n8a17zVas/Jw25f/fMFB93zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiAWhcbqxks5T1cquOgB915G45c07RMFEhPRbBif0AgA0gIg\nJbtPtkhaoPSjSBVPi6RY+GnDkuwafM+OAH/9t4X2a3g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6122", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6122` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAX8CNq68JNe/RLWiN7EVKH5PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxZTJkYTFjLTFiNjMtNGQ5ZS1iODZkLTY0YzQyZGUxMDI2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM5NTg4ZTktZTAz\nMS00MThhLTkyMjEtNTk2ZDFmOTI4N2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5jpz7qIp95pjGBV3oyBQFbZ6a+sD9HDzwwvLbiTrjgyTrEltvLa0NhzcDA1z\nDOwLQ0omwDzJf21LtmyGtZsJjqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNNZhlW+DeXQyIXp1PaCS68Ty3SkwHwYDVR0j\nBBgwFoAURyOp3dSSFQECsEocGpSFHPgblxkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAmvqxsAcWVdtqLQ5Arx34jHUJYHMfermBjsBor20KL\nzgIgLR0TcGdLQ84WPT43owcNPL/QDzRlq6exI3Pj63ylZtM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASXH0s3y2wzwjHidPL/W2GOPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWUyZGExYy0xYjYzLTRkOWUtYjg2ZC02NGM0MmRlMTAyNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzo0rnJbarDGoaXVCHB2uiwzmHFSe9PNwtQyO8Vpp8KQ3k\ngN/SMWTZDYHC6IFmLO/s1rhsWyIg3iyetlXjFxago2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURyOp3dSSFQECsEocGpSFHPgb\nlxkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0+pI6U2GHtbTCPdZf19PO7Ho3c5aNDsfRGzKa2tttEAiB6sAn0YCSK\nUmFpr4fLHMRc9NM7yIInTcnIpN+anVhxbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAaTFuFvbMdB6x1emtbq91adAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM5NTg4ZTktZTAzMS00MThhLTkyMjEtNTk2ZDFmOTI4N2M5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MDQxNGIw\nZi1kNmViLTRiNjUtODEyMi1jZDJjZjFmOGRhYzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATMLuzftezMrRMKc1rig62FooQ15mkFaegVlxAN4pmxGsiK5yKmiocf\n9atFCipj7NnMyJnvhEZGBB/GdRnErmDvo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ01mGV\nb4N5dDIhenU9oJLrxPLdKTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAn8AgB1hAn+CknoKTfVqBZEMn6jBszWyREoZd4LWEhcoC\nIG5hLGzYesbCAhOTvJSVo2vpyanyuzGO7cTu+Cul3LHX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6123", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6123` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAZIxyftOooe3nG7UtKCO+kE5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhNDI3NDE1LTc4ZTktNDdkYi1iNWRjLWRjNzQ2MWNlNzNhYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2E3NTdlOGQtYzRi\nMS00MTk0LTkzMTUtNjg3NTA4ZDc3Zjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElPf+lBGtxHZTEb70nm5qjmHFmDRjy1LrSd9821+JdjnknhTHsIMRUog2Pux7\n06Ie2YBJrTbwWfUyMTAfpBn+NaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8+9qWpbj8TdAcJpP/tN/JIyEKxswHwYDVR0j\nBBgwFoAUdeiQduChHrn1FomVtiBc9Isu6AYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA6S5Gt8DQcsykZbrs2xOrHlXhu1PkWm7ePWfjADaK\noS8CIQCyP7lomLFkrv59wJGzeD4cXsRBz4YBUsoieWzP9X05xw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbsLmVcGAThI1ZHBn2k5Qc+pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTQyNzQxNS03OGU5LTQ3ZGItYjVkYy1kYzc0NjFjZTczYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQo4rmeLU2hgAHk75+dhpKiJHPzUJb/dCmfqP+cxfA2IX2H\n23yIPV2gTJdippownrvlhY/MdTSxO0o3SKpri8LKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdeiQduChHrn1FomVtiBc9Isu\n6AYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZEFvfoHLLN14wliut+JBPtRUkY9YOuqm5yW8VRyaLTsCIEiEfLeEbEu/\nmNHSG2FjXmEbizW6H5uqaDb17Birdj7U\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAW4zBHE3HzEFbuGfiLAok4WYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2E3NTdlOGQtYzRiMS00MTk0LTkzMTUtNjg3NTA4ZDc3Zjk5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZDA5Mzc4\nYy0wN2Q2LTRhNWEtYjdiMC05NDgzOTMwZDA4NmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQYmRYFe+R9pXN2TTBl675Ik90bvnK6LWAURnAAOLW6dTQsYszAJFt2\n0bwVWTgT/tppwu6V558SE7N4fQquVpczo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTz72pa\nluPxN0Bwmk/+038kjIQrGzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiA5S2rpbAFApdtyTDuk2a3zIl7Wgb5LT8OVJni6uwSq0AIg\nIgkanrpRW586oywCSrlttQ3kIk+VyfTJTD7rd5r5LkU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6124", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6124` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISARSLRGVYpJLxLKUagfK3GfnvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyOWZlMTAzLTUzZGUtNDE0NC05YTZmLWE0NjVhYmNkNzA0NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTEzMmNjZmQtNjg4\nMy00YTY2LTk4ZDItNjA4ZjI2OGMxZjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE86Wiqm48Rb2GhpjxWh295dm13iD+4S9qDGgBxm25eAShjZaf3P6jR7JR47Lo\n1wqsJ+eT6SFfJLne3mL2tAI4taOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu5SnjJyyRf0K7SZZfmk5qxlSewMwHwYDVR0j\nBBgwFoAUnZLUnFjj4f73VXMaTM+Fasd4HdcwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAgRUEbjfKpMD7F0iINQ4U63ONKoCjVjNBsSjPs9qr4ZcCIQCV\nyZTsM/3BgpPcyqRBWohkzGjnPHLPsJmz1xtB+wD4Lw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR/SbD9Gr7WQNHoMjyHsukwbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjlmZTEwMy01M2RlLTQxNDQtOWE2Zi1hNDY1YWJjZDcwNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFh4uv/t2KTGHcnLyc3E8WFVZeNF43AZAVy4P7i8ZVXdEW\ndHZq8kxyGAAg9jlxrOPt3qgxM9B+sj6vspfpdZtdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnZLUnFjj4f73VXMaTM+Fasd4\nHdcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIsl4YR13AOx+ujhpN0+484IGOs4qkbtLR+jkFgLivcxAiBupPxev9MF\n31gLl5eN8Ox8585vqZphdNjIxP/epqP7rw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAf8+qjhqDGfV1iI1MudtVgDhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTEzMmNjZmQtNjg4My00YTY2LTk4ZDItNjA4ZjI2OGMxZjg0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1YWJjZGI5\nYS0yZDJlLTQ3MGItYjBlZS04NWIyM2UwYmVmM2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQgWEv9nJXDCJX1EfzhcekLL6MB645RBuPmFyF+U5LEV7WuO5qqCC0K\n2FO/aQwk7efpWoE9YGXMHzCeR+Q4zp2ko3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7lKeM\nnLJF/QrtJll+aTmrGVJ7AzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAtwfcgzcaIre24hkdXH3q60VaBAQx1StjLzOpwCLW0hoC\nIQDgoKfgX6eVyBwgyNEpNyOL0zOB40dSm1oSFLD01eVQyw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6125", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6125` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbidwKU2XXfqERuDtkFKw33+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNTliNzY5LTE4NDAtNDJlNS04MTg0LWMwMzM5YjUzMGI5YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdkOTA4ZDgtZmY4\nYy00NTM2LWFiNDQtZTI5YzVkN2I1OTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv7opOSaKnWaUZ2irTCjknRTMy/QmukzfUVxHVKYp3Ihj358RJlF/cLSmKBCf\nl+uJ/BQ0KNmy++TmcRtgvLAIhKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURaj57apNJvp4E35RPTvawtZ6o5QwHwYDVR0j\nBBgwFoAU/gkFCJLsoYZs6KEOzc2bMfkNF2AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBlkSIukka3egR69c19VVpFQFuLA3nTRkQM\nkUeJ5ETF+QIhAPf4QR+NsWUTPyceMOgcQ9eS5kjsqC+MLaeFaIG/O/1c\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYSE0SjyAK7Mz4zg4sv8i+oGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTU5Yjc2OS0xODQwLTQyZTUtODE4NC1jMDMzOWI1MzBiOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9rRFGlaWVo/doNQ8YVeHKVZUQozN4CoYqBEW0sHDYM0nk\n/bOYesjUNRuC8hH1SWzCTrNV3BBBug9tAGYBIVTlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/gkFCJLsoYZs6KEOzc2bMfkN\nF2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJMncT9aTli5pCZrIUrR92x+2uzN6PzsibpYuK1QnyqyAiEA3pqcc5oG\njTz9GairvlZac/D4yTEJJ2M3QIy+9F0v8Q0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASrLV+57y6l1FIO3kSQ23LFtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdkOTA4ZDgtZmY4Yy00NTM2LWFiNDQtZTI5YzVkN2I1OTZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MzQxNmJi\nZC1lYWY3LTQzOGEtYTY3YS04Mjc0YmEzZjI5ODgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARVQ9wsLiZi5Qdkl0vuKglLCZNl5DXYvFXBAywt0wlFNK6xukBBaL1S\n315WakX7h70V9EkPMyy/XS5SwaPFWAino3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFqPnt\nqk0m+ngTflE9O9rC1nqjlDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiB/RJtMJ4OWyYobcSuZxegEEzFy7f93qTF9MaRXCUemiwIg\nWvaOYH+Re/leywnUAAQXRfzbWfq8nYauKweaRbx5SpA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6126", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6126` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZBQAxNF+doThZd4W7yHJB+aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3NzMxNjA2LWIyMzItNDYwMi05YWViLTk0NDFjMjE5Mzc5YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhjOTIxN2EtZmU1\nZi00ZjBmLTkyM2MtNDdiMTRiNzM4YzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGrbhKJqiQLtrzgkSXPDjkr48OuB+8IDjlYPvc1xZSbmI4irnArp5HwN/qtB5\nKF1zbMjgxNJu9n7rQUXgRbWmkKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUDZkR5wnNiMWx4C1h5A52+j1ySswHwYDVR0j\nBBgwFoAUyo7HdhdWw772oLCc+m0fae/wubkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBYvtkh/5M6tu6vX//F628txTGMmLpUEqah\nvo3GOzRKggIhAI2yLnYM7DrAWCYMjycGn21HCyeAc1K6lNMQBrsphe3M\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR4PS7YksWgKUT1ahEgAPC7tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzczMTYwNi1iMjMyLTQ2MDItOWFlYi05NDQxYzIxOTM3OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFgRYE/DNwuPDdYjZkHStcSzgmGf1DRq+MjGJLGnkv3beg\nvb7EkOJSJpqrc7G8WYOuPpmSwLchZC9RR5Wap33Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyo7HdhdWw772oLCc+m0fae/w\nubkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEna0ZCjxUNRsyAzw+v9FrlfuX6o7jbQULT3AR8ltIx8CIFABSX0pZ9OM\nKDIl/aGpODBNIP8ia/4y9vRfWPnB1a0S\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAU4ruCGFK7rIldKPC7knUUQEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhjOTIxN2EtZmU1Zi00ZjBmLTkyM2MtNDdiMTRiNzM4YzNjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNTQzODg3\nYy00MDY0LTQ4MGMtOWI2NS0zYzc5YjBhZmYyY2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+X7pXbvoXAqeSiMVetKI3TbKar0AQf4n9qtJUwYSBKrgidxiv0uxY\nkKYW0ey+bEskbOLKej2LddQ8dpjEwRUGo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQNmRH\nnCc2IxbHgLWHkDnb6PXJKzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA/YwHhfZ7CQfsRpFuWKLJ2KItTEruCaxJVjS2UJ3a1mgC\nIQCZw82mF4HZjFzYkL4xfwMBNm2qlQzDSDypQ4maN6UzwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6127", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6127` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARcjbMuseIZr7Io7CUTNSYvtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhNzQ3NTEzLWMzMTEtNDJjYi05NWFlLWYzOGExYWU5YjY2NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNjZWRkMmItMGE2\nNi00MjBkLWI3MGQtYjZmZGE4ZmRmODEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE04wK6GVyoK+iuDml3gvti8sIRdSpUx7hO9/k4lpUEdCyYwd4McdNLcP2J0cI\ni8i1+dbZSPPpsIL/D6FvgtlI/KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUODho5yBRa/1eyMh6XgI+zg6paWMwHwYDVR0j\nBBgwFoAUB8Qtu8G/ovXmTvbzqeP4UpdjfBQwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAtlXDHW2cfUQH\nVrSCwTkQDqAXlPBFhdXWgOTUrA0PNKECIAa1AxxPHNzKl2DSAHTDfgJw4eJ6uHWJ\nolqHEuSf++5H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQBiruGAPFC8o3l1r/TFTZCDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTc0NzUxMy1jMzExLTQyY2ItOTVhZS1mMzhhMWFlOWI2NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREWyIzw03suUaeMyXueqNUvYmmDkYAPQ/6QOJCFQ4oY9iR\nlsHo+ZBQkM8U8fDBiFsK7MELv6hpmMW8EXjVYx7Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB8Qtu8G/ovXmTvbzqeP4Updj\nfBQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfl7WEY7nGvy03YHUF2qvbIFtW0/2AAU7P9mCPbgaSfwCIQDNFIF9t3sD\nCLsaN3aNedScSl5ZsO6nnem18Xq+HS8ORw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXxsDjnz9oMdfMX1lN/2mZHmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNjZWRkMmItMGE2Ni00MjBkLWI3MGQtYjZmZGE4ZmRmODEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkN2JmNGNh\nYy0wMDdiLTQwMjUtOTJmNC04ZWE0MzVlYjM4ZTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASiPl0One4br5L/EU7Og40SNZAyItFgGVlh3hizo/pA2b4HY9acn7NB\nlr/mWVwQLvci7wQkbZADyv7GCl5UNam0o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4OGjn\nIFFr/V7IyHpeAj7ODqlpYzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAyz7riw8bJpEvPGSTO+OOAKSLy1RM7xZJJwsEkQqMWOgIh\nAKn4Bq99d2xOf6CqxeVGcuk2a1JG4oIhMzXi1AkLOr6E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6128", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6128` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQVDxQ5TFL24hZe/BHcDh2TFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5NTM3ZjI1LTA0NGEtNGMzMi1iYTY4LWZjOGM0NGI0OWFkNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ1ODRkZDEtNTg0\nYy00NzhhLWIyYTUtODU1ZDkwZWZkNWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx/QtHrPcw3YqXsGDwp4PrbA/zfY9jD0olJqnkX51XWAV0v6SOGCrFlTkSw0M\npNy6qRV6KzidP/g70yVe0nwFSaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw2+916cmLe5ZyqREIj/2jcB6y3owHwYDVR0j\nBBgwFoAUBKdLJ1WvZi6m4T74IDcU33w/YiIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICf3m5MQJmlwqpt0O+SvzY5o9fu137YbDcceYw7REcp0AiAMNcyyYts15AyM\nCD2CfLJeogbZ1PwlIP73D/gYZ1LAgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUivSKV/xivcHoSqC1IgxqJRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTUzN2YyNS0wNDRhLTRjMzItYmE2OC1mYzhjNDRiNDlhZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsU70u/z653C2ZZbChXGOtklEYrcG/WzD40/ep8UL4ZfRm\nLhiwcujjR/0ECaGjI8yytI5SSKw2Sk3BdTwghIo8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBKdLJ1WvZi6m4T74IDcU33w/\nYiIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCI+Zqtzm27ER2Be+BFkS6PkmQYhGuL44oM2/jS6y2SkCIQD9pNiVApzT\nRdtvjpdPa6B0KPPDu3To7OsYAOy0pInBTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAT5vi/3G0x9obSCe8BMCPWOQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ1ODRkZDEtNTg0Yy00NzhhLWIyYTUtODU1ZDkwZWZkNWVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMDc0ZGU4\nZC1mZmMyLTQ2OWEtYmFiMS0yODFiNTdmMTNhM2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR4Y5MXkjHPNKdz8RK04RPXzH8meS3GTCkkUh3m+aazxlurgvAQ2z1r\nHAFPC34dKhiomtEfalUdIayM9kxgu7r1o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDb73X\npyYt7lnKpEQiP/aNwHrLejAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiAypVXga7iexkBJFKPOIaqwWld4jA8LR2DEL/W90kNaewIg\nDowsTdV/uudxkJtIWsU55sfklj6w3l3vbIBtrxrOTeM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6129", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6129` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAd1LY8UvWv05P6AmfXy4QT9cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlM2Y3MzgyLTk5NmQtNDA4Yy1hYjlmLWQ1OGYzNGE1N2I0YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ3M2M3NmMtYTcx\nZi00NmVlLWJkZGMtOTIzMTljMWY2ZjU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY3olWQprrNE4MJCR04bCDbpu0ASvUqFxIqfEGuLotYbVCrOBzqXFmwvACOc4\nvjZ4yuXOJWGslY5tPJz+iaTBpaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU/fzpO5x9GUx18QhwoniVReSUV8wHwYDVR0j\nBBgwFoAUJr9VFtz7SzP2Nn6VC3yew/do4UIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCID4R1/WiunhSOKiL/ezA97WIV49o4irZZwNwcHRLy/JbAiEAuxG72VpaexdP\nyWTF35DHJukUk2JiIsAiaBbOtXMXw1o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVWefr+LUKQcPPmfMsO0tbFGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTNmNzM4Mi05OTZkLTQwOGMtYWI5Zi1kNThmMzRhNTdiNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARreoquazvpPhKfGlEvCss9+01DR75SZGcpPOqLavUhl19L\nwjIomrWOkcD+AXhMKlLaJWgUoN+Tey+UgPaJrcAJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJr9VFtz7SzP2Nn6VC3yew/do\n4UIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJff9xPITkDzJs1EN3vkVO0C5uXb8c9MYva23YoUeV70AiB9haOclsXj\nyQMd/hYB1nggWLKRks0/7YJ7jHsBloqUlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAcxxs0IdxmsBxK0XAHjdb86uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ3M2M3NmMtYTcxZi00NmVlLWJkZGMtOTIzMTljMWY2ZjU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxN2ZiNmQw\nZi00MzRiLTRmYTAtYWJkMi1iOThkODQ1MjJhMmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQQir0/fnoCDeQlzqKPLJTciT02H9buoNcn3FZEpnrHVClzqS4U7/DM\n/09RJoNhyUQp13BkOR4eeXsGGEhF2STIo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRT9/Ok\n7nH0ZTHXxCHCieJVF5JRXzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiB6zL4sEwsWoDmuK0zU62IcxD4gI5+YTSfg+8dCKyJspAIg\nKQhTLtS6NtcVS1m6H4XTHMRsGvbhsuBovyDQZrG2Vnc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6130", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6130` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAevNQN/o52jx3mUgc1Mg+KnuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3MDU2MDQ4LTc2ZjAtNGFiYS04YzZlLTg2NjgzNzU3NWNkMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVlYWMzNDAtZGQ2\nMi00YzUwLTkxNTQtOGQ0Y2Q4NWM4MjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPCcvoisF5Yhi2EoVHzPmgFDBaloDUpy+JvYoEK2gxVWpkiIBKUMk4VHpMrmA\nvUmoMDPP/RkVuaqHjHrw4k/3MKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi0MbgJjhAxCt+g3HLLMRm1rIcDkwHwYDVR0j\nBBgwFoAUTpTI7tDlvA2iQ37lyWl3+4u0RY4wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAvychPiYs0+SJaqY3zxHS6x55kp6OpAJMKSH1/wab69oCIQDunFuhrLSB\nGOi6GMBDKA/2d8pgk2y2+kvXJSgfsaJkIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfwNyq9yZtqa7RulDp46uaC0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzA1NjA0OC03NmYwLTRhYmEtOGM2ZS04NjY4Mzc1NzVjZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpZSBYjCPObad3uzpXWAjit5dsFigv9jDNL7nZAS4E+SeH\n1bWVBQimH4u4Grw9MWBFOBEBu119/g+WzKBVb6t1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTpTI7tDlvA2iQ37lyWl3+4u0\nRY4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAybFr8lo0Ld0R3BHfxyuJfXdizFPtqOrBUAxdAQ1FuwCIHTkfS/d3wY8\n3lbGbPwVXnhdBIx0ygOIjzgIptaoxljP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAa7CHQLqh47IZl4DogQ5IQlcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVlYWMzNDAtZGQ2Mi00YzUwLTkxNTQtOGQ0Y2Q4NWM4MjkwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZmM2M2Zj\nNS0xMGI3LTQ5MGQtYTM1OC0zMWMxMzcyYzYxZTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARCZs2ISrLlDjlg60OHFgCYJ7Zp1oLAhuh6FxpH1M8GKvTHaLypdzCb\nNK7cHim5Z6BP/3TQjmw4macAr0puFyRSo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLQxuA\nmOEDEK36DccssxGbWshwOTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiA9F7DW6/6NsNrHDrg5SFM61NF/etiKD0tKfEL9hi1rWAIg\nUvT4a6fcj7inTluDcAKHPYFwCtAqQqzxPZklFEwTl4M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6131", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6131` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUaNKqmR2HVnZL6tYsWdvJJ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1ZTZmNGUyLWFiZDItNDE3YS1iZmEzLTRiYjk4OGYxOGQxYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc2YWZkMDktNTg4\nZi00NjYzLWJiNzItMmJlODk0YjRiNzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZQjyetOcf7KxYQwI4vk7qzO9ztdRHMDfqTSfCxdVroLYtyEvNcTX55LusEA+\nfadOkUXMxDPDVfg/5XtEd5Q5CqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKzgEGGZGLtNqYrFpueTg+Qatug4wHwYDVR0j\nBBgwFoAUBg4sJsiZQBOrRAbrQfQELIA1NqwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA5cQwx+XOYVqx6a+xtJsKwUoT+UF5zgX2R4FrEtzM\nHq8CIHS5FeX5TEqNIJ74FKEwhAIZus9mMUJmQNS8hmXgt5Dh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf063Y/FwkA+j1VTTI2wlL0NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNWU2ZjRlMi1hYmQyLTQxN2EtYmZhMy00YmI5ODhmMThkMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgxPpa/aqtUJG4ohaYFZPUpsm6tbYu6rry5e91xLctdMcT\nyjaqf2rDUYZkQ6Hsfy9Xr2medHI/hcWLr6rcDX/Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBg4sJsiZQBOrRAbrQfQELIA1\nNqwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNVUKMXaDTXvHjA9h91QujYANBsJ7n8Pp/+1e2z5xvMQCIQCEorZPpokr\nrZXb6eCzfFj0IfG32fJxUQZxQkjI3M0puA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdQgCbnoxT8sI0NDn1YnOOrUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc2YWZkMDktNTg4Zi00NjYzLWJiNzItMmJlODk0YjRiNzRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZTcyN2Qw\nZi1lOTY2LTRlODctOWJhMy0zYjlmOTFhODZjOWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARR6EYESimNC0tAfTLPY8C+dBoffDMg+9sHi4YOQH1ikvVTMazFy3NW\nTMIJYbfpZ89vaziYURvsR3AY8WjWZfbvo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrOAQY\nZkYu02pisWm55OD5Bq26DjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAYT8cqhiWvnCm8q48+OtQzfDZ+pJQ++dkJ7DckstXw8AIh\nAOzxnSqp9zL1T9mxuikqiUQrPn+sO+IKDE4S7E/+p7yy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6132", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6132` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWQqeqghNtUk4di6ur8sDHvQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4ODgzZDE3LTdmY2MtNGRmZS05NTc2LWNiNDJkMzg0NjcxZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJmMTJmYjgtNWVk\nMi00OWVjLTk5ZjYtMDlhMTExOTAzMTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvf3ZtZMjp67GaiICvUtFv+2eZLn49EJ3UWrbZp9edV4npNK8BbQaaFIBNO20\n64epX2HCErhLj8eiu6cRsw/b+qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSKKjvEnPq3gxqXpJxJeqy/1VjNgwHwYDVR0j\nBBgwFoAUHa6kle5WSS9SZkgMW/JRsb84AMIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA4UYTvPfq/fDdhNLoYiOo7Trk+7bW2lnczjlIh5cx\nV14CIDM81ql5V/G3nwT91SBrWyPIszIYYeg9wXMZuyXziQrz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWy/IvS6vrsnGbWf9tIk+1IAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODg4M2QxNy03ZmNjLTRkZmUtOTU3Ni1jYjQyZDM4NDY3MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbolZHxIlC6YGCzO9Daa5OKn0Lmj5zuPXxUeqGpMUiIglW\nvsPUtqlDLCbfOcvHaklftwNoG1DBw87A4hDH7CGzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHa6kle5WSS9SZkgMW/JRsb84\nAMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMbNpwLFFOgwmXpudsZYEDC2qDushzNYkEw0iwLS4rDcAiBtLZELoumk\nBp+otuf26DTz9FyFbxxVrSbig0U7Hfhx9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAcIADEMVhIQBN7WAI5J2Dcf4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJmMTJmYjgtNWVkMi00OWVjLTk5ZjYtMDlhMTExOTAzMTgzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMTg3NjZl\nNi1hMjg1LTRiZjQtYTY5OS1jODg2Y2QyNGE5ZDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQPKy3w/J4//Ivv8/0FbL0pB2WEFg9EQ36IOhCsA4wKGb+aNjUswF7n\njZCrQsHyry0y9ovI53wPJI/zvmWLwn2mo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRIoqO8\nSc+reDGpeknEl6rL/VWM2DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA37pSF0bglko7uroWN2UZjWvhoXiwlqVIiyyiZKKOGzsC\nIQC2Q+l4jyHe9vW/iC/F1IBmXSNhkAqN6Gsr6IhSeBgK/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6133", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6133` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISARpB0Z5BwZ+DltORVUvFS60OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlOTQ2MWIxLTk4YWYtNDE0MC05ZjYzLTU5NmQ2ZmI5YTVkMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg1ZTI1MmQtZTcy\nNy00NDViLWJjMjQtZTQ4ZjM5OWE3YzcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5rokCjXsmZZi+VJHOo4P/v68IRkKA0wWlP2RdUGSDtZweW8bkTothasYTS/t\ncZrowmY/Hr+UFJrHEB/p8ln3jaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAPGY1pq3bTskdgPX4JehdEgDZpcwHwYDVR0j\nBBgwFoAUbEbQwi56Z/ptJWKsMEutK1JuQQgwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEArQePqAhA9bB2lSHZfUtZmnAlUWPNTb+qb3GqaKGpooYCIQDR\nXiFwKzhrzS9eAsUl5jo3xiQEPv0+lEhpYvxGi8eC5w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATY4XRY1rs7H361Ely5+kmUqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTk0NjFiMS05OGFmLTQxNDAtOWY2My01OTZkNmZiOWE1ZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASF6rvmqQgez6Fpbe5Ub0sIYWI3JUoUhq58n4VX5/sm3obg\nlWZtW2HsVMT/i8LOP7oX5Fpi04904nFIMLCt3yz4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbEbQwi56Z/ptJWKsMEutK1Ju\nQQgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANMEj+HGC0xa0LnxgJ8hN++ymLhrV2mB8obI+PRkAAibAiEArEYV0sAz\nIEFHE7Nz0y+VmhDGBG9gHz9tg3de25ZOcJg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAfKK1RqBnx79gIIGo52R2uKRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg1ZTI1MmQtZTcyNy00NDViLWJjMjQtZTQ4ZjM5OWE3YzcxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjOTI2ODBm\nOC02NzEyLTRiNTktODUxOC00MWMzZDFlMjU2YTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATaszPG0LKqs2MrgCVSED3tP1FnwUdU5y6woBer0QuR8D78HgBAVo7C\n3Y3MtIOwayY9fZoxQqiYS3o8NLQJq2AIo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQA8ZjW\nmrdtOyR2A9fgl6F0SANmlzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA6P2IY0uhA9vBhj/e59DDqxEUpw31Uk5bHU363ZfhYg4C\nIQDx2SO7FVUku1HUCLmeLpB60LMUNvoeY+64mDGR8NGwwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6134", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6134` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbzS4KutcsiN/r9oLu96b+93MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlZTYxZjU5LTQ2NGItNDJlNi1iNDcwLWVjNTE1OTkyZTZkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdlN2U3NzItNmZh\nMi00MTE2LWE1ZWMtNzgwMzlmN2FjZTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESR/MyU5JY70NHUN0E592qMbZMBHXtfX6LXyG/kxpbvU9WY1tKoKQV3JSxthS\nz5P+nrjfVelIKiG3MJXbSCMSVqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBG6QvFT0aTLQcqby7W9DAetv6ekwHwYDVR0j\nBBgwFoAU6GJG2K3FRAoNoEQMpRHTeIOFBCkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAvSS1/TZi6fLyqJYt0xdQ3V3lN7KrPT3Y\npWpJ185a0l8CIHb8Sp1T17ozsp66ybdV+9TJmdDoeN9BCMnPJnAyILbd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYHdYcZ8Ema5rGG5WGWXC+32MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWU2MWY1OS00NjRiLTQyZTYtYjQ3MC1lYzUxNTk5MmU2ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUnXs1Xj2/YOqEF+CnE9QsqtnJ0LqAzUi4sZ00053X2fha\nxJsMGDr3sT6/2L/xNgON+gRcNx2/qOQk+fCCHdtgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6GJG2K3FRAoNoEQMpRHTeIOF\nBCkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL8ELikbiifUEkfcxKdScAAHGZzZWBjwc8cDbW0iNHQzAiBUlqeCgBm7\nFMzoujYMQOQThdkHNQ9jmXucbezRvG/V7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAS/BZhqMh64oalCp2fMpLSssMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdlN2U3NzItNmZhMi00MTE2LWE1ZWMtNzgwMzlmN2FjZTAwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NGYwZTY5\nZi01MjJkLTQ0YjgtOWIxZC0wZDc2NDBiNzAzMGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASld1yX4JycfZMaQsvouumyaHxzafF+tvBFbX4DNzMeWXnpjCT995iP\nIYJlNllapdMN0Y3tULnjePFXDgqbkVAMo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQEbpC8\nVPRpMtBypvLtb0MB62/p6TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA/+Dl73XBQoV8/CMoSDEq9IOmMUCdEotXRoqwfR562HoC\nIBRqNad5E4Q+v6CxSRHnpJBXyLue/h0o9LlmKts7cFxl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6135", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6135` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAWHhZtIFq9Vbzq8gvCeqbXqPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3NTI4MzI1LTBiY2MtNGQyOS1hYWEyLTYxNTg0ZThkZThkYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTcwMmI0YTItMWE4\nOC00M2IwLWFjOTUtZGFiYjA5YTlmNzdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB6r3GEhNmMR6EMQqs9dGmNC5tUO6ZSJ/zu899OpR2H54SlZ4lmpVeYOSQpQ8\n12EAunRlsLewnyPmm6wccIswwKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/nsFtid7PK8hhYKv9kEEf6NOolowHwYDVR0j\nBBgwFoAUXNykFJleOB6nXldw0ul2lVPpZwMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAhckhlbg7ZiPaJAMuj/+mct+ftm97Eo8L\nkuTKH6hIvtgCIQDhu6boMwY6vAtz1SG1y2zaDuPvrhKq6f5rDoqkT9zJ6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVwSXiVQi3anpfpU84Njbxy7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzUyODMyNS0wYmNjLTRkMjktYWFhMi02MTU4NGU4ZGU4ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4+Us/dhUGnNDrBvVbNvZ65Zn/d6WpuU1P1j/6p4IIOcqY\nqkp9Nb28/fBsL07jJFlHdf1fhGy+SiyaU8mYBeZlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXNykFJleOB6nXldw0ul2lVPp\nZwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWip6u1DGBv4NhNm8k4VqHRiKSuMadpCfC88mrlIWnuoCIQCxh7jCef3Z\n/X6PeXDaZXmjGEApAeA/XwaMlHoocq8Z/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAWyDQDM6n4UQw83sQZ7SgONYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTcwMmI0YTItMWE4OC00M2IwLWFjOTUtZGFiYjA5YTlmNzdmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZjZlZDg5\nZS03MWVlLTRkYzgtOTY3NS1hZWZmNzQxZTBjOGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQyggvW8E9Dr+NZp/yin9XmWbftHhAbn1S8qaJElQn2tlQARfaSxCqs\nbozjt1+3DM93en0xFaDI24SRyPH38bETo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+ewW2\nJ3s8ryGFgq/2QQR/o06iWjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAt3pQiaQFQ5YMDTHntKtEBMy6Bq3fE3GkiH4Y8up7EaoC\nIQDAj8A34h77Ac4stym7dNdLw+Lr+MZ2KBzgehYegEPdCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6136", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6136` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdEg8tPJoE2Kq/WIrOY3pav4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwZjdkZmI2LTE2N2QtNDk1NS1hN2E3LWY2MWI5OGMxNzlkMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGUwM2QxOTAtNzhh\nMi00MzYzLThkMTgtMDlkMmIzMGI4NTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW2D0l5T+1b2JuD2tvps3F7bQDcjC4qGcRAzeciTOJfQ/iXJA679J6pfjWqpQ\n6gJ1ux2fHtSgKvkglRCX4Cr9YaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh+qYUosmCv+fpRJkOzyZdndPel0wHwYDVR0j\nBBgwFoAUKjOI1epBM+crxbyUjeu/jxX/6V0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDObn7eI1fvzDZ/IVthinDzIObz\nnoP5oWzfj6xhuLcsigIgC7Km4V+s34G83aYljrxhl0riuHJXf2UVuJ5J75WkqEM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdvNEkQUTt0mV+JNbQO0hLkIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGY3ZGZiNi0xNjdkLTQ5NTUtYTdhNy1mNjFiOThjMTc5ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbco3NliOez6wpJQENJ2pLCNP5oU29+SLuynaOk0opecXt\n4AkFS90gyQ0NMsQyYP7llWzIsWVivuvQ2vt1/+Clo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKjOI1epBM+crxbyUjeu/jxX/\n6V0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANOQAKCmg33vMhzXdH+wWXWmxLPbPcQ/ZA+SRQO5XK/JAiEA+6eZhru9\noIPIXgu5aA5Khfuf2qTOigk6SNMwkdhwW24=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZHaqmibI7Oop4ifb+wkwBLaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGUwM2QxOTAtNzhhMi00MzYzLThkMTgtMDlkMmIzMGI4NTRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYTEwZTE2\nNi1kNjE2LTRlMTctYThhYi0wYmZjNjM5ZWQzZDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARqjiIdm2u5RpuOh6wkDYoy+qBGiZfYZaTacGOUwR6ycibdaEHpiWZE\nu7IiU4KiQA3kGoI4yo4apTt2w9DnuUMxo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSH6phS\niyYK/5+lEmQ7PJl2d096XTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBJCt/+nuX9vfAyzRGWdN+lmNazI/bEqfAUNP9B1fJj4gIh\nANztF3E8eWicSg8I3gU0mX3/25tKSTZFPbYovPRQakxl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6137", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6137` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAS5CZ61hdxd6FsaTfv/QX4xUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczYjJhZjU3LTc2ZDMtNGFkYy05N2JkLTI4ZGI1OGUzNWRmMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQxNzMyZWEtYTYx\nMy00ZDNjLTlmYzEtZDE3YjYzNzk4YzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESUlZiPT2EedtpoPrjwpu8RbXlrStNFGMuxuUyOFC6zJ4NHlEsWNdzpoWl21d\nn8JXNGFN0i0fyXhhtLFUt7qsHKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw5JRRAZl9vPd22wa0yHyIDstiqcwHwYDVR0j\nBBgwFoAUwd78QIlqJ78jRFisyvQGN33MBtUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgCOEJ8JTq\nX/HML2Uvx1X748GhZlNvr5Po1t+HpKupZH8CIQD/ycC1pRtOegFbk+oNO3o+JLeX\nUtXig7L7x/fWersrcg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfRZh+A/jzisfkGkJItwZzqCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2IyYWY1Ny03NmQzLTRhZGMtOTdiZC0yOGRiNThlMzVkZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiPFBEvuvFxGLtbaagM3GFNeolz3KeNnI7M6j6RwYzAZRl\nYtbMThij6K34r6/Zse0q8ggcWxCMU6DAnoOLrU4No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwd78QIlqJ78jRFisyvQGN33M\nBtUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCC0a3LXj6xLGSBkTMCnD2mfoqpPdOLbfuW3PT7VVRzACICSxFt7C69EN\nb43G6QCtwcPigHYKxgwtgBW9xEw3RIuv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWNvFLmBqQiPEfIWNOGhy/K6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQxNzMyZWEtYTYxMy00ZDNjLTlmYzEtZDE3YjYzNzk4YzY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZjQyM2Vk\nYi1jMTI3LTQ4ODAtYThjMi1kNmZlOTljYzIwYmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATrxycbDk6UU8/vBL+2bcw9DoL5rI3d8K/Bci4SIwL703eDLb2+kFH3\n25nsIbwADGwhbBr14n6oca890we4G6HQo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDklFE\nBmX2893bbBrTIfIgOy2KpzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiANXYrK/iVUYb/AMEVHoNkqazOCoRjxLyrEiHQlQv0I5wIh\nAPM36qV5WR8K3bdQeoG5kwVyyoO+4HWQvMWCsgbJ4c1d\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6138", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6138` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAakehMcpkKg/JYPhxseCPgfYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2ZTg3NGEwLTdiODktNDA2NS04YjMyLTllOGM5MjRiNjY1ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUwYjZhN2YtMmU2\nNy00Y2MyLWE3YTItZDQ1OTgwNmE1OWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/NZAQ9Z4Xtp4F0sTj1z/hOfzY9xDdbdj4OkitbQ8/qGWWsGor9247Q714F1L\nPCSbkMXOr6/AsdmnoRwDB1Mq9aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFrDZLZLzA4fgnvA/mnVYZuQTnTswHwYDVR0j\nBBgwFoAU3RKZACq3GhPSMdxaWB0xlw+E6hgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJW4ZQq5\n2mRUjBuJVFbhUYPFVntZKzKBLHyGvT3onSxWAiEA1PchZhONopgYSxxssrp67Fhx\nRj/sDDzkhkZb+o14+r0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfOKToYdjhwDNA533Zg2LnhqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmU4NzRhMC03Yjg5LTQwNjUtOGIzMi05ZThjOTI0YjY2NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR47MPRpGPnFUi0xfYCjwtQ0OfOnd60IMcNvnKCUvlQXWdW\n9PhLhEiTMbzO4yxM3GKUI6+1DlLm2Pe23WEGs3v9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3RKZACq3GhPSMdxaWB0xlw+E\n6hgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJWtjV0GXiCfliLkqJvUr1eUA3EwcyoTuWWi7nwfiDs7AiEAiJq/l9Cd\nLIeGhC2tgj3CJSSMFKnMrLl9g9qLOksuKiM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQRTl7CRsg6t8WD4riGnyu/qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUwYjZhN2YtMmU2Ny00Y2MyLWE3YTItZDQ1OTgwNmE1OWE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MzRiZGY2\nMS0zNTY1LTRkMDAtYmU0OS1iNDgxNjZmMDllMzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ+63s5g2HcGFZ2VGCmrIwcc3zym/qkqglTKVlV6C77JrPZ6OcF+MtE\n/1r3GdJW1H+e/zJHJxKpe8wMmGOQ+bKeo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQWsNkt\nkvMDh+Ce8D+adVhm5BOdOzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiACWbJqSvM3mOqwqjW84CZpaDYLWLULf2+LSKVQR3oE1QIh\nAOgFg+cFrKMmV250IsaOUhuzdLcFKm1R/wGRRwKlj8OM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6139", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6139` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAQdu+BUEn/Oj9S+jHUkoTeuyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNzA0MGE0LTdhYTQtNGU0ZC04YzRmLTE0NTIyZjExODZlZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVhZDE3MTUtNDFk\nNS00M2I1LWIxMDYtMmQxZTcyYTE1YTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq+t5O0rQ3Chzg4KXDwRP4M+KL3W8+Yc/R6ZoustqtnDdJ05l2Nh3hubTpJkX\nOS6ZXI4+pf7MO5qFvamBI5EKK6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcjw29kFkBRK5izHUFYorZNjjh5gwHwYDVR0j\nBBgwFoAUl6ssPQf6PqBhfRK8D8tJAMUmQ48wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCID3+iiKm\n/Kfqw1+Jf0Xf1QXdQYmQVzkoCwx+plnoVJpKAiEAo3kQISl0WGsK8JMb1v+wQXGk\nSyuyWSJkuOgYOcsyTvk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAepWKuUj4bp0vF+teNkxqajtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTcwNDBhNC03YWE0LTRlNGQtOGM0Zi0xNDUyMmYxMTg2ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8LXQtvOhRAwAdTrT1k9oiVsIASfMz5vTtx3LJyWbLKZ9s\nQnjEjUNR3I3THc6SBBJJoT/Wd5Xqi0kr6PiOpIZ/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl6ssPQf6PqBhfRK8D8tJAMUm\nQ48wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEyFYxboJpGhTlx22AHs5HmpoGPAk/58RKnqMs0PU/DsCIQCHW7F+DHY8\nW7XCXHOYsE33ixUA39Hk6nTgWsoGXX3j7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAYTSuN3C/jOkuHZQMif8iOzDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVhZDE3MTUtNDFkNS00M2I1LWIxMDYtMmQxZTcyYTE1YTEzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NDU3NGNl\nYi1mZjVmLTRlMDEtYmNkNy1iMmQwNGU4YzViMzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR1l+3Y7AbCBnbbSr+e5Gr1MqUT7TFeEYSJxqRBPzvESPWtmAuM5g4n\nALepn7kikNBzSKdk0py2DW400NacQL9vo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRyPDb2\nQWQFErmLMdQViitk2OOHmDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAk7kIOFe+nQXQLx+r5p7z9iP9Mm+kS8MeFyb0exmCs+0C\nIQDshZSbDJZMNVBxFitvcqLnksHKnIiltcmF4XIfShR9bw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6140", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6140` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISASAHpA0pxRfkMjAaX3/OtJVVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNzdkY2JiLWM1ZTMtNDAyMS04NmNmLWVlYjZkOWU5ZGEzZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJjZmYwYjItOWJi\nYi00ZTNiLTgzNGEtMmM2NDVkMTc2ZWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk7pXfYoRufTvOIW0IoQjILLcDjWztloc4dE8bPQTxBpyeiniVqkI5xNsHHNf\npveCBUmqY8YhPWM5cwt/GsUAW6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxLHA0BBFkVODprhevFcJL63tHAQwHwYDVR0j\nBBgwFoAU28l6vy9QqmUodNCUJaAum/+l+LAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIEi7QkKlJ3ljmdcU/x39rxs9fE6PbyClDYqdBuCMAGiPAiB8t86Cssvr\nUxLeyfJRksxwL0Me17B/zKdDazTTc4g+gg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeLTvbg8VDFQfay2uFhzIGl4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTc3ZGNiYi1jNWUzLTQwMjEtODZjZi1lZWI2ZDllOWRhM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRNpAaKFUh6gBiR9q7dx7HIGpFyGhVx1szlsH3iRYnNdlr\nC7mB4g7Rw0lHj6VQL/KWJxKluUKzjk5TnNouC5CZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU28l6vy9QqmUodNCUJaAum/+l\n+LAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL3XbNkjHN2aEzdOoDxrCTgB80Kg1MaFX/0oBNR6G/bLAiEAz0JrrUBM\nqyLg9UFyr9R4O7JghDDn0pCfiHx00m35aNY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISATh3TkiCJWurG3/7qQsJqzBBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJjZmYwYjItOWJiYi00ZTNiLTgzNGEtMmM2NDVkMTc2ZWNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmOTE3NTFk\nYS03ZmZlLTRiMzgtODZjOC02NWIzMGExNGFhM2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASn+o4Rf2oMYA3iRMplthyals0pIMCS7RDhsT2T6EqnzFLrO/+IeqSQ\nmTTJZce+Xj0et6XAXKKwlcu9KOo3OB8mo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTEscDQ\nEEWRU4OmuF68Vwkvre0cBDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBxTXUnCgNAznCk3Iax/NOKEnOkoNTLdB9NnzI4pTZ24QIg\nDmakWnxnkIa3zEeumiOEPQC1c2YUyVd0Q9YRvDjWJYs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6141", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6141` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAZQUXaeVbuZppBL4a1LanDVAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4YzhmOWM4LTA1ZTAtNDZiOS1hNTA1LTQ4ZDhiODk2MmEwNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmEwZGJiOWYtMDZl\nYi00ZDUwLTlhZTItZDIzMGRhMzY5YTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2kz/ma5a32IxsUHda92qRZAz4NbqgKjWUUjUpNYCQM+O7GszzrbttoLq7bd3\nvq4YQc5KVCOjhC+eyZca4rtnQ6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwHCjx14lYStKyyTN5oGYWvxBX1cwHwYDVR0j\nBBgwFoAUiHXiAK+RB/I9YksZP0k83yWvbWowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDqtMtQV7LdjaCT2PPTtAL2hYsmYZRBlYJs5W8HwppUXwIhAJgmgpbG\nwEsfhrC2fVkFto/DpGGEP4g0eqboqA9MiD90\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaHrLAy1mAryKNHUmCEcZ1IlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGM4ZjljOC0wNWUwLTQ2YjktYTUwNS00OGQ4Yjg5NjJhMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+VLVCavPqMXZIiLPTSEqFoU5e1Yew/wuKBJumiw/1sM2H\nL/ir2Z39YJoX3KOzn7Rk6LqryIvHuawrgnk5AAOXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiHXiAK+RB/I9YksZP0k83yWv\nbWowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbgW8JN6oolkQaImDftmwENnc4geQ4Mr/ZQJMW+US1UYCIQDDLrd+wlcO\n/KhLa5Dwx97lpzEvf/cV1XJEUzj3aQKx+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAU7yVGMV+Bh/4re4rVdQbtRkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmEwZGJiOWYtMDZlYi00ZDUwLTlhZTItZDIzMGRhMzY5YTExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2M2VjYTVj\nZS01Y2M0LTQyOGUtYjdlZi02ODlmM2UyY2Q5ZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARHGlzzQjGZ08IuTkZKhtdTU23gpYQrWMnNgwjnWhrtXV5RV4yt5b9i\nPvjPBdgbGI0oYXBlHTU6LxC0BTXXDbDEo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAcKPH\nXiVhK0rLJM3mgZha/EFfVzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEA2eu+pcObRIxRV/GZkgzaLHT7HgmhZtjyArwChfC4gK0C\nIQDscgdm5n/vq1CLDBHLr05KFYYnf8aERfkU1oX+seyRRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6142", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6142` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAaSWjK9L7Mk8jOxLXYReHED4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZGY1MGUwLTMyNzktNDBlYy05MjI0LTJiNThkYzY4YjFhZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhmZWVlZWQtNDBl\nYy00YjMxLWJlMTMtNTY3NTgwMDZkZjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYMUzYUTTi8CXj/Z0MULspfVdKScn7y5BhrpkEjHOc5rzJpF2pFOhZXoTsQpu\nW8Cow/E1OWBUWSH4zuGFlhw78KOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7mcVVH+h0vBSWw3lYybgkqymPE4wHwYDVR0j\nBBgwFoAU45yvlQXPxmUhvak2MKGgRnMg8gcwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIAGC9J5LPEIR5rrWCxqVK5OEdd0Tj0UMdd+doDwgGNBJAiEA+XW1Bve3Sqsc5O4l\nqlLCVQzCgVqsSgTQ0U1BU9JjdOs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASOs+/XXJMH9dmSI5V1mROe8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWRmNTBlMC0zMjc5LTQwZWMtOTIyNC0yYjU4ZGM2OGIxYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3m/oOvMOTj80PbqiH2/Xgs8s2cZ0UHRfIVOwa4EBINvv+\nsSjmbOUcN3zVdVwIKqbr1JlaudmVwn91I4CTMb50o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU45yvlQXPxmUhvak2MKGgRnMg\n8gcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI/PoutnlqGj5TSlDyX86XsmXlJWeTodxtCPbS1084OeAiEAuv6+/P4D\n3QIRORI4zc1rcpxbe8QYvGVzqbhEFPwRifg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYKahbAKwsCDKgggOmhB2JiOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhmZWVlZWQtNDBlYy00YjMxLWJlMTMtNTY3NTgwMDZkZjdkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MGFmM2Q1\nYy02ODFhLTRmZmMtYmUzZC0yZTRkYTA3OWE2YTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATjFm8nniMNXbNtnNTmJCviMlKjwMCXRBAJh7bSBi0j6I4K0lV7BBO7\noir47In4DQE+kiSTvP2BKgkbIob0dRCBo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTuZxVU\nf6HS8FJbDeVjJuCSrKY8TjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiASVuz5itzX0CTnrCeJkqiMfXI+5BXER97PUPiYV1WHuwIh\nAOGr/1fSRGQv1TnTGFWM1t1CN0QN8P6k3KLlCcCau6oS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6143", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6143` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAQuPH5IiCj6YZ5e/Sfqf5sHfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0ZjM1ZmU2LTNmODktNDExNC05MjdhLWNiZDE3OWQ1ODI0YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA3OTYxMzAtMjdj\nMy00Njk0LWIwZjctZjJhZGU3N2QyY2VlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEATCWwQU+vej/uQ53E4VvixV4T+WuIsNKgIu9uppdwy77biy/qvnudmF7Nlk8\nQeI2z1y/+H1ircRQv4MFPQI9haOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8OrK6d1FVxNgV/bLr/wQ+QaD8YEwHwYDVR0j\nBBgwFoAUX/IaX4C3D0xum7HvH9Lg37vln9IwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDb8OTQ1jSRV95gV/rgjlP38CcxDxd/T+ajyTR6I9LU1gIh\nAMG2URIcR5LwfXaw7wU2MoKOROjCmiHNMyvhfx/cHt4+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd4sq5IiE9JBD78XGFye69jQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGYzNWZlNi0zZjg5LTQxMTQtOTI3YS1jYmQxNzlkNTgyNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRYOfcBopkeYnsa8SiLzgbqnQ1QIaQsD0YPcll6eF5BjJO\nWNmBzBKdwY9GxbvEm0gG9ZMimAQTgriYBUYtL2jlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX/IaX4C3D0xum7HvH9Lg37vl\nn9IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKPNlbwsnY4x7jd0vARuaasPGXtYEYG7wzWjRbqRXNXKAiBh+GXkeeRz\nQbsic+m+JoQS9KhOcNiSgdW6gZ+Lz5Hq4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAX3WOsUq595ebCZuJG5EkLoCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA3OTYxMzAtMjdjMy00Njk0LWIwZjctZjJhZGU3N2QyY2VlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNWEzZTlk\nYy1kOWY4LTQ5ZmItYTkyMy01NjRhYjdmMzIzNTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATx37LcYfh6UgoGPARJem1ONv6EWiZkINZ5kLHlshg7z/Idq7NyPMm3\naOi/mBeThMvl1lh85DKnTmsx/Crgphk2o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTw6srp\n3UVXE2BX9suv/BD5BoPxgTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiA/wCKl515OZR60T/3ZjW0d60SOlylDPFyyY9sfdY2VqAIh\nAP8dT/Qn2SC4PEMQ4Y1VP0P3uhuygX1XXpZBV657uXIG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6144", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6144` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAaH7+cj5PjSeQgDf4/xgYA6RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkMDRjZDVjLWE2NTctNGVhNi1iMGExLTFhNTQ5OTVmM2Y1MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGY5MTYwYTEtNDI5\nZC00ZGFhLTlmZGYtNzM4ZTBjZmM3NjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErnCiPQ97ySD04xLQLMQRMzv6SPjvggXwIem/SmyALP9sIC5q4WvN+r2nyUfF\nIAiKuejOadDdK9ZS+X3yqyFSF6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaer/15qq4w4eOh4K9wWA7Kcx33cwHwYDVR0j\nBBgwFoAUY0u3UrrYuwC1EcrHbFajq3h+AFIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIHe/MpFZEaBvlPQgWpzSEQMvmfaJqjOPWMUnRjfP+8wQAiEA\n3bOD0WO2b+6VJfg0s1nYze049XKKiVIMBtMVJN+Z7fw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcqvSFGOsjm8B5Wr4GdT8soyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDA0Y2Q1Yy1hNjU3LTRlYTYtYjBhMS0xYTU0OTk1ZjNmNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBOxOO5KSIK7wqbqft/Q/Kpef6SaoJ0feSSjTwkEdiuo7V\nYUpA6NBsuJkBRxVkQ0foQRSuotj9rpfp+Wp0sCG1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY0u3UrrYuwC1EcrHbFajq3h+\nAFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV7JDzrgkJ/49DZy223qo8HDR7Ce43bLG4KtheYj79qMCIQDxHgA80RgX\nyaBn88wdCHTICGyzEvJyQR57yaXk/wSV6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAc9ZfXZiCqDEL2yI0PLcm5g4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGY5MTYwYTEtNDI5ZC00ZGFhLTlmZGYtNzM4ZTBjZmM3NjdkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMGJjMzY4\nNy1hOTFhLTQ0NjItOTQ5MC0wYjI3ZWYxMDM2MzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASXI5wh7ZxVbX8dBmDjGXMIfTaqNwlOh9R4rXW2QOWJPDImVAMp/Wai\n8yXUQYyBhaXuAjtM/gYeHpTPIKt6VlVRo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRp6v/X\nmqrjDh46Hgr3BYDspzHfdzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAu3BJ+8Q11HCYGJrgfIkJ/FxzM2cmrViQGYJf/9l/GsgIh\nAK+7AxNk/uHsRjwaRXEJB8eQAfPwv14LUovATR860u+q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6145", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6145` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAVoQieboDfux2tcjjdtcB015MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhNjQ4MDA1LTVkOTItNGQ1Ny1hNzEwLWIxNThiM2JiMDRhYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI5ZTU2N2YtMWVh\nZC00MWI4LWEzMTQtZmRkMDA0NzhkNjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzN5F4fkaeFC7pmey5rqrLGpFLDxTsFO9D8+5opz9Mq3S5EDjI6wzMkJxggkP\n5WXTAE+fwSIeqcYQcM2cxZad0KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu7NbJkLBY7admoXDbAWXwigw6RAwHwYDVR0j\nBBgwFoAUPu18lkRjlRjk1lBFXETpKDR8fdAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIF0nB+V3u8NZ\njMBKp+JLEWSs3Da6Yj3BmHdbomnD3Vu0AiBYVqp2j6TAPj9bvw70lvqyrGIUNiJ/\nz944k3uieMJTPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAToZ/orIBGYuXr1VkH2C5j2wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTY0ODAwNS01ZDkyLTRkNTctYTcxMC1iMTU4YjNiYjA0YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdPyNbqm/sYm5aQ9sEH/sqozt6ZhrA2TcDOtns5QINZx3k\nfEZrWPJB86rByNY5dkbI4urpnJ4E65alTcpHzNMio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPu18lkRjlRjk1lBFXETpKDR8\nfdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJcksx0dGaTWnYuU0c3WkSlR1o7lqtkfD4A6kpiIVwXMCIQC6yqYbaMZ6\nud0gV/wIyb1u94Y82ieroEodOTQNv+Uyrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAedolBXEwUWxsmBCgwcjSN9aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI5ZTU2N2YtMWVhZC00MWI4LWEzMTQtZmRkMDA0NzhkNjI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYzhlZDY4\nYi0wM2I3LTQ5YmUtYmQ0NS0yOTNlZjhkNTIwOTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQK2NvPFp8ul5EJjapMFUdppBW5RhsXkma86AAjLSjyNR8bIVcgYlxu\nqKrpd1yQZpUgEXdPLKGlLF1BgwwHiOvbo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7s1sm\nQsFjtp2ahcNsBZfCKDDpEDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAmb87pgdTjUNThNTzQqeQ80UnFDgL/OMENVi8EzA6nkgC\nIQDzXOIXxwgjQEwyUxzRb8CBk6yv3OpoTQ0M9pLD7WMuVg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6146", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6146` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfr4kQ+J0jlPsZ1/mRC3bacUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZGEzZWMwLWEyYzgtNDQ3Zi05YTU5LTQ5ODFlM2MxM2JjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAzMjFjOTctMzZi\nNi00ZDEwLWJhYTItZTE5MWQwY2RiNjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE11JgTAeSH9p5hda2ZdwRPuaXKXCBidSjbuIKJAncAICuEA2sJxrSlUgOdwnV\nWgRdKtfEWFbgYeDB7Wqe3kAHpaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxAQfNeu0wzMI7fiRqDWekzzg5c0wHwYDVR0j\nBBgwFoAUA8vEJvKOsLrG6Z24EVwCHXmINiowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKHZrMTD5RuCyHxekG2PxaHH7vpBCfkBG7Ix+Lh7xcRaAiA7y6IPcrDI\n2r6nprUERC/aI3lY+yvf0Vfe7tYW5xS2Ug==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU4tTlxat4SpRVx/Jgsq3WlRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmRhM2VjMC1hMmM4LTQ0N2YtOWE1OS00OTgxZTNjMTNiYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0jC8PxjaBKQGUO1LzBSAWSvZElQzhP6SzXF107qMW2PGX\n5ZY1De43G18DvB2bI8wlEtyCUqOqsm1aT479XOAKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA8vEJvKOsLrG6Z24EVwCHXmI\nNiowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALLC874FGY3ZLZvlc6kKQSP2znHeZEO7k+k10y0CxxWGAiEA+yVM2Dzl\nUkCK9ECHfpvOttJVTfvAW8IxOUyGK+ujpbA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATklgk8WhTZA/azlopues0USMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAzMjFjOTctMzZiNi00ZDEwLWJhYTItZTE5MWQwY2RiNjhlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmOTIxN2M1\nOS03ODBiLTQwMDAtOThlNC0wZjU3ODkxNDVlMTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ/xOer4GVG+oXsx5x+Sn8lzw9RIAoC2LdKwXkIho43GOgcs3+G+kOT\naYudyJIcD65o/led/TvequfgxnlSPf7ho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTEBB81\n67TDMwjt+JGoNZ6TPODlzTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAqstWPU7m9C8HVDeAWwPupv5/K82Pnsevr/mZbpBBQ6IC\nIB+86UfyQm4y1hwKe3sDXt14gyW/UpXLnXXXZGDyIMUU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6147", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6147` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAX/saSoX14Q2hkf1qDOpz7AlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2MjU2OTM5LWI2MGYtNDc5Ni1iZDNjLWMyODdkMTQ1MDRiOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjJiNzc1OGMtZTZj\nNC00NDE0LTg1YjEtZjVmYzJlZmE1ZjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbSgfY3uZYU1mK7nezLEBrE19VL1gaCPDPrKczvNJPKvIdLLs4+FfBS9UizmI\n75aUAXITPQX7joKKnSgrMm7GN6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUshEgsBn2ZP3nUv7pnHL2zhrwVJcwHwYDVR0j\nBBgwFoAUs5tJaELJkaYojXCeOLqenwYfPWwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgAN5qhzpfu5npFEevVbakzlvmETrGs9SMVAR/y9NrDPwCIGreBI2fBuOu\n7UUG6Ka7mtxIi1Yvfd2iRMN/Dmx0SYvU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ7xa6MrARicBm9ZSaGyQwpgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjI1NjkzOS1iNjBmLTQ3OTYtYmQzYy1jMjg3ZDE0NTA0YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS1ss8+FtgIdDbVIFJMQcKtJ5yoH95ajKsSpivgYpSbtaF\nxxZp8qQbH4KRLHX3PQRy+4d+t90Jcil5BWCoIJ2bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs5tJaELJkaYojXCeOLqenwYf\nPWwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN6csP0roTd3ZwE/+qDv6rdrIMi9llDhm/nGeR/+9+6YCIQCtEZG+OExJ\nkwTv3ZqnYZLH8MJ3jfM0S6lPLgskMYOEew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAbTtB2S2NqIf/ByMm/ksoRauMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjJiNzc1OGMtZTZjNC00NDE0LTg1YjEtZjVmYzJlZmE1ZjRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjODgzZmFi\nZi1mNzk2LTQxMzUtODMyMC1lYTA2NmVkNGNiMTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARwPX1G8gUpaC6wyTvx1OYglQF0+ZCgwLVa1NDLV9t+CsnmDJKxo2zI\nOzLRHqUMMNLktSIEEXENteMIVmzx6eBZo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSyESCw\nGfZk/edS/umccvbOGvBUlzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAuqR7s+HNk65j18DAwwWIsh0XLF942uA+MawPZCxYUvkC\nIQCr13iZJJpGTzlD/O7Y/0/1hgFNQE6dK15u/oEHQlO64A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6148", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6148` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAW3snufeXJpYLDglFln2q5pmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjMDcyN2Y1LTY2YzMtNDM3OC1iNDA1LWEzYWYwMjllODgxMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjVlOWU1NzktYjlk\nYS00MTlhLTk1NmYtZjE0YTZmZGQwODU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd6aYFLfqjZrAq065Zhe6wJQ9rIgWfV6Uzr9cLyCkXXmj+HVt06jXU07qcbFN\n6uWh0x/xyR/tmm3IXO/QhR+A6KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEDbVQ8fcyMphfA4h+0uPaO/rJncwHwYDVR0j\nBBgwFoAUWCk94MZSmIoLuNTRfh+7Ucm8UvUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIGOIE/c0lQJxA7+JWVzpuqDTl56Qlf7sLtzv0rvRyYxzAiAr6V7rGlsC\n8ZN/9ufWx2f97Tj5fKNtXO8Z2GGChXmIzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaaM6v4jvJyLQPqevwOlZoxJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzA3MjdmNS02NmMzLTQzNzgtYjQwNS1hM2FmMDI5ZTg4MTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1JpGaUTMRU8MlC+vwnURmUFNpaj+WBX8n3V8gtKdHq8Qq\nh64Mg+Vwdjafgf8l2NK14jmZQ0CemwJNVVAZeUQAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWCk94MZSmIoLuNTRfh+7Ucm8\nUvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAObFTEO30rKCMyu5j16mV8ZYc5VypMv9Tdnn9YNIWviVAiANzKUo0mqx\nLCar/clfwx/nNtZly277Q9+DNmy9yrBPaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQtkLfGmj5+0ZeIvcGDFpn39MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjVlOWU1NzktYjlkYS00MTlhLTk1NmYtZjE0YTZmZGQwODU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MWY5MWNm\nYy03YjAxLTRiODAtODY4My1kZDU5Zjk4MGI0ZjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARrD+v/kiCONLKN5D9bxI44sb7hHb5/NxDyL+ueDi1TrkrWebLbQY1C\nPaSWdp8ulp98+u4ZVceYFfR7+ieiqCFVo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQQNtVD\nx9zIymF8DiH7S49o7+smdzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBQA+muv4r8p3R8gX65F3wrs+2g4vcXfzx8yrCMmKHtSQIh\nAIdAHMSJkz/aLVSoHec0hakNWyvdBWEDEQXG+EeE5dvq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6149", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6149` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAbbQcgqDsMS3Rn6oZ/FrTTD0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NzAxNTZmLWYzNmItNGRlZS05ZjY5LThmMDU2M2E0ZjU4MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg1MjBiZDctNjc3\nOS00Yjk0LTk5YWUtYTE0MmE2MDJmMjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1WFvdonKfi/hNv2Wsc7Ik+06IMi6PufuznuU4CIL/9B3jSfpa2PImke9mc+P\nJS4rfTN3DWddf6c5fjmSRRWwZ6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYzDhUUI8/0J4ygXSR7N8Yb5AmsYwHwYDVR0j\nBBgwFoAUjJ/Ed53VFGn/7pvTirWPlSQDeJkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIFUF8pmemcgte0fGdVES391iTepW3rXdLOpHONtx\ny53vAiEA3UuQgzYAM/LQnZaTL/czOxkaJ4XsJ8owXFMHl6iCHNo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ5k5RNWITUWyzACo0RwbRWWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTcwMTU2Zi1mMzZiLTRkZWUtOWY2OS04ZjA1NjNhNGY1ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnlvNq+D5WOiNokHThu2hP53AiL5cx8ljpT9fQJ/xe+w65\n4ZHcCAUVyS6iHtl0ZxBaMOR5Jm8RLN/mn7ms7tcVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjJ/Ed53VFGn/7pvTirWPlSQD\neJkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAImd90GbW82kSDXXoo0bc3y5evnb6PdXm5SmpRXcPz+7AiEAwXrT5qVP\nwCvxVfYMeSxXIC5tOU7oXxBdcCiVPLmEzQQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVGHebzkTqlkupcoj5wySBwpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg1MjBiZDctNjc3OS00Yjk0LTk5YWUtYTE0MmE2MDJmMjFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZTZjM2Rj\nNy02NTMyLTRkZjQtYTE5Mi1mYTVjZjA4ODk1OTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATdlMvgeNbKKDJt51HBq5ie6QEQUqt3R/jIM3x0dscHiAIQQLUytLif\nYiTpL7wUk0I17wfZfx7E6nfbWq3KO/K+o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRjMOFR\nQjz/QnjKBdJHs3xhvkCaxjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAwF9E52r+RNYdNuPy4EXnnK3U+/IeYByaTlolWf0umRUC\nIAWgrZjQ+UM4VufAv6a0rf0A29BP7ZKQSoTCzQJequPT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6150", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6150` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAVNJNFNAKFA7bcEkB5E/xDm1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4YTAwYTZmLWU4ZGQtNGVhNi1hOTQ1LWQ3OTcwNDNiODgyMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODczNWNhYTktZTAz\nMC00NWY4LWJjOGUtMjZjYjZiNmUzNTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnZWJKTDfq5/pzDsfb8r54qsD14EWmBuH9iUQ1o/hohc7Jf3yzHBUnb9/YRCE\nNfvoJvSQJ5Qf2nH+VHF/Gy9GD6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlS5WX/XeQwHPJkmpaC6bEHEWNCYwHwYDVR0j\nBBgwFoAUAzUEAo9sYa4keOtTqQ9WGgGiDQAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDo3vrTOQnqlZzrmVij/h0DY/btOUfbdaDukVWH\ny7O/1wIhAJ19coE/fJBhX4QydqcnUSTcff2ccA0YhbO60LHeL/ye\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATDEHQjXOi2imf+BwetvA5sgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGEwMGE2Zi1lOGRkLTRlYTYtYTk0NS1kNzk3MDQzYjg4MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDLpn/r0IRQ7q/1nQ5U6GnJPNSc2MAlkGG8BZR3W+jms97\nDc1qk3vY4q0PTPnEVwGcbNb+jDLYmvWoc5KgaxPOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAzUEAo9sYa4keOtTqQ9WGgGi\nDQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXAjHpJQXPhTVF7PVCStTVctvZPVrFjlZgejQxeCaedECICt6DOfArLHn\n4ymp8EAwDchx+KQrAru6UPAlvVFAk0L5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAblZACNWMM7scGvsRjU1hUcxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODczNWNhYTktZTAzMC00NWY4LWJjOGUtMjZjYjZiNmUzNTU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxOWJjYmI1\nZC1iZTllLTQwNGYtYTRhZC1iMWVhMWZiNWE2NzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASx8N+qa2B1my1iacWqxRl5ulXZyuBtajO1km46Hg7MqTjMLPM0J9uH\n3SEa7JVDbhio8EBIIuMTuxuKv0Y1BpYEo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVLlZf\n9d5DAc8mSaloLpsQcRY0JjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBRG1kvlawp1HLd7vvot9JA8VyFWAVDTYuDULgvrhyyUAIh\nALl8niCKXCzunNVJGLXIM+r74pWfALqW5vJugrWemdhY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6151", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6151` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAUo2iz1hTNl40/P88fPXVlVRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MGJiNWYyLWI0ODItNDY0Mi1iMjA3LWNiYmRlMDQwMmY4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjcxZmUzZTgtOTI3\nZC00ZGQ1LTg2M2UtZTIyOTgyYzliMjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC/e2GJDbi2qig0C6SDWjiW5lsmeAPtvniFdaUBD6CcebJspDnPseXzi9X1kF\nZ4PUHi6G3eNu70/OUP9qElwbKqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUVoQYPcUmhG14cb3rGmG2YtA2GcwHwYDVR0j\nBBgwFoAUwetUJ6bVwAfBcDdL5DPIoOR2zO8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIBVlUOc+UWLsG269ie10o2YqfbQRT724dU7noocs86gqAiAE\nTtOITCfi/gyZ2PLVcPd0/DyBO37puDQud2LTbrk4cg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYMt1LioGCPdh7ltwINtbcaYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODBiYjVmMi1iNDgyLTQ2NDItYjIwNy1jYmJkZTA0MDJmOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXpycR99BDSo86DnnwMlzjFr+2YprAixUbFEJjIrTEpMIz\nzgcPsQ1JsIsQiKQZ+ZSTu/ZuODTGkNyr5hOhoQHmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwetUJ6bVwAfBcDdL5DPIoOR2\nzO8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALgqr8OHjXq89KN+bJDiMqz/V2prgzso3Uiqk9QfBRbSAiEA66XhP5q0\nplJK4sNHFNVeCINgjnAMDKRmiVaN9YIji/U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAY6JLNKWC5QV5VkS4cWsANcqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjcxZmUzZTgtOTI3ZC00ZGQ1LTg2M2UtZTIyOTgyYzliMjNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZTI0NDZi\nNy0yYmM1LTRlNjEtYWYyMy0xMWZhMjc5MzJmOWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQYPjA2L+XKH1cIrtj4sJD59Dj25MhMhPVGWAK/WfrQWibjPZ9Vmo7O\noaRa74WaLrY/yCRToLGqB6kwNh1p44pxo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRRWhBg\n9xSaEbXhxvesaYbZi0DYZzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBAFLK6c9SKWrccKuyYEtbRFcHnRhpbN6P4jAMCAPzd2AIg\nCdlVTUXXP3v8FXI0vpx/HX/KINbB0MPsrG8qhqm9DWI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6152", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6152` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASqkFWwQPYNJHxm3lmfdo/mBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwMjc4ZmI3LWZjZDYtNGViZS05YWE0LTJlMzYyZGQwYjNkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDg1Nzg5N2MtZjNi\nNS00YmUxLWExNGQtMDJjNzFkMTcxYzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETCK82rX7MJS6uGy823/yQDSS8OgDYpM/a9Azqxo4A/sXrEw9/Fz4BEZyNMww\nkPi0JTxSzRQhSmUAfIG7Vnfc/6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB9eXcDRYICJBhj5KhT/O+6wyvH0wHwYDVR0j\nBBgwFoAUREqQGx4tDCHP12g48OkwoB4XRIswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIFAv3MihLVFthJxN0KzB9qmQ+NCZr2Hm\njtSQIuXEg482AiEAquj0lGpUGBkC/TVgV7Xc1T5bGpEjIwiuhy/wlHjCx6M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe5RjwOcSNwRAv1/lV19lYp3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDI3OGZiNy1mY2Q2LTRlYmUtOWFhNC0yZTM2MmRkMGIzZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6B0gTBmVbWsrXzbR7J2dYkJlUVbpikTFgshci0Cr5U41K\nBNu2k0XZOfbigTkj/6mcPTveYgW+OooFYaxTua70o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUREqQGx4tDCHP12g48OkwoB4X\nRIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIphG9yhwbqP6UsXCNlJ01fnIyjL+sgSvq54CVyRMnqSAiEAy6jE2hPD\nSRfibF55tn3xhPFZsXeBr7sHNjUk318k5gw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAR+FO2+bMXSAVp8gQolmOyzVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDg1Nzg5N2MtZjNiNS00YmUxLWExNGQtMDJjNzFkMTcxYzhlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhOTU1OTU2\nMC1lYjFiLTQ0YTAtYTc4NC1lMzY1MTFkMzg0NGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS4N5zCGuyADZid7Onv9Kw1Ng7SZYm1DWb8SdfukAkLMLmN56WA96PG\nA4iHBkKk/RkF8w0ZBX4xlFqP0SxEgU67o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQH15dw\nNFggIkGGPkqFP877rDK8fTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBddXrqAVrRGtLLDUbNvWAb74zuJQofVxcXNWnIb0HkTQIg\nYlbAUQlAiO+rY0yLsLY0hVNJagj+lhfhwnOtg+CZdHw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6153", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6153` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAT43RdqUBnK6nDAi7NIlYLmTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMmNiYzVkLTNiMDItNGEyZS05NDYzLWNjNDZhMmE0NzZiZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJiNGFhZTktYWI2\nNC00OTU5LTlmNDItZTBkN2IyNTVlMjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVUKu2ss2XpeYce3V8vsbUT2miz8/uEXf10Z/f03jf8GGB/PapcTfGAOULweF\nYAZ9QXGe989ORPZFiY1wBjMQ16OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcMHO0COxnoGhakObs+r1NYPYYUowHwYDVR0j\nBBgwFoAU7bcrxakhGTqLNqMNpNgVb3uXRtcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDXDZadFuU6aE5xm4IBZW5XEyiBIv1f\ngM9oAHN+MTf4TgIhAOo/gqhWCqxuWpVq83xTgfOT4HcAoULNOo/GWC90pxLc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAde6TS5XU4UFHhTcmxa8oNx4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDJjYmM1ZC0zYjAyLTRhMmUtOTQ2My1jYzQ2YTJhNDc2YmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ31c7Qz9/hKFrMqk0+w/AcT7I+tvnZcDsQ/qHvELE/lUFx\n7NqFc01RanjvhsKTRSO6scXDsSHguPsU+tNaKySDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7bcrxakhGTqLNqMNpNgVb3uX\nRtcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGZ6JjTjj7wybYAcbmTYknovOBRKfZoYib8iNye4++LMCIQC4ZV3H6OZA\nHpt7wfRLSNTcTczse/7PEMDW3ON8xX4gRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbZCY5YtMAkUL2kjP6GrxnZZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJiNGFhZTktYWI2NC00OTU5LTlmNDItZTBkN2IyNTVlMjJmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZmU0NmMy\nMC02NGJiLTQ3ZWMtYmMxNS03MzM5MjU2MDM3MTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASsPXEwvuFb6jYP6Tr4wrqIl6NPZuX9PCsy3Ml6VnCdJZxAkuCK8P1m\noYpPGdgeHXHCenNHBFDrJrqSrCc32bvuo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwwc7Q\nI7GegaFqQ5uz6vU1g9hhSjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAsda/9WsnhrObDUNgbt7D/Cs/GK3DeWxIQIQI4YsKFgAIh\nAKlEcIyGmJhptHJK0UW7i1QU8q/ogwDzaQsglL3CDOg0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6154", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6154` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAUwCzIp4xam6Cw6mvY2jtV9jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4YjY3MTQ0LThmMDYtNDVjMy1iNjM5LTRkYTRjZjBiZjc3MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFmZWRlMjQtNGMy\nMS00MzE2LWFmOTktZDRlYmE3MDQ3N2IxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8tbq6QNh7ZZjgxOoGCL0FAoLMu0+RqwBwC82jwc5ZNSTETvZkbGR+no3vl4L\nLi8+l6y2j3l7HNKIOl0/eZeGm6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpzmqvla6YfHiqD7sFFMbiFhROSgwHwYDVR0j\nBBgwFoAU4l6qKWoidJM2E0ER0q5Ww1PY3T8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAScrYdp5wWV\nSkIiWRYTBEe+0HWjZ+50pHbVbkjK32uVAiAJBzaiPvteU010curL6wwIFasg//t+\nOuk9NiaMjdHVVQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT3KoCPkqGagZkrD7vJs+RXkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGI2NzE0NC04ZjA2LTQ1YzMtYjYzOS00ZGE0Y2YwYmY3NzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEloWfxlTRNF1oc8rPs23I/KY+8Cpj8bwS9i6LQEpJFsZK\nzPH/1RS4YYyQky10o+jPtlzAuAVKP54K1SD4j+C5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4l6qKWoidJM2E0ER0q5Ww1PY\n3T8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLjmHa+bJ43QUJBCNVTXcHdw1nOxiSw6eCxiQKLgjA3UCIBqU35FR4u6Z\nPmV2tM+25A3O0mp4Lw9Of61jGwOH7vBB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAbJjNvt6mMjFd8daca5cWTR/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFmZWRlMjQtNGMyMS00MzE2LWFmOTktZDRlYmE3MDQ3N2IxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNjlhZTli\nOC05YmQ4LTQzZmMtODAwNi05OTgzMGIxMGE4OTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ2eQRiinQtwsQMxoU4B25/oCWZLIb0HAU6FkNMDq4FcZW64K436laq\nPhvYjWXUlzgic2Eqe4tBGHwLiGoDZenvo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnOaq+\nVrph8eKoPuwUUxuIWFE5KDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEArPWrHn92g96QDxqZfAlgWgYY3h/U2MVxn3znE30sDrAC\nIQD4Se1HqgtAEIYBYCjbaMGV3TD/1HMiJDYSNijqKSzoFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6155", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6155` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZ+/dMzKbRBPJZifPPJyqR9EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMzIyYjUxLWEzMTMtNGMxOS05MjVlLThmNjI1MDgzMzJjMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTAzODg1NjYtZTRl\nYS00NjA1LWI2ZDgtZWJlMTE4YTNjYTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErnBR6RFgYX/drHcRvCev9ctg4D7A7KMrej+mXtMP+J3qxArcq+9GCCB0T2hX\n7SlV8gvsxcQM7Z3IoXXKzRb2UaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSPktECvbGfAyJ0pGeTSf8IkALAkwHwYDVR0j\nBBgwFoAU02VKiZ87ah4oaul3c8j1GZQSHYEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIge0+aLlvaqaIoNmw7gNcCWp5O6Wj5XOkUXbc8+i/BFM8CIQCzH1ha7OQo\nKz2S6boDrC45jHsm2B8EOk3AnhlRN3iz4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf8RQl6xeZrEbz2ODO95YagbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTMyMmI1MS1hMzEzLTRjMTktOTI1ZS04ZjYyNTA4MzMyYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASD8vVN39DCSIAU7+rapuod+GkeK87y697o+P0GLc30/xHI\nJnoGvWsrIf3wVrF8y3yM1DLPe0RNBdVJSQiqEnUJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU02VKiZ87ah4oaul3c8j1GZQS\nHYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKyWS2lxY5m456X9hpSv7qdGZwGGQvWxlU5ilEZY/b6pAiEA4ZVUa+UF\nqF9LtawlCc5wr2vw8DrisCWR8v68XeDbU2I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAXVJunF8xJ7b2sdj8jXT+kDEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTAzODg1NjYtZTRlYS00NjA1LWI2ZDgtZWJlMTE4YTNjYTQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZWFlNDYw\nYS00MzVhLTRhYmItODhkMC0xZDI2Njg1ZWE2NjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASibf814stOrEYe8N8TTEGKxFj7OgoqUzADEaY6cJdmWrWp+gT57IDe\nTex9vfv2QTpqAw+GD0erVXmOABr6RBe8o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRI+S0Q\nK9sZ8DInSkZ5NJ/wiQAsCTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAnpeJv9FPkWRckcWarDWisr/uhIKjW5iO/Or+oZrzGj4C\nIQCnl9tByu6Hb/WdMdruO8IpRk/WCKZl7VL0w5Il6oo8JQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6156", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6156` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAdfW0J+YqUorFYdA1gLL85GSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwYmUwYjdiLTJlZjktNDZhZC05MjM0LTNkMDNlZTU5YjRkMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU1ZDgwYzQtZDI5\nYi00ZDYyLTg4N2UtY2Q4YjQ4NDg0MmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOElnYtMjz1+/czHGi1rpo5j8y5iIwUhEDOz4wJ+59aC9gOhjyd5ZNUu9EBLL\nkJIMm3ev5Qojbu6SZKbb/yeP0KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAY56dhDvBKx3B7dtNzjcgkH+ms0wHwYDVR0j\nBBgwFoAUfdxfcf4iATrcp9Gbc/+3tY6jp2QwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAPey5ngVzE5t0Ny0uBn+XhEowgZC5KYZlT4YFamYZajEAiA7yM6lzu2n\noOaGurbOYKqn37mY82wqdRpsdykqnP2mbg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR/elS9n0OkrqNIRFLH3J6FGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGJlMGI3Yi0yZWY5LTQ2YWQtOTIzNC0zZDAzZWU1OWI0ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWkCY24Vb3dzEYEhsgOq3iTeXtcdlMKDRbEhsOH+lYdJe7\nPatso1A0X7U4dZHHCDxVUJBdJagw9xb15IX+JOTYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfdxfcf4iATrcp9Gbc/+3tY6j\np2QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbnTnX72S1gshrpLK8Hl3WvMzHnXG3N+E2NaWa40rOzUCIEXfahYgucsH\nn8/QiQvU+2CW324uxC3G1qk13/5Xz8na\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAUTJbXyv8F8M/GEzag0lnlYCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU1ZDgwYzQtZDI5Yi00ZDYyLTg4N2UtY2Q4YjQ4NDg0MmQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ODg1ODM3\nZS04YWFjLTQ0MjktYmE4ZS0zMDNjMmI2YWJhNjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQku7ssF8k2qtgXXEi7HPUnCPP8AdcCe1BnQfbmfkMFfx2QSwxhK66m\nzWbgLoXyuGn0+uMLzOO+t+0J8jFfVUteo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQBjnp2\nEO8ErHcHt203ONyCQf6azTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAuiIOBj/1LtaV2Rzjt3SlL0wrHESieJIQlKn+xCDvmLkC\nIQDlRthSlumLm0SOV4flQUgQXB01c4hj2q8QS2LBqE1wzw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6157", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6157` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAf7rTLQpNlBgHs5H9tC2mqWEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MzI2NmMxLWZiMGItNGY0Zi1iYTFmLTgwNDgxMjQxYjcwMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDVkYjM4YTctZmRm\nNy00MmIzLWE1ZDMtNWY5OWM5OTQ1YWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcU7cQM8CY3+D1Cu1+mDuqm42hjo/sG+tbnN7vndK3G3ofo48WaLX+nhY3I9Y\nvKyIA28sye7vBClN2zfch+YSYaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFRMTSL+R+c4LsK9X6sFmm6Tw5nswHwYDVR0j\nBBgwFoAUJ79aBXkqR4LdO0uP4yn8Kv+pfp0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBewnf3+u7sd2fwG1rzwHcEAOrUzkI7q903xuaIPPu77AiA2ghwCJacC\nvqEj8CnU4TWZieoiqLFKWTmyU31dO/2/Qw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR6od7iH56OT0L2MGJWF98+MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDMyNjZjMS1mYjBiLTRmNGYtYmExZi04MDQ4MTI0MWI3MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUjzqtwWQhchvPxgaZrxoesShTALwdoiOS2jQUvHiblOLs\nsRx9Zw4OSMLaBS6e4Mn1fU586PBozZ+Xv0w0vdDBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ79aBXkqR4LdO0uP4yn8Kv+p\nfp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPHmyauUW1MXRgOE7UMNuPSX5iM4a8pT5Ck+Ui464KVMCIQCxVmvRXnri\nG+bBBwn2FoawFXE5EjdFFEXHK73EDdm3jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAaYaCr2mHmpd3eC12/5UeI8jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDVkYjM4YTctZmRmNy00MmIzLWE1ZDMtNWY5OWM5OTQ1YWY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMTQyMzVi\nNi0wZmZkLTQ0YjgtODMwMy1lMWZkZTMxNmYyYmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ/Hnqz+eN6OoLhGehFzoOtOO/R8n0jIp1foI3AYrbng12LGdX943tu\n+9YG6M0x3PIYtOwc9zwEHLN66EigBa1vo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVExNI\nv5H5zguwr1fqwWabpPDmezAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAKMgXfX/gTJMebEKye2iVWSmdfNQ+PCM5flDhgXXV76AIh\nAMTdM4WS93IKWp2JxCPau5qkGrlS0RBgMr8ppic20U+0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6158", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6158` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAR0l2GSj7Rlbm0ptv84uNnH2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2NzBmZDQ3LWM3NDEtNGQxZS04MDdhLWJlZDk1YTA3NWQyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA5NTliMzEtNjA1\nYi00NWY2LTk0ZDItYWE1OGRlZmIyOGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJL+uOlLr5L7tuibxfNBP3cEt38hYZe7GUk3ZAFPlV89OaUqS3Dta1H+dRaSr\norpcXKy673BDV3CbdKyYTpNRiKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUopxX0Ghep6uWELWaYlCW5Armmb4wHwYDVR0j\nBBgwFoAUNQu2WYRb9U6A+7+Kq4m12paAKbowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCRfxogrB+ySDnrLDOnlgWYXVbN82KxCSg7odqG\nOMgnSQIhAJgBK250YvR/Pd2X9A9oar43HlkO9FT4SOS3wNXQn74f\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZdz2R92iLcbOf65Rn7NSuorMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjcwZmQ0Ny1jNzQxLTRkMWUtODA3YS1iZWQ5NWEwNzVkMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXoF1tt0prIp6BBLi/iWenyvfNDPeVIt0E6TQ7fujEPDRl\nn68TV+8ERSLSIt7cFHQ1FsA4YhJy7e6FYGR1sur8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNQu2WYRb9U6A+7+Kq4m12paA\nKbowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO7Dc88r9KXGtg2EJvQmvCSTCKXKFBEPMY0t1K8yo4DmAiAeTv6qNBfQ\nUSDOhurtFDnog9TZZMwCRLtsLSA/YPosoQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYT6U5aviTJxWQOC3xN4JsBTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA5NTliMzEtNjA1Yi00NWY2LTk0ZDItYWE1OGRlZmIyOGE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNGFjN2Ew\nNi1hMThiLTQ1MTMtYmE1Zi1kYjI4OTE3M2VhY2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATrqpxaw38zDHmY0lR+kmnFt/E68VzkLS0bD69x8oKX7jXRXf4bJsy0\nsV2FRo5lfqprYUUpMiur/Nah8SDGKxsSo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSinFfQ\naF6nq5YQtZpiUJbkCuaZvjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAguCl1npEaM9cpNfu1wLv3XtnehJ8qGWXCA2ojF1MV4EC\nID5Oi7ljVNOrvNS5nJlmoVsPeHbl9Hc8l1wbqy4bODZ8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6159", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6159` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAUWtS9gfnmEbJeP84rh2mBiAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NzVlYTllLTNmZTktNGNjNC1iOTQ5LTI0OWI5ODY3MTM2NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTRkN2E2OWYtMmYw\nNi00MDMwLTk1YTgtYWY4NThlNmNjYTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoN4VGTHQ8M3YSOsDX9lNWROih9GnaR5qyc/2NxF/Lx9tEOES0JkmBh9s0EuN\njetphY61ovTyUmakS0Yp1xJeGaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXV3aadDnA1gDOIv5FhRX8WBxkkgwHwYDVR0j\nBBgwFoAUug9N9Uujsdic4v5nHrFLQDDYLyUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCmHcjlxA0KvQDEpvTPbaxa+2Wy2A/qCitXpIYP\ntkcfEQIhAKiEvbbu8XADHu+JpHzXnQeoZCuAAtw6TdGeEgVGTo1+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYlCNmkMoNlUgM2JQLR66NZPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzc1ZWE5ZS0zZmU5LTRjYzQtYjk0OS0yNDliOTg2NzEzNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrFeeXO+NlHCzx5hc0yJ1SJLoQoJzQl2clikr6gns26eoe\n+tfgA8n0TYU6XSSMkSQyeULnfcVbsmRSRnAmFtcxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUug9N9Uujsdic4v5nHrFLQDDY\nLyUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC111DQecbak7SqyqQoNYc5Q32vJfQIhWwvhQWroi3soCICWgOZCwi/Z5\npecj/9GPYdsa5BvM1Zj+H+uCpvhGGW6V\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQK16MCdyw0o4G0XhfS6pWMXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTRkN2E2OWYtMmYwNi00MDMwLTk1YTgtYWY4NThlNmNjYTkwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MzM0Yzc0\nNi1jYjY4LTQ5MjEtODc3MS01OWU0ZDIyNjIxMzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+YY3GoxMYm7puOrtcGzkhzR28/EJPyeAljsuUnnjwvVc3QdyzyWw4\nBPsg5XNGWTnnSKOlyXsnTLAHyj2E0ddxo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdXdpp\n0OcDWAM4i/kWFFfxYHGSSDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAyk5hi4m4BL8J2ZivM5q/5USBw4keyRGibVu/4Cs/k+QC\nIBcmh7oU7yb60CiT4xwpBFF7lwbpGHjGrpDlBy4s6WOW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6160", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6160` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAY2OJiLxr4EdpQai+f2+b2hmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4MmE0YjAyLTRmNzYtNGVhZS05MjlkLWQxZTJhYmJiYmQyNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZhY2M1YzgtNDU4\nMS00MWQ1LTk1YzgtZWU2MGRhOTliY2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF/4dDZoF02XddioL3L+QnHCgdT3Xi2iDW7haShEE9Y6z1ujK7PpRsAYtrAF/\nSEGCgWcSid5MPagVZNish0Q3RaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAGlEKdDP7QFzF69Qd0y9Phm8RyMwHwYDVR0j\nBBgwFoAUyYfLN+r4eMBfGnUBJ+/ngvUwN1gwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCn/4u/JsjHbS1VC6YHVzuzCyuWHbf8v2gFMI/THDP7cwIg\nMduljx1qtQbdjMBQ8sMHzVq3aws2a2JzmKVldOkLB2w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcePR/g0rvz4v+rzbbHIw8q1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODJhNGIwMi00Zjc2LTRlYWUtOTI5ZC1kMWUyYWJiYmJkMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMux/lAd4A+r7n0nsfcEqqkQwpqT1VmtQnPk4Sarg5fPpZ\n8VQGGjXRADwKNC72BF4TmwBVza/HPEUZk+ahXszUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyYfLN+r4eMBfGnUBJ+/ngvUw\nN1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKLn9AODAXCKwFol9t56+8YE89Nx7/0tXZgE9jywpIR0CIQDbo9liXwKL\nD+EP4IfBEP/pVBp0vQ7gT0/C+fKAs97ilw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAV5AFwmd1nT7FC45ma87JduTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZhY2M1YzgtNDU4MS00MWQ1LTk1YzgtZWU2MGRhOTliY2UzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZGExNzFl\nZS00MjU1LTQ2ZTgtOGI2ZS1iMmJiNWU4ODM0NDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS+DuxZmAbnRsu1BcVPHe1uO9QYpngIB6CHRPU4iNKHop7neQuQe4g7\n8zWFuq93vAuAu/H+CLgITe3Yy8b1T9Bqo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAaUQp\n0M/tAXMXr1B3TL0+GbxHIzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA/BaYTFyL08NsWfucAiR8shyIaiFS0WVEz5rr1LpcK7UC\nIAvjQ9ya192qXAtyiNeQH4D90bcZ1VE7+32r1yZnruLT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6161", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6161` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISATRBVT+YKlc3uaCOm/qaFBaPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiOWI3MThmLWE1ODMtNDlmNi04YWYyLTQ2ODE2NTNlNjk4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhiMzBlNTMtYjQ4\nZi00YmE1LWJkOGYtYzg2ZjkwNmM3ZTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI0N7ka8u5FnjSd4yacNYy0MnuaVm2CZMwEDiQVn0Rfis4nZTtRRnaq5Z15G+\nWGqYn7LfTwj5KCKTH16dWDXECaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi8HuXt/f65ypwppVgPoH0HSmaJkwHwYDVR0j\nBBgwFoAU8cfC2Fl6ul30YqiPK0YO27OYR18wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICcgXcMJ0js6MXvQBCnoZIfEeQumELYs\ngWwWfPQJ3C8zAiBThjzZ693vTrYR2F1HNk4zQI8MlTT77qw0p2VmRIY8fA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATyGfGlr5hMH3t+xneBn1OKWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjliNzE4Zi1hNTgzLTQ5ZjYtOGFmMi00NjgxNjUzZTY5OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLlEhzPT9/Nl+7QllyNcfCPpRZwEI8ZW8zkLKXhYIiTxLc\nNaAuH1g2usZ3bb0YNQ62iEnzPXaDxL8Qtfn47zRWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8cfC2Fl6ul30YqiPK0YO27OY\nR18wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM15Tzwz4oOtbyvHgs7H7HVpiGsly15MePqwX3Q882wNAiAfLIZo8Rbh\niCo2heGg3KZS16+pcU6hb1UhXCSHfUQjxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAaheqow4st/4yYDt6ajenij9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhiMzBlNTMtYjQ4Zi00YmE1LWJkOGYtYzg2ZjkwNmM3ZTU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzOTRjNjQy\nYi05N2EyLTQ2YzctOGMwZS0xYjg0Y2U4NDM1YjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ55povziVlmcr31NK/QIAvH6GUK5x25mmnYbgBi1xtvD5mmz/29uV3\nK9il8t5v46yMOmaeOYcoyJqn/j5y3Hxio3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLwe5e\n39/rnKnCmlWA+gfQdKZomTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAsYkAzOEabXYsgAUeRqoDKtLYuL088trIaTzmgAHD67UC\nIQDIMbFH2hi8tO0ajq+Ossgknnyujs+wwFwvBV8ckEEMWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6162", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6162` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAXKB/fljeHUajHeEapMUL2JuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0NWFhNjJkLTJmNjItNGM2NC04ZTY0LWI5MGYwNWQ5YzkxZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTcxNmE1YWEtMTc4\nOC00NWE0LWI3YWYtZDIxMjg3ZDdhOTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN/E5SaDCJIPcjyyey83FJ3Q/1jAVua3Ngb8aOHNwOhusvOSGHjJ7okgaUidC\n+u0BhLmZDRHSUy2n0RVzuuYtP6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU77HrlFF7R9w8q2/GiL1bd+r6HEkwHwYDVR0j\nBBgwFoAUc+/IFm9AbvyB3ivdO7ukIhI0KNQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIHUCSY1C0LelMv5UppwQBTDPWRUmMVWS\ni/QsmdzpLSY9AiB5ci5mQ3+ikVD+6IL5/7Md4WbFAk/6kf3UIRlxbh5uFQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbSXj8NyxpqtTs6syMAsY5LbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDVhYTYyZC0yZjYyLTRjNjQtOGU2NC1iOTBmMDVkOWM5MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMsjVnHioMqRtLrxOjOSWJqF9souM+Fqkc2a6K5qv1cleU\nQQoesN5ACZtYbfomLPKrr4RAt9LnQn8n1T3TKsYto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc+/IFm9AbvyB3ivdO7ukIhI0\nKNQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL/cNVZr9HYpsdByoPJ6kIBmdENXlPxwUfY7uKQy9kulAiEAhZ7CYlQP\nPvD68H/yn0Aqn2qklFJJpRFuCJhMluYvsrQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdrC+ONFt3sPs4qDBSmL+r7IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTcxNmE1YWEtMTc4OC00NWE0LWI3YWYtZDIxMjg3ZDdhOTE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNGEwMTVk\nMi04NmFmLTQ4MTEtYjNhYi01MGVlY2IwYTJkOWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATCKnIXNJZzJ8Q7FkNV8Tb1xgL2zQD6TzYL8U8rLhmJhXt7Ozratdbh\nMZKneCBusHLbPk+Pk3Ph3siwSORAe+cuo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvseuU\nUXtH3Dyrb8aIvVt36vocSTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA23pqSJfGO1q8CS0sUEVRhnaAw1+WT+BkrA0KxFptEx4C\nIGClnD1ihoyjRUpgeZDCKI8OOvKXd+q6T8ErJlNUolFe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6163", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6163` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAV4lYvJ2D/KvtlAoGL4qYikvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4YTA3ZTY2LWFlMzUtNGE0Ny05N2Y2LTViMzAwZmIzZWQ1ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk4N2EwNTAtMWI4\nZC00ZDAxLWIxM2MtM2YzODJkMDBhM2MwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP6f3XXilSsRjpXSu9oWyx9yGKwpVNuGKr9m43aYiyqY7qbrTX2UDCPxiHwI3\nPAQIDwqLP2tuSeCi7c2l2q0cXaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPn4O7g/YoccC2D1dlecPd5rIPRwMB8GA1UdIwQY\nMBaAFGYw31dqxEDWNpcC1ssyfPzCkzqdMAoGCCqGSM49BAMCA0gAMEUCIQCdvQnr\nj6tBf3p5z/WSeXT6EBQXGH2kvnxfzwLqfeVnBgIgMu8/BldVJsGxRVz4hfsWA1n2\nj5XKaMd2kA7XO2ZBSoo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbl59nK//+nMuLsrgmh46RxMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGEwN2U2Ni1hZTM1LTRhNDctOTdmNi01YjMwMGZiM2VkNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4fT00jTTK9dXn662miM2hrZsOcxC1uK9Iep3ald45gbGC\nWZ0/S/ZCnX1S2dCyPTOwxy51Tgd0NOaHo12LGOsko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZjDfV2rEQNY2lwLWyzJ8/MKT\nOp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc0xz9lvlsi+lpmHsWzYXA98QFfbFHPULJwGQ70Fxy9oCIQD0+jkmq+0E\nRoCym+SQrSLmMREKOvQCdzSV0CMDvaiMhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUdgji4cSciTgD7+yKGcDhJhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk4N2EwNTAtMWI4ZC00ZDAxLWIxM2MtM2YzODJkMDBhM2MwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZTViYzli\nZS00ZGNhLTQzY2EtOGY3Ni0zYmU1OWMxZGFlZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASHgBuByyviFeIs9k1JnRwTIPuORzZZJ+BYcVWL0XzIuUPXhkTDg1p2\niiEl4lDmzZfbotDFxxQxMF7VkGLjAGjRo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT5+Du4\nP2KHHAtg9XZXnD3eayD0cDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAon5eca3asEvJ2jhdDZKJ5Uz1DcSeIW9yGHWS\n9dX9PbkCIHXUsrd8kb5DsCwcgwPqlSGvxb7GMOOAf4CUfKe+K8Zj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6164", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6164` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISARZhN7BfLrTw/J5JYdN/h/I2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1OTIzMDc1LTdiNTYtNDQwYy1iNGJiLTY1ODlhNzM1MzM1YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVkMTY4YzEtYmU5\nZS00NzE5LTg3NjUtYjQyYmM3M2FhZDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQTOos30SbcKRBZW+VeEQeMPEBIkdRWjXqFEF+tAE1+bJoN5P3g0bCDHsfW0E\nP6f1P1AIyA+1u4mckbSc5/6vkaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHRP4i7U+91Y9pPzBXx7yCuoEu+/MB8GA1UdIwQY\nMBaAFAf7doSFa+x9Y8PplPLhFIdSoFVXMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAkP+ZJSiO885vP1XzjUDeyZ9TapizwSLF\nu2UY3Pq1Vr8CIQCiL3+8XYaHPnPpLddaHxxdMSW5bNxQkxZyU1p03mxhnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYg/liT4HypUh6ndWV9Jd/s1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTkyMzA3NS03YjU2LTQ0MGMtYjRiYi02NTg5YTczNTMzNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0b39BbaTNvnP7cv5evW47OCa+gvRKKvPZgWSZF1Jd5B6A\noTEimyotLtBx5L0ZnuVJUckAFWFZcT4EqZxKeS9lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB/t2hIVr7H1jw+mU8uEUh1Kg\nVVcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIxDbmQQ/7s2B+dii2o5XJLIwa09f7KZkkuYXSqTOJ+QAiEAnmJrBW4k\n4JisbJng5fw5keWOwFl0txZ0Q+pxQKLFzj0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAT6B/jdrcut/7nXOScrKmejYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVkMTY4YzEtYmU5ZS00NzE5LTg3NjUtYjQyYmM3M2FhZDI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYjMyYmRh\nOS03ZTYwLTQ2ZmUtOWVhOS04MjUwN2IzYTdlMjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQMGY0lFehwzr99lZ6nzjg4WTi0J5Mj1tvlSzsvxRkoxSXtFAiywJ46\nmggeZbbmWX/c6du8BK1JWFrBxMBc+3pJo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0T+Iu\n1PvdWPaT8wV8e8grqBLvvzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAoi6k7npBU/6DqGsUd4+6VatOVSy7gggssppF\nC8Ue2FMCIB0hwc6b3564vyzJ5D9MZFn1dL3izNMxYDcvidYTHOIs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6165", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6165` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAb9YPd9YeRHiMR7ZB9gnnIg2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNmVhZWRjLWYxNDUtNDNmNy1iODU4LTBjMzU2Y2UwZmE2ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk3YjUyYWItZjAy\nNi00YzUxLWJlNzgtNGUyNjc1ZmM2ZmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVw1FGhTwPrfHzKaoB867rjjJLFM03his+wtIMN/m93yCLUHF/n7uuxtzQ8wO\n9tTLQetGWXDp6ys83rc69ybfR6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHwe4Dp2lexROC2J+jljPu2L2T/KMB8GA1UdIwQY\nMBaAFMy9fgJfiBRB9Sx4iuO4X9jd4924MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEApmmMEH9BQjQTnpxQ8IjAZGyqpxNtOqSX\nIK5QEK59o7sCIQDYlbj3s0DTCENmysOQ4yLgFbe5MhxSDoosnnUktjqVYg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQylEKYIA5mGAEjoII0bGQJZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjZlYWVkYy1mMTQ1LTQzZjctYjg1OC0wYzM1NmNlMGZhNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjdIjZ081L+pJ3Exjqm69m62A2uwz4U7/HBOCRoAAnjBTE\nf2FP5ZCD2z81jFC78vy+2/tFOfoaOJCwBUDntUHso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzL1+Al+IFEH1LHiK47hf2N3j\n3bgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIfRFxlc58BWj9o4w3Wxv4T5X+IJiIHW40JECLYhxz1mwIhAJCfkmU4FFaa\nZGVEYLqFatg2/izcBiklnXssrHJVEvRK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAa6uTO4W7rDa3vM4tJKkszFUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk3YjUyYWItZjAyNi00YzUxLWJlNzgtNGUyNjc1ZmM2ZmIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YzNhNGUw\nYy1lMzNmLTRiNzQtYWFiYS0yNDdiYmI0NjdlYWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATWCmilsLTHl9cNGN71NplbJbNzxpC6gJxIJdJsy711j+0LGFQ06jOl\n7PgquZXystvqGgp/4QxzEBBvTqLc+vbwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR8HuA6\ndpXsUTgtifo5Yz7ti9k/yjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiB/o1JHtoS/Av0sGrPaWQ/A30Xx/+laZ/oLxVjZ\nBj6SOwIhALu892K6y1lsXtvpBFpwjaffSV2krZM9/W0hrCZnfF4Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6166", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6166` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISARShDbUF6H8Pt1EqUvgB0qq2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwYWQ4M2I2LWU1ZjktNDc3Yi05MmFkLWExMmQ4MmVlNDk4MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUxOTZlZmUtY2Zj\nZS00MWE5LTkxNjUtZGIzNTc3ZWZmMDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvPXTkyMKBUFtMwZWrq+PLWRiTxHzNlUReTbeHC4XLM4aVSy4qE6eJh22BJvL\nIMTySxd0Aw+PBG+3EGNv4B+cRqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR+cs5Y+pjeQh5NgMFnpv2iMv1r1zAfBgNVHSME\nGDAWgBSMrOoRb+RQuP6KcK5ddPL/vy2vIDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC7wSKSqNb2xuRaeGmbkLxRKmkGZbba\nAKCsmsRf1wI40QIhAMHUBbj/PcuoobUEUWvU6q5iKsIoSzoDBoJwXGexxzJl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ9LzS+LA1R8iymdgaam+u+EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGFkODNiNi1lNWY5LTQ3N2ItOTJhZC1hMTJkODJlZTQ5ODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATznBMJSSZBG9sc87Iqk8fyg9XT3TTJXEhAWXsGA5raJY2a\n6nCx3mBkwvSrbVgVcMbqHX1AFZ9zR+l9CeZKQxrXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjKzqEW/kULj+inCuXXTy/78t\nryAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ92hnMfMFz5TuJUQak8lnT5RqHfJtXlBevD9QPopa0sCIQCRFhSpUCh+\njokO6OHxY+jJbU/bBlV/RuJFCtDs57PsVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaNV/k1rEQoSzNQj0zyGCYjKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUxOTZlZmUtY2ZjZS00MWE5LTkxNjUtZGIzNTc3ZWZmMDgxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMjlmYTI4\nMC00NjQzLTQyYmEtOTI4ZC1jMDViOTUxMjZhMGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATqiNXzxly1HS6EiM3boTWKiSBtEBmERMvynLMQXJPkW7RBWghWksrM\n84hmPTonN+AoEsZbg7z6VKDgQat1POGno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+cs5Y\n+pjeQh5NgMFnpv2iMv1r1zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA7Ovwoc6QXWuQY8Zyd02kYzAwmH3N+E20xVeU\nRBC0PAQCIBbFHMY6CiMcXf6z7/TBFxt6m1dgvSLrTaoyHEQrUb7p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6167", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6167` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAagRhR98pOEtBh4kKi/XKtDCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzNGYwYjgwLTE4ZGQtNGE4NS1hOTY5LTAzYjU1NjY2NDg1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI5NGM5YzUtY2Rl\nMy00NWU4LTllZTQtZjgzOWM2YWJlZWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjOXRY5ms4MSZ5Kp1t5762i/v+eRS8pepBstURTb6lGIw6rzvkHK+D0Mb6GeZ\n1bi8ZxM5kE/knQhZFYpqNV6dp6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqJsc7ZoF4debndquUXLY1tZ3jgwwHwYDVR0j\nBBgwFoAUjGGIYSlultrN7C6uc06LDuK6P/gwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAn/0E1OnDkeuK6\n8RMYQuTB6HyuXkzKrcABJOOzuXhfPQIhAIAihcDIWk9Kv52g6DN1gSCfg1lx6iXH\nyAQwgOiUnsh7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcUzwDpey9qresMYzM8GPg5jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzRmMGI4MC0xOGRkLTRhODUtYTk2OS0wM2I1NTY2NjQ4NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlDsWab2zZ2S5d+QdsGLBHr6Nye6g/Ft4OV2jW2zZCO4mA\na3Qqd2lHP2/09W5uuM1EAqNFlHzi+38ZQ1DdCnSvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjGGIYSlultrN7C6uc06LDuK6\nP/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPb27+qT+mviOtOhBgKVX52FFgxF6+olqoIUpagGEQCaAiEAm/Pn9oxS\nayCYzVqu+nUdvGVKWWcDbxPk6komvzEyan0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISATodPel6lPv2rV0jIhlYCc7ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI5NGM5YzUtY2RlMy00NWU4LTllZTQtZjgzOWM2YWJlZWFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZWFmZmI1\nYy1jNDM5LTQ2OTYtOWFiZS04YmZhNDMyOGI1ZmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASU/AHNmtx/8c8Y3r9Uwxxsl8qVuCYCIENBI3ZlqcQEi5UQC8kGFQIf\nk2rsotggXswGRtKUSJGkquhGomd7/3D5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSomxzt\nmgXh15ud2q5RctjW1neODDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA9qFAtmp1vNvJ9nRnjHbC1lTRpMJQtR0ey5oW\nzAq3rAYCIQDPEyI75fj3fcK56HrqNNOFmGhvlRnmLF8NAWCKG1cIHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6168", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6168` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfHAD8P88BmptontQLlLvrmsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3NjE3M2Q3LTQxZWEtNDc0Zi05Y2FiLTA5MDc5MzY2NjBiMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU4NDc2Y2UtMWVl\nNS00YmVjLThhYzgtNDcyY2Y3NWM1NTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa3lpc5y+/u4WjGNCnDVtSHopVTTOSHqbp+tKJgn988hucvz/PrGO+rV4UD5T\nfxeUw4UtFnmfXlLIKDLUW8HdnKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz7y1oZSKVf6x70ddu2XlYQgAL2kwHwYDVR0j\nBBgwFoAUhEOywSQW0WsXJOn+CdB6Rpl0xygwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAmYXdxjVZqIc8\n6kP0u5m/5abpzQxdDjI74vn2MeTRgqkCICi4FDUWYjrtGjlRkh5R1ZXwwSIFCPwJ\naZLwMwranJ/M\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZTG0fX5qAKItC+K3KNJyzs6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzYxNzNkNy00MWVhLTQ3NGYtOWNhYi0wOTA3OTM2NjYwYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTkssrVlKhxpMa5GWyct6/QwIGO9lhz4br3i3OWwMpmfh+\nD7GS+cJbT3lumYbfFHjGCsQhVYQRPILEgqQ6+xIFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhEOywSQW0WsXJOn+CdB6Rpl0\nxygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ5lnl0opMQNz8ZMzIsBFQeyYyKL3AtK7XmBTzjeBGhQCIQCptkrf/d1A\nzpUTQ6thsr7/kD/z7rcYRycpsRl1Vk/6lg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAURTp1rp0kMzcAgiCEz2xpnCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU4NDc2Y2UtMWVlNS00YmVjLThhYzgtNDcyY2Y3NWM1NTkwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0M2I4NGVj\nZi1mNzY1LTRhYTYtYjFmZS0xYzk4OWMyZjlmYjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASilX8Id1rGRphQ0Qg351wefOM/zf76kojD+6rXsbHNcHbwiMePI3Vo\nbCvP0ZXfHedDbNef35Avh9XILCbg0kAlo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTPvLWh\nlIpV/rHvR127ZeVhCAAvaTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAr0O+5bs6+rnMEekbvuDfhEDWNm1PNJmbAyzF\n/CoOIcYCIG3qE3Wv7xaMpvXF2A/1pScqF177oUftuumHOBZyIZjr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6169", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6169` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAWkLDdd2i0Nk/IUkMoB8/SF5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNjk5MjlkLTIwODYtNDZjMy1hNjYwLWMxYWVhYzE4YTk4NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjYzYzUxMzUtY2Mw\nNC00ZWJjLTlkNDctYjIxYzQ2YTY5MmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdZPMXXFyMnbVV7/KG4b1D67Y44gBhWrvvzEPdBqFcPCaSWmxTeUI1GjSQmrE\nwaK9ZcijqA3Ps5Ltq9JCvP8V16OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4OWkMCJSlUN+eFtCNF4+oRIjkfowHwYDVR0j\nBBgwFoAUi6dq6x4w50yh0TRNoLAnXCDOqqgwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAkciTbS5LnjGYIEQnTLism\nrFGR2J2hVqJj3Llmmp+eTAIgFszOUJ5aTsjqhxJjT69TiP62cM4ohwc8HZaAgwbi\n/8c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARHNMvlMYx/QTAko3/to2c30MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTY5OTI5ZC0yMDg2LTQ2YzMtYTY2MC1jMWFlYWMxOGE5ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfLFIhj/L05Xk1cuifjJEhpuQwpZBxD2W7XeBc8MMnTNkR\nx0csqpiQ+zxBYLDY586FC1yB6xUJJ1EaxvC4/pxqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi6dq6x4w50yh0TRNoLAnXCDO\nqqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP9MyjcyVBxEtRXW0NPv1bxwSDoACV/t4DJXjZmMsUiIAiEAvG1t2cUb\n3hpmkB1A5z6wQN+JERtm7FMwVKBdKPSKSH0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAXWAEW2CpB4wqNaKCGZMAI9tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjYzYzUxMzUtY2MwNC00ZWJjLTlkNDctYjIxYzQ2YTY5MmM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNGM4MDVk\nMC0wMWQ2LTRjZDctOGU0OS1mZDg0NzYwNjgyMWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARHm8mlHDv4YJ9HyQ8wCzyX9YgLJ0ZTjmlEsIf9PQmmeJFYS9etFXxS\ngO0YZXqoNQu2AShodsi5VqPeeL2zw9g7o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTg5aQw\nIlKVQ354W0I0Xj6hEiOR+jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAnMHjJCd6jTxN9sxAQdDvUYDVoBttnxhLipwc\n9IYYlL8CIB66ILK1TvSS5aLlMPnfm9j8d3Koy0IpMlQ91VsDiev+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6170", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6170` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAVpC/WlqlCXD3BmK4BrV5lJ9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhOTBmMzg0LWE2YWUtNGI4NC05MjhhLTM2ZTFmYjZkZTg4NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNhNzk1ODMtNTRm\nZC00Yzc4LWJmMmItNGM1Mjg3NDdjY2I2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEunmmIEXxkpnd8s70rCfWZLJbewfBv0nsFUc3uKWeRbgpJZdBSrpOWFg8W1k7\nQ/nvbGFCLYI6JOJxMtJXUY9VgqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU60m5Z6wzA5+zSUpV22g2ULwdSBswHwYDVR0j\nBBgwFoAUH050e+eltPlff/ugj+3Cb0LSpIwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBD9A4k\ncwoyB6i6e2Sm5JcH8Q67j5U1rzuJNQsWF2YiaQIgDxio6c0UGkWrUbmJ0cJt9XH6\neiKpPuwT3fCgXALrsOc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcep0ivXF3jyj0GxW/VGnH1OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTkwZjM4NC1hNmFlLTRiODQtOTI4YS0zNmUxZmI2ZGU4ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARz5ce0J6c3cD5isydx8l8KmYa3iSOxLgIAEwNitbqjdXAq\ntMNubv/6lGRtpPavte+kmGEeIhdGFduCz/A2aisOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH050e+eltPlff/ugj+3Cb0LS\npIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWh/ncEak9HJYr0lUaQp8s1/lkqMQIJXqb23GVCggk6YCIQC79u6KEYOW\nBfMC9Vxo18bwbXuJC6I66EEtS26+8Gwjcw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATEzWpzLNMDflIMyyC3IlFhJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNhNzk1ODMtNTRmZC00Yzc4LWJmMmItNGM1Mjg3NDdjY2I2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNmUwNzc3\nYS0xYmE1LTRhNzgtYTc1OS0wODE2OWYxZTc0Y2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATyuaqVYXx+19RndJYGKwsaUQ2wCl6D2t30HNvtajQVrmwmVfobWAbz\nSbQYthFPDPWlEh0mP9717UJOfdI/KmEKo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTrSbln\nrDMDn7NJSlXbaDZQvB1IGzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAQrcw298sWGmQbwUsc4tafGOTv/YuhUNhahQx7\npDk6KgIhAKgrChBwhj00r2Ep260MNl11pXHFWfAsdiQWEr9m42zG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6171", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6171` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAcsLO4kTLivkqlXUNtS2qFSPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0YzI5MDRlLThiNTItNDNhYS1hOTMyLThiMWY3ZTQxMzRkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA1MTk1NzYtYzQz\nYy00YmM5LWJiMDQtY2M3MDU5YjA1Y2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu8i3+VgYfEKHjv4OFrlTS1p42Jk6HQB4bewaKTj/X0B7xCtlIhNFwcEMos78\nigxMVxRx0QvPcajot0rEsTF/DKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/5XKGzCGRjFi9VOiGOe2Of/owJEwHwYDVR0j\nBBgwFoAUOXkLVBjVYG18D4C7Mp731J7vc/4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA6PzQ\nIyD8pcYJ8ZkKyWKH5NotrFBy70h8OTYMofImw+ICIQDBaWs6qdJmJBJULgvLNpAK\nZZfj3gVWXcDBaAA+f5rYRA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdbGzSlV6SMlAFrxfJyewMLLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGMyOTA0ZS04YjUyLTQzYWEtYTkzMi04YjFmN2U0MTM0ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1VUGQrVAS869fZ3+qx+aAMC2KH0XUzSEfrpmFm2dXw+/N\nW4WSMKzwgH5MYgAwTc2R/QNhnCQEoTootBGOpi/Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOXkLVBjVYG18D4C7Mp731J7v\nc/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAORKxbEzI7+kCzloeR22eBcYHwQXRViWxxDkDoed0BgVAiEAimJqXzT2\neV760DLtm+WtE5MNVp9/z3rdN8Fiaa0cnkk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbLEuvYoTzy1kZXEiL83VC1sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA1MTk1NzYtYzQzYy00YmM5LWJiMDQtY2M3MDU5YjA1Y2ZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiOTg2MzQ4\nNS1hNzcwLTQ2NWYtYjlhMC1kMTljMDk1OWEwMTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ3/Tq3S3NxJaD6gmDajdWXkD9awRn6xzChdImJz3UDu4xyhA8S8s4n\naL0fC0NxzPG971bY28yt4tx5AcKrWa38o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT/lcob\nMIZGMWL1U6IY57Y5/+jAkTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBMdztm8dpnBGs2GrAChxEZW6Wtx8FlfvRDuK2G\nrx/7FwIgaEOpX9tYi0IMwA9qEnArHM3tjKBf5MUqHb3trXaktJg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6172", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6172` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAThwPqX5IeDT5+avUN/qwvkpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNzc2YjBmLTY1MzgtNDg1ZC04ZmI5LTJhMmUyMmY1ZWVkZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE4ZjdiOGMtN2E3\nZi00MzI4LTljMDUtZWM0YWQ3YmY4MGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAD3Tsxq2aST7oCfVvogss3rxRzRcxjC47sggVhLmKpypxu0ib2PaWM2+/igp\n/1piowLoQuxLoE/6yeeTBRhShaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJ5uMSnM+mCkM1bvOdRQBMkr7AESMB8GA1UdIwQY\nMBaAFIQYb4ERqGzROiTV32dkRJm68zTlMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvlM13ySb0VHW2BnYz73yrVdJUPzZIO3E\n38597eqqmGUCIQD140A5/dAa6YVrbe/xqQ3Z0IPNkMpY9J3T7dJGmFAlmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeqv8b6TkJM8kO7kSFxHjFj7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTc3NmIwZi02NTM4LTQ4NWQtOGZiOS0yYTJlMjJmNWVlZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsc3tORNybCpQRUpxqSnXSXxAMH/aXcN5Uhmxr5kE77KxH\noJu5TyhtpPR+RrF/gDdRqnJBl9gFstww2Tl8ypd7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhBhvgRGobNE6JNXfZ2REmbrz\nNOUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJo4rt92XOcuMVBTCXNqsNN/fFB/qCuosYBxqGvxOgksAiBbCUjhhO5E\nAGTCnzgvsbJz4AP24+KzfkZjQuYBxg0H2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAS5dS1/Q6izgHjwSgdf9Drj+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE4ZjdiOGMtN2E3Zi00MzI4LTljMDUtZWM0YWQ3YmY4MGFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNGZjOGMy\nYy0zMjY3LTRmMGUtYWEwMS0yNTU4ZDNkYTI0YTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATpApMKZ+Y4tdvkiBj1PLzKhHICceS2R5VGClNxXH9PJT1esGZ8uwOx\nw2AFyyVnh5p6AweY9gOBYZZ95xQhMG4Ho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSebjEp\nzPpgpDNW7znUUATJK+wBEjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAhvkvmfnZu4nt8B3HrhLE2WP8yd7py6kg9tW7\nB8qT/dYCIQDUAmFcmdZu6WfhQDlDTsMFZ4w81KvhDo+QeprN+ybfWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6173", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6173` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAamwgAjj4Ngiyc1if7TiNp5/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2YzY0NGVhLTQxODQtNDIwOC1iNjBhLTc0YTA0Njg4OWIzYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEwODg2ZWUtZGZk\nMS00MTNkLTkyMTMtNzYwNjc1ZGRmYWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+zicq/a8C0IlFey4ZX45XV11JaZBr49M1oscBPxZkPBQTHPmD7ozBDRTH1cE\nLj3GBzlQfH65agsQ7Fo4icEMs6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKt6Fj75aYFB/q7f7CYtQmNPx7L0wHwYDVR0j\nBBgwFoAUneKW83smtir23vV+sg/f1yTtoaAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIQ2HhmkDjTU\nFK8y4N7OQdzPT8zntCK3St3iFvyB5pomAiEAn7O+tJ3waWBCBBjBUJIKChPp8Z3a\nw0AqwDDrdiQwnMU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARDyECJi8/0NowGr9vQd4jxFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmM2NDRlYS00MTg0LTQyMDgtYjYwYS03NGEwNDY4ODliM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBSVL3zSsXDBI/1uN+3j0vVXbFIYJ4c5RnbQ9S0RvKVFvn\nwJE5Nfs75qk0NWUX7xU5FA+KtuJ4N5PV/VFNLMq3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUneKW83smtir23vV+sg/f1yTt\noaAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKt0nh8hQW4b4HnbUH3iCVNNbc02lRnM7Rf528N7l4Z0AiBUuLTmdRc4\nVAlBMysq13ePTBFyG60CkeOdnAxazv9F0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATdgGFq/G/zccZyL8cdJK5ERMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEwODg2ZWUtZGZkMS00MTNkLTkyMTMtNzYwNjc1ZGRmYWNjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYjUxMjA5\nMS1hMjg5LTQyN2EtOGY1ZC05MjRlYmMyZGFiMjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT63wgjHc50rcekad+97J2C2tRRStSPuJVGbBksq3KvOzKHWL1DFfv/\nZD9+t6vnlBv27WEKgYlc62fBBvpKe1Uxo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQq3oWP\nvlpgUH+rt/sJi1CY0/HsvTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAepLZ7SBHsFAA3oLj6O37U/gS1ptHziSeTMaf5\nGwwP6QIgL/ZOy0wQSahAtdu+jz/gfbeYA1/qd1NZJypErrBdIaw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6174", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6174` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAWpTqWs3vTvzWgVNF2Xmv0VKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlOGYxOWFiLTE5MTQtNGFiYi1hOWE5LWIwN2QzY2Y3YzQ1ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNjYmYyNDUtMzM4\nMy00MjhhLWI2MWEtYzMyZTc0OWQ5NTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsM/R2UYOMN2NYDOVK0LxlW03jWIZYLRioMYfMXFn9zu8+dM5/3DNXfe7zOSU\nw/cCGPmfqUeDubH9XgvuCCUtcqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo5Qywr2xSrfxK05vvebfugZcFHcwHwYDVR0j\nBBgwFoAUnY+LXE7b8FYtR8jaqOzF/cg6jAkwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIwFjye+bGvo\nLJ+Tfe4uk/mQAK4JSR/FCQ+9CDrtJliFAiEA7+L8c4na+vqGxEzNzeK2vm7823rB\nFszZDHVDXvcgYU8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWm0JvGqx2uaClxzgJxIhhKiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZThmMTlhYi0xOTE0LTRhYmItYTlhOS1iMDdkM2NmN2M0NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVTpjdBQSJZWV9plBCrf3gGCl0o0IQrOoqAMpRNzwydI15\nfExPdx/d/m1CuMWG1U+92YBBY8fJYPYpPdjmJMWjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnY+LXE7b8FYtR8jaqOzF/cg6\njAkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfF4PvbkA2TfJVq0JV3sqfQQ7W4EOEMcWLPeD3TxniRkCIERq+vePGQhK\n8dSlVqmB9zu/qe6DxPrKOkRT62rJFPdJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdJJRYKLGjYyYTv4ZV4MZHyJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNjYmYyNDUtMzM4My00MjhhLWI2MWEtYzMyZTc0OWQ5NTkzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNGJjODI5\nZS02MGMzLTRhMmMtODI4Ny01ZmM3MDIzMTY2Y2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATiM6bJrmS0BEmNhCEwmfzcQcaOq8GjHuNeym0bpN0pffiKq6tTvF3G\nxLofZO62SCoPxmEimFAbApWds/wLn/Quo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSjlDLC\nvbFKt/ErTm+95t+6BlwUdzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAVsxodn5OkqrjOMyUs+1U1VkUHwi10uGAzPV5W\n1JsLjQIhALpmYT5Mk8vBOsF2ABi63JuoXf2gPSfJomNo57eJ6XNf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6175", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6175` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcS77u4sykeDr7OXp08tGokxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MDcyMjBlLTNiYjctNDc3NC1iODc5LTllNWZiNDQyYjE5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRhODdjZmYtZjZj\nYi00NWJkLTg2ZGEtZDdkYjJiOWUzZDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqON9qAy1N41fLV5uR//LXLNJv58qf3wkO4c/xVdhQG8PC5o07LEPSbSKv6x/\nrUSp8sG1b1Sf0B9oqP50aZOFcaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcEaJ+xWcLhfWKFjCRvJ4IKUoPxUwHwYDVR0j\nBBgwFoAUwVZ4HNHKDhFU90QFaBGfYPIaoZswKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD3dpxtneGX\nhHeTWJL8mCCVjXw/H+H9jFuBs1FCrHEF4QIhAM8WwTQ55bzz3OtKjiMNYbi9XlHS\nLPts6EpOAd8qHxch\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfoxhp5xi/FEwp+evsIodZe4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDA3MjIwZS0zYmI3LTQ3NzQtYjg3OS05ZTVmYjQ0MmIxOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrw5bqBd0DJPzPg2dZTXncUwIwtzw8xMGsbqIA1dtVtnoS\n1xAorSnPYe69RH2t1+LIE/NBGPJq3M1way1XpH7qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwVZ4HNHKDhFU90QFaBGfYPIa\noZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJJiTLCS67RpYiyurHcPYIgk1Gqb4IL8dG/BKrU02rLDAiEAuWNu2Czx\nHQXvkszW5WBbXpUhiEpOY+GQBefZMBKg+0s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUYWU5esfbJ487BBSPWU7vKqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRhODdjZmYtZjZjYi00NWJkLTg2ZGEtZDdkYjJiOWUzZDhlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMWQyMThm\nNi1lY2E1LTQ5NjEtOGIzOC00OWQ3OTYwOWU1OWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASVjhgSP6VxqEAFjsJ4ByfusPsXd8ex+tPbEBaKDkraauR63XojhvwA\nFa+6MtpoCupuYmllgA+g0AHJoVxC99ILo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwRon7\nFZwuF9YoWMJG8nggpSg/FTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAs2XhYZQ/RhAqUzT/d8vze1/y7S7IffXzRgXZ\nzpsuAGUCIHmKpqY3CC6Nn1qjlVRqeqCpLq3X2y8S7j7C8b38XVqo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6176", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6176` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASzkJ2JAZHeNKM1sW2OgSo4OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzZTQ3NzQ4LThhNGQtNDhkZS1iODJhLTVmODg4ZWI5OGQ3MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA1ODRhNjQtYTY1\nNy00OTc0LWEwMTItOTIwNGY1NTA0YjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1+ehN61P/fXOyn+pLYa5Jx9xURLxdt+eWTofjvM1X+uB9xkc3ZgEvok0Zq2h\nZPn29iGF0rq732CRxUVthrKATqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDe91/+voVgXZPnfJQp84l+bxzJUwHwYDVR0j\nBBgwFoAUj3w486rqmEQAGkfk+YoDooam+zowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHJh6Divr8k/qn28uAbeUjI2bVeHGVMukfSpui1CggpRAiA0D1I+PeY1F6GD\nnPSDSg50c5nyKJE/XGHSCkG2Jg77KA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT6riJoLq3ts+F3CBQ7pAqCRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2U0Nzc0OC04YTRkLTQ4ZGUtYjgyYS01Zjg4OGViOThkNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmcDYnVG1d19VHMKfAbFgONUfHPZ/gQ41bgWKdV++S5PGS\nES6t/QHoAO0Ok+zPfdCaaU+ICmyCl5AbrHisHPspo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj3w486rqmEQAGkfk+YoDooam\n+zowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFhQzEAXWqAFXZEz6WA+NMDUZ3/5YArmU0jlGSwc2lwICICzjKbBK13qr\n+zcH69olHfhsvuELLzy9AtjVAQw048LE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAY/XXYFqELm/LTPNwPnR/zVqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA1ODRhNjQtYTY1Ny00OTc0LWEwMTItOTIwNGY1NTA0YjkxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYzY1Njkw\nOS1iYjA4LTRkMDktOTk2MC02MDAyMDQzZDk2NjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ0Pp+InnjABnsIZ4cj5LhqxonZyQwhUezsWRSC5r9W3/gNsSQ35iUF\ndBiq/SJhHV9pEQbGTn6H9IGqMpVUXIgOo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQN73X/\n6+hWBdk+d8lCnziX5vHMlTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAdzr4BJ06P5GfxxVFcuem5a6pwRwq/UvCKS0OH\npt/PAwIgdY0Yp+XnSPe1oCrIkDp1L4rh5xO9eVrkGJUwWaGcoeQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6177", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6177` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQFTS1ooYz9Pj9rzDNfG05XLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0Njc3ZTJmLWY3MmMtNDU3NC1iN2E5LWI4MWE4NWMyNjBmYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgzZDU3MWMtOTM5\nNC00YzUyLWE3Y2MtMTJiMTgxN2M0OWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErfA4SZql4l5igFzwL+Jrwkt7dudFV6D1H8JJ2UxnbIo/YE81C/RSyh+s5pCq\nN4v982DeVH+tmUrHwjG9poLP/qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk7zzchKMBM2NpgR4nI3lE0A9hIgwHwYDVR0j\nBBgwFoAUpR/mFPJORcqy3r++8acVJQX2NyswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDL2udq+xnzA+l60kq3718Ky2ALaYG+KoQdPpznolOEbwIgMXHPQCqCHtMq\n1FLq0U9H8zEIY1aUP9n2W3fy5NrRAXE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATspUJX9OzEEsdRukjkJnReXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDY3N2UyZi1mNzJjLTQ1NzQtYjdhOS1iODFhODVjMjYwZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9QASsl2tXkolAJcb0A/LkpMW3FQabUxHcJjKKlsN1W3bw\nGE3IeN5on+HKd8iAqaO2SrR/F0IzWt3nhwoH9shto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpR/mFPJORcqy3r++8acVJQX2\nNyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJXz3d1SXywIDKeURpuIYzlaSp2tNGj0I9/BwX6BwAdNAiA9z+ZoURfS\nkTk8c5WXsZtz5TNDK+aJtGaDnR1sqhmeAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWVM0RSiVFdf4UzmAxcQgTelMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgzZDU3MWMtOTM5NC00YzUyLWE3Y2MtMTJiMTgxN2M0OWUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMzUxZDVj\nOC03YWI1LTQzYjQtODI2OS0zYjYwMzA0MWE0ZjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAROofNE21Muv21JLoWtTXNCeTQ6YGDfLuqDgeG3hZkF2EL7Wg3mLJTW\njEcXi8+vdBfGwnCM3LlJBSbD6+I5rLz9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSTvPNy\nEowEzY2mBHicjeUTQD2EiDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAy1Y9ApznHOBE+6n/h1j4oOoq+2KcXp5LrjRjr\nqxCXtgIhAPDAS8fNLgTdFPKgltJne1xD2uVYcFmYCsuoZDxHFghg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6178", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6178` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAfdSrIuPMcpr7y/je89xbGdQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyYjljMGU2LWUzMTAtNDJiNy1iYmUxLTlhZTI5YTE5ODdhMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRmMDQ1ZmUtOTk4\nMC00YTIxLWE0MjktNWNhMTU5MzM1OGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHXbFEdbGnc6yNB2l1bybmoRZxUKGzlxu5Acley+aGFCVDwEEmoPjzAnFFwQG\ndiv8LuaUqoSP81y7vwemdaMRuaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM5qJdyOIZMtRoxW2k+zX1f7bKlowHwYDVR0j\nBBgwFoAUdhIJte71zaZOTE+sS9on3FS7uokwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDC\njIdMdvB1xRNcM+9vMWGze4KuYIf3jrBwqZUux7OJCAIgK5pqcsWUIGQXWIYYiux7\nRoT3UgDihzLvCH9RcaxdMpg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUA7XhnjCB0IiztrgtHK2TOhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmI5YzBlNi1lMzEwLTQyYjctYmJlMS05YWUyOWExOTg3YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFVc9xrzlWEzQt/xD+O1MLkWIE0AO5zk/1+ytkTLTqmb6D\nmo2fB2pkP4khcSlxQv4w7PRNWL0VrbzDvoaHpkiEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdhIJte71zaZOTE+sS9on3FS7\nuokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAODqvLnNKjFPXACGQhV0AvQUY0uMTuuJBIG1gMRzVYvrAiBwto4evS3a\nqxftjfgR0KP9ILOkmlQzQ+mtY6/Vm8GYcg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAb3pwO0mjQZW3lSZLc5CmvGDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRmMDQ1ZmUtOTk4MC00YTIxLWE0MjktNWNhMTU5MzM1OGQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMDc1MGNm\nOS1jMzhhLTQ0MGItYmFkNy05NzRlODhlZDY5NTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR+92qI3ko+7SnI6UcCGoK72i30qgsapZJKR8VSf6qtifpKTAnjnJ/j\nHeUQ0H7lXAxUERM4m9wNKqPYqlCAbTXZo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzmol3\nI4hky1GjFbaT7NfV/tsqWjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA2gyIynlLb9ie/BY9gbAD8JPqQuNVQVJ5HCjJ\nf6hRCjICIB8bmGhdiMJSu88Uf8bm1V9K68pWvWL0QpMx9DfUWWC0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6179", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6179` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISARlPlOJ/cXDUKD/PWxIHPjgJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyNGUwMmU5LTFhNTMtNGNhZC1hOGZiLTNiZDRlOWRlNGZiODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZjNTgyMTQtYjdl\nNS00NzU4LWE1OWItY2VhMzc3MWIzY2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+lvz+uI8FAIx+mBtQx0Aq6hOBTSCzmicdrNrfnw3o0eHPU7wWrTQOvSG3aVi\nEaY0PVqPxtrqVs29C/1g1W0FnKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUla8Bbiv3JmAMV8fcedgXEPOivukwHwYDVR0j\nBBgwFoAUWvWMpZMmHzZNrMom2dPk8pCIdqYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICuJemQEMjWimjZbuyW6g/U4TYS8jlOuWaDuThTooNixAiAIkQee\nck5kQgZkZKc16S25qetNmqsLmZla5dSfw+Z47g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASyRrmQ+q8ac+GaGqyfUuDe1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjRlMDJlOS0xYTUzLTRjYWQtYThmYi0zYmQ0ZTlkZTRmYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvHVlRrKt3+k1p+7pRv31zyy5pVMTlyrXLgdL37oYoVYmO\npISU+9gPwe2Ny3uNiiMeMTjBpWhb42Y40IjGFysEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWvWMpZMmHzZNrMom2dPk8pCI\ndqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK/tWvwLSmpMvD2ik3PlRA4o14th1BErMzP8GdcleZndAiBMXRkf6i40\noIU/99GSSWpre/E/J+0iN+NU2WidAbECPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaT5963jnDS+n9FlKbU38OVfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZjNTgyMTQtYjdlNS00NzU4LWE1OWItY2VhMzc3MWIzY2VkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlOWQyYThi\nNS1lZWZlLTQzNzUtOWY0Yy03ODNmODJlNGZmZGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATQyvQyN4mI8gMLd9ejEID7kerPe/IQBROku4Vix5rdkH3ULQLwV5x0\nJG9G4va1bfL6q7X8DpNIykfmZvUeUj2Vo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVrwFu\nK/cmYAxXx9x52BcQ86K+6TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBmJ371pWKeKk7L+9oIIXUUT593WQKBZ6o0ilWZ\nrXmzgwIhAN0ho5W5qRcy/i8wrb6IKNKESaVn4r3FPlNdUGsfJdAE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6180", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6180` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAeI/OgY9odj7/dJObIHu2TaSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiNGYwN2IwLWI0YTktNGZiMy04OThjLWM3MmZjYWQ3ZDk4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgxOGEzZGItZDM0\nZC00OTdmLTlmZGEtNTk1N2IzMTg1NzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqx0Nge52GqBB5vdml+88qEkwBWdz7zzphsX6O6aaZL13XAX6ia0HWSEQojxc\nDCLeBX+VryMkUXL1DY+o0mvQPqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1aIXRghT66miXIlINGrDzqgFE9YwHwYDVR0j\nBBgwFoAUuvwX4te4uQPs1HGKNcoi/V/788UwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICTIw5nEQvByttOlpazhLvgXqRqoKPVkvmLg7LlCcBo8AiBs7m+/\n5RZP1AVAx70s+Guilb/cXT6uI/HHPjDF1Lg8dg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZGyM4FOvhRXj7QUWlAWMYhIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjRmMDdiMC1iNGE5LTRmYjMtODk4Yy1jNzJmY2FkN2Q5OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfUGNfKS936UDllEKnEkyaISg7rqOlHVdX1iCUfBD0Mc7i\nvjXSR0i2du6GUinMGGHvDEkfab4VshKiOqgRpRmho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuvwX4te4uQPs1HGKNcoi/V/7\n88UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJZ6RXuNVtf3+rW+XgvWaqSn7UL5FqMX1krt78i6lFFzAiBdczmnGckl\nGJLo6v0DjBwLmY/504XyU+u2NfRQIWwVWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAYShTzqX87eridfrXCV92va1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgxOGEzZGItZDM0ZC00OTdmLTlmZGEtNTk1N2IzMTg1NzI5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4OGEwMGY3\nOS00NWUxLTRlMjAtODU5NC1lZDkzOWUxZjIyZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATGnDSONJEEIujF8bf6Qdz2NRbQmellBN0FrrEIJhWs2m3xKviTp7zl\n4+9TZiEuezjeNVV9rW9x4DQeNG4ToYHNo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVohdG\nCFPrqaJciUg0asPOqAUT1jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA8Yk9RnpQUtywjOyFA4wiV3kpD2xLPBqoqZv2\nO2V8aNkCIQDIsgWcEP94Okj2aMwiN6sbfQB2oDRE1YHLpNK+BDerHw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6181", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6181` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAWOP1uKzSt6CgHvb70o2PJ+yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNTg0OTk3LTYxMDMtNDZhNC05NzYzLWNhMGUzZWJmNDJkNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIxNmI4ZWEtMzM3\nNy00ODNmLThhY2MtMTRiZjBjODI2OTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ4lX444hYaZ+DcPaVpr/0WxLhGKV8FXz7C7xJ2rou8vzNJQ/PKjVubP3JSjg\n3IKkxJxXJwTlnfUJY4Qo+pSiZqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGXDMVRO32tgmuVVuPKLnjuQI+v7MB8GA1UdIwQY\nMBaAFHj95Eql/VgnJ4pdCgupZpU+Rr1ZMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBhhraw3pU5PkuD06hSRxMDI79c2yG6m8jo\neH+DC/2uTwIgf4LIvWFwR2sUeTF6Z2VpcNyGzjtpt+xmR+rRh2kgF8I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbQaNFbGLhAuVBXie/rryzR3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTU4NDk5Ny02MTAzLTQ2YTQtOTc2My1jYTBlM2ViZjQyZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLxPYyO6GRB1oJ8dKHq5TtVzquFs0HIjRausRUm+TFkQ8x\nSrr1grYU/oAYoHY5ruhx/Ooi+GKeMGk2FnOnNt+0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeP3kSqX9WCcnil0KC6lmlT5G\nvVkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR8NLaQVRNYQqZysfmGEedcHSNcS1MKqdiHO2y3E77JYCID/jtr9Uhj31\n9DtoKywO5kMBzseOIXsf9Obi/DO6qNKr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAV3jrb0uk+hizq8V55werFwwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIxNmI4ZWEtMzM3Ny00ODNmLThhY2MtMTRiZjBjODI2OTYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYjI1MTkw\nMC02ZmYzLTQ0MjUtYjc3Ny05NjZhYTlkODRhMzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS1Q17cOMdDG1wm1o2mVy9euazf5rT6Tg8cpIiRtCJXtknZn3c1NyPg\ni/ili1TCgLw1i1YJx+Xv2vcco930tVh9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRlwzFU\nTt9rYJrlVbjyi547kCPr+zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAztPH3QRn3ctzNofvPcGnoQY9pFUIhaXPpdtH\n9mhgxRwCIQDFe7JN1muI3AZ5FuJ+kfI9W8i0NHSd/XrfoPDdrxhLqg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6182", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6182` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAfWWenQko+ZZsCPQAmRKIJNZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZDlmNTBkLTk2YzgtNDZmOC1iZWIxLTA3ODIzMmQzZTIzYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRlMzJiYzctMDk1\nYS00OWMyLWJjMDMtYzY2ODFlOWVkYzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzq94xlm97tkbBVCYVt77EFRM+KZTLyQRWBDWTGKG1+K13Nf4ZhWPq77M9J/4\nLHjCzEKq8ReGWQ6VydPWlIgQg6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm3QvbcELGK7rV0rDFN+age4BwGIwHwYDVR0j\nBBgwFoAUDBZ2MrqnxY61HjAtk9NgjqRnEH8wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgX9kOuLoqz5dk\nPu0a1P5zk9koIaKowHUPfodLoGoE4/gCIG+l9pxizmdFSYX2sa8iBXMqmt6UZItd\n9y4g3pcLcqqq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARRFtvhM4DCD4bQ5oStvhahgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmQ5ZjUwZC05NmM4LTQ2ZjgtYmViMS0wNzgyMzJkM2UyM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASl0YJbsl56Kx6QUVUjVe4EDCxtYxkA1hISLyMoG2Vb+Qla\nZu1TQXWSB7YwIPPdrHMHJbvLUz2y/NUhE12RfuERo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDBZ2MrqnxY61HjAtk9NgjqRn\nEH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc4yzm1fJCams3dVJDBJIrdIeKnTX4dcVC/5LRY3u7wsCIAjlk2M4pJvT\nHWqNrUMno3owAE7oUtB311e31WPqKVMg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAa5LHrTo9acz1TJrHAM4P4VEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRlMzJiYzctMDk1YS00OWMyLWJjMDMtYzY2ODFlOWVkYzdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlN2RhMTkx\nYy1iZmYxLTRhNWQtODRhOC01MmI5MjA1Y2IxN2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQfYhJgKk/iCLVr8ozTSXogkRQXV06eB0FfYzhzMTm7VRXV28gr+Zto\n4wZqLerrfilHwd0ObnF/qoK4VkCI8af1o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSbdC9t\nwQsYrutXSsMU35qB7gHAYjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA3XFaM6GecTWppDjKUS2W6AWvvimJ3JG9yAKP\nA5NqagICIQC0pRW5Lp1bewAFCztDQfDAj+olgHf3Z4MXtBrgU7cczQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6183", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6183` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAV/NaL3+2bTPjjBwcPk58AtPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMTAxNTgwLWM0MzAtNDZkYS04OWZkLTFiOGUwYTkzNDhmMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ2NmJiZTEtYTZm\nNi00NDIzLWIwZGMtZGM5ZjY5YTExZTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3duqQH49xTh+6W7SjsBrI3A9RW0xMoMWO6OijUVPRfqqn1NDmNzWByas/JzJ\nzP1kTeKeCY2Fg6zDJvPnLeUokaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEM5pJfLwMtJJsxwdA1cyOGKIKG4wHwYDVR0j\nBBgwFoAUp0Eqq+B0HLgHcjWzysLS/RCSOocwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgF14zQhBJURQl\ndSnb55ytTgb4wucPOUABF6oa7sNoryECIHNHfHuyJEv9KdYhVbAV0efSJq1Dr4kG\nzDi2nzqWXZIH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY4UZMs/lXo3c3bdyEAfgflNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTEwMTU4MC1jNDMwLTQ2ZGEtODlmZC0xYjhlMGE5MzQ4ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm43fj7JV5xuO2fpYlbqEs46msY7CfRRMH38XTiD+rfKAV\n0Olqfa1jYw9Xa3Sg9BNqiRqFyXF9A96QoVTps5BCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp0Eqq+B0HLgHcjWzysLS/RCS\nOocwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdbLFPZl3RKuf9QR3g1rvypBO0GSOS+ZRI2ERHD2eJ1UCIHY40owkOqiE\nDddOWPZnvuwjLz1epH5g6pnlXnJdSE4g\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATX0JwF29eR8B2xEAd17MUxBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ2NmJiZTEtYTZmNi00NDIzLWIwZGMtZGM5ZjY5YTExZTFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMjRkNmY3\nNS0zZDBlLTQyOGItYTlkNS02OThiMDVhNjNjNGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ6+A2gQWY+n7Hswens81f7HSH3N8ol0zk09UTUKKeHihGEgZkzubdD\nbb8bMgOXPlcQ4fWb0ofl5w4E8N/WQI7+o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQQzmkl\n8vAy0kmzHB0DVzI4YogobjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA8kJH8in5hz/rWJ8hsBW0v6/pmEwgRsqPDZxN\nAL/QrU0CIHk9FwpUIinGqln5Z7y+COhpWycfFryCHwudr44a0Di1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6184", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6184` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVmq7WEk46ldm+fT0FurCrtvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3NTU0NTY2LTBjYzItNGYzMS05OGMxLTcyODg2YmNkYWM0ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRlNmE1MDQtMTNj\nOS00ZTc2LTkxYmQtOGJkNDk5YjkxYjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb09xeNIM/Mfa88oUzkTIW6NIkkYJsIhgI9m/6sWZIiXppOtwV0t01qcey1OU\n6fkyKDxNPshXWEa43vDl7TyGcqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU181U6fsom2uyMslrmoZKiQaKRT0wHwYDVR0j\nBBgwFoAUyULRns5jdnopfpHxDFjsA+3GKf8wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDBwcmaKG7c\nBl/KRmrWGS8UGTCPFRQn1fmVtXya+fPmxgIgWEWPybfah9ZpEuZ9IqUJV0tEaSpn\nBryyv8rr66wMhJ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcVt4/ATV2grUyGZ4Z0yO/plMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzU1NDU2Ni0wY2MyLTRmMzEtOThjMS03Mjg4NmJjZGFjNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR25+6d9b2I2C2+xHVgKxIEVgsxgyZcHrkSKk82ApQSqTjA\nl17yfVO9bLEGr3c2w168qSqwP8Uik5miMc/UEbDRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyULRns5jdnopfpHxDFjsA+3G\nKf8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALSDeN/wQZW0qhhQHbyh9dzNAtLyAybeU1COYtizwat7AiEAnCZY3H7o\n06TyTkLrciAYoZYV9lYMGqy7HUQWRvP2CJg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAT9b7VArchhzNW7TqhaPvaaFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRlNmE1MDQtMTNjOS00ZTc2LTkxYmQtOGJkNDk5YjkxYjNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NGI4NTBj\nNy1hMjYwLTQ1ZDktOWU4ZS04NTZkYTNlN2UzMGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASsNyIgXaxT8kpVhvrmpQ2rjnFioy+ck9hTdZxr0Y01pWBqaPkgwVcg\notLBwY+KKqWjwR5WMMJuPyfeazEVajFKo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXzVTp\n+yiba7IyyWuahkqJBopFPTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAknJI14lCTQ6B2s+94dIkijTFJI55tjX85aOb\ndsV2IWwCIFTwylxBq8qoNzvwSqs182UfI92TbmJAV+Xs+vWWrGLz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6185", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6185` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdej38JaSH05DNxiYG3AILLuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0YmU1ZjljLTFlYWUtNDc0MS04N2U3LTI2MTY5Zjg4YTBkYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdhZTI0YmQtNWM3\nNC00NDBhLWJiZGItNWQwNDA2ZDUwMTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnx3vQ5piadQebBa9rGypQ2pjRNWSOHYj85sPrs3mCNionJyrUGFt7llw+jDs\n5677b9SkTOJ1Qf9LukqNFqA80qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA4PaUG/LyIQKFRW7/hlabBAxHwowHwYDVR0j\nBBgwFoAULgB0Z/9GIQaBVSrOemecV1aH/vYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBT2oB1G+Iv4BcG8oKYqaARgcb9D8FmyvREoxuv1toQwAiEA4uHUcwHkp46B\n0/OKo5lG0LPFrjeO6H5ulSyC+ecC53o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASvDLArrxZQ8cUDcQFOQCR7sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGJlNWY5Yy0xZWFlLTQ3NDEtODdlNy0yNjE2OWY4OGEwZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTzn4b8m9eqNfgcszJxNRCKwXKiFHPYKE1oVQcvlI/6RNU\nEpAh8eSdXPCMePQEIqYe/qfMDYEn1ti2JizKaR/6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULgB0Z/9GIQaBVSrOemecV1aH\n/vYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJM43wWtd5Oq0mvromHfS3o/Ggl2OHOdCIFpjLTHBOGBAiEAqmbMwJcN\nZ6oC5Yen3Y7thyksG8yKdgJChIsU65pUQ/k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAc2oOHCX6Angdvt1Hf86ewfKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdhZTI0YmQtNWM3NC00NDBhLWJiZGItNWQwNDA2ZDUwMTcxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNDRmM2Q5\nZS0zNDZlLTQ1MDMtOTU3NS1jMTJkYjA3ZDEwYmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATPvLOL2seaLzhzQ/a2rvo0cBYdvQMtntI8unVt0ltzO3XBCKSfVNyl\nmbhw/vzEN1+hpYSbweK02f6Iz6m0ni3zo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQDg9pQ\nb8vIhAoVFbv+GVpsEDEfCjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAsu+iX2bAThIaqRow41WmpGlzeyZxvMRmELhf\n70apIyACIBqoQE0qrkQ3GUex2L4lMz0jBahNoksTlRG0ED2pJHWC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6186", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6186` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAWVEu9j42knymW9cnbtdj7KCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0OTIzNDIzLWM1NTktNGI3Yy1iYzMwLTNiZWM5NDlhMTg5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJjNWZmZjMtMzlk\nOS00ZTlkLTk3NTItODBiMTRmNGQ0NzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3DdifUrBRDpRgOPsSkcgfvRi0ApseeM824CNVgTncKTWFj5erXMGQYQf53GY\nUF4kdgxsjGALGuYV3ziKPLlRsKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpGv6koVyXHk7PQzBKbXGBD+O/yQwHwYDVR0j\nBBgwFoAUqY/By8WyKzsFeRbyT8c4r5NWdR4wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDfX/iZ0vzng6I5GtohcnCZ7sZMxa5x4gXiMThYQnzhiAIhAPYlFL85gIT/\nCY6nWY2ed3n82tZHzovQ7Pfr1VNGqKxC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISActzVHbystxzGlVplyPEbErnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNDkyMzQyMy1jNTU5LTRiN2MtYmMzMC0zYmVjOTQ5YTE4OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFCQK6D9SA1bJDNXHpMtD3h0rqpwjv7jBW1gztJv6U0g/w\n03PBYFbdcaQczqViq3dTsvYw7CmE9LEfDPc5iGZEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqY/By8WyKzsFeRbyT8c4r5NW\ndR4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKRkFBPnJnIUVmnFKCyVt8+PqlY3e/3Mgub+4P0Oyb3GAiAonpfnNUwG\ndod8piPIUMXJKVqb4H2B73F02gGGyHfNQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAStAIiV9LFrYhYbIemN+Wg0mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJjNWZmZjMtMzlkOS00ZTlkLTk3NTItODBiMTRmNGQ0NzE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ODk5MjQ4\nMy1iZjExLTRlYTEtYTVjYS0yYTQ0OWFmZTdkNGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+Pp4YNUNQ7xY8021EnulF5O9qBBdDdGCusPOOw0aOaNBRXH0O1wjl\nb69rCstnb5VPrMC/T/F1nIozQ/Nq0o1do3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSka/qS\nhXJceTs9DMEptcYEP47/JDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA8R+bFEf1hBuP4UXsg34uvNLwxkNiDJ7Bj/xL\ndYzxY5gCIFKxwFAgk3WIg2jU2X7JzN9RsBwDnsyOG6lpfsR0Z0Pl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6187", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6187` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAZ4a7O4BRRMJ226kTlUbfUqbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzYzc2ZmNjLTg4ZTgtNDgxNi05ZjdhLTBiNjI1ZThlNTcxZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTczZTYxNGItNGU4\nMy00MzU3LWE3NDQtZjBjN2JhNmI0MGZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1aDg3+YeJZa/kygERTEqdwBnJmlXcO1ypCzLR7dTHfKDP8pzH4AlJqyFwH6W\ndyi6b+ZhcZx2wYYkfPNNkiZky6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJjTfTSHtvGrvTyjN/bYax+7wuHYwHwYDVR0j\nBBgwFoAUwNFL/FT0RAEdlUsJo3srOnDJd4cwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIG2/\ngvmUEdqhEUF5kfWnIilXImtGdpnXoFdB+GtGz2QfAiAFrgZ+FHAkm6UrB/DYDIvl\nJs1Mdh1ZyHu1Muft9Z/eMQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR+HWRzcUYUI9m+CjKeIel0DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2M3NmZjYy04OGU4LTQ4MTYtOWY3YS0wYjYyNWU4ZTU3MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVc5/lV63iiFTgeanAtQEkNug4+4tjoMrWlysPzng3qH6G\nXh8i4wmx87J0EYjvf7N8BV4POZssQIV6c4vbLUz3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwNFL/FT0RAEdlUsJo3srOnDJ\nd4cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH2IHjh8bTkAdKB1gvtrdQ2xeY2AjNRAfLpfjSKS73Y0CIQDI2rxo6+fJ\nAAcDZFQqxfNR/KtAzZVTIV9K+Wp66JA5tQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZN23bWgJgcDMsm2/mw0f7DnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTczZTYxNGItNGU4My00MzU3LWE3NDQtZjBjN2JhNmI0MGZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZmQ2ZDE3\nMi0wOTJkLTRhMmEtYmM4NC01MDMwMjBlMGZjM2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARgfxRHhhgaVo3AR4WY4COG30aO2Pa8z0d0Qa1eQ9+9gLFBhmyl8yLU\nBpHpGzERf9Jm7LQbtbr0QLGRb6EGpTwwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQmNN9N\nIe28au9PKM39thrH7vC4djAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiBgFTS+1KbDD9LK44WP8GwoNO0zVwrNrLD1L7T0\no4Qo3AIgfge857ePBgAzkzvbxhBTs6IltqIA1Y/3js9oktIvFdw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6188", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6188` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAXsHsr2Rz6Ogg9rc/4U3CAmqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlNmIzNzhkLTk3ZmQtNDIxMy04YzZhLWQzYmM4NGFjMzc1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQ4YmYwZDEtYTky\nZi00OGE1LTlhMWEtNTM4NmVhMGM3MDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENjHOGHFdXkJ3mSmLbzD4dM7VcNjkerlTwCnXkmTxk/n2ohdwHMfYrtronJXe\nk5OKA6uy6XHgJGotQThCoQhbQaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwOEJmphjH8rdQv9NQWTZrvcJbygwHwYDVR0j\nBBgwFoAUQoajVgKWcH9RbpwGRNf5ggKjxvkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCICMqUpZYt0Jh027+PPKODoZyK2PKn0/eQYTRCeEZpBuLAiEA8SAf\nJv5PQCHQw0x+LsmwvLMD3ddRHplIAn+X+cZMPog=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZkVvIauFJ2CEDqb9oqsbvSoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTZiMzc4ZC05N2ZkLTQyMTMtOGM2YS1kM2JjODRhYzM3NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYN06U3ln3XvwNpugb8jEf3pT6VrGT3bN964L+TRdJQa6a\nVQdEoUn4aX4T5sBR4Mq+wo/BK7OJGs7/Dkpcwm+to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQoajVgKWcH9RbpwGRNf5ggKj\nxvkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALj0pMSimwT73q0n43JJnr5VR3jIO0KEENH3zk5U2fa6AiEAyEmwJ8Ya\nVYw7m7NMEfafDdMJccA07cilnClY0VmZuBk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAZ5r/JFHacwLRQpBt1Weto+vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQ4YmYwZDEtYTkyZi00OGE1LTlhMWEtNTM4NmVhMGM3MDUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZjlkYjM1\nMS04ZmRlLTQwMTEtOTcyZC1lOWRhNDMxZDgxYzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATqfwCeH3rxcB7DZNLUJPOsEyzc9AQCoSIfKoeJMNR81dF/FCJcj1bP\nF7gRC5mRmIyLAp+SeV09zXCqfx+3Yk+lo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTA4Qma\nmGMfyt1C/01BZNmu9wlvKDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAxoF2J5w4pSjoxe8kqVGRKCwpTCWTLkqt4Ot4\n7zJ1nKUCIQDqp6iSlgl+LAFjkQxriY/1Le3u35xS8LQYf6vyP1fj9w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6189", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6189` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAXLJeHW+WtF73CdVfs42qKRkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjNWYzY2U0LWZkYTEtNDI4MS1hYzY3LWM0Njg1Yjk0YmFhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q2NTBiMGUtNTAw\nZS00MGVmLWFlNTgtM2JjZGEzNjE0NGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIJDsgxQAky2Jmm+2SXU/IJbM1ZqRuzCV2Cw2S1rLpRnw5yrjIQ3Xb0AdL2Aa\nBpL1V0bXVMMJ6MysvhWamuBQ96OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlRRLpjNc414I/mK+SpUExBKLIBgwHwYDVR0j\nBBgwFoAUMRc4amVpyTeddpax9HO2dgcEmKEwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCtl/ORuT3OrPvAm/YAMzJ5gU1KyQomTZwvRGLjW38dtgIhAIOz\nbjN7Ah3pzeqYiLGVyPmdcEhHJCxTXqTyyNgVuzXQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUnDdfG69Do+6jlcmQ78YuMOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzVmM2NlNC1mZGExLTQyODEtYWM2Ny1jNDY4NWI5NGJhYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASE5WJrqG4iHmXwM8DjZjPyUY8Do+oFI2LVM+iv/gJ4T1RL\n+fMFdW97+9U60F74CfcWk8KVpF+GM1XiZ43yuZdso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMRc4amVpyTeddpax9HO2dgcE\nmKEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI97xDlmeaNplkvETE4JwZRoeoeNvZxPYYCh9jqsIr1oAiEA+5jGL9fh\n/9lYTJ1KKbxDdXOtHjGomf0Dka81c45TS5Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAR+kn+zo2rVA9JG48RmUa4/DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q2NTBiMGUtNTAwZS00MGVmLWFlNTgtM2JjZGEzNjE0NGJiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMTlhYjhh\nMC1jZGM1LTQ3YzUtOGViMC1iZjk0NDQ4ZGExMzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATMMDm93EBItgKW6dMucWTRg/DIne/akcu/hv1O1/iu10ra7byGpC3O\nLD2XDXdOS9quxaxpqTpu2Km6I3enEGRNo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVFEum\nM1zjXgj+Yr5KlQTEEosgGDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAwwsubxTYJWZTA7s+AYD50xqbhBzbBivnGxzVk\n4qTVqAIgP9sR4pnqodgZt0W7wKlzql3PNLwfEja4LyyPJELDTkI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6190", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6190` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdqa6fNnlkTVLYLjcMUyvv9EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmYTEzNDk1LTBlNjEtNDMxZS04NTUzLTE0M2UzMGRhMzAwMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg2NGMzOTAtNjYz\nMS00MDdhLTgwYzMtYjUwNTkwNjJiZjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF7AYFTlooU2tgHi/PUqyjxvO870z6XHVTUe9VxsLHl5h+Ul9QZOniXgudgDl\nfKcHoGXDI8YTWOvp6YeOk5njXqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR4sF22n+XSmyrL7tU4RrVyfMgu6zAfBgNVHSME\nGDAWgBT5bJtYFlkNaKCDs9nLwAi+M7LUWTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGepNVyDmnLHZ0lRQ7x2Uw69Sr9CgwhM\nkvFGYZTSxh1dAiEA5j+BhcM10JEL5IS1DLSH5CpjgYX/Aeo1iMmYhrdLckA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUJmp8zjwcJKdBVrYdCKble2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmExMzQ5NS0wZTYxLTQzMWUtODU1My0xNDNlMzBkYTMwMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARThAdGX1HCLR8fYolVXHrCMCD7hWo1W+4XLegNazN7hpjc\nj5FWSOhBfXkX8RNTgIyxKElZSBluQn/VONc0d8Reo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+WybWBZZDWigg7PZy8AIvjOy\n1FkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIULoy/i7coYpC6TsnmrImaSF5HP/5IpQsr4nl1P6blgCIBcYTYijENgW\nGkwPHctk+enryN0zPy0Cz1M+JYGmy2uv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVCpbqd2QFalvdOcF0l8oMXoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg2NGMzOTAtNjYzMS00MDdhLTgwYzMtYjUwNTkwNjJiZjVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNDY2NWVm\nYi0xN2MwLTQzYzEtOWY1Ny0xZDhjNzgyNDRkNDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ8hTiqhXcHpjR0Fi1/2mLBkR21/NTQ+dDFnpmdMebV15ySw0JCSTfc\ndozbThkKmt72lc51FQXbIj1v9vFxjhaLo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4sF22\nn+XSmyrL7tU4RrVyfMgu6zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBzjDLdNndUyr9vvHxUJulSlg6UG2g72+qH0vwh\nh3dY0QIhAMnZcJt7x8y/Ec5PW6a1qahPh9KykMsve47iE44zV39i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6191", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6191` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATFCEt518+Wg9u45+0/tZ6UwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzNTQ5OTZkLTM1NzItNDRmYy05ZmE2LTE1MDIzM2M4YWIzMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU5ZjQ4MTgtMjFk\nZS00MGQ2LWFjYjAtMmYxMDNjZDczYTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKQd0MtG5/XckqG+p0f2vQ/j3qPMbo6yLKMm60zJhZZfvHb8TmmN+MGMi/qS0\nYki4ZEJx9ef3t0XEh4Z0xeXw+qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmrl9oCIFObhddO2wKzzg0mTeE9kwHwYDVR0j\nBBgwFoAUOSAu80WCc5wQ9JxL12phZGc8ydswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC4dDAhzGk3\nrWDGojNgjM7aP8BTLcIr9qTOnZqiCgmfEgIgYXVIZCBHPCeMi3N94L8+3/f/VGxK\n5dWwG0zd41LLE7I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdyidTZtjko7s++Q2QpN0aoEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzU0OTk2ZC0zNTcyLTQ0ZmMtOWZhNi0xNTAyMzNjOGFiMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMHIf/7uZLRyngyfsKFKEN4go7ulFL3+T9HbQ6dQAxpNXv\nVKZrLcbgbyKv/XiWZilvp0eg9I3oSoNYpT536imIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOSAu80WCc5wQ9JxL12phZGc8\nydswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANhwljS1zHGb4IhQWD8BjAkneZlFXEVdmc7M9Ag7sFvTAiA9Lsa7EIlk\n4tAUvhpyQ8l1aoT8jUm7dweYPgjSf+PPlQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdgJWhvAOF3Ty6lGeJrlhF+XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU5ZjQ4MTgtMjFkZS00MGQ2LWFjYjAtMmYxMDNjZDczYTBiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NzJkZGNm\nZS0wZTAyLTQ5OTktYjdkNi1kOTZkYzNlMzE2NDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASpwuYtmASUemW1ro8OHHk4HNM2VZqDg3O48oezI8jZkfas5yxkq+um\nOJNzKcZVDA8auyEkDcqBZfYxsfBIFKyro3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSauX2g\nIgU5uF107bArPODSZN4T2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA1XBgDCNT8k3M6pk+XmWhsbmlfaWGIVJjEBEGM\nFpKnygIgL+D3wMV9D68CyWUsG4lgPffyOyRWk+DoNCeJfN7VyAA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6192", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6192` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAX6sXVI222GmDqRVutlEm6ZZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjYzRjMzVjLWM3YWItNDU3Mi04N2YxLWJlYTg1YmNjZDI1OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNkZjI5MjItZjU2\nYS00ZDdkLWE5NmEtNGVmN2M2ZDE3NTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8cdagd18zVl9vQ0wde3g+Qp+p9F08rXJAieN0x7DMgBpQNtuFxAO5LmCHdd5\n/ex20pAFw6TBdMig3r8rthve7KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6C44WmxNJ1+ewcJB8f6KfSrXmX8wHwYDVR0j\nBBgwFoAUEAme2tcF+S1GJrCe2TiR1T/0cL0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDEcxpWNPLB\nhHt4J5GSTPBIg5Yodosb9pn4IZ27DBxyoQIhAOYTROD57BXlYoT8iLYZRuWXH50g\n3nG7TFqcKxA37SqC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYAqX82Q0LXwi4X8blkNrGmwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2M0YzM1Yy1jN2FiLTQ1NzItODdmMS1iZWE4NWJjY2QyNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRwmeAD3K5NBOH1kdKaQSMQPEGLWtuwCCAAKE/vkxlGsKE\ndgWZwWwelG9Oc0QZ36xQ5fdF4aOwO6z+IBbxOzDqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEAme2tcF+S1GJrCe2TiR1T/0\ncL0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP628YDwhqERFyky15XY2dgXO1hQ+aduASu/0i4ug0q0AiEAxOzGo5jl\nJZkgAJYWCX5SLgh3YfCttgzbT/VsmnY3Jh0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAUKO/CxFk8kXl+Q50UoZzVsJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNkZjI5MjItZjU2YS00ZDdkLWE5NmEtNGVmN2M2ZDE3NTY1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MmE3Mzky\nOC05NjljLTRiZmEtODE2Ny01MTVmYTdmNmQ4NmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASMXpD+z7nVroKYfmyGpMtLjsCpc0rJRhaDvPkRjaZehZl+xopCF/G+\nK+V9dw5PmLVRhSP+UIds1nUFndlX9j/9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToLjha\nbE0nX57BwkHx/op9KteZfzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA8MO3k/taz6SwWXEKMJVtCHxxuzZPLD2PUX4C\ndht2Z7MCIQC4xV5wODYMP0Puu8uynbyIwwHbG2B0PBIAzjd7pb2IPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6193", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6193` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAaE/oh6jLeatkL7ks3JezqANMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZjkzOTQzLTRlMjEtNDYwNS1hNjIxLTkzZDM1YmU3NzMwYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMzZWYxNjItZWQ4\nZC00MmIwLThhZGQtOGE5YWFhYWVlZWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEew6Z3tfeXdA6pLhk7lki5BaCU0tQuJWHSHaWdppQwdaQRIxkaH97LEdUhX5v\nb00Zc2WCpzsSNIy7h0YfYR9EZqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSKdXqwA7sKu0RNEGyAVWui7gnUIwHwYDVR0j\nBBgwFoAU4K3WDVf9ac3eRa4G7uXTm1RtOaIwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAw/3hPAKA\nlXRAbiH1PBq8uI39nNBp0v/rcCkaOHYZCcMCIQDtrSWA5waos0skG9idV5zBEyJG\nksajmJ9AggWbkOQV/A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ+c/PTJN99qATxUVZCy8rdOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGY5Mzk0My00ZTIxLTQ2MDUtYTYyMS05M2QzNWJlNzczMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVgjZIGuMcZqjI0K1VCj3KmDjWCNCKeWWYVaqAtFkwq6/h\nYmTGXDH5GIY+0FCyNhN6n0ZuMJAOWvLOHiFbjSYxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4K3WDVf9ac3eRa4G7uXTm1Rt\nOaIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLF1/NsUdq29lQwGn+5cepkScJxBqZE33nIkvKIjnfgYCIQDVG4YA7rSQ\njDX0TdMKHUO/TDLLcksFLs8xr3QPXbDnXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZz1lcPeInsXvJmoM20vB+zWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMzZWYxNjItZWQ4ZC00MmIwLThhZGQtOGE5YWFhYWVlZWFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MDBmNTFj\nYS02ZWM2LTQ4NTgtODlkYi1mZmM3ZTBjZjFmNzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARj6E3FlIwxPHGKs595SfX+ZnNPqL+cLr5t9ogJZ1Guiym8FLYNA89Y\nUdodLmAwIX27SSLPDRDuaJC03qEY0UV6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRIp1er\nADuwq7RE0QbIBVa6LuCdQjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiArAIJ/+1IwL1sFDkdvtu2u2WQWlMCE+1Q8aWvY\niwQ1MwIhAPqkK9CI/3bLgIxA3Lla/L8Ridkqy9zStMJ8xnwMgb/9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6194", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6194` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISATJV7zLd6dN8G/GwqFm54PXSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjMWYzMjQ0LTg5NGEtNGVhMy04OTdkLTRlMDk3YjdhZTczMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y3NjM1ZTEtNTk3\nMy00NmUxLWJkNWItYmNlNWJmY2Y0ZDA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFFagUVxoT9VXGa7t9QRnKqKcGVwh+eLuPsI+faIZghZxFFHz+KADAvS5dlnN\n1Azjb3PPFIDiunfRQcmLm6Qe1KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/AHYGMFHcFQ8w8mbiN9MEv5bXF8wHwYDVR0j\nBBgwFoAUR9Ls4BKx6/Nll+aETEOV/j8IjrswNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAiXHafJu5QpzhEffytg/SshQSx7nrjfM0l1+vsHD0cIICIQCAc3IH8HGW\neAewve7RuGpDqIMhzjun3+8RsQuYp7twtA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASNig548eERqZGrwoxmTgUZqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzFmMzI0NC04OTRhLTRlYTMtODk3ZC00ZTA5N2I3YWU3MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnOGcTbzj6Mj0he40NOGW50ZYRaddp3/7bJD55zRVvZ1J0\nobJ+Vo8BvGLwgatAauQuDtmhqdVbmfhM+qmX5/Who2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR9Ls4BKx6/Nll+aETEOV/j8I\njrswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIga/3vpRGuFlSQu4Ikq9gIQ6Xi6IfWPPJcdtAv8gJlZy8CIQCvf8AMEbz8\nw6rQlVSWs4sprSkIxKHUyFQ41AS+dv29Pw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQuNtvleHTQ3fjL2GeVsgyvLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y3NjM1ZTEtNTk3My00NmUxLWJkNWItYmNlNWJmY2Y0ZDA3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMTRiOTRm\nMy1iMWNkLTQ1YWUtODk2MC01NmUxMWM0YTVjMzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS0puDflCKe2sc9TUF4Bi08/HCTIWFTSpY7O5L4eI199qabTDVkzOdQ\n3e0cXjE1yE8NYzCfY1Dxyc3A8izRz9iSo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT8AdgY\nwUdwVDzDyZuI30wS/ltcXzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA36lLH1F7kHW9IdE+AAuHt3Wfrn2tMCvgrdTB\nDsdo6RcCIHrEfLRApzwGICPdsLYzfnrShwesqrZbhaXjgEMLftll\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6195", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6195` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfjaei1deW8yFUV0cGPnbMMDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3YTU5MmY5LWE0OTUtNDg2Ni04MDZiLTVjYjk1NTIyOThlMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE0NzAzMTMtZmMw\nZS00NzMyLTg1OGYtZWZhMWNkNjViOGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKHF4ifUcGUY+l5pf1u1Ibl/KgCNCfgPlgLc9pTRxLOdn0JrBHkyw9+urOm+F\nyUfz//j2Y52xZ3vu5gHa6w0Zl6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPV1yo7NYfMNSPlSr+BUN+fcYneAwHwYDVR0j\nBBgwFoAUyVuFdLLDWS0Na05IuM0fQvgUnb4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBZw9d3iV6POc7ndid8m77r47dy0blsqGPHj9nOI3Ra+wIhAITyXJsOvG5M\nhcF7zkbqz7MsKFyx+89EZgIaiPVUeJLU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXkHcG0CKP5ygH+bfUQZtKV8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2E1OTJmOS1hNDk1LTQ4NjYtODA2Yi01Y2I5NTUyMjk4ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATd8VwXqNVG/qAXdFFcj7frZs5JOBjkdMZOoVz/CMNSQO6l\npK3U8lH8jshzu6BzOPjFj22h4DWEKRqeYEVoBXpIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyVuFdLLDWS0Na05IuM0fQvgU\nnb4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALGBoqVMW/d0LSzj2CjhwR0DrWRUyQ7cRBu6WdtOPpy2AiBCAG+9bRZm\nGR3nKl4j61ibg/793ZeWH9Jj89Sgm+Uvyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAa+t94PDaL+2L3pkPw7YxSmsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE0NzAzMTMtZmMwZS00NzMyLTg1OGYtZWZhMWNkNjViOGIxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NGY3OGJj\nMy1kZGYyLTQ1NDItYmZmZS03ZmRmZDc2NjhjZjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASwUUDp5yw0NDesXqPJsqpYZBQwLPzhKp1Uy8li7f8fG0IrpNrj072V\n7wVkzL2DlqJNpJsJXCc44vbZf0RWxQ8Fo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9XXKj\ns1h8w1I+VKv4FQ359xid4DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBC2DizkxS4X29aB1Eu+ltUIVrw8YRyxUftpJ6t\npqk3MAIhAJHoxvZVCO7q+POjEtplhmvW8w6/auTIKTjHPMsvmRUe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6196", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6196` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAY6tUeOmK3g513V/DJQ3uk+PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyZTgyYjk3LTg4ZGQtNDU3MC1iODZhLTVlNDRlNGI5NmFmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM5MDNkOWQtZDA1\nMi00MGI2LTk2NWQtYjhiZjk5ZjNhM2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtCIsp40Of0B6g1V7uqFQ78TcHcnASG4QK819k7mv6FD0yS9EwuJLbTjaybNF\nDURRmAUAQScq6Pul11DHArOV3qOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDy0LqK/wRYB1w+FVJcdh0PqGrc0wHwYDVR0j\nBBgwFoAU0GikFwJ4wzDs1Sz2zYxZFEZSFAgwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\njoJQt7YoJMqgh0FWTBEoW4REAzSgLVwmwWYc/kyGB9wCIE7Mm3U2qakhFqCv7D0N\n2n9jMz4HfkRRmNq0pr3m+xAz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVRkIdVR9cFtfZcfZUw1gHmsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmU4MmI5Ny04OGRkLTQ1NzAtYjg2YS01ZTQ0ZTRiOTZhZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFYcxjweyStasNde9/8CxMlg3X2QsgJ+DwrRes/fSAMh3e\ndl42nFJRaWsC4bLwlyFgfigj0ITEYLU2ovnXcH0Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0GikFwJ4wzDs1Sz2zYxZFEZS\nFAgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMWivYVJWHbhIQKjIRLbz8qnWFwYPx9uadS828msZOgIAiEArugaenEZ\nfaC482bV4HPOPNqdtkkhl9+L310cBHG7ru0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXMTTzFQp3ejUtYFUnQdANNVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM5MDNkOWQtZDA1Mi00MGI2LTk2NWQtYjhiZjk5ZjNhM2M1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxN2I0NzYz\nNC0yOTU1LTQ5NTktOGViOC1iZmRkMjM1ZGJiYzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASWBzwc10ZzCFjTE1gEJUWIgOgP8hLpAdIyG6Twfd5CyT45NAqp1zZl\nlwgjrINeOn1+LdkOGl062u93LqRmOK6/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPLQuo\nr/BFgHXD4VUlx2HQ+oatzTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA8DG4NqSG5a987uTfeHTlEc8zcT29a2xKiqBV\nnjlkt1YCIQCtoRaKfQtM+4La8B5TLOZIRTEOIOpcRTOYSClX2afHHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6197", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6197` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAU1dPa8RIcFU2Dx8oHpppmbvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYmEwMmJhLTYwNDYtNDVhMS04ZjU3LWZhYTU2MGQ3ZjY0MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI5ZDE1Y2UtMTE1\nYi00YTc2LWI3ODYtNGQxNmRmZmE4YjgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZYa2q3m/bqQy5snIX8yqKJjzsoW6we8hFw1EGjmCU390hlyvRoTm/5WGKyyx\nQi03z/M61j4ivJHa75EGXP76LaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1v1xqwcgMcjYTDieE0CyofiUECowHwYDVR0j\nBBgwFoAUiVWcG+WOckIy9lntRcyEeDsUJyUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAukZLfxBULQmpNge/M+gU6cGSpuXunDOJNsBg3LFOxT4CIQD9\n6BE9wCK0fH953NOBE2nKSRD64O4zwRhEkBzqjcejxw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYUBocmF6STQ1i4/eY/3TF2zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmJhMDJiYS02MDQ2LTQ1YTEtOGY1Ny1mYWE1NjBkN2Y2NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPa1Di4wi7WfLV0hHKJfEAOq2BxNeyQkbyA/RJjowbnAfY\n4T4GsR4f7VgjNOgZgKKYx5nXubYKycHF0ao3FXHjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiVWcG+WOckIy9lntRcyEeDsU\nJyUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKb7e2SQqXPn8CffgDpx5h9oQe5qmSyDl4yCPASvjEFXAiAVrCSVFM73\nmoe++9R91IUo+F1EjTlaF0JCnBUyplrFtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAaBSR1UWCFZT1kJVsxwIQIG6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI5ZDE1Y2UtMTE1Yi00YTc2LWI3ODYtNGQxNmRmZmE4YjgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNDk3YjBi\nMi1lNTY2LTQ4NDMtOGQxNi1lYWE5MWM4ZjAyYTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQXNSRnE/goHhMQamkaSPqCyUG3KZUGGgyAK1v8cfownXG5xwCsbpc0\nyW6NwWBFM9YqzN18JWEbyJL5tsOHAoR9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTW/XGr\nByAxyNhMOJ4TQLKh+JQQKjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEApYHfI6Do7MK0HFKUHEZf1c60SVUsBXyuFtfD\nj3p1aGcCIQCaEN0eh/H/TeQhWtmOEdIzhAW3FJvD75RVzl+wJmJoHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6198", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6198` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAaAKpD5nb1ZSLCdmSiLGtjRUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNjMzZTEwLTQ5ZjgtNGRmZi04MTZjLTQzYmY2MmFhMjJjZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YwNmY2NTctMjc3\nOC00MTBkLWEwOTItZDQ5YWE0NzVjNGNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0vM32SAt4wc80flpTTtcwgke2PgRIm1O8qTZ/n1Lu6iqS992nZyF7jnC7o+9\nTa2gl1KRrbqazd935RrEc2n5TKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDK3kDVqWx9jos9vXJwPL5YoMXeswHwYDVR0j\nBBgwFoAUflykb9m0g2zLus5vAGj90SoKxq0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAkDnEu3pzfzUNNMGw1t1l36dF4sjZjtzUJTAIx8lz148CIQCn\npmr55JSS3Uss/Es1rOtudYUpsN1x17lN7ofvptJHyQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWpMlSBynZl3yCQLejiP7mslMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTYzM2UxMC00OWY4LTRkZmYtODE2Yy00M2JmNjJhYTIyY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATB1f8z2k2g5xYXfWRAzDVM2z/i5rktnl82czCoJRUMZYkf\n22maor4dvDyooJam2GfaVh6QHsLcJ9uxoV9dd/y1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUflykb9m0g2zLus5vAGj90SoK\nxq0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP6qfT8WL65lhMks/Vv+g6UFqf8vTgNFkcF8sLorxujECIQDUVVgIQwis\nluWVmWvIvq/mtExaITCg0zy4Y3TUiyM4vg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAewxjVbEG+R8CnegLsmy9EJmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YwNmY2NTctMjc3OC00MTBkLWEwOTItZDQ5YWE0NzVjNGNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMmY1MDMy\nNi0xZTlmLTQzYzQtODM0ZC0zZmNjOTA3NzA2ZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQp8LH1nGYa+Cp+6+LrhNywuuJCNqSQqoinI/goGzu2oHj3JU/Qrdzs\nSo0DGmzXk3a7WRlh38Mh/5GpYMqjEFNdo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQMreQN\nWpbH2Oiz29cnA8vligxd6zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA6ivX0euk0G2B/eH/H1HAf0PdCjpGH+6CZmdr\nwke/VAUCIH6gYEEla7+6N/TWzR3fSwv64SoRlXF+SCFDBhK/Md86\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6199", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6199` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAUdUkErUZX183RDA/QqvTBOsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1YTU1YTdjLTMzYmMtNDhmMi04MTE0LTY1YjRlMzY2Yjk1NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA2OGUxMDItNGU4\nZi00YjUxLWE3NmItN2JlY2QyMzg3NzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJRDcM9zNuXGq5H6NWCy37I0oyK8jmQjDLv2HjMi4eNoW0/MnBTj3N0YKxVe/\nrBb5avqbLNNPvRjpbf7mVECQtKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiMx+ZQJVe8pFue5tmQl1bdfE7dYwHwYDVR0j\nBBgwFoAUnfy11Zgwt0mWqYvwpqfq6b/8qTYwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAtoQvAz65GNKK\nyJ9uJUTf6vw89G3GgEl6K4OGEauk+BgCIQDue6A1vLnqCkY/ETU3iY0FhSLMrnke\nVNg1/2xbnCpw6g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbhesYTqh8kLkYjP/PNK1waDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWE1NWE3Yy0zM2JjLTQ4ZjItODExNC02NWI0ZTM2NmI5NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdkMeuzZyRexfrtAvmZfL22Bzhp1KFqCNXCx4PLVe+USch\n9D7Kh+gT9uHpPfnZnkXk+3KJjW5QzhW9YhWW/Ap4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnfy11Zgwt0mWqYvwpqfq6b/8\nqTYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCVfZ/i3OeVOKSXAVoEomLCHMEqIssWpo0agWt/zQEQcCIQDrItDx1oaI\nNJQXNVOlzG+PNPj6GyzV5ZIfbggBEVKZrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISATs8ZU/Zd39QQeDnK+Tp0SVGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA2OGUxMDItNGU4Zi00YjUxLWE3NmItN2JlY2QyMzg3NzY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMmVhOGQ0\nOC0zY2NjLTQzOGItOWNlMi02ZWU1MTc1MmY0ZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQO6flvknYbRdsAeCx01CUrBAabNtDeRgAvaKzpd5TnwfdfP9khblrD\nBftBWVvYgXJjrcaBArU2oGmWt3re4Fu6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSIzH5l\nAlV7ykW57m2ZCXVt18Tt1jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAgSP4deiv36bRd3Z6zvyLT3g63glzlS3OvWed\n+CLWmQcCIQCN8IgljxFdS+VMZ5L6Kt5MYUyTbLyuQ5cNkAqFh10lpw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6200", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6200` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQqk9YRf/+TaANQkJ18Hy4gLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNWFjZDkwLTc5ZWYtNDFjOC04NjIxLTQ5Yzc0MWMyYjA4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFmNmJmZjUtY2I2\nYy00NmQ5LTkxZjEtZjg2ODQzYmUxYmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPCLekqpFKE+wfKd7FFa5vLQ3O0KYPOCKNnSlSbl7pA1mtpFDlQ2eG8Zbvgl+\nc5aaKB425LpQTPeZVlJkEeYCU6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvHF9mO/X697qfIEXHtV54Z/q7mMwHwYDVR0j\nBBgwFoAUOHo+9a8IBFW/sf3+0UXiLNGMTOIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFhv0erJH2y5vZjenUHbYaKCnMgxw1M/bbdCWK7SofdBAiEAmgBqG17OdNnq\nHDddeds7L0knUsYfXjNBfrr4xJDN3bg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdpIUQOoT8BTmu+bJwjruh2mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjVhY2Q5MC03OWVmLTQxYzgtODYyMS00OWM3NDFjMmIwOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgT02EmOBV3JdlfGBNOdFNNBG2SQF37lsrh19o2QQ9ttzy\nWFVWbJLRzWD6Fqaf5zhFDMGWgtRR8UalWJNxf91Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOHo+9a8IBFW/sf3+0UXiLNGM\nTOIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOUhBDE7SANmqjaTMoFC6rN2MeOXhHUicPbTWYIH9t4UAiEAuVYpuLIO\nEIR9cIFk66bRm1E7cPzR9n77ovhcZxILT3g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAV6zlfyztB7NhpbQae7s4UZVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFmNmJmZjUtY2I2Yy00NmQ5LTkxZjEtZjg2ODQzYmUxYmY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNjUxOGIw\nYy02OWQ5LTRmYzUtODliMC1iZDhkOGMxMjQwYWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASJpMz5XNvOnqzpe51WcCjsD9FrPYX8CNZTmUtri77ryIdm5YSvsgLG\nDQuuopQkcZhj/c5T8SndIRJdvIbkpyQdo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8cX2Y\n79fr3up8gRce1Xnhn+ruYzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAzFOGuQQFopxZ31UQqvbKe6bi8EhOGMKdEci2\nrzUxTRICIQCNY1nO2zvqMnkLGMEwcR7IPO+2oSgvKtnbGhyw8pQbhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6201", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6201` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAf8TOwLYGfdRe2XpUkUFNjuVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiMjk4YzMxLWJjMGQtNGY1ZC1hMzZkLWJlMjQ5OGZiYjBhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk3YWVlOWMtOTI2\nYi00ZjJjLWJlNDgtZTU5OWQxMTI0MmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4mktekwiXYzV3meJoJt+kFrUtrL6GsvlOvLkupIFh3hMsr9PYjpXl9Rrp8SG\nyDjsg4/n6AZMWggBMHAmnWyC/qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG4GTK3pYSRvw5DOnFHrhBlJWQikwHwYDVR0j\nBBgwFoAUbSgQZtygOdM/phgFPnrkQD2vg+gwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCID7peyo66EYq+qYmkNd88Qf490u+FLux9akUVcQPTzlxAiBUm9f5sp04ZxJC\ngKz1xRa8/aZj+hjOHs6DBYXiNcKGtQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYZtOOloQlG3g9slK0Xw+msIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjI5OGMzMS1iYzBkLTRmNWQtYTM2ZC1iZTI0OThmYmIwYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiatt+qaUb02U5+5c6mnrb88FpO7YkrTs0sdxEiyN6SF+N\nXvqA9mqFJuJnPHbZBjEt4YL+sjkDAPKePrRwIJROo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbSgQZtygOdM/phgFPnrkQD2v\ng+gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgENzEVnql9D1uPyl4DFulzoJFQVWPOm3zVuP51gdixj4CIFXbRFfQrH25\nqLmSU2zSkMu978TRJxC2w92RCArh9ksD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQQY+XfjW91AafdsW6+or6IeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk3YWVlOWMtOTI2Yi00ZjJjLWJlNDgtZTU5OWQxMTI0MmNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NGVjMWNm\nNi0xNDM0LTQwNGYtODEwYS1lMWYxZjlmNDdkNWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS6twBdWs8r+8fMb3kvpCukOP0l1yaMoSQ4TKcRTjguu3J2wH1iuZnV\nTcES0QUolqJV45kGHlIsIiob2e9QkoOho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQbgZMr\nelhJG/DkM6cUeuEGUlZCKTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBVIpoYVRTnfnquS9UG6d0wosZLh1p8tYgy3RCT\noinDrQIhAMkzMSiBFXZ4T4PiDEAfr0Ex9Si5CjO1Y4tXy5Zv27Dg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6202", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6202` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAXbKjWNRLcpzomMLBbyqhwDdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MTA1ZTg4LTcyNDYtNGEyZS1hNzFjLTc0NDRlODMwMmQyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGUwYjFjMDItZGE3\nOS00YTUzLTg0ZjgtYjc4YWNiNmNmYWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgb5yePWs5XYv6OGAaefbOTCBPN7X9KfD1+FudDDQI7d+yVdIBHbXSPULB5Nb\nOahqH1G1hOi1m87aMcOBPghLdaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOJ6nUuqkWQXJHqOrGpd5PEFlrUwHwYDVR0j\nBBgwFoAUMg/vvzqiAvq4bkHMWnRHBEW68gIwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBHeYlm2Urn9dAXjFDUeJkEiUdZQMtNrbLz/u2QpzKBtAIhAKe/AqeceG6p\nx1glCAOFcYJywI+KC2ljvKjdYcwNwpWS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAajaez/De911rxObrs1cBtSGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzEwNWU4OC03MjQ2LTRhMmUtYTcxYy03NDQ0ZTgzMDJkMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrHhNeTsGSVWB5rTrHO7iwjrRF3ge5Gyk6DjRyATTgW3Zu\nM1gT6wFp2pOaFQfmo1DjdvKOVA/4BDaY4rdcklkFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMg/vvzqiAvq4bkHMWnRHBEW6\n8gIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLjCG6aZdPrwYV0ZMHu0vqBcnV7iH45jhSNj/TwJtgasCIQCquxJtqAyQ\nYWczcQNbJvTizmv98y8X+yCBCamqwsB4/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATqV/JK7l+Nld9mtNhvVtMs6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGUwYjFjMDItZGE3OS00YTUzLTg0ZjgtYjc4YWNiNmNmYWFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3Y2YxNDlm\nYS00N2I4LTRiMGYtYmYxNy02MzYyYTg3NGJhZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQxIn4beKSbmR4Nwz7SKui3PJWarlw1G+2gpwSGpnhicVTBDELHT/lC\neUresf+m/U9SzLZFVjXxS/F5QoHHhaVYo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSk4nqd\nS6qRZBckeo6sal3k8QWWtTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAhtlCtv40MP8i4eBv4n6efZ8vzecEGoZnqcaE\njQp4SnECIBoMAfEkfXNMBjZ6QziNGbBtXL/yp57vIZSwF/RLy1I3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6203", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6203` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISATTk5T1wMAYqOORznzxte+WXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4N2U3MDQ4LTg2YzYtNDQ3ZC1iNjE4LWNjMzUzN2M2YTgyMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQwYjBjNzYtYzhj\nMS00MTRmLTg0YTAtMzY4NGU1YmZmNmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE387dM1WtGX7NmZhDl7wQC6aO6JHvwGgtQf94EqCu+f6de26w6qwvXTRFRSNO\n11/JPbLFYjJhytGT3Bju3F21PKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuig9q7rvtHVrMqochr0X1s+325YwHwYDVR0j\nBBgwFoAUcDke0zyzIO5c5QS2/ljCXdGm6XYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiA5bFqlnzlN8bbWshrGnSS+tJC462G4hAolEK0bioIY\n6AIhAImB67UBFWDhwlj19BzpVnJTbtuOXvCc1VSEeiyh0G4w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASehpmmNBOvMKoYD8gr872+jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODdlNzA0OC04NmM2LTQ0N2QtYjYxOC1jYzM1MzdjNmE4MjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqGNdqTgiXAx6Hi0vyQHmKquP9Vcg8zEBrDfQ3fH6B5ybu\n7Vqco6z2Xl+Y6W+GY0PoU3wQUgMkdrYOsLiZW6o1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcDke0zyzIO5c5QS2/ljCXdGm\n6XYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANYml077Y3YbGBwU3HNkv0jp6Jw6N3oA7Kp0GWW1XsxTAiEAtPKTG/ZP\nAUsSBFivgTDVV9lTU9RGWoC13pTKsL4i2GI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUzsQBP+TazpvfNj8r1AHRuBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQwYjBjNzYtYzhjMS00MTRmLTg0YTAtMzY4NGU1YmZmNmY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYmYxYTNh\nNi1mNmQxLTQxMjEtYjc4OC0zNTM4NmQ1MmIyYTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATU/8/4w6ad2hz1NSGjBo5dg7km+MYvwSMRYBEs4PpHFA3NZi322BcF\nNZ4lRIQBmuYk5YN5CxBdec1zJCw7YkSdo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS6KD2r\nuu+0dWsyqhyGvRfWz7fbljAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAp4Y/GQKBsnEKPJS9FLppyZ2Ld9WnDKTSukc4\nRc97tbMCIFtaCgMgC18ygdkIjXmpJMn8VEK7PwgVmwOTHRm3DbEe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6204", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6204` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAT6/CMEI2ta7UYSaSH70p4bcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0NmMzN2JhLTY2ZjAtNDU5OC1hNGQyLTc3ZTlmMDM5OGY4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRlNmI3MDQtODk1\nNC00ZmM1LTk4N2YtNzgyOWQ0OGU1ZTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElc5x4il4pp9j8gjBvSaEbRrwrFqIgxuRU99759Cm6XZlRrDOJazB6rewXtg3\nP8nq3o85HzYZBhM5FGkcUXKciqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfCu0weGYP7BXKPMfIR+sECPzmH4wHwYDVR0j\nBBgwFoAUWHfdwlPnnFj0ZgnAdLzqWP+LS6kwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBhb8RebRWODZupDvvefr/WWZgapMlWy1td0q6nzisk\n9wIhALFwjOTixtEiqbazDeyuwM7IK/t6SZfteKb/O39gPWL1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdwSf0FdwQhGyyVY2S4sV/8BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDZjMzdiYS02NmYwLTQ1OTgtYTRkMi03N2U5ZjAzOThmOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATv5XDyUmjLOvhDHHJnRIvoNF5NF5i6HJZEQIfVxAgn39nI\n9TbixDhBzvJJbacT3AxA/vusr38jTDriAsQGc08Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWHfdwlPnnFj0ZgnAdLzqWP+L\nS6kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIDCXvzECKMvECgkvjPWVmNbX1I/x8TVj+D/yd5OdK1dAiAEG99dAUzM\nxn7kr2NR/FWmgaNtKefTMd4FwxS/D2WTKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdcGVcR+1mmSwbe2NcQERpdxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRlNmI3MDQtODk1NC00ZmM1LTk4N2YtNzgyOWQ0OGU1ZTY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZDQ5YzUx\nMC1jMWU3LTRiYzYtOTE5ZC00NzZkZTRkYzc5ZDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATdcmy1DnzkqEKWHhv2PHhj9cS0b2xGWqXvLlrPANnr3gEV7h2DXTDL\nIlEP6yVyMoFWA9PcJhzUt+MQXeD9MmD7o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR8K7TB\n4Zg/sFco8x8hH6wQI/OYfjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAglkHusNtjpIN4zIz3SjGeImugFPnxFKk35S/p\n6rOGPgIhAMTkF3nuMzxcXNXMmIp4GkLih+mdJ9y6rrQX83Czjioa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6205", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6205` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAb4SemR6UOV/q2D+HS2a15X1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjMGNkODBhLWIwNmQtNGU4Yy1iNTc0LTdjNjVjMDUzOTIwNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdhYTYzZDQtYmIw\nNy00YTIyLTg0OTQtYzc5MGRiOGEyNTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjT1OkiHolD8HTfloDdOJINybC2T8VyiAWpuybZH3/bOZQAZ1bDePDncWLd8d\nwMFRfa877gJ2XaZct9cddFyOIqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV9dX0+H0GA2x6m3UmpUf/4i493MwHwYDVR0j\nBBgwFoAUkjRgasG9rbDKHWhRkqlGzLJh8jkwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiB7izisL0FCi16O4yXi4mNUa4WjUkUPs7Wp60csLV1ZwwIgYJe2\nBoSQf1CV2+bDX0J7wibYX10irJ5w6UgBx2RWF/M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASz2XyHcjhZXEqraS6BAxZGgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzBjZDgwYS1iMDZkLTRlOGMtYjU3NC03YzY1YzA1MzkyMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQf+cqRBssFhu6b4nnE82ClHSS4MPP8eZ6Ss91ll6/loGFi\n4dAn1F5/UwmRN0xz6uOUc7HGhnxzVdMO0hWNfPfNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkjRgasG9rbDKHWhRkqlGzLJh\n8jkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQAlbyFyFeh/aGHXZoEnU4oPYaHLEyn0LlZhoW2j+FkkCIFVmdrhE3P8R\nwqJgjbbdmrjArDwrVfLhXee6kU0lZAPc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAROjJ5ZjjjcjMPdM1sxDX74aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdhYTYzZDQtYmIwNy00YTIyLTg0OTQtYzc5MGRiOGEyNTlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MTdhYmZm\nYi0zMWMxLTQ4NjMtYjEwMS1kNmFmMmVkZjc0YmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATER2GwSYsctyRW0OK8XZ05jMd6UPbcOm4B//xxWU1DgrzwnuSN6u+B\nYQRpu2XXJ4HN3PNsdZWr5sEN30OWM91fo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRX11fT\n4fQYDbHqbdSalR//iLj3czAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAoUuzwb/uMsyJyWsUjtft08+hM8MSKI+XDYAvO\nslW8qAIhAJzQJbqEKnD6EgI8DPki0zkorjnWr7rHdAeG2OqyZ95z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6206", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6206` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAVzbKFpM8J4OdVVYrGbC6kZWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMjdhNDQ3LWI5OTAtNDJlOC1iMDA1LWJiYjVkZmYyNzM2MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzIyZTZkNTMtYmZm\nOC00ZjQ5LWIwYTUtOGZiZTJmNDAyZjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESI81+D73t9D3WkopCJIu4n9PUAaPJeRZwTJ+c+NjANyrtTXbsaIodWg9Cj/v\nbhekh3q3RCsvGsJ3fsFZPgmDRqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSSUEc7ok6Q+Zcv5epJ2ftkhjxFowHwYDVR0j\nBBgwFoAUK4jfyDN10YEnpu75mGwV3MAB6gcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBxRFSQrlnOAmZ/RDOwI6F3cahAcM64NAU4\njgsICmwcKQIgKLW7NZ07lf9yxVmxKJN1SCJ7G9DOWJzlQFPOLtg9PXk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX7WtDVwnf/m4AXGiQE07ew0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzI3YTQ0Ny1iOTkwLTQyZTgtYjAwNS1iYmI1ZGZmMjczNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsQYsVAiumFXt/7Peq59zfma79d7D+5MNnJq6/p8QV7rr2\nfWRsUHJbOWlqW4PDwDH14OW2A2xuYQmfCp+EQsvQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK4jfyDN10YEnpu75mGwV3MAB\n6gcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQt9SKbVMobmi3WGmNYbfoDioajyyqO9VeQdgZ8oztf8CIChHRdAedvn+\n42R0aFcsh1PHJ2gQKIr7X4FLEld6RUqn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAepyXEhwQz8f1ciD5KELCh+DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzIyZTZkNTMtYmZmOC00ZjQ5LWIwYTUtOGZiZTJmNDAyZjZmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MzZkMDVk\nZi0xOTE1LTRhMmYtOWM4ZS1lODY5OTBkMTE4YjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATlQVbGrRR0srqB1JFEg71tX86RYIucv1lXzC69hBUAEpgT0gy7dGxd\nlZVISSiPP5vqFXwKm09yU8KJb0SLahsuo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJJQRz\nuiTpD5ly/l6knZ+2SGPEWjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiB/Lw2vIa9NvmY/T84ACWM1K3fi8a+UtK66u5MK\n9NhgAwIgH71G96jKAcjSVrXuAXq4JqoqAqFD2JqWEjmlg/Hbj5U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6207", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6207` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAfI3PtqtSFSOgTIr64+x1e1kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2ZGYzYTRjLTE2ODAtNDM1MS05Y2E3LTE3ZTZhNTlkZDFhYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZmM2JkNzItMDFk\nZC00ZTE5LWJjMTAtMzg1NWFmNzI4OTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE81TfKIJ720kiDhchoxSPTFokHd7x/nxa3uv5O7U04k1uLKcuO1/tkf8mMPHV\ncs81EEjD/h5FqlWlKTaICFRf86OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIX/Hc/CvQ/OFgfB6/nZknCzNSvowHwYDVR0j\nBBgwFoAUOHkhInJD0RawSQMUu2IaBkMytJwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAwdrl0yU9FuA/Xl6noKeIlrbEhI6hDj7g\nQdEaj2ExBW8CIQDrrzWaO8dKe9nAntMO7NVRCVDOx3oUKAXM4bmoarmeoA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeLj5Ir9MX+sj2bwf9ma3OliMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmRmM2E0Yy0xNjgwLTQzNTEtOWNhNy0xN2U2YTU5ZGQxYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvGZM6MC+sQodZ2raHcwuB6VwmvYhtYKSlzd4kJJtG1ZQb\nJ9LI+/XxRN7sFKHxTloQpEK2VUUY+iWV8se1auano2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOHkhInJD0RawSQMUu2IaBkMy\ntJwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdSLhmzHvzuymSD2mw/iAE6L9eVfP7mqgeyfZoIwk74gCIBCzblv2Csq0\nNHjNbQNbDNymrvOv2xb9rBsQQstaUvDL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISActcSVkik2xk59oBLKosXyeuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZmM2JkNzItMDFkZC00ZTE5LWJjMTAtMzg1NWFmNzI4OTcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMmNiMDhl\nOS0zYTg2LTRmNGUtOGQzNC05NjRmZTQyN2VmY2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS877UwpFRy7IeRiGJDEOvNbcccvudBEnN0LkhPqPwrG/As51AcUNb9\nmpYZDvKKIb3cRqqGN5M4yrQ/12J6Hrryo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQhf8dz\n8K9D84WB8Hr+dmScLM1K+jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAcfPOVp1P9M7ipZPCYsB5m1vlVqHAZCz2mZB7Y\ncLT9zQIhAObnvVHgE8m1IwYTEAReWMcsnAT2E1+jOv0zyu9n6Cqy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6208", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6208` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAYCPYovvAW1IpA5gCUicV6oVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YzZkMTRjLWZmNjgtNGY3NS05NDNkLTFjYmQyYzA1MTVmMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNlNDExNjUtMzBk\nNi00OTNhLTljZDYtNGNlYTVkNjQ1ZTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6BbGp9pawd9tj+veLy7t89yFkj1+6wP1++ShVbRPGCFBktCM8iKJTokOl3/J\nx7TtJpEl8rFA13fKQns69kM4/6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ071VwVTXXD4iW21CZ5G2aMro9IwHwYDVR0j\nBBgwFoAUGhHPaCGZtEs4PlB1a6IWIfgKAeIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA+vH5TkFmZ7gW\noOne6e8/l/KJwTXsalVi52LTIrascKICIQDtQdKFwAFfaBXyVumntPu/+679bOAW\nPtUJEbVyLoMj5g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZxzCP1Z/2xOIxXSKTgLrrdvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2M2ZDE0Yy1mZjY4LTRmNzUtOTQzZC0xY2JkMmMwNTE1ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjQxXKlmJyKDtOAqH6Ma8Uj2X9xsyKAXM4L39Ux4aBvK8K\nLa1SwhYkYYUq5kg+pqiPj0mDzovyqTqKDJRff+bNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGhHPaCGZtEs4PlB1a6IWIfgK\nAeIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPbS6IJLs7awWTV10ydAvOK7iV8P/Rt3Zaz6IOc7lS9RAiEA++DqZT2K\nmEwSvmRDxnxPhKmK4ZRw17lLCvluFIVx4cw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAVtWCHzhN4wfykdihuq4k6OQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNlNDExNjUtMzBkNi00OTNhLTljZDYtNGNlYTVkNjQ1ZTFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxODY4YmQ0\nYS1jMzJjLTQ5NjgtOTc5Ny0wNGQ3YzBiOWMyNjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAART7kazS+DPZBj+xNNiQovDqC5b7r9Jdklnyk6+H0S0Nek+FHyrDU16\n5slsfnZz4BbZGaPBKMvAVcoo3/XgHbHgo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRDTvVX\nBVNdcPiJbbUJnkbZoyuj0jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAuRtdAzSV/jSu38yQS/7gDJAXA//pyc1lFKa6\n4M7RigACIQDKL9vYC/IBW87agBPkJExVw52FeiDEiHiDBdZ5BkTCzA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6209", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6209` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZuPEpoGso9Jyy/4xpf+fJODMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0MDEyMjZkLTUzMjctNGZlYi1iNWMyLTVmZjFlMzdhMDZhMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTAyZjEzOGQtZWI2\nNy00OWFiLWJjNDAtYTc2ZjQ4ZDhlM2FmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqFxjv2x4aVYtF/olQq3qi+qEBtRaa2v7BWpVMO+uUGFywRPvO5++GI0Ywt0W\nSVq1sYJVk4DH6sClDJcksVzM2KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT/HDuQtkh91amCQqFkkFI3EDyoowHwYDVR0j\nBBgwFoAUbxXSuPLNlI87CG96IYv7+xtUOiUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCeNkF1pOqqgMQc9w8B8qo9tpjm4t6avEL4S5uWiisqdwIgUd5p30U6+VNk\n0Kh43AsZEcbc+una8kkRmPlvPYPPodw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXpfJDWN5HBcxVKfWT9ng1gUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDAxMjI2ZC01MzI3LTRmZWItYjVjMi01ZmYxZTM3YTA2YTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8PFaiFNloYvu/Q//Z4+840gfLugneS9zeA8SS1ONPglgl\nGl5+gTlQoMjnBgW9L09KODAoZYQRFCq85wiRqt9yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbxXSuPLNlI87CG96IYv7+xtU\nOiUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWR556bFcwHwDTtm0FNLqa8fTxsrcN4OtPmVNHj7ginoCIB+LQUdZ6l5l\neeslbM1SoN+eCtdZvKSNaSRloYCxSDc6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeRtPeu3e8furFMhiSUdXHH1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTAyZjEzOGQtZWI2Ny00OWFiLWJjNDAtYTc2ZjQ4ZDhlM2FmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlOTJmNmJi\nOS03NGM2LTRlMTgtOTEzNC02NThmYjM1ZmEwMjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASxZK52HgqpjkREfJViz63MDWcJ5yrNKZiMat2X6mo9ztMgpq60Wvd0\nFkeG07Zx6c0V6QKn60xkopU6NzI/H35No3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRP8cO5\nC2SH3VqYJCoWSQUjcQPKijAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAujYqSYV0RnC4SQsqc7wzDcbw+lRatLxwd7V0\nn0kuTpMCIBsV4ez2KUkQc9kXqHqgj1Zb1y23Dcel0CXEXt4+2HMI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6210", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6210` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASKVAeKcdpZ+KFjDNrwjVQj0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyOGY4NmUxLTJkZDgtNDVlYi05Njk4LTYzZTZhMDg4YjhjODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY2YjkxMDMtM2Uz\nYS00MzI1LTk0NzMtN2Y4NTgxOTNkYTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk3oicu0sLy3nbzAeLXFFU0mUFAwafU5/SSL3Q1PWalqm5jdn8Bj/D2r+kXOP\nNbxpkaLknpBmdN/D55THCqFCDaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWNnnl6CCx7fIncmsHxeJPezcbQQwHwYDVR0j\nBBgwFoAU7wjAMdZXz7iGFTcWDaniwU8i3hwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICB4VEzFccCl2mEPb6JTV5YQNAlRtSHu3q6Ds9TMhuJKAiAvE27vIZvsH5vM\nG+6a+Gjp0AjM7RUk24KA4arKa3S4Ag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAewYbkpkK9zUatWCCg5D7JFEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjhmODZlMS0yZGQ4LTQ1ZWItOTY5OC02M2U2YTA4OGI4YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMHvYpMXcG51mF3wgH7SRYZGGr4ymbMRSfppyhb0JWkPjH\nrXxaGRpVykZg2/nEkkzNSoXIc9guWs2rYsnZuH1Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7wjAMdZXz7iGFTcWDaniwU8i\n3hwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEr2+xcUBMklMRIkQTdTw/+OrriVNSvxxwyL4vCTxFQ8CIQD0+/ioDMBU\nQZT4HG6n18asuqSWrVog6qClIai3Z6WSXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZsO163k0ZqHLUAWtQmYI/o8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY2YjkxMDMtM2UzYS00MzI1LTk0NzMtN2Y4NTgxOTNkYTNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZWQ1N2Vk\nNy1mNGRmLTRmYzAtODU1ZS00Mjg0YTQyODc2NmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARgIki4SUS8iSWq4fLGoVLcoL8w/w9CogRwhTC86AMpSs49MiUmr3IY\n9NaYTUR1oT3dCpdeQQX2PmqZnKNZ3Z86o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRY2eeX\noILHt8idyawfF4k97NxtBDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA4mCUqCecjTKZtL47CONy9XVvLHzN0oR2OULr\n9t/1R6cCIFoomUIY0b4b8CUcSrDcQimT2jjr3NA2wQqLTr6Vb0fc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6211", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6211` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZjdsc8iqGjUCQHxZAFuF6t5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZGEzNWM0LWY3MGYtNGQ5Yy1hMjY4LWI3NDczMDhiNWZmYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJjYzkwZjgtZDQ5\nMy00N2EzLWEzNmQtNmU0YzJhNTU3YzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESayU0ZeulZxLhWJ42+DHIy0BdwqSLqXzF3rYiSsqfQZ9/ghGFUzfW+LD9ikr\nvnFX+dwWRFN0eKQuJmYAGdfa6qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx0yIjl/hMfd0hg8utI+gSHp5Cc4wHwYDVR0j\nBBgwFoAUTqOWxhBiEs3lr8k9y4Do4OHC5yAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiA4A/JKtmu4J1P5hUETZl61kioYU8QHZp/9o8rAEkm3zAIhAOxNuks+of4C\nppRz3Mfn7KpQamq9vVCE5z3dJ/Bjdq4r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUa18IOnS4YqMauKmwbLONH9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWRhMzVjNC1mNzBmLTRkOWMtYTI2OC1iNzQ3MzA4YjVmZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQq5Dq3c9KoNH6MfWviuYgF+iRDxyTdSF7SeMcRm9OrFBfE\nBhIZNhFIlc3SVfC8C3bKfmmXcn9c0p/1t56rUDapo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTqOWxhBiEs3lr8k9y4Do4OHC\n5yAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO7ubvutzdbVOYMi2NwQ6io4GUXTzRAiVbtbzsbuPYtsCIQCc879qCM33\ngK+v8fJRPD0fMAWMHH1+Ii+eU5ANaPlcKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAQeWmOouP3/wzC0dZ9n3rxaeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJjYzkwZjgtZDQ5My00N2EzLWEzNmQtNmU0YzJhNTU3YzhiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NGQ0ZDIy\nYi0wM2FjLTQ0ODgtODUxZS1kYzEyMzQ1YTQzN2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATA0LliJVros2GciDh0B3uM8HWZDzJVJxAwaUu/4TWnC7Mz3t+uZSFE\n91WOOfkldVe7P62nW9UQlgYcykouyYEko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTHTIiO\nX+Ex93SGDy60j6BIenkJzjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA1Ef+g7RvZ9dRGzc1TQGnUWtUOvhjBpIxwRZQ\nG2czStwCIQDU0VnxmJv8bjpy+QzIFg2cczdCB2MSDQU1fLg9uNEblQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6212", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6212` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAa7GMtDZCWsP4rKgZNyBhE5eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMTY2OTY1LWY5OTktNDdlOS05MGJlLTM4N2Q0M2U4NWZiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ1ODdmNDEtMDNk\nYS00ZTdiLWIyOTgtMzIyMjExODI1NzUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhhuUfRQLV76Bi1KoTnStQHzzpfA9jKne457Rytxr4bY/UwqdfKWNjs8f9fu6\nFf/iqzYiki+U5/B16j66rZHhrqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTpKEVrlPvSGhNgdmegPsX7UxCSUwHwYDVR0j\nBBgwFoAUiLwM27tB2NA+XJNMG4T3OR8C1+0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBQeG3DP7MR8L/4PsjDNgUM5g6Qdb9rm8vqAiEGr9ly\ndAIgWJi1j9+JdTAeNKVMTptEGQg5DTwNpkaWK+rFtr5K6hk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASQuJqqhSfXfv8BkLTjpupMYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjE2Njk2NS1mOTk5LTQ3ZTktOTBiZS0zODdkNDNlODVmYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+A/sJ6BsxNNexrJ9EgMvkfBMcdbernF/Ks2IbEsZS9hix\nvEV39bx7DWJ0KfwUU3DpOurlbFiY+SzyIIKa6232o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiLwM27tB2NA+XJNMG4T3OR8C\n1+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALtF+gN+BF3rMroKFAnaHdqshIYeUw8nhw395bxZeEZHAiEAtd0sCy4g\noj11ZXH5k6RwMfqDQzjEyRSWbMOsOz1V7V4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAVS0xMls++CgvVXGSuQPc07AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ1ODdmNDEtMDNkYS00ZTdiLWIyOTgtMzIyMjExODI1NzUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjN2YzN2Mx\nZC0yYjk0LTRhYzctYTdiZi01Zjc3YTIxMDJjMTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASGakwNBp42dVvP9V75U7lhg2Hz9jwyZT92HjWYUubaSCDHM4OT70yj\n/5b7qmWxbuuerLlPRB36SEybhkLdzmSmo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBROkoRW\nuU+9IaE2B2Z6A+xftTEJJTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAUvsFsrOcTm7gAv6ysgPKzhly4uDVNULWKl5Ov\nQF0cyQIgKm4ixTJE17vOeWX4AfQs6UdlZ7ZPJaNz0eeh8mXYNGY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6213", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6213` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAeiRF9POqWhN27Y3oNGEljbPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjMjA4YTczLTRjNGUtNGIzNS1iNjVkLTY3ZWU4ZWNlODNlNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZjNmJhZmUtZGU0\nNC00YzBmLThlYzctYWRmZWEyODJjYzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5GSf1th4rYse58aBsLPSMCY7/CFZse0b2CLYe+QWLjLQ4rrfIxZrGlQxO2VP\nFKkCUdE4M6DIFZ+XTaCP49IN4KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcsjciezOPswSz2RvdOk6ZdeiP7owHwYDVR0j\nBBgwFoAUkj4uicXYouQW32Y9r7G0yTuwXIwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAzn0jqJ0kPkXBnPAmw0/Za442jma57vysn9ciuN8m\njtECIBcSsrU1vMLyvmGsGvHyASLlNcqWU0EBGkD1fGm6g/Cm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQdZFPhEln7baFk2ybVNRimKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzIwOGE3My00YzRlLTRiMzUtYjY1ZC02N2VlOGVjZTgzZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARj/0Sa9dIK0QIX5l/ICFBTyfJcSvm4CIVN9IRxpk+YGpZt\nozB8y4i+KttyAirUBUyq/auE3QKrKDgURUToZBfuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkj4uicXYouQW32Y9r7G0yTuw\nXIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPAIU7T9hqCZ6PAN47HtdevrjK/cj1oyqKRUJazjm0OfAiB4dzmr8Q/k\nAcghHom+2FjJFqSlnccjkCMY7LiTLa5l+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAbcq0/bu9GLqYjx/J6eoTGRcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZjNmJhZmUtZGU0NC00YzBmLThlYzctYWRmZWEyODJjYzU3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwOTNkNWZj\nOC1hNjdjLTRhZjgtODllOS01ZTdhYWU1NzQ1MWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARchw8muRXVa80s1Egt+k+x9K6qTMVDN/3wahrIUtht0l/lZpTjUSzH\nk0ZkqWLrFzgc7miGLofQzihiy9n1GfyMo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRyyNyJ\n7M4+zBLPZG906Tpl16I/ujAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA877/ywL0AwWtfsY0V4qTM7pImEEOnrFfxvnw\ntZO8En4CIQCL9UYFja+sNMa0DAGw4P4GEvwD5k88fU4xrFaugLdHiQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6214", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6214` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAVtRXFMEWE8XRZ6bWAsrGGPdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2NmQ3NjM4LTNhYzktNGYyMi1iNjQzLTY5MmI2YWE1MjI2MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2VlNTM0MGYtNDFi\nNi00ZjZkLWE0N2UtNGRjNDI3Yzk1NDAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6HX+8Yf2y7oGbmgHq1u1WOUxL6yneHaS6MjHMgORHWf/4ZfFrltcBxWRQPPs\nHdwgOI4teXhZqRunjZ6k/OeQoqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNn4UgMsAVWhlL4cKZXY2hFxmAxMwHwYDVR0j\nBBgwFoAUgDSMlV0QLi1Y+77BNImXScr+SC0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAzX/nnMw/gg2Kx3giWxlT4MBsBp3Nu3+twYcP15o0SmsCIQC/\nD6xRt5Uc1o0alHjn5n2XHxeCBQ0Qf1I4kx1ZpCtZtw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXywRwdVFmbF2AaSahCOBzMDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjZkNzYzOC0zYWM5LTRmMjItYjY0My02OTJiNmFhNTIyNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6NuCvmzUqLu7jnXmhDPsuuCK869AKzGc8MAYap55gfyUq\naMxcgUOiBt0/0hElrCV3PoDlm+sZ6CYEsZGUsaoNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgDSMlV0QLi1Y+77BNImXScr+\nSC0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALygmQHhO7XNT3ng/HeFNsP1QUIb/RW7wQkSWyB/f3vAAiBsG26Ot6RH\nYgMginuTQsPtN8L1XqVdPsXcyGExgVs3zQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeVuHFQmX5C/fbX3nmGMvm+9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2VlNTM0MGYtNDFiNi00ZjZkLWE0N2UtNGRjNDI3Yzk1NDAzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzN2U4MmI5\nMy0zY2YzLTRkNDgtOGNlZi1kNzMzZWI3NjhmYzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATuYdiz1IipDamIupeKa+gZiZjVi+qEccbFHMP8+CqaHSACm8M2mFfP\nAyS7s96r0B6PwCAWPOwyOIx48OLV1GxYo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ2fhSA\nywBVaGUvhwpldjaEXGYDEzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA1h/SFuM9RituFM9ehIdxMIixvAB0LbWzbEDt\n/eTvUxQCIAo2dI1p6oXd51e2GPKtSDpDQGWVM6zqpWFFfZnhAaYw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6215", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6215` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAb5joxyAX/aFOvziNVCTnnvCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3ZWI5ODI0LWMzMGItNGUzOC05OTI1LTIxZjRkOGFjMGE1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFiOWY5ZWItOTJm\nMy00ZTFhLWIzZDQtMTJiOWFhZmVmYzY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErplidVLkAExV6T67tCZUUzXea12ioayob2/mzNQ/E+I979cFfRMXXhnJ7qF0\nIfrdDDNVA5FgFslbyxRSq27fgKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiJ1ojKHlavi3h5MwnODQfHsImpcwHwYDVR0j\nBBgwFoAUyUKZnxnL/3NoWvialHw1qZ4wP7wwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBV/h3czmND4cWTvJ7rBpV0EDQYtuYJ4W3n\nPmrfcyQn2AIhAJ6LxeG33CAF++u/y2xdLprG+a2Em93ij2aqgzGFTxlD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYTQErCTAPOCg0WR8Q0M8YhQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2ViOTgyNC1jMzBiLTRlMzgtOTkyNS0yMWY0ZDhhYzBhNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUHVXZ+NTp0s3dsrgphf56kQHeqNO2GFlNVLjJrgTs5//r\n28lCYgOtK5a+MSEyEygMyhD+AQjkgTw07vgUU6vHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyUKZnxnL/3NoWvialHw1qZ4w\nP7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJjeFOP617TfpAly3Ywpf+Tq0yUrkO1FITfh4wyG+L3wAiA4V7OF1+ln\nza2PFhMtv5oFJ2UhPDArr+TFbpW3kg2D7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdMG8dN+YYXZcuiAK0x3cNb3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFiOWY5ZWItOTJmMy00ZTFhLWIzZDQtMTJiOWFhZmVmYzY1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5OWZhYzEw\nOS00ZWNlLTRjYWItYTc5NS0xNzU1OTM0ZTViOWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATIdlaKgaDHee60uJXig8x604j7wr3iarPGwDJzSi7mdVqyembgrkJ6\nGRdaNcl8M7IMFPlRCGJs2pGSZqfmTipyo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSInWiM\noeVq+LeHkzCc4NB8ewialzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAtgAbbFEQYCEXBIe8Nf//TzTq4OgQnJe6BTVV\n1J5Jn7cCIAx5T2YQFZgkeQ2eGLoOpPdjpMCBUXma/xJN/IjJX6f1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6216", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6216` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXNP/zmpGMX6ebBuLRG5J98JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzNTBjNTI0LTYzYzMtNDg1Yi05ODgwLWJjYzI1ZGRmZWU0ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdjYThhYTgtNDQ2\nMS00NTM0LWE3NzUtNDAxN2I5NjAwZTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhqf1xxY/iOwDlSCmJCUxuvlig1YcMertdU2um/jP+LdqoUa4oCCCV7BO3zpF\nEev1kHIRdnPjEKnj0Mksae2M8KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULu7mSAonn2SK7r534wl9+5lg1xEwHwYDVR0j\nBBgwFoAUW6TCyyFWsiC22wYLIp7usoRnDR4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBX4LsFFb5TNU/njifP46F0T4jEvC73wwS5\n3FyBadyI+gIhALEvNVc9izeFE86Xr+DGr2fDx2pIVXvnQnbbhsUrsfu6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc8ruMvvc80T7szOVjXzW340MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzUwYzUyNC02M2MzLTQ4NWItOTg4MC1iY2MyNWRkZmVlNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTGA8uVJ6R0wgq2bDOwwJjbNvzkztytV2vgDjxZusvVDP2\nOKCroWlIvrMAT9Ixx1rPzYq/Be2rizm5HwDWI8RFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW6TCyyFWsiC22wYLIp7usoRn\nDR4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWI1J5JVYdvWOXl00njqeeLKXZGnCL3aJbP4dtHzXt0ACIFtEuqecqY3d\n+uTFqrC5K3b/y3b4Lg4MHiCOAaZI1v50\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISARoFTWCElyaDO214IN+kqXJiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdjYThhYTgtNDQ2MS00NTM0LWE3NzUtNDAxN2I5NjAwZTEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMDExZjE5\nNy03ZjQxLTQ4M2ItODM1MC03MGE1ODM5Y2JkNDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ+mV2knkYhbWtypRP00JjzLRVw+3pPxA5XL92+V24kgWNK1zTfurXw\n8R7N6kgCMgUfxkViLXsBRHGXM3g0DT8Io3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQu7uZI\nCiefZIruvnfjCX37mWDXETAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiA7y29W+v2BJcE4MtROncxYj7BfpZ82Ryqb1Upd\naN6j9gIgAbtMcEM8JxQeU4xH2Shzfcab7C2L50NyGO9fOY2bJM0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6217", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6217` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAcU9P26d+7t67GJKES9cEr/tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmOTZhNGNkLTI3MjEtNDRmYy04M2MwLTgzM2YwNTBkODQ4OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVjOTJiZTUtYjVj\nMC00ZGRiLThjNDQtYzkzMWJlMjJiM2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ2BjdQvoMaqTEfvI+H3oFRxjswmFC+lvEDw74GffN3SWJsSaFhL/5Hk0QLJT\nZoRDsjPvjgUzGQxnxht4k62xPaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ2Dk6qGw9HEZrzUPo+5gXctDkugwHwYDVR0j\nBBgwFoAUzdvLHmQ377Sr/WP9TCR2/yFKARIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCQLUoLBkeLMXKZUsJ3YznIhrV7\njIKdztKQ8qUl9ZamlAIgJtdCnuqb7wPYyMiqDyj4q5z1iTnNRZAhiJylE4t6Hqg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR98dMREvKJUjWza2Lzk6XuQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjk2YTRjZC0yNzIxLTQ0ZmMtODNjMC04MzNmMDUwZDg0ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8fIfDSmS0EoWGAwsDWPbDbCyg5GtKo/6rTw0vG+BseGHc\ng6EoTFA9E93Zwgjv+/4xDMfwpjUZLfscf6RiuTv2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzdvLHmQ377Sr/WP9TCR2/yFK\nARIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJTuJxByQ32yzAEWNYJP2cSpYOxsbSGm9yi/DZ8X51ExAiABP3gJWH3F\njrHHRBrdMWjI5RlImn6PYe31686+9/7lpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAULk5PrI6KU0RiCViKldV/gMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVjOTJiZTUtYjVjMC00ZGRiLThjNDQtYzkzMWJlMjJiM2QwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYzJiOGQz\nZS0zOTEyLTQ0MjItYTRmZi05YWY4NDhlMTY2MzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATlaoBY+GPG9JYT0akue5hSZMhwRoVeabuTyRTfIhSw6cQEudotjBTz\nU+B2Gz2qwxpSs3UlfhGOUefBynOZQReEo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRnYOTq\nobD0cRmvNQ+j7mBdy0OS6DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA1YXpB95+L5HjXbLGoPllj0HeczRg4VXp6uC2\nzoa0izICIQCEXOGmWBJtiAvOkEq44WlT3Ql83vxRfK1IzjpvK1wHHQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6218", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6218` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISASFQrQ+bA2VjkMb+YZLDUwHpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkMzQzNDE4LTJmY2QtNDY4Yi05NmM0LWVlZDQzNTUwMmMzYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhiYWIzMmItZDQ2\nNi00MWI4LWJjYTYtZjc5MzIzNTE2YTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYf4oduF9rcXlwqRvQ/yT8sBOtNNnzDaNliDnnjjQc1aiId4yIzUiZ1zgbHRH\n0RH993+mwNZ0+S9PmQ8ImpsVMKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuE0MWbfmns+/Rmi9CLx4TjbP508wHwYDVR0j\nBBgwFoAU6INRI0VHmSu767ooaTqpUbTkcCgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgap1l471F\nWag6auzLQ3I2eLbYAwNRhKT34S0aR2BNIo0CIQC7PtZLPUly5THwO0kKEQaAywFH\nFKLHJZ7gCKRsluvQCQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARTs63LzfB9SiDqded+Rd0NKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDM0MzQxOC0yZmNkLTQ2OGItOTZjNC1lZWQ0MzU1MDJjM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZihRsnwxF9v5u3+2BR/J/WwO9Q8D2Lxs67OMDv99IpHfR\nkcp/CdRAtuLCcORzfCgw8CVNS5WXb/F5AZeB+yKso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6INRI0VHmSu767ooaTqpUbTk\ncCgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUpcJdEkq6MSjI8NLPbvvcLRlz/rssScwMw9OeojKG5ECIQD649ak5zwl\nbbeyRvmMEU37UoesC819jPShDrghJ5DvdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAa0/zzIPdjnvpeqLBUoYqFRsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhiYWIzMmItZDQ2Ni00MWI4LWJjYTYtZjc5MzIzNTE2YTA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjODJlNDcw\nMS04M2ZkLTRhOTktODNiMi0wYzI2ZmZlMjZhNjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQd9L7I/xm57oyJJAWZyt4YzJD8cMSvP/TDayGacdhIDKZdMN2Q7psD\n/IPAnsl1Fs+dwKI6r6tKANC+A0XXkPWoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS4TQxZ\nt+aez79GaL0IvHhONs/nTzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAtpcQrJ6bu/Mir0ryrOOF/FZbgVo/Hn+l8IwI\nNbQpZ5sCIH1wXBkqhWG231s0Uk/w4NWaqBAkB38aOh8oqzmnq4G8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6219", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6219` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISATb8gCz0u+FyGu5RY7zDWt1vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MmYyOTE3LTM3NDctNGViZC1iMDI5LTYzNTZhMWMzMTBmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBiODIzZGYtMDNi\nZi00NDFjLWJkNDAtNjI5ZGQ4NjEwZmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3v+91toEdsKqvPQDj07Yu7zrb/MDJ/emweIif/OVsUP/f5kmLkhEkPReUaUj\ndjfePOKk8kDjkWr5MvnS6oyqQaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkf2AmxGL+LQoVvGUt24pP/Ut/ggwHwYDVR0j\nBBgwFoAUjYLy1vds3wobFXxH+XWDle5ZWAwwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgHk2x1MSH\nIiH63e6tFw3kJCQBOnRtKd67BSaksriCHKYCIQD11IHZFAEJ9q8QDlUfQObI+rX+\n7vzmiCcYQRe0GvtqhQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQngm4nvsNoLrEFDutV28ibhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTJmMjkxNy0zNzQ3LTRlYmQtYjAyOS02MzU2YTFjMzEwZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7AtpPhGkgijYEcfZ2hrppG4pPdJO0sRRLrZ+PQga7a3b7\nNN0s/UeL7l1qM2B2Oy6beuKTEvbLz3qacYOUsuuYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjYLy1vds3wobFXxH+XWDle5Z\nWAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANI8D2l8W33BGCjwAHg70+mQ11PZuFBLPeOJnuFbmykfAiEAnz8Hz6GK\nc9B/zT1uZ8zyswemUpPYsWNrkLyh45LNbLU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdBvx51eFWl9zuM2Z2SuJvPZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBiODIzZGYtMDNiZi00NDFjLWJkNDAtNjI5ZGQ4NjEwZmE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZjQzOGU3\nNS1iOGJmLTRlNTYtODYyNi05YWUzMWJhMTg3YTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARcQ/fsKmFcZr9zP8VFJozsEMc6DOEaakrKloIKVrgyOBQ5zPDAoXCC\nVvdFexlNJOAqvJE9mUstbg3VITqTO7DLo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSR/YCb\nEYv4tChW8ZS3bik/9S3+CDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAuQk2NcmoF1ymAxYYBJIYiYrJLXnOvMATF68Ca\ncpvcNQIgEVA3PIwgoe7vFDDtFAmjXnYrJqzL+VpscTWUnvsRnH8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6220", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6220` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAWGmdR45aKHQPQYv7pkgNLZdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyNDcyOTgzLTA5OWItNDE5My04Mzc2LTc4YjQ1ZmQxZDE5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU2M2NhNTYtNjVh\nYS00NmExLWI4MmEtMTNmNDMwYjA5ZjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElvfDKOsPtFhMa3AxBr/OlSG9iU5AAeJXCn+RyFCTWe18FlAVG7yz4ln2k5q5\niQvye0Uz4cyv22CK2vyzEtpZPaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3wGiK7ehL7ASXXEEy7Y3xDRWH/MwHwYDVR0j\nBBgwFoAULU9dDnIFKVYV5vDl6X0p4FyKVoAwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIF7dB9KO\nMZ7ai5kW22aeX/98uXh+7mao2ca/1Y8+Q2gIAiBXCJu54KEP2ZNVnkYoG5WC4RHe\nEvDmHHiVt3Fb3zHBHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW4Vyh5KLFf+SJZMKtK8mn6oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjQ3Mjk4My0wOTliLTQxOTMtODM3Ni03OGI0NWZkMWQxOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDB+1/xw03J602A26JdijsfrHv8mpqqOQLA5T8IR1cJZ1m\nuKMqyp+SXC9rS3dn9+Db1QFQtKxIsNfvvH81bWmSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULU9dDnIFKVYV5vDl6X0p4FyK\nVoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEBy5d/bDxoIsyuEJUkDClMOV81WkbsB475G0+j7dRTQCIQCOcqxBzw3t\nhDZ2L6ehIl7UND1iEaCqp1EWvi2sQ1MkdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAeZYsM+dujU4Nid6yTN3IaHSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU2M2NhNTYtNjVhYS00NmExLWI4MmEtMTNmNDMwYjA5ZjQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NmMzMTZl\nZi0zMzliLTQ3YzktYTZmZi1iOGQwNjNmYzBjYTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQnJudxXqJZ65SUpQqcWLT2wdYo6b3EUlHgTatRzwhN2LhdKCF8zcQh\nrkxlGcrFJPwR+411Ed5uW/WXt8S40T0eo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfAaIr\nt6EvsBJdcQTLtjfENFYf8zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEAohwIm+fr+qpWDQV8lxcJKOqeIuBpAQX82rfX\nMBWoFpwCIQCucCc0cPwgshcHwlU7jY71QuSPxa3FcLFHnvc9+ndnPg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6221", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6221` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAbHomU0jUY12KP6fNUkFfpCnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNWI0ZDA1LTRiNjYtNGRlYi05MDE0LWIwYjNkZDg4NzBiYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgyNDc4MTUtYTIz\nZC00OWNjLTk4OTgtMDZlMjg0MTA2ZTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE50wvo2XHkVJGesJM2exaK7h4RRGYQ1W70OVHsyhqSwxglj+x3LoLYr6QbOJw\nlLMtUS+vTSMqV6O6zx/ODxL3TaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURfSSTkFXRvF7JkD3683lwTzP924wHwYDVR0j\nBBgwFoAUNwmFkFcCaYqTX8V/2efuAcRUxYEwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIDCWdarhUmTXydP6CyD0DZOsrAE/BX/9BnPvoQDH6HSPAiEA+fEMzh41\nS80TKvYM9ZESWLoPf/O+4l4EXEEMUNOgUyU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV0hNDG3y+gJl8H8vfwinkowMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDViNGQwNS00YjY2LTRkZWItOTAxNC1iMGIzZGQ4ODcwYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8tUX5pskD6iPLxliJxCWzUGacduDFhEJNGdQkQrmIdlnj\nh9iE0U5nKZPi59R0b1xePIUNbjl6EqDgowD4knY2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNwmFkFcCaYqTX8V/2efuAcRU\nxYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCFRX3T/7546Y1ZJQ8l3Tf2Xmm7hROYkdYYTMt+8X1ZsCIDPiPYUtdXLB\nPd4DEhxu9gt24+TGMCTeDBk/I1ZltF6g\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWLbG5h3G47urVWns8E2Mv4AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgyNDc4MTUtYTIzZC00OWNjLTk4OTgtMDZlMjg0MTA2ZTBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYmQ5MTI2\nYi1kMmMyLTQ4YTItYjhmZS0xOTMwMjk5NGQ0ZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATkHc1sxTdfQ8Ej84YXscBUhKKzOSAdsZ57XaYx0XqVIMbYo/14HywY\nn+imEP4YNVeply+oYwOx/M26836uX3ayo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRF9JJO\nQVdG8XsmQPfrzeXBPM/3bjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAvdK7r/6yZxUy+VRLG7ueACIOfjmwuaguxcdF\nqC7KW/UCIB3r7lzsWgOzL4w8I5o2wQ0vatHJpu1OCGxBysE18wDd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6222", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6222` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAaAhU0o8tPS9Zi3AWUiFESeuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5YmU1YjYxLWM3ZTQtNGI5Ni04YWE5LTUwMjZlNTk4ZGVmYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzcxYjE1ZDYtMGY3\nNS00MmVjLWFiN2EtMWI2ZmVkYzMzMzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHD42DDT2EYZNgOWTgYC1nIptG29yg5bztbsCIP38TDHOMdKEiGk/1IUdr5CT\nXsETCy1QGoaGhxh79eF+b67cJKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAtxFS9GWm0Kz1+tQ5FHf5D5vWncwHwYDVR0j\nBBgwFoAUPEn/vx+o7cR4QmrcuyRdAH+dASUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCw+FPCjhpbkZ1zAWakfGHJFeiit6VRoaSPmIa8z84bWAIgJB0LBvJO\nxd+w8Hpv0yz60F3BfhUxd4FoE/Y5P8q2onQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXiRqVgMoNfKMVutqzUDIR/fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWJlNWI2MS1jN2U0LTRiOTYtOGFhOS01MDI2ZTU5OGRlZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGGDi59OUPUoN4og24MUbpiS4pFrHr6KAnqtMEOl9Lxo+r\nSwxDYHzunASzfXIwl0/QS8zA/rdiMJpODbckvYr/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPEn/vx+o7cR4QmrcuyRdAH+d\nASUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALlij7x0tUGcq98rFWcNIoxxiw+rvwfTSNIMvQHPNnAhAiEAgFXp45/c\nFNQMUag67B306NG7PyV/pqQpnYdlHmPE6M4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZhu60l2g3Dwthcs0PrC9seAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzcxYjE1ZDYtMGY3NS00MmVjLWFiN2EtMWI2ZmVkYzMzMzVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NTZkZTI0\nYy1jMDg3LTQwYWYtOWY5Yy1iYjE0Y2Y5NWZjYjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ3Qobl2erhW6XhFY77JSOHhtwwFk0Y2U7wIdC9fVOvTjvi/0lgU6CH\nGFQesR3I5vhz7NfhDRxXouo41KQAJXeSo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQC3EVL\n0ZabQrPX61DkUd/kPm9adzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA/OTrTB09Eg3i0aJfA6Id6VpIfzqmLPDQcP3C\nTeJ1UZACIGuQ0wzhWHitAReNeK9j8W6UMmgBZPaOx0llPj3pyhJP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6223", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6223` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISARZbrSnXCRpskDmw8h17zUUdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhM2MwNmZlLWNiMWMtNGJkMS04MTQxLWYzM2IwZTNjOTAwZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjIwZGI0NjYtZmE2\nNC00NDNiLWIzMzMtYTkxOTcyY2UxOWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEey/AF5yFpAat/9ZpMygRbZQe7OTZ7mqp3h/NulTouCZqiB2dxvMln2wUBu/Y\nob2REGDZhbm04+33lP0i0WFEDaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOTvY01dM93XCwfzceYs3FZKDIMIwHwYDVR0j\nBBgwFoAUqo7R9R124uZtuvZzdWu7GBEhzBIwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIG1x9HnRrzvDlAQCYK2ACMef+c5bzpBunGHJasSW2KwRAiEAtmDmHjHssNX+EeKD\nUXg2MenFDEjnGfVr+r3vLJBD5uM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVg4b9VNzz4LvVmh2Rf7sIHWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTNjMDZmZS1jYjFjLTRiZDEtODE0MS1mMzNiMGUzYzkwMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLwNtt2AvtHHG+SNWpmY24A8zw23cyHDCXSc7s6pEIvqtx\nvnLAQaXfAhIZkzGCbKTyt32Xbny6zfvRXqCZoWgjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqo7R9R124uZtuvZzdWu7GBEh\nzBIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPZH3pJJSFIuPxP4XK/4hOFEI0/fq8skvhYr7cRWp2WYAiAaS6NZLpl5\nrMxGqisoA91hXPHF7bFCStiqdFjdBQ0Uow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAaE52DsgoW9SFAlh7ha6Ifs8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjIwZGI0NjYtZmE2NC00NDNiLWIzMzMtYTkxOTcyY2UxOWU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZmZiNjZi\nZS1jYzYxLTQ0MzYtYjMyNi01YjI2MjNjZTQ5NTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATf4bDjiPHw2rgwxqT8xgx1lEDGJf+vqSZEK318L6rEMoVBQrPYgEab\nCSY3aufl/DD6vAxDq6iv6nr3Imus/UvKo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5O9jT\nV0z3dcLB/Nx5izcVkoMgwjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA0aLQUuShU4ES/DmBRvJmzxem/G2+hQZGzUL5\ntVCtbQQCIQCz7Rj6NGNRur4BN+QJzPDvDX3R3PnVsaSiMu76z/RJYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6224", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6224` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAQ9aV2o2S2+S2DLsOSapwxMCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNWIyY2FkLTRkMDMtNDA3Yi05YTkxLTE2ZTg0NDFiOWQ3ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA4NzAyODItZWUz\nNC00OWQzLTlmNjgtN2QwZmNjMTdiMmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhmiSbXBwVslucx8kPhYMNr+zuwxj0lRhTPMGUaONVp7cFNaVS57SmH6g0FDU\n8FrFyx0TWTK1+qwLapcs+XKgPaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwTzlT7rYWIcM0cspnq4s6ffMhA0wHwYDVR0j\nBBgwFoAU9UgXSY27xkxWAJaqByyHF90dTUcwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDdGQUNGcFtHJ/HqJ98v4E2SxvKBbVXnAUjkfO3rVdclgIh\nAM6Ton5aMOh55zmA8nr/ArbvWKnUGTycukubSHQn69vR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQQ1/Q3DKns9hru+AAMQrdnkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTViMmNhZC00ZDAzLTQwN2ItOWE5MS0xNmU4NDQxYjlkN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNzoMvwiM/+2wiyrXVJp2cD+z1NC/ulCOAqp8zIf81Kyrc\nUCYBmWHUYkxrq02oXJUlnSiZ2H8RQceJ+n9hPpTSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9UgXSY27xkxWAJaqByyHF90d\nTUcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfyiyvMN7ZJSarHPx9TkGClbN21lo3uVYNrWToPc/9qcCIAwB+3eSnFLQ\ncm4QebFBzBBJj1//orjgAM82YnTJwlzM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAUG9VpOnL8yOzfgdUkOluVivMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA4NzAyODItZWUzNC00OWQzLTlmNjgtN2QwZmNjMTdiMmM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwM2JkODM0\nMC1lNWMzLTRlZjEtYTRlZC02MDA4ZmViMGE1ZGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATc3o+FWOipibuUV8Tj5T7r+MVPMsDYyKi40RkFwj/u2rd8Py3soDr0\nzx/x+cJtOUQQJIlnTHIjxRVfuePnLuBLo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTBPOVP\nuthYhwzRyymerizp98yEDTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAiJUcYJQrBA4Hn/XuA4UzI1hXAF6zdaiUn0uwk\n01GPeAIgOj/Wur2wVqYMeJVA5oo/2/lSZk18SsrqWnjcP4zoOv4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6225", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6225` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUVy0CLgPMBGPuKPioWJLKN/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwYzMxYmZjLWQ3YTgtNGU3OS1iZGEwLTUyZGY0ZTI0NzgwNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY0NWIzOTUtNzdl\nMi00NTFjLWEyYTUtYmI0ZjFjM2Q3OTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9adY/lBnrfXqWqzakDREBhCLxJ5STR3M3a6RC+XsBOYAzjNfecNsLlhwGHLA\nVojxmz6ZRTYLWj7sD4OCoMIKUaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf/flDvqhCRptMK80yczcRsGygHIwHwYDVR0j\nBBgwFoAUQIi968RfGvDad5RJ+zDQpMtcUlcwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIDBSXVpgOrcEAp3QZcNOUa8iK8dAHBGDRBbtKiKmzcsXAiEA\n8cN4qa5NVjUTiVFJzEBv0eQimXb1llRqT4XYRjzueag=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARH4CdjW1i35pCfVjZ/eJGCaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGMzMWJmYy1kN2E4LTRlNzktYmRhMC01MmRmNGUyNDc4MDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTr8jk2uDx+DoBJfwe1qSjP5g+S4hBBFgvEbRZpuyHm6lM\n7M7ZmfOLLnfArGW7bPLD4rFC/WqY7ztcaC6ah2tzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQIi968RfGvDad5RJ+zDQpMtc\nUlcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALGS8wGTUnoZTDv4UAkw8MSjbHY3NUnV+YRGjTYumscFAiAfIPaI637E\ntimIc//BlhotY28XCnYM3L90bQ7DuWAfow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAX/HNt909p42XmeKii1JeNhQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY0NWIzOTUtNzdlMi00NTFjLWEyYTUtYmI0ZjFjM2Q3OTBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMjUyYzRl\nOC0zNTQyLTQ0MWQtOWMzYy03ZTU3YzI1MDBjOTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASrVXYZ/0EBgV8lKX7MuM1x5CaKcRnaQTv8yYZXPzHABvjP60JZkTbs\ndNaAuH6ftLmRVRigj4/0blgDBBYbbKB9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/9+UO\n+qEJGm0wrzTJzNxGwbKAcjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEArf9hOADdSYrRofi2T4DDZq+zZAFkKAYoK3Z0\nTozx9cACIH1MureO6akjkXyxkhEGjl8YpaxV76nYuMbGJ3BKSd22\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6226", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6226` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZ3v1a9PUrCUCiYXXbQ5zCBXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3YjY2NmIwLTYxOGYtNGRkZi1hNjc1LTI5NDA2ZTc4NTg0ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg5MGNkYjEtNjU1\nYy00NDMzLTgwN2YtM2ZmNjNlNDNhNmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIYBz2h61ymmNaCy2yT0ou5apfejr/QU4HGTxnWEjDqMNjawsKpiHGNIN4/TX\ne568EqwKLaxw7D1zKbjpxj9M+aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJjNBBtmQpg6jdu6zflXllOqOkcwHwYDVR0j\nBBgwFoAUa9tjRrevOx2Ukdo/L6lt6tzqEdMwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHCitQ2jU2nm\nAUwTvqsm0g91clS8ev1QyqvclcV+D+JdAiEAp08dSsRV75zdu28Fm5FdfF8BXEOp\nfyRwwXfTqwgHAmU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZyjixQpHe07cgMMFJYdUbUEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2I2NjZiMC02MThmLTRkZGYtYTY3NS0yOTQwNmU3ODU4NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMXjwr6KlCVEopxI/Miyk+85NrOGUug+PSAa76PTKqAeFA\nrAf0FZAzlCFqZZkKVdbqkhI/NB9ea4S7YI5iMBHFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa9tjRrevOx2Ukdo/L6lt6tzq\nEdMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJnvP1jrV4SN8GaNpFm6c5pjmo2ROTC+8+V3YDj97VybAiA2junDORMR\noEvU0xKmy1rnjN4TeyIJWqRmSo9zrLMNQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcRnOFANPesKoQ/XNjeSZHcDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg5MGNkYjEtNjU1Yy00NDMzLTgwN2YtM2ZmNjNlNDNhNmFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MWVhN2Mw\nOC1mYmYyLTQzNmYtYjg0YS04YzYxMWU2OTFkMjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARbmPNSu1GVJhV/YygUMr9ew5e3p0dOo2ctgQw5aSC31+/eRdlrZy9R\n89+TMeFHMrfrHl7gH5BbvkOqkKwbImUmo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBScmM0E\nG2ZCmDqN27rN+VeWU6o6RzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiB4EndWKjKFvUOVhnZdfhfib/1djs0sttVK102C\nDYs+RgIhANYxY2FaJyAfXxssMyKkuU29UIINBl5JUVju5gSRb64N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6227", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6227` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAUDjixaRzHN1O5jrLVXhtcaLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1MTJiZWNmLWI1YTgtNGVmMS1iNDI4LWZkNmY4MDhmMGZhYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI0YjI3OWItODEz\nMS00Y2RjLWJjMjAtOTAyMjMyYjg1YTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1Y0afxDmTFgMUfqQIJlQeMD21VTe9h6zWG2/ZcfMHhXPvzxYCZPN7vobJujQ\nGZSsZcVro5eYMBVlGVibt7oAS6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbKGUEK4EZH6XP+O5UhocaW/EsCgwHwYDVR0j\nBBgwFoAUAVML6lW5Vclpo5ptqj5neP3keuswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANYgYBBUpv5zZI6NzSI+As0O9+OnmQdw32nDXtgzf7uhAiEA+/OfseRU\nO115zJn3G7UGZuZ6MGkk2O0NCfZPzSqOke0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASEyJ1ceuvLcEN5v/WY+Ld4WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTEyYmVjZi1iNWE4LTRlZjEtYjQyOC1mZDZmODA4ZjBmYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASW02kk9Asj0xrGGtc5V597ebgc5yr6zxOEGxRsLw+F70JS\nluoHjvZhehKgKzXjsS19zlMzGlLw48t06BXxsHOco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAVML6lW5Vclpo5ptqj5neP3k\neuswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI6IJtebM1X7Nl6Rm+Gqf0BpMkL+qwOWiie5GigGNKevAiEAuvOkyJaF\nss803ZQz3KVxdwQlsrJyoydnktL4nnI5Frk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeoZAPMCoAgOwEEU50KPsVCgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI0YjI3OWItODEzMS00Y2RjLWJjMjAtOTAyMjMyYjg1YTMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMTYwNzJi\nYS1lYTZmLTQxOTEtODczNy1lMDU1YjJhMmRmNDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATffzTxPWNWGkHLwbB/qmFtvYt1KBC9SBb6mt/fjhGY3F8mMtwmDlIr\nRMRYC2Fj6T/ojGmuvwUqXFCFNuBOaAiko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRsoZQQ\nrgRkfpc/47lSGhxpb8SwKDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBSW36zWD558ZPJX4flKbxhimyY29JbQNCe1+Si\nffSBrQIhALFs05fVcQdwoT+T10dFoCe1ypZifqTciCLAOEoCyd2n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6228", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6228` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISATfVblP/VOMMVtDi9VxhP2qJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2MjA4N2Y5LTkyNmMtNGIyZC1iYWU0LTQ0ZTJhNDk0ZGE4NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzE5MDVkMWQtZDYz\nZi00N2MwLTg2MzgtYjBkZjQ5YjY2YTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhtlPnObFM+gZOTo+ni0QQqY8aveQjCtjljQ3yvsaPsCLOtvp1IJWC1GL+ACi\n4G1S7CiYpLENWto51qfQQcuczqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwXriQoL7wToGN9KDPoiA8SVHH1IwHwYDVR0j\nBBgwFoAU2ZyVuzPf+1U8QJN8AEzd+l+0HqYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAKd54UPcXjt8BEs6du/imt3nb1LZ+gWoU+Vl/FqOzLIqAiEA+fGfvrjx\nS5zzoDirieO8yZ7aWixKeGJJudyMOqbh6No=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb4XHETJ/UYkkattzJ0+32/tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjIwODdmOS05MjZjLTRiMmQtYmFlNC00NGUyYTQ5NGRhODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFzRGENJ4/F/nd42b1UCHil/dB7E0FnK/j3Tu0iEIrO75a\np5s3GaEikrrhuhLrb+IEbYZ4Aq28CAwWBf15ex60o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2ZyVuzPf+1U8QJN8AEzd+l+0\nHqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANyYcbdsPmEqD+IId6DAka0Rehqqr/9LW9ujhY0oz/UIAiEAgamWTX1G\nN72JvblK0sJxt0qb9RYuy4UwfTC+MUm+Vqk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAV/QW3xjW4CNCosl1c9d3BxdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzE5MDVkMWQtZDYzZi00N2MwLTg2MzgtYjBkZjQ5YjY2YTQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMzFiOTE1\nMi03N2ExLTRiMDUtOTg2Yi0wNzM4MzVkNWRiYzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ7OvwlMdd37MoL8VI80vvuSdwYqdLvOnxBHlOiQAo1ASBSjBqI5RIl\n56Fjzf8hEyjg1PEssLO2BhjHl8PlW2LHo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTBeuJC\ngvvBOgY30oM+iIDxJUcfUjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAkDPOgR9e2ZM3BdU+KBIBR3YdJ/UMJv2+xSfJ\nVLVOthcCIBT9skpedtZg0PtLqwckmRdSYam/XzA2BP7QJvsZk0RH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6229", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6229` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAfBSTMeReCz1RRKZXse0cLb6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiYjRlMDNlLTk2OWMtNDkzMC05NTdlLTQwYWNmNDE3N2M3NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNhZDJkNjQtNGU3\nZC00ZTQzLWI4M2YtMTQyODNkN2U2NTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVlXtWruEX1P4NNlPF4XkjC2YVpftRce3vLAXSFNR1tsAdwIBhXTDbBbFNJXa\nbOY/sgDGvYTksWbR4AS85QxmnKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWd0yHh9Kr6F5+AFKrg3rgO6Hg3YwHwYDVR0j\nBBgwFoAUp7oU1Cz6N7ByRj2lLvlCGDXsyg4wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCFBz4mRztFdFJ5znrBvDTunX7bDRKw2zbFxhWVSxsdwQIhAM2mV2HX\ncamysPH2VCBLKIgbQI+0n+WcCRvpkWZC0urf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeaiiIQ91y5U3j/ddcCQ7LU7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmI0ZTAzZS05NjljLTQ5MzAtOTU3ZS00MGFjZjQxNzdjNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnloXShIxzsEPIxIdGYsHwc6JaxOkfxDVwqfydOdzAVLQV\nXHj/ZxtKc648gX6sbgwJ4hrQzBEzEQeqKAeAxsaoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp7oU1Cz6N7ByRj2lLvlCGDXs\nyg4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL0nZXEcm6f2r9p8fWTsD7zLoC665Pb5KBxKSrpZFt40AiEAtdaYCkXA\nt7s/Zt6UnYDTtOisqJF6spos7WQWC1LoYag=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAcMVbwtlS1c/kmPhpnjenxgZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNhZDJkNjQtNGU3ZC00ZTQzLWI4M2YtMTQyODNkN2U2NTE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYmZiOTli\nZS01NDI2LTQwMGEtODUxNy0wNDcxZGRkNDQzM2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQGVlvypVd9Ywhz42UrWZqtPYucdCKZVEqOGE/DIqgk1ILvd3ncrwVv\nRaWRXUNr5YOJB/j+iJc+1q4yXVqZJcfro3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZ3TIe\nH0qvoXn4AUquDeuA7oeDdjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEA7VNlmBVZ0lhw0uMcBdQo2q6bi1cR9LK4Q1fn\nVcroQaoCIBcE8/mFERtNvpwBdiNf/ZILcbLmiw+nlZOY+5Ew89N8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6230", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6230` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAd77z7h2+OyIOBX5gEDo7R+zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0MDYwMjllLTFjZDEtNGI0OC1hZTRhLTBhODRjYjcwZTc4MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM0YjRhM2ItNzEz\nNy00YWE0LTljZmItOTM2ODEyZTMzZTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs6PpX9AGpcbNf+Ye7k4sjJjgb78lCZVbqgmkVHeiHU1dHuAwFWkmWNh7QG4E\ncG/oKXobRztJn1OFPvJx+UlOpqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULKwAoN7rYHlKFABnHQ0B0dBiZFIwHwYDVR0j\nBBgwFoAUkkgGlP1TnW281zDMKMzopzokWPUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGnoJ3343o6uOdQkCJUmetb+hkbVnVLdt4bicCKw\niee2AiEAloUfBtuXPhvfujKmpa9xggvYkYi1pwa0+xX76UxJR1Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfkgqH0JcrScMnb8/QLNiiogMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDA2MDI5ZS0xY2QxLTRiNDgtYWU0YS0wYTg0Y2I3MGU3ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmDTbBJqq8AwLHmHUNXCUVNxF3g7LZmgbo+9oK+KYfmRO2\nmigQ9pGKkzGATKjjF4hE2D0MvGU6U02HraL2s+fZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkkgGlP1TnW281zDMKMzopzok\nWPUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJYP9+h2Pukq2wH/4OsjMOCB6Fcmj0Mp8Bif6PiwcuO6AiEA7Qq6gURC\ng+0dt5kMQmqRDS9Sc1anKEsy/1qCbgyYobE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdKzGhKpYm1bfLRnJG/rQ0XwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM0YjRhM2ItNzEzNy00YWE0LTljZmItOTM2ODEyZTMzZTc3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZGU0Mzk5\nZS02YzY2LTQ1MzAtYTI2OS0yNjI1MDJmZGUzNWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAReyDfaqVIU0e9f2Cn8TCUvhc605hylMmGpOHHkPNwtrdbLL1HR0/fH\nfpXuR7Tbx4moLr2gAZht89aLr+OvtJp6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQsrACg\n3utgeUoUAGcdDQHR0GJkUjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiATml6xa9ieLXH6y9DOIxCjVV86EHJhIJ3b6KeC\naTEG4AIgAJhuwmI9JClsVYSOCu5c35IlZuW0rM4KLQf7f1XDy5g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6231", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6231` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAVKzvcaI6RHhV+M+0NK/0eCwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZDM2OGIxLTVlODctNDgzYS1hNzk1LTZjNGQzODExNWFjYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVhNGM4MDEtZWE4\nMC00NzZkLThjZjAtNGIxODA1NTZmZDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvR0QA7lhnS7+7tC6lYs4q+fvFW/AiCsvHDIrbmUJJhdyKMgB0pnMlBLrS42M\nXa0b2z7UyUtAqWGQTdG5/rh0mKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU37J4r9O1gesMDlaT/u3aUA/bmHUwHwYDVR0j\nBBgwFoAUriFIoZPf3iWQFNzzGMUBUtZIFycwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIF+ReE6L72MzpL/iLNfFMe8jPKqTwoAMhXGNTKNz\nV1RJAiA60YSvZvpK7fPvss0GotAJwM3/TEwhfC5R+sdPRx7YKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXtgFfLaEKbZo56j65t5nPANMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2QzNjhiMS01ZTg3LTQ4M2EtYTc5NS02YzRkMzgxMTVhY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkE+NNkWyUuUrBhUzE/j6Dhk4vd+di1qdYrQRTsT0diEEf\nPo4ZOQsS+zCyrzzRzhONtmNqW+Htmf6BVTH/N3kTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUriFIoZPf3iWQFNzzGMUBUtZI\nFycwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANURdCFhiQcIl9HaEUcE4yOxUS/6FI4yhRofLF+GTb1kAiAhSQxNUjRj\nYcjVO6anmkiGXBQJTk3eDrcUN4bTrS9sig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAb5j+YL8QQOrgvYluf+kJpCaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVhNGM4MDEtZWE4MC00NzZkLThjZjAtNGIxODA1NTZmZDAyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhOTg3NGRl\nNy03NTU3LTRmNzYtYjA2My01NDUwZWZlMGU0ODAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQiF3pjEmDvYcm0QMssEeHJWbsjS3eE8yiIksNJmltW7EY0Swp8//Lp\n0qHfugsT0nBgceWivkUrUpr4JhFHwAXfo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfsniv\n07WB6wwOVpP+7dpQD9uYdTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAgegeCdfDvIxMssU6rnJw81D7KZN5evTQb9wmQ\nN1+eqQIhAI7XJB5KV8YA9nCg6YE/OCxm/O/ofaJrX9VTH2ZcwwsK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6232", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6232` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAYvtFXnnaO/tKYXa63dwMYuEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkYWUwOGVjLTYyYmQtNGRkOS1iYTYwLTgwYWFiNTM3MmMxMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFiN2E0MWEtYjNj\nYS00OWUyLTlhYjYtMGQ5ZWQwMjUxMGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiJ/r1eMGxdLEz/ksIQWtQ6rCTuoGbYvN9zoycD6l927J7pmbG5b32XXnMfxY\nife/IHpScCtHSM029YH++minA6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZdbo4jTldCQoMT98QkCitlGRjE0wHwYDVR0j\nBBgwFoAUfUJdMaHtyMRVJGGDIRgH9rZe1oswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCQDxhK1JpuHLseFl//6PxgWC8o1CeG2shmp8SdP8fOdgIh\nAKWHtcr88IzbK8h9yuTfr/E/CxSpTb1cVElXu5Jr+G7w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUEi3IH3OlL8nOs4QHhMUwZwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGFlMDhlYy02MmJkLTRkZDktYmE2MC04MGFhYjUzNzJjMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiCkYJLRiE29jaj0XKm6amLkuzfzxWq9jxfFevAR29k3Xt\nibIivZSwntA+1QlXZhwNlqI9xiKZYg7rcVGa3r/7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfUJdMaHtyMRVJGGDIRgH9rZe\n1oswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPDO7E5prMGnq6owj9tnr0InlfRjJDv4aBDKKNsQ2eyaAiA0J+NiX1KZ\nORKaA9qe+h4pEDiqvXINceObc2QMbaxy4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdUQ6DzzsLbymV60lqYJlPPyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFiN2E0MWEtYjNjYS00OWUyLTlhYjYtMGQ5ZWQwMjUxMGMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MGEzYjMy\nMC0zMDg5LTRmZWMtYmFkZi1iY2I5MGQ0YTUwYTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARiEA/Ro8gPphbGYAvBwYW6mDBH7yIR5qVjeohaQkDzjxoBp3xdIHpz\n3x6B9Sw8vfjFL+IZ8E5eVk8qgsa6/Anno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRl1uji\nNOV0JCgxP3xCQKK2UZGMTTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBnyx6P9529NeF7xth3KxFQxeoX+fMz00iq0dwT\nbUSSbwIhAJdXtyhPHCR7FBA5gYK/K77tM2ZJpCyeu8DkgMC0Wwxh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6233", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6233` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfaQg2XjfG3Vg+Y9nqA4hJUzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlZWUwYzYyLTYwY2ItNGU0NC04NjNlLWQ1ZDdmNWZlNmMyNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYzNmNjMzEtZjk4\nYi00NDU0LWE1MzctMzUwOGJlZWZjZWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJMaeN6/9qFs96IAQm+DWYFPl08vWeoJtkc4x/UdTFpdJPXquGlvjay8AiXES\ne0Zp+AuWMdvB/DxhneBlIBvvcqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdxTvJYVgQxZIYF58FJVjixyqvpAwHwYDVR0j\nBBgwFoAUyoAvan4obeE/yE2WLfAMFXTvLo0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIH28xBv1So4BT7MmYQM610AercShmDCk\nfzpSgphsq6BDAiEAmFDYXR3BMGEGIHjDDQ+ehGNozACL81PRmGWjnDYl7bQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaEd3Qf/+3TzExpmXrs+WjRLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWVlMGM2Mi02MGNiLTRlNDQtODYzZS1kNWQ3ZjVmZTZjMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJzAc6XUYfnEEPNsVJQdeROIO7cusN+UU1NZyv1Jcxwq/P\n/JRc632umwKkCWfwAoukh76d8mqJTIzPT9YVPiQ/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyoAvan4obeE/yE2WLfAMFXTv\nLo0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGLO9XT5e/XqFtenyrIT7dN/RL41wgXDozCLCHefY2GUCIBsogVc2NfdA\nWm0/733BRDuEHdVR4lkXuZVOUsFF3Sdb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAfbWk4cY6pAB7gcASzdYKDlAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYzNmNjMzEtZjk4Yi00NDU0LWE1MzctMzUwOGJlZWZjZWM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMzBjMWIw\nOS1lMTExLTQyOGEtOTE5YS02ZTE3ZmE2ZjY2NTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARwZffFXTR/INM8repmkg6FGJDF0BVRsO7JPY/CblqRvAsxRAaqnZVU\nkXgLx47KiultuT02nCT4cpOKtm/CGlYOo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR3FO8l\nhWBDFkhgXnwUlWOLHKq+kDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEApRegBVTJrP/6JTI2nDgKywvcZ66P6qi/jtSf\njOugpT0CIDRojytofNg/RvtrMZ+HaYjlwxHwcrXfVxbx9VAb/Ou9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6234", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6234` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAUEEi9sPkcwV6vS/uSBUY6KJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1NjYzMTUxLTI5MTYtNGExMi05MTliLWNlZTZhZjA1YjIyYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg4OGU4OTEtMTMz\nMS00YmE2LWFiNGUtNjhjYWE4MzNiMzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAxwfYgy5ufmdJ82zqlwV6KsU5FBenPfCs+4OFWRGLg0M/cMXn5o/UoFt8rCc\nPfELwV3qwRmKonjAEpRmaZXnCaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmuTFfyxwu7hxeRTgGEy6hPAM0m4wHwYDVR0j\nBBgwFoAUNslURfNrlZmHv47QajAS1GkEEg8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIF6rhx5gtBI1zP8n/TCwjd9ROK+T51U7\n0aXbuDEnduxAAiAzMeG8OBUKNcF7GTyypB/ti8XKlNVz4V96VfGX+XNAlA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQDVn3DEkqncHWENbHpP1lD+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTY2MzE1MS0yOTE2LTRhMTItOTE5Yi1jZWU2YWYwNWIyMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/yJu5rY5Ffuq9fsV1LhCvBh+NXy5+Mr/j3BRg2/G4dyiG\nfom4v2O8QE09kXK7KT1Klp2G5ENUOJuHVCsvF4y3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNslURfNrlZmHv47QajAS1GkE\nEg8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC9kicaTFaKZ7NmZEvn4bRQczNvMFPOSyXFdHOMy8rlwCIDH7Z7HMdCSo\nWAdfWSR88mDMSJ5dqQX96QNmi/koM0oL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUNMtfq7a57cxo/IEHy/ouQwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg4OGU4OTEtMTMzMS00YmE2LWFiNGUtNjhjYWE4MzNiMzBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MTA3NTZl\nMy02ZjY4LTQ4ZjgtYTUyOS02Yzg0OWU1MTYzOGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQQuz/nTaSBv8DNtahhQqYLg6dwikHVSUpwOOksVr2KaS3vsgMolOwS\nCnMPWhZ4aOWAvjq4CjgVdjveNPJiuC/jo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSa5MV/\nLHC7uHF5FOAYTLqE8AzSbjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAzmWDEtEgN1GTdTSh6AJxQdeiG8cM3IEj+hxb\nuNuL8VICIDt9Zs9q6OmY15tOfAuUtM91jeUZcgnN7On9kKDExjZH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6235", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6235` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAalbox8+sv/F5pRCrjx1icnHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwNzY3ODEwLWI4MmEtNDE4Mi1hNzVmLTFlZWNlZWI4ODE0NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQwOTFiOTYtMTI4\nZC00YzcyLWFhMzYtOGI4M2I1YmE4MjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXEGyRwRLH0e+lyaLOTuVMHFb1fIkhrHTn3ghXa02UjBpk41Ix7c4vkt3jIzA\nmtuZnTKXH8OTQK9NFhXK4rDt/6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtdVmBqi8ehkjra82MhJkdcQ/Kf8wHwYDVR0j\nBBgwFoAUlvSQXbl9L9wERu5TBRvVQusDOZQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCKQ2m7Dor0\ntly//WNllcEVgu3y2sWQKW1C5Wu5ypMNvQIgTDhi+xxJYYdYGkMkg3xAeJAZ0zLt\nW8hphPZphAFXyI0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUDWtdk5UArreU8rM5JbuOTCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDc2NzgxMC1iODJhLTQxODItYTc1Zi0xZWVjZWViODgxNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwoDLr4FAfm+UHBPPt2cgKZ3zWEPLPUK71P5vZcWtxhVMA\np33twoKpXWbQ6kv1yf9WPOKBzQf+844iTHv6PuJQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlvSQXbl9L9wERu5TBRvVQusD\nOZQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK5HCOMNMJHy6IOoE/h7nmSC+WpbMeDqeYIa3yjfjlxQCIBFwbEV9f1ij\nhEaqggewb103hSlxDw3kWT4I4ebSeU5I\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASUwNQ0adhGexUC1gzb9nqPvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQwOTFiOTYtMTI4ZC00YzcyLWFhMzYtOGI4M2I1YmE4MjE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZTMxODA1\nMS05MWNlLTRhZDMtYjkxMy1mNGZjODM2MzIxNGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATcpsmb0WPgdRLMQyMpbvQBQ7KTlh+6kW3s/j7cWSwEdqhnY4wsOlDk\noaCLqqtREBwUe6rXISyxAE/w7TIbBefSo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS11WYG\nqLx6GSOtrzYyEmR1xD8p/zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBKEt7T2vSlgVA0yfvkJvPxpd4iqx/PUdPL/zsT\nCvsnYwIhAPbQyPRk6CWYiJ++50MkGWa2bQsgDAcIvY2E1jomKGiz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6236", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6236` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARVYr+wnTOAyBd2HguSSLXt5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwYmNmZjU3LWM3MWYtNDczMy04ZDcyLTJiZTliOGE2OTFmYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA0OGNlMjAtNmFm\nNy00MTkyLTgyMzYtM2MxODEzM2YzMmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXEVICrpCEP6ALft6sk92pfyLfsyrEJxOZztDqmHi7ABc+mwz0wTK63vyRpbo\n9D58gX4yCtBRCf1rx9VRSZN2T6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU39QLrzkfhjthKdxNUUBunVihqxQwHwYDVR0j\nBBgwFoAUsV5znmqxAZNOOM0gqLH9CwZeeikwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAOekDBMF7F2b531LuRVk2xqc+sk+TEttHH0YYUkERDMkAiAFoRZKp5Nl\nSNFtZ12qgfNaoz3YIl5frUJNgwhd1dgjZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWJk27q98OVaVql8X9RIk5KnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGJjZmY1Ny1jNzFmLTQ3MzMtOGQ3Mi0yYmU5YjhhNjkxZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiFtqAqIX+N0AeaBvHgeKZAFSHqUXmwQ8qsv4r9nLNsA4r\n3WvyBAEd6MmA7RuyKZQXIJkRYXzPN0NqPbf8yT6Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsV5znmqxAZNOOM0gqLH9CwZe\neikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMiIaownA55fuIJIurERsoaC9wH8n+TRuuWX3o8KHDC1AiEA6hPhGbsj\nCBkpOZ844YwnX+02z1bFT3VzAhPyayGUm2E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATDWDLGf1sH86k940cAlyJDFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA0OGNlMjAtNmFmNy00MTkyLTgyMzYtM2MxODEzM2YzMmFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNjQ5YTA4\nNC05NGNmLTQ5YjMtOTkyYy1lYjU3NzQ3YzBlOWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARhP4MmgTUKHfpPbvSFW1myX364TloAMPzBWolOf1RF6J5+ekfi2AdD\nin3mSpe6BB3gb+1JcRcQ0Aqbqdt+4rKMo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTf1Auv\nOR+GO2Ep3E1RQG6dWKGrFDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBqLu9O3aO7NykviXkvkNbe31YqKy/G8oNjqxW2\nWefjbQIhAK4UUfKuG9D5RQSrS4ZCGi0WwTXmg8694Bzz9DmCrc1f\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6237", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6237` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZIGNhfs1ss+ZEuhrX8MKzZPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkYzkwZGUwLTE1M2EtNDU0Yi04YzZiLTBlNTU4MWFjNDZiMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjkyYzVjMTEtNGZk\nYi00YmY1LWJlN2YtZTk4MzFjNzkzOGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsfzrnST6ztPB2BKkL3mIJNaPw3qmp4bu726m3MRZc4f58EcxjtM1xnN3DwvI\nhRgxb1oqn9rqCF7aJaINmhnfv6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDPYAtcaBrosf4ABAfVO0To8/wTUwHwYDVR0j\nBBgwFoAU+d5+GG8YwMo4gNMN+GwRU7wlWz4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAIEWQRsPSJpBlB15XYdvUxOtIsQDJFXkj0pjo0+rPNV4AiAs36Z5CBg1\nWu17yYbwcf5gKlcklGMVYlnlWwwUPoM1/A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcQvPiXGgJBgsZqZRxCCpqqEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGM5MGRlMC0xNTNhLTQ1NGItOGM2Yi0wZTU1ODFhYzQ2YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLfTdTYC3DqaMw4iVLNyye12MyvTAyw9NuMop9Ufn/X/J6\ncnrGbKZPkGh6OU9EcVJFxqPi+R3NWAP4dSYKIvHFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+d5+GG8YwMo4gNMN+GwRU7wl\nWz4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKxQfCjAll2z+5b2llpoTjMl7qVPRYFs/YtMcEzaJDCsAiAfcGUVNpAD\nILe/E+JhTS+fGJDlitWD8nLrDTFTJshNUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAURvJaDklRTB4dZ/vGb4Hz2NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjkyYzVjMTEtNGZkYi00YmY1LWJlN2YtZTk4MzFjNzkzOGZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYTM5YjI0\nNS0xN2VjLTRiNmQtYmEyNy04M2FjMDMxMGU4OTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATpPc9q4THCUgoG53NPy4H/6zlLaBHzP6xlRy4doO86stAjy4PG96M2\nM+7AKq+9Dq4yNOxEdT3CS5srN9zPq9gno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQM9gC1\nxoGuix/gAEB9U7ROjz/BNTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiB64TedgCwOWYF1ZV+rTKM9grEL8rPqMT/RRpSa\nKHp52gIgIEd7+xjACeq1RyjGF3JiE5XkC7RRcT5cjrimvLahYRo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6238", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6238` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeDuO0bwWnE78a1oDiqPfR+hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMDU0MGM0LTA2NDctNDkzZC05MmYzLTViYWE0NzdmZmMyOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFkMTQ1MzQtYzNm\nMy00ZjU4LWFmYjctZWU3NjI5YWE0M2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuYrlB9uPWPYTfms1wxi8XtjDmPkjsRvk5mY0ofwhVTdF1ObShzpLeYUGPVun\nEXjNnsvvTmp9Svwl4qAQs3nOYqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUThSNTxQrAPH9XMZYWl5KGn6Wz/swHwYDVR0j\nBBgwFoAUW6cYncseg7bJxQ/X0vt5REOF03MwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDjET6TMEb8E14gz5z/BReCJB7F2zAzUdHmGiwBfV9CAQIgWSdB0MdJ\nDpUYRK5A9imFsRMvSoUA7Z+XwIOlBjXUvPY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZfKiwQSKQqfq4Eml8wQWlqiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTA1NDBjNC0wNjQ3LTQ5M2QtOTJmMy01YmFhNDc3ZmZjMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLHK5LsncgaByF2kHauElK99Np/dWBgZRLDFZlEVBKR853\nZMns0+1GVH8JgSfQLfGhc8CwpJ3L+TLrqs547p4eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW6cYncseg7bJxQ/X0vt5REOF\n03MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYoKt7NPhwkt1LCEyLVNuEG8QRTEbkEQ97X0IpZ7arPYCIGmEyYXjMaFK\nIozXy/G/N4U0Qgo6uk3t9QTF/s31NuLY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAXF1U9qVakNYMQmmfFWfTlG3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFkMTQ1MzQtYzNmMy00ZjU4LWFmYjctZWU3NjI5YWE0M2NhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5YzdmMWJl\nOC03NjQ0LTQzZDYtYmMwZS1lZDI0ODIxMGY2NGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARPYUm/I37HVbnK/tBwuIPi3qUvGAqdnaA5hn6ky7wneycgP/L0QNCT\nqCq1VHQoHCtU5+fBk8LckT4D7//7lawAo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBROFI1P\nFCsA8f1cxlhaXkoafpbP+zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiBbDFh/NbmrgpeAeFc8ZbGmQX1UEHHrRfkfTC1j\nnIWn0gIhALI/dsmKC53Mgl0/+VaJYcq0LvTy+lG/FFu0PBzGte/n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6239", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6239` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAVSxL5Me1PX4hI5DTEtPshxdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjZjA3YTk5LTYxOGQtNDBmNi05NGI2LWQ4ZjRlNzBkZjI5ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg1MDIyZWItMTAw\nZS00NDg2LWEyZmUtMjBjY2MxNmI3OGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERgxWYuUKyU0x5QrQgpIr9dOrTRusNG3SQYnE2cF9pAoHdDGqt0MPW9zh2IZE\nM69DDpi1EHpgqrC6dq69ESmPuKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNQKfifnxoLpRWcNYF0Hlb/pGF8AwHwYDVR0j\nBBgwFoAUTuY+qlgqgGNDhBN/OxNnOCTJx+UwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIACMNcAVMpLGTh8LQppgEOjI2r/v8hbsOVFaQEhw\nubyiAiA78hXcRRsin+ukoNFXg6BQylAut4fPLXl2X+kb7ajenw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfIvdgzMouIwk12qTT5eVrS1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2YwN2E5OS02MThkLTQwZjYtOTRiNi1kOGY0ZTcwZGYyOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdP78R3zjuQjl6jdJjXiZkhOQMIob6EjMjewbOcGANnkC6\ng8xCEgcR7QoQBcwd+ZOCYZsD9bwWL5b1SMlQkXEko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTuY+qlgqgGNDhBN/OxNnOCTJ\nx+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL9eev5LmYyk3RWrABMugwLqHKAEOzjz6I/m/DK7xavkAiEAwLUKV2Gr\nTnMbXLfaaOj9BFkvZbXKMvTXakhxQ9A3YvI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAajXjEeoeuCU/8QpIBENsELpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg1MDIyZWItMTAwZS00NDg2LWEyZmUtMjBjY2MxNmI3OGUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNmFkYWNm\nOS04MmRmLTQ0NzAtOWJhYS05MjEzMWQ0MTVjN2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATOj3qvuYpbDtIBu7HC8PJk/uHas5tmZfT9GZq9QLlnx/PQnfFG/8Q4\n+gVOpFUg6oOuIZox3WIagfBeCK18bo3Io3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ1Ap+J\n+fGgulFZw1gXQeVv+kYXwDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiEAueW35ABNZKHciok9rI8FIHzNMfHWfy4TCxxh\nqtxpRsECIGNIVoxaIWE2RAC1ccNAy7cb6+024TbV7KI2mDmFOE0k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6240", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6240` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZpyj+bTMSgR/86bjCDc6BYiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZWIzMzhiLWNhOTQtNDQxNi05YjgxLTBiYzE5OWE1NmUxYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY4ZjEwODYtNmU3\nNy00NjhmLWFmYWMtMzhjYjhjNTJmYTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGVwD7PPGVitALtQuJlX93SSQ5xt8+phFGEkmnUfYqSiA8g3KfdXeMJ3DOsQ1\nh3B7E7zZvP2WPjMS3SHn9ngvIKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwQw9ZfNTN8yiv+WA+1ASm1y0QXIwHwYDVR0j\nBBgwFoAUYCwhzJ6ZXzopLb91Ha1UOitGLoswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIByvXtDsEJj0s3MRYptbrFZXG1lkV0cMo3c7AbJ0\n1QtFAiEAsjh71AepZlADXhrHbpZ4dd1a2g7tH9ERTrwNRLzWEhM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQNImJYiZn8uhIvymNgjGaASMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmViMzM4Yi1jYTk0LTQ0MTYtOWI4MS0wYmMxOTlhNTZlMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9wBEwASZuuK7BHZ2CuwtVWFZYRQEFmeLe68pQTQtEXinK\nJNDa0w61KNV+QsASiDSxK50i9MArgT+DjSdQepJxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYCwhzJ6ZXzopLb91Ha1UOitG\nLoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPYon4JsHJIkaSXhjSaUPM8QmACSl8devziwBrd4wBLFAiAHc9M/HTtZ\nbLthWg2Ut9J+OxcILk1S0LzRiTRBomMRLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZXWV1RFxk3AWQHxOnXPhHp8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY4ZjEwODYtNmU3Ny00NjhmLWFmYWMtMzhjYjhjNTJmYTY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMGJjMzc3\nOS0xN2U4LTQ3ZGQtYjE2ZS1kZTZiY2U2MmE5ZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQXpvbpO2ZuelcAtB7A1Nk2fYb8C7QT8boaOkE1tBuj9PKZdtKU3MTZ\nr8IPelHMwLJOvbvrLBx2+TJaPt6PR+Pmo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTBDD1l\n81M3zKK/5YD7UBKbXLRBcjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNHADBEAiAROY5BQ2QvIuwrp0awsl+rW+QFm2EIGOYuM4Tu\ncHcAxgIgGIhTxdpTJPETAJRQzt1KR29dQPscuYi7Bkqbi2gaN24=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6241", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6241` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAao2L7LYsjO1I2GNV75EEQuzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3YjE5Y2E1LTQwNmUtNDNiMC04NmU4LTBkMWIyMjEwZjQ4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE1MjdmNTYtNGY4\nYS00NTJhLTljNzctOWU3NDQ3MjRhOGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl53J3fLDFtVonk4QTr6HgUNRkRv1MyY/wszWcMtH9lRf0ZFi+TO4skYsuOcj\n5xGpIsoNO8o56Q+uZlm6XWFv/6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8lHLwM2i/g+H/UiAO70WWnCIFHkwHwYDVR0j\nBBgwFoAU2Hlz51KkqVYpyydJG1IVgzGfrs0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQC9Kdl3g22E3y+kSBKyMPs3nRpoe/o6dQulcD+Gn6ZjlgIh\nAMAXEztkTMi4BA5BeAtgwZcjBjO3ZoYsCU15a8V6gUfX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXBXYu+KqNEYokkAQgFuOL6TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2IxOWNhNS00MDZlLTQzYjAtODZlOC0wZDFiMjIxMGY0OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxgJH5cJK78theCliy3tTl3d8Yt7OPhlmhiEBq+lkx9nC7\nKqrUOjnzZal2jKdKR86eNcBYIYY6X3TbRjf7erpFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Hlz51KkqVYpyydJG1IVgzGf\nrs0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGQRKy7HoKswgv3LmSUxiWiM248kDnyIean5OERKwq4UCIBdMq0wFmOkM\nn8WHtHc65aRAhnYPinSrEmDk/JlO+fV6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAeF/UHGWi8/UXe67E2li/cz/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE1MjdmNTYtNGY4YS00NTJhLTljNzctOWU3NDQ3MjRhOGQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZGYxMWZl\nNy1lNzJmLTRmNTAtYTVmMy01ZDVkZjhmM2IwOWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7wDJtN2eSFl/ioNmzHGcUoHL6IOCugwpa39//s6DuTh7vc6YjcKO3\n3F7s3GvPCqud6w+UFZXpDdtfmSjxqVAmo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyUcvA\nzaL+D4f9SIA7vRZacIgUeTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA5FGk7nJvnDJ2jjoNlREALbOpQYBeN4ndSPSt\nuuIAdxQCIQD9wwAY3XZM2fDhgZ7PfWZfAUGN/o5SakeT/WJ9FeIbxg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6242", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6242` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISASvpAW12fsLm/e+mnZKoDA4XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzNzY3MWYzLTdmMDQtNDgxZi05ZDI2LWYwYmJlZTE2NWJjMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE5MzFiNjUtOGQz\nYS00MTI4LTk5ODQtNjcxYTZkYjJkYzcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENpmZ9fvRnQLqBRoTIDPSXy9kVD2S4FQB9BnSEf5ZjwDrkaU4JuDZgyJ/eb0n\n4RCiHbP/bVJaUZlaiN2t5YPzi6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU46/T5Fn/43S9v13l8HhUk+o5xdowHwYDVR0j\nBBgwFoAU8Yl5RvKo/REXUPBsPWuDi8welK8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDy8dh4wB0q550jc12NJoMI2XfqS/jf\n4u/9ktYDbzeqoQIhAMnTyWAyNew+CUchHZHhDCiYrezx9gKa34M0jV75+SYy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWXY0HtM10X169iteK+loRq9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzc2NzFmMy03ZjA0LTQ4MWYtOWQyNi1mMGJiZWUxNjViYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBvCDaqEjvIT9oUJCpzQHm0GzjGCGDTEG/EVMod03ISBGH\nc+uCg/rG/n3aggcZITDz9aAl5+rxB3QDJUJvGxxro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Yl5RvKo/REXUPBsPWuDi8we\nlK8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL+mkaAMKPFodWalyC4Mj6u7fmibHR7muTk+1T3SimkiAiA2zVxl0A/S\neRizeK04bSbRk1MuEdgowShZxX3K3/AWwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUEp8uY4SBIiN7zVlD2WbAeAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE5MzFiNjUtOGQzYS00MTI4LTk5ODQtNjcxYTZkYjJkYzcyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4OWU1NjNk\nZS05ZTRkLTQxMDQtOGZiNi1mYTI1ODE4MzhiM2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASwdRMXijgOTBTwwr+czGSmbH2L1NMZjN1iWZ8mAvZJRZIFARjgVvPs\nJiEw0f2+Pp8sD1XviJK08pi0gOn35o40o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjr9Pk\nWf/jdL2/XeXweFST6jnF2jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNIADBFAiAWVGUOvIY+e7qcPxHI8xriQfuZg8uN8dQHlFm9\nE22CYgIhAL60IJ6qeQ4IRqJeUitxoGC1CUON3W9/9z1x/68Im2+L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6243", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6243` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfyFgzFfxMLy2EDrX0k7E6UmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxNWMxZDJhLWM5N2EtNGY1MC05ZTU3LWI1OGVjZTQzZWQ4NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI0Y2Q5ZTItOTI1\nOC00NDdjLTg4MWYtMTA3MDlhNDljZGVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQJy56ee/NCKiktMZqvceaVrsCMbX/1LDMyycLPEtJm8WKTxyzzExjEP2Ry/J\nD52MMkbQ4qG8Yv9hmjtXFBralqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0y9Ht/yxVYEQwlltJ0CmbszVSiMwHwYDVR0j\nBBgwFoAU8r3nudaVhZCbsEecNFBfHhhhiLswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDfKMRU2eY8haUUfKpm06j1LIkHEAGt\nRHzHQjcHK2jF4wIgPs1Afu1983ZDfRM+178IStuk+3okZFonbJjwOinrFlk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARyp5MT/0S/OfpA0m9w91nfaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTVjMWQyYS1jOTdhLTRmNTAtOWU1Ny1iNThlY2U0M2VkODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATie2DjsQ7ZtfiS87tdM9EcO8coGn5tvr59aTn53ocCDBMN\nzCOCsRaeckx8tt1leFGwb6FB+jMuU2pKAuirErRuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8r3nudaVhZCbsEecNFBfHhhh\niLswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPyIO6EaRRjlSy44vEEmDGXz9PYiyWbdHpUJQ7U+jrtAAiEAtDLC7Dcb\nY/0LcArRHgBJWIL3+9JgbkN+5mF2ju8SCXw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAa1XwRMMKyz38FLx3lrsJqG7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI0Y2Q5ZTItOTI1OC00NDdjLTg4MWYtMTA3MDlhNDljZGVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MTdlYTJh\nZi0yNWFhLTQxZjQtYmZkOS02NWUwZDk2N2E3MWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARm9ZGJ3sXnDRoFl76bgHB0nmWkFlFjsqW8pyNJ6NAq/a6A4yGIyvLU\nW2MwKxm8VZaxx1/G1luiqQpcW5du6k21o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTTL0e3\n/LFVgRDCWW0nQKZuzNVKIzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAA\nATAKBggqhkjOPQQDAgNJADBGAiEA/nJrrXIRzNRJJNX67c+cWVpvZWnOZWZBKuN3\nbKHKymACIQCNHzDeYDcz05iSFXELbBkWl+3ZN21fe7QaJQzeCK4HFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6244", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6244` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAS0n+597y2wtFfPPTY25jK7jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhMWU3ZmFlLTZhMmQtNDFiNy04ZDExLTYyMjI2ZGQxY2RmODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVjYTU5YTQtOTdj\nMC00NDcxLTg5NTgtYjRkNjkxYzZjMDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7zuody5TLWsAleAFBbhhthsjNekOhFRNXyjf+znAwHWj+lRXmj0JeeYI3YXS\ne/BbY+Mtat1Lw7wFlXVDrSeUpKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKUlmKd0jvWwN8dIJ8g51I+O3KC2MB8GA1UdIwQY\nMBaAFGzgMrxVUhU5wsegMgPucayiT/niMAoGCCqGSM49BAMCA0kAMEYCIQDOAfer\nO1jSKriG1VZbmmNbbhfrqApcFHphEB82oKPxDwIhAORKYzeCuECA8TJaJYzMhuct\nAiD5CxoNorfZpXltEVTv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVgjbEZQM8QFSKKBhcv0s8ajMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTFlN2ZhZS02YTJkLTQxYjctOGQxMS02MjIyNmRkMWNkZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGso0YZ+OfQaKxe3S1qwOBzhCo+ZGXT73/R4l8Nn+DOoaJ\n4NnBpotW8OCKuX2D3Ue84NpPc2ejqCvoqhFpWeZxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbOAyvFVSFTnCx6AyA+5xrKJP\n+eIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK74w5Y00ujrQVKwidUZv5Z3ohDU/PSrBJMmBaB9awTPAiBDyYHawVAT\nK7BTndTMnOXSIVH8xyiT+Q7GC1h1ldd00w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAWwqEgximzxfBxlTOKA+2slCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVjYTU5YTQtOTdjMC00NDcxLTg5NTgtYjRkNjkxYzZjMDA1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYjMzNmY3\nNS0zNDdhLTRkMmQtYWEyYi0yZjQxYzZlNDQ4ZDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARqM7h5jvDvqmU5EmIk5OQrdgkTwEHz2Jn99KPolCVQA3RHWLs17FOy\niTQ2O59dKyjpvuI/0jUfR0NYn9BypHEdo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSlJZin\ndI71sDfHSCfIOdSPjtygtjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAx9acKJBgGkhzWlFmvnHsSTFhge49sa8YT8kU\n/iq+WQ0CIQDBelduv4zu3wClfEafiiHI5zFJuE/ewL6WoXNqy0Fe7Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6245", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6245` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAXmv9uAlGf60tJVjInAvVKEQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNzdmODYxLWU3ODItNGQ4Zi1iYTFlLTBjNjYxZjExMDI5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTgzMTU2YmEtMDc4\nOS00NjMxLTk4ZWItYjI0ODExMGNhM2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOrwrSHL2d71FjzIMiSJrQNLCK6RYiwiHOy7+XX3xF1HzakgmZYZr8ErjXVLv\n1a7pNx5SoFcMifFwtKvvrCxVI6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOyeGQzgg+kONIwbmFByRU2vqLe8MB8GA1UdIwQY\nMBaAFLMY9xPhtZ/i7+REqMP62kBmHSybMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAK79iLoNneinUqkFC5xoz7h6VsUkvhKl4c\nMnTrgyZsJAIgEX64Iiz+BhKU6EMBGmS2CiJ3v0jBhZsey+w8YWxNpTo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU/9aS2Atv8tamM8LM/JBEcTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjc3Zjg2MS1lNzgyLTRkOGYtYmExZS0wYzY2MWYxMTAyOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdvvYEQ6N0DkOj3/S1mP5jTgDsuF1CfiCNmfJwuSKEHo25\nvyLdZ15p53lTVyPzpx9ujOqkjye8tIZc/1uf7JlEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsxj3E+G1n+Lv5ESow/raQGYd\nLJswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOpV8hJqTHp6pf0LcFkscJ6lEx6sx/Jz+q/fio0gHIPwCIQD179C9ejVs\nF4kmow7ZX1The6kpzOjAr2fBUZHCIoTuFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAc1evyljnQBIaz2+7YjMErPHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTgzMTU2YmEtMDc4OS00NjMxLTk4ZWItYjI0ODExMGNhM2U1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZmFkYzU4\nZC0zNzZiLTQzZTYtYWFhYy1lYjcxNzU5NjQwMjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATMGc6oU98LdhQORAZjLgdkw7MN1w1zXS+8tFqSitHr0gFArm/hU8sy\ngn2CJnCFMxdbLxASjRPcWzZtLqmU+V5Eo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTsnhkM\n4IPpDjSMG5hQckVNr6i3vDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAyn3FRCF1WhbR703eIHu3kiBdSdLua/5gFtJy\n1ug+X3ECIQC58AMPK7hJpuDPR3iyekoduUsL+T09SLR8mEeXCPX7xQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6246", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6246` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVpTtldb62232lFDupD+MBqoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2YTljMDYyLWQwZDEtNDI1My05YzczLTZmMDczNDY5YThkYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE1MDczMGEtZGIy\nOC00N2Q4LTg4MjAtMWMzMmQ2OTlhMzdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn0gOWekqjN9yT4ToAv4crZRIhhiCA/9C0zpV/s5e9ArdS5AJIOcJRZqnbnjm\nh8BNMF+imbJWljCfmMZXVie3gKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNGl1c22uI1FXPlr/HHLoa5/FoG1MB8GA1UdIwQY\nMBaAFJll3k1GBHyILrBpCdgkCh4Ma5z+MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAlcyX8/MTFxUOiJS9+0wL17QrQeeoAGGn8\nicsjwOlRhgIhAIoaJaL3rWUt7PpdxGxx3bbF0mVjic2Vd/0vjVrmn4HI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc2ba/FM5BTbPYJ4tbWJC91BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNmE5YzA2Mi1kMGQxLTQyNTMtOWM3My02ZjA3MzQ2OWE4ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWVpaGhO0srySjiNH+myEtqOsmlhnqYnZ7SMXRbKcsas92\n6XTUYbKFlFMCrrxe6/HRkCyqVffY3r3Frqu2NszOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmWXeTUYEfIgusGkJ2CQKHgxr\nnP4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIQd53nCCNKgdfkIMdm3a+t+9XMGGbiZh8Dy+B1OSMB8AiEA9BKvuWYQ\n2FlrjiCZiMljdmiX9Oa+PRV5w8E/KXUBIDA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAcrGHsazdxEdXiBRSE26A/ZeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE1MDczMGEtZGIyOC00N2Q4LTg4MjAtMWMzMmQ2OTlhMzdkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYmM3NDlm\nYS1mMDgwLTQwYzEtYWJhZS0zNmVkNWE3OTBhM2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATOC5afp8bjjEJehZ2IAqcrWRy0uLUAbI+PJxKsYVVQPQm0/m6GYJpi\nh4RpWexwvJuexdbGjaMPUgsbz89Evliso3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTRpdXN\ntriNRVz5a/xxy6GufxaBtTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAoBledDXkRXRkrp0qkqo7Bj0/ClOW4hWLi/I7\n+Dql34wCIQCAErwfGgwczeQ0sanu8Y46Dyd4VXnWJ7w9LbFG+H/EnQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6247", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6247` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAXPKN8yWv0OmPKvfxlxBrIyYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3NzE4YjNmLTFlMjYtNDg3OC04ZTBjLTZiMzZiNGY4MWY2NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2UwOGY3MTEtMDYz\nNC00MzRiLTk1NGUtYmVkZjkyOWY2NzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9xD7FuSHPvye+0XW2k2ySCXfSpmYXlt/CzI6b71f5CUlu8lk3ffSjywszOK+\nL5mfMH6KNfVgRyMp0bk81mupP6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRPYSWeEKDy1cPBaxHMxPF+6YFqQjAfBgNVHSME\nGDAWgBTHwMxdns2X00WNf/heJbLck4fJFzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDl+FIHwJrwjzEHNFnQpQQ6T89jeSPi\n2+JfwhyQqJcd+QIhANupdJ+26wp8HDParXUGkaf+zmnVvkPeUlDEW6N+mNL8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf+G5O4k/r7gD+AZj2p4aEXHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzcxOGIzZi0xZTI2LTQ4NzgtOGUwYy02YjM2YjRmODFmNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq5ZXl9x5ku8lM3+PlyR/ygaYpVWGjB6AkpAZpDwLtEXFH\nnBnXSDsmJiKpryTsZbFK548sZPGAlo/i0FmYhLKHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx8DMXZ7Nl9NFjX/4XiWy3JOH\nyRcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALJ8i+z7B8xQXMcC4EHQeqxfGvEoPrjTIbtguEuhsWEjAiBVYb8Z0jyE\n6EM3yuB1PyhI4KBt0lrrF/njmgsAGiI7Vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAVPR1XNxWB0b1RKLK5SncIk7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2UwOGY3MTEtMDYzNC00MzRiLTk1NGUtYmVkZjkyOWY2NzM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZTA2MTE1\nOC01NDFmLTQwYTQtYTFhZi00ZjA0MDc2N2I3NTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATfMvTtxMoT+cjVaPxtPaK+HxcOVnwdu3qe0VsK+Hr//C9e6t/uhhh3\n7l+QN/XymDFQPPplVmsr60OLXUVDqSyAo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRPYSWe\nEKDy1cPBaxHMxPF+6YFqQjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA840UHbvbQAtYpoolKK//hUxdF9my6PUEe+Wg\nIWoT8IACIQCcyUtamCFQKDPXmbVpkqJnNw2BjfalPXL+1clKwgYg9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6248", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6248` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAd6THFER80pyzcq/nyJqmfa0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MzM4YTE5LWViMWYtNGQxMi1hM2EwLTliN2QzYTYxYTI0MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhiYzA3N2UtYTM0\nZC00ZDdkLTljYmItMmRlNzYwMWZlOGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECPLwLmXiNqXuPcK1EWLJA+4PkjI/KJF+ghFm7DhCQYLi5twPguXiUdnpCDrj\nXVBnV8uydRV3PNNyGrXxGHkrtaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXNWg/CFRS8BLB8+BhHXdUDGWaHIwHwYDVR0j\nBBgwFoAU+LNKmcmAWkBZzsErnw+QqhbkHCkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA6Rvls62Ipuxm\nFGhA7Fj2WsED3dAxQ+eOv3YUtD3HU68CIQCrZee80VendX6YgPAmfcTakF2eO5IW\n1q1fXw0SeOQ9tQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASoOVxcEBR2SsAsEjkWVhJJRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDMzOGExOS1lYjFmLTRkMTItYTNhMC05YjdkM2E2MWEyNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARv2/9SPbD7B/PfyGQvjpUEf3yhVGnrM6v0iSclglSmnBZe\nsBFTpopHFzhMqHfd0z6E4rkwStVYFfCBVUDcZ5t9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+LNKmcmAWkBZzsErnw+Qqhbk\nHCkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTg2yH/hjuetX/4LqL+f17TYNt48DkaNqtOCzjHMQf3YCIAGIk2uiYuBi\nVFAd9YKriQflS62t/KcJHOIEWKslB3gB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASPOuoOsopa7fiG1RVBcBCMLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhiYzA3N2UtYTM0ZC00ZDdkLTljYmItMmRlNzYwMWZlOGE1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MTg5YjQ2\nZS02NTI1LTQ5YjgtOWNlOC05OGJkNjQ1MDJjYmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR6fLyujx9kG1xAt7/1Gvv/u0QRe1jR0Ftx2v3vPllmCPzHL6HMiWPb\nBaggVsqhevK8RxfiJD7xwWBbrVfILoEeo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRc1aD8\nIVFLwEsHz4GEdd1QMZZocjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA8/P1DJr0MPut8X5yOV41nCx9E3adr4Kykhxo\n2NUSNQsCIDYrUWMxatSReK1p4yS+MpsuudMNLOcbPCAu4mwpIO6b\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6249", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6249` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAeYZ1bUV/0N+Y70muMMI8xhFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczYmM2MWRjLTE0ZWUtNDQ3My04NjIwLTY5MDc2NjdiZmMyNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM2OTBlNmQtZGQ5\nNi00NGQ3LWExN2UtNDJkMDkyNDhmYzAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFvUDMNJIEEJB0i5bPUx/yAShbIetSyOjlJxVkZNOHiLExLMVa2MURSsGAElE\nbn5pM1d/UMaNssoTGvpgx+oqeqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUddVhJNLliJNnwafg8LCAu5poqoswHwYDVR0j\nBBgwFoAUdvF6JX6l9jP79acE/NtOFQXwtzgwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA6W0ho9zrdlUJ\n3C33lYiOpbsp/v/Pa8TZdDyfS0rGh1QCIEJSQucTqdUEwTceh4jDihwGc6pAo1UP\nCxStzexbt2YX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYbne7qw/l5BYEbu5GKENZNJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2JjNjFkYy0xNGVlLTQ0NzMtODYyMC02OTA3NjY3YmZjMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATADnNKj4JJ7JfIIVlqA/CJPtq2ABdqMmI9Fk6vairh14mG\ngDLPy78MWMdqOPXYDNRX8bKVVbUpf/dhur+rE9w5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdvF6JX6l9jP79acE/NtOFQXw\ntzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJT0kAiXWscTc4FECkfMktgY8VVO+QREKDpsGlJmbus0CIQC92x/th3D4\nxNQIKwXU8B713+d4w8IYD58xQwjYVqGf1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAS0UCUMf8IJSkN5i6MH8OrhGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM2OTBlNmQtZGQ5Ni00NGQ3LWExN2UtNDJkMDkyNDhmYzAyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNWRlYTEw\nNi00Y2NlLTQ4M2QtYTgxYS0wNDI3MmMyMDYyODkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASoQQTOmokUBCBqbvU8JBvvjKSOoc0heazGfxzz8EfqSD5btz7XeH9Q\n4sLXvGdVRkC1Px+Pk4vjSUbspGCcXBrzo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR11WEk\n0uWIk2fBp+DwsIC7mmiqizAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAxghS2x7B6AHH8RxrnolimWJsj+gQVJHb9lvK\nSQu5GKwCIBwtoOj4BnVqit3s3Zs84S/pYO9s1XVwMiwzaI37Xj0+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6250", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6250` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAdYMRlBcpIT8GKnbsS4W8/VVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4NTY5MWMyLTNjOGItNDIxZS05NmQ3LWI3MGQxNzYyMWY2NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjlmNzU4MzktYjQ5\nYy00OWFiLWJlODYtZTk3Yzk1ODZiNTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGPA6RiRWtYBpgIZt/uG2C4ES1EXHna//maAbQZ/kCfu3ehcWk7KTVfh+lkcI\nx8z9odrrNWkz2dZQfik9OYVSrqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzvmOby1Aq7Bcywu709e9eVFlvfcwHwYDVR0j\nBBgwFoAUFE+P0PTq3Q1gBanUKIGt6Naug1YwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAi03jndLAJ36g86lVX/Te\nCiYqyavEeEi6BaM0bMGd0YoCIQC7RIoS+xOTQ+7x48ue7iiELLGBeCmMQJQ0NC4+\n3zgnIw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXKYdGPYY/+sSiifzmjM7ZlcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODU2OTFjMi0zYzhiLTQyMWUtOTZkNy1iNzBkMTc2MjFmNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrmwO/EKKpuceE1ZdoGm0JaOVteypmhSGmZm2n8iPTu8Cf\nzuR2/K0dqmtU5wCfuhW8JqGipN9JVHPKuxp1SksUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFE+P0PTq3Q1gBanUKIGt6Nau\ng1YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK0QNYZuG2K32VsXam4XFwJTov3EG84W0ho3osGqiY/0AiBUX7eCIcLs\n3SXG1zmaW13FJx+WB1bPQpADlq+sL5+uXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVdurla/4WhkrgGuVleTl4ETMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjlmNzU4MzktYjQ5Yy00OWFiLWJlODYtZTk3Yzk1ODZiNTEzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZjQwZDA1\nOS1iYTQwLTRmOTItOWMyNC00YTI5Zjk3ZTVmMTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATnGH0PIk66VkZgOEfrpc2jsRdVOXmvzrFwdMCrSk+iFAv9YXR85I0W\ne4K6S1UIk6CmuU8mG5rwiSmiTl5sPdY3o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTO+Y5v\nLUCrsFzLC7vT1715UWW99zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAQOSjrfeKydY4ZfASjpDQXZdSgaEL6yGB3DOIp\nPmGXlQIhAJq92iOPLXWzdo3adI3j1QRQdL//+/LBXtyqSiIvxzlR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6251", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6251` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAaJKDKCxJ61LASHMhUDDBawQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5MTEzYTRjLWRlMmEtNGE4NS05NDA2LTA2M2Y5YTQ2ZjEzNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdkZjQyY2UtMzlk\nNC00MjZiLTlkZjUtMTcxMGEyMTA1MzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp//nw0+4TSBD+n57ZykgbdoZMhYOPScCT8gSMYcU/M3YcmhtwWjCJbbEoks9\naW01iDpVj1DUr7m/3qk8L37wiqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIUAYsM9yYgxohGt/IgfmX1H8xr8wHwYDVR0j\nBBgwFoAUhXt9faZP0voEbGMa5t7FYNfVAdMwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBrsmVA\n+Ache4gnxOOENokvoZtPqlQp2Q58RrqiCwbEjgIgTxLkyY3j1xsjbfmsdwhu+y17\nzMdqAt7nq3vwshZNYWo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAegyqUVUxYO330zwVOcMxk1ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTExM2E0Yy1kZTJhLTRhODUtOTQwNi0wNjNmOWE0NmYxMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQajZo+ahm42y3/L701iHCYgLZ4CMGXRCoeGEp7fo0DvSiw\nFitd+9yH9vX24OiPg7j50ImNQULCh1fPrXAyXxnro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhXt9faZP0voEbGMa5t7FYNfV\nAdMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSslAmYbd/fv/rzyJkTvwXg+j5AtyK8jX22uXtu5NcP4CIFec+ifVtR7Z\n33KJuCs7gVDFO89nOQTZmJROUvtEz9yN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAWrfV+lXGE/5sqNOkn+c0HU1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdkZjQyY2UtMzlkNC00MjZiLTlkZjUtMTcxMGEyMTA1MzY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZjE4ODYy\nZi01OTM0LTRhYjctOTU2MC1mOWRkMWE5Y2JlNmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQJBFvkiJ6tbFQe+WVS9BwRK3EnhtUBQrxJfJWLqtXV6B1tELQmsb2W\nPflp5S3fAnahjEnPCgr5VcaO988mERswo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQhQBiw\nz3JiDGiEa38iB+ZfUfzGvzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAkZiB2f4owFG1e7hvh92P41t+qt+H6Mvpi+Iao\nZq8cjQIgajNPCQ8jHE6ooEH3rIbK+mBDpF5gR6EbNTkgf0HV0ko=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6252", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6252` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAXnv1mZbaygnzMpS82pCmSjMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllYmVkMGVjLTRkNWEtNDVmMi05NjE5LWUzNzFjY2FhYzBkYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQyZmM3MGYtMTEy\nYi00NTg5LWI0YTQtYzhlODExNmRkZWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc9Z6VCRH4xp15GpjE04L3CN68qydji/2AgKIS0RiOyjlqmeUu0GydTOH6beQ\nP/yxkwtUcsDGRk3OFNgYyXTAdqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUURuqL88M1d/NmkZ8w/205GiSE+swHwYDVR0j\nBBgwFoAUr6cm3TA6ZzB0PEqDYdoyzeu1yhgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAiK3i1\nMzeBnXPN12VIXpzvTKVb+XdkqK/LoEhIhMiH/AIgcU4LtCoBvpLXALIzHjUPTxau\noM4uyqpPUNK2qNt0NXI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZrH0UVFF4KcBvNO1s8Stx+yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWJlZDBlYy00ZDVhLTQ1ZjItOTYxOS1lMzcxY2NhYWMwZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqhtOdoeRWn2J3adncdq1ComW4Jb3iF/PHgpUOv9OAEt0L\n9oXZLeAyOBze3tEWNM8vG4AL+QqjU25u7PhXjz1No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr6cm3TA6ZzB0PEqDYdoyzeu1\nyhgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOpYH63yaMVMBHRTeal4HbC3T5FLfmwL7Xg+3JoIIearAiEA5zj0e7iL\nQjPbszrJ8dOgb2VR3vZX4bfYi9LYSRS57Ss=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAUwj6PsV2SrYmVa05mzielCeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQyZmM3MGYtMTEyYi00NTg5LWI0YTQtYzhlODExNmRkZWFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMGQyNDk4\nOS0yNDUzLTRhNmUtYmU0MS1kNDQwMTBlMzFiNGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQKaUhIH5zBaoBXJ9D4Y1v3dp0g+C1+2CB7AsOy/MWJ8QUj14z1cynH\nUnU8EdLvPxcBH6Mx+diJWku0adXALik9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRRG6ov\nzwzV382aRnzD/bTkaJIT6zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiA/vvBySS8cPrFoQjssKGyFYETuudhcPNw9gnlF\nVYcWPAIgHkCSh9ypfe21hfzrudeYUCdKpDSGzG2N1Yp4IUv7M7o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6253", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6253` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUbSmzxqXD7jYORC8AZ1sfiXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2MzA3OTFjLWQyZGMtNDBiNi05NGQ4LWNhZTZjMjdkYmQ0YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQyODYwNzItOWJh\nMC00NmI1LWFiNjktNmE0ZDJiNDAwYzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEORqOxfUBnYWpFdvR9OjORKC+epiFLqaLhvlAlvscFqRUOYb9PbgW6nRAantl\nP/d7f7yI3wRx60vmXFyJWjMLDqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLFybwtUxg+SQwD+4YIHkixiyqUYMB8GA1UdIwQY\nMBaAFMUWRs5D+WlTuXrisu0+NQF0y4UsMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBI7WT0sND+8b31wwjfR7VIvGd0V38/SsrN\nLVxDcleE4wIhAPyLSgMVfvLaQx9EYl/cvJQpTeOs4tDQNRWIHc67ULFS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAekYFmVHTCG16G2lbuFFYL/HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjMwNzkxYy1kMmRjLTQwYjYtOTRkOC1jYWU2YzI3ZGJkNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8CtT8092/u8AyLtjb8e7ot/CEVtKsQjJ/mOM52V0UxFQs\nWhKgkjhebItGxXpW5vs6DhjbYuudwGHfSNoZat9mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxRZGzkP5aVO5euKy7T41AXTL\nhSwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJD/PIhBpYZXwNXVYSZLD5hF5zVNpGLbqjE2pY8KIoadAiBDIccWZsfx\ngC75s6ePHMljN02PsXusEKARMVor/yPN/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISATkl21KtYYtLQwifnavIH49iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQyODYwNzItOWJhMC00NmI1LWFiNjktNmE0ZDJiNDAwYzJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyZTdjZTc4\nNi00NzM0LTQ3NTYtYTZmZi0xYzIwYThkY2JkODcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQZPqeI9jJJ31IQ6W7KwIApdXbJ6w9UIH+hyO5bbl3SqiUHa5qnzewJ\nAuYH1ik0ATZv4pDYXgHd7xjYlcs4XQy6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSxcm8L\nVMYPkkMA/uGCB5IsYsqlGDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBMjte7Z64jE2hcTm1HOWFodbknmxsOidsro2do\nLXjuVAIhAPwR/RTedNq8phuRwglskLmnyus2H6liKS5uXKxHWWa8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6254", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6254` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQ9NOY1aJiQ5nFdTVuG6TyLNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MjM0YmM5LTcxNjMtNDFhNS05MTE2LWNiMmExMzU3ZGI4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQ0ZDhlYWMtOWVi\nOS00ZTljLThkYTctMGJiOWZiNzUwOWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1EW/m/gSpcochN75/IkbxGJdgUER/LcXnQ+W++0euHWfoLq4kPJ37zaDFQmA\nYUHl2PfqQloTwvkaAIMe2zCpSqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA5aA+W0BUiR3SVcDKDSF/uBMVi8wHwYDVR0j\nBBgwFoAUOTlRJnjNvk7QeO11hZymX+DO4/0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgIBqwtPkJrNur\nuWmbtaHBxVRcUeV7LOIT+zTHhWLuNyMCIQCcipcKllgJbnVSi4NnLpcxZ54A06Cb\nH/OZh7N6zEoi6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbs4y+uuCmqPnd9y7ZWdgrM6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzIzNGJjOS03MTYzLTQxYTUtOTExNi1jYjJhMTM1N2RiOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcrJ8sgUxY7l+ziybms/ul4MD8HJ/fMBRs1B0xEvSQsG5r\n85uA12dHPkGtHM7cQ10sg1lhWFPfAlVpMhbHY53Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOTlRJnjNvk7QeO11hZymX+DO\n4/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOccl1If0E1/qg42afRbkrCsXv4BNuXvSeIxgXDPWGu9AiAcX+tHHgxF\nCcuuFAvy5z5nlmBX27Zw/Mf9NjhFVudcKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISATIiHN9KZxglD/nQp2nvMiF4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQ0ZDhlYWMtOWViOS00ZTljLThkYTctMGJiOWZiNzUwOWUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkODVkZGI1\nNC1hMGIwLTRjY2UtODY1Ny04ZTU4MmU3Mjg5M2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASqg+dGPUG6yG5oqkIwqIPXgzanHUVSE6BcOt6Z2PQYOD5odiAVd7rq\no2cbrPWy5pFB0KNGr26q8QKwX3w0BOZ4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQDloD5\nbQFSJHdJVwMoNIX+4ExWLzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAscgsH1SOFFoa+owSzc3AqiDbTPL4i5XjbJP5I\nha1hFwIgfWCL42aISGPvtpQk3lsQxJh2FBc0D+C9fdH3qL1hJGs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6255", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6255` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAT/2GNJ8Qwll9nXd26vADLI3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkYmE1YTk0LTA4YzEtNGRmMi04ZGExLTkzMjQ3OTI2YTdjZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTJkNTNhMTUtYjlj\nNi00MWUyLTlhNTUtNWFlMzVmMjk1OTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7MCdzI8695v2vwb9+gnB1cGBUy/+zps1B/xf7Lsok69z58nlZlaLWvC9UWfc\nsAJsE3XidiffYi/zcm9ZgjHRiqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnvhCtOcJrlTROjLPpIGSu1JgP4YwHwYDVR0j\nBBgwFoAUX1rJxWXjLEqCOA17l3vmhSFBotYwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgK7syObLwzhdo\nnOpFTBqsIyuexGWhX4pr9KiJwLyIR7ECIQC/rWXOnxIwggK2D5Fv1ZEGJzF6eO6I\nZOWK/NTH5vKx7g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdJQefmxf/qVSkkOg4CQKbHzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGJhNWE5NC0wOGMxLTRkZjItOGRhMS05MzI0NzkyNmE3Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMH3OO2fGXptUlHmiM0FYmFxTg5bTSyN4ukxU2RYsyXY+7\ntW0Q35DEl+Z1O8zza2zLr5RBEa7Tfc48j861pa3uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX1rJxWXjLEqCOA17l3vmhSFB\notYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMtc7rjKZ06wlxihwBcAkFYK9je++TgAl/feV0gvTft5AiBdreXM05Bg\ngWLdXBLFicvyYZulJCIZgqKqCZjBD8cgmg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAV65zaovuFiO7onq6H5Z27U7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTJkNTNhMTUtYjljNi00MWUyLTlhNTUtNWFlMzVmMjk1OTNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYWIwMDU4\nOS00NDg0LTQ5ZWUtYjY3Mi0wOTIyZjk1ZjJlZjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR6dL0eJCwWIgKbehycQCHdPtNQSJeygDJtgay2c5LTyEwAgP2u2J6e\nGtS+NK4m0tT8z6SegHrxgp5a2cYsaezjo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSe+EK0\n5wmuVNE6Ms+kgZK7UmA/hjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAxQfeFsL7fXX5erzJSrm+mMUGU9lsjhM4ixp8\nfQfmH8oCIEjd68/hLFx+tLWZNo7+hD2ngh+Pwmnvedn27gjl7PTQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6256", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6256` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAQDutXXa+268BdGaqk60vPljMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzMWVjNzA0LWJjZjItNGQ4NC05YWU5LTRjZTc2OWJhNDhkNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ0YjM5YzMtMmE1\nMS00OTZkLTkwZTYtYTg2ZTJmMWVlNjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN3WduQMkbl7szQGLvJqT7s+8DTKsgLunNH9UQdh/EaUpnlu3QeWC5bSGEiBL\nUPXp3/YnfLTFyStczQpfsribrqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUkBiQG3dpEW9Xen1Aspf4L6dENkwHwYDVR0j\nBBgwFoAUBDI3WfivJhK3z/b8UNovrsOJXsIwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCS/oMnxAjQ\nWLx2lC37YTnU6X6iEFvEReuKyd1otvErzAIhAIwCsRaDz3/y+FcffMgIsh0YHVz8\nttWYvRUAyDOtHVj/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdj8RvMEihVhNrmaxqEZhEUjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzFlYzcwNC1iY2YyLTRkODQtOWFlOS00Y2U3NjliYTQ4ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvU3ndaPCEAgyl376MiZVw5NIU6XG/BPgFaOr1Z+d1Ix5K\n3BJvmY47r+BzXJoDvBpW9gNE4M0O7rHS3THFMiIYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBDI3WfivJhK3z/b8UNovrsOJ\nXsIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMtpN8WDBInHswTwtl4kcCu1l7lW503IE/NQFK73K/3MAiBzKcUdqv85\nCnwhdcjGKNtdCvs1e/GqfoQ52703m0zLXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAYm3mhjHvtTA3HPLoNenHGUEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ0YjM5YzMtMmE1MS00OTZkLTkwZTYtYTg2ZTJmMWVlNjYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMWFhMWQz\nNC1jOTA0LTRiMWQtODQ0Yi04NDM2YTZmYzM4NGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATvVL1BP9Ztm9eSs4ywM3Z3DGqbp++yFbYUcRWfoJ+Us34ofzkkTord\noEk1APIUftb7ca2eBJDxPYwy9TAVper9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSQGJA\nbd2kRb1d6fUCyl/gvp0Q2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAouhyeLyYPkWX0IbXwbbgcWCG3wUiccq1Emn22\n1g6M/gIgILrc/AEZbLUr96HtS1oZbvwxDyQ20j3uFc+ry3iuL14=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6257", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6257` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATej8Rat5GtNBfIRtSCzvjjeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlMmEwMTgyLTNhNzktNDY0YS1hZjMxLWUwZGU0YTE4M2FiZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBmMGRlNGMtYjk5\nMS00ZTNlLWJhY2EtNDQ4ZjIxNzNjZDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE71z5SA/Nb2fsnvtkRWXQ4F3Rdnyy5jjG2Qo8F5essIaewRBNTC74qDCqtrUJ\nv/YWlxJf6FvLndw+1/YQAd+PUaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhJ7gf6wUDFKZltNqI/zFD8RSBc0wHwYDVR0j\nBBgwFoAUiKaewvGSQYmy+xSam9Rkpqraa9UwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEHgn9jGEbnXPmd4VsIX7hWzoGiDt1cRDpB3P4v4Q3SIAiB5vToxG4E8kxvN\nCc8KRYbdr+kk7fJlHg6DXvsbIeM7PQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUMv0JxNoBUnCJAGyDviUBNXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTJhMDE4Mi0zYTc5LTQ2NGEtYWYzMS1lMGRlNGExODNhYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRXr8/5hhLzh8vKloLQbOLsZbGOzyLIAEXijwAbK1+lPiY\nFYe8jKiAsB3vXnPbdIxXjGDTsbb3ik0cnDx+Pafso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiKaewvGSQYmy+xSam9Rkpqra\na9UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANT8/rm3cy3tP2iRD6QQyPafw4aM4/3zSsCLwLeQ4ao4AiAm9P63OFi1\nPKwZfZVu7VMPK5hsJmCAFLXCgUtBM5TRew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAe8iM9TGpeawWS8pcKbRi6xIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBmMGRlNGMtYjk5MS00ZTNlLWJhY2EtNDQ4ZjIxNzNjZDNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyN2I3MmUy\nNC1iN2U3LTQ2NDMtYTQ2MS1jYWEwN2ZjNzYyY2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQdtmgtA73306OxpaseosmBGLlepbxZ3bbNZwEJZXv40TxNwuOTzrzu\nuiePO5t7o/flNgYTr4GrZYWM1pk/ZbAKo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSEnuB/\nrBQMUpmW02oj/MUPxFIFzTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEArxhe/kEbRHpmBuSoNcJTT91wG0t05qqkdVx4\n0ib8OCACIAdSJynGjAbaTPmU9o1j8F+UPy8Fs2i9/6+OlySnz9HC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6258", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6258` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARvMooRTEwno/+5D1FVujF7JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NmMxMTQzLTU5ZDgtNDlhYS1hOWY3LWNkODAwMGNiYzcxMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc1N2ExOTgtODg3\nYS00NmUyLTk1ZGItOTkyODk2YThhZTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVWRPLPyuM61X05b9M+XUvxpxTeCBS+5VADPcrRYaem8REI068HQl1As9MzsI\niz8MB0J0LD/4AIreij8Bcl1VMqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvXjywduPhmEk3Sq+WgiOepMvm3UwHwYDVR0j\nBBgwFoAU/Xl6XOK/q4Ln9UHEnMoSozhGo3QwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC7COXxbI5mMkYE/ctHUCxyrNV0FariKW0E9Z2W7ABgUwIgBFH/CsSV3ZFC\nIrGagtKwpN6txVqI/6Giz9zYFu+qSOk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfJ0KF1JuZAcYmr18PID5HoZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjZjMTE0My01OWQ4LTQ5YWEtYTlmNy1jZDgwMDBjYmM3MTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd7pWQCek2LW/BM6QeNmyBdpeaWy/SKWhNx0SHORNz1/Aa\nP2oOt5n5GaIA0LjaDQcmb/KCz29Xfe4z/RZ9fSDwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Xl6XOK/q4Ln9UHEnMoSozhG\no3QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFp5fVNpJNzns9ND5KgvBr5voAFA5FYuldFK3QtOIs/oCIAe6BONIZdEJ\nufIBvpDMWvjfIM1S9rOXjmfvcgw821Bj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAW3BMEiTq4uRmJ7BMc3GhoysMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc1N2ExOTgtODg3YS00NmUyLTk1ZGItOTkyODk2YThhZTY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlY2E2OTdm\nZi01ZTYzLTQ3ZWUtYmFkMy04MzA5MmYyY2MzMTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASPs7p/tIQlScZXjfCEwP1QA7Ga+STk9EoFtObfc4CbaxUseqMSl0m9\nxBkR5/lnjZ4LzMJ12cw7/ec9RnFoZDFPo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9ePLB\n24+GYSTdKr5aCI56ky+bdTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiB4KB7YXSy9x9sBNM7twQIZadQysIfpnVipaRY7\npWx86gIgYQRqSe/hfEKggag4Ky1Etg9MBmt+SsFBfI3Ea87831Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6259", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6259` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAW5n5bofJIFRr+tzYjs6BD+TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMmY1NDdhLTI0MGUtNGY0ZC1iODRlLWZiNmM5Zjk0NTQzYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTljY2QzMDAtNDhj\nYy00NTYyLWFjODctMDBlNzQyMWY0NDUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIZp5o5p6jngVFcFi0pjB6QZ0Ajgj4NxcUBTgEKveKeKEIqZRLom08iM0D8KA\nxkM6zM1fE7JZNdkY4gwu+ndI9aOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUskOjL3ciGuSJREhJ0NmmntlBmAYwHwYDVR0j\nBBgwFoAUEEE1qIva8vfKvlfMhtnnT4AumQIwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCy\n3ntojBeCsFtFaNd1yUSnj+/BigkSZ+mN3FGBR7wNewIhAJSrfQstg6czaU2Ej2/s\njSTpMUL6KAE5qXBZdcQeDwMH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfdfUk1nZyzUiabpL7WpwS20MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzJmNTQ3YS0yNDBlLTRmNGQtYjg0ZS1mYjZjOWY5NDU0M2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFOR/qGQoiA5clp2ExWOEuDNjua9PRhKmRczgj5Sl6j/ww\nH1+abW4OPAv92MPcN/VNWBXUSeXHFPPuno0OLo2vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEEE1qIva8vfKvlfMhtnnT4Au\nmQIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge956NjICw/Qf4AJ2Iy4Mld3QO7iz0Ue0tkqiu72vC9cCIGUhh+gIRMvY\nJrI9x3QFrsWrCnk/3X2FahCdCMwtVEIS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAQjmbV2WfCd/lFXCX2TcIk97MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTljY2QzMDAtNDhjYy00NTYyLWFjODctMDBlNzQyMWY0NDUxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NzZlY2U0\nZi1kNDc0LTQ3NDktYTg0NC1iODY1MWRhOTdmNjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARSafUNnBIeKop8WduUXzLbbSi0q3cCr3ukLaSmZeoEYdcGaLB+bOQy\nGu0DaHEuuaQwFFASqAYmf7KOJpyi7YSRo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSyQ6Mv\ndyIa5IlESEnQ2aae2UGYBjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiA78avUXwkpjWTyzwmFT1N741byTEWa8+430sd2\nmILAjAIgYrxGYDQ2xKOaSN8q7WDimPEvPeqIiS+SVviHnlQan/M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6260", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6260` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAbezMbfpFUaINb/71F2DKIVHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExNzAzNTllLTVhZWMtNDI4ZC1iZGE2LTUzY2ZhODA4ZGE3NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ5YzIxNGEtNGQ2\nOS00NzMxLWE1NjktMGI5MTFlNzNjZTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHN8ZpohT6OVlatHq1lOtiofLxofy4I2sToCksHNtvri7M6t3ZVjZkVZ4Gm6I\nSJU5PPgFPbj/Lojzaj/zVyBBl6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkehSmQ4X/H+gZ7HbMxnB++Ii9SIwHwYDVR0j\nBBgwFoAUiDD58oKIjit3Ty508QFPc2s3awAwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFhWWoX0Yi+n2CZ5Shlr/MWg6I9mO/6m/SFkUjv1XFM6AiBMRxYq\nTXKXmlxGo1SU/Dtaz9RZZBKofxXQYgZLR3E49g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUQF7zbBXELLkYnIIAm947VoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTcwMzU5ZS01YWVjLTQyOGQtYmRhNi01M2NmYTgwOGRhNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATO7Gc6qHLu0ikvSVrz7EIWviahYjljX9aDmcWvSqVj4ZLA\nEctnoCxN4TwDxo+2Cl+qj/rvHjaM+bSC8ouo/rmUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiDD58oKIjit3Ty508QFPc2s3\nawAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPSpnuVbRyZ8CVc6RJ/1PbcFkxErBesquNSSb7ud5exPAiA1J/qdXXQq\nGjKXQ8q6IbXh5nK0QX8Vi8ScKTQLC1ReoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAUv9obpQXTAA9Ptmghrs+tGEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ5YzIxNGEtNGQ2OS00NzMxLWE1NjktMGI5MTFlNzNjZTUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNDc3NTA0\nZi1iOTIzLTQxNzgtOGViNy1hZDlmZDE4MzEyYjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARuSTKHu+O+iJq/SW33e5mTWiZl8tM/TjITm2M43DEjcjx63yW1ZjpH\n7c3dVEK+iFq1k0p5AAXx6pYfh1YbJfF/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSR6FKZ\nDhf8f6BnsdszGcH74iL1IjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAw/X3S6I2qrjYFXyytqWVbryBx/cMkg/IgouX\nmkFmcPoCIQDvl2GFQECYwzV3bbAgwLHWUi8QqEQOsUFHBohp3EmvNQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6261", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6261` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAWdhOd9H/85s3CgUbszRuKYrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhZmQ5MjcwLWUwODgtNDQyOC05ZjAwLTA5YTM0OGRkZjI4NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhmOGY0MmItMWIy\nZi00MzU4LWE2ZjUtMjdmZDAyNWI4ZTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAlKRHkp6LBDRUbk/uhrk5EbVOftR8cZgn9giEhk1TyHuZpVGHxB9mriR8zrf\nwxMMbrONdcqe62hNtAdEQuOsxqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGULfjeMSau4MkSTP/9C4hdayRtkwHwYDVR0j\nBBgwFoAUDeqa8rPuFJOlINrfTFP+Nc30DkIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDmNtBAzftVs+VUasKoAdSpG8tyrb8bEJU9+hlohZt1OAIhANEX\nvA9ZV82E+KLrN7sngpLdCPsoYz4vyWPgQaDvrZ52\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATSN7i8Gp97Uyyn5zon2hjGMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWZkOTI3MC1lMDg4LTQ0MjgtOWYwMC0wOWEzNDhkZGYyODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrMpA8Kz8mzdXZ5iiz/Tz2HPCT/Zb9BJeOXt1lYpXajaIk\nNIwHmeQ4UNgvkyyJMRNX7JHL4VfaabUI0kH3NaPao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDeqa8rPuFJOlINrfTFP+Nc30\nDkIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIZpxgGjAAv02EPEJs17Q16FrNP8PLdFGSPAIu+63Y38CIAeIVpyPZLt+\n/LtAUCrC1UtzM1aNvOOO706XWYhvObc3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARROuZSPlqx0WgzwwSPu64uYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhmOGY0MmItMWIyZi00MzU4LWE2ZjUtMjdmZDAyNWI4ZTAzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNjMyYjZm\nMC1hMWYzLTRjMGQtOTZlNC02ZDhlZGEwMTdmMmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQjWJn7biIp9mi+XUVZG3E/8/ytEgcYKYBQqKAJJxydG2xi3zorJp9L\n07b9RDIS6aJCLMnNeILR5ptvHFgzjqqjo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZQt+N\n4xJq7gyRJM//0LiF1rJG2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA2T9e4RGHfizQUlOpFkqq47B8T0tFj4f5iNVM\ncoKGqvQCIHToFKWFqkfr0uEQVPBbgR3syt8JRn8P5WcDkPChoM5K\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6262", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6262` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISASqTV6NhZ8KWf5iYKclPKgeNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwZWI1MjQ2LTIwYTYtNDU3Yi04NDI0LWM1OTgzMDdhYzE5YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q2ZGMwNWMtYjdk\nNy00ZjY3LTgwMmQtZDg2ZjMzYzdlMWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp2S7qGOl1wdEpVOG26g9DWnKQbyMomI42wAscDZINeIpRMFyuwxKDAAnOEAb\ny/SPmPSybQ+JHxVdDlHkAReCdqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOfStaiFoLrT3zRBIr1y38wxWpukMB8GA1UdIwQY\nMBaAFL2YfGQ8QZLP/turRTzzxV8TixW3MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiATYnBG499KYjRJZk7zOcMxbcpRauz4HYZN\nlnD7QhwoXwIgXTk8P9/CV+XMJuKH8UI2hfpdHN9Ga2TwdQ+8FLLV654=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATBm00H0Jyxq6q6qFU8UitwjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGViNTI0Ni0yMGE2LTQ1N2ItODQyNC1jNTk4MzA3YWMxOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtJI/isUcbJ6cn0Wrf2UKNAhWTeGnz2YCvgeGai1/XsyL2\nGNnqmTI1EjeKWURq6bq2be5bAqm3GwvUWriVBXO/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvZh8ZDxBks/+26tFPPPFXxOL\nFbcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAISiJL8OloJFQAhO+xqQKUjWHQ7PyOc1BEe2lWJoVsOqAiArlaD+cgOu\nJIReC8Xtz9qGcCIzyW4szUsWhjcLAnNZ6g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASA56ceZ1Rc3GbSxq/dt6n+wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q2ZGMwNWMtYjdkNy00ZjY3LTgwMmQtZDg2ZjMzYzdlMWY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMWI3ZTM5\nZi1lNDI3LTQxMTYtYmQ0YS1hMTg3OGFkNmIyZmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQuBbsN5zj6LbADXAPlUexmKY/60zjasklnTTZ5G1k+3i29HiiCh9XK\nVnU4NgX/oUx/p7PvmXWbUhs/oFFBdALlo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTn0rWo\nhaC60980QSK9ct/MMVqbpDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAgWr0XaZyYHY+j9iEen+N8I2GRI8CIqGalXTU\nxx79xfoCIHaNLc3D4XT3fYQdp4+hi+ZU5CMQsFY5OOJWaC3jyYyu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6263", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6263` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAZmFWstLYR0/Hh380b9ZVTXzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2Y2ZhMGM1LTEyZWYtNGU0YS1hMTFkLWVjNzFiNTYzMWRiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI4M2NiM2MtOTAx\nYi00NDM1LWFiM2QtNTZiYzRhZWE5ZmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF8l7VrsfPfIgdowMplk5oJ08J8TrhzRuBthui9j7UkO3Gs3p8hCRm5Qvzhcn\nZOA7tHvVtsv9we/EKn3VP8sFPKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURMzVeT51o805+a++vx3awTRl5jswHwYDVR0j\nBBgwFoAUqr4MMhc5WKC7Qpta5BY+mbvKxeYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANzXgF0AdVHp\nIHvz91iD1cOUJIT1yeDd1f0WIZ9q7i3/AiBXpWFnw50z/1HuWUYVuyL6KVUStggq\n4DveqK+JwRkxNg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbpYFifZbeemWRwYJlfD7nCaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNmNmYTBjNS0xMmVmLTRlNGEtYTExZC1lYzcxYjU2MzFkYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxYVmvqYXmXEmLMCZ+wogCyrjxQyO3bq+SltI9r7Z4tdVh\npJDuu8TQA0xsLBOrUVNuNxZJ5x7mAB5U4tm3ttsXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqr4MMhc5WKC7Qpta5BY+mbvK\nxeYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga6ZphKH5EDrymG3hbVicYCpihLQrGaeFY4ROp0ON0wkCIB5psKBDl+om\nVGMy8mOVBkBRMBH7BcDEt3PUfdGocy3m\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAb3x3W99aebz9aN6FlXFc+FfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI4M2NiM2MtOTAxYi00NDM1LWFiM2QtNTZiYzRhZWE5ZmNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYTJhNTdk\nNi1jOGUwLTQ3MjUtOGJmMC1jOWViYjU0NmRjNWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASfyKwCr3LFlH3MMFxgpvnflmIInw+z4/AOpf57xENMdjLtr3jb5A5Q\nMuw3GKdFC0vPjDFiyIZU4ZYnrzoMzAVWo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBREzNV5\nPnWjzTn5r76/HdrBNGXmOzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAkMiXIE7QQOJnalsChQeoX8T3VBClpOAt3OgW\n2q26+UkCIGodR/9XUS9sbwmxSq4OsD6oZPz+Gk2iCTMfDm2QeAhd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6264", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6264` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAY9IU0Mqf2YhJyFT7oM6Tcx+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4N2U3NzhkLTVmYjAtNDc5Mi1hODIxLTJhYWVkMGRiMDExYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZjMGU5NGYtZmUz\nMi00MjhjLTlmYWQtNjk2OWJjNTNkMDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7fF1brjsgxmBncpsuIAGVf22KXVt+9nb1jDa+8G//VlFOJSyGzkI7zQuZcvD\nnBvIYj1drwvMRA/iWoD50cUnNKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqJhzhNvp1q1nS/0DzxZUrKkB/O4wHwYDVR0j\nBBgwFoAUKn+8kRGj7DqSBSZKKb4c0daUnw8wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgQ2/xGgJzwKmk\np99O+v4hk7SfKB47qPfBGQiU2h6hJYACIHZ1qZIiJLESgZh+vfgiptt3zZqUq2EM\nxgwMIa5eLFET\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW34EOdke8iVsN/eDkSeffxqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODdlNzc4ZC01ZmIwLTQ3OTItYTgyMS0yYWFlZDBkYjAxMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR47xNNHeAiQAKfnPf8NVFeIGwzaLtZ50Zwt7Tyar7CFHro\n+8XXQXqTgcHgj6If8x18v8C9qPHQGnritWSWgEYGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKn+8kRGj7DqSBSZKKb4c0daU\nnw8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUc44Rnq7dVLSpVuAMvL+T0a+5aHdaeTw6vfKuRQ3rl0CIQDMu74moujm\nAOW56aetN6i1oguLp9cfr4A0avDhrqColw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVS76Atxpiog7I/7hftgQgXoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZjMGU5NGYtZmUzMi00MjhjLTlmYWQtNjk2OWJjNTNkMDZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhOWI5Nzc2\nMC1lMDFkLTQ1YmItOWE4MC0wZGMyMjRjMmM1YjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASYZ+IwoLiGhhIQXDCOwq8S4WScWObX73U62FzzeYSJXIcn9JESfBzr\nI8hHPlSInYP3m+8nap9tUWBVSvwExpHao3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSomHOE\n2+nWrWdL/QPPFlSsqQH87jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA4AmH+IXQeL05KuCJkN308gRz0W/Jbj1Tln0H\nMr6ZXhkCIG82+4zmfPA/rm3PdezD7vimwAduI6iRpJnh3ZYrilvj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6265", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6265` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWNRfWDsHPV7x2Qjg1DAFNcXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5YjZkNDM1LTEyMDAtNDMxNy1iOTg2LTZjMTc2NTg3ZjhlMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI2NTQ0ZmMtOGVi\nMC00ZTVmLTk1YzItMjZhNjExMGI4ODNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaEPMGnW5zx63zQZ3k7CJqM6PkOl8bysD0/5n7IF48/JY7bIeWEhATtDVXsMk\nYe2JthA/XWFPWry6SiVuVSQ4MaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR1pzPHIcRwaZxnj5zGLiuvuvIkQwHwYDVR0j\nBBgwFoAUax5p1ztXu4Nzz5qzvDaJkEThA1owKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDYP2L4WxtEP\nYbdqN1dwZ2OqujWKB68oED0KP607SBZtAiEA96bilJ2RJ8qLfnDr86a7qeJDy+iZ\nU39i8b0QJaqxroU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATNzHNPFd94BXl/L+gRUkccUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWI2ZDQzNS0xMjAwLTQzMTctYjk4Ni02YzE3NjU4N2Y4ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUGKG+pF5KowOkqRAf3Ostk7cAdm0qVAUbjuIHXnjQD+VD\nfnSLyVFkPP6og9klK34PS+OOx2zN5KAHaZsEvEVIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUax5p1ztXu4Nzz5qzvDaJkETh\nA1owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIU4km2V+16B33ehUD6leh7xvQaLXtPsPfwyrXsIt34sCIQC9xBY+vJC2\nw9+baT10u22OFYFMEq3k1sCmLpgiCWHTdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUM9A66ce/p4rOINqsyxjHeLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI2NTQ0ZmMtOGViMC00ZTVmLTk1YzItMjZhNjExMGI4ODNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1Yjc2MTE4\nZi05NzkzLTQ0N2QtYWI0Ni0xMzg1ODgwZTYyMTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASqv0LXvst+8amtcF3S6bdusKE58rypwEgDLbqRDa3BwQhqJDUwE3+q\nPxq74fPhUdZPcoJzR42bwRPfPtcJSaUNo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHWnM8\nchxHBpnGePnMYuK6+68iRDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAvuPfyBxQI3wdEizgjgINdg31kUlaPGqxAnHrH\npgyZIAIhAP2fwu3Pa6DxaMqMVBC/30Wk7IPn43c6aqsIV2uCuaA8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6266", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6266` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAUYWe6iAz+bOVL9hrgGDi68rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0OTk4MzFlLTM3NmItNGU4MC04ZGVhLWM4ZTRlNWI1OTk4MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBkMDE3YjYtNzA5\nMS00ODkxLTk0NWItZjYzMWY2OWIxNDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsJx3Sxh97qkhtN67svaS/+R08unVWeJJ9oPO5/2b6983JuyJ2LHH10F2cnUR\nyCFO2xTzbgM8jij2TS/X7m7TeKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFVvdPIdwQk2k8MzuBkcSiVpsjiAwHwYDVR0j\nBBgwFoAUdTPZMhXhmYDIHXpUEra/aUYhqL0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAjGyxHdBY+Tvv4VTcO3dMdSim71E6fLxzkXK5ny/tZpAiANuLbRilka2dyq\n2HMXK0EadTFtFYDuTjRTodzUH4mTZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaDCzo+4daivYKz1wV+AyFoxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNDk5ODMxZS0zNzZiLTRlODAtOGRlYS1jOGU0ZTViNTk5ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLDrX2suvbap+FtvXHLbWGY7GWhwuQwUYWOaFZCcEyUhSZ\nC7anUsFHSEMER4Eo4ps3ip6GMm2eFi61g9NY3NqEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdTPZMhXhmYDIHXpUEra/aUYh\nqL0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKC+r5XDEGExILeNkN2ApTB3RSeYnaUjjLk7tfnEz8EkAiBXrbZEwP7O\nDJsiPL2+EggxKBuMWiIDAI3V/e+Po3OaQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdxrlkDEy/ISLnfxwV8VTMD1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBkMDE3YjYtNzA5MS00ODkxLTk0NWItZjYzMWY2OWIxNDRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYmUzODIw\nYy0yZDUzLTQyNjktYjU0OS1kZTg4YzQzMzQwYzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ7ER33GQVwNOI+BwHai/XmjrOMw02KPYkTmzZatQ/obAmTeKtuCFzX\n+Pmc9oBIV96bTBQL5SzIqYVmH+0Tn70eo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVW908\nh3BCTaTwzO4GRxKJWmyOIDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBFVZmCREZ4lXInHFFeVQcbUo+NFeBuTSn1NVVG\nqFHaiwIhAOIwgURNGhkKzgnoQz4JtCwJADpyaCUFV1upD6z7gX4P\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6267", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6267` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAUlpu4FaKkCXs2fU4Vw9UJk/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyYWI0M2FlLTUzODUtNDJiYy04NjM0LWEyZjMwN2M5MDUzNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNkY2Q5ODQtNjIy\nMi00N2UyLWJkZDAtMmI3ZTA5ZGVmODVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1ee/HMmNEzMPYTS98Umx7vA4XYnVjITDvEJtaZP9I+VpvTAoQaot3PDQG2Fv\nhq02dIoucVe5yHEvwscPRmRW3aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUMH+KO6e8BGgnOEyd0JSFS2bP7gwHwYDVR0j\nBBgwFoAUdg0vNASP+Ba5z1iTrLJdkYUZT2gwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIF6H1nBOeWte87sxK+cOJkjbrX7brBO3+QYqD51WYdXsAiBjaNlbi3jnBAQ7\nTz3St25m2mn75rlqM2SWzkPLRN3Mew==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQcpbVWh6/EaDARAY3IC64F5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmFiNDNhZS01Mzg1LTQyYmMtODYzNC1hMmYzMDdjOTA1MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASW2RYNsQO68AuTt9yDIS+jsGmkSoCP6FIPnsEwZvYLl8oT\nhLw7GcBhyjtpjxTmIDsTgBCD2x1AxmjC3KKbquRio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdg0vNASP+Ba5z1iTrLJdkYUZ\nT2gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE+ofjh67THUJ1MY7sQo+0jhV57EYz7amsT2PKhHRDPYCIEiRXoXfrCT4\nZNRrTFh9z2taBd8HsJynU/zkvbM3vjal\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARby3e4V7ZU/MUROCPjJnjiHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNkY2Q5ODQtNjIyMi00N2UyLWJkZDAtMmI3ZTA5ZGVmODVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYTgyYTY5\nMy04OTY5LTRjY2EtOTZlMS1jODA1ODQ2YjlkZGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASrE1FatAIHmuvGtle0gutXaLwVbbDJu6j/1SHm4zCAhWOzKGnLvLfa\n/UjU8lI2Pjmm5RCs4rGJuqPMbKo9LfBOo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQwf4o\n7p7wEaCc4TJ3QlIVLZs/uDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBCRti00wrpQ9OPaIyoDCRr7YxI0QAgWjp+RnG7\nIwSz/QIhANI6HvsxnRpOHDDx/D57/HmiflrmtnbZ0Dd4YSqZvBIe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6268", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6268` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAVMSed/I+/cclu2zfdpHi4GuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjMzNhOTQzLWQ5MTktNGRjZC1hOWI2LTFmM2Q1YTc0MTFjNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZmNTM1NGEtYzE3\nOC00ODgwLWI5M2QtOGE3YWM1ZjVhNjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+fo9JeJNU0CipwEd3FkevHLPzy14khJhOs0uoLrtisfA/82facjJCuKvk0IT\nFEAJcb1x9q1phWm3qSReFdEEjaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpD4ZUYxYoYXQaraoTfRz4WwhmsQwHwYDVR0j\nBBgwFoAUnEO8OXXCUJXwF3VwUADS2wkgC5gwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHqO\nt3E6yGVSBhCBN2iubEZK847dCoCZ+uw3OPsywlwXAiBSKSJFfWHTZATPkSwpFirS\npyNdgVPQL5WZ1z3eoeJlEw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATuJf/UQhn45gLM6LrQ6tsrVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzMzYTk0My1kOTE5LTRkY2QtYTliNi0xZjNkNWE3NDExYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwf/y4pR2qoht3zW17eNRQlNaZI7asFI9d/0EsyQTukzIU\nW0Lpzj+ZNm7vUsbHTdRPFNpz9Ze629Ih2iUL8ByUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnEO8OXXCUJXwF3VwUADS2wkg\nC5gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQUbAptEmBroHxOXd6tIpimSwkoMHjIB41/t6AUtTiAQCIQCAM2mqSrZ/\nREcN/kKP9V6Iky6cn4ScZfpc+Jgdy823/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAQAXPczxagQp03JvxEolgLmEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZmNTM1NGEtYzE3OC00ODgwLWI5M2QtOGE3YWM1ZjVhNjNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhN2Q1YTVi\nNi04NTgzLTQyNjgtYWEyNi03Nzg2ZGEwZWVlMDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASXldFwyw7jZhyFBVsZr9c7/Rf61PP/3A/qSutgYe3OMU6aNgb6HMWs\ndt1eQp1eOkyw/cEMz4gboRufhgl/+q+Xo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSkPhlR\njFihhdBqtqhN9HPhbCGaxDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBOli3zB1GlY9/ptI1bM/SAyyuKbADd5/Gsy4it\notIV9QIgBWoAZaWWnlZ1nVsaBeZm8uQOdA03vUu688iplSPdQSE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6269", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6269` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUOduidRokuEE/e4Zz/nb1I6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2YTY3ZDU5LTlmZGUtNGNlNC1iNGM4LTgwYzhjZDZjZmQyZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQ1OTMwMGYtMjU5\nZi00NWY0LThmYTEtNzVmZGVjNWEwMTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENH3jz7W4LHTDPSdIXYC+9WDSmNX3EG4HAiVHxo2Bm8zz5OyC2K6Kpn+YKG4h\nVvu7G330Q2G6v1Q5eDOpoYoElqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXVezsXOTmhIXR+YoBEIvQ0WJPwkwHwYDVR0j\nBBgwFoAUXFl1Vzdo4LRgEj1/hbCS5hsNgvUwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCtCik+dOAADvh5YdtgOZ7urJ5ez56pPUV2yn7/DHY1OwIhALrt\nvB36B+eXt/dETIknQqaFaM2fSQjT7vH0VK7crJPj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdKpNWedzHyhRZquFZCJc6pzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmE2N2Q1OS05ZmRlLTRjZTQtYjRjOC04MGM4Y2Q2Y2ZkMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/csHkIHg18PsQXbi2TxCL+I5CFp0zQZ3evAP8bDcvg4Xo\n4EmIzPMat6jia94WrBoFITSo+tehqZdkmHY/Lnpxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXFl1Vzdo4LRgEj1/hbCS5hsN\ngvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANs1pwTMOO5KYtOsB9CTCCE3aGVekdnZm+RWj9N1FpnxAiEAvKDmgIR/\nb/hUCWIw9AulYcXFSRezoieKG0r+vvDcrV8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAZia+qiLVC1Fd7IKsyaId6Y6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQ1OTMwMGYtMjU5Zi00NWY0LThmYTEtNzVmZGVjNWEwMTY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMGNhMjdi\nYi02MWYyLTQ5ODEtYWUyZS0yZjM2YThhMDllYWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASGbA+BiwDXOLH9fPvHljEL6+hieZxbdqesYTjjoRiXkBUd0YIkrUQX\ni/PZizr+iEXZfxBRfe0YKKj9XmCmWJWVo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdV7Ox\nc5OaEhdH5igEQi9DRYk/CTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBgWeKNXYoYYFxgT5sze50E4GNXjtgkW0gPx0I3\nbBsqDAIhAIJJ3Q28w8k5niFcZx6TexV3cWQS6ApVtlxRVUCi0TSx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6270", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6270` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYhlwspaWOztyruzxgv7JH4+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1YWMxMTllLWFhZDAtNDE4NC1hOTFlLTFkN2FjMmE4NGI2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFmMjVjZDctMjdi\nNy00OGEzLTg3YTEtZDVjZmVhOTUzODdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4PaKOwVOnRaMSLV9l2hxuVk/hGBbqmIEnvEyNksm9+DnHTMB8hmFV7PLfGmH\nJfhg/ZROuFutqNSiJWh0brzsSqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoAYFWLgVjpqVC0jz83CNdMckfaUwHwYDVR0j\nBBgwFoAU5MeFgqWZnjbIwKB+4w7kriCdCQQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCYCjCXPB1NK3kN0j35fFohJI6rXSlIIygex7D0z9ws+gIgHdh0\nR4MqaQ+uvN8mEE9uPgoJm2ZRhGYbBEqmIngRwWw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUnyhIQryyiDXUJLSBu2eS+zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWFjMTE5ZS1hYWQwLTQxODQtYTkxZS0xZDdhYzJhODRiNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYlEpB/7Yt7f6Tr7CoBNlDILV92BzwGrWrM3RYbiw/2EE+\nAtlbRX1i1Qop7VX/fGFw0NdD4vceQwsYCFPsmb4do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5MeFgqWZnjbIwKB+4w7kriCd\nCQQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPGpuJJWupJbMAidsAjqhwNqydgdywoK489ei52tVJZnAiEAyug+IczC\nBH73cW2v1n15BbfoK8V4+CrvfEXxvss2D+A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAd7cFvnwqTHS6kXrSiTGhAlmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFmMjVjZDctMjdiNy00OGEzLTg3YTEtZDVjZmVhOTUzODdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwN2VhYTkz\nMS01MjI0LTQwYjgtOGJjZS01MGM5MjJlNjdkODUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARV5RTbMbBYNKJ7K5lyAmtVKaPHJ60jbYGrkInYCObZzvv7qzfc62OW\nvC7JWFMRbpw8E/f7yV1lGF5xyiMlmWpFo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgBgVY\nuBWOmpULSPPzcI10xyR9pTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAthzrGeI//91S7pKVcCZBb7yyRKHI9SXF+4OX\nfO9mJBsCIQD3f6EW1xpCbZGf/ktn1T5JCCu51S0VRvqP7XRuqxdJQg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6271", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6271` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcs1MTxhVvi9xNriZz/SVoKoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMzBkZDY3LWE5NWMtNDM2MC1iOTJkLWZlMzk3NmIyNTViMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNiMDgxYzQtYTk3\nOS00NTM2LWI5MGQtNjY1YWY0MThlYTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDa1mbIiTMkQSyHkeTW36zFrys6zE11+BDBMU3/i8i5BBwsppcB2c828H1rw+\n0gx3oFdYqn0Rd3upzTbNiVeLUKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRLc4gMQDuzXXhzv8XUFBRNVnaxXTAfBgNVHSME\nGDAWgBTA05+vFpqbQbM2o4p0atmdLyXTXzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDcpLpU7gzN3U6rdn+n8g6SBYk4QscY\nk1dWu4p1fMZw7AIgGz0KElfoR6U5ufexwkTY8jI2uZniQUz80xdpZrGT2/Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaw8sZ90J2n+O3s97yc7XwvqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjMwZGQ2Ny1hOTVjLTQzNjAtYjkyZC1mZTM5NzZiMjU1YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReH5ACT53X/cbWqSKp87dw7gb43a4b/5/EHvjg5Gvdmmx9\nw+KItV/K192AHb/GgPEhFfLwaE3PKwwoyAqxFkVxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwNOfrxaam0GzNqOKdGrZnS8l\n018wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKYxIcBX/ZeeUqJ4vjNF8iuu1Ps0e8iKbducOLcoKmPRAiEAgrk3Cokr\n4/qqDyY1LY8pDuVKqPHHRl1hgdVgT11G4cs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISARXEIatUXnXgerhMmFEKhzTMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNiMDgxYzQtYTk3OS00NTM2LWI5MGQtNjY1YWY0MThlYTQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZTljMjBl\nZC00OTYyLTRmODEtYjMyOS1lNzAxMTVhZjdlMGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQs+6ZqD60kzy1dD1dgejCgmkOsraiL57LCGpQ4kBqEl5T05UBTX9qF\n3e+IMb5cCBDfxKXxwe6MNnyfuTX/YTHWo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRLc4gM\nQDuzXXhzv8XUFBRNVnaxXTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA35S8Oc/gAJP3kL8qUwb9Non2oaivVXT7ONLs\n3s7WoR8CIQDVFcLzHHxnyrS3Dp6Vvkoa9U3/cKSa2LPH/GEfrqRU5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6272", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6272` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZRsIlR0cGTXdopypJpBFFEpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0NGI2NWIyLWEzODUtNDA3ZC1hMTRjLTY5NjYyMTFlNDEzNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M0YjllMjItMjY0\nMS00NTllLWIzNDYtNzg1YzQxNGRkNmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgCyXNTlJe3fSnyOfrfajdGA7HFK4BGH/3MxhzloVCsCeVpx/iOBYzKrVK0Fj\ngzCC65IYzzGUrIr1gcA5/KQRxKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG8f3KsXpuSRsu6oSMk+tPMQ35pMwHwYDVR0j\nBBgwFoAUcr4eT5KFnd8eNaunkpM88YjiSVEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGRYKfhO/nIF\nfOiyC8RcUZhR2gHD75yT89Q7nx7RP6foAiEAsjitnUYwUrP/yJMTb+b6kfT3Fx4u\nC08yGDRqoQwbA1M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARq0BmN9OCozPfIsXKW4mrheMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDRiNjViMi1hMzg1LTQwN2QtYTE0Yy02OTY2MjExZTQxMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxTQc1wwmzaIsTAuXfIS0C5BXMCKcya6C3EAGBSN+XtkjN\nIOZ10TT4r7kLnWmN0aGMN9g6ykDx+8YlXpHVyNSPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcr4eT5KFnd8eNaunkpM88Yji\nSVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEXHSu6Rgp+/cWzCG6IjsZ3mGDD3I9f479iGOgejfXBUCICCrwfY1bexD\nhsyXL0CvVBOYC9qfuDMJ0CIyCUhRa00B\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAbRBQxkApJ9NvmQMSueXFO+uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M0YjllMjItMjY0MS00NTllLWIzNDYtNzg1YzQxNGRkNmNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYjUxN2Rh\nNS1hNDM5LTQ1NGYtYmFiNC04MTUxNWYzNjg2M2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQcEKkEYdfmezHaF9XT8XMXS8Cu54IvXVZlpnelLT9FuIOsOq/9qY2O\nFRtxgwIAboo0EL9wz5vkKVO/0hXaEM3jo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQbx/cq\nxem5JGy7qhIyT608xDfmkzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAyZdmifaDFRodsjLy8QFMV8T4pdiDpAIBYNfF\nDXpyUXcCICzj4+LKplgM3GkD+e1aGexT0EOUTFRWQG4K4eyFqOd6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6273", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6273` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAaRtJ3TgmdhWsfwxm1NxsOJOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5MzY1MTZhLWYwODQtNGZlOS05MzJkLTc5NGQxNDI5MTNiNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIwMDIwYmUtZDcx\nYy00NDRjLWJhNmUtOTQ2NjBkY2ZmYjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdOQ/LkYtEaGKodijQKrwFw9sTORdApV1niBEFzdyQAmaZg0qrDCbYKrd8x1i\nNCQgx3/7HnaMRRVnGaDZdg4wbKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBiWd8R+PbjAuIYZwc+ZOrqGrK6UwHwYDVR0j\nBBgwFoAUvVvnJLEHRjVZNPkjXS+AsEG9PAswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDaQf8cPU2d\ncnBLoDHs8xa+TzmYM01AdIu4fJFvYG39IgIhAOmlCEdY903cyG1ahkGDTNyQIz/B\nM+kxnnaJvZu7Afc3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU9+Ks447JqYJBIHuozrTwLbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTM2NTE2YS1mMDg0LTRmZTktOTMyZC03OTRkMTQyOTEzYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRrQmmhrkVXuLHYt2aQjapkqKlLV8ra8plmbrQ4tT3oylA\nAoZn6V0y7JYjF9vh81CcmGzI3bHKundhVUn89DVMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvVvnJLEHRjVZNPkjXS+AsEG9\nPAswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf6dB8Lo2vqklKr9M0bVI6Obfq3PwRT4pH5KwCCZlhO4CIHMBmfnnpi5V\n4DoFJfulaPcv8fJVUxRaLkaYquCn1Rql\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAZXgf33DA5lDDj0ywYEykpuSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIwMDIwYmUtZDcxYy00NDRjLWJhNmUtOTQ2NjBkY2ZmYjkyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMzQwZjZh\nMC1kOWM5LTQ0ZGQtODBjNC1iZDk0NDk3OGY2NTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQet7efSiFZPtHqkkMqXecCP5b+EMEmwPOFrhLkUiUid+XqnjIDsh3R\nw+AfvoF9IU0aC7akPSoIxh+Yc38/b3h3o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQGJZ3x\nH49uMC4hhnBz5k6uoasrpTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiATtufkod/wCYHRc893bEvnSk3M+rrN1XQWuA42\ng2psKgIgIFeS3rQYz4jBvinRw2k/KbRDBqf/L2KC3R3ABt2vHww=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6274", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6274` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAaWhebpL0pBDQcz6V3aam0SNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmNzdmNDU1LTVjYTgtNGM0My05NDAyLWNiNGE2MGFkZWM2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJjYmE4ODktZWE0\nNC00ZTJhLThkNjEtN2FkYjE1ZDZiODg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiYMbrxfGoFGUblJbdRF1GVyEkI0dYwyCJjVavpTDQuQlJnD7LyG4A9o61tbw\n9usLum514cSQTSzf9K6WzFMvEaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcS3FiRlE87FoElHOUB/2qua6Yd0wHwYDVR0j\nBBgwFoAUrjvCzMtD12UXWurOEQGHdgVMDHowKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAnCjJjVlE\ngKzKEsVXvv9S14xVt3x+4p+jU3cGPwo9GIMCIQDSirc7MfRZip7IiQPI8Pj2m6xs\nA8/y3cfDo2d6bMwDwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYiFbG58qBXS52FttNdNtn7MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjc3ZjQ1NS01Y2E4LTRjNDMtOTQwMi1jYjRhNjBhZGVjNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT13u6YPluo5AEr34o4rOhILyO8wO26Tk3ix70JSHqhhBm+\n6balnPYEYRLiiHmdCzrcyIOaTWGDlyDkphRf7gN5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrjvCzMtD12UXWurOEQGHdgVM\nDHowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNvO6dz3nIvWfc21Y7xGIWQoSQHL9M2J2Kp0h3uc9Xf0CIGbCug0VgkFd\ndrHMag/9YkvVnyl9204EnEFj6iRdC0cb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAaxN/J8eF6URkIl9BExCEhyKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJjYmE4ODktZWE0NC00ZTJhLThkNjEtN2FkYjE1ZDZiODg2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNzlhNTAw\nMy1jMzE2LTQzNDctODEzZS05NDNkOGYyMjI5MDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATF3qBS7STvQ9tGN/VXTnIIUYbJq0pn3gi1d7DBPX1wODDRd6ldltNq\nRI2FRFMcYnKlPRgka+dzVYzImA5NUEQco3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxLcWJ\nGUTzsWgSUc5QH/aq5rph3TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBn++Ti7D+PhPJDtNm9yW0NCcZutWsdTcOx7Du5\n5JbQlAIhAP5VLEHuvtHdZ9HQIcGl2v3v0woHyuUa4eYc9IRm/aQm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6275", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6275` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAUAfnybIbqlEEPENrmHD2nEtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlNDQ2OWEzLTA2NTItNDg1Ny05NGQwLTI2OWFhYTEwZjM5OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDliNWVmZjgtODlk\nMi00ZjMyLWE3ZTItM2YyM2ZiNTNlMzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9e8E0lNgWvAdOFeresASx3mnWfqxwZwNILKm4TVx8gea4UMuXRKm55qWln3h\nDCOsspxeJf+0q3Rxc+4gMiOrG6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1YwPZTZySQh9CoprGiRPO1O0m+AwHwYDVR0j\nBBgwFoAUnBMw0kj/MsLhKoKn1WY2v9BqKTMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiA1vURg0FajspJ6hzYkAiq0TO+pE1X0YDba7m0UJgxdHwIhAPt4+KU1ymPQ\njTJEeIJ5EwJDj5QfqUqgANbWve9X6TE7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcsKDXUXVZhpQKk6IfofMsGlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTQ0NjlhMy0wNjUyLTQ4NTctOTRkMC0yNjlhYWExMGYzOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQl5ykB2ACzUhWd/EC/PEGRX7y9XAL54s5RnyhsourtGcQQ\nwOQFBukaMlrvVkd5P7HI+qD+4v47fh9MfmnkYdSno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnBMw0kj/MsLhKoKn1WY2v9Bq\nKTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKU8Ic8Mlt5qhGhWO8JhnUPwS/GQwwRH0ecqNSyPhF/MAiEA1nQ1ycG+\n9Xe188IUWGUSrDILsp7kV52myLHdvIsxHcE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAQrzbxTEP+9C/hSeGo4DEnMiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDliNWVmZjgtODlkMi00ZjMyLWE3ZTItM2YyM2ZiNTNlMzY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNjczNDZl\nMi1hNGQyLTQyMmQtYWZkMi03NjVlMjIwNGE2MzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT0K3jbAGHWKDgk9fNr/z+PBCzgqb3sxNIK9RDa+1vcnLG4Abg5ge4V\n00tFA0hrnX5zrwb7NEBa2n6n0Zz3+nuWo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVjA9l\nNnJJCH0KimsaJE87U7Sb4DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiANudHxv7pYNfRVUWi7glA/ZFA9I00vMGT3NBf7\ncKGC3wIgDVXsa9d/lQU5K64kE+4/QsDpk55lRe+xazwdWgZSpn8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6276", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6276` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAR704djPIuqRH75jDgZ6/Hy9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3MjNhMjYwLWU3MTItNDZhMi05OGIxLWQyMTE0Y2U5NzdiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTcxYzA2MDItYzgz\nMy00NWY5LTlkNTQtMjg1NDJlZmVjN2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE2niWisewlLdJPzJ8eL6b8y44f4JTARgYqQp59K55zVkogYeUTEOpR2iMNoj\nd9je5a/odRbhsp1Sl4dESppnh6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdigzHKRgBEoqWfhyciuVTh63nJgwHwYDVR0j\nBBgwFoAUg3Xt9RUu4qOqW+BtAGdHZku4KkAwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAw/Nziigf9ZCE4Z+PUxEKE7z0FBy0vCiaWh52dc7MS7gCIQDnTxWodCMt\neU34Hz/ccHa4iKtcqeFA6sux68AoZw/sJA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAewFTbxFaJzUS0MD8BuZFyiHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzIzYTI2MC1lNzEyLTQ2YTItOThiMS1kMjExNGNlOTc3YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqadKdfgPYYf5uZUllrEHTmkHca5Gn7dG4bQihr+1tiZUd\njO5Sorg5JQsuwoC9toiepMRJQTZ+oXcIsUn0KWyLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg3Xt9RUu4qOqW+BtAGdHZku4\nKkAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIwklXKONvUVtmUiQx5KAxovrXjU7i24RdYyQK4CcX40AiEA+vbpQQTA\nM4xk2QSYEhHShMEclNAOcYTssrA/a2ghTAM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARCYVMLtQTl+8Tpy94gYpSmvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTcxYzA2MDItYzgzMy00NWY5LTlkNTQtMjg1NDJlZmVjN2YzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMDY2OTNh\nNi0wZmIwLTRhOWYtOWNlMi01MzlhZDYxOThlZmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASj2+sGdTUOnsBI9V2S7Y91lJ0d9zifYs26D2IGzSXj0NuCw8z8tDlH\nLkGAvEzYQRcjPhnhqt8S4hcCrkgM/nClo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2KDMc\npGAESipZ+HJyK5VOHrecmDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAusFNfp2txLZhOx49u6Lqic49MDfIdSTHQ7n0w\nJtx3RwIhAOjyrdNEkXrbKvle+vMmnlFNw/EwyV4C+ejsgtKfxEd/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6277", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6277` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAZnC1AqQ2Bsrm3K1aTKx3eOoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3YmM5ZGE3LTAyOWEtNDVmMi1iZmZhLTA5OTJiMTM0NDVmMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFmM2RlYTktYWJl\nNS00ODhmLWI0NGItMzA3ZGU4YzFiOTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE89HzwFHT8orjakdSsGMhgAN0VNxqFFEv6kXxh6SQya/btUalwjL67yfw7Re2\nA0CVnhfzxSUkoQZLSylPzaQZ7aOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUibZK2Rp1zQbCYRThnzWrBQy+qhQwHwYDVR0j\nBBgwFoAUBt9ZpH2ZgQoCq1ZhsRjCweZCk8kwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n5bQ5ry+tNAXPzsYLB+ALWZ0Tf7HMZ92lCU1+RCShVZwCIQC/SFX3P7ErJCTGUZF1\nYJ/6YEL+SSzJ0AVmyruhhIfdBw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY4i2TWiWFEKfZh4biqxIBnhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nN2JjOWRhNy0wMjlhLTQ1ZjItYmZmYS0wOTkyYjEzNDQ1ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDmENFfzHJx8uTEYORH12AHDRaOc5Fhf5ZfAgPIcd26W9V\ngjRLJK1Jz0qkln7dF/2zcIv5+gM6mv4uSqy+p0Nyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBt9ZpH2ZgQoCq1ZhsRjCweZC\nk8kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK2FnbaGWUA1SkZ5mD+9PgTPZtDpK/ozDurhNUhQ5Bc5AiARl9F9swT2\nlxmdAm4QiK1lhb9f3QZIxb9DxdmGAsvyew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAdulpTkO6+lsX+jkLUmvYrslMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFmM2RlYTktYWJlNS00ODhmLWI0NGItMzA3ZGU4YzFiOTdiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NmMxODAx\nYi03ZGQzLTQ3MGEtOGQxNC1hZGJkMjk1ZmJlYjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATtKQ+FGWcedtu6jGTEQ/86cuhmz2v/S8ng2ATvetPthGLqaAVs68Ud\njFFMwDa1vJKmagFZcO1OEl4yS5JqgJkio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSJtkrZ\nGnXNBsJhFOGfNasFDL6qFDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAzvKy9R3ZNsDzcY9/+BvxAsY/IbVL7BJaiwAG\n/kky3CsCIQDGnSeGYY9/TjpAbUF+jzGEtdpwX0j+INbvuo9hkklYvg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6278", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6278` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZ1hhQP3vVz/hZnCvufY32GBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyZTc0NTRmLTliYWUtNDkxYS05ZWMwLWJmNDNiZjk5NmFjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBiMDk2NDgtZWU0\nNS00MGJjLWFlMTYtZDI1NDNlZTJhNGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1U7afXNJ51AWv+LCaYLV8VcuPphHeGIfRpdh+JeqyHlZqYfz6Czv5bulfAg6\nsd+imPnRM5KEkjJqk/4+c1G3NKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmXq/Qe828AI/ceTQc2jICIm3bvAwHwYDVR0j\nBBgwFoAUaV2A9f4b8YEvREHzFgCxG6CLAqkwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA4VP7qmMETQrZzA41bOcQYHXb+ux8oYdA69CgfooymfcCIBJK\nvs6P2jF0Ha38vRO25OxyS9wFkktBcnScm5UO9+7b\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWzUFXv+3WpJ+z7fLIltrecSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmU3NDU0Zi05YmFlLTQ5MWEtOWVjMC1iZjQzYmY5OTZhYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqZ4GYDUP+MvXh+l6sqJBeYIJ9L0EWVXAl5VDTvav8SH4w\nAhyS6zGFlefNW8DsM9HobF7BHo4RS3Kk1eC6RP60o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaV2A9f4b8YEvREHzFgCxG6CL\nAqkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKDGaatGlSqxnPwpwZgRBMfzlcav50bxfAGg++W0ukstAiArU+If+WUh\nuzuiuNZSvq1hh0y7vhc6GrZsprHweNwXNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAT4xARjmGT1R4h+FjoMnnK0TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBiMDk2NDgtZWU0NS00MGJjLWFlMTYtZDI1NDNlZTJhNGViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZWM1M2Mz\nNC1hODJiLTRjYzYtOGVkMi1mNzNlNzIzZTAzZTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATOoNoK9db/FuIwoZezSiOSAUPuQ7sQpY7Bth6acTFT7icwpwkW2eIj\n48p7tjKOA1mixxmYKKJPxh6Qz79GYyrno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZer9B\n7zbwAj9x5NBzaMgIibdu8DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAg2y7zVcs1v+McJ2eAKIlGEHakT3ENzF2TtKy\n7/0rmTECIQCnXNMgI+FnyG2V/LCV7s0ngM4Ubo0BNLIJ/g5Mh4f8lg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6279", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6279` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQ+WuIsDt3+yBR5W1zZ6TVIcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjY2RmOTAyLTFjMjQtNDgzZC04ZDkwLTk0YzFhMDQyNjM5MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JmMGQ4OGItNWIy\nMi00YjFhLThjMmEtNzg1NmNlMzgyZmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdtr05YtqM9qYe/I1n2YyAgOQZhy2TLMxlkAzRHGgcH9+vaN+7aaRq0gqiPl/\nu+9DpEmmXmio2G35DSTk+Qz5saOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2EmrhQNF8pfiwqNflxzCJGgwDCIwHwYDVR0j\nBBgwFoAUiRXhe+iYfIX3PIkmwV/WMe3ddA4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAkbxj5vFwq+8NCdQZ5agMQWyeFs7X4WoWEYCn18hpKPUCID1s\nf3EfaL+oWrr5srWln6UxFhlrSaDhX9eoBNCiJlgX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARerQBnNCN0nlRP1Spiix1WrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2NkZjkwMi0xYzI0LTQ4M2QtOGQ5MC05NGMxYTA0MjYzOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASy4gtDsYyiI40TKLH/764vrtkc3DPXruljHR/i5CGSBqMo\nI7uhIBqRCtaLa1kegRO1kAFBU+/9iq0IRhnpzAO8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiRXhe+iYfIX3PIkmwV/WMe3d\ndA4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeCCp50zTq/TX8XcYuZrPx1zlY1IiMEjAwoGw8QlK/i4CIQC48XWic9mq\nZauBVbD3rQxK/OWT+Kx3XPls6Z90LPoI8w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXe2GLjlcYhK1r3P1yX6PyldMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JmMGQ4OGItNWIyMi00YjFhLThjMmEtNzg1NmNlMzgyZmU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NjRmZTNj\nMy1jYjA1LTQwYmItYjMyNy0wOTE5NGI0MjBkZjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASjsX1RvYUPFKVVzpyw4DPbTPXYbp8YUyOnpZMnqBShHFT5voVcS0P8\nJ9ZH5LrcIrpKLUaeTRsf5yGsLu/HkwRlo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYSauF\nA0Xyl+LCo1+XHMIkaDAMIjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAzLw7dbIwDcQbcBsPANtlGk0OjniRNFmqgnz5\nOxsUGAQCIQCUNSs+EbiRAw71y3e/nlwauNssLGse02AvJTOilRSzTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6280", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6280` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAb65msB+AcJY0yhhQbuMsdh2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MzhmYTE4LWM5N2YtNDU3NC1iM2NlLTBkNzJkYTc1YjQ2NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzk2NjBjOGYtZTdh\nOS00NTVmLThmYzgtYzg4NmRhNWNkOGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElc/dzhOWKT3RyAKaNJv7M2x5H5Dn8UWUOdDrPXFA9H9QeZV8/W/1NWwXDVwa\nZErZ5UkwM41hQiWo2Ee3jTauEaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU29Fu3Kt0vS6hGAuGai+c4cCszd8wHwYDVR0j\nBBgwFoAURQHSmcgSasIlGn/F4rQqCSaUolwwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiA3jR61F9o8Hwlz\nNyqbmELP/VAgGt7VDKela1CHvqIg4QIhAPNBAKEByk2paioLMw9guha879pvjqHa\nWEIaE8U0XjKo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATN7RjgQdCYw5nNpvk7r51P9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjM4ZmExOC1jOTdmLTQ1NzQtYjNjZS0wZDcyZGE3NWI0NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARO3KgL8HtCpihQiJSM/afD3XW7aZmpic4ytMnFTmQkUlZv\nuxl+udCUNeQXBaZJdmf0H5/rky+HuekPgH3UuXZMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURQHSmcgSasIlGn/F4rQqCSaU\nolwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPWrzTD7SF2kXMPtKCwd6HfzN2Cb/iV49BQYm7nJdrucAiA4vQ/84SjT\n7oOipAqRDPlc4XWKziG1m2wxMwpoDaTmxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAW3YkJQKnJa7x6dJcrdnX4GjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzk2NjBjOGYtZTdhOS00NTVmLThmYzgtYzg4NmRhNWNkOGQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmN2IyODIw\nZC0xN2FlLTQ1ZTQtYmI5Ni1jNjQ3ZjAxZGQyZjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATcjHyjykNss117yl/Hkr4WmqIeM4BUphCjOXTgxzbEFhH8XR6HhuPO\nVTkzIbFZb7oW4Lqgiq6v/Nz4tZxWuctNo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTb0W7c\nq3S9LqEYC4ZqL5zhwKzN3zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA/YNWZzP3jR0tlWslI0R2+SfU7pm989rv+0lQ\n6bGH5qsCIHDrZPSJ2hMijggSd7mr9R4HP8TDLIKyLaaqDrZuh2ay\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6281", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6281` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZE9ZJKz5xMowV4cFST1YdquMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyODlhMjg3LTc5YWEtNDMyOS1hOGUyLWViZGYxZTM2N2YzNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2MzMDA1NjQtMmY1\nNi00YzAzLTlhZTItMTYzMTNkNjU3ZTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE14H8bLfMG73Qpe1F4Jvmuld9RYKFAdMcZdYWVdV/JSLEcE4OKYF0LJ63U5Gb\nAwUCXDRiSxK1iZmHN2QVUQfIO6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoEwld0Ye6KLcnmJ7w1w2hBCpUFcwHwYDVR0j\nBBgwFoAUfP8SP9TZ2douD5jdLYVe/38YlRowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDTwiHvjK4PrFeg+IhLUiS/cWWjbPGsae/ttbOi+sPm5AIhAKM96t03+o4b\neotdQsyNGX9J3875RE8LOfxNZMPox38t\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYY7QGB1dsLr3Elfvkr58tEtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjg5YTI4Ny03OWFhLTQzMjktYThlMi1lYmRmMWUzNjdmMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpsHFzii7YXNNgIW4h1K+KM2yjy4vB60ZB159+A+rMcEQC\nVbR0CoSxkJGdsTHZeBI6C9uW+jilrjPxrJ19Qxufo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfP8SP9TZ2douD5jdLYVe/38Y\nlRowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPH3ORhAUilR6Q4TwkGSYsOwQjjDO0k6Av1OvzKEJ2rYCIAHY79jwkIgz\nYaSR4NUQCfAwylN6oTA1SaaDZgWdgK39\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAU0vpWeEDWjtK/beQR2gaEuNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2MzMDA1NjQtMmY1Ni00YzAzLTlhZTItMTYzMTNkNjU3ZTVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhOWVkOTIy\nYi00NDhjLTQ2MmUtYjcyOS1mMGZhZmMxNmQ5Y2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARnFK8Q+uDvnLJbiZsezfrY/fmNYntKNJsSBJIAmPo3ToqYSMoEaJm9\nfXg74EbjtL65sKOJRmTr2rrAmmDmjIa3o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgTCV3\nRh7ootyeYnvDXDaEEKlQVzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAtsLwHw3KR59MPXK4yxkpV32INLCBMgLRxWxo\nvg7N/NQCIGHVjBhDp3yLjWEgtlqu+ufP+Ep3p8AdqnKuFY5Qq7O+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6282", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6282` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAS1fdoqSkGmUZiSrR9jVbJP3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YTBkZWZlLWExMzEtNDVkMi1hZjcwLTc2NzMzNmZiOGQ5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ1NjZkZTEtNTg5\nNy00NWVlLWI2Y2UtZWYyYzRlYTI0OTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEomQbHmB7noW/hfw2L/87RE7iO16K/dc6/mNgq+oT6SV3uHynm1PGErROQ//f\nBX4hASxAzKZTwWD6tMnkCn8XcKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFz13pQrok8z18mOD94yMU+uwf2kwHwYDVR0j\nBBgwFoAUfkZFvGvxRKeB/Lc3i4z3/mckiTQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCmG5LQKvbBIfdnKlTayb8V726VuNkq1I7uWVUBy4l0ywIhAPvmqoRxS6zG\nGl7YGQvRtifK4qK31tnO1CRm8jJq1by0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAarmcdxMMgB+pgmS80fVX5qYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWEwZGVmZS1hMTMxLTQ1ZDItYWY3MC03NjczMzZmYjhkOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8QzzJ9Y4w5lE43UAW59agtqN5IMSMjCTc1swnZ9zAOcA8\nddKaND3aFe8Q/pG5n6kF+HuCgRiaQP4nUabe7bdso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfkZFvGvxRKeB/Lc3i4z3/mck\niTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIR5qQhduQBlfojGXfZNh1CNANKHExDVk3EB1UFgDSv2AiEAjfTZaN5o\nBEr0p7b9Z4uUVAs4Mjt4EjtWfVfKxHSPCbM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAVvFLd3U7qggdlaS3FliCO62MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ1NjZkZTEtNTg5Ny00NWVlLWI2Y2UtZWYyYzRlYTI0OTQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1OTA4N2Fj\nMC0wMDFlLTQzZTAtODI0OC1hYzVjYjM3OWQ5YjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATieKYzZWeycFWZDEMqO006P1g/oCI7mU/RS5DC8rhi/qJgAr3kCuxX\nc3FTuEBMTXMR+z9idNM8ZyzSOi219Wm3o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXPXel\nCuiTzPXyY4P3jIxT67B/aTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEArzXeebgCQqA8mg+f8p/t4SzF8PZflK5mqauK\n4XWdu58CIQCyGM+ypLbnPmZgTWsjVUEFqtGbuVAbrZkhCL3q/CjAHQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6283", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6283` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAbR2brQh8Ed5fdFT2LnOrN8CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzYzNlMzJhLWUxMzYtNGMwMS04OTJhLTUzMWYxOTE5YzNmZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZlN2JiNTMtNDE3\nZi00M2ViLWIyZDctNzRhYmRmN2QyYzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsu8lDIbnH/LeheFPHjXydBkYmHysV8UtvXAo8MBoz07dxZyDU5RL3E+bxRIc\n1wj+ZL6Un8L0TBtY92M70ZRJcqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrk4qa3W7tkKmD/uEmYHm4VU3AhMwHwYDVR0j\nBBgwFoAUHWHYHgBgvC6LKNcUaQjEHFgWoX0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAErzeWGeKbypxbdzKqoIjQHwd2m/Dma8U7yy3OsHkHnwIgKW2UPPYPUaLI\nf1ogx0zJMrwrPGItaVlVCli54tCKTAQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfnVNAv66s+5Hh878u+xxQ1IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2MzZTMyYS1lMTM2LTRjMDEtODkyYS01MzFmMTkxOWMzZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROtaJKtMEmtiPKBSyPFWVfm6KxXkITaqiKkhKiqsyHhxIu\nurfmiWwtP3N/IlsPXnfam7yT6rdhB1BuL5PvktPzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHWHYHgBgvC6LKNcUaQjEHFgW\noX0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOkGRpeGx9IfXVJOxK2tfAq0Nl8mpHliBcJIJ7QUwAz4CIFD+CUyBFiFp\naLkBPRpMez+hLHJWljZKAsv1nljqoiIQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAdP+NO6c4TX/yRTUEkARcXFNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZlN2JiNTMtNDE3Zi00M2ViLWIyZDctNzRhYmRmN2QyYzY2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0M2E4ODM0\nNy01OGRjLTRjMTYtOWM5MS1mZTI1ODg0YTY5OTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQiB/b9STY0tOjc5egf0hxgcFaxorZ0tl3qbD4GkUunlmRU+27hSQG7\nwWovGLZbQvDrQi7bv08j5M9VW7TE5KF1o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSuTipr\ndbu2QqYP+4SZgebhVTcCEzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAz9zPftoxykgjWjlQGTJqxO0FtblfyCUN8mFJ\nB7WTCVsCIHKNZ+LInYzJ/Q2GGy8WzKzT7idwIWkUkHhCOrA+t002\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6284", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6284` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAd2BlxnFObhasU4uf7e9TYGYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlYTY1MTMxLTIyMzktNDg2NS1hODJlLTRmNWY4MzhmOTExZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYxNWRjMmUtY2I1\nNS00NmJjLWJlYjEtNWYxODQ2ZDhkMjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE34W6vOMKfSc2Zlsqni5r1rmcERRne+1JiN6WuyWhhI1lREXLMFtoKdjaE84a\nR1LoeliJ+7Zw/WuIDdhJNzd7jKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmree4ieSGsWRgOnsJ6H3aXz8AoMwHwYDVR0j\nBBgwFoAUGvRYUo3kZd586Y06lNFUF4cqoFAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAVrn0cvgYDoBlarlRoWb1PR/7v1QghvDh47loeXyDi\nzQIhAK2KSaSVBZIepaLitfaaLoyEvYk2RQVhqwF4AXfSjHz/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd6fk/FDd9KKnynBPEw68gciMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWE2NTEzMS0yMjM5LTQ4NjUtYTgyZS00ZjVmODM4ZjkxMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7IKHOjRrtOKDY3fAb5oVqV8kAuDRc2co7/pQzxAgC+2Ti\niPUV8PNDR7S+kPhNwrZGPyPT3zwoPJmXeqZ/R7fwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGvRYUo3kZd586Y06lNFUF4cq\noFAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKy8jztRj1noyC0eZ0JNalloMC0bKgqE6nRBNTa5Ke/cAiBlYZq9Ub5M\nzbxPLYRRryHTF7/Jh2G0msmUTXmvApma0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXLx6pV3HD/Yt0bQtEa0SoKTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYxNWRjMmUtY2I1NS00NmJjLWJlYjEtNWYxODQ2ZDhkMjRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxODVkN2Q0\nMS0wOTc5LTQ3NjQtYTMxNC0wNjBiN2QwZThjOTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQjBMDddyZ0slWe4uxRhslOjqs9eRrp6Buk59bZIzd24ieIJaEUwGbf\nVU0bHcE/+nIon5rfhdscuQ92dPhN6PKXo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSat57i\nJ5IaxZGA6ewnofdpfPwCgzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAqm03OxYgj3bEO5iWah7UHKKDSmvDPOf8gkXc\nfRpZ86sCIQCCk5dkmCWd9rkTjREPbCxn6jDB5pEVIAcBnam26Nnf4w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6285", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6285` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAe3r82+jZAoqfeuFeDJ5XBEmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmYzIwYTBhLWYwNDQtNGM5Zi05ZWEyLTY4MjhiNjAwY2Y5NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFkYWQxY2YtYzA1\nOS00ZDhjLWJhOGMtNjhhNTYzM2U2ZjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdYiOA6g/WNwM/lG4J7KDkFwRsOXDs8VPVdsXn9offNW3luGaJuaDaFXtwPxm\nypVBQaTAZqYden0NV4AjZSyu2KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCvSUhUZ/MN0WLqvmd8MPcRDcHqUwHwYDVR0j\nBBgwFoAUKS0DShakt7gCI6Lus4gvXYW+qiIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAsyQDAS3qcYMIKBqQXbgBrR6S3veyU3FmNsAlyV4W\nfjkCIQCPfWr6Ttq0+SakJClSPz3b2Aoe70HDDCMpsiIZHodvmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX+vSoCsBC2uGZTzHZ4zyooeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmMyMGEwYS1mMDQ0LTRjOWYtOWVhMi02ODI4YjYwMGNmOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV1/GrGq60XvBtA77M/jcB9Lds0rVF+VIfbfmuPc8Qtvda\nL7O/dJF4NCMWtgopEd1io+2gzEcU8PIMG+awKkMNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKS0DShakt7gCI6Lus4gvXYW+\nqiIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPimIgwKQ+jVHzd9iAQD5xZiSHKudNq8q/G5EK9C5IcEAiEAvQW4YZTl\nc+pNZm8VZNl9GscrNk3cPfVAVYtZqixVwTE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAQt+B0On6nGrN/ZGEgi+mxGqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFkYWQxY2YtYzA1OS00ZDhjLWJhOGMtNjhhNTYzM2U2ZjllMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwN2UxNzMx\nZS1jNDg0LTQzMWMtOGJmMS04M2ZjZDE0Njk4YjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT53V18a4TVHgUSYL+EgywgUz7Yw8jz7tx9BBjGnW9pRNyPk3RPNOln\nT+qOsZld5mRvDKAk8CprouCzCUvq0vcio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQK9JSF\nRn8w3RYuq+Z3ww9xENwepTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBnxgJFIxALePcDjxX62Iey9tV2TiVlEE9UF8kF\nrBBzoQIhAKjz3zggxVG6dfb5Ssefz9AVgEiJ/rqs7F3HUTa4n0x5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6286", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6286` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYiJz1RXTltzh+aAAxqM9k4uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzZGNmZjczLTk2YzYtNDZmMS1hZmY3LTI2ZTM4NTlhOWQzZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjMyZTA4NDYtM2Q1\nYi00Njk1LTg5ZGEtM2ZmZDE5MWQ1ZDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyski6eJ+hpbTMGAo7WGGKtjHUYJzNbCWeD2jhRDN96sJScLbLUDqpvCrfPwV\nUTu6S+UCIt9vrnu75+DcUW1WJKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdZC1Drd4eiDI5o69UTj6xiNhfRcwHwYDVR0j\nBBgwFoAUi58fFviojvN7hUxMcRrAQqL7Lj0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA12F3XMc590YLvghAKkFuSQA3SqnZUWMD4CnvD6dNqWwCIH5k\n+UWzZEtn/QMT5XvwxEvZbanSimmF3pP9yAwkOBND\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAURVd+4jqOhZP6n+O5+pfsPKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2RjZmY3My05NmM2LTQ2ZjEtYWZmNy0yNmUzODU5YTlkM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkrqXbqTi4NpGAOuj49BasxKMZQ/Mo5W8YAPstLGCjLzYe\nFFY35InnJWl4fU8aaHzY+OfDs5D9lCe/zUCTSRbro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi58fFviojvN7hUxMcRrAQqL7\nLj0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfZhokFLZ91FhO2dB4YzKHQsQmdzilOQoc2bZf3HxH1QCIBlKiXazYWRk\nEkZhZdZ++Cu3JwYvtOkm4ddY9FNHMKka\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAS+KetrTUq5YcCgSpMwiDITtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjMyZTA4NDYtM2Q1Yi00Njk1LTg5ZGEtM2ZmZDE5MWQ1ZDgyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2Y2QzMWRl\nNy00ZDRjLTQ4YmEtYjQ3OS1mZGMwNDUzZDM5ODEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASlCyMPX8UtaYtxGp5bOPXcg57a+5TSZzA+L602G1kfUKY3DeS3y6MS\nxKBxbAjK2DOArMuP647Jq2UFNDBU8WJio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1kLUO\nt3h6IMjmjr1ROPrGI2F9FzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBxtzk9Cyib4grsp6rk8zHIrywriL9z8kFsTMPj\nE+K5eAIgftEACIF76GoLZzhjxuD/pLe9DtwQpOgVJuBReTjHcHQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6287", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6287` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAYu/IUFX+IsTnNK4HJ6/3DGGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ZDQ4NjA0LWIwNDQtNDBiMS1iMGQ2LTE2NGQwZGZjNWJhZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjIwNGI5ZTctMjlh\nYy00ODRlLWEwMWMtODE2YjEwMmM2NjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErY6NlITE4bIQFDbFjvfXx+/+/LxXPH/yvip9xK/ogW5aqq9lcjEHDDZRtSXi\nXdo+cfju3oezhBTrNrn/KikcmaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqDV0DpJD7l+PhfgfUzRtBLFxKhEwHwYDVR0j\nBBgwFoAU4xOJZZ4Pqilw2R6kezwLvW+ACOYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB/WzF/7G8/CgzTKBl2hWDvWo045LkmyGJw\ntiCNeVUJ1gIgCAMH1KgkGRgxYbgx/4UoI3QjFgEO3/f+iwZl7ytYG0w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX5mS1SNWC4QAvJUAGxezj/AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWQ0ODYwNC1iMDQ0LTQwYjEtYjBkNi0xNjRkMGRmYzViYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT37Yy+RD0iIJ/Jnq/7k0ugKZlomo1NbHBF6626SFSi4vdX\n2jR6VnGRIQ/U1FZcE0/DW874kOpOAPW7V56xVw3qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4xOJZZ4Pqilw2R6kezwLvW+A\nCOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMWiS3NIhCw8uzrQz2EcfIE++4tVMzITFL0l1B/AZlGYAiEApSbpYMGr\nUV06Y72HzfdDhzXkHaRDq6yqViECBYVZcEE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARNzdJOiACMfSyfnKEqlSXOVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjIwNGI5ZTctMjlhYy00ODRlLWEwMWMtODE2YjEwMmM2NjQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YWQxYWQ3\nMy0xODEzLTQ0MzYtOWFlZC0zNWM1MTZmMjM4YzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQSnQd58LctzCFvEPGo8AxohiOh3JiGTf58ec1+1d8vvFg0Y/0SvZvE\nuYyGsOqki7yZ8TetKdd+7ndNz+IB+42Uo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSoNXQO\nkkPuX4+F+B9TNG0EsXEqETAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA9Qks5cyCjl/nn4oi0b6L/4L9WgE5vy6EWORx\nRnfAOGACIBwPCfwSQLVReZtvF4bn6eMuH3p4F6oqtK3mmJnie6K6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6288", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6288` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAY1eY8itI+uBNO1YSzVdw5SWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNzM2YTE2LTI5MzYtNDliOC05YjY4LWQ1MTk1M2Q4OWFhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZkOTZmOGQtN2M0\nMy00ZWNmLTgxZTItYzU4YzU2YWI1MTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt+v/vg/r+z4YEgzfxcDvOA+J4PFnLzrclLjk1Xrx+8XK3cbDZL9wHhFFstUI\nii9/7euXMsjWh2p6ICfmeR+996OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBrulL0xYZmh6/Da57KYV4Dm/jc8wHwYDVR0j\nBBgwFoAUHb0wfFRtxuB09kWj1deQ0IiwibMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAJ24IcgzpyZzGbg2GiH4tjDt1C+j0rpGoF\niaNw1Q6qLgIgFO0+8HeqyeivXU2nu77jv6ZmTMZ92slDCCGIBo8njmE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAag14GEaWqBt3lHh4POS7bo1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzczNmExNi0yOTM2LTQ5YjgtOWI2OC1kNTE5NTNkODlhYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASp//Q+Pfi6KLXE+V7kJXJM7wBMxcvMQQZVZEz4npdhJUXE\neoFu55HD1rMSUSmN/8JcgYHYoHrwlfOB9tcC4hUyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHb0wfFRtxuB09kWj1deQ0Iiw\nibMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO2dc1D8dMXnzAHb54pGEagTaajq6cc1x9T2wR0uzul7AiEA3PGA7zOe\nHz8Z97mcVdLsODz8Lb10tMAcIV0IK66JkYY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASDljIDAzFO6TErVWnf7iirCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZkOTZmOGQtN2M0My00ZWNmLTgxZTItYzU4YzU2YWI1MTE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MWYzYmE3\nOC1kMWIzLTQxZGMtOTVhMi00NDRiZWE2NTc1NWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATUzrCeKwfmQPvYUhajnLTRpcZnX8SUR31htnspLt90Mn10zGUoEaNY\nZHDNXpqJsCD0VUNdSXFJKAsLfjSJ+lQwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQGu6Uv\nTFhmaHr8NrnsphXgOb+NzzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA036wtDNGCn2tOUKmTG0+gCq+nkAQQ4Uk8hAO\nFzlcFS8CIEDgt8cBE8/Y2uGUugLAHBMTMvgzLx3oh8J1VH/nvU4N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6289", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6289` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAcMO7BdhMIa+/lTnEx5Ca8stMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMmUwMGI5LTQ0ZmYtNDY0MS1hY2U0LWVkOGIyZGQ0ZmI0ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGY0NWFjZjctYjg5\nMC00ZjlhLWFjNGEtMmQ1Y2VhY2U1MjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEALKCwjwoufjaGWlfVSACc4n8Jejy3AOcD+O6v2cJy9TGMQ3+j8lJQAfH8MD/\n59tJCT9J5c4jd7hUAoih96AiqaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCHHwbXmIgdtoyCecXaykVSnIwiowHwYDVR0j\nBBgwFoAUMSRVJbYv1he4xGqnmaPjZ2LTpWcwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAtfZYklJkIqJr\ntPcLonq+jh8ZVbkPN1Z4s/kCOiBvZ+YCIGodislqVrMrvzwNRnoC5vYkZ2PlHaFQ\nD9Tk/PoLhT1k\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXZVuGBoRrB4LovzI/f+RfIhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTJlMDBiOS00NGZmLTQ2NDEtYWNlNC1lZDhiMmRkNGZiNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXZ2TqNNOsKnUzKcsdkKeZqMAeeK2DLWSfkDBvZ99hfzU1\n2r1CEBvUhg/jwILmNzHCWJBXRVOYRPVEg5rXruyVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMSRVJbYv1he4xGqnmaPjZ2LT\npWcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ9oUyehmNQe1dw4sMXlEQE3Mqu/KhTmQcetj0UhRZxECIHGXnDKdwhhR\neKm6XrKieXNbkLx/szFXAN6ip+UnHBQw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAVinqZmJw5ypb95eBKxwgV/hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGY0NWFjZjctYjg5MC00ZjlhLWFjNGEtMmQ1Y2VhY2U1MjA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNTBkNmMw\nYi1jY2U4LTQxZWMtOTQwNC05YzVlZTY0YmIyNTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQfetXCQsWbq1whBACDotDV27+4AC6R8oVtHnZTbhJzY+lwZJ3aQoP3\nnjCbOxsqXmbKtQSTPPdKtlPpuLZna4Aho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQIcfBt\neYiB22jIJ5xdrKRVKcjCKjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEArlD5a2SgfLy/rwlfu4ElDfAE1jO8lEDjIyNO\nVhebZqoCIQDYCY0ohxwlC8eLYotTLVGB5DVwBeb1fUkKr9U3FicV+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6290", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6290` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAc8HWlWUE6nwerJg166Q/UMBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMzhlNTg4LWU2NDktNDJlZC1hNDg5LWI1YzA1ZjY3Njg3MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQyOGUxYWYtNmVh\nZi00N2JlLWJjNjQtMWFjNWQwOTA0MTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd3s9Tv3dYTF5NDNE19r/qowfsAqbnkSJubzfQwuT3jlnnTqvw4w39PxHW59b\neeZBzzAwFoqheFcP5PRnxRWqaqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcDt6huNBsulP+UMoPSXzFxgZH3IwHwYDVR0j\nBBgwFoAUcazZiohWZK4uLWYuyC189cvdOUEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCMyC+zBRALWEFvBvbH/eyrGHdQGHO7QlD3N4EwSDWgcAIgHDXqSKMdp9rA\nRV+z+LQuyYwz55xLETnD2bbwa5HqwCA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf8bVi7TEo4hGO+TRTRkuc5XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzM4ZTU4OC1lNjQ5LTQyZWQtYTQ4OS1iNWMwNWY2NzY4NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+NfEap/PiOLuQuKITYZIzVqzHYAcPKNIe21MCGQPUWIhs\nQ/bj92MzSxDcNPMyHsgmSOhy+/VjfbdJn2CXqReHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcazZiohWZK4uLWYuyC189cvd\nOUEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAL5IDpkWqcYfEGBXTjA5fcLhNVQi2O/iSg4Ko/ptZ/sCIDWrpG6tUuxK\nQsEAoeovmTkFxYh8nTJXbFeZwiJO+K0u\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAVsQuGVF8QiAgUSZNPp2gNA4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQyOGUxYWYtNmVhZi00N2JlLWJjNjQtMWFjNWQwOTA0MTQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NzE4OTQ5\nYy1hYWY1LTRjMGUtOTdlNS1jYWM3MTY1ZDJhOGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARdnwqtySHCel6if+mqWEEhKmnuF3haYF+4jaOkilCPA7Jx0ShKWpJ2\nqoP4Qxwa7+SnWh7QBgzxAblk31XXYvPno3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwO3qG\n40Gy6U/5Qyg9JfMXGBkfcjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAyJ+vSGVRNkNkHj7CN7TFPmVKtp2F1LK4AKmH\n/8q+IH8CIQDmaIpEb7QKIrTDz3NlCIyVIj2zWCItXBD1pxhdLM5JWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6291", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6291` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAY/JqrG2U3LT2cz2vu8T35wZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0NjlmYjA0LTI3ZmItNDJlZi1iMmZmLTczNjY2MzMxNjg0OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZkMWU1MDAtZTdh\nMS00MmU0LTg5NDUtNjQ3YTI4YjY0M2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd4BbmJEH5Wc08ffGToA8ebWLNbn6VuCfL3BzV/SgbrVmUS8sYyWojL48Ap+Y\neBqquNE/k1p2IULWXTy6bFal+6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBcE+yqOiUsgR+gmdqEIO99bA8nIwHwYDVR0j\nBBgwFoAUuuTYv3uTYzCE4zLHbHF5MTND1jAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDak3gUqVzcsh+MkBKYV/4VBNRbRpzf3kvM69MSn7MDmAIgaAkm9HY+DgEb\n3H0yXQSTkhJwb7AAE39OD8AfoBZwshY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ5i779WpkAHzJzYqzYyzCEuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDY5ZmIwNC0yN2ZiLTQyZWYtYjJmZi03MzY2NjMzMTY4NDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9PjIM0Guc5xs0LeYXhJuh7/7J8yWHkchtt2fpWa96jDaL\n1ZC/Fu+Lxri9IFxVT4jHmH7wTrfYBP03Lzis027do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuuTYv3uTYzCE4zLHbHF5MTND\n1jAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc6PbS79NV9CnXcUjTrBcNvPhtc5MQLfUB+69nF164C8CIA9oYnnx7Sr7\ncIzI+nXENw7uPUTl4OhgLybn7aMGnL5T\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWNlaVee/XBipK95PzB5Q0VpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZkMWU1MDAtZTdhMS00MmU0LTg5NDUtNjQ3YTI4YjY0M2NiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMTRkMTUx\nZS1jMzA3LTQ4ZjYtYTgxNy01Njc4YTI2NDJiNjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQKgZAxQzPgaFY7T7VE/d0GB9k8ME/sWD7k79zkpWxh8Bs4OGi1BUxN\n32/sHpZzLRXy3fHQY1tpT4db3TNNmWqho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQFwT7K\no6JSyBH6CZ2oQg731sDycjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiAUaajbq+A1BPDXsMAClKeHyf3dZwnPXixNOP7W\n6o05/gIhAI3wrdt/PB41JkEF/mlkqD7u7o6h9IAepVxRwKuOhomF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6292", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6292` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQ/11n4nouwVq26xL3x2AuXLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNmE2ZjhjLWEyNTYtNGFlMC1iYmIyLWRkOGFlN2ZkMWY2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjkxMDllYWUtYzJj\nYi00MmU5LWFiMjktMTRkMjlhMTQ1NTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEriAWPG52OYyZC+oeOTVn6P2UBnGV9oe3Im4klK2hYTVwCySXvOxPY8c6lQos\nqPtWf4rRJMy9n7P9q/LIjIUtr6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5wgP7uoqJJAgkt5lAmcuUNOF7CcwHwYDVR0j\nBBgwFoAUXoLAFkxazSclDSPRcfoUwZwEa2swNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAdKdkgGYhu6B15knSDV1rVxHxYARQV22xfCyRRDzOpIAIhAKg2Yj3Hopqf\nHk8gn/FXYd2oz5dWzOIcLMIkRdNTohtY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY/MBiRw4mK75DcgOwpO5piyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTZhNmY4Yy1hMjU2LTRhZTAtYmJiMi1kZDhhZTdmZDFmNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUAIzP/dqzDApMUK1jwSmVLq7HLQn8NWluYgCzclxQkg8A\nf360ara2cqGniDBHdN4bb8fK35PXnaWIOq8hbbXGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXoLAFkxazSclDSPRcfoUwZwE\na2swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYqfTd8SqGmGJew8bblsWSdkPsGoOTLlNNNRs+zhMlpICIQCp7m7qv4zx\nGvLSzO92Grx8GcD7LA85TlADzYtBDVzMgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAVCcLXkQmb1bgaIZDA1Iw814MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjkxMDllYWUtYzJjYi00MmU5LWFiMjktMTRkMjlhMTQ1NTVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZDc1YmZj\nZS0yOGRhLTQ0MTMtODcyNC1iYTQ0NzA0MTQ5NGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQmmpar4jZP7jUde9s7uXS7+SruhFCsEWX7GwmB1yaI2KP4G2aJhnyR\n4wRRdv314qIT5nqJr7bCEfJIVSFF8elxo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTnCA/u\n6iokkCCS3mUCZy5Q04XsJzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBDmkLV+HWXyTY+zZVVv9e2nWzXKWKjSW2/li42\nYtViEQIhALzX5FEmVMvxDvwR9Ex7rCtrturnAV5DMgZDCl0zJSgu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6293", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6293` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAR4cvHfTnLci1h5bR6PaZ51WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2MTNkNDE5LWYwZGMtNGViMi1iMDVmLTdkODNmODZkZTIyMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdhYzVkOTQtOTYz\nNC00MmQzLWE4MTgtMDNjYzZiNDUwMzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN2QmLEo0duA1gxfKpt5OqZlrskOo/S7EG3h5oozETAxE4IHqHjoXh5PXh0f+\nbBJ/Y3CbxaZSFpQCMWYpMHZHH6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+R52ANOz7LijlK0b52S+l88gcSAwHwYDVR0j\nBBgwFoAUGc4DrqwpAoHb5nk4qfEZXsLha2UwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBzoT3DpPell1Tvm8F/+ncABtHlOH3hiGyM+zUhobxM\nvAIhALSB6LlXfNZN4lJK2dn5p6251kLV8yPV/ua6+/fTe0Mw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAYmhrPLVQifErHBeaxizlZ+iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjEzZDQxOS1mMGRjLTRlYjItYjA1Zi03ZDgzZjg2ZGUyMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3y/1o5l1OTmhs3rH/21anIAajX+RKkQNi8DO9WTJEWo79\nnaUB8dPnCHVRL/g/92O+ejJRUapJ6h8P1JdjmARto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGc4DrqwpAoHb5nk4qfEZXsLh\na2UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIfWOcrHMqNc5giUzytQaUNj34/sxJ1zTQ1x7OpmahcqQIgaHDlQ+cFdHY3\nTQ8T2Z2W2QzLo4BYVwc17Ir8bD00IvQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISARtoyIq43ghCnLkms+Lz7deBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdhYzVkOTQtOTYzNC00MmQzLWE4MTgtMDNjYzZiNDUwMzAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNjUxZGUx\nZC0zZTA0LTRmNjAtYTE5Yy0xZDJlNjdiM2I5NDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATkd1hYcLBYTvzdBP/zRRJjLUmX2oRetTqC3g+MZayruT4MiXVBbxNj\nbY/1B7EHtUPKo5bs+zmJQhFLyjZj/dmNo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT5HnYA\n07PsuKOUrRvnZL6XzyBxIDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA2qCxojqo4Ht+tPe6Os2xzBchD5gmxjjbfeqg\nMX3P5lgCIA3ReU/D6tPlWrxI664lgXiGP0rF+fFsQUsNLkhed4Ch\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6294", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6294` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAaAEdEoFUB4vj0yC2Y3PfBGRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2YzY5NzY4LTY2MmMtNGZkYy05M2M1LWI1MmE2NjhhZDRlMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ3OGM1MDktZWEx\nYS00ODllLTliZjUtMjNmYzEyMDNhMDNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOvlqzRPUfS26RcIEJbA2u7RRInp2gLRKzvIiK7kfq2RoAe1Yhc6f54AShxUi\n2rZxqy41Sz0gq+xy1xQpxwLwSKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkSarqt4B3Sb/ciHiXIslwcvMvBwwHwYDVR0j\nBBgwFoAU9tdN9s1czQ2XoxBSLzpOkw5sYmAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAhadmUZ13VOf4pi+7vzsKvn27k9oR62Hrudv0nqpc\nc+ECIQCVo4N186HlLV0WdWctgT41+54zzHrd7Qrhc1Mz7vLS2Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfUMYfagfNQ0+A0IGXCcwzqnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNmM2OTc2OC02NjJjLTRmZGMtOTNjNS1iNTJhNjY4YWQ0ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREZTluqWt8F4lBqOw8iV39g/TCLFpwersYVBwlpNHuvk2e\npnblPAASkTxQ+s03pse90kO+GU0XixbyYR33Q7ono2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9tdN9s1czQ2XoxBSLzpOkw5s\nYmAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPGSZmcp6xD1Lpb/NpMlVKAnFsXmP/Vuo1v2n6k2NPYyAiEAm3GZe0N7\nt6gi/c5fNzpPRXXn44rgBa/+c5euoqgvDI0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAX/LL1aEH607k3Gw7kShbeEdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ3OGM1MDktZWExYS00ODllLTliZjUtMjNmYzEyMDNhMDNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZjFjNDBh\nMy1lZThiLTRlMGItYTU1OC1mZDI0NzRkZTMzZTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATueWPwkgN5QLYEQaki87wxJfww4hl2Z2XMbRpzo6QCMvktB8Y0/N7L\nMfvp3R4upbF/CGHpcSTBFPWlOQuLa3/qo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSRJquq\n3gHdJv9yIeJciyXBy8y8HDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAnUehgwb6swtD3SD6mvGsQOB/w1dmTi/3QnGu\n+VipYO8CIQCp2ZqmyQJQnOVuI1MpLTaKbGM/GtTVjKsYYdSQsRySMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6295", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6295` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAQDFGwxPoEcd0Rqe5IVvl6A4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NzViODdhLTIxOTItNDFhZC1hZjEwLTU4N2JiNjUyMzdmOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQyODM3ZmUtODJl\nOC00MzczLWIxZTMtM2UyOThhODE4YTA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPkzbhGS2x7p1GXDX9mZP9eewMoIzglcxyez9DZR9iaVi//21wcGEa8MCqiMA\nPzSevWAtxzoVET2Sp+7Uriiwp6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXOLxx18jNsTDPicEarIFiY2jgLQwHwYDVR0j\nBBgwFoAUWfdtldOl4LQSWz5xVtbut5TB+OYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAiNa8jJovKZ87dNFUuoxBaRNd1vYughlbyGUWO93h5EYCIQCU\nssVVwIzuJKqS8bWBrKlaVnLgz9iGvYP7HB68e3KrAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVV1CQRHGPR/lXmNoKMF2jBNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDc1Yjg3YS0yMTkyLTQxYWQtYWYxMC01ODdiYjY1MjM3ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPMPL1JjJJByrZ0HtB3kKDjSz7SvM7bjAw5lMBPxHSpjdk\nyR/D9JLrsbryl2DQtnm1ixcqMvAeqofefzSYdhLIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWfdtldOl4LQSWz5xVtbut5TB\n+OYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWUlbGBJEyI3eSCtWJXDLNW/5utZkUoDesnJU8haLmMUCIGN1t8MGw6vJ\no1Rt+15dI2bBIleTB5sMhfykJbuBRvsX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAaWIfPjblcTj1/TiAfWkuPjQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQyODM3ZmUtODJlOC00MzczLWIxZTMtM2UyOThhODE4YTA4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYTQ1Njgw\nMy04NTlmLTQ1NWEtYWQ1Ny0wZmUwOWI3N2MzNWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASawFRuj9fp6iBeAcYiCgwDDRiOVqT3KcEfB/hoVDMk6vnuMT3OR86g\noCpkshrIrvnIRjtd5I9w2dkgQqkxxWxco3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRc4vHH\nXyM2xMM+JwRqsgWJjaOAtDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBn+144ZOddNd+WoHNyomuObF9q1/VCvnxWhUcF\nB+SpMAIgV+xfEXpz7ht8Qs+x6my2FSFivg83M+nha4zDXYMvUyg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6296", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6296` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAW/FRW2DdEzEsaUyOtBItousMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZjVkM2VkLTIxMzctNDMyYi1hNGFkLTFiZjVkODJjZTY1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNjZDA1NjctYTgx\nNy00ODhiLWE4ZTAtMDdhZmUxOGM2N2RlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERp/au8uETWpvRFJ2CO3yENnxZ5kpB5r+mgbVOvBvdr29Xj23RQjc2RVoxkFu\nCr9Nt36BiZT6EfajqQO6+5nQmaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ygRYiMBuqaX3x8RdInrqQaUhi8wHwYDVR0j\nBBgwFoAU5jRbp4WMKE+e0YPIv200VJ+LS6owSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA/3zusVlspNOGNE3O+8Qr5phwATTT8ktX\nhLMAVKL44tECIQD4vd+doxy/E3Ziz3L94ZUQRLurpYxTnLmWFqreWu6T3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeSZsi1CBL5BR0vH8eAWNW+yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGY1ZDNlZC0yMTM3LTQzMmItYTRhZC0xYmY1ZDgyY2U2NWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyeC/H+1eecPI03dHJgnE469zxNTQwNMFgq+445UBCODQ3\nh2vHJk+qnR7zvOrpaX0iu7TrEBsuQtYm/Mwazr28o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5jRbp4WMKE+e0YPIv200VJ+L\nS6owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdRmh3lA09TJBezr3ir+zfEtr+lnXdGv6yknklFA+EZYCIQDFTH/ZotBC\n933blrRUPOFhd4l8kAjHXNwyH/NeqjEDag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAQP8eX8FhxaUFDtnMYn8srh5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNjZDA1NjctYTgxNy00ODhiLWE4ZTAtMDdhZmUxOGM2N2RlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OGFiYWQx\nMi1lZTMyLTQ5NTUtODc3NS1kNmFmYWE3ZGMyODYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASCoeYzZZwhP2DwVNEMVIezVCWCA1PeijNUrvbTNAzQ2w0s3mhjEPsR\nGCZa6bQv53S/iQQTYvlFFUruZtYcB0RJo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvKBFi\nIwG6ppffHxF0ieupBpSGLzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBz4MrPobBD/8QIdJ8wOH3mKET5eToS7/Xa8EN6\nxt1wkgIgNbubWSRVyMxN4EgiDp1ocaVY+llOvSe9tv0uYqZSPRM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6297", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6297` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATm2sPLEk9eISvD4rQw+OJkVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1YjQ5NzJjLTNiYzUtNDVlYS04NWY4LTg3OGQ1Mjk1NmM1YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlhMTcyODgtZGI2\nMy00OTc4LWE3MTMtNWE1NGVlNTY4OWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo1oXsId6krPiZF7zojFnPk6ZN3JLkw6pMWpYJsw6FZTzeQSC99icvAgRxrfa\n56p6AD0WLFjINO3z+Xyw+OZ40qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbEfkaOXeiEcfROZZ7Dek149A+DkwHwYDVR0j\nBBgwFoAU0k/y4NbhCIwS5NbdudqHU0HrHVAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBw4dCWFVubah51Vu4FjFXb/lsr7FRUJ7NP\njj/hu3LERAIgTMua8v2uypaDgU52EcVS8Rm4YRd63Uy5w+d2dtkHmxg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeUrlvlEYiMlyZSLBHgH0g89MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWI0OTcyYy0zYmM1LTQ1ZWEtODVmOC04NzhkNTI5NTZjNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfS0ZMjSVxCSRZhsaUNiFtmBuqo5JHY6JdaXZQhQwQ7SQs\nNEx0+9GG0bCd1WXZ5rMf+n67ohCvKSEzRTMT0lKvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0k/y4NbhCIwS5NbdudqHU0Hr\nHVAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ5cyMkYxSpEiQXVytKbs3Ib7MukudcmzdC1IFBBztRsCIQCN1HNRRrzZ\nR0U4XvkogdfAxMf7zvMCmhSscBSRiW6GFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWDBvagnST8nTX+EoNckPcy5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlhMTcyODgtZGI2My00OTc4LWE3MTMtNWE1NGVlNTY4OWQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYmVkNTFi\nYS1jMTBiLTQ4MWEtOWQxZS0xZDgzOTIxYzQ0NjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9tTrEl1zM76WWsbcuD9KN8oY0+MiHq9ehrPV3JVuLGWb71l2bdRfJ\n8X70ModP5DquEHlakGvR2qkiqDxkqMLso3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRsR+Ro\n5d6IRx9E5lnsN6TXj0D4OTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAtl9iJKjK8Eb7mwLuQ6D4Jq/t59p1dzHm9vHM\n3WLf7VYCIB/1tdR+1YDj5XWt5rc+mMTMPvSBSH8jMp6oLzGpQcad\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6298", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6298` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAdUeRmVvd94HlKlq9ZXA4qgPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmYzA5OWM2LWNiNWEtNGE5My1hYTc1LWYwNGMzOTAwYjY0YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2EyOGU3YTUtOTg2\nNi00MjcxLTlmZGEtN2RlZTQ4YmZjOGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEAGrQluZK6vySc/o+RFhQNkfIS7HeWP2BCaLvu76xZBpPg2tfB+tVPSQvswN\nf0jXgLyaHDr0Ea4tZmw/PQQ5VqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHgFXC7XPXSHiPZdoPzgtsJ/s+4MwHwYDVR0j\nBBgwFoAUfUPIR03WnzZjg3YHG2xB1SXjc6wwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHfFJZjqO3gkiraobcu8rY4Ok/DZ\n9WJee5aYIqfwfPCDAiB2Z0n53JPoeIAlAd882Gsm9xuTHlhRTRBgteikvxF2tg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWHRpvpVBLYwoDsa2iE66bWcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZmMwOTljNi1jYjVhLTRhOTMtYWE3NS1mMDRjMzkwMGI2NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATB86Aj9l0upCrcSI0XVOes0J9ZVNoMr4kbOrfdH1k15DzH\nBD4HeO2Z9juEgBLfVxn/y1rsVk3RtcBpFTI0iGtXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfUPIR03WnzZjg3YHG2xB1SXj\nc6wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO04U1cQEGuhoTacAmxu0hbUc5dsos3lrSxCIxudFrM3AiEA8aPC5O/k\nIUvEs1mIUUTAghnprGCiftitskFxC6bL3Jw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAT+2u/QTS/sZSNPV5OnnHQ2TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2EyOGU3YTUtOTg2Ni00MjcxLTlmZGEtN2RlZTQ4YmZjOGNjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxY2ZiOTZj\nMS1kZWE1LTRhYzQtYjIxMy1lZWEwODYxNDE1YmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARf1PVGmuvJduu+zNk8XawChJBTgbbZvaFak0e62Aj9/ILZRqcOHT5O\nwX4diDjQotSHi8jvGnpWZbS3/eRsjotso3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQeAVcL\ntc9dIeI9l2g/OC2wn+z7gzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAzll0jyGpyeD4xDDmQnXwO3k5eVoO8mDsWSECw\npRLyQwIgLHrDmAiienNmmidkyE7YvAn7Ewgr3iQwTNBMeBHN04w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6299", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6299` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAZHTdOLe7xN61hs+uGsoM7jEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ZDMwMWYyLWExZWItNDNiYS04YjZjLTc5YTUzZTcxYzJhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE0ZDg0MWUtZmI4\nMi00ZTYzLWJiNzUtNDdkYzM0ZDM0MGJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEciCTDHdxdDwvxqMFcsjWiNfF3Vdl1hV54qj+3mChreGCEtWFvfn2Etjy4NRY\nrrDbiC2HQ4uYx9cH5tpvVHnjj6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuqd6L895qgSPADzdwqdcGyyTcEEwHwYDVR0j\nBBgwFoAUvNnENtRNEQscv0Hz9qlbaUWxBOswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgPcRLVWPZ\nNYWe8MEmM/sYq0UA40miZXJtm10lr+K2ECYCIQCKwGgq5APwKlRZ2fEolExSiE6u\ni6Y6ljNNql+PpOwhSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATq2eEGWDZKQo7IRLx8+y0n1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2QzMDFmMi1hMWViLTQzYmEtOGI2Yy03OWE1M2U3MWMyYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASduj14Afo9GL+w4q7aNqqRoNXR8JuTfcqXNeGklKW4exv2\nQuEMtIgHzXW5McQ4YR4igSNgLecpUByWRhzF9ehdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvNnENtRNEQscv0Hz9qlbaUWx\nBOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOvB02z7yjMKjoWk2Fa7J6CEEbB7be2Y1rXlYcj7IW8JAiEAgUYJjwh9\n9jAfe8UnWTm9zXhueg2xbbhpNcWoC4hvwm0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAd3MoCgOD8eSWyWYxylD1y2jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE0ZDg0MWUtZmI4Mi00ZTYzLWJiNzUtNDdkYzM0ZDM0MGJhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMGNkNjMz\nZS00ZWMyLTQ0YzktYWZmMi1kZjZkOWU1YzRkMWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS2KFPopvjbY+X0OpVwgxmHmAo/EEk4B4QeWuJhZBW7WYqS7CbotaeI\nnN87L/uyiu/BXDYVhNQJjefWAs9DDOVbo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS6p3ov\nz3mqBI8APN3Cp1wbLJNwQTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAzjRsHfHpGZNhkUWb2MkA4upjrIc+Jb8NXWri\ns/voz3QCIQDsbaaxFAjoWi86VctnVHXBRWK9KaEBzNJhPGD9M3OCgQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6300", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6300` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAVe8ShWQLUd+6Yi5AmKVAy6fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmYWNiMjYzLWM3MjYtNDAzOS05OTVmLTU3Nzk5OTM3YjFkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzMzODc5YjctNjYw\nOC00NjExLThiMmItZjc3YjJlYTBkNjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuGTUCJ9XNhljWC+JolhR4xwwdoXmtcNXZzRCLJuNW/G34FolLLkb3RR9AfNW\nG7gd2bQ8NZsj2N3aUYCe/E2kYKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgiKqcu8mJkfVs+mE0VOGqRiZeWcwHwYDVR0j\nBBgwFoAUcfxfvOM4sVz3/o84rCta0Djy4QcwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPUQ9GGP\ndvhT31zhQ/R+yFx9nXL+ZfTQsUD2M7Hhr4PfAiA2Pk/oVcgS4gxwwUe3Q1N8e6lS\neez6rWVs2ObyYj29IA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZqn5Xv3MgUAFFwzJsNKiQbrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmFjYjI2My1jNzI2LTQwMzktOTk1Zi01Nzc5OTkzN2IxZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKlKHRhks0GQmnddKsfTKGeCcayrHuYrWNXgWoqpz2bSIT\n2gVjbtaK0rcVIBaclC/NGoDRvuuN+xJZnIi09DCzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcfxfvOM4sVz3/o84rCta0Djy\n4QcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN9bkHvwAADnJk1acoOUcrkIZoHH0iKJd5MfmWzhNVfuAiEA8ux6E1G9\nddNSm+one46XN4DWUdmSio038M9NVMpWl50=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAXw+vAuQRxq4xf/HZZz0gCqdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzMzODc5YjctNjYwOC00NjExLThiMmItZjc3YjJlYTBkNjNiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1OGUwODdk\nNC0xZmJjLTQ3MDAtODJiZS04MzcyMTE5OTU1MzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATZHT2PX5PgVzWYuraQsU9nXdr/6CbKXQX2PW3RFPlaDpsvIpuKdCby\nzjkhHavyJ8fX2BhGQdZlE5L/P+dRf0hso3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSCIqpy\n7yYmR9Wz6YTRU4apGJl5ZzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA+whvSg/2cPHmieut0Sl2wEcI/WWmUXWrhOvp\nDemU2bYCIQDHNdMIP7lKbCF2FTX6snl8T3Mpce53bILo8BW7SmJTqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6301", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6301` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAWnvVqS+HJJVVn866nSUCIyYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhNzFhMzQ3LTM4NTEtNDQ3Ni1hYWE0LWI4MDU1ODYyOGMwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOThiNTQzMmUtZGM3\nZS00MjMwLWE5YjMtMGIwNzIwMzZlYjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDZlJaoWxpfnLoSWoplfCAa3YC6zfxNKwf5FhjVp9D2AGaTLciyrw3oiRGMdS\n/jo9AzliE+6Uxa/mUc21g3bEc6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz9Vfl7aSuWgYXLgVSZufe5cHTiEwHwYDVR0j\nBBgwFoAUain3230x1Saa/P3lIcCE7YB12DcwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFepzBDQ\nRM0EMiikZnTvP6vAt5sibNTDaWmut3EZEl7vAiEAxLahKwsHEmbIrsV8c2qsLWz0\nEAg40k1qyiwTHXZH/Xc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVQQH5gFNvJTwkpyEL42JUSkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTcxYTM0Ny0zODUxLTQ0NzYtYWFhNC1iODA1NTg2MjhjMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsyW1MlY7vpI5gTY8j7gDax1yYc8KfE9zKX9ckn51yc/bU\nib7CnH7SeGvW3Pq2KUX6LOXfbj/pE+5PjdX1g1qCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUain3230x1Saa/P3lIcCE7YB1\n2DcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDiyTFLcFscRrFr2lEg7mcHExJCX0lFu00rVrooBnjOMCIAr+aJtXBnnK\nNJbXcgg/GJbrP8O7jnLDOPMOu0pXBChC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAQewBKMLvLWYUwrib5DUzppUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOThiNTQzMmUtZGM3ZS00MjMwLWE5YjMtMGIwNzIwMzZlYjkzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZDg1OWIz\nMC01ZjFhLTRhNTAtYjAxNy1jNjdlY2E3ZjJiN2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARyAkQ3T9FT6r1lkDflKbnHnX8tYMk8Phuje0uTV2NNOn3sOBsZUbhi\nGMK4PuGve60Jje1JVHCLIYKm8i3G7DV1o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTP1V+X\ntpK5aBhcuBVJm597lwdOITAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiARRMWWv9Dr7zpd/9oG3EmCne3Smk3TAoKUG8Ph\n6x+RQgIgDj/78RbIzHzGYSd5y55zqAK+4nROb9+ZqHvdc1F7+lo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6302", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6302` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAQvS4s6eHvp/6Q9T33Bb2pk/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxMjMwOTY1LWJhYTEtNDVhNS04MWFlLTE3NGI5MTk0ZWMxNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTAzOWY0ZTgtZjgz\nYy00MDRiLTg0YjYtZjEyMWE1NjFlZGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeomIRCeIMBfSA5WRGZP9wZqrDM4nMbxTdrPDKDqIjH+xEwytPI+WNuphboNH\naoeBaokEVIuRxXGMirrTT70DC6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ3HbM5hOjfCgbvdMdQhdwRnHNPowHwYDVR0j\nBBgwFoAUdtBLYwtoksVXyMme+faWVXsFRY0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIFJDqDU+R5745w5yRH17ApNILpdf0bnhzu9JloMh4nmJAiBL5Fks38mM\nX5gDur7wg3DiTxXZECUOkXPj29GscjW4Lg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd3Ck8Jgoq8xDnlQMx+emuN9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTIzMDk2NS1iYWExLTQ1YTUtODFhZS0xNzRiOTE5NGVjMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2sT5lemHzyCbsW6MXV3SmKBJpXItsX5BTMz1kGPDHX4cw\nUJik9xbKZjzBZTJSNl8bhDYIoiLB0syChgX6SJaao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdtBLYwtoksVXyMme+faWVXsF\nRY0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANtwYJgYtCsjAvP4tpbYWcxMOvC9DQkkJKfilNPer18rAiEAoze/PYXo\nH4UQgSdus8ikaUmnPRQab9MzRU65pBydOFk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAec07oHrR2jlk0rRAecRoyHcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTAzOWY0ZTgtZjgzYy00MDRiLTg0YjYtZjEyMWE1NjFlZGM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMzkyOGNl\nNC1lNGIyLTRjYmItOThmMS0wZDE1N2JkNGVlZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATKnrYELFOr5w1/lRRTEZ0J1GzLvlFXMbE5bohxVjYY69wTIiHHRi5Z\nZioFXKtb5Rzbu9z9biQhvNOzBStjlDFYo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRncdsz\nmE6N8KBu90x1CF3BGcc0+jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA1BbvYRveufYxskjDQEnmEaqqhNmwg5TfOvn6\nBaPi/18CIQCCJlkhkXz82Sbe79k64C61rwtL/4dCi3u3b961PPSiWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6303", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6303` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAU8cFV2RQYpgrU9mPyPuJW0sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1NjdmMDEzLTY5ZGEtNGNiNi1hZDcxLTUwZTczZWNiMDViMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdkNjE3YzQtZTc4\nNC00Zjk0LTg2ZjItN2RlM2M1NmJiYWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0C3SLDb0kNcSoa1ZAxhvj/MfzYues6RPUA5eaVhFzYQg+iB3o3Y0IJzP1/hz\nZtXEB+34tnhnx1BlH7IdzmHGaKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUffccStrQTjC+MzBTQIq0KLUm+HYwHwYDVR0j\nBBgwFoAUcN9gqr6LxQP+XCItF71+06h+rzYwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDGuEzwSPIvYqhcFW0iKydfy/pIKAcH2mdlW/XXQ1NplwIgIRIf0I5/\n65EtUEnhFBpRaIGY8WG1hGu3f2ns3QKKMfo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZFUgEw9IWxq/eVACGP4W/jXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTY3ZjAxMy02OWRhLTRjYjYtYWQ3MS01MGU3M2VjYjA1YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnlgluqgtCvpB72jhk66O0zIiWTv4Z4KaPuQZZJmlUwVTS\n4B12UR+p13RTD63jhPlNGQOHhU/nGeU+ZoKA8DF9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcN9gqr6LxQP+XCItF71+06h+\nrzYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEX0DP3ZsUt3IbSR/OfAVzkkpC7Ju/0x5sUSoXQE5oJkCICAEnCb+SY3j\nM3Y8zTRsMVXSzvIk7uEpFNw6zkPcxW3f\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAXqJHNRBcXqRELZMKcaNRTp4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdkNjE3YzQtZTc4NC00Zjk0LTg2ZjItN2RlM2M1NmJiYWFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwY2QzYTNj\nMi1kYjI1LTQ2ZTAtOGI5Yi0wZjNiNTZhZjgyNTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT03rzdE34XJ5VNfE5nR44bsaDZ9vfpopmRM/QQnPSDOgggza4G3K6Y\nTyK+QzClXFLcRvaGsGlEmX4jCki/ikD4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR99xxK\n2tBOML4zMFNAirQotSb4djAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiB1aG32mJNajVi9uXWCK51oxlJhOKyolFld9BRP\nCe1QdQIhAOtKtYDd03YdzuYzJm5jUTrGH/e8zN9u5F3mlclLcCmB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6304", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6304` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAW9991BHpYOZRDGl7dWWJAUWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5MjAyZmUyLTJhMDAtNGNjNC1hNGUzLTdjZWM0OGI4YWU3ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzFkOTNjZDYtMzkz\nNy00ZmRkLTlhMjUtODUwYzU4NzE0ZTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoPrE6dOKMhNclcv59hWNIk6d/TIyLoks9H29o/sx+MMQ4t6DxU60NaEQxWXg\nwrY63tAH0H2YgATkuSB7E3smK6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNJ6A+cbssvpgE/3eT8RS+tI+qM4wHwYDVR0j\nBBgwFoAU584RRDheOv4OCxEJ+LgIMxVYzGgwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDZWBuA6dRL6m0gGS8ariiGF5G/MRhxFCArRQIrE7Ba9QIgDzl6gXsTHrELBFch\nVNt4ZqHZ8UzeWo/eGnO6/SBj7yk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVQN0DIbdaL7lgTEcYmKIMA9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTIwMmZlMi0yYTAwLTRjYzQtYTRlMy03Y2VjNDhiOGFlN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQx6ESzrtwywH5rRxndzSJ75iGHYNb40VDyBOSUW/DlaDAn\n4opTmMv7+eecFagSbQN94Q3Hhj49VbPgyGgrIkqzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU584RRDheOv4OCxEJ+LgIMxVY\nzGgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHWe3yrKWxUDyoH3hlt9cCO+Xxe7NHjLQQmQvgBigJ5UCICjYG8Keuq1J\nrN1OmmHjuGeuAah6EfyQZCnONIKNrViN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAV1Tt+uJZIzdJSWm9N20XqoPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzFkOTNjZDYtMzkzNy00ZmRkLTlhMjUtODUwYzU4NzE0ZTJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwN2NkNGVk\nNy1iMjcwLTQ5OWUtYjlhYS00NzI1NWRmMDRhMWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7t+Ye75G7wG/iKskGFbfH7QPMzX+EiaeRgp6UuJWoDVQppFX+a9v7\nHkWHbJ4EAb2acLqfJKL/A7pyG1/+4qdao3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ0noD5\nxuyy+mAT/d5PxFL60j6ozjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAgWVJGE3tupvlMNlB3DT7bEL8wymVhN8H0NPG\neiP9hsQCIENNFBZ/ooNxWBVf8hmXYYG0ciGwA8F3Q7LAp/9IQvo8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6305", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6305` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAT5LtuhQGN/7sxUzsGO+mE9DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwZWM4NzhkLTIzZTktNGZkNy05YzA2LTRkOWZjMWRhNTRiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgzNDNhOTUtMGU1\nNC00NjNhLWI5MDAtNDg1NWMyYmEwNDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECx+g9TSIB8zp2ahYoFyYQSm2+THWf3P/cJqLevs46qAtSaN9GB+BDxVkfD3M\n5A+iRTJsOnlOBCtFaiQLfy18yKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt1xTJB1OOQu1iYiaVDorwb6b+PAwHwYDVR0j\nBBgwFoAUFqFpmgkQYPjZpGh//husqCtblL8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCF8tWSVsRTxSdvZ+TlcwoCV0k4fDpkcZtd1bYteQPbMAIh\nALulUsOvHlN/VNKj5+yuxL6iAl/Hgd30pjs92mP7MsO1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT/q4+nNJ0yDdcaf6Kf+4C0gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMGVjODc4ZC0yM2U5LTRmZDctOWMwNi00ZDlmYzFkYTU0YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJa7mtwWOWTxG1AGq8DnfwBNvWS/qzBzwQMw02L+s6hbx6\nplEheUin53HIYFziMSuREwDmmebTTKBQ0sEQ00VUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFqFpmgkQYPjZpGh//husqCtb\nlL8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK/id8IGw13hBu+zhsS8gOq/V1QcAvTnUKqW3k51DKcPAiBZVO+RRGUO\nZ8aouQlqYRLI/5hR5Q3c5fVLf/3Zu1p/yg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISARQENU6s8o4TZFDi6HJHluPOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgzNDNhOTUtMGU1NC00NjNhLWI5MDAtNDg1NWMyYmEwNDY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZGU3NTA1\nNC05MTRjLTQzZmUtYTE4My00NTFiMGY4ODAwNzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS/X/ykm8qCHNgAkkx/ZMqB+ivggkjiVx27PtQcUCYFCNryPU+AkLFX\nJTNn+6U9KdAyl6BMRoex602D1W18P66qo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS3XFMk\nHU45C7WJiJpUOivBvpv48DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAI3NX8/X92uEy6p9SyalirWZ9y4vMjQdmwpono\nWB9QgQIgE+yEfwzLE3s4QAXHqL9yBvNteJMtjUTejK1XjYrN+KI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6306", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6306` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISATKJtmcmBhP8kdliJW2tY5xQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkZjgwZTUzLTRjOWMtNDJiOC04OTFjLWM0YWNkNTY0M2M3NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FhOTY3NTUtNmJi\nMC00YWUwLTk3ODgtZTU5ZmYzNGQ5M2JhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEblrgdGeO1kT4wXYnCyK6vLnouaz9Hoqp4MUOUPIQNEIoA34s0pS2AhtI8R3v\nzvpxoc1mhN+kVVx2pAb9MIlqUqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGNrSGrqIC0qQ6w0DnIgR+fLZr2wwHwYDVR0j\nBBgwFoAUmLPwfC75E82olnFBCKCvhkrY3aAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIE8Aaigf+ynf+Zevgu7wtuDV7EZ8lnBhPNR7+v/2CqRLAiA7\nCXzUc1T+50z5ce8Yi3uLCT7pdPJg0Q+v7YvRNEQ8ZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUNNglin/d+Gplww74NT2wz/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGY4MGU1My00YzljLTQyYjgtODkxYy1jNGFjZDU2NDNjNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqJCCbE4LB+W7t+uxvEH9UssH77DYln+h5ZmXQ7olBWcJM\nkGNF1Bec4zeoTiDZRb3xIZjqlaffftwC+AfW+qwro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmLPwfC75E82olnFBCKCvhkrY\n3aAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNfm/FUyC4qGZj+5Ax0zbwuFcbY9hXq06jcQZCKaONm0CIQDQ3e6iWIrP\nzu9sWxFDlk3m/1VUJZzmNRFfc1b22Uiifw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAWoNlSMRULJOGuLlOCQRk2PwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FhOTY3NTUtNmJiMC00YWUwLTk3ODgtZTU5ZmYzNGQ5M2JhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNDJhNDgw\nYS0xMzM5LTRjMTItOTJjOC1iMmNlMTY2M2UxZGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQY5dSNAcVimBx8KJ4FhsHl5XQcYdgXjnubZjB1VhGGGBZn1YU5YrvK\n+dpJICbQs81NjvxGT6ijHIbzbK4dKQH4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQY2tIa\nuogLSpDrDQOciBH58tmvbDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAnCV2yA65Kcr0ZEAGMys4bA3QleMIILFM5y5h\nRKCiTY0CIHouweU9q7Nqry6RJLaP7BqRC/Druytg30S/2q6rJNNc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6307", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6307` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcgFP2hVM1lEXergmCPgNZC7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllOTFiOTgyLTcyZmEtNDliNi1iZGRmLWViYTFkMjBkMmQ1MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhkZGI1YWUtMWUy\nNS00OTliLTk0YWEtZWNhOTMxMTY3YjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECD8gWycKUWOp80QMZ8lKCdKMwISTdAumEUN/DadFHiF2jsGHxyjsCVi2NqAc\nyujzfKU5bafHiWeTCO0BGnCo6KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBTwni3wVS41U4A9NmrgrAOcBWE4wHwYDVR0j\nBBgwFoAU3jOsRUOA1ZbLpF+O6llJR0Ik6HQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIG5PVB5hU2+s\na+1fc27PlUmKq/J4WvS3hRSr3m8v7yYkAiEA4GJyHOw4mC7XyuSkN5JMNZ507D9i\nP2MjEoda+GSPIYk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATwzYGKIWauwLDkGz2oJWlvbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTkxYjk4Mi03MmZhLTQ5YjYtYmRkZi1lYmExZDIwZDJkNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW8r1cRT4VlqG5qx2bI9M9nppzj327XcOVlH9O6AHVkOWC\nYkczhzDGIssXQiTgNLw02O1WF1DdEYK6XdKKWTBOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3jOsRUOA1ZbLpF+O6llJR0Ik\n6HQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaZ2HRpvsNZitiFo8Z5B0PiDK81uY7WsFPB8heXDzGBACIGWbY8zR47Bz\nQ5jRYX8jdTZq7HvhTXqszq+XKnqfZZUo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAfhYuYFG4DCabZ5wDqE7lxWmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhkZGI1YWUtMWUyNS00OTliLTk0YWEtZWNhOTMxMTY3YjA3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZGZhOTFj\nYy1lOWRhLTQwNTctOTIzOS05ZTVjZDcwMGJmN2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARIgTsxIr6gmp8yd/UQ82AZiQkd+ugpH/x4Ooe5UYwX0K9ZG6hC+0Ev\ncilvcECHMXoc4oqBX6B8pY2SgmFlxsOEo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQFPCeL\nfBVLjVTgD02auCsA5wFYTjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBMsEoiB4xP0vusE52YyZUoOP+efX1oMtK5F9Gk\nDM1ZnwIgYE1eXCyFMs0R7Xpnnkm1oFH44EiD0hfmmaAVp/vEFYE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6308", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6308` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAWufKgeAmyEpnSe3Po+pUxjHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1Yjc3MmJmLWEyOWItNGYwMi04NmMxLWFkMTYxMmJiZTFlYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUxZmUyMWYtZTI0\nZi00MmJlLWEwNzQtNzRmYjM3YzE5NThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX/+3xAsaKkLFwdptnMs82N/UnhKtaGzeiOXbQFouhvE0DyvCzbeN+rt425pQ\n3RveMWY/tJcJrk/KTrYCJclIqqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+omf7CmaDc4o1SdcZSmN+nfJg3gwHwYDVR0j\nBBgwFoAU4eAi3yTlqbVIAXbzPYfA6jAIarUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKw1/jkMQodd+0E4VErObf7E8n7xv1/5M8zKDB/nYYV/AiAAhQUIXtGg\nQdRcc7bIAtDXZOmgTsHPEQARUKkxNbshaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbHTSnMJF2FhLq9IbNirYDktMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWI3NzJiZi1hMjliLTRmMDItODZjMS1hZDE2MTJiYmUxZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcOn8Chmv2qqn4IYnSEABhU+4skld1dlpM3ZiR4fWjmSb2\nNrkukSO1FeQ00AFpqw4ZYhiQLfZq1Tx80q6/MpcTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4eAi3yTlqbVIAXbzPYfA6jAI\narUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIdpG/oa8XJRwIHr3Dw/i52/3HDgkjPQXeKQ7o50Wf+TAiAV8YBhjKrh\num/Hd++ns122op65uiVIR8bxoqMs/r68HQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISATqr5YGOtgk/PUqSklVxkRvdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUxZmUyMWYtZTI0Zi00MmJlLWEwNzQtNzRmYjM3YzE5NThkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMDMwNTBm\nMi01N2NkLTRhMzAtYWE1ZS1iMGFhMTEzZDFhM2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS6ww6BWdd/u86CM4s06p6P9vi5SofxhIMRLziThlhT6tTHLK/V+3UQ\n/ckQj/mICyyUKpsYxmQL8qtxxKOiGpqio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT6iZ/s\nKZoNzijVJ1xlKY36d8mDeDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA0h49KGJQcZ8cm33BKEbBQyCaO5hnw8QUfWng\nVvOClTUCIQCLn2ODAq5WGB7sDMCPHqBi1XQApW7pTn8XiNvlX+ZjaA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6309", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6309` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAW5uP6mDshtEi9ROMwBCVKV/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0OTdhOWJkLWYzMDQtNDRkZS1hYTg5LTdiMTA2MzIyMGQ2ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWMzYTgxMTUtZDIx\nNC00ODJlLWI3ODItYzVlZmE0NWM2MDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdo/0aVJB8cSua7riewB/FLhzZ8psiGO/4E83t4HD1sRIklqv4qHbWEcMOkfn\ne3qVtfJEEarzYUrGxD7tIbp/V6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6C2OYjhUYD7kQnkUIA6qufCyYxQwHwYDVR0j\nBBgwFoAUXJSWFS0rEqZPNzyub9n2HxXOuKcwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANsbT6xH1Mhkb2oSBoFb7d/NkMF0XubCBFNbPVojcuv/AiEA/2HAXym0\nYvUfK0HUvYJITvj6Ty8dLWV3opwZ5hBCRIQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUzOMMpREkLRpJbm9OxaKgCeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDk3YTliZC1mMzA0LTQ0ZGUtYWE4OS03YjEwNjMyMjBkNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZsGFTUgqaUto4zv5IQX98ASskouA5pL1GVcYa++ykKOQu\nZnhGWILJe8bfu8yuhScOUYzcQjfFBXD9xMtZ1DLfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXJSWFS0rEqZPNzyub9n2HxXO\nuKcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGcnmpWWHY0fSWXElxTJOLGrjll8BVvA5Tvp7cgKTvqgCIQDaJXFl0kw9\nHEniCFXSb9HGAAVFmNPBbxQliiQQqucIkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISASPTVWERg1Xatx4vzmoNRqjIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWMzYTgxMTUtZDIxNC00ODJlLWI3ODItYzVlZmE0NWM2MDA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZWRmYmE2\nMi00YTU4LTQ5ZTYtYTA4NC1lOTcyMDQ5ZDJjMWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARG0St+nFH2K9mQncWJ4QYOErhpQg0SasKyby5Awd9AHMLPznM633eY\ndzUiWPBYZgL3bpdRvKWFj9zAdRmlAC2Go3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToLY5i\nOFRgPuRCeRQgDqq58LJjFDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA/RoyCJo2X+SYaiQLn4GYQm+4Yr2mQstRU+db\nF+32P10CIAnhFvm68atPGXJuWKmo8Id2pHYN2fsDHhM3ntwVEmiK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6310", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6310` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAf78M0zyhTyApagORGQ5JNFvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NTU2ODA1LTEwNjctNDBjNS1iMmNlLTFkM2M2ZmQ5ZGZhZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFkMGI4NTctZGFj\nMy00MmU2LTgwMmItMWZhMjU4NTVjZjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK5dB56/K9CHrJX7V95nGCFSHIxaWoDCLfDV4H6Y7K4hmIiohb39pi7GyNdBg\nb55dD90VtRSEkB1bGAVX0LbKTaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQIq69Qm6XJy16CchJrPu2SU5cmkwHwYDVR0j\nBBgwFoAUkAsQ50Yk30UUJXzKQm7aJrLlW9kwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDLRTMnbNo8laxDcytK+UvbZLbTJq74FmMp3iqtur7OZAIgRrH8VOui\nbZTwBViHraixBzflYKzyVqMK26PD+eM+xcQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAamocTTSWWsPmXq6+4fBCgvEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzU1NjgwNS0xMDY3LTQwYzUtYjJjZS0xZDNjNmZkOWRmYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbpr/MumExBbTEI3egl8g1ykCG83B/YiASe3F/Tvrqjm/W\n+dtYpGLnwEVJw8pmZ+KUaykOP5JO66XJYRyLFBX/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkAsQ50Yk30UUJXzKQm7aJrLl\nW9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIRrcfY34jyVYrjjZQ5lqHI1+GnaOO6oFMT9kz8MiYxSAiBCn86RItG2\nc9wQifn9T9G59g5SK02FajErPOVvwFDIGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeDQ0yYYMPbeJM7vbCNRHH46MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFkMGI4NTctZGFjMy00MmU2LTgwMmItMWZhMjU4NTVjZjVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkOTliMWI1\nNi1kMTA1LTQxODUtYTg5ZC1mMTNiODJiMGIyODMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASt/7CV/op9vHkoB4uGs7jr7n49518LN8fdAm/a0X40MSffgNjaZwyt\noEZJimJLQQ4zBoVbaG6kK5dDaKUdGmcko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRAirr1\nCbpcnLXoJyEms+7ZJTlyaTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEA783Uo18PeaTR7JO2Zk/YJ54SNY/s9B9WZi4I\nYa8srmICIE4Md8ZeMB3ej2pBaryrUT6Rc6ygEQ0ax5KSshcXf0c5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6311", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6311` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAbiqtNFVOko6UH0te2+OIkwSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmOTI4ZThlLTY1ZGUtNGU5OC1iNzg1LTE4OWU3NTEwNjlkNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBlNWVlZTUtMWE3\nNy00ZmU3LTk1M2MtZjUxYzJjY2E1MjVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPOna4ZujykdnX38a8OxGIl624DVS8L8XFJBQD2wm/dg/3j8j1QhuTBHjmzSp\nrtQAk8rZDtOVjGl0OWF4aw9ptaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTPYEl4GAJ6cH1loyJUrkhqefbpIwHwYDVR0j\nBBgwFoAUowmOMfbmr9zi+dcEuzeK0eqP4acwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICwgWJ7jJn7CwKFd7xk40um+Lk9nz4/aHT7M2U2t\nIYj1AiBooOhPf+/TOjZkr+xwaojRTP0UiYWriseaxpzoK1W6ww==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeW+Wfe3e6wBB6JrjDCBwzxaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjkyOGU4ZS02NWRlLTRlOTgtYjc4NS0xODllNzUxMDY5ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2SBkvWTAFEn66JvpnN+9wdb2aAvu+0GSf3P/UC99+lrYo\nkl/hVRo+vCanPKvnoogAWgs1ETWMRisxkHS6IQkno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUowmOMfbmr9zi+dcEuzeK0eqP\n4acwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALAQvv/vJEWaPj62JoiukpTujpet2V5fhC/xECwYEIR8AiBFp2g8kSLP\nkc2MPGjbGlwWyhjr5fkVMIzbdme7ZGIq/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAajM366beOLLpbqlAb3epsjGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBlNWVlZTUtMWE3Ny00ZmU3LTk1M2MtZjUxYzJjY2E1MjVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ZTMwMmVh\nZC1lNTFkLTQ0YjMtODJiYy02MGU4OThjMjNjOGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQz16mal4PfyDNqxDeIM/a0hGZcXqRZuYRVz+SkXDu2EZEM7L669shx\nj1n2QpAc2vXD9/G2m7LLX6uzUnpIvxowo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRM9gSX\ngYAnpwfWWjIlSuSGp59ukjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiB9FbId9qQdVCyxFdEhoVYxLD0KUCeHpWW+RywB\nUQnivAIhAOzDEhB2MHpIKnRgECVxSVZ70pZYStx6pjzPcUAUHftL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6312", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6312` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAfth+a+C+pSqpcneum2ocPEXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyNWRlYTg3LTRhY2QtNDBiNC1hOWQwLTdiY2JmMDhmNDQ2ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ1OWViN2EtNjUy\nNi00NjZjLWFmNWItYzdjNTdkZmNiYjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Wd4UPhBM5Ic0GC0YPpTHhlDX+3x9fMJVcO2/51/5aW0O/Rk4i8KxgMcK7pk\ncnx122DL3bxFbGr2eU4tG8T2d6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoIiQ+ocTYcFQXpGqwMXwpeVzDW0wHwYDVR0j\nBBgwFoAU2vHLMwriPh5YrN41foPe5C1HQrUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDd7JMhobHgo2G+HymOfzqpA4y7WSC2wp3Divum\n7lO2GAIhAP45wPeYrQxlP2rZQ0nVd0KJRTdEoC3GeuLwgChZ9P3+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZkUks0igXbK3BcoDMcwVJtnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjVkZWE4Ny00YWNkLTQwYjQtYTlkMC03YmNiZjA4ZjQ0NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7j4AaRh9nld2f8SD+KMC+GJyCfiU7ETT/B3qjvZDkwTId\nOeExN9ADjOmqTE7y1Y9Ziaqmgtm1C0KbyU3CWf8Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2vHLMwriPh5YrN41foPe5C1H\nQrUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANxshnAz6pttVhIcy/uokV93r4YWLv7Pj6THOjjKmZ0qAiEA9zNfY+8s\nocZqfnxXJyr+2xjpQAzUX9WwyJjYKl5Bn/w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAcOJuObBFGYKU5Mu++N2nP28MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ1OWViN2EtNjUyNi00NjZjLWFmNWItYzdjNTdkZmNiYjg4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0N2VkNWFk\nNS03NGE2LTQzYWItYTY2NC02N2Q0ZjQ0ZGRmMmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATNz8WYf1kYYVN4TEbdJowgyQs55Jz+HTYxdIN9Xozf5LyFrTU4e2h6\nCG0qxctxjBdrNuOCtZeWI5LuDRwjBp2no3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgiJD6\nhxNhwVBekarAxfCl5XMNbTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA6nrT1QZwR9Hp4gxoBHimVa+efNa7E8CLSlw+\n8kJK2ZECIQCme1brHPs13H3Zy3DaPxd5SvAEpWzU82IivW+j1vgFuw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6313", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6313` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZfc/eOIv81Vd5GJuqkA8n1DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5MGIyMzQ0LTIyNGYtNDY2Zi04YTQxLWZkOTFmNjRkM2QwMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzFkODM2N2MtMjdi\nMy00ZTNiLTk4YWYtYWIwNjZlOTA0ZmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzQkawXniHme5EKqAUOUpAirV4bX2oOlVglOdGJtAOW5l0KV0Gp3NUiWu5DqN\n9MczTG+0ukyxKLM24J0uc7raUKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGPe/a6md0U26wQ41IWHomMKLupkwHwYDVR0j\nBBgwFoAUXVO6AkpFHxW9spnvZbkM9NYLlGYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCP0HmE6U83nEAZ87vHNHGMwzkAxceBoYWkup8CnuMCwAIg\nKS4HV7b4aB9yZyE9qYljNyyUSYKQsKJVlaPGCgsprbU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUappFIDBFAowwD3Fp4EZJggMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTBiMjM0NC0yMjRmLTQ2NmYtOGE0MS1mZDkxZjY0ZDNkMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzIcPF3R7o1tNTM0s1jBCVBf5VsPVBQ2jAuNzbLdnnHenL\nSwi7vC44G57DAfZPcesEGWYEWkBdnup7O2IjZ1dgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXVO6AkpFHxW9spnvZbkM9NYL\nlGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKggZEOTUvRSJ2Asr5+0P23ZTtIgqrkPYP3i1+9BvWZjAiA9tjlPGdTf\n4NpXTUWzRsWRIZjJImPrl6vBZ7y/3LO9TQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISARWQAU3R6YRLybHPGoyjw3vMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzFkODM2N2MtMjdiMy00ZTNiLTk4YWYtYWIwNjZlOTA0ZmUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OTYyNzhm\nNy1mNDkxLTRiNGMtOTlhZS02NGFkMTY1YmI1YzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASz8lxP377ctumHUQQ+Ft6nEjftTgoQbkv4FRX7W8Yi5ScAsoIU1e26\nLUxhS1MeXSvHJo3sV9qn9GH6NZJWTMIyo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQY979r\nqZ3RTbrBDjUhYeiYwou6mTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAmI7lVJ+L9qDpNJdefqccetRSPIhLSVzcwItx\nRpTg9jECIQCgQHDfyCVFTRxa8U8fhAi8R5lGV/MsauMrFAyriaoVhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6314", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6314` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASCzbMoEb3YGu9FUIVQJ3n6TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3NzNlZjg4LWY0NmMtNGVmMS04NjFkLTI5M2ZjOWNkYmQ2NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFhZGJlZWUtZDI5\nOS00YTMyLThiMDgtMGMwMWQxYmIzZTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECpImsA1JAgG9mGJcuFX6jpFKLDvfoKInLySiaXVaH1JynReX4Q1Co265N7JS\nXg6QZF1ZLozW3jB4wCgVtAFSDaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxTDoMHm1JSFi/bhy1uBIrR96PnUwHwYDVR0j\nBBgwFoAUQnGWmegnll7RP3q8tkwyKAt0e5EwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAnBD7iAT0gIzMOvM31T6QRuVGCLGEEs\nrZrmRcCkMRdFAiEAm6jszt7q4NNp3RWeILkYreTOM1yRSjfIb+gT9zmNIZc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZnwxoPbKwUdzFtwZzN9VCQ8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzczZWY4OC1mNDZjLTRlZjEtODYxZC0yOTNmYzljZGJkNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/nkh7DXRdPUf7QVIly1theTDyKz2WLvZRL1GOQYsn1JVi\nzlhZDhrUqktG2A6qDSTAXoIHWxyZBogitjw56lDKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQnGWmegnll7RP3q8tkwyKAt0\ne5EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKYDi1C2mlTxLpsq+q7OD7fOOObpFD7JNL4/0OVAL1rvAiEAwITsm6Vu\n2TYfsNa5Z3+ePXTRHIT05uxeHHNzMEd/VhQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAU0Zrrhq4nZVu9jgIgQkzHuxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFhZGJlZWUtZDI5OS00YTMyLThiMDgtMGMwMWQxYmIzZTRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NzM2MmM1\nMC01OGQ4LTQzY2YtOGQxNy1iYWYwOGQ2ZDEwNGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASB4F0bRDobuJ0u96c9xbPxWTBtF0nBFOk/hfHQt/1Qm0Z2IgwZdYOA\nQDNfu9nTs0AhUKs8SeTAUQ12UVskEWXzo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTFMOgw\nebUlIWL9uHLW4EitH3o+dTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiB52ftPfpK+8h1zvyI/h9xNdNDShryGap2aLnxj\n9PihCwIhAOQdWPx9n2wLGNp6ubxip9y3I2Uv2q1RcVISu9VXYYcC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6315", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6315` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAfMyru2me/+xg9BfAUaTreWTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjOWZjNjQ2LTQxMWItNDY1MC04MTc5LTRiMmZiMWI5ZWJmMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYwZTY0NDYtYzkz\nNC00ZDdlLThmZDUtZGZkZGUyZDgyZjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENGyyL81K4f25Fk/Ry+6T5zzQqYo8+blEPojzOjbBwPEr92mWRwqJaZ3cKWd6\nszRYC7+F44jiRVkVEhURcA+HhKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3J6e27MS3zZJIAXj+vDeWPriXsMwHwYDVR0j\nBBgwFoAUnA/gyCsBgeXyEB71HgWOO/jUkFIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD5b/viyGfz5TbkNlkL/3duJRD45pmc\nhwydvliQNLk0zQIgdvTtsBxtvwYoL94RVJ+u74jUgSIX9Uxcty8SF3ltsn4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUpOr8vLe0hi5sxkQD2/a3IeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzlmYzY0Ni00MTFiLTQ2NTAtODE3OS00YjJmYjFiOWViZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSZPP1fpm6Iy9By6jKvmh2C1PnqgzHDXZ0m/bmn4vEA0Za\ne3c6AOmZyKJgCq7fWFhbG+6so7fKR1bhFNncFJBao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnA/gyCsBgeXyEB71HgWOO/jU\nkFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANoGenV5uUbDeRoq1WsmnafJc1DHep9WZJtpYz5iVt4JAiEA7XmHq1Tc\nXEf7t8BJTar038/C2dAQOsGEyFyEgMxlgHs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAT7yzzGcxdzY96bIfYA/CIrZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYwZTY0NDYtYzkzNC00ZDdlLThmZDUtZGZkZGUyZDgyZjlmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NGM1YzIz\nZS01Zjc0LTQ5YTktYmE5MC1lMDFjZjA0N2Y1ZmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT0KNZGjaJO9I+EVSbYaAG9u4LpgSKVXr6cEWv4iKZH0i9DxOPK8XGu\napB5XRSd0XLfEk5ol+iFvgYBCeDeuSGMo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTcnp7b\nsxLfNkkgBeP68N5Y+uJewzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAKBl9Y4ynT+CMRtFOezu6gdHC8+aQUWqGspJVs\n+IKKJgIgUbWAUhfzqG53CBV7FLZnJDqrLyOGusJ6yHbLl8j68Bo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6316", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6316` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATEILBDcDN/T1ndl/jsfwWBtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ZmQzMTliLWI1ZTMtNGVkMC1hZGM1LTNlMzNiNzY0ODQ4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjExOGJlYWEtYzAz\nMS00ZjUxLTkxNWYtYTZmODUyNjI2NzIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf9M76BtIucgQnRrgYL2FPFUJiPF0w9J2NBhcp7z2zt/ETwNCUUGdIi/kD01V\nNlFKprcTF/tZJD3gPF852lvoXaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnk4Q54rqqAU3rDcwMnIb8rGjetUwHwYDVR0j\nBBgwFoAUhAQaXXMbZurfW9dCoq802ev0thkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC/PolCvT/k\nn9HDZ9aypaEstSy8pSy7odJQ7mwprRBuRgIgJLX4S6Z/0l6OBiYR9EOpLVquQfhR\nfqY0n/2tbLLeUSA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAStWUmYmYzFhDN7van4Nb9qHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWZkMzE5Yi1iNWUzLTRlZDAtYWRjNS0zZTMzYjc2NDg0OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSk+x39S2cBM2Ess1ZJXme2VwTQjGLr+HLyM1qc+YVco6S\nmLt9C5O2CIG68vukhmjzK6sXOoLFBKYsJMUt5h27o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhAQaXXMbZurfW9dCoq802ev0\nthkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP+0tov37zUD0kgKxTYRxmgV8BQ1wGkNs9YThZQAbKW3AiB6M0CgBW6n\nfmqnblA7z5OnLzLn5ms5P3s9X4irNJdISw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAf/1+SIXZ3UzcI+CS6fHDZOtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjExOGJlYWEtYzAzMS00ZjUxLTkxNWYtYTZmODUyNjI2NzIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZjM2YTI0\nNy1hNTFkLTRlZmYtOTJhZi0zODdjZWYzMzZhYjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATPS1H489GjUkmh5lKuTOOx07iNHm8ExIp+PO/RdyyewbXQ8QjBc5Ih\ncn/TL9gLdcS4wURtNLrYpWtBAuTBNmnZo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSeThDn\niuqoBTesNzAychvysaN61TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiBA6M23tMCsDLOaqVY2GoaJZDc1ctrdOUYQR7YE\ntfNBywIhANNnnMf0E81l253BV9oh9O6as/PHGz9tZaF10Uouss+z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6317", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6317` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAcv4/O+DvhHrrppy3SkarHr4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmYTI5ZmM1LTY2MzAtNDEyMy1hN2VmLTkzNWY0YzM4MDAyNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThiMTNmZDktNTY4\nYS00MzA2LTlhMTctOTNmNTI1N2MzNTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKA9HYvLaRASTrunCNcFNZRisP4TjFa+eYV+7IiymZDvR8aeH6tdaxH+9+QUg\nVF501zR9lPP5Wa0v60IP6tM286OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxKURDQZWykfF/BcVn7jc+aaG4O0wHwYDVR0j\nBBgwFoAUAtYEt52RZtpdyNtj771BeqfyJ7AwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMluYTrnc5RKiinRbDHqAgtMylYqpG1zPBIZODK3sfamAiBGtpWXo5jT\ncaNPYjk252+g2BLZgOueXMzWWS+5JFitWA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT16pP6cNiLDoCwge0KpCsdIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmEyOWZjNS02NjMwLTQxMjMtYTdlZi05MzVmNGMzODAwMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtcL2Z3G79yssbjVDW2SQLzJnFtoPxTmjQEFilXYfNjaWu\npTo8XvbCkm3v0Q4Sp7dVZH/JVrqAKkDEnD9uU9L4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAtYEt52RZtpdyNtj771Beqfy\nJ7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeRCe79b5t+sl+dsm9x1xFvh5cVC2lNuXLfExFCAyrbcCIF+6DEYPgUZE\n+DP9Z+61YpDCocC9hqlX5wvPTZF1eGYu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISATeV1vfyU2LBhT4VhmYb5bKeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThiMTNmZDktNTY4YS00MzA2LTlhMTctOTNmNTI1N2MzNTM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMDMzOTA2\nNi0wZDRhLTRlMWQtOWUyZS03MTMwYzJhODgwMzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASSg9oDIAaZ29pFGMVtqEbs6wO0rIdR8joC9zlNgTebSvNz+mA5lS8x\nhVRgu8pfeOVlARCVFFZFoXbUHVJLjUr4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTEpREN\nBlbKR8X8FxWfuNz5pobg7TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAiYyFPa3S2saNR6foR4eK1ndP3YCaDJ3IW/hM\nkNoMbeECIQC3CJzvZ+09sGytJ2wFWrV5g5Lfv3M+gu3pc/DHJ2X7Kw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6318", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6318` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXMUFtM5Wqa31NK9WnVwKZVbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhZDYwYjAyLTQ2OWEtNDExYS1iMWM4LTMwYjk2Yjg0YWU1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQ2NzU3ODAtZGEw\nMi00MGZhLWFlNDQtM2EwZDU1YzdhYTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExpgDz0ym5R1yWffohLKb2PDnm8aixDizmFV09h6aP90DnRIzGixDEUMXIqGS\nxl65tLSz9Grxa73Sk7+eZIDCh6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPdp0KGqIn2q6ug+m77XUXkb31kcwHwYDVR0j\nBBgwFoAUXje5h1LzGp6+aFBJp2B6Z4bt8eQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhALT6DAcH+NSJyOeWRyzILnHg3uRFUXjp72rv9vlvgrKkAiBt6f9djXZE\neCavwU9IBl1WXnIA5SVriW+sXtfYg2duVg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbcAl8vfW4uiUUGfgmDtoicTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWQ2MGIwMi00NjlhLTQxMWEtYjFjOC0zMGI5NmI4NGFlNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPh+ZPaihctu/TCpLJwG/C0YdKH3j2UXphlLTH/i7JX0yc\nZsskO3J3resQWCoxW6H+HjBr2vZgYYjk5ZyyaMSdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXje5h1LzGp6+aFBJp2B6Z4bt\n8eQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT5Dcad34OZw5BF5a548aizpr4mMQ2o3+mcXMFU612JsCIGb8hbz9REv9\nYM3OcKTCeVbwmB1Eg8CdISXfIDuxWdpE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAdWgSrxNxIJmQlvuX+c5v3FmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQ2NzU3ODAtZGEwMi00MGZhLWFlNDQtM2EwZDU1YzdhYTg0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MDJjN2Ni\nOS1mM2IxLTQwNGYtOGM0ZC1iZjEyMDE2ZDYwNzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARGdyk88xDTEpOdHLfIcvcHRfIrDe8YYISeWXkMmzwJZw5fYoJJ3Obu\neWglmmQuG6nH+XIjExWa9A5e2Z/RfP75o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ92nQo\naoifarq6D6bvtdReRvfWRzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiAxHiy5ZS+KSZY7JvGUEUnx54WzSG2es0k2WS09\n55sqOgIgb/Gl/bGlKFvyrQDg8Rb9OHFbFgYg7GWNyg0G1GEcFfY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6319", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6319` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAdgbTVEJ/NIOWeW8KNQ7aC+bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkN2QxNTRmLTNjM2UtNDgzMy04Yzc2LTRkZDE0ZGZkZTUzNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA0NzQ0NjktMzJj\nMC00MmRkLWFmZDctNDhlMTY2NjBkYTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN6vK9X9l6t2MuO2lsw3xwLZWaoFVUcu+UJWUTGzyH0ZnkmUZuxqQB3eCmdxR\nA9x/tiKpU4ybA7BXybQCh9SqT6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUza+52Yhg3sZl5ZTw+4lOUPCl5kwwHwYDVR0j\nBBgwFoAUNjyrIUND1xNKRMRb4HuZbxqVe2EwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCID9+Fb32BJGkMtkXjy+eUS/rFrA25KmS6aW/hYbbGVMBAiBvz2O2TOrF\nMVeNk91husxzHl5JFnheJzG5KDyQUTEkmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVgC3S3d9QwlpLVkwfq6Lwo1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDdkMTU0Zi0zYzNlLTQ4MzMtOGM3Ni00ZGQxNGRmZGU1MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATL1XJfyXTPqwmUsAAf0aeljcMSRc7jQzgq9271GlEFQ0h8\nFCLCa+gQ5h61h1dkFhAEkAYwYwPxkb81NQB4HToyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNjyrIUND1xNKRMRb4HuZbxqV\ne2EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ2RqHNLzAv9/303viky3tvhkPsNycgF5wa9xrwGwqm6AiEA8WLCcSrO\n7hJYRknr3zTz9PklIbY0KPk5MfyuftLPvPw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAR5xaZItZfg5mHBWCJQHr3HIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA0NzQ0NjktMzJjMC00MmRkLWFmZDctNDhlMTY2NjBkYTBmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYmE5ZGNh\nYi1hZTIxLTRjMDAtYjJiZS1mNWIwOTM4N2Q3NWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATVazCs6z5m4ndWNmEdhpOmUaJSTz2ZEMYrWFwnoQxLgJEaESvCqBwD\n1JzbHt9BCvuyU+sspnxP2moo2t9ip5KOo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTNr7nZ\niGDexmXllPD7iU5Q8KXmTDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEA1MGKkGtmMPcg2CxSPT+aHQXDgRDLMBTW9mxc\n7cpm5K4CIQDqM3yhzDgI+YzgNnCBxce6fqySHSkM+7UoxCLA89PILQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6320", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6320` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISARjpoLQ5qjo7q+ox00HG9qFMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YTUzMzkyLTc1NzYtNDljMC05ZTgxLTYyYjRkMDMzZTJkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUwNTQxYWUtNjk0\nYy00NjdiLTgxNGItOGE4ZDE0NGVhY2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4vxP3Fv6cLZK0oGrGN0Z+Pro4eU+qBN7+28c/xlTBTzEob+hPVNNfPYRROpW\nqpiZ7nYNXiReZ5w38P/c5gbHRaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA4AJisDxVPvURPsUBAYdXgw4MtUwHwYDVR0j\nBBgwFoAURxW8zhODT6tTLjR5lZzByVndBUAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCjVOIxET30vJS5UMOhWPDrGJYFIMc59r7wgU7v\neMQ1xgIgVquapd2eIDDlCat336gN750m7LbURSgijDRMMqTqg40=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAenmxQmENeRSQYrJkSc+GgcFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWE1MzM5Mi03NTc2LTQ5YzAtOWU4MS02MmI0ZDAzM2UyZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMLnWT/UAsl6iakuDTvvLDKj+4Qgm/8jN2pkKWMum5lYa2\nof8HweTqzCWvh4niRRsiHspsJc+627jTPQYjuZTUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURxW8zhODT6tTLjR5lZzByVnd\nBUAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRMY5mD+Pa4zi+Bf1bXlfTEZn9AD/lUxQ2vd4qZm4iSUCIQCCXblpZK6G\n/f2NW40zlx6F8P4JXQLG1Ykee/Spj2QD7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAUJC388kE7pz4s/+QYktFKlWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUwNTQxYWUtNjk0Yy00NjdiLTgxNGItOGE4ZDE0NGVhY2RkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNjYwNWFi\nMC03NWJlLTQ1ZGItYjAzYy1kMTIzYmNkNTlkMzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASbL6IlTMiJhHQu48NEEOOd7/SSMx4TRVUYnnvkFDATRwI1UKFTAJPJ\nRgnTUwCYGdJgWdwz5yWWHgujIZQogNDzo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQDgAmK\nwPFU+9RE+xQEBh1eDDgy1TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEAoQcRIrPco3byt0BsSf4XUEWPA7Ga8OwVoLPt\nS7xkNW4CIEkM1Uui+VFef5ox6w8G1zjCW/AsSlUGzy4o3vPup4HR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6321", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6321` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAa5eTjg4RC3lPgn3vmdnrPMSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxN2JlN2ZmLWYzZjctNGYzNS1iZTZiLWVhNjU1MjUzMzkxYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQ1MjcwMmItNjc3\nNC00MDI3LTgzNGItOTVhZGNhOTMwMzM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnHKN53vxbFeE8p7LmvlUIb7yboI+hsIYgmyk1VhN/4UYasEw3Ffys1622lN0\nF23x6kEX4erQBU2oHMxkIKYh5aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVOlByMoeJxTH3kHZ78rpLua066IwHwYDVR0j\nBBgwFoAU6rR0IbXO/OMFhd/BBZNkrSO65gwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC5VxFhfX0UCCi6riSQVFmPUUI2nni7oNtm98fO\ndd1ECgIgZo7IzFZtixVgtiW350rs1/c4v/FvXfcQHz3wK1yu2ZU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcenOADNzStnFg+zE2uGCf39MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTdiZTdmZi1mM2Y3LTRmMzUtYmU2Yi1lYTY1NTI1MzM5MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpumph2duvgPOf80u0cVp+v6HfnPuQsqtOZsDfq9jZy2jS\nWJReQwDjLCfy2caIDT9mSCIfZ55dml8JkjjLR/+Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6rR0IbXO/OMFhd/BBZNkrSO6\n5gwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf6WbU1pMEcwBHT1WcO1NbO/0Xt9PwF4Zlnh7vCMFFnYCIEBykOxcr66/\nHVu3NtMrun0hcfTRDYxho5SnlwDXn5zU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAX82g7hOvQ3HL4QFEW6MAJOZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQ1MjcwMmItNjc3NC00MDI3LTgzNGItOTVhZGNhOTMwMzM4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NWJiZTFi\nMS04NGFjLTRjMDUtYTEwYi1lZTE2MWU5NTM1NGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASRFAr/8IP2iJEJGXtfTpS/p+KZ7YPH3mWBj3Bw/cGyKTAyIkaymSnv\nZOnrcdH0kjQe2iCNZ6H4N0aQWwp761F0o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRU6UHI\nyh4nFMfeQdnvyuku5rTrojAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNIADBFAiEArfsNesTca7Q4BYyX2eJD5pOci3sU4SUja0Yr\ni+vIpwYCICt65dVaHu7OUu+05YdMNDkfe0QJnlf0sZTX/IVpsog+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6322", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6322` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISASr4BDEB1EozshVLtOB7GEaAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzNGE3OTIxLTYxZDItNDg2MS04NzQxLTg4NmY2NDliMTY3ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFjMjllZmQtYmEx\nZC00MDI2LWI4YTEtNTg2ZTBkMzRiNWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvBKt3hN2iM53Aocm0XfHlbeZjbn2x64ZGFqhfmRtegTRAS9FiHAbz3OewacA\nTQE4kNWYZiBhoyLE8CTaYG8k1aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzqG5ZDCqe54QcEayqU4tFYXGVT0wHwYDVR0j\nBBgwFoAUPgyXHv1qgx7vVnNiwo/JEBSZEe8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIAS6BI5j0/5T5+MCknLZmpeZqCZbdhc4jgIlVoJfWpQkAiB7\n02f5CMVNjfuJyZCSMRXjBR0t7acHPLcEHaoBYYMozg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARGASisJDbrPTGmfJd6IvWHJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzRhNzkyMS02MWQyLTQ4NjEtODc0MS04ODZmNjQ5YjE2N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnVgUHgXS7FKIlEApRNDzr0tSjX1tS27c/b6U+aHu8YK+P\nzWV6pXZKfVdMzy+PLk1BT00WZk+QcwaztcVU4GIgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPgyXHv1qgx7vVnNiwo/JEBSZ\nEe8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALQyJLDM2Vd4UVSYdrq5sbfRh/+lP6BosHGKPML8q0O9AiBv9iNfjqWA\nzYolVt4Jub3eTgcVhdX6lxHoB4DnW35Fdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAa8ms0XT3mFpfbg0LR9WWRaRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFjMjllZmQtYmExZC00MDI2LWI4YTEtNTg2ZTBkMzRiNWQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZjUyZDBj\nNi04ZTAxLTRiZmEtYWI4OC1hNGIxOWY3M2VhYjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT1Bi05r2nFQNAoXYFPpaN0Vwny7WmQlfxNPJ4QkQvS9EOb1uwm5HMh\nHipIIMItFzL4O3uil/ZyJf9RxQ8idQqbo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTOoblk\nMKp7nhBwRrKpTi0VhcZVPTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNHADBEAiBN5t2GUAuGmZRBobXYsJZIz0hmfT0rjdGaGBuz\nK/OmBQIgBpBOIRVtJajSR1QJq7zgoZcrW7Y324UuGecpym7ofLQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6323", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6323` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAYPyHfKbVlZpm5X7g/TjMLasMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkYTVkNDBkLTYwY2MtNDFkNC04NmJiLWE5NDljMmJiYzBkNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFkMDE4MWQtMjc5\nYS00MWFjLWIzYzctZmJjYmUyNmIyN2FhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEETkw3eS3kzXxkzkplePytB6IdjhY6ugl1d/D4Yo6AYVAHbbRv9x7AmQfpkNE\nVaVrw1OaxLD3wo4aD9JdyFL+4qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNEx3wi7WCEp4HosTD69DxpXfJv0wHwYDVR0j\nBBgwFoAUhaMw21b70cEtDh4fNfeqvfEYrlEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDE3ONStUekct2BAGxV0ofKPleliflF\nIL/CoA2z61+ezgIhAKCSmGAtaJ562mAiccVXx+on/7yeqN+Dh3cQI+/MC7Wt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT0xlgnscrTUTmQbGuga8IlZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGE1ZDQwZC02MGNjLTQxZDQtODZiYi1hOTQ5YzJiYmMwZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXg9SbcPRwbqeSelGpPS6waUGmXWjNp84dJCpPSdzNMws8\nLHDm4vmeEjxTc3Msi9rlU9iRovEvUgvkS4RJZkvDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhaMw21b70cEtDh4fNfeqvfEY\nrlEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ14xHaDUexhjYtEl05ztVX/3dgCW/RvSomLwnOzpzAuAiEAlWZ4VSPd\n+ml2pVOHls9pRrsI/OvLDpePTEwgSRPZGGI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISASEt5oFnBpDN9kFF/U4zGEXDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFkMDE4MWQtMjc5YS00MWFjLWIzYzctZmJjYmUyNmIyN2FhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NGUwM2M2\nMC0wZjE2LTRjNmUtOTM2Ni0xY2U2MTMxZTI4MTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR/LzQEqRKamLIzNPUTfXfkuLhuc7ItqYzr9WW1J2YBYSa+f8rlPxsT\n2V/ojASAOzr1j/YdpPBLxASzxRyPOVSdo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ0THfC\nLtYISngeixMPr0PGld8m/TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEAvUF00yCS9NTMyzuKTh3WYD1JoD173hqerpeA\ngG6DooECIQCIRJKlPyM3CoErY1ezSQ9naBSVIt8+2m1KNJ0MYdgBYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6324", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6324` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAR0fpo5ClE27Q7b1xjSxNi0yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhNmVjZTg5LTFlMTItNDUyMS05ZDg2LTFhMGQwOThjZWRmNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDlmODhkNjktMTkw\nYi00OGJlLThlMTAtZjNkZmY2NTIzZmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZB22b9/V3hFK7YoyY7wGtvgO7SaGzDYx0L1NjP4+Hp7l92ZYtb+ot1NzIX3O\n7jOZmKm2K6UBTz2wHwsTsGrjsaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN2Zh1msktP02DmLJx9hlqKssnMowHwYDVR0j\nBBgwFoAUM3FQDCqXb5zr+lg4VGrs5vQ8I/4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHFmgo0s8Fwz4d2apPWn3g2ETByhkAz4\n1ryW/FBt0lBIAiEAqlb0Icq5Dj2y4aJdBVlTtjDvr+MoVEoWJANI4v1AzCk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfoUrUKfNtA7iX+sYQhIsdEiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTZlY2U4OS0xZTEyLTQ1MjEtOWQ4Ni0xYTBkMDk4Y2VkZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/QmbWPr7mRxaL8pfxlqfeYP6OL3KKCAdquyxC6+j/jtln\nEIJPwNjPITQkHB3daarE9RWfJXdAYIfeQjpYGA0Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM3FQDCqXb5zr+lg4VGrs5vQ8\nI/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXGlllTouihuxpxwbrE3vEhNTeug7l2JEREplPM+4dc8CIQCMXeujSQ4a\nvRwDPWSdhYWXGhk15Rs/H53zDEEBrPtgfA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdmgAwIBAgISAZ57DwMWvP9UIhHwuHVc7yBfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDlmODhkNjktMTkwYi00OGJlLThlMTAtZjNkZmY2NTIzZmE1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MDIwNDYw\nOC1mZjIwLTRkY2EtOWZlYy0xOTQ5OGZmNTcxYTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ542e8BVpKabDqU6+Lo0yDDvQB7TASwg2ccrqXd813ImiDew1nWniY\nsw+zUUrZB1YgGz4F1Nok4bODmdgIDK0Bo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3ZmHW\nayS0/TYOYsnH2GWoqyycyjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEB\nATAKBggqhkjOPQQDAgNJADBGAiEArCKZyzpCkgjKSNtseQEGmFVfr7nAq4kznugR\neqMQ8cwCIQDHGX4tYBggZ1cqIMwfK+sAzeBecbMmPpThARsIK3BudQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6325", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6325` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVdt9RTmfN0xRyPu2l+kD/QlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljN2M4NmVkLWI3MjgtNGNhZC05YjJmLTQ3MmZiM2MyZTI4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMzMWVhOTEtOTBi\nMC00M2RlLWEzNTItZDBiODJmZTFhNjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEznsMeNrFLWAcZkQC2OXAPxyukP/HeK5zrUi9NUO4AI8irSxuJga75RWTyNBO\nONH3DQbfD/MBALNyWIWkZViFMqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLbHo6z167t7F+TX3J+yvjJpeeXrMB8GA1UdIwQY\nMBaAFOeqC8AkdWkbOXM8mGkYFkF8KqptMAoGCCqGSM49BAMCA0kAMEYCIQDhonc3\nRbsqdBdSvNOQw/mjPFAdd+gB+YPf936k3Ns98wIhAMGWB5+5YmRRaB3m0Ufslvv1\nQDzFeaoAbCAPp1cn/D16\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATStv7ZpViev6nVzqw0UgH5OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzdjODZlZC1iNzI4LTRjYWQtOWIyZi00NzJmYjNjMmUyOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDbzlR5nupzsQwVX4L5giyzP2aIpZNnfNPpfuQZ9pr1wzs\n1g31tGfPxcYhfl+AvBJCwn8FV8HKiXQ20BCU0jYxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU56oLwCR1aRs5czyYaRgWQXwq\nqm0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ1DcfA9se83S/qUMajyoJXRkYtRWOya9TLGfrlJoRXUCIQC+KcyNB60l\nyP7PmEC5t5T05DjEgM1k4H3DS8oscO6syA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAVGEdj1LabYp49/YioEyovhbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMzMWVhOTEtOTBiMC00M2RlLWEzNTItZDBiODJmZTFhNjhmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMTUxM2Nj\nYy0wNzI1LTQ0MGYtOTBmMS03NTI0YjE3ZGE5OTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATQsow1TAFMy5mW+EGSzv/ox8wZ+EOT8YZycFgX/pceYciVx21sCe2z\ngy4TH/+v3mo+Ks9RQKDu7PrNWha3x8zpo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS2x6Os\n9eu7exfk19yfsr4yaXnl6zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAOJc2P1SiqCg5Pa/xHnlQUitMItZSvaegx1To2O4XPRt\nAiEAuIQ04vIiDFlr+CeH5dIgTNNlrBN54sBO2bFMlKHad6o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6326", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6326` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWVe64jJA9ttFDbD5ZDFxyQVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4Y2YwYzQwLTY5MDktNGU4OC04MTZkLThlYTEwZDg5MGE3ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhlYmE2MjUtZmRm\nNi00OGMzLTk3MTEtYTNkMGM1NDcxNTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcbeIqxEheBhzXU1+kSI04BRQ/tZm5gbX2U7D9AhEJxoQasWnrn9qNsxVsetL\n3sowFDHj4Jc2mm6JvMRIwbLsiKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGJw4ax2Qbiwesoh5G6wpzPbJD+MMB8GA1UdIwQY\nMBaAFF7ZL4TTIWNac3kargzgJHqxSUMFMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBOfTg1SdIgr9mDppi6UBoFSolzlcvW5VnD\n9nJ00GfoHwIhANU4lP+3IsxAPNRCMo2yuG3NmHPTkDaZyXzoal/gG1ko\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUDvcKfzOGCZC4ugEENQj9vbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOGNmMGM0MC02OTA5LTRlODgtODE2ZC04ZWExMGQ4OTBhN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYUwhSttRTpGrxnwd2O9zghga94X+JkGSSp6I38IRAqd+U\nJhU+ZqrIGobfqJn/iJ6J+TH8+FOtaf4dMMPKi16no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXtkvhNMhY1pzeRquDOAkerFJ\nQwUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALcGxXuH2Ne831msghdSAKuc7J+Cl0+ZzKXqI1E513IXAiEAhLgQwFQE\nIdl+5lw/ASUmfEpEDOgM9H8YNZA9xAN2nZ8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaz8OXw8fdgts+GK8vDlLhQmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhlYmE2MjUtZmRmNi00OGMzLTk3MTEtYTNkMGM1NDcxNTllMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMzE1YWE5\nOC05Y2FhLTRjZTEtYWY3MC1kMTQ1YTZmNTFiZTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASybCxsfWJyte98mUHYcveuE7ofeKNHdO8B4FUbWXsTl2I799EPhlSJ\nDazoS15r9TkGou6Rqu0k/HR3tiOhpRSoo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRicOGs\ndkG4sHrKIeRusKcz2yQ/jDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAP3OZ5qL9NkBxPUQnRUXPdZhgMPoqMznL4yZ45Le8k5J\nAiBL4zZKMUzsbhCp0FH3eVYBIIen6ZpmsyZeMVi2+SWp6A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6327", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6327` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcar071sq+vCCLPCrBW7N2VpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5NjJlMDk5LTk5ZTYtNDI2NC05NGI3LTNhZjBkMjlkMWQ0ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQzMjlhYzgtYjI2\nOC00MDZkLTkxZWYtZDk4ZDQyMjYwODM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP9BhrVkhO4tgxSiq8ZKCT/i9WZ9R7UTigbRaJaCZbSUCcuh7KWgzGFj8WEZ/\npii/XoByBcajzea74E7c3xOU/6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHNr5gyBPDbcN1kBtv1xfQg0lOVMMB8GA1UdIwQY\nMBaAFCc2Wrg1lZbr0hCYiP/mWrB4BCmjMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBhpjvnBukBkJhduPxB5iB6YsES8c1ds3T4\nCrq/On0qFgIhANdm3O1HEMa5LHdwpuru1Wmhsgc+UOTI3cnyThd2okpo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWH0T36xEGKbZyY8DXL8jmHGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTYyZTA5OS05OWU2LTQyNjQtOTRiNy0zYWYwZDI5ZDFkNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWS+2h7WgxuQsxCcm+b034TNMtPGTOM60NQxRAbvYL9yjw\nxdTWcDfVFlFMC6lRg2S1YMbCe4W6zAH8xNI56wsro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJzZauDWVluvSEJiI/+ZasHgE\nKaMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM7q8rAHc1RBVj4PR3ccp2A4B3cxJe9uD5xyqILelQFpAiB+rCERy6Vx\nChEq/welOBCNifYvHAe8pnyOiw5pxcRsdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAVISbYzJd6wuhwoDJLRFlLmUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQzMjlhYzgtYjI2OC00MDZkLTkxZWYtZDk4ZDQyMjYwODM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlODhmY2Rm\nYy00ZjAxLTQzMDktYjliYi00NjdiZjAwOTdlMGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASDiXgovt9daFxEHseVWdXlW4wDXses9n/az8+ionZbaKVcCuK7U7zN\n59rwGEcKoQy538qu/0AatDQx03SCPnH6o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRza+YM\ngTw23DdZAbb9cX0INJTlTDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAMDxAiBA9DC5Kcs9/i6XbHP84mcnCKjPj8j/oYaFIUCq\nAiEA8BvnBREso3cWnknLTXH6McoPIQw4ijSbXOSZZuuDPjY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6328", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6328` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAWxNq4oaTpf5gf96vw7xQb95MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjNTQyZWUxLWI2NTUtNDI4NC1iY2MyLTQ2NDhiNWMwNmEyZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM5MTVlODktZWM1\nYy00ODNjLTkwZGMtYmQ4MzVhZmZmNGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL6iajjaLhNaq/6bs4bkkJqPW6Tu78biZX/mblDHXbUqa5D8L/8JcduCW3UBJ\n1BrCh23Tq+i0Kih5tVE6gk44l6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRjr+VfGLueoqG9G9JfpALUoDXUlDAfBgNVHSME\nGDAWgBQ5zteSOwUv8A3LkIBPMhcst4fduzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDcmFRkCpjts159LCIgM4dZ5xZNClZj\nzHVLn3QRXXZHDAIhAJ3lhm4PP9PRyckARjWq2G/tu8xx60uLuCjBq7EJlogj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbvQ+b/zfbAMHXVBPT/uOgcyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzU0MmVlMS1iNjU1LTQyODQtYmNjMi00NjQ4YjVjMDZhMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2I+lEiaE7EODzhAiqFlAFECoe4qAib13XROCC7dqKV8u6\nueXR6dWUTLH6+rYc6FSYEZ5vo9KqsuStnYCQ1BIZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOc7XkjsFL/ANy5CATzIXLLeH\n3bswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWpTQGWLumygoPD1b+FaDXUWc6qP6F0AYvmyTyQG7PFMCIQC/rQXxWUn3\nosSoLV0BpnXVBlSqNCbsasiE5ijIhsyZFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASgB7D5nBozS9DleVGKXk0/3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM5MTVlODktZWM1Yy00ODNjLTkwZGMtYmQ4MzVhZmZmNGY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NjhhYTMw\nYy1kMzZjLTQzYjItYTYxNy1kMjhlZmM3M2NjN2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT7dlbGxOvmekmAvKOeQZEltvJt9IuELX/QXkHrEI5G4F5tPRTcePsQ\nBva0LzNZt2rtwl++U6F36sORUAfdlrNyo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRjr+Vf\nGLueoqG9G9JfpALUoDXUlDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgXTD3GTp+RcBVYViJtEx+bE4ubFfEDLr511F1hjpE+B0C\nIQCDSuljSB6glqtxVVTwgwPeRb/7mPE9rhZXh8A6kdaoEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6329", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6329` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAbCnwuFI20Yi3jEdfaqdxfWtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzY2ZmMWRjLTJhNmEtNDhhZS1iMTcwLTQzZmJjYmZlODkwZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI3MDFiMmUtMTcx\nMS00ZGE1LWIyYTEtNzgzNGM5YWYwZTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWOsCt9xza9w739yjNOUB6nzRslzhLN5LBYwqPKvhtV0ohXyXdkQkXstqo3SI\nkDeejLyF+no1i1TJYKFHamgAi6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+acaVJbVB04+4fVssRKQiuDAvNEwHwYDVR0j\nBBgwFoAUw1xYXqk17bcj0iSNtoJzwiZaJW4wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEApZBJSHz8hk50\nVCg4viGhKVQ35I8a+kHuMKVlHLY35xwCIQChK6mOc/4Z0/hzNM+V2CBshNq6P/Bl\nZwGpoWdznkRb5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZkuOHBsGlxPT7IE8Ad7+LttMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2NmZjFkYy0yYTZhLTQ4YWUtYjE3MC00M2ZiY2JmZTg5MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUrMoNRtyXbXVeEgLU6OANbBZrjhkcrQVl7TRup14/kUrs\nRZHEEbZN92aDW68/J+eLWofRDsk2hBeion02ZnGco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw1xYXqk17bcj0iSNtoJzwiZa\nJW4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIcJbmvts9QrCOfua8EgH+Kjb4If+4JbFhtGcA80dFWkAiEAjTF645kX\n0XLKlWMwE3cPsbEOGzgjuXIHRB70iPiIcDs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISASYNfX2fuHS5V03O2VGY1sxXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI3MDFiMmUtMTcxMS00ZGE1LWIyYTEtNzgzNGM5YWYwZTA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZjM3ODFl\nMS0yNDg2LTRjYzYtYWQwMi0zMzkyZTliN2YwMjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQPT02du2MIo4Npid3CwARBOO/Vb2mk6DiXoCugL5ut86OFSTyo9ovF\nKPPQPUQlXpxDphMCTik88UsDS1waIpIHo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT5pxpU\nltUHTj7h9WyxEpCK4MC80TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgZbaVzzm35CiHrQuFCggAq9lTnGefVpLbYwrjlFOhVXIC\nIDlN6uRcnEo/j8kz0eqDnf1Eey9nSz6vizHpd/n6UxhP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6330", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6330` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAV8P1QRpikylujXlYSIEpRUdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NzFlOWJlLTI2ZjYtNGFlYy04ZWZhLTA0ZDlhZTRiOTRkNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWMxMzRiNWQtNTQz\nYS00ZjFiLWI1ZWItYzk2ZTRiMWRjYmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEChOV9d8HEuyZuYpVcg1HBhQbUeK3o2dtMNNVCt6FZ14Wzva4SFOWyv1v123v\ns3Fga2qbXnH9963x18jeqWSfV6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMGyQN/zAo5aDclkcoqzfoz0KYSwwHwYDVR0j\nBBgwFoAUi0IIFT9zmvcMY/D0VxHN4VBqbIcwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiA1fna6jXjbQ2AZ\nlJE7MGCQQBQwjoRMnLpRuow1cWpTXAIhAJC04ctsR0vl5Nuzha1SBxanEcGpOKc0\nSxXAYL8smc8H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVlWOhj3YAt98hQcK6eaEW9FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTcxZTliZS0yNmY2LTRhZWMtOGVmYS0wNGQ5YWU0Yjk0ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHvnWH8vTSVBYj2tFi5G5V+wK2/FWRX5xC71hSa/T9bY51\nVjjwo+uyihU4rtNVKasgBwaCOesbQmtrICt1rxo8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi0IIFT9zmvcMY/D0VxHN4VBq\nbIcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLg66DtWTYXOx/Bl7DbFe4LoNabL0vD2gsH+VJZtsRWkCIBlDI3hZg2hL\nkJPOenCvx2aTaiHuTIRGNuUp4FCti9E+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAezcZLlqcotW00EZaRE3EgiOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWMxMzRiNWQtNTQzYS00ZjFiLWI1ZWItYzk2ZTRiMWRjYmEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMWJlMjcx\nYi1jM2MyLTQwZDgtOGUyMC04Y2JiZDZhOTUyOTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAScPYexZo9LmmO13zinNrsZ1JAjEUiOB4ZQdoii4TnczaOeMqr7JRYT\nhabSAWu+AMA3+20qmbqEF+zxGwDJ91J6o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQwbJA3\n/MCjloNyWRyirN+jPQphLDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAOvT2UGls0QDKk/ucECee2McpvkVqsesw9JHTZtVyXUE\nAiEA/wE/4age3zinsnS4IFm1aqKP73YkK3aEkJSodQ2Racw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6331", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6331` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAQ1Ae4N6dHVsudLhkBSXIUYqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4ZWE1ZjRjLTU0NzgtNDhlYS1iM2IzLWU2Njc5NzYwOTczYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk0NTNlYmYtMDY0\nOS00ZWFlLWEzNTYtOTU0ZjU1ZGZiOWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE35cEF5JNCGJo6jbgO5RsH5LuGiIcmSYOIuKtAcP7Y5HHoIeN22dgZzjR5WcR\npZUwTPLnoEag10nadRwNbWGliaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0filF7X3NFyItg65Kiq4HrkWRKkwHwYDVR0j\nBBgwFoAUySj740T0T6kpK1LZL1fnS5uzW2YwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBf+jcQuRS5XPa7S0E225xy\nWwqR1bVpug0GbP3E8jW1RwIhANoIFo7rsPNYEjrzCTEYvNmCKnPc1qHIGqyeX5Tr\nqCKw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASTYbxkB8G6ZROneJWHyIVLiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGVhNWY0Yy01NDc4LTQ4ZWEtYjNiMy1lNjY3OTc2MDk3M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyL9zD6Em0+5XSyGWugoe3cbSnu7P9dqR3denwiwp/rSPp\n0nc+t/fuu/e5a0wQljS1nRghObgqZcsrMwVT9LOWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUySj740T0T6kpK1LZL1fnS5uz\nW2YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN3PlBEDNVekwjlP+Mppb1i5rp+DXbe2BgwRC6hRXQyYAiBga3+0Yb0s\nrlTWrzA1gPOC2dzsNGWHzP/WvOmGUey5BQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUiUcp3FdiW7guWChteE1jaxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk0NTNlYmYtMDY0OS00ZWFlLWEzNTYtOTU0ZjU1ZGZiOWI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZDI1NjJm\nYi1lM2EwLTRiMDYtYWU4ZS01MTA4OWNiZjEwM2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQoY+YTu/Jy9Y6YVil9Bhh1Qm60NRjO64TC4Jp4ppCvEwtPD22sHYLu\nOvwOzxW8imSvpfY1RLj5N5AEekwHxaBno3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTR+KUX\ntfc0XIi2DrkqKrgeuRZEqTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhALGFJu9NHdgaGpCXNVd92Fd+oWAGHcvkoImigatvZKp4\nAiBDdGQKgTSSE16e+AtVlZke322ZDt17qsW/HVzAuJ2CxQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6332", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6332` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAb0ZC3YvwoYatRYsdC69vesuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMzJjM2U4LThhMzYtNGM1Ny05YTI3LTJmODNlYTMxMGNlNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBiZGRkZDUtMDk3\nMC00YmU1LWE4YmYtODI4NzliY2NhNjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFcOjmDZnpuhoukmR3T7b5NFBHjYGXUqh3NDhusisv7yVBI2MPU06KDfnSgkD\nvPvE1AcnR3UxgsJ2j1FsLRVTG6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtDM1huxF6pXCF4qZ6dRtnxd9nKQwHwYDVR0j\nBBgwFoAUgB/x/LxZLI2sIiyVD229kIzEBIgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAwoRi\njaGfkDSKvFUGTUEyxLkBFd8P8iB3a6kBnpFzjYwCIE5CSdjXwFltTLKrzz9TMFKU\nnBDPhXEx8A8rM+SjZIyb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWx3mEszi/yeKRBqpm122eNeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTMyYzNlOC04YTM2LTRjNTctOWEyNy0yZjgzZWEzMTBjZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+OJiP0G44V9+kjR6p3iOdObfh4+C3dDJDDidQvhoMJ2Xm\nzLz28qHaCE5MJLXrxjkNBDVPVeXtE4ratxSrf07Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgB/x/LxZLI2sIiyVD229kIzE\nBIgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIQ17I++cYG+HIwWMWpYQF55q/ypBO3URl1w2OMPBF3zAiA/bikJnrwz\nd3J05wciR63WMsicbpnGH5XkwNKfssnI1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAeEyJjevfYUx11+Su8xBY1UuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBiZGRkZDUtMDk3MC00YmU1LWE4YmYtODI4NzliY2NhNjRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNDMzMTAz\nMy0yZmQxLTRlMzctYWNmMi1iZmFlZWIxNWQ1NzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARyKTnhJ6Mj9Koqv6x4F7lE63An2aWSrA8aSxKsRZ+RotSwpWjgQwac\nkJwCTBsuXOE8nu8MCCHX7HpZwEOtknEGo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0MzWG\n7EXqlcIXipnp1G2fF32cpDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAICwIX6MfjtqUTGRZHGqLOaAEvnky0QJpLDEGjjGmCw/\nAiAH3HKTVnlY7+G/lJaLyNPCY9nC2tCTXxlCBwnjFWs3Ew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6333", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6333` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAdZKiXmNHn7Y4DtW6Szb5fTUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhZWIwNjg4LWE3NWEtNGQxMC04ZmJiLTkwMmMxYTNhNWQwNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFlMDA0ZDgtNGZk\nYy00ZjNjLTg2YWEtZmRmYjY4NDU2OWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkRlrV7Iwxb2PpZ73jcVNtF87vZxJi18VfrxK+VfBZg2MjkS7FWm8uUh7Lb8J\nIEG9VfbR5bJK/JQ76jHdWMgjRKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEo2/1Dqd+YCNRQquyNOJCNJy+2QwHwYDVR0j\nBBgwFoAUPXIUY+VsDz3TdWH13UJT+QDGqh4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA/YRf\nxWgdHrcmmntwKBTRo+gaU0IMRW7FmtboVFNF/CMCIC+7rRQ7WZgbmODZ0BBKl6qL\nOhWOUTBRaSWsHquGCpdR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARj4Gq4O2aFRpNYJk4f+avsZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWViMDY4OC1hNzVhLTRkMTAtOGZiYi05MDJjMWEzYTVkMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4FzL5o1TjHmKX47MkGzYp4HqDoUCdUk/1oMibZzjsKX+P\nZRbQq/W8pDoMXlrs4b+m9fKDTsWnjaIpjS6wcHfjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPXIUY+VsDz3TdWH13UJT+QDG\nqh4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgE4ZjN10JDSWb8h4hTxVHhFjz2nhfwGY7ERjCNm2+ylUCIE5RQHJ0urGD\nxzzuyq4aJHdpZ8cqSAVYJfDgGo7AmQlX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAdijFYIVYfnQWFJki36z+pXoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFlMDA0ZDgtNGZkYy00ZjNjLTg2YWEtZmRmYjY4NDU2OWU0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNTQxNjM3\nOS1iZDAyLTRhYjgtOGVhMy1iMDRkNDhhOTUxOTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASlCA5uJAuSQVDB+Eg49bYOtvf+2/YVdZk6SYMSUDx7SZ2Y9JqWyAcz\nv+KgRvCFSR/TR2NJfbG8Lvud7LvEssBLo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQSjb/U\nOp35gI1FCq7I04kI0nL7ZDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAMxtUytdiLUBSnH7b+y5g4kCEPZ0plBJ6KZPtm5Nr7wO\nAiEAilfx0JcSqtdOskh4ityxTH/lyaCvUEyM8rOWwqQeQaI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6334", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6334` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYE2a77hwZs1/+K1C/SkP6KlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZDFiNDI1LTg4MTQtNDU4Yy1hNDUzLWRjOWVhMTIyYzNiNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZkNmM3MzctMjNk\nMy00YjU5LTlhOTgtYWE4NDA1NGI1YzYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmgigfCRUI/v3uSG2DOJyTrtKVufV07qMgybS/AS9mSS+yJyPTcHuMUZvcuis\nOIf4UoNW0utru3Agn4txfhr0WaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNGa8bAOapxJGBZCGQOLGM8GEuPfMB8GA1UdIwQY\nMBaAFLojG7K0QJ3ztF9Bv8dbx8v/b01uMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAvajwdnOdOwS7Gz0NKTxmqz8crPSmhK8c\nVjx1qB8bSx4CIAncOEBPTGJwS1LLP909/TnhOtrZQMZx/WWCWE/OvM/8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbBNwDvPAoAFshcOs+LC2CRtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmQxYjQyNS04ODE0LTQ1OGMtYTQ1My1kYzllYTEyMmMzYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTVmv5mfliq86JqAx7mI4DRb4m3XjOQGN4y4dJVBuG9EA/\n2/65kqV/Zd6Ox64OMhr9e5eDCsoP42ayrpOukuJBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuiMbsrRAnfO0X0G/x1vHy/9v\nTW4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDCrtWOZnXxRnYtf+N274eaOu2hxO0fPEVo9dKWwXsvsCIQDAmyiG6OoX\nV5aJH9kX6Njn333OpQ8p76dOhbdir4s2Wg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAQeenEUd/bdbIUKE/1JQgV9EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZkNmM3MzctMjNkMy00YjU5LTlhOTgtYWE4NDA1NGI1YzYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZTJlOWI1\nYi1iOGM3LTRjY2MtODNjOS00NjA3Njk4ODgzOGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQGznNffO+OqOZdsryAwd30RrvMG0OQyfttBhAayZxfaYBJ4XD41zmO\nlwAYen6ZmScu/CLYFmj6An6F+GJ3LQCho3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTRmvGw\nDmqcSRgWQhkDixjPBhLj3zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhANaWIKSOK76LVA7mVdoUsAGF2yLly7AhAZIIDmpqlRZ0\nAiEA6/KY9/IYDldPs4jxXC4N5shxLTU9Y6r+RTrXPC3NHw0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6335", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6335` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAcZ8NomLk0InnBf6ZhjdkADbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0NTI0ZmYyLTliNWUtNDdhMy1iZmQwLTMyYmJmNDdhZTY4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFiNmFlZDUtZmJh\nYi00NWQyLTk1NzgtYWFlNDgwMDg0YjU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEarzsMIDfNdiVZoI1Kl6tvLRdA31BO0Fm1GGAY3GN0jKDj33C7WvI/KT/XtCC\ni4jB8XxcplPMvXI5q0YFbN6u9qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh951YzkbweKO1OXxeRma2hZn4NIwHwYDVR0j\nBBgwFoAUt67G05Gdx3SwYdLYC1knYyGCQ3AwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgTp88BpH2Ctl1\nSlWYgKIRiY6EGPjSu5xuwEVW8O3eqZ4CIQCMiplV207qlMxUO317fI0GjZq3BTol\nF39gLZq4omyrQg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd1prClfytzQ5k5GTj8RjmvNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDUyNGZmMi05YjVlLTQ3YTMtYmZkMC0zMmJiZjQ3YWU2OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0OFwXuPtcpcpr1lk4CYmpoilRig6Y4spoIPznjEKbhSI5\nGW9BP9Cr3qRGXXbof74y71hNvWC9MVyIIoMn83YMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt67G05Gdx3SwYdLYC1knYyGC\nQ3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPwLMw30r0h3pPe+zBm8e90pskd6tVMjiTIcrO/n1p9AAiAXyvBNzhbJ\nBZhewJYQW+HCPdFGLif73wh8+WdqpYuorQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZTdz1iT3TmCzWbfn8bEf3qeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFiNmFlZDUtZmJhYi00NWQyLTk1NzgtYWFlNDgwMDg0YjU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMjBmNGNj\nZC0yZTAyLTQwMGYtYTgyNi00NmQyMDBkMjliZTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASFUPD8PDwR9gmsGP/J2EDMqIxb8wsVCYYZSEsCfSlJW6kMvpW8Kb5l\n8/FUVezsJ3RN/bGoUjawexMDZfegwpCno3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSH3nVj\nORvB4o7U5fF5GZraFmfg0jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhALrb6g3GWOYD9uHJ34T8yBsp6q8e4DcDaxb8trBgG1rz\nAiEA+iYDy2+1l46CTiQN6XKfwCEWSEkRUAJuLxT26+YVHOI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6336", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6336` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAXgf+Vx/wjfD1ZRNoTjo52eKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3YTA3M2Q0LTlkMWQtNGVhYi1iODkyLTBlNTliZDBhNzg1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJkOTkyMTQtNjhl\nNi00ZTBmLWFmMDQtOGM0OTc2NWU3MzdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi1Y9Jiid4Fw7VjzPeQDzR9RPts40iuX099J686Zsq3mhmE4pEsxflWa3qwnC\nEbLFZUMrRf+wLRggjskB4QDlwKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNVQ2zlziQhnds3mNRcFykh81f5QwHwYDVR0j\nBBgwFoAU/TXoWLtJTmhb3D7N9Y2JcvxmCLIwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJzj4tnw8yYl\ncO8tZjX4dN6BxHUg9AI9sq5CVj9LA0KUAiEAshRGFGHa0fW7jfgrX6Lh9J6US5wR\n5ezel0XPnc/LZIU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUnpIAeR+Y/NCawhVUJQ78jXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2EwNzNkNC05ZDFkLTRlYWItYjg5Mi0wZTU5YmQwYTc4NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARD4lKJEEe2H6c5dDKMCysaWfZY2nArWfB7CLTGUxjLCkJX\nJu0f25m3YlVZ6oKNCOohjdwQee2kPSxhA9cfa0Aro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/TXoWLtJTmhb3D7N9Y2Jcvxm\nCLIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbIEEpgRyjVCN4d65Z4I3WF/AY3nRPOYRCulGnRgvin4CIQCVK730OEJ2\nLNvcjKkVYYda6qzlSTWwxeUTtPAwX0bi2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASJmhzUypHdGadaFNpeincWDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJkOTkyMTQtNjhlNi00ZTBmLWFmMDQtOGM0OTc2NWU3MzdmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZDk4MmRk\nYi01NzI0LTQ3YzktODJjOS01ODBhY2M0ZGRmODcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARrdQYi96DfLmO66b/WlcAZ/olagM33t++mrHQ5VVIa5EIG7aC5/TqO\n2dKvnPx+op69aq9B0Nw9AapFEYXf0KpZo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ1VDbO\nXOJCGd2zeY1FwXKSHzV/lDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgEqywh6HYUoz7G2MoTEO/FL1882hlL+Ab8ZqmgEE5KWkC\nIQCLdNyrtBkyW/pQa0rzJT57qKaxMSOEXAye7djZtXRGhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6337", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6337` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAblJUq+a7b2YWQjDu9mT0S7OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ODRkODA3LWNkODQtNDlkMi1iYzQzLTcwZDNhMDYzZDFlYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFhZjA1Y2EtMzEy\nMi00MTc0LTg1MTctZjkzNmEwMTRmZWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ6r7UhuFqNNAFBJd+rPyunhibfv6kaK25RzvNEsltT1Vrvppe2UtLkd1tv99\nXUUqTbqMoELgZ5pguvoE1fZyIKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0OMmvuW4ov9kg4xLmlCQOiPLcY8wHwYDVR0j\nBBgwFoAUrJpPN7W13sjp5bfyYNUG/Nvu3TwwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDdosH7woEN\nGqxtXiDCfMI0duaAhIRNYxsznZCSv0Kn8gIhAPhK2sMX/V7XC/pGNjhI+qtyx7RC\nTR3wirwvefAJtiaA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZdlGmLcBSDFvfKuXuD6koaIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDg0ZDgwNy1jZDg0LTQ5ZDItYmM0My03MGQzYTA2M2QxZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT87oytYLLxp3hOBlcF8OqMKPYa0BFNr20//Jc6GYF6IljR\nG8lV/F3niMf/yHBrg/+Lne9sAZ6fNW5SYjQgfQHPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrJpPN7W13sjp5bfyYNUG/Nvu\n3TwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgO5+WQ9LT5td/LBEQLXNnY/YyPUVCv49dgSqMDj2Y0roCIEjHnyQLV7T7\nZNjk2jqVyDm0cOu64l2XTgy+myoUbOnC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAbvj6iSTOjXXUIcu+Kv5bXu1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFhZjA1Y2EtMzEyMi00MTc0LTg1MTctZjkzNmEwMTRmZWViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1OGRjNjhm\nOC04MjQxLTRjNTEtODQ3MC1lMTJjZTA3YjAwNDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT09e7IUNTJMI/IedtCzoQD5hDzn6lrXem2KF4IdtQt2q98JYofxKgQ\n7svd3VODUC0ygE4EDWSoE1jASeEV5Kyto3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQ4ya+\n5bii/2SDjEuaUJA6I8txjzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgTDeYqctfl4TD0Wvs6+q9rlUhF96n0xKa+eHyhrKx1YUC\nIE/Uk8sJsZburtycrvyTzVJVlYTvHeM7Ky1XFoaFo9yd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6338", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6338` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeQ5O5Htiyiqewp2OAnG65AJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1NWQ0NzNhLTg4MDktNDBiMS1hNDRmLTQyNTIyYTk2MDRmYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU1ZjIxOWMtZDM0\nNy00NWE3LTkwYzAtMjJiNzllMmQxM2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfZI62xM1TcYS/HQS0LqcPw2cwxVHkuV/biVxQ4ZBsHvyaoqs+/wgoaniM48/\nWzOiXD+W+Dyv75CHIiBBw+u5FqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwnkGSPEa2pNpQdGbZl0YQ9/bIBEwHwYDVR0j\nBBgwFoAU18GCxjej5m8dc0TTw5YsZhknrukwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGBnLe0qtmdiASx6VD+O2E88iFV25Bp6DIS6JeFGz8xPAiEA7NfUvtxswPBG\n99nWZB6GPz7/SUb2HOVynSjF6qbzujE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYyZZMzck587l5N/vJBozBiwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTVkNDczYS04ODA5LTQwYjEtYTQ0Zi00MjUyMmE5NjA0ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScusDuzy8MHbys8yfTXWPDeBaKdhajKFLa5tCx0IcllNV9\n8Kn4cUFNmEjB1W4XTBeXr486W7DyBRjwvXUztfVTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU18GCxjej5m8dc0TTw5YsZhkn\nrukwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbRAgu99bZh/4fIk/oyQ09iG/HcIvDp+dR3X5WIZrtVsCIQC/+a8SRFr6\niEtBYD6gbh1yGaqjmEnL2fzNm6N1pt/EGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAeVgIK8BXZspYI9YoaH90ceqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU1ZjIxOWMtZDM0Ny00NWE3LTkwYzAtMjJiNzllMmQxM2Q4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YmRmMjdi\nZS1kNzA5LTQxNzctOWExNy1mNTM0OTQ5ODhlZTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQsSpC0IpHeKoqCr2SGH9nyYGWSRFME5atIoERryNZ+i4eMiwp6HuTu\nB0AvQfykinewDY11b3F3E3QWsC4dJmafo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTCeQZI\n8Rrak2lB0ZtmXRhD39sgETAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAKkCdOuGDPjOIOSO0ySsxVRbMpqeQ+5I4kWK60TbzqDY\nAiAArf/xK5UDEqvoXdEF448HnmmjQeDpjhK6cun86nE7wQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6339", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6339` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcLIUz795/Cx+T14Pp0FERTPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzYjhlNGZkLTI5ZmItNDVlMC05ZTQzLWY5NDQzMDIyMzY4MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNhODBhNWItMDc1\nZS00NGY4LWE3NDQtMTY3ZmIzYTk5NzNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfhf2on5xYcgdBBE0WkQwZ5XiN/HCM9Ct7Gf0gHmW4dZpXB4Ea2IaGzQXTSQL\nRlAD8qVkn++CPN1+0sWUxojG7aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhixiWOaPQLlo8kZ7/vk+45Yyj1cwHwYDVR0j\nBBgwFoAUxAmPrVfVwsCqJvO+3fUVskhTwYwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCnLh4fOpZss/o5WmX2vvMT3kU6D6P9W2Qr5e5wgLJqwwIgRo7aDAEFERnG\nmn1+so87e+EQyE2J9xPA0kpR7cwg0Q8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWJL+KbcJoE7n2oG4GD8hcCCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2I4ZTRmZC0yOWZiLTQ1ZTAtOWU0My1mOTQ0MzAyMjM2ODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+toNLdCLA/s4efgxfQLR7fcVzmrUN+nIbDGYe4X/e8xBl\naQP4EHHbWNMKhl8Dt/pC3fjRR6dqiwpEs7gXGrPdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxAmPrVfVwsCqJvO+3fUVskhT\nwYwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfTZEdxmLfUevWXLGDo2vY7yN73MlMEgFqevCbXUP+qgCIQCnTvapB2MF\n/SbZ4x1jC0QZqvVG5JmS4zQyRoDO5OdLeg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAe6xuL7Zurtyf7e2Cw/KGO+TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNhODBhNWItMDc1ZS00NGY4LWE3NDQtMTY3ZmIzYTk5NzNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNTM4ZTE3\nZS0yN2U1LTQ1NzQtODQ3OS1kMzE2YzNiNWVkMDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARED+KNmU1MyQ6g21FkyuHXphwPGB/ayURF86GU7VPB9utTd59LZ6EC\nkQrm2poj6uDaZZc+Sa5h31cQR+5Ny9Kyo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSGLGJY\n5o9AuWjyRnv++T7jljKPVzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgaSoGr86S23AqE//zLvw9+m0/Cb4dsenekCCJ4a7ezxYC\nIQDl/1+9fjFlBsmGeqZN0iQ2L/Xb9cv8OaPrZzl8/vcdHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6340", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6340` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAbCB9uypXXPnh9bKJZmZX+8oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3NTViZWVkLTA4MDgtNGYxMy1hMzkxLTkwMTc5NDcxOTY3NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2M2OTZiNWYtMTU5\nZS00NThjLTk1OWQtMzE4NTYwMTkzMDdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+3GVfrbMPnWtecIz5NYl3VQxQVySJf4Y94OcNo8mozmLVq239/uvjk0Er43j\n2Tvzx3AQzGximS5UaccLs1iRMaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUgaqXNip61yuwWgrOca07pMWsDMwHwYDVR0j\nBBgwFoAUJG+r2KGTOdbchlZ9pySy/+chNaQwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCS\nQQ6cfa6gO5ZgOX0Y6dnOXouztbHUxqTnCwfY2tbUkAIgPrup8FpJmzPnW09zBwwX\nNlPmbVMQfU1W1z3GN/mBGJ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASSNeF2G178ZfpjvXdgEX+H0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzU1YmVlZC0wODA4LTRmMTMtYTM5MS05MDE3OTQ3MTk2NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQol1xr6UzQEWWiSKMy4bSxvUakrLfN/J8pskprrWVKSs03\nHpP2FrUQoDGgd2PqSRm+Rf+a7EIqMNnXI5kMXgSEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJG+r2KGTOdbchlZ9pySy/+ch\nNaQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPWuBqD2mHCheKYjVbFxtBNZds+kSX4+LCTR8IUa/K9aAiB61lo4CXfA\nLYHqBcssspKSHT4cV3moE0zoHv8rim/cyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAWWxPPN8nvoDeoudN+Hd6yhNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2M2OTZiNWYtMTU5ZS00NThjLTk1OWQtMzE4NTYwMTkzMDdhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZmI3NTll\nZS01OTE1LTQ3MmItYTFjNy1iZWFjOTM3ZTlkYzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASOcxDQSI4vhdwukpRWjRD+VtoegEwnhFlYfq+sFLd8C5z2IyUcg3mi\nq/Wit0JX15aGDh9Wc4owu9FsWf3tgvvCo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSBqpc\n2KnrXK7BaCs5xrTukxawMzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgUvvpnzcCcTBdvbIAclsu3E0ExPlExiJUtahuNBpdwqoC\nIQDuVgDV5/2NV37y4jM4JR+J6HqX2g+zGtOiGrXEnQF2qw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6341", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6341` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISASh9HpUvpoCNc4pnIXzZI1FwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjOGM0ZTBjLTFhY2YtNDhjYi05NGJjLTYyNjYxNDc3NmMwODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmM4YmE3MjQtNzc0\nMC00NTg0LWJkZjUtOTA4NzMyNWFiNTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp2QElzzrJMmA8O3TDMQ3MQfn8qXbRTMkMqMUmen0npI3W/GreV8iqB/NVpEv\nhgqLAYGxzK7FyH9RJXhhCJBv7aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULH3iRZYFZgVaKjeRJ1P3f/hYA3EwHwYDVR0j\nBBgwFoAURF6IQyatkrcSo18THSSYIAVd3/YwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGZa7kIVg+vGwkRGHD19IczpiSfpHgkO8oG4OTAynklwAiAMDPET\ntbQ3XWNTCVieItAZoU3AGVOHoZEa6VcFVbFjXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfNedOENZIF8Dk2u4Iu0+cgRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzhjNGUwYy0xYWNmLTQ4Y2ItOTRiYy02MjY2MTQ3NzZjMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATn3YGsRu/dMKSpWEyV5eF14mW397AudzPO4k0E5rup5+h1\nkEV6KOivuChy9LoEJw4vFQ+erk5tD8hxZjEM8rPJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURF6IQyatkrcSo18THSSYIAVd\n3/YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJMUSoULSN4m+yTyvCE80Xdh225ObGhUBnF0OomV3GWoAiB58DZayUJr\n42wUyLCQfMDyFffufPQ6zFE9dsiZMuDMKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAeK/g9TvvqRX1bS6iYGwSciTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmM4YmE3MjQtNzc0MC00NTg0LWJkZjUtOTA4NzMyNWFiNTVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhODdjODk3\nNy1mNTczLTRiODQtYmRjOS0zMjczNTkxNWVhZWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATxSPCY5/POeiXErf418skiDPyUAGndR3aBxkdmphI350JEnw/1/LwR\ndZ1DqKTNizLnlWfBUT2qUIKW6Jqyy2z7o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQsfeJF\nlgVmBVoqN5EnU/d/+FgDcTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAIO7SjLu+reYegbstPX7aoNpiUnYnfDPCymluYRHYtog\nAiEA4DgFgChg6pMVw80J8IJvZqJ0IiMZehOLi8LEUDSIuak=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6342", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6342` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAWuYDT2gwnbh+rdY+y2hXNBRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2NDI5ZTQwLWUyOTItNDBmYS04N2E1LWVmODAyNDllZDc0MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkyMzMzMDctOTFi\nZi00N2VjLTk5MzktZTk1MjI3NmVkYjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJE66hLQhx6TvY4ZU7Cmt0V7FPuVmAdPucP8Mg74/3eHHkPrmJggf/B8B6yoG\nVv9z5DacjPOjUdHJqu4BbeZtDqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUObaNRWx12M1oTQUR4zRVqw9bg+YwHwYDVR0j\nBBgwFoAUokH/cg/9iDT6uY8mygdtqKsU+TgwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCqvioKbWLVIhiLO6Sa2AIPDn7ayzQR18nHM+TSmTBHDAIhAOoO\nXu+KgHnHy6is+NzIb9bnAm+b0+5F7JrGK2cUrC87\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcXCJfVB5qNOQbGndcNCMWJ+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjQyOWU0MC1lMjkyLTQwZmEtODdhNS1lZjgwMjQ5ZWQ3NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6IMlfLu9uRBivdLxYlGIZ/AMMrk9Ns50Z774M0lwoIyjp\n+qS9NYkDRRf5ptZU5mK+tcqxIHLKAdNPiZ6+KiLJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUokH/cg/9iDT6uY8mygdtqKsU\n+TgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO8EfhaFPrIODSH7c+paUUQ7O6WE4FIGXC82uJBv7TcNAiEA/s5eEkDr\nosQYeRDpUueywUjOgGHmDcp1VJcdXaFbF8k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAdkk9R7q3WgBi89jykTu2OUoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkyMzMzMDctOTFiZi00N2VjLTk5MzktZTk1MjI3NmVkYjZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZDUxZWRh\nMi04ZGNlLTQzZDMtODg2YS02ZDhjNGEwZWM2OTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQao7Mi+dO8Bfm/40vIWaxne+SBal6rJH3/qjvOoy7FRBy6Ro15FSad\nHCoQNQ6JoMVZxnOxb2oZXvDb8DXM2yz0o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5to1F\nbHXYzWhNBRHjNFWrD1uD5jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgboPF+hCeUl3dsSa82pMUTmFSbItsN4RqrGbgLpBrg3gC\nIDnlTjy1P1xv4cb/GmKuyPpJow32VTXdUmmGjgbLg1KZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6343", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6343` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAWCNxZlH7ny1NE7cn9KeFt4YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjZjQ4MGUyLTBiMDAtNDM4YS1hYjJlLTcwY2U5ODkzMTIyNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk5MDA3MmYtODcy\nYS00Y2VmLWFjYjItOTY5Nzc5ODJjMjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUmxZQgrKYlAikgC82swVCpLUFQ1dmGqR0GOXyhiG12DIbOZ0wo0el80NZQdl\n2HAxCot+OFnpbyQIP2ESyNvNyaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFkKjAB6aGtGZ/2lt4TCf3KJUpp0MB8GA1UdIwQY\nMBaAFDZ5G8+MvD2/qrw1mj6ghU7hwFU+MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA/Rmtyr7OGQ1UyjCL4wtwvF1/IVgKkUyMY\n33Zd91GgbAIgcqta8uDhUPkBDdQY127HfGZZ7+ryMgL5pW3oj5SkE/Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdpXJbGUABzdha+uFm/rIC8MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2Y0ODBlMi0wYjAwLTQzOGEtYWIyZS03MGNlOTg5MzEyMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROn3egyIuRXOmPwnkbHBWUHX3dHCDK6vREG3DfXAhb/OPM\ntFTK1I3vmnQg2Vx/RHzza0oiYlQMQdZlPt8RBbmEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNnkbz4y8Pb+qvDWaPqCFTuHA\nVT4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJdB8Zpy41RFUzl6SjTDmfHkJCZWK7x5AGQgfoBLjjtfAiEA0h7P+1nI\nBNVtvCdaXFAsJ4XZQHMdLSUfitTgblwwLhY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAWE/sFOud1TJsWJKUCPGcp4/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk5MDA3MmYtODcyYS00Y2VmLWFjYjItOTY5Nzc5ODJjMjA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1OTUwODQy\nOS0wMDNmLTQ2YjAtYjczMC1hNGU2NDc3YTdkYzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATT9I1+oZ0SUA5DA0cLsjoxrFD8oGM/Voc0waSPj4KPtAbrLF/a2b5O\nbIMO/eOQVmoy6MRaS9km6kE4m7rA1/05o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZCowA\nemhrRmf9pbeEwn9yiVKadDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgT0cFKuNg9/AfUSQdOd57gS2NJwcV0reyp49l6/qXwjIC\nIFFqxmJC91eWGwbFXab12YGIQLp89UHlhlD9Fr/NQmvu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6344", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6344` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQklQReqn1eZJA4l+fLnJTW3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkZWIwMWQyLWM4MGQtNGM1NS1iODIwLThmNjMzMTRhNzkzNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFhMTY1MjQtMTVl\nOC00ZjZhLWFmYWMtOGU1ODcyOGQzZGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5n3trvWXxpZ3xjX3JTnyeiu4/uZVxsOHXrZ9GJ2TV6lbSEryE1qeGNmKQ9fb\ntZnGweIMurq0jFZEIsZsnRqzqqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUojbsqxW3EUe8VYSvQpeiptizMI8wHwYDVR0j\nBBgwFoAUQpBwdA/0lGYhpe6m0XqvCpKyALswKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgG8Q5UHORP0Ic\nh3Ox+G8yJ7DrZBdnUCpeu32l7aMhlp8CIQCJlg7xF7l/QFiflrSMJTDIpYk7K4OP\nyYDTKmzjMz5epQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbKdIapp+hQVtxcMPCMJwdnbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZGViMDFkMi1jODBkLTRjNTUtYjgyMC04ZjYzMzE0YTc5MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8dfF/6Wpvgpas2duB6LgvBCrCZHxc2alahbrvp1W6FRW5\nLmJde3Jixo7lwwahqwwPhPC/jjUxSaehKRn2uFKJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQpBwdA/0lGYhpe6m0XqvCpKy\nALswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANRKV9mgLuM32FdaeH+r/ynb/zOxC6/DuFwQiWZGiNGCAiB1zrZMdyAP\nbUJpiI53gXBUx6HujjjYhnFjdhxlhaqnzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAXaGImfuKtTy4IITxyfzAkUyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFhMTY1MjQtMTVlOC00ZjZhLWFmYWMtOGU1ODcyOGQzZGFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MDNmZjcz\nNS00YzM3LTRjMmItYWQxMS05YzMzYmI3ZjVkYzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARxS4SFuSg2D4ZyQ5lK7yRjdbL2ZHJwafiSmVIl0QnsYuxKN6ZbXBdv\nSzV7CfNSmqEQb6Fmud2Ax9v2xZ2cBozto3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiNuyr\nFbcRR7xVhK9Cl6Km2LMwjzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAOYSeQeqAh7DLtNnztTj0JhVuo9v5as/55BvCPFYM/JH\nAiEA6VTpo8SklfgSU+MXyG1kNsX+DMNZsTTzY8lQ77j9+oU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6345", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6345` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAUH/dfjRLTZxrI3bkArkghCFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhZTI5ZGI4LTE0MTUtNDllZC04YmFmLWE3NmZlZTIwNzk0ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q2MjUzZTctMzM3\nYi00ZWRmLTkzODEtNjU4YzUyNDAzZTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0gnUxIUNKQJnDjny/A6NMWgB29Si77K3aseMHbGO6zIKFCacDdmlkM0mBAjS\nTaFN9KzlwcV/I8as0+N3YdYHBqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4llyi3LKqL2IUdIgE/fnLVweohwwHwYDVR0j\nBBgwFoAUUzcojQbBr5r6RvDAco/0j7nkOjUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJ4rvBpAu47I\nKiD5cp4ZntNsG4LGuvpCNyOq8xt5/3JWAiA+WpQScCY7IWZZd4C0AsDkhs11PwmP\nnpoXlwuu4ls04w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAezg7SE2NJh+qEFPV8G5Ose4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWUyOWRiOC0xNDE1LTQ5ZWQtOGJhZi1hNzZmZWUyMDc5NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT443hBxKZVgtiDiPYtddEocnVPWM0eN5+0v6ESORrACcV+\nldIuHJC2u/fUdPZwjKVASjpUb9vTBN+5YdiXZ/0/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUzcojQbBr5r6RvDAco/0j7nk\nOjUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMCIB2jBLFlgHntYNrzoj9hPKoRVYzYuVXshyT+VZzLYAiEA0EBIJ4Q5\nPBtaFJ9HOWhmBEfaXQDqTYb2av73oN+IyTs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAe+bTX2KraWSQv4y1LzFv5+YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q2MjUzZTctMzM3Yi00ZWRmLTkzODEtNjU4YzUyNDAzZTlkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZjIyZWMz\nMy1lNTlmLTQ2ODMtYmMxMS1mNDFiZWRiMDVlZmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAScEt26YZGb1iGc2eruM83yu7SOM1XU6DB8i5f159458V1kOkfKhR0i\n6wpCcozn061+4be2OnoT2uRwYSZk6uIKo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTiWXKL\ncsqovYhR0iAT9+ctXB6iHDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAKU9VL5gq4l3lIHhwLy3l7wo+OeQOoJRzISg22YPvFih\nAiEAwSwskzC2saQQ07hqTCyRrOH/2uHacSkar3yBxHuJI5k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6346", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6346` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZfYeg8Waax5K4WXYL5L5+UNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiNGJlZWJlLTUwZjgtNDE0Mi1hNGMzLWYwMTk1ZDc5MjY5YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGYzNzE4NjUtZjc5\nNy00NmQxLThlYTAtNTA2YWMyYjdjMDc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzDF84B83jCKIVJW8z9+R6nDk2Reqb9TzuFWzWyj7noINK5cWID59/0fuJywH\nMcq/WjPP+dLVBJDVU9XG9qQ2PKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnIViYXonicBq+WaOXkwdl56ZoGcwHwYDVR0j\nBBgwFoAUNVwyz3wlcMGFQlu95UORpyW8t44wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIF11xPrQBcI0\n5d0QgkfmIiUAktmEuJT3ViNg75V0F+b5AiApedPX7hl4QNamnihD6fj+VHxFCOV6\nQJ9TE0t/PAydUw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbyLK2G1RUzHKrb9j8UV09SIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjRiZWViZS01MGY4LTQxNDItYTRjMy1mMDE5NWQ3OTI2OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDP+JkqAN7bgpRZ8g3iTkan2EHuUM3pgTC/CkM/wi/0qXk\nYiha6+PQTKgDJYfL1B7KqS++ChDKkTJ+NAwbSN+5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNVwyz3wlcMGFQlu95UORpyW8\nt44wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOnf70z9fg+TiErrQtT0+16jT7DFG4Mr1dTKNvtReUzeAiEA+XhhpESd\nwEHWGm2AHl4LOM6vRYCrhHd+39SAsUVlF2U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAUdFEe6uKXq2jp/6b9K5Aj5NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGYzNzE4NjUtZjc5Ny00NmQxLThlYTAtNTA2YWMyYjdjMDc0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYzg2OWVm\nOS0wNWM3LTQ3ZGUtYTA5Zi1kYjhiMzk2MzU3ZTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQydHiZr96rQzoRvYvjcXAJm5LZWNu29xBJcR6U4/hPc/JHbyP8qjCS\nZEzDyGCG0XjK4HpK+O4CdvMSEEs9w6qfo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSchWJh\neieJwGr5Zo5eTB2XnpmgZzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAOGZO15MX8zMLhVms7C1x5myEcKuOPuoRTp47SuYe2BD\nAiEApedg2dHrv2icqanqLUlyEraJ0GSx3DUETiPv/gzjOQ4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6347", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6347` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVkWBBoWN3pkkIvYXLBnIhHOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMmQxNjE1LTljZDItNGUyOC05NTRkLTlhOGYzMTdlNzY4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVhMTM5YWMtNDJh\nNC00ZDExLTk4OTgtNzE3NzFhZmYzMWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELUmEB5GyxnExKuNfvLAhVQ5KQM78pls8nN5MtVLmJshQea8pSUPytQDgfHRy\nrC1n3gkW8k6WFMM7CNI/0g4MK6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3+JwLgNx3+bqcOu9P0+qDi8cEU4wHwYDVR0j\nBBgwFoAUThzyea4s0zAwA+NeGNpUnZpMduIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCC9tm7P33U3GxxuUxxIQZFO9yR1oqSJlU2WEGt5l/UkQIgHPsEyu9QxeAJ\nAdVZ/QLo73Mh5Ciy1+t8bteEVPM4tCM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbmfxYEjXOzIELmGV4mKXbaZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDJkMTYxNS05Y2QyLTRlMjgtOTU0ZC05YThmMzE3ZTc2OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASr2VYKWEjQFRClq8GLUQb/QLbArOpJj1hXGsazJkJa7BnO\ntuM3wQVm7TIKA7339Csyo2WpSTITQdA4p+AR9bKyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUThzyea4s0zAwA+NeGNpUnZpM\nduIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNU4glAk9WuvvXjjPkg7XEOpknSvfKCMro8TgoEn6etQCIHkS6nXjjVo+\n9epYbL3oYavEOhs8SiMNEq7M36UaVXBm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAQyX3lHbcxfMyOHeOmo08FVgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVhMTM5YWMtNDJhNC00ZDExLTk4OTgtNzE3NzFhZmYzMWJhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMTk5YWYy\nZS1mZTIyLTQwYTUtOWRkMS1mMTdlNDkxOGU4NmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARY0It3vZ9p9UrNDJmRIQX4xqy0SQ0x46vaQJn9IQhzraBCqWYWnk6X\nPhgZnw0pPWDN5JV8Ig/UQqoqRAowtuyXo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTf4nAu\nA3Hf5upw670/T6oOLxwRTjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAPofqJmHom5OUz4V2PBheyfWEtYwY62JX2/Yd2kbGQUl\nAiEA0ydMzY5S/L+yYHU6VWCkyYafTufwXV78xgRudRfJWtY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6348", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6348` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXvV77Odd+4YeEwEIprEgXmpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZTRkYTM1LWI2NTQtNGY3MS04OGIxLTJiNDdlMmFlOWU5ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGMzMWM0ZTQtY2Vl\nNC00ZTZhLWIzMjAtY2M1YWEyZjdlMTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzwXlehTu7x4zzddIM2oWPSxVvJV5azvCZgY6h84HGT4QSDyh4MdiOeFF6W8O\nfDBSCeaAXpLuyBek5CRAqmfnBqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw5Q+cAxitgTEeS8eYf1usObkp7UwHwYDVR0j\nBBgwFoAUa9IQTn7qtx4zcgoKfnvCKqnFQ2MwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBhm3hZTqBsXcHDwxwIhyiOcxGixdXHxDjO86S6l7MtwAiEA52IGXj1IUNyI\nfEiuz+8mgf9PWiokSATw24uUai1wJZI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS5Co1UDF8fjBzBPazQ4mgX5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGU0ZGEzNS1iNjU0LTRmNzEtODhiMS0yYjQ3ZTJhZTllOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxcxkLYYpJ5StmaizsAmewd/dnsLN+dDyR4Yz+grtmAaaN\nHIAJGg3iHqtVD4oqkXeX5utUfGNeXphi2TVOEmR5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa9IQTn7qtx4zcgoKfnvCKqnF\nQ2MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANlvbQjMTn137rFzN3ES7/1WhwqT21//wI3neo7Nu7+nAiEA/kusw71n\nf9XNbl33pDP9IMkdtFZWVvvOjfCCKwfAaSU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISARJ0hpWknrgd/KQDAdbrwlpVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGMzMWM0ZTQtY2VlNC00ZTZhLWIzMjAtY2M1YWEyZjdlMTE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYjMwZDgw\nZi1iMTZiLTRlODItYThkMi0wZTc5MDdjMWU2NWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARxAy/nTvDq0j5CluVJXPL7aENnimM4OmEh8/RAYvWPTkL9Rgs6qInl\nCsylDFVHPnZ9Sdin+UmiZwLLaapY/yCuo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDlD5w\nDGK2BMR5Lx5h/W6w5uSntTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgH/EgGyEWeiK+yFUghDqIr988Dn1x8kUPjDMM+TDquc8C\nICRkurfTdKO3JTm3h9mTqknankWApSq7FGwbA/M95h6s\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6349", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6349` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAXbHryt3rKKMFrRG1z3KqnKEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhYzZiYmY5LTBiN2EtNGRmMi1hOTEyLTY1YWU0MzRiMmZhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg3ZDNkYzMtYWY2\nMy00MzA4LWEzYzItNGMxZTUyN2RjN2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzAf240z0Kh2rNvNmNwGTuCg9FMskpgxL66OUZq1ZuruZlO6OIpnU4KEjPnZO\nQrmdtk72No0DwYYyAwEzs9NDG6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbn9qvlFlmTCYttUkVPv5s+IXqZIwHwYDVR0j\nBBgwFoAUnxdXXcbIsQxmyoGkMGS4VW8G5QgwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDj\nUCH9k+weU/qIDwayIbu1SkLogY4aO0vW3S5rsbYkcgIhAMBerA/TjexYjfbqS+MR\n5I5c7Q+9jW4Z8r0yrjThYBaJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZXAsquW6c1vioNRA9M1fF+ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWM2YmJmOS0wYjdhLTRkZjItYTkxMi02NWFlNDM0YjJmYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzC150Ic8H46zPT1xXhgGROhS8IR4B8ipns0U4j0ZgDsuR\nK4YppqtMqmI7DNi7qL9woMaNwl5zzwkhvvvOk6xxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnxdXXcbIsQxmyoGkMGS4VW8G\n5QgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPUqg1L5OYYG9mrTlyArEU68Khs5L9MUJyitlE2XBsIcAiAcsyJk6sR4\nDTjPr4tNR8X/vd6UwFWI9lSUzkbY2JzSfA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUFY2XPPD/Lk296Ilhlp+bBJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg3ZDNkYzMtYWY2My00MzA4LWEzYzItNGMxZTUyN2RjN2NkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYmQyNDhl\nOS1lZDY3LTRmMGYtYjYyNi03ZDE3ZjUxMjAwNjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQzEK+7eeZt1a60UbXi6C9uIY3s5insC+1R6DJxRJPBESMs9x9SkGYM\nm//GQssvWoosIzuSB8fFL339hROkZbK4o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRuf2q+\nUWWZMJi21SRU+/mz4hepkjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAM+St7rSSvHMK/sVomNJA1LVUHr/r+/31jQGY57AVTPI\nAiBYvYbh1fV91GvrCk64ZXMjeipZnLBT2L4ZFJ7UERPZxg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6350", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6350` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQnMtBRpvtr3zbfB+vB1wkEOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0OWIxODliLTRiMWMtNGE4MS04YWU5LTgyM2NkMTA3ZTgwYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE4M2YxNGQtYjdm\nYy00ODhiLWFkZTktMTk3YWQ0MjVkNzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtUtaQrpGBIak117jy9pRoG6hEvygK/6BGxDGdGhZZt2NGo53rtxxkjqc/cvY\nkA2DAXXIn9AUbo6IP13nzfdoYqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU7m+zE+YMhWJ/UBHnNNq65HR/n4wHwYDVR0j\nBBgwFoAUrb0zNqzcXqD5fqoJIx+8ycS7xYgwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCzDUylo9PvBNVdK9ebTXGm1Ci7Ie1Etu+XetjDrIsMgAIgRs7f\nmrH1evBWcYq9R89sBem5oJe0TmUePTUFYGDdHKA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWQywnnaxtacyCzqVoiJJqeLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDliMTg5Yi00YjFjLTRhODEtOGFlOS04MjNjZDEwN2U4MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStV33om8HldoRQtG5YoGZ/u3iVehu0KAUui/u+yTyRSM4I\n6wRNPklTERwCSE0Lv/6rpYRkYpg+RzJ7ppLq40Ydo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrb0zNqzcXqD5fqoJIx+8ycS7\nxYgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKuOYHrluTZZP3sGqXBOC4PJOokVmo8Jspg+mjJaox8xAiEA8OXn3gxH\nUqJNpviBjmPoYu8/ksVUY+sNH4GXMHysYw0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAfPau43bOQtVk1tjChNMqgbfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE4M2YxNGQtYjdmYy00ODhiLWFkZTktMTk3YWQ0MjVkNzc2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiMzEyZGNh\nMy1iMGE4LTRkYzAtYjdjZi01ZmNiODI4ZmUzZDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATYVqSjUD/rfJlczcUcZTJv5GzRN/4MX5bmQo7uFLkDLTmnYhIkwejH\nlFtoQu8gsnIyQNiuuwZ7HIBg/8j5HCpQo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTub7M\nT5gyFYn9QEec02rrkdH+fjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAIWdTDs/5IchlCLAUjIYVPbl8CQbwv+7V1WAm27P1m+I\nAiEAiJFfDmJNSrvWtExcx21BxcSyqK4K4HfB53yZCdcXyu4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6351", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6351` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAfTl8Fi7vXK0YfyMwkZ/peFQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5OWI5NWNiLTA1ODUtNGI0ZS05Mzg1LWFlYTVjNWYwNDQ5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY4OTMwODktMTM0\nNy00Mzg4LTlmYmQtNzMyNWQ3MmFkNjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEocw6HmInVZ8v+l94rXbfKCQHM7qFmKTReGGy62zcdTBD9CKWAWU8zHkNYke8\nSQRZPJhqRX3TatNPL4xknqWm+KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZJOOA3UrT9GWQcrJZn9saOq0Pc0wHwYDVR0j\nBBgwFoAUC6BZUzNm1ztOTUUbVo17hniwa7IwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCNg/qj2jWJehfzB9r8wy5MCgaISyvD9X3UuXVdErPQGAIhAL4l\ngJTaJ5143qEi12DV7kD46KgQt/vz9iJQ+T3LazBf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARO/UGLluoFBW77uU4kBL+GXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTliOTVjYi0wNTg1LTRiNGUtOTM4NS1hZWE1YzVmMDQ0OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2H0xEzmPASqF8cnnYm3SUpkQ69sn4U5F4uP3jHfh5Nmb/\nsCAEHjGFgYg3QCeP6bn8Xtcv4JfyMYgWtvEDzyaho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC6BZUzNm1ztOTUUbVo17hniw\na7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMLvJ2SOtRT/E42U6Sx3i6QIo9XbRqv7F029wwjlbZ1WAiAX/UTPt2Gq\nVvIKSo1jW1WfesvwOm34UNBRAwpCYh0aVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISATTNEa9k79VskybljA0NIkaBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY4OTMwODktMTM0Ny00Mzg4LTlmYmQtNzMyNWQ3MmFkNjg0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNmU2NTU1\nNC0xNTlmLTQyOGYtYmRjNS0zYjc5MWQ5ZjM1ODUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARPLhrhgyHIEeUf/hyjA9btqPS/MmjTTdIn7haaMh5/jbDeXInQ/czt\n5Z0e98QaA/NNTYKsDmh4hGRzifp6cqRVo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRkk44D\ndStP0ZZByslmf2xo6rQ9zTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhANVZjJllvzM5PmeOhg6rTm237SVy5YgCME07Xcm3nPZi\nAiEAzp+FbAzCVrQkWeryekvJBSzLBrz0zzE0NPMaU8j0iXM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6352", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6352` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISASpSFLMLBho4lbMPv7VDxPCQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1MzhlY2FjLTBjNTEtNDNmOS1iZTkxLWM1MDk3ZDVkYjY0ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA1ZGI2OGMtZjNi\nNS00NzYzLTliYWYtMDdjZDg3OTEyZWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET3+tDeFpitgCcbo28YL3UXdFTuIiFjaW1/gpfGZXIkBZEPr9AMXuKDmuDIpf\nmoG5aQMxKPUcQR7xHlzgFJ1hG6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRv54MYfszkx3Wadv97bUlmd3Oj6TAfBgNVHSME\nGDAWgBSgcKDpqTezDHma7At/KNW57DLkYDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCH1mMe9z7xiCunuv8FtK/PdpM72vZ0\nkHXcZchWCrKc3QIhAJZ965s6SeFTHad5F5qboJA8TPhDfNNeO60zSqDf16zz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbl/yqElg67x5gWA0QaNs4jHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTM4ZWNhYy0wYzUxLTQzZjktYmU5MS1jNTA5N2Q1ZGI2NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsJqlQZQ8D2EsOz33wUiezYVOU2QUm0U3KF4ddfsdPgVh3\nRQ+T0MnkINpI4Nu0dZ8JHt8oQfSQJmigxGlJAhBvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoHCg6ak3swx5muwLfyjVuewy\n5GAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJhss3g41pSwlzrJbWUIV367QcYHPRHuyOR6M5vyAIVGAiEA/Qib9+7X\n4uDLjt9SMDmadluyLq4mJGkRwUM3n+bVczw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAXYvJEoarImKloQ24FAxHiwuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA1ZGI2OGMtZjNiNS00NzYzLTliYWYtMDdjZDg3OTEyZWIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MzAyNTNj\nOS0yZDhmLTQyNzQtYjQzMS01ZGU1OTBhMzk0YWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQnrcvUQO9/f5puJjePIFjJcKtTXYG74ZFESFckqymge4RDXYVqd236\n8/kl/43sH2iBACGQy4MBr23L5t0JpKKqo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRv54MY\nfszkx3Wadv97bUlmd3Oj6TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgVbo1rJVkBoNaqhaBAoGDqnwCimh1A2I11EXHU6g6US4C\nIBnSK/O87vrQ5WJ+shS/8UzYaU6Xo+5kKnmjf+wTjKkK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6353", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6353` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAfIQUCHrHHj+vpyj90vD+fEJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3Y2U1YTI0LTE0MjAtNGM4Zi04OWUwLTJmODE4NTJhZDc1YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc0MmI0MTctZjM1\nNy00NjQ5LTk4MWMtYTRhMThhOTUyOTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECoThxI8FvM/udFt8yZpTxRNrdmIeC9sQ/r8DiepKBFJg1yNjvEQxJ042NioJ\n12fni33xGX3t8Xu0xvNVZEg9IqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbL7R3ZBn9d7Dwn4LbWr+J4IetoUwHwYDVR0j\nBBgwFoAUAFNTGBLiNAChNBzPEZ9t/iK5rv0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC+OI1UFfrQ\nWKcSC4FyD+kNyKOEsJ7n9juVM4/KJX/imQIhALVQAHAndTz0GYm30cR2Myt3LorO\nBY9Kehcc1N+YtE/R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQd2S6xNjsPsqj0Ki9oTIjBcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2NlNWEyNC0xNDIwLTRjOGYtODllMC0yZjgxODUyYWQ3NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfsRyWAf6cQwKnu0Yw1h4EUetpRXGqsKzHi6V4WC2T+K4I\nJdcVbBdFY2R3zYziA9YZUtnzLW9N0jj62u6xU3cFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAFNTGBLiNAChNBzPEZ9t/iK5\nrv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMIbzao/3pHK1re9Yf/E8jFBIWq66ItyQ1TVSQc3utTlAiA7VHst5J0W\nQcaSKE4cM8uV/ABr3+GUZ1YJNpVb7l1xYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAVKIyTSzR4IhJr7YTuwb7L5GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc0MmI0MTctZjM1Ny00NjQ5LTk4MWMtYTRhMThhOTUyOTExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjODY4NDFl\nOC01MGFjLTQ3ZmQtYjUwYi1mMzE0MDZiZDlkZDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATSAXIx61GuD4k6pWlUw4OO4jQo/8QBxrzusXpqIOubpuxhi731crDp\niCY86qBBwofivo9MGwpv3zyOO9mrg0+ao3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRsvtHd\nkGf13sPCfgttav4ngh62hTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgfl5YCSZEk+84YCTPkpxpEk3AmJHBqGcrYaRXlMNNj2IC\nIF6wxpFdnDHW320HJ3xaWcTeflViyFQbO5PGGVsHSyZv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6354", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6354` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYuxCzz5a7+HQMrT6Z4KwNRmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NWM2NTJjLWE4MTUtNDkwMC1iZTRkLWNhNmU4OWQ3NmQzYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRjZDhkMDAtNmVj\nNy00OGQ3LWIyYjctNzQ5OGJjMDMyM2U0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEivT7LZ2zBMdG+C2sBktMPGKfRe99sNrCCqAKCVKWTve9C0QXO6zkDimGnIyB\nOzPTkfWzr03SHqvd/EdMR2hdv6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9upN6H/P8aY1gy7qerF2UawKE3EwHwYDVR0j\nBBgwFoAUB3uEVt0cyJsY3YOkLC1OUyP+X4EwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDZJNUwIkFW\npazuJ2MZKCphT/Jgd55p8TqcNrYQJCRPKAIhAJheI+SXvgpi9ynLFqBMh+PTw0Lk\n6DbPajnEkhg/xVy7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQlK6IKN8R89HE+3T4vSr9K+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODVjNjUyYy1hODE1LTQ5MDAtYmU0ZC1jYTZlODlkNzZkM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1W9vHwzl/YrMN+CRfF1DTg45oZXeRihz7DX4tPH8GR/Vj\ngZ0IrWDzHQmBagio29xrEhSqOwevXpmvOdT2RnNvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB3uEVt0cyJsY3YOkLC1OUyP+\nX4EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW+DZ/KF2vS0a/Xh7cThttKzz+vsaOkcHlrlo5s0AU8MCIQC7Jy/E/n8z\nYDqaxF6+2D9O4zChGLNddr87xoAFUAknkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAb459ylwmDtn9rspaeYHhH9bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRjZDhkMDAtNmVjNy00OGQ3LWIyYjctNzQ5OGJjMDMyM2U0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MmU1NjE0\nZC1kM2FhLTQ1NzMtOGZlOC1lYTkwMjkzM2Q0ZWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQK1NHI1Lb1Qg1fM8G6xjMUQaP/SQZq7toz1XublmKnuxdzR+JqMBJS\nryHi7ojCkmZi6WBSGH2dpM8oiNMMGRKco3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT26k3o\nf8/xpjWDLup6sXZRrAoTcTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAIlEhO5LIa22KTSOtO/ycIxMYDH1jWkXmgMchmy5jAIV\nAiAVuhbrIo4EJ6XNY6pCwEFGRSphuK21dWR/CuQ4dE93HA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6355", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6355` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAdbtlbmQxzp7Rb6MJnCqNAiyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhMjI1Y2Q5LWI3MDUtNDAzZS1hMTVhLWJlYzM1ZDViMzhmOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmEwMGY1YzQtZTk5\nOS00OGQxLWE4YzEtMGQ0NmU5YWE4YjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmFj6CSjFCQ8sHo9BtA41ktWibfWK0cG85Ig7mBskhIrh+TEtVSpAPfxkyZuN\n9hEFj4h+tLmLIVV0l3SoYC6ZBaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbK2i1DUEEgW7wENeTKRKDeHQDdEwHwYDVR0j\nBBgwFoAU+jJaRgICXAMvSb/d0d1LghH9NaQwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAk1ZljgWX\nZJ1IGxjN9MmRr/+DsjVkoxqxwMpkVNUmJnMCIQDhou5JnJm66VkWdwGhSpB9hnVt\nh+k26oUvTnMsEeZznw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdugapSuWKLMzlRTz2TFqU6fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTIyNWNkOS1iNzA1LTQwM2UtYTE1YS1iZWMzNWQ1YjM4ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBdP1mLrK/ErsTsfmDmwOafz/zqV5OqTtVywopEEmdk/sh\nNwGmN+JXNrIwYGmQrIoCiAsJ25oWzfX1jeItYTDuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+jJaRgICXAMvSb/d0d1LghH9\nNaQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgASEKQEcadSyGgplAsi5aBCCUR7+fRwk8Ew4iE9df9y0CIF7pwb0RQIUL\n43dHFy6h7/mkLwuNLb5I70WrnTzQdWR2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXNm02IIOlsJlC++7McsR2WdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmEwMGY1YzQtZTk5OS00OGQxLWE4YzEtMGQ0NmU5YWE4YjQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkOGNkYjQ0\nYS0yNWJiLTQzNDgtYWUxOC1iMjZkZDkwOGY5YjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQeteaPtfd6je5JyOHuJaxv26txkPJgjhQA15wwk2HHlp19HWRniHP2\nizc5e3O9B/wPmJFX8uUuGs4n+V2TakNvo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRsraLU\nNQQSBbvAQ15MpEoN4dAN0TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgSS4Emmw+9IrkJiXRgGU8M7twxk742Yxk7X/V1xWd96QC\nIQCZzX6i325fx8qJJMcLfYLN4F/LUk+Yqqh6glJqZX7npA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6356", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6356` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAZ/YAbvSCYkExVxoy/px7UycMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3MzZjMjY5LTU1MmMtNDBhMS04YjQ0LTIxYWQwMWM5OTAyZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ0MWQ0N2MtMDlh\nNy00MjRkLWFkODAtY2FmNDNjNGVjZWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6tjdw8M26NjVZMBL19SWXe1OpBAZMtqwsVUTdCyo5ILhNFnnDsfTOgl+o2rQ\nzuLABQQKmhP5jcpkyv/YVk20zaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIVJLRp1c37dXBx6pSv5bGdIrilUwHwYDVR0j\nBBgwFoAUuqO3Lk5bymyENFm5Pnw7HtV/4l0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA6HYGmmY4LIraUurv56KfxmWzHAZIuBs2DpQ8SwREzOUCIQCdCa6KHYIi\nmCKoMUvwhUfGVgP783ZgBMoJUgSO17zVEA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX3NCsVjwdVzEC9UXqr7Br7BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzM2YzI2OS01NTJjLTQwYTEtOGI0NC0yMWFkMDFjOTkwMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPpHJqKcPze70XcbR0qTcJ5vE7EPQM4bVrM3PKhQL9L0U9\n5xNSwqAZdUpfhRAilOQSLfc2j6iG74JwOe82JyHAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuqO3Lk5bymyENFm5Pnw7HtV/\n4l0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZS6Q7rSNBFyApZSSN3SYh5q1di+RlmB4l6yjjewx6tACIQCIlcSo1YFn\n1SCbl+Imkb+Ll7Pkp74cZu3bNZldGld+8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAdKBHwg8/lmOHP2pgtPprFoUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ0MWQ0N2MtMDlhNy00MjRkLWFkODAtY2FmNDNjNGVjZWVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyN2YzODYz\nNS0xODE4LTQyOTEtYTliYi1hMWIxZmVjYmVmOGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQYIeckl5CIG8oWsEQ61ll3L4y8lna6+5HoP9nLRWt1PUIc6Jon32n0\nAZfaZw26Q6FrN94jZl02m8kN39ZrO0mso3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQhUktG\nnVzft1cHHqlK/lsZ0iuKVTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgWrwUAtYDRUWRyCn1egmSfYoeogViG60EliRhnAFMcm4C\nIEoO/liJM6j7z9t4+R9VeLyzAtg8gzv/CvmttNCGbBcW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6357", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6357` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAaEysOi/M/aw54Dyu83hcP0oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0ZThiMDgyLTAwNWItNGEwNy04OTBmLTU4YmY0NmYzMWRlMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZlODY0NjEtNTg5\nNC00OThlLWFiNzQtNTE5NGZkMTMwOTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpJaRUFgmKefzEpKkB/g2Trrf+KvSSPvnpKPrX/VmJEi6Wfz23xN1pjfloaVV\nYPEC1q+EKknVs4Sgkm4gnjEp0qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/qrm163enPyeCeN6PysS9TEV7dgwHwYDVR0j\nBBgwFoAUyTuunQhb2tPKxpgaCdsbPDiNM5wwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiBSEEI8vn+gupEzQ3fD/H/SgIkWVBanlZ7PxjiJ3x4jkgIgTWfzNMNYwFyX\nslqDxJdeSe1ZQ89X3VBs7eJKKvb/MsI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeTJcLeOCzq68CRMQv2QPDNpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGU4YjA4Mi0wMDViLTRhMDctODkwZi01OGJmNDZmMzFkZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATf+ayQpDLpSk7C5fm47JATZZWCgd+CANodrD7mSj5AEXoH\nWWXh4zba4mQxBhFJcDXRVhl/+KQi0LNS0PU5IjXNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyTuunQhb2tPKxpgaCdsbPDiN\nM5wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ7ONygqJwZ+A5FRLEPt/c7vxE+r4z7SpZFcOjzGjtFwCIQDvgr0RKFIP\nFb2inHCqPtiYDmPny7YKyxDISDIk2vQrQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASR2SWzE0vPnl36eo2EyoJV9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZlODY0NjEtNTg5NC00OThlLWFiNzQtNTE5NGZkMTMwOTBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNTY3ZGU5\nYS04OWFkLTRjNTItYjE0Yy1jOGYzNTgzNTA3ZDEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARfJt6fCyHH22qioxdx3dUp2GlZk9vZjOeX33LEgAAYE30l40uFEbhI\nSKtxhIYCLKN/Pd7aDIuNCjHCK/fbeADDo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+qubX\nrd6c/J4J43o/KxL1MRXt2DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgB01nrpHmcHl4U0GjDtaw225Kqr59Te7+zstep3WrdMYC\nIQCYPUXMpxjz32uywEW+7uX2c0aowKR4cHtZjeOYVnFTrA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6358", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6358` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAUHi0ymjUDBRBhuoTsjPBSC3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1YzE0YTgwLWMxNjYtNGVjYy04N2FiLTJmZTBjNWM0ZWM1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUzNTFjZmUtNTVi\nMS00OGZlLWFkMTMtZGNkMzY2ZDBhODZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8E7s44oscDmgO26bcrnJbdP/+oBcSvzD6552mewz8W9jldgPfpKjP65UA8og\nA3ZPPYrcHUI82X4+fNqdZeLlaKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsGaYSJNOwuVOAuRGZxcrtuiHUr0wHwYDVR0j\nBBgwFoAUP63WZ6IyBCFf7bGDg0Dt9rVXBecwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBF\ndVr6IAmsxBcLeaStDdZTvIHcMBude6kHaDKpYo/aGQIgJ3lb6ADm1JbyBcb4RyL1\nutka7EAYUs0lMNkUc43wq6M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQIYCgbGTXdEHRQDF4XAqGfXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWMxNGE4MC1jMTY2LTRlY2MtODdhYi0yZmUwYzVjNGVjNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4OjTQbN4Xq7KD8airqfp2PiJs2R54tyT2a2bQdWtDun7r\n7nZIiZucCUjWGLp3JWx+iosXKasqEChT90J7hiCUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP63WZ6IyBCFf7bGDg0Dt9rVX\nBecwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOAf59XofFuSNpCw7wD6SspH6l0JByx+HN35R91ypIpUAiEA/C+z5SrY\n+9L6tN7YaYalWnCkVQoQGzV1Yvzq2Ym5vQ8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAcd00ZP7YOPUHOWN+zxjA6j3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUzNTFjZmUtNTViMS00OGZlLWFkMTMtZGNkMzY2ZDBhODZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzN2E3ZDBk\nNC1iNDk2LTQ4NzgtYmFmMS00NTI4MzE5NGFmNzYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAStwAmytrKEuq/QUAO//GRNH98iosz8+7jlnmTzFclv+MpJpSWdNUza\nTVQJinFjtKTJNSWTkxKIusXp9LqZsnIio3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSwZphI\nk07C5U4C5EZnFyu26IdSvTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgXvEPEvyUpyYxsL18/jeWaUaA83mTHDXDcLscChFRiG0C\nIQCDJUKPORyaR8Ztwh3VG3S3gSDSjohB6WoUYMDwVdQhAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6359", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6359` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISATs4nS4/YVkcyWbDleJ4lM7wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlNjM2ODA3LWYxNDUtNGZjMy1hNjFiLTdiMTY0M2VlYWJhNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNhZjM3OWUtOTY5\nNi00YmQ5LTlmYWYtNGEyMTFhZTEzNTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbT2YRhbVS+nP6EjVr7f2RgWOJFxMyq6iuzMRBCiLfys5VSFkbx5fzyRPMiaQ\nTsDwrGayzDgJuYmpw5IKIF80PaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFefa91B6h7su+ceSlSCH7GAe0d8wHwYDVR0j\nBBgwFoAUd99BlLYKkIXDE2rBPU+4xhwLHMwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiBOC+uoDygP+1Um75lCjc38UhZqMbhVByhFSICa7sIDAgIgfvd2\nRk4e0cEmOcImjbxjzwINtlO7AP0DTHU15gRLKdQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY2/d8UqPnmjqEKtcazG3SIKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTYzNjgwNy1mMTQ1LTRmYzMtYTYxYi03YjE2NDNlZWFiYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWfCGdpNv+NtOYeEf+diS14TgnXCzQxS8B7JxeK69cGtVP\nS6s/c0jvNS12bQ9BTFsnYhtym7PNGbQuL/kmS6Lpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd99BlLYKkIXDE2rBPU+4xhwL\nHMwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANuMGIN5cU6hPJze/S3XBrZyQUgxNpXBitWq2BiQ69czAiBTMh3xrr+Y\n/dVSqmODcPaRuqbU/F5sez7rlUsU3tJHQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAWMsFCWCTQz21EgwFBP3V1QFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNhZjM3OWUtOTY5Ni00YmQ5LTlmYWYtNGEyMTFhZTEzNTRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZjMyYTFk\nYy1jNGQxLTRjY2QtOGZmNi01ZmRjNzM2ZjU4ZGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASwzJbXnk/g4QEWDyK8Ov2BRIBkMZDIO+owRT4wlHSDKbvnIehUyTze\nwV9mJIFWOsRrCl1IhKl3iQvrQb2t+h22o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQV59r3\nUHqHuy75x5KVIIfsYB7R3zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAMjMzsuJjOXbpv44Yp0lgykInOpwK8Rv78+Xq5bDQLxT\nAiEAlmdYP1LwyGCjbRQzaDOFg68ezcoj3NDj3VfKw1KCuAI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6360", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6360` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZvfT5atEXmoYMT9Cb3J28QaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1NzhlMjU4LTVmYjItNGIzYi1iODhiLTM3MzI4YzUxNjRiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA0MDdhMjItMzg3\nMC00NTI3LTk2MjEtZjM5ZWYxMjk4M2M2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyrdlDUiyhqrhUrEeURp/XSXHDlwjJYXspf1PbZxeJpoaertOPcmSD26m3sZS\nUbDpm1y+v8qx/J/EEt/zHw+j3qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZTvwa3zEJoBSBBOLsDPfgo9iYpQwHwYDVR0j\nBBgwFoAUxNIGyhCRj9tDuQRAPr/j3TLj+NUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAg8S6RMrNz++eeg5OXPpBfLxJqsQzRxuCcGP5jgyfAK4CIFO1\nGFA/ZvKCiYzfWTfKCsnGd5qob/rySu6bV9AhZACN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATpKgxdbVSsDrFUmlpE7BUzOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTc4ZTI1OC01ZmIyLTRiM2ItYjg4Yi0zNzMyOGM1MTY0YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOWGCLr7eEIquIorIBde2EsVbqryaZqH3FCsclqIJazzeq\nv6qbsdTnVd3CdkmIkX9JOEsIwpaFcLiuvFKaCAB9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxNIGyhCRj9tDuQRAPr/j3TLj\n+NUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIv37NkG6y/QMnDtul1JoGPrBL8yt3trfhX+i4kVNQ6cCIHKarR+grnaQ\nKrE7XNFI+MvNPNog6E2h1fJ/Qebu4N/T\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYXmbde+mCF3/BgIn1ZSWTPlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA0MDdhMjItMzg3MC00NTI3LTk2MjEtZjM5ZWYxMjk4M2M2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMDg1YjM4\nNC0zNjRmLTQ3OTctYWVlZS01MDQ4ZWFlNGEwZWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATSM4cyFUWdBZW4yTLTaA9CjJYofsknrY9VNiYr1GwGZQf98Xm04vOT\npLMbMU3spWwdS4YtjS+Ruy+cXL4SKBUbo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRlO/Br\nfMQmgFIEE4uwM9+Cj2JilDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgdnCB5SLBQeQSaeHBmGURsA2u3uYEy7rayfXQcCypFRMC\nIQDiw3RoW8Y4I7kcIM3rv/vIpfwXx6lXjXWsLmHt/d4vpQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6361", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6361` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARfTj3AmCwOtQocaDx/VynsDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ODE2NTU5LTU2MjAtNDM3MC04ZjlkLWFjOWM5NWM0MTI0MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRkMWMwYWYtZGQ4\nZS00MDY3LThjODQtYzdiNzFjNzVkNjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDheJXKGW5raJvxIfLp1xvSBq8iBwglahVFM18pqWABcgYSjQxHTNp2W72gld\npuYX5Ud695D9oODrcFTAgg81jKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKf8M6YbYcW7ls4XS5oE2l77VCJswHwYDVR0j\nBBgwFoAU56j6ws1ZFD5xT3FRWiYcggl7bZswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBCB0hMrY3qf2hc\nbJEx74KuS7xlcEJjTSXtrOj0hzAAXQIhAP2QTcgmbeSYPQ4awp7kPaDhtkVewDOq\nXoPcwKRcGb88\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZib810sGUm7K/nXM6yaXIfyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDgxNjU1OS01NjIwLTQzNzAtOGY5ZC1hYzljOTVjNDEyNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQrVAxacLY38zbW6okdq4bCPvLVk4FIOTJTL3CuBUT+QeX\nLAHSYM9v2hXdUGaoLJVVyjIovJRoaYkQiEhHiZ/Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU56j6ws1ZFD5xT3FRWiYcggl7\nbZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJYhFd7CnTxPF8eao3nD33MkH3gHa8a5rJVhD3thh9JCAiAx49i6z4yI\nH8Gtag//pxiBXqy5uWmI7hSLmlqoCIcBwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaeTUNvuUqVmK5UcEwrfgJ03MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRkMWMwYWYtZGQ4ZS00MDY3LThjODQtYzdiNzFjNzVkNjljMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NjYzOGE3\nNC1hNWFjLTQ5Y2UtYjEyZS0zOGYyZGRmNTQ2NDIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS27XMITPHdIbTzEZZ98dk7RdjgUosZxFGoXIr7XgkGH/QW3T8YlWjc\nmnTXZPyjgffeHcmGCw/EA9VUX8UUWTn8o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQp/wzp\nhthxbuWzhdLmgTaXvtUImzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgJWCcFNO6XeUT6dVzmQuBhLHwnvbV3Sjj+D5TEGjRWCMC\nIQD8TVSQY9iKPBsQzAFLQN31OIJoOTplUQsJsh/u6/QrSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6362", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6362` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVNmx7HDJZk5IdMB8nJz7VL+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyODJmZjc5LWNjMGItNDBiYS1iMTFjLTYyNDI2ZTBmMzQ1MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQzMjBiYjktMzk2\nNi00OWYzLWJkYjgtMWQ2MzBjYzEwMzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVpQshAUgXFlXzuElNlk9xYNfynt6nzal24UaDs6scPENYnryGHrK+/AByA9o\nRvfnqAAvkGRLzNYdO32mhyYgiaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3TZHFqbbLOExSnfbEYWTEFQjQjEwHwYDVR0j\nBBgwFoAUXTsZO0mICbKBwO/dhAuxOa04LhIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCkJV3APUq9Qc2L44c2IHhLYLy4Otr+l7bsvoYh3ZzyOwIgdSH8KTOBaiHF\nShEDVb8KVWAHhHuAPVnG8BwFUWqqJ1A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdhWNKU8jbKRLLaJWZZHd1SJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjgyZmY3OS1jYzBiLTQwYmEtYjExYy02MjQyNmUwZjM0NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlrZlayRCsifRjXaUFzrJz/OhhxvrABgE6ZsPiuci3ybUy\n6MPl4zPdTQWlOyaCH3eXZfPLA7iPd/qhA3pzXc6bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXTsZO0mICbKBwO/dhAuxOa04\nLhIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALgVD8EIOYCWddun1kzZfFX1vI76MKEdVpeyWg8Zl/7iAiEArXNLjmHW\nL1ZpsHptRKD2yaxdVKyA+K49f5KhkN6keBQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAVlcVyif2BYiBtZOG/1Y3ypIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQzMjBiYjktMzk2Ni00OWYzLWJkYjgtMWQ2MzBjYzEwMzM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NDlmYTZl\nYy01YTcyLTQ5M2QtYjQyZS01NjFlYmRlM2EzMGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARA33XEcF65B5v8Y88RfHU4uHi8Q0ESanRgWGghgskOPZeUtDbifkEX\n96elB+qI1h3uysNaw73mZ9tGSVajvo+Eo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTdNkcW\nptss4TFKd9sRhZMQVCNCMTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgP56Rs6MdutmAjNw0GoL/cEFxX2/ukQGeoJRYAX6ANpoC\nIBghec44xLeTLOtkWhXTg52SspWGYgV08HaIbp8EvqnN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6363", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6363` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQHAvj/vI0aSPwTtpGaVM1UAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0NzY2Mjc4LTAxN2EtNGE5NS04NDA2LTEyOTZmZmI0ZThmMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgyNjdlYmQtZjVm\nNC00OTY3LWI3MTEtN2U1ZmJlOWEyNmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWelba8hXr4GVxuPQQLEnAt15AfRhCLyOezZNTI5DWew6JqmvOAe60VROL57r\n19wPcBHq/ID068wgMWRA41Bt3aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpgRb4Ys/LzvYDtxoSTQ50u0YzbwwHwYDVR0j\nBBgwFoAUQXYzEup8E0mzH6a/tAkRr93+T1IwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHq9ZY0HiKtllcSVrOaWljCEK9NaqeypXFaMY/Ji6O8VAiBx0GrqSzlUPWPr\n3kya3xNwCn9Vb5wdbuw6Kz68GYQRdw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbcUmrsaVOeMOMFWt6v08tEcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDc2NjI3OC0wMTdhLTRhOTUtODQwNi0xMjk2ZmZiNGU4ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlx5N1YdVQ6CmZoruI3gTDbo5o8BOXyOdFdCL9RPioA3GV\nTH1GcZxJaSp//rTEuygxGGCav4yolt1p281X4Wbio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQXYzEup8E0mzH6a/tAkRr93+\nT1IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZPFSmp2Auhl+Or5iL83NHW9HkcXyfbdsur43h/MgJ78CIQD6xLYrb9JN\nyQ/w/dogSwYv22NPIGcloe/bibKSv7VYTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAd3ON0qo7fH58V/IGvLG5vsiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgyNjdlYmQtZjVmNC00OTY3LWI3MTEtN2U1ZmJlOWEyNmQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZjBkMWM0\nYy1hY2VjLTQ3ZjAtOTU2ZS1hY2NkN2E2NDQyNzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQog9DUmOc2WvEm+Te/0iHjBh5B6bvzUUMn052vK4djqZSxlxe60E8s\nsuMvwVlgiRurQbj2b5q3yJXy7GOzMOmko3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmBFvh\niz8vO9gO3GhJNDnS7RjNvDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAI0lcDB8OI8E/EMXF0n4eg+/Souiz7F+jauS7QuKbvRB\nAiEAkwbOC9xvO6lyoGrnSnv1Hc0/EK6yJrAq41Ec6xXqkI0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6364", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6364` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAb41JDeyL4mw8uK0OQRnslxMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzMmE3NGE5LTc5ZWItNDUzNS04OWIxLWVhMTgwY2MwNWE1ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZhZTRhN2EtMTE2\nNy00ODczLWE4N2ItZmY0OWIwNTMxN2I5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeMW7OdVK9PIb3UtqO6ethRTSwVwulcf4sEhCS78P3dIAUJXpowA+tcOeAsME\n3bpVwWq5O2PaPeqT/IxKPYXkiaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpSfkVIdeDeNzLz7c0/4iQpuuwMowHwYDVR0j\nBBgwFoAUCRR+HZg+00z0LV2rhNGEVxkqvHQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAozqCTM95PuuXapLIb4QspfMJdkVK7f0+i2tA6Uh8kuQIgQ7H5cvoq9nJ2\n5LGsdzw2EeAFhUE9yYPcdYoaOBMFI7c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa4KOeGzHv0sJE9QykzwBCq2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzJhNzRhOS03OWViLTQ1MzUtODliMS1lYTE4MGNjMDVhNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpcq4goPvWFULnDpp0P0CKT45rLYRinZs0+eP8Dh0MATQo\nlOBHUhMxJO0HUToFXe3BVeLparYMfn9FiFz5WreZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCRR+HZg+00z0LV2rhNGEVxkq\nvHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeSOimtX8mGLsYYPfZnUb5NV1zBdprSuFO8xLJiJJCRACIQDmPvy44X6X\nJFSO3P6jclks2Dc3roFLL7MW+uLOL7KdDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAciSj+SkH232U8FY+KGcKwjtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZhZTRhN2EtMTE2Ny00ODczLWE4N2ItZmY0OWIwNTMxN2I5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNjE3MGY5\nYy1iNzM3LTRjYzgtODk5My0wNDQyYjM1YWU4MDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATWczgRKriF9JeWQwXZVcORFVTMoBbDxUlCgbUejGl1DqWhe6Kga6e2\nfxMAM+edgBoQ2agDNCpUu+YxDGWXv9SLo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSlJ+RU\nh14N43MvPtzT/iJCm67AyjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAIeaDZGMqJ5aYbRarJGkAXU94sqfwdRcCHtpsjgs2qyC\nAiEAxEUhRFDuByCgFGHLSXgFDIEnSsz9JJrSKG37MS0jBw4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6365", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6365` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXO/rGNYHMR/TKzh7RPMPN18MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3YWU3NWZmLTA4NjgtNGRiNC05MWFiLThjMDBmNTlkYjZlMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkyNDFiOGItMTUw\nZS00NDIwLWE3NWMtY2U4YzYwOTAwYmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2F+/LLXotS0+t290IsYpK86mGZ1lYfB1zsenZ8juRHmB9jvRT+9Ak5y5JQnx\nDcC2dZ3LQ6jkwTnwD1Vz8/6qOKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdZJrtFXvIusRRAsBWQW1CzRM/MwwHwYDVR0j\nBBgwFoAUVXOixzVyrYd7vDlM5z5AmYWiScMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiB/XMHpuFesmZ1f/Lech9URHIozNztTGAvx2MV/xchU\n1gIhANS430YhJTKMLbW+QEL1Gk6LSzUemC6LDXBDGtzkjgsf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQpvGyFzKVXkQMhfAmVGv0SzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2FlNzVmZi0wODY4LTRkYjQtOTFhYi04YzAwZjU5ZGI2ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlS2+D4WJVxhJuthv40nhaGYPG8dsCPoZbI1MQH3GYDuOn\n6uE1vLyJGptxapSet2trUniNLWY7+w5wpnhYs6Zho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVXOixzVyrYd7vDlM5z5AmYWi\nScMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOQeO2VJ92CFOCRcClDPDvqCgb9HSeuBdAifnush6BWjAiBTKSZHhVg2\nLBEW7W39P35eqBnUj4DcSn+lhWcYRNQwdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAcwMAHek6AqePhgpIuKHteM/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkyNDFiOGItMTUwZS00NDIwLWE3NWMtY2U4YzYwOTAwYmU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZDE0MTc1\nOC1jM2M2LTRmNTktYjk4Mi0wMDcwODRhMWJiMDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARuFJXXuMW05B1EbsgH/zYrOUHlhFonOJbgUFFsT2/VyZfrPJwjqTBt\nf4CtptULmvtXxWjPSdUJ1A8vuNeJGnfOo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1kmu0\nVe8i6xFECwFZBbULNEz8zDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAOHTHKcDhyKFJVsNuZhJ5jZSjXlJ6sJgQNLn0RHCi2GT\nAiEArG5wWZexctUr+0qzzvSOhDJ9mFBJ2aiO/o/t0wlmje4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6366", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6366` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAQp/Fpmzws/wIkpo1ALtoqwhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2YjM1YmJiLWZkYzgtNDY0YS1hY2I2LTBiNjU0YjZlNGE1OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBiYzI0YWQtM2Ux\nYy00YTg5LWI4ZDAtMWUzOWVmZTQ4ZjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETz2WHTSXPf0TxRdXUhk3OAlrm5aXTMxdJ6EJxKcuVobcvXg2Xn57u9g8m1z5\nR5WFs4nxQnhAW4KS5xIHqp6RK6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhY5WAZnYAI7tYC9Tssqle4BqpZAwHwYDVR0j\nBBgwFoAU/+P1Jp7r9JrQCOMB7SU730/XUfswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAt+zegoNCfj7vkR1ElQdLNSpqgkr1ENIqDl4KbXsC\nKzUCIQCUt73YzIiICU6BU+dyMYi8h0oMPANQ1/RPS6AogGOOUw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZhnVzxnuMxmVc1LQ1o0YpijMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNmIzNWJiYi1mZGM4LTQ2NGEtYWNiNi0wYjY1NGI2ZTRhNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnGuUsWIMJ0Ua7gwUMCE4OhsAu7qfvku7YL32VPW1aVj99\nlsOO+FZsgownke9s74WSWUoXTCcOTtRwrA4QdvMgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/+P1Jp7r9JrQCOMB7SU730/X\nUfswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbNiwlPtlDL0UGtRSW804v9looKvoJl6YnQV2fq4owBgCIFSX3Uc9m9gy\nhM7dXkqiV++LfVfXqG+/8uWdWm87WXoj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISASo40IXEbU/AyOOc/cmGvWMCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBiYzI0YWQtM2UxYy00YTg5LWI4ZDAtMWUzOWVmZTQ4ZjZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZjFiM2Qz\nNC1jZTUxLTRiNTQtYjMzZS1iNjBjNDUyNjc1NTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATFHiciS6pGkyCGbfQPg6BDj8D6BSo2FMqGFOW4wnLPAAXsZRHq/BvN\nDuRBNVKzYHhcrZA1a9o+gXrmDcbnbpsoo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFjlYB\nmdgAju1gL1OyyqV7gGqlkDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAM0TNYDtdibJgPngSkKbzU/MRTcnvyk2xrdBR2161v5h\nAiEA9JV0yzPxKY4GPZyj3teQlRvRMVZZnNS1eQnReLSjb40=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6367", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6367` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAQP+FPKrXXpZNeExQXP76x2HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViMzA0YzA5LTFmYTktNGY3ZS1iMmY3LWVkNmE1MDZiN2EzMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYxMGE4MDAtYWFh\nNy00NGY1LThkMmUtYWU4MGFiNzMxMzRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESQ3j5xzY8uKfe8E4D7quCz8fRTnSMDDZ+TWSAEl9VX/5kJfOiji9B0OSVRq+\ncAsyN87cCPW7PtHJateicN6Hu6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdJydQwslOSBod48UkbfQ4J2EFVAwHwYDVR0j\nBBgwFoAUm65vtXiv+9S4eRtOoejo6sTpbL4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiA1Zl6OaMXyYFhICPWtoDpeiNRC3lv8RBDi78U46194gAIgJ34t\nizoAbfeiC0yprjQoOu5qN2xFztUDN1EeDVRfYik=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQf0yL1WEAc4zKN1t/fa9GvYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjMwNGMwOS0xZmE5LTRmN2UtYjJmNy1lZDZhNTA2YjdhMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVrvrXAFjsZrA3iyHxRFzp3RJxqRvjEzz+utFLfFPG15M3\n6uDArH/WhG9aTenQvQNAgTzUULKJiZy17GbL2xg4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm65vtXiv+9S4eRtOoejo6sTp\nbL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJFoWRSHl3QKld8nCnFiC6bhCJhpV10yXaGMAewHyAuYAiAw/s9brEXy\nBBoGkxbX3qJW6WGw+HIayXUtz9+P3YRlxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbP2D/ASnoQbAlso5MJjOOGmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYxMGE4MDAtYWFhNy00NGY1LThkMmUtYWU4MGFiNzMxMzRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MTYwMWU2\nYy0yMTEyLTQ2ZTUtOWM4OS0wOGQ3MGE2MGQyM2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATcpD9hHb7jroJI3xum8OAZ8FvPEgopsycxHeBxIZQCRnP1p5qxViq0\nInHng/pmPouz+7W7cIjbBJWE+ytcMJ0+o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0nJ1D\nCyU5IGh3jxSRt9DgnYQVUDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAMaYBi5Yx6g1pv9b9ajoUcZOJHMr+O6XlKTfYg6jHAks\nAiBsk5IRhlxu4RbWcP87FG0wlHIJiG7wQLDrY3nJMbwJ7Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6368", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6368` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAWrWZIttQnHivh9n9y2rqoWiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlZGQ5ZjllLTEyZWYtNDViNC1iMjM5LWUxM2Q3ZWEyZmQ2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDlhYzQ0NGItYTkz\nZC00YzYzLWIwM2MtOGYzMjFjNjJhYjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyPkMB8WurC31EH/4QS4OxukDkIjz2HjNqdkR+xcip39joL5/OQeGrFdf43Hi\nxHjZZZ5zDM7f1b8DgqizDl8aXaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuh3YVbjcfXbiJtdOrk3sikPrN+4wHwYDVR0j\nBBgwFoAUWUiCGGbS4kfuVheDnPjSvNcTvw8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiASoaaXVj8vDehpLoZ/YzLbs31H9suSEwjq\ncct/iW5CPAIhAMaKrIYieoFrfaIwU0d6WDL5n/UcrAJ9OSHlE3x4AK/B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWipvEh6eCThkuK3+tTtoi66MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWRkOWY5ZS0xMmVmLTQ1YjQtYjIzOS1lMTNkN2VhMmZkNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHM/xx7795UvgV9aZ017007nTb6Bu4RyYvDaBMJPxhK+oQ\n9y+hNBd4EviRKdCQUm7gh6mDvxoAX8XbPz3SxFkWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWUiCGGbS4kfuVheDnPjSvNcT\nvw8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUZ0I6gBJwruWjx710rz4G7I9hGEssuEL/mb63gkFMcUCIAq6Z1WhSAlu\nzuZd+0+e0k2WWBXJkYVAR8ex9GM04es6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUq0rdIjDjqNJhHgzacGXWr6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDlhYzQ0NGItYTkzZC00YzYzLWIwM2MtOGYzMjFjNjJhYjQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZGU5ZTll\nYy1lZjA2LTRkMzgtODg1OC1lZTc5NmJjZDc0NTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT0o/VgO8Kkjp/rfjzpVNGTr2fA+rBsqPEV7tOfUPG0tgSxMtZR5Jzi\niS1bQmcwJSWChPNG5TujhPVhQlQwkDLbo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS6HdhV\nuNx9duIm106uTeyKQ+s37jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgMOQ0FR98ymlQlPnswC2mfXrk+hTbEumHRN9icHwkyXsC\nIQCvMiXYUcvW9mWfDOPjg4uPKjC4XcfJXqnPR4GNweSmiw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6369", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6369` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAfqdMVCT1K1gchDqfvJ8XUzLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4Njg0ZmJlLTFiZTAtNDY0YS05OWQzLWJhNjAxNWRkNTcyMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBjNzZjODUtNzMx\nNi00MmNhLTg4ZWUtYjAwYzgxYjAwMzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtUKA0P4KTw15DkN++1sTiiP1rtGJX9D6S8TN66/7EQMKeTTXUbG8mEUkD80h\nEL717vlI/4oMtKJPOp+HbKP3QaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVmODqnrgkGW7mgDjnQhR/63fCRkwHwYDVR0j\nBBgwFoAUHdq4vKaE3+3VR7AnUaRp9ATvjcgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBWAUcbsyWpXAx8ltWhTcQq81g5kXsvXWCP\nan3C3Lj5fQIgXIZbtzohfsqU6cwLm30RVVx3iY4leh1cKzCsWWoUBU8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV/hteJ5NHCNvv+nQ+pLdkk0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODY4NGZiZS0xYmUwLTQ2NGEtOTlkMy1iYTYwMTVkZDU3MjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATi2vsi7rYVXcfCHEY+nkkxpTCjHxgxdUvw1HKZIDSRhdlk\nVxJD+qspzURkyyKmD6tgK+0iwqCpDvhc6jjbGSNUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHdq4vKaE3+3VR7AnUaRp9ATv\njcgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIzpGl3dAZFobCMlCQpC5qQd+SY45DqF8l7NmCrW/2nKAiEAqvfAT2jG\nlIanX3VT6tHHAQCf4nHEyXbtFKTtEB9EnYU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVbZnt8gqfoXXmG8bHwnFfLxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBjNzZjODUtNzMxNi00MmNhLTg4ZWUtYjAwYzgxYjAwMzM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMWViZmQz\nNC0yOTFhLTRiOGQtOTExZC03NThmODk2OTNmMDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARfmf5xm0GclM58iTxWVnVySmzuaqh2wVSb1UhZbO4IP3PXPHlfg6O+\nBiY/8s78+hjCuiaZY5ul9XQdmLv/eZVto3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWY4Oq\neuCQZbuaAOOdCFH/rd8JGTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgbrKKFouGCnCPnXfNltJQCPk3WpEA2ekizDU3CW5KVlsC\nIQDJzCKaKOADZ5QFpBdEmvDZEpdQ2j+q96vHMRHqhZn9fA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6370", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6370` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAZgkl8x/A6XdP9B4Y3w9PXGrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MjgwNGVmLTY1N2QtNGYyNi1hNjhiLTA1MTA2N2NkZWE0OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNlMTU3ZTctNjFi\nYi00Y2Y5LThkMTAtMGJlYWNiYjRiYmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELKPJ65IQq10GR6jJzBlUMZ35tYpslKszhJaIYMM9Nl4X7nGsDjxFBpsANR14\nDgOaFQCTTUXCf8QJ+zn+a8CpqKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcRuSMaxDOPZ6kkFpf+xh4EGZHBgwHwYDVR0j\nBBgwFoAUIMs7e2eYZzzbje6IxOV5oSmnlB0wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAm+7uVH3BbS7Z\nDeWkn5GVohvnPpYAWnu+p+VPgWuLVMUCIQCfqIT09lqmSg8aMLX2M/5RifB1N4GY\nV2o7ew57mFdH2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQeKzp81mxKyM3tkNMKWmhqZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzI4MDRlZi02NTdkLTRmMjYtYTY4Yi0wNTEwNjdjZGVhNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYVxp8VH6ogP8tl5Z3n12qHJhoRX81J3SlL74wyqAdoABw\nKOtz1dJ4biTuRV/BknnmfybNOeNozdFGtoAQnXtwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIMs7e2eYZzzbje6IxOV5oSmn\nlB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVfQS+Vn68QEJasnqOFLc6vBD5H39i176vVLyseS9oNMCIQC7jcJKsfnT\nmWfTNKZyszc9n0Td28+PsYy/DM2uXcMPzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAdpIQr3IG5LLdP02fRcCsVuOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNlMTU3ZTctNjFiYi00Y2Y5LThkMTAtMGJlYWNiYjRiYmQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZmZhNGVm\nOS02NDU2LTRiZDktYmQxZC0zYjI2MTU3ZmExYzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR2Xv7dF7CRHPNXkCcpNMij/uWRZ+FkpVl3ArJIOfWQ7wY7Kd8VNj8f\n3cw0DYF9JSopkrdBBlp68Rod4PUbdOIoo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxG5Ix\nrEM49nqSQWl/7GHgQZkcGDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgdSdnxwH8Ry3uoAwcCCFinXUoYYgSoPZLJD95ybsXB2cC\nIFIO9ch/7hUqkeF+Lfv05JCwHlfPInrfeWtOmHQLmTx1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6371", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6371` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASwl6jUTzRpJwOG8yx3dN9S/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyYzViY2U1LTY1NzMtNDRjNy1iM2ViLWM4MWM2MzcyYzc4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc1MTVjOTktY2Fh\nNy00ZTVmLTllMzktODgzZDg1MDIwYTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHJN44/2ovnWR3hVlGL7Mb/PoFMbN5NECwnBPn2v+8nEw3G4XfUO+Itr+tAm+\nRdLacOMu62RwxVdWMAS6odSyB6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwBwbRSMUeKgfVTrJeTUYWcclEG4wHwYDVR0j\nBBgwFoAUsCUgmZiANGhZD2msywVApDKlMzIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDTUWrCykwE8kLmlkNBqB2p3prCn+ZmYr8bNpYsgQIEtAiAVnQb+gCi3xZk2\nNWJDvJRMDjCL74Nou7nEirz+pe9GXA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQJlHdnQESXf5qrQMBv/OoiIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmM1YmNlNS02NTczLTQ0YzctYjNlYi1jODFjNjM3MmM3OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwWwQZUD9eHp9ODGapYS3rDpUJMFpVtvhtRZbeCClnfBPM\nLDEtT74C4AQd6wu4HoMcAPrUVN8/v6MK9q6u18S9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsCUgmZiANGhZD2msywVApDKl\nMzIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQ6vXnFbgdvcEhQtu0oic/0hQRkREjPmuRqaFEik5rm0CIQCXuQy2NbDF\nPcL5Tz/BXNg/d/eqPgmF7hSvMD6Hup0Z5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAdns4KtfqdOLpYerJSWkhN5vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc1MTVjOTktY2FhNy00ZTVmLTllMzktODgzZDg1MDIwYTY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMWZjYTdj\nYy00YTJlLTRlNjItYTk0Yi0xZmQ1ZTllODVmNmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASn2vSi4pNbhBHJ/1DZdDEZS9kVSByMTuRY53qAj6fEM3kHcYqR6EVa\nzd19ej0z9gwr/yPyink9Zeek4ANDufbJo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAHBtF\nIxR4qB9VOsl5NRhZxyUQbjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAJkIdJsofaM6WKYnnfAvvaXz6Ry47byYLOSYUdRVqARN\nAiEA7dlJ3T9GP/Jh5xCxwmy8bMGCcAkNdWZrhlrwO6IoEVk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6372", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6372` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcCgmQe1I1KdRr4Iw5qW7kCHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZWViZWQ3LWRhOTktNDZjNi1hZWQ0LWFlMzA5ZDAwYWNkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBmNWRjMTktNGI5\nZS00YWMyLWIwMGEtMDkxZWEzNjBkMzBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQMD4B2TELQBORtF31yJTawCR3AW42xbYMnf7TKOZCf4sF64aYSAJsN8k1ySA\nrcBHf7bQJ3TXwbkdV1hbIU9cd6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUArm4ha3sFa6xvwzlGmMHt4WnOgcwHwYDVR0j\nBBgwFoAUtfVtUFqvPTbh9GaDZPN7DqZAyt8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCYjlfD4OkIoTtPI3P7YvHid/1L88sP2IH/AMOOnEGC6QIhAKsntlHCvppE\nbb7BSeq8B9DInNDTm1uTfhrzyT1sIGhB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbMpum42rHisi3OKx0LAKZWLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmVlYmVkNy1kYTk5LTQ2YzYtYWVkNC1hZTMwOWQwMGFjZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8vgShZ+HYGf3UmgT39mmieZGCv4/2pKZI/d5/sJuqjlqu\nSbrcgGL3x/Ycq8kB9EyxMFS6pWljlF8u2BLtVGEVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtfVtUFqvPTbh9GaDZPN7DqZA\nyt8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPi5wQhJyToNyymI2p6CdIP+0RQwQwjzV/jmDnb7AWrFAiAIbIQuwike\nyFOp6nXAIcBCGEQf0UPlbthZGkk2OE8r2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdDo3MlQWK5rGM7zGM8UgG1kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBmNWRjMTktNGI5ZS00YWMyLWIwMGEtMDkxZWEzNjBkMzBkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5OTdlM2Q4\nNC00ODIyLTQ3ZDctOThiNS04Y2IzMmQ5NWVlYjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARraYbyM/zUOb4J4CNhTjXLo+OS6+fcn3DLKi185j+2a1PlAmes5fA+\naimAggK6qREny33YvzTTwH9bLnDBvv1bo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQCubiF\nrewVrrG/DOUaYwe3hac6BzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAM3oDR9ZjoOhOJL4uYBFvQ/7qUZIdcSaR12mqtPecZGA\nAiBV0ezFzq1Agk2ouu2dddXTjuOGar5TIFOax9YH5xiqfw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6373", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6373` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAez137qt/yqsxQmXg/fO6SWHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0MDczMzM4LTc5MzUtNDExYS1hMmNhLTQwMzI2OTVmMTI3YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc2ODAxYzYtOTRm\nOS00MzAyLWFiNTgtZGRkYzc3OTdmNTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESJE+T1kvPIdXk9JeFd9L5hqzd9muObXwI6JURm1oevPBQuXP7iQgQvMjofNs\n29vZqBDau8f9lO2HxMh5b/bpc6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/kMM4kXId5+ijNCx6YqTw7agPP0wHwYDVR0j\nBBgwFoAUCWtUi2zQXeHWXJCHBfSX4iPBFKMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAs0dzo1MFzKe1Fhnml83hzZYtmayUtLCcu0k3nIZ9hG0CIAFlWTVbBqXH\nzfaikcucsCz97UyMT7YlZ5t5iXiI3kb2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbag8OSoVYYonxs4Ak0ebhVHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDA3MzMzOC03OTM1LTQxMWEtYTJjYS00MDMyNjk1ZjEyN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeTrxttYyUDGelgggWHyKzYUm5gx6DiBCobHsf7FOXFs5P\nCktaRuh9ppuNUjGB7EzjEL+rr6cHp8DZucpfHbGNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCWtUi2zQXeHWXJCHBfSX4iPB\nFKMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGnB+71DFkHPRQHjjwU4db3IRR++g1duskD8+bYKsppYCIQDv2WpNqi4y\n5XGoLTFj9IBsQcCVC0UqXFMyT7btFKhIYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAR0KzDBzJjknzUS5Jp9ou+YoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc2ODAxYzYtOTRmOS00MzAyLWFiNTgtZGRkYzc3OTdmNTVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3MDM1NTNj\nNC1lZmI0LTQ0MTEtOTI4My1iZTA2Y2Y4MmI0MDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQOLnQvlK6dDM8rzsPB64+4ABsTqPS5/Ms1ahABZ6UKrM1IElEhMrZz\n49KsuVx+ytWJ1Emhmrs5Q8e34UcfzP7Go3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+Qwzi\nRch3n6KM0LHpipPDtqA8/TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgfz+gRtd+o1nHFwTPaJdE/QYj5/QxbxoszZonF7oDS/gC\nIDUsvzMjlKmpTMi5HSxiFDQLIWVGyaUK13rJeNrmDWky\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6374", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6374` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQAcIsLOWO+UGhMku9ipkimkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2OWE3M2NhLTI3NDMtNDVhNy1hNzljLTdlYWQ4MDZlNjQwNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI2YjJkYWEtNzY2\nYy00MmU0LWIzODgtYTYwNDM5YzVkNjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/mvqaNwW6nHO5EIkV3a1q74hYVqi655HmtdSs1U9OavYtBSom/r39tkcO8Xb\n/6ish3Vf7vo4/bMNvTR7crRbGKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQZmsz+xBdzzxvQhFSbHKgErFPZgwHwYDVR0j\nBBgwFoAUtx3UH+oPfEaUCAmsprCYnmOrmx0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAhi9CJAk1/SMeOAhZjamc8x//oz7JWu8q9HiCDdxI\n9H0CIAku8aPfC3FKoCGMQQCgSNKavOsYPVpUaZF6D3KkhOcQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV2RVI/RDyZjLOMBCwZG3mYiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjlhNzNjYS0yNzQzLTQ1YTctYTc5Yy03ZWFkODA2ZTY0MDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8BfmZzo2BSHqHvY6H4QySHEL6gasb4CGPxCrJegSOQ22T\n8a5sSyl20U8kDUdiNGiHZsLmd7+rlKulDnLrQN+Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtx3UH+oPfEaUCAmsprCYnmOr\nmx0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYRN9Y/rWteEf+vhr1aBTeRkFdv0xRIcrpVpMCDrk7pMCIQCYk4iTr5+v\no9VrwUp1SF8CV7IA8YYwbVo8HOigccFu8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAShzRkCClMk8w6pkrhgGA6CqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI2YjJkYWEtNzY2Yy00MmU0LWIzODgtYTYwNDM5YzVkNjU1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlOWU3YTY2\nNC01YTAxLTRhM2MtYWMxYS05ZDI4ZjE5Mjg0ZGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQCaqRitz6/PX7zq8I5GNdg7aZf5xu9NMadFRUqTMI79WCALW3w9NqU\nocLu5zeXB/116jLSFcBWpzzzFGIbo6h2o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBmazP\n7EF3PPG9CEVJscqASsU9mDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhALYparRE7vUwnxyK1oEr/oJNJqOhYHedKtqO3L0W+nGY\nAiEA5b5vdoGhEcem15Yn0ee9FV5YpS/DHHLadBCRsR4YXqk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6375", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6375` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAfNd+2vRJ3pTAVmQfcqFdbt8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1Mzk0NTA0LTY3YzktNDFiNi1iZGMxLTY0NjdiYmEwYmE1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFmMmYzNmYtOGJm\nYi00N2M0LThkZTUtNmVjZjA5ZDkwYTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6sLPNPgRwM1xkZ7v6jEgGtWOPevQrWBO/hEw0B5HhUDvXwm7u7VoIA/SukTW\nyUfPQxss1RlUD1MRcyFYkSTK8aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS3VkCDs88Er8/CvYNFLFB6tvZ7QwHwYDVR0j\nBBgwFoAUJqUDk6LuXFOQyyl7XNSZlPgogLAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiB0+qSbFRY9D5G+2ey37ShyVJl79/1mLLspV+kxba8w\ncgIgZXZQzPmwqeh7aV0kQchwAFPo16V7PJA7DnMJkKlD4qw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcGrbka7C5HO4katjLqTldkhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTM5NDUwNC02N2M5LTQxYjYtYmRjMS02NDY3YmJhMGJhNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpE9Q/jgvNB+/JN+TsTv6AjXN8SCltNPt+Blh3JD6faB+O\nad6mu2+/Swoj93G//QBR7mKnbI74DlxqdFrtOAJso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJqUDk6LuXFOQyyl7XNSZlPgo\ngLAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSVUol5FHdsKwe16oMunX7QoA8Q1HjETZJL52NproL/8CIQDq8IGdxMH0\nLhexu6Hny9VAq285DLmNhnH5A1H6yP02Vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAcMDy/QGl/LBR4X6LGAejzAGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFmMmYzNmYtOGJmYi00N2M0LThkZTUtNmVjZjA5ZDkwYTFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZWFhZTNi\nZS03NmYzLTQxOTItOTQ2YS1kNTU5N2MyMzUwZTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATBLLkEv3EYzKeFa0d96rDfT8okIr9uMn0Oofjta6Ug7Ls8iyo4sFsi\naWNAwZ81OT53tIobD12LeoXhxoWf6W65o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRLdWQI\nOzzwSvz8K9g0UsUHq29ntDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAPd0hqQ/obkChK+WlNh5z1a+b46oaIXIWVTHgfe2UE/k\nAiBUGB1LKYvvukxHQ/QNjQ2In8TyBkigBRbwcluDu/yGyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6376", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6376` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAb+x1jKinmdIQcEf3MQO4rIKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExNWI3ZTFlLWJlMjItNDhhZC05OGZhLWJlZGI0M2Q4MmM1NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFjMjU2NmMtZWI0\nNS00ZDM0LTg2YWYtOGJjNjRkZjg1NDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcb2HkRuFHIYNea73+8GZrZbs+EmAIr4xWZb05ZEtbKomSZK7otsS8gQXl2pe\nZe8V1UeMMibTpT7ZfIMqeJvE+qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBXOd7GvjdbQr2COw+NmSHYGPeqUwHwYDVR0j\nBBgwFoAUHA0wuvbK6O3lgLJSiWkxaUL8JVcwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAoHgbnGDltbT1VK/4AgPW0nKb+RlL7F4XJJfjHa6SGTgIgEMxr\nxJqC+5ReAjl9YVpqx9jQ4oo6WKnqqoXI8PCiGJE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaCL3DAKsFjVhTX9YG4VbTsCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTViN2UxZS1iZTIyLTQ4YWQtOThmYS1iZWRiNDNkODJjNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsRNNdmNM3qJ+wAgjV/MlZ7ZE6xMNRYP9GgjGJi5qV18hS\nhXk3OZ3EPnN1uMzng/bQuNDIp6+EIO4ZodMaoFAzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHA0wuvbK6O3lgLJSiWkxaUL8\nJVcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL5aT8QIhAgHc1+aDoRvpqwNh1k3u8/deOk1jn31W0gkCIDScPMeosJKW\nBloZ1ezAAWNfUrqamvAnHHU2JlHXJ1UI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQJ8SPk9574z416tsv4xv+8AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFjMjU2NmMtZWI0NS00ZDM0LTg2YWYtOGJjNjRkZjg1NDc5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ODhmMjNh\nMS0zMzg1LTQyMjEtYjQyYi04ZTA1ZTI5YzJhMzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQExeACq62IEyZaiHAnPmTpbrTi9kfVtdqNTH5Ee5BbncB8GCWhfMcx\nSsMckzRcjJkXN6dO2EBvrQmIOYxeCLATo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQFc53s\na+N1tCvYI7D42ZIdgY96pTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgYJPQ+vfggbXhBrILXPCYn+aZLcTrA6LIVJ+Z+hqRFs0C\nIQC+tE3wjajucKWU+Vbh9r9MW1dJdfI9mex0F+68qPCZGg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6377", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6377` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAb3FIoRAA0VWvot8WgudmJUsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxY2E3ZmIyLWE4ZmEtNDUzYi05YTAyLWI2OGIyNTk5MTliYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRiZjFhNjctYjQy\nZS00ZjEzLWJiOTYtNmVkOWQ3NzVlYjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyZG9jz5vIhsgXsjOe9dF2n4UL/J1hMEsAcJjvtRLJ8zGcjT4RPJk6ry8pQUI\nykF2gAK5e1XcTBgGkfgkXyHjzqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFw/a7DYb+Syxzx5KXjFYb887DzQwHwYDVR0j\nBBgwFoAUDTlna+7FPAFHTnCL0b9ArGcm5VswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBCzbB6/CdGo8xvGfrUKcAunyVmndeBACG6\nujiCLmYoEgIhAOb7QvIgU0FeP2EXnI4Pa4DanmSo9x5Cq3nWHCv/G/Ab\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdorcM/w6dhm4LCB/QdnX4TvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWNhN2ZiMi1hOGZhLTQ1M2ItOWEwMi1iNjhiMjU5OTE5YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzwGmM6AMbi1p+Pfbz8OqUJRcQcOzrugaV7+ZvVcxJGEga\neSCpIicwOoDlq70kVZfxWhUtOwX1i2fLHQ0jbLPLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDTlna+7FPAFHTnCL0b9ArGcm\n5VswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSLqV+3pTr8gzphff7MDpdY3iiPJkSTxnSP+uJQ9qPZoCID1EieQdT2x4\nyEKSZxMF2gTD+x5LoJ5LZw64HXhsOdqb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfgv3YeKI2PFdsNl0sXfxd5cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRiZjFhNjctYjQyZS00ZjEzLWJiOTYtNmVkOWQ3NzVlYjM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNzNlNjNi\nNS05YjJlLTQ1ZGMtYTVkYS00OWU0NDUxMGRhNzcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASxbmg9gmgaFNx57zdKvj2WmORDWA0p+WUUFEHd862NDKNmz/V8lxZX\nlBKKiZZ8cSSBNXB/GaefIHafovP39MOIo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXD9rs\nNhv5LLHPHkpeMVhvzzsPNDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAMxUkbvFqAWsGm/FVrnIv0vyR0mhDtSJ6GSXpEA91ir5\nAiAqXYbKzC4BWwsfN7a1y2TsYSri2nebepnxqnt1wsVkIw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6378", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6378` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAZrDYfhQ2uX+r8dNFybsjHWqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MDk3NDkzLTE3NWEtNDcyYy1hM2ZmLTY2OWY2OGNhZDJlZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdlM2U4NzctOTBm\nNS00YTMyLTljMDEtZGVhZmQ1MDEzZGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQX7cDfCjjPiu8ed6m+wOYEpc9mcljR8pWssXfeVYxZbLfQUb1KrxiybgAP0o\n8Np8SOKheL9fEcfh2RProLr7nKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhF13fsTSkjubgFQUU5Yz9s8UejowHwYDVR0j\nBBgwFoAUBRDrhiSZiur8g/jcb2A61zTM04owSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAqt+CnDj+ba1RGArI/q8wBzUJAcAdEsxh\ncHJU1UV+TKUCIQDSOqWun2zQExJ+xm5zBLz4j479nubgxZCtXNM0lVfZgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV4CMqRi3xb+mev/P4exnxbUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODA5NzQ5My0xNzVhLTQ3MmMtYTNmZi02NjlmNjhjYWQyZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrnL6QOEIU+eYgai81LcL5S2f+GisS7zokLhOgtrXv0pAl\n3yifXk2SGUJBOLd308SVML1FVcpRHMatk4B2XWx3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBRDrhiSZiur8g/jcb2A61zTM\n04owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOpj0FiIv17nZ+HWB7GAI/4+nIVZ1YPsn//8rOw/BYeLAiAHmR1X0bUL\nFDwL1XeEvD5jpfFf7Ybo0yi3McTDxM8MCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAbX7vToR9Y0RK657gnytaBFJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdlM2U4NzctOTBmNS00YTMyLTljMDEtZGVhZmQ1MDEzZGRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkZTgwNGMx\nNS1kMTQ1LTRjYzQtYjg2OS1hYmQ3ZGI0NDA5OTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR/HqGPN2w/MpuYiPzwC2sPmDCZoUU3YRRGmcX6yHiXYaA+IGcFF6q5\nis3OJBLa+K1jNbC/Y5x9dMN2uNrVvQUao3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSEXXd+\nxNKSO5uAVBRTljP2zxR6OjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAIifxpXR9mmSIYb/F3vHwp92Dln7ZR5+GR/WcHlpi+Yg\nAiEAnAyEzWa/Cwg5ub4w1x5X7nywA41JBwZMDbXibGnkG1c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6379", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6379` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAXGKSNJcEqZYSroddShyhGLhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNzgwYjU3LTI3ODYtNDBhNS1hYWQ3LWU0NjViZjQwNGZlOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY0ZThlMmQtZTAw\nZC00NmM2LTg5Y2MtMDIxODM1YWM0NTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa5GBcUFo2t5NjJ4IGBMMcgcIHTtIA25xsjzgjHw4hbvGL/tfs/iGsy2jAeDs\n2S4r4EkhTvnRCqqYC+Uh8LIFQ6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcyUsYRu1w9Nk3AYQFPT+H1vkrPIwHwYDVR0j\nBBgwFoAUDb6fkv8Mr2CjglxUUobzXb2WfkkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGOGEkTwPlnQBJZ+3v2trfbAWrHb\nnYSKvDHP+q4qiSteAiEAsfXbsFy8gVaLRM9chkBRQFcPidhpV7CJEUkSdvOQWfU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAem7SK5HZDgy2+rdvn9yOUYNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjc4MGI1Ny0yNzg2LTQwYTUtYWFkNy1lNDY1YmY0MDRmZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHkTBEI/t2qMXcHa3yr1ebadicAyLchBWayV05x5eLP7nE\n2I9FEJ6gjwLXI1p81Ik6e/HXCwvZczf6Szc7H3heo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDb6fkv8Mr2CjglxUUobzXb2W\nfkkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPNs5m97fSN/XVf/WMB57aQJKMXHD5O58Nfr85PElhp8AiEA72pHxDZ4\n7dRUNgrpnngsc89hE8qvgpW9YjZApvst1L8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATqgdqpSB/J0MYjMnJTAHL60MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY0ZThlMmQtZTAwZC00NmM2LTg5Y2MtMDIxODM1YWM0NTU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNmRjYTU2\nMi00ZmVmLTRhMzItOGRhMC0xNWIzNzVlMjI4ZTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARAIYZ/Lv9LC1hzhMd+TcKwkZ49zlu5uJx6dhw0ZwRuL/v59FCRuu91\nOMspEsla41BnBXBkuAxRUamGst48Bo6Ko3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzJSxh\nG7XD02TcBhAU9P4fW+Ss8jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAIMt+90JvHN3zaHlxk0Z7YpsIsoknd4+VhihVPizt/ZW\nAiAvciCgd1h1WvfvHmN/NegYg6W1bvv5AiRej3MF5HL+Uw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6380", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6380` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAQHtn2Voy/JKsZpHAhAt3j5LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiYWVmMWZkLTE1ZTEtNGU4MS04NmZiLWQ2Y2E0NDhjMTdhMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRiN2Y1OTQtNWY1\nZC00Zjc5LTkyYmItMTMzYWRjNWU4NmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnimZvwTO5uvlWehAP/Erk93IRzl2/+LlJVPgDTIqwDpGU7yLjpQ8irpBeQgN\nLIEA36oXnOcTVhx0VT5WpYVViqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPk+Qww+xa6ZZ1fXLxdJKLuqFkL8wHwYDVR0j\nBBgwFoAUuFoR1SKyyjqHOBd44VVdls9vhOAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAN+4MeGI\nX2xo0UuJqzzO1KNBpXKO92ZxcaQnSJypVviUAiEA809oMsggvaIIjtRQKqDSKlJB\ngTTKpQSqHozVKjDKfZo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9L8UlcWxLTTx/yFuqrTQ58MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmFlZjFmZC0xNWUxLTRlODEtODZmYi1kNmNhNDQ4YzE3YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy4CG4BMNNvT6+dDtClWM0G+XKdAWX+2YGVzXLgvgIrbRC\naTe/KhBSnTNJT1RSH6y70J9PVQeTH8gSAjjwquEzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuFoR1SKyyjqHOBd44VVdls9v\nhOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDjboBLY8wKVz450fkcfcNfreMih2Rzhy7rp5inLJBZECIQD09Xk5Vm8E\nU8M08uEm0+d6bqLTXsGgWGR/Sil12EXSTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAdTDPujBz616ugPx7xQu7X20MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRiN2Y1OTQtNWY1ZC00Zjc5LTkyYmItMTMzYWRjNWU4NmFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjOWRmZDMw\nOC0wZTk5LTQ4ZGYtYTVmZC00MTc1YmExMjAxNWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ6lPQ8bSgW6kisW/KIlqWm9JoqaxNXRUDI1Nil1ijOfwwqytLmElKX\nBzPZ4o6PqmFHYeDfshF/SjB3nqWgL9++o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ+T5DD\nD7FrplnV9cvF0kou6oWQvzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgJwRaIUoEtbwSDUL9jXVV9AP6ZzANlUzK1BJrrJaXN+sC\nIEFkrgtCXTG1JYl4+UpqESC4Fx59fSj+FNZoS9M4N5PP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6381", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6381` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAU698deniRx7eqdAa6bxqX7KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyNWU4MDM2LWViYjMtNDU1Ni05NzBhLTc0NmRjZTNjYmU2NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNiYzgwMTMtY2Ri\nYy00NmIxLWJhNDgtYzZkZDVlMGI2ZjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW3s+Pr+Ktf2qCeXSNHazfiG98GqP9UTxVmoZMzLyaJa0nUup+lnAJIwVOfQc\nOhfQLpIGts0pGy8Axg+EgsKfmaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Fgt4yDXjjPdk06wkKYLFWuZ9mUwHwYDVR0j\nBBgwFoAUgUprF1L3OfGBUrjKkjsbr4Bjo5QwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgH7TfSz2Q\nTX+u2P9FdH+BDwH6ZMUdIxdOZ0RwQbIjdbsCIQCWJ0D20FuZceC9K2tcC9w0iAxK\naNpYt0Ya0rwDqwDuAA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe/1tc3GEhJ8MD9NJRRQnHMrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjVlODAzNi1lYmIzLTQ1NTYtOTcwYS03NDZkY2UzY2JlNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATy+Ho4xNP67dgX3E8DC+Rmfw2/ir4RNB5ITio39WoLk15J\nh+89w/X5lU3V//RTplHePAaOE9+HqN+pycb9aUrWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgUprF1L3OfGBUrjKkjsbr4Bj\no5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMFrN/jiGfUWzgRje7n9aA0hH5P7gZPELslNu5/94GmXAiBzEWGBiyhT\nUl1inHXhybsSKPpULpKHJQ69GIwyLuKmAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAbuEYq5NJtSK8wpCJhWaou1BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNiYzgwMTMtY2RiYy00NmIxLWJhNDgtYzZkZDVlMGI2ZjI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYmY0ZTA3\nZC1kZWRiLTQ4MWQtOTdhMi1jYzMxNmE4YWVlOGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASjyyMmNWdXhbsrvioV3LugvjiNX9O21Ilsp1xuDvM0jLYnu65/xDAG\nt/pPikctnE28vlcRj63C7vJc9WCpXRSZo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYWC3j\nINeOM92TTrCQpgsVa5n2ZTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgIpuTsKbBwBlKCrfRzGhoFGf5GU8IwlIPhGAd4PnYX+oC\nIDMvmCR3ARHxLfKaambFLLH0fAxhQTUKPOF5VFVQFUj4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6382", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6382` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISARyZbn8CQtPz93yD+7bg016RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiNjJhNDYzLThjMDYtNDdkYi1iNmFiLTFiZjU4MDY3Zjc3NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I3ZWYwMjQtODZk\nZC00OWYwLWFmOWItYjNkMTM1ZTlmNzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPrfyMDjJ5k7wZgvx4WZIlJZvrU05RCzvzL24urbMpFX0lSny+31yITcwywpT\nW5Cv74iTHzVdhnL4qMLMT/0L0aOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPoOpTS1ImjS158QhsWdne5bQNcwwHwYDVR0j\nBBgwFoAU6cBqzUtMqR/MkQpWys9fwuJpOzUwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHdT1mLl\nVhV1YAn5S9DvZGmR3uHp6UpJr5oogaOmYFZqAiEAnsIBKXvBL+rZrYFrQKxlhWBN\nXYvh/eZrScuCOzGnNbk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ8idukW27tACeCBviIyVELBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjYyYTQ2My04YzA2LTQ3ZGItYjZhYi0xYmY1ODA2N2Y3NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxpNMcEK0uCU3Ns90E5hg9cF9dZU3Kghy6bOeOYTfM6HlP\nrWwymmARuEJJPnD38tHD1bhasOTL3p0xYxqFMyrOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6cBqzUtMqR/MkQpWys9fwuJp\nOzUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZdZY98LTsh1c+sZy0TWZSAvZUKSmogMGXMJwc4oV0JICIQCqoP7kF+zG\nAg0Vgs9izGt+gIvtdBJ0rKe5yxc2MGWqDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQ7ynzwZ6XzoDVXlkVO+LF87MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I3ZWYwMjQtODZkZC00OWYwLWFmOWItYjNkMTM1ZTlmNzI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwN2QyZmY2\nMC1jMmUxLTQ2MTYtOTJjOS1kYjAzNmVhNGFlYmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATB772bEF1put5NHBSVykZIS8biCPDl8Vpmahn/iY0sx+giY2DUnHN9\nh+u66SkctpkGvUZ5oFfDCkTFSAX2MkqRo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ+g6lN\nLUiaNLXnxCGxZ2d7ltA1zDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAMD9cMqnkzMI34ICK9fITuN/0PDCuUJ1nDrlqCgArVYD\nAiBn7ztpAKvzo4I+SGAmkfTJLduZLc1LArLFcKH9uC5qCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6383", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6383` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAflX8gFTYASC2MyD+d5Rk7EqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwODJlMGNjLThiZjEtNGJkNi05OTlmLWQ3M2VlMzJlMzg3NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU3ZDVlYWUtYjdi\nNC00NTQxLWJiYzktYWQyYWE0NzM5NmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGA5NPk3WaDIbkiMa8XmMDk83c71v/voXU/+vzv0Tr7twsh9tlf+6PW/22AEO\n+e80jdex3Kqvw6CpLDOLDZEECaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9t/v8B+wcx/LvXszjA7ka9mZ9CUwHwYDVR0j\nBBgwFoAUlRg9b1OO+Pbt4EX6TEvmSZjVneIwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCHrQLHuyKmfCJ3pjrM5wEVOg5aWGlRfzvosfT41c1L4gIhAO1Pqg2S\ntd1U9Vxl0Xinal7Kgi85Yix39ynlHhwMC4tq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU+ZPAQQI/E53i8j3mCAue4hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDgyZTBjYy04YmYxLTRiZDYtOTk5Zi1kNzNlZTMyZTM4NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt5mLav9eBd//qt/A0IWp6quNrhOgtFh0tiwLk3jpsV/E/\nAuDqB0oetVMk+rfzNuM6cOBmZDx+bO7+90JvwHjIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlRg9b1OO+Pbt4EX6TEvmSZjV\nneIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOJgsGBEIjnrIZXoUHoUcKeKbbPSOI/wHFQ+sR/7m9KxAiEAhH1Wl4Gj\nd5LQJqsb55FquOgIs55IpM9QC1yyBRlTlnc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISASyMQ1G9x21/mhrpt8nTonDfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU3ZDVlYWUtYjdiNC00NTQxLWJiYzktYWQyYWE0NzM5NmY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiOTAxYmQ1\nNS0wNDg1LTQzZDktYjg0My1kNzdkZjAyNDkxMDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQzgejmZJdyOtUKY9NG8ax5vvsyCy9C24Zr7AKI41tWeSxwTXLSaAae\ntz6CgaE5wBUStOflbRtQHdbUb1V30Jx2o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT23+/w\nH7BzH8u9ezOMDuRr2Zn0JTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAPPQVyBPaNh0cwckz8BNx2axthKlfdWa9AX5+ostYTI4\nAiEA1eS3pfqzzwQfqpQPzfvbTRsKmuShCfZtr0Ue66xdAb4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6384", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6384` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAe1BvJziDlrP2nrk3M8HX9rmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlOTU4ZjM0LWM3N2UtNDI1ZS04NjIwLWJjYjUxN2Y1YmM3MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhmZmY5MDMtOWRj\nZi00Yjk2LWFkOTYtODRlNTAyZTkzMmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV4V9duMTCoUy3Wwikz3r//JEyg4OULsM5y26u0SdIidkgk2tLBe5Ok0otlyY\nRDmvgtFl6eU2j1Nsqvcd/NIJJ6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUctW6pAMwPlG6qiZTsdUxt3DFXSowHwYDVR0j\nBBgwFoAUy205ep8u+6L3UhZYv372GmMedowwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDs9U24QLOj24wBK6uxCsFBm48j5Ly6Hh7Q2PlyBUSZvwIhANPtEpBl\n9DUwa9bdzXFRK3e4u1n250Qf3TNNMYO+T0Q0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQqmIscXkoaOF+7B5hfXsqHqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTk1OGYzNC1jNzdlLTQyNWUtODYyMC1iY2I1MTdmNWJjNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIpciAa1XTNEWlenmjod56kTb3dfRt+sCK3BaOKZYCVPOJ\nYA8zYLvkxAURr1KwKV/0w3rQtE7bB2vFh/JfkzG5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy205ep8u+6L3UhZYv372GmMe\ndowwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIcVU20Us139MtQCmeJKhfn56SjLbC7kXOnsYHNjPfCLAiEAhc5x7Xrf\nuPBBgiMSPDr56FpbEqh/QWSAWeAMNICBtNQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAWoBAtsf24uSAurV3r8sHAWUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhmZmY5MDMtOWRjZi00Yjk2LWFkOTYtODRlNTAyZTkzMmRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMWRlODcw\nMy1mOTY2LTQxODAtOGJiYi1hODk1OTJhMTM1OWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQTcquMM25enGmAXL+I1/uSrocjFMenc6xTNljxssDMZ0d0Yk2tloiu\nWcicJoNyU7CCy2fTWaIOhgE1LxDJM3g0o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRy1bqk\nAzA+UbqqJlOx1TG3cMVdKjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhANMBwxAAE532EbGb3iga0LkjbUQE3wHpbA5NEc+CQ9Hp\nAiEA6OzZtHcsUbr+Mwn3LeQ3b3ohgbrhwfPQQx339ioVD8Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6385", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6385` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAUVPdq8kM0uka0jPjDxGjEtHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNzQ0NzhiLTcxYTQtNDcwMS1hMmYyLTkzNGQyNmMxZmI3ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODY4NDIwMjMtZjFj\nNy00YmQ4LWJjNGItMTVlNTgyMmY4Nzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6zjKEv6XA3Urwi1q//7niIgV2fkun1ZYYzNUVgJlmZiAaslAln56o1Jeji8y\nTLCewOl+JK1SVxHGzt9FR+0e4aOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTnacU0pVka/N62/Lp1SqDYrfcOcwHwYDVR0j\nBBgwFoAUuQ8UgsYMvDngOBf8jKgHAZxfpUYwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIAoc/YKFrKUWW4YcryCUJ+X1Cie03PndjT1dDoulJohSAiEA2ror1ykjITVCJr47\nD9eKq+/NbAYTG5aibdFSWij1q7k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATl3jlIxI+92yK9Cdwm2Y70NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjc0NDc4Yi03MWE0LTQ3MDEtYTJmMi05MzRkMjZjMWZiN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8b4iZBTPWx1ozMHpweIEEVFAbqeL5mfgcuI1yFhssxRwm\nQtyQdcbHEWYUySnaRyHBZebO7yh2dPplo9sXiFtBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuQ8UgsYMvDngOBf8jKgHAZxf\npUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcmLnZUyPCH7oyKp3OFq1I6sjzjmA6zgov6NgtpOiVrgCIGctP/2a7mVw\nlUU53/nwP2ckATgUt92xtHAFl7oTwGWd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAbxd5iPL2Z5mbsTgV1AgIG3yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODY4NDIwMjMtZjFjNy00YmQ4LWJjNGItMTVlNTgyMmY4Nzk3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MDI3YzJl\nNi05ZWM1LTRmOTMtODViOS0xYWRmYzQxOTEwNGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQxAmlqy0qfklUopAQkmfPi4n5IZNhGkbIkzxbIGMKg5OfBv6vXaBDc\nejaS7Wvi3KRXpYoSTEzZMXQMnvnNoqaWo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBROdpxT\nSlWRr83rb8unVKoNit9w5zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAJGEBNGXwXJfyDrdmmCUHk5cjOd63yHCrQDOfgqW5FJ7\nAiEAxdpEEsfZYGtrXY0ejPRMbyKa7ib7nbSn5GsDD8Z1QlM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6386", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6386` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcCgLdx0FEYuH3fb+4H6aJ2pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1ZjQ5MzBkLWY5ZTctNGExYy1hYTVlLTRjZjg0YzJhN2Q0YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhiYjY4OWEtMTU2\nNy00NTEwLTkxNDMtYzFmMjE0ZGUxMGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElkFUG5Vf7KAU4MgbBg3M7Aqn18XaVKna9kVIVkeq2rzcEhgOUvijOXiTtTXN\nTgMo7SCFE6w/OPAKib5vjwG+HqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUivPlhW8dR1VfoUey/QOrBb84aDYwHwYDVR0j\nBBgwFoAUbUhSA0tZEa90Ix/2QP/jBV/skwkwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIHZnNOojsx4MH8gKCbWozVBuMF5miQcOeNcB72/R4p25AiEA\nwRruH0mXe9YmdcQoVTna/IbBM7graem0SyV84h++j8g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb2AzZBankDHtDbbD0+JF4p2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWY0OTMwZC1mOWU3LTRhMWMtYWE1ZS00Y2Y4NGMyYTdkNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGge9d49fNvs4GdRPPg136oxq8EepG+Hu1Vq/KHNT4KvkY\n7pVlPaNvZu80bCfoXspRQXkjFhnZXcSZ/d5qt/3bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbUhSA0tZEa90Ix/2QP/jBV/s\nkwkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFY9AHiz/XSHXaEwSXqCDFHZgRNjPtewyGolnxPPc0HACIQDIu+tPMOOo\nfmSuXro8m1RVNTvLLtQzyd9ptCVgEXY8Tg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAcqLa7lKhixSP9Y1rqUQIiJ6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhiYjY4OWEtMTU2Ny00NTEwLTkxNDMtYzFmMjE0ZGUxMGRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMWYwODJi\nMC0zMjBkLTQyMWQtYjA4YS04NzI4NjAyYTI2ZDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATv7AsCupTJ0XWhj0jSCD33Agyf26+6uAvPHAAxcv5R0P8/JnwRwrGi\nRjn/jyoMeFz1zUyuvd42dcd1owbz5k6+o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSK8+WF\nbx1HVV+hR7L9A6sFvzhoNjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgWeQMWiPG66ZXTLhCHeXQJifhymfg0IPlPcsEUsi0y8AC\nIA12R/ql1g/vI086U5FShBkKxRTj9v2E9OHUYIJeTiid\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6387", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6387` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISARHRm28pwf/ExZzismRtMNvfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1Y2JhOWQ2LWQ4NjMtNGVkNC1iM2QxLWNiMjk0YjFmY2I2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBmYTVlMGEtOTFh\nOC00N2YxLTljNjEtZjk0MThlMjgxNWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEL/4+VHZxBUAY0YlRoOPy6kLIVX2nvCvqQ6x1796LZzR880PdIHxIwC3vkr2\nHSeirNLqiHfKRUd9WZFYe6Vdi6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcLO1pVAQ3bTwwhiob0CHfDL/tGkwHwYDVR0j\nBBgwFoAUcvdOzQVscSgU7rCMT+asAv309bAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIHbp1Ar1OuZpsO94qJ3IaBK4Lb8uOD7T0zTk2SIOWsYaAiEA\n5GRYwLsH20SpRWgt4OVnJ8Qz4qTPanZrHGtsMO8vHpo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASR/WK5333dS+0SrqLBvDjXhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWNiYTlkNi1kODYzLTRlZDQtYjNkMS1jYjI5NGIxZmNiNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzWBheqJrnuVB7HVxlXl8o1HF+9tbMhSvNLXa32xD7+VE8\njFjGvsNj5QaU8msZyu/KkUc3Lj2BbNsUQ1UddM/eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcvdOzQVscSgU7rCMT+asAv30\n9bAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOiwizXmi/8lDdeZ1lGX3c5JCyMofK7auejw07az1wYEAiEA2TRT4PWN\njume+rBHRxLdsOs79F1fUWqiTOpeU7DuD60=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAbC3a2tbEtZ+6gLR5FVawJ8dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBmYTVlMGEtOTFhOC00N2YxLTljNjEtZjk0MThlMjgxNWMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MjJjYmQx\nMS1lMTdiLTQyZjAtYTkxNi01NGVjODk3ZTg2NzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARiRp9kNLODwTC6NHlcZr0O589aHF7iNTX8Z802dAP3Pv7ufN05M65I\nWDHnNk6nkGGO8RYtInJY5HlSlGmWXQ+Fo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRws7Wl\nUBDdtPDCGKhvQId8Mv+0aTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAIpmb2PtSALwIQ3DzjaHWfpdBmgeZU+pug4YRGHMxr9/\nAiEA3z8oiB+LJf2vkXHRHJgwJSBK4JDeuSyCl05FPAZwADw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6388", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6388` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAc1mqccbcz12njogk8BnnjyDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkNTE2MWYzLTU3NmYtNDkxNi04NTVkLTI3MzAzYjMzYjlhMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI0NDgyM2EtNzUy\nMC00OTk4LWIxNzMtNmQ3MmUwOTc3YmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoTvAN/yXc8W+mXlnF9NabgM1iYbAHqB+uW61+Ns46HDWzgVlor5FkDe6hm4v\nxb9iGOf5rDVbJBoVLgF87eKpbqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw2Zv0dpF54DuzKl3VpTxwDl4e5MwHwYDVR0j\nBBgwFoAUUYuBWYKc8/838UQECU73p4pmIw0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEQpDhDXeLjN\n48Oqu6VYbIh8CdS60BwSJqtHdgk+NK25AiEA9758jRK0KVDrWAXRHEnv9gEEtnsM\nXp+BsDla5b6eJeI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfRpbSEN6s4B/oJXiJmESfIHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDUxNjFmMy01NzZmLTQ5MTYtODU1ZC0yNzMwM2IzM2I5YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjPr6Vsy0Z3xVEbkqd11Jkd+6IGyE5+vg7/MDEPD5DwFsR\nAMIb7SD8Gp6x/2A8epDBcnvtqtQqbRxuTUnU1ri/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUYuBWYKc8/838UQECU73p4pm\nIw0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX8Nv5GR3jgMGzUCmUnjEaMnR6LYPbXfHPmPF19l7+/wCIQCH/7ecYpdB\nycSuYU+DRwEKrf18LpNloOfRl2/8fFDohg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAVAZ2llihApOA4pTwE0K0eVFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI0NDgyM2EtNzUyMC00OTk4LWIxNzMtNmQ3MmUwOTc3YmI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NTk2N2E5\nMi05NTI3LTRmMjItYjBmMC1hZTZmZmI5MGI3ZDMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASacUIqFwD4IJhjT3jto0HEDHeJ5yRiirWqJvZ86VLmpVSk1vQdEy6T\nvf56FmtbVnofcRDOxu5dC/JPhqS0HFMNo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDZm/R\n2kXngO7MqXdWlPHAOXh7kzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhALA4JKpHNHh3OMhsQQkP12Y0OinVkGPYhjVjqdHwYi47\nAiEAp89mFze6F29mhvDwl7vloD/BUTa3gJxd3fp0Nqk3HQA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6389", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6389` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAQCjzffBvtsh57Iy3Ww9hHITMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MzYzNjJhLWQ3MjQtNGFlNS05YWJhLTdlYzY0ZmJkYTMxOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM1Y2U5YTItMWMw\nYS00MjY3LThkZDUtMjIzYmQ2ZGIxZGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcghYmTsFiB4aZsNxsUFVlrZnKr9leV3elna/psT3JzjL/Jgdma0Pc/26/H+l\nvfVCD57qkIxH2Zkvg2PWx9zXD6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDB6Z7K9E4VPoL4fGtqXTnG30VF8wHwYDVR0j\nBBgwFoAUosIMY3QSpR2+QwNqH7vE5o6cjikwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgCwfr6l1Rne5tWQWS4aPVryeqsdhwVPEpnXFJLk7ntD4CIG/8Ve923woi\nZGMnKx7qxxJmfZXzF7H+K+XOhNQQ0+ss\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbCiizTOBkGzUiPU3dW5NyrEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODM2MzYyYS1kNzI0LTRhZTUtOWFiYS03ZWM2NGZiZGEzMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrR6AWlBfiEdsaRwbZXfW+fC8Xv6IatarVVGLUqiXTqEtu\nN3NVcoxAJ9TZ2B5W68GiGq4hY6VzXsHQpgy4aTnio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUosIMY3QSpR2+QwNqH7vE5o6c\njikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOEl9jF9QKfXCNdNn5iq/ydddlrX/0QzTTYkB2mw1v/+AiEAigX5YZRK\ntr9SsKngDcaEY7VDSCOk4pKf9JzOZ0CydQk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZbblcKQdURfReKbdrkphdzJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM1Y2U5YTItMWMwYS00MjY3LThkZDUtMjIzYmQ2ZGIxZGYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZTNmOGRl\nMy1iNGM2LTRmMjktOTU2OC1iZTRiZjUyZDIzNzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASF0MYJ6NSqzHTS6ZoFZ1G76DvxIAaPAqOBYJN6UHAB57KEz3wUa/Ge\nPtNTZz7yYESTJRpVXeZRb2kjvMwUevwYo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQMHpns\nr0ThU+gvh8a2pdOcbfRUXzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAN3f8AYbPlrNyV7VnBIhByb/DPtYUz98vDZRFkIr7vEF\nAiBOTLuski+x+fMlb2TZ8UkVAwE0DBajuAwTBG/HV5upLA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6390", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6390` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAae3bSnJFtivlsQ+2jfZwspQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhZmZmYzg1LTc5OWEtNGI3Yi1hNGFiLThlN2JkMTNkMDg4ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjIwMWQ4Y2YtNDM2\nZi00N2U2LWIzNGEtZDQ4MjVlNzEyZmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyWb2m7pbt+9X75l/zsaXOFtpo20DA45c4CEz1NwDvBSMH2xE+SDSyszRsh8Q\nTCpjKC88iIR0TCHLoU6Xu2KrWKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuBLMpX53l+8e7e6jhR5ePYYtctAwHwYDVR0j\nBBgwFoAUTF9PXgxa8fvX6XqqctGiwgT8ZyswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgRQSD1Oy5EMKFi8v0qgl8FGu23BjE01hoXb8yJGG+w3kCIQDBVgTLAvXi\nzgyhrW5cm6xcBvilVebcpbwj+uKG1ButsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfxlzmqvXrTZoKtA7l8Bi2mRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWZmZmM4NS03OTlhLTRiN2ItYTRhYi04ZTdiZDEzZDA4ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqMzgJqk1jIYjgYwnBkQjKqI7GCkkY7CxUAkVtHI9vBTDW\nDzub5j5+Ww0jGFJJhgbOdTRrDhiMa4ZYWsUAT366o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTF9PXgxa8fvX6XqqctGiwgT8\nZyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL2j6wF8C9+2paYNzukBBPm+R1bDAWw0Yms2FqTT6bdgAiEA1iPisS81\nZfKKSmBnaxkTtuyM6K+SuZa2GLVB8fOzVrY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATrkgHbz+AVuixjYrqJ6chXbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjIwMWQ4Y2YtNDM2Zi00N2U2LWIzNGEtZDQ4MjVlNzEyZmM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NTcxNWI0\nOS03YzBiLTQwNDUtODQxMi1hYzE1OGMxNjBiYjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARFQHfmfY1xkYIDmcdV0dTq/tupubFlzxHqb/ZpU2I/h+JdcxhK4Ym7\niAJ3d3xjR/htq+ucYPGAEHuIdyntWE+Ho3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS4Esyl\nfneX7x7t7qOFHl49hi1y0DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAIRHCOembfHee6+tsSFmGpuL1WdqA+7qWTpgNrnCRwX2\nAiBrXH4Yn16cn8ivA+kWmoDebZR+BtM01HwDP4v+DuhOfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6391", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6391` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAWPaerGObTcZzfE6O8yDbmtOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1ODM3MDIyLTRkYjYtNDU2YS04Mzc5LWE5ODk3N2NiYjUxNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ1MDkyODctMzJl\nMy00OGI5LThjMzUtOGNlNGQyMDg4ZGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERxA3oRXsFyORdieicPKvkergOxmzQJwp64HD1vydO3sXjr2p79CbrfeMwyRk\nLx7XOAsh9KOBNWawEoHheYW566OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAGV/pbquSHqDXMgj/XF1YWqrKW0wHwYDVR0j\nBBgwFoAU1srtT8G3Am/rH8I4GWx7dSO2+80wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBCMHtge0FbFVmT657CS1Ias1fnjkCki3TThryamuu7YAiBVyDQUAV69\nU+2nh19XFKASZAbGUX6LLXeso3/2wKCP2A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS+vNPiyNioyZnLu8aC+pYnLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTgzNzAyMi00ZGI2LTQ1NmEtODM3OS1hOTg5NzdjYmI1MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQpydCEgPIEC/YL0f7wpspFNQ6s92JYK7YwGi8kfCUWlam\nhBzZZNmaDXgyMGK6yfX4Xmq3mViXVo1Lw5d+4iTzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1srtT8G3Am/rH8I4GWx7dSO2\n+80wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKg41nXa86N0ntuLfY5sCex2cdGmszwfxRcgS5uZZExwAiEA2UglXyEK\nWmo0rUj9O2ltLVo0dflfZ6DVnEuqfhCekv0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAdWsnDZMHk2SuS+ScFIBMGCRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ1MDkyODctMzJlMy00OGI5LThjMzUtOGNlNGQyMDg4ZGM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNzk5YjE5\nNi0xOTRiLTQyN2EtOTJiNC1lYzk4YTk0ZDQ5MWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATetXbFGQZMP2KgMe62w7+KZrxiUcqSB63+U/HMaWa9DVaUI8gslpy+\n3iBxcuLfdNHfmQX7DE3b4rXQ0gI9yb+Ro3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAZX+l\nuq5IeoNcyCP9cXVhaqspbTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgHXzUKUUJo6JMtV6kL3d64wBH+2xqHfxjdNPDi8r8dlwC\nIDXBloPNuKbzzPkRg3yfCEV8CGoQMieTg+Dj/8eDR8lA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6392", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6392` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAZD4MA2fjE5DQ/Kq4du5EG2uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5M2EyNDg4LTA0NDctNGMyYS04MGY4LWJhMDczZGI5ODlmODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNmZmFmMTUtNzhj\nNi00MTRlLTlhN2QtNzcyODBlNmVlODU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtRSVuLmEQsKQRqhrLjsYP82x/Qtw7rA1ZnpkZBaA91GB937vPc08ynzhiryx\nueF89SY8LcgmpWXdIHtw3bgg5qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1xlUdvzzgVa2aKiR/7bfGkiO2DkwHwYDVR0j\nBBgwFoAUrzEVLCN0PCGTaH88KRHlzcClTNYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC/a0u0mq6jO4y7lQDleVpMwnl+KRtVXULotmHa\nV0uzbgIhAMsCyoF1YYoEuXb+eWJZfO4pCK/MZOrf1h3banIT3bgz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY4GDjFo78D058daGs/yjYRWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTNhMjQ4OC0wNDQ3LTRjMmEtODBmOC1iYTA3M2RiOTg5ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV6kn/gc1D0tqx9rsyWEjuZPE3kA2s4SveZb5q7tuuToGd\n/5ESEjRewd4E3EnDTs4tvf949dVGv3QXNxQ0n86oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrzEVLCN0PCGTaH88KRHlzcCl\nTNYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMdGEOWOEeV75ddaZsaEq1bX56+Hjaf9VpTnbmcvO2XHAiEAvhthcxrG\n22cel23uW5R7nmO+RN2GAYPsrYUMxj0Kioo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAVwVkyZmffV5vq3pyv+9WuHzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNmZmFmMTUtNzhjNi00MTRlLTlhN2QtNzcyODBlNmVlODU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ZWQ2OGNk\nOS02Y2E0LTQwMGEtOWU1NC1jYjQ2NTY3Mzg2MjYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATFuUWLDDYuLUPyg3wXwazUcfTKHAL4WMJJ2A0yFUN0lO78HSdV9S2V\naR3pgUZVnyidxdVdd9mdauKs//oJxxKOo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXGVR2\n/POBVrZoqJH/tt8aSI7YOTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgYikObIrXJOdu+11PBDoDhbgWrli8WdACJQES3QhEp9AC\nIG3uwoMdwmZbeFPWK7Y22gSVus0XrYM0nBE/x9Kr2qjp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6393", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6393` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVyC/Wx3p5b6Ez5x7/kQK8U2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmOGU2ZTZmLWU1NGUtNDA4Mi05MDhkLWNlNTI3ODkwN2ZjOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIxYjkxMWQtZjI2\nNi00N2UzLWFhYTMtMzU2MDQ2OGVkNzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx3xF6ipZEVJj2fumtw1CwxnFbGnz804EP3l7i933OdApjDYH+3qpBRcdkDTy\nDT9PYKwa/cUhv1J+/KcRwkNmG6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvnCoNxLWC+N/4nP1owpoj3QoggYwHwYDVR0j\nBBgwFoAUrsNb/POsOiWVZ2xxE6iZCy+cLbIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDTzmlh7ZyjYZRJnVDp8NO1ctSm+LfkTubDGix61\ndErSAiEAjkB7a/p8TxTYAyn3xNwYH7rsp3K67FpXN3HW2LpARoE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVkUNO0o0IzqGSvSd8hoRWdhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjhlNmU2Zi1lNTRlLTQwODItOTA4ZC1jZTUyNzg5MDdmYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXLVpHQnsxDdDh2xoLdL9atz7VCMhYMjOiKPR8yQgD35HT\nI+IikuwxstrLgUUrZ2+OTQvVSDzdgfR6clHG0ze2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrsNb/POsOiWVZ2xxE6iZCy+c\nLbIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANLFuOgE9tGLoyGZGZmjhIEPiLKkvahj668kRcMVTQHdAiEA8egNbpTp\ne4n0JqizjOOsIYcSK/NIR8YmcekxerBncug=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAX9R3F4MRAZEpunkH4mgXjYWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIxYjkxMWQtZjI2Ni00N2UzLWFhYTMtMzU2MDQ2OGVkNzQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkODc5ZTkw\nZC1iOTg5LTQ4MGYtYTZkZC1kY2JmNDY5MmMzZDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQqOSam/wuWUOUcN8uhHBPxZ375xUNwqJ5nS7E5eIeNwrYE2xTD3nUF\n6G/f+cVvzXSozWM6I5HCTopGYOEkcJWTo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+cKg3\nEtYL43/ic/WjCmiPdCiCBjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgUQq0D8r3/QVVxgaQDVWEYFZv9kUmYky2GDb0rbsQxX0C\nIBMsV8+0v7xDITbZeGd1tK90Psmk60XAQw/q0WFkm26a\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6394", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6394` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAaDyYg2eSKRWNXsmvFkH/gOfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4ZmU1MTMxLWYzZjEtNGVhZC05ODYyLWIyYmZjYmEyYWVlNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFiNjk5NTAtZGY0\nMC00MmU1LWEyYjAtYjFjNTQyMzJjZmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6uwUJaF7HiDeIWnOs41pxQ90uiYx1q7UmnS5wL5fa+21wt2tTHymyXN88fek\npY0A0Mq6DQU24Uj7nybEimk38aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY6UUV9mFHtbUT4IwwTtMjnkBosgwHwYDVR0j\nBBgwFoAU8kFSIGnO901xngm4Si7MuN0bDcIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCICKX63zP6a4ssm4bY7IDfI0YNPXrzZVeG3vdm/1/fAIhAiEA\nv3cM0QWpqVyNPCTCVp6q8SERRcnxYX2Hr1IeJxp4aHQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZnzrw4C4l0eeRAJKkB63SaLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGZlNTEzMS1mM2YxLTRlYWQtOTg2Mi1iMmJmY2JhMmFlZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfugpPvDTPab0Z5SPLw1fnwBiZNJZn7JQlvNFt9jEKc8Qa\nDhjsZPCMnvUpAQ9tkPFi0pRq7L3KYEa59gRN7Ruco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8kFSIGnO901xngm4Si7MuN0b\nDcIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJJ5TkDesbRWX7P4b7Z86vMj45Thm7K9MZtW3KsWQKJgCICnqrf4H+GXb\n37Z/vUw3Z6Cd9PTMTMfEfDosOeiHtpFX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAQG//uT03IuS60tAOFnNLGC2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFiNjk5NTAtZGY0MC00MmU1LWEyYjAtYjFjNTQyMzJjZmFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwZjJmNTVi\nMS03N2RiLTQxYTItYTAxYi1lMTU1MWMxNjhmZGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATLqf+ZE6FvRYcZOqx/ukHMyLyREMxzK1J3y86tycNH5CXxeEPjsaDt\n+55Qdcn3rwYcE6Bw4fe6iTCL+KeitQMVo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRjpRRX\n2YUe1tRPgjDBO0yOeQGiyDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgGpXT1ZNcJuLDhRKI2MjR9GMpPt4V3xXdOQ7nBAo84Z8C\nIBGIh2bv8+oNME4s7CHDQZgR6tzoomHMQ3/jk+LMyC6I\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6395", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6395` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbbqxuPRQy3daxg1eny/M4HgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyNzM1NmVhLTQ5ZTktNGExMi1hNTJlLWFjOWM2ZTUxMjcxOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThiZjIzNjktMzg1\nMC00ZGEyLTlkNWEtYjVjMmUxZjRkMzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmqDsV+vMyGOUUBnsX2ZvEci6xtVJPU5UG1CaHKeWDeAD2j79zG9hxSGieFKO\nY2Kd5kip2idQJZsGqXjhG7GwDqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSYnXlxYPMmpkR9hHAZev8LPLMsAwHwYDVR0j\nBBgwFoAU55u40vx3KOkmLl/kU5ZKHd/qcpAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDuwcJq+T8itoLO4dFbFj/ytKrF9Iwt\nKQHd13dxltpnqwIgTOcMiI8DyoR6yjvESHz+/EZi0vkKtgHv5JwbGKCda40=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfcYU/WVcp7CQVS12Te5mPzyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjczNTZlYS00OWU5LTRhMTItYTUyZS1hYzljNmU1MTI3MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQK+4lKAatiMHxRv3y9SZ+C1BlIGgdd/xMBXXpL1AwthjsP\n8hwo/m8k3RME3oSamCkc2YYz03u2D4yVKJIEs7tKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU55u40vx3KOkmLl/kU5ZKHd/q\ncpAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJOwvACGRp56Bx5rFX4mIvhHLurrxRSVFgfpzeZUVmNuAiBAipSy27ck\nfNf/w1xvj8KzbIIcstwQXDKs3ZjTxNLd2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAeflo1COCjSFvNZXK5d8BGiVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThiZjIzNjktMzg1MC00ZGEyLTlkNWEtYjVjMmUxZjRkMzVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ZTRlOTJh\nNC01NmEwLTRjMjQtYjdkNy1kMTJkMzIyODk2ZDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT9/6AoCQBEcol9ho8auXnEcbchAHWud/vKu0Y7mJa36TxMndg8jW45\n/QZW/5XkyvDIP4uWPuyN4jTm0LNHMpvBo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJideX\nFg8yamRH2EcBl6/ws8sywDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgNxRDVZZVWqFSiuzZ1X35/CCuZ91s6OEM2PzC13M4qZMC\nIQDGaTdmUXhN5LcLZTMPaOOWMgFpenO2hmdVaV0hN+TFDw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6396", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6396` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAcL0cUChZbVwcaS3Av9AhwO8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyMGMxMDgzLThjYTMtNDE5Ni05NjMzLWNjYzcxNzllZGYyNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA2ZTFhY2QtNDRi\nOC00Y2NlLTkzMDUtNjg1ODU4YmM5NDk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQhpIesyPYKaZKSv06diISAF3hbWhscdNHtu+Y284Y4csOYv5F3T15ldYxg3k\nw7rKG43M+RrkOOuL/pLvAWcZ8qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCmYO3+hYmvEPg+3bq8u6vq1vkTYwHwYDVR0j\nBBgwFoAU2mjGBoGBxp8E7P0/eXv1VBZUEHQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDhYTNwPobvJiE/F2qcrsWqIXCY94DV\n7Ll5de0qyakh0QIhAM7ONSjNxYEmNtfWOghcTkGc8SVMjXCavF7dPsATNNS8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAREXSpKTqp/fAfw9fnTPet5aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjBjMTA4My04Y2EzLTQxOTYtOTYzMy1jY2M3MTc5ZWRmMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWoG0NT964FVXzRc3aJFc4V6GF9IROKUjfkeqGC70dugmJ\nPIZnLZwLnoGUtUGszAGrjWwfRyfIz3zqv62l621Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2mjGBoGBxp8E7P0/eXv1VBZU\nEHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALBsuSKzs27i5m/amXVGEcoz7OwwfNS9AxAXOAbilplMAiBCqZH3bFhO\nZxNi/eRkAB8ihGHIiw9YigokexOorxYYdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaDtdqNSBMrKpMr+HpysOP/kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA2ZTFhY2QtNDRiOC00Y2NlLTkzMDUtNjg1ODU4YmM5NDk2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNDc0MDdi\nNC1kZmU5LTQ4YzAtYWE2ZC0yZDBlYTJkNDBlNjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQGuAA/O08S62a3Wh+vtzSTRejCwqvbM/q/O6bnufnBk2vNYjsqfCQ+\nRM+9kfFG0ZfsAvLXQiSWBUI83eZkBrC7o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQKZg7f\n6Fia8Q+D7dury7q+rW+RNjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgRDlDCjcJodQPfRb6F/VnAIaEGus7EBTh5xWEeW9taIIC\nIQC3zywOlp+XU1st810bqdasxg/sxqA0v94jHuQ7Rl4Igg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6397", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6397` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAdnGmfhq0368Vq7UshoKIX32MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZDUxODIxLWQ2MTQtNDlkMy1hZDllLWI3MzllMjhmYzQ3MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IxNzQzNDUtMjkx\nZC00MThlLWFjMTktNTVjZTliMjcyOWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdiZHvU85vCx7v+O+l3rjNqVKjp+RcRmEUKOjyGk+A6/8wOYQqSHU1RVkbIRo\nQplIeG1lo3TFySdM7xNIVMQoAKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvOguI2Ne6ICDib++KOcQwZHObSUwHwYDVR0j\nBBgwFoAUG8h35oBRiw0WszrqwIT76DwReGEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCv2fISBk7I\nDnvzken0ksywvWN+zBDH6wxuynpxiThw1wIhAOPqPmaT1AQEGFkN/S85niFTuRfx\nJVyELXdWXXbtBq8e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd1FLtqiaomz630AqQ3mF6FVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWQ1MTgyMS1kNjE0LTQ5ZDMtYWQ5ZS1iNzM5ZTI4ZmM0NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQarMNmskVQEjUKRMZnJx/Gg4+/gztl+RzDQScytHaHcr+s\n9AuovH+H8BKC6qd1sE2esMhnD0incMQ3IwL3lumeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG8h35oBRiw0WszrqwIT76DwR\neGEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXTAv8AcH++8ZZz7pBJVrloyNFQywtMDu9JG/MsPDRIYCIAixawzfjY/T\nDXlmNYkNk4ZU3iC58jaI2pP/7CP1AJOf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAXjtJ29nbNADO8W4EC+C2Cq3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IxNzQzNDUtMjkxZC00MThlLWFjMTktNTVjZTliMjcyOWFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmODM0ZTg2\nNi1kYzk2LTQ2MDAtYmUzMy04ZDQ5NzY1MGY0YjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR8jkgcEUvG2LQBeFC5oVsqK+hMShr7p/sYgss9ZYGRLLN/syp/v1yW\narWLox6UbUwK+gotegnzv/g0NWROHT3po3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS86C4j\nY17ogIOJv74o5xDBkc5tJTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDRwAwRAIgVU9/bLCJbDL9ffyQPnsFFFo3rOAWN8o9JpE7nSrvTo0C\nIHTgvB4sipzJK4fdMjTP6hoWYwch+eKgI+XNm1Y8D6zz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6398", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6398` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAcC1xdhz3egMe91qeULArhozMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5MDkyNzljLThmZTUtNDFmYS1iMDg2LWQ5Y2M0MTY1ZmJmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYxYzRjNDQtN2Yx\nNy00ZDEzLTg4ZjItZTM5MjVkZGFlZjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXh9G27YAx7T7Hfu4h8km0p6lHNZVoKFj53iFjiEQFyA/P6EO0SHLCEaSS+1L\netH8tZoeC56hdc3GitVOSNk8IaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/3qujf1XWe1nQKOrpP6MbA128towHwYDVR0j\nBBgwFoAUB9476jsgzW24ihRzXPoSvsUBIm4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgKQ2NiEl+eOUPqZAURt/2vmaLcnZQpThI5tx0ovfuqf4CIHu2sUWJHysX\nciFKiTqToIJHO2R61H33F+JtrIbsBmzD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfScAGXM967w7JLHIa1vBwDRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTA5Mjc5Yy04ZmU1LTQxZmEtYjA4Ni1kOWNjNDE2NWZiZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzl+Wbuycm5K7GWeFnryFOluCNaGs5+h6wxZTckkWV4WCB\nvcNQp9o46KRCD2o583ic70vPwyfrQBjwTqnIWf9uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB9476jsgzW24ihRzXPoSvsUB\nIm4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOpgjs74+SU4dbZaObHFyHsLGz3uQIoV1mir404rHm+xAiEA8vPDTN5a\nB2TMex07g4mIbTYCBcvrJXQbcEa9dFxkYFg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXXnDYTwsjo5U5O37/QrS6/UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYxYzRjNDQtN2YxNy00ZDEzLTg4ZjItZTM5MjVkZGFlZjk1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YjAwNDMx\nMS1jMjhlLTQ2Y2EtYmNkNi0xYjI4MDc4NGYwMzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASPtFTcGJ9hBHns3XGVTfrals1IDkh0zvegZCtdxFVJ3qJy7n9vgF+E\nVta2h+HLXhaejx5cgzWP8gL5wEtwhxfso3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT/eq6N\n/VdZ7WdAo6uk/oxsDXby2jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgBbtc6DNZ8XaOX1wGZ70uyB2m3CZCjzD2n+26gDH3ubUC\nIQDmeUgCNA5pACEGwKjwnHvPoCaZcnZNnvrX3EMkowogvg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6399", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6399` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAZd1DQ264zqKBYNoSroOcj9UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlZWMyYTI5LWMyZmMtNDM4Ny04MGFkLWE4Y2VjMDM5NDQ5MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU3Y2ViNzUtYjBi\nZC00ZjVkLTlhOGItMThhNzI0YzQxMTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECpPQhZGYa37w0F2/CRmglxYGA9bP7B94E1o4ZlcatfBid7kCQI1/I48KK6HZ\niQVjIPFrLY40ID6nw7VHYzuJjqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlUhfLxPHH/XXtZUQrE1RavfxJtEwHwYDVR0j\nBBgwFoAUMUqaMOFQQbrsK3gq2LniO/+DiFkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgZ4VsV06dMKTTqukoE9ww46EYAo6KBljfmsznJ6iSr50CIAwU5eqxZ9I1\nRHS5RV2RurzsANHdjk8jQVzVpzfzPw7e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAef1VvNR4IfL0V62LJJWgvLxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWVjMmEyOS1jMmZjLTQzODctODBhZC1hOGNlYzAzOTQ0OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyKg6H6xDyD1fZoSY4AdFIkJL4t0SnnIMpxVzcOr7jqiz+\nODy3POfVO3C0Z4W53dgZ611IEsQ6GdZcuXpg7s8vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMUqaMOFQQbrsK3gq2LniO/+D\niFkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM8QYrOqVNi/ZLkrgzS8tDGiBv5/7fpoFdjY1uAoiXVBAiEA2NKA236y\nvznBLXYxAlprsdoAMF5KNfEQvftkBkw0vp8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAdyt5D6x1H+5HhL/bTVTCEAJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU3Y2ViNzUtYjBiZC00ZjVkLTlhOGItMThhNzI0YzQxMTMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNTA0ZmMw\nNy0zYTRhLTQ2YWQtYmE2Ny1kYWJmMTc2MDY0M2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS1YLiLDHiXH44kfpsffPti5DqX1hAeoOXdcStcaznTQUY9x9JdhfPA\niz67ns5uAr9Pr0l+mMP2ejNzX/DMOtCRo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVSF8v\nE8cf9de1lRCsTVFq9/Em0TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhALoUtxRRP7KD5k9tjDZedmuoXaUzmPEEkSvBPEMImqUZ\nAiEA8UX6TKGFcndpdITN0Eg7sd2Fjo50959lITYZ7WNElgs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6400", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6400` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeSArUusHkddS8dezUkCcrUYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjZWRlOWEzLTcxMTYtNDUzNi1hNzFhLTNlYzg1OTNlNTZlZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I2YzNjMWItMjVm\nYi00ZTcxLWI1YWYtNzAwZDQxYzdmNWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDEIOODdwbKQjhUCg/6s2DIUxn0o2e6CSUAe7KQEHp6hx7QhoMb8LVehiKb+2\n+Q9UbLi/zSf/oKV+5cW01tkarKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7HQtu5wTfEOlHHGJZ/m4wIZH1EQwHwYDVR0j\nBBgwFoAUvBM11FXY5rfQ2zCmPAfJimoRBTMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDg2RBsEvmnr1NtUYu24cTdqG5m12OtEa69cgGcAsxQuQIgQ76sQFRs\nscwX3hXMq6KOFzvPYbsw6AB5KV/qtHNnMYI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXWERYkD9vwgq1OhatuVKYpxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2VkZTlhMy03MTE2LTQ1MzYtYTcxYS0zZWM4NTkzZTU2ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARg8S3Po4n8rG+yxoDhzPglqDty6MmSfvORkK7Gy4Lf4VfK\ni0pwzFGXayvFBMG3iw1DOLSC4Tykx7fm3P+QuaaJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvBM11FXY5rfQ2zCmPAfJimoR\nBTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDZEOiYoKrb4Hop8xUUlvMJPRx7Sd/x+gFwMPhOKcVzgCIHMtcbQx5dvN\nag5aQiULIu1rUE+5xJz0CubcIY3Zjg9j\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdWa7q1GSdQWengWbtFCdpihMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I2YzNjMWItMjVmYi00ZTcxLWI1YWYtNzAwZDQxYzdmNWQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0OTI5M2Fj\nNS1hY2VkLTQ1OWYtODZmZC0yNWVmN2U0ZGYwZTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARJYbUe5qQ2Mit9datalIfJz43JrS0dsklFcg11hppQvnSKj1KrxBzF\n24+4e1Kng0vQPl8zlx0P8uHiOY3JmPuho3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTsdC27\nnBN8Q6UccYln+bjAhkfURDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAIKnvKLrhNRXzgyrw8kxPc02exnIHJaDQoYtQBifUD44\nAiAym4z4rx0rRmcOD1wa2ZcgB5nPE4v6oIlhTSTJfpfBAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6401", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6401` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAW4/GCT5M4VZ/Ngv9R5Ni9rKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxOGVlNzUzLTk5YmQtNGVhZi1iOWE4LTk5OTVjMDFlNzQ1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ1ZTYwMTUtNmYx\nZi00M2M3LThjZjItNzFkYjRiMThhZWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4Jl8fa9EL++muHyLjuQYjNhpPadyzf0La0PzOH34Iv89EOmeuxrVp7IG+H42\ngUqx/tEV8qhgz6qK4G3waZwO6KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9s/HYyv64kHUJudMjtOX7Q3cezswHwYDVR0j\nBBgwFoAU4ZIWMZhy2uxqwmlQY915qdy15JwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHJOvRTYUoopr29242firaDXNy6/yyZ0X7MqmQL3\nCbwPAiEAnaqs3ZvbwCx0SseZ4NFRalf/E/3JVV5IiQFLe5xvA8w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQZaadVyDfZG6v2UDoQo31dBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMThlZTc1My05OWJkLTRlYWYtYjlhOC05OTk1YzAxZTc0NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqCgYSs091AhuQ2e1+ro8sFZU8JIRag76iYxfgnm+rHwaI\n0/CZair5ESkkHKsQXtpH0ECnnesfDMH79NMgZ1MZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ZIWMZhy2uxqwmlQY915qdy1\n5JwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKs8sE1fZL5nPA4Dl8Hzp+GOW5mebuCFTkGhlAO3tq+BAiBacBNHAvSw\ncm76M4mf0uzCqgISlvBTqzpG1GrDGYvfgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVohdR7RI0AdFGoD1290JH4HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ1ZTYwMTUtNmYxZi00M2M3LThjZjItNzFkYjRiMThhZWNjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYWJhMTZj\nZC04NDEzLTQ0OTUtODJlMC1jMzBlMzJhMzE5YzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT4SYtzPZAK+n4Kd7ruHJ6LYT5Rui76TVSLyRyTJ1YB8e9VAY5t7sad\n4HREvjwdTc7aVCJ7MgBZRFJFJb8GlZu2o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT2z8dj\nK/riQdQm50yO05ftDdx7OzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgZVwe0PSiWqYD2+ey0ZbOUs++JoVQmh5xEmUFqXvPjXwC\nIQC5lts39R/Y1HzZdqq0dFHBnCvhGLJ3+GKgCcgzcoS1+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6402", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6402` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQf8fv2NqdGYDA0u5etTdGr0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzMDI3ZjMwLTU4ODktNDM3Ni04NjY3LTk3ODE5MjM5ZTA2NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFkNGMxYTUtN2Ey\nZi00ZTcyLTg3ZTUtZjA4Yjc5OWU4YWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdk93mbfoVJghH7pRg1tBXkdJx8ymryVdSv2YYjNHtXwmaV7b268LXrjae8a6\nn0c/cpt4XHTX1AIS7shBKXzi3aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEBq7F9zbMK5cIpCeCbRjMNDbfk0wHwYDVR0j\nBBgwFoAUv/cQasKFPbQKOwPtYzl8GIFT1lowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIBjCkpKqfcpprhRsGFATA8p6kh1sVTsszeDyg6Yg\nl96EAiEAxazH+nO5Ckyoa7aCa4NzgJHlO0WDzH18lO646joLT+g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc2XeKaD4daksSy7CU0F1HaRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzAyN2YzMC01ODg5LTQzNzYtODY2Ny05NzgxOTIzOWUwNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARs4SR6XjjZnKfq/6I76krQ0KLlt+BsSws4OvB6ljHyIANt\n1drtb95FtrZXkVHhUt0q99MEnBKws5OrpBCqRY8wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv/cQasKFPbQKOwPtYzl8GIFT\n1lowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPCXOThmYKlH2vx4imTd0rJQRoe7v+sAg9mdjnuHGnOZAiEA1AzCOlH7\nWaaIdbx+feelH/2NqZDArWjpithCzaYEQMc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdwFNg9DmSJlGddqC2cKBCmmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFkNGMxYTUtN2EyZi00ZTcyLTg3ZTUtZjA4Yjc5OWU4YWFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMTYyN2I2\nYi00ZmNiLTQyZjUtOTU3MC05MTM1YWJhMzAxYWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARvU0X7AeknAgjwc0shgmeearR55PFFMmMYdwtdPCLHP+NsIhwbDpyw\nx9DRUnnmxR4BQHgsuGBiGH/JZZup6Vjvo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQQGrsX\n3NswrlwikJ4JtGMw0Nt+TTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhALQGvuVf1K9by+2w5QPgClJrXxOVuyPgLWfXbXoWDnIr\nAiBTOazUezMNp53Da91uI5lajl0dXr3qpGDG7fIY161+Qg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6403", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6403` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAWyu/lml3mzUPDXfKxHN0VyQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1NTc4MGRkLTk5MDUtNDA5OS05Mjc2LWI4NmU5MGM2ZDljYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2UyMTQ2NDgtNzEz\nYS00MTY2LWFhZDEtOWNkNjRjMDBmZDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEULGZsDVOcDLEiOTSymJHqWl3d+JNpRj2jDWmf9avN21Hj6U9F7uxM8/dERTR\nxCnw5EGJpJ1diqhp/e5dODQMM6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeXkN4Zi8DvsrVDFX5pMFMM+RI5UwHwYDVR0j\nBBgwFoAUmH2Jis5pHM5AHKFSR4eXeDrXnHMwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCID5UDDxLaQ1u0k5RWHxHqS0fAEL6SYbC9urjDRC9L7lRAiA0\n5U8UP9GgBB8B0i9Vckuks9P4m2eX1ca3dpBQU27lkg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAexQ0AM/beTQEaJkaReU8zbZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTU3ODBkZC05OTA1LTQwOTktOTI3Ni1iODZlOTBjNmQ5Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNLXc+VE/NY2ttnCZyDoICWWaZVhEea3TDkHI5c/92JxY5\nqJeJN7dwHvmb2S8F7eyWsbqwZvpeXj6i4HIKdzN6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmH2Jis5pHM5AHKFSR4eXeDrX\nnHMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHATG+Fitz0nK2uJROhAeNWKSuOBYIA5CQUD9IUdnAvcCIQCvh+h+QmIM\nyn/pF95tJ7LBxHxB0AvAH+ijUF2C9uk0SA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAW39gV8XVGRAab4R1WLwaEZ8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2UyMTQ2NDgtNzEzYS00MTY2LWFhZDEtOWNkNjRjMDBmZDhhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZDhkM2U5\nNi04MjFmLTQ2NGItODZjNS1iM2E4NjRhMDJjNTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATKyu/8GXriQ7Lxe0LIqrji9U3UEAfKM08Sx41Zc8TL5x45UyCWpWyP\nAXAQ0j8Ut4OSgPx1IUbMdoNgUmQh2F98o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5eQ3h\nmLwO+ytUMVfmkwUwz5EjlTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAIDjfJ5s38PAez39XStvWZlFAWL94bSaveWUGWrgjN9e\nAiB1zijweMDboun58OoVwnmHg7zDJ/Dlfm4ghmB5s6m7xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6404", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6404` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAez7JYzAfjsvpiD5nGcYFYgHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyNjQ1OWVlLWQ0MjctNGM0NS1hYWIwLWVhMmVlZDc1MWEwMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVhNTczOTktNDgw\nZC00ZTBlLWJjZGUtODk0ZGZkYmI0NDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeDGYrMISewXZyeJqEdr6yjrsHXfpFFuZWaAQhvnSw1Gr7/qpI6JSfQ7U2o+u\nAJCzyr0mWbyntzdSzA8r0/hFFqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuL2DRU1Rn3TjZoMOopQFlIiksrkwHwYDVR0j\nBBgwFoAUGOXMPzIcXcAvsmGQ0C1fWYvM8UowSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIDoOZ1tzjsYMqhX+ZPFIfxDI6zP+MZfZ\nEoFS/f+inkSfAiBxRKpgypqzu4XItyRCKPRP9oM/UOwAbORnQmGrOHBkPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVfgZoxvDe9X/4/+vGAPvEKVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjY0NTllZS1kNDI3LTRjNDUtYWFiMC1lYTJlZWQ3NTFhMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqXhoJ4g7/bK7f9xt4GnkuDk9Qf1PMEfX9gYSqxWkiH12s\n6EKQjS/L3bHjoLpYNApNsk96Ve+FMtJGLlb/9jE+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGOXMPzIcXcAvsmGQ0C1fWYvM\n8UowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKjm3mFN4A1HC7qqmAmIpf3L4YeJzgrky22yvij6MJbNAiEArQNJbVjm\nL3iWRK+RkKI5ZqSDrdHlC9uRomqoBlSRsP8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbPSDO0yjzd+/6ZIVEFE9YMJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVhNTczOTktNDgwZC00ZTBlLWJjZGUtODk0ZGZkYmI0NDg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZmY3MWFj\nYi1kOTQ4LTRiMjktYjg1ZS05YTRkMDEyYWE2ZTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQjoViv6Lwx0W4YLeWS4NjpPkKjFuVGWqxoN6NoMPKJPzzHzPbr7V3C\n5YFlBoKGgYzdovCz5rs6vTnxxCSmisREo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS4vYNF\nTVGfdONmgw6ilAWUiKSyuTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIhAMjOvn7MeWqXNihAW/SXT73bLVmtoaEijBfNS+H69ybU\nAiBAf8vBSU+zq83h2mMYBnRF2+3/a9i3pELzREfCskuy1A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6405", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6405` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAeiM8uLsccr1xbKLXfSK7xL1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMjBmM2EwLWY4ZDctNDcxZi05NzMxLTIyN2QxMjc2ZWVmYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZjNDVkYmQtN2Y2\nMi00MDEwLWE1Y2ItMTY3OGFmYTYwNWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDdyTZ8NDip9uhrEzCuncZbU2+3CvYBFLH7FWzuUYwbuZZQf3kzCKFEScJO+V\n2jpBqn9/WArPcw0rDq6g8Krfv6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvwI+dl5cyO6MZubdwHftWh8aNE8wHwYDVR0j\nBBgwFoAUwJVFrQZl5U1miqzPnyWLIPu7YwMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCmDfbuQ5rVP+aKQ0p5BeYRyRd7SZyh\nZSgNNvwtrvgMwAIhAJzXziQidUlO7f+JsqZbgPAGqGzaEj5f0nAeUTpJcnqS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARqtiMoPUD8wYGOvWR0kv9K9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDIwZjNhMC1mOGQ3LTQ3MWYtOTczMS0yMjdkMTI3NmVlZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvffM7AhJvgH7qxC0wzpin3gO4lmqEV0VLCM2XGDS8nGjn\n48Dvq//xCjPVUTxQSwlKwJb3Y9PPNMkKP4IXeg0qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwJVFrQZl5U1miqzPnyWLIPu7\nYwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIlAy94BrlzWY2OBM6Dbd4XgDcJlB82lBDgHLznv44zmAiEA8UQ4Zw7Z\nQnDQxoY7tCN5zse9Wg2z3JYF/zN9Kq5ioYc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISASwL4OllzgmamL6VDBKcbCIcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZjNDVkYmQtN2Y2Mi00MDEwLWE1Y2ItMTY3OGFmYTYwNWY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNDdhNThk\nZC1hOGUzLTQwMTgtYjk3YS01YmE1MDc1MTgxN2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT00EQSNIxR3DQoxikFaIb22oVHlSFGkSNvE2Za5kcruJzwk2rfKx9Z\ne3f9fHH1Pn2zs3TTwBaZN1pF73AofHrRo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS/Aj52\nXlzI7oxm5t3Ad+1aHxo0TzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAPselUYOYiFX6vjU/v3CthsAaThCHMZnep2yK5xUAmuK\nAiEA1g3fP04iZfWPwUhVelMapXpR3vLMxTRt+Nq4dTg/UyY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6406", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6406` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAR6W2EU90TTqhWP1jMZMYDc2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2NTAxYjdjLTQwMDUtNDc0OC05MGU2LWVmMjNlODk0NGU4NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA0OWE0YzMtNTRm\nOC00MWM5LTlkZDUtM2UxZDRkMTcyYTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvjkg6iwlF8PLcEbsIjeh+joiuN/1gAoquPAuuSAE3gtOeGcdvGBitMqN9VAN\nFfHFtUUTm4XbYu+/pvKdhDcVkqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMui0mIZrQ9p3ijdpbt7dTHNv7N6MB8GA1UdIwQY\nMBaAFHGxnWY3Rg+uzzyySJK1CN0tV5MsMAoGCCqGSM49BAMCA0gAMEUCIGiVarN2\ntz/EDe+H6YIKaTLE8tyOGpAUDZ/EknyDNeFvAiEAnl02PUBJhFaWW9LitOVZZrXa\n4N4v6Lp5dVEbVnX7+uQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdoKs7tKJDKpC3eRShVr7VuBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjUwMWI3Yy00MDA1LTQ3NDgtOTBlNi1lZjIzZTg5NDRlODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQE//vYCPIjMv8++ttDpLSMZW1mvabasMueyHXzK7lwM9SU\n2VCO9P4wyX4XxcrLQBtUVOh0+2t8yV0O/4CFCygoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcbGdZjdGD67PPLJIkrUI3S1X\nkywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALwc59/9V0x1LYXx4vdut4W4kidsyViDA2w5asDnG5T7AiEAtR4bloFB\naOnXFL4gbEb0Q9mIfGwiJnJ8B6PsE2CRhPw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAfB/i5T1ScUtLYb4Q6LnX5KVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA0OWE0YzMtNTRmOC00MWM5LTlkZDUtM2UxZDRkMTcyYTE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMmFhMzI5\nMy03MDNhLTQ2ODMtYmQzZC1mNzA1OTE4MjhhM2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT24TJGtKIa/6TX1kRiFDvWklkpfl+RwJV311RPoLvsnNBklu0BpDnt\n0tweXXyh2Svp6FtWrL6cxFih2tlFJgU5o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTLotJi\nGa0Pad4o3aW7e3Uxzb+zejAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgPpds1yhalv6/u/oWENwcJuXxf7LkmKhOAI9T\n3EthckMCIHwShyU3CIhu0yqMRoIvx+n91a0EKYSdRoSIW7wVupTX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6407", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6407` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISARPb4lSq7wyzW78qj+u+4LuQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkYWJhOGJhLWM3YzktNDdiMi1hM2E4LTY2OGMwYWUxZmM2OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQ1OWMyZDMtMDE0\nNC00OGJmLTk3OTgtZWE4MWI2YWVjYTIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOMnDTNyidFcILfqXpXq0N0OSV1w31JEduAnV8I3YmEmc0L5kmNkdVhtZiiJJ\nDugDnlvMsjYQ/Wc/mPg71woemqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIsC57Duf60lNS1/Fn4+NwXsOrZ9MB8GA1UdIwQY\nMBaAFJcIwIMbIt/kJL3zV0ZVpB9+C51yMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAYf8Eau03/1oTG+7bBVPyG+7KdWPo63GUj\nZJXf9k/wYAIgWBuiYn0bSu2oN1veioEw3RVbTbNXMBP55+dTbPogVQ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARpR9bKhtZt8qUdCkN6exQHWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGFiYThiYS1jN2M5LTQ3YjItYTNhOC02NjhjMGFlMWZjNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGyTCFR9SZx9CYAmAygSQmTGqksAxVux8R+VGZneTxCItl\nNjlofuuGsE4KcknQoyUKTYMSDXmQvI9lTOyNKxcZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlwjAgxsi3+QkvfNXRlWkH34L\nnXIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPadE0lDA0Yrb3L9iNATAjwe5dv0lFkqqCmPYAZO/VFdAiEAhnfjIeg5\nsOS1BLN7Oqk4fEdPn1kW+AhJtK72FE7biSM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZOb29Stau+6kVj080M0nfN4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQ1OWMyZDMtMDE0NC00OGJmLTk3OTgtZWE4MWI2YWVjYTIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MzBmMzZj\nNC01Zjg1LTQzMDctYjFmMi00MjQzZDM2ZDA4MTkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATneKpt60CNUG8SmkfuD+2jOVgchbEp22pmKWpt/7VlHYYztszdwTtI\n9hfIxBcmeP8zaR6cNVOYqVxMBqpvkAvqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLAuew\n7n+tJTUtfxZ+PjcF7Dq2fTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPhWxw5mz2zNTsoptLMdiQAhhE1sUIOxAIk7\nRq2VSuvtAiAtaZTaMpFBXZ9KsH4Y3jQ7O4fV2wttFegrm1cUF/+E3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6408", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6408` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAb0kZaQ0izVlYRQvEY6b51vsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYTY1MTA4LWQ0Y2QtNDVjZC05MjVjLTQyNDc2YmI1NjA2ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTIyMDU2MDYtZGI5\nYi00ZDQ3LTg5YzItOTQ0OTNhNjY3YWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJUCW/1TVYXf8BbREf79qVHhDxhoRrQNHPXEcDONLXr85JiAvD+6QxJHjaoBE\nkQB/VWDLpp1929lapyWmmG+9saN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPZaHSFMaaab5Yck3NqTYmATCbY3MB8GA1UdIwQY\nMBaAFG7ekFMviidtwXo23EvtjX1wf3JpMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBEFtoLLfVJSWWi6rJ2drksX69yxFdmAH5D\noxP1irSV6gIhAOgdrAzk6w6ET5+bAGEbdC+bJw/Pt1VeTEuJFx21jiHW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQHhaA/xp0nPjjBTCBc2XqzdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmE2NTEwOC1kNGNkLTQ1Y2QtOTI1Yy00MjQ3NmJiNTYwNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATubX/y+lhOcDnR+GTZRMxDzTIm+vf+HeqdreA0ZTHBThYY\niML2waCl56F4uPguvmqUUyIyduENO4qItV4sij5Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbt6QUy+KJ23BejbcS+2NfXB/\ncmkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOIE0wfcbM0j02d7sgChjLWdKg4ilSL7E7aLMNSxAZlXAiEA+meShCN5\n3cWJfU2UF2AG7lffyakgyG380JKB3RAs/d4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZJEGsPXgXT+Lf2MZzUyS2ndMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTIyMDU2MDYtZGI5Yi00ZDQ3LTg5YzItOTQ0OTNhNjY3YWQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1M2FhMTcy\nNy03ZTdhLTQ2ODAtYjU2ZC02NjQ3NzhkYWM4NTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS5wzW/GSD65PuArdFeSlZGkX1hZRHg603Ih0b2Sqs5pkDlwh9anWxb\nzMYTuejyk4sYhZuBslqVd0csyzJwj4uMo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT2Wh0h\nTGmmm+WHJNzak2JgEwm2NzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgbrS/Nu5FlQxwDh25OKqNfKbKZTQjUW25qDrx\nKyiNPmQCIQCnP0TyLvNDnvdX6EYZDh+xl4SFl0G95d9e/ukg9CwkPg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6409", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6409` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAWVlNFPOBRl2XtwGdxozndEIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NTc3YmE1LTY0MTktNGI0Yi1iMGQ5LTZjNGFkNjRmM2U2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFhYWE5N2UtMjAz\nYy00MWVjLWJmM2QtN2RkNGI3ZWY4MTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMkzWRowwbEGzHBxPl3mLCnbjIuFokVS23iZu9jAPEGOL9gt58VOHkdzxrvCl\nvvBLsTa/YPV6U5o1qw6vXHdrzaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTz1TMZilpZNsMNl0fyfLJQ5EbNfDAfBgNVHSME\nGDAWgBQ3f5GwlhOl7aglbDhp3wa8QG9IwDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGizg41UUV9L2G8NK1HbZSYXQ2B2SXZn\nfVQ4uJjsQz2BAiAkYT0HpWzoVLMbe7yyiRO3fAQwuxbh559Owa4vPNNh/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARkdCg095uNenkRtqLURHtnkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTU3N2JhNS02NDE5LTRiNGItYjBkOS02YzRhZDY0ZjNlNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCiDOnfc7kSaZQYD+IvT7+Jkt0TWKQcj89tsmL90urc9WD\nas/xbWAeGd/RaENsspxoSN9qHaMXJsoZ44gkP3oKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN3+RsJYTpe2oJWw4ad8GvEBv\nSMAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMOvDfCbo2H67+rFNhYBCv8bgobpLRtNGIjvBOYn2qFeAiAlNkGsmLU9\nUszrT+BW0AuEpRGIM2OuMVbxWk1f/Xu9ow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAdxO/nwQjSHnW33jCDA1mPnsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFhYWE5N2UtMjAzYy00MWVjLWJmM2QtN2RkNGI3ZWY4MTcwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNzhhN2I5\nMC0yNTZiLTRmYjYtOTM0Ni0yZGMxZmRiNTYyYmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARVjwm8V9vSrPI6s2ylP+TJjIqEFsZoJIbh29LcIxdy8gu/JRlpXtKp\nkS3Q5BUiA/CNtj1pdhVAxXiEdv6wgM6Mo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTz1TMZ\nilpZNsMNl0fyfLJQ5EbNfDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOQuSKge/cPW67g/cjL3wfWU6xncdKguggX+\naoPkvwLzAiEAmPKjDeQPnKNevr6+b5vAQbtAriTIXJf1VFfTeuXYvOs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6410", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6410` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAamsGSY5KSyXZrC6jKbT4MGWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhMDU2OThlLWIwZjItNGNiNi05MTIxLWZiOTMyNWNkNDFiNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE5YzAzMGQtZDkz\nNi00YTgyLWEwZTgtOGFhNDRkZTc4Nzc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUntUbOvjK0CB4xVWAslUnIirzcD5FUCQhdeu0eQmMvO0FbCrD5RwSk/L36gS\nqTUB0FcRPlOmirT5pU0ZreVOJKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVN7c53XFvGBwh1b8YHNSPqZolfcwHwYDVR0j\nBBgwFoAUqD4BHEIiXXIoJnDc9PFzZ4dWAskwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBINTxsgC2ZD9Lk\nLlREFo1y4iXyq0jf84h0EbSS7sB85AIgFtUyYAss2BegFzsd0myTCCwkUyfarg7Q\nUvVe+LJ2bWc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQAG6uvb0nc25lnxSuUSB0YfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTA1Njk4ZS1iMGYyLTRjYjYtOTEyMS1mYjkzMjVjZDQxYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrulra6kNFeIl6Wod4rKYhwwlGb7ovY+PW64hosobRuHJ8\ncyjugibUI/cerP3Zal+ygWUrS4pcuFl90Qpw4ZDAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqD4BHEIiXXIoJnDc9PFzZ4dW\nAskwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIWme/RVRUignYdP30LSmDKO9Zb51vSNSoUCKRWbF1NCAiEA0kIhpplT\nPSR/lu2SGDOGXFulFjYIocp4E4GGi7B+cJY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAfajU1K0utwS18AmIQdAbtFGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE5YzAzMGQtZDkzNi00YTgyLWEwZTgtOGFhNDRkZTc4Nzc5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0YTRjOGRm\nMC1kMDdjLTRhNmMtYWIxNy1mYmQ2NTZmM2JmZDkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARqD1/unmNAY3SymY/Oz9DEFXPH4juO+dNG5icDahEfRHV8SwImvnMI\n5wSckeyvNmMmKeLs9INDA0dabGSf2FELo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRU3tzn\ndcW8YHCHVvxgc1I+pmiV9zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOcu2ZzzY2lOJzgR0o6aVt6O1EOEIOhGbnGZ\ncGim+mIrAiEAp7lAS0ruaSiFHquoz0HlEX6z4Qd40tqp//1bBeyFjzM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6411", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6411` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAS8XX52oyKyzoc12Du8Z2E1dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwOWM5Y2E0LTJmYzgtNGQ2Zi1hMDQyLTUxNTkzNDE1MmJhYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDcyNWE5MjYtMTYy\nNy00MjYzLWJkZGYtMzAxZmU5ZDQyYjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKqAxvGGDGlCeUsu89iIxF3gv1UMj7rSJAEpMmSgPCTbgaOw6qpQ2D78A/25t\nYGaYNNtjEfj5QFrlu+kRGhTumqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiU09xfLNdwJWPou1vjBuOLPy5CIwHwYDVR0j\nBBgwFoAUkDIB8RomFP7NkOtRISshQxSyVMcwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEArkrwSzPMJ9Xx\nHikWyYTF/tKnyx5hJ5Ea5grNxsobngkCIQCninkN9kowNg7FEc9f6ruy27KMrpBT\nLHfMOv9suf2d4w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcjv0sXdsARcF3WwpeiPw3rnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDljOWNhNC0yZmM4LTRkNmYtYTA0Mi01MTU5MzQxNTJiYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQO5fJqnZMgBpaw96Vx/DUsdPsu0XZ2T3+8zwQsfNf9Fav/\n6ITYQNVRyXkt3iC8tPDHJq4e2QpvlEeZXqRLzz65o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkDIB8RomFP7NkOtRISshQxSy\nVMcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN7wEWz7pHpBiA13tDfpcflKcdnf+5cPNO8OWywSaxL2AiEA7ycSVg1K\n3oyP8Tfg8MNQj/pzpRQwiUe+OONOEwCZqrs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAej/jeveaXq3kBlM9xIgnWf3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDcyNWE5MjYtMTYyNy00MjYzLWJkZGYtMzAxZmU5ZDQyYjZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNjdkOTFj\nYS01YzczLTQ2OTYtYjUzNS1hOWRlNjIwN2E3Y2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARqdozIeD4MyQOZOMzIsne/RgXELek3kHZd75ewsmb3rA8Q0hqxlaH5\n6oM1xTRtY8rIf0yPv4hyBUo3Dqjjm+Tso3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSJTT3F\n8s13AlY+i7W+MG44s/LkIjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJtPNszbkSGLDrgmsbaZD1dOiv1+koc6q+b5\nEYxen+V6AiBlvVhKlrwQqtoZoWar6J1tXX6ellXAojWyeN/DHQ1kpQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6412", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6412` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAXq8y7st9IiSN/lwWwysOff0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5YjEzNjhmLTY0ZDktNDg5Ni04ODkwLTM5MzExOTMxNWI4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2IzZGQ4ZjctNGY1\nYy00ZDk3LWI5NDYtMDY3YzE5ZDk4NGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElCldXHRIqX9SN3Fn99itkLoWpS2Q35m4AR8wYGQK7BT2jtGWcmSd1TbwUpaQ\nA3s8DxBhLJZ3Zl92pKYq24Y316OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmfkaLeM14/v9SJgag5E1bkEX4lowHwYDVR0j\nBBgwFoAUZNsGFosfWnmT3ttuDm1VISDTzRYwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAw5iG3Br5oVRpjhFWuVkb\nuOHOISVhd03b5r9tPFTnpx0CIQDNq7z1df2Uscdm3gJxRXhTmy1RkZvXrS+O/OsN\nPVMqxA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARAenIFiNAlKuT4BGAlb9HXfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWIxMzY4Zi02NGQ5LTQ4OTYtODg5MC0zOTMxMTkzMTViOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAVfx4x5KnyBroNZqPJwz+3uWZUQOwel+qpiV5ZPFSr5Xq\nvxkGovpdqALVc0o2wb6VfGbmOhkDkiQmQHRywOXzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZNsGFosfWnmT3ttuDm1VISDT\nzRYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIvcXgq/AWa6oPRuIDRnouDN5OLz5TziMW2YJxhkJeUVAiAUxdztEdGk\nbi9PhUB6N4gZ6u0pgbC7rzFte/lJur8eFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAcNDVfEqwTz+zb66nI4irglbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2IzZGQ4ZjctNGY1Yy00ZDk3LWI5NDYtMDY3YzE5ZDk4NGVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NTBlNzJk\nOS1lNmMwLTQ1ZDktYTM0Mi05YTEzNDU5OWE3ZTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARF8N/I33/+H99VLA+6EmxBilqIfV1Pa7hF+8jN3HCNV1KA1FXNKTDb\nE5Y4qkfLpSfBo/G7bopcWgKKNnmOfDPPo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZ+Rot\n4zXj+/1ImBqDkTVuQRfiWjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAMyFzjVOqQjUEGuRRhqUq6D4/WJPsI97nvpn\na5IApaaZAiEAxMgIXtV8e3U+KIDvmtzh2e78/vnR2AxjOqzWOPAqp90=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6413", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6413` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISARtBIQmpIvkCeaCVMPE+GUsCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4NzMxZGJlLWExY2EtNGMzMy1iMzBiLTA2YWVlYzFjN2M2NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzYyYzNhNGQtZTU0\nNi00YzgyLTlhNWItNjNkMDQxNzE5MDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJac2MHEL3LE1zhc0+Bi1xhU0PCvTQ5cGM6A4bCach88rhn1xzkTnalL/qIrN\nhrXNhb2fBXnqUJNdjETTpCNM5qOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0uwc7U9mkDLMBbTl4sDSzjR4ILUwHwYDVR0j\nBBgwFoAUoUCr38IbgFEhSAUEHdzmQoepSHEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAn4Yb\nFXQdJuivOkI3mWMnWi7UTyTl58ymOyMqa2sqJN4CIHOb4skoG71S8nes24l7aOq6\n6RVisbZpyr20EXPEsZPZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcafg3roZupvbX9JkiDFPJPbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODczMWRiZS1hMWNhLTRjMzMtYjMwYi0wNmFlZWMxYzdjNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQolgWywl97rWiqfXno6o84OXIFI6LE+GJJf65xEwwQa1VQ\nLYCW85rEs9dD3472841YgtLcnKJFxeEVfXRDNMwCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoUCr38IbgFEhSAUEHdzmQoep\nSHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLB5WwsLCHIm1E0DjaDJQfXUEu5T/QweNDg9oiQPLN+ACIQChol2dfF6S\nWZOkdeyQ8CY7teueJtWrk2yuT4CHVGwg7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAeNmiNlj7yUm0dvgnnPNjiHUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzYyYzNhNGQtZTU0Ni00YzgyLTlhNWItNjNkMDQxNzE5MDVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1OWQxODI2\nZC0zMWNlLTRjYTktYWQ2OC1lNGI2MDA3Y2MzMjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATpcJEAFQLzxi+rchH+SeBex/3I85jDmPad90Tx0z2EDsv4n0mY2zW+\nHVh25sYldxGm6QIU1byFi9mUkImHB56co3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTS7Bzt\nT2aQMswFtOXiwNLONHggtTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAODev6eZ7/PXN1d+T5IfIyvMafeyjvFW6bQ0\nTFCrA2c7AiEA9SEcRLmrNCoEQ3c/O7G+Zy5tLMOUr3h3206h/KfFI7s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6414", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6414` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISATi6VQANAhj6oPMvgG3fooLUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyZGZkMzVkLWNhMDgtNGRiNS04Mzg0LTQ5MWI0YzQzODFjYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFmNTg2ODYtZDgy\nZS00MzZkLTgxNzItM2ZiNmRhNWRiMDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDSaLhcn6zX4+iHm/PvFH70qxb406FjZ84XCbJKk4sUgXPYBV16tq9Hstg//0\nIg85dAxiu2awFKczAWXk0dnF56OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUANtKPqWo5oogUq1Hh4PuAtyAIP4wHwYDVR0j\nBBgwFoAULQfUaL7ywCZjthP/2fTmspFlnUEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAqUME\nLZF2mZRklXDo84IlM+S6eRbGYl8Vd7/qTMQ5aYACIQCHI7SyLin4InAdhWXKQixB\nrKI7zh5RwVnDEgiZiJcVDw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbS9CoJFi4+PsHiK5A6HXbLTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmRmZDM1ZC1jYTA4LTRkYjUtODM4NC00OTFiNGM0MzgxY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPwXSQmg/EenfymOCaG3Y4YXu2mbHH9Lju/aIwNMwSYoF7\nAm56f+8atGeV/2k0eJ3pr/6rzhvDu4pCnJ+X9iLVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULQfUaL7ywCZjthP/2fTmspFl\nnUEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF/8ieqxg8Mh52aGJd9ogv4d93asraXFSwlXybeFcy7wCIQCtn9t1cCMF\nR2rrlnPEIZB1daJs9lW53IEAhndTztR1JA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISARnNkNCsdKgByeLAtt2vlAuhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFmNTg2ODYtZDgyZS00MzZkLTgxNzItM2ZiNmRhNWRiMDBhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYTU1Mzhk\nMS1jODVlLTRjZGYtYTA3MS01NGIxNzAwZWI1NWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAShAlTB6PBRN9ElZZZJtmOl3K6RrazUoQ6rA9xLoLa4Ir38VKbOhbkb\n7KTWL+TmkGA55vB19Y51GTVZeEKG5CHKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQA20o+\npajmiiBSrUeHg+4C3IAg/jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgTx7s9BvXFYeW/VAG3BwmGqOxTck77YcaMwsK\n/CXKGMECIDy30WrJD1AzhRoq8EIDr2L+GlcLpbs0hFuogUBvGkpF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6415", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6415` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAUKgx8HUn0gCEATbnaDHKAw0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwNWE3OTI2LTI2YmEtNGUwOS1hYzI0LTAyYjg1NDI1YzFlMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY3ZjY3ZmItZmNj\nOC00MDEzLTg1NDMtNjEzMWZmYzg5NDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES9p9Vk07w3552mv0v128KvnkcUBJwbJ/dyEpXzVWeq0WzoKLhp/UIwDbOcIf\nkHJ8pzjeT6Q420W1JrRabl4LfqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOLF7fd92BwZzFBeKZ62T4tp4ebgMB8GA1UdIwQY\nMBaAFMVOI84MGlRCAAobm+T3iF9igxrYMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAtO62IzWTyq3uIDUR5aOG7Qx/3lSFKF5H\nDbA9bHeeYe8CIQC2LvZb3Q6qFY/bdoUM8ou/axXUJ5RzxWg/qkEPq4fezw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcW31PDkZn5Lc5+/L2cL2X6uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDVhNzkyNi0yNmJhLTRlMDktYWMyNC0wMmI4NTQyNWMxZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARv4PBENS14tbE1a4/nFPNjIhYo9Z15HOmO88XJ480RTE9s\nvPQdpP+5D2Qem0QHBrpZB+GRKz9Z0PEGzYGTnaeio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxU4jzgwaVEIAChub5PeIX2KD\nGtgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALCds59TA4TL5DVEURTmNaWwc1oRziUHeAChXWIX0UYiAiBDycYXHzQd\nDT2U6mgqqsOn5ghINiI2pmXPliP/FLjWQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISATjPQDNcNkWatrjdAcfcQHKcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY3ZjY3ZmItZmNjOC00MDEzLTg1NDMtNjEzMWZmYzg5NDBkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2OTMyNTRk\nMS1hNzUwLTQ0YjktYTNjYi0wYzA1MmMwMWE5ODkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARg6/oBpuhEwmRD89wbU9T/kTleKv3l4+WbXDBtFkuqOYFwLhd1K2au\nXbbygrlEetDXRN8lhLXmeRPzFBAJ2Yp7o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTixe33\nfdgcGcxQXimetk+LaeHm4DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOE8aNouBbYMNchuC/3WnIjp+RGwtAkaEK2d\n6xniqoAtAiEA4LTNjcAceXF1ulTuufpcH7ZPAIrUXMRZBO3B81fC2jk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6416", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6416` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAU0p28glchJMmFCfutpZdYeYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ZDYzZDhkLTU3M2ItNDMxMC1iNDAzLTg5ZmU5YjZhZjUxODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMwOGQ3NzctODU0\nZC00MDhiLTk4NTAtYTU2OGRjZjY2MmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm6D9vHfA8D2EnbBOS84XHksJZXx4xXwkJ8FL3UxCbr8+YI7vwyrzbOnXPNz2\n2xEMonpjM/8SCqPAnk6RwjfYd6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/KrLePDh2RIO0sAPxwiCwoKOJcwwHwYDVR0j\nBBgwFoAUmalDW1Y9EX9oKvjSxRw+8RyWljcwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAItGsntpFWmj\n8+Al93VMle4xHdZ76Zs4BA7Oa5dLCJrtAiEAtjeVEmLTLoZVp2s4uyoGIGqGMCmE\nlqsbIRjPtww00gk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXgdmmyrkHNYiaHZzEpIlCAoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWQ2M2Q4ZC01NzNiLTQzMTAtYjQwMy04OWZlOWI2YWY1MTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsai0goI1dNENs0uIXiVnrFK7bM7mnckMXBEaI/M6gw05p\nCZ7t20v1BldXLtOpDWo6ACr5KwyNgQPUndptRGbdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmalDW1Y9EX9oKvjSxRw+8RyW\nljcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgefqZ+wWatsCz5U9nsnh4rbfTYxv6b0Edd/0CedCdoOsCIQCGsVoz5Kfz\nHF1w+27xvEl79NHtdzTv1XGHol5eHRy50A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAbcP0COUpJ+sNzX5YQQJJmdoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMwOGQ3NzctODU0ZC00MDhiLTk4NTAtYTU2OGRjZjY2MmJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyM2RhOTEz\nMC1lNzAzLTQwNWUtODgxYS1iMmI0OWRkMTMxZmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQjqSRSi5Bnyy1cu8QnALxcmYtw7mcKgWmhAJB0tq3z1JSMZNRntDdy\nKNAum2N7gIU+UxZGE/Bk+I0wtEOI9zUco3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT8qst4\n8OHZEg7SwA/HCILCgo4lzDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAL/gaY2/+J/Wr37iOIIs2ACXS6Gv78GKEeBf\ns8WnwgeNAiEA8HNzxyxkfS599EaodR8vn1e4wywnBAhJCF/qRvFmWsw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6417", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6417` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAW/wmREuoBVc1XZuEInM7RgFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2ZjgyNTExLTlkMzQtNGEwYy04YmQ4LTAwNDM4ODk4MWMxMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJkMjA2ZDktZDgz\nNS00NDc0LTk3MzgtNTZjNjk5NmI0YzFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER701pj5dJiuNQM8KHjeabuL/3kUFoFMyqwkgF1UC6WL8/GeRw7bJaSE33Uh6\nRfp01b71850Igel1rxXok8XTGaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrK2oxvR5p8PlvaLzvQXt3KAg+ZMwHwYDVR0j\nBBgwFoAU70t4wT4yN8NhZPrurK57XDr8+28wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOBw3bbO4dfI\n/58AMFpcgq1Xm0BFqqalWPfk8e5sTurXAiAeNE8cnnD+mZSFWXglY4IWhWUK1bUv\n3/QTTetoiLZOTw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARgBc1ErK2MO76hwZnppipWfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNmY4MjUxMS05ZDM0LTRhMGMtOGJkOC0wMDQzODg5ODFjMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg8Ni5eS4F2tHEZCyuVYPOmkxKK5TdHe2GFbxI//a0FVYN\n0+z4hnEiSPdw3Vp8cM/Y0Tt2fCtHMemlGJcAC0YCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU70t4wT4yN8NhZPrurK57XDr8\n+28wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAObKuLmreukBHdtBhSwRMtfZqShKYcpTqyrEgB6SkxM7AiBmoEHOjVjX\no5SGhtzi/k8GmcHE+Hu4TSETgbE1bUf5Sw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISATrli7eejpbwJfC/d3O6WX10MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJkMjA2ZDktZDgzNS00NDc0LTk3MzgtNTZjNjk5NmI0YzFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MmRmMzFi\nMC1iMDY0LTQ0MGYtYWEwOS03MTE2NWQyMjA4Y2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARHzVBgaJ7qqYjpWFFl2ulLOkvaR695/OZEk+uPNiOZXLx6HA8d+y04\nlrN0QEG0jMQ5vyHIVtmwc6OnKeLzfLBRo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSsrajG\n9Hmnw+W9ovO9Be3coCD5kzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhANGczAnjS/9IiJIyoQFI9GMHE9f4Y4hT6epJ\ntAJ08I0yAiEApaq7ttf97bePBsQgyY4LTb/bj3y/+bZwsGZKXdqO758=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6418", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6418` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAfDdqz5Pk5AiVAjeXLt2pWqMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4YTliNzNiLWJhY2MtNDAxYy1hZDZjLTMxZDJmZGJjNzE1NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMxNTBhZjItZWVk\nNS00N2Q2LWI3MTItZDQ1ZjkzYjZhZDRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0v3Ds/P0E6eX+SUZKCHBPk1K6YtfkTSm1iMfFd7ZAzR9I5l87OzXIs21RwuI\nWldAJpEmPLrW6vTLYeSDpBNoMqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUahYg+rSggwEFV34sDb+xeURw0oMwHwYDVR0j\nBBgwFoAUCrJwaFaCn3Wwx9znOxGqokPuXMwwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQConV7c+LkW\nINYxVlDQn4Davg2yAhgClcJi6ldbdmU4FgIhALecsMV6EULcnO7myQ76zICqbxTc\nuPZYH8/5eEm/g/AY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZa/fas6dyxQUpy2xhUfRKcJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGE5YjczYi1iYWNjLTQwMWMtYWQ2Yy0zMWQyZmRiYzcxNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCx4R7HRIg5E+qeCaJFxi0yLXHjZWnBtN7NCh8aYq2B6SM\ndpOtlffqqXe2xpt3y0DQnQJqIryyONmMFVTegDkyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCrJwaFaCn3Wwx9znOxGqokPu\nXMwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN6mA35vIbY52xYwLcp6+xZEX0awCe+W2EmdrMUyAS7kAiEA1eysgB/4\nALq+sn60FWdxkyTKeCGft8K3S4g+5W4Knbc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAShdiEYsxmAnT4j/LmCWW4GzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMxNTBhZjItZWVkNS00N2Q2LWI3MTItZDQ1ZjkzYjZhZDRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMGQ2NGM1\nZS1mZWY4LTQwOTUtOTcxYy1lMjY0YTZlNTczNGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT8DUoHe0AHITA2m/J5AzrdUNQmuWuKhDjkgGVwp4jga78moz/e7Tkf\n0iJC53zFfEeB+G5fLHw4Ube5QD5svHiGo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqFiD6\ntKCDAQVXfiwNv7F5RHDSgzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgOz+1CA01CzDjY3GoeVKWfNEcBB62dz76leQp\nDrYq/YgCIFw/XsU2YL31Yk1yy3Y7RIuOi3sdrSmjtjT1lGFZDH6K\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6419", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6419` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfOlqtzh85X6MzgpT8Rr2FPhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllOGRkMGZiLTViYmMtNGEzZi1iNDkzLTg0ODZiYTY1NjA2MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdiMzVmZTMtOWRh\nNS00YzNkLWJiODMtMjFjYTZjMzMwYWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHihGVU4lsze9dvMvq4jzaT27YpjZdwhEMvaoymxbzY1efAh/nCb6S24zndvw\nwrVk/BKJl4vhfoplg7YF/43f2KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv8F4rvZ9Orde1WmqPQCNa/iZENswHwYDVR0j\nBBgwFoAUKeCD/EsKwJNqD94vT/bOmzh3vI0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBZoJiLqtIuvTXnANN/XRgA7339JMiA8a6pKdMh/Fk2wAiEA/iqhAVyVyc3s\n6y4ZClgUzfhfOJUQeqYxKTgrn6fC2r0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXIDZdxcQOTLcLzKelCxg3L8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZThkZDBmYi01YmJjLTRhM2YtYjQ5My04NDg2YmE2NTYwNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQurf+7wouc6yPysG3hkO9i0JUgUjgGNCQL3oeQLlvkGyMv\n4m3Ah0EiEbvE5zqXoBcbz9ec8x9d9OrdwivvBbpRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKeCD/EsKwJNqD94vT/bOmzh3\nvI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaO+bCJV8BWHZhjAj877bCo/zfnVmDNdTC4Xjg9PSYNUCIAVb9f9vBixD\nKHXzEO650u0kz54HT9fpA9DtKtKU2gWp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISASvz4CrzU2xjofjiSx+hNkpeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdiMzVmZTMtOWRhNS00YzNkLWJiODMtMjFjYTZjMzMwYWZmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0M2M1OTAz\nMy05ZjcyLTQwOTYtYmFlYi05ODZiZTczMmViYmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARZi53wxnXEekNAHQEGCobBc1zjCGNErtIZtzqLVFzupHT6xqbb/54V\nb/zdLibn4KZKmxJT7+/Pq4M3L8ZtIzPLo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS/wXiu\n9n06t17Vaao9AI1r+JkQ2zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPWM4XN+YAnxeWpA61lkGk7v5IAK9gYYmRl/\nx2yTJiihAiA9GXQq7A/VnFouZjsKQ5G++fVlECA7s6sGyHeumtDjYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6420", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6420` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAba75n8yqg1NiXCTB3gJDRgxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NDc1MDdjLWVjZDctNDcxMC04ZmNjLWFiNWU5Y2U4MmFkMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I5NjczMTYtNGQ1\nZi00MzYxLTgyZDktMTNlMDYxOGIxODI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwTo3GcyN4N8uDQ3IosXZA8hD5hCqjzyaRV870beEat+GSSUm6yVuJU3v/p25\nENX2EfKB22QDmzVySfWmh2oDsKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH/F7pGDl8+7tKM384cJUNhMqdSkwHwYDVR0j\nBBgwFoAUIkXX474mK6YCt7HC8xU02uKoSRkwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEG/SXsJwRS651choXKNIliT6VXBWD2J78RLdllCBvY2AiEA/4PyiDMy+929\nJMZD2Tmg+SFaOg5S+hRKGyVgbwd10vw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfYI/hxayjgZG26v/CRPujo7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjQ3NTA3Yy1lY2Q3LTQ3MTAtOGZjYy1hYjVlOWNlODJhZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYu0DSiKqs3GdgQoll3pVosRdc9QOFXHAgTqIaodP3W7+T\nK0SDe2IBAe8B/lQn75XOuO4x75+eKzJ2lVABpQNQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIkXX474mK6YCt7HC8xU02uKo\nSRkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI+yiuhZodA7awHTrhtIcPvWaYd7dpD6SEH0dQVYLuphAiEAyLxJgOsz\nkVd2W8KeD5BCcF2vvX+KSSQaXtrQ2UsfqaQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAdLkCM6Ck2dXfqXywNtVFjyiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I5NjczMTYtNGQ1Zi00MzYxLTgyZDktMTNlMDYxOGIxODI5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMzllM2Nh\nMC1lMWIzLTRlODktOGFkYy01ZTNmZjM5YjgzNWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATxMbGve2SfPqvZW2aHzt5E78NHsDTgD1KgEVl+HDI5LCAZVPHbk1pK\n7eyGBYPvm4jH+Igu461N2kad+AQHd45co3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQf8Xuk\nYOXz7u0ozfzhwlQ2Eyp1KTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAK+MMHGBxpBzZ79K6wr/X4sSv2zydltpzi3X\npGuyZ3M1AiEAr2SkavoJZWpLqo3LsIirfLXM/MehPRcRbooM4OSyeOw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6421", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6421` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAb0OTMWLH1iBUB7RiNdkx94tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5MTcxYmQ4LThlMDEtNDVkNi1hNTMzLWUyZDg2ZjlhNzJhZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDkxNDBjYWYtNTA5\nYi00MjEzLWE1ODAtYzU3ZjM2NTM3NDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq3RLgM7/406Z7fvN7ngJYqND4msbp2+6MPo+mI+K0Q9wHTCUwPAq7sXl3eYP\nFqICh8t8F11UfSgiuVQWKHWqdqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6DjtNIwVszfn5C9cVF0wy/9YeGgwHwYDVR0j\nBBgwFoAU50gcyvJyQeRZeekY5e57lJJ5C1gwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCi\nGTpmhXSolZR/DDnZVGj4yxj8DAz08lmreBvD5oXtKwIgexrwd7oAW8kGBEles0W0\nMXorV0ccvkM8GeJ+d1Ag4FY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZPzkgcBm3hQNauBi/xa9dOYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTE3MWJkOC04ZTAxLTQ1ZDYtYTUzMy1lMmQ4NmY5YTcyYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCaVyglOviRd2mrvzlZFqtibCT3PEGR65EUUmDhCVKx//t\nGPCkK0RO/UhWhl47uSM7uDxeGyr3jH1+lfOQa04so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU50gcyvJyQeRZeekY5e57lJJ5\nC1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVK1eEucpr9Idt+iFKJ65A5hQKQTibdDKCMTE216u1JICIQDFlDcFozqK\nPywnTuPjKTmr9vM6AT4pR6b2oXNOdJZtjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAc6/QEyJxaYJPJ5mw4p+nohsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDkxNDBjYWYtNTA5Yi00MjEzLWE1ODAtYzU3ZjM2NTM3NDIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNWI4MjFh\nNS05YjU2LTQ0YjktOTQwMS03MzY0ZGVjMjkwMTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS8eiba/ISPr9TqeV6VoTP7nSCuxjwA609Ss336gC8c1xhS70SscEHF\nbmYkTc97GRXN+Y5SJXrdJG0Krg9X8nmAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToOO00\njBWzN+fkL1xUXTDL/1h4aDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgN389XTNdo+NPH3vUa+Hnz9Bj9Z5JLTrmU2vc\n43FNS1oCIB/PrukqY4tI+F8Wigd3j3vm6oVcInuSWayFb2mjyfw4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6422", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6422` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAf+gAwIBAgISAa4g48PYRcmybb8mP9EbgxlPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4N2Q3MzJiLTM5ZDYtNDg5Mi1iMzk4LThkNWNjNmE4MzlmOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE5ZWQzYjgtZDlm\nOC00ODgxLWIzNDMtNGM1NmFlZWY3N2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnjt0lSS9kROmsiGV58O3WcYX3I/Rnna8Hug+OHKVG2PF/60YD3+psLfK/4f7\nJWnww9+9uSIzAHwmfnDzZScrxaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr8ttR0Cgq4TVSotjtnDI5cREJOowHwYDVR0j\nBBgwFoAUsuNE+7U/36gzEfcKdocsUoFRHpcwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0YAMEMCIAFDxcqUI1O6E2wZ+bBLezIE/oFlTpKi/7r2cjEBBsEGAh8hFPib\nq+hJSXb8/abG5ktCyrRHgCU0GjANZTsKBVvh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASieVeUbMsPBH8G41hs3RN9OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODdkNzMyYi0zOWQ2LTQ4OTItYjM5OC04ZDVjYzZhODM5ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/CL3lkfX4pYYO9z9xi3RIOPOs4Qh9Xl/pai7PQvaSicoG\n6NmAnMmG+JTYKtLldQJ1o8O4ecfdVVdXmrNb+yO6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsuNE+7U/36gzEfcKdocsUoFR\nHpcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKKVymNW+p+q+sHnka4D3rEtZqnXz/HzgourW3oBSW9vAiAg6WdC35A2\ntiU0Zzul550w6MpZRPmGpr1xqKQn83k7zg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISASnUDOI17LOjh+Kg18t+N1BpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE5ZWQzYjgtZDlmOC00ODgxLWIzNDMtNGM1NmFlZWY3N2NmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjOWU5OGMz\nMS00M2VkLTQyZmQtOWYxZi03MDMwOWY2ZmIzZmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASU+rJNs6RD84Qp8S8SPj0AHoPybLIUJkQ0vOtFtV76hK4uuCCJ6kWj\nvwKbxkx7YWgG6cyFhOAuBcB5nZTfEDn0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSvy21H\nQKCrhNVKi2O2cMjlxEQk6jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgXec94s/3L59EeAOJUBJmWSyuRjvGwdWGoyrV\nhwvYdD0CIAj/dAyg1Rm2HihYgWmYSvH/Zzc8jY3jOlLmzXyAYOQj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6423", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6423` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAbDz6GVj+0834LBMy9lnP8z4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NjhmNmY2LTFhZmYtNGQ2OC04ZmZlLWMyY2ZkNGY3N2E4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA3YTM2ZGUtOTc3\nMS00OWJlLWE1ZGYtMzUxZjFjYTQ2NjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEncW7VAioV3vBofPrrVolG4yQ7b75HTJwirbV6id/dyQ2ROfcCYbsiThR9Kph\n0pm8xw26iWmyot4VS4u9axeph6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd5t+0b94ME4p05dRtldub9vymv8wHwYDVR0j\nBBgwFoAUlnvpuUSfO5Bfymnt4M/WxiAz93EwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIBFwRPE/Gir/xUKqZGeFDM3hy1eFuQY1/o/rBnnLOdlsAiBb+b7r\n2qGHuLihrW6jH2ASlLHgOAzX19coSy4oeaQeEw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAThEmhk2GfST5xgiwN/MHx+KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTY4ZjZmNi0xYWZmLTRkNjgtOGZmZS1jMmNmZDRmNzdhOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3kZJhfaRaa3I6/wvExxu1FLCBASOKFFvICJtRprHbXe2k\n9o3/bMtA+lXogfQOFXoTfgwgmA2UEjSr7Ly1xxb4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlnvpuUSfO5Bfymnt4M/WxiAz\n93EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO6rfqbdXKu2PWVyV1ve8t6ZpRfLCv19kCp74mAfOpQjAiA59TG9gNmE\nxmtcEvpVYVHKzYArhhbHs2ck8gI46kpffQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAYQ+I7HbGqPNNuFsE4Cd5SosMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA3YTM2ZGUtOTc3MS00OWJlLWE1ZGYtMzUxZjFjYTQ2NjMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmOTdlZDIy\nNi0yMDllLTQ3YmQtYTczZS1lZTFjMzBlOTc2NjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASLzvzIUeNPge/QRoO/2H9TOz4ij5UZ0viKxgPorIR8TqIfxlwkeDQk\nRJa4XQcVPxqGNirOkAdhen6yS0jbWHuZo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR3m37R\nv3gwTinTl1G2V25v2/Ka/zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhALY3JrsU+An6TPlfZK2ADRm4jmCFK/ufQJdK\nxukflK7VAiEA1xwFeTYJ5JFa+NcuP7+84Iws2cRoEjr075lEU459gaA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6424", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6424` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUQafogaoRKRu05AknG+Z/LMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhYTVmMmQ5LTBhNTktNDhjNi05ZWRmLWYyZDNlYTAxNDJlZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE1OTJmYjktOTI4\nZS00ODliLWE3YjAtOGIwNjRjODY1OTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgmyPsXlkKBORreg/E5RmR0XHI8QIrnBuYR+bU6AiPNKMuyHRvcQptykkOEQd\nAS7C07GU/Cc3/XRS6pY7G5Uax6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDT1GwUug1E2QkSRvV7dd+wXlE08MB8GA1UdIwQY\nMBaAFP0fnkGCs1pAew6A6VKsrjw2klYGMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAuiPh44JeRQNiaWtrXqi3KBhbRPmaYLtE\nG77My3YH5KACIFwIPmu7SpqWls89AJ4PWR7rpspsfVjHzZ2dolHOAO62\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQHqIhypnjk6UZ79bXB/I31KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWE1ZjJkOS0wYTU5LTQ4YzYtOWVkZi1mMmQzZWEwMTQyZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2Sd5PZCVYUEe2hzY0yzen4IV8/Uz6E9Ld43iGm+eQvfwv\nqkZPUuYav+Adm3Fw3bKlqZ13ib/p2AZE5NTIiRUFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/R+eQYKzWkB7DoDpUqyuPDaS\nVgYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXwKz+vnCi9fkK59tE5b5SS7skv7jZHjQWmCbKtNheTcCIGtHbv6lWkkh\nzlDPTDbBXiW1+dc2KC4iTET+BC8pmvhG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAYukmXCeTFkjSNYdJ5xb/lfxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE1OTJmYjktOTI4ZS00ODliLWE3YjAtOGIwNjRjODY1OTgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhMWNlYmVi\nNS1iYmQ2LTRhYzEtODQyZS1jZWMzZDFkMjM1YWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATU3huYZbhYp3rwVSqndFBX/rvB8rZ4bqNAGomcphp/2OhFWHM9iuxl\n/lcMEcfsR1m+eIfxXB3CEZy6bpCD6aJvo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ09RsF\nLoNRNkJEkb1e3XfsF5RNPDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgUwFz+cMKLnjw6UMbnBdsXz9aPeGI+4vHMbFe\n8UdUzOUCIFxEXkVJPPBrx9wKj63zjhIXV2EEYA1SZDEJFNk5mIkp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6425", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6425` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAerWMVCsZFZMm1jt/wzb2610MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxNDE2M2M5LTU2OTEtNGU5NC1hNjM0LTE3YzQwMDk1YTJkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjViNDZiODItOTk2\nYy00MDk4LTliY2ItNGUzMDE5MmJmZGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6YDUG4fidd0Gh1LNk0ZgJ1EbagJhmHRci9g9v5He1qahT7A7/1RM15Blg416\n3KrrZwZg0ALZrJNR7yQcYOlT1aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCiL2fgEA0+VPNAQTt6VG9J9AoFMwHwYDVR0j\nBBgwFoAUZLTGFU3vqw/pJLyTFsaV33Iet6UwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAL8lVDRmH9D5\nZmlb3VZQDfMQbWVPZD6ryp2ORE1VzpPBAiEAhH6MGbK5GifLuRyKhyCyL3Z1jv3K\nIXiBO6sSg/OqBEI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ2IgoPpETpm2H03izF8K3bXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTQxNjNjOS01NjkxLTRlOTQtYTYzNC0xN2M0MDA5NWEyZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9RcU3CUFq5V9OnSiVo8/NGaouqHqdynAU3gpLvDbiqL3K\n1nZQgsor4xeBLDVqShNSR63qwetrZdbHIOGwROWho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZLTGFU3vqw/pJLyTFsaV33Ie\nt6UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ1Vs3YZLiDOchlOQG0Af/jOCkkv+v78e0LW9zzsfpKqAiEAmDHO4sXy\nWB+xHfGHlAyL4phOtloTLxvBLW6GzyahCII=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAY3JGw9ccOSYxHoy0A020TyCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjViNDZiODItOTk2Yy00MDk4LTliY2ItNGUzMDE5MmJmZGI5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYjBiZTFm\nNy01YTdjLTQ5NTItYTY2NC0wNWQzYmU1N2M0YzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARG1Is5cPXqcnF8E9QRxLRsKQVzRZpv8W5lHynaT1cwQT0MaEfKT1lq\n/46MwTOpSj9De/VEt8eyhyQYsadS2Sp6o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQKIvZ+\nAQDT5U80BBO3pUb0n0CgUzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgE6hoXch8DOsOtbTl/qYjCKqdbkVtoseRracM\nz0EWLDgCIE2UDVe68SXj4PrFGp4suwjxVmpy4cNqWeg5YqWN5kuY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6426", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6426` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAcjFx1TDqXxAMzHTSW6j06maMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwOTU3NzM2LTdlODctNDRmYy04ODc1LTM0YWFmZDlhNGUzZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjkwNmYwNDktYmUy\nYi00MmU5LWFkZGUtMmFjN2UwNzhiNDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECprEWMQzM3oFeKfVzw9dxXaGvR5tHkswjzwk59oLUz9NjUrulnIJV5E3Hbtz\nL0k5BzIsvHZTCI1xfPtmpLxp1KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUft58/sKqF04fuDt1I0UcG6vDHiIwHwYDVR0j\nBBgwFoAUW+qi04pgJCvX2nUvpAfyrQWYMRswKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgMakTyShqwLQd\neI5yWld65Ddh3OgUr+guBQVMpabQgEYCIA6KDr/yVmQvLslG0JAipqltAv6xOh0o\nfYRZtoRc+LyY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaMitzR1K2BsD+E3uvuF0F3JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDk1NzczNi03ZTg3LTQ0ZmMtODg3NS0zNGFhZmQ5YTRlM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWqsJUHeclRmo9qR+C08IBXtSt+SyxLv1J3XZfl+/WNB8i\nGOFYxTCKK20ZbkugluJuC2/FORGq2QYc6qtIidgFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW+qi04pgJCvX2nUvpAfyrQWY\nMRswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHQh+UMKv/77KneU0Zk3wA61qacUT1kgu76QHyPooAeoCIDZ+luf1OyWz\nEW7M9z8Jc/0T/bQ8P6CRX2VB2m5ne+2/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAXSTgY97TWsGwy3JqAMTTGrGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjkwNmYwNDktYmUyYi00MmU5LWFkZGUtMmFjN2UwNzhiNDc3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlY2ZkMjgy\nMS0zYjAyLTQ2NTQtOWQ0My04ZjlhMDk3MDczZmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARte/g+bkRHz4jPIp6T5uI2+Dz+ch3eOnCBF6wQvb93Z+No68R1sulX\nQzWHJQt7qCNG39dmOA8p+hWbicTdNgyho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+3nz+\nwqoXTh+4O3UjRRwbq8MeIjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIBRzhmxEFpyZDFspgGQNvukehIYEctCHxZt\nfFRuvYilAiEArfpTaHNnOTH8Gn3xgDrraF20WKno0YcaW9LVSquoyD0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6427", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6427` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQFwHtmiFGCXkC+To5GZPcuCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3NjY5OGIyLTYzM2QtNDI2NC05MjNkLTBkOGQxMzkxZDdjZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjYzN2M2NWUtZjE3\nMy00ZDc2LTgzNmEtMTM0YWZhMDRjNzVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfHkhO+sLNBzbOh+yvrs0Rr7+6KBRBjm90LZdd6GmJ7fx/ZZ+5alfHF2Hdxkr\nZd3MuNiMzeY4X4KSlxCf9BRqUqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHdzpMdPNZ9E1wpZW5964q5YiV9YwHwYDVR0j\nBBgwFoAUfLksuSpH7GPo8A+W0YTwxZRGOlswKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGFcZdn+Q6be\n3IlVPOZD4dxY9klUVy/QTucCNEPwloOcAiEArbvq7eSK6QGJhMYhlyUb1DF++wYv\n5M1JUfZtLDkg7YA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAclO/zMzk+eWxxxR0ajeG7inMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzY2OThiMi02MzNkLTQyNjQtOTIzZC0wZDhkMTM5MWQ3Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9LQ6vjovrGVhN83eA5yLXjvxA7MT4U9heZJ3pivd/Jn+3\nMPATw6EHQ1rNAsUxfjeoO9VKlx2BtbZOix85Uzeco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfLksuSpH7GPo8A+W0YTwxZRG\nOlswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfn/Gur6cnH9C1xbw5ogLtoLArjoCewp5ZMp3rOhZHdkCIQCx7ajneT8d\nvVXdBRZU9LelK0Wg5HJtiat9tsROtWV8tw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAbTXbrhWqIkwKnetjC5V6FalMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjYzN2M2NWUtZjE3My00ZDc2LTgzNmEtMTM0YWZhMDRjNzVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MzQwZGMy\nNi03MzhlLTQ3Y2EtYTQ5MC0wZDgxZGIwNDY3MzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ2h51fJj8FTrFxXwP8rbH45NuXuUEYw8d+racidVEsWXXF1yTGwyzM\nfuFxuvYdBJdmLLl+nYyKxeEtm/YAQzN8o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQd3Okx\n081n0TXCllbn3rirliJX1jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJ3y6DPVAFjNMzWEezMcbHeb+gtxJxWvtBXo\nmy7MKJSrAiEAiF8WCJT+PtXG3h+YmDGMqHZxEZueXH5SLKNKQ4ReJ8A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6428", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6428` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZcLNhi7Rjy/CisNvdVvcSMrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhZjlhODE5LWNhM2ItNDU1OC1iMGM5LTMwNzE0NGEyOTA1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZkZWE4NmMtOWI4\nNy00ZjI2LTkyNDMtNTQxZDA3NmRkYjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiqLBERgc1o2nKMckpcKQhRstWcUYVuy5YK+95do+NO/Qoxk1L/+wU6RtEPJK\nIXCPV5Kn0z8dBqA+l9khSVf1dKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWn+z9Ifis/TcbNaTE84+OT93wQ0wHwYDVR0j\nBBgwFoAUL0yfbuoDsQc1DHF98mZtDIrDuPcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIC+bMX3PzCjSj4kMKjD2vpQRrsbmIlDIhevBGIIYs+KDAiAmC68j/ishuUSy\nGtolyfpmGiR8rRC5YocnsehPhzrxTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARIP80PWJ1XOI6ztRVxmdm+LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWY5YTgxOS1jYTNiLTQ1NTgtYjBjOS0zMDcxNDRhMjkwNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTOeHnOjb4otrkE4e6m4WOYHI3uLLhW8PyClG/MkLyvmdS\nqMQSC6O0CPaOFRMqjXuQpTtP4CGyjmRd0zO4G82Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL0yfbuoDsQc1DHF98mZtDIrD\nuPcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOMa+d1SBeFfPqcjPVnNNis4u/zHbTefzutexaR+n30oAiBjjyDptJPE\nhLfPqXrVfJtk+OfT7k8ByUbuyYv6OzT9EQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAVaGb5FVXQK8+nkra3fVzRMXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZkZWE4NmMtOWI4Ny00ZjI2LTkyNDMtNTQxZDA3NmRkYjRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3NzVmM2M1\nOS1hNTI5LTQ4OWUtOTAwMy1kYzc5N2IwMDMxYTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR5slqpqd3vtXn92rH+1MKfy/DMOVGcqKKIskQ7EnXAZLas40Ozkrj5\nkvOgrJr25sF8qzwcoLVCwidNNEUrvbVxo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRaf7P0\nh+Kz9Nxs1pMTzj45P3fBDTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIbxjQAhTuAOg/D+tjDHHWHgwAtJmB0TpX/f\ntCB8RMJIAiEA3vvv7uERVIT9JhaRtr3KGC843oTmIrXJEVhaoQpxRh4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6429", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6429` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAcki/zn4TJp48NlbVL1gnsyHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NmNlODdjLTQzYTAtNGFjZS05ZGFjLTNiMDcyN2JiZmRiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ4NDNhNWMtYTQ0\nMC00YjhkLTllNWYtN2Q3YzYyZmQyNzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEJ74UR2FDOMnt9YZhMCKsScIgIF7YguTb55B3MV/5YQMRKpUuQ+d++gpMtWI\nf2KWvKBy0Xivizy0hppLl7iAuaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUse5jUt2tPPvt0hvyhgnva5ofkuEwHwYDVR0j\nBBgwFoAUfSi5okcXuEruL2qrPqcE27S3UQEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHARDNj1pxeBbBjxQsJtzhfkHgW5t7tKZW+WfEto+KRiAiBKA3cKZ19m3FV3\n1/c7QlN21N/zZJc/sIpF/R+9VOzGWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbtkc0com0g4drL+nJrDGFGsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDZjZTg3Yy00M2EwLTRhY2UtOWRhYy0zYjA3MjdiYmZkYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUXx/E83Ad1Nmi3RzmxMZerfhinc6BoAyFZonFH8NK+/5M\ne5MvicfTn5lZoHXhx9XgQebdvjP2oKPgGJWYsSRNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfSi5okcXuEruL2qrPqcE27S3\nUQEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLJ9+gjWXfnL/rAB8wmNnoN09IpdYqyKTdS3EJ0qwQ0sCIFVCq6EyzUB6\nbQT7jAuHfoCcl9Q/HCOCKcSGiwyDjlhz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAWVdtk097nfufuur6DPjDI8oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ4NDNhNWMtYTQ0MC00YjhkLTllNWYtN2Q3YzYyZmQyNzYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMDQ1YTYw\nYS1jMjRkLTRiYjEtOWQ2YS0yMWNjMDBiZGU1M2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASGBX77fnnAQyNIr1dc86/su57bYyBiqCFJEBqurYHNnaLlyuAbwfuF\nJ2Z+R5yW9MM20Wd02zOJS+AHw7PAKhsAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSx7mNS\n3a08++3SG/KGCe9rmh+S4TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgZbyfiHolAGEWDVdGH64yi0LHXPxEST/xj4Kz\nmnt6vBYCIEs8QLUpZ4PQ8yyg8kq3RZIuyCTUt+XskdLOenW8v8u+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6430", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6430` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAbH6zoa5L3fmU+K/XsuRilNbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3M2E4MTkzLTExNTQtNGJjYi05OWZiLTkyYTk1NjgzNmQyNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBkZGQwNzAtOGYy\nNS00ZmJiLWEwYzMtMGM1MGIxNTRjMTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi2lVN0xkGUYlNO0Hv6KDomQCMIjjrcL6MbyG3E+OSS8bdPzNSa8l/1W35clG\njnf2ptIxf3Pbo/H9tcT1RbKDQKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVJpOw6xsDWcizBpp5XhdIb2KkUMwHwYDVR0j\nBBgwFoAUeBRJ7z/j4OFw9cEdpwM7n/jAIkUwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCw\nhY0x8gRopd/ogglnGqfwufMDcSMEFXlU7+6WCarKMQIhANZn7+qsD/RPHrvYlskI\nlVlJNJc0euaOzQNOQt1W47iM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARWjSyHIaQTlv1R1jwmFRkncMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzNhODE5My0xMTU0LTRiY2ItOTlmYi05MmE5NTY4MzZkMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmxi1n0E0i/OEffTFeoNt479ICwmM2rCLuG8F9ddzONmej\n8a5GCFKt+t07aUzU1WBbvtrVPi3Ny4v8FTXoWXLko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBRJ7z/j4OFw9cEdpwM7n/jA\nIkUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK+5ge1yf8lswuq48WTSIdd24Ma4vZBE/mg1ho7k0BaSAiBQrvcNBhNg\n+dSXdsSp4eYjC0FW73g7dg92T4XLDqyOqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAX+fS+i0MzSZh76uS2lCLNULMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBkZGQwNzAtOGYyNS00ZmJiLWEwYzMtMGM1MGIxNTRjMTdiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNmQ1MmI4\nYi0zMDg4LTQwM2YtOTNjOC0xN2M0NGM5MThjYjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARc77ZuPxl4B9zezYHnUZ854H/962srQnHBSMdN/XFsIjenOXxlaPJa\n2xdjleb05tvDC/EaUZ99nBzkx+6QLztQo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUmk7D\nrGwNZyLMGmnleF0hvYqRQzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgDcx8xwVm+Bl8jj/FD9xIgWOrwn/pyvlcUurv\nkaMohAcCIQD11zhjdfJt5jMM+Xn/QFl9BLX0EWVY1UIboMbOln+g1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6431", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6431` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcC7d6t10oCX8zvrMp2OYPUoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2Yjk4MWFmLTI5ZWItNGQxMy04Y2Q4LTFkMWY1NGNkOTI2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI0NzM2MjEtYmE5\nZi00MDUzLWJmNzAtMzBmNTk2YTE3YzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5Nwf7qd4hOhO971H//+nkpqZfkl8ywItUJWnp9+mBF9is1RvRNmlaP1P7gaB\nmX3gCHQsYCwcJilROQb1fYnt3aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfUmLy3QuvyneCOJPGJ3NLsdvQKwwHwYDVR0j\nBBgwFoAUhNe+Fcd0ePtaNAssZhmknF35abkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBVXr7gUV1qds7gYyr9z2Pf9UAGtBkA4Uk5EaDTGEvzbAiEAg+VQ\nAhqlZ7EZJuQtCRDdh5zoonK1GP4Yk6sV350a1tY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS/MpfWJHiAcPYJG9ZKhV8m0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmI5ODFhZi0yOWViLTRkMTMtOGNkOC0xZDFmNTRjZDkyNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2WxY2yVXHe1gCZutVSjfAEFI1UObaz/ULBBuE9TBwLXlD\nuVSTdlAR67zY/NCMt4qjH6Tgd4V9waSQccRX2Exro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhNe+Fcd0ePtaNAssZhmknF35\nabkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ+hYqWBAdJzfsI7XCMo5ydC8qg2mpD3Gd84HxBma+a9AiEAtb+GPHAo\nzG92Qm/ObESHhk3BXH6ynHjMr0Di94l23W0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISATWjOlqcFun7xW6EsGJHduNRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI0NzM2MjEtYmE5Zi00MDUzLWJmNzAtMzBmNTk2YTE3YzFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkN2MyNTgx\nZi1mZjY4LTRhZjItYjY1MC1mZGFlMGY5NTViMmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAThLBoVAoEpPWe0PsfMuzmP5XLFzVY9SNdZAcGh+HpghRURMWITfnDL\ntjF4z3m5LWZwWYhCXxu/PPCnJajXvW3Ho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9SYvL\ndC6/Kd4I4k8Ync0ux29ArDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhALpG74TcSIR/6FqQaeqf41ffJl8EuGR84G18\ncYY7ouxbAiByNYTjtbQ36h64Kj2hNhzB6aJaoEC8FqFGmA5ATjzEew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6432", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6432` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAd3Qv9WnQvK9srkKGC50MiAGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyM2MyZjdkLWY4MzktNDA2Yi1hNjk3LWNlMmQyYTczYzMwZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRhMDYwN2UtMjRl\nYi00ZTc3LThjOGItOTljNzRkMTYxN2MzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDwquUnAVHvHRtc3RgpR+tcfqSsomIXItZDRJG53MESmmxcx0YIT8OC44hYqg\njJPG5SPIRj3f/BVx5jpIe3Wn6KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvvLY4AA1xBqnvgl6qk5nA1vI9TEwHwYDVR0j\nBBgwFoAUS5PTfe2B4Nt8h6cAIp8kLqWOD3YwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCxt3FATZmr8YZHrXwr7X5CLsv+goSXaeDjmVxi33up7wIgMLn4\nCcV0UxdyaNTKgbNxkzHzxZJzFhgUE8DmPgKYpAQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARVqmelVm/NblfGwlRD2tqy0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjNjMmY3ZC1mODM5LTQwNmItYTY5Ny1jZTJkMmE3M2MzMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6OFipWqAHF6iCal2rQoubbJ2fKDFiQhUNtF69k6kBZoMr\n+Jouh4EtwW+TUVGaeCTnvermLOZBFi0KUy3+aXFHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS5PTfe2B4Nt8h6cAIp8kLqWO\nD3YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAVc1eypSD0bx+PKxhjpry7lTgLIzWd+qiZ+DFEwdk1cCIQDbZBpSFOmX\ndtXxKPOSFBlH9QAMM6z5xDy0FzFRL09vMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAfYXRelfLR8qABaQ1EomVx2KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRhMDYwN2UtMjRlYi00ZTc3LThjOGItOTljNzRkMTYxN2MzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMzMyMjY1\nMy1lMTVjLTQ2NGQtOWViOS0zODdkODRkMjcwMzUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9IH7+gVrQRueCHXMYmHXNxMPWXOzBBoSayNM0YpCuN7Vc2u4Zx6FO\n3Xd8LOdlQCIO25d6ea5nA33RBYrHbNgIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+8tjg\nADXEGqe+CXqqTmcDW8j1MTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIjXRQXOFomCrnqI3ATw1yJgiwJHltK5fK8x\nSYEqXHFaAiA+PL6XyzpJEZQSBJCfL8djpF55AMnHbWPgHA28VurUMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6433", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6433` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAftKgcuNaYHubEjBKp7AJZaTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1YTZmZGU1LTk4ZDctNDkyMy1hYTE0LTdiNTA5YWUzMTgwMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdkYTA0NGQtNWU3\nMy00ZDViLWExZTYtMmY5MTA1OWNhODA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmefTxIMPT9F6z0CTKbHNJgpvu5OtcMIZJ6d/d1vcj/O/Ay6McZ21m+ai18oo\nkQlJhK2qYO221CxYy4e/iVhzKKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTKYSLwcdc9etCY5VbauYB4xdCf8zAfBgNVHSME\nGDAWgBQP7I5xBvU49uCQdm+9Zsf4BswRrjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGpWvjw8okU9VjcSH5bxiPUmuEPSM8nx\nCLV4IqySWyASAiEAvRh9V217l0CN2nbig7Ejbjj8CWSLsAXgPyd8xMvBDps=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV+Y2wY7YOUVsUKSP28W7QcfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWE2ZmRlNS05OGQ3LTQ5MjMtYWExNC03YjUwOWFlMzE4MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2zIe97CvrEOtcO/iDdtS2lISPRdDzr8/WkKAjcirSXM1d\nUanlq6dyMdO5rXJ2n4dYxbgPanJ74C2lKqNUyRBko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD+yOcQb1OPbgkHZvvWbH+AbM\nEa4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTqtyl0spy3elR7raI+B9LvocreYG8iAx4Uulqwt/iVYCIQDgiZkyxtSn\nfYVVYfweXhQ2Obs8/MkBussWu/rLTPKNUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZxVJ5C4cbo3p5ctTG7As3/rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdkYTA0NGQtNWU3My00ZDViLWExZTYtMmY5MTA1OWNhODA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNmU3Njgy\nZi0yOWEwLTQzNDktODM4My0wODI5NmM5MTYyYWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAScknnJ+B80+DuqWrbqiGWYR+ET+7/nPd6vfbvIWWWYY5uclVT1rqFN\nfPuy6QMI6PFgiNHHUYxZRfhvGpswROvpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKYSLw\ncdc9etCY5VbauYB4xdCf8zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMdBE2iiuZ1aUacNLUzFl0+oN04rc9662w4y\nexpAaIJOAiBSfJkUk1WcIpg6/ktFJfqnADSMA4cjMX0M5m0g8nEAqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6434", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6434` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASujpZBFqa+IbCyknSmyCUnxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1YmY5MDNiLTRjMjEtNDE0YS05NmE3LTNlNGFiMGEzMGI4OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzcxY2Q0Y2YtZWM2\nMi00ZmZlLWJlNmYtNzM4NWVjY2M3ZTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOfN7dJHpnek5dgE6wW114ANub3R88v3Xxj93fkPH1WL87zewZRDPIfDvp7D4\n/lfBR6LzEONYRSSiz998y/kCQKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4LJ3DToFCSTyfoFC4FQZWCVWpjAwHwYDVR0j\nBBgwFoAUmriRpPmWNr8xvXIGwapdtHS0zT8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIFZcjxyedL6z\nkUYczTRjBxq6eM/VbkX7ke3j+WRJaQiGAiEA4Rf7gtTythSMyOioqMMILG9yM4HL\nkI6kRlwgm02wMLo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ+pPE4d85G4Z7kxea0dzafQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWJmOTAzYi00YzIxLTQxNGEtOTZhNy0zZTRhYjBhMzBiODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnGTRc1ZiUHlCK3O2crtmAd98Cw0S5yOsJCKZnRdtMAMLl\n96sGdOSsVoEG1ero8Wn8fOssBtDK2H4UeUAirdKDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmriRpPmWNr8xvXIGwapdtHS0\nzT8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIHJ//6yY8TD8rti23glFmS/LSd2qpKtydQhVXI6JtKtAiACnSDo97nW\nvTf+95cvEYxJvYIcO+ZeKqVWYRgpFijC9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAR6+iSZbGuPujAXHqZk4Pb9VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzcxY2Q0Y2YtZWM2Mi00ZmZlLWJlNmYtNzM4NWVjY2M3ZTgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNWYxMDk5\nOC1kNDA2LTRmYTItYTI1ZC05ZDMxN2QyNzQwNjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQp88oGjSilwEtnETT0qKUdRwgQC6hEu3vfCdIHjOfpsb8Tbp5isOy/\nihKjXMN+PwFI148u1z6DPLF9ffmyN73do3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTgsncN\nOgUJJPJ+gULgVBlYJVamMDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOQ40Cq6Puf5+gLi8XFRghVip8KtDBSOq8Dv\nQCp2oewTAiEAoWWnR4Kv85q1bo8hRc3Vp/7hlzjI3nx8d6zkoL02Few=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6435", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6435` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWXrbpQttQkkBI/k0qgH27m/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4YzM2OWQyLTJmNTEtNDYxOC1iMDZmLTdhY2UzZjRiOWE5NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZiYzdiZWYtYWUy\nNy00NmZmLWI5MzItYmFmMjhjMWVmMzBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXnQ0Ak3SUrI58yiTKOQd6LK0vwEFYkwlitpFLwk8o0jp9vcesE0DCSHrXQNW\n1is+YLccV0zUDGHj8HjjFfXmlqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC+mJQWa4lCtZb0boZ9AjI7zS2GswHwYDVR0j\nBBgwFoAUOnw0I821wEASbnBOdMNneZG9L+IwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIFzVWP9t10n7\nZI9MCRWMqWQWQGo6CtZ9j4GqVn8a5BO3AiEAiCVWE5OvkzMW0CshNKbiQr2TjX2x\nDVGGCry6YQrXot4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUGZxv+5IRHz6bIlyO6+aBOxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGMzNjlkMi0yZjUxLTQ2MTgtYjA2Zi03YWNlM2Y0YjlhOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtpDlyhj6/lW5faQhw1cF8iBclh4kcj+dVvA5zBEl2CX6b\nEIIJbXIZYFKwObCtJPq+6PV4Ih4pSCqcQGKTEtKPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOnw0I821wEASbnBOdMNneZG9\nL+IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHWUUN2tw1TQRJTNflmlPWxWNf+4A+YcJgxsT4RiGePECIQCBurIGhgdt\nfUAFKooSeDVZ6ntT3lTNo1YWW8K8AVcqcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAZTwesHm9vaB7lWS8vKDNh0jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZiYzdiZWYtYWUyNy00NmZmLWI5MzItYmFmMjhjMWVmMzBhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNTRlN2Vk\nMC1kMDBjLTRjNmItYmU5MC1jMDgzN2YyOTcwZjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARSxWuhWPweabaThts15u+YmYwkTBqHPvoZmMGzPS10TR0/9DQrk2B0\ntpLP5Vh405FGpGuhWHJ75Vt15T+mHQUKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQL6YlB\nZriUK1lvRuhn0CMjvNLYazAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJgqbywoavSiccEXABNkPuJt68oyqN9g1MMB\nkYyQzMz5AiEA8wQPINgEYfqEB6aOj1p5rEWPfBZWXdFriZkTs84TowA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6436", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6436` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAWJZzEAKiBz3w+Y5+wkjrKu+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4Zjk5NTQ2LTk0ZGItNDcyZS1iZjE3LWE0OGY4YmRiNTg3NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBlZGYwMDgtYjU4\nYi00ZDJlLTg2NmQtMzk2NjAzNzVjM2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf+sZOI/aK9mFHBSPves4DJyQKv4DmgtKms0EocZjbCLWWXXBAOw69EGbSgLC\nTmDxUfbswN2uYrAf/lKpy4iwPKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZkFGGIWc3Q+Y8fSp6Kuoniellf4wHwYDVR0j\nBBgwFoAUFTJ6EhsvNdqaJxlw99yl3gIZ830wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAzIS/WrEHU\n0132ubFcHK/Ftyu/ZcIrZ/FUHzAE5cPJDwIhALVA4Cpkx6Mz0sUd7EAUOxKzz+JD\nwRphLV14ye4LFr76\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc96eyCw5GFVqCv8DiSyEKmzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGY5OTU0Ni05NGRiLTQ3MmUtYmYxNy1hNDhmOGJkYjU4NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAdy6MRn2dAH6IpJ/J9U6H/mKeTDEamDUdnx5d5k/uBlI+\nE9B4DFJUwcXKnDhLNA7TwlzK+O1X3o9GQ7JyTjdso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFTJ6EhsvNdqaJxlw99yl3gIZ\n830wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEz2AS+AmfXMtjIdm8iy3Usadt9+r3qvIA34uNgpn/X8CIQDYhkf9OZSt\ncAv62StCh8YjIb9AHtc9EF+0JwXRTmESQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQGX7+1FrPcAtmWZEQDiIUsiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBlZGYwMDgtYjU4Yi00ZDJlLTg2NmQtMzk2NjAzNzVjM2Q3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYzVhYWM2\nNS01MzAzLTQ3MzAtOGM2Zi1hNjNkNTViZWY5ZDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARUQUNWmC8IpqSLJ4UZlRS03dhrV8G+YiK+Zh6cBVhHPwqsOJXNIexh\nvBATmvg5H2YtAv3/wprwIrRifRtaIVPWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmQUYY\nhZzdD5jx9Knoq6ieJ6WV/jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgQSYLjjkvLSpNacWdeuJXq/LZWKOORHOmaPVE\nlkhOxpECIQCpO5IlFsTlWfe2so2/jBGuclQ4eI9jK77a1Ud+KJTypg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6437", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6437` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfYnNp74H27nrfU3lInLa3duMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyYTc0MDVjLTFhY2UtNDFhMi1hN2RhLTI2MmU4OTk2MjA4NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDMwODg1NzMtM2Rl\nYi00YmIwLTgyMTItY2U0MWMwMTI5ZTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnxKdpIbdbFddAeGryWVuBA2SgWlJLI0A/RnMlTuyD9Y+GTmk7tye+/A6WACy\ng5HY2TXYIxg6rftMzzYYmDA/qaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmdd7fBbFqK7gDUaTf7H3l1QBlz4wHwYDVR0j\nBBgwFoAUdH3QmJKEmMn8LF7MNBow44Yo4YswNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiAz3WkQGoI/LjjSmQL0AKBeFcKFV2MxpwJce0X48yqYywIhAP6+tyW6koI2\nJS92T55Wt2+h5EiyD7tQgnCceTKgsRw6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZzYQ59z3+NI7o8oCtwcfaQYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmE3NDA1Yy0xYWNlLTQxYTItYTdkYS0yNjJlODk5NjIwODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTpIG9I9XwB+RV6iwJ5NigeFhqWVpycSWf3ECNT0thD5DS\nQLglNSwSnrb0syE7/7DQBgU/ZFSSBZ914t6yj/ulo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdH3QmJKEmMn8LF7MNBow44Yo\n4YswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfFmW+46f0oWskIbZZk1MU5njQm2NR+7jlt1+xACGaW8CIQCKL09Eik0B\nRw5GGU0/uWE13A+sI2tly0g2AKRJDDDBmA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAVIii6V147QzqU79G6B07eNxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDMwODg1NzMtM2RlYi00YmIwLTgyMTItY2U0MWMwMTI5ZTdjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYmNjMTg3\nNC05YTZlLTQxNTctYTllZi1lM2E3YTE4NDc4NTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQXP/XtAYDq9G+1EcNzUTV7ljdSSZYbrwH7QUe83e7cgL8pRmwq0apD\nJo5KsBz7dUM4SPeuD6Xxe1fShxZxf8ooo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZ13t8\nFsWoruANRpN/sfeXVAGXPjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhANQsb0xI2BIP4PK6w/XGozUbnu9KKs03vG+c\n46XquOBBAiEAuWhoiybBRpXJ0vf+ZR0MP4XF/8fYn2FvOqES+GLkPec=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6438", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6438` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZSoPD1z6/bISYiadyNogHs/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZjA3NjBiLTM4NmQtNGY5Zi1iZjFmLTdlYTc3MzJhYWU4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM1YjRjZjItM2Zm\nZi00ODA5LThkOGYtNjEzNDIxZjAxMjNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwsrIfnSOYJqS4lW1OORijlQcCdxtGmHZbhirE0u15bI+KS+/usgWhyk5VtfJ\nXecKjBjPec7wQy4SC3tlmfRU8qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu8Fw0Ycpu1BjemsJ/nn+r9ejnfcwHwYDVR0j\nBBgwFoAU5Ik79RpfqgGa+Sw2nUCiJARV+okwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAqhTziuqxloy3MN14AWIGUJrMg+sNp3moVKTxoIAGt5AIhAP4S8YssIcVW\nMBmtIEl+h2IUv0mc0dlghaAz0U42dUss\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXVImF5qTDAgiSmI1h4Xn1FwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmYwNzYwYi0zODZkLTRmOWYtYmYxZi03ZWE3NzMyYWFlOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd6xsUGdQ3aPmyyyigYUtbz4o8I0W775+BOUpH5rFMWlSs\n1VovSXTM2AmAi+zt27946h/tS0k/4WoX3ScQjkIqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Ik79RpfqgGa+Sw2nUCiJARV\n+okwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPKWZKb+GIC0GYtAlY7dHFPEcOCPkiEMWqq6ubEJRGmEAiEA/WCdq6FS\n5n9tcMbF5QDXappmJrCYzoNidPa6sMX79PU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAckTTyDA66lSTsl5fNVVeVjIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM1YjRjZjItM2ZmZi00ODA5LThkOGYtNjEzNDIxZjAxMjNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZWNhZmM2\nMC0xZDYzLTQ3MzktYjk3Zi01Y2UzODQxZWExMGEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARoYwPp/4GibL44qPwJDAx6Qma8Vp4H+OBO6ZMWWL+z6bC87HTAMdQw\nXWsfq/fVY36nW1QBwk4bxqfr7ZVOdjVxo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7wXDR\nhym7UGN6awn+ef6v16Od9zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgRpsNlwEh2L4ia4nh3x/+h8WB3uA3lW0iUYsx\niYRaa0UCIQC/fYTBsM0JwzuChL4N3ex0L02YHx5oC2pfEAqIaKa2vg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6439", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6439` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAZEgGKX72HwdIzebKiLj9gPrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0NGY0OWM4LTllODAtNDU3Yi05MzQ3LWY1M2QxOTgwMmVjYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc0OGMyOWEtNjk2\nZC00NDljLTkyZWUtMzlmNjZiMjBhNjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE61L91x60xIQThrShOX1hfbvqp9bNncEmCUbPU8JlqBUbSsdrhJze1/HocZCa\noLoDECoVUshEl0yZ4pvxKH+OeKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU27tNgqd+lq5bh3jxaIAwIYzJu/0wHwYDVR0j\nBBgwFoAUWnhQaZqnijBpn3cJBOCsjpaBU7YwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAf\nXBVM/hqyUNPELf00H9ZbJG/fvm/19+EqCZvIYvwV/wIhAKjTkfyvbnBFmIUwbud4\nofY3JuK/zlgXNJI4wEQUu0i0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVXXetAylJ4cx1RLnVRSPRgCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDRmNDljOC05ZTgwLTQ1N2ItOTM0Ny1mNTNkMTk4MDJlY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW27AysV4jrC7Jvz8MW8zSo9d9b2ETmD78casG8HCH3NzV\n5oj5VYc/HGRqdUWkXm5cFGEWqpG/H+cu2XvCeg9xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWnhQaZqnijBpn3cJBOCsjpaB\nU7YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPFuoUgdaQLWeWuhl1FL7OQmdZaomQqSxZ6BPyc156PEAiAUHlqPq/1r\n20ZwdCdSH5xr9llo9xdaTn+Ndk+o/QmVIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAd0yLtZjdatNJqZ67FcY6Rd6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc0OGMyOWEtNjk2ZC00NDljLTkyZWUtMzlmNjZiMjBhNjBiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZTYyMzE1\nMC02YTQzLTQ4NTUtOTMxZi0xM2QyMWE1ODk1NjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASF8sEptJm6evkyd6KNcum1YG/rHkLDroMGtZl5tmkijQoR72DH1wY3\nTyfmUYHO7p6rKO5LPI4gHp83kzh11kkao3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTbu02C\np36WrluHePFogDAhjMm7/TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgY4rfo0vtdxzuzJYRDEW9SPsyoiI3TwTCEhmt\nBSvDOpICIHnSvgB7mUvY/ti09HSVOfb1YM6m5V1gMMBfQdsLGjTY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6440", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6440` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAb7Zx0yaYH+JMObapCf6w1PzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZDZlMTFiLWFhMDQtNGY5Yi05ZjU0LTNiYzFlZjczMjU4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI3Nzg2MGMtMTBi\nMS00MDhlLTg5NjUtYWY5MzU0ZjU2NGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8e6KdmrFsMcUTOIrW3gNIuOMKxa8w9nRgx18e+YR//JH6jje1GomvxyrsWWt\n0c1ewcm0D8TWlXFPTYFDj3IAGqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0hl0eL70qh+XCWRkbtXjO9N0O30wHwYDVR0j\nBBgwFoAUQUX6mymK8ylVXwkN1eU6au1mG9gwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAi9EC3WJN7C1cJkf//XoI4XB/iMDMssNyEIp7731n1nwCIFZN\nXjxOCyrWsZXu3AiZsjrG2Gc6/l/zGWH9IgRz2aXt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXMgB+YNthgjlpoN71YAxYd3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmQ2ZTExYi1hYTA0LTRmOWItOWY1NC0zYmMxZWY3MzI1OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScJRdVtT37FlkFlqDxzi2Pagf99VCDIYD5M+3xKPEVI+Yc\ntCEbh6EIFu5PK6s6ccAyITtWueIsFYgkhVy1z7eRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQUX6mymK8ylVXwkN1eU6au1m\nG9gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ68W0eJ1BKJoYiIFgCIBGsbndwAjy+zlFR+zmC/L7QnAiA6lt428EWX\nefX7HCkGJUvliw6BSs9MURsCtV8mpQvYEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAW8lvvcBXT5ThEkT6XBkCJwaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI3Nzg2MGMtMTBiMS00MDhlLTg5NjUtYWY5MzU0ZjU2NGRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNWRiYzIw\nNC01NmQ2LTRiZGQtOGVjNS01MzdkNTIyOGFhMTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR5/H/MvT/fn0wOJiTztu9G+BsGS05UkXdDHJtFmsmKZGCgloKZNVAK\nn943+URlKGJOmVt1rKQuo6oXmOUdT30Eo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSGXR4\nvvSqH5cJZGRu1eM703Q7fTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKxgmA30SpKDJ1Ty+JwZb1IiUP8bIFZyuH4I\n5U2xrQtvAiBZ4WVXfx2Ko/t+VkcOmb2C9ywW49ybPsHD6LwBboO5yQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6441", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6441` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAZrdUDiRrHiKx7Gip8+3d1sfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkYTcwNjQ1LWE1ZDQtNGM0ZS1hNDA5LWYyZjlhY2RjMjkxNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYzMTZjZDEtZTg0\nZi00NjJkLWE3OWItZGVlYjllMzM3YThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESpjqawx0zWNDAFQ/Y9t8KKop7HTbJEY0Bn8FfsFVgMK/yo7lV0q2JNRX2XqH\nAYlvUWMRDpihmbpR3jpwN3sPtaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0o3L5ktSf1+EI1+ZK49S3xhvQlgwHwYDVR0j\nBBgwFoAU26HZ4ziZ8RHgTXrjetap+NjKo8IwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAhTRDlxFeUW8wvRtNxOXUd6EhylHrxDkalOZyqKu8H2gCIQDm\n4w1wCuQQVj9x/7h/GO3tc31gYbCb5SxwhK3MmqpGqA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdNa6MM5SJ5lzoBCzlu3B3pyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGE3MDY0NS1hNWQ0LTRjNGUtYTQwOS1mMmY5YWNkYzI5MTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATY1IXDflh1lAagBgs6XEXOZBfOKqCjmh04XbzxDp1W/zSo\nIBJO48MiOnaXuInVeszhyHJl9F6NLJ/oCzxKYB4Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU26HZ4ziZ8RHgTXrjetap+NjK\no8IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALF+HBHXESMiPIn3I+eGPKR1z+H0hxkFU/+r8DtzA+XuAiBKmEHpr5hL\nM49XkIChGX7mNEBGfqZG5HDNdePnDP/ULA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAW4VVZXNV8Sr+yMkWqJjBD0kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYzMTZjZDEtZTg0Zi00NjJkLWE3OWItZGVlYjllMzM3YThmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZWQwNzg5\nYi0yZTljLTQ5OGItOTk5Zi0zYmU3YjA5MjBlZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARNzUkUByTOoIo4uQ84ucYXawJLF1b8wRhdi1XJZiKEeuV8TidB6ikQ\njNhqctpbJFMkux00E/fVDtxU/N/PZ3Xko3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSjcvm\nS1J/X4QjX5krj1LfGG9CWDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAK+0sShCJ22m47c/CisvGKeL67GoMcLFyee/\nrSY0MlB4AiEA10AZ5KAGadZaUnE26mW6cPKmt0730yLbu8XBwEcex7w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6442", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6442` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAUxtALCRsD6gaw992G6+f52nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ODgzNmQwLTIzMGUtNDQwZC1hYzYxLTc0NDVlZGE3MTZkNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNjNWQwMjYtZjMw\nZS00ZTZhLTllOTUtNWZiZWRmZTJiNzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFZwdM8rQ/LsO9OWZdAdVg/8JIJplC/KkBYBj/wzMGlOlq2tipkeoQk1441ZZ\nC5h0pNyrBtz20B3idmft+9rR5KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1cZ8KP3A1Dq408V9CnVq76qMTAswHwYDVR0j\nBBgwFoAU7Dc+RGh5iwKkvNTNPlnQ9I4Vmy8wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBDyQga3ufRbV7q\nMrxBdzXJ54rFwkIyBuPjh8VTbFXJTQIgWWBRXSohU6ZmwRIShGYR2pQRmHapXLmM\n8kEq+cvD1r4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcWZmiPVaHXMZMAQFbz6rvfdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTg4MzZkMC0yMzBlLTQ0MGQtYWM2MS03NDQ1ZWRhNzE2ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdx7Ki+MTdBXcoLrWFnWxFMj1LJ8Xn9Y9ERRq+WrznRmSw\nXeqld4BWTs/p2DxmwZ9cFAXBoG0pI6HH80GKr/Xzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Dc+RGh5iwKkvNTNPlnQ9I4V\nmy8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKK2gYXSykm8wcmdgZ4uyEWZYHKbpJDvHn6dyW7QV1fcAiBUa76LE7x9\n+pWuoqp7ifOVZ/w2Akr+oWt/TT7i670Rcw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAXd2yNOfgs0E32Ci/Cu2AaRCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNjNWQwMjYtZjMwZS00ZTZhLTllOTUtNWZiZWRmZTJiNzJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZGQ5ODlk\nMC1kYjRkLTQwMTAtOWYwNS04ZWI5MGZkNzNlMGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATe7b0VURaQlchDmbaBHUVz91VO8xkYrMM6q3Iso4/eO+QhXQ4EiQUK\nyR2CDgZYISslnhuem5475TUi/Tf7SuRwo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVxnwo\n/cDUOrjTxX0KdWrvqoxMCzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIOwEVowFZl6J7lCPSpeprblZl6SIT0sM0zM\nIxcaeLghAiEAs3rp7bwmh/Ai3INZ4VRbm8ysCCGqg6fMRl4/Gk9JOzU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6443", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6443` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAchxJuCVAer07wZy7WSkhO4JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhNTc4OWZkLTU2MmYtNDA2Ni04NTllLTQ1NTZiNjdlOTZiZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDAyNzgzZmItNmI1\nMC00ZTY2LWFlMzctNzg4YzlmNTQ1ZGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFybvqbSkhrrSlqPMmCfwqr9Qm7LCqICfnUveXSFXT8qDQfeaYemTQ4sC3DG2\nSes0nGOVevT8zYYWhuakzGRvy6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR6cpCcZusbnp103M1sePNhwtQcQwHwYDVR0j\nBBgwFoAUy3naiLoz9TXaGe3VOOmkLtUfsQkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIECt23q21NgNcLdIz1ZpEM99Cf/FfGjpsQZjBfglkHoKAiBOo9bXoVobXzCh\nzTwTMzkMuJvNxpp7TQtmuvIeRI4sUw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARHtYGS/UAZ+UmvfZMhgqxQfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTU3ODlmZC01NjJmLTQwNjYtODU5ZS00NTU2YjY3ZTk2YmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpJkYITnrzJDrwdhyCW9D6KcpBAERMmvVHnpNqivpseIHC\nm+h3k4DOP98/JmsIelav9HYtCbVcAEJhHH6xyTCVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy3naiLoz9TXaGe3VOOmkLtUf\nsQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLFL09LWgvoDwFmsepB9gm0qFFeZtQ1+4JYDvi8CXllwCIQCaduWMpJ4y\nbqUzz1Rzps40sxRg2N91ig68i9yD4oXI2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWN3vIwUIpR4+Y6hcDfXdRleMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDAyNzgzZmItNmI1MC00ZTY2LWFlMzctNzg4YzlmNTQ1ZGU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZmI0OTkz\nMy0wMzJiLTQ3M2ItYjRhMS05MTc2NjQ4NzZiMzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARjRZ+XuYS6eCQMpDv3LmAA3DrOAxMatCDs+m3MZAvVy1r5pMvQPGBy\nbF8mf4Ovtgr/vttqvxIUJLr8/PlD74Yro3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHpykJ\nxm6xuenXTczWx482HC1BxDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIpYC7BvOCHBIfOzRWkix2LSUACBbsBXNtsN\nfwg+jTpcAiAtiBi3KgIYW+X8FtNYHNyKt+NGvkMgx7/MZnBaE7vP5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6444", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6444` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAf49rn8isoHGpYjMwrVEjrBKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkYTA1OTgwLTJmNGYtNDYxNy1iMjdjLThkM2YzNmZmMTJhYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E4MjY0MjYtZmQ2\nNi00MjBkLWIxNTctYTlkZjdkM2MxYTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaOyAAnuig4eLZ44sMptSwo3mdRXdFtUqaZxU6LkGmy72K0QwrxQJ+KbHzb1J\nBlRqBHBsoGvcQ1pNdhLddX0NZ6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb60XnrxtizDbIf2b/aytwqAKwcwwHwYDVR0j\nBBgwFoAUM5dTNQCLnX7LL8WY4z2ilFiKBy4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDa7xBbzwarXakl5bUsEFn8XgHjJwVzgtGxHpZR5Ic4YwIhAIcxpNG+YQJx\nh1LXqxDisvrtiWz/huZjasuru1fHR/SY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcHd/q6qqEZZmtA3Dp4BnjlzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGEwNTk4MC0yZjRmLTQ2MTctYjI3Yy04ZDNmMzZmZjEyYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6QoMTv/IjPB6Pul5+iQXmv1qQ6TCAJz0821fYWYQGCc1N\np8lcXdUqwwcsLelUGezqipDgloOWkbyT2wlLqMgZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM5dTNQCLnX7LL8WY4z2ilFiK\nBy4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHKCwjDikNI79JcU8u1CWdiAJRETNpEmB4WxZ9un0Lo0CIHiJA8uBaoYs\nINFJ2R6gKdTA+jb5m0HJ+isMqfgzsRcC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAbglTQm/7P4fR+KciINOnrELMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E4MjY0MjYtZmQ2Ni00MjBkLWIxNTctYTlkZjdkM2MxYTgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MDUyMzQw\nYy05YzBjLTQ5M2YtYWQxZi02NWZhZWViM2RlMDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATaAEXBIv6sbyCzX4LHT6jLl7i4Bql9YPNXHQ/iaXSzCiyrsemNQbcZ\nNEnrhalmQoTS+/9ZwjWINl9dE/Y4X2TZo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvrRee\nvG2LMNsh/Zv9rK3CoArBzDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgPk/Hl3bTdWdQB2nPAS2WGjmgjg9M2pQ4ykOI\nOBh/vrECID/JMu45wlUkbYRgAEwP8FHiHO94tKp9nrwep4kCxm6y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6445", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6445` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAYjS5YbBG2pAcGmMTq3pXHXdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNWUwYjU0LTVjYjEtNGEwNi05YWU2LTVkMGJkMDAyZTQ3YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM1ZDBkYmQtMzgw\nMi00MDhjLThiYWYtNTcyNWY3MTJmMmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtZ/quTqZ/oflS2Q7uv+kT7lmSRQheDW+YAW19bqS/lW/bxUUMkvxa4QcWHv2\nJuu4qZF5y9d6lNQWo1a+y3Wq4qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGXp9RZCq829hQaupkiCSXNg0fhMwHwYDVR0j\nBBgwFoAUW3zTJ11h2KhnA6czMGGcIJLtu7cwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAmG9eq+rIGeygmbU4ZVCy28CqnyRpiY8gACEZnkvH1FsCIQDmDQqmOWzD\n59XuRJfNshHMAzd4KYRhaKI88DSm0Qa/+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXvQvr8m9LZVZ0NMDhqLQKcVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjVlMGI1NC01Y2IxLTRhMDYtOWFlNi01ZDBiZDAwMmU0N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxreFZ90d+5KjgTJ5nxIF6STMaovt1QcY3QJTF8v88eNer\nvyQhG6Yeg4LI391Rt+6T6mNHkujVEZoMjW+XsAVqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW3zTJ11h2KhnA6czMGGcIJLt\nu7cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHANqN1S3OMW2Voy4Rj0jDUn4Fa8Ec9UATmk8s7bnLcwCIEt/Jl7RGbp6\nRzF8kBCK4ntwxka+eQSiSqxbcAFXTV2b\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAdaO78yndxibH7ffltCugxtfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM1ZDBkYmQtMzgwMi00MDhjLThiYWYtNTcyNWY3MTJmMmExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMmI5ZjQ0\nYy0yNTZiLTRjZjEtOWQ3Ny05ZjgzOGM2MGVlNGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASRI70kqIr6PX3jSrWo4dS/2nC8YUO2ytDVdsEOZ5E9dZSIpiqsyf0G\nZTc4RxDJ1KGq9bmC3VIKni/nrDq5XLyIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZen1F\nkKrzb2FBq6mSIJJc2DR+EzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKLQn8rn0xec4wpCPTXOqfoWUwPoL0Z6wHLS\nhpxStv8EAiEAiaj+uegX34uE7zLHpv8zqQE4WHnS9gkLfHTTicuYu6k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6446", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6446` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWYCZYEo5tv/r+WMxMpBrnBuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NjQyMTM1LWUzMDgtNDM4OS1hMmI3LTdkYzVlOTZlNzdlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE5MTFkMjYtMjY5\nNi00OGQwLWEyZDYtOTVlMDk2ODRmZWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBfXwA1L2vuKCCYlXye4ZozBF3evEkJGJQB5sTBaqABs2yr44s3noLvl6g74q\nKG5r9nCWvIa2OLZGO1m9Qc+5+qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaqTbuAvz0P6Cq1n8xHiqipSQ2m8wHwYDVR0j\nBBgwFoAUckIpmJ38L6sNeE/rFRotefNDYvIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAq6yd/pIzlulRjyqL7I3REsXtdqoSYfvXigIZWvGR\nI/ICIEPDu42ny7SQvOVHEc/ryE4E+ir3pJkwtBrCpXznPPkI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWymVPYSNnFX5RYYMxz4z7BiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDY0MjEzNS1lMzA4LTQzODktYTJiNy03ZGM1ZTk2ZTc3ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMsHqJClWcG93ILr140L13p6bi/CnqJG9iiDUtEjhRE3+g\np7mhr9WC9UDuSdeqT3d0FLZSexpGzOvdo0jHGcw2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUckIpmJ38L6sNeE/rFRotefND\nYvIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSnzSZAlzuIhB4//vj4zsPlhZUScEmC57nMYQ465aaJ4CIBCh2/tYm9bJ\nYCsex2kzgSL0iPvThRC3Ej2BIlYbVejx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAQ8JieQNIxjhTlZtg/l6V8xFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE5MTFkMjYtMjY5Ni00OGQwLWEyZDYtOTVlMDk2ODRmZWVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ODM5NGEw\nZC04NjRlLTRiZWMtYWE1OS1jMWExMmVkNzJjYjUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASYeYK96qHez/Lz9Df8ucj+sfRDDDGHIFP9bIKIyFtLWrXZQ3ZDu4sk\nXjrkDq3OeHvKVqacDHvfsNicApnr+gkMo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqpNu4\nC/PQ/oKrWfzEeKqKlJDabzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAO57iqOl+qQvS8nnIi0f5HLRV4U3On4LgSQC\nbOaj8Ui9AiEAl2JutH1WCN6yLfoJstNuO2t/2L+NaMzdzpbCj7Z6HKk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6447", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6447` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAWOTackZ3/RwLDBeCihXPhZwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhYWMxOWI5LWRkZTctNDE1YS05NDk3LWJhYTE0Zjg3NGI4OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjljNTdiZjMtMmYy\nNy00YTFlLWJiMDEtNTkwNmVjNDYzY2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDANbuil5FXVPRe9n+qWU5/v3gf6lKFxI/VSkZitS7yATNEq6fc36w0AP7FVW\nelOm8X275dXtJuxDPY8Kv7yifKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY3ubYmWYWWdQ4hC1tjOHDLCVkdEwHwYDVR0j\nBBgwFoAU3XPywD0DVcltBhs66/jH0H4y3iswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA+GaA0pML+Fa43yVSsmEffxU/fCPq3VcqhJpooZZO\nkdgCIQCEWzY/asjq8E22M7/4rdA0dAGXAM8V2f0lISE2Y7jvpg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATvRyfICN3m40aFLRXGKx35hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWFjMTliOS1kZGU3LTQxNWEtOTQ5Ny1iYWExNGY4NzRiODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZuypHoVkqK7FIPgWgBlCVLb294JFCGKzmdK62SiUH+dEK\noIanEWXHtyOAe+oCuELD2YO0k9bVsHw0uqDc5q8ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3XPywD0DVcltBhs66/jH0H4y\n3iswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANJnKXazR7PAgEa9JdMXWmoIT6Unxya4ZSM4YEZthLOYAiEAtrPbGda5\nZT1OOMUezxQ+V0Ra+Mv3l+pxD3tz61iTWJQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAe0iXDLSfnHU1U14tUXW2ixpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjljNTdiZjMtMmYyNy00YTFlLWJiMDEtNTkwNmVjNDYzY2I3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZGIyZWZi\nNS0zZGU0LTQyY2UtODllMy03NGZiYjA1OTczZGYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATevy608tfzcMAHL3z/ygUo5VnwXrLa/Pd4SpwQwHr8rFcvUKuXNvj+\nC7sQEqFBuyMBELvaHDl90AbFa1zeFSMho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRje5ti\nZZhZZ1DiELW2M4cMsJWR0TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhALbhJ3NwCvL0euBm0VfUmNyMhRkqiUEVdDOZ\nrlxzvNgCAiEAzxXPFjJQlH9kr1LYxmJLhTOJR/bda1248VAebVegnQA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6448", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6448` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAYpSruWcL4qD/ukPH+g4Ly3kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliMjRmZmQzLWJjYTItNGQyMi04ZWVhLWRkMzA2YTBjODE5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjU3NGRkMWItZjJk\nNS00NThlLWIxNzgtOGE3MDk4NDNjYzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUo+N0xy7CuGEM53pNoqbconVTlJYLtxcgr+eQyyRqWAGAW7Zh3F5WU7ZdhV4\nQtS06aGgWbTYBc0nlDr9YYrD16OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKU3lDxWQb2zk0vE5OIlk0Y829SAwHwYDVR0j\nBBgwFoAUC3lmXcj4qCm9xKTfqP+dsuBS2qQwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiB+2SGg6iB2qEz/fwZP7pbdbpqKkFSJ2rDCMt1XKG/euAIgb15H\nEOe0AsSV9axNuiOwWmXyn+bXhF8Ai/Xpv2sBlIs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbJv0BYVJuAO6LFRS2It2IaMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjI0ZmZkMy1iY2EyLTRkMjItOGVlYS1kZDMwNmEwYzgxOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsQ0axCSKI+yLtfo5DYNFlsYMgZfLoulPfBjBqunDg+HhJ\n37P/PmBnykcNGTYJ3fSFCZyoVsqr+xfr4Ca+JC+Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC3lmXcj4qCm9xKTfqP+dsuBS\n2qQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALFhCZEbFafwfw7dph3zqHY0yHIVt1JHgjP2qu7Kfqm9AiBMhf/kIrUN\nopppJdB3OYFQQxhQBwfsQ1p3/BPJCi3yow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAf49pPFzf4h+z8O8rW/vnXasMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjU3NGRkMWItZjJkNS00NThlLWIxNzgtOGE3MDk4NDNjYzY5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyODI1ZDA3\nYS05NmM3LTQ4YmItOWZjMS1lYTk2NTc4ZGM4NWYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASagKYKQ/K8lsu81pBs7rlnEtnqbS6XkOwNM6Q3Hz3eUWq0P/G1NvXl\nUmWt8WQtCKUPU2U1u7BM11Nx3etWgeNao3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQpTeUP\nFZBvbOTS8Tk4iWTRjzb1IDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhALBRwo5lCpTSsV7hvQFRkHvnneMR4G4ROCBA\nYLJ8oAqWAiA3oVbSj9FNkyvw4NocqjbFIKEAswW0PUYJpl4LszERew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6449", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6449` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAXq77DivzMzuIhqMJ+XXASDVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlODljOGE5LThlOWQtNGRiOS04NGFhLTMwMDcyMWMwODZhNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJkMmRmYjMtMmY3\nMS00OTBhLTgxMWYtMDU5ZmMyOTgzNTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+k4qpHoZNtARuLJ7FxXeNYLRxlwl6Rrtq7B513dn3u5zlDjaROckI3FFlLPL\nhcf3jKqjFH7uJLqx4oHOYaYB8qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtF+ClqW9L9HCaYqG1GnswLf1wtYwHwYDVR0j\nBBgwFoAUV4JEYi5nvCB6FC3Ez0zHWObUyqEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBMhz5u8Ng/hQdfbiAs3vJK9NnV/BjM84YT\nIBftw5D0AgIgAnLtUgkiDvcn9l/47SvamirCLKtjfaEFspOnVLwwWfA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT2BLTUf5oss6uZ0t1IgyQiRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTg5YzhhOS04ZTlkLTRkYjktODRhYS0zMDA3MjFjMDg2YTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/Ym7uA71p4PYIymf2kh6PgH8Z6rurenQwWDK3/rO9X+c8\n3IMcJolExrx1RslKgA4fDt9z+D0WaUSeMY+lb+xlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV4JEYi5nvCB6FC3Ez0zHWObU\nyqEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSIPQ7EQ8aJmcHsqBhMfxWG14Jw+1LkXTRSm1gj2+MYkCIQDePhADp3hP\nKvENuy1WoyZdwdd9sPZdpgj0gRQWqCWG4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAclDx9dDylCXjUMY7KoyC/m8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJkMmRmYjMtMmY3MS00OTBhLTgxMWYtMDU5ZmMyOTgzNTYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3YjgwZjAx\nYy05ZWRjLTRiNmQtYmQyMS0yNjc5OWQyMDFjMTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQYSyrjJMyauCgvUNXNxyD58WYu16XiXS2/vssKJh57faOAaNQsujFd\n5xW2rRMLPjV7jyQ9Ea4m57kz+wezzPw3o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0X4KW\npb0v0cJpiobUaezAt/XC1jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgQ/a9Gwxr67tiVl+lsRFOL5pA6P7BebI3/dYp\nS43GpRoCIQDT3d1d++8grqTEr+BzDDmvAQveo2RIU3xKKp67aQ96YQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6450", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6450` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAWZYIg3KfgszwI+jfZ1hFCfRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3NjUyM2JmLWM1YzgtNGI0Ny1hNjg2LTUzYmNkMmE3NjM0NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVkM2VlMWYtM2E5\nMC00NGZkLWE0ZDEtZDM5OWM0M2Y0MGY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Mbb4Exa6Yd8sr3dYGvThVtmNDPFbI07xeNI47mtQrFTeP1hnsbOCCUoTnGa\nOQVZLarmx9tmb61y9yN0w2s82qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFkwJFxpldWk0lrkeGhu/R0uznSUwHwYDVR0j\nBBgwFoAU8g81zbIpU8gdFYqRwwNTof1sGK0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAGDKQDDNsxR3ayNXM4u+nU6MPVWslpQwGQ\ngEvirFOLZAIhAPHWXNblF8oM+hLE8k8JRuuNJ+VZWRbcEKgCpN0SkekU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAetjUNjdQ0HjBLUNZim4jPFnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzY1MjNiZi1jNWM4LTRiNDctYTY4Ni01M2JjZDJhNzYzNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATd2bXLNBsJUHlncPUFinLeF+qrJ5b39+tEmBYBuARwkVp4\nrs4vCl2TqouKUXc5olFENN3k2mcdhRu9VV+hnxZRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8g81zbIpU8gdFYqRwwNTof1s\nGK0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKxVTAR8IBwIj+zSzW+rWqxpKr8L7x0ipiL+lVyc/1CVAiB+IV14uv2u\nTtmeRT3D0pyqDTwW+IwP70Va7ee4TuiqVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAacY5c8LAwrfT1Gysc425NazMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVkM2VlMWYtM2E5MC00NGZkLWE0ZDEtZDM5OWM0M2Y0MGY1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxNjMzZTU0\nYy03ODcyLTRiMWQtYWI2Ny0wNjMxYjk3NTllN2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQDJM9oM9ALS8PP/J5GSsSPbTU3kq2h21/RMhii8BmAAM0kM0CrwlMx\n6iufFgnVYXosJcjvfcGMZDQxnKWA1RyKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQWTAkX\nGmV1aTSWuR4aG79HS7OdJTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgQmZ8LcyzbwtVqWQYuSNxl+zCJdcp7a3zEdDw\n+0uMoJECIQDjMHJNgch4xbO/wOcrjZGawhxO0Gj7hu33xnA8uMHPTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6451", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6451` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISASsJkD9/ct85CfYAReWsw9DdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxMjAxYTRkLWJjNTktNGMyOC1iMTkxLTFjMzY0YjRkOTM4YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE3MmY4YzktNjZj\nYy00ZDkzLWE4YmItMDI2MjQxNWVhMmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDGSTYPTLw6WYlRxLHUD+tVozuK6/zw/ZqlE411/dlAH4TFAdm0FU5RvhA2Jr\nUT5+0MLgJP3y4Tp5gQAOR8qUD6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD3WtZuLVse59IcdlQCpwmS0m9wAwHwYDVR0j\nBBgwFoAUflw5mn/37pHo0MArn6hK+4d0bGIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAqTzd/wMKPXCs\nBEfTvrb0q4rONhyPUtQx9MZ+DinmghoCIQDfdJrof/1XXd+YZua4DKYtGkCMiBNC\nWs2kdDMSlZorKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZNHPcCINsd/Why3BdftyVfIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTIwMWE0ZC1iYzU5LTRjMjgtYjE5MS0xYzM2NGI0ZDkzOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfQlJC6WlrQ22rpYlfHu5YFMWB+DALL0hIiSa0pLdZ0kzL\nGZ2YKuICagB5Zjqfbsz17BeT2cEgxjhEm2Y3B0gxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUflw5mn/37pHo0MArn6hK+4d0\nbGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALGdh2w/F6tZ7VOp0XRyQwU5J+cqIZRZYK8E3XtxGU3QAiEA1w3cryti\nZHEFKtOLnz0zI/I8vj6iGNTcfWQ6n0XHgxc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAbyHFbrgZ9OCSaZS39KDI+yeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE3MmY4YzktNjZjYy00ZDkzLWE4YmItMDI2MjQxNWVhMmYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZTJkNTI3\nZS01MTdlLTQ1YjktYjY4MS1mM2EyNGZlMThjMDcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATJQWOghGDQaIO6AYEa+3S22kZYAZzlHjf72Mac+w835yYlBZTm2upl\nLjBjcn5tsT5mZtyfTyeAJ/6NVzfas86xo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPda1m\n4tWx7n0hx2VAKnCZLSb3ADAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgJQ7ReBXTOUD7VSDH9IWXQjR8NqRwduD1da0+\nsTrP7tACIBx2XwOJPP9CgG8XOLTuNp61K5KM7WYfTjPtNmtcK5sX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6452", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6452` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdSALHAs0zDvkhAY796OPxkEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwYjNkY2RjLTE2ZGItNGYzMi04YjM0LTQ4NTAzNTk3OWM3NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ0OTI2MGMtNTU4\nMi00MzNjLTgyNjgtMTM5NzlmZWVjNGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDnOgMCWanReZg4GuWW9TJ5nNYtbCLaJ6YGUMcGr0ONS22GYjyEtuyRcKTnBf\ncf7MZPshqcHOQjm1Q1QiVeukLqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYpBWzQIazHNGjiK/VrVTaPgUVMswHwYDVR0j\nBBgwFoAUSTRhohKhboF5hNTWXi3utRqu0EEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD3d6jZ1c8gyR5Rmtp2zabs2ldtF8r0nxps50FvBrtNEwIhAIy7jxtGBLvU\notrma+2cepkHkcfA065ItVXCtlFPLr9K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAes2SYqxlxWtIhboUzJlbc2eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMGIzZGNkYy0xNmRiLTRmMzItOGIzNC00ODUwMzU5NzljNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk9sNKfbVT5hxGoupxRaAUVrIiHpokQt0paHVu7o7AwmA8\nWTq3erNV21sz6OuC5/bLoh0aGFK7y0FoTYGr0mdho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSTRhohKhboF5hNTWXi3utRqu\n0EEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPANjydU7yKBT/8b0oIG9PmSG/3wn4ZviMafJUIuglFsAiEA9TOjobXu\nGEEFGXWk0i0PWNUZPAifxMXAFFf8fUW+Hsg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWqNcQbdHxpu8CnSijoKjA24MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ0OTI2MGMtNTU4Mi00MzNjLTgyNjgtMTM5NzlmZWVjNGFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MTNhOGE5\nYy1mYTUwLTRlZjEtYjNhNS1mNzU5MzgyNzViMTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR0+w5xZZrtMqLqRKyAdY6HNdbBQ3DJWu0+faS1ZDbEJZ5qrmQbGm1t\n2KZw4Tx7GPa8eNoRy4EwMmzpTYYHa34qo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRikFbN\nAhrMc0aOIr9WtVNo+BRUyzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgSfUIPShf8t+wG0/QXPLpoY9o65KMUXaAYmK5\nMyqatSoCIQCm1CfvPM6RdoaonTcFdzv1YDMxoXlwsLnq2Lyz45vDOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6453", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6453` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcQRgEa5kwQN31L7UuylsSjzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NWYwYzAzLTgyYTktNDdjMS05YzczLTdmYjI2NzkxODhkNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzE4YWY0MTItNGEx\nZC00NmVmLTliYzYtMTQyYTYxOTVlYjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+bZsTivBmsG4J2eUC6ZmgObhCqEETEedsxdEAFGaqq/6n2hix5S4W0bM93oV\nWsWvms9pH7BOW//hw0oHsZZrIaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKJgkx7vnThdxr59zYamp7GV0VRQwHwYDVR0j\nBBgwFoAUNlQK/7ALwQF8hd1yiMk/9wPy8bgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDmzGqnunuwr6yxZXUI6Lr/acBzdgSgh0MOQEXe6mcxGwIgbgBjJ2KGhQIo\nuQqXygycqoCDrDb6nYxastRESZU6x0o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYcDbxmwcP3KXDOY+Ig4qaCvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTVmMGMwMy04MmE5LTQ3YzEtOWM3My03ZmIyNjc5MTg4ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQla2ewgW4mHNB/TS71oUX8d4sHr509oy/AdMMXlWQnbOrz\nU6Gw0nddZDa3pahMwxM8C8vSGaEAhotFLdUXUfp3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNlQK/7ALwQF8hd1yiMk/9wPy\n8bgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI8nSvKn9nmgRwgYR1mT2dxRbvfjnQg1Y2ZA50fFgXgzAiAj3qNJUs3U\neKblhSVsZ3e2zYCSlNJMfk0S9DaGhzHBsQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAd3wUwKVBtGla0qfLePwlOwaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzE4YWY0MTItNGExZC00NmVmLTliYzYtMTQyYTYxOTVlYjg0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NjAwY2Fi\nOS04NDlhLTQ2YTEtYTJhZi0zZTk2YjA3M2JmNGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQP4ZdzEkVtisRrtsMiSJlosThVXqYqBZagZ6EmwiT3IbaY2xC5xO4m\nT2aB59QIktGX9L0N42s3Re6UH9WLSfTYo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQomCTH\nu+dOF3Gvn3NhqansZXRVFDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhANDKNvGHtOHYwGvj/WxWN2Ji63Iw+oFZ1vUx\n/us9H7dvAiAudCo0CcI1teDFG238lAcyOY4BIIJJ5MhXmsDkHmClwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6454", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6454` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAWqn7FilQXmq6PP9cA8YamtJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyYjY5NWE0LWZkNDktNGNjYi05NzM2LWYyZTAyMGU4MTRjMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ0NGQyNGMtMWE0\nOS00MjdlLWFhZjItNjVlNDlhNWE3NjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkYTTNn5/eF6mt8C5odSHjrhdmbRhC2eY9SBlOsjHvhPIPDNUuDlJOB6gvyVA\nUJa2Da/5d8fh7s7D6VD/8L5gsqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc9uELdA58qZSNOq7Bx8VUiRU5BMwHwYDVR0j\nBBgwFoAUCti3slSKJ1xY5VpcFNv3ycmlN3swNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBs/IBp0waT401VlBY42qjOEE3suLW1DptFB1y986KO1wIgRiMZp5tqmNoN\nqkKhhlu64ZYULMOQOsnnNiT+2/9xrxE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAda0bxiNKS/0nd+oonaMnDukMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmI2OTVhNC1mZDQ5LTRjY2ItOTczNi1mMmUwMjBlODE0YzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZYdND28vRCWlch00glQ/kHZvQUiZv8nMZ120AcA3MabdC\n7emvBnvtgWDuu6+E2RN7tZupcCBi4Cke/AhjVgXIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCti3slSKJ1xY5VpcFNv3ycml\nN3swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaZuwXVhRJ5e/O0vGBHWQFR0QarnRzj+JH/UX5/ch360CIAhgKd3V2ydX\nRUKZtoynUhMr+zSyeBDOKZ4XckMate//\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAXE2URDjFOfNDdguCjUIw03RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ0NGQyNGMtMWE0OS00MjdlLWFhZjItNjVlNDlhNWE3NjRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMDc3ODM2\nZC0wNmZmLTQyMzctYjExOS0yMjFlNTVlOWM5MWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAScphydetgLtPLUqB7Y+axSqf7FWtJcEwFXJmvxKr6c12ZlH3wmT5NM\nhselNFOCgXJViUzeGkZC+LJE2vtZGRm5o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRz24Qt\n0DnyplI06rsHHxVSJFTkEzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgTXYXhWmWZc1QOdpu5nZyACBnRldkR1eZJ8G3\nnKcI0K4CIEvppS5O/zTZOLgOgZdrcFY0whz9JivqDK8fl6KvVrLk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6455", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6455` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUnJ+MeKvYL8b/faet3mImvlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmMTg3NjljLTU2NWQtNDI4ZC1iODM1LTBlNzc1MzViMzkxZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZkMmJlMmYtZWY0\nNy00ZTQ4LWJmMTUtNDMwMDNhODdiOWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES5MIBhftvKU6vf76cZGU2GjkGubbBZHrPFwPbaSriYPIDLFU2pcCMUXOSl4j\nM470l3ocfn+S8GYpz7ciT+3DPaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8GoCO0rog9Pd8/j7ezy4ng/V5EkwHwYDVR0j\nBBgwFoAUdTCBND019GBNgq8qaabCl0new6EwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA+8eAxdD1in40qe2sibG+6nbMAEXucNSTxdLH4SCy\n6AQCIHRYBFA6He4RBSi8taesIhaDQ0hKKfLfqxlNXrwEkd4q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcqXWIzmnys1hQbkYyqJyBL5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjE4NzY5Yy01NjVkLTQyOGQtYjgzNS0wZTc3NTM1YjM5MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARscbGrKwRJkC3dP4wxi0hTgjLaQVU/iARdP3V9P4Yu+qMD\nZvr/R2DxGz6pm8NbMkBcqdTMDtxC1PillY1voMJ/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdTCBND019GBNgq8qaabCl0ne\nw6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKkxEEJy5ReBBIilNkvccDKPxehMinudSDWUU7xGd+A5AiAnC3nHWLiy\njtEokTGOaM1G5nBra0VuOL8SGYuhnLXdHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAQPiliiP1NoQro2M1O6cmNbHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZkMmJlMmYtZWY0Ny00ZTQ4LWJmMTUtNDMwMDNhODdiOWYxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNWVlMjJi\nMi1mOTA4LTQ3ZWItODJiZC04ZWMxOTc3MzlhMGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQlwUgY6eZoRruPIPL6Jtb+Z64+N7PvcxJs0FKyK0qbDKvMj31v1/PM\nk9KBd9UpAtqgiKfI5LIRSEf1C4dR70aJo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTwagI7\nSuiD093z+Pt7PLieD9XkSTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAPfoHIobD5j+u0hodGBWbKQGSnSuw0IjdOZX\nhwfHIycnAiEAnnNrHw+cTgnbvfRPVpkm/ixzXBxUP1I/6FLOTBXlapI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6456", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6456` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAb7F+YKMLOEGVuXtmM0CPCn8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxNGViMTcwLTM1YTktNDMyNC1hZjBjLTdkZDNkZWYxYmM5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgzYzQwM2MtMmMw\nZi00MDQ2LTk2MDAtNDMzNTJiZThiNThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/YKWgIQw/JlIsrHox6H2g/QtxP+QiQD5p7/DKH/aL9VJnjy4TU9fvuAz4TOv\n2e0jPAPtMuArd0SX4hGdKIfQIKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGnbpcchxC/PnEUIakTl4YEXZyvMwHwYDVR0j\nBBgwFoAULjs3E7K9qCiw7VdLVa1fU/plAzEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA/gQQewVMMF40tE6/+YT60DJGHj618ILwNeEeC9k/\n9pwCIQCjR24Fp8CfWE9VHglTEjNISIwGDIrdmsA+xL5vxTYidg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdaNnmAYZDuoYpcVX7mT2TJkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTRlYjE3MC0zNWE5LTQzMjQtYWYwYy03ZGQzZGVmMWJjOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbDQBoX0oIv0GHXAI+kFI7fsKNIuicisJuNp/NUgiAVVc0\n8IMypf9vlcRfrhFsYGYnSOMXPZFEDnSWfLEpLpHao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULjs3E7K9qCiw7VdLVa1fU/pl\nAzEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJuq852En12zo1vHmMe8oEzFvLRimCwo8FQRpj4KlUZiAiEA2dm5h28L\nP+hxcftJ4pt7ClyopXmoF/bt0K37j8j5q70=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAWk3CnLFPWeWDFN6Rq7+1oJmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgzYzQwM2MtMmMwZi00MDQ2LTk2MDAtNDMzNTJiZThiNThhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMThkNDZl\nOC03MGZlLTQyMDYtOTY0My00NjVhZjQ5ZDc5ZjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ7pN8jp1/DnHh8I2F/n1/ORpotMra2VrZEjhCmKhrtA00AU4tv3Xrp\nd6PDkW5SsqBh4qCe0UdstMyFphBxwZTyo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQadulx\nyHEL8+cRQhqROXhgRdnK8zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAMTe0S2xGN4foAldbAcMBfSoqQjn5bf0m9ZS\nPV181pgcAiEAzUM3pIEbf7/a4poPbjeXrf7taI4OkH86GSTdWKVRAwQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6457", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6457` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASIHavFJHBpKzqRBI/sIEz50MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhY2I0MTI2LWU5ODMtNDRiZC1iMTcyLTgwNTNhZjA0NWE1MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY2M2UxYTItZWI5\nNC00OWQ3LWI5ODMtMzI0ZDUzN2FmZGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMBZRk+YWcP9rKO58PJHegXKQO+BdysVxIZMH8W8gOwHTVQOrTQ3C8f27E1YZ\nNgiNDAuMQrY6l7VSTcuFSRK9fqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHOFoo1WOWyn8YyC+Npb+ixnINrwwHwYDVR0j\nBBgwFoAU3ogAUx/Eco6NdBBUya1JuYaJSyQwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA/jDN03rtBN1ToDr/u8UFPh922brsfpUkViJV16zfh6QCIFBn\njY0Ol+ZUvOtiK6Fvx5h5f9RC4dUrmIK3/PEDFQ2S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbP1ZQaitGnsEscDB0nCLAtUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWNiNDEyNi1lOTgzLTQ0YmQtYjE3Mi04MDUzYWYwNDVhNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm7hATPFEgQMT0MjbX7sqgSNr7Hty67XAkzU7amus/emcZ\nXI62Sr/kX0sp3hpDrQseqEXVCtGB71NSBmurW19go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ogAUx/Eco6NdBBUya1JuYaJ\nSyQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPKNmhp5PFPxnu3s4CESnBkddceC/qpTAioQRC0cEMfHAiBVYeiKBxwz\nJZ9OKtH1agkKS4Rf6VYGUoSVyF/lw8fYpA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAemcuaSoN+brfG5EtMHLlA2gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY2M2UxYTItZWI5NC00OWQ3LWI5ODMtMzI0ZDUzN2FmZGE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NDIzNDAx\nYi1mNTU5LTRlMjUtODA1NS02ZmEyYWU2YTUxYzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQG1HlRj+5DJIPoZiB074IruWzLRPKEIaXhbG5z6Ma9maghyzRP0ihe\nDHcQAnwfj/W35TI4PM7Sc6pBjHLVVJOco3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQc4Wij\nVY5bKfxjIL42lv6LGcg2vDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAL021qSqdZK4j2nras0lAP2BlRZlJm5m+Fda\n0LmOHfNPAiEAz18ksIjTgl6IvFK7gXyS1tR3X/395Pr2ZYVUCOjmCKs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6458", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6458` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQoWVx6XWaVlADHoydwGsz8DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyZmJmMjMwLWQzZmYtNGFjMC1iY2FkLTRjY2UzMjI5Y2RkMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc1ODIxYTctM2Mw\nNS00MmIwLWE2YjQtMzJhOGE2YjM1NjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERiMHfdh4Cc6XK9f5ikYXXYj6uchPWK+OEbl4ZGsJ9P6rcbwXQrw3yOFml/oU\n2sAhKorIJUo3Kp1MO/8wCAzUvqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU26qYfRsJ+IRKQHRAfQQrfK8ZAwIwHwYDVR0j\nBBgwFoAU7bG1OkB+HtXFtq4bOnvQpPoHMIQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBxENa2JvUPkTlbFXSMYbo8KxDoyOyE8qYb\nSwnsmcvZ0QIhAPs6213fsA16mjOnvhDGekyHTB6TWb4dGNNq6wVK43MB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQSyDZuA09P/qgjQrnlly3y2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmZiZjIzMC1kM2ZmLTRhYzAtYmNhZC00Y2NlMzIyOWNkZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpRIt1zwuWv9RaHEXixLzSvXWvMGrbgE1jfUI0he7XGGoY\niCKpfQBJTamYGfXEEnTt9ewqvMaftwnEWHpxjAN/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7bG1OkB+HtXFtq4bOnvQpPoH\nMIQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOuess9g+4jYKM0nK2T1VFvRZeEvTgwnk1us/axlc8r8AiEA+go73OGD\n1OqVmKCHkmfIPE2GsFmSSfXY7dr9XTKylXY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAfrJ//6eYS4jwCWWmW+H3il+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc1ODIxYTctM2MwNS00MmIwLWE2YjQtMzJhOGE2YjM1NjczMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzN2Q2ZWIw\nMC03OGQ2LTQ1YWQtYjc3YS0yOWE0Y2FkYjYwZTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQGR1dY6nINZ68gRRTfDzU0rPToSjxuopKPS/H7b/EArP+pDk/8SA9h\nlpmPHbUgSqIOQDaoA+jaVVdZ3het/x0vo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTbqph9\nGwn4hEpAdEB9BCt8rxkDAjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgYxqiNBR/JmwQI42TRs9I6NO/z4lIdbyPAJ6X\nmyhYaZsCIDJODVsTPwVdfU6qcs6f9a+pQyTGq1Agv3X0DEX4xZyx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6459", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6459` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISATVkv62/OI97JromQzq8C2ghMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4OTZjYzEzLTM5ZGYtNDVjOS1hYWM4LTE5NTk2N2U5MTRiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ5YWY5MjctMWUw\nZi00NTNmLWE5ZjMtOTZiYjNhYTViMDlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgA+/zI9m+7uY9kTySOh/oIotGdbEx91WRTEieYimG9BWFhiF8QvUnby1sOqS\nvJSRRHOKcMRIh1NMHacTDvyLB6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoILdou+p4/xSjHf5GdEjo3oTSI4wHwYDVR0j\nBBgwFoAUog/7ASQ8HshoIMo0lemj2/WWrrMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBa6VDv3l4zxFnQ1hqjU7XqtA3f0JPI5EJt\n2xymKMd6jQIhAJzvLn8Ces7yuYH+zdjMKrLzIxJhdftJiUiQDNAzEqWE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXYaArG23HSbRFBbBouZed1oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODk2Y2MxMy0zOWRmLTQ1YzktYWFjOC0xOTU5NjdlOTE0YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQs7UeucZINcI8zs6a7jL+GGF1/bB5Oc3p6Jl5SMtxh3rzZ\n8QcGD+utUKHxarhC5QEO0Z/7+kxQ6ihCI4i0ih+Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUog/7ASQ8HshoIMo0lemj2/WW\nrrMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXqfAUA7rPLGPO9/2jXy4X/unOjRbNh0AhAvDZeYXlx4CIQCrdhefRE/7\nSgVLNjqbF6yKG8Dix4RyDEvnfshuwfUqNQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAb7rKbt7/HZx2LoChINg8ppJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ5YWY5MjctMWUwZi00NTNmLWE5ZjMtOTZiYjNhYTViMDlmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhZThiYmQ4\nNC0wN2E2LTRiMDctYjk5OC04YzQ4Yzg0ZGU3YTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS3XsXoonWG6eH3Rz/3ZTIkpM/qA593GS/QOEmVHF+KGqDvq4HIGYrM\nHn7fiQrHp2ygqZAJtyTqYhWCZdn+DLavo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSggt2i\n76nj/FKMd/kZ0SOjehNIjjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIMJhh4VK2W0Apy8qJJo41BdlEzJzI53bDYN\noJkOZ227AiEAimbHP67zyIxDHNdZVHQ3lNhWnBG0x+GA2CQd4OqGb5s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6460", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6460` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAawGvuwubCdGFeidmVoTy/1NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ODMwY2M3LTYzNTYtNGM5MS1iMjNiLWFjNmZkMjkyNDc2ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFlMTY5YzAtZTg0\nMC00OWE3LWI2YmQtMzdlNjI3NTEzODg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgz/ivv/x1QANfxzrbj1hJtHm9F3cpEbN0qmbyUJfnIR5TrC0adi7rIodVnD0\nRp873hho3PQZLQQhTA/wDv8sMqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxyc/2kRhIwoX1ak9ctYuXq0GE04wHwYDVR0j\nBBgwFoAUL9QAdH7husw/UqtqgJRnMwf0UywwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDB7Bau3j7pvU57VA+6BWYcUUhoc\n4kRW9Xmp78DkL66mAiEA/ubEBeo569067qlWL6q7zI8Bl+PkzVYWA8/7UnqtBwY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcGUpoUEUSpM+ZWiF1AoKr6WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTgzMGNjNy02MzU2LTRjOTEtYjIzYi1hYzZmZDI5MjQ3NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJCXPM5rNLExCZqaK4pLQ4Mv85C2HI4sSAuJOJlx0b8RPK\nx3eqQO7oOK/fwZgSsN6/D5RHtk8S62pCTZbuDRS2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL9QAdH7husw/UqtqgJRnMwf0\nUywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCeE3BgSen2x+pnb2NVZtD53qBXFI+8LSbq2ssaQREzMCIQCaTOK5yC2F\niCjp4/qoGrk6YI5NJxm7jknE0SQZvj6S1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAV5ztgYh43hU4BEKN+LsOhhkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFlMTY5YzAtZTg0MC00OWE3LWI2YmQtMzdlNjI3NTEzODg2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZWNhZGVj\nYi1kNDViLTQ0OWUtOTRmNy0xM2ExYjNkMDdmYzIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQv3L1T1CBjSK/RS66h68RrO5T+YoSGeTEGB0vIAEUT2toeWA9Dfwrd\n25Z9cvjL1vWMjNXTu/Ou/qx5zgQU6D21o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTHJz/a\nRGEjChfVqT1y1i5erQYTTjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPcbUI0HP04nVyj12BUdycmLSNlbWRt1ygXT\nY0qMzW1oAiBpxckcxLrfm/J42RGAVX7nJyLMvNwDtyJGexrMQay/gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6461", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6461` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAewBNsOeeNBczj8Z6+jL3p5ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNjQ1OWNiLWU5NDUtNDFiYS1hZDRlLTNlZTRjZWY0ZDc3ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDIzYWEzOWEtYTYy\nYS00MmExLTkxNDYtZDJhYThiOWZmOTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELjRS1jT/iU6WJ+A/MFEmSywrPtw5kXw1uhNqRnUQ8/mkvBLCJnZ/BuId7GIW\n8+QW0JT4dfyB9n83IiXrHN4EtaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDoEofeZaT/4n4cnkE9NEw/nBWYowHwYDVR0j\nBBgwFoAUYVwtKzPksScR1bw4Gw8VrZtIYgkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALMC2BOj\nn4vxli6SxlkE/zzd09qJbVt9Yl43lNB10Q0XAiBk7s59JuMHm25ZSrigh6MAzBa1\noecfQW+EfPMA1a6TCQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb5Ky/QBwA4jqv1QtNUCAgPPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzY0NTljYi1lOTQ1LTQxYmEtYWQ0ZS0zZWU0Y2VmNGQ3N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOPHPZ7zbXFsMIwoPrdnfB77pTfiAKsl6Tkyd50t3CMUT2\nvzDJ3RY7zNSa2qHz0tOSqa09lrgvnjHife2/PMITo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYVwtKzPksScR1bw4Gw8VrZtI\nYgkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgegHhXtGEzMYVJO4gZktbQhDfzEubniQMeoKhpUcFfqACIEDPJA24rK1e\n1YCyzuLEV4vNX2SgnTfbJ/xFe0Hxq/Pu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAZEE5UMxlPFVGzSYf3brkny4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDIzYWEzOWEtYTYyYS00MmExLTkxNDYtZDJhYThiOWZmOTQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzY2QwM2Jh\nZi0wYzJkLTQyNDQtYTJjZi1iZWE5ZGU4NzIzYzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARaoBjxJRHLW1A3tpRULDEM+PH4/QX4KaBTjlXUbFMP8fkzvMD0EtXc\nOgQJq8bqoEH0P8xGPNYqiUjKcnk0KCino3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQOgSh9\n5lpP/ifhyeQT00TD+cFZijAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgN1QabQRkunTFqha+//pAUIu4y3qjXiCz81WW\nt5G35yICICp5Uz5yowABLQOxlvQN+t9LX6i5nNIZubJb2Ahv3a3I\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6462", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6462` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAYww/oT/gRjDaacVolY8M4KpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMmRkZjZmLWVlZGUtNDY3YS1hZGIxLTkxZjQyOGZiMDI2NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE5Y2ZhNjctMTVk\nOC00NDQwLThiN2ItYzBiNWYyNjI1OGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAarAxXWqAwofHD5lZTTOGxDR8q8zVCSdxgjwiZzSoepwlih/JWx3ZFwzSABE\nZ/x5y/+uPcTyekkBI6NxCasr+KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULlk6FRje5Ci5+ZwP5PmWJll6WmYwHwYDVR0j\nBBgwFoAU8T7RvmuIZibnpwLAEZn+b2qNRNQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANw43DOt\nDB4ez/JW7z3ULBMZSA6PyfVP7o77r4NLD/7hAiAKH6+jOQTphAFHtzKiorLCQY5j\nRBLA7g66+Mn4s8O/8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXvZvH05DHjmTI9vkE90WydaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjJkZGY2Zi1lZWRlLTQ2N2EtYWRiMS05MWY0MjhmYjAyNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlFkmOM41z5NzlIdr4k3UUpXB3Kc5mvI1AisEU6cc56ZLR\n62Jrd15/t4poMUrYRyW2d2KSxxk4d7Ya5wHHKBjdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8T7RvmuIZibnpwLAEZn+b2qN\nRNQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdczrbZx18jDB31A7ZwAo55oG4YWnEL97COTZI7gkahwCIB5g1ko/CKXu\nlAUDCHZln/SxS1SUq+biVjyaJlAM5M2q\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAc96z6gf8L6d3RB86vhcJSb+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE5Y2ZhNjctMTVkOC00NDQwLThiN2ItYzBiNWYyNjI1OGRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzM2IxMjU4\nYi1mNzQzLTRhMDItYmU3Zi04OGFkMDQ2OTA5NTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASyAQMuG2VVZQXYHl3XaAdEX1v9dP9lfqwG8DXMYK6mQLuGDYrFbACn\nZbIxhotFS8GNtlDtmZBnvcj+Uu0rZFxUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQuWToV\nGN7kKLn5nA/k+ZYmWXpaZjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMcb+sWO2JwfpJLVWXzjOGpEbGx2ykTvPazA\nzKGWq7BCAiBICIis6b2U6HW5IqsFkpLeEIGE9iStLgzRWczhBPm/JQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6463", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6463` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAagU87OPDMdWlZDJ0wUX6IavMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlYjBiOGRlLTg3MmMtNDUzOS1hMDFlLWY0ODVlNDNhNGI1NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUwYWUxNTMtNDBj\nYS00Mjg3LTliOTEtOWM3MjlmNzdmYWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwofV4s+bBlwheaeurbLo2JJd7l6+u411eDLaUEGk1/xTHQEejryJ7fbhnjb3\nsthIA0dSmQb86eIHDHen/WXrbKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUja4EHUEq8jHaCn60k8tnGqb76E4wHwYDVR0j\nBBgwFoAU5w1SXm6TNA+XkaQ63kphsd1DkLUwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIH8Nq5Ba\ntl2b+0Dgf5a9LRSu6bt9bmAInymmAVaJfLMBAiEAgb95QNacoPFWQ7KG3Ezz9FSB\nuZMAlvVdP7V2nvvDTuo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbIEFkxgAAUn42n6ek2kftpfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWIwYjhkZS04NzJjLTQ1MzktYTAxZS1mNDg1ZTQzYTRiNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATH1xTTL1yVPriCuBjKNZ1OMg6/PejrVGU91irzUUEq3dna\nvI0xh75SbCb7q45mQw9HHc+hS0KYnJ6bwBDLJYCDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5w1SXm6TNA+XkaQ63kphsd1D\nkLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK60OStiumGgEbdizE9nQNj/Bz3FuOAGsOAVWkTgVIXQCIQDOANqNKFuk\nU6L0QCEX3aJravXq5pe7FR6vcpPfhNjBeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAcKnTmBnSiyeGB7901TyWkk2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUwYWUxNTMtNDBjYS00Mjg3LTliOTEtOWM3MjlmNzdmYWU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ODllNDZk\nOC1jYzNiLTQ3OGUtYTZiMS03N2M5Yzc2OTNiNjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQi3GGJjVWRZ7tLaMfqJIWLUcnwpWcxyPV5lgK36MYvQUCT1sJa7v8t\nt67nrZaiQ3EABUZ+fcEqAa5L/cZhoPXbo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSNrgQd\nQSryMdoKfrSTy2capvvoTjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhANM2/a2+x0MwbhqVNWvITNAvbPF4EQUNPHy2\nPszErZBKAiAPrq+2fUV8Mz0zrs8pcvaTiyBSlOYwEVKo5OYlyEAyZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6464", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6464` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUNfpeY0I3G9AmqPTQaFcCqYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4OGI4YzEzLTRhN2EtNDlhOC04YzhmLWUwMGJhOWEwYWU2MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA4Zjg2YWQtNmEx\nZC00NjcxLThjNzgtNTlhN2E0MzMyOGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvOHdB8SxXRcbKNfe03NxI8HxpeDSxR+GF2vXM+m/F0Rzbgo2IWtwn/OiXFzM\nfztX9uITJdRMa0N7ln5zAMvc0KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3CmBb6fKn5RN4xNnn3Epl5dmntMwHwYDVR0j\nBBgwFoAUVMep/KzWMkoOVmIS6c0eiYp5pMUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDsaSkeKN0TDTZvEKOWoAijVSNODdW9Wuv0ZbhnczbftwIgX8cgsuu3\naw1hEtsZM7sU6draN261XY1o3n+jIUicue8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfQa9lug0X4v064u5Sryw3KgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODhiOGMxMy00YTdhLTQ5YTgtOGM4Zi1lMDBiYTlhMGFlNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATp1cJjqU9K1dGuibL+3TavGxOnl57DCkMvJgNQDWOFvWwd\nuycwJ0ZbAiPImXB//K3NN3QNXSBf1zV2IPxlbYs0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVMep/KzWMkoOVmIS6c0eiYp5\npMUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALYDrK0sGVD+zduPfs+uPPd4NYMkIhFtV4lheFGY9CppAiEA4joQSXqc\nVI+VAxNu+A14agnZwoVa7zs4dsgjwBmMm90=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAS1wM5Zh2N+Mfo7ISNFchZw6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA4Zjg2YWQtNmExZC00NjcxLThjNzgtNTlhN2E0MzMyOGE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYTRkODkx\nZi0wMjdiLTRiMTYtODFiYi0xNmEyOWNmNmJlNmMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARAyJI+2DWvj/TI9WEqRZ56DDr/1GIrBN3YSNQ4FBuzn1ooBGfRvnCC\n0SEBeCZMjbZ8qjB2UKjSaNhovlxCYZ7lo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTcKYFv\np8qflE3jE2efcSmXl2ae0zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgdq99/1GdMXOv2WCz8ChoZpsYOALR61Kq3pDE\nYB9PapYCIFSiCt8A9kXKgpFxA/71nDIFxGPP/7pLUBUvP35mSCQG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6465", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6465` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAXnowiLELLUDSr4Rom0QjfVNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllM2NjNjhlLTBkNjItNGRjMC05ODEzLWM4MzAzZTQxNTM5NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWExZmE3MGQtNzhm\nMy00ZDJhLWIyNTQtMjNmOWU3OTgwZDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEczsRHGDETYyabEmmpXG6W31niIFTltASRym7jtTrI8B2MnDNb1jAL72hASZe\nCy5nJv/jpob25rlxpUFvQ2SZGqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBT7Fi7MGMdYW/b9/UDamHlZbE7MwHwYDVR0j\nBBgwFoAUqccW2q8fyKSuypY25l3kcTQpPTwwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDReLENk9HMh8LVK8nzJiC5EZSdBf0jlKFI3XVzcr/dQwIhAMbk1QpM\nzCUbpuoaBS1yzGN+uNUW/g+q/C1NpWeR7ebR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY0UoByEevK7WJvKvdDv4lgfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTNjYzY4ZS0wZDYyLTRkYzAtOTgxMy1jODMwM2U0MTUzOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkaNvm7ur+J/MNCIt8TSTvIw6BilAOWrvP3MOgaDKwg4dY\nUd7/qVXEQTZqVaFIp8CIPXQcQshYTgN05drGMSSso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqccW2q8fyKSuypY25l3kcTQp\nPTwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSyruOoUJZqoe0TvMC1viNPbI0bMsFDuT6DhbKXtdgcQCIQCb+VKoAiQh\n4PuBXrrxct8toHLYDFlxpUtD3f4i2GgVOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISARw/b2EgdXPyohCIoRdXPu6QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWExZmE3MGQtNzhmMy00ZDJhLWIyNTQtMjNmOWU3OTgwZDVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YjUwMzM2\nYi03MzYyLTRiZDgtOGE2YS0yNTc4OWFhZGE4ZmYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQvhOY5MIYjsnwQWCrkHQ1MDgJv6pZRE5x2aths6tnGrevjc2T4RJ/r\nuL8YfwtXLJOpzK2j3F0Ux2eHDWPRjdtuo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQFPsWL\nswYx1hb9v39QNqYeVlsTszAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgR20dH11VmLlpUrgzNg1CtHziIWq79q/Ax6pa\nQl2hppMCIDYnpd5ucd/JMIYLIxj5LtH5+Dhu9FvajdF8hB6hdr9H\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6466", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6466` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAQt5qVaoKtJow0/DSQKSZtFuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxMjE4ZjE0LWJjMDgtNGNhZS1hOGY0LTViMThiZGFjY2RiZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDExMTY1NjUtMjZj\nMi00NTM0LWJlZTYtMDlkNmQzZmQyNzQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzBq8jWDyqROugPyA6GC5KYbBff0fniZfHcGybAvrAlRNU8jmZb/ajGON2kW5\nPDavhl3IqHmV5GdU2C+GlilnSqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK7vokfLQZjpgpwHq6ePlN13k3w0wHwYDVR0j\nBBgwFoAU3rWXh1uB17bV9q+0FAeOnEhWFs8wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIE29tZOJB2ZEFzmM/49qf6AHxY4oZYf3zDeqtqFrfvRTAiEA0ZrAfc8eZcL9+oxj\n9B0o1ar3iXtjy2qoVSDqCA/RlSE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASDjmKm5Q3YJfgsQ/qaNMIFaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTIxOGYxNC1iYzA4LTRjYWUtYThmNC01YjE4YmRhY2NkYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTOJt8zERJSntCmqcicgX7dQuLCxhQY81j5tsc/BE+RGom\nifizwmSjRPZqXYNPPZKq3hT/wrAsISpJd3bF0rgzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3rWXh1uB17bV9q+0FAeOnEhW\nFs8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBrjLeKm3yI8EWcNBQYMICOpfGOhL58ZvN2eH4lSblegCIQDOj5t08O7i\n+zICzSg0gB027vzEEZL0Th3jYTfv2CrEgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAaS+r8LAA3BoLPJE/KjD8+lCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDExMTY1NjUtMjZjMi00NTM0LWJlZTYtMDlkNmQzZmQyNzQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMjJiNDhj\nMy05ZmY1LTQ2ZjctOGZhNS0xZDFjODBhM2FiYzQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASMfGDok8rwCNUpIJ3dGk2jFmZDffKXv9fTyCS+jz9bN8QWpPd2k2y6\nJDnEcfLUTm3SGl9YqRr23zl+u9MQ3ZlKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQru+iR\n8tBmOmCnAerp4+U3XeTfDTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgUCTXPAM4BqnIKtKcvT/RQ0BaTRJQIJhvv4ts\nwk0HfqACIQDxSHaI+c/AdxKwPQiYYjqrR1r8Gm/M6ow+D20cHrZJ8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6467", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6467` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAdDx+NZhVTj1xt5r/sMetcj7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2MWE1YzdmLTYxNDAtNDVjNS1iZTMxLWQ2MGNhOTdkMDU0YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdkNzM1YzAtMTI2\nNS00OTU0LWE1ZTYtYjYzOTAzMjVjOGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe21dLXigz/KzK4RThZ89Ap5jC+XfLcpf2m4jalC8uk5XI2YccXdzHRcNCjQB\nfpMdrTRmWZqmuBBG4KEa3AMcQ6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw7J7ty3JU133I4ua2cfDPnopfKUwHwYDVR0j\nBBgwFoAUTh76PPyIKl0JmWQ4UxlpASgZdzUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDOb9skuGIuErHctT2QOfA93UC9VhQEaA+QEGjGaVy7HwIh\nAJh+Yvkn5kePreI1m/Q5gFezSH39ZEjN4qmbsuFHPYJX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU5eEBpz33nzwuIjy0CUdbI1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjFhNWM3Zi02MTQwLTQ1YzUtYmUzMS1kNjBjYTk3ZDA1NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZ4BVrxkR0Hed9RAOd/uban61zWcmk2yuEjU0BSHcA8V2p\nvAehlpxFe3Bm2yPYZZ3MA8HOKv/9wGG7C/z/ULRno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTh76PPyIKl0JmWQ4UxlpASgZ\ndzUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJUBWt6ol7t7y39UpUlA8IniW8C0sLnN6IvqCCdMlg+/AiBZUQjAh1DO\nJ3Yd+D8Fn3FGhUeUiPAD6K+s7ETXQElptg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAVieXCGQQ5X5rAnjatGJi+lKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdkNzM1YzAtMTI2NS00OTU0LWE1ZTYtYjYzOTAzMjVjOGYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZTI0ZTE0\nNS1iNDAxLTRjNzgtYTVjYi0zYTgxODU4YzVhYWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATeyjje2I+805haJwFdi40KGQ4aCjf8S0y2rGSJ/vyi2p6mam9xAMJx\nbIHXM8Jzq932lWyuxrCHX44K2mQllB8Lo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDsnu3\nLclTXfcji5rZx8M+eil8pTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMZ4iNH4M6ajtTqSHvCcSb4JJxY4GLnAxvUd\nNNSbRDXTAiBmM3fsXiOlrltehWzzfQJ3iMAohoRKA47bA3YOhLpLbw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6468", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6468` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAWqvhZ5FhhC3sciOSDx8cU6yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZjNkZjUzLWFmMTktNDllNS1iNzg1LTNhN2QzOWUyYzRiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFkMWQzMWMtMTZl\nYS00ZjIwLTkxNmUtOWRiMTMxY2I0MmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEflY2BvoUyGa7Ln0vVcMxJryseLPy5/4i/aaadQ9Lx8z6tN88U+DD9xs3BuUs\nrkmhkd6Km8Suklz+LZM63hicvKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5PsphsAYAjVOfaOvfdAw5yRspY0wHwYDVR0j\nBBgwFoAUXSaB1hk4vOfUZ6npUyXeYLFgy/gwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCICWjzuB+TOPbxa2A1xHfL7LysrhuUPDR9QFT3H1Bj4fcAiA2\ndlNAX3LQIH6JiPGPCZNAd46mq268pkhsxlpdazIMYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQPBUNfoBmP76rKJGqBXYBq7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWYzZGY1My1hZjE5LTQ5ZTUtYjc4NS0zYTdkMzllMmM0YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwXtyzrDArWawgagAOG6hNFvS6CKruFQwn47Fy95TZDfcX\n+saO4WkLJ74ETEx0oY5RBYo7pmoh2mzXXQaYoRPGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXSaB1hk4vOfUZ6npUyXeYLFg\ny/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDhuCsRpUpUVU3Si5VgRQ4jgEcJB4/89hRy9usyRkZOICIE5j5y+mfXfi\nJepIqnHMIFTXZYVHRjysgCVhmhrjOX37\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAXtwb7L7JW1ubkQgD3RKDm49MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFkMWQzMWMtMTZlYS00ZjIwLTkxNmUtOWRiMTMxY2I0MmY0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNGNmZTM1\nYS0wNGY3LTRmOTQtYTdhNC02YjNkNWMwNjFlOTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQNqV22ETC3la4g0zmfHOl0BPA+YDth4qeQk4P4yWqNzFDGaAyP3yBu\n1kVL0anHjQhSUR35ARXE+/Ne3Tl4XcU1o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTk+ymG\nwBgCNU59o6990DDnJGyljTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgensdX90ypeH1jVF29R7J5UkncKG/DML0VcqR\n61QU6ZICICgLGCpqeh1fk8j0oo9JDf7o7z85V5tY5SJCmOZGcaAJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6469", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6469` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZktcD41avkjjOD753qLHK6pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5YmVkOGI2LWEyNTgtNGYzOC1iOWE5LTlhMjY1MDU0OWFhYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWUzY2EyMTMtMTQ0\nOS00YTU2LWE1OWUtZmQzODdiOGUzZTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV6h7ezZzjb4CwB/nM/HXtwxsBg3+19ZxCI36dGzti8GqcvuACouE2PqcosxF\nIXvA+MQdnfs9JkOI3IVznzE6yKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC6yh7xFsUrnvvklt+xNMhbOR100wHwYDVR0j\nBBgwFoAUgHubdLk7NXFET9Nl8fX9BDLkuD4wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGDVWln4DKb9\n56WijOX8jcFjpSDPNtMwFtvYLcprv6VJAiEAkMYtpdAFKa8QlLcLG8TDY+Q2m6uI\nBNdCCylx2SOm2a8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUxQ+uaHfW/GJ04IOEv58yhsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWJlZDhiNi1hMjU4LTRmMzgtYjlhOS05YTI2NTA1NDlhYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3Whj9NkWaI+Gm2KvIfiSC1P0PSx2cv0hrFtfKE2gSK9Ky\nvWnNMZzjxes0Mm2HsS0Jv80I5z6Y/sdSXVdn5Zngo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgHubdLk7NXFET9Nl8fX9BDLk\nuD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI7sFSswfkXil/1C0ji1t3xxo70Y8PpieLCmCW4Q2zVfAiEAi55FqN9K\nInX3cdnMv3dfr0vZLTcwwGLxgM4FBAooXOs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAeWCxBZ0Q/azLzSfv10p9OuhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWUzY2EyMTMtMTQ0OS00YTU2LWE1OWUtZmQzODdiOGUzZTQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYTMwYmJi\nZS1iMDI0LTQyZTgtYjI1Mi1iYmEwZTcxNTg3MjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQMLt2OxkwnqNvu+CsuneB6WrcB8O1UYmLkYrX4AjYi0LGDPCMl/MQ3\nzY5/QYO+W9veSh0ILUTo8mVC32iM7HIio3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQLrKHv\nEWxSue++SW37E0yFs5HXTTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAPjmG08qMGKDJxBVI4qhfPIOsEgKOY/Nhhg/\nKlKMhvgKAiEAi5ZPmeCw9mLOPspAthByi96MpveO1mGJYFpixiv2vVY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6470", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6470` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAVUPRnGT8SKT1k/+jxyy0MRcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmZWMzYmI0LWIwYTQtNDZlOC1iZGE2LTc2YzI4YmEzYzExMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdhYWRlYjItMDNk\nOC00MWM0LWE3YjctYjNlNDJlYTM0NWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEncsY86OEEChUFKX7ieXvVcaZxQRmbuU2ZVlnSsZ2nYr0sC8IQ8M28DuGlYfQ\n4N7t96/spB6cwk72iL7dyavY06OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTA4Yi0jINgf0joNHjtZme70oBvswHwYDVR0j\nBBgwFoAUl5qMJvPuGgeM/0Bmca2IkxfGCjkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMNKb89XkYJv34AEK0HFo4bPVbK8sNG8H9aydl0NkqQQAiAuksXXEN6s\nhuvTJt+LpFI4IhDZlU9D1ed9/nbql/aFhA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdCXdBuxD951VkeCbYMgwufvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZmVjM2JiNC1iMGE0LTQ2ZTgtYmRhNi03NmMyOGJhM2MxMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyUgEqucFbs+BwchfSEl9VBJDYCKOcze2kP3zAFkFw8G7C\nh3jScxOozEaXEkmAJtvAlCljV4Yjy2R4kXB7pxlZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl5qMJvPuGgeM/0Bmca2IkxfG\nCjkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSbwptFE+GaCIc8aMbPwJqHEnyW1u1NNH8hlQ/DDt1rMCIGjghE+xEvqE\ne/gn9yvAPVl3nDmEJn8ffoVSN+lNe05Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQFKnQzb0ItN43UO6oFtHkU+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdhYWRlYjItMDNkOC00MWM0LWE3YjctYjNlNDJlYTM0NWM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyYzQ1Y2Mx\nNy1hZjg3LTQ5ZGItYWRjYy1mZTBjYzFlZWVkYjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATJm7sOBLrfwxMsreWrAFO3omDAUEpppcGqu7ebMw9nig7X5lZsJlXb\nY4uM+mt/cbuZF9bjJ+ZSGQgqrxN/T5Xbo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRMDhiL\nSMg2B/SOg0eO1mZ7vSgG+zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgTCwSRXjrCKoFdTLfEDL0LmzSUCrkLiZPwccS\nMfc3WjoCIQCZdezkWfRkHWQw4kn7ifvgkiS0OZDUUIo+gJPwB/LMsw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6471", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6471` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISASXf3Id68jCu3PEyuUB2yGl3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1Mzg5MGE4LTVkZTMtNDlkNi05ZDc0LTk0MTAyYzllMGYwNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNmZTQ2MjItYTUy\nOS00MzVhLWJiNDAtYTIwNTZhMDFmYThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZzSpgSryQMC9gMaaHgw1ZO1M7ui3dVCZyeuemA9X/YiYWrLxQeUBRh1vmjVe\nxQF6A4dv1+sCPbToL3v0fRTwkKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1nczbvwCqSqqBzokd4f0LIaY+oAwHwYDVR0j\nBBgwFoAU036llQng2g7sR1Nkjg56Ecb6EJEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIO/GsgrD8dHsh00ZrOXlX8+/Lg0M1nOQmHAIL6tWz93AiEA1C0YPx/E\nlZL7dZoDOBlhR5G1BulGJStfSFmObE4L/CI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ8jS5biM0xNM5nLSLCbjAJJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTM4OTBhOC01ZGUzLTQ5ZDYtOWQ3NC05NDEwMmM5ZTBmMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6xvrMqSeU5OZigKPr42WfUS2onrFjebEGq+vUpcPYhzwQ\nIWdL3FxXeeEjScNRXDb7yfTUAtfhiZet943MDegGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU036llQng2g7sR1Nkjg56Ecb6\nEJEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfkOhna9P8rU8ENZaOJbDLzH1MIuzVFyCk6xSL5Llpq8CIGJnDu2FxmPi\nbl+GcKaaY2VGQfB6VS5AViclUOUi9JbG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAa2rKBjGDOM3jmjzUOJ/BX9zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNmZTQ2MjItYTUyOS00MzVhLWJiNDAtYTIwNTZhMDFmYThmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNWU3OGQ0\nYy1mMWFhLTRhMWUtOGViZS0wYzY0NGE3ZWY5NTgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATSew6dYPl8iYIUxHBg9HLm699EdAZIC0KerN+p3frtLzqcfDxux43Z\nXgpXHt0apBH+MIn+qcyo0CXju+m7M6cKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWdzNu\n/AKpKqoHOiR3h/Qshpj6gDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgFvlP5i8fWN1US2E70Qru+eqB/BVqgN9fOL6d\n0lCPJ34CIANKHPSJZofZKov/TFU6ZgXP+cUS01nx1kpWB5pC7CKx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6472", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6472` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAas0Tzt1sLZseC/2fTGy08K4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlNjU1MTM1LTdhYzQtNDg2NC1hNGUzLTJkNDViMDk1ZDFmYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWI0NThhYTMtMGFj\nOC00MGJkLTk4YjctOGM4MDQwNTE0ZjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtngqy12C8jq7lUaII0+NNqS1SK7HF6wSbOH1qfFnAWfJF4txUIfkAAMrf3Fl\nspZRjdunCGT/Zg1jJ3IKKm2cLqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1wVGOfZaTxAXxQ/uVEzPaztO4BUwHwYDVR0j\nBBgwFoAUwp/9zD9ZjbnAsYYSiYc9/47wbj0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCv2tTfzE5wik1I6jRFdqSQf6FcNSmJx4pTEbztowg+0wIgcatiXJks\nKp1I6vPDqbRAYiHRACAUdkIN/RmS4sazc88=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcWTAqGGiPYiTKYHijHNiFxGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTY1NTEzNS03YWM0LTQ4NjQtYTRlMy0yZDQ1YjA5NWQxZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASibBVbag5O4Xan4H+50Jc0rPfdkW1KSuI33HFir3wIffHZ\n+lT9y0g1FU1DwSUBD7aNILtNcH93Y9XZ0v1dw9cdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwp/9zD9ZjbnAsYYSiYc9/47w\nbj0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALGfpVNzEz6CfhLnZw06Ph4owdRTVf9DpkLfr46iz4NsAiEAqQyLkXmH\nCOXapM9WFM/hGwnZr8moRFSYItugOt/kI1E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWnrjTMgXiZ3tQLm7unts/VWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWI0NThhYTMtMGFjOC00MGJkLTk4YjctOGM4MDQwNTE0ZjNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlYWFmYmQ3\nMy00NjJkLTRhYTYtOWU4YS03MmJkYWFjMjE1MzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARyJJjnU7ZiOJLvL5fg3yP+MCWUCBkYyZcuSdApmKebfxTcv65IXaBZ\nevPtXuqXE5C4B4PyjVEUMyRtRVgnY/Eto3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXBUY5\n9lpPEBfFD+5UTM9rO07gFTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgGuSCFj/VjzTXsotB3wSkQLTFFlTU9CSCzZW8\nM3JDOycCIQDyTCoP3GO+She2wkj9cd9aqDXfZ4RCj/tNNlPBOALhBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6473", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6473` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISASWged69YAmNGkAkaFraKm6FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzMWJiMDk3LTA1ZTgtNDEwNy1hMzMyLTRlZmY5YmE2Yjg2NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRhZDY5Y2YtMDY1\nYi00Yjg3LWI4MGQtNjRmYmIzNWIwNmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELyASKG45ld7HjO6COM/jY/12Rcu0DmjfUY2Zc3wxAIRr51BhT2kUuIVGZr0E\nG6jsNL06gu48fREKF2lGOZ2oZKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi9O+UmJ74wXYL/6PQe8yo1L9LB4wHwYDVR0j\nBBgwFoAUhlpkAS5fR/dIt0fv6kGRC7Pv8sEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC7/EIE9ZAy07TolfAKeI4dYA6E3Dbkb1wQRQSd\nwqyAzwIhAKKtf9AUWaIl1xMNtg6M3c0DY5c6BHtvQPQFciBLzrEM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ9dhC3JR4ZYMpqhpDshH/AEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzFiYjA5Ny0wNWU4LTQxMDctYTMzMi00ZWZmOWJhNmI4NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcDNSmaCt6SMmbdFDvJwoR3KYHd9VLFNxjNZvB040INJMG\nKsT946fTM4nF1+hbzsVq3teEFg8cGb2HG1SzGkgJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhlpkAS5fR/dIt0fv6kGRC7Pv\n8sEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdgn9Qd8yj7KO0McFCmu1ZxIgmZaCui5pjyh8IfgqZMcCIF4BbJhMCzMW\nqNvW015ZxROng7N2hRCVAz4QA42Mu8ql\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAXZRHqNwe6xejZgokpua9bthMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRhZDY5Y2YtMDY1Yi00Yjg3LWI4MGQtNjRmYmIzNWIwNmVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwNGJmNWJk\nZi03MDk1LTRhNDMtOTYzMC04MWNjMDdhNWE4MGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARHxMRDSsm+yEMS0aCOd+hY+MjYKhRnpUu4fT5uSF6gYTINviga/D/V\nLF1YhjCm8F0JzZuNULdOTxXKoYIoMCNSo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSL075S\nYnvjBdgv/o9B7zKjUv0sHjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgOVlZQJUU8q//f9Xzo2eSrWaIH51D0hK/9OAp\nZQOvKxcCIQCv2EfNU+HWJ3P7Zt9NV9b3jpc3a7BTOcAbOETXu1UA8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6474", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6474` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAeLWaoS+ci0OU7Rako1W6469MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3NDY1M2U3LTZhYmEtNGZhMC1iNGY4LTUyY2I1MDM3MzU4ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQyYTU3MDMtNDRk\nMC00YzE1LWE1NDMtMzE0NzgzZDc5OTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI1UChhDPD2r59Btl+sI9/IyDItvK6Bcdt9BRhqVv9RXmWKA0G5N8qydHjLmD\nXRfTJR3uSc02iugPFEE/C2pMP6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9pQRI+cin7hDpVsCrSQt678TBuEwHwYDVR0j\nBBgwFoAUquBn4iitgUlzO0AqkAzKLia0oL8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIHKMQCfRXLSfixJKob6w2P5sa6eP2zn8hncT6hEF\n8Bj8AiAXVvxAyirDMj/3S4Z2b2VZh9CpO0CQKsJEbCNlxlY7RQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQt3c3y4RE1zgDPUiRWa9WU8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzQ2NTNlNy02YWJhLTRmYTAtYjRmOC01MmNiNTAzNzM1ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATD7immMhQzMDnDa048GqLd48uo5JrQLhTI7yYvWqNtVwkT\nMte3YNhkOpMXV5QAi7acYsYt7Ka85M28XgpLEaj/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUquBn4iitgUlzO0AqkAzKLia0\noL8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMKZYuFuER8iwNREfAWRvP3G1ZxySBD4q4FlaB8xrlXCAiBsur77TNFI\nnikuCnUTXrCSkwXiAAQqshHi2nv2HX6vig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAYkVuf3p/vEQgNtEYmfmaOFqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQyYTU3MDMtNDRkMC00YzE1LWE1NDMtMzE0NzgzZDc5OTMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZTdkZGQ3\nYy0xNmVkLTRlNTMtODAzZC1jMmZjMjg3MzA2YTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR16qLpA3XlWN0/kHYElG+5MXHXIrjndhex+wLAi98I9THbH9yPw4UX\nbwmwPVc1pCz9PlpccXuR8ewK3OmLH0Rdo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT2lBEj\n5yKfuEOlWwKtJC3rvxMG4TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAM6GpWxJwGW9Sy6T6H9r5YZYGViC264JS+vn\nawx0DvRbAiEA+9365NNO5QdXMKi8WbnrXpSA7C+T6ukz4J44QvooeKA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6475", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6475` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAUgBM48YuwcNgyKR4cj31lUZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyOGYzOTM0LWUzYzUtNDFmYy04NTIwLTk0MjRlNWE2Njk4MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY4MDU4MzktODVk\nMy00ZDU1LWEwYjUtNGZiM2RkNWQyZTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmV3xJub9IkBk8eg3vZk1u11KqfG3mK2LOMMFju/sVZ7Or3PJ9i2VofHlD0eQ\nkIIFf+F8CUxGAWC64rtEDaG2sqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQoECgZGggRRFkXakpoqTI+XkRuAwHwYDVR0j\nBBgwFoAUrBHOs1IUh3CSiQoMLtgzEwfNsbAwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIB/7ABQ7HXMU2X2HuEvzE4MulmHpGPZq0oqxC02Wii0fAiAR\nMwefxRmOJwzbc1O48mYvlTpDHXJZrOtItGb4GrXGBA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS3VduHcm98rWk6sL7GJIecaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjhmMzkzNC1lM2M1LTQxZmMtODUyMC05NDI0ZTVhNjY5ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyDgnojh4EMfqH5mDShvEmQWhPTQg9jcNZynu7rJw752r3\np91+hcM/YqpjOiZnP3UmYv0SVIUW83rvbPqKY/oko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrBHOs1IUh3CSiQoMLtgzEwfN\nsbAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfXM0Aea7wA4BLnuN2M6GRpq72BT/Hsn1pw5Fb/4JiKcCIQDeQirV+/9A\nznJYB4pjFmcetyivUaT9qCSv5XQYOTGEaQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAaD3O+1QWNuXKindLBF8mzj6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY4MDU4MzktODVkMy00ZDU1LWEwYjUtNGZiM2RkNWQyZTk3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZTNjZWU5\nMy1hNTU1LTQ1MzktOTI3My0xMzI4ZDE0ZmJkMTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATFkigF6wAO4bxaAGpRKiu16zK2zsBH+Rsdyf1wSNLQLOZRH6ijE/X+\ncwbahGIxixwQLS4rZp23kmzugMK3ppg7o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRCgQKB\nkaCBFEWRdqSmipMj5eRG4DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgN0WQtcbjBKcHnhmuJgM/R3sl4fHZz0EC1nZS\nZdHZUKACICc+EXfiqH0H/upNhhREMUeGBKGK0tvQDFqlHcwDTy5Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6476", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6476` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAc3nifieXk2U10TIpLFAaT+DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMDcxNDg5LWNiYjMtNDRjZC1iNTdkLWQ4MjhjYmQwNzliOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U5YTgxOGYtYTY1\nMS00MzU0LWI4ZTItZmRmZmEyOWIwODViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1CrluXmFqhLNx+72GAI75vKnOLPeBJTxMWbYcs/EG2zsn3jM0EheSNOzcF+v\nu+DENnrCWjkY5qRYhQkj6M7sYKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOxqGgJsesLDYiEr9ukEiAGcFg1AwHwYDVR0j\nBBgwFoAUZF4kjcECh2E4PGTwsWcYR2nfj4cwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDhUyXCzZRGzwndR5Tp0ZVnzzVo/PEU7\nt79sHhKhaHVwAiEA7iOyuN6nUN+cU7BJW8ijFdC6yme1Z7/jNxaKY7ApCKA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeW9elxMu5clnkx5jLaUW5VJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjA3MTQ4OS1jYmIzLTQ0Y2QtYjU3ZC1kODI4Y2JkMDc5YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsDokPUkoAEKDm2WcqFfkrZFdXRIW1LfW03g333SqtPqpU\nHzd2FMtAaXzo/7Xw5VYV20K+Qjw9deI0ho6v0BNso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZF4kjcECh2E4PGTwsWcYR2nf\nj4cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWY44Blp4iSenMf3yEeJCFldkbV9FhycMdGIf6VJb8XUCIAUg6JxUNqZM\noip0Sz1kJO+oJH5JRdh+5obW92jClNOl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISARH6k9w5/silLwV+JzkkulwgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U5YTgxOGYtYTY1MS00MzU0LWI4ZTItZmRmZmEyOWIwODViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZDBjZjRi\nNS05YTEyLTQwN2ItYWQ4Mi0wN2FjYTk2NjExMjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQR1zNS+QxJ+fkOgiLKM20Vdbts5Fr5m2U1lavdSb0lTNMTmcpkH6WI\n+9JUlcUyI5jG8qbpiWcTDnvDHSRgOlTUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ7GoaA\nmx6wsNiISv26QSIAZwWDUDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAI33n7TQoA1byBEt6JRsk4uH7qiihXsW0q2J\nlsrqIBy6AiEA8flhc+t+mlVngy9Qa9gBYujfvN2VWXZz+FPEcojPy5M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6477", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6477` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZUxmApzWYywWKIme5FgDGavMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwNWJkZGM4LTI4ZDUtNDM5NS04YmExLWQ5YTlmNmYyODUwMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ4OWViNmMtMzg1\nYi00NzA0LWJhZDItMjU1ZGY2NDBmMTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfLsjiR/7iIPYXbSpOckAb63oQhbaMpDgRi82ys5REFMCYYifLLiAfdhwWzlb\njFt9YOx3PRN3lYdsoBrZmNJee6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdUSJoXTTZ+4K5rMUeMatw20tG3swHwYDVR0j\nBBgwFoAUlQ27ThAjoiDTzOxjJti1kT9zB74wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIH1M1UA4e6bnWmTZ48ntUidE8ChkPfcM\nPw0TgwlCMKzLAiAPhen3BX4T+nP50tTpb6rNLE28RYB7s2/WF9hF3VbuQQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZkDKqw5QC7jMrCVUb+o6N1GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDViZGRjOC0yOGQ1LTQzOTUtOGJhMS1kOWE5ZjZmMjg1MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYUV0Y7B/oz61CCaiDTyy5dJ3ycA4I/kUPIse+R+/4z/hK\nsllKbQ7ww6HG2SzgZhRyKhIC+/0jTK9lq5cGgTZSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlQ27ThAjoiDTzOxjJti1kT9z\nB74wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeAlBVo+GVYa6W5pdLCJ1FdjoNcZLCfI8iJw8p7/PcpICIQDCqBFhzhAq\nCaGsc5qPGQWAJNAI1jqRsgheiWIs9lH5nw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAe01xg1kaIbiKwuzkKmLnDqsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ4OWViNmMtMzg1Yi00NzA0LWJhZDItMjU1ZGY2NDBmMTIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5Y2NiNmFk\nNS02MTZmLTRlYzAtODVjOS00NzRkYmMyMjBhZmEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT8egxZ0FXhGZMB7mQFR8ay0c+k4Q9qFKBgQy3fdUW5F3/Bo1BbwHEA\nDjIc28FEWMURq+MUL+UQH6BwTdeJhmbdo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1RImh\ndNNn7grmsxR4xq3DbS0bezAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAO5Xj5beVqWeC8tn2rF0Q8Nvwa+aESMTl59o\npPjsNGLgAiEAlFXu7z7qADTEclHAyV+6EAED9kTdLHj1m3k0qJUJEx8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6478", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6478` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAV7+IkX4gYyJdZlrPd89ameDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MDQ4Yzk0LWJlMzItNGMxMi1iMmUxLWMxMjU3YWMxMDBjZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFkNDA5Y2ItMDA3\nMC00ZGQxLWFmMjAtMmQ3MTM5NDIwMjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7tVBQDNaV/Cc1d7AHUSdiQlJGEiGJnqEy5jblD55EnHEhTJ9aArjxW1sJK7j\nuZSIblDbDa8IePfIVaD5p9T7lKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfj/v++rgnvhX3e9YuJLXj5t4O3swHwYDVR0j\nBBgwFoAUyFl4fdpEmGUl5J8uObCw84g/ZjYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEmCLrJCHGna\nmOjSEefGfcHzOCsLIHWzhHkoVqypr6+HAiEAyrQgoaSaPeRTXgV05sZUQ+MuQnbB\n+z/OtjhiIBYpgmM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWD4TAiyPTTBlDTHemXgHTfiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODA0OGM5NC1iZTMyLTRjMTItYjJlMS1jMTI1N2FjMTAwY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOHV045r+1JteoFIWHG31VnJttPkS2DDkrx5Y0Z9UR+Do/\nuu0tfDrOdqRaKavCX6+6e+loHlFZ7xCHhu4cvU0Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyFl4fdpEmGUl5J8uObCw84g/\nZjYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNHfTwwCLOQrljpjHHUHzMIEh4Wp9wlRUSNmK0g8sLdwCIQDV5apPJuFc\nNqSceTAHGLnMp4ksIRpSk2/+ygQqJgUONQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAUV3DP42DpyXaZpuLgtg0q/uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFkNDA5Y2ItMDA3MC00ZGQxLWFmMjAtMmQ3MTM5NDIwMjRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZDdhN2Yx\nNS03NWRmLTQxZTktODk3NS0xMDEwNGI1MmRlM2EwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARrrugrinVsKyYfxwU0/fqYvwRXIC65veqfzYVEm2IvDExcMgRabbip\nTki8N8RTrIFBEJa4167eYasOHbXWeWmuo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+P+/7\n6uCe+Ffd71i4ktePm3g7ezAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgeD2w1VVjiCxdYp69YD++IPhN9W3QAvlnevhY\nYUO+OjECIQD312szthwTMqHP/FzhkcKos+AGg5Ez1In0nKEysbipgQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6479", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6479` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAU0gS86eGEA9cJndk9Ud+PJHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4MTQyZTVhLTlkNzQtNGQ4OC1hNTk1LWEwMmQ1NjhiOGE4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2MwNmUwZDAtMWJh\nZS00OTM2LTliNzQtNWI0NmZhMWYzOWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm5PciGeVH6DAxXX7ezd6HeK9ED95q2fYp0I3HY8Jk/PFp/EK3rzTGGCsMiNb\nRodL96Uqk07YIcJka73LCBgwJ6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIc0e40NxG7gxyO0tvN1nwMdW9xwwHwYDVR0j\nBBgwFoAUWeQxEPRKMBpXhp1Wl3fmoLKL1iAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKKxwbhNjZo6822hzXD5Y0a8DzsJ9Lvf8JuzfW+cDPRxAiAQpl9osV/R\nbeseYybJDF1uvZ/wcvq1VVAJRMzFmDqCqA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAancoR4GtPOcBe6Q+ktFXPKSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODE0MmU1YS05ZDc0LTRkODgtYTU5NS1hMDJkNTY4YjhhOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbyB4qgcsockepruyKg2SaPL5J7hM2GQC6i5MQVxCBeXH2\nqXJyVuC78R39dG3gQb3+IqD+jB4Zaawy0iaVivZ8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWeQxEPRKMBpXhp1Wl3fmoLKL\n1iAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG8xvv1ZEKbyHt9q+7WRCZjJXMm/0Z7mLf8y7clp/p4kCIFyyfmwIqNcX\nbE2esgaf5K1QDHK795Q6HB4vMYN1a2MG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISATq0dl96c4p+ch2RkfaJWG5/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2MwNmUwZDAtMWJhZS00OTM2LTliNzQtNWI0NmZhMWYzOWFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MWJmYTEz\nZC1iNmQyLTRjY2EtYWFmYi03ZjJhNjlhMjJmZTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARLdYXSTEL9aDLr9XVbuDSkNGmfKOTU5UJjuZFrQ3GqKu+Rx2BPVTbc\noDsZdMUwp0fimzvcU9r3saryawrQ9XYoo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQhzR7j\nQ3EbuDHI7S283WfAx1b3HDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhANXXgSqZq+qkKFa8rEMM62WKpbnsclMP+TI/\niIBxtXqpAiEAlqXQIYlt1uWty4/DW4zmXaLqSAgreK9Wvp8CDqylCjo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6480", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6480` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAW7Fbz3m7USZbn/gRZngPncMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyNDI5MjI3LTlhZmQtNDNiMC1iZDg5LTMzYjc5MTY4MDFiZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZmYTFiY2MtMjBl\nMy00NGZiLTk3ODQtM2VkM2ZkM2RmZjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWrHnmdKVH2DCQwp5+dts/Q9efiHfYYOOr+RDghPAsC1V0bJ8YYZD3Ep7FVOF\nRzQqJHVXofm8v7Ey+VhAXVR10KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwLXOwUoKfXRA1SMG8qoxQHI47x0wHwYDVR0j\nBBgwFoAULyS/mDZXDD5zIOP8934GJjGlhjgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAK+67xs+/4MBpSYjv940/6D4qp1so6mq0cHLz9mGn84rAiAK8NpEYDah\n3TI04y2jF397TzEl98mqGR4/iY8hPvtWbw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQl8+kbGE5Ar1MTT/8nuEM0pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjQyOTIyNy05YWZkLTQzYjAtYmQ4OS0zM2I3OTE2ODAxYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCP7LB90Z5ZRplx7uzylb/ZjumFNifbv77ulN+CA4Iwn+d\njGR2vu0+NqbbmHlEyoGDFQ1ua76dOpECTbA5mJGdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULyS/mDZXDD5zIOP8934GJjGl\nhjgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFqcq036OPbMe5s7UehubnYmVPzFM43QM+CZefFpWTuUCIB0BouHyCpIe\nweaVBMiEeD3DmgG+qkXnXR7zhquXq6y5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAUfkVD2R3R1E78ljO0kr+Fr1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZmYTFiY2MtMjBlMy00NGZiLTk3ODQtM2VkM2ZkM2RmZjA3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNzViZjhm\nZi1lMjE0LTQ5ZGUtYTNhYy03NjAzZDUzNTk5ODYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATJAMHMtzxFY2HKs+lvDkZRpaGta3bPqwwZl4C2clsmy5Cx7muqBUfE\n0xl2rsaz5seUBAvETzM4Qftuc6fS3u1vo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAtc7B\nSgp9dEDVIwbyqjFAcjjvHTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOLeCXDHlBvoQPcdXopg1n5cfXhKHmjrSY6h\nRDf4S5FXAiEApq19r5Dv8vvyuHUkOxKJfwn64E8KcsApsshjnKmWW8U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6481", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6481` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAX6owR+m9d+Wg0ZN9Oxqa3DWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmOGYzOTZjLWVhOGItNDcwNi05MjliLTljYmQ0YjA1MWU1NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQyZjZhYzctNjIw\nNi00MTU0LTgzMDItNzBhM2MwZjA4YWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+bCLvj4RKB6/CYHunzl10mItPZ2XRP5p5+Or6grP3EPo7jRinl3K42g4h4j6\nbl4ooEEw4aiq+EPtXUf9Dc44CaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8f/NWYh2fuRs6XKCZFw/0gE1LlAwHwYDVR0j\nBBgwFoAU+9XKrfVdJfOQl3cRtwLjgD+nGA4wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDYBfNKpDMS68IT6ovG7dRdcnwgOpnlodaH6aH0SMDiLQIhAOScDsO0\niWsd3fNkHAlGl1Q3G9B0KVd3AM36sHPm3zq3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeeLwqWszapuGrjuuUUe93k4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjhmMzk2Yy1lYThiLTQ3MDYtOTI5Yi05Y2JkNGIwNTFlNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR8J/cYV4Pk7kXM/2QmWJQ37v4p46iIiuUDRoUD2/7J9uu\nF+/7w/3k3F9KUkhgwYRHwB8xh33po3U3z4/NLGCTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+9XKrfVdJfOQl3cRtwLjgD+n\nGA4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd1RXgDH2zyv8HiUEIBhW0pdJJNpNtCppfgg/9Fuq7IACIDSQN44qfu1b\n1eaAXG83/WydqYaeCkmi3D8M3tb5Vd4x\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAWkbWKAl1paKuaG9gz1oa1W5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQyZjZhYzctNjIwNi00MTU0LTgzMDItNzBhM2MwZjA4YWU2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MzI1NmI4\nMC0zMTgwLTQ2YTItYTY3OS1lYmI1NjQ1ZmEwMzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARnik5Iq8dqFbB3cONlsPbqV8DRBf6+IJfYdK8qer/Z93kY6ZCSGDeZ\n6ECPfTiBuVZ4tSl7p+/yMduqBlYu2ePWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTx/81Z\niHZ+5GzpcoJkXD/SATUuUDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgXnN+chHDdWJRumbeRsNcaiWFxDi2dNn4TxHW\nN+WfhUQCIDFASzMRhTyzESD6ylq5Gk3OoSzKZLnXLJl52Q1TKsdu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6482", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6482` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAX/yuNFlIIANZ2FwkdESqGa6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwZjhjOWYxLTAwNDItNGQ1OC1iMzdkLWZkNTVjZGRmZmFkYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNiZWY4NjctMzhl\nOS00NTg0LTkzOTQtMTVmNjQ5YmY0MTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4nI2EioeDGuCfUgEv4obbqe5mdZMWTmZDNoLHzVzsAMilpULN48wctqUzkuK\nmwJ5Ff6vgRoxgd1mVQKa+dJkd6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcqk2rEwYJug0/ouLaTpc/elwsFkwHwYDVR0j\nBBgwFoAUuXjHyW9JSm3IqvSkpCwLJ3jL1fQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCnpmOg9d5VUXC368UB3uKusWP3RXz00op6R7uf\n9eci8gIhAJkzsTKPq6k2aK1aZdHyYx5k+c/0RTi7l30r7S0oZbZn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXkt7KQRvo/IxQlHGM7gj2pxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGY4YzlmMS0wMDQyLTRkNTgtYjM3ZC1mZDU1Y2RkZmZhZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgpFqSwGScs5B0RPTAxZJuPu8gRehkLkkmX1jdYDB67TJs\nD+wGLPHnmbEgmDRGT6xekVzy3C8YF6q82X6YOrfgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuXjHyW9JSm3IqvSkpCwLJ3jL\n1fQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL0oFwmPE7OI34wvLDKZAO8w1awjAxQ9TtDzt6eyNph4AiAoZIu8wCd9\nvwJKNU7g6hvT6HF0Zv2wfOLNBK8kQEdvjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAQAyqyn8FDTlAoNoPMgOKrTnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNiZWY4NjctMzhlOS00NTg0LTkzOTQtMTVmNjQ5YmY0MTY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2Mzk0NWNl\nZi0yYTcyLTQzZjgtOTBkZS0wNTQ5ZjQxNWE3ODYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASVwbtQQO5XsfymQDF5lb1TPvnZnhWfq+6PpLZXFMHrRCwG7EP0zA0C\nDGC+Rwoe1KoLD+PHiz7YsyNgCZAOP+U0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRyqTas\nTBgm6DT+i4tpOlz96XCwWTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhANLtaUUI9lE4lTs8aiAefA8aAG6L/Qw26XjE\nwjCSchnIAiEAkTfDIjj3rTvklpmqexGuENB/USSpQwAkQyAIcHJnveY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6483", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6483` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAXYyrwEgi/QYbZa6TcG1+zyEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExMDYzZjIxLTZjYzgtNGViMS1iZGNiLWRhZDc0MDNkODNlZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVlZWExNDktODMw\nYy00MTNkLWFhZmItNzU0MTgyZWUzMTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoE2MqcRPbBxcn+A9C5J08DWgt/dixPAThuGvcjV5BhNB1SY9VErkAeWyWjFz\n9onhUuNrhyn/RhiJnOnqGAvj46OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8L7Jb0VkzlHHhCuFZIrSHPv7doAwHwYDVR0j\nBBgwFoAUPHSjsP26VTW0TRJoZ88YrodNGccwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIE+wZI7oFOKo8N7XbFO/wMwr2Z1yWS8JI1d5ee5y\nSHKrAiEA6Ncy2iCZ95U+9ICbSkipI6b7SM/COmnakPkgOx3/vT8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWskSAKAhlszBvvdNMgA5/FCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTA2M2YyMS02Y2M4LTRlYjEtYmRjYi1kYWQ3NDAzZDgzZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCSdKA2uHRTDuKKFD/yBelAWqn6lOfxXCWhhswKm1WrQ99\nERGoW1/jN2OV9t717LY07KzDQlreVXE4SBoTFxI5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPHSjsP26VTW0TRJoZ88YrodN\nGccwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALJ50uGAlpJa76EqItB1G1GYg7vBrSvX0jHFO4nZo4xSAiEA+mz5M0Z1\nHj2H3Hcl8ila2vrOSQoCzfmNZWlJ2rEqkf0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAbWU8fHrZJSdGxkDBPFoPLx/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVlZWExNDktODMwYy00MTNkLWFhZmItNzU0MTgyZWUzMTA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZjk2YzNl\nMy1iYjlmLTRlYTgtOWRmNi1mM2M1ZjljZjQ0NTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQcwz0svRk5MtnYRZeglSAnwEFU2qVy35rbdZUEVq/dW8if1hrQ3Hi+\nShMpAGIrkbnGtw2Fa5f3uDkP5Eycu+3Xo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTwvslv\nRWTOUceEK4VkitIc+/t2gDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhAPcJElEgvqPCcWpHd8RwjEoAu11z70e1LX1u\nq7gbcwtyAiEA9BbS7FKLSTASYs0tTKkqgmdPbl2PI9JifYPGR6CXNqw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6484", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6484` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAQhVLAfQqFuIwYQtjM2nEX+zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViN2RhYmY4LTdlYzItNDQ0MC1iZDY2LTdhNWUzNWE4MDRhMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTExYWZmZmItODA2\nYy00MmE0LWJkNWItMjM2Y2JmOTQyZGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmaxjJuII5+bsTiXvz5wh+HfW+Wlf75d92q+4SO6MiSibKOOsW7/06dbEdT4l\n51SvQBCsRd2SgYFBlQpwJc18EqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdDlzQBMfnMjizBd8jaR+MLOPi/QwHwYDVR0j\nBBgwFoAUYMKFwHGL7MYjtkRMyDzLVu2gKhQwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDJgWEgtB/L+uVlqLPhSM3KoES7U7SEihK9ayNYlAZBnwIg\nF52UECNVEv5KLJRdffY60Q0+DtK+HlU2g7jqcgOa3I8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdesT1rSW/6VLlOPv4fDecRdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjdkYWJmOC03ZWMyLTQ0NDAtYmQ2Ni03YTVlMzVhODA0YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRwuZhWNfSBEU5dWM4IctABc27zGhE7xdZlyRFQ5SyGyH2\njc8SehXwLaeAe668OXtjt9yE8PXwhUZ7WXCgqaL+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYMKFwHGL7MYjtkRMyDzLVu2g\nKhQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIVPnfiEyXstlDykLo2q0cbBJnP4yav15VoTZHfQDKjYAiAxbTMq9GzJ\nxeMxuyM/lodHHQ/nFxqTOvbqCGIIycjmwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAXcSVuwvnmvdK1rJ6r0+MEV+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTExYWZmZmItODA2Yy00MmE0LWJkNWItMjM2Y2JmOTQyZGI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0MDZkYzNh\nZC1jNmQyLTQyNmQtYjMyYy0xMGYzOWJkZTJlOWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASKCemRzEYk4jRQsMGeBS8vCgiRI5Rqzn/I0w/R0o1Cti0BAbvsZGmL\nQKKwTBhxQXnJmHeq4Hku0H0tNL6hOqyco3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0OXNA\nEx+cyOLMF3yNpH4ws4+L9DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDRwAwRAIgcjzETMPOOtLzC0PtTtdvCVGkGElWp5O5lrC8\np4Jae90CICNyD/zpCEJ9NYqnUxUDhdkCzYzDnNieISmM1DWM7nSI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6485", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6485` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVfi+Hvx+vCXEVAFwzO42c/rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmNmNmYWM1LTAyOGYtNGJjZi05MDllLWZjODU4NDFlN2EwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhmNTAzNTctODAx\nNS00OTRlLTliODYtOGJhMWM4ZjhlMjE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeyULwUi6RT/EHY08hYWLq+OebtqB7N76O1jqUmzj1w/65NI0bcU9hoJ34Qc7\nV4Xl0CAedH+Y/nYXbgVScQz3UaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+P50dcTKwG1vnZo1/UAJtxzX46YwHwYDVR0j\nBBgwFoAUHfE/qAM91Gq4CtVDKhsWcqyD+WcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEJt9gCwCY6PJWeh10kOlNWo0BrsOOci\nmXORZfmvnsSnAiEAq9Wz3PSCFNLoaxSPo2CTyVzUdrI7cuHBQ+rGkB/DCKU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATAEziFwhbs5Uc4ckN4oaM9oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjZjZmFjNS0wMjhmLTRiY2YtOTA5ZS1mYzg1ODQxZTdhMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkMcQXQE6s4mv+lQ13p51aUC0HF6LK9OFXBB0WvTjx3LdJ\nMBoTmaFmBWO3LZReJ+ZRPgM3Q3FWL9F6BOc+aPQdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHfE/qAM91Gq4CtVDKhsWcqyD\n+WcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMJvHjC9SmiVC8koQ3zvaBp4anBh6TZEbowE+YE7MwC9AiEA8QyZHd9/\nXWqU00FWkESlYWMUQlsE+RYs1DdXimRPfVk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWM76sUuDfKuxglVRJ9TAonXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhmNTAzNTctODAxNS00OTRlLTliODYtOGJhMWM4ZjhlMjE1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzOTc5NGQw\nYS1iODg5LTQ3NGEtYTRiOC0xMmYzNjliYzYzMDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATXo5h6Wa76b9P98sK8/PpCtoPWl/NHVEzpVEkGb6r03O0BJz8DADfP\n9gGIwu7/G//zJg4jifo3sRBwzG0itdluo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4/nR1\nxMrAbW+dmjX9QAm3HNfjpjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSAAwRQIgLaerULGHAMfCVEsmk9cHehXm61UwYIzRjZD5\nop6K/TACIQDFtg9Cz2VR23r6Y8kvwmpJYumy0T8R6H2ShnPakV32Uw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6486", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6486` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQ2a4Xx9Oj8HgL3PLJTxHpDPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNDQ3ZjE0LWJlNTYtNGQ3Yi1hNGNkLTIwZjkyMDgwMWIxYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFmZGQ2ZTgtMzRh\nMC00MDljLThmM2QtNTBiOWJiNTUyZjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEISWLfSjZvSFe+RQndVAGa0e0GnbRGvPJqEOLxPLA94W9GdrH09uWovfm9uz\nYZv/EbaibFkzB+5vKwGLcaqsDqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqrHt8ZZ6BAxZiUJR5pdGRZyY0sEwHwYDVR0j\nBBgwFoAU6VggP7QJKtKlCyqyx3dUHEeasyUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIByHOQJQ7HLrUwJ4mykL4bl911F79CP5\nL/6iD3Rw3WUUAiBlLToL88z66FN2bw9p+C0RhnMbCiXqTDxE+fqz9sTbBw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARfKlRl3eM4tXBAZPFdefU6JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjQ0N2YxNC1iZTU2LTRkN2ItYTRjZC0yMGY5MjA4MDFiMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNNBCW7ESL5I8q7ppugmpC+ko20I60rcDN2sVMR2JdjRws\n8W7550uqXN0qlrzHhanQ/Uqq+fZGCDQWc9em87R/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6VggP7QJKtKlCyqyx3dUHEea\nsyUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJnYUkKMLrMQSJgaR/MCmsUq2rRxGKYYF7mlNrHU7eHcCIQD279+dZ5la\n/beR0RxsPUGXPLlyl1rxh1wn/I0jU7H2BA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAe/5u/esXFxqu/czvPwTJf9hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFmZGQ2ZTgtMzRhMC00MDljLThmM2QtNTBiOWJiNTUyZjViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MjRjNmFh\nYS1lMDZkLTQ4YTctODRkYi04M2ViZTBhZmYyM2YwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQkbYIj9dJH+bzBAHZrnsroB3nj9pODTPM8SSt5tWiLablTWCHM9WKW\ns6FlFBw7jk/So2pEp+wxuu717a0Cht6lo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSqse3x\nlnoEDFmJQlHml0ZFnJjSwTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8A\nAAEwCgYIKoZIzj0EAwIDSQAwRgIhALorHsfNKMJ/B+h+lwELY8QLYHYTXltij7lR\nmFUniN8EAiEAyWD1qq+ePzINwXQ0386kk1Ow4nMDrYYK5V/jfY5u2GI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6487", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6487` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXK8c7yzSl65kGBqXfPAGSnfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMWYzNTIyLWEyMjUtNDY4Zi04NTQ3LWQ1ZTQxZmZjZjQyZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE0M2I3NDgtMTk0\nNS00NzliLTgwYjQtNzQyOTY5MmQ1NTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqbfXLVRnszkveZtNSlHu94cERp9VIQbCuyVZkXX9l0VMzNl9Jnes7VJD9Uin\nDWy5sA+VCAzzXmBETTtXMZyuJ6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFM9BHIXRBiGtVXLMBjidpAeS7IgpMB8GA1UdIwQY\nMBaAFE9qWB7psgEVSX8yoFEBXOXCZY6LMAoGCCqGSM49BAMCA0gAMEUCIQDH/ne3\nHMwu2D+LBMDEQKDuIKO5sX4itame1v/YOWY6kAIgW44yBvgjpArw9+uZp73uU/OT\nEzn7We3/1/z2zG/0fvk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUIggZQjX0LLG9btzu51g9pHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjFmMzUyMi1hMjI1LTQ2OGYtODU0Ny1kNWU0MWZmY2Y0MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARifVaZIoU5YOarQ6Qg7rCqo2T2zYaTi3/nJDz6TTGwnIGw\nG9FwHbn/Sm6hG+WXP5fhemPvPtEIYI6lQQuAHuiCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT2pYHumyARVJfzKgUQFc5cJl\njoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP9+HyfmwIa2pwz0yPPzKgWMxMwVh7dg4qWBmN+cVbXzAiBAdtyk4Yoy\ngscacXpZQyC7vp1tLDbahR/TrOsfYTYH+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZVCJaq1Ty4slbq2bPBIF3yuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE0M2I3NDgtMTk0NS00NzliLTgwYjQtNzQyOTY5MmQ1NTEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjYzk3OWEz\nNy04M2U2LTRlNjEtOWU1Mi00MDUzYjc1YTYxMWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQEP+FURuM6HxxRT6U6w2Wrja2UYCYtAZCnLMCedW+FYQpDPc3FvJoI\nvfRTImiXokyx5XMDUl61E/UtKMYN1kY0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTPQRyF\n0QYhrVVyzAY4naQHkuyIKTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgaLqvBfBonJ+v0qqFy0kk+eXI3oAWNQmEHTBZ\nL28n8HsCIQCFnE6urlz/1ezh+R40exgj5a8yTPhk4s1dBfb0L1Jsag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6488", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6488` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAb3EQ86PufzrQmn8fmhQAysCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhYWI5YjllLTIyNGQtNDk2MS1iNGMzLWRiNDY1Y2NkYjllMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJlYjYyODctMDkw\nMS00MjJhLWJiMzUtYjk0ZDc1YzM5NDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGcRVBvBb8OGrKrI1EOeriiNGVkpd7bUvrn8c1KFTsK4AibVRmPk47/raNuHm\nvcHOApayxzCQaEU1lj6U9erpqqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLdwmlZf4el/9bVTXBHi5QL4srHnMB8GA1UdIwQY\nMBaAFIki13th30vT3V5CBV6dhaHY95nUMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEApCvIbZxJoIvU1QU1GocuIKwnpI/UmDjs\nL4Gahp9s1RACIQCCaVbcplzpQH0K/vfqVANdWHZuhDgv0V1W/uRuZj5YKw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZXdTMxK4nQX2OpLgB+wsHsrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWFiOWI5ZS0yMjRkLTQ5NjEtYjRjMy1kYjQ2NWNjZGI5ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7iKfsFVSpu5Ngk57AOtuYEt2VbhWypvFxjEKR6QaKf2zG\nlTkPSjw2zS8AFvD+2ds+8YmSF9gxRmG4XXXxu/U/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiSLXe2HfS9PdXkIFXp2Fodj3\nmdQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKeZdLde1QgxtGBuCU49gF77SrOShHPhpL4Obmq7rgbWAiBIGPaoy+L3\njnzyEvpiE50ePG8vfZVXtiZ0nc7h3t9Gaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAV8LLJhFwpbQlz+PRmx6/3ImMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJlYjYyODctMDkwMS00MjJhLWJiMzUtYjk0ZDc1YzM5NDFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0NjU0Zjg5\nMy01ZTVkLTQ4NmUtYWU3ZS1jOGMxNmUxYmI3NGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+TCqJOIm2jF3tve+0K9hzguIBVMF22so9zlbhM+Q4ljFUizzyfNTP\nWya5vT7ferR4ggmpKpw/pXxgy42M6Ueqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS3cJpW\nX+Hpf/W1U1wR4uUC+LKx5zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKJbzSWD3p0WEpAH8AjnQkqlXhubSBdWNQwO\nXbgEJsuzAiEA/tw7YjDSJGXExAPVGp+Nj5QaxZWd5A6yAtkru7sbNCA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6489", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6489` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAV+FyiKr6oo4XCpQqwykoUyuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZGRiY2ZhLWNjOTEtNGNkZC1iOTNjLTkyMDUwOTk3NzQyNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ5M2RiMTUtZDkz\nYy00MDUyLThkZDktMjFhOGY2MDFhNDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFKcBoQqMscmVc0qLr4fzWRuDH9bOWvnZi1jNNipRNKhaoAUQiCWgOibtYi8R\n+8FxIJ7OS24KAPpJyKbbjCdbsKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN8rr0ehT1322JnlLWHBfoRyuxOpMB8GA1UdIwQY\nMBaAFH7OTbTQkmvNsjrjqYXvNNWSAOlYMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAB/eU4WO+Hh7Sdf3fM/1SqFq9ahl7ci8Z/\n1Htw4w0T+AIhAN4fNST4HiWW4BsZIvYlJd1xxuG+frw6+vp+Ozc58hsp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQmHf5JPuqVtQGZbZBNd2VucMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWRkYmNmYS1jYzkxLTRjZGQtYjkzYy05MjA1MDk5Nzc0MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBX/So8YZpnaomcw9kmC0D0I0yx03+hOac3V964DeDFMdD\nuOprMAOrHSyYZcDn7yimF0It7nDPNeCFjfdgY0M2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfs5NtNCSa82yOuOphe801ZIA\n6VgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU3DOMLQQ40wfEI3IlFgIr0fQdbHjDfw9ZXMF4q83WrUCIQD5otBxvKo0\nqJsNpeFLWc3smlusYumvhUU9RW2Zy0+ESw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAYl2dT60YdQmyTQKB9zqzpSTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ5M2RiMTUtZDkzYy00MDUyLThkZDktMjFhOGY2MDFhNDRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlMmYyNmU5\nYi0yMjE1LTQzZWQtOTJjZC1kZGQwNTAxMWFhMTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASSfE9lfSkMGHLX0WjoTt5QU/hCASNzk/86zw+6we0Rwa5MeUu1jnsY\nfQp9lyLhRIGnWIj6bfpEnpus9N4UEij2o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfK69H\noU9d9tiZ5S1hwX6EcrsTqTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhANFOHqhpaIZzAOiIdgISgeHwiB3hEgbVoaC8\nQimBJJNmAiEAmiMoqZNucK0I5Utnxveqe5VKDRTxW0gNxgG6syC2slE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6490", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6490` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAaHli2XHKWPMy7FFAfU9i8YuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkNWQ4MjJjLTJkOTQtNGFjNi1iNDkwLTkyZGMxYzI3NmRmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBhYmM5OGMtMTcz\nMC00ZDBjLWE5NzgtMDYyMWQ0YTE0ODhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEahDfHXxgRPhON0pv4skyIpbQ/pLUgjgrItvcLYB8HUHPosVA2sWPoSPdKTcB\n61RpLqYgLkQdLi+UmL4vA4/I4qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSeFwWxC2Ka9YmeTkfnqZyKWHR1jTAfBgNVHSME\nGDAWgBSRLa4/uExbsdHKpHxtzZsl7MfrODAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEltSKEvBgora4zyZwjZgQVfFev3IRT3\n11+PBfmrORpmAiAwGANjWMFiYkZHAjo7TGWNUZljF2euU9zDTcBmH5WDKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcWjIf0UAXBz0vEqpiFVmnYpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDVkODIyYy0yZDk0LTRhYzYtYjQ5MC05MmRjMWMyNzZkZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoBd1tYf2PHQFSgOgyMR9QOS2POfY7wHqFl2HP025IQIvt\nGKBloDbwl3p1qs4DsUKOJUiCBzE+eCnDwAHpNSa4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkS2uP7hMW7HRyqR8bc2bJezH\n6zgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALf4eUZwD1G6ZLFXARRDCMDIs9r60ZFq7GwuvnWgF7tmAiAVzhGPcJai\nTE+I9/nqABnCbsoGMKN2lVhlkUlVkjdleA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAUHMdFY8rkhOqN1tT/Ip6bzJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBhYmM5OGMtMTczMC00ZDBjLWE5NzgtMDYyMWQ0YTE0ODhmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4YmNiZGU0\nMy04ZGRmLTRmMjEtYWUxZC0xMjgxM2I0MjlmNmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATHjW6bPifdavi3de7j8PzTmACXQQyq2p16cKbUiZy37Eqg9EoJutQz\nCK0QqDkGRZNjEJZ6A2yToDRlS1RdqeEAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSeFwWx\nC2Ka9YmeTkfnqZyKWHR1jTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgTKWlgx03LPVQb0+nJ460eyRkvLFd7ld8UI6U\nK0drlq8CIQCmbdIuhhVJ4oCFc44yg6DXPxMQTnkf8tWozJrUHCbJ/A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6491", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6491` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAcEGATJiFtSszp3ZEc9lkLQXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0YWE2ZGNhLWFjM2MtNDk5NS05N2NlLWExNzhjZjI3NjE0ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE3NjNhYmItMWZi\nNy00NzBiLWEzZmEtN2QxMjYyNDBhNWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Px6ZP33qXR10it2zBTtwHLG/5Qm/qL3KQCNONjSnq1yKuHAbNC6QMz1Fgy0\n3V6pQjPTbZ3Pr19yIR4762w/zqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIvccoatZ2CR/2O8PTwwrGa/3bPowHwYDVR0j\nBBgwFoAU3BZOi20F/UPyPKVfIMA8p6sqWW0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAzEwtP1ZppSui\nGA+oWsgrraSTINtbkRd6p7rohl20GJYCIAGJWvgThxH5WsOSEFcf0MAOGmtIJQdI\nPCUUEV+Ta2p1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAegHWOmSxOz5C5yw7cL9tZneMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGFhNmRjYS1hYzNjLTQ5OTUtOTdjZS1hMTc4Y2YyNzYxNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4GdYlNmYGtyqF59efY1XCtFgQ4f1Uy5t2peF20mTZ7WGe\n67wzO+LgCdyifjMqeXm4Je/sfIAOEJf3ONaAjB8so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3BZOi20F/UPyPKVfIMA8p6sq\nWW0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANc59zYKxndfqVQhYo4P/4ZM/pH0Wdz3cEpihDrz/2kRAiEAvAZIV1Tg\nb6pbKSOKP3USseN11d1mgeK0+nqkIUWcN9Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAQjIdOCpmdlsQD5STX/91PJsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE3NjNhYmItMWZiNy00NzBiLWEzZmEtN2QxMjYyNDBhNWE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhM2I2ZDQ2\nMi0xYWZlLTQ1MTgtYmVhNC00N2IxOGY0NWUxYzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARKp6EDRSa15I7zBJvsHbdaplxG9Y6T/1sh06XdeJw/JCCMfUdbTYWN\niq7Wx705ccvV1nTa4pCsspAY7VFaDCdVo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQi9xyh\nq1nYJH/Y7w9PDCsZr/ds+jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgWcLzRos51QUxy+68BKeiTIRprOPePaXS3V8r\nsxHD0PICIGkdZga4ZUuF9FaeoWzlOS0D/rsAn9kuSKFuxSusIxJr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6492", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6492` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAVObPoQlFEeipHUdTCro3T12MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzM2UyMGI0LTViMDAtNGI1MS05Mjg1LTA4ODRmZjVkZTA0NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA2ZGVlYzItOTMy\nNC00MjEwLWExNTQtZmU2MzFmNGUxY2Q0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqj6+eITkn6QE84n0s3qefbLnSWRfH9SDBEVOdeJVsbvz5L/dp04FQ+NEp/fN\n5NDrOKeF4sYr4BCkw2o+M8ztZKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtK9WPkVfKY/7ElkKVV7pf4A3OKswHwYDVR0j\nBBgwFoAUc0GRRXgGsd9M1BrGiZuZd0keWjIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBuJee15/oz4zSO\nv1YIor22ruoWXbzbe5A7vUIbV+xZ6AIgaGuD6//bKlIuHNQvOmhLo0RSjMgnXeYY\notO6pk5/jnM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAepVotIOIy30VTaHlT7G/I6yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzNlMjBiNC01YjAwLTRiNTEtOTI4NS0wODg0ZmY1ZGUwNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARywtLN28svARt1AkLa3lmDeMDf0v8XIeaxH/8pfHbsN6HQ\n8ufdbdSzt0CA7QH8qjbV2XcnPSXZQJxHKbpSc0sQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc0GRRXgGsd9M1BrGiZuZd0ke\nWjIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALxMEOUR3t2PSqGXg0wru4s5PaCFMjgSJIb2G1IHWtpWAiEAgoD6KdA5\nVEzp9B2ahDz4J6HVTGbeKunR1GNSK6qji/g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAb6Jz1rdRp3OamZ2DSqGjOKsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA2ZGVlYzItOTMyNC00MjEwLWExNTQtZmU2MzFmNGUxY2Q0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNGQ4ODY5\nYy1jM2YzLTRkOTYtOWIxNi0wZmU5ZWFkYWRhZmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQgdqb9XOJuaxu5bd9g/q7Qux5jeCqq5YLiHmV0fUEESgIt7exfhbX7\nimYBaJgvAAKy7zi6qeduing22BqQuqp/o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0r1Y+\nRV8pj/sSWQpVXul/gDc4qzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgG4fATT6X0dMGbAzuRPRFhr2STCOibhwnPzMJ\nxP866mwCIQDU/wiEGMpP0r0nVgPqgeXDqsv0vAZrDOuMiZnRSAJBlg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6493", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6493` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAR6qHMDWX5CMMIywROcS5zb7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjMjBhMDM1LWJlZjctNDdiZC1iOTM3LWQ0MzRmMTFmOGI4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFlYTMzMmYtNmQz\nZC00NjFjLTk0N2ItMmI5OWViMjU4NTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEALYT7DfTVl+z8G0AOH1TCCnvADjbhBUlQuYlVkrE/RR/LfZoMYqRCH8YH5vw\nfdg2QGUiV7WuXQ1quq980AOjQ6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFgwZO/bpZuOua+zJx7wcE6PBeXcwHwYDVR0j\nBBgwFoAUI1wW21LPeJtW4SQbb26NRmb8cTkwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBHgvkyuhHg5xRb6PQbhQYT\nbf1iU2Ec2d5yIU7NEL1AMgIhANaU7rM3uaoHoejRSjWSn9a5f8btnUGSXRUFzUa+\n15ta\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQwaVo+un38EhdEw14thbIlzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzIwYTAzNS1iZWY3LTQ3YmQtYjkzNy1kNDM0ZjExZjhiOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATayKrpacrqIx0BuGFpOdvbZCRC/jon0lAQ7S+pfUnrVULR\nWrcXrL6wtBWDRKrtRryMEC7nQKt1o2oTvEdPOiI0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI1wW21LPeJtW4SQbb26NRmb8\ncTkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW2kIhTAtj9VEae9MA6o4tkyIcELdJrWI2t1k8nXO9sQCIQDBSOTAI335\nlJPmC0E1JLjbCGIpsJ5WutmKlsGP8rlsMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAcE/jp/4K2ATguF2XNTIe6u1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFlYTMzMmYtNmQzZC00NjFjLTk0N2ItMmI5OWViMjU4NTY3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxYzc0NTY0\nOS1lZDQyLTRjMDItYmM0MS05NTYwZGQ5ODQ0ZjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARxBfmqdBkHu25fXLZ3i2IFY5GZrpiCDxHIeOYhLKlRXNm+psjvKya+\nEysK5uBy2PxM0tHejfrieFBxw3myxn1+o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQWDBk7\n9ulm465r7MnHvBwTo8F5dzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPxWGu2NX0+1Usxp8P9LmdaeC83G6tSC444m\nglYi5cciAiBnAaN6qQc/qftIMHV+siQJPZUg8Y2QH7Poyi++5hyAbg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6494", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6494` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAf/0Xe9SNFh6X3C5siSSPPeQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwMTUzNmRkLTU2NDMtNDAxYS05N2NkLWQxY2JhYWY5OWQzYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ1NmEyNWQtZjU2\nMS00YTNiLTlkZDQtMmEzNDc5M2IyNmRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErw1wvds1kcURxyy8g/77yw3wqS7i4IPO7cY1C1P8AKK0oXIvhagvXMdvsMhL\nDUjdzPhnjay50vpjrZndv6yDlKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwgIpdoRq5uo9ol0UqC4eL7HOf+gwHwYDVR0j\nBBgwFoAUr6FrSo+eflneLZTw7Xw/4HkO1JowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBB6GNi\nqhOzAlzANY9miopKF52HylN0j/upMSACidfXbAIhALPyB8EZlHI3xu/WW/fzpDbr\nB2vkeGhwpDX2D015cOwf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATcpeO54cJoTZKgi7P0rXGojMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDE1MzZkZC01NjQzLTQwMWEtOTdjZC1kMWNiYWFmOTlkM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQ4OmCoz2qE3Y+e03PlrzqnoKrWMgnSBthxG7jjoYowkDq\nt9jePlnEXLM7CD3h2UD8dkMnmlajB0H8Btk7zSTxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr6FrSo+eflneLZTw7Xw/4HkO\n1JowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKTmYHePAoBh/QE1c9g4GAt8L5UrBYMxkPlfRF2urDnRAiEAiR82MNzi\nIbmm1oS4cWVCHHpBSWNmvCeKufKhTF2ps5E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAeY+AFvx210cnIS5GkMDC02wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ1NmEyNWQtZjU2MS00YTNiLTlkZDQtMmEzNDc5M2IyNmRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxZDFkYTIy\nYi01OGM2LTRjZjAtYTg3OC1hOGU4M2VjY2Q3NjAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARBibfjKoV99/mlg4UWqIKoS8A7/uRevE+x8KpdVwXhldQ48fF2qnku\nyS7Knc/cEnZcO5hLlQN0GeRU7g9aR/vpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTCAil2\nhGrm6j2iXRSoLh4vsc5/6DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgcbwhyddr+zOw1vjWpO0BZb6oEkjMGY5mEg5g\n6tD5p/QCIQDtd0NcKUxO7CwQMK7x46+zBMYKme6P7ZhxOxI4/anUaQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6495", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6495` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAfiogtY7LNFfHo/wUgjSzRXiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViZjRlNzZmLWZiMDEtNGMyYi04YzM4LWQ4YTk2NGY2ZWQxNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIwODk3NWItYzRk\nNi00ZDM1LTk2YzAtNGZkYTk0ZjIxZDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3RXvUuheD9XqIR4/AT+6MCo1rR/d/ew/CeIJ77vTyijIwIJRfdE4xa6W8U6K\n+DE313RNcP0ZznhJiJKJSSUwraOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmyUvj3z9mW5qQshmHSIh1eopL/QwHwYDVR0j\nBBgwFoAUUaVCl1qPYF2bXXVWUXILsV13RZkwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAjeUhu\nGqJLSTb38Yddkv81xxXb8ShaWRZeO9mPjxnEVgIgEm7KSOi7SDxFcGKfhKkyU8B1\n4Ntq3bIOw03G9a3C0XA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUTAVAcPRM0Ub4JBlbE2mtLbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmY0ZTc2Zi1mYjAxLTRjMmItOGMzOC1kOGE5NjRmNmVkMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyEWZDTaK0gyfIhH4wk0zJdrh80HNaLg2whdY1Oe21czqM\n7c1gu9dhuXPM7i1OSnnkOsf9QdnGTKuHD9iF+1fSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUaVCl1qPYF2bXXVWUXILsV13\nRZkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHg9boo0t/A2MQ5PNBvxf4fStFB2v5fYyYRrRNDHMuO4CIA7AmwLei1rN\nwjMlvtjOBI3tgmdwLy+ArnyAbuZCK+Km\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAbY/gtaeb5G02FIukLeAZSfAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIwODk3NWItYzRkNi00ZDM1LTk2YzAtNGZkYTk0ZjIxZDM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNzIwMjYw\nZi1kY2EzLTRmNjktOTFhZi1kNzE5OTFmNzU4YjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASHBhiWv1SHslwrXJOHALb1AobLBH+ukceQArSzHDpRk300qBeKrnxC\nR682tUXMAD6abNNctc0VlkbnojdtyMrXo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSbJS+P\nfP2ZbmpCyGYdIiHV6ikv9DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgOvH3EV74osNxAeSQI7hC6TFT+6GHVulUY8WF\nyMPuPS8CIFsslpB1UL7TzOVjzwEA2/RJt57GkVZizdqe0BHeS9Wg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6496", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6496` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAeLDCQQ6wFsOnQLDAnoAbi02MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1YThiZmI4LTNiYjUtNGU3Yi04ZDc0LThhMGJjZTJiMWY3ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWVhNzEyZjctYTQ0\nMS00YTA0LWI3NjItMWNkY2EzNmIzNTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2u/6Cc5+kso1gtSFZpmkJKV5uaZPM+ajIguz2UoKeQFjUq4bDY69wZf/yxNy\n0lATPoQDqLnKRqHzvBJSHrpSW6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIYY2Mg3yIrhyW3v3y5c5yRTpV0nMB8GA1UdIwQY\nMBaAFIuLNLH5/BaCVx0d3jB1Y1sf8ODBMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB11Xeou8USlepRv+Tyxa7z2vW8AvVl9In4\nDfAT1/f2VQIgP2k/Vtkj0afl8I2bbAcDS4FHvSlD++TaKYGFE04BjHM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZx5TR61gXQB5MSwkAXErRueMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWE4YmZiOC0zYmI1LTRlN2ItOGQ3NC04YTBiY2UyYjFmN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARd1wWPEnpd5YZ2vVxMGqhPFdonsdrfUqAIoMw15ghexDlW\ngky3mZNbeRWJRNw8Zr8uClII3Cp3aY6BtYN8zDY0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi4s0sfn8FoJXHR3eMHVjWx/w\n4MEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaq17LSKqm9TGPg1nVrwUra9n7MLLCBDH8XVRNyVkFp8CIBL0zc7C9sMb\nfBFuAonDre3p2WM+AtJWAC93trEh+duW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAXmLYmsNop+rDbrzsX5m62fAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWVhNzEyZjctYTQ0MS00YTA0LWI3NjItMWNkY2EzNmIzNTE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2YmNhYmM4\nZC1kNzcxLTQyY2QtYTRjZi1jYTcyOWI0OGFkNTcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS7WS7D5KSeNbDbmayY1icmwRQ+1P1pDWExyP6ig++Dh45PmpxBuN85\nLpesKfOEtXWxh7TZGcaOAesiWpsgXypYo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSGGNjI\nN8iK4clt798uXOckU6VdJzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgdOK6axwssIHk5j52tmWM5mskeSMrL26G+sgv\nlVbpqCUCIBuFqi53O7zXKXHz57LaAQEeF2tURqgYwI8y5Me0gsz4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6497", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6497` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISASiXYC/CY+2ZR8nA4MDrA+D1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiNGMxYzM2LWY3YmEtNDVhMy1hNTliLTAwNmY3ZGNiZDY2ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZlOWNiMDgtYjMw\nNS00MmMxLTlhMTctMjg1NGMwOTc2ZjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb4hA0X/U0bQqGsjRDdFKws9uGx2pjRTKoastbh9kbVvHBF8xmqAW6LHpZTrT\niGrBsoBuQxE0OY340KHzG7WPDKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOUHQctxOur057Ol2allc6LF3W5AwHwYDVR0j\nBBgwFoAUKasXZ9TqS0VGLNqCZZR6ou65WCowKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgEnigYcVyNrow\n+gEXoQKvotzyGWycTs9U4J8d7FzBoqQCIAKeePm3zupFATWZc6YaCMrS8mGzRZg5\nIP/t1Npndfxz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATRSzbLhElLhQBHWlyFvxYarMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjRjMWMzNi1mN2JhLTQ1YTMtYTU5Yi0wMDZmN2RjYmQ2NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnFRenF/Zoyks4ibvSX5MgkHX1pAkCazWCKQVkCRxumZWS\nawTnb+Iu7wyUCsnQ8UDasQoQNYyXxtfYWBjKzJ7mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKasXZ9TqS0VGLNqCZZR6ou65\nWCowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBNvzTpDBmxKRJrBsStbvlcvA3z8kGMihMwosV0/PlHsCIB2Ck5/ZJvjQ\nvid4cdaxJzkceDOMvhiWaToQglL1uLg5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAX27HYT+KRyhokRP8uRnxPSPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZlOWNiMDgtYjMwNS00MmMxLTlhMTctMjg1NGMwOTc2ZjBlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMWFkZDJj\nMS1iOGQ0LTQ4NjgtOTZkMS1lZTYxYzhjY2FjN2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS32hsh7tvKT60G2HSehUOzg2nHY55HMFGhpsmMxNFs6h44d1n2MKyM\nW5cix3x7A67DnuwPTDaV2V5JgoIe0jado3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5QdBy\n3E66vTns6XZqWVzosXdbkDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPkpYBQzTa1VLIBa5UeqzHGN8CdXmyneRHw1\nVXNSTiH0AiEAwXctWDC5cOY3xAMM5N7k7kzVp9/ygwU7ykFT9IutP7Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6498", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6498` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAa/gWoB6Bp6QY4so1xepfo91MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmNzE1YzJiLWQ2ODUtNDc0NS1hMjdhLTIwN2QxZWQ0ODk4NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRhOWExZDktMzFj\nOC00MWVjLWE3Y2YtOGZlYmU0MmRjMTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvVfvPalJTXzbOn6OXMIcvT1sCHZFKql/dQ+uJ2NU15TJUMefuJObCJI70CXh\nwrjAa6wOMsUo80+kN4JlccyjCaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaUqhmDBHIG9rerZALNo8rs9flCwwHwYDVR0j\nBBgwFoAUx5/s8JUWpCH+1j274bYxQCGkIwkwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANCcdj/62Qia\np6PptRSZ6xkwKmJl/TXQjMnsch5DE6+MAiBUCxQw5svwkt76rhbYqCITsn09bOI1\nNyRloqowKMoqNw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfq1i3yAG8j66+lFfHaCv5afMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjcxNWMyYi1kNjg1LTQ3NDUtYTI3YS0yMDdkMWVkNDg5ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+2swFy3Cud4TWW49n9MFyUcOwp+cbK8O1+IfzBGMJzDwL\niJtxA6ZfQsrd4D1A/D+VZSHUT5Ol9CMKMaBH7UpFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx5/s8JUWpCH+1j274bYxQCGk\nIwkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTmRfgQOhBomXCSxFL5+tWCONO+ew0Y+i/NvT8184KMoCIQCreufau5uk\njLwXkbnQ6ae+7lqA/Zz5RUZw+q8sP4BByQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAY6U9sVOpJWUt5uTvSTd+NETMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRhOWExZDktMzFjOC00MWVjLWE3Y2YtOGZlYmU0MmRjMTRlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkMGI4ZTEz\nMi1hYTNhLTRkNzQtODZjZS00NWE0MGE0NDBjOGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARfJvsnosdAxrGJT79Ni82ksDcAU5X30pyTZJ9xWt2/XiXj5i58R6Wh\nj4SksX0GHlFVCyQpBgqVmCNrznr9tXFBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRpSqGY\nMEcgb2t6tkAs2jyuz1+ULDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAIOVge9cKbfgWubgVVk1D+4Ly/GtAweSvUAO\nvFnDX3NhAiBdLiNGqkk79dX7Cmk34tbY/7mkYoFMhzmjlDl6wmbcUQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6499", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6499` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbTQgpFMz/vc+buM/swjmS5LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkZmI5MGU5LTM1YzgtNDYyNy04OTUwLTVhYTFjM2M4MzEyOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNlZmU1ZWItYWRh\nZC00Njc1LTg5MjAtMDVjNjBhYzMzODFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiSI+FHrt1pwm/St0TmFdGmviQe6OsKcovwOJsd0ZKcXgqJ/6N7xzA2Sb2kYG\nL5BZnjTlnafXwuH9dw8RJEL4ZaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1++QmAZeT202OeqX68R6fnt1JKEwHwYDVR0j\nBBgwFoAU8+RwMnDNgfAUPc21G6eOgs2eXjswKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCgCl8rNRzX\nHmp6yx1EL/FjsoBjiTQo9vN67r0/7VFQuwIgQM2n5f/efnw7gtu2j0pKxqa0CBtj\nVDK/qdzGSACLyX4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa2buee7wd1eLM4+sFt92TyRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGZiOTBlOS0zNWM4LTQ2MjctODk1MC01YWExYzNjODMxMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDHwKAMNw9WbGlS8nrt/dV9sg1YraJH0v+p5EOFVe+3J46\n7l4rzvr0ajxiKYO1i73n33movSBrCq9/seJ/NG1ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8+RwMnDNgfAUPc21G6eOgs2e\nXjswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ7hotp5vp87mo20npX+Plw5TLYF82s4qlslswx9UhKsCIQCebIDh9xmY\newOtRiycKytf5Z+hl5VuKTCuyp4KMSDJSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISATG5WPtLcCBLcAx4IqJgFK8aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNlZmU1ZWItYWRhZC00Njc1LTg5MjAtMDVjNjBhYzMzODFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5NzdkOWE3\nYy03OGZhLTQ4YjUtYTBhNi1hNjQ1NGE1Y2M0ZjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+4YLD3ZTjlmjfYyt7GbkbXGwC2l8pvNDFRHsEN2AYoqu4zKtGpcoi\n672y27wCjOcPKtawoGr39Z3k8Aed1Msso3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTX75CY\nBl5PbTY56pfrxHp+e3UkoTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAM+bSH6I98bQirsplBtmoEzX5Oc2EXBgLGYI\nr8UQJJVVAiAriul48eKQNad4TjJHlTupQwcnAx9TCR7vxl2jSMIpBw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6500", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6500` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZvPZGI5EEh2lwfwj58P0mX8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZWQzZDc5LTMwYzYtNDYyMS1iYzJjLTI1MTVlYzU0MTVhMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJhYzA2NTktMjU3\nMC00Y2JhLWFmMWYtZDY0YmIzNmM0ZWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw3vst7l4C61gGynZ0dZO9z6zYGy6Zjgz7yyktGvigyf1FmqnmIOJXMZeNqoV\npOeoEGxEPAqEaQi1c/2PLKyC36OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSVKG7xQG0FDxuPEthT/aYUC65BkwHwYDVR0j\nBBgwFoAUgYOqT8a/js5l0ZRfMlmWzdv0hjUwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCHuf8TOnT7TaBGZCqiUhdAvwa7SBVqLE/sb4aXoG4uhgIhAL0sxIRBdKzq\n2SFsHV39Ubg2PM6BoAU70FegHZAzq8r0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYy5JkIw2cOMIFRdpzi34/IrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmVkM2Q3OS0zMGM2LTQ2MjEtYmMyYy0yNTE1ZWM1NDE1YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlEFjV1muIjSLqybsE2XhXH5FbSjMRYG9dyHvmswvCpCWL\nx6XBNBv6+ToG2R9MwUAiT9EA40SUjbMKGLUZOh5Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgYOqT8a/js5l0ZRfMlmWzdv0\nhjUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKELYsT4n94IdpZ2PttoYmmsIcvwT5/cKeg6+F2m5mYhAiEA385T/jUr\ntLiSQzZqYpTq2fqM8trMunv9gHlen5B5tiM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAfZbzrD4Hr+q11REzCst87t5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJhYzA2NTktMjU3MC00Y2JhLWFmMWYtZDY0YmIzNmM0ZWViMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYjg1NDBm\nYi1jZjk3LTQ2Y2UtYTU4ZS1lYWEwYzQ0OWVkYjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASf0QvMIhuhRjIIB/zTndEZljttEzjmT0NLxNsM9mvVAe+oT70WY49m\ngHXMSXhWodJG1T/g9+fCrq+QZVMbodmFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJUobv\nFAbQUPG48S2FP9phQLrkGTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKbGSPWiSjhxQwFZwDT4dx+lyta+fgLyXOkV\n9bmktAJ7AiBdWJdAbrlEun5VqGD2e/Vsu2Z5D8uubO9qIkrVZecJ6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6501", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6501` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbS38Jo1K0/U+sKsW0OThsAiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5NTJmNzgyLTgzZjYtNDY1NS05YjJkLTgxOTRiYTFiMWZjODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmVjZDNiMTktNjQ2\nOC00ZjYyLTljZTYtMzRhMjMxZWE3MGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnm0v0D/NzpagyHYyWcDmoBDRfhkUct2vnPvYAUP/YG/hT0MhW9lKeDz73UZ1\ntwlclvkB6qestAlHebE2PIGbfqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa/I9m19nsyzCXbDIGKdj60DTvHAwHwYDVR0j\nBBgwFoAUJwbB00gjTo7mMuF3ZKPcn7jomlgwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBUvRLMc3Lgex4SMo9Fwt+BCy8VBy1GLGcGne+PXB0dYAiAtHYIix1Q8fnLx\nqMB2H8EPkaGzQ13zTku1ReYiuCS/lw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXn/k5qiTDqGGfM6B6f8XUKZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTUyZjc4Mi04M2Y2LTQ2NTUtOWIyZC04MTk0YmExYjFmYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0AQXMsgmPAicW2PHpcDaiYhttAIVnkVeZUKrS5WCSLk3Q\nqtdqkOLgtsN7nvJX4ndGVoA/hEd43iCA5gfnVZWto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJwbB00gjTo7mMuF3ZKPcn7jo\nmlgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK3KrMYoMGEeWsGznhLzOfLM2ZPkh6tSD5/gNWWlS7yUCIFVynNMQPKck\ngE1p3Il6gEQTXmHZyyvrqfGNz5akKaMg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISASiBLx0kOzr1m5TF2umEbA+SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmVjZDNiMTktNjQ2OC00ZjYyLTljZTYtMzRhMjMxZWE3MGM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNjg1OWE0\nZC1mMTg5LTRjZGYtOTdiOC02YmUxZGE5ZmM3NGUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASSlfW4jJcOSLchdPgY5GDD+/oYOsg1AJLGDs5DGcg+m78zvMn1VNb2\n77lmp/yGVKEk1AgpaEt/GyC7ngGuPDkeo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRr8j2b\nX2ezLMJdsMgYp2PrQNO8cDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhALXpTv0oBd1dtmUiuyTR6H6pzI6a8pv62IGq\noz4KfBSOAiEAiwuHmu5CHKdulafPFtYAZ3B67aDniDJMeqGNiqYvsgs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6502", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6502` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAS0G/w1pbKrGoxbHvnrifN/nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlZTcyZDE2LTVlMGMtNDdlZC1iYzgwLWMwOWM4MWM2MjE3MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGY5YTY2YzUtYzcy\nZS00OGRlLTg5ZmItOWM3NjQwNDcyZTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkW0SuuZhG0/r0+aYIAdUZ5Dm+GrzgbgwVQa5/gB3pj6g9wpPiLpTZDt6CCMj\nBxs9wHenHewQ9ZHRhvwUJJH15KOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxIfovP0l1zVFRSToUKM4+ZUYbHowHwYDVR0j\nBBgwFoAULjs7ctuSQ3epWcND90pw1qd9GIEwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBiN\n53zlJ85osb6Yc7m/RDKt082phIDE9JSDWBy82Y8AAiAjvpW/kGDLZu0504vZLMy7\niAmxZoUSIJnjK9oe70irXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY3sA8oQfCveSDeAciCrSNRaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWU3MmQxNi01ZTBjLTQ3ZWQtYmM4MC1jMDljODFjNjIxNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZmMOOxL/z4a36zc7rtlhKYj0+14aAFiFxxI6JWLEPaiMN\ngYwnXkWqy7I8SbV58pxcTCknLXuEhhZ1e23agJ7Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULjs7ctuSQ3epWcND90pw1qd9\nGIEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOCKwCE/fhXG9zKfsMF8gcU4DKgFzEEH4A04g0QUclpPAiEAtBYtzXKT\n1XtSYAxKaCnnHOZu0qnhIU26nZVtipAOvKY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWk6Eeouk2P3ikyHbM0dVol7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGY5YTY2YzUtYzcyZS00OGRlLTg5ZmItOWM3NjQwNDcyZTQ1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZDQzODRm\nMy0wY2NjLTQ0Y2QtOWM3MS1iMGM5MjVmYzllMmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARdSHxV+5rV5VfrKAQ4Wwq2+mw+ldNZZcuxZTcBs3MQd22WouhNonkX\nauLcGVOax30aGLrSikML/xmwZQ0vv4ALo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTEh+i8\n/SXXNUVFJOhQozj5lRhsejAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgYjkiQ1CU7mkfAhPi2YS2fepthHNuWo52t5IO\nDXJBm0QCIQCVm2VO2m9hkymMgme3J6tfmnCOx68gyZblkzjKBS6bkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6503", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6503` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAegtnzMDU8BKQqi9wGAiAl3dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2OTIzYTJjLWFiNzMtNDE4Yy1iMmVmLWU1MGY2ZWYzMTkxNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzcwNjM4N2MtODU2\nMC00YjczLWExNmQtYjZiNTE5ZDU0MjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjf0OYSylXfyj3arkWev1GJlUSFrVNaqDFsGqBePYwE5Ob1OXTWTeIFGV9TMy\nj8IlLEYezwNc31tai44YJBRJiqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTabW4uRGuQqpix4CW/cZnh6Q4UswHwYDVR0j\nBBgwFoAUCFHr1MmIHAaMFN5BdfCXp7EePf8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCrEV6GZScYNGgAzY5/xqhqu+FM4ssTmmDNR+9I3ZRu2wIhAOi3\ni7U0dL5mblumEXSQZY/O/deKZpG9g9IKF2nA4vY/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbouFmFh5+zAtO2jOFMRhAlDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjkyM2EyYy1hYjczLTQxOGMtYjJlZi1lNTBmNmVmMzE5MTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb4OU5bsHWsfsbeA8+tOoewFSHZ/Bkb0M2ablalRNcPCs8\nCbWL7MlYDjYb6+XaNjz2CduUUQIapY3KXunq19A3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCFHr1MmIHAaMFN5BdfCXp7Ee\nPf8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW8qC1RgLj/b2M4viRVB+xEmasyj5M57RikpQNIjw5iECIBwxVB/Daetp\nen2b0KaIexDcClZBke7LzL1FTOSP56hL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAchkvtK00T11jmor58Ut2LFTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzcwNjM4N2MtODU2MC00YjczLWExNmQtYjZiNTE5ZDU0MjBlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjMWNjZGU5\nMS00NzgzLTQ3YmQtYWU5OS0zMmYzOThkYjMxNzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARc0sRkMEdX1jhNLV9ICTPAYzjlHuEk2fk5QuRDGrU4y8GaMlsi578f\njo54g6a80ZA8rxyVm2EN6ILS02+gH9Nao3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNptbi\n5Ea5CqmLHgJb9xmeHpDhSzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgMmRifQhIVj8UlUEmnb8O4xOzI8hyPrgAwIWu\nL6IoNesCIQD37vDIGcOIX4kUXRVUVTqOcElo2uVkEDsdS9eMmcocYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6504", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6504` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUCSySoLRPItfQb0bJK5ezpIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiYjAyMDA2LTU5MTgtNDIxMS05NDc4LWFkZjAwM2M0MjYwNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTUyNjk4MmUtNzBj\nZi00MzY4LThiOWQtYmNhMjk2ODlhNDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEme2UaLskcRwaekcJQ2nHVqelvBPifOsRcXTDq58RD1T3FKYI+tj7Ne6IYCBB\n8X5bQjk6/tk7YXCvweyyIGWCS6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfGnJLF2lnFb08I9u2ANI32w8W/8wHwYDVR0j\nBBgwFoAUkMTGCd1XcDDTl+5Tx7qxzBLD/tswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCun4shS8E+rhVkDHOuaGJSmhhZHSV6k3G1BVKs5X+ljAIhAIFL\nWevPhGGY0t7GN7mWubSJ7ftZmgU74qcQKag+FHHY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa4EpopJ7DmloA5DVFZoy//7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmIwMjAwNi01OTE4LTQyMTEtOTQ3OC1hZGYwMDNjNDI2MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIOLwzvxZY4JaozhZD87daU2xJCvKzXukgn5Mc6NhhDaNX\nGIyrOi546HYssv5o4mhM+IO94zQ4ivtKXL1Ppa34o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkMTGCd1XcDDTl+5Tx7qxzBLD\n/tswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTR53QT4l9438fqu+Xks+b03VDz+mOQZARbfxp6ynmJICICdzAlKYRxg7\nW7pVQa8R+++P8nA7RMczQFtxGXzlxGTm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAeQ2FCuYSOH4MZ9FTELVhXVRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTUyNjk4MmUtNzBjZi00MzY4LThiOWQtYmNhMjk2ODlhNDVmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyMGYxN2Ez\nNS1lN2E5LTQ2ZDItOTQ3ZS0wYjkwYWJjZTA5NmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARyryMBpFhltQNxqKxdvI3Tfef3OQ6iKP8EbVMK+Ciulhc4w4YoGEvL\n7IeeM+ga80BE5EMiVW4mXBj/VhWN0Ccjo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR8acks\nXaWcVvTwj27YA0jfbDxb/zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgCutkqDNfKgefE0krbPgTtOb7PM8AGoLBkWKW\nH9jkag8CIQDkD5gBwod1S4jSKiPt9WiorIQV6xthv0fl/5O4Ugwd3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6505", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6505` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWK7HjjaQKlKelvwiXEupLyyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiMWFiNDllLTYzMTAtNDU3Mi04ZGVkLTdhMDllYjAwMTA2MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAwZjRhZTAtMTkz\nYi00NWZhLWIyZWUtNTc4M2RkMGRmOTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdmGwPx7yCTh9SCtcJA1fygKckQasKowrfGxkv/UktRt5L8iTcKBtcD1Xlfow\nHRXBX77csYdrbXpTOVZWRdetv6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEGIHILSUEDJMIg8dvNFkPpN5QOiMB8GA1UdIwQY\nMBaAFChzaHJxFwR1ZaCoShNN0hoNeju1MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiB0/me+87vd29afIbedzreSnXh0qXmVt41C\nL6EnwZXsSAIhAIzvODBenKNWx3Ah09N2i3iRjrnNeYjcE3CpirksKwj4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWK5tGkcQfw6IUa5S+LUP4qzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjFhYjQ5ZS02MzEwLTQ1NzItOGRlZC03YTA5ZWIwMDEwNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKx2hVK5GxYmAgef4a/7wsEQZGHfcftCVXICagJQ0whZJf\nRMUuRIqJJ8Dw+4mx/xljyfhq6QLrUpUB/hPaYcYko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKHNocnEXBHVloKhKE03SGg16\nO7UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALaU+51S6gjaPA3kv+B6CtAXN2Z8t+ikVDWI1Q4BunO4AiEA5E3bvOWS\nwB9UPbDjZHJT4eaxW/hM5A0VX2P3pjilWkw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAWrXsq3+IeaJ8e9DAp1RqeSxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAwZjRhZTAtMTkzYi00NWZhLWIyZWUtNTc4M2RkMGRmOTA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmNjlkMzFh\nOS05MGRmLTQzMDktYWE0OC04ZmFjODEwMDMxZmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS1H0e9xRRaWRVBwpBa/0HxEHfsxf0+bk8yXetd76jQpCEvXtw79DFw\nmHHQYm02LPzy6yE32LWvb8BLdaelSXluo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBiByC\n0lBAyTCIPHbzRZD6TeUDojAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhANi2h2sT6knf/gK7+jLBQiLMj+65A1WZwRhY\nmVvmLfxoAiEA1ZlDoT+TwMhbJvswBs+L/MOw70dJYqo1dSiSl2AR2WY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6506", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6506` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAY1eMQbqeQYkrGE3/RbkJffGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjN2VjZDg0LWVlZDUtNDMzNi1iODNiLWZkYzc1M2Y0MDAwMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWMyNmVjYWYtZTI2\nNC00NzJmLTkyMzMtMWFhY2M4YWUzNTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETVfYKKW7IfxB8OlWV3+FZTLBLIW93/F/aA6WW3OELaHXVy8rlMmri02GApPI\nVKVWCGJXOm8ZnSdnknJILraSR6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCVjjAUD8ouXpKpz+WctiDQemHUIwHwYDVR0j\nBBgwFoAUFCra+pdnFH7FaMVvn7hXTPoP4NowKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIXEBOsUVycH\n23i3qDl58YOPN/Xh1jiDqdiSrqrRBlPJAiEArvDJCyG5/npZUWuGHezFKUv4Us/y\n2ii1C0q20pBAeF4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY3Pwedg0/Z7l2gQq9dSqokNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzdlY2Q4NC1lZWQ1LTQzMzYtYjgzYi1mZGM3NTNmNDAwMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJCXrMQZnLZEP0T8do4ROOEo6k0o1mGCk+PQYwkStmqVoe\nIYdwi+PVsvDShtSrmvJHZ1j4pYhuwFjhlg9kXt8Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFCra+pdnFH7FaMVvn7hXTPoP\n4NowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeb9tIquPs4sy70W6RFvPnS8yh8i+Glu427zWKKw83TYCIGbp1p2EC4bj\nb96FbnsJVpsvbHu9wM/MzSO6EWuBdYew\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISATSzc2GuCdlv58AFXjLcHzR9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWMyNmVjYWYtZTI2NC00NzJmLTkyMzMtMWFhY2M4YWUzNTQ3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZWM5Yzhj\nZS0zZGE4LTRmNWUtOWFkMS1lOTVjMmRlMGUyZDUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATjEtNO+zz4P7bJFvLR25KfiTvcXmoPuqfLJGxaTdqmFRcsiTAw6+M/\nieKo0EdRp6D/tn8VtEH66FY5e58Mno6Wo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJWOMB\nQPyi5ekqnP5Zy2INB6YdQjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhALnS6es1l/sD1FaQdZjR0z2wUCCX40jINuBa\nBOTxELOBAiEAwy+MVWaxUO4W9BRlwtWVDK1cYp4bzAEMmz1avdZlnI4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6507", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6507` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAdi0m+VEDa/EuSvbboHgPmhbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1NjZlMTliLTYyZTAtNDk2My04MTRmLTdjYTc1ZjI0ZDQzMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRmZTE2ZDMtOTli\nNC00ODQ0LWEwMTYtOWYyNjgzNjViZTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESAB/rXbUyH3qybYElIoeUeD62Gi0siuSbrimZL8jGxax/YiFsimfKOvYQ9DX\n2V88vQXNK/6Bf8FXCleoPM+rH6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTQOeZG97p5ZnXjB3KMcCfxpxU2IwHwYDVR0j\nBBgwFoAUXOKKTgmC4xUajJnF8swvv5dVKcIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAOmCR0BSJpyF\nZebcuNnQ/QoeUcyZjMNIjjbtwALUmsHdAiEA36iJXQN37WKXdRzfUljMKx1p57XW\nh3XcyARKbwrMHr8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUYGG9dK12PK2mjpZbUgWfVRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTY2ZTE5Yi02MmUwLTQ5NjMtODE0Zi03Y2E3NWYyNGQ0MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPXhDXkSluVADAifkm75hTuEvV4spMtP43PlhqXQcO3KkY\nNewLmA6wfWO3vCePOMUT9aj3DIPCWyvcHOcfUfkwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXOKKTgmC4xUajJnF8swvv5dV\nKcIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIu4pNRMHjMreNl4HaDOj1x4UKY/myClaEWcy1XMlkP8CIBGsUTO3nVkB\neNBpkWfMk7N2PH65+xq5Nxt99CUg8YUU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAWCshYORB8AviMpvCVcixbiYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRmZTE2ZDMtOTliNC00ODQ0LWEwMTYtOWYyNjgzNjViZTlmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1NDJjZTY1\nZS0zZjI1LTQ4NDItODhmZC02NDBiNzJiNzVkYzMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATUHBfEE0zOSeX57Gl1wqPj1fL8UAqebJwJZxsDZfPhtyj4wTRFjVo1\nhF3AchKb/pZFitLV9GiISjV3Er+6oF2Fo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNA55k\nb3unlmdeMHcoxwJ/GnFTYjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgM/bd7x2MRTn38v3gqwNTM/br6gFutio/k7lS\nhreFq5YCIGChNTv57YmqUT1GAze3pLTYkDkD5Q9iIRb0w6XPyAEV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6508", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6508` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUYPk6sXC2lUHpBXXcIXoD+GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMzNjNmIzLWFkMzUtNDM0My1hZDUwLWQ2NjI5NTc3NzNjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRlYjE0YjYtMTlj\nOC00ZjU4LTg3NzMtNTJlNTUzMmQ1NTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBrj4buxNyl349Deo0x3H0dKWpNVX8MNTw8WT0YdwfyyAb8XVGZV+EK22Ys/Z\nZswlXTTpMcCGtcY5drqHNAGEqaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKcV7p5Yj+n5fn0718sZvyGTpcXYwHwYDVR0j\nBBgwFoAU/8v+nxif8f80Vtw1MMGoTkGyuOowKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICVMMcG05tDL\nLru81cS9nU4kZP/RIOYzhCmP0jH+5y2EAiEA/TOYsozPKkvge8mmnpT5LlsJgjFF\nE0Eyhk6du83cmps=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbAtqhYpBs3/Ki0WiCZs/G7XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjMzYzZiMy1hZDM1LTQzNDMtYWQ1MC1kNjYyOTU3NzczYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNjEubociBozRZNWMqBdobAENLTdUiroYBN4iyd3qosMZB\nC3BdpVlRH9BDoOAKD7PqLQcNFLjRKEnIydL3Mp2Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/8v+nxif8f80Vtw1MMGoTkGy\nuOowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGwaH0eNzRrwmrCJBoEayGGa7mGFurkdO597+7I9QvN4CIQCY2mqKElSM\nF+sa9KmsCmukla+tid60EE4RAPoFUKH7ZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZHXXxoBG5COfg2LP8y5OdvzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRlYjE0YjYtMTljOC00ZjU4LTg3NzMtNTJlNTUzMmQ1NTg0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzYTQxYzA5\nMS1iNGYzLTQ3ZDYtYTFiNy1kODBjNTkzODA1ZDQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARbuZ/vvm27fz4+6oqWlSdwcRE4YTV0+z2lPxaAQUImmVzPemL42CIK\n+wlTWwUGwXhq38i36G058GfyI1V6jTZWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQpxXun\nliP6fl+fTvXyxm/IZOlxdjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgKtMBCceKLT/E1hek38b/UH303y1izR8feiuH\nzdJqx8cCIQDHbuklBo/HMpaW3zjTG/Wn9HUyI5pn+oqISglBLwCvvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6509", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6509` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAU3CDcrVkg2jDLtz2Nq0jbiIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxYmRkODQ2LWZlZTgtNDFlMS1iOTZmLTBkM2E5ZGNiYmI4MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk1YTI4YzQtNjAy\nMy00NDU2LWE5NTEtY2E2YWNkY2M4NDA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEvOdNZMi1gj8zISa7JvPE3lYB+FYA0M+H29OZzy1VEw3PEs0ze3nZmRlD1p8\nOA9GNdU/6kPwO08hAcbhNNeKF6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoZwNDacu8tQd7myGNoQuiPrqCHgwHwYDVR0j\nBBgwFoAUjAPfoh13HcedI4Qb114Ze6vfYAIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFp/aCQ/HaxbAR++n0B8F0qletKKMKE3wi4k1q5iYzpMAiBYyypTXP4l5zPs\nDEmLRSHFJYM3AKscMXRmn0f09fyf8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeo+jFKjCBD0XF/zc1ImnhnsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWJkZDg0Ni1mZWU4LTQxZTEtYjk2Zi0wZDNhOWRjYmJiODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHpk/jBaazpoC9vVfn7U2OK4Wz3J6QXlZdbnF6BmnUr4K7\nojez5UYtEiwz7MNfI/lgpbFTihxKvW9Vgc9H9oIio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjAPfoh13HcedI4Qb114Ze6vf\nYAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgajUj2gQ2mIEQrTmR+vdvsla0pli/4owJ+KjkUgEEcuYCIQDbRcD7D07/\n19EVw8/oDh/KsKRC/wAyVKPg4DPxufBXuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAY9yq0dlkD8lwHeW8/DijCVXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk1YTI4YzQtNjAyMy00NDU2LWE5NTEtY2E2YWNkY2M4NDA3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4ODAwZjI5\nMy0zMjA2LTRhNzAtODI1ZS1hMWM3OTA5ZjU2Y2QwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASnYQrKKdBWKpXbRfoIQ1PT7cwbaiikYyi/hJS0kGAGKF6bMopLBxMy\nwL2fDiwhm06TKCbRVoKrwEoajvp6QZ2No3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBShnA0N\npy7y1B3ubIY2hC6I+uoIeDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgTxfL7v91RSY1Uw2FiZkAZEL6i73uVO0z/hZs\nCBM7bXoCIHe82JHZYDGzOghda8OAz/grLHBHcsNHk09B2TjkMomu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6510", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6510` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAfPyccpojhZ52R74y9e12gy/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0Njg2NDU1LWYyMTUtNGFjOS04MWFiLWQ1MjM0MDg1YjZkODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU5OWJlY2EtOTA1\nOS00ZGQ0LTgyYTctNzYxY2E2NTI5NWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQa/FO3r5zxb5o+SiPKkj0unMGqvz86BhQBFUeY915w36J4uoQESTB0QJDxE/\niLKZl540BuH8GXl5GJsZEsxgsaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUPLvjYZ73t2DNLYB7pfHqjZFEOkwHwYDVR0j\nBBgwFoAUgiIvbWS5QNgVfDxWB830/2kWwv8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCh07fx4fdc+yrafI2pGq/SgoVOaATDHH27iTWHQNw8sQIhALTn7QI2gtVP\nQkNXV+VSFmpuPb1f+LjliS9SaElILmnd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWfXxBNh3c/BBru11fwsj7k8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDY4NjQ1NS1mMjE1LTRhYzktODFhYi1kNTIzNDA4NWI2ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjFvlLNsJJdmxM/gCa+2nB/QwkdXZWggtDjPCf6N29Og4t\nf43Ji2bQTQG99/IaPeWVSlWG1m0gTObtLgDcdF48o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgiIvbWS5QNgVfDxWB830/2kW\nwv8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOqemqtWFna0IGDZmvt41lFZEZf5kvZgHfMX+Vl9CtpTAiEAsQjszlwP\nnD+LxvA7cDeUagJKHYHYv1MDXzt3z4T18Uo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISARqy35x4CSkNXs5B+CG0iKlGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU5OWJlY2EtOTA1OS00ZGQ0LTgyYTctNzYxY2E2NTI5NWI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNTMzMzA0\nZS04ZDhkLTQ2NjgtOTMxYS1lZjA4ZTZiZGFkMmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASg2f63CHxELeiRT8B0HEqfRoLo+2UF+87GhkPo4cIclnP+sbCkd4B6\nzbAszC4hsEQQXFJx9Ib0Ox+YxZjmlNjro3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQ8u+N\nhnve3YM0tgHul8eqNkUQ6TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAM4tk7T3Qr5Ilz1SpxNrUO78PCs90eQSbDhs\n/tfGXlvvAiEA3ESnXavg9hODfXFsnzWS2hG3wd9q3Oo4xa3jpsMwHWs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6511", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6511` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAdoFFBHAMWU5qH+8HtWyv9frMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlZmIyZTFkLWUwOTAtNDM0Yi04MGMxLTI4NDAwNWI2MmY4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBjNTI0YWYtMDcz\nNC00YTdiLWEwZDEtNmU2NDM2NTkzNzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbD9k7NuoeFbwAHaTY4S5udoQD6bMDVMZkEXFBrX1HDLBWLr178cA0pq0YGhx\n4VePvSejWQ9NBhAR3DNE/YJ9iKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7u+b0fA98cvzzST5nAwD+y0zi7gwHwYDVR0j\nBBgwFoAUdNyOk+q9aR00cQvAV+1APvRP4l4wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICSs\nIlLfhtYT6rLuPypgDDFnNNdW57smZ3vylclvUHmnAiEAj88ryxaFw3dq+uxZlXNp\nm7HP7khl+F0qJrhi9WcpQ9A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWCPB+i+5UcxcFwoOJ/rabEBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZWZiMmUxZC1lMDkwLTQzNGItODBjMS0yODQwMDViNjJmOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkk9Zgv1JXH9kdrKXcrmV6r17cVp6llvesAuAbtiiq0WCr\ncS7Q5g9sV35XN9xeXbkbddlIPBK2vr+AtIeDfNcVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdNyOk+q9aR00cQvAV+1APvRP\n4l4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIMmTf14SgMikdyD5hKDE0gQ5p2ArB2IobMoQAk69vzqAiEA4YCU580+\nCvFOZKJrCBkYOohuATmoXocDZRSyI/2SqEM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISATy21WDlOV70lGTjs310S3nEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBjNTI0YWYtMDczNC00YTdiLWEwZDEtNmU2NDM2NTkzNzJmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNTJlNjQx\nOC0xZDg1LTRlOWItOTc5Ni1jODY4ODAwNGIyMTAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ97oDlauja9yHWuSTJeXLsqePEUCDsVsnOoapNGej0qyII+lJFPQFH\nCEKfl8IdNGXY2elmMVVTWlQ7v2YfKWh0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTu75vR\n8D3xy/PNJPmcDAP7LTOLuDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMskAxW2Z9oLOeCCaXvlaLWFrqy96uH1vBKd\niKqC116tAiEArFy36hDHwenyvk4FQDCPIqTeCB8gCBA1yzqEDL3kVVI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6512", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6512` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAV2+ybozg2UQZaFG37op2mf0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzNTA5MTM4LTg3MWMtNGNhZC05ZDdlLTMwNDIyZDhkN2IzYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E3OTU1NzktZGJh\nOC00NWNmLTkyNzEtNzJjMTdkNDAyYmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcHWUpGlUeP0za8nRPBUziyV2mIJG2as/PlIhSG5p7poviMQFpyykdaECKydq\nCxkIEmtGSts3fZ8L7VKszLp0NKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/WgvP61oifmqEjJT3P6wGzlRD30wHwYDVR0j\nBBgwFoAUbUTB9vQboZnGBUeeiG1pFhyYsiMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCuY7Lh0KmrkCJwCGJX8Pt0za/aM0ZktIvqofC/U3Xy9QIgUSv5\nSXH75HbfwTFd5XF84G25DhQI9YlhSmNEiCmBkOo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW4lxTjWNj0/ZnwKLPXxeXsnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzUwOTEzOC04NzFjLTRjYWQtOWQ3ZS0zMDQyMmQ4ZDdiM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyuPVjprRvRkDh/2FWkhf+4tyfyOBg+Oyg2YsspDwlsP10\neWK18EnU1m4Fp79LUVYpa4yhIHikdSDJYC4ZgQk2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbUTB9vQboZnGBUeeiG1pFhyY\nsiMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP7O3CkoxKH8HXR9rbcZ/7fKnkccTqNXfxxIYwBPtHERAiBaHjMSj7yW\n04h9bP2UFkC35iJVQX1DfLYIYt6Ch4Pzag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAf4dW/YEQ/1zx4QVJAVVuV7hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E3OTU1NzktZGJhOC00NWNmLTkyNzEtNzJjMTdkNDAyYmZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2NzU3MzRk\nZC02NzA1LTQyMDYtOTNjMy1jMTFjMTFkNDgwZWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATKmxwHhbuBpG0CdqQMNEZoj1nBbT8duU0jqEYk9uZLHtlfa7yc2j18\nFb9kcCpS1m5mtPbS21GUQcB0G+x3BpzLo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT9aC8/\nrWiJ+aoSMlPc/rAbOVEPfTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAO2vf+dTbyEoq9TM2LW+kSngrL9GfjTFrdkK\n1iBiYSQHAiBBW4DkqKwuKbNGslP4ug6uE2HjFnaSdpZgQzud6Lit4w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6513", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6513` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAWRmq4yX/fS4VfDXO0ulMGz4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0NGVlNWFhLTFlMjgtNDNlMi1iM2E0LWU3MGJhMDI0OTMxMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk0NzNlMzgtMzhh\nZC00YzEyLWE1YjAtNWM3Y2ZjMWRmYzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg8gBMsdjWwJsHjz7TPgSyJPIryRlQ9TIRFyXvPyYfnw9q7IffY4RCp3uAkUB\n/1Aomn3mRyhM7irLFGYTjEFGtqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMUZWT9GiyDSVhcneqxEN3U0KhvwwHwYDVR0j\nBBgwFoAU5FitGd9eAhqcmnW4MGkYbbBhwi4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCZjMpLNxpKh/SJQ/OywPxDsbIyC6yFVL0NJwjH/UsjtAIhAPw8\nSZIpQQeiAd5niJAZr29hTCs5HOaXjOqk9w4gh4Dw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQDh3wm/HwlnV+yqmOgJrIVhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDRlZTVhYS0xZTI4LTQzZTItYjNhNC1lNzBiYTAyNDkzMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYKgRfu0/RwfYScCnMi5rqRfbW6A3XAoilHVZVfd3FNAR3\nNQ5rQnwYEQ7rkuWt8nviu/Lm5+Yi2/BbUPKVgGuCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5FitGd9eAhqcmnW4MGkYbbBh\nwi4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMQwBI73WXgLtmgKq9aTE0D1Iuuy+QQGs/SK6xTzVeMJAiBVoD7OBb/D\ns4pMoI4h9VqQENFu9oXGMEGy3gl4tv9fgw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAfvVk1U87hXYa5G5KD0uXbLRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk0NzNlMzgtMzhhZC00YzEyLWE1YjAtNWM3Y2ZjMWRmYzk3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzZjRhZWNh\nMi0wNmNkLTQyNGYtODE0Ny0wMmU4NGFjODVmZWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQDW/2vhmn2YuFBG2vhyYjm/mHTxIFwptbddUh/ckUZ1PpKyFGJxGkc\nTQGWLtOIUIcLIvzltGEhxB4RfFe2GPWfo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQxRlZP\n0aLINJWFyd6rEQ3dTQqG/DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgRmrbDKkDQInwie+SOk1yTYK1AGVlkZn4qJkm\nAD8FVoACIDnuBctIFAB4JM5CWQLRN14S2mFiO+gEuwA3tKhKYwmJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6514", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6514` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAazliickDdpJDuS3k9jYTn/CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyOGQ5ZDcxLTRlOWItNGIyZS1iN2JjLTM4MGViMDVlYjE1MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE2OGJhYTItZDNk\nMi00NjlmLWFlNjItY2M3ODllNTI4OWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQlZwxZE2LjRZBBQsH5bClUmpmaWfrY47Rfd+f8gmE3tDpMwKI4kLhOSc6S2s\nqYXbfFURc01HfZ/TH5xgG7PEWKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTQF2fHiLIc2bVdkARabHKs8mdAHjAfBgNVHSME\nGDAWgBSnC/9ILOBtZyq1BmhJb30NdAG45jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAoS+YhcYwXOdS0qaXFvW+kFpdT+cm0u\nnohT4oTPE0/KAiAm4chWfcrX2hTC16kW6P1XL9oQdDQOVKo+0fgw4M4F+w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAccru0YjCyh7x0HGCD1C1uhyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjhkOWQ3MS00ZTliLTRiMmUtYjdiYy0zODBlYjA1ZWIxNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIVAl+wEhckv+bvGv65BVtKsa19k5ZrDqDNhQG28UeFEdG\nS2aI03tYn+dHH9bMzTCm806vOXf6cHPHlhNmi4Jxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpwv/SCzgbWcqtQZoSW99DXQB\nuOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIp+fqW0WD9u/QBkhu1yMrTELOxPlGXQn1SPMHX/nBvUCIDTOHkO6Bu1c\nOQ+0YMQhC8MbHUTJ5RbZdkoYp6jZ5Fwo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISASTB4Oc4JWQHCENxb+3qPFOFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE2OGJhYTItZDNkMi00NjlmLWFlNjItY2M3ODllNTI4OWM2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxN2I2NGI1\nZS0xM2EyLTQ2YjQtYTg3Mi0xZjAyMDQxZjViZTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATJ6DCjjbxuEpBKk3biehQ+/x7FAl3UNFoPcupWCBlDqS8IPmSpMCBh\nw7YSts4hQa2BpnJE2Brv3CkgKBTpUYRro3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQF2fH\niLIc2bVdkARabHKs8mdAHjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgKQbUNZCSpa5m7pJyZEy4jNxBMd7ieHhXseJD\n5ogeTk0CIEDoVpxXlTrgz6IorI9wszrz2E5MTNDAxZAaGS0dcaHa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6515", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6515` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAeAIYkqAL5V7DaI4z/03PIxjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwOGM3NGZkLWUyZjYtNDBhYy1iOGY2LTlmMTQ4ZDczYmUyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBkYWExMDYtODhm\nNS00ZTNkLWE5OTEtMzM1MDVhMWZhOTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESiLnmxUXZPnldMTif6R5lwoUrCXQZlcZjlCUb9nxs+gn9o7JjasbX6Fh8y/d\nol7fvT2U8Dm3Zlb3w+4xnxYcuaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6t67vYPYDr7DYLTQrAbaEzg23dwwHwYDVR0j\nBBgwFoAUTDJF03msMWytEsyUjgON8Q2uZu4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGzSMHP3O4MJ\nfNi6vVRtmALJufiYKbO2Y+L1OOA/PijTAiA3wvKECOOAZnj2y/25LGTLIsHde291\nWeZ+6htflVcPLg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeS9bKmu6+aLgExj7BIn96w7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDhjNzRmZC1lMmY2LTQwYWMtYjhmNi05ZjE0OGQ3M2JlMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKiTSCMGQDzdkVI1pNuOg0XC8SyvJpDsvRJRicUKckpezA\nq4z2lSEZigrZooxgHSCvObswdLnGdF3kiOYVOSLto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTDJF03msMWytEsyUjgON8Q2u\nZu4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCRVCau3GDUPC2B69+mXQeae7vjgXo/5UwvzotUTObAACIDzxsMbA6n/j\nrusAMLGBxFh6K2d/kEhtq7bYpwaVwvUo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAaEOQBsWZTYGiOnpkXhXfQikMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBkYWExMDYtODhmNS00ZTNkLWE5OTEtMzM1MDVhMWZhOTRjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNmNlMzA5\nZS02MjkzLTQ5OTItOTVjNy1kMmNlYmQwOTY3ZjcwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQN7i9L1nEmpH4zcUO6q0OCTjzPu6fU0dTN5UM//HabPYm07LRpKO2U\nI79E/i9nE81auwG7xzPuwdqASVEnZz7Wo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTq3ru9\ng9gOvsNgtNCsBtoTODbd3DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMat3vfd5BElchfoVxNtXRw/BC2eR67f/jOE\neXW2q9ZRAiEAt3WDDmEowsZa7oWWRfcfpYuN/4fs+xCl/dCNOsWXx0Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6516", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6516` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAWectW7GkzgZTqru3GMhkDsYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhNjk2ZDExLTdkMDctNDI1OC05MGI5LTE3MTgyZWUwMWYxNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ1M2I5MGItNWYz\nNC00NDg5LWI1M2QtZDI2YTc1NWU0YTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAXKSmoSRhF5et646L8uhvlzyIViM/arwprlLX03HQPD57Z/Fb7JtIGJNrfHQ\nhItz5l4gOYwB1XVTQBP9MQSXKaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ0s9mZfBF7xku486Nr31xl2Ao2wwHwYDVR0j\nBBgwFoAUwCHvWApeXSFieJQTDcejOaqqewwwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQConjBl5gIq\nn6ZrAcD2SZqVFJYUOeNkgGEVH7g4S/wtzAIhALU5KgWSmsuJG0PuW7O8b57IGvQk\nHgLCxH4QuJtJ4ItP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaU5ubLcxK4FEhAlw9ypwJGNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTY5NmQxMS03ZDA3LTQyNTgtOTBiOS0xNzE4MmVlMDFmMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQW4HJm6iWZbJ34OD5Uuz/rvJWUpNJAW6lfb/Buf17m12+E\n2yzzBspl78IU9DLo5Tow8r1kMasuJs7HN8LL5ZpKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwCHvWApeXSFieJQTDcejOaqq\newwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFoaR10IOEyRSgY0WSw8d0flaGIRAmvWps4ooAcxHnHoCIQCYxobSvUB/\nu0g9io63Kbp1IjX7R8tDlRWldRp1M4pr5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAejtrPqeFAU6sUiKM4fUEd0fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ1M2I5MGItNWYzNC00NDg5LWI1M2QtZDI2YTc1NWU0YTE3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwY2Y3YzBj\nNS1iNTZmLTRhYjItYTYwMS0wZDMwOGFmNDJiYmUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATmFsmVenIVzFj4H8QTsM2sOTCNuwv8Q/hFBepnWulEOeLWsc6V4S6L\nNmYIorg9TScHb1wElv2xmVNTABMziS7Qo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRnSz2Z\nl8EXvGS7jzo2vfXGXYCjbDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgZ7RzXzfpSTHm/vC/q/8u/8THSjGRhOJ1v6eM\nuFGeptcCIF6lFWDhN8GyHA/JZEVPj0svw1wHiyhXo3fKGQV0go42\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6517", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6517` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAdXzJ5WZFh+vwhLs+z7xVsuGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2OTgwNWQ3LWI2NTEtNDM3ZS05OTE2LWIwMjNkOTc5MzQzZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNlMWFmZDktODgw\nYS00MWQ3LWIxYWItNjBhODlhZjJhOGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc3NqVZ4hhMiKWBnP8MAP6vDr/0emsnSXo/9nQ24nGtws08Kn4vpxLGryjEpu\nOjQ4FYUao6+BmdFUb5nQgTGvcqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcHnwWwXT7xqTycUkGf9zflCZEcEwHwYDVR0j\nBBgwFoAUtinqk5hMJKaCbi2g984FA7qvlX0wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAVh6R7oac7\nUF/E5GA9fBECkv+0n4u8Cx2djwE6xum1HAIhANcBQYE8Oyo+D/PSl4KDLOMZ9Oy9\nIEB4OWpAIokabOMJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ77bhmxTvyc/3tiibisKn/iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjk4MDVkNy1iNjUxLTQzN2UtOTkxNi1iMDIzZDk3OTM0M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8RnS9Wbhiu51LWvLIvocCKVzoxE1KIm62RH7bFyWaw/Mg\neC85rXEUjSoD8mjI+3M1DUyEFMolbCw+osZNRFiXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtinqk5hMJKaCbi2g984FA7qv\nlX0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPpi410dKP3JYDDmYY9rtFyjiVXp/rO3YlCYN6EWF/TTAiEA1mAzulYB\nu5zpImpBIUSrBdf1PUKqHWT0De/MLJfxvNk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAYzUyBI/WuojImYF3rqKfzF8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNlMWFmZDktODgwYS00MWQ3LWIxYWItNjBhODlhZjJhOGUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQxMmFjMzFj\nZC0yMmZjLTQ3MGQtYmZkNi03YjdjZWI3M2Y2YWMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+/6Y2I0Po20MMXc1JnV18TnrRxBWxISMGJ+znTJ8Rb2+H+JPy0vwJ\nBLNVtWY7JPeV5EUYnxyp+WnzOnkaNs/ho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwefBb\nBdPvGpPJxSQZ/3N+UJkRwTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJXka/+KxgpDAWnvEX9euyU3xmIPDEzgS9Ol\nwrKwxEd7AiAtmNNlle0jHh/3VPZddL3fdB3Ok9UOIDZ3SNQ9Dc0nwg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6518", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6518` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAWAp5crwvjHe2LEE6JnsXaeeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3NTE2YmNkLTUxMzktNDUyOS1hMDU1LTI5MTg4ZTc2YWQ5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBiZTYyNDgtY2Qy\nNS00MmJhLTk4N2EtYjg0MGZiMDdiMDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESh0sco/8vfwRh27nVyM7rEqOyc8tDmIEzlVPu3Qx8o42A3Lp8LnvkJ38C4CA\ncesKOOnvILvIvRizKVbDa/ElaaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUchZuz91qLPtXPTk2KU1vQ8xVF8owHwYDVR0j\nBBgwFoAU6e156LIeH3awpFJ1a/SzOA77DrIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiBJNmgREhaaJUrdR98elzhHPTJT4061fSYrX7DnUE8ueAIgECGoKsgbfQc5\nZsVlVuIY2sLRqSAFlU02gB3pijt2L0c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdG2LriBibYX15zYptTbe+YGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzUxNmJjZC01MTM5LTQ1MjktYTA1NS0yOTE4OGU3NmFkOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+alYnj/PN9y4mEfXw95Mte6Ny0MJ7Nzkn8B6ik8wM9AWf\nTgPFa0x0lXHv4y6pz/wRQvj67Hh1bLuU8koFsarRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6e156LIeH3awpFJ1a/SzOA77\nDrIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcaocwFUw3YTubf+uOWHLIsG22Q2E7bRKpk/eBEZOXYoCIQCOvH/0L3ij\n40odZUwWgC8b3XFDxeM9oPw0+ONKGS9xGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISARRK1d0JfeHUammqjUxY2ZsoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBiZTYyNDgtY2QyNS00MmJhLTk4N2EtYjg0MGZiMDdiMDk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5MTQzMmFi\nMy05ZGMxLTRlNTEtYjRlZi00NmE3ZTU1OWFjY2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT/8CRV2nYPaOUqmJtnAU13iL+hZZ4ehHxbv+qzgx0mxMI6xoKPZygc\nTk/FP8g0b82ZZ0s3ykuVvP+fb3I+N7S0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRyFm7P\n3Wos+1c9OTYpTW9DzFUXyjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKeLD7Jy/sg/eNPU/YX/PJuj8S2MAi0+m1Gs\nnboUsuSHAiBJ7WtJnFexnI/qdyGirbgM5ekzGTinymDql8uYy5xPLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6519", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6519` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAY52PAlpIwfEcrITXCyHnzM2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3MWU2YjhlLTgzZTQtNGNkMi04NmFlLTk0YjIzZGRjNDI4ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRjZjFlMTctOTQ4\nMy00NzZjLTgxMDctMmE1NmMzOGY0ZTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7m+gu1P0j5GG9zgZCw1qRaVQrGJaLq3VpURHj66fXzvGu4VtE0V8AlnsTyMR\nd62Gm6aH3AppR9C82z+6WjjusaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdUcl2dEVQHciqOfEkNOsLWttmncwHwYDVR0j\nBBgwFoAULaCPN2j+23nR9URXyDiaSG2YvrcwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAfScyjO/c3RfrPpoKb7c5jnL+WId8GlDVx/f+uIp4ZRAIgQ0bkUkAK16sz\nXxhQAkKsAbr8UDkKx5X1fatk6HbcHVo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQxwtkmoNlWLQXe8gB4OpY0TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzFlNmI4ZS04M2U0LTRjZDItODZhZS05NGIyM2RkYzQyOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDLsRL4SSY1luxeF0ow9sFF4Rm6z+a3koGPCqGImjez7Go\n0gCPvhUXz7DFNyyviwC1nH+QJ5VQSD/ToWQc8F7wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULaCPN2j+23nR9URXyDiaSG2Y\nvrcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIIRGGBHhFlt1W+BaLzmm97fpTk0jlo/T2lnbwvsVPejAiA172qJdR0Q\nLO39ezMYb8dGyY/CGf2cPQBiovxETb/Sew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAXD4Do0ZzrgJHcxACVobvj39MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRjZjFlMTctOTQ4My00NzZjLTgxMDctMmE1NmMzOGY0ZTA2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4MzU0Y2Zk\nMi02MWIwLTQ0YzktOGE3MS0xNmFkNzA1OWYxZDYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATXWbkzrIUF1gfdzEJ+QWQupR0tFfPQcM5EHhBuJKrU8rI6Px5Hi9kj\nyc3FMd4Saly+Kk4vdeX7hrW/1UGYaI+yo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1RyXZ\n0RVAdyKo58SQ06wta22adzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKM2q6CCXH6YTfpPWcCGBRtK7QT//26LYF8k\nnf/2PYwOAiEAsRUjRG8kSk1ocbMoI8qGJHon646RkUw7I08xkkITH18=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6520", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6520` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAXOpdmpo6YqAdepZHlWu4uNVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1MDczNTY3LWFjYzctNDYyZi1hZWM1LTdhNzUyZDkzMWY0NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNhM2ZkMDAtMzJl\nOS00ODQwLTk0M2QtYWZkN2QwNjE5ZjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBa9nMUhegPUsbbsb8FuV9UJl+clWrO95OADf0wnC9nV/JIJad/T03XgkMXNd\noofv8V6AySnjj7zQctgtn4S5PaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvuIG+66El9Emt9/HAiLHABSR4KswHwYDVR0j\nBBgwFoAUqKIlkOqqSpD+yoEn2iKkxwRL+TMwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\nyYZS5wseC56Th9pIRgJ9CDGBLxS1PNuTtazULdc755oCIQDELOnEZ8l9G6FfanFL\n5mrr9KHhXbWZh4bQpsGFKUXSAQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWxF8eBZ8LF80ykLmF+vKaa1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTA3MzU2Ny1hY2M3LTQ2MmYtYWVjNS03YTc1MmQ5MzFmNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQICPAW6uPv1t7NP3E2U/2CqRoH9E5sANz2KU4j63ANckDv\nueZc6+7yJTJe+2y9uYdcPwa4Cxzmnr6utJA2RamVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqKIlkOqqSpD+yoEn2iKkxwRL\n+TMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD0IUzlnosTcjC06HO5sQ3ji65JED3bspp0v0ytl19O4CIDkkpIINzOIt\n2gkzmwgUOBTBVyc16XUpMwqiCGAbjned\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAcHMURNmQIEuP95ucNX5tdW9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNhM2ZkMDAtMzJlOS00ODQwLTk0M2QtYWZkN2QwNjE5ZjQyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzNDdkZmY5\nNy0wZGMzLTRiODQtODI0ZS04MjcyZjFlNDU1YjQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASKGmnhpylLAeYFsTfH2vMRUAJoiKh0wjStSt6+8gwuE1UKJDr54uFh\nbzPUiK5yZ2svCO88dGupwQqj1RxpypMoo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+4gb7\nroSX0Sa338cCIscAFJHgqzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgWWZt/uNzGxBi7JexI1FkPahHbPHRCubhzz/L\nRRRShc0CICjJKcjwUsCRpki0UrH8LClK3BXyzS2I1X7k+dz7mhXp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6521", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6521` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAWFVCuofN/BZyoTIqfPP6BIpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmMGU5NzIyLTQ3MDAtNGI4Yi05MzljLTEwMjMxNDhjNmRkMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE4Nzc0MDItNTdk\nMy00ZDI2LWIyMmItNjkwNTEyNmMxZDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhGmKutAh8KBAcNXlAiCnKDjsFzl6smBkVzkp2yr9p2r0bf98UOU/0NJH+Zyc\nJNmmYwOMMYiDXWqPPpUblVn7UKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJSv/iZ7jXKN7iaLIkOMnRBnBNowHwYDVR0j\nBBgwFoAUYUtZXd1vgs/hztc/r/P7za0xVe4wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAyRbxRGZW++FIyljFe4q7dIG9UeEtXx149E9qmMjRSRkCIQC2\nF1Pq4wN3X3DG7MibtvFolwc2etccuDeCvuEcz5RxTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbuNSEhyqwFeCo8pGtkO79oaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjBlOTcyMi00NzAwLTRiOGItOTM5Yy0xMDIzMTQ4YzZkZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4wHBW3P5ylAS60SMGzP9GgZW9CGZM1DtOjHZAAIqunQai\n7ROUiTERT8SvoGub7jDZS+MfWoQLK2zmlmePm7cYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYUtZXd1vgs/hztc/r/P7za0x\nVe4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWu2k6RFtJEQHVNCVF1lzrwUg/NeTpmGVcBZmlHapGtECIQCi27poO8/4\nblBZa581KbF5IvFGpUCNu3y2kt/IAbER3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAVwNkbcj16uRDT7Q9g6pp/rWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE4Nzc0MDItNTdkMy00ZDI2LWIyMmItNjkwNTEyNmMxZDkxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYmQ3YjBh\nZC1kZmQwLTRhMmYtYTkwMi02ODZiZmY3ODkwOWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASjHf3RLl8KSmSQqxYB5IBHAk8Hl8G/A2Dzvu7XOtT7GHNF3o6da+q6\ns01d7R1BamYvXsDP1rce/JiMeNGRSBdJo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSclK/+\nJnuNco3uJosiQ4ydEGcE2jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgR8IB6G1qHWeFFgZyudGIW3R/ob998ZoAaONC\n9DVzMH8CID37LLB+G774AqO4chiqBPfBU4yVgKl8UQ8GwW4Ei1Dz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6522", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6522` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAXu+pQ7NEJB8oxc3DeRxKFTXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmMjU1NmJjLTk3MTktNGRjZC1hMDE4LTNmY2Y5NTg0OTBjMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjUxMGRjZDgtOTVm\nZi00M2M0LTkwMDktYWNiN2RmYjFiNzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsAgdPuzozpoOyqa+FYpIxv3x13KaiI3T6ZKmSyO22gyRSPK/S6f6hWVj0Dav\nzBtoI3B+vMoCtCaoTjGvDRI5yqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyiDvqgRtYG2N45f5bwI2krHZubIwHwYDVR0j\nBBgwFoAUM8HzTlORvodpR591pXJMUbjY+eAwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAjKHUV/mOCD1RUAfIqbbYrd5d02cpPiR/UxqJsVwJUgsCIEmV\nuCN6tWQrSP2/s0ruBeJnQSA7N8tN6daL0EQDP82D\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASIf8AbVVLOs54KNTUJd3tGAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjI1NTZiYy05NzE5LTRkY2QtYTAxOC0zZmNmOTU4NDkwYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATp+Ynt3jpHbYKNT9NCANz/6JmrRovL3MWDidI8fDRfwfRR\n7GSKPgN/lOesCilfoYpoZWrOCGUwcj0G8ZnUDnLqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM8HzTlORvodpR591pXJMUbjY\n+eAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGLD21U8RObuO+V6Uj9fJxde9oCM8uYxDetyp070yQcQCIQCfDpiUoJQ5\niJQ1x+tU16ttYKQj+c1/q80QpTxRrnxfqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAQUYQ/j6wvynnARVTgXcgt9DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjUxMGRjZDgtOTVmZi00M2M0LTkwMDktYWNiN2RmYjFiNzM5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiYjIyOGRm\nZi1jYzQwLTRhNGMtOGNmMy1iMTllNWEyNjk3ZGMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQ9b4vtIwLwdFyfehHumIGxudbtXoP3mgIsI/J15Vun88NIX1/OxhM+\nU+utf2XkHd7r0HRWVE/XQ6xct0f8IdWto3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKIO+q\nBG1gbY3jl/lvAjaSsdm5sjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgAVgFaGoFlqlZq8umKQ1nQ1LFoF6w63XBWbxZ\nR5TTqwwCIHgFKc9P+JMRcOngB0lg8ezL2+hpWTSxqeIEApq6kxH6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6523", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6523` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAbZeomn6WUeFDbwV9/iP2whUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4ZmNlYTA4LTQ2NjAtNGRkYy04OTRhLTBkMzA4ZjEyMWI4YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk0Y2M0MzYtODcz\nYS00NDhmLWJiN2MtOGM2MmZlMjkxOWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDZ4YznllDoHEyDQMJOpQChpFUPDn1PuLonXyCtdkxuSgnVoDjYofiXZGfU2K\n0prmntPIYmzvx2+f/rDDWLKVuKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxCYDc4Q0xeOXbTTV/T/fUDoL3WIwHwYDVR0j\nBBgwFoAUzkPtttru9iCXqv+gD37bKnXijBkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA1JYLcn+RxSLb\nFT4+ab8bY5eASvlxuHDsbuYQfeWaHpwCIQCMi+cdkp1xgwx78xTL/48cx0FZ/dfc\nusTm0rmwGM2stw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfEzdfZo0rR8VvEnkHbV85JFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGZjZWEwOC00NjYwLTRkZGMtODk0YS0wZDMwOGYxMjFiOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuVVYLnMWsf2FCF1VzrZwdEOqHpt4pyU3lqDRy0GZC41T4\nAgN7okSEK0qYKRi96Se1sby+JJcRXfhavlovMl/Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzkPtttru9iCXqv+gD37bKnXi\njBkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALMmxxPs3ty/F++dxT9NGNj2G67R7ltx8qqqxdMOmf1aAiEAxVBI+5xT\nR5RFRsul6ufr97QaOe0LfWJJUKG4FAkFgDk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAUioUe3k3qfL4ecDRgOU8MaDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk0Y2M0MzYtODczYS00NDhmLWJiN2MtOGM2MmZlMjkxOWYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3OGE3ODNh\nMS1mYmY2LTQ4MWItOTU5Yi0zZGU0NmQ1NjIwZTYwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARCkfv75BetJwdoiGtOMSJNrLEKemCEZuQ+aM+2vDZpznwP5jsNJv9r\nQKz8smyVB+fmV1SiNfe9izduKAMfEtGwo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTEJgNz\nhDTF45dtNNX9P99QOgvdYjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKO/a5SVKdDHEaFV62rPzmb6t84pymIJItlU\nistbkIKxAiEAmQ3Ak6FLDvlAuR5QcWSfpG0z+o6oj2/co+foBN/nPI8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6524", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6524` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUxeqN2I/KJYkU0c2V81B8guMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5YWE0ZTRhLTIwNDMtNDY0MC04MDY1LWVhMDEyYjRiMmJmMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWExNmZhZjMtNzc1\nZi00MjBlLTk4ODctNmZiMGI0OWU2YjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3KDyiROO6BVKoKtB+yq3uOPSlPe8fJ6PBRDgDR9wWiQY/TKjva4f9t5AmmOg\nis9n5IgvwFZ8KVaonl4agA0Qx6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm3BdyrVmtWq7REuQoGw4gIP4VhEwHwYDVR0j\nBBgwFoAUQDP0KJJ9pdw6UvUGcMUaONkn29wwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEkrFt9X1oBkOo/yFDLA5U9eiONY7ekimPr/+hZLwlJNAiEAxxTG9VOFtjKt\nx91CNG0lOaleBH2qyutaTYf/Hj2lJaA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZPVfKPWQ0BWQTL6bRwiymHVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWFhNGU0YS0yMDQzLTQ2NDAtODA2NS1lYTAxMmI0YjJiZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+Nx77fZ07Xh11B3+RN/85gzNbJmPjRM+PcG4KbOaSmbt3\nNU/JzypKcKJIn0ZqupMGSN0FH3lbCOjS8MGpEEgRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQDP0KJJ9pdw6UvUGcMUaONkn\n29wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXOPiyL/QdlgH+ZyQhqVJnp2KY1s8JSYazistbT0StSICIEUqK38vRX+E\ntQNogcSyoHis1c8M30JClCToK2dzndHW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQjeNQ61qEB2PHxx2lrTAWM0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWExNmZhZjMtNzc1Zi00MjBlLTk4ODctNmZiMGI0OWU2YjI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzM2ExZTk1\nYi1jZGQ1LTQzZWQtYjljNi1iNzQ4ODViYTIwMGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASXad4pj7pQnUwNaK9dZQL51xamoOhdq4rEKjpbWTbF1kDizxG5n5w8\nvM8OwuAvtK6WKhHAAr8p3W5UtYLwlM2+o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSbcF3K\ntWa1artES5CgbDiAg/hWETAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAOpv+XBGhJ9uQv1AIUrW4U4ILPRupzG7nOjx\ntQ6lL4WqAiBbhWGXGbqyZssJjvQhQ98+I0u1qO8tKS4yietZNlzyNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6525", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6525` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXVREy6oXX6vJTJC6LUDfJtMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NWQwZWFiLTA3NDItNDJiMC1hYzRjLTc5OWQ2MzlmNTNiMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAyNjQ3ZTItZGIz\nMi00MDRlLTliZDItYTQ2ZjU0NzRlOWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwb6Wctw1MgVIDffo0bY+bBi2ZjYaZrUabmHvT8Rtfn9FMZNoLszL/UbADPe/\nyPwVAtwXPfCN/JsMUM/4n0QeMaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVrcgJpNZS9A/OimNtMSvO5monH0wHwYDVR0j\nBBgwFoAUX3k4XWN8zk4NzOQL5ZmhUKD9f8owNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICBvCJBsp4j1FiRFjJTbfs2FDITvUN3bsWwv6VLE+LuJAiEA15+7e7lN8x7Q\nLY8Jp2AAghjn0tpf8KQt0jiFcXHpAd8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS50gGY5CWXAL6VckLOQWSl+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODVkMGVhYi0wNzQyLTQyYjAtYWM0Yy03OTlkNjM5ZjUzYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYXYsbr1MNloPcjLr7j4ouWfMsCVyZ53DoP/P0bqBty+pr\nPu832bnSrj2fH1fpssyUvLev3/iskZ10IEe5d6mco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX3k4XWN8zk4NzOQL5ZmhUKD9\nf8owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK+96Zt0biHK9zfSJu7VLkjTMNV2luBYQkRdmH0BPgIYAiAQJSzpX8wx\ndt+ktbjBEdpPyvj+ThJF0Te3+hSxeXGi5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAZFGXXNyy6oRYLWyatO30QfvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAyNjQ3ZTItZGIzMi00MDRlLTliZDItYTQ2ZjU0NzRlOWMzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ODdlM2Vj\nMy1mMGU3LTQyZGEtYjA2NS0zOWNjMTMwYWI3NzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQY2Bs3qPzxu2fsf6MCuHS12eLGzurFt2KxR8xv4auZ+VCc6pfinNG2\nTT6Uiny0mpiShRXLX8THLaBJzO1wFUwbo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWtyAm\nk1lL0D86KY20xK87maicfTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgE1xfWmWwJrJ1n5UD1AgI5tr35T+cJggm9tH5\nXUzs8+QCIE6au0WUWtmYO6BzgLI0W0cbgwN6G72d33xCT+pwoSzl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6526", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6526` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAVjRo0YGDfjkiUd88rTg5bwJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxOWQzNWNhLWZkMGEtNDUwNC04MjQzLTZmMWM4YjZlOGZmNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGEwYjZlZDEtYjc2\nMi00YTdhLWEyODgtNmI5YjM1NjZkYzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1Rxs3JZmnfMG4Avgwaevvns4ImwJ9w2JW3hxBqDEklUuUsPDDYdqNc0v1grH\n/JycSz1DZWS/auHlPIvsZbGn8aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPWYaiQubGnqgQTlv9+5ElMgyqY4wHwYDVR0j\nBBgwFoAUgksHUpxWND5TED8JIyWSBWxhcEkwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBdUM1D5YY28tZ2phQBuxqCpd9VlboezHit8ITVBfwNVwIgeyQpojHwZPu4\nNiUrgZwpY48al35r3vR1orQBgRetEvM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQZGmpWP7j6veYO6iUiggiYtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTlkMzVjYS1mZDBhLTQ1MDQtODI0My02ZjFjOGI2ZThmZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJkWSHiMf7h5fCf4QZMJrOGTpZ6/cWLebqW/94iFcvD81O\ne5tOehM0iWDVX6xdkv5xWX+MSZ8egHxmF2+sJy2ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgksHUpxWND5TED8JIyWSBWxh\ncEkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAwGbE1hVwTxY5sr0egHDDcCKrPHiIe/2Cw0+7imN5M4CIA+/Wfb8v1Vs\na0bSUGSieJx/byavqHVKVq2vWbxMX4by\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAVaOcbEpnA/54Hya9qiy2Qf9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGEwYjZlZDEtYjc2Mi00YTdhLWEyODgtNmI5YjM1NjZkYzU3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYjU4OTZm\nYy03NGVmLTRlZjQtODBhNS0zMTY1NjJlZDg0YzgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARW73PvYDnfiT1CNMOqtXwhkrVa5KnXTAxwXs88IuuQisl4vj0XKx8Q\n40YcIX+lJ3BwJzX4e2xVb+x9uEzx8GlWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9ZhqJ\nC5saeqBBOW/37kSUyDKpjjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJ8Wcy29bzwTq25A1xJ+wtmAN8R/xNamKowN\n3vNLOlFYAiANMvoqNQTzdEH03tHXt7dNCWxm137KtyzU/VBrDN58SA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6527", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6527` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISATXPd0xc+pF7tQ3Mj74w3+oDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhNmU5ZjM2LTk4N2YtNDZjOS04OWM4LTk4OGYzYjljM2FlMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWViOTI1ZTMtYTM1\nMy00Y2M0LWIwZmQtOGMzNGQ3YTU2NDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERozkPUJBPabDrxhqkLpx9JvQPgQWp0v+qsJ9iR6Yo99bQmI77XyxsF+uQcHn\ny1k3b3KMSCXooeTzH3euNNKCUqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDpnHmCLndKCTdyWkqajykMIut74wHwYDVR0j\nBBgwFoAUB8EDfRSut+mg2Y1bo8Jz3h5R7mgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBvxkqy8i0k+RW1t01RQUHBP7G/FgF7IzE21MXWsZTS\nqAIgF0Ht+vAYBlvpou0kcq2CNmOavOzdxRJzEoqBYtWUq/A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdNlSXCMJUGGI6xsn4VCWQS7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTZlOWYzNi05ODdmLTQ2YzktODljOC05ODhmM2I5YzNhZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqqvz3khfTpinglGLwLE/+cgtfbC3kl04qP7Hv76CIOl0x\n5R71swcJwk/QdKPCazeG4rEqFhKO516CibrQqCqXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB8EDfRSut+mg2Y1bo8Jz3h5R\n7mgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBR0wkGiCsvDeGRkn3QQAPzz2VCA8hhhwwn5IA+xo+24CIQC+i4qy1wEy\nZDUGHNE2y3tMdg9aIslB0N2LZGFdiL2zoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISATt3P3iqwflwGXPMeXPY1Sk+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWViOTI1ZTMtYTM1My00Y2M0LWIwZmQtOGMzNGQ3YTU2NDMzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNTlmZmIx\nYy1hODBjLTRkMDktYmZjZS01YzgxZDVmOGU0N2MwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARD5bFKPv4EC/y+uEFStk9kzOS+k/ERKPjzu1rW9M5VCv4YdaEDrdja\npj6xBsFfFm7KfT0xj8uHf1qyY1RPY8xDo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQOmceY\nIud0oJN3JaSpqPKQwi63vjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgEfm7fR+hKCUeIm29Ympj1VL5Gpx4kWOEy1HA\n6/OC3OYCIG/nCyJQQ8Ler6q86st6Su1LklX4LDWEBBIVvhsHiaxm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6528", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6528` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAaN1xFLNEu02Wo1ic335fyAYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjY2U5ZWYzLTNjZjktNDNjYy1hNGEwLTM4MmU3MDQyYzk0YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWYxM2Q0MGQtNjBi\nOC00MWMxLTgxODgtNWUyMmE0NWRiOTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIkRPR7L5jX9tzapt4r6x0hRUa+dm/C9vwG+jQk9Z34D+Jz2Wxkdt1F6+l+IU\n53wH9P7XZZz2oEjWc4l9OH1/uaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9OaNOX6aOTUc6KDXe3E1B+QyXCgwHwYDVR0j\nBBgwFoAUVaiLQTF6UkRvpF8K5QJqcv3+vwwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAK347Z34ibdCuJO+uvp3VsDU72jUh/wN7nYGeS+BlC\nJAIhAIyD3W5q0D05aAluIDBZnQeLwCusqsOEFjHURy+7rVNc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAefz6ueNAWki0fcVvPEqWP7QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2NlOWVmMy0zY2Y5LTQzY2MtYTRhMC0zODJlNzA0MmM5NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARw6iuvwKtV3B11HBPp3eMDPlAOPKvqk9CvqkCKwmmV0HKF\nHabCHI4B3K9ebjz8LC+9K7WBUu3n14bDodkZJG4io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVaiLQTF6UkRvpF8K5QJqcv3+\nvwwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOs/G9O3KJNNsF5TImA0EDUuMAesQO77AllIGHNkp8MVAiEA/pIQrVrj\nkvbxtR9NxJAQVqF2jlk5q+Zxls9sM9+Lf6g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZLjkhBQC3gtyyYL+wemGLXoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWYxM2Q0MGQtNjBiOC00MWMxLTgxODgtNWUyMmE0NWRiOTczMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkYjRhNGNk\nOS1hYjdlLTQxNzEtYjhhYy0yODRjYzhhZDUzMDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARt+aUAI4CSn6BB0uc2yjWXAm5xq8foGrBbtMQxHLxAt9wGrc5a5ZPh\nvRH+6NUT9nGgBSnXiulbmPNEoQVQu0bCo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT05o05\nfpo5NRzooNd7cTUH5DJcKDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgYIt5spopw4X/jvAkiziHc1/OcmQaRiKfNa+H\nSFKsbyECIQCvVUl+wcMSN6hL6LjoFvAF80ONhCe3hW1CzoGFDcngNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6529", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6529` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAW5pShXk3mw8hWZDXXFEXchHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MDgwZWI5LTliMjItNGRiMi1hY2JjLTExZTJkYzgzMTU4ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdiNGE5MjUtNWZi\nZS00YTRjLWI0ZjItNWEzZmFhNmI5NTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm/XzVd8A7uiO5xE22I8VfBh88YleYBklECySvNN918d+TQRlmDvtM7DHOIuP\nM0S7HK+W0Ovo2jhOcD7xvu7xWaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJE67o+RVfM9JC69w/bfK0wR1GvUwHwYDVR0j\nBBgwFoAU/2Yrr+82gwc1okRhUwASoUhPmqowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA6BhF5oCApJOPLcxgmUFDN6gxTba+5xFn0f5Z6O0cU+QCIBUe\n2BJ4EMhJQC/qU+L6fk4Xm54qw88hQ73Y9C0S9Y4d\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARKFR0hChx63Nxf+a7SlVon2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzA4MGViOS05YjIyLTRkYjItYWNiYy0xMWUyZGM4MzE1OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUGhUbRJQly5CwK3SvCNQw1UU85F9qhX9DCq/570/fANIq\nkcKc8cNAH1OlLuARasfaxfAU9K97T/3LWf140Vxco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/2Yrr+82gwc1okRhUwASoUhP\nmqowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDfHrxP0Lmd0Hyj4UREqAXqqlqn4cpmNsEpFnDQahYBsCIQDj5UTc6wu9\nvrqYdYShECYhPfepdNHRmBX2V9zE3ZTkJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAUR37Q538YjjArkRAR8wn7kfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdiNGE5MjUtNWZiZS00YTRjLWI0ZjItNWEzZmFhNmI5NTJiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlNWFmMDYw\nYi1mMGI2LTQwYzEtYjRkNy1lMDBkOGYyZGFlZTQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARXztPvKFg3M7sI/deCFWBlNzt7OCAgM2fGa3mWJfnF0k/K/Rm7xhjX\nC4NtvqrFR4xbdx3JCoBDVR4apWdsi2Bpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQkTruj\n5FV8z0kLr3D9t8rTBHUa9TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgc30bdx1qvur/3E5JiT+jQbkj/BwGCT4hrnZ6\n96EQatoCIQCYh32eUJFmYnM+/nAv4tFDsZhsg59gtibaa1XyxklyCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6530", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6530` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAen+SeiAvb1K4oJI/s8etox6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlNDc0MmRmLWI4NmEtNDZlMS04NTI0LTJmOWE1ZmM4MzFmMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE1NjkzYTItYTQy\nNi00YmY4LWEzMjItMjNkODgzOTdhODlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECDD7rtFisUKN4hsntBmZ96ZY+B0rvCsXEe5w4YB5iccEnK+Jg4XVJnSq8Yzl\nLka7Ji8iaO5FHUafE2YmBW+c06OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMbvXWhKsJn8DRNl5Qscv631p5UcwHwYDVR0j\nBBgwFoAUcdJChsYyQxy06cHwSexR7JN7hWcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBRClk29ghgS6bjw5Ove0LMAYlr6s4AsXpp\n6rV++S6AcgIgJJSKu9IdE6Rc2ntTr+2nj/5Jbx9bZcFMd7Ei48VZRFY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQbG/uqLP9c7NbD2MZ52LGA9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTQ3NDJkZi1iODZhLTQ2ZTEtODUyNC0yZjlhNWZjODMxZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcBbam59DsEC3JOdQTnc7VF1tQXNQuyl8iTDiZeAoAFhew\nU4i/L1Tq0DTOxZrTPPRZB+r0+q0xGu18kHVuNr4po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcdJChsYyQxy06cHwSexR7JN7\nhWcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI265b6LWhcHLjdjlzGN81kw0Dok3jFz+/5tKN4uXx+LAiB8dCfKDAgk\nqWOkjjz3ifJbX0JrvrE9yY2iCwC1xRHdAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAX4QT1TbyPjifuhVK/vD9GKJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE1NjkzYTItYTQyNi00YmY4LWEzMjItMjNkODgzOTdhODlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZTczMDQ2\nOS01YzY1LTQ3MDYtODk5Ny0yZThjOWI0NTE2MmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARNiQxoNiuoSTEvjQjPu2cH0sKDj7MDGWWR9tta1Keg4psyW+rLoFuU\naSsGbRpUOP50nD7OQ9OEBAbxapE0nxvko3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQxu9da\nEqwmfwNE2XlCxy/rfWnlRzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgcqgx297talVz9YQhMS2Xxot3874OTnrwUouU\nMj6/LNECIE1HRzwPxGKm5ltpdLMptR36vSwImPaCT+cf4g27Gs1g\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6531", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6531` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATQxDLhegdtiSMQYsw7SGT7wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMTNhNGU4LWM1NmEtNGFiYi1iNmViLTEyZDE5NjlkMWVhMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdjYTRlYjAtMGVk\nMC00MjM5LWI2YWMtOWQxNTc3MzNjMmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjfOXIQu3HfNNgL9Qwo+tGDy0MuyZZF6XchhgfupiJ/jGWT22KjZLyvuprIxm\nxt9g2FktBWQargkXVbSOJy6UXKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUymzzKYS8vjndqihe2AnH6EUZ4oswHwYDVR0j\nBBgwFoAU9WPzTOV9/o08Jujj7EVbvIeoZzcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAaNhv4PsURdJcsaAv9duSRkSPR5W+2QDhP\nOgAyjjFk3QIgYHTwK4xc9oLd9Jg0iktsX+mTRAh28PIfZJdYIlpLpj8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeJl3ye+Vkm5SqB1zRocsVnDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjEzYTRlOC1jNTZhLTRhYmItYjZlYi0xMmQxOTY5ZDFlYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrSnycjt0BJ7J+cQi66RIP9/EYSRKSv6h2qo4Pw88yJSO1\n1aKyixHAmpIwrQ5CYrffM6WSLpIt6yfcKqL/YkXKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9WPzTOV9/o08Jujj7EVbvIeo\nZzcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJKHmRMEJldYB8cMooM93mLTQFpnA/+ZvxaLK+jlGI3WAiEA0DWxMtAG\n5eFgL6dMtRfeT1lkvIOx5YkFjbsx/A/N4gU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQQrNRfmxInneZ/dDFl3XoFvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdjYTRlYjAtMGVkMC00MjM5LWI2YWMtOWQxNTc3MzNjMmIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNTk2ZGE3\nMC03ODRmLTQ4ZTAtYTk1MC1kNGMxZWExMjQxNjMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+ra+EakfYh+UFMjMFR+ZxwQZrBxhHfJ1j36koKCWG7NwguDJFXZi1\nXdhXqbjY78A2E/nu8QoelcrmJXkog/L5o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKbPMp\nhLy+Od2qKF7YCcfoRRniizAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgUu2FrCU+64eQjHFD/W5qlSBxvgvndZsvMghJ\nsF9E1/kCIQDnp7DBJty4RYO0qamrW7ICPqS40XRtiI6j9A2Oivj4Sg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6532", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6532` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZ+NMBSWD9dwXjku6Qq6qbo7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyNzlkY2EwLTM2YTctNDQ0OC1iOTk2LTYyY2JmZmMwOGNmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIwODhhM2UtZDMw\nOS00OWU4LTkzY2EtZmZlNjM3ZTBkM2EzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElurv77rOflQ9pT1Kg8YI0XiNwPiDAwNuUNVOFP4m+yFxMbpvPc0c8aAwhYbn\nrWCDq4JJxripLgs5Zy85b8bjCKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqgiNTOLpeDF6unfF8jdmrBg/PTowHwYDVR0j\nBBgwFoAU6M57C3T153Nv9ClGk0XEatNbXnQwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAwh/m/jBdyVYF\n89JrKrxvLZ11QOMr8FXlilVyw6EqLXcCIE7xr2ZU9bidjI5DRKVk3ffIGQ9PSwfq\nzsPXu7UsVwkc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWEUIM7bVLFNZf/2PwZsjZefMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjc5ZGNhMC0zNmE3LTQ0NDgtYjk5Ni02MmNiZmZjMDhjZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpjSzn5+rexgkv10tiPhDTjf3o/qoFfxHvza0krX/JwWPu\n5rFCbWpN4TKz/Lf8YwsYgrH3DEUyLraFdq6zv/V9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6M57C3T153Nv9ClGk0XEatNb\nXnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO6s1MBUhEQYqKNPWGZ4CRDW5uzLcHN+JQXuseiPG3w/AiBROHSAypp8\n5e9grQD4LECteDC4uvITStE4kmRfRbc9tA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAdEznbuUlsWKlWKmkfZrceopMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIwODhhM2UtZDMwOS00OWU4LTkzY2EtZmZlNjM3ZTBkM2EzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ZDAwZTU5\nMC04ZWE5LTQyNGYtYjIxZi00ZmJlMDEzNjZjZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAThl2K4uwIzNk2q3VJ6qM5fK21b2hi/Ns7I8MboZSZG+YRSy50q/Cj9\ngEvt/5BergF/H9IL7DQLAaVlrQnAJwBno3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSqCI1M\n4ul4MXq6d8XyN2asGD89OjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhALIgEWV8wZE6xh6WXBlDIu+WZzpzEpse45kX\npEph8NMYAiEAhGA/Jx0Jfj2nIbGdV4qkXOiZst+G97gAQv7ry2q5S8Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6533", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6533` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAWqf2wWiONgTfqlevDHJ75UuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZGMyYzE0LTIzZGItNDQzYS04ZWVkLWM0YjFhNWUyOTg4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM0MGM3NDMtMGY4\nYy00MmI2LWE5YjktNGY2NzMyOTRhNWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEYyYfJXhFVWC7Kttwv7RoejlXyoFpJuQSMQjyADLAnKDUBWR65Bdn5PTLmpG\nAILsG0yNg/2BF6IF6mLaqcHv56OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUog3a2qGcfvv9BUOOj56M3c8yBUcwHwYDVR0j\nBBgwFoAUTbaWgzGdCSwPZ+FajJQ4+qlYJ1owNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCJjS5yaXQQieveQKsFLsTsBbUVm04krGaGwTbkWTsdywIhAJL6COfOqkOm\n2GxD4mYaR6K/OGBj1odyxg2HnafEYNT9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYKXpeEGCMvsXaW1SGeTtc5AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWRjMmMxNC0yM2RiLTQ0M2EtOGVlZC1jNGIxYTVlMjk4OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuYlmePB7ajGyqXfuYYYLsgsCp8W49PLeJTEBpAV5gm/TY\nu1yVbi9omGBIIciZS3jDr0Wwlksqo4Glkk/vmNy6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTbaWgzGdCSwPZ+FajJQ4+qlY\nJ1owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUYdiQnOeggFltWcYaBrEHgbRh6qlkdHOJnnPaKNmJRwCIF3JwxuUVJ+x\nzw6+DATrP/OiBZOdG7rzyU9FlBY6kTKL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAafCVB6/Bi692V7dvt6gVxM4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM0MGM3NDMtMGY4Yy00MmI2LWE5YjktNGY2NzMyOTRhNWQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5Nzg4NmI2\nMi1mMWVjLTQ4N2QtOTA1MS0yNTAwNmI4OTVjZDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASBKsiiCk2GKhc8TpNlsEq9v0yQfgfsAO+Mr4QgVkBdddbMOUxLOEu1\nE4QZcbS4H4SJarb35LI52FSCudmd3abfo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiDdra\noZx++/0FQ46PnozdzzIFRzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhALgFgMFvDq8PxeFMy8z+00xIgXkx75W+pW0M\nP5EpcvNPAiAkt6h2x7lX7CE2j1Tf/LpwEX9VJZENhyI0ahXOQelBAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6534", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6534` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAY0HdHRWuqA9VzsyYtEmFNO+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZjRkNjRlLTA5ZjktNDc5Ni05ZmRkLThkZTI0MDA4OWY1YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAxODUwNDMtMzVl\nMS00MzhhLThlY2QtMzMxNDNjNzE4ZWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDcgpdopMPUOQRHwRM2haPv5iUT/II+KCMMvhAP+O7Dv0e5F+Q4v6LRo8l6eP\nIRkf3IOCswdyHoXzEpu2/qjRrKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdJ+2I4LtpcJLA4NialZaxLguJg8wHwYDVR0j\nBBgwFoAUuVOMjEt8S47rmGnQYNX0mlyka+IwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGJrN2ogxF/2n4qTWfsm/70rQ69mKcrnhB7eSsFBx25UAiEA5QLUfHOOYazg\naWRciRqrDN8Xdb0SKbMVyVIv9DHZHMo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASPsFyANGwBQMMzD6W7MRFR+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmY0ZDY0ZS0wOWY5LTQ3OTYtOWZkZC04ZGUyNDAwODlmNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATO5FcTFFXAUnHlNmPILWPCOtDN+mt8ISiHpskg6PYpRNkY\n4RVF00pT6m7WYmjTmopx2ytNMbdRak26VqEuztImo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuVOMjEt8S47rmGnQYNX0mlyk\na+IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIuTl2fcejMJBd/gmfGUN1Z9EPC4fufRq4/2z0ivnNG7AiEAtTkE/g1E\nFa60XJr60rrRK12E0e7y8w7iPw6NiqkNRP4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAewyG8nmA9MS9eWAQFhHtytWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAxODUwNDMtMzVlMS00MzhhLThlY2QtMzMxNDNjNzE4ZWU5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5YzJhOTY1\nMC1iYTc0LTQ3NGQtYjE0ZC0wN2MxM2E3ODg5NDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATyI/c1mKtTg6vfVAu18NtnVe9e8uTHiG4z7i4MT0o6dL69WSgAxbKP\nYVMoHP7Bd8zlqYzaB6++m6A4DX7cRuPko3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR0n7Yj\ngu2lwksDg2JqVlrEuC4mDzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAL/pc/9yCd57U121swm15uLbLF0etJNIhSXr\nitPCtv7uAiBK3JWrHMqdFAaT0a52IDgmKnNG65O7T5FcWbMM9dsJhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6535", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6535` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASwBm61dYSmTN9NxOCWBwoC2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxM2NiNzM2LTEyZjYtNDc4ZS1iYjQwLWE3MWZlYWZlYjMzMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU0ZDAzMzMtMzJl\nZi00MzU2LTg2MGItY2VhNDA2MzFiNTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy4dhVOslAVSgg1P4BVRmygNoMVQfn5oWTNY+uXJHYAS0nm9Xsl4fWprx2Fq3\nHEIXe5KAx9XP6aaTgCVXix1hzqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxSAR2P2JBmHM7vjwogujV3xj/vowHwYDVR0j\nBBgwFoAUGfk1UEX2mT4M5gdzPx/wTLa5p8wwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiB6BOWYqiL+x116oeCmd0xggzmbPs6auDx+af6IA8j+egIhALWA7k0+sk69\n7X1wh6fz1fc5cSjCEwOKx4dWzSIAfcVU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcPjwTWUzld321B6gp32fA1OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTNjYjczNi0xMmY2LTQ3OGUtYmI0MC1hNzFmZWFmZWIzMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShhbGexsCPyYs/QmJMc4JX40K2mFpMLDnoU3fh8ZJ0x0fc\nhYVY491TCVavKOi3aWTWsiA/4QCXz3o9Qh90XgEmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGfk1UEX2mT4M5gdzPx/wTLa5\np8wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPn7YmhhLwfK8B1Go4O0tdowpe28FfkTAyhBe2PixyrsCIAX193KwOjaX\n3j86DdRaWakuTPsn30LVSWuHeZJ7j639\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAXYXuCKfU3qxaWdIOv/hiU4KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU0ZDAzMzMtMzJlZi00MzU2LTg2MGItY2VhNDA2MzFiNTYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlOTQzZTBj\nMi03Mjc3LTRjNDMtYTFkZi1iMmM4NjViNDA2OWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR+Oim4LopAJsWGzndReEgqNT/zXJvok/RERY/KG27VIaPTR4hre1VU\nPEUJXZzR8/MVzNxc/QWEZ4iiYxC9lYDWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTFIBHY\n/YkGYczu+PCiC6NXfGP++jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhALHCzS+r8hVmflVTbtOX2Xq+1SVu0Aqjj8kU\nKWpfvqiAAiAhvp38xfvEFVqULAgtbzScMl1m7lu4tECFwj3MQjO53Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6536", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6536` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISASoPnUstYcWCw5+/GMTHA7kCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwMDhlYmUyLTA5NDAtNDJiMS04NzBjLTdkOWM1NjJlM2QzNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc2MDk1YmUtZmM3\nNC00OTNlLTgzMDEtYjViM2MzYmMxN2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmFBQqErmzrY6Pl89roO8JjcmRBP0ma3FFFQtjCNZzMcprt0pItfNrKHKWTs5\nGuFuSCmwAqgD3o4n40flJb1kLaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrMXvqEV/NykcF/hlI7pxxSXvoX0wHwYDVR0j\nBBgwFoAU+HmO22TzKlC728byWEr5zYg+qbIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAzgyjTsziuIYFZX4mrOkTp8BL7vNV3D65NIAXtgC3\n5uYCIQDPBrSNB6AWXgUUUo6e4+XsECNEPQTP4QyPt+Atxied3Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdygTZjN+E7fOwx81R90wtIYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDA4ZWJlMi0wOTQwLTQyYjEtODcwYy03ZDljNTYyZTNkMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2l0DPwOagncqmw3UDRWOWJIXCvzqXF+cFpIJcF2/X0P2D\nKcQClJKBtkwJL9hatX7+4ChSgmtn+W9YeQHk82EMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+HmO22TzKlC728byWEr5zYg+\nqbIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMeM0oY8wYqkZCwhXIs49jfXoexrGFEqDPfVg53yK1CICIAbgcTXmZSer\nj23KQqp0BeUv+4stohEPfc9/W/foSZqH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISASS5aBAsh+r6vGxuI4FSJC0LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc2MDk1YmUtZmM3NC00OTNlLTgzMDEtYjViM2MzYmMxN2EwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhYTcxMDJk\nOS0zZDEwLTRmOWYtOTYxMi0xODkyYjMzNjVkN2UwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARdhyA3cCNvdwaiO+eLLOU88dVelp5igWm216NqLyc1sRTq2mT4530D\nNWlmSfOWgiLA3fYrqxo5MDDaF7q6eIvPo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSsxe+o\nRX83KRwX+GUjunHFJe+hfTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhALx63xe/FH2oG4Pb3/YW3L9sA4Dzle9O+c1H\n5T/fwf8pAiEAhriqkzAPn7cXQdnwuga/kia2K0GIsvfLgpgYRzqNHuE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6537", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6537` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISATiUrUUf57att9t4ZFvLNWtdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNzM4ODdkLTljNmMtNGNkOC05ZGUxLWM4MDA3YTBjNTIwZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJhYjg2NmEtZmNh\nZS00YTJjLWI5MWMtODY1NmNlODA0MDFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwAi8dA2JiEw+t+VYBRMz9a2fGzrpnNWbTwe+KOmSj544SUPhnqWMtEBeMnEF\nHOlbLz6MqC4KewFCOKYuqBMWHKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+4VBBpaJY5rhwvbYNVRLGbOWuMcwHwYDVR0j\nBBgwFoAU+gk9XKIsuw0F0LR+1m3I9dgiw1wwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiA2EqssyXCjpLvFJk83TX5plkk4ppbT6/ra6h1Zqi0V\n5wIgIqULJe0UmQEhdPmewj6tOIT2nAWCYJSqr4bUZz/MfIg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWsXkOIx7l1orwK4ZTDM6pRgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDczODg3ZC05YzZjLTRjZDgtOWRlMS1jODAwN2EwYzUyMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATePM0ZSjZp+zB7Ld+81ijpgvCkL+6x6AR71XKVJlsCLbMt\nf7l9k1ZxH06sgZhP9jw47EGTS8fEWF2CoNjaSrlbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+gk9XKIsuw0F0LR+1m3I9dgi\nw1wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ/miyyOztuNrexdVHSOQZNJFi5oXkXn5u6ACAjsi4ocCIBWJrkiZndNe\n9N1g2FZne54QydLO4cGNGUsnybWnx7r7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISATgd1/cTVdGuvT1IqUMTyslkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJhYjg2NmEtZmNhZS00YTJjLWI5MWMtODY1NmNlODA0MDFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZmY2YmJj\nZC0yMzQ4LTQ4NzgtOGY1ZC1mZTdkYjZhMjZhNDAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAS2ZYhJowMp+BpqbihFl6E2nA+/ZZRiHz9R611FmIcRgBBeyggDXmzk\nKkmUIw4+X8DpCvv7/u2UBfxHlX+HneEMo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT7hUEG\nloljmuHC9tg1VEsZs5a4xzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOUxusSv5Z3x5Bt8sua8lUKv6iSSh5e40Gso\njQBdOcHBAiEAsUsF2ysAhexPMRoppFl8yeq+jCJOXN/imGi6UOGl0gk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6538", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6538` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAR1fjtadjHYMNF3R2/ibnkoSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlNjJmY2I3LWM2OGUtNDIyYS05MmU2LWIyMGUzYTA1NDVhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODNmMzk1N2YtMmQ4\nNC00NWUzLWIxYTgtN2Y1NjFjYzA3NGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIbZqUGOYoWGW7FgHD9tHou334krTBFom/B/I0DRuUQMfbraN/Cfj+IyDJDb5\niJCCzR0j1WO7Sqtbu5HwN8SgHqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoy73hDsKBgLlBhJQM2fXmeccjBQwHwYDVR0j\nBBgwFoAUg8VI0C4RaWW5WNe6buWKusEoZ78wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA5w0mvXanN1+S5Qn3OZDSjvB5rn96SnTSpA5sFxXPHgUCIQD7\na+zZOifYWYcuCN1fJqZICSzPwRhtaSMwPx7+FSwmCg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZYQHyiXFOLLYzR3nfnsS4+aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTYyZmNiNy1jNjhlLTQyMmEtOTJlNi1iMjBlM2EwNTQ1YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3+3gPrhRhEUasDTWljoN6g10d+Ca7v2fU3OEGrZ0ORIDF\nO0rqVxiGOf+Dv8/3+fMZuM2PSKV12D/qwFOkYakco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg8VI0C4RaWW5WNe6buWKusEo\nZ78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKFVxkznWtxVJY6jR7cDVq1PJL68MZY07p5fudU8CEkkCIQCykPE09a1y\ndG1wOVPu241cDDIHDAKVBGIevxWyccF77A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAWtILwtniReYahlqxUdiZ7eKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODNmMzk1N2YtMmQ4NC00NWUzLWIxYTgtN2Y1NjFjYzA3NGQ4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNzdiYzNl\nYS00MWUxLTQyZDAtOGQ0Ni03N2I4NDcwN2VlNzAwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQiTKuyCpPnBw+ZveZri9u0kNWpLWZM44CKDtMe9qAWsqI/lieQimaH\nalQHlikYs4mlt3O6jT/FPjO2pQAKxyMAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSjLveE\nOwoGAuUGElAzZ9eZ5xyMFDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgTzkze4fVFSVkCfFwc+lNfsJAksntGUdpbs2p\nslrGwqUCICsAPmNq4PCf9KlDUY5QpOWyVJLs+9e2elCJ9jd4EBCy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6539", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6539` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAUTY9fHgSBnhX23cvjg6vle1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxMWVjMjI2LTZjODQtNDA1Yy04NjRmLWU2ZDY5ZDhkZDAyMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQ1Mjk3MDktYmUw\nOS00OTBlLTgzYTAtMmFmZDk1ZGIzOTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDYJlHPdaaYS+hEju6ZPiwkCpoEr4jodj0TiFVYSQ4/QXFNwQMlGfnJTCETP2\nOv3wtsW/r5zPV6C9biWlkqYwEqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+b9VhuJ2D1dN95FxU2eleYOzfeQwHwYDVR0j\nBBgwFoAUNPUBceszGLHFYDle+omNpocnLZ0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAWUyVdBFTJcyUgfj7lDzsyBKqqLBremNDG\nhZIaQ+qQmwIgDktwxoSXx1iI7Gu/OFibiwgFWGcxL424iTX1JRbYN0c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWkFSdI66WmejEx8njUKPUpSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTFlYzIyNi02Yzg0LTQwNWMtODY0Zi1lNmQ2OWQ4ZGQwMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3ZEEVVT5ZxnLq3y1tWB2vfbfHyiIjN5/GjIkisPj1kPAw\nS9M/2nKBFYOB8zo47W+nukABAGdlPIzXs/qFl7Wio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNPUBceszGLHFYDle+omNpocn\nLZ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN0O1/nFSgWQGUiAZEzxZWWz40YXu6QsbUA9FLSMDvKwAiBh/2f0avZb\n0IVryZyW/0G8nGWnm9nsInT7GR8AgiqWyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAekppvARF3ibkVw/A4PWk39SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQ1Mjk3MDktYmUwOS00OTBlLTgzYTAtMmFmZDk1ZGIzOTdmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmZWJmZjQ0\nMC1jZDkwLTRjOTMtYmY5Ny0yNzQwODljNjkxNDgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQYM8nfGN+Ul3YVjhi5YSgP5QwCyoGGUZGNsjUgCT4FE/mhUsVV6Hds\nmnOaCQZa6rbkVtV/YOLLuG+ktdhGZCVno3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT5v1WG\n4nYPV033kXFTZ6V5g7N95DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgZM9vdMdhisFQxZ5clB5uatW7UZQSOVczKR1B\n1+HbpmECIQCplV5mbaP/yx0PW+rsx03Hjtv3VaIpPYVTJPyNGCQbiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6540", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6540` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAU/HQWq7LrQemX9EDfiOU5oiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyMzI3YzgwLTk0NTYtNDY5Ni1hODlkLTM4ZTJiNjZjNTgwZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVkYjEyOGMtZWZh\nMy00ZTBhLTg4NDYtNzA5MDIwMzllNGExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3/2XTf3HceyV3XZweV7xWGP6olfcZ0pkTjgQIc9OADfku0L8/oRr55ObjqX2\n16gnZREgPe0L+uPWCl1HG9Vq6aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpQp/JTjvwOGBQdjtz0XFZbvQa0cwHwYDVR0j\nBBgwFoAUkS1N5Fen5D3IPYwddlsMczxuPkgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA5QDfzRxSWnKoVAcrgJn4/voGezg64cY/\nDQBNz6cEtfgCIEJxl7lYfLodMEl9cf9/Tp8lLo3yUHNGpPsU3+d9+8b4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaL8vbf9iI8++lFqKG6vS4FjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjMyN2M4MC05NDU2LTQ2OTYtYTg5ZC0zOGUyYjY2YzU4MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlFFlikn5Ecm5SnjhFjfMuYPFRn0380f+HfkxXzOwC+C2S\nwH/uTeJEhYI+uqTQXjAS6O+NAFmtsKQOd3wvWM8/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkS1N5Fen5D3IPYwddlsMczxu\nPkgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOqWfl5zglxKwC5HvNWiIpvaMJFJDnSod06o7J5tJZcFAiEAugL1djZs\nD8Os0S/ogr189iqsrwi8uiIGhY623/ZVajM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAWz6wwGPIPEszdq/ijPWovOaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVkYjEyOGMtZWZhMy00ZTBhLTg4NDYtNzA5MDIwMzllNGExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MWFlYzI3\nNS0yMjMxLTRkMjEtOWEwNy1jYzI2ODg0NzExNWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT2k65ay+qrwRXHWesk/Exi+AaonvQxsMonykqQbojndRu9aZlu9Qxx\nj5kxeGYoPaiiVvDm4Kmv9RSH05TQYp8to3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSlCn8l\nOO/A4YFB2O3PRcVlu9BrRzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgQ7fcOzlnfxhNqmWM2bDWJuecOu8Y6rhGleqY\nM0L+rlkCIQDtYmuHu3vJguhPujDPYS+XVzMCr4bVLxGk9fPYogdAtQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6541", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6541` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAcx31ZJ07NV+GGW1ghVvHezzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYzQyMjY5LWZmYTgtNGQ3NS1iMDcxLWUwZTMxYzU0MzIxMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU3MDM3MjEtMGQ1\nMC00Mjk0LTgzZDItOGEzMzg4MmFhODAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ4mgxJ2vDmmSlVIgU1G9fLS24b+aNPnN1CFmrrxfdpFBofg0v8BimWn030oS\nqxrESXaRmCvvHe3/RCT9k3SCCqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS2SEBGuOs+As3lLx4KG+kyPDgGQwHwYDVR0j\nBBgwFoAUYKFR0sPJ7s12zlBko2aBSjSA17swHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIE5j7UUh/rnHElb8/lxXl5Ecf+qG\n3RWVbGsf6J9brRFxAiABSXvQhnSY6+ZG42O3RAzpWvJ1Zwcg7J3IE64iUHBfjw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATF2rQq1S9bOtCNJg0pcTaboMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2M0MjI2OS1mZmE4LTRkNzUtYjA3MS1lMGUzMWM1NDMyMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLoTBwezh2KWn9ltqxrYyr6Pv/8GQ+SI6P+Fu8u9Z//Kf7\n7MlGqT2eXA1RDZGP7rP1RD9lrGcbhXdlAAcT0I0eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYKFR0sPJ7s12zlBko2aBSjSA\n17swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI0h97o1jpzMAxHB0Uzuxm6WeMfeMhuXpIkK43T9uyyRAiB0dJh63EFZ\nv/JqW9GpbTZTNSVGSXxSvf2G9OdlWyje+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAVl9MIYrfa90be930yIma1B+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU3MDM3MjEtMGQ1MC00Mjk0LTgzZDItOGEzMzg4MmFhODAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwODczZTNk\nYS00NzVhLTQ0OTQtOTBmNy0yM2E1NzE4ZDE4MjkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATtdPzdFLRtW7+Uy9h5i2g0i6dUdfgOGC84DdgIkSuarNEUIcotxFtS\nWgF51iGjpx9JSCZa1ib2ev8tLe7s2AZIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRLZIQE\na46z4CzeUvHgob6TI8OAZDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOopL7ewbBxCpT11BrbezmWu2j7rqVQkClJp\n5zjmCZB9AiEA4PL0RmtbwKUdNhSUk12OFssbUi6+eCFCGhY8+k0gXjE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6542", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6542` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISARsTO4hk2pQMQLWS4BBTK4gmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmNWMzZjc0LTIzYjYtNDYyNC1iNjY0LTM1NTIzMjQ0ZGI3ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2VhZjRjZjktMzQ3\nZi00ZWM0LTljYjUtYTA2MGM5Yzc2NzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVlITMPDOMfFlN7Ec56tUB27jmS/aeC3u5uZlyMiGFvS8Rsy7/kcxPHYEMPNG\n0FlDnwijVEEURafXBVZ1l8INpKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUotCf0RCQOuilScdOpf79vr4aqEUwHwYDVR0j\nBBgwFoAUkCXq0oZOVPV1M8MZ0aDEhZmpNhowKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgGXHjryyB\nYN4NpM493PZOkS1QpBVXC8/IN0JV7Cjypo0CIClMH5GKjiUBwpLUozMOCu5coyMi\nV6dovp6iq9Q26Hp4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWW5uQ0mhay71UOUk4RDWO3pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjVjM2Y3NC0yM2I2LTQ2MjQtYjY2NC0zNTUyMzI0NGRiN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATE9nVKTdH4OuD5kB/cKN/NDPBsVw9WDIbSY4qkFByaXX4K\nCHF6xFw/OkdxLPNE78gVTNnHjo7+5FfyKz9H92XCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkCXq0oZOVPV1M8MZ0aDEhZmp\nNhowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIbcmxzAH07y6kM4dmBFlW6/I/XjxUtZCb6WH7UpsSk1AiBvMgTv7wFu\nPAneqFLSGILElv/GFnsaP6+3JY7C8o7bFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAaFVtL0b6ogcdcYaGfY9nY/iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2VhZjRjZjktMzQ3Zi00ZWM0LTljYjUtYTA2MGM5Yzc2NzRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjZjA3Yjdk\nZS05MjljLTQ3MzgtYmM5OS05YTQ3ZTM5M2Y0YjEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASlC3jGEqibrOryYe5d1hopFx5J8tYtmqhyITi/1gPdQn8cudWnWBxF\nSQvlZZT2FkrLizJ95GaTF+nkLaN2tg1Do3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSi0J/R\nEJA66KVJx06l/v2+vhqoRTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPgc/eYmRI1dhUDqTIOXUz+YdgskdpfoGul3\nrAXE/0TPAiEAyIO0ODoEgRtPs68kXu5CtnZ1jLCqAG8vBdwUOcTXSzQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6543", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6543` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAT5Gbydtzo1JAA6C1tkm4vOsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1MjJhMjk3LWI2ZDgtNGQ0Ny04YTk2LTU3MTMxODc0NWI2ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTYzODk5ODYtYzk1\nZC00MGQxLWJkMjAtNjUxYWFiMDQwNDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFRnipybhnGyjzDjsT7Xhr3ipv5RcpzxnZiKBY5kAkXFWmQN112HMSXQpj22+\ncOP3bVg1wMgYw9nSwfbzNPDnyKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX/J8i7kS7jTYSJIdBsB29T16sSAwHwYDVR0j\nBBgwFoAU9oDeJCa2MHk4tr8lDI1gKA7t8LswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgQqEzVaCO\nm8uVlKlLkdGib2qMc1TztN2sMUKaH+bme6sCIQDxvJf0iVzxNnmInoTBpEcl0zgm\nFXAsVTVW/Hb7Zhhaaw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS/hpu4ZojeFCcRISozGNrisMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTIyYTI5Ny1iNmQ4LTRkNDctOGE5Ni01NzEzMTg3NDViNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg5UkP1Vk6OSS6GKsXC+sS1BZ0uaoNi9tdRBRkcwIHuSeE\nqzOtgiMVi9L7Yhzr1WXUPKJqrKGdmU2Tr1EuN69Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9oDeJCa2MHk4tr8lDI1gKA7t\n8LswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZIRplRN1wv1beppkgOjUaAQBq0nwBgw5KRVqwCTe6H4CIQCB4CyQB9MF\nFDOM0dtzWU/xe7stQTblh1yU03w5CFhU3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAQLUT1udOAweksXIxQbT1Eg0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTYzODk5ODYtYzk1ZC00MGQxLWJkMjAtNjUxYWFiMDQwNDhjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MTI2MDkz\nNy0zM2FmLTRjOGQtYjU4YS1hM2YxZmIxODkzYzkwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARtdqPtDHhR8qZx9L6D0AhVGGPxq7R1QCAGiF9B3SMAhYeK86jWhRtE\nly/VnZx5AQAbv6znaSRGb2oJ0IkXarb0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRf8nyL\nuRLuNNhIkh0GwHb1PXqxIDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAO9X4YJ8M+IscbXuHu0OWBUWomW5xB1Xgsfr\ny3xaNN4ZAiEAhuLj6nQwcro4C68+mGuesCqHS2vFZeZjfJ4M1sS8MuA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6544", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6544` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAdY9vLBIugbZE1r7KPX2tlrVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZmJhMzIyLTdlZDktNDMxMi04NjA1LTBlZmUzMjY2MmY1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWE5N2U1MzktOTFm\nMy00N2JlLTlmYzUtYTY1ZDdmNDczM2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEKmCjZtQ+G8BII9A06Krjx2+HScYtcA/kMgkXYdPAVJQIlYdHPbAydDIIyFm\nF2cBp5V9iOtcMAsmNcYa/bSJlaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj1RLmQTHsXyifShSWJTZ31rGXLowHwYDVR0j\nBBgwFoAUb+23Hjpj7SkhrXVndqJxS9x4XIkwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBgFnaOl\nDOf7j8XND7bwy3XyRctUnTwNXER+IF73NzAfAiASXULdjg94iIB9PTRfDqIoNg/E\nZE71lvVB4fXjZS6eXA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeUWmThL14iNIE4EQcIiLhyOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWZiYTMyMi03ZWQ5LTQzMTItODYwNS0wZWZlMzI2NjJmNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2AukM3oOgC5FQNNUFSc5O/nnaFaf2gET6Si5xNrYaunpN\nsi5tFMe30aHtHR+0WoUlK6GJwguSk5DljJ4rkHwMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb+23Hjpj7SkhrXVndqJxS9x4\nXIkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfjLVAwCD9pXm2b/9ckfIgC/HPEC0DY7Z0q+INdX3sukCIGHbI0LoKc2N\nEOLx75IdIWG4opBagUS2Z2KOWlqLUaF2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISASzdZgwX2qrqy44I1EWJ/jtRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWE5N2U1MzktOTFmMy00N2JlLTlmYzUtYTY1ZDdmNDczM2Y1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiZjk4M2Vi\nMS1kNDE5LTQzMTItYWQ5Ni00YTUzODRlYWFmNjgwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR4PMNil2WzA0L4BEODaQ9nisv83FSXzw18dRZBnjuoU2cduYd9yCF/\njfS8WpHVaGh0yzbxN1N8LcsMrpOZPbhCo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPVEuZ\nBMexfKJ9KFJYlNnfWsZcujAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKapcuqHkWY+WQXoPLf26E6eR1U+Vkej8O8b\nwljZOTSwAiEAyD8Xjh/y3LlM+FI+2f+p6Db/hIo9H5fHkXpTb9UAsH0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6545", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6545` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAaPwnX6U8enU1iTNpPOchTrDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMWVhODAyLTM2ODctNDFmMC04OTRmLWRkMjU2M2E3ZWZiZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTAyMTg5NGQtMTg0\nMC00NDI5LWEzYjYtYTBiZWE2YjQ5MWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPDmyFOaxi25K74trqT44lK2O/ew6ZWIZOl05y/wy9x2DlYOnHxoVX8pc2UYc\npAsGUTg8JI54r5+7B0CxgFkMtaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK0lSB69nStNYbnIbVr+6lq/UlyAwHwYDVR0j\nBBgwFoAUC0w/WDME5pL3JAsv956VLgO4ZJMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDNu/MF99LU9QSL62bp+5JajqIQdg405x4Y6C4AQYKN2gIgdF+/whwi\nqiLdRO8TKX9iPz+W9lAd0+DS1BVV+VEEsos=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYINBaYefSNQmt+O0OMy3i9eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjFlYTgwMi0zNjg3LTQxZjAtODk0Zi1kZDI1NjNhN2VmYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYpr211WT+T+QU7KRYP6f+pWLnNfO0FVgK7cQtmGPKp43R\nZUeEETFPcwPc33BCy8BUi1I/Tk6Fcg28i+9mXxRVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC0w/WDME5pL3JAsv956VLgO4\nZJMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVWnXBPUoR8yBMiKlVywvN0V704zcsADAYgQQm3Hm2PcCIQDtQcciIb0J\nEEFpRoJR7Sj2kZD2JYX5Lp1G8M9fQIwIxg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAY0N4L5hM2N05fVvDyozRBHCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTAyMTg5NGQtMTg0MC00NDI5LWEzYjYtYTBiZWE2YjQ5MWM0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ0ZWYzMzMx\nMi1hNmZjLTQ3YTUtOGVkZS03Y2JkNTUyMmExNmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAThORNZER/AYNAD7xlj6froTAlx+4ybCHrYe6Hg+kSgT1toG9ukZKjH\nsWkE9qMBean9KNfRronE+Akb9Vlz6o/bo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrSVIH\nr2dK01huchtWv7qWr9SXIDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJWWCf/ckqEHqDThZ2Txje1Bjkv1g3YvgJga\nS04/axsNAiEA5iGzkcyJHzRKKrsNTXbUKwuS7AYoeM0Ghx1OEEqP3HM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6546", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6546` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAVRL6b5l9pMUecbUTAE+i1WrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiMTY0YTlhLTQzOTQtNGY3Ny05MzJkLTRlOWY3YjQ3OGM2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM2MjkyZWQtMDIx\nMy00NDliLWI5Y2MtNTk2MGMyY2UzMzZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3f9ZvRDofASG8GdMZdgrquaYMgkjbq19ohWJ8XBq7r+VvjX7BRxO6jaM2e/5\n8ZeJTlrBYC1jScKvTzBCoGWh/qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD/qYLDYVD+aSDd+qR+bPiEii5vswHwYDVR0j\nBBgwFoAU//d62O2hQWedU4JV9obrcSRqxb0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIAQDUVSfY1GT42xzNx4kqHRkTxbx9h5c6LlR5pFWCqxLAiB5G9t9GQOi\n3vHRUgWMShI87USvr7C42WpT2J9DvdY40g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX/wPHl24JtWaCK7kUxa79VjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjE2NGE5YS00Mzk0LTRmNzctOTMyZC00ZTlmN2I0NzhjNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4e6AYkBcsD7pzpsockfcS10bZUl8GP8bAF0AEsPUZpzi5\nUb72kvT12MvDa+cvZgA1yhCbvX+vH/OdupJsnQd7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU//d62O2hQWedU4JV9obrcSRq\nxb0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNYdfOTuHuGFADyuVVfGoDZ/a2H7toCEzVy0kUgV7gG0CIQCmN9ib1ixx\nChxT9glj0tv63LameIacqIqKm0dbyEnr6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAZDI8mNmbkFAvf1Lmndc4GdDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM2MjkyZWQtMDIxMy00NDliLWI5Y2MtNTk2MGMyY2UzMzZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQyNTQ0YTA3\nYi1jMjc2LTQzNTMtYWZmMC04MmQ1MGU5NjZiMWEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASSHV41qTtTq6w1txCGbH59gXOQ93fSkgzJtDY7FxqIW4bZy2gc3mA6\ncnOyE219bC59+8eI7pvrXDd8Me0lO/Aho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQP+pgs\nNhUP5pIN36pH5s+ISKLm+zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhALukYA6o5S7+ynzg+52TVRkR6gMQlHTEu+Cn\nyAyvLmrIAiANKSItKDM0qdTnGS+XLbUYG33QnGJwsxDtptRVVEqIyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6547", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6547` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAcC7Uhxbk5zBpZr3acYJ4YuiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYmYyZmU4LWU4YWMtNDAyNi1iMmVlLWUxNzY0NzAxMDk4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjlhMzdkZmEtNDlh\nYi00OWExLTlkMzctNWI4NWE3ZTE3YzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMpChekC+KII08lCFP/nKEg9zwxeH43umyxy60RHVebRCwgTuYDvawa1XLQLC\nPuW+NtwEHdaD0bKyVnHq3eOynaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWLBCDhdvtbKar+wDjnRUR5Y4QTYwHwYDVR0j\nBBgwFoAUxvDKroL2WBeV23vCsqMnfCYvB6UwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIGzSk1ACbhOGaUQ0wOX/G530xxBR+VcH9VkQyop6O381AiARrW5p3oTFS6Meyysg\nBF5MRd+sTl41qHcTZRHzoJV7QA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAau1woI6CQ3QNccnA+6S3rzkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2JmMmZlOC1lOGFjLTQwMjYtYjJlZS1lMTc2NDcwMTA5OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThEV4ZNI03aVuZbqBWLkvig3h8zTp8Ik1TDN41XV1eGMNW\n5qmYPumfmsqgEyJvaFkrzuPms8wwrFGM/U0OE8Cho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxvDKroL2WBeV23vCsqMnfCYv\nB6UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOgSMHHumj4W5yYaC1eTrgp+/rK7nOmOMGVTGlpV9HfoCIQDe1sH4Z5Ol\nJSd3AORvq8uJfN3hEwQKE/+zqwfWD/sLDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISASPOqtAq+DSBX4uvKex+vz6EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjlhMzdkZmEtNDlhYi00OWExLTlkMzctNWI4NWE3ZTE3YzdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRhNTkxOTFm\nZi1kNmQzLTRiZTgtYWIxMS1iYjY4ZjI2N2Y2NmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATyFY1a2HMOsCMW6S8cNRhDJ+/ukAiBhpA2/5VHeVz1URPZ2kNsfYOp\nTwFeAWo4W2UvCNPe0I+ToRehd0UO+NjOo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRYsEIO\nF2+1spqv7AOOdFRHljhBNjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgKFlQlv3psNvigl9X3C8qcaN1ugvrgahS+PJb\nOw2lHbsCIQDYjRqvqPnlBjufK1ot5hWzvno6HtB5qYxRfq1pktq4FQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6548", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6548` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVT+3jAO5GQAQA3WCmNjhBHyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjODYzYTc5LWU2YWMtNDQ0Ny1iYWM1LTkzMTVhNWUyZTViOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk5NTI2OTAtMjUw\nMS00Y2MyLWFjYjQtYmQxNjZlZGY2NGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB40xEp1JeorwNPRlYJIjh0gSbdazerPtqIIqFNq/UykEWpOONM9H4wBlx+4e\nLHaQ0kdkEh//2S30Q6RIeFfGZaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPbHcZyiH36tEzbbbN5r3N/sN74swHwYDVR0j\nBBgwFoAUwW9ZfjOtCoO/yuFmx5t8e20tiaUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIFT2dxrXaXRFKatMw+H9GTs6kxrxuVSxJwhZ3VikQDlHAiEA\nhYP+pa56xaYlfYgiyLqFbsSAmRdUzE724MgaIDNdAtU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ4566MtUZHB+iDEdGwqqmnaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzg2M2E3OS1lNmFjLTQ0NDctYmFjNS05MzE1YTVlMmU1YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIeCO+liX0mcAcoBBrCfl92YxyzjiZieGT4F5J5M9lZPyp\ncGZlMo7+1Loj2Pb+nqvLOriRO4Zesd3L3Fmdbjneo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwW9ZfjOtCoO/yuFmx5t8e20t\niaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge0oqPP050tdmMxE46tGMO5Kipkibq+QrsUJlmvmUH7gCIED9pFrFuDlu\nP2XyJWB8rUKGOwWA5epLlVLkeCgWjecD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAcnuu3TYFIMKS62FTS2PKQ7EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk5NTI2OTAtMjUwMS00Y2MyLWFjYjQtYmQxNjZlZGY2NGRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmMmMyM2Ix\nMC0yODM0LTRhZTAtODU3NS04MDkwNWE2MzIwMGQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT+/OXdKOyWHztvkeoz/5IFijx6cyuR0FGvN5+NYEe4hsm9wM14GNJn\nkUIXkDWIpT/Fe0JNsDUf5I+0aW8CWI9oo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9sdxn\nKIffq0TNtts3mvc3+w3vizAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgHikQp0fPicg2UOOqRb70bdCBjTgKSgd2/n6e\n0DKxVD8CIQCLrq0fUhji3xyM/AGz7a7QByM10GZeBhG/nSYWAhLW8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6549", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6549` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAc/1qXZ8yUaA9C/CTQBSW9gsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxNGYzYTlkLTVmYTUtNGZhNS1hZTQ2LWRlZTlkZGJmNmQ4NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjUwODExNTktMDVj\nZi00NjE2LWIzZTQtOWFhMDU4YzJiYzNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqT/TGCumgfWL+DB88M4CVAALLON9Z7oBIJ5JjYk1mccwvAfrx1/0ztoHl1Rd\nm01cn/pOguHk7qKQvwdIeaCLhaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTwhgNlBKrHIVShnCLcD6VLw6oRUwHwYDVR0j\nBBgwFoAUGa3c/nhQbUMatWJMsVCKD2F4HAMwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIBOEAbS9458DRy3MkqgX39IUZAuXwLwKQfMQG9pLzsy3AiEA\nqvH1DmLcCYAmpEjlOAaFMCmzlxTZxmgpF17dTetjeGI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfD8fwT6CF9LSLgHfTLCyye7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTRmM2E5ZC01ZmE1LTRmYTUtYWU0Ni1kZWU5ZGRiZjZkODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzh51B6/fFPe1wzc6RB7ecTzwjw1/MlWkw0ixCOtBGuD00\nrnummYhjbjUcoA5ltQp6iaJXjboikjDHKs4yxWwto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGa3c/nhQbUMatWJMsVCKD2F4\nHAMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge9VsrODURAeC3Isi5Z6IDlIOjUVMumQXPzwR4RnWWU4CID8hjbKEdSjc\nU/SbNinxYzfItxNbZveVFAPoFPTd5qRh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAfpQ5AWIlO4kDjWdRYWQ88mnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjUwODExNTktMDVjZi00NjE2LWIzZTQtOWFhMDU4YzJiYzNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2MTk4YzE3\nMS04YmUwLTQyYmUtOTJlMy0xNjlhOGM3NDkwYmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAT6Qh7ghmKucQI6wzhRXLMRUIYyiu1if3OcjnbW8er3e/hIjV2GPYl+\nBwq2RFFVZbCL2mQbBhB5X4/u9pd9mVdWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRPCGA2\nUEqschVKGcItwPpUvDqhFTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgITpP+E2gevSeFKpnCyp9jCzkhkpfDy5gNT9n\nOostc0MCIQCiwJu9grzidpn3ItQzePfymGTwxVBl5Oy0f8eakIGu+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6550", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6550` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATEQYe2IzDopMr4aJ64WA/VAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1YzFkMmY4LWFhNjQtNDVkNi05ZTlkLTlhNTVjOTU3M2ZiNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2YzODE0MDEtN2Ey\nZi00OWVmLWJkZGEtYmFjM2Q4NzM4YWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+XyArasMB2Q1q6x2Z66Gwn4agkEBwlWzOR/80lrtrU4SZcn3c3nEC1r4xbO3\nifTjjh7d6q4d8/wouznMt1JulqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiCEnB42dX2o8iYZ6iIAWm2bhCAkwHwYDVR0j\nBBgwFoAU/F3R4MF0LKm7/uW5u+ve7TnLHlMwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCP/cFyjujJ\nCw2XHTwm4nC2OSS91b6jq66YItaQv3q1RQIgGNl6UCVq383RTdv5mdLdCCwDcbhv\n+/lnGUF8HuUGomQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdE9KIVhWCQywBb+WEWLd5SZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWMxZDJmOC1hYTY0LTQ1ZDYtOWU5ZC05YTU1Yzk1NzNmYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqVd4Mhzjj+ADAUQob+LZ4dYnwjXUBgiyRHc0H5FHSUIBD\ntjkEXKmO/uM8MbqmUxJuTKCuTN/1EThzC490WyBdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/F3R4MF0LKm7/uW5u+ve7TnL\nHlMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALhxt5/mE4vndtC//X4URdyjzurP8IIsqPZMw3P2hnKgAiBNIohMJdb4\ntlP/6DjPrMPyE4LCaQ7Sba2kIu0nGtaCzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAXqBtqcA1s3341C6RuBlH03bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2YzODE0MDEtN2EyZi00OWVmLWJkZGEtYmFjM2Q4NzM4YWE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ3ODUyMTVl\nMS1lNjIxLTQ3YjYtOGQ5OS03ZGQzZjBjYTcxZjIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASb30db6SlCqqwgcc3K80/J/4KfRDhGxPBeDHZlX3b+CROvzO0pY7oh\nCjgVILK1cPd1eLrqkzu/2itmDoJCUMRIo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSIIScH\njZ1fajyJhnqIgBabZuEICTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgS8N3F1RrSuGz0UfGF8xmm7yB8oKgV5YvLlQ/\nWo1is6ICIBXCrUhJqTqujF+ovEBRDj8i75GIIXvxgN2lZuJ895Tj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6551", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6551` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAffDjTi/IlN/ms8GrOuLUN8oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4OTZlMzBlLThiMjgtNDlhMC05Njc1LTJkYjRjYjNjMzQ4ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgzZWI0MmQtNTc4\nZi00Y2MzLWE3MTItNTgwNGZmYTNkNjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/SXMnMXnNHt+Fp51Dq46eLxE20nneOadehPLEsiYaCuycdnRodGq7AqgqqoH\ncL54W3e+9K6cPTZ/M00je89gUqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQoj8z9LR9sdGs2zmfe4cDeDKQi0wHwYDVR0j\nBBgwFoAU/JxY4GKapQ7EL/MD8z0HiRrS79kwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhALfI5HuOD60vFmtw5pu9q0oBAPfPFHF1IHJ8lSL97YavAiBMth1AP8h9\nJkpV1xPXqaPlNsyClJ+Td9RuEtA8Pjfncw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX6nXhm9oE8ZaeMtNFB6yoRzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODk2ZTMwZS04YjI4LTQ5YTAtOTY3NS0yZGI0Y2IzYzM0OGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/UtnEGnVvyd2T+FF2jLK7YzpCoNr7+eiOenHz93KiXC3j\np10Hs0G09nXnq4N1/+ttU97IsyMSLf+lA6SskNreo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/JxY4GKapQ7EL/MD8z0HiRrS\n79kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMk90VmSs6WW72VOrvaJ4X/z1Q+TL8bvJ2qKT53TI21OAiEAyhuW8+ur\nXXuBOmrpScXhabYEAzqHmdOCVvSvss/IpQs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAasplxzsgEZIZyJy7Eh+Un47MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgzZWI0MmQtNTc4Zi00Y2MzLWE3MTItNTgwNGZmYTNkNjg1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwYWFiMTEw\nMi0zNzM0LTQyMjctOWE3Zi0zZjM2MmNlMWU1ZmQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARv0tjLpw522AmnNEBN/BT4dENlYNFBKhlFaQUttydhL0y4GhG2OoRm\nUFBsM3q0oTDhum128idmSWVqkK2ry6Seo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRCiPzP\n0tH2x0azbOZ97hwN4MpCLTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMzWdsHnE6MTB9umThr2/aVzLzSHa8NEoFuH\ngAiooosLAiBr7m78VRvAPQkVAFbApVblW9TBYeiGQIdi1JmkGJWAUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6552", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6552` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAY4xwCvGJExjzChKZqejne0JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzYzIzMDZlLWU3OGUtNDIyOC05NDIxLWE3ZWJjYmQ3YmE3MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE4YTRmZjktNTQ0\nMy00NmJhLWJkNDctMjY5MmRiZmRhNDdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED7K+mepJ2efF3n2aU7bRDydyyLkD0xipU2ZF3i10dFpXuk09uyzN+9RIezC1\nb51GBoCx8cipPbYioZbDmU6u6qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVGKsoSqAfbDgOWPB5dtc6Xu+HXcwHwYDVR0j\nBBgwFoAUj4Ks4+GHG7CEIrddx119vqgSDC0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgML4KRQkJSryDWX0tyuNXhPx7fytq7eD569OoA/7lSLICIQCTwRBw7RCS\npr0v0lmpdjnrF2SoxgbVhIXpXl3fjBl8cA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZZit2r4nCJpkZOTDhpPqX7/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2MyMzA2ZS1lNzhlLTQyMjgtOTQyMS1hN2ViY2JkN2JhNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoFE66TmBmldXED4IjmgtT2JezWr7cmdn05FI2XGS2l9Vx\nMk9Z3HH2Cz1NCqJSJBPA8S/d6kqOzLOSr7HrRPwGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj4Ks4+GHG7CEIrddx119vqgS\nDC0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKptA2ix3BqqVOSrLD1lMZUYV5B2eoaN4NimOp8rI300AiEAngJSCP4g\nvf8NC1+rC03zm9FU837HGfexNVNftBLGbgk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISASKU8dp0HCq8GXas7vNoeXzeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE4YTRmZjktNTQ0My00NmJhLWJkNDctMjY5MmRiZmRhNDdmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1MDZhM2Jl\nOS04MDU4LTRkMDctOTMxNy1jNjE1Nzg2N2IzZTMwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATlX2aeDWmxHkdAN0jUDiiLwJJQq7pT21lk37z338x0yKenK8J3wKmt\n1NVLR95gkVpnC7qkQaba5lACvZHcROoTo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUYqyh\nKoB9sOA5Y8Hl21zpe74ddzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgOEbkZfyqz5KFM/N+Tm2XyMR83E3krYmwyUfD\nithaWGcCIEkUDTMDj2tAo7A6AKm8JmgsiAVdX4/uZUYuyy+/p15G\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6553", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6553` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAZ+I8x6MDowvbsvEljEO+9mRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzN2ZjZTY3LTY0ZGUtNGY4YS1hNmYwLWYzN2ZmYmRlMWIwMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VlYzA0OGItMmIz\nMi00YjhiLTllZmQtODY5ZDdmNDljNzg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcwEV6DkhJFiclbSZOXFMiYe+lW4t+uEm3fbzbtbEaiVOLG69c+PNxK1A0loC\nwlsrmQ3Ip+7nARzCKY1OBkshK6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFk4VumPi1s+GeThKHUp49kJ44PMwHwYDVR0j\nBBgwFoAUvhGpMD6Wo561wa2hpqJ9Dsds/DkwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIC9v+gJIQRU7P9IYRDA2CKP8XW3WYMV6AoQ1LzF9LX3cAiEAiESak1Bo\naOr/s0NsMKI54RvIkbAXVrsSGH5nff0w2DU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZYWH4vPLcEed560yaAinI66MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzdmY2U2Ny02NGRlLTRmOGEtYTZmMC1mMzdmZmJkZTFiMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlCS0NByKqD93PNcFCWTwwFXT9rkbZ1Sl+n67/HVLGQwV4\nMXB+0udey4zXmWtzw9Z0Olzg3D7xTz+0jqojCINSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvhGpMD6Wo561wa2hpqJ9Dsds\n/DkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSoxDh5Mza445Q6atTlHIBMQc2RrqrLbWdDLyw8FSD90CIQDQT8xbDkLT\ntH0ESWyuJ8IkIGs9v5cJvWZvLEc+XFyagw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAQJezKoJWXriHrj+gkdpVodhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VlYzA0OGItMmIzMi00YjhiLTllZmQtODY5ZDdmNDljNzg1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmOTgxZTBl\nYi1iZDA2LTQ1NjItOWVhZi00ZDFhMmNkYmY2NTEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARDTVZUTUfTLE51ktuMZjfaNWzhbwCqXIcTpvKJiqUA9iRnrGxWCoL5\n7z1nr9Emb/ax+lNrtiiT+aY3+fU5hsBTo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQWThW6\nY+LWz4Z5OEodSnj2Qnjg8zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgTSvRsy3u3QOdC7l1UuyeoncTEhvSKr80yvQc\nsx5GfrgCIFtIhnkrP4vSvY4CSBjSGC35+nrZm+6EIh8G6VuKCyqb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6554", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6554` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAWyBaD19PhH1R6P9ezOjx9BRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmOThiN2UwLTU4NjYtNDMzZi04OWI5LTAxYmQ0NGRkNjIyOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEwODMyZWYtMmIz\nYi00YjY0LTk0OWYtNjA1MWYxMjJlMjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuLTZnDDtWkbKO+M/bpGtvG7hnTbQaRJbLw2vMRZui7bVqmatA+Vn5Jf67k+j\n3kTuuA9oJfjxwGfdfEiPqVz8CKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9N8JWq8B5S/oQL5uNDwm5I1KhAwwHwYDVR0j\nBBgwFoAUyrWarmcXN735yYJQ835zIw+l3uMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDRd7qgUsDUHomPVqnpXYPsVqW/vu/5zbdQVSH2\n6FTKLAIhAIWXb2EJzkDZn4+1yDsxCltBs0/UeJw+UhbVLgUj3YpA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY/iRZJ1PqUzArL6IaH8mFYaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjk4YjdlMC01ODY2LTQzM2YtODliOS0wMWJkNDRkZDYyMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQU9sQsBeHMC6AlZEXd9pmJx8W2tn1bfe7LaHa6EpHawgsP\nurP4ESrPOhtM8VUdSSHI/6TB0O6XLCL5SWiovUjoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyrWarmcXN735yYJQ835zIw+l\n3uMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAzjuz8Gn3+7oFYBGVMMIqduBnQ8zuQuThqEoRj/ENlgCIB59YFL6mTdW\nq+IS+OX7cGPkYTGr+4AosCGJnWO0BEKe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAY/lBUK9DBGVo13z9cx6l0y0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEwODMyZWYtMmIzYi00YjY0LTk0OWYtNjA1MWYxMjJlMjZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiM2E0MjFm\nNS0xMTNkLTQ3YzYtYjc1ZC04NjBjOGUwYmRlNWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARnXDR6Ov9O0+izN5oR9CGBPSn0WOLYNsI9aYuu7wIjOVzWuTSvGXnQ\nF5SkXgt5tcwNL5RpDvlPKorDEY1NgkNQo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT03wla\nrwHlL+hAvm40PCbkjUqEDDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgHbUoMh/NgvhREbkcfIZsf9KHglk//RO9gVnQ\n+Z28I/gCIQDYYA2KWevjXNUnlhQJgorjdXbZ0fyk6PMP/hSC+Wl83A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6555", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6555` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAUbG0kfyAfAHm7ldKBb2C3EfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2MjNkYTA5LTRiMDMtNDNmMi04YjQyLWJkMTU1NzkxODAwNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFiM2RlMTItNWZm\nYS00ZjMxLThjMzMtOWI1ODBjZWNhNzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwF8Rn93T8BgtaCAawv0YbWb7WJxNcvMixraLhgQW8pZPS8TL87h2sNZc8iRT\n/J7grx4ozTNm0+es3wiaYn9iO6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1YD/DZ+2dQprE4Ec0D9wpGqHXNIwHwYDVR0j\nBBgwFoAUEEeAgD3oTJ1ofBz0X2UGNaa19/QwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCpAtMgrfZ9vQf9qLPPGVypvLTB4/HIIck8+GdR\na9wAIwIhAJsFn3TApaOfoXeH3axb0fC60cXuAQRJHBg/5Z9h4now\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ2nb2JJcS+izZk7BMyXuX35MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjIzZGEwOS00YjAzLTQzZjItOGI0Mi1iZDE1NTc5MTgwMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASF7G0yULYVxtmzxOywymAZVUtzdWTHfUDtxT1iUeAofhRd\nRZjGoxBXTNq+5KzXimTpStCxdRl78NiCE2lB2ncCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEEeAgD3oTJ1ofBz0X2UGNaa1\n9/QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLoXDInpCtI4jQ20aIbav71qvLODxS+x2Cv1VJqao3n4CIQDQ617ysAa+\nE7g7gkyhcXhWUOb8qnmiDZ/PR0za3wQSOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdqgAwIBAgISAU0QAn+QB31cGlS6YEK4E3rPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFiM2RlMTItNWZmYS00ZjMxLThjMzMtOWI1ODBjZWNhNzQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ1ZjhkM2M0\nNi1hZTg0LTQ4ZDctODg2OS02ZDA1YjcxMDQxOTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR5bgxQxDOfp0jrnrm4AUyFEwL6zXxElqzLVb3Xig8GfnfxGPNMoa8n\nTsh02ttCmbhNF1B59TCNd8pgg//icOPGo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVgP8N\nn7Z1CmsTgRzQP3Ckaodc0jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOlOdfxZ0t+i3LiRT/6R57LF6M/iLuoSa3cF\nymSOGAP4AiEAxUmkN5BgqNmnSsLVEPGh/Uk97OiScyXkWeb3cuwWT8M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6556", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6556` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAfbgyzwtsPYgmyRfW7qhUvf3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkNjEzN2M4LWI1NzctNDIxYy1iYjQxLWFmYTc3NDJhNzAwMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M4OTE1OTQtYzQ2\nMS00NGM2LWExNzUtMWJmOTlhZTcxNTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErr0G3+jFGLswERGn42qLacIEwxULpX4fgLVA0KIHL63unyoqWdgbZXnQG+CJ\n+fFii9x2i7YTnFOHYze4xSxQFaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxKuwUdn+C/2zpY0rUi7giVRiE1gwHwYDVR0j\nBBgwFoAUxxa8vq2yzSFVLUV6gNRJRXxUvGgwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCt+7Pn2Nzg9cmUzlwc5oapWDwOe7SSeTLGSu/LGFEDQwIh\nAIncUinGQhknTydCpqCu0ZyuylWymy2uK6jI30HkgVcU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeOGjTqY+pPBpvQO5kQ4/bl0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDYxMzdjOC1iNTc3LTQyMWMtYmI0MS1hZmE3NzQyYTcwMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8LuJDh8smC3qtgXjoPOUVsOv4RXvO9V1jSRPPux1Xzcod\ncWmhWwnp0mtdjVa+a2dhrRqwcwCWVMomS/s+bZkko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxxa8vq2yzSFVLUV6gNRJRXxU\nvGgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIjvix4CvQtS71ClqGttgVkMg4a3NuiMw/D5gSD19PVDAiBZOiW/UotV\nFKZXpGtHdwMxsn2AJ5KfzFHS3rXDIrzLiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISARH0XASysT+ma1Mwn4AsHtcAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M4OTE1OTQtYzQ2MS00NGM2LWExNzUtMWJmOTlhZTcxNTMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQwMWIzNTRk\nMS1hN2I2LTQxNTUtOTBmNy04MzVkZmI3OWZlMzEwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQcmbIWZe1GXhAFCgAm//kDZeqsNjOTObE99LOlTpVpD9h4JzXDgKo9\nxbOlI6VU4PFkuyEh8m6OdKk/PmhGy5kCo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTEq7BR\n2f4L/bOljStSLuCJVGITWDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgGJEwpm44/K9f8Uk47IMfKrE5mGJceCctgMd1\nUpYI6csCIGl4nvoJ/M1NMIJLxjMDFZXBv3JN8GH2PRPeS59dEaZX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6557", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6557` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISATRrkfecYmq1LNlRQt/aNi3+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmODhlZGQ2LWFiODgtNDcyZS1iMWJmLTg4ODQ5Mzc0NmJmYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRjMzBiZjgtMDAw\nOC00OGFhLWJhMzYtNWM1ZTNkNjE1Njk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqTJtIm3X3Ynbwa3GLvIf2vPhrbIV1uQAR0Qg6YsAcmYdC+lufxMg3E+TNm4h\n8m8St6zZ1Bnceb6qkgU+FArV56OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNeR6nMewB5iOObSpTdD8pQIEDZ8wHwYDVR0j\nBBgwFoAUi6rZYSiHqBLwTv1SCgu3c7ttM64wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIFj8BszIhejrDbCCa4WcB1Jn5DPtZ0z8\nuRVemE4A1JOpAiA3IAs5O8JG8zQWMhGLyuFImbrzhI9dKiavE9d+7GP5kQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbHnQYCy8BKEvGQXLAbmdgnvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjg4ZWRkNi1hYjg4LTQ3MmUtYjFiZi04ODg0OTM3NDZiZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvrJyXR921MAWRwACh+f/ZaRA+cqm8SfCQtz4JcsCqV0Fc\nHAs+Mhmniz0tjrNaltl16awzR7qsBYxQTfQc8/oco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi6rZYSiHqBLwTv1SCgu3c7tt\nM64wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSXWE8Gkj7AcmQB0hFo5zW7z05DLaP+JqyNRVoyXSPWgCIEbhkssRgLCT\nlLudsUlFqNL7ZvM5Dkj+a/aNC6phSxom\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISATSKqgdSv/K2+ZBmbYGjUlh6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRjMzBiZjgtMDAwOC00OGFhLWJhMzYtNWM1ZTNkNjE1Njk4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzMzc0ZjYz\nOC03YWJmLTRkNDQtYmQzMC01NjEyOGZkNDI2ZTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATqwaLUWuIKRiqXXrH52N3YLpV+l96fqIbQMcmMCpmkr7ebhYwpdCaA\nTMOk0UNQ4rZ6ezpeqBQJHdB7aU6Q/Vumo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ15Hqc\nx7AHmI45tKlN0PylAgQNnzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgOqlysLU5ZIRqS5iMAiB2D8jw/GbXZp1Ftey7\nyU26Mc0CIQCNoqipUmQn/GSZ7V+lS/H/4iTNd3lgYpCA7VJjZXgyJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6558", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6558` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAYjLaxCf3xKECDsQxKsh1cFpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NmFlZTdjLWE4ODktNGNjMS1hODFhLWI3MDAwODk3YzUxYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M2YWM5YzgtOTcx\nMi00YWQ1LTg5N2QtYTI5MzQxZTM5MzA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElB3dgzQ28xXaApvkc3XplNrPc4ZzKm/cAtEwb7f9/jYmVdBrVU/gd4Dhp/BE\n7BppcHDk0RW8n3D7RE8UwFaVLaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURl9Kqj2F2bUfOT6Fxl8nVa1rgIAwHwYDVR0j\nBBgwFoAUA7lCqPrz0MD60eFxTKV2ARbRd6AwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDkKwJLCFmbdqCGRT0E62p36YnGMmsag\nttowJ/5sGdLwAiEAvsau5wr7bYeUDHzK/QugykT2LKwT6/HZGXaVeZPJZnE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARaQsEzwrfWbyAyGHtqkIYHpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjZhZWU3Yy1hODg5LTRjYzEtYTgxYS1iNzAwMDg5N2M1MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtfAZdATx1vNIX8za+RnLjBIIlqGSHSUO3QMSG+ShjTbsM\nesS1kUrXnwZMgxyndd13OHidy+h9/r2UgSE1j+OBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA7lCqPrz0MD60eFxTKV2ARbR\nd6AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSZlfMPETCEj+oCmqJIdMa9yC9r2PP34fXvkCnDDEbOICIQDIoM3P1K5D\n6teCYYcizxLx7Urjwkn3RLLNvpoOqdlGPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAa8fLe7WC9V7CectOf8eOlTqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M2YWM5YzgtOTcxMi00YWQ1LTg5N2QtYTI5MzQxZTM5MzA2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRmYzEzN2Qw\nZS1iMjdmLTQ3YTYtYmQyOC1kNDFkNWE1M2JkOWUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATJka2YvHFrR7ynakaYCawGHll2MGRYYb9sVSa/cYiXd+ie1/zeDDTB\nzws5hRbGiqYHbhA9sgu5hRA/ykhn3oJJo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGX0qq\nPYXZtR85PoXGXydVrWuAgDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhALQckXRH+9bL00mbmBT4fwEYlGlMXEYBsUJa\nBN1ert4BAiAF0r/a2i0e4qSO+SExm2R/z86wEHfDg6XYuK++YCW81A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6559", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6559` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAaK0YjgKDqKia4Bl7AeLGLFFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MTI3MDVjLWNlZjItNDU5NS05MDYyLWQ1N2E5YjVhMDE4ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRjNDUzZTctYzNk\nNy00MTMxLWFlZDYtMzc2N2M5OWMzNDE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvbdEtlpXz7E5Uj2LHvODYrxAs8TVh/RfxnWS7SYHt8abtDgLWkt2QgChvILn\nyXppKY9tDdiPulDWuYo+rM3mlaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULj5yQIKwQwn8Ef6dVgWi7Trgi/8wHwYDVR0j\nBBgwFoAUjI+yauySDusryl/NucNkIHwysDkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDK62WMQcca\nemy5nYtvxOuB8cLRQ1RuATb/lbd8gIBwCQIhAI6SIfRZlstg9AoT61666QsNx0vp\nNjH4Jc/L2rdnPCN/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdbkgmbBhJ34HxlD6bzX0c9qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTEyNzA1Yy1jZWYyLTQ1OTUtOTA2Mi1kNTdhOWI1YTAxODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASogQ6IDP0iRSZ3rW0gBxFEkBrtzkLfyGm1/Zmr0UrMJInD\nclMnxmS05DUyKAGGzgoPs3lPquxXoSBvpoojo08qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjI+yauySDusryl/NucNkIHwy\nsDkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHQDXd+/MKS6KEFz2f25iWdcCMMWiAFSRufGqKYnsJkQCIQCmBVMAjhZf\nC+c8HtuWgbn+wsCHi3rzqU1s2vu3CWTXkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAfXzyAh423gSoHwQMnjK8zrYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRjNDUzZTctYzNkNy00MTMxLWFlZDYtMzc2N2M5OWMzNDE4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQzOGRlZmFj\nNi03M2E0LTRiMmUtYjVmMy1jZDdlNmQxNzUzNGIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQcnVVdUfZghOaabEs3e7bqsaMxKm3xX2dBWOrNGYxjDVM9f9w86Ox8\nLl9aWsrbfqFlcV9t1Lw5cRw97y2oKRzuo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQuPnJA\ngrBDCfwR/p1WBaLtOuCL/zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgaZNgE5TaFwLw64V/PCtLnvYVzznOmsgzavuU\nPcSlw0ECIQCmjXNf6XsTX/0aHwgJCJYECyM/zU+b+ZbNkZy3srq2XQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6560", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6560` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAR67Fc4Ln/b5i9JZ5AdvHVl3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1ZTE1ZGE1LThmZmQtNDIzOC1hYjhkLTIyODUwMTUzY2MzOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQyMzc2MTktNzcw\nMi00ZjU3LWEwMWUtZGQxNjM4ODRmNzNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmr1sMsOaXpqeY741Dk5QBOoGsHjnb6j90I9eI+A1djQPl34LvoaMwt29YkL/\n2c4/Dd/9o6nXSUaZ84G8L4qmj6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUrd89XVJsgwP38RCeZ0SJWDN1CwwHwYDVR0j\nBBgwFoAU4oO2i+xiD6gu78eulifGxHn5kIUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANEEu1CZxbIvtwkW8QxeAp1o4AJ95yCNRA4ZV9ihpAaAAiEArr/ui4W5\nsPT53sapHWY1kBsCuqe0VNg1hnADGZGVBns=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZA8EES4EKtVBjSHhTziVUt1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWUxNWRhNS04ZmZkLTQyMzgtYWI4ZC0yMjg1MDE1M2NjMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcbJKufTXPdHvGR7M2H6e046WWvYsOydYY1dRCAj66+har\n6X/ewaUNPcJWPUkMeJU9dOB154bF+dn0O/rPFTToo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4oO2i+xiD6gu78eulifGxHn5\nkIUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMp7qRwZHvX8bfF/PzzSR2Cj0iIz0OAWJalcmKbNvRsXAiEAwxadvV6O\n9TzKJB/n9dFs3CWRNKh4Ev/rF7pr7jbbWhI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQnBEGdu6fsO/l20ohRd14xcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQyMzc2MTktNzcwMi00ZjU3LWEwMWUtZGQxNjM4ODRmNzNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ2ZGQ2NTRi\nMS1jMmU4LTQzOTctYWMxYS1hMTllNzczMGUwNWIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQMh0/123GVDMcbFXzZrvfYqR8k29/vDqJWbWW86lDjmX7XjF8KmYVY\nLuRHySwmQ9TeQKUGcz+ZOUVAMr7tewJCo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSt3z1\ndUmyDA/fxEJ5nRIlYM3ULDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgHn0QQ7smnnZgiUwdjDEiOmWmZkaYwkIx1pBz\n+Vq4F2ACIQCuUiH8Qp/JZ4303jGhX+apUEhqbIPd+qlYO0RiuCwSsw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6561", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6561` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISATT+M5K3yPVbxQRaVJF0AiQ4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkYThmMTY1LTkwOWItNGIyZC05NTk2LTY0ZDQyMmZlYzUzZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk3YzYxMDctNmM1\nZS00ZTAzLThkZDItYWYyODYwZmRkZmJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErrmYMSXQaThRsNDPjAEjTqvly2PCkm4Vw8JmLKfSU028itUzALyQKnIohSmn\nfdv8xxb8JBY+KHN/LolGXU413qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcaNbJ0SCAShi/BvozWTG66U5KkQwHwYDVR0j\nBBgwFoAUug8XBe69l+YslK0qocxqW/AGUMYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgDSLzpu+u5Q4roLyKqQv0AohnNEzGR46kCgtaxXBJFn0CIHLLqY4nvsfY\nizWbNHaymSTnFDFdtwF6DSNltk6BzWn1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa3pYWW5GDHwih0s4pDrh65GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGE4ZjE2NS05MDliLTRiMmQtOTU5Ni02NGQ0MjJmZWM1M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfkg17saSP8h4qoPNyfpIta2jTxzYkVjoxwtVmANRh3qt4\nygHF5lvvE7B9kcIPV928rr945dBKjsyfLT+306epo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUug8XBe69l+YslK0qocxqW/AG\nUMYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALNVbrx6PkS8Ard4tJR/pRc2UOAtc4xXS25HV7eNKoiOAiEAp/KXPC9R\nSigMeGkXyjF4oHVP3HnJMonumdj/gRRwOFU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQLCd3OuPdHk34nads/2WwNpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk3YzYxMDctNmM1ZS00ZTAzLThkZDItYWYyODYwZmRkZmJmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkNGVhNzdh\nZC01YWMwLTQ4YjEtOWJjMy0yOWRhOWEzZmUzYTUwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAR6NQXl4yxfRf4kqTQGKz5scXpNr0PunsFCub0LCgwy9SeuY0eOGnbN\njOoCuL2eX+vEo/ibR033LeZEoUN8AL13o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxo1sn\nRIIBKGL8G+jNZMbrpTkqRDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgLpJtu5644/7oNKy79TaPYfuGFsXMrG0kPz2H\nfSmms9sCIQDMmuQK282G26LqNrYInD90vvh8joEb7jJwW/xfyYBTew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6562", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6562` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAfOZZuuzbrqbxmBQfTHtIj8ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyNDQ5ZDI2LWViOTItNDA5OC04YmQ3LWM1ZTUzMjc0NDI3NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ4OWYyN2UtMzIz\nYS00M2U0LTljZGQtNzYyMTI3YWRiNDgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpGumtmj+dBlhMjni+qjsOeLmzUjdAzYYBuUyDmhIveQjolKEYnEjkCvF/Gmp\nvfGDBjytt/TUakzlb2w5CEidg6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvWhh0keTFX0IqTh9sWykUtpd/jcwHwYDVR0j\nBBgwFoAUhVtMf8Et/WOD9OI9q3WqzIBBqLgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCwIBCXg6yoXtxM/Elbm3WOUi1aVrafYZ8NnSEETTVaaQIhALRcQOLe\nVdKe58fkbW/g/NCVzXaQkvpmZHgXYuIKIP5n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdvQ3r6X6f8dRzssNOfGmVSwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjQ0OWQyNi1lYjkyLTQwOTgtOGJkNy1jNWU1MzI3NDQyNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaO37Y1gCYWAlG5Cy86K0FV54vEY94gZqmpilM75UxTuep\naLSAA2lj7rRFmxO/u1VtvHdS+N5qHKSx0PJ5A+Blo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhVtMf8Et/WOD9OI9q3WqzIBB\nqLgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIbizN5srWr20RmefeoXMEXHT6rMPXZKUNmjOzuTmSXeAiBVP3QNv1i2\nbbBGD0al7IrAXMj1auB8cQgNuJOtNdOwQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMzCCAdqgAwIBAgISAUmIaS7lfmy7QNcnXTe4vnsDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ4OWYyN2UtMzIzYS00M2U0LTljZGQtNzYyMTI3YWRiNDgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ5ZWIyMDIw\nMC02NGQ1LTQ4ZTMtOThjOS1iYjI0NTcyMDM3MWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQVZJK0Dorm7WcNynckNxS2iseauzlUKpcxs4clt8v5maqkeCEaMyzC\npirPJKy4thlGZo18BkhxAuDpI0dh8QLio3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9aGHS\nR5MVfQipOH2xbKRS2l3+NzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDRwAwRAIgAJzsFa3BI3AlN+KyfgXFMDhj71FEHJnAjMNc\nwWHY2DICIAOzPyh3qVnBx0pfYqbNxwhq3yoBrie9uh+VXdgGntzX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6563", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6563` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAUhLRneWKWxYVLYd2Kgs07SpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjZWQ1MzdjLTk3YzUtNDZiZi04MjNmLTgxZGIxMzQ3NTI4MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWRmMjViMmItODk2\nYi00N2Q1LTkxNzMtNDNhOWU4MWRhNDEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFCudZbtfxmhELUCBwj6n1Zc35wG5gNo1rPzCvZah6tkMNWoYfIBDpS6mWkUj\nEp1nEA5/oHggNtf8kvcOIQgr/aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtjVAVh5A2LqXl4yLbbZS3BmtTyIwHwYDVR0j\nBBgwFoAURKBNpnyY3ZKFhcgP9KkhXw0HLHgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIGHYmfRufnn9rEznQFCnauFmCMzlJ3s3+8S1IG0Y\nPsP0AiAcCLlDcOEva/CnhgIi7hrwNPy0a3G3GgP0uWeftT7cHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVFGXVAuuqCfQ+BqDUXmx/xyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2VkNTM3Yy05N2M1LTQ2YmYtODIzZi04MWRiMTM0NzUyODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUOhJWZMM3EysGp718nZF6ZvxKtULBgal81J5dtpdT/YLG\nrkce0+LKeTuu/Tns+DsPCxpLKX8TR/r/MCy4D1Ndo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURKBNpnyY3ZKFhcgP9KkhXw0H\nLHgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALtahk/5Akn8SMQGow0gqarYD10OPk8sSPE+N73ZGfbtAiEA6PN9Qrtu\nvb0b/rGjPa19H26q3zV42C8GFYCEt7cb5V0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAdW8IzANHRGpoMaU1GAc6HotMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWRmMjViMmItODk2Yi00N2Q1LTkxNzMtNDNhOWU4MWRhNDEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyQ4NTU0OGQ5\nNS1jYTdiLTQ1OGMtOWUzNS0zYzg4ZGRkNzRhMmIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASevGxq4awM7EW3z+0TjaZNZiDrX7RW+6UC72h6oEm4gfRzrINNNWi2\np3xmJg0MjhRvHEx+6syZLvmuVhB8XjERo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS2NUBW\nHkDYupeXjItttlLcGa1PIjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgQrChZpescYiu7vnvhk3uh5sQsJ4s+C6OGcpH\nn3XiPGkCIQDPvfL9noObdx0HxxPE84MKSoPfQZu9OIpXKZ62Vh4IKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6564", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6564` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAWskumh+bb+hc+LSnxD4xuhmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmYTRiZDkwLTgwZDMtNDk0YS1iMTdhLWIzOTU1MTFkODg3YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFmNTU0ZDctNjc0\nMy00MzlkLTlmZGEtMzJkNWZkZjY1OGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEB1ujWlCl1H3uHsQRB2wdsijyekD3B4PzU28z9yP7RJ2yLPisUVB/EnRUj0X\notkp3OcXs7ZvHqxcKto5WXzb46OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUek5gmYaQrALXFfCvYIqRzxFC8NcwHwYDVR0j\nBBgwFoAUe7rGKkPc0jTqjogUjW5xwBy5jBEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIC4J8QIiqiVHX5Cy99z02beDvkJ+SOAQzNT9l1UV\nBqJBAiEAglyIK4RsmbBvYjRTwWBdAfcmwOFrlY+93RabX7AMwEY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARuJhAYM5cBm43313IV0CXvQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmE0YmQ5MC04MGQzLTQ5NGEtYjE3YS1iMzk1NTExZDg4N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGbaqLWU1GGTsyrtoZ+iOHLZYiwNkbFQvJLeszp79Am707\neR/ifIN1LSTsQikCI/fWc/5tO+foOTfIUzLLP8v0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe7rGKkPc0jTqjogUjW5xwBy5\njBEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP2OyJewtPMp+yEtcYSZFqMiPaASKdiCehedMc9Bi8IZAiEA9ab0imuT\n15AcFwWQUtY4srr6Ht04/gH+pUq9a87Qs6c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAVI0ubzdLpViDaA5ZmtR3A3JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFmNTU0ZDctNjc0My00MzlkLTlmZGEtMzJkNWZkZjY1OGJlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRiNDc2ZDIx\nMC0xYTQyLTQ1MGYtYjFhOS05ZWQ1ZTMyMDA4ZWQwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAASxjwyENN7fwXEHTjWQwyOv2p9XZN99aG3c1F+FhbSjCL8rvsWFmT7o\nW5oUbLnoPuOiH0HrqG1a9X1Lmg82+Xvpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6TmCZ\nhpCsAtcV8K9gipHPEULw1zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAM95cvo+eFt2hlaig/mihjjgiOg34JSTDkzC\nTcu06Wa3AiBSsfeKikSuUSlGYU1TElwbxN1lPr5bLAURZKf8mgJ8WQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6565", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6565` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAbxo9n86kgg4pC4Ow+d3GFzcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhMmEzN2Y2LTUyMWEtNDUwZS1hYjY0LWJhNWFlZTc4NWFjNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJiNWU0N2YtMDIx\nYi00NWNiLWFkODAtMjQ5ODU1MThlNDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyVTBhsVI5XvVNziKz2paJmc69ycUZv1IG86wT2N2O8kF7gS5AXb/f2ZTzEVH\naJ571vL77YmAkHH6bvY4vv+SX6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOPwsaQHv6Dz10wo3pNN9A1+wXkUwHwYDVR0j\nBBgwFoAULiuSbT0Q1oRPMCY24inKbiBSwdgwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIG8hintppgK5eyD2sNLFLsGHhpV1sFyuIdJlY9LbGeebAiEA\n6MCys8O7T/qlK+6bt4CkBycRFQPmKpdUTF76HQN++LE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb8d7rLDlrmUyeh5wc+J198aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTJhMzdmNi01MjFhLTQ1MGUtYWI2NC1iYTVhZWU3ODVhYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzqNq2Zc0we1WmSS07onMtpClmePDgCf+og/ru98YrZ4od\nBe5fCZ8nfguzYkfGUaGvby0+FFXpkFVq8QywRUkyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULiuSbT0Q1oRPMCY24inKbiBS\nwdgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF1vQFd/PdWtXCZTCxcerFWZKIDLzQc7YddHEd9v9TfACIQCELB3SCsg+\nT3nyp16IchYlvsia8KJlYnS52C3Ba22U7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAU1aJEcztOxpQpoBz+zYSQe3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJiNWU0N2YtMDIxYi00NWNiLWFkODAtMjQ5ODU1MThlNDA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRjNGI3MTNi\nMi00ZDA0LTRjNjEtYmRlNi0wMWQ0MzdlZmEzMTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAARAblbFc8AkE3qlA/pB5gqDZUbgam10lMK5BEWjEpgKgFpyhkr3Hu8i\nVDtZQxK/pTpgw21rogItRrGSZPX7Mm6ho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4/Cxp\nAe/oPPXTCjek030DX7BeRTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKtdfWieGm+MbRW/ab6IYsLGbLLhpIV7lIzG\nzzlxKXHmAiBwBWvDOub5OLb+KG0+HWrrMehBIdU/HLh/Ki5I1oUReQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6566", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6566` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbJlYzmWBJyRBx82vneUvQLvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZWVhNDA4LWJkMWUtNDJmZS1hOWY2LTI0YjQ4NGYzNjA0OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVjYmMyNTctMjQ2\nOS00NDVhLWFhNzAtOGNlMzNmMzg1ZjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl4o65tjxYldqRu+D0LWQ6oUmiJzH++Us+ibJ7q4nq4sGzvMry9a3vlwojDmV\nogc1OeKv7jW4nxBRea99tihhQqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhwn93uM1YIErLBIIafgkiYRVdFQwHwYDVR0j\nBBgwFoAUpWHIR+EHlZ+/ApT5iCYhsQM/CDYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHK6NGa3e9d+ubLj1ITtZiTt/fjLyc9o\nPZKOJSmIJqsqAiEA9B3xEQu0LjOFKJ+0j8BKrkAY7vbbsbbASGs35A2MEtQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASZPCFaVOtRLILQroGHcJeOyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGVlYTQwOC1iZDFlLTQyZmUtYTlmNi0yNGI0ODRmMzYwNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyAcFgc3YryFKLTjV3H5Dh/GO2dKMmriItti90z8yZVQJe\nB8HDlg9rhsglNktVK5NWlAVmIr52ZXi7as3Bd/l0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpWHIR+EHlZ+/ApT5iCYhsQM/\nCDYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAwveJCNMeykXRBurKdvXBpoTW/EGlD+2Sg8ccSzGcnsCIQDmT5Skc8QE\nXCaC8qPl200n/IW5AD/CZfKXtMCB7q6FyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISASUuyySPWS0oabo6B5x9sCvnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVjYmMyNTctMjQ2OS00NDVhLWFhNzAtOGNlMzNmMzg1ZjA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRlZmU1ZDYx\nMy0yZDAwLTRiYTktYjlhNS03MWRjZGZkNGMyZTIwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAAQj36jjJbpxTRROhxqkqfUUcCxEz9Y13gFsjJwWDkYw8XP/JKu9C/+S\nHEKe4PmGrnkanA15XJNPY2Kgw9ImDt3To3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSHCf3e\n4zVggSssEghp+CSJhFV0VDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgSEyFnRFsPFI6alZMJHHwzVbxovMHFAdadAtW\nFZswXBYCIQCJCq1mTAzRuaBsDQf21rHdm2GUo+U/vMnAI0qFI4tESw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6567", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6567` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISActtMxiouutRmRL8Ly0UeAjhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3ZjAwNTg5LTYzYzEtNDU0NS04MTJmLTRmYjZmMWE5ODAyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQyOGYxNjYtN2M5\nOC00Yzg5LWEzNmEtOThlODVhMDRlNjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYn5J4A3K3KQk5Hx2y31EXMlNidgdNx2+e26eiQS2KIw11+c8u0j5j3kbyQxn\n7ScCAqJgQaqK5r2lHiGyinf8kKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKyfUez1eN+tHv+MlKz7faAuc+f4wHwYDVR0j\nBBgwFoAURxzbKaUOYoSt4b5T0zZgsjGVMN8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDq47gBy1tm2qGsWmsoa38jWMuOB6X8d\nWtmUOdWkwQhgAiEAmXtQJb9p1ttBX4/T86NMQlCWTGPSzWKzmj12Ky/jmkQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWJfcfCiT3NQquIxT/vAXItUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2YwMDU4OS02M2MxLTQ1NDUtODEyZi00ZmI2ZjFhOTgwMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+r6YjDOIVzhbzmtAj4riZY2gacAXFW0MzPp6hhpnWSM13\nizA+oSQ++Q7sjdaUq0tepg0oupipfJkaH1iJNhyHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURxzbKaUOYoSt4b5T0zZgsjGV\nMN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJkgS96uBXYX3VDZcXOnicxx/vHef8AiYGVSfZUKnFNaAiArbJOQ+xHJ\nOO5mRAilG96w7XOJwoD6Mm1KsLeo/KXhAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAe/OLOt1W+v+wUfkVwIxaFYJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQyOGYxNjYtN2M5OC00Yzg5LWEzNmEtOThlODVhMDRlNjk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowYTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEYMBYGA1UEAxMPYmFkLmV4YW1wbGUuY29tMS0wKwYDVQQFEyRkODllM2U4\nYS01YTkxLTQ3NTYtOTk0Mi0zNDQzODhkODZiM2IwWTATBgcqhkjOPQIBBggqhkjO\nPQMBBwNCAATApFk26QWyVQi23Z+SiL75ff6fqUn0FMgmif9ESB2z4g205Ilv8BfV\nYzg2Iphz/82NX93yBAS7XR0XDeJGVx1Xo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYD\nVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQrJ9R7\nPV4360e/4yUrPt9oC5z5/jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEB\nAQEwCgYIKoZIzj0EAwIDSAAwRQIgVCHwxUXz2hrk1MndqgaOuexWg2MJdg3icx2f\n7wpeB30CIQC0IPzCuaLyKTp5gzjuJqByXAGQGhmSkax0PhW6JvzoWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6568", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6568` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYKvpjGFZD4o+2rADoZZ1l7YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhZjY0ZjU3LTNlNWEtNDc2Mi1hMGI3LWYyODI5OGU4ODEzNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBkMDEyNmMtMTA2\nZC00MDFiLWIwNDgtOTQzZGY0YTQyMzg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHNvekMr7yj9SjTbtYC7Wj+JcoC81QKD9Sef2Pf4EsXQvrVKXc0uOxytpYxRC\nLVU2DfYuw1MdQItjU5Pu/VNwFKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNc0XsrfV6i/9gWqXxix5I7sTkE0MB8GA1UdIwQY\nMBaAFFPAmjSD+iW/LT06ZW8OHn+2D/5fMAoGCCqGSM49BAMCA0gAMEUCIQC+eRDk\n4ov2mk78bko7SHVmpVTziMeErd/09u59qQDUKQIgcVCXPaj2SWsdvQcVrVhunZEh\npgGxd0W5ex//jUMvc9w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQrkVjVpibqnXoxXBy22GVFVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWY2NGY1Ny0zZTVhLTQ3NjItYTBiNy1mMjgyOThlODgxMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASa/1ZKlPZdpMeAh1dyh8/enDmvkQIK3s6VZ7YoEK+nt91A\nrFetnxSlqmlcxwiwaGW20jLHsDFi28iVXc4FBQ3Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU8CaNIP6Jb8tPTplbw4ef7YP\n/l8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMyNiOAYzxtSAqT8y/LOZagn5V38WIL73PBuUPLPijJuAiEAikA6Ea2J\nM112vPzPTaZLKIXswlWcWUCcyNQ6SPxAixo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISARS52PXntENS/Us7197OO/fdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBkMDEyNmMtMTA2ZC00MDFiLWIwNDgtOTQzZGY0YTQyMzg1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjc2YjlmMmEtZmU4ZS00MDhkLTlkZDMtM2Q5NmUwYjg5\nNGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZ+6jWzWEyMgV5tAapIN2CpOe\nDD9vdD+Sw4GTGSctvt8BPVZyPp4QYu3waHJ81umJ06uk9fmI4h9FMyuDAs9vVaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1zReyt9XqL/2BapfGLHkjuxOQTQwCgYIKoZIzj0E\nAwIDRwAwRAIgAlZ/m9meaIJ6kv++NPx7s4fUjs9M3KkwHIFh33we408CIAfcSrB/\n70xd+/pRZdUnmKgFxXUMl3qe/iNZZ6vkM4kj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6569", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6569` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAS5HgfdhintjJm/58buoGFUiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ZjVhMWY5LWNlNDgtNGMzYy04ZWE1LTdlYmNhZDkxMTI5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRhOGFmYjktNzhi\nOC00ZjM4LWEwYWMtZDc3NmExNDgwNmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy6QgSLDgh2zcIz8lgcQ2F8QEb/urk6OTmhDfMGmEUat96e7xoekgApb/O6fB\n5wjFs41ewB0CDvgNvRgjA9bV3qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHuZiYG84JcsSWWGvIuBmUvWdHYVMB8GA1UdIwQY\nMBaAFHZuVprOmFZX1lJKCoUfCzXvwDIgMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBj+p+IKGOzxnZ/0waooJ8BKlLKHn4BeL1j\nxrU7HIcTMwIgIf7wbJYRDbC9qlEKE+33XxFptFm7426TD+psyboHmnQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZpXL4Ot9Pgwqtte33+PckzfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWY1YTFmOS1jZTQ4LTRjM2MtOGVhNS03ZWJjYWQ5MTEyOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5gPa8/Fo06VmjG6auTAWbUZpEfssWFoTeep/08DzTdFym\nlDxNBhqYcgbVEv9JbcTV53RVoeIMOoujWxKKmiPYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdm5Wms6YVlfWUkoKhR8LNe/A\nMiAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGg7UB2zeszo37UuNliuBMWO+JmE78S879AQSNLRQMdMCIBlKqgWOnseQ\nLyinhtNW9HEEh317jCxjkmvoySJHcTAG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAbLFdlrjPQvF+B6oPEl3bfdRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRhOGFmYjktNzhiOC00ZjM4LWEwYWMtZDc3NmExNDgwNmQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQ0Yzg0NjItODQ1MS00ZWZkLTk0YjctOGY5ZTg0YmZk\nMTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjWXID4ERUEcKbdX0bs+By9dU\ncaGSsSDD4vI0JWfHAdSqr6v/eR7Hrw/cFPcKi2j1lfbY+z1utm4YL5kpq/n1saNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUe5mJgbzglyxJZYa8i4GZS9Z0dhUwCgYIKoZIzj0E\nAwIDSAAwRQIgUoEmGD6SrQglj+Wz8Prb5UEsMHm2rnwbEFnK5yV9TDQCIQDA3MOd\nJSgLgR0O+xxDaLxWVw1Mh8qrcV0wyE2T8g5q7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6570", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6570` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZAzuBN5hUcm4znAebBHb7amMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlNzc3NzlmLWNhNjUtNDg5MS1hMWRiLTAwNzEyZGQ5MTFhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNiMGQ4ZjAtYjRj\nMS00Y2RlLWI4NzEtNDg4OGQ1NzVlNTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs7qs9NAzAHEgaSpL2ZWXEKapvFMUlIaL9VgsM/iV0D2xBTHxv93/C5zsT79G\nFKYnAwYgXG4zC6Y+mqRwMJG7uKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPL0QLWwGW55me/vaSboWgaKCp0GMB8GA1UdIwQY\nMBaAFNqF97wNwIhTRoNAhMPdSHHes/N9MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEArpexe1qLiMvFXfDJumppxA4wAxnyoSKI\n3sgF8RPxnUACIHimB6WvNL06ZuqlW2OKWI3tfjQkPQJ3k1/ywwJMxCNk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaJBdAVQ2/J0oA6VuO2TXOPyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTc3Nzc5Zi1jYTY1LTQ4OTEtYTFkYi0wMDcxMmRkOTExYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVr62bzKoc0UZdYyS3e5oID+D7tOkpUvASDRpHxJxH/kpg\n0uIjZPFmf2rcUiAMEyIvHQ8AuXgSuI+UM675OVkBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2oX3vA3AiFNGg0CEw91Icd6z\n830wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbpDdWOGcEKpG6f1u2yq1IPt7CqxIb4yTLFsQ4PDV8AoCIQDzpur2oiiQ\nasCUkg5OZCPRqkDBFVfsFy1HdefuAnfUZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISARa9bjHfhIQm95G2pGqabFXBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNiMGQ4ZjAtYjRjMS00Y2RlLWI4NzEtNDg4OGQ1NzVlNTg1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTI5N2M0MmYtMGJiOS00NWE4LWFlNDgtNGE1OWJkMGY4\nNDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb0XZKvKj5pMQ3Mz08ud4T5yE\nQba2vAT70pJV23onGXT5pC1AxeCyXlbFzFlTOqgeaJKk5RDaGtAT0U8+FX1xBaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8vRAtbAZbnmZ7+9pJuhaBooKnQYwCgYIKoZIzj0E\nAwIDRwAwRAIgWyIPEVg/eZXPvcN97CYvv/4COVSezhOH+Pcjg4Sqv5ICIF7ZRNTG\nKSk9cmEEU+ApFO2Ul56UJb4T6gniEdXE0eSd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6571", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6571` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAThdfWwf/GL1Ssj6yzMN95CRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkZWFjNmUzLThlNGEtNGUzNC1iZjkyLTQ0YzEyMzBjZGJhMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdjYTZmNGItYTky\nYS00ZjM2LTg0ZTAtNjJkMTE3ODZhZWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEANZ7tLiPt2N0FDB9XBthNqBXpRbIF0JrqHsFFKqhXr97/YAfw2oQlXoeyHNx\nyx5Ji4mz3jZjUWue0J5aRIzYcKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTiVP9fcgHQiMr8OrxXE7Y0k+okMzAfBgNVHSME\nGDAWgBS76QixuQusv/Tr7kn4zyL7E1v4oDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA/bprdi8aXFPPXNOKimWS3Tf2EAdGdJ\ndz4tJ3Ak0VDWAiEA8+4xyboP2GO9+yNwGOC9RMHn3hjypfWWE5AeUo6Krwg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcU4QeRlftLHqUx2M2rDWvW7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGVhYzZlMy04ZTRhLTRlMzQtYmY5Mi00NGMxMjMwY2RiYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6wmvN0OlYw23egRI5ncixE+99DHzNz+9GrAM9UQaBVwH7\nzrXvZUCaNhe+TuMS2dOyGkj9bZym01IPoCDM7pnno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+kIsbkLrL/06+5J+M8i+xNb\n+KAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcI+jZn5UQj9b9LbK+NCTqWrLws81Q+o4EJ/k1XE7JrsCIQDpmLNGnPxz\ncwXWmZmtjKUEoTDy1Gz0lMqbo/ROHIRxKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAaMxwq35LGUPpHjGuzyTEWwRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdjYTZmNGItYTkyYS00ZjM2LTg0ZTAtNjJkMTE3ODZhZWI3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2I3ODEwM2UtYTUyMi00MDUwLWFkYTgtNmEzN2VjMGYx\nNWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZDO14BqtS+POmolEdythmium\nAG8YbSvqbvvPINh+kPQTV6B2JRiiLXiI44eAKg/iN4PR/oGjz9dOgNGvjnT9u6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4lT/X3IB0IjK/Dq8VxO2NJPqJDMwCgYIKoZIzj0E\nAwIDSAAwRQIgF2Pl2gCRdDjA+/Jf+L/K5KZmI8stqNdMmB5BPLvLLucCIQCCAhGl\nQG3M0gab94JMVZtOpiNKwgJCtqxJ+THHWbkq4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6572", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6572` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAbiuZdYYrmaV4pM4KNfl26PnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViY2Q0NzliLTkxMmYtNGU0MS1hNzQ2LWNmYWE2YTVkZmIyOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZlZjkwNGMtNzNm\nNC00YjUxLThkZTUtZDNiMWY5ZjRlM2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE740FgxewQf03s/W+FlG9npeH1aHHG/pXbgRNFBzXk0QyyteZZwFwo0pOJWVN\nG80sRajGaB3kEsPvAN05o84PEKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsFGXEA1Kf1BjXcq3974uJ20jp6IwHwYDVR0j\nBBgwFoAUlFgkzUVtARwPw6C2fgP6tApf/z0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAnBmXMWtL3d3T5\n7CQQ0zTtmETylaD2C3n50/Tdr9HcLQIgWRydT39FCsqdUsG/ggDM05IvooLSV07G\nVtYyA2wG3yQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWrnS1tAXhX5yVYF/W1F3jq7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmNkNDc5Yi05MTJmLTRlNDEtYTc0Ni1jZmFhNmE1ZGZiMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzi1cX4McE6um53a6thvI0OtSJtsUhLA3mZb0Iy7HNbpT9\nO1cAyE9FU6nhC+xP7t59INPS37BZdXJQRoKclpKYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlFgkzUVtARwPw6C2fgP6tApf\n/z0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG1JrRFjIC+LouoNJiLevy7pCFl3/dhQ3g33cj8319HYCID81AdbZugFb\nA2EUaMzu2FkDny160P79BrVoioZiizSE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATgaX3wskxeEc7gp+0DatWyeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZlZjkwNGMtNzNmNC00YjUxLThkZTUtZDNiMWY5ZjRlM2NhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQ5YzFjOWYtZjIyMS00OTNhLTljMTktZmQwZjBjNjQw\nMzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDW3hWD91xUXv9kCIFuI0yolY\nPfG4i0WsA21+R/VFruF+tVWj9NbIWDQi6/wCzgiWYOzDBCPNZY826GDakKFIWqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsFGXEA1Kf1BjXcq3974uJ20jp6IwCgYIKoZIzj0E\nAwIDSAAwRQIhALuDlTuLQPrhm7gz78WVBFFe15P0fhMwxusPylwj5cExAiB0HqXw\nPfygerGa3jc/lyBwjr/dNMlkFmNzX7x6eMnGyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6573", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6573` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbJcRjYZ+EvwS4AG5vsz6fzmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlMTBkMjUxLTc2YTYtNGVhNC05NTlhLTJkYTFmNjcwZjM2YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjcxZmQ1MmUtYjU2\nYi00NGMxLWE5OWUtY2Q2ODQ3YjhiMDc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErFuqOaAE0XJcJ4brbCidkIYoHHHBZvWRBUQ5mvCU+NjzRXD/f+dSjLaKcqXl\naei3PZM3szIpMR1F4Fz+IO4pqaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO2RPLM6yazI1d7+g5+wiO4RzUSYwHwYDVR0j\nBBgwFoAU2IkTstz67EztTof9NM/le8s6t5IwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA0TbWCbAHABqa\n2nAbFhS4Y3EE3TqBlMqOk2Exb0QPCiYCIBk8YiH1SBF0AHfPdQnRYK9GiSaJLR1w\nrCTcQEbJfYnr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfoT/c89/zMEfggYppw5oSLRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTEwZDI1MS03NmE2LTRlYTQtOTU5YS0yZGExZjY3MGYzNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKiKoF3i9CilDBVw6MYzoPRyB9KEy4QqmXGHlearAYSyaD\noqW9QbMA47xGImgvejXiNBgsC2bYS/e6sXl0cajPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2IkTstz67EztTof9NM/le8s6\nt5IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJdQ5nVZsDlBD+t8eXt7xOSjpZvhD3x/ylRFhQqacAIZAiBrPWzT2eDt\nKSL0UTl5JA1KJlt5cNXY0CFA1snHpOsX5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAd5qD3wFkxPA/Z5qR11//k5cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjcxZmQ1MmUtYjU2Yi00NGMxLWE5OWUtY2Q2ODQ3YjhiMDc2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWE3MzUyYzQtNGFlNC00ZDM2LWFkZmEtNTc1NGY1NDJj\nMmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH5IJHhnXzsLcSI4zDK09rGcW\noqEyRy5u9pXhl1W2f6STT5WpvD+x8ZOwUk2g7bvD71REWzO/cfV4V9CTooQgwaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO2RPLM6yazI1d7+g5+wiO4RzUSYwCgYIKoZIzj0E\nAwIDSAAwRQIgfsTiYmm+9EhodBTVRJX2bLaV/a4u6tni/0sKUsKprW4CIQDxFyqW\nCgPN/bpDwA/YEuSyCPyrsIG0sQ0DMKwqW+yvhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6574", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6574` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAZg052jRupabrGkaLk7/mbJjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzZGZlMGMxLWVkMWUtNDdiMi1iODZlLTI0ZDAxM2I0MDgyNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTExYzEzYTYtZTA1\nNy00YmRhLWFlZmUtM2JkMjExMTdmZWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjDSLVT40Rs3Ve0bA4eJm5A15p0Y+AcSVCK+B5dicRaSro2iEYu7vEKlcoJ41\n7kri3qevcaFikhM6nLqo6D4WDKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ywdWgBLHShqZbHUakMnLP1M6GMwHwYDVR0j\nBBgwFoAU14LNmFEu7Svsh+jMIF2e2GeK5lYwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAuCbgVXy5no1U621PSJj1/\n5S7xIARkZEA+67NbjUoGmwIgX5e0YwsKC8WD9ZY1EusZt2Rk34p0yyHoa4iL51eq\nQfY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYbcX8JAI1wVE5T4PtrzQx4bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2RmZTBjMS1lZDFlLTQ3YjItYjg2ZS0yNGQwMTNiNDA4MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATueq2dDLHJcRZScDdeM6bxRR2jiWeJPSJqlER8zPL9+m6O\n1pKRGUUtsT63C1QXpxnUE4kPegE8Ey8VkyEpfRCMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU14LNmFEu7Svsh+jMIF2e2GeK\n5lYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRujoVc+H3MoxOE2EXyzsdeJ21QC/tuWk+V28RCZB70ICIQCVQHnWKv+I\neCnilEdPKViEg0Ez/9/APb5lpk5Z+YJ0kA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAY3I7H32p7NY7XFEURf04dO/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTExYzEzYTYtZTA1Ny00YmRhLWFlZmUtM2JkMjExMTdmZWUwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODA0MGUwNDktM2VhMy00MTQyLThiMDgtZGVkNTBlY2Q3\nNTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVtzGkGSzkO+pgFX07o2ikKf3\nWqA5RTRgPNMTbT3vcRTKT60EKQoZQ8lQl3R57iCFPPBz286UZ2p5GPOyWWNAXaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4ywdWgBLHShqZbHUakMnLP1M6GMwCgYIKoZIzj0E\nAwIDRwAwRAIgffO1wlNBdLWcKmlbIGV0pZw7TbujGpWYf+grai5UrW0CIH83O5tq\nJ+Uc+fKKlb+14VExZkgNPkIltQl0oS+rtenl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6575", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6575` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAb0jKbpYrhORi4C+tKYT9xkuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmZWRkZmFiLTFjNDItNDA4My1hNzA4LWJmMjQxNWQ5ZDkyZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTVkY2JiOGEtYjgx\nYy00OGVmLTg5NWEtOGJmNmUxMTUyYTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjl538mX8S1d1WdNhA1qJuLMx5ILSIKUWFZSXEGuIe4L9+DUaQloApVQ/Ngz9\n5wl0awZ3zvEbwo8Q/rXz1wLbj6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGOcpKGgfUgtnaND68e8Kz+T5ff0wHwYDVR0j\nBBgwFoAUPVtEI8ZQPUwIn0+3GPYFBd8zfNYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAob1C\nlNkMK3CMoorDIVW861L0uQqVVZqvawxErncYHCUCIQC/R2y8pk9aqHRt02ZbfZw6\nRddnfKbnIuoJ/2Jvcgj84g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbNE2/8u9mPvePNS7tphCMG0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmVkZGZhYi0xYzQyLTQwODMtYTcwOC1iZjI0MTVkOWQ5MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEQHQlF9DIACbpFGZLXENcBabrqpKuPXq/sSOdp0Nxq9x4\nQ4yhYLuJY+FqPE0nStMdA7RHiIvQUfyaBUUPPvkqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPVtEI8ZQPUwIn0+3GPYFBd8z\nfNYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWaYeWMYPeaI6D1AZ0bwWvcoozaXrkhtimK6aIEe6fK8CIBy7cECOXvk0\ncZDvFGhbGFwTJ+mI/wGo44/AD1Xb37In\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAbDhVtFr9/9yK39x0/g/GLJTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTVkY2JiOGEtYjgxYy00OGVmLTg5NWEtOGJmNmUxMTUyYTljMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQ0NjM2YjgtMTJjZS00NGQ1LTliMjUtNTViMmMxMmNi\nYTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhBkjjSPqTeCfC4d/L5l6i0S7\nHU8jlV0sasdZ4SZFbjz7EKr9vy1MKNGsqBhacoI3IWt1wDPLtA6+xkd6p20er6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGOcpKGgfUgtnaND68e8Kz+T5ff0wCgYIKoZIzj0E\nAwIDSQAwRgIhAK++SGnrb5ab4s49z327k5sxtYN2HWx1cnlSVBBmH6yYAiEAyayC\nbwnWv052Ic1nD2BE0pR+aRnmtsknv2iCW1887fc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6576", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6576` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAWE/QcSKRUA3c9z0o81h/1kVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhYzdiNmZiLWM1YWYtNDhmOC1hMTBlLWNjMTNhM2RjNzI0ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2JiZjc1NmUtYjQw\nYy00ZDVmLWFkZDEtMzgzNDI3ZmIxZDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEifjhV3dr0UbauP+DRJLSxIpcSe7BV+DeZNXGyolzdVHiKG49a8dvC68DMzNA\nko1kAlX2ozH7pAE4ddGfavti8aOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOcwfGBYnJlgZf8nU6k3pst2fVoUwHwYDVR0j\nBBgwFoAU4bg+hx9r3IGxINQQl0vPriQt8qswLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBPpo/A\nrGWmg1/H+aCRYiWarA/XU7h9D8SQdn9JFQKXNgIgWrTmYFdXrOOpmwVo7eSADyxm\n/5u1hxbplDeyz8fYdIY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaXZ384HC8AUChG0n6udBm8cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWM3YjZmYi1jNWFmLTQ4ZjgtYTEwZS1jYzEzYTNkYzcyNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJ1jz6cyg2Eri/dzUHWTIQYsXC/L2ZUJClHw0Q74P5TNEo\n9G4WNKxJXqGpgwk3u7xOFBzanHPOR20EmJjI1lFBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4bg+hx9r3IGxINQQl0vPriQt\n8qswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP2nyuGn8cT/SIwNRm6KeCJ9CyfAXHiRoovlPCcxrOOrAiEAsDg2lYqw\nPggVeFaAJYZmLfBpysJpIUXWtRC2xGdlKoo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAX10u0OdmG+FKmhV5uV/0wPeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2JiZjc1NmUtYjQwYy00ZDVmLWFkZDEtMzgzNDI3ZmIxZDg0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFkYjE2ODktYjE5Ni00YTVlLTk1YmItNTQ5NjZiYjUy\nYmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcixIzpvJO2UfaHekHa16WSOn\nW+jGJar9fqpbCs5I3rBu1c7I5wgUuSO3DWPml95c/y//s5SK1gk7gTbUGajva6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOcwfGBYnJlgZf8nU6k3pst2fVoUwCgYIKoZIzj0E\nAwIDSAAwRQIhAIoAsX4OVpGRojK/HXs/ddcUHrQN7you6j1SzTiULjPYAiBxs72f\nh73T1dsMIypSU5A9ju3lxycKapV5CIKeAp4Lug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6577", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6577` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZiLIYFUt02fZo2V5kHWc57QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3NDQ3M2Q2LWE0ZWUtNGE0Yy1hNDhjLWIzMWQ3MDg1MWJmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVkNDRlY2QtZWNj\nNS00OWYxLTk3ZTYtNGJjZDhjNzQ5ZjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfy7B5tYcvL2J0/3F0EaRsASso2xwLs3LCItDgsFM3S4uKE8u2vPp5oPuT++g\nUoAyU4sQUYw973pL9zI8Pm+GiKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFB5bHmik79sTF8yaOjjx5kz04QGeMB8GA1UdIwQY\nMBaAFAW/RBkUbXZr6QEblFUikRCnFHLFMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA+SQADgSL3VcC1sf9Gs5pPRpwZmy3b9+m\nMwwNwRSHMKsCICxkpM9etZtn7siYRt9CJzWo2rpAOEQD6JJRjEpOaDQz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfFo5FAfPITF71LSFHXKFYQTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzQ0NzNkNi1hNGVlLTRhNGMtYTQ4Yy1iMzFkNzA4NTFiZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQf5MYTLaSqp6lyzCvinubpEo4v0Da1XsCQichgZZRm+LwS\nJGsjgQuljqzJld07Si/tIc6ZEGNu8POo9z9hAYPco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBb9EGRRtdmvpARuUVSKREKcU\ncsUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANL0e3iDAyEShpuYAkpRymJlbVRdj1+vFuLihFSsmcJNAiBEQ6Jc6qOf\nT44JMFP02N739U+sHHnKTAc75GiIpFCXtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAemVZ0f6IB/da14SUavbeB00MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVkNDRlY2QtZWNjNS00OWYxLTk3ZTYtNGJjZDhjNzQ5ZjVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmQzNjJhZDctYjA0NC00ZDc0LWIwYTItMzEyYjRiNThm\nOWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVnijwtPYmZqsOyb0oiJjypUS\nMJufTSiUEDCEUg6kah17veg963PC7MOqcRqzuTXsiR1g+KoU+7sZ+CHQiwXheqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHlseaKTv2xMXzJo6OPHmTPThAZ4wCgYIKoZIzj0E\nAwIDRwAwRAIgI8BdhEKBTwW3LxDXh1ozsii/OfzVTHCNTNxr5oE1O8YCIFU0QNDP\nXVU1GUSJDDpceQtcziRDbiUYXg02eIC72ojM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6578", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6578` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAfTmF5ooKB2LmN2hN6n6iGrfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3OGM1MGE5LTJmNzQtNDYzYy05OWU1LTI3ZmQ4M2QwYjJmYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTcxNjVlZmUtOGI1\nNC00Y2EyLTk2MjgtOWUxYjY3ZDQwNzVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWaW2lgTXFddK/++dhzsRYlafUCWw3/Eqd0qobCY1S9lKb3n6nAwn2nFzJr01\n1enJaFThyt4Wf05RFCZzybHLf6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKshJfdD3l6Gl1cyFgH9X0LSkTycwHwYDVR0j\nBBgwFoAUivrjmm8Q9hOPxj5Lx1gQrDWKqYAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgfBovHAReXJ/r\nmz5q+G9XEMW4LB3kW7M8OVP/TIuHTBgCIA9r4Qu03vuanK2IVqBgiuMlq2eba9/d\nXjksqlDvYA7a\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT6IbaRcxTV1SlaZwuwnMTu3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzhjNTBhOS0yZjc0LTQ2M2MtOTllNS0yN2ZkODNkMGIyZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0Tj0N6dWIqTJL5HMiXTMiNJ8aNirYnJF6H2imk4PqEDUh\n2oQ5Fc0wOkzzPjWxcXema0c85Cl/4n4boD5mXcP9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUivrjmm8Q9hOPxj5Lx1gQrDWK\nqYAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIzXcSWRBkEmdx1u9YK3N5kcVQHs7N07yWqMCvURWbDrAiBgbZalt26Q\nn68P+nMB0sz3W4I4iQY2xkWOOTDEziZRHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAVihjJUEckuKvGW0j5MQ7y8eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTcxNjVlZmUtOGI1NC00Y2EyLTk2MjgtOWUxYjY3ZDQwNzVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzYwMTQwMzQtNzg1OC00ZmQ1LWFjMTctOWUwZWYxZTc3\nZTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAcySb1wongynjg866CCbaYiR\nEXmwN7xWwRdDbi2ToY58cZ7Pf9h75jYh2yOqudOATgcXXHlvaRn8NMJxkFF7yaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKshJfdD3l6Gl1cyFgH9X0LSkTycwCgYIKoZIzj0E\nAwIDSAAwRQIhAIhQvdP15Al/NK7YRxcriou5lPkjhOiGDLF9o5B6m8HLAiARoCPv\nWNfW/qnNdHQGg5wFQbHjsqAni+niczcpeHMH3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6579", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6579` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAW/N6skbwT01jZWI/Z1uje1nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZWI1MTJiLTU2NDMtNGY0NC1hYmMzLWFjZmY1ZDJjMjdkNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZlOTdhMzYtOGMx\nMy00NmY3LWJkNjQtZDUzNWVlZDI1NGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZp7rGhgFDpTaDttclvU6/fR+OveO8NIAyDpzfH96WDteOtmfKp30UQhdNGCR\nyTVKcz2u2y5vekKR+ScBCnqYCKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9j41LNTB8l4MmgAVdoIgejvC/DQwHwYDVR0j\nBBgwFoAUAOEaeUJT7ELe+JTHQvHV8o1ANJ8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPlR49Cy44gz\nDs6zLCo02ir4ri/mktQXLPpK26b0g41FAiAUG8GAdm1KGyu2675+9IQhw5Fd+AaW\nyQgrvJWh71w6TA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAatGqWGn00xN3sy5vQh+DiOPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2ViNTEyYi01NjQzLTRmNDQtYWJjMy1hY2ZmNWQyYzI3ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrU0wUnTk595C+4MilbzPF0ghSFSHUAjrLf0Of52TVX7BM\nR4oq2sNEMHWC2INayL8ierbbqG8G/PsuvdFpAof0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAOEaeUJT7ELe+JTHQvHV8o1A\nNJ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM8tK+6U2LKGPtdtQpSXgfjgCEPACdzhYLR0Z8J7ieY+AiEAroRPkSgN\n84DqzjJVS1qTaos1NJsvFcvcRIWB3d9zcQE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAZCegf+oTwQSfeJmujVtsn/eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZlOTdhMzYtOGMxMy00NmY3LWJkNjQtZDUzNWVlZDI1NGYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjMxZmYwNTgtMmMwMi00NGY1LTkyNDEtMGEwMzMxMjM5\nMTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELi/aLvAXweXoPdrdwEB6Jqmg\n5F9KQIBfhAh/L+DqQsjak7qXum0Ac4xowd+L4MoCLoyEjTCIVMsY5j9Aol090KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9j41LNTB8l4MmgAVdoIgejvC/DQwCgYIKoZIzj0E\nAwIDRwAwRAIgf+9l8J3V2DACNYj4VsYfzS02BRWjjOb41YSeCnrwsCoCIE+g+8+s\nOPsq5fS2hq/xiv7Q+KltZuQwsMvPHIwLsL+5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6580", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6580` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAXB/XmKqGLGWjCO6La0Gp59YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyNTUyYjhmLWNlYmItNGExNS1hNGE0LWMwN2E4M2YzMTE4YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIxOWQ1Y2YtNTdj\nMi00MzJhLWE5MGMtZmJkNzc5ODYyMjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEngSX2b+uMvAxwaOR2dGpLBiYN8MaSyk9Uryyv2xjXdm4yCMfhLbDrxZ4ksu6\nXYDdbkG5u8qj+8Fp28RpdnpVfqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjKyy9CpNbZDNAnrsLvmRH1Z2P+8wHwYDVR0j\nBBgwFoAU2/IOvnnXAfiTdWmawXcixtwRR9cwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCFB/VyF8YO\nohx+hlU5zSgDU6+/1enY4J7inbO5EA0u2AIhAMnlu1kMtbIax5NsxaCs2Djx4+2O\nDOVXCKcB96Su10qV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU1qUgtN4if0Th6fhLBp0YvSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjU1MmI4Zi1jZWJiLTRhMTUtYTRhNC1jMDdhODNmMzExOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZb+3eYUIbctSv6RxAzQweZHQXmA0z1VXrp7zhJhyTv4vG\nHTAHlwWb/171TIUvshXMfcENsnz9fxQZkuol0oqOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2/IOvnnXAfiTdWmawXcixtwR\nR9cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC8O0HzBKbLteZJ9RxjP6V8N4QEyfOW6w8DPqDMRYv4oCIQCH6BQvlhxB\nUQc6MjSHUvrcLdxXI23Q259Yd8o+xt744w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISARtA0nlky9Y5MVqaDwhS94HEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIxOWQ1Y2YtNTdjMi00MzJhLWE5MGMtZmJkNzc5ODYyMjI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTU1NjcwYTktM2I3OC00ZGQ3LTlmZWItN2Y1Mzc5Yjdh\nZDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFJ7Gc8dWLG1O5lYtzAjke7wN\nVOY0pgAxCIspa2B3dSLHIzRutiYIffr5UM7vAJmIJ/yllQMqp5BwvbOP+DlfY6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjKyy9CpNbZDNAnrsLvmRH1Z2P+8wCgYIKoZIzj0E\nAwIDSAAwRQIgGYdvB95eN+CwbgsIu1cxIjanzMNRXpooESc6LsCprL8CIQCodFvH\nLx0M3vjiiAHTtzrdLm4DVUdsJytUD6J6kmjR/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6581", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6581` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWsOkjotX/TmXnJWSFnAMA40MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4MTA4OTVhLWVkZWMtNGJjOS1iYjBlLTRmMmZmZTE2NTA4OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI5YjI3NmYtOGM2\nYy00OWJhLTkyZTYtNzAwYTQwN2Q0OTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPj7KbOvbI2auAIGE5husQk+dKVgEEfWUCLB5OxbqxFs7EksgSUa48uJngGX3\nlfRm7hLjZ3HuPROFMaS3LC+MJ6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeoaU4mj65CvxG5sFZgnT6ZoPj1MwHwYDVR0j\nBBgwFoAU1H0Fm5tyssNwQm8uIyI1iB8ehr8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICmp49eNeFQsqXDPNC6zSIDWU0YgWUFJUHYZX/7I4ahbAiBo1Dvfhky+h8yP\nrijGQvlnwDr36A86NetlaXHf6Hlurw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV/GzyjivG9anxl52U/rYciNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODEwODk1YS1lZGVjLTRiYzktYmIwZS00ZjJmZmUxNjUwODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkgECFVfC+LokMgpZozqfweBxRImljXh9jACbWnouueKFs\nftwPEf1fle/uh3Rof536yETS6cSQQGP/Bkc/LYhPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1H0Fm5tyssNwQm8uIyI1iB8e\nhr8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKC8d3FQVL2ylg3SbOsmZU7kcf9OmbqCZEIptbdrWpNkAiAr1TLMpU5p\nces0DTm+tkjPBQONheVJ68+s9DDxqLtDUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAeBDEZLfTMYCHCBQWFxq5cjEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI5YjI3NmYtOGM2Yy00OWJhLTkyZTYtNzAwYTQwN2Q0OTlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTBlNGYzYTctM2ViOS00NmYxLWFlNmUtNjRiYmViZjc4\nZTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjq6IN24uz66xZIV2KEdlhsR1\nwBBWmxBSUpEyO3VxhtgL0299qrHVQkqOAxdyb2E4IOrJP64YCkO03YrCOvi416NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeoaU4mj65CvxG5sFZgnT6ZoPj1MwCgYIKoZIzj0E\nAwIDSQAwRgIhAOPNjoaS8fdQk5/J25nRvPU5ObQEUhmBL7aShTuBH1MRAiEAlQ16\nKr/07biIMFKrktwrAjGYe3M02URBAUdQ2cUwKhw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6582", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6582` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASgDBs1i+NI2QQoXCcsfYJsrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwNDdiZGJmLTYxNDMtNDBlMC05MTIyLTViMjAyNjMwNjMyMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODNmZTA1NTUtNTQ3\nMC00ZDkyLTgzZGQtYzk1NDAxMGUyNTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4LnCGr/ID+uFXbBtOpZrvdInYB9RdJluHKXkYG2nhzMlUYjKAW1MNC9zHrNX\nnnCtH+NFccdxVS8vOV9q2x0hYqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp2oLPKlnuYXU6ef5mHJVdkdVkzgwHwYDVR0j\nBBgwFoAUpfdnlGLZGikCsXR586U0kRIq4IowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCHzVlFYFVjgwlpNjNCxKS1BcmGhmfWPazWV9/brjHOSwCIQDv//53T9s3CDYv\nP1zo56s/JEdcSFOskS2j7fMoY8ra5w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARa6XiFPoIfO+lslvg2Sq36HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDQ3YmRiZi02MTQzLTQwZTAtOTEyMi01YjIwMjYzMDYzMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ98J/cPYBr6uiZkzfpGmDmHwWVUnkeI+MrGvsH3zNjolcE\nj2bN1RfW0IRwkkhjQLQ03Pi6zkmvUWwTVpv5aRZqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpfdnlGLZGikCsXR586U0kRIq\n4IowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc37UOT/5I/pKKlJBjtGFUBTn0DPA6ty8Pli7OmVBZ+wCIQDop4rkOqQ0\nzMsDRjLXZr6nJQK98K4BCHScq5MP42QYfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAbEqKuu+eA+cIH1OGQgT62fwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODNmZTA1NTUtNTQ3MC00ZDkyLTgzZGQtYzk1NDAxMGUyNTgzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjg5YjMwNTItMTNmYy00YmYyLTkwOWQtODAwOThkZDg3\nYzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP/y1aiRB2Xr1z504b8AUd/Jr\nlbMgSKSxvl1tVkFrFIv39qoLpipXe4mSjZB9omG0rhoGCgJ4/X2tp98iN5c3k6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUp2oLPKlnuYXU6ef5mHJVdkdVkzgwCgYIKoZIzj0E\nAwIDSQAwRgIhANhwTxwN9GNi9/pw8yIdqarIFj5y0RfRSqrFnByUJoJoAiEAqMAH\nwMjdSu91uDYami0tSG6un2ZdWAActxmepLrHnPA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6583", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6583` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAa9fLNwDuDv3ejJGRDgfVtCtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwMDQwOWQyLTZmODAtNGViNy1hNGVhLTZjYWE5YTgzM2VkYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzcwM2NmMzgtNzUy\nYy00MzlmLWJiYTgtZTZjYzkzMmQ0MmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmeCLbyqCrQ15IXVAtlZfCWXP25AXkVr3pO3yKO3jSE3feJsO9HXSCQwkvfvU\nF+QPwB1ytiNwqc5l6FUeNIbScqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrYqj9epJUiym/vvCBhjHFCqMFNcwHwYDVR0j\nBBgwFoAUKgdXjNTWPZOnoEF9P7DQ+sPurlowLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDA\neXFzriX5SnLG5Xrb9UWV3pqvCSD7fB5kLeIXFDsxGwIgSq9sdCRQSWp37wco8qqf\n2XRKlDAuTNNBRnfBk5VRK20=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQekDAeaKY+YzK5imKKZD8vyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDA0MDlkMi02ZjgwLTRlYjctYTRlYS02Y2FhOWE4MzNlZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9bWo29PiIpiBTSyDOz4+WpN/dz8/QIA4y33IqKfKUCGf9\nHSjWW0uqfkRxnkw1P9AUpoPRRoVDq6i1ureoimVlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKgdXjNTWPZOnoEF9P7DQ+sPu\nrlowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV9kg0t0g02yQc4qaCCcK9t3lRgOEz+EN6nQd0F+auWoCICCp6xOUdw0Q\nIryjKKmbSivQRWkGqHGasa0IfRIxfhq0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAVOLSwogeqyy+Q65PFdmf2euMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzcwM2NmMzgtNzUyYy00MzlmLWJiYTgtZTZjYzkzMmQ0MmRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODNkNTQ3YmEtYTYzZC00ZTA4LWFhZTktZmQzMGE4OGUx\nY2RjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbVC+IpP8vo1B9iaBmSNfMIrT\nYvl5oqWVCcsM9bhbmtpqLjb7AIlJEweLYhzSDK4+Xkr/Y2TYfZ2+rCYF3h6slqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrYqj9epJUiym/vvCBhjHFCqMFNcwCgYIKoZIzj0E\nAwIDSQAwRgIhAMhw//yI8z4PAH3tbf06hu8tMiBnwuvgO4XMVE+ydcXhAiEAuOZd\nYx69MJrd8rlwcPDHeUze/LOAawgvC9Mrm8EmIFE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6584", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6584` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAUQiZJ1YpdxYuCIl/p0xWZtzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZmE1NDIzLWQyNmYtNGI0OS05Y2RhLWY3OTdlMGNmMjE5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVlMzExMzctNjg5\nOS00NWVjLWI3YmYtMmEwMzFmYTY5NzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEivZxsyuxazZYSkEbzQxgEn9AG/GJK0PO0jCOLPmTUF+JP4WfciVVYpIvj1pW\nIBI2lEMFJnou6zVPXJi4nmJXraOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT3YNZJCv+Ldbh3GkU5B32Dz1fLEwHwYDVR0j\nBBgwFoAUVrsBKy38TlXg9neovmVtn4lknpUwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCXpSH+6i6UweYRFkq+33dTeREkDnw6DroMUluCM+AbdAIhALYe\n95w4C7CM+UfGhqpPJcpNHsTLgnOr8Ff8jKk0y6nV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASguqLV33w6Xc1j4kZRV2W4EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWZhNTQyMy1kMjZmLTRiNDktOWNkYS1mNzk3ZTBjZjIxOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARp3HeE4LZJWyXtn2Fl/QDp0ZfDo/DZwBvkIR+ilrMVHdCn\nRHSLiI7tdCqZqEzwQ34zXddAec/afkhgXAW6vTl/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVrsBKy38TlXg9neovmVtn4lk\nnpUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP6g98fFKaaheyOt3oDnfQ3vY9V+M13OAA1ugjRJjhuYAiBJ2fKii3zf\n3M4RQdF1FXNkW4JPMpp1Vy4cQtZSxhoXVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAZm2wyAbFeNki7LK9LWntkXbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVlMzExMzctNjg5OS00NWVjLWI3YmYtMmEwMzFmYTY5NzEzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzViNmMyNjAtNDVlZC00Yjc2LTlmMjItODAzY2ExMzE2\nYzRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP3auDERc87oKQvfY8rJP3vEB\nr02bVeqJ5Uf+Wf1obDRgU635LJyZo60/4wkpWjOEfSxxVGWhqXJkaWdVdxqTM6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT3YNZJCv+Ldbh3GkU5B32Dz1fLEwCgYIKoZIzj0E\nAwIDRwAwRAIgarrXKzw9gZa/JpPWcfjNOPldAOv4sBnGFosXtJvgycMCIEb4Fbxd\ncieIzHs6qFNLvoew6Sut4qGS5LAYlnquF2YC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6585", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6585` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAd2+rS115xpcnPM8lRrFUQ1aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhOGMzMGVhLWM0ZGYtNGI3Zi05ZTI3LWYxNjg2MThhZGJkMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWU4OGQ4ZjAtOGJm\nOC00ZmM3LWI0NjUtNTRjYzkwZTdiNTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWCTmACHldaAdt130NP7NBIGyg2fTg4KDSXkqiRUUKLoMITtWm++Px99wTtuY\nbu4Tglu43CN0xZmNzWMWCSYS3KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMTR926Via/RPPblFm5PIOgxR4s4wHwYDVR0j\nBBgwFoAUNuWOQJQOTPIIwxRC1kjzHGJKhAAwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIH7YdSJIGvHOI6+mQ3h2hge19J6kwTm32jq4BUwkk9kmAiEAu7aC\ngxpPMNi8dJOeBiqWWXnO8+OsKA/WMslmfXfYXQI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcw1oFNEgKVO1vSO5lnnABmFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYThjMzBlYS1jNGRmLTRiN2YtOWUyNy1mMTY4NjE4YWRiZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQB61n3+sKuCF3gpoVrTMpfh7hqbOTsFxDRixhcYzBd2QWF\nv5uj35iHp8hCl3lUtmrNNCklRUgKBd7mY4beovKxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNuWOQJQOTPIIwxRC1kjzHGJK\nhAAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAntU+4xA5a81ri6xMV2LIsFvJyff7bcRT0uyanXF70QCICrkCvHf5lP2\nxKcqnHnLFx7gKoZXXwg9VtqljL2ca4Z5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAY+++crvhYX9KlQ8io7EALFlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWU4OGQ4ZjAtOGJmOC00ZmM3LWI0NjUtNTRjYzkwZTdiNTNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTI5Njk5MGItNGU4Ny00YTk5LThhZGUtYmQ5N2IzMTYw\nYzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECwD08mLeKWJU/76zAwrk4XZP\nlv1Bw+5v5t2kOIZmLxW4RYHkNZmk1KT/0vma1JmI/yMNoGejds0fM1InQjyQo6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMTR926Via/RPPblFm5PIOgxR4s4wCgYIKoZIzj0E\nAwIDSAAwRQIhAPjs8K/ecHfdlUBfDG1dbJCcRz/VFIz7tuxSkgdQVoXgAiAnKXsz\nQjPHpUZeyjTumfX1Vb3mfJP8VrHESAXCC+jNfg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6586", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6586` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAfUXNMIDgjs+tlHUVALM/EBMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjNjVjZDY1LTIyMTUtNGM3My1hYThkLWEzMzBiYTIyMjcyYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQyODAwNmYtZmM2\nMi00MzE4LThjNzYtNmIyMjZkYmY1Zjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPBSYuMt12Nhd1IpGhlrcHFjaB/W+RwxW/Eult8KAOSZT0t3EL8tboTsPUCH4\nHW2mu9elBOs0qbXbqEEA4QxxX6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDFTMRDkKXhBsXaPxL7AlwiMFA5YMB8GA1UdIwQY\nMBaAFFqmKorXHyiv5OX2SXHTQTbUo//rMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAKGpxMIL1uELpWeq7Oa9JLT7CFE4tgrfOO\np+tMqSTVXQIgc+TImWUhs+QWaVfhuAnddZq1w3mnrscxD1UYtxoZSMU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATOLx+nWG5z0u2H3zoj3e713MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzY1Y2Q2NS0yMjE1LTRjNzMtYWE4ZC1hMzMwYmEyMjI3MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStjzvBAgP42pqmKF/cHmh111Z4x6CHYFWzIWeeZ5/bSW+1\n9SD6Tz9iM9CyzaeY76yo6AieMuGDG4z0i/jnxv0oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWqYqitcfKK/k5fZJcdNBNtSj\n/+swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfyC94l2tarGL85niLFaEjWLAk/6bRIBG708xEBtm1i0CIQDpFRfg4FHZ\nYM9irLiFvL77yaVLkIJGST2FuSPKSbUNBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAb2uu3gkaB+S4HQR3Zsri5PbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQyODAwNmYtZmM2Mi00MzE4LThjNzYtNmIyMjZkYmY1Zjk5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDIxMGE0ZmEtMjQyZS00NjBmLWEyZmEtNjczYjliOWEz\nZDJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpaYnxvdkccfKHNrnZ2opUx0t\nD/D0MvRRDExdLDPnHP8HnGgCkWL0Bo5HQAV2JYpXH68XCxUXdphkKkWvKrM3pqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMVMxEOQpeEGxdo/EvsCXCIwUDlgwCgYIKoZIzj0E\nAwIDRwAwRAIgN5Qa+AZ2I1eMiKv/rGCUHJ1PPXdQTrIjVSE3/2Q0nroCICo3MUX7\noT76qVPHwJ8mHyps1gLHAdr5LnlopdcZ0EeH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6587", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6587` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISARJlSmhyqy8cwprwffMpIx2yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMzYwOWIzLTk3ODctNDVjNS05ZDNlLTM1NjNiN2FkZDdlNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTkwNzA3MTAtZmU2\nZi00MTQ5LTk4YmEtODM5YzUyNjhjMGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzJAQxw9LrIkjYYZi7RmWtCtYH8acPZDmwnAGwg+2K8cog61TzEbh/eGzCp9F\nO4x17Lp2nwSMKNq8yPEP1ojewaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuEU3Cc4V7/dTT2BIfWXiXT9BWj8wHwYDVR0j\nBBgwFoAUT1mfA/C69qWSGEuIbV4WSEGva7owKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAM+MBlG48bls\nzBOamkFbDfhbu3ER8MrvtjKyWIEaxkrvAiEA6tjIr4VSj3u5ZVC6uVXmDgqmFFjr\ndJ2cuyW7FSFJY3k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaTEQSka/H+qCmPbBh0L3EN1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzM2MDliMy05Nzg3LTQ1YzUtOWQzZS0zNTYzYjdhZGQ3ZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASx3fJK3Gmgd4KGTW5Hh7fvAHTGCPJenPpR/m0/m9IZgQ8M\nnUK7TmwpjOpw0LZw1Gc4a8RWvBgmrFrs4v++GUaAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT1mfA/C69qWSGEuIbV4WSEGv\na7owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANqLf3E9M4ezO53NGJNDeaKPPB7oUbhNGH7Kv326hl2dAiEA2zHC2h4K\nII7+xvF5b/7VpXceklCPsLtEb+2HoRb5JyY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZ9znbBnGx9u5czHW21clnkDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTkwNzA3MTAtZmU2Zi00MTQ5LTk4YmEtODM5YzUyNjhjMGU4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTBhODQzMzUtMjIzNi00YzRhLWFkM2UtMDA2ZWQ5ODdm\nODUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw5xip1H1Ib7xxBM6tMRjYcLV\nC3JS0P8MIMxELIZ5/89cRv4vZQJro5L4keHeS+yZwddIb5dGJZQjc6KbCNrDKKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuEU3Cc4V7/dTT2BIfWXiXT9BWj8wCgYIKoZIzj0E\nAwIDSAAwRQIhAOpIBRrzmgkq6Bd+JWW1FjcioshKvZldD3cfxHc/SuKmAiBAyQaA\n2r8rxxjfu7UexP/st1EY8kynha/AJcS5BDhhKQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6588", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6588` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAR2ow/+bEO7Er/enmN0iZxCqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzYTBlZWU3LWJjN2ItNGQzMi1hNWM2LTQ0ZDEzMDlhOTM2MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWRkNzE5MDAtODkw\nMi00OGZjLTg1M2UtNDFhODgxYmUzZGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu/y2tRKOE+Hh2plTaCP7VXLVsNwfT1Y80pm3VuQ7n4zg+mlweXBs5moRydsl\nrIRonbKPxAs+m5mi21yqWeWZiaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbeYE5jxSpI7TeJFvi/bIAiebaAcwHwYDVR0j\nBBgwFoAUlJXMF94dO5cxDIkNgSt0JNCzNhMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAN72hlDgt9/Y\nkAM+tK7fu+aRvVWeYeeTLmNVwG+949CJAiEA58SOZn3NUlJNQ9Kwxon/r+c9P7Yr\nOsoOLu8LptUJOjo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWTcVyegc38nWxWKjwueOk0BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2EwZWVlNy1iYzdiLTRkMzItYTVjNi00NGQxMzA5YTkzNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATm6kJ2ZM8RnUTiaLTVNtyUmummHlaBBxpqEq/A6gzOUqJw\nUDy5Uj1q7iuwQyCRgLgFYkw2BvTzogGSvkq4WoU0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlJXMF94dO5cxDIkNgSt0JNCz\nNhMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM1vOl1XzwEC9yvpZ1zJ7NoJ1pCnCgHiJ4qcQHHTFldUAiB/t5IJa1fd\nL/dP6XI54OmI0rSxayrrD7yPFJYZb/315A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZh3+KZoB381qE0agZrqL2IbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWRkNzE5MDAtODkwMi00OGZjLTg1M2UtNDFhODgxYmUzZGRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTg3NzA1NWYtNjdmYy00MTJhLWI3NzItOThiNGMwYmM1\nM2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK1Q3bGca3KTITV9VzPRE/iP6\nG1YDC/ZW3DMhLS7LoqIv/cQ+nI2HHqd60vDWEGos0Z52GY2PIM0Zpc60GrjggqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbeYE5jxSpI7TeJFvi/bIAiebaAcwCgYIKoZIzj0E\nAwIDSAAwRQIhALmiYY64vTlKDArhKrSSoGIlGjAK3WRfSX2YFIh66GRnAiAOLHaU\nIV/rF7VoHPmiYVcsPPXKN6XtjVLw2MWEvq0IhQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6589", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6589` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAfhIICfY5RCUXau9Z1Vzz2jaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0OThmMjNkLTk1M2YtNGY3Ny04YmJhLTE1OWJhMTJiMDk0MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDYwOTM0M2YtNjhl\nZS00MjUyLTg0MjYtN2U1MDA5YjliOTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESrk0WsapgXU8WTfRwHTtjR/WFT31Gpe+ZQNd48cIyjreCiw5Qhc/uD/oGmum\naFF6x+IIVHWtNQdSRSi35zOBjKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxmtrsZKuY0YuLpa1A2+c415p2v0wHwYDVR0j\nBBgwFoAUW6WbrGomX5wWM1vGbXcpCzr7Fw0wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDg7VaJTTMI\nn3Zrqd0zV6r/26SRtRk3fkRYlIDDHmbIEAIhAIy6LiFKC0LCcDfoaKhA6kyjxN09\nUkpwWAXI4WvxrB+P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZsCwogBvBwVb+oZpSuSEU0AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDk4ZjIzZC05NTNmLTRmNzctOGJiYS0xNTliYTEyYjA5NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYYoiLPTM8G13AyonjaRHv1k+laxAItK3zyiZ12rU4a2O0\n4XGnRiZasllmNvtXItrVXcn12aYNq4hJ3v9B104wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW6WbrGomX5wWM1vGbXcpCzr7\nFw0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRIewXtERbJhdkFyc3ZsAUfZ89Ka8qV6UOIl5nhXEWR0CIGyW3fOTWq4J\n8asXCv3ZBqm0uqMr1hesEA86hdwRBjkl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAUqBFY3q2g7PHbwTiQIG3A6EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDYwOTM0M2YtNjhlZS00MjUyLTg0MjYtN2U1MDA5YjliOTdmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTRjMGUwODktYWE4Yy00YzcwLTg0NmUtZDdlYzkzNGVk\nY2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/yg8LU+Wpv3obv+5aS6aCdEm\ns8nW1s6PP2tX4ZqwuKBn43M4qd7LG9P9ZtJ3KU0irEmyQ0s4jXw2axOcLrHCYKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxmtrsZKuY0YuLpa1A2+c415p2v0wCgYIKoZIzj0E\nAwIDSAAwRQIhAKLdzRgtiYyst2E0SDLfP3BiB2kia0fsdze9wudoo2u0AiAbM0Im\nGiTvrZU4g4H+sAai6XQug7Xfjq6hF9wi75qcOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6590", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6590` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAde8tO8WbZESCw80rZVfFbRoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1NzJiMTJiLTUxN2QtNGNlZS1iNmFiLTIzMmU0NzdjMTJlZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNiMjE0MzAtNjAy\nMy00MzU4LWFjMmEtNmE2NDJkY2QwZDQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcw5YmKt9RxBSMJaiDhuI+VBreQrmn2FP8mVk8ZgaC0WaagfeJO1fFZ639s+F\nQBapwHMJy624EfA9Lh40JO1cHqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6IuCWVEu8e3Rqn2ZGRcxnPHyX1AwHwYDVR0j\nBBgwFoAUDYFC137Wzv8EPvdB4YJknMR9JRUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIA2wcItRlI2WZL0+iy4dJTVgIQuHzgBRFXHOsyd7HmWiAiBFIs5tNLBEpNxP\nE6MrceJBjaLNf2HQnWRptRKeLr0x3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfNPHgYtv5fvj/ryP5vh3+vkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTcyYjEyYi01MTdkLTRjZWUtYjZhYi0yMzJlNDc3YzEyZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5zWC0P06VYeLugyqx2ZKJ1HBF2Yxz9ZDV3vltOPkFycI/\n0/xNa9YfqsbsAiU8Kj8BiCHTcetTf9HQfO7crBQeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDYFC137Wzv8EPvdB4YJknMR9\nJRUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALAoNP7EJt2YYEaHzttnHKf1wQ8T9rejLExGdO98HuRAAiBP4r9WwN2C\nELJy1XOG0o+lOHgo2rS4jpWrbLroygsFGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISASg7SF0iKz8MKSYZb6dXBFF/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNiMjE0MzAtNjAyMy00MzU4LWFjMmEtNmE2NDJkY2QwZDQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjYyMzhlMTQtYTM4Zi00YjUxLTg3YWUtNDcxY2VkNTE4\nYTI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVjhxi+SASAKMMWnLceXJhDIr\n/Qvp0weeclmqmAgDDrvR5xe6/FzOf+Lf+j2BB+BvDmAjUQVw3Y0irttV19hcpaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6IuCWVEu8e3Rqn2ZGRcxnPHyX1AwCgYIKoZIzj0E\nAwIDSAAwRQIgUrkPCnH58Un3EdZtL866WYgD2Pa26CKCeMlSIMClsTsCIQD/ROVg\nBysHO5E7knRD0hzH1GnV7NiPxjzzRFekIxAZzA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6591", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6591` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUl57jNfNAWokErvo8YqjFnSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5MjViMDQ4LTkxNzctNDFhMi04MWU1LWM3OWIxZmI0MTMyNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThmNjU1ZjgtMzdk\nYS00MDk1LTk0ODYtZWE5OGJjNmFkMzFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnvmklw1E2AmbCptqRelQ67LojHLyhKDMBTFfuVuZX2MrDWTsUMHXQ1gvNjhH\ngv1NfLjAMvvJaQKxeD50SQO40aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe+vWUMZUPkoNG1EqJgQMdnxZEOQwHwYDVR0j\nBBgwFoAUOJ5Gxjb59jPjOSpPV8svyVOS5x0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGNPTdCMUQLCRfWwF7sMytBcpcRZwHQjscg9ZgETwIu0AiEAwMfizg0UGzec\nlClkOmxKS5WXoPPFADZZJYFvJViNeOQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdhFr8Cf0sGhLqr9JJos56AVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTI1YjA0OC05MTc3LTQxYTItODFlNS1jNzliMWZiNDEzMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0vrFGoJNFYBbr2EFeymlTx+79SvPo/at7WzqQX2tXsice\nLsediGnmU80z5jpVqFR/BbjUwrsdDYNaq5KOmWWbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOJ5Gxjb59jPjOSpPV8svyVOS\n5x0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY90W8q537kYXiToNRhv7eIg1Vj7r2WtQHTRsFlGF43ECIHves5V+rygB\nky+yMq4c3dNUXeHzmPZBlAVHbMDMELRb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAd5mjYv02E8WyH9GytGJS+cjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThmNjU1ZjgtMzdkYS00MDk1LTk0ODYtZWE5OGJjNmFkMzFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGY2MmIxZTItZmVkMi00YWE0LTk3ZjktYjQyMjBkYTgy\nMmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsG1bQDMtVVXMOV7LcvtD0xxg\nyYWu1GLKKNWz0B7XqpaTHWBRfaRhONYTFkIleDm54DYEawBqA0QCEshXAfDFF6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUe+vWUMZUPkoNG1EqJgQMdnxZEOQwCgYIKoZIzj0E\nAwIDSQAwRgIhAL0yj3VkXEbTvL98dEhD/vYuYeC0/teOuZy4tRyyOs3DAiEA8j47\n5ZzHWavg0I246riltfepZssrJEHRHzLhYMH2DbU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6592", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6592` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISASskxZR0yU7yFbrJjOtaTPoaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZWJkYzBjLTI5MzQtNGZhZC05NjVjLWU2ZTE0NTNlODJjODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE1NzdiNmQtNjAy\nMC00Y2Y3LWI1YmYtNWU3Y2U2ZGUwOGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVZkyrnZ6QZc4o1sVZSouijCpWd7CcD3Yt6aB0kikq+flvP/eUPLaAhOVmyZe\ndKPOfXPUBLhhaK8JjtTleUVbVKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9L42kT9biEJLnYm/RYEDfEtb+4UwHwYDVR0j\nBBgwFoAUKJJnOs+MB6Ari4qSGdUxxhBk2qkwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICB1\nOCwJn1ldrW2SQCGrG8YX9wvLVQoFQkuF/lFwzZQfAiBS0URdWjY+1B1CEthyHsa8\nCpppJ3y17hjFVG3VnKCS7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARp5W+HXlIvj9SmlpVSWILmgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGViZGMwYy0yOTM0LTRmYWQtOTY1Yy1lNmUxNDUzZTgyYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRo4ltrVIwRY6w00cWPzfASAV02ZaA/OcBGtUhC7nZz7OD\nlaIgQN0ms+wJGAb/n6wgjYnndIaSQjKgisVwShgBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKJJnOs+MB6Ari4qSGdUxxhBk\n2qkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEIlriVw0Qe9Wok1AOmyrkKxRs9u0NxuPPrXLf3fKo40CIAIen2EY8QAW\niq7loErRdnILU4bIy/vzFya83TzMUv46\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAQLv5s4Gc2qS0SWQlTPJNea7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE1NzdiNmQtNjAyMC00Y2Y3LWI1YmYtNWU3Y2U2ZGUwOGJkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzQxMjVjZWUtZDY4Ni00MWQ1LTllODQtMjZjYWYwNmVm\nOTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzW/TQX39X9mfo4zNgNIIiCbM\nWJ7oTS7+4MG6xM/+/1/qAKyFI2GHRFHrL5ZChQcDha7is01H2rjVYbFNeWdB3aNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9L42kT9biEJLnYm/RYEDfEtb+4UwCgYIKoZIzj0E\nAwIDRwAwRAIgGEdPi42nNysP/hdeTFq061mfYulPseTck49e+NdpB5oCICHBm2Ua\nCqYYj1kLx8eGzduz5flN/2ySJc/LKKEkeivf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6593", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6593` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAdUCoDEIikI85UeGZrcTPli6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwOTg5Y2NkLTc5NzYtNGYyNy1hZGU3LTBmNzU4ZTM2ZmRlNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZhMzZmZGEtMDdl\nOC00OGE1LWJkYTUtYjdkOTlkM2FmZTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5n3QSNyamvjuCr8nbNVnTqZKmpLddkbZqmlUofuZ38/0kj5Fb2vwVRrsLV20\nuNktpJwVsBzbagSwxA0cKwx0zqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUggICLWQ/ZYyTxKq7JJOzlArslEwHwYDVR0j\nBBgwFoAUTyN9gKtJAVJEihpXopTsOw3DZ3gwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQC2NFuTdXfhFC+XATd7MGFILbeu/jAjriGRNSOWUOAscwIgRwt0\nOrucMxFI+8eSEqPOMXcIsb0V45GmMfjgAEjKtEw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa6KeMxMeb14SnqPTkkt+BvsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDk4OWNjZC03OTc2LTRmMjctYWRlNy0wZjc1OGUzNmZkZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3m7BpjVutyzbCQMt8s05OOL+qUnlBXv0HwKEabNMO7wkT\nDXKfRSfCpcHHwpsm0InTzydyt7yS8FZ/AVSyOOIyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTyN9gKtJAVJEihpXopTsOw3D\nZ3gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPKxz2quZ9IrBqrtQalBhKK/Vq0+VI1u1wVD4IQeKtycCIQCo/SH4iX+Z\njgSGRnLzdDW9V2VXt0uoaVG/Hp96nMH7aQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAagQstgomDLSPQj/+c0v6qMXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZhMzZmZGEtMDdlOC00OGE1LWJkYTUtYjdkOTlkM2FmZTE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGVmODVhYjctMDJiMy00YjQ1LThmNDYtNjcwNjRkZjQ2\nZTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVTtXy6VOXivhFHAlVJ5Ju+bf\ngxTplqZAlpGXF/9cg38NvfhqCyiB6ja3kZU6HhbHUKsliXMPrtapD/J/8PN0J6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUggICLWQ/ZYyTxKq7JJOzlArslEwCgYIKoZIzj0E\nAwIDSAAwRQIhAMyWslslndKaJF8cQhEvWgrSpDbiKSK/H4Tdkl772jzOAiB1ruha\nJszh26TfK/2J2Bu5ov9CNyj8Jqk4wJTFPWMfJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6594", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6594` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAdNaqqv9iHU4V1t9bOjB83KJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3Y2EwNjY2LWNhZTAtNDkyNS05NWQ2LWQ2OTdlY2I3NGM3OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY0MzE1ODItM2I2\nNS00M2NlLWE5Y2YtNWIxOWVjMmM0YjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyPk4zcJg03JcRC1RwHnJZkksKRLdd7zBn7X6bSscKW0lvKCNFq5jSJSYrRYJ\nBrXB7LoCcE0cS6PuGkCi8etOx6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwhd7scIs/5M0b1Bn7gPzAze9zvUwHwYDVR0j\nBBgwFoAUuWJNxDEojGKyWJc3CT/yyAZRFEswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDoP+VOanNxbCE9Uu0bXL3umEJG8z6kbRDEhkUo2xsVqQIhAO9X\nmtIaxYZ8fuRsGo3cWmk9fuIm5vNZsIPX9iws/c1k\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWSWEPOaqOvvx3TloRDtWjLmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2NhMDY2Ni1jYWUwLTQ5MjUtOTVkNi1kNjk3ZWNiNzRjNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjDjaU5SmQ27B1yaErhBUEMcFAQ6N7c/OiTJm4SCbhTP5E\noL/+CeVC9VWm50QpvEfmoZySIlXDsgEqR5orW4wTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuWJNxDEojGKyWJc3CT/yyAZR\nFEswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYrCfECA3gV1bQ+BpZjKN33zz+mNBoqDZXG4KpRCaxUACIQD64pGgsluc\nThB2QyC1dz9wnbXLMwq1Vau4mb2rzmIJ4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAcYjABkxipUIXvnqp1rMaTgSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY0MzE1ODItM2I2NS00M2NlLWE5Y2YtNWIxOWVjMmM0YjE0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2Y0OTUwODEtZjQ3YS00MWI3LTkxNWUtNTYzNjczZGZk\nOWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEF+Qbge2ustlQEr8XRp9X1zqb\ngl89nGc+OpYoqktXjTV3F9YsT8QdaVqEEqODMJbQ2JVU1ott0EEEmDl+VSvMnqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwhd7scIs/5M0b1Bn7gPzAze9zvUwCgYIKoZIzj0E\nAwIDSQAwRgIhALZrKACb9z7FbfjhURniSFZBtpuftQJ6VJr8DB4Z/K//AiEA1ITp\nyz81kGmH41UfJxqJL9Xq2aWahVoZjMeMfXjeUnY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6595", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6595` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAV8mxnLHJetr2/NwnfRPEEnGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmYWVhZmU0LWUwN2UtNDI2Zi1iMzQ0LWI5MDNkNjU1NGY5MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWYyY2U0OTAtMzUx\nNC00YTdmLWFlOTAtODBmOWIzNTg2ZTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/OSb8o+lXoen3OCtsCGi5yb2APN34PPWscubNeHD/3dNIWjYwSImvwxxgh+D\n58ou8GlvDlGjt+4WMxg2A2pT/6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTLfiw1vfTIkSalpUbfU4sbpgiP6jAfBgNVHSME\nGDAWgBTrB2WggSKlKQefYQiP/LnyXzXKrDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDBmcEwpnwKTWi9HpnsTB0rw7dy+mIV\nlALlapruC5PmzAIhAJ8gbuRN8vQy+xEKRN2P/C2NzJwo7qi0uaQ787WMjZYe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXqTJNExwKn3W13CrxCEWQOiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZmFlYWZlNC1lMDdlLTQyNmYtYjM0NC1iOTAzZDY1NTRmOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzZQlKrGnm1nMyW2Gr6mgZr+G3Hc+LYTQwMyqDFxLT0aqu\nM9gbIYBAGH7a6EnLmFEMcR8f37Z88QQV+jVwpK05o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6wdloIEipSkHn2EIj/y58l81\nyqwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANaKd+zh3jVznijDwJXJNn3iPq6NUah7v/3ddH0knMQmAiBYjlD9IWA4\nSwPt4w/om8mF//f+swdqxO0lzqiRB77v2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAR64l/ksvsTDfdRsqSsdOqBWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWYyY2U0OTAtMzUxNC00YTdmLWFlOTAtODBmOWIzNTg2ZTNkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Q2MGVjMDctMmRkZi00MzY5LWFjMzItMWQ0ZmU2Mjlh\nNTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoQBgP3nPDCkk+LUCAi9SDgYZ\n8lF3uyFOq70wzK7RhSQmzzJlVikrFLsZJkXrzVG7+rERsMRmx8h1M9V7gjTqm6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy34sNb30yJEmpaVG31OLG6YIj+owCgYIKoZIzj0E\nAwIDRwAwRAIgQHa7Y7FxGxnUfV9iBdsIAQycBIC/cPo9ULCA96Lnb+sCICAGNZpv\nIiQr6PLALMbGeU5zywrm/D98NbmDk2vVg6G3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6596", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6596` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQswLRISymfyZdUKYJkmmzt2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMWNkYWVjLTZkZGEtNDIyMy05YTI5LTFlNWM2ZDhjOGQ3MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA2ZjUzY2QtMThm\nYS00MDE4LTg2NzQtYzg0ZDFkMjNkNjBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoO/ZMFCMO7+5QqIEg1bWfT/A+DQHloNu+skggXVF5hKDXZG5nnHdnrNcESQx\n6MtIAiVwwWmsTSKbe9pG/NBajqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3PsZ1BHOM5lJGQsQ1waRw/lhq/YwHwYDVR0j\nBBgwFoAU8m9Lh1zDrg1LyuUWVtc5DMyONbowKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC4Jh4AA0e/\nxPcztbzX+pYbPGNv0UIcEwWPSkl9L+ax7gIgEvUs8lUgjFbsnsnAGLikUPKOQ6y5\nTwevZu7SWQ3Gnl8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYPRJ792vk5xH2Nn73OTAZWyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjFjZGFlYy02ZGRhLTQyMjMtOWEyOS0xZTVjNmQ4YzhkNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATphHOOWiAaO1JsAPqRHMT2y/2qWuhgd+mZUQyJOCH+6knZ\n3PKtAQhjVAGZOy5gIH2UUVooSq1meZ2/4VrZIn3Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8m9Lh1zDrg1LyuUWVtc5DMyO\nNbowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPX/ejrZMvyR/4/9a+SuuXRe6fMN1wotYy37raWROWIACIHMwM/+J6etB\n75N5FO2YLlrEpm263Mo0HTnK5YwD4P9Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAdW6Nyl67V6V3YHkchqpklm5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA2ZjUzY2QtMThmYS00MDE4LTg2NzQtYzg0ZDFkMjNkNjBhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjAwYzhlZTEtNWU0NC00NzEyLWJiMmUtYmI3MmVlNWIx\nMGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAMI0KhtIN9j2r0Md0IE4oKZn\n9iZH8ZslJoIkjrsdYLpcTE3Em5tx/MxYzZqUCTuUmXo88usv6PrRmTxxAxPlW6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3PsZ1BHOM5lJGQsQ1waRw/lhq/YwCgYIKoZIzj0E\nAwIDRwAwRAIgWqIazeCC+kG5B9IlWS4xtp1x2+yK3kKUYa3ZA1zDTncCIAMVxlf8\nUWGZCLSVrH0yQXkR8DYMscP9slmuN8jWbBEr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6597", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6597` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAchyA2fXTQ2Q0sXiBQ7hGDcOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViZjgxZTBiLWY0ZWItNDJiYS1hN2Y0LWVkOTcyMTI3NzA2ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFiN2I5MzAtZDdi\nYy00NWI1LTkyMTUtOGU2YzQyMDJhMTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHVFUoadHSjYxumAcLgPtTjZdbSyfWUK5WgTWgPgXzi2GZ8HgoOfUpOhxhyA0\n02SFeg/vHd5uUV3g6tsrteAUraOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE6WYBd+GzliMTZfh8/WZhylq+O8wHwYDVR0j\nBBgwFoAUNaLzMhigtORRgULzs0utU2oFOtAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIElZ6YLE6Mhz\n/hyR4KJ1grfXz1cIgIR8dRaLBXQgY6IhAiAom9/HcvLp5RC2GIpigdq8SC64Myxc\npec1B6KQRfpI3g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWKgEPhHAVZcT12a9P6TON5sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmY4MWUwYi1mNGViLTQyYmEtYTdmNC1lZDk3MjEyNzcwNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQg2l2T4gVir3ikqCY40K3veBuNcAlusgbewSCQAND0AbPP\nwmGI3sF7NeMM2/e6iOK9caVBHw9zZz/f9yzSMlpLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNaLzMhigtORRgULzs0utU2oF\nOtAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgREbyWIOuDmAe9cLXCraueXkr7sQcWh1tWZFcvVGQNnwCIA3ABWev9XVW\nzT+SpaWV4Pk3Ph3zzPvMaG5wb5yZtyrx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAS/+1b25qi/h1QAosSEiokdeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFiN2I5MzAtZDdiYy00NWI1LTkyMTUtOGU2YzQyMDJhMTA1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjM1ZThiOTAtMzQ4NC00NTJhLWExMmQtOWY2NjgyN2Qy\nZGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX2TquVkR20frxHPjLSNPBK0T\nM0ALfIkF4Zl0l/r7RM933HixHLbauuPiFdQbdaasLPVkNoswJiY9HBCPw/mOb6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE6WYBd+GzliMTZfh8/WZhylq+O8wCgYIKoZIzj0E\nAwIDRwAwRAIgFf60S290JU7+242pcsLDUSJ29EkPPalgI7ZQM4MpQxwCIA7apODR\ngYJbeCtXsGOZ+Gsmc1+a6zbL3Hr8M5V8SaOM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6598", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6598` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAcrMp54AiBg0yIanNo765N+JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNmJmMzBkLWFjNjgtNDRmOS04ZjI4LTc4ZjA5ZGUzNGZlNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNiMzcwYjctNjRk\nOS00MTdkLWE5YTctMDUwMTU4OGQ1MmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM+wEg8+/8Zzu7cKyOYgy872BhVDclyGPSxbdJNBWWpbvb84O8VaZ0wed6zzZ\nQ/KOpWjpIo0rJrxSq48iX2+rq6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJni83Szcp6m8LGo6HKKouImQ7/8wHwYDVR0j\nBBgwFoAUhpuNUU+NAY8m6LVLsyNSjQrwtxgwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBUKpIYJOtA\ndj2RXdncLqyUqbFKpCMl8pX/+i4VcSfWMAIgM2hsAY2RcMWW04bujAdkh3vg83ZF\nN0hHGoj2BYGzSmc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARMfdKKYgZhLJRSx+l3vctDbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjZiZjMwZC1hYzY4LTQ0ZjktOGYyOC03OGYwOWRlMzRmZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIva2Lh/Q084KXDmKzuxZKSJ44vz8V6Sc8wwlm/89N1+JC\nTYBn5t286Y5YsuRqJ8q4zSiF5S6wQUaj0xPKOHV2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhpuNUU+NAY8m6LVLsyNSjQrw\ntxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMXi4Kq2GARPm89vG5+XEFUkAFf0lZo0/p5hHXXczt40AiEApVyvwvb6\nWcj4Bm1rKIK0BAkjxxCGC1bz/4kXlsHwfVQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISARCG9lX0e46uk/WlIEoqxeldMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNiMzcwYjctNjRkOS00MTdkLWE5YTctMDUwMTU4OGQ1MmQwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzBiYjdiNGUtMzRmNy00OGZhLTg2YTAtY2NmODBkMjQz\nNjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElPJXbFrQ9KMzinJgDVYoDAek\nYga/zf+MRh/JmTi3e4m5qMQ5kimi/WOhCNJhwJ8OliFw58ng8r76vQ3BPtUuraNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJni83Szcp6m8LGo6HKKouImQ7/8wCgYIKoZIzj0E\nAwIDSAAwRQIgAvAl+8dK+zmN0s0P49xs2aASHS0IEp0N9UeWFfu6cU0CIQCMTLxk\nnw9LikbeOqxLXctL1/m+Ne+yKCGNNOdo6BCXhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6599", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6599` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfN6a4IZUfsKNyiqNqN3FWWEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0NDBlOGM3LTgxNGEtNDNmOS05NDU3LWJjMWQ5NGNkMjk2MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVkZDJjZjEtYjFi\nNC00ZTgwLThiMjktMDE4YmNjZTQzN2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwIupmjwEQn72qjqLLtpf7fhmzMzcrD68L0S7YipKwptshEwiz7iRxVA5koBg\n4WzoatMqjnPzR8+weDGD9b9CjaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM0yFTiLBgpnYPBPv0BMfGQx9YcEwHwYDVR0j\nBBgwFoAUuOgqijtll/5TBRXPbAqsBZFhY70wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiBPKx9xKMNy8Ivw7AEAYV1MdLcFZ3STaa4IuVJgt+gvzwIhAMc7HW3sk2mS\niiJS2aMpBIZH6piVALPnBI1zrGeqVrS6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbhZORCD+UlWQdZzdR5y7BWQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDQwZThjNy04MTRhLTQzZjktOTQ1Ny1iYzFkOTRjZDI5NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASird0T6Nq1pzyG/1D/ynio3OM+SzMXXlF1fh8ClLxMWrvT\nAbWpqZLLT8UzSgA/KUhooP3EtUHby2cQ+X7DHUDMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuOgqijtll/5TBRXPbAqsBZFh\nY70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVfmBc3TCJozwy6WCSxzr7GGtYqygP0YnLfpYVY9+B9YCIQC10F9++EWj\nmFXKM3U2ui7aNvE6N/w4LOXtf37/RF0/zw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAW2FRh6A/nveDyZwsYvWIRowMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVkZDJjZjEtYjFiNC00ZTgwLThiMjktMDE4YmNjZTQzN2M4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZjYjg4NWUtN2VjZS00YzA4LWFiNzktZmMwMmIwYjY5\nNDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKQVWsV6oSSNooNBaogo28jO+\nuxIgX0+eDxE0p3Z6IKPPhFu7Onsm754ATeV9ZaqhxT8Yf+aitrqUvJYjulB296NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUM0yFTiLBgpnYPBPv0BMfGQx9YcEwCgYIKoZIzj0E\nAwIDSAAwRQIhAPvvLuErg7UTELRzb9JpJyuAhM91uObLAB6EkMmqrR+AAiBe1JFw\nlHGuF+kRG3L4xbr7Vh+Ef1yw3mMDtUvnEf2SiQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6600", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6600` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAQZfXZITTOrIU+VOa8j4pCu4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwZGRiNzUzLWVkMWMtNDMzNS1hNmJlLWYzNjYwNGUwY2NiODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY4MzQ1ZDAtYjEy\nZC00YTVkLTk1N2MtNjE4ZGYwNDI0ZjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEikGj42ohRSwMg/q++6RA9DwXbSUwsVgcsbR1799WRFU2QREiivGN0IKcjtfJ\nP2fZgzYf2S5JPdk2v+RomPbjwqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlH6PDgczj7O+HjYjJ4nTfCkNNdQwHwYDVR0j\nBBgwFoAUUqkCPxghjXc38iBW+8ZOgp++qScwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiByxECP/VN6Vp3k9Cn1yHX0Fz7iAW1q5JuXJ21Ros/esQIgTat9wPA/cQgs\neDA9GNWXnYDuMcc1IcOMhuQCDZloCSk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfNou3iSIbm/jZjKC/gQghUiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGRkYjc1My1lZDFjLTQzMzUtYTZiZS1mMzY2MDRlMGNjYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7K4WP0FcdU/2DjiABRacuPwxSbRwgBu/uiQ8mvTfEqqKd\nvFY8VSHkvrXAdzWG2ho7OzReLUsrE9SorM/nn6Hoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUqkCPxghjXc38iBW+8ZOgp++\nqScwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPCVhAeo8XjEd2uv3XWe5JnO/ZnfBJiStTbjWR1/ZLC2AiBy1MOQYZ4B\n3K7ekEjRMXq+3qa7S9dgiPtFvz0P419kpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAYjgMPFVOiUT57eEgwAU8gYwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY4MzQ1ZDAtYjEyZC00YTVkLTk1N2MtNjE4ZGYwNDI0ZjA0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDQ0YTUxY2ItMTBjZi00ZGYxLWFiNjMtMmQ3M2RlZThh\nNzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpPdG3cmEVIZaV0Gv+421dJ/2\nVp+uh0fHU4DJq6QsQmC2ADG+BTC1Ho8ADly71Xi9t4yJwt4bnm7BjJTk6nc09qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlH6PDgczj7O+HjYjJ4nTfCkNNdQwCgYIKoZIzj0E\nAwIDSAAwRQIgFfpr8zUXKVYcPFi64ihYPWvQcvGSc5FzXafmCeqg2pkCIQDlmyuA\ngR6ZZbE5FIeHQYPdQIk9jesrAxnFBGBTFN4tqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6601", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6601` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAXMEPsmEYZ7rsSTIzeFrJ/QyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNzhkNzM1LWYwNWQtNDgzNi05ZTk0LTcyYzczMWQ3NWJhZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc5M2M2YmUtNTJl\nNS00MDQ5LWE0ODUtZDBjZTk4MzJjYjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED7pFnU19Uf8L5nakoJ7hLI0FNqOnVYhvgBEnWlWwlOJEcYr8hridPRK1fx5d\nFark0Q2E2RUkwgeh7mH27UmerqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURjEzTgJCnABj1iZR+7623dVlCe4wHwYDVR0j\nBBgwFoAUOI671zUf8PNRPOTt/RIBJWpBiTMwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBJ\n0/JCRIlP8w6XsPiE7X7/tDQugrv57So3Zs8RMeXqPgIhALXB7S2b/whS1d3Qu7z8\nNqPWD2cNIAaHXwMjxQ6ldaQ7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATToZCkOEsC6QZoTU+ukhmMuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDc4ZDczNS1mMDVkLTQ4MzYtOWU5NC03MmM3MzFkNzViYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTutgpHd/cpzWigB9UWluFnsbHiTnAWX8m012758aTv2uB\nZ5GR3r9VXHCFluh/54of1Mdf86+9IJIhFTFyiS03o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOI671zUf8PNRPOTt/RIBJWpB\niTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANDVNOKRyEKZso5UpmNkhSQU4vaCYRhrJXA/q60uucfJAiEAinaQZyUO\nBjAwZ1lAg3/rhFLzvF+2se7u3QJBsQCTdm0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAWP42cppUl3B3bO8SPu0btTkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc5M2M2YmUtNTJlNS00MDQ5LWE0ODUtZDBjZTk4MzJjYjFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk3MTIxMDktNzU4NS00ZmExLTg4N2EtZmQzOWFiZWM0\nNWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3Soia1317iHrWuwc4fGFPaXk\nsC7zJ1YxB6y0gXb+rVfSPSq+PNPudq+XKjvyX+LzF+D6a1lHSHLIgyLEO2+XEaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURjEzTgJCnABj1iZR+7623dVlCe4wCgYIKoZIzj0E\nAwIDSAAwRQIhAIx6UhH2fJ5CnGJjclgcY2fCY0hetRd3zNeAJF5keCStAiArKuNW\nC1HDE+pAl1BV09bI04HvUJ9jDLQtGoF2zBBvgw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6602", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6602` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAeWwCl/PTD0NVZgMkL4gOCgaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNTM3NWFiLTY4MzYtNDRmOS04ZjMwLTIwZGI3M2NhNWQ2MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdlNTBmN2MtY2Y2\nMy00ZTE1LWJkZTctMjQyN2E3ZWVmZmI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkjDviE06trp4g06/SUPY6UXWFAEgL1VIusssPFQTFyBxA+T8jPiR6WGaTHO/\nfmDEYNMs9jeQRkhbr9boWUuYVqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOHf2FyQk8BDH8PwJrO6QndU7vkIwHwYDVR0j\nBBgwFoAUyXXMLU23GEOYL/OCBY8S3u265U0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAlPot0LSTsNaCAMBcbOjPhNrHUmR1EWCCnk7ZfF28IdMCIQCr\nBOVbaUC+wfKJzR0Bq3jF3cSmln5nKSzuNEOESQEbLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYklI3yk3r8pXpJmh1dzR+mJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzUzNzVhYi02ODM2LTQ0ZjktOGYzMC0yMGRiNzNjYTVkNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6FJn8si7IrTHZBMNNtYwAA8DI7V5bSy5KO+jN++v4X0wI\nGHukpbb2pCpfEa5XoPuVaEb7k6LYwVmHynC02if6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyXXMLU23GEOYL/OCBY8S3u26\n5U0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX9LMjUvyqlj8Phu3jcXXFTJYfPcDKBlShg5sWSOorHICIQCPx0ukJ8jb\nBIontfnEbO2xZDCTO5bxpdLYw7jlzzjaFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISARdeQ4+Z8H4hKifeRlQ5q1tOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdlNTBmN2MtY2Y2My00ZTE1LWJkZTctMjQyN2E3ZWVmZmI4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzM5YTJhNTQtYmQxOS00NDE5LTk0YzMtYThmNzRmZjcz\nN2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjnGiW3MDHxGA5+8w4PLDUPwr\n0ghWPqfncdlAWqPYHrINIovD8pXkKnpx7fJxmskKtLUcf/74HA0BOMVxXMTvw6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOHf2FyQk8BDH8PwJrO6QndU7vkIwCgYIKoZIzj0E\nAwIDRwAwRAIgc09QGCEHHk/ds2gcvYi9AfmeQQf0EhozD02givS+WnECIGKq2M7F\nUZRhO+/dURn1++HcUtjMeDhVFc7UsIqAY0OH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6603", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6603` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISASumhyEWuwOl4iSbZdjhJovHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYTdhMTUzLTUxYjgtNDlmZi1hMzcwLTg3YzU5MmQ3ZDQ1MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjViZDM4OWYtYWRm\nZS00NzZiLTg5ZWEtODFjNGU5NGIxMGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmRhQGT6HriUhWPLPGwTM8mT+FqOVuLklKtG4ogbsr8QnRomkb14YgOnHLEWp\nvMMNlAGp7l5ZZaLNQF81Z683kKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu36ajSoTxw2+CTcOVboTvA5onhgwHwYDVR0j\nBBgwFoAUnJWS3y9/CDHyBtWLtss+hmvmG2UwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiANiM/yHpFzDolFT5AX3egcPFzw2TUDUj3huTNLDSvhYQIgCVNF\nbClWWXXTEBWbMnCB9JUMzuF1qQo+ypCol9Jl0g4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAam3gm6RfUzVsz2GJSeynu23MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmE3YTE1My01MWI4LTQ5ZmYtYTM3MC04N2M1OTJkN2Q0NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZLmXRvWncvOmblq9RoSIDRMuFgmiNB5B3UXU5POi678xw\nm4M1K+bmAum7YjJat2Kji02gwkpd7Q90OOzWClCho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJWS3y9/CDHyBtWLtss+hmvm\nG2UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMALogll+0aFZKKRYZXc/5sxVTNdGhmr/Qd3YhaXGmesCIEHf/HX6P1Wk\nel59a+tWCWS0KgKgkd50QpkB5ryZ7/5K\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISASrLcBovxM/7ZvhODV3t5Fl9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjViZDM4OWYtYWRmZS00NzZiLTg5ZWEtODFjNGU5NGIxMGZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWZmYTYyYjAtZjI3MC00YmIwLWEzMmItOTQ1NWRkMGUx\nZTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG2BYJXuPpVNcISJPZH0I2D8a\nl8DzwrK58vZQNr0FlpV7WURVjjHfPOV6Dw0YNKU7us9aw46WKpMr3S1pknUXdKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUu36ajSoTxw2+CTcOVboTvA5onhgwCgYIKoZIzj0E\nAwIDSQAwRgIhAPy6xrs1zGVJ7hFV0YTFKR1MTTv+9/JX0zdhKpEbSv55AiEAxLSl\nW4IBUkfEsWgv2XeHaBD2RPYj+E20AfZkNfpBleE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6604", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6604` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAdgqgSZdQK4Zl2FYhWNJTzI7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmYjE5ZTE0LWQzOTEtNGU0ZC1iNGE0LWU1NjU4ODY2OTk4MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRhMWIzMjAtODI1\nOS00ZTg1LWFjNjctNDIwNmI2NTk0ZTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExJPMZl3l0V6bJq9qYpdZhmj7huyYbcnUZKbYMt+Cq+pyQ8UXJrtI3eYC/yJE\np9KsQVSWBsENbbrKhEy925hZ2KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfbLmVkO3ZClR4dBbcdnRQEFf7AwwHwYDVR0j\nBBgwFoAUPpgLovRJxrfe/FdKo6q3QUGNBGswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBCqNZv+P8xTPs1\nemzsHd4GevML2tekqZyADixd01fe4wIhAImg7TKJnQMJVzoHPw/02SYhjzoBo/yQ\nNC9+XX+kXd7d\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf/+QsJEtFREYkUKXrsNXs4nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmIxOWUxNC1kMzkxLTRlNGQtYjRhNC1lNTY1ODg2Njk5ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEJW+EFRB2EvpJd7TjLJDlqsKNE4hW15pm+JLvUOHwhvVd\nKAQwIVCGIwMUNyzzAi0d+3JaUpX2FEdK9vVOTRrHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPpgLovRJxrfe/FdKo6q3QUGN\nBGswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOyQ+OV1fzwaPADbxYKTQ/7hqtUO2vY1+PFsTlpy5UyQAiEA9oCQxUbP\n4wAN6m7m9TUZ9FWaB8d0sZMM68G/rHJt4gk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAV73WRidnhCa2wHbYd/VkqVdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRhMWIzMjAtODI1OS00ZTg1LWFjNjctNDIwNmI2NTk0ZTEyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmIwOTJjODctNzZiZC00N2RhLWJkNWItZGYzMWMxNWYw\nYTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEusKjn5C/zlZ2sJ1kk9EOJyv2\nKozTpXtge5hEGQkmYoYff2dA4LJjRPL6N3K7F4agbsLNlNUgX9CbicyuMJkmyaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfbLmVkO3ZClR4dBbcdnRQEFf7AwwCgYIKoZIzj0E\nAwIDSAAwRQIhANlIdsM/NTMEymn5rcUrE9dcSFfbvnsutt7xDQWzTzNyAiAUd8DH\nBqqUlds9c2UQhFUig+GLFu3NV0rBq3MGbdfQEw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6605", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6605` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAV9FglrBHrxbIdehvEOrCYFdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMTdjMWI2LTRiZmUtNDViZi1hZjk4LTEzMWE0NWIzYWE4MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU3M2Q2MWQtZmQx\nMy00MjM3LWE0NDktMDk1OWU4NzgxZmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEopbCYcU6uXqPv5T/f7o7lRenGHMwBuKl9e+vuMdGk5tePxQdmPYGQgAlMuKP\nSpGUc7AFp0FnU5rJRMl0xkFM3aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh6TRMoZxcNCMVBfOuCc33N9nZDowHwYDVR0j\nBBgwFoAU635mKVfgosAOW5wyf6cvyjUmk4UwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCjDkCNmkxwmHjDbt+EaKzDc8jN2jrmSqdMebLm8q+QZwIhAK25EpOFNpJV\nxtk9dsjhf2iv8Xp8wo+Q5m0mzgfA9byn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfnEJB+L6lg+7UDNS+i1FjGJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzE3YzFiNi00YmZlLTQ1YmYtYWY5OC0xMzFhNDViM2FhODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdpvbj+Qal8Yiy5BUSEEQO4tZSFup/f8hGwSg7ut9V9xr9\nP2lkGTwYR0LHrzxdINOE5sluwuiIMzPPjFKjpDzDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU635mKVfgosAOW5wyf6cvyjUm\nk4UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdl7WQg0qbkHe4pECsqm9+9/rLCbO7W+kyUmFlJetyKcCIQDUXnNsHqhq\naH6+FTTlGPCUm9FA671eCLxbUuaki0EuCg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAcPoacsZF8+wm9Zj+SuH33bHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU3M2Q2MWQtZmQxMy00MjM3LWE0NDktMDk1OWU4NzgxZmQzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2U4ZDA2ZWEtZDY3NC00M2E2LWE4NDYtZTNiZTA1YjQ4\nNGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaHMxsoIYRhfioAXok2odismI\nOS6G8ykj30z2tumeDsRXtfkoYUfZRsFy4LA940YFlKOfUauMcLx9iTcevRQguqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh6TRMoZxcNCMVBfOuCc33N9nZDowCgYIKoZIzj0E\nAwIDSAAwRQIgH2GQdX7MtXSONN3Do+CM9g9EphtD90u1Y6qlqsLgMKECIQDUOBEt\npPydYs76fQZHtjVlDGP36LhMBOxwIc2wWTIrNQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6606", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6606` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAczzpRBSh8iJhwUzhmbgV+THMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhYmYzYmI3LTA2YzUtNDcwMC05NmU4LTYxOTJjMzk0NjBhNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2EwNTIzNWItYTNk\nYy00NTdlLWEzMDAtNjYwNTlhNWU4ZTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMN8jzsHrG1rzJnGW+gNB8h7BymI1tGYweF/aOAnai9MhffJ9SDWCmWU2dym9\nZhB2ypLJEf98sblIsLsfxOyqBqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS++34iEYaNy+uSeSws4sHhfGNTEwHwYDVR0j\nBBgwFoAUVgN/903UZNZVZXl4w8DHk4PTrwQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDRbDIiXTcD9oF4FyXXL2MgvxUf6UcfpVSSMVt5kcd1QwIgWj7MzbXUoSZ0\n5g9Tbfw64s8EV+XlZQz6Zr3aEfLf/zQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWSLr3wYWceAFkSJfi8eW96EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWJmM2JiNy0wNmM1LTQ3MDAtOTZlOC02MTkyYzM5NDYwYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvcJyTMjdvzD+jIoYYSxkHtcIXMj5plBLSvo8BDILY6c6V\nXYeXJX+9kS54KkaI+QfpTR7WUzEdhlabV3tROKyao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVgN/903UZNZVZXl4w8DHk4PT\nrwQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdOkrrULytX+bKSEkZWpEGCK3JA7v0D+C7+u/P8WzD5gCIF1mBQM8RN7k\nnTpw0W2r1qrE3uR84MEsNXRKWDxEFhhE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZDuvrQsp49TYl6D2CKUq8B/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2EwNTIzNWItYTNkYy00NTdlLWEzMDAtNjYwNTlhNWU4ZTNjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDZjYzA3MGUtZmIzMy00ZDlhLWI1YjMtOTM4MWFhNDFm\nOGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn2IlnFJfxCQQLJIXk48242ys\nu+GbvDL6g7FzWLK/cl/6sjgbjFZyqJC3mfw5RgiLvm/EHdl+dXiSLQIR6H/e76NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUS++34iEYaNy+uSeSws4sHhfGNTEwCgYIKoZIzj0E\nAwIDSAAwRQIgL+PWq7s1cKlicRx7tenB+oVxxtjjfDbWIGbEZs3kAFUCIQCqZ8QE\nEUUWQKfAC53ZORfSCDY5kq7etHML6Up8ek8EIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6607", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6607` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISARCASH3gmAZmR7C2nYZcnu2WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmODhiMGYzLTE0ZWEtNDY0My1hZWViLTEzOGVkYjkzYTBhOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFiOTI3YmQtYzY5\nNC00NjgxLWE2ZTUtNzQ2ZWRmNDZhYWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/PHUpIcTPihsYO00yjWEwkiFjlcnsLaCZzWLMM2+8LZN1Un6yx1o6T7AwW9c\na4WHr70EFquoNUw7LO+y/HKOq6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa2zI/v+AuKZWmcwbevMeGlR0Ns8wHwYDVR0j\nBBgwFoAU3TZ3iyDJy6XCNCkgLF5BQMLkObswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBym3P1Cq2B5z8shSsdBBj5sH3AXtGY6kElwCxJ+B/EdgIhAOM4xKt+OKTi\njAG63gM/6Owo+CqhggGBcjFj7P4UJeZ0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATt3547vPWikKPKmU7N241koMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjg4YjBmMy0xNGVhLTQ2NDMtYWVlYi0xMzhlZGI5M2EwYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgD1hBM8xxcESkCkZEYmUhFW8ny/6pJ4cY9qfED9u1CIgQ\nhTSgmw2mFEQbD1+4fWOgpkHT4eb092Z15dOZ3NDSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3TZ3iyDJy6XCNCkgLF5BQMLk\nObswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfT7RauEHmCZ6simy1k1VW9cj5wnhSJ9QhQsJ5WbwOE8CIQDY66xJyiV5\njviPbYsos2JHsuHj5YvLoGCQ4FWJhrOetw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISASMK7MfNzea9yvWqqmZKV3ZwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFiOTI3YmQtYzY5NC00NjgxLWE2ZTUtNzQ2ZWRmNDZhYWZlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjAzODA5ZTYtOTA4MC00MTI0LTg2NjYtYjVmY2M2OWFl\nYjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPKUKrGXZ3GJm8P8xHUQU7X0Y\nhED7tHAGsxrK57YJuxArNMiC1R0A+YesRLsUfXLZabLI3A/BEcv8LzRHcq/9sKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUa2zI/v+AuKZWmcwbevMeGlR0Ns8wCgYIKoZIzj0E\nAwIDSAAwRQIgK8TksC0cGaZX7QwxewRZ231rIFUhQEvoQilAaB9y3h8CIQDyfkkJ\nOWp4nb6ZwXWa+mYtir1B4jeCrZM0Ra1/l1vKPw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6608", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6608` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAYkAH6Wt3EmVrj0N8i7jVguLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmMTAwM2MwLWFlNTYtNGUzNi04ZGFmLTUwMjhiNmYyYTYxODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQ1YmU1NTQtNDg4\nYS00MTgyLTlhY2YtZGEyOTEwZGEwZGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtErNTGsDHo6aoNy6yQuoAsirl6zFE+P+T8yiulgZ8DEratkko6TsdUI9avin\nDF0ccdByhkjyatL52V8Bn7sh8qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlAJw99VmoNeceifUnNQ9Xg81O6IwHwYDVR0j\nBBgwFoAUixxW5K+GHxv2J4PN6a9uTu27zbIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBvfy91SQA3Zmz5sfXFMxhnWBsYGQpzmeOu8ZwDvrBR\npQIgJzX/NIM30J9kzkUSBNH2e2y2Fx8x8I2iRFzsX0M0P2s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdPlu9V2HQVkRnNq9lfB7r0rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjEwMDNjMC1hZTU2LTRlMzYtOGRhZi01MDI4YjZmMmE2MTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuXTYsK3DbOMdXxa4h7XUoNiT0Uf7K55+CgI6T9Lrz+7jI\nJ4Qq6UMaelM9s/mXsYm4DVmAySVCTfeobja24oUuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUixxW5K+GHxv2J4PN6a9uTu27\nzbIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbxbNQtu4YF9EbkqohEiJWv3zRiT8/biT77zd66A4hAQCIDvdEGIS2nLz\n7CMhuhFku0LhxK0uUGKq+2Hj2H97Ka/X\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAbr/38JFVAGkGv27Frm48nfBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQ1YmU1NTQtNDg4YS00MTgyLTlhY2YtZGEyOTEwZGEwZGYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWI1OTFhNjctMGE0OC00MzQ3LWI4YTMtMTQzYzliOGRi\nMGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPnuSE0FfEAm0eGND7QK/B1+o\nMM+T2W7hx73pLWc1FlSH9b39EtyFkXch1JfbfphJPDe2GCRs9+vVhh3MrAaq9KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlAJw99VmoNeceifUnNQ9Xg81O6IwCgYIKoZIzj0E\nAwIDSAAwRQIgJ434kYOJ5S1Y+Sm9mSTlgWH97NCQBelt6H3peYde2jcCIQC7vBWW\nvG/UIdPkzbMWQMx4f6g1vxJPaPB94dzf5o/OAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6609", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6609` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAd4mALTh9n2/OhD1E/YoexUoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwNjFiMGIzLTk0NWYtNDQ0OC1hOTkyLTIxODc0OTE5NjliNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg3MTliNzItNGIy\nYS00ZjU0LWExMGMtMzk3ZmExZGVmNDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyV8ruNiXY9LYh71b510Hs8rRSbR6bYd8CSQAvEsvZ78i6M0SRcFryhMm6a/O\nAssqDQkkXE7BipsqMmUM1pvOe6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd0KZPHCDWe3GrcyG+qUTNjSlMcowHwYDVR0j\nBBgwFoAU5OOxVDucBz3xwoTkPacZnJGOIO8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBXZYHFuMRYsG3wEzPCuQMMX7aLjgy/VfvTFoscjGV5\nngIhALinMXwxSzGDatCIIiZV8AF9LOgMQMOIOy0ujl5iY+b1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaLc7ltRGfdz+VrOdSnh1C0WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDYxYjBiMy05NDVmLTQ0NDgtYTk5Mi0yMTg3NDkxOTY5YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRcBq3TEXrwM0qSctZXe+ihjW9L8lkiYivxJSipQ/sE0Zt\n1pAwUN6JblgjuH58IuOVllvskkc9md+kgSTbNu08o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5OOxVDucBz3xwoTkPacZnJGO\nIO8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTb68Sau8+WGcKgKCGE7ukjoNEBuyW84Dir336qphooYCIGoM4xFyv2Bc\nThtDYpO20x+wdDvPTJAmWtzs7kovsOiD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAX/9g431wS4hujd7AfZfPoPqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg3MTliNzItNGIyYS00ZjU0LWExMGMtMzk3ZmExZGVmNDcyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmY0MTI4NTEtODJlZi00MGU0LTkxYWUtMzI4NzdmYzQy\nMzYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeBGTCKv8U/2MiibyZXaMj47K\nn/j/W+U24/40mTvKLa2mG15NZfwAnmqWpL8MmKIQRzM6lHlXBDytudly/WKfRKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUd0KZPHCDWe3GrcyG+qUTNjSlMcowCgYIKoZIzj0E\nAwIDSQAwRgIhAKtBm94p5SBnps7q+7HcIjo2teTkmck/gGsITaPbKZjoAiEAlHCL\nY+RAzKo/8cxj14W98xwU2ir1G4OSrSLpv7KJEiU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6610", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6610` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAZnSi5PSSTh/oHreAhRkFvc2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjOGMwNzYyLWYwNjQtNDg2MC1hMzhkLTc5ZTAxNTAxN2M3NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU3ZmI3NTMtMTZj\nNi00N2U4LTk5NjAtZDVkNDYyOTJkN2MwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeLho98jGix7jBmvl4sK73OX+sZYmHv6M8zgFM/xrrYQPO4fO6lw2g9C7uRxa\nK5h4jaPbKuwNRC8oHWnpCM/UlKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3PWCVGrZNJuY8fdr578vUP25MlowHwYDVR0j\nBBgwFoAUuswLxDMQMb0IWQl2V7mQtg5qvjwwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAm2eFaQaKzdRAWSb6Y1m5TbvbvD0ifbCq5uHOSj3EK8ICIQCp\nPVfRZ7q0HuqOxupXtojLJQIVmpHICvEM65gea2DchA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT68olUze4yyXtDuu2wmylsHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzhjMDc2Mi1mMDY0LTQ4NjAtYTM4ZC03OWUwMTUwMTdjNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSMgYJrH9YpDSRdewkh+L6ZxQw6+fVghpqXGR0XLi5fJmw\npT+M2vbooWHMeL3rIUTqosjqko14UoHOBxy0epsKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuswLxDMQMb0IWQl2V7mQtg5q\nvjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbjcLpQuTDboS9XdqdUZPgVttzqXU+0jf+gYLxDVYeOsCIQD7sU9xSi6Z\no3VDkEcewiRLQlcceJe8tubkIIamynB2Ug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAZ/4rMaiT9QV4i9nqGSwX6x9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU3ZmI3NTMtMTZjNi00N2U4LTk5NjAtZDVkNDYyOTJkN2MwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjU5YjQyNjMtYmE1ZC00OGVkLWE5OTMtMjIyZGNmZmI5\nZTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL7NDe/W7yLRBs+9SBh5esWku\nOVhGQonV2uWaPNRF4m8163ZTsM3VvdRdYgPc943j3ZuT+46Wz05OkaONpF9nUKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3PWCVGrZNJuY8fdr578vUP25MlowCgYIKoZIzj0E\nAwIDSAAwRQIhAJsybgbBqFgEYogNjf6NxPVksTYbQ0WLYuxlRhNB5sZoAiAckHKR\nBFbZ2xahbpi7qtXrEHtOxB9fjyZyJ4wrSmwfiQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6611", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6611` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAeUX1jbtDc8nk+In4u8DNv5HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhOGRmNjk2LWEzNTEtNGMwZi04OTFjLWE5YzFhZThiNzU4NjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ3NzlhNTAtMDJj\nZi00NTE5LTkxNDEtMzg4MGUzZmMxNDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6JQXGRPOfx4vHbL50rGWoomgwLkgYYkf5j5F/XtNoJTl8Pmot/K3W4x+IjSF\npoHX2h5ClJELJ0oqRq8AAs8MF6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURVhX5Fy4vRNbhSJeHJbWl0FpoOAwHwYDVR0j\nBBgwFoAUvAZaq9bB0tboiTTfBXetINiYuWcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAgzMUrtJZYgXtRZTCaKrYl8gibV+Mgzsbd\nSrfGvnCjKAIhANco7CRmTM0FqF7nHWIxbByMc5jB3K+W/IPdb3FumJqt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfurOTvtA0Y0b42xPl8OyxDcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYThkZjY5Ni1hMzUxLTRjMGYtODkxYy1hOWMxYWU4Yjc1ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNw2JQJsDVgj639U2QXq9xTbvkW2kInY7aHiKDdaQpjvfQ\nLOQ7eMqZbuxhXQfro1Eqou/ap4Ww9Qwrz9/gdXqjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvAZaq9bB0tboiTTfBXetINiY\nuWcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaWC+uim2dfeKnBJpMSZUPQbuSa3z9Bb6IhzAPGWjXmUCIB7e8HpGrFuZ\nqp0rAujveuJwABVRWkQt4IzsusIzvgqR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAaulX4Ta3CjU8+mp5JdwNGTOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ3NzlhNTAtMDJjZi00NTE5LTkxNDEtMzg4MGUzZmMxNDZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQ0MzhhZWEtZDE2MC00ZWVmLWI2YTgtZGEwZGJkN2I3\nODRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElQ8akEi7/bBX9oLML1nJAE0/\niVbV8+q60T9HBc/nBMpmBfrrzK5Nkq1jJbbVsRWWHM/CCw+3cnKLN4a5CKpfbaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURVhX5Fy4vRNbhSJeHJbWl0FpoOAwCgYIKoZIzj0E\nAwIDRwAwRAIgbTfNc2P8aBDDwxez+Wk4MYp59HBAsliPoICEK+JJoGsCIEMNtIj6\nTWKEWdgvvKWdV3fg0M1ZyOtWCwWY/3betLGy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6612", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6612` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAfZblRhsU2MGIInrAD1X3Rh4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiZWUxNDJmLTk2OWEtNDBmYy05NTc3LTRhYzYzMjZiMjUzMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU2NDczN2YtYjM5\nMC00ZjI4LTg2Y2UtZjZhM2E5OGYyZTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcnOceNVCx75ZGXF2Fulh07PIFsLc/gTY2VM1sBCec07hy1iQt1B089h3AICV\n2lsdTLiciNzYhBYPDjTYUMLbHqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUub6Hbvrtq7Xb65bznOVhv44z8ncwHwYDVR0j\nBBgwFoAUoy9QpG+F7eRO90pWfWUHPxDbARIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA8w53AzP+BQvuGAOsb0OwQtb37L9Fwg353\nNHX6ks0ZOgIhANeVy0X5l6l/C53daqC3s9Pk0zu/ZgJhB9WHtJZ476UA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaximUJ/B8jk2Fwu/gn7vpm0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmVlMTQyZi05NjlhLTQwZmMtOTU3Ny00YWM2MzI2YjI1MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq+tw9bkXV9eCTMAbRVeJjyH8Ir+f+OJbqfl7nm4bf/Xkx\nx2iMeBAK6LIcM73ahXut71eOtgq7TsMIyMfAjLDSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoy9QpG+F7eRO90pWfWUHPxDb\nARIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0z/sXr479ZSj0HCmuP7PU953ES1v5znETsjf+rdQZvAiBGNhP9Qfbz\n/tp7cJvo3bLyrkI1Se/IwYFj9xwcARbHSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAfKP13tbs8sRXJKpEHrjZb+bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU2NDczN2YtYjM5MC00ZjI4LTg2Y2UtZjZhM2E5OGYyZTk0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDVkZjBlYTMtMjk1ZC00ZjU0LWIyNTYtZmVkNTQ1MjYx\nNmYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi2AV8cahNkqVQkk/ZTBpnw/S\nrl+BWPJ6xMhjZ0808kVyJNdGBQrcK3W+QKeQM1WLSNjZhdgHW5Og7N1+4oW8vqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUub6Hbvrtq7Xb65bznOVhv44z8ncwCgYIKoZIzj0E\nAwIDRwAwRAIge/m+ZGh/BZlE8gk9KYIms8XazZabSE9gxoOCQpz7wM4CIGvAHLwy\n9wWdaxuTsLFTBiFybc7yRCulChyzJjrcWfSY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6613", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6613` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARuGT/FuIm6TtJxmzRpgSokfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxY2FhNjZjLTNkNmUtNGM5OS05NDJhLTYyN2FiNGJlMGRjMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk1MTBjODItYmNi\nZi00ZDMwLThlYmUtZmJkMDE3MWI3MDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtzoiEC3JYoieYOeTkbZDnrMj+lOdeB3sQclNt9Bonqi58Q13VyfnWLgMNO7R\njDzIns+l5xGXnAGemXvhObz6CqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTgOa1fnH7BumXe2HsaiiEk6cgHIwHwYDVR0j\nBBgwFoAUwAxjHcFBEpBfqd2IWBYYBOhVnHgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB6R676DgAkqjWf\n8Pgv0XhZ/HFaVbpxiTgRrRUJlxc6wgIhALzAeiWtfQnOoWNR6BxFzEaVwtegbcUC\nFzDK5FdOs8tB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATSMWOlmRMGmvVYCIY94w6drMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMWNhYTY2Yy0zZDZlLTRjOTktOTQyYS02MjdhYjRiZTBkYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3tmBhlBnGNVlGsZc8ni7wFMtuFmRpP3d8BvFVG5pVO79X\nWGKqwMpZKqWwDW8j/M4ihsJ6NlkgTproLETbeHy4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwAxjHcFBEpBfqd2IWBYYBOhV\nnHgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIPOD77hU7Ukm0/qMxngk9NsiW9474kQp92i9KXm8L6DAiEAheYshGkG\nRjW/p1xEXLh2GSNxZENwxTqnWRrbQos1COA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAZ0bST/jVp+bccH1xKhJhIAMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk1MTBjODItYmNiZi00ZDMwLThlYmUtZmJkMDE3MWI3MDNlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzIwOWUxOTUtNmY5Yy00ZGYwLThhZDgtNDkwZTYxZDYz\nYmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEVx/avXv2umufnG3EZ87fBrC\na4tD9gy5Ft29viURUN8LUmnjqr+RVKr2Qd39NugSd8YedCOQ87bxxk0YNpIibaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTgOa1fnH7BumXe2HsaiiEk6cgHIwCgYIKoZIzj0E\nAwIDRwAwRAIgRS0Ni80t91pttH9YFwIqbAJ0Pfj0NJEvoc8syPkNoMACIGYUrIsN\nLM+VzQGURYXCq6PLB/gaj6ccnGGrOsj/43o9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6614", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6614` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAWayK/tMFDQG1I+z0O4ktGjnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1OTRkYmUyLTNkZDAtNDNmOS04ZGQyLTlkMTM2Mzg5NjkxMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWEwYTM4NGMtNjJi\nZi00MGQ2LWI4MDMtY2FlOWI4MDMzOTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3/5LlD0aal00hzxlJD9S7i7Nnac4Yksg/ySTvL8M7qv5ZszsKfxE4KS4Wa4m\n1CwUexfobCK2lJqWhGkK1zOLLaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtA/zG2+uT1E6QqcyMWZdDLheL9QwHwYDVR0j\nBBgwFoAU5yeNa68voZW7xrniE5RDrlOqSIgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCE3saIPqS991FWQKP9B5QhEOZqsHNZ5aR+ceYOrjv7KQIhAMSxX/YTtpk4\nv7YOjbg9uYW4jKEEm6eP7v4pNmz6eTNl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfDI7P2M26nJHhA7YLCltBfMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTk0ZGJlMi0zZGQwLTQzZjktOGRkMi05ZDEzNjM4OTY5MTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdEofoP8GGBUqX9B6Dia+7h5f2F8n+8JRjWkkD2320d5GA\nqydb+Z9RAWjfVp4exz6rMXp9SgMJ0cYpV2vrj/0Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5yeNa68voZW7xrniE5RDrlOq\nSIgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKGzuFHCoCx/HxviNRA8SMuDBaZ6ziyX6Hy80RCoDr5zAiAzEctaWNTQ\nhvvXoO4lX3EYJH/Y1pWSxdIQLaywwMXW/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAX1ylfrsstN2CfK4knhpxklWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWEwYTM4NGMtNjJiZi00MGQ2LWI4MDMtY2FlOWI4MDMzOTdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTgxYzY3OTEtMTM2NS00YTllLWI1OTQtMTgzYTM2ZGEy\nNjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk7JYMljd6C82kzalQhP2Na2Q\nkgQksD0qgxcV4MXuQvm7rq+BU7dzWBdVh//82WulnWYn/bKimkro+tQB8gE7+KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtA/zG2+uT1E6QqcyMWZdDLheL9QwCgYIKoZIzj0E\nAwIDSAAwRQIgTN6+MxV+CuCnsqqi0HL3OPzzqvooJ2jn8yKFRnXFsVQCIQDX0Sh8\nfEuxNWkKiLbGO2IElHLngkQzq34qcsraJHBnNQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6615", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6615` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATy+b+N4j4XPM3vh+LeP8rI7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2NGZjNzQwLTczOWYtNGE4ZC05NTAzLTZiZDY1OTU4OGJlYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY4NDhkOWUtMDc5\nNi00NTdlLTg5NDAtOWIzNTMyNTY5NzcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErQkSivLivRQrUl9ebEqXVmxr/ukNNQUltPG2vd4fzatCBpXL9BIB1vZMW3vD\nKJoiXe0HN7RUlvJf6PiVMSpUiqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURZjzoEan/Wf1zJY9JHhmc1OlteQwHwYDVR0j\nBBgwFoAU9D/FyxPhjoQJnDsmAkWtUsFDiNowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCbMDoCgt0Vbs2X5ACUHHKxXXY8dmV4jWagsR6y8VweqQIgewlAtb2G0TJ6\nevojqtgFM2Ni5XnbvlZ2MVg6XBku8jQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVTjg6NK7Pna0+FCc1BaVdOlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjRmYzc0MC03MzlmLTRhOGQtOTUwMy02YmQ2NTk1ODhiZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8R3sPMDnNUINaSuqarNOrDX/PvpiiKz+LTnXfUPr1jTZP\nmnPeJ19HYrJ/FTRjnZl0akaEKXv5J8/ItWdnyC10o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9D/FyxPhjoQJnDsmAkWtUsFD\niNowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMf4VEuZT2xIjS2OuHl6TAeY6dWzEE+FSTRdwyP7s8zDAiAfDh/Qf4F1\nCcqASjXsMpIGqr6DQdU1Wi7V13rT7TiTQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAaDN/pnN7uZ1N4H3ASomagsvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY4NDhkOWUtMDc5Ni00NTdlLTg5NDAtOWIzNTMyNTY5NzcxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYThlNTA4NGEtM2JhYS00MmQ3LWE5ZDctZDMxZDAwODQ4\nZDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKt776l39yAjazIAupzmyJiTa\nFVHsmhkZHirWK6qha2BsWSeYQEuWPua4i/kIUOkle85cxU/nO9eAxr/bzUJ11KNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURZjzoEan/Wf1zJY9JHhmc1OlteQwCgYIKoZIzj0E\nAwIDSAAwRQIgawiNvO8EiU6xtLRQMHz5NwPMHtQwvl+NUbcpFnB7rmICIQC547dS\nDyZHwD+PbimWO42jCa0ZfuA6fQNhBq5t3+rrdA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6616", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6616` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAfgT/1ThE9NDEhI6bT5L+IAAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3Njk3NTI5LTg2YzctNGViOS1iMTI1LWViNTA5NzE4ODY4OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQ2NjQ0YzItMWM2\nZi00MTQyLWE2MjItYWEyOTM5NDQ3YTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECyhVn95zppqu+zoTlVrvasKEsniTmvEFKimT5+AgzcNfsg9JsT9W+2J4XGx4\nfto77/qjy3uuKLAVC5QMBUXIW6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2DrAjF4teF2TfJ9Gyi2h9Uv7RUcwHwYDVR0j\nBBgwFoAUmtAHlpcdmOnC2g/+Iy2JGSKyMpswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAxP3dOsULTUSfsMUiBB8f51Hry0sBS6waQ9HDTwDMTLgCIQDtLaAXpQib\nB1Zf6YBKD4p1DBk2wNkfPSqUsditXq9zvQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASSUndAvVKHGQo0WAMPxt9i+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzY5NzUyOS04NmM3LTRlYjktYjEyNS1lYjUwOTcxODg2ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5Ru8TNXYvFum1e93BzLTha5HCaYVDDGvnRzXKLKUzackz\niiw8tFdlXO7hreSpJAnwknlidfUZZQp+bdQgd26ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmtAHlpcdmOnC2g/+Iy2JGSKy\nMpswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANa9XsUKhwjYVFwfH8IwYo6TgpE954hC6btheHlF7lhCAiEA8dMWIdl6\nB20NasPFjqcNRIeV7r21xP3TjiNH+gGMc6M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISASqhQ3355h3yJno1ejNWrhyMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQ2NjQ0YzItMWM2Zi00MTQyLWE2MjItYWEyOTM5NDQ3YTgxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2EzZTIwMzQtOWFlMy00ODFiLTg4NmQtNjMyMjY1ZWY0\nZWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4m+Z/2GIx6vXLwnQuIqDUn5U\nT3wLLZhmp5/9HmTm0hzmssDz6JaTY89HQSiiH5aoA/o1NemNNceLeq+z/VbQW6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2DrAjF4teF2TfJ9Gyi2h9Uv7RUcwCgYIKoZIzj0E\nAwIDSQAwRgIhAPyklskEXYDKlUC6dTNiEuPczvKSnfCQl9iIzyLbyQBVAiEA+f9j\njnGYXSPHwzBRvhy2rii3o0vvPObwFSSIOq5jZFs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6617", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6617` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAV0rOVGNvoB4hngm4WwgfQNaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhZDQ0ZWY3LTMxMDgtNDRmOC04MzBhLTY2OGQ3NWZiM2VkMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FiNWJmMWMtYzcz\nOC00YTA4LTgwYTItODgxM2ExMzBlMmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp83tNS0qpX9v2jxBI4iRdsg6CUle1V8fpAeD60wBwAaK0BiDCbBtyL3LuDnI\nokPf+iLQgip/qj9v+kBF1tRbSKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdVIhsQu6veakFM9RGld4NgmtXJUwHwYDVR0j\nBBgwFoAUVM/nAqvATpDGyGOYEVrnEwB6goswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAMqq57LuslyZ0rfWvuGIwV/9TsN6owzvP/n1hBkNpc\npAIgVw8GUPFDE1QusIRcdU8Uxym3zE1UqDfO8XOtJjEX3hI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASimCjQQ2CQ+aB/dicwy8H87MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWQ0NGVmNy0zMTA4LTQ0ZjgtODMwYS02NjhkNzVmYjNlZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZYdy8a6Xs/2q553UjPPSetyx8iRRiWqTNBBvobuavj/8z\nymd60qfb9IZncVIiMvY+wT+XJSCsqw2KsSzVuwCMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVM/nAqvATpDGyGOYEVrnEwB6\ngoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZNdH5/QmBzfsanjww/sw5MMi51dvkJVYuQO5XFEjOn0CIEXCOoSbPZMu\nk9JsRoi+WiAE7Aw5xbyguZS2f8rI1vBZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAcG4IV8WgSv5edgYXcN/7zx0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FiNWJmMWMtYzczOC00YTA4LTgwYTItODgxM2ExMzBlMmNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmY0Zjc2OTItYjRlMC00YTU0LTk2OWItYzg5ODgxODlk\nYzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0uAqlSM0EcO9OfxDP0mC+LcY\nm9PtsWV6On8nnGPgzaxfcG0abKAhoTU49xbw+K6eX/JZW4XTunAiitt4nACIvqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdVIhsQu6veakFM9RGld4NgmtXJUwCgYIKoZIzj0E\nAwIDRwAwRAIgK0BR5X9LEy+O9av5JhFFfOXKgG7K/Mk4ICKun9DOtIUCIElJ9SH2\navVLlLv/HGIMRGUd+56VlQxWaupY8XSnHBB5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6618", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6618` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVUHkAZxEEOsVaGV/ZiQUAfiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0MWVkMGU0LWJmODEtNGQ0ZS1hNzYwLWMxMWRjMTVhOGQzOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZlMjhmNGItNzAw\nMS00MzE1LThlOWEtOGIzMTE0ODgxM2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETjPTTBFXs5ESu67zemgZeJIrUgHYML8AMvv7D/Gf87ouzc+2l6k2IcFxlblq\nryb2/SV4jK6oylvH553qmKnbvaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzbzUMUwwi4jadiT0+btGdnnqksYwHwYDVR0j\nBBgwFoAUyTQuPSieYv8cNR6gS9YCHDntgOkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA9zw6MZ8d6Y8+6OAdJ7rlJeG7Dj/gGyDlz9h1PMfk\nU+wCIGnv2OnS3ryvOT6yqcAZ3aVD7Di+lf4E4HGJJq5exPAk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfgNwSzux8tzZmZ6s/Z7ZASXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDFlZDBlNC1iZjgxLTRkNGUtYTc2MC1jMTFkYzE1YThkMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR0MM1in74TpEgPUf7wAE5zqOGf26OoYekvXJtFrf8EFnE\nDGmfm5GGUd3ry9bVgC4GRFLARk+rc5NECWo2DwIXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyTQuPSieYv8cNR6gS9YCHDnt\ngOkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPDTYykZr4Ef9IERBx0TmZwYjYeor1svWfIZq8HwvAZIAiBA3+r5Y/7Z\nRUxyPeTxFyc87Y0x/YGaSrXjLaVS39Egig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAa18rFTo/HNEYSSOQgXsdkV1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZlMjhmNGItNzAwMS00MzE1LThlOWEtOGIzMTE0ODgxM2QyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTlkYWQ4YWYtZjg2OC00YTQ5LTkyNjQtMzE1Y2FhODBl\nM2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMPx/IAOf7+oLJe3v3xF+4WNO\nxmw1/kFzHdxR9yv90qFLMIfsrt+Fmoyep45yHggP5PpW9/sJPhRnRqimOiNo5qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzbzUMUwwi4jadiT0+btGdnnqksYwCgYIKoZIzj0E\nAwIDRwAwRAIgIbk/zaG9iJJbptpdQZVTxU4eI0VHAaUwFOTu0j7AwdcCIH41ewXQ\nate1LvnF2rObUd+H7h1tmhUOD552i1fxRmRy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6619", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6619` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQC+tsU3wM3k3FU+1PMXjm5xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2MWRmYTE4LTg0ODEtNGEyNS04ZDRlLTUxNDY1MGU4MWQxODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc4ODg5ZTUtYWI3\nZC00NTAyLTk1NTYtOWZlMGQ2YzA4OGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa0Xb7E+rIGpvjB6NgUM+RM8hlutU5vKVKC2Gu22g0I7zayYqzRpMz0zmj/Ze\nKXGUVG2qd/sAIoa2WTacq/mMEqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm1Zv/C9Net3PIkxcrdTs/Z5flJowHwYDVR0j\nBBgwFoAUxvwU9/sG9ZB0HDGaC8rzD9jXUNQwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBO9a5YXunT7GpxYcrEHe0ryJpIqIDc+k/fK5E747OObAIhAJIU\n3mRWIoIL9M8PFAFuIlMqI5MZpzeNSWuIGsa4JIzI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUJsHypign84IT5SBJXkr7dwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjFkZmExOC04NDgxLTRhMjUtOGQ0ZS01MTQ2NTBlODFkMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMOPX70GNOQxdV9/ADRJwNSaFxtpVDibstKLp1JZVWCjNA\nvDjsR3T+ngnkuFE6heNhNrcZSPr73jZtnbhnelLgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxvwU9/sG9ZB0HDGaC8rzD9jX\nUNQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYi+4tGap5BZ/z2HRAjoxdziori0SpBQVDoYHM6VKM5sCIQCj0NTqMNzq\n0BLrywAhwAhFR4+6n+nqsZfH7TfgNMKq6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISASLWx5Ks9pJr24BP2wupAEVHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc4ODg5ZTUtYWI3ZC00NTAyLTk1NTYtOWZlMGQ2YzA4OGVjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmJkYWFlMTktMjIxYy00NjNmLWJjZDktYzIxYTNiMzA4\nZWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPTfHcUGZo9nIMAKivhqOXCnl\nobTA0Ofv25U3M7vxvEiSMHv97B7ykga4Lh9I1yRbQsLHpdcgRlF2fz837v5xeqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm1Zv/C9Net3PIkxcrdTs/Z5flJowCgYIKoZIzj0E\nAwIDSQAwRgIhAIXeFDbCDG6Is+AeUl2oWViq3aCkNaRmJ8SZp6HvNtksAiEA/es2\n2yEN8s7/hPhaycbrqgNPyjVwBN5bmuF935dKCEI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6620", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6620` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAbvwnhCYYmtvqhKRFf0Z3uEEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0MGIzNDBjLWViZTctNGFiZi04MzZiLTdhZTk4NGE5NzRlYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU3N2ViZGUtYzQy\nOC00YmJlLTkyMjAtMmYxYWM1NzllNDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuYG9itXjB6Z238oYouajm8isahYMXLU3I6mTpQ0pNMl5cOqllR3BtwWktcRD\nmewTFATRHoKOPI02NyBOGh0QS6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuJ89VioI3O5tyFd1iyZxVnEc79EwHwYDVR0j\nBBgwFoAUZ0T8jpn9yaDklWhLuBC4O5s9HW8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA8vYh7aqA0k6/UW7DXNhQ+M8Fv6CEo5Ff\n5dq2GY794DECIQDpZlDTmioNf4kJ04ZQypvieNI+gKx0ktWBLzvfkhdCmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUYo4CRHuR31yoWZt4mrKBUsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDBiMzQwYy1lYmU3LTRhYmYtODM2Yi03YWU5ODRhOTc0ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBB5otMAQVZ2XPSGJH24mr4ZwbycyMSfKlDe/y5/dYvZWu\nMTk2kdpJLjvAVomAixGS7EdWz9w1Uxb9uJ2JSFxvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ0T8jpn9yaDklWhLuBC4O5s9\nHW8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOTmPcA5Q+2DIJ+VH5l0TVa1j+INt3eJtHNyB/hVD4mbAiBkyjEY9THN\nWEL1LIC8yqMvSzCxzhqMXZ173+GWR55q8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATH0T+9xrDPg26vk0vrdYa6SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU3N2ViZGUtYzQyOC00YmJlLTkyMjAtMmYxYWM1NzllNDYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDA3NTkyMjUtMWFmMy00YTY1LWE4NWItY2Q1M2U5YTcy\nZTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEswLeOQ0p3/zu2s9Al26rGB6D\nWm1bgtRcESWfTItrekhrGKCv+kMl/1e72eGCP/dzQHMyGFpSXIUxtMx3RmLna6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuJ89VioI3O5tyFd1iyZxVnEc79EwCgYIKoZIzj0E\nAwIDSAAwRQIhANqJa1no/Z8BSDuvoE8ruofgIYzmOX2HCIGkGwTAdWZ3AiBhk0sp\nDjIV7ycQW/l3QVCp5zK2cLefBQmTWVZeVR60qg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6621", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6621` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAaffc0NnI4WnUM9SgoLeILpsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NmFiYWNmLWUwNmQtNGFjYS05YTAxLWYwZTdiZDliYzQ4NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY0MTAwYTUtNzk1\nMi00NzgwLThhM2MtMjY1YzUxNjM3YTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHdm2m5s7dXnC0may9PNS0dh85/zfIJENn+fI8YuD+2uKNp8JCl2s8Mxwd2md\naXeYCeQJ9nnwtkXJysZUzl9i3KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmzTuFumM0ZKDoZXAuOTNdssp/vUwHwYDVR0j\nBBgwFoAUtOE3avnUvawHAkXrlPeAswh5p68wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvmdeXbA5lQrOEUNm3eUHqtfmkHoR5VKu\neqQ6FegeGrMCIQCu2Q40PpOQ3SQ+yML8xcqqx3Y8Vr31BpEXF6usClcYNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWKSLvGV5iDQvKwtAwF1QZLvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODZhYmFjZi1lMDZkLTRhY2EtOWEwMS1mMGU3YmQ5YmM0ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtvGa6kYpOWL9DPJDf9nPk9A1cUMfq8HF0AoIvcw79VuZ0\nXbS5L5IS1ixF+5OjNaicvvNaAHasAM/PFY45NTmGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtOE3avnUvawHAkXrlPeAswh5\np68wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNyEt1Mygbj78zMBMuxCrZMFC3TECMJWT5t+bZZr+DfICIGmPfTKzEJtE\n4rPlusNCNr1UraLkEpRroNHzdGgSMCGf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAYIpxMHU7bwnYSAT5Ou8SyTdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY0MTAwYTUtNzk1Mi00NzgwLThhM2MtMjY1YzUxNjM3YTBhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjNiYWNhMGQtYmFiOS00ZjA5LWFiYmMtOGNmM2RlMjVl\nZmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZ1eoee+ldaEij+unYcAcuWLd\nKbMN68IVmbV1QzI2oz+8BJCjWG8hq3usCQjjnmgHW3jNLPu/NsFivL6HhbheXKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmzTuFumM0ZKDoZXAuOTNdssp/vUwCgYIKoZIzj0E\nAwIDSAAwRQIhAMy1OL7nRJG3CSP+NebKu1hsGnCUoUzS24OKiCjtXMa8AiBsvkEf\nmBVbo8sGd5eo8pBU++7wX2zy+orGR+FbbCvD7Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6622", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6622` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAUSLRn0KmBTbXxDZTRFtgqg/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MTEzMGIxLTE0NjgtNGUzZi05MWI4LTYxNWIxZGQxYzA5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVmZjk1YWQtZDll\nYy00MzQxLTkxYjEtNzA1ZTVkYWZhMWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExl3e3FCHa/00snAqxWN4pT9Er/VnbjMph+DBary2Vkq9/CGw9xGcQKci8gR6\nOD/7SqbQ8rJzQNMczZUc3/+oJ6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqRkXdqXve7M9kdfLEVk/WRTkMCYwHwYDVR0j\nBBgwFoAUsqhA9DIHqL5u7u6h/gYTkZYqvpowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDe68/CnzaXe8qulbE6Hf/K+J5xz\nqYnKpN04WSj2jd8CAiEA/eNpEKk1dHfOXXr7617rNXgBhM+Fb5Pc3km7CvECZ2c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARRRPZ7afX/Ouda0D4He6gmBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODExMzBiMS0xNDY4LTRlM2YtOTFiOC02MTViMWRkMWMwOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9y5bak1boidwNimWyDD8gLgJaNRLZQsC7Hg0qZcDxMa6x\n22xA48ffBWGquqfUcETAgR9q8RkUBMy2R6I2upW5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsqhA9DIHqL5u7u6h/gYTkZYq\nvpowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMKSNE+tEPgeqqB+qPgMlNckb59WvBiwFLXdUc5IQuw8CIQDhPFzrPoDY\nA/l2vHO3rCB7KM5hMCSYSKXTZ49bHnT0ew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAX/znn1KO0RZgY2vf+YmMZrnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVmZjk1YWQtZDllYy00MzQxLTkxYjEtNzA1ZTVkYWZhMWQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjgzODc0YmUtZWQ3Mi00YjhkLTg5NWQtZjFlMzIzOTUx\nMGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEz0fBbsQdMWyFCMFFlbJbv9tb\nvvoFjPcZykdVCgdNxcCfqU6BeyEq4vPL9GQ7ayu4Tdhu4Gujd+9inkbzpngYgKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqRkXdqXve7M9kdfLEVk/WRTkMCYwCgYIKoZIzj0E\nAwIDSAAwRQIgZHTUGiox2YxiG2ueKcolnR19gFoRxgjPaA3zVF/lso8CIQCJ+Trq\neVRgE7njNkr3/2rjr4hqbrDy8NLZkD+7mlz9Kg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6623", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6623` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAeUk61B2i68awLMNz4g89JjcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5YzMyM2UwLTdiZWUtNDFkOC04YjhmLWNkNzM3ZWE2NzRlZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQ5YjY4ODAtYzUz\nNS00Nzc1LWI4YjgtMDVlY2ExNjJlYWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa4bstZ/U7gj2b89B3GhwMFJrcveqZxRSbLFqaUwYhP5mjKCNhP/TV+9OlgAH\nyllRvj4VJEqenOjCppdPwZx9y6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJlX8JDv1rTIpFBzWMiLuFqX0gVswHwYDVR0j\nBBgwFoAURCtv7pg+BCmeHTGC5lYaagzGamkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMC7AlZ4\n8Qo9OL90vo/nOIXn2SZHO/XVbV+HpjUkDJ/vAiAmpM4x55sY9jbUOUyMFlGHB4om\nuF4ORvzfbXyyXAlu8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARur4W/rVQVA68MbcdmABFw6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOWMzMjNlMC03YmVlLTQxZDgtOGI4Zi1jZDczN2VhNjc0ZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJIe2kVCk/bAWrEIMdSiH1GEAlqmq6ps7olGnSp2js6hQT\nTXLDqqMTyA9cGtZgudumcLtI+mu40AF05fEBf7zpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURCtv7pg+BCmeHTGC5lYaagzG\namkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKaH7crCt8oejkoVSKwQrM0AJ9e0IZJ4EH05KgsBp2o8AiBroNqeh8zb\nhjkY1hwXHbqFm3MyvZTqdCWqPrILuOJnKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAZhIrqW5GswTvI9Fkjh3rOXxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQ5YjY4ODAtYzUzNS00Nzc1LWI4YjgtMDVlY2ExNjJlYWZiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjFhZTE2NDktMWVmNS00NDQ0LTk0ZTEtZDhjZGQzOGNj\nZTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiQrosmJrogAcJ1G3uOYN+/RQ\nUuWWwm4sLwSJiguIYoe+9h5nCW8i3SdC6jWEqHc7EbOBJG09NzmnNcfcTeapSaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJlX8JDv1rTIpFBzWMiLuFqX0gVswCgYIKoZIzj0E\nAwIDRwAwRAIgAODVigEqIV6A/jPQ+749XpIRPoKyOUZ7w/4sc3OeJAwCIGDu6fYJ\n6HnWXI3GzuQJOePa2HX6wqcOX9wtqX13cNB8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6624", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6624` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAUjbhqp51/Yz+G7h+6jLmT6/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2Nzg0MTA5LTYwYzctNDEyYS05Yjg3LTJkYTc3ZDU4Mzc2ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjIwMzAyZTctMTFk\nMi00YzE1LWE5MTEtYjM4ODRkY2Y5MzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEon3daF3oRKbgQQtsT2YUd0t4fcI5aLWKnEL/uKeDTpBxR+poPOv6BGMROYoa\n/8tzg9+s8cg7O2ucFeAm6BBzKKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+rANZAVLx62gVg4HYfDJz40Qer8wHwYDVR0j\nBBgwFoAUCub6dPgPL3SCtx8ZdBNNQJYvNgQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgK0BStdJv\nA0RbAdh94FhxALyGVa4a7Y79HjbVO3MpcG8CICzD2xKVF5u1bmLWWotHpyzsatx/\nmZ/A2vyXTpsVsGhJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeI1UvY+KZ71BDqeuvFcFJDfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjc4NDEwOS02MGM3LTQxMmEtOWI4Ny0yZGE3N2Q1ODM3NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIM0XxPT60fpX5VwZ4QmIC3WBzmrmhJRH4QD4yxzIyCktG\nxs1zsl1Lpi/MvcK8L1OrpDECGjRAoq5mws/1jsGfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCub6dPgPL3SCtx8ZdBNNQJYv\nNgQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSVJOjeLu8QZzW8a8Yp45jt/E73vcE5unSF4gKVD/Jy0CIEldSMbDYVyK\neX+7gf21TUADTLBAJQ99eqUwCipkkicZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATJCaGjUBiXtBBPYqHMqsUnMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjIwMzAyZTctMTFkMi00YzE1LWE5MTEtYjM4ODRkY2Y5MzE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjU1OTI3Y2MtOWFhMS00OTg1LTk1YjYtYjVjNGNhMzM4\nMTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsJ/MgAAliIPmX+XQ0qnadtW0\nuC+hfZNQXGi2XZ3veNqZMvuWu1V7e3z6vxzUm5bLqzgsNPbkN0bjwjajc2jtw6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+rANZAVLx62gVg4HYfDJz40Qer8wCgYIKoZIzj0E\nAwIDSAAwRQIhAJAtDxAWDF5tBtVHHhU0Xtiw6YZdkQ7RJcVudQwoerkOAiBhbCS0\ndso3Qi8evZW5kRh/FTSchkdISVK92mgCURiWkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6625", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6625` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAfBpNkemXHAHbjBUiJJxw67SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmYzhiOWM0LTY0YzMtNGMxNi1hNGE4LWNiMzE1Y2EyMTM4ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWY1NDRiZDItZWY3\nZC00ODZkLWJjNzctODNmODAzNzEwNjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExjO8uGTHP5DhkxA2yxX+pCjigALxL9T5w2bBD1KH0gmbnMwZfC2G3AF+STBj\nTf4FIZagErGHaHajKF+b0BwJDqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgxxD53LOVNnvOdoMlbpnOfu9MqUwHwYDVR0j\nBBgwFoAUNuIiNgWhFCQFVdaERbLIrX87GUswLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICeJ+P8b\nDcMSqg/xsxxn4zEAevLtsqshKK4lKz6J5ZD2AiEAgMNjqjRL/NQa1rhzn/CNBSmw\nEEbZWIBlLfLnhoFsh2k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASfa6M/OvGXSBzjvRW2fn/ltMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmM4YjljNC02NGMzLTRjMTYtYTRhOC1jYjMxNWNhMjEzOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4h4EksfWlL3FvnkSX8fQPW5DnpEoMWDPFE7F38NDFc3ul\neVu4UVBej6LY6KR4Lg0lK/224BXAgjUw8uDiP55Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNuIiNgWhFCQFVdaERbLIrX87\nGUswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc1RjFxh0pUgDyNwWabi4KV01uzRcAcs/NVIA2VGcXVcCIQD81WodVW5m\n+4knD/UWgInfgT5gL9XI+RG6LxeQmRQwJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAavvrMeJe6oVAcPW5YOAZCcXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWY1NDRiZDItZWY3ZC00ODZkLWJjNzctODNmODAzNzEwNjljMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzU0YTcxMTQtZGRhYi00ZmVhLWE3M2ItNDVjZWM5MzU4\nOGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEogdNq7jncbclpvswQxxXRpEL\nNSgtNACM6mjyFSFUylF9EZ82WGwIRqDWzuY5kRosbindK7eT+8L7FZKt+Ev8F6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgxxD53LOVNnvOdoMlbpnOfu9MqUwCgYIKoZIzj0E\nAwIDSQAwRgIhAJtr0MDe018gLZZkh7CAWIrOH/Or/6270LrSZGKFe0a8AiEAyym5\nPgNk+tYaaDj4Jy21Q1tMhX/MXXJerk1YyC6VUoA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6626", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6626` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdkZwbDS1GZQdw3HarAlhRl6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1M2FmZWU2LWNhYjItNDJmYS1iNjc4LTcxNGNiMTM4YzY4NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFjMmFjNzQtNmY5\nMi00MTJmLWIwNjUtOWNmNzFhYzkwZDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEinKu+6LGPNkX2A+HwigRQkIHwL3LdgVZ4+Ws7G3Wv32JXQ5jjWMG/iojjZXE\nIMhOxS8yDVoRImC+LMAXv28nwaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURWlo80Y407OFObpu8jtx6FCCpn0wHwYDVR0j\nBBgwFoAUGGWX7LvZn3VWtDEmQ1UN1RSseA0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIE97xoByf+UboAtOBwzSfFxA+dekjbBC/bLv6ruyQONkAiEAsTy97uQ6\nwflmaAIoyxatCAU500bWViBzwkAgJV9j3uw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARoBYwk1chRGF6SB4Z8iXzrEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTNhZmVlNi1jYWIyLTQyZmEtYjY3OC03MTRjYjEzOGM2ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFN4Ta/K3Dg3mcw5QorUyHOHuEmNputsv2zs5KFe7Sxt8C\nmJ5FBZbNpWK3BGSKKzN2kH3R0TgMOflWUXHPMhCUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGGWX7LvZn3VWtDEmQ1UN1RSs\neA0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIjnLfU4GB9aWnCb88wrSWt3lsdmMsaoq3vcmBYa10jcCIAOgybIR7rDC\nhPgqJ/QJHuPbaTQfFwiU+HP/j9KPYPsV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAVj3OsMTugE9NrgginTUC3bAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFjMmFjNzQtNmY5Mi00MTJmLWIwNjUtOWNmNzFhYzkwZDIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTgyMTRkNTYtMjdlMy00NjBmLWI3MDMtOWI4NTZiNmVl\nNWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbF2EQrOk2UHYWa2bWdiHfL2Z\neACr1AIJN0qezcVYzAAnY7uTyKse3/jIL4isC4dI/QYVBt8f021GyJB8IVZhdqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURWlo80Y407OFObpu8jtx6FCCpn0wCgYIKoZIzj0E\nAwIDSQAwRgIhALePXCmFguVuptdUSNoqoDx7SejDWY7bLvtUn/2sBQCiAiEAhHgL\nPYvcW9qPqGNpiwxeNeCGzuCzXy4pF9dlN32HoV0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6627", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6627` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISASdHi7+yIeQ0whRV+WCABFZuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhOTQwZjM0LWExZWEtNDNkOC05ZjAxLWIyOWMyOGE5ZjZlMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM5ODI4YWItZGVl\nYi00NDI1LWE5MzEtMGQxMWI3MmI0MWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI/oPtJZAtmpYE+3MH9/hKf9D5xW8h5f9+HAydI+TSZfFLC3YihpcFl9YILKv\nqlLq4IWsXOnaAGhOT55sqAwpFKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoiFZrzawWJE6IUjzNLv2Tu8pWdUwHwYDVR0j\nBBgwFoAU4vi8OVk3OzEeMw8MouyFXPX2D3swOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCwHVO8nBhNDptJ4aSsFk5e+kWjjxVkRZxv6BdY56dI1gIhAIu+Qd3V\n+h6o/I7JsdvBJWga8Y2hSyr0AXzRkTgVRB5x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX42dMluLLX/wLq7Z3dMCGoUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTk0MGYzNC1hMWVhLTQzZDgtOWYwMS1iMjljMjhhOWY2ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/TpW7aw4TldAo75NbxqQhnpKX+gkC2h1ZbN0o1UT2y+3B\ngv8gU73BF7p7AVJd4yACNfyFb10g/pcXaLcMm9Rwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4vi8OVk3OzEeMw8MouyFXPX2\nD3swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIwwsMURYJH83UZZ+T0/EsihOVr+XllMrjIFMh2p3YBmAiBRIyfPe8Cq\nAU59Ab9tZMEcJUPD2NY2sNFkLyUrCWH6bQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAXi6PResoSxiZw+kazb5PHWXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM5ODI4YWItZGVlYi00NDI1LWE5MzEtMGQxMWI3MmI0MWYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmYyZTUwMGMtYzA4NS00ZGZiLTg4OWQtMGIyZWRhMWQw\nZGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE581ebCXymxuHCm4eIPA13eRa\nKCgTLSXOW8KCeDe3RBVgiZHumslERNpoWhTY/06jbv7yM5NOvxHSdnp7JgAHcqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoiFZrzawWJE6IUjzNLv2Tu8pWdUwCgYIKoZIzj0E\nAwIDSQAwRgIhALBsw97CgbzXyq23PauLSEqBqg5OYYpx1ySkvkQRI5tZAiEA7DHq\nxDlWsWxSeS27Eih9aFXRGHkz0INTX8QDv4Mvnw8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6628", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6628` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAdAxcKU+/PahTvbgwucdnP5jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiN2RhZThkLTU5N2ItNDM1YS1hNGI5LTAwNDlkNWQ0MDRlNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIzYzYxNGMtNzM3\nZi00OGU4LWIyN2EtNjQyN2YyMmUyYmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnkYG4Eoj2Wgd1uHN8Ou7zdYWZQXZjzS4cOTENLHmTYtsweeoUqkf9ob9P+jl\ng5XZGoD06laas2SY5BSjw06CfKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM3gSk2R4kfVwyd5wTnLTdCvLe1YwHwYDVR0j\nBBgwFoAU/+E/MDBMYJt+alI/nl4nVDx2oiswMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIDZvaixrbDBZrARi/BN4462e5huvf/AIyWOj7Q8QtCZWAiEAs0+oSxTMS5yjfh/F\nxv7ONG65tRV04exo3QRW45TlF9Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcSkd6To241JvIlxyQPVSbTbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjdkYWU4ZC01OTdiLTQzNWEtYTRiOS0wMDQ5ZDVkNDA0ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQB76wM9u00rB3IW6EmQd6PHbiQC3oi9NKmNw6zUFWEggKi\n/jiU3GFm4vUick/WwVphAKr+hFWMwhOCXOOTlF45o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/+E/MDBMYJt+alI/nl4nVDx2\noiswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOz3N8ENYeZd3gNLFbbr8uOA2ifLUOI45CX3hC9d6EAGAiEAxd8kVB++\nKMAvW0Xwyme6vbQmI1beEVBpYHl08yEdYMg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAUGkELuafX+Cw5LGI5Hrs5XwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIzYzYxNGMtNzM3Zi00OGU4LWIyN2EtNjQyN2YyMmUyYmM3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOThmNTM1Y2UtOTk2Ni00ODFiLThmYTItZTY3MmYxZjdk\nODVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUYYIhAvby9kkJYL+LZR1jWBt\n6RyihvJ7Ece0OzoTA3/3LeG3X+sN5jHXDWt12ilPKvS9iyFOK2DKc3+YBPKxPKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUM3gSk2R4kfVwyd5wTnLTdCvLe1YwCgYIKoZIzj0E\nAwIDRwAwRAIgYT8m+6+Rk+YCx/5RVBFzDhifZIqEb6oHREef7/xl/u8CICieV51s\nQrSIITjCvMV0vdUSFpVByqWWndbn2oGuhC0j\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6629", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6629` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgKgAwIBAgISAYmpbq9l/oUtVc+JYbE6hK6XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2Y2Q3ZGQ1LTAzYWItNDVjMi05YzZiLWI2MWZkODFhYjY0ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTRiNzZhZTAtZTYy\nNy00N2IxLWIzOTQtNzliY2M0MzgyZDQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp6CHZBGY0bsL+nnG2vBLt9hZPYdNuYAqiX28COtgSJWUEQTT66ZU/LcamsBS\nJ09tokQlz+LYRPNg1iY1tXz0BKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1GTDTIpDk6CcxrSV5/vfEGHX8kwwHwYDVR0j\nBBgwFoAUbH0ojEY2MFv8QTceNoQrwgxMKtwwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0YAMEMCHzFy95CW05Qmp93Qoc14La34mJFIQxGBskyFunV9UdQCIBKJ\nNEdOJdgFsF7ieosnEwIgJUEg/ya00f1MrrcyjWeJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXkLrAoi6XzdeigdBPGIkuIrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNmNkN2RkNS0wM2FiLTQ1YzItOWM2Yi1iNjFmZDgxYWI2NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPY5+HHhv/Q249s9Vg/aMK0oalIf6MLy0vWeZPQhdn4Cpd\nWKvBGATW/pMcZiPccD+BMgDcfu/Gu9hNc1/eIaG7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbH0ojEY2MFv8QTceNoQrwgxM\nKtwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJqSQv2WZXS/irO9Ftc+SbS/+SeLREjx6ocfPELy0vbmAiEAgOLoI8a8\nJv9QFWk9brfDfOzPHLPxUp2f7YvbjElx+q0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAQWslgd7zo8ErvwXM92BBUlsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTRiNzZhZTAtZTYyNy00N2IxLWIzOTQtNzliY2M0MzgyZDQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODIxZDk0Y2YtYmZjZS00ZjcwLWEwOTYtYzQ2NzM1YWQw\nYWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExbOlyznkrwdnxV/QtMq2EgUI\nKM/3yjMV/opVQS0lXGPijOK90TYSemf7Nfp+Cd9cGv9BAjvLFoaH2xHtFG6jW6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1GTDTIpDk6CcxrSV5/vfEGHX8kwwCgYIKoZIzj0E\nAwIDSQAwRgIhAKNYXgORFkxLw/mMl10uIFFjB1IkvlFxGijKOG+NpFxFAiEA6usP\ne4r0aBeioHfkvgeaSaaOLkbbDVPOapseea9TbmI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6630", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6630` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcj7W0w0YFEJqDk6Aj3k6Y4tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkMjU2NDQ5LTc1Y2ItNDVlYS1iNTE0LTJhNTUwNDIzNDA1YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI5ZDg4NmUtZGVm\nZC00OWJmLWEwNDItYWQ2NWY3YTk1NzQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4AyC1Z4tZnmas/bPN2AH5I1pq8h6KAAIKUU/VEdqJ1rV2yGPLaOeuPvGAanF\nSTzCgiIGfXv94dl0xEKvVaDh1KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfixTcySIpv14gHpvTZvCs43C1tQwHwYDVR0j\nBBgwFoAU0q4FLYilywDDfSW//s5il/5UTt4wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIFEjXXqpYAz9b9WG9ggA0+l9wJNKkKnuqn1kChlivDFGAiEA\nhkIjoAT8zS5XH6JJ14nFpXeGDx+9xmqM8RVS2GZDiwQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASRfWHS5cMMuH+rdHScWdiNsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDI1NjQ0OS03NWNiLTQ1ZWEtYjUxNC0yYTU1MDQyMzQwNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW8cmX2D7epnDqwYrlJpa0z/66Jq9f65p2Ypc7oM+188h/\nqEF57/skVIibCB8xJDx2nXTyuJMoqX9HxNCYnfoko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0q4FLYilywDDfSW//s5il/5U\nTt4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJkgrPMK19+pFgPxm4+SBXKqhsyR7asElIpAD0EaC8FiAiBR7BnPpGn/\nMkCIb9lf9RI2Wz8w9Zlf6lhmuwRvHofZpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAeTAbnVs6CKiezmr+yVumqHqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI5ZDg4NmUtZGVmZC00OWJmLWEwNDItYWQ2NWY3YTk1NzQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTA3YmZiNmUtN2Y3MC00MGYzLTg5NmItZDMxOTVmY2Fk\nNTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErAFqwW5w1xFe3OIWWLHghKjv\n0laAyk99g3w6UA4L4FJ9AvwaPeNUyr3acQmPtsXwYP/WZiBx73Gl62c9bCl+oqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfixTcySIpv14gHpvTZvCs43C1tQwCgYIKoZIzj0E\nAwIDRwAwRAIgJWtNVoiTZ0PvblZXi1ngkQga2WkRbcyPba/YP4BQQagCIA2TNsEN\n8J142/t7oK5rbJu4KK0iiHpjBu6WOsf7j9M2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6631", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6631` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAaj1wp9hndHlNzMBRa4LBc+OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2MTgwZDQyLWYyYmItNDU5ZS04NzhmLTYzZjc0MmUyMGYzZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWIyM2ExZDAtZDZk\nNi00ZjdlLTk5NGYtZDdjMGQ3MTFjOTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdl4vEjqPE5lWd3/sVYZHsNIOymDgE4Je4zLVkUGmiXjS9C4Mvk0ONnWypbnb\ntpa19USFSOa7vEby9GT1wlfyMaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURAufLXlqusHPZUJr0omkl9cFcFIwHwYDVR0j\nBBgwFoAUafg69nq5u0xdR3QW6jozDeP7V1AwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIG6CrjCvU8AY\nmJx3nPZw2R4RRxpvICVjB/wJ9JyC0cm6AiEA6+wHIIzUxS0WuIIWF8H+9EgTKFu0\netYWlpWooa8T6C8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdcrFD355NwTKuCMGXQUch46MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjE4MGQ0Mi1mMmJiLTQ1OWUtODc4Zi02M2Y3NDJlMjBmM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXAKVeNq3NIpJcIynqvBR1bNT3o1FxZ9wzxoQJbE+2Q/hG\nhhIn7OcoibbQGZ4sMTWNRhlxRzuwA3aKIEJIF944o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUafg69nq5u0xdR3QW6jozDeP7\nV1AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK6+iF3WXj/9i0PC/aKxILHgufX6nzlIlvO9nRZ09IfaAiBjQt7baEeI\n15BM9OwA8jog+tcaoQcdTT8YAzZ9kXJ2Lw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAeo2JX11ZJyo3c0ItZNChPUMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWIyM2ExZDAtZDZkNi00ZjdlLTk5NGYtZDdjMGQ3MTFjOTllMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWJiOTA4NDMtOWQwOC00ZDI0LTg5NGEtNjZmMjBhYTMx\nOTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEzYS04B3CEYrJmjGj0zuxUkz\n5G9GBAgGZfiL39+TSgyBWto5Bs8QeAATdpDRcuMe2OFLw5WkckjBDgFVaq+5IqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURAufLXlqusHPZUJr0omkl9cFcFIwCgYIKoZIzj0E\nAwIDSAAwRQIgHUhgVnFEQc/AjItoKL9rd+9tfv4b9lNXJbi9cGn/OFECIQCTQfXG\nbGrv7S+ri5B1AjLE4LIOfY1y2nRGKl1roPo3Pg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6632", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6632` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfXM9NxT+/yO01neQoFBaVzuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhYTc2ODcwLTVjM2QtNDhkYi04ZjYwLWY3YTEzMmYxYjIwMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRjZDMyMTYtNWU0\nNS00M2VjLWFiZDktMTZkZWFmMjdkMzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOcoP+d1fhtcLDyt/3MiN5xeHIgSlhhqRoyQMeKQ3n3oPY2NPzTTkhJ1wK7qX\nYCMx7LVW6rjEma5uhtDaTrlRjqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqsR5/E4Unezcdabe5BhHZjui0uQwHwYDVR0j\nBBgwFoAUDTVH3bCkbIP/6CkDQa6V5me4abEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAIICSeLvkRcI1J/W71EdZ7iOLSBVrkwEbolnY8rFau3BAiAkJQ/KiKvv\nrBDLHA0DZWR3onnSgISV/5mXq8ftt88XgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUmfY/NKfsOohHs2wL2gaX8iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWE3Njg3MC01YzNkLTQ4ZGItOGY2MC1mN2ExMzJmMWIyMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe5AMdUnorxncLTmrMg7Wl2MQHmUg91Scz9oiXzgqisNvu\nXGq94mkzOR2IuZs/dQebiMgBGN0C6G99QUqUPGfZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDTVH3bCkbIP/6CkDQa6V5me4\nabEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO+Qfc+Gg3BYCfFarOUvXXxXt/L7Im0t0s7a9AYPdUAgAiBQMAw0DB1V\nq+79JsjINNzFLV/nEDV9XDk4Aj9b9b6I0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAd6AVTwUFWx1w3OE/ya3AbOJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRjZDMyMTYtNWU0NS00M2VjLWFiZDktMTZkZWFmMjdkMzI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGE1MmJjZTEtZjg2OC00ZjFjLWI3OTQtZjg2MTQ1Yzg1\nYzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP92aU9sK/i+qikBp3QnrQ5cG\nGKMav6CP2jTVpVFt3Cz2Y7LxfzIP1J98IElinwOjDoU2LGSfpgT1qblPKChit6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqsR5/E4Unezcdabe5BhHZjui0uQwCgYIKoZIzj0E\nAwIDSAAwRQIgIDU3qG4T7IIrvkMYCr2EZLERtzDZTrIC3UzgqPYkDtsCIQCOz54X\nZf+LMdC7sgW86pyQvji1rg+HFFyjazX2oWlzrg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6633", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6633` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAcnnyJQHhGItMD5NxV6Zk62FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyZDc4NzFmLWMxNjEtNDQ5Mi1hY2YxLTMyZTY2YzdmMGU4ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRlZmE1ZmEtMjlh\nYi00MjUwLWFlNjYtYjFlOGI4ZjBlYzhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjeBpQoIvuHGhtre22N83iRX4OatWLxgFbmL+NtfGUjCA9/3h/zI4R5qLeG+D\nQojA2ELlICrehdCdkb32rMaxUKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy1Cr+pXjzOHd/SvW59qoEd+IJEQwHwYDVR0j\nBBgwFoAUnJCGbD+smc35BopFXcTVMJHShiQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgeoJl3WfAAa6u7Bnk1KviKdp/7qiF0NmeT69C1iS6b1ACID6U9zZlh3BO\njWd5r6eFMl2Ol0ZPr9VyuT6iJ8cC7j3P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe0gfT7HkPdUryoVd5A/t1RZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmQ3ODcxZi1jMTYxLTQ0OTItYWNmMS0zMmU2NmM3ZjBlOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfwpmp/KuQbUUQGCDWVB/0uV7czol17gDkSJ0WvyYo/DjT\nUeOnYSAc973KOJxYUpx0UbXSvexeWp3wyHkzikYAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJCGbD+smc35BopFXcTVMJHS\nhiQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgX711Oogcwsc9aXGlgCfQQuatZgASitBDlJ0IOEK2f2oCIA9mwdeNLBQD\nB4rxaKuK8fIDTf6w0guYG71ZuTzGR0QC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISATQqjmHm1t+p+u+ZUmTQ22WkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRlZmE1ZmEtMjlhYi00MjUwLWFlNjYtYjFlOGI4ZjBlYzhhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWVlNmYzNDctOTIzOC00YjQ1LWIzODEtY2IwZTgyOGRh\nZDUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl6AwM9W0uU7lsr6sPuIdAUXm\nTlC44ps2w2rUWJF5e2YXRzp9QX83vupC6HcqvPfnSkzpEuB01NRSrTmxLf4Z8aNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy1Cr+pXjzOHd/SvW59qoEd+IJEQwCgYIKoZIzj0E\nAwIDSQAwRgIhAO/+2igUwneUXNb1r86/RDIiyBPLmcDCrm9oXElvm8a/AiEAiDr+\nPenaDWYQFSGLJqInQCC3PJ3t9H2D+wQ9kX6uz18=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6634", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6634` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAaXA77nVeCIEBfyZCSlc+KMLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmOTA1YmM2LTBmN2ItNGE1My1hZTBmLTQ4ZDhmNzMwOTAyMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWVlY2YzNDItMzQ5\nNi00NGJiLTkzYzctNDhiMWQ5MmQwYzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAHXy2NEMa+cA6fe/QZhmiXxplXBRfImw7rPpXZSFddKQGydsN9EJ0ZcjgCTr\n71J7MhMWagYs0YaQGxl2Z8urQ6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxqReCCXm/Q+hrIYT9auPc+9mYTUwHwYDVR0j\nBBgwFoAUt34BvBQrLFJaHt5h5rY7+eXs8ecwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIFcXp7FONMd+Bpix7GWi76lA/rgRPxfdLO5TF4wC3zOaAiEAkx6Y0vfh\n7yOKC58NNMKZwYEiOcuVABssolsGORc3SEY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbL73hdBz8XLJLh/BOlf95GbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjkwNWJjNi0wZjdiLTRhNTMtYWUwZi00OGQ4ZjczMDkwMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTi6rAMnk9goXQQ3cT5wRI9Ite2eafBKJzEeNkm1zrN35U\nXaxUwgI/iK/4Df7zWyWgI6cL+aRfHR4DoC/KLJuYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt34BvBQrLFJaHt5h5rY7+eXs\n8ecwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPF1yHPjMx8eNJ5U3YM1IEv2Wl67Do5cCY1GyDFITy3oCIFUrnhHx4zpQ\nJXV1YEz3ys+CG/ZUGGzGfIQe6Linhc+D\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAYUjodrLKfQz2hTwg3YBLgpFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWVlY2YzNDItMzQ5Ni00NGJiLTkzYzctNDhiMWQ5MmQwYzY4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWYwNmQ0MTEtMGIwZi00YzhjLWE1MGEtMzQwYmYzOTc5\nMzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDep3jbU4RRa7RBf/VnUCcqtm\nkU/gt7XxYPFp+JBGYPKJJsO9GC+VXM4gGAIgTW6POlMElENKgyMTQuL9hSgE56NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxqReCCXm/Q+hrIYT9auPc+9mYTUwCgYIKoZIzj0E\nAwIDRwAwRAIgYNMRmWUo3mWrcK1Yu8/jDS4JaR5h+N3QZgic+gWaroACIEsApbnF\nerO0vezKHebIdziXifBlaxzyCh7wQ1tt3vGW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6635", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6635` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAbCKhjiQDb9+UMU3dGPQbbJuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2NTdhMmM1LTM0YmEtNGZlMS1iNWZiLWI5MzFjZTFkYWViYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RhM2IxZWQtZmM3\nZC00NjA3LWEyNzQtNzdmMjIwMmI2NWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFOtq3XkE7ANJZblbr03yTa+sTPtRDCkJW2+2gOEKhq0cO1a40aPyG2sdPTFm\ntUkmV4IHwVOH8R5bXOVauuufW6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXz9LEzTqUnFjvQblk2jprbDZ5XIwHwYDVR0j\nBBgwFoAUcVZuL79IIpTievHBYHQds3u9C7EwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCmThnn2bsuN/WMpcirWxIkx7R9Q6ynRJQzJUCq\nwUkp5QIgKVAotwlx3k0fwfQjo+qix9B4G0FmxxUXco6rKLmq9yE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYd5f3vlzycFnh7TFqyuZNyVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjU3YTJjNS0zNGJhLTRmZTEtYjVmYi1iOTMxY2UxZGFlYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASg9OqHauLTlaB1uUNGh6gNTHaoozD03zm3/hn+9+CXV29I\nHwFyThvZd+MFy1L6bSh6Mp4AlsZiOgB/m2/NZAIbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcVZuL79IIpTievHBYHQds3u9\nC7EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSopmkczPMaX2nXKRg0ah0Z/gCNvAeArlQGuxFiTMW6cCIQDY3uP6usDC\nQU/qRiQ1C0P11C8pw+5UXdmXObT4riLB6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISASt6IjlvEBpEdksW7OqjwaiNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RhM2IxZWQtZmM3ZC00NjA3LWEyNzQtNzdmMjIwMmI2NWFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWRhZTViMTQtOTQ3Yi00NjE2LWIxNTEtMzU4MGI3N2Q1\nMTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2tqRDCBVyuaeYV2a2QTFH3qG\nB49sIWIBpKWjbTMDkcVBVZF2ThuIcmD9R8vmueGgLcnUzTIB/YhAgLY4T/GGSqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXz9LEzTqUnFjvQblk2jprbDZ5XIwCgYIKoZIzj0E\nAwIDSAAwRQIgEVO6JvYHmNG/18udq9ROJWRascJB8wyVK0g30V35fLYCIQCEKjri\nTL8zE4gWUXW1c7N7COcsSfKe7skFqozX4rXZ9A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6636", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6636` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVbMfCKpoQWkkpqfVrRVPCJQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxZmI1ODIwLWQ1YzUtNDhjOC05NjQzLTM4NmFiZjAyM2Y4NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZhMGNiMjMtMWVl\nYy00MmQ3LThhNDItNDRjNDc3OTg0MzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv6t37CeWnCJluYXll1CtveKLfeYw2Nq6LD+ycsH9EwG8Cxr8IPeXQcz+JsyG\n6CcTIHhTxCExFW0tSOZRQ8clI6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfzA6Xr/fCQliFkCtyNRWn3ylW58wHwYDVR0j\nBBgwFoAUHh7fQSnaJim5PbD/RCkIwN+ySLMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIAnepEKArthNcy3uAhLaNqX7wMmDgQ4dIHRSKJVK\nPGAOAiEA4ylZRxSL3M/RjTA1TlnilkBlv1OWbCMr/qErbgExmHc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWuxXEVZHLoCmO/8i+Nl4IPrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWZiNTgyMC1kNWM1LTQ4YzgtOTY0My0zODZhYmYwMjNmODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/jZYNXxDvQDVxPSOsSLw/QcNcewUbjw0me3mq8fy5ZJNj\nO3KfJ4Y8Z6u/HOuGRhlju0boSpPqtrAJSF83h4+0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHh7fQSnaJim5PbD/RCkIwN+y\nSLMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANaa3aQM1AZDYRm9QBLze1Y2XA9XJUlCpqGeglotR0JmAiEAt/MYcjnn\nOFGNmY9m8mLu9XLI6cT7XSlo8VDjnF4gDx8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISASVBpB/wv8v8GjQL9AsrWgZLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZhMGNiMjMtMWVlYy00MmQ3LThhNDItNDRjNDc3OTg0MzgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzIxYWMyODYtY2E0My00MGFiLTgxNGEtODU5YjljNTQw\nZWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9rtD6ZG0aqQJvSjxBQatvSFs\nwlbkfpGKz+7O/unmAH6RIkT2GMTG5lrm5VzyYqmP/8EzzVn+g/ngggmNh55IgaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfzA6Xr/fCQliFkCtyNRWn3ylW58wCgYIKoZIzj0E\nAwIDSAAwRQIga0u063X1kzjENKRqTCLuEW+jNCBcNY9OoIVdmoQONH0CIQCBop8Q\nMMxcZ7yXxPvNjfBrav4C4fX56p9vxz5bvAH9JQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6637", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6637` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAT50gfnPTO6f1boIqoRDnSrvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzODAzZDQ3LTRiNTYtNDBmNS05MjI0LWZhNjlkZTU0OWJkMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIwYzdhOWUtNjgw\nOC00MDIzLTk4ZjEtODdkYzAxMTI1NTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXsvWAZWvVEr3rsWegYOF109Sxzb/zzS2QQei8nlkWX1OXDBG9yMe+bAOvAyG\n/4B9TEWRSQlhnXvTyc7RF4R70aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSUvYk8JPQCfr0oKBAnOD2J6L6N8wHwYDVR0j\nBBgwFoAUKDrDMarWKCHWCrqKsovFT62X+L8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCnaBaELHOLzLajjaoFzQQMI19D5kDr36JiCWHrUDKiOAIg\nFKh74u98qPf/6UsYUGwIYki3GDq/lF62LW93MAKuEKo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARqX5g7mivrK2yjBBtqWn9icMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzgwM2Q0Ny00YjU2LTQwZjUtOTIyNC1mYTY5ZGU1NDliZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbx+MxPyfJBwusNLmJCM8lS7sb49UP/4RikBmiJgwCBZXX\n0EnFDuj0T7WOn957dNk02Uf92pmM7/Lp2Wfb0Zsko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKDrDMarWKCHWCrqKsovFT62X\n+L8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIVifB+D+P9FjVGzyLe/WRhyV23OLshByv6dcxBkt8dRAiEA4qCvxD5D\n6xVyYApPI+bGIbX+vxrQn4QSwwEBBX9V9Yc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfGHRjqU8O5DRFfUB5her5EOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIwYzdhOWUtNjgwOC00MDIzLTk4ZjEtODdkYzAxMTI1NTI1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQ0YmY1MjUtMTkwZS00NWIxLWIxYmEtNzJiN2I5YWRm\nN2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESk6SQ9+v6f5XPUR+pX9Rv747\nXlLfFUbXzTOdZ2lRGdhWPc/heEGV4m5djtL7+x9tHi7vpmtZmxy9sCM6FO/kFqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSUvYk8JPQCfr0oKBAnOD2J6L6N8wCgYIKoZIzj0E\nAwIDSAAwRQIhAI++tzc1HuoPA7qq7af5pCltIgyAJidaCu11CyvWKTtZAiAhnREO\nj44GQEKGINuRJUcPw7gPARw6RC3+4Q6yun/faA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6638", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6638` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISATCGSlMOBaEnyXKZh2JSVv1sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NWEyNjBkLWYzYTItNDdmNC05YzczLWEwNTAxN2VlZDEzZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWRjZTIwNjctMjFk\nNC00ZGVjLWE1MDAtMjExMmIwZmQ0MzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE+sylT3UY/icqe7XuhEcvZzDqf1iezF2ixW+xrOCXXbGGyXeqWZPzWgGodkH\ncjtD6Vs0Z4Bgjh1o/HvBNkzs6qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU10X+yi7ntbszlFKyny0bJg3Xjk8wHwYDVR0j\nBBgwFoAUz8k3n7kt9Kgbi03tPrbg0dh28AAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIBNrPHKhpHXTyOnYw4aOLPCI6siiF9Xg\nEw3wZXUwFML9AiAowWD79M2uRf0NhTXPxjC1olb9E2ZUxTLxIoYXz2UcMQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXhq4amOm3fVLJBVxam6wMurMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTVhMjYwZC1mM2EyLTQ3ZjQtOWM3My1hMDUwMTdlZWQxM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx2BSZDPNgcqtPleIaay820liNkqg1xMSosgfRm4V5w+6G\nTY2MglKP+UynQzTXzXdbC7JjF4gqLYGm9nekJFu4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz8k3n7kt9Kgbi03tPrbg0dh2\n8AAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSSupLh6SClblt1zRezN5RU9Kjd7HIuLv63eYa8mRU+ECIQCW8TsGX6he\nZ0sKwkb7rpx1sEVsGsBHHoA3Bhfcfm/aIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAQXSDaWy8KzYA7t1RTwMWJ7cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWRjZTIwNjctMjFkNC00ZGVjLWE1MDAtMjExMmIwZmQ0MzkzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTA3MzcxM2YtMzA1NS00MTg1LWIwOGQtOWE0OWE5NTM5\nYzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2irvMHVTn9bazwcQvMV3bzZx\n5O2DHe037RyHTTWtTfEnUn54f8CAVCl74dfwvUtwKFre3GO6/pgbiKUXjD7Jl6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU10X+yi7ntbszlFKyny0bJg3Xjk8wCgYIKoZIzj0E\nAwIDSAAwRQIgAk3GsW/waWEs+ch9eaNmft713g6awPPVX2lhmvGORfwCIQDHysan\nQAiwc2IOrSOil+UrGwIZ08wBv+zdfLbfFR/b8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6639", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6639` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAc1RHsk6UXbw+CIkiT2V5fyOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZmRmYjJkLTQyNjItNDI3ZC05YTZiLWY5YmIwZTQ1OGU1ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQxNjcxZWEtZDQ4\nMC00MTRmLWJiYjktZjZmNzEwNzU5ODczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQguw0SR6nazf836ue5VmObnRvQfV8pTpuQlgbe9kUFE9/aYeOyv/ha7rS7Vc\nlHOBNWs8lU80cvXQwgbxywJjOqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjnLuac/DvMYsRMUd4HIXcDFd0lswHwYDVR0j\nBBgwFoAUMsEqr6F1LLupcif+akxThhwvP1IwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCICUW9uRL1cBzN8u8Ftq1t3KhOvf66lVa\nDx1uDDicruDHAiBKZUuHFQb3mLRzQHLQ5EyNZvycM+EARszzH6/mnKNNKA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXC2/2PxKk/NUxJTIEL+A0GHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2ZkZmIyZC00MjYyLTQyN2QtOWE2Yi1mOWJiMGU0NThlNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnFjivhVxKLKIdG3Pzgrmx2wFINuaiO2vVZ4h88cFS2ASt\njuP6xpDG6h//E4L2kMNtoAIYDXqkb5ApB1vD04i5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMsEqr6F1LLupcif+akxThhwv\nP1IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDcOzcXIG07ISt1p2tcutBMBooTQzbCfLTXaz2j2I6B8CIEGtCUJAaMc/\nO8u7Nt643gsYiARpJAY4ooyaS9qWqcx/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAYYxwmTA+zBgFX4uqaacsbQaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQxNjcxZWEtZDQ4MC00MTRmLWJiYjktZjZmNzEwNzU5ODczMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWVhODM5YzEtMDhiMC00NDA2LTlhZWItYjg0MWEwMzkx\nODg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE//oiSrmRk/O9VVqiCxvbLWDa\nzNiRO/9ek02NP0zgo3p5jKEajgMrYqTf2BHSay6tctmFk33qvPSXIu6v5qKY6qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjnLuac/DvMYsRMUd4HIXcDFd0lswCgYIKoZIzj0E\nAwIDSAAwRQIgEyV+8VEtamumWoqJtOzBSL4QecDbmVob0z0wLOAi1MsCIQDUhpt2\nFQxMMKm9BLoWA12Ahy08Y7j+wqluICcBwZUN+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6640", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6640` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAS+iT+kruOH72lfrwVfGIVvXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxOTMyOWE0LWE2NWMtNGVkNy1hZWZlLWM5NDYzM2JhMmU2ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzMzZTNlNTEtMzAw\nNy00ZDFmLWEwMWYtMmQ1N2VmNWY4MDFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETcXrp3NI0/owjmtcQlHeHFazXHNP0oGJDw9EDl/YkIHvW5Rzi5oB04W+Zsx8\nAg2wXSzovFUOcXckr/cBzlxVM6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjY/3vl3YJkIOlW9IrlowiteKFjIwHwYDVR0j\nBBgwFoAUx3C4Xb1HiGJX+k61y18szyszOiYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAwVqZ3SyrlW\ngQKpHGLwq/EkD00AanPyYHFlRLiGrRP+AiBMVI9sdaCH1QfdyQ/WBwUVFiv9riPT\ntJIEQXZvXsM4vQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaFl/G+mYk82iBzonIDKZh4MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTkzMjlhNC1hNjVjLTRlZDctYWVmZS1jOTQ2MzNiYTJlNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhndzUV3OqK1KfzaGpiHUjrKawqQJhrIXawSjwhEePGefx\n3WdwK3eCToVtSl9cSQnaaE25ncCLiO+rcl1i3yHRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx3C4Xb1HiGJX+k61y18szysz\nOiYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN/IsrpA0jNtceWu8GYXQ2H69bC8YzWs8WFsVw3hVG/2AiEA7yUR6Zyz\nhUuZAua+4eA2fERTFTxhhH8x4QkcXYPFiQo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAVPiojwAm89mQAVyd6oDu30nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzMzZTNlNTEtMzAwNy00ZDFmLWEwMWYtMmQ1N2VmNWY4MDFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmY3MzgzOGEtZmM4YS00ZWVkLTk1OWEtMzQ1MWJmZWFh\nMTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPjH2ur1Fca007B7y10C0aBKx\nJSpmu+tvzU0m11dAqbmARNEb6fZ4OMlh4Lj1wgPLCdq4wtHukKg/QpuLv+3I+qNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjY/3vl3YJkIOlW9IrlowiteKFjIwCgYIKoZIzj0E\nAwIDSAAwRQIhAIQHt8G9SxwJr3kwNHFg47NvezrPE1FVHyZAPElVRFTlAiAv8pE1\nw2jBE5uDIhDpgvtnZ1O9zgXvvlRFs6eFXklCNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6641", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6641` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAXtVYFjbbjpox4ozDaXIemDRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNTQzNmI5LWI1ZmQtNDNmNC04MGZlLWE2MTQ3MjYxMTcxYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdiYTk0NmMtOWI4\nZS00ODNkLTliYjMtM2QxOTc0MTIzYjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsnWCVmcvqwBrpPFb/shtbwILPZbF+lE122/wjNiHST6pqXe89wbxZ8pzt+aj\niLOHQey9ppte4IAh6JtGda9+3qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE95dZELgcmDiG32ev4NyyJG1AWgwHwYDVR0j\nBBgwFoAUSR8s+7j7hDliCYQOg3Cu1L5PABkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPizbhENIeVlMYQ4fKHLtFUrJ3EhSQjCCNSZKq3bUpEiAiEAzTVUD0Kb\nxKxAs6+snrybD1s4tgz8Ztn00C8vWUhGGzg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfhN+A5gsohI8jDX79XlKJHIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzU0MzZiOS1iNWZkLTQzZjQtODBmZS1hNjE0NzI2MTE3MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4j6OUZ7QEOUdVnETN7hpJXvHOdc/4lTuve7cNxFwjtuh2\nVtEGN/3xwAgvBiPogOn117C4qyFP3eunQzEXlxHjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSR8s+7j7hDliCYQOg3Cu1L5P\nABkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIWhoOFr3f3yeBvwnpfXYhr9cocIh9c3NsWyvRF5KKYpAiBrQAAxP9PV\nm5r4aqdO6WHotEEl5mVCTpuPPeRPv32gaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAThIG5jO2ddohv3KJ+pwAK7hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdiYTk0NmMtOWI4ZS00ODNkLTliYjMtM2QxOTc0MTIzYjNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmQ2MGViN2UtMzYyNy00MmUyLTkzNjQtOTQxYmFjOTEw\nZWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8iKQWaGaNXkIcpCN7bdZmrOl\nb5DxBdpKV8J7dUi7NpN+/jmfyvr1FcgUisQu2UkHJr+sI6CruDJr6lui0Gfdd6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE95dZELgcmDiG32ev4NyyJG1AWgwCgYIKoZIzj0E\nAwIDSQAwRgIhAJCfjwf+rZvEdqznEjjPalSOc0NPG6m+VrejCzYNtxKtAiEAqO2P\nHYZjn75TbL2P7OByooPtwauNyqKSSfOXH0+UNvo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6642", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6642` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAWsexJOwNj3U0ICBaI6GifVBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlODY0ZjZkLTJiZDUtNGEyMS1hYzliLWYyNDkxNGE2ZmMyNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVhMzNiZjctOTM1\nYi00MGJkLTkzYTktODA1ZjhiM2UyOWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5b8cfVZWdZLFkIKsD1ejUb6nPUC5ShNOb2oxFbEHP5VsLXyXBrn3jG+d41iy\nG29JDwHRTvqsP/c9CBlJ+X31AaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdnEiHC3cPodIfIazdGGvbLWwivcwHwYDVR0j\nBBgwFoAUzl9eloZqU4L5gENgJGUZkwbFjdUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAK+J2bLD1F7uaQMno6IMVyRTLNpKj0r3GhWmKmorjxkYAiB/mvy4detN\nEhnpyiYmoU+0PBy9EjsZlYmE6WBBy+yYyw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZdXKqVrbvRxSjlARwp8HA7zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTg2NGY2ZC0yYmQ1LTRhMjEtYWM5Yi1mMjQ5MTRhNmZjMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZpBSwm3TnBezYD/l/gK8nwwbhO+/Z5p24jAcnHt9MIXo4\nDWvSNh+15zpeh6xaxCUGIIGvDxsrL3uPr6C2oqoJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzl9eloZqU4L5gENgJGUZkwbF\njdUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga1NAfeW0hs6fdNhoexsvqDAJDbfALQzP6dmx8fwOgKkCIA6qbzEu8cgU\nV1XLmYjKbrbTixvWF7rxZup2/tFsEjiD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISASL3dSf1vc/O6C/8yJz7TRz1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVhMzNiZjctOTM1Yi00MGJkLTkzYTktODA1ZjhiM2UyOWNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmViODg5OGItOWE1Zi00ODZmLWFmZTMtOTk5NTNhYjQw\nZmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzyiJtlcpj5m3p2vz2xD2Hyz0\nYy83rpTMuanzTLHDxQMVTEB0NTEfaMUqVyZY+dh8X2kko9vdnb+ZRHYCdHGQZKNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdnEiHC3cPodIfIazdGGvbLWwivcwCgYIKoZIzj0E\nAwIDSQAwRgIhAK8bZR3n5auwxd7TIf+0A0vjS/WkEplEqBfErn4r4Hi3AiEAv9Dn\nxe8BbYuyABsR85WJs36sArase3iYymkETyfLwso=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6643", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6643` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAefcC4UZOfN7uI/aBF8bii3lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3N2ZiM2EwLTIyMDAtNDM5ZS04MmNkLTEwMzcyZjg5NDMwODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmYxYjkyZWUtZWU2\nMi00ZTFiLWJkNzUtYzI2YTcxZjE5NmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgULKayULWqUpNM5S4vGlihf5WkEeKUABZrJA34Al0xikk6bj2g4zJ1xIFSAk\n3wSYSRSZx34AOv2GuNHbTeKvF6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1NzRuLx95Ral4cpxhybN5BgUeqgwHwYDVR0j\nBBgwFoAUcwvqZsX9mjzyGBgVLc1ctWOajq0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCmRtnjHcQxQXyFYcpl0bUeqrO2S7Pmuhjk1vj8KSAjwQIgfCmliWXy\nF3cziJ4VAiK82HZnYbkWQ3GVulFScHO9fzs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS1HGvFcrQm3jxEWXkezsWtUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzdmYjNhMC0yMjAwLTQzOWUtODJjZC0xMDM3MmY4OTQzMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6Mhu3GAhF6SvciIqOCoN6P0LtR82gEjGfCRZl2PdCcyBK\n+Y1rb3wI/g1LCADudHyK4ote8TLKquO6J1RHB3cio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcwvqZsX9mjzyGBgVLc1ctWOa\njq0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdV8xc/sc1pENzT+9wdUtmSDLkQ134JywEq/i1fKrZoYCIQDvCJiL4/qE\nUQv5zDsG1d5tNbsJAaXnBb+Wnor+jRWkOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAaDqZ8zh6YKfmdCr3DC4pV5pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmYxYjkyZWUtZWU2Mi00ZTFiLWJkNzUtYzI2YTcxZjE5NmRkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTEzYTVmMmQtMGIwZC00YWVmLTk1YmUtZTgxNzRhNmU1\nMzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVhhyKtf5KDtRuHxAWbCxkg2n\nypBXQUeUuPIcpIPVsszPKlIabPnHyHlbpljq4cGQOC9r6BAA0rUzVrBy5NDctaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1NzRuLx95Ral4cpxhybN5BgUeqgwCgYIKoZIzj0E\nAwIDRwAwRAIgeFOl/AO4pxXYnNi1yJYxy5mXfVGnxbr9v4efrgG0KsACIEY4Jlad\nPZeStME9Xygl3e+a8iyR/V11MMeRwf/7RCfW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6644", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6644` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAR0VvpDJX9JOJT79EVNLejDuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjMmViZTU0LTliNjYtNGU1YS04NmM3LTVmOGVhMWY3NDdlNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJjYTc5NDctYzUw\nYS00YjFiLTk5M2QtNTE2MWQxOTNjZTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2RUaNIAmfH6MOQLYpNjO+K5b7+uZUCNbpbRfscbMswcTpMj9wWkhPb0NqR6j\n3W+XyukVvg9rHyg/CE4CeLKkS6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUblC+83p9Vn/SH/7vFhZO0WoBAaswHwYDVR0j\nBBgwFoAUnYw+A9uBnbpkaic7ptmCCmZhqakwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDbTopgId5LaN3VK/iVWD4iU5/qL8yZGrc0NA+w\n6WSb+gIgD/dDWGNTE5chUpYN2/4ji1jYXcnlUqTq5yTE7g7UeFo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc6h19YI5hB3vqkilu1ObI24MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzJlYmU1NC05YjY2LTRlNWEtODZjNy01ZjhlYTFmNzQ3ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATL2yBgzuyjFjBLrLhsrdRB+YbOAZEbbiVpKZckzhv8oCgA\n64UiKPgZPQOYCoh6i7Xgy0AOekm+a/zW1zQqdfMYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnYw+A9uBnbpkaic7ptmCCmZh\nqakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPOje4wHM7GYVOy+3TnKf2QcRcUNIyWF4FdftI3dFXnoCIGrlyMfFYA16\nGJnxZxNq3vCW6Eal20jdzhzN03fs9j4W\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+TCCAZ6gAwIBAgISAS1waQeuVSLbTTt9mP9XpjABMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJjYTc5NDctYzUwYS00YjFiLTk5M2QtNTE2MWQxOTNjZTAyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGQzN2EwODUtZDI2Yi00YmJhLTkxZGUtNDE2ZjI4OGNi\nMWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYFtVUB1xeMY6PPLVVcnGhv/8\nNdEVcSZd5PZ0hA338CKXrB3nICDp2FMGZBnNpB2QpZUgEqNu21Zu/GngX5pII6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUblC+83p9Vn/SH/7vFhZO0WoBAaswCgYIKoZIzj0E\nAwIDSQAwRgIhANoPaLIvmcXkD7okUaJ/zPVAgVsXL3sMalWuv2PTW/jWAiEA0dYv\nUsPPEGfj41YKxys37krakLzoZKVDdRDXtQEgcmI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6645", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6645` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAcjYEkZ35Cw7Jm6Uhfwx6fVwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1NTk4YzI3LTJjMWQtNGE1Mi04ODg0LTEwODEyYWIwODEzMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk0NDExNjYtMGI3\nNS00YTNlLTgxMWQtYjY3ZDZjOThlZDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXmiIySSjdIFC9bScI9diRFP0SdLWqEB5CFYsv+611mJdV4yGf+X1Bhxto6HV\n1xSZ42znbUelfnR6HDS5O98m8KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlrGNkkgUpgS+BPWNTUJo2EazfhcwHwYDVR0j\nBBgwFoAUlgPVfxM5+0BTvpuI44kNYEVOHGkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC3vOosK2ecmmOXTk4m4PQXE/XcZD68LPdote4f\nSXORrwIgZ/q/mbrv33Z8AwZ4uNqknoQLRVlSLzrDckesoZVpu4Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdMK0q7co2eiTouT4YUc40/jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTU5OGMyNy0yYzFkLTRhNTItODg4NC0xMDgxMmFiMDgxMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt2Wn3C82n44S4wpcXF+87ZeOIZUO0Gvt7J/QrA9Bm2gxQ\nqRtcNtvDPF75hhNvDZ0s4sdSJKvmma1h/nub1dpYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlgPVfxM5+0BTvpuI44kNYEVO\nHGkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAdBbL1ljJ9NN3R9Qnzzk6eQqpvHkc6WLWn7AkLOn/RECIQDo95IflWyD\n6kumNot5EP9j+ciP6npw5xG49uYcLAcMHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAcof/tQeTPkEZsKTSMOjloNzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk0NDExNjYtMGI3NS00YTNlLTgxMWQtYjY3ZDZjOThlZDI2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTBlOGNjODYtOTgwZC00YTcwLTkyZjItNmZjMjUzMDNm\nYTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvcsuQYvvtxJe+8qDIvk6UUWX\nqhzcBtJmFNHwzGpZqzDiIV+xWUen1ehQ1LWTpZATUikpmWzxlfalEr2ZB2mMHaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlrGNkkgUpgS+BPWNTUJo2EazfhcwCgYIKoZIzj0E\nAwIDSAAwRQIgQB4n05U2uT19yMY+lh4trpmrYjXT+t2Za01CUAg/VjgCIQDjxKTB\nlkOAk6DI3+D44LGf6rFVGu2wwnXWtDfxjChxTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6646", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6646` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISASDcfqb4IUdGOzFYZABagTfCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhZmI0MmE4LTJhMjEtNDk4NC05N2QwLTMxMDAwODI0NDJjODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY4YzkwMjYtNjQw\nMi00YTBhLTg1ZTQtMDZjNjQ0ZWE1Y2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJmawPE1ndDYDfXyZWBlXMuD3Y1at+4Qh+CITMXBjPzLQn2HGXpP1zt5Lyy2N\nXPCUAObCQgLqO6CDes9WkpzexKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0W0DPfcFVg70bwCfrPGIkzc2qj8wHwYDVR0j\nBBgwFoAUmEJ4ZOI82o7wsxEDlxrAXw8qIAwwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIG45ijPpFGw2yRWYfW8krK3142jvORCASeB6XxxqqAgsAiA/\nO1rRkgyNwgD6LN0ma+y1t8xFqWavkf5zpgXf/nth1Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYa67lmv3lCXribxzJwaVNsrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWZiNDJhOC0yYTIxLTQ5ODQtOTdkMC0zMTAwMDgyNDQyYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsHZfd1nltzMKykgGiUyqdcc11Jh7UJjb5MqZ/D8t9WX7x\nBoySNuHNyUHYjDwSSuNPmVCYFxBSEdr0EZFnnw52o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmEJ4ZOI82o7wsxEDlxrAXw8q\nIAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM1n1g3+a9J4J84rwRbwasbrIrGe9n0+ZvXYHPH3MevHAiAK6bATDInA\nHA4tAyCO+Noxnsg+eCp0A/iHrSBpx1rW7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAfkqwJ9ag0aj2EizQzSYSxhmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY4YzkwMjYtNjQwMi00YTBhLTg1ZTQtMDZjNjQ0ZWE1Y2RhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjM3OTFkN2UtMjUwNy00MTNkLWI0MTEtMDUzMDIzMGFi\nMzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECQKH6mx3MUTBcBXPCtlBGm+R\ndqPVyeWIIFTKbEeWEXyKNb30FKoRfmeMkojob/0rZmMUEO4YyCseoYluNe8sPqNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0W0DPfcFVg70bwCfrPGIkzc2qj8wCgYIKoZIzj0E\nAwIDSAAwRQIhAMErImzi9muVv7RHYhWMSLwEuRffc0eg1EPy0uGOSI5EAiBdFD7W\nj4UtJMNsGic/+r17bcIglA8521ZXKc4w6iF0vA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6647", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6647` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAaDQxouoDvmi8AXWJX0aHmslMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxMTc2OTg4LWZlM2YtNGNmNC05MjgwLWRiZjIwY2UxNzA2YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODM5OTg4NDQtZmRi\nNS00YWNlLTgxYzgtN2YyYWJjNDEzYWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExvswZ6RFs96HdZahGSlvuk4N28mmfWx7t/vtmrPjZlocaSykzUyjq9Vqo6CY\nmpYovK+ixQJ9aSJr+XuMtkmgoaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBblQVcUk/sd4Nsuld7U76P1lA9cwHwYDVR0j\nBBgwFoAUjo7uwpSFCF9P1BeUkVmH+eqMLN8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCPlaxqOvMsbWmmW+8Vx9ylnwo/FP5I\nppVzqHsnh5WGFwIgOlD0BlUV6CxsPT2PykVom/jc6yaTMem4iqayhNYutAs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbbFNitVR/4kV64Q8dcLrDpDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTE3Njk4OC1mZTNmLTRjZjQtOTI4MC1kYmYyMGNlMTcwNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKVNVDGWOrLnzfWa53t1ceo+HpQBmRyodjh5yFDtQAiidH\nds6ac4Mbs5q7sEivuANlWE08MKC5/gE3Cd4YOL1Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjo7uwpSFCF9P1BeUkVmH+eqM\nLN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTgzDiHk2+8xfs3tBnHBYDVtnQFmbAn28ZjQFwLwWFWICIQDbM6BYbopF\n5fq97T9kz9V0Omh5+nvxCWsjYw3dFih7nA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAYoZyYGuDipZbzmEpfo6jK97MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODM5OTg4NDQtZmRiNS00YWNlLTgxYzgtN2YyYWJjNDEzYWYxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWM2MDFlMjEtNzAzNS00NzBmLWFhZDQtZDJmMmY2YzIy\nOWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg7SzQGjvUBeYnGgFrr/dNX2Q\n7sabW5n60SERqmanfTbVqjs9Zc+dAcVVnL2+kK3N27zHUJy7ib+CR++ivvkoIaNW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBblQVcUk/sd4Nsuld7U76P1lA9cwCgYIKoZIzj0E\nAwIDRwAwRAIgBLYnMU25GTw2fX3P0ntmKjWy8iaBpOYYhcs99/gZ7cUCIHRWnpAo\nZKGCQOXAtP7WPKRnlyY70nx7tWhoffJ71tGa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6648", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6648` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISARirTg32xgHa70Fw54tq7dwMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3ODgyNDA0LWJjODgtNGI3Zi05ZDc0LTQwYjk5MWU3NDhmOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdiMmMwMzAtNzMz\nOS00YjNiLWI1NzEtZDUzZWMzN2UxZWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpQumkDKdin9p/yIcC1yLnv160/GCtIlHLVRmTQx+ShoAkv3rmfo6PsaI0HhY\nnOlkZxgM7IvKpH2K43lyeira66OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPx19ii+16nLZ/wmZ78AaXCIAv2MwHwYDVR0j\nBBgwFoAUTL9z/VMKPfIbXIE+Z6Q5IU44Q6wwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCgJv81v+JPQklEoyhK8V3+7qYKNUr+\nXB5OGEj/tMVvDgIhAKMT4Gye8Mlj6VwYe9K0Pvq2zS49ziYG+3h+JTN3HMAu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASiNXD06G8C4fPYIo8Olx25YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzg4MjQwNC1iYzg4LTRiN2YtOWQ3NC00MGI5OTFlNzQ4ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkHLUNIuyCyBFuD6ylBJGFTlvPUtCn25TxvjVPMptS0mj7\nxjSTZvVL4ltg1SKyzW1JdIS8D6NTS0gyL0ZLfO4to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTL9z/VMKPfIbXIE+Z6Q5IU44\nQ6wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKec3v4yFoleyRxg1zdXXVUtoQf1wLr9EMhsiPjO/XDfAiAExH+fF+6t\nZIcpF5DEhSi6ovi7q+p6Z6OIp9tnWqymvw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIB9zCCAZ6gAwIBAgISAXxV+ChAwjmYgcoQxvKedrPeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdiMmMwMzAtNzMzOS00YjNiLWI1NzEtZDUzZWMzN2UxZWMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjk1YzViYjUtOTE1OS00NGFiLTk0MTgtNWZmOWYxZGY0\nMmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEywp2ctpS5ufuaRQh3+l43rGr\nnVMAUtiCx6cmdycThRzy6k7pctoiQRkqddK5mc2LgfoU9l6Xyxv1qRcLh7a+o6NW\nMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPx19ii+16nLZ/wmZ78AaXCIAv2MwCgYIKoZIzj0E\nAwIDRwAwRAIgQX0YCSlf2LPXexjI1IRqXq5h+9lLx7D05iAcbqCCtucCIE5rkaXX\nVT8FjYXTk+nNRPlbBF8qwWw5x0/0Ed/4P/0z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6649", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6649` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAT5pkCJ+YriPwtkVlLZitunDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxZDM3YzhiLWVhYTEtNDQwYS1iZTU2LTQ5Y2FmMTUwMjZhZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQyNmJjOTEtNDgz\nZC00YjU4LWIwNTEtMzU1ZmExY2I2NWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHPtWdvml77p3bhvV07TibPkixf1WtZ8bPDNiPaDTtm4gnrEd3zFIn5UCp8BS\nPgYr18Di1XUBDGGio1h3kQVk7aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN+HTVOApS6s4dIdp9Pqkl0hqeP1MB8GA1UdIwQY\nMBaAFLbCacBOATl225TA/0y5hyNazmiOMAoGCCqGSM49BAMCA0gAMEUCIA/mGlSd\nU1aYuiS2cbk8SLRqDlllbOPYq3T/y1HVcNK3AiEA1Hlgqee5+jdkMvnxps0U4Rl8\nOaYSbsH5+AtpJcH2ztQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYjc0Ef9WfjOqDCUrumDoE5vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWQzN2M4Yi1lYWExLTQ0MGEtYmU1Ni00OWNhZjE1MDI2YWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjDUrUGi0yM8Dbpd2kbtv3MpIarqYMWoQPALUNxOzO2uZX\nxN5T40gKLz1pZrm/UwubVNtajCqxPf32Gp6Y3d3Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtsJpwE4BOXbblMD/TLmHI1rO\naI4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANHIWmkMtKivmN6bhB6tbcSfXWpvu0TLACCmbRa6zu/hAiAUr3Z9v+AL\nYINxiZGvqbw2J6T5vtPlMmwEp4bUq4z89Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARamGwGnW/MmD9mHyMQLJfOeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQyNmJjOTEtNDgzZC00YjU4LWIwNTEtMzU1ZmExY2I2NWUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODMzNWJhMjEtNDFmOS00NzE2LTliNjYtODRkODRhNzQ5\nNzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX013zTQsvKNCBmDllFrthwT0\nq5YRWSg5JzfBkYpyuzo91sq54MR0/GJd5zD5Kpbn/y4+6bqVDZ5/R801sQeitKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU34dNU4ClLqzh0h2n0+qSXSGp4/UwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBhVwXBhbHVx5DZjHuGJLLnvczyMY1H\nEmPta2P3Z6yiJgIgcm4JoRF64IEq8L6xdL0pijIP6ufOs3l8UGMdZ4o5KaQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6650", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6650` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISARh5X6JRzobZ4b+dMVTs5ABYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0YTljYTZlLTc3MDYtNDM4My1iOGNlLTcwMDU5MWEwOWU1MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUxODJiNTItMmVm\nZi00NzNhLThlZWQtMzNkODNlZjA4Y2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEatSeM0enYNWCq/r97OEZ8ymJP5M9fPg+P3TV+Jwam6xnoslkS57aB/jaFNlZ\nUtJPEN7osfxEt9emCnhhZu4PPqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJFTPLXQ2QAoO234QbikMGFUcSnDMB8GA1UdIwQY\nMBaAFPPBTNaDvJa68D76TaTDzqhOwBwXMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAnJlJmVGd8Oc/oEQVTvOJV8lshV5PvSzW\n+Dp9uN9mbcoCIQDkeEHtT0GqitNL3zq2xjH006uwicDb6mpRUA0R6YDKjw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYFM9DjO80fUW7EHmFfD8a3sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGE5Y2E2ZS03NzA2LTQzODMtYjhjZS03MDA1OTFhMDllNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaVT1y9rbV7KZ9Kh22O7BFp9LCcOtoYMHcb/JSbrYaoUV+\nwVa3L79rldkgCVtN7TNorwYQv2rm5DWp0wtQO2Fpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU88FM1oO8lrrwPvpNpMPOqE7A\nHBcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZJf0Oc9Ie/sqTmVmHmtArpR+AWsu8XnYzkdtrLR5cMwCID6a9BRQ+dRg\n2rL4Po5O2MD2Q364FfuZJR+0+l5PGvJU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUbyOLu/HJLbX0Rdsn9B2xnkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUxODJiNTItMmVmZi00NzNhLThlZWQtMzNkODNlZjA4Y2VkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTNiNzkxYTQtMTI5Yi00MGM5LWIxOTUtODA4ZmY5NTg0\nNDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJlAyrxU9EJ/j4Vo/2yL+FGXJ\ndT70lFpaHzXiQ6WCxpAvglQSng5JXxGTRf63+5lV4Y2HD7VwagqbWlPFgwyVeaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkVM8tdDZACg7bfhBuKQwYVRxKcMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA6l3Fef9DPIijwohtXWQ3bPk1m9H8\nfSxuKDIml5fXnqUCIFvT2/00BoqT5jwgrP8DQTGdsdf/b37Gq2tnYeNiFd8p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6651", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6651` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAeqS+nLm+9iqd6dg3PI/CaMuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjOGJjZDlhLTAyZDYtNDE5NS04NDFmLWNkODZiNmI2YTBmMDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY5ODQwZGItYzI0\nYy00YTE5LWI4MGYtMzg0M2RjNmRkYjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjKIlXZlD1X7CAIjkfLGBZN2uHW1YvpIJ2Ljct4z1l+XgxOdMH2G0OqS7TT+S\nN/CFijPNylfFy93X+ljZuFt1a6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCI5hx+AuHsRYP4bWHZqPs0swcj+MB8GA1UdIwQY\nMBaAFNuYUneXdffYETFVZ6zQwsXOoqCVMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAuH2uYdbIIa8mwucoENIYNhlqE4PKt9BM\n3VW6m/gTfUgCIHh01Ei3LcB/YbPLNSJjNmuD5EfcqS0hW3A48fB0iTNS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeCHxEJgJSP45aIIWr+z753FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzhiY2Q5YS0wMmQ2LTQxOTUtODQxZi1jZDg2YjZiNmEwZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEfNZfTx+CmL019BJs5y2SkS397vO93dTsFxkUszlLzVDX\nbHbVsodZRWxHfTKLulRszOIsrJLFN3N6kHKvRTM+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU25hSd5d199gRMVVnrNDCxc6i\noJUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIdNnkkmhLr86zsUItZSPGMrVqmWzJxpsM6OJ9UenCV4CIQCpz4rTy8Ww\ni8Cda1Tc9594KyebZ+A78N9QZ8h2o9KJKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAV2N3+VZi5V0RV1UNo1t2Q19MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY5ODQwZGItYzI0Yy00YTE5LWI4MGYtMzg0M2RjNmRkYjc5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDg5MTg5NmEtYTI1Mi00NmEzLWI1YTItZGNiYWYzMDJm\nZDFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV3dwCwJWV+d+ap6BqJKOrI4W\nYuUKnsf4UKKs8J+zUzQrchXTNgINUecx9oNohWFxSbezMu8if2oz/YUoA3BnBKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIjmHH4C4exFg/htYdmo+zSzByP4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAyzf3R0l4i25wjRWSjK/nc7SYG0+U\nqMb3KHUVwUJeN+kCIQDwIFUAQQWbpFXukvBvj+SowfkWAU3FrhCRHzkDqYyCwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6652", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6652` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAX6miZ9mM1ZL1AYzSrTCMFJoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkODI2OTNjLWE2MjMtNGEzNy1hNTU1LTc0MTk0MTlhMzU3NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg3NzY1NzgtMDY1\nMy00YzM2LWIwY2EtYTMzZjkwMjkwOTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERm5xqNvtrY8EuImU6RNJrr4nmXve8fE0I+RK/H/UQwzXJix6KNBXvy4d7CJM\n++MsGx7Zn8xxX+Hzyvr7rwJYbqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQlhFlwKGKH+MVqZDUQ4BYU1cxf7DAfBgNVHSME\nGDAWgBRY8Z/IfC6Lvhumhtd1mSwDnRuL7jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICLSvnOXP+IW3ccH2zCdBPZr6MIchuQP\nBDD3AyCnMR7GAiEA+ZkOfbUu1nYASs6elA8NC1CjdYuQ7HrRxJayhmYZ3Qc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT7vt9T1iaI7d9Zgp7AxSQJ3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDgyNjkzYy1hNjIzLTRhMzctYTU1NS03NDE5NDE5YTM1NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfJbGtmxUztEtLB3+aA1LN0oFiH2wLlpHGeJdbFEJxAU4P\ngCLddAInwSXB4YWShkdiwFkmpo8lArXODAt+zPsIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWPGfyHwui74bpobXdZksA50b\ni+4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALW69oRoHb1FHdGHLx0UtaXY75/vE6ONCe8SWP8dU5HTAiBSRE0oWjpk\nK9afW3NOo99PQHoFIwQnC5SM1j+TB2sosw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATyF7iSkRSztCvYU/GlXSa92MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg3NzY1NzgtMDY1My00YzM2LWIwY2EtYTMzZjkwMjkwOTVlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWUxMTcxMmUtMGM0NS00Mzc5LWE2OTMtOWI4ZGU0MGIy\nOGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuaQq1/UILHL4gpzADP/kQjtm\nOCZwG0RKGEOVH18tTrCoJuFkv5E1fkxsUL5hSGvCHBloWfmCqUmSshvlq6srr6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJYRZcChih/jFamQ1EOAWFNXMX+wwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB6TqxuAKBAdK1loFCz1WvbjXEVQ2Z3\nmMSCc6E5tUlqKgIgWeR63lB/SGP7miQGG09DkrpvWiAWdsXb53gldH+0I9E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6653", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6653` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAT02fJCUB3D6qIGHx7dW/OCHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1MDYyZWYwLTA1NDQtNDhjZi05MmIxLTFmMTVkZjMxZDZmNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTMxM2VmMDgtOTdi\nZC00NWM0LTk4ZGEtNjU1ZTI1MGIyMjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGnfIs0o2apws3EM5KJTswc+rmQmJaUUFPSEHc8nCLgLl5xynUXkpIYxLKiKm\nb1mOh6YTivEkfPxvEd2SSrolS6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULEoPE/RNk36rSyq1kobSCmSWgZ4wHwYDVR0j\nBBgwFoAUI4L7MSvRkM8I3qLitI+eHtP5Uf8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA4yLBOphW805O\nVi2MwiR3ezk60pwvPMXyPTPxtU9omnECIQDgn2zbHtIOIjvGRuTD+D07yOfh/GFG\ncmpa7gVYw9vG2g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbXGiXEvLLr0f5Rc1W3wy+jIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTA2MmVmMC0wNTQ0LTQ4Y2YtOTJiMS0xZjE1ZGYzMWQ2ZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAnw7veTVmyU/6pzj1MgwKFfO2lrYT3hcysI0n3GwQdqqA\nrcMRB48uLQd/+2vlyJakGyVflZnpVdzRgjWchvUGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI4L7MSvRkM8I3qLitI+eHtP5\nUf8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVFcY6Z7ZlF7728RBvb4tpPz43Azqdt/ars3rkoXO244CIEFWGcAJ0HAV\n2B9eg4RNmWBCZt9iBMzQ8fYKaFP1AITh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcP+nPnAcafeL81bE01sj83RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTMxM2VmMDgtOTdiZC00NWM0LTk4ZGEtNjU1ZTI1MGIyMjdmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ZlYzU4NWMtZjc4ZC00MDIyLWJlYWItOGQ4MTkzZTk3\nOThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL5uYaUThsEHT9MXPIluHuK9j\nh3TFnjVUk1M56wt2uTk7OdkcLo6HMTBcWrV610BFaFTkF+q965dkOYrmnDw8cKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULEoPE/RNk36rSyq1kobSCmSWgZ4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBznJZFu2vKtGSmdnKBFTPnWiKf/g0t\nbBI+7AqXVoRhdAIhAMCfvY0C1OfBma8sY3huQbwDTLjV0Ip8W6XNyBTYthyV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6654", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6654` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZHRkAnOaNQ/mpIFL9dqNuxdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4NThhOTg1LWY2ZmMtNGMyNS05Yzk2LWMxNjJlZGEzMTMzZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWMyYjAxMjAtNmY4\nOS00OTQyLWJhMDktZDc4MGUzYThiMDg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtRKlkBOKshCEHIw80cUFz28A1PrA4VhYbAkdXC38/+jF+aqrbVLALas7OKtI\nm9g+BR8f9ekFXdOkZ9tysFCaEKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFM6lOJDHigftBntZ/G/BRGChdPMwHwYDVR0j\nBBgwFoAUSsBCTLMRywzCDfpl+Yu5ffNDrmIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiA/czXVT28k6mW9\nL38kdkREtyCQMScsV/fvu9Ni6WUGnQIhAJrWis2dVuHXfpqxylw8hdBSiupEfIuz\nB3kIvQHNEmYf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVYaHeW3dpoItEkvx6+LsJwmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODU4YTk4NS1mNmZjLTRjMjUtOWM5Ni1jMTYyZWRhMzEzM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKLYMW5BxS2942uXhBjQQzguEHwz8S9zS6SIubAUUaQMDb\nGYXIXb0RBlFUnS8S2pdQcjO7b47h8949qOEkS/MSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSsBCTLMRywzCDfpl+Yu5ffND\nrmIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOXo0PokBpyXO8Jw89oOGCT41WfWLyCihlxaFcuoAb1kAiAC8Vh0AHAn\n64fPt5J5sQ1uZCjXI0SszSYWZomrqyA7gw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARl2r3uP+rN9DueauxejEkIjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWMyYjAxMjAtNmY4OS00OTQyLWJhMDktZDc4MGUzYThiMDg4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2EyNTA5ODktMjJkMi00NWJhLWI1MGQtMDViZDNmY2Fm\nNDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDA4aZsIlG6RJO8ifkAUvAEgE\ndhqXUYq9i5v/ji4Jc7b1x3U/Zxon96KZi/Qpnk7iPbvUrKc7Vs8vOt7CObEnN6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFM6lOJDHigftBntZ/G/BRGChdPMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAh8NQWGyfV/MjldXDv4V/feVtTGeR\nethJrsSmOLiHvY0CIQCzAVVQwFUO2UVl/DzPl9Y4JOdDy+nOztEtEYEXAQXXaQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6655", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6655` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISARJToH9Zd5255vrgr1ASLEiMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxODkxYmI4LWMwZDMtNDljMi05MzY2LWM5ZTA3YmFmNTdkODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWEyYTkwZTEtYjcx\nMi00MmY4LTkwMWQtNjBkMWU2OWQ2MDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED049zd7IwTzF4WYRHad7PNjNCt/cUGRPr5jKTiPFM+vIQ45dIZd1VE469Iqc\nD/o31bGJbshJUPf7LFZqCW5oyqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb4Rphqa87nsaHw6hWuk0WZnbMlowHwYDVR0j\nBBgwFoAUSk6Ywu0wFlgxj4ScmvX6OuDEEFEwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAvU8V1WeguJo1WC1TMRD3\nWmCrxpPd6OWjaqGn4cUQ3c8CIQDwlTlhmf5LtKYAAwcIjD1bkB88GoM++EXRJYBi\nwMl3ZA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVOiYyMahdeJAzOQn6dPca09MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTg5MWJiOC1jMGQzLTQ5YzItOTM2Ni1jOWUwN2JhZjU3ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMiDjVDkqFeRd+wEhhKBI1z51lp2//QKvojDtG6b+ulMWR\nMtgyQpEt+mY/h77xQpsn+/I+KUNyDu5TX5vcWluOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSk6Ywu0wFlgxj4ScmvX6OuDE\nEFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI2nBTtRoyQ/pKXYfgHZDT4IfFpH9p75mFvLwTCEX0fcAiEAwimD2BdT\nre2Dogm2J3boeDgRgfuNBOSJAmhsSnHZPcM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdyw0zsfRpJ1wMKJiaqR8X3dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWEyYTkwZTEtYjcxMi00MmY4LTkwMWQtNjBkMWU2OWQ2MDk4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjAyMDc1MTItZDM4Ny00MGU4LWFkMzYtNzExYWI2NDU3\nZDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8r/4U15Tsi+agoqJLt+uymy1\nV4SikrJphkOuwN7xtX2HA5mUiubizrIrn/Tk826dBo8RE4DC+hu/cUUP3jrp3qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUb4Rphqa87nsaHw6hWuk0WZnbMlowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB5swP2kFrFhD96T3Zx9sLnjf+s3mYj\nPj0+3LfrlUVV5AIgaOdI6ZUWOvdhg0lFjv1+tHzv0k/je7gl9NXurpAYr6A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6656", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6656` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAR3nzGRDmA4G349i7IqJK6BUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiMzk5ZmVkLWY5YjItNGZiNi04MTZiLWJjMjU0YTMyYjllNzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNjZGYwMDAtMzUz\nNy00OGRkLTlkODItZWQ0ZmEwMDM3MzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZKegEDuHUElPRQzekf0SWPGG2z2CWpJpVGEn0KsX+dUeFlMca6MZBRyemTmO\n+qYhc9UBvIFbXdQuRkvWnEAeZqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbl9vQTDyPjuHHqPLcVo2O/Df9nYwHwYDVR0j\nBBgwFoAUJuVY2EhzGWRwn/1wYdTILyZ/7jAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiB5Gs32\nQDkOXxj5tKcPMIQi1cd0jQ3J12WiixvQ5GFIzwIgGhG0PC2TYel3kyw6ipwQsyAs\nRQ3bUjt+X4ORcIedqZU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfBuF/PgBqs+KAIRPF8It674MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjM5OWZlZC1mOWIyLTRmYjYtODE2Yi1iYzI1NGEzMmI5ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFU15amjDvQ7rUqqzkhxCWtponyvNCZXC/Ij/32pEw+Rcr\nIR121icGJlu0UnSNQVQZLSm9ahopHYbu55D11sBHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJuVY2EhzGWRwn/1wYdTILyZ/\n7jAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFxJxQvgBBLiBjm8m6e658ts/qaqui4HJfXBEBfPwJ90CIQDZvMZVLJ3q\nEyAKDQVR6ZGVQhMRoq0d1/prEGIG4Me8HA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARSEdQ7wYrAVeJ1MqZEPTGEcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNjZGYwMDAtMzUzNy00OGRkLTlkODItZWQ0ZmEwMDM3MzFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGQwMjdmZmUtYzI5MC00NmNmLWI4MzgtYzBhMzk2ZDhj\nYjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm5/IHqyVbn3RI6tg0RlhG73h\nB4LdS8VL9OLvQ4v7R1DopRITc0vNxOJPUPI1cCtaNrHHpByROVP9PZlixVT3LKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbl9vQTDyPjuHHqPLcVo2O/Df9nYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAskFl3X6R1Yqq8VLgGle94n532AlVJ\nLvaFJ1tU6Of8VwIhAMT/vN2IDdYcDp2y/dxWiYp7/PkY3aUFILhkRMD9SjF4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6657", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6657` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISASEfiVtWdOS6xLLWdhLQgDgpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmMDA3NWQ0LWQ2OTUtNGRjMS1iODZmLTExMmEyODkzZmFhMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTAxZjdkM2UtZmU2\nZS00NGRkLTliOTEtNmZiN2NiMWNiODRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHFPe07Xe9xNdpxNYCno/eeNlWDUSmZVAD3TH4CAi5zUgUhK60obXNqEKrmz+\nT2ngweYGIhE4gHszQKIbqFlouaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY+xlnDgGTx3h9Y67qpIz0vzDBBkwHwYDVR0j\nBBgwFoAUydS6Dn8Dn4H3kFWUhzIB7AL0J4cwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiByv1x8\n2SVWdRqJqrHM6oMpsn28aplOdkfOu5cX6cuRiwIhAJNMybb20RJcBAK+m3UlDroY\ngeVo9WIJKe5dTrl8aL9n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaESl/ftcJkCoYg0VY3KFDElMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjAwNzVkNC1kNjk1LTRkYzEtYjg2Zi0xMTJhMjg5M2ZhYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQN4dABRJZefZEeJ5raUSNinLjAMioI5iwpAIzHc4Wa9l4C\n44BC0yoBslSxDRDJudILUiDpLmmXb1e82QJ22R3lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUydS6Dn8Dn4H3kFWUhzIB7AL0\nJ4cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS/Im84B19lk7vZlwRy1XPbczaorgfs+UYjkTQY8QEgACIQCdKS/np4sS\nM9g1wa99tCSNYPhgHmg7CRhjQevW10X5jA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXWPwKXO/kla3V2zwqq8IdjRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTAxZjdkM2UtZmU2ZS00NGRkLTliOTEtNmZiN2NiMWNiODRmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk0MzJhMDktZDRlNS00MzZmLTg4MWItMTMzOGE1MGM4\nYWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAED6VKJ1RxRryg2a6c6QkWTsoW\npqompthD/jVuiebby+7VJuKz/tku7s937VR4Gm9gq8cA54UM8M5RqSviFZgTAqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY+xlnDgGTx3h9Y67qpIz0vzDBBkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA3TwfrgreC0u6V9py1tXn4NQeNWdX\niUN4t6HXvl12k5ICIQCbL+wpI9A8nNHM75j3YEGPD8YkG62Oj2BivoKhvl2MhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6658", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6658` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAWKwIbXKGCpZIRQwc7gm7VIHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZDc1OTQ3LWEzNWUtNDhlMi1hNzdlLWUwNGNjNDAxMjQxZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRkMmQyNDQtYzAy\nNC00NmI3LWFlNjAtNzExNTJmN2UxNjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgjRYQ49DQ+fBHuKE8VUZKrQ/yoqpqdLzj6gWqFPcyJqZlbCxQTEm8S2mkfNi\nM6SPplj84bNdOPh1Wlxqhpg1FqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFG5cm6Aji53W5Cz37n4zP8nvdHtgMB8GA1UdIwQY\nMBaAFPjur2sPMo2heczRqyfm2Jrbtt9xMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBODfJ2FHnvS2iN0LIMdojvglHTn6mr+DPQ\nbhrapLf7AwIgZou6xYzRj1Z7/jXTVxIm5P7oqgHbjDgzuMK7Xgy577o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbweFHAC15ucZQK3cbf2y/1EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmQ3NTk0Ny1hMzVlLTQ4ZTItYTc3ZS1lMDRjYzQwMTI0MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShhPZF3XD5zoIw2DnBRGUlh7vFdHxyvr2i+4QSX5PZuKLF\np6VvkBjNH105w3iHxhwiCf2fwBY9DsqGaaPeekYWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+O6vaw8yjaF5zNGrJ+bYmtu2\n33EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgURMvJSN5Smcwcji/Rk3kQScxdKzZlOCfUyINK/ZTbOwCIQCO42Z6JdVF\nTvzCwCU8/WTu+GiKaN0S6R6XFFsjICH0ng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWE+UfD807bDal/NW1t3tg4qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRkMmQyNDQtYzAyNC00NmI3LWFlNjAtNzExNTJmN2UxNjFlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmM0YWY5NTMtYmM1Mi00MTUyLWFlMDUtNzJhZGQ4ZGNm\nNzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy4LthUF3C+pPANFx7PAtAN5P\n7sYqvu5yhjxPU7Ytm2IHz0kb16k6F+TNE1NgnX2Pekq19tNq9qIm9ThVqAinnKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUblyboCOLndbkLPfufjM/ye90e2AwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAmRO7SpFmdcSdX6COdBgvqTE+IFS0\nMIEV8/sDwPqw5b8CIHCdJujs26VHkr6+Dx6ibDgaxUURctX1DaLnKcT7S0Lg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6659", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6659` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbCtj9A3RIZRqBb22etgPe2ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiYzc2NWVkLWViNzctNDc1MS04NTkyLWNlM2ViODEzZjlkZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ1Yjg5NzUtNzJk\nMC00NWIyLTlkNjgtMWJlM2U3YmI5YjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiWSpCkE57pv/StGBhcGsgR0/efEhDQOCcWJyGjDdXua58o4gZeWk9QWqiz/2\nqaZpdP6GLrF0ZmmpETUXrQ/aTKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH7vmQp+eYuR1+/gtuaXhDJGsFC0wHwYDVR0j\nBBgwFoAUPIhrG2TB9dZI3Zwvoj36Lp2ya2cwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJG1Re9Od7Nu\nSDoLRIZWqo0qJAdHYUg9TIPlHwpsUimDAiBFJfVa0Fgf6oDgqV77cwyBxrjYlhN5\n2BEwWYY4O1RBUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb8Qou8aMEtE2iHU7r92Um6OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmM3NjVlZC1lYjc3LTQ3NTEtODU5Mi1jZTNlYjgxM2Y5ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATT1jhLibionY84leCntpKjuMXlS1vBzCR6tum4j5XoNz0X\n4VIM/bYUxja1IPpWlKNY8m0GoD2ivfYA2Zrvv3aJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPIhrG2TB9dZI3Zwvoj36Lp2y\na2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOsv7Z6zgnYPheCwx7MsAVLgw1xL+GLUsM0UgMQr//nKAiEA++2kdjQZ\ndkSTNKYt+mLoWsC0Owt/stfoUGiz3/kCCK0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAf0yDchxZvapN9Q81ELK6mExMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ1Yjg5NzUtNzJkMC00NWIyLTlkNjgtMWJlM2U3YmI5YjQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTVjNGJmMzItOGVjOC00MjQyLTgyMWYtYTU0NGYyM2I1\nMGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9jgmK7QYTboZEHg3zDbzZJv+\n6DXKgTm63Vy8Bh8Ch7lhT0zC4z8BJ4OYiqiGh6uIJ/AOVHKKeIwE5Min3pOmOqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH7vmQp+eYuR1+/gtuaXhDJGsFC0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBaUpPn4f2LPt5lz5uJvhNap2Iea6kU\nrJrhw8fYo4Md4gIhAJqblmSz3BsolhIlzxyBki/8+PTDJyhpuB/zRAfLHmVY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6660", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6660` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAW1ewZAJ3+7d5HxykG9t3jxRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNTQ5ZTk2LTQzNjQtNGJlZi05ZGZhLTUwYjA5YWE3MzBjYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODUzMTIzZjItYjJl\nOS00NzFiLTg1ZjYtMjJmMGU4YmYxNWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVPjlqI4YWccJz69UqXaf4NX+84f2P4YU93oh5S0DXj+eem64TY1/4o/rtpDZ\nj627er7fNe5fk4TvX7Ela0JJ6aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSee6DtYfe147vBlM0GV0NF74PCAwHwYDVR0j\nBBgwFoAUC3q+Zj+cR8C9Dl+B3ik02pCWznMwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJlyleBpj7le\nsRoy/gRlg448hr+t9EhByaD8XJffds/TAiBVDGJ79Vo9r6iP2S6hedauRDhtT5z0\nUeV6dIHnvFDnsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQRCtbeW2ixGBLTg/4IfRoIZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjU0OWU5Ni00MzY0LTRiZWYtOWRmYS01MGIwOWFhNzMwY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvhRqJOXf5EafTCmdoWLoDCKAjMdB3HiVIPFU5ezz3+cHM\nHoZ3pVGwhBq2zlQsVr6tBABYDRatb0C/hLsUhh+Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC3q+Zj+cR8C9Dl+B3ik02pCW\nznMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcY0kadjX2ubvF8ebIpRrty7BNa7n+gET6Tt3vioWcOgCIAWUKI8Tmda8\nUwnRfUWRgiQ2eaeYEz4V3N5twbQg9vo5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAX5viD+CazW0FrkYwq8HnWljMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODUzMTIzZjItYjJlOS00NzFiLTg1ZjYtMjJmMGU4YmYxNWE5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmY2YzdjZTgtYjI1MC00ZDRkLWFiZTQtOGExMGNhZjE1\nOTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4SrsGk5wIoZCgbCUtMRi7tGw\nrM0v0fXxbEMBqTKiCJeVmdwGbybju249sKvcR54h7dhfMRI47ilkZPM6Zg2zyaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSee6DtYfe147vBlM0GV0NF74PCAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAE+49epfbgJuOgW4h0gfhjeEsxTQQp\n5joghbuUlsSLtwIhAJSWqEGZGxr67GO6iZFWs04Lk0+uYDisbGHza63An4+S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6661", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6661` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWrpo+mWko9jpUsT8hh5UM0BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3YmJmMTFjLTA0ODktNDM0Ni1iYTlhLTQ1OWRjZGQwODk4ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E1NjNhMTAtYmJl\nZi00Njk1LTgzNDItOTAyMGY0MTM1ZDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELnLNu1QAe6oyg2P0uh0NcYzHiwjrKOnwwC3BLc4rLk45NRkpFn40nvKn6xve\nRTkR9bQ5XyHtoD/p+krYMd5WPqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj7MFs2dr3zya9GG9pF+Z99AFeKcwHwYDVR0j\nBBgwFoAUB1KnVfQiMDhPUmao5ySzBOEgOuIwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCFmOt+cyTQ\nFklxFDHnvqP+Hp2n++pmAntIEY6Yxscy9gIgO/1lTBviRUrvU4Xr9j6D0Skztz88\nGuRKCc8f1fgu2fE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe+mG9wukyGoLgVQF/U1RZjNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nN2JiZjExYy0wNDg5LTQzNDYtYmE5YS00NTlkY2RkMDg5ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASO6qdbDYmHCzz3D9GSYFQG4JdecUZnwcNE94NRTUi1x+84\n4x4DDfXRD24UfSDCzVlBxTDh93uzTcs4g/9pvWyCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB1KnVfQiMDhPUmao5ySzBOEg\nOuIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOd+OQkMyBtBeL4FI1puA5G9y7w8xZ5OtPjYDNUckqFtAiBOPDMhzwug\nheChc+Yjrf3AuUOTx7vWJaXqDNANLBivSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAb4BF2cKdydobKBToiMBgMx7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E1NjNhMTAtYmJlZi00Njk1LTgzNDItOTAyMGY0MTM1ZDZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODY1MmI5MGMtNjRhZi00MjZkLThiZWItY2E2ODNiZTRh\nYjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJnIOjcfHLvS9XfB7NB5Lu+qs\nZ2dJhGqhFpH5sLm04iXc7KjYJuO8tNuimVJIp8Eq6oSKIU8CakArVMKo6zS60KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUj7MFs2dr3zya9GG9pF+Z99AFeKcwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA21AgpczozbKHlcYxkYMQgym9Q02IK\nnwS+22bIUEOk1wIhAP08zWHCX+3AgNiFaB6SFV+CmxmoUPV6U8APjV4fVQYT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6662", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6662` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAe/LBGrCyT3C5Z8LBT1b5eN8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmNDA3MjdiLWQyODAtNDc1Yi04Nzk5LTAzMTg1ZjZjNzU0MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBmNTAxYTAtZWZh\nMy00MTAwLWE3NmQtMjg0MjhiZTdkZmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESvN7G8vnvX68ZnCRtahD8hc56PYGjGHjmxSt7MyHZP73PTgMzLHYLOtSRDoA\nwgs1vjdK5b0JU87qVKmtP7WXL6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoF2rRSpYgEgkHmqeZa3Kqx9fH/cwHwYDVR0j\nBBgwFoAUzx+n+HgxgDxqxhyhHOq5QkoR0e8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDDa8+kJOeg8XbT777yh6jGLjJF3es45oKESM1XIfGwkwIgfAm0YT245I3s\nIxQoi9GULTXg9gNrhZDaO/+HHvumT18=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARSAb7sXc12qoShL9xX1wQ95MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjQwNzI3Yi1kMjgwLTQ3NWItODc5OS0wMzE4NWY2Yzc1NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQd9te3wUnLiFRQWmWnRWY7dRFYPkqZzC5BWNZWJihiZI2O\nm/G6zYbQYaBuMsyLGoE/pX4TxDIdMlViLwaW8aFzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzx+n+HgxgDxqxhyhHOq5QkoR\n0e8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL0sHMlXxIsHlBLLIugq4jRxynor6aCF1ZIjO8AD0GXIAiBZ95clqb7J\nqLwHfRBjuJiDvyobYJYurlKMBJEvCOEhYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASg+W9p9Om+Hau5SCU7Nw55YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBmNTAxYTAtZWZhMy00MTAwLWE3NmQtMjg0MjhiZTdkZmZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmY4ZDA2MmUtNzg3OS00OTBhLWI0OTctY2Q5OTVjMDli\nYTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsc9CkwPRvVQ6OYjux2bsMXnJ\nqQuIpLzeMbnFZOOCEaONDR+J+St14Z8oDmb624xKnjO3RLoRiIKkydUrfs2NXqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoF2rRSpYgEgkHmqeZa3Kqx9fH/cwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBvRKgR4wNhxgNTsNv2/Pk7GbQaZwA3\nmr9Ob9Y9Wks9QwIgUgaa3uXYDUG05bgHel3pLUHWbxcGV/xEDKdvperdxKw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6663", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6663` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZ0ucCX7ySLaqFCardeloiZMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlZWE1ODE5LWE0ZGItNDM5ZC04YTdhLTQ4MzM2MjEwNzAwOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI0YmE1MjUtMjFh\nMS00Y2M5LWJmNjEtOGExNWVjNmJjNWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElA87zA/sybgrX/n+NPJa2lkl/6RpY8VSJVnEwbXbAoJ6sJ7YUH02UmLBfjxI\njGWNJvWIjcExbxUjmwT0DoJEw6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZcdZtW5oJbsLHjzPSig8Ajt/hR8wHwYDVR0j\nBBgwFoAUnkYlkd8DJU27qgfgctxqLuVKz00wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC7U+BlSGn8P6ntKRL8hE0X9C9itQnU1ZVetC+J06MsvAIgBYI49UxfBZej\nI4niyA47u6Yqtx+8ukkyK11AhzdKKAk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbE/FeXn4S7anXIzlwnq4gG2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWVhNTgxOS1hNGRiLTQzOWQtOGE3YS00ODMzNjIxMDcwMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8e5pyij5sGnEQI5V6S0lyFoeoKQFSLIiOAlbUt1dH/zN6\n0BQIk3UHTciypYOk65MWHym6QiMEc2DbDKD2HG5eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnkYlkd8DJU27qgfgctxqLuVK\nz00wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOG4NvrSHWAE2VSyRlkLWMryVFBXmAYY5DmxY6+ds5FvAiEAjUbQoERb\nSOMi8VO2wvk2+sZUidgFrFrwwe14dvo66G4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXb4j+m3KbN9CX5vapGMsnNfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI0YmE1MjUtMjFhMS00Y2M5LWJmNjEtOGExNWVjNmJjNWRhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZiMGEzMTYtMjQzYS00ZjQ3LTk0OTgtNDE5OTE4MTE4\nYTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMA/FHbG6fXhULcuuELnaW7vR\nrpY0vmvIuBfQgFTNn+qt2tky+9OlP1dG75QcqJsp+LoH/3/744v4k7OPYOkiZKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZcdZtW5oJbsLHjzPSig8Ajt/hR8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA0VCZR1q4tKZl71M73i0YLREczc3pe\neErqZNKJznFPHAIgSrb5XmvuIbA6C9L40cyKkEZxontwKgg4c5JOwroiZZY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6664", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6664` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISASgvPfC41eYx6woBN6WbkPlDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2MDFjYjgyLTFkZTAtNDJhNC1hMTdkLTdkNGRlOGM2YTFiMzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZiMzMwYjQtMjgx\nYi00ZDA4LTk4YzktNzFiMWZhYWViMzQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMzDj1hKFfPiTmD+Mmr9XRO4aUL3kJa0lYSweLwrbzg8B7y9oQcuKqbYZaiQr\nHY/zo5Zps1kz87Xt0iAi6jyKK6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7R2wi3u4UUs35REZDWvNC9CudRwwHwYDVR0j\nBBgwFoAU5w3LTS8tTi/BpVuS3rfK8vwk/cgwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD6\nEjK2rNzm0B96TSW4ojpkGiVkzWkXOK+lIBpy8LYO8AIhAL7kAyYxl7/qgBAtR9Jl\n8gYYegaz2j6oMQilhaeZK38P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZHg+a/RZUuc3wRvshahiOsrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjAxY2I4Mi0xZGUwLTQyYTQtYTE3ZC03ZDRkZThjNmExYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeC4GACyIaViAa6PDqksY2BoCPcMBm+Z/zuK9suURO8/6L\nJ4qeW8IWN4a9x4VEbdOD6+BUlSCz8BF7FRsHmuG1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5w3LTS8tTi/BpVuS3rfK8vwk\n/cgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAWedHw90mVqZ+QJ8mys01Ym8pHEpI7/zVpjPSBCqxHQCIFNxhNQxHMG0\n9ft9QBTnpvo7Ww5Ut9cFBlsMgF/wyNCj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQIuiS7IjpXCKa6I6/XMrD6JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZiMzMwYjQtMjgxYi00ZDA4LTk4YzktNzFiMWZhYWViMzQ5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDkwMGVjZjctZWZlNy00OGIyLTg5MjAtNGZhOWIyNzE5\nMjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExG70SWI7uzC9B3NdobQhW4rm\nly7jzhGdvaHZm/VDWmZXvuUB43ga+hCU4DeNYzXyJ7UASYMS/Khy0ma+EXgZSKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7R2wi3u4UUs35REZDWvNC9CudRwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAYCJhRRxBx8dbColwHvi/gSVqsh3h/\nsNPl0iGdVNoaiQIgAO9KLcep2kzfX1+vgW8F3I5k0z1Ps2tPgXRjO1WPUc4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6665", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6665` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYrlthSbhevRDeEQTrkk7B0cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1YWQzZDcyLTc5ODQtNDY5YS05OGQ1LTg4YzU4YzY0OTg4YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZjN2EyMzEtMWY2\nNi00NzQ4LTgyYjctZGZkNDkwNTVlZTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP2Ya2LWgo0kAZNtCIBD9yaX4EHBF7i0tbaRMwKcAnFv1rQc+Tv4/p4w3F81C\nldLjtlAeo3DrfYUaw9jief2gEqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyEqDDiqOCsWSl6OE+OmtPUoPTKYwHwYDVR0j\nBBgwFoAUamc+iVTWKD4gEdjYVj75uvDUzCIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCc/FQAYxD30vF3/tF/iFYFefSNNR9TwsbkEiXyKSkHZgIgdhaw\nlg0BAAMWuJtG+vROQt8td10cwVA92g/rvdkN0CE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYIKXeHu+XR7Ja9xyml2zIt/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWFkM2Q3Mi03OTg0LTQ2OWEtOThkNS04OGM1OGM2NDk4OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgvyhLrgvFLTfH6LVOto7mhOt1NZeHM8smWz6NhgSJYIlM\nEG9qe1b3Oh0urBzF3oX4asKqA6giQcg1ufOtaB4Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUamc+iVTWKD4gEdjYVj75uvDU\nzCIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANAJPWFAZheGuxZthaOpIh4EkSR1ysHqbWpxSi4u1IdqAiAo+M/lgDYk\nwQ7jaT0FjO+RCIvrRPjiXTpvEdgnGsXD6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYMG73nAZhrnl/tBHPeszS/TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZjN2EyMzEtMWY2Ni00NzQ4LTgyYjctZGZkNDkwNTVlZTBjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDFlMmNhMTgtMjk1NS00YTBlLTllYzgtYmU1M2ZkOGFh\nMzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoPuvCKvFqnrOcZ+pUusAk/hE\niaqK/q/R8t5IliKcwVrwGDUf14JTf6HLipyitr+v5oZH+B9fE8uemWVYJJnpFaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyEqDDiqOCsWSl6OE+OmtPUoPTKYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEApTpyfskrJ9M9sCYRJzJLWdKVrAe9\nIF1eEvP8bbvlq3ECIBMQnrV0/ZCfxWmgPyaLhv7/oS3OGJ4iyknuFvV1KfRj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6666", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6666` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYt28xmr/9D96bOUYQCsbxXrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4NzBmMDEyLTVkYWYtNDI0OC1iZjNiLTdkODQwNjAzZmU4MzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjczYTlkZjgtNTNm\nYS00ZTk0LTk1ODMtOTdmNWFlY2I4ZjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsx15LQAWpRLgX1iIq7XnqRDG+0M4cWOn4jluGIUJRsGM0KxiqNC28aO7YzRo\nZEwXtAbZm8tePmJA/aGoeYRdhaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGWoAXHdc3bMMOEJqT+I+4vUz3b8wHwYDVR0j\nBBgwFoAU74n7UM1STVBKY+0nyJcY+j9Alq4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCICXk5zff+X5Ut4U9N8x2ifxt9Kb2501Yc9NoGB3dYmkEAiEAkE3t\nEaVnNs7u2T7/K9iNFnrVe2Hrxa8eKom/5y3VooE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbGZiJUjf+HZgGOAobm/MiCfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODcwZjAxMi01ZGFmLTQyNDgtYmYzYi03ZDg0MDYwM2ZlODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrOApL4Sd/55crM5IqkQotRUSmP6AxAXQpIpmUjZKMTZ+e\nxJbHP2INU4/kWQ4kL7q+4DXqtZg1af/No8Gh6wGro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU74n7UM1STVBKY+0nyJcY+j9A\nlq4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZgyMA7ul6q/BOCBoX7TMe6cP8RvIEbCFcGJCDpKH8LkCIQDKPlbqfX1p\n3TWn+egHpBwdedCiGC6l1sCukIaqJvtM1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQ5rqcuV9YOEzx4BoCveuwkZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjczYTlkZjgtNTNmYS00ZTk0LTk1ODMtOTdmNWFlY2I4ZjkzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDBlOGRiNTMtZjg5NS00NjMxLTgzNWQtZTc1OWIyNzdm\nYmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkTdP4lxd06vm6Ib0M0pRIcdT\nHIvLA7uFPpODjZHYldQNIGs6q3cED31SQi5NzTYotJ7NILJlMXUxe1YU429l9KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGWoAXHdc3bMMOEJqT+I+4vUz3b8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBKY/c0bWhFX4dyoJC5D3Csbx0JEymn\nC2K+QjiTAZP50QIhAO3a0gqhcDTrc+nhaw/rIPW2Ak4VWH83g7eWqwL54mbd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6667", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6667` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZGAsa2mnvBqZBywEu2HoKyNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0N2M2NzI3LWVjMjEtNDg2Mi1hMzkwLWZiNGY2YmE1OTc2ZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWMwMjM4MDQtYWFh\nZi00N2Y2LWI3ODgtMGM5NmY2NjA0OWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeYVz1aNZktTVRNpIigsKLLLiBEM9ekYaGLNVbl5msijNn72btR1Dx5zykFqX\nYoaCsuU2ioslXSEbOsmEBfz23KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJEyqOAppl8FzL+j/BjWA85VZm2uMB8GA1UdIwQY\nMBaAFNRxZgqJgG9o53pR1N/plARwkjQ1MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3PYXFlY5yw8c5KObuuDmoDmOIHxfIKth\niSVZFM+wfHwCICUb7CaAvLFB7S5GPA+k8+w3Be2hT3Pxc7xJGu9Zbuv5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa3WsKGE6P8Wu7tfMdl0iZJuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDdjNjcyNy1lYzIxLTQ4NjItYTM5MC1mYjRmNmJhNTk3NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTGGhNb3UEeQwMCGP6zYxz/ivGzZQnw+FRwkcN2VRq48st\n4u//DWpAAOHsJVEUzBaiHvRrj6iFkw8woHmFrncLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1HFmComAb2jnelHU3+mUBHCS\nNDUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMtEmEZNSGkiT28DJei+Q0YyZMhi8NnDl5ORmFM51PhZAiAoxBP762Bh\nlKVkX1k75P1d6+kC0a+gKtWMhA3X1QUDHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXfzkb+pRSB0oI6xhtf+VI9YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWMwMjM4MDQtYWFhZi00N2Y2LWI3ODgtMGM5NmY2NjA0OWMxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDRmODg4YjAtMDM1NS00NjJhLWFkNGMtMzFlZjVjYjc2\nMDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/lTNi+b2ih/wECN0GPwlW0fm\nng4XCDuhn59+5qGcJlfdT6MkDzsCLlqruZBJsW2YrljspPJdSh9Lp5xEEyLGQqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkTKo4CmmXwXMv6P8GNYDzlVmba4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAIPJBSMMvbmBp8MpS8UHAY+VpJlQdX\nTSZmvf3iKX17swIgLRE6JeUqats8tLxB382BKddRcp2NPKRXGULVA+64PVA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6668", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6668` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAYfJZifyXyGut0TQB5I3DjZAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ZDc5ZDhiLTE2NWEtNGRhYS05ZGFkLTI4YzdmMDQ3ZTg3NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk3ODVkNzgtYmFh\nNi00N2RjLWI3Y2UtN2EwZDg1N2VkMDgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5tkZXspi7t2nwEDtkW6I6ijEEJkZMXqg3ewwR/yUsTJnEHnf/BCnE/iSYtP5\ngLwWkYqMK7QvDt8Ywr/yvBcBVKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyF1kdBVjGzfEQeNq2/1MkwuCZXMwHwYDVR0j\nBBgwFoAU0CJZLk3yc8AQaVTCGokfgTR26B4wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgKLaglcbGV4kA\nXBcuVd7CekXyytbUuvbDZrNsGt4N6nUCIDOp3ifdG/w9o2fIbRMnHz4PbjIfYesY\nXl7tSndXrRbD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcDJHSRvg4+WqACVRml/KsKgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWQ3OWQ4Yi0xNjVhLTRkYWEtOWRhZC0yOGM3ZjA0N2U4NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFoKSxe7WLKuzwtAZRUT75TdzfP9eYBJVIQ2H64gvJ//SL\n8xJT1RKQDguOaSEGz2RY1YkjFrBOVRVcAGYC4S/so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0CJZLk3yc8AQaVTCGokfgTR2\n6B4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI0s2wlfLxRTDAmO9d2sij09EmNg6ziDqYxJDheDieSOAiBNiRneNODW\n9GguB8uQIS2kuEUdtM4905dKX2Fa3wA+mQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbffcQNXCNbXt2Te03ssdqfjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk3ODVkNzgtYmFhNi00N2RjLWI3Y2UtN2EwZDg1N2VkMDgwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzU4ZmY1MDItYTc1ZS00MWMxLTkwM2UtZmJhMDFkMDM4\nMjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJOknHJY5/nYo+bhXs68edyW7\ndYp25UMA7ZBr1PQ8qqKjgSVU63URnBDPdLikXhhHP82ZIaa71IM68zdyziIK5KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyF1kdBVjGzfEQeNq2/1MkwuCZXMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAwut4I1eDwEb4ZJcpsJAjKrsrXg/c\nTy5OayjOiSYIMRcCIQClnWT4cAK3hqcybq142f+66AGCkK4bPx2YFTtb3tVVFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6669", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6669` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAeHBdsSfTWcq4Rd6SBIAFZC8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiYzI0NDNhLWJhYWQtNDc0Mi1hMDhjLWRmNzIyMmEwNTA5ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhmYjE2MzUtYzA1\nMS00ODAzLWIzODItNTcxYWY0ZjZhNDMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1jAtfoSAdYUYlSodTrnhMJkQsLZKiXwkxV7XfKcyBRgyZzUtzgOMm0drhKjT\nMJ3sfDaZJeZHQf/L8R2DjTq85aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjsaig7VEBIhLS/tOE+K2CtoXGfQwHwYDVR0j\nBBgwFoAUkcguer20OF8o1LS/+/gfFzfRI84wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOTYWnMEApiR\nohH8q7c0aUXw5+l0gyJn5kVZRTFT9SaYAiAe4lepjlwbEGHWRi/bdV5U5hLeZHLp\nxi9sbSyotwLPMA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQhn+1wYv6qadqUNW0NB9xBYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmMyNDQzYS1iYWFkLTQ3NDItYTA4Yy1kZjcyMjJhMDUwOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4Mv/zpD+S9x0sAeKNjaFEIJ68Yz1JfXgjfar1SeBzPwHF\n43RAXcX4YWBst0YgEU8inVH6qMkctg5DBFxISiAso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkcguer20OF8o1LS/+/gfFzfR\nI84wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAjVLKdIrz0rAvhXNswD8SmOnVMFlVMR40oHYFZYBG3kCIQDDBZUVRcA2\nPvvJVRJhvnpVBY7Qc11kwobFUMKt7rAPeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcJrof3dAQH/HTsJLJD7lIP1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhmYjE2MzUtYzA1MS00ODAzLWIzODItNTcxYWY0ZjZhNDMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWY5ZWQwZWUtZTkxNi00ZjAwLWExNzgtMDZkNmM1ZDhh\nMTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJpcGZdgtVMHv6/owOxc7XGgJ\nywFbZ5bh4Ev9Y0q+9IpLVcjUhP6LsPeaA4fDeHKg/3lZlLhuMh8qQwt7IJYbRqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjsaig7VEBIhLS/tOE+K2CtoXGfQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAyjkqe+J4TPpenVQ+tkueeZvRIzP0V\nNnSd2rAH/FUt4AIhALBedD1MD4X124BhCe5Q8Psdcbc8BlnCFIiX+R7HfGIS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6670", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6670` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXNSjmGWK+GHXW4ERkNahQ8DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhZmY3ZmNmLWRlNTMtNDI5ZC1hNGQxLTA0MzY3NjNjZWFlZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI2NmY0NzgtZmQy\nZS00YWQxLTk2YmEtNzg3ZGJiNmNkNWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2RFBqIxl2xYAvVMLpDjz5LsSu1g4O9x8EVHrOe5VJ75yggLqQkh0GZaZcVxK\nEHYWBuwk/1YaThfssm9Ltb9pB6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYw0hf8Hjq82fGfG6Gc+IL6Utle0wHwYDVR0j\nBBgwFoAUy4bXNK03DyDFg0a5cFbr0OL8vO8wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCACU9eKXS7\nTkzVi48WAr5N0ZOqgoBSHROQXMJcWAcuEwIgaAYTWJHHpa8nK/DPz7U1Yid40RRk\nQ2nSjaP6nsHkAho=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAShDdeWtNqD/v46hPpi9lYxVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWZmN2ZjZi1kZTUzLTQyOWQtYTRkMS0wNDM2NzYzY2VhZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAFro2l2VhEKHMlN4w5mcrZ51oPqHdqkx681yQtN/hw7ou\nPi68qRDn4RdebnnH5VRygqUxrXUQ6CfegYDMJxUEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy4bXNK03DyDFg0a5cFbr0OL8\nvO8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0TiDU/JU38665jlBDSVONFXaqPrI9J81XNWUBhTnZzAiA9A888Fg/U\ngI06LdZrFyU/VXUFD0ytQlzJd/WsuggOdg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdmwANQ+XRj4oRD8vuI1sog0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI2NmY0NzgtZmQyZS00YWQxLTk2YmEtNzg3ZGJiNmNkNWFmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmNmNzVkNDktNDdhMC00OGY2LTg4MjAtYmQyMmQ2N2M3\nMGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOP64W0DAgyOdy6bB6cueQ/V0\nJleP58uvYV8/XpuHcKyTDlI8kBVqYAiBU6E3y/ENCHrkiO74lS1GX0E5Vb5RVKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYw0hf8Hjq82fGfG6Gc+IL6Utle0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBivchcy7JzqgxqQKA2PeoqljoIuSxe\nDvIIwhyfGS/5rgIgM3qOo5HPHC7ksAooVwDpR3/igqggqa1PMbSi6S4AfOk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6671", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6671` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAS2tJwxtHW3qaDOi/EF0tZ7QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkMDFhZTVjLTg0NGEtNGZkNy04ZTgyLTcyYzgxNTZiODdiZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE5YzkwMjAtNjI5\nMC00OTE4LTg5NjEtNzVjYjg0YTk3ODgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8TFZHYPVG1XzepsB9O1kWV8P7CkH+4Kj15SyBmh0/RnH+zYeX7o2zODecK5U\nGq5aeiCISMVEoRY7jv5/cidNoaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGh6ZzR3eF6E8gCjO9WxJmulCw7QwHwYDVR0j\nBBgwFoAU21PjnFPWBlDtvFlfQ237arNu4PUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHKJ9nG7HSZSn/ylKM0bKij426Wa2SofaPLy6rZgDmAFAiBXNpifdfscu5oB\nPNaWzCp5wEz9nJyv3rkkkJr3RxJFSw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdcpwMWVFwCPkFA9PmaqZyYNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDAxYWU1Yy04NDRhLTRmZDctOGU4Mi03MmM4MTU2Yjg3YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzTA1qGTs7KncKQhnv7cLOdIufDQDJDJ6VSLvfe9XEcizk\nvTVfxX5IMQ/qpaDp3yPZvI14bMMGBAjchAGiqoIso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU21PjnFPWBlDtvFlfQ237arNu\n4PUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIganr4loObvSIC/WtCHxsOhgUB7IgN/UERgJhy9kE9vWsCIQC5TfUGQMFk\nPd5uhlPKECr0pJ78DxffAG6ypIbo8QMyaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQCFe/5F6ZyLaHtonBIYUH4pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE5YzkwMjAtNjI5MC00OTE4LTg5NjEtNzVjYjg0YTk3ODgxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzk0ZjI3MzktZTA2NC00YTk3LThkYzctNDYxODdjZTE3\nMzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWqiSjy3DUA/pBAy6oa53AxKo\n/kiZNp4IPL63QKYhe8Fl9WbuwK8Rc/uLP8BBAAULxyjn/5+7O5IAOSYEakPz+KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGh6ZzR3eF6E8gCjO9WxJmulCw7QwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAgWM3UlAsSQiaZi3RJzuJCf8oYzL7\nSlEXYTZi27K4o6MCIGArkBuR9gctys94xp6kujlA++B/dcsfK1iq9JvYJuRe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6672", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6672` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISARO96iPnVvhqmfBLnyKki93XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmZGZhNmZhLWI0MDUtNDhhNC1iMGQ1LWE3NTg2YmYzMTE1NTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM5MTRlM2ItODFm\nYy00YTU0LTg3NTMtMWQ5MGFjYzQ4NDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAsMB4Mryoh1M/2XM/JUF6aYt/NpZKsby9ZUx+aEDMKs0FcsNRh0jBteK+Sdw\nKFieqQyJOR+Qszv5R+qK2L+9UqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG0Dtq1vTndzk18KLWXgS2w6UJw0wHwYDVR0j\nBBgwFoAUxQC3AyAzYQpEn2H9vih6W71HJfMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIB/1ZiKp7Tqg2Y/JxkacRh/S/OGQAo9RUTSCVT2e15/WAiBLulqsoxJEPaFE\nUdhag9zQV9q0YW2BRtKbFZMC31IWpQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQyB/izRJoWKLEX9KizsqfL3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmRmYTZmYS1iNDA1LTQ4YTQtYjBkNS1hNzU4NmJmMzExNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKteGkotK7gCNNVXnbbhVWPGD/kQBlsTzkDfHirQB/0EjJ\nvI12lbyFJMcr7HHXRboxWYnHfGbXNnN2EW6Orx+Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxQC3AyAzYQpEn2H9vih6W71H\nJfMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANkNrur23xZh7kXxC5ldzh2nZEK6FEYGUJ7jhnBAiJJBAiB4R6IFjuRy\no0SfIyfL+JQ7UNoxF9xTWozoE3W/lf+JNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQ1rSqHouJo69mUxn7Z/1EHYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM5MTRlM2ItODFmYy00YTU0LTg3NTMtMWQ5MGFjYzQ4NDA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjkwNGIwNDgtODc5YS00YzgxLThhMWQtMjI3OTRiZjcw\nMDRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB5UqQ6LCSqAJ8zWKCSqV0kI2\npwlfk4/32VaWhGbSOpMxqdI+eLcjykC4EHiPM5RIhWRPbx5vham+IcnJjJo/PaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUG0Dtq1vTndzk18KLWXgS2w6UJw0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAxTcqsf4VCBwQ+0hjm+SSun1I2QMf7\n0Uce0B8wmLj4YQIhAIP88f9vFERrPye+6doMDximUD/yC0K/OmkpanypCBPQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6673", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6673` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAd2V1JL+N8ErtEjn2BVZRQquMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjOWI2MGVlLTQ1Y2ItNGY5NS04Yzc5LWUzMjM5MTlmZDRlYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYwMTc0OTgtZTkw\nMi00MjM4LWJkZTAtZDc0MmUwMWIxM2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIVNF+/nMcKhi7CiZcfinTAOLb321HiPdTfGnb3VpgIrkLcvBJ7r08iQAma3o\niaxP/0nPETHFnuGPrMSmqYnZgqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwz1G5LM6qNkPfZLm4cNNo7RP5hAwHwYDVR0j\nBBgwFoAUe5kbDAHAqAChqI/XEEk771ZoglEwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDRH\nKK74BFMCAw2P2ERGfNil7gtROJQcHpIHajfVAyBiAiAJcxmjX/+dAM0MHA0rDsqq\niphnLbt4cyYWDJxFMb2Ttg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAefzZBt/OdyMVSCaYUZFJlueMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzliNjBlZS00NWNiLTRmOTUtOGM3OS1lMzIzOTE5ZmQ0ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1BNUIZebjqFNJKOz9stGvi4+9swpn5cqVwhVx4LhP6VaO\nZiqQAiRMovcSDZcOUGMXV2eP1JtllxhLElrzAMNho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe5kbDAHAqAChqI/XEEk771Zo\nglEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgal85muJsOVDnrkgZGVQK/kJNjlB6WGmOVOUsl/Qpu4QCIQCnAz5F/EBn\nRJTbME0YYDPvkgWdpYZNid1c8NF3CQMxFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICBzCCAa+gAwIBAgISAVuoxmOcHBCg0NBVN97V6NQxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYwMTc0OTgtZTkwMi00MjM4LWJkZTAtZDc0MmUwMWIxM2EyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGVlOGY0NDItY2I0Yy00ZGYwLWFmNTUtNzY1ZGJhMWFh\nZmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYifu0h6diDrxG76eV8uPcCq3\nHiB1xuXDCVvy7eWmIo5kIzazd3bucKracnQZqQkqF7P568oNeh5r6SitekUowqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwz1G5LM6qNkPfZLm4cNNo7RP5hAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNGADBDAh9RrPiXM3BmJ/yDiASXU38NQHdj6cou\ni4sSVAqqX4V4AiB3yO327vcH3YJBf21h27vFZOz1wXbEQ0EXdAwD0mgzAQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6674", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6674` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAdJ/eaz/1h6Gow5j3u5hiUZuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMGJkYmE2LTM4NTQtNDM5OC04OGRjLTkwZmNlNjU2YzBmZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM3MGZjMDUtYTA0\nOC00YmNkLWEwNmItOTQ5YzdhNWMwN2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzvplycbR5ZPKpgK1ZaZNMaQbo3EqYHZr2HJsPOEDQe+OYh5t0gSdJv2vHltE\ntm1X+alkpR7Gu8rbE4LkjZE+bqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzIO9VNg3FeY8k3ABQthKWmVJMv4wHwYDVR0j\nBBgwFoAU600Rw2DdduBI9hFSMU52QsfUK58wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCID+ZaMOOQ9NswHcC9bduguvhLLN/pmty0bIqj2q6skjTAiEAqFlg\n/iEKCbK72Ls3qfdstEkwmNSacxYgr8N40gQHR2w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYb2UvJHxQBDtOFm/5Mi5fXMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDBiZGJhNi0zODU0LTQzOTgtODhkYy05MGZjZTY1NmMwZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaC5N2NF6lhGP0M2LTUAinpJw9kVIssiwwHz7kWGDGhqRw\nerEye/0iArhkmP9lOmLo6+uKbzAsM+d1N3+Cc71No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU600Rw2DdduBI9hFSMU52QsfU\nK58wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMdGPtwPkqzlsp4byJaRZnh1HjmvvDCN/Wsh+CfwFEFcCIC8yhgh3mX2N\nbsfQU3tpGLnEB0Cv+i70uB0rypxm+EJe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAax8R1xBSmur1b8Z4nORDU7FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM3MGZjMDUtYTA0OC00YmNkLWEwNmItOTQ5YzdhNWMwN2E4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzZjY2YzNzgtZmU3OC00MzgyLWEzOWUtM2MxNGJkNjY4\nYzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2m6qP4ivt//vPF4w1wJZ6Yza\nVqdAQ1omXzfYgmPE1qe8WFly3Nz/YCCRjxXWhu0Z4TYrbGW+JJY4Td68VcCweKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzIO9VNg3FeY8k3ABQthKWmVJMv4wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiB/BgQtFde2gu7q/horph/zZMrz/sAQ\nc8Xys2RFpz4hmAIhANswb4U7V/STJEKtq/lHxFseesC4NplXOdQYbbUm4OGi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6675", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6675` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISARqZR989JWfEtX+ttZyQXaXLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxNmY5OTA3LTkxMzQtNDY1Ny1hOTk3LWEwYzczYTE0MmRiZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2YxODFjYWItZmM5\nNC00YWEyLWEyOWItOWQ1NWZmZmZmOWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqK326vKFMY8bbkBYHuz/V//gM9VCMTR2HoLcUeTirM8Rn1MKwIYFKqEUU8Eb\nV9gPj4MKS+FigEbxiGuFzjid0qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTD/9wv4BWmhEEHK6H9y0s2dlcNYwHwYDVR0j\nBBgwFoAUYtuyCT7OdlOW2iYT5ZYMRLdS2TgwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIDRI/q2+0gUTf2RlQIwY88P6ncEEiVsmlfWIl0aq3Jg5AiBd4lB5\nZbPVCCr4ouFiT+zpSOHKIF2oeEBtGGn+kvQNPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUXlah8gyup2qZcGUfgUgLdrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTZmOTkwNy05MTM0LTQ2NTctYTk5Ny1hMGM3M2ExNDJkYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV1TZQp/medKnmOhYZX0b7pNZTRUWHjJ6FLG0YGft9o58i\njY/Q4DLEDnPmwA4HjfaYrIskjuwZ8Lspg1lbCBnro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYtuyCT7OdlOW2iYT5ZYMRLdS\n2TgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc+1Y94EPVXcdT+hcAdett9nQKs+leISSb0M8OnGtM+0CIQCqNV8HuIs+\nLXPjJ2h5UIR5KE4pvFc2YaqLxiBaB+sptA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdIDvynUajOQqdjwODN8zr9MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2YxODFjYWItZmM5NC00YWEyLWEyOWItOWQ1NWZmZmZmOWFjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTM3NmI3OWItMWNlMS00OWQ1LWI4MTMtZTMxMzQ0ZmI5\nMGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETqgULOh99VWvc0d/FHDVGODy\nTY5tS1aXw4Cg48CjALlw3YAvbU4gFY0C5p7yZVhWKg4Vy+1SI4876NFvOq0/raNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTD/9wv4BWmhEEHK6H9y0s2dlcNYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA11q00SXMDaOdNv2DWy2nDr+Qmm+i\ne/EFyMyPi/YehOQCIEYi10axm0GKzj5ZeoYg4GYGRhPOJktCHalWQ2rayboj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6676", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6676` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAcBfHfAz+j7305ahkdFXO3LvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5MWIzZTk2LWVkYjUtNDIyYS04NzdjLTJhM2QzYzYxZGFjNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZhMmJmOGYtYTA0\nMS00ZDAyLWE0Y2UtZTFiMGEzOGQ5NmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwEhHnDSVBwWq9IFFqEy0oIK6G6ERk6kPb0dxKIPdJpX6yMHjdSeprMr+odPA\n5o/UunwyJtJzY65An7qJBo7EkKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTFEN5S7pZoUWrm+MZoK4CGCPAIHzAfBgNVHSME\nGDAWgBQtQAQpfs3CdQ7kAP1wEjfe3aotdTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFfZbyNwFhfEBY1/Nku+Uc64HCLJYF4Q\nEtFJAo5mrADoAiATP+sRCa9JsUENu/YhyT/46EG46qb4ry9tWRX1Xnpe2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbxlyWwuCw4OCqX1+zq8D+4oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTFiM2U5Ni1lZGI1LTQyMmEtODc3Yy0yYTNkM2M2MWRhYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQD14Hn84BlYjtMq4aP2mzOPDyd2tektCNXvCs/gAwjFXYF\nUcta+ZUe8ty3SSpLgjojzJGiEdv9qoELR5FTx72Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULUAEKX7NwnUO5AD9cBI33t2q\nLXUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMRoWvxsCpdwC6EA0FdztPc6ykbfZJ+Pi+tPgNH85qLZAiEA7IqTrqsC\nuyYPJea4Y0pBAmFmdGY/MEJF6y92scQlZfc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAe3MmnQFeAiIZPwSiTF2kfYNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZhMmJmOGYtYTA0MS00ZDAyLWE0Y2UtZTFiMGEzOGQ5NmNmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTBmNjkwMTAtNGUzMi00NzRmLWJhMmYtMmU5MWNhNjA4\nMzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgPm2ktBSFdWz2r+sTDhzsqEn\nMhFhRa4qftns+aGEy0HHg4XjW9XdT9AwdnWPcFl8/G1YcRboekGDWPVVfzypA6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxRDeUu6WaFFq5vjGaCuAhgjwCB8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAiTflzbyxtkofyPO1dTQScrhj5lUip\nJNxO/U3PkgokwgIgaGsigXLj6IYdyYTV3aMEbW+6avzz9jlywWwKoCL+lLY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6677", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6677` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARnIwH5QNb5TcdPGqOIjNG/GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MmFjN2MxLWVkMDAtNDYxMS1iNjA3LWYzYzk4NTUwMDZkNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IwNjEyMDMtMDcx\nOS00MWFmLWIxZDMtM2I0NDY4NWIyOTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+FEs0wVBpEaHw9Xg3ik0IyLJTFYa/9Y4Qeh1pzk5KZMSpxmVvHF997M5E3zP\nxZdWT4rSaYyaaienBuSJgGYaEKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfhPFLWF4635lZhBKrj3VmLV7PzMwHwYDVR0j\nBBgwFoAUNSrwpOocGYn/cGtwWca4CI5V8iEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBTv+csLOIJU\nwcr4RV537UTv2V00LKSYldnGu30QxnAkAiEA84m8A02Ig2e3Qa1gNLMkdwiTCl8g\nvi6X6X4TPXJ4++k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASoQ0oKahadTydUHo+H94NU9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODJhYzdjMS1lZDAwLTQ2MTEtYjYwNy1mM2M5ODU1MDA2ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm6YSHdUs0ftuSPNO0laZfu+PV+q+nTENkp1Lk8VoU+K1I\nnqL/C2eUpuWYCbsULzHqgpfhFUl14CZqR7G8sculo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNSrwpOocGYn/cGtwWca4CI5V\n8iEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNp17E3sS70A5C5xz4M055VH1y+izaUnlwG1sOMNw6J4CIQCFJwq1U4Op\nnpRsx+RLK7CEiRfCdOTYgDTF1UPqKj0z3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAUaRjll3T2MVcJeWx3E/G2OSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IwNjEyMDMtMDcxOS00MWFmLWIxZDMtM2I0NDY4NWIyOTQ2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWNjNTc0MGEtOTdiYS00MjI2LWFiZTAtZTQxYWZmOGQ1\nN2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESGXz6bbTHPSM3jWS5Epd0FVJ\naOrejV2aoEYzsFf8SzWkUpg2Bcu8sirKRC3uLnV5I8MgpmkHy96j7lPMNbpg/aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfhPFLWF4635lZhBKrj3VmLV7PzMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA+ly31CTlqExlmIzrrr+i4uNx3ojjl\niKWL58rT65hpGwIgam//+mx6EwzKNAfjv9qJ5UJ4i5yHCHdx8P+xK+uu378=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6678", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6678` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWzTYzBxWRAWiYrN26rXdvOcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYWY4M2JiLWI2NGMtNDI0OS1hOTVlLTJkMDExODZlZDIzMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcxNDg3MGYtMTk0\nZS00MWE4LTkwZDYtMjUwZGM4NTVlZGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESKAGluCodZ8cB9avN0ZoVj7acTvEyCCRUIL2Qt3ELfGL/Vq7hqLBH9mQLur2\nxYEXImqWFfFZBhsC1TjzYmD2iKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU056dW/4Yhjq3maAtVkCPSjFK9JgwHwYDVR0j\nBBgwFoAUgq9LXgFogtIHkUKCLiTVMYXjmyswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIDpxrqVKE604\noMtrgktvnwb+RkAaVHKH0Pd0pCxBPLw8AiBY5P5uDru9BUr6xk5PK4pKRfjluWZt\nIIe55lRfPIhjWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATIF83kWka9vDVCnfEJlKQAGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWFmODNiYi1iNjRjLTQyNDktYTk1ZS0yZDAxMTg2ZWQyMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQc6T5cF3ONXEO3Rob3ZnP7P6w1LNS2TtWmrIkAz/X6sttM\nqI9uL5clfwIg1GsuNUdIg9q4M8kthbiGGmw/s4z8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgq9LXgFogtIHkUKCLiTVMYXj\nmyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVEnVTscy01BLyIfbv4bpwqDo41ggtvTeE4W63iWjX4ICIBirhUlY5Z/d\nObfMIVkSGigadYoSH59GYA2FVwt7mGpu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISATar6ASUB/qPPquE+nUzg3V/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcxNDg3MGYtMTk0ZS00MWE4LTkwZDYtMjUwZGM4NTVlZGVhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTM5MGZjYjYtZjFhZC00NmE2LWJiYjYtNjFiYmI0MTE3\nODEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvR15MXSnVbCvVu4F7zbpqMBC\nhzPCUCgOxkFVPxCtFBeXZkdMlksc4ABb7Jk5kXHZKEJQRxy4rampW6JFRpkTJqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU056dW/4Yhjq3maAtVkCPSjFK9JgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAwG6XKZGIohHL3LHiYQ3jUP+538qe\nymHX3gU/PlZsvh8CIQDyQs9B58bfe5+TTLurIQw3XO/GtRF2Lf0ul9oxAjTf9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6679", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6679` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAZYHdxiK2jbCM4B5CZrlzde6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4MDE2NzdhLWEwY2UtNGUzNi05ZTBkLTBkN2Q3ZTVhODc4MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NjNGMyZjgtNTVi\nYS00YzQxLWFjNmMtZmEwMGM1ZDBiMDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECntc5RjgHKqt3TaKi30P7su+rdblOg7oe+gat/sYk2U/di0mzS2dM71joZCI\nZXSXYCaKv/z1FbOTnjRTOAwGbqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhzhPHIxMczUnNCs7yTVFsfKs4rEwHwYDVR0j\nBBgwFoAUEVLmoDBXeoBkbVsXjAnjCczoqkAwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA8+yHLObc\nXPIkUj/qqCy/I8hsrz0SQQuZqHzRkTOl58kCIA7yorn4456+yrWO+X2E2r9gS2GE\nakZUti6MUKZ+Shod\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUih0LhbhERyrsbS/YAD0acIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODAxNjc3YS1hMGNlLTRlMzYtOWUwZC0wZDdkN2U1YTg3ODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1t/3xuVf7RIBtxZqW896Y+iH+V99Gd7e6FKE5WbmZiPhl\nx4q0UCT1F921j/bORe0DkAt47OsWJ9N0y9ek7fuho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEVLmoDBXeoBkbVsXjAnjCczo\nqkAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgURN3YL6NoO1Qx9qXyMqC8TQ9XE0FItRKNP4dvXnMEMACIQC5/qjDpO2a\neO4Wp+1230LRX1LbJy1fvXqUtIAG/qLUjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdQeNcJhLVg2mu8EWiT4M66QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NjNGMyZjgtNTViYS00YzQxLWFjNmMtZmEwMGM1ZDBiMDhiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTJjMTJjNjQtNTIyMS00ZTkyLTliMWUtZDQ4ZDk0MmIz\nNWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzelSn+YupY4v5T/wXvPrI0fu\n4EsOw3yTU3Mhm6ArzZWYz4HYst2lvM7ea1Pl3JxH+rhkq59zm9Z0ZQ8fCvm936Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhzhPHIxMczUnNCs7yTVFsfKs4rEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA8C6h0QbX/NeS3z+jtA2uhhx5+7uo\nvyLF/StG5CG9T3oCIQDub8WFoUUunniIOtLeo/6kTGZChsaLZk2KgGqkFVdr4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6680", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6680` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISARC5o5uUpISbl29cYFgvkabkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmZDBiZDQ1LTE5OTMtNDI2ZS04YTVkLTc2MzU2N2JkZGZmNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA2MDg2NzYtODYz\nZC00NWViLWIzMjAtNjExMDhlMDBmMjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcFEAjHm5PSOkbGR7CbJVsc35NW6wSBM6ZXM0mtwU/x0LaIUkJTqqPSFKYDib\n/kZgVTl5BZNn+bz+F+fQHdtArqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvq9JLb3GZu5mchI6rcYdAMsdWmgwHwYDVR0j\nBBgwFoAUqel9tq6BTLBTQtn03I5HLLIavaIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA5kOsmDnIv+NPhpchpI94D7sTMpkBTPgX+97ihOhYEvkCIQDo81DBLDbn\nKpK2VBXgS3zAFGUlT6//xLrrNurkPvIzQg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYCcctJP9Ep+1PvuV7Hd2wiNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZmQwYmQ0NS0xOTkzLTQyNmUtOGE1ZC03NjM1NjdiZGRmZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqaDgg2AUPqyfkFxW6W08MxscUvs/WaQAdpteRKu65pgLT\nfenu2bUzctWhPD6CG5CzK9GIl8LH+K2WnUitDAimo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqel9tq6BTLBTQtn03I5HLLIa\nvaIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCbioV8fLqy0LQzxJLHz3Av45dVd1dfUHqaGF/0CzzlkCIDrz4nLcv9x7\n0/fdrRS0QR/IfdEZhZwQvPKzLIfdV53r\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAU1aKa7TuA+JJQFEZTV4UPiQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA2MDg2NzYtODYzZC00NWViLWIzMjAtNjExMDhlMDBmMjRiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmEwMmQyYWQtNjUzZi00ZDM5LWJiNjEtMDRlNGEyZTY4\nODQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWrXI11AZfxLLgebme3lyag14\n2T7MeD2vtCN7PZ/Gku5pGqZPFuwxpASTVNwLJx4IPtYhfpCO41E9+rt+/k36zaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvq9JLb3GZu5mchI6rcYdAMsdWmgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAoCQWGtWQmzZlJWj6T8cJ58AEz9Hx\nkqczZ3Av+zbYdUQCIQD5q/ogBWVT1GsEF/XvRR7PM8xj3CPyWc26hZSCkfu2RQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6681", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6681` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbOx9am9wCU36Kmx5FR8WBHcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2MWFmYTM1LTQ0OWEtNDk4Yi1hZTk3LTkyZTU2N2U4NjNlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIzMzdhODktMmNi\nMy00NDQyLWFlODktNDRjZmQ4ZjRjODNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdsbY7zHJLkcc5GbGG3J1/J5DUz3atmx1REOAIu1gPMvhtn90qAGGXxmk2+yw\nQ09vf/V/9ZPl/4sFSK4UxgMbuaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0yCBn7KOhIi8xPMKJY/Lz4ZCNXkwHwYDVR0j\nBBgwFoAUbTFJDeyDRry/CzULbf4HuvNVQVUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBKIUYyVkHSF/vz94KZiGa0Ir4+UFp2XZlvqeOCh0WIsgIhAK7gh3uXRbvA\n++wonTmzEpUfI9mZLYjVYkaviONZBF0l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfCo+5GnCqSThXJ/v0J8bDD/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjFhZmEzNS00NDlhLTQ5OGItYWU5Ny05MmU1NjdlODYzZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASy/EAyuc/T1BbRVzHRL9cO+CG9aB5qWSddX0qPCn6rc5b9\nlGMFbW+NX7mgeGo+lwxWmZiU3iAKVU0Efkd9MBrIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbTFJDeyDRry/CzULbf4HuvNV\nQVUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPobodpawzsHYhAkwXIv4pJ1tCayoI0BL8atfsXsL2GsAiEAyxZsvGKd\nOwFETOmJsE1wD4nmsNrnPKma5S6o23Po2bg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeClnc+zAL/P0zrzaw+1gxkAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIzMzdhODktMmNiMy00NDQyLWFlODktNDRjZmQ4ZjRjODNhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDA1YmM4ZmQtMDI0Yi00MGM2LTkxODEtMWFjMDQ2OTA3\nZjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE68Zs08sKGUh4t7xAZNMD0T8h\nmb3uJ8N/XHIk7DEpMrT6BR1ztBNbIoSdslDMPHbIRMHfvk1ZvdeKh/ZrQVTM3aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0yCBn7KOhIi8xPMKJY/Lz4ZCNXkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAt/uizo8EjipY7z75PcKew+BCUtPE\nTfc2jLSC6AawQUMCIQCSLbvu/WUlOcnmLxxUQzXM+uUudAILRSCAeMabunIDNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6682", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6682` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAcbKhABrvGXOW1T35l0riUd7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1MWVmMjAyLTc3OGEtNGQ1OS05ZjU0LTBhN2NkYjhjNTE1ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2VhZGI3ZWQtOGZk\nNi00MDcyLWJhY2YtNGM2OTIxMzAxMGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmSjNNzGWcutOYiAgCU00EbN2QBc93x7XcXv7tUKwNZoGvG1TyuBZLp8NaI8a\nsGHHpIwbEwzUkg11Z5SjpdXuraOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmX5LDggHQk3gI+HupsTGBZUkZwMwHwYDVR0j\nBBgwFoAU6Wnx/wID1+lhLxGJPxYNX1+zFIwwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\niEok+lpf9tfK2w4A9WoMoWtDLSK7QmjBt3WEsYi6XHkCIHMEFHXFsXovaTDliL+F\n2VLEyBeurLMv7SQ9/0S4NPWv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUK1dKRtq5jsuzYAgBD+gBbjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTFlZjIwMi03NzhhLTRkNTktOWY1NC0wYTdjZGI4YzUxNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDdD8nwhpULdYHLNcf/zNVlilT6qkTv8Fr+9B3QpxmLIPZ\nSwLXm03TlLcJPBY65W38PXDUro71V+q4/kepIiMlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Wnx/wID1+lhLxGJPxYNX1+z\nFIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANHiAmbgg0MrmDG2Zn2n4AQR4qlRTdtuilK6H9HbHO+GAiB/YBw0AAMa\nVPg2ezYs/xc/AG8fniQo7ydb1HtauqVpkA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASgpIsspIVNj8mD5gMeUGMh9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2VhZGI3ZWQtOGZkNi00MDcyLWJhY2YtNGM2OTIxMzAxMGFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmExNzY1ZmItYTE4ZC00ODVmLWEwOGUtZTE3YWY2MGJm\nMjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwPkP0fCUYs8x/kU36rfE5r4p\nu8UIB8Voff36K2PoGNpSEcxCGMJvVUlYg1X+ld9xz4Op9fjhwlyz162jD8utuqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmX5LDggHQk3gI+HupsTGBZUkZwMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA6tXWYxrBRAOikm+dd6lUxSGuYXzR\nhjxgU376GBLWDfUCIHIVKaoDGGpnWkbkqK94TPDE0/FEVsLTOjXnaNB/FFWr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6683", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6683` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAQ5/+AA+3Xg80KmgCPI3s9ppMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5OTE4NWI1LTY5MjUtNDVkOC04MjRiLTgxZGRiY2ZkYzgzMTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzEwOTQzMDEtNGJm\nYS00NjFlLWI3NDgtZTE2NDk1NGEwMGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKMrNHphgChbzb0Y/GH+xvGS8YxkrpXoXGFKqSXvk7Wb9RFebU++iuIJFbHK8\njmIyJk2uz5vBPMvFRfMV4HP8t6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI+deUwT3YJI95LSAqHs5gh5a/0gwHwYDVR0j\nBBgwFoAUK7pVV4LajNks6deIheSC2coGZxAwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAynFWCehu32Jdx6c2gzw+B7DEn6WhxMHejhZFkncee5sCIQDM\nMerCPRVq0HtxBAsPRcpvp9JGvPK8Q3uRrgDCV4wnHw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfdk/4CGJmrjkDxl1HlRPisaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTkxODViNS02OTI1LTQ1ZDgtODI0Yi04MWRkYmNmZGM4MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpI5ICGH9b/RvqB4/K4yYLlFRyLzckjBtVP1TqOtqOjjsv\nxzDlfmAZgY43enROP0f+GhMmhZgjiVBuqQR4M9Dxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK7pVV4LajNks6deIheSC2coG\nZxAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANpYcPmStHAXiK/Lv4gP8l2FDXsmUQvW4+2FBtPmL2qrAiAX4I4AutOx\nIuKSNobO5q+6miYNxtEp/4AmmWsgNv7OcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASIjD3x8JFzXZk0pryujmRlkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzEwOTQzMDEtNGJmYS00NjFlLWI3NDgtZTE2NDk1NGEwMGUzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzU0YzJkNWYtMjQzMC00NmJiLWJkYTEtMjcyZTQxZWNk\nYzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWpVo6opedIbtOlokRrn2ib2Z\nlZXVBA2F/ck/ny/C2AaaxLvTp6XBxuQ/Su0e6ds2zzDD9q2+X+2YThGLJb2VPqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUI+deUwT3YJI95LSAqHs5gh5a/0gwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAyoqFOJX4K2h4ywWdgvXdFMO+48gp\nXg1QdnyDpUkhrZACIB1boXTlbDT0JSp7Up3MV4E9QfcqhC/NPna1O57mifc+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6684", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6684` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAaPBW6h9E79EVej8hOHRl8BeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiOGY2MDMyLWRlN2ItNDI3YS05YzZiLTE4Y2NmY2RlZTJlYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgyNmU5MmEtMTkz\nNS00ZjM0LWE3MDAtNDEwZGI4N2JkYzIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Z+xyVyZJpiW+CJrsLcMuu0DKbLDQM3lHAXFljEhb7NqYmIA4u0uxBrXryuP\nzrPnh9KhaIqfgkGNwer+1MqBfqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUET888SfGXNodsKhBhTwhP0YWxoMwHwYDVR0j\nBBgwFoAU5yVnIaBkw5Guy/ViGz/lS8wKc0cwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBIGxlm0xkZr+m2Yrys7lJmB5di0PNcY8KhI+o7ekmQ4QIgb/2G\nguWXZHosY5ye+UKfDUP7QaXDR+IfGHjIoJM4mmk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcZyFvnNTQU1cwpZy4pSa3uKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjhmNjAzMi1kZTdiLTQyN2EtOWM2Yi0xOGNjZmNkZWUyZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASf1WDkJmwWuIkQ/O9EiKvM0OwgorhUqpjubY58tR7KgOH4\n0JGje2mlmwnkTRCI7WiXiUsuos2j8kQglg5cdvy+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5yVnIaBkw5Guy/ViGz/lS8wK\nc0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPGVsNC1+8ZLzUyJpWSxTeVn2P7DiDdo0FdhY9M9nCiCAiEA9uWh3xYh\nCgTJZpjG5fq4+1PT1ygZPK6s8bdbLXLCHrQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcqeGHHtKy3xFGfkprOcaAhdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgyNmU5MmEtMTkzNS00ZjM0LWE3MDAtNDEwZGI4N2JkYzIwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTIyNTJhZTEtM2IxOS00YzFkLTgwODQtODQ0NzAwOTA4\nOTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcIBZmYCfV52DKpoHrdDMxgSt\necEQF1UWmUtRYCXPxK8TOMXpAsVYkjyz0ghcyPjI3kwQd1tSyf+OznGCAU2dcKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUET888SfGXNodsKhBhTwhP0YWxoMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAnY3MU/HyGIW37/rEeCfyx01h7qTH\neEgBrH1zMxgTPecCICjDd9j+OerFivUgtiM97UXZ/e2FHnoYBMvQ1PS5UTWA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6685", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6685` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAUCspEXVccL/tcZHbAeJfLoYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ODQ1MGViLTc5YWQtNDkyMC1iMmQwLTAyMGU2ODNjZjA4MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRiY2NmNWMtOTlh\nNC00OTExLTllODgtMjE4YjVkY2Y4ZjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+RqFHEr7RL+lZYlmVWywPu3ywRwvLSLbWsU5Hnmg14xc2pRMtOwmpPwcCbsS\nk0kye+/Olo/a2wNV9AmY8+ahfKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/X87tJLCgIsw7g9mdj9mOE1Ww8wHwYDVR0j\nBBgwFoAUFKCb9Fd6Xl0mlFpApbTWUgysAjswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA6DS79wmuhJ60\n1WoPrQmU7/B4r+JgA0LQBArfUZbbm3wCIFOjisPL2kzDc5oQeEay8+YJRKnSNwmz\nlh7lWWZVn1dv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWvRpD7eedxfYlysJP8jLQvAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDg0NTBlYi03OWFkLTQ5MjAtYjJkMC0wMjBlNjgzY2YwODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAyjLvccKuSWa8wxugZbmwQ48El8vRiWZVBBG2mQTcNrsU\nzpka9R38JRFxxHEb11JxBvV91kTsbxIBlycpFXAyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFKCb9Fd6Xl0mlFpApbTWUgys\nAjswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR9uTisK8owJSaydxiWGIgXvSaftGaYRki65GjzWKdJwCIHVf8WUCY8NO\ndXH1G/tuSCKQB8CKUSpW7K7hjRWKlGh4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVgPTcUI9IwKsyzcqhRy7PK1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRiY2NmNWMtOTlhNC00OTExLTllODgtMjE4YjVkY2Y4ZjdjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTJlMmVkMGEtM2IwYi00N2I3LTk3NWItN2NiOGVmMjIx\nOTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8jOYC9DzXJX3EOe9SZb3u0D6\nOjdpmw8sjCH+qJYf0MU7ReXEQVx5LQTgI9mPc92CbB2l190LgFqAr+Aak+S44aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5/X87tJLCgIsw7g9mdj9mOE1Ww8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA8SZGEPaXhM8YdnHqzHg75yH6Vmva\nbTO+sMRoB8oBIV4CIC18enzIEX5QIiZXFypOfpj/kPH6YuhZRP1r80T73M5o\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6686", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6686` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAQ5ZQiu73k7sJFX8XCedpherMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlOTQ1NDdhLTQ1ZDktNDg0YS1hNWQ5LTlkZDllMjdjMjg2OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg1NWU3MWQtNzhi\nOS00MDZkLWE5Y2UtZDI2OTg1MjFmNWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAHMjQWxTX0NSENWn3ib9r6e4xlwSz7NiO7bFS126w6uR9KW5pMOyaZ6UXjrW\nq292H8GGqCC4H4KpCjigb79m/KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBfHnvxAEOu1gGHsMGRi1vfIRW0gwHwYDVR0j\nBBgwFoAUT5U7cQ0dXjbOj2BB9DQ5X18w3h4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC+nWhLLHdGs5riNqLGD+LmDaPQjyz9WcAiCMjWPNVNJwIhAO1z9ozDWqdH\nZiOAgfOqsfbYq28dev7uVi42rU+SdBi3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfvLYfsm8ouUgP/2e3hW5X80MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTk0NTQ3YS00NWQ5LTQ4NGEtYTVkOS05ZGQ5ZTI3YzI4NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMD9BM/trJeQnbPneXdO1STyOmhZHnHY+ZhvC7QQgTzwGf\nVg/O2HY8qPCDgVizw7zLfMzY87YOG1RSAXI1CG8Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT5U7cQ0dXjbOj2BB9DQ5X18w\n3h4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL1AUAciN7zex6QZ+TpugMAl+lpq/u+mRGE+uSfm4opUCICFwXeykI6fR\nvkHmuo+UicGqPwrETMnU79W+BmvKUUeC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYgXShlJIea5gYywckQLZlfuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg1NWU3MWQtNzhiOS00MDZkLWE5Y2UtZDI2OTg1MjFmNWMwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjVhYzhhOGUtMWVkZC00Yjk0LTg4M2YtMzBhMzEyMTk5\nMGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsFqtHiD4XJ9ZR7O48u4s7rmv\nAUzBQGpyi1MAY87p0RzXizBnvmpVi6K5QqgGt4Me1/oJjLnMuCQv/tbN3K3QzqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBfHnvxAEOu1gGHsMGRi1vfIRW0gwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBWIxwJcvgenRbyrT3pCyLAPrYdDqPu\nIIe+wbKbgtooJQIgS6RE89iazVtF/vItHfhhyYr004R8YP6nrOzk73wFCXM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6687", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6687` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAf8cS9v0uuKW5ToKnc9lAX6DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjZGM2NTY2LWQwNGEtNGUxYS1hMWIxLWRmOWM3Y2FkNTE0OTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZkMzY2NzUtNmI0\nNS00MWI4LTg4ZWYtNjI3ZTQyZDRiOGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFfxe8mimLIH+LeTyL1KVobBnhu+To8JO3C5PXgAfdh/Ui64FauGnng5gBw7A\nSnlBMWtFQqn5icYBM6ZKdOtOoaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE8oIfhSIVO0zAW8eL6TCAfHo2OwwHwYDVR0j\nBBgwFoAUlBkckqJD7bOjFt0+l0Mr/lW94JowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDAD4RDVUi4tEsOacpdgBVngeyVPiNxfIsUJTLAlUK9FAiEA/IfeFzKGhj8a\n25eUIqekUBlyY6Y717iT+KrpK5g/RQo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWZ7rJenBPTbeISOUGELRBOHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2RjNjU2Ni1kMDRhLTRlMWEtYTFiMS1kZjljN2NhZDUxNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIZ3i5/XCoPlxuyex3IbZxAuOxO61reZRlW3xCQ/3Jl/Sc\nGjmj7+998WC08w65SGImnwsBOcCwgJ2ULXM8H1Zoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlBkckqJD7bOjFt0+l0Mr/lW9\n4JowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfcvITHesAraza95V3OBUfAaE6TvaUQPxyDAQb3xAAu8CIQDCzbtfWGQw\nF+7nXTgtnj5BG8pPUKdmchsEqAlai/Ov6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYFcpYS06UTgrVmaqo9QhNbeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZkMzY2NzUtNmI0NS00MWI4LTg4ZWYtNjI3ZTQyZDRiOGJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2M5Njc4MDQtYjQyNC00NmJhLWE1Y2YtNmYzNTRlMzE5\nYTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXINWoDplIsTfjROcKeBh5Ofu\nFgrI978E9rqLGyAwN5IosXI7pHldaMPCLWdMuosw8w97TjtMmUyyBmEBjqvg2aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE8oIfhSIVO0zAW8eL6TCAfHo2OwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAuDSPvWYrdhDFm1aQZyBuURf+zX7c\nzWbsEikta9co0dMCIQCzzR6m6krPnksCRx2yMzL2bKLPQlodjraQGsnlPZ0sYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6688", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6688` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfMJ9tEvcECOU4ztm+hp090fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5ZmNjODZkLTg3NmQtNDVmZS05ZGZkLTc5Y2NkZjg1Njg1YzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE0NjU2YzAtNmJh\nNy00MDAxLThmM2YtYWI3YjgwNzkyMDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3snBEqo7lzsorN/oSTqw8FTm4novOYopCvxFeek3r4jC5uZFBbsLVj1m2xUp\nbPcsF0IlcC0MLBiNgeKTq1NtIaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbJZEBWqd6yXFkX2Y8g//kJXtLQIwHwYDVR0j\nBBgwFoAU1QVFhiDE1lgYxCxkVwLOE/Nx2oAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAmQ7TMGPm5ia/zCY2OAEFkXOlYCSaVbIQ7V++R91ml+oCIAlBJRwirx33\nTZXqEXeEjqHX0GbNH1ESbA5EzMT9tpR/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZJOgw6yEotTKfOMAfK3YXvBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWZjYzg2ZC04NzZkLTQ1ZmUtOWRmZC03OWNjZGY4NTY4NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThBN8q0ySp7tIOhbtp+F79oUHmVWwTJR5kihePE4N5QHBL\niI1oDP24ZnofanrONH0GCbaqCiZ0isQq1+5qKkhko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1QVFhiDE1lgYxCxkVwLOE/Nx\n2oAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVVpxdLakeegx8FpD5N2A65H0SgnZoUw/+oQbi2dZ0jICIQCfsJG0q5Hm\ndPdiVvKAnkn1Yg65p3QjkTx+UcCXT7Jl6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWzoLNVaOmDlF7Un0ovD+5AWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE0NjU2YzAtNmJhNy00MDAxLThmM2YtYWI3YjgwNzkyMDg3MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzQ3ZGFjZWEtMDJjYS00NTE2LThkOWYtYWU2Yjc0Mjhm\nNzZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmG829Ub/KJoXw94kpbioXdtn\nRRAXOP26qlndTwMPYkfkF6POUz5M3oM0YYjUfgwceBiY9FlQJXo4aUPpuaQqe6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbJZEBWqd6yXFkX2Y8g//kJXtLQIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAwJE8sUGpVWcmZBz7drFxnixNM0h2b\nL5ZVM+glsu1dggIgfImqpfJkwffb1GTW4618AEWK2zCE6CsewNtxSaSmNiE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6689", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6689` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAfPurpDU+vCKdX29M/gTiUtRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxMzcyY2NmLTgzMWMtNDBkOC05MWI1LWI1OTJmZmQ1YmViNDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M3ZTA4NmYtZWQ5\nNi00YzQzLTk2MDAtZjBjMGU4ZjQzMzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8LIs+OXP6ErOY7o1I4ibG101y/DRa7CzTi1iJBv+1NJ58si7MHdDbvhgtf6p\nyFkxc1FXwVk6Fvkom40iGq3lw6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjGSDa1hHmFG3nZeQMbh27KcU4pswHwYDVR0j\nBBgwFoAUfC79OPHHeU6nV8mOJx2B4zoEdNYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAsBvvie2Eng/wQIXBhRqwbRdCWeQQC5fQ65IN27AE\nIRUCIQDbQKYV4e5yKJ2sLM8gzyU97LbDZhfjSTrq983yOjuKaw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZowvYE9OgF6Xcq5zDW0kIv2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTM3MmNjZi04MzFjLTQwZDgtOTFiNS1iNTkyZmZkNWJlYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOIQx5lfCC2ZqdY+zRCk8RV6eqn97TVxsLXOPnX3s49J5d\namyVlQCY4Fyj7tdkfYb/rlZPaqPNgywj4U5VWQ90o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfC79OPHHeU6nV8mOJx2B4zoE\ndNYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGRF4R5Ff+cvBHWPcR5SESH2J0CNxnkUa5BwBhHY6V/ACIHbr6TZ65rWf\nr10W92S+lpI5z7VuVLKFUhjIo3g+SMwy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAel/nRd68eEFAtvLstjmU91JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M3ZTA4NmYtZWQ5Ni00YzQzLTk2MDAtZjBjMGU4ZjQzMzA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTY4NGI0MjItOTVlMi00NWU5LTk5NjUtMTI1YzZmYTg3\nZDMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbgsJkn5xExeyslpl2FI16gT2\n/ajStDJhmOLv5juF02F+/+8oUL9MGrToBwsJtDwPJI5ZZLaaZG0o/9fz43SilqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjGSDa1hHmFG3nZeQMbh27KcU4pswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAvDEjpgGoI+1UisIZy0ePmhd2fXic\nOiBL1Zpy5UWyzsoCIDIXA+FEEQozMzrLA9fLRYhzYkpEGJWYKCzP7TBYn5jD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6690", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6690` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISATKtbFb0yIYKYi5zabJ4bdC3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4YTQ4ZDc2LTIyODEtNDgyMi1hMDJjLTQwZWY1YTY5YzBkMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWExODU3NTItYzMw\nYS00YjJjLWIxMGUtOGEyMTY1MzA2MDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfV4A1ddluAKSVCq5HIECFdJKFu2up4SRzPMh2duLAZ0syxxuqvCsy/6hpClj\nvp27q/92xtSlKFdofztmWz7A9aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUCVS7wATgsnLC9ovELfr2sxW0EEwHwYDVR0j\nBBgwFoAU+vW/09USi/mxJNxQSrQm8Zjkc/cwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAs2YBiTNqfjbENCdki9OwZ/GhTtj+9guHu49OBl5p\n+OECIQD32A6lTXIOavXEqwD9ORVidOJjb6Jtk76YlJsbunufig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVPboefcWpfRfvAggblvq4AqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGE0OGQ3Ni0yMjgxLTQ4MjItYTAyYy00MGVmNWE2OWMwZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjJCQVMCqWE61sFMda8Pmxax6uNTX0P/y5TpAEcrYqivJa\njUl7XnPllcIOamx6cE5e5ISqvWvD8ERfinYnqhbho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+vW/09USi/mxJNxQSrQm8Zjk\nc/cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN8AxwJkzGLmRYfux0Y5+5f79gSGeorzss1x6gAE3XKWAiEA95wS+ypW\nrIhNByVec2bCxUbOB42Hprd99S7odS9LIKI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaG5+yQTCTHpy0kqbboTSZdrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWExODU3NTItYzMwYS00YjJjLWIxMGUtOGEyMTY1MzA2MDk4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmE1NTQ4NzAtZDE5ZC00NWIxLWIyMDgtZDg1ZjNhOTEx\nYjVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaUnpWBeTc7X6yNMdIVi5BAte\noWUBXdLMc+8ZnyliAdLpGugbNjFJFDQ5EQ2JRm57j8f1w+q+BNYrIExwZVtjbqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUCVS7wATgsnLC9ovELfr2sxW0EEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAT4GEMO9AHb+SxexfZXo2sGrYCAglv\n85vusSBddknUSgIhAKd9lgQNOR/KjulRBG/1NQP58qjrpNe02nsX2eOn8eYJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6691", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6691` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARz1n+E9oPscZHpIWF/DOUxSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxNzYyNjRkLTIyZjgtNDdiMC04NThlLTc4ZTA0OGUyMWMxODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVkZWQ3YjEtYzRm\nZC00ZDlkLTlkNmEtZmFjYjdiMGUyYjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9AY4+MH4u/815qrVlsGGFL+EoKCw8UuABNqd++WlYXbjP0ZuIW49guhubuUM\nlyHiyG6CFl3Y+sHUY4OdLt0+i6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvuaxeMuqrzUGUnMfjHM686ENFDAwHwYDVR0j\nBBgwFoAUbaEPC0bY6ikpzy5dqNceujmkMa4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAj49BzKic3Kyi2rY0hYQgZX/gwE/EpGBVAsgFG/qL8+UCIEBM\n7L92tlOhpl6DjP8aKsUqG9+atHKfqzbKLsgXvkEG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaqXphaC6KLJEOA5V8MQXwg+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTc2MjY0ZC0yMmY4LTQ3YjAtODU4ZS03OGUwNDhlMjFjMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrG3zlflp0lvuL+iROEqr0SDWTlqm6HwUhDdQkJsoCZkQk\n6E4gBsdUe6CXVT/U8kYWBNNTL7CFVtM521UTNTc7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbaEPC0bY6ikpzy5dqNceujmk\nMa4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMTuSsJvNyvmXmoD98rMd5alZyX5nDyV4/xI4tY90Uy0AiEA8sTF8Gn6\nXr66FCJgbcn8U6Ox2y7kV2lSGOmizkfnnHY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcwLZlzLBMpU7gPZvzP/1yNFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVkZWQ3YjEtYzRmZC00ZDlkLTlkNmEtZmFjYjdiMGUyYjIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODgzMjI0MDctYjMwMy00M2RlLTgyNzAtNDVkYzllYWEy\nNTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEifiPBTGSAMVa0mK2NMmZwazR\n0+FMbLP49m793o9Gd6ITAauIW8raHFm6RdxF+BqElyg+lmSFION3l7mCGmzBGKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvuaxeMuqrzUGUnMfjHM686ENFDAwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA7XvOhM6NjHPONz4sX7uLUA75gQlZ\ncbenPlXxyH2fbNQCIQDkKR/Jayk4J8lWFlrQuuSiS2t0AkmNHs0iv73l3P47xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6692", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6692` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISARmIXAa07shJtLoZtytwgaAVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5NjY5MjQ5LTAzOGMtNGZlMC1hY2UxLWNiM2RkOGJlOWI5ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjVjMWJkOGItZDg5\nNy00OTVlLTgwMTMtNGVmY2JkYmZhZjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6X23w6qO5RXE/k7fgnXCrq+awttueMgAC3fpX4Qqwzcb8Y8MeKEFAJnmgrY7\nQnvj/bVebJe6R/Qw3p2XUOI2W6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnAq5cCLHBJAORup7S+y7JXi75iMwHwYDVR0j\nBBgwFoAUQ5xUTNCi0V8hg43TxBv4wJd6vWAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiA6h+Uz52nj2eBrYV2HNdF6tFlOMHi2eXTR\nJFJAYYa4/wIgXzzhp7kkFnlLFLa07FYbcnNIneSN5CFlMuPfreiSdso=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQu9I0pdJeStcDWSKphme3sAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTY2OTI0OS0wMzhjLTRmZTAtYWNlMS1jYjNkZDhiZTliOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiWojlxHpNXzn6yJqL8wQLGRzxnXbSEyFA07DxbV6CDMNL\nieAWzmJRO7kB9cA7sn7XVlPwYb25TrGqKwMbVvC/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ5xUTNCi0V8hg43TxBv4wJd6\nvWAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJrSny6y5bG4923OT3voZAmuxocRPihFpTLjFOZuwtrzAiEAmMVDMw8a\ndfUGVlQg0Qw1HJnkfenc0caJxgruLFHlZ4A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZ8cn6dNihJ29W5cWC1nuUSdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjVjMWJkOGItZDg5Ny00OTVlLTgwMTMtNGVmY2JkYmZhZjYwMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTU3MzUxZjgtMmQxNC00MTY0LWJmZGQtMTk0Yzc2ZDlh\nN2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsCCksBwMtSDFehUNvrvJAR6G\nSUu5nNCoS9/XCKHGrTTHjyOdPeD5N3NcIUhG+Gd2nAxcJd1IHXafd2enUUj8gqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnAq5cCLHBJAORup7S+y7JXi75iMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBz4sqVnH7qsDvCNvads+Zm4wMeNgI1\n56pRNgS7HeLskgIhAKCYyyBcd2wrCPn9bHlVI6gxcl98S2ljSPcfA7VggLp0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6693", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6693` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASC/48VFGLfApwhFAKipCy9UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYjNkZGE3LWJhMDQtNDU3YS04ZGQ1LWY3ODNiZmYzY2MzNTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIzNTY1ODQtMjE1\nYi00NzQ1LWEzNTktMzQ1OGQxYzM1NGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfF5m87DfDuCMadr0UzyfWLWKBtSz2PcjLbrfVWUtf8s+oRvTNCknoY78FuoW\n/kBXCRQXIEUhb7i6OeLRxRCmdaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn80qO5a8CSUYJszcsVnMnV6dH6IwHwYDVR0j\nBBgwFoAUHxGPxtdIqXLNMxY0YgZHiz+blxwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA+e454OU3h3xg46npiW78EooINj7qKBss\nw+EILE01BfICIEMW9CXNm1m337qaL5iIUl7vJ3I+Jni3N60BiYz52HqK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQaqKNNTv5s/e3KQm0n2UP5HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWIzZGRhNy1iYTA0LTQ1N2EtOGRkNS1mNzgzYmZmM2NjMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3JrQ6bY1ve61GI8UG3j1uQzss5sAkTr7fG3C6e8607ueE\nOSH6a3wvLcneyPKb0dPLPefWJI09+VEP0/4McbX+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHxGPxtdIqXLNMxY0YgZHiz+b\nlxwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANqBJ9ThZDesJygFPuuoTFJeiIOwU9YChn9tJeG9mt48AiA22adv0FA9\nwOOgIH+/0EiI2D5u2+mMDciKWRdbk7pd/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWAkEPgVQC59r5hL7vTfaHguMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIzNTY1ODQtMjE1Yi00NzQ1LWEzNTktMzQ1OGQxYzM1NGYzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzlhNTg3OTMtOTU3NS00YTNiLWE0MDgtYjAxN2MyMDll\nY2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOIjtk2MF8zJDkbdR++rsfyAL\nzzZ1iu5NT7KM0BqcWYJyVBa3yIgC8o7xHL7uuSRDi6AQzp/aDtjhesZKFT6VAKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn80qO5a8CSUYJszcsVnMnV6dH6IwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiABYXdwiVYs3qsOEOUJ2L+eqIDyhmTj\nXPwP6PMA+YExrAIgcM83h5gsSK1FtqM3zwGZ2EuicTY6zn36eVT83z4XObo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6694", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6694` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISARAqbdYD9zwWj3V2Tr4q0uwpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmYjAzNTE5LTU2MWQtNGIxOC1hMjliLWE2NWNiNjQyMTQ2MTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODliMzA0ZjYtZmMw\nNS00MTAyLWE5NDAtN2U2MmFiYzQzYmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY0mnFiXg66YCiboiX+gXNQeDAtPjJCZ3WcJZ5/P17bF+efb2LHhjajvZX7pF\nUS0312PfZeS6BKnzQvj1l3sOU6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9+1T38CeVA/4U9XDMAlb3RFw2dQwHwYDVR0j\nBBgwFoAUffYD5IUW/YZ/BSFhAdOTV2VYRKgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAi4MNLt5kkB9d\nMRQmt4TuxleQtV+qWNLnUgFxRkaPlCQCIQD4aCU6qPoE5nE/2mbvDTJQzM6lHqMJ\nUKyFNyRZLcXodg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbJMblbMzq19qS0YD4asXCohMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmIwMzUxOS01NjFkLTRiMTgtYTI5Yi1hNjVjYjY0MjE0NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASi5/QAQzCCq/6YMUbOv0liGWqlDFJerI5ahxSkf09h1xUf\niI9bM+y7zeu2gl8daQQmw3TWUo6YPmTpkOjzTYJ1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUffYD5IUW/YZ/BSFhAdOTV2VY\nRKgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOvZ6NmZ5HmE8OeH9eUKMfLG3HxRIvyDEbjNEYWKZM3oCIA4wbeNPXx+f\nJtk9FAwwAI02HvKxOizWfpjUApU8e87B\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAaZvN2tZ13fdArAmRYUaUS+nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODliMzA0ZjYtZmMwNS00MTAyLWE5NDAtN2U2MmFiYzQzYmJjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGExYjViYjEtMzYwMy00ZGI3LThlMGMtNDVmYzQ4ZTI2\nOWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkRbLfj3OWZv0upCXZhJepAUm\nI2Bd1MOdai5If/XB62QuRBdApFfimYMu3OCLCG8DsrfhOxA/HhYBOARB1DYufKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9+1T38CeVA/4U9XDMAlb3RFw2dQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAdyUKL3pplDaHOk3p9ro+EFPLoVC6R\nf4iVDHNT9Hlp1AIge1yHZr8uGlxbqjo89M4oXsr3pNMd6d9XfkGr8IKL6Js=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6695", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6695` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAf96t3UlD+f+nGNzyUc5l58XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExNjU5YzYwLTZiZGYtNGJhOC05NzAxLTY1MTI5YzMxODM1NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZiZjhmNTQtMjYw\nZi00YWE1LWI2NmMtNjVjYTEzMzA4NTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER3PBYCZgj+w2fb8I6eKry3UhzDUIyx7P/hgb8gWXIufuspJ0q1/m2mP0acgQ\nXdexIIgfgMUQ/ZnjFs+kIKd0xaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNDWilWto3Mdkug73DzYgePvF/mQwHwYDVR0j\nBBgwFoAUqHzKOpq9MSSiTwiA7dz3+iG3JV8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGv8wgoGNHmX0vIZwHrNQI26m7QnMKEODnA6j28v12IoAiAE5zXRU2Aa4pqk\ngQCVuTOQPTydSkcBevt6JmaQpTLWvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY882wUIHUs36QKQiEgKq0+yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTY1OWM2MC02YmRmLTRiYTgtOTcwMS02NTEyOWMzMTgzNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIGIGVGeAx+s8HC9FkHJTrSQlNgL1ugk0vHJMKugZASvJs\n++vOobDlydQMpMvzR/B50Q8bw97Mmy1S86fMBJtCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqHzKOpq9MSSiTwiA7dz3+iG3\nJV8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUsqJtHkgk0/2gNI3cGnrwHT7aig7ZzWl/LQG3qzgOOECIDceZsD1vhvc\noxTzFajVQJM0o1c7n3IW4MLFRc0KCMzs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQZczVPzAfmveZFhfSbDHd6sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZiZjhmNTQtMjYwZi00YWE1LWI2NmMtNjVjYTEzMzA4NTlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQxMmY5NTQtYjIwZS00ZmMyLWEwZDQtYjIzODhiYzU4\nMjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE58avygDHq0Zsj4SrVMuoDo6u\nI9M+zgVoE9+A0MBv7ggmU4CmdcSCDtJnY55yl3lVWOJGOks8/myIQzW6y879laNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNDWilWto3Mdkug73DzYgePvF/mQwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAcWM7SBezt91ndAs/ee7huC8lJ6TPN\n2Yu4U0C9iGjmyQIhAJOpBti0r414wM1OhcZIKFirH7hrrsJK44KaItgZtd61\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6696", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6696` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASm7asL4uKnNu1LrhaH+7uq9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MjAzYmI1LWFhYmMtNDM2Yy05YWUyLTVkZmRlYTVjZDkyODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhlNmUxMzEtM2Ez\nMC00YTRlLWE4ODgtYzU0ODU0MmQ3NDI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECX8IFiNZndusJngTSO4XRcHgDsX0I4Xtc1bQVSJTXFtUq0aUgySOgIYBTNbp\nkj+naoFMJ8HJ19LckaSAxsiukKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvYHqVWoxfYn/8q4Heao7nLVXW2cwHwYDVR0j\nBBgwFoAUnMJ/6dGaafAFP0eLG88a2K5Gk8wwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFfaRjnSc0yD2i5xHQY/Ypl9zl1asCLrfmPEgIaagtWRAiEAyoqDy0C9u1Ba\nwBkrbfbkGbKyXWr8+iVeUik+4EkC+nU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASMPyOvK0wzZsMEJWhCRQuncMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODIwM2JiNS1hYWJjLTQzNmMtOWFlMi01ZGZkZWE1Y2Q5MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIhrxg6kU4QoHA1ogaUjDLGLFZ069BMNFh/lylgXwpvhCi\n3VpMqlfNN/bdWjlI3e/8Sn3G0pxKccw6j3usHhkTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnMJ/6dGaafAFP0eLG88a2K5G\nk8wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALxVyhkciq0cCcOWYDfq7dTxTowzN/jKqL1rZ7ash0whAiBof7oM9AFp\nTJhbGXZZ7HnvfKwpJQNn6rn82SmEEZtcBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAT2v793EVg4GhsKSsikoxizmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhlNmUxMzEtM2EzMC00YTRlLWE4ODgtYzU0ODU0MmQ3NDI5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTE5YjUwMTYtZGM1My00MGEzLTljN2QtNTlkMzFhYTFl\nY2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElvFWXEASBOOYCdn/bOQNl3/N\nqPfy99xobKZ8g3PoHdEJbanmlAIv6Q2mT7ti0v4Nyyl14O1PDbueZrdlexZnHKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvYHqVWoxfYn/8q4Heao7nLVXW2cwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiASoyF/NMaOi7y+EwQa7O+4zxo8nXbZ\nQ7/1WQWLxNSBMwIge5H3kgQxbBxtOThypQO7eJ7x/rof+as4213lWnR+16w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6697", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6697` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAaQ3AE6l21jFr96Bd8K55Kt2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNzM3ZWVkLTljMWEtNDVmNS1hM2I2LTM4MjE5MjIzNzVkZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGIzNmUyM2UtYjYy\nNC00N2NkLTkzZDQtMTMxNGQzZGU4M2ZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoHPyUxzWFUGPN/HebnK9HpTaTe37OdmJm8t5iA2/giUPK56HIfXd5Sk93C2M\n00zO8Oa8evUyPLWbQ9pRl6UOTKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU/5Gw07UtkNNyoQIfvElko5iGaswHwYDVR0j\nBBgwFoAUeNFcFocLi0qBeRmeccoZjs8krE8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBeNmccbTxreqCNrGvyqa8aekz1p4Vp29UIrWQ7uBIyJQIgZcEUKCQ0VoMw\nL79kKiBWwpPSw1PWA8ITocCPKN7uEHY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARKa8OJzANsapBifzQ3ZdU1uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDczN2VlZC05YzFhLTQ1ZjUtYTNiNi0zODIxOTIyMzc1ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWn1Ry5rAls5Cyl1g0PWCdUgQVK6sM6p8xvtiJ1VWeViV2\n0Y2hr3ph5o++kqhIGyFlU8OOkxew/WuIMhT6lO+no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeNFcFocLi0qBeRmeccoZjs8k\nrE8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALa8hCP4q1/9uA1JqDg91uOpBkKUl2yPgsW0SIRyIA5kAiAUhRBdQDch\npiZAI0m21lzBvpgmK1fSNcWkPByaoUWAew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAUiOCS2S6djXCIRCDDyG1y/BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGIzNmUyM2UtYjYyNC00N2NkLTkzZDQtMTMxNGQzZGU4M2ZjMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNkZTFjMzUtYTZkNS00ZDVhLTg4OTItMmJkMzk0ODc0\nMjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErxOg9WLgLMQkpbZbaH5t4zae\nLexGI7053zLyTDlGDHHg0CjRDXyNY1K3koKlST9iYsa7DfD0tJ8vcDt0XpB9Q6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU/5Gw07UtkNNyoQIfvElko5iGaswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAwf8dyIhzOOSxdp+EAd39ZjClql3gt\ntTVljIVmE0OMFAIgCRFHyNAeD7QuZt42r/Bj1F6ZPzeFiQ6GBAiMt2goBag=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6698", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6698` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAdzTmNzkr6VOU9YAAZvJc1IlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZTQwMDFjLTdjNTctNGI0MC1hMDZiLWQ4MDdkNWI1Zjc4MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI2MzZlNTYtZTUx\nNy00M2U0LWJmZjktMzBjNDZjNjY0MTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMasayArhmDLCJ3zU4ryRSiTcHSPGdUEQ6sEmsbYyE4YK633T2fDtUaQnIIWm\nlEDNBrJ9o+vuyV264/XHBQqzf6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUabYVoLdBPTAN5+9++6VFw4OVN9UwHwYDVR0j\nBBgwFoAUsJtQ+dqvZNcnJy7UwQJ6y1HS39cwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAnWfw2ak3dlbnWw4TELM6aXDwL1WYjDCTE+dA33PmV\n4AIgURsYLfMNo3AJV02ant+1GaVctdXmzdiZaWKDoIpL7Zg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATdPIB9bTMtQ0v/M/cmc0p6gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGU0MDAxYy03YzU3LTRiNDAtYTA2Yi1kODA3ZDViNWY3ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGjnqYKZdVo4LPk1TCDAFhMQpqzd2OFXxiISZJ4TAiWCKb\nrtdOycAzaJtAwr6SmAOzMX9YG/EHKqnKdGWNyT1Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsJtQ+dqvZNcnJy7UwQJ6y1HS\n39cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOI/spDyugVO8i3ZuFLCfqlCqaQeodyJIsRt9er0ZL3cCIHJiAP5FRps9\ncN+Toj+6KZ3LNC78oBoX6rfjI1DzbOMx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAaOl8KpLbm6pihgbdz3UTwuhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI2MzZlNTYtZTUxNy00M2U0LWJmZjktMzBjNDZjNjY0MTUyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGRjNjlmNDEtZTk5OC00NWM2LWIyOTUtMDc4Yzc5Y2Ez\nYWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQM+6KjwjkqG9IVslKZ/Z6bvY\nRIkuCMljJeubRtFIsGD5Dw88+JRZDEj63b/+kJ0sk8YkvV/iep3hQro0+VJR3qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUabYVoLdBPTAN5+9++6VFw4OVN9UwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA7AuUKbgRuf8AW7FvKUyZJjS59MDL\nB4AX7hLsKpxfC34CIQDuk9CghoIyfMeLBbirYPmxzRW8zeTax+MBMUJMx9KQuQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6699", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6699` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAQdOrW/Mdo8XeadUNZ8c4vN+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwY2Q0ZTRiLTA5YjAtNDZmOS1hZmIyLTIzYWU4MmI3YWQ3MDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjAxYWM2OWQtZWJj\nZi00NTBjLTk4YjMtNzk5NDZlYzQ5Mzg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEehf83OcFZWFxJgAFNkFG2gS7tiFIqLWRDNCxD3DgaQQ0hArjuOyBo/T+h27o\n7h+KeCy0BUED/geflZOXthR6u6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT+YroZq3nWiLMZHuhEeRV+BAdHUwHwYDVR0j\nBBgwFoAUZAaNUpTQNzovctX9y9EnNIByRh8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAwyLEzZurtfZ/0je2UauinZkyCeXWO1N9RB1LMzU5\nJVECIQCyuvHGnU3giwcqS+FqgFzlbpFPQQUsojH7YOrQ8M6VVg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARa3rYK517n9NnhMtS+pRVcAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMGNkNGU0Yi0wOWIwLTQ2ZjktYWZiMi0yM2FlODJiN2FkNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARt6q6YlBfDJeBCoeB8xwJyLUbSA/RSxT+XArHx9Ic5WYep\nda36LLXbgxUsOiIkN9Kxqta8JRQAt+ArHIJAx4Tqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZAaNUpTQNzovctX9y9EnNIBy\nRh8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgROyPtpaPYTwt/38jvMMQpv4P40G9HszQHlulbGFVMXsCIQCyXlZoTEpP\n0sriSOri419s7TzJP6MPaTlm263OYbwu6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAUj2UMbTTTtRthUb7dr+pFB3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjAxYWM2OWQtZWJjZi00NTBjLTk4YjMtNzk5NDZlYzQ5Mzg0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDUzZTM4MzAtYzgwMS00ZTRlLWE3ZjYtYzE0N2UwY2Mz\nN2IyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6raw+qkM00y0FeKmWTZ4InO5\n0PDo286kUahQHotdYrNZhpItkt+O+VJQmRb/bzpZaAM7AdTJRpZvyzV7QRcXBKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT+YroZq3nWiLMZHuhEeRV+BAdHUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAwDJa+bZkG5JzPajTfH0a1ZfjB+Dyp\n6FKa5CtNv/4qVQIgKk4EpCl4lwtPAliDpk8+DLRoWnft5fNQFApumf2tuH8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6700", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6700` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAUvkms7cExmYYsND6SWKgExnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2N2NjYTc5LTVhODYtNDA1Ni04ZjAwLWNkODIzNzk3NTlkMjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU1ODRmNDMtMjk4\nZS00MDk0LTg5NTEtZDVmMDNlYzU4ZDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjOEEWORrYqX6VBwVmv34b/BRpDQHiW4x4rY89Y4D1gQ4Qtss5POX/kOG6e0H\n5BqV9++a5M3DUfi9EalmHjCScqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHglIf/BQunYIl8C0bklOtHVKcawwHwYDVR0j\nBBgwFoAUEdscYuIgdojI28tC2/t8TL6uc1EwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAZNRMpF66KkS2PXrHhX2fdxF4tScZOBjAzGfPplTwepAIgKKqS\nYdgDrPsGp2BbsUJb9pNbcFKterGVm57WMbTiFOA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQUB1b6cXk0ejm2hfXUiZZv0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjdjY2E3OS01YTg2LTQwNTYtOGYwMC1jZDgyMzc5NzU5ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATy5SmTJQ1OofprxcrmuBYCqvcBD3ucZQgrEYtD9l3lXDcY\n5bVg6zzM5DRjjEgm+DaTjUuJKNwdis2NQoFp+yy5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEdscYuIgdojI28tC2/t8TL6u\nc1EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLQ66AGWYRWWSe1h4UcTWzRFTOFWiT5NFKz7y9K718RUCIG+HL1Zk1GPg\nWBYg+J/bF7Euh1Lq/wU9NyRpiZjh3/Qu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAb2nTwFimm6LF8l9LaAvaHjTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU1ODRmNDMtMjk4ZS00MDk0LTg5NTEtZDVmMDNlYzU4ZDZmMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzc5ODAyNjItM2ZhYi00Y2I4LWJlMDAtYjgzMmNjYjYz\nZDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7JiXA/8mvjC7/UhH9jFLxhit\nP8buPMPCp22LW7swCFTF+Y5SD6ml8/p9CyojuOhVPB+hgEL6BzEAH61rH8bcyaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHglIf/BQunYIl8C0bklOtHVKcawwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA6UxO0Ipqd1lcWcTlimJrKC4AyPdL\no0/k3KT5spXzJ18CICFoV4wZGGjcKMVD7B+xAOzkRqXTbGOAZEAS71UiNIGq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6701", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6701` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQirD3uJjHC3Dl57BqoiGJrDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyZDEyM2Q0LTg4ZjAtNDIzYi1iODIwLWE0NDY0ODVkMWY4NzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdmMDhhNTctNDY5\nNi00OWFjLWFhNTAtOWUxZDQyNmFkMTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO5UiLHmjK7sCgoVACeVCnPHbbwkvmozSNP2SLxE0rcjFGUAz/EsnzOpTeb0I\ni+2vEcK41KojNnx7czLTChbU56OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi2WuYiLz+bLb+fVB6tkx2E0D3U8wHwYDVR0j\nBBgwFoAUSPZtq/BiORwmkc3ZJ2BV8QhZ8EYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA9RztLGwRTzqPviyoZ+W8aw57BzfLb8yx\n8QKcYO4K1m4CIAVSq7VmuddCnz+SLltXk3C9YbEsbYh2JdlqMRk7v6ow\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfe7mg9hOoS/2xyIxFKzO5vQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmQxMjNkNC04OGYwLTQyM2ItYjgyMC1hNDQ2NDg1ZDFmODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKL91NBewgIGbM6/ef/k8zmV4PwIVZTDHmX6mjPzRjtlYo\nbAwLbEH1HZxuj0cjtnTHwpEwawA4m0yC/ZGoAWIVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSPZtq/BiORwmkc3ZJ2BV8QhZ\n8EYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW79voyG8F1JfLQZP9gbocOYJhJ0jOO1Rmoq8tCWbPYoCICx2YRwxsDgc\nPTbduutIdgxoFgAbEJq/uUXdhsBttOub\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARcwrx+fjJgFY5D3yQr7WJ/9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdmMDhhNTctNDY5Ni00OWFjLWFhNTAtOWUxZDQyNmFkMTA5MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2UzNzg4MTEtMThlMi00NTE0LTgyNDEtNmUzMmExY2Jk\nYmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2h2OcdFi11DT9J0en2jzQFAh\nu4U32MyIofIOdqB1nRwo/uh7jH8lFTp5dK1vWUMHZB0RJg5DfPOzE5lrW5RmTaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUi2WuYiLz+bLb+fVB6tkx2E0D3U8wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA1LEM7He+SZSVzFcUDD7BbthKMCum\n9dnd363WNExkqUwCIQDM4Z/RqCsCf4EQWG4D8xT5BDpfCYGHvbOf4+ivPlKt4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6702", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6702` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAS59UQ1CCzWp9S8BpEilzmpOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4MmNlOTgxLTE3NDYtNDI0NS04NTZlLTQwYmZhY2I4NjYyZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U2ZGRkYmEtMTZi\nYS00Y2I4LWJkYjAtYTk4MjIyNzM3YWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWh+9Dw8xH7u56ii4MAawASFrHK8IOv6D2eY29PsyvQi0gHJsA8EFwHrzEfje\neub0sv3OKGAai3a+LvmwKXhGQaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+kVGPgAueI3oVY4ISX918L7MhUUwHwYDVR0j\nBBgwFoAU7ie/HOTKn/Q43afrQR19oMvxKeYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAoTtAUkfUA5pHfC2Q0f6OcBqoAJu1wv2AI\njg8sG3yERgIhAJhx0RTRi6jZTE//RcTicPspqxMMq698994xK7z4qmCP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUrkBtOXoQCWOTf1qR87tMssMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODJjZTk4MS0xNzQ2LTQyNDUtODU2ZS00MGJmYWNiODY2MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfJCicvQU0ymKVpUDhIsgaJEbe9KJ+d8sT7OuRkkKH0lAF\nuiFu+7Wn3sN3WdlsZnlM4ZBiIZO+NoiVncN6kKCDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ie/HOTKn/Q43afrQR19oMvx\nKeYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAPCxgw7/wHOxYmdB4foMKwqY5zzZV/vqDl3KcrNANPsCIQDgEsxS+o69\nVOVzAYK469ngkpaABhDVrOIYicuwGjZW6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVmPOIgjKDNAb/cZnAoTZsbDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U2ZGRkYmEtMTZiYS00Y2I4LWJkYjAtYTk4MjIyNzM3YWYyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWVjYjQ3ZTEtMGIzNy00NzgyLTkzNTQtODllNzU4Yjc3\nYTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0uJuTKVTtKDj6e/NYxtAiM1/\nP0ELW9dV0a+K+vc6Rbc0B2HcdSHsft/pLZG5cw0H43bbCqoPmtSyuofzjNjX8KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+kVGPgAueI3oVY4ISX918L7MhUUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA5iXoV5pOk4YDmlwT6g9YPVx61K4z\nUubhvZOh+8+sSpcCICvIzbeHUWMidAOobcS4YKzbGCcIbGON+bPCoMscKagu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6703", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6703` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAROpayiHMED/iWqU/I8Ab7WzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2YjdhYzNkLWZmMTUtNDY4MS1iMGM2LTliYjgyZjE5NDY4ZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDAyMGU4YTQtZGMw\nOS00YTYzLThmNWYtYzc4OGJjYWM1NzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpQWltTf53OhiykQcwBT53M7butCBz4Uj8E7IR7+a5UtP3ySfhVdQ7p3Yz/uz\nlRGIRt7L6Zec5i8Kly87wzqAsaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdv7oTHoLsDenBGVNjMLph0B8awswHwYDVR0j\nBBgwFoAU5/jr+J2mZqp2s7BYCk7LQ2SoApwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCID6RRF+2M1KtYTOFDtymR3FwhzDm\n2S9FUFxiJsWXyneEAiEAy0OUkRmPZPVGAu9HotzWYpCYE74rwsMIAVlrHmlCWkI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdRt+WDhvKghewbU8ydqZztXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNmI3YWMzZC1mZjE1LTQ2ODEtYjBjNi05YmI4MmYxOTQ2OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsn/QioNpjOwt+poG4hS3ljwXPuNCPzygA2cx86kN76fX3\nK+xCIxNYPT3lsiLsRoi3I+Jz0FI20KLEmccq8ASPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/jr+J2mZqp2s7BYCk7LQ2So\nApwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO2RPacA+NsmMqDWS6AlGE0Tk9bOJInIxaxuROLIOdYIAiALcGYhigjQ\n8Ld08XYyD1zZ9T70aZak+3GLMKY+EDbqZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfK67MiCvg3xLTCBjlPT65sxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDAyMGU4YTQtZGMwOS00YTYzLThmNWYtYzc4OGJjYWM1NzdlMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjBjNjY5NjEtMmVjZS00MDhiLWE4YjYtYzFhNGM0NTgw\nNDQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQk7AXJ95MJhikBPzAiJOONlk\nd2i22Tprq2PlI/3AxSB5OjtYUVNuJxxumPXmIzmwmiJm4qgqJ0VfK+LwlhWMY6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdv7oTHoLsDenBGVNjMLph0B8awswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAskXlyp3jkLtxNGKifk+MvDCS5sIg\n4lerpg12tv5r50ECIDx4P9BBShn4NUQOmr73MvkWPwemCfGA/F2dADw6N7bz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6704", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6704` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAZV9oQhIaaBm3g8KtwK5eDdiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5MmQ3MDI4LTU3YWItNDgxZi04MTFmLTNiOGFlOThjYjlmYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY1YmM0NDQtYTVl\nNy00NDEyLTlkNmEtN2FkMzQwOTRjYTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcpbmQj8kCxIexk2wfAMsXgyUgp88ybKyv215joCMZTzFezcqcztFGWGO+92E\nj7VRQMdlLQo4xEV9B7xh2cvTkKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULxuMsSmC3BoK8g5lNAWLFsK1xRkwHwYDVR0j\nBBgwFoAU7ldcFa9QDEWvUCcAZJKBt4eBtn4wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgRb1SsOlM\nxum9HZqtb/i6ANG11xsaaoeixGJ0XxvsrgoCIQCRDPeUCW8t6tEyyBg2Tzd9DCgd\n4kGYABVw9XHpPop0Vw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARQ/6a60fMDcecZ00Uhml8frMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTJkNzAyOC01N2FiLTQ4MWYtODExZi0zYjhhZTk4Y2I5ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeOK6wOEuondNkieGfoRpUFnC19Lyp3uf+WL2HUCv0sUZ2\nWGtn7gCzwh+K2xfRUoIHuyCmrTfaaFnjRaxcl8bHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ldcFa9QDEWvUCcAZJKBt4eB\ntn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKU6Ow4iimbD/ZMCsgS3sBpBWymXO6TL+L9EPSgMPQd8AiAnwGytG+QU\n1y366RkmAsLyTrEo6HGks0ePoFRX9DT7mQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVwROSQFSifhV/ZU0BguKupfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY1YmM0NDQtYTVlNy00NDEyLTlkNmEtN2FkMzQwOTRjYTE2MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTkwNzk2MGItOWIxNS00OGY4LWI2YWItYmY5OGEzMjk0\nMzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5UvMrpD3dLcfikDpgpIhqc0X\neKSVuTQmJaxx5loIbxhS5otBVXLxx4qksEPjq34t95KHwXZTpdZ7KiqM55+tbqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULxuMsSmC3BoK8g5lNAWLFsK1xRkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAOWdqd3sGsqkAFbLk23rngkgP0b4Qn\necnoa1PAhq0YcAIgRiXUJI3agf2prkYpzGEZZghKo4OeTrPPkvaDq0g1p/Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6705", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6705` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAfkQ7fvurrACgBwOUMXW7/ZMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNDNmMGZiLWEyM2MtNDllZC05M2RlLTIxNGQxYmNhYWNhNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZlZjk3MmItYjk3\nYS00ZTc3LWIwZTYtYzAwMjQ5Mzg5ZmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVY7sawJd0dnzMEDj6eBJbAzXaORRLdXfW7gg+Sv02k7wv8MELNMatzkaJ843\nSX5GuV3NLxdhvT9yH9RZAx3agKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPq+wwCvTN0TOQWZ08/0S7MmifbEwHwYDVR0j\nBBgwFoAUBWixjM5zrsqeQfrGCZJ0e6ugh50wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgfXGz2DI5\nQEwMPlXP0eC8aHKd/rHDiGAUNU1gD7s8gVMCIQCqon4fIcSVAq3tMaxV6HpxIwa8\nLTc0Ia70gH0Tpe0jXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYHQPCuFPHgx/2n/9dTieqRRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDQzZjBmYi1hMjNjLTQ5ZWQtOTNkZS0yMTRkMWJjYWFjYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbwqceeoujl/6w/UG6z1zsbzVkQn7buCL/EpKCo0hXYsUW\n2mtlTtewVvhyMXIHZ4xI7ox0HEPHRVJti8O26ux1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBWixjM5zrsqeQfrGCZJ0e6ug\nh50wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIvcGg7deUk9UzBYVmDyyqHhNmG2iAnKyPzwR18R/JXvAiEAxwnxpAZW\ntvM86I6UC1p9xi3kweUGrzU+QoUJxk7ioo0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaZyel5YLsRCe/gEWWG78iakMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZlZjk3MmItYjk3YS00ZTc3LWIwZTYtYzAwMjQ5Mzg5ZmQxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDU5ODRkMWQtY2ExNi00ZTI1LTllNzctNmI1OTQwNWY5\nNmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBKUkFlSRV303FYsre8Yh186Q\nOMuJUbJ+7x0MZl3kAd0asVpQoQ+W2N3MzbJf9uMf4OCuYvHz/cffGDK/lqO5wKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPq+wwCvTN0TOQWZ08/0S7MmifbEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA16zC0Xuvhni1T7z8s/LCAy1/PL83\nWXqCKF7Uo6RqA6MCICJUohuaBWyCLks4y4CRlU8ocAxMiLdxlE1ZC811G26w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6706", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6706` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISASdQXGH05RE6aP0dTSOKsXgAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ZWMzMTdlLTdlN2UtNDQyMS05Yjg3LTdlOGRhZjI1M2QwNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg1ZWI1MWYtZjJj\nNi00OGQyLTg4NjYtNGQzOGY3MmQyNjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEctDG8f+EPy6ZdQLqlZAL+ha8BCFfCYmd8XRhmU5v10whOWwzjYUElOjkAmT3\nRM5pXApwjsE92j6H+BzNmEI9iqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUayvfTE7ta3BWRIQrsfhTL16kD6cwHwYDVR0j\nBBgwFoAUbfUur5MqbBvr285fc5NQ3csGXXowLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCzE4BU\nbrV/Rb5aQyyGRYENbOur0WbItWRzhlFzV1yTvwIgUSqoag62uZurRMCl30SoCJAn\nCx13pWDM5wD1VGOLga0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfy4T8Lr+HkrZ2gKXaP4pyhVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWVjMzE3ZS03ZTdlLTQ0MjEtOWI4Ny03ZThkYWYyNTNkMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAywvoZmGa9Aye/bw/xa04331LKtMqaa4VPAqbmxMQeKwh\ntujSPG/K2yD0UuPqqy2NW0UaRz9/d3Z4F76BwW7no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbfUur5MqbBvr285fc5NQ3csG\nXXowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXk1bkT9tV/IcXawLEB/yJPfeceA/a09z1UKtD/2m9uYCIQCt11OBnayJ\nRPnIlIbeEWgl9yaVN86R3s/Fm/sCtUmYHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfI4/K5F26+NMcaMswSWO8dBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg1ZWI1MWYtZjJjNi00OGQyLTg4NjYtNGQzOGY3MmQyNjM1MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2QzNTkwYmEtODU3MC00NjY0LWE2NzQtNmYzOGQwNzUx\nNGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4o0snlVrsvq8Qb5VWRWEeY+x\n0uA6iDCU5rPbHuA3Mmbsz1JfIn7Rpe9Mn+78GHHupg8ic4cgwVdxS7SgTGzNEKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUayvfTE7ta3BWRIQrsfhTL16kD6cwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA6p+rsztNiQ0EDExuhF+2a+WisE2r\nAFzXWgOKOiasFekCIBulQAJD3YtQq6NJ1fRC0A1/oeXYfx7kgVzgBGt0PhUz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6707", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6707` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAfOWNWIxzkkfbrSJn9up164JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MzNjZWRkLTVjZjUtNDZmNC04ZTljLWQ0MGQ4MDgzZTdmNjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdhY2I5YWQtZjNi\nZS00ZWRkLTgzMTMtYzQ1OWMwZjJkZWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED0gmbtuBL5mh/mE0+5kIRLSnHqIVS+2DdJX6XP7C5o2mu6OS/uwlCQK62L9Z\n5//8aP9AGkRSAUmjLcLqA6EdlaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+bX1qdJ3lTFUrvnlt5320fYcBUwHwYDVR0j\nBBgwFoAU7yIVLL9nbI/Elpg05gFYd8YBP7MwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDvxwk2+miTHeZvF1TXbJJ26qS9bHP00rg8XSwqdmeouAIgNW+tVdmn\nIaC/DbenMG8NEnpLadsrXzh5dv6FXC2nBEY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR3MSCHusmZg4GsD7lsqRz/vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjMzY2VkZC01Y2Y1LTQ2ZjQtOGU5Yy1kNDBkODA4M2U3ZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgc+qxitniDBLR/ORVjLZ58ZT6QhAHFP0eODTZ8cQRiL9x\nbHGQy7ujqb8wGV8105XvUxvfBEYMo068q2WFfNwso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7yIVLL9nbI/Elpg05gFYd8YB\nP7MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPSPZk4xXaNmMWkgE0vx4eph+KGen1bcI/8lFNW5K+iwAiEApnG4cv5I\nBo7tRpJNFQk144RK1Xjcs5NzrJqxbj+qaTI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAclQLn+GASRu3GkoGC6hK69AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdhY2I5YWQtZjNiZS00ZWRkLTgzMTMtYzQ1OWMwZjJkZWFiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTRlOGVjYzUtMmZmYy00ZDVkLWI5NjMtMDdhYjU0ODE5\nNTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjUOI49BTnDbkhaPspGCj/n3/\nsF+W2tBqgI1zhWwcbZEpFAq+h1tph6tKA4fyz67d1CNRaR+Pb5g0G91HBQvJAqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUu+bX1qdJ3lTFUrvnlt5320fYcBUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA+THEDGjEQgdOkTOLGGfwL1MxVRLA\nN4PeWp3BiWTyvhQCIFYGLVmGcq6sc32SCNGmxb63p9LbD9CZ6yW+/o0n56s/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6708", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6708` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISASrDWWbOlbkqjWTuCV7U+qMjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExM2I5NzJjLTdlYTEtNDJmZi05N2MwLWIzMjRiOTY0ZTYyZjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUyNGJhMmUtMDE2\nZC00ZjIzLWJjZmMtMGNlNjU3ZTViNmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwU2rMNuvB7yoTdtCtEhvnvTGFwVaA7M6uZ2KwiKYt+FcO+gn5tXr+O+e5NXj\n70ba2EqiTJkeS3QckC6Hlaaa36OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPLSRU3GRiYHGgq0w9AC1KTyRTSgwHwYDVR0j\nBBgwFoAUBp+h55zBpkdGq0PoUsL9XeyfuVcwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCbmTXt2qIxajcc2fkoHXyBcYkWtDgalRnE/6XkqVx2uwIhANdaU8vl\nrbCEAy1rddmxTkMzVpZpIL9okSRh7T46jgit\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVZQnwPBR/J2nguJIJ5Kw8/5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTNiOTcyYy03ZWExLTQyZmYtOTdjMC1iMzI0Yjk2NGU2MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb4hwEXOJb6I8gHJ3mUNiNiscibKrztTzSx95Z8nBl+/09\npE7UVH92pzjftdMBd7xjdpr4l8cGfg0FopibIQzio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBp+h55zBpkdGq0PoUsL9Xeyf\nuVcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMROByNddilC25TtT79j1YnnnFUTmNgft6EExe7yw+CgAiEA4jG+i/ug\nA26CG5feeR7YzVxtJgx9Flxba3DqLStAcq8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdqG7AsPzXoRfnGGD9tJxOBaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUyNGJhMmUtMDE2ZC00ZjIzLWJjZmMtMGNlNjU3ZTViNmIzMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjYxMDVhOTYtZmQ1NC00MzlmLTkzMTctNDFlNGI0ZjRi\nZGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPIA8yzKhp5N5cwSfrdXyla14\nttVtTeYe2BSqp5E0OgDOoW8ZPMfls+uE+w4s13fpvJSfBAZz2IKgIWutnxHM4qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPLSRU3GRiYHGgq0w9AC1KTyRTSgwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA9zRp+NOsn0hM9X+GexhOlnF+sGlA\n000tUzImRaR78WgCIF1AYdDOcMQLKJ5GRMccyYUzce5dFtz3YfLXGY317lEJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6709", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6709` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAQvNz7JO96ZF/jHh5lR8Z+vGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0YzRiMjRkLWQ2YTQtNDFkOS1hZmY1LTIyMGIwOTk0YmZmYzAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY4ODFiZWMtMTg2\nMy00M2M1LTk4ZDYtZmQ3NTZmODVlNmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdwn9ZsouJSiP7RwUZ1sfZabsWTMHQvtDV/eGsHmnA8dgvhG2ujyf0Ln9G3o6\nINyX96jGFjcXzpH5oGuvOuddoKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUda2IecfFHSlsDyL9RoZ/5nYbpv0wHwYDVR0j\nBBgwFoAUk6BqirfbpWotM7a5c69yemd0qYEwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIBdG03JNc/UxZpG2T97MKnHNL+jLAyrSVF1pHfLb9DTiAiEAxetrgY+lFZ2em45l\nuIy/B71wYMBPz7kuGFVmqJfzwMg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfX1I95VyXtTB/X7InthludiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGM0YjI0ZC1kNmE0LTQxZDktYWZmNS0yMjBiMDk5NGJmZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6hvWIWtuvIKjT/KoWpg5nAEVt9gUdtgpc1L2yRuAOJIij\n8I95QD2lBLBlbf7byQVM3FI/kqzUDE3ArYLkIPk3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk6BqirfbpWotM7a5c69yemd0\nqYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMsIzj7CbwNv8+QDtRjrE67DjMNrG40GzAnp9h7j2ORECIQCovESrLkab\nhqnTZxBOXAePhjamWygQQEcX8Bb2XQkl6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbJEECttgns6MLPskl+5yjR0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY4ODFiZWMtMTg2My00M2M1LTk4ZDYtZmQ3NTZmODVlNmExMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTkwMjAxNWItMDY0ZC00MmIwLTg3MmQtZjY5ZmM0ODZl\nYWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6eX6jL/kD4JqTHUM3zpFAsCX\n6Aon73yoqGNfIBmbWNSNnhmI3HQaoTDQ3HpiDbihGXvKNgK8se8BHsj6N3hx9aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUda2IecfFHSlsDyL9RoZ/5nYbpv0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB4viBUOD81gCVWoOHS6SWs8M5kGIRH\nDzlXRgMpBYhLMgIgD+WdnQG2DqJjIPayE8j/TDEgsTONGw7bpL6KmbcDJxI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6710", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6710` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAc0SOsvB2O+gpqDYoQjBpT4JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZDJkOTQ1LTQ3MDgtNDdjOS04YTI4LWQ4MmU0YWJmNzI2ZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBkYjcyMWItNDkw\nNC00ZThiLTk2ZjYtNzg2ZWI1NzE5Y2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMsCiPtrXvUmIj7U52IAGY7Xn7RgnTp64gZ4nVgqgKmApQFVcnlcpFIgy0gPD\n9jZASvIvHR2JQ5IvZWRaUtWn1KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7bStzxwL3EfBx2TEHtn0uTYHFtUwHwYDVR0j\nBBgwFoAU5/bHGEebk32mrl1S3NRM4jqSdH8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIFuZETjsRnJuY51Kh11Ff44jCQihfrouzg8FQKz8kj2MAiEA\n0uhWu9uS+KpRWRQgMBOB66C+7fjqe3DUaPv37flFr9Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdbl5/V5r6L9b/v5Io5lKBkbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWQyZDk0NS00NzA4LTQ3YzktOGEyOC1kODJlNGFiZjcyNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZag+7imw4ipj3o7f/GEvn6TIzsr/v6IWvo2Lc1D1JifBR\np0Ta7MJihN+NWtnRFH4Zr5BC7STEj1oiyIOHU3fYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/bHGEebk32mrl1S3NRM4jqS\ndH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbtfF0oxru0L2drXpbM73EDZJsQOAdHTI2rA1DwpNUCUCIQDYYh69amKh\ncco3VgUJBTrihHnEW6+Thsf37+cShRalYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXveEdt2k+dEMElYwM6PKWuQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBkYjcyMWItNDkwNC00ZThiLTk2ZjYtNzg2ZWI1NzE5Y2U4MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzU5OGEzNzAtN2U3OS00YzlkLWI2MmItNWZlMTExNjFk\nNzUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM0HBc6VBkTWX/zK2kKfaiEfK\nSuHtMpkZXAhsdQBgLyIXVXuszRY83twaIEaN9h3zlaBuVapBQqJDq8+B3ffAiqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7bStzxwL3EfBx2TEHtn0uTYHFtUwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB5vO5wNeWNiG+KRtKUVADlSoGWCXO1\nsbjn9G4/JHnA1gIgKDv+wsKTDC0eo8e7DofbXkxgyxCRJMqNru0NTEsyQTw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6711", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6711` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAa1urAZ8oCRO6hUOU1ePJGW9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5NDM4OGRhLWFmYzctNDdiZi1iZmQ1LTViOGE1MzNkMDI3YTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdhNmVmY2ItNGZm\nZi00N2IwLTkwNTctMDhiMDE1ZjAxYjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWQZwg3R5nsqsrtN8P26M2B63gfxqs86BO3L5P8ZoBLzqM7mQsqwIETc/Qq2w\nndzG/kOao9sj4dwUvo/qGARszKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ6pug6PyVcqXU7mjTAbdrbv9zpIwHwYDVR0j\nBBgwFoAUsz98bNfjODGI+qhFatbrxHpU1EIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDRj1/cxr2KR7WodiMCkWCBu5gwifdRfh1GkSf0hkwB3AIg\nMXAIPoZo+pIQ7NVvnf4R78MbeHgWQwgl8hR1P0wA6t0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAckAt2fVMPuT53KUTpIH9Q8AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTQzODhkYS1hZmM3LTQ3YmYtYmZkNS01YjhhNTMzZDAyN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJPsUmpQA0fB6p25dUtZgl+IRb7VkvcyGchbQucMqTAiww\nkOLZVCSCfhe7nvViX/Nym/0XvoKHgjt9l32dtw/to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsz98bNfjODGI+qhFatbrxHpU\n1EIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIfGFQxOGMHuhOzE3tp31nSZphQEkf4QF8rEq7+zlciXgIhAKyPf421JwZD\nGytMgOpHiRwUuaufdAQ7s62k1ZJJoGQc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaiCvcVVLFEUt0WWWc4GaJqzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdhNmVmY2ItNGZmZi00N2IwLTkwNTctMDhiMDE1ZjAxYjQ0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmRiNThiNmEtNDhlMS00MjEzLWFjOGEtMjBiMWFlYzQy\nOTBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbngUwtU4bMA0X5yhSMrjAVdc\nFv+Jdo/aa2WLlA1GdVy3JJ5bkBQ8/mKyvkqKfjwg49Hl+abE+BhIQwKp88RGfKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ6pug6PyVcqXU7mjTAbdrbv9zpIwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBojvix1pcUG99eYF0UsPsGc1m81qer\n5G98ubYEhiPbtAIhAJB2tnGsJqDSB58sQssV+sX8T3Tbf9ftXqXUL8CDh7a+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6712", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6712` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISASSFJH/2WOQdKBPkCV9cUvswMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiYmFjNjE4LTA4MzAtNDhiYS1hZGIzLWM3NDk3ODY5YmZhODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY4NTI4MDItYTU2\nMi00ZjI3LTkxNGYtNzE3NDQwODk3YWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiSF0SqhWOLcorwavEyPh35iqVlLvoSAxCivG7Z6FSAbVk2JZPY8CFg8Xpwti\nac5iW0g9Kb3tJ4aPyI493aYV7KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXtKN8Ae7mASksxcpZefbML4w9pEwHwYDVR0j\nBBgwFoAUI9KJmxIRBSWupnOWxyf97r1ApUowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIH7YQOyvddTb\nCT6A7rBncKsYhETxhQEJO/lJdEnDocwwAiB2zNLb1+LFgRNKlNHGgqX9tOrBTpwN\neht/f4i+wHN0vw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX7HcZUgFtx5glO3botptzThMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmJhYzYxOC0wODMwLTQ4YmEtYWRiMy1jNzQ5Nzg2OWJmYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoDA4G9aZQustcfB0UCqF0V5YoLIGh988VaViMREhFfb2d\nppqzpSSaRosn70/a2mAZeSRjb4hg05OklB9iQSEwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI9KJmxIRBSWupnOWxyf97r1A\npUowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOFWPw1OO4D09At6dzYrb4nIarjSxjMTB2BslgGUdHFaAiEAhk2EqpDM\nfnRbCMHrPC+WaliFHJC/z8THQ8sV6K3vF/I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfOtBC69nO9QmPCEte0vMnsHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY4NTI4MDItYTU2Mi00ZjI3LTkxNGYtNzE3NDQwODk3YWZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWE0N2JiNjYtYTEzOS00NDJiLWI0MDktNTliYTc0ZmQ4\nN2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWm+iF6Vwx2f7tDutgG/hbFK7\nYm0gaIuuXl0nD/Qh4CcTWUFFCG1As2l62AWenikCBrCRF3JsrfmMBCvQXugrLaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXtKN8Ae7mASksxcpZefbML4w9pEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA0G7mlbB56gP/1ir/WRWWuIEoVbUh\n1i69M3R5txFBa0sCIGqppxCKp30pDgi/MC+8GyDXyUoxvlW1pQ6/qrvrq7dc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6713", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6713` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAY5ELXYtmapzqOSM1+szt/YYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5NjZjOGQ1LTExYzEtNDU1Mi04NWU3LTFiMTY5Zjg0OWJiYTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQ5Y2YxNjMtYTE0\nOS00NjM2LWE1MDgtM2Q0ODFkYTQ2NzcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1CQ69exwt4e1ZxHuhdIbV0RFo9yX+bMbVONz3DRMwomocLifGp5UOoM5tp4U\nFC4iTqJuWHDJDF9NTg1U3fsOyqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwCrbmpM96eGs7xAeWA9HVwska2EwHwYDVR0j\nBBgwFoAUoLNvXSYR0uF2duOL0e+3bRoi5MgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIfFH1acb++TpfKJt4ifXvuuaZzmz9rgiLij3+6rgMDTQIhANh6w4K/qyox\nib+HZh8Te7C8OVvQjVmcacni92RTAkM/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd/c4jRACDyo309bjzfUr11tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTY2YzhkNS0xMWMxLTQ1NTItODVlNy0xYjE2OWY4NDliYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT86F19SaEPcFSW2IWZKCqps9AH1sA2MjInqWPstan4NjQ3\nNCr28XuEaqc4jHDpPs4yJV9B26wlIeKqiddSSXEVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoLNvXSYR0uF2duOL0e+3bRoi\n5MgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMCNdLDvUVb2JxqvqXr2kwsDlsFQv0AQYuG4gpuIfxhaAiEA6BVmDEha\nqbAjdpdRYTjQRH6AsOlp3FycgPktv/Hji0c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQHjI/OojJqkcdFL8DmYYbBeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQ5Y2YxNjMtYTE0OS00NjM2LWE1MDgtM2Q0ODFkYTQ2NzcyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzBhNjc0OGItNzk4YS00ZTlkLTg0YmUtNzNmZDNkYjkz\nMzZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgqFbubuija7Pyxvv+V0qPgxT\nTCOVyG1/dK4RXPwVS7kTLVvKMGEuq+IGP3FJrubz1GOqhxkPp37ikvXp013Yo6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwCrbmpM96eGs7xAeWA9HVwska2EwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAinpslP+A0CIHq1y7llQZP7TVrFfT\ni27Lg7wW+iCFkZ4CIQC0moFafCTcFFR93w8gsTLoQ2cEPdk53tWeKPC+XuHiLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6714", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6714` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAc0LS66drLnudoyrEy8YwlFDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmOTBmZGJlLTFhNWMtNDA2MC1hNzFlLTUyMzI4M2JlZDRhYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJlY2JlYjgtMjdh\nYS00MWY3LTljZTgtOWQ5ZjBiMTlkN2JiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJJV2oJPxUXrft2PEOL7kYaoBP2KKSaEgDJVS+U1LYqqAXvgO6h6qLrMDU+Cy\nwhhSa9yJyDEfOw8DYmxn8rWvvKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv+Hq39Uw3p1P6cI+yM6AB1JC6bkwHwYDVR0j\nBBgwFoAU+Ra8VFGZ/Xo0W3uWONdzDhtwTkQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAOCxCozRr2gOF5CyDdxnSh9rzrvRQk/8YI9eWsYf6kBsAiBkrqvSvez2\nhk+LrlnYl/pfb5zAvD5Oh8sITmEd+x1q2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZQIntOUsNd7uDk5TrfN3OTFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjkwZmRiZS0xYTVjLTQwNjAtYTcxZS01MjMyODNiZWQ0YWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyFCcE6vIKJkjD1kK7qD3Mrgku6Bg8metI0EZ99hdOik0r\nMJPHD6Mx05Cx+ixhcl3xccazfQSCxCeqOpyOrEi5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Ra8VFGZ/Xo0W3uWONdzDhtw\nTkQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOAMNtqH9wtgKp5H1WecvwIQrYwJp+54sBwA3ln4hz9UCIQCqNoy9k9Yb\nK8VSqlSGxE4/+JRexA1uNXgargs9OwjKOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXZ1vItjsYKXGX49l028vFywMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJlY2JlYjgtMjdhYS00MWY3LTljZTgtOWQ5ZjBiMTlkN2JiMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjAzMzRjN2MtYzM2ZC00ZWI1LWEzNzQtZDBhZmM0ZDNj\nMjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERjeslOVYdu9AoE5HNU+MKar8\nwDuVrTQaWfoD5OdVU7Whs6jkkcQTP0fy/L76DkwUNaChI22DhUCEHuRQz/Gf/qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUv+Hq39Uw3p1P6cI+yM6AB1JC6bkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAr9QT97hGaGo+hlEjK4FPrJ5HPU9V\n8sd/KguDBLkQ3hcCIGo+4xhqzad9hpyiihkyeRnBk3GAeBRDFcKKPSoxiFdQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6715", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6715` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAfdZeJQitfx/COQnVjrzeIGPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZmE3NzhkLTRkNDMtNGZmMi1hOWI4LThmYTFiYzY1YzU0ODAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWVmYTQzYTktYjI4\nOC00YjZiLTg3NjItMGExYjE3NDZhYWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE56mwtLZhylQKJYtUW9Lhy5bzYCnQiWKz9CNsJDY+TU5fUXc2m7MNFmK1hkfd\nVqm/3Az2XBuOfqAY2RXD03il/6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ0/Kl3knzqojKgk6bAHsJHcO7FEwHwYDVR0j\nBBgwFoAUechJnNX1Ye75ZfGGcrpNsJk+U7AwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDacS5AWbdFsbMYvQsXJcv7HqfAYov/GzRgI0ioFG8w/gIhAKzw7Sxu\n4Mfpi5UE8si9gm9osScgWKEUyrLif17UPbaI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY8jGOlXcXbZohmBixwE5HUhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGZhNzc4ZC00ZDQzLTRmZjItYTliOC04ZmExYmM2NWM1NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARf2L8jiEpZ3QGWEPu7r7kD7LHvUsubLUDhAIr8jPeqwnbG\n7VZA7Y5Sgqe3H5ISuErwKKsJemb3SOgcH5Hjr3c3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUechJnNX1Ye75ZfGGcrpNsJk+\nU7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIget67/QBdM0e8SHFIplujQx1Dfrd+VS2igZZt5JLw4rsCIQD/w1tKpjsH\nX/5h5hZOK+gYakNHU/bE9yUnIqELSSxQbA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa8+3Hlf9yAjAKagB6MaM8YzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWVmYTQzYTktYjI4OC00YjZiLTg3NjItMGExYjE3NDZhYWFkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmZlYTcwNzItNzA4OC00N2QwLThlZjQtMDJmZTAyMjM5\nNDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYzAy9ul2UVKpWXjTalhiwuhd\nkvuMM/VbDCHtv67wQOWO9Z+QxN9gndzN3U5HiBrshmbhWXA7icN4KEFzZAb2e6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ0/Kl3knzqojKgk6bAHsJHcO7FEwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBHsYJIJYbjoXt0b3jmzp5DcnaKd8ey\nS9CWueL7Rd5sOQIhALJfdoNvjhkKYTMAjaELsqr+PYX38PHBQyDn0lSGRysQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6716", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6716` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAVm/Y6GAXZ3MMtE4qTu1K3ymMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjNGI0OGQxLTY5ZmQtNDdlNy1hYjZjLWQxNDRhMjUyM2E0NDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA5YTJlNTQtNTRi\nYy00NTVjLWFhMDAtZmQ1ZGRlZGFkNjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnpimEp/bpfCjT/aY1i/GQvrGN+eI6ybN8AhTzLJdkMc2G6Af96VJ2NjalMV/\nIhtxY4YDUBngfKRx4xto3rBu0aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmicQDeUUS66aiZl/Z5mboI+o6S0wHwYDVR0j\nBBgwFoAU5uyH3AWfYHv3N+c4OmOxMhL80GowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBc7vfHI3aLVDb0mlS48qbq8FKhHqLMs9Qjws059\n5JVxAiBdIN8RDf1MkDA+rMxV+dkEnEw6FoFiv3DFY+xMofl11A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAfMECFhfysbUY1Fy65ffJyaVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzRiNDhkMS02OWZkLTQ3ZTctYWI2Yy1kMTQ0YTI1MjNhNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATulnN8uP+JMM68Kd/29IvIjYsdwl1LnfufyPYOmIyAhgPA\nf26e3/aVleSJynbd+H0pwOBaSkOhpVZkCqu8plx7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5uyH3AWfYHv3N+c4OmOxMhL8\n0GowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIfIRHieQ14O6PIm37C3EP9JnePXIoW2EfH0bx8GDfykQIgMxFfPVx49KI3\nTohPqmVVQ8if5OqM81uBEffcNlS1SLA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYnAiPwq1zWSRjaBKOQJ5F8NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA5YTJlNTQtNTRiYy00NTVjLWFhMDAtZmQ1ZGRlZGFkNjAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2U3MjQ1OTctYTc2MS00MzE1LWI2NTYtMTMwZTUxOGI5\nNWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPmmeua9hbovdNbDfz/UBeM0Z\nkfcVCKCXGL4g+4w/kR2OfogaSSMRiyzPytUPHtU6az3ODnElJAqhKPR38LMkuaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmicQDeUUS66aiZl/Z5mboI+o6S0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBoKv9/qQMlRQ2lPfsOUtpERSBfVrzU\nj2FDQLaHtItunQIhAM6Y/KTEn5S09LycwJA1nY8VH6Gj8GCYI5APWHZ6EkMX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6717", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6717` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUpueMoteT+UQvBbVC633pmwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMjhhODFjLWJkOGEtNDg2YS05NTZjLTllM2YwYzI3MzUyOTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDFkYjFmNDktOWI1\nMi00NjM0LWI3ZGQtM2ZhMWZlYTBkZGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfJDOSRDygp8GnszCBJNIXdXl+5nKOZ1zySVny0cQDimds0djTcp2AqWDo2ZT\nnMXBZgpg9RoXStRaA50eT+IcbqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqVucXdQP0Q7ioS3kLqu8mg/YYZYwHwYDVR0j\nBBgwFoAU8Gm3FwnesFNfBz43gk5dRqce44wwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIBHBoDOV3TUY4ASbuNuZ+6j1W4BSjjwX2uFaTnTc\nik59AiEAtkwOBxMX8wlBYhTawVE40hSawpsin9sn5QG/cCYeN4M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbxjA2iy3jOSuVMkR/3/3jjLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTI4YTgxYy1iZDhhLTQ4NmEtOTU2Yy05ZTNmMGMyNzM1MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ91/lCtMM70W36+k0isK3yNIXYv9r5SDlQ03zod5RLoJvA\nNcWg0/HgzZQQho96Ad+pQ8GZgLfYAkBRl9g02R9+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Gm3FwnesFNfBz43gk5dRqce\n44wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIbqEdSIJiWBUrwigbWHtLEqA25DWlx6mFMSGodSWlTECIQDayTMY8iUx\nPlemp9eara7hv4fAIJAApdCwVKD+NXLpAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAT3trIIlyU5ShhIUFEFOEaqOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDFkYjFmNDktOWI1Mi00NjM0LWI3ZGQtM2ZhMWZlYTBkZGVkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTEwZTlkMjktNzIwNS00Y2Q1LWFmNWItMDMwYTc0ZmY3\nMWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEc3dyLDI8scxL6/YQh9dSdCHZ\nMTxXL3KpkTl+J95dccZMd2+aGWwTQx8jxWKOPJiYyLWntWKXOvZPivonFHsIa6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqVucXdQP0Q7ioS3kLqu8mg/YYZYwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBydILZHqmsNzI6qwHynbSH9dG9RzuO\nFU2kvwmHefMjxQIhAJE0SDasC8i6a58iBAmBd5pzKAsV5j4iai7Cb+GiCY2f\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6718", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6718` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAcsnM8DeWfVH+DJ7sdwX5wlXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2ZjBmNDc2LWFhYjYtNGY2MS1iY2Y4LWQxZTVhZjVjMjA4MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJkM2IyNTgtODY4\nNy00ZGM5LTgxNTQtZjJiZDQxODhiODAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ1GG0ZxTkMSuqFoT7zZmNIkMaeh4TGkIx6Sk26WiQ5EEXjW1I/JnXo3TDVWM\nIeO0FlNtwwFApoUAfoYGb8sTMqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPe7r1DndL+tR/itSHSJP2uGiVQwwHwYDVR0j\nBBgwFoAU6YBL31n4SC8I4wABfEFsgySqMO0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDA/X0kjiJ6a3eBpnUt1U6XGCp2+H5lxjTdqKEHypDAsgIh\nAMndHovozxJAyLxoCchdEvRiHQz92sUl/gmbBt4r0bQn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ/bjtPBiIeNiuuuSpcQ/KRlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmYwZjQ3Ni1hYWI2LTRmNjEtYmNmOC1kMWU1YWY1YzIwODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsNU39ICA2u3yyRYJR8hAFNoFVCzVJPLVOH4V7qiP4Bfa+\nLBChQM+iK3fdJ/3lTyDEuGQgQqSG8QrGyr40QPbHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6YBL31n4SC8I4wABfEFsgySq\nMO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPqEgm7D6nffK9439grxuL8uw6zNLk1k8RgZdxcHDm5rAiA9EPcg0O2m\nwHpIEhaXy2drIiyeTseL7vwDpUOP+4Kpdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAarLFWUy4AhZ0mWzN8JV1KKhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJkM2IyNTgtODY4Ny00ZGM5LTgxNTQtZjJiZDQxODhiODAxMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjdkZDU3MWYtZWY5My00MzM4LWE0NjAtZmExNWNkMDNm\nOWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJaS7QmpAxxzmevAX8NOV6Hhk\nCJCyMFViBFtyIMgy6cvpcPViQrmx6L/IBsHl1mMCqPCa+nHDSHMtrVOEt0GNeqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPe7r1DndL+tR/itSHSJP2uGiVQwwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA3TaTQMC6kC17IpR1i8e00N5N3br6j\nd/tHexpS0WRXdAIgA49Ps4VBxvJDcSqDcLL5ZrpcX6b0+O8IzgOOBsDMAyo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6719", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6719` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAetVoB63+nJA8OXRyCEhx1sWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxYzc2YjQ1LWY2ZWEtNGE2Yi1iNzAyLTZjODg5MzE3OThjYjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI1MmRkYjctZjA4\nZC00YzQ2LWE4MzItNDMwMzZiOGI4YzZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPgexXWCBHGHeLSOp0I9KN+sk6zew/bNAjAXhCxKTuUU1FFGvBtanpdKSwc2y\nFc6x0qleoOu7xT1aovYZJS0KZqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU22+ayI6zT11DWmTwhihtCwjFdKkwHwYDVR0j\nBBgwFoAU+Rhp3xMLIRjCPlZjy08NpRu9NmkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCEUNVpNWIERTic7bfZJHeYxt9qH5as\nKUhz6RYqOH6qagIgEIHIE85K+oYuc5Kcfy60wiIbkwAXpMm5+AM7LWxt7xc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATMzFpveexAbGdutHnwvymEjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWM3NmI0NS1mNmVhLTRhNmItYjcwMi02Yzg4OTMxNzk4Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMXm7g0Qogtdn3cboTlYJXDJhnAIZl/zwGcNmkdF2lz6Yv\nXTte3SWJHYBxnDsVEfUPty8VgpmVFauCFhp2WHgOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Rhp3xMLIRjCPlZjy08NpRu9\nNmkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKPl6eAVwJa9J7ATLXCntgIzKfT1OWC/fy9jJoqhWiopAiAtClnKiRgd\nDKARQkG+Kzjn8VYprqVlJS9jqotEfwT5YQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWFjHiFC+0fmqC8w8FS/LwvgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI1MmRkYjctZjA4ZC00YzQ2LWE4MzItNDMwMzZiOGI4YzZkMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTViY2ZlYTItZTMwZC00YTZhLWI3YWEtYWY1NmE5ZjRm\nOWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEq7YP6mq7M3qJUvej2M5ucCor\nTyOXLB8o31I43d2xoX9nYiThGQGxCGZOzG2JGxDwSH++GzTJiDTNW/rbYirHqaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU22+ayI6zT11DWmTwhihtCwjFdKkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBUbPfBAVzNuFTvc7lLMW7WOO6FrYdd\nUL7g5HmqyXq9gQIhAMVo3tcBc8cgI/J0XrIg4rWnngoYC5SsQWLTvMvZRCut\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6720", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6720` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAT1gzzvifiYIsN/Y1L16SQUUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjYzQ4MjU4LTM4N2EtNGI5My05Nzg0LWY5MDA1ZGIwMzBhZTAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJhNjhiMGUtNmMx\nOC00NTkwLWFhNTUtYzI1NmZkODExNTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8GPMSVP4zJAXRT7xeO0iwx400zmj9Uxu3gZW9spvIJB9EcZWwJdlzihka2c7\n48RWqLCcCAHrOhmAwHoDp5jXdqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWkyMimUIyPQ8dyH8wnC1ru1Km4MwHwYDVR0j\nBBgwFoAUuz/J2y50DBwPmhfA94bcfd/uChgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC+21t+34kCM9pdObZARmyQad0trimU\nrDGspMTDSjO1nwIgbQlXn7BPLBxVO16JXI8drX6par6didkK+NSl8biCIEw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcUNPLWrCzYcfSITKprJw9s+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2M0ODI1OC0zODdhLTRiOTMtOTc4NC1mOTAwNWRiMDMwYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDoTsdbo2vZZRaSMZtE6FUDHQuDazEFoZU97M6a+2wrQW7\nMUdRbI2V24GMILQ7qu8zJiFqGdu1BKnm7lvs/UVMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuz/J2y50DBwPmhfA94bcfd/u\nChgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALXfyykTMlBXwkcPDuQKiHfPyT9GKY+bmmOz0brR0wQNAiEAp4tAuRpz\n00GHEkTANhcC216AnV2/vHMumfMGBCmBaCE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAc6Qk5tyMEmsPpSP/12YyTDhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJhNjhiMGUtNmMxOC00NTkwLWFhNTUtYzI1NmZkODExNTIyMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTUyMjhiNWYtOGMyNi00YTc4LWJhN2UtODViMzcwZTMx\nODk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqHAnP98r73MSA/beNfa3/aPG\n8AcaATbH04p2ZbGSG7SGgRCX7DgU4HXtG/IckuobcszxiX2adi3NwUMiYsFF06Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWkyMimUIyPQ8dyH8wnC1ru1Km4MwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAllS/8J4kM2zntgUfvQY/HUIPLKtz\niWdD1D8Z/6hw4wwCIF6L8zuR72xVr8RlaQgGKqB5tlYa2zmXLufqCXjFbihI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6721", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6721` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcPixIttIyw/lntpVFgqw9eRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyM2U3MGI0LTZmYzYtNDE0NS1iNjVjLTliZTZmZDViMDMwZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODY4MjgzOTMtMWI4\nOS00MjY0LThmNWQtNDA4Zjk3ODFiMzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd1NAenxGs4DWWKKA6RUWLJL2cum0s95obcWZiff6Pqut7K680y+E6gyYBoXX\n9H8JJoK+L0rIaPlLYOvVauRaeqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYKnlFrz4I9kC9KC5C/7lmq4G83YwHwYDVR0j\nBBgwFoAUs6Ch7HX2qlZuChXathRqaIUR+80wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDitzG1HTu+\nx+C8qm6gyrw6rGniZgzlDuINhq25Eo6BgAIhANUIONhs2qvV3h2h6uCy0PM9OUej\n2KbR6YfJ3XdDpwH0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfaGh1ZdhRp3hmZ5T8Bh35NxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjNlNzBiNC02ZmM2LTQxNDUtYjY1Yy05YmU2ZmQ1YjAzMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+CoM8aOBs1vpZZNJNyRepOwa5E1hn1GP9ttYwXUobjJ4j\nFmEHWzZjvs2hXchpKiQBMuQHkLM/JKsIpSRklE5Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs6Ch7HX2qlZuChXathRqaIUR\n+80wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJkRKKL2w6VaPRI2Lvo4VR57PF+HBpGJyxusxgJvBuRGAiBgydmyjjPZ\nGuYepfsTE199eo/7eIaTI1GjxklFSBa4LQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUTUfxa3KBfRidLDK1t0fDbuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODY4MjgzOTMtMWI4OS00MjY0LThmNWQtNDA4Zjk3ODFiMzlhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGEyYTc4MWEtODA4ZS00YmNmLTg5MzMtOWE4ZTk1YTMw\nMzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFsjl0EseVxIyqPDhcmSvb/te\nURVzgDcr9o3nbI7tqcSQ8ru6jgPp+GeBGPEU/3bldnXUX9qr2dWwaLedPuX9W6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYKnlFrz4I9kC9KC5C/7lmq4G83YwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAgGCuCOrSmR6y0A9SdUq6qgIUY1HI\ndaJvWi90c/Kxi6ACIQCniL3MxeSM/oR14lO3L8pTl7vd1oKJF0VEiRYeD/bBXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6722", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6722` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAVimKdc2OuAl2ETjVsOB3duPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhNGQ3YjM3LTM2ZWYtNDdiMi04YzZkLTA4MGE0OWFkZWE2MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWVlOWUzMWEtN2Yz\nOC00ZWU0LWJlM2ItOTIxY2E1MGUzYmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk5IE9SaxAdBNfOacd/UFyy9ldjnZCyM8X4n9aNSP9JTfUyr1LWX45fumgX5c\n60TLMHFYeb5UK5oPi+H4ZyWZsqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0cXyPGE0CIcn3Pa6Kc/+6AG9VDcwHwYDVR0j\nBBgwFoAUXl0UfIULRtgVbbOktc1KUHYbMbwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgOubw2RsedztEZDoG8+5gY73nhEbLphi4LAdt92wBYEQCIQCp8Kj9jT73\nrAepfSsWyGgp6ubthHK/Bu8gn431dCyi9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAREUswbYoBvHxoq6HAMn6NHFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTRkN2IzNy0zNmVmLTQ3YjItOGM2ZC0wODBhNDlhZGVhNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKnTIT2riA6Mudw3bX0UNDhXlfXpzdEq4KlZkuPH/UA+iW\nLSK1PuiqtUfMQ4m/W9bAb+NxtQodNv7OC7Rq3RXio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXl0UfIULRtgVbbOktc1KUHYb\nMbwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIqKX5owv66rUM6DhBrFC3RZxnV0bkr2LZ+5gaP4saAfAiEAseu6MpOj\nRuuPFYEQMQHrbcmCCvzcEGhTGDdSRLGo548=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQbdAhN35CUJW93eFcZjzIosMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWVlOWUzMWEtN2YzOC00ZWU0LWJlM2ItOTIxY2E1MGUzYmI0MB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWUxZDFhMDQtMWNhZi00Y2FhLWEwNzYtY2M5NTVmN2U2\nZTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzSlT9NCac+eK8tLUaqs1hT4Z\n4kOMq1/UfqFkZ4JYqlaH+/ebrDaPTCUIRZ/AqL/H+pmISGWL2LHMFwq4A3vroqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0cXyPGE0CIcn3Pa6Kc/+6AG9VDcwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA3i3M89g92+PuJDQZ830sQUAkn0Mz\nUUCGOefv0/vw000CIQCPRuHp4o6Yw/If/jKx0HytlaaFB0fFfiMTkNbW2X2eOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6723", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6723` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAT5aukdqPnkND5bS3LJk0uezMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0ZGFjOWI3LTU3ZjItNDNjNi05Mjc3LTU2Mzk5ZGUxMGZkZDAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJjNGJiYmQtMzMy\nNC00ZWU3LTkzYmUtMGE4OTFiYmI0MWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ9vP5PoXjiqpjiEgd7SkgMGTCYdfkkTaJiy6//1AIzBudGQMgGpGJraV5vIz\nPT9YQTX8245T44KRjf0u/U8Y7aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv7K9jSmR6y1l18HApwDJfcSlijMwHwYDVR0j\nBBgwFoAUs47e8A96VLIJCUFNcbNgmBIHHRAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgcS32Jf8mk09ltGM92K6Mgh/8mHIJNFYeDWByYNEZ4Y8CIQDkVBm86XHE\npsRXqXJ4DYWEHzXXfTz7tLqWhTgpoZCxiA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXkJTqTzJJZdCafIE8OTtYipMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGRhYzliNy01N2YyLTQzYzYtOTI3Ny01NjM5OWRlMTBmZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqK9a4bnQJ8k/f3E7o1nwD7w1KI7jdm0SAaggFj97RPz3s\nepQ8zl+jhzMVsIUGmj/hWaWK6iETziPxBIcIebK7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs47e8A96VLIJCUFNcbNgmBIH\nHRAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTZvF8UnEzIW0dutZK93VakgenQU25ROdaeXqK5Wmy1kCIGi2PKjTsbTL\noxI/uxVl43b0Rgx5TyH00bg6dC8b+89j\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfHu2wEawOjMPY9nc6C/9nRrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJjNGJiYmQtMzMyNC00ZWU3LTkzYmUtMGE4OTFiYmI0MWFhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTUzYTc1ZjEtOTAyYi00YzJkLWEzYWQtNjM0NWVhMWNm\nOWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnO3y1bm+ps+ldklBe3sUPdN5\nPZApxGQHYeKAYLjRVne+Eq0nUHYvANvUVVDpj7E0P4u4WJgIX6YUX3KQiP+gNqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUv7K9jSmR6y1l18HApwDJfcSlijMwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBxQhyqv5b4Sf3TidLErQpB/ctY/TCO\n6sKpuaYenH24pwIhAKp9ktTrILRlBVORX0SXZKYdpDxUrRW1L/SQAiQPjuU9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6724", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6724` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAfWgteZbKu/+rVStLby8qFJ/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5MDVlMTIwLTVlODctNGJjMC1hOTY3LTk0Y2E0ZDY5ZDY2MjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkyNTU3NTgtY2Y0\nOC00YWViLWEwMzUtYmNmOTQ4NzgxMGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbESjsDVKJ4dC2d+gOiK4mow3qsyE6QOqEzTQvx/Z9TyIWB4FLqhPVTTM/m71\nFtYE9SoGl9BjnuPef0niGJ6dLKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqLdF/qsX6DOns1uMCb5BzLMJhRowHwYDVR0j\nBBgwFoAUDhOnNdoGKq0ue9mqXEpKt1o69EgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCXq59Q3bjFxWSJRlK2P06VH7weqnmmrOgNJNn/7i6ZEQIhAP49iyEW\nYFdM9neUIY4EUk2hivoC0/6UflpGeF653kYc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYwxxMxn3aCy8UfHMOgo8FAPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTA1ZTEyMC01ZTg3LTRiYzAtYTk2Ny05NGNhNGQ2OWQ2NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUrOzXg7X/ieiNYOSQe0MOTIZZ3cMCPFXnBmiRYwVIuxRx\nt0N5Xb1zBTRapwys1u4Zm32cEk8qd6hryaJo4TaUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDhOnNdoGKq0ue9mqXEpKt1o6\n9EgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJrvJ+v2rDQhk6WJ5asnLHJSOYr+PraGdymQd4d9zRjXAiEA0OLuOF3E\npbRJSgcIHJfhZNeAVrCLot0h3sLh+vT7nlM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeUjciK2GjX/vqxz1Lfu9fmOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkyNTU3NTgtY2Y0OC00YWViLWEwMzUtYmNmOTQ4NzgxMGZhMB4XDTI2\nMDExOTE3MjU1MloXDTI3MDEyMTE3MjU1MlowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjYyNmIwMTUtZDQ5NC00MzhkLThiNWYtZjU0ZTBmYTMz\nNGM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKyrDjWyADv1j3f291aWAFHy+\nIcumivrS5Ynar1y8Nj1cUBFJCPrzl43M4YwZ0HK/KdYI//VyxPQPSYilXvLzKqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqLdF/qsX6DOns1uMCb5BzLMJhRowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiB4Cb62I8xxRsF0rIXzto6KyALxZyj9\nmf0u/Pbm4i3N7QIhALMJDUkBxYXJ8PuobPk9eWUEHrIgnTlKSzxZRTnRLdUk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:53+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6725", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6725` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAV9TlRAH4EbCkn8UMUNruV0bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4YjQ0MWYyLTYxNDctNDBhNi04NDY3LWE4YTBjYzkzMDE2YjAeFw0y\nNjAxMTkxNzI1NTJaFw0yNzAxMjExNzI1NTJaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWU5OTdjOTMtYTEz\nNC00ZWEwLThkNTAtYmM3NzBkZTQ2MGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw0rbEBMvB234rWLs9rN0guvBwXV51x6efarH+xWOVWl89mX5VoCZdaccuAga\n63nd0v+NDNK//1g7hsd0isN48aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo8wY9KDNzE/q3dLgOfT2sa2Lz+0wHwYDVR0j\nBBgwFoAUNBhFjGW0f3opr8/l3tXy0V+3YD4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGq4H+G4q2xpzXs/Ik5MMDwzEpYB4Zurmb6TCcwR\n0OMAAiEAi9wxEnofW6j6Rrj6sIKmU4EBTFmMJj3ZO+qmc1q3AJo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWcRHGAnL+PNG6XJC0F3xlWJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUyWhcNMjcwMTIxMTcyNTUyWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGI0NDFmMi02MTQ3LTQwYTYtODQ2Ny1hOGEwY2M5MzAxNmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNu8ezGIn1LiBF66ws+Mj7L8/V5QC4Gh93lVRyULaDA2Pm\nuwnhr8e3HZFfztDhXNONn/r+Mrb7P6hD6OPDC1iqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNBhFjGW0f3opr8/l3tXy0V+3\nYD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALgA2VXpWGChtpm7VsgFn+9YDvKXV6UAwRe7FFcuVLqXAiAe3vIBA5pB\nmfmp4g1N8eU6Y4IbrATCbOKbiJXuwwm0Rg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAb+hVX0nH9ktN3MHRURoxNgSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWU5OTdjOTMtYTEzNC00ZWEwLThkNTAtYmM3NzBkZTQ2MGM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDY4N2MzM2MtNGNiMC00YzkyLWI5MGItMzQ3MjVjNDZj\nNjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELJgJyPA1F6tMWHwjddB9iSE8\nqiTFgqWrB/muevdr+KU2t9VcrqmI5nzUVGrtDtsoK1jbYI4p4u6FbWEY2/hMt6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUo8wY9KDNzE/q3dLgOfT2sa2Lz+0wDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAl7RDcs1A16Cz2IchyhfnkJCO+y3R\nu8mnDX1KgrY+GvQCIHc3WSMhvuKaLvIakAFa9M4Zo4r0HtZfhxrElZvVyq73\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6726", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6726` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISATRoFnxQ9rvlPdPwU+cyiZiiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMDA1YTk1LTA1OTEtNDRkZC05YTFiLWFmM2E4OGVjNDNjNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBjMWU1N2QtZWE1\nNC00ZjE4LWEyY2ItZjBmM2ZkOTU1YWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcYyGpZ3r0mFb/7JowZtYaUfSNRMz/wPXpLEx7DmMEExLqZ6b9MTfymz01DuK\n8Z+ww1pN8h6pHAU9ztQ4VuRnhaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM5WpqbYkhv1+yZjAldW33nQIoyswHwYDVR0j\nBBgwFoAUY3TYLPi0e8jSDCnY+A7FIpHeQoowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIHddIYvBIjA8orNv6e428JoQL7HrYf/dUXOjsLJW\n9QkkAiBHX6TuLhvzB6oQAZwpQI5M1yAUeSDbFAyPVfvUtEikcA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY6nkFb7fSNuPSDmI0oRbJ2FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjAwNWE5NS0wNTkxLTQ0ZGQtOWExYi1hZjNhODhlYzQzYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASogsQRTxcLr9dVIH9cux71eMH1p1gKL86uHLZz/6HGOyr0\nXlxHR+FA4nYCD5D7/QdTn2bQPgr7hqF3mb/FMoLCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY3TYLPi0e8jSDCnY+A7FIpHe\nQoowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDrNsapbpanL+IUepnCm91oPd9eNAnZEMBd3ZiEttFqACIBY7SyjYLB5l\nW18PFJxydLAFDawhVEGT4awSodvyuHpT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbxUGG2xvW+MhSpZE6+kiz3XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBjMWU1N2QtZWE1NC00ZjE4LWEyY2ItZjBmM2ZkOTU1YWUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDM1NmU1YjYtOWQyMy00OGEwLTk4ZGEtN2I5MTc5OWIy\nOGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgP0L8DwkV4jE2JvGsEeT8SDn\n/g5rfhR/b6zGm+Z8AkwpdJUK0vRcl+bBkbzORR6srqRArSI+f1+tOLXmFzCs3aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUM5WpqbYkhv1+yZjAldW33nQIoyswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBzzy58isLMOPnnAEtr7ha60PKmPV21\nA3fIGfcMd3nvqQIgJ/ExIsTEoRfx/BBLslHFZU0IFNCRCMajpkOn98MOmj4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6727", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6727` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAbttR2PJUezsOObtXEPajgbyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ODcxMWRlLTA5OWEtNGM4OS1iMTNmLTBlOGI1ZWQwY2MwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBlNTBlZDktOTFj\nMi00ZmRkLTkyM2ItMGY5YTE1MWI0MGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6nbgxgGBVr8Sbt/g5a1muFkkp96SCVLfQ/buqT6J6BGigjE9m0KPWu0uO0PS\nQXCTK71mWdWU87XDjIOdObXi/qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhSjfzP7YtypQ3KkFquimK2iGuUkwHwYDVR0j\nBBgwFoAU1wkM83no5N44m2+1lDFN1f2Iu6QwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDFaqLnUZVsgFVUMMyeWHo4b/E2nrq30nvVEbkEGi3/cwIh\nAJbOZDjDN/KxIpRNC2/ysFoP6SinnzL3OJAUWvowFJjx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc/OvNRNcUdsmkRyUm0aj/QwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDg3MTFkZS0wOTlhLTRjODktYjEzZi0wZThiNWVkMGNjMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7y/14lOa6rqmTy2BkQJsHrZT2NWUJzYPbtlIzmazfwh2Z\nb7L0lH6QHYvBwzU/5ZS59G4GSrH4HlqazTruxrLGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1wkM83no5N44m2+1lDFN1f2I\nu6QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSdV3vFdni3pSa006XdrysGXQYJ7mLnm1RJFgPFqBFioCIQDPnjK7cWRR\nNe5ftHeqcsmzHODmy8eRoFOmXpLMNfaUhg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa8GYWRsnFuhZ0ATwN4lkbpIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBlNTBlZDktOTFjMi00ZmRkLTkyM2ItMGY5YTE1MWI0MGZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTlhOTFmZDctOTY1YS00MzlkLTgzYjUtYzI1ZDZmY2Fl\nZDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkg9xR3FW2Mc3arFB3Ar2A1Qc\nUWm2WNT0fBZtDlaPV4+02DlTs+XWVtF5eMY6j54bIaev+/MbTIlEaLArA/lIvqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhSjfzP7YtypQ3KkFquimK2iGuUkwDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBXbJh/wl0NOtAOKJTytLJNjDGnG3A8\npXy0muF5dWPAXwIhAKPIiOtF14AWaWmZHWDI2jP7sSRgck9Z8aVTnvs20pa7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6728", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6728` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAaEQpXhZlvy0zKadDCYfYer2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNjRjMmFlLTA0ZWEtNGYyMS1hMzU4LTQ4MmM0ZTdhMGVkOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM0ZjVkNDItNTg3\nZC00ZWYyLWI5ZWEtMWVjOWFlMjc3MTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEilnorv8dhu9d9zcbjtS/2QA+A4IRc1tD7S2fcf+RVCfarCIVSiinjb6svvAB\nG73Kr5O4RbvhwGarNT+0XRfvfaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMs/v858RDvLudvIOptI3FGVSWTowHwYDVR0j\nBBgwFoAU0cCFrzRrCaJD3wNtTZETaPj6es4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCID9YrQNuUiypy5EiTqPfK8fyfKw096gw\nV2H/Xk/9i6eBAiEA1Aj1r7Znq4ieKukU8nHd/yKRKdNN2lwBONP3DKM6NMQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATRkiZYghmLBVCe02/O+HSl4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjY0YzJhZS0wNGVhLTRmMjEtYTM1OC00ODJjNGU3YTBlZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWDtuGuRNCevfPQ2LdVsnaCIe8w6+y5M3IqoCELn6rYMOS\n4HiewguavEteRGJQvTUItxDMnZhO73pwn5Vy8I48o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0cCFrzRrCaJD3wNtTZETaPj6\nes4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaAo//nIWQ9pzFQ9iEi83Fg3R4wBbH84oAvJIbYVe//ECID8/JlhTju1n\nINOdt1qqWDCyvLVCDf0K5rBSQZct6aZ+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARzRR2MgGPSTU+hiin2cQXD8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM0ZjVkNDItNTg3ZC00ZWYyLWI5ZWEtMWVjOWFlMjc3MTM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWY1Mjg2ZjYtNWU5MS00MWZhLThiYjktMGVhZmI4YTU5\nODE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErgkXfxF1WAGsgRVue0KGKa06\nPHKRA2qH8DbzxYn0QMeIW7/WkxnE0s5htx+h74OKNwqkRpG/fy3PuhccgGGSTKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMs/v858RDvLudvIOptI3FGVSWTowDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA3RaSZ1jP4THuy0EmXX5qgwXyFXGp\nacltMQwYxwiyGG8CIQDLe2Gb2DOXyZ6/6LAb8vbDr7j7xjPbeGVSvMEdRfHrqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6729", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6729` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAb/rJUESkOEikfzOG/yAAktlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmMzIwM2VkLTQ3Y2ItNDUzYS04NWQ2LTVlY2Y1MmJhODc1ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcxOGE2YjgtZDZk\nZi00ZGM1LWI4YTYtOWFkZGRiMjI4MGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnuu6JMs7dUx/uwxDRYp4Tq9S6+prASiSr+TFqrjJzDBAnyvVG8omYc6sDJ8h\neEZW+T/W+fLR5qBH+sZ+TAERcaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUieGC75xbRK6FZ+SSjOXxXwhajwswHwYDVR0j\nBBgwFoAUaLpgemk+rHR7PkNaGLirOU3fzy0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDLVJTcuHslGut67A03M4cMdhvWGOTu\nAdVfwbCQbvQO4gIhAK5Fdn6MzjzpCoI2cQwD0LTpm4HkdQZVjIe11RJYJtC4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWlRptA43F6koSbGi/GHH7d2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjMyMDNlZC00N2NiLTQ1M2EtODVkNi01ZWNmNTJiYTg3NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP6gLgburG6exZDDEJdIBMs7tSd9719rsdvnPHPwi/UVVb\nK33f1U1YaY0Hf3CxH7jtapftcWJlo6KhBxYlvE1yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaLpgemk+rHR7PkNaGLirOU3f\nzy0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJuGpoEtk5yTRUDTq0qEG7XMbXQxf0lqBmtUHQdP05xGAiBGx0hInTbO\nrIF7AcNukSPzslv9thCmdG4ktjmCvwYi1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVSTSHq9XPPqZgbXMgI1MntvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcxOGE2YjgtZDZkZi00ZGM1LWI4YTYtOWFkZGRiMjI4MGNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQxMzI4ZjctMzMwOC00N2RiLWExMzktMDQ2Y2ZlNzg0\nY2MwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkwesTEPs8kIJ5+5DQaNRJRZ4\nHWODGJ/muM5CQgkqkFUQ9nh8FUtPt0jRm+GJcfFpz4h2NdATQJCOC/oaz8/cDKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUieGC75xbRK6FZ+SSjOXxXwhajwswDwYDVR0RBAgw\nBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBFlBgqD8NEsX/CDyytThdeN9x4ocls\n7N+Bh+j+BwxoAQIhAO90UwnCJT5aerGC1tkLRs2+gKC61w61roO5Y/ZCmMYd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6730", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6730` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQ5/T82+2s6FIM+mgQPkKVR9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmNWEzYWY3LWQwN2YtNDRiMi1hMTc4LWZhZjM0YjAzMzQwZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhjM2VhOWYtMjg5\nYy00NDY0LWJjZjQtNmY1ZmJlYTUyOTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKC5pg2Ujjd9b9/9XTdFf/mA8ydWpx68UjkOdQu7h2LVJX5Mg9NDU5mnXboly\nmLxxhI4wzhhn5SYqHJuHe86jJqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFCo9RQZLiPauNrqTf19MNzzqxqlMB8GA1UdIwQY\nMBaAFEnNHcY0XZZ8ndCb1YC6pfSNiEJxMAoGCCqGSM49BAMCA0gAMEUCIC/sjH6a\nvPu5q0WIoshhGwgvVf61KIVQheaQVgOK8PXOAiEA5fHtRlMA0Q0Tai3fTxSJK1Gl\nSZCEKgCyJ6hyD1Ivv1Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc6hvF0xDt646NqIew1UQjFyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjVhM2FmNy1kMDdmLTQ0YjItYTE3OC1mYWYzNGIwMzM0MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3axltZ2/rblQ5vxN1ouxQG+tKr+7BkQSxf+iwMqecFgsH\nn4WZ3jDiNo6MiHOV4gLgfjGD7kgN0KjfrtfBp79io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSc0dxjRdlnyd0JvVgLql9I2I\nQnEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL7H43jmPm9tzI2t+WDpmqZsUjLZZbCuwvnpJAumT+eSAiEAn23fDy2N\ndUp7FPxdw1eaNerDbgRotHFiq1eVWOpgy9k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZ+Y1gyKR9ZW/wIb61S2n/PdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhjM2VhOWYtMjg5Yy00NDY0LWJjZjQtNmY1ZmJlYTUyOTBhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTU2Zjg2MWUtOWI3ZS00YjBiLWE5MGEtNDIyZmI0YjFj\nMGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ4Xap51vOEoJcCKp5hYxoxgq\nzia0eqqh9mYf8JjJCkjwJR3u/I3qV+5Q8OsLHApxs/0sDMEYujuMra5F52TMLqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUKj1FBkuI9q42upN/X0w3POrGqUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA89OEZvylm/3PZOdyDSeJadw22VXsq\nMpVSLQUE2uI6eQIhANt374om530q78LwpgcE4gVHoKmZwX4LSMFsFFc+cZ2y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6731", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6731` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfo9HD6jk6CNmLqzXYWH9JyOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYzMzMGY0LTNmMjItNDFiNC1hYjIwLWI4NGFmZmMyZjkzMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWFkOTMxNDktYjZl\nOS00YzRlLWJmYzgtYThjOWQyZDQwNjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEwm8BeaOuMG5SE7od3BJmvgccvJXSxxzUqy/HJ3mMeiop/7Ob43I0Bsa1zjB\niXUHTXm+5b35B6h7RAcy6L7nS6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFE+TKn6f1Ih3Otxj3n11/J0LpAYxMB8GA1UdIwQY\nMBaAFH/r9FWR0bbkOUQsLT+J16nqexu7MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAybbxW8ZmAdUuR/2lvkxsgBXeL7XRXoc7\nb7T7YEpKugsCIE9gPRnpEfZXjiqiIdeegIomYkRJgnPcsIATUJzX1VA5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf+OB49PWNvy5ZtlkbbBu3ieMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2MzMzBmNC0zZjIyLTQxYjQtYWIyMC1iODRhZmZjMmY5MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQP+aIcHcp+s/jwEqhtUTp84YA+fKlMhfADZ3vnQasEABPO\nAetBzqhPVvJLf793kqumoa2R7Z7VM/VbaXYptOqTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf+v0VZHRtuQ5RCwtP4nXqep7\nG7swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbEFO/EAy36y98SgUrYnxSR+42v+r8rl8UwXeawd1/OYCIQCIvSCJ1WhX\ntKe2SEAFWCWUSsfMjwnWLkWmZ0NbzUZ1yw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdf8yDTid6HmA660CfhLrvI0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWFkOTMxNDktYjZlOS00YzRlLWJmYzgtYThjOWQyZDQwNjQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2QwY2JmNTEtODU2Mi00YzY2LWFhNzUtMWEwNDVkM2M5\nYzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY1wE4fDmufpSekNJ8kqESveL\nIlQPGWCriisyo1fFPKU3X4BElwdpaWcRkZd1GTRwR7UsFqvoshof1hGl1voIdaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT5Mqfp/UiHc63GPefXX8nQukBjEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA7Aug+8yd1peFgvGsUHcG99CVtcBXt\nhXCwU+M0O3i5qwIhANctwNWLtb3vHh8n13N3YkG3u0ohyTUbkVCs6u3f1buD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6732", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6732` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAep2aEncAN6mfzmGM6NzIwu6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1MTkyOTI1LWMwZmEtNDYxNS1iMDUwLWRjZTVlZWQzMjYwMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzUzYTE1ZmEtYjI0\nZi00OGQ3LWJlNWQtYTVmZjk1ZDlkZDBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESTZ+HbQAMMGlSh8I1keBZoJMoQyUar/MxlmKAxk/osNSawJLxQ7X0URGI9Tm\n6zr0r5UvT+3wqN+ZX3ScDV6BeaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNsJ1tQNH/itGCEIG+q4cAlAtNe1MB8GA1UdIwQY\nMBaAFAd9g1LNFsmlCYbJ6qqjeRHczUIXMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAtWRKhLmfNpvHFjS0MzEobOqRWAj92hkJ\nqsLewBV71pICIH3u6umR8eQeV8O0u9B+Tyw4XrnpQ9G5yXHtGpwx0VgY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaRh+SnS/BHYdLVIcp6UsYgRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTE5MjkyNS1jMGZhLTQ2MTUtYjA1MC1kY2U1ZWVkMzI2MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmucFnfjdzBK7Z4hzNKSLy7ND5QK065sE5rno4jh2RiRpJ\n0F2LvRsyHfCXOMV89vG/j2EUBoQo23fwo3oZJzFho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB32DUs0WyaUJhsnqqqN5EdzN\nQhcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcrtrF+erCH5NQIq4wuIndaVyUuLr3J8ZFKmWXbGqwsACIA4bsGuYH5f7\ngAwQU7z9JdbjFeFgE9oNuE9/Pv9i2ypo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQZy8Rt590aJn7UUbBkLpQIMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzUzYTE1ZmEtYjI0Zi00OGQ3LWJlNWQtYTVmZjk1ZDlkZDBlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDBjYTExYzUtZWI0MS00MmRjLThlZGMtMzZiZjk5Y2I5\nYjY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbfYcinZdxzu2VqL8wEi5L4i8\nEKuH633Ywl3LLprTSqZDMFADWZg5Wd84jUHYbgqMPAM5o/cHQk7JwW3XS2xxT6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2wnW1A0f+K0YIQgb6rhwCUC017UwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAhkB/xzvvfZq58HRUbWrr+HPlm9lG\nHEWz1es8WhFQJ1ECIA/WBQPd7FjpHzeALozqiscD0p5fwt7DzecRNOXonwAi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6733", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6733` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAU/htwZXkUaQWTY1sb7Rbw0DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzOTE5NTI1LWY5M2QtNDJlNi1iYmViLTkzOWQ5MzcyZmYyNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI1MTQ3YjAtN2Ex\nYi00ODJiLWI1MjYtNzZhMzA0OGUyMzA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5yySzqTbMsrXtKDkOTPryDfeqMyQueMDG2UE071E00IPUvMOnqhstPUiRkIB\nxrrp2z5sjDvVOdoU95hn/M8GraOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQSPKJFLizGkOqLx8vHTRjpFST//DAfBgNVHSME\nGDAWgBSXOR/B7JeJorcCGhh2FYXvCP49XTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC8KKVQZ/KZ8EbY9UGMEftnp5RgBB24\nsJSYk9WIIIXr6QIhAMKutCN9w814DqMR06D3SgwGOMxkEey1l41AQ+oMtaAl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf4kvG1loIuRFDUCc4Jz8MEiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzkxOTUyNS1mOTNkLTQyZTYtYmJlYi05MzlkOTM3MmZmMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCn36jKwyDpzIuZDNHx5xf2b/8enymXTgQPZ7NzzpWIywe\n3LJYB5bHXfODewGqLXq75bSPKhrevH1JAx59OU+lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlzkfweyXiaK3AhoYdhWF7wj+\nPV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP42PGjJI/muI+l89PUEz0atTS7sNGoZ/bFfxiGz3ArmAiEAk2R6/AkS\nJjsxjUanMfiwWi51M2ankuHb6+fgJUoT4yE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdqqv68qnLrIc2qDI/xwvhkaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI1MTQ3YjAtN2ExYi00ODJiLWI1MjYtNzZhMzA0OGUyMzA4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWU1MDdhNjUtMDIzYS00ZTRkLTgwNjMtYzgyMTg0MDRj\nZjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX4FHAzc2Sb7VNmaMzyZKetOY\nuO/UuMqlQsSCvRnZJIQ4tHD3sQztHcGdjHRN5tWxuUpkRCb0fI9rCCUwgvD2+KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEjyiRS4sxpDqi8fLx00Y6RUk//wwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAoImhSkDKJ9rU+spWc/lVYuyYX4CL\nPBjjTlryQ93Gy2oCIQChfqLkskVpMgswbj0ufE9F4SjOrl/9QPOWVG53vvSWHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6734", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6734` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAcT8RXrbAkbBQgrp/qwj877aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMzNhZmI4LTc5MTQtNDZiNy1hOTA5LWEzNTc2MGNmN2Q1ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFkZDRlYmUtMzU1\nMC00NGU4LWFhNWUtYjU0MjU1ZjcwMGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAwKeTrjF4YQB79YmyfZAiJwFSZ0gwgfd7A8OB+fsm1qO93kamI/LK+GPlfrY\nXXBJ74f9orSGyQQGT6Mg/jL4uKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZdrqJyXVmLMSxjc858ResxYT8sIwHwYDVR0j\nBBgwFoAUnp0B+HCC2bm59MBAqzpziLVWj3kwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBmvo41W/hB5opG\nXvw2aGm0Q6mozIO4Bmo2eltvT0E3IQIhANwSYLSw928aZm48Fef/08OgJXjrz2qi\nsaNHdcyCOGeC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAafM6mgAd1Kn3oJvVisiv8HCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTMzYWZiOC03OTE0LTQ2YjctYTkwOS1hMzU3NjBjZjdkNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEOdlxk+6+KDCJTowz+un+q2yFGDlZHIzpbYvT1ra6WiMp\nMx77NtQQXZ/mDfCeft61vI4+KePfqgFR9tbBVVw4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnp0B+HCC2bm59MBAqzpziLVW\nj3kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALJMrzwa3F8RbUgEOYGGYHaF2K2aX1i915+CBOBxyeHCAiEAhsWU8aw2\nSc/eCmmy2HpyvkpwZR/n79IZNX+y/ee7JGc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUPmSe9OV7ayDrO/Qg/TmgfeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFkZDRlYmUtMzU1MC00NGU4LWFhNWUtYjU0MjU1ZjcwMGU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDhiYmVkNDYtZWE4MC00ZmY5LWJhZDgtMzQzOTljZjQy\nYzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEPvmSoLG5Yo/A6JzP2oe+Kud\neEDkyht+4BymmcTFcLpb96jZDi3KBXikwMKwZ+Vya27z4We7sLu3RqA/1nMdNKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZdrqJyXVmLMSxjc858ResxYT8sIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA9tGJCmcSBr4CqEjVURp0gPGMz5/6\n0RNzaB1T55oUIW8CIH3BTX7478oQJ1+sH2u5ycjpNuo84g2/80wTIPHWM4Yf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6735", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6735` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAdY3y4qY7Q7FqHElNBtFjT84MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkZWRhOTExLWI0OTctNGYzMy05OWI1LWVlYzY4ZWJiYWUxNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQyYWYxMmEtZDA1\nOC00NDBiLWI1MjMtZTJkYjRkYmM3OGEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4uHhwiDj92fbkAaFSV9kuQMEThQHdFymLEG4qB6gsPCf20DJ6FttZ8nD1brs\n1NX3hjHRZGVMRjQjLrK/ckNYqKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/NmPj/THox3TxWzWGLJcKt7w0WswHwYDVR0j\nBBgwFoAUq6qUb5wbM0Aw9vx27JPBJdhGyScwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAujIfGVW9Mb0+\nnW5XkyPksLT+WDgnCHbs4NJ2E2m81MwCIEXsav8dGKiUCEhnI/qVN1iXgU0NDdE/\nm6TYUtKK1d3V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAchJmL3tQFUbDJOmhFPep/6/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZGVkYTkxMS1iNDk3LTRmMzMtOTliNS1lZWM2OGViYmFlMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1njfJc8idv1Q9Bjuc73MJB/Ekppuw4/MTLmKpvlkoG38b\nFsBs3PedeWpS0+i/ym6mkgEqM96hD4DKopVE4KkLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq6qUb5wbM0Aw9vx27JPBJdhG\nyScwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMNDbeSITY/CaipwTTAr8UqJh8Iiol3a4pGhsNQZhAarAiAfL7c4o1+p\noSb3fUby++QmuOQl2rgdugfTGgvgf70FBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISASgHgG5Uq3SXVV+BEVLgsD51MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQyYWYxMmEtZDA1OC00NDBiLWI1MjMtZTJkYjRkYmM3OGEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWMzYWRhNzgtNTNlMi00OGM3LWE5ZjYtNGYwZWUzOWNh\nZTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDT1Vl1VV6pKei63cSmKGinre\nh2Pj3Jc416idOsEVg/BYn2Zz6FvJcEl21/wuW1jbQ5Ika4Lm7hGLKBhxzYPsT6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/NmPj/THox3TxWzWGLJcKt7w0WswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAq6FWdQWpQYPTc2hh3AXFvzEPmUff\nKOtco8EQLPrRviICIQCHwtyDzWvLl0VTkk8HTiUp03TxLwa6U9af2AlJopUqMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6736", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6736` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAWj9yHyksckEBJFtjIt8YV5MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiNWFmMGM3LTllYzMtNDBhNy1iMzE5LWRkY2ViZjg0ZmJkZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTgyYjBkMmItMTY1\nOS00MWFkLThmYTUtY2I5ZDlkNWU1YjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcuzaPRfu+5i1vqvuZ+5/HXJIDI3+PDIkYPcLEbWeVJBP3aQU8cTT0Vwn7mJi\nRLXwRr04VdVP+eU33INxVb7/oKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBFSW1gd3cKs5Xt9mIGYNMlpNvIQwHwYDVR0j\nBBgwFoAUCmbGbo+q80V6TDbzcf10TIJtdcYwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAxcLw3ZynKXS74snxVq5b\n1sRH41n8uomPwhajK+HlbHECIDkVh17hvtvwc5U2epLoreizGscTGw/bNnYb3G0r\nR2jq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQFP8mmPgyr0XGS6lbm+PpRhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjVhZjBjNy05ZWMzLTQwYTctYjMxOS1kZGNlYmY4NGZiZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASusw273/c8wcJ2GbgP0hd8GixyWnV1+oYIR9G/ahL+qbU4\nJS6Qz5f1P1Kl+nrFivJ883GmFN4AIJ6wAb9MD6Ldo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCmbGbo+q80V6TDbzcf10TIJt\ndcYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLOTh/LQGsWEjRkqBm4PMeOXPz5sVLyCyciQuSIAcex4CIQCaSt+NASWU\nN59UmaiZPVFk/al/CBLHFsHNiaEnJ2qGTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcHIamQG2sk2m2wB+rGtdxYeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTgyYjBkMmItMTY1OS00MWFkLThmYTUtY2I5ZDlkNWU1YjgxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGZjYWU0Y2ItMmQ5Yi00OWZlLThlNDEtN2IyM2Y3N2Nj\nMjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVhc4vleVN+/9vCT52MpsO1V/\nphQTqzzAG27WE3++XVFNpmPOoHIN+MVVXmHk72gLA5snDTkepsVf7TbZUIjb26Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBFSW1gd3cKs5Xt9mIGYNMlpNvIQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAuAjfemQb/FTcImL5lsld8vdWTbB+\n1udmQ8a/SmCzx9UCID3RfK7X9u0sCapi92bT9ml/Yv5LDnhhQZVE5cwda6/R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6737", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6737` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAQoZ0eELBLCn4T9X/E7+c2RNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4NjVhYThlLTFhNTktNDUyOS1hNjJmLTFkNzVlNjViN2JlMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUwZjBkNDItMWUz\nMS00NjE5LTllZGYtZDE2MTExZGMyMGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5iVMaV9+w/VhBN9Z2vLXZHZsl493GwDVLc1tJtfB83swGHglqgJSlsbl+lWC\n6/BeUiZto9ZwU8ba9kYWZ78IdaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlT+zpDmNVN15S3X9HITxf3iA2EswHwYDVR0j\nBBgwFoAUnNkbIjuvbD1dJPTsBhHHr4TMXCgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAw6wX\nTR1AweAhhcSc4n+AbWqgPFqi1Hr7GbboA6BPKTMCICLIPBgV1IX+RAlkR49fX6+l\nDRbgu9kU0fStkRo7Hv6o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAePrRKA4OfbqaLrOqb2b2u6SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODY1YWE4ZS0xYTU5LTQ1MjktYTYyZi0xZDc1ZTY1YjdiZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBjlaZhGAfo8aAOnKxL05RBcFneRCSX4aRwSbVbjYG2KeL\ndVcByZPPwfWHWb8c9TyhnwDMDzYmWLLh3/WSDaPBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnNkbIjuvbD1dJPTsBhHHr4TM\nXCgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQzZFE8YW6cI04IyM/GYQtCIoGYTg5sLBOCgEvjC11OgCIFhcPvTzxGms\n9PO1SWU0sxjmXDjQmiLuY18mqTFj1mRl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQBIqo6itiApr+V/+D29fOqvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUwZjBkNDItMWUzMS00NjE5LTllZGYtZDE2MTExZGMyMGFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGVjOWQ0OGEtMWYyZi00NDg4LThhZjgtNTNjOTRhMGEz\nNDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEq12/IBxo8CDoXQYIoBePB84h\nx2MCULnt90fk07wXo8WoUuaz5qPHp/gqqYH6sS4WBrTMB55IgHEMCn3HcgWVTaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlT+zpDmNVN15S3X9HITxf3iA2EswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAXFoGCcMALAF7LbB5mZ2m1LhUGVEaG\n5ZdyLrs1LNrugAIgYMaAWF7BhYLCZJZ1lX6U3V57E14eeHOrUo5i5iRzOHg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6738", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6738` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISARS75kVpFAUpbYUj696HBlpIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMjNkZDdhLTU4ODktNGJmMi1hODgyLTU3ODJhYzRkYjQxMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRjZTA3OTMtMDJl\nYy00M2RmLWE4YWUtZDgwYmI3ODEzMjVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESgNGXOksM9qLD5umPBQTzZZLJIGQb8oDoCLSwpqQje1/0+2ed8wrzYcCPSgH\nt//4t0Slp5CduqT/w8IvJNig0aOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2oTwHIGzd4HbJO9l93eAqbKgX7IwHwYDVR0j\nBBgwFoAU4qIV7SihqbWYJyEkriZiRNzGuUkwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA7V/4\nCPCtG9ZKRk6sxZg5vh2u86yH4gkYsA2QYOvQet8CIBrenadP2lZNYaHInVVFR9f1\nAXKIQEVPBlhM4tdI0vun\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATp76ZCAH1VXkqOeaozAJckNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjIzZGQ3YS01ODg5LTRiZjItYTg4Mi01NzgyYWM0ZGI0MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3hM7S9p8llK6v/F0HUJrR1o5s2hsfztaT141NePboG+PT\nETqp8UoLVMJbk8mZ+wFpN7vL3/k8t1fiC17xF9FRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4qIV7SihqbWYJyEkriZiRNzG\nuUkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKJNczHBJ20ISEnP7tJ6jPzKTIj37b2tqQasJjSfsm6cAiEA8Wkkflyw\naXXFc9VEJf0pXcGsLBO+Xm8jd4/U/FiZ3Iw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAawuziRekTc8m98kZgJs74XCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRjZTA3OTMtMDJlYy00M2RmLWE4YWUtZDgwYmI3ODEzMjVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjgyNmQ4ZGUtNmMzMi00YTliLWEyZWItZDRiNjY4ODcw\nYmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEW8UC8kW94yavaqzfT/83khHc\nhjCg443Bd9agtqTvZhnZKjJyKKNlgqn+OoNNX7TmX59X1ezVkBTQM7HO/rj8CKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2oTwHIGzd4HbJO9l93eAqbKgX7IwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEArfK9BMIjBjUHSzWAcHLf+CCNtYEG\ncWCZ5m3bzkWmPdQCIQC2hcMgOx1emd8oVl4wFlMgHZMca10MGQ0tfx27ermX4Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6739", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6739` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUiyK1zFl/gGwklN7PvyDpXQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2ODdmNjBjLTM5MTItNDEyZS04OWRiLTZjNjM3Y2NkYmI4OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I0YzQ5ODItNjc2\nYS00YjU5LTgzZDMtYWE2NmQ5NjQ2MmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoGnYdf6Kmz48/Va8mw17WXqIl5aA2iBBK/N6Cjg3mmSC/LC1sEe3+6PRyE5n\nkX4Ci9pSdoNin4OqbZypIPb7/qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFP1yOv4N8jbaBB0ewV5qYLanassxMB8GA1UdIwQY\nMBaAFO1o4OqBUg5ge2H3OTcNYEl2STSlMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAPsJWpbUoszHZkCU6RdfgfCI/6x6YHwa7n\nLe7cbcwBsgIhAKqVY4Pfs/UxsEO99N/g5wj8KTiNGtWgkC4HlndNjeGp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbsTmS7TDqmHA92YIKx85PFhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjg3ZjYwYy0zOTEyLTQxMmUtODlkYi02YzYzN2NjZGJiODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATszhw+H/tk3q8WkCsX3ZusNgLY4m840xjj1GIwD7ZYrOST\nkGNsrINsnHpRQXjooQipua0b42mQ+AEz2iZOW4EPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Wjg6oFSDmB7Yfc5Nw1gSXZJ\nNKUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMh3FWgjLcVSqsfC3RKotX4jnBTNWp5bvvAH+tdX9qn4AiEAm1kRXvQY\n95fI4Xubz+8aXTOT+lecwvlz9k4+5AkODvU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASgq9MOfebg387wO/mMO/kPMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I0YzQ5ODItNjc2YS00YjU5LTgzZDMtYWE2NmQ5NjQ2MmU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmU1ODhlODgtYTFiNS00N2EzLTkzMGItYjhlOWMyMmYy\nOWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkvpyLgNW8+rFleFf08e36fco\naHsZWSkKRb9xGzqbQ+L36H4f3ALM9ZCgHN+S9v0umH4CcxTwUSo7pf/rrXl14aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/XI6/g3yNtoEHR7BXmpgtqdqyzEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiATh3N10Y0fVELMNsGsAAra4tKKM+GS\nN8HznewsHtJ7WgIgc3K/fA5ZWzIB/cxACsdPHwX8+Cw13/Y81SZEw1kkjys=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6740", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6740` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAcscrXwk8YikBhxLL92DvibkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMTkyNjZjLWViNzktNDI1ZS04MmQ5LTc0MGFmZTk3ZDE4ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA0NmY4MTMtMGI3\nOC00ZTllLWJhYjYtMDliMzZhZjcxMjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeKHn0VyvulwFXwcwhd0K4kONhmvn7KcakqBRxP1HJ6/ttitOwT7NhzS2nBTF\n54KvNmTV++bKmxjzGutK9HWX1aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUphjzStb+sH4Jenoo05sl9FJq5SowHwYDVR0j\nBBgwFoAU9CduW7SDAOeXzoFgyi5qibw/r6wwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAL5D87Fsq5+A\nx+OZO5F5lLbldxUDoOWeLiR9GxMNA/z+AiA6AIj9PtVcP66cJ1eVQnJHN2Z6ZwlJ\nKCrgOvmJc9oqGQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARzaRbhrvVkTFNc7maTb6UXYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTE5MjY2Yy1lYjc5LTQyNWUtODJkOS03NDBhZmU5N2QxODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmaClHiTIeJl1GRhjyRwjKziHlbl4eVsEyvnglQ7har5cr\np4D9aF5zHUaftXQtn8wVLTdgv7NtHtAOBkVophO+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9CduW7SDAOeXzoFgyi5qibw/\nr6wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBSlPv0ueuZ6XvVqIm0k6aXNt2DaZajDIlsSfFriDLFUCIE2UN6HFfMWJ\no1iMu+rf3V29OkMhQTPBbgnCyhYbR2wS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZgYo5jJSwnoGSeU8d7hI6HEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA0NmY4MTMtMGI3OC00ZTllLWJhYjYtMDliMzZhZjcxMjU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjIzMmUxYzYtNjkwZS00MjcxLWI2N2EtMmRiNDQ1YmY3\nZGI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2Yn3W27mbjsuXzUT6U1IznM4\nom8Z7w1OTHxpUdBOVrANXUQJQgToX7uieHsT+t+hFUtTPA5Dqid7F7K6ULsCLaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUphjzStb+sH4Jenoo05sl9FJq5SowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAWDO0L+0mYUCfMUHpwt+DGEnnlh5iB\n8IvUMl+NX0amQgIhAOU64ElYz+MEYZnNJZeqyyAHUum/4kbHtz279Ry0qarL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6741", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6741` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbcfjDQC4cCUPyz/6UYsV+I7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwMTAyZmE2LTljOTAtNDVlOS1iODY2LTVmNzgwZjBiZWZjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYxOTQ4OTctZmYw\nYi00NmQ5LTg2OTItMzkxZDJjMGJhMDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfoDYwPKlrjfKvOA+UFeLFeA0HW3m3TubblmTeV5ifiC944UlC9Xl91CdjMPC\nF+XzEtfdoIgTFMQtg/j8QlCbIKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU07olXlTkYRGatOluDtMc8dosTFowHwYDVR0j\nBBgwFoAU2VMf4pRTkWNSmOGku8JdulBzHQswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPmodVyT3vAK\nJNLBOmRU9InncckIygT7unxAUHpVOo2vAiAipDnDValV/XX4ZFBoJjhYwtZI8xX/\nk6/Ap04vB2DSYA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARBBK8iTmIBRiAXCq6LHqvetMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDEwMmZhNi05YzkwLTQ1ZTktYjg2Ni01Zjc4MGYwYmVmYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSU+MaUaibIoJmiH0EEoLSv7aDHKbgyWYppgvVVKyaGUJF\nVFlcrmNn2YIxo8X/bt069mDXJ4PV5c50gPN6Ur6Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2VMf4pRTkWNSmOGku8JdulBz\nHQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPIFZ1WvzUE/Vkk0iMvFyxzp+Uym0APPI8jpXVJXqsf2AiAt1gajYwgk\nHiT5g1Ljhdti823ggiEkM6xLnj73P9zg2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARs8eqT3OJ04hJZ4Q93D50jiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYxOTQ4OTctZmYwYi00NmQ5LTg2OTItMzkxZDJjMGJhMDQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTdhMDZiMDYtNzY0Ni00NTBhLWE0MTQtNDAzOGY5MWFl\nZmU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOL70HHwBAYW7XfNJVlcrZ1IT\nHsniB5WKZXv0E+2Diz/61+N7VZHAIAxqpw93QuSyKeiDGWgEQjEubig8XoBAF6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU07olXlTkYRGatOluDtMc8dosTFowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBipl0Jylms0+OAybMqoXW8bfzQkuje\noPEPQQoTy0P64gIgcuTKNPYJCrFeNYWXwd+ARxZbVvOzy4JMY1pmbYGgws0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6742", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6742` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXeAQWW+CyVCb3Qr+QBhzZSvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0YjU0ODg0LTdjYzgtNDYyOS1iYzVmLWY5YjAwNGFmNmJkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU5ZTI0ZmEtNDVj\nZS00YWU2LThiZjYtYjQ0MGZiMzUzZTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtH4hU+HJ6RhLjkZiJ4SPPFjJ9yZzcRO5lv4Ev4wk68fz6dcmAbEjNV8dAAzs\nqmlohYwJoRXjpq7Rfs/zAvuX96OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1w3hRsXL0SOqclqIfbKFFRiOg5EwHwYDVR0j\nBBgwFoAUEqCULVC79j3dudEdzPxfcPVT2OYwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGcg4D5zatsI\nyBjbakv2H54Vh1pBLq6ZYGvYcs0+n6/1AiEA0u1cCg7JP/SrmrJS+BGpAOXX5WzM\nNe3niPSjeW6ezxg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYnCncv8CPqyeg2zcQ+HwRvoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGI1NDg4NC03Y2M4LTQ2MjktYmM1Zi1mOWIwMDRhZjZiZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9UmbcoBV4ViT5+bdsAgXxFExGOcv0qigRiXjn6HSHtGW/\n1/HPg1xNRHSeeB05HyDPM90ezHEFRpJfVVXRM6Ugo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEqCULVC79j3dudEdzPxfcPVT\n2OYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXFhe8GNKNFAD9VxxsnDu902qnvgdPO3jaXW9cF+k1BACIHUmbIFDRszR\nCqvdCjwq+zKFwUjpx9Vbk5k+t+jhSpEX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAS9hwjsOm4da/jo+Al1idhl9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU5ZTI0ZmEtNDVjZS00YWU2LThiZjYtYjQ0MGZiMzUzZTUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmExYmU2M2UtNTRlNi00MTFhLWI0NzgtYTllOGNiMGRk\nYmRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/WNJmEoASI+4WMTL5Sd7gxIZ\np3yk+/uGuCczJrXXWUT1nKTm2Ny4LgG/KXNdorwraYIpustGZKjM83okHzk7LaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1w3hRsXL0SOqclqIfbKFFRiOg5EwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA3v7cTyAKYchduH65VlaSSMu9tJa6\nMSukyeomd6vJi3wCIB5TkW8+ReCj6JGyFAJBe0OvpqCZbIkED5UsQ7+fVUTN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6743", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6743` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATz0EXwqpRYlyJGXvwHDsmnNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYmM2YTNjLTNmMTAtNDdlNS05MDhlLTliM2U0YjMzZTdiNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFkZjQ5NDQtYWFh\nMy00OTcyLWE1YmUtMWNjZDk2NjRkNjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDtMe/hwFUjpnf2xJxn/CK/apfGJTtDMZ6Sl8mhW2RyBDcJd4P0D7FkY/RPor\nEB9VyI04JyH5Xy9dAlxcawpro6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkyEO4ekEecRtbOcb4SIJcmfmArAwHwYDVR0j\nBBgwFoAUxC492fv4oIQuL/TwoXwvxlUBoNEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFMzdMdrcV/uYQ50XOaan+gJiMyX2NJbOWg6YKpKxMDeAiEA//So2Vkb4smB\n5qiX5iiZn8+ruYbNJt/A6KfuHpbRFBE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV6EYVN0Pa8qIDMxP9M61ZPkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2JjNmEzYy0zZjEwLTQ3ZTUtOTA4ZS05YjNlNGIzM2U3YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATop8deCkjARjmM7Gckwvduxk3PPS/nr5lk2kzIXAr20GzA\nChv8Ro9ZWN542LMcx3UYoh59JF5SYC9tSJ67jv+jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxC492fv4oIQuL/TwoXwvxlUB\noNEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJkm+GyeJxeiJoqLjgKUM5AdVkcs6wB5Pcfa8ABpU+VMCIGkU9YHQfIoZ\nx4DTeYyozgR5oo45K8q9C9qCEIEXVrxt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfw1BcFtLiL6LLJg3I4uyIXZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFkZjQ5NDQtYWFhMy00OTcyLWE1YmUtMWNjZDk2NjRkNjk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGMxOTcxMzctMjI3YS00MTk1LWI4YzctMjc0ODY4MzNi\nOWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbr4wWGn6qvhMLUgYwMBMWo7/\ndlRM/+pJwqHbGbZM9T9aYOtnPfmumjMc4VLlGoLtI+tuASV4tVGLIyC55LCjL6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkyEO4ekEecRtbOcb4SIJcmfmArAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEArutdr8kC64yTv16D8GEvVqChK3U6\n5aWCP07r5vWTfysCICCPdKk0s7a1Bsx8saLAB+EQkdSZdnDYXO7I6GmiYDzV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6744", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6744` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASgZ4CA4Yw4WWjAOdNJsf6TSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlYjZlYTFhLTU4MWItNGQ1Ny04ZWM5LTlhMjllMzA0ZTRjODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGEyZjljYzYtY2Ew\nNS00ZGU5LThkYjUtZmYzZDU5ZjM4ZDlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmVKfuFDIHwHBznPA/eCDP7eDoNj/PceiANS/hOjPSsviTY5PBgYUMAgd9bwy\nm4ZHnO4U89OgjTk560kXSGJHlqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNlG2T/usQpJD5uecaLBTfmRunFUwHwYDVR0j\nBBgwFoAUonjh1stjRmiBEKHYP5CiDKfcEqkwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAoPH0wBQnMts9CYEK6pOCStb9HtnFw7kSp3KLfwF3mCAiEAhofdj3ekgx/W\n0oIBv9q6FZuarsLFVW0eSs9t4T7Ge/c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATo5xD8MeQdM+OoU0KVwGgclMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWI2ZWExYS01ODFiLTRkNTctOGVjOS05YTI5ZTMwNGU0YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARB6e9iWZLjKJ1msIaXkC2sMTkWyk6DytHQAXBRw2rvAXKj\nnJN1YIPJojADFHyVvdCXuQ6fsNbCIvB4NS5OKfOco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUonjh1stjRmiBEKHYP5CiDKfc\nEqkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgezkZRCmh2nl9HyO/9SamrxS1vMQTrpLgI9ZRvJXZicQCIQDY/sunQT5v\ndyGgFz06kTpp1XQ4q9E2HrrbFgJlrHKwJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZ52mkmaqcvhpb+ck1kn9blBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGEyZjljYzYtY2EwNS00ZGU5LThkYjUtZmYzZDU5ZjM4ZDlmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODBlNmNhNDctMDY3OC00OTExLWFmMGEtYjNlMmM0ODYw\nYjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+OT/S6FnGoSYh3hCTvXrrjWF\nVMOxhHLJM/hU9oZWzcG7RCvxARQwuJb9qIfBxC0WyWi34byOzHY4iklMCOBLmaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNlG2T/usQpJD5uecaLBTfmRunFUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBAGMUtZUKUp3DwGAA+g/YqzE/PXZoC\nto2CRxQay+mydgIgfMqQcHBa/52Ro4rSMRENYfwxbp9qq652pc587lTSKJY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6745", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6745` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAUeHbbvitMxsID3+1ULxuZ5vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ZGY2NmFiLTM4ZjItNDRkMy05OWNiLWUwMmQyNjE0MmMyNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg0MjFmYzAtYzk0\nMi00YTY4LWIzNGUtNGIxYTVhZjBkNGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg2sDBnkP+haADs28rZ5r3KwQrMdOSkuCrFAIHYNrOjcP13lpzxy35HUTMnBt\nKz0G0dUPy9jszKvA+Y0XA2h6OaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfFbsnjHPJ9NANpxWYiHQi1KYqhIwHwYDVR0j\nBBgwFoAUtGTEIyqkAXHYyy2lPdxa2Iaaio8wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDW\nVzeETRTrOM1H2FhUEjfUst407ytaasyA6uFU9rFVMgIhAKe/F77Nk7CE03mi6xkS\nSJmfRditVn+72Gj0rbZoVGgW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe/Dc+zxLWgbCr9Nzk2MLLTIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWRmNjZhYi0zOGYyLTQ0ZDMtOTljYi1lMDJkMjYxNDJjMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR78UtlluaOQ0dZi/9xw5p7dAIE78zmoRruC2xsX9hYe0KT\n19Y4oWXtYLOe9dP436/nQnDgGIEuQIjrJ0lp85/Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtGTEIyqkAXHYyy2lPdxa2Iaa\nio8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIj1kwZQZSt3TFJ1tOtfGLSqHIdjnd30H/gcLF8n+unIAiAiaIFT/dXi\nn0kMiLrwKIQzE6/EPtM1hjMe7cQiN8sIRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAThE8p9t09qhRGxYCQPRzWlYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg0MjFmYzAtYzk0Mi00YTY4LWIzNGUtNGIxYTVhZjBkNGU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjE5ZmQ1YTEtNGU2Ny00ODc3LThmNzEtY2NmMDRlMGEy\nM2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcd3433f07BJwzWXhaFUJWijG\nlA+NfyCKdkEhnPE9OExamrSf8vy7cNxWOgkr0f1MW5nzrXZNyy5dz6v3z8tUEaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfFbsnjHPJ9NANpxWYiHQi1KYqhIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiB+fRoPNEephgQWVBMezNDBpb+C/K2z\nE7D0qAJSmiRO3gIhAMuuLXRJSm2bKnH6HcQ/CtkmRTVb6kV8h49OktD7KnzA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6746", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6746` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISARe3VEhjbUUV/o6GDMsD/q7xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlYzgxY2JhLTk1ZWEtNDVkOC1hMjMxLTNjZDQ4YjkxM2U3YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FjZTNhMTktNTgy\nMy00YjAyLThiODUtZmRkMWY4NzA2YjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoE+Rg5xfpFz5dw4DrQ+YZ84vmeYiaS3buIMwqjjkWYtTvnAtr5kBG7XlfWug\nRlOb0RLcfgp8oZy0ks/KBn61uaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc238wQDd2NZdZgQfaIpX7K1Jz0YwHwYDVR0j\nBBgwFoAUWpwsMEG7/U7XJO9mbAMQI+2cGpkwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGWZ6laq/yJLXZFuS1YH1lbP0XNNvH2XdnlzAfh1tBpbAiAWXTSC\nl8X2TmZkJlWc0HFZOnwAcZiKHG3OSy2NSoDPCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfOGyTNLXPVeNf5G+hidvhbyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWM4MWNiYS05NWVhLTQ1ZDgtYTIzMS0zY2Q0OGI5MTNlN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkiy6sJQgs3hAg3vUntnC42hO87Jm2cGFXDa6wn/vmd0cx\nECZwd4DFwss6XdA2AzSZVW9iafWd3vdeJ7/Vi/Wjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWpwsMEG7/U7XJO9mbAMQI+2c\nGpkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPP3gxO7KD6cRYI5p7BrIWHYOp+YBEShmyDEpWrol9gMAiEA6gg4AptG\nmFKwJyLvWWZdrys5O5lV7vTWBvPZCRb0vn8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXBNcBG1wEB0tKXGTTrnxEoGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FjZTNhMTktNTgyMy00YjAyLThiODUtZmRkMWY4NzA2YjkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDA4MmMzZmMtYjNjMi00YmRjLWFlODQtNWE0ZDAyOTRj\nMTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErMmA/krC8aA1SZ4om3AN8AY4\ngk+40qBjpSrP70RZoYXelxuc602xJrl1drSTw234T1UUBVEIsyQlGPokXn3mrqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUc238wQDd2NZdZgQfaIpX7K1Jz0YwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAVhgDNapK5u1NlBwF7U6ze0ePwcqEl\nUXN3ceC6UwPblAIhANer4ZcU51SpkTljndJZbmJIC6wJMSyeem85SqARdPgg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6747", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6747` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISASg4aq/MMNOosSkH2b3a/O8eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5OWZhYjcxLTZhMmItNDU3ZS04ZGVmLTUzNDRmNGQxMGJlYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNjN2UxZDctOWI0\nMC00ZDg5LTkyMWUtMzMwOTBhMjZhYTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn913QnStUkQcW3fm41RJE7RsNA5pSThz0H+zv0f6yVKwfPz3mCZRIprhrPj9\nWHSeg+F0cfUer44pf1wdFmSD2qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCQh2Y53gURvbqIKJkXqwMHZsBakwHwYDVR0j\nBBgwFoAUEe9CuNfKXGfdT3PIkxK0cPb6C8owOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIAy5/WQOFW8Ur3lcDb5eeGged1/jfJytTa00WZFOrOdUAiEAl1Ib\nFd5JK7tKDAtuWQGkyeLRkovNrpnCQDfgMWix5Mw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWanlP1jzJNgbbJgkxuINSKDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTlmYWI3MS02YTJiLTQ1N2UtOGRlZi01MzQ0ZjRkMTBiZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2fyZAGsramYULyxZWPqoWvVicxOlDO3WJI+x0doNuTHM6\nUwUP7cVZlHQy7iOAkyNcVbUdQC2ZFq1HTUfp8Us6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEe9CuNfKXGfdT3PIkxK0cPb6\nC8owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMZLQKQrbvZRWBymbgo5ZYvEjNuAruZSC8eYsdxcyyvwCIEiMxIIQHeqM\nSPnnw7FsoMi/1vp2bvMiKRpS3MfCzBya\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQMq9/dmTMJc182KCZR4asF7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNjN2UxZDctOWI0MC00ZDg5LTkyMWUtMzMwOTBhMjZhYTg1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQyNjVlZjUtZTg0Mi00MGU5LTljZTUtOTY4ZmExMjk4\nNDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtuYL3GwVbfzOQfkcy4M8uq/o\nQulnfQRWvmdNzs0GgVej2iSOrGjoATelAnNryyAss67WT57Js0kf2L3Yn9uTS6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCQh2Y53gURvbqIKJkXqwMHZsBakwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAu3M6lC50kkkA2KmwFNz2a1BTtaTO\ns30EKnMWOh+oxIQCIBOuHQJ7cLrRWAD1CUdfovz8wk3L55ylnKmZkmgaXDjr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6748", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6748` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcDUn2c7MQ+fP6GeUveDjzbuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MDI2YmZhLTQzY2MtNDE4Zi05MGY3LTRlOWRjNWFlNzg0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk5YzA3ODYtNzZk\nMC00ZTA1LWE2YjAtYjUwYmM5Njc5YzJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzwXktfspHehmS+XXhHQ49khC1Ub6JLIxr3kv2fC5OMNHifpg3KAY3M+F3LMj\nX/8ieutdN8kBJM9/wPGhErLnpKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNNkDZkk+TcliXCyFUuYA1iFWnwbMB8GA1UdIwQY\nMBaAFKthl5heIIj9cmcdYrdRMAnjGJlUMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEArD+xET4RiX9axeqPXzcdJI4ERzIADJQ2\nehi3IA5+XWkCIGVxJG8BuFra8l+AUHxHpJOCL9tUlknTlaraXXaDTkV8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXCyAbvHs13YbYhYd6xtnl7DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzAyNmJmYS00M2NjLTQxOGYtOTBmNy00ZTlkYzVhZTc4NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASk+cRu3l5x59LQe7LPsUWTDdhlXS3t4Z7s+xP0oRGxzlsk\nIorw8PRWcoYgwjiRhIR3weB0BfetNpz8/sAQjLXko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq2GXmF4giP1yZx1it1EwCeMY\nmVQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgL+zGwiWGdVpDby490TjZGE2yy1iXNRU36+cZGbjRwxQCIQC5sWy0zDX5\nzUCoXXk9gF2Gg8oylzpfraUx7R0OkAaCjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAd8+dJAjqvoOwZzhvKupqYUzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk5YzA3ODYtNzZkMC00ZTA1LWE2YjAtYjUwYmM5Njc5YzJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQ1OTIyNjUtOGRiZS00NmQzLWE1NjktYjdjNDdkYWM0\nNjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdjakA9EHeEZ/3CpjO4ucgEhO\nIftMUWSG+Xeyv9MZFbgMv8H5zK5cIDr6QYj90ZvJpqUwsJuEFtCKlBWpJg+RyaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU02QNmST5NyWJcLIVS5gDWIVafBswDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAf40Kum26lfmQ2GU9VUIPWpAWh2khh\nDBHyUTQowjFB3wIhALs7ST5OlPR2L8fqmuyROrnlZtefnF9wPSPoNPDxW1Be\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6749", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6749` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAXgu7SFWmcQHg5sKtCxUUGaUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjODcxMmRkLWMxZGUtNDMzMy04NTU4LWI1NzA3N2VmNTljNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNmN2U1ZWYtM2M5\nMi00NTdmLWIzOWItNjEyMGExOTczYmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEocPZQ1Nh7fPUNR9bKUsAs+bgtd0y0pAkXl26Eiq5roUWTqzMvdAkwLPULi1R\nrh28dw3rKAMXm4EB82oXajRxhaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFny72XP84NKCTFdD2MMu/YU8ecwwHwYDVR0j\nBBgwFoAUVPLrPhx8xUYEsEgKbH1cIVnubqcwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMcnKGatmeOP\n0unRTUF/vPd4tk//JdOMulc+LMId2rLNAiBIan8BLRIvXMBp8ndfXi2X4mer3XWD\nll4hOMdroCYLjA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQlEnzJ3vrazumhEdb3muvCBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzg3MTJkZC1jMWRlLTQzMzMtODU1OC1iNTcwNzdlZjU5YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBOQkMG2s7Wq7CaI3fKrvAyfhLhkkRW1cyiArnNuP8K9jP\nm8uiGur28eiWm3jgICKkPZSAjPKMGxmMCvrU2J09o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVPLrPhx8xUYEsEgKbH1cIVnu\nbqcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALGRrdZTcaU9aCAx6YMU8awfa9oTuiaU+0w/yhDxBBdLAiEA6A4urOIV\nqGUBIWf8N4unvq9ycxoO/L7Y/EB7loiWgHI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbpG1GI5DLnAsQb5Lyx6UqbPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNmN2U1ZWYtM2M5Mi00NTdmLWIzOWItNjEyMGExOTczYmY4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTYwOGRmYTItZGJjMy00ODQwLWJhNmEtODM3NGE1NTYx\nMDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERdvLVmzgIP7FYL9tpwddqxFm\nn4ugQiZBUrnkkYoPlS8wlBuTIRx6gSGxFoi4vC+7QXNcPBOjldV0Lq8BxywQL6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFny72XP84NKCTFdD2MMu/YU8ecwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAgm83wQOEtEv2nMmSw777E3HN5PTZ\nLM+YR2lxj/DpVq4CIQC6HKQ0mTqgB1yy48opAoKHzvZi3Sce3a6CU5kxyo26hA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6750", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6750` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATge7637Tny3W57eDvKxlcDnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNjBiYzE2LTQyY2MtNDMzMS1hZGQ5LWNhMjRlMDM2ODUyZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM4MjMyZTktYTI3\nYS00ZWI2LTk0MDgtYTY1YTY4OWI4YzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA+Mh6IK2ucX18pL8yM99UK32u+RcTvi8rWX9MlzXtIATw5qK2dr7ieRL+hHE\nViYV9flJlNCWVLrSwm+KMakdgaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTH3TacDHQbXE73GKoCIizycKnyYwHwYDVR0j\nBBgwFoAUZsQOdRXyep7hzTYfHbp6lB7Or14wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALeyMyKf4DvF\nxL0RUfS8YjtWGXanVAZtIBbHAo5/DEI4AiAG/ff2gQn6HTUXqnLS4kd8KoepKlZg\nfAvwiB01NkvGOg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXGDB4+z8BJ26SqJc2LR8lHSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjYwYmMxNi00MmNjLTQzMzEtYWRkOS1jYTI0ZTAzNjg1MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyWwxnJB33uunco4/8zOp/7Kdz5FmcxU8XgBzrf/f/4Bj0\nPXyk/jZ7wyhvn+SOmmjaiuHa2pf6Yxq/CPgoAzPlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZsQOdRXyep7hzTYfHbp6lB7O\nr14wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWZ5jcazHI+xg2340i8A69RMJuHO3K1skDH0Zkqh5Yo8CIQDI1aErcxMl\n6CqHm+RW6ZhaAd0Xs6hBinFdrfVU+VpIGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdJRI/Eq+lDK6FWOc+gN9KzmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM4MjMyZTktYTI3YS00ZWI2LTk0MDgtYTY1YTY4OWI4YzAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2YwOTE4NzAtYjgyNS00NmZjLWEwYWEtNThjMjZjZDZj\nNWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7CF4w95r0HzlRu6Xlkhyg3hz\n7XR3EBmubFgZLmeWy35mEQqnV/PCejEtmgRi2xzozYUvr4X9V7g6oueXhn/p8aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTH3TacDHQbXE73GKoCIizycKnyYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBnrno34U34Fk5vnXzBjFSZLsgMrC4J\nkGWUGYPGva7wegIgPkYat6SKuKqEM6141/Rq6OrSMZORCerp/XD9QKFMsD0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6751", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6751` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAb9nPGsckuPQ4DrhBqejhcfNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NGQ4NGEzLTc1NmItNGM5Mi1hODViLTAwOTE4OGU2YmViODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGE2NTU5MDAtOGE5\nMy00M2UzLWE0YjItOGZkMGNiYTFhNWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkewT80ReCyfOhA7FvFOWMWQ+EHYDAc/bpbjnoEtSDUjuOdGLRBsrmwed04st\nzXXikD4dTZIPFvBIE3TipG/cJKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBwv4epKV55qTXW6F8xDbOZ8ky5AwHwYDVR0j\nBBgwFoAUzsVq4M/9IBsE6ZIrjs8XBasv1ykwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDWtV294RHH+\nFvlhCRAPWf5vCUBKmycQI/AAeycM9nRdAiEA5jqXIb81X8LcLO4DmYvDp+UaCg2J\nLzfUAqzcVW0zzr4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXPEsDa7jRiErnAATEDuqwR/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTRkODRhMy03NTZiLTRjOTItYTg1Yi0wMDkxODhlNmJlYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCnxWMqAuetWkhuz5pjGG3DYEGQYifImavZHtTCCtWnMjB\n0kX4Vu1Q1t0fVmyxwlwFBeBBRMlS2gHXgkT8UuHWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzsVq4M/9IBsE6ZIrjs8XBasv\n1ykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMOy/ZwCVFLEH6NWfdmupztoDrac9Ut7wmBbk7C73UIwAiBa0JKxNzJh\nw4ecg/ds3imJOf3zGDUOiccdunTGdiqW7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXNz9eFRFx6abaHNfOimGy6oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGE2NTU5MDAtOGE5My00M2UzLWE0YjItOGZkMGNiYTFhNWQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWYyMDk4MDUtNGZhNy00ZTI2LWE3YzQtNjNiZTQyNDE3\nZjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg5PRy5xquObgva/7AwiI4bWj\n0yDW+L/ryO7xf06LHFSaevCg3w8R/0rXWCByOO3c/jiLobh8UGL0xA4epIne0aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBwv4epKV55qTXW6F8xDbOZ8ky5AwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBqL4AEDo1KyIhuB5F28kWSWdNvbMB6\n8KaiwLh3bG2TLAIgM4u9wEVwRo7WIKMrcuPJ0vKpcqxCt007iD2gnwepuTE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6752", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6752` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATKRosEBMUbOp4hVyL+pV7o4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2MWFjZTkxLWY3NGYtNDFiNS1hNTJkLTgzYjI4YWNlMDY0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVmZGUzYTYtY2Nk\nZi00ZDdhLWI0OWItN2U3N2Q0YWQ2Nzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdZVTDqgZfvFzABTrcCrhDcU9B8/yUxjVsHtGlCJTvprdrBLiztQ8MzdKrM3x\na4J6q6z/6fJAgcm3WJniBpBid6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5J7cRT5Zy+hGbD8KQcLpMZthi0cwHwYDVR0j\nBBgwFoAUve3g78c/B6NrteLdsft+mA/DMHYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBcq70MvLio99bXXiYxGAmOarUgvUFqUgiLUAZYXKbzuAiEApTJ3Im/2BSSV\n3RAa/odFJiwkmXodxJobdbKYXPbO8/8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAayPhqp/8dz4goimcWpoZoQQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjFhY2U5MS1mNzRmLTQxYjUtYTUyZC04M2IyOGFjZTA2NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkvGxz+pJ2PcNT2nF4FF6toxem7jrT1iYvQf+uOqBTivwi\nasfDT/yv3guxzROUzsqoRr9AziuASbNLdb6bSF9Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUve3g78c/B6NrteLdsft+mA/D\nMHYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWSfDw3IVcXBYawIjC0hpwMZdfuU0gp4UVANpuWzmZgECIQDuB43ozlk8\nvdh6Ut8sylB71kCGiRxGbCUaIkLCL/puwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXgbWPRjkBPq28tAN1u4saV3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVmZGUzYTYtY2NkZi00ZDdhLWI0OWItN2U3N2Q0YWQ2Nzk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmYxYzM3YjYtMTliMy00MDBlLWE3NjgtZDZmYjg0MDFk\nYWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErebkXXLaUxIgxqYi2YeVBsAq\n3nZVKK0Y8qDZw8uhlSZWTzfQgBiHK5bNMNg6tsB/uheDYWV9xpXxB9oDZBkAaqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5J7cRT5Zy+hGbD8KQcLpMZthi0cwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAxAHCPvvFQiHyQXsivl2y9SAAutLJ\nRMSymYD0j6Pe9dsCIA/4MUiKdZg4ipQfrzFN/sbPKI/7GWp5dnH5X7SPCcp8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6753", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6753` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZD6Zz44RNXXuGwk+ihj7o6cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxZWEyNGE1LWE4ODgtNDFjMS05NjA0LThiNzIwNWVhNDZjYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFiMTY4NmYtOTIw\nMi00MDMzLThlYjMtZTdhNzg0MDMxZjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExCyAaRND8AA+SJzjBiGSNzcbkeYn2SgV56KZZyhAMO+eOB2Yh2rbR7cYtrcy\nKE7PV1b85mUGC2bvhAOUM4bxQKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU41KVpk7HqmCr8vZLJzpVJFxHxIMwHwYDVR0j\nBBgwFoAUD7l9rNuwBMdEy+TQWFLcNT3ubP8wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDEid+b43FCmA314DFBkUx1ctzZE5UF8EIZVGF+HPdUZwIgE2mduuTPoyjo\nmuUIaO39k2itmPCXpPxFG+w4lX4Qz7k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXv99jLg4EBjszvSc+VeMQbxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWVhMjRhNS1hODg4LTQxYzEtOTYwNC04YjcyMDVlYTQ2Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9azFu9Bi/vhuLWQOpQH2gvu+eGMkKN9TOqypAzThkfCaB\nuAbAQNHEYWSAwHbOTU+Sv61uTU7Ptw8K0IzIK9J7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD7l9rNuwBMdEy+TQWFLcNT3u\nbP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP6JKqKSh31JxEW1HqD12YgV+XAx4YwLpx3Jpk9oQqo8CIAWgvA56cW6B\n57DtAgHfvDbp6kgcdDef3VqQCIBGdow8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeiS0WoCYpH2+ec+QWYvjSZlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFiMTY4NmYtOTIwMi00MDMzLThlYjMtZTdhNzg0MDMxZjMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmY3ODAxZGQtZjMxZi00OWVhLWFjOTEtNWIwODU2M2Uz\nZDMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp10C+CxDghizdsfbEc32c0kt\nlRquhOQB13vmMCa/oZwBn7mjJIBO9aDUho4FnnH6RJ6cIBm+wHmMjrjmDmX1raNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU41KVpk7HqmCr8vZLJzpVJFxHxIMwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAq6Pc7s3E2l2UJ47NISvgUcaLIOG0\nsQ+cRGVtONm+eIkCIF5CjRt8UhjF32KcQ/h/cKVkQFLgEek1eLd5nV2WOV50\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6754", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6754` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAbs8knFQoLJhVdsfC92QjVf9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkNmU2NzI1LTdjOGMtNDRlMi04MzVjLThkMDAxYTZjZGU1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY1M2ZiMjctYzg4\nNy00YTdhLWE4MWQtZDU4ZjkwMmU3NDA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELyazkdmlic9nS9RMgJqEDv5CEzSQfBT3wj/8B9TjvFIleboRCNpd8anWlphP\n4FZrEptFTKTk4tL+VTKf51dcp6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaxy4ONOjYdLLjzbNXw/XvkR5HacwHwYDVR0j\nBBgwFoAUxRD9CPn4Suki97SMQoiJ0zUfuFowLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD3\njvrg3LeKQReOeNAGBWYu0KnO1aU+IthI2NwGYAPrIwIgQouuUMw3nJjb28UBb60u\n+b55ST30RDK+OcTasagbPeU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQEkzRzh6OGJgtPOKIc3nhRGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDZlNjcyNS03YzhjLTQ0ZTItODM1Yy04ZDAwMWE2Y2RlNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQO4x9m3LiqE0tD99v+LBvBJaUpdALq3AWDwBmZaAyHTN6c\n2IklBBzAXyKQEXTmIt3jIOQfalGxvoB5TJLZ0tsfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxRD9CPn4Suki97SMQoiJ0zUf\nuFowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJyxzN1iF9RFOim41la1Qh7nIOzVtevGjqngE9ouFaLICIF5OoK9Cvwmb\nRmeu4rp4xAOs7ywrFl5qkZlGM8RpeYuv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbnPLwmKuTV5C7/jVSCBfC2GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY1M2ZiMjctYzg4Ny00YTdhLWE4MWQtZDU4ZjkwMmU3NDA3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGUyZDcwZDQtMGUwOS00Y2E2LWIwMTQtOTkzNDNmYTRm\nNWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqOCgk6MwHl3LmQIYOSpYTttD\nampRE/sy121OzMH0ZtfSGuYsHcONo+YTNT6Nffx+OezYjkA+y28r4Y67+EPcCqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaxy4ONOjYdLLjzbNXw/XvkR5HacwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA1OlbNamGbqk7dP8hoNd1EAwgCuA9\nUIM0PNxZzebjBH4CIQCYjFNseOnzqVTZasm7bhF/HyFpotDF6S29XyT94+KAJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6755", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6755` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAaVugHaZym+ecHxe7Lx/YuieMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjYmIwYzA2LTZmNWYtNGM5My1hODQ1LTM4N2YzNTgwMmNlMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2MzYzdiNTAtMzg1\nMy00MzU4LWJjYmUtZWFjZTQyNGU3ZWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvEfZaLCawi+/oBuuv0T39G6/Koocq4u8UiTP1MKoLYQEOGnwJVbwv/2n3YNX\nrkiTcz6BFkJ4FLQRZjIbbxfks6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYcWrBvs9SZhhSuzVBV1DD+0zHy0wHwYDVR0j\nBBgwFoAUu55wrBmNcEme/9jholwGYunBiBwwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFFzYExlhC0GKEq6OUQAt9V+rtXDaz2JYpraaU6whAptAiAKmoD+\nfL38DSIgHUFb47HrMgn3mWHwRyal96qUVmuHOQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZyRtFxBRS3oNDJO31/1Z3Y1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2JiMGMwNi02ZjVmLTRjOTMtYTg0NS0zODdmMzU4MDJjZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATd+porO79n8l//VZBD6S49zA8wwp8XCJKTBA8FcVGMoZSd\nqByzB4eC5r3jVXCUsAid25JkCPmFrf21XPMAobRMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu55wrBmNcEme/9jholwGYunB\niBwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX71MEK2Us5//PeOkzsvY8JAE8uhdFIt+QEwm/TArvmwCIQCUHGSQI74M\nQZOfVrizAO9ngkP7FDCVI2J1yr2y9fvJvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQwZXm/SMPvIA1l4Cj428pKtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2MzYzdiNTAtMzg1My00MzU4LWJjYmUtZWFjZTQyNGU3ZWRjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTkzNGM3ZjQtNTNlNy00MDA5LTkyZjEtNGRlNTVlMjhi\nMjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE88RUzF1g8OLOTGEaPo38WGVA\nHCyG3S5rsUemNyW3/dg44A19jEFWIPUHX4UG1trvSs6Hst+285CK3YCRDRGMuqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYcWrBvs9SZhhSuzVBV1DD+0zHy0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAZUmuOZ7m1iYG97n4rQSgBO9rrOOMZ\nsUoACixslhGm8AIgLJWyB7loxBHCaEncEMGVdNSDsgYM90bOHMk4cvTSj1w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6756", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6756` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVk4m+jUz0EidiLic2zWePbWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZTcwZjhlLTgyM2EtNDQ0ZC1hMTYwLTQ3N2Y5MDJhOGRhOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg0OWRiZGItZDQz\nNS00MjcxLWIxNWQtNGQ2N2JhZjRjOTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES0Iy8SHfS1eg7yqP9nn4OdwAOVFA9IYM8U8VofeXcJs6oFBeHATi5OJCih6X\nBCL53EBnXHVYqABeFp1bd5Qq9qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUokWZTQkfg0Hvubx7q5uaOFDLUXowHwYDVR0j\nBBgwFoAUoAL6N1n6KeBvcRzQEq38VitIhnIwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBMJQu24ts8QLL41nmLWd8E+AvikMbyv0MV0a481M4mmAiEAvXPh\nAlDKG1DAuAYYlvUHBovLkm5Z+CKkcvcO7qWYut0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYcUDus9OIi4CC/3Ilo1I4VVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2U3MGY4ZS04MjNhLTQ0NGQtYTE2MC00NzdmOTAyYThkYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqThoqsQY7l/1NzihchKv+BQtfYH3zIOVy8WAmHCpGMwAS\n4irehn3j2dolHe3U/R3FSBaipwVVD8I9WTpySFgto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoAL6N1n6KeBvcRzQEq38VitI\nhnIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM2NikqCIcD448qT2mpphfiYqkqsLOgw+kC3Ojdh0zWICIA1iijAuZD7E\nJxSuGKZaql6VrqP/1/cFvUhw4jGgLMtr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfbECodQjGt8t/6LAxOIOnN6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg0OWRiZGItZDQzNS00MjcxLWIxNWQtNGQ2N2JhZjRjOTY1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGJiZTc5OGQtMzFiOC00MDk5LTgzYWYtYmRiMjExMDc2\nOGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+qSmbDLKij0nK/jK7/QCQ4CH\n4q0mO3Y2fsJ5966KFR2P4jkLfaHTANyGdYY5WxJjEsEkvwUZb0p++gNGLgrdkaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUokWZTQkfg0Hvubx7q5uaOFDLUXowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBjNbcQ+pNzRPkQiAskuk4IJGNykNrH\n/9sh6UgFUxZVjgIgSWBI5/Uo9Y+iIKiaECN4jAl6FJRPIMCQzl6nKIrhtsk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6757", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6757` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVDnxzhzjeOTr5ML8JmG1YVTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiYjlkOWNmLWU0MGUtNDg5OC05MGFiLTQxYTg1NTNkOTk0NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRiZTBkMmQtZjkw\nMS00YmU4LWEzM2MtZTU2OWVmMjY1NmU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEov6QnwtJ9RrzkXjxyw+HxRRXRZU/j+BOoO1XhgmE32hYkIW0KMHYAYdZ5tFV\nlKBHzPORs05lK9mTyoVI7qJLeaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQigqiycRpvBETRiuUtxsEQkicDgDAfBgNVHSME\nGDAWgBSed+nEPE0kefLlkJVIVayQzuAcsjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDpLOVOuOZlzxY3h/gDVwZM0ZI3uKKRw\nZCrufa9ocWE/AiEAn60IirjIuN3+OmA/QoyWUTFZl//RxcnxSAxmMgi3ACo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATR9GwOZ/QV3acqBZJdn7q11MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmI5ZDljZi1lNDBlLTQ4OTgtOTBhYi00MWE4NTUzZDk5NDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy1vTRa8/RjDurk/UO+/4+pvzkMYfP8RhLajzMIIQXng/I\nomFDeq6dFQq4sCIHnKcKOrclsy1EN5Mb3NC8q8NWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnnfpxDxNJHny5ZCVSFWskM7g\nHLIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAODc4gT7jSqMUWQzQyKF4CVseRfV1eSfyKMyzu43zHsPAiEA0S0zMl+F\nEjxoZUI4SjQAkW/eK49ojJWAn+YI+jw+5jA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARx1nPvD7lq4eKdtza6i+zkMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRiZTBkMmQtZjkwMS00YmU4LWEzM2MtZTU2OWVmMjY1NmU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTc4ZjI4MmItNWJiMi00NmJmLWJjNDUtMDViZDcxNzM2\nNmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk6cUMASdF+qyuKem40J5uJyl\noB8MNM0SxSY0U+6TlBGsrloedbo6saugIOC6CJdpQ58mtnWWpebw0kT8PbV8QaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIoKosnEabwRE0YrlLcbBEJInA4AwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBZOASTokLl4S0IYj3nGlmaygOwVRN2\n+v8AqVe/uPDK6QIgH2B9JayvxU+dR/j4OwAOxfA5RPC/cnrHo79/tRlaCC8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6758", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6758` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAUeCF9SGXPwEjnoEkOATB3H1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNGZiMGI2LWYzOWEtNDljYi1hZDgyLWNiZjVhYTU0MDBkYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU3ZDQ4NDMtNzFj\nZS00N2IwLTk0M2ItMzI0MTVjMTA1MDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw25djkZU1rH3t1scuQK2yyJyevsltngQ7M8jk8L10sM0vbgIzkpCVzekOe82\nSyJl/kDuTXxR+zLHYVunRVb2PaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Uv9q6OmTgJ454sUyP+rwqgOSbIwHwYDVR0j\nBBgwFoAUmjPB/D2SHYSOJ/z9parXZC4I7Y8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIAQx4YsAZvAa\nKUuRj/tEJCpaSvrbWjCT6B83KomnjvabAiBeFxC1mIKFQKS21caIG3eY/xIn717A\nw73ouPbfhHkcFQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXEJn1wdFzjiB1P6hmtgBkMRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTRmYjBiNi1mMzlhLTQ5Y2ItYWQ4Mi1jYmY1YWE1NDAwZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVmC/mGqG5+UD0e1kcxDMLa1k3nBqJNLqe8SJuoRfVU+aW\nh6lys/+NSOCaDDW5t3evVarH1KwwxwdpSlX73ut8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmjPB/D2SHYSOJ/z9parXZC4I\n7Y8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK0XbPb5o0BMiHKL2U+cq1mpYFisSoSPKBIHD/ZG5u7xAiBRWCmdoiZp\nD2owyPnXB31KZYJ5Ige2bme3tDc6AHP3LA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWXutgXeByX+KCZ0UY1c/HhnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU3ZDQ4NDMtNzFjZS00N2IwLTk0M2ItMzI0MTVjMTA1MDY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjczMTUwZDItYjNhNC00YzkzLWFlZmEtM2NiZjgzMGZi\nZTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB4rVl9/M0EleWj4kL+CYRkq2\n1GkieJsxXv6pjacat9HaVLzhVbTCClPTM8/3F/O3uxmhKsfVEKibkoFpeDIT0KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0Uv9q6OmTgJ454sUyP+rwqgOSbIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiApOS+B7j4n6L5Lmg9HAEJwh6oyZ7GX\nzRwbRy4rlqhhiQIgfovVvu1/2LJr0+pzgRC8Bv/XaCjq8EFcnPryacKsWDs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6759", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6759` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATCG6OxGDS4xBzEQ8c7nxnVqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmYmM1Yzc5LTNkZDEtNDQ1OC04NzBjLTYzMzliMDRkMmJiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM5YTAwMmMtYmU2\nNC00YjExLTljNzYtYjNkYWQ3NDFjYjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE13ydonSFGuMl3xC36aQvES46P4/XrEfplk4/Tnyz4tdK57qz/0uD2SvubQeL\nyS8zQtA7vFCnH3OXPqhnSCAbg6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBRqdzaf0WyYdCvFOXcUFPRKgHUYwHwYDVR0j\nBBgwFoAUqbNjfpl9AQbxs0fwg5ch9psCJ1QwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCs359CtS5q\n41I8wB85pYEJpuITn/SPvk2V/x/hAE0UgAIgbR5MJYfGJwDYKzpiNp/MQ7aOp9B/\n2AVoIIReFY0LxaY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXYKlS8mxb/hfbwCxPSaGed+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmJjNWM3OS0zZGQxLTQ0NTgtODcwYy02MzM5YjA0ZDJiYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdmJVyyY86LX52Liq4/wekfsE1dNXfkYjmdNRNsBKfa9E8\nxtd0O/uH1QaEd0yfv0OuXP2jXngRY7NHauQ+A9O+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqbNjfpl9AQbxs0fwg5ch9psC\nJ1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYyRZtbNHzC/SAt8EsXqL7VrcDL17dSGslPfIAQRo/EoCIQD48T/rXizM\nuMuvWewCdFQzWwOqnDIw9VikaXdn01PelQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXHaSOKmVnYbAoklamW6HYJQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM5YTAwMmMtYmU2NC00YjExLTljNzYtYjNkYWQ3NDFjYjBlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzUxNzA0YTctM2MwZS00NmVkLThhZDQtOTYwOGM5Njkz\nYzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH6A8AB7rpyHA/wWe6fx5qgCB\ns6emGnyWQD3iy/0t/KO5vtKvJE1wEnV3dK4px+y+/0StP5rZwtrzpMOTE3iGIaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBRqdzaf0WyYdCvFOXcUFPRKgHUYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA/1RUT0krcZuPwV69OsZXeo8ehqgQ\nHXvgW/SFeEHi9b4CIQCC2db+1o/KBHiiB3cGmFb8LoGIKSRGNXC0vSrjvlh+wA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6760", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6760` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISARPMi6IS7wHxdxgjNxA94bFFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkZmZhM2I3LWZkOTMtNDM1OC1iNmNmLWU1YzdjNjE5NWFhNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ2ZWJiMGMtOTA3\nNS00NWZlLTllNzQtYjk0NWI5MjUwYzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFQiO4fRTHXpXb/0eDoEPx9rkNkDLH4AijkxMgQogfR67n+PQCHNMxcM1KNtB\nV1YZ1ofGhxOFCP7JYhybXNf7SaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzXCUOFX+UaYU/2BwwNu0dDyS4b8wHwYDVR0j\nBBgwFoAUGBC/NtJhK1OLXQnxW7WbBogtWlUwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAurNxTUFQ\nDE5BjA/mDZGMRrus2mmiAFgK0N6/jgf+tbsCIQDi4RKGQzt6Mk0Md/Oe13hGCc/p\n/6ZAaZNZwIsFtJtPsQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdr7QF3rkAxUgE4lbv6Y0dhgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGZmYTNiNy1mZDkzLTQzNTgtYjZjZi1lNWM3YzYxOTVhYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYSAWglBK+SwS5XLLGlhGDqjyEVh7shcjcvPZxWWx8w0dl\n6A8U6wan4HvkD7erLTgnhCOMolC1xetHXPVS9/4Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGBC/NtJhK1OLXQnxW7WbBogt\nWlUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMWd7JRlgmDLIBEcV8k78YaCfmIj8mVKXuxKVx3e0DKgAiEAwSwdbw+i\nugCHGg/mMcjh1clm2kJHPc5o+KqObeXG7Eo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAd+ZTFHHdjl1sA2Kw891kCyQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ2ZWJiMGMtOTA3NS00NWZlLTllNzQtYjk0NWI5MjUwYzI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJiY2E2ZjctZTAxOS00YTJiLWIwMzMtNjk2ODY1NjA3\nYjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6i1xNEkJgaBmxaolPKqSTQFJ\nngQBUg+6vhQ4xNfWchCHM0Tqf0PRJetXnsiur0h1SqMVJqfrgpZqAh03IZTLn6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzXCUOFX+UaYU/2BwwNu0dDyS4b8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA1YvlL4Zt+lCmdlfnMLVrxg919GUrV\nfh6K8xBuMTzk3gIgZwyZ2m+U80YdcuJtSgx/WfuhU8y96Jmw/GE/H3tH/j0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6761", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6761` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAaMz/3GDHmpfemJedSqOSWYqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3M2QzNjExLWE4YjctNDRmMC05YTU2LTUxMmNhMDY0NDk3MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQwYjkwYWEtOGNm\nZi00YTk5LWFiY2MtODlhNTcxYzAyZmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvQ/2DqcRrZ8P5LfkFXOOz6J79YQOlLqq++bLVza66s1dVbunyJxqvpmGo4oj\nYetTIzr1dQ+PwNVXIaQw6Jmu16OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyPRg4eUHbF/gXu/WIrZ6GX7GivAwHwYDVR0j\nBBgwFoAUMkF9ZhdGHend6QVrQ47ykHKnvhowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiA5fRaj9dosiKiJx6lshSEou5EV+EmJmns8rQcI00JvyQIgSJOrxCDdWb+/\nHkSPeSSamA7Yv4GFDytWTE5C50OyaB0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbUnqPyBUtyiuMK3ebUipwwnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzNkMzYxMS1hOGI3LTQ0ZjAtOWE1Ni01MTJjYTA2NDQ5NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqiO8H3EP3vjEDSHMkC57pYtvMr9kG0KFmdOi1l7xB4Aix\njRvo4gDUfmmcgIewYV8xj0uqYeEao69/MhhXUTYho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMkF9ZhdGHend6QVrQ47ykHKn\nvhowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIPzgo1b8Qp0CPB26s9+7CC9hofI5jGifXIKzE2mhUAEAiEA4VqZenlM\nNWUNswbU0PAhaI80rlHASRBMmkD6TSVnHn0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfWrR8laLGtZdSXlsTf3VTITMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQwYjkwYWEtOGNmZi00YTk5LWFiY2MtODlhNTcxYzAyZmY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2YzNWI2NmItYzY0Mi00YjQyLWFkYjEtNjE2ZTc1N2I2\nMmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExTG09pZfZD6+jlvU+HLYa2Vf\nNCcqcGEkAUyQIFUYs7x0uIBzyrB2QdHzOe9GTaAt89klaH/B+R0d9ckCoGJdaKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyPRg4eUHbF/gXu/WIrZ6GX7GivAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBh07rQWS6hK5mh/7kzBSQOPyfTCkzq\nzGCR7qLm15NhRQIgc8Rd3+EYQOj3FF4zZ0RZfeegg5NvItI4XSaxI1jKqM8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6762", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6762` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYVhEsLqxFU4RZwE04zCwvWFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3NmZlZDIxLTFlNTItNDg5Ni1hOGVkLTY2NWQ0YmE2YjY1MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjMwYjkzN2ItNzVh\nYi00ZTQwLTgzYjUtOGZmMDBjNzhkZGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs4NS1T4tH80gZX52gQrnPdv2/7jA+M+RzW9ccgFHAxQPtfFpsxZx2LAtZ3OP\nocIvsjjWXVpKwrFZ3kyaEPdwNaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV3rx7I/0YIQZMDi6fDsMrZhjZiUwHwYDVR0j\nBBgwFoAUxiPenNJJ5GY3CN+ef8tn9xiiry8wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBE044uTBFrThSeZmcyUCu29GjHGtgNSqxc5KoqsHVdTwIhAKyttsHR1yVc\nHjiHQ/rIfxDXXpgEjanAhHcXPOrVYM69\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbTDmmUEYsuObDBAzrvZ5aK+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzZmZWQyMS0xZTUyLTQ4OTYtYThlZC02NjVkNGJhNmI2NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATksLZPhv2ebX3vflE+xtJ9/xeGlDlZ6rfwFOFCS9Z7egg3\ncRQI7zxJPDYboPruIovRHh2phw2IZh47JZ+U+Aygo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxiPenNJJ5GY3CN+ef8tn9xii\nry8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJAqwICpUVNhaVR6sAP0qgV0LFrPpSF4EDE6uSsLeJoIAiAfsat++djL\nlfCGhMUALaDk9LXy1xk5JRBmS6D1fTDLmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAat8ctyn1DtjSaBF5if/6XpwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjMwYjkzN2ItNzVhYi00ZTQwLTgzYjUtOGZmMDBjNzhkZGY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWIwNzYwMGQtYjA5NS00OWE2LThkY2UtMjRmN2RmYmM1\nZWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENLcgEGQyUavH9qlhV6uNEX+c\ng6DI5NrqtdcJdUTCgw6HtWc8pWH0/WOSaTO+Y/sx/J0+aI4XZ0qWQWvmP2ddwaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV3rx7I/0YIQZMDi6fDsMrZhjZiUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA5oEfG1VLevFIgNH8XJZsKgR3t0iE\nEaTYRVKRRxcPlAgCIA3FFU7AZ2RJPpHbbHCGgATHnELseSBkpKo11x8NMNCm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6763", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6763` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAaBPgR97hy1kBI3Yn8jc+VRvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3ZTBlMGIxLTMwY2QtNGIxMC05MGZlLTIyMGRlMDdlN2U0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEwZjc4MmUtODI3\nNS00NmVmLWE5YWUtMGZmNDNiOTdlZTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3s6RTkQPCIf2eAnY76fUhH3Z+h+F6TIst8cLq7RL1BL0Xwl9MP/F/0ly+2Qc\nfVvf5PA88psyZy9gMb7g8syOOKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnSe+tX43h4jhmo/yYgqvtGIn5HEwHwYDVR0j\nBBgwFoAUgdaHsYpN5GfxY42F/SN5Y/rKMkkwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBI\n2OCcTy5we3dsT3CsfP6MFa6vsD9WVO7pVPymvW966QIhAPOVDo4+qJbIabjMkh24\nAz4Z23sP9xaap2N+Wzi/ZoSe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR1x78Rd/Pxzj8V5lvQsrCosMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nN2UwZTBiMS0zMGNkLTRiMTAtOTBmZS0yMjBkZTA3ZTdlNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQD0IBcpRHJgD4sdHn+an9JDljZL5pileIxdN1uGGrys78K\nJxnrZtsQyZnkO+meKF38d/W+rHek6GqwzOZY8NhAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgdaHsYpN5GfxY42F/SN5Y/rK\nMkkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLgny7/OMzeXrTissJJvCSmZICIV0YNQ0hWZVW10hTekCIQCGS5x5Mgm0\n2yHfYWwT94Dcwdg6oIClj+n5f8XqjRbp3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAY/K0S9k8e+zkmYGMtmWy034MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEwZjc4MmUtODI3NS00NmVmLWE5YWUtMGZmNDNiOTdlZTk3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDk4NjFlOTEtMzBjMy00MDNhLTlmMTctZmUwMjY5Y2Nl\nN2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJvIyYjqSvfM460WWFImgZZHH\n7oOn4NQn8u5Z+SRjEtQvHmVc4XwmcTg7fmgfYKHQfop2f8kf1RYN5EM0Wp8a8qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnSe+tX43h4jhmo/yYgqvtGIn5HEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA78NLfbFvQLji6B2waW7e8vOzSfO+\nzYzXggknywKpzLQCIGYcPjHWWlWOT0AJdboAHSpZ/B4GN/xQnXA5ewpVPyUH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6764", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6764` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAahwW3lVvW1YOmLJbieB/kfKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5M2Q0ZTgzLTBiZmEtNGM0Yi05ZGMyLWZlYTUxZTUxMzFlNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjcyM2UyMWYtYzEz\nOS00MTM5LWJlNmUtMjNhNjhkMWVmMDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsfW0JVZYALZs9nOcHi4SAuciF1rg4oQBtyd9M8aTckIYHfHvHgDab+JBfM7K\nWFCxyl1zwfTGwQPHDYdumAbXA6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/WVIISxiIxP7oqt11yYmaNhLwuAwHwYDVR0j\nBBgwFoAUZWOXh70IyNBNKzXkW/tLER2ZZNUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiA2+Nx3CMt6p5b14vsLd3qhu51xHZG1EzsTnNn7ecUChQIgZ5sk\nmlxp5N0pp7lEJyk1zhm50SSgiyHAgH4MQV00Mz4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU7lb1mTQ01mCWYiJzIFNJFMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTNkNGU4My0wYmZhLTRjNGItOWRjMi1mZWE1MWU1MTMxZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATePcg6bX8C+gZvS290eQNLERHXCktDhr2voeFR4gjnPSGT\n2MBxAn4dJffrLmmmsV6RaJl6me4MJHIF4l8K/o//o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZWOXh70IyNBNKzXkW/tLER2Z\nZNUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPA5z0UxKUBVx9zo8hVUazhMJ7+GCmlf68BnwqZwUQTtAiEAqD6f/6Op\n8pAUmGax5UFXjhusOfWb1EenqTAJ+qRkhqI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWmeDwMrUP4smaL5zu1qzAZpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjcyM2UyMWYtYzEzOS00MTM5LWJlNmUtMjNhNjhkMWVmMDI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWMyYmYwMTItMmMzNy00MGNkLTgzZWYtYTk2N2RjYTFj\nZTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQt+aLFar5v/fcmbXRRpspCqp\nYF0CGNbqSqZckQQfqZvrlUscivpyeQTWeB6cl4B+K4xX0g+YzQiKJN+IVpZeUqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/WVIISxiIxP7oqt11yYmaNhLwuAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA96lyk9HkZOKAv6Ye0b6Gw3E61q6T3\nmUQ+g6Wkzi13gQIgB4dK9a/GV1fH1EgjW24UwKfj8wWAWJOJOcMpRRV2+jo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6765", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6765` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAVDKFUUyJiv/8Ek942H82z7bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmMWQzNjc4LTgwYmUtNDcwMS04YmM0LTNkNWI2MzY1ZjNkNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY5ZjdhMWQtMjRi\nMy00MTRkLTlkMmYtMGZkZjBmNGU1ODEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl/I9BzS6j7JhvZcMLGSRPeraZ3Bd6FcPKIs0UEXTJI6YVB2EEO8XwWKPHRUK\naOgHGWEbivD4BHR6+TC6IhG8c6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqF/TLV5s45lmKEfTTr9JMPDtoacwHwYDVR0j\nBBgwFoAU1CVTd759N7HwpiTVD4ywQfqA4pgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiA8NI4wvrCaE2vpV+nEUw6sxUsDbcIC1jkCl0JHzuu5TQIgDh/z\nx99vbyKIs+pbU+qWV77Mo0mKLZnFug3EHQbnaBw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQr/BoDQe3eFrPyGlfnSHwF5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjFkMzY3OC04MGJlLTQ3MDEtOGJjNC0zZDViNjM2NWYzZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvM2Dw2KVlbfJSG9rYQDsYnMeRf0lxqV1Qel0aXBvLZyOr\nXw09wPsayIx5YskwNGdlldu812w4JTkBaYslKyIwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1CVTd759N7HwpiTVD4ywQfqA\n4pgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOWnQRXz8e6jiUMmLx71vqp4V273tvkiDWeKFFmPyrP0CIGcWNTtoi9Tj\nuXPanQ6SBcqeP4walrknXkw8TuGJPFK8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdZpV6HoBosKx3C4BotYLkOSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY5ZjdhMWQtMjRiMy00MTRkLTlkMmYtMGZkZjBmNGU1ODEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODlmZGY1ODAtNjBiZS00OTMyLWE3M2MtYzczNTQ1NTQ2\nNDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGy/wrbJIYwgXoUq4j8ZFX+VO\n8UeGm9tjjxwKxTIYJw4aXB+4SSghmM9lD0IwaGkJtUsdNWDbPWc1lhuPaBl9H6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqF/TLV5s45lmKEfTTr9JMPDtoacwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBfmB+tAuT5Dtnl6QRQpkCxjAeTR5rF\nZ9LvsXnBaPu1fQIge8+p9r+zP4TJHEO1Lka67gleR/njPhXqdGaxUdlU2Xs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6766", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6766` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAa7aNffL/lubPFC2uRJe2tzkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3MDlmMzVmLTM5NGMtNGQ2ZS04ZmUxLTdmOGZiNDFhNTYyYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE1YzVlZmUtMDIw\nZS00MTRjLTkyZjctNjdiZDZkMGIwY2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExuPwTN7YNhpOC+ukN5gmgmndjuxQxRW8IObJFYSYBXRC/khUFCg8kfbXpgQ3\nUujCxad9NH+ism61sk4aix8sH6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjq61FWwJa2a9Br5AZVfscaWzUNgwHwYDVR0j\nBBgwFoAUu1M+ueVJvdB+/f1iaOI9yXZJ820wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA1ybCKfXdDbTX\nClM56Oo4vTt+Yoak2Fb4fK2R2c21YL0CIQDOK5QFBpbSIbgiM4wXSLz+3ij8Qizo\nCcZzpT6ORO4JZg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb97M2AG2KezOvlOp1tUS8X7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzA5ZjM1Zi0zOTRjLTRkNmUtOGZlMS03ZjhmYjQxYTU2MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATitF5rEaN9RyrvcYcixy1nIWPx8hDVwb8JHVt2bqD66g0i\npTj1sZx6aQjlC9OUgJ60Sw5StoCrcgHSZeyHb4Dvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu1M+ueVJvdB+/f1iaOI9yXZJ\n820wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK0wdcc2u8cv2cAVZPQMV2jAa9N9391hyRF8Z5X/QO84AiEAj+BLGExn\nRlj22bGspXsigN/E80Xue2M3SshXl32iYg4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZ2pvq8Yjjn0CMIgE51aJbZ1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE1YzVlZmUtMDIwZS00MTRjLTkyZjctNjdiZDZkMGIwY2ZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDc3NDU0Y2UtZDBkNC00M2UxLWFjMzUtN2RjMDdjNTUz\nOGQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKAKLDVDJo+go+N26UTUthmSp\nIyZmQwEY/4filh6cuFXz6313+U55+/51ciEZEMTLmTGFg/v/ajYz0jUVWcvSPKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjq61FWwJa2a9Br5AZVfscaWzUNgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAkcvkcEfTqN8KTQyiSox2VOCu/CMp\nM2M438wH52F/oRcCIQDiF3NH9zGbkETpwvUbkL4PAh5tgU0QWQC35R1p806fUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6767", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6767` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVbM34RJey1pQdaFhvFi3rk/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjOWY4M2U2LTY5YzgtNGIxYS1hMTllLTkzMWNhNTMzMzE2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRiOGUwNTQtMTJl\nNy00Y2U2LWE2YTAtMWY2OWY2ZGQ1ZTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF76TI33ncqiZA84z7QdJbN3Yo02p3qTLunTrdiSBkpWyUdNQf0euxvfDbN/n\nG11PCICPI+6DHDxyxMPc4toQOqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGDotCYGzap9NhNZnIRyCRM5KG8MwHwYDVR0j\nBBgwFoAUOt4sX6L4Iw8U3naeavpEHqZP9oowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDSiwwRMkeR+NnFZQI8fxgbFsGHQLnvr4s0az3qZANbSAIgEGJQGHwQDop4\nQDZb0Z1KKb2kA9e8YJzS0Ldc9Djbrl4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATib2pJ1+EUgGdfn/n/pRA4VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzlmODNlNi02OWM4LTRiMWEtYTE5ZS05MzFjYTUzMzMxNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyhnB9sWZs2bmyYSSDp+xtXQyq8Ea6Bq7EopEccrr+6kxJ\naLg7BKX+amCGafL8CoOnqN0sbI5D4GfY1jLuWqL0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOt4sX6L4Iw8U3naeavpEHqZP\n9oowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdyfG2rTCZZutXrYqLsPWdgx4URsH8G795a0n4Bn4/F0CIBXkbWYkD3rg\nvvlMZsUuvMPpQ4avGhnN2bsj3pGTfPkQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWVFxKHKHQo3uiVDda1MDYh5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRiOGUwNTQtMTJlNy00Y2U2LWE2YTAtMWY2OWY2ZGQ1ZTg2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODcxY2E5MmQtZDIzMy00NjkxLTgyNjgtMDQ1MmVmNjdl\nNjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo7cWGtV5AOB3N04arYA9hL9x\nQt6DaBcUEvmUFCKm2FB/xEf40PVDYlXIjnxAGdOKy/ItY2rtPE32OE7u3wmRdqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGDotCYGzap9NhNZnIRyCRM5KG8MwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBN1ejKnIX/qnASlwyYee8+L95Kn4SK\nRVYRtokRE9JF4wIgV2P8soz8wU8VvKAptpeGpetmUi0G3EPQcMO0D7w+5pY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6768", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6768` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASUD8j7Yq2AMvCp+WXvtuyO0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1ZDMyNmI3LTk1YzEtNGExMy04ZDA0LWE5MzUxNDRmMTRhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQxN2ExODAtYTQ2\nYi00ZjYyLWI2YjMtMjNmMGNlZTUwMGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL0eVDsiVrhqkwb/Ir5mLdHpZQQhtTPVXoxjYFITy2doSEqgQZ2PAJ9G8Yz51\ndcmsIfPEGaJWx9oISjJ4G9T27KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU699j5SpbTddl+kIORLeaeGYVXkQwHwYDVR0j\nBBgwFoAUflZs5qUkOSTLB0PlQkMy2RqRa34wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC5g5wP1UjNNBbJXeidS8JezYwGs4KTuSo83oelgY0h2QIhALqJggmg+FFL\npP5JuImFuaW23V9f2PkzUHYg6uckoijP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbpq22XdoIiMfnI500QPmi1eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWQzMjZiNy05NWMxLTRhMTMtOGQwNC1hOTM1MTQ0ZjE0YWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbbT2XUsezbTtFMkr8+wRRmwVBIpiO1/57c7FT5oehh/iK\nzWI3ff4D65elFHXdwGSGdGrCqOe7G+jIMCHNhS7Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUflZs5qUkOSTLB0PlQkMy2RqR\na34wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNN5iX7yIhGQiitlB8h00LaghqJik2USzcVmCc4v5TSUCIEuPq9iX+pkQ\nfjPkyzxD2+Dtd+IehxCM+5BHZBcFBdcU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAddwwKzWE0FkqdO9YgXzs9l/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQxN2ExODAtYTQ2Yi00ZjYyLWI2YjMtMjNmMGNlZTUwMGRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTVlNDIzODMtNDIzMi00ZDQ4LWI3MzctMmY0NWQ3OTEw\nOGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi3GbIjYBeh615VM/ous05EGa\n1gpIJLxHOw92r/39Ok5rIquFWn+wRuvdsz+2T9KYnMxPCyvegXNEvZQjkr26XaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU699j5SpbTddl+kIORLeaeGYVXkQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA0LlXtRRfjQGaSEwBECYpsHpLjlgl\n67R3RjDGQzXYzWUCIBf78HpQhgXGbKG8pqycUl/ka/9nOj2a6QzQRE5mj3fL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6769", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6769` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAXcF4tnVUyZ1GMTaRDaUfVR0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0MjQ2MDkyLTk2YTMtNDlmYi1iZDEyLTBjYjQ1YzY1YjMzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc2YTkwOTEtZmE3\nZi00ZGEyLThlMjMtODhhNjI2MTA1NzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWKrSh7Sh1CSB7ipVvxDUyXBGesaCxhw+DpjmSkdMpwh+e5IdQ9QFqWZ3YBQ1\nsKGsZu8OXz7ViArj9iS3gbUeJaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCdRCH5iLVN5DmjxfCF0Fez+1WZ4wHwYDVR0j\nBBgwFoAU1kAub2hMyT1KuB3KZul4+KseZCswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAieZrCo4ui/7cNic5i794n8ozsWGbToOI2vKaEytwMNwCIQDuh1ZLYr2Y\nLX/GSFvsTSOdmPDIAXea9/eaznh/dpoctQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWEYm+hXT6K7+L1bIokfAqWxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDI0NjA5Mi05NmEzLTQ5ZmItYmQxMi0wY2I0NWM2NWIzM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbZp8hef4watGDgYCzmXm/wdi8VkkBhymnGbiE3fr/ja6N\n+ncWAuAmmLjKarnQxwjausQAM7IC2ftUv92eRgy1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1kAub2hMyT1KuB3KZul4+Kse\nZCswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPFWD2Tn/gDRZPnUZ89lyUNo1zb3IVPCLvEruL++nQo4CIQD2zAm7MjLH\ntIuvS2CaoY2I0aJmY/CTfR4ObTZds8POBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAe9mXIpClAmHxbGjl/1JLAOfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc2YTkwOTEtZmE3Zi00ZGEyLThlMjMtODhhNjI2MTA1NzY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTU5NTQyYjUtZjNjYS00ZGU3LWE3YTctODdhNGJkYzNk\nNTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQDC3g7R38j4yMLKFtfbzXUWI\n1iTbXB/sHaJ0vAVMi7DQlMv1GKGWRzqzYk0Y97spXsusVWBGbZBEVaDAnbQLpaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCdRCH5iLVN5DmjxfCF0Fez+1WZ4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAsf3pVAPCSa7msMiNk8d5ovCpnlT4\nB3y3CrTjol3aZ50CICfE/wpE3i1Or9zyjVVBT519E4cYStIelmb4XBref/Jm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6770", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6770` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAQYguS+SrQIkJiYa9nv2a7w2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0MzZmNzNiLTYyNGItNGQ2MS1iMjAxLTczNGZjMzdmMWRmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI1ZWQ5OGMtNjM0\nMS00MjAwLTg0YjEtMzIyYjc1NTBkMGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgd3xD6pPoA9Z7rnTFM6AzGOkdUiZ/DPaTrprbF309n+vJ5hlOH1IwMTxPcA0\nKZSRfKaH21NAMU7MKO+nzgIZP6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhfBVC1h0ij7mbYgZORsO4j30Lu4wHwYDVR0j\nBBgwFoAU6jdrr93UNFUV/GNVNPx45XQzXHEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAhSQTO3m2L8IDekPSHW3jwo+wZNJlnnguev5/LNLQ2\nZQIgZ5Qkkmcq/EEcghWd3Uheuh7Sz/l3eob9pMq3T/YBqTQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATjwGgYLbT+/aDv2NHuqEY+aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDM2ZjczYi02MjRiLTRkNjEtYjIwMS03MzRmYzM3ZjFkZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiohFDzVwvrPi4+m8jAlKeW4YD+SYuO7srSmFU3olMW00o\nFAa81M9S7a1iY/YkV6xZp1wdfJmuSMXs1vuCxmSho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6jdrr93UNFUV/GNVNPx45XQz\nXHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbZVrqU94JV5joDghs4h2QaPnaTHlLRAeNHQcB/dFPIICIGG8xHnEfOS0\nBEVbA+1jQxUIW2YP24VFy6Mkq3EjxCQT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAX0OKNEdoZqoDzwMXRTMme7RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI1ZWQ5OGMtNjM0MS00MjAwLTg0YjEtMzIyYjc1NTBkMGNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTUxMjk4YTAtNzZmNi00NzEwLWE2NDQtN2M0MTkzNDBh\nMmRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOQtvZDuNj/9aEMeWHounM3Io\n3v1atTPCj7boT0fia3C7w3qjIoKnZissHEj+exncD+nltgmRqbRV+Fal+c1jW6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhfBVC1h0ij7mbYgZORsO4j30Lu4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA2TKJN9JpEgSWRMVYmy3G7MIt5uIqB\nl41K0Id91HqHDAIhALtWYVeiXaCON+xeMNs0mh3g6SAKhqLkfsv1YXoaLV3c\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6771", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6771` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAfIaEiZRxp9tzGcp2L+Uoh9CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5M2E0ZjU2LTg4MDItNDNlZS04MTRmLWQwNDBjNGJiYjc5NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRkYzQ4MTgtN2Nk\nNC00ZWY2LThiMzItZDcyYmI5ZTA5MWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWbzGG+6sZV5L1OyA3t7H6l1pAt8kBZasMM244wwGP2vhanqAMhvTn9M8aKYM\npz0TNcE8tfxwKwui0tXuDKkM2KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhRtljfamLpZ1BZPjnE2CAzY3AkUwHwYDVR0j\nBBgwFoAUVHNC1ckUuA7GJEtf2SgQ0moWlWYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAbBGSY4AVoBJoFGCZlrRi5k0ofBUJR2baWnQdhLZt0\nxgIhAIsiY7PF3HwKtzJVvT1kkECtisNhtKauO9YAvM5yiMl9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXfx7HboA6hQr+M/ztNSspOkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTNhNGY1Ni04ODAyLTQzZWUtODE0Zi1kMDQwYzRiYmI3OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnsomo+Nbq6x3l6T3yrlySvDf6NEZvugirQTTdZ0zRwH9T\nsAYlrLatmvWX2oRqjAMPnPBJotr5LESp7VGP4z9do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVHNC1ckUuA7GJEtf2SgQ0moW\nlWYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPOqXmiYfR6u4SHY1erDBtMZtWsRj3NmsNGzaPoo86RwAiEAza5bH5a2\nmuck8T8jMS0//tYp1aL/tZA5YohotryXUAU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZrnmhgpFFyLgYoBMWO4uIdmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRkYzQ4MTgtN2NkNC00ZWY2LThiMzItZDcyYmI5ZTA5MWQ3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzRlN2Q1YjEtZWI0Ny00OGMwLWFlZGYtMGFjNzU4YjNh\nZGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGCpyQ0EkHUYK2oQ6DF9ZSFAo\nqQTKN0kSd/2ztt3jOlFMOJIa1eiilEfZ0eAwbeh6pgrV30chHvToHa0ndEOnH6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhRtljfamLpZ1BZPjnE2CAzY3AkUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAtAMHO5Nak9IvwmTI+yuHgQ4VJv/G4\nGTXr2A9QlrlYNAIhANCMKu1HlCHbu0DJvcDL4Mr8KuNTeg0UYwaNmF67mVpp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6772", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6772` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAd8IOsAQsRfsaLvfdKyh4c1PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2MWY5ODVmLWFhZjgtNDQ2OC1iNmY3LTQ1NmQ1ODBkYTZlMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc3NmVlMmYtZmJm\nZC00NzY2LWEyOTEtYTAyNzgxNDFiZmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE73J8Fn91+cQ8tLeKZWXxR6iOsFsuktH7vZEKHXzNom1MtHURRxvoaVJduZXO\nxYOjUMGITO6KoVXDTXznJ8GMaqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH9ZV0emOj/rIZPwW29Th/r+zGMcwHwYDVR0j\nBBgwFoAUU9N2rPPnafU9rKic3V8k1QRk6VowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAgU9+yvja7Q5AW6Eox+OQbPQ4bLhsHhnq0eLJyuoGGKECIQDh\n1DGBvL4ra8v66g14LEKsLOtKrYOORbg2mE4RTghJjA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbRBdDXLrRENVowH1ZBMX5jRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjFmOTg1Zi1hYWY4LTQ0NjgtYjZmNy00NTZkNTgwZGE2ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsThzKELFvm2eMuC5qbC+YDp3CzJTydc9e1YjxQQRfSE8W\n2w85rZ7r4De9QzIIds3q77AIxuDXVwad3S40t/m+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU9N2rPPnafU9rKic3V8k1QRk\n6VowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALdnlcA8fHz63vrwfS3EisKVLxGDLkldGg4SOTCMa61KAiBuLz9Qy1mY\nmNfuhdSyKbpEydxTjq7pAjJuWZMDtXNI4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAandjXfKSxf1O6Uy2udr1+9BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc3NmVlMmYtZmJmZC00NzY2LWEyOTEtYTAyNzgxNDFiZmZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2EzY2E3NzQtNzc0ZS00NGYzLTllOGItYzViOTQ2Nzlh\nODRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4J6BbRZCWdbVYuxkka2qIFPI\nfZSKCyOcGhWZorM5lF88IvrZay0J5BRRcR44+xK5I4Tw29WX5hgsfCY1DNTLl6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH9ZV0emOj/rIZPwW29Th/r+zGMcwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAi5s99IhN2XZxRv6mBeBXYQqQtxdb8\najdWART67Bxr0QIhAPJ2qVUEvHv2hYV1bobA/Wset1g4R15bG39jo/35G44+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6773", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6773` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISATZxZpLAP2cMBXiTC04QbDLqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4ZjJkM2Y1LWVjMWMtNDM0MS04OTE2LTA5ZTdkNGQyODIwYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNmYmRmZGMtZDhk\nMC00NzJiLWE3YzEtNzNmOWY3ODMzNDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwDQOTgcWotqkBlGvWXbQNM66Ij+a44QUmrv+EC7fOHDqOl18ojNnvdqcVt3Z\ndf8fjxHKruaPz8F2pgS0Numnu6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV7K+bsJ0un5k7IgqQGsXVr69oGkwHwYDVR0j\nBBgwFoAUlMa3Bt6ZncfXzhHMVCJTLZZ7wYEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBSa75Si+wzbTCub6zlZolrUQbPS+LHz/TJ\n2XLDWIZGLAIgYiijhu7jg5rOPZERT6uzThfi3KJKxgFjAiUM15jy4/A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX1q5sD+DbIonSFuqYFvgQ+RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGYyZDNmNS1lYzFjLTQzNDEtODkxNi0wOWU3ZDRkMjgyMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqmas1esCdy2t3tEVZnm5b41CZlcVV5XumzUVtkZw6bc6q\nNQ6SNKhaJsxFygTnBJEEuFLAvXlV0LTgbeEGeBy2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlMa3Bt6ZncfXzhHMVCJTLZZ7\nwYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEtY7L3zMO2viuleGz2aInS+rMhG5w50dLqhJlDmX7fMCIQCxwezPumir\nvqXjzoKMkkvaFIt8xHrSZp3rRM1UwIIhCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWCKBnK1sxC1N4q9el9+4yp/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNmYmRmZGMtZDhkMC00NzJiLWE3YzEtNzNmOWY3ODMzNDdkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGEwMWMwYjUtYTYyYy00YjBjLTg3MmQtYmZiOGVmMDlj\nZjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERTLexklFtVfKpDX9dXBaU0Pf\nVdegU67DdmTZxf8yk7HZwCC/zSPBHhjbQEM9E9VTAsCgB3QW4YH4/oVM2GnIPaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV7K+bsJ0un5k7IgqQGsXVr69oGkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBE6Ndhn4CF/xZYYNNsEhl9abpRlxwa\nLuyFpuaI44MyPQIgJEWqER2nTS0PeI3uZpC+74X/ELyT+QLy8xr+cbOY0+k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6774", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6774` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAWMOvOKWi4X22V/zwgWfA/XNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlNjU4ZWJlLTBlNGUtNGM3Yi05YTA4LTkzMTIyNTlhMGY4NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNkN2JlZjAtMGIy\nMS00NzZjLTg1YWItZTBhZWFjOTg5MTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBYjKUw1aike2bTYYyvGZmFbHejtS+N9bofPhpZmO8NsP/oBVRaudMKPOBqHR\nfkYmHbPxPjxycU1+Yw1pMSpRyaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU88AmVi2awpy6a5yviV90FYjRQtUwHwYDVR0j\nBBgwFoAU9VMCioOXK4WO6f9FoNpzEczpNVowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAXVjSNBPu4x37T3yXlQD1FEMG/5v8T+Usp\nRzCeURQS7AIhAKx1mbJ9CVMeHFJXEkAFT8487jGUuP6SfxhsD0fL3A00\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXHQV0pbxBa03snEeN3DdzmdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTY1OGViZS0wZTRlLTRjN2ItOWEwOC05MzEyMjU5YTBmODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNci5nfxvHfyXCqMvDJUbMOYWIDC0m8SYrWvCQM3bcxLW5\ndscps0RHnqoqgoV5jsz3N4NuWSlW+G9g9tGbaljYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9VMCioOXK4WO6f9FoNpzEczp\nNVowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKfyC/hf5hRvGpFVgxjCVshYWfnXBE2kQeMqdAJP11OjAiBNN/+QdxmR\nUoJvi9d9hnqGUHDj56ekalXZwvJl/c0JNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdTGcVRRFzJYzr8N5FOW3HC3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNkN2JlZjAtMGIyMS00NzZjLTg1YWItZTBhZWFjOTg5MTMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWY0ODQxMTQtYTdiNi00MzQxLThiOTctZGFiMmU5NjMw\nZTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAXZPitRT7Wlr0HXjPgx2aFCk\nZX6J4N4PIjSh+lXP3hJXOsVV3kARaxg8gimccDzQGMSpfBz0niJsEr9GiaH256Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU88AmVi2awpy6a5yviV90FYjRQtUwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAjcSARTfejsBShuz/Jvxe0GuZOMTC\nB6wQnEvbZauprtwCIBCKOpL5a7CTqG15Q0TqundtQ+F7qe7cLFZfx6+1VfoH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6775", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6775` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAVoUmNN9RLOPa/O1VNwg5gSOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4MGYyZDQzLTRiMTgtNGFjYS05N2YwLTA0MWY3ZGVlNjVmOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg2NzQ3MGEtZTg0\nYy00OTI3LTlmYTgtODM4ZjlmMjkzYjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElnEM9WzqgQW4pLS4LMVVHk2ATVRk7gtUZgJdxtZFXKlxTGij0V9m9KpLJq0D\nGY7PcWMM+ZwJXbfleMLG149VRqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYkXa6C+17P/2neMnKX8JLowezFQwHwYDVR0j\nBBgwFoAUgbQQOP+s8hsFA3lsUGbOwzo8iMkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAkSkAeg14HQwz\n3cWiN7YsPi3tzsP4FXRZSuljD4PEsz0CIQDOLG21qryyj1susZjhYXKE3JLknGZz\nZbwS9wO45jI05A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeyw4v7j8D1VwlwZPIss7pSYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODBmMmQ0My00YjE4LTRhY2EtOTdmMC0wNDFmN2RlZTY1ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSznNg8c7ctm/GIEbeZqCQpyZ4yX6OTnzNSI24/AY37UWP\nF8of9D1/IsIjSwIu+me9/wUAJZYtT7zwHNEbt07oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgbQQOP+s8hsFA3lsUGbOwzo8\niMkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKvAFeRFv0Hlr0ItSAlMrDywy9Nb6gru6FAlh46B1QJ8AiEAy2owqEBs\n3GS5ePchZzuTE+7G4b7rmlNIsYCPtYXL+RM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASfTX5umzLFFZ+A7sxw4zwEyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg2NzQ3MGEtZTg0Yy00OTI3LTlmYTgtODM4ZjlmMjkzYjM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2YzNmM1YTYtODA0MC00MmZhLWJmMWItNDcwODZlMmM0\nN2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoOX6eWhg/F0UZvvgW7WEzwwV\nrV+wykJgQvP0iUnciKrzVtq3Gi9xSfvKOpdgQBsgrCBpx0kyt8i3momdjX8UfKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYkXa6C+17P/2neMnKX8JLowezFQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAqqIGL1wDfoCoQfLruJNyJsCYPTvk\nhwzVdF6MZkOEYNMCIBq7X5f+CX9ErBHGaltjJfwDrF7CHMrfsBn9EidWNODO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6776", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6776` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISARSGUDAd1gToBl/9H05DIwXGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4OGYxODQ5LTBiMjQtNGM2NC1hNzI3LTgwZGM3ZWJlNzFjYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFmODI3N2ItNmJi\nYS00NmQ5LThlZTYtNThlYTI5ZGNkOTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERdSHWhvfcbmjnBovIhypcVVsoFTk440tGlF3U8twYXTDTIu11bgFO1RLgzK+\n6vHZQWrNukYL4azsgvyfFdGWU6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQxMTGAGBS5wZ94DIz1Ql4QJWd1UwHwYDVR0j\nBBgwFoAUqjo8oBjAwoeW8uCtlWOfoiWJ0lwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIET8bZF8y6b94nRMmmmtyRIdJ1i7sjbpGRmI5gluXBE7AiBRDWZUyvdnJO2c\n9qprbR3XbABW+NQvLZMlLo8dYSUYGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASazvYX9lasgFQpBaedf/bPpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODhmMTg0OS0wYjI0LTRjNjQtYTcyNy04MGRjN2ViZTcxY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAp25tNUpsl6A1IDmtMnFl3+bHq8V3RMczHspBHPbmWojG\n6v+TNA99fy3XFT22avrNmHooorKP3cKJeZXLT2hMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqjo8oBjAwoeW8uCtlWOfoiWJ\n0lwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOs6u5tGN6R66Gp39qcJ+wSsJDhyR5xa+ogPSa5pZemeAiBhYcMC7jHa\nfn5uk4ucPnSky2g28s9ObrrVZTRQ5dwWzw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQl4yNHdM0F1qq8OKhC0LXbcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFmODI3N2ItNmJiYS00NmQ5LThlZTYtNThlYTI5ZGNkOTMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzljYTI5NTItNTZjMC00ZTI2LWI4NzctMDk1NjE5YjI2\nYzUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgcGKisKeAeVwNZC0Dt2xmvd/\nF9Qx0mduLkaG5QlUOT5F2gLmqaRNuxYYCyy4+XeE6Yj6Jpi5S5jvWc5rgPqRZKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQxMTGAGBS5wZ94DIz1Ql4QJWd1UwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA8Dk/Ts5mCY09lHsxnWWn20mmQJ76\ndilgV5cWcxW+b7UCIFW8D+Zkr072KuBdNGCrLXQDJGja5t1J7UNyvJN2uWAd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6777", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6777` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAU56du80xkorxGxMy2Xijnd7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NGZkYmJhLWM4ZWEtNGVjNC04ODM5LTFjYjRkMTg1OTI2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYyMmIxYWQtNDgy\nNi00YmVhLTliZjYtNmI0YTcxNTJjY2FhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4DW8DCZEoz/Cm3K4WE773S7Nyh4uYc3/r8nhi2O1fNMXDfckb16m4NOLvBUZ\n5CbdMJbaB6aHJxNwf8L2XWvd16OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcjHrRgrH0UiKRGu5Tr+hEFVWykwwHwYDVR0j\nBBgwFoAU+auULIC9qM0Lcr+qflao51to6XkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD+AckqopT3MoP5ojYnfd0kG7lkuVzz1/z6UJORfMsxCgIgS3ZxLjTdkzLU\n6xMSCd3AJzwWCGSpDsmWEDi5o6rw6OY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATIO1cvoh+UtzkF+Jv5z/k0TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDRmZGJiYS1jOGVhLTRlYzQtODgzOS0xY2I0ZDE4NTkyNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFuTnVuWKUkmJeKqLNOdlGzxhF7fU2iFgMQP2vuGom78Ec\nbLVnFW0BKwZXl3vSMQqy5w7AlLge23I0L/e90oQ1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+auULIC9qM0Lcr+qflao51to\n6XkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMmwrq6AEpBltm+p/iJGTEp9Euf2irRmM5bt8MFzz7/AAiASCq7KzZhJ\nN+ety6YcpZJlzn1lNNI17VBqPcKkZvaqXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAealuRhneWTABFVduTdFDNsLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYyMmIxYWQtNDgyNi00YmVhLTliZjYtNmI0YTcxNTJjY2FhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTk1NDhkMDYtNmZhYS00ZmUwLWE2YzYtM2ZlN2RhZTIw\nODA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERuEjvCVuuJa6EWpLaUr1yjl/\n5TBdTlpvGlbXHyfM7U5013INGuJ346Hu8TQGL4zKx+Zx7svmI4ZbaYPq5UrafKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcjHrRgrH0UiKRGu5Tr+hEFVWykwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiASKhujNmTN+65FuJLaWV3MMpP/UoKJ\nPku+KUynIT1akQIgNgttk5Uh+OSFNXYE7vPulAflzB+N5kwxdbPwH+IvM8s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6778", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6778` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISATCCBG3K/VMs8UQZJt+ssI/VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4MTA3Mjg5LTc2YjUtNDdmYy05NjBmLWZhZjU1YWY1ZDdmNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZhYjlkMmItNzEw\nZi00MTZhLWJmY2EtOGEwNjM4ZDM4NmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOko0Jb6xOiIfCZiTfrRk2VPyYbkK1x8krATl3kh+ps6uy6OY6o1Lu4RzOxYj\nODsFDDiyIV8PjQd5z/JNsGeJ9aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgrI8FP67TFnPcyxhftNtlQZpjtkwHwYDVR0j\nBBgwFoAUAb8CWWFttXJ1cKST+0XkDhpIn3swNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAravLBo+cbR7+aphW+dPDsfkybjkZA/kt1K8rcbbw+g4CIF3kx1D3xMJY\nq6ywvnEKWqMO/ojkPreVy3jfCc37dFyv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcwY8HWQogUQdK6lHT6vbZL8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODEwNzI4OS03NmI1LTQ3ZmMtOTYwZi1mYWY1NWFmNWQ3ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqh0C7qGbKUMsOYOIHVgsLWJaKLFEaIUR2MNpcJEJF8W1X\nA56734DlhmiKRNCx6ARX0zE1Of+c2ZqDAak3xc9Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAb8CWWFttXJ1cKST+0XkDhpI\nn3swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIAd0NOmiPp71ob6XqokY8FVndpbuNyIu21yEtdnUWHnAiATJA1M+IwC\njn7CF8zZsxOBy1oliT1SQV2hCOiP1jpq0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUSv8C1GXgitnFr9AsHsqaIPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZhYjlkMmItNzEwZi00MTZhLWJmY2EtOGEwNjM4ZDM4NmM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQzYTI3NDEtZTMyYS00NWVkLThlMDEtMzQ1NDRhYmE0\nZDI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0G1rx0R/j2WgNPaBqHPmMP1p\nqECnepqaCAYEicE1KUfHcSU1ZpjrHL1DP5FPhFajDFG142Q+ydSn9OhUrPf2o6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgrI8FP67TFnPcyxhftNtlQZpjtkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAjAhH4oP1lHOwHXHRG++kl3J3UmFl1\nBfG0Eoix+FAGpQIhAIvCl38fs66V3X2szfYgNn/7qi4C/SUSnQOrP3M3+VIg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6779", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6779` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAfRFk4VdnN7xHgTxJdesY6kRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1MzE4YTA4LTJjYWYtNGZjNC05NjhmLTE4MGE4MzQ5MWQxZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ0MGMxOTYtZjZj\nOC00NWUwLThkNmMtNjNlYTk1Nzk5N2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgcDAuJGw/18ydTuDhqMRApi8RyJgsqpu+Mtdp9XbhOl450AWMJ6/Ot+nawsM\nLw2E4D6Xbk4WeIIeAUwDZSHtj6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUizoRtBkO6MhbXYM/BpEVhWDPEFgwHwYDVR0j\nBBgwFoAU55uR955T+HbScJnWiO+cGQH7unEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEApsMFOEThvswO6q30PxaSVtJf3mLSvpGrV8l/J0B9\nnrUCIFnxtY+U4v3cd5gR+TOIYasV/+REZJ/nMUZbEaGWvccE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe9PeYXu88S3+IZ3XHGzCupVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTMxOGEwOC0yY2FmLTRmYzQtOTY4Zi0xODBhODM0OTFkMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQirgczyskas5t8EN3Q+IG8a+FzkzrtgEcBzfEdUYoZKBQ\nvMiQ/4LQ9z4uEjJgezEcJ9GaC+MHfJnCPfh0usdTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU55uR955T+HbScJnWiO+cGQH7\nunEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFD12dV4GcH1rc8ylEAB5t2ZjolbW7HAHFwXJWJQqalUCID6q0Sgp32Bc\nI72l8HhPtY49e0lAon8d15gr/tgH0IjF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZNnMMGJYLn1Q4J0VERwL8r8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ0MGMxOTYtZjZjOC00NWUwLThkNmMtNjNlYTk1Nzk5N2NkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDE5Njg0YzktNzhmNi00MTJjLWE4MDktNTY0Mjg2MTVm\nZmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgo8kAZnxZofmCfRIyJHNOvSS\nAdgcEw0o/Wkinpq5aZEM1PmWPVP0EosC8wSDAR4aqBGYTvc5BNoirbjgACJzfKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUizoRtBkO6MhbXYM/BpEVhWDPEFgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBaZxsvU+8x/JGE9PNTmFHElDv0BuK4\nfzjd8i0PJylTXQIgM2nqX98BSpUe9cYUh5MnmwicU2jheAL2ehZ1rRy4juQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6780", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6780` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAR7DG+OnPyaRgX57nXNNjdApMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiYmNkOTYyLTFjNzktNDhmMi04NmRkLWNhNDMzNzA3NTU5MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQyNDBhMjktNDRj\nNS00ZjIwLThhN2YtODQyY2JmYzgxYTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElqUeu7WnJb/QCc+1knP0IVFhdJkCEw7SXHsqC2IFX0aVstYv/nq1xcZqeb9c\nNfZDhDH7w6vverM1Du5qDxcLUKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDVxwIcU02JlzIUgscRBK357S7tgwHwYDVR0j\nBBgwFoAUZq6sVieyzrsqE94U7oNoUVpWvEcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAYuUrY9L2kghO0HNN4P2ehSc9ztswYFbFnjLJNi65/\nJwIgZQVXKzf+xGAJnWm7+3utTHADnGwn8tcHClO/fntEDZs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcd1uls7hSf0xeyWyAFrgGQcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmJjZDk2Mi0xYzc5LTQ4ZjItODZkZC1jYTQzMzcwNzU1OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhbvt+DR3uam7l9KxsXdCGpFW3Ai1BJ+qmEhwzosmUigvq\nq3q0gDgKVXe5gkOY2b8QnPk1wUBK3cM89dZYKLq0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZq6sVieyzrsqE94U7oNoUVpW\nvEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM9HrxFHZfTQdw4Esia5Ra0xBfCgrkRaJNp4cklSfurfAiEA988hEy/p\nLMV0Hiky+feBQY77lfQWpVD5TiVmCMQDerI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUb9Xunh1MCIAVnukgeYbM3YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQyNDBhMjktNDRjNS00ZjIwLThhN2YtODQyY2JmYzgxYTk3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmRhM2MzODAtYzBlOC00NWVhLTgwMGQtNTIxNWNkN2Vi\nYWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXwYK5F41ZD759us40Z9yA8Ga\n1pUvAd6Cs/GiOigTlEzVPmG6I+wnZb+i/JfQ0xbvTvz0vWLl6QcksEh6YHQQ/KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDVxwIcU02JlzIUgscRBK357S7tgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA+mNicxvaPNoxmMpHDvBdUXbVW8LW\n5BW1NxTXtnIJ2bECIQDzOz5pnSw6ORQMcEqY0/T2S885sTL4UrBJmOoMHnugzw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6781", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6781` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAY1wezCuz29Uhdlkh4OhyLguMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiNjk4MDJkLTE4NTYtNDUwOS1iNDBhLWVhOTk5MjI5MGU0ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFiODFkNmEtNzEz\nYy00ZWNmLTg4ZGEtODE0NTIyZGRjMGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuwTVIfuhj8q1jxh5GaeP3Jq5IAMFh17JJ0qzVK7K/Ber6+8M1hVlEzVSfSY0\nAzN90gquCK6PD5JEB6gFJJUTm6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Gbl2mCOQEO8oQnpL69VO+fXqJcwHwYDVR0j\nBBgwFoAUg661IgoXjE/ygTFghSD/Mzsu0G4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA1Gz3ZvCiH3KWQ33X/90eHz6Nf4qn9CydgMrEZVI1aloCIFiP\n+6fCCaJA+dQBBNldr2kvhHw9mEuA6BAEqAOfJLbM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASKsMrMHUsnaeGcZdu+oJDFpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjY5ODAyZC0xODU2LTQ1MDktYjQwYS1lYTk5OTIyOTBlNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYLIs00CKB1To+3J8vLTFDqVpLwm4AHLsl6vPAAP3WkZ9+\nyzWbsqxxFfRrAJzsBiDiMJesaNf9LOy8x6TLdFO9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg661IgoXjE/ygTFghSD/Mzsu\n0G4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH1HINWlvVRxpzhcVmG/LNd/qQ1Tup9Hbwq1u3jT/ioMCIQCvdYbUPULu\n2LrYK8KGnp+6IEovvemTN2gVf9WHrHILQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASgH62/OeUf6mKbKWaWUD/ezMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFiODFkNmEtNzEzYy00ZWNmLTg4ZGEtODE0NTIyZGRjMGM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTkwMjU3MGEtMjgxZS00ZTdhLTkxMTEtYjQ5ODEzYjBk\nMGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhjnv5dbzxtl0gcGIysZSZEHX\nd9CtConnvgfLwCYYpHeW9/R22GtwZArQoT4pXxeh5EOycqYXaofBEZ/hW25ppKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4Gbl2mCOQEO8oQnpL69VO+fXqJcwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAn7bmS2+uqn1XARu8GKX/GYL782AZ\nunAxvphqrT41oO4CIFfGd9Ve/oKcC/3xJWIVz75j9+Gltk2euA5+9+kTJz8t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6782", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6782` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAcc1z42SqZ6IJKzfou5+KTw/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlOWIyZDhkLTUwNTUtNGU4Yy05YzFlLWEyN2IyYjg5MDI5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNhZGEyY2UtZTZl\nOC00MzIwLThmNGYtYTFlNGIyMzlkYThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXABeIhuVTvu9xEK/UphD1v+jyZVphrP9nbcVK2oN8dcE/H0pcB/lqXZuBtsH\nmuTN6RDzFCIIAjTnQYFwonyXk6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ8ads0Vr3Xug8DGpFPGpiGlXuLQwHwYDVR0j\nBBgwFoAUDmzuMelTXmhtCA+FvbO/fuAxAXEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAHmpDf9ralDSBbpLGsqrw+pbMOpmU6cSWF\nyGqAIAA/uAIhAO+hkzlJMgx6rS1HZo1omn0zsyATlPp69O7L4esA18er\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcmHjf+8cWTpFSnwA5AXcjNVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTliMmQ4ZC01MDU1LTRlOGMtOWMxZS1hMjdiMmI4OTAyOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARM02BywTMu+whyCxVF6x2qq7C6VMaPw1Wv7Q4ZA51Dql0J\nIsTmLdst5uQbuyrHIGgKTbR/LuDSo8t7mSDbGWkQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDmzuMelTXmhtCA+FvbO/fuAx\nAXEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPKivIQqA700fB0A02YPs3tsrKhnrVcF24TGn25u6sB0CIQC34+WgfBb8\nyWb2eoBZoQ/2VI1+1ULakwsBu7ViQnKjHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVrMURvcgLXsdvSBxiKoiX/nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNhZGEyY2UtZTZlOC00MzIwLThmNGYtYTFlNGIyMzlkYThiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDBlNTRkNzItYzdiNC00NDllLWI2ZjMtMGJiNGFhMWUw\nNmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtKcHZVNJAyYIGd8uB82FFfyw\n2wndngBEMyjHvJ+axeSdulCJQGf2mNRED+vcQuLnqBIxLDqLUZtm4QSAQWfxyaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ8ads0Vr3Xug8DGpFPGpiGlXuLQwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA/JNllcRVyzKee+3gIsVg+RQLMgnc\nFxf3EMQPpEDlMKICIB2vYpM13zG29V+Z/WI8Q44av62g+147QXFEIwbfPhyn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6783", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6783` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAQAygQqvyyY2rP5CrSsrIhk2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0YjdhZDk2LTZlZjYtNDc5Mi1hNjlmLWY2NmQyMWQxYmE0YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZlNzFhMDQtNThl\nNS00ZjFiLWE5MGYtOWZmNzZhNTE1ZjBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1suBkrkPF92+QAgRMH2M4mWbOjEIOIOycxa7sZa+xyEDKM8yfNvhsa6L2U3U\nT4rJU8a+TtCuOilmVZWC22CWaKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5mgnOvf2hiX6tbhhzKZANTpLTj4wHwYDVR0j\nBBgwFoAUkm7bCfv4NkLNGWT4ZdzeZRDYzPEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBrYyoWOboFtmgntQwYx5RgIq64F9qehxwK\nk+5lvZku7wIgIe5Lqm7jTTr+DX6HoVH/ZcC+c4AIgB/+6JzlUbH98Fw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATjwb92d7JfSkV4UD/T8YyPvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGI3YWQ5Ni02ZWY2LTQ3OTItYTY5Zi1mNjZkMjFkMWJhNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbupACgV9hK3Lfl+VnGbgSaR4NvFkia/lcpOSPH++kJWM+\nRsZBNX3gY5eY6Z/bcv/pc+Hz2q6zU8DoKqdIfpBPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkm7bCfv4NkLNGWT4ZdzeZRDY\nzPEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGqiLdEqM/ZkkXqEQPm6cToYdWbdL2HUpdgJv82LuRYYCIQDY3Y9tXF0O\npiQiH9WILjUSRlFZfRhYwRSLb3t5Rjt7Bw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYhp5GIKJEI0LQ4TubcePwc+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZlNzFhMDQtNThlNS00ZjFiLWE5MGYtOWZmNzZhNTE1ZjBhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYThlMDBiZmItZjNhYS00YmFmLTkxZjQtN2M1ZTU3NjAw\nYWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESR/Ti0SbGqLLKTBm5M53GugN\njNjdhIvR3xzJgkIy1SNcmB15FYl4trVg1VGRFJdqoMUDOYVg3cLCK8YxeKz1gqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5mgnOvf2hiX6tbhhzKZANTpLTj4wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA1dsJm7SEbSKYAiJDABlcosjomTT/\niaaNMjXJx/x6PN4CIQDO/ODl6fGdb/1T7oigOET0d38pMwZHhO+PxF0c1RCFmA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6784", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6784` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVyMbBx/AqP9mYVp0EZFyn0QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkNTQyODA0LWFkMjItNDU0NC1hMGRiLTk2MmJmOTI0Yzc0NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdmNzk4NzItNjkx\nYy00YzNmLWEwMWMtOTc2OTc4NzYyY2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDr1dzP/b9pnIjWhXRHOYdFrDtegQTxEqUQKCPFNU4jCHamWBor48tgmvP0Q+\nVUSP5dGkq3rGK4GN0OiXqtgzn6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtsYGYfbk40HkiP1Ne8z1BkYBZNIwHwYDVR0j\nBBgwFoAUbqoNKk//6mCdFFMgQicvkJ8FCxkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCKOhhxXz4cGZHiVrHLdt9hIBD0\nD+XA1bo7r8bDeTYdVwIgXMyYcs8nJgD5yXXSLph235eYeYIMyvPaF+5nFdRs5/M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWexbdxOEROvVHdqiyUCnmX8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDU0MjgwNC1hZDIyLTQ1NDQtYTBkYi05NjJiZjkyNGM3NDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm7zQQYe8An1Z+r8D4B3cTMMBMQ0QX1bjsJzqnQhTg3+nT\n0QFRF9oZ5dLR/Kd0mT0XS4wFiOgkBR+WunT4gHXZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbqoNKk//6mCdFFMgQicvkJ8F\nCxkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKj8QSxvMOkAFaF/6vN12n7bLhkeSyXi8RQ+2hPYEiF1AiB5d/RxZlzt\niikwtcXEsucdSQptjPQoW2pPrdUQbHsyAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXJ0khRQIcxALhvgbR8JN2RzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdmNzk4NzItNjkxYy00YzNmLWEwMWMtOTc2OTc4NzYyY2NkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmZhYjQxNzItNTlmNy00M2I3LWI3ZGYtYWQ1YzJkYWRh\nNDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj846COBLOlkROOZ1DfPb3k8o\noRt++xWUuqnNolQKrWNtGDarpylCFxN7D4tOCoHJ3aotNJkFX0GMC1mhUoPyRKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtsYGYfbk40HkiP1Ne8z1BkYBZNIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiApfc6+zAhqWGwnwO0Jfhrm9Da+5tiT\neSnd6jAN9ssEvQIgS13Oq8hLbIODCnT5hGmnTW7C043nLxAAxAqdKZzd31w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6785", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6785` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISASVevTHuvYNzTl9brbGACoF0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkMzFiM2I5LTU1OGEtNDQ4MS1iYzBjLThhNzdiMjQ0ZWI1YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBiYTA0NTAtNzhh\nYS00ZTBlLWE5ZjEtZDdiODBhMzZkNWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBFsuGvVpHvgiuVYCW07faUUHfl5sHx3TRO6du66+1j7PYi5lA0KfzZ9WjZtq\nRpoIh6j5xPCKOh/um2nB9vokrKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvNlVundrxHzJVSmXjdl8LF2C4ZYwHwYDVR0j\nBBgwFoAUKeRyJ8s1Z6/KWOQ8fCj2mrTSz9swKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJ2PGRRg\nOP3dm1VesvBAxf5OU8iJypqKHR7P7En6TCOVAiEA7G5XuOqpdi4PiN6ioNHU+doA\nA7J64P6AEabkGz+Ddgw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeRfuYrydVfS7QXcthcwRQswMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDMxYjNiOS01NThhLTQ0ODEtYmMwYy04YTc3YjI0NGViNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfHZ34Qo9FQu35F42fk0JyH+P2E0Eh9L6BTc1DmwM3kQ59\nNN+HrJmPYtRx36PjCy+N0IKtgKMf2/FKEeDCSHgBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKeRyJ8s1Z6/KWOQ8fCj2mrTS\nz9swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ5XSQAtYeVO+t/a+XJbBMKMw7+lShSAF8qjtpMRBgDCAiEA2+A1WmAA\nY/WPXrRRvQa40EPulrCFkUqeQsCkgLDvAVk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAR2/6C7w/mkDL9pjXiqobaVxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBiYTA0NTAtNzhhYS00ZTBlLWE5ZjEtZDdiODBhMzZkNWE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmJkZjAwZTYtOWY1NS00MGRjLWJkMmYtZDk3ODczMThi\nZGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjTBE7Vk59t75n2hNWlPbNTC7\ndg0IHO6ZPc858yY8mRmll9Lfr3kkhMCppVyGN4qfi+oupscJMiXtjiahxFHmKqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvNlVundrxHzJVSmXjdl8LF2C4ZYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAl3Ix7iYcNlMUW0K73v/rf2dq/qDc\nmBs05om+wJmsErgCIEopvxRJ4T1UwsnMpu84FWNHuDYLKN/ahJMjZi2oS506\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6786", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6786` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAVoOps2LN7qSx0bpO2TdkXZpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNzBiZTI3LTEyMDUtNGZmMC1hYTBkLWNhYmY2ZmYyZmU3ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA0NGU3ODEtMmQy\nZi00NTg2LTkwZDYtMDNhZDU3OWMzNjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBXGqa20MyFZ2GsuH83uk6dReg3tNF0obHGhdOWY1MelrEhEqnL5fFWwhttZ4\neP15R4uMQI1/wxSnLc8FpPTAoKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdByc1WIG6HcygZa7Mwrte0jTEkwwHwYDVR0j\nBBgwFoAUOH8ys3zppS18BTcxfkMFCQzXVJswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJbEukii\n7nJBvwGbpJ2f55NDsxv0p6ajnf2+ZIHL6x+rAiEA+2cr+2bwaBCdKs9zt30ZRBVH\n9+XPwFiRNCNrjKtS0tc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZq6ROgRMcDZXmFbUlu9eq/CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjcwYmUyNy0xMjA1LTRmZjAtYWEwZC1jYWJmNmZmMmZlN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATd4d8GuZsgPZmmyzeqhAFQDrKz6NZgl+nIjCDGkGlllh1v\nDFa7bwFFfW/OY6nxRN19MA7nqWaj0B6+A7HjGCFHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOH8ys3zppS18BTcxfkMFCQzX\nVJswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKT6qljuPLqJ73VrsUE7Whf03hn6GdgnaaKGQDCb9DHRAiEA//VXu+cR\n2kdCHV5E9cD7U/KiMR3IG3MYPXrvwRpR87g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVuJJQXBVNJ1PcKxD8yEfrXgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA0NGU3ODEtMmQyZi00NTg2LTkwZDYtMDNhZDU3OWMzNjZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTY2NmUzMGUtZTg3Yi00MzlhLTgyMzQtNjNiMDI3Yjk5\nZDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELQA9UFy8fFMJamYMkrIX2jzq\nEMt4mtD/vVrYDUdR7uKTxek/FUYxstpYfgzzhJF8j0kJq9Jy5f+rWutZ/BnjP6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdByc1WIG6HcygZa7Mwrte0jTEkwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAxZnZtuFkzvK2FvkfDzOPufLFdQgk\n1WU6W7Q6X3gdLXkCIQCQQSDq0AQXUu3hjto5zwwsgAunQmvK/SBbaIcH6muPaQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6787", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6787` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAerESOCJ1okf9KP/ZISxT3yzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3ZmY0ODU5LWFmZTUtNDViNi04YWU4LWUzYWY3OGRjZTRjMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTgzMjkzNDMtNDky\nZi00MjZmLWJlMGUtZTVkODFkNmRiMmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV/6xHK1ofmr8Grz3b/2KcOJB6YtrKLxojQRxU8wo86DdA3q3/E6jaiWzxrw+\ngmriJj2BFbcmzC5TP5XXE8c3wqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ4Zv3zUNRQU2E4ShFAF2AqeZhVEwHwYDVR0j\nBBgwFoAU+RxS0ghqdSBR7zMrxt46q1r4yKkwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEWi25MX\nb8+O/SnQ1yQEdI8s3fELMp5aVZxPZXDGrgu5AiEAxI0p9aYU0NVOi9I7sdKhmjcU\n1uNruL8eQCRjNx0VoE0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAatMC08oORF18oQz9V+0OZIMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2ZmNDg1OS1hZmU1LTQ1YjYtOGFlOC1lM2FmNzhkY2U0YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARh8l/wlHR0rXSUXHkttA0Fv2pP5shi7anTm/B1yOd/VKdk\nB+k5inXW586emmmY3Fim3fHNyRgERx2CsOLmKpkeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+RxS0ghqdSBR7zMrxt46q1r4\nyKkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANlgcEKumd/z8VIfVixMelURt5nrF5CZ98DvMp2ERZfwAiBT7guLtUl4\neJCGR8eBGJdj1N7jXGeUFn0AhQVQZbcBAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWbrqD1C2m7U8eHG158LopSUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTgzMjkzNDMtNDkyZi00MjZmLWJlMGUtZTVkODFkNmRiMmNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTIzOTI4NTEtMDEwNS00OTljLTk2MzktZjdhY2FhZjdl\nYjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERhvD5Q5Iabr3whbxMh9XYtR/\nh4weZLbG+BFzXHYemgCEIBCv0AY6Gzt/unG4n2Wp1aaUiIUfSJ348H75hRduGqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ4Zv3zUNRQU2E4ShFAF2AqeZhVEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAo8mDosuhzY4xGb43goPYpStndAAm3\nygiTxwGkbp1otQIgd6dsm5VqSw46f5DJ6cdcsoDGiElUUVL8Buy9/3t0l2A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6788", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6788` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARwZiDX7AnxnkOkORR83hH3MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZDEzODFjLThjOWEtNGU1ZC05NzFlLWM3NWE0OWYwZTBiMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkyZmY2ZGEtZWRj\nZi00YTJkLTkwOGQtNDljNmMyZmVkYTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFuKON7zm+vfFDQ+3e5SN6lBIHsI/g4k7apPc5HNmyf13VwqucBaX/4/krI+m\nJQMf+i8JjkmJbMrtuIXmZbW+xaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrqvF7l9P/QZG0r35khzJlFBnVPwwHwYDVR0j\nBBgwFoAUWEj+kwLNvlPzVPQ1Kh6L+93WLIYwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCcN8La3Om4hvnOv7Q6RMt+Mw4NWtvCIQQaF9x9sd0uTQIga5TevTSI\nHoKHAiuvKa801i8QOEtCeeKxHUz0efVPvWs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9isoFLHGpTv75+K/GnPjtDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWQxMzgxYy04YzlhLTRlNWQtOTcxZS1jNzVhNDlmMGUwYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARawnx/nDkvkzKg659tz7H4aAqsEzg04YWN/EcM4i3judKW\nEi7LlVjTIWMF4i32XGWqk32Df8pZQ2ieuBkIgN35o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWEj+kwLNvlPzVPQ1Kh6L+93W\nLIYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC+CB16gpY8hE07WtNtWwtayPuhfsAWVEx2cYH2DMbTUCIQD4/d6nvywP\ndQ1xdZWihtAUJcDO/pN2KpV0lurNJd5r2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfArbYfufJPtXU25GUY0PDpIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkyZmY2ZGEtZWRjZi00YTJkLTkwOGQtNDljNmMyZmVkYTFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDE4MWFjOWItOWE5OS00MTcxLTk0NzQtZTZhZTRmY2Jk\nZDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjDcA5By5t6YeNqA7B5DVblD/\n045jGmUO9ERrA2k0UZkHsWOHRUqK7d9QTaOZFKbNolMqLov5/CvDgaPCTEDFvKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrqvF7l9P/QZG0r35khzJlFBnVPwwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAV410WfpiRN19AvfzmQBXPCZyTYzAk\nxAkdjxGsz6+TpQIhANK9Xw6QSCHzixSwGHuXKsRgSjNGfxzNe0MQHPhD+n/h\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6789", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6789` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAZXIKqL7v6wfOapQYVlotvYAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNzZhOWQyLWZiM2EtNDdjMC1hNWFjLTJmNTFiZjg3YWVkYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzU0MTZhNGMtNTAy\nYS00ZDUyLTlkOWEtNWZiZmYyNjVlMzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN7ZgPq4jF+8oDi8AyU1O+r/uB4hlrxkbwuJQaV/9VDUxIdGHECUbrEKd2rIZ\ny1+ULeoBe+nhHT3I9EBqAdHaUKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURGN0Tc5FTjRM4oYzvSqHe7hJ4ckwHwYDVR0j\nBBgwFoAUZq/IbdK93vdNgVeUYJqWhCgttNMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIGZ/pa3zkdjKPZSDMLBPzFoTEISVXYPyjScmumYb7kf5AiEA2y0DZl46\nVeNz6nUYM3TMSHyIuvB0DEtmm0sM19u+SHc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf4AGqpBQXEWxawqZ7Gxg6kwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTc2YTlkMi1mYjNhLTQ3YzAtYTVhYy0yZjUxYmY4N2FlZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/+CgW6fw2QQ40XMomTLixli9Ik5oSDdG8odEvEzdSPoap\n6H6f6w4ls/hgZ73AI5gu4QfBOua5741HefEv718eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZq/IbdK93vdNgVeUYJqWhCgt\ntNMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIga/EWkZM2B8HmVHtddD17as8QhZ9tj7FbcwNubzNt4KQCIQD0XVk5LKCC\nqz93S7ZlJhkA0i7+nPs3fAuXo8ozXop/IQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATWrsfJKag7DujQhX1yie5lcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzU0MTZhNGMtNTAyYS00ZDUyLTlkOWEtNWZiZmYyNjVlMzAwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGRhYWM1M2MtNzJlNS00ZjNhLWE2Y2YtNTQ4ZDY3YjIx\nNTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiv1VKdpnkJg8QcDHC7wsOKK8\ndYn3SeFI8pt0x5Pp3JodDun70DObeLlfgj3MjFhxsgsM2DsVzuWQT+a7miMWDKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURGN0Tc5FTjRM4oYzvSqHe7hJ4ckwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAeTvwRxf83Pw8fMN+VSBIP8VfP4C6I\nfMlwGamEBc8sRgIhAMZ3zgW7ndvTgSjmdmlpGQ+/BPQ/mO7g3hrQ0J+Cd9eL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6790", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6790` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAUd2ARtirucch0LrwAvGluQMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZjY2OWZmLTViODEtNDY2Yy05NGUxLTUwZTRmYjliNDRiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFjMGUzNzMtOTA2\nNS00ZmZkLTk0NTktYjM4MjMyNmIwZmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5nmJGopOrkL1pvvprnXl2KbV5q8W3Re3qw3XYMjJySO9BNgV16vUpWsW4hc/\n4JHQZS+9KcdReP8YzyNESp+6cqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUktul6vKNVXp+EZt0AU5DTDMxdMowHwYDVR0j\nBBgwFoAUMJE7XPf9FRe40tL07zdgWq5mV80wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQDA7pZRUQ5XVQXZgoGFYtg4YlOYFtkKMJYzhhdjAN89ogIhAJ7PH7Ji+/RDfccN\naQYHWnb4kwJfJXGgfawnl+YrOc70\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATvRIzAjsIVVbtsxpp5HuSKCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWY2NjlmZi01YjgxLTQ2NmMtOTRlMS01MGU0ZmI5YjQ0YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASek0oopPfYgs3jF+XcKekcSdxZi7xi5X14xYrurKTFmzkO\n+gTgn78fcg/ghtDxqMETLY+///jNVoGenLBeM8mWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMJE7XPf9FRe40tL07zdgWq5m\nV80wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLjfmGzwCGr2xBrZ1yDxVH2p5bbrNZ3ZFPNdFK+oRYbICIF13MZ/GSVrY\nlWQtzpnJQ1BMiC4g9nmLZXc8IO4k/138\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARGRnb96mARZDl1mZ3Iy8Q/mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFjMGUzNzMtOTA2NS00ZmZkLTk0NTktYjM4MjMyNmIwZmRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzQ5YjI4YTEtYzMyNC00MGNjLTk1YzEtZjAyNjNhMjQ1\nZTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtKXPiZNeM4+vFIcof2z5Gj8i\nB3GqpWginR0vp+NgK4MBbevCk98lRqNYLzeTJkA4hxtK8r+bFixgZNBZv30tLqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUktul6vKNVXp+EZt0AU5DTDMxdMowDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAi3qNOL9UeOKjfbby/4aXt0A80ezw\ndI37XhseHHOvHR4CIQC5DoecBvUaqp0GatUesrVOPQs2/2IvA4Ag6HH7c1naBw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6791", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6791` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAf4tOLobMyey/7uCEMZBkYkBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNTlmYmEzLTI1MzktNGQ4OS05YzY0LWFiMTcxZjQ1NWExZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdiNDNiM2QtNjZk\nMC00YmQ4LTk0OWEtNTM2YWNmODE3MDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW71DAS/DWveXfG4pI6VresEX8uRFXpzCu+Le8P+sdmqynl5y0h/wKtSkqwml\nxxUMdiLN93Og8T43Of16Jm5nMqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDNtoumO7VTle0dQKnzSY4teJwzIwHwYDVR0j\nBBgwFoAUZXvAkEYo6ZPF+/kbWHgBp5EIwX8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIAQc+L7NyVeaAz4QtnESnH0qv0hTJDfSu6xWNOxpw9Z2AiEA\n7aT0SALMDrj/t4TOwvbMpaMK6mhX0Q6w2+V7s4U0+4s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe01CajZ7tV0KcbGrIJPHtSTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjU5ZmJhMy0yNTM5LTRkODktOWM2NC1hYjE3MWY0NTVhMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyuJZ5IdrQwfHhxphjQt1FAED/vji3lQN1dtNKaouUpTln\nB+AEzlu0JaU4Ru0rM2gB/1GMdb/x8PIhrCIdo8D2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZXvAkEYo6ZPF+/kbWHgBp5EI\nwX8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKZeN5SZu9tSm6/LFXkNoWotQ/Bf13R4ukUm9SYeuvGfAiBgAKcO1Q5Z\noND/HxEULlXWb3qJzaf2JAgo9Bva1GHp+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaOM6w2Tq6dthwO6g2W9m0CEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdiNDNiM2QtNjZkMC00YmQ4LTk0OWEtNTM2YWNmODE3MDljMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmJkNjA3NjItNWViNC00ODkzLWFjOGItN2VkN2IyNjJk\nZDFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKw3Zph83p8j3o2YiW3gr8GFw\ngsQX4dKC2jfw5ZHVslYQFAfWnoz9tIcWiLAOw+gNWpOCih9/cj/g+keJdwL4GqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDNtoumO7VTle0dQKnzSY4teJwzIwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAvkeRRBbyfZ6F0QBFgrcmxA44tuYo\nctXUyEah3tvjPVYCICoCflOKPgxGxAz2R8WVx5vFjnD8VyWNf3Blf8Aittxg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6792", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6792` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAXX6njGzbiSqyhJN2Zy35nvjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhZjhlODc3LTBhMjktNDdlMi1hMWNhLWViNGYxMzZiOGRiODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ3YThjZjgtYWM1\nMy00OWVkLWJkNDYtZWY2YTM3ZjIwYzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElKlutXqHyrla7aUlIIc6PDdEDDaAD+f4YP+jJiCdwjLR2MzSwXHkSKzySNPm\nzRGs7mBEF/MJl8CrUoVBFAXBrKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU38DgJIWrUFndWuX9BqfmamrmsycwHwYDVR0j\nBBgwFoAUnCcw6q1oc1X279kCexuf1WnaeFYwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIB+gjzPfcDpGv1qqnhwM5thwPdjnZMJbn8XcIrydHXpJAiEA\nxCiTrRc+teku1r8BPOydb5kzxSne/mvW8MTIAXfig4M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeVrrdL6KxYI7fsCAk0nEf54MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWY4ZTg3Ny0wYTI5LTQ3ZTItYTFjYS1lYjRmMTM2YjhkYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATltKAf3CYdbx06CNSoKzvj9OGRrffGwduIEeTSRXm3uLY+\n7i6Og2zbZB4LgWgFAmI2iR6RBYAztcad/UpHXurwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnCcw6q1oc1X279kCexuf1Wna\neFYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDASGlWYnKzDG8CcKo/VsEnJ1TJvfsgtGFUelVNe+CW4CIH7jI9H75vsL\nO8bPEaYRH/yA4NBEq+l9gBhrRrdOJVKA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARTLcJlWcodMfNqY4hq9qQivMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ3YThjZjgtYWM1My00OWVkLWJkNDYtZWY2YTM3ZjIwYzI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzY4OGE1MGQtM2UyMC00MjE4LThkN2UtZGJiMWI3OTI1\nN2U0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENhmW6b79Qqi23wuk5cNOGdsp\nQToNgDitWjvWy5szbaPqReULSBKf4IE4YuTglokeTmUJpRsD6bed8y3MPHYjLKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU38DgJIWrUFndWuX9BqfmamrmsycwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAtt74LY8BJFhyWUCg2Ltk/d4866Il\n9EIZGzmBrb2uQ14CIQCpGzPLFqapPPQRYdCk4EBjLkWGGJn4BjeWxbp9ZTxcqQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6793", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6793` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcZIJnm/UIWNn+GaNth/5ANtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZTgwYzNmLTA5MzEtNDU3MC1iM2IzLWZlYjllZmVmNzdmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQyNDdhYTUtZDgz\nMC00OTJkLTg1YzAtMmYwZGNjMmJlMDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhUBG22NmjDElX7JGiPMJOcsiSbq9SSZiFGdqze0V9/hT7bkQxdw0Tkds/0fJ\nY5ssXRH5KEP1/dzlVSJbh6Y6tKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUERn/TFlmN0yQTe8iMKY06qlW2/QwHwYDVR0j\nBBgwFoAUkMZ0JjZv7CsTgp/bSisQj1VjmmUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCICyrXwm7OOlK\nz5yncKCr3v8Uw2D4qYcWOI2cz+mUbEHYAiEAxX21ZeSDzjNBKBVbe1EC6acNl0PV\nKi7EfwW5NA+opKY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAehJkMfMs9bh7l4XLX6ULbwEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmU4MGMzZi0wOTMxLTQ1NzAtYjNiMy1mZWI5ZWZlZjc3ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkJ5gTj3c6hQJFet1CoJcZrslslSDXrq4jlkBEyVMY1dQG\nbNN2VsH+InofKtCBOQ9PiRrZLtpSurO1QszWgqwNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkMZ0JjZv7CsTgp/bSisQj1Vj\nmmUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEid9OTjRmSbnfY6TzvMV0jPz2W2UNsC+HRMi3DtvqdECIQCnsQ5y1+ac\nqMY5Fmh+Dh9lPkfsaeYPH4GCCmii3GIK1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUzAupNxWTavl9kOdPlSGz3UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQyNDdhYTUtZDgzMC00OTJkLTg1YzAtMmYwZGNjMmJlMDhiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDgzZjM0NWEtMmExMy00ZTRkLWEyYWItNzY5MGEzYmVk\nM2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELr57z4j+IWPk4g/BKxgUMBj2\nxtPW9stq4Mvc5emHabssAvCMGir23gFjbYrfil/1tHaKBUem/P0fW9HNUVFrwKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUERn/TFlmN0yQTe8iMKY06qlW2/QwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAsWWBcFEVjp5NH9UGTwhswpBu0qw7\nsIwqzPLK9sLYSrsCIQDr+cbSYulmF+Oly4Jdkn0NuS+ANDnMuNE7hvMug0hIKQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6794", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6794` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAY3lYZ3PGJkfVLCA4TUQEVpSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwZDAxOTQzLTMzNTAtNDFiYS1hOWUyLTMwNDkzZWNjMjFkZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YxODdmZGEtZmQ2\nOC00YjdkLWJhM2QtNjMzMjIxOGZiMDE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhnmKZ6lwkMh+PIYZJt739q2zIObhEtHC9KFWhUSPVzLQ3bJ0dD9gYpAA7q7V\nNzH6i2z9TvoC2U/JpXV7OVN0Z6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwldSetnXBehdE1w0b5fm8iwcSpEwHwYDVR0j\nBBgwFoAUkuhb8a6MZXjQYqYmvN/P26kksMgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALBdZ/r6ebFSYmAIOCxUmDX0AQEKuj7xG+OauWMk9V1iAiEAw4gDW3pA\n/kbtWBtQx+nDtcu+8EnxNMWbpCz9bMYyzqo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcwUE18pHEe7dlhgF/B9advPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGQwMTk0My0zMzUwLTQxYmEtYTllMi0zMDQ5M2VjYzIxZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARo2qg7LwUX1kpDQiiiSyCgoN4XCeftuyPCNRqgQuYkBbTZ\nz0v6JrApCcntzdShokORk9zbLrWEZkFObr/dPdZlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkuhb8a6MZXjQYqYmvN/P26kk\nsMgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDLSTsZkkdz4+ZiNRtefLXxjNoEnhPyc8LoPT7l1dUvICIFvEtJ2Ru8FB\n8bqoBx82Ii92sWNMUqv9XPIETcT2vzji\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUyT+EUdL92aYPH8uVuMWYzDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YxODdmZGEtZmQ2OC00YjdkLWJhM2QtNjMzMjIxOGZiMDE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2I0YjVkNGItNDg4ZC00ZTU4LWFmYmYtOWI5OGMwZmFm\nYjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEW/JgGEFG7UqP07JoxH21k+NC\nfXw3a1uEAX+fT5nrwXe3L5OifNbgdC2qdg+QrhXIvtHoRiSNbmgJxYH/AL1S+aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwldSetnXBehdE1w0b5fm8iwcSpEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAv8GhDbHe7zHnul7dFw0HIInKEXV4\n66/UM0aQxA7c/+ICIG74PKUiSMqwaltmiaH7wSMk1ELjAGCUekf+noJTqEyN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6795", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6795` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISATfhZ6O/XfjlbxF/IsYcOXyxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3NTkwMjgwLTIyZmQtNDE5ZC05ODQxLTNiYTM5NGM0YmU3YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFmZGIyMGYtN2U2\nZS00ZGQ4LThhMGUtYTY1YWVlZTQ2NzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEngGDynGxwvcum7scyXuhbSwyiUr3O+eF6Nk6LedANvz7V7DhskmN1cHisBax\nKki5NK1csfr9Wipism8tis0ByqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpTEqR+5qyMxdnAPn8RBshWrzBm0wHwYDVR0j\nBBgwFoAU9wRz7QuDlfIzsyPbgqBY1cPalw8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPtQaDQ7nK2OZa+ffQ5sSwg13+2aq6Uee6JddFjrsm7OAiEA3xGRj/w7\n6BUpjNpa7dixX7aXdVSIjJQMU8XOdNXFPsE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcvOLVrxV610KS7KfoLzzXyiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzU5MDI4MC0yMmZkLTQxOWQtOTg0MS0zYmEzOTRjNGJlN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS12SCexWVdhKJnUR7XFIDCpPtWxLu11MXpXaIuBSOquPNP\nGe5XPsnXV3TCoMVHvk2TryVkyN0DYV3ZauFExWcso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9wRz7QuDlfIzsyPbgqBY1cPa\nlw8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBU+7FiL0k0Kdyx3rWLwAbIIX/WQEYS49snCTSfHtLpwCIFfhHUP2KVky\nIahYwx8Z/L0AWQwZlqHqLU2k7pnWFwUk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAY/QzGQD+6bt/R8pmOJC6LS6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFmZGIyMGYtN2U2ZS00ZGQ4LThhMGUtYTY1YWVlZTQ2NzIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDEwODU2YzEtYWQwMi00YmZjLTkwMzMtZmViZTUzMTgz\nOTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEajlwO+WZOoGtAlEhiN0dITkZ\noly5s6jM6SeL7a64ZeSBreGfHk5KahK9yAF2Fv38xDJHV4IOotA5dyk/XPFKH6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpTEqR+5qyMxdnAPn8RBshWrzBm0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAWG7ti8g7W66N6szb9GaBn0D8ak5nn\n6tB6TP51xBSQfQIgPLUjDn7xp3ATEobEMmxxPvMpi+wnhIkXobftngHdau0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6796", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6796` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAYvCyDY6F3yvSelz7N9T0njyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiYzA5Mjg3LWRlZWYtNDAzZS1hZjM0LTY0OWI3YWQzNDY0YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM3YjUwODgtMDNm\nZC00ZmQwLWI5YTAtMzA5M2I3OTIzNTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXHLuIRcpgaKVQRTJpdCI3JL/Gs8QPfmlPBeOWcYqEMAlbHhLhVgKK3bfj1pw\n75uhVlKhu1ny45s0oolj0QDwsaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+iD/hbnlgsao+Q0wWoU7NGL1o6QwHwYDVR0j\nBBgwFoAUgb2kluiI3cbCdwtBQK5aI/BJWRgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQD/58jbTgUPzz3upF/8VQRIbK7LgIrDJJuGxx4I4r1wFQIhANCFRYtJ\ncisiz5WCjZlrUEiMvs3cI0h1HYfq64k4stlG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfgsdsexbs0WWqopimZS564wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmMwOTI4Ny1kZWVmLTQwM2UtYWYzNC02NDliN2FkMzQ2NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASn7aaC9IXcEaNKuM9I4B2tPzbamxWDGOcCjyqCSYKYfQWG\n4cO84E6ppA2USHOgCJU2enPYS1FsrjkYgoFyvjy9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgb2kluiI3cbCdwtBQK5aI/BJ\nWRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG/gavQ3ccibt+IvftpCtE2h6geGx1jLhQRwGm3e6LsICIQCAYHxU7hCQ\nepsMDBxpDE3acRGKIByD1+jZscTsJ1hVAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfSmEOoPC2mNo6QWNqsWigg0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM3YjUwODgtMDNmZC00ZmQwLWI5YTAtMzA5M2I3OTIzNTRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzBhNzIxYWItYzU3My00M2M0LTg4NzctNTdjMGFhZjE0\nNDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3vprEJkRiDP+gut5JQa0H6O5\nTdo4TwXTgZwwdGCwucNabzuLDy0eHHXs507uu+/WfZZMpcrhAzJc3B9zpk6YeqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+iD/hbnlgsao+Q0wWoU7NGL1o6QwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAxyMyPgEioPribTtREv9AHrdeA/80o\n1AtTBe4NUTzKRgIgI83Bt3qn85RstOyaWskoaplG2BJ3RD8q3gUc82MJ5Jc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6797", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6797` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAW+eHHEdjCe4uBawf52cz/brMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNWQ0YzJkLWFkY2EtNDk3Yy1hYTViLTY0YWM1MTgxMGNjNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg4OTRkMDQtM2Zi\nZS00MGU4LTgzNjktN2M1ZTY5MTE3ZThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtXSKHn8aRkbkXyabRjoeLSliXq1DNCU1yU2cNe+/2VATUNXCmt5dQCGbZmUY\nv/TTjdLlBGz7wIW+nwsRLBAQBqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZHtomSO8YtCr0zkMYg2v2T3bmsgwHwYDVR0j\nBBgwFoAUO+ZkzwLjbbx5MQ16571cBuNwrrgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCYcsG3cYSTAppsGYgOUqYmMswkG/fM53G+Ceho\nnMpzNgIhAOECX8T8AdyFisr57ImIIZ5Sp4ix90XJcvOGMlSOuqXe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbloqWikgNxs42SxSLjxK7EXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzVkNGMyZC1hZGNhLTQ5N2MtYWE1Yi02NGFjNTE4MTBjYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdQp6UrPlJcGTBN5WaoQuqjQ3jsc791JeVEFUtqJvHtQNf\n4ZRYSz/wjEuf/xDGDs0kA0iWqxxh04ctEuWAIaTIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO+ZkzwLjbbx5MQ16571cBuNw\nrrgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfF3CETR1bRIwNPbeC1YkVVtgBQy40vxnWmzqZA1XyAYCIBgPFCUqTT2R\nOaM5r6HtyXiLKlFa5xTrqUyv1RfxadGd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeUD9spHMp3dIKq67UDLGSAIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg4OTRkMDQtM2ZiZS00MGU4LTgzNjktN2M1ZTY5MTE3ZThmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmQwOTJjNTYtYzI2Ni00MDk3LTgwNzAtMzUwMTdlMjFm\nMzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1aB0ELpouUGbzBGXEbT8tNJi\nHCZaXuXYqXkyADEQidGdtSiSFWcVp7st2XDj81wuQPRBVveKTib9vOFT4M8DYKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZHtomSO8YtCr0zkMYg2v2T3bmsgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAqoyIdKXTfqhY11ptLWKekp1eb5zd\nazLbmQl+xwRWrbsCIQDVBbXxCMdatN1UysDPZnG9ZfDuFM0l5NGQqyXw/cJcNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6798", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6798` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISATwNE4a8eEM0dIuROyIZJEebMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNGUzMmFkLTM4YjQtNDNjMy04NjM1LTIzZmJlOWQwMDY3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEyMWI3NGQtMjY4\nZC00NzJkLWJlODktNzdlMTkwM2RhMjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8pHL20yiVp22tkbV/b2zEsOmwk8fU50z8Sry/a9hMEnrB34ZNQmsZeMIhhas\nf3CwSdE+AjAYnf8rRv0qTSgUdKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV5lo9TXK461X0zQ39WgKaUAK6hgwHwYDVR0j\nBBgwFoAUneFR3I++4xsdOwBVOUh2f1AVFbwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIF2q9G6TVZuZHXtjg/0Q4ggAglwH5Wu7evX0z7sd\nx2TyAiBTUJQlIk1lHDbYZaVNzmpo5UH5wV3ULneOJC6u1VOSXQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbHPc+rktmPb2mG/MkrJsA8iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjRlMzJhZC0zOGI0LTQzYzMtODYzNS0yM2ZiZTlkMDA2NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBIwwW7KGsSK5+hRIaLBtIyfYH2VBOj8aI33gRpTLeNSyP\nAjsBtGqPN52LJCDEzFapu7ASZn1NbbjOOcZEvhRgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUneFR3I++4xsdOwBVOUh2f1AV\nFbwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWLmVG3O8kDPmxpL/GLXP34xBspFz90uRz1OAGf2RN7ICIG6grJV8XrfG\n0T6/deRkHUlbbKgXSbqtSjhSxthgVTD+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATKJRZLmlgs4OBwC6mGE7qjkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEyMWI3NGQtMjY4ZC00NzJkLWJlODktNzdlMTkwM2RhMjQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzJiNWUwZGYtOTdjYi00NGViLWI4NTItMTExMWU3MGQ3\nZTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExiQWptjXr5MdlS5xkuGfzS9O\niv3MrciBePad32G+TuygUC4eXAAqY2/QOGX1eW06tcP4hLHIo7U+ewwLDB4esqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV5lo9TXK461X0zQ39WgKaUAK6hgwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAzN5694INM4xfDacBMTVl3iSqxOxqM\nMT5+8w1TI9/mTgIhAOWrhQgXuN880LIG11CZTzF/KJIpnQNU0EGC0Q1Jx7OV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6799", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6799` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAWagJBsqpPOQis/gOKJAP4POMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5NjQ3ZjYxLWNmOGEtNGE3OC1hZjM3LWRlNzkzMDFkMjk0MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ0MmY2OGUtMGJk\nNi00NzhjLThhMDUtNTAwN2QxNDM4MTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYNl/G80q7burb17UlQXLiPfFPSyXXUIqv7zxPyhG1W5MiKCtba9BmJmrNcnW\njPlcI2Np+15QWqPZMIs0gk/02qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7D8VxjjfYG0SPzrBKrVZN/7PpfkwHwYDVR0j\nBBgwFoAUDni2cORBQ3NjIvw4xRoVUfebbeQwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIH7/saNzsKJtJ5x4Mi3L4QZzSqv8gsY2YurBDmylyD0dAiAC\nFftMKqhNIIXdsKMsIPT2nQav+Tj8qyubLHAAR5cNLw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUx5g6oRkDKjHVTACnLBn48iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTY0N2Y2MS1jZjhhLTRhNzgtYWYzNy1kZTc5MzAxZDI5NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpvbkx9fbhkxv5qd/W0uaHn53imKS8qe2uJcU6wkBLGmnv\n8GiAbaeusT1J0LzA2Zi5uE9LTbAiQm7QOZmUWyHto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDni2cORBQ3NjIvw4xRoVUfeb\nbeQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBknQCK+bkYH2dw/OqKvELOquVpOfAOGXE/6AKVVs28gCIQCu/8hzouX2\n5empH0fqGoZKMuNucs1rYjlNzcSdVPru5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARsP8+aDARl0920q3adBG0nlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ0MmY2OGUtMGJkNi00NzhjLThhMDUtNTAwN2QxNDM4MTJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzE5MGM3ZDgtZWM5Yy00ZjdjLTlhMjktZjBjNjMyMzhh\nNDZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMmx/+A683JAAHcoudvHLjN0N\na0tK6e1zw1FxWkj/xA36EbuCbpS+f9sKg69pXeOn4qShnmtqb02ZXZkX94TUMKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7D8VxjjfYG0SPzrBKrVZN/7PpfkwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBRJXMHvSXyQXDTdu5SNY74IO6ifEY0\nY/bTeSIhoOgHVgIhAI/z6I2nyWaSr9au7vBke7XTq1yNH5riqPToM6zxA9xY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6800", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6800` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISATYFsZds+SUBx+x9m6ScWmXVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3ZmZkN2EzLTRlZmMtNDY4OC05NDAyLTkzODlmYjgwNzMxMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUwNGFiNzAtZjM0\nZi00MmE0LTlkZTgtMGNjZWNkMDRlMzBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4ESQxiwY83lWIeHdohPTSIhInV/hHF2EE4uqw3fHHetpCPS8pHLDdj/2eL7H\nRJz36wDTvCIJl/EVRJ63a7MaHqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyHzP6TfFQUeop1tnvHr47CN4vNMwHwYDVR0j\nBBgwFoAUaXYxiOC5vPLZblsrfRZ+ncwQDTMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGWAQ8+SgRj3yeV17Z/3dA3nDcvPaRdy\n+GdsZK8ZRt+PAiBUk3Q8pnRvfmu2To/KNW80nwO7f7JjvkRie1hgqXaxiQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWQal6+r01UD9Y31ATjcl/5NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2ZmZDdhMy00ZWZjLTQ2ODgtOTQwMi05Mzg5ZmI4MDczMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS58ptL5+m13aGVzgmSjRUNKvAMqo5aPhVpqEh3GsJYGrcC\nRnIQYIghRlgoLLRTn64FLw8GMuQIlGWyuJopC5WNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaXYxiOC5vPLZblsrfRZ+ncwQ\nDTMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZSF7kr2aWRjaCTmb4VhWRDaVXTX7WdscITZ4aKyjyY4CIQDcCKfWGauO\nbWMBQbuZHaKGjS5EYxlSzBcDgOFbm5GRrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWla88Mfv9fhWnFbbych8EKCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUwNGFiNzAtZjM0Zi00MmE0LTlkZTgtMGNjZWNkMDRlMzBiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjM5YTAyNTItMTBlOC00MTZlLTg0ZDUtYTNlMDUxYjAy\nNTA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaI+BEedBoBSbGjWTpxUnnHD7\n4ATYobUXqkOvUuwDu5mHdql6ERwxtQyRBjbnClbxqliLTHu+bauKorhoQzED2KNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyHzP6TfFQUeop1tnvHr47CN4vNMwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiACPHKmfUvmkyj0KpGmJovnfrOGm7hv\nLK+L6cX44IKs0wIhAPHYNNJwQPW0lLe7VyZKCdWLtiI8Lx/HYdLDskj359cX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6801", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6801` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISARKGLNqi1uq2+2yx023AVGDYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyYjExYTIwLTE5MGMtNDE4My1hM2RlLWMyMzUyMWExZmJmMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzYzNmIxZDMtZjc4\nYy00MDczLThmMDItYjg0NDRiNWFmYzI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEp36+WdKw6aon/RdPVEWZYWQ95/2p/nYfIBAn6YBVN8rXjXwF4Riv/A2zbq0\niKxwiuvkaGbFWDxLvYyYa9J8yqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGKEikJqEido87p7ueuj+RuHemM8wHwYDVR0j\nBBgwFoAU21Z4BhqS7XGNbaQcw6Bkf9vyrdgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDjddVhshAuj7oB7HjFoIYGBylxxl5I\naf8omPJpcrBqggIhAMb5wDwUw437wn6Sez6H3m5qWIBfFIeSd3XQKGwrsC5m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdtv6NKGfE0buTg9dpI6OgP1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmIxMWEyMC0xOTBjLTQxODMtYTNkZS1jMjM1MjFhMWZiZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPXAlImdhu6V3/KjAJwvayjfrDxYUAKU3DqnjOjUPI9dHu\nMaM8W+CTIcVeqN7DdDqwVOywxSZEOA9LwF38g2Jpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU21Z4BhqS7XGNbaQcw6Bkf9vy\nrdgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL4Dvukcds1eNU/CGV0rH6LnfbJbBSdO0NLWkeTzXDpPAiEA0GmBwV7a\nblMeewftR4sAvLRFpLkGZ75GUdmQD8lsCHw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUqoCe1RrP/3gPiQBaiuj3iUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzYzNmIxZDMtZjc4Yy00MDczLThmMDItYjg0NDRiNWFmYzI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjljNjM2MDItODk5MS00Nzk0LTg5ZGYtMzhkNTg0NDg1\nYTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOI4/t1ptSb2F3mZhH5029Ut9\nX7WYlfT/cEXpkRnP//2AxPnIKfJyeOr3ZbUF8n/DjshsJbY+qjZ7Kio6eQBWBqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGKEikJqEido87p7ueuj+RuHemM8wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAhTWZlP9pnuINST8Rjn1T1Hb7vd42\nksfWpQsazfXAZsACIH9DEQbXOQ6onOJeeL5E9HWR53A4rVPcug3h7OtfZuy4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6802", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6802` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUZtdTdFbdD0tewBGiNEkqAKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5NjVkMWYyLWEzMzgtNGM2Yi1hZjc1LTA4ZWE4ZWNlZmJmOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NlYWQzYTktYWU1\nZC00ODI0LTk5YWItMTc4ZGE5NDY5ZTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9U9Tiu2R2qT6rn62jIuYUoItLCrcfI9cR7KXvPt6p90RdFwETmzl7CNTtfCi\nm2+M8NM3tLWnU9/JNtxVSrHXy6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUliWR/dKf/ACvLP+Sp4w6Rh7xyTEwHwYDVR0j\nBBgwFoAUfjy9AbdPXn+jF5z3l3inq4lUJsEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBvskzHrboha\nAhgsnnSdRwUeZedr854Wj6ZWlUXDVONjAiEA+9+v5GwTQ+pLT4EsCNNSlAUGbwD7\nhx6Nfayx1j5cUu0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZoBjHlr2M+xnnojipvBmPuQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTY1ZDFmMi1hMzM4LTRjNmItYWY3NS0wOGVhOGVjZWZiZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDGOkA2Wr2owi8QTYahio1XvVkPNFnFBdAqpDyJpeMOnwa\ng9mprad6mNMWJg6fTwLN6PoCuNWzCY03hdqVfbn+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfjy9AbdPXn+jF5z3l3inq4lU\nJsEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIDfq2Sd18XG3CbIMtlkjsgrlLgLM2kyXxPdrfF3M/XMCIQCOGuqTYmP2\nzySuzaTETAWydPgGPEI3OAGr/RTX5xqi+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbl86MkGHhwPA2rhFV0HvrO2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NlYWQzYTktYWU1ZC00ODI0LTk5YWItMTc4ZGE5NDY5ZTNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ1MWRlOGItNWZhMC00NDNmLTlhMWQtNjkzNWI1NGY5\nNTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECqrW3JRzExAeZpkARxJyx/ab\nKGFheYVAGXSRQjK6BAUo8I/Y352Von1G7zK4MJvb+UVEDJNm7cRipK45w/SQ4qNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUliWR/dKf/ACvLP+Sp4w6Rh7xyTEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBfNxbyTdFZRluwfQen+mDzTAcEwBbM\nF0WUFRoCKAUqWAIgSyWme/3CN+YXrfQFuQUTd+c8kBAxuHGcnUxQQVFnaJU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6803", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6803` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAW/q6hZ+IKb4bU9/2VQAM2SSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiMDg5OTRlLWMyMTItNDY4ZS1hOTBhLTRlYzJiMjMyODY2ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQwMzM1OWEtYTdl\nZS00YjBhLThjYTYtZTNkY2Y4NzlhNjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd/P8k2f16Sl9ebrkYJmQlgBRNGUUUwNjiu24RnwnqLq04fVvwW/Jl4oDgieE\nZPqltLmPDRV45vINe80NM0vENqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUscmOdOefl3lQfS9OvzC6fiSF1FYwHwYDVR0j\nBBgwFoAU7/LM+gAC348YdRgGpdlpC6Z0qsMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIged96sZ5yAeoIPW439ujI/WcMkO1ygwyEyQN5SmdhRIgCIQDU5IKd5kw/\nVO/bkETUG5mmuHftw58QSD/d93Onp4gJWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVNsn+iT9O99Wuuy6nN1Fus0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjA4OTk0ZS1jMjEyLTQ2OGUtYTkwYS00ZWMyYjIzMjg2NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNu3hAU1abN6ot7rripQK4fgpKR8jql9Q1zAI7dvbFBtnV\n88+ROp4R2nPNWYbDuVMWa+65VXgUiWNTlaGDbULNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7/LM+gAC348YdRgGpdlpC6Z0\nqsMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA9oa0TWPzApqhy3QXD5B0PHWCp9WWRB6I7p+VXrS9RsCIQDjV1KPjUWu\nGcoas2U1bBuIl5wfIGE7vaPZ9sm8C2wLLw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASUUENZGOgv4liSR07Wyi3vyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQwMzM1OWEtYTdlZS00YjBhLThjYTYtZTNkY2Y4NzlhNjIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzAyMmE0MTQtMGU5Mi00MDI5LWExYjAtNmUzY2U5YTgy\nNzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEt2XG0HkGTSfYxJKMADTs854i\nvQvR6cncuTG1gsnCz31JoLlhDFgM+T+doC3gWQCPGJ5zKkk71xheX0kYsWL+XaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUscmOdOefl3lQfS9OvzC6fiSF1FYwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAYE5KsNyAJnRkCE3GmFUhQIaLua4cl\nrcl4j9ZXf+aq7QIhAPHwS6caJYF7tyFLB8AUB8uxScAZ9K1HxXhznd83zJqr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6804", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6804` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAToLXpL8X+P4CWVfi2F+0WnIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0MTQwMDg2LTAwZDMtNDM1Ni1hOTE2LWQxZjYxYjllYTY2OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQwYmZkYTAtMWU4\nYS00ZjgxLTk4NmQtNTBmZmM4Yjg4NTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGHOXjmzfMfgsPq8lpmy8jf/7N7whtpEATq+Y6/cv2kwPV16l2bcOYr3/RWgM\n2PTEg38JnggcciC2qddXXSesU6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvwZ62fYPodXSh+/SL/k7ZdLxNmEwHwYDVR0j\nBBgwFoAUEcMF+nStxx4omKD5Mpr2g3VAeyAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgLb3EXps88Ze4BlzPr2rwuBz/43JWNvZs9oPx5PzbfEICIQDQ/KUTq9V9\nNlib5chzgRwlbzhPUpRAtU3XBXxQr/csLA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASKIawQJ21Qc2QBZ6zzXZU4XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDE0MDA4Ni0wMGQzLTQzNTYtYTkxNi1kMWY2MWI5ZWE2NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4fIIGNf+1DLAjOc4kPZqe1KCzL31T6OREqDbRXQizt51I\nSnuNVEei5rDJSisRxfgn2b1j1/63wwiy+vZRA0mzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEcMF+nStxx4omKD5Mpr2g3VA\neyAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZUYtgQlpLq4gbtrGTd40/e1OwuEFpd3mJs1WUoLfFLMCIAdE/Me7Vqdr\niwcwu8R7gE0zgdExs3/3aepSlr024+RU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWPoFbS1O3yzPi/dJVCE2X8cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQwYmZkYTAtMWU4YS00ZjgxLTk4NmQtNTBmZmM4Yjg4NTQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWM0NDk5ZTgtZTAyOS00NmI5LWJlN2MtNjQ5YWU1ZmEz\nYjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8J+pahBfY1fxYPdcmzdSl/Iw\nMfbFsEjfdgeJSHAXdrPm/WVTh0rc953hVXElqaPrFJ4k0WpuJO+f7nNVUYQ3CqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvwZ62fYPodXSh+/SL/k7ZdLxNmEwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA1UDxVkyGvp+H05T7wj84e1YR63xj\nG4kQ1wwV8iQdpJcCIQCa6cqGPHsy620ssG58B+9Gm8R8j2vJrtjt11OT1d7Otg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6805", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6805` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAdp81j9bAoRSfPMTQykI1RRMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxYTEzNGMzLWFkOTItNGE0Mi05ZmM3LWJjMmMyNmZlZmY1MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk5ODQ2ODItY2Y3\nNC00NGY1LTk0YTMtMGY2ZTE3Zjc0NjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErxiJ7KcJLA7gh3YS7gvO1EB98+NqGdt0V/aTDTMSxddZQ0uEPwoM9IvPpRZI\nvd2BozU0LnB+jhshAYISxEnYhqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWXnJqpukinI6HC5mqY8dmoN3RuAwHwYDVR0j\nBBgwFoAUZJp5BT4WU1tYQT3162dJHf+90jcwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIAr+ioBslbXEydpI804mPnDOMMxepfXkVyHRMiYJGMaqAiBsUlC90fLh\njK0bVDSWAnCnNCv10FoxJQsvC2rj/qDFZw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS9YeNDzwpMedrF3ey8Ab1UGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWExMzRjMy1hZDkyLTRhNDItOWZjNy1iYzJjMjZmZWZmNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZp4YZ61DDm/s3i/PanvfH7chf0e3N/CoByT0UL8fy9SNb\n6wZ7SG/OdcMsOnf6kHJ+BMcSWr2+K76Uo+Wda9Sjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZJp5BT4WU1tYQT3162dJHf+9\n0jcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZU0wn1rIkkgkBrASnj9jepNLtPxxJq+ra12daETffMMCIFCMeUlHDU6R\nd5+qCGIwfX7wU8r1Xr7UpMRdmFdOqod3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeHUCHIZ7Fkw3ZaaDl+hoYtdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk5ODQ2ODItY2Y3NC00NGY1LTk0YTMtMGY2ZTE3Zjc0NjFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmUxODkzMDEtNDJmYy00ZWIxLWJjZTEtY2FlZmFmYzNm\nNjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESLS5y95qOSPbNSPxjZBALLuH\nHdLbhV06lfHZ792z1yARqG87SOEe1hvgiaKCR1DBELP9UT6iW40kRaJLyW6kKaNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWXnJqpukinI6HC5mqY8dmoN3RuAwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAlIuJOo830yzCJMvFz67JVn7gmj+I\nwoXKZjTq7ZZInwICIDkViF+kvhz21KKQLwCGbwRC71ctRRVxpgkLWZ5prf27\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6806", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6806` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAZlE/ifWUUC4q+aFtADWWYu+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZjY2YzlkLTlmNGUtNDIzOC1iYzY5LTI1OTAwNWY4YmI1NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE5NDEyNzAtMWNl\nZS00N2Y1LTg5ZDMtZTUxNzI4OGZjNTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcXsoIj3ZjE2ghDcRRjQp1d8aE4hQQh/YYdrj/Fqbgo9eSAb5MdsQKf4LPDCc\nysqwefUITwQG3lCLMc6MDgaRjKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKWu67njSOMWEq1ZIwSYIct66cK0wHwYDVR0j\nBBgwFoAUGVT/jTnrBVIneNI12KyKxl6SgK4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEgukRJ9rkPNpIyZAbnMzAoHwI56oJbRkiNO7Sv3\nS9NpAiBxBOtIRkZa54de3jwCU8vlS5Yhm4vpAIRU7vyPL4OodQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAebAVR6Sj7hV6Wcy89Q/CudZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWY2NmM5ZC05ZjRlLTQyMzgtYmM2OS0yNTkwMDVmOGJiNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQT+qLpn+Dl1WdEKE+EK3Uw4FcvCzSiZ8pbSswWpJ1EMfki\nczkpxxm4q4ys2zWkX+XbOj6xqKH0kH2D1OMpQIfRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGVT/jTnrBVIneNI12KyKxl6S\ngK4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXT7QlKaDIgO0/xj7XO7Ms3H80Qz9grFzlr8qz09+JfICIA1/gbWXb9Xu\n84M2YkUpKtDNtB2DKegXS/w3kKDJr6jY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAasgPxL1QYPsVQ+OymVfo592MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE5NDEyNzAtMWNlZS00N2Y1LTg5ZDMtZTUxNzI4OGZjNTJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDA4NWEwZjEtYWFiMC00NjkwLWI5ZGQtYzI2NzQzMjQ4\nNWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENXTxjkXZAn4e7wXUUphqGqPP\nqF5WtMZpbXPnAQ5P/GEoZ0BNAIPzUIxksV8xKnrtgDR8LZmsbFf8D4ZLw3PUKKNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKWu67njSOMWEq1ZIwSYIct66cK0wDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBzBC2eH/xhdFhAugZx29+lInQec78w\nPQeQQwOAAUJUVgIhAO6zQmFcRtzyepa2S9HPRqR9B2qSX7OUUkb0tj/zCjV+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6807", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6807` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAfj7T/OLxDqV/F9f8y01gBTlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNTQ2NmRjLTc3MTktNDBmMS1iNzQyLTYyNDk5OTZmMDFmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDViNjRkYjMtMDcz\nMy00ZDI3LWI5MzQtY2ZkYjM3MTc3ZGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV+mja2W7J9GtNrXZhY4RNdEoZ34bCxU6x4MA8ir5wwqz/IIzr3sfsBSabGic\n+t9M+JAtewzieKI9nCpjkPfglKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUolExKpa6B5Br6yXCTKVbLdc6Q0gwHwYDVR0j\nBBgwFoAU3ZwZ1F1+4/ikGZzn7fvXosL4FO0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIHpUoyF9Ppb7n/p0P4Hb//uM7kmQHuIiQUJJALqr\npNGCAiEAyNmeCcMhTJm9bM0jAt64xSreY3QXH9opHwp3/B/ndVw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUI7odPc206dDNHoUABTOHDqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTU0NjZkYy03NzE5LTQwZjEtYjc0Mi02MjQ5OTk2ZjAxZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlewJRH5a8J7qjeMwV/9YY/AtQEYkm5TFDHZRndRe69CAT\nXcoQqH05osCQzeuxMJjeqd628KRgt7wLAMh2b9HWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ZwZ1F1+4/ikGZzn7fvXosL4\nFO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMsG6LtuLEpkQkwkYAsFKHSVk1XcpsEg+fPYskrP+sKUCIA3KT9TiyL3V\nFHeIRsyroCJUhGMcXJXFUK8s2wV7ZmVJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAY9mGyn7TKKWz5AtO1Tm7TajMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDViNjRkYjMtMDczMy00ZDI3LWI5MzQtY2ZkYjM3MTc3ZGRiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzBhYzM4MzEtNDZmMC00NmNjLWFkNjYtODFjMTVjNGM4\nZWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECAGCCgUD0yViHnT5+cKst8AL\nB6shWj2q4iXjdFhiQFh1yWd+if2pbDoEQcUku/E7CpwPoXrsRi6H5EP6oOIiW6Nn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUolExKpa6B5Br6yXCTKVbLdc6Q0gwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBCzav/j+lLaylPfPHe0ALbYALiKrYk\nKKgbHKVzKJNk4QIhAMSNPwmWdWdLiQFSB0+dHSJjJA3lUMh4ZFrEj6JO9gAX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6808", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6808` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAWJirz0qJiISf3gyldkkBxceMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3ZDVhNDRkLTA0ZGQtNDhkYS1iN2JlLWM4YzNkOTg3MTQ1NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTllMGFiN2MtYTZh\nMi00MWQ0LWJlODYtNDlmNjUxOWZjNGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq9MVZIVcYeTGRlPsAhKPKg/1UMSewvIooitFc5WyaIXMMU/8G5xgH0/HPm+m\nK0kP8lXn3bFUIReczAVb+mAdG6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCrzQvK3jJUBAapE0FRq2TKupVUcwHwYDVR0j\nBBgwFoAUNEO1Ny4QSsW+rEfBHnYQopIZkbkwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDkJZtg0wMf7n3qeO3jQ3iFxfdPfjn1VnX2HlauytvyXQIh\nAICwXIKcnjqXXdFNT3JUoYDlUVMdSrVUTahE4kYJCvhp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAedY50jmW0v8wOpOqbKwGOpXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nN2Q1YTQ0ZC0wNGRkLTQ4ZGEtYjdiZS1jOGMzZDk4NzE0NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+P8O3bSVaKkxJKzEPW4BDN6xIAoR+cYaQslqQuHnP5ft3\n/CJ0lJTAXClrJCAYJlNfG1j4RacYadBwYLPXeX1Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNEO1Ny4QSsW+rEfBHnYQopIZ\nkbkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPeFzaCPa5CnepXDlZZLLGZ1O8xL/oo7Kll7rJJ/6GK+AiEAigrEHAaQ\nCQChKobmCRsW3+OSqlU/E3KxVKx4HPs9nO0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVM4zj8pEJEmUKWD3oi8XRdoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTllMGFiN2MtYTZhMi00MWQ0LWJlODYtNDlmNjUxOWZjNGJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGY4OWQxYjktNzVjYS00MTQ4LWJiYWItN2I5MGY4OWFk\nNWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENPyNMAAnfZDCTdh7LpQcu05b\nTwf66c8iiQtVrNIpdO/WTvkOfw1eQABypzCi/oHxL2cyjf7FzK2kU4/Lia/dJqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCrzQvK3jJUBAapE0FRq2TKupVUcwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAl8qty8jHsX3wwjvGDywHrEC5nG8b\nDrFQKgyE0Tdnj/ACIQD2vRIFFwWtuJqqdy00gY/S6K351/mpcTe9V+WPhrXMSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6809", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6809` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAdElLc1+ydWOZ8FQOCbjmf/xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMTY4M2NjLTlkZWQtNDZkYS05M2VmLWFhMGFlYWMwM2ZiNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUwMGE5MDMtMmJh\nYS00M2U0LTk4MWUtYjY5NmI2YmQyMjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMFxv0W1X4dTt60Ee1+te/XGLLft3qdrr1zFDmS+7xHQhjj940ysiBmhInCFR\nO3TwCfDp+2c4CpP/hb36U63X06OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn3jsx8fUkuG3oNr8JMd36QpsesMwHwYDVR0j\nBBgwFoAUsby88ko8p9MIXygFu/gbN16vvv8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDvzcK45/PkKctcDX1exSgS45aVanE+\n9RdUhKFAjuCygQIgQppAXJuGzsD8qQALdQSv1QtNLO5viw+L9gDIEuKcRKw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfbh1useGZgO8NvbkEVLCGdKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjE2ODNjYy05ZGVkLTQ2ZGEtOTNlZi1hYTBhZWFjMDNmYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASU1NAAKgTWrU6eoFRyHjCZgExIX0J0TeMIeKVA5ifuqNQz\nl1qaP64s5MN4bZXwsLUb4J3Vy4gQesLusby3+Rs0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsby88ko8p9MIXygFu/gbN16v\nvv8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALtt2IH+AdySFju/uaAaJX/NPa00aZZJkhaMWZJif0U9AiEAwiXePhcb\naGIKX0c7Ay6XUagQQdgc+WfzfgRUOkqhjEA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXIFzjyCGWtfCYpQKVhupyzEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUwMGE5MDMtMmJhYS00M2U0LTk4MWUtYjY5NmI2YmQyMjBkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTUzNTcyZjUtYTNmNC00Y2IxLWI2NmUtZWNjMjk5NGZl\nOWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEU8qYtLbqGDExON5sE/jYcYb\n++vgjeRjdtn1cQNSrVVpWdIIPGZfTh+atI6ubOe+SsyjMsDBlsdV7YIs1rC64aNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn3jsx8fUkuG3oNr8JMd36QpsesMwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA5MU4rtZOUkyEIoJQTwrCQj/ffBHP\n3OOJBpaeFrw+o5UCIEVc0HJ6BReQv1QKUm6G2QqbqQcbz4Mn5maUiOkVcFPO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6810", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6810` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASYhQfhfv/93n/ffk1bA0onDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmYWRlNmJhLWZlNTAtNGZkMi04YTQ3LTMyZjk5OTIyYzE3ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJlNjA2ZmEtYzg4\nMS00MzA5LWJjOTMtZTkxYWNlYmY3ZWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEefln2v03if6W2gxZ7SjDPxgZgw0X6qYZvhgF3EEmzE+WBvXoRKUrHW9ozuQs\nLpjYiAwvudoCC85M4qaMdvp8sqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb2ouyI1i22xPy9m8CUZLVuZG3pcwHwYDVR0j\nBBgwFoAURQ7kSqJwIPtcibCk1wcck7n8N4MwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGqTGsCasONQWMUE1Lz1JY4hgoFMQRV6\n23TbBPbRDA4jAiEAq3w7Fhgzp9G2rU2pDmTSTWR8tZlN0D/KI2UKI/6A79Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb+Ezio1tpovgazmAlYpwMZPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmFkZTZiYS1mZTUwLTRmZDItOGE0Ny0zMmY5OTkyMmMxNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkGxKY3TbzFPv3ap8Ednh7/lS2vTu2KjTbJnwIcfVbWGvf\nWomguiggt0NojwZUKoyl2D6wCynY9xUjMqH/Z1ouo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURQ7kSqJwIPtcibCk1wcck7n8\nN4MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPEEenv4z+XHrPxck2ndE+rW4Gvgni/IhxLe8JUjF4LyAiEA6WEqZfCN\nVmH4m8cMWI4TZNdGb2lwQiEA/OmsVWxdAiQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISATgFNxht7TVbIwXeKD6eaOknMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJlNjA2ZmEtYzg4MS00MzA5LWJjOTMtZTkxYWNlYmY3ZWI3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjJhNTUzZGEtZTg2NC00YmY5LTkzOTEtNmYyY2JhMDU5\nOWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErelnFtfn+oceJfk6DBqmYia1\nX/ztdy3hUFzI7Q3kX5D/g28+w+DWqGDaced3OF/dkg4LhU06C8uRDlWCbhsQFqNn\nMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUb2ouyI1i22xPy9m8CUZLVuZG3pcwDwYDVR0RBAgw\nBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAg/NZpH7Cs56RsiYsbaCBUbL9J3SD\nSNQ/Z2opYQ7cOsACIQDxGPVa3kFzuZrBvNMBIYq61lrYCKWYLF67zoeUxeVyUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6811", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6811` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXlrVjSa0Y6fi/qNMHDmoJXbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMWJjMTZhLWI3MjMtNDllMS04M2I1LWJjYWM3NDE2ZWVlZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWExNWQ1NzAtMjE5\nZi00YTQ2LTk5MzktNzg5N2YyY2I0NzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJT2b2DQX89qkYMSZyy8K5u6vyl5RlvADEsC+6htuW8HYIl414aQLGRjbabgq\neaJKh2T+cTDRrh9p2zJOS71Dv6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN9A6L94l5UDp12NmHNTXX8bEhoJMB8GA1UdIwQY\nMBaAFGtwP1oJ3+juik3vwelD6payXT7WMAoGCCqGSM49BAMCA0cAMEQCIFghMTCz\nYnLW0ygsb2zMWrSaJQv+MtNbdYAO/3NLo/rDAiAYUsOjmpiyfuhoJKBOuQMRFN7P\n4uEd6e0VB6Yns9w43Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISActkKY5IWAe3pDPEXjJ5ceOhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzFiYzE2YS1iNzIzLTQ5ZTEtODNiNS1iY2FjNzQxNmVlZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjfEyDTNT0QTZXkLFpMk8Sv3Tw1l4dc/4sMl+3cQs6YPmy\nowdVrM8JLhSTQx+IVT0AwPNTVRwpP4kEHIGYitcxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa3A/Wgnf6O6KTe/B6UPqlrJd\nPtYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANfF9xxSrnLD3STkdp/NgdWXzwWZSd60Ls0v+IXKEb+RAiEAzbUKNcRw\n+Z/VxPHQ/mP11Lu/8gtgtRfh3arfKFLNr/M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAYnn9NWUmYoaJM+ecZg6NJrjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWExNWQ1NzAtMjE5Zi00YTQ2LTk5MzktNzg5N2YyY2I0NzU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODUwZTZmMjMtNmY3OS00OTU4LWI4YzQtMzgxM2YxMzVj\nNzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEBNnzb12OPeCMU3Z1Wfh3A2p\nk/8adtwFmVDK4pirPgl6KeZGyFmdeaeP1CcszfRKokpeNYCOmsN/xMurDanHgKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU30Dov3iXlQOnXY2Yc1NdfxsSGgkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJJda+2mLhOS1dGW\nDZuH03GYgHqV5rcDUDvIRVcuSZ31AiEAzaF7XEAf0nVC5cHIydIMRakFKIvXnMDi\nkGMKjrieuPI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6812", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6812` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAVSTxGq0ZWcBVbsCqz3GwNo5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyOTUzNzE4LWE2N2ItNDljOC1hODA5LWUyNjQ3NzNlYWVjODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc3MDA1YjgtZWZh\nOS00NWJlLWJkYzUtYTYwNWNkMmYxMzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEabhBSfUj8V4GWRFwFVL/boxWh+/Rhnd3CexpXZAsnCpD46hRhg3crKL+tMEX\no/2QhJoumbHG1guWNmJIs+hT66N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFu0c/QlOd8Pm8GGdS6xzdnArqunMB8GA1UdIwQY\nMBaAFHW6hihOIWZ0CSP1awkOL6MjXcvEMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAzFGHC1ZFXYqHn45Eiq0/aMSMQYBXsYJF\nWG4OEUcA8mwCIQCXLb48vuiC7+FQAtnUMnZKGXhY3qSicJ0e5fsV48GLsQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAemswAF+6jvETesIdGNkh9yzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjk1MzcxOC1hNjdiLTQ5YzgtYTgwOS1lMjY0NzczZWFlYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2Us2OMfliu+3vMYuwIWK8L14TSI9QCEjzGc7m1RajNsyI\nPsRQmgTHX40pBBgwPFpBjvptHeRaJjQYH9tuh7yYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdbqGKE4hZnQJI/VrCQ4voyNd\ny8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBG5W8BcksSiSxCehC2z5FQ+Jlv8waBcXrw5crTLitcICIAwqGUcAJP6l\nwADk09B58ozWLc8CbpkbrX3tpQ5vryEj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAY0Elr2N0PsPqiXV+lN/C8yhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc3MDA1YjgtZWZhOS00NWJlLWJkYzUtYTYwNWNkMmYxMzMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTAzMjEyYmItY2I2OC00ZDNkLWI3NDctOWU4NTM4NDc4\nNTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbmDDe0+op1PtPvZLIMg8kyxZ\n/llVE7yTshACw7DGgsRay8Y1zPqStoySxlxWvMmeAJzDQoOoxoQm1tt5+/bKv6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUW7Rz9CU53w+bwYZ1LrHN2cCuq6cwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgYZ7IAtJyaXZW+oWd\nhY3HzLUSxd3FXPEBUvy9Iy3bleMCIGszhwkA3Dr/l+oqe2iv1jKnD8X2euV4Qvqt\nY3pmtEbm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6813", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6813` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAQIzGK/YzmozvJxSzJBKyPQnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxN2Q0ZTM5LTdlMGMtNGQ3MS05OTJiLTQ5YmIzYTA0NzY1MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJkNTViMjYtMzMx\nYy00NTIwLThmOWQtN2I5ZGRjN2I1YTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE89Ach6qVekob8ZwD1+/Tl+mb3jlKyZKRGvc3ufUHMeIzX2wvhi4VEp1hYHtj\nOtJGcoOGkPZH4OptzE8wrHSr6KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNs6Gg/rDamKC8aM1shl+Uc69ta+MB8GA1UdIwQY\nMBaAFIL5eKNPYuAUqU5hHGJE3cKKUGgnMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAkV67qxLT7jnNg4Vev1rehhaw5FSb2eDXA\nL0n4jgGh5wIgdkmQOCNNXW+Zvg0dX9sVW/GNaxW3v55BINOMixyQAm8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATufoIcfNoA5gf2NKBl/Z0GSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTdkNGUzOS03ZTBjLTRkNzEtOTkyYi00OWJiM2EwNDc2NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARn0TWR/utfe7EEB1AFVjHZNmHqczFd3WtJidOsrGcaO9df\njDPIIU/Kx3yFl1Tnvx8KvclIwbMUONorgWpSzqtco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgvl4o09i4BSpTmEcYkTdwopQ\naCcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfuk6FVu97bjbV3wn4RpuibRGmTAoe1q5uWrqC83xnfQCIQDXdmWrWOTX\nyUF8XKXcJ1TLz6AfEGlwc8sXHI6tSsDPsQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAW4P1BWzFoKtAF9X2sPYziGoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJkNTViMjYtMzMxYy00NTIwLThmOWQtN2I5ZGRjN2I1YTU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODdlOGZjYTUtMWU4Ny00ZjQ1LThkYmItMjk4YmVlNmU5\nYzgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWiE7pPMn6SwRjuniH7KZoi3Q\nhMEk+Z9RwIYL9829zt4z7c50SRWszPcn6hkl4R+KCJVOpnxPi9yiNXoGGNLqPqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2zoaD+sNqYoLxozWyGX5Rzr21r4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgP6+xUgzePrq95B03\n0GpTbcZHxP5UMkHBYb9JBHh/L5kCIBX4kEZ14kRmmMiKsg7VKPB7/90YhuNwBcrD\nK4ofoW5S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6814", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6814` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAf/h0QDQYOE7AmFRhwF0BaJGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2MTY2YzcwLTRmYmUtNDAzMS1hNjM2LTRiNWZlMDM1NDg3MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFiMzg5YjAtMGY3\nYy00YTRkLTk0NDQtZGUzMjhmM2Q5NTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC84Aj0D43uiWwaEtsbaWENuLGL5u/jaN0SrmjPmcJ5CnglhX2DSnl5UapCBu\nNXaK0veSHqf1IefJhyr9ZcxNBKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT8m+hZyZ57V6MlDdFBWiC7TyW64DAfBgNVHSME\nGDAWgBTOEpvwLzF2tmYycGzkFSx5vR+9/DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICFNtHZ6XOONTcQt8iOEp+RMgj02VgyJ\nQtOx/b0IkhR3AiEAhegEmE9IAYHT2EdV/Cy0YLma5uvn9lM9rTNDvo18I8o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfEc5+I7VWLsOGPFLA6ym69EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjE2NmM3MC00ZmJlLTQwMzEtYTYzNi00YjVmZTAzNTQ4NzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGbnInF/FFUYjwJ/0+YZL4hT7bYont53/r3pliIrNA7oBN\niIrYQdEaK0sxtv0hIIJhTjdetNzyLPQH0OFsau6So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzhKb8C8xdrZmMnBs5BUseb0f\nvfwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJabcLXWjc9CGdexkDOjQ0XjD0MeATd1+impGfX2XUXjAiEA/UYpNmgF\nuW4oML6btJGAWTVg8vxTa9huQvCguhUWLMY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISARzeKDvS9OTZjXHJor05tX3RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFiMzg5YjAtMGY3Yy00YTRkLTk0NDQtZGUzMjhmM2Q5NTU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjZjNDdhNDMtNGNmOS00OGY5LWIxMDQtYmM3ZDI4ZmRm\nYmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErCmRb1K7eC/68qAgBDHULTwM\nRQn8JWp4TsS3Zro++otKIOdBljDdbR0jFHDYRAJ+fKcagR1m1fhvyAPEdsqPiKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/JvoWcmee1ejJQ3RQVogu08luuAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALcZ3Umq7a3kltlw\nFQyh7DA1QbIHYiYqQjaalGV6cEsIAiEAmTMdwgDHBa7WPNkP2rSmXbaneL3HWetd\n83tucSGP96Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6815", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6815` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAUmKoIJsxhkowmx7U2B+F7n2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1ODc4NjRmLTVjNGItNGYzOC05ZmE3LThhOGJmMGIyMWQ5OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE2NTE4YTMtOTAy\nMi00MGZiLTg5MjktNDM2NjdjYWMxMDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESYQqzujDjYJCHsSQAoB654QE48GPZaX83ml8gooY8YtXV6Er25x9TfRfxf0s\nWY9efZbXNFcJCLqwpxq0HTA6+qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy7WIzBqOixTFKUkmKVlIL7VBtvwwHwYDVR0j\nBBgwFoAUhfq/7Mm/P4gs2NUBALf6OlJas1QwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA8vI9xhh773b/\nQg9YYss8KReRS5gmh4UhAXyzYcEkerkCIHaz4ivCKDAvEAB6MSS13dOFov4CRe+K\n7/RF4kg8PHuw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaRRwfjU5fhwD2BC40GtIdouMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTg3ODY0Zi01YzRiLTRmMzgtOWZhNy04YThiZjBiMjFkOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsgB2ACRpyPmSDP5dkod0C9CiD0e9cwz+OyaXSqrOkjjBj\n7OqBRCP2l2ADpdRr0T/eKIquwzgNySf9Q6ldmGVEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhfq/7Mm/P4gs2NUBALf6OlJa\ns1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM9FcNJZFaXfEc6rQmix45ClfcRdo7anF7T6cZUXenl7AiALdsbMase+\nllBzAAQuqjlQczaOXo8Vc3DJI3Xln/AVwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISASmx+WyPjnC9mhaqfec0RjC2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE2NTE4YTMtOTAyMi00MGZiLTg5MjktNDM2NjdjYWMxMDBkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjNmNWM0MDAtNmIzMi00ZmNlLWI1MGUtODEyN2Q2NTYy\nNzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKytOk88oBcXr9Inc9dOHtZei\nL8ebAZwn5M2jLYmn8DRRtB3krB0twKCrfBwb4etMGpejIbDRwJsIvcKykdOzdaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy7WIzBqOixTFKUkmKVlIL7VBtvwwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgGrIzFe9CHq3rkBlh\nAcTeIPLFc5V5iX8CoZZDiznji70CIAVCU5X8vq2ep8RVTfAvP/QVp4l/75SD8RyI\nbhp68dpe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6816", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6816` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASJgE2DRqKjNX11x3f9Ar6TOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxZjgwMGU3LTlhMmYtNGFmNi05ZTA5LTA2YjI2YmI1NTNjZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjEzYTQyOGMtYTVi\nOC00MWVkLTkxNjEtNDNjM2Q3Njk4YWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY1vdM0PiCW/e8pgeecB6ZhIt7+N5BsxyK1qF5JXbIS23Y0DocHoXMbRwbFM9\nqH/dWdvldqQiNk/TPKKFG9Z1JaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcky9XZGKrpAfgrOkFv6DJcL55uAwHwYDVR0j\nBBgwFoAUQ9RhFi4fyYtRuNRvqLNotMRs5vgwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA2vOKVteOf6qe\nnGf9WKSh7HVfUILJed+Ixt4IBUtFqV0CIAbpG7NoLWB/isUydb6qriSJA40ex/BS\n4TOCXj5cJ7N+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcjF9nT/Q6O125GSQZeLAwyYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWY4MDBlNy05YTJmLTRhZjYtOWUwOS0wNmIyNmJiNTUzY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ86pvxBKKD79BTCKuRbPKOZaFNPjqz8g/BzH/2zhCnljok\nZ4GrX1oeP+GRVuueW1RSNalgD1x3+rrTW6oTixVIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ9RhFi4fyYtRuNRvqLNotMRs\n5vgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPcWxu6ztPU4XXvm30RNg5ae6eBiTkD2z5/8syLX4whoAiEA9UD6Bj81\nKXB+KZ4kOwTU00FIhFFQEnBdcLAaiEnzoYE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZMsvk3h410y6UAOCSJwMKLTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjEzYTQyOGMtYTViOC00MWVkLTkxNjEtNDNjM2Q3Njk4YWZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWZlZWIyMDEtZTExOC00YTk5LWFkNzMtODM3NGMyNWE2\nNjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj2Gj5Lb84B09g78DK3RatWoh\n5JPGmhrRAWTzv1RgyMVTYBvSFmN7wrW3zA9Qva1yrBX+RNaHjMoo1M20aUzUP6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcky9XZGKrpAfgrOkFv6DJcL55uAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgfXORZd+5v8SWPNe1\nw+8L6oYENhMYiS4IC87E57cqlS4CIQCGFawvISGTN/Vdza6RIfIuF3RMCCPfaQ10\nzLMGWxazUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6817", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6817` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAUQY0jhFYfF1lH2Mjis7KqP1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5Mjc2MjllLWZhNzQtNGM2Mi05YTM0LTUxN2MwMjA2OWFkNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdkOTliMjctMzFm\nOC00NTVjLTllNWUtODU0ODgyMjJmODU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIhaGYTqQZ8ttmXbImzJWavtV1lWAwhy0PdjrOdZFUr1ppdKQfSaXJ52eNQu8\n2zp5TSMVpxnYj5yBN3bMvSuk9KOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv7yrqo3ncxY2ZklrEKmAQTqt1h4wHwYDVR0j\nBBgwFoAUkEgO6+fBM0xl8j+wrubxIjY2mhIwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiA19104g5LoQAkOgK9bnl0W\nE4svRfeVMP497d4fuo+4ZwIgacyWdIKhvzl8ep/i3WpuMKRFc6ooAV32isJt6DTS\nSpI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYsYXIOXeZ0ezXrYPEQq8Ex3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTI3NjI5ZS1mYTc0LTRjNjItOWEzNC01MTdjMDIwNjlhZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKGuxyCZtAV/UI0STziiDNmHQhLfwRtVMgGQATSFHVD2zI\nfyhjzOzxLFX0/U7B6p9VONmXM/UxqZ6jziTh+3/po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkEgO6+fBM0xl8j+wrubxIjY2\nmhIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYdvdnn3ytRHIsGyvaoJ5QACr2sXBEOvWaIiOlW8QWaUCIH/cpzfhTSUM\nJqsvANJqvl/e5XgvSmiPej3NpGRCyfum\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISATFyOrfAR/xbLP/V/PgfzF5zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdkOTliMjctMzFmOC00NTVjLTllNWUtODU0ODgyMjJmODU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjdlNzIzY2YtYmVjOC00YzQ4LThjZDEtZDRkZmVhNDlk\nZDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL7Un2AjPW2cdrYqo1Y7xqf2s\nWBwxh0Z1UPogq7sPEWj8VdQF7lvshB81+t8xsLlbnRm6KsE7VIaSZFfIlGZQMqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUv7yrqo3ncxY2ZklrEKmAQTqt1h4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgIt6pkipb7TeKkdnd\nkf9rOEdeCjn26/PQUn7Ed0MK+NgCIQCtO5DyvMwr1vf3br3Y8s49zJ0ZlmzFY8gH\n8Z1jgnWcIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6818", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6818` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAei4MDUD2MYHHLZSNSoTSy8RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1MmUwNDM1LWEwMDktNDZjYi1iMjhlLTAzYTAxZTAyNmI2ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDljNmMwNDMtZGFk\nOS00NzFiLWIzNWItZmI4YmQ0ZDY1NzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG7/7lk/EE0tiFrLqmLSvhoKCq4X30zY1ZSUNssh1It1m8Ye3Si0CYWEQN/y0\nV9mRLBUuLvMTWUwJXSS5J6c/haOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7VYsxYHVIVTJpnFjUK6s9zH+9kUwHwYDVR0j\nBBgwFoAUxZCPFvyJ3QoxXkjNKgrapfKJptYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiB5C6x9\nPyYT6pU/0BEBLNh6aGrveh99QQk9XinErLhbqwIhAIis93hqi5zc5+6vKPwKOh0t\nnvTHit15Kup9qyDL4CAb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbMADaEGB+5faz2U9dWgJOC0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTJlMDQzNS1hMDA5LTQ2Y2ItYjI4ZS0wM2EwMWUwMjZiNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQrQ7uwC0WsNe7dLCryc14dzwAsIOjqO66olZmAiCQnV7YC\nibkyEy9py+tEtPt92GvDcHFS8pCLgkECHN9n0ysvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxZCPFvyJ3QoxXkjNKgrapfKJ\nptYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO0EmPwQiyJntOFdbAGYHrThO8n6iw+tZ42ivpNdQq/7AiEA+PkOMR8W\nrthrb3Fzc9guEK47R8O4FSNuZJNJEaKh/V8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZLaeCSZ2wykes9bEX2lxhWHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDljNmMwNDMtZGFkOS00NzFiLWIzNWItZmI4YmQ0ZDY1NzZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWRhMmQ2NmItYTIwMC00M2FmLWFlODktNTIxZjJlZmVm\nZjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs0gflVH59ttEAFld4IvFxUgq\nTdYietjl93rZl0NxAUeAfd1u4Zc178Z99HHqEdd6eSOClxb2adFEaXvjwZu59KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7VYsxYHVIVTJpnFjUK6s9zH+9kUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMgFQNvBHZMGZ/2l\nVLLngRC0cBlFl0ZZuT6lhvAjvcecAiASKGDi+WcfCwzs6BPbMIVI87VVihSpSVVN\n/pCO1Ituog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6819", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6819` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAT1c3SSFvZYN0pqxrp0TR/tNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzY2JkZDlmLTRhYWItNDljYS04ZjcyLWViOGIzZDUxNmQ4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ4MGVlOWItODc5\nYS00M2EyLTlhMTktOTcwODUwZWM3YWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO6kZgWNT9d/rysZyAexPVG+cGKcPhTe5mPO8R1Kqa6dKNGcURMWx9TwdGbXt\npsoYzDNc6/Su8hhVveUIt5qB/aOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4iuFawfTab3Ps5KzNmiM36aPj3MwHwYDVR0j\nBBgwFoAUDGh3NcSg87CDUTwVKNR1vkZstVwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAYGSFb\nNd9FTxKPWz4qfdQCDQgZE6oBJ4Cn7fiP7s+aYwIgEF1uDz+026mvMsinMOCcZApD\n9acVVP6k6RGU1PW7sKA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcH1WuzHESi6nhb0Cf9PNV/OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2NiZGQ5Zi00YWFiLTQ5Y2EtOGY3Mi1lYjhiM2Q1MTZkODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0BWOKOxEI7pRFK36QsASnBcbD8Gecq+1q6ZjDPTzcppXJ\nHxLupp0e+WreV5fNbtD3ZjICyXLyCgINTjzR1oAio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDGh3NcSg87CDUTwVKNR1vkZs\ntVwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgODLelSReI5rupvPGTnhrTuSU05z53BXQoK15qFE4UnICIBapRXpSBVen\nZCPwXkekTKnUrKf6RgCWsKKw0EI4S2NO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAYVyXIxVfOwWy6ex8Ns1bOHjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ4MGVlOWItODc5YS00M2EyLTlhMTktOTcwODUwZWM3YWNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDkzOTE2YmEtNzA4Yi00NzBhLWJmN2MtNTQyNjc4ZmYx\nMWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgEm1VI3DSLDLUu6fnn16JD4b\npx2YCKNDJRLtNult36l93vhN0HIPu8R/vAVmyOOnt7ZQL3VfA6LCSp2QuTccN6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4iuFawfTab3Ps5KzNmiM36aPj3MwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgKUqGY/hwSQ37bKB3\nJxdXK7tF25AQPxgjhKTw7bsWQJkCIQCRlMU773LqIEdCGreeZyIlU/CEcuZ1hjV3\n7RsZ0PP8ZA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6820", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6820` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdU9VpEogWVD3CgHUvl3ECIbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5OGEyODlhLTAzZTAtNDU0OC05Y2IxLWM1N2UxYjU2YzNmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTIyMjlkYTctY2Iw\nNC00OWMzLTgyOTEtZGUwMThjNGEzZTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIsNQ/WeiIGpqr83rkt8BDZLwC6a8h90K/KZDjDwB9D1MwcctQgT8zwu49oKr\nuDUBkgGyJn+lGPkx4TghAH5gkKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKhh11EB7HP+F+V2871dEPPoLAyqMB8GA1UdIwQY\nMBaAFCtCXJo5N6eX5fvrQOCxWpYSS591MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAJZZn7+rt841Z3vthGtFM/zr1ELKC75tdv\nhnOyysJJiQIhAOlVVCxbTDOhalPkpYUjmpK9BRVtxNpqhfXEI7Hd4BTx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd4mf/oxRUL/YlgmM728WkOHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOThhMjg5YS0wM2UwLTQ1NDgtOWNiMS1jNTdlMWI1NmMzZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNLr2cE04hooKjgS8N8sg420+oMWbPig4t29p/8jnFHxE9\n1ta0HYmgr2EVYR4xHfuSezrZOge3/Z9Mjtb6/hyRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK0Jcmjk3p5fl++tA4LFalhJL\nn3UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKX/NdQsrfai0IbnMqcehwEF+AVkjOoo19gIyx2moVnMAiAtt+SUmEOn\nBlx4vxXkQJmSLultog0hV+zbzZkNhJ4FMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAY9r/OK3O+KO73tGPf+MokGyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTIyMjlkYTctY2IwNC00OWMzLTgyOTEtZGUwMThjNGEzZTAyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjkzNjhlOGQtMjgyYi00N2ExLWEwMmEtNTZiNWNhNGE5\nZTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzj4xPGkUqjffETpm8YtoiD8k\nNRFPgPfcVhKt7EtnUpr5IvQ+uPetGaV1CAKWnrL3VNy0/ejQKAhR2wznHyXynaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqGHXUQHsc/4X5XbzvV0Q8+gsDKowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgdRISoeYG65ubSWVt\nU4GqS6PLesu2UuazW7ryNTUPor4CIHgpHUSdCEZZT4XtLZhiKc4ipnCKUmU7zvO+\nV/ToEQ8K\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6821", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6821` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAXwHy8FMI0Xh4snFSittWv29MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2ZTczZTMxLTdmMmMtNDE0MC04NmQ0LTg3ZDI2YjRmZTRhZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg5NzM5YjEtYTFl\nYS00MjNlLTkwOTAtNDQ2MDhiZThmZTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU+xuzOOXmBrwxYga1xIEloqN8VZDHJwt3e9Vx2jga3YVU1oeS2WBKwP9fGMV\nkR0raWorUK93KKkO7b4aS1DBGKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1WkFbzI6T6HtlC5eJfxACmxVmd0wHwYDVR0j\nBBgwFoAUaDrva6t90bTg3ZaDhL/NNIhB2A8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANxoUjit/jDs\nb0mXzfDesoICAqSqZkJINkiM59Ar3ozoAiEAlIgz0v+MRU1Y4oZyXawzbAGYP3dN\nQcW7JkCuA1vF7As=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV7gDu1Coyw79I36FLqd/iK7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmU3M2UzMS03ZjJjLTQxNDAtODZkNC04N2QyNmI0ZmU0YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2a8mdMt7IOXPBG0I6McOGgQAsuGpmNT5SWSJMKTfmWhZn\nTS9QHCBuZgizi6Fz/QZI1h/YmQUxhRXmbekIkZkwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaDrva6t90bTg3ZaDhL/NNIhB\n2A8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPXkd73fOKNJQEnbv5t1aEnm6wzZi8/2XDco7wPUZX5yAiAKi5U6rphw\nm8dZz1ycp7dxwbFtIcCjWW6hG9YHElK9Gw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAcGbn/smCM3EeHtAQI+vcouEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg5NzM5YjEtYTFlYS00MjNlLTkwOTAtNDQ2MDhiZThmZTJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGE1ZWYwZDItMDAxNS00NTIyLTgwNTItMWNjMmUwMWY2\nZGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENUPEbsZumiizvipE4guJAPwj\ndeViY0eVHuktRdv5fL7j/A/bcXejnNVP0XL1HrUbLxGWzr9dfA3pPMc1yEfb8KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1WkFbzI6T6HtlC5eJfxACmxVmd0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgUBLUv3Z8TrhCZSrA\nB9A+jEzPKN+YfdwSD1dvUGBhv+gCIQCAztOs3lfknfwCfisu1NFYDfPoEf7Jvh1U\nfwxGeH5RMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6822", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6822` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASVAAmtxqRZuswbXgIhBIRwYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhYjUyODE4LWEyNTUtNDJiZC05MWE2LWZiYWQxNjRmOTYxNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGVlYmMxYzAtODY3\nZS00NWVkLTk4YzMtNzc3MGQxYWU1OTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqjFPuyKcKGQPsYfbw1b9PWc0YYQH8mME7uzInEERdj/P0f3xMEuACjkb5i3O\nfHqcYywSPGzD3yR9ybfkBZ89fKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtBmLSSij0wjJuoYX1Aa9JrxKOREwHwYDVR0j\nBBgwFoAUIz8cDv86DsSy+qwrUTP7oeOxhSswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgbSFgfsSqZagL\nTcgv2IlhDgo/Wp+5hy1FBi4LkRGHAIgCIQCKhhLoCWwaAujlboGGfluRpdhqsTb9\n1zPu2cANEfJAOg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ/feG2mXiD4OsavM4uB3zdCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWI1MjgxOC1hMjU1LTQyYmQtOTFhNi1mYmFkMTY0Zjk2MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZEtJLxiUv8Bk6rIE0Zg3NsTcHcxCMB9y1+8OnLmH1UI7x\nzF0rzYNHsSwM15DxmsJ2KcIOAD1KmwuDskTZgSHro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIz8cDv86DsSy+qwrUTP7oeOx\nhSswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeKI7oV76ElvKMwMpbDPTheMqlNRIzbBYtAnGLdLgp9ACIQCS1kWaxbq1\nxgyPdu8FqfQ73Fqk2Veat5t5hT3wAD8ZnA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAU2CjqH862zAmhodKyE1/5QAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGVlYmMxYzAtODY3ZS00NWVkLTk4YzMtNzc3MGQxYWU1OTljMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzkzN2NhZTUtYTdlMC00YjIwLWIwMmYtNmY0NTI4ZDE3\nMGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsrEpNzZ5Wqrw8f1FDXAtt1de\nQ6WD1zlkq8tkzehGhEBLyx9i26L1UfJywI3H1PEUBJIxIYXswJ9FgA5xvDOOhKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtBmLSSij0wjJuoYX1Aa9JrxKOREwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgRlj6zEckUVLxnDHK\nhVkN23pVQ3N6qRR9Xfxtm/LVFykCIARGd6co/2HSo+VINA5VsKdGN72NGEwsr5ob\nNQ/Ej3Z2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6823", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6823` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAeIcbQ+ZSkrLDzSmUFoxpP0qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MmVhNjI3LTk0MWYtNGExNi05ZTI0LTFiMGMzOGY0NmVkNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjliZmMxZmMtZmMx\nMi00NzU4LTk3NjQtM2VkYjAxNTYyNTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfQsiAYyjDHBxZ72M0J+nguxlVknlJ51I1G4/EW3hF33hevA8slYLrS6vl47k\nLNZwTvU7Wb2q7O9hF2t+TJTnH6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5kW90xi4NDwGgK0MEnlO5tJO+XswHwYDVR0j\nBBgwFoAUMLLWf/+CxmVjHSTmroXW+bMl5R0wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICKQ/04uy1QL\ngsHkZIM0gZiFSKF4vJgRUlW9Ijv4zYM5AiBcsWYhaRogP4EWTRKEfz9SPw/9+MKI\npGUAGnvDgdfgTQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXEaF9N6YNuiZeSnsc9uxEoPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDJlYTYyNy05NDFmLTRhMTYtOWUyNC0xYjBjMzhmNDZlZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvtVIbYQurvh0pf6aPUALkxt7pjfE+OTaDopz51exEvIpJ\n+AzH7vd56pWU3hdp/KaWwHqzc+CMWgk1AqeeHSDSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMLLWf/+CxmVjHSTmroXW+bMl\n5R0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJYwuTEq3c0zmKMznyJVz3jO6AcwRi9Rdkv5jOf53PKaAiBJxDBa4Bri\na75G65OECff8Vv2/OaWyjB+msk+bpatJkg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAYH3IHrUORfoWflOz0BfF5SMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjliZmMxZmMtZmMxMi00NzU4LTk3NjQtM2VkYjAxNTYyNTNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTBiZTE3MmQtY2UzZC00NmJlLWI0NTAtYzE0YWIxZmRl\nNDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9nnmELbiptoJ6KJoEyZhETv6\nvh918NDUlaD8AVQsHBlAwUprnLrom+g8vqll51tIk7yCaDVvW4wJXpn2b0DJj6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5kW90xi4NDwGgK0MEnlO5tJO+XswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgUl9fcq8OoV0dHlYB\nWOlOLsX37wFn5RGUm5gjYSQUiLACIGvSO12Ouc3/y8kq+HDs5Lka3G5GdV2a+zme\nXqELZqq6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6824", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6824` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAY3wbFzmjP1xpVQigQO3ieuHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxZWM3NjQ3LTdhOWQtNDU0My05MDZiLTVjMDI4NGE4Y2ZjMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk1ZmU1OTctNzky\nOC00YzQ2LTkzYjItYzY1ZDc0MDNmMDc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPYOPURb3Ae+0xSNV1usOJRR8EEfJjRn+HRvubxwffE67ibzsAdyt3yJ5eKNX\n/1mU8KsmtpKwV6XtYUG/YKF27aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6MtqUOYt3PN+nmq7G/uqC2Jpz9cwHwYDVR0j\nBBgwFoAU6LfuEVAilVGUH1ngv38xnBENn6YwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCZjTNqBesSkhGX3Sb0kaqnnFptc4Jfsh819Un90MgRswIgHguAPi2P1jNe\ntrvZ5XbDLvjWNEWZE88h7rzBYlmKN6w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcSrJY3DGEt5PIR9jljux5sUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMWVjNzY0Ny03YTlkLTQ1NDMtOTA2Yi01YzAyODRhOGNmYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqCI4jubTQTSE8IUoxbvORd9d5oA/3vulyln+ReBHFovcl\ncn92BkE/PRwdgRZ5ER4E7cUSXD39Ay8r3IXrlXINo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6LfuEVAilVGUH1ngv38xnBEN\nn6YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgey5AylmGPk2ZjbA+Ndxu/wP+DCTPUYnUdRe5MIt5VioCIHtFps6oD1bF\nLAJhH073WIiwamXL1UCZ4UpI1/Z04CHh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISARH30P2/9e28+Qx2857o0VWpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk1ZmU1OTctNzkyOC00YzQ2LTkzYjItYzY1ZDc0MDNmMDc2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjMzZDEwOGEtNTIzNy00ZmMxLWI4NGMtY2NkNTY2NWIw\nMzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1iq3kaPDr1t+OJv4v5zlTted\nkJ3GzTHozsYq7wuC/bMIrJeEanq1vPAHMGAiPfLlHPFC+O1KInhk6+rq+fME/6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6MtqUOYt3PN+nmq7G/uqC2Jpz9cwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANMDDOUlabRoVQLd\n+I3MANASR3DwtHClZahmqqrHowslAiBdh/yjCO/RTL0A9JLL8q7OWBRyvkpl4kpf\nP6KJEPLzFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6825", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6825` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZMYU4+zHHzPxFFqWSHON/W2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliYTg0MmNmLTlmNTctNDI5ZS05MzYxLTk1ODdhOGFkN2QxZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA0ZDRhYjUtMWEz\nNS00MTFhLWI3M2QtYzQzNGFhN2RlYTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZwWhe3fCHldgG0KMPQ1Nw12paxNtDflHYYqTVQjoKF4iStvQidY/0Os+hzXV\nKhucZAz/9O9ihM3lJp/aHzA/bKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3o9maUpQw61G7AgURXs/biR0fpMwHwYDVR0j\nBBgwFoAUb1Gp+39uaG8AHtsQrVqvg0wea0MwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCMaXjOx5voUSwzztAQ+2fzSNLEEkLfhDQ9OsxYQfqbFQIhAPBAcWgK+CLi\n0bhRUYOewDbIG6Xpujf8UKhfPvtnUg4b\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARUoD9GNywR6SIIs8xe/UkKdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmE4NDJjZi05ZjU3LTQyOWUtOTM2MS05NTg3YThhZDdkMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASL79tVx4pDLFSEX0DKBRPMMJN5BuichtR89fBuj6KRwNIf\nHAl7WZNc5ZFxr8M8NgtiyY3KOstF/oFr4ouApkVQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb1Gp+39uaG8AHtsQrVqvg0we\na0MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgf7mDjydOW6+fiBUmVsUL659hywAswaHORGQO4X6K9ioCIQDCcPb3XTOV\n4J+cFaMci9xIrQcsBRakstlGv2isLArCMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAWGC7Dsa4ApFoXlvdSAvKkKIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA0ZDRhYjUtMWEzNS00MTFhLWI3M2QtYzQzNGFhN2RlYTdmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjkwMzAyMzgtNGViOC00Yzk3LWE4ZGQtZTE2NGExNjE3\nZDQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG/0nP/6F1ZCJSi8grFZ7zy/e\nsQR3uYhOS+moKOgxmxuvNwntMCt7aIoI78nlMjCqtWc0fn1EAczSn2ay/KDz16Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3o9maUpQw61G7AgURXs/biR0fpMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANzP9qeyJwefoo6H\nt5BVC1ZV8ooMBxFEPUJKBCaGW3FMAiEAmUwzBGJoXDY92O+AIJieRYyddOc3l3Nn\nZ5AMM2aJR5Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6826", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6826` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAcAwDqKxGtRc6XtjuKnmlsfyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiYjJiMTVlLTgzYjQtNDE2Ni1iZmIxLTUzMjYxZTBkMzdjNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc4NzA5MzQtYWNh\nMC00NjY1LThmODctOGUwYzlhYmZmMWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECxYggjmxDEiZs8BhpHFH1KNUEvQhzleL0BTMc8lxqzuMdBxMT7jvNXAR7XcV\nHb5wqRc0lzu9x7XNlsuTnc8GhqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbmXQhLWzLzW0WFUe50YJ/qqfe+4wHwYDVR0j\nBBgwFoAUeuo2JdoGmcHZ4WS4emZOscCOFWQwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDV\nEqxB8PDE2nicGZfSEtetMFIVxJEMRjUb9FJIkfC7ugIhAMO5S5I6uWOvKJTOMV3P\nOx066HVlOz7/W4qQPd7ImPKV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcAjfVR44t6n/ooKZRwueObbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmIyYjE1ZS04M2I0LTQxNjYtYmZiMS01MzI2MWUwZDM3YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHU2rQVApnuf/EhL3yh5ufK/WBlWwL4JIMcC22J8WfvI4s\nfJVOKcj7q9dFQDBBH5MZUc0dHuC6/C2Fh8tTBS5Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeuo2JdoGmcHZ4WS4emZOscCO\nFWQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPelrU1SYQ6ZWOy99W0YBryR0MrSSMomvDClF74Hd+0KAiAjMecUWgy+\ngk8vSCzrfZVw8aE2wV8PXwsgPczN19ezNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAW7bgRnfrqikqUAwbSu/39XjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc4NzA5MzQtYWNhMC00NjY1LThmODctOGUwYzlhYmZmMWFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzhkOTE5YTktOGJlZC00MDM4LWFjNDAtYmMwZDJlM2Yw\nY2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbXgCa5+UBLXS74haDCif7yzx\n9idIfdGK+ijQOZfEsZ54SqbYiwHDXiiXdC+9DWe5OH+5D+GUHxjXmTErII5n/aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbmXQhLWzLzW0WFUe50YJ/qqfe+4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgE1oy9wJy20wx8HdX\nx/Ck05K2asuGw2pqE2Zpz2vkb6wCIBdGU0Wb7aDlWszxq+eenVbZrvuhcon+C1h+\nvL/2d3bS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6827", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6827` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAfJgDe39agnVnF7HcylHPLnfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzYTE4NTI2LWMwMmYtNDZhMy1hYTQyLTM1MWNhOWUzMTYxZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRiN2ZiZWEtMmMw\nNi00NTUzLWEyN2YtZTJkYWJkN2EyYTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGtb0+KyKsBMx81wJR0SOg/dVFt/US09tfr+06mZULY8DESQGlXIeWLT5D5D8\n59nCWyoTx8r5lE4HEEeyb2mcJKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbyMNzk2rTPPiRj4a2wpZ59PgHuIwHwYDVR0j\nBBgwFoAUXuaGge2vs6HfSUz3FL6q2ABEMI0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQC0n4CGjeSoscm6iTEsrvK3ZtOsYvM3WkExj2HxcVDJ8QIhAOjT\nnidudc20IAuHF1JCoQrsCKorO75Ow10WTaBI1g0D\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVyxvFGDlQDOM8mvPLzXLSETMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2ExODUyNi1jMDJmLTQ2YTMtYWE0Mi0zNTFjYTllMzE2MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRCxN2o5WHgqC5NsHD8DqbRp1v8vG9+sFsq2cKiNU9Mw6Q\na/Blu5kOu9NL7ZaIqloZ4XAYU4kkvGQmmDXlnglco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXuaGge2vs6HfSUz3FL6q2ABE\nMI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQEBwBBNZg40AmYXwX6ZMgCjRYpd7LVVy0PIMOsEmaFsCIAzFqCHA8qvK\nmVn8xnDae9V0fxuDdSopX+Piw7BmECp1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAWEdZgp8IjXUs6URS0YGPBFAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRiN2ZiZWEtMmMwNi00NTUzLWEyN2YtZTJkYWJkN2EyYTU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGQxYTRjN2ItOWVkNy00YzAxLWI2NTItODg4MmRiNWI3\nNTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFcGFl08CqS/4s+C4DRGEACg8\nJ1CZ8M+/XE2NJMpDh4tPYvu+FMW6CCLmh7KQYR64e5nhzivE4YfMxLf9McQImKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbyMNzk2rTPPiRj4a2wpZ59PgHuIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgbDwkf8+jOYYxUPNU\n2bzivqt0qX8a76kYKe6Sy+DBaukCIGqCqqgA3sCv1n+/2nPp+wDOuwm+t9FUG6TE\n/+IW3q1H\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6828", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6828` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAfjrNfghJ25HK31DZ7s9BuPqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyMTcwMjE3LWNhYTYtNGRkOC1iOTM2LTNlODMzOGIzNzdlMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI3MmU5OGQtYzcz\nOS00ZWU2LWFiOTItYjVhMjFiZDRkOTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYN+w8tbC9wOgsDW4lehTxh+yiXxO8pehHvedeUNS3Tc8/agumbRZK77kcApW\nfSjXbY71qFFsvXPpFTMC1oMTaqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhsqdx5SqSj3I6QQsAuTijfKz6ywwHwYDVR0j\nBBgwFoAUfKaFUDeRzXrWyIYb2BXWk4bLcAswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDNd/RLSYbcEZB7730q+uCiDvv/w4NBoA7z8oIxpNdPXgIhAOca\niweJ6HB6fK+Rdfvh8qXFhqBZQ3V+pGqseWml5zzd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQXjAQiE7FfTQ9JThM8aZmwzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjE3MDIxNy1jYWE2LTRkZDgtYjkzNi0zZTgzMzhiMzc3ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFU72xEWBsLYIFdvO6qZfis23W76dwhZTcGcboJolPxiOO\nzpGNfeVYHC+JmqASJnSEfGALcbGYH8uY9uIoHgrto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfKaFUDeRzXrWyIYb2BXWk4bL\ncAswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANs0/SVgvqwkobO1IcvNHIjBE/TZ04Ldob/CXjAw9zoZAiAI1mCrAU1K\n8/CK/mR75+6aMWF687tfqgqdmfx7W211tA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISATAao0gPhWGBUpkAvPS/o/MjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI3MmU5OGQtYzczOS00ZWU2LWFiOTItYjVhMjFiZDRkOTQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGU4M2JlMjktMjQxYS00ZGFjLThmNmEtYzU0OWZmYzNk\nNGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENvHO7ezKvf+p9VNh6h76oNjB\nCItCyhnaLvaXyvzuNS4PdgtEgT8O29rmi7p2NsKM5Fl2VQUp7ES6CJ1aTs5EwqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhsqdx5SqSj3I6QQsAuTijfKz6ywwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgPsKv2o2V4h4U/Uh3\n6vB6HlyAj7tkahbIXAfAI3Nn6UkCIQDMBNNvFpgwjYsFuatMuOnTihEU/+MhRreO\n9Eg2pTjZEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6829", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6829` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAdzGVTrWEDkTd42sXEl4jaUvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxNDMzMTVjLTQ2MjMtNDRjNi1hYjNmLTU3MDlhOGY0ZDQzNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTEyNzM0ZWYtNDdj\nNS00ZTc3LTgzNGItYjIzZWNlMGQyN2FmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOnzPBMN/3aM1l+ZaubEoSPk57shuCKQbcM0v+x/+Mz5h+oiE5ik34nbVTgmV\nVM88BeZZ/wxAAeXVY3W9mMwDsaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHL1Veg61LMk2bXjL2rDMRTBkERPMB8GA1UdIwQY\nMBaAFHEl1SttXGgabE8QyWIoS/PI3R0SMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAsMiqfTzEGbFDTNLNo4NbQC+XbAD8NQybB\nvuC5mSxITwIgJfBFqysKbesbFq0vhtzVuDWxVqWMBDjidkCoWnik+i8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS7IWDjXk2lLgQjF0T9MJc+9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTQzMzE1Yy00NjIzLTQ0YzYtYWIzZi01NzA5YThmNGQ0MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiHVMyIIZJGa/Q5tnYF6RJ2BEuBzp7eivkg3Uy8GwCAZmo\nFk2P+NdYcXoeRKalXEoJAf4mV3RGwZ5rJCaTR/cro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcSXVK21caBpsTxDJYihL88jd\nHRIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJiuuzL2SLAQ8lR8Vh0W3zUNYwM4zL+T3Sbd/77DwJWDAiEAkxhgOpse\nQm2BCilm3a/BRCHaORmHVPOul86Kj0zh2Dc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAW9wfuUHsIeKNnrysufItMTXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTEyNzM0ZWYtNDdjNS00ZTc3LTgzNGItYjIzZWNlMGQyN2FmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmY3NGRkNTEtMWE5Ny00NjkzLWEzNDUtMmNlOWVkZmYz\nMjY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5H+Lha5XRGt5KdGaAB2G9otn\nXCQorYdJ2ojPtQT3QldvnIsmJrYWhdoEpL1Q2TD6ekeYy9ZS3PFvwdCLp29YqqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcvVV6DrUsyTZteMvasMxFMGQRE8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgFHY3m/J87xFuolY8\n8q9utRtiStBqmk9yRMqW4s4APwECIE1JTC74SOGL9zbI9eKwEn5qXFIPZ4tcGn4v\nhUo+eY82\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6830", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6830` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAf6iB/7XSCVJeCvAW8GjuzXMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0MWZmNGFiLTI5ZmYtNGMyOS1iMTA2LThlZWU4ZmVlZjY5MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBmMjdlZTktM2Iy\nNC00NjllLTgwNmUtMjVjOTJlODJkYjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1Gv1bd7ySxLxux49WPLpAJrfa1fQGe0uXOGs+oL3cv8Ims6ylqDc72zPC2sB\nLRHu/yxzZYtPxO6Qdkr6tXb+RaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAqSPi34uGv8klodMMtoLN5vRmtcwHwYDVR0j\nBBgwFoAU9VxYybH+/gAZQHAMOkbDYfk0GxcwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgOnIwkVKukjNF\nDi/r1R0e/wvHP1mDXhSVv99t2XO0PQYCIQDhMZnqmoDAjibQFr/SGqC5iACSzDhf\nHIEXiKdqpCjg7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc4Y0yf7tlYw+gw+yTXxHv8+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDFmZjRhYi0yOWZmLTRjMjktYjEwNi04ZWVlOGZlZWY2OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3r5SmzJbdltaweTb6pyRVcsboAGCH89J5sLioist/zfOI\nBePPjQyrb4Irqv22yT1N0gBEmZEEo4Qu8AJnsUAMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9VxYybH+/gAZQHAMOkbDYfk0\nGxcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANniPRKcAshrfhLnn6/FEdkjxZQfpojE6ghngrDrcqQwAiBwBBG/95Vx\nm7qiOyRi4gESA5ekCRY9FIG4akFm+nnuhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQK3XDIiRGBK9b37nuqldSq9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBmMjdlZTktM2IyNC00NjllLTgwNmUtMjVjOTJlODJkYjkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmYyOGJmZDYtZTI2OC00NmNlLThkNTItZmYwNjkwMTE0\nYTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj0NDV05R9Z5yN0i47c45cSVE\nMWsk2WB0eBikB971eWrbfYy0tfOywMFZReze70EbP5X31Yj0Syg/zijr8EDaeKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAqSPi34uGv8klodMMtoLN5vRmtcwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgYTDz9Wjr5+ecGSnI\nADUR02MaSFr8XNTJK3mEl5oK69QCIQDPSaGfG3JX7BLAXPdQV5xyPK0qUdE8wdON\na/w/G+G9Xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6831", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6831` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAf85/pCUB9bB02mp0W9P1bkZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxZWQ2MGQ2LTYwMmEtNGI0YS1iZjAxLTU3ZGJkODIxNmUzYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjViY2FkZTgtNTZi\nZS00ZmJjLThlZjctMjkzZGRmNTY0MzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYku8UU0C1YAtpAP39RIgslTVOQUpzeF/0zq23S2CAOenLsOzHcEDaIvwsUAK\nIGaLA2Yn/fvlgPFyD1AeI7qa/6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/eHOBc8QfA7YWqGFgZNoWp/3AFMwHwYDVR0j\nBBgwFoAU7VewRKm1aLE8eCq2NjjZX/QS+vIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgYOwoxnNIc++D\nb4ip7I/lKK/6S+0zzYLJjyMYu4gmkAACIQD5l8gZ3fpiGi5NKumcJRQgUtXghD+r\nliAO+db5u/R9KQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfkU0/uTPRmTSq8WXY3VwA6aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWVkNjBkNi02MDJhLTRiNGEtYmYwMS01N2RiZDgyMTZlM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEFVm6kiQORJXbawKbRTN+sW1hB43rPyrHowg4CdKLrxw1\ncGX1ChMUxFLwhQP1KL68siE8LFuO3etgjCjBkNvyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7VewRKm1aLE8eCq2NjjZX/QS\n+vIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPlaB276KnIU+enPWc3luloc1vcIoqMpjYBuGyYdAZKwCIQChqz5ByR5U\n7KIIqIVSW1XhFDmFp+Zge/WsIA1NcfN8aQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAddzxtPp+gAOwvXpC3Ryv6z4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjViY2FkZTgtNTZiZS00ZmJjLThlZjctMjkzZGRmNTY0MzNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzBkODhlYTgtZTg2My00ZWJiLWFlZGItM2ZkZWNkMzA2\nNTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/nfNUXn5ArYVo/3xmfCIWwzb\nbuReI00q2mUsHS+Q+Tc7g0KfMEDQlRqn87bFlEnzEMkxuQRh5kYJ5pVp96a/MaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/eHOBc8QfA7YWqGFgZNoWp/3AFMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgRoig+6h+hXuy0OYm\nxnqsowhkU7XoGzMl9G+8L8Tv2zYCIGjEfoiGJu7NKCMH+9sQYtoI4OS7GN48ksw7\nklOj7Yvh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6832", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6832` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYA9+wdFKMDAIadq98oV1q7zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkZDRiMTE4LTQ4MWItNDc5Ny05N2JkLTU5ZTU3OTQ2YjU1OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JkYjk4NTUtMTA2\nYy00ODIwLThjMTktNzJkNTdjZjg5Y2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEasK+cfJ1KDYfMzNcjhpIl5eShqM2IZZ4xNdDUh8KFZQa0QgzaZm4OLjsVP/G\nF43lzltOA4xSEwxno+UbplN0EqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6vdY57YOHE7vtVm8q7Y/VOsYlKkwHwYDVR0j\nBBgwFoAU0xaLeJPf0QGzREmKcirgqnylc7YwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDED82AC7GS\numjqQ1AIgX3XSb1BoPs7/79k/kYrM01rYgIhAMOafXjmjbSKzYoEU2zFpZWI5VlW\nqCBTev+f82vohDHA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa+caoinQha4J0NXscwOObndMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGQ0YjExOC00ODFiLTQ3OTctOTdiZC01OWU1Nzk0NmI1NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0vpgplUJXTWUIDm+HnDZOHfLJGGFr/FAN6zz7SdEzwYKQ\nzHJlDk1wmmMktxEOhwEO9ocAWRRCch7QuMnLVL0so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0xaLeJPf0QGzREmKcirgqnyl\nc7YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJfEDgSn436NMCov1BTAAn7wU60ao2M3V/3ADflLS+q6AiA+wqJ1UOSG\n0QeKQkLsI2nkU2pwuKBPsY7RtqzZno58mw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAf8MToiJ3GDJxCrJQoiU3QqZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JkYjk4NTUtMTA2Yy00ODIwLThjMTktNzJkNTdjZjg5Y2YwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGQwNTBlNTQtM2FiMy00ODdiLTgwMTgtY2ZiZmVmYzNm\nMDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEG70C3rutUh1g4qJ9Z/w5mYV\nKmOYfEud0gfS/7+1JVsvMojvuwNpF6sR8Vscvji211Eu6/gdT+kB+ud2V7X+t6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6vdY57YOHE7vtVm8q7Y/VOsYlKkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOeUcC6Ypz5BLW18\n11FsE2iN+3ho6ifONEhFSYzC79+pAiEAhRhgGpWnk01UrWFD4rC4iuLEJdsoNr8A\nAWFyNZ3ffKI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6833", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6833` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAY5txAkquBR9ZO3Krv2B/3UPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5NGFlNWY2LWJlY2UtNDE3ZC05MTQ2LWMwYmViZGFmNzNlOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjVhOTgzMWQtMTQx\nNy00YmQxLWIyY2QtZjcxYzVmODJjY2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjIzTbAo0o5joc25Enq6IqMTd6nexIjGHhUgxadaqqGW1ggktzSYHX64w3sZN\nwFWginbiPevE/NOBr8+axU6d36OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0cTAsoOSQI5yHDY8GjobNOXisOQwHwYDVR0j\nBBgwFoAUwffhwTH/S26kMjcXoBsUyLU9DvswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCrPDFZXbI9mtKnf8/Gz5mcJoc3suNfN0SmN1hUSYl8uAIhAKgDgCN+o1eo\nDuBpbWt9Nl2exeaA36NPQGTqnl+qOd5S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcUGatLbh0AD/RjACdN9UL8bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTRhZTVmNi1iZWNlLTQxN2QtOTE0Ni1jMGJlYmRhZjczZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNTyWYx0fv+HXfQ45N/4yUP8qFWLGp1hVcf/SmfgcBOr7u\n6ORtaWrcfzrujIaO2u59Nzhuz3i/ogNgq5nYgW88o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwffhwTH/S26kMjcXoBsUyLU9\nDvswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJcN1eEsaJTpHzC2vwYSfevXPuc6lgrCyjJPuu1PHg4vAiB8kIIV0+as\nZZQNesIuWJlz/DwRrre5NzN/ClSjeMQzVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAUngY5qihCiYOAdn+KSMNwxEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjVhOTgzMWQtMTQxNy00YmQxLWIyY2QtZjcxYzVmODJjY2Y3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDRjNThlNWItZWNhYy00MWZiLTg4OWEtMDhkZWVmMjk3\nYmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjHLhXR+kgRrcCYISbHBtMebX\nafqyvvqA8jRgZ/t8XrNe880c3nPzDWyth7MH6K2UWwtG37nibPl7BHAn3/RJbKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0cTAsoOSQI5yHDY8GjobNOXisOQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIiqA0li6RAQ439B\nTpU5/m6b60JMxSgO6DE2jgiNXFM9AiEAkO7giJ64bBrP6ds+PgEaA3o6qrBYtPHY\n6ShChzVY9LI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6834", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6834` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAaLDoHMRJXDx8XRm++Y6z51UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4MDg5MDQ4LTM4MDctNDU1NC04NzZhLTFiY2ZjOGZkYzdlYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRiNGIxNDUtZDhh\nNi00N2NiLTg2NTgtMTY3ZjcwOTQ1MmQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEblJ/uUo8NVLleb7AcGZ+/M6UcX/xv6vmnwwYTCpA1bEYSJyMPC+r4cHO7FOs\nxRiQkXykGgs515HUjhnhgoXgY6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEgra/1nCZXRv7okeMzNGwZPAxTUwHwYDVR0j\nBBgwFoAU0k8zug5QK8K9G1wjnTOWFG3Se94wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDxWX76lKl00KYwyxRzkQ0HVlhhAj0NqExNPXmHsK3JwQIhAPCXkQgRQvbJ\nwZvTN2+6+kVfFhW7rKeC3jD2rno21+y1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAax5ZVh8woiG+RQMro7YvfOOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODA4OTA0OC0zODA3LTQ1NTQtODc2YS0xYmNmYzhmZGM3ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXAYkH6JKpWRBRXtbQfXRG5BhBrvhSKs46DZ9/FQIwXXPw\nWVSBM/p0vOMgfz3xD5cZdmot16cIgNj+U9ETC6y2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0k8zug5QK8K9G1wjnTOWFG3S\ne94wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeAD0NibVRiaoEMsQV2K4acq14g3+GuO+wqC/hkSUBnkCIQC3fZWXUQme\nutduuGgZ+4+jjuC81kwYvtJYoGok9M1o3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAZeyBMLXqG6hJecchF3AVIeAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRiNGIxNDUtZDhhNi00N2NiLTg2NTgtMTY3ZjcwOTQ1MmQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTI0Y2FhNDQtMzkwMS00Yjk0LWEzZmEtODdjZWYyYjcw\nYWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEteQWN+RN4uSUz0ok5h4R2hmD\nFPhPIU5DpjYlro1oDi7tEGgVBSvfmEbBnFttZTFVddNKTzWyF2plOjlXDNmo36Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEgra/1nCZXRv7okeMzNGwZPAxTUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgYDav7wK6nxEf/huf\nVqCRzxwDGA2UHCzbuvMC5Qqz080CIFcyDHQWP6IMVC83IOAvqVfh20qmnGeZfmmx\n4IyV4u5l\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6835", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6835` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAXOpfr/qrUDt35bEl6UEyi36MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1ZDc4MWY3LTgyZmItNGU1ZC04ZjRjLTc3ZTExMjc3NmZhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGMxZDkyYTUtZjdk\nMS00ZDk2LWE3ZGMtMmIyYTUxZDRlNmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJGe+KtAEmD0tXsqDRswNy+m86UXC7M0iabLZcNRZDRDrz0PVTh8c07UY/hxI\nyD4bCOVS29Dmu1ro9erlNGG6aaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNki2ebWiDljn+ndxZY7pF5aI7tEwHwYDVR0j\nBBgwFoAUazN7pR0T/yRj+yafTYibeTROwZAwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHkt\n4L+bvDjxp4zFX35UL1HkjLIRaImU8sVmy+tcRyexAiEAzDPxXLcuPr6d6VWHN2S8\nopcjLyeVK9SNEBiTIrEDMq8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARSRdXrTGyd17JxuR5h2QTxjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWQ3ODFmNy04MmZiLTRlNWQtOGY0Yy03N2UxMTI3NzZmYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2zkzzigX4stMvgiIqSjYvJ+kYSiq50845iNa9h1jxQ56+\n+nTFz7/51hosXYH6vt6RJsjWkKKw12PuBrX3R2loo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUazN7pR0T/yRj+yafTYibeTRO\nwZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXf29cwyNOw7/j/DDyCjWM9rYjS5N/S+UWY3ZLL75/cICIG1l2Be0VK1f\nvoM1nhnC3IC/EO6LV7nyHEVYNbte+Yjv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZ8mT6O9+L/c5I4J3ekdXWKmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGMxZDkyYTUtZjdkMS00ZDk2LWE3ZGMtMmIyYTUxZDRlNmM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmMwNzVhNDQtY2YzNC00NGQ0LTliYjAtNmUzY2MwZWRl\nNmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo3AU39PQURKpvFJogZJMETAy\n2qyXnI5pWCJ0rftl2RbX2RH+XI0RoPvkQBejKXtj2Ym6vXgB/lf6YqjEy28WLqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNki2ebWiDljn+ndxZY7pF5aI7tEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOtYXZBqXBixYN3t\nOHxemE3cLrH9WIUpVZ0ap5vPP8b7AiEA0OEy20z6//FRZiUhcYywO4T1kcjYQbbc\nKCPNdsonel8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6836", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6836` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAbbhVymCBXN1/cZGgiV2ylZXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhZTQzN2M2LTgxMWItNDk2OC04NDhlLWYzZDU4OGMyYzUxZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzgwNmE2OGEtZTVl\nOS00MzkyLTgxYjAtYmQ3ZTI4MDBkMzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEVacEvFw+fWYHVyTDxEy4DLrM1MVixRPCQ91kmWXz44g9XjecAS/4DXFHk9N\nUV6tWCfVZPX0hpGBfCtVn3ciKaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgNHiqgXVbyl4X3RQzxhXAIm1t10wHwYDVR0j\nBBgwFoAUb2qEL/LQkjFuez0Gv86xvP6BuHAwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHJ05D1ApnOkMNIZVnP8jbhquaSUyQfs0+xgqjvuCOjZAiBVF74K\n5CHpsV4RsrQ5pdLeTsa0eow9jXoESPZnTtkMPA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ/FU+oCJ4xkSswG7SHETdiNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWU0MzdjNi04MTFiLTQ5NjgtODQ4ZS1mM2Q1ODhjMmM1MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5FxgS4Ik+7YOklVoOj+lhXiZEZoNHA93fWjz/sdv6OUVl\n1hET3k1UkKwkrULt9Lk6UWJ3QWCyVo99cBNmRDDYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb2qEL/LQkjFuez0Gv86xvP6B\nuHAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQa1eV05uMRrYOThzsrMoecR0ieLYjdzbMzp2/iI/f54CIQCYZPnbSUss\nlCHAU4a2d2ypO39oT8riKdEGGhVZwYEcgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISATgfUMPEcjnxQj+xXekfXfroMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzgwNmE2OGEtZTVlOS00MzkyLTgxYjAtYmQ3ZTI4MDBkMzY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODYxNjQxZmUtODVmYS00MjIwLWEzYjItN2MyOTJmMGI5\nODJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhle+VBHtS/6L4NqEvyovS2hv\nCDgle++q3vOrIWOygrWYYAFOzKSk7x6G3OZgP6nE0tuOJUSSo+fbiBxk5kVrVqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgNHiqgXVbyl4X3RQzxhXAIm1t10wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgXhwiC0pxPg6qjbGw\nkGkZZgolAkEndSyNSJL4wTkuItkCIQDZbMwQgTwTNI1qWFmEig/p/UJWq+PBmkZ1\ng1SCxZcCOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6837", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6837` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAbEuhVr+chCitYrt2pExhrwvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMWExNDhkLTljZmUtNDc0Ny05YzBhLTU3ZDM5M2Q2YjgzZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY3ODYyNTYtYWI4\nNy00OWQ0LWI5YTAtOTVkYmY3M2JhMzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEywbXhlfwxTEVYoYOAtTiP8ur9QqFGRhIS5uysQmOTyQeH7Vhv9LmR5JxG+Pn\nQMX4PE9qExTmEMWNtngWoPPFxKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWffBTCVksjnqZvDGZ+pOAEMh9uEwHwYDVR0j\nBBgwFoAUwm9T/BTL4aoKYax640qv3bIEzn8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCID1T9t+Hf8sW+f7aPdB5gH2H1lUvm9AGajsk48UGjVU+AiEA8qKh\nOtUgYQQXWU6zURyQ2twN5f+Lxcx1dmyzZvIk7hw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe3xmGXAhda2O9ZX36DWO2vSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzFhMTQ4ZC05Y2ZlLTQ3NDctOWMwYS01N2QzOTNkNmI4M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFP43mlv5DAq3vtGOzP/9JV5mQcJ0Y2QQ2VnpGgZe43wHR\nK2omce0egMVf7VAMZ/KYZMCBOSqx1U42A4VRWIRwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwm9T/BTL4aoKYax640qv3bIE\nzn8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgagUvVEb04/CI3xEOxnX7zNTCi5ocHfeCWsw4Y3utoNYCIQDLGwVF5Cmd\nQW2XsNQnWSLtenN0By79mpXkIfJGiqe21g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISARv+5r9Ix0TlMZn/iecLdEEhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY3ODYyNTYtYWI4Ny00OWQ0LWI5YTAtOTVkYmY3M2JhMzAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGY0ZTA0ZGQtZWIxMS00MGFiLWFmZDUtY2NmNjczMjQ5\nZDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEW2Fcpb2eg39W0BFlyubSTYWt\nktt5MjNMQqRmIn2lGfP1lPc9+5qc+yRSARNDoTY/VhqaJGruNRfl/TsSUi7nMaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWffBTCVksjnqZvDGZ+pOAEMh9uEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPPeuqrtFOCkymHW\nEGpU9xZskpWsLJvqtC9uwj0pg+CfAiEAxfxz+TCpGQJINmuFPfdpBSMFLJ+YFaPI\nvrPbkB4G/0c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6838", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6838` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAQlCLC69ZyOKFFc9PiDu0/MlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5YTczZGM1LTJlMzYtNGUzMC1iOTA1LTNhYTg4M2I1ZDI4ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWE5YWEwODctMzll\nZi00MjhhLTk4NjgtYWNmYTNkYTA4YTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEucDi6pqqsQVKmhM9WVKt+GcbzoNWj+8PWHwBVuIDtYYEwSgGCdNMFTr4O9Cy\n4L5Kn4CFAkO+rqJ0vidLaQrBJaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTRze5tnItKS2pjHBUsiTucbqhZJjAfBgNVHSME\nGDAWgBTnOsSEcpioX/K4gByylmr1iSkpXDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDqn5wCipjfdqag/6sduTXtKMCmoByo\nMF+E05YTJBVAqwIhAM89hsQQTJaKixmRBYmP0QV4fdHFjZbU8mMtL9BG+jY3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATKKAUbbW12iP9XxZqB/xthKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWE3M2RjNS0yZTM2LTRlMzAtYjkwNS0zYWE4ODNiNWQyOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBD1EFVKXzJCsURebE/+9Nbig6e8Ja9sAfaidb8/8VEIOi\nWTsbFE1HeN8Qy+CWmgxel7jS3aOR1OmNbYcpJlKpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5zrEhHKYqF/yuIAcspZq9Ykp\nKVwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJpfBDJ6MDhwOlGMTbcgK/W2DqIDH/XBnukVTnwiV2PYAiEAy1cfNkal\nNqc9mSL6jhiWHCWVz9vVUEQE+WAdhSiiWNA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAd7or9xbutLMopCPXLqNZzGpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWE5YWEwODctMzllZi00MjhhLTk4NjgtYWNmYTNkYTA4YTEwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzk2Y2VkN2QtMGNkOC00YzlmLWIwZGQtZGZiYmIwYjgw\nOGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOSc2UHKNQzA1SNkFPh+iBPfa\nRspSneazqoQAO6NSVUAotiTv4U11QxsQsYHPsz/AahtjOWz5P7sUqf1aSkwEVaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0c3ubZyLSktqYxwVLIk7nG6oWSYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANgy/xAF6bKrrbUf\nKw2IZ8Zany8gp8/sENQOZ7Qntr4cAiEAlyD2NO37jXLk7EiO6xkM+ZnPxPVWptSB\nZhoiAEP459I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6839", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6839` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYNuSrG8svTOAlhu/uPY8iolMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmOTIwN2UxLTJkYjgtNGYwMC1iMWM0LTMwOGViMDk4YjUxMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThiZTdkOTUtZjlj\nOC00ZGUzLWFiOGUtMThhY2IzYThhN2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYQRVB7DNBQiD9IHs6+yw8gLO06cqAwT1xbqM7q1+j4uw5UWhT4EhGEbfDwLG\ny6SgwC3EkxMPIHOwgE0S2qPJi6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD0pTwSmiG3TOk97EtqRzKyNPvB8wHwYDVR0j\nBBgwFoAU7XdnKE5/zDlqWlPv+i5kK0l9duowKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIF0vmSHSm5/N\nrKFGprENHp3OzdzvK8n0qzMN3xf/Ur9GAiANdhCBVYnJeDNDcF7kXEjiHfY/rWju\nVU4V2uR4iVzQSQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbd4m8anPNaLjw7P8IU9lsi0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjkyMDdlMS0yZGI4LTRmMDAtYjFjNC0zMDhlYjA5OGI1MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJ3v7s/xfucfYP9cvd0xI3ldR00H8SJvHVkcKAjXUibD88\nrt9khCgwh6n4LxGS0617CgQLlX2pQr+lFx0n93GWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7XdnKE5/zDlqWlPv+i5kK0l9\nduowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWiceJHka1kA8bjK/KliP07ywEOniFOcFC5EwHR7K/DYCIFMs4iUGgVfq\nZBMcdnY0NOeZIHHQIesVPWk8SQVLvDZN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAb8SRiXmxdfP0n+7QBPcWRNlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThiZTdkOTUtZjljOC00ZGUzLWFiOGUtMThhY2IzYThhN2JkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGFjYWYyYTUtY2JkYi00ZTIxLTk0YzYtYjYzZTlkZjk0\nOWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERlSL09HomeiDJwUju3hgpOdg\n/TgfYd7c0q7wUnvn7ukl2/wVy7uIZsRAhlVQPtRySzexJEm0w+9jfuwcB4/0e6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUD0pTwSmiG3TOk97EtqRzKyNPvB8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgZj7CuF5w/geImq0z\nQE6mW8HjtMsL7FJmXkOe1d5Zt8MCIQDf6vXmxpm/YwwKAsVZrwymUCNjdu+KPp5A\n/ipvLNKXuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6840", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6840` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAaZ2hTEHGTfjabBn5Clh4j6IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkOTljN2NmLTE3ZjMtNDQxMS04MDZmLWFjZTg1ZTQ0NjUyNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNkMzZiZGQtNGFj\nNy00ZWNiLWE4MDctNDM5NTIwMjAxYmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqglFmmxnhgqCgF1vVOke8SC2hOWnaNLdKQnXL+oox83aSg9bC8yjFe5hzfuK\nzLvM1b9o1sDud+Z+BOCjZ9xnKqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5nUDZgDo2spuMABtfolq2j9BrtAwHwYDVR0j\nBBgwFoAUtzgGipUzVPJAktVbntC3/VRWnqwwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDeYK11GJHl9\nVlojsJrqb907cZ1KmK3zCZxm5cLAGPbbAiEA3ga/HIqDUGxI4IBORvhAt9LjRLNS\nxJtkiZC7+tNbxK4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUSo5XWcK+Gzi1ksPGfTxsE7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDk5YzdjZi0xN2YzLTQ0MTEtODA2Zi1hY2U4NWU0NDY1MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWANlyA50wsCMS1yFlvatGL9xj2OBNh9dpG2fn10Z5SP5E\nlFX5Cz9HnpiJgJUGS4mCH8oXrkFdDx33J+PGIg4ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtzgGipUzVPJAktVbntC3/VRW\nnqwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIH7oCdrbfdh7kvLkFvdOMBfubnSdu8OgwYYFvCceIL8AiAnv4NU/PEw\nuThnh7oGcDF0O3si+UoxEY/lSPiVmpHxNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZrslhbGwFKK1mFS7nYOToLEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNkMzZiZGQtNGFjNy00ZWNiLWE4MDctNDM5NTIwMjAxYmI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQ4MjI5OWItODFkNy00ZmFlLWE3ZTUtYTUxNzdjODZi\nNDMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEI/C3icllr8Se4YbJAuycHAQC\n3hUmukFGji2sNM5Y2pO6k9ifPP7GTAImQHZVw5bvzya6GS1r4KXZECPdaPKi+KNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5nUDZgDo2spuMABtfolq2j9BrtAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMMAQ38JZdQPsdM2\nTo7vi5mfTrJfC2RDzkipJf28qQuPAiEAu/Ds1yNgoD/QGfy9CSyEKYJw4BD89kEu\nSQBYOxl11bs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6841", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6841` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISAcHrstL24/F3h5WVMr8zYKcHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NTkzNGM0LTk3YzItNGZmYy1iNGM4LTcxNDk0ZmRmNjgwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2MzYzNiOTUtZjY0\nNy00ZDE3LTk2NDctYzc1NWMxN2VjYTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVRNXu73fRgRfxXJrEhUyt1KiQ2Yi3r+0Rb4co3NnZmX/CzRRTlNZPlt/fVuN\n9UP/Wbvz1P9t3gdfWJBGCEoTh6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXieP6T/GIT/Gh7STTswNoEBrqsowHwYDVR0j\nBBgwFoAUJ6NkHZq47S+/ZZCnRM++NLFmAXUwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAxegdhUgN\nyta6FdtQhGepNMgGxSEOKZzmuv8UHaOFTZ8CIQCiIq/GAx86bc/5lxAo2JfOzJXy\nu+Svo2rwe3I01syvcA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARtR0gv2UjYcvhwX/BP1kixBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODU5MzRjNC05N2MyLTRmZmMtYjRjOC03MTQ5NGZkZjY4MGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6+o+JLDlmFm75Xz6YScrivmdfZSyzjOYxu+xi5xMEiks9\nWNcDU4qlibEYUz1p3h+m98mJ8fpvt+Zz/BARI8tio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ6NkHZq47S+/ZZCnRM++NLFm\nAXUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALt0hZnQrpJ/hlShsgx6X6VCtCvQ5PNbXAdLIaSnBiC8AiEAuz9wE6E+\nWInTLz1uoO54yvV5f0fx6ebhzug6vlEiAtE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAfKTlmx/6g2JTHx087jk5cz0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2MzYzNiOTUtZjY0Ny00ZDE3LTk2NDctYzc1NWMxN2VjYTA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWFhYTNjYmQtYmU2Ny00ZGZjLTk1YjAtY2Y4ZmUyZDYx\nOTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6/vrRcFRdAZo6ggDQw5f9haZ\nctakmF0O9doL3upeM/c9Gtm/uoAKxlDiM0H4DeF9t4lqo3tfR4NfREnAu8kZkqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXieP6T/GIT/Gh7STTswNoEBrqsowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIlzCfceee51cJEG\nKq+dMITkf4a2QcrqtFURoKoSpHueAiA+JVaZXpiJkfiV07det6PG03PYeJ3xuh4x\n0AUrqLYaSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6842", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6842` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAURDbKjrU4G/S+SQVVAMJ+laMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyMGI0MDMwLTVhZTItNGM4NC1hNTcxLWU4ZmQ3YTg1NzdiNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAxN2M5MjItYjNk\nOC00YjZjLWIwMTctNGQwNzU0YzE4MmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiwTZ+t+0AlvW+9d2kBfvwnxOsDZiUtlUVvivbczg8uHeVQ3+n7/MMAS2+Hql\ndh6+qh3Io/XoGGsY1x8vaRnIpaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKcnMj2snVPJmkdB61Shq7oW/DE0wHwYDVR0j\nBBgwFoAUFL6Qs1rbz5FXFDHtB5FM1whgm3IwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiAEsiVI7XZVYXPVv/7RAgH0YzSlfOEZm/yrxFYeo6NDLwIgTRUUzleRMhW3\nnH2d98NtJ54f4B9CEgB7h+xz/LCmaME=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQI1E4a/gUz25ZQfGqGx5MBRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjBiNDAzMC01YWUyLTRjODQtYTU3MS1lOGZkN2E4NTc3YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4BR5ciog2UVaiJ3CF73nd2/zz7ly7CTlAENo/kMhqJXQ6\n/akL077ZKGnvZBHKqTT4Cd0xWRvPNLqWf0JIG8HMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFL6Qs1rbz5FXFDHtB5FM1whg\nm3IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEVsY1+OuNq6rxNoiO3d2QLotm9GkcIj8Gl2fFpDz+60CIQCIj6kHQ0G0\ntVKBvvakTs+4Zwy5n7Ru1ZP6r5ZuGrWFSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZa/bFlVimL9ZdECD0M9IKctMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAxN2M5MjItYjNkOC00YjZjLWIwMTctNGQwNzU0YzE4MmJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2M3ODJmNGItZjkzYi00MTg4LThiM2EtMDJhZDAxZDRh\nNTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgCUiz6INXw1V2Zyujsk4PPrY\nMHUdyHMp3QHtnvWDw9uw0PrHNUhkj5joOGPpnvfKG/j2ebCKmr/XMhGNvbwbPqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKcnMj2snVPJmkdB61Shq7oW/DE0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAM0coR8ekVJsO8SJ\nN1V9Mv4kHg9tsIB1RWZJwWdlCZRBAiEA4NJyxpSEXhlti0N7Msf4nIxTc0XnMfnQ\ntNdchgKikQw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6843", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6843` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAa23uH97VOwRR2kPXreb2yRiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxNTE2NmJiLTNmM2QtNDg2YS05ODllLTRkMjAzOGViNzkzMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNmYmUzN2EtZTdl\nNy00OWRkLThmNGMtZWE3M2UwNTFiNjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQK+0UIKxTOmeoaWOyKM+T3EuC/6FN3vtoV5pAArStCvfzGPi3mcAn9Nluk37\nOy1pMM7ttlmj6iLLkyX1d1gA5KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPmXhgYtQyjvLfF4ZxeXwVqUjg/4wHwYDVR0j\nBBgwFoAU546vcz5eKKPQs2PijcOybOg9lMkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiAR3XGH8wbOvApqjISRupcwZ0ZoyB1ov+3U2a9UBAEZyQIgT7mlDZ2Nk+z0\nJWMqY+0Cl2S0cIwIPC9GrT/NqkvA+uE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcLrdKjPJ+aae2rOlmO3UdGvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTUxNjZiYi0zZjNkLTQ4NmEtOTg5ZS00ZDIwMzhlYjc5MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLzd8mhQZtzUlizoKbFlUcYBU+vQt6vmLMEnOGGW/lb7a0\niCmSdJM/BibkiwjnLzghacn0dB29Te50uJJdhrVxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU546vcz5eKKPQs2PijcOybOg9\nlMkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM5gTOcwCc9VFyGKaZBdKGZlLVPLW9b5gplGgBUqLQArAiEA4IlfDrSk\nfer7WYS+nrXAMbi9Y9tHBax0SV4iuViI6HY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbzRNSZoYwA9SkfeGH9vVDQTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNmYmUzN2EtZTdlNy00OWRkLThmNGMtZWE3M2UwNTFiNjQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2NhOWE2MDEtYjc1ZS00MWI5LWE1MWYtYjdmN2FmZWE0\nNGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj69dV5EcAALizjioS+Wm0ViU\n39RT1EPIsfwulvSLeMaeoz2tQhk93JV5KblQOqDf5GQ8JVVCLQezDF0EH81vd6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPmXhgYtQyjvLfF4ZxeXwVqUjg/4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAO5Ualjh4wOhsQD7\nuWQDby1MGm/XRj2llN6OEHFzjgGJAiAvFTKHd+OjkJpMkeDMTy8o6h5V8pqsP8UG\nbPnXJpcERg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6844", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6844` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAd8pj9j5qcVFpZjGBccDJ95hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwOGM4OWQxLTMxNGUtNDNmYS04MTcwLTQ3MTljNjk5MGFmZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDEyOTJlMTgtOTRj\nMi00MzU0LTg0NWMtMzMxOTIxNjExNjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElS/6dEYCm53rxYI9LUfhQmykhnUUqL6Apu3/qPqlLk5Xoa0vnSlhJWEdxij6\nkSMI8VwuUEOOivxD0X1EeeC8Y6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+hU7Hudm18D+ffoNvbuZRi6PViUwHwYDVR0j\nBBgwFoAUhpb5UD+spRxQcMhUJ6ZSHcicvUgwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAt\n1+tbdvH3iGk5jykmw7yLcpzw2BJaMNDYFL1M29hgzQIgNpEUNlWNrjvFGgRYeY6m\no9VjKFvKzo6YffjtLI08rzg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWf+ErGMY28YGVJ+eplpkAjYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDhjODlkMS0zMTRlLTQzZmEtODE3MC00NzE5YzY5OTBhZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASneUBz8UZlZ55ks7MUbmmgwBd7SQ3s7LwevlTdpXWRgxHF\nwuSc6DaOyyWLTSKanI7s+BpOV7QdfGHdaYc1h5jZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhpb5UD+spRxQcMhUJ6ZSHcic\nvUgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSynKfMOUMt2Lp0oETQOWCxcDJCtJurIE34f2FyBceZMCIQDskWEz0oOG\ndSStiq7Cvn1h/JBZabx7JBVYOBh6mhnnpA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAQITB8vnAl3AMtEQ0yv0waa6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDEyOTJlMTgtOTRjMi00MzU0LTg0NWMtMzMxOTIxNjExNjU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODRmMjZmYzctNzAzYS00Mjc5LTgyN2QtNjc2OTdjMjQ1\nNWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErJXy54dvBdnp3yUzdfaHp5m+\nn1uiZ27YSuAr/EgVWu6SezSusrkUP3rKOMJAaFIK18Uw4IydwEqNduapjrTEpKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+hU7Hudm18D+ffoNvbuZRi6PViUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgAtVj3VXgDF2yx2Ny\nb+dMY8c26PkkWdVzHGGlcgycm/4CIQCG5XCvAq8oDIjR2IhpfO6yBBSRV0EWejPu\nwLvSJxKUgg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6845", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6845` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAarNXRzirC5mqa7BmdAPw+cnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwZjExNjU4LTZlZDgtNDY5MC1iZGYyLWZkNzI5NmQ1MjNmMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmI2MDMxYzktZTc2\nYi00YWQxLThkOTItOTg3NjFiZmZlOGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESdMj+pgH+4hZ4NQ9JsThk5nn9gQnUT9CEqrE6Bnr1saNVh4nthlOaLH4F5QR\nOIAm669gQRZYiCoU4qZi2IAsp6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvfGG5uPu9gFoOTrD1fTKY6mDYwowHwYDVR0j\nBBgwFoAUFp0RTnLzs+Q3ytudSREeKcD68JswPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiBh8Ky6Et4z/GpuCMz0d93NwoSLFKTafr7sEwlXua9KaQIgQlyZ\nDUB6ODtzw/GdgQenWaf3FbT4UARNvspHsGBHogw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfSFimFoHMOvogVF2j6Uzd8XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGYxMTY1OC02ZWQ4LTQ2OTAtYmRmMi1mZDcyOTZkNTIzZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1ooNHQc+qHhU2/XN9xsHCUJHGcQrUqfyvQ0lcfYvZVGsw\nKQCNAuWKI0ZRvIrRDwP/FTd5If/8SKshsW1TxDvWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFp0RTnLzs+Q3ytudSREeKcD6\n8JswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK2Iyc7kICFP5KQ6dkucdC12iCbxmyv6Ry37AWoIibb/AiEAxdHB5Zfi\ncVVzc1yGHwkwq00HBe9s9xno60aEwmZQGjQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZ5DPscg7mGktKsh1rQ88PlmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmI2MDMxYzktZTc2Yi00YWQxLThkOTItOTg3NjFiZmZlOGRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzIwZjQyYmQtMGY1Zi00YWIyLThkMTMtMDNjNDkwY2Q2\nMzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4JFyYu2gESTJe3J8yUiGQFby\n1wz237ywbR1fDfbgOIP49BDHEVCdK3MMrS7yML7hrZltAcXxHaSZOKPhoondlqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvfGG5uPu9gFoOTrD1fTKY6mDYwowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgKHqHOH84h7aLFmPk\nvE1mav+nUyg0NmZjbwQvftiogKICIQDAbI4nHWw3Lra6Of6nbPJkQBXRtbz/vPvb\nst8Ngy9i3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6846", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6846` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISASW1/7pYcfBUvBak3mOn2El0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhMmUwZTJiLTg3OTMtNDQ5ZC1hY2I5LTVjYWFkOWNmOWJlZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgzODc5NTQtMWI1\nZi00ZjBhLWE1YzYtMzliYjgwNjg3Y2Y2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELt2zGmY7y/beRB0keHQXcJKr3GXHGBqLgLcjqU7d6HKWH+b2+AHzk49y+3II\nvqdAXkDWL+l71qL75yslyxzsr6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXebeYTNg71Il7JSwEA6ysswFqyswHwYDVR0j\nBBgwFoAUQRZn0eatZnJVqwuDZEku7Kpl4t0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA+GgWcV2JPShB2/Zas4sIR8s1DWrn0DXF/tj5ZbbndDUCIQD8\nz1GVC+gZc5aU4y0O3YV9aE8b4jgySpYCA1HD+LjmcQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARIQ8u1WmKiGhGELpFt9roCHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTJlMGUyYi04NzkzLTQ0OWQtYWNiOS01Y2FhZDljZjliZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhGrhpEZDj8AR9ZFTqEScjxhAVwJC83VI2RS6IfEka/1va\nPUTFzmmA3NZLRmyzXxcAa6F2s2sC4iK1D7E7fVJqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQRZn0eatZnJVqwuDZEku7Kpl\n4t0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPkv4NpD8dvq2AAfCU8TcD4lH4i4dO0oeQzzWki70FecAiBYEFRsHfcx\nk0Ry2z2EHHxX0ciuQDd6M05PgApH4MDCOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAdRtJ+OqrUMcYFawmMEI9VEsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgzODc5NTQtMWI1Zi00ZjBhLWE1YzYtMzliYjgwNjg3Y2Y2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTA5MTk1YjItYjM2MS00ZGQxLWIwNjYtOGUxMzVhMjMw\nZTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa9dne+StT+D+xxDTlacM6uF2\nRsCkl+ajAoT9voyGbobFkTewdlW1dtdkcmUYiU1Urbznt/xunvXWTt4a+daPrKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXebeYTNg71Il7JSwEA6ysswFqyswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgIJcI4zcFYVDkYrta\nj7ZjNHiAUBwrKy0RFpMtoF8gdfcCIDgIIIqp0GlhhwjxW7fyyOrmHE3m1s3gaLAe\nN1pEaK/1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6847", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6847` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAaZ8gMJtIPj6Ce95fqEqN6m0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3NTNkY2RjLTg5ZjMtNGFkYS04ZmI4LTRhZTZlMmZkYmI3ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzkyZGI0ODYtNDRh\nNy00OTI4LWI3YWItMWI5ZTYyNmVkZDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc219gqu3SLgwxGRI1Znsu8vJDAgl2lzZZX39ql7SkCugj86npp0/WKaKhz85\nZBEzJDVfYyiAzVpmUClTgOSDOqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSsBggA+M3RjaNr/4fqVD+rIeA24wHwYDVR0j\nBBgwFoAUMKL9HiQAbB/eLzCPjE0w5gEeXG4wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiA8/fMLVDavMZWu\nmmXpxtY6ipEWyE7udy8O15BciKFpLQIgfyO+dFQ3YIC2YJPyfQQqKnSgmJ8mGVY+\n1nAW7+GqHfs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ0PpTg+25kmhkb9OQsfSzzvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzUzZGNkYy04OWYzLTRhZGEtOGZiOC00YWU2ZTJmZGJiN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ39gGwyRzjAIQVsp3ivfAE0tHXnwJSVGTZeN9qn8npqyIh\n4shqSAd4NJlO/D9xMmxgQoOtoPRyZnG12HXcNGj/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMKL9HiQAbB/eLzCPjE0w5gEe\nXG4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOxG6067ci4s9uacZWERAWwh8Fzvs5J/W3yK07Z7EiqeAiEAsXiq7CCO\ngg9HuYbibRN3Rrb9YSWIc7eKLF579ThGVeI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAf8KmKyQQoKN48dpTyxJZ8tIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzkyZGI0ODYtNDRhNy00OTI4LWI3YWItMWI5ZTYyNmVkZDUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjkzMWQwODUtNGFhMi00Yjk3LTkzMmUtMzllZDJhMTVk\nNjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExubB5v5Z0GWjrUptmnk0tAoj\nRIfWIvSnavdWsorWOdYuRwXAZdD0kdug//WWQvwMQxtaeCK8zcOFXqfdbVCKLqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSsBggA+M3RjaNr/4fqVD+rIeA24wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgZ6p5nACSQuLSXTCE\nyLsYVJTvLDA/JHG/2pwv0LiOl8QCIDpfJcQZUEV5336Xi3JQdJdD20yohN60IAEw\nRmztSDd3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6848", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6848` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdX4LKrSUMLtZtQnrNQudgZoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1ZGEyNTM2LTgyYjQtNDlmYy1iMmRjLWViM2U1YmMwM2QzZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc3YjJhNTEtZDg4\nZS00ZDYxLThiMTgtZDQyM2IwZDBhZWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzJtY7l5sR9NsSQjI1lLfFQLdHtBpo3ZXuf+0sg+2QuygRqfR9CamwGOxUT2/\nUzaMt4P+fddu+9dYUhgKLVTcfKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcwrjTle/VohCTWSe+BWjYwqUwRswHwYDVR0j\nBBgwFoAUvUVmQd7fjFjdR5Zr4NJ2ssYKfygwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEpDm7ezOpW5UMzFb88f2PMqabcalLKycDxSt4R4xXHgAiEAuovT1YXhkoUA\nooYJ7B7UjGAOEjZUiwh4iO0M8ZrXwdc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVQyVM0B7AadBMMxwbUYBNBcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNWRhMjUzNi04MmI0LTQ5ZmMtYjJkYy1lYjNlNWJjMDNkM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXAVDquGiDHGbB58T+wrm0qzuZZpwPCht6Tll6oBp29TDD\n77XsXzZPIHtMbvqiZnIx2nvtNOkolG/Iztcqklzjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvUVmQd7fjFjdR5Zr4NJ2ssYK\nfygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYXP6rOdrIJZ+dJGA7a2I6cmVqScczUi8yudUXxqwXR4CIHKfZEl3dDEI\ngmqToHk8NZ95F7hTxJwwDyfAUjnRpqQd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAdcqVu7p1oVwswyn0JTvO4e5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc3YjJhNTEtZDg4ZS00ZDYxLThiMTgtZDQyM2IwZDBhZWUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWRiYWI5YmUtOTlhNy00Yjc3LWE1NmUtYWZiM2M4YmQx\nM2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEO86lgPLcSh3DULC7AIC+f1B/\nRkyH67l9o+XatMA5pI4XVkVJDzPmRvoKFWDEPBnpW5ZJ2ALUYYNGNOPILmyWWqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcwrjTle/VohCTWSe+BWjYwqUwRswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgHfEQjDapQT4YP/mW\nddECASZhFzwCHkcBSvzghquslWgCIQClEpNyr9seoknodiRt2xkLalXj+nvIhaop\np4xFbl3VHw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6849", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6849` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXLSIPsnSeDEqatJd9va9OXXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMjNhMTQ0LTVmZDUtNDg2Ny1hMDAxLWUyZTZhMWEwODc0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMwNWI2YzAtMjM0\nMy00OTEzLTllYWMtMzQwZjc0ZWYyMmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEktjX2zKiyf2PYG5PSqcvPetcFWgle784Z2TPBYs/44X7eiDniQXklBHpPeKu\n5m3bOatnbGqQZkrTZO4IWP3YaKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSZsoIszWOhVfr4Eb40BFkKZ5qckwHwYDVR0j\nBBgwFoAUfU92MtIzsQtB6rAzyK7mh3JPVnEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCP2iXfLsX23W1S3Te+MZfCKonIEHA6ER9HIzLR6UTa3AIhANvcap5U3c8U\n0qCzP0tE/W/2FtJLosPhdNstRgjGrU52\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQLHkXrE+QcR87fka4OM/X3TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjIzYTE0NC01ZmQ1LTQ4NjctYTAwMS1lMmU2YTFhMDg3NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvDeVxJ8XpW2rWGsA7cWu1zssofBjx1EzeEdEGozJqN0g4\nLgm4gJWDakt4CMsLK+GwKpTBlWUBEk9UeKo/iOhDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfU92MtIzsQtB6rAzyK7mh3JP\nVnEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMkthlxRn6caXx0n4EAAm24U2XaMhSx7lIFYGtsPD+clAiAsM6yYkrE9\nzGm69DW7TjUyyfqLQC9y5ystvM12QONVMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZf0lsyzLoRvhYBI7Rf/rhh9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMwNWI2YzAtMjM0My00OTEzLTllYWMtMzQwZjc0ZWYyMmNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzhjOTAxZjAtYTcyMC00ZTE2LWFlZmEtODU1ZGIwY2E0\nNGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnyrkO/iKzHzo2e4G/VVF7akN\nzUfz0dmbfHz0WAc7dBwCkvq3hl14cRgZyoR3ikEICZWqfX7cPA/0eUrOHXa2s6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSZsoIszWOhVfr4Eb40BFkKZ5qckwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAL/pKoCNNdj9xZ7F\nYY4ToqIhyv2DS+YVq17LFzuWZBOcAiEA3u6nnQiAT/W7OWph7R6dtl56ha+Xfbs7\nlyI5z+GMAm4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6850", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6850` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYl4niVylPcW+ECqchgtuMlhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhYmY5NDdiLTVmNmEtNDM3Mi04OWQ4LWI5NzA5NmRhMjc2YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI5YmU4ZTQtYTVk\nYS00NWFjLWFmNTYtYWFiYTBlNWY3Njc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXswWOJorb8fIbI+T2C/d/BNAszKWaCB+pFaRx/qnx3A6DTp94uUD8G4B7b1O\nSjn6RUvyRdxaCW4UeZM5gWSibKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiDvk6w1zDuEpCiLlDIrq/1dboKswHwYDVR0j\nBBgwFoAUVzXAJCZCZSUkTPu689MjzEXkPP0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAIc1BkYiRwrFiALXajhvIJUvuI8eiREKaR21bOXTXNAAIhALOqMWQn8SfK\nWUmri3UdLhg3+VmmUyckc95nC+byR7+O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVv0Nh/WfpwTZRje398bzKnsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWJmOTQ3Yi01ZjZhLTQzNzItODlkOC1iOTcwOTZkYTI3NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJjeOLytlgDeylAus4tWGz+Rxh8GTWSPjNhpwkauw4qMFy\n55NOJbgMpq92KKqcLvVb+S8mYWQdB26Mt6/5nWCMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVzXAJCZCZSUkTPu689MjzEXk\nPP0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALIWGoY21ZyaEWM2ec4rAFqyGH/VckAeR1rWDyuiI5fCAiAj8OZvCiC6\nUTyG9ETJQ8Vp9h7SalGLde2YinkAG+yPwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAbb2y/4J95Tm+1Ni/Lf3YF4LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI5YmU4ZTQtYTVkYS00NWFjLWFmNTYtYWFiYTBlNWY3Njc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNhOTUyOTQtN2FhYi00ZDU4LTg3NjMtNzZiOTdjZTlj\nNzBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECvD1iHFJ2OmCGhZM7Zj6YkFz\nRiCPg/Bf9CGpSD5ixvH5AZW11i0yR9a/75XXpGurfSCdo8hOFZ1e9nQgPL4RLaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiDvk6w1zDuEpCiLlDIrq/1dboKswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgWtaGlnzxUYAuLXRH\npT7CpjWuhMUp7EOBMiANPFtkGx8CICh2bdypbjFedjrtzJFcu1seUpUYWv8MX5sf\nenQbQ1kb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6851", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6851` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAfl2FrNFlLHwbCgYBoG+zOVFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwOWMzMjg1LWFhYjgtNGZlYi1iMGYwLTgyMWZmYzdlYmM5ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRhMGFlYmEtZWQ0\nYi00YjQ4LThiNmUtYjYyZDlhYTJiNjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwSlpA48LhIc0qStsU2COw3yo7n3TE3l9XxjLVijdrJLIGE/7EMC54/fZsaYE\nNgfnsgiPkoRp+kVc8osWHkamh6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbUlxneLjc2S4BN320i3NZbJuR0kwHwYDVR0j\nBBgwFoAUFwI0fCydEH+bThVy+34lTl2xSCkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA+c32+vUGhPGp1dtMgFXx/lkdxQZGimIhKnh5LQGt\nLq0CIQDhCOOUL5yW28tD5wq9vonQ8u9z3QwW/Vpc4G0T3PVtZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAex4RkAbEWS352Bg0NVmuvWMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDljMzI4NS1hYWI4LTRmZWItYjBmMC04MjFmZmM3ZWJjOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+V6O8fH7L98UJSrSwVjZPg5zR3syXj3OHi1ZMeRWggGDY\nyEkMPEg1SiSKJyR6sv3Zgg6ieZ69WqTt/+3IUYQao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFwI0fCydEH+bThVy+34lTl2x\nSCkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG1/89hzd8fZ49KOR/+pzf20+Erv1bVqlCx8PT26mAZwCIQDXmj3YsabN\ngYadjtetqIATFEhNSQahj73mSY+MMxkQVw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAb5c5f/fBLki8HeudW3IECahMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRhMGFlYmEtZWQ0Yi00YjQ4LThiNmUtYjYyZDlhYTJiNjBlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTNiODYwMTEtMGUxMC00MGZkLTlhOWQtZmRhZGJjMGM4\nY2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5GVjU0wsmzpUsCBb7njxNFD1\neZZBMA2A5CcOesK1BN/Qi2vWaxXWg7u6zxz1aU9i/mIngjXQumohi6HjvaLAQqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbUlxneLjc2S4BN320i3NZbJuR0kwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgImevz2Hfd71NfKTx\nL/z3y9jYAY9UgVjyipya4TnhNjUCIBBdFnv5IQQJV8XlcFyOSxqnDF8kYC9/u44O\nnVNyoWdh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6852", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6852` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWYne7NhTMj/3ximsM5XrnPvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MTRjMGE0LTBjN2MtNDdjZS1hOTZkLTg1OTQ1NzVmMDBmODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJiYzIyZDUtMGFj\nYy00ODk4LWI3YzgtMjM1MDkzYWJhOThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7p+SfoGATXCjvRmywOXsNHJBqTsXQeNjslsxJhGeqWQRLCSP9/zuBGZEXpc/\nHqHUoblLJ+JtYO5nz1jXxefHP6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIVhBeUtH5pdK83MWPo9/a8nYmhAwHwYDVR0j\nBBgwFoAUcMyKZE2RYfegtYmtKI1LeKgg3GEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA17E8ZKwflIVLItg45AuStWoMR0nANzB5PMSVt32M\nl0ICIEOPBf5Jlz6aiGqSXm4zn5yUIGTHgtHk5DzNXzQ0rcMA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXkJ7KmatAwGShFrDdr8xiWZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODE0YzBhNC0wYzdjLTQ3Y2UtYTk2ZC04NTk0NTc1ZjAwZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQr1CbQCvlJ9A8rD9Ow6QQpj2GlWkO2qbKqF3+20KFEVQ2t\nZf/EnOAPeNercEgMhWsnjBYkq6tGSMbwbDJi3psLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcMyKZE2RYfegtYmtKI1LeKgg\n3GEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJbeaNFzV0VI95DkR9MKEPhw+SEVu//akIiKgdj0nrRaAiBZDaX+eLOZ\nNIt1rnIB66mVSsfEo77rLKxbF9lj7/fX3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAYzQ26eET5ZLOF6WZV70BNelMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJiYzIyZDUtMGFjYy00ODk4LWI3YzgtMjM1MDkzYWJhOThkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWJhYzRiZGYtOTQ2Zi00N2MzLWFhYWQtMmZjZDk1OWFl\nYzU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjjyD5Ywh+CakfuCEd0d65snh\nqSv+gCx0LK4bF7HePpdk0/SqdyEoSuoBTzlaJh9iA7h9dHkulIPyBrqPPvmuaaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIVhBeUtH5pdK83MWPo9/a8nYmhAwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgL7qqS9+oP99rLAfd\njGbV1ou2jqNgc3rf2cC8du6xaw4CIQC/nixuzTs8GKEo0+J8bQU6tD3LVD9Hunfe\nYeE1DR6/aw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6853", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6853` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWS4jgW/FZWDbKZoV0qQ02XIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5YTZlZjEwLWNkNjAtNDExOS1hNGY4LWQyMGVlMDIyZTI0NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY3MDI5YWMtNTZk\nNy00MDZjLTg1OTEtODBlOTFmZDkxY2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGt1SWpPqOesXq7qTSxPv6zicRuoeTYH6bZqgaPAf2oPiulr1pKrwfze+G4PI\n2MS9OmC599Sine+RtMUK/+wQ0aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlpAtxToof9ARKskiTqt6M+5TgDYwHwYDVR0j\nBBgwFoAUVg11xgRr+p1qvEvsvZvBsI2Ha78wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA8HbMrsVxk5JHuzEbx4mvzZmXaIdOgtoEnPPOFtMR8m8CIBZV\nxjvyeNjJtBRYUv0C5QRT+u8uw5UHOgdasT69W36L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYAWvq/qE0l1SiHbNqvi7fm/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWE2ZWYxMC1jZDYwLTQxMTktYTRmOC1kMjBlZTAyMmUyNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXWfi2kvQaRpfdVSc16aho1yC4sq+jSOG3Bc8rJeEC1uPf\nIQJ+TBZk5fQSzcXnradxW23DYszxvRwThMQizwqVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVg11xgRr+p1qvEvsvZvBsI2H\na78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK3l0CVD95cluNmYv3uZ2C9+ZH9b+1xIGox81l9z2trKAiEA3iCxMl2T\nmFM02+ynFy3m6vHKKuEmZq0ttRG3F90lJ20=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAcrWH/eFb2wvJRis2qg4dOD7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY3MDI5YWMtNTZkNy00MDZjLTg1OTEtODBlOTFmZDkxY2E1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzQ4NmY1YzEtYWY3Ny00MTc2LWIzZDMtOTcxYjAwYjNk\nNjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOlDnO+TlyOF6cdfCbTW9h52o\nymrMdUaY4k/tkIijL7w7dBhvAc7ZNW9raFjHXhrQNgEDg3uGJhIF2xI0JlkZaaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlpAtxToof9ARKskiTqt6M+5TgDYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgbbIpb30z9nN9Xiq8\nAjogxM5yWdtoPBmlvV7OX21vOncCIQDkOA9M4ntAlTDfv7GPRyeKfBgTsg/OvvAp\nsyxk90KlvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6854", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6854` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAWwlT18/97YocwnitLwVxm9AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMTY1N2ViLTU5MzktNDU1Yi1iN2JlLTE0NWY1MzhkMjYyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2IwNTBlNWUtNTA3\nZi00Yjc2LWFmZGYtMGIxYWYyYTM5NGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwZ2eIikR0ewu4CT9Me5yDwtmAs/W7/AW9+c7KmZehDqtfuVOVV6Bbth2HbTf\n0S2jU4SZY0/oZd+em/ktfAAosKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJBceZ+qUEE+HwtWHVFEsLg5zLl0wHwYDVR0j\nBBgwFoAUvuWVAvpQrW1jnpY1/xBGVOts/lwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA6PmSD4fPWMrJMiRcb/FACkq4VJV6pzUq\nmcR/NaczTmICIF4JilIB+8POs+socYklVTS++mmpumYxgb3l9BPk4iTx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ9lxwPD+Oo2lj6mjkWTqxGqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjE2NTdlYi01OTM5LTQ1NWItYjdiZS0xNDVmNTM4ZDI2MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4xLMkBVSXzUMV7ODk4u4gMsfglEwCFI0gdJyfh5T0Q5MD\ndP5XY2qMIG0lZJ9XMvoaAG9CV9XyleJlFk5FzOWuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvuWVAvpQrW1jnpY1/xBGVOts\n/lwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMkQR6e7AirJ6d/UWbBvGh5oFxhsVdI40/kwULyLy2aAAiAKlv6nphng\nrQcA8kI99DRa6w2XLPg+6V//QaWnITZPzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAYL6KqXEfiWRcs5q5gZ/9uG6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2IwNTBlNWUtNTA3Zi00Yjc2LWFmZGYtMGIxYWYyYTM5NGE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmNmMDhhYzYtZmZmMS00ZThmLThmMTEtZmU0OGVlNzFj\nNzEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERJeF7HVmLfrPgZku6jvUyF2t\nSinT5FCVrtxc1VBvb5osy1cBFkQTpsPLbHpB7CGjfOt1BYBqTLGsXFE2VbKuhqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJBceZ+qUEE+HwtWHVFEsLg5zLl0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJQFJMGmDiprcLfu\nZLvulpd2L4B9TqoMI0kOS7Azn3vdAiEA/3edVk+gtCQByi2N8BOSEpLsdDHHU0e3\nWG3Oboeukys=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6855", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6855` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAYPoxTemKoMYVPwMetx3FYkXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmNWM1YjJiLTZlMmYtNDJhZi1iODE1LTZhNTE3NmUxNWZiNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTE1MDFjNmItZjVi\nZS00MDE5LTkyYTAtM2Y0ZWYxNmQwZjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdFldgimcf3djnToUEEv1iyqfyNhEogDdc1vkfWMQBtzjHY2HwD/eayKMa4Rb\nEcpIfUumAklOfDlharoPPAMb/6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEQumoQnhdsRlLIbkgt9efoooRpMwHwYDVR0j\nBBgwFoAUxCpE1uMb4r2BLJIPXYvk3XmuCk4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBvVHCjArRGGgtMji65ZeR4quGyYVhalkRf\nJux3nwKN+wIhAMIZ5C4v6sfN4UyVExrk4ZfdrMNJz2oNzGoU7toOIPCf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaJHeJiN/gkgcZKsvdt6w1oAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjVjNWIyYi02ZTJmLTQyYWYtYjgxNS02YTUxNzZlMTVmYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATswnTUiV9yrKs8MH9DJfpKoBGRPzenbWwEUlzM84JLF2Cg\ninxXFUjoJwHgNYv0oEVJj0FBr/hlUl35+I70e0SOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxCpE1uMb4r2BLJIPXYvk3Xmu\nCk4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANGIWI8nNQGtphnBHDDCI5jNoN9UlC8C8A2fvrRjwhIsAiAEC9Qbq5ys\ntECOppWF09hilSdfCuRwcQVjZi316KGJeg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAcM8LWJIyTXEwlBiJy98b2WpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTE1MDFjNmItZjViZS00MDE5LTkyYTAtM2Y0ZWYxNmQwZjYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzI3MzVjYTYtN2QxMC00MDM1LWEwMjktYWJmZTBlZmI2\nYTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElszBydNlQCsqjIfAqTDM7/xd\nAvosmUh8Y/DZWBvfay/M7CxQuMQuydJoJx+Do8iOBUcw7AYkzxFcTalYXz7/MaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEQumoQnhdsRlLIbkgt9efoooRpMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOOe6Kdp6ApB3Pgw\nK+/7HKVzlKRc15uQDeBaIhxlHUHyAiAiNoY4C/O77ajR+ttDWUtFlA6k4Ecpw65b\no5jYp/Q+Zg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6856", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6856` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASyrSWuz2ixH10r2EF0v2fNgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZTkxMzFiLTE3ZmUtNDQxMS1hNDAwLWMzYmM1OTRlMGY4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZiMWViNWUtNDll\nZi00YTg5LWE1N2MtZDI2OGQzNDE5NGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvkyCUcyVxSewQ98smDJuRebvCncELMdlm3j7fXUBk94Guo1U3Xi40zsPfMBT\ntS3ap3hPPHNfTJ+UU9V3lBa9naOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpI704mKVM6JaEtQz0uZ5QRJrvkMwHwYDVR0j\nBBgwFoAUdBXZzC/Vq0lfUYt2HZKGIvTVZtowJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBkM4A+jouam0w8\n1LPBGcMMZAz1T3XsRzSyMYbYLtcMXwIhAOaqvraXDoalTuqpHiNN5Yn7uO8MvLx6\nMUTYx/aukola\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVxrnT8+ifP0rigKuNs9Ma0mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGU5MTMxYi0xN2ZlLTQ0MTEtYTQwMC1jM2JjNTk0ZTBmODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKRU07+DHNddpdn+bvvtY4aWnn/Ai1Q/ZDMS8kIrYA3CNn\nAxU9tEURT6V44wWfW+CEQ3tteoeH5Xtuzit5/zvAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdBXZzC/Vq0lfUYt2HZKGIvTV\nZtowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhANMmylLUSv1/cHvo7fPs9tdnqYRuGBZM2LqniXXfpOPQAh8kxdny8rnE\nww1mM1mlmGuzh2wXXh8lboKVgi85fq1f\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAekUE75Ld0vpoPEGd15vDqTYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZiMWViNWUtNDllZi00YTg5LWE1N2MtZDI2OGQzNDE5NGU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTA0N2VlNjUtOTAyZS00MDdhLTg3ZDItYjM2ZGZiOTc2\nZDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1cnUybtgJy1ul7sw2hcAgOQW\nU7h3ArHx0xMFaPGTKMsJZFeaxkpuOZXuuz19/5nFD2dfdwww89oFcn//pFFXVaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpI704mKVM6JaEtQz0uZ5QRJrvkMwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAI0zS5JqdOrVdfCQ\nokQ7FDVQRRUwZ+9BddNRsBLwO/3xAiEA0DS+NsWc8vHuYDqD/+kAqOsczIKXZQVP\na0kcs9IT4sk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6857", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6857` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVt9JaC1K+voPMYuXaya7LHmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmMTI3ODc4LTE2YzAtNGFiZi1iMjFhLWRjMWU4OThjMjc2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFhZGRmNzEtZWUx\nZi00MTA0LTk4NTctYTY2NTNkZDA0N2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErCtQvt/INimuKEs5m8b+P1ngv4167btp1n8PpiwNTO0yJy/ecUt4KpqzBnfu\nDh2UIhAjXtddICELaGOU3VGwgKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBu/tW3r8D1VKnNJo3uEvMop8a6kwHwYDVR0j\nBBgwFoAUnJTeDWJM9bby2zw3cTgUM4xAW9AwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFxV10ZXwNhzqbhVKlvaamaBU9CYlMX6fyZGDExW1338AiBpA3rKXn5r0lvu\n++KOg2c7k93vNIboOwntMEkrwdv45g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWVlUsKH8Z6t+u7jFy6ZfcyAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjEyNzg3OC0xNmMwLTRhYmYtYjIxYS1kYzFlODk4YzI3NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMvmezadE6U2Ov8X//hPk3C4eb3bWto5/KGBnsE3457d7R\nFhBHlW/lsKSjrdi+pZ5bzyVBvoopqAs/1lao7/DCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJTeDWJM9bby2zw3cTgUM4xA\nW9AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIJ0oqiY2wibOY4okoFsPlYofsGUxBitwQbqDBMP5N3xAiALYz3UuQqj\nI3WD4dyHRuZKq08klt8xbyYyFJq4Lk6yjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAfASs8AO9tr1UgGD7pysYTeBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFhZGRmNzEtZWUxZi00MTA0LTk4NTctYTY2NTNkZDA0N2U5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzU3MmRlODUtNjc4NS00MDg3LTg2YjUtNDlkNmI0MDk2\nMmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0SSfusLP5+ia9IyIbShJW6yV\nvNCGLcxMprKkq9Mr51/e/QVORcAeGIDKEgJU4Wq4GPrIgEgAoOCSuz/7K964daNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBu/tW3r8D1VKnNJo3uEvMop8a6kwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJbSBX7A2GsYEJ+6\nyaqhc6VFuyN+gGHmCPkZN7xB/CGOAiBUBcIRt6zHd1vYhjoj9RK7aOioeBbmHRwQ\nHcP0QgB6dw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6858", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6858` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWptrdJSb0l38Anl5uKQDPHdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNDhjNmVjLTgyZjAtNGZkMy1hMDhkLTU5NTlmYzJjYmU5MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE5NjNhZmItZjg0\nYi00NDRkLThiYzktYWViZTY0NjgwNjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEynpegft9s70lzr3LGmCSvSVt1mVVYYXJUgQIGslpWdlzGV1oc0f4UbZEoiEz\nv0W+EodLEK3NBQdeXg5jWZZnOqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULEGg+mTtA37fXkB2YYY9hGRSEZEwHwYDVR0j\nBBgwFoAUK0T49+pui5lSNewNfpUtQE0SzvMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCbniG8pgaWj1FGrJytI14zWZswUFMYTD2jbmsnaxQuZgIgO0RXGk6TyThW\ng8XsMchXXPlv2K4MG2J/IQCnbMNq1i0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWJSpcALkTGLYzSYU+J3ZciXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzQ4YzZlYy04MmYwLTRmZDMtYTA4ZC01OTU5ZmMyY2JlOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7lrXNFdgYC2mSyqiIDJv4z3IMILFr4XciLh/G3rAVPLHh\ntZeqOsgU6hCbcS6J/lPE/6UgSEZiR8Y7ZHAbrjx/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK0T49+pui5lSNewNfpUtQE0S\nzvMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN0H29vHor+6cv/Hj0Egr9l6e04T1Rtw12ii3c8oYigICIQDGQIQR+CtI\nEFMTB9J8B53ds8moqf4aMfEOF1kuFrUZZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAa3ng0yFRxVKRwuQKdquUBSzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE5NjNhZmItZjg0Yi00NDRkLThiYzktYWViZTY0NjgwNjI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTBmNmQ0MDMtMGExNC00OTg4LWFkYzgtODJkNzgzN2Zh\nMGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgffiGtP2jvGkxJgTVD4vCZPY\nu2VCFGhA54aHAy8R6/fVoLIhr6K7jJ629JdagD8a5rCPOd1gE9n2rnx7AKdBcaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULEGg+mTtA37fXkB2YYY9hGRSEZEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANfJBmciPPSUd8Sx\nJlYScpjqPXlTS8f/oj6K9uFI3deOAiBOXGRJg7sXzLYC1LxStICPFvieUA9wBBjG\n2SwdsdSLgw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6859", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6859` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQ+wg/Cokkxk0Q9c4OGwkVG1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ZjgxNjI4LWU4MzctNGVjZC04ODFkLTgzOWFhNDE5OWNkNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQyZjlhMTQtZjZm\nMS00NWIwLTg3MjItNjkxYzBiNmUwZDIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3K9WKUsTFCToO02COhhRJGHZLF1Q127mZr82YPK6073jwQmH9cBv5fyPVsfR\nKM31lJN0b96MWAwKjQ4+IZx2yKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3N6Jyz0dGy20bK8ZFTdPuy9LG0AwHwYDVR0j\nBBgwFoAUB+qxYJH9v7APewO53yCfs4hAF2swNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBht5fQtpC3bESjkYrYfddzt1IejO4/DlcGXTRRaxi+2gIhALw5NEkL6Bqz\nDZS0KtBkm630nqlCi6qGrHIg6QA1UdwH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUTmaVM+poP4b97br3hm9TGoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2Y4MTYyOC1lODM3LTRlY2QtODgxZC04MzlhYTQxOTljZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASi8hKwtirrS0ub942oQ2e4O83Lw32jxVKi9TGXY3Yji5WB\n52uQEdsHTA3QKKXLPhQ4L3et0iZMhCiBEWqvavEIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB+qxYJH9v7APewO53yCfs4hA\nF2swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANK0kRRQJ+A1/FtfovBGuHRbG+aPYC9vICIkgJMYk5L2AiEA8dJUf4b/\nJaXzuTLjTB8gqF/2s5X689ZiizTgtqfh+yE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAUrYv/22P5QyoHYa1qpsSfHJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQyZjlhMTQtZjZmMS00NWIwLTg3MjItNjkxYzBiNmUwZDIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWFjMDAyNzgtYzFjOC00NGJjLTgzNzUtZjM1MzM5YTEy\nNjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAidvFsjbAE3nwfoRnghuwBYe\nXEU4pJdEOKP8bFnGNISP+CJh0MP7g9GLAdAGrcvVK0z+zyckSvufpSEhyfDd96Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3N6Jyz0dGy20bK8ZFTdPuy9LG0AwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKjgxzvCGP+ACv5X\nRCsnOI0mwS30S4LI67zz68hjgKraAiEAtxoRsMyZBB41AYajVcUQXsSVBGoWV3OM\nrmAbuaP6NfA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6860", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6860` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAVn+z3NZfKf8+/hnotRSY4+QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1NmE3ZTViLTI3YjAtNDA4NC05YTExLTBiOWM4Nzg0OTEyZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA4NjJjMzYtZjMw\nMS00MmFjLWEyZGQtNDJjNTE3MGYxZTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESFFTKuCW41T7JZFWWGS7bbmlt71VigGCmsM8X2977fP5sX+lxEQNBdMjOzHh\nKCTsvxRcZbxESNyRocCq4uzfnaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj4jtDNzX6jFhpP9eAOdfyv74ZDowHwYDVR0j\nBBgwFoAUBGYP2e4+hqyT78/SOVFVE4NiKUkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAnkBRHIHWYVfB2cqDQ3OkKhPUtYBVa6iZnkS0dHqf\nOG4CIQCUJ6s/Ve4V9uQc5lyZ7EJ38r+kKcyUVuW35fqkCpnGhQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf92bwRGdh4PMKpv2NSkekc9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTZhN2U1Yi0yN2IwLTQwODQtOWExMS0wYjljODc4NDkxMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcIhhrB4EIX6PGkCNCXOIWzB0L7Z5WWK8OFl522SjzbCnO\n5DB7/IZny+WbFFOeW5J3IBQ7MqJYbSSnC4SHUG/ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBGYP2e4+hqyT78/SOVFVE4Ni\nKUkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPzSpHJNqweyT1OIUtJntR9rE1tlcqW6vF7K5UhE/J63AiBrs8yBdr1K\nvCfPA9+6pZIcorfuGevt3vgfqD/6QPLOLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAT17Njss9IoByBrf9MQ2J18JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA4NjJjMzYtZjMwMS00MmFjLWEyZGQtNDJjNTE3MGYxZTU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2QzZmJkMGMtNWQwMy00YWVhLWI2NTgtMzhkZGI3NzI1\nMGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6yJI1NI+dee5tmGkSTq8OfNN\n0lovQ3Sy4xGzc7VuykIilg/M4TaDpERmHPu7EMBqpUnuism0b9TAOyNjbXRAqqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUj4jtDNzX6jFhpP9eAOdfyv74ZDowGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgKxuUg3C8yoJy15io\nT/LTquBpStN28ngoPv5hTeWYwJYCIC7g6YNuPZiRezg9pEQvcAPLphJgOjahtu6l\n5E7FrLFh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6861", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6861` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAYzh6AlGaR3WFTcXkYJRkp09MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYWEzYWEyLTQ4ZGEtNDg5ZC1hMGIyLTkzMjM4NzFkOThmYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg5NjVjYjctMzIx\nZS00OTI4LWExYWEtOWYxOWQ4ZWI5YjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXF7YUVOCDar/BHG+bw5IZ4Inhr09/biMRSmR59ILhg20Cl/cJgifiySHFs26\nl8clOSoa6c25TbugHH2iv5S2tKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn1wox+0W8JFUr4vjwX4X8RsFc5MwHwYDVR0j\nBBgwFoAU2kYRFjjIadLv72JJVdtmog7zHX8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA/uq4xIZtREdcPWcnVV9DZC2zZI4J2/urix8TXvFS\nANcCIQDCQavTt/IqgvYWOyIFBc8rMTTsSY4uUR9ppSfRpGyoFw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ90q/0FQPMoYkUhf67P6RuQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmFhM2FhMi00OGRhLTQ4OWQtYTBiMi05MzIzODcxZDk4ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATB3AP/rtqfKSBS3M4JGrjKh3zmdGcrAdo7jYy4Mrd8rrb/\niWoLmGnIayBMjgvFwY0xkMR5CSKC7GJS7cr7IB5co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2kYRFjjIadLv72JJVdtmog7z\nHX8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJcrYq9dGWxhLGtn/ww1jvz9slR9rq09RMhljMv+pXj4AiARbP+FYQyD\nGLpc+UU5vyaHQAX4KMoXoM1PqvJL69Rd5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAXzdZANeigjy7d4APVq7JlptMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg5NjVjYjctMzIxZS00OTI4LWExYWEtOWYxOWQ4ZWI5YjI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTczNjc5NmMtNTA2YS00YWJhLTlkMTItMmEyMjYxN2Iy\nOWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEswIwbI0urzDnUnHjk6AjKT4e\ncJmApBgN7/XxzNh7CYukXfuoTF575IdDVCDz+0MT5VXE6pERp69UknkcfWr9c6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn1wox+0W8JFUr4vjwX4X8RsFc5MwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJzsh4p8ckUjV8dh\nFrOKdq8a5XRjxXNlB18FtJy2HDnUAiEA3KEkrq246zAyAgg0QwYtBIMrgNxtMYzX\ndrGH1KHZR9I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6862", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6862` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAZlI0FhGjH1SMYJCbnu0A6x4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxODdlY2RjLTBjYTQtNDBmMS1iZGUzLTMwNTE4Y2E4ZmQwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI1MTEwMmYtZDBi\nNC00ZmEyLTgwNmUtN2Q3ZjdkNDYzYTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUbWHKohlMHfINbfUFY6M60sDJpibmcvJZK+fUfs3F+o2xNqpb6DIM5YwUKf3\njvEfJ/phygmXlWBQunJnH6HbVaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHmKvCgTMGDHWK0giFid/quq/UIgwHwYDVR0j\nBBgwFoAUsKld8BaQYFVwDh39ypBuBxh0K+YwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAFgJH35INCr3RHbffc3kHw9xR9kIwXndKwtxlqwoS3vQIgKN7Y\nsGAdRbNsVAuBRWed7Z2PnKRrDvWtr3RDSy3QS2A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWDZ2T8ZIJtmhqbZRTvDGN2bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTg3ZWNkYy0wY2E0LTQwZjEtYmRlMy0zMDUxOGNhOGZkMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSk7FC9FfEFseY1tzKg8F1q5yn/DKWX7b5tKjC5svZUH3J\nL3+FJXzCFGVCcZfP5G82JL6fMpiKAaPmHYmnWY5+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsKld8BaQYFVwDh39ypBuBxh0\nK+YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYQGCbxbhH+aOuYN0CAP+WIu68KcHjZin1F8EJ+6LYpgCIQDt+fkATgA2\nnPoNEJMeC90fmahuH0iy8pQ/EkptGOC7ZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAeT3RuzSLzm9T9GNa+UmLuH6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI1MTEwMmYtZDBiNC00ZmEyLTgwNmUtN2Q3ZjdkNDYzYTk3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzg5ZDc2OGEtZDc0Ni00MDAxLTlmZmItM2I3ZTBiYWRm\nYWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzImVRIvmkKeHxnLVROhRndrk\nOhaIaTlKz99BjfLvWppIUiJk3fykxcswMerDKDtqS9BaLavDTxsGAHhinU2Q5qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHmKvCgTMGDHWK0giFid/quq/UIgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMb6rvwC1kFCnVc1\nCQTdsPW1A/lpWJugVnk39L/2xhJBAiEAnISK/kyffNrp4V8CqJ/mofgAyQvs1GSw\nRs/2KVWE+bs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6863", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6863` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZAovEFBCVhwHYSv3w4U4II2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlZWQxYmUyLWY4ZDAtNDE5My05YjkzLTNlZTQ3ZGNhNTIwNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2EzODYwODgtNzBh\nMi00ZDIzLWIxNDgtOGU5YmE3ZjI4YTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuLFInFy81pjz2xAsPuDnaKVr3EpvDYglhK63Z4ylnYJDUsOqCfZXjELF7SZz\nx+x46Pk3/9cdWo5QYMajCU/b2KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNi78IXqaa9Go5kdeWRYyEvU1sy0wHwYDVR0j\nBBgwFoAUpApqlC2OW0joNVTMBxjxRumfQ/gwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAhgQIYGIQSrRM5QMV/W6avJW8Tn8KlFpd\nJ+Lgv7NzNO4CIEm7DMJFlEu+tgnx/NqY2w5Bv6jRMMCVzGwn84yy/0kz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXop1WeRP297kx0XAd4GKDv7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWVkMWJlMi1mOGQwLTQxOTMtOWI5My0zZWU0N2RjYTUyMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEdEEEiq4HE8vR9j511pZWJaGy2De8loOvA1OhjooVR3hp\nQTFaW6sP1+0vlDBtCL7bVfra3FHv63EV/cj4cl/so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpApqlC2OW0joNVTMBxjxRumf\nQ/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALCBtKe2l8+VMC4GgRhACtfqwCVAf8SXf0ehYntCmzh/AiByuunAzz3H\nxBceLy26su6o8pc3aRDTYhkTDojZlrCxpg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAbXhE9YYoZL5sPLZEPZkjiMNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2EzODYwODgtNzBhMi00ZDIzLWIxNDgtOGU5YmE3ZjI4YTI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzAzODY0NDAtNGY5Mi00MjFmLWJkZjYtNmI2NDc2MGM0\nOTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyj8JlW4HUlwxpFheHfhEauHN\ntFWA7bWuupaUnwZ1rL1eoePvZmfib/AEP4+HZfU8l0J/WpVtTOSb20DIiXgEFaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNi78IXqaa9Go5kdeWRYyEvU1sy0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAP5qk+K6rd2AurmS\nIwY6SrWwhSwu+DJeDIWtM7SC0AJgAiEAqOsPO3YtLX2AlF50MhhMpnZvfec5Pgyc\nuOsk7jzse5M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6864", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6864` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZNTs6GnH2O4zJ17WF0GDW00MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0ZjYyZjQ1LWNmMmMtNDk5YS05ZjRmLWJiNDQ1NWU2OTVkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzM2NjE5NjQtZWMx\nOC00Yjc3LTg2MWEtMGFjNjUzNTI3ZjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFxkJuE8vQWDCx4cN6aaktTPPvahu2VMS3mOOhWO63PnfhwnHnmUGadniFYEA\nlxe4jy4T6cHEOwYKEhRbh2kDDaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnDetn8j32HwshPzoCwSwx3MaB4YwHwYDVR0j\nBBgwFoAUBOVEZ46Qexv5zrO5pnXlLO+gY58wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA/TVhMeI6tSLO+Lh2PGVI9pwwzgyjPEo6R\npYW2HRLQxAIhAID+fRH2tMudDOPQdYtJKDT66naul7UhBthrA4EbZehN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeVbyS/6J3Pz8kf4a6YZqBihMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGY2MmY0NS1jZjJjLTQ5OWEtOWY0Zi1iYjQ0NTVlNjk1ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgjrLrx5j7CyJ4LYrEGeiFvrVnlXxvOkXMuDt05CpDp9BY\nBAa+1QBzIKsx3S6K+6wYHllP+fedNcbhBYSbduRko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBOVEZ46Qexv5zrO5pnXlLO+g\nY58wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUL0rtpgCIgzRfK10OKJ61QXxeFJpz90I2Xp9P2O4g8ICIFoCLdfOnZkZ\n/ALThr7LBl0VnKNBpz+d7sblgCAKHwuU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISARLLR9NxmXbY98XboHE5a5BqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzM2NjE5NjQtZWMxOC00Yjc3LTg2MWEtMGFjNjUzNTI3ZjMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzMyZjE4ODAtMDg2Ny00MDdlLWIzMDAtMWE3OTJjOGRm\nZTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEISlB68422A4XL4lRGIrRLUz9\nThTSq8uffS0gFznwXIWfxVPBztxKliZNOQgIWGbbvTnGsULS6I87EM8XKAkNa6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnDetn8j32HwshPzoCwSwx3MaB4YwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgFCWitf+HOi0TVTkA\nF9Nk3Q5lGR48CVGvDCiQaToLmB0CIC5a6B8DquLZB7Ja2I93zAM5zFix4zhmiTAv\n78znjVk9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6865", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6865` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAXL3fn9KtwykMKftQcfSQgEfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExM2MwNTM5LWQ0YjQtNDI1ZC04MWEyLTcwYjA5ZDBkZGQ3YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQzOWZjYmYtMTRm\nZS00YjI5LWJiNGMtMDNlMTk2MzI5ZDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXmlqDYV9OUMMXTT2hMc31sq7G/8adTAdDNitZHSjRfXUTIaHmalLMwo99QCG\neYLYtkP0q0qDfo29nMD+wMzcRaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi+it1ZjFuYapsVRPuwYI68BGOyIwHwYDVR0j\nBBgwFoAUOz75eJGs4Cq/VUoy8BKJeHvbglkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAQYmtMdGqcKJnFymQ4wFyz1wi0C\nQjy8WnNxIQxBgqENAiBm2TpeNufLoPTKvBLgEy4fPsEjkX9TKhEKIjMr2v45nA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfCTV7TwcWX6/YZBi3dQRpajMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTNjMDUzOS1kNGI0LTQyNWQtODFhMi03MGIwOWQwZGRkN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhy/e32hBFOGFDz8Z85rCCSroNWdZFsXKubtSePTxRInoe\nbDR2Xt/XDt/NVSCLtYEH5+osvsj4QXSOybDrGpIAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOz75eJGs4Cq/VUoy8BKJeHvb\nglkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYJALYths4P0C4JU9uTNett0xGmV2yJO0FTMgsBoBBdkCIFrhg1YoNcGF\nsNwm57HBN7ZpWA0A0tKs2q0voWgmVGHH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAaxsmXvq7FixPBowV0rSlgA+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQzOWZjYmYtMTRmZS00YjI5LWJiNGMtMDNlMTk2MzI5ZDZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjUzY2U2NzAtNTRmNC00ZTMzLTkyOTItZGFkYjA5OGEz\nZjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVktxSAHdQtPO3vMbbJq/vyYW\nyii7iKdmvOVaqlyZssVpreoLp3RrMlI/hPAdCuJM32SIecvGAERtHkO1fADeDaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUi+it1ZjFuYapsVRPuwYI68BGOyIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgCuWVt5v0SUWYraIW\nTK/kMhpYgC9zWUZBEsBxziEtb8ICICt68LwMxT6bnipS5RzysvTbbuqRGAstkslo\nhxyMthEh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6866", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6866` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAckXX8ue1KCVpfrqBtzVbhIsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2YzJmMWVhLTQzNDItNDVmYi04MmVlLWQwOWM0NjY2MDA0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZlYTExM2ItMmIy\nNS00MTAxLTgyYzMtODJjMTQ2MTUxOWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsT+1QfRvLjRt5wVkMZo+Y4AxLXkjxMLIf/+sgZ5ysIbgeS4m+6XDWEEeM7my\nHwCk9gGcHau3YyDvL1PgdGFu0qOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKuMfwpH+ueHd6sogeB8rWDOXL64wHwYDVR0j\nBBgwFoAUnQjjHMax4s/0cF/nLf/FAPVS9wQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPObYH21\nPmGGaP3THq1HKvzKQgRPndCXPpBSSBV4I+0vAiBLb66QylP6b5ojeVEsqnD7GoQo\nf4oLP9S38eLtidV45Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW7Ea8i33WPMM8nLXqJ7j9ScMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNmMyZjFlYS00MzQyLTQ1ZmItODJlZS1kMDljNDY2NjAwNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+BDj21bCKdLR13z3VjeiL37Jrj+8jyAi/CrJY7s3MjLEn\nrozNTwErGE3VE/dZjGcNCD2dQc+/aGMYvusQvQ9Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnQjjHMax4s/0cF/nLf/FAPVS\n9wQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWPcp76TTR9oiUOPGYZfEqDiBqnrIA7uwJhUQVtL6djQCIQD3Kc0PgXsk\nxRXEWTePHd+y+jS/P9ISPvcZjcrUMeoZ9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAYG0cG7NrbaYK9dCFK9Jj4OnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZlYTExM2ItMmIyNS00MTAxLTgyYzMtODJjMTQ2MTUxOWM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODA2OGZkMTMtZTc0Mi00YmQ1LWIxZDUtMDc3YmZlYTQ3\nNDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExH05OmZyWA6K5wjRxvKvoOB+\nrbbT+qW7U6+pZXFC4bZcsLf1Chf/fXm1TE8ibHeAEbkP0VLBHfcjMuD279gcKKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKuMfwpH+ueHd6sogeB8rWDOXL64wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgPOU6ltLeHdqLtkw9\ntpv8H7zTCXeNn3aNVvpH1j9uvbkCICZUFctaZIpzS/5ao273SXXU7pTVla+bmV4J\nxGIBsnyd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6867", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6867` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAdbePqa/t4QCktT3tOJKSqDgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1MTEyMWI4LTY4MGEtNDkxOC04YTFmLWQzYjY2OGQ4MzkyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg1MzY3YTgtN2Vj\nYS00MmFmLWFlMTAtOWY5ZDM0MTI3ODI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENw/PVW1OXAr8NmYuDgPVI99G0kVUwbHrZCViFEa1ukOW/nN6Qh7Ex8vQdnTM\nIqg9945EYF18u8qSga0pREzzW6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsAxYzzCDaNvf+bXwoqO66UrYJfEwHwYDVR0j\nBBgwFoAUHx/9NIVE47jI4NA5P845CNscSikwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAKoZK7Bp\nA7Qei4Wo2uvn2WtqH9eRBvH0s4lnWOvYq7JfAiEAw2o9utliQibK2eJUfylkil60\ndtu7tLuLG/2Iv+tr1wI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeIY6i9HEd2v+vvLTt1VIzGJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTExMjFiOC02ODBhLTQ5MTgtOGExZi1kM2I2NjhkODM5MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATA0FutGyLSiaWMJSyHwIPzox9cBU1UNhWyrrSX2pAuWscG\n/UR3GeNSU30mKYGdNSullKlwEaBcvfoR6N4ycVPHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHx/9NIVE47jI4NA5P845CNsc\nSikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJOa3ALfSfpacE589E71KWvghnsYGnU9MLqt+DUsvsspAiEAzIe/ca2B\nyhQPB1+H7cfT3Tnt0nFjPCrQdHPR5VMT/yU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASTk2gpIUpBig98w1B5IT62jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg1MzY3YTgtN2VjYS00MmFmLWFlMTAtOWY5ZDM0MTI3ODI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWNiMzVmNTQtMWFlMS00MTdkLTkzOGItZjljZjQyNDEz\nZmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEagysJh5fw67VRKSqpgso4Df4\nRMdSdIljpEP+ygOPrk1l27j9uwlGlQxEqbVsel0SYMrLuy95K0fqPDQW3Nm62aNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsAxYzzCDaNvf+bXwoqO66UrYJfEwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgeUoI67OiuDUoA48z\n0lLhoNiHvsSGs7geSnrXvh9d9GECIQCT0+u75aNiCZw/R68imKg23fdClpQ/hSLt\nTCMeO+zjlQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6868", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6868` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAQsI80iwtbVKgGPNgVD44/h4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2OTBjMWM5LTY3YjctNDlkOS1hNjZkLTkwZDAxNjFlMjA1MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q4MmNjNTUtZmU1\nYy00YWYzLTlhNTEtZDMyM2YwMmJmZWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEisZx7DW6XgDj/TacIH6hHkzori6bhN8fOr6/0wqRn7w5XsfjYDRPCEa2ooK/\nsa0Kbrb1Zxw50Wl4vlQUHR3hjaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl4mklIqF28TAtq+b5ngLZMJ4dZ0wHwYDVR0j\nBBgwFoAUqpYiEkdCTE3f1dxEPAmpMIN68bcwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDClcSH\no8slKuGNIfr/u8f6Vbjv7ZCACgVj7r4+FeeemwIgUyn9dVg8w8yFXIZ5kca9YKx9\nQ+hXMlNgHEsdB4BKUSU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWMO9GVigzUo+4QFrLCow+lNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjkwYzFjOS02N2I3LTQ5ZDktYTY2ZC05MGQwMTYxZTIwNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV2DaoAgZ4CJOtRbDCKWD8OC8iWdjgvp2MIh6mNCLSWIn3\nMAqyD555ZMQCvjU6ejwDsoRanuCDShVyRlurrUugo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqpYiEkdCTE3f1dxEPAmpMIN6\n8bcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMLwutCRuX/eSRx2uokbpStAvjDkAw/FLgbl2zoGXnq8CIGGGzOVg4sDS\nHAeZpyPYA8GjhHHYmSFABgcyAvhk4sLP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAfAxLXLM4dz4kvPDffBz8FqXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q4MmNjNTUtZmU1Yy00YWYzLTlhNTEtZDMyM2YwMmJmZWY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTFhZTkxYzktOWQzNy00YzUyLWFkOTQtYjI5MzBiZTMz\nZmYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzLakYp3dBgzF5E+mBuu40Qim\nCcuPtGnge3adeizJysvGvfzrYmviXwhO/NuNhzRsM/yL2AQSKMEA7DHBtw2NMKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUl4mklIqF28TAtq+b5ngLZMJ4dZ0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgc/aXetaj26I2htE9\nVcpFrz8iLOCwLSMf1EIGN7fQ8WwCIE+OQ0lVYXHXBL98ZCaos4mIFp6PIjeEUYV/\naRcMxfsV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6869", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6869` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUGeX4SHH3vfQsHDu0zXrJx0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NzQ0NTEwLTY5Y2QtNDNlOC05MzBhLTIyZWJkMjRmYTI2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUxZWE4MDUtNWU3\nMy00NGNhLTlhZjYtMmNjNDFlOTllYjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz0AR2F4lSyRUSkBT5TjLpaJqiR8NhQAmQXb7KFghFvjJPeY5zJoK7XjCSTGu\n92nScgJ/9IM9BtgB8qhujTwl96OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSaSwkMAesTIF/uLuHSywQPob0e8wHwYDVR0j\nBBgwFoAUcQvKUhFr6cwO/wdFZblCvkvwdZwwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIFQiH3wJQS+9XjUXTCBEqx9uvI+onJeLHX7WnzOhMNBBAiEA6gTD4qvx\ngcvLAKLMJFnc8VJWT/PbES04awegzWQ87ck=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU477oSDrWijw89MA2aFWh2wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODc0NDUxMC02OWNkLTQzZTgtOTMwYS0yMmViZDI0ZmEyNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd50lD309X14WwWf2CrfAQ/bdE1r20LfrqHYxkD6ZVegd3\ntPqFry/LlTLJcpzQ7hhVOowE99pNpbr8DJ1DDaVLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcQvKUhFr6cwO/wdFZblCvkvw\ndZwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDIs7EV1VSu4yCHMmKY2xxmzIMp6WXQ1vOD38a8zOQ8YCIQCz6Y+x00QZ\nOcDjNWfv8BIsyrTTHm66IDDWfSP0CkqEug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAeOcAZ4x13oed9yeknxdx1JjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUxZWE4MDUtNWU3My00NGNhLTlhZjYtMmNjNDFlOTllYjUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzE3NTQ4MDktOTJiZi00ZTBiLThkZjYtOTA4MzBiOWNh\nY2NlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaKK1ehFi082dIOpmRxlURTLF\nH9pL/Pihog4L1whzqmSzzK9r1brGooGfa1UHGdW2w9uVftSA5ZwApHuXVn60y6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSaSwkMAesTIF/uLuHSywQPob0e8wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAI7PkyZVsGb2iKSd\nOLrEAw0swtMBm3R0K1ZS1lv91IHcAiB0bmBmoWuzty/8GK5EPtBgqnMTFX82pGSJ\noM4gb+zazQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6870", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6870` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAR69zO5areRz8klM93n99XRbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzMjU3YTkyLTVlOWYtNGE5Mi04NWExLWNmNTkwMjBhNjI5ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTRlMzQyYzgtMDgy\nMi00OWQxLThhMjUtODUxMDY3NDA3ZjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPsN3WZaJH3gSBtSyULTXngUpiDarkTN+UOpTpX4swDypi4da6mAT7BFV8rou\nAEmdG7GCIXazV1MdawWNvCu+V6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl4G+fmI1RtdENpuinwjcTMNfNucwHwYDVR0j\nBBgwFoAU+vCXwFhD9TLJPy8mwBSN4JZpCiEwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDQwjhIxJcm9Vl3yPqo1CM0QivxHDPUit9kTpyfaJgToQIhAK5lDxWD\naIO3oWasnpCtvLX/IaMB7M4npv7MheC8CM2N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbiJuYfoygN5cRJhccgr3OvTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzI1N2E5Mi01ZTlmLTRhOTItODVhMS1jZjU5MDIwYTYyOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQ7yEHJFnh3gph430yZUe1YQ+uRPzuCoVNqOT5nvRXATPF\nTGB/sZuEf+k4xKF3Hxf33lOOg3o27G0CGRaaBHTWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+vCXwFhD9TLJPy8mwBSN4JZp\nCiEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTZf8e5iyDbb3XbxNZyAW9jtD9XWfCNB8HuwyFcNOPh8CIHbyrVMbhCqJ\nbMO/A3awLOyRDu5KWnryPFp/v618+Ty+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAcQr2qWR7BLA19o0koEj8F7YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTRlMzQyYzgtMDgyMi00OWQxLThhMjUtODUxMDY3NDA3ZjkwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTIwODI5NjUtODBiNC00OGY0LWIxMzEtYTljYmI0ZWZh\nNTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDy9enqlLiKjfq/NcWUOByd3R\nCkeW6w4MPbyGUP9qYdFc1LITMQyo7i23HFlFSmQkKymZ1/Xh6iVWL83+nM5m/qNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUl4G+fmI1RtdENpuinwjcTMNfNucwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOqdb1AGP7uXk65p\n/R5hC9pKGzkoeC+rJ3HNL6RDk6jcAiEA8c0hbfLpIi3Qekn/j6GuAaqLyioMGdfk\nfpFOpZ+E3ug=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6871", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6871` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAaRNrErxUogGCSxjCOXSUNsqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4ZDdjY2FhLWI2NTctNGVjYi1iMmFlLWI5YTVjMzViNmIwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE2OTQ1YjYtM2Y3\nMy00YTZlLWE5MzAtOTM5ODVhOTkzNGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc/x9IUfxLpW5PWFgbI6WcO5XdmquOlZvdFPb8LDBjstcnurGicvk1UjXBoG6\nQQ3QpTL/QaYTd256h2Rz5OwRHqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjNatR/WUyiojmt0zwt743WgyfXcwHwYDVR0j\nBBgwFoAUr5Ohnt7N9DEHSz3ZI+8MRdsQuiEwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nICMuy39qdTRonBqR+tWe8vJliIuaAo/sWJtHQZGlvRkIAiEAtUJFXTmWbP3o7AHv\n7awj7l9BbCqJu8Dh6DzsTYza29M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAST2IdjGdREZSTfxV+xmIjv7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGQ3Y2NhYS1iNjU3LTRlY2ItYjJhZS1iOWE1YzM1YjZiMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxmikTNf3vyY8g37NZ9f7SEXK7w6O30zafi8x/EdYiHEuZ\n9NPJemaYkBhVm2wXKs+XOe0bNlWjC/tF7bww0gXLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr5Ohnt7N9DEHSz3ZI+8MRdsQ\nuiEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL0P+Jbzlw3IyoJYlCmWlAF0HXW5Vt/0Idpu6VkJuOMmAiAZN8fFysSd\n8v0ZWVFw6ASVNsc9hpNgFMUu0Mn2J++nPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASPvIIn2X8qvQNtJIOizWoaNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE2OTQ1YjYtM2Y3My00YTZlLWE5MzAtOTM5ODVhOTkzNGQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDYxOTc2ODMtMWIzOC00NGU4LTllMDMtY2IxYTcxYTgy\nODJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5+D4at2ORFMdeXjB6BSlqq50\ndr+06G+YID6EuQo1ILSKqpnn4mVr5WEsf3DSIfRVL54eF2RP+W84yUyYEHaGoaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjNatR/WUyiojmt0zwt743WgyfXcwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgL9fkbT84YP48Qb7R\nXxQtOQ1nEUL296fuq/xNN+KpFdECIQCeR8y9rP4248/zERkuuPHo5XG78e97hZ75\noF45grdzKA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6872", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6872` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAdQzR86QuyKheBXBwbjEKCXbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjMzkzYjg5LTJmNGUtNDFjZS1hNmU2LTgyMDZkZWEyYmYyNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI1NWQyZmItODRi\nNy00ZDJjLWI2MTktMGUzNWIxNzQ2ZDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0xl4xYLgj6OKAUqJ89yDQoKgKMbrW2UpA8yW2e7RIdLSuWjpmjbEjyqPCzkE\n/jLxQbnOHF0M1ZFRXlpTmTAsoqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT0zQuMi9gmMGS2Y3WmnDc59VhTswHwYDVR0j\nBBgwFoAUkF8BbhPkONqKxyFo80ZkIV9DmHowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCTkc0GrL84Fb2X9kEEn0ZIIRh5M198xQdMwWbwdSWdlgIh\nALXpOXDwjeb3d6tHSkRJwhNWlsEv+N0Fu0NwCVCc+pUR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQIfhZFPY9zOSjJwvD3WOk0GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzM5M2I4OS0yZjRlLTQxY2UtYTZlNi04MjA2ZGVhMmJmMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZNXsEiV3jnXNPW2Wtesx79fHOafqW3tS1oskBMrH1pey9\nAe7bCED/qMF8RGxBXvlU2lvYsCJ56CjIKyoaaI0Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkF8BbhPkONqKxyFo80ZkIV9D\nmHowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdJaqrHgzlidWXgrgpAPaqxR3FoHZjvVXf6suTcM3dV4CIQCexCWC03uF\nb8EpQqB9u+kZoGJiXQo9th+wxEp3G8MAwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISASZAENlfpQgdGwvvI9D+djKLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI1NWQyZmItODRiNy00ZDJjLWI2MTktMGUzNWIxNzQ2ZDg2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzNhYjg0NjktNzcwOS00NTA5LThiZjUtNDRjNWRhMTI3\nOGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEirzyP42gXxYoC9HnYXrgjwWC\nGfW4jvrMvRKCbpRV20V3mb9zz1n/Sg0PpNmg8S0lzfltZMwyn1BuwBEGATZlvaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT0zQuMi9gmMGS2Y3WmnDc59VhTswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANeFYyng4lEEsh2c\nMLGPM3JfiQ9fDFFKyWLRFdzjRfS1AiEAmgloLjPwzDmvL3Xw7xa6C35MbTh005LE\nB9cQi4WFwzM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6873", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6873` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAUkx3BiF8/aGEEYdLof/10XCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5M2JiNmFiLTY2YzMtNDYyYy1iNWE5LTg3YzdkODFkZWM1OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA3YTQ3NWYtYzgx\nOC00Y2UyLTgzNmMtMjkwMTA3ZGQzNTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXuYHJWhvlIMmfvZRXQgUcnYhNT0CCKpB4qPEP0nzCbEO/porQkiu6vNAhdnN\ngkNDmPmjxmYcfNOrE2uuzi8n0aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn+hbVV+VDikD7zmBH+7Yf6NGKrcwHwYDVR0j\nBBgwFoAUJSNhurAszg/fvVtb9N1o41ptmgIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIHNTrkfGos5d0AinChMDyv0Tw4QHFXb1V5RgI11zFRcjAiBs\n6u1sFKfzpv0BS2vPeL4TpMXC56POTX+dWSSlGtBIsQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARr1uDn3geX6OXxoFRTx00+zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTNiYjZhYi02NmMzLTQ2MmMtYjVhOS04N2M3ZDgxZGVjNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASr5nnamb/pD1hnCJzUmVOgNkdl9DNiV7RCVm4GAVkz9iAm\nHV9fndCgSoiiU5jQu1ZhCojISQ3mjoLNV347waSRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJSNhurAszg/fvVtb9N1o41pt\nmgIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCJKNBYWg/uZAiBvowrJAwnRYPTMA/CvGxNsrVeZu3fMCIQDUE7kqceCx\nibO3DXeE7XK4y9LvQd+WlaMfmsatD+rBcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbDWrN5u1GYO7KVDoOYVA3qaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA3YTQ3NWYtYzgxOC00Y2UyLTgzNmMtMjkwMTA3ZGQzNTYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzg1NDAzNGItYzhiYi00MmMwLTk4OTEtMjQ0NTgwZWEx\nOTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVdkQrXrUp+b22hpFsoHy98CN\nlXC+m2bV+dQ46D+owPN02uh2KfSZdYupY0n3rAL5UnnuH1/GbEzCCmFRIX08EKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn+hbVV+VDikD7zmBH+7Yf6NGKrcwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgCRzQdsFsUzWWcXxB\nsc1K5wiYQ19Tc5Fp5eI4Sa+zwNQCIQDqZrTUcOqM4STlFoAkuFYLMefw6ocKeDSB\nH2EHSbHEPg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6874", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6874` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYWtZll3SmKeTvp6bEmnyguCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YmI5ZTE0LWY0NDYtNDY1YS05NzJkLWVkMjI2ZWM0NzJkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTliOGMzY2EtYzJi\nYy00NGZiLThiMmUtNDQ2OWE1Mjg5NDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERZSsueZx+W3fqC5pJaTtFfaBAly6kLCQiUzU6XYH4krsDAPofWjKcP09ZnVS\npwxGVtwLH9ssaLyg+i4IOOCD6aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmnu0BpyZwN1shqv6azBH27lmZC4wHwYDVR0j\nBBgwFoAUTxvHxtl6GYOFPOcJSRx265XvX7cwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDlohPrOr/X\nK9cDYLU+QgNzVSQhM1hWftpkiE+/xVXycwIgIQxpWjSoku4YdaP7AMZFxKFYlfUk\nGon86GkmcYZEX6s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWb+1JFswzr2x0q41bYwBMEbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2JiOWUxNC1mNDQ2LTQ2NWEtOTcyZC1lZDIyNmVjNDcyZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpVq71TR5X3/vYmzDVmXrq0hGxuJnuYK8m+spsbSQg4UnV\nG0lyeXg4TrNd7xCzA4yKwtVxyUm2CORuzpaTOWa5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTxvHxtl6GYOFPOcJSRx265Xv\nX7cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYOjzxv1YjcZQ+Dc6dlM3PlcKpzxeeNW4fTy9VEm3hGACIB77p4k9o7Cj\nXpaLDQ6O9i87DGdWDurPoGsQJvzjjw96\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAURVCMN2vJR0bYAO4SGpc9sgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTliOGMzY2EtYzJiYy00NGZiLThiMmUtNDQ2OWE1Mjg5NDNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzg3MDhhYjQtNjdkZC00NDcyLTg1ZDktZmVmYjQ2NGM5\nZDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENPdFdLqa3/Q2XF72cxYB9sGp\nyMZ+6k5rRD19ezh0rr7H4SBhmOqUSkICyXcKlRD1h44hlXFEhw/g2pvggcaoNaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmnu0BpyZwN1shqv6azBH27lmZC4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAL5ZSf5MY5OmF7C5\nGmW2bDkUUvASBNPhU6QX3mQCpfRRAiEA9PG5w/NMFyxHwkT02H+p32jYa00c7nBP\n+1e4Z6U38T0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6875", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6875` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAS/GJsvm6x3tX/a9GzkZwGDLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmYzIyNzk4LWQyZjUtNDcxYi05ZGQ4LTE2MDYwMmZjOGQyMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRmNGFmMTAtNTRl\nMS00NGNiLWE5ZTEtYTJiZDhmZjc3YTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAv6WQV/dWGJqaLAxFKDIXaMlGzfQrieQnXXwQ2yzgjjXVfE/Bx6aJDp2GuD6\nfvo0468/Mie+1iUHS+f32uBjfKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3/qqCYszkM/XfRsxAFxoH3FSsbQwHwYDVR0j\nBBgwFoAUDhIOMGIKhWARYW8ibdsMKSXYUpQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIcfTrDWjN0eP+Ti5VoPW1+umIoDZKeGseVWZkMtVsyGAiEAkcH4Jqdc\nhKpvty/Ux082k886eTSMSTWp021lYeSuaKA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASX0a8FAZuPknvcqkWulTQ5pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmMyMjc5OC1kMmY1LTQ3MWItOWRkOC0xNjA2MDJmYzhkMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQY11h/XLyh/2qmfTOJ1b0rkj6AUtT0sH2Rqfu232Vrjff8\n3dJ0wezUq6rPag1YSlIxgilpjDUXqCnalQ3vN2N3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDhIOMGIKhWARYW8ibdsMKSXY\nUpQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIXWL0jrBVxk7vYt6Zxb0LFYs1DnulmPzbB0bicKa+YtAiBVsaawegGN\nhDNXE+Xq+IekrGJlbMfTu9oaCLnNYct8QQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAYXo8kHVkwaf8KjOwx02JGyPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRmNGFmMTAtNTRlMS00NGNiLWE5ZTEtYTJiZDhmZjc3YTJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDQ1NGI0MjEtNDg1Yi00MjAxLWJiMmQtZGI2MmU0YThm\nZmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy/qwer3C0c4qG8vyby35RlWo\n7JtGLJmw2GJS8kCjypMF5jICRfhh+MC1WFJKJk8TwJ5vXnJDU93FB8a8vZojF6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3/qqCYszkM/XfRsxAFxoH3FSsbQwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPQhRWg85DWzTxjU\nZG0HFf//46dS/aSvLnCvgI+T/F52AiBa44cJG+fuX1q3WPCWb7q3O8V07VU759lT\nzcfDwyoOqg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6876", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6876` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAb4fQcbWDx+MX+H17Y2va/thMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyZGYyZWI4LWFkMjAtNGY4Ny1hZmM2LWEzNmUwZmQ2OTI0OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNiZmQzMGEtYjlj\nMS00MTUzLWI4N2EtMTM1NGExMTgwZGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+/vlJPFtEieMWMRM8XkK/iU7Q+ae6t/8rqVwbb3kBPHlvjnh7QJQSIR3gINl\nmYM+37x9oopAvrtQ+o3jnohjR6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU01Z//M80T247rY22zoZAs/6imqUwHwYDVR0j\nBBgwFoAU8MZwqh8iQFSgfvSyMSlBb01jqgIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgZLr1/drlu+4NO6yyU+dtAeLwY2Ux1pApcuv+RfiepCACIQCQzjOxppGw\ngNiWrjcMvxhvcdJiGgYwujPuNc2O6Jo0vg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXrZmbmJiK7wpy3NY/s5rz+jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmRmMmViOC1hZDIwLTRmODctYWZjNi1hMzZlMGZkNjkyNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQ6UuwkuBQOXC50IlYvNPN6gE7k9l6WdrJSry7HaX2T4o4\nTTX1OY53XHLuDTrV7J+Avm/CaPzDE/BHM0LqcTN3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8MZwqh8iQFSgfvSyMSlBb01j\nqgIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD+rCkNpojODhn1NtD74H95hqtQ4eYflvVCVuULI2a3UCIAzU1N6pOwQc\n+feaVn877lamZ0t7+rZHXHNayPQ9PF89\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZvIo/YhhJTle/3G/hMyfn3NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNiZmQzMGEtYjljMS00MTUzLWI4N2EtMTM1NGExMTgwZGU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQwM2EzZDYtNDA2YS00YzM1LThjZjUtM2M3YTBhNWVk\nMzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9eK2+aV6J37MiaDnmadH9s0Z\nYKxePkVwdwZQPyU5nA9ohiHCuZVflIgilVeKr6uzj1wDX55oYVNqcm34e9Dq66Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU01Z//M80T247rY22zoZAs/6imqUwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAI02x60LGRBpnJrw\n7En1BJUwMdbR1zYnDvL/aT+m++SkAiEAvF0lfT4wJ0JLqlODSD58buyFwnofbUae\n4/qozfw0Vno=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6877", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6877` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAbzXEqzeNGWSVHqxEUurGlDcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNTM1ZGVlLTA2NzctNGQyMS04OTRjLTJmNjNhYmUwZWNmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk0NTgxNjItN2M3\nOC00YmMzLWFiNTktZTJkZmMxM2Q4ZWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETkhSczw4n38nCTabjb4uHehJkbEyrGisfb6VzOQ3I/StACXm7paQhDwR7E5Q\nJr31AYSpIYWVpdjBPZbKtSQnOqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUloBdnmpp60MEASvOsI6fh1E7xigwHwYDVR0j\nBBgwFoAUWfmHe54VxmVWqvZ034h1qUghPG0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCo7OUelHDKYo/4dOpHCTUL1FAaB4XVFvD4kOuYK3nF5gIhAMRoWp9S\ngFMPlFFUceYI/uh4tpS5DDeutrhRbtGp5Tmj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQxmovuAHsP8a5oR+YGa0FG0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDUzNWRlZS0wNjc3LTRkMjEtODk0Yy0yZjYzYWJlMGVjZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxe6xs7kTB8w9B58xoRwiJVkdr5fkbWW/FDnZg77MzeKgb\nW/PAI6nVk3aHOSf4UNGUin5xxVw63SDZFS+gNr2Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWfmHe54VxmVWqvZ034h1qUgh\nPG0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbjgy/s2AyMYPFwsBkDAkLOt4VhNOlZ8L5F/RBzUM7/wCIQDchO09gZKI\niE3LeknzwUXg2U2SVpbPBRiAMSSRzWvYUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAcTV9jxj2aYgWKcEIsT5ldiEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk0NTgxNjItN2M3OC00YmMzLWFiNTktZTJkZmMxM2Q4ZWFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTc5YzNlOGUtZmM3Yy00NzY4LTk2YTctMTM1MTNkODMy\nNTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE20S/o7dID7jWeQ0gRSys5YCJ\nr8e+WwFFloF9PzDP7I9yYQH73ozGssEep9k9PyI1c20Tkkv32/cf8voMkwUEbKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUloBdnmpp60MEASvOsI6fh1E7xigwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAO/+TNxNnVDK0omo\nB1h4aw3+2bri6E67mvK1W3h1n/JHAiEAv0mIc6tlasDWTF78qmQLJTmS79KjTFd2\nm0xCiSnX23A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6878", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6878` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAV0faSqwot9QqVUZqq558cfQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMjIwNGJiLWQ0YTAtNDU3Yi04NmRhLWUxMGRhM2IzM2FmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJhMmU2ZDgtODhj\nYy00ZGJkLTlkNWMtNWY4M2IzYThmZTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5GZfzjfkVq2UzMUh9PyHJHn9Dyd+F4k4cOyFK8fB/wzdjR/wEDQeO/q522UA\n6SZfzYVBZd1b7EGwln3EtXxBRKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMC+jtlf9uk1Bwj2R3PykY4q76d0wHwYDVR0j\nBBgwFoAUFX1j+v7IoDMTl6uWSqwghdNfElowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCICXKakmY6g7rTAa+3+Z1ElWZsTDjumDIaI28Lnnd\nKz+UAiEAkzXRJSriDDlFZ9uu+EXrLq+vBOCbY9XpnTe2tmSw7vk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXT+siMcwxGzxLexhWii+ofrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTIyMDRiYi1kNGEwLTQ1N2ItODZkYS1lMTBkYTNiMzNhZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHb3qUji6kbb7XhtqKeAVAdbLX8IkV4T76i4pBg+MaqV7U\nCaQ59B+8Yn0nh4yBQeAUxNpHQQzs8t774wSNW5aao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFX1j+v7IoDMTl6uWSqwghdNf\nElowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANdJnsvzu/ptsmlpsCVmR+Zs7WLkQEFTGyXqneie76D4AiEAqOQih/AM\n0CS1aC03gI6+ykkEgrmxLvojSoC+2tXQQQU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAWqbbApZHQDJmZA/qn81TLkRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJhMmU2ZDgtODhjYy00ZGJkLTlkNWMtNWY4M2IzYThmZTRlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWNmMWE4YWItODg2Mi00YTFhLThmOTMtOTcxYmNiYzM2\nNTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjnfo6LQUDdDGWGnnnEHbT4Vp\nld+utmKROry6dIja1NNb8Z2tXr/2ggkbEWxtuDgzvZh+Hs32HM/zhgPbk97wT6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMC+jtlf9uk1Bwj2R3PykY4q76d0wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgISV4w/lkWpJiribH\nl2deB19vYsPmHXOkG9aN1V6qLDMCIQCKW38Gk6c+p3bOanv1TCTDgE6NM9NB2ibE\nllAOOB0UpQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6879", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6879` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAc5dHr4FTJwKWQiD5B52QHAmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxZGUyMDNlLWI0N2YtNGJiYS04ZDM0LTI0ZGVkNDE1YTE4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q3ZGI0ZDMtNTJj\nNy00ZThlLTljMTAtMDllMThmMmQxOGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIC6NK4japebMpC/jMih5F3xMtwtgTRpbsyDJ7CmbyUcKpsOof3PkDdyD9iez\nZM+dpGmYrtOot1HTAqPhQJeo7aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1VKp30NtPjsrhQ4qfz0jm0B9c2YwHwYDVR0j\nBBgwFoAUnRCp6iRegvmxtJiQyAKHX/3bboAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIGkXqTZkmX00+T0fnIiw+H9ih5mqb3nTh88P8Fib\n3SfHAiBH/AnbbrhQR0gZ9NqWoXUbxHDq5mnUToPpcJ2OIj6JTg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARDJATz0vqIpwjqmD4pkfW6AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWRlMjAzZS1iNDdmLTRiYmEtOGQzNC0yNGRlZDQxNWExODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRvnSlL1wmz5iWCkumsHOYOOelqwFB1L3YxFR42UYi2R0A\nXKbpkW47OSOW4x6aJ9fJ6/t/XzrluM78J8ndNQHPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnRCp6iRegvmxtJiQyAKHX/3b\nboAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMDPOaOBb2Vl3RxQTDXOVCTswM1DO/D/Yjk5UJQv8+r8CIGhr0VQ0M6ti\n4sldWsPlMd1Tss5c/yy8vLxpmT8cme17\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAXuLu0LFWr4yvJF/KtN/RBWMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q3ZGI0ZDMtNTJjNy00ZThlLTljMTAtMDllMThmMmQxOGFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzM5NDIwMmMtOTQ4Ny00OThmLTljYmItNjhhZjYyZGMy\nOTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqVGmUbswnswfEQplyJX4C7NY\nHmfLGrsQkeWFCt5fKtqVo0NYezRglDzo7sXCmoZbekmoOLAyP+p89J6n7qH066Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1VKp30NtPjsrhQ4qfz0jm0B9c2YwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgM01vhq37Cd6lWbaY\nXQERuBNL5bjHqX648EpGXvfD14ACIEc+G5tNaXwxhaJlMqVg8j4Hm7bTOqqGIqUE\nIKS5cIAh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6880", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6880` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISASiStKow7LfdHdOj6inz3RV+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4ZDAxNjk1LTU1YTAtNDllMC04ZWQwLTM3NGU2YzhmZTU0ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzYyMDNjMTItZGI2\nMS00N2VhLThhYjgtODcxNGFhNjAxMDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPKIkGRGTQcnO4mvCZI0gzaHQk3vfN738f40HRzzMR7Z0dTWkvKzlnv6RDYzr\ni72mg6Yr67Cnmn8P7AHo9TdV96OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ+FeRnLGCj0KW2szZjEosfrL56QwHwYDVR0j\nBBgwFoAUzhHiWCE9QbVvDCf/BKRuWAzswk0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCICDtuDuH+LwkkNQuwIoausrpsXsDvb+IH7OBnabsMYBrAiBC\nwa85YUu0VWJIvbPG7W/4RXifiADOYtoNyVCpXZmVGQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcHHwwlTl0ZRCNkoNJobuu1/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGQwMTY5NS01NWEwLTQ5ZTAtOGVkMC0zNzRlNmM4ZmU1NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkdzB02hX8ONK+i2yYu1B7nxeky4LsdHBVuys3MYjmggYY\nd7k/00Tln6j9auYcV40+gkNC1MHdUltq54r2vm44o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzhHiWCE9QbVvDCf/BKRuWAzs\nwk0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANrvQWCNxKwYBmC52yXijhYvA4h3tElzxtXdA+kHomePAiEAmhcgQe6W\nLgPt6L4B5xO1JWFOpwqF2UoNlsKyA9loVik=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISASHy535WyGQSVGQHGLOEtIxrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzYyMDNjMTItZGI2MS00N2VhLThhYjgtODcxNGFhNjAxMDZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjFkMjU4NmEtNjkzYy00Yzc3LTk2YjgtMmNiZTA5OGU4\nNzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAET8QM/0VjWbG6FQH6TSybJdqP\nPRCRfMtMO5mxIe+AUIeefBKixf+EJ4D+JvwLK7exiDTKbuy3F7q+zJivdqhAG6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZ+FeRnLGCj0KW2szZjEosfrL56QwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJj9ekE9wTxtiKLj\nezefSH/hrX8D3PQxZcUyRu40QNtrAiEA5qBKBPmbzu5Z5narHi/m+c92SN0VBo9h\nNN/weH9pTU8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6881", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6881` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAW1v+pWhsjK+MlgPX/j9nbGvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkNjVhZjNmLTMwY2MtNDNjMi05ZWMwLTM2Mzg1YjY3YjZmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzdhZDBlOGItMjlh\nMi00ZGZjLTliM2ItMDE4ODU1NDNmMjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUYe+GKV8Vx5coUhesKS3fmBqi1xKm5IEN/EhpNpTB5kOcgOdwGD3g8mTbaPf\nZPhx5D5zmn2Iz22nx7cQu9s396OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ+e3abl83ecihaOzfmwDaw58ClgwHwYDVR0j\nBBgwFoAUYSCftPHqdDyoW4qTlgH3AQ7hECQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCtuJHL1AB3ssNrtP8M7gUUvIJq0Nic\nNKjGfqtR+JwUxAIhANTri83oWY/lFeriqlW6gVwuiLygrjo5S4R/3DI2LLaN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVL9lQmFIKlF0VD7kqaCmAdeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDY1YWYzZi0zMGNjLTQzYzItOWVjMC0zNjM4NWI2N2I2ZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT485q1/MbSU4V0fyRN/lW1g/F3TyNi5RToMIU0yzYSxT1j\nBzeshvSEIgTk4V0q0c0k/x8ZIvF21tI9O4ZoHVsRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYSCftPHqdDyoW4qTlgH3AQ7h\nECQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJwLMScFhNYgyNE3sTX4BmOXF4Ti/bN5RTAOaCieH8c4AiEA2vgWs7iC\nvcqkV2lSlP8aH4bJyDWUCF8mtL1YgQSzDfM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAcoNmdgpdQB62I6G7aPHRbMNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzdhZDBlOGItMjlhMi00ZGZjLTliM2ItMDE4ODU1NDNmMjZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzQ1NjkxMmItZDE5NC00NmRhLTk1ZTEtZDg5NGY3MWY1\nNTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4O1mU+KUpSmaJrOebjKzx8CT\nOn1rbOybtfPyEGYQpm3AXzFNEpE+CstKuduO2YJZ7ibJQv6tOeNkVZsTXv0qxaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ+e3abl83ecihaOzfmwDaw58ClgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIjcmXfU6WroSFqY\nLS+h8LJsCKxdvRUHfjjjOhXiTl2/AiEA+hpaT38To++kUSUuzgBq0tjYRR77UNMO\n0DeEUNh3270=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6882", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6882` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAfdvrQkUT2w+xVYriQUePAw8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwY2Q0YjI3LWVmOTgtNDE3ZC1iZDhkLTdhYTZkYTA5ZDk5MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM3ZTkwM2ItMGEw\nZi00ZWZmLTlkYTYtYTU5MTFhOTMyNmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtIAuTExtcBRSZThQTqqCSRo1Equ1JTBBm341etzNDKXr0kqnO1TYaHZRHIjb\nKy7+C3ac+daXtCE2I/T2ZF0ytqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYpmfJI96DEGzCb4t9AQ4UFaAT5swHwYDVR0j\nBBgwFoAUu/Y+gGAuVDt1SVBCnSm63Y/vmRowSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIH5z3sKnNcDEunmMcF1E3Iz/I4QmV29t\nsLEKHCyo1VfBAiAfCG57GDT1EUMEYsJuuaJ3vztRtiKkfLVokYBkET4EZg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUFy36iHw8fnChhuRNQlMTnmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGNkNGIyNy1lZjk4LTQxN2QtYmQ4ZC03YWE2ZGEwOWQ5OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxeYPt1x0qE+3C1/5uPiObORe78HRMY7iQJTPygES/Qumi\ndvtSizGQ93nptaW4o6mfgZRTyVHqevDBrws6Cpvdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu/Y+gGAuVDt1SVBCnSm63Y/v\nmRowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMV2H9iOyGDTbn9A3cb17CG8EjDnLGwvW/fJiIiw9Z5ACIQDWbmk12ZQW\n2vm+fkSTny8u2uMi3b/MwxmzMCmQFlYxEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAfhyDj/CqmSBJ0FXjQNx+kmrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM3ZTkwM2ItMGEwZi00ZWZmLTlkYTYtYTU5MTFhOTMyNmQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjA0MDdmMDctOTI2Mi00Mjg0LWJkZGUtZWExYWMxZjBk\nNWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWhPwAhQRlM6m9Cj1W4oJ5/0t\nRy3taEOoEEGh9qlZVbhmz14Bxh1rmUPWP/uK+AWM7vOIr6xK6RQEAVpxl+wjmqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYpmfJI96DEGzCb4t9AQ4UFaAT5swGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJ3oAP8eOMa+Y3PU\nLEHrBhxQ9a6RrLCdggdpqFMmKZTcAiEA4zvRE8Kicwh/Vtl4QmzuejvIrEAQ7fTn\naY4TpB6Fbds=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6883", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6883` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAXRudV8T39q1WWyFPU/WLILwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMjE5NWUzLWVkNDItNDVmYy05NmY2LWM1NDlkM2NhYTFkNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRiZDQxYmItYTA0\nOC00ZTBiLTkwYjgtMTdhYmYzYmEyY2IwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqfm5Ly02/QawMU5kJOzp9fDSfTQMnWM529F7VJ8SeNQS/4U0dGen0a1MFnEf\n0lJ3gqGqfGczazj2Ujg33HqzBaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/HpLn+H2RWu+nkz1Zc6UfwjYR9QwHwYDVR0j\nBBgwFoAUWcBwOrWjn42nIR7ODh0jiTUc5WkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIC9DeWmh7teo\n9+WYBJwS2KTrAUL8i/kcg2NUFmdwMTlMAiA1HKl9XhfTnr2xrZuJxuEqRObmdbNG\nANqr6AWVsO0YaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASo5OWa0O/s5TCxrJASmqlHsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzIxOTVlMy1lZDQyLTQ1ZmMtOTZmNi1jNTQ5ZDNjYWExZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZn2Z7DC2CWbZYrZiG67hEetwamrIxZMblyifmMGUlUKqq\nwkP0VoQMx2Sfi+VQup1EnjTkyBX/Wuoq8lTqZhNto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWcBwOrWjn42nIR7ODh0jiTUc\n5WkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbMIunKYvGydb36OqSzaB8JBgQVBMJ1+lw3Zdd8EW9OwCIQDQ22qErlvE\nQKMvvkUnPBNvfTnQBppbXBsq2veuhbv5Hg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAUmdZQyGHT9Z71mdJXuVfcQ7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRiZDQxYmItYTA0OC00ZTBiLTkwYjgtMTdhYmYzYmEyY2IwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTcxY2I2ZmUtMDc1ZC00NGI3LTlkMmEtN2MzYmY3YmMw\nOTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcu/29MYoJuPOq/4wCcYd2dXd\nDYVqpXSETaExX5PjwXPtTjoAateoQuvsw1wLVUTMH54xU5X3YpAcvvilmvH0wqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/HpLn+H2RWu+nkz1Zc6UfwjYR9QwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgF9qVnX3ZWAHHa7yl\nPjq1ezXrOuMfXSCYzemTN3OmVcoCIQCZgh8Kr4keOfG9E7iyAk9+t8F31+1uWXi+\nt5ZuwWavIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6884", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6884` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQeBxqHr02dz+BCLlKoGNiXHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzN2Y1YjBkLWRiOTYtNDcwNi1hMTE0LWI3YjVmOTAyOTBiZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU4MWUwOTItYzA0\nYS00YWJhLWEzYWQtNmI1MDQ2NTBlOTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5cTNx9Uz0K1vop3NxNtsnkbMyvhyG1d/Bt2UnXcSEKFnN29HB3URBQiS55LD\n0RFt/dQqaxTQCFT4QhhuiHuW56OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW3JJ7BDcIuZ+06ziXYC9oGW/UtkwHwYDVR0j\nBBgwFoAUyLdJ/Prw5WhUP7PTymOfScjmZ/MwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPx5iWuJwxP3sfvQ1O3gHX5GEkiHWJYPS9BKf8chhBtLAiEAzUDiFIzX\nkOrkm7W10eBSGKlsAOUq6XUuQ8kuuDf2Oek=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYtNdgtnBkPPcCL4Xgv3isj1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzdmNWIwZC1kYjk2LTQ3MDYtYTExNC1iN2I1ZjkwMjkwYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIQPYQcgYp75N80Lhs94jVCwpWzaYcH1MMz3Wi6xT/wkyV\nYPiJDBXt5aoAY6nAlthlTgi/JZBVASaxYq/o3IzMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyLdJ/Prw5WhUP7PTymOfScjm\nZ/MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOOW8DAEvB9GosOvwRzQu7nTi8SJ7l7H0XLTyQv/nhyFAiEA9aW61QrH\nEzZFOzNrpb/2dSFnDzLns2zHO/w9XphnmDI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASN8wjAr2WKJyl3Woi/NsUddMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU4MWUwOTItYzA0YS00YWJhLWEzYWQtNmI1MDQ2NTBlOTczMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjM1MjMwNzItYWZiNC00MzE0LWEzMmItN2RjYmYyYTg2\nMGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhOJTBVxf88sLvrtU6u0FjeWM\nPJwii2cTjvF88gRlsIcMRo2+Tk71HbM6HQGjBEg03OCuRHmgApj91U/Q1LCPjKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUW3JJ7BDcIuZ+06ziXYC9oGW/UtkwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgHYncoY91ArybKCXu\n1Oeo5LTgZswUvLrwLu5vY/XMiCsCIQChY5Jhav/DMgnS+fWw9nYGiLGO7DzfREw7\nFGDNDM0iQw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6885", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6885` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATetEMWS38ZN3qrOe2CnUEh5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzZGFjM2Q1LTI4YTAtNDQ4Yy04YTIxLTMzZTBkN2NmNGQxMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc1NThlMmYtY2Fk\nZS00YWZhLWE5Y2QtZmUwZjgwMmYzZDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFLXLAJKo2mBWZD62aNR+YnBmXwBhmC/O1CXtgINKJ2NZxDFn8f6WcY7AyEZO\nzlfTbXzSm2vF02LJiw1jwdOe5KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGNDhtuzjoL/fW06sCjQMtLls7a4wHwYDVR0j\nBBgwFoAU4ickxXjDpie6ruPjQQaDgpKnJeMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgVqsNh3A5+Pdoi0VmRvo44khrQON2K6Va6DLjfCDv1XwCIQCPlnDqYUwG\nqQljax6ln/VjyNIL4gy+5svJqy65JeW3Dw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcnyzYwaHuZJcuBagMCp0wQEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2RhYzNkNS0yOGEwLTQ0OGMtOGEyMS0zM2UwZDdjZjRkMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm8Cxkk8bT7TDooJK7HjpjR6UW85IdrRAOy41/rhPTI+4/\nd7uQtOYmX7Sl1PaWvmBD0/ygdzKqgufi3hRHlzHFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ickxXjDpie6ruPjQQaDgpKn\nJeMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQPk4fqeoUyyxIDwEch/ZVSdtBYH03eF1SSq8AmwNkzECIFYONwYfoN2N\nTkEIU/34w8QB8JIKNerUha8niS5Siaj1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAToa3P+1KYYgG38b5oStcp/sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc1NThlMmYtY2FkZS00YWZhLWE5Y2QtZmUwZjgwMmYzZDNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGRmM2ZjNDEtN2IxNS00OTA0LTg2YzgtMGE0MTdjZGYy\nNDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB3EE7iKFUeBLC7XOemPnZThL\nnISDlgiEsIHRGUUpnjhARA8SWByk6biIK0c59Z+hBHCJJccUSS3iqJk2qwJ4w6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGNDhtuzjoL/fW06sCjQMtLls7a4wGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgAJJr2Z4alUeIMqG6\nHMT8cxBLo1laU28AzcK9DgO2yxECIQCYCK4vWNhTKeZHjf6ZYElMkSipsd/hy36G\nF/7DkMTTPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6886", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6886` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAWf7zMz0BtoWwpoQqkGSrNVjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjY2I0OTQ5LWQ0NmUtNDE1Yi1iMWRlLTRlYjFlNzZmYWVlYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhlMzgzZmQtNWVi\nZS00MGZmLWE1MzQtMjVjZWYwZjZlYzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIFfSB4FBj3SG/ytmxvSzn090a1nVJLPg65asddIaL2kzgUIs3Jz5fTHmzmsh\nLNOBqiK2AN0soM21Yy5VxKDYIqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOvMbsr8SguyD0gvATryA6bejE+cwHwYDVR0j\nBBgwFoAUkeubIfR9jGn+hIWXJkHsOMrBeE4wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDd1X63bggOfW+jbdxNHPbf8M4JWlnG8eZE2MygIu77AwIhAL0jipRo\nRZqhka6+CWqpKQ+YA10YUD2SGB1NOOFlCD/5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUwPgmb2Zir7ay1PdbpEJQ4ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2NiNDk0OS1kNDZlLTQxNWItYjFkZS00ZWIxZTc2ZmFlZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRLihZ6UQ7u22xTo4WpwmYCiZEpUNtYXCvlqKnKrxImT7k\nvCdn7j/xtZ4WsKoCDJOgrhbECW91fcJO0AVRQGhGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkeubIfR9jGn+hIWXJkHsOMrB\neE4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMNY4WWxzIBWho85fGyfCLfwHcXui9KLCltunXkKRpWRAiEA46D1zvRa\n7gub7+pFz3i72H1LvHK85NuTXpoZ1Kf24a0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASs2QhpynwiRAp24dX7WZuwCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhlMzgzZmQtNWViZS00MGZmLWE1MzQtMjVjZWYwZjZlYzEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQ3MWZkZjAtNDU4OS00MTkyLWJiZTYtMzI4YTYwZTgy\nMzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo0H3IBYs8AWeMtattwxJWaYM\nFDS5Ni37BZbr0IodUC97VNitur3fGfhtAb0R6x6vgwnX8tea/RhL8JVmQsWqWaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOvMbsr8SguyD0gvATryA6bejE+cwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgAls4XgRdSHs8MK4+\nFTTx5d+3rkrmkQDUXGzlsFJR4kYCIQCOv6Y1MfRt4PwIWCqvIl9hELMk5qLr3Hkv\nbKMRGUOEIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6887", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6887` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAbVeBWXs7hOA1BNDpLNpAD9RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxN2ZkMTVlLTBjMzktNDc0Zi05N2YwLWEzNzQ3M2ZmZDEzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDliMjVmN2EtM2Rm\nNS00NDI2LTkyMDMtMDU0NzFlNGJjZjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuYH/UeTDuGgQLj+MmyoQRD+PqXIuF5S9YpkmgE3ctS7lZIC7nJKsqS0kk50X\nFAXqssALiBiby/+XDRkn3YdpgaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtNCzJy4S6fIsqi50XIAO6+cz8TgwHwYDVR0j\nBBgwFoAU+VryPchJtlTUQOxJZZ+KmAuRO/cwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCud5YibD4wCS3Y4rfoAT/4kIKgK/2PnIeLnxDg\nYpHKrAIhALHEDlFBqTfl/yimiRBiyu08Kwq7M34MkG8UCJnUrdO/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR0foYLZH9o+S1705m1RrnRTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTdmZDE1ZS0wYzM5LTQ3NGYtOTdmMC1hMzc0NzNmZmQxM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4PxAxXl2CkkUFLclD35zm2qB4WXgqN5LK2rxq776K6byz\nRh9Iy1z9ot+fqQFRlIfWfMg64diyQ7ca94uws5nUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+VryPchJtlTUQOxJZZ+KmAuR\nO/cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfcV6I4ZqkPxpMxVuSrn3cEOglChntJgmQJwsWFAjrUcCIQCwznQa5CdR\nZ1W8mylWc+Y2WhOLr9tP2OtIQUrq1RbEFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAaPnl1oUG+TfcMXd+E4SJaiwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDliMjVmN2EtM2RmNS00NDI2LTkyMDMtMDU0NzFlNGJjZjM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTZkMThjODQtMjdjNS00ZWQxLWJlMTQtNjVlNmZjMDdh\nNzMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnssqKmW5TkrWfGnBrAhU+/E2\n8FdhA1ui4hmoPiZELIMio4b8ZQvL9+NPW9REgn5EM0/xnSvcMGMKw/Gq00pDq6Nx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtNCzJy4S6fIsqi50XIAO6+cz8TgwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgG/2fol3+dvVrRMqf\njd+wfkHSCLQVMIpzgBs3t3UsTl8CIDPcnNkfNVBWmQNtayEm5Z4g0F+5tVT5jB52\nCQpNCDIN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6888", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6888` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAfnUY95E7K+l6mu8qsXlADDjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllOWE5NTA4LWVmMTgtNDVjMC05ODk1LWI2ZDUyODU5YjZlOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFkMGE3NTQtNmU5\nMS00ZGU4LWFmYTQtZWFkYzE2N2IxNzFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1mrmpvr+dNnyho4bCg0qw3igLlDoUflHYPXkNeXd0bAgKH0CY5wdx1hzaiNi\nL3brs8tb/TWxeOlAhrb5y81wZ6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4IxpquU/gcxjP1Kc5Ixhl0EJPfIwHwYDVR0j\nBBgwFoAUi2AnJVS9sNEQNINNmFTTQpr0avowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIGiNFTb9T0lOaqpr8XuLX8VvMTvSm5pqjO6zmLZM\n7xPyAiB9pzzB9C6sBc6bZoTimxP8VHkjKGc8bs7ql5rC/eFTSw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcA7GWCQFMZjaXSAoGmNLIabMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTlhOTUwOC1lZjE4LTQ1YzAtOTg5NS1iNmQ1Mjg1OWI2ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQExegIYAcrsmlFj1dXjq/Uk4yJ5rJp3leg0VilCrfkmrYN\nsTaQ8N2SXUpePQVdB9AFrJdyt28tPOz4+woy5Kmvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi2AnJVS9sNEQNINNmFTTQpr0\navowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALRDKyJSaMhUdVHvrEya9GuUd0NWBrVw5ov0lB/TqwBTAiAaQZxmFs6P\n3pJcu2jAb3l4VsSvQSKHpKx7di+/AM3ydg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAfWpVshEN1Ix1UvAc6KNEspUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFkMGE3NTQtNmU5MS00ZGU4LWFmYTQtZWFkYzE2N2IxNzFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTc0OTEwMWQtZDE3Zi00ZTY4LWIxNTItNTk1ZTY0Mzk3\nMzNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsZixrsmCVntU/5cOMipv/ZY2\nF+SGrPSEslQRir+AZ4hnKffkwi2skhUxNPCWGwwsxpieMfmrLJDUB3umNI8OkKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4IxpquU/gcxjP1Kc5Ixhl0EJPfIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMqXao+0snR04kUH\np2ST9mXqlgYrsXxp5DWbwDmzhV00AiAuVUyzdsI4PM3SiNsHNc4YFjs2Tn+xYcbU\nztgC9OlRTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6889", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6889` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAeX1CebiubYxY2SBYPFANgYqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwODA4YTJiLTk3OTAtNGU1OC1hYjljLTYzMzE4MDZlNWFjNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE3MTFjZjItNDJh\nZi00NTY1LWE2OGUtNzMxMDMzNmM4OTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsX5PDLgjsDKbrY4EUfhJD7o11ESVHTJlhmnVbNuWru9/9/z4ppRaih4nhnWH\nuLQSKfS6VWqCfwpX66Bo+PKnvqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGnbhgWaZE7LC8d+YEqzLw6BmKOYwHwYDVR0j\nBBgwFoAUbZPzXP7jia0P7m+xppnhb0y4It8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCfjc7RN+UAL0ZDt+iWMCiPM7Is8NTccxOaD+RhzUDgoQIh\nAOxo5HApMloiTHeSeqkAbt6nYKwQeV9xVJO0Mp1UmKAW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbtwmOl8i32sD+AGPjMU/h4tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDgwOGEyYi05NzkwLTRlNTgtYWI5Yy02MzMxODA2ZTVhYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxzUjN8ZLF4oRWGWD3QKbHBt4WzZWd7iyifwBqeRkAt+rS\npDsVBRQ4XAXJdiVS7LU38zWbkuilOUgv4C5B9e4oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbZPzXP7jia0P7m+xppnhb0y4\nIt8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSxc8qL97HVjRViJyPqB1kc21l1amr5M7HlPiUPB4obgCIG9w+Ogy3p4X\ngZ+1l8dM0FrQ+e80dlLiiqwtlys5g7Rn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAY3BZGPHty5sk1PFjPcsljiAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE3MTFjZjItNDJhZi00NTY1LWE2OGUtNzMxMDMzNmM4OTJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY5YWZkNDAtYWNkNi00YzI3LTg5NzEtZTc1NDJlYzE1\nNjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6p7ZEyVwR6IeiIyhel02v3Vk\nBXMr93mrLvB2KZmzZr/xCikF/TZg027qOOAbRlppDrfBAibxuIcBPjfiI4CemqNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGnbhgWaZE7LC8d+YEqzLw6BmKOYwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMwW/PS5xVWfd/Dp\nDAi4bRcuBMH4kkHm754H3IBY1HJFAiEA3YebXJw6z+knnVNC6bjUbLtWVjbLCwVc\npscU6VI6VNw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6890", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6890` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAW7GNZIgMnkd3nPXJSVQ2prrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjMWYxNTE5LWY3Y2QtNDAwNC1iNmRlLTgyODEzYzZiZjYwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ3NmM4YTEtZGI4\nYi00NDQxLWIyMmEtYTgwYTU1ZWUyMzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+zRErW/xdN4qmMV5r+eciU+GlB0OkZ0vkaL4YPBhbyY9mzszTAqU7qFyjwNR\nGTzc8x2+BHT8zLYxvoWg8ScvMqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNjeMX7Ya1vPH50PeHRErGtdWIgIwHwYDVR0j\nBBgwFoAU8CNIyCTZZ1ZfO23SSChL5U5cwYIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIDjJ39ZImRfixXo0AXCrSdlYolY955gA\nqJlK6MbH5QYAAiAlZD+bSYDDBujwQXSsdh3TpxhpZXxKfrP5+bHCWB0ONQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAReqxIhb3yFezWYZSfqih5OaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzFmMTUxOS1mN2NkLTQwMDQtYjZkZS04MjgxM2M2YmY2MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEXxRyt53Aj8OVLjBjFCOJDF0O6ca2iWOlj4OsY5/9d25Y\n4WYzHF6h+2JjJcQnhL2LVIhdtEXZTtPiCr2/3DTfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8CNIyCTZZ1ZfO23SSChL5U5c\nwYIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHGjH0YAAmqCW7lORan8SP/bZH2cUm5RIvEmdQDRcz5wCIFaZbz32UvSQ\nd3LZkiRbIhkdw3SjmM6W1Bt/T64twKjx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAfWoMRgZr9Y3Qah8IiLlHndwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ3NmM4YTEtZGI4Yi00NDQxLWIyMmEtYTgwYTU1ZWUyMzI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmEzOTYwYjItY2Y5Ny00N2JjLTgwY2MtMmI3MTE2MTRm\nYWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+XGbT3BCKEtb3QJsOCgI7Axw\ncfVoHZZ+w8400jRKdkhIbtB+T3Nrr00kGZCyWTR6Mpu+VALOPOPbdPDAyoAtuaNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNjeMX7Ya1vPH50PeHRErGtdWIgIwGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgIssXt7i5/0MOGX8h\npKERKmawvTdO5fsslE57xCsxR5sCICRrbylvVff4pKDnsoAaJ05b/W/yPgvOfOIL\ngYnuovOP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6891", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6891` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISARS/76sewiLQZwEV/sQF3fKoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkYzg2ZjFiLWZjZDUtNDRiOC1hZWEzLWFkYjYyOTQ1MjI2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE1YjYxMDEtMTli\nNC00MGUxLWE2ODYtMTBmNWY3OTBkZDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEERrPZAq278y0wigXvO07pTQlI9sre6kS6Tw8CTZ5s9Xpab2WIvbJqyaO5FO9\nlo/h/qlFQkM8sI/TmnQXphm0PqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2i+1RRgnPLidBPuKTtTMXcQ66tswHwYDVR0j\nBBgwFoAUw4dXyD1/y2c0Vg2bMOo4CPK2viswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGMxL/pVrcLfQo/kJt8oPbclrHgzpZnB\ndtiNKmrClRgoAiB3xJ9MSSk/8iAHYCBWzrZ4OqpHRvsNTjA5XCGgKtXsIQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATkRFGqSLM8+mfOtQq6PGfyfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGM4NmYxYi1mY2Q1LTQ0YjgtYWVhMy1hZGI2Mjk0NTIyNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+BSRhxC1VMmw95NlKbGOP8HNvPtwugZQyVE8nuuu4ZbYq\nZ2uiTibeKg6+2CJcueN+VVbo9jfczHnQ68FcRyA6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw4dXyD1/y2c0Vg2bMOo4CPK2\nviswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM9LWxde08yaYsw2cF44dezBPLPNc4WlQ+nUfGnZNOGKAiEAo6TrcJ0z\nI0oeyixxQZstY24J35cPhGBoS16ROxg9BEU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZbqdwdSjZTZwfGMx54auBQiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE1YjYxMDEtMTliNC00MGUxLWE2ODYtMTBmNWY3OTBkZDNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2M5YTliNWEtNmYzMS00YTNiLThlZDAtZDNmMjQyNDZk\nZjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhWEGCcEBwmjoA2cES6PlXgwm\nOpgvoAfBeRttE74Z6WbFJ2rO19hKeO8xkBXAIfrPatyRqQPTjzR52lZRXtREXKNx\nMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2i+1RRgnPLidBPuKTtTMXcQ66tswGQYDVR0RBBIw\nEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgHV9RAkzBEU73WQD8\nrfeXE+LXAnLunSo9zZDsQpCOebICIQDXErWSrbzk5NYfwY0XpW5vE6/pskdrZ+iz\nFGiJCA43SA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6892", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6892` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWq5Uk6vafWvoafASbLYZwkUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4NTAwZDkwLTc5Y2ItNDg3NC1iODliLWM0YzQ4YzQ0YTg3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlmNzViN2YtZjAy\nMy00N2ZiLWJlNjMtMjM4ZmVmYzA0YTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWg3jWfGNziGuML5MX6NdjoP5Q3nL81/66lIPbbEPL8JMIQCLtmc1gzGwW1e1\nlGZPk7lwSRsxx+FlSKkOtX/TRaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGjqnK+yDXJbQAMN90zwtHLoe4VMMB8GA1UdIwQY\nMBaAFPqGqxdlKiSx6DqZ2Lz5DjjLrf4GMAoGCCqGSM49BAMCA0cAMEQCICsop4SZ\nX2LJ/BDPumvciDSFfaX++jCymxisCrpofBsDAiA8yBPq0+FpZJ/lTzmZdWyFu3qZ\nJDvwbad+Z5LTUNARFw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ/tB247b4mTUsp87y7bXffVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODUwMGQ5MC03OWNiLTQ4NzQtYjg5Yi1jNGM0OGM0NGE4NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxR2Rv7rQshJSPskwl0s5CKdY0MuPcVI/y3iAiwNLwkqT8\nMp/4T6ayOMpGyhC0KwPFyFtcwdFedCoG/Ia3NL/Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+oarF2UqJLHoOpnYvPkOOMut\n/gYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANuXwj6epkdydsveAi9VJaK8zRLnXs/LVveKB3xZC0MHAiEA38b6VPdo\niomxybiBgQC2tJQoDANBRArMsSQQGZV6cb8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASkmvDL73ktpr2qbaz2x3zfaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlmNzViN2YtZjAyMy00N2ZiLWJlNjMtMjM4ZmVmYzA0YTMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjE3NTI0NDgtMGM2My00NzZlLTliOGEtYWQ1Y2Y5NTNk\nNTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn+E6cCbJJf1cbCX0fNB0F/Dm\nir3c9ljXbOfXhFonSXXmK+AzN2vquJJj2Ryt28mFjNTQ0Y3TyMrBPWwOQYeeSKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaOqcr7INcltAAw33TPC0cuh7hUwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgILwoZb7i\nfPR9vREwgDPK0CcSaG1IiQm5OpbUjf9S3uUCIAOvuYMSqm/6RMDCt9XDmHVCZAsg\n+zBFoUPZSE3RFfyX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6893", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6893` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXqPb4jXQiZrJHZhyHm0Ba0aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNmIzOWY1LTM4ZjMtNDdhYi05MGZkLTkzNjk1N2JlNmMzMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI4MjdkZjAtNmRh\nNS00ODhmLTliYzMtYmU5N2IwM2FlOTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgTjWSYBdAIaiEQ/pEdWt9JuW84l5ag9GWUjW09CoZf1+OLMU8ycsns6Vzh/0\nTUzes4SaWUo/2dBFeyBaOvSDdKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKcSJv5hNVfxBchAvPQhkM/7njSoMB8GA1UdIwQY\nMBaAFHxlj6xl6LJ1Bd5MjyF1QbBy0bBHMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBnA/5ZMXxFr1uAR7SpcVLITxqX00CpqkKl\n6LqkqQOETgIhALLg2xeaMALt1mhSJpreuRAEeZFml5YzpGGIDJtu30Pn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARXdbIm5pmcpWZt+a0RGB73tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDZiMzlmNS0zOGYzLTQ3YWItOTBmZC05MzY5NTdiZTZjMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASL7esPRbVJ/r9R1CSCbtY4FjceKVPYb1EQrQdSXxWTto7d\nenVyhIKh6BcObmTiaJ8wudPWcOM4exdYJC8S8DGRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfGWPrGXosnUF3kyPIXVBsHLR\nsEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCIcpSn9+0xjylMayIIs5r3cGd6mw9TtPxZvU+Lp6pJ4CICrbzTH4cbbP\nBZJxVQXdTLVret3/JLTGMXW0inxJoBAj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAaiHCSbatyCzrV/7sLYi8SRYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI4MjdkZjAtNmRhNS00ODhmLTliYzMtYmU5N2IwM2FlOTkyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTIyZmUyNjQtMDU5Ny00NDhiLTkwOTgtMWZmYzc5MGNm\nNDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETJhQtYg+xlcWbO5I+jVwejFD\nGE4SMQ127jpxhKH5TaXWXas3MdZRz6YuFoVNc+EvLCno2ynEWsM0zQUOreivz6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpxIm/mE1V/EFyEC89CGQz/ueNKgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgchXU6QgY\nZTwnoWneI3EsCiLAPoOopTvrV7tib00fB4UCIAbQ765u3E0pdr9a/PQi3Utc9KTv\naPhVl+4jt6GsuLqb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6894", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6894` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcEXTC/F8d1iIp6TBe0lI3o6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhMjNkN2I4LWViMzctNDUwMy1hMWU0LTVkNWRhNDM0MGUwYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODM5Njc1YmItZGE3\nNi00MjM1LTliZWYtMTAyMGY0OGNjOTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEczdH5dPgzXoc5yDN8gxQ3vHSrItFjSrRkbroptp2vi+cNppCUOW1iap1juTg\ng/eO3IfmeyyDucRQWE+BQndreaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFapxBT6YvYdMyNtO6Fa75zhesdmMB8GA1UdIwQY\nMBaAFHg0ghk4eKGPQ8jRviYSoLwiC+gcMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBU0OdgltIVfIL7GSX5jZYnTpVxJj+MItST\nSQz+ugt/IQIhAIgxQRnqFXZ63jvmYtRqT3pXCxarKEaBzTPaBXO0EaNt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV6M1zwbl75T3SojfZAY+qy0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTIzZDdiOC1lYjM3LTQ1MDMtYTFlNC01ZDVkYTQzNDBlMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARY+zMlNwKjqOjXpGkX2M5thyxl2YJFZQvrpsWfPsBY1qCI\nc8+23+LyU2iWaYX9zIuiK0zSUTLYO0h8KKRK0aZWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeDSCGTh4oY9DyNG+JhKgvCIL\n6BwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMNZmAnTIm3qXMuixXgllVDEJl5o1uqzmpqAptAZNYJwAiAMolunOQN4\nyBD9nfeu0hvfhYjzFmH/EOFQFZ5hxRBYTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXYa3kBAoTrm7UUIpkDFRlxfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODM5Njc1YmItZGE3Ni00MjM1LTliZWYtMTAyMGY0OGNjOTBmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDU2MDU2NDctNTlmOS00MmNkLTgyZGEtZTg3NmU0M2Fl\nNTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERgQWm9skCtPJYkg6FHlp3MOk\nDHWOBUBAi5oPZ70KDCGLumDvadqHm/fJzA0/Yaq4Fg+zf4tc/3Ah5EyA7h2vUaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVqnEFPpi9h0zI207oVrvnOF6x2YwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKiHHu1T\nae0nudKuTaOluFDaZjwSmrHsMhmXP2xZWW2qAiAEbm3pKJEbQ7kpMrfM4Ru0Zh2w\nztPbzzJ7R+KN3UCKCg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6895", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6895` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWRTH5gZ65Vfv/FC5tGztQdRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzZWExZWJiLTliNzAtNDczMi1iMzUwLTE1NDE2MzMwNTVjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc3ZjBkOWYtYjM0\nYS00MzJlLTkyZTYtYzM3MjIyZmNhMzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2XmI/ZGg9sn1R674aurXcs7ZFxr+ANZpS41M/HQqMA6JfvNPyErqCni5XZ/U\nrcI66xUhHq19Muxv5AWxJhvPd6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSSS8gyZ3TTu+JYlr5vsFzR5HbsPTAfBgNVHSME\nGDAWgBSt7ppJsp5uyaf98TuG+xNx/pYrRDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFRBLRIHmISLX1y37J+CcHd0rMK577UB\nbuYLJF8QbwbXAiEAy5Y9wo+bFdQnZb9UsKUyoCznqx6yGU6pcu1qZ1MePfA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbDzvf/61XJglPqDUJmeb2yyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2VhMWViYi05YjcwLTQ3MzItYjM1MC0xNTQxNjMzMDU1YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREMbymofIK2KKDRlTmHhWWQH0sYPpztkvzszqOjJTrSG/q\ne3iqIPKp0G+Y6WdNABVnqtPiu0UP0Y4BcVY8GWkQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUre6aSbKebsmn/fE7hvsTcf6W\nK0QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKxzynRnGYjU2S6hZo0EFZ+WZCiCFvAZ1KFEqT63cDewAiEA99RfWDBg\n7KsydXGMnMEngLSeKrw0yQKxZ2pQfzdwHV8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZQRFqoQv+u9BT2I7U+1mQvNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc3ZjBkOWYtYjM0YS00MzJlLTkyZTYtYzM3MjIyZmNhMzBlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzllMWZmMzYtNGI1Zi00ZDAyLWJhMmItZjVjZjZiN2E2\nNTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkRaxiL+YpnE692InhE9e7+5C\nDNSoShntsRxQcAxvKRHxpM6rh6kV78p6IP8XOyKir3bq2x9W5clUwrmMYGFa2qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkkvIMmd007viWJa+b7Bc0eR27D0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAKRHMNSu\njNB6aJl0cIgQW7/I/LsRsUpFrrm65ld6rqqsAiEAwYfnerV9H2I6Jplkes9eKFjk\nsoqOMMPIwzjVOpAqZHI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6896", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6896` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAdA42ze7z9Sg9yJayCuNfPx+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwMjY4ZDgyLTZjZTYtNDEyZi1iN2YyLWQwZTliZDAwYjIwNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI0ZjZhOWMtNWIz\nMy00ZjdhLTg2ZWEtMmIyMDJiYTRmZjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyNQyV/rvdDGw42zbbUE19uFLLa7WKIzRD2UQxEpGCV2dyXXwJCrt4iPxKWjk\n2dIp1OQ7VrrfqzP38DxAag70E6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU33NCG1Jbm85HLP8aMHHACIZQXTYwHwYDVR0j\nBBgwFoAU0EyF3Vw6H3IKMmt+i/RBPaeY6XkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA1R4hoPTK38k7\nyrZR8jJFsT5jFKhilwljX/x/Evv3ezYCIQD5wtgcEDRAE1vanXLiSpboDyZz7uRR\n7C6HVk+LyCibtg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdi13Ii2Udctk0gTdp5Xf75BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDI2OGQ4Mi02Y2U2LTQxMmYtYjdmMi1kMGU5YmQwMGIyMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHJQgp3daDLqQU+NCnyG1m7IjsUyxCmVN22jck2Q/Bvw6i\nela0x3wW3BkKf7ONQ2ULgzgFKaxOtm2PvxC3INDwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0EyF3Vw6H3IKMmt+i/RBPaeY\n6XkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI0ZfIgTlUw8SDwhttpiv4j2FL86T3+tNfJcqmMB6V1lAiEAy/5ThwpO\n2jrt0SOam/2shHs7bnKZ9V/mKyFwsHXNs+c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAa3fe8gOORNi6rvKM5ryiDiYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI0ZjZhOWMtNWIzMy00ZjdhLTg2ZWEtMmIyMDJiYTRmZjA0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDdmMGFkNGEtYzU5OS00Mjc2LWE4YjUtMjNkNzhkMWU5\nOTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdXvKFTHoiKOZAO3vdxj7jPQS\n10KaeEQMw1whCAaUpie3qAJJDNqbYT9uY3N995y5gzUm/CTbF7ExComVmtFC/6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU33NCG1Jbm85HLP8aMHHACIZQXTYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgThV6DsTG\niwTIQ2DyuxlNtqvOHRmJg/RWzfoioFvdxdcCIHRSn05qQxzoMOaJ3v4JlnsTJxfk\nG40cO2uBvFwuQ8Zm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6897", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6897` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWL5i4jPWNtbpkNxe/EGJLt3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxNzA2YmQyLWVhZjMtNGIwOC05MTRiLWQzMGYyOTQ0MTkwMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzExNTNmNmMtMDI1\nNy00ZTVhLWIzNjQtZGI3MWQyZGY2Y2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdTYLIvbyC0AnC5uI32ABdpgzx2aXiJmN79+D/HUVcFKOGGyLM2lDnPPqKBFr\nVd/TL0w46HaVvwgdnqnh57aS66OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDlvj0IDyyQu60RbhJ1qzMyI3cNwwHwYDVR0j\nBBgwFoAU9a8z20m66NBr5sm7whVBRxungtswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAmpk9jUI/UPe7\nLh1dqrebNETB8TaYxVZLJnwTuHRgCboCIEYZE2PVAcf+fZ6+4/isztx9Uj32gqQv\nJ+ZlnHvPEgmS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX6/VKhlT8X+Jkk7ayoXhrRUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTcwNmJkMi1lYWYzLTRiMDgtOTE0Yi1kMzBmMjk0NDE5MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyw7O3Er2OMq8PmV1vWV/GxB9TZY+vFm7fzmIpKNjz+Zck\nbluGMogUIdxdSkg4OApowtDGlw8sN7v1/aK5Sso7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9a8z20m66NBr5sm7whVBRxun\ngtswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMoBqO/Fdc1zKloItSJQJlN0KuPtkxwJ+R6/1OLx3TU8AiEA7bI3Dvyz\nYe2IurCxz7/JoV4rabIKsltwUQdzM6XUrO8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAR3rApRnxZQDuZUsUEogV5qNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzExNTNmNmMtMDI1Ny00ZTVhLWIzNjQtZGI3MWQyZGY2Y2UxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGE2M2JmYzktN2YwYS00MTBmLThhNTEtYTkxODg4ZjVm\nNmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUqD1zcxWXwYxRsdd4vRzbtQM\nuH4M8IdBRf3ZKVMC0h0f9r0cec2Bsc9g4y+m/Z+adUi0j2gkLi65+RGjv4vJQqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDlvj0IDyyQu60RbhJ1qzMyI3cNwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgVvgzhu0V\nBE1NLuo2wnfiSmR256UbTdCLf+qhKSPFqygCID7uhEpossNBeEOM/75J22Vwf3+s\nZ7CxXhWxnl09zmOt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6898", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6898` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAYIW5KDRyhwEa2tC9E+Ks3P5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNTU4Y2M0LWZkNTItNDJmYy1hMmMzLTg0MTJmMzcxMGY4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNhZGJkNDYtZjBh\nZC00M2U2LWE2NDUtZjZmMDA3ZDllZDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErSix+e261+YtRPiB02zIqnwNGmY6G2X9mU8Jt63EHXinK3ka91jUkvaAlAsa\nrZQd+DGpClhnm43+pukcEOBZyqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvc+LnAWEFxeycnp1aTZFhwlSzbkwHwYDVR0j\nBBgwFoAUM7By3KigsCsuopRx7OO3PXmqeo4wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAh3yR4tnK0movQpXtrYLU\n72E4LlF0pAr+KRf7vF6uRRECIQC8hFSJ9//GcaoWdIYCyyeMljxAfOmXdFvtwn8S\nOF9oEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb7yT+2yPeyK9UhdvNNt7DhbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDU1OGNjNC1mZDUyLTQyZmMtYTJjMy04NDEyZjM3MTBmODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnklETJQF5Vt1UCat78T/HES0MbWBM6NIpcgBjzExBsHBh\nUjfPCzjYIVLdE/nO5HA1lKpvSg1coP/89P54biXJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM7By3KigsCsuopRx7OO3PXmq\neo4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgREpwdv1XXCmg37OQwPOE+QhXcnAjL7MaI6zJw56j+F8CIQDcNcKhllaE\nzSlr97BmnjXuUMppygDfL9iwvG/eJZDhrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYOgcKPDTU/CG76i3U3j+nYkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNhZGJkNDYtZjBhZC00M2U2LWE2NDUtZjZmMDA3ZDllZDAwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTVhODA3OGEtYmUwMy00OTkzLWI5OWQtNTkwNzNiNGRj\nMTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZNVBjPlzWxhlAtfPKibR8xXz\nlcUkurUjdu/7EEYej/QueHc07thdoSN+TVA55emlvRY2yIAvsNxg3SOFnCr9YaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvc+LnAWEFxeycnp1aTZFhwlSzbkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhANUcyeMV\nuKgAHuOUdm++kKW8L9n1gNHT3BOVg/T/rYzXAiA9Y4hmB3zSUjwdzfI5hGetWE+M\nJhzCDWCQFtT41buCKA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6899", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6899` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAblD+F6j5qMswp7l0fXbgtG0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzZjA4MTFkLTFkMGMtNDE5MS05ZTZjLTMwYzU0NTYyNWY2ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDUwYjE1MmItY2U3\nOS00MjIwLTk0Y2QtZjEwZTI2MGFkYjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuSL+s5yktzW/ajp4pwpvlUuYk01sogFyYfyjkyeC7YvLFb7R05h9beNbDHjy\nl9KcW/UeaQub/oNzET2jEcNeoqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI+qjPna8PzhzyWCyuJ0wzc8nUsowHwYDVR0j\nBBgwFoAU2REjsVOJPmTPR5V2zEcI3FjpQ/0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAly3h\nQV1FW07jdRTgf2XlPqEJfhnT1HXT2i7HAQMxJpMCIEEfXiILM1a1xoHfwxPoz3Gh\nU6ez2OyJ7N8oelrSmp6V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdnmOyKcwCdNhyyjw6kNuWvkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2YwODExZC0xZDBjLTQxOTEtOWU2Yy0zMGM1NDU2MjVmNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROBisuFRL2qu5Oxp03ocNrvnihiR64oZV5xcpmHCz096fb\nISAPMkhwOf5CwC/jgUJWJrYSYCv7LytjLy/0HlUko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2REjsVOJPmTPR5V2zEcI3Fjp\nQ/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfcWc+CM8CZA9ZzTT194Ljt6Qy87Nvtw+OAztCqG+YzACIQDsSgd4V15H\n+XtLesrXgL7bgsGUaqaGfwKPQQ7u7a2MXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAThQXUZ9jxvuH2pnaBfv6BXCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDUwYjE1MmItY2U3OS00MjIwLTk0Y2QtZjEwZTI2MGFkYjkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODc5ZDkzZmMtNzUyYy00ODU2LTkwNTMtNTkzZDY2Njc0\nM2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqvZjdlsJZuzEPa8wKidEEilw\n2/7bUzFjr5tVn0eFHzrxs0dn944So1d7mcfihmU/4LKR+3p2KuwE1QqsaGyeIKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUI+qjPna8PzhzyWCyuJ0wzc8nUsowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgM2JNZdUt\n9k7zTCLLx7RdblISibC1OkCbM0VYMnC7c/MCIQC8eP+vUZrJN+zqY2ME/oam+zHH\n5KZgOWuvksKr7eUDBQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6900", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6900` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAZ8jeVzwi7u3bxd6PDSYqIaDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1MjMwYWI3LTFhMjQtNDI5ZC1iZjgxLTMzM2UxOGFkYzI1YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE1MjUwNjctNmUx\nMi00YzY0LThiMjktNDY0Mzc3NWZhMjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXiw9VwqjAem3dQ5lcSEWsTU8lL35PGHA+vyV/9WBWyseERInVFB2PEbb4Ktp\npdppPbZ/zSviYD4uSTPaqOS926OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk6rzu+w2qfO5CP5HZf4dFFfp9KswHwYDVR0j\nBBgwFoAUlrS04yHIgpkiBWmxNE/MOmgvb5kwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA4LcE\n6LYqXyy66r5McXjS6cvpoEJiUXXT3ILeLSxtzDkCIGqIRKKlCgDoy+8OECujsIN/\nlH+WvgviLotFRv4Vj3Hf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU9QaInGclYyAMHojRR34XOYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTIzMGFiNy0xYTI0LTQyOWQtYmY4MS0zMzNlMThhZGMyNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQ3rRYRp2BNAQzoBQVoIb+MFfXAhWIyVYaajtA/kpC58hy\nTzsw+yUAzKeqyjSrRA1Mx7uNlO7UxDFA0Mz4Cyv1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlrS04yHIgpkiBWmxNE/MOmgv\nb5kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMvdPlHidmCy4n1eeAu4puq9TRutnAbvFuXiMAvtGRiJAiEAm7/OEvqn\nNYIYNlK0jhiaVTsj5VvwdtmwSpIC0272mCE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAS/hOfzQkYSPvAiuuXiopz4dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE1MjUwNjctNmUxMi00YzY0LThiMjktNDY0Mzc3NWZhMjQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWRiODFiMmMtZTg2NS00M2JlLWEwNDMtM2Q5NGM2YzBi\nOWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5R1PnSnNbLVUCfm2mSFjQq6x\ncUj7ZO/CXalBZ17pborChE9xRA1hDzwzBMArbr1RveV2/DnVRyEcYWbfqYj8CaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUk6rzu+w2qfO5CP5HZf4dFFfp9KswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJq0SquA\nC3l/cdSzQlD0bMIbnQQklXMHVfakulutdtBSAiA2ULcTdopNqNPZ/FBhCAI6Dsog\nrqkg31qnJvhVgKWdeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6901", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6901` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISATNKExv3RxBpfZ+JQwpehkowMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiOTJlYzcyLWVjODgtNDU4Yy05ZGViLWUxMDNhNDcxZTZhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY2NGM1YmEtMGI1\nOS00NGQ3LWI5ZWYtYzU2MzhmNjc0YTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJOiLHaTV+c/LJvc4WbV7DL1oiwFj/FL+J5Y1rVAZsbaiK9ANTH8R7CkBMvmW\nhhlmDJPeLdS/9OtpcZQBzpuQxqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHCmgu/NK64v/2p2h6jQiRUkqchZMB8GA1UdIwQY\nMBaAFKPY/3jeqmwKNdFm9pltNBdqN/b4MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBOlAOAcLVNs/D5gh1jrwKmTjcDjuQaCF7B\n1txaU+pvZgIge34F1JncnBEh+19cUj5St3V09bIsMXilm2ha/bhtZlU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYCnJE/e5FcTHvVZwMxkxLCSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjkyZWM3Mi1lYzg4LTQ1OGMtOWRlYi1lMTAzYTQ3MWU2YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcbdwLDkczP4MFIwJA0kgfpEJ8WrqBB7DIiJdJzotDS2W1\nFIpeeUOb4KlJ6sMwbXVLOruJOVUqoHGdbg4WfWy0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo9j/eN6qbAo10Wb2mW00F2o3\n9vgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPnGvXvbDeEeQlzT1RLIo7cXOcxtZ9l0fG4iRu07HvYkAiAiq1sOQbfF\npnT8NfCwaU9kdSCKnkEA7aS7U1/xEI6Y0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAaRent9x/LstG9ivUccIQWngMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY2NGM1YmEtMGI1OS00NGQ3LWI5ZWYtYzU2MzhmNjc0YTJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmM0M2VlMzYtN2YxNC00NzYyLThhYmMtNzcyYTFmOTBh\nNjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKaDr5ZcnRgFM+MH4yZ4BySin\nGlNNv10583jTUR3TYvEa2FYBPyR1t+SsAwaHm/o/yn4U3GUifzm5pGROGl/8ZaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcKaC780rri//anaHqNCJFSSpyFkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAL5zJNEF\nysRuUoU24mbvNJ61KnZDXpJiXE7IdY9M1We/AiEA9zZFDRmjVOp3/zAYFWOaPTyy\nNRlbPHkvShkeeeYnk7c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6902", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6902` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAc6eMJB9XH0kFj0j9HSLqy0OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyMzAxNjYwLWVhMzYtNDE0YS1hNGFkLTI5NDRhYTFjODM2NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQyMTU3MjEtYmJj\nOC00Mzc5LTllZjctYjM5MGYxZmM3NDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEZEd8VfcvIyqJlJJoca7KEktaGngSWJtm+bhXdDcEq0woNU9CZ8557fcYbdH\nn3PxSgUlcC/utdDmycITdAIJv6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA74cLzxXMqvsi1jd6cWnNkehkYIwHwYDVR0j\nBBgwFoAUDSeTvS/E+SIZu2EOVJdXP5lRMoAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgTrHCaGKJaQV+\nml5xmLa0CdLNC+oDVIHpGUAnOY5DDjsCIGdYWXdJos+oIYBKyGhPcfB7lf1E71SF\nImPNQ9GPxSOL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdlqMZqeKEhpF4VsnnSagmzaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjMwMTY2MC1lYTM2LTQxNGEtYTRhZC0yOTQ0YWExYzgzNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0eYE5eb5BGN3hrdBHVrwXSKrvKG9qDuTMlTsSW60ag8Vj\n+Zo819+hjafrp/clJ1zeH+BMtR8CrvskAN+DbLFPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDSeTvS/E+SIZu2EOVJdXP5lR\nMoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeNcIyISxc6cQ96XN68TZIx4XyJAp0YBd+gl3OGOLxwcCIE1xzg0vbMmD\nRlOcGiC2Q3iPG93pwnDUdmBXwGT2UFjW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAaItXR6IlRifbMER4fN+REVwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQyMTU3MjEtYmJjOC00Mzc5LTllZjctYjM5MGYxZmM3NDVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjc1ZjZhYzYtNmJlYy00ODc0LThlMzAtYTBjMThmMzE1\nNzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV9uyMfK8IPLs0mpZg2RH5N8P\nHL1I0Ct80RNLJCJdql7/9hqVM1/xO2N0Zy3xFt0yEvvtpZpDEkfoAkMpKTMNu6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUA74cLzxXMqvsi1jd6cWnNkehkYIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgcS3whxh3\noqnh7Rdsh2sRiRsXxalO5kz3lu37IpiMEOQCIGxYC78LYG+Vzx7DPAcbEjITp6XP\nZGh0y4vgpsHOwb8T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6903", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6903` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAUYYPIGC+Pc0OgFFvMWRNiVMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZjEyZGQ2LTBkYjEtNDE1Yy05ZDFmLTkzMTk1MjdiNmU0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzI1MGJiZjItMDE4\nMC00Njc0LTkyYmQtYzMzNGUxMTE3NWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYbDpU+vbfqJdpJ4S1sVZ2QX87F9WZw+niJmdiazTYp2+GFCNHsvh2lLFHYvX\nz/SjnSHOQCHoqRTjhQm0J6WhV6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn+Ppe+NNpAEe6yLQZRAyKWdpHsMwHwYDVR0j\nBBgwFoAUIHJb/i3xEfgTcfIvF3uQZS3qYe0wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgcF00aj5QezDm\npqjBoDcZxPAIUMjniSlwAPewBOhCz54CIA/bNur7bddw6WNsVfTBGldBaK9o4AOE\nxmU+e5qE2AiE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcpUdH+cw3vZDuVmqnMrylN4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWYxMmRkNi0wZGIxLTQxNWMtOWQxZi05MzE5NTI3YjZlNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASb3H3Dx4DEIupoJcQdCUj3O4T6dvVakeTkGlmAuUSRkRLy\n40rJ/I3yP6pbc43hQVvMnYFRKKhiBGfdPcm3ZIJbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIHJb/i3xEfgTcfIvF3uQZS3q\nYe0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIIv9XqnbpqLbfBnlkw+C5G71IEtvmHbkiYuKpWInlKmAiEAjLlnXLK8\nPfClrmEnSScFzJc0RV9HglTUeV50O7hw3V8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQHtJKFpsY6dkr0ZJeGMMLZwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzI1MGJiZjItMDE4MC00Njc0LTkyYmQtYzMzNGUxMTE3NWVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODM3MDdhNWMtN2Y5MC00NGY4LWJjYjgtOTY3ODY1YzNh\nYzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErpE82rQ3US7lz71wJ6CPLEzG\n382ifxXo7HdWUjPyktKJPnXwFsy/lRGXFED2ZAgUDwVQrd12F3RQlsu+q16WbaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn+Ppe+NNpAEe6yLQZRAyKWdpHsMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgNwhjWmXo\nRC99ktrU/BFjhHRTOGS39YnQEu+efKsN9xkCIBl64PhMY9fUu9UapHTTZzYLknS0\nBl7HQaQ9DOFwKkJS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6904", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6904` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAV0gXZjXFLmYwWS72PNuuRG9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyYWIyMWU0LWVmMzctNDFlZC1iNDBkLWRlMDNjNzVjNjI3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJlMWY2ZTktZmI4\nNS00YjU4LWI0MWUtOTQxOTViOWE1OWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiTanA9/MelAFqvy5NFBduZ+tunXmOxgrRWLXnr5esc/mmzZTlEwrreu7IVed\nK9TzSW6kx3owfmZ/AP9k32hVvaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW/Ra/nCJmrSCRUDxWraQU8Db2GIwHwYDVR0j\nBBgwFoAUlUlKkUGEksTdwVbwS2qHcklNYwQwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDSacg06tow\n1jtqCt7CbnvdOFzhVNoGqUNelZ7sIhSxnAIgSp/BI0XJ2JzB1tbWq1oGvL7QeMJp\nPtWyqY9Fv4AoLv4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV8xAtMn3BA2z3/LO5JW6ATqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmFiMjFlNC1lZjM3LTQxZWQtYjQwZC1kZTAzYzc1YzYyNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOz2X3EAMIhsQ/n+pak6cBe01Ume0dHhyNfKaOyJUJE9V+\nt7eFRC3v5F1A61ZmgK8yGf/FxmYBkXeZpbixnhAXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlUlKkUGEksTdwVbwS2qHcklN\nYwQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXPMVavt5JN7yq79XTWn98mKRMIE+Bnxajhm5LqjZoM8CIQC4rjjqpoGz\ng5COXFV7YJoii4a0S9Tdv/ctIqxfLiAY1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZTM8PYfI4dX0rvFloM1PtqyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJlMWY2ZTktZmI4NS00YjU4LWI0MWUtOTQxOTViOWE1OWU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjc1MjYwN2UtNjdlNC00MzdmLTgwNWMtOTgzZjM4MGJl\nYmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETWFBMwaxVikXa/jIajIq1XHE\ndYzZEX6jD942HBKq6mCwJJGLdRMG6lG4uxMrHoftpWHIsnmDJzmVhlK18u9vgKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUW/Ra/nCJmrSCRUDxWraQU8Db2GIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgVHdSr/IL\nd0MYqhmFqgZTPgvre1APfQf6xJuJkuaR+V4CIQDCWwHYSxg+uF1brDzx17wQPo29\nTbooa2Zt0cMF/0xfAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6905", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6905` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQiNdLvl6SR4A0s+q7buztKyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNDljZDRkLTk4NjMtNDY4NS04MTQ0LTAyZDdjNzY5ZDgwYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBkZGY3ZmUtZDE4\nMC00OTk2LWJhZTUtYjYzMDNlZGJkMGM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiojgI+EJZhHZD81WeePgU9I6CAKZjAomhma0XR2xzHgfK+nI8tud74BW+5AW\nbwjpsEUJchSv52KdzVVWnx3uEKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/E6iZp1IKYC66ZxlKIbZ7rZCgE0wHwYDVR0j\nBBgwFoAUqzHjS8lmY0xVpztGIhhDvorL6u8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDhl/ys2YJ09xvoLIhhi8XCiUDbqyieYTpPyChkVS2fjAiAlUytCcw/cuCQ3\nDTAR7Drbj7nE5Cx9HTOWtjQm94mJ3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATAyu4uvuXAwSRdEOhX+euJNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjQ5Y2Q0ZC05ODYzLTQ2ODUtODE0NC0wMmQ3Yzc2OWQ4MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk7a2BO1NRNneV14mA/zZYBD6rZE7BUJ4lZBZccaMS8xPj\nHi6Uoc2vKDdaheQ9FKF16Fq+Ax2y+aPDTUCixLDko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqzHjS8lmY0xVpztGIhhDvorL\n6u8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUYrmPeMqGp3iM3Ne08ivnpxjv3Co+kFUzFZEKVftgrYCIQCvikiJWJ08\nwRBuEMQnpxM0o1ru/Eg2TaJVtFhmAbHOdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAaCjVY6mutOtn8pOfLHb0ji/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBkZGY3ZmUtZDE4MC00OTk2LWJhZTUtYjYzMDNlZGJkMGM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmUwN2IyZTQtYTJhNS00MWQyLTkzNjgtMmUyYzVhZTQ3\nMGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmdwC5zKtrYwGnnFJb8KD8gnu\ng02X/pms0C6cmXHGt00oCUvAeWuh4fp83TX6bC020oHaFSe0iF2j2KYzbq9WH6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/E6iZp1IKYC66ZxlKIbZ7rZCgE0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhANxeBmd3\nQEKkwQ8JiMG+BVwbWjvOcvuO34VfpvwjWn+zAiEA+VZwoVH6xOa98QHzsMXEmLIv\n7q2ISKmxt5Vy5D/7ozY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6906", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6906` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZHtHpOIHENBPF29QN8CojsSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyYzU2NjM0LTBiMWUtNDA4YS04ODFiLWE0NmY4YjVjY2JiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZlZDYxMTYtODZm\nOS00N2IzLTk4ZWItZDI1OTM4YTA3MDUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEehxS74ozOhiZwCobDiqDh7Ve14DwsgqwbkaN1L6dk75gU+AdeFqrGsrghJe3\nDjlKahaqr0dx8vRFqfSb67+cFKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYwRqGfy1xF/fYEh7uN39J6waieQwHwYDVR0j\nBBgwFoAU+Sawr/yttLysvDSVsuTlklhICj8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCRm3Xu9D+hAmRxIjROHmZgv/CpJbsYXXGTxUJmagMkmwIgPzxBfzRaNC1z\n350FeHtcgxZA9zWH4OG64hiAJ5FtmqI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWXeYfooRQ+MXU+Ka48NfQaQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmM1NjYzNC0wYjFlLTQwOGEtODgxYi1hNDZmOGI1Y2NiYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdf4lCApJ03s25GmabW5OOwjQyXTQXEbzccvH9+p7Jlv1h\nVp3Uefhgzhp3JwEV2m8KHnwfcWfqC+w6ZQcAwOc7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Sawr/yttLysvDSVsuTlklhI\nCj8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE6I8UGYB2e6Ag4bD35c3X1OpdB1RYn2LvOoIzaVgBLwCIQCdkjUM9wgd\nSq6AKARTZUqIco3mcJHGbzQtiViYHysvWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARW1LWozrJt/GdilUuN0sSPYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZlZDYxMTYtODZmOS00N2IzLTk4ZWItZDI1OTM4YTA3MDUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTNjZjBkM2YtNThiNi00NWUyLTlkNmItMDUzYjg1ZWIy\nYTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/jJlZghU6V5L4EDXME/rT7bo\nozWzhO96q7xXzEg68j71wF1ofytfIR9/Lv+msmD+9LJTyChIlAURaJuTKGmzeaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYwRqGfy1xF/fYEh7uN39J6waieQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgZEhE1CCJ\nN8sr8GKObaTfNIaaLZ5onvcKEOu7gO7v574CIQCC6zQy6yK7rjh9Ib0n/mkdJjhN\nmxGKjd0SUFSG+pr44g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6907", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6907` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAVGrfhkdq/XobJv0A8ep/ImfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3OTQ3ZTViLTA3NDgtNGIxYS1iZmI3LTAwOWMyMjk2YTIzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYwNWZmMzktMTI1\nNi00ZDQ3LTg1N2MtYTYyYWE3YTQxOGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECH4MRNGm7Hx2IRBXPMHeRV8mZmksDzLv06GY+VcB3DbSXH7B02EvVmH5BBsS\nwjaivaAGfybRumylAbhf8gBxUqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTSVZdOfdKwAxEsOQipHWOfQkJXYwHwYDVR0j\nBBgwFoAU895DBWfz1rPpxeJRy73r1/G4Mx0wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAWp\nrdhlO1aypFFPOqYRY/mc9mGbyEwXc9S9K2sifum4AiAl5daP72eS87xpklMsmX/y\nqswz/mB4gLGjicp7lSn2qg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARUrlN0J39Fs0mGe3G/sZxDTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzk0N2U1Yi0wNzQ4LTRiMWEtYmZiNy0wMDljMjI5NmEyM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgKZOz//NXSLOv9Jul2GBHL0+zWHvBJz0gtG6f+gu4RIUI\n4qb18EFZQKVl3+A/+8vUalABe/p8zK7cwC5vjUgQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU895DBWfz1rPpxeJRy73r1/G4\nMx0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJKzLF6VZYEOUaKRcWpRZ87zfDS9GW3zdvuOW124C8pTAiBLhqLaXI3w\ng28aooO9AMoaeCbI7jFqlpc03neYbHpKVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAUcEPW+TaFGn0p553n7gRztkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYwNWZmMzktMTI1Ni00ZDQ3LTg1N2MtYTYyYWE3YTQxOGZjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWI5MmEyZTUtZjVmMy00NjI0LWJhNTctYzZkZTU0Yzg3\nZjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg/zccce1N7AZIGfETW/VSS/+\nrqpKZDPUBtFmo02dVLgwrEnIQFb65mR8xVGAZqQbdBbfPsoB6WDST4C3lWYGq6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTSVZdOfdKwAxEsOQipHWOfQkJXYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgM2aUdqAc\nyOBOwxuYhGrokWM0yIXnF5vGgt1uEn7z5OsCIHcZ3J7vqWJ6AHqdZGrGqzjTV2ER\n70YNGFEmzjW2TeSZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6908", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6908` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAQeG3useZFYmyniasXRvUWk9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMzIyZDVjLTUzYmUtNDMxOS04MmQxLTY2MTQ0NDcyZGY5MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNhZDU2ZWYtMWEw\nYy00ZDQ4LTkxOTMtNzcxODQ4YWY4NmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr1Na0AipiuTpUY0bR6xhCgr8Mv/D2dhoA37qDdMXy1EeerrpG3Ou7Y1KYxQA\nEIxiwrtNyqmaQE8MVqKXdyGSUKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1xDJjWOSuHBxdmOG/ZNZ7FYFjSUwHwYDVR0j\nBBgwFoAU/stdbJxa+IQcBLPXXoKdm8+lJoowOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCpAWln4qDC+3Xthy9iCQyiKQ04UQz/NPju5UWfWSmDmgIhAJE3\nx7hPgtdS1Hluqly16aF8fjMiiJvikZofftFvKPtU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATy2BbWOXylHCVPGwaWS2kMhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTMyMmQ1Yy01M2JlLTQzMTktODJkMS02NjE0NDQ3MmRmOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWeHV/1sOBqTVbOK032wWcyuN3StWdRLPphsLwU5H3ZGIB\nU8UOInxPuDeeqYtzicF0rtkYrj7mpf+kYvtGf3tYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/stdbJxa+IQcBLPXXoKdm8+l\nJoowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXtvdvRZz+Fn1fpBb4Aw3H1HQo2qjeT85/JLjbrLN9hECIQCtz/m/A8pf\nGTiYy1a46WYhkamT97unPy2mmJ3taxM5Og==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZ2JUPd1S6DsWRXDRfnRxzHvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNhZDU2ZWYtMWEwYy00ZDQ4LTkxOTMtNzcxODQ4YWY4NmE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzM5YmUzZjUtYzRlNC00OGZjLWFiYjEtZmJjOTYxYWVm\nMTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+Cuc+zPgy4l3yIF3HzqVfpIO\nRGlikRFTOT2K9qLtfVqhyy4sNyCN3Eb24efyXcaAE77GlFSaUM5t6a7gVNaeYqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1xDJjWOSuHBxdmOG/ZNZ7FYFjSUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgREsiSkxi\nAtmHdm7xUOx4qBR1ZIrGO4fJxkNCTGcpGRwCIAmUDM4er60k0uzql1qzlfoWJsMv\nlZd/IlOmYflQ6MCm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6909", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6909` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYauHMODnMIQRf1Z0cTvbwWhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmNTBkZTYwLWE4ZmMtNDg4ZS1iNTlhLWY5ODYxZDY0NDljYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY3MjJhZmQtNmE0\nYy00ZGQzLWJiMDgtMDM0MzJjZGU4ZDE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjlyYupxTeaLrJNKSOytyhsjFCGV3s4ktBcGoexOEelTzrLP7n9kG5rG8RnaD\nsTEFM9HCiy3w+bhdyJ2NMuAyTKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO98JI39TLUFcfLfviu4piz4Vz7cwHwYDVR0j\nBBgwFoAUuyrtTFq2/zLFOp3fT+2labP42W8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIDdLFdUc3sKrfJB75cQWOFPKQt7pde2UTeUNYHxBhpFJAiEAwxXB\nw8n6a08Uu1R4B6+QKh5zwDsJMOcJxOkUMb/YZiI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWyY4uzmlbSsiJbv+HSmAXnlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjUwZGU2MC1hOGZjLTQ4OGUtYjU5YS1mOTg2MWQ2NDQ5Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3GDqVg4gSNByaleJgx6A+y1XUd+a9TTSfdUWvMKsdaJLL\nF6d4nK7udc9et8JC75Gj+jxYnVU+Oj2Rk+sDcfpKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuyrtTFq2/zLFOp3fT+2labP4\n2W8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDZTMMpTrDW+tmJlBGKkiWxcPRnaoVTZzpAxNQ+5huhACIQCPpt6mfJcv\nk3Ze0xxwpCIMRw6GTM7H7K5gY9BncqBTIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAc5kzmrI9G5sl9cnf3z6Wt1mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY3MjJhZmQtNmE0Yy00ZGQzLWJiMDgtMDM0MzJjZGU4ZDE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ZlNDA1ZjQtMTFjYy00NjM1LThmMjQtMGY5OWUyNzQ2\nYzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9uaQ49YfiRMH/UpiGy/Iq6dm\ny0nhxJnvppoDIMWVKmjehkeTIC6zBcqDHk/eu73vVA7iZ2BCSqP6TddyvQ+5WKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO98JI39TLUFcfLfviu4piz4Vz7cwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgBunt/nTP\nHp+jSyXYMKScUMkuGp1pXNpFR6hFKAuRhcsCIQCYS39DUuXFI3Q3gch8UMowPTiU\n0rneeOsawkfV5fV/5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6910", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6910` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAX20HP4wi9vFO3xTwoTlarlEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3YTE0ZTczLTE3MmEtNDU4NS1hYjQ1LWVlYjI5MzFlOTllYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE3MDdkZGItYzVh\nMy00ODAxLWJmODktOWY0Mjg1ZDEyNTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU2qpD7GOVFTs3sbngOAhV9nS/7qVhVolTmHWkvadJRfQJB0zxGD3BY1ljrpR\nEpWt/4Ad/gD05Ny1n3yN+RNXY6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJTOh4KgsO0aJ+JHYw4ce/L+aER9MB8GA1UdIwQY\nMBaAFErjESoaeEiiVSnBNICl5KFWaHrLMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAftGJ09ZTRsY+DtfeC2FA4ltMq/MDelJfl\nhmagETpbggIhAOYJ0wSwAcDw2FZKp/iEvN7lVhuCpZgVfEAz/ZX8lLhm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATPK26Fc3YfsouIHM8GDKjauMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2ExNGU3My0xNzJhLTQ1ODUtYWI0NS1lZWIyOTMxZTk5ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeYYarP90CeAU4y5ow2l0Oo2Kj8twUjZ5FR188JoV2jSII\nUOH1RmQ3U7nLpKa1vd2aNYaH8UW1EZRozymjnu+9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSuMRKhp4SKJVKcE0gKXkoVZo\nesswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOqZLjc2cUxxHaZN4ZMmv63DLoSOxWrzzrBIB3tl2YQAAiBnZ1FuEDM/\nvuYEfe2eEMEzCU2kL4bQw6vQ6wrbVgNfJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYArk5iCzmS6Sko8GPRpaZzdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE3MDdkZGItYzVhMy00ODAxLWJmODktOWY0Mjg1ZDEyNTNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTYzOTdhYTItYzlmMy00ZmVlLWFiODQtY2Q5OTRiNzgz\nMTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENMz49E0Vr4/DVZIwnuv9vi3P\n7ch8qMdouKYsXTtbI5v7fq4A1XiRS5ze1I31GTrf4JbBkmU4JgDpkBFx7zATZ6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlM6HgqCw7Ron4kdjDhx78v5oRH0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIR0cy8f\npq0HFO00wPejeayTak6RSaAdMOeXMvXEs42wAiEAnfvKEwn7A3tkoaoHUBy5CkVE\n4D+hjQn0fbYE1XrZP9k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6911", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6911` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVwvLi3405zYEyYZlGEtbHHqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NWZmNTY2LTE3MDEtNDFlZS04NGY0LWQwNDIyNTJhZTI0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQwYzIwNzAtZjE0\nZC00NDUzLWFhOWQtYTA0NGM2NzIxMThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1WWrUziDJL/GjDSkj6HR90yFuJkZb8nN8JjAl90RAiusTdbfNLxDmel1SUv3\nlepXvlYBAfGqq9Qq9h/flpz566OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYSOu2MQOeXFonWimy/zsfHrKbdQwHwYDVR0j\nBBgwFoAU4lomORj0ukq7c1mC8GG8Va5aJcYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgTyVg28ngKoVJ\nsO52mICLI9r3CqUOaLVgWu6cG/s4LF0CIQCgJrm40hBKFVHIQ0qMjEOrHNYpLbEr\neAP5apixqX82MQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARdgJ8GFF1QR49534YLXR2HYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjVmZjU2Ni0xNzAxLTQxZWUtODRmNC1kMDQyMjUyYWUyNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS83FdGnmtl1BC/xdjGXO+RXzmSjZk/MTO2jl9rymQxzy8I\nktLDdnmATalp4wq51/NwpkM/q4VnTELkdoKYIZ+Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4lomORj0ukq7c1mC8GG8Va5a\nJcYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGSADy3Eu5QSDIlsGwqxV3lDtbsb3f8F438oW2mLdm10CIQDYOyYKLkXR\nvHl7zLYYN0Y2U4XcyL8KbJN/hPok/+8mQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARM8I4AZ1a0acpndfLEra66vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQwYzIwNzAtZjE0ZC00NDUzLWFhOWQtYTA0NGM2NzIxMThlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzM5NmMyNGQtMTczMC00MTEzLWFiYWQtNTVjZjNjMDYx\nZThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8p5mjsj41JKCpVgyEDiUEBgj\nE9JrjwWuFaQsupTrbcCWRW6Xia+KCTG8A0/m6kfFbfFQnAwJksOmX8P0cMGrD6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYSOu2MQOeXFonWimy/zsfHrKbdQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIdLQpiJ\nit47Tu2DJ9UzEvqseRdt9WGTYXIkHMo6diPEAiAFHEezt0hLBBLvArWNdO3dFP0G\nVH/RbL2/AV1Fve8QOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6912", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6912` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQ6OF6YFojFqZcDYX/5yP4uHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNGRjNTUzLWIyOGMtNGM0My1hY2YxLWRlZDVjZjZmZTBlYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWY4YTQyMTAtNmJj\nYS00ZDIxLWI5YjEtNjFiODgwZTM0NThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEch3BYrrMbndhJ9I7d8obZyxqwDhnVI/FH9l8Kbol+n6xUjUoFGwdnQ7W/IP/\nizuogr6ijmoEcoCRy5+LQZek9KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr8rtZszUwcOrarzFpo03jgkpnLYwHwYDVR0j\nBBgwFoAU9PVcNK9zDUU/oH8Jpm8sprORJmIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMMoutVXXjCt\nC75d2rb3FIjbukx1AS7x41uszfEz2SJ4AiAhb4UHZunYQpGeIUpT04bE8YvCyJ6u\nVSt6dJx+zzHQCg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQq+8cZOxF8V49WIIMlK/TjeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTRkYzU1My1iMjhjLTRjNDMtYWNmMS1kZWQ1Y2Y2ZmUwZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd8vTJeTeXSnFmWSh2980YREJ7ogG6CLurHxVGS+FtUcOp\nY2Qv9xuYeGR+rKLqQ6gB7Ntuh2HivCvQ3r0pkxZDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9PVcNK9zDUU/oH8Jpm8sprOR\nJmIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOj8sqyrO/LdFANCznCThkJh8TjX2JE+pzRtA+XlV7LBAiEA7nIU3hHN\nuMjw0gka2YqtdSw8nqasY41oZxPcjPb7AWM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUskXlXhwMBVYgduWPKGJloJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWY4YTQyMTAtNmJjYS00ZDIxLWI5YjEtNjFiODgwZTM0NThiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTA5Y2UxYmEtOWNiNC00Mjc0LWE4ZjgtN2IzMGQ5OWQ2\nNzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwg6zpqIUuKcHhOxJQiAp0vbZ\nNwcDxicuQA6uYbpdQ2RdCujPwBZzxpxgOmhQf/pioDxgiNfFPYu0I6K/N7mVpqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUr8rtZszUwcOrarzFpo03jgkpnLYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgB3xgV4PI\nmC8uvwKoTvKy4v1JLGxzg3ZLGYGZei5j3dECIQDrNziB9t+a5xUvbJ+DdhnXjH/N\nvhH+qfHPcI0GfLEZ8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6913", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6913` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAT9rO3xpurzqs7tLqxxh8WdVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2Mzg1YWMxLWNiN2MtNDIxYi1hMTU5LWM4ZmQxN2Y2MmU0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmMxZDg2N2ItOWYy\nMC00YjgzLWJhMjctNDRhNDAzMjkyMGM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECzdV/b1IIB3WD6DKU1mgfbWRpJPUw9xgdvkifJ+1777zAB+IYzJP9Is0VJ5j\nxXrO3XsGgCdFiEHsFx8J+41UjaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUly7Z5J7bs3ma8BWQ8E3vGAE4ViIwHwYDVR0j\nBBgwFoAUGkaotKM5toNwu1AAJdeXoDLgcqowKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD074BICa2+\nb4U7SpRJaa71aFVg8n6MB4c+04mq1+hMwgIgFPKxHCDT7NFvtwVu1EQNkykAI4me\nz52N5PGuDRJAy60=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARv36L+mGnM9BsVg9gfq/iO8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjM4NWFjMS1jYjdjLTQyMWItYTE1OS1jOGZkMTdmNjJlNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAOOKnhKZ9t1HcSzDqJMxFnl4vwut3Vqh2Sip4E89MJUGM\nRBCZHMW7ucZxHlko9RzjQqAwe+nqQTkdcoOluPzGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGkaotKM5toNwu1AAJdeXoDLg\ncqowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN7SDpkX3w5Z+PnepRb/Wk3xBhqHPzBA7foPfXkYT6iXAiEAyPpsxuFQ\nXonGHx2jocGPuGfABfH03WG5PENsz+LJYkM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXvdqoak7C6ibS6+FSAK3qZMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmMxZDg2N2ItOWYyMC00YjgzLWJhMjctNDRhNDAzMjkyMGM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTljNzY2NDktMGEyNC00NmQ0LTk3ZWItNjRkYTI0MzUx\nZWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQOfbCUzRP7H8dBHxpT3rIIaw\nJImAHygPxmlG/Hx9Uzvi+kofkQhZnRQ44AsEFdzGX+ZkAy2ToLSBKprHzP8akKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUly7Z5J7bs3ma8BWQ8E3vGAE4ViIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgB2irqj4w\n+447+18/LXbbNWTRFrQO3Acp96SR3vFLu+0CIAlBUIiXjKMdiasnQaxQG+jRCWKS\nlFr2CEEpu2NqbVX5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6914", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6914` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAd6+aTiwPHRJxvYZeV8/ncw5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZjEwMDJmLWY2ZGUtNGUzZi05MmIxLTM1MGM1NDlmOWVkMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY3ZjM1M2UtNTM4\nMS00ZTZkLTliNjYtMzYxOTFiNzdmY2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESOJrCc6vvzO9Iffk6Jw5fiauxsBKG0kfs38hHZLyT1s6fqDCr9nWIw+iiQhb\nUEOERP40kmr4bBL32PYuzjy0FqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYwcDli5do86xy80pf5Br/B7Jd54wHwYDVR0j\nBBgwFoAUlcC96PgMg/BMpPGeDj8IHEX8GTswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC82GH13B817pkq43DfttpH3rbcZNvRrEMG2og0JsPbmQIhANgscrIzjShZ\no6xbBfxYc9VSndbKtdd3H1xs+z7lBp1r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ8/MpzKBYF+bzh96rJK1SR+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmYxMDAyZi1mNmRlLTRlM2YtOTJiMS0zNTBjNTQ5ZjllZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASD+jw7ROLuAeegxXj06ehlB10iyFJCwZzU9L+Wl8H4USwG\nC76S+U31mmUSJ7EE49mthw8ex5eNqWLo55q+Q7fko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlcC96PgMg/BMpPGeDj8IHEX8\nGTswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEop2oiMiBrNBXhBaGseWXNbNzD0HnYrHK9lfSmX/jHICIDC1NjHBgBUY\n5olFMLTtO3yL5nye9ahA2vC6IagOULPj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAceqRb0lZtDP/KJEnZXDC7lcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY3ZjM1M2UtNTM4MS00ZTZkLTliNjYtMzYxOTFiNzdmY2EyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmZmNjAwN2UtY2NhNy00ODcwLThhYTctY2JmYzRmODVh\nMTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEF/jdSRwzoZnch2BjEon1Zopd\n2GP/wQ8BM6MkbHhth93KxSiPkNKL/ydGTjs3/PU3SKBFSgIU6O9rk4qxx60OIKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYwcDli5do86xy80pf5Br/B7Jd54wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAM3Jd5of\najQji2RL0knqCwVSskHUrrRSbeyTLxYEVnM4AiEAjeXI73f7ujrRUVaoaPvLo7BL\n047TG/p12BCQrNdv11M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6915", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6915` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeefSGhl9/dMXED791jgRM82MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjZjMyODk4LTZkMjMtNGQzNy04YTQ0LTAxNjQ1N2E4YmY5NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThlYjM1MWQtNGU3\nMi00NjRlLTlhNzQtOWMyMDcwMzQ2ZTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEryJUvzMq8WN98nMuc7AvJApeAbrih6GkZW4MlI0lW6bgiB78ltf/VjdqD/dQ\n44gf+7BhMMuml6kVg+bFqfGvhaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuoZcsOsrNwkFeNQxPD15bMaiAsEwHwYDVR0j\nBBgwFoAUPz0Gu96Avj8flnJ9NfkJBXbW6oEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDEcaUcimiNNfi4hHrdyNuXwtp+Aq5vj9r07ok+x2q78AIgVEjMWX8LxEzg\nmO2FuOXIAiRtMP2Pn27z8zYOGqFkF7o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdukoFOonAgOG6vv5VqBjnhVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2YzMjg5OC02ZDIzLTRkMzctOGE0NC0wMTY0NTdhOGJmOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARX0xgs5aywXjMchMR+vp5ZLrl3CiLu3FZUrWGhb/spbZsD\nEkWHIoG6Hb1GXv0yKrwTp5ILrx07yQVXBsZ5uM5Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPz0Gu96Avj8flnJ9NfkJBXbW\n6oEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKbs/A4+V9V8nTLQP00g6NDvacli0tnA0YG8zWw/Yb4nAiEAi9vIqmRl\neZQGDtiTRfMOtRSoeg8X3yqTX+yQDhfLCWo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAQKRg/kpH/rt4L64xcGRUUihMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThlYjM1MWQtNGU3Mi00NjRlLTlhNzQtOWMyMDcwMzQ2ZTk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjIwOGVjOTQtY2M3MS00ZjIwLTk3ZDUtMzg2MmIwNWIz\nMmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3zVqWmUhcsTrfL/yU8OSCJDJ\nX23lEA1tLFksNIhGD/AG/RgwaKzHvuWjXp3D0ehc8KfBawUMbeV1XuAJkBshPqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuoZcsOsrNwkFeNQxPD15bMaiAsEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAINHPa4d\nOgQkRt0gxwC2pe7vZwE40snkSo5dK/nnSaKcAiBQRMKxw1HDCKj02R1Cn213Y1ZZ\np0GASDkuBqAJuSlKZg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6916", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6916` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAeAzgsszVjf6thWvD/VHfuW6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3ZDhjMWQwLTA3NmItNGRhYS1hZGJiLWRmYmU5ZThjNGU3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZhY2U1MzktMzkx\nYi00OGNlLWE1N2UtNDc2ZWRkYWU4NGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMCOMrriWGGvc5fNydjzDsDPCzoOoi3hCJ38Ighwz9rzEqQI6NPFLVuMtE/7K\n43PIzC+kNCZ/0XpLsbP7ljC7DKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJsbCMdUwFYLYx88AJ9e+RafGVTswHwYDVR0j\nBBgwFoAUgab0JF6E1hjXU6LvJYelS/3Hxl4wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIErD\nOwEXyp89fOBnGwN2a5jmXcHdcmnV7FGcUedBl8LwAiBLzZtjYYOcgYYN01Wcn3v3\nLzaiRr6NzthetotoO0Y+2g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbm2Ah+pGIOhBVTJVdgJo/t5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nN2Q4YzFkMC0wNzZiLTRkYWEtYWRiYi1kZmJlOWU4YzRlNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATF5134RVWTmgtzFDyBphdb6+NBGlq9EEAQuS9QUr63qsNE\nbH/MJ78tWgsAd6y1FIACmHUnIDSm6RBHfpPfHeMJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgab0JF6E1hjXU6LvJYelS/3H\nxl4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIXtYjQCLMTN+Mbir5rhe/JZmJm6p7DO8hA2NysquVw3AiEAg/cByOUp\n1uOxXVBvOjhbQSYwBsSo5dDyv+HjPzGXNqA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAWFJ1K8XscESEBOQrkNaYS1uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZhY2U1MzktMzkxYi00OGNlLWE1N2UtNDc2ZWRkYWU4NGJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQyYzVjYzctMmNkZS00ZjEzLWIzOTktNDczM2U1ODhh\nODBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVnBVKsA6TwRPbnoH0IMMXDfR\nuPjy8j5+kQtnuYpupO6YjCBmtdum9/egPcMaawU0NBzDyjABMjcVydmjTBgopKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJsbCMdUwFYLYx88AJ9e+RafGVTswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgZmnNO/B8\nqp9kIj7heu5FT3aM9lkjNxUejNWnVCbNqMECIDhAO+d5Q8qQXcznJTfuU/KSH5+9\nnOoRsiT1kLX2EGtk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6917", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6917` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcLZZbjRcYUvul5wr9cc5gNxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMGQ5ZTBiLTliOWItNDRlZS05NjY5LTc5NjA3MzdmZWZiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlmNDhiODYtNDM3\nMS00Yzk3LThlNWMtMjA0MDdlMTE4YTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjDpRGX/gF4dLAHlkorxj6QvuI6qfzQmQiJixn4hnBLEL4z5aSaTlMiM4yi8I\nB6paQN5Pi+AJafM9M5PNx8p1UaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrZgdF1NFhBoeo/9vW3CkClI6d5MwHwYDVR0j\nBBgwFoAUYaz31KT1LL1Mvn4anqQKdVLwQR8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIHD2+Uu1tEANu7YuXTcmaMJkDLteWnaienLFQO7YkhOxAiEAtu6o\nR15z+19ZJGfkFFUlDVgu1TmLkXPMBAFWMUHALD0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXHz39Wemnj74XqTrcnTE6zVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzBkOWUwYi05YjliLTQ0ZWUtOTY2OS03OTYwNzM3ZmVmYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASN67ZQBwCAeONDAj4f4eiwnX92o9sLwQU0Z0WdIpJk3Xeq\nE1cEeaNCipGHZX/TB3L+rfkCbMk1/sqn1vnDKc+9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYaz31KT1LL1Mvn4anqQKdVLw\nQR8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA6mfE+d8Ok7rtAdtFuKRvvGIdp9/l2j42JxaWoBzSXsCIQDTTjVdpDCu\n289htVU56sO6j6Ea1Ag2MlIlQgOYCJ+h1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdA9c5toAmRpcvs/lAUQz+l5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlmNDhiODYtNDM3MS00Yzk3LThlNWMtMjA0MDdlMTE4YTFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWEwYWU3YWItYzVkZC00YTA3LWE2ZTMtN2M0N2I2MmM2\nNmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEubcVC1WmZUdifOejAkhU/rdI\n8QLJf/ZCD3nfPNI8NkbHQ3OgMTMP7CTyARHEErN+pyh+0Q4JjIUCN40w8WFINqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrZgdF1NFhBoeo/9vW3CkClI6d5MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgEz53lSyY\no76Jo/sw+E5yZuHHiw/t8IdN2ADQu/Q/qbMCIQDwuQVUQaNxssJcoPAw/Qx88gUZ\nNKZVhpYdru3g+l3bPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6918", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6918` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAe7Vr1mY+Wzd1BMsDdbpG2b3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ODkzMmM3LWRiNmQtNDIxYy1hNGJhLWRiYzhhMTRkYTFhZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2JlMDc1NzMtNTRk\nYy00YTNlLWFkNmMtMjNkMzU2ZDMyNjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG+G+sxN50m2zHILoVnrbut8/PDYgodviQr7VoPpCI7n7JOXUCnJl2IM+iw2j\n3MExaRI103RTRVt/hGL97uS28aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlo2GvmUXKoBsSVI3Lz2Gy8P7v6wwHwYDVR0j\nBBgwFoAU/68OeCAr1d1HxglR8tT9OCdL8PMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCC95vvEe7+Be3vdQZXU9AjKopYXxEMKNtzJaT1BM01ZQIgctc2\nC526oLK/NvGHiNyB9kkZuLpxT9bH0hfPmJjdEY0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASQxyjSEKzRu71A8nR7snwKMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTg5MzJjNy1kYjZkLTQyMWMtYTRiYS1kYmM4YTE0ZGExYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT22JIqWj+mwBqKDgGJ1Nf0OLTsD4mTZ2MbEou1cD2n3e7W\nh9q8AVPyX8VU1F3bHkEk5FGN3SAFxkEA45jpbwzuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/68OeCAr1d1HxglR8tT9OCdL\n8PMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI60770sM0AfiPI32TiwOs3+IEHDETK7XrLpcdDQHn2XAiB5GQ6eCcuY\nhgSfcjfOqe5FKeTIcKUeLaL5Ut+S1DI8Ww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcnYRyzrBmy1B6Loh3KuTdEfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2JlMDc1NzMtNTRkYy00YTNlLWFkNmMtMjNkMzU2ZDMyNjMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTA5Zjc1ZDAtNTNjMy00NjZmLTk4ZjYtZGU3NzU3M2My\nZjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDSUKzN/IghlGtsEmCKHy0VQ/\n4S5uRdOAq3O/4ozGTNcTRhbYd+gigTPWbzq9lFNxPaUC9FIyTyNWE56eK9B7taN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlo2GvmUXKoBsSVI3Lz2Gy8P7v6wwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIdRX/lU\nKI+0tNohMLgqf0UHwcnQ2991HTLLOelDJFJOAiEA1BVaSPjSKbdYKNbyZqcbETGy\njLo8sif1lgswSkMiPdc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6919", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6919` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAQmvGKCUAzQ56q1yEEct2FlaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNWJjYjhjLWVkMjItNDk5Yy05YzZiLWRmM2M2M2FkYTRlMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc0YjdmZGYtYWEy\nNC00NDk4LTk1NjQtNDA3MTY1Y2ZmMGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPOFZUEvemZzhAdSljOU0I6E9G1fKbSKA3yRitn13Gppzfajc5zux0K4K18pY\nXKi3ToJeFdy2rN5Fr+fdUeHjFqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSPzxatXrJw3sfnZzq3Q6LrlJsJrDAfBgNVHSME\nGDAWgBSX8kCjkvmNKWLVSVwXECoVjJThZTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDWP+0tHlxUYFkM3fEFlrCsVuB8rdm2\nAqkxX0rUFv7JxAIhAJlnkX20evszkSl4ChTM5a06ZMMmpshES+1lQ2AQVzrr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUKCMnR9M6uXbzj0SOB/+X8AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzViY2I4Yy1lZDIyLTQ5OWMtOWM2Yi1kZjNjNjNhZGE0ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyaSmfS76jlLPDC/37RLHAXRS31iEvEFe4PWKcI9mK+qJp\nWvy8sq0yFzCfVq2bdNiOojuCquqkx2MW/FBmkuBao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl/JAo5L5jSli1UlcFxAqFYyU\n4WUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMk+MCAe/bQNEvGA5N/UVu7iCazArCUIm6057Pzt+ukACIQDPVD5JCjIh\n2oaQZ+rz++FwJ5b1f6lpYyYJfNtxSbZHUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWpmPeNjw/NKbk7TFUsyvnqMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc0YjdmZGYtYWEyNC00NDk4LTk1NjQtNDA3MTY1Y2ZmMGU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjc0YmRkY2UtMTVhZC00MTY1LWIzMjAtY2M1YTQ4NDMz\nMzY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaeodlssdnNn7jqz3AXwi7Kn5\nE4kltJEqV6jiQYs5fueNnwdLq8pHVVQTrCVB9Wj9109ipdNOQLnnWYqou3R/GKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUj88WrV6ycN7H52c6t0Oi65SbCawwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgbIpNxUJJ\npx80CkfgOYngIHuCZNxyqZWBkw47NgBcTs4CIQDLP6q+37gP2EEqk7ClrpVYa9xd\nw/3tOxWhcz+Trv/coA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6920", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6920` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVPWHy3FkLwxkac4IrHNJVb2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxNWM5NDkxLTg2OTctNDcwZS1iOWI4LThjMmI4Nzk4NTc2YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDZlMjZlNTUtYmQ4\nMC00ODdjLTk3MWMtNjkwOTI2ODgyYjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7QDfXUZmvC07gsRYBVlnJcIJ2KxAT9ppJ0C4fnRhxqyZWaPF09dCjjYI3La+\n1IheChJArxe+mGQUOHIHjBp5oaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrxTBJ3NSRevY8nfLWMR/Kw7v7eswHwYDVR0j\nBBgwFoAUpn7Tp5rgUueLr0vHqrS3tPLettgwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCPJVu1w2N7\nYuc27S4SUilJV2P8vjfvWkpsJnVe/xeA0wIgc2BVsz60x2d9NlnIPcw/xbQoHa0j\nEuYJFYmZY8bckSM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARx3imtcvRTQaduPwLnpmpdfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTVjOTQ5MS04Njk3LTQ3MGUtYjliOC04YzJiODc5ODU3NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQO0l+rBUvxZWOxh6QYoipv6qLYRgdozGmIr6HWS9tkrdU3\nho3qNKnJ0vGfwAkjQDCgT5+TKU+5R04sCTcsywYxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpn7Tp5rgUueLr0vHqrS3tPLe\nttgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALiZw+7myXw0WMIrvzA/GNnn+ckgTuUPdWz8AWwDWeNcAiA1sJZUT8nt\npnXD+QcpxBTD2GSNMFvVjOqvaiswIHm4qg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAfqx+kNoTsE32lz5Ok9toTwZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDZlMjZlNTUtYmQ4MC00ODdjLTk3MWMtNjkwOTI2ODgyYjNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2Y2NTlhMzEtZmQ0YS00ZGM1LTgzMzctMmY2NDRhMDAy\nMzIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEja0pzhtWag/PUAf05ip93tMK\n5Yg8BRXOWglS+5vXg0t7QA1w/d4hCeOMf0NMvBkabLa/hoHBTxhe9Ie1L7Rs3KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrxTBJ3NSRevY8nfLWMR/Kw7v7eswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgflDscvBu\nLfwzrQOIpT3vEjAYmR6mS4bKSSHSm/bgzzsCIQCscOo6ijI3C3L6crpZGj/2FY6w\nJekWXUaIYIo9lzADbw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6921", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6921` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAURD6naiX/l9FWQMA+I9F2WdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMWE5ZDBmLTBmYzMtNDMxNy04ZmRmLThlNzEzNTdmMTMwZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYyZDA1YzgtZGZj\nMS00YzFlLTk2MzUtZmRlZjZkNmVkYzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjnYZLO8e8KTFXOeM53+NhbdCTn6qNxi57tEVzHxAZDrKYt/91u/wh6njruTr\n3mjJ6ysao9o+3KxUx9YIS7uuNKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1nxvLZbxpdGV1QBSeDw2lFzRQ/QwHwYDVR0j\nBBgwFoAUpxt+Tbe26Z/6Xvf4SkZtyvnDrK4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIDypBGpxdqfZ\n/RJsoGcCsaRJkFEOwyrZKZ9Doif9gSjmAiA2CwLehnCGj5zUPslqqPIlzWkFgkcy\nDtKQTlN9KtwvJQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcp8QbdUcZbQ5yqwH2XXmx6ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTFhOWQwZi0wZmMzLTQzMTctOGZkZi04ZTcxMzU3ZjEzMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQulyzHOEb/FErD8RdsQyHcy2ANk/20eVxyVMpXXNyNB1Tz\nAiRPBICu7yvVM4I4k487UisAnFqGotkiVedJdTyjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpxt+Tbe26Z/6Xvf4SkZtyvnD\nrK4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJOH88QOUws3hCQK5bY2dC8IVcFAeLJ3nWYWyKAuIYuyAiB4KGehjnW/\nm/DpsmcumwYAzHYWm5pxqU8fLc5gdNG2ww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWyiHoQr4TAEqql0wtYmgQ+BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYyZDA1YzgtZGZjMS00YzFlLTk2MzUtZmRlZjZkNmVkYzVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmIxZDAxMWMtYzc4OC00NTFkLWFiZTctNDA1MjMyYjRj\nMzM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbZ+aBpvoIBHGqJFl5D9eIORq\nqxtRGSLzSw/QJ2/dRccoWfl25q7ZVSYQ+jO/buiTWR1y+pA6nU6xk5YyIyJJgKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1nxvLZbxpdGV1QBSeDw2lFzRQ/QwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAP7rdyyK\nE0dczJ6n51c3NpOHVgugKzVpBfLyWHgLG8udAiBTs+YbwIwVjP7PXwNb/73oAfCk\nabjbC6JetqUhltDZ8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6922", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6922` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISASoZHSaBiBoO2PDWLb6nkNf5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NzViMDljLTlhOGQtNDQwMC1hOWEwLTE3NTEwYjY3ZDdjNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE5MzI5M2UtYmVj\nNy00OTQ0LTg2NDUtYjdkYmU0NDU4MzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3PwErmVgIjnsQBpO5kL4NCzJSO7TdzpO0fXwjD4zlr9DBEzEc+XbgguCmneA\nqRvG1OEnMKx1syRRxevWzlLqi6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbX2vCEemAukIhTdFMzYjEYB4huAwHwYDVR0j\nBBgwFoAUqQNOhM1nswVcZbKpGBQDZrIZPPcwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA1dJBKG+Q\nVHpcAFgDYC/J3A2hPNLEaRjvuSMvaiXHnEkCIHomD70Fwz1HyyIDGLl+I9P6dxLX\nV/cjSCoZDWe9WkWl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATB1w/RkR3oi+NdOideB/of0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDc1YjA5Yy05YThkLTQ0MDAtYTlhMC0xNzUxMGI2N2Q3YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgqB76+WfqOqj8VYe02cGY5Kl0BEopo7zvqF2ax7s4RXDC\npFBvnQfm5+TZ1n9oL+3nsPOORA9b72AfEJH2Hlico2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqQNOhM1nswVcZbKpGBQDZrIZ\nPPcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM/mSTre+/Xm7Xv4EEPvUIjPYNKp8gVF8Vo4QWDQSKNsCICxauT8TFEco\njuDA1UQmGpc1V4kbQwbHpwbx+SgB+j2G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAd75SIJT5qVeicxQzlmojQ0KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE5MzI5M2UtYmVjNy00OTQ0LTg2NDUtYjdkYmU0NDU4MzJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDNhZjU5MzctNzNhNy00NmE4LWEwZmItYjYzOGJiN2I1\nNTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEipaWzzlSAfZlBNBMKMSifRkY\nCvO0HBIuBPRWSMZHYt6Kgdkh+8IcCNNrvT0ZuG1ScbIrUTwUeXqQF1cOY9OdxKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbX2vCEemAukIhTdFMzYjEYB4huAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAN4VrPZ0\n/LdxsiTyZS8PXODvfxrQGOG/JbLdL4uQFcUgAiEAjpOX75BrkkNluRuYcQbMb4NX\nitlqEjjjtyypUssSBL0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6923", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6923` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYUYQAH9FN5oTUBuqDrtCIxcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkZTBiZDFkLTc5YjgtNDIwMy1iNjA3LTBjMGQzYmQ2OGVlMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGY0MzVjZjktOWI3\nYS00NmM4LTgyYWEtZmFmZTM4ZjQwNjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF7KHMSbqzQWczY4VwSvu5gzhxHjsdXKmM9NTMhYnjDiDyzHAB86fhKnhPwXG\n1cqEwKh2o8b7MxF/GEwYb5M8DKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaHb3AF7WM2XZWFZLrs7k4yxjQIwwHwYDVR0j\nBBgwFoAUeU5EgjOxUjyWfVOmbBJ25RH4LtEwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA4DJjTZbxDwo3N5k5SxYUPOPGdyBAS55G4o6h3taGGvgCIEZaUuP+z4JZ\nWhmJ1O2H9y89yVdh/LFFzwIpUWOzmF+8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAURNkMEmDW/gCJFMVM1q+zYFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGUwYmQxZC03OWI4LTQyMDMtYjYwNy0wYzBkM2JkNjhlZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARChEgopyDsYFa/HVvMIO0Sju6CS0uavQcRDyUddFUQyMf0\nj2Z7FRSwWGya2Q13RvwCqRcSiijvCm1OGFG+x6leo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeU5EgjOxUjyWfVOmbBJ25RH4\nLtEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMDIRApEm16VMg4V2+uJknM0ng8VDRkYRuFssu0kYavTAiEA478SiztY\nBDCRlcFrEECg1z1B6l/FVhGpVUkNebVuDKI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARvG7eyMlPu44JbMpdBxU/p9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGY0MzVjZjktOWI3YS00NmM4LTgyYWEtZmFmZTM4ZjQwNjM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjBmNTYzMDktMThhYy00OTdlLWFhMDgtYjRiYjEwZTA0\nM2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2IWQJ+wllOK3KFdjq6VCb3h9\nzNJfLmoeYHz1BMFSQyWom+HBwOImZeYDBUnL2WxRKZGRaBaDjos+ahNdIT5syqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaHb3AF7WM2XZWFZLrs7k4yxjQIwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgXuk6BTdc\ns6IPa5i5J2GrY5FmnRrFdCtylY+J04nb3sYCIQDzvQ6S4J7Ku5LY1JCW48pP0m6h\n5wx0EWjb0YblJxQ2fA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6924", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6924` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAdiXk2YHKP//FrB+8d4pTDJ9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhZjI4MWI5LWY2ZTgtNGZjYi05YTI1LTc1YmY4ZTRmZThkZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUwMDdhYjktMTUx\nNi00MGFiLWE2YWQtNzQ5OTI0MDkxMzRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3tQPg88KjmElukTB4bjoPw1cnkOxsckp8s38gWX4/8Y1jcMJ4Kmj599+nZT8\nwIgXEA6U+h9r+G79KGo7RVRxR6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9OIOoIpsTgCqzubvnKhHFyNE59owHwYDVR0j\nBBgwFoAUxXZ7j0rNTV1O0GwY7YCAumTw6vUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA553DYie6sowA6BdygC42JaUN658DAh4g/J9AYZ2nGkICIQDcK7JXVmzx\nL0ZQ3fEnfy3VWuGiqi14cIgolyXUcKbJxg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY6vjMOqwc7RsD0g0MNT3Qx4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWYyODFiOS1mNmU4LTRmY2ItOWEyNS03NWJmOGU0ZmU4ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtJ1C9w14yXg+41S5mZUML4V2MA+ED7QOS+Z9qSBYCLBwE\nW2hDUkzlzO7SIDe320M59PBi+9zukmmQBG8tIufFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxXZ7j0rNTV1O0GwY7YCAumTw\n6vUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSN01WTVmFKlI+z5i9wm5LyfCcM+I5QvSBSBF1eR+NR8CIE+WCDK/9V7Y\nepO8WKvcyG8BwJw58KPN3fzGpOg0mmTJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZBlHSBItlGtuaaarxtCtStgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUwMDdhYjktMTUxNi00MGFiLWE2YWQtNzQ5OTI0MDkxMzRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQ3ZjM0MmQtOTFhOS00OTY5LWI0OWQtNDhjMjA5YTk1\nYWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUGWZv5oA2WhguPAjmPloBZA7\nV7vpre/nH3Yxje5inWXoF5Ubz/7bsP0cjMCsoEiQxPLq53updE4pu3aYWML3LaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9OIOoIpsTgCqzubvnKhHFyNE59owHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgGIVtXKcf\nex8iJqajO3KkSdj/pGEEVbji+DHPMQBQvkMCIQCM8EQXyssOxxqtuLe4qLgPPdru\nAdWlMHMVoX9s0tixOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6925", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6925` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAQ0tifh9mhERA0hMkR1HbIxiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3N2ZhODlmLWEzOWYtNDE1Yy05ZjcyLTdmY2U0NTUxYjQ3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJlZDFiYjUtNDg4\nOS00OTQyLTgwN2YtMmMwZTFkYWY5YmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBUU5AC6X8W9usGEyy5uND7q1vPcB1U3i/KOeQqF9SABP5Ry7Y0Gz+Y3rEbPH\n/1TpbxpfnWUkVReU+eUOYqmn2aOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq8xyyMpVfCn+iw4jXkmUSvdAXY4wHwYDVR0j\nBBgwFoAUbcYUMVVw+WyZE+Oz+u/Yv3LI30QwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n8B1wdqNruEvfyL730ZNtN18WR4rDSwaI+FzIdYkU+Q8CIQD4Ram8mNtPBNyICqS7\nPzDDj0ZKARCBTtPLEZaPGeGzog==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAel33sczhaFf+pylbvBznXtuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzdmYTg5Zi1hMzlmLTQxNWMtOWY3Mi03ZmNlNDU1MWI0NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2j9HX2XevE/AOqbGcsG70jesR4pKlZKDQE+S1fpPlCewk\nOJGL9y9d3c0tEF+S+gykfocxp9XUPhoEUzmIplbKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbcYUMVVw+WyZE+Oz+u/Yv3LI\n30QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANKV3qR+dBdmbDhFb/D9eLa9kXgxjcsTCeYW2e1GkRwmAiEAxEiJb2lC\nB2AEv/JdYUG2I0UD2Yyu778x4AVMu4NXOSo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAXY4CmrIVUUXkI1KeNuhviSnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJlZDFiYjUtNDg4OS00OTQyLTgwN2YtMmMwZTFkYWY5YmIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDRmYTYzZjctNDc2ZC00ZDkwLWIzZDktMjgyNzExNGQ1\nNzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1yC5rMT5e3+ccS60k65+2fNm\n1nGTpXQUtwFk5NIFO+d7cCkU3JW3dQwAI4BMIFyLHrm/ur69ImD3YmwB1YTKH6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUq8xyyMpVfCn+iw4jXkmUSvdAXY4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIWIvRhc\nOyMvtKioi9aZM29Sves5DHE77JWjrqUMI2cdAiEAwYxH9cCQIN9ho/kiHB6GxQp1\nfr35Mh4a8uEKgsK9oXc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6926", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6926` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAd7aoKNucD4aT0QDRyX4IIt6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMmI2MWZjLWI2M2EtNGM4OC05MTFlLWM0YTMzZmEwOGMxMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJlZjkwNTctMGMz\nYy00M2QxLTkwNmItNWYzNzU1ZDhiYzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk4tYXK2XVjPaY4cpFX2QJzENPs26W+JWXjrY+4ImHMp5459C/hb14tRALqqQ\nFeJexDoWNpZfw664VgbJcep2naOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd7McDyo1UtS+NIU2Y4iis8CrCPAwHwYDVR0j\nBBgwFoAU/pbjTNIrUTHW+BoylwNGI5KQLtQwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiB+oGOB+NMbEcjpKKL/j5fiNJnvNLRpA9/3ckeBuGrRZwIhAMmd\nNZ4HvNJuLM1o23Q5Om39qL9yjsy/w1nvudMU5+pT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYh9Jo/kndZtBPhre22ivX1IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDJiNjFmYy1iNjNhLTRjODgtOTExZS1jNGEzM2ZhMDhjMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATppINB5NHtCNCFfpUAPzLZtn6iQ6ZVjypkNBZ7rqIllmLO\njEjeNPYuWiCeUEWIPvIAZrtrRk7wil/O6bMAUEELo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/pbjTNIrUTHW+BoylwNGI5KQ\nLtQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgX+WYQTgCkM3rxGct7gYM7PBuLNo6cFmx6q58igN6CWgCIDrHzBPzUWdV\nd1li1IPKkCgFwS79rIXjshUecWbQPTh0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAfWIEXjeObCudLRIuJlGNOrJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJlZjkwNTctMGMzYy00M2QxLTkwNmItNWYzNzU1ZDhiYzk3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODkzZTBiM2UtYTNmYi00NzlmLWFhZmUtMzMyOTMwOWVi\nNjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYO7rQZj5L607ZdGE3zMCSbWJ\nKhRMi/S0Z9W1QAfm2u1WHorUVSK0MNV9Sr13Z31FTZA43hBX2L8/jOix2s9QpaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUd7McDyo1UtS+NIU2Y4iis8CrCPAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgMTdDuN7G\nif84vtS3RNR0yKPAoUH3e2l8Hmai5Fc4dBcCID8dqbzDdjXZtsWpFw10YLG0tyhN\nKnBFiSD8x3myF8D+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6927", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6927` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAfgUKdCfYZk4m6zFsX+6WQ7TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkNDYwZGI5LWViODItNGVjYy1iMTcyLTEzOTM4NWNmMzI5NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzNhYmE3OGUtZjJl\nYi00NGZjLWE1MmMtMGJhZWMwZWQ4ODMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4ZP9FkQEhzcAMHGl3ulcwlPb3flbg8KYDT1+U0C/P2X3xNxcfOOnzhiFvvWY\nyFHnJwtDPb3vxg+V2Cg5nfr9C6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5rHDo/08bvPYvlVBooGbOgcql9IwHwYDVR0j\nBBgwFoAU9FpoyLLocg4u3REumdmeVa7zZGEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAymGPx7sq9M0UyBpIJcxODpJAgzWWPWsLFiPazcjXTxoCIQCh\nKUPCN4JTO966j4cZ34PIXHeohbg8eyquf54KrO3ZgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZj9RVu1ylw9A5VJ+YKTQgbDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDQ2MGRiOS1lYjgyLTRlY2MtYjE3Mi0xMzkzODVjZjMyOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARB+yJpI8NysvMNjRkLXXZZQaFwS1+hkXyj26Fu3X+VPMTE\nijAnLsNQBEUYB6Yq5JYF+pJXtNWFc4e5pdTZyB1wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9FpoyLLocg4u3REumdmeVa7z\nZGEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOw1xCPWshgn7F5F6Zwo80ogdAxcFVPQgAQXnTIwBwAhAiEAyp1tw6Lt\nzWz6sG0cso5uGWygGqy+duHpc4gZdfF1fwc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAba+MVovHmiIsx9N1p1E/gY4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzNhYmE3OGUtZjJlYi00NGZjLWE1MmMtMGJhZWMwZWQ4ODMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjE3ZGZmMWYtY2U2Ny00MjA0LTkzYjMtMjc4ZmYwZDBj\nMDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqVwmHQ5OMqwUCgfVy33345C+\nWA8NmXZbOAZvMdQ1HFhZPa4O/7ef/lwpKtQ6BWMTdbmS+a5O5AL4GHjuQ5MJhaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5rHDo/08bvPYvlVBooGbOgcql9IwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAOroLq3c\n2o9QOABtKaVoPtTCxJtAyYozZA4yUeuhFTqOAiEApceK+FAzLaagUuvIl8E5Wp3R\nhVrzXynaNsWykjqSMEo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6928", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6928` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZ8445EjhOCzjpU4mtxrmHqqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwMDNhMjA3LTUyYzctNGNlYS1iMzE0LTkyMGFmYTg0Y2I5OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYwMzQ4MWUtMzFh\nMy00ZWFiLTkwYzMtMDE4YjkyNDhjOGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEceWstrqVc5c/9VHQUwtVvjHS1paOkMJ4+SeEO6hEVn6NiXuPvzfqM6/oub1J\nRl81D9IZhp+CgS8hJ0LTsNCoHqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkLkP3CD5GWBHoKaAG40j2v4Uud0wHwYDVR0j\nBBgwFoAU+89e+ti9Fah80OPX8bDIpVYt738wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBWwgI/SOdL5YcV\n51/VYyJZiw6/xYXI/JnvqOVLOractgIhAMlIRjVrNbru5PAYNd7uYq2wASLHPok/\ntRhzXEE+oprk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVTuZl0fYU7CoOKnNb5oGa6+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDAzYTIwNy01MmM3LTRjZWEtYjMxNC05MjBhZmE4NGNiOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUUU4hEpoX55dszczARi5KIkL6IcP1IupSVbQOYCiWcuJM\nYkQBL9OXH2c+0hggIJtx4JZBHS9u6v3fVRLSCXbeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+89e+ti9Fah80OPX8bDIpVYt\n738wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJQ2L958f1PXR+hLsF+c/KrFqV4jaK/SkXha0yEs3DbcAiA6lwDzYs7r\nPE5qNX2Sm9Mt14QZ8/HQw52x76QxD7BZdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQsF5LP9VOqFv+RrP7KS0HTzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYwMzQ4MWUtMzFhMy00ZWFiLTkwYzMtMDE4YjkyNDhjOGYxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzA5ZjY1MzItYjU4Yy00ZjEwLThlOTctYzEwYzVjOTQ4\nM2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHJITmTlTonx7Icvx6LuTNbBM\nWt1qKDzUiK+FLivs5gs0ZG+D4criXzlkPoByemHXIkxF7PKtN4tBLbWbmAAKnKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkLkP3CD5GWBHoKaAG40j2v4Uud0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgSqUXF+nP\n7sxY9PqyZoI4YZcJnkLyAEEhtgaw6wSozbUCIDOM/tDcccr+kjzdesfNdwTRlQg/\nR1cy660sGgEQd97R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6929", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6929` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAexBcbjlaMzdIOaI0bOfmo9aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2NmM5ZjNjLTA0YTYtNGFjYS1hZWFiLWU0YWEwN2NjYmYwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ1ZWE3NTktMDU5\nYy00ZmEyLWE2OWMtMGUwYzEzY2FkODdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiYwebut6ecBhYWVuWlYb/qBIaM9ekuAKUjOkE0wFZ0EjAYk+ob8K891Vk97w\n6txav4kVz7Qq2p8DjCfWOz2+C6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUU1aZYKgBmxZmKR5tVkLEerfIPQwHwYDVR0j\nBBgwFoAUTKc03hXL2vVjdsimTvHmZjNNCZ8wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIG/PTD94raDKt/jCstsh8f1d9GdIAYFFs84aYtg0KobGAiAzuGSylYWc4xBd\n3vrSIPPF9Zfh6S2elmqLgyrVYG9CkQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf2jDJ3cHTeGh1HwUTTqzYtEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjZjOWYzYy0wNGE2LTRhY2EtYWVhYi1lNGFhMDdjY2JmMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROO+eZRY9rSUhOj2ByGBKYAvagrsUOJgYYeRTqhQUIokUk\n6LcoXAiXmM3pFx3mlQPFtFU3FWYSlmW+cM0dvU3Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTKc03hXL2vVjdsimTvHmZjNN\nCZ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALmVfDLN3BK2ZaZtwTtyhWn7ko9d+bTcTKY6ItdJkSooAiBqsQzQhYKe\nvWT6nWQjH+82hPoRGpVG7np7Y0lq2oqJ+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQtpzLfrhn0MgfNfmSvJKjnbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ1ZWE3NTktMDU5Yy00ZmEyLWE2OWMtMGUwYzEzY2FkODdmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWJiYTk0NDYtYTk1Yy00NzA5LTg3MTQtOGY2ZTk3MDE2\nNTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYEooUIuFxwYU5H8Wm4+jm9Ce\ns1DXVpiAS+Ptg9ZU9ZImMK+wITZxXM2yOaVqOFMMlZm7hJTgqT7ck/fffQXYu6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUU1aZYKgBmxZmKR5tVkLEerfIPQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgDVP0/a14\n+KZ9KIAM/JqAHIBFuBWkvv/DE9HpuQ9o1ZwCIBSlOi9aX5CGcKcjfP4dmcByt/hS\nfjftTLI6nhNHGg48\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6930", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6930` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdj2Kn7pIsibYxxWt2Dr7jH8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyY2Y1ZDIxLWI2YmItNDIyNy1iMzU4LTI3NDU1YmZkNDRhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzI2ZmVjYWQtMTdl\nOS00NGQxLWJhMTktN2JmODNlNGYyY2FhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0iTQKRWOOY7SvExY2VgH+yo18fe7WNFoNqdLe5UmX0AMF3X/x4DObNngpmiM\nCEKF92scqfBY5c/TQ3/KGn6qqKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTgTnoeltF1SpfpNhY8YInBdBq7kwHwYDVR0j\nBBgwFoAUM+L/oSE7uwY2obTy/PmPrJHcKTcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFgRmS/8vHPTnd/xuQwC8n6PB0zkugraQhmotkEzji9mAiBIppW2N4CEzp0t\nUW6tcOS6BUE93hH2PQJx6z+gIC6m2Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASaJGq5LFruwc47P6k5ekjpFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmNmNWQyMS1iNmJiLTQyMjctYjM1OC0yNzQ1NWJmZDQ0YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS0Lun1L+u8iChRh7WChRHlZnMIL8g76kVRFTkc0KWyGRp\nqsUmR8uVtPtZg6Lt0FWqB3I/i98xl1B1+gbeZX3to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM+L/oSE7uwY2obTy/PmPrJHc\nKTcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbMXe1iq53Qcw9jrSuJVkcoMU9y9mK3l/U9ulTcf463ACIQCRXd239jr8\n5F87txR2eHPMC97bMhExuBsqzg+1iFOCOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAa+w3hbqLKT4fupO5GNTBp1YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzI2ZmVjYWQtMTdlOS00NGQxLWJhMTktN2JmODNlNGYyY2FhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODUzNGYxNGMtYWQ2ZS00OWQ3LThhNmItMzc5ZWRhYTdi\nZjJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDt+DqPjp4rGvRz6SoV9HriWD\n1lCDMJnYFfVRZxmnqh+M70rP/F2kItYvvkb3DTLlsaewFYMIlne3PyHZoA/WF6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTgTnoeltF1SpfpNhY8YInBdBq7kwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhALZMWGQ/\nl1vu8xE4NOqdWvpf/Ec5EQFv6UqjcxLEtOHQAiEAr8QEpHTWqIDezSOiOTaiXYWU\nSWxhzXImM+aEfMwwcZU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6931", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6931` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISATK8srOKiQg5IrUbB7YCPTN+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0YjM5OTU0LTY5YTgtNDIyYy1iOTZiLWIyMmYyMDU3ZjEzOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQyZmY2NjItN2M4\nMC00OGRhLWIyYWQtNGZmY2M2ZWY2MGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoOhpwSs/v9BnkAul+2l0rgZCXIQoixy/4+5fzl0Nwsd+Sm541JfKYoWiejdj\nq6RORK8CPSPLnA8TSprMIcVeu6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxkj7KJc3JvVCAt1XWht/q9PCMgMwHwYDVR0j\nBBgwFoAUVUOvFBPpAXjUqo8kbZWUDHMpHHEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAC2wHwLVVqKWvf1afyLOEA0Z1xjHShI88EKng4Py7CngIhAKwyfhiCqmIk\nmbYm2c5EpRyFvtlGzhMeZlbrF4z7M+z2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUahZx46amfh6FoXJuxLQH8TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGIzOTk1NC02OWE4LTQyMmMtYjk2Yi1iMjJmMjA1N2YxMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQexN1pEzCImEYVf8GV0ZIt2E/fIvutu0gxy2aTUsPTS2OO\nr6Y3LuTmCDZMa8+bc+HINBEzLTqZBNNdpoxSBrGNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVUOvFBPpAXjUqo8kbZWUDHMp\nHHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ0eMj124KV7F2vmlt0hGkw6TadYvWaFW0sX7hn4K/bQCIQDq7V95+mvG\nS6LJWiEZ4xmbZboQDBN46uyNofrwo6JhcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZhg+VwKfMxsF/VaDqQ9AQV2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQyZmY2NjItN2M4MC00OGRhLWIyYWQtNGZmY2M2ZWY2MGIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODIyM2FiNDUtNTkyMS00MWRmLWEyYTUtNDAzNjY3NWJh\nYjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExquzXtXcAYlrmjPm9zfVv6XH\nXVREUYBq5WwuzLj0hDS/X1eZYy2xQliAz6+18mnpqQibgiEilI95/Ufwvee0x6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxkj7KJc3JvVCAt1XWht/q9PCMgMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgcEXFGqV4\nMH1qxWMrgGQZfcApUd1gUeU5H1Z90oSH+xECIBmMvLAY51cW2u3GlVUsHVWRKKTN\n+5bovxuVtPvnQuYE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6932", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6932` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZjbTKtyU2IVQ6b3NmC1D7rmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmZTYwNGU3LTQ5YjAtNGNlNS1iZmJhLTM0YTUzMDg3YzcxMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM5Nzc3NDMtYmU1\nNy00OTM4LWI2ZGQtYTRhM2Y2OGY5MGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjYR2QaFVsRLvNuAl8ztqmoKY+URgfkZBTIWs8Eu5FdcrIhz0cWW94VM7gWvj\nVyfuXdQJzf+KGjb9Xht12igRcqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDs5bSx6deRoCma9kovXmqx6FzOYwHwYDVR0j\nBBgwFoAU/reY6cFzWQUJ46+ZD+2cd/CE0mIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBBO9enuKtC/sx708cV+mYlMe8fDL2i1ngudyX6yRsL\nHwIhALJootAUEaNTvXxW/EnAiK68rPTdy2Upd04BWRakc5lL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVvNC0K03/w2yqNd1Uo7aI0eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmU2MDRlNy00OWIwLTRjZTUtYmZiYS0zNGE1MzA4N2M3MTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDnCttWiTum13I64QNtyih86rzpM7vS2eSuSV6X84job+z\nGDiSUfEfYxULEWtKg6OFrRY+kH6p1KTlsfTfdFB4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/reY6cFzWQUJ46+ZD+2cd/CE\n0mIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBrV7HCcfaTT2GMsRy3xnoJ/I9wnpOnwNL/hBsvNpE2ACIHPRKFpkTPP7\nrWhqNb2pKEe3zVS2kvKA2K1S8rU/3lR3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYNf0DEhMAq3/Zimn1wBlzRXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM5Nzc3NDMtYmU1Ny00OTM4LWI2ZGQtYTRhM2Y2OGY5MGViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQxODM4NDktNjg0NS00MmMwLWI5YzEtZjE0OTZlM2E0\nMTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpU2GvBla9jYQmCnBsnq8bcaM\n+Fz8fhUEM3tWVEoX5mJbqzhZBQRwWuVGOISXqnJRPoZWLfwYWkOhmeXgRs+RgaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDs5bSx6deRoCma9kovXmqx6FzOYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhALAA6fIh\nh2xKvhcceZtSY2oIInPyralwAAPan7VHXt5FAiEAiqK6559RWaKarwaTz3evS94S\nXWu9QPdQZYaPTrCEWxw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6933", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6933` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAfR51zzZvhpZJkB/XxpH3740MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjZmE4NjkzLWJhNjUtNDk3OS1iYzc1LTk5OGI3MzY1MTRkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBhNjllZTUtODJi\nYy00MDkyLWI3MDUtYTk1ODE5NWNmYzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq9FPE9CBpvnTutE1v5nG84Q5m7L7x+Z0fyuNGld7MKhOgDckVVb1oFkBhA3+\n1sVNLJqr+AzbhdyL7Gp0pTmMGqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZql4XoCzHBVMOi7n9LF63RT7O9EwHwYDVR0j\nBBgwFoAU15CHYRwFtVUuCGBgukMFeapCLGwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEApPOSbe3iRC2YvtjMKYT+5DT2raVgtaeyNdCHa1lJ\nxjcCIAgWrMpHuzeJn/mBoWJ7K1c8j3RoQLINEAthd3/KGvFj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaP93EvhogsKQiW3yE2/YZeRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2ZhODY5My1iYTY1LTQ5NzktYmM3NS05OThiNzM2NTE0ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4LgBlbaQNRPBx229EcYyQ4oaSlwt5DaZFHVRcGkmIupET\ni66Wa6OeXIm2xD1g50jmjj92d2qoZKWJuEv57n9ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU15CHYRwFtVUuCGBgukMFeapC\nLGwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIfY4h08H79uQ6lp0oSXgtvRj9Iso2OAa7TsokcCFfI7wIhAK4vFVseuMZV\nQgJE0GV6eTImNHSnXd60PYyBlGXbJRlm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAT/Wu7CZmwjQr9HXrShADaj2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBhNjllZTUtODJiYy00MDkyLWI3MDUtYTk1ODE5NWNmYzAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWExNjliYjktYzVkMi00MDk0LWI2NGQtNzJmYzI2YzE3\nMTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsj253dbm/ln4pBoxteOPqM8z\nHxcNyRlwP3n0cWNG1zWZ3BO5PFU2F1eXzdtSNdFuQLCeuVv7oDikqq1xmKloCaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZql4XoCzHBVMOi7n9LF63RT7O9EwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAOyq5mR6\nzFNuvPj5d5dYepw1MqpwhEf5q68ap0i/QYb/AiB9+uot4pfIDOkQOR/aqjpFmKvA\nymLk7yYKHaVi6vB0vg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6934", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6934` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAdBWzrD8HZ40eVNuKnKGfdJDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmMTg2YjI4LTE1ZTMtNDA4My04YTkxLTI2MWM4YzZlMzUxOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdiZmI3MzMtYjdj\nOS00YzRkLTg4YmItMWMwNzQ4NTI1ZWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEprVyWtcdNnTtaXtqTEqsT7qcRI3HBEhZIG6iKw/Zjose0fy4JAA+i4f/K7Xh\nSwyqq0FG4AjkprFbDgeeglbpNqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsnyl94v31Y+F5xM1aRBHNettoLswHwYDVR0j\nBBgwFoAUxhEVhoOMETvou7PAxtuZYERpwMIwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAi9RkcJ3Mj2VeNLqwrA2y5fF9knT9swbjC/Dog2tFmr8CIQCI\nkgYA7XseZaoyzS3rfKsJGuU80Ch7VCh5POfOXD457g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaRIggrcabFzN5L6dZk1G9ldMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjE4NmIyOC0xNWUzLTQwODMtOGE5MS0yNjFjOGM2ZTM1MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqP3f0hE51Br1djZCK9CnXjVpq4klwjbYNe0KwlXfjgnDr\nfI0us8HV4UR0MwDB9ACI3zsu3r2q43xcdB6B9Zgxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxhEVhoOMETvou7PAxtuZYERp\nwMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeCUbCfBfRZPlC18emCiMBf5nlFdEiJZhAzRgX6t5vZwCIQD/vL4IYSDL\nPJOSNhgiTzP4ungUUKmLpX5cgpjG/kKKjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAexeEQ8lMW/u3RtqF3O6vz2LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdiZmI3MzMtYjdjOS00YzRkLTg4YmItMWMwNzQ4NTI1ZWEwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWY4ZmQ5ODMtMjRlYy00ODFjLTlmMWEtZWIxOTM3ZWYy\nNDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg9ocMiE/NgJL3vfgdhjJDyso\neEzIiHNH0aDJgobtucu7KZBSM/3w6DpwUoEEc9i9rSZ1zhPAo5VOxAoaZxpt5qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsnyl94v31Y+F5xM1aRBHNettoLswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgUghtwqlR\nvkvSUlmRrA7JfXdzwiRkAg4xgcEwGWeDcjoCIQDI2XakvdCd06Z7jT57n5C2vFd0\n3s6t2qS11qVF3LvQVA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6935", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6935` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVvpJ/YeMEMOSiQUrLEwDg5pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZDQ3NzM0LTU5MTYtNDQyMi1hMjcwLTJhMTFjZTM2MmY2NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMzZTNiYjAtMzQ3\nOC00YWNmLTljNDEtMTRkZTdmOTIyMzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqqp5dBWSFUvwMtK1qvcYMDDP7HqVnsgkqs588u0+jVIUw3XAMb/CPDfDES3y\nyf5Sp0gLwbTCfITmmVqOoqSPXaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGcdQ9pcjnKnJNuRU6dM6TTmjZoUwHwYDVR0j\nBBgwFoAURm4g7BXK0MG8prXET5KyGKWPsdgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAopH4O3uIwFpLN1BvyjuuanGgHcwuUz+F\nLgZRYLiAG/oCICGiU/M1zeF9hf6/tHGMIAbJAh3LBVoIFtmzP3aps6U1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeRWKnSg7aMSVsHrkyJc6xJ3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmQ0NzczNC01OTE2LTQ0MjItYTI3MC0yYTExY2UzNjJmNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkf1wing4ZOUQY11ajErkTHtEVcVZjwMSasGCH1hQR66fP\nrKOzMCaqK8qDD3EC2VHlQTtCYaAQYVGWfk2VOQgJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURm4g7BXK0MG8prXET5KyGKWP\nsdgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE71HYIz383gbDl6EVURNY63nS2ZGlvC5FrZ8fUtligMCIQD2UsmwbbbP\nDXGW8jdL8ENZ+sDWt9OvfAv9Tw2SWGITZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbvdTqAXCIrQts5JPEcuGTInMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMzZTNiYjAtMzQ3OC00YWNmLTljNDEtMTRkZTdmOTIyMzMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGE2YWJmNDgtZmM1My00ZjkyLTk5YWMtOTI0ZTk0Y2Y0\nNGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnEXsxktxnUqaIz7tu2raSKKl\ni5GJbTB++e67KMPLXhrQtR590rGeBIAioSb0ikDJrARqK2Q2a0NyBxRXUWwrEKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGcdQ9pcjnKnJNuRU6dM6TTmjZoUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIga0/J2JWF\n8MmourY5VmPil+MTBNI31fzZ1Fazv5uIgzUCIQDa5QpydTDWxel52pjJ9SvekQvF\nsFshFimHDro8xBuXRA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6936", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6936` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAdvcHm/e9O1TqCUtcwOgIc6LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ZDEzOTlhLTA1ZDEtNGJmMy1iOTA3LTU4OGZlMDY3ZmI0MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI2YTRkNDgtN2Nl\nNy00ZWNjLTk1MzItZjVmOTk2MzJiMzUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETpWT2YTLUoEdI5gTJVwIKohwFqlaCdRz3432rHzKiKyVe6I4dWMInrGr8trm\nUCVsVgpJCHzwuFsy9+ulvWIWI6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkGLAeHX/HfJb/rxeInhHSk6zYNUwHwYDVR0j\nBBgwFoAUfB9j9dCZ1K2fJRlAWGaPKO8ogUowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAkZ874j0AOD1YjoE6zojJ1mliCYXn6JDL\nHGtZTFVs+NACIQDx7eLxvo1d0GYI76I9nqaQJk87fH+jpOxAEww9wVfH+w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATHr1LI0vpZQ3s/VZf7PvQpjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2QxMzk5YS0wNWQxLTRiZjMtYjkwNy01ODhmZTA2N2ZiNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ38BZV0wXBdHR5H4uAN2nMQKNnVct38TEa1uxjL6MokhY3\nudasfHT8N8YaFLb7BQigRSFwNmqw5yL8zK/hc/kKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfB9j9dCZ1K2fJRlAWGaPKO8o\ngUowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOX8if4/4kdEjPN/xqqKfzlOcsomhKcutei/BLPmnGoUAiBtd05Xmfyz\nzxF3GdkEe0pbWHOIk6P9sQQ3uPBx+zeVgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAcdcJsltify2e8ifIpLL3wICMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI2YTRkNDgtN2NlNy00ZWNjLTk1MzItZjVmOTk2MzJiMzUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzY5YmQ1MmYtZGE2OC00MTY4LWE0NGEtNTZjODBlOTlm\nNmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2HwRsWMg8mcBEEO8cY6woayQ\nmMlg7vSAfrFY7R0DnabxCkGz0+2y49Wwa1E4m3lgjsH06G5oBFGIJbUWLcWVSKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkGLAeHX/HfJb/rxeInhHSk6zYNUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgMf/d0Hgg\nhFMOu0dKJIoP/4k8PaYy+TI6ZlOaBcO0EJECIEfrECHIn4UBSxHH+3cuC7ZKi5cP\nUU6iFTTZ6rThTqO3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6937", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6937` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAYUYfwwJA4g3mUrtaxLwyZgqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyZDk5YjBiLTNhNzgtNDE2Mi04MDk0LWRhNmE2NTJjNDMxOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFiMjczZjUtNTQ1\nMy00OWIzLWJmNjgtZmI1ZWIzNWVjNTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB5GX0DAvs/cgBDULNT9mna87gIejaG720oKFXs/vP45wyyXBdiR0GyuHZmzB\no1SO3TLxAVEUcYTi57mDHOnbJKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuslWWYAVfEx+Tln2EZVuz5zpnNAwHwYDVR0j\nBBgwFoAUrd/aIfALaFhFKu+dyVP7Etf7HYEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBTBiHJT5nSqs0O\nQBnzyYYCo+ljMEHeV3POEUnHUKcXCgIgMMPjH2CN4BC6kdpofRBtjoMY6XvdJKD4\nxUovwDB5Slc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASJQO0cjkpxr8B5So4g97W0xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmQ5OWIwYi0zYTc4LTQxNjItODA5NC1kYTZhNjUyYzQzMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8miz3xjjx/XHqGEJmuwv3dowb8UkUESm8J+SXuowd1CUR\ngm4UrayGh7z/DTfMPuulPTVIPVRKg8aPYTS4C99to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrd/aIfALaFhFKu+dyVP7Etf7\nHYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOSXN8WUAmbm/hPRuhIrVF9jF6Haxt+dQdRL/kwcDpEMCIDEUsFi1cmr8\n+4y3Yeh5mZTxLcMogJGg7XV6KyFnIeUS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAeDiX/9QixcjRY2WWGuj172yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFiMjczZjUtNTQ1My00OWIzLWJmNjgtZmI1ZWIzNWVjNTdmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmUzY2E4NGMtOWM4ZS00MGU1LWE2YjktNjNmMTE1MTU5\nNzk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuVtfeQ/srEk3AiiP7Cf0Itn1\ne88tkXx4TiFZN8Ipr4PX7mpPxxeVYkZ81SHyI1gdxEE87r8Sni1x0gQdHy+oe6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuslWWYAVfEx+Tln2EZVuz5zpnNAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgNZCzLR7L\nWCB9Iz+8uuwSaAnMfhgFF86GJrSGTN2zXC0CIQCUfuffH2NNVkK6b9cZUl18uS2q\n1phr5P9kz13zp7n4YQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6938", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6938` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYGG9M3/2dx9I/ArJEwS896dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZGYyYzU5LWRkMWUtNDBiYS1hMGQwLTM0MTc3ZGRmYjdhODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMyODYxY2MtYThi\nYy00YjY3LTk4ODAtMzU1NDY1MDYwYmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPoYO17fjz3rvk/oDqyBk599ryidJjbvPQtV/dDvetWiExEGiRXuWBAbYHZxi\n7DnShH76DNU8LSTfvC8e9FKrRKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUrdn8WRdOo4cr2CPZ547IEay4iMwHwYDVR0j\nBBgwFoAUEAw/7Gd7CwYF5t4GF/5jnRDsqOIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFeEiSwi5n8QvgAK3em9uLMOQnG5d9b5eOjDZbSvV4o6AiEA08F4e3AJ/Av7\nN99GdzSmCXLXhuurN3AIltWMidByOX0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY/U9yPfE27jAODtjnuOprGVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmRmMmM1OS1kZDFlLTQwYmEtYTBkMC0zNDE3N2RkZmI3YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR64BCw9jQqiLIF6PIqgY4WXUqc7Lec7KtzF3Y9WeE/WKOC\n9iels2NgXqbLJFZC5M+YjCr2FFMMxfoquZMVTRmVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEAw/7Gd7CwYF5t4GF/5jnRDs\nqOIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPxKeueBSZ5FFurEad7bb9HxuU6pUUWhgpEF1M8as4o9AiEAsoP4KKyw\n2qIk1fY/YNBYr1Vr/bq5Oedn6Q3FhjtcZgo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZ3V40yDZrNjAUGXgQDSSkyxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMyODYxY2MtYThiYy00YjY3LTk4ODAtMzU1NDY1MDYwYmIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTc1YzBlNTctNjdiYi00Yzk2LWFiNjctMmIzYjkyOTlk\nNGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKW2xf9H4O7Y1mkh8TIwiVMku\nvdF8WjFMRVEV8ps7VVG1YcA/QOcf61JiLobeeo81CZkyvnm326UIwV1LlHP+maN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUrdn8WRdOo4cr2CPZ547IEay4iMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgNerzb2Wd\nRXF3DXXuLj/raA4gjBUjzXwilJ9Nn+8xtn4CIQC9QJ3gIWuV089TS1gkd3VRWTIU\n7S7NfPJkIa+VAKSGqQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6939", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6939` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVbh1PBQd7FhqQ0pUOZiX5d9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjMTYwYmIxLTc4ZWQtNDZlNC1iNWVlLTAwMmI2YzQ4YjdkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmYzMzRiNWQtMTYz\nNi00ODgxLWIwNzUtYTRkNjIzYWUzNDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPTeOKlXQSG+s/n40mOx/tR/O7wK9s9XlD1d+cs3ntrY4iekD3l1Gv92tC2fX\nv/qx9w7RJfV1PUygpIO1ex/AF6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTiGft+i9zfDbiUEBBbEeaMyDL4QwHwYDVR0j\nBBgwFoAUnT8Ih/lZK71oci/nKc+G1GPlVyMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCu0uQzzsgqhj6if0gWxhkdfv29g/dX8orep1tbP2+pdgIgcd1cR4ldHn0f\n3xeWzhHL11jTs4qlsNITCD5SadzI/lM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa4OlF2Uc688fvyMmPB1/gHHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzE2MGJiMS03OGVkLTQ2ZTQtYjVlZS0wMDJiNmM0OGI3ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpkrfCfP3DvSm9Wf6FBKsw2LAz1i+QDXXDCLugklNhvMg0\nbQ2/IGFYh1NS+wsBbY42GlQxF3iu6dm3YB8ffB78o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnT8Ih/lZK71oci/nKc+G1GPl\nVyMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBMKjEuNHXXEii4Apq59MbvhTyyv2BgoVS6eTjTBhWpwCIBPBz0L8Ek9B\nemz2l3XhWU+V04tHWrhFzRy0oYzbUFjW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXROzWOCyO7mxcKnwNlRoIBhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmYzMzRiNWQtMTYzNi00ODgxLWIwNzUtYTRkNjIzYWUzNDcxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDNmYWQ5YWYtYjMyYy00NGY4LWEwYzktNWY0MjM2ZTUx\nNTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEau6zqWOsKzPs67QS/Z8w3BD4\nzt9mGwtP0Ujefhppc4crShdVuVcTGLq5VThXQIrkG3zFTQe9pkrfyiR8xWKoRaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTiGft+i9zfDbiUEBBbEeaMyDL4QwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJy8RGU1\nWvWB+UZGhr1xvvKxADphUegXBZ3e4opq+utxAiA/icav0wjwDnQfghdexoNI66Hl\nTjN90A0yTpcL0fypRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6940", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6940` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAakWYc4KsCvS2187HVYFc1oRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkYTBlYjgyLTMzYzctNGM2My05NDAwLTdhYWZmZThjNWYwMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg0OTQ5MzMtNTg1\nMy00YjQ4LWFiYzYtYWVhMGUzZTA3Y2JiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvwR0fHhs1Caip8J3jn9QKG7yxSTo/6OKy+CGU+SWlmoMZRVKH4YDH3pusUVH\nmCIlEj7PMtB6o+XsKPGttXr5TaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYL/yhDNchosUCtKYIZI9V6WBom0wHwYDVR0j\nBBgwFoAUkARnWFUxyt4EzPEDVyFbcp6x9+wwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiA1PGVu6RbA0kU1HOBLPt3FCqub4k5Wi+tzrwKeNh5rygIhAJEn3Tn7SbTS\nKi+EDhi1i3jH/rXs2FWUqHk8o1akfvEk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcIoeOFXO3fqtDnfPLgjS6iwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGEwZWI4Mi0zM2M3LTRjNjMtOTQwMC03YWFmZmU4YzVmMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnLFukVvh9R/PlWYRi9LwLuuFE5uq3FA6WwUdp2wQ7Np0E\nuOCBj9kAhl6APznQ0o6Dl2PLYMKW+dXuJqsiQv0jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkARnWFUxyt4EzPEDVyFbcp6x\n9+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdbGJWgWHmU4gv2EiPlQjXNHo6ENt9h90FWhOo1WVDo0CIQD5CZc+gFBi\nMuePpQq4hPTsap4pJGUAj/cWlC8vKfRnjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAeHERn1TApOw0O6F4jPKV7a3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg0OTQ5MzMtNTg1My00YjQ4LWFiYzYtYWVhMGUzZTA3Y2JiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWQ3NzZjYjEtZWQ1OS00YjgyLTliZjAtZWU3MTNhZmEx\nY2IwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOnYZWFM7WZekpVIOL9pfjct+\nGdZf6Gj26M6+InE10+mrQzLwH5hYXY9O38sBjDssWR59uO958XQlXJ0cX+pbuaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYL/yhDNchosUCtKYIZI9V6WBom0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgT1s+TgYR\nwTu+omxhkbY9mAEIO9aJtCKFrtwRw+2E7sgCIDvg3/jvcdO1qWYdTf6tPfiQZUmV\nUH/DjAqOlKKYz1+C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6941", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6941` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAc6+8NcWTbEDjn+FYuizshg9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxM2E1MjMwLTc2NjQtNGMzZi1hYjg4LWZiODZiMzFiZmE4MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk1MDM5NzctNTMy\nOS00YTA3LWJiMGEtNmE1NjQ3YTFjY2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYxucpYWMiLwSG0A2rO7SUR+dZTnXM+GRIJW9VQmgEvbTGfFOvJ1JduuArfLp\nbY9V+nWFEhVWwAlYWZWteEVOzaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUHnu1MWAYPB7P+TIPx1cxZ5N7BQwHwYDVR0j\nBBgwFoAUqTlt3AxZdRWzhRkDvfTuT/t0Op4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBxBKy0tiA3ughQ+6ZntcFnTCe6lZHeOMs6Jvzpvkj3\nNAIhAPXVTA1adIdxUwm8JknEIvVBWuKJ7GNPsP/jHKjmfJ+r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU6E3DV/EIPQ3YQyO4WbT+1tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTNhNTIzMC03NjY0LTRjM2YtYWI4OC1mYjg2YjMxYmZhODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBNQAkulYzqhYUUFtayxC8Aw3LmLccDb4XfHSwphVcD0pE\nSGmmu469qpzMJ6w+xgH1CP+QOLl8QUQtSpSmJRQko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqTlt3AxZdRWzhRkDvfTuT/t0\nOp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOQXkv/jN3/HSH9e6mVxgiZysrWeXC9RO6kzZ5lICIJEAiAAu06/JUvD\ni0GtnKyJyFHHWjGwtGVot8vNYUEMRgIVBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUOARwtzshVW0f2IREAG6R90MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk1MDM5NzctNTMyOS00YTA3LWJiMGEtNmE1NjQ3YTFjY2UzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmY0ODFhNWItZjZlNS00OWU3LThjOWItYjI5N2M5NzY1\nNDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnih9fx1b5BdlvSMrkvIowWWG\n0KUVl1pOzPcEFNJjxY9wgRIhFn5/d6L5PsVKRuP5xQ1E1nPx6n08YK3CSulFi6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUHnu1MWAYPB7P+TIPx1cxZ5N7BQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAKyuGDFX\nWryjr1VbC07aurJO9J0/WQvdkw6ewkG/zTqYAiA4YIp3Q9OB+pYkm9LnctyKAHn0\nBXu6MNkvHdNp4LQepA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6942", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6942` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAee/PGQIWrdOyfOAqI/UwmPRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyOGQ1ZDI5LWEyOGItNDVhOS1hODQ4LWNhODcwMWZlMmU2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU2M2VjNzQtY2Ni\nMy00MmI4LWEzZTQtYzhjYjIwNTgxMjZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwfhQgYThlcHz4L5wRKbR1yO2QW3NjQhAe++aYaXYm9Hj0cpeq//NyRRoPZ9b\nCQD2HW2yhWycC8Jo39deA/mlEKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULmMQ08AND2SIZgrSh1YQRhQa1gIwHwYDVR0j\nBBgwFoAU/Sk737d697E2uocGRiOHauVkFkIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAQ0FQtm/ZeYAB7/3EYkCqBarCWaraE4YeLS9idTwkT\nygIhAOXdhYmbfCZgEMskBp81EiKXxirWoxmethY2FyR93aFo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARJs1fhMPG7s7OFR7J2KqZt+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjhkNWQyOS1hMjhiLTQ1YTktYTg0OC1jYTg3MDFmZTJlNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRnL0iRuwC11fqolHGiZmPmmjh1mSDLXyyWmofgTP7vFAh\nyT1za+6LDn2gs7nFp8LhzgEujDomYzCX7Tn3s4Geo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Sk737d697E2uocGRiOHauVk\nFkIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLsajqCrrjv4EQwLx8H7j9Ss8XabSRXPHiG0nh28lKkgCIBGPjJaxE60X\nfF0xxgtdaGEAulw47CCc4wlhZHRwnu5y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYrFpe7uQ/Ftu08n4a7YN09qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU2M2VjNzQtY2NiMy00MmI4LWEzZTQtYzhjYjIwNTgxMjZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDVmNjU4OTQtODgxNy00MjQ1LWE4OTktM2IxYmIwMmI0\nZTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0tNQlccWp/eJo53N/bxE4+u7\n9y57AKm83QL36lv/97Pxx0PBFbPctXu8qsQt0/OpqTvhp254bKzKihUHtFAwn6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULmMQ08AND2SIZgrSh1YQRhQa1gIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAPZLsZXr\nLVxwNHbAPJ6pJat1IaOdlRQSBfrjGLNVMyhzAiEAujI4mjQYTsG32bRCpK8MsBvk\ngfOc4mFNPK+5yyt4WYk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6943", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6943` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQY1rMYhI6iu2Gj2z324HHIbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNGU1OGJkLTZlNWItNDkxNC05Njk3LTVmNjNmNzkzM2M1NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM1ZTI2ZDQtYmNl\nMy00Mzg1LTk5N2YtNzdhNmY0MDkwZjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/5ntfPMWiYV9MUBWd9QhfF2HP+UQdugim9YwQ1w/pD0Y8RxsVANdLsCH/CY3\nffbBUPYNEWtH9ZPBQeu71R7O+aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhT5RqSUOXr3M7d34+CjhciDXHmowHwYDVR0j\nBBgwFoAUN+5RL79Z3UVeO1nSA/tdwfvvgB4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAhGP8xvBDumjlzuRDchzXMYunxcyH83bdLd4R63d2fDYCIFZm\n3eCWAkON1cKK/t2kOdk4txk14l7CAuLSu2nTewS8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATYHqAwpXLmbwZMcCsnCYV0hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTRlNThiZC02ZTViLTQ5MTQtOTY5Ny01ZjYzZjc5MzNjNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToet4zA/dcngcwUpKBXrMrOkAB00S/DICFnTxFDtvHBkks\nGNGH10aOiItsuZ0j9FZZinw+oMMdmN0yPPni8BPxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN+5RL79Z3UVeO1nSA/tdwfvv\ngB4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgayLKvuxXfwS9NBv/LqEhLv0FsQEcDeGpTAXY8eR3IN4CIQCFpU+TZR1Z\no4xX6xVTsFPW6aE/n8hRfm7XzRPNL9eDZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAd9WQbTFU6GHvcNOFPHFIAxqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM1ZTI2ZDQtYmNlMy00Mzg1LTk5N2YtNzdhNmY0MDkwZjExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjdlOWRlMzItNjE2MC00OWZiLWFhMWUtMzk3ZWI5Nzhm\nYzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9ZO+wSRt4s4oJIQEKpYGPl/k\nzw6vwGOj14N5U920gMz/4J5Q6/Hs2iLRDATl0TZ5cG8uDfD9cw9Z+8QIBFM9TqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhT5RqSUOXr3M7d34+CjhciDXHmowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhANwEx2fP\noV0C3SqVp/e1ArIWPZiIIacDKQYHN6pGWjArAiBQCntl25/TVCHMCCu/xDckH43X\ne4mlgCuz3ABna76bmg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6944", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6944` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAYl7LKRkc4WeZQJ+4J163z+vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNWRlMGZhLTdkNjAtNDk1Yi05MmVlLWE2MjIwNDViMzIzOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQ2ZmU3ZmEtYWNl\nMS00MmQ1LWEwZWMtODI4YWYzZGMwMWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECpjQ3GSXu96SwcRxro/lEeqFsYR53NdsNDNNrDozd6qrQVfYnDwAxypFlDdv\nYUBQydbYgAeVR15/V9M/k2QpRaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVAwMXqjlPS7jYLYee2QUiA4WRWMwHwYDVR0j\nBBgwFoAU70e4M4LlanQwyGph1ceyjL7BV+gwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAfOoSNo+I8MtY9DcZ0ywWVN+vRk5mueQbk\ngruZhUVI4wIgWG5RS7MBfwZEYja9tULoP4+5EC/kX/YvpinTeix8lK4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbXFJEoFYuzmhKP0gqcFZPCmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjVkZTBmYS03ZDYwLTQ5NWItOTJlZS1hNjIyMDQ1YjMyMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq6y+H7SY5eyHqvtIuOc17QAFNuXTEu40KpFSyWTKvUR/z\nvXz0Enzj1/HJsrAsYLn80qz3JaGggawyvDPpJ0pOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU70e4M4LlanQwyGph1ceyjL7B\nV+gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANpua/pc8t1Iasb40zXgVcodOoOoESvkqEs5oNOoFlrLAiEAr2KLL/Wd\n0oCCgWwliQJmAmfazqnOwXZEv2RPT7fnEE0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWjqytjzlFzoFFJPdX3sE6ZIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQ2ZmU3ZmEtYWNlMS00MmQ1LWEwZWMtODI4YWYzZGMwMWQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTQzZWYzOWYtOTgxNi00NDI4LTljYWQtYjllMWEyOGUw\nY2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbO3OUDYBRlkP0FUbznLxZX3w\n5mkj1ELBAkb1slKTrWRZUzTI5yz7th8LuQcGTf/R6wCUknbK0KCqNfumrS7LRqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVAwMXqjlPS7jYLYee2QUiA4WRWMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAPSQyvS/\nTIA3TXF6/AbA+LhDeBc8HNU/j8RimqVT9Cg8AiB1towTvidfLtveM7LXOD1F5qSm\nrkGjETpAEQ8aclaJnQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6945", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6945` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAYIqXcvZayHIUmmHxu3ddQ6jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxYzYzYThkLWMzZmMtNGVhZi1hYWY4LTJjMWE1ZjY4NDcwOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI5Y2E1MWYtNmVi\nMi00NzUxLTk2YmMtNDE2OWJlNTMwMzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcdlhajgeLuvOWbyIB1bZbd3w0jSsMPKNa5Xj8y6X1r2pLswq6MxYzFuxEvT/\nQgFXa9j8wGVchgn9CK6iq0qovqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh+nUuG7EUbGUX5bUVnrpSx9k8X0wHwYDVR0j\nBBgwFoAU46oqXgpqquVMLaZKoU3exEM+5bIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAmtSAnzzRYZleAD7EwTRJqDOPObqniCKx\nDojTi2RemGcCIQCka3+zRKQCDdXhSVp4kYRW7VICv2W8OFNIywsZ3rBHAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAab8kUdvGc873b7y2/+8zh/qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWM2M2E4ZC1jM2ZjLTRlYWYtYWFmOC0yYzFhNWY2ODQ3MDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVa6ll7Z/+uVQjzv/mhkC1QpMZmeIQlTk7zoaVRl6nNr+H\nU/skCQCEZZsa2WcaYsBGKEPPGe6nkse6xeKVBY//o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU46oqXgpqquVMLaZKoU3exEM+\n5bIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANKX6WJN2lBqWYGF9WUhhdqalnw+96fbRt1xzrtkEODTAiARknWnSt97\nLrxk7xK6SPGGylT6+grPZxjzr2EzlzNajg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARizui7JICY+BQnBcFVfeKIQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI5Y2E1MWYtNmViMi00NzUxLTk2YmMtNDE2OWJlNTMwMzE5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGMwOGUyMDctMGI3Mi00YzA5LThkZmMtNjk3NThlYmRh\nODlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5iLZz7wn2AaKvteHeIdtdwd4\nlWebxzZK7wO+p8DzFSosKfaZkGQaFBWb7OU2IkYiXr4dmbvgcXj43PbzXTpKyaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh+nUuG7EUbGUX5bUVnrpSx9k8X0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgJX4OEQK8\nGu3L9787syL0K0xSKblmv7n31YcyU6+8kbUCIQD5lZA9r/HYciBdd10Ev7X09KuI\nAehaJ0IFAa105pP+Rw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6946", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6946` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAX6Sw2fdJROk3cpuA8ciN/3bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMzRmNGNlLTA0NDQtNDg4OS04NGViLThhN2QwM2Y0YjBkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU3NzhmYTAtNWJj\nYS00ZDE1LTg0MTEtMTc4NGMzZWNlNGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWMRkZF+A6tHXBeNNVUlDIYZMiK+KVWExSIelbWrqhL4mpHazrFFpLZDkX04C\nVqFCQKA8umEA4Npk/pWXRxMjTKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG05PZKcGCPsMjgm4XoMXa0iCztIwHwYDVR0j\nBBgwFoAUqukfWXrYQ8G6txhR5Qs+XUqvTXEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCjt6akGTz8HAr/FrOU2NWRntO/\n2ud7A5eAzsvZaSkFlwIgEqBd9I2jRK/Nw8Ta+YCRc//eEh6p4wkq58+tFLUhuNc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY4qBRhyFKtEp77oSSiSKj+0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjM0ZjRjZS0wNDQ0LTQ4ODktODRlYi04YTdkMDNmNGIwZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3OSfP6Lwskt7A5VpqIOOJCd7hCfssn/YhmoQn1lh6ag9k\n0CfhT5ghpp9Y3qp7PLV0JiKeoftILeBP309dSG5mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqukfWXrYQ8G6txhR5Qs+XUqv\nTXEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQwsTvR5V8dTJaw644IUvVaEwpzXdHkSASRoN95mhzDsCIDMgR2GJLOH+\nBeF4WKJSxJBKGA/RgP5DLJOOW4pV+5DT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAbLPCrfBBhhKD9lHAiJIXDhvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU3NzhmYTAtNWJjYS00ZDE1LTg0MTEtMTc4NGMzZWNlNGNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQ1M2Q0Y2MtMDhhZS00ZDg0LThiYTctNjdjMGU0OWJh\nZGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6/LL8x3xJq0uHt+6Ijvwqjuu\nkCSF9Nt5mdcBMQPrgUXYgknS6oceMGv0Z2PEVbNBo8m44neoUjLB5FPw9RVqpqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUG05PZKcGCPsMjgm4XoMXa0iCztIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgViVWKyHD\nblL8AKBfWLokr8+TsY5cKFePxuoAwJhmm7sCICllxYIFkCkWNkQ5c7msTOkM/Cw9\nF9Cp2PXGo+dDUJ0E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6947", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6947` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAYKDDKC9ZNUlKczVpSDWMU9FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1ZTljNzQ3LTNjYmUtNGM1MC1iYWRhLTFiYjVkODA3NzRmMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI5Y2VlYTctOTNk\nNi00ZGRiLWI1NjktNTQyNDM3YWI3ZmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDHkpD450/RKYkoWDLz+d2Yuxm4g1AnXsGea81h3foGTryySaSI9oRrEaRhu5\nv7Bh9O0h9b++B+YrrA15kDL2EqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY6S+yj8T9QL5IGH2AdE/BwNte0swHwYDVR0j\nBBgwFoAUekOttZ0imExeQ3Ci3dHnsc6ehMUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgVPYGXjVr\nP13IUq2b25Mqq9lhb7XC0r8kt+BchM1HgRACIQCRPdYiUi+MoHwZb0spd830xTof\neEqadgYzBAbYwB9ztg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfSKWxxbxQHlfR5PjiO5J4ElMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNWU5Yzc0Ny0zY2JlLTRjNTAtYmFkYS0xYmI1ZDgwNzc0ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARv335r+mQi7zzFn0ybob1WY3ABhky3hk64bZZLrRtMeAjL\nxAodBMakKGl5EHR3yR22XNle4E0yb7pWu0hSq4MAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUekOttZ0imExeQ3Ci3dHnsc6e\nhMUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBqoJ6yn5j7s/jibcXJCc1oPyJNsepqWSwGmBvoEfZCwCIDGYzEvsOxiE\nzJcIck3J7KBP38Ml9+F0rh+qxebZf6Vg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISARQTfZpxmbaPSALfBBY4PUY4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI5Y2VlYTctOTNkNi00ZGRiLWI1NjktNTQyNDM3YWI3ZmE5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzczZTRjZDAtZjIxMC00NTgxLWJhMWItN2ZkNDE5YjRh\nYWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgV/Sf7XY9zlgQkGQmtezBl9n\n5SFAG5lNIf6XkuFavAR9FFLk80U+VcCgJ9BsFrCTyOz2q93Ff0Bi0mfwPfjqwqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY6S+yj8T9QL5IGH2AdE/BwNte0swHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAMOS3QEH\nJtz4f/w+giSBDwU2u2Y8sgVEFFSQxEYaoP8jAiEAj2a2JHFcvaksE3TX9MGufPCA\npcOrOZOUZpzPNyCCeVY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6948", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6948` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAch23yCc4RqDcKSWJ1+/Z5FTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1ZDc5YmZhLTg3MWQtNDYzZi04MThiLTAwMjhiZDIzNjZjNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZhN2M1MTAtY2Uz\nNC00MWI5LWJhMDItYTViNGI5MWQwZDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8Zd8kQ1ZfLr2sbU0tyaLcD6OZvTU8OGdRurme7oB4InJXF+zxE+EbqWgjoim\nla3A72ui9xEn07kNsUUggwSIj6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTK/xsviW4BqBM0bGcysfUF0lt/swHwYDVR0j\nBBgwFoAU7sI76E1VjsEoadlezHV7LWs7t8YwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIM6lRWL\nSZUvrRZAUHJkhioYDcHaRLhpS3tlDGSWNR/DAiEA6hcUFr/zFHcpnGHAkutBLKSv\nCqxaD9EG5blkydLkx2s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQKU4hcyJFPH2p6AW+xauXIUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWQ3OWJmYS04NzFkLTQ2M2YtODE4Yi0wMDI4YmQyMzY2YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6+aaCxjKc/GpW2TYwhm9Z+Z2iS/9VKF6FE1BEWtPwj07M\ntW9+11VDuZILRxZY61rFlgdWWWwxz9lolJE27VoXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7sI76E1VjsEoadlezHV7LWs7\nt8YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ5rBvKfNigw1I5LVav7pUAF7kBPrEDWwAg9x2KAgwOkAiAC9uCHcscd\nvgezuWGhy9SisGPVVGacHVP7Qh2tWHRv0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAR4zEW+2KIP8/VqBZdxs/ThMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZhN2M1MTAtY2UzNC00MWI5LWJhMDItYTViNGI5MWQwZDVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTIwYjI3NDQtNTQzMS00OWE0LThmYzMtNjE1ZTIyNWUw\nM2MzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqVpLzeobSQWqmmFPpneuKElX\nsKPderRMkITjrElV55oYRf4CHt775jQ9sCUuD5ocdmcNHJ4eL30I56VVDjEvraN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTK/xsviW4BqBM0bGcysfUF0lt/swHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgZNpKg1uY\nqQSJcZL0lgKEbV3pgzB3cWds76OG1wncSOICIQCXF+K3KtevBi4sUq60TnDL6dUg\nNkTrerygJ21aQjUIPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6949", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6949` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAVxNOgujgr9kkJp9tWuD5nMNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3MTgzOTk3LTk1MTgtNDRlNS1iNjI1LTUyNzI5ZGYyODczZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjgxM2YzMzEtM2Ex\nMy00N2U1LWExMjYtNzAxYjU2MWJiMTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExpP3Pc5QMabfVD922XZg6ec5cMxbVrAKPCbncIsef+xSGW+0WjpDXzk+QpkX\nmLCLLl/zgluKI1n/RvzcblJnO6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsgtMpmrAKXhyLyQxA7NZXZGW9yIwHwYDVR0j\nBBgwFoAUjtdxNRiznF2jaNqwV4r66LRZgB0wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDBiYaX\nNCIC87iXJREuFCqDvoI0V3s+yF47Z1vcDTtwJAIgHIdXBwmgNf7oZI/mcQ4ojhgI\nRIMRGMeKq5L9wKHK95Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcQQLlRsxdpm2xWUlTgHlMfrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzE4Mzk5Ny05NTE4LTQ0ZTUtYjYyNS01MjcyOWRmMjg3M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVPlP2HhQeLJFFwit/xnWvXbokzkCrHCDrYimm1o54+PZi\nXCs7S1biJu3gRI71ftMplKEqtjwtODo7azmb0erDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjtdxNRiznF2jaNqwV4r66LRZ\ngB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANCb/JZdxJgUuSXguGwDc+GsQb+JAEt63lnAK8LXkqplAiEA+w7R7Gzy\nHYm9FCIkj7nDVzgBxUBzQkzE2lQqLd4GTH0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZzaOSvVPdSrZfvZFFlynaNiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjgxM2YzMzEtM2ExMy00N2U1LWExMjYtNzAxYjU2MWJiMTc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWYwYjliY2MtODMyOS00ZjI0LWFlNWEtOTBjNjJjNjkw\nMmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYgfG8PbI1CpztldYVF9vjZlc\nThjvx1yqeratnaKq6pSNRhCVe97OUuIPPcN1QLFEah4mTSsarzsLYo6SA/D/mKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsgtMpmrAKXhyLyQxA7NZXZGW9yIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAN5mZJSf\nZBED6TJSs8wWDg2crL/JbHm6ARN8vkxR/1c0AiBBet3Pekj99IKbSNJ6bOicsYKA\nQb6PsIp9DNRJlbGEAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6950", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6950` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAUtbO/l3JZesT/trJ0V52i5oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhMGMyODk1LWRmNWMtNDU0NC1hY2MxLTBkMDQxN2MyNGVkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk1NmJkNTAtZTk3\nZS00ODFjLTlkZmItMzJjZTNjM2E4NWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECxbGdSgdJcN0erw/E2/aYd/+3ivDeyF5zBBL/gKJsVEEJ94njmPtmcNGuABS\nC6FTHAqs0Pg4ZC+gwONTWPCOUqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqNyfW7n1nqeZkXJsOs6GoG0GQrYwHwYDVR0j\nBBgwFoAUOMfI5x6PpV0jP5Ug4fmO+WZnGSowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCB2///H+ndhnjUJrm/6DCyLp2lSzjUvO7yXLqZtShtuAIhAKcD5kIt\n3VmDfAbW8w858r+u+j2iV5Zdm2zxjOSKvgSi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe08Lj0ndPg3Jie8x/hgcYpDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTBjMjg5NS1kZjVjLTQ1NDQtYWNjMS0wZDA0MTdjMjRlZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2id8ccLT6/WxvyK2KwhLXHrnFv8no52IYBHSki0avJMmU\nKELycVfIiqlva+WImwf/iXPe5lzkr/XUp40mzZSKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOMfI5x6PpV0jP5Ug4fmO+WZn\nGSowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMssFc2F9ddgUbmX3hkmqYFKGx7yn2LmutMTirtsC4RUAiAtCg0f40IQ\nhJoTqzeRj6G6WCKGh2AFQkXvwk+yfEnD+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAXeAeIcwKR9t7Zp6PDTdfjgTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk1NmJkNTAtZTk3ZS00ODFjLTlkZmItMzJjZTNjM2E4NWQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjJkMWQ2ZmMtNTY2OC00MTUyLTlhOGYtM2E2Nzg0NTYx\nMzZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFyYtnoufijuKNyc1iCSUdQq0\nzS8H2rfdQ/fQRS8MzV8H4TDJ/plwr4eEq2XVU5UUvsu03/roD053jUcJ/IRB0KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqNyfW7n1nqeZkXJsOs6GoG0GQrYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJLFghXk\nOuoF9Hyz20rCl2QnIMuZ5CZLQ+Y+OtvF/pH0AiEA9bc8e1mq5FszQWt9w33G7L8U\nw5iuGZTSNe7uXV2KkSU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6951", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6951` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAag9jwPISGqOxudd6IHUVEF9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyZTc1Njg0LTk3NjItNDVjNC1hZjNmLTk4OWU2MTI3MGE4NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYxYjg1OGQtZmFh\nYS00MWQyLTk5ZWMtNWYzZWNiMTNmYTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+hMkwKh75j45KzUOwE5Fq2K1hQ5EJ47SPCPx08tZI4c0i3f9I5AvAokHsBPY\n1gUOP1DTTdRn6b4/lR1lUnR/JKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBl6Nq51e51zMFlCkzSyYTGZtJ/swHwYDVR0j\nBBgwFoAUIwHpJgAE2LFuIhVrRZ9Eh8DdKI8wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIDNtNmezK8r54tqyzfYrtIZh0F/RxAwNaSA1EfoeCmtmAiEAgbrdDu7I\nlPau6L/YlK4RhwgaEhbRpXVHAkYl32gktuY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVX2Ddwc4yZzYLFQCh4pA+6xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmU3NTY4NC05NzYyLTQ1YzQtYWYzZi05ODllNjEyNzBhODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNI6Iz5ayWsNdZarW7GbHudlFi7SE5MbW/3NvQzLwlekkp\n+2LmKgBWnZ2ZB82Q1BmtWM5nvRPXl0IWqrrNmivSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIwHpJgAE2LFuIhVrRZ9Eh8Dd\nKI8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOIp9SXKrm/2PbMq/POvTWqOuAie2XPAPy4PX3/4lIavAiEAuGw8AeMu\nJ2ZG81VmahLWfu/y46bk+G6nmQBK0QQztW8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAW7epHisdhk8xp2hmbOMD+iyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYxYjg1OGQtZmFhYS00MWQyLTk5ZWMtNWYzZWNiMTNmYTQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWZmNDYzYjItYTQ5Zi00MDZmLWFhYWQtMDJmYzU5YmJj\nMDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQWc/cuCP/f/bESnyxwIorIR1\nKwzkPJRzmbU2RGOnm274jBqeveXbpCVnfzewUiWwR1V/SB5FSmCEYVe4WlBE8aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBl6Nq51e51zMFlCkzSyYTGZtJ/swHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAJdoPgCk\n67Vtj6OJ0gqhvl2gzqcvuf9lVDUkx+V2NhkGAiEA4CMzZdrA7wDFE2d0vAvEReHa\nc4ldgUqYLGlXjAOUSRk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6952", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6952` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAZAWLf1pSPkYV4vf3/HIVOI8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3NDg4YmFmLTIwNWQtNGEyYi1hNTNiLWNkNzgzOWJlMDYxOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE1ZTg5NTAtM2Mw\nNS00MjcxLWE3ZGUtOTcxZDYwNTI3MDdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExKHZAc6ox66fwH985L8kXSRHUId4YB6ZdIekiNJ/BIQrKoCHfzzfOU0B0ZzN\nj0agYt6RZPL/mJl0s8dAFwULvKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTM7etuUiHv5nZXCwJ+uDIm/P5S8wHwYDVR0j\nBBgwFoAUb/AmBPCa/vL1cb5o2PJ8SRIrxYUwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nICHL0gr/ATe00OFBGpqzE6XAT1Psssx6TJGdFeDB1e0KAiBBSdl+1s2FJe3NIXMJ\narz19nihljecLYrTd/cDAxW3xg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVJf1bMvceaYdZEQXqJjV0LAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzQ4OGJhZi0yMDVkLTRhMmItYTUzYi1jZDc4MzliZTA2MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCCYE4aKL6gs4bZuecyLNjWuk2h18k4TlLKMuA8KRryZQi\naLgLpaRLQhUfxAtnxI63NAX9QdNiNIpWRB4cWUggo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb/AmBPCa/vL1cb5o2PJ8SRIr\nxYUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJOpZVXBYVylP+1bzCZMK3gRmjuwzeLmVmWKiBtGgXqOAiEAkHOZU4QE\nMNLxMvpe8bcx5ukBxJ1SEvpFfH6ZtnWndwk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAcPgoIkq8pPn4yV9vWwNjRFCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE1ZTg5NTAtM2MwNS00MjcxLWE3ZGUtOTcxZDYwNTI3MDdhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjczZGUzNDAtNzQwYi00MjJmLWExMWItMDRhMjVkZjc0\nZDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6P1XoK1G7Lkqetzf1CByMPtJ\n+Od4jzMC4FwS0waUcFpfjJ94V5VyoTQuCQpd4Lgqr1ieNiVWOm8u49BxZR6Ef6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTM7etuUiHv5nZXCwJ+uDIm/P5S8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAMmhP5hK\nZRLhsq+pf1AHZz4TTEwO/GIFCIOvjFt0EH/5AiEAu+9neCb/vltjXmaFfGnjuY0R\ntTv8yXMylmYJw+f0FVg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6953", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6953` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAW54PL3+mdjSSQmwg8NZFSXLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3NjQ2ZWRhLWQzNDItNGNmYS05ODUyLTljM2Y0ZTY2ZThhZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTkwOTQwODMtZmZl\nYS00ZTgzLTljMjAtNzkzNjExNWMwNzI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzefReb3ct2hl1C0E2Fs1tWngOBA78YbbmhDqMyZNmXPT96dTC3vz2SQo4NZE\n/DTEOT0HTePM3ZpiUuFRkPkafqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmNtmbQlea0tRKj0Gr/oPYfbFjO4wHwYDVR0j\nBBgwFoAUDMHokMEY2HpE94WLIIaZlSMPriUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIBi4K8NA0EqBFRzMzUwjjEY4CHS78zxFeRgKvePZ+Ju5AiEA\niRgKMkTw8Ql2UMsT5nE+QXg+5Y5XWjgXqiN7eD8cjks=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcmVgSjgFLF8ZvMnuSY8s+3OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzY0NmVkYS1kMzQyLTRjZmEtOTg1Mi05YzNmNGU2NmU4YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARi05fsq92XdHQDyhAJI/oWIxowU0ywDcToBOqgrcOS8LVT\nI/lPOdYPDMEPT538Aq+9/Xt86TqPHpw/Ul1IGWFfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDMHokMEY2HpE94WLIIaZlSMP\nriUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANoMmZv17jym1hIjSGy7tbEPt+F6Z9hozwsAgA7I8230AiBtxKWVWVy2\nPeT8CeQuR3FW59iYAoMbCnDSC4sGVXRxDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISARNa4I6o9C6PwmL+siyXH9RgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTkwOTQwODMtZmZlYS00ZTgzLTljMjAtNzkzNjExNWMwNzI3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTgwZmM3MTItYTNmYy00ZTI0LTk3MmUtMDM3MTM3NDRj\nN2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzHHR46roxYgov+xqY4R3VP7R\n36pn5Fgwi00tF3GnUvGjRAjSexE30dPYXBhDHNJTjH1ul6FXTV4hmjuNcjwNRqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmNtmbQlea0tRKj0Gr/oPYfbFjO4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgO7OFlNXc\ni+769nRmurVCFuTnYF8xe9tag1x3+GjlqRMCIHlSzd/rJ1ryLCL27zkdn/7CDRBC\nqsDfYWBpRKNdIEqx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6954", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6954` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISATn31/izBSYRgBTdi7wEnPDBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3ZWRlYmNmLTZjNjItNDAzYy05Y2EzLWQ4Y2Y3Yzk0MjAxYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q5ODZiMjUtZWIy\nZi00OTA3LWIwNWEtMzFmZDJjOTU1YTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGuPyFAeZ7s9rFzQYzeEsxZnGnjfvSbdKty4dp9mfDEwZs/fu0e8v7kV7/dqm\nrjukInkWSNybNol1kp1W0kl53qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlwPPl4gHiMyomudYapYErmk52JIwHwYDVR0j\nBBgwFoAU/NLabIbd/ngxqCjQ7hT3x5hereIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCID1ThUCKM2z/CTKn0x44bzBmoPzq9rlicfYJ/mC8GbDhAiBD\n186hcMGQluNh59cb1rAN400EPW3gevT97Luyx/turg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdmxJ978JTVQtUJOuEdgd/2bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nN2VkZWJjZi02YzYyLTQwM2MtOWNhMy1kOGNmN2M5NDIwMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCoha53XCEub4BdHfTR7qY6ob8ZeXz8OHubr264HQQkXOp\nCjZjsp7OUJUSy+aAK0TMHeoVwtOFHR+QhwN6/LPYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/NLabIbd/ngxqCjQ7hT3x5he\nreIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANCaWcPb094EYon2pqN9IpJyN2un5g9nDIqu6WiE1aGmAiAtfMBuJi6u\nlGKmORYQMQgCox58Fr/ghXklwE5tsxmuvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAd/ciIh0vPwG3tKf8K7GgBDbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q5ODZiMjUtZWIyZi00OTA3LWIwNWEtMzFmZDJjOTU1YTkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTY5YTdhZTgtNWFlZi00ZjRhLWJlZGQtYzIyMDUzZGMz\nYTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAMlTLif2peZTr0N6k2luNp8I\nBcclmOJx1qyr1OIOG0iaopHkAIVepYQlAgYv+i/pxKjzNR+zv3pS377537AisqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlwPPl4gHiMyomudYapYErmk52JIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgeQlrLD08\nG8V/6TFqn2BuQ4+5BI4rf8zN3VMn9rWP+bYCIQCUJ4UC4ihpNDv3ikvv2jh3fD14\n80XFdaEJHEvnGXXz3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6955", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6955` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAfS8mR3CyoG7qeOUBkJiEr4xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4ZjVlYmEwLWVmZDktNGMyZC1hZmFhLWFlM2E5NmMwOTI4NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWE5NjEzNTItN2U5\nZS00NTcyLWIxNWEtOTFhYTU1NzY3YTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9gOdYcQScw13f7hePZLtSpAKnKIXPEolkf0yzUMT4Zkd2v96KgA3gU2AnedD\nQJI4A+Kz9RNJvzq/W7ZB6HhuxaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWR3aHVBNnuZWEyQayY3CxAonyFUwHwYDVR0j\nBBgwFoAUF5ctJkBO0wt0mFBVTFaXi+rWvUIwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCgol3yKpZa\nxbEPiqwwm9eq6xjim5P75nUGmxFPGQ0wjQIgT6J4AaYV1MUbodIufRRCIoOok4ox\nv3iU7q2hrGdu03E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXUD01vJkhwgZVMYI4Mfx3cUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGY1ZWJhMC1lZmQ5LTRjMmQtYWZhYS1hZTNhOTZjMDkyODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNLnpfO8pRXfAD+lcULufhtPvWvLF+Apl3Cd14VjqbE/F1\n88+p8rekcVBWwtywTdgGylWN38xYfIHM+YV34Jjwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF5ctJkBO0wt0mFBVTFaXi+rW\nvUIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDCgVyY0/fYkeqw+Olpmp+Q+Z/n4TPmzkTZyhcYFMQV4CIAs9npaWPkkX\npJyKAaMDmnhCEiI3Te7rt0Hfs2Z5qXOj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXrhtSN4GPmKzVHQRFR4kbfLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWE5NjEzNTItN2U5ZS00NTcyLWIxNWEtOTFhYTU1NzY3YTFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzY1YTg0NmItNWE3OS00YjU1LTg3MmItNzQ0ZTFlYjEw\nZjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXVCmcDInkTwMd77xISF3/VR5\nXE6eT4OPrgRRjlKxrM3Q0MU4Rd0OdGK6Gvi0Cb2suu9YDDYETFCCAH0iV4YHhqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWR3aHVBNnuZWEyQayY3CxAonyFUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAMVWofFS\nLx7OLKQ0Bc0rT2zGcfCo1gXJb8zK+q9auFH+AiB9CRHLHa6d26LTX2NIEUj9fjzm\nZoYUwq20QYenHZ9UEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6956", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6956` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAagfsUgtmNI1b3NFaM2bIHAvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhNzJjNGRiLTlkZDItNGMwMS04YWI5LWM5ZTFjZTk2Y2MzYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU2NTAwMjktNDAw\nNi00NTJjLThiMzQtYzAxMTgyNTYwYjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2+5cIO7LiBuEeWq7bzvokkvVHk1ie96lv+ykGHCu90r5sMwX3fNb7YCmOqow\n/dakaJ1ODDL/liZeuR9q4RXTiaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2uUhUJrUzoAjuafqUyn+eLOaix4wHwYDVR0j\nBBgwFoAUaZgQewTnCKdtgSwMpYFYxWXI0oEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKIokrSEq3BvBADleZ8eEIm3cFrDH4QakK7gOCsp0BCZAiBiA1+5sI7C\nnhn4linD4cFUJGjnaiEarb7rsgqPjZxC9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWZs5jlApPedyPOccs2nVNliMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTcyYzRkYi05ZGQyLTRjMDEtOGFiOS1jOWUxY2U5NmNjM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0MihiI8R1HGhLX2KQhyHaJWJb7VnrNnDv+zawVPQJm5G6\nsCYuE4bIOm72jyi2wLNtXLM7ilXyQX3C9Qnmfykfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaZgQewTnCKdtgSwMpYFYxWXI\n0oEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO/LWytIewbEbG15Pewf6fYYKMxGpsOJg6j69aw47qikAiBKc1gwOTV7\nXcK3GAVsgg/SgqprviopThpb18Gc/kjNIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYnsDKaBGt5oNybrB7AehTv+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU2NTAwMjktNDAwNi00NTJjLThiMzQtYzAxMTgyNTYwYjViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjViMGMxYTYtYWI1My00MTBlLTk2NjUtYzBkMWI4NDFm\nNjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwVMbw1WfAJoIqK8KcltPuae4\nKa/tToKKZvmY86ZkylQMmtm0Z2BXxonfoY8qO45+6TmNXLcQ4O4m/OVpYIvxAaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2uUhUJrUzoAjuafqUyn+eLOaix4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAJ6aymMr\nCgxkITJ4mtRbpUB6X3IviUwqLytTv5Xpwxc1AiBEAOEZrLGZPrGPZ9Jzto+kE3zb\ngfglO3uffkkwBxAFRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6957", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6957` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQyYvi53UJGm0U1bKF/y/Um8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMjYxZDhlLTQ5OTctNGYwMC1hZjhmLTc0MDRlZTg2YmI3YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNkMzNlYmYtMjY2\nNy00ZWMxLWFhNGEtMDk3ZTEwYmU3Mjk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECdAzEH3mQdbf6X3JBKJL/FNW8KETONT23JE/oap+EuDRUE02+JUFE1qrR7uA\nBoC0Be3N7rrd+Hg+eKNpLyi7fqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeWZkNo4lTXwj/5sAYGHpLXR5L1cwHwYDVR0j\nBBgwFoAUirb8jqZXyrWa/wukahdXlozwVa4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAN7cCk2g57+mC2P0pAzl4ZskvvIbDBzHBOTh2aC2jC5yAiEAj3BGnVtT\nqCWTDoxJHkQlY9anKMMpidx5zTLmrpHEYPw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe3+0nmQACYANt2jEphosld3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTI2MWQ4ZS00OTk3LTRmMDAtYWY4Zi03NDA0ZWU4NmJiN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFQX+pvJ4cWgpxARfjGcaMbpp9Hr6cl4S9WmcGhj9IkPBG\nud1GgHkhBnuEZ8Xb2vZXY+jW7GLLQVqoQLiCsW1To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUirb8jqZXyrWa/wukahdXlozw\nVa4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYdvn7HPmnYXcWHdIJIJSGBUbcgyYP2Tf30L6svi7xncCIQCyL+9lwO92\nhV3inISjRLwKvUwSV8Z0UZK7rrDkwtalqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZTS0ceVU+irF6BUG7drx/BoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNkMzNlYmYtMjY2Ny00ZWMxLWFhNGEtMDk3ZTEwYmU3Mjk2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmYzZGMzOTItNzgyNC00OTEzLWE1MGEtMzljYjljZjg1\nYmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi9YxcrUeWPeQe2fH/rk9YAww\nP2y9L18FzhwnDZ753zDtZMxmDRr/2SPbi1x1YNxy7WQFX3ByqK/qDofw+rmJVKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeWZkNo4lTXwj/5sAYGHpLXR5L1cwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgRQANxR7K\n0ShR+9Gk+Ejx6UWZ5aNEY8YdSMVZF2I5IkACIC/GLxevMJUwWigTQ2Cm8W8wxQxb\nOsKGO5xqKSxWv2JH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6958", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6958` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAYutZ58+S7lkbaLZQWv5qPy8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwYjI2MjAyLTY3YWYtNDI5ZS1iZTg0LWYxMzUxMmVmNzFhMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZkMjUwNGItZmE1\nYS00NTRiLWJmOTAtMmE2YzJhNTE2Y2Y2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5S4QUbv8PQuW7zHZil1IfkqePTSNnYhGKyAixmXYHSy5SacSHbROV2rfS3um\ntW5i+LC57QXDw2os14Bj0yzC/KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUuCaxh/yPSQMfyErWpFxC49lydswHwYDVR0j\nBBgwFoAUOh2eC/nWlquHBH9T+GfpfQOwZ/swOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIE8avrr79+KyO1OU9OCU/B30u+GWkXfZAmH9IIHChy/LAiEAshV4WSmv\nxDelU/iSUD/lYUV9bn3Q4uRmcCA4bjodjAc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQIhrnSL7LO3S93cw5NbaUH6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMGIyNjIwMi02N2FmLTQyOWUtYmU4NC1mMTM1MTJlZjcxYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4Mt77xfiCjpOx7yUjnLYwwOUwcOH39IXv7B4gHD2nGGz2\nbrOfXRLUNUdjkD0TP41p8jOyc0ZzJOmgCHTYhIsAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOh2eC/nWlquHBH9T+GfpfQOw\nZ/swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPrlv4McCHZPzo0GTUFQUwH4KLMXAdQqDsv1LJNGcfetAiBaGHyE1hiE\nCbyy5FY5hNxN5/YHO61BbaeofIpZYh7kEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAcYmS2qgVxtjLAuJw3oeokStMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZkMjUwNGItZmE1YS00NTRiLWJmOTAtMmE2YzJhNTE2Y2Y2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Y5Njk0ZDgtNGRlMi00ZGVkLTkwNDUtZDVhYjExNTc0\nNzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy5QCED6O4yZXEo14K+nhIJYc\nW4bYBlW/Sn+foc5Jtob4lqM6MEK8lag2RzU7o6iqRR2outN+e4lWUp8PST0B7KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUuCaxh/yPSQMfyErWpFxC49lydswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgBAMiLOM2\ngjL6pWGnLCtHEQI8p8WsJWoBcSmN5Jj7l88CIQD4Iv904dZt0aS7Dgwf38AR6d7E\nIAArHPUur/XvGFWBsA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6959", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6959` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAQoGTQYj2RrddpZif+9nWMQSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliMGRmMDNlLTJiMDMtNGNlNC1iMDk4LTFmYjJiZDNmNTIwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYyM2I0ODktYzIz\nOS00MGYzLWJmNWYtY2FkZmQ4ZTcwNmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGXjkZvoR7C18wV03mGFLSfi7X6Xv1kWh5FeoBnYn7Trot3jB04HX5yHrO5gF\nkZkK3bgyLTEEGaTDRWdhQmTUk6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXsCktjRdYyBfEWE9n85osvqKMm0wHwYDVR0j\nBBgwFoAU4XDYP03xs8ujrlLA8w2Hk4kpYMQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDHY98vPeOXHqbA0TJcQMcQZIB/miEOvHk3Zvaz\nQkbbbwIhAMJiNMUG5Wz0McAVnzHOAWTCsATglDq9efodnt/qf+Eb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATw3jnxUQiUToNH/svBjXSZWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjBkZjAzZS0yYjAzLTRjZTQtYjA5OC0xZmIyYmQzZjUyMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSVVtnxH+FtK9yH5nu9J3nbUpKceV1dajMoD3lkqy+rPVS\nLNnreE4u6BtxTpYP1twx5MExn5r6vG+WPmQbEoCLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4XDYP03xs8ujrlLA8w2Hk4kp\nYMQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIU1ujsatuvrNmLr0zoDW31Eluxi1wTWu79x8gveGmcACIQC5bxXSjqO1\nHUba7UlAZz68Mn8smp5TBHQRWFZsFGUrFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATqjT3bPCvbsSpBzPVD2y7KlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYyM2I0ODktYzIzOS00MGYzLWJmNWYtY2FkZmQ4ZTcwNmFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTAwMDUzY2QtMDRmNy00ZGJjLWFlOWMtOWExNWE4MWU5\nNDg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExJI2Xe1HSh1HiJr9QNgXojRg\n5uoMdQYO/7M/rbd+dArurWuRjCIoXXRZGIg4G95kzkmwE9MEYlXB9wTxwG0FBKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXsCktjRdYyBfEWE9n85osvqKMm0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgZ3S1BJwa\nEK2F6Oz3s2KZ5anVpbRDttCAwrZaAGLHutACIQDMfkyT4h86hz4GY3QkY0RGUz/A\nwvIJJ1uj7tzDSGkb/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6960", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6960` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVe3lhrOzXDLL1+YEVCfSo+cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzOWI2ZGRlLWFkMzMtNDBkMy04ZWEyLWQzNjE2NGRmMjdlYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVjMzhhNWUtNmM2\nMi00MjZiLWE3NTQtZmNkNWIyYjg2ODZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERZ6NmGnyMKEykeLGze3Av6yVWmtUpagBBkpl9xYw4O2C2AemOypXb+DuTD0u\niehN5JA+q6hHhZLTkb0ZOrBiE6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbVC9RBCbbUcun/TQUBTGR2r4ER4wHwYDVR0j\nBBgwFoAUYzzUngk3IL5rSYSSbjRtYMp1vLUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDN0LWiTNlQh7JGYUn0YoX9oU2AGcmcsnfR27vo\nB/tpuwIgcvVG/0Wg0zvyrfKwXJTf45L68w7YM+JmaLJBIKjEyn8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc7t+GIcnquEAhwCu3DWYpMhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzliNmRkZS1hZDMzLTQwZDMtOGVhMi1kMzYxNjRkZjI3ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeI++BmNZhIC9Kd7pVxwHCmDtzJQXah/02ZB/3vuSHx3oi\n08yA3qCagi7qfIrEdO88BeraWWHNHf7muZVUk77Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYzzUngk3IL5rSYSSbjRtYMp1\nvLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOBf8pzVMs2Ldp2DWqGPA1ru4wArHsWs/fvnjZ5iVOHIAiA9lP5Rw/PJ\nFKZ7oG5JOlm4I7H/vfrJSMPCTl0cAnxOeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAbUw29INNZmFRz+L0piBOd7GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVjMzhhNWUtNmM2Mi00MjZiLWE3NTQtZmNkNWIyYjg2ODZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTc5YjRjNTItMDBkMS00MjNmLTkyOWEtYjk2ZGRkOTMw\nM2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2msrZV8e5dQLwcK3AzJhYdQL\nZXnM0CCsQCG/Zq7fOA6wlg4U7EikK9C24FAAgU4nh+th2yJWyIsXXA8OikwZxqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbVC9RBCbbUcun/TQUBTGR2r4ER4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgV+2De2a5\njillYGMH8eg01L9uujhzf9T7mbtzwhQGepsCIGYXgnkC91DmcE8OOjzkAFj7qcmh\nj7Gce44Tiy5WpgV6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6961", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6961` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAW8UA55Np8IM3EdlgiBdNtoqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliYTkzNTg3LTU0YjgtNDNhOS1hODVkLTYwNGY4NzBiNjVjNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY0Y2JjZmQtNjM4\nYy00MjRmLTlhNGQtZjY0YjA3YTg0YWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDtAKoDzhjYtMpKL3wJiyLtGrfsgldHLJBe4wQZQuw177SReMCtD6MWEtvxP+\nW8KjS8XJH50fIYoGn9Pza+Z+0KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUz+AJ9J4Hq4wkuYkXhtBHc+x7sIwHwYDVR0j\nBBgwFoAUTQ51seA5co9dKree+o3G4sVKtaUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIH4pMb8WB6IrnDiAy6j3KHV+kMw3XHSoYI+El1/J87caAiEA\nsvEeWsk0xuab1B82BOVmNiiIZHDp3/F2aGUzQcZ/QGE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUmJh4I1d54lWnPIQgpUr4rCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmE5MzU4Ny01NGI4LTQzYTktYTg1ZC02MDRmODcwYjY1YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsulhNivYD6HkkDbT7UwiAxVbJeIFL5QUDdBfngtmObKmS\njCtN4MD+7uVGwoXrM/Qgp9HyVdvYFJyxeo48z/6Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTQ51seA5co9dKree+o3G4sVK\ntaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaYqbGxRsniL5EwOpGX9hTgwf7x7eKd1MOewx37L+HkUCIQCCoEgGONs1\nnhOnKqSO1ueyoLx+JTEYJMXENj4GWKGcTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVXKhJPyQmFrDrvwWN7BiWI3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY0Y2JjZmQtNjM4Yy00MjRmLTlhNGQtZjY0YjA3YTg0YWNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjk2ZTM2MjEtYzYwNC00ZTliLWJjN2MtMjNmNTc0NjMw\nNzcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcTzJeGzrPwRX11KOr9silPV6\nfL+YtpOIIUVkOR+fO8RmKeVtfaQddMJlTgGporMs2STUTYyelHlDFtt4bZ2jQKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUz+AJ9J4Hq4wkuYkXhtBHc+x7sIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgNLdPRyPJ\nBRBsufoJH2GKG3ErIeVRVtewBIrLA70XpBQCIQD6mu55iHHV/5JyAEJVvglr5I+W\nVJ4aDGxnpJsphE7czA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6962", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6962` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISATJ50SmkJ5E8HxPzM05iowqcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmNTM4OTk1LWNhODMtNDcxYS04MjFjLWFkNDAyNWNhM2QzYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjgxNGFjZmUtYzAz\nYi00MTQwLTk5OWEtOGQ1YTJhZjg3NzVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4tIj0LV+qFB3wUy99s8TPK3pAGHmpvn6W8J+z2i4qNFeSeIw0vMKSx5SuO/T\nDg0ESORXYW+3LHE98DQ5BRaqsqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiCJtAt1OVksdVR6KZ2KwCq5PqV4wHwYDVR0j\nBBgwFoAUuqz3X3Vo921GlCFUcG8UaplJsuMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIG6r90X1H+OZtZRI8crt6kqvQzBcDGM4\n88SwidrtjMTLAiAl+97gnzTOSqCRWde7b6lAo5/aQacdzgqMDO5TTPslnQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZBrWOrLC8mCkD191oOcIMjjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjUzODk5NS1jYTgzLTQ3MWEtODIxYy1hZDQwMjVjYTNkM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfJLR6ePRy+b1ovS1KbUOb/X/h3ZoTaCwhCdG/wmCCEIbJ\nl4JkCW8i33Rv4jaY2WAt7UiV4UuBKMD+GNF/0w0Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuqz3X3Vo921GlCFUcG8UaplJ\nsuMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOa5tpbQ1BvLJvB7enJE6joUuYpWQOzAvUPTzJUFsQWMCIDkQlOMwEHsQ\nw2qGVjlm7MuY5EDiT24EYdDXVO0l0D1x\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAdgPxIlAvVzu9hKJ9qpH5Y51MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjgxNGFjZmUtYzAzYi00MTQwLTk5OWEtOGQ1YTJhZjg3NzVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDgxZjM5NzgtOTJkZC00NzNiLWJiNGMtOGRjMTY1Zjkz\nZTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8s0KioMX3WseSfLtZfANXoS+\nzh9PNqbVGIKhtcq6i6GZkegPAknRJG4BQ68xdHSdq4DjgpKo+41YmW2xfZJMYaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiCJtAt1OVksdVR6KZ2KwCq5PqV4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgCVhs7aRk\nB3h5rJwyMrgIcocZspu5/QczoullMX+DInkCIGg3WTv9r+EjmsWCQvjkDitqwPe/\nZQz23U2VEWypE711\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6963", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6963` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAY9qWxqtZrT1vp+g7VnS93+3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwMWI2ZmVkLTY3ODItNGUyYy1iYmY0LTVlMTIxOTljZTAzNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY0ZmEzNzItMjQ0\nNy00NTY5LWJjZjgtY2YyNGVlODdmNjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdt2LYESsurlSoEhDOfaLiy9uglafyZJM2T7tDfsXneKdibqYGK9y5Ota456d\nqkevYEvFTKjMfo5YoIkditOt3qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE9SrzWBHYpGmUPJgdq15vFAN3aEwHwYDVR0j\nBBgwFoAUM7dAk69jJFQuAqy4FGmPQZcYDgcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDnm5mwm25tZ5M4GwqUqG4fsFcGfdTo\ntPF1Kc+QQwiMcwIgI01tBFxeeVheGQxMk0fC/5C+rGYywxSNOsXNY1O8uJ8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZB5DSSRiGhI5Aqob7zOrLGVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDFiNmZlZC02NzgyLTRlMmMtYmJmNC01ZTEyMTk5Y2UwMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZGd1xruFj3hpLNl6PeGQt/FNaN99vXyV4sOUPG/mfFe/R\nxeNHYw6SKEx/sdZo/sPggEznBYBlIuvDI8Swdu4go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM7dAk69jJFQuAqy4FGmPQZcY\nDgcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIKi+FOpIy00DS6dTyxB8qgZ9pzBOukxtWhUTXIh2uKcAiEA5sdH8dDJ\nocizMUvJ7HO7RnPz9RrviZAa+r8019d/xvM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAVzD2Rf1FY0ZEhffec130idlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY0ZmEzNzItMjQ0Ny00NTY5LWJjZjgtY2YyNGVlODdmNjQ3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWUyOWIyZWMtNDEwMi00NjhjLTljZWUtNjAxYzE2Mjdi\nZWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJXkEo7mD2DvAouj4SEwQxOcS\n95Nh1WT/9JviAbuETZ/5fCh4URjldOIOqUuSVcN+y7yaPp5+QZzyYdM4yVOK/KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUE9SrzWBHYpGmUPJgdq15vFAN3aEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgbhkPttUM\nhRtQlaQeuqn70y1byoxwSneLAhpMlzY/+DwCIEOQHos4vAaIyEl3eDfe7QrDAm4J\nLY97XyvPjm32DZfc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6964", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6964` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAeNy6b2VddRbl9vOAZ1vvMtVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3MmFmNDkwLTMzNDctNDMyMy05MWNkLTAyZGZlY2I4MDA2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkxOWI0ZDctMzM1\nYS00MWJmLTliNzYtOWY3ZDEyYTdjNDQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3DWaUp0PPRlVTtJbYDbjV8TWLkvRI9b4+cGBbAU/bYfycbETVmfCQaAPk9ab\nfkDm0DuYbRbEIyvHV9v4O56hdKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBrGfz4By+pGqcUzZxk27XIwYQOwwHwYDVR0j\nBBgwFoAUjDl/U76Ng150T3T+ofwmu50rd/MwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCpAllTnGnZ\nw/TrngWbOWIyWlh1++y7JUbGXpl1BhLq2wIgZVJTAdVYxN6ZQobQF7qVLgj9tQ3E\niyp5euKL3aBwHfQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUWM0U0qep95yvZAYBQLy4/IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzJhZjQ5MC0zMzQ3LTQzMjMtOTFjZC0wMmRmZWNiODAwNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7fF5jLuOk+Br1Bt2ZCAgilM+PAU/tzylt173xqKPR8FkV\n1tTVTbclMRGzsUOXlreC3ELxyRlajrwEhROIFO5Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjDl/U76Ng150T3T+ofwmu50r\nd/MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOLiSz+kXA2fBW2xoxqrMrYllZDWM361CNWnRC3dfB1SAiEAmoV/K94l\nmTAuX5qvWhr62n22gN5f0d8JYbbEss56d1E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXFS5fmsD8dOv3/IrfwHnziRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkxOWI0ZDctMzM1YS00MWJmLTliNzYtOWY3ZDEyYTdjNDQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzY3MGM5YjUtN2UwYi00NGI5LTkyM2ItNGQ0NzM3NjM0\nZGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/b/uQqtBt5PNITU26QfJHFNj\nqBDjDBkseqDoTEMPw8I7J2uIwGPX1L13eT982jQ4dvRE0fZvvR1Hrm7sadG4E6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBrGfz4By+pGqcUzZxk27XIwYQOwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhAIbct9Yg\n6ocTwnP7jeMvI9ocRng0weexhsoc64qQ/cy2AiAKoRrlAGcxQRs0OpySFGdeeYXE\ngW6DJF7tW9xSA8AKOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6965", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6965` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAZjUTbMtD/wEZkB5yzHLMzoUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4NjM4YmRlLTQ5ZTEtNGExNi04Y2QxLWZkZTVmNjBjODhlODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBhMDhiNDItOWYw\nNy00NTFmLTg4NmEtNDMzMWU5MTBjNjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGvhRpHN8YKBibEkxdMjrK/+rmtx8Dk+TjsXYq6VgqMwhq8CNSju/aGBK8e++\nWpC8c/4ExmTF8Sk05dkDyRK22KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeYHf21FbRWOJaGAiBsakuep9XHswHwYDVR0j\nBBgwFoAUg+zKJbE3+IYstNzfP3ESMqmxQakwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAOg5tsBn7T+89i8qOMM1MfEufewl/GGzrGZGZN35B/DsAiEAvPIXCSFU\npTD1mS47cKh1nk8e7bR8ym5O8fyt13mNOeM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUfobrVBUGPl3Z647WY6A6LBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODYzOGJkZS00OWUxLTRhMTYtOGNkMS1mZGU1ZjYwYzg4ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASE7ElRMnAu1EJuqUoDRc9+lWrVLtc8VqFBalV+rFp5rzwf\naWxfhuFLp9tGD929KrEE5/QQrpj5PMyFwSoNVXwHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg+zKJbE3+IYstNzfP3ESMqmx\nQakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPv77+7P1/mRA0wccePjQzrL2SwHeQWI70vPv58Fruf7AiB7YFb9GxqW\n12OmaPV4Ie6bPKM5cLJrEVRnE+S8bl1rPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZt754qy5C0fpmc2TAEIP618MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBhMDhiNDItOWYwNy00NTFmLTg4NmEtNDMzMWU5MTBjNjRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTZmOTIwMDktYmM1YS00MGM3LWEwNmEtNGVjMzA1NGMw\nYzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgg9tYbunFx9bpf4wJlZyS9ji\ni9IFtSpLX7MwUtTY8rSm+fc+fRdELMuZ1sCE4oiOihdqkABl+ix67kl1gZ+6mKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeYHf21FbRWOJaGAiBsakuep9XHswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIhANiMW+TX\nhSVAwqqDFm0KS0ZFgneU3pzVlFTj8LR/nvKJAiBFhEaO0HEdqcIjPoeOTM5DSbCs\nT63MWMwbc2JB5a7b1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6966", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6966` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAc8ulOorR7/a+PsPKixXKB30MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzNWM2OTc0LTA4MDQtNDBiMi05NWEzLTgyNGRiMTc3MzdmZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM0ZGI3YTgtOGYx\nMS00YjBlLWIzNjYtMzYwZmNmYThiMzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqUZuMxdXoPx0fZ2PjG0JLcO5fbhr52Hx9S6MQy/3sAWQ0SGeIpH8lb7+myy4\nnw5U53HaVG1f6Ep67H39ZOe0+aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlUXHg/q5ZZrxCQ9Lza3OY7Kky9MwHwYDVR0j\nBBgwFoAUcANLBaBFaNo+6HUGJWsyLW6hjpowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgRZU5+3Whxbt458i+DRDK9b/bC5wvd0yQSLEUPF6P8qUCIAY6wNJoCfUk\nk3fS1oTF0iKR9RSpgciClU5kwbgb1PHP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU3Kc4PDr/4WG7Deocd4LeqkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzVjNjk3NC0wODA0LTQwYjItOTVhMy04MjRkYjE3NzM3ZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmSgdDwOSk3sxOhW8agiEjGJE4aB1XZx1QwqWgNY6L8qbT\nw6d7jf/61KEp23FXU2n9BWFD8hiwPWpdE57xD9+so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcANLBaBFaNo+6HUGJWsyLW6h\njpowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXfVfCsvpmSH1jZcnFJUfAZ4vce1VJiEwwtx6n2poVa4CIE+Ai73mJ2Pt\npSvQphD2DTzoER+aiHAr29D+xq4HBg0B\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUzYCbwCH7g5PiHAifNt9FhaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM0ZGI3YTgtOGYxMS00YjBlLWIzNjYtMzYwZmNmYThiMzU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGE1MGQyNDctZjg1MS00NzM2LTkxMGQtMWE3ZmYzYzgw\nMzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYeyQk5+uNfL+42CzXJ+bK5Q3\nc/3tE6NUXUz8KQSz5I1lxFD/Qjkv8ZqM60xdzS6QIkh32sNbDtuxNQvQY7P8i6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlUXHg/q5ZZrxCQ9Lza3OY7Kky9MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgMtZvoGov\nheRPS++fBnzxKdcjc2CvJ6m7SQrJqHaocoACIQDPaNGxS+nlvGo1GKZPJfyTHE27\nUmutqmprQ6Z9wXGimQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6967", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6967` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARIlHT6sRJvMIgksaF70e72TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxY2JiMzM5LTcyNWUtNGEyOS05NjEwLTkzZTllZGJhZDQ0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzNkMjZjMDItNTMw\nNS00ZDNkLTg3ODktNjFjZTdhZTk4MzMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED4E3hQnVKUXS21QIqFgEVDs4m8cW0OinOt9DN3nn3weMefaUsJRTK8qx4jlh\nIBWwC9zeHHF3tDtz2N7A96DZSKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUECSrW8EWCPwTCiUgPAS9M2cdiWwwHwYDVR0j\nBBgwFoAURDGNmwohTwFJtoV1n+KUgVGCsqIwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQC5y7lehLxaZ/ISjRf0HNKcfXfeZV9wC/CKhksAUNhqegIgVHqaxeoH\nxmYL4vtqLeYQeslJ5SQT+5rKYEx0n8EWGA0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARNyHqM243C+1rVYnt2TrNh8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWNiYjMzOS03MjVlLTRhMjktOTYxMC05M2U5ZWRiYWQ0NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyb8m58hhp04GQC6QCl8cHEGq/sCNkVAm96pi/fTG6CPKu\n33VV0+YACG4YQqoczL+b3Wovk+dUbQPLmP2qfoGTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURDGNmwohTwFJtoV1n+KUgVGC\nsqIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPjzRBh3GQYCX6+o5m1LrBKLwLYmVMyLzf5UznsG+UftAiBUXJOKR0iM\n4HXkSR+U+qZkNMgzh3snNj+ThufGnqUstg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAf1wNjuGIUuC6J5Wy1Kwh8hPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzNkMjZjMDItNTMwNS00ZDNkLTg3ODktNjFjZTdhZTk4MzMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTc1NzE0NDktMzA5Mi00OGI2LTgzYzItYTE3MWRiYzg0\nZDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOVXYpOnQvAagaoMXCWP7Dhxb\nYndWm1KF+7ediw8/sB7VS7ist0WROi1v980XHLr5KuTqLHnkFMzauC+SwMAVoKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUECSrW8EWCPwTCiUgPAS9M2cdiWwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgaCRr2DLu\n+Hn5me1CB9pq9R3kmrKYX9SWinHuhrRrzD4CIQCK9VAPXnv/OmOu5VYCG+wBy1po\nNHwzMWv2kNOKzNIRQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6968", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6968` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAT+Lb1gEW1Brbla4vIBh7EWcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwMzUxM2VkLTY3NjctNDE1Ny04ZGY1LWMxMWFjOTAyMGY4NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgwZGY0YmUtNjdk\nOS00YTk3LWE1ZTYtNThmZDA0MWU4YmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaWVTftB5CyWE+2rdtuZt1UaZO4grVST/zqf2xaDWxjMxhflvhesNAZmF4546\nv/xW9lkmuaF8nQyyrPHys1JDLKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL2Behu/xJ6Vf+Hkb08WUhxmKMsQwHwYDVR0j\nBBgwFoAUL+7RekCleJ9V05FmLifG3Po+sVIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGAxxh6DSgjg/QKO8DS181B4x6Ex05mskvrHTDTu\nHlZiAiEAoaTn9I1dbOTP0P6X9SHhkedvmNLZOVUWeaZH5M9CgrY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASpo/Mj/HBL5PqBOd8OcjD0SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDM1MTNlZC02NzY3LTQxNTctOGRmNS1jMTFhYzkwMjBmODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsrZptXzFJhhCrvmoFWAarYHQ84aeokZ/24DvpdccwdCHi\nF57a6GovhbQ5nIAnfr67urPyv9ArleHcu3chx6Dao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL+7RekCleJ9V05FmLifG3Po+\nsVIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJEdNPZ6Kdkj528LtkRrOjdYK+TvdA83zIoZ/GknFZ3mAiEA8hGqha+D\npIW+lI8anr5qjaT/g0rig2RuZ5E4cjqzGGE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATjoH09HzTiuoV1HktUOLEVBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgwZGY0YmUtNjdkOS00YTk3LWE1ZTYtNThmZDA0MWU4YmZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2M5ZTU0MjYtMjUwZi00M2NlLWFhOTgtMzFhMWQ5ZDI2\nNTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERx/QjNza5u6/V45gjEd9HZby\nCQe437WRqFdHT5IwZnT1MKMowmN/mzJPQpiwldW4gbAwvUHgYdCzlQ3oiTZ1WaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUL2Behu/xJ6Vf+Hkb08WUhxmKMsQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSAAwRQIgbJiOmQFg\nEZ+t6njs2/2KoLDWVGklP6Lp+DCh2Mo7sZQCIQDDSNi9HPKTNGCl6x2DUTT/iDiI\nRidAeMlzphKDWAe1Hg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6969", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6969` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAdLhEFcLLmMtfBkDmT2uFeE9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0MmJmMzAyLTg4ZTMtNDhjZC04ODhkLWY0OTYyMTUwNjY0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk3N2U2MmItN2Ux\nOC00MDliLWE0ODAtMTI2NjkyN2UwY2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtqRMblwgGjhxVNgZTy2ftVHENZmYZ96zhwVblFvA25gEPRRTwMXulcqIf77c\ncTNbNqkGGyB3zNocbsY3/VMNeqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO9vmRUBJ+/Qy/ix3kyEXSBYhC+QwHwYDVR0j\nBBgwFoAUNRCBClJ8zTovabKkSlla4OzhxiowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDSkraJlTN7/h905FQ/E9R+LWU8MMAmT2HK1OX7\n2HlIuwIhAI07M8BBVn9ETP70MFIp5/a1nPapM/+xmuq5ru77EBsc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb3zaJdEkMNNN7xR9gy0hLIpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDJiZjMwMi04OGUzLTQ4Y2QtODg4ZC1mNDk2MjE1MDY2NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxBsTmrvDR5Yr1xncBY6N2kVxMhaGZh9GwucbT7d75ZJb2\ni6R8DZT2QVMLHPE81WxfCMBOxy8dnLHhuXsaUBYHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNRCBClJ8zTovabKkSlla4Ozh\nxiowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJva7TURLTgACtj/Oat2B39zfGmfhLuBAEvll9qo6BwzAiEAo6bWPtSR\nwXNiIkAYrFMP3KF9dGtgAPRQHFuQaC/SGNU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZHOVeshiz+Xsc8/o9xVyNIHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk3N2U2MmItN2UxOC00MDliLWE0ODAtMTI2NjkyN2UwY2I3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjY2OGI2MzQtMzU1NS00ZjQxLThjYzMtZjI4NmE1MmE1\nZDQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEze5sA2aZ0DcoceZRZY/yhu7g\ncR6seW92jH/ifLuM1q2m2xAgsUNRkq3BoBgxitvHTR0Ho6Gl1OSXD8Qk6IiwYaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO9vmRUBJ+/Qy/ix3kyEXSBYhC+QwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgbFb4BrPJ\nTiatfGEZMn10Zl1dXk3/W5vR+SVNZ+N9eqUCIBroTtwVJn4lI/m2d/ov7oF8oZI/\nRRms10yXlO6RZEKI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6970", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6970` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAQMk4yA8+O4wmd3Nq1iXTnlqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNjhkOGMzLTM3ZTYtNGIyNS04OTI1LWM1NGIxNDE4ZTQxYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRiNDc2MTEtNDI1\nZC00MWNhLThkNmQtMTliMDkzYTEwYzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGfzAdrZi9CpxhOCt+Fh2zHwdP/VBBtFsVUfwSlTULgcCaRId0efbsilRFD5G\nklp4T/iCGtsqelDBlGpPcE8RQ6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEn2RBhwYtMfGSpYW30o4VSwUihAwHwYDVR0j\nBBgwFoAUwN9708uG0QqsPzCs2xYHaqjnAaUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCC3i8OfCZEmByX7P1QvnEcnKMaeLo/SVEEMUzmGMogjAIh\nAN6iTMdCqzPREPtzpN+vZntg+54fF2M8lnBiMDaMb+DW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb09KssKNWYkkQURdwd7fWpCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjY4ZDhjMy0zN2U2LTRiMjUtODkyNS1jNTRiMTQxOGU0MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmN/Vbpd1ltM7yYRGaXv+jFK3ZhhwRwrAK5/D++td4ZY1H\n2bVcyBGIAZq2IC+9t9Y8kFCfWbX0GRWdMBxesI3fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwN9708uG0QqsPzCs2xYHaqjn\nAaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPYWh0QXgASw/sFLs1fYjy2jk/egQJzu7+H6ItkqyzzJAiEAxlgjfXvu\nTku8uGVybzabrTG/Vg5yTc5yMBCbfWABR78=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAX6GwOmN2LJv+VKk7GpLeZ4gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRiNDc2MTEtNDI1ZC00MWNhLThkNmQtMTliMDkzYTEwYzkzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzZmODE2OTktOTM4Zi00NDBiLTgzNTAtMzI0YjhjZjU5\nM2U0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwT+/OgzZ54dDGnbqCdm0NMsD\nR2uGLIqZM4drq+c//GOhgukgUhO2xQ5t2bh8blDpbzqnGLrqKo+KceyOqEhOyKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEn2RBhwYtMfGSpYW30o4VSwUihAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgO7tdOvki\n2yCeB0eHn4MU8nS85ODaHcMMeFf/wTw5uwwCIE57pKal1YB1Yj/WXzSqaIjYK9J4\nAWBRr+7HzZJf1vQG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6971", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6971` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAWRLbVZqvMYetfgo22cLyKV7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhM2U2ODlkLTBkNjQtNDM0OC04YmQ0LWY5YWJmNDY1MjgyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU0ZWMzNTktYjU3\nMy00ZTAzLWJhY2YtZDQ1ZjE5MzU1MTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP/989yNGqG2nCNzc//Ks1A/+E8OgN+S9/3VBNcQBFUS0Ku18Rvb1Oe1rmjgX\nBzCC3wvwkvBFBm3VKIeXWQ0RY6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUMSe2/Shfpl+qRin5c1tyvYw8ncwHwYDVR0j\nBBgwFoAUguDIYuGGO/LgzhvHX0ejCcFLD1kwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGs90JE6FRL+YV06W0ZXLr/kLYT4bkHS\nKaUPTwpZhWWrAiEA6ikeV5g74rEjMs1BA4A4DKyHSeq8BLUDyiVpVW2x+aQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATYMOw0kA97G+NB0dcjb6Ox1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTNlNjg5ZC0wZDY0LTQzNDgtOGJkNC1mOWFiZjQ2NTI4MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmkog+maRMkZUUfGqLn0YSkh/cg3TfgVb1Uy0EwPFNzD4z\n/+teI7eXdBaa1FVWNPKvlANp1ZCqO/0xTLGMBbkto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUguDIYuGGO/LgzhvHX0ejCcFL\nD1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZtyuVelD4h5Q5Gv1seO15SjY9+bxKzWilsJZ2ezsm7ACIQCxfXRgwbGB\nSW2+wslha/jVsL/4Tf0bus3b4zslP2mFSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQeiAybOl6jld/olUj3aONsOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU0ZWMzNTktYjU3My00ZTAzLWJhY2YtZDQ1ZjE5MzU1MTQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGI0YWYyZTEtMjYwYy00MDRhLWI1YzYtNDg2Nzg3ZTE2\nNGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER4w5/0/0YTHHUSh9C6jGalk5\nhhkHiuDxiefZsbn5/nJZkjq+xR+Vo5BFkknP/ob2S87wSmwqjOwNHZtM94FH7aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUMSe2/Shfpl+qRin5c1tyvYw8ncwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhAIR1y6gC\neDGbMyJBBExXLNr3UIcT9edsXw/zie5QabY0AiEA8dWMG9anl4ATUJZCO2YSQCV/\n8mQqZSPh0JnzHh/9aog=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6972", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6972` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAZxdH2gv+XHHZkOHWDMGoMOVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3NjYwODZmLTZkZDYtNGE1OC1iMDg5LTJmZWJhNDczZjJhZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmExNTFlMTctM2Rm\nZi00ZTIzLThhYTUtMjMzZjVjYjEzYmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIb5FXB+jewlJzGKGtK34LBh0jZ2XYPYoCPMzifseb1/RTpTSX7Ha7Iy/r3DM\nqx0vWBYIv5bTXqyDN+fFQQtGnqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOc3UuVAisfrtzflUW/qBntAodrgwHwYDVR0j\nBBgwFoAUf0tU0rARPWJmSTcx2f93bU5PztUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCr5m9/ixJsQj4xaJUH1vMm5QLJ0wu3\nKoV8o0X42x+vfgIhAP2u6XnTDBx0skykA3LsGcPFobbIHNO3dINNBTJsPLBi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfJJXEu9Y6LJB5CtdUH5Ah6SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzY2MDg2Zi02ZGQ2LTRhNTgtYjA4OS0yZmViYTQ3M2YyYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReXukpG7VRsXZqR8NxbAkGDMFBXt3bZbYiyOr4JbXTEfmX\nhJe3KoOM9S+9CBSItDRtLA3XbSmjl3R5uTdyIgEFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf0tU0rARPWJmSTcx2f93bU5P\nztUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJwb8RjT3oQMFrksrNLLxrGGObPhIaxYTfXrUur4zw8UCIDFGaiivp35j\nhE+8daob8Py8ryuiKV9oMjXKLv4gdjIx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAcEZtStn7ddmvrBf4VhOr6BvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmExNTFlMTctM2RmZi00ZTIzLThhYTUtMjMzZjVjYjEzYmY1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjE2YjllMmQtODY4OC00Y2U5LWE5NTktNTU3NDRiM2E4\nN2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy6TwATa3JWUK5Gk28w1xRM0W\nvEg4DbL2p4QTg7AfUF+9J1FleLeKDMEE4wSskoEsIo7hKOeMrWQAbZ2CawKKmKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOc3UuVAisfrtzflUW/qBntAodrgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZIzj0EAwIDRwAwRAIgOg4jb6j9\ncec9Ep1QXpDVEpnHuw905GN+npR2vNNu+v4CIBTaKSu+vbwrWrFJxPRgRfQz04Kc\nWs8vlNSxzSyLYRWC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6973", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6973` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUKxUOHcSQcTrsIND/KHiaebMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5YmI1NzBjLWYwOGQtNGUzNS1hOWNmLWYzNmI0YjczMjQ4NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjc5MDU1ODctYzZj\nMS00Y2JjLWE3YTYtNWJlYjliZGE1NDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4aMoJmb499XgvoO/Gfs/C8GA49ir1bR8ibv55tanr4DGoTklVg3fUlLkQyGR\nDiU6C8sThESy0AdE/8jyX27Y+6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFP0nKOVyP4GdOnQY+cYHWuGC+gUhMB8GA1UdIwQY\nMBaAFMk1aeXgD3Zvac9ldy715+eRaqzGMAoGCCqGSM49BAMCA0gAMEUCIDWZEWm2\ncdxLdNSmbx7avwZtsn5Htzd9U8q0k+PQk2r/AiEAnhSvgVGl6myxhoK7IIUxPyjC\nZ2dhAKZ2IKjCaRttydw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVCSMG7Pi+wfnuQHXkpbDbKoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWJiNTcwYy1mMDhkLTRlMzUtYTljZi1mMzZiNGI3MzI0ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJgNlkMQv1JgehYvMAkt9XvregozKqdjZT4z0fozMNn5oN\n/TAXrw2PcOFRZrxVl8EGXk86tlOEUoQJ6VazgIHvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyTVp5eAPdm9pz2V3LvXn55Fq\nrMYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF5m3pVIdyeH2MxFakNbwfoX2/X5UQZpDP+VDwip5vP0CIAmYDG8F85r9\nrSTXKCctvHFD9nOyC2YnxPcP14ANld5f\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATcARcg6im7+vcJ0alDPJh/rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjc5MDU1ODctYzZjMS00Y2JjLWE3YTYtNWJlYjliZGE1NDI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWU5MzEwZWUtZjRjMi00NDlmLWFjYzMtNzBiODUzNmJh\nNTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaa4oM7NBAQtKoB1PYtnZQVCM\n/FkIRM+7mU5q+l0OLLzVpwkJq+f3MiucCwTeH5q9bI6Xd5q+DsnRIrsFuF2wcaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/Sco5XI/gZ06dBj5xgda4YL6BSEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgA+bVvlW4\nB44tbuvgNNNvedOH540vfnYavo+KPsAzSIsCIQCetvEBO6HVM1lz8z3DNF2KmXc4\nXtXfkgPU210bASXUIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6974", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6974` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATzmmhyVnWNMWfjmgTsCGkj1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlZmJjOTE0LTAxZjItNDk2Yi1iNjY5LTM2MDc3MzZlMWEwYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY3MjhlNjktOWMz\nNS00NzJmLTliNmMtMWY2Nzk2ZDkzNGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJSFQo05vZEGRNvuJMy5lenu/r9ck84+jppyYA2m2yeWjJrUR9/vyTXUUM/Px\nW4vXMDkiuuBl/zejtNPsQT6cVqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMABnV6xsvpqTyL00jHPYE32g63eMB8GA1UdIwQY\nMBaAFG+o73BNgUFGEHeand/6Jah8lKo0MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiB8f0QJE+mi2fdflpgjebe8nHm6MPiR6NG+\nAbEubdCUkgIhAJ5PDSfJityGszIuGaS6NIV5DoufcciIY4kGIn3LlaSf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ3GUb4TAWLGeTfoO7fGAZuyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWZiYzkxNC0wMWYyLTQ5NmItYjY2OS0zNjA3NzM2ZTFhMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBEw4xxd0qIxObPvV2r4frwN2rjz8S0wo3NjyCta4Us2Bx\nbSeydEJ2AByxIugTqVGWTUOE97UK9saKjVZ2lXZ2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb6jvcE2BQUYQd5qd3/olqHyU\nqjQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKHjA0PWDnUYDlO8pkbqsUtS6BSZe9C1oBMtOdqj9eZzAiBSK/my4BXR\nsgHIQenZf+0cI+0WBJNY9CUwtcMrHAAsZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAceKizeyFYVPTaHhi6nDbdCdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY3MjhlNjktOWMzNS00NzJmLTliNmMtMWY2Nzk2ZDkzNGRjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWM1YzUxNWUtNzc3OC00ZGRhLWI1ZWEtZmE0Yzg4NDA0\nMTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAfB7PYeu3oejf0B9jmOhdKrW\no+0ahdNtu3RrVKndECg+uf21UWIhS4coulqPzaJNdmo6CVYB495cZVkcV/Irg6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwAGdXrGy+mpPIvTSMc9gTfaDrd4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgMtV18LD9\nhckSIgy4SZD+nXW3RbvFjEq93eLKKf3ywpECIBBSEyGNLRUDbs3FY3o7ewSYkMZo\nvmVpfCw50EYAQRSM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6975", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6975` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAR6CpMVS89BFuVhwm8AeQqCUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2Mzk1NTQ5LTNhZTMtNDI2Ni05MmQwLWExM2Q2OGQ2YzNjNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ2ZTE4YWYtZmFm\nZS00MWMxLWE4ZjEtZDMyMDY5ODAwODI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoF2+LyyLEAD2+sZWnt54fgcoG6Wi+ln70fWenNPAlJMqVXfah8nhXQos3Cio\nbFwXUQZgPukcOf1uB7to/QQJP6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKeG1OsRZ96bNV/BQGLMby5LLcAGMB8GA1UdIwQY\nMBaAFNN6AdiVND1W3DkS7jkijbv7hin9MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAk0eWe/cpGSuHrbNhqlZqBn1mJDBwo2ka\n2jqW4R+8ulICIAGcqgE9FN3F47HiOQtD+mO//qUknHFIJ88kKw4Id6Us\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXJNZaLvpZg21d837KaSlc/LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjM5NTU0OS0zYWUzLTQyNjYtOTJkMC1hMTNkNjhkNmMzYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHaiqMcTC3FDPMLSILy1yyw24RbEvFy5TIJZ3MVHLucH3m\nq7MHNPiKrmsppu0mPgm24MeJQMgSEClbR8u+riOzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU03oB2JU0PVbcORLuOSKNu/uG\nKf0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDJAq2XJv516OkFwUL78jyQOZjfXK+QUrg2Og7mDlUVECIC9WKSVba7Va\nOcNWq8qCNxdpge620ERwpanmD8cs5d2l\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAY0ZWIhsHyP7a1jSQPquooZOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ2ZTE4YWYtZmFmZS00MWMxLWE4ZjEtZDMyMDY5ODAwODI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjY4OTJiYjUtYWRlZS00ZjAxLTllZmUtZTRiMzM5OTZl\nM2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9hW4dsJAFL3WMu4pLvJKawcO\nf3nu8/49D0iQb7JeHU6RNUiecPAY7V7CDoe+sb71l3FbVa3WQmuin5Cu0PMGdaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUp4bU6xFn3ps1X8FAYsxvLkstwAYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAM390/Uk\nWVNTEC69Eg6jcEkDL/CnnzJ/7utnmF9vdOsNAiBWIU/VZwyxoDp0vDsxQFw6dtDp\nl321mX7IH9ohrOMyeA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6976", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6976` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAXcf4qG+UWPa5u90XLMPK47fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjZWFiOWE3LTkyYWQtNGJmOS04YzJjLWY0MWZkMTBkY2M4NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZjZjcwOWItZjQ0\nMS00MGY4LWJhMWUtYjY0NzBmOTBlZTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgt9pCF2qubElYHz8ulBigSS5EIIWzBRqHp4RGnFV2UpKNQBCEd4HnjEDKuG7\nMQBO9eXMsosV8zGeSMyhiyqVQKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRfTKjZfW8XUrSVxzO7p5iQLszgKTAfBgNVHSME\nGDAWgBTlHesdIg3y4tRz6INKhaX54QmtlDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICG/3f6OE5r3nq7KByfp7ZYNXCJ1f1I2\nwMrvd5VjTUOfAiBY4tlYSTa8AGGYcsk61nxt7stuq9tRr4ib4NPOQPUM1w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW0HrFkjiFNV2f8gBQ+MByJ8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nY2VhYjlhNy05MmFkLTRiZjktOGMyYy1mNDFmZDEwZGNjODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQwabAOkWeoeLxYcj72TeffmaWdhISm0YBk3keLDHVdmHH\noVk6O3pPgbga77BokVIa+QkQ+aqSu50WhzYNDgeto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5R3rHSIN8uLUc+iDSoWl+eEJ\nrZQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP9MySERz/Aw6ktOj4wQ0KiEYs1TNyr0t5IylCfgtHtuAiEAqzPdscBI\noHVIKfrcK0tm6OJ9KashFTohdXFaiBZQta8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAbFR6s/zB16T/rHrRZ11zh3WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZjZjcwOWItZjQ0MS00MGY4LWJhMWUtYjY0NzBmOTBlZTE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWYyZWEwNmMtYmU4NS00NTM5LWE5YWMtNzU0Y2QwYjg4\nM2VmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEW3OqQ/XtNfpa3i/bEQ8cJOr6\n2y4WLUiZAYRhxu/4PTkZubjg5SokvreKAOAX0cjGBNSS0pThYZnuiDvhyZA7IKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUX0yo2X1vF1K0lcczu6eYkC7M4CkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgaM8nKmL1\nGqQJJ0H1yayDDfpzyY3yOh342zoGFg2jIe4CIFWWhX4Sm16mLThs+faoIk9yhd5Y\n6vErMkTJYdIkscQj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6977", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6977` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAXnMXZYgD8OQHrsU4o/UDux1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NjI1NzM5LTNjMjgtNGMwMC1iMzI4LTE4OGNkNTNmOTliOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg5MWFiYjEtOWFh\nNS00MDNjLWE3ZDQtNDNhYjMwZmY3M2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdr1vuupojJ1YYcQSWUZKstqdZxJ0ofq3sAofHlcXemLeS3tJe6u/yZGpMMeM\ne94FKsHssCXEYs9e371KJNUSAaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTfmfxHTzSC4kPFZNbT1iDJSIwYgwHwYDVR0j\nBBgwFoAU/yWdi3CJRmL3US/krdafcOFwYzQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAiDLbRvzOJI6I\n4yvgfLY0SJZ9kpLavNqQ9cc3oyWd+TICIQCPaL/QwJ8oZ7m338bfbxsnmOJ3eL4w\nKAkAdLuHU39wrg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUlc8yniVTk3M3jgsUFkGKiVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDYyNTczOS0zYzI4LTRjMDAtYjMyOC0xODhjZDUzZjk5YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+/4HKCP/AlWAFav5o7K9Q6kOSWXoSKq7O+yZYSd8Nzn8d\nMogWaGuPs3gJauutMvOJBjJZjtrZlNyncvzp6/kSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/yWdi3CJRmL3US/krdafcOFw\nYzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIeWVKc8q6fccJpod2OWKPlcmAee/j0UJ7U9dyfWIQGwAiAMSxH1DEsI\nw4YOYp4KgC3eQrYm/2oranxmY9i79PAMKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISASaHf340UWdaLAavZhBYfYYKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg5MWFiYjEtOWFhNS00MDNjLWE3ZDQtNDNhYjMwZmY3M2Q2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGNjNDEyMmYtMjdiZC00ODA5LTk3ZmItZWRjMjhjNmI3\nMDFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0VFTSWUtfU5WgDMGI0CTnz+z\nRx+z3mMivkE3w0grYOu5whqo675YYRxnCk6swEzexgvGOeYbZOcUiUy7f6HXu6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTfmfxHTzSC4kPFZNbT1iDJSIwYgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKKWPP5D\n/3/ijpy82Llgh/yJUY/aHOaGv4UiCAxovNiOAiBwqlkhrRtC0NEMsr3gaUShEb9O\nt7KOPGy76ms2s6AXoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6978", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6978` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAW3ghwh5sdviDvl7Q6ajKZmmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzODBlMjNjLWMyM2YtNDcyYi1iN2ZkLTI5M2QwYTdiNzg1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjUyOTY3Y2ItYjZl\nYS00OGIxLWJlMDYtNTcxYmQ2NGEwOTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUWU9ZKI5bzlwT7drJmQnJe8Htj0HPOAbkRUzEKIgoZ8I9gYZOC2MN9wb4BgG\nTND95ZdzIhD+bPkhi3q8YyzvtqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx6go/ulAW60ewQ+k3gifqeYUk8YwHwYDVR0j\nBBgwFoAUDuicZ5wMYsnhagrzOO0eibhU3aowJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAuxTYiDr0qaueL\nO/lMHld5/cmPzI1JFBTjzRHrRMVBTQIhAPUp2yjAYbH1jKWIKrvSAwXeUxtdaKzz\n8Ipw2KjvB7X4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaEukpmEzptY44th0QunD0B8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzgwZTIzYy1jMjNmLTQ3MmItYjdmZC0yOTNkMGE3Yjc4NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5In7bAwOzavmu/9i/a4qjuLiWyus6JNDl2t0zlb7c1qTF\nGT0tSJsU+1U6owiUzHpK0XlvMOZHGdFn1Jq4breko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDuicZ5wMYsnhagrzOO0eibhU\n3aowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPZHwg6aY0P7J1Uq5t6vKLOb1To0PSqbxHOb8vzlRiSwCIFS3tbedrGjg\nc3fbuDDZhaezh0cVVomOF7beee/TT+ft\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAUUjlbBdVOf5M3+q3ggAvldNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjUyOTY3Y2ItYjZlYS00OGIxLWJlMDYtNTcxYmQ2NGEwOTExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjc0ODNjMGMtMDVkNi00NTkwLTg4ZDYtODM1M2U4MzI1\nMWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx6S5Nzcs/hamVCB5fL2ETKgC\nBUAJwUJmy+aYESWEQ9ZowbruS/HMraLC2jGUz5cA/i+sIn4szIaZyCpcZA7vS6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUx6go/ulAW60ewQ+k3gifqeYUk8YwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgJSe2GqlR\n7QRxUIlPK6AK6mmYtgbcZ9uWmVq+uAcNU8ICIDXRepvmtoqlMN+T+3jwPYFu5jXh\nQvaZLr/EbJqwWp7/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6979", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6979` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAScrTcNdwTZJFL1LNalx4zNYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNWY3MjAyLWEyNmQtNDQ4YS05ZTE3LWQyZTBkYTkxZGUyNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU5ZTZiZjQtMjhk\nMS00ZmVmLTljM2UtZmY0NzlkYzBjYWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIFoctYz46pW4wr8wsmHywq/62OvmktMR5hBjqnj2/KQdPq95R6syxEPdw2y9\npe7tDOP8x/mbI8++0dOAWs3cQ6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUciksUuavB2SXtzv+8xwJ5KLnYMUwHwYDVR0j\nBBgwFoAUzpISFLPbmW7sF+H0uMRdJuis4mIwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAuBTqupU+/SJoEnSpykQ3\nfBNPxfMj+D/2/38bbCmKxrECIHZbaqzii5gpRNybdnqrJWzTBDlsYPQWklIXmqn1\nMA5l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYJyZNiRhBczRvDD5NnXvTAfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDVmNzIwMi1hMjZkLTQ0OGEtOWUxNy1kMmUwZGE5MWRlMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQI/ejN1DLNDA78Ys4U/MoZCJm2K0Kr/6OZTgDDfjoNoiOW\n+mkXb4+IREGap3pVjRZw/hwpmDZfb6LhCsv5tsUao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzpISFLPbmW7sF+H0uMRdJuis\n4mIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAM2DoGt9CXEVh5MV89zjLawbJVoDFh8NmFoUKAQ0sWmqAh9zipwnAg9m\nfg6fnezAnKaspRzaBYdQTz1jQTtKKwas\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAc/rEomHBzOotradJav5LnhYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU5ZTZiZjQtMjhkMS00ZmVmLTljM2UtZmY0NzlkYzBjYWMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDk5OTlmNjUtZWFlNC00NDM3LTg5ZTgtMTExMjkyYzJl\nY2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEv4qCdaI2GWcezcJjm8U91Gbp\nUk59UYXl7WqMQnJ08jMKZ80iKyq+O1eNMR9CMNvj6TC5sl3jddGLeNIECYvHWaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUciksUuavB2SXtzv+8xwJ5KLnYMUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgC8IZfuu+\njNe87TRBE1PD/865BZaskk4A0S4w3vAmDS0CIQDWXFfX9tra31Cmv4aTeYSTXzTZ\nX80h/3cnmQhkcl5UEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6980", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6980` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAVGu8G/5xaEB5opLNHJbiXg0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMTY1OTQ0LWNmOTMtNGM3MS04ZGI3LWZhYjE3OGMwYWMxOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJmNTMzOGQtNWYx\nYy00MzZlLTljMmYtMzIzNmUxMjdiOWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExsDjtaC6Uqmbm8AlzW+IYSAmciXXiGPvDlIf2H1NcCwQ3xGlj3uosO5o2s35\nlKPDIaa9RfZbnSA02l10FiHYeqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcS/BxVYfwxT4Dm+WYc5wcS8cH0IwHwYDVR0j\nBBgwFoAUyFZkYj5p+2psu2nAafzPL7bac8swLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiARuxrS\n6hhOaeBznYSWuY9LzJBaysrYOlT3cOA0fSkdFwIhAPt4lWd/1v20eHvVb5tz2iEI\nSv0+W+ZbDe+xjHSChd2j\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY/zKRt//zDmC16eiYA9rpWoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTE2NTk0NC1jZjkzLTRjNzEtOGRiNy1mYWIxNzhjMGFjMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcEGwri4BkZH88Y4lOjPDF2nZovGVUcJWsLTVkQZ7kSlCQ\nmiuRvayOVtYnqhjy8SSL4uwH7pOgmAb4Lx3FlRmAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyFZkYj5p+2psu2nAafzPL7ba\nc8swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALLaLU5+mtZwDZl4OMyLNZeWTJF/jMTw8myZCbCAbyrCAiBXR4Pde7o3\nLPAXApjCH3lj3V5TeUKwfXhlNvh6XlOOKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAdjUXKbPb4v2xoAqQrrtZ6yBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJmNTMzOGQtNWYxYy00MzZlLTljMmYtMzIzNmUxMjdiOWM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzY5OGJlOTctYWY0My00NTVhLWJiOTktYmRiZmFjZGVh\nM2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkBV6D4hqWYUjNtPQVUjEUohq\nYQUekyaLNN/8iJPFrlFo14Hoa+S7PbIe7oryPFUceWMSvPZuv703vCXogPIO+KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcS/BxVYfwxT4Dm+WYc5wcS8cH0IwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAIC82EFe\nhQoEOfL3oiZSvL8AkZ7niqt8GGitPlpSfbErAiEA2u6l/vy9i16QJZmIl1muplMa\n498fZVwNYhaUjVMELjA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6981", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6981` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAbs+MrjLNc+qJ9QQTWF2ZpRRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5ZDc0YzJkLWU4ZTUtNDk2MC05OWE1LTVlMWJkNjYyNzc5YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVlZDRlNmMtNjVh\nMC00MmFhLThkZTgtYWIwMWEzNGM0N2FhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqHNJkRRpxTKzZLvfvyfg/HinD9sJxyzXCoRLlZLVqqO22e/R/FyhN+8VanSp\n3o36EqEgnXvc7pk8Pj2Wbte+caOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk5XCCuAsIiQ13ftwWMkUwsQsYpgwHwYDVR0j\nBBgwFoAUfqiDcZeoAHOZfnR+ejDGJpjNvgIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA34vh\nYXOdNDl5GTxTnmpLZR1Ci54sJWEmvXcCJzxhuZACIQDrG3QoBF3GdYcE8OsyR51K\nIl4AFLrR0iCl+GxEKfYUSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATjz1WugrV4yhTuSvbuQzHlVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOWQ3NGMyZC1lOGU1LTQ5NjAtOTlhNS01ZTFiZDY2Mjc3OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS694QSHSQP3UHoQBTMOYBOcip751NoZlRemdkcpTZcF4JH\nhGR/n9G2qkgP1UxJwNbfQXrYYmbQTK7WdjmWOWCbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfqiDcZeoAHOZfnR+ejDGJpjN\nvgIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga3P4ajau55t4LtF9zUiwdBW/AGvZoIVGQ5J7Sz6TtEMCIB27wEunHTep\nK5Y8xaSBMjmvFYssC/Wz4cnK7+vibc6Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXW8cXaWyeNJPnqlOxDHDZn+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVlZDRlNmMtNjVhMC00MmFhLThkZTgtYWIwMWEzNGM0N2FhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWIzMzFlZTAtMjg4ZS00OTI0LWE3MzctNmYxZDg3ZTE3\nNGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERXjYRQgXaLZ0EVnXZxGrGtFu\nwgYd/2FjaLDT8PbBO/tLYsEFztUPCnxgO47l30zDyQsGFII1cv98/gRH9eF38aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUk5XCCuAsIiQ13ftwWMkUwsQsYpgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgHei6/TM8\n4sWfz7bkB2LOL0ydKnSgM+v9gG7sqDY4cZUCIHfZGj2495wP7wyq0YLZOaFmwC8P\nuyB+CL2GW466uxtR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6982", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6982` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAf4umVlKNs3CQA+LPN/RZqI6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1MjQwMDc2LWFhYWYtNGFjYS05MjNjLTRhZjljYzI2MDRmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA0Y2RhNTktZjZk\nYi00YTM1LWFmMzktYWMyYTE5YTRhZjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEivN6hgGCmOwIPsG5GgJfh5YF/ukLNMXuw3A/6uU3XXzYJ+IbNdx2JdhRu7d8\n4Py9var5U1gScnWpynZZM4C4IKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFQlHwsMA8duMLC2I/41bnM4k7wTMB8GA1UdIwQY\nMBaAFFJtBY4UpzdsSOi3KmsvwKO3w1VPMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAg6/mZzTj78085ekLyDJuDbS3uXGPSKxM\nK2PiT1NH0A4CIQDVOzSEpSFgHdNv3KZmbCySOjvhU98kkgH0FUS77PML1g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeDl7wECY3RCQ8dLNFpk0ezJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTI0MDA3Ni1hYWFmLTRhY2EtOTIzYy00YWY5Y2MyNjA0ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShqMatv0wTs1d5ls4YYjfBckkyO0dCCDRdqKMyksXvuK/I\nW44bnr7LrFrQxozxGvbQL9Lfi7YFMPFMu1IQ8G/oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUm0FjhSnN2xI6Lcqay/Ao7fD\nVU8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOCpuOJ5rwPStJvHD/g2RPlg4KDVjs4Y+yDcW3pK6I05AiASJMG6wDKL\nt+dSad6k87NMIGWwpXZaOLJb4cU4AlzY7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASS7R1eqSFm+CqlMIHXgmYBgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA0Y2RhNTktZjZkYi00YTM1LWFmMzktYWMyYTE5YTRhZjQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTgxMmY4MmMtMzVhOS00MDA0LTg0MmEtMGJhYzBjYWNi\nZWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiAlCgCju77GqW1sGhMKd11HB\n74lBqh1rUA7VZRu8Ig1BQtSHICah7L/qUDSwGAGuoiUGXAZHL10lWpgUHa4q2KN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVCUfCwwDx24wsLYj/jVucziTvBMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgM81uD5bY\n/CBR3cnDnMDuEXU3+TfwBvsmYK5vw8TzZoQCIGsgc5Owm2uMg/gybUx8WhnUYqy0\nEfG7EPkTXC4+EO8v\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6983", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6983` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAeSaB0vOTl0yx5t5IhCa4yWdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjZmY2YmVhLTM3MmEtNDMyMi04NTJlLTFlZDRjNjgyZGNhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjEyNjlkMzItZjlh\nYS00MmFiLWEwYjgtMTFiMTdkNTRhOTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDoOA6sArWXgYlWEcJIZQwj5Y2V/W0UDasq1KgXnr7BY9SY1enjY0Ascfx9IQ\nLh58vNZjugKyzorEeiNI9A6vnqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqHguAz3ci5Y6w/vK2kJE45vVnmIwHwYDVR0j\nBBgwFoAUZNOhMtTTF96qwjE8UGEcAYL/aHcwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAL4479fRQmBt\nhiLnbfRMiy3433U6L/K4lYSvraqdV7DSAiAly0omMThd9oU8FKi7tvpF4oMS721g\nuPvcFUfoWWXB8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfl2j6di7Sl9rb4vFZD+5wk7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2ZmNmJlYS0zNzJhLTQzMjItODUyZS0xZWQ0YzY4MmRjYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNbu31zxiwl2zaJYQg5sECAm9k+uU+pp7O/X0Rbl0hM7cV\nh2H/HbPwAxz+kdGifBgjVXF+LWRVV3WnoEkXKnZyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZNOhMtTTF96qwjE8UGEcAYL/\naHcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANL6Jw1l7diQlG6/CbehP/Jzene7wwwiyFPfemppvwf3AiAV2JmKLF/Z\nNPxZ5lzetreo8YWM/3NNlBFvU6D0wtxxaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdI98h6ZC8j1A4kZO9Oc55RtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjEyNjlkMzItZjlhYS00MmFiLWEwYjgtMTFiMTdkNTRhOTM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDA4NTNjYzQtYWQ0MS00MWFiLTk2NDEtMTA1Zjg0NzBk\nY2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2C8PvEO1M0BtVVJubkEKI4SX\nleB6FpfEqcUSOeQ1HqV6mlOLhfBgif46N+6ztkcgJl2+TksZaRMkFMGDlq9bEKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqHguAz3ci5Y6w/vK2kJE45vVnmIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKF02MaQ\nDnOpA5NMNcrXAT1fBETiLWtaSO2BuFnm18SzAiBQzxdoZeiYov9fzP3j6pM3OmO5\nTSm/3yqO6n4rHrsV7g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6984", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6984` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAZ9Vbq2rbC4z4xU+O8z32IuJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkZTk5NDU1LTkwZDktNDM0Ny04OTFjLTM2NTIyZmI3MzBiMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU2ZDYzZmItOTA5\nOS00OWIwLTg2N2QtYzMxOWIxNGJmOGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnGlE0engryaIqdUOwShdhQYdYbuKxAvY+aPDGYb3H5ctZi4yrFfMn394FMju\noEbIkAw6CRY+1U9KPvdpZHS/E6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ7+d4Tu4MAPH/2SXYqgVarjgWskwHwYDVR0j\nBBgwFoAUO8km561yn7Q1I19mAvwSIzzbBAMwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgesRgUDXR38eu\nhYjV7ZM1OrSJ7OZXl9mKjcYknykdgFICIEEwZ2qBW/L807lRaljcGE+AzKeN3A0s\n4R23u1DhahCW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWv3CRBGHX/aDWiChLYvO7oRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGU5OTQ1NS05MGQ5LTQzNDctODkxYy0zNjUyMmZiNzMwYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTn18IrM7EtlMBleOVqifwujJ2/KQrVL6GCwUdqYh53YgT\nfoOhERgAZ4A6RarZ0oh6NH2N4EjhWz24xzwnb27lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO8km561yn7Q1I19mAvwSIzzb\nBAMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANxP0srs3Y876petlwdYEnhP3yCg7vzwJD641ymMFNwNAiEApwQ4jH2n\n9eTCMK9ueg4IWEKurYD1lndSpHpqw6t+3lg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAXyzhMtbnJ3Mi4OiiwK1HqhMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU2ZDYzZmItOTA5OS00OWIwLTg2N2QtYzMxOWIxNGJmOGUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTRhYzk4OGUtYWQ3NS00YTVkLWJjNjUtYzU4NmM5YjVj\nZjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZXD9VkULLp/kRKS5kzYRz2Xx\nKa5azYZuziTiL1QRjTwOHKGAQ/Tw4ANwRSAlXR27Kep0R8J+7Bmh2oxtra+lEKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ7+d4Tu4MAPH/2SXYqgVarjgWskwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgDKNUqngC\naAn6ZAhSHg70hwaQk9rDPmsy5CJxX9mSaZoCIFzNMPROnUrieS5Qny/56WvgLmx6\nhvlFYIl6Yos+8ric\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6985", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6985` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAfJCOsp1vdKRjYfmq9HSwA/tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyZGZmYjE5LTlhMGYtNDNhMS1iNGNhLTM1NTcxYTNiNjlkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk3YTkxZDItNWYy\nYi00YjM0LWExYWYtMTMxNDYxOWIzMmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz1YK8Ayg5j1MxEf27aMCkopIScLQ3M7UHnk1qZ2mMw2uO6ttWo/uRNO0bhu/\nT+haCaKWYfYlKIsrtMyKEOY1hqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO7FE/Nl8NjzQvDxJDzOlbocIFTUwHwYDVR0j\nBBgwFoAUOE24nZeUYFISF/i8fDQKae+5OXUwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDTRvniwIPb\nVrwbSwCHQO2RweqP3ihdglJL7p5KaEh2WQIgWMaA/RmkZU2ylQbUM2G7KTdQ/H61\naGpP0bbaej/N52c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAet0wjy1Lt6zuBHYvBqzJ80FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmRmZmIxOS05YTBmLTQzYTEtYjRjYS0zNTU3MWEzYjY5ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGsrE4UmlTyD2fBEj0szVcTM88nVpR8xOPXJmeKKMpd8ob\nlsFQJ5VKgPekqPxCm6GgbhwUzm5XbB/FyBb69tD+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOE24nZeUYFISF/i8fDQKae+5\nOXUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDgYSv9lRtu1qgBce+HHXHG9Gr7/x2NgJCy+aGTHcTsYCIAkOf1Jpi+KR\nvoJD4KFeZbY41H3lD0KxBbAGxi4rIesv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATTR0k0goMhgnYTRzqavM6UDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk3YTkxZDItNWYyYi00YjM0LWExYWYtMTMxNDYxOWIzMmVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjcyYjkyOTEtMmVhYy00MGJhLTgxMTEtMGZmMTAwOTIz\nYWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER2XrTd7zejDFLVeQta2Y8jb8\nVLcvo0FUpuZOpzB/LIYRCUjfqgxYgTC5k8yaxErgQGqmiiBwELLDrO6E8Lh1maN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUO7FE/Nl8NjzQvDxJDzOlbocIFTUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgY8wRMly0\n0Q+s3Vcv+YsLG6UKNtzyhedB0iPGZupm2CwCIQD15LrjAXfjziysn0Xxu3owc3iY\noHkbMql7ZjVNHeWdtA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6986", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6986` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfqnv0vZ1/eAGCFquRPxkh5vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MWY2Mjk0LTY1YWYtNDNiYS1hZDkwLWM1MDUzYTk0MTdmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAyZTljZjItNzE0\nNi00YjJlLWExODEtNWRkMjYyNTc5ZmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqdhrmNwASVKcuhx3ONFE29r28IHGGBA8PJ0qLzG20WN0amzNiQD4aZLtjpby\n9TcXAjdDcpSaexpVKqojDC5uUqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXqOaTIzIMrZFnX52PrdXG+QztGswHwYDVR0j\nBBgwFoAUOK10nkqp/CHk5hsurlUospMJbnwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICoFSGqxCqSl7jWx0y7dDDgM2YXiFd/L6Gbf1I9hrag5AiAxmWZcVVbg/iAY\nJhaiZJOqH7nEGvW/S4TiZIfsO59iDQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdAO0kDQs6poY2vDuWB8U+lmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzFmNjI5NC02NWFmLTQzYmEtYWQ5MC1jNTA1M2E5NDE3ZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPk7bkXg+x8tZPDDy8i3sJe02IFXXOkJCcv3/sfmXiY+as\nSw5Dww6yvWGjxSM99OfPxqIPQt3Lp+c0gBQVPh3qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOK10nkqp/CHk5hsurlUospMJ\nbnwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKSJDDxIKsJulN/PYH2bfvchykUqbEs1JG2696wGfzlyAiEAvIxFDlCE\nnm51cgSv9jv9IcyyPQtHzaT6Ne0Z5ZrlD/E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAYYgk1YMR3rPQsLCbUTJ0Pj3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAyZTljZjItNzE0Ni00YjJlLWExODEtNWRkMjYyNTc5ZmQ3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2I5MjkzMDYtZjMxNS00YTlhLWJiNDgtM2QwYmRkMTE5\nNmNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBGTjQ9JOPR/CuAO9icDhOekE\nJG16vZyPVpiTMVExCmVutEzUsewnW9eBgfK5yNf6je9qKP5WUQl/ZTwCkJLfwKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXqOaTIzIMrZFnX52PrdXG+QztGswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgLdCFrFO+\nA9iJMgvuY7ahX/ctet8iV5gzOHHSpAo8jA8CIDwA4QCywXD/WySgYEcDqVMDiC/K\nselB9w9lMvwk5Fv9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6987", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6987` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUGB7K8YylF0fvZeDnMfV8sCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkMzllMDc0LTZlMDUtNDlmOS1hNjNiLWFjZGMwMjdiODQxMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDJmMzYxNDQtOTlk\nYi00OGI3LThhNmMtMjBlZGJhZDI3MGM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbateTIGp6mDc2SE4DnuuTrhcTqy4nKT858IlwelG4il3XPOuhKIkuurgI2IA\nOVPFK8JUFQPcnHmfTqhH5/TC76OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHCEooXN2LaU/OUJSM1elffezgV0wHwYDVR0j\nBBgwFoAUm00dyV6xQ2IKeO00nGldzRj1i4IwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIB70c/Wjo9g+ArypHD3N1tjbQoVTKwN9y/4nPr87PvR0AiEAxaaZ9M5Butxm\nsnhA10IWJ/XR95X2LR4xdCJG8UYEKsY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfAPzKYYdMe9ne8qQqVcyKTiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDM5ZTA3NC02ZTA1LTQ5ZjktYTYzYi1hY2RjMDI3Yjg0MTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx0goFHfkoB0Q1Rhbudv8CQrh6LArUk+NXVeOfB32B7gWX\n4OeKV6psGNte3izMMDgI4zrynvLLQnV37RRXE9Gdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm00dyV6xQ2IKeO00nGldzRj1\ni4IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRMdtJpMb9nRIuBDKodU8jzz5S3MJdaNk5uQSOYnKU5ICIQChST1/qDoy\nq2YG4b+54LFDNQiDTknBW8eGiC6dflN3LQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAdE6R4/XoOhqFKOw722rTmLeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDJmMzYxNDQtOTlkYi00OGI3LThhNmMtMjBlZGJhZDI3MGM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDQzMDFiN2YtMjliNi00MTU2LTlkNGUtMDg0ZDJlYmVi\nZTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJSF7f8+S1O+U8F7GoGTn0n8i\nsS2EWA/i/EgpAfyMvTEKL84pGgJ7yT+0jDMKenAmh8xGK4GHXxsPFUSfUJL0E6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHCEooXN2LaU/OUJSM1elffezgV0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgLLJwSekK\nWOwoH3m7Nll0yvxu/Y0eaiCgoiFWUkqB9EMCIHY4VdNjBE3w+xW4M2u0yFoLNfYH\nMRDgt6K59OnAXLNi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6988", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6988` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAfOtjDMdOD4v2+j7ZPqz+6tdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4YjFhOTE0LTk0MTItNDY3Yi04YmY0LWVhYjMwMzc5MjFmYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjVlMDE2ZmItYzNh\nNi00YjliLWJlZGUtNDc2OGE0YWFlZDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQBQsId5Mz0n2tCX77hDKDEjqWh69ierqGVYKBNA7M85kV9scxozRjQ1PdPo3\nR+xOvZRIZV9bGK/wysfVZ5/LEKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvlRt8R0iR8mAeCQbE1E0W3wFdegwHwYDVR0j\nBBgwFoAUSymrb2rFciCgEaHUqLJrfYX/hX4wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDgs\nMQyZF+kbwqZ4wCNYZZzC/OnyUOBGoOrOGjibGNBRAiB7ByokuoE5iYELiWAmB/Na\niJfqnKbpqgAB5FtxBF5HaA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWeACvN/W7RDL9/UM5gRvKimMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGIxYTkxNC05NDEyLTQ2N2ItOGJmNC1lYWIzMDM3OTIxZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTdTM857LQBtY5KKeT907Xd8BfHaheRO+00bPfzM0HNgDa\nvXdbgQOD72UV8FN6WDmuA1RpKz35dVAFEggZ+2tMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSymrb2rFciCgEaHUqLJrfYX/\nhX4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE3OL90G6dpIk7vCriZ3VkhkuAT0pS0f7l7nX8cGZknwCIQC1QFgBxzlt\nLz9QNmXGkYsZZnzo2Vn3aPjz35UP5gkwjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAfwaqdonljQT/dW3dqvw5APoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjVlMDE2ZmItYzNhNi00YjliLWJlZGUtNDc2OGE0YWFlZDBkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjExNzlmZWYtNzMxNC00Y2FkLWJiYzEtZTE3YzFmNjI0\nMjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWRlYM8rg/gjdSf0Ahxp8KED4\nPSaB+pqNlzX5zkshMlGzz+chhxW52+kl398Ipg6l55hp/CBaz95mG6Wi4PzYqKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvlRt8R0iR8mAeCQbE1E0W3wFdegwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMuQEebD\nF7iY5YPHlpS6+n27X3xq7QpAx0NKXXPq3pb8AiEAwS1YxASJoxwAOJbVLaVvaxSg\ndjWrVJw0GNQZSUnXFtg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6989", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6989` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAelCwL9AQwIFQdgPpcmAhPxbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllOWY2YTQxLTU3ZDMtNGFjZC05M2IyLTE3NWZiMTRiNmNkYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDlmYTRiYjYtZGUy\nNy00ODUwLWE4YTktODExYTViNjVkNDA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO9EC2vYOpyNLLo/axypz+VwAxvt4aEldnjsACPtQynMU4wfZkX6F2p6S2+EZ\nt1EdRIZhCJVnRTNSgZJaLuNEJ6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvppjqk6QzpDaxkaqnkrVmgKWTuowHwYDVR0j\nBBgwFoAUG1Hdr1gMdVc4iYd6FoI+AHW+WuswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCZX6fq7PYIzXJG4jsZFNQD4I+K4qWXbSGZYfHHSh+mYQIgQq+q\nX/JI4uKr0Q34ftgz7qwzmKtyt9ckbPLVYT+C8lQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXkebA44IZ+TySyt1qOr0rvsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTlmNmE0MS01N2QzLTRhY2QtOTNiMi0xNzVmYjE0YjZjZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZR6GD1+JiZMRzJ5IGQ0CoIWIhM9hc5SM5pHStprJNINya\nKjOSwXo3paZN9dwZ8ACQUG8J7jhmTqhS7TL4jgn0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG1Hdr1gMdVc4iYd6FoI+AHW+\nWuswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNzIwDbZihKKyxzSoZio/p81m8AHaqvxb9NHmgFl2h6ECIQCY2qlzhd5A\neheULalvx7awHnZbqDhzhLzMwBIKMxbivA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAUl7JQE6lRnO2a+lPASk2sx/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDlmYTRiYjYtZGUyNy00ODUwLWE4YTktODExYTViNjVkNDA2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODYzMGU0YmYtMzQyOS00MWUzLWJjYTItZWYwNWE5NGQ3\nYTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY1q9PZdXuXBqdQZRbx/OfwE7\nrnxBNpq0o+NyLkMEZhvpPaI3YXX6Cr8AtjPU0QBBZfQw2ymcBl7QYdewXhHbsaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvppjqk6QzpDaxkaqnkrVmgKWTuowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgXB4aH06f\nH7AEZh6g+nzPlY2Gwnv/SO1R3WkHtdNUgLkCIEsko55gXydRpt0QBc/cpcwnA49s\nmWYQxoKKqeHInUHp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6990", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6990` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAcyc/Wn3BkycSSpOnQbRzhwPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMWQ2OTA0LWQ2MTUtNDM1My04NGQ3LTQzZDI0NWMyMDQ1NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNmNTYxZTItNmRh\nOC00NDZkLWJhZTctNjVkNmExNDNkN2JlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExVop5vaZmq/TBYC3ToiqR0sg934bWfoJrBf4fOAFlXKsZZ56ikOSmfY/SGkd\nln0o9eoc4t/9YjwMfXakcvi0YqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqXCy5ie4Wies61ZNJrCIXTUeThAwHwYDVR0j\nBBgwFoAU9Qq7LdROJleFUNcI7Y9+a14GcoYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIBjz7/LWVK9z6iiryWLsRnBERrDUGhGo6JvBVETkn+vnAiB59iMK\nx1kVLTQQP/u6faTycau5o4n/UvJlM364ADE/DA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWanYjesyAk7HrAQLFsjfyIdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDFkNjkwNC1kNjE1LTQzNTMtODRkNy00M2QyNDVjMjA0NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjWxZBbBVPWNlrEscY96SFQDNaVOCtqUuzbCtApbX0kMgI\nL5lNqyQKI83iV2PvheBXX7PDOH0/UKFjxK19O5Hyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Qq7LdROJleFUNcI7Y9+a14G\ncoYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbcFghkQ4+OzkIT+DEGAshz5gC0GGrD5RAznyY+1tDVwCIQCelrBgVOC5\n2Pu5e48bGPoieB2cGNfREwUrvonmSS76aQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdfN6mu1mt6lDdjOmHXGeJfXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNmNTYxZTItNmRhOC00NDZkLWJhZTctNjVkNmExNDNkN2JlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmQ3YWU2NTgtNDY4MC00ODAyLWI2MjQtN2RjYTdhNzQy\nOGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEf6tsQgYnUCEi1qIO+Zgai7aQ\n2dCSm5VOkSKEUk0C41OKQt8PRzLVP+1I9FyMLAAQKtYEaa6AchuubrD93M2zOqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqXCy5ie4Wies61ZNJrCIXTUeThAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJkEZWnj\nGaf6pJbVTgYqaFz4yBWsYEvKSqoNZy22rjufAiAaOplS3mrHecsOBrs2a27S2bx4\n+zB6YeXziivP3ejcig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6991", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6991` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYrUs67gEkk0b2Gl08QhQAK1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiYTAwYWNiLTNkZGQtNDVmOS04YWM2LTdiN2Q4M2Y1MjA0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA3NDkxZmQtYzRm\nNi00ODQ1LTk0NDEtNzMyODNhMzI0Yzc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUh85ZdkT+eOkwKVm9Agi2+1OtwrHnfotwzRg7xX7GhwTMoTMeBnuxxqbFIhs\n8N/V6cicK7K6NZztKmr/wwyB9aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFP8jTkvwtQCR3vT6OUQtgArrS9HfMB8GA1UdIwQY\nMBaAFIwUOgFGacY6dd8YaPbfwD4+QnZYMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA82EkHnEtLzjTRFA2po2wOf6zeOtGOeFv\ntmTguM0xac4CIFRHutz9cIzbdLgxUtX8s4RIifu3MscQ0Dl837VvVsc2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeLH5DAN49c8jrVq/Ds09NGeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmEwMGFjYi0zZGRkLTQ1ZjktOGFjNi03YjdkODNmNTIwNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0qOdQA05nNXMjz7BL4gukHUsfhCRp1af2rBLsDYHNU6qj\n2KGAeI9MTbQxUl3F5ARn4BnL65/qrx2LC1rnNAfBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjBQ6AUZpxjp13xho9t/APj5C\ndlgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIBQtI8xNdyX/50vegXYSc0wKudH2hcqP6/5IS3z0nIrAiEA516FQ33s\nFlrmWMxODxsGg4GPclSKzprMYPdLFiaUPNM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAQp41n2oLQcCQFLlTWYTWdZhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA3NDkxZmQtYzRmNi00ODQ1LTk0NDEtNzMyODNhMzI0Yzc1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTQwOWIzNzYtMTcyNC00NWIxLWI0ZDAtNGIxYWY5NzM1\nOWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUXdN6PsYf54iw5CykLcdJoR7\n/R/KgRzWxeInNR2O9kRVvLWIlUxSx1eabd1kRpPIYkGi4k8B/X2EAwWmmNzDI6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/yNOS/C1AJHe9Po5RC2ACutL0d8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAN/SeqhN\nvkoaP/WJesj+M/7ffdfB2JVeuDfeXqzvSFL2AiEAyvPntmiR+qXT146JTBvNKwic\n7cOko5tDYCSDhRplgw8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6992", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6992` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWL3sfna3GvqYRHzZ6EtdCn6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlZTI5ZDU4LTBhOTUtNGM1Yy1iZGNlLTM3MzI2YWNlMTlmMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQyZmY3YzYtYzQ5\nMy00NjI4LTkyZWEtZTc2ZmE0NDAyODA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESxsXqn3zL7QLVDvK+iXsBrE6ts9PSacTQLjq6m8F3YLHxD5k/F/pxoc5fcuf\nSWJVQZCbcijiFx2YFbjgA/rEvqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT056wW9Vd0ZK5YAFqDn6c4EbglcwHwYDVR0j\nBBgwFoAUZ1yLaWyJVl2aIrIRCCe4HpRlg5wwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANslkZMhMQKR\nV/e5xqCXIuNCGLdlhMYqU3RAZD/6DDOoAiAQv/1eSz7v8n1BNywTwim8ImZHpTDy\nGiEHG1jBDOSGag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaEeXb+5F/51AYjY22aSkD3kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWUyOWQ1OC0wYTk1LTRjNWMtYmRjZS0zNzMyNmFjZTE5ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYmqJ1UTy77dp7osu8p7EIon/Zdaw7bZPyfYeZMGd9wRZm\nFLrm9+yjZ8aNwlLUxygEp1R8TsInZeRbmL/fKr4Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ1yLaWyJVl2aIrIRCCe4HpRl\ng5wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMDlQA28onpx59Z7DSsOJkBtQ9+026N66dHIWTqib1lvAiEA5jICR9eJ\nhB0yRKDqj3siqtKwJ3nRKH31ZX8FJXqt2pA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISARiDqaZhvNlbIVle44+YtJUJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQyZmY3YzYtYzQ5My00NjI4LTkyZWEtZTc2ZmE0NDAyODA1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWViODg2YmMtMTY4NC00ZTFiLThiYTUtMzk0NDc3Zjhi\nMGZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqlKwoM/n6GyXHlyMp09T9Hlm\n6ql68PoyZFDmQ2Z4K7+yDPNZxLgUFkusm/6eGb9wSSxlqufsu4LhpdwUZYLofKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT056wW9Vd0ZK5YAFqDn6c4EbglcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgEI9uE3Be\nJbbSorGjDi2/k/vYJ4mKO354PjsYLeG6bbUCIDKYGtl5uw4rdZXiWS3V5jGCXx7v\nK2GHTaXloI6AHscA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6993", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6993` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAT0w8aW2vdKBG7KKw7YPFOmwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwMTUyMDJlLTM4NTAtNGE2NC05Y2M0LTk4NzE0OWFjN2RiMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJhZDU3ZGUtMThm\nYy00MTM0LTkxNTEtNTViOGJlMWQxMzFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPsehDvWuQCJoKL71Zq39/fn8ky7tFf9L0EALDMi98Zw812K4NSh2f9bj5oDh\nmPtVKzJy3cRDBzSXzliCHfQvEKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmYRfaRlvMMOcCQlJZN8Wjtuv6kswHwYDVR0j\nBBgwFoAU4p33wZRSOBlB6oH/Z9ubr7Z2xiMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgflmwiQRChie2\n+O/3DKF7gKDsuAj5qqdJ0u5lWBVTiB0CIBsUoaRHpuYniMCUsSd0x/im4v/n1E6D\n8SWAUndya+/O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa7cgDkJr6jqvVvH3B1UJMlgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDE1MjAyZS0zODUwLTRhNjQtOWNjNC05ODcxNDlhYzdkYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5YiS5CdLtLsS8X6j7f1lJFyl5/BvHjv46fCtz3GIgjk0K\ns9uiCWIT/6BWlqsmuYSklDCWEjMD1toB3bBc51ujo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4p33wZRSOBlB6oH/Z9ubr7Z2\nxiMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAlJ7A1mh/FQTPsLfvPw+fz2wBSX5sHBwJdCTo86ibQsCICQOFGnvMCkq\nsfGjneFgOpTI86eNPDNNmuH9fQ4/B/xp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAQrZTO6IWReQ+ZVWQbGxob/rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJhZDU3ZGUtMThmYy00MTM0LTkxNTEtNTViOGJlMWQxMzFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGI1MzRiMjktNTU3MS00MDZhLWIxMjAtN2UwYTE2NjZk\nOWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFSYTU9lVl1pM7scmjHMYny0W\nll7uq4VGAQMlC1X1rY06syIoEUWOK4Cdt6ePq2CXyJe/1dw+Rtnx6dBLIBJNVqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmYRfaRlvMMOcCQlJZN8Wjtuv6kswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgItWIPhaF\nuQUuSRWlfch81Bcuwp7Yu0HXaJEsYGrFXcUCIFMzNJpC6VZYjxtqZUseM5wGdTYn\nzWlhfV7IV1SKZ+aN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6994", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6994` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVAKv+OQ3SmkHrgRvYVGnYIfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkZmY1N2I5LWNmZTItNGZjNi1hYmYyLWM2Mjg0MmVlNGZlNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ2ZDg5NjEtNTgy\nYi00YTMwLWJiOWEtMTliNmRmNGMxYmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEstZcIYSzjQpuOe3lPGanGQ2+OTYXyC5u0WpTW7tRJzOZxvPGYfRMB4gm9CBV\nYPZt/RTS3KE9cYRNyKhaU+CtrqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6HNwpfaQAT+IeuoYoP8QXrnr6IcwHwYDVR0j\nBBgwFoAUk9d7Q1/Opf7KC3Z8EN0hQQ0gssgwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCl+cScjjuX\nZbxBpa2NYe44Ph/ReVfcOzVg0Quil4jrTwIgH9rnBl9609cTDMty7c0bi39HFU5w\nOvBINN1zLWqwJK8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAROoOUt9Qpk5lCIhTPEzVJfRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGZmNTdiOS1jZmUyLTRmYzYtYWJmMi1jNjI4NDJlZTRmZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3pf6920piYIzWXXZi1HylGrAdAa9Lnf1DAO8D4SZV5FnA\nj/e2Deu2eKiXPj3Piqzj/TbOGFAyiJWksoE3Kinko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk9d7Q1/Opf7KC3Z8EN0hQQ0g\nssgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEOxYrdk3yBPOpaXg5uGUzW34hc8AjEEufmKSgB5+9rwCIQCkQ8R5hUb5\nG4FjlIROf3b2ClVRsd+iOTOBl2rO96wiFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZDtBUcM5q75kpvPewkxTnOcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ2ZDg5NjEtNTgyYi00YTMwLWJiOWEtMTliNmRmNGMxYmRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2ZmYWZmMjgtYWJlZS00ODc1LTk5YTEtOTFjNjk1ODVk\nODg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExdb8no9Ow68uVwW0+uxWK+dt\nzmv4SNkZJF1pjeUZJg6167+HzkitxgqoefABAGfiKKtLgVwiptEojwoFAxuTrqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6HNwpfaQAT+IeuoYoP8QXrnr6IcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgXQvriPt3\nWlxrpj+6Z411OOH0Das/vzHV6YkrqOWk4QwCIBvu5d0sJTUNGBEwnKxXOsNDYN8G\nT0U4W+rjo2Lk9XjC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6995", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6995` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcgIAs+/sGjXJpcb7uom11wgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZjg1Mjg3LTMzMTMtNGMzZi04NDE5LWY0ZjRiZGE5NzY0YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJiZDZkZGEtZmVj\nZi00ZTVjLWIxZDQtMDNjZDdhNmQ4YWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiDVlXLte+oadZagfuj8nvLhQIVFHLwLyzcxWbl++Jsk2Hd0VsRqiurJot3Az\n5G12a+iwYwuauM/Yhvk32+DbHKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQVEYagj012RTBpdH/9Qh5XZ17YgwHwYDVR0j\nBBgwFoAU51umBgdTxahd4nj0V+yC8pmaz1wwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCWCwuV7j8wJtE0/KH3zUv3NDr4WgXWcArMwM7WI+F0YgIhAJTwJafYyoCy\nPXY8LT8s6SAYxRPqKa+OuDr6msRu6TuU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQEHfS3B5g8DXarIA0o0ggG5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWY4NTI4Ny0zMzEzLTRjM2YtODQxOS1mNGY0YmRhOTc2NGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ10e6O5mIykO5gMUd7RomPubHqtMxf5AbAurd03fNm38DF\n5JcCrL+9kWaJx8NlBA7tYs8bFRoukPiuMLJh2ZzQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU51umBgdTxahd4nj0V+yC8pma\nz1wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMHY6IKYci21PP7jwvjtj67WKtagoxic3Sul3swP63HWAiEA4KJjHs+2\n6VG+TOrgVO1giYKNSqiygaCvzA+26yEy04g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWQ8iH4f0n11Rwj1Y+u8U6wrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJiZDZkZGEtZmVjZi00ZTVjLWIxZDQtMDNjZDdhNmQ4YWUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDVkYjUxMjYtN2E4Ni00MWRiLWEzOGEtZDA1MzRkYThl\nZDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEv6DTtdBoVaJIez7bo1kj14NP\nG1QKzXRzaIKwQndIzG0y6T/EsZbkJ6kCVlJUjhXX2oOqOtph0z9JFt8PUjCxa6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQVEYagj012RTBpdH/9Qh5XZ17YgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgC35rM31A\nz6NsEE/J+RDhQEReP1zRto5Ng+L3SUvV/5ECIQCSpuSSCp+HFLuRtCKzPv5xR3FP\nCrbO529v//+vG55eMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6996", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6996` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAY0wV/RdHhy+Ao5gmuAFaFKDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5NGI2ODQ4LWZjMzMtNDMwNC05N2UyLWFhMGQ3MDU1OTc4NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQxZWUwNzAtNGM0\nZC00OWIzLTgxMzctMTk2ODExN2I3NTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8UiPxchi0/JdoFPa2dllHnqmAn/AAierw+xe//rGx7GfyYVf8ro4yXQS5+e8\niYlWhJH6X2s7srWRqbx2C24dtqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyaHQVXYsVbqlVVaSRU0bW6Coq/YwHwYDVR0j\nBBgwFoAUUAN5OAwpObntgdYatJF3d5kKCMswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCEBpKhkEMUPoU/s2ZkPivp7MzRKevtFUnPZjxrv4hpEQIgUghGSM/F2AHg\nstgHq+YSF1ddN8Y5YLoV86y2sHyS9d0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZlxaRzZJNAzR6T25c05CsQUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTRiNjg0OC1mYzMzLTQzMDQtOTdlMi1hYTBkNzA1NTk3ODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXXYP1rkhgwZJKCYcBVXT+3qNmX2GFLY6hY1SohcWWcunT\nxybcSArjTq8Ec6PL/RsNaskJR2MUxnpNebbw8Dy3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUAN5OAwpObntgdYatJF3d5kK\nCMswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANHvdiSqtHZ2EYSQyKu88W7hZAVK0RbiymKnBblp+C9pAiEArV7ElCY3\nHJSfXQrPpHDzTZ6mP153ED6QJUCW0Qj9imI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAV8mMDRaBvcK6NNdV7ZfNuHtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQxZWUwNzAtNGM0ZC00OWIzLTgxMzctMTk2ODExN2I3NTc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGU0NmJlZTUtYjMwZi00NTM5LTllZDItZmQ4NmUyNTM1\nN2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsruoP+J2LY8kcIal8dTc5G9l\ntkWXZZDJLICDzNypvsx67UuR3agtLUGmm0wm7ssALkQPRaouq/ADqfSX8esCiqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyaHQVXYsVbqlVVaSRU0bW6Coq/YwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgMyqefeTS\naRBdaKWQkr0Rbzcyrd82TCx0UDXKq+h6o2cCIClYSxEfj9Nla+MJU3AzQAK4PW1Y\nPMhJUbnAqzSrp+8q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6997", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6997` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAQ2IQytNGcx31ZxF8eA7671BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkZmRkMzUzLTE2ZTItNGJlYS1hMjlkLTc2NWNmNDBhYzQ1MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQzZDkyNjUtZDVk\nMS00OGUzLWIzNjUtMDU1OWZmODQ4MTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUeq5OEToHPczToeBxELGYeBY55fdLBLnYW+/IBFqfXoT/k+bJti1gRPLuA7i\nURcN9nH4pf4tbJlC2wxbOAEhw6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB3zylXReejhThO3Hrpso3CIxe4owHwYDVR0j\nBBgwFoAUAmhbTciaCTkY8aNwCu/n7TxsBhIwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFoK\n3xG5orTI4/lnOrfpH8HihdgCBcTOJE7sbW/BElD4AiEAq674fcf2OrItOdFusJic\nhTQ1n5SvRq3ggSgZh9cODLQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfEDaFW7wTRUx98uzCZqO4S9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZGZkZDM1My0xNmUyLTRiZWEtYTI5ZC03NjVjZjQwYWM0NTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASblikA0+2sn7OrqIimL3HfFQyCEKrQKk6E2PhC5j09+rMD\ne0c8fxHqIkSaZGHcI6i9kv/JLReLR3LCBTY00oTKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAmhbTciaCTkY8aNwCu/n7Txs\nBhIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ0pcIbOR5PbDkwpXpdbmcp0iDNV8w2vPef2/nxOjjxgCIB6YmlO7mgEd\n9gKlfZyurRebfMUrW2RDAkdmkOif2gMq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAb9m33yMTo7CAMB7xNNemcvXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQzZDkyNjUtZDVkMS00OGUzLWIzNjUtMDU1OWZmODQ4MTIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjA2OThiMTUtNTY4OS00OTQ2LTk3YjMtMzhmN2VmNDQy\nNTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHuktrmU3Av8YAz9QcJCdsuDe\n1IBHU+6soiq29sB+KvrVL/YPUGwDo4xLAAuhd8nec2LSDm2m326es2rYbJ+UuKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUB3zylXReejhThO3Hrpso3CIxe4owHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgbluOL5Kh\nw8JBKafWgIuKtPKj1viIoGVgDoQLLxdRLo8CIE73HrwtShMmNKwWVYr8GCbhpEqZ\nX+Rgz8FlCnmiy178\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6998", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6998` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATdYYxw7aOZRu/nPlaaC+SMuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2ZDZiYzcwLTZiMzUtNDk4YS05Mzg2LWJlMzU4MzMxNmYwNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU0NDFlOWUtYzAw\nZS00OWI2LWJjYTgtYThmMDYwMTRmMmI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Y5F9enZOHdJyqpdPKfzkYP7eSbar4hV/xbJil6+/ntW/sD0f5pK+qI7j+EV\nrrTRWKIF5k/YqtY4HJaxHEL2LKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURevSKIjOwc9ZZqt+q08m0pH3NcowHwYDVR0j\nBBgwFoAUGvDrcI55dZtB55xkhDZv2Sby0rkwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCICmeDfoWxbypMjAjNYGPIMAbocSq4nxyfVmbtMrRjltsAiEA+2Jz\nYcWbdXmzH9SzIsevCPfz/r4atmg9eNUm+8W4H4M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU63EBzHkfzw9WcU8babARfEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNmQ2YmM3MC02YjM1LTQ5OGEtOTM4Ni1iZTM1ODMzMTZmMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASddFfBmK3AMWTLanbjOPjbnDvjlrHbmLZlTyOnuuxkK+Ls\nVhoCZyutBtajwyCjyY+cu9EPxnoFCniMLdGXDBExo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGvDrcI55dZtB55xkhDZv2Sby\n0rkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKZcfUvEgJPT48OhIIX1fJCu4Lmyv1tBXXNA3NnGi/eBAiBoT0f08Xz3\nYTaa5L8XiCrymIMY+ZJAD5OxN+wot7/+8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbvc0YBa/rttNlkj1N3UgIBOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU0NDFlOWUtYzAwZS00OWI2LWJjYTgtYThmMDYwMTRmMmI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWVmM2JhMTQtNjRmNi00ODdmLTk0ZTAtOTQ0OTkwNTM3\nYjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFQQpxcUh96fquiWEegKP2qCI\n/prZoDXt6QBLAUWyCIKS+phEXLobX7/vHKvP/MsSTlWafr3xf3NFxBm+CUs5xKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURevSKIjOwc9ZZqt+q08m0pH3NcowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgSX2jfft5\nJiD7WENQfWKz1QqrHMkLz6+sBlARYZ1zS9oCIQCjM4IgieuTiK3GFCcTFWrYUbRS\nEaM4uOg/kOpoDXCOqQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc6999", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6999` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISASfrtMbjJ+a21sgy1FDEu8uXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhZjQwZDQ3LTY3ZWItNDExOS1iNzgyLTQ2NTQ1MmE2YWYwNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNkZDJhMDYtMTUx\nYi00YjZlLWI1NTctNDcyOTlhY2VmZWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmQ8kf0P/jo3Q5PtesRY3S/EqKsvvlEY6WDZo4IY7kyv6PLsXrMMCe5P/vsBx\nRKXqyfAvb7UEuy1uq0o8oTfh7KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw3yukICCRsGrujsik5cw8H47q8IwHwYDVR0j\nBBgwFoAUve8Dxr6inWflpelUEvAu9KaKcFIwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDkqOeme3BuhJ/PoArCglvyq9elNpC1+3afce6MjicOuAIgdmyY\nEpCqJs9xTpObPjPJsrw8m5SFdrLEUaIy2KjEm28=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd6cgs6OwDX/xXZgHcokOxGFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWY0MGQ0Ny02N2ViLTQxMTktYjc4Mi00NjU0NTJhNmFmMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVTLCYVtpXrhrvqsE/9xVwJBDDYbqoBl08CSDvEm10qv+8\nsdMoKS013a9RC9gWD4Va7ktseAKWLOR9zygxsR6Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUve8Dxr6inWflpelUEvAu9KaK\ncFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIarNwGsJInUdG7Q2Z0qu3Io6eO/KgeC+sqQt+RdVEi0AiEArI1tcJqc\niA2RUf2X8VISOtarau58+ojXEzOsPESgi9o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdxMrxoq4KqR/fTdtsJNhr0fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNkZDJhMDYtMTUxYi00YjZlLWI1NTctNDcyOTlhY2VmZWY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODdiZmUxZmMtYzEyYS00OWMzLWIwZTItMWI1Y2EwMTUy\nNmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo8ywntWnuStMESQ2BvPgOsHt\nfUzCqzDZY/XotCxHSKsFKxUxwsDN/0LskTAcnOTHsos3jSoBecy3yvauOqmrhKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUw3yukICCRsGrujsik5cw8H47q8IwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAL5cq5SX\nQtDi+UzTlgeW8tBrFmeEwGEHRhbVTodBXDR+AiB0C+kfHnguNYIsdRgPBMY6WNzM\nhiDvGAKQKFef/qqC8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7000", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7000` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISARrNl4W0DkF2H4GrB/LHimtAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1MjM5OTc0LTEyNzAtNDhhMS1iMjBiLTRlZjQ1ODIxYjEzNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTRlYWY1YjQtMGFi\nZC00ZjBmLTg2ZGEtODI3NjY0NGIxMjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDrXCYeUMuw//9IlhUe+Qvw8Ac/+Sjh0Cmhl0Spvmn/IBrVsrA09ZbjTYGaEF\n3+9yqsuBvILDzvbtgYkK2ii4i6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBREbZtG6zOnnhyoEu6Ff54/CMUmMDAfBgNVHSME\nGDAWgBQkKmdLFcqKNHm4SwTebznproGZyTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIG3kXRwriRoZER0kgN4VbCNzJTzRUC7F\nbqgDvMrqdztLAiAsIb8PTJdKXbfLqEd/JBpY/s2YBIJnrJspdLxOyQXd8g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa+iFu+VTewnI9EdOxogwmPeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTIzOTk3NC0xMjcwLTQ4YTEtYjIwYi00ZWY0NTgyMWIxMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+6A2g1mS+DqEFGF/+IK8npmOfe1BpSoZ5Kb6otL1Fcbm2\nRl+9TYah4zOFs3jvC8p9KPIUq+stevtrvJvJWeCxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJCpnSxXKijR5uEsE3m856a6B\nmckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMMR+dHUBEV+LVPf5huXfOlCbRNkGWvfVxSqDlUMlI/NAiEApeLdT0D4\n1jBL7si8uyygJI6R6JLgN0ZVIX83I5MxtLs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAetg7kCjHUfnFnjFrVDnQmjPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTRlYWY1YjQtMGFiZC00ZjBmLTg2ZGEtODI3NjY0NGIxMjFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzllMGViYmMtYjU3Ny00M2ZhLWFmNGUtMWE1ZGY3ZmJj\nOTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8ulhLVfvIHeAJ/83n4kK3kgZ\niz9Om3b0qLfy5N7F+NK52n/VwbkfEf9261GfSL1ja39PdzgvqRBCEQXFfMxKp6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURG2bRuszp54cqBLuhX+ePwjFJjAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKzKfAez\nL7bfU4G480C/65fk5Ig5UECQICtmwBXoVMTzAiEAiH0CSq90DOxDyC81e7a4r4zP\n35RvWmZDxlaXEzqeVx0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7001", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7001` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARvgFR4Y+fmBPb3f9e41LNXDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwZTBiNjkwLTYxNmUtNDA4NC1iYzBjLWFhNjJlYWI1YmZmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZkOTJiN2UtNDYx\nYy00NWVjLTgyMzAtMTFkZjFhOWY2NzkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO9zgj3adiURPd0Wbv30/IH9lzRRx7WSWMsVt8O0AsEv+6/QCaH6+HZ2DG2fl\nvDfxv3/04HRdAfHE4snVxsxDjaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4qUFdcAGtQGIHGs/W8xNr9/WBrgwHwYDVR0j\nBBgwFoAUzYhJo54UI6phObASB0tPc7+3sYMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBLcf/4jmoXI\nBqQ1fNh6wL65Rntj8GWF1+exn53sHJGBAiEAurvp1IDxMMdU5N8jKtd1sXY9fI8y\noCJ5N4tNo9t01S4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARBakbx/1eU769d21Bsp33zNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGUwYjY5MC02MTZlLTQwODQtYmMwYy1hYTYyZWFiNWJmZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQ8/4i6KmggvM7whslLMiKsxoor1YpK1ERmaOlYSXKbUNr\np9SIhHPURuTX1c/qVusyxNo7wbKrcqHzh8kzRnSOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzYhJo54UI6phObASB0tPc7+3\nsYMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRUJyLUmJ1xE6zZrG795fnjGJCyYlNrmFO2v3L8oxdMYCICswW8YwF1Gw\nufhPuEDGf10Z+oOIk1b8p7zMlhSOdOnQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISARSK0e5/UVwfwCitEm1C3RCcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZkOTJiN2UtNDYxYy00NWVjLTgyMzAtMTFkZjFhOWY2NzkyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODRmMTA4ODAtYTc1ZC00YjQ4LWE1M2QtYjI4ZGQ3ZGI3\nYzVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnX3SfiSLZA3jAgP94Hf/EW/i\nJc37g7XnXYhmmD30EBzODr4nH5ZcTQTG84ASP3+jI0uZXNdyfjF4PMNdOlHTCaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4qUFdcAGtQGIHGs/W8xNr9/WBrgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgQOAJB1bR\nWnV3yp+6drHCS8REVMDPrs44oq8tB9uGhGcCIAezsNGWvVO7ILFo2AaAtVwzyDOn\n0kTIE13g32ZLGTtH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7002", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7002` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAXWADr+OCsnhbTkG2714t3zmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmYWU0MDZhLTNkNjQtNGFkMy1hM2Y2LTMzNDdmMWJkM2RhNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjMxZmNhOWUtZDE2\nMi00MzNjLTgxMmMtYzYyMDNjYmViYjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEckUwOVBcxmSY51tZuChses1ZpBAoLw1Ve7IUngR3hd7MBNXlze6QxG/BqPke\npFVUwHHklODty2J5Q4JRLGefBKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUujn7pXWUhPAupvZ+DjXMqbaIIM8wHwYDVR0j\nBBgwFoAUCjHzcFZhzcJrE6rJ4FNTye+02LcwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCID+i7sA3Bssk\nHsGxGn2MWXlK477yaXof6SFEnI/kudEqAiBn8CbL+zEufELcZlCFO4SVTDa27Ozm\nr+QYTv8HXbLcrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfi0YwoKLcsmjifyGC4SxJ5xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmFlNDA2YS0zZDY0LTRhZDMtYTNmNi0zMzQ3ZjFiZDNkYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkC21YHJp+0m5WbnBvfwTiSthXECOxe+fxGw7Dzyiz6mNM\nP3nzMV17y7tbBXcqKhjUTOcsPzaTbcpPMa+Jt1Z5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCjHzcFZhzcJrE6rJ4FNTye+0\n2LcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGDHoLEqVEFUf43gFooS0FGPC1yHf2uHb3kG/9XH30LoCICIJU7p2D8Xk\nGTjQ0Z1XfjyQofYQHTem7lUra8RFA5Gy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISATmdVtqthj1JR5uXeZAxxvFhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjMxZmNhOWUtZDE2Mi00MzNjLTgxMmMtYzYyMDNjYmViYjJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk4Y2IwNDEtNDc5YS00MGRlLTkzYWQtODkwNzVjY2Uy\nNWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXIq8KSJP8WqQJl52JaeRUYlS\nBcyznmrAD5Pp6vWNBgkBRYCR1hoJ+7JMqHehXOqEnRX4gwEwbOyMlLtTy9y4hqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUujn7pXWUhPAupvZ+DjXMqbaIIM8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgNgWxRqr8\nmz+oFvpNduxlTG4bHi0x8tCWxK3YmsAI8asCIGF9VBTFGZ1iG40L+VtFzJh0PtNc\n2MBmy/DFR0OXXZ/d\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7003", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7003` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAdiYtFwILJlzrJYegMAPiWSWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1OGQ0YzE0LTcwNTgtNGQ5ZS1iMmRlLTRkODA1OGU2YzE5YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBjMmNiOTctM2E0\nMi00M2FmLThjNDctMGI3MGZhMDE3MmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQHZzAXtN9DqQuooJryyC0invqzvR+LhZtHnon0RqRlN4fM8TxAajVKnu9QrR\nv0ibxtBZyZMynkkemym0klJCAKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuqdxUawcXpVSZGEGKTT4PyHcw1QwHwYDVR0j\nBBgwFoAU7p9p2Fxvcl/6pUte6Pfxb49YQcEwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiB2ED25HE0+\nfJfH9kv9OvWsb5ekK9qhyX5hCqKrDT+KSwIhAK6fyn86tcsFjqq9+LRxdJtgDVFB\nxwmpqO05nqdp8MMt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXmXMVdF4TAmW6yNf0XPjZnPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNThkNGMxNC03MDU4LTRkOWUtYjJkZS00ZDgwNThlNmMxOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnP2aBOwCXTI6VpWtE0+DVgXPNOSwiWimuICpE731gnUU7\nfnHrgkea8jTarOhfr2m4IgyvyBkJzpW2l3JLerWuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7p9p2Fxvcl/6pUte6Pfxb49Y\nQcEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJUg4FUZMrIua53MbeB2H9If9N1cywOKVVUi/uCGa2s/AiBRSMfXomYv\n6JnvrZoEaJbF/nQzIaHsVChNfRHnjxjy7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYid62cypOu0gHz0RXo4HbZrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBjMmNiOTctM2E0Mi00M2FmLThjNDctMGI3MGZhMDE3MmI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDkzZGRhYzctZDcwNy00Yjk2LWIwOTItYTY2MzM4Nzhk\nNTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEz8eX3Woj8hkdNekX/3X2u9as\nLD8ZfzgkBrc/crSPiTmp+vjcR3NmD2kyu+UNPQ6bSzA5kxZ056KQRMt22T0RgqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuqdxUawcXpVSZGEGKTT4PyHcw1QwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAIxNxEDw\nXVZabPi1UPZXT2dM1uyq3dcNvwTN9o7sF7uSAiBI3h9jNtjFfeIu5e8WY5G+68AF\nlCowi8RmQ0NXa3q0Bg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7004", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7004` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISASvPuaWJJZ1SKY909EjXFn6VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5MWNiNmNmLWEyY2UtNDI4ZS1hMjA2LWYwNGIzZDZlMDhiMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWVhMGE0OGEtNTk0\nZS00ZmUyLTljMGEtZmM3ZmY3ZTNmZTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMA8+DcF/tLDgVoiLdsBrbEHhsWvZA/Si8VpFN8wR6orRM72JCo9OICKCngLT\n8ANFf8MCTCcUHbfO9WuJRuZZLaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtS0MlyxTb0sNJoLeTdAK9pkHY8IwHwYDVR0j\nBBgwFoAUXi7XU0CQgsmGoqia4y1j7QVXdS0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiAUG+PmnuzmCR2/c5BLyRB098p/SkckcgST+lARJPKecQIgGBsxfaPUvT45\n6W2GgTcIGBNHRqzYWJiTyqyxKrFEGiY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASXf+11PU2wvIuqQZiG3eocUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTFjYjZjZi1hMmNlLTQyOGUtYTIwNi1mMDRiM2Q2ZTA4YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi7Haa1Kq27Xj2mj9BHo+YW2W82MKVAD4rIkeQV7PeBulz\niriNuiA/XxJBmvinJLJrGygk83vDOKqqsCmA0x/yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXi7XU0CQgsmGoqia4y1j7QVX\ndS0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM0G1yQKc4HXxd18gnhUY2wEYS2Pa7DBPygB8jN0ap/wAiEAr7zOtUT1\n6ctqYMQZg0gXAqRaOGs/uWRn23an7CesfV8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAclFi9lASr9U0TZ5HV79AstBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWVhMGE0OGEtNTk0ZS00ZmUyLTljMGEtZmM3ZmY3ZTNmZTNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGRmOTQ1OTAtOGM5MS00ZDFkLWJiNDMtNTcxNWI1MmQ4\nOTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3pQCYEgWvarQ05YqJhyTB/fo\nT0A05kvh0BbMuXfx2eXRnr3LK3PFp5ZEZB0/7NdyerHW4njJWTTSeiGOmcOOZqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtS0MlyxTb0sNJoLeTdAK9pkHY8IwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgRpDbe+I+\nPQxRdUoL6wNLypQ36NoiPqczUd2ZjiWbUpgCIC+Bu/S9lFo9kwPS86Q/d97h3YNS\njK/eMPcRq78sG6oy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7005", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7005` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZAX70ojsxrhwFGWCDlye9O7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2YTk1NjNiLTZmZDgtNGRkNy04NmY2LWE5YjQ3OGNhNTA0ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTEyNjA0NmMtY2Zj\nMy00MjE5LTkzNzYtMWI3OTMxMWUzNDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEws+4HfJwub9DL96zuCQkIQsySUdtdg6QhUCh1gpaXWVYtZhoyUd+waAAWCIv\nytsI+r1R22fl9CEVv7/0f88+oqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNrRBZ/QgzWhUAvK4PwAiObAfokwwHwYDVR0j\nBBgwFoAUs+Eww0YGgr4D6tLhsxtSkkXXG2AwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiBxghkt97K9U0X65OvFx3rmcvH7hfuqk/aOppXKiQT+agIgQE+Kon9EkxD5\nWUY16BWUX/u16jynBP0mByCgTdXH9wE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdcjsO4CzbLGP0ns4U4UiZKEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmE5NTYzYi02ZmQ4LTRkZDctODZmNi1hOWI0NzhjYTUwNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASA90yM5v8OVZAJ4EExB1VW0u/d19YZe2WS3miGzdTCup9/\n6J7AtTLYoi11p7EcfQfFwAga3ZuYFA95i9CSRCQJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs+Eww0YGgr4D6tLhsxtSkkXX\nG2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI1huL6xu6pMxFrAdnBtQMPodgqcTnS48B0DdceouY3+AiEAgnPtEbGD\naGiwJM8NJ00vG4oBqVfLpXCtpUMBifyLqNo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAZzrtLhRK7eeZn5UL4BPfM4LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTEyNjA0NmMtY2ZjMy00MjE5LTkzNzYtMWI3OTMxMWUzNDFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTNiODYyYzQtNTNlYS00MmFkLWE2ODYtNTBhMjg1MDFm\nYWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdobGn/kgpBIgjnVFFW9Tc90O\nkw+nYFlOFcgQUu+mP1vda0PAXb9h7KE6zpece+izCKXvg3bVemnR6XsGB1WlV6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNrRBZ/QgzWhUAvK4PwAiObAfokwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgLALDUwo5\ntp07Jr+dtNTgwLobZb3iGAeLtLpMjm4997ICIE6k32IYUBG/BhcmJnr0199mAieG\n8nebH3HLYPP64Bk0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7006", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7006` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAX9yX31MO340Gm9aZ1BMNtqOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkOTJjYjVkLWNiZjQtNDgyMS05NGE0LTYyZDFjMWVlN2U0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRhZjIzYTMtNzIz\nYi00MzZkLThjOWMtNTIzNWY2MGNjOTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Nn9kQSvnHkhGib7nh5cYtqrNDkcyM3X+JkyA7bdqkn00TgbVLMf5uUGrFsA\nEa82WP4WSmQGSjOPZvkCvd508aOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1xiziyxf1EUWC+IPYKxHT6Kt6oowHwYDVR0j\nBBgwFoAU5eWsSB6hshprep/Djrch3gjhY3AwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n5JW4COEHLOix8s73bTUH98f4jngPiBUiaRwIXV09PM0CIDmh2MHicBb+w52Z0dEU\n6zeZvX+eUPjT9mcGFRFY/dr1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT35ZhezD/eRDKoRV+9PERh7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDkyY2I1ZC1jYmY0LTQ4MjEtOTRhNC02MmQxYzFlZTdlNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGzn8o1y8wQgNUEcH0CXKU0LpMOAMdTCxWEA7ef0cnK6kg\nuz/rNl3cJ5GO062FIyxulBvRskvX/FMgvhSoUadNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5eWsSB6hshprep/Djrch3gjh\nY3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPr5/9Y2mUugUlUk9sidkUA0VvXngCLnD5NetnW6eEYgAiBB14Bv30Vn\nwX/DFGcPtZXYNTwAaoKosLYNMYGtAoaAjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZ2sVnqRUWVL8hokkUVsoVwVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRhZjIzYTMtNzIzYi00MzZkLThjOWMtNTIzNWY2MGNjOTFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTE3NjIxYjgtZmYyYy00YjZmLTkyZjEtZjhkYmE2ZThj\nNTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+86Epu/Yuf93fv2aZuHxAtvN\nWp7lAfX4CxZeIWPSMtcby/14hj990NP/UcCEJWNIB5pXV9x0SE8xAunc39ZEPKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1xiziyxf1EUWC+IPYKxHT6Kt6oowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAM6dMOea\n9CynupT2Q7cCS5xaFI4EC6cwv5Lcjz4krogCAiEAqG7ECl/r5whqPVBjBKgwdCHx\n13P9iv6v0a0OjNdsqyE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7007", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7007` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAcpZSWGR9UJo7VzTebgqMYNyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ZWVjZTUyLWVmZjMtNGI3OC1hM2Q4LWFmOTU5NDE1NzE3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNhYjU2ZDEtNjk2\nNS00NDFlLThmMTgtMjhlMzk5MDRiMjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZiXBeHZ0FADhMF1loPDJ7u46dL2xXdjACi4kAbSNPveh9PeoWJDTLi2mHS0G\n9X4OZnj5AFi0CiQ/4E5jvFwVeqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAp2T/8aHg7c+stxTP5Mpo57LEbcwHwYDVR0j\nBBgwFoAUL8J3a7XZ3+b50fu/u8dQmvN4G2QwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA+4NvOOUo3DggfCiYAAB2ezCLBu9QCQiowzkBquRMnXsCIEHT\nUlPRdAPxNpGbSvaAXOSq+dLN1rruCsWCoeLRJGVL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdCbWgkIj5xMKzCiWCHyjsEgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2VlY2U1Mi1lZmYzLTRiNzgtYTNkOC1hZjk1OTQxNTcxNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0aoNQoBBTFl6G2D/EAVxz2kLZeZtc4ROduYXdpfOW96rA\nCBK1F/fDfcmyWARZCKT98npKw4708ZRZnczSEyvPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL8J3a7XZ3+b50fu/u8dQmvN4\nG2QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHKbs+CvAokh+U30C+7JzVCf/nhu+meSOLkkUIo/ksjQCIQDqn4AClK77\nsbH36q2XwPnikp0/Q3VAoJbqq4s7o25tcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAeIUAi7gWlrSGi2WyiheRhlbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNhYjU2ZDEtNjk2NS00NDFlLThmMTgtMjhlMzk5MDRiMjYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTZhMjJkZTctM2YxNS00MDc1LWI3OWQtOWE2YjRkOTkx\nOTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZ+adnlxjIhlv7zRMVtmJPVGR\nZ9XlaMQwqbOvFkRTI8i4kONws0dzB7Nmv1TPQpN6SkyjDZHeqtJgYVnID56uAqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAp2T/8aHg7c+stxTP5Mpo57LEbcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgRU4pQhzR\nj5pSdulEIFsdmB/0KJ0xG8hWd6W+Fy3J/KoCIQC28vWjyqfm4D092/dwtvQAx3HD\n4vVxkfAgm/xQ6ya7Pw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7008", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7008` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZNDhYN6vN6mATBem8xym66CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiNjkxMWFiLWE5YjMtNGU4My1iMjFjLTIwM2RiZDgyMDEyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTViOTA5YTItYzgz\nNi00MDQ4LTg5ZWMtN2EzNWMxOTQ0MWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjOUWv7WLw5/NFdJQO1I1c2ljyOjH8G8nb/l/5yFteonbG5xeryUmxR8mxY5m\nkQ/smdA2LNUB/6Gxu7PM3KOmTqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUk6FioWo+OyjNvo3C25m5YXouTAwHwYDVR0j\nBBgwFoAUQdV5friIn+EqQgpMsP80Cmr9NOYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiA7GcMGIHbCY99Ntc7YYoyWF0cqGQHE+/pZ8RMIv/klTAIhAPHW\nAz7V1TqqOoChEwtLtk0qigap8+/CabfJBwsZ0wpT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS7B2JOSaBvrQrDdyLH8zwK5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjY5MTFhYi1hOWIzLTRlODMtYjIxYy0yMDNkYmQ4MjAxMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0SOKl+LY3KuT6ZzUFYg1d7bxsfwylm9jgMTotObdDeXpc\n9aNlt9aV6t/CGIYl4zdOxVHy7zJijya69Jvj6bIvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQdV5friIn+EqQgpMsP80Cmr9\nNOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI8bHytXqwxJyaQHnKyAZkvqcTpiL83alsvYRozzg7nkAiASzIJ1S/ZA\nQSIC/VkDwW46LSfRjmKQuSEjoFlTAeAO6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISARuy0XYMFL+OLZjjSyHlMEpOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTViOTA5YTItYzgzNi00MDQ4LTg5ZWMtN2EzNWMxOTQ0MWFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjY3NjRiYjAtZTUyZS00ZGEzLTk4MGItMTY5MTcyNWU0\nNzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvL1VVafbvJ1/PUSNzvI/3fu0\nHTIKvWfewpgaE8k2AkYAa/Wbiw58qTj3aLiqs2mku9ViYb7f1KmRIOw2xYKOgaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUk6FioWo+OyjNvo3C25m5YXouTAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgW/6cga/u\nSnkEVUnnwleuRbDs855q21TLMbCbnrJuD5ACIQCJGpUdOUmRt0i9FI6tgUizlPFQ\n9AAs/Oea1mFwrX3PHw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7009", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7009` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbvaHC2NnDoI7XLUg/qk/XBtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjMDQ0MmY4LThlYWYtNGRiYy1hNWZjLTBlNmMyNmU4ZDY3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg4ZjNhNTctZjZi\nZi00NjRiLWFmNjYtZjM3ZTUyZGU2MzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh3QhmUE4k7vtKfBeiAn9P4hlZGtan+YLZMWO4Xq5NsU/Ayp8/sTKap0biGfu\ng+xT/69C2RJP8J/HjQju1H4QQKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSGOIljFErK8Ljbdhq4dul/n9oDcwHwYDVR0j\nBBgwFoAUjAaJopkFmp1gpnVMcB10QKnoXREwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAu9ene6Be3P3I\nLmfmmDlloFwRd/HEL8hZ4SSxwxyqWd4CIDDAwoVkmHuuBu2qjVKwPiRwvgsKPmpd\nO/svtQjBnlJP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAePci7J9dUdHcc3BIY42VhoPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzA0NDJmOC04ZWFmLTRkYmMtYTVmYy0wZTZjMjZlOGQ2NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQe6G+3OuDrJygUggA7lnQ7P75yelACUEL4TF1UkT/WL2k4\nqVHPXdnVM1tLqNpT3wMnH/xG6gn0juMjzgpiJCQso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjAaJopkFmp1gpnVMcB10QKno\nXREwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIIFTEMz7rF0wqbwOSYRk6IQhcYLqFkWnsmES35uhzIyAiEA5Ri7G3V5\n/Cm72w0lcu35KaYmuKGs9rdn8eOQiw4v49I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAWIe2ZfJ+Twg0W0VRD7Hutp4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg4ZjNhNTctZjZiZi00NjRiLWFmNjYtZjM3ZTUyZGU2MzZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTNmODE3MWItMGU2ZC00MzQ5LWIwOTUtNGU1YjIyYTdm\nYTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzWR/9xYAL6SJSNPOkPsbI7I2\nh9RAuSSlpeAFmdHdc6psHsVli2O97ZB5BML70QUMsSqnWjBx6fb33LkwwiR+yKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSGOIljFErK8Ljbdhq4dul/n9oDcwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAMJjJxkP\nhYBdDbi5DMLCxuPMafdByYtCZBmVRu7x9fGPAiEAxD3gQE4DyQ2SwHgNe8MlYO9g\nKq+yyD7IogeNwK14xeQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7010", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7010` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAauWBxWzeZ+VCeDJqY3K7vWdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2NDc3MTVkLTg0OTgtNDFkMi04ODQ1LWVmZDJjZjE3YWFmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNmNDY3ZjctYzdl\nOS00YTI0LWIxODktMzBiNWU5ZmM4MTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu1tI6Icb7Qv2W8Yy71yfNJBuMbI0ji3qiMtFaKEQlfIolCpU/TsFptf0HwO8\n8AP/56o7EoRUwoxUkLK8DiqleKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUltsi5Mexhi8OwD1IMkx8Tspw4FQwHwYDVR0j\nBBgwFoAUkVXBLL38sW9ZFLH16AsIGRpr+oAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGHXOXRfswLNdhIAaRFn17An1J47DH8eymGNaoBto8bJAiAQtIwHY2D1Re5W\nXGG/3znfs+xvqgw23KNIv7hOkN+yOg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVwMlec33TRBwxH9IYAMfLXhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjQ3NzE1ZC04NDk4LTQxZDItODg0NS1lZmQyY2YxN2FhZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHwO6hLL3sxCMgumaDfDk0RG6aNkBRRk21qcTg2QKdoGA4\nJ93JeND+t82xQ12IaT7fztxj/adv520yL7K9JmD2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkVXBLL38sW9ZFLH16AsIGRpr\n+oAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMsVFYzStl/M+vJsez0G4KH2ekDLD+PmR6WsTmlETaecAiEAvtKgceoR\n/IKN+74BtGwn/yRq2ohL0mVpuTisYqNcz3U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAaInn58l5jWpbcQJr0iyiq8FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNmNDY3ZjctYzdlOS00YTI0LWIxODktMzBiNWU5ZmM4MTUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjA5ODZiNTQtNzM1Mi00NGU4LWJmMTQtNWNhZTY4NThk\nMDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHB6RZ0W9UNJQ5cVIpcPevMeS\nEIBvmafX2Lz2uMuXBw+b+f+ys9VvVSRaorywyR98ZdeTokF9Bo8/PzFAASEbZqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUltsi5Mexhi8OwD1IMkx8Tspw4FQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgA58XHbbZ\nOoEnFCCEupPWza8YFEursc6C3O/94uAbTt0CIQCyE2F4JMsT1d0u+rPmqDD7ibLy\neszwcuLek8S8E876LQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7011", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7011` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUwoM7+9CVx+8B/VL5oP0y6oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5OGQ4NzE4LTg5NjQtNDI5OS1hYzUyLWQ1YTRmMGU3ZWQ3NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg5ZGVlZGItNDhj\nNi00ZjA0LTliMTUtZmQyYTc0Yjg0NjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUfa9DqXdJMjaZikmZHVYrgFj9IS3tOEtOkH2jW0GZsQGy8qOQfK4KaY12Djy\nAK2iC3oQYQEgNf4WEy6hDaKRpaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY7S2eT3KWv8bPkT+16IH7szajeIwHwYDVR0j\nBBgwFoAUb/vSv/4M6ZauZkxcP0yFZo2zfKIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCuVinIcsZFaJQpjEBu3tt5H+GtJZ4nN4QfTU7LUOw26AIgWy16iVlN2r2p\nXQvp7Ft1iZ1Czs4mIl6dg7Fe/m3la5k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS1a3qH+1bNomAfRxyeJ0+z+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOThkODcxOC04OTY0LTQyOTktYWM1Mi1kNWE0ZjBlN2VkNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8cHxzDwViOYjYsWqI0KNq8XdtgIv4CL1m+zKdKaY20GbN\nViT+03syhZyxMsCENd+GaHyWTtfvO1ZxJ/qtBfVlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb/vSv/4M6ZauZkxcP0yFZo2z\nfKIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcZ4bzkZc50V3EBWQk6ZEPNIK6tZKmVYG7xWDGuLkBCYCICRPeo46XFOw\nFo2suIFKEAuKHIQJ16K9lwn63OOlRKEp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdaoNcVaAJwsD5ILhQFXZBAPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg5ZGVlZGItNDhjNi00ZjA0LTliMTUtZmQyYTc0Yjg0NjlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTFiZjdkN2EtZTRhMS00YTVhLTg1ZmUtNGNhYjNkODc4\nOTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMM9matqD5DYR+WnzZN37RuZh\ncYwl6BudlxNlZH+gsz15WiXjQX7VIppXxlrKhBienHVhufHGDNxKskP1eS8YkKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY7S2eT3KWv8bPkT+16IH7szajeIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAIqmTDAJ\ntDr8IIAHCZ+XWg6qz0t3hahaTyCuDzuw+mMlAiBWXfoGv7HmG3Hj12UORESPmk4i\nAluI3PDJPsHaNAyPWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7012", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7012` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAQyYLpquFZm2RP7V1ykQOzYAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3MTgwNGZlLTRmZDItNDBiNy05ZmYyLTIxNmU3NTI5N2ZmODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA0ZTkyMzEtYmM5\nYS00Njc0LWFiMmMtZDVkMGE4ODAwODgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJVoMy26viV5rbv7X65AKkKMaYMxvDlP+Z6KXoNhY83xhsP1eP0c+MUDhQhLu\nOLXsfvisQ4+CTu9v8nFA+mj/tKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpollFGZhdSgZvkly5ArLw3MXrcEwHwYDVR0j\nBBgwFoAU2asknD1w7MaACuPdMGtogxkQCh4wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBBrC0qryHSMPxZl4wjvFrhmERgv0PHulp0YzNlUGjTiwIgAXEG6E1BRZ3Z\nWo/hqFMKT+3UD81krbZqOCkJH67T/lE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAayDNjl2Y6syQTO6IPIT4Pf/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzE4MDRmZS00ZmQyLTQwYjctOWZmMi0yMTZlNzUyOTdmZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATT6DddFeJpGJzHd6NEWhrcaFc9fKcruGOU+wNRH4xgOxZA\nqN+2Qa07oq5Ct8MeoGkY28IcAJJB+00M0IEYAluDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2asknD1w7MaACuPdMGtogxkQ\nCh4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKLvOTgA4TSwU/yzgHFqy/YW7H9Z8iYE1GmIV1HQ6UOsCIQD1RCQfHRz4\nVckTkP0DmbN2bIP5AQqs3l/sM/lZewdhsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAUhn6AByWe3Tw5ePRcEd3ppeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA0ZTkyMzEtYmM5YS00Njc0LWFiMmMtZDVkMGE4ODAwODgwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTU0YWVhYjgtZGI3OC00MDg2LWJiMWQtMzU0OGY1ODVh\nOWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyCgvq3jmIuPuzBOSvMMsYaKl\n3mkIdK2orYOE7vZd/BBBhJIzc1NnNeWlLsKN6wpkHOrl6Kh0PBcZ7ng9+oZsIKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpollFGZhdSgZvkly5ArLw3MXrcEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhALoUXDjE\n2lmkDSrEc5Zz5XhOlO0PeREFA1n7L6ertfbdAiAmqNyOTl73S2cfU6YhpaHC7Mqj\nU/ArJuyqRch/dBEx2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7013", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7013` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcL+AmNsIW5nv/h2CJVKQma6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMDhhZThlLTc5OGMtNDcyYS1hMjkxLThkZGYzMWI5ZTZmZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzEyYmU3NzYtZGQw\nYS00OTVlLTgwZDEtNGZkMDI3NGI5YWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiCn3epAGKqb0Ip5bxCPxKyfGHipqAzSr6n2LVTibBl4loCITrSAkkP24PGQj\nFaSRafZ3MdHv0DHUGT4L7TCkhqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2J5RzN48vRkd2GBg+cjAxBhcn94wHwYDVR0j\nBBgwFoAUPR8/t6rY69/QQ+huv4m2+uBBJL8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiB/xAOMBx8JIPa8Wt/XcNyDsQiwVVdkKf9r+XDhSsgW\n4QIhAIeeJbWWwSZwmt+MK7BXpmx9c9bpqDzpdqn/oYR6i6sN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUZKGi5n2CMFweSF0fNZ7imuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDA4YWU4ZS03OThjLTQ3MmEtYTI5MS04ZGRmMzFiOWU2ZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3+9vX5kmppngnEp/8TZM638bOArhRbQIuA2BPP7c598nv\nT7ANxwudeNeKedt2evtJyGkyGmFJ9SSeZrcz+jZ2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPR8/t6rY69/QQ+huv4m2+uBB\nJL8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPD9fcHBL9KaUAV2/qXmvH80Es9hVSVdAIQDn49EJmLKAiEAxfapsbAX\nhoa8IQwvSRxPcaIjTbyWSTybzgWwSoBbiKg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAathe4X/byUZjc9FT88n4mfYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzEyYmU3NzYtZGQwYS00OTVlLTgwZDEtNGZkMDI3NGI5YWE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzAxZGZjYjQtODEwZC00NjM1LTg3ODAtNDc1NDg2ZTVj\nNTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyyW3915W94kOHDddGYN8IKr3\nvdNNORBUzgtbC4OV9lpQBedv/FvIXgidgibPVjVXMs9yLOl5UOte+CX5M/QOUKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2J5RzN48vRkd2GBg+cjAxBhcn94wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKcYRkJy\nnM57QEjo03KgdOjynd487ncPLL/Wj/tWfsqiAiEA4a3W5iJTkDZ6N+jIfNQpBRaC\nGDdXUSXU1o4s6Wu55rM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7014", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7014` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISATYt3j0yzznsxrOJNGiL7lDDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViNjk1Zjk0LWQ3MzgtNGMyZi1hNDk2LTg3NDhlN2NiZGQ4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFkYWEyMDAtMDIw\nZi00ZjQ5LTkwMGYtZjA2NmJiMmJjNWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaXJ8+E1UzAZXxwQ1c+7X1nAxqS7Ohg4OC7NcfJk31OnPkodF2KPLejXZ8J+w\nmQ7cAfLvgziitm/Bbg21K0wOv6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUHZXPkSt2d9bt81AYmZSdRf8tEkwHwYDVR0j\nBBgwFoAUgDf+WZvjJMgJx6oflBGGO04YW8YwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAoGDExYz6s762dPWaBD8Up2JNJ1fdUFenYtXM10UB\nS84CIQDi1Dky/GYu/6ESytViVYuasKfP2qdZkggc00p+sE4kfg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQzUTbzy2qpB1jtFueJxHTg+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjY5NWY5NC1kNzM4LTRjMmYtYTQ5Ni04NzQ4ZTdjYmRkODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIGKW32ZNTgAD18oybDl5ZwZF9dNqGMMKfZVJQwvrJiLNt\nE4QovcJjcf9pSLSjD5b3zDgjru+dYOYvWqmuEVb1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgDf+WZvjJMgJx6oflBGGO04Y\nW8YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIE10FxFv8ptP6VMbBJXkBiaE4n7TYbJ3GV3Av1GAVbHAiEApCxtUhGr\nnplRD5F1CsH7f8VdCF9ZJ/9CynmDBEoKVm4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISATtX1JOKzWDv95PbFcam7GEeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFkYWEyMDAtMDIwZi00ZjQ5LTkwMGYtZjA2NmJiMmJjNWIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjRkNGRhMmUtODgxYy00OWIyLWI1NDYtZThhOTlhNDc0\nMjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErJXp214+VXV8PiHXzuMfa+Rp\nkx46uEuCaMBZmuonCD9jNYL6m6aKKewbSNcDfnxMsxiM3SZMRaD+8q+9hJVjBqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUHZXPkSt2d9bt81AYmZSdRf8tEkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgKacYgNOj\nz4onIQLnwbaatpROARm+IVKEM3j6/REofaECIQCeUu9yqnew7adr1500BfkRXqOa\nxvCbnvlnQNeLMC2pQw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7015", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7015` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAXlD1kLKK0miCqDuvXe1uiOCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxOWM3MTZhLTk4NzQtNGRhMi1iMjA2LTc5ZDUwODI1ZDg0NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmI3MWRiMDAtMTlm\nMi00NzYyLWFkMmQtNWUwNjIxMWM1Yjg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2fo6FFAWb3jwn1ICSBlefS7CXxw0yeUsPyBlAvsHO4zK9kmQTIah8y3IZBEE\nEheGtg4NKAt2SbFIgtuyrC8j36OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsp/VJzO34rfemsrIUf6yDynxMQEwHwYDVR0j\nBBgwFoAUOPhcOJtW1AwIBok482U9ZEXoDvQwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBlpBBnziLprQpJ1NwzuNS0+ICRvVM5npbcxU4CWMGe3AIgTzdc\n9bAJ0HCwS4e1cVT4izQwkDPYku6QKRVCMdQ3+hg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYxrQRPBx3q/0lagoyXyjxQfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTljNzE2YS05ODc0LTRkYTItYjIwNi03OWQ1MDgyNWQ4NDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvr6foN679CPtuIZ9TpzQKqdaHa38iLb2L2LyIb0DQBbRb\nCj4Ky1MY1X5Ycv0be6F4bLwMkrQlVjF1/SYe3CLco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOPhcOJtW1AwIBok482U9ZEXo\nDvQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOjLt5Lyk9WJ4TjkZCPbiwBe/NiIHt+28qh1EfnmJdVQAiBpzQPKNXdn\nY9NMoP//sXKnFDvMQUTpz6d138beYjLrJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYmswHYEZ55+8OLrxA73cc3vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmI3MWRiMDAtMTlmMi00NzYyLWFkMmQtNWUwNjIxMWM1Yjg3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjdiNzNiMzktZmZlYy00ODY4LThiNjItZWRmOWU1NDNh\nMTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZIx3kT3eSUGXSVAs4U2Y7LIN\nsSCYKQ/8CCh1njq0kljc32lx9KHWxL+DDxN9LSuXadrWMt8J8+J/Uh8HBsdFUaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsp/VJzO34rfemsrIUf6yDynxMQEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAOKzDJsq\n2+16ZCBsQCsK22N1GeGzR5oGvtnOB94yxcCHAiBkB+FdtNW+HS8japrlMYvOkASe\ncudnqFQAqnLGxFJbxg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7016", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7016` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAXiQqvadpxuRYvrJ5zWmrWVZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3ZGE1ZDJjLTI4YjctNGI1Ny04Y2IwLWZjMzczYzE2MDc1MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdhY2JiYjctY2Mx\nMy00MGUyLWE3NGYtZTM0MTQ0OTgxODY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9TkKgYGo/8XaDaWkU17R08Q5E7sZqorwUlTrGgdGCKJjgSdq45paHQLTmtd9\nFO3IGOPcZNUIzTIxljle7Z9BI6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpqLe7eExQpPwLTt1XZAsSYoswiQwHwYDVR0j\nBBgwFoAUz1miXxRc+a4AHxcdSOqOyz5ez/0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBpVgJjiCCdFRGpjT8tnAeRIrbxe9WoQ2ou\nbbxAUbkDXwIgOEM2aeYmuBA8+XRhY74TeJ4/Bk+jqId/UfCbzv0JPio=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfbESVtjWKOrjGu1dOyFwbeWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2RhNWQyYy0yOGI3LTRiNTctOGNiMC1mYzM3M2MxNjA3NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFqV2SCflLDCor16guxuHFays6rFtIB1SNi7U1kq+om5Jk\nkX9mniNtljCgIwzDsudMVPzcBnPL2TFjp3Kq5Ngyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz1miXxRc+a4AHxcdSOqOyz5e\nz/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALmReNBPOp1NRWEMI0dtaDAWt66PVUwavvdRKRrN5HgiAiA27S4DDmn7\nEbkgcmx9NLVWcOYYQrbG9yvU51m/t2MAAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAYckkdAz7PrKT+O3o3M6IvEOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdhY2JiYjctY2MxMy00MGUyLWE3NGYtZTM0MTQ0OTgxODY1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjY1YTNlZTQtNjhjOC00MGQ4LWFlZGItMjM3ZWFlYmNj\nNTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhLBfrK+tF1qDU1dhA16poSS8\niM9ziNLEnOiFkMqxxCpbW76RxbZDOdr+aEMQI+G0Keak5lOoWv4MrDaDZ/ffAKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpqLe7eExQpPwLTt1XZAsSYoswiQwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAOgYcTGb\nXsbztyrHpwbyIkz9uVoY+bywt77bH4yg4nJBAiEA9wGS22/wLVpjQIhbT645h0ws\noMEF5jHwEl+yFL6LbKs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7017", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7017` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAdNNobgDhqE9fnd5uyKmTu4pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMjEzMmYzLTJiMzctNGQ2Yi04ODdhLWUxYmE0ODk3NGE5ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJmYzA1MzktODcw\nMi00Y2Q1LWFiOWYtNDc3ZjhkNmM3MmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEByiynfN4MIM0OZDCG1JhBi+4H/Yw1KlnFNa+lm8rG5juozxUM72V3xfWGhu1\niOiWnEzMsuIbNd2bkHyuZ26uiqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYahmjMsj+m6C30kRCRBuDTJv1w0wHwYDVR0j\nBBgwFoAUgo1E0xip2M+BqEgjNjlBO5M75OEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAtetZw8ZX25xWrynl1pt+VZ8ehtA5qQ2mM\no/X98Ssu/AIgUwvWAwHxqbAAFO/dRhVwidsowpNIbRdCOt2CbF9BcCE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATVbvz4I387QtpXfJBIDJp+kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzIxMzJmMy0yYjM3LTRkNmItODg3YS1lMWJhNDg5NzRhOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGhMMsc9Ww/z8JbXwhMTJZ5DOMXuSklioKdwLZXsnl5HLQ\nV8lCA0F1l7/rBCckKmC06JCEiDohel7uJxkIs6/lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgo1E0xip2M+BqEgjNjlBO5M7\n5OEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAISbf1F3E/HPU4uLEE4oUmLB5CL4LZVkrvbOOxMIOy9wAiEA9LiIBz8j\neHEAb7YTNuU71c/ERRJqIRSfq+2dtTihPQI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAY1sm5LW03n165jka+37BA5lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJmYzA1MzktODcwMi00Y2Q1LWFiOWYtNDc3ZjhkNmM3MmJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJlOGZmNjItZWY5Yi00NzY2LWE1YmYtYWI3YjU4Mzdi\nZTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpJ9jTejNKHB3LhbjR+xcyne6\n2+G24yTovZOGu0+DbZPswf+y9r8e6ENRyYmYcfrKKcj8Wb9sMurEI1h8s3QLjaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYahmjMsj+m6C30kRCRBuDTJv1w0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPxtmV5H\nEQt8MGNg4cEAqQUEieNAIMxHYr8qTDmtv6fDAiBLl/cc+pz3+5VQKSeRz+EFGcIN\nFnKUtDOCaEZ9343bSA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7018", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7018` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAWLG4rASDM4PcZjK7xDckWdCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2OGM2MjZiLWQ4N2MtNGI0Zi05MjJlLWM0YWNkOTMzYTcyODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE5YzZkNGUtNTFj\nOS00NzRhLWI5MTQtMThlNTA0N2Q1ZmFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWUQzeWtyMzyfJAtvB+IZq7sTxzoWrDgKQVbZmZAuwkrJ7aKun+yMMdv6mvkn\nlyrg1E46krNstPVgsFxT9wwWqaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4BgeaS0+eFg4EJYbvlLCJJIgwXAwHwYDVR0j\nBBgwFoAUYSn+TfDFFaSCxHrG/C6p8vC9d3AwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBIb81DosbwXfsK\nPD6DG/KW7Ik0XTrB89F1iydgH/V9ZAIgLuJ1Q02u8X7gmXyDBiOKEzNHkQXrKj6f\nqNYUwcgud7E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASUIVPQopNPHaTG7PAiXkJ5/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjhjNjI2Yi1kODdjLTRiNGYtOTIyZS1jNGFjZDkzM2E3MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSBIWDeB1gleZspnTnaDyOonLDFHZxep2ItHrkeUDm6oEu\nkAZfRifFPJnU6JcwirYYmZ/5I01kkmD7SNXi0Xdoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYSn+TfDFFaSCxHrG/C6p8vC9\nd3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAiYSHXpZ4fmi+Q2o6lChyUXrmrHnZtUjcfBeG+e0ISwCIQDJygWNWzSZ\nMNl01opR3rBog+e0chxALuIuPaytoaP1PA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASVhfQoOKgFgOpP2vvuSI26FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE5YzZkNGUtNTFjOS00NzRhLWI5MTQtMThlNTA0N2Q1ZmFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODc0MjViNDItYjVlYi00ZjU4LTk3ZDQtMDViNGQ2OTFk\nY2ZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZ7wcA9LZiAE8P00lMoj8X2Kz\nHI8ABuW3WMRNZm8MEO8bEJtG/Ql1FahRb+Z+H2pQ0rybXne6VAGl3rkdppV7YqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4BgeaS0+eFg4EJYbvlLCJJIgwXAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgGovNlUjg\nymYvn1gyeVz50ZV74U2inDUeEJJ3FJV4ploCICmSffYJjub4ZTaSHwkGBPCMEqD6\nClLAzI4LWesNlhTF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7019", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7019` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeVHj8CNA34VGIUDuewHSVATMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2Zjk1ZDVjLWI1YTItNDcyZi04NjA5LWM2NjYxZDcyMmRmZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI5YjZiMmItZmEx\nMy00NjRlLWJkNzgtMzc5YzJmZGM3MzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsnOP0NvKWlL0hRGP1ahuB93pZwjo3DBnSA8t2rtwZL3Eg8ZBtMHFR1sYaPKn\npBWg5Sdyo+zp3GF4EE4cKEAXxKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJs9z0DXbDQyrqraceGqNo1cNLhkwHwYDVR0j\nBBgwFoAUVx9bhmzBW1Ni9jF6VJyEKZvvKvowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAc43iQZlVBTm1sSmEqExxTnNhTbGhNuThFUKXRse0CcAiEAz0YnOV3G6Xz6\nsUtVqfy9AtjXzz/SSYtKKuAg6hafg1g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATZAsNsPpWQMT5YSewzt461aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNmY5NWQ1Yy1iNWEyLTQ3MmYtODYwOS1jNjY2MWQ3MjJkZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfoZoYae2RF+eCz+L5aBgrbYRmlry/pH/LlIX+kM9uA0AH\nGAUqHr9krGUwLpJllrHUuYlXbt6r8ohh8kH7qtv0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVx9bhmzBW1Ni9jF6VJyEKZvv\nKvowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMFbhQN1bKHSF2kXDue1AwrWQQDXXb0q9y6dfe0tzQSsAiEA3O1wdN73\nJRRb5s4uzCOaVj+T9oaRcxcrPDdfSNLrJZM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAT/DwEYBMr6wRny3qVnPX2VGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI5YjZiMmItZmExMy00NjRlLWJkNzgtMzc5YzJmZGM3MzkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmY2MjY1N2EtYjc4Zi00NmQ0LTk0YzQtZmE2MDZlZjk2\nYzk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZJNqcR9VYhaew+a+ZpPl9fou\nRMq/Pv66+tx0s0OFSkAaPa8ThArGa6dZrARaB9ydHdXvkBArYVKQn+I3BnZUA6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJs9z0DXbDQyrqraceGqNo1cNLhkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPU4uAq5\nYF9UaiJqQE02wVOv4rLMnB89Knvfg5NVmHo8AiEAgCTEARdQTSOyvIX8vgSPdagk\nI6naL6l6REChfDkqLqc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7020", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7020` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcUYGr+5X5+sDmLZr/CTwyZoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5NTI0NjAzLTAzMjYtNDQ0Ny1hYjIzLTk1NWJkZTdlY2UwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgxZTZlMTgtZDVj\nMC00OGJmLTgyZDEtODZhZjJlMjMxNTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDST1cHljGbn9OjKK/5dh02jPJa9iGaZXtFtKA1aoEGzPU/vo/kBK3rEoJQWr\nvQfln9qnKkeotzej6cgn4KLbuKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/jXBN8BFdvx+IZ+bFnB4P+R3IewwHwYDVR0j\nBBgwFoAUvp3AhT4XFn8/NSm7nKlYeRfEiuIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIErhB1gDeKaFCwzJjKbjHWmcb1WXS1odAx+zATD9+sykAiEAhMIbDZH62G7u\ntDPu/BZxFamFX9U+NUToyPr6FE23M4I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAakG9bbtqhUpY7oXXswqo8srMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTUyNDYwMy0wMzI2LTQ0NDctYWIyMy05NTViZGU3ZWNlMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARovJTYKn63cxEiHq8JubieRvObEBYeFEfEiy1pQITcIUg/\n+0EGPjGB/FECZg2H9llmBvXcgEQWH6XuKtmILbTto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvp3AhT4XFn8/NSm7nKlYeRfE\niuIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJAVjZvlAbn3gMG/TO8nNkgH63kYedGAi33PRhHpDII+AiB/Dn2ObPSw\n6c5e4d9bldRu/hOXgaz2kwXML/ze1rToJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVvN5DnPktb1INjUgK0RpCy2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgxZTZlMTgtZDVjMC00OGJmLTgyZDEtODZhZjJlMjMxNTMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2RlODRkMjEtZGJjMC00NWNkLThjZTctYmQwYzZjMzMy\nNmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7crs2hluhoWFXt6HO5ediJ2D\n0ZTyKgkVuffDfJIp/E7Ln+pzXAGvQ4dbb/83Wrekpk9lTsicGOokWTPu/hMRnaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/jXBN8BFdvx+IZ+bFnB4P+R3IewwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgMEzL7LLn\nmwLTL2TJDWRtF27v5bVnqFu+Xhq6rv1MKmcCIQCZulMefa6esjj453lBpRFSRBzG\nqXQSiRs3EA4eStrG4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7021", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7021` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAS+CvTwwDAfigNVu218AO9twMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MWRmODA5LWQzOTgtNDYxZS1iMWE1LTNiMjU3ZTdkZDZiMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUzNjY3NjktMDAx\nNi00ZWViLTlkMzItNjkxNzk5YmQwMGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdwXapuQh0yKQ/trlMwlF6QxLRQ/e12Gflog+kvhcD9lBrhJ6NY8jpmN32RJE\n7C9MVInZ5jnLTrB/71OtIrtw26OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN7NdC/PamA/9hnuunchAMXQ4rJMwHwYDVR0j\nBBgwFoAUpggPZo/TUK6rxj5/0UccJlzyDW4wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAnnnjLBTJbw5sAEbXojoxc1D0yAeiIRwcgd1ddHr3XXYCIEeq+MnNaFQf\nHuBnuvODJBuxEZ7eTHRPaHR+TLlQjQoJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUKzglUjGgHpVGomkhxxYNXVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDFkZjgwOS1kMzk4LTQ2MWUtYjFhNS0zYjI1N2U3ZGQ2YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATajX4miUy5iQBwi90zCtWujC29DP+fNjOObzsDLPt1WPPf\nRWhnD5RcJWAu3A99a4lBWZeqVaB53S8uGHZ81Bvjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpggPZo/TUK6rxj5/0UccJlzy\nDW4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOUHnv6/IC/gAIPwlrqBlKInbky4aCiLEWFymMDGh1ftAiEAupT7wH6t\nY01xEK2XRH7cz0PfgzsWioOWaDzU+Gr1IsU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAe/R012HQ8OhM9NsHzbSNW+TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUzNjY3NjktMDAxNi00ZWViLTlkMzItNjkxNzk5YmQwMGZjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODI1ZTVlMDctYzQxYi00YzU5LWE5MjQtZmUyY2VmY2Zj\nMDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsbcBlnEjATFs8ICAlK7HLwzh\ntoX0858ypAhSHMTWGq9tE1jzaMRqLsesPObRi0KYoYNxmEbxOsW2RevY6wpbLqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUN7NdC/PamA/9hnuunchAMXQ4rJMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgOu/BYA2W\nZIKNs+/73L5O20UFqjYXJFN320eE5Cl+RTkCIQDfEq4e1l019XO4lPNjEJQn9oj7\nQgToDj2YamvN7deVKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7022", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7022` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAbH6/eVapGgmuJybDssYcyVyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMjI4NDBiLTcxN2ItNGUzMC04ZWZjLTBlNjM1ZWI1NWUxMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgwN2FhM2YtYmNm\nNS00MDcyLTk4ZWItNmZmODQ2YTMyOTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Q4kQp8OrZT/yXHy3RcP4qmea+GzjgKuykho3YY1hV27qY6ypoSdZyE+nycN\nnyPJIudJ7KzgFig8bj7A8r54u6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL0hl6dYb7oKWIHsSE5YTriRJofAwHwYDVR0j\nBBgwFoAU4lkdtVbldkg0g34slyQ8BFCh1NYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiB1bcMXyL/u0rS7ATW6eoAvpBYNKoJJSgdy/xwBLlur\nIAIgLwpbPEv63wXdK9/CHe6F8v60+sM4VbpmbC8F/4tLpRA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZFNuYEVEnpJCBJ2sUSgQ8EdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjIyODQwYi03MTdiLTRlMzAtOGVmYy0wZTYzNWViNTVlMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQNBiXjbwx6lW+gHSSbJfhFMmnBM/o1MxpiRMv78hKloT7\nHEkvNXbtm8EVoduVDZV8jWwLGTxqh5QGtNmqArjHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4lkdtVbldkg0g34slyQ8BFCh\n1NYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR44vnd/b7o+yHsku25Rz1ItHgrfUDeTGrglMXx0IU0QCIFyYQfb7JjwZ\nKdGGSPS1EhmlnljfEWxav+cJPkZER27A\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAV9tXY0Y8NR5E2oHhqUWHwDxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgwN2FhM2YtYmNmNS00MDcyLTk4ZWItNmZmODQ2YTMyOTgwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzM5NDIwY2UtZWYwYi00NDRmLWFlYjktMzc4N2VlYjk3\nZTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEckMX///YqSSlNQW09hUWcv0M\npHJcwA5gTAQG6VgifCadifWrGrnE81c799/Eo8TdeKZcuryEkyQi6NwkKpBSuqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUL0hl6dYb7oKWIHsSE5YTriRJofAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgaIRV5+Vq\n2BOke6Te0y+u5ZTshj3IeYYPh5M/hSCwoO0CIHCHI+2JS4FI209TJ1noCl6sH+Vd\n33MllkVNRYw/l4Th\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7023", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7023` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAeKqkOerBfaVZ5QRlba3NFb2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhNzA2ZWZiLTQ2ZTEtNDYwMC1iMTQwLTkwMzRhMGQzODBiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzkyZTcwN2MtZmM2\nZi00NmIyLTk1ZDktYmVmNTRkODgyMzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZQoYhKToYuA/kSQxAz51ffTSpgMae2bGSqG5WdDjC0+drAKtwME294GzOqWf\n3xlbb8P8nCc9xOrwdW3bK5hCmaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEUWoyDaZP7/hUa8mCg3AcWDWu9YwHwYDVR0j\nBBgwFoAUWic8pyTHFYyW5tj1fUEkavgo2I8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiA2rAajV19pbfqmNiXbkiIAET0PdG5/CnUUZPVMbctc\nGwIgVMuCrAMmrB0hNN8T1+J8yaKdf2XPHIfa0zKAlJxGxw0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARJTKEppSz+SXljM//Iy3BotMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTcwNmVmYi00NmUxLTQ2MDAtYjE0MC05MDM0YTBkMzgwYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARklD+A1puEZxwow0JFhkL4C2TyNC4+7v1t6IP7paZ/731U\ntXT4T262PRTueOPexui+vi35iljZ3FKflL1QRxZEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWic8pyTHFYyW5tj1fUEkavgo\n2I8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANQl554ajObUa/9r4DTf6yNDn0r2/KJWNFsAxcrhwp5/AiEA8uiOeKet\nSfP/Gp4jdWpHQi3jW01j+wQNCdn2zs6QS7g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAVonBE4OZX3hYGvY71nrDuKqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzkyZTcwN2MtZmM2Zi00NmIyLTk1ZDktYmVmNTRkODgyMzI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjQwN2I3ZjAtOWRjYi00Y2E4LTg4MmItOTUwOTBlYTAw\nNmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM3CPJpASzVk+uzTqjjGel3OE\n8d25v77Oq9FGkI8FN6ZrPc/VeC/xZkc+ltxukbO/7k/bXk/zxk/SWrOpPwOjQKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEUWoyDaZP7/hUa8mCg3AcWDWu9YwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAKnN65d1\nAv1JFGOt/rW25lXTYJkX1RuUfcLU2BbxopQtAiBYUPyS5U/WTW1G0N/jMrsaKWek\n70GB2JbKziM/ghiqlQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7024", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7024` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAQjFHr6jfFv/UucbtbX1GVKNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2ODk1MmE2LWE5NzQtNGZiNS04ZTIzLTIxZWFlZTA0YTVmNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTcwNjU0NjEtYzRi\nZC00YWE4LWI4YjAtYzE2NGVkOGM2OTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/bup8H/+H867AFnnkp6xXrElYCe7FdpnTfukYXbIJ74g6MTAA4GNZJzWR46c\n49mMSRJtyAo3uvv82K9QrVdmKqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW5qItVNePebF/2bt4hRa+1w+L6QwHwYDVR0j\nBBgwFoAUMYQ7f/nxXXI0EvhW4O5AT5IWvFkwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAkIar5YzB6J8w6akzzVeJ8E9A2kIN/VWuly7qZd2JukQCIQC8\n6KCqXIX3BpUWifLRpiG/Ab6EmpndAoSRIdFfaxCykw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbrUd+bco0yugY1ABfD71aQIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjg5NTJhNi1hOTc0LTRmYjUtOGUyMy0yMWVhZWUwNGE1ZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPKiFgLu4t7y0ARkuWv6tT1Xy1nuBLnK6xZx516Vk8Vlq0\nh7/vHnuLra+sbiqvAQUK04Jf9NSiqHMNXoipNo79o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMYQ7f/nxXXI0EvhW4O5AT5IW\nvFkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUjfid1of/Hdufj9HOpdGHHNQkuEEsanU9PdwA7KsNBoCIBNOHbJujLsS\n3asbvt6ewXRr/IYLzDkQQ0Sn9ObMgq8z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAc00MuUpc0ntNIuHs5CAvuPWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTcwNjU0NjEtYzRiZC00YWE4LWI4YjAtYzE2NGVkOGM2OTFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWYyMWI5NzMtMzk0MS00MTdjLTgyMjQtNGJiNmM5MDg2\nN2I5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEigx+C/Kx3lpJMOkcrdo/PgPY\nGsjCBN2Usoh6vC+QAwetmEOOtABMrYTtjXrRUFIomLi9pszdYvwLJQgl27jjKKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUW5qItVNePebF/2bt4hRa+1w+L6QwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJIbiwju\nbFs633oCLtA1Ietu2UOGcEV2jwUOm8u+LxoMAiEA6g8QARjCrDkKgkGk8PQO0MYo\ncVhhUJDuvKsAFd+nASY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7025", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7025` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAe9CPwvb59qmcIAEDoTpLa3CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMDEwNTNlLTE1YzEtNDg5My1hMTk4LTNkMTEyMzI2OWYzNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNhMWI1OGYtYjQw\nMy00NGI2LTkwNmQtMGE3ZmZlNDNlYTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuezXdKtn51aTymj9QvZk3TnVLwNNqT1uZ9Zq3fwBiGDuVGvGYu1Y8yklN8AR\nHa9vvYlaRDbKs/j00m9swlHnD6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAnkxtW0a1UW7mSqIEojlZbPsIqMwHwYDVR0j\nBBgwFoAUZ3G8hwtXbMR5Tb6LOpMpt5GESgEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiA5KfXzFN2TmLP/Ebsq0hRuFV0ZHNYK0qcd\nvl6tuBePMAIgBKKYE537kNpF08sjVjci4qMcCA7B1X5eyF/YJvgddps=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAacmhawSBe7YfZiyGgQWk4GuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTAxMDUzZS0xNWMxLTQ4OTMtYTE5OC0zZDExMjMyNjlmMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbzBG16EKKwYtow5vSgHp1dRW8JMEF1d+sHE6ovkcib6LG\nYXC2tKjtmFxstke9wAqqtk6L4oUVczb5/dYDWIUko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ3G8hwtXbMR5Tb6LOpMpt5GE\nSgEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYovqxvhx7iHfVqhWcSxOLQI6OS/NDdjHVUOo0mWnyVECIQC49Jezv0Tn\n9u3oCdddwHdyZY2WvMU9XGUHOt/q/zvA8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWQEGqvrtO4zsIsFHuqNRvLaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNhMWI1OGYtYjQwMy00NGI2LTkwNmQtMGE3ZmZlNDNlYTQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNiYmY1OWUtZmRhNC00OWNlLWE3NmMtOTgxZDlhZjVh\nZmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtpKPstvGCcGaGDfkS1YGZ3rc\nVfagLCGuTGnHgPuAAMitp0k1hK79WCyv62RMwarJ5VzYBH3kUtTgIQq/6EplCaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAnkxtW0a1UW7mSqIEojlZbPsIqMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgcpGSWDQR\nN0NbWhQLCZu6w17VcpeGgIsM6VqVYfn74JwCIQDdXUKFdxI8j1noLlgKurp2npQI\npbfDB3+2c3V1RU7Cog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7026", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7026` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAeq9dgeNg0wJijfMC10TgKaGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzYTczYzk2LWUyZjUtNDgzNi05MjI2LWUxNTNiMjIzMjliMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY3MzE2ZmItYzNh\nOC00OGM2LTg1ZTItNzNkMjY4OTZjMTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZqpD/bmlV6daIB/HXYl273yv9Q27cicsFGe/GFyEwRtNXg9/ry7eGndjt7nL\nOR954Ig9VNeseR8c/SgeaHK9XqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0P/8rW7eM7sXy3am+1lfVzkMkaUwHwYDVR0j\nBBgwFoAU91Gq5WewCXX4wFj6iCt9DIlG2AwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAi35ZxtL0/5UPn+9AReoXv/ApNBTA30Ef\nmjhREODGf6UCIQDSdELDzR2ln8NyfRXpK+ghfYNPwNi9NPfloiwAf1qigg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ7QuL+HYVVoLL/Jj1CWPgWYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2E3M2M5Ni1lMmY1LTQ4MzYtOTIyNi1lMTUzYjIyMzI5YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1E/4CDMb0UgRFwyZk0c6+CalIlqTlCybT0gd4Tdwq1DqH\nYoiCwFwCxWhGJzj+umB4uv9aaiDSeGP7ufjHLVaXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU91Gq5WewCXX4wFj6iCt9DIlG\n2AwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANT0RLPqr/9ACcVP3kpwjtLsmY4Ue+/a022ldYCu3ZsnAiEA7z3RMsun\nTUbjZVh2APbbsKdMAgLEgCLAFRwanvzwYuk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAY4iRq1lEXThf5pl+AT2mLo6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY3MzE2ZmItYzNhOC00OGM2LTg1ZTItNzNkMjY4OTZjMTc5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODQ2ZTI1NDQtMTY4MC00Nzc3LThkNDMtZDJhNjg2MDli\nMzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHrTjsUfs4uXvqPn5loazWxE4\n349f1vgl4mJAw03wjxpTpTKjbkABYxXoj66YMt9aotZnec8RXCtgm+s8Ahd3HqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0P/8rW7eM7sXy3am+1lfVzkMkaUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgT1zwoUkh\nNk0BbLxmXwfHZLmDzFhWl9iXWwez/nGPEgoCIBC0iboZ0/WHOmmtI2cB82nNq18r\ndbWfrAXrV3S9d0Ea\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7027", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7027` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdYvS7zmI5wpUCk6Mfz2HOKTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjM2I0YWZmLWRmOGYtNGFiMS04NWRkLTc5MDY5YjU4ZWI2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ1YjFiNmYtZTll\nMC00YWIxLThlYzMtMzRjNDQ2NDMyYmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERvf5wiJliF40ZTEdLzYbBTqldMTtk+FAvIfCzUW+f7gm4VotQSIUKUS7ndyj\n93Ure5jVhEPPdl9QO2rJWNDJu6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvX3gIFuPTsBh9dDJmKgc3pkfH9IwHwYDVR0j\nBBgwFoAUewK+IP/38MzjCs2UEf//3EdRSDYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBE1Y3Qkm4NldbSSjG2h22yja5TD\nzpSs1PU0IKS9uvLAAiEA5HO4Wuj3AeLPW5tLk1urz17LYcnA7IhxpawXjP3en/o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ4SA0BQpEAEI5oT5kMoYX6kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzNiNGFmZi1kZjhmLTRhYjEtODVkZC03OTA2OWI1OGViNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTAM91JY97a2LByYnN+zUeSI0/qslClWKTR2Xg2Hn7CL8u\nWg3o22MkgxWiKw0+yS1bubgIYwexAW5uqm4g4kyTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUewK+IP/38MzjCs2UEf//3EdR\nSDYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO7/EyPmTStLI4H+S34S2kXg03Vn1SzyexoUtXqgA4y0AiBYAfSulBbN\nINmnWdsm4hbNnNkJXWdkvAuaxQymd+4F+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISASt6RPRNGg6n+hwDcSeLMkRtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ1YjFiNmYtZTllMC00YWIxLThlYzMtMzRjNDQ2NDMyYmNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmU1YzZjNmItOGFmYS00MDY1LWJmNDYtNmRhZWFkZmRl\nMjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXvbXVkWbUBv+tHN20yFnEsVi\nNzCyI7HhyhxVOcbCwd2K4pkFOkV7Z5yWU5VWYJSo5bqaRzkGjhlRA2AW8Bpoz6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvX3gIFuPTsBh9dDJmKgc3pkfH9IwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgCml7n4n6\nXIRdn4r+b9Vf8xp9z9xlXd+COHvEz0PBoFcCIDbRzth0zH0uQoBnzXzRdjRk/AJR\nD+2Jp/HaqNvagcc8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7028", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7028` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAeDHKV2FWi0CDNbhyTPgnIS1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyYTU4NmUyLTY5NGItNGYyOC1iOGRiLWFkNWNmMjczNjFmMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDkzMjE0YzEtOGQ0\nMy00OTc2LTk3NGQtNDA5ODg2YzkxNmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDK1jaK4fKUE3qpaQQWIOlu0lHEiCdCden5tj+c++1wsz17iQWojmqFlWXQcl\nFYWkS0w733oHHF57H6ZSTBgIq6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYVR1DlXooSRYK00scomskjHSi88wHwYDVR0j\nBBgwFoAU7Iv/xUXOKNlRGtPp3KcbxvAyU+owKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgQojuOzCz\n2ADY0v3qeTFCaLTQHlr2wtN+x+IP9ZqHjV8CIBzw9/pZTwrHhzGfJqTpk33Ls988\nypKAkNdtKInAtbSf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcgbDx1BPk5yzEEDqvd0XQL8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmE1ODZlMi02OTRiLTRmMjgtYjhkYi1hZDVjZjI3MzYxZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnKfQ4BaDY3PtOlvoj1qyi1d9MqGXIQ4efXtb9v/MhdvF0\nf2JDLy9DFDBbcZNbAkTfF+5YcXDfb7Wgde7/9f5ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Iv/xUXOKNlRGtPp3KcbxvAy\nU+owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXtLTP0C6YOt6iu0qzVzEzRcn1GXpC3ifRWID6GC1qI8CIQCVjqVcdnEb\nB4hEXfb6zqSLuUNf6cpgsBP7Mehi15osZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbLjUfsPQiu/GoJjR7Y1SfFeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDkzMjE0YzEtOGQ0My00OTc2LTk3NGQtNDA5ODg2YzkxNmVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQyMjk0ZDMtY2M3YS00NGQ5LThlZGUtZDA0MDI4M2E0\nOTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/r6TjgoDzEb5hH5C2/VIjXnO\nWbKI3KgG7kIzz9TnkcoKDZ2X0R0ckGgh1LnkeRJL3Mu5zFwRx4uzNwnTIVJ1xaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYVR1DlXooSRYK00scomskjHSi88wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAM3TibOb\nsmoKu4gNeNfHAqTxoQj8eljmoZfez8yxnjIiAiANsGn9RgyQIjjyg/jF/m/VjWZ5\nG2/swshZKFRy8vxlkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7029", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7029` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAbwtWRkcW/ZEOcGRXPhyjy2tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5MGEwNGUyLTZjN2UtNDViNy04M2IzLTNkNDc1YmFlODdiMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTEzZDRkNWMtYTdm\nOS00OTk0LWI2NzctZTg4YjVlMWQ3ODZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO/aiitjK6P0EDR9AZiNw0u74zXIbRBOjGAElIEcqNAmEiyUYoWqaXxiRAIIF\nuI+PoN3qGSSf3bemwypoqhCYx6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPJEPnCzRyt/TGX0VZgWlkUAR6iEwHwYDVR0j\nBBgwFoAUa3F4CbGLihZ9SeEtKbsON60uW40wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgA9NC84vm\nXiEcwCDCuzuDhFealDkZHQegiIKlCUDQmsMCIQDryBwL/my2FqMj9fMgoIwG/AdA\n1jw6cUo26SkxRZVYwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATkzIJYvN0FRYsiSiuYBBdUjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTBhMDRlMi02YzdlLTQ1YjctODNiMy0zZDQ3NWJhZTg3YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEt+jBHSl9agAqeb82L2D24fxNG7kFuWEGyYcZW2I4pgZm\nCBA0b/NayTYnL6l9ZefjJ3wqtlpzFnhtLbUpX7UWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa3F4CbGLihZ9SeEtKbsON60u\nW40wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIyf6vNzrglYp3i2m27PO+Q+VgvBULOGKO/jBFbuFDYiAiEAmIiiWYEr\ng4OfRY6UO3BFp8oAXCkjnkafAY2SAijvZUc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbY2QS6V0xCfwll0bMgOLbEeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTEzZDRkNWMtYTdmOS00OTk0LWI2NzctZTg4YjVlMWQ3ODZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWE2NzBlZDQtYWQ4MS00NTUyLTkxNzgtZjEyZmFjMGNk\nYjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp+BNjApsr+UxO3Qz0GZA4RFu\n3271HRi8n2CISYG5BoyIuXgc2CMhIFZshvpdz7fooRqg5ZATYvG7CJPkFZP0gKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUPJEPnCzRyt/TGX0VZgWlkUAR6iEwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPujOqcM\nW2C9s69ZtlDr3w3v5s7G/QRLXv4lL4e7ycesAiAu8hGbQHo82qEh1mBMMDRnLSMz\nX9Lala2HXTbPvxkrJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7030", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7030` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISASbWr6OUJGt/CHC1bw9yn0VHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjODkzMmI3LTE0MDEtNGJjZS05YjBlLTk0MDAzYzQyOWJmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y3YjkyMDktMWM5\nNi00NzgxLWI0MzQtNTk0YjgzZTE5MzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECnVHQEhH3OGeZqhT6vqV2Df6dg8QHFXzn/FjdoikFBqtQzCj0Wj3u7TMx19N\nFv9zqExsyGINITFTlTIEl3ZcUaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWFGEZhXk6OfBCFmhC6EwYjMsT04wHwYDVR0j\nBBgwFoAULU6Y4Pi+jolKQQZO7RC+C6p3X28wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGFtzQxy\n34tk7tXeloo5ObR7iyby6tsilID55E2VLbHUAiAc/QfwR+vc6uP3661HcYSpuWdK\na/HGOwPdUrSrF9/35w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQbAzJkObINT9QBYJHdy0D5cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzg5MzJiNy0xNDAxLTRiY2UtOWIwZS05NDAwM2M0MjliZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9ojZBZ5/q7vsCt4ug9SUKDj3srMUjPvSFBlM0u4Q2FNL1\n6YF6gnjKBTjUVI8HcwV7E3G3HlvJylS0wfPjbZjKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULU6Y4Pi+jolKQQZO7RC+C6p3\nX28wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUumZ7YmKySRy1krSwq8SOr616Gd/HLWvEETat3+b9RoCIH6043yS3h5s\n2aFY1FJef4emY07nj9xUcy0eXaeSZ9g4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAae1kvaiuCzwcnlKKR8+ApCuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y3YjkyMDktMWM5Ni00NzgxLWI0MzQtNTk0YjgzZTE5MzRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzkxMmEzZTYtMDFjMS00MGMxLThmNzgtNjNmNTNkNTk3\nYzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYv9fFGCdrETQ6AM2oh3gAZvT\nNMrDGamKtQREwAxLx1KiKSgVoduQove9RMYSWGRtOO9oJRl2JCLA0MFs1lJ9TKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWFGEZhXk6OfBCFmhC6EwYjMsT04wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAJJ7xQoI\nn9Wua8eQ3vASQljx/k5qAJwGFWGL18yqBL0EAiAAm2Vy6qF57hkoP98awMwSn/aS\njEWN0+OET2lzbcdgng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7031", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7031` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAX14RvDAGynCmgZEWqQ/fgoGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMDI0Y2M0LTNmY2UtNGU2NS1iOGFjLTMwYmU3M2NhMzFiNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjlhMDQxMDMtMjVm\nNy00MmYyLWIyYjMtZTM3NjY0MTc4ZDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfcXT+WOMNF/tL/14r7wZYgYKH/hGZtaI+mhzsP15ZGT3I0e6EeLfZBo5yfpk\n5uW3m9dwk0O5hiUs80eTZckL56OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU41x+LX8SG4Vo+Gycom4VvQiHPu8wHwYDVR0j\nBBgwFoAUTsMW2KA7k+xCl6wXdBhG7jggze4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDZCyIdgYviVSxsz1cAr34SWHAw0joxIKZHPH0qWY+1awIgGBE1msS1\nqc8Ob7VUmRUaZWG7mLeApS1v2theaJnQ1LQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAalhSp41o6sjSlM9Zt8+B4hNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjAyNGNjNC0zZmNlLTRlNjUtYjhhYy0zMGJlNzNjYTMxYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVOPWHrrLNADAES2FpMfR7Rq248I8ui/krjv9xP0n2+N/i\n0zAU0cpXuIInBSP8GYXM1xQmL0H7LlkhUylaOp1so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTsMW2KA7k+xCl6wXdBhG7jgg\nze4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJtTfVt2kMpqDE6NZdld/wZlYnCj3XLdmPXqYNTPQ/RoAiB4seK3FcrA\nt1/r7OA0ZndtLFQ0vMoIOBQ2TsrjrZuP4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISATfAceLXVDYkIQi1saupLlsNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjlhMDQxMDMtMjVmNy00MmYyLWIyYjMtZTM3NjY0MTc4ZDlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmEzMGVjNjEtNzZmZi00Mjc1LTg2MjgtNTMwMjFlODY0\nMjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEogIAniv9VTSX4db4OilfIBgP\nL2Xy+a89WjWxovqsXu8lVNTEFqlEEnz/B00MH8OMCQ3eb6l+3FmyYg7oLsXxcqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU41x+LX8SG4Vo+Gycom4VvQiHPu8wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJSkrjIS\neEeGxhBhqgWhBZeZifIZCXB1niDFHYm5RQPtAiEA19sUyMZHOsV8o+G790B0HaVE\nlb2P7EFWQJtO182rhd8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7032", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7032` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAf12ggKNfFPa9m7KuWNDd4/JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NmNmOGUwLWQ0ZGUtNGMzYi05YzIzLWQxMjhkNWYzOTAwMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTYyOTUxOWYtZTEz\nYS00MzI0LTgwMDEtNWQyZTAyY2EzODcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpVPc3zjX5zXClTmi6v1mS8d+LEx/vx9MnOMgYmdVZOXTi8KAOAjlK60294vD\nbX3TJylGtQX67Q8XULmMEydlRaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+e0whBsRIi7+oXmDEXoxAccL6K4wHwYDVR0j\nBBgwFoAUJR2dWTKbukcNq2CniwSJJc5ugbYwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIEaKhz2jBIyj1O3NwqXCupFW2xI9lyhROaXU9JIXLmYGAiA2y9OBdIfM\nX9KxvilDx4Pm7gwP4OA9IDguBXCm3ruzSA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZPzED1JI/ttKPV7qNQ609KzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDZjZjhlMC1kNGRlLTRjM2ItOWMyMy1kMTI4ZDVmMzkwMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARW8gkXpP06gSnMoz92Zl2NwVn0IHigjpZjb30D/ljRiybN\nyUq/zeAUa5r/bdM7kJqVu6jsq1D05ZkOlUbB02LZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJR2dWTKbukcNq2CniwSJJc5u\ngbYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC+iPrQckm19+UU0gBMwk4SRo1Zoh+K3r0WGcU1l+QnsCIBUSSdQM2qDm\nLOMxcswM+njVd8PHec+ofoPxMqmA4QKC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAauiBFAP/DRJuoapfDrcFq9MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTYyOTUxOWYtZTEzYS00MzI0LTgwMDEtNWQyZTAyY2EzODcwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGEzYmEyYzktNGFjMC00NjcyLWIwOTktZTJhMWViMzI5\nMjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbP0NMU9abrwEGsDhMvc2q3zu\nDsdPOzmslH7dlyJWA6UvD4vlcPMUVYIPXW/n1LR3+KQwPzjlefJuKIs8ZyH+GqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+e0whBsRIi7+oXmDEXoxAccL6K4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAJWdt0G6\nb6pZ6SaFlIrkwGM4ZjvfVID1B6v/PNReOQhSAiEA+yHpvl+SJkLdowGzBlNhjLMu\ndRjfwNdnN75eMzOfGq0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7033", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7033` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAWS5yfJuWEvGNxi8oOwSJFzSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2ZWIxNDA1LWViMjgtNDMyZC1hYmY1LWVjZmQ4OTcwNTQwNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE5YTZkZGQtZWY5\nMy00MTlkLWIxNzUtMjQ0ZTY4OGQxOTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvxfJnJ9UrH1L7d+SUjp9vZihYR5VcVyb7yGGNKfZNQ3PKwpqzEMkOnYlWaW5\nM7yNadLZgWtyy3arlkHqoBfO+6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkwMIRzPyrEmV1s8ECS49kifCHYIwHwYDVR0j\nBBgwFoAUk6LHP/PfAJlvTSMeCszBshC0fzEwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIGXWYdB1E6idUnjIJBlofpiyB6vT7aFZIjAEQXbwa5WWAiEA9bp+cn5pr3njhxNA\nJLMruFWIJqRxaabwtbm1zJ8U33U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV2g4F9feInafN6G1mDXM551MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmViMTQwNS1lYjI4LTQzMmQtYWJmNS1lY2ZkODk3MDU0MDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQY2KAojgccmToT0MpU0dsrsxFS4avXiU8/85/ksvAoOCz\nXjmPdH5Qp5WXcPyV6xqYqm1FHvCbOAUGJx+1dA3Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk6LHP/PfAJlvTSMeCszBshC0\nfzEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANrrLC3z+CL0oxf6j1f6vggYi7gdNoSZzydmsGyS5BgtAiBn7Sz++zDh\nblGaMykFmtBLegTqeQarec0gNqJgqItipw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAf70gpOOlRUMFAPlwKtzAM8cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE5YTZkZGQtZWY5My00MTlkLWIxNzUtMjQ0ZTY4OGQxOTc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTU2YjYwNTUtNGY5Ny00NDcyLTlhNDAtMTE1YTIxYjBm\nZDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfV/PyOP7sGYDrUzuMnVEBz6T\nXGYCGrlTn6ALQ11Yx/oSVL2pYSvaAStursPfSZWS4sfJVsnqi/ixeCp6Ah/UJqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkwMIRzPyrEmV1s8ECS49kifCHYIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAObsvbj0\nfl0y+9g7Oq9f9SpZd32rmofXbThq4yn9KlnrAiEAp2upPtOeJTgIq7OuhpTnBxHG\nt18vW9tLRka9rvRLDq4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7034", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7034` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAdTrakPwTRUcOvIG3deMRUmTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3N2Q4NTY3LWYzMmUtNDk1Yi05N2NmLTNkOGQ3ZGFiYzYyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhhNWIyOTQtY2E4\nNC00ODUyLTlhODAtNDA4MjMzYzZmZTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED5GZWsBXL/TX5jRMdcbc7jdiwVBVq/ks7QY3RtrO9Z5Sg2ZWBz17H+XuNroH\noENRikC+GF5Vh5mdKZjBG2HixKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIY71Cauh0wKHFEbIOqAZoPjwdiwwHwYDVR0j\nBBgwFoAUrTj73B1mtOko9nBlL4/bl2fdlfswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQD3HH3MHlkvmiYcDhMtbJGmb0p5Mq7M5D7wNfoSo1216gIg\nS4Zz4XTFkqVIZk0dN9hrK+oJOggw98FCzRDb40XFq+U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARhwL2uRQD4BdPI9VTalJ1CbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzdkODU2Ny1mMzJlLTQ5NWItOTdjZi0zZDhkN2RhYmM2MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBi06K4R7HyybsnsBCepnYrTfEtdxaDZjMJsy5hpAwYime\nfGpOyNMogG0B4h4uPV64QGM6AIr00vhbZQ2O6Ebzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrTj73B1mtOko9nBlL4/bl2fd\nlfswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgROFZmhtvv1kIwiMGiwcHBzvv0QjTJNNdvjPvaqyNakACIQDQf6/UDSsb\n7XKFgHSCFPrpjCV1nbQ+cmpr38EXltjjRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAcCXNc96zeDu5sHi73uUsGVvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhhNWIyOTQtY2E4NC00ODUyLTlhODAtNDA4MjMzYzZmZTgxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWRiMTUwZGItNDg2MS00OTAxLWEzMWQtNjcwMTMzZGFk\nZTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsl1kmq67SosaZh6k8oFoYrij\nNW0tzkrVKQiRkdMuEw0YlTbMWzASxNDad7WLvYQq673j0sJ2nz6xMZHkPstqUKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIY71Cauh0wKHFEbIOqAZoPjwdiwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgG97abSxG\npok2qgiN57A+OYNEwxsFD2cWdSHGVCUMB1ICIDcf/asu7ecyrN9KLEKkOdlOPbm1\n9L1QdY8r0q3pgyaq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7035", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7035` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAftX/GegDrTRH8oGWC+d39zdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxMjllMzE4LTU3N2UtNDU5Yy04ZWI5LWFlNWIxMDUzMjJkYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM5YTJjY2QtZDYy\nZC00YWM1LWFlNTctZDg3NjE3Y2JmODhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVOMalNlWGzujLFrlDtdHePPnpxJ2R8n3e5F03rHYXfX8zu2vNAhy2fZfrQ7A\nE/na8K4GXcPKP2rlnjPBi43OiqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBKCObrCP4ZqpNzGIPSROM1oipM0wHwYDVR0j\nBBgwFoAUvCOiBemeJiVf7Cej/YilidrcIk8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDYD85H0uKaVAilwHxF/H8wWf7crXRgivKiZAIB3z2BYwIh\nAKEH9rlHW4hS9+kSoxb8ziHQ7qy/qXe7k7/YlEld4H8r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeJlYaQps8jgpJ/bKsgIUStiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTI5ZTMxOC01NzdlLTQ1OWMtOGViOS1hZTViMTA1MzIyZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/Wts9TAgp5F4F6o+ZqTFPoqZl5AHQ64dgBCyhIcU8zLa0\n+3694FqmuDGuy2x21QQgoLHI0+3xgXpZZREeRBlLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvCOiBemeJiVf7Cej/Yilidrc\nIk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJZ67dv06hfyyqiTq/FN+sGE6rrPXFw2rG6ERULRRlVvAiB0UMd8Nk1Z\nfC5BDsNAw4vvu4wAtKS2pZ4GGZGhBWTttA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAWPkJjsDTjsnS0jqVT1YX3IlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM5YTJjY2QtZDYyZC00YWM1LWFlNTctZDg3NjE3Y2JmODhhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjQ1NzVlMWYtYjk1My00ODAzLThiNGItN2Y2YjJhYWQ3\nMjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9k8ilbusy8Sh9POB5/8lPlZv\nHsqLd45SGwiYsm5eBULFqqdEnXePQaWELg2btj21IiH7hR9PtjZ8X99WMvhKTqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBKCObrCP4ZqpNzGIPSROM1oipM0wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgeYXfUnYf\niFE4HYQ0m2/ObYiz+vIXHkan+f4N9o+Rzw0CIBhNWvRgOvPGjCj3sLP/qZ2vHNYF\nIuMdXaVRmrQgJlei\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7036", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7036` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAbD4JxOklFIQCHMdfivmhYfWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExZGE4N2JjLTMzZjMtNDYyNC04OTU0LTM2OTA0NjllMzk0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQyNDQwODItZmI3\nOC00NjAzLThiMjYtYjE3NzI0MmQ5N2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQTHTshQAoDCfAFPa7vc/eKYukZBQVHF6Xmzfo6Exs+FYXc9Xh4wE+lswZEJ6\n/WNBK/4HorGBE57LA5QEGKXunqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKwFI2q6ZumLtXdDQcyc/u/1F/6MwHwYDVR0j\nBBgwFoAUumVKZj0JbdI58pFZdU83e6gVcoIwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCPtijb1Tn8\nSwhtXmIR8L2+W7yvf/grDm1C/0dkLiy3OQIhAOK05ivBbusErLmoste5sI0Qslwo\nBqZKHH0xn11jZh4R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASrjeSHaMYjsF7vBIXx1yYe+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWRhODdiYy0zM2YzLTQ2MjQtODk1NC0zNjkwNDY5ZTM5NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHU2KXQUYieyhtWZugiua4fs0yS5Tn4epK0WzImsE/tGre\nmB7gcXefiYbRY2boTI8KS06G0QYgGxKHJQEX6WCco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUumVKZj0JbdI58pFZdU83e6gV\ncoIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANj+TeA4RVc/brZf3D7J6q1qtb9LKlW7GGaGUmjnuAeyAiAbGvCbSmQ5\n7UT+F7jKD2F1Fz28jFNRJVV5PUnCVSGEVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAf6UdtOgvE3/7ZgHs/vkKRrrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQyNDQwODItZmI3OC00NjAzLThiMjYtYjE3NzI0MmQ5N2U1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTEyMTIxZDItNTcxOC00ZDVkLTk5ZGUtYThmMDdiNGNk\nYzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb8osjUGgw04IdB9UbjdAwq8G\nMmG/AW/JKi5jo/tgcMgMHKyofe3UCYVlcwh42bJvt+8Po30nJ8Ez8rVvITHUj6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKwFI2q6ZumLtXdDQcyc/u/1F/6MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgTwJpo36h\nR24YWY79B6q6r6u8bSPBIjS5+9JCB2m4ScsCIQCmzLy1y6JpLaKn7mcuy9Uvtelm\nB1X7uhNxAO0N8nv1hw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7037", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7037` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAdfzE17FJOgPjB8jvS3hnHVPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZTk1NDE1LWJhNWUtNGQwNC04YTY0LTFiMWM1YmFkY2EwNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY4NWNhN2ItZTY3\nOC00MTFjLTk2ZTMtMjVkZDQ4MzgxMzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiFqrU2KiHoLHvBKIFoA/7unkiwd+kkmg3k8ydqrvuPf7IiEZVomLDNTpKA7m\nnOsegEJuW+mBdLFT+pdhp63QOqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj6rbM4MHC2nmSO6aJGrfSNAtR54wHwYDVR0j\nBBgwFoAUdbMucO68VJMjS3DkNKlrOwVYJ2EwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAIIkdZVbk5rE4vOCGM/KOQ3rJtVg3JQmThQrdQoVgZQSAiBV6QjD0sud\nihC8FiaG4dm7NVJHP0LttDpJKFxBUMAdWA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUdCmRA9Lh9lBKuSkcY6uS9YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2U5NTQxNS1iYTVlLTRkMDQtOGE2NC0xYjFjNWJhZGNhMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNRFiRId7CtWbuIsmDURYSe7aaFpbLp50nzp9KTv76YxSm\nl7uYV3+ctG3vyyx134jZ6NeEGH2GF6iYiTOT7GtQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdbMucO68VJMjS3DkNKlrOwVY\nJ2EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeDyJMRUx//YSzm5EMho/E0cNYot3RTJLToufY/nrehMCIQCr1oSmh8l4\njr2J2k6freurb8hJevWD95/Rfmk/sy/uPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAYlRXaS4zd6Z20OOoFtfye73MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY4NWNhN2ItZTY3OC00MTFjLTk2ZTMtMjVkZDQ4MzgxMzJjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2FmMzY0OTYtMTBjNC00NDMwLWFhODItMDFjOTM3ZTQz\nMjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9LE4jDGg08QWPrDFySI18J4i\nS3Ov9UzgmdEkOhcc+mOfR9MVWkehPd5RFx8f5yJOUD+/0C9p50jjMTCnwbVSMqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUj6rbM4MHC2nmSO6aJGrfSNAtR54wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgdBQIASMR\nh7K08EaP8bMRMa83EmGjsjNtCeWMRGhHC7MCIQCoQCyF66eLdAypge8cCd47PLZN\n3t1Z8zAo2soIuMMxTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7038", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7038` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAemFGgojdtV+cej6+aPoZHcFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4NDY0YzQ1LTc2Y2QtNGU0Yy05NWEyLTZiNmUzNTc2YTkyMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjViNTM0MGMtYTk2\nNS00YjVjLTk2ZjQtYjU0MTE2MWQzN2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzxASEcb3TyMjlixPOJDTgP7f61grL/yd2IzxlfmoWk31u6+FdLmwUezoAH3h\nK48d6UQ/hfkP8LMWE9Yq8PX12KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXwWqWzb2Qif9G8bzay37ffFIa1cwHwYDVR0j\nBBgwFoAUZ4BLRuJOywW8dn/pf+vOXGFqFhQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhALRy9zcHZEQFKIYiJf3hTFnOjOhjh2QAvbGG2VaJU09bAiBUtsH2Z7aY\nm8t7+7W/rtaeop2Juo0s4M/io5RQKTVXVg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcW8FWI+MQy2QY621qp8eatCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODQ2NGM0NS03NmNkLTRlNGMtOTVhMi02YjZlMzU3NmE5MjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKv92QF0HhoaeznWulAUe9JrAbD1jFzVec2s7hLAE8HlxP\nphv1luQXR4gg6cKlrMu6K5fmZ9bLfhRYTd2GBvudo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ4BLRuJOywW8dn/pf+vOXGFq\nFhQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKefHZ3B8i6i2rklcOx87e5NO4z1pGN1TNQG0euDHgMyAiEA4ISZTEXb\nsV5wJwuvwTIkEg6KWjpfR0khFwHr6Ela4iI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGDCCAb+gAwIBAgISAdp1HSPDNBP4KDvm0Xz8gqooMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjViNTM0MGMtYTk2NS00YjVjLTk2ZjQtYjU0MTE2MWQzN2RhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDZjNDc3YzUtZDg0ZS00MTYzLWEyN2YtZGNhM2UwY2Fh\nYTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEawqugPc2b7CgMrwCZfUR/6xy\niloRcHzfGvS+MahO+rJBnZ3oMTM7CyqIitTGI42g91zQaZBFFxaRYagZ6TP+8qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXwWqWzb2Qif9G8bzay37ffFIa1cwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDRwAwRAIgVNb5AYlq\nFQ+BJeLsR1objtSCyY7f+ywEr8Bui0mYIB4CIF0cw/cffHM3ZEf05S/OpJjCkS2z\naP9TnRzqfWOVaYIs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7039", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7039` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAaXW39vhTLD7gcJNe9soSrqmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYjYzYzNhLWUxMTUtNDI3NS1hNzRlLWRiNDQxOWZlN2QxMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU0ZTc4NTItOTE0\nNy00ZWQyLThhZGUtMmNhMGM0M2QwMWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgSV8Q/CFCSXFBI24tlfNgVNe0ytQ5Hhewh8LYUvnbOBLdRsdOtaXWw7T4ciw\nS2kn+m6vYPrqTalMalcMQPl5M6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhLZqLUyk8q/x3uz+vMnXUZNs14MwHwYDVR0j\nBBgwFoAUImUEisriHPYFkZgoBKdHkjC7JfwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIA668O+YjRW4BQ1YE1OqDcOAhbihOTSjn/pQjDgNJgNKAiEAmFAtDP54\nOw74RDlIS8tCJGDmjeh2ir1dvmv6zPdUFWk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZBK9+z64ggO/W60+icL9bVhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGI2M2MzYS1lMTE1LTQyNzUtYTc0ZS1kYjQ0MTlmZTdkMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuG44vm0IB9h+qTohy2+M2OVN3eIKuNfkc58XaKYJXV38g\ncnRazPipOW6SmNYuQjnPA8v9+E0zNZpGRHxpldmso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUImUEisriHPYFkZgoBKdHkjC7\nJfwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN1jEbq5pSmJ8aRpn8H5iO/LZIV9nsH5xKDvk/8xqW/IAiArjMziykAb\nQYD+7uznZ6Nip/3CTzxwV9+cZJoc8Rw4mg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAWCDuj16r9It3Q0u4L6pO1h6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU0ZTc4NTItOTE0Ny00ZWQyLThhZGUtMmNhMGM0M2QwMWU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTg1OTZhZjAtZDRjMi00ZjJhLTlmMDItNDQ1ZDZkNjIz\nODllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWofEDjwyXjpNqFLNmMrQWeCK\n2wfWWFxgcJJddT1iOdQjp7L2yRCimNxOVFxcyoD4fizIMWWCEt4/MGIvaW0qwKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhLZqLUyk8q/x3uz+vMnXUZNs14MwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgKdWouvNq\nAK387lRSkC3lygdurc0gCYXMBpIYG1AZat0CIQCLFipNg8aSoFvHD7qct/xNpURc\ncCzvUljMtsScES9W9A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7040", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7040` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAYq9k9jPXUsA6L6V2gkFnmgBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxM2JjNjkxLWQwNjItNDUwMy1iYjQ4LTUzZmQ3ZGI2MjU1YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQyOTA2YWEtNjZk\nNS00ZjRkLWFhMTctOWNlZmIyN2E1ZDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7ATX/gLGOrNn31h+5bYFnUhmdib+lDl6YsGrpgmRBt4TtnoAZ+jUadnaxsUV\nKHkhbPau3Q8EYhIFb2WdFyBQAKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdJN0rBcz6JyPXlI3JkTbED9PIfgwHwYDVR0j\nBBgwFoAUWuPUh6cqQJF51EhL0eHlSNXLqsswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDmcqAjb4Mm86jDpo9F5mQ+JOdG39gs6eJxuhpP\nlK8AXQIgWXTtpNB7fB9iql4RbK4F+MPQPK8be8h45Z0hBisQZsc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQT2FkABBi5IiL7GwmIjWUpiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTNiYzY5MS1kMDYyLTQ1MDMtYmI0OC01M2ZkN2RiNjI1NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQ4Jd46fxHPlTqnn/4du8HpA/2vO2Qxs1mjd1zWUJH89WX\n1KyaNqiPgC9ZosmAFaeUD5ySxZ6d5d9KYqksXrQJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWuPUh6cqQJF51EhL0eHlSNXL\nqsswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ+ZifzQr8Bgpx0TovszGPVEky6K87MSJu6awVjdwvoUCIF217b1gXX+2\nr3UDkdAsfdSLGs0E+3JYHBgUBoCeFTUC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbbFy9GnVod5ERbWr3EyCBRsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQyOTA2YWEtNjZkNS00ZjRkLWFhMTctOWNlZmIyN2E1ZDRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTk3YzRkYmEtZTY4Zi00ZWE2LWFlNDEtNDU0ZmEwOTU1\nYjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUgiRW0L9nv503kmfBwFZCsYD\neZfRkc3IzOIvxDiMhS44Sm0aAHIKerw1mc6OUL4jz+Gl+dqGOxgRU27VfxPIaKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdJN0rBcz6JyPXlI3JkTbED9PIfgwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgeMO6xCWB\nAysE+2/loGko6XqVv74qJkJjN5LZ/Uwspk4CIQDJGzXuo+RAeF/hzI1psiKH94SP\nZQroYgmhzb0LuAegVw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7041", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7041` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISASrJobzLhMwdagSNx/W1LjypMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkMTM3Njc3LTNiNzctNDk1YS1iMzNlLWZmZDFjMGNhMDJkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmJjMDJkM2EtYjM5\nMS00ODExLWIxZWQtYWUwY2ZhODZiZTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE312sWp6qL6OQIuq2JahA33a45JFBqSXnCiOojUwban4dKLsyFQGkWVHc0QsG\nM7PnLS5FPFddJdUzOv7xnTDp4qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzv5pizSCBSIZ54Oh8oeBxYtygLowHwYDVR0j\nBBgwFoAUaXU3E1zn39cS+9Ryeaxep6jSVPQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDOm33E+kC3d5+Z8rJ2Nyx3Kr7V5SkvVgqSCEP0\nSTWTYgIgdyuo3r0aE5Cm6hAM7024asdUszqPUhnEgBHO838lTYA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYqXTlmxPqI296JghgnM1LmqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDEzNzY3Ny0zYjc3LTQ5NWEtYjMzZS1mZmQxYzBjYTAyZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKtvIuN3W9baAX4DHU99ZJ2MkCaoZDSwS7nPoN7YsEFXO/\nT3PX7r8cZYMTJC+UMEfoNhDzA28kSXoTNAUOC2Abo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaXU3E1zn39cS+9Ryeaxep6jS\nVPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANrWmM6oly7Xdk73VBN2qDx6sb6DEecLJLcdbdESVCDRAiAmcaWf6nwe\naKqFQT9FDbwXi+wqtpQ0NZDr8oN6Tbn7CA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAZVv9twNt5J0SCz34IlzU3oWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmJjMDJkM2EtYjM5MS00ODExLWIxZWQtYWUwY2ZhODZiZTNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGE2ODllOWYtZDFhMi00ZjEwLTlhZDUtOGUwZGIxNzU5\nNjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELurhlClRRPVlUHlTgc4s4z+F\n4bCUjNrGXkUNBI3/XMaq3gzjVTSv33LpnW2Tp2gbBI7TkdIdlx6hyhWHUOHidKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzv5pizSCBSIZ54Oh8oeBxYtygLowHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAM+dBBy1\nTgvPU+8kPcbA5A6Q5SgTGHpuqqw5lETN68wiAiEAqUCMGaEfRt4q0L2OXQSVCF5j\n5MmohiD1JmOhUYwwEC0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7042", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7042` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAVCSuQUNLLnTfIvzcw+0oGpfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3YzFmNWIzLWVmYWYtNDQ5OS1hOGNiLTc4MDYwODVkMWQzNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJlOWY2NWEtNmFj\nOS00MjA4LTk4NWItOTBkYTJlNDZhZDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuZ582SpQZmuQZ7ZhpzmblADV4iiQp09ZimkFzVGmd7SKKpI/KmP31cCCYc8B\n1Du1qMTgnEBrJy9hYUn35oeTZKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU41caOPXsVYG0Hleq+SJLkZ0qwsswHwYDVR0j\nBBgwFoAUq2e9Np/AFM/bbX5rnxrAgR15oyUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCICM/fCz8ieu1W/K6JHOaGkHHlDX7HRnIgv8KgphNvYkmAiBp\nA+iQdfrvVVYTJiH/3Jl7ZsyLNQrS5rEM6fk7Bsjjqg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ8RHa8lOIlOU2eqiVGqiz6gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2MxZjViMy1lZmFmLTQ0OTktYThjYi03ODA2MDg1ZDFkMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNTOeAWbp4jqE5/s/C8Wj7KhyFzZka+EGSYV1pJMLBV/o8\nyUzVStEI1pCjN1JQe3NT4gL1WrvgDwE6OiWpl+s1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq2e9Np/AFM/bbX5rnxrAgR15\noyUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOd9hsoFSXZ812gJDG0HHkezm+t8PN1CzDrEQWI745O7AiBgUBq2aywO\nlBwyhU1A7LnvY3LOgMldJuKDtQry9kQgow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAXTkXO6oMrhXwntjszGUBrbwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJlOWY2NWEtNmFjOS00MjA4LTk4NWItOTBkYTJlNDZhZDYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGFjNGVjZTgtMTkxNS00OGQ1LTk1ZjctMDdlZWM4MTVl\nMjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmuSoa8IyU/ROTJofrUE47n9P\nAqF5fcOD3+uEGAeLpXa9c/9pafrYMUYKNxWjFtwHNp8PfEovBJ6h2PkkqHA9CKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU41caOPXsVYG0Hleq+SJLkZ0qwsswHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgPBK+eCO5\nHI8Nt4SyLUrnM8K8mlO9W404cGlDwU+lHXkCIQCc/c3oXnGCe3kcfeh8Oq6XaGhH\nCPXFgpSVIuSSJbVOcg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7043", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7043` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAeBntK5yWWypGtXyfqEdpkTjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3NTg0MWM2LWY2ZjktNDE0NS1iOWRlLWE5YTViMDBkMGI0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg4OGE1OTktNjVk\nMi00NDdmLThhMWMtZWRhOTU4ODcyMTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEy7nv9t2JenP6HSswwOeKz+ojd6ysjsmzF6bZ1SVwTInTBXNcWhzFlwaGQ6l\nBa5/Ly9EaeYaQ7QMawSguy5xkaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwJjeenBhCuyb8+l1aQVLecJi9rAwHwYDVR0j\nBBgwFoAUV3Q2KDzuASVEj5TLgVMRuGtMYyYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDkAiBLv6ihrsT92YvUpVce4z6ljvLV\nMLerUbpvw9kOAQIgWJRf7S9SlIqZyV7V4lOGJAVBxc+9T6jDKp139KQQokQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW53Vc2FT+K9e9AUZ9ibYqpBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzU4NDFjNi1mNmY5LTQxNDUtYjlkZS1hOWE1YjAwZDBiNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdeSZMmH/8z6kpsaOhCqOAPlENgUF160Ihug1nkE2ZdUs3\nG5BcJPav93LMTnindKnVwGkrf9UsSq3jVGjHzST0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV3Q2KDzuASVEj5TLgVMRuGtM\nYyYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMHnEC+nEY0+VR9Z+RB4e9Obn239nq58DysNd46shyc3AiEAkBIWrPZU\npOn7cHzY9lW8KlOTirA6b6AOcasb/Xrw0ec=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdJ4PNSeXMBTSFHbbJQiEF2AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg4OGE1OTktNjVkMi00NDdmLThhMWMtZWRhOTU4ODcyMTI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODJlMzgxYjUtZjg1Yy00MzYwLWI2MjktZDRjYjIzYWE1\nYWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHxlFMxErF/Wb0Y+YSx+qrsSA\nAlJIdYaPqxcOTvon65ci7/wJI6xFCt34cGg++et0iZGwP/UWk9FtxPqCMPf02qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwJjeenBhCuyb8+l1aQVLecJi9rAwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhALZex7mb\nKZlFDOr0v1g40+5bXLLb5UvhbL5wFnFGLTDuAiAT+Xo9g2nPdeJAsJizFYapDrFJ\nOn9BsgJ/8FFjGAeADA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7044", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7044` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAVBsHXgD8J1flT/27ha0pv31MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5YmE4ZDI3LWZmOTYtNGM4NC05ZDdhLWQ2NmJmZjdjMTAyODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUxN2UxYjAtNzU3\nMS00NjVmLTljMGYtMThhMTk5OWE2MmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXH87cfWOCvQdg0KENoTnFT0xn+WsL//O+25Gfdl9b7rUH2swQwcgsxQlk0QM\nc7nCNuOVuqRB10Ua/RseNxj/hKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXX6RSxT4rRdgrmobJuRqfF+CmUMwHwYDVR0j\nBBgwFoAUG5wIYg/+zxHATtMZkyZBRzqIhdAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGbeMQ92biSM+2Z6vfJal+t1rTqHwiEq\nNuNJLPB+Yt4lAiEA6ZwrmnOi1evduNfz5G1MqyAaXUJP2w0GKHK72HmP4no=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAToARZPb0S056msy1M7ddmi3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWJhOGQyNy1mZjk2LTRjODQtOWQ3YS1kNjZiZmY3YzEwMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCfidev0tfpapvkaEWaP5BNeABxWY6nisZno124Rv07Fv9\n77e9FGY1nCxo7avBv+uvkuT+X0qMmTeQpaDzDVguo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG5wIYg/+zxHATtMZkyZBRzqI\nhdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDOC8vCP65pP1IghrNYDSsSLXCpS5hWk2okstU/5uPp4CIQClq9v7MX/C\n6U7X8oiHvSSmd2UPIvxhGCKKdbHGKOQj7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAdUdYLXDTTfECaVE9FHVX3NgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUxN2UxYjAtNzU3MS00NjVmLTljMGYtMThhMTk5OWE2MmE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmNmZGQzODAtNDZjZS00OTg3LTkzMWEtM2E3YzYxNjYx\nNDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEf56tS2QR+Z2nooIvZ54sEgox\n+0immqnbXnTYc9vYTt9iS7LWyEsiUuTdLcQ/6uYox/b1FPiBcYHnk0ylCXqcGqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXX6RSxT4rRdgrmobJuRqfF+CmUMwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAPui1ufA\nV1Hr5uUl5J6sBzZ7e9nNluPMGgQ8v0jOzw63AiBP0VVSLXMUplmbYCzPuxFOWhGZ\nHkIhspngJNm+qllprw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7045", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7045` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYtPtIYYOunGQbUaTaNKl3h3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmODk0NmVkLTNkYTQtNDFiMy05YTNiLTcwNTU5MTU2YzJmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM3MWE5OTgtNmIz\nYS00ZjAzLTgwMDMtNzI5NDg1NTFlYTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwAy7vWe79bP2igPt550AoOWI0OosY/pdgbbeXfnF9tR+ICTcAmzQp58f8Yyl\nuIv13TfSNtlTbOM8APX8lvTow6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEho/fl8cvTTRHQqVoNV6ZDFAhrUwHwYDVR0j\nBBgwFoAUjglXffpQOjGkSBmqn5LjbeRUmfAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCjyta6Da0f\n2dD+St54OTWngHThlCmYSvD9+Goqt5hMrgIhAMFzAyrOO2Z9ZU8uo7naq6lKinz/\ncLO2AMyGNCYDPaCO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUgZKLvw5A2MrUiC6yn1WkPhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjg5NDZlZC0zZGE0LTQxYjMtOWEzYi03MDU1OTE1NmMyZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdLnZ7bVLhFeEn+gzbrLFgfnvTTTn+GSSDUYL+jD5o0ShE\nr2u7avFRC+yUCVRRjch7HbqZzHRnPwq0XtjWJ4qTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjglXffpQOjGkSBmqn5LjbeRU\nmfAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbBZXp+dHll+mYZyOAhTJDdIfwSWh9kG8dDC3wSJbKwsCIQDF5B0wuxN3\nK7PYGiufiaClAoNHzzq3L4WBdGQJjKREkA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAZhsEVxMJMif7ajnCvxjqTKvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM3MWE5OTgtNmIzYS00ZjAzLTgwMDMtNzI5NDg1NTFlYTcwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjllNjMzZDYtYjkyNC00YWY0LTk3MjgtNTc2ZDMwODZi\nYmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENyiawFjwt+IGWgCihezcUi6p\nhn7FBHMqo/HPMhcalm5rSJWICLQh3Jk1ThkHbawKEPQuy/mdJuH1X3oY/8oDpKN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEho/fl8cvTTRHQqVoNV6ZDFAhrUwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgGFcUZFYd\n5hHg6c7G4jlWLVqnN8x7mR76DMJFxuMQ5cECIQCkOIt+dMbnS71Pn6Cyjg/Qh7M4\n+Q/NTy7qsnu5kYMQIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7046", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7046` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAdq8KhBfvxqnlrM7NCIH4vesMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiMjA0YWMzLWE3ODgtNDQ2Ni1iZDc5LTFjYThkZjI4NDk5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NhN2E5MDktMmFi\nNS00MmI5LWFkYmEtYjIyNDA0YjU5Y2UyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf+rOFPcKHP0QMTj2/9U8KaTltzlk88M+7eFScYt6t3hsYA3iGN7Yxk59Runs\nPtAddhb2Dz2f6XQ5CjLGB/SiSaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSu1JsUGcRwlpimrb0gfvyHQTFZkwHwYDVR0j\nBBgwFoAUWtlPd28/yvuavRq1khNV2/FAGL8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgMuTNm1qJLF8DHCz6N5qymmp+h+ha5LqWjx4Dxe1nnmwCIAusxcgqnNGY\nuobKTmtFOrFGd2EPs9Pi6r3a3eBt6fYO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQcYcBe6Yw8YVURRAAEcMNWgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjIwNGFjMy1hNzg4LTQ0NjYtYmQ3OS0xY2E4ZGYyODQ5OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYy1VkrU52FxgJO+G0lhfTxxiAjQuYkPkTK4OOqj6EK52E\nPxszPZQw6cNlBj4jXTPoAOmbhnBr+Rz0bYbEn3qZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWtlPd28/yvuavRq1khNV2/FA\nGL8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOHu/nFuX0TvLfdUUEnQtARJWC0R/VTZxsKEnkvdNql+AiAvHLTSo7WI\nRaZ94ixMk6nM+W1R8YZ7QWo5Fd66imjEeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISARKMrWnxpcuhaJcLxWAsUWDBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NhN2E5MDktMmFiNS00MmI5LWFkYmEtYjIyNDA0YjU5Y2UyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTE4ZmY3NjctNDM1Yi00YzRjLWIxOTUtZjNkZmNhMDNi\nOWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER14IRd2QEpSUey0hVXpmySkS\nkgS8PhZC1q8cCCe+j0L1n4PQSzmApC6NlfEOhJTbhJEv6dBq/7bWe2L/cEKL9aN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSu1JsUGcRwlpimrb0gfvyHQTFZkwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAKqPn6X6\n5CZzs0FEPiVva1a7ViKHb26nuDgSKwt1MJ1KAiEAkeHVrSHQqBjPP/svQOS5mays\n1dup7IK0WPt2OtobDgM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7047", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7047` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAdi2SVByic8unt8xjyEgYa9LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0OGY4OTJiLTZiYmMtNGYwMy1iNjhlLTBmMGQ4ODdhNDYyNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdkMzE5YWUtYzA2\nYi00NGQ4LWI1MGQtMDVkZTYxMWU2YTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaGU36x4pFHRspdDrySwz8EGL0jN5MOB2Jz3Aqo4sZo+XTVlfroU0Oir2TQ+R\n5zp0IZ/sdiP5qbcXkinBIVtheaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNQYPwgNluBmd+7/MZluREXfPddYwHwYDVR0j\nBBgwFoAUDzXLsvRFH5N3oEJ5W13o7tdjW0gwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAIH2j8c3xZcf7qRheSPgPXJYG2IETb36xKtlFcKU7LtVAiBhTHwG1jHv\nOWxKu33sxdWUBcfL91FZZU4EfvIIxDM9jA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbV4YVxywYlVAhU3XdJGudBRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDhmODkyYi02YmJjLTRmMDMtYjY4ZS0wZjBkODg3YTQ2MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbRqwaC5Ns0lyCCo2V59nvU0cQrPYgwaML27qY9WFu3Sdp\nensx2OnfshJC8QEbl6A8ZT7trKqMDE1OglIGDEDBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDzXLsvRFH5N3oEJ5W13o7tdj\nW0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdlKqnJLwliomehxkOwforxTLY+ZYVjZQGLf+nOlv588CIQCGKXH+i/qC\nCsO3WsHeV425QzR2WdYwrEUOwa8EnpQBMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAU4rrA4VP2BHfbiJZJI77v9FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdkMzE5YWUtYzA2Yi00NGQ4LWI1MGQtMDVkZTYxMWU2YTNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzhkZjVhN2UtZGQwYy00ZWJiLWE3N2EtNjliZGZlOTVm\nZDFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6CWTZ9ywevmR1xuT17ucXawD\nQvgr6pCv257Kz85sDTBELgEMNXDZbsCpm0Vlr0TpkUU2GCR7BIF+Yj2qsxJmVaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNQYPwgNluBmd+7/MZluREXfPddYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgQkK6Fq7n\nvJe/X89PO+62wyqZ2uDqJfSWQAOZRBiSX5oCIQCoRCa8ztcpNna3N6Sm4FLu8+gU\nl5Yeo1OQle1oFdWjWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7048", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7048` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUuuY9FIcHnOl2z7mlJodEr0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlMDc2YjZiLWJiM2QtNDUxYi04YjJlLTMyMGE0ZTI0OGU4YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZmZjQ4OWQtNzNj\nNS00MjQwLThkZDYtMTgyOGJmM2JhMDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr3FQDJhUYWGT+yKSuDGiDNuHeIfKTvhLPsDG78shVCJh2Wj6GN4UIbbAOxyw\nW82WFhqix1+EaanmPdKWdCe0FaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxum6iGvQqC9h1xsdw8NaAaXG2/gwHwYDVR0j\nBBgwFoAUG8vbOjleqL6eNQHELRiDpCasxS4wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCOJnMYzNI6Hm0BQNwFaTwcTnARErqX6rQ2PkJ+5TZwXQIgbPr8RkDd\n/9+ZRa0tMeu1uutseWak6/V8b1Jqy1PPj2E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARoE8NQS/BDcbmAL+EbW7UKPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTA3NmI2Yi1iYjNkLTQ1MWItOGIyZS0zMjBhNGUyNDhlOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqFzqpcuTAkymvBqmnQXwM1M6sfnCM8JKbCVk0CYl7AoR/\nn6+U+Q/3kw8OFf/shtZ2YPCaAtj/eHao4ZjOZZQAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG8vbOjleqL6eNQHELRiDpCas\nxS4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIfy6c8VpkVRd46sF0LQGoMCyphWMKU9G2Cx8CiHGpdYCIDHXxtMrt3El\nHb45FdSOQFciFkfxzSY+1WQqcTlMHdBj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAb+gAwIBAgISAWKohwbd6hnAEbCwAkQYvZNWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZmZjQ4OWQtNzNjNS00MjQwLThkZDYtMTgyOGJmM2JhMDY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmZjZjk0MzYtMTlmYi00NzVhLTljYzktMWQ5NGUwNDU1\nMDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENLSUv28APiYPh9LF3UtgIEiK\ngsXoe7KwJeRmY4C6Abl9/f2KQW/+bxuVgrWA6oP6DyMRhYNdXQJ0MkW7wk3MWaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxum6iGvQqC9h1xsdw8NaAaXG2/gwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSQAwRgIhAPI0eGeu\n1i1t0+qJVD831seAvb8xhSRlp2kv5grPtPxvAiEAmTVKMLnVceQq3b/YdzHTBO11\nU6OhL7iXn0j4SnZlngY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7049", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7049` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAe8Ry9m8iWGUqbOug1uuaizFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjZTAzYmI5LTU0YTEtNDNkNi05MDQwLWQ1OWE0ZDdkOWYwOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQ0NWYyMzEtMDM2\nYi00MWZlLTlkN2QtYTlkYTgzMWJhMjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEokulMfdLG3GaerQzgXzTYGxjb1p91apZI6/shDeW7GX2j3pKbVtkOIuVdXJe\n+TuK5pgebqmlwvHxJtoHrFq1S6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULqKIUPUr5ZLC6HHypRVjGIGW0PIwHwYDVR0j\nBBgwFoAUpczVhhhuuTj3wqEoYLCdohdQQbowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCLmrRGCOTeIqw2LvHHaMOJlfaZqhU9mPrdKoPh\nwOMauAIgR8fdJGZA9bDp0tg0KvnTR4s2PJZ3kA5fJRDpU+DHTho=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXLU89U0wJhwVMrby688uKBQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2UwM2JiOS01NGExLTQzZDYtOTA0MC1kNTlhNGQ3ZDlmMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0w/SGvhb6q4vj4+AcuY7i74nSiaTVHSmfF+uSZtUY89/F\nDYsllBXzj/ZSzxRWzr/QkR/CM/Hw/td01Sr+eVQzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpczVhhhuuTj3wqEoYLCdohdQ\nQbowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ/azq7TUpGTut8OA+Kd1HWeq+0CyXCLbxXmhW8CeMLsCIEogk3PTZFvJ\nAPQiaBRadOkyQ34w5/Xfot0yrfTg8RMb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAbmkz+TD2bSPKUJ67sBYpx0jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQ0NWYyMzEtMDM2Yi00MWZlLTlkN2QtYTlkYTgzMWJhMjljMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzRhN2QyZGItZjE4NC00NzYwLWI3OTMtYTk1MjcyOTIw\nMjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL8Ox7dx56APc7zw3dlXT4NQx\ndRb+iE6VBNbwtNwPucQrz0zcvqrOq6SOWWtefokRJ0BKtt8jBNaleoPnFZfzp6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULqKIUPUr5ZLC6HHypRVjGIGW0PIwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIhAMTfPEz2\nDZIWAYuhMQgJLZEjluAbEueKVOgtXGLK8h3pAiAGMJmasEt8Bcy0+DHToPDDFIgP\ny1sc8QF3NCxbJqUZqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7050", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7050` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAQTq1kG4Z/XJWG03AVVWN9coMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhN2RmYTIxLTU3MmEtNGM4ZS1hYTQwLWUwMDc1NTIwZDk3MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUyNTcxNjItZjBk\nYy00ZjNmLTg2ZjMtNzBlYjQ5MWM2YmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVVlaAlIu3TZhD69sMUoOu0DoNRcB8rggRLJA8bLpdM5KtUhJXEIE9WbRNAAD\nFeKeFdgBw159W7tFu82pEcrmtaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNh6lan4vknnseD2upGV/jiapAaYwHwYDVR0j\nBBgwFoAUDqjFEbCFMBys7Uy88kzexhpJkZUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICGbB4ESbPj37Tni/c41aQUhCYGOXnHfZ4Px7sfV\nmfsCAiA44HUwiwwa15+iKjUnj6rc/cP/CI4CcMeTuuaULl3XHA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYMstbeALC4ZnHatNuaIkYcYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTdkZmEyMS01NzJhLTRjOGUtYWE0MC1lMDA3NTUyMGQ5NzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkSWlKanocIgbEDwxxy0gF33DeHsNW35vGsyrdmQ19dZiy\n1hXepktFfEeK9mqbJLQdvuwqdtsiBfZA9Z8rjp/Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDqjFEbCFMBys7Uy88kzexhpJ\nkZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIH+1j3pz7VMwgJp4EQDNN60T9VzGse89RMVr6zdFjLVAiApvVkzuODN\n8xrK24SrCdfth0+oMdgg+PWWdCnTCOPT9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAS+P47f4tlanwuBYFPWGzdi6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUyNTcxNjItZjBkYy00ZjNmLTg2ZjMtNzBlYjQ5MWM2YmY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzk2YTRmZjYtODFkOC00MWY3LTlkMTMtMTE5OWE2NTIy\nYjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo7cAk/lj9l/PViJh94MwuqaD\nyINWB3KA5PHr7adwYts6ZF3uoLDY1tLY6Bo+I1IBTxrm7senl4TdRDDEwV8eh6N3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNh6lan4vknnseD2upGV/jiapAaYwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgEOmxx4lO\n3atfPI55K1V/rxobVEBLDzVW3mKpDoti0PwCIQDBzjUI3KReImLB/ohj6HtB3P9b\nNJ29OfL5n24ad5CTHg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7051", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7051` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAQH8X1eXpgUz3WKeYC/gGQC5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmZWQ4NDAxLWMwYTctNDZhOS05MWY0LWQ0OTRmNjIyY2FmNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2QyNzQ4NjktNWY4\nNy00Yjk1LTgyMzctM2U4MzcyMTY1YzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESjyVcOkSDk8uXGIbrx5So3t/IaSLEJRlegWh2h4ra9Wvt2A0ZhKsnVcOk2pE\n5K3RAPz391drTzl5yb2glQMtwqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzwAOJzx/bMXJRsE98ZvdSIXpEi4wHwYDVR0j\nBBgwFoAUvJbq7J1Ku0dicU9q1wa8yY/5JkIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIHcSgtVGpav1QAlgoQJZN28qbrSwWVn8N9rAuLPwJcUzAiEA\n8hEeiTThbu8pzKIwpMBLtmCpyMUq08CQlyw9ZLnKhtM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWq8EHu+WRxzIkaMoKzTDGzgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmVkODQwMS1jMGE3LTQ2YTktOTFmNC1kNDk0ZjYyMmNhZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlVB8BYpGrlS6bPdpTjDd3khqGsLa7ij1Tpdi+uNs9HsJ3\nGHM2jZXH2gqez69HUI/hDCP4ylCXYynmixNV4y1Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvJbq7J1Ku0dicU9q1wa8yY/5\nJkIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRWUPlmVe6oMBzqcUdSe6ZgIGJcpBJ8Rw7n49OzIaqw0CIQCEpIxiYyZT\nmlv4UTHktEAYOzXqx0ABPBt/tl6FeYtHbQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAcjFGsynF/1j0SdbDMqa/mZNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2QyNzQ4NjktNWY4Ny00Yjk1LTgyMzctM2U4MzcyMTY1YzE5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTA4ODQwYTAtM2I3ZS00NDlkLTk0NzEtNjcwOGRiYzkz\nZjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELE4MMt4qgSdR7URuRlzAUz+P\nyxsUnLIg+3MoxgUwEEPgNIQCURIVO4wzD3nbxiURwdCZeJjBWp0GA/wO+l7y/qN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzwAOJzx/bMXJRsE98ZvdSIXpEi4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgVYX5DNij\noCwwmt0u89TvXvUwp0yptntx8P9U18sc1W0CIQDMYzXpncYHmBngtsh/rkfH7+SL\nxWstz5weXZR5e5gqnA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7052", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7052` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISASlKEb+b22inHKhpfpTWYU6tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkNWIxZjlmLTllMDAtNDgwNy1iYWFjLTI5ODM3ZmI4NDhkZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUwZDYwZjYtMWM4\nYi00ZTU4LWE2ZTctZDhlMjIzYzM0OWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExInJZK47lrsYHe28hWiSE1ESjN5wfwxjxrJRsYear4YT13u5gn1YAnsWlXHL\nqKlMDrkc5WPXFd7VgyNfYX6KZaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC6UvYaAZx/rqBX17WagmiXyqbR4wHwYDVR0j\nBBgwFoAUjVF8f03bN6xjhr8V2/aJ4WQQQ+QwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCDAig6R82RIw7Q1sbMtw8PKn4K+Mm+\nlsgGpz+HfXxLFQIhAMtguKsILwjeX/xi0fR3dVd1c3Nfpdh43NfURFO1/0Ui\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaq8jKNn4NxPzgw/qf8jFWjUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDViMWY5Zi05ZTAwLTQ4MDctYmFhYy0yOTgzN2ZiODQ4ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIIblMGGhVm8N3lysXiITEQrjjyZLR0yUkn9rLI+zo0Ocs\nDQlpoqkmwHjC6jaZNwEYgex/S9w3mxN3FAxjfPAto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjVF8f03bN6xjhr8V2/aJ4WQQ\nQ+QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDUFPvvDFcuvpmH61k1W3Xciu/FeOy54uMLD0LQwJAakCIEHkx3oEBSfA\n9CsFJ+BI48KUN2S1Ie40fahgofN5s2Hd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAaWY8qckVYteePbSC/w6SuD5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUwZDYwZjYtMWM4Yi00ZTU4LWE2ZTctZDhlMjIzYzM0OWEwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjYwMWY0OWQtNjQzNS00NjcxLWEzNTMtZGEzYzhiNGE0\nN2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIVWTRfuYu0CTK1ONgLCpe5kH\n0ss8whxKKNGL97/lgXg6iP3fi/5goSCXNGmo4u7InlfW7v4jTpOAjKFQpTQxDaN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC6UvYaAZx/rqBX17WagmiXyqbR4wHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgTBfLNCiM\nxfA/m7BGOpzjLHSe2uwuIUsYdXoKdBuGlUwCIQDwlYJKInMMzUYpfeG2i9SQqqVE\nsHa5xabQGJ2FYfy0qQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7053", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7053` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASG8LXY+2uXSDkPxLdAWaSDMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzYjM3N2E5LTliNjctNDEyYS1hYmE5LTVkMzNmNWMwNDU4ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE0ODNhZWMtN2U3\nMy00NzM2LWEwZGYtYTY2M2I5OTcyZmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO1D8gCBUftTTeUkyNLXR8b5crL/5LxnjEgzN73+WBGzJaa7P2AbtgBqyQ1NT\nGAylwpSyaWH0JRv+73nEqefVgaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwBwRHXAPovqDOLA/wkrlypQxMxwwHwYDVR0j\nBBgwFoAUslGs2G1d7Kz46TxtuzH8Apf1QqMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDKpjzIZ/9PQLbmfRzgZus4BBNUyq+1p\nFg2dbSb8mv+qAiEA42B4J1MGo1qqemzRI544PfZwYGylP7eYtb71M9fPqXE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYGY6JxfEda8H/b623JQNJduMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2IzNzdhOS05YjY3LTQxMmEtYWJhOS01ZDMzZjVjMDQ1OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAZmPQzOU5AJpBV0svIcIrAjC08w9nTf6mPBJ+Y8ov5Fgr\n3ri+hf9Fjp33GP8Xr0vm3fXbqc9mjAebv76ZIGmIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUslGs2G1d7Kz46TxtuzH8Apf1\nQqMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQcH/t8GS3LPFl8xWr82TGTeInzO36k9Dvbg9vhYgOxsCIQDrLxelgzDe\nCY/CiCl+tvevq8E5UYpFOrGQd+O+Fi6wwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAb+gAwIBAgISAcKhBzNpgvAmGn0CI/yLeJKmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE0ODNhZWMtN2U3My00NzM2LWEwZGYtYTY2M2I5OTcyZmQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjIzMjE3ZDQtMzAyOS00NzlhLWEzMWQtYmE1ZGMwMDMw\nNTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUgTRIrSp0tHRaetAsrsBMjaB\neTVRxuMlA2KOn/NEBbtQpYBL5jX/2ItCNf2YbO/fpDSDGCVVp+0Tbd02bIthoqN3\nMHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwBwRHXAPovqDOLA/wkrlypQxMxwwHwYDVR0RBBgw\nFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZIzj0EAwIDSAAwRQIgVjRGqSpz\naKrgkoizLrK6HDn3URUe+FGKeWzeM+Neey8CIQDwYCnSdi5w2Vohri10+L2TmDDN\nMSLRx2Gqu6n94h3cKQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7054", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7054` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAcuZFdv0hH/3Ip2YLAFE+YN0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhZTM5NTE0LWQ5NTItNDMwNy1hZmExLTliYTU1NDgxOGRkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGVkMWE1YTItODY0\nOC00YTRmLTlhMjQtZGJkYWFiMWFhMGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFAymslOVrQan8sAJ6oZQn6OTMtVn5yFDiH+o9bQkVS6l01gnf+rT8dJD4L/L\no/cgt5F+n5dGHCTGYd8hEFnQAqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNtCss5nw/RPPgy5xdGw/gsKuKEeMB8GA1UdIwQY\nMBaAFJiXiFAenwfIZrdTc6ewPF054pPhMAoGCCqGSM49BAMCA0kAMEYCIQD9OsSw\ntVfRvUgNJ0m0Q1c44hNXgAyoTRGD7Q0cDHMAXwIhAI8XBY7xQq8cy1YoQzyyKrTk\n3FXDFnKdIll1NKT+TGpc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS28exYjrFgaRzoZApChIk+tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWUzOTUxNC1kOTUyLTQzMDctYWZhMS05YmE1NTQ4MThkZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqkBrLzROUxxhjYed59V4lV62fH0mIp0IY62o3Vwn4kr36\nvt8J+hKB7Tc8kRupvHF/qhj7CpRe8rJTu07ZNMdoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmJeIUB6fB8hmt1Nzp7A8XTni\nk+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgI6GuxNMLt/aN+m18FeGUtTf65O+IeTvnl8PKgtaKOHICIQCQzxNoBlMX\nQOEopHtbEswrglIhf+6ki+qkfFQmX/O/Ag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYnjfN1xTnyJ2O9EDjV9Lo4QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGVkMWE1YTItODY0OC00YTRmLTlhMjQtZGJkYWFiMWFhMGU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGYzYWJlYTktMmRmMC00MzUyLThmYjAtNWUzZDVlNDYy\nNDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL0jbNInh43aHZRgurper8CDv\nANKNYKNL3aaAN7mQ74OpdIGGrOi/qUqSlhLHml0Y6LKG6N/dm8xkjVj/TWtZFaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU20KyzmfD9E8+DLnF0bD+Cwq4oR4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG33bTU8bkZwq1dL\noHRkOGO+2yrJsWy6Dg7QIQyb2KGFAiEAtlzQI6c8K+xy2fIQiRWZKBIUWLvzE+2I\nWscrtRZrcJM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7055", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7055` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAcEjkG3MdQvM4HKkkIfXmwdsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMTY3NWI1LWQxYTYtNDA2OC05Mjg0LTQ3Nzk5ZDBjMTc4ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBiYzgxZjMtYjZm\nNy00M2FhLTg5NGItOTBmODcwY2U2YTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU/2ypf0B9jAvC8/n3l8Skrr+aE+U8raHCd1ai16bserrfwRtg0UEFrKaBWku\n2Q2ahRWRzt7tHZUnY+q90fUSd6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMJ4VPjYDBNL+eLLaxWavbnKf2SpMB8GA1UdIwQY\nMBaAFPAPmwcuoC/GTc0wtv1eVhW0mpYEMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBYCg2ml7TJ2/k2lxtb5UYzeFgvYc0zL0V2\n9cKhz97MhgIgLue4ZrhcjxLp+7Z8j4Ak4Rvfil134DEau5YpmSUc1fI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQcV/l0HGG2/LG8NJE+14L46MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTE2NzViNS1kMWE2LTQwNjgtOTI4NC00Nzc5OWQwYzE3OGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/Al1SJrm1g++fOP0+4zF6Ws6RqeKfDV52xrxUeo6uwO09\nNVz946sYqHCqceOtAV5eORDGI3FsaimxjeevIkLco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8A+bBy6gL8ZNzTC2/V5WFbSa\nlgQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOu9jgZayyvZdEyMCc4+74Va/iP5YMMBwTUSkO081pXUAiEA2edEGrFX\nARusU7iUL1N+LesC381fOkfY17UXVB1d+pI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQ59n76GFvBOfdfbvYafbd9CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBiYzgxZjMtYjZmNy00M2FhLTg5NGItOTBmODcwY2U2YTg0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGY5OWM5MzYtYmRlZC00YmVkLTliNGQtMTc3YmE5Nzc2\nYTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEz0dGXZpbGHfXCasQPeEzrFZ2\nASdjgFSOTYAcyo9szowDv2TGLikq5iZ6p5HBCx5PoIINxn9Rtsta9FvzrIZm1KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwnhU+NgME0v54strFZq9ucp/ZKkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC64t/ncJ/LDnNH\npBI1Vzzu/osEbXHwBi1EPK3De+iD9AIgLScEHRPdkKkIDuhMom8Me35GaevaBt9Y\nJtn2GEdKlHg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7056", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7056` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXQeR/MppNs0G8XnbkdbCbvwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5NTdlMjI2LTZiMTEtNGZmMC04MDVmLTM2NjE1NGY5ZmIzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJhMzA3N2QtZTRk\nMC00NjIzLWEwY2ItNGRjZWZlMTUzZWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9z/wc6I5ZtFu62mMuEEQLFng4ZZgxFLlSR6KNrTLwrS9PraCFV9NOW5G66SS\nKfMaDJVRoTvSWX97gBRk3LdEV6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPotxY1wBDm4UsxHw/2RCSaIhBYiMB8GA1UdIwQY\nMBaAFDYGHXOLAN+bup4zHxZkVB2Z0UibMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEArcpQa/pxYClvw6q/cHGmOpkcw+RHcLhn\noNPYBLPgLIICIC4atBEPfRJp9LNfksmQB4mWajxym5bAcarA2P4CucyP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUQHFoOkpSqUZBmxCyy9/5n5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTU3ZTIyNi02YjExLTRmZjAtODA1Zi0zNjYxNTRmOWZiM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiyptpsuz4aWH0kEyt3be0tL4aKfDTBrsFnFwSXQW8GrKl\nzrVHkCB2pYU2JXoXR58JZhkmZxCiIoxDT7KRwJibo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNgYdc4sA35u6njMfFmRUHZnR\nSJswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKJ8JdI4sbRqTkx5yAU4UUgkZazcQXUGzEbC3G0SGyI3AiBJ39ie9YaW\npMIiJzXDx7VTqayPTHUXoiF8YjRC8jBbfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAZ6QjojsUleSbpDoHoc2v8gEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJhMzA3N2QtZTRkMC00NjIzLWEwY2ItNGRjZWZlMTUzZWJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWM1ODg2NjYtYjM5OS00ZDA2LWE0NmUtYTRmZTFmODQ1\nNzRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE82Uo3xplb0zKWDlIQM9kgL98\n3FJdZH/iW8FWVwBi0o9MYMHyWaDOi6x5fhvgjZ8DQUZd3p9jfaWR42HhHeKFGaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+i3FjXAEObhSzEfD/ZEJJoiEFiIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDz213nt2S4yOA+\nDW3qh9Kk0bcnu9rMxWsqLlYU76Te9gIhAIQyUOokOspdMsSk+h05dhf+fouZSXkR\nDtvy0LOm5ZUy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7057", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7057` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISATkpghWlxPAIChE2KJ/V2fcUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ZDgwODA0LTZiNDQtNDY1Ni05ZDRiLTA1NTkxMjg4NDQ5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAwNTE0OGUtNjE0\nOS00ZTg0LTg3ZGItYTEzZjM2Y2Y4NTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFtPg/39ohGsKrSVyGkPjJbM3M/ZnGZkZUgIVCrDQOngK2hfpMXQ5T0DyeKmh\nDdXp6eGoNvynLVhDhGqR1AOVzKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQIMv2hUPDaLi/e7nF1JA8oI/NFtzAfBgNVHSME\nGDAWgBT5nyuhqEtU41I7ZDOxz/PZoj378TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDEQVgMzx8UWGLDEAkG75829/wRamC6\nk6XkyM/tOabSgwIhAJKxgzIZdyp21loE+lsg0IElJdrkbXMkwIHrAe0CPaAB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARsaAeiIWd5ewtkqwVgrMFsyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGQ4MDgwNC02YjQ0LTQ2NTYtOWQ0Yi0wNTU5MTI4ODQ0OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5Yxk0WyWDW0NIM0jmyf1pYqaOv2773Uhea64yhhSQVBjn\nTTobmOf5qhoUtFZ8MlwnQeAzQ3+hnDRgNmoQN+n8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Z8roahLVONSO2Qzsc/z2aI9\n+/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIREeyKXEbxXzGK81o+UeyqV7SpeSzPLiyEpnWzoyFMTAiEAsYm3vlbW\nZ7pNZTbMzFqYoNXxyNZ5VlcY+weXYZW6oKU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAcf/891mwyN7ikZv3yt6bGi2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAwNTE0OGUtNjE0OS00ZTg0LTg3ZGItYTEzZjM2Y2Y4NTJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTM1MTYxODEtYjJjMi00NjljLWFjYWUtYzA4ODQ1MjVh\nZTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/MoU92m0+JI5z4uS+7qDphtU\nk6WduSTHgjsI+VAMGIrqYkkEbdVhUFoiRoQLc2/1fjwaqsG/JWMOB19kfX8jVaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCDL9oVDw2i4v3u5xdSQPKCPzRbcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDGTUKWquQ8ePxB\nFkMMvxXfgtfO+RVlbnKLkOo9+0RrUgIgeDao5X+gXWoaB6fK4x9MU9KGbrDrte0M\nOg+HBQ5+Tt8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7058", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7058` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISARDUNNS9g9fK2/rtxENamaJnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyZTc4ZThlLWMwYjItNDhjMS1iMjM3LWZjMjdiZDQzYTc2NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDNiM2Y5MDAtZWRh\nYi00ODUyLWE5YmEtNTBhMmI5ZWNlODg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE03/2L3EE3Ec+2i1KwIN8DiqgUzohRitfcEWHZSbBYTBykPvJgY42dc44QvqK\nvNaqz99XNbZ+huk5Pk8kadxxhaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkU3GLrs5nKMeViBOhwOs4T1HT84wHwYDVR0j\nBBgwFoAU9mBp4VyzBJW3CEFMwWl/I2KINVIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAe+dxziR6ouX2E\nizf04Iw8X3XmvXy0tStIhbOk4LEMjQIgcvjeZVc9iXM7N6pGlFGB91LQzr0C4XcH\nLppCs6ArE8o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXNv1Vko1Yj/cYJGZ7U5OzqKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmU3OGU4ZS1jMGIyLTQ4YzEtYjIzNy1mYzI3YmQ0M2E3NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR416DkzH/cj1xP+LRqAJ//IclrKVTToQTKtZ+808mo+RcG\n9sOEGMYMkRQGEqJxvVBjYzDhrPKcHU7s/TLunYoCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9mBp4VyzBJW3CEFMwWl/I2KI\nNVIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKrrdrTGtaCadSkYk4NuoDO6m3mfag6BIgbCOk7WP/t+AiBp1rExadPK\n7vawfkVlaYybg5L5pv25/oZYxU+X+WRv7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAWsjUggN+f7fFsgqnSKWs6bvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDNiM2Y5MDAtZWRhYi00ODUyLWE5YmEtNTBhMmI5ZWNlODg5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDk5NmNmZWYtMThjZS00YTliLThiYzEtZjI0ZmFjYzIx\nZTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2BOf1uiI/QJ2W+EHXsEJb5x/\nr1OADjI1GGQbOxbfF/OQR4IfyDYYBpHy9Ywu47wTVo4pi4WE2CCP6rKFquvJqqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkU3GLrs5nKMeViBOhwOs4T1HT84wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHAGJ04O7x0Uwtwt\nPjv62IQmrsJC+WKu/d4TUdo7UA2NAiBZePqR94ctSy3uLJuoMJ1ecLEMWlFNq9Nv\nGCky09Sjow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7059", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7059` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAfz/jsDR9vPnthWYTedefS8IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMWE5NWUyLTc4ZTMtNDkxYi04YzM0LWY1ZmViMDUyZjk3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTRlMjFkZjEtNjIz\nZC00NDdjLTgzM2QtZGVkZWM1ZmZjNGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsG4zdpdzxjDnEbwLkGQefJkfYlkkQ4VStikQFkAmb99IDWy3bMgBnYkP2rbI\ng+v0Y9SxG0UZ/cJI1FEeXDa2VqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT6rlUKrjqvEPEcYA6S3TClAPu/QwHwYDVR0j\nBBgwFoAUJir03qI9TYs1fJk35M7fc3e1xbEwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA+ZGCGwZ9WGDrM\nppuU36AbQlyHs94bDdD1J1WRZoEoxwIgUAzD42unpuI9cDAnTgIYmmOitnPmf2Bj\nutUZmA9437E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZNP1LiWsg4wGlWsPL/GcIuDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDFhOTVlMi03OGUzLTQ5MWItOGMzNC1mNWZlYjA1MmY5NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg16wto1KUjLWsAYsbF4WX7vdkFGpjY2atZU492fgkV0pe\nHFXvPpP+3WuIr216iI3ZpScfp1Pr0bL9R9u5dBnAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJir03qI9TYs1fJk35M7fc3e1\nxbEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRbGkaqi0EKzEwZwIq7zdu9tvekdA7uO9PEyi3Nvt8rgCIQDxFIX1S7tQ\nYGNuOwA6Ws1bnTAgdZBRBXTJKB6dBphUmw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAfFsJJONYkwUcs5WJk6pBBpiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTRlMjFkZjEtNjIzZC00NDdjLTgzM2QtZGVkZWM1ZmZjNGNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjllMmRmODEtN2U1Yi00OThjLTlkZWQtNjI3MWNhNjRi\nZDQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECf9Wixr7JWLz+ybDdQXk1Bb5\ncFz1oD5h3q18cXVjsg4Bg+utbHnG+hfeom3YnUAA3Nr5Gl8ZdvnW6/sa6V4Vx6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT6rlUKrjqvEPEcYA6S3TClAPu/QwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICulRnQeA7ZMvl06\nDCQXsq4hTjKPwSW/KUB00cAXhCw3AiBrS0eXKk3dTUF0Ank5h4UhOEjW7vbjFqul\nkVDHbkhhBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7060", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7060` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAS+VCHWYekW+Thyyr8YrNNbnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2ZDA3MDFjLWFkMDktNGEzNy05Yjg0LWYxNjQ1ZDFiYTY2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjEwOTlkYWEtNzBl\nZC00MjYyLThiY2YtZjdkYzcyMDgxM2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXnz6TB6WPjF0gB2dIQyV1y+vHp33nwIBJxC+QgIZRGMOd94e8HObvLJTkt3B\n0VdGB2u9GG62GSZT+piAKPu6mKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvRj00QoXIMj9KGgI+dl7+HrMMLEwHwYDVR0j\nBBgwFoAU1WhKgJOTSRjD79NO2qmTnefoP/gwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAy8g9cpZpVyFKNz+rnp0Z\nzadbAnXRhtbrmdhvC8IOsWUCIGqE/ZNwYczLlH4lejvZtE5cgcBBE6IPUrnRZ6Ko\nSwnB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcRnew50fhCjtGYqD8NeSUQyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmQwNzAxYy1hZDA5LTRhMzctOWI4NC1mMTY0NWQxYmE2NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmVgAL4z7SymI8Z8QYoV53mQszWt4SLdKrW+LUHGtC4Tof\nqFMy9aX57iKhxDj+9gjHbF4JXAPgsLnx3o0cxfB2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1WhKgJOTSRjD79NO2qmTnefo\nP/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM9heOLitZD0B0Uc0gVTV3g0IKyAApmpXtsiW8ozIW3SAiEAu61uM9yF\nEZRseuuU3DdSHGR+Rx9byJVdIAVokMBu5Mc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfeu2p9WoKorJbacauaqd4+QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjEwOTlkYWEtNzBlZC00MjYyLThiY2YtZjdkYzcyMDgxM2QyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTNhMTc5MWUtYjgzZS00ZmRiLWI0YmEtYTI3NDc2YTMw\nMjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+rz4h2wlrhju097Fu4mbAUF2\n4D58hgiszgByEHIv0W4jaB/9o4fu5eqgo4m5qRoY7bWiFpiTlVpAkJVn+RfRG6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvRj00QoXIMj9KGgI+dl7+HrMMLEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHMbnrI3Q2O+CWgR\nOIRev+zoSR5/1ccSdIwT/fa1jE56AiEAofj9Fj+O1+KFAg+mvjBLtTGGWMURAUPa\nJsY2ZXHq6bM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7061", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7061` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAWhDvnAcxug5Rq7shQEfoU10MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2MDc0ZjU0LWYwOTQtNDVlNy1iMGEwLWIyMTNkMjJlMDIwMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzkwYmM0MDItMjVk\nMS00MDUxLTlhNjMtYTk3NzdlMzU2ODQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyYDVLaD33MbL4GhCtM9hoDWa01COdlPLtDx1ABX05m3EOR/+/mtJHr988DYL\nBy75HBycJNlezkUyFcceQZ78uqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbU+jmW4Ss7FvDBBxkpnuDeul0ukwHwYDVR0j\nBBgwFoAUvnGw7AOJeq8Udqp8d8t45B8woikwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA92Mb\nARXS+4O8XTbaDgP+SCxYMBWyZ6iHO8fSc/LGvj0CIQD0Yguin1Y+HNuu0ZkR01rU\nC4TECldZTAHRujBegO3Ekw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeDFsd79qLVKH3Jq9WG7nWxXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjA3NGY1NC1mMDk0LTQ1ZTctYjBhMC1iMjEzZDIyZTAyMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9V9O6uVrYsLnCgSeYrJ2TEKqw1g8cY6PV4MMRYgi1MPSZ\nQDz1fM/oEQ9c6+nTd4dGrz9xOsIc0oK6Wjcnqytbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvnGw7AOJeq8Udqp8d8t45B8w\noikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ9K4DZQAMgpoJPq2rAO1a3Zdj09cBrQ8j1KT6O9OtCgAiBdI7Up7gVX\ndsombHxswgOhvOIoy7B7HR6gx7szceafOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASp2J6dLKR3iQBi6HgXx8QefMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzkwYmM0MDItMjVkMS00MDUxLTlhNjMtYTk3NzdlMzU2ODQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWM3OThlODAtZDlmMi00NTU2LWIzNjctMmNmNWMwMWVk\nZjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6O1coyjI1ixiKCzUwj+MP2ka\nPOnLaQoR5OqvJLK7E88iglsb81LG8i+FDuzzZAdPmYyYdyoT84RX+slnhodCIKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbU+jmW4Ss7FvDBBxkpnuDeul0ukwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCqOEY3dnBI813E\n6X4pIWe3B2LIKfc1YiekpGnCJtmB1gIgFm1ugi9ldJeKUcBknizlRNqH2E1dn+CG\nYws9OE+heRg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7062", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7062` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAZyIvFRZ+bVCiFU5+qV08ecdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MmNhZTU0LTA4MTctNGI2Yy1iMDI4LTk1ODk0MTg0Y2FmODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM5M2NmNWItNzZl\nNS00MTFjLWFkZTMtZTI5M2M0Njc5YzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETG+x8KyDF+0ja0QIG7h0Cjiv7hAT3nhxFoOKsY4+gEUhGvkFKVmwTZNqNSAW\nFTSi/H2AuMA5s6cnyfdFekTfoaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhkavJEZrdVqEm50qs7rz/D3uH+YwHwYDVR0j\nBBgwFoAUOUYFYqWWi4s5BdSgjUPNBzJzTuEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAOj1ft\nIBFEuQQa8hHenAClG2KXaODjjY/TnQyZoC1oXwIhAKDwlYSsL3ackwNiVmeqhFgQ\no+5Drdxlg8siSYGFIuzK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUq6BCNHlKwwDbDtjFV6HbK6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjJjYWU1NC0wODE3LTRiNmMtYjAyOC05NTg5NDE4NGNhZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5v1f6o+C7noB5soMk5VY6uaIiWGmUaMA8P54CDp6+f/jf\nnOAkLEokg5kXE6UlRv3+h2ulxPyXZ9d1HKwM2KYuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOUYFYqWWi4s5BdSgjUPNBzJz\nTuEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJiGK07/RbCuy4tdpHmwVI0afsODYFzjvZ5VWwfYHkfvAiB1ykCqnHzG\nxQx3fSgKFbRAAItiAYt1D0kazmyGFgYKIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVBiOunkuhq1NI9glycyBCQ9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM5M2NmNWItNzZlNS00MTFjLWFkZTMtZTI5M2M0Njc5YzM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTEzMjM3OTItMzc2Zi00ZDAzLTgwZjAtZDY0NTNmZDAx\nMzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQyP6AM/nUpwK/sVMgoUdue+f\nUjnizrm4/mtuP8Ocm1GNqepR5HK2VlGzxcxE28osiUMse8gn4eiHsEohRSJgwKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUhkavJEZrdVqEm50qs7rz/D3uH+YwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHo7BYLD/zn7qU2/\nlVpYBd4Mkpezqif3Lo/fFeIk2zaBAiEA2Jh5PQkePpIevh95xm3UGF5i0CexWydY\nbSlxfpdY34M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7063", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7063` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISARBrFF/BD7BfqG3EiaSK9xTlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjZjVkOWMyLTUyYWQtNDVjYS1iNDA2LTE1NzhkMzc0NTY3ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQzMWJjZDctN2Mz\nYS00MTNjLWE5ZDUtMWMyZGI3NmQzMjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvguVXoi3xftrAs2PFsPw0P4SqtD6ZXOxdrTuz8tQeCEKwW0nKA8EBdmhM666\nFP7URCi0Wn+BxuZ4mTL5eXWyDKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMHAYX3SdgJUVZ6Mx46XC7g5L3czMB8GA1UdIwQY\nMBaAFOsFBXSGH/NAEawMG4CuBDKMh2YyMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBTLf9a5fcAZSgZ+M+K5mjoUxv/9p8PlFEO\n1ggSg1vBvgIhAKJ5lNGU6TGNPAdeSehscogjKqSOiEBWabSCjBWVN1Xt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQwjlDO4bYWzYHjvkr+Fh98VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2Y1ZDljMi01MmFkLTQ1Y2EtYjQwNi0xNTc4ZDM3NDU2N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMbouXDgdvNNtjQpAxAZHKtOM0zvRh3s2/w0ZkYv1LSkIH\nDLECiNucWojfcsWRWd7ooRdjT4YcBp3Y8PHzFHkUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6wUFdIYf80ARrAwbgK4EMoyH\nZjIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGiva15xlVWaFT5EmUkok3FNLoXLq7ZG3wfDyXpRVQHUCIQCXG668cPVb\nquonutBwQQFca24EtnaCZbfQIuIhdDDDFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAfHQOFI2+TjOmGtcvj7+vlKWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQzMWJjZDctN2MzYS00MTNjLWE5ZDUtMWMyZGI3NmQzMjc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDc3ZjYxZWEtYzFmNC00MTI3LWFlN2UtYjczMzY1Zjlk\nZTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMFUrKKtWGyQ3spKwvhQ3t7Jd\nr72kpWoHD9GzEr4C+UEWvq8kTZtOFV1yhj0h04GMkrBGBlzhM6x9TwHCgS/C0KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwcBhfdJ2AlRVnozHjpcLuDkvdzMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDlrEWXxA3wrChE\nDB9IPecJdmRn8IJZOIAgOiVgaLHxJwIhAP3Mh0ugjToXq3pX6z4Sq7xnKt6cKT2Z\nYTbFL4H5tGBl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7064", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7064` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVR60HNJPzNujLRT2epnvWcBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZGQ2ZDEyLWQ4ODUtNGJlZS05MjU2LTI5ZjBmYjI1YjlkMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODUwNTlkMGUtZTIy\nZi00NmRhLTkxZWUtYjg1YjcxNWFlOGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3lnK/0k2MfXasCsxGIAwPEVIQ9IlByyxdZzgZvdNfoqzTfyLXSMCXo+05lln\nXcwUrE0ahwz4ILmXxAAIxOhTrqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1MnFOUH5M5fqGjI5wIA7mewjGnkwHwYDVR0j\nBBgwFoAUjukEUCPf0mYDP3KXxWxcXTHbOFkwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgImKXVJN7QNnR\nk+43iv4k9WIYZhYOdD7G/Mi2h51r7xkCIQCO3cCHRetFA6sSJvtkXNcTJYaZzvHm\nkDDjLKkQ/besXQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASxOEDZcQKy1YbweXxPSMMLSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2RkNmQxMi1kODg1LTRiZWUtOTI1Ni0yOWYwZmIyNWI5ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyXw0dcEaXyNIbSx2td32eDHxOvw7Zu6yrwFc+5XAVXDqO\nKaqPVv4M8gWUDL3Whp6ZGbEclpGhB9l48cO3VeUpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjukEUCPf0mYDP3KXxWxcXTHb\nOFkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYWM1+RmtErCEFHRalYw07nSLY6tc8qR0pujWxI65cpICIQCuQy64s8ej\ncUNPssyfVbOw4/X6gd8Q1M5fSw34sRnbrA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAVJUiG/H67hyV+UmVXIns4thMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODUwNTlkMGUtZTIyZi00NmRhLTkxZWUtYjg1YjcxNWFlOGE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWIyMDY4ZjUtMmJhMi00ODQyLTk1YTktNzJkNTQ1ZWQ2\nZGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7GBuEAtpZt5wzVUhSj0NQ8sW\n6zsYB4JcT0g0o+tRO7vHu/SLbCkte/qPV8pA3zo5z6EyFq63logJ3rRgByGV/qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1MnFOUH5M5fqGjI5wIA7mewjGnkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICUxSbylv2+CFE0W\nt8aICIKhRI2JQnaKtXSq9fw2BZSyAiBIodTisDMTvgSkCWhiirH9Q/2NOp6qH1sx\nsal9g97rOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7065", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7065` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAXgGm6g9JUOTPYQnSAF2pHDMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5MWVkMmMwLWE4N2ItNGZlOC1iNjczLTdhMGQ4OGZiY2UwNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMwNDY0NzktMmUw\nMi00YWZhLTliZmUtMTc5ZDI4MWVmYzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmw0CJsZsPdVc4jr0ShZTde0c/UoNk2VT8l1N1b/BzU1bp3BpjhJY0vjsL2OI\n9zJcbKxP9wOoLHXCtd0BvWS+maOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVEl+Kxb7aqApinlFMY5iQCcWUO0wHwYDVR0j\nBBgwFoAUUNcd3UixG57xCfpib5xVjuYEnHMwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgMbPycCsCS3CJ\n4Y6BpGK0AR7AN5rNtptEcOqegBGrKcQCIQC/FYfLPVAN6oqbP+V96wxjqaknNIno\nEFmGSvwayth5bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVo3HxXs0SChqlhe+rhqWEhnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTFlZDJjMC1hODdiLTRmZTgtYjY3My03YTBkODhmYmNlMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVfnnGSKU4RukHp8LjW/4MvGsEwitQzHT4yDs89AuS+y84\n1MzXAoqvYUSbql8gcKGTypF1vobIoGX+Tqlxlayvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUNcd3UixG57xCfpib5xVjuYE\nnHMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMc/PD3C0rf2WDQc8xLtdMEuuTZJYG+sRMsyTUVEhlCDAiEA4uvPnKLr\n72tCP2zqMC2gKMyqX4jCgFvZkVFdZG9mxQ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAWYkGR3n73/jz3RtYfJ2vMteMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMwNDY0NzktMmUwMi00YWZhLTliZmUtMTc5ZDI4MWVmYzFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDI1YTdjZGItMzRiNC00OGYzLWJkNmItODlkODc0Mzgz\nNjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExFr6qUpLUVSmID0alnp/SV+7\ntBKmzray2eLMobbHi77MFLKrHvf/DEKOUfeGntvxWORZmowPUr54O+uFIgLdSaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVEl+Kxb7aqApinlFMY5iQCcWUO0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGxZIJmHLapTUB5B\nMO4Q2pUUnZ0oKcAIFcveavRu9OY/AiEAhKgyTpiOlOFlNLNh9TWFx9llzt4fB6HD\n9yZt0PF7cIQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7066", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7066` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQ6kLI2WBxm/ARbD5Sv/POpAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhM2JjYjg5LTgwNjItNDgzMC04MDlkLWZhMDFmMTU3MTI0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzI0ODNlMDYtYzI5\nZS00NWIyLTk1MTUtYTAwOTBjOTQ5NTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYygt5j1VGAtUvogOCTheRH9vV8b+YMGM97lAHbsYfSG5EmaRm8amErF4/l9H\nP0hcKgbPcWd/rBwIwoSmKeoekKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuN/jvL4v/G4GxiEWvoyHQTmPnKkwHwYDVR0j\nBBgwFoAUGGeani/6o64W/B+bOwOYNRugpIAwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDhID2bApVHV\nLLEkMyZk8w8ffmn4Rn+57Zk9c7gytD4EAiEAjTVrl+3WP4ml7KWTvq0LebXmIiFc\nB40SVH/wRjqr6u4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdMgOS1iTVoatnDL//wnKLU5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTNiY2I4OS04MDYyLTQ4MzAtODA5ZC1mYTAxZjE1NzEyNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOu9YoMKpwOCky8EdVNFyo5VYbAF/7CPAaievgy2W3bkG2\nqbfkO+y1l1NEJjHEevuKDacUuYCbrnQMcwNJ4WMeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGGeani/6o64W/B+bOwOYNRug\npIAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY1NkXYfJaikT6Zizv34DxlafMEr6yQUIDuK0Y88/b4MCIHvOlSC2Vsc5\nRoOccrgASd83Xf7+l/LCKq531fR28ag8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYZSZqQv6jQuGdbx72hLcePIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzI0ODNlMDYtYzI5ZS00NWIyLTk1MTUtYTAwOTBjOTQ5NTc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTljYmU1MjMtMDhmNS00MGE3LTg3OWQtMzAwOGMxYWZk\nYmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV3LV3j8LcqIrWpPto6Lbg84W\na670lk0BTYD8lMn6Qw5DmAeKa9BwwNCnUqThzmFMYEkv4OnBMyNxBhBHmlgcKaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUuN/jvL4v/G4GxiEWvoyHQTmPnKkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCj+pODR9U7xaUl\n0JutJgEUTIYWn9GIakYO0/hKnvzWpAIga85nAwEolP709WgZdV0yphhvMX39QwgC\nZoXEkX+/Xmc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7067", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7067` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcWobaMQy+GWW1gkaaouCFp+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4YmE4NmRjLWJhYjUtNDM2NC1iNTg1LWRhN2VlMmZjOGI3YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZmZmUwYjAtNmIw\nOS00MTAzLWI5MzQtODM5YzhkYjUzMWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1z/YvZNZOvpNhj1NROFnpzarouFdtY8BDmcGoeJIyw4j6vnn5aRq1m8uJM3v\nteULqbvkC9ie4NSnqecYm5Ee0aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/qX6N1UcQlxWP+e6C9jaafXaa0IwHwYDVR0j\nBBgwFoAUa4fj58mcp0KCzuYJZp9CRRWKnQEwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDI4RsDd1RqOYkqwDfoO7m61bhzWdS5nQPg+eagRj69AAIhAMM2T2QQn2kP\noxeuoEGWub/BYaKtEwrP26hAxMRO+1Yv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATt//rv6k9y1ZpmtPB8qWTMMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGJhODZkYy1iYWI1LTQzNjQtYjU4NS1kYTdlZTJmYzhiN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx+gXX2N1UOYJr6a8yA60cpiyJMD5qiNvj3FUvFlHXegbq\nFll3FMkw82gr0z1qOL23lqW5G+lRTjNfnaoWsAOjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa4fj58mcp0KCzuYJZp9CRRWK\nnQEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIQir91eX23ddGHJvH555/AP7ycP5Ney3afh/twX7Ck1AiEA5l9eHv2n\n7wf7DcoKfWzyzU/5xPiH6iriEQm4MLbrgho=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAbeiaqGNIC2LehDn6P9OOiinMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZmZmUwYjAtNmIwOS00MTAzLWI5MzQtODM5YzhkYjUzMWFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjdhZTc3OGQtMzE1NC00YmQ5LWI2NTItZGVkZGNlYjI2\nNWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQg1h2v9W1g1SD3SKTEVc5Lr0\nLGsLz70+FmfA3oxCjUwdOHxV8/N2YkXMXT5u5WhE00J2CvzIS86OEDBGRhQrAaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/qX6N1UcQlxWP+e6C9jaafXaa0IwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDCu2a/MbKEgkeN\nCjQ4vsjvOYI+1/ne761bogsD/xQFUgIhAKD7f+b3WcsvYDALTK6/K+tWSsa9/W36\nSVHWgIF+nMRB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7068", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7068` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXzaNTFpw2Max8KWXbSF2LndMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3OWE2OTc2LTYxZGYtNGYyNy05ZjExLThjMWEyZDlmMDIyNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI3NzQ0YTUtMzZj\nOC00ZDEyLTlkOTctMWNmOTI5ZmE4MzgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkpm1y/GlQqi2vlDBCn/mdKkBdlIeJlzbwCjjrE48OA3CLEdCTAYM5eEBue7M\nFyKZre0xcgfKwBbzI4EYoCe3XqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURovN27xlbriBQwK8EKI7NT2fpSswHwYDVR0j\nBBgwFoAUHTa9SkODuZBrfCj54M/3LrV4r1wwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDiIrmDoDCe6TPoIZgJ/8O4mKW1Yzgxq5gTqaj6xSqOIgIhAOHpjpfNhu9N\ns60yQFttUU3+s597Vl8+Y/e3maUMhu+K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZVOopc03QWkvM/jteBcq6W6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzlhNjk3Ni02MWRmLTRmMjctOWYxMS04YzFhMmQ5ZjAyMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATblqZqF3cD/as+v6h9KIunTylih8JznldCFdP5x2ho8hMx\nemKFudlqgWtCZDNdJc/8IojOXPR/Cz/OekIpTbuqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHTa9SkODuZBrfCj54M/3LrV4\nr1wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALeN9xrAfC9G/S3dsYtWSTywHdErYcqNi6/byVf51dlHAiEAiYQtbIjQ\nnVX0RGAUrdFQPDIKpUJPamoRu7foA4hxof4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAdHMQKeSkVUhqVp9ygw1q0M2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI3NzQ0YTUtMzZjOC00ZDEyLTlkOTctMWNmOTI5ZmE4MzgxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTIyNzgyNGMtOGVjYi00Mzg1LWI5OWYtMzMzNjY2YzY3\nNWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDqlZNCwPKaNLg9ByToNQ83qT\neFBvMSeHFqc/1vaqgL7Ptybs2U7ig67tkzGCNqTboDZNsXAIJ3JlPVVRVOjsAKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURovN27xlbriBQwK8EKI7NT2fpSswGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEqxeCaRZTiipKaN\nTYyNu1ozNWcMETDr/NLCGuIvamtbAiAURHFCs0amPJRZSdmrWh4GJwR64MXPly/u\ndig9LgLFIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7069", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7069` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAUgw8wXpoYU3aRyqFW04MaEJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4NThkZWM2LTYyZDItNDI2Yi1hZDExLWVlNTlmODZiNjU5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2IwMjZiYjMtMjcw\nOC00NDg3LWJlOTctZTUxYzg0NzdmMmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExEW0Odo0Lo3FJoGfHgrjgMAU5RyvNfgbUaOE8n/MzK+VSptE83njJ/v+eQqm\nUK1SmUfw1SgZEge3PFdhH71KHaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU44++a6o1AfDpgnnplB0rnWdmbQEwHwYDVR0j\nBBgwFoAUZzA8HhqfWHdCjIzcPu4zKzyK1HkwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGQq\n5koZiMIcUjTt9wjfL3APASQ3FIZl46qBDam85k4JAiAXpkl6e9rEDDtdq0EsjiZ9\nF5ADalz32Gbge3K+8wIkcw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcjRituUsaskhXQaSV1dJxIeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODU4ZGVjNi02MmQyLTQyNmItYWQxMS1lZTU5Zjg2YjY1OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQe4N6aicjpqLzwpTeyfHN3Ihtr2B/YiFeitH4rlUZWOUPN\naxg+2rpNoLgpMRYmMejGHfRmbFJzq96OwqZTwAkBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZzA8HhqfWHdCjIzcPu4zKzyK\n1HkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfW/YTwJ3mulAUBnlxZdvMAw1mVlf8tq2vjX1ioRyJRcCIQCOnFAgOTtl\nbRs8dyDfYjlWFu+wDhEG9ZZrL2gqcktjqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAUcxUTSqoUVgDfY4CoJQxNmDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2IwMjZiYjMtMjcwOC00NDg3LWJlOTctZTUxYzg0NzdmMmU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzQ3MGRlMzQtNTRmOC00ZTg0LWIzOWEtYjdjMDhkYmQw\nNjIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEI11oFV4CMTqa2ArQ6gm0LRgv\nXtJUDLIwUYcasVgkiyvlUU7h5VFQK5swYy1KnqXzAFxbVM0DrFxqr4iRkXpgTKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU44++a6o1AfDpgnnplB0rnWdmbQEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCt8d3ha/8tEjHX\nkWMjQVK8/yvsu0NQg6YKYCaF5WGohwIhALoFDy+OY/P4zbtxezDvBJywqISktDg5\nCSewMo8+eicb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7070", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7070` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAX3mlfgojTUFRv4SWqDQMjDCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczYjQ5NjQyLTM3MTAtNGVjNC05N2NiLTMzNTM2NDhlYzU2MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM4YjZmODYtYjlj\nNC00NDE2LWIyM2QtMjdmNjRhYTlmOWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAgglSUai5z9d9Ki0E1FOZRS/fc5Nu632qhCUBp2hjsgqyUZ91CW7MCNhQZqT\noZ6yypbn2n2UKxRJPH1/GIl0X6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUARlYMhmJDVzaUT4F5/9TwockCQAwHwYDVR0j\nBBgwFoAUfobOotcAbl4zmbplTyfRY5+EKl0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCvpYQZ3yKm2SwxiZzBy8Dl/zSebXTJaM2+8tPgEkSV5wIhAPrL\nxnbHzHQPab1KVQMpqlyOKeolgpOCfKqTpheywOUN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYCh0ehT8buoemurY33ABnE7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2I0OTY0Mi0zNzEwLTRlYzQtOTdjYi0zMzUzNjQ4ZWM1NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/xeVYG1uZm+aMOee2lNRcj8jNGbEANj3xsvJiNbySLB+U\nR2vJOGfp1YpagCaomX4q+haUclgslkPmpGp6trE3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfobOotcAbl4zmbplTyfRY5+E\nKl0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANL2XjkVHpAKL+rRv7RXxq6W/FspP36SFwrCJI6VpAukAiEA54Ly/sWr\nPmzdaQ/6LeoGl1EnHCSYNNwToHVa+yYJv0w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfKcWNoFhH0qsPnuhE1z/syTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM4YjZmODYtYjljNC00NDE2LWIyM2QtMjdmNjRhYTlmOWZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzY3NTc0YWYtYjY4Yy00ZDRkLWJkOWQtYThiNzQwMzdh\nYWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoTKNMxghtohYuq3U6TgXr/Ok\nLvgZtTP2WuqkogjJulOx6vW9hx8VRIhtrCrtzZJ8NRn7JX9BXeLEijIYUJeEz6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUARlYMhmJDVzaUT4F5/9TwockCQAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDRb3KOZ0riPsHB\nia/mdKLQ8UFUqY8pQA6gLjpOgotaHgIgYqrjvhxbyyL5MbQFf8wKlnmspnctl6Ld\nxCJVZcnf86Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7071", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7071` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAcg/lrBueKLcNhL0m242p0p8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3NWQ5ODUyLTA0MDgtNGFkOC04OTQxLTM5ZjMzMmE1MjI3MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZkMDNlNGUtZDZm\nMC00NjZlLWE0OTMtM2U2MDZkNTE0OWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE75m+nDT7+p5oxd1ctwAtR+NUzvADVidu0+wt/b1Vjb4nHyyiv/VSzVV+caix\noZUwpszOuqyplE4wDuL0I4AQFqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH0rGCZTLoSuhclhqpr/kZrpYvyQwHwYDVR0j\nBBgwFoAU/xpcENQAcKLKdN8II0kIjzJdoi0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDvd+aWV0j7UYZBdE6tv8aYVuS+89HJsrX9+7po3jk/eAIhANMM\nM/xC/RLjTbtgiplCPOD7V02G6/Co6NjLX169jV2e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUd/FusExRPz90UYvpzLu7mTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzVkOTg1Mi0wNDA4LTRhZDgtODk0MS0zOWYzMzJhNTIyNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxZZ3WtEcT9bTDSlUVz/oWkfEcrDx0Lv4Liq5Elo3PuI6c\nOsFMmKvzBr/AyqcjY+A3OldrI14NWaV39Pue+N06o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/xpcENQAcKLKdN8II0kIjzJd\noi0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP/E51owEX/eyGFiey+yvajcHtluRCgHDfpyHCtLOJYIAiBW0UUxaglX\nYJA5QhBAH3fCzQIoya/sO0ipSEHsr8TNgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAS6dUgYNhLN5ZU4YAVOMeTCCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZkMDNlNGUtZDZmMC00NjZlLWE0OTMtM2U2MDZkNTE0OWY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTg4ODFiYjktZDQ2ZC00NWE3LTgyYzAtYjc5ZTFmNmQ4\nYjZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExzl1aSP7SzrYtDaJUy31jD3G\nlfB2nb3kBznHGtAKq3GM78937JOj7uP4kKWwibR6ogQQFtoeo0DfnA/Zr3pEJ6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH0rGCZTLoSuhclhqpr/kZrpYvyQwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGLgcgQYQrkTMAVs\nWIcbGpgW18EKjXBY9vAdUrEqrwzgAiBDZA3kBpobM9DzOVCcTK1w+J76HcODFA4Q\nPzRmi7IvNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7072", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7072` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAd83+hY1LAW3+9QaM9InVUjpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiMmExODU1LWE4NDEtNDZlZC1iYmFhLTBmZDVhOGFiYzc2ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE3YTExNDktNmM1\nZi00NjBhLTkzZGItNjJhNzNkNmJlZGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoU5d1p91HBj6bXgwlcmyebq68M/xk68vIwJGWRZMK03noy2MYGkiVP6K/kUV\n6jJdzLiX6AF/s4pCqFM6T4Ok0KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJt0FhwUGI1/hicVCaaWKyKXU6WxMB8GA1UdIwQY\nMBaAFO55BGZnpHFFjWbAl950qc6fA9lUMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBEIRbf/0w4y5CGervNx9mYu/t3yh5mhJSh\nHIN5VGFH7AIgN++niTjMmIUeQGofd2SoOKG2Mvu0OoK/QjyZB9YMJ6o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeagrW42zsaumHz8Wmp7VnYKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjJhMTg1NS1hODQxLTQ2ZWQtYmJhYS0wZmQ1YThhYmM3NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmcf1K/5nzzjc6ibGeR5ttDDYJv5gvcYJAf31IhbVQltut\norxtC/o8GjZE4/ICIObmcWj58mN+IKOAHPB6A8qio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7nkEZmekcUWNZsCX3nSpzp8D\n2VQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJZehdxbBesk3T8N+o3SHmNh40huV9NR5TT+jS56zApoAiBDiHoEuMnp\no3Wr1oTT24x/f0q3BC3AX6MLM6Q1k0oYPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAa2Rot9gsw+24W645baqV9G0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE3YTExNDktNmM1Zi00NjBhLTkzZGItNjJhNzNkNmJlZGU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWI0NTdmYTgtNjIyNy00MDI0LWI1MzMtOTc1MzAwYzIy\nNDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOezF16rGa4v6KekOaBcSveJN\nyruFn4Hg4q6uP3xVkWS98CnWQNjIUIeoyu/qdct2Lk8TmNelSHjCIx0pq8QMHKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm3QWHBQYjX+GJxUJppYrIpdTpbEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBR/mOSMVGnPI+F5\nsXBioJxQQJVEOSAR3zRo7MTqzHw9AiBdUmFF46SUWHLD+UskxLUozPwtCPpiWnG9\ni6o2N3qgug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7073", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7073` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARjVZ7P7b3rJhUFQuIIgef31MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0ODIyMTZkLTNjMzItNDViMC05Yjc4LWZiYjY4M2ExZmNjZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg5OWJiOGYtMmJi\nYy00Y2U0LTg4YWEtODU2YzdjZTJmMzFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwrtFy4nseRGXD0GQqHdk9FBRqR70FPI5IBHoSakYsgvQNKS3JXCufIl1FWxC\nJtd9WFz6Xy7FS9oFxJwdjmi26qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWQy829xLHY6DE39EXn2OUcBccFQwHwYDVR0j\nBBgwFoAU+XnBcCbbNVb4fQbR+gLoS0DKB0MwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKC2CmXtk1Yo\nVtJ8rp3OV4pQDS7s1mPRG6yrDjSvKX72AiAlT8qXVtN4qWYnw7bSndH0uf2XVG9T\noLdQHMiBwG946Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT5/qbJY/an/JEsJp98lRgyEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDgyMjE2ZC0zYzMyLTQ1YjAtOWI3OC1mYmI2ODNhMWZjY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ429n1T8HO6EIMum4sjcidGjWYHbNWHdCQ16mWz5iR9g6d\nebatsvUG7v4ai7DyxAN7Ez0qQqcX1XC8O1b8RejYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+XnBcCbbNVb4fQbR+gLoS0DK\nB0MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPx5aKSNrHYGw1U6S0g2G/06z5tKr7K3+RCzBTyHbTqoCIG2RNplYjOmk\ncoJSSo2TDtww4zBDurEWgM2bQnCphJHr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAV+6HOI6OoN3pyzFHUirbFYuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg5OWJiOGYtMmJiYy00Y2U0LTg4YWEtODU2YzdjZTJmMzFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWM0NTM3M2MtZGFmMi00N2RmLTkxYWMtYzQzYTMwZDRm\nNTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC48UfC4yUrE4piHFVqLgV1jq\nUrTuvGYyfPs7hyOLqXGC+SZBkdekuoq3jUBFYnfPV4I9xUfv9aaYokCXcxrJHqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWQy829xLHY6DE39EXn2OUcBccFQwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDQVTBSIdfvTXs5b\ntcTFcyikXcy1MC1e7LEbhgwCTBUhAiBUneC3kFH7PhtDJLxmyi7t1UMFBlKpjwTS\nagDmD5Zr6A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7074", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7074` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARLIdzbGRcm9VwBXWNny6TzyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4Y2Q0YjgzLWZkN2MtNDhkZi04YTY4LTJjN2U3MGM3YTI5ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhlNGE3M2MtMTUw\nOC00ZDNjLThmNzMtMGZkZjc0N2Y1Y2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsucZfBNwcCrybvRwwOu2u3FZCneSapxyG7Gr87lyLkDzQoIWgtlFgEavqvPZ\ndAfFirXgMIAnUg6EorFuZG6Z56OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlGs0V+omjhY+T1yPYlkLp8dEDG0wHwYDVR0j\nBBgwFoAULsvf1tDhGpPRDJpqGDMa2NKj2ggwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALveSe0pdZEj\nvQO23k7eYxXSTY78hWXaXHU+5PLhRYPGAiBRtIkYx6BwXg1d8fdxQAfrXVzuR+eV\n7Ct74lhok3ulfw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdTLhBrTsrKXai4hnC5BADI2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGNkNGI4My1mZDdjLTQ4ZGYtOGE2OC0yYzdlNzBjN2EyOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4gbZp+iygrX/ctb1in7RhRQWFQslctQz40SUv1ke8OL/a\nFChXX2sUg4ZLGi1HFq/tqTTYo2lDmEgiSw+UXYYyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULsvf1tDhGpPRDJpqGDMa2NKj\n2ggwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD/icyGEIpcj0IWSlPiLANCtwQPmkcADRedtAREpZw34CIQDkfNf+yIz5\niAkGtvp4eSvYAME+30ddomNllkhc9K+wdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAdRhl7PTQUOc+P5kaIPQXlH4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhlNGE3M2MtMTUwOC00ZDNjLThmNzMtMGZkZjc0N2Y1Y2FkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTdlNjE4ZTMtZjFhMi00Mzc3LWI2Y2UtOWM1ZjgzZGRm\nMGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEO2flFQy/9hOxoG4jE7rjJQwF\n/xl8i553JmtD7X8cE8+75xmjojTbKJ1p7iVCgiryXVKJ+adXnI/82GEiWuxmyqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlGs0V+omjhY+T1yPYlkLp8dEDG0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIALQ2VR1CkMcRIcY\nz/V7KHMJfAK3YfTof5GUL2c+BZREAiBgNxYYh2F8+qM9rtAGSujvAm+etZsKw1Ea\ndut86L8Eeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7075", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7075` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASs+kPdPafsJZNV7wA3MkH07MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0ZmQxZmQyLWVkN2QtNDk3Zi1hNDJjLTBkZjQ2OWI0YjMzMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI2ZTVjOTQtNjEw\nZi00MzhlLTkzYTYtYzFjZjVjMTRhM2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKSAGNN9CA7vH/z40ImSTG8ks1IL8UinBuZ3Ya0hghy4QHlyPUC7Wz+66Rnvt\nASK480l6VDmjBK0kk6a/PXOyPaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrGg5W6kwSX1r3Y/YDCKwrOr5cfkwHwYDVR0j\nBBgwFoAUFsXNumE5S0XV1FcSOAGjAJrGnk0wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD5jh1Id9Rb\nwMi0ilTuJTib8wSYODi0DzyGkHCuMkqZ6gIhAO8ePaeg5TUzpbbOvqgnEWbfuyl9\nDLDzM3acLjeIO/NW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAawi46WXULkFWZLY1MNx25LFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGZkMWZkMi1lZDdkLTQ5N2YtYTQyYy0wZGY0NjliNGIzMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrRJlIoy+MMQPpa93wZSWFfV90HMbQn8vQwHwymP76teHK\nyO5zBKFubukHDE1Dg5fs0KNU5xiSkgbcp8hkvaweo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFsXNumE5S0XV1FcSOAGjAJrG\nnk0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJeAlznC3/++DbUzs1zFdxX0n1Ab4nE1BsfuhNril3/mAiEArOuKNfNu\nrR3jzclRUO7fxnROorgBnxVoaBuB7/t978I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAXtzDHwAxdqz4hTV00E5sNq2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI2ZTVjOTQtNjEwZi00MzhlLTkzYTYtYzFjZjVjMTRhM2FlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDdmY2I3Y2MtMjc2ZS00MzEyLWE2ZGEtZGUyYTljM2Vm\nZGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEshgo2P/2je0IvmgM2AEhWnI+\nS7j0lSKYAkxj/L4DIjpzNmCHnrDpuHg5TgmmOHBr/ui9XXQHn8Ddal+/yxWibaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrGg5W6kwSX1r3Y/YDCKwrOr5cfkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDZgXZknu4pKtx4\npeE4GNjjw1rIS4xe6wMf5tBp1bMadAIhAJ1fz9yJf3nQlcwLEp+Bf/VrKNkALdRA\nfvcxD7pOaoCf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7076", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7076` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASz6QTov15H7HiZ0AfxNufSTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYTQ4NjVkLWJhNzMtNGNkNy04NTllLTQ0OGExZmVkYzY0YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM5Y2I2YTMtZWU3\nMi00NWNjLTg3NzAtY2FmMjk4Y2U2N2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkVNe6+hqM4fiIc9HSxjATSDAQyvDZzkWDUjEtdbi3bdo+BGX6a+n48HPXfKc\nytosiBE/DTvJeMM15/gHoz1g2qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrpNnRaNqgyWnSNlN7nixG9xc7bUwHwYDVR0j\nBBgwFoAUhRaNWygt36iX8xI1d9+tD2gofEkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDFYhypRlgeKRwUZCfLrnIirBw1bnmxT2Er9Ip/Cnf1/AiBW7dnpf12c3ZqB\njv23OJ+UMD4dIzhCBC/21DyMqbf4nQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaWfNOG6+KbAu4ftU8aRk9pLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWE0ODY1ZC1iYTczLTRjZDctODU5ZS00NDhhMWZlZGM2NGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASA/Q6lm4bAlLln4RbImyyqZO9hV2Tisar+wOThL1B8V64C\nMqf3SedB4nZvNQxResD1Snoz3wZhO5fU2ZHvnRy4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhRaNWygt36iX8xI1d9+tD2go\nfEkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIKIn7PRIuEA9QGDxqyW25GDEh/CocolwwzG0qC8YpDYAiAcm0SIVs+A\nC4aGfMXG1L1NnD4CVWY4q1BaFuqIOpzTLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAbfNI/U14D4LAgebhkwLp0G/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM5Y2I2YTMtZWU3Mi00NWNjLTg3NzAtY2FmMjk4Y2U2N2E1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWYyMWIyNTYtMWY0OS00ZjYwLTg0OTItN2VkY2MwZmZh\nYzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWoKXfGzdNhiQm+aMNjxVGJ6u\nYp/TUq9UqAhBVyjqt/9i/Y2OKlESk6HH+qv9uEwW/BZUOvEC2P5C2l6sttMoDqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrpNnRaNqgyWnSNlN7nixG9xc7bUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCmr0x0bGEoAHyt\nuVWI5RVzpcUdpKRsdKNHRV2dgDbjKAIhAMS6yF53A4Bv6RmK6IJLPVKFYS/JnaaN\nkfttxIGezDoZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7077", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7077` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAR/Wf+crDDS97Iw48VTboBAoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1MTM3MTg5LTgxYWUtNGQ4YS1iMmQ4LTllZjVjNWExNTBmZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjkwYjlkYjktMzYy\nYi00MWNjLWEwMmEtYjQwMTk2NWE0ZTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5LPbSFMO5sRlb+ujNFXh8oYfAePInwy8NqB/ir94HtTTxa0DV+1tmeGQfHX7\n6SfKgpFtwXMq3pYOFEjvq/ja/6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdKORBUW2Z9Kjav7/8xTEgY3SnYgwHwYDVR0j\nBBgwFoAUCcMMXcA11yjJy+cCwjYBOcvH/TQwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGF7tmJqhpT35cp2cq52rTIFIe13n//ZyUjIpyDMjtBAAiAJ+tinqPDj9MGM\n8vc5Tr3z0BwHks2kUZUaANE4Vt5qIw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ85f8Va358Hn+uDLNyFPQZkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTEzNzE4OS04MWFlLTRkOGEtYjJkOC05ZWY1YzVhMTUwZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNFi0lSt3rRRjACy9/uaezRVnPHttOjR/QbhoGmw8A+jzr\nLv9B7waFMhRsIn8aqqmwK4G6p2LEG4UDpSh3E8fOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCcMMXcA11yjJy+cCwjYBOcvH\n/TQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPZOK+65iH1B20WY2dov3SU6CXDWnsrLO5TYdSvAyGKACIQCUHhKmPtRB\nX/B0PDD3mnaKROBpxk+4PhPi9A16wRcLtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATSM2l/9SR8zqkzhlI5mAJ8jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjkwYjlkYjktMzYyYi00MWNjLWEwMmEtYjQwMTk2NWE0ZTMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDUxZjMwZjMtMTEwYy00YmUzLWIyYzMtZWU1YTQ1NDhk\nZDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+xN+QRzHN3AMgsq7s1+bFtru\n21C4Xv0yWSzEsMdNaCjRwwPXQJCjPkRlzuXIs03QDDGuIAeYuLB2+eN8m6qJ16Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUdKORBUW2Z9Kjav7/8xTEgY3SnYgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEtvWDoHy6uQnftG\nNnb5NUJHe1RqwUCPoNZW3Tkid9JcAiEA9lPQAo2LoTHZoFV+I48F9raQHUf3/h3i\nood0wpnzvx4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7078", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7078` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAUYE49R/oUThKpXz0j9/n+bqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiMjdkYzBiLTVhZTYtNDE1My1hY2NiLTI0MDdkYmVjYjk2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI3ODQzMDItNGI0\nZC00NTY4LTkzZWMtZTFmYmIxOTlhYTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEADGL05dQnRE02lI+rdo0s3mmhWzVwvTqJC4gEQTkNvDc6CQ+X/rCi5pVq+RE\nX/0otJHkwBSKARHLKqnjEzhZbaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5ebn9zaGQutQ/fxfWR/3E0sf0FcwHwYDVR0j\nBBgwFoAUbyuJRuZ554tdBp/rkUYk7HzNk7AwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDg\nNTpoVcDTDFl3i3trpkl6yfKlIzZL7AmkJbLDWDed1AIgKCGV4O4MXF/YQcuk3PL9\nGJFLVbCP5tVM6F6fItZ+jfA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ6+P5FnoAJHWBKtwLzkSnLEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjI3ZGMwYi01YWU2LTQxNTMtYWNjYi0yNDA3ZGJlY2I5NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKvDmv/KUbhrCsV67ASGq6SC9x3KDyMrWWFaVNMNpsGdSi\nVJ34u/jTj5DRSEZPTQLwyCToymINQs6MMUZ8u9MTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbyuJRuZ554tdBp/rkUYk7HzN\nk7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNY4S/pjRZfwTFHnKqV6XjZn8CcTN0dkVpMm1BibujCcCIFVzzNA2i+ss\n8ZcOunPE3zTMRqULZdu03ZBkfUypu0dW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAe8h600s3SLLJz1Yh+560DwXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI3ODQzMDItNGI0ZC00NTY4LTkzZWMtZTFmYmIxOTlhYTkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2E2YTBkOGUtMjczZC00ZmUzLWIyZTgtZDgzYzBlNjg4\nMzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1n3dGJyOsjlHQUjU1RZIbn0x\nB7kt2eEXmfcQVzM1ttZ4tY/koGNvabbm0+GcjQNSrrxqhwE1SPJVeUiVF9SiQaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5ebn9zaGQutQ/fxfWR/3E0sf0FcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCucoDbeiGImQh5\nFBDke1gFwRwsTyKZFzO1lGH1f8rrtAIgaPR0p5oxpM3v60ZmQgFHRiWmmF3SnNlf\nGm0LpRU1y0g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7079", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7079` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWtrrSQM95UHUlQVH7CYeRXbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5NDNhNjkwLTFhZTctNDdjMS1hZTA3LTViMDg1NTU5MjE1ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM2OTY1N2QtNmZk\nMS00YWRmLWI5Y2QtMzUwMGNmMmVlMzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQUJPiRhLWn8FCFkhMRtCf4w/IpnXCQRIYC0Pl//TjP/udrjB2GXiVBEfHeEe\nnoPXdEUcmeT+oJkVfp+a0SBwF6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsNhZ8dXVrjyeqwmE9k0tcfWaWjkwHwYDVR0j\nBBgwFoAUg+tXty77etOHjluwh6G12IW5I2swOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDiUHrr2M4pAjqByidZMgcyx0kF27cgHkDXwuXPQaD0QAIgZ6eQ\nEbEBoLWrC2H1Nj3tuxmBYYoMfL04QFefDJJ2rUc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf2rF64ozklYShmAKXNin8oLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTQzYTY5MC0xYWU3LTQ3YzEtYWUwNy01YjA4NTU1OTIxNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbq/f3mtNhUlc/SQ3qF1mGokzghfzW3qo03+wafuSEjJ7E\nsAx+4Q8JPdcc/Tp00dX7jUmbj8wlLsgFX5mER6qfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg+tXty77etOHjluwh6G12IW5\nI2swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW6ENOrtp+ceRhKKnzQTXWfY1zdnJQbgT2XCqv/Y4fxsCIFGdFwgy7Glw\neW6W3cuUPlWoWoM8VVNZ8Kdz0dpQhJTb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAaPjBDDzOQLMx22iRrc9KVCbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM2OTY1N2QtNmZkMS00YWRmLWI5Y2QtMzUwMGNmMmVlMzU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzMzYWM1MTItMGJmNy00YmU1LWIwZTAtZWVlYzVhZmEw\nNWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0fI+ua1Yzlv4TUG0GfIUZ3O/\nId3fDDfgJAOZGTIWr0dOp4wk+xRnEjz9kMa0eFBp+h39U2pb7W7YHT5T87USG6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsNhZ8dXVrjyeqwmE9k0tcfWaWjkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHqWlheBMIQBVTRa\n8QzxhAb+nP02nznEQEswqw7KLlASAiByKLPAmqMSlExKhd38qhzatpcCSLWKGXIK\n4CO05gBKKg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7080", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7080` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVMvMWYMnzEp4g0LifUlfQwiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMzhiM2RmLTRhNjgtNDRlZi04OTZmLTUyNWY1N2Q5MTY5ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU5Mjk2NzMtMzU1\nMS00OGE1LWJmZGYtNDg2MWI1YzZmOWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEILwhPyuy+1YUP8GA5FBYstm8OaYoXvdrD+MfvtFVRAjBGMQeeQ53l8x47Mtl\nuYH9t9WhDK3jQs+LSaM1lSl/G6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmSMenr/smcDYD4clclwVWZR1wwwwHwYDVR0j\nBBgwFoAU6qnqRXIYyrMC2XiJ0bAldohVpoIwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIAW6KISi5ZJj7ULJTNlhBwUeRMLJsEqzfQwkWEQTH9ZSAiEA6Ih3\nTJEjR6j2roi4CAvvHD+5GX7oLUAreT2RTcFJyig=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARjzBBNumBRMDdbNc9iYLmI0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjM4YjNkZi00YTY4LTQ0ZWYtODk2Zi01MjVmNTdkOTE2OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpkBg6ThYAamA64d0WLh7mRIx9F/ZypQ12mjr/7WO35Cxk\n9s4L7d3CxGA1mAvgBLW1vDKpW5ktx2fuOjistbS8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6qnqRXIYyrMC2XiJ0bAldohV\npoIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAWXKPOVnb09pQKqeqv/DNrK4AqlT/WktdRgZMYc4eSgCIDHA8AaEmEWu\no1QULqAgHyM4IYEnD81VBZWgcB5YP0oN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAUW+m5DGAHZRrs8+X02XQjpRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU5Mjk2NzMtMzU1MS00OGE1LWJmZGYtNDg2MWI1YzZmOWY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjU1MTM2NTUtZDU1Mi00ODUzLThlZDEtYTc0NTdkNGRj\nOWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfWm9ioGP8tU/ji5chGprHmm3\noni3UWrZIHruGaU1h7flOmU4MbGB4m4btsAZt+0vdM8mzPoLokJ8yBxbnfTpFKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmSMenr/smcDYD4clclwVWZR1wwwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDxteFSBsE8bXHZ\nhJ066+GOifQitv2VF2lKAmNsYuKpdQIgBCGzmfNkhAxKhNOYw2zNpBLmBo1EHLle\nAl+TyPbokos=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7081", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7081` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAUcuDCM6dlQTyV9BlfiM1dG6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MDU0ODFkLWNmOTktNDE3MS1iNGJlLTFhZjBlMDFjNGZkNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg1OGVlNTktM2U5\nNC00YzhmLWI2NmEtOWUyYjMzNGFkMzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbh5bvBDMcg4ZBZXXlBp4Z8+GQu5P+5Guen3e1/a4//VJb9z9y6m1Ggbz7B3U\nvcm0Lfd1curvn1cd4AFI8ruNGKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR/qMeLyq+AXGOX4N3D+Y0vV4vRbzAfBgNVHSME\nGDAWgBS63zDAa5G0iwIEoD/pHCxNSPYQMTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDZujHocL1rffZX5hLE0fv7k6m6PgXt\nZKyo19OXqO1aOwIhAIYvSg7iNqcAmzDA8ij1WvIjkxEWusAIvBJmvJbnZrh+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZnXQ3iEio4D6i/8ToL3n1rQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODA1NDgxZC1jZjk5LTQxNzEtYjRiZS0xYWYwZTAxYzRmZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAx/LNNQXkertawA778nolAPwon7Vz5Ai0TvhFlrDFddxi\nL74VTfq6dVV2RiOmus/GUH9wNxT4v/Il0DTCLAVto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUut8wwGuRtIsCBKA/6RwsTUj2\nEDEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKSQCzfpwJvaHVMqaDlCr0XAccElpfQEU/HIn5voscGvAiEAw3/bemCy\nf21gRlY7AkoyD7pwn05N7MQOOCYQAT6TLHk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYkBW55h2UJU89XuAAC+T4h4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg1OGVlNTktM2U5NC00YzhmLWI2NmEtOWUyYjMzNGFkMzFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGNkYmJhYmUtNmU2ZS00MDI2LTg0NmEtZjJlN2JmYTJl\nMjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+Mw5JaXrrODR29GZPUbPkx7t\nO3fg3Kg4eYLtmP0qdSPwpxbKRehsUdHNV9T6WIUcgodNvaQ51oARGS4dlVfYEqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUf6jHi8qvgFxjl+Ddw/mNL1eL0W8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICpxEU1+Y81DdKYd\nML9uw3RJzxjRRz84yKnYv54OkKjRAiAk2O8tT1v/EtsA6KJCAhMM5GBqD30L3FZ1\nUO3YReNMqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7082", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7082` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWdjfeG6iekecpnquRTdwUV4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0ZDdiMzcyLTRjZTktNDMyOC04OWY1LTIxYTE0NGYxMzRjODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAzMzU5ZmYtZmJl\nZi00NTJkLTliYzgtYjM4MDdlYzQyNDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF9lfwGYB3VdNNNilULfQ0dRSr+Q90O4K3jWyKhNMA5XJ4krQ7i8pVg5hOQXw\nRMYDZWz691wLOs4QDTOsOwAiu6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnvhZ1KkQ3//6k+42+TE64jvygTwwHwYDVR0j\nBBgwFoAUb463zncqNRAF3Q7CSwKwo/l3+X8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCfzchARMGS\nd/ln7PijWE+TjrBhS8WuVBsrmrMtqHJteQIgfP4o2fX7nTxhx8PdeJt0xQnHSkPX\nMfu34XMilpiRsT4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaI88BErUlPw65pIcNarQyvoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGQ3YjM3Mi00Y2U5LTQzMjgtODlmNS0yMWExNDRmMTM0YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTmWDMFvrneI3EHlsOnAtVdLUGYwF3g8sOyFagiMxh8XvL\nQQqwS5Z+k3Skf5d/Mcxns1Ny7yoT5zH05C76YBoGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb463zncqNRAF3Q7CSwKwo/l3\n+X8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTbNuvjMMrBleh21eAclBzSoUOGjadhAbwrNV6Wi9IjUCICGHjTd/Dyni\noAakIGOcipJ6UUAR+1j7D/YuR7T2XBei\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZLW5VhEauLoQRQRVS4pMtZIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAzMzU5ZmYtZmJlZi00NTJkLTliYzgtYjM4MDdlYzQyNDI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWVjZDg1ZjEtYjMxYi00OWVhLWJjYmMtZTNjNWY0ZTM2\nMzA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHDZGi4N9JRNOoVK4VZJiq8Jj\nMiAhQXz2CbivjIkD4FurIncjcBVbRgKfn+TWJUOlS6VXWT6gwVfCoTjwavS9lqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnvhZ1KkQ3//6k+42+TE64jvygTwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCCDBEoWl0XYV/v\n49knimP3Aet3jXiLMer1IceL6DPBJAIgHBiIFFSTypPeZnRUJeWIk247x1tzxVGV\n7SAoDMVYpvU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7083", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7083` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZt7Zqq9Lq1HcnH90OIgL09CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMzA1YzIxLTJhNDctNGE0MS1hZjRkLTUyYTFlNDRjYzM1NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI1NDdmMTMtZTYy\nZi00ZDMwLThjMDYtYmZlYmRhMTVlNmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESZLuPSLHZLwR3yKuzl6+8AIZtP2ovgWUl6CdwYXu2Y45J1eJXEs2fG9E1rma\ndWw6TcH5HEIyPQTluvpts2AKTKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvancP4zBq0eSxgnk7xvy6FDqgYUwHwYDVR0j\nBBgwFoAUamgZeRi2+t3a/8nyNNq1SiLxMMAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIG5jsBf64ug1\nDPftKqIYHBfdxq+8DPIbI2fV85CKNaOQAiA9lyeCyP0cBwiSU6ylSlsS9swOMrM7\nKvRgDA7e1Tt3eA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT9O4tADuzhFVKs9STY8d1FIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTMwNWMyMS0yYTQ3LTRhNDEtYWY0ZC01MmExZTQ0Y2MzNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWbFbq63DJKjBB1Rg02k8PleQXYiibB/eBV8a/bSLIh0bX\nSaRwWiTBwLNDPE2/siBM35VhRUNMVIX1SCiDstNHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUamgZeRi2+t3a/8nyNNq1SiLx\nMMAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKAOTYvwwb1uGprQajRvJPwsOOo6I6P1dq6rMMZ3wf8LAiEA/53ykk/9\nqdgDJkSiMX0ovswPJJ2abE5n26+/yLTydbc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAVSyQKNC0NrngyyKojjkvAfRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI1NDdmMTMtZTYyZi00ZDMwLThjMDYtYmZlYmRhMTVlNmE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODRjZjA4NDUtYjdiMS00ODM5LTk5MjYtYTljNzkzMTQ5\nNTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqR5IT9Ql6r5GAvmZ6n1TOEx9\nd5PbOgBqulnphF7d6MyBZROJoECICJ9ggFYmZqVVQVcTwndFCtXEz3CMHARc7KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvancP4zBq0eSxgnk7xvy6FDqgYUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDuaZYIB+xYDuV9\nQLQGaYtXGZ4wdQJ9zhAFcU27yCxnugIhAIYqSYPtHYLQjARe76hVsBVO9nMCN7h/\nbY8oYD+ie6A5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7084", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7084` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAXEceyOEKqvAclY1Da5AAxfxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2MmM4NmY0LWFjYzgtNDBiZi05YTI5LWVmZTVlZDk5YzNlZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjkzMTY5ZmEtOGI2\nMS00YzkyLWJlOTktNzMyNWY5MDZjY2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENnSNbXwn3Gtb7+CL0vxH6/cSxN6dq67uehT3ABka9wkd/X++BEQum8QtiqYx\nbT/km8Gp77C9Bm/xnQQn10RpSaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyDdhCsv8Ng0V96Pc5zsmq9WSjnYwHwYDVR0j\nBBgwFoAUqCx6ne8a40jOmkuySaBgTY0YFQ8wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA7tdFZpAJ\nVGDfi5nKWo54gO4Q7zW7cRTSqGJA9W/iYHMCIDA5l1dmUVWP7qS82ujIfgFpvi3x\n2hPCCpIbkGth+VMQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXq8+KNHvaiSi9PD7EvD1kDwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjJjODZmNC1hY2M4LTQwYmYtOWEyOS1lZmU1ZWQ5OWMzZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPenbFsQuI5/ycqmcoA6kKZwtFX1YgOCgfvbXChzMIxAtD\n3LAAFZSerdq1vLY4ylRNR7MD1MscPLyAVu9repjbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqCx6ne8a40jOmkuySaBgTY0Y\nFQ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOcR8KCLVDAqIlt822MEEkpDGaKcAhnE3/sGVBzkh11DAiEAwl/RNdMT\nUQ10m+1PUHM4zAkcjgQOyEiHsEkQMNgO1hM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAeSoUfiVRn+tRJsolExyegbSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjkzMTY5ZmEtOGI2MS00YzkyLWJlOTktNzMyNWY5MDZjY2Q1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2NhMDc0MGYtY2RiNC00NTE2LTk1ZGItMGJkMzY2MTMz\nNDdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKIy6spXW6KEsq0qynrvcTp4J\nYiktttWY+AB93zkH0lHDQwb13IBGsFaE1VFc2ESbpXbEAGkbJ9NnQpLkjKt0n6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyDdhCsv8Ng0V96Pc5zsmq9WSjnYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDahp2ZTAUntL/5\n8TSjvJ54Ix2DAPJs6TPP44cGj33VYQIhAOcVhuKtu9vyIE9wj4mUdej5fwzgj2nn\nZBbvZgTB7nwg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7085", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7085` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISASSCd63XHNoWrPqzW6AqG8DfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4N2FkMjczLWViYjctNDcxYy05YjdkLTI5OGE4ZTI5MmM3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2EzNTUzMDctOTAw\nNy00ZTFlLTlhNTAtMmVmMDM5NTg0MzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgjkylH0+6Mx4bL7Gb8Skm1YLhTCU8AsOpuhzhu90KfWIux0WxNROuLpYryAO\nODpPMNJKDlXl4gBr6Hxqh2QNC6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqSmY7h6HYDCzZmMoKM68CJQNCEYwHwYDVR0j\nBBgwFoAUnbvMdEepdd27QAzAZMrGhmjEQeMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAq6ztd/dhcDx6wqT/9jRZIqw0uioc7rwPi1Ap/z5eCwUCIQDOXeVuikEN\n8YmfgPDMkfm/IIG5iDwAlJQizbKaiMv1VA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcTny9FGqAdGyHysj64J397IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODdhZDI3My1lYmI3LTQ3MWMtOWI3ZC0yOThhOGUyOTJjNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrVdDFrN9bTDxdmpW7Kq5+kwwrPxvfh0igMx4/1JyPUUGm\nFr7RVhRupFBatM9bhYtQf/Ji2akdP/7k2cEr+6I+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnbvMdEepdd27QAzAZMrGhmjE\nQeMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALJDKSKX5hI3sCm0ISg/eln08gDrdNLu62yTZb0FzBHbAiACrdGyIVTS\nXK+vMeON1khTrFNsmra+Xk6f6UocqSoXwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAWuhUYXAq62JCuPVD5tmY9VYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2EzNTUzMDctOTAwNy00ZTFlLTlhNTAtMmVmMDM5NTg0MzAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNThiZDY2YWYtNDkxNS00ZWMyLTg0MGUtYjlmY2JhNTI1\nMTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExxBaJmXbnfew87u2Xy+uwCSm\nSgcGBQ8x2phyFMrpjh2dxFqFEqopmhvx2Gyn6Wmvn3n7HEC8/cDE3C6H9Ep5e6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUqSmY7h6HYDCzZmMoKM68CJQNCEYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCm2kI15McMAN/p\nePXDVf30+tWmCzp7unpX/1WqZx0pcwIhAP9cWfWORfSaHDyJBW4srYkUMQF+AjIJ\n1RndWCcVtVAF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7086", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7086` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAYEb30n903pvPgdZpGDojOE+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwMWVlOTYzLWRlYjQtNDBjZi04ODExLTdkOTg5ODRiNWE5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE2ZDBmMmEtNTFj\nZC00ZDU1LWI3YTQtYjlhN2U4OGI3M2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbjKqRxaIL1Z3IzWIukbyVPLLPuQYx8Y++8H8zXbO+DRkTX8GV9Lz5WKCIPgF\nv6WEEV6H8eLRxP/uy9kjuQMUkqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtxJKO8wRpS6VduMN0M/hvczW6EIwHwYDVR0j\nBBgwFoAUefrNEMrQjziTyJNRl7SdCmjS9tgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAip7zovROMuEep71lG/SeqOlEJmplQ8NjGmseO4oUv1gCIQCOMT0a7xxT\nKALDNvNDgLfac29HctPnfA+AOreXzq3tqw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfQamSzkGY/SxXawYEbhzs/8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDFlZTk2My1kZWI0LTQwY2YtODgxMS03ZDk4OTg0YjVhOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7vw8CsJkSRGkmGPIeBCkd/vqEZRJmU6h7GXQMlAEuJqJW\nJkHYGaXi27RXJtDEcLAgZaNuQ/rJoq7Yx9U1DOzHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUefrNEMrQjziTyJNRl7SdCmjS\n9tgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG4aENo61h9w4QvMVVMnLxf6TBghmafgOjyOubd5etZ4CIFvkL8G3At1Y\nDRmBjz/ZZgkNZ6SnqUDT9DjtftcGm7J5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISASR8b3DnQP1C7gqFRKNqwAjOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE2ZDBmMmEtNTFjZC00ZDU1LWI3YTQtYjlhN2U4OGI3M2ZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTBlNjE1NDUtNTQ5OC00Yzk2LTliMDAtNTVjN2M4YmU4\nNGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFfdg1RVc4GkgGHlE/sCCrwNY\nzLqHnvpmLsOwuAYgoY2yEYqLLnRCWzQsYZNYm+hOdbNM0bUGYm1vzd3m32JDZ6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtxJKO8wRpS6VduMN0M/hvczW6EIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFUpqX0ay6UVekvQ\npSwj/VXaqRI0c6UPvcg2SKloJKrPAiBeS6PJkaR60TbF+Aq+hgtY7mXNuUrRG1hR\n/IdmPu82/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7087", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7087` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAVZ6d1x5Tf+L6My9Wx/c3/irMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0ODk4M2MwLWQyNGMtNGUxNi05OWQ0LWQ0MDkwOTZhNjY3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNkZmY4YTgtYTZk\nYy00Y2MwLWIzOGUtNzEzNzc4ZmI0YWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErKl1c4RF9J6JH3GvE2tZGcpmZ2SNbs3bFrAfOtyL4UG84/+GgZsDA4ioPT8H\ntS+IBSm/3tmAvviTG08aQNYa3qOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsK+ePjeFXbFz+WknplMI+xaIWY4wHwYDVR0j\nBBgwFoAUpHsUPt8HKOmPX9fg8HHcpaHZJ+EwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n2iQVZramQ0iT8+aOF7KicV/icbZDkCzWXrVsTnh2c8sCIGYkqSwecqVZoiYRwuoI\nmT8d2BOH5ZiiGZCxLPZyX/XW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfSzzTF3UUQWiXuaXIvJ0/3sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDg5ODNjMC1kMjRjLTRlMTYtOTlkNC1kNDA5MDk2YTY2NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBm3xT99wTfvC1Q+i2ovZQmG/vKyMy385I7yyiEeAvxo3X\nRvlUL7oobxgRkHjK6pZuGJU/MJTRe+/O3AJEH39Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpHsUPt8HKOmPX9fg8HHcpaHZ\nJ+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJnszsCIeVH0vvpsnmLXql+OFbssiTdD62xXKIK7DXr7AiARWlZZeDmF\nTD6+h9QolXRqw69zQubSpQz7Oxf6yZ2fqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfbFtdmSGL/XdM4aU8uSMeQBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNkZmY4YTgtYTZkYy00Y2MwLWIzOGUtNzEzNzc4ZmI0YWFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjMwMGU1MWEtODE2OC00OTQ1LWIwMTMtMjhlODc5NmQ5\nYzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExT/Brl7bbDFaBGC2i9h9KtNs\nq9Q9tELpqA+HTgRwU41qSDWQkIuFQAfbfbACMwLziinVPIW/ewTHqOYIJ7fcEKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsK+ePjeFXbFz+WknplMI+xaIWY4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD8ESVmIWMBAnnQ\n1sKtV8Tb1NzfnGc1YIOD5U0mymhu1AIgBQpuqeTwL8FS1lxkvzVymr3mS9+JBkz1\nKm7yYnk/sCs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7088", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7088` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAaftiDoJp9H67edhJkEuyYfEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjYmRkODQ2LTdjMjItNDhkOS1hNDE5LTMwODc4ZWJiNWExNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmYwN2I0MDQtNWE2\nMy00NjlkLWJkNzAtMjRkMDI0MDgyMGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERIG708P/3lVHXAwD4aEJ9MNLEMyDTNreGYzZEcnLK5BhQBG7BtW2zLbG99vm\nkvmz6+Ryv0k5O9mUVLd+1cA/saOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQutIabCK0CI5VI4azSchIRG3KB0wHwYDVR0j\nBBgwFoAUYPTfVm1Qv6NkH80MA85wxrU3QO8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA7FnwPYoXILp0//SKnv662oK2zxwiJK3gIWPZIauvZh8CIQCu\nK5wGsevnZUVIxAlN2mgt3kPiJu6Y7cyGx52VKdP7Ag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARD1nZBNR0bbAq0t0Vm3LkXdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2JkZDg0Ni03YzIyLTQ4ZDktYTQxOS0zMDg3OGViYjVhMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR78uWNdyteOZeRT5sULAE/IDxKif1dh+csqTCeUWSjhnGY\n9QPB3WqWdMhAKScvBRKyCirjg7KKT8oZvVsfGouOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYPTfVm1Qv6NkH80MA85wxrU3\nQO8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNIyltGy6Xhg2GJ8SrnkXgen+hOfSKnBoscPGtv9z60MCIQDIpbwHRqm1\nHSy5r2+QZXAC2aI6VLIOWpDJVJWODVl3hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAcqhew9h6S5RfPmaavy8z47gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmYwN2I0MDQtNWE2My00NjlkLWJkNzAtMjRkMDI0MDgyMGYxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjM4ODhmMWEtMmU5Mi00MmExLWE0NTMtOWI1NDMxYmM2\nOTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEvN6oc3EFW94xQLnBpx9oIzI\nHy9QWePtHqz60Bi/tUtEVKAzH4ShIgy0RfdvFsPSUUa0CTtilLh74C1bCgzidaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQutIabCK0CI5VI4azSchIRG3KB0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFF2uEv2Q9KSLwr6\nMG8eG7yIAumUAIAtfC9ZHbnw/PDjAiB5hdhuOsMiKGUFhtz5hAg0STw9VI+3GQRk\nrlZ68LiesQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7089", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7089` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVtinKi46YPwLhF7x4Lwa8rtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjNDA5MDc5LTJhMWMtNDdjZC05MjlkLWZlN2M2NjU2ZjNlMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRiYWU4MWMtMDlk\nOS00MDBjLWEwZTMtYTI3ZTliMTAzNWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+K2wxZ8vhHltdAloRG9tQRsI/63XjpKW5K9sTOhazqBu2ye+2vvC3eaurV0V\nUaRZGlcY5o9esOodhKctbQAknaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOX/xx7witMNtA6yXKO5xKvq4Nw4wHwYDVR0j\nBBgwFoAU7T8cN/aqy0rRFd/C8ZNcJsrVqjwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBlRkJL47XklgtIwqNAEMbNp/RqAX72KjDZH8KZtxGTNwIhAOdt\nMMqls3QZKEB7ynzwBl8WmKi1o2KXQEBYy+I98vQV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQZyOrRttfsCAwQOvk6Jkrx4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzQwOTA3OS0yYTFjLTQ3Y2QtOTI5ZC1mZTdjNjY1NmYzZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7wbXU/iPeoyw5yoRFyNscZVZR2T8/PMQw5wj43F/uCXtV\nbYUBsyaGeGSxTt6yCkhX0waSJVyl3iTvyzbOU4RTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7T8cN/aqy0rRFd/C8ZNcJsrV\nqjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgepv31b1drdc1TSZpTXY+pvHqrsY0PrbDXyw8XnMYs+8CIQDFvFGAOV9B\n5hfPf8bJZFPJ/MF/BvmJnIhsqx+HeGWRJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAb1Kp7vWyZLMek7mdLPlonxNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRiYWU4MWMtMDlkOS00MDBjLWEwZTMtYTI3ZTliMTAzNWZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTU0ZGJkNTUtMjgyNi00ZGJjLWEyZDYtOTQ4NmZkZWI2\nZmQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEc6VkLtISNsr4MbE6fuDjMr3Y\nkyS5b/Qk2yEi78fVkzGtlcuY2CsYuMJ34wf49bC8c0QuztZ5v7aN7VtD3xfjuqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOX/xx7witMNtA6yXKO5xKvq4Nw4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIA/I7oIyid3Bh/qy\nbIa1OPxrCpIexssD8jsk1Yer/2mQAiAG5dwdzpHsHoVwybbIHW7wyCnYs5AlrjWQ\nwvf/uZFM9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7090", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7090` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAZpBq85swmjblj6e6zy5Kq38MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljODY5NTk5LTViOWEtNDhiOS1iZDJkLWM0YmNjNDAxNjhkNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUyMmUwYjktYTMz\nYy00NjU2LTljNjYtOGM1NGM2Y2FjM2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz/04kbot06ltye8Nerbi8g2s19jz2ITcjgnP0lqW8vac1vt6jQcPPxOzRc4F\n7zdRkyJYTFy81pIvqEE7Hx0ZyaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8jz+7xbIqC6tD8QSYz+VN+TG+Z0wHwYDVR0j\nBBgwFoAULr/GK9ralxWPMFF2Op+G4VuMUzIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAz3jWkQ7P+ruz\n0kPQmzsWsK4wwfEjjd4hi22s0+qEWNACIQCyImllWJtcdQTWB/9GZS4YDOGh4eg9\noDaTovmSZoQAwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYb8hCSp2LR/7tzKmo4Fy07JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzg2OTU5OS01YjlhLTQ4YjktYmQyZC1jNGJjYzQwMTY4ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYHNZexD6zUiZSx7hPHS6WfBm39NVkwRjBMU/DQbbk3Ta0\nrKKaiNqo4P/MN7iz/Q0TJxrELh/RFLqWYaGm4OJ1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULr/GK9ralxWPMFF2Op+G4VuM\nUzIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPcNzBZQ1Kdh9zvDSpUDbXvULmR3qVxUxJxCu3t9FNkHAiBaYNK2DuXQ\nvRK0caHaAhEl1V4P6vpN0ZHs30ZPhumYtw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAT7Wgng/s55nt393hXQlwtV4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUyMmUwYjktYTMzYy00NjU2LTljNjYtOGM1NGM2Y2FjM2MxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjkxNzljMjYtNjA3ZS00MWQ1LWIwMjctMTRkODgxN2Nh\nZmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGkHzOFBkkITRpevPaVUGfAJi\nAaVF+ZwIwOGmzwE1E1y2WPJQbpJZcD3ISScASQA8Ne4FXsY0mhFLYjiFdA1ybKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8jz+7xbIqC6tD8QSYz+VN+TG+Z0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEglxGX7pdIgw2UT\nBjYooDPQ3yeja5m7306jyEPiBx3qAiEA2IwtgYUTU+m456K7HNkFfQGwpScatzJc\nVNEdRoPzWok=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7091", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7091` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATX4n3YUJLMRx1N0kQHJWGWCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwMmM3ZTI4LTg1ZGUtNGZmYy1iYWVlLTlhOTRmOGMxMmEyZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA1ZjNhNWUtYjE5\nMi00ZmZjLWE1NzUtZTc2YTExNDcyZGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERtA6RhOI3MM91Rpbf4xMV9izBrt0eHbMP2MzRX2Va6rM+/WgfCn9z38EftFz\nfuPT7pRBFjfQ7frFgkXzKzRe/6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDUJ/+ndXyH83g6Gqh7s8MURcqCwwHwYDVR0j\nBBgwFoAUE4RFXSIorqsN4zdGED1IJRmmbnQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCYnfTnBoMnXnovSz2MsFNBOw+FUDuZu0YCMpkYL+kyrwIgYV8zdg3Cyy8N\neuQ3P3+Ye0ccfAUBqOYUbRN6wGN7XVE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU0W6udfrLZkIv7jFo8gZXRYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDJjN2UyOC04NWRlLTRmZmMtYmFlZS05YTk0ZjhjMTJhMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQ/qhDkw89D+qjpVtbyeoIRFofc7stz3Gqw2C3naV8sRK7\nH3JpGX+Et6f+HhtrwIHDcyjZEL3Tm7/JXXQx93Nzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE4RFXSIorqsN4zdGED1IJRmm\nbnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMsyoC/52rmPBjory1siZ/ekCLzZtTQtOf9Ui8EttF5cCIAGpKbjLMuL0\njok9zMU0VFejrxlklyXAeyTZmXAIVrry\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZJZr5cKYsWJ4MMS1G9ZGlr+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA1ZjNhNWUtYjE5Mi00ZmZjLWE1NzUtZTc2YTExNDcyZGI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGJjZDk1ZDAtNTY4MC00YzUyLWJiMDItNDg2MDc4NTFl\nODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdrSsrWCEd6jE87DaUXr6sMbj\n8WEgqd7mmC9X4TzOcbVqlv3TnQYfprshisscGtPTlJNZlwG5IqNtBAboVwut9KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDUJ/+ndXyH83g6Gqh7s8MURcqCwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHGDVo5jPbBC6qRL\nS/qoI7x15jMbFF4OcdK0pc8wZbcvAiBL3OfjbQ3WXIqpN4POwzUm1kb1bxcsQQpP\nPJJvf8G4uA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7092", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7092` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAS7OE8An35187C8ONeSOAs5mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyZjU0ZDMyLTQyYjQtNDNhOS1iYTMzLTQ0NmU5NmEyNTVhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2MzNDIyNjUtZGU3\nZi00MzIwLWFhMTUtYjQ1ZjFiNTVhNmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECfX694mxQW+8nwptUMPjQwiyli89hahWPbRRRYsiDmM2LLXvXOnkEwBELXf+\ndUG3e76lstn1Bee+b5HJotT1laOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiTbvEux0H8vD78ccM/hNg7xVh4IwHwYDVR0j\nBBgwFoAUzU2ihAFx9wkdF+0Btus+U/P+ptAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIE5FcJTBhYQjeeSBybPAh+RoYvocCAvLpH+eICcn6VsGAiEAtCCTHyuoL8l1\n0ffElyjK5te+p6izL8oOuyTk0TptKG8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdMLQ2te76R+WVJnsAC6Yw7oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmY1NGQzMi00MmI0LTQzYTktYmEzMy00NDZlOTZhMjU1YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFR6384PiUaK5kuP+wpP8dDbQYzwm8WUX+Yn3EnVHD9kkh\n1VAXwNchuHu6FL+Tf37SDGWRBxlVB0UCerJAwwfZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzU2ihAFx9wkdF+0Btus+U/P+\nptAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIEwWYnQcIroa/nZ5XfKznOnAUieq8RlrEZyrgCEnY2jAiEAsBVkIfa6\nXvUap3fZaIby3K0xoIj4hzj34sUAkg267og=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbpoTRCD8QEtLsOPNdy6xRo8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2MzNDIyNjUtZGU3Zi00MzIwLWFhMTUtYjQ1ZjFiNTVhNmViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODNmOTUzYmItY2YyYy00YmI1LWIxNDctZmRiYTI1MjEz\nZDk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELDQjOg22/fr7u+LQrcV+RmjV\nbrDRjqIAUTlmHn+dZtkw70CuDlTdoWYfOW1PJcqZekEpAfN7Ddlx5N0oztoRhqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiTbvEux0H8vD78ccM/hNg7xVh4IwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDWgPpp/WOxqhr7X\naevDJ13tjkbGsl3U1MGNNEF5WMhZAiEAolqcAwqr6kY2wtWOGZa3Ypdhyu8GRSTy\nb2m7uy/QevE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7093", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7093` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdrMpiGyUYU6JhK9RwkbpcePMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjNTQwOWNiLWU1N2MtNDE3ZS05ZDRjLWE1N2ZjZWY1ZDM2OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWExZGRmMzMtOTkw\nZS00MzY0LWIyNzMtZTdmMjg2MGRmYjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmq8SWlMCFPsYCyRAGGmqn0jirn/S3e4Y91OJIPUG/PRAnIqrBw8bT0s5ynW9\nUIuFTDv4+fRC6eNFvUWSMvlN7qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0jcOut3UNFCCTZH2myrITAuOp3IwHwYDVR0j\nBBgwFoAUfJftim3jgxnER/4M6Lv7+Oywo+MwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAFO3TIrDisPSe5AiVweypHagbwclrRauaHtpLP+CmfSQIhANDKpk03NzBe\npTltjn9/kAlaozpJiVmuBMr+q4cG1WV8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR+ebKk0svpGvOQ0OI4EV58UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzU0MDljYi1lNTdjLTQxN2UtOWQ0Yy1hNTdmY2VmNWQzNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROulx9CFgMVP1VZn6UCoCMOi2i9HMyXouFJlf7PuwXnZvC\nPNnAsVrIMS5wJsva7DhTP32Fwqy5jUfK6+zGYFsgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfJftim3jgxnER/4M6Lv7+Oyw\no+MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGkWDyklZW61ivpwWA9yPDRIJbbAetgSwGxtCBspz5rUCIEw8yiWBnVJW\nWzwzeDYIbB1sMRANxn3fq2lgXYj2EEo1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAY3UFBB28MBCroWie121YOjQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWExZGRmMzMtOTkwZS00MzY0LWIyNzMtZTdmMjg2MGRmYjZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjIwOGI5YjYtNjE3ZS00NTNhLWI5NTktZGU0NTZhOTIw\nNTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETypEAPSomvVAIUdbJSTplr1y\nlI9VMjsqyx7OOEfCuozB7RfcUoEyKlO/rpBbbtvkSoHGps4MJXvzXU5MweLqa6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0jcOut3UNFCCTZH2myrITAuOp3IwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEBw78NCZvcXWuDE\nkrTPCq0GeirsuXEvXIXcLvkDY1IRAiEAtl2ZNcrwPf+KThwQk2BLbhCq3bRtlHe+\n887QLsqdzaw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7094", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7094` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAd1ck5ldI3PtzJht39CfHn3TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxMjI3ZjljLWM2MDMtNDQzZC05YTBjLWNkMzg2YTIwMTAxNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNmMDVjODktOTYx\nMy00ZjgxLTk5MjYtZWY3ZTUwOWRlYWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZdj+tCzULHdVacST9KjLzv+axiumJPkaJbtowLLAXCqjFXBzaiQ/WIb2Nucd\n8TbftkyT3JyWJE7yEffAO2HF16OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOFO8DhCBpS3vM9HW+ewgaws7tg4wHwYDVR0j\nBBgwFoAUHkmWh2UTZuwv8G3EJwAWlJDJ0acwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAWs+6unZFyXbmfJ8Wn2OpzSSqbosgUkqfn1FfA5Ohm\nxAIhAOqUkeaKBHFn9tS4xukLpCIFCtu5uUouNWJNBWFjnFio\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAepf1ZZmn84Ldza/6hnaqdE+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTIyN2Y5Yy1jNjAzLTQ0M2QtOWEwYy1jZDM4NmEyMDEwMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDI75g1OBYLxdWko+O0Mzb5bJVC6eaPKzL5jNBVLmDDA8l\nM7k5fXbWopD4+kZFoQXVSCnoVoNDTMkhDzaS7DSio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHkmWh2UTZuwv8G3EJwAWlJDJ\n0acwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAKM9foF0Mr/FytIQGBhQZnbEZb9+9Ns0hO1l0at0B1YCIQDEz1NuYvKi\nRS3OjnXSStRFAT2uFZucKvkqWMH6II5u0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQuhLIMda2iG49OHI8CAqbvtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNmMDVjODktOTYxMy00ZjgxLTk5MjYtZWY3ZTUwOWRlYWM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzdiNmVhNGQtNzEyNy00ZTc5LTllYjYtZDIxNWYwOGJh\nZDM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJWQsKmktGRatGjuFW6upmO1E\n6VGGzailV8IDPKuExIjYqJ8cK/NwK4kAursECRs2YJ6vrwXa18Ozw5Db2PYiuqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOFO8DhCBpS3vM9HW+ewgaws7tg4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDkPJf1w5E+bdtT\ntmX0vRHDmGq1JAPL+IWAH0x0jD+niwIgOF76C0S1mCCnD2v41KaCEySyHNMc7nLQ\nV5arhQuseZs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7095", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7095` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAbU4iSQgA1LuIBumperrL9BMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYTAyMzUzLTdlZjItNDA0My1hMjkwLWI4ZGUxYTQzM2M5ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRmYTJjNzQtYWZk\nNi00NGQyLTgwNzktYzUzOWM3ZmRjYjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE46AAUUTJxgURlTJpiKYVoWFLT30+IjpKNgXWYc2uDx+r6lxlLXHfJrsYCEi9\n7zxntZi4NlBFSDNuFPQJXxESWKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW3+QJdI9hhIx62c8wc5FBWO+JxIwHwYDVR0j\nBBgwFoAUxc6XvBFx7BpeWY98o/mSybUnxMIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAqs3v4nR7Z2G6ZsVeBtTJAkUSfPrMahmKYjc9+q43\nFWECIFAGISHCKehtXp4vgOJPZl56xAFNfsrq2BCYEhzDKKGY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZYxAK1Q4Za+GwD6DdUeM/pMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2EwMjM1My03ZWYyLTQwNDMtYTI5MC1iOGRlMWE0MzNjOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLxLnyCgWjQ5Qy6C9QQSoY7HLZZr3fxFCu+DAboX0amQ2k\ngN0sTIkIsiLYgwc+/qoJwWPBbVwUwDrF2/goG5hoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxc6XvBFx7BpeWY98o/mSybUn\nxMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPvbNlpVrnVScwPvD4c8ap6xr+Ck+vNdt3SHgg7pjqzEAiEA89WUCT5q\nbHVO2OcV0rk19TxCVUP1nQVbCn7+Bh/f3qs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAWQejtwqV4HyF6rz0uOM48ekMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRmYTJjNzQtYWZkNi00NGQyLTgwNzktYzUzOWM3ZmRjYjg5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjczYWIxZjUtMDcwZi00NmM2LTljNGItZmVmOGJiMzU4\nNmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIMZlWJubAYmrw2qw//aN/GnJ\nJqKqTeY7YgXB6HuDD/c+b6DtUg+iRJ8GXm3kJzerX8oO9yuXPkYEuFCEeR+yOqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUW3+QJdI9hhIx62c8wc5FBWO+JxIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDntm6YL8o2WaiZ\nbstJXpq9EDhFVoM3UEyepCobpGWTIQIhAM3mQFyzkCuUCb6N3PTPbnA7DgaGDzKQ\ncm53+346MBcs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7096", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7096` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAQsevBcscPJM9yJLUy1u+kVoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MTdjOWVhLTFhODAtNDAzNy05NTA5LTgzZDMwODI5OTY4NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDc4ZGE1ZDEtNGQy\nNC00ZjkwLWJlYjYtMzUzNGU4NjQ1NGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz4wRGHOF5jMLWpT6m2oCA093CtUg4XlZPMRHRq8vShm/O9LDDE4L9LXYYKpm\nTIR/Ziois8EHcDKJwuPkFarLC6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ7QCqogvT26pid6KZhNvJtV06QcwHwYDVR0j\nBBgwFoAUjm52tnV8hwtan2n761zRdjdCHFUwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAW2pxVFuo5332W2+nmQz8188nq9rrFC76yvxwcMbg6wAIgcZC9\nuc0gwfPUwpBmmGNJaQLm8wO0NEwyDxdwlgX0W6I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASMLOHiWPpWXxYYijUaRkdbCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTE3YzllYS0xYTgwLTQwMzctOTUwOS04M2QzMDgyOTk2ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfevGLS0qxRPwIJmkugG2m32omLuvgQ6seKQB5t++yDaT8\nOya7OlnGUJU+ZophRmE8w0FWehjBNRY6GohSMYdEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjm52tnV8hwtan2n761zRdjdC\nHFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSW+8T7fAufMSUPiDTLXE8KfBxyNtCQ2gAFmy7Mdf2x8CIG8amEmYbe/h\nSi4GcqINcnX68EdxnQWj1hMWbFxlSnzY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASB7UAFeioGVcW9dnq7JibVbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDc4ZGE1ZDEtNGQyNC00ZjkwLWJlYjYtMzUzNGU4NjQ1NGM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTNlY2Q2OTYtOTM3OC00YzBiLWI5YjAtMmQzNDA1NmRm\nNDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7rjhu9JVb9eKjfm49ZSTzJY3\nHHhJ2xrhHUWCuhJb38p025ZF+jCT+OEYO+DzcC38cx3yMt7ww4V797vhwJkFtKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZ7QCqogvT26pid6KZhNvJtV06QcwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAoMhDjaKx+/5cTz\n3xAEM3WQaH9oZwj0erb4gAK+eRn4AiEAtZdJUqdbXn/nbBR9HTC2rlnt7dd3jqSs\ng1duVjI7u/E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7097", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7097` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAeTrUx3HaGXx8bQyCo2AX+E+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyMDNiM2Y4LWY3MTktNGY4ZS1hMDUxLTE0YTg0MzU0NmJhNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNmMzlmYmYtMjYz\nOC00ZTYyLTlmMjktMDZhMWUwNGRhNmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESVVBKctQdydMl/fwFtvVAXGXmlHdnUOhe88dHyS1IF7lrM83FJe3CnTmpceN\nDHLW0x63miZHDApxrV970E0WpqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrCDJg74AN8QnAE7k1PxqJKkQwncwHwYDVR0j\nBBgwFoAUlohTuREG7GgMGnM5+F1/mOUWv40wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAkmQeOCt3jWqfLfdcpafNjakC7XaaAAn9\nSreppiwo298CIQCR0rQhdQOtjri28tqRdd5y7Gh3KPsRB6rxjX4ZzwNtqw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbRESU6tM5Wp3R7eyC+2C5VwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjAzYjNmOC1mNzE5LTRmOGUtYTA1MS0xNGE4NDM1NDZiYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0Q1kqFIDSYuh+VJT5QYkI9Sj+Wg2bqqDlYCExDJ/roquY\nomC/qDq/3qvciHoxj9M6jMcqHDw4lUAQ+bXSY46io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlohTuREG7GgMGnM5+F1/mOUW\nv40wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOLfLNdWXg1AN56SC72KJqogcqJ+A5p9I4p1pIn5sWcHAiBYjdS7GJmt\n5phZK6HlIClJei4PQu8sXQJvodQGPVaTtw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAUNurd7QU7KZsyZGNwfkUmp+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNmMzlmYmYtMjYzOC00ZTYyLTlmMjktMDZhMWUwNGRhNmU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTg2OTY1YTUtODRmZC00MDIzLThkZjAtYWY5ZGJjMDQx\nNjc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2110zchNZ56HI5Z6L0bFRkpf\nJBQogy0vrsc90ydVhWp+VbgKJ7N8H6PYYX2mZjNI2GF5ypS679BJKPBvhFxQoqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrCDJg74AN8QnAE7k1PxqJKkQwncwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCjFmSm10tPgQc1\nkqjcYAxEmvdFtluXz+muKJRbWxwdTgIgHQsyjHImbzPOxijFTrAVdnXeVpzwwT4h\nW6x8+hEWI0Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7098", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7098` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAUEvV9qnGn8kKjARtNaOwTsKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2YWJmMzdkLTU5ZTMtNDhhNy04ZDVkLTBiMGQyYmZjM2JmNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA0YWMxOWQtYzlk\nNi00NzhjLTk3OTUtNzc0NmQ3NjZiNTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERcdt7PN9t/3BxHcUlBQICHpso8WpmqCNo18yPI60p6dS0+kYUF44BqTtsooD\n6F1CHwxU/Mlix9XcUqGdDLOH6KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNFge5Dwhy7EdMVA/NMqQizF0i9AwHwYDVR0j\nBBgwFoAUpz+ZsuGD/G6Jfr2JBofvrSNtlIAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3SE9eGAWoNmfOpOzRlxblbNAwpiGRpTj\nC5jVywYalyICIB7Ew3VBCXjrmJ/vlR1HYH0loahJg7WcbEuQLhxbG08E\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ/as4SJcJ8uuW9gscsxlyYnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmFiZjM3ZC01OWUzLTQ4YTctOGQ1ZC0wYjBkMmJmYzNiZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeJWkMVvQEPl5Z4XdwpEIcrKawaWCUTl65ScfxmsII1x2C\n+6hYOfKY3174zElSybtFaaJPRGVYrRgu1BBPT1jPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpz+ZsuGD/G6Jfr2JBofvrSNt\nlIAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJYfHLKpExKiuCZxzfCEv+U/W6LpKKyKtcxOHBCtW7D4CIFzZH8vYtYGy\nlP1Fs0jmuED2XtCuuRwlcuVgJoMQW595\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAWUMdIcenN+WcnDmyNRM2DdrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA0YWMxOWQtYzlkNi00NzhjLTk3OTUtNzc0NmQ3NjZiNTJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjRjNzRkMGYtZjY4Ny00N2RiLTgyZjQtZDYxYmY0YTIy\nODFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj+ry1ZT9mB1qqPzMPx1EhnvG\n2H66UAUXLoO7AGKoReF7tXgLOQ1KredZ/QWjEO6wM8R1e4XgPe0TgpWY745Y46Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNFge5Dwhy7EdMVA/NMqQizF0i9AwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHO0pQkF3JVezJFh\nuM0TguVTqw099DXmZ+fqiX8CzTz5AiEAtF7CkfMJ8d0wBuqy8Fvx/g7uqXWM9YJr\n/hxB8L6qasA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7099", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7099` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAbvfmGxRo34wS7EHkgS6V6ZiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlOGZiY2YwLWVmYjMtNDEwOC1iY2Q5LTliZjlmMDlhOGE2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg2MTRhMDktOTFj\nYS00ZDY3LWI5ZTQtODk0OGQ5N2ExYTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7k4c5Ek31WzOG0wnlP0OAPLko71S99PlLGZyOhG22ujNiWCgX/QQUTO515OT\nlEMslif4qhdFBO5F6UGWGe22iaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcHTLxYKVBm5Zj9mnkWriMY3izhYwHwYDVR0j\nBBgwFoAUKg3vO7jH34gRERoV30FIShGXYvYwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAtNPVbGfKprVlI\nyAuZtOTdsb6g4kZrKbs/LpIaWRarvgIgH0NXGiu50A84jq2rhMSn1pPaXf1BM3DF\nyPQxo4IY/Qs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXahIuJ2L3IL9Ckx17wya4OtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZThmYmNmMC1lZmIzLTQxMDgtYmNkOS05YmY5ZjA5YThhNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjIQDdIrbMuxUEvN2ptmiVzrWuEn17Z7kq/xjfqsBcNDi3\nWn2y+QZyG8J+NbBmbk5SK1bZwLKWKLBPrcVwBikSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKg3vO7jH34gRERoV30FIShGX\nYvYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWWYWBAVdzUUl1bXdaMmNgIcbstz53F7CHta2yciFU64CIQCrG6LQuOxB\nEbK4cFsLV6PTVRWxIMf/w1A7+llWrgNUxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYIGsrfKLvQMk6/LlRu7pKPqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg2MTRhMDktOTFjYS00ZDY3LWI5ZTQtODk0OGQ5N2ExYTlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTU3NTMwNWYtNzg4NC00NzBmLWJiYzQtYzgzMjgyOTVm\nZjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyJ+ugQaav6hH26qDo7JtxbUv\nn6PFgre5AH64z45M7ioIRvjZxpELji12Fk2FaUzMXc3fixDg9rH84gtAPskuYaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcHTLxYKVBm5Zj9mnkWriMY3izhYwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFTP/Zre1ik8MBV0\niN6CdzKOpll6YEwrMFiYktqDDgdBAiAzK771MDZOpcnPzNnkMKqQ+iY5u6czDW4O\nXbxfJ+PRJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7100", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7100` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAazgvG1F/mIkV/LffptNwz3GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyNWY5NzVhLWNlNDEtNGFhNS04NWU0LTcyYTE4NzEwZTNlNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U3Mjk2MDgtMjFi\nMS00NDgzLTg4YTctNjkxMjk5OTExNDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPR+ajCaBKeZEaIw6gSybgDlwV14ciJiD4Bg/0yHIEXCwidWL4wVAI4/SyaAa\nqk7I8cydwJiKEvnAnvIJsrgGQqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVz38R9947Q5qvMxcM5E7Hi0X4F0wHwYDVR0j\nBBgwFoAUeXU7+zpAlVE5lBLlpJqeeK7rxYMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHzGLwxQwnpX97Kl95hpD/rRNjtXK+nKa59CctyHpQ51AiEAgtoNbg+pU7uz\n8fySH1wy8eYXz91V2hXazGhzO5D0mgM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAafKzf0IkbhlMfUZ7Z8ifDwzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjVmOTc1YS1jZTQxLTRhYTUtODVlNC03MmExODcxMGUzZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASB7DgS9ffYZVQKOkLCtrsoHDhqL4CwHAB402LEH3YgNPAg\n/RF1JAGZE3mRtxwOmOiFH2O/OwgCJTyOUvyEipH3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeXU7+zpAlVE5lBLlpJqeeK7r\nxYMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN0bbTTb80uXvkpx67xT1lWDk+pPHisRrzOWh1L+GzFwCIQDkRG/0g+6S\nkRM1ZR9XsneAucvnC5IWTGrAPT6y8AVAQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVayPZh0KNDtrOAGiHDqhV+UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U3Mjk2MDgtMjFiMS00NDgzLTg4YTctNjkxMjk5OTExNDM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWRhNGU1YjMtNTJhZS00MGVlLWFmMjAtYjg1ZTg2MDAw\nZTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQReOmRn0cSo/4uf/ziL3p6Y1\nBcXlaLz+lLQZcg0ooS1rbRYRpfJguK1kW0A8TazvRCZJltmswn+UUqEivfYMRKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVz38R9947Q5qvMxcM5E7Hi0X4F0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC9Mm34hKnDPxvX\nEmtiVUPeb8Z4S4kT3YXFCRTZfAGEAwIgP+ybOkFpe2+u4A543XWnP0VzLKOJ217o\nMk5sUtM7iC4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7101", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7101` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfv74jexErhCEba8vuyQ+bKnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzYTc3NzJlLTQ4MDktNGNlMy1hODI1LTUwYTBkZTJjYTZhMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNmNDIwMmYtMjlh\nMy00MzNmLWIyNmItZjg4YTM4YWIxMmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWtu4ta3DFCX8X8MJV9FYhkXG9Pn10NhmOcLwFpHeP89u/qKPPWAI74FVuwfD\nOp+2lgSrQBjmdl/Fz6yzrE+JAKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwBkYgjxG74mD/4wxeoUY6tGMmcEwHwYDVR0j\nBBgwFoAUnJ/FmsbC1kZW+gFWYu3bmtuvXzMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICVtMRg35pt7Fa4TsTKL7RHbHxrZO/P7h0h3+2vwqy+oAiEA37QqmpBqiHzM\nLAeFTxgX65XRdXlTEWiWGUmMp601stc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbM1GbwIU+SP2ry/oaxrE1hAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2E3NzcyZS00ODA5LTRjZTMtYTgyNS01MGEwZGUyY2E2YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKUn9B59BoDMXtjjiHaxLanlSTb+HZkAWvtIMiOLVAdQoV\nEOvoHDI3ScWyWJaikAX5vgwouHO4q1p4TmNEPHdPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJ/FmsbC1kZW+gFWYu3bmtuv\nXzMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEk3H6eHngrvbE+QUN01R54aj8WE2ZycuTyrIa80Haf4CIBjDbzyEEn0z\nkCVVPUdL2jF8DqDjiriT61O4vIayffEy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISARHrZY5WwBvfdp1pfb7PmKwiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNmNDIwMmYtMjlhMy00MzNmLWIyNmItZjg4YTM4YWIxMmM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGE4NzdkZmQtNGY3Mi00N2QwLWJlOGQtYjU3NWFkOTU1\nN2QzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECO5E5jqfJqxPz/zrdUpYkuRu\nOiccWrZEJX/hFYBxoXbPTK9N0iNfYEB74JfRz1NTEkGBAbSs8TQV8Zaz1rLLKaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwBkYgjxG74mD/4wxeoUY6tGMmcEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHDkiUA3AYAtRw1y\neySsKG/H1x7tnc++/g1HCr/1hwflAiA3xGtCnxaBy/Rrd1mEHtXc57SDrvTlzEC8\nm7B2YL1XOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7102", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7102` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAYLlg8aZtnTq9WLO+y5YIy+zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNDkzZmE4LTMwZTEtNDUxOS1hZDJlLTc5MmZmZDMzYzJiZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZhOTlmMDEtYjdh\nMi00Zjc4LTk0MmYtMzcwYmFkNTI0ZDEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEudWvxgC2w2m722xKHEpBJb8Acf4biC/nIQRSMKLQWeamzKfS6KBkpoF6Yzj/\nt+gPZmneMoelFZ9qnVzogaKx86OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU9S/y1IjvwmZvdNSMz1gplrqqt4wHwYDVR0j\nBBgwFoAU+74m97r7j2IRjhM8dHj8231YRDowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAPNrVj4GdzME6y6TmIft1xmC17GveNbBCluLa5x7qbrwIgB1U47Bg6EwWo\nugTbmQPjM7NoTvdLf4cqY5EQmSLMzNY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARQUqvx/e48R5NuQu65xz9qoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTQ5M2ZhOC0zMGUxLTQ1MTktYWQyZS03OTJmZmQzM2MyYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdQZc0m5f3UuEcu3kKEdd7ZgXY6n6NgCOUtPJre18ww0fA\nRSEkNasy635zT3WRRIIdUyirA/UmBPEqWXuQgwyto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+74m97r7j2IRjhM8dHj8231Y\nRDowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOj+A05h8cvqlo3T8So4sjUOLqHPnRelApPgvxHPbmBoAiB/zTlfbC8P\nRWopxCUclNNY2Vm+mDjoJkGnsu6NgKTFnA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVCcXYWOVJYYRrntWDXNk5JhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZhOTlmMDEtYjdhMi00Zjc4LTk0MmYtMzcwYmFkNTI0ZDEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzI5NWUxMTgtZTI4Zi00YzE2LTlhNmMtOTM0YTgxYzA3\nMDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEq70j2dF28SWQVs5OjcBkJNEC\n/vTPY3Aebk81b1pi6Dn6zMvtcM8m1TTYakpdnqZK6Ec4wmXye8pFxkvjQu57AKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUU9S/y1IjvwmZvdNSMz1gplrqqt4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDjcF3ExSxVFeR0H\nJ0h3To8wCgWiUPYpQwiSRVgdFClXAiEAr32Lx7+G6wMhymojube/Ce762uS+sYHY\n0aXFqky/8/M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7103", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7103` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAXx/5KOY6Wf9NbyqCK6M+MvpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlY2UyNzM4LTU1YTUtNGZlMS05ZTViLTU5Zjg3ZTNjMDg0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA3YTdkZGMtNjZk\nMi00YzNiLWEzZDYtZjA0NmVlNTFhOWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEW8jyTffMzMVNXu+goymSPewqy3qQSQSjWXmnH7h5NR1bxDcm8Mf01W9imJQ\nRt6iBH/G7AFllRRCAyEPfiP8gKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeki6dYIOdBghbEpCihPzlhapN2MwHwYDVR0j\nBBgwFoAUYLKR28zQltf9JYGE4MrN/VlvzAcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEApgc4nJ6OoC84WJfsadwPzPsb0WZ9oUSJ8PMLXap4\nlmECIQCd9iPRNCtACJXwLDDEXSX7phgvAan9rH8NaCbC6Ju0OQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa+PJ+lS0gCi6v9BnExbU5MAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZWNlMjczOC01NWE1LTRmZTEtOWU1Yi01OWY4N2UzYzA4NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8JAX1gLeuzReTeOZTAz7ivp0VMPPCYbw20qvaiwH5An6y\nyNb9agdP+mp+rdjRkzsGPFpxsr+yItQy4AZCk6QPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYLKR28zQltf9JYGE4MrN/Vlv\nzAcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgagDJjfQemAYP9MA8TM6xBqIaykFaXOvaBpxh58QPzF8CIClOA/M25s/z\nUHrfOINQ2DxWQy3Yq1QSD6G3+BhRsMj5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAS/YgnU0LwzE+RRZh52smc9lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA3YTdkZGMtNjZkMi00YzNiLWEzZDYtZjA0NmVlNTFhOWIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGM0ZDhlYjMtYzliNi00NjdlLWIxYjAtNjdkOWE2Y2E3\nMTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0X5/z5p4S5glWKtVTskJEwfo\n27mRN6ztL2wNSoJeVms6ONeE0ZLf1sCCZWJJeMuKG2IGqiSDKaDHz976W3CtkaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeki6dYIOdBghbEpCihPzlhapN2MwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICxxnPnJNnETagnQ\nQPo+aZ8w5Mqk7XHQr1d/jNe9GIKxAiEAn2Fc/8pM+7DQO2IXukpJOWU2FEQf4xOO\nzu1RFr+JgwY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7104", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7104` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAciyB4sYjapjv21hB7ZKDN+xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyMzUzYTNjLWFiMWYtNDZhYi05NWM0LTlhMDg0YTk4NTg2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU4ZjdiMTQtNTgz\nMC00ZDdiLWEwZTgtMjYxYzM2ZTNkNzI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3M8cMf8N2T4DgMMyjo+ouGc07guYhebGsfCBhNGoZ3B7tmd+KSOXxcN+Amz7\nUu3mOKWyrPjSNjKr1KeTubxJu6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF1v84/ZTXUDDD1RjhnsCPY8YO8swHwYDVR0j\nBBgwFoAU5QOBKRbqWM4ydry0WI54g9MRkHUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiA8AA3W73kgQKqBvCEGPxa51X/r8R2+7nozZTHz7fo1\nCQIgeXlFSE0DrWgtS50VR5NlZxnCt3zXc/1EONmiCcldWKg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV+dQuPuWl6tL2euJyELM38WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjM1M2EzYy1hYjFmLTQ2YWItOTVjNC05YTA4NGE5ODU4NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQT5tsKcVE7yZUF5ppDdBIEmwExo/O2PNKtkKe8OOQd8y9p\noSW6uHKXOVoADjipoW2lKz1ZVSJPvvUgpm335cFmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5QOBKRbqWM4ydry0WI54g9MR\nkHUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNj1RB+g6ozJmZ/jrTK/44aamqK1pJtI1j/7bsrIrlNECIQDWQ0DlLrOQ\npFir2FOAW4KlnBIsZIufmC932PAiJqCdjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASj/4SA/cwb5PNispX12c1vNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU4ZjdiMTQtNTgzMC00ZDdiLWEwZTgtMjYxYzM2ZTNkNzI3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWMzYmVkY2EtZGVmMi00NjAxLWJhOWEtOTIwMjRjNjEy\nZTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEmBh1tVWy+ml2S8k/XktbhO4\n3QBYfk/m0nKBAwHt836rT3Zc4kL8Lz1BB0TDQGSpbaNO8yEQ+SLZPWISg04cWqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUF1v84/ZTXUDDD1RjhnsCPY8YO8swGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFx7dP/OLmX7XA7H\nr8SYywVaTg4/1R9Fu4t25s/QEdhsAiEAq8f06e8Zg+lqd0ZFASBwlaLDSJ+VWzuU\nPbNusfG3BzI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7105", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7105` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAcAECsKlr1Wb+Ap9y3Yx3boWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2MWJiODQ5LTBlMTItNDdlOC04NGJjLTI3MjYwODI2MjQ4ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk2ZjJjZDQtZDRi\nZi00OGRjLWJhMzItODI5ZTYxODgwMGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1GwWQZ3O1Z+xb0A1FJuCKGRS7avNpP/uq0uHvAhCmlUlJFAoYroO8K5QcqHo\nquUoUyymWxdNaSyv4xwaLaD6z6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/DtKE/aqw6vgicvV11bXg3II4jowHwYDVR0j\nBBgwFoAUPlpWTyaX1UArydGE7kktI1Rf5tkwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAwd/A8dod6G/jFIQjU2QBQLiv3NOB/1YZaHLtD0p4f84CID59\n9jn/f5GR81wX/ipIOY5ZsE59ean8kommzflFoRV0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW5o0DgzAztVtEq/kIr3Hs/FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjFiYjg0OS0wZTEyLTQ3ZTgtODRiYy0yNzI2MDgyNjI0OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXDybO7z1twSiQkyPybK2UCmSdX6+1iKeQjQg/JjFJmd8k\nJGWlpyeeLAw/76ImxG79YzrkqkrQqxtASK9dWKU2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPlpWTyaX1UArydGE7kktI1Rf\n5tkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIIRJRhbk6O7IBqITmcxojA67j7xs0RUHquDz8MVVHBmAiEAssVd3BZ8\nkm0T8LikwPHXim3uhIpk4AX+bJWPQkISegk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAZMlhhlzvR71rooA/BeUBGWxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk2ZjJjZDQtZDRiZi00OGRjLWJhMzItODI5ZTYxODgwMGM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2Q2N2FlNGUtNTM5Yi00YzdkLWI0OWUtZmI4N2RkNjVh\nZWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEERdfg9nHvMYNQrlgRFAIa76h\nmaPdV1KnnkgtxR3eDLBj74yVt1e9HvntmdvCG5AuqMcaenNT0hRMyNuSMyLsF6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/DtKE/aqw6vgicvV11bXg3II4jowGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC1pKL8UZYiBn+w\ngeLYFzU51yOeRf2KWDGEJ928TrU13gIhAIZV7KPLuFPHuvAhGYOExyOmWMh/FWrR\nL3mGT78ydziE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7106", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7106` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISATM6krOSOsvQVDN4876qYhICMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiNjU0OTg0LThhYmItNGY0Ny04MGI1LWZmZDdkZTg0OTJhYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJjZDcwMDYtOWM3\nZi00ZDFiLTg1MGUtMjEwMTYyYzVkMDJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwmD79pLnW8wT92RzUjLD1zJt/OxqwnqNQSfKnay2Ime7NR7+ef6JdMAl5hFe\nA8jpTzo+HbG8D0YNtxTdNRnjSaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEITtKcu/u3YaDj+bg7+GbHSKZqkwHwYDVR0j\nBBgwFoAUSQFEmw7KQSI2AheUb+NH+46Is4AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAlpfoxO1C3KeqIKYbFJUjltcdR9GL4j3Q\nQLgaggHvxJcCIDyWAfxco04nvRLHAQP1/bKOg9r070OJG+8wQE6L1WwP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWjsapMTU8mpo7s5oxVGdtGUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjY1NDk4NC04YWJiLTRmNDctODBiNS1mZmQ3ZGU4NDkyYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOuLN0vVM5sF4lAAUKGJ6khh/3Lcn9BYlGpBXWpv3+1VR0\n6cwAeELVzCFwqHk+3dOAU7IVjHhWfK75TTay6ebVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSQFEmw7KQSI2AheUb+NH+46I\ns4AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDuHBL+MST1ZFge0Jhm8xfAVmbkCscurUOiisjeCUGVwCIQDZuEx9b30+\nfk2jbdKF6dOmvI6tJiBpEwKSSq60b5HkCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAfQq3dYsIGj9YNHJG6MrMz+rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJjZDcwMDYtOWM3Zi00ZDFiLTg1MGUtMjEwMTYyYzVkMDJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODhmZjRhMmEtNWQ5ZC00ZTQ2LWIyZWUtY2RkYzcyNmQz\nOTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZflpjgGkByHxQe82s95O5QXj\n6yWfCTDCgPET/+lowpQ09hz2S3wsYHXfb87EByPlXpLF2KaTYOcqby/7ytvP36Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEITtKcu/u3YaDj+bg7+GbHSKZqkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCk71REGMWai4Ms\nax/c2XVYRajEOKBMeOWNtDG33GQISAIhAJELzEpzaXlp4BFzjuZScHLF6Tl5i5jt\nYhyqFS/06maf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7107", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7107` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbI5xefsl+Z/e+9Z4x6H5YftMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljNWY2NGExLTQ2ZWYtNGY1OC05OTI0LWYxZTFkZjRjMTczZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ1YWRjZTYtODYx\nNS00NjE0LWJjOTAtMTJhY2Y5YmY2Yzc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEOy5O3bEhslGrHojhR/gfwVs4TMxozxAYNApby2CzW/uks5Eu3Gdi5r/3w4b\nSP9KCsY6oM5aAdxS3B14BNjot6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+wfYvTD0ZsP3tB5RbavM6GPMbT8wHwYDVR0j\nBBgwFoAUFvOCAWN2V0hZjeV640uikKOmaxswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBUPZQlDuAbw5QsxuqOF7/PdynGhhD9E6iy\n2AWykcwoWAIhAMTtXAmDGzsqjLRluu/cxSOK+oYa5E6tWVsSYuv1KNwQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbfdUxCd/Lg097byfJCC2bLJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzVmNjRhMS00NmVmLTRmNTgtOTkyNC1mMWUxZGY0YzE3M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCXPtGvPfw+S9UqqBqf5+t+tTdH/IdDAmVkSOA2yFZlNzU\n2M5lv8MM4bBCFgj8e4C0Cm6dtCmT/PVhESxb1P5Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFvOCAWN2V0hZjeV640uikKOm\naxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMOdNvx9U9KTbAljT8TZE4r4JFABJ3jMP5oEMroSnjouAiByULR5FQAO\n8LHxAeSHZbAKPHmT67eAtz6ZhMlQYlEQpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYd7XI2R3dTrVltTx1ix7iIVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ1YWRjZTYtODYxNS00NjE0LWJjOTAtMTJhY2Y5YmY2Yzc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYThlNmYxYjQtY2U1NC00NTlkLTkxMWEtNjQ2NWJhMjNh\nNjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKaMV2x/I8nnZ0nNk4rZx04LN\n/ACzlovzLVedfRWt1x5CcNQaH/Tw/CSqOLRl0h9E9XgBiYhSQUD+80v+53QHgKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+wfYvTD0ZsP3tB5RbavM6GPMbT8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEi/bFst9VVDKRo4\nefprI1ut4v1ERX3EgSCuHf6UrNdLAiA2x8D12uJhgpf+8VMRN1Mxc4fXSuowiGQL\nq0mgV6vP3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7108", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7108` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAXQLj3qtssoQ7GQTsZZMMbN4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmYzk4ODYyLWM0ZDEtNGNmMy05ZTljLTMwYzVlNDFjMjI0MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjlhYmJmNGEtZjYz\nNi00OTlhLWJiNmItYmE3NmM0MmQ0MDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjZIe99PzCf9YuSv77vYK2YiEP/+2YAbshMB5lQirzNiIh/rQiozH2ElyNao9\n7Ghhf9Oev0SPG6CgLYWevN8y/KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTwnc3yEITd3h+FNZXhqZLnfL2tkwHwYDVR0j\nBBgwFoAUHTe9gF+JMWFgqmvelM/OXD3f5QIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEvRHtUbT2IhwvmkVG5rTTPgJ4wm\nlFoEru8YfmpEPEFQAiBolK+DTC70x2XtBPXn7qvQJ1yG7ds6f8rIG8L3U2Vu3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAewtWjMTMxpVQGZn3e4azxjiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmM5ODg2Mi1jNGQxLTRjZjMtOWU5Yy0zMGM1ZTQxYzIyNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNzBJqP902rlIft8U9uMQuUzTeUb9VmF5hijTFm64IGVl2\nqwdQBDubeZFhzfhGsrXDQSkCGlA8p3d9t9br1cKFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHTe9gF+JMWFgqmvelM/OXD3f\n5QIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMGKhCWBQpjcLXNey++qDWDBaii7aq/Psusg7UyJiqkXAiA+cQUDVzuh\n4qcEQtqySQ5cujmY3XmteczekIRCZzsyMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAXOMWZD5wEQZuZAGkAMJb9Z0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjlhYmJmNGEtZjYzNi00OTlhLWJiNmItYmE3NmM0MmQ0MDQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjUxYTBiMzktMDhmMS00YmZiLWExYjYtMzkwMDI4ZGRk\nYjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5TrKmYgYqg9JSdbXiW+irYrY\nw7FJe/ilcf/yA+XpTcSEwEIn7R5K2iXqvdFImKNXDe154T9vILsCQnoHLlbgl6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTwnc3yEITd3h+FNZXhqZLnfL2tkwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICNYWuE9ohSz+YHR\nxHuPM6fwhVX6G7A6r7EwTPyYmgr/AiAxoZrqxefZG7bCL/r1QV5ToDP/rqBpJFP0\nB9OFxMrylQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7109", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7109` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAe0WlQT0MWlIyCjdNtrKGeRGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZTI2ZDg4LTMxYmUtNGFmMy05ZDI0LTZiYTY2OTJkZDNmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZjOGMxODktZjY1\nMy00YjNhLTk3ZmMtYjgzNjAxNmNlOWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENswNsaMMeK7BAMnFDzGvEldkfbosMtDBKPVPeZbtZJCDsrIxxub4f97CKebj\n39EQVv1h2KBx2HnxtZeBFwHIVKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXHqhWNVxa5hnjXJNXRNesWuKxQEwHwYDVR0j\nBBgwFoAUT/h4z+b0WWZH7VFuwkQHmQ8t6MkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgJ1UHjOr2\nhrDrKhhkWgxhV6v1RJ66PivaBNcUaIgd+ZACIFx8XDMZxhtYOAYC5Sujs3bs3cEs\nKc4XDn4RUWVqqGLU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWMGsCB/tbiNJ9QRoDsIr1cBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmUyNmQ4OC0zMWJlLTRhZjMtOWQyNC02YmE2NjkyZGQzZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3opCo2mN5NqFewFe+vrVtCn3TJ74ERKpkTurzLtJw7eTd\nXtPMD9XHWQmLasW8aPxsaf7VsyuZsQR6nffSxjxdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT/h4z+b0WWZH7VFuwkQHmQ8t\n6MkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYyfTTGRL0SR8hyYnKCmaRbg8gJLUGPqi+TaOnPpVGRACIQDNf42VNBbb\n07q/JhekyxfOHibuYFkd8JqEzejGc6JYIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZc/hiTJHHFEdQ+csZZS1T2pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZjOGMxODktZjY1My00YjNhLTk3ZmMtYjgzNjAxNmNlOWFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODdjYjhjYzEtOTNlZi00NDc0LThlYTQtZTJmNzRmNDY3\nYjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV3CmB3lY6R2YTc0PfWQt+/ev\nLQX0E3OG5PAeU/m4YSIBV56GmZdm/gdUHHL5+lY6bJM282c+tPMbVgcm161u4KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXHqhWNVxa5hnjXJNXRNesWuKxQEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAPbal5NzxRVImYj\nJ6Io6zqjlyd3IeHNsXxgw359mBLqAiEA4MfaB+2r9uP7gJszj3K19x1U+nnF7kd4\nVjKP0TpVmYI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7110", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7110` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAYYhRctCc+as59RC+SF6Nk2hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1NDk4YTZkLTJhNTktNGM2OS1hNWE4LTU3NTZkY2M2N2QxMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGMyZTNkMTktYWI2\nNS00ZDVmLTljN2MtNWEzNjAxYjk5ODNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbBDuS6kd6r9laUmSf3HaliZggHTKWX5yfyDL8IVZM+E7XJRfCSpMNp1hoa44\nv9lz17Mv8nlMpMUolDibMz7IJqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOXZn6NUg/HI/NxzPGcZOmxDZ3qIwHwYDVR0j\nBBgwFoAUzzfJDM2+tJD62b5s6B9yttziF4QwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgacsdggfs\nsod/+mGVJ2iDwa90EV2TCuZXfrCYyaKQUqQCIEmO3i3fc4j39KUOMV9ApplZYAbp\nRZQ8mNnxWFMWjnf1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZUeQTeGibLGJ5feZLsSPo9mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTQ5OGE2ZC0yYTU5LTRjNjktYTVhOC01NzU2ZGNjNjdkMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyOoQc5+eFIjntk8gT16bwYbrXHFtRZEuHE6S7mX0Uumjj\nCP6TjqFXAjhzkdZCAbCytWLJHq5ieLiFbkIra3Qeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzzfJDM2+tJD62b5s6B9yttzi\nF4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbGsVmgDtom1/9J30jiYV9qvdnuuzhfFU5y28t64AbYkCIAEhQ42GwJFn\n6B7dlfxMr1jp/9liWo88J2sXe5Hre1it\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYRLVE17KpdL9oJAm/+KiTN8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGMyZTNkMTktYWI2NS00ZDVmLTljN2MtNWEzNjAxYjk5ODNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmJlYWM4YTUtZTdmZi00MzUzLWE0M2QtM2M4YzEyN2Ji\nMTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfarvRz+WMquKJk6lutt/mbwI\njdA/E3PM926ri85HTda4I5WtnUmgzcqlDfwoPA4WI0kQoNDhqzSk2pcvJ3b8eaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOXZn6NUg/HI/NxzPGcZOmxDZ3qIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDtD6IN4M6ob3E3b\nF2Ol1k6qJN8F5WoaXTW9oJIiwK2aAiEA4lCjvcVvljSGqJRN8PrYOSirtTIpn4kS\nzpuIX7T+Z9A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7111", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7111` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAXSc6DvHwHLSsXOxO7eTMqz3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhZjZmMzk4LTFiY2QtNDFiMC05NjJmLTUwMWRlYzFhNGMyMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVlY2RlZGMtYmIz\nNi00NzdiLWFmNWItYjVjODRhNzdhMDQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp//VKcbf8YPT0fCmFVd68/ixoiIgQz3+puPmi5IWg4L/cCx6kh9zM2ZdY73r\nQj4vtWOVOJLXn3TN2pepAQOF4KOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr/aHYVbkVEcvSnI6l+omMTTVtSEwHwYDVR0j\nBBgwFoAUjI0IfWhleUSllwClzm8fprB2AwAwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIF28ZmQW\nE3v1h/aIpRCuEnZ2ARxVoB4TOC/ZRxg3ICf+AiEA3/nFDVRexRNLH7G6ppgORR5z\nCOpmAgLl5z4g5IzL3Rw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARqCjTbNPHfhfVK/ltvLrQtiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWY2ZjM5OC0xYmNkLTQxYjAtOTYyZi01MDFkZWMxYTRjMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjDcP3iigFdyIEt+K6GWViIEeZsFff+gzDAr6r6DQQ+y06\ndyWRohoZ9uWuSfX3JEbeRH+T7qTkvK53ypPfLeLho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjI0IfWhleUSllwClzm8fprB2\nAwAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALHwJGMHSvCT8Mun3uqLBNmxeTTG5F3Xrc2BnA4dELVqAiEA6IkF9Ezv\nHuQKLEIXc11E/y3tejGjhVB09CIhEYCJvfQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAdb2IM3ni2Bo7WM9ru7k6djjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVlY2RlZGMtYmIzNi00NzdiLWFmNWItYjVjODRhNzdhMDQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmY0MTA0MmQtYTM1MC00OWRmLWE3ZmYtNmU0YjY2NDNi\nNWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETqHWkZJZUwYLYvMwkdmwk4Xs\niJjNfEs+MoBJw31dZnh3TNPuYXouUVQ4saQsJEJ/qPzVQSfQCFBVM7wiIOUsIKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUr/aHYVbkVEcvSnI6l+omMTTVtSEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC0XDTEksi9RrHI\nsI4wMgupeZ7Nx88bLmx0NW3nfzBWqwIhAKEpSLuBayhzo8rvCyjThPQeHoRnNRkW\n2OOkTHn1JoXM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7112", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7112` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAT5dQcpVUeNyEhGfjHs0jMe9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwMjRiYWMwLWFlODMtNGIzOS1iM2FiLTIwYjg2OTFjODE5YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY2NWY4MDAtOTcx\nMy00NTI4LTk5OTgtYzMzMDgwMjFhMDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV+dvGdBvYz/eKVx7HWAPtKQXKUntlZZOxruS3SQRiYWnO9gKlVlEj/uhdto4\nt81HM3ErdPEKsY2gL4nSKj6Xj6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4EoenKnnjWdua0V6c8W+KD6N+98wHwYDVR0j\nBBgwFoAUD/YS6k9USV3W1g5SQRnANcaWsCwwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIHKgVfKhxbLc18wyWmgxvicXb3GMJHaVNwQb46xCehZ4AiEAuGDb5dFP\nOBS9Dv3kf3IGM4wP9FHI65i+C6FC6ZmNilI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeZ1jvAr6PLOfdbvmF7Yv5BeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDI0YmFjMC1hZTgzLTRiMzktYjNhYi0yMGI4NjkxYzgxOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvtaM+xUds6QkdyIMduuY2DNIUxuwHe5RsgJYYrGxKIF/H\nW2blHZjquzabhrFlVjWeWCN/dMKHGWP5VNoFYbndo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD/YS6k9USV3W1g5SQRnANcaW\nsCwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIgahdHPZvX1MBEf8kpP5fpgRWmAzXrls+W7mVRwvP7iAiEAhn8wXAUj\n/zbJrB5kpZFYERbCFg6cKPuJtUYeWUKY8+8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAeoZWxCenfQL8Ic7/lUZxjGLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY2NWY4MDAtOTcxMy00NTI4LTk5OTgtYzMzMDgwMjFhMDliMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWE4YjNhNDItNWExYi00M2E5LWIxYmItN2JiNDZhZmY5\nZDQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEumf7IS+de3vFkfWWptZybOia\ngfBPJn/rqbc1qZvGG4thogjmkVHyeFNRLVsdlH4zftqnQVqi45YQvDVniVF2VaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4EoenKnnjWdua0V6c8W+KD6N+98wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHflvb68yu8YiM6n\nIX2b3rRTPzee6DsavasTDtBkpRvYAiA2xbaLYRu/HlnQlxFmdhGjKMoSl2yAdAiM\nvQb6uSg9hg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7113", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7113` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAdz+9bDU33AUGUz2pdJV8WxWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlYjhiZTQ3LWJmOWMtNDc1NS05ZDM1LWU2MTA3NjYwYzk2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVhNjJlNmQtNWQ4\nNy00YThhLWE5MmYtMTE1NWRiMjA1ZjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgKoiSy/PPmJ5B1KBqFvIdwgjHOVxRkXmmzt/uC1gBZNnVYn45dgN04EXHfHL\n8FAg+EyOijud/Pqqpc2596BfHaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK6VbdtMOw5x+xfoaCs8nCISVmTwwHwYDVR0j\nBBgwFoAU4RD3rlOKj5dYGR2okHpqXkBl0G4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIAWdxM9MkYUjxCuh6j9/ZJd7lU8cSvg4J7skeOlU2qSmAiBl5Upx9qk0\nGujZvP3p8Kd5Ty80kud3BRvZDZqfYYg4fA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU0y39dGrsZGTrBZYsslKS3XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZWI4YmU0Ny1iZjljLTQ3NTUtOWQzNS1lNjEwNzY2MGM5NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQz46XJNvo9XDHmktZEiYRw8paaqP8Z7CINXpk2NsoaeK0H\n8EXzgHoDLOi1OxBwotHeyOI15vdZ9w7m+xMsHMbxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4RD3rlOKj5dYGR2okHpqXkBl\n0G4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIIPuHF9GkWnLg6kIdzJgkcveD8e7e0HTt5EIFVQ0AnQCIQCyUbC0JFbg\nz2jkrYESYIrcpzN7oTbsU4Tdl7U7wR7S3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVQghjVWZS9lB37DdrdmXkZOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVhNjJlNmQtNWQ4Ny00YThhLWE5MmYtMTE1NWRiMjA1ZjVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGI2NzhkZDQtNjMxZC00M2RlLTlhYjItZDVjZWYwNmRi\nZjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM4uxepqpUHavkVY83blVFHEs\nn5QiMvL/VqHaBK0VzWia1n34Z9Ce2v08XnB4nFOSX1fg26sJEeD+Phf6rHZLtqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUK6VbdtMOw5x+xfoaCs8nCISVmTwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCID6cnYbnxVnfrG4k\nue7fJQHv6+9yOHoJcorrFuAXVKhWAiEA6AddzPZXx6IuRKr1WgDRjUzy7O/UFB+j\n6za/U12UrFs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7114", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7114` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAdACpBKjMG9NI+vdM8OlHTnWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2YWRlMzJmLWFkMDgtNDVkOC1iZjg2LTMzNTFlNjQ4OTAwZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBiMzBmM2MtOTll\nNS00NDY4LWE1OWEtZjNlM2I1YjlmMTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOkc0FHYFQcCATdGFMPEQLqxVEGPL41EFoL61d90SJuf1MIx+bGlaJQpihK0A\nhvaal0Ix4X+jh9cUpSwwcEVt46OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURwfJ/m0AyCVrgQhcOx1cBZcVP4MwHwYDVR0j\nBBgwFoAUlBW9eDaCEzJ9ZOFKE/dZrHIS66EwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIGnU22UUl3V3eswuB8EnVVANSQ81AnaDMiJTiJjhhPO5AiAgHXlvr59MpfSwIP3x\nAHOjEnXhJx1/WSW8dfikecov/A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV81q+YQLFTVtWlCWtyBIi4MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmFkZTMyZi1hZDA4LTQ1ZDgtYmY4Ni0zMzUxZTY0ODkwMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP60Q/6VpA+dDYMExqjWcELhmNTiov9aGm3sPbLtfVoL5V\nBQgxGWR02iSndB6WN1uCJKzIJqlEdvdzrT4dgeSzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlBW9eDaCEzJ9ZOFKE/dZrHIS\n66EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgan8+Ka2otkq8zPp7Z1j1TqXCNkrTuHGJ2wvxEbbcFNYCIBHdCkcXd137\nYQfaqlYvIzfmIzdlSzjfq+98Z0KoGnay\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAZT/CMsi8auWHYqX3ezC6iHZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBiMzBmM2MtOTllNS00NDY4LWE1OWEtZjNlM2I1YjlmMTY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjFkZjk4Y2QtOTAzZS00Zjc3LWJlZDktYWQzMjg0NDQz\nNDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEERcWnIhqN2eYQUqP/GaOVLTo\nbsagn0+3HlWMZ10Z4YrLtMGxjI5+8yosax3IlmM8rK2/s4pAMlUCv8VtHiX6L6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURwfJ/m0AyCVrgQhcOx1cBZcVP4MwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDhvZgJ1s3ruY+J\ngKdFORA/rgCu9eVn/BKymek8Qne9/gIhALFJgEA3YauPClcMcPbhQtqdsDzvxi5Z\n10+QG1pbOaXi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7115", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7115` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAcg0I92oUS4od6E/IIu+jLXUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NmNmM2NjLTg1MGYtNDdlNy1hYThmLTQ5MmRmYzU3OGFmYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTAyYzE2YzAtNGU1\nZS00YThhLWEyOGEtZDBhNjQ0YWRkZDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzi+6rERuclvgAR64CIj6+kxM0rMC1n12uI8tUlYQKizntosOYJT//Kon1PsM\nTIsNIqTGSlSrDHbpscfBTH9MXKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfMT0eG0hRWwNUFbIw6Sk1XO1/vAwHwYDVR0j\nBBgwFoAUrOYCwXhdGbCJbxiKZC/r710ocJswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDmuFdSxIHurnqQ1xP8v6qfADXam5THaBSmhp//3kre9QIh\nAMs66oSBFRQ069N7DpjnCc7fofEiZr/qGUItImy+Jrc9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbJbEoXm0tCqPD2jUDsFO4+XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTZjZjNjYy04NTBmLTQ3ZTctYWE4Zi00OTJkZmM1NzhhZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsF/Is4y+AP0NxP7mSnRx/RkTqkvs7yGV0ee8hHKzLxsUH\nz6h4UAmjzgES8L0JboYBDz6MBXiRDF/r0Z8PWrYao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrOYCwXhdGbCJbxiKZC/r710o\ncJswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFVHxpUZLpoo3syOGy1yKFRg1tazKU9G8yGFZ5UkLvQMCICdRSjFaZGm2\nTANwIk5b9A3/2ZgqvU0UvUq3cX3qwppA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZYxeE12SysoPoIZpoHaMKl/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTAyYzE2YzAtNGU1ZS00YThhLWEyOGEtZDBhNjQ0YWRkZDM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzMwOGY1ZGUtYzkwYi00MTAxLTg4ZTYtZGU1MWNhMmI3\nZmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEISTZOTIFqfFcwqrc9pJQc+ro\n0w/cJGCOchXj6mlvrYJsf91FadDMX1i207tX90sx4tz7AVcfvSQduJSzk9EUBKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfMT0eG0hRWwNUFbIw6Sk1XO1/vAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIE4H6JbS/CSKJU6c\nQzdu8NbfwAFsYN8giMUd1Mo5e6ToAiEAtfNDvYJC4NdQeLSzn1QLBtL31OVuVx0P\nL+dZSCoDacQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7116", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7116` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAQzzXeFVXDpl4Vv1Q8KL5xz2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkM2IzZWZkLWI2OTgtNGEwMy05Mzg3LTYzMmY1Y2FmOGJjOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE1MjE3NzctODM3\nNy00ZjkzLWFjYTYtYTQ4OTgyYjY5YTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUtGpgGCZ/140yq5LQjKObHT9Mo9zrmt0CjQ0X16PtcCrj74JfUECeKNZrKK8\nsDPs9khUZ7dSvWfNOEnUUZfLLaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOE0dWXRYqg6iHgEONJOASWWpFkwwHwYDVR0j\nBBgwFoAUSBA9QqtSk0ntqKzproB778rRvI0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCgbAfUjL4ahko6JnELfH+nwRTKaGpvNj1N1Oaf5+Wz5QIh\nAIAEGQRHTr+2r48+NoJJqt1/r5JYW6LAq4Zes+s8jb+1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfD74y1WK1AnYynJ0Zaxz95AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDNiM2VmZC1iNjk4LTRhMDMtOTM4Ny02MzJmNWNhZjhiYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSdjRtXIBl5PcBph4iq61purWAnqtmVriINmT48b6Abd6I\nY7vV9NTpWx91sMx+SWAKgjv07AA0AMrKlBncyE67o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSBA9QqtSk0ntqKzproB778rR\nvI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJqsMLgLuaDxflgLMC5faV00mgK29zfaoCjyS68JcST8CICkCKgOYT2QE\n2db+HYbIYZf785DxdyxUzHc9CaVCNHAV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISARHemguEIl+eM0J15EcV0lttMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE1MjE3NzctODM3Ny00ZjkzLWFjYTYtYTQ4OTgyYjY5YTk1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTllZGJhZmUtMGU1Ny00NGRlLWJjZDktYjc2MzY0ZWEz\nMjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKV1pt2F/3XYeUbZJUFisgn4l\nROH/hwrp+IfrenH64k1KpGT38gAKAKzx0j3FJo4IWE/WphOG4L9pCq2LZkIhS6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOE0dWXRYqg6iHgEONJOASWWpFkwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEn3riPggTZmL3Ld\nWUKLgHv7iPy7eVkx8mgXvRpMBrYMAiBlnxZQpUSNUkajNlG3iWM0affAG9/VRp4o\nm7W+wJmwuw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7117", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7117` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQyxc1/BMSdRUvwHISkMTyWmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwYjRjYzExLTY1M2YtNDQyYi04MzcyLTUzNDlhMzA0NjQ5ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdkNjljYjUtNDk3\nNC00ZDQzLWFmNmQtNzBlMzhhYWIyMTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXhSIBgIW0w0F+/wAn0pc029cjXKRO08xkD/ivRIw9ZPPEh+3osozRTSNgs29\ndHHN0e7D03awt7aRZIAwixEtdaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5afD7kn778dHg6tycB3oioZqu1QwHwYDVR0j\nBBgwFoAU5jQTUKhBmIyomNJVymvR5drFJUMwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCICuHei4eE8GP\nOLb3GlmraCzpA94j41WEtbMkRiPbLV2FAiEAitbENGWIzuEbiqsu6VWixgJi5hvy\nLySOoEkhJZhqUz4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQn0z7fVroDDtYbEsJXcQ+oNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGI0Y2MxMS02NTNmLTQ0MmItODM3Mi01MzQ5YTMwNDY0OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+qxE37tj3oa7eNJq4npuIcJZUMeGsw+CBuQda93kzW+2d\nY74KcikMjdMXUvEic9h46CiiRdbEGX/c3JYR6ixVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5jQTUKhBmIyomNJVymvR5drF\nJUMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMlb1Fy5nK5pjD7EcESZbtk0b7TPXFDenPC0LBmhP+/1AiEA4+EiQ4cw\nk1v5fNushowLHypO47WEKIU70f8HK7VX/5g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISARIIKbGiZqOBHc/M8HZcWNF+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdkNjljYjUtNDk3NC00ZDQzLWFmNmQtNzBlMzhhYWIyMTFiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZThiYmE1NWEtNjBiNy00YmQzLTkwY2YtNjY2ZGE4ZGM5\nMWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE10QbqF07Rs84bRidfQR7mKsg\nKJO5PoBA7I9d0b0V97irfcvZ6UoRNtVN9l1qSTgiK7GN+0Xx19LmznWDTB8CxKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5afD7kn778dHg6tycB3oioZqu1QwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBbKgdaVQR1IOoQz\n85amyj9RgdOQraEI0shbKG9lQRGKAiB5KWLeTTYASFiYErg0CNqnYOsq/p5JBWXe\nUmAqPoi+OQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7118", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7118` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAc9Z/p928RkQO7huFz3wjJh5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ZjVjMTQyLThiZTYtNGFiMS04NjhiLWQ1MjA4OWVkODYwNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZkZTgzZWUtNGZi\nYS00MWJlLWI2Y2MtYmY1NGM1MjJlNzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWI7QXYQXrKh558PSbhbfFCzRJXL4pEFSZLh/8lyLQpuhF92+Qaar6hp8VDkJ\neKHRBs9udsZVDmRBDhiI3MytPKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUudFmtouNCOD9qv948rqwwEx1xy0wHwYDVR0j\nBBgwFoAUZse1t5eFd1YIGJsigArPtDx/QIUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIPXLo3ha0P5slzMlWL2p6cpFrsqxUPemJyu43qbrpXiAiEAz8S2QXtq\nZg0ztERSShjEf/KWXTwupzi7VOpKuX+pj/U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATkqGUsdFs+ka1aRW9FK+gCPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGY1YzE0Mi04YmU2LTRhYjEtODY4Yi1kNTIwODllZDg2MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2fQFyrgIWVNJfh0/auRPHkxRm9aVXRKzh34/uKFhfCh7E\nEAan3rekj8DnLfBqT2Q2KXbDP7itZ47tBuqZrv6Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZse1t5eFd1YIGJsigArPtDx/\nQIUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQkbxtv0PKCKRPe4hB1D8tHPGABiyB/spGjaXVsYyM6ACIGncffdrDwb9\nz5nYmuMFwr/r9LKFx+tBlycHhsoOfSOA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISARSIWFY7NslRhPOpWtNv9dFiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZkZTgzZWUtNGZiYS00MWJlLWI2Y2MtYmY1NGM1MjJlNzJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmZhNzJlMmUtMzU1OS00MzU3LTg5NGYtMzVhYmI4NDBi\nMTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKkfMT+BTU4lz3FHsUKqKeYH+\nTq5dhxMyV9LsnOiOi2iEGcqCnnlwKFP62m1+zNdRmPS3jxNdhvxy/6znkiOH/6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUudFmtouNCOD9qv948rqwwEx1xy0wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCiRQpSkcMPO294\nm2F8xTjez4Jt+XS/lEpwL4Aw/xac5gIgNuzySehzyIumGPbZP2oZItng1ovftlMo\nV+aiJOx7GUE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7119", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7119` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAY1XkCIahilhk+VMC7Nqlh4/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxY2VhNWM4LWU2YzItNDdiZi1iZTQ2LTliYTJiYzliM2FlYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU5OWRmM2MtOWM0\nYS00NTEzLThmMjMtYjEzNDNhZDBlMDc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExixMQHEgFCTUXd0T9ltjRQ4u0CfWknYk4c+qC6+2cA6lhhFoNcELiwVmo2jb\nbnJNXDcFmWLxAx4c2TjKyn4P1aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCjZ8P8VvWWCXmwPOTxvI8VrZnK8wHwYDVR0j\nBBgwFoAUCtIl6HTQJF2ayHwcJs7ZC+cv/IQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAN3DSxoDxpHtcesIwt3Tc5x96jhWjg/94RSlivz5abhzAiEAu1sjt9Qc\nhju7oc/k4LjpTgCXt1by93MmmTf0i0bAt/w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf+m2lGw2+pqW3kACKzKhZKnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWNlYTVjOC1lNmMyLTQ3YmYtYmU0Ni05YmEyYmM5YjNhZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0ilgtu6OIkliLhClvsQWE0QOBOLwk5AzeSAYXGelXfWJh\naHws56dJyO47puazBI4SfdDRLwg1KQVof8ar47eMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCtIl6HTQJF2ayHwcJs7ZC+cv\n/IQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI5tST8XB7caQFhJtNSln00acJT87Ky2Tg/q0Z/J9U5yAiEAh+bGZ8JG\nxpolRsWZaQukRmstSSy2WN+gxlkrQ6wHZTE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZaUlmUWWOj/o1VUEq2AsEvkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU5OWRmM2MtOWM0YS00NTEzLThmMjMtYjEzNDNhZDBlMDc2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjM1MDFhYmMtMmVmMy00MjgyLWI1MjYtMDA4ZjIxMzYx\nM2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+Atm+45j6lYg3WegBAJm3iRW\npV7rAxueETYId2Ma792C37P13XivrOVDqyAosMArjEVuji4SwNWg+0k145LWvaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCjZ8P8VvWWCXmwPOTxvI8VrZnK8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDG+dOKjHvIrMFK\nnJKDHWfIhjdDyx2EyQQ3pt8zoLIIGgIgdQa6wpuj2zw3ot3PZhdrM5uIPtF6ANJX\nM1DZRz1QDcU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7120", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7120` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAYJOrlFAHsBEY8Ndwc2sOSxtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlNTlkYzNmLThlZjMtNGI2Yy1hNDc1LWJlZjYxZjY2OTFjZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJhZDg0ODUtYmI1\nZi00ZThhLWE3ZDAtZDQwNmY5ODFiMmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/GOwpN690gtcTgnWx24IGKQPP4qBOw6T+as/Kw9jabqFyB9pXa9J++y8GIoU\nWjfCV3HDBacrVNsZfZhsMMxsRKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU19sCsJ5mH444I+F9e9UMNEM6QO4wHwYDVR0j\nBBgwFoAUZvLmu5U74R2L9Tsw98+QeFLmqQQwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCE359oN0mkgn1fugtq+VUZHInYDDNi26FoBBZJw2M6WQIgSZa/w6zY\n8rIh7DlYxr8Rj576TeoERCm3KfRRqa/QOcg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbz7J0HJjzwM2MHvQE6k8gweMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTU5ZGMzZi04ZWYzLTRiNmMtYTQ3NS1iZWY2MWY2NjkxY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNoV51jQTEV1dsaJrHN9abYNNni1RviQkX1Ee04j8pc1fW\n3eadSyjpy3611GguX3377cE8NjJbT2pQreRBbmXDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZvLmu5U74R2L9Tsw98+QeFLm\nqQQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJleeB65xLvqxqwezIRANhzHhjECjDxvqr/mn/oPF81aAiEAxm/QWNFF\n+TW9z8dr1gSHYtLoEOmf6lsXWuO4l0zewR4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAQHNf1s1cRYemwpGUOTbk+fxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJhZDg0ODUtYmI1Zi00ZThhLWE3ZDAtZDQwNmY5ODFiMmMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDY2OWE4ZWEtZTIyNC00OTBlLWJjZTUtODc1NTdkN2Yy\nNzc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB7YUo5gI7LF8ErQhwdbSceRu\ndjUHVjw2JfjpqlxbUbBSM2zT5ND04jVYGj2DR3Yc8hjoVynLLZsZR0/0MjvD3KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU19sCsJ5mH444I+F9e9UMNEM6QO4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC38eD9by4nzDtx\nep8A9n7LgVaB4EpiernRQ/jwi9VDEAIhAJ4VxdDwv3HHipHzxQN0hBe/oO3y+qOu\nx3xLXleD+JSm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7121", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7121` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAa4DEhxBUxs8e7SeRojmjOJZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1OTMwODc1LTUwMjYtNDQzMC1hMTRjLWY2Njk4NWViZTljMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA3MGZmMTQtYjdj\nMS00YmFlLTg0MTYtMDQyNDhjYWU1MjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaTyA0rQqoEa5Izo6z8ejZ06LEU/oTG+AKyPflkK859VPQUs105QbZniEY83M\nhQACtJlEIr43PE/bDCRMF2iHwKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyjRGQ4c+aMK9qxrWOAt7XGVxwRIwHwYDVR0j\nBBgwFoAUXuqZwqgcesFiJGsAVIGbdQ3Rjl8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC0GD0AxfhfiT7NWYXmK/bHbBfeiFLVAN6U5WIm\nnS7YuQIhAIPcwj8tq0D+7/njA4KnLOiBA5xdzE4bBSO7cKD10hO9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbYSiWhdtRBMdDHfKEJeyg/ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTkzMDg3NS01MDI2LTQ0MzAtYTE0Yy1mNjY5ODVlYmU5YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDM3CP7m+j57Rf/AlL+6OtD1ZZ/5sFe3WhAVAbfT0CiJBm\nGGXP7t+wAc5A9LaNGxo6zhybulYXPtmBG7uHJw0lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXuqZwqgcesFiJGsAVIGbdQ3R\njl8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB41AbAMuc2xfEUNZy0QG/S+WCR/98dzI/L6+PQdjle8CIQC0erMs+LFR\n+o6Ci5ZCf9IZeU6iw5gpaQPIEUUS+h1IfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAW5CeDSaHVBxeppw8DgEr6JRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA3MGZmMTQtYjdjMS00YmFlLTg0MTYtMDQyNDhjYWU1MjMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGIwODQxNGMtYzlhOC00MDE0LThhODEtYmJlYTE4ZWRl\nMGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk26Zyu0wGSggEFnIqZn5Iv7H\natW0m6JN2Ht7wUh/Aw+ULwPy6jZN2B21GbbXUbYTb1/4PhnBfKBgXezWtN6jCKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyjRGQ4c+aMK9qxrWOAt7XGVxwRIwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBmMlx32/h83oB9k\ni7AR/aWx35qAHcjc9uS/aLszag/9AiEA+G4fWK1cpHwdruRKESSTvKF7e2Fg048H\nlfm9TVBoC80=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7122", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7122` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAaSPZdOzRQHL+jr5mrlX0mjMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3OWU4M2M4LWZjMWMtNDkyYy04ZWMzLTEyYjkyMTIxOWRjZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmExZGQ3ZWItZjM2\nOC00ZTA0LThhOGItNjA0YjhjZmVlNGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk4oopE5vgXoHP0heRvknyZsIcNPd2HPXOanX9gso6k5dh8dGIH4IF72dqSvu\n+Svoj0VakywUKa2DkOsOa/iWt6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf+i3sr5lZU4AxbHxTyYg999N6CwwHwYDVR0j\nBBgwFoAUzCTrmXM2rUrdE3GhbQdC/h6djEMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIB42tpAvCt72lenVT8ch2oF1eDVEqhqupsFT14LX\nXcu1AiEAryHp5zCl6rT/9EC3mo0dzzi505GIyxFO2SOiUEyni2Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaAv0ZVP1JeUx1lRAOsvkRDSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzllODNjOC1mYzFjLTQ5MmMtOGVjMy0xMmI5MjEyMTlkY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGercHWZznZvwbyqVMj0Y5Kid3LS5es4gtx6jOBeyWNQ+N\nojAuc5+p9dnUNjge40Bif23A93iARZfZZYhhluQ7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzCTrmXM2rUrdE3GhbQdC/h6d\njEMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLCHxomr5rVochVGCXSW52ALWtym7FSfuZ7maptLbuWYCIEz5tcasswTH\nNZ3IGN7Y7H4k5KhN2CMC8+ljIyxLNyMM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAeXtXp59OyAeLIb1HU4UKWOWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmExZGQ3ZWItZjM2OC00ZTA0LThhOGItNjA0YjhjZmVlNGE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjIwMmRkMDktNDlhZi00NmFhLWIwOTktZDBjZmMxOWQ1\nM2Q0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAES2tStWdIieONHR8hNR6l6VG7\n8yVSEUTrW7nTnPhDlqLyKiidl3GFkaeEwfcJK6ac9meSUG06Fz2iGeNwt9c4VaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUf+i3sr5lZU4AxbHxTyYg999N6CwwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFbM3iDgRqrYBT+j\n7ha1DG1R30toPdCIRB3BkwiK8RAQAiBquPM3hcMP+2bAO+NVsjQ94nth0w0LPJT5\nEu1BPOJOFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7123", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7123` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAY0u+aaldJVfjPkzV40OI/SGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3N2JhMzQxLTNmNDktNDRkNS1iNTkyLWFkYTBjMDgwNjQwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTJkMWM4NDYtZGIz\nZS00NmZmLWFhOTMtMWQ5NjY0OGIyODdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYHV8supcNebI3WXRd+TBnMhfci+PUJYmWCuVJsEv+/SmnMQ0rvz8H32Ht7k0\nJ5yctid3L2Cov1oWhgjGgRJ/7qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaZc6QhX183ggiNDc9lI8Siiv3Z8wHwYDVR0j\nBBgwFoAU46hOqHkh0G9VhdkvpX/b2yArRmUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCaxdLBfYuflxZRuCXiDdl24i8+y4i0ZFBMhJN1qgM6uAIg\nK5e5S/qOWdO0VqUL2DQe6IM89y8o/7NJIvpkpjNYBBQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeWU4Oja6xVB4tpoarzm4MKhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzdiYTM0MS0zZjQ5LTQ0ZDUtYjU5Mi1hZGEwYzA4MDY0MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARf/0at5KRpmgm6RdDF47DIEDbiXHJEkwcULwyKIMFctwDi\n3elNBwN1gXrOSNTFr5dAH6I+g+UDDkRCTgMtN4x9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU46hOqHkh0G9VhdkvpX/b2yAr\nRmUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgebqlGEz6Ee/U85e8Qo0m366ySXO0u9mCwLxOJOjiT4oCIG02Vf3AQvxs\ncH9tc+jrVl7uy7rEdn8IJNM9/v5zGvs9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYFcR2pVfUu+qh9BoMpt+Vj2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTJkMWM4NDYtZGIzZS00NmZmLWFhOTMtMWQ5NjY0OGIyODdiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTVlMWIzMTQtODY0Ny00ZDVjLWI3NTUtYTdjZGZhMWFj\nN2FmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+Xu1BLOgS2AUMHvLuzbMDr/c\neBvaA2NE+X744jkJ8U7rwWxp0HfJpO7UAHeZ82xFz/ZhjHgTU5ZHavEPoulja6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaZc6QhX183ggiNDc9lI8Siiv3Z8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCb9P9jP/dKELOy\n6hHKKOGVOxvC8o9xCJLxmIwowseBEgIgKzsrcX8n3qJAz24u/VaI1NxuPMdPHkV5\n6BOXFKeZUhE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7124", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7124` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQzJoOwW93Wmcr429sSw6bxDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhZGNkYWNiLWM2NDQtNDA0OS1hZjdmLTllMmIzMzlhYjVhNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RjMWVkNWUtZjgw\nMS00NjQ4LWI2ZjgtMjA0NjA1ZTUwMTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+rYBVzuDCvfk19T6ULeCLXI0pli2k0sq1YQeogS9SBt6idcU5RmgyZtRX5CW\nIVKZG+syyW048Z04RAzPyKVGZqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUig2qDchyUtckHwBbeOy13ti7A9gwHwYDVR0j\nBBgwFoAUfi6h0tbOOir7aLIElJa/tZUPvqQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIE2KqMGqeSwDQ11ndnF+JPBFq5oTLf0O\nY5SWJKuP8NB0AiEAsahR+o63/lsgYuphwhrVGszfgQchTM//yruAzDH0ec0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeRxcvUXvRS/kS9PjGgSztOsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWRjZGFjYi1jNjQ0LTQwNDktYWY3Zi05ZTJiMzM5YWI1YTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARINO7qpGHuuhE1nLzRbm4f1MimzEEYj3OGJbF8XEJB+VxH\n8Eo9zpvaUaA7YTye6BAYEDdIGMqcnIzPaX2m6P5Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfi6h0tbOOir7aLIElJa/tZUP\nvqQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM40n8OFplFKN371PGjkcY/9ep8mRjmM2KF0If2Q7tiUAiEAwPjqnrhO\nWm91RM1encY+KCr7IjlxxbLjfdfx8GDuJZA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAf79a0cNvKlPZaxfoU8U4wVqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RjMWVkNWUtZjgwMS00NjQ4LWI2ZjgtMjA0NjA1ZTUwMTRiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGFlYmJmZjItY2ZlMi00M2UwLWE0OGQtNDcwMjA4MmE0\nNmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXmnb6wfU92Y25v/GQVDFn6hO\ng3p/iTqJ+81rmn3emAjpj2VYhdcVZNxVebYB9Vo1UfQehWwDPobBUPTrwfY30KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUig2qDchyUtckHwBbeOy13ti7A9gwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCTyZYqNssgiBwD\n8D58Hervudw1J70SjKhplEeDvYNBBAIhAO3WyegA/ojV1WJs3jVTB+U8IiI5LTDM\nd3HdrdFCbGHF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7125", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7125` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAVAoZg9KIpZoXn8clItPCsM9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlNTNhZGFlLWVlZGItNDEzYy05ZDdkLTRmNTM3MWI0Y2IxNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWIzNmE0MzktMTUy\nNy00ZjMzLWI1MmMtMTYyMWY5YmM2NDJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7+tEqB9eLWJoPO8pZOlW2LhCiy/G2vs0ewrCdX1/Wl0+15EOrjITzEMDd9xf\n04eQVO/gNNWoH6058xL+4GmGcaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWGhJ4YGoC55Gy91Uvz97MYllP6YwHwYDVR0j\nBBgwFoAU7sZXS1hDXj10+nVMt0plBHIK15IwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIEVrgA4oDoOxT+PhWkjk/Af2x2udkGCI\nlUmpt02TXhHrAiBs9HCknavccLk3eXtKAnCRg4t/n6XJSGsIFd94KqHrBw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQVPEolbE4eNvwkyC2tNVd3aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTUzYWRhZS1lZWRiLTQxM2MtOWQ3ZC00ZjUzNzFiNGNiMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIR6xpgMqkEXeV6PdsyHHZGKhc17z2mJriouNvvVKv799u\nt2CpEk87q+DFDk0AqtxyJ0y/GUPD5AHsKxOEiaU0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7sZXS1hDXj10+nVMt0plBHIK\n15IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPMkyCEza6/7BPUwC97/VOM/XADrP3VWvAmq2talrk73AiEA8NX8WU4M\nkhz6rZXFHBPGsJI0nqynXVtA5cLRoZ/zUnE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAUwV6d1igShfqaGdo2+IRvwfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWIzNmE0MzktMTUyNy00ZjMzLWI1MmMtMTYyMWY5YmM2NDJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDc1OTI0MGEtYWU4NS00YWUzLTg0MWItMzk4Mzc2MTg3\nNTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJGSYUOCNSIN0OEAWhDt5+KM8\nWz+mW1keRgybWZNx0Rj573n+DmxTkOyrp3g4lsmwISon/lxXv0mIOPWe1bLhL6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWGhJ4YGoC55Gy91Uvz97MYllP6YwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDIAZmi1F5AVtS3\nOSk+yBPmMP6VeQ0R9agpdUeg6XQVGQIgRMM7QvLhSGchIRZov0QTDmG5dBCBfdB/\noSG84Y/MImg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7126", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7126` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATTVhbuqEu9y7d9W1ypT5XCfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1ZGY5YjY2LWFiMGItNDZkMy1hZDZkLTNkNGFhZmFkN2VhMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2UyMTQwNjAtNDE3\nYS00N2FjLWI2MWEtZWViZmNkZDkxMGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3sfiMFIelJ9MyiTcZkGD2I4HRKClJlOdGlJd3N3FVqH24sGDLdGZ5isef2iO\nu7g6VLOiwKTW/je0xAfYcQDMU6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH7TaqsgmJpelj3b12g6+vmjqQd4wHwYDVR0j\nBBgwFoAUptEHJitepC55/HLQpUQMA+vfzE0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD9XlfpAdEe\n8RKtRnb5xqehIV3XwCJp2UDproBpsF8WyAIhAP9/XDiYz5LXcAXzs9g0Vyoc5i+3\nYWmubakF0aVxvMTe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdQ+kMy6+IZr9vwFAN9jCx/FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWRmOWI2Ni1hYjBiLTQ2ZDMtYWQ2ZC0zZDRhYWZhZDdlYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRc5jjfiMoEtNJ9ZB0jiLchVeDfY4J5LAHjx6KL5IvwkqX\nHaDxYJbg/EfeYF+8xCah4TLOgYXunaVLeIvljGOao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUptEHJitepC55/HLQpUQMA+vf\nzE0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgELV60AC30H0h57QpwjVPARIqzaYRjMChnYYsawUeH2ACIFv5GsKfmwD5\nyZFNiwpwn1+qyzp2S7gYPOw+okVcLLNx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAUTGJceNknt40XEuRglo7h5lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2UyMTQwNjAtNDE3YS00N2FjLWI2MWEtZWViZmNkZDkxMGVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzQ5YjI4NmYtYmFmZC00YTIzLWFkMWItZTk4Mzc5YTk3\nYzJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEox1P6AXSHZ6mUxxLc92CyzVT\neHt37Q8J9WxLBkFZQiB1fERKfImPYDRpZmTnrCprillRPJxx4CoP363SX+hDC6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH7TaqsgmJpelj3b12g6+vmjqQd4wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIChwKCIZbOfe5EXs\nszu8ivtLJB12WNA+FrfXQenYQn6kAiEAvVS0LDZsUTmytkDizYEouMDor6+fz19a\nZQ5tjIrajzE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7127", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7127` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAdCgmYLe8xWd3QqXlY1VXPVEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMThlNzc2LWI0MGMtNGM1ZC1iYzAzLWFkYTI0ZjVhZGJiNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhiNTM1NGItOTQw\nOS00NGQ3LTk0MzgtMTVmZjAwZGNmNWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0Dw9TFuPn07N2xEBNlsxKUxEYzXfciOM7f1zr80TUr3ewG6dh2/B+4v1E4/j\nez0MugYyAMZZ4w89P288PaPUwqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUvXIrdDBtC56eCqNUdHbOgUnSHgwHwYDVR0j\nBBgwFoAURvH1UczGqRlRB5tKUz72qZC+pEYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgd7Nr1c68ZSgKK3AJJmDFM4w4WcZDZaN4TY2zRB2fASACIQC4iGS62VNi\narb01Xp1RzexgOrPhDJL3r9TqpQUnTfLLA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX0lglZfcEXWY2r9V2wiWe6LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTE4ZTc3Ni1iNDBjLTRjNWQtYmMwMy1hZGEyNGY1YWRiYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjsoPkaxemus/mIFC9u61tJDqHySDv6UHUQcqfm8YOXa6s\nsKZnvr7RC2wgHZkKraUzqtLUxxlWACr0WEUKbMMXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURvH1UczGqRlRB5tKUz72qZC+\npEYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIYJEW+ewYn1okxav3Me774+LpMJgAF0ZoveqxXepWeWAiEA2KHS1VtL\n/etQY5+vrzjmRA7LflMZxFjuNyQGvtvQSNM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISATvp0M1ej+jiXjJelFGZ4gcRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhiNTM1NGItOTQwOS00NGQ3LTk0MzgtMTVmZjAwZGNmNWVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmQ5NzQ3OTktM2NmMi00ODhhLTg0MTgtOWY5MjA5MzJh\nNDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOQlaEni06JxGml/G9SF2zL4x\neZ416Wzo1q0Yp4u0WRS8FuqGrGeC8conD9DXw2Xj/WEwZATH9JubrFKzteouHqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUvXIrdDBtC56eCqNUdHbOgUnSHgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCXbMYqXpjhImEW\n6iDTDKqc1VL8IVoyT9lra28f7cMEZwIhAI2mfzpUXzqR8UtIxKn1N69OEIlhbsHe\nynvInxQ0SXi0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7128", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7128` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAfqkENDI7ZIxPLucg53gnDPoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMDExNmJiLTI3ZTgtNDk3NS1hODgwLTU2MjI3NWQ1OGZmOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ0MGU4N2UtMjgz\nNy00NmI0LWEyNjItNTI4ZGE1MTA1ZmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElPFm2dRLwomazR98Kb9GZtLLTfKbI55eAfceug7MNx2iRnorfqh7Lsgc2Qox\nWDsJBYhGAoRNp3ONF+QQmFm+M6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTONUBlZTfmYqz/GaDzVrUfZlfZ8wHwYDVR0j\nBBgwFoAUYgB/DXBQM6MKANYoFSEmK6pPGBUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgLonxGZSJ9lPA+HjnjOihOyfPavdrI8jl9XACFv3HqPMCIElrSCgspC48\nJqLxF/Rs+xmd+ukbjKGRYgAH9pThZep2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUypV3r3lkj35KeOULKQrrZ1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjAxMTZiYi0yN2U4LTQ5NzUtYTg4MC01NjIyNzVkNThmZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGlHXJEJxucG/AkiAXm20o4O+MVr1I3+hiyyqU3QONpb1E\n9U8CGFMlz8mhnpe8MVHVE3TMcpRJN41KIpgzf3kSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYgB/DXBQM6MKANYoFSEmK6pP\nGBUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALbNdtazx2VlzDOnHYPQreIMAhSFN6DkU64RcIdG4BktAiB1YKTwlkfy\nf0npqBhpUKP6wwvV6xpJkaUDQBBmN2KNfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASGqh0eclz131x/ZQ+oBxXyDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ0MGU4N2UtMjgzNy00NmI0LWEyNjItNTI4ZGE1MTA1ZmY4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzQ3OGE2YWMtMzkzNC00MWQ0LWEwYjQtYjVkNmExMzBk\nNmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELz0j9aGgp/B9LoLgJejWfWX/\nmVAKqP81q2iMjYP8kXmaxMBtv57f5LEyzcrhNhSkSbw8pDcp/TB4wpaT1pCaQ6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTONUBlZTfmYqz/GaDzVrUfZlfZ8wGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHs70WFr4DW80SJa\n+TUwVwcRZntIm0oU0/i+nusM2RlSAiEAxgkl1YyC7ylH1bcJ7pPEVJT65WAncTcN\ntUnq/FK80aQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7129", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7129` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAUqSo3Xx1+W9UUBy97giad0cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxMGE3NmE5LWYyMDktNDBiNy05ZTY4LWFhMDJkYTFlYmNkYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVkYTU5Y2QtYzgz\nZS00MzdlLTk3YmEtMzRhM2E4ZGRjNjc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUJQYksaSiJ4BrsYNRIIa0vLlrka4/cMatPgX39MlI3sPgwysJVBkkakO8vRe\n0QeCBfI7IpYfn4hrMAf2yPWJi6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgKwHj7sicYElGLqvFlMGgmVrdSMwHwYDVR0j\nBBgwFoAU9k7h2sadF4qp2fUEn1o5nCtC/7IwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCICuAe0FNQZkHlr7vL3m5ylJCTuG8KQZytRkUvp5/KypAAiAHzrNUtc24\ngyKRDnsnL+xqJiB7IFmHBKRNn3FkpqMfcw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ8Ri3L/g3APpFiiF/bzm+zzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTBhNzZhOS1mMjA5LTQwYjctOWU2OC1hYTAyZGExZWJjZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgIFU21TYgnO4fYoFZSrUIgjjaC6C1oPCzQ9cHR68JxBcF\nl4KRyyjwpQd8XW05JQwVNFFJBmN+v2qxOpBhQjOgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9k7h2sadF4qp2fUEn1o5nCtC\n/7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALReN5vbcWciYs3UUki4WZBRRfPqStptD3Kkq+uIDdLUAiEAjvN8lIPH\nMDPHCQbr36VKoQGobyUrfvev5zrzI83slpg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAUNraP+Z1krKcJc3txrE+ybNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVkYTU5Y2QtYzgzZS00MzdlLTk3YmEtMzRhM2E4ZGRjNjc0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmU1NWJmNzYtNjc3OS00ZjY1LWE2ZjMtNTlhNmRjZmNl\nYzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0y3viLqieeafvL7LIZTmfvXd\nDI88TTcDcKfDR6gxoBvIIHrTNeHPD+x7Gw9HcCbBR9imhWAWLpafKjIXJO7RRKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgKwHj7sicYElGLqvFlMGgmVrdSMwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCWuD4XdS1Ri4WF\nAk88ei5v3ht+F0hMVQx/51yW+kAddgIgHu9tLeh2/ivWk+YKJ+eBTI3BevBwpKCw\nXez9rd7DOXA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7130", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7130` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUg1jQM0aHxZvTQ+f/IRZWraMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5ZTcxNzZjLTU5MzctNDViNy05ZTI1LWYyNTYwMjMyM2Q0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI5ODUxNmYtZjJm\nZi00MDQzLTkyZWYtNDBkYzNhNGEyNjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWllqWuyHuOK4ktIW79iYCRKOzcX0p2/N6K7NCMPgiNIsWZYfR5SzZWGzsh1y\nurv5+bBECWNXyo0sYTG3BFk0yaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK/363NBsDg9DLiC45S6fWumAHlEwHwYDVR0j\nBBgwFoAU0wEJBWzxFqflPxYkQ0I4UFmX6qkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIB+7VPYZrFR+9KiuAdCjXaDkUAqkx52a9PPVL41F\nRynBAiEAo652a6DKDzufpzsp8USZ01hCvVzvMYkaWBKre80KDhw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAebJw5Gcjlj/ocanBIpnlRC6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWU3MTc2Yy01OTM3LTQ1YjctOWUyNS1mMjU2MDIzMjNkNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOzP2mdi6oJqrHpQgFdSZM/kbjb+7X2Nh7zR/Mm7M+zdR4\npoTWSCvoabHc/cg8T6aMrnwAhePe3b8lpB0j3LJIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0wEJBWzxFqflPxYkQ0I4UFmX\n6qkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLbFZFxTqO8M4ToR7Z/40gr+FjObBwtTlL7WeHfUvpqgCIG2b0Dn3hCy3\nTSbcBbR/2QgAmF3xM8qfJrSFa1HjibO0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAY+JMUq+3jop+vA2/Zlg6761MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI5ODUxNmYtZjJmZi00MDQzLTkyZWYtNDBkYzNhNGEyNjcyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzQxMGZlZTYtOGU0OS00ZTNmLTkwNWYtYTM5YWI1OTA0\nYjYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK2xC0TwWRx9eCRYHjpTCf+8M\ndWYHzUzNIMHSIE4KUtO4ajM40zmbrJth1PrXUeWE6+EjboYYsUkhLcw7lg+fBqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUK/363NBsDg9DLiC45S6fWumAHlEwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDrgOOBQVNBnYdR6\n3G8HemiAOY1MfWXlWcnJEr/619o8AiEApy4Vj2U7l7nYXxx+C/9tJ8ZvESKDzLRm\n3j8HRim7tUQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7131", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7131` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAf9EHyJ/yZFiM09VxukYP3RBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNGIzNzUwLTFjZjctNDgzNi1iMTYyLThlMjZkOGQ4NjMzMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRlOWVmYjItMTk5\nYy00YzZkLThhMjUtMmMzYjg4OTk3MGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyyb7SZfiui+4e3PpT/CZ05sJizW1ylv1QajNRzjuwicd0XAgYphOXosrm78l\nhMr2LRqKllD79oNorMYolj3D5KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtIGuE8PU2OBght/kxvtdXFT6D5QwHwYDVR0j\nBBgwFoAU7T4R9NEqZhfybk8LnUUdDPaULaIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIAgG+fbbZK9j0iSk6NMpkRqrzniIO2mrTu6GMWtn\nKg45AiAxPLWLYGyXbIF5GzdhNssGnAcRaHUnJT1KRppNb49iYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWg0+3V2uhDfdM+3Ez/oVusOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDRiMzc1MC0xY2Y3LTQ4MzYtYjE2Mi04ZTI2ZDhkODYzMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbP/WUvyH4igPHVQiIyLmxdqfpxou83k6Uau0pmg2eVjXx\n30phMYKR+N0CMtGHsHam7un61nloDt73TG4Z1I9Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7T4R9NEqZhfybk8LnUUdDPaU\nLaIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIYe/CvU6E0Q+AqLcK/5J5c89Ro/2kKVxxTL5dvx2qqAAiAwyA9pvY/s\nEyBF1K9w/BrOA2Y21DGAx7PAI3buBTjofg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAZM7Uei3ghpuEYYb2w+GzlpkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRlOWVmYjItMTk5Yy00YzZkLThhMjUtMmMzYjg4OTk3MGU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzA5ODMyNjItZDQxOS00ZGE0LTkzYjAtZDI2MDc2NTA5\nNmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkUm8FoESLiIg6k4v9G9hp12l\nK36l/Y+PLJ7SPlREccK1dNgTnza6U81VG6pSAdxmRJjIgpkl1qNAkV6HwMqPM6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtIGuE8PU2OBght/kxvtdXFT6D5QwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHjPL06I22dMgc/4\n8S5J7SOoH1aJAunO2ePTZ1S4nfEkAiBzV4N9pfsMwAzLnU9s7+jR++xo0/5sOChs\n9Lujq9YhQA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7132", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7132` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAQmhQHm7qpYhYkypaRV9m57MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNTM0MjZjLWExYWItNDEzZi05NDgxLWQ0NDRmZjYzZDJiZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzEwYmE0ZGYtMWUy\nOC00OGRiLTljYzUtYTBiNzg3NDgxZWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDlZq2DordIQKPqjjZRw65vFC+Tgc6SZ6iPRp3NwCmDqHbSR0cfuWphN34CPl\n7+Cdjp+Xky9JgL9YyaFBYruvOqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn3gmGbXFoIWM+3iIt8bQWNPQGoAwHwYDVR0j\nBBgwFoAU4S6oeiaukBFnsi7CA8e+sMB+tVgwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDwuEHZucw9ErxBuLK/PggEN8t9+Xlj889P5gzaImDkOwIh\nAM5YN9FpD4M0YVhAplmfaIFNs8NA/GYmn97ixlAhBdBo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfeiYPDB7lX6WQxvFj1q3NtuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjUzNDI2Yy1hMWFiLTQxM2YtOTQ4MS1kNDQ0ZmY2M2QyYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ51eQ8sY8O4iims6eFr2cWko4GNb1oE4yKq7NvXzzpJY4V\nXBAAi8wElNaFXVRZIgEGHNbsNo2o+3lHTHJ9MgTYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4S6oeiaukBFnsi7CA8e+sMB+\ntVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNKiGtgHg8fufs0+ovXHOXJZnqGaLNlCdprlG2QezupYCIQDx2aZqmB08\n6unyaCs6y1KLvGJg4Y2vClc3orfVWV2XoQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATKuwz5JiH+KjRUxkZl+SWAZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzEwYmE0ZGYtMWUyOC00OGRiLTljYzUtYTBiNzg3NDgxZWU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjJlMTk2ZjQtNjVkMS00YTYwLWIyNzItMGJmZTM3OTk2\nYmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtnZ5C3RoRVMe7mpReaktvnB9\nDBD/3BZfyrxXw4Hieh5XpnGuU5jC9QxIztHFHJv63r2sR5VI9eXBz0LD5qj24aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn3gmGbXFoIWM+3iIt8bQWNPQGoAwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCrn94AXq/wHRkO\nusU46pKX18kN3vNC9hYwLv+fWaw6ugIgU4xAUu3WoFMwU2oqZRKz5lB9EAjKzLzt\nZCWTjOnzUNs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7133", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7133` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAck1JjIXuo7DdXI9M35EDLavMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNDk5NGNjLWNlZGYtNDJmMC05OWNmLWY5MDQyN2MyMzBmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjMwNGJkMmYtYTM3\nYi00NDgwLWEyZTgtYzI1NDI5OWJhZTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEghcL0zXNtIiYlN++gfU34Vaia0/G9xb36VwfqqHwNN2xsm0qt8Nyy6125Ao5\nyGqf+Xmali1lVA5oSfS2Y04kqqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjLd8kFDaldj1Sp//Pb/zWZbpjSUwHwYDVR0j\nBBgwFoAUhbQryC/+a2PukWK+NF80ZzAhGRIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCvqLRzqfAG+3X3bWrTqaJCC7lB3PT4\nzGLZpWUsivMbfQIhAOhTkPDXxONFDwP/i337oVvEWdHnEOQraEuh1rZ3hVPz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYV+WjEdvNue8htAd8BCaqRoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTQ5OTRjYy1jZWRmLTQyZjAtOTljZi1mOTA0MjdjMjMwZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3w9QqT/jvoaP8U6A4DdQX6A29tsjN6gO5sVu/RSnk+LmZ\nKMpXqM6YGjRw+B98brZDjUFVLec5ZID1yRLB7RV4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhbQryC/+a2PukWK+NF80ZzAh\nGRIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO4b9f5mtmEUFgsTG90dhPGq9h8SOAjY7w6AGiwyIEJYCIQD8TzcYa/Wq\nqwZwS4C4fOM0zFyvsXtnPdaYI4bmVEiMqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAYzcR45Q5j7NQ96N9o0eXtSrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjMwNGJkMmYtYTM3Yi00NDgwLWEyZTgtYzI1NDI5OWJhZTVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmJhYzhkZTUtOTM1MC00NTE5LTllYzItMmI1NTc0MWY4\nMDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIvKBp2f0n4QKgANrHgCfGXSA\nDsF5SOmXLN/IZw1ONsd+k8Vp+BowC38C6sMePzGvV8ibJDZI305rewqIaVTN0qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjLd8kFDaldj1Sp//Pb/zWZbpjSUwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCvP1k8mOV/pPjd\nz8+WCZdQp8/BH3yX4UrpI1rzfOQnjQIhAJs+t+bQJESbuIYJkVvL2sYXzEq4s4Pf\nvILvlcGIALeQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7134", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7134` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAYtpGVyUf9LT6yCG2a5aMOoQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzNDFiNTkyLTZjNTAtNDVjOC05ZDZkLWJhNTljZDkyMGNlMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJlY2Y3OTgtYmRm\nMi00ODk1LWI4ZGUtODAwNzMxZTI2ODhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgFp4nuMb8mD7IG2QBmZZaspRHj1cJ8RuTx9njnQAbzz46EQNJ7A14Nli8diR\nNqaPiS2FRIuE+MyGbOzSuJZ/SqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4sEb97Ni+pfu6Yl96EZ9yiCt3lgwHwYDVR0j\nBBgwFoAUsZbbwfhNJHBdvd3KvTSNRAI58EkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDzlIXFPssEFG4n/qIxi5ophq7nVr3W\naIst+OEbsW/zJgIgMirf+fuob6yqeYsiJKMI0nNYkxbC3o3w0kqCzA227I8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcbLN5378OUWVH2JhIX/7FT0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzQxYjU5Mi02YzUwLTQ1YzgtOWQ2ZC1iYTU5Y2Q5MjBjZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBH4ZAwNB+oUy5cPnnAyNrA11E8P5rh2bJT8BY/sZXsgru\nE6fUBpXA0vh9JtY+u6GC68OPfy1nZ33B/Y0HL68eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsZbbwfhNJHBdvd3KvTSNRAI5\n8EkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWjX8yN/t70va7wrzWIkIoP1xnCYm64y8QFfuJ1zXmoYCIFeldhXOeBB+\n2h+g8ml7ATez/ZmP+3kPdlHBdX46wTUf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfemcoVjKGR5uz1o/BWeaDYqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJlY2Y3OTgtYmRmMi00ODk1LWI4ZGUtODAwNzMxZTI2ODhkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzE1NjUzZTYtOTUzYy00ZDk0LWFiOTEtNTE4ZWMxM2M1\nMmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw5XkuBJbgp4cX0vZ6PIte0OQ\nCy8cqfbmx7ntQRZqKufUAswthMVI2aoMp6/XE+WYcUQlqGLSpuCNclVbl3qN26Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4sEb97Ni+pfu6Yl96EZ9yiCt3lgwGgYDVR0RBBMw\nEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDZv3oaaeGltz+B\nbbIPtnbqD69XzuIJKP6xU/vpWTvRAwIgAO9hPak0y2BLBnIrUdhZVFgHN/5AbWJ8\nF4XAlFUXbwc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7135", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7135` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZc+J60DVie+Hho/hMJKHr+9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyOTY5OTVjLTQzZjUtNGM5Ny05MjY2LWVlNjA5MGVjMzMzYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ExYjc3MDktMzVk\nYS00ZjIxLWIxMjEtZTA3NzdjMWQ0MWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQmBO6VH74J2cB8mvUIxzuy5Puaoyp801Zq3xsSkvw+2gZjblkCO+9V7rCqSo\nS6V5Dckyr8vXfubRIN7FsmIbr6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBQFFoJENYVOnkXZ3WQpmf+Ct4EsMB8GA1UdIwQY\nMBaAFFdlz6TMzUoIse3n8G82Gf2pTcGGMAoGCCqGSM49BAMCA0gAMEUCIQCIeeZW\ntxFoR1MoqladkemYndw7R+iblwZc/ioVGweBZgIgUM0SUXdyfy+3XXey3XqF+jdk\nu04XYALK1zd8h0EHS9o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVqxjwuaykXpuZSGPqkkSYr0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjk2OTk1Yy00M2Y1LTRjOTctOTI2Ni1lZTYwOTBlYzMzM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ73Ngk0d1jbhp9Qhmk4uF4Su6ru1e/ySYWDm4GvBADQSko\nFYSpd3H/Kd05xKNJ5+fWf6fPrOsGTDO26YkbHO3no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV2XPpMzNSgix7efwbzYZ/alN\nwYYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALuMTH8x+K/ho9LECswzXvUG9dGJhJ9x+4alHbmgDPN9AiEA3JrUfppc\ndb5AjJGuWN45zgRKybHa1j2mAIqbN1bHjsk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAbxRm+pJ1XY1YHcd1BW1yyVtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ExYjc3MDktMzVkYS00ZjIxLWIxMjEtZTA3NzdjMWQ0MWUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTQ1NTY5ZWUtYzQ4NS00NzM2LWE0NTMtZDFmODJjM2Ix\nYWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6wksD+kiansUCRPsvu3x18Jq\nM/VM2y6Lus0bQbKQ9skVVwgcX3poc5U2J2sEBlqJC+6+izotR5J/fs6GODfYrKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFAUWgkQ1hU6eRdndZCmZ/4K3gSwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDRJp0o\nGHf7aNOBw/zxc+iioW5e1qHygjG29NjTPHKNUAIhAJ4O8UkSXAOkAlDfPzbxJIDT\nWVyx7ByNQHAftl4YKVGp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7136", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7136` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAS4VNj5K7s2wbxT3kQXX+apaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwZDc5N2E3LTU5NmMtNGRkOS04YmVkLTEwMWJhY2JhZDE2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY2YmY5YzctZmNj\nYi00NjEwLTlmZTctZjNlN2EzYTMzZTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELinpVtSVLSgF+JxSKsl0yfSjfFFH2IFbg74ATSN0kdBmJsNCx2w85+Mu88iO\n1uCXoytMjKT9/a8OwH+ahXZvDaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDFdz0Fo2OLCp6AweULBHMlxXpfTMB8GA1UdIwQY\nMBaAFKZfhjMPGWARv2gexpgyiANtq8LDMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAp6o6z/VNNvdEjNHtQWtTOmTOj4QhfKYi\nQ0lcivIgGiUCIBANGm0zuzskr8jwvZE+ytHbp61rrOUyUDHSleAob7Md\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATr54MTAvEZ/xHvY8XAXaMOlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGQ3OTdhNy01OTZjLTRkZDktOGJlZC0xMDFiYWNiYWQxNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGxKjkcfRNbvjEboEq1lA7+/MuTvkGuOnDxrPYwnW1FDSP\n5Ug+kRaI3Xk3MHO/zsC5mUOw1Wiwf9fh1oZCITEwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpl+GMw8ZYBG/aB7GmDKIA22r\nwsMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZXn4wwCvQtejMpPv1wTXhKjq/bnADvaBXP2dFqJZ8+wCIDyJM1nI63F2\nlJW5bvUaKrU2y0ADtLB7tpz/cwd10k4p\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYJurf+WMVjTiGtzF/cNv+qPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY2YmY5YzctZmNjYi00NjEwLTlmZTctZjNlN2EzYTMzZTc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWZkZjQ5ZGQtZTUyZC00M2JkLTg4YzctM2ZmYzg1ZmQ1\nZmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUgnd6T3lMu/hiXRTFi5ouyqg\nfsmX4aLp88BI/gDB03dbZunheN0HVaB1R6UVTox/pSgmSKXsI5BOLd0JMz/MTqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMV3PQWjY4sKnoDB5QsEcyXFel9MwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGQbyIYT\n8ZKqAYczlIqVllYM1Lehda/FPO9ln+H4WIHzAiEA6sMoYQ/skC8TnOonrVoz1yRU\noNqydNl0yxZaNfX9N7Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7137", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7137` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVG4XQJaIUbz0t8kElyzb/Q6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MTMyYjA4LWJmODAtNGYyYi05MzBkLWMwN2IzMzM4ZjI5NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q1YmZlYzYtNzYz\nNi00YWNlLTk2YTktMWRlNjJiMGViOWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWjDmgKHl5zvrzqfTkSuKbTzS8LYA8v+Mnp/Do+mWvbSK5mo+ojBYlNckHkes\nhRpmpY/0LudmgfVptz4wMrjLGKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFiWK19pYPcON+8SNcPY+WOCbRmmMB8GA1UdIwQY\nMBaAFLeWmXQUsZXLxc33c+XU7YyEKjItMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBk9UKBayXseWAl81z1NYL2XenO2kEuE3re\nKRFpLTgFvgIhANUN67XIPi1WxaI6L0X4HASs5hnN1J+CGAzohuoixSzG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUqVPD5iA4ub2kn9GKG1duKBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTEzMmIwOC1iZjgwLTRmMmItOTMwZC1jMDdiMzMzOGYyOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARURT1Nh2M9mbaV8nBFECg95Gfy+mu8pa6ejg3ABRsXesrF\nMUxstYCXTkS4//9blq6+gCsWSfHJyAasELSI4Qtso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt5aZdBSxlcvFzfdz5dTtjIQq\nMi0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSreq0DBjTCP4mXx4vzAmIvVb0eNIhn6wHOXpAuvFRWQCIF1fuUt1VCBZ\n+XkPgKnR2O/s58pR3fHLK1EBIUX5PIfg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASh6bxJaveSVR2WJe3CB9Ic9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q1YmZlYzYtNzYzNi00YWNlLTk2YTktMWRlNjJiMGViOWM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmIxZjFkMTUtN2YwNi00YTg3LTkxODEtNWFlN2E3ZDZj\nODYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7VDr5EJWgG4rRnLUGQxPbnUl\nomCmP9K2AuNiqil/TTmYO6lSzzRWkZRE82VvmP+SdGJBvaX+/HaZ9qUkDZ14UqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWJYrX2lg9w437xI1w9j5Y4JtGaYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD5RrSb\nJKoZ2+UYV16XcwU9HZMJou+onvmsUYnIjIBLLAIgIxl4t8ho7PWZ1mHXce/Nwwyu\nUwlyqZ/j7RIucFjtsDw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7138", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7138` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAaGB1PAWWHnFmIqu5IdnCZxVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmNjVjMmQ0LTNmZGQtNGFmMC05MjZjLTY5MTg5NDhkMWYzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgwZGNhMmQtYzUx\nOC00ZDI2LTliZTAtNWJmMjI4MmUzZWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtpnSv3mk+i9En6gcKcH5EwDOIMVpBkHoJTVYc3vlJhJ6p9plLJ2UVNcqNuoU\nYBDFtnOjPA2VCpGJboLMyA22NKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQSoc31j0BF9UyfJli/lbPpjz3bbzAfBgNVHSME\nGDAWgBQsYTbQPNlEEwFtvF+NEtNJYugVMjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIH04s3e7mEvgBusrgmJVRpbNZE6LrseP\nMOkNnm5O0QDgAiEA04bj9pTPjpg3y7ht9AKjryNyGjI1fgsl9DNf4clMelM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR1nX3F6IhuCo4NaBrGVp2soMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjY1YzJkNC0zZmRkLTRhZjAtOTI2Yy02OTE4OTQ4ZDFmM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiQWiLEwRP7s+VFUtTdBmaEzJK6lyW7DKwWuiKq6fbv+U5\nOObH9z4aijph7vcSOgiEVUFyBBI1CQT3T9HheGCMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULGE20DzZRBMBbbxfjRLTSWLo\nFTIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP6NzplbTS6gdjxfVPhyLK805tsEMcJJMcDkgkwvBB+eAiBonaP7/AfE\nSylK6t6bJom0Gd9eF8po1yXXv33rtXLzEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAekVeDC3xT/liRspngS+lt51MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgwZGNhMmQtYzUxOC00ZDI2LTliZTAtNWJmMjI4MmUzZWIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmQ3ZTM4MjctYTlhYi00YWZkLTg2YjMtNmIzMjhmODkw\nNzg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6ohw3Lpqgf6NPqGF/yeqICpx\nL5HGaufAh+0Y2WqTSP720gNMbuTLHApfsQc6NcNzXwJtxWNvgsJpYI23mLc7dqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEqHN9Y9ARfVMnyZYv5Wz6Y89228wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC/EX3f\nqY/sBqM+j1YbbIUvaiLj1PspuVFODGHnJ70oYQIhANxGJQ4rxOjcOSTFmP2VpQgZ\n9FqCU320hRfincgDSBTi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7139", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7139` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAaNF0tBGEIokzIL4mG+tWrpPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2ODlhZjNjLTUzZmEtNGQ1MC05ZDI2LTQ4M2U2NjYzMWUzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y5MmU2NjYtYWIy\nNS00OGUyLTg1MmQtOGY2NjQyYjZmZWQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA0mlR7WQCwZTKLOWD9R9tp/oFbjqm+Qi+mL+x/Y6Ga3/Z/HRKQytMuzt1Cem\npJYmGFiqL8Wj6RQB/OmaXwjZNqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgEmIvMuX8bXnX5w/jmlb6szD5sYwHwYDVR0j\nBBgwFoAUywwxl0v5x2XYn27zdeD5ig/Uuz0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAy8koNLrO2y0j\npgPhlfwT5/7RCF4XQLfn5Fdks0JxI3QCIGIyHbOumevpoAXGmJgbEpXOoLIXvabd\nsoyjsVdo/Toq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYIqQd14D5VugIfWmZTxi01wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjg5YWYzYy01M2ZhLTRkNTAtOWQyNi00ODNlNjY2MzFlM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPpLj7faImrqSK92YhyXjWhimNt0Z05FVrGMi+iuudZYUh\nrI6Zl8qfgjbf2MNjlxP1AFVcMZZuLB7nwCjz8opmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUywwxl0v5x2XYn27zdeD5ig/U\nuz0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM/Im6Q6x8iZom29y63h9x/wgxmWds/7gNIGlddXRaNfAiEAkMQWL22f\nrd5Im/iJyQ9/niGv6dKYOAmvusXPsQmxq+o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfQezYlQ8Sst2kbPEVAer6T4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y5MmU2NjYtYWIyNS00OGUyLTg1MmQtOGY2NjQyYjZmZWQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWE2MDNjMWYtMzY0YS00N2EwLTlhYjctMTE1ODQ0NDM2\nMjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFBcoap0E1WUr2CwJPf8N1mMK\nHFG7p2O18P+a4Y3c4RCtF2zCDbrV6kZpgYKL65BsdO368M4mCktH65sO40A+LaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgEmIvMuX8bXnX5w/jmlb6szD5sYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCK8EbJ\ngtdHcyL1zeFZTKknm+7hYa8nkOMZoUNBgDsW4wIgOTi+ORh6CfdXds8UsQz30qhm\nfsGmGR9Ll1okPg1xH1o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7140", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7140` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAbnw4vGC5S2YHwSmR4qQCtm+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwZTkyZjdjLWYzNjItNDVmOC1hZmZjLTYyNWQzNjI0ZWFiMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVkYTM3NzUtNTJh\nZS00MmFmLWIyNTAtMjk1MDgxNjJiNjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQo9FnudnxVqq7OVqn/wj2Ei/wx5QMxbfLSxgmsA3Igzs+TPhMVgys/HKnHEL\nPyfDfUbKL6fdVfKZvxs8ejcwK6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGXAbPxMkiOPw9npWz7XwT+onThgwHwYDVR0j\nBBgwFoAUvYGorFajzS2xEXcfinxifDMBM64wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAeEc7hEgNpJ+Us\nmhEJYtIjLLbUoGQIB6xYoZVNFGJmZQIgCXvWLd7SZlVTo7CX6IVVpuVLAmSkAJSO\nSzEOChF8eXg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf15Zue3UKprHLsdraUC0mAPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGU5MmY3Yy1mMzYyLTQ1ZjgtYWZmYy02MjVkMzYyNGVhYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1wBbj8sY/rPp0mgdJyDD9qIkxTNYcf3cYPVLMMNJFX18g\nZ7j0O9q4a6ZF06Hax4s+k7cLuCYcl9XGcNsMXBgBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvYGorFajzS2xEXcfinxifDMB\nM64wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeZfMc/+jLVHqneqoeaR9st9cKudaNd1L0cmUS4uQwqQCID8q1k72bYy1\nwXXy6O2oD+8Ed6Nu+LXn0qyfJOXZHN5y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISARPWP5/QGHhAuwVhXadOp3fVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVkYTM3NzUtNTJhZS00MmFmLWIyNTAtMjk1MDgxNjJiNjM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTE1NzE5YzMtYWNmMS00YjIyLTlmN2ItZDg0ODQwNTk1\nN2RjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWMKFynae2C5AnOV+/Df25YKf\niWtUkulp26FHFNIsgTDLyFj8/f16P5juGNim7QNuWnd+qQp82mJlYDMpbZqJAKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGXAbPxMkiOPw9npWz7XwT+onThgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC+kr0O\nVH5jVmbUo21kyEilp2XBXbVamNfZ1W5xM2cJQwIhAMHBfBJGFuOQcKOPnDXWklTm\njx0F2AYANzYTRDgnObWV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7141", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7141` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAat2mSFXg1nPbL6Wh3TOiw6RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzODFhYTkzLTBjNGQtNDQ3ZS1iYzA5LTM0YjkwNThlZDFkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY5ZjZjZDUtN2Ex\nYS00NDIyLTliYzQtNTNiZjg0M2U4MzBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoEj1WOwP7C/p81mEs80Y/narWiR8bUtzzy1GsBRgbpJ69MtxvAW6XjqTG94a\nCEc53Wiuz6S0oIrn5K9g8eAmAKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBlpPVzkwiRUKOUiFCE1E9JRkpJwwHwYDVR0j\nBBgwFoAUuedyEqbnP0M/IHYN4mIYuHyatlwwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAj/yoj021E3EQHtj/zkUaK\nSgp+fKy243GWwM5zDjBBywIhAMiFXE2EunfV/9sWbT14uoDvkw7Vc3FWttBd1TX3\n6ZPL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbvaJZQmhOelTJiDGza1DvFGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzgxYWE5My0wYzRkLTQ0N2UtYmMwOS0zNGI5MDU4ZWQxZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKEGvkQSUDbulMV1CUT5oHysQoI7gTyYJl7qwOB9T7WjP8\nUcPkeeE6bxAJhDaBOpEWHdTFxnE85LTTPYJ4otvAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuedyEqbnP0M/IHYN4mIYuHya\ntlwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPhZaiDKuSggrHPL8YnwF8aELk6qNwo2g7jW1fvVAnyPAiEAmTd2IcaW\nZ9UuYqE2f2xoiE5oPCltM28Na/3znzauFa8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfcN74HGGyW+jZJ0yf823eckMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY5ZjZjZDUtN2ExYS00NDIyLTliYzQtNTNiZjg0M2U4MzBkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzI1MjhkNGUtODNiNS00ZTQyLTg4NjEtYmRkYmJkYWE3\nZDNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEz9V87kklZ3dS+VIwfTV9grj/\njmw+DsyFk+VyaFAyk01clvLP7pQmB81TgiuAvYw4bnPFG5M++RA3MziT6WBgOaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBlpPVzkwiRUKOUiFCE1E9JRkpJwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIF0gqfXd\n54uuwzmwWgCZL+ItQHuKer7Xb7kXO+94YyaVAiBYbqqEzGsq2ksEu7sj1pqbZg0n\nOzRRXpgv5mB/ef4I0A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7142", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7142` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAW6OzGiYvtTbgSbD5NBS10bJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3MmFmNjg0LTk1MGUtNDRjOS1iZWM4LTRlZjIyYzFkNzQ0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE1ZWJlMmYtM2Jk\nZC00NGNlLWIzMWYtYjZhMTlhNWY2YjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnDpkucaPTUsS1CA14jgEvXrifjtXbMM0AXo0gtG4RN52Msz1BAoZFqiUi62L\n2C3t8+17ABrYpv2bddKOs5kWvKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY3rLgNEhiCnkrPLmCjLvsqJLGWcwHwYDVR0j\nBBgwFoAUa+KjsklZSDzAeWFxn2pPOV3+NVgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAhDUP\nfT36jEEFRq/c+fLc7NLc6+7kdxYICGFVx78JP1ICIAazzglo0LUIHZfCTYWCqY5U\ns/o3OUUrXhiqtoOYTev1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa77bIiKL1UnjrHSGJdkjR6FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzJhZjY4NC05NTBlLTQ0YzktYmVjOC00ZWYyMmMxZDc0NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFIZtU84ySb53+dmXRtg3mak52s3Aa7qKGtlsx+7JIoSjQ\nbxufVpHZ5TyhnsgC0Frjgy0tcYLFV17huiu/6+YTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa+KjsklZSDzAeWFxn2pPOV3+\nNVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZz+VpA8bMDSj4YOsRp22gkxcYOXQ3xBV7hbpg3TZ+aECIQC139k61l2s\n1DvcJoNVNeF2y2xw1dArBkJWx4stZ/CMEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQgTZrls1QwecpHQvecN+zZkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE1ZWJlMmYtM2JkZC00NGNlLWIzMWYtYjZhMTlhNWY2YjQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWEyYTgyMGItZDYyYi00MWE5LTk5Y2MtZmNmYTJkMzg4\nODE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/NO9e6qcrMXA8CkTc4e8uuPe\naKRHcjucFHgsjj4WYRwFcrDM0rBMLx2mtmLxL4WSrgwPGzQQY3FOUX6bGrGa96N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY3rLgNEhiCnkrPLmCjLvsqJLGWcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDHOXQ3K\nxKbgCilYbfx1ttjQIblltgG2KyAth1DOxPseAiBGqwivYKW0QKFtQVPOBrXQsAhU\nJDNTbKoB1Z63yLwfVQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7143", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7143` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISASiJRHKAAbA6G8B7KgPME5gnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMjAwMWM0LTA5ZDgtNGRiYS05MTg5LTI0MTQyNDg2NjRlMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI2NzIwNjctYjRi\nYy00NDgxLTg3NWEtZWNhNjE3ZmEyYjU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFLjbaHDZGWXMpkt/NeDZ1tBDwvHqStZ/6wtJOcEiqwWEd/0J2SyJa2oSByfK\n/mUNYg8llId5JVXgQ82zJv+T56OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnrJgr3k9a4wN5BB1nQ/1nRl62+4wHwYDVR0j\nBBgwFoAUFugqv5V6ImrqK2sKRqQKBCWC3NYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBBP5Lc\nqrL9IURf7dZAAuHLs1V6NcmWamt7ENSrvBrKGAIhALEziusa8/LZTe5fFDSIucoC\nMXVrK1cYlXDZXiXPepOH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd0Nh5Tj25yyzMV72rVPEg9jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjIwMDFjNC0wOWQ4LTRkYmEtOTE4OS0yNDE0MjQ4NjY0ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkV8fdeF+pv2cWtvFIS5cKQNm3E5kpj5ZgiSFJs2Ylu/fj\nwlcIMS2xQVgAB2QVDMXHJgXPa5v66XxM5ngaTQH/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFugqv5V6ImrqK2sKRqQKBCWC\n3NYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfObfI9Sv56u8lP9FNyaEMJuKArXZE80zGJ7lPha/BuoCIDLJjTqDU7Wa\nIueDkaippL5RdSRhs7Wiby5lT2EEEujS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAZcXcDlPH+EzS8jxjmOozS6ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI2NzIwNjctYjRiYy00NDgxLTg3NWEtZWNhNjE3ZmEyYjU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjk0M2M0NTItNjhkZC00OTIxLTg3YzctMTJmNGI5NWY0\nZTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgpgEnd4Od3VDJmd8xij34IE3\nEKv9aIXA29aPGRz34Ji8KXCImVOwqMrAPzhklNMLK6WRTfq/te+xIcogDAebj6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnrJgr3k9a4wN5BB1nQ/1nRl62+4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCTAwSx\nZbShBjVDeKBNA3BC09YFLx1bRu284VwHeO8PHwIhAOeulSmdwb3lw+z0OqKw9U0x\nAyMm7sStrpZkbiBRxliG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7144", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7144` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAc84lHUeWRwTUsX78Ce8qt/nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ZjBjNTUwLWIyZjMtNDIxMC1hMTkxLTJjMDc0YjZjZWI1ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JmZTEzN2ItZDA1\nOC00ZmJkLTgxZmUtMDczMWQxYTdjYzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE84LAKrzReadSfBc+zIvTMJP9uXVUPhiKR311vFwiL/nZuR/NF5alKfePFXUE\niaF76QRab9F5Lid8i3r6T8PNJaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIBODwuvhZAjYzutGJByopadszGtMB8GA1UdIwQY\nMBaAFPishq+zZQe4pt/a/DsDziU6ZBP0MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiA6ZJlXpGafzbRZ0v+f3gCCYMDcAyB3w9Ie\nqmSaDndN/AIhAJO8/sOxpcC+zjQ4gPfwT30YLOfIVMKQTuSahZXFnQCV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeDdf1O4Jh8c5xSK85zNMd+BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGYwYzU1MC1iMmYzLTQyMTAtYTE5MS0yYzA3NGI2Y2ViNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCfCiXkG5HF4Nv6bxqGuPfDZsv6apflLfK0jcxJ89sLhRF\n2ryQkW7MXmNgbO2hVrXqvYtsk7suJtIeUmUmBtY0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+KyGr7NlB7im39r8OwPOJTpk\nE/QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSNuNN5Nusmy0xCNeQ1dnZlzq36PpGH9sYit+oWNm/j4CIEoSbOHbkFO5\n/87Le4Slwce1C0VWT74yXitlnX5SydRp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbksk4/A3E7tG5Gn4OKo54HqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JmZTEzN2ItZDA1OC00ZmJkLTgxZmUtMDczMWQxYTdjYzk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTg5MDRkYzItNDQ0Ni00Y2M3LWI3OGEtNzM0MDg4YWQy\nY2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqeP7Pi5/joJg5F9Bp1ORyGZ9\nLu7fvL9RYtzWH1eMwS1hbUUaWrmEk6Y+COuRS4QifWJdU1oBnOdKYWucwNn6J6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgE4PC6+FkCNjO60YkHKilp2zMa0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFXx7pZn\n1rI2rg7+70XixSxNVnKk2HL2Grr64dMfRCpKAiEAioZloZYH0dsUPxhmSIjbDyz7\n3sDDRmf0JnoPr3vwB+s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7145", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7145` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAcwkOJvsiX8xHRoe72dvcGr9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwYzE5OTE4LWUyM2QtNDM0MC1hMDg5LWMzNDdlYzAwZTAwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjRhODk0Y2MtNGIx\nYS00ZTY4LWJiNzctYTkwZTBiMzhiMTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIHH+1zQ2djcmmHSL90nYO9wgbtaUaCeYj9J4wfiM1e2Bece3yM/PWAhi7H4z\nFaxstzybQSvDtuz/8cCTo9k9BaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWBY/5Zq6Sk272UPl1flnOr6X3x8wHwYDVR0j\nBBgwFoAUm2q+S9T9epFINUb71nHUNRdcZEUwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgDZCk58UohnRr\nax4TtYAQEN/ATdorYxUHTUeQTFUl3cwCICVBtLYcLRTMSSuh7qHfu/+IAcuEba/t\nMKa3IxEDYUla\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcER1t+f6M6tHaOrM6rlWlWWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGMxOTkxOC1lMjNkLTQzNDAtYTA4OS1jMzQ3ZWMwMGUwMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9nSnyscBszsl2mXsxBjSk5OmmmFevnfZN7pOftF+zuPhO\naHPJabm1CBBfypd1v3yNbNvXGZdC2HIALnmXx3Ejo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm2q+S9T9epFINUb71nHUNRdc\nZEUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALF0mkUxsHabjrO3F3Qr2JrsuP5ljbqUWJTOGuAZVmZjAiBnsCYrXbyw\nBeoBC3kdkR1Jv++hmLBIBDKCRtXQJzW93A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAb1TIprQ2v80n3dLy3W89JQ5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjRhODk0Y2MtNGIxYS00ZTY4LWJiNzctYTkwZTBiMzhiMTcyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODAxZjlhMmMtMjNhZC00ZDRjLWE0OTctYjEyMTJhYmI5\nM2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/dEF5mWfRvYuWR1cFEKkFtNG\nW4R8oF3wu3HHfWDMd5IjvDRZULgLeLUmJTcKptiAGMvPTTZJYvIUUo7RMDJNEKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWBY/5Zq6Sk272UPl1flnOr6X3x8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBGfwKOk\nj5bDWUbD0X62OAlDyKrJrmH3AatK9lAt4i6+AiEAqTTmLGLmCen5I4/8Vewj4ItO\nb80bI8Wl493ys1k+rwo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7146", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7146` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAVRHK6xTvda4GeysQbsCvHFlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlYjlmYWQzLWNiZmQtNGM3YS1hYzE0LTUxYWQ5NjZiNTQ5ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgxMzRlYmQtNDMy\nYy00ZDkyLTk4MTktMDZhZmI1MDE1NjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi99UvkFzmHU0wBAk5JDsRyQ9L1ih+F2E7ffUrJ9JdKV9G8EjNF2Q3QHDPiYh\n5yZEt4cnijYiD0sTXLLitjgNDqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ9yG1MqL1fN7NllG5hOKrL1bbeswHwYDVR0j\nBBgwFoAUAuA///kCXtuZoCxRZJ6aO1TheLIwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAO7NNAnWmJg6\npT8ehAxdhAh1IofvmGe1GS/eXX5L2C6pAiEAseYlgP1vDtlF9M8sQ6Cyrg9BzVpn\nH6SBpMa1alOMNno=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASwONs1gv7t+1rl9CvDBNljlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZWI5ZmFkMy1jYmZkLTRjN2EtYWMxNC01MWFkOTY2YjU0OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPMo06jv0taUIZP3SKll/Ht6v5alwGCTfiDXOPkWi2FAUb\nfGCnXlDFTe34uq1UMgSpeyqD1uI6HNjj1MUtpHbDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAuA///kCXtuZoCxRZJ6aO1Th\neLIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAInXdsjPSzDDTMRN4EmNcetEk5CaPKkwHOnhJdgb21TwAiBa4k6v1PQA\nWPaEDUnyLOcDJwGiBYvfDhzx5VzPexqHiA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAc01WJMeh5U+ckUXxZOtHfQhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgxMzRlYmQtNDMyYy00ZDkyLTk4MTktMDZhZmI1MDE1NjM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODUyOTI3MjQtZmE2NC00NTk3LWE5NWEtZTIyNWFkZmZl\nODJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnncUPcmDrigOY4KOnx8rCw50\n4zWH4gHQ0blb6V0j8kHmaEKjwYatscA+cVIATcFO5zufOGr048NLUV7OCJOrIqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ9yG1MqL1fN7NllG5hOKrL1bbeswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCYqU6t\nAXM5UENx+ceTIrgcodbGjqBuME8wFEPAdGS0hgIhAM7WjCRd9o474+gFO6NpxO2j\ntJU0A5cmjYYVsVmfDcUa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7147", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7147` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAarKHJYwBZ2sN4XyYvkoA9KmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzNmM0OGVhLWMzNjQtNGVhNC1hYTFjLWMyMDE3MDg0ODEwZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZjYjg5ODYtOTJh\nYi00NDIwLWIwZjEtNWNlNjhhNGYxMTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA10p3xdZyxOe9WHAtY0nalcQaE7t0+mwRWVc0BtmBrGp214bEtnMd/7d4iJR\nQpjItTGLOfS1A/mat6a0tSU56aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUspkNWZQIbaI5bmRbvSnW2wujFa8wHwYDVR0j\nBBgwFoAUyi4f4+mIYgUDCkYAuIGL04UJ1H4wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDbjTYMPb2pO\n2TDF02bNh7SG3QBZM5MdW8qpl2IONVJGAiEA7eSxz1BLy9pV43FLVKkwqjNPY3Bp\njLg74/MdiWBAD0Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcuaNQn9zQhJ2oJqFx5Sx0DbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzZjNDhlYS1jMzY0LTRlYTQtYWExYy1jMjAxNzA4NDgxMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBml4B7AkqsHE1DNDOhviufUDePmlpVngDGXAJFZSmNsm+\nQJq+cJi1UwUd1nVNKMAgtM5pfpPRvWcoygsup+CZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyi4f4+mIYgUDCkYAuIGL04UJ\n1H4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANGcpNBTCnB2ntvlsFsTieSOgi7+cexw4hNzL6kTzCh4AiEA27SwEkcO\n3RIAamYY4jaCTCaifhW6yPVOjVkZCuKLUNI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWPWu1n6DgDkTY7lBd1qlpo6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZjYjg5ODYtOTJhYi00NDIwLWIwZjEtNWNlNjhhNGYxMTYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2ZjOWI1MGEtZDQ2ZC00OTVmLTkxMDYtNzE2ZGNlMDI1\nMWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG9zUASyr+em10s5BMH94aUKi\nwyrvV5hGFCqGn2PNWR9PMrIEBYLrYCfs4nPqGAAFEkUUh1vRyIzPph5w0h4MwaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUspkNWZQIbaI5bmRbvSnW2wujFa8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCQ2Lsv\nnBl7PWlcA1CIyL+OysY/pzYMT7c98JgmIjG59gIgPAqD6LDvntMk8jHEc2O0KTTu\nn5oRrMwKqBBNJ2qfdus=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7148", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7148` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVzltS/pkPfIO83eNyapuNsPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjYjBkNzQ4LTc5YWYtNDU2MC04OTQxLTc2YTNjODE2NjE3ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJiMzYxMWItY2Fh\nOC00NWIzLWIxN2EtNjk5MTg5ZmIwMjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/q+tFHrYTq2A66cb2zMJUVoQC+zTsgzE1ADwT0wCeWbSgK65+nSrHvaf/TaT\nei5vt6EVKH7k6xLhdg35QCsl1aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Wlv5Q1iiJrvwAVjzr6F+y0vhLswHwYDVR0j\nBBgwFoAUvTKdGWYenWUSLluKTCPxTXA8QiYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC7wk1aNu7zZgdb65W9xxkVYiVB1Hw7ZLRXQGPKjJW/WgIgZhQUwIjq1bAZ\nSqOKstWliD/pS1CiSmf66hD4ADkQIp4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYuERZ37Z4YYA+BQ9g9usgdAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2IwZDc0OC03OWFmLTQ1NjAtODk0MS03NmEzYzgxNjYxN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuiEswQGTpyPu4XAVN8kwhiWWK7mMxBzipNS5ExlqQEmL7\nbu6pL5RLF8zbigt2VyloEeQadmUqNOkHH0OoYgFWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvTKdGWYenWUSLluKTCPxTXA8\nQiYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPjk5rYyT9Hpwj4fAHLULCu+b9OtPZ/8U2if24W4wDNkCIHO3hr+qyfeJ\npJagnpERpSDB3smzUWIVTh2vwbGdtxhI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAZ4Sw1Kld2KIQ2ok4TiAS6+2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJiMzYxMWItY2FhOC00NWIzLWIxN2EtNjk5MTg5ZmIwMjAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWM0NjZhMTctNzEzNy00MjcwLWI5YWEtNWE5OGRkNThj\nYTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWLahhl+yR6ctSyhGy0EzoRry\nBtql6R6OdDOCgL7LbcDozsYuLUZqP07QOeuo0S8+MFPh4NE0sKctBYBNpgXSlaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+Wlv5Q1iiJrvwAVjzr6F+y0vhLswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCcDv4y\nVE5OkiNI0FJhnZ2fPzyVmTWwpC9Bx9mJNoJ/qQIhAMrKWMLJpuMRXeiL+QgedaaR\nk4++msvLfkE+d9xVwWR3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7149", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7149` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUN/+4ZdkPPqNPaH6kC4y2PSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhZDc3MDJmLTU0ZjUtNGZhMS04ZWU1LTE5OTAzMGNkM2FkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTIzN2JkMGYtYjFm\nYy00YzQwLTkzNWQtYTE0NDNlMmE0MzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEezIQ5Gyix0WaRaBamU/i/+3nNWSwzyuudDhYlIYstKPB1C+zSOA6QZ0lxSTc\nNtNciUzUPb/ts/6FsMUjDiBA16OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUluQsACbBh1zzNdta85NDD1zerwYwHwYDVR0j\nBBgwFoAUOGmE1HvdHBpBIFaSXtJcIOrs3awwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDvCXx28GBCmVXkqwcLI4gMj6nXOv+zuLgVvaGgCKtgzwIhAJBF/7GhFHDO\nm1eS/z2LmXIu/fXHtkDXPDn5vmpFeMSA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbbPuPaHhKOd9YLpd7tdO/5DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWQ3NzAyZi01NGY1LTRmYTEtOGVlNS0xOTkwMzBjZDNhZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVMGAFTkFq+TmGoldEXzoHW85cjOliyvDMRpvQm8Ak1FmV\nvIIbDfNoXiOz3VHgTIbsU+1oW0M3IjCGCtyyDJnpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOGmE1HvdHBpBIFaSXtJcIOrs\n3awwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPGzlIMDxH2sSaCJw5ZHudqqRJciOzeUtjvkgAWov/sgAiAn00Mej78c\nowUYa7++NC7Nebuhcqh4jYpYdvQbrlZD+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdVTSWD9Vt5P9G/JhEWOHocdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTIzN2JkMGYtYjFmYy00YzQwLTkzNWQtYTE0NDNlMmE0MzM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmZjZmU5ZjktOGMzMS00MTRmLTk1Y2QtMWYwZjQxMDA1\nMzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3qM+XjslDufySngCcVh7MJ8K\nYmTBwyRvjmI+doUkmtePljete3FR0fIVVWnj00+dPSPFNil+7R2IcHPtBgHNn6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUluQsACbBh1zzNdta85NDD1zerwYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIEYhdx3M\n9zA66GrPlA3rjMFiwayII6UfgEJnCN4AK7DCAiEA4w7/vyXQMOzx5wJXP/M0u4dG\nInZ9LNYeo6gQKVVqD8I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7150", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7150` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAZfYe4rW9lAsZgspngtX/X2EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwOGM5NTMyLWRjYTgtNGVkZS05ZDY5LTJlNWUyNzc3Y2RiMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIwMTdhZjgtYzI0\nOS00MTdkLWE4OWYtNzU5ZDI1NjZjMjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhnj5w05FgLSzdJl9+GDqMwet/QrNDlm1ln8JbUAEJ+Sm9jACjZJJVIKOSAK6\nIQNf4zKYkFu2e+q/TBsRsIX1x6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU802MevwC/I488lvD0nkhGuOwo9owHwYDVR0j\nBBgwFoAUsZUIYdYYGSj0KYCpNEbPzhzm694wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDX\nQtpnEo0zg+DfjB6vErXyh2ridarOG0dacT/MzCm5OgIhAN8FCuEr92HBTZnAS55k\na+Qkaucd4tRHIgEOYDjKgFRI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWQc6uP6g4jdh8mold4dVTf4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDhjOTUzMi1kY2E4LTRlZGUtOWQ2OS0yZTVlMjc3N2NkYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHLRaepfW0Y0fc9Uw4EKsk2EyN40EXmdIwvmXMmx8V6J4c\nmDsDVPp5vi4U/jpGSpPuAPOT9A19AMi3lxzhPLVCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsZUIYdYYGSj0KYCpNEbPzhzm\n694wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANEcp/FMVkVpm50pvezOrM89WdRJfxUELyCyozjCyepDAiBx7Ehyps8H\nJOvBWSvaASZ/pe07yTr4zls+GVlyx21NTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAfCXunymuk6GH8Su6bSp4B3EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIwMTdhZjgtYzI0OS00MTdkLWE4OWYtNzU5ZDI1NjZjMjkzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjcwMjcyMjktZjc0ZC00NzczLWIwZmUtMTE4MzI4MWVm\nNDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr8T1oAoxYvdl4U8MyDzlKfYG\neyEPZmkemXwJKEn1udblkLDk1ct0ZKToQ+/I24Jizy/clfGYnzikVmUMODI/HaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU802MevwC/I488lvD0nkhGuOwo9owIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDAGjK7\nKsdOFTVJTC1d3PXj4jj6oJd0QOBH8lNu3NHxNgIhAOwJSi24jIPrfDGMDV6yLP4z\nbgP0A5MHnMtBfFdwTb8y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7151", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7151` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZNjkMojpL7N/oe/oj7gie6TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4N2M5NTk1LTUzMjctNGQyNy04ZjU0LTU4Y2FjMzVkNmI0NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM5MjFmOGYtZmM3\nOS00M2FmLWJlOTItYjFiNzY3MGY3ZGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaNCz6PAa4qfm4D5W81Zeivyy/eNMM0wRVRhfWl9VdhOEwJeEuWHHIzBxe2Px\nbkeGrKyVsVG3MByNraOSyqN0kqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm61xzKLbb8PqihG4AM8OpU2b1s0wHwYDVR0j\nBBgwFoAUA9ZlWPvmTLdrx7YPTM+1kzNH3AgwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCGMZ6jXXvOOZ4KNALUpzSSnWNCnTOsxQxurEbLTXhsPAIgVqfz\nIBeKlLMRWnHAXwypeflL/yZHk5QXxALpVWSX3nM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVCYZOWeJpdKVRmRxA1rOBY9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODdjOTU5NS01MzI3LTRkMjctOGY1NC01OGNhYzM1ZDZiNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpudoDxqacJoQ2SEPk4KoL7v8K+ZhydgaNNOjdCEYCXinp\nN4rh4EQiBSt6g/HCqhylOqTS+MAaLSlz9df7fnzKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA9ZlWPvmTLdrx7YPTM+1kzNH\n3AgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPOMq51lQLg1lLJqHrBalHCYIpcBFenx5Gmz7F7Ig877AiEAv3T8wjnE\noqonJVXCZnNvQgG5zvd7ZiWGqiWgG3ok5ko=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISARPT/WgMs3tj4qRNLTyIxBJBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM5MjFmOGYtZmM3OS00M2FmLWJlOTItYjFiNzY3MGY3ZGY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDcyMTU1MDUtMDY4ZC00MDJlLTljMjMtMWEwZjdlZGQ2\nODRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfQs8lOJ3OFD8Poi/WATYiJBU\nsDxhdcZicnDizcEs+b6ZKTJpkLnW8uPgzb19PM/vpeluqNYYASUAk5YzJbx8oqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm61xzKLbb8PqihG4AM8OpU2b1s0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDuwwa+M\nyG7is5VJV2ivc4laYdxOxA2oF+5+3+yV6P9CAiACBnkmjSXRA1iN6+YTNm1M/NGz\nyD/QrPInZAaPLnL1Zw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7152", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7152` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcgR3CSqJZM0FzO8p0QaL1m5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0M2MxMWRkLTA5NWEtNDYyMS1hNmNkLWFhYTJmYTc3YTRkZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDdlZmZjODQtMGYw\nMC00YzI5LWFhNWMtZTc2YWM2MmY5YmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh4JOdebVqs3UF63a//HGh/Ei88YMJ1eJd17Rw7Xc+HXNYjRAcv5BG7/GJ5ZU\nHLwsi2TnrrOd6JYtYvIyM6bHP6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/SCgwLG1/ExWH9iPleJFu11OLx0wHwYDVR0j\nBBgwFoAUZ5dwMMMxT/7dDT71hiJJ4Q3OjXswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIDRj6O0dybximaQplI8azsO5OEcRegJzSytxob6Zy6VnAiEAjJsE\nLhKS6zID4Z1/VvBY1cizD5M8hhFqCL9/CP6Qwic=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUQAXfeEyJB74YCdnMrYRv8oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDNjMTFkZC0wOTVhLTQ2MjEtYTZjZC1hYWEyZmE3N2E0ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfzL9qAM2YrkSICROacHj+3LJobvdGSj8wiH2Woe5ibUNt\nHUGxplC6u2XO7TIqhgf7uzFJrzdwnvzqpzBBgWiLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ5dwMMMxT/7dDT71hiJJ4Q3O\njXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM2qFLGb4zzbf7xLsMtqmvvRwaJAT9+NHJQYGyLMlSIpAiBfONUu9ubk\n6HQ5mqIL8WNHJwZwD6Fs48zHpgxNvGEucw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVMmw16QfY9kTy2ksShChN3bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDdlZmZjODQtMGYwMC00YzI5LWFhNWMtZTc2YWM2MmY5YmQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2JjMzAzMmYtNzc5My00MGU3LTkwZmEtOTQ4MDg0YWYw\nYzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfYeFpwIcOWab4L5wxtxepO10\nALWMldW7rWeYIQ41YcrKrUp4pOaqXbOh8Ooy5Z1tP8NMHF9amVuqF275/qXyhKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/SCgwLG1/ExWH9iPleJFu11OLx0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCPO8RU\nJ4aAbK1HAXLSDTfYy4cd6n9+fzCwZUC2NkrVhgIgAWKdXI7ALvuF08uavpZUE2Or\n8o4AT/xFC/PqSdnOeyA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7153", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7153` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZB6BV3hQnGXvH6OAJTb/UefMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkMmQ4ODA1LWM4NWMtNGE2OS1iMDk3LWI4OGM2YzY1ODE2NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc2MzllNDAtMDVh\nYi00NGRiLTg4ZjAtMmE4ODcxYzZiZGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnLLZGO3SF9VqtCysLJD1D2TO5crQdl9lmbJqSWcIuDMRfuYXTTwneNQ5Brng\nibFFmV/W3b8Hcr5mfonJlflQ0qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFH/trYKs6bKa61n/kagfb/qvxqa1MB8GA1UdIwQY\nMBaAFAe8fg5mwp5y7s0etdGmzY5XPqTsMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAlKO46lz5Snh6JG0QJxbTQ9Lv9vwBjlmo\nHFFJdveLwQcCID8EQI2OtRWW21DIPNPClDIqhZHnWWlc0GEvRldW63ON\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATuF14n8HJgk3EBReSQTgAJyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZDJkODgwNS1jODVjLTRhNjktYjA5Ny1iODhjNmM2NTgxNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSwIFSSteXeSoC67kdFTgUctFvqj+kzWQX5e7PZvwpTvWq\nCR4qtTM+CVI8+Sb/Mtu79e/l+XoygF/l/XcdAB3Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB7x+DmbCnnLuzR610abNjlc+\npOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFbT3ivkG0zIysHZxZZM/Z1xsQy/hOZkhyx5PlskMtaACIBP40jOuGxUV\nsob00dwTMM4Mm9xMyPvf+0EWn7v63GGT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASnpx0T4ED4aotX7dZCS2QQ0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc2MzllNDAtMDVhYi00NGRiLTg4ZjAtMmE4ODcxYzZiZGFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZjMTgwODEtYzBhYS00OGNhLWFmOGYtZWM5MzQ4Y2Ex\nZTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMwTWpPzpfJe12FJflM1dP9Vo\n2C7DNvEeAMoQkwmHSMfvD6pajTpKvtNZFYQ/tgYr5k1yEFIBOUWatdgg7qBPIqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUf+2tgqzpsprrWf+RqB9v+q/GprUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDJfMr9\nWda6mjB6n2gQq5OJwblyvfdvrEb3RFtvVfNTWQIhAJXQ1Qm7CFgAtq/a0qfUGo4+\nEqjW0j04yPNI9fWg9TfR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7154", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7154` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAZWA6BYPeZPHlMLfcCMoiJEzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjMzY0MGQzLTI5ZWYtNGNhYi04YzYyLWFiMTk2ZDk3N2M1MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM3NjA3NTctZTBl\nNy00OWY0LWFlNzAtNTVhMzRjNGYyZTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsMPfg84io8mB3cTWp2wAZPYl8fX+idlCYgF4RroCMy80/xx7x3FwTRn60i2i\nSCTRscmd17v/qMD3A4DXaywZaaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTbbP/GMgEq+AvFm6Cmbix//KwF0wHwYDVR0j\nBBgwFoAUzO3ajrYOVeeYEI4x299Vv0Jw8PswKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhALQzH1ECwXg1\nxgvv5yNJT17LBryDF1Hcmv6/O6MTT/FcAiEAnoZLEeVi7KSrDJFTLJuMVovwXcTT\nSmjyvFySn0pCj/Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQJRRXLGMDW+HP0UTKj8a3B6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzM2NDBkMy0yOWVmLTRjYWItOGM2Mi1hYjE5NmQ5NzdjNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqRHYAtETE/uRsNfBnJFtWxGiksohPUGzFH3gugjGNxg/3\n56QfcNa5GLUB+rkr6lq/9Vkhk8yydUCuEzR8mWvMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzO3ajrYOVeeYEI4x299Vv0Jw\n8PswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMdA7sXLaKnCR/ij1X+CUDpXoalILdzHynQ7vh31TrDhAiEAm5lCgsiq\nXBHk5XMczDFQLxXX1wcW5T8Wdn6c5/dFqhE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAdh9ir8tKBIZhGJp4mJGez9KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM3NjA3NTctZTBlNy00OWY0LWFlNzAtNTVhMzRjNGYyZTQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYThjNjJkYTItNDhkYi00YWM0LWJlOTQtYjg0MTg2ZTA4\nYTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEq1lOjX4jYpWVOIq6o3elsV7f\nm6CBsqsL1W+eH7439Y4IzYUgKlfDDpKTaypQS2S6UOrdQR5socotBCxI1H73OqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTbbP/GMgEq+AvFm6Cmbix//KwF0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIHoz722X\ng2xvt+AQ9Doc6hCuJncPxq7YMQjQo9NXWqZ3AiBQB1U9Y+HlRfyrloUaDAecYWA5\nAixv78f7onkFQruO6w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7155", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7155` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAXsf7fVkMVDI6cevFX6Ez99rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0ZmQ1ZWM2LTE2MTgtNDYyNC04YjMzLWZkMmFlNTc4ZDljYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWUxOGM1MDEtOTMz\nNi00YjFlLTk1MjMtMWVkMjM3ZDU4MzQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5QzP/ithfjmcpJDri6pJZTEEvmk3LfABV/Qdn42hZLe39jAqUJLiQtP9WWWx\nMKAxpUDJqcMAY5TW6Mc6WKQy1qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsPN8w4ZQ8E6bn87LRRxEj8Ynvo8wHwYDVR0j\nBBgwFoAU7Yag0fNuluLxJCr0GwmNw2zzeiswKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgJu/OT9cvjJaJ\nDV+Hadkl84fXA+YUzP3LQcVpz47aEs8CIGJXCksPmSlFbCAahVxkzuELf6hXYXUW\n61UszxoC2GkS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAduN5UprcXKcJCPYUk+SINdbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGZkNWVjNi0xNjE4LTQ2MjQtOGIzMy1mZDJhZTU3OGQ5Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9Q32ZV3eMZQ2gJ3DDUItaS2tL76ojR8flPB6Ksv52IRra\ntqjTBWxBy/Hhq/R97tp0q7lfxN/Gjpv+J7gXI1gvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Yag0fNuluLxJCr0GwmNw2zz\neiswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeNezQuR4Pi58Muy0iN0EenNOKc9lMxgtWHvby1JpIcECIBK/n4vCAkDG\n7Ufv7ve5qaIGUHDf+gSX0v6q3pcsGc4l\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYVuNAS44iNTrFhk14LibRE1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWUxOGM1MDEtOTMzNi00YjFlLTk1MjMtMWVkMjM3ZDU4MzQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjExMTVkYzktMjdmNi00M2Q3LTk3YTMtNjQ5N2M0MzYy\nNjIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqu3rrSt7vUjBmEvdxVwVhWVm\nnLHDbEc1FFuNchFBu7s4xoryiM0wolZ3h7EfUGZLlVybNhbhf1G1QsFe7fL9eaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsPN8w4ZQ8E6bn87LRRxEj8Ynvo8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCI0Ncy\nhC9z9XMyEo42zQmCaYaQuCxzZCDi2scZx41w4QIgOQsygrSdCuFE2FI4v+MjLHsp\n9ZcqB6xGLi1YChuJnco=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7156", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7156` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAd8u42cw3BHPLyqudq04b56bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhZmUyN2U2LTMwZjQtNDAzNC1hZTI1LWM5MTYyMDA2Yzg0ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U2Njg2MWUtOTI4\nZC00Y2MxLWExMDEtNTdiMjhmNmE3ZmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1uEtNPe6zu8Hq6RbDAs1XDliQTZ7jbNDbuBbq7GN8e44uOYZG2Z16l09B1oU\njSm37HH8VwOSnNAWGSltgyHHYqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ9WUFdp651vpQDSX5a5EV4OqSIQwHwYDVR0j\nBBgwFoAUC2Umh6129+mHS9MpNnaZOZXCRj4wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIG8qga7beouZ\nME860W/Mz1+hLEB1E+l63/NwAHjDC3GbAiAn0QK4hvlTAxMuxuZBL1VcO1NyG5xi\n4ywlPv/ctQ9mOQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWT5MR700HjSMnZopmnXjXbjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWZlMjdlNi0zMGY0LTQwMzQtYWUyNS1jOTE2MjAwNmM4NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoeQjrdodSucg4GyUBrx7oPYAGpNM8uk2QXmrvuc6o9aMt\nhMnO9r91Bld/delkgDtszMwEq1I9m2nn5Rl8uu+2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC2Umh6129+mHS9MpNnaZOZXC\nRj4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANe+4MOF3D/JY7657mNF1YRbogxg3i5qVvI7d9x3Q8XCAiBZNzxIbr0j\nWrExFp43RkKukEtqC4u17W1SyKTnv7/cVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISATJGmQltx+m6JhHIkrISAIGiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U2Njg2MWUtOTI4ZC00Y2MxLWExMDEtNTdiMjhmNmE3ZmE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjNlMWExNWYtN2ZiZC00NWMyLWE1ZjYtNGE4OWJhOTAy\nNDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjmXbIkg6WqJHxazt6XZJHM/k\npW+6h/z6F0VJ87ZGi7W43BSNl8rQkiw7vvsVlY01LkBHRwr3CWTiggMOkgcSfaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQ9WUFdp651vpQDSX5a5EV4OqSIQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBE0ZYda\nPQ4iOjrahOU72PZsMO8SYiOmDj85NWCzw0QYAiAVZC/jFvP5Z3DQs3zgYnUTinlX\ndD0YbNfrivUGCt4/XA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7157", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7157` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYKJsJSV4dXTAsO+G7Yxw/VTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyN2ZmNzg1LWY3ZTEtNDg2Ni04NjlhLTE1MzAwZmI0ZDEyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZhYzE5YzItY2Fj\nMy00ZWY3LTkyNWMtNTYzMjAyNDQ4Mjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtzbdaPiy75TGp6OpnjWdQQjO0L5BZKvh3aPhuhgkIbirtvHKU8zrHoKeSHA3\nb21II+jGyzBRQz2yKQyCHnLhOaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEly2zObP4vxvI68DLzQMLUh7th4wHwYDVR0j\nBBgwFoAU9kKxU2nJbZnuwVq6panDPP3fSREwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGC/dFgMy0eu+d/F/iFhcabd0F743nZBJIfB2Wl+7uH6AiEAxS3iu4BA3SKb\nqB31T6AKTnCHNVRNdnk9rWDmbh7ZW8w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAerfwN0gZ7DnY3Jx9LMKhscpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjdmZjc4NS1mN2UxLTQ4NjYtODY5YS0xNTMwMGZiNGQxMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPGzKArahTVQVm/pe8h3/nBqkGDkLsVarbkI6udHSO6atK\n+/n0XmAHkVpFaWCGfh/K8cF0nyVYVpNnTJ3EScVMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9kKxU2nJbZnuwVq6panDPP3f\nSREwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN++/Erk/q3wn5Kiyrpl3oQW/qijJHlXwfo612GAzoJUCICVwhkjdiDdj\nOVJGxNmN/Frl7QVhfhzgPKP8PE7UOe0Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAUd5p9GWfKemIji6eauxMeErMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZhYzE5YzItY2FjMy00ZWY3LTkyNWMtNTYzMjAyNDQ4Mjc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGQ3MGVkMzEtZTI4Mi00M2UyLWI0NDctMzE2MGYyYTIw\nOWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXomxwQrNmt3evokWM22guCha\nYNt5sKMSecAPb51cq8tGlxUwg7UpYq4a1ER18oNANBEiaCi2rpTjherGSqlkzqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEly2zObP4vxvI68DLzQMLUh7th4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD60kky\n82bpxbQta0iCBWXninEGvneINNBDzLW3ls0lrQIgbOoIzJhWPJIzbHnNHmjd0YIc\nyVhO+aDEBt5N1xVC6S0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7158", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7158` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbvFd4J0k6r5DZQ5MpXfvq21MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmMGE0MTRlLTNmMDQtNDVhNS05YjVhLTI3M2JkZjU0ZTRkZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk2Y2MzMDAtYjJj\nOC00NDIwLThiODUtYmYxZTdhZGVkMzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ0WY1LPKP0re4j2JoNchG2ht7CvRQw7aGAcySpdSegj2F0ScjwEbSKXK6QN5\nDZSZ0WB2wpqtAPJjWAujyrxNWaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOo164iL22iXs+nrS0oXtpVdUwMQwHwYDVR0j\nBBgwFoAUZov197w7cDYiQ/RezzovHKTvs0MwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCID2Ogf3sugAcTKKdbQHYpzzEIQMirziSX7q3HDjZmrTpAiBoODWPHV328hvi\n6DsmIaQtlVB1vv011R4IOBGFQKsm+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATQE7Gc/hefFrDmoBT/+Us8MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjBhNDE0ZS0zZjA0LTQ1YTUtOWI1YS0yNzNiZGY1NGU0ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH3yOXEu+TJcYPY/5EYnkMjoXvh9cfxn1QXNyvnf7Ofl5p\ntfaGf0Zlt5FUVqiijv7Z9emx33UFSDy/BVD+sS2ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZov197w7cDYiQ/RezzovHKTv\ns0MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMgCBKLvfY8TUzyPkFTqSvafh01GOaPvm76m0nW9h+btAiB+8kMB7j5U\nhId7lxhBOgSwAGr8fukeqgSKCBeJGEsblA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAV98LhCulq7SDwBSEGKqfcFrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk2Y2MzMDAtYjJjOC00NDIwLThiODUtYmYxZTdhZGVkMzQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTUxNjIyMzItODI2Mi00YjQxLWFkMmMtZWEzMjEyNmY4\nYzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEelC/mj66Rn25+/Mr0gHcUOZx\ngp/C1lEi17YLr8C0O0t/8tIxtOKyiTXSodmIUTJ630v9rgI6sbUZ3H+7T6T2zaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOo164iL22iXs+nrS0oXtpVdUwMQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIArSmj1z\n43PlrBFGyj290TF0jxk1dRf3RlmV5pd53ay1AiEA5uJ8ylyqCymXt0x9MZ0jJymV\nvue5GiS56rINte3hNuU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7159", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7159` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAZlOGtnC5RMIJgPR5DavNTaDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViZDhiNWVmLWYxZTktNGI4ZS04M2RlLTNkZTYxOWVmYjEwMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA5YWRmMDktODNk\nZS00YWQxLTliNmItZTlhYmM0ZDc2MjcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyfVJZHlJ6LW2wci7PNBw3UfvfYxQD63/XKCRnM6zGjNUvkcObQ+YX7MERDnS\nb52jySYmNmw8QtHkRkDmrSKLhqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6yT8Ak5TPdUR0Lln6ZeCYI1Y28AwHwYDVR0j\nBBgwFoAUlpg6tPkrKxI0twLnwtJ6gpZ454cwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD3\noAdxYPs47Qg0ma7sjt/IXECGrUuNOOeTukztlmAFNAIhAKqgP/1HTaD4QUp7CDzu\nHPV3kgm7uDIgXqjJ+2h4P43t\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQgknOLyoePjXN6TFdwgj49fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmQ4YjVlZi1mMWU5LTRiOGUtODNkZS0zZGU2MTllZmIxMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0dxV9AwA/MFJgpn+xVjsUcd7+phtuRI0VexqLcPgwKfjx\n5rznX8ie9sAxHe1br6KdikxqsatyQvu4aS953KQuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlpg6tPkrKxI0twLnwtJ6gpZ4\n54cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAqmU152w5TwmBEi+S8qfBs+zNz2IxBK41g9UzgdYERcCIQDjKzkKC/au\nJ13Vo0KuwagiTgctDVc3/r3/JiAo4cvO4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYvL1AYgW/mK22yYNsYS6aqYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA5YWRmMDktODNkZS00YWQxLTliNmItZTlhYmM0ZDc2MjcxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2I3MTViZmQtZTA4OC00YWQ3LWJkYmItOThlMTgwODBi\nMDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX1FWb+evosCcp6jUa/h/8cRy\n1y89erAJL8iiMsvMJM3rLNTYeDjaa9y1nf3pk5A4+RlkyzFx/T6bO5vWm1dKE6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6yT8Ak5TPdUR0Lln6ZeCYI1Y28AwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCICyZVhXK\nf8sElKC619ajg2AC2+3d7jYki0SY8Ev2nj1DAiEAgkaWnisCvDP8LmFMvOrTdwd6\nDSpiVqEh08evaoN3kbk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7160", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7160` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAeS+uOhEQIBk5YsFy7dqKCxhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhNjMwODBmLTI3ZDctNDg3YS05YzU5LWRjMTU4MWQ3ZGIwOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZhZTIzYjItMjdi\nMS00OTVmLTlmODQtZmJhZDZlMzkyNzVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6vnBNumVhmwa6j6gQsYEYECosc16aLK3+MQBJysOvnh7IQAUGLqblMziw6Of\na3PqG6Fv/uqHwUTEx8PRIKJuyKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYaAcmgYzwwoyMpuhH95EC3ZLkO8wHwYDVR0j\nBBgwFoAUca5V170e2X5cOzXYET4aJ/A1DyswOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDnxqThOLrwxbelyCYNHVSD3rpSPinm0q5HkM8fW204ewIhAJjp\nqCewQGnOjoF3q2U5m0Rd7psCPhRYf7hBAKrQyVMl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb7IEEseoOcFRef0pTNsJp0tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTYzMDgwZi0yN2Q3LTQ4N2EtOWM1OS1kYzE1ODFkN2RiMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjkudweAIO58yOKjxNaPw1UkgheUVpzIHnmoS81bP/ynmd\ns9fh4OtairxkA6jSa5MGBYM5elnPQLFoktiUMMmoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUca5V170e2X5cOzXYET4aJ/A1\nDyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPY3EsIrUH2K6PHn2wRvP4I9HivHtBPwBHhMVEea82tuAiBRnbfN2K4s\nIulfu2Jq+aoo9CVb8jkZ4CiB1AlWKBZN0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfHmnaGq95yiKKrGD3cRaA8HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZhZTIzYjItMjdiMS00OTVmLTlmODQtZmJhZDZlMzkyNzVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGE2N2ViZWUtMTZkMS00YmZhLWJlMjktYjY2YjQ5YTU0\nMjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwfBKvkKM9/4utS1QGGbv18T5\nfR2iKMIInT+CGHx26o+MZOiFRH4vF/JY5oV5NeNWUJw7aYnFT2me68uXF//Ij6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYaAcmgYzwwoyMpuhH95EC3ZLkO8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICxq/P+o\nNwRjYGVoS95cSYzhg+EJjt8CJD6CM1n9dBbZAiAIwUb1EFgx6lp5gnMG1ACGTzcS\nBiJFSLwwQsJdE6ZTiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7161", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7161` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAbwbI0BpjcOsZ9a8q/EOxPfjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjOWIyZjZiLWNmYzYtNDUxMS1iYWRkLTVhNTQ3ZDQ3MmI5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI1MDkwYzYtYWJl\nMy00YzRjLTg3MzUtNzU0Y2JjYjRiNzJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDo3bzluMNVqVj1rNgaEvp6kejdzKMoscOPLY1a3vDoLwzULwyFlKbtmNva7E\nAV1aH+MAclciVaqeHrhR5CvHUKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Wyq+dSe5HokNk5yI4s21riCx0swHwYDVR0j\nBBgwFoAU7HOdv+OnxirztF8837nTT05eWvYwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDu4SYfjH6qG2LPdSwDFmcwg/VKk0M3BEXmeMUXV94F6AIgPUfs\ncAvqt8LH2NpzYSqTf6PjZKzN7dvfe5Sa5UBBzNs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXWTXTCKmxyFhPWzR0n6szxMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzliMmY2Yi1jZmM2LTQ1MTEtYmFkZC01YTU0N2Q0NzJiOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7bVh6LM1nXY4yAw3qEBYSymzY42uK3pwmU8DbubjFU7WN\n+xLikmRYVDdSPXvQkE2qntC+QG5wa0Kk9pi6EzK+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7HOdv+OnxirztF8837nTT05e\nWvYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaDpLsF/q+TjaltuzyRgXG6ZSP/Cp+q/Tm1frweF6jUACIQCfd7ZqZ4O/\nAsvi1xoKmkg3AhxjX3vX7f3dqZOAWnrxuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQHeYbLXa7wrXlV8WElt+uH3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI1MDkwYzYtYWJlMy00YzRjLTg3MzUtNzU0Y2JjYjRiNzJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTlmMmQ4YWEtMTA0ZS00NWVjLTgyZjktY2RiYjc2NGVk\nZmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYdAdG9BVsdZjMhsMTLm2uB6B\nAR3xwHRvICVhDsetFPclVjqwM12VkbwiuoaGgiHOG7l2ip9iz8xDIQ3mzi35faN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0Wyq+dSe5HokNk5yI4s21riCx0swIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDwmWncl\nqU8ny/kli1I2YGQmLz/nu8QgLZMAtLFYSS81AiEAsVYyyHBY4OZP46j7SuEZi9Zk\nTDYirIIZgAkazCJgPas=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7162", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7162` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXbkp8XTTgUnxHTwNXKZqZeeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzNGMzM2ZjLTBhOTAtNDliMS1iMDgzLTI0M2MyYjVlMTk2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY0N2E4NGItYTFh\nZS00MGIyLTliODAtY2FkZjY4OTVkMzYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0emMTtdjXCCuxJ8vgD2VSxDzTEbJ4amyk7zKrfdxzfIQ06bgKgQlPM295e3p\nnlKKBWKnfVKzW60VHD8mzRRH8aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT3tCVA16d9THAgHXmstrdyW4sSyjAfBgNVHSME\nGDAWgBRe4uW8/PaDI4xlkzo1e/1IC4c9fzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCzYiHCMMYudQsQnLjuJLz2r58TSHel\nLZxhh3WYIS2W3AIgXKAlQx/ro+idd+2W4+RXqZZq7V6C+IlVw4p3NJdPkw4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfk0RnzmxPAdYIpFMwbI4b1hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzRjMzNmYy0wYTkwLTQ5YjEtYjA4My0yNDNjMmI1ZTE5NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7dTHkfAfDi0xqsvqFnS2+0Gur8UEQkhiykeiEvAaRWzj4\n2PEbUfVGSFNrDo6O1VHY5hKX1wHTcOHyJpSDEGBGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXuLlvPz2gyOMZZM6NXv9SAuH\nPX8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIElykFIVuOowzbbTnvgTp+8gYwi7MITYUQaU82omPSYCIQCb1bYoygKp\nKsMI74w+Ed4NTT2yok8kHBXGt5/yHG0xjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfC1PQg8DR0DFEn/Ugujvr3jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY0N2E4NGItYTFhZS00MGIyLTliODAtY2FkZjY4OTVkMzYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODZiYWFlNmUtY2FmNi00MDZlLTg2ZDEtYzA5MzJjNjM4\nNDQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfXifCy0WNvkf7JCm9kcf5fxk\nqkB0MZMXcHpmgQuRfHdE5iD+Rc6IbN7F98DxnrXKFmcfm+AK8WcduUnM3sqftaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU97QlQNenfUxwIB15rLa3cluLEsowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDkKSqNv\nCywhR09WKB80xzpoSIl6IiINO6uajwxOajXmAiB7L5M/IZWz5/4faJgZdZ6qL94E\nxWfA9wH4Y/1Bac4LwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7163", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7163` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWBME4R7apKJK0lN2O985TB/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4M2MzYjllLTQwMGYtNGNmOS04MTM5LTExZWUxYjNmNTVlODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdiMzM5OTItNWY4\nYi00MDM3LWEzMWItODEzMzhlYjUwMGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9+weAq6HzbulHk93zhTmB3pAzhcvvHZwc+zQuxVUOph3oTnry43nSyywqNei\ngWkF3N3s/GIJCqeNBAmbcNZRFqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxefNL5krcdMSFyhDls5noPW7QVYwHwYDVR0j\nBBgwFoAUm/1Cem9T0qMi59wIleST//1AIMowKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGoX6ae8s3ES\nEaCi+qY4TZGj4iPiKRpej4Qos9hziZu0AiEAxcawxyFGbVIghCNJL4eD8oL/YUwF\nwpILxzVGJwfiEG8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbFS1mNX8FAb3CpHqJ7P4jJwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODNjM2I5ZS00MDBmLTRjZjktODEzOS0xMWVlMWIzZjU1ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASt80SeJPsgU+I77gRJAE0Pqnx8owieRJtVNKT/qY3ln6dd\nQ1fr2WBgPtolz0fARnl1tD4opouP4sEW02TNEYTZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm/1Cem9T0qMi59wIleST//1A\nIMowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbmn720nMbC5GAobOiX8614lBCTGgmB/Mwpu7LGCLrMgCIQCYNVf2Vj/j\nDDIBDbLDM0yZNWcJY0dyUdGdu9VPFWuOpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZIpY2NRE1pVVskdg7tFZpHkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdiMzM5OTItNWY4Yi00MDM3LWEzMWItODEzMzhlYjUwMGM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ZjZmE4OTUtZWJkMy00NDAzLTkzNTgtYWY1NDlkZGI1\nZDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZ8cn7IX6LJie0fuqJGPh8+F0\nWxsDe8LWMALkq/giLWus+xPIvjrCgD5tjQ7zKXuTLHsxVz7anAPsFYJ3D5+mM6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxefNL5krcdMSFyhDls5noPW7QVYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD+DOhV\ncSY7KLcHde3eZENIEZ9BEYcEA4PHCALNlxC24AIgMhIhoeVlc0LRfCLlDkCEhuNt\nRNoh177X5CXyI79guus=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7164", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7164` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAby/jAEDSw7Mgtlg90F/yGJRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3ZjFiMzU1LWE4MDktNDdmOC1hY2Q5LWVlNGZjMDJmOTFmMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmMyMTcwNGUtYTI2\nNC00MmNmLTk4ZjAtYTBiMTIzOWE3ZTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwbV/0ihC4AZhkNG+zdG3AFi0wtU9zsdnh/ZKTEr7fI81iGgAIEUYBnS6vXmT\nXQdgWTVoHQ4z+TohgoDdHAj5gaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUprD1nfPAmEHPiOXWTGmSqoNIRnYwHwYDVR0j\nBBgwFoAU9wpDJrtxH8ULv/kjnm7ywdZAG2QwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAepdUWJ6aR+\nT0qqLWdYKfzpP1u2yyhvX32lLfRIOtrlAiAOZEn3Lxg0G54oSDFg6l4rNFtjh1P5\nUWbWoOdLffNA7g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaYcURaY8q3fdwjRVPUHWOrkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2YxYjM1NS1hODA5LTQ3ZjgtYWNkOS1lZTRmYzAyZjkxZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATH/UW+hIZLYhTU9I4V4LBWHjmpIe+Q7V9ycHzYlNuilmOg\nJEtdzKEiPK7QmclKyPs4uLz/XZaxHDuqmnR3oKhfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9wpDJrtxH8ULv/kjnm7ywdZA\nG2QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI7EDGMS2HUTomhjw3h1KGn8g/ENnIzTG0QdJcIXZwZpAiEA/TJ0YpvL\n6bpv3ppaGj4V2OmutLYeH4OALxzTvqvWRts=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAcldil8RB4e9dJaepk7+ifniMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmMyMTcwNGUtYTI2NC00MmNmLTk4ZjAtYTBiMTIzOWE3ZTlmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTRmOWQ4NDAtOTQ1OS00MWM2LWIwZTktZjEzYzgwZTcy\nN2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZX+V2TztQWB0WokceW29sbiz\nK3GfofCzrwVfeXAuWBYxlqBtkd0dpV89QRE37tt2tX6Nrb4D4QcDZVH0oapMmqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUprD1nfPAmEHPiOXWTGmSqoNIRnYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCx5wgG\n+d7fC1957nWfWSZlcemUp71gunse1xcu455SFAIhAMqjfhF8CHr2++8iVRrlN7Xi\n4pzxbxFKybfwXNPcyBO7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7165", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7165` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISATy1SSHwEimCwAQf9CGT9gBrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyNzk2OWI3LTE0ODktNDJmZC1iNGMyLWU4ODVhMWNmOGI2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA0OWFhNTAtY2Zj\nMy00NmI3LTg2MzItNjU5NTg0NjI3NGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6ZfKCL0iar0cB0UZolzioTar3/W0+3bXDCF2o7stNSFZbbN+Nb9IRCw7Qr1g\na52S+azvmR1L+T38LdHLCW0wtKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxhehi5HZ2+KEMbnHFuA84pl2AbAwHwYDVR0j\nBBgwFoAUde9iGL2r31W6NZpXkLPWwjTKi8IwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEApIYuXsPc\nxgNLVRaCb4ZdHht5y4C4JPLOgqVhir2sEqICIQDQGK/yIiKJkoPMyccjbiEg74Lf\nyIgcnu/J2WnwJwluvQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU9HX9WFDKm7kW2F/Y74HsDDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjc5NjliNy0xNDg5LTQyZmQtYjRjMi1lODg1YTFjZjhiNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjGywZ5VuKfru7dscKVwV9zzNvQrq7n5VsMJalBI6ke/Xr\nY0voQ9Z7nqJ9m3stx6gEy4WPbnuV5DKHHW2HbCR0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUde9iGL2r31W6NZpXkLPWwjTK\ni8IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN7dBU7WKzjjikS5TOdn/1uh+/uwGbCxAM/sTHApvu3AAiBqqCWafs7r\nFdwrkajxi9Pq5cnw/GQajjVOCocIw7dMuQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASlPfHm0+Xt7c48FDmho3Y1xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA0OWFhNTAtY2ZjMy00NmI3LTg2MzItNjU5NTg0NjI3NGFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTMzNWY5OWUtNzVjZi00MGIyLWIyNjAtNzQ4MjMzY2Vh\nZTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAlFDePMjWfKdb532awdgcubA\nwTbumQPa+JU3yJZb2SVO2G6nSD+eT+T2UkUtPBs9bIiZAIEfa2OPaLh6ROgymKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxhehi5HZ2+KEMbnHFuA84pl2AbAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCmASY9\n1tuHQNtO0n4fKZiiK9PdozTt88F3g7Lvos3xxQIhAO73XpTVF5Np7wGe9p7E62Ev\nTHPUaEIf2q+Jh8V90RNL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7166", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7166` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAXJU6gb83XvZL79zaQoYZSkkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MjVjMTFkLTdkY2QtNGNkNi04Y2MzLTI4OTY4MWQ0OTg0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQyNjk1NjMtZTNm\nMi00MWM1LTk3MzMtNjA3ODFjYjdhN2Y0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAsSEeWVF/wXSGOopPmNVZxVly6uH1Seg8qTl5UY4GYFJRN6ohuay3RcU3wgX\ny8SO+Ho9LIvrm7cuPHfP8oF35aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+dSyM3IIHI61DtxHXSCr86L//iwwHwYDVR0j\nBBgwFoAUjlZVsbQ4FRxaomff6ougoHj25h0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA7YD6xfbFz/3ago+q+1EG/uSwkX9Xh7OQIgFGcn8KN0cCIDxaaHdBtfmY\nTjqHg5R6V2BhaWJfto8TnZd7zslLbQUJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS2Rs0J/TdLbLHx9AemGGR5YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODI1YzExZC03ZGNkLTRjZDYtOGNjMy0yODk2ODFkNDk4NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRDNXQepfZnaq5RLdwI9JPwZ6SxWGRIh2KfBAKlJP//7WD\nTBq4nGGJf1+an2Y14x/Ba/5LV7dKCUThqHU96HDxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjlZVsbQ4FRxaomff6ougoHj2\n5h0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALIY7WsskfxhKe6lkmUwslxOX4rGDZdJDSWcx1NpuYVSAiARQWAr8IwT\nQ4rplpqY27MdS4xacUj93yJ39GthiEVCrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAU+Gq1kcyr0Mz+9kH6O4Abl5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQyNjk1NjMtZTNmMi00MWM1LTk3MzMtNjA3ODFjYjdhN2Y0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGIwMjA0MTEtNmZiZi00M2MxLTgyY2EtODcwNzhiNjc5\nNGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpW2K+J9UV96VJLHJYUvm+5Bx\nhpilBV8o6cC24rliOCcLrJl9InlN3IOdBFE9b7EHt7uvjD8hszTkppX6WKsAsaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+dSyM3IIHI61DtxHXSCr86L//iwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIF4LGmpz\nOEQIz32RwfZycyUqaKp5rRqGyFTbYP9LDKioAiBvvmXqw4Y8NNU6N4isdeEP4UaN\nmozWx44VEs6giDAeJw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7167", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7167` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQMyrqeiIkNIouKFe6z+XkfEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczNGZiNTRjLWE3ODYtNDBjZC1hNDE3LWRhMTkzNjk3ZTEwYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRiMzkyMDgtN2Y3\nNi00OTIwLTk5YWUtYjFhZjZiNmI3M2UwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESPILWEyf/IoL/0ClVBwPRVh5TgZArjsf9ipmh5S/hKXPMWOAP/qkcwcA2cFk\nDVcSBaaHnMYVCMTtsujkKqcLqqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9nymUkpPf9QXAZ8ICgqIlamEcsEwHwYDVR0j\nBBgwFoAUQkXYXlKDGUIX03ELGFJa+HKWKuMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA/8+GOuUIxQfFsweyvr2kjd5mypkT2AK/pEuR2yKo8T8CIHI4DzWEcm33\nm8EweH2AVhNVjAVjm4RbrgVySan9185S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcFlNPnIPb/0Fow7J6vGCJ4yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzRmYjU0Yy1hNzg2LTQwY2QtYTQxNy1kYTE5MzY5N2UxMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARL3p5/b6knxrc/YREYlszRe2FdW7klqTERFFnfyDMuTGD0\nis2IiS9aCEztmlxFQ3TKgbLsOnTJYvhIlNO6t9OHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQkXYXlKDGUIX03ELGFJa+HKW\nKuMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSJGSNz9ofq+JVDaeyQO+ofAvSKHXRPlBaDVGkVOGoVYCIQCvUJFbChxp\nm/ENBCxMOOB1omvRKts596vpwTD3Zeho1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAaj//54om9MMclT2IzWyKdR4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRiMzkyMDgtN2Y3Ni00OTIwLTk5YWUtYjFhZjZiNmI3M2UwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTI0ZmI3NzMtNjMzNS00YTAwLWI2MDMtNWM1NTczN2Uw\nM2RiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEylfUYXQI9L0ptv4y32B0+LpS\nKg3bWAwhaUCqmda2Pn+eyyprCvwY9NxPPRGvVLD5UNwWsNfQaurgd/YvS0LNoKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9nymUkpPf9QXAZ8ICgqIlamEcsEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC2k0so\nhAqSSwAVSdUjxQkyUyYKX59TkZlZSLSC2xunoAIhAPux3oLgXZF6lqEIgEUhH5S/\n6LdqB0rpLf4etfsSK7OX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7168", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7168` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAdL9pbKXyZU1mviZsrgEPj/SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlZDc2MDNiLWY5YTUtNGIwYy1iYjQwLWU3YzE5MDY2OWYxMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBlN2ZmNWYtYzI3\nMy00MjJhLTllZTctNzc5NGE0ZWRiMDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnjyWE47EZkIYdXpJ6NaN1IRWB+9lA5WffTTaSb82FyZ9VreHz+8jkm+RBIHI\n6fRGcO/jGhiNSalzQn1dopcabqOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtOjjF1WoG7VTruMVO08F7rqe2KgwHwYDVR0j\nBBgwFoAUZR2AjRsaSVjGUj4IIDo5ANUj/kMwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\np8mzNYbhetAfu85d7pX8gaFuh/KtZ5VZ5/1IuovO5DQCIClfqSGgtgIpd/7QfFU+\ndwZB0i2h+G1HGZu8vyCX+7Mz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASrmvVMZRlRjtGN7eEqhUj1yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWQ3NjAzYi1mOWE1LTRiMGMtYmI0MC1lN2MxOTA2NjlmMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeq+XU5b8ORd8aprNKV4HFH7ztRlWslQagdGLOkd/ZQ0WO\nwGDuA2LN461YwyJ0fMkmfjko4ks7F/4hTx3atrdIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZR2AjRsaSVjGUj4IIDo5ANUj\n/kMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGUngO1Q41QVs01fFny8Q7KlMzKqTmsj+2C/I3ddrYQgCIQCn2CcD6sL/\nMikjGHcO1byTnoqHOK5rkCEJi55OK8oSKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAQ2A7Nrncnvku0SbJotWxkzdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBlN2ZmNWYtYzI3My00MjJhLTllZTctNzc5NGE0ZWRiMDBmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDI0NDE0ODItYjkzMC00MDJkLWJkMjktMzNkOTlmOGFh\nYWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJSoQToK9WNJPVQjQ/C8jWJ+a\nyg4LiMtoc3KQ/E7Hj6TJg6yWD6z1DzGzOUBE7+1t3lGoEJb0AXkpU+TmmrXVj6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtOjjF1WoG7VTruMVO08F7rqe2KgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDepJSV\nA05S1EbCq8I0tzG0e65+h4u0TS9Wlqrp3BqvQwIhANZ3itVJ0jTOe+9+lE3t9hgL\nGMUMb/jMgv3NZNSHnN84\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7169", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7169` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAfseHUTOw8j+Q+u3PmwvMyivMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkYzgzMTg2LTM4YzctNDNhOC05NGQzLWQ4YzkwNTA3MjA3MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJiODRmMzQtODAz\nYS00NGU5LWJmZmYtZTlhMjRiZWRhYTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETfLs5uW4V/Zl0jIAcx4bf9VLTWKl9ERcdrStpH+yPLnROaFbIBcgcmV/Gcr3\nv1QQM7jbIWrCIFju0j+qgYqtLqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsmjsiwWb8oXiXdL7zWK3EpUKP60wHwYDVR0j\nBBgwFoAUb9Pn50SccJXdH7c8GoX96NR8MzEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiB7t1kACxhh6fILeCO6UKONwgrSGHugyeuiBjiyB3RGkgIhAPlS\nf4hPtl4YkB7PtMEIfx3MaZxT7RZCIT3PkHy3jJud\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVB+cCrGemhZ2eUxngslC7n8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGM4MzE4Ni0zOGM3LTQzYTgtOTRkMy1kOGM5MDUwNzIwNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATP8kei1ZPjHBfNMnOaXRvm/QjLAfCYjniR1Hqo/8j+PTJu\nLzHSnfRs7RFPPnY84N+EZPKErlUnkr2ODlSreF/3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb9Pn50SccJXdH7c8GoX96NR8\nMzEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALr9go2dHiWu+JmuLMQGmhSKhfuqeVxRq7GHmzA7eWRUAiANIwUj0xRh\nyy/Zos7USf3k3CEVdG5qo51FkzZ95fq1Ig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAZGol1lGOHQKRGuJXJGb+nz9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJiODRmMzQtODAzYS00NGU5LWJmZmYtZTlhMjRiZWRhYTVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWVkMjA2Y2EtMjgwYi00NWRhLWI1N2YtYWQxZDE4NDdi\nMTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETK6PTfMbrWHdMxtkQ425jjuF\nBeFxtWlenJpb9L/hPQn2DfSQxFy7ZRUqVXFpFu64xCSS1aCEZmQTT+1nGmTnp6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsmjsiwWb8oXiXdL7zWK3EpUKP60wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDi04h1K\nj68RHBNkomtutG1B3OCk8EcK12IvrgnE0WulAiAwTZ5vdwm0DSVAn2TLOdA/hVW3\nZGr/oqNRRXXuwqqAUg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7170", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7170` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAX9ZKVDFpH6pCpMxgZyBhWUEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3NWZkZjYzLTE5OTgtNDA4Ny04NTRiLWY5NTU3ZWNkYWJkMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJjMzE1NDctM2Y1\nOC00OGJkLWI3YTctODcxNDg4YmY5ZWY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYcXN+EWAFdegb0ZarDRlTBoYAt6NWy9Nx+akKpP/gxHxI0Y6DvQPP64dT6yr\nQYWcOtDpwP9AcNUGEBimoguJBaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTDR3+FOUpZWcd5lNkfLxbK0iG+YwHwYDVR0j\nBBgwFoAUGmzOJTxj69WazmOdB1nj7eZkqvAwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEApSLtzjz3l+pU2YVwI9V6ux4Ms+tu1gUDxkOnDywofDECIC4a\nVeuNQcycyBHouOfV0KA5IpScRibh/sXEs/6yWSbw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbnXkwBdXukPMVHarOLo+FfKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzVmZGY2My0xOTk4LTQwODctODU0Yi1mOTU1N2VjZGFiZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzw1llNBBwtP2vZFbnXRz1pMhgVSc5Zx4dVcXEnwkaLDHA\nBw9eAbeBdKOq9X/IvjF3jKt82fIdq4AhnhkDhkjso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGmzOJTxj69WazmOdB1nj7eZk\nqvAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNM3TcBDbqwWMhmwzv05J93AdLP2lT0JHdpYLDuYetOkCICHw2RKYns8K\nzn0C8PEuwPX4x1FdsCfCkRtKPrF0/BXi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAV4DwzsBjWhI2kIogk/qxxKrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJjMzE1NDctM2Y1OC00OGJkLWI3YTctODcxNDg4YmY5ZWY1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzEyZGJjNTctMzQ3NC00ODRiLWE3MWEtYjU2ZTQzMTdh\nZWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYyuReuS6otmnXs9QkYUDX/PM\n09JbEzlalNRL14JZ1NzTa8qxRwzbYXK2tBqG2NiuUsSrYd56elh7xXmA4aw/UqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTDR3+FOUpZWcd5lNkfLxbK0iG+YwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIARuiVWb\nRjROE38P+pnxcvn8pz566PA38+aDzuwRxrRrAiEA94nUKqRYvQxv5K/qY8jbdzzz\n5XTuPtASKxfL6jNpLSo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7171", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7171` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAd+TTt5KiFXkLeGMIGiLRMxFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiODViZmJlLWFjNWMtNDRlOS04ODM0LTc2MTcwY2ExNzM1MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI3MmI0Y2ItYjQ4\nYy00NzRmLWFmNTYtZWU4ODEzYWI5MjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXBC6KTAuU8buaGMMIwDpx2umL+7+wZEO5g3S9H2xtF9yfPM8Df4u8bPTZaCS\n3yhf57H34XF6E6sLNn3pWxJEjKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2af2uiG8Myxs2R02oKvOwbWWbDQwHwYDVR0j\nBBgwFoAUxEDfE1vb+Nk4YAcmDiTf6KCs/TkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBRUEjPyB2yZC4j\n4MkVCg3OoQ5MWdvq4M1VCdu8OE4MeAIgd9m5Csf5U5YrTlM1ds7jppl66V+fqBh2\nbu1EERXygjg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdiyJ2FzFsaVcggQ2QdWL2xLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjg1YmZiZS1hYzVjLTQ0ZTktODgzNC03NjE3MGNhMTczNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxv4w/cvayy4ILto6lJtMiUAWcR4P77SDIMGKH3xTqfpdq\nqf6okY1KvbkCvKQSKXitVzwAHJLHkOeKokL6fXI5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxEDfE1vb+Nk4YAcmDiTf6KCs\n/TkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIFypMg5IghhxPB4E2oEEGaFtNxMd4nmQfdttvU5r0ZxAiEAySPj6CGX\nXjAAutLtPXMswoMWw+L+iifEPdH9oKt/XKE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUOhRndOGTPRvs2Ji6sRBBNLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI3MmI0Y2ItYjQ4Yy00NzRmLWFmNTYtZWU4ODEzYWI5MjFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGQyMGYxOGItMmVhZS00NTlhLTg5MGMtMjkxNTUzNmVk\nYTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpqUzfSF7/ZnPOXGYm+ZSIB8E\nSAgW9ukc6QN1bUrrnwVbryHFj/LufLqXCdAwdAjZ/Vjq6D/U8TeoBmHvBIHp4qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2af2uiG8Myxs2R02oKvOwbWWbDQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDTDI+r\n5JCLEeq2RoPlEI4XPROTk77emfps8hIB0biPegIhAOMhl2UzajxvQiJzn+UBk3Uo\npeEZns4fHr1aJl9wQtRI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7172", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7172` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATzTrS15jcUi0FWe/Kj7kWWFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5N2U5MDUxLTM2YmItNGNjMC1iZWZkLTBiYzIwMGYyNDM2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU2OGM5MGMtOTY1\nOC00NTFlLTg4NDktM2I3YWY4NGJiMWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIHRF3FqKXwhHuvMTi4ea+ceiBFBNeNpI30EEPSn07iDBsL+jsu/hkTrTSai3\nVySLITV/hzToo6CfPEXTKzNI/6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG44rkQBPxK3cjshViVhlCiOX3F4wHwYDVR0j\nBBgwFoAULhgZE6mcuOUbBbhONpyWYQaaT8UwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCavfFIQ8c24Th3ihNDO3CVujugmd+DOslYsA4Veaez8wIgAfdSDZELcS5S\n1Q3QmrQwE7zc8XKfgyKfqUeE4xSo8yA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdn2T89OQCRf7k5K1fAtUlKrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTdlOTA1MS0zNmJiLTRjYzAtYmVmZC0wYmMyMDBmMjQzNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUFlynstyzEFPUT7EyfTPLG4bSwpBUSmF7qAYdJe8bobIM\namcQeDYtvRgf8PObrb+g1Yzcs3TCvcu3JK4cnP3zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULhgZE6mcuOUbBbhONpyWYQaa\nT8UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN7I5z/Tm8XGHy0r8kYgIg3fZpclNHFAqt9npHtlMUHzAiEAu6gqNFZs\nmegutwshYaMWiI4RdwBuWmkO7M45Zxx3Utc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaCbJficcasxdGYxB9aAFTzOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU2OGM5MGMtOTY1OC00NTFlLTg4NDktM2I3YWY4NGJiMWJjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGVkM2I2NDMtODY3Ni00NzJiLWI0NDUtY2U3MTRiZTE4\nYzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4fgMXniy8/86qO60dOS31Pef\nBrJ2TFxHHCeG/BwFjrQUQqCeT1WLH9p5yhGtT9fTUQn7qsL0EBpKEFC+SC/lmKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUG44rkQBPxK3cjshViVhlCiOX3F4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDGvvSXT\ndwfXRF3peiW8QKFqD0hn5/l9OamBZf06F4xhAiEAmPX3AsSvyzm86iKhawM6b+au\nkRbMpuMtKW8cJsIIiww=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7173", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7173` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATLvxL1fP0L/QuuUfzmnAOvlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0Y2E1N2IzLTJjZmItNDVkNi05NWJjLTExZGFhNzllYTRhODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdlMTdkNzEtYzAz\nOC00M2JlLWEwZmItMGJiMjJkMGMwZThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6+H26yM2NR15AQehBJXRyxniEFHyVN8kmrWQSksD+ZqKd5RIRDZzehUgxwP/\nihiXhsyin1BxLtS5LaZ3ud8b5aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKTDUO2ZwjLK0U+rVpbV5sgZDyz8wHwYDVR0j\nBBgwFoAUW4BH62PbQfZP+FisoEAhtxiZMicwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAMSynQNhKXg2yulOTAZrK1rHgjP4gVr7Uys8PJWk4qsAiBDnqj+xuXi3XZa\nWiZdCplFtGXaMcqfVMnMzr6AmQmuwA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe85mg8JU9hAGZAp/ZG4/ufgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGNhNTdiMy0yY2ZiLTQ1ZDYtOTViYy0xMWRhYTc5ZWE0YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgIh1/fMIKcjEeidsT3uclKPOd/TKwytgzPGiaEMmGKopw\na5l6luTHRzW/cgxdaZ/aFmVXpevswkehBaCdfQZjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW4BH62PbQfZP+FisoEAhtxiZ\nMicwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP7u85RGjYJuUe1jrohCkJ1sVRVoHunhJLIixiqeMNDkAiEAxsIcazAM\nJJCRyi4NVcqobfonG+l71mlRhrdj41rSnko=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQvGPgKwmHdloQ3IgyM1wGkLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdlMTdkNzEtYzAzOC00M2JlLWEwZmItMGJiMjJkMGMwZThiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2U0Y2MxNTUtODRhNS00M2IyLWE1MmEtYTE1MzY1ZDVm\nMzQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3q230aK2Yz5/k/JGTGhIgTTE\nF77YU6loN8CBO4vp38lDL7w58ZRjXXyhG9t8fDI+SZQkTMdW2m6Y2y+M9yrg/qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKTDUO2ZwjLK0U+rVpbV5sgZDyz8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD68yBB\n7P85/r0S9K/Nt50FDdqpQZdgJ9q3EgHgeEhZGgIgW9i4VgoTanoP0rRCtMcCN78u\nRQ6vahydCsOdv+xhr0U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7174", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7174` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAftjiaJ1w8WY0Hw1K5TFdPGHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4NjI3YmJlLTVmYjktNDUyNC04ZjU4LWU2ZWRiNWI0MGFjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTMwNThjZTktNDA1\nZi00YjQwLTgwZjAtMDllZjgyYTZlYjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESy9NMcLyansrhC5A80lof0tdqIvax2EkeWOF9mlutJMz4b+RGMYZLbNYMS0X\nd8TbjtJdzRKdQ1siKun1eO9arKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvi0gaWRglXukqyji+6a9l4T6knQwHwYDVR0j\nBBgwFoAUyNVeqfy9hA0p+vJjK6eAwUQadm0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAxwVNaRZ0Z1RO9q938qMUifhZut97GMDoabDthxNXpHAIgHSCvAvRwZGwA\noaJXT0dnAvrviF3uYgS0kf19R7Q5qro=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdTaR8tEPIEcSLNhNZEVKezMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODYyN2JiZS01ZmI5LTQ1MjQtOGY1OC1lNmVkYjViNDBhYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQckyhrT+ov7BF1sPk+g8EXbeiCAHK2URqz/HPDKFIWkxog\nrPEKzICHUootBcChixXZLMNWCTMTXcwrjkdlpyX0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyNVeqfy9hA0p+vJjK6eAwUQa\ndm0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgI5x5PFs79EWWyp3JTo50BDPLrerWLZt6aSFqQ2bwCWkCIQDGOxZ5T+p4\n6skD57hO1GnxiBhVbcynRMgLzdQy4bBWtA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAcQjuYldSiXqRaVRCdIy8Oe9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTMwNThjZTktNDA1Zi00YjQwLTgwZjAtMDllZjgyYTZlYjA2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGYxYmVjOWYtYzE5Ni00MmVjLWExMTUtMWNlYmUxZDk1\nMWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw6/jw3Bw825t4mcdCuT/gjjS\nOC92J47D9CmR+wpPheCiz9U/0p5X+VcCHciikluuQ3Bxe3m+y/8hSR+dohpCVaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvi0gaWRglXukqyji+6a9l4T6knQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFJSUEDi\nATPZmTk+XJUd35IjfLz/8OVuFKHzDSTFsjpqAiBgDEKaVR63KO3WLYUD36r1ayKA\n4dDsDuY91XX72QQ1LQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7175", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7175` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYM3TSY0J7euSIZag6pl7nM3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjMTkzYWRhLTU1Y2MtNDgyNC05MmRjLWRmYTI2ZTFjNzhlNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmJhNzJmNzMtYjRm\nMi00MjZlLWI0ZmMtODBlOGNhMTFiZjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ExsALoO+W1UUf2KWipVIz4FWBbc/6b9Ktl0jnWeAFXlvcRq9kLKK1OQEkpr\ny3v5qpzfjfeanas6ohf/XBHbzqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkjLBYeswQ0ZtIiYZUSqn1JkNZacwHwYDVR0j\nBBgwFoAUGFLCbqoU4hCj/0QQkNqUy0TFrFYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAnnFEX06JRr20bAUWyVVqnLce8GcRKS9v7dxv/YUt\n6wECIAvqZwiNlwKU0sss8aQQ4YBX99LtMbWiCBRq4SyaeFJW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWJZNkHPQbX3B6DdOdxdcBw+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzE5M2FkYS01NWNjLTQ4MjQtOTJkYy1kZmEyNmUxYzc4ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgILCOYiFrAL6bPaH4lrpAZL87UKnTvxBTNGcPBqC6ryIe\nYnq2p8r+tGAHBfTrRoFPNEafzdWN8npJTpE0RT7Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGFLCbqoU4hCj/0QQkNqUy0TF\nrFYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO8jo3GW51Gr+kngHE/aorn+cfMj/U3LOW9m95VuXxeaAiBGdXKkTzJi\nQ5PdKsGq7qYPbOP+lc+PToGUt90mZYBzZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaqxcrpAp64xnogUOZZ5H44ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmJhNzJmNzMtYjRmMi00MjZlLWI0ZmMtODBlOGNhMTFiZjczMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTM3MGZmY2EtNTQ3ZS00OGRiLWI3N2ItYjRiZDE4YWJm\nYzRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQHDv58nLP2FZYH7uDMULrABp\nPY7QA3zsWMNw0u4nCiSJ6u7zwWrXnjdClx1AN9O9eVvnDuNZzOzcP0clVmY5QKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkjLBYeswQ0ZtIiYZUSqn1JkNZacwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBVe7v8F\n1VwJjbD/WC0RgtXJstre4+qTjk4II/Y2p7qfAiEA7Vp84BUOM4v4njY9SpmmfBZ6\nQzr63GR5plR8rYUYlX0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7176", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7176` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISATDqr180VDR8Tl+Cql1HoDO8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1ZTEwZDlhLTA2YzMtNDFlMC04M2FiLTcyMTRjMGM5Y2NjYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA5OTYxZDAtYmFh\nNi00NjMzLWEwMzEtODVkY2ZlNGExYTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElGpr5RY7VOcs57+mF1B21wPd9tFIpl8QPdJbeTpfghEKSsPgHgQBUgO5xe9V\n0t2EyC1MWTu7aPzm1w1jjhw2taOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd/sPfUBJNQG4DHNd4MpD9m1ThFgwHwYDVR0j\nBBgwFoAULfu7fgS7lKoXIwbTV43mt9mUv+swQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBNbTs8sl6VeZL0VZC9gzRKXXMC1kZSmcUcF30Tr1Hh\nHAIhAK6twhBwDV7LqX7R3qDkfprDA8XocdqDt3sngwKSwDMV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWyqgZH6YzS8KxllzZVxly3FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWUxMGQ5YS0wNmMzLTQxZTAtODNhYi03MjE0YzBjOWNjY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtfvN941bUs7JcGtiFfsFe1olXhnjqZr0WC+QS52i3uU9K\nD/dkrA6/cJ7tyf0Hh6K6qJOe0kW0/k0G9pMWfijJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULfu7fgS7lKoXIwbTV43mt9mU\nv+swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgO+V4hker5/68j3DxfPH2KNmc1uO8MDh+payf2oVGoCICIC3Cm0KjKwp1\nj6wAMpIE5S4kdIwEskcHXuTzOly32RND\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAbpDEoQxWTMaGkwF+tUHfN1cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA5OTYxZDAtYmFhNi00NjMzLWEwMzEtODVkY2ZlNGExYTYxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDZlYjM4ZGUtYWZhYS00OGZkLTkxZTctMmFkMTQ4MmQx\nNzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXN+jkCsxKuOlkoNz+q50+2Vx\n9g8whym6CMabmgR0Enb9mR6pTtvBqyKUb9KhAPYJKTjFFPndRpYK7r0SW4y8QaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUd/sPfUBJNQG4DHNd4MpD9m1ThFgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDUXnVw\nV/T5ftr1NMzxqEefsek31lS6591gr2nlunqiIwIhAKocQy/zPk0g2odMCnG/2ASE\nJ1kkzOpoA3Pk/3Knt5bE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7177", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7177` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAX2kol6fCAgEYgQfJMfioP71MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlODJlODE1LTMxNWMtNGZiZS05ZmFmLTVkZTRiNmQ2ZDlhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmMyNjVmYzQtMjQ3\nOC00MmNmLWExM2YtZmZhNjEzZDViZDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkLC8c2NLo6Us4OxKdE1ezCtAkeLLzCSXJcWcRntR98Nmjz+BqZ69pVxpPJ2D\nwouf2+9sNVHsWz8u+xZ+TCXeAaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNpZ+6/KMr8M+n5pdOcDHjiZmPjswHwYDVR0j\nBBgwFoAUxNJXcY8ktiT2K+FV6hyV08Xk+YEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAiqJttrLEn02hgxtPFjC3+fsXmWPsmcgS5TWkMdrRf2wIhAJ0i\nHLOcLZ8wT+lmi2fvyLk9aMLRFYFebTmVzk7UX7Bp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARjYZNEAfvFiUY+Ivo3ZKsA3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTgyZTgxNS0zMTVjLTRmYmUtOWZhZi01ZGU0YjZkNmQ5YWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqwoe2My8zZ4auvz43JNE2iGVUaXKwIH4uDfen7k9CQolE\npBTURi5BukOxULSfQtaiGHnAXddsaPoqWNhahMvdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxNJXcY8ktiT2K+FV6hyV08Xk\n+YEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGQT1TuqhM87jEJ5lAeyeyjXgkZWX8I52A/PGlsdo/vYCIQCutiTtohz1\nVnkNgelksNS7MYyowgytFZWTZ41eF+giFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfgPmdCbSFng0JzDnjvw6AZdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmMyNjVmYzQtMjQ3OC00MmNmLWExM2YtZmZhNjEzZDViZDYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTY3MjA2NGMtMjI3YS00ZWEyLTgxMzMtYWNhODNhNmRl\nZjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdmKTF4YWxiN3hQmjaZhf6b0h\npmBhmoskgk6jmNW1gAe4aBIBUqmSUUAWCQICyIT7KFiUkD2YnF/LR5CGzLbjBqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNpZ+6/KMr8M+n5pdOcDHjiZmPjswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCSVedZ\nJ1euXGjBK0ggjumlmFYPkDik9VNrRmwa6oWnyQIgIbEo7m17GuyxBoTneHl8Gmgx\nnkyzO+XTYwX+l+lf418=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7178", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7178` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAYqA0X6gYLDlcYbJiPqpKA6MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0NjFjNDNhLWIwNGYtNGQ2MC04MmUwLThkN2IwYmMxZThiYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJkY2IwYzEtYzQ5\nMy00NGNkLWEzYzYtMzVkY2NhMzUwMGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW22Yd3o2RBqqiWJuQP7gqEKxRr8PU2Tto61oY/Fl51KV1SRIgsPWO0c0Y0S0\nLqYk1qIw2oOgtFRqWWowcuX0Q6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQOVkVRroIhvtDW0Par/dSS6BrIMwHwYDVR0j\nBBgwFoAUQHsfmHQPHI6BO9Ne0G9OuZjsVVkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiB2vDBRSXeriwtBMnVIx0FOTT0JK7OJNzyt\nIH7+SaFI7wIhAORY/UngvHLXgcw2ElwMtZHRcmT4xT/1UDjxUy+HPW8V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARVXb4Cf/4w/+OWOyp12gAewMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDYxYzQzYS1iMDRmLTRkNjAtODJlMC04ZDdiMGJjMWU4YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqAc4y6mHcHT/wvwVdmIzhGlCh2vi8979QnV2xcnVMQtJh\nxuyi+3+CPv194G6EGA7nOMC8WHEqEDeLywC/ZPpzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQHsfmHQPHI6BO9Ne0G9OuZjs\nVVkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW7cSPWYigItE4+CXakX54amQxpWphaP74YxZ7QXS/rsCIAGESf9LapJ3\nxdiWVLVQheTtdwLwUQFsikl+VDeWusHJ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAYq8o5ICmukdCHg5nPXCS4zcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJkY2IwYzEtYzQ5My00NGNkLWEzYzYtMzVkY2NhMzUwMGM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzhmMmY2MTMtOTRiYi00OWQyLTk4MjktNjI1YmRjNTIz\nYmYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDjJwA8wjixKiTtChXn58HwB5\n5QE7UgBL/M+gtsiNAq3V93sOb8XkrozkaqGqM0UkpTye8ivehZcXdetk35YMi6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQOVkVRroIhvtDW0Par/dSS6BrIMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAucdlhG\nY6CxUGGMFE/3M+BrSlk9UIfpA7IDqjJneEWEAiA+XZASj2Lt5B7mujWz+ZD0kBJV\nbcbyTtTetz0pJ7IqIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7179", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7179` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAUFK7Ax+yYUHypAslaiV+ZgCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2NWNjNWRkLTI3ZDYtNDA3OC1hOGYzLTU0YjI0N2UwYjBiOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWMwZTYwNmEtZmU4\nOS00ZWYxLTgxYmItMTU4ZmFkZjkwODVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEid6vGmG1PmIIhtC19ZtneLxLWyrqhSpH8Kc6mhFc7RVEVBPgYoKtMqpp9cF3\nZ7nG5nE58IZYPVDc2uXB7Wln0qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDpE874Vet2O/JPkeBo992R57cyEwHwYDVR0j\nBBgwFoAUA9/kQubx7lNplj61H5ob2q80w3AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAkaF5zFmt3fLwQcZW2hPFY7YFRC8ywMP5\nquRxhSlJs+sCIQCvCg/88gULPIfP5MyBuZPChPM8i4IiUxnMIqJuZNzvgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAac8chc+nqH/bM3VjxE6TSuWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjVjYzVkZC0yN2Q2LTQwNzgtYThmMy01NGIyNDdlMGIwYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTMlYLmaRsBHWVzQEx3bEs2WZcM1Na6DnHWbAh7YDntyMm\nOH7hqF6UFthJ9gbzUvfKiZF44S+MejG+2fL+AUDzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA9/kQubx7lNplj61H5ob2q80\nw3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP9zOVkMxRh8Pzpzf2QZGlpHFvqSu8XlPEpa9QOsf5sJAiEA/M7SuRRK\nWctG3D45hm+odjRnxthA0fBeVs4vR07YENM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAVZZdNiqSL69pIZclRj+nF8EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWMwZTYwNmEtZmU4OS00ZWYxLTgxYmItMTU4ZmFkZjkwODVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTUyOTJlM2QtMWVhNS00MzIyLWJjM2ItYzljNzQwMzJh\nZDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkma0Rk/xf1eMd3H0ggUzzKZY\nBaZ57U/VculHizVSU6JgAXhkLlaEsfkU1ddPfd6VJ0TqORitOjEMyCn3yIgWtaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDpE874Vet2O/JPkeBo992R57cyEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGQAx1ta\nCMxGZb7jSk+dwMxMb6yPcKCV6oCqIY9ZG1KpAiEAvqhL0CFjFK0pef1Swt89ViJ7\nzCG+iShfA/bfkvgOYEw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7180", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7180` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARCWgm/gaKv+Zj0pTzBf5UvDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3ZGJkMzBjLTkzMTItNGU4NC1hMDRmLTEwMDJlZTNjMjMzNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ4M2U0M2ItZGZm\nYy00M2M0LWE3N2UtMjZlMzk5ZmRiN2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDpvzzxraUfrO7rGeJUBq7mhxmguqyMm5XlPeYWZbVcGKPdRDl7nebzSA/eBc\netN+B8JLijp7LkL9HePpMoS2r6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0OvOOVYg0RSsAXGdSczPaZqE/1AwHwYDVR0j\nBBgwFoAUBxdDfto7IQG1dmMK/coMI3juGtEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEApyXpDtKWUnJr\ndX7hq34Dsn9DGOCGB1ZFXLN1qxQ7pScCIE6Sv4pAmA/C/bxOQ1JTrlr/O4nLZfH+\nqF7Y0e/V4Kr3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAesx3WuADYuVNZM1W+yhsTH6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2RiZDMwYy05MzEyLTRlODQtYTA0Zi0xMDAyZWUzYzIzMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAYqb91Sg7tA4WBoA1dpl7LZf83jLkAOkS1mrjLloyZGWY\nRW6xOeqB+KmWtqIv7PW5noJq8Fk3W65l+LHBo5ZYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBxdDfto7IQG1dmMK/coMI3ju\nGtEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKJtsn5WlspKro8rXNJ4YNaG6mivWRrGZ0dfFmLULrkJAiAiCyeAwtS5\nr2giz1mS/fA5+0XJLe/OCmHM5Tt+A9wy7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAT3ZqGNtX1xl2uMzpdG6D8JmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ4M2U0M2ItZGZmYy00M2M0LWE3N2UtMjZlMzk5ZmRiN2E2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODU4YmQ2Y2UtYmQ0ZS00OTU2LTkzZGMtMGE2ZTFjNjU0\nODA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOJtCVb0WFIY/I5R+4TueK6Rc\n04WyzXmWdAtoNcOOYyRC5DWKDZb+DFLMv5+OWrb3d7qUA/0l4SDCjBav9+jHDKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0OvOOVYg0RSsAXGdSczPaZqE/1AwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCICnN/clt\nGC0+QC5wni4lCog07rm8Qix/olhV4iVq8DKDAiEApc6qd3hMsxLVZ/3opPiRsbUU\nt9SGCIs/CUYe7fUkzm4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7181", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7181` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcD89K4Ckl+tewjGiziHcD9bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhY2IxMGRjLTg4ZDktNDIyOC05Njc2LThiNzQ1NTU3ZjVjOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2E1MGI0NjEtZmZi\nYy00MWIzLWIzNmItMjgzMmFmMjBjODRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8a2O7hYU0z9KBg+3CPvWHg3y3heHsS/dau2OwDJbxN0jyygnLdFsttiigEa4\nNcM94+G10RAtwq1aa7/gXzAkMaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHXkWHUnPWGORLpuMScYdxU7nNywwHwYDVR0j\nBBgwFoAUU11YrN0umB5D5yIB1Tw550JB0HYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDLct7Z7/S/rceijgciPu4K/x+OcNVA1446UED8RoPnSQIgO0+b3xJOWxKw\nUjmVBleQe3uj6czEg/s5QG2ELvHd3Dg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYsYemqP57l9J9PEM1tM9FRKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWNiMTBkYy04OGQ5LTQyMjgtOTY3Ni04Yjc0NTU1N2Y1YzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEu6Hfr+22BFzKTql0AYqj1qJalOsR5XvdQZnrWc5FLt9I\naVh12/G6rM4+/lHEJnMlgFZuhepq7NRayT1ny+QYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU11YrN0umB5D5yIB1Tw550JB\n0HYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALA/kpIuCGZc+OsqcMuknqbV5y4YT5hOKTjBh7IqZHjBAiBBN55rmmYm\nq2KT2RCe+JOPmO9h4RvzzxlxCJ1hLiac8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAS5zjAC9oTs3NQ6Q5A71B7PEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2E1MGI0NjEtZmZiYy00MWIzLWIzNmItMjgzMmFmMjBjODRlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2UzYmIwZTUtOGJkNC00NzJiLWFiNTMtMWMxNGUwOTNh\nNmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEueeT++mRqS1R/GCxJnGeAaBZ\nizjq/JHeB1NIISZqi+HQwokqIOzO1r7P3tHmM6IGpuL8n0+y+xV9Ex+EVRwDq6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHXkWHUnPWGORLpuMScYdxU7nNywwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDqNbWR\nVrNNel6kNjq/GmB55gtfjxQkcg95ITjrREXZ9QIhAKVdHFJEr7DkakdpPVSAunFZ\nUHrNcJrtcJ5J7FQPmgRN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7182", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7182` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcS9K4Gr4WgEYiMZ7kfFJi0sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzNDI5MGFhLWU4OWItNGZhNS1hN2M2LTYwMjVhZjg5YTE0YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzM0NzkxYzgtNjUz\nOS00ODQ0LWEwZTQtYWUwYzBiNzE1YzAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr2qo1p6f9nJprm1V8YDbiblr8y1vvzo85RI3gPh2OKUtQ/xZYAxG1T2auMCJ\n/idMAdLj/uOanGqhrRrahRxlRaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg8XANCr7BTs8zGZFzFpmDkmLz0IwHwYDVR0j\nBBgwFoAUTptk3jpv0EsTJakS0p0bMlYXtokwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC7yb7tFArBnfletJtuI6zK5wGYQB1vHlzMkxGjn5sM8AIgDLMA9e4Po+Z9\nM5BwSPSDX2a65UESHORlPboGmkP7XEE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWZH4Sojt1VyopHrnVKmz0xfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzQyOTBhYS1lODliLTRmYTUtYTdjNi02MDI1YWY4OWExNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTXWU/a2L/fgRQsx/kBSnMEFBr37mCs8ACFClGr4/aepFl\ndSzi/KupJYIhI/kZXoESwvOgquj9KLXa2x5XDZUOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTptk3jpv0EsTJakS0p0bMlYX\ntokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANV8T34RvV8YmYyMB17KKAZ+z7R9f4G0tGQiBaMYTwDXAiB3Go4rDRZO\nprVrwpqIRjiunMzptQC6vx4PqhsNHjIlfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAX4q/i0I8aRq8WaSrWeglEk7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzM0NzkxYzgtNjUzOS00ODQ0LWEwZTQtYWUwYzBiNzE1YzAyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmJlYzVhYmMtYjkwYy00NjhkLWI3ZWMtYTczMzM1MDJh\nMGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERnjKfTBqeCbTYgcHt6LKLnHK\nAiKZSWuLbKebnXBD7Ccg0SWfvGFfCBH14CBUz9sEdnkYd+tu/9OrcGbl1ovK96N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUg8XANCr7BTs8zGZFzFpmDkmLz0IwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFkGmyHN\n/T41geqjZyQ4mg+bzjNfAC9Qm/Xs68vLMXjDAiEAwzTBXMqmf582OYArx95d0UQ5\ndb6c18bxSuz5svyJCyM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7183", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7183` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZexmutyfK8A47L8NrZ8nUuxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3NzBmYTNmLTBlNDYtNDgzZC1hOGFhLWNlNTRmNGIxMTAxMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc1MzZlMDYtNmNi\nMy00M2I0LThmZDYtNWE1ODVkY2RmNjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK4+REFBuw9qBZeVIAdw8PF9NK7tUq7FT0JzPcUkway2txHw2Dhtcg/JC4EtY\nKJHm7dUDxtEizBYgEsQvB6sL56OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3inUrfdv85EqNpNTqlk/eaEZI/4wHwYDVR0j\nBBgwFoAUwVaF/7bwOVzJmKsWxexn2n3TWlswNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAg1bout7hBpNgEqXwN/G+lgUd8KWpgMYcfyAzM/Fw1CICIBOOaMM0xZER\nDnt2m5yb9C+GmU2I/FK/2DblcznLMmON\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU+C8C+yb0ysjVgwtLhg0ps9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzcwZmEzZi0wZTQ2LTQ4M2QtYThhYS1jZTU0ZjRiMTEwMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7FOhzl3pRlLw8QAqAnrQZnIhYe145nEXD4YuYlxRXRRv7\nCk55j7Z0TrcT80SNG7k//wZlGR8aaAPaQSsKQRiLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwVaF/7bwOVzJmKsWxexn2n3T\nWlswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKF6ISV2AQdUxLFTeD3xVctL4wHHt0hUuaxjP9oPoMZ4AiEA78E29kO2\nN5n01BEIsiUjjIqXta0PXWNf8vkiuSdsQH8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaXfR9ftcCeSmFgj3ZBPatEgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc1MzZlMDYtNmNiMy00M2I0LThmZDYtNWE1ODVkY2RmNjgxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTg0ODk2NjgtNGIxNS00ZTNhLTgyOTMtMGI2ZjJhMWY5\nMWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyALrOW3gYQGoiwxXRP+nBsVB\nCPNGl019L5AhHnvdeK/6+/+TZP0CelZIgryOcD/wGO/smxHqbWExXHft7ejHfaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3inUrfdv85EqNpNTqlk/eaEZI/4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC9JS2g\nfnjePDNEZYH45I4nrxexGgBI/uTyaXZDP2NGdAIgG9iOpUnsptNzHnNwBcyrtrHM\nAIhBO1tjk3p6lVLM2pQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7184", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7184` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAa3Nc9KGsxLtgZvUH40RLeyOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0NTIyOGM3LTc4NmMtNGQyNi04ZmM3LTRhNzIyNmI5MTg4ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA3OTBhZTktMzgy\nYi00MjQwLWE1YjktN2ZmZDM0YjA1N2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuNc0ukXLN8qYS5CVukNn9/rQ2HiJfZhIDpWNpKARSxeh7f0L5XmXMfCYtx0A\nfbOC5fo8GzUxPaqQuyIKUigMpKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcFbIaAdMMeCubWvQVvqbgErWTKkwHwYDVR0j\nBBgwFoAUvpmXr89xe48hulvrvGdMbHHP4oIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAmWJonA3wfFTRhJYsDzRW6dSXCzEZPGFFG9c3Nwn5\n1gwCIQCBgF3iDI0gKmpvhwBP5t5Dtv8RYX9ZSLGHw/id0nka7g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYiQGP6I55tx3f0ysX+h5wS5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDUyMjhjNy03ODZjLTRkMjYtOGZjNy00YTcyMjZiOTE4OGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxNxkU6z+UxXrT0fmkBca5BT5kpkGYycL81vmFZkaD4PnQ\ndW970xDKKGGmml8MY/NIZPQZqNaJt2F0MpH182wGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvpmXr89xe48hulvrvGdMbHHP\n4oIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTpDeXmt1lgUaWIY7Gg7ozh68/lfsKylF8zvX6HZoEEECIBI50W/qz10s\nN+p0THDFTOAvy3uuxV6TV57/R/wtissF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAaZjE8RVm4xQ9AqEhn1GPxkuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA3OTBhZTktMzgyYi00MjQwLWE1YjktN2ZmZDM0YjA1N2I0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODFlNWFhODMtNmMyNi00ZTI5LWEzMWUtMDczM2RjODRk\nMWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEayiEu0mN+dCZXbfs2ZsaomJj\nioGpB0ixJhTf2B2Iw5u8vO6xfdBGoUlDa7GPlHcP++h63LaQvdy3ZPOJUdwl0qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcFbIaAdMMeCubWvQVvqbgErWTKkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCXUDgt\nw7r9/4pjQi5Ibk+lGvVq4eQripGhzFCuVE9PbAIhALUBZHdUOJbkmhpa+zgf0nPE\nH7VuthNqjRA2qIyOiCw2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7185", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7185` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAV0QTR/OcmB7lUS7b3MB8nq1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzMTMwNjlhLTM3NzAtNDM3Ni04ZGJkLTkyMWQ5ODU5YTAzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgzYzc1NGEtMmQz\nNi00NTI4LTllODktMjgxYWY2ZDk4MjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2AkS1SUM04Zj8R4Nr8UC45M2b4YTg8PdMtGv2behx7qSEtM0XR+rSFAPR4CU\nsEJ2kp4hFJCNBdRjRpq/yXPSD6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfDxfQ0dp5Cwc6BoldtT6SdkT91IwHwYDVR0j\nBBgwFoAUuzBpapCS6xzSWSa0DD0GSmP01SwwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAsDs43E1AlfZeb1IOSCNFNYd6MHoTthEQ1VzrxJbE\nrgICIQCPenEe6qiKpUSn5llNp9Oh4ish8qxbyYrqfGYsrehukA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQYtPCHq/WdMQ2df4iPwkGKgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzEzMDY5YS0zNzcwLTQzNzYtOGRiZC05MjFkOTg1OWEwM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzbBwF75UIUCsGNRjKrhzofE7G9f/GrDRgkvUvkij2izM/\nhuaQUwTQ+fI3oPLK2kQQ8ovLdSk+SO6/CIZ/R8WXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuzBpapCS6xzSWSa0DD0GSmP0\n1SwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVkPlpSFCitIhOWd7dB8cbitF3OoZ/Qz+EkpolyKegCsCIQCFCeZOC/Im\n4zILzNspE50IZ3aStMq8pxrN3ysMuEexVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQ/bEnhL6tLMDGfCW9xgTFJgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgzYzc1NGEtMmQzNi00NTI4LTllODktMjgxYWY2ZDk4MjczMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWY0ZmFjNDgtZTVkOC00M2MyLTg2NDItYWY1Y2UyZDll\nNGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAET/vFFjlT8aBoBlvqx0Y7gjUB\nw+Img7t1+yyHmgHOFU7YLZI5Rqj74ebsP+IZjmbsigIlDQK5zA0ctn+xyyCnvaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfDxfQ0dp5Cwc6BoldtT6SdkT91IwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBc7cPIQ\nwQrLLqCb4CE1eThlyS6WLeEcu1pdD5wQxCRlAiA8f9rf7FhFDOYP1Tu9oka+puQ1\nwzpNWIzeErRTP008Lw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7186", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7186` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAaJz7Ql7d9OLXwZXlvo+QtWCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1MjE1ZWExLTM1MTktNGQyOC05ZTM5LWZlMjNhZDJhYmM3MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE0N2QyODktYzNj\nOC00M2ExLWIwNDktMTBiNTZjYzkxZjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvwVLYG8xJ0dK26ttvQRaw/+lQlzDpcHT+dCzAf7jEHJY79Je1quFWJUCMj57\nWXYtSLME5ie2j2S46K4kd+UHIqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaPEUlgQoVd3Z7DARMGLbgNb7rGcwHwYDVR0j\nBBgwFoAU+TVohdDf6r0LiwvRYdO9azXHKdEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAsR04XQgdWFrLhpPd/t0tv1l/eSwWcKyZRBcqrPuN5TACIQDu\nnrPdF65UjkHIaGPWE14lwGoIfw2Eo/QOcS5j7Zlj9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASX+igEqRVkF0oVrCL22dvWfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTIxNWVhMS0zNTE5LTRkMjgtOWUzOS1mZTIzYWQyYWJjNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtYX/T/MVBZdKzHb45AAVRwhTxRn8pZFhM4KDGVwI+8brU\nFN2377OEn8mXG253UxtR5x8kmO0aly9PLoOO9tX0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+TVohdDf6r0LiwvRYdO9azXH\nKdEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN54thnrcrVXanSiaSQ2PXAwKuMNCAiLLclNJedseGN0CIQDPcCLSW1yn\n/SfzvNW28BTU/Tfsc+aucUQ/ZHdr/zoUqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWAohM2DbYIXnFJ+CmTo5GwNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE0N2QyODktYzNjOC00M2ExLWIwNDktMTBiNTZjYzkxZjc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmU2N2RhNDYtNjY5YS00MDRiLWEzNDUtNmM1ZmU0MTdl\nNGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMKPD6Gv0dL+vWif+U8Qb8p2N\nY+lDJfL5D8rCDkGlfnHl2/3g5OFaRPtd3JKc0QGWNWIzTw0Atcj4X0CxRuG2wKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaPEUlgQoVd3Z7DARMGLbgNb7rGcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDynHnl\n8Akh2s2Ypjhq180Fh4xUu4pLiZgZbtebJ6I9XwIgEaVr1vXep2zgnc84svoeucKd\nihDA0t61vJBHImMF0Ug=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7187", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7187` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAaaaou7aPDMWDBXpqhdhVKuhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4ODdjZDE2LTUwYzUtNGI2ZC05N2IzLWNlNjJhNzliNzA2NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU3YzVhZjMtY2Nk\nNC00NGY5LWE4N2MtZGM3NGZkYzQ2MjBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE80bg6L+XTQbzP8g+fRoLKaHcYNFLFMFzOq9yUHFLhQRnee9K6qR4Dr+2PBSE\nq8wJkhL832ovEyQ2uK8Q32zwHKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmJgNHV37N/C3xJluhIbL7yPZEogwHwYDVR0j\nBBgwFoAUgLS/dr5MY2B3hpCh2kUsV3HsngMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBNiHrabmVOmHNrs6AzzEoK6bMGadK2of25\nOb+vI/lLfQIhAOFME0EJvrXQRfdRlyUJejGgbRc5joH3rZ6pu5UQzxx2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcqwFAta/HWyF57HKdtwySFKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODg3Y2QxNi01MGM1LTRiNmQtOTdiMy1jZTYyYTc5YjcwNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2EkMsRcdIv3BU4XPcOdVhd/wLzM3P2i2JiH7gJcoZP4c1\nOWePsEwMFdGLv5pGnsGnehRI93622ICkl1VnmUqMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgLS/dr5MY2B3hpCh2kUsV3Hs\nngMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN1ELpuZY1oHYkXmbj4rqygJx+3ZpftkivP6DhYtTdBoCIEAtnhvuZ9WD\nA3Swpe9uCFR8NlChL9tjHhevawXgaNvM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbjrIvFSSXZqdaY86mpYUGJkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU3YzVhZjMtY2NkNC00NGY5LWE4N2MtZGM3NGZkYzQ2MjBhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmI5NTA0MjktNzg0OS00YjE4LWE1ZjMtNGQ3MTY4NWJm\nODU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGKOsq3Ud8nBBLooKxVV4SoWC\nNmy/EV62pLbwc4zt9VG+nF/EUtAsOZDIUUQ+0MRUEsbQvP9UrnyzxOBBDwquX6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmJgNHV37N/C3xJluhIbL7yPZEogwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC33Ete\nIyhU7cu8yaFTuOXBPgndeLxBTwW9uxqLdbgMuwIgbEEvWC28Mnd5336OfrH4Y0od\n7XldfyMeWo7xIRlOAnc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7188", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7188` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAclEd7UrK4qDbEOVqSCzr9qQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5YzEwNmRiLTllM2ItNDUxZC1hMTljLTMxM2Q2OWRkNWJjMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE5ZmE2YjktYWI2\nMy00YzhiLTg3MjYtZDEzNDQ5ZWEwNTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkeLVg7x/PIbHFtrc5gaHOqhF3UzAn5dM2bDHQ/GA4Xy21dIs/m7ABMeODPIB\nVz43UURZGhIFJPaB1cYTL0Ed2KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm85Mc5ROasSiDzE/wZrUexiPe94wHwYDVR0j\nBBgwFoAUKobXWK7Uz27qOrFkvMZ6gjMtZrAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAhVHwfJAU/6xc/6+TzZefBoxADCfMCetq3\nc/9lLjiBtQIhAKqMKqXrmNKUorAHYg+uuXP1vhwULlcHjhHBlNbN67bG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASVF+u6YMFD8f8YGj0Ci2ms8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWMxMDZkYi05ZTNiLTQ1MWQtYTE5Yy0zMTNkNjlkZDViYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASosNLEJDbWtYqGEOd6H9DIvrWy2rByoh66UUFcDCbb8o86\n4cJuw/1G6MIHroMaXfMEqxBQq7j0OELqy48vyOwWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKobXWK7Uz27qOrFkvMZ6gjMt\nZrAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTVdlWc2+Hs+fUq0u/+OUh3PPzbRuA3XmXPnPL97JoB4CIE/9ARn7nusg\nFBDNCPNewI5s26kDJ2EmqHQgdfMEyAk3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUJym5Ze0jiGokX/YsNnK4uIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE5ZmE2YjktYWI2My00YzhiLTg3MjYtZDEzNDQ5ZWEwNTZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmE1YjNiNmYtYmU2My00MDBiLThiN2EtMTdmMjQ2NGNl\nNDVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEon/YoCyPIp+jA/DdfkLVhMNU\n3NDGJs8IkSKfK1GzpYhuKs3TAMrNm3Md5BUKVw5f+TVGCQeFAawuAQdvCyFuGKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUm85Mc5ROasSiDzE/wZrUexiPe94wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDHDpLV\nzetUJAWrj+14ihKSGI/IwIMYYVAqgI8wO/5WxgIhAKmpW1aFCY5VltLRJMAhU+9I\njPEUry6C3mYErQFmItb0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7189", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7189` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASabyUS0oLEu4PmE0gnhg9npMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyYzY3NjI4LWYzYzItNDg4ZS1iMWVlLTFjYTdjMGVjMWFmZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI5YWQwODQtMTdi\nZC00MjdhLTg0OTYtYWI2ZjE5MWRhMWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAHW+v+nCHarmU+uUvGnReo9H1gvGyd+6kf7AKk4o29xYH9SbLW9E1M9Hndcu\n9s/F483u9OuB/fgGIxnjh9cNNaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/VH5RiOzTT4TXLQAeJWEHmhRyvMwHwYDVR0j\nBBgwFoAUQ8mhTibY+OrOpOB6eGaFTr72alkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAdsjR9PAbiWyjJSMSfiaNStE7N9\nwfpLsHyAqYDupPiqAiEA88JEXCpzxzl/PqvgHA1Xn8HgTaUM2jkcKUFXclaHcrE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARvbALZ58FbwxRoOngkqCLwEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmM2NzYyOC1mM2MyLTQ4OGUtYjFlZS0xY2E3YzBlYzFhZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXiKN69RYE1NO0a+zG+QaZ5/7/Io03coNPl5pTLjGWLe6h\ngXGyjcPm5IDt+gyI+6u7QtwSLPj3PsbsT6Khv3Ivo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ8mhTibY+OrOpOB6eGaFTr72\nalkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDyqkckdRw392PvsPborRIlS97MRht7Kfwu7HKKUDn3ACIQCAEYd/WfsL\nEGOdQl+GEGv+0KEYCsO2kq7i5JhRvzb7JA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAac4Z7TJFuI2p1eK0QpvYZc3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI5YWQwODQtMTdiZC00MjdhLTg0OTYtYWI2ZjE5MWRhMWQ3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWMzZjVjNWUtNzMzNy00NDk3LTlhOGQtM2ZmMjc5MTBm\nZTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwXo3+pTgdEsO2XnrFBKIJ1HJ\nL8BD6JfXhKWQmCL6Ik0aZFbby1p223oKOtZ4uveh31jMwBa2jLOR9SwTffpLAaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/VH5RiOzTT4TXLQAeJWEHmhRyvMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBShu6NK\nHv6GK9bsUGQP+XNzQP8pIDc/OtO8muQueFGXAiEAlHzoumnD2HwsE8lmWO6yRpFp\ntdmexDUYV01SzR/QBw0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7190", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7190` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAQ93hQmzXNh9yOtZn0+OTVv9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyYjUzYWMyLWVlYWEtNGYwNy05MThmLTI5YWIwNGE4ZDc1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc2NDAwZWYtMjZh\nNy00MDVmLTk1ZTItNWFkMzBmNWU0OGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKupv8xQbZYga3fUI1CLtfJT3CWULvC66LoCkYuTGvmdr9L8SBgMLV/BbTWPD\nEdjWa7323DX5yfVHCxvdeCCNkKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0d/xVrMeD4QuNdvvBmyBrTStEx0wHwYDVR0j\nBBgwFoAUnxDQp0a1i7SDHAnKsqwvyyIJUa0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgPxkauZD9\n/2ZGTb43vfisav5dOiA28hpguybs+QWAsEcCIQDsdAmmTl40T7J+VFNmRAjf1YZS\nE5RrmGDF8kJNh5Iedg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfiVqXUCVGhph7rBgDFrHQZ1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmI1M2FjMi1lZWFhLTRmMDctOTE4Zi0yOWFiMDRhOGQ3NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuDhUD9ptJidwB/fUop4uSZVXj6uqAX/TptiUVIcS3vGc/\nPGHaFxyuq22Z/Uc//v1N8gvsdES4VIAMQ8cyt3aro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnxDQp0a1i7SDHAnKsqwvyyIJ\nUa0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOx2PjnxOU7WF7E9nocOkesSEERAy0HBZyF1ETsygeYHAiEAjMDTvCB/\nFyt3pQUOQXV4FwoQiHrQYuRneim+VJTK+0k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYJQ1G9CmJi1p+UyfJ/LFU4DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc2NDAwZWYtMjZhNy00MDVmLTk1ZTItNWFkMzBmNWU0OGIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTk1NjE3M2ItOGZmOS00ZjkxLWE4NTgtZjY1OTVkY2Qw\nNGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEu5ik+nDG665p1+sJYULduUb6\nJGdN0l/QyfU5bviFduPIQ/yaYo2hFESefI4gC8Ck7dKGJQ8pTt11ePR9fpQJ+qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0d/xVrMeD4QuNdvvBmyBrTStEx0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGcpofTi\n1g6pripFW5wOH1Me1swH+SyyTjLgD3LJOiAYAiEAqsS82ebNVk6OgP+8HQrLKCkM\nHzXtPHMb8i/FQAHqTvU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7191", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7191` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAVVIkOZH+nfAxtRkART+h27BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNTM1MTRkLWUzZWMtNGUwNS04ODY1LThmNWVlMjE5NmZjMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q0OGQyNTItNDA5\nMi00YTZlLWJhODEtZjdjODI1MjYyMTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfwEEI/cDMm9iwbWvPL/8ql7ZUPGhC0o/s9UhJ/Qslq3AmDOto/C+fZgrGl9o\nZnuDrIPiMg075r0tSQVHemTORKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMXFzP2fjJGDLVM8baJc5owuirCkwHwYDVR0j\nBBgwFoAU6e1mv3fMA+c6d1Qp7wFx/+Fm3lowKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJOs8PvY\njw5507VR/X2C0A9vzkVARlhTgPesaiRto1WlAiAFh4xyhEdn1EOKNB85tU7SBQeS\nIm+zimVMTHLF3OWczg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUmxVphEQoN/LVEcF3tqDPzLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTUzNTE0ZC1lM2VjLTRlMDUtODg2NS04ZjVlZTIxOTZmYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnxgbGtLzZWYyhCI5QpaR3aTlF/zmhr3PFgHdyyI+l43Zw\nA22BCk+bVTg8lPaSPjQw1mpifTfIpPeMmNdwcYLqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6e1mv3fMA+c6d1Qp7wFx/+Fm\n3lowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ7zU5dAEo3yYCZlMHdFU79OP3uZ2H6H/F0ezN7fLUwTAiEA+y8/97Ah\nLeKf5NhjSHSxFi9COwrdzRpdfaWBEEj+AJs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAecGSDz8pQRsa/9sWCUrwxUGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q0OGQyNTItNDA5Mi00YTZlLWJhODEtZjdjODI1MjYyMTg4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2IwMzExYjItNmVmMi00ZThiLTgwNzktY2M2MGI4MDM4\nMDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn+UhgELkWTkhYxiLEaUDpeKq\n+MnVHA1aa4rb3s55Re4HR3By65m/buoXEcDF85Hl5nvHo5eJnoSEBUhcp9W9ZKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMXFzP2fjJGDLVM8baJc5owuirCkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIEZpU9sM\nZGdkYu02vxEhcnjzfUqyE3zjbZzphnPFT7waAiEAh0tg6KRMus+FhjQFwrPLOMi6\nTXhRI41UQ6rA3z8PhYQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7192", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7192` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAfSN5Wkcu5kGMYM77W/czYOMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhOGU4OWU0LTg3YzAtNGUxMy1iY2EzLWM1ZmI1ZGU0MTJjNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJlYmJiNzQtMzFm\nMC00MTZmLWI4YmMtYWZkNDg2ODE2NzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1qUt/PCV+ci+d+Ch/I1OvLj8iv4w9zJctF2HfPHFzABdktmFV7fK+k9xdLmN\nhqJawkaoe2v50FimqVpwydqVC6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwEW7/6ac7HGrIt0we8kz/bGAKdgwHwYDVR0j\nBBgwFoAU/AqeDuG+Kk/zL7B25VmR9N7OgH4wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFQIC7qg\nMilScy0JYOpqa/m5/rAJeaBt0NpkBUI3+K6rAiBaPFH2JVFY9EkuLiBW1MlYdfP5\nLW5glMuuJvUPRPo9PA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU0B4TJOkAYeJctNmELkulLRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYThlODllNC04N2MwLTRlMTMtYmNhMy1jNWZiNWRlNDEyYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCurDi59/QJ4NHVmXTHfirOLebqL1HZLT8oGtPVyfJJ6+4\nR1/z+yZ6i7lBDsZoItNm7g2Pjm6xxeeRS0lcQJTto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/AqeDuG+Kk/zL7B25VmR9N7O\ngH4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBU0KkC/JzDVZiInAdGXBoXNr7yKdhJxCrExec0Q8mGwCIQCRz0rxQLzG\nJ2VUrJaRRNeTqhLiz0dJf0/yAsi6s2xkGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWcMBQvcCzk7wXoLHQR4st2sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJlYmJiNzQtMzFmMC00MTZmLWI4YmMtYWZkNDg2ODE2NzZjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmVlOTQ5MGUtZWM5Ni00YzJhLWJlY2ItM2ZjNTM0MWVj\nOWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhOZZv54z6mUAyC2uh5psdY5g\njc6RP2y5MVL2c56iBLjaP3k8n6pmZ3gi9pKMRiAUT5R1hI+bTA8m47FL40jtiqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUwEW7/6ac7HGrIt0we8kz/bGAKdgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAbNaXPK\neHN1Wd2PZf5I4R758mbJUdGIOAo6QnpkeECVAiB7Llq/3J3Dg1LrdQPK8P9Lhk6v\n4nvZYpjyf/2yA1piuQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7193", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7193` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAbi/ZkYUlLa6kqyov5xSOhRDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViYzcxNjUzLTUyYzEtNGQxOC1hZmNlLTQyM2EzZTQ3YWZhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGExM2I2MDEtZjM0\nMy00MGFjLWExNjUtZWY5MGFkNTc3ZjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEen4+ARq710LkzjlpRcmk3xJvc4DuSGDBheBQQFvigr872vn0jLCte/8jbsaI\nNDTOkvBf7dFoC2tR1hUPgV1ZB6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDL8HpJB3KSZivMVgUTRHpdmTV3gwHwYDVR0j\nBBgwFoAUr/mAtDfcp/gTahcLspSZe5KJ1fgwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIGImtIYaR7j1KN6Se13syFpbd8wLUYNcDqYq9kf0e9rWAiBMqSRRUQUd\ncoB362Mqrw5awd3UXTNF4AZEe9RHNL94LQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASejHUqrRejeI2tAM4sukHa4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmM3MTY1My01MmMxLTRkMTgtYWZjZS00MjNhM2U0N2FmYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnf3EFDxVVsMmVlmD5JYFiZ9g0y+vx+V2weLh/5FFili77\nmH6Zpi98n8+Moiq4gc3AbqU7IQVpelxmInVjtV8qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr/mAtDfcp/gTahcLspSZe5KJ\n1fgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBTMdcDR0msvSZ3WQC54IA67QW5C5TmnpURoRsSqYr1oCIQCpSsJx9WMy\njOYiPO/X90lOCuMttN6K1jUvHdhAQ2Ad4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISATPAHHMTRz4nh3lQSGR3vxKqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGExM2I2MDEtZjM0My00MGFjLWExNjUtZWY5MGFkNTc3ZjUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODM1ZDQ5MmEtOWQ3MC00MDJmLTkxZTctNjJmNDQ2OTY2\nNDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEff+w+9uKlhpzy22drQUdB2bM\ngt4S4uqAdbiWhpOP7MzXd8iTlG18llfz7PnCXR1qZwmWlzC+lD62EqvnsBTWK6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDL8HpJB3KSZivMVgUTRHpdmTV3gwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCis7Kt\n5eVrBjSIZYWX/8DVVTkYuEMNnuxd2R6VQCiK9AIhAOHxxS7lQOLhJYb+MhSGLJ3s\na+/vNiL1G/JYm1gHDPWn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7194", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7194` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAdnJ0jgugZ91WcyLkdkkKckyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4MmIxYzY0LTQ2MjYtNDljMS1iZjI2LTRkZjZjNWM4MTA1MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJiNzU1YzctZDg1\nOC00ZTRhLWI0MTUtMmM2ZTc1YzA2OWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEactTtAgckqOOs6rJ7RQAZksA1rradLnu3m2pc1n7fMJXXHH8e6viOdJUuHvp\n7T5yyWPec+rNsJnMI0/BW/fei6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURrTCrbEWjm0anarodp8BR/hl18owHwYDVR0j\nBBgwFoAUuKqp/9yh+b5jkv4oerDCQfcuelowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCICYMECunlWmJrxuj2tKlz9ySszs/mfGpbsDoC78IWhjGAiA2R0PtJkWY\n1JUl0EMJc9SQoZ05JtbN5mHnSkyH8ltp/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATNshGbPR3L7PoCh9nH6w/ZVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODJiMWM2NC00NjI2LTQ5YzEtYmYyNi00ZGY2YzVjODEwNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrT56SMe2p1cuNwCHPbyeQsh5wIhaecKXxbI+ZtADTZf+5\n42JomGULVGWwGms1bxUJCePw62010u5NuhtVRAiAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuKqp/9yh+b5jkv4oerDCQfcu\nelowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeRAsw0VMX6f0Y32uC5ASw7j/GozTJC4d59Q/uvnSOcYCIEqdQRmcHGef\nz59rBcT5uno5e5Ld4T2TActN15jodmkW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVpzUHP97wfFYYa62Ks4hwevMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJiNzU1YzctZDg1OC00ZTRhLWI0MTUtMmM2ZTc1YzA2OWZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmQ2MjE1MjEtNDFlNi00NGRiLWFmZmUtMGJkOWRmNWFj\nY2I2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeUGX+z0aP2VWEDPGvWxLeN66\n8U5V035W1JPDomLJo7qwl2MNBHjaDELb5h4V1qOsGs/sZwsJyK+aIm0dMKb766N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURrTCrbEWjm0anarodp8BR/hl18owIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCrGrMr\n9bc1xzqMWOw2ccajDbPtamNQylpiZOA98OC0oQIhANn8CSkJBCH4s9ZId5p7lOhi\nLSTLC0NJdJmmG7JyWdY3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7195", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7195` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAQ8iaxdRfY2twEzisd/wq2IcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMjUzOWJkLTM1NDItNGU4Zi1iMzBjLWM0M2NhZGEzZTJjMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUxYzdmZjItYTM4\nZi00YjQ5LTk5NDAtZjc5YTMwMzIxZjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgt8PLGw7zs0uo6ws+5RJVk4BXyUbtee5DaG17E4EX3hg4lpxCTq6rQeIXR04\nvRhVzCLJMbMrhKrjHCgwPcfh0qOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIxCncI0ZZ9j6+bv8KnZhtmq0IaUwHwYDVR0j\nBBgwFoAUqCGsl+h/3OtGWtefef70IpuBulQwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIHTB0CjrRlEoAVRwdj+q71MuT79pLA4uLC1iOufghFxDAiEA75JXwjDg8a2NAwpC\nK8Ln/9Xd2QdjcpYdlgjk330y3GU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXrYgR/76MdM1ZmXDg9+7p2PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTI1MzliZC0zNTQyLTRlOGYtYjMwYy1jNDNjYWRhM2UyYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARritZAeXZY2jtAhBdf2GHCmlcJ2ygHe/3oOKsZ7/22KJPa\nwFWddTM6Xt7ddP/E0LTgoLpbLctqVMwcnelsblefo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqCGsl+h/3OtGWtefef70IpuB\nulQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJnF5qr17OJqqP0xooPJKBGnuWZdHSp9WwuAcTtb+GggCIQDBHzqnTV2Y\n7r+1eGxg4kCxu0mUncoDp66/FMhmRp7Z/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXRrDwC3WdXG5k9mvLh/4t6zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUxYzdmZjItYTM4Zi00YjQ5LTk5NDAtZjc5YTMwMzIxZjQ3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODUyM2EyODMtMDg2Ni00ZWFmLWFkZTEtM2E3MzYxMWIy\nN2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwWBgv7/CCYFB+w4GHG47PbOM\nA5nFvR/AlxkfNLYEwHxko36xACCXiZ9Zl0ZUYwdnHYqxe0gONB4wQb3NNPtRy6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIxCncI0ZZ9j6+bv8KnZhtmq0IaUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBYmQDfH\nsqAVyH1CO8ilgCq6831eBxL5+fVJ/pF/14WJAiAJYvM0gw/8hyGj7I7KUMg2GEnf\nOMm6WuvRJX5OQHD+bQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7196", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7196` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAcFnPvbUT07edJzizCg0q9PeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkOWVlOWVmLWM5NjEtNGU5Mi05ZGQxLTU4NTIxZjcxM2U0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmIwZjc2Y2ItM2Nh\nOC00MjAzLThhNmQtYTE3NDdlZDRhZjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoK62WvdpHDoID5i8OzVMXROoz0wMCI3Rlto5kb7g5xBJZlN45xK3NvDg2zcC\nU/lKIQqXbDlVrlEY+VxhpZXyfqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSa8AZ1OnK+Z/YhkYzNTDY9o73NEwHwYDVR0j\nBBgwFoAURP9aowRYtqRwH/09ZGbEzg/y4MIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQD7BqCOlkNr9tVwGDSXBCYneQFDA9J7mkk0M2S57Jgd1wIh\nAM7Jhtme92WYi8eto34wJxwylop61MmAxDEVVbqDw64I\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcggH4jfcZrUmx87FIaxib8mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDllZTllZi1jOTYxLTRlOTItOWRkMS01ODUyMWY3MTNlNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/Nu80uvSgOQXGOuDaFAg+YtuA/sd0oowLXOY6jiI77yo3\nwVQYcbMzzWXpsvPrvUB2M2yM08VFYXfW7mA7ZgjTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURP9aowRYtqRwH/09ZGbEzg/y\n4MIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgflk8+oIFRYXd6/teSxsZymLhIVHFzLo+nfTTGaF63LMCID/UYws15t9C\nFk3PJQj2AvoOwQ3k96EgLe4RM/NL0ig5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXbQlew+b1LtHDYDcZgT5izCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmIwZjc2Y2ItM2NhOC00MjAzLThhNmQtYTE3NDdlZDRhZjA0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk3YzY3ZjYtMGUxYy00ZmVmLTk2YWMtNDkwMWFhN2Yz\nYmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMND6PD+heoiNxJ79bcKJH5nq\nR/KSetO5pQBylvivxuqr2cAj65u8okxb5Rsh2qO9eBA2jlpFSFW7V4vQBpDoWaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSa8AZ1OnK+Z/YhkYzNTDY9o73NEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIEsbrmZ6\n0DyfUhadGtRmNWVxClDbO/ECBYGqjrNtxpA/AiEAyvCWubXdAyZqhf9wd9k9Ge/w\n9WacK0nCML0v6QE2DNM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7197", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7197` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISATya12VeoVWhpfAdoC+kye8GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNjk3MmJmLWQ4ZDUtNGVhOC05ZmJmLTk2Nzk2NDdmNTE0OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmUwZDc3YjEtM2Fh\nMy00NjJmLTg1N2QtZDM2NDllZjg5NGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwUOWHZcniA6L0M9n6gr/UyyMvPv4F36DgsXKbZTUxd7SNAxrduvoSFJaEybM\nkdZn2563rZ7k6lFe1P2GxybPDqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURKonYTk2YibNlILTiQiXmPfvawowHwYDVR0j\nBBgwFoAUUnMejeVedkawpeqJJiujnbpC5zQwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCICEwj2dof4djTIvUkdM2soh+0/xxyx/lj8fTC7SJ+j0XAiEA\n76PiFqK0TfRGDjQ3r8+OmFMAJlhMC8x828i4eI7qB5Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVVh3arK72N5TnW59NwRPo5gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzY5NzJiZi1kOGQ1LTRlYTgtOWZiZi05Njc5NjQ3ZjUxNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZPunJqILyhObAKVn4pLRrkhpJe6LXZJftdaa20Z0GwaWI\nn1l5QMZR7CezOVwtwHIUbv4DGBCeXkFZHOfQvuywo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUnMejeVedkawpeqJJiujnbpC\n5zQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJeGpPh4/OZJYcqJF0P/t9h/R7waiW+tQkYZjo1eJCGYCIDWXbB3PQtQA\nLCe3q4KvO/wMDrJA1oXDlygQ1lralGgy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWDeNYjybkSaINiTBfUoHuMYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmUwZDc3YjEtM2FhMy00NjJmLTg1N2QtZDM2NDllZjg5NGE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWZlZmQ3MzEtOTE4OS00YjJkLThkZGYtYjgyYWFiOTBi\nYTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGoOu8cdIjH3IDAc9LakMlCmt\nmACJztOtgXCClyvFZOk59NixLifZyfGbm/ucaKQGH43s8naGeXcYsD4a+AAE06N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURKonYTk2YibNlILTiQiXmPfvawowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDFPl9X\n/hx0ELNquzXyt67Gyj6ZhHHK3b67p5UEclD8MQIgW0iXthoxLrqkZhc/WCAaEs3J\n1q+g+hZSjMv3ExMMvcI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7198", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7198` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZMPsSgm1anpgC6HgGnEpuoCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzZjM2YzZkLWQyODYtNDU3Ny1hZDU2LTkwZTUxOGI3ZmZkNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTVlODUyOTgtNDAz\nZi00MTYxLTk4NTYtOGY4NTRjNDhjMzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExbP/C02aXeh9tJk2pGHqUc3UIFCk+IZ2O3ywLpWpUQYdVBKLHSY76DkiTNQT\n0YpXWA3lEclq6S/biYIfivLLP6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEAULM27OUTcH3R+ciKS1ih60iEgwHwYDVR0j\nBBgwFoAUPkREKk5keaCE7YpdarNRxnnsW8AwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIEEh1oU97Y1L\n76xj7pt4h27cS0pZB66Fox4R8jalB/7WAiBQ8IO51fgQRb3PaYHq22g5ivWhteeW\nko4N6A8ktlZm4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdKeMYMtkrwJ6ceZn5FOqoL3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nM2YzNmM2ZC1kMjg2LTQ1NzctYWQ1Ni05MGU1MThiN2ZmZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpZ1YxoddffjDyhvKFV9AlOODyUo5c10FrHP5xcZFrbthL\n2ZYm5fCrW0jZ0WapRJTaz6jyVBOEbgtCW8e1gyRlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPkREKk5keaCE7YpdarNRxnns\nW8AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfTzZSvMywKx4+kdgSwGxtc2EfUCUERmh2l63MhQQb+ICIQCj1qhit+sw\ni/pYXTCm4x5pleESKW7VNMJ72ngmHA57Tw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAYmAgGXyT0FzfqG6n2+Q9Z8hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTVlODUyOTgtNDAzZi00MTYxLTk4NTYtOGY4NTRjNDhjMzgzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjI3NDVhYjgtYTk4Ny00ODgzLThmMTgtY2EyNmNiOTdj\nOTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE29ACaaxiNTSbzwMgTYylcVHr\nfFXk18hWPQh1tSwtDHAzl6AOE+DnspW29CV/SwhMMr2bSkDY6xRLA7uNMbHbCqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEAULM27OUTcH3R+ciKS1ih60iEgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIF4Yrros\ne9Ybg62MYwXc6SSzL2pwX7KxA9O6yNidZaupAiAl8KECI4elgNWnOlEopRnW+HDQ\nW4f+jOx0kkeqCEqnTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7199", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7199` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISATbWGmeQZDGZoAWODpwqFptjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxZDdmYTE5LTI4NzEtNGU4My04MWFjLWEyODNkMmExODEyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFhMTY1ZWEtYjYy\nNS00M2E1LWE2YmYtMzJlMGQxOGU1YWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1Ls30OR2nI5KdV5qPOZZvci2gXC/ns58u/lxjYD5cD+5cP3eBwAD0eQA2oFu\nwVfoHAdrwJ4bgs+yH4E7l5hpkqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn9rKkj8rfzFFPp3/O8hXJO8W6LcwHwYDVR0j\nBBgwFoAUW940oV7MpVYc8EHbF4P3kxzJ60MwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAN0pjG5LxGDsOTieaLi7jXuljtdL+WbdlkYVJpMxBtD0AiEA0Y5EUOGJ\nFaHptN6bZv4ZVwE5bxlAPjI5RKigEx7RUA0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXumibIRpo4u7zJz29X14/rlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWQ3ZmExOS0yODcxLTRlODMtODFhYy1hMjgzZDJhMTgxMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzNTFOwCL2gptEUC66o9QMn0ywIKkpRkEU3CmAkH8H/JSy\nAprSlxt9RsZdKJ9x/w+yO+yMAoE1hrPZ+Yzriq6Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW940oV7MpVYc8EHbF4P3kxzJ\n60MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIqeY8UPO1lbBBpLiyaqWYTNasPETi3tOLnVsQoSIbBxAiB7CAVGdqN8\n1kvu3qcd4e04bEQeSPAcK/cDIlbjz+TTFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAUt29EVWJXs+x4W0htRfO0rdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFhMTY1ZWEtYjYyNS00M2E1LWE2YmYtMzJlMGQxOGU1YWRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTRlMzIwMDYtNGY1Yy00ODc1LTk1N2EtMTgyMTFkZjFl\nYWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4Di1uynISvVZGZ9WsXriqP8r\nOVw54wYdfDH9W4xT7MnW0+1aafW4rkBItbGRdYAeSg93OpD7LU040BLGAvYwMKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn9rKkj8rfzFFPp3/O8hXJO8W6LcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGwUOCZ6\nwBGEnuPTpJEgSGYIF2xf3ptisNNHFlAoNBBjAiBo/kJmGqU0L1oln+qRNsVTU2xF\n4cfQ4SexqbDw8iFL1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7200", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7200` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAe1s9BF/D/gfJ5hNRAFGQRxoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3NTRhMjNlLWY0YjMtNDk3YS1hMzRjLTRlZjc0MjhhNDVkNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjgxMDdhYmMtNGJk\nMS00NmY2LWJkNWItOGU3MmY0N2VkMTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETq8yqllqhZFiuKmeXvEzP8VQ6U973j3ltuRdUOE7X1JcodBu+PLzga4FTCFd\nfhAtOU2tvR9fK/VBuiwFUQ5iYaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa4Z6evbpIW9oHNJdGhMpf8rXhmwwHwYDVR0j\nBBgwFoAUnfgVVemihIszShfRs9I9Nt3hsvQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIuqTHB/jVI5c9LfgYpynGWuGnDnMaDAM+vGC/oy8wsyAiEAjUYDYRCo\n5Jd0cP4wdRb3GM4PNgmdrCvs1jklo1wpze0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAalFWGuQesPMAQrQWjmbGd+uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzU0YTIzZS1mNGIzLTQ5N2EtYTM0Yy00ZWY3NDI4YTQ1ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATO/Izbkngnkfg1O9/Hh/T3YY1gKTA+4vdXYfIEKjKXuh2f\n06+Wl0qcwpmPH3jqYiXdq/SGkA5InWGX0Df5FtLFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnfgVVemihIszShfRs9I9Nt3h\nsvQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGPlv/H4gC68HPjsJZFRAdmKDPQBm3tG56pS7P8vQw8gCIFdEWHKA39A1\nWTFTEV819Xt4Fa0EcjBoVgc8RSDz893a\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAazndYRV/MFbGOJvllBjDqeRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjgxMDdhYmMtNGJkMS00NmY2LWJkNWItOGU3MmY0N2VkMTVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTBkMmM4ODktMzRmOC00ZDdlLWI5YTYtNWE2OTU3ODVl\nYTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUD0t6zEPxz5xcl0002iVqhSI\nLTZxTiPW3gKFgCLklZImnlCmS3U5RRKOfvZkQWMMRe9cYGwMSskbrFXNxIfeCKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUa4Z6evbpIW9oHNJdGhMpf8rXhmwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFUCO3km\n3vO93sXrLR59awLzdyvABafE5canGhL4Q9Y7AiB6oNy1gVWYN6AaIeBASgVc027L\nomlRh0D+tqgnINx2qg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7201", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7201` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAZz/31FtFTRMC1c5SiXifEIxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5NjA4ODk4LWI3MzgtNDc2Ni1hZjljLWFhMGVkMDhiMDc2YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JiNTg4YTMtMThh\nNi00YmYxLTg4ZWQtNmFjMTNjNzgwY2VlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4Glp+DmFhnOu4685oq02z2wYeQO5I2uverJrOvK+VHLWq50Tffa8L7rYOPt+\nIyeC/KILRDP9f9p9b4aQ7ifuHKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6H2TIRoNeYXKq+ldIiT3x8TO1KowHwYDVR0j\nBBgwFoAUILiQc4S/O+v3xemwcISgu7xjbnowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCOc6lQrrPTQlk2RAGBAn87SqxS99UjRINtsEsD5RCxIAIhAKPrDm/L\nq9goAeIeCHSFSvPONs31HNDyfHDHR7a/0OFF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdLKO2sgn1XP8f79hYUJkAVjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTYwODg5OC1iNzM4LTQ3NjYtYWY5Yy1hYTBlZDA4YjA3NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkQ39iKTxScETOXuGH2yONN2PNGnarkhEg6smrfOBggPTp\nOT/iCgidV6/djmNq/TmTZqDxOXodBYIoK/EM0bSUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUILiQc4S/O+v3xemwcISgu7xj\nbnowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU/6W7MVaMZfmHvo4tTEq/cG5SouO/4hPxL6iktlr/0MCIDVp7NISr/CI\n3QqCD1mLhPsbWq2d1PoqoFidxoe+Qu1c\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWqbRxJBBimcC7rtEmEMYb/bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JiNTg4YTMtMThhNi00YmYxLTg4ZWQtNmFjMTNjNzgwY2VlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmNmOGYwZWItMjY0OS00NjA0LTg0NTctOTZmZWY4NTY1\nNzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7kJja1+q0LrYBvdx7NljYM5Z\npjRuGonehr5MNnXV1HEgMyviZVhLbPWl2wooqZbLz2mCgjbRuN0VhyS4KfARJKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6H2TIRoNeYXKq+ldIiT3x8TO1KowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIH9TJYDe\nmvwj6Dbnk5H4tvT4rWJFhNPeSXggs44Wb6jZAiEAnVIRmVvkrJyNdMte+c2T9biu\nmdc3NfF4MNKipvCg9Qo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7202", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7202` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAXA1ckhC2eVThWXB2KsOZMS6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3OWE1MTg1LTkwNDktNGFjNS1iZmVjLWFjM2EzZjI1NjMzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVjNGUyYjgtY2Zm\nNS00OWRjLTliNjAtNjgyNTJkMGI5OTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx2s6fy3+1PHZehQBUdYpyxziMre9ALwEK+wtlQL691LTVeULC0tEZ6HYv4B6\ngee7jgfRzmq6VDhdlkMNRNEl6KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUokhclmYsxvWwe13Y1p8jhJo6mL8wHwYDVR0j\nBBgwFoAUJAzLEhJgwMsIESCvETQqOoNPnxEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDYFWQVMB8DuGl5idCkn1S6WRNFabKTADTJJYDS\n/AahYgIhANCBSz7QVppM0kdUNJBHdZkLpQg9alF5V3iPX38EFT2B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUfZCy+WfduIaJeMfjo7Yy2eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzlhNTE4NS05MDQ5LTRhYzUtYmZlYy1hYzNhM2YyNTYzM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2xlwFCE5F4ddoKPJyzUJyHSew16vdOpyIkh9fzLINzS91\nPQc3lyEfnRNJUGVJ0v74eC6Yf+MuClRjm+4LNSTCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJAzLEhJgwMsIESCvETQqOoNP\nnxEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMcT3u7BLeNKI/jBq4sPcEifFlhE+cW/2k4QPmku9XjyAiAyz1b5XlM/\nnYEFLixB3DsEs+VUMGSo3+S2XysvuJbWYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAa9YaUoTelMc72nMplQztabJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVjNGUyYjgtY2ZmNS00OWRjLTliNjAtNjgyNTJkMGI5OTcyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDQ5YTUyNzItNTViNC00MzJkLWEzYjItZmE1ODc4ZTRl\nZjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtjbMc2F73QLsgjQfRmOAUupU\n9A+ApKNPTze//3B7XSOC7SLzKHQaxsqnvA/gyUXL207pVJPsglf0+5sLrivakaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUokhclmYsxvWwe13Y1p8jhJo6mL8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCldohe\nsD0FiffvhxVEgyT8WLlwbYOiw8Pbo+xaqlYLaAIhAL416MrqRqzqQJs1n2S0/FDz\n0X+6Gf+zJrWh6iBbrhdQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7203", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7203` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAe1HOYVpw3ZBu6OFmbCOAj6SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4OTUyM2ZjLTNmNjMtNDAwMi1hN2I4LWFiOTk2NGU5NTk3YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJjMzRmOTMtYzU3\nYS00MzZlLWE1OGUtYjVlNjdmZjk1MTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEedRQ4LhfQ0GgoClmBGT99kHwysDfi54ltO5IdggOSfC1UUqRIDuLoUYEoxI1\nyhycRBD8ApjMiOq3ia6KavNMtaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSkau5EciO5/Pt7ESxaIatPSLsIcwHwYDVR0j\nBBgwFoAUS/nG4zSngaLmbJt8H+yZncV9+bYwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIC00AK6POua8BPLFnGdrvqkdrRmZNpps6JariGNT\nwGdoAiEA179/DZvhkLIkbNgh10O0ZtPn/6KCBYp528UYiRomr94=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQj0ndCR28bBipcgy83niL57MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODk1MjNmYy0zZjYzLTQwMDItYTdiOC1hYjk5NjRlOTU5N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASs50a4yjsziWntpkJe/uBYeOzkKkYR2w9SIxhXhwtRekLf\nw/zVLU5LCkQ48PsHtFjFRGQlsdLtaFfz+293Zengo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS/nG4zSngaLmbJt8H+yZncV9\n+bYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN6rtgMfOH4lh2vsYob2gN9d1w0mgNEuNA+sDG4B1aarAiEAoIWybxC7\ndcVrrz2b4r9W7YVTb4xecsuwmnjkPlT876g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAa9XCboiwc/YnUDDMzPaewLPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJjMzRmOTMtYzU3YS00MzZlLWE1OGUtYjVlNjdmZjk1MTU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmMyYTRjNzYtZThmZi00NmU2LWI2ZDItYjg4ZmJhODNl\nM2U0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERWvGf7VbVBdgfoINapteoatQ\nxrldtMrs9IWgPunntqpC9abTOL9wwIhzlsoVbJodjNQsXN9qg2Pu1nQPo4Ccz6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSkau5EciO5/Pt7ESxaIatPSLsIcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIA0SQg3G\nW9Rtx5J0SaoeB6reX9WuyqvWA6/sKYpKf7pHAiAAl7pQ701gtbJ7VTrDYfMBf1QX\nAPKhthgJDkw+pkUF4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7204", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7204` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAXJa8CM5ICUJAqhIJpOTUDozMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZjdkYTc5LWZlM2QtNGZlYi04NmY4LWFkNTZlZjE2NzdkOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhmMjU2YjEtZTc4\nMC00MGNjLWI1NTAtN2YzNTI4NzhiNzk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFyb2QIMUSaufrqIigu9ZRyGBqP8B/7M/2jHPjERwtgCCIH3CytqsZ6AN65pt\npv8o9J4uaONV2X7Q+iivUlyBQqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3eoNQbTjmsk+iAvhUDEu+kYboyIwHwYDVR0j\nBBgwFoAUy+pwNzy2kPmLkDytmYbr8afkkE8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIA3Zaq4npuM303H8xUkA48I0LZFq0XmAt3jgZAXmuq/EAiBo\n+blncDikFZwWZPpRUu9lcFEyqg7r2LhvAymd7nsDwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf6kSsuHMyhycQJjrOruF7LJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2Y3ZGE3OS1mZTNkLTRmZWItODZmOC1hZDU2ZWYxNjc3ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe46YbbxlOwcM65+Xz4zUQzdLt/CeOBR89TY9tghFIHxEE\nA77n6MAfzTVWR7Bht91BBNHQCEdKh9cHJIWqaFy8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy+pwNzy2kPmLkDytmYbr8afk\nkE8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJwKU9wr+hZAIaHEtNHbw8FLeR1AIkO8KprUc+mtwvhQAiEAh25xD+jf\nFAi5rEyoj84Gosc0fra/NaxD7lbfo75etoI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcwE8/Hfj225UXokFZ0/b4weMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhmMjU2YjEtZTc4MC00MGNjLWI1NTAtN2YzNTI4NzhiNzk2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDAxNDBmNWQtYjc1Yi00ZjQ4LTllNjQtNWZhMWZjMWQ3\nNTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE04tqSe4DmKw7SEi0H3qH1B8D\nztMU/EbtcYKWQdfIghGCcc3Pt5Gt765g8BfnlOotyPrn2YCZO2b89x2ajZXir6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3eoNQbTjmsk+iAvhUDEu+kYboyIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCFSAhR\nv6oJdc01/F+Y+xY9e+8c4dqlgfJT4rGD9PnJcwIgDoPsHGkFDoxwGYBNLyW2Dibu\n7O8cTMyLAz+9256Lors=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7205", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7205` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUgWUS1YGqhq87eCuucC5t8bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ZDFjMjkwLTAyMWUtNDI3OC1iZTk2LTI2NjYyMmRkNTdkZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA4Y2MwYTAtMzcx\nMS00N2MzLWE5YWEtMmE3MmRmZTIzYTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC12UN9RKECRlqM/I7QQNHAng8Z3ChiQe+RkR48zggKomarxAM63MUcX3npZy\n/TsHLbkkW+k5N64uK/+YgwvUnKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ09RWaDo6FA+r6LWKUgWou69LwEwHwYDVR0j\nBBgwFoAU1Gc2SfkXNRmBp9bidoSiBEbqttwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCID+ob36pB1CcaRamn80E4O4eapwc/c4b\nN+k8f3SQ6HJeAiEAwmjJGZFlhpj/FOXmcdsZDEfmlPzxIUxX0keVhSSZwhU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYGge2siKctFDsJsYK5Pwzz2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGQxYzI5MC0wMjFlLTQyNzgtYmU5Ni0yNjY2MjJkZDU3ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvuP8icN9COx2zi0AgR4zZmLhBZ/qCNpc8ThpCCFybOJbQ\n95PK88h760Cmz9MpUK3pAs84qYA80lDhF0qG0TKbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Gc2SfkXNRmBp9bidoSiBEbq\nttwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgURno/Z+MOfR3nou27gtBJy7VVitaq4G84LGOCeH0tgkCIFDRBB6/oP31\nYWX7HN0Pf/6WAmNuAo4a+SjRN0mgXpjs\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbR/55DYcgHC3gRWVyrobc9EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA4Y2MwYTAtMzcxMS00N2MzLWE5YWEtMmE3MmRmZTIzYTRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzg1YzJhN2QtOTJjMC00MGE1LTgzNDgtOThkNTE4NWNi\nNGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGk190i8Iq/QSoCXt0DW0K6Dj\nFK8QBa4AIzVIg8yBcLUPlEEO/GuKIoZAgZmqSuJvKedrlK14cSr8fAAV2pKgI6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZ09RWaDo6FA+r6LWKUgWou69LwEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCnoNRv\neSdOJzwr25m1obrjF7WWUWFY976L+J6uhMMWagIgAQJfYNgUJmAWvU5Q6DavsNOs\nK20x68Pzr14iRjfPTP0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7206", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7206` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAXoNrcgNvn+VtZ/7wQIGN3W6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1OTVlN2ZiLTQ3NTgtNDZlYS04NWFiLTBjY2ZjYzgyNGFkYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYxOTNhOTAtZmNk\nNS00NjhhLTg2NTEtMTFlZTc4N2JiYjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpoCPuVXaHJ2Lkq6TiyDUMHWGdfCQWbyqBAca9jrEAb+4KLuAyeKTZXWJmWEa\nR61WybLnBDfB5PiUw7s+xcPpKaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOLLkRYddvdlwgJIblfNt8qm1/mEwHwYDVR0j\nBBgwFoAUOHS8Hx6uTwYxT+wsPvWHzHovILMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDd5gCa4b9XTXKKEPKow3Dayc3PJAJ5\nK2qKGdtwk5bg/gIgPQ/ZIal0XgFG4QMe/csUcgUc2WDOO6Z9la/f8kFEZX0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQY3l/M0j1OgG9LPgsr/BapvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTk1ZTdmYi00NzU4LTQ2ZWEtODVhYi0wY2NmY2M4MjRhZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQO/ObHNWMyZfHxAgpEOTTa/QCVWmryYvEqY0941UR/f7mP\ngNEDSXcmfmB3ZWwWed0NdI8j5EP9NTEKbvNFP4xso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOHS8Hx6uTwYxT+wsPvWHzHov\nILMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP7DoelLFko6BiTCVp07UWPyendgYXKgQwe+7MtTuC9gCICOwwl55Jj4e\nRWZNf/jnvhHLOM8FEicpBy5J4StKBFHP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATRlElAITQluJhG00Z6oY9GQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYxOTNhOTAtZmNkNS00NjhhLTg2NTEtMTFlZTc4N2JiYjQ3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGE4MTI3MzQtNmUxNS00YmViLWEwOTMtMzE5NTkxMjY4\nM2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8hByhKc+Qt3ngmywTMfTVNll\n9lBMDIn98ylYBTY1HVBQX5TrX8jJHVcSb/9TWmNY0mjJQD2N6R+zxShFnHDqR6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOLLkRYddvdlwgJIblfNt8qm1/mEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCJho7d\n/suuRsTqBjaFTgz+YKrwdot0I8G8/yN5Qx8AAQIgBXcycmjdF7vpCKckTGQqVVjt\nmBYqGVI6QWR19ZiERLw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7207", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7207` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAf/Q03hP0CCuNdJGAZEkJbPBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1YmYyMTQ0LTlkOTgtNDhmNi04NWUxLWZjZDM4NDc3YmRlYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2MzZmI0MjYtY2Ew\nOC00YjczLTlmMTMtZDRkNWFiOThiODhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMcP1fW5xOtUhwYGhnC2jGEeo3n/Hq9oUk9ndytbwDpMFt0WrpZlSvzW6W5TD\nseGisNTErGXwLbCPUpJyRFoqYaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzKPdXTNjyFCPYNzwCjncOgEJTYMwHwYDVR0j\nBBgwFoAUKJAbGs9MAofWB4GvgQ5WjQx0CeEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEGZ9f+xODv6\nKNiP+jNkMyaeoxNBsEFUCbmgIARsm6aaAiEApO5ziidJfDh3+8kjBIL8/X9zvCgV\nd9geup4BLVLGbXA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb21zJmF++S8Hjl/2P70vvJRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWJmMjE0NC05ZDk4LTQ4ZjYtODVlMS1mY2QzODQ3N2JkZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBknEqCpbbZmG5XKbh6qzgFNigkUDyjcVRCAfibJn6p7s9\np9KMiR2CZW7lhD1PtOdKTfXnzAQVd++dwOervXXXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKJAbGs9MAofWB4GvgQ5WjQx0\nCeEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZM/qTB7qhTqWliVkTh/RrBlxZvBzuOsK57olEJ6y+aUCIHQ9R3WSSQf7\nLB0N+cBey/IKvpqYBEp6V+SD7fCYSUlP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVXA3orHL7Z/453DmIpZqQXWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2MzZmI0MjYtY2EwOC00YjczLTlmMTMtZDRkNWFiOThiODhiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2FkYTc0NzAtYzc5YS00YzYzLWE4NDgtOTMzYjlmNDQ1\nZGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvMQZy6RlLwIMQ1Nu+7KL4lf2\n3Bm3tTDb4j+QFsRrY34WBfwVRLTEgPxXNArWeHS2npUTstsAVbHqkufPdd/g66N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzKPdXTNjyFCPYNzwCjncOgEJTYMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCgM1+F\n+//wMe0FxRh5yzkWQMMk/VTW42XrydSgyaNjdAIhALhzcPWm3h5b913LfBPlTEqV\nHnY2fscYq5jLX0fwcjOI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7208", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7208` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAXxbI5uKyn+6ymJ8R+0AJYDhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2MjIyZTkxLTM2MDQtNDU5Yy04N2FiLTU0MThhMmUyOTgzMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBmMGQ5MmYtODAx\nZC00MmEwLTgzZTItYWEyNTdjZWUxYmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERLi8MmRV1NxJvRM3qHN9TkyDkiYE/qGe8lzNjcO1GGoY9y90sO9jK8qBZhk8\nW0itM88X30AXXa2NMhFkudJHUKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/98f3WvU0s835Lw8f4d/oyCmbK4wHwYDVR0j\nBBgwFoAUTXI3PWIsQpHdCQ/FQzlvWNUI3hgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAO3LEWZPbMb5cXLPDjtPA53Q9a5AhHnQVoa8sCn+uWAMAiBSQOmSOvAE\nbz3LvRs8y/ggbifiaBUYel2yXMlgW9VwCg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcOvKX+BELoyT/4WVKbIX3nUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjIyMmU5MS0zNjA0LTQ1OWMtODdhYi01NDE4YTJlMjk4MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHLGvdGdYyAAFasQ/4qL4e+68DOleSIYbTIBxgFOcs/cBk\ni7/vrWlprAT4IyVkiuvukmRhuqG7HCV8g+mV9j1qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTXI3PWIsQpHdCQ/FQzlvWNUI\n3hgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKHN7EICfCiqFRrSerSpzHfKcDlyGQFK1QaVg3Qo3DumAiAOos/Dm11j\n2sb4RLCBPdp+QJY+e0tfJwAQgDAm4C/ObA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAZVzvtzOtOTvZkJskNsL6UC5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBmMGQ5MmYtODAxZC00MmEwLTgzZTItYWEyNTdjZWUxYmM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODVhMDAyOTktMWRlMi00ZDU0LWJmMzYtNDNiNWU2ODI4\nNDU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeaCOR/F2K2YHZHT2m6Eu8gbP\nvA6lm1MYqQr6t4TFMV1pS83Dnoe4OGJfOxhxXHlgSFhe/moqC6rWRsg3vUXEa6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/98f3WvU0s835Lw8f4d/oyCmbK4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIEftf+KZ\nQgwtG/8aPXs9qxoXWCG2frM1gzMTAUkYHwWIAiArNwlY6iaXVFzTp2hc83y2ZVTY\nAbSfej0lBULnzOCTAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7209", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7209` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAbpF2T1hbrU3ODvrc8i5R4D1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNWVlYjlmLTk4NzktNGU1Yy1iNjE0LTg5ZjU0NjdkOTMwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY4ODdlMGYtMDA1\nYi00OGQwLWJkNTctZTE4ZTFmYTU0ZDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXfbYWL+3SPuuyOCjSCoVT6MXq8QWGMoxCCZfSAOtl0Hfgni6E4zoArgvZyQp\nM3e3y7WDe0vB8QtOR9nlM/4c4aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxhoX4uPVMWCj77xgc8X6PQAhVaQwHwYDVR0j\nBBgwFoAUrc8b4busycww4rnK27ouY+9KrTwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALHIM5GB6RiXwkMi8GwoAYF9sF2OkVYZpKuVaMy0AhgAAiEApKgrWT7W\n6P/QSLBAm7A9SBuZuVki4MOUVYLAhJ5ejY0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVUmcgxbjTwq2Yk1vloHfN93MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDVlZWI5Zi05ODc5LTRlNWMtYjYxNC04OWY1NDY3ZDkzMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEyDSZ4td4TWHuxuM3NyX/r6wnN0YnWtUuh4oEM3FtRyCv\npqCHrbchOyT9FVQP26aH7pTkZaEs6R/p4CIg7Ysco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrc8b4busycww4rnK27ouY+9K\nrTwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd1mWTP4yxoLWnCCbWiBVQKsLM680nYc31+JBOS/X2WwCID96EL2Aopiz\n48HNASIdnD025uX+IKaSpUV076WYDSci\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAbUH20Yhn/AjxJda6NaczHzLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY4ODdlMGYtMDA1Yi00OGQwLWJkNTctZTE4ZTFmYTU0ZDZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjJhNjE2ZTgtOTU4Ny00NjcxLWFjYzEtZGJkZDU5NWE5\nNmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELsLAcjRMdpyRKmEY48nmjZMD\nEjFZARL2wiIsCA7K2fEVY7IWNtwppEL7ClFXnuLobRrQn6Plgp10SEzbr6Or/KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxhoX4uPVMWCj77xgc8X6PQAhVaQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIB7jf16W\n68G5KQcATfu6Lj6gXldRJ+NBZ4+T74feYqR1AiBpnVDllRp0HYKTFyWA6d/MQoZb\ngNziA4YxnMG4psmLgw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7210", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7210` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdg+CD0ovgPNqkTKB6VnlUWdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkY2JlZGM4LWYxM2ItNGQ3Yy1hZmNmLTA3OTlkNTU1YTg3NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTIxZDkwMzAtZjE4\nOS00YWZlLTk1YTItNTM1YWJkMWVhOTI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx1Os83KF+yuKWVnyCbZHOEEq9QLfEWuXrlmJBhwbEV/3vTF0jMH33UjPFg8k\npW2DEKCg2L8BEsFl4y1szeUNU6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWF9LF5zScEOW4AiQ+AgBy9pSJR4wHwYDVR0j\nBBgwFoAUv0b3BJ1cxlZjyHINgqGoJ+BgZ68wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIDUABRbqmtw+sOT3nqKI9lh10RgAAnWHpleaQP8lkJXbAiEA0ITJes1n\n/AnTo5eUxaSfVjBhXOQtX74acS8LDSad32s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVAqi83x7u8qr4coqwZkr+QeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGNiZWRjOC1mMTNiLTRkN2MtYWZjZi0wNzk5ZDU1NWE4NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPEnq66XI2eCX4Fg+cogVuDUvn+EHga48i55m5lqIZLBOU\nlcW8qlkDldY3bxhCGrautz8hxuSXIOfFVph9suBio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv0b3BJ1cxlZjyHINgqGoJ+Bg\nZ68wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM3j7HTiFUB711cVOhOM302oNfg03tgvQ497vo22GluQCIQCTlXNrdzX2\npbSvFYSjvt2B9KJH2Gl5qwK+0AM+Ig71RQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAeibBqcSVbv6r4DK9qSMUWalMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTIxZDkwMzAtZjE4OS00YWZlLTk1YTItNTM1YWJkMWVhOTI3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzM4NzdjYjUtZjZmOC00ZDM3LTk0YmItYWRkMTJiMmMz\nODEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmhnCLcljxOfuuOHCVpJHJwqx\nqZCO8aDdW6FsLTJaoOowm8Ej+niHD+3efGEDqFvGL6nFDTtEcc19xlSe+RY8mKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWF9LF5zScEOW4AiQ+AgBy9pSJR4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCSxHvG\nKu9NUSZJj1u7nvZrLHhLejoFo+R/PrnUTDbbxgIgC7HFsIsJvcQnwA5d0b2Cx4Cl\nxWlDNoX2jNxv7G2KDlI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7211", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7211` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAWjsD2uuseKckYXPCeOw2xsnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljODY5OGExLWYzMzQtNDBmNS1iNDFhLTk2ZTc5ZTU0YzE0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzczYTAwOWUtZWZk\nYS00MGI1LWI2ZjItNzYyODdkNjFhNDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErNFJqILepwFzn96hWMvS/bjleiHkrKnGM58TpCISgZScC1niYQphWHR/WYfD\nXIFhneIUCUvCXy/yncVZlGzDuaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU20M+dpaqzCuGPu2KI9bdpVq1JI8wHwYDVR0j\nBBgwFoAUmhbSDAJGoBIhMeWsGBr+5ReLHwswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDhTwetHbuFkxma+OoPL4GD+Ew0FyQW1dlgowp9\ndcigwAIgXX2uQnHV3GitQ90uf2jgEc8y/wkuXfagMf/TOK+DMtg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU5jMNuPAxCsYo7hlx/iw8BUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzg2OThhMS1mMzM0LTQwZjUtYjQxYS05NmU3OWU1NGMxNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnO3et0cxFzUAYRViek3c9hEEIcWSFhnGjbFATvtmHtl1c\njrhcWQqMmgBkLdJWWdhoM59ITR3G0AdfximyAgA1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmhbSDAJGoBIhMeWsGBr+5ReL\nHwswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO6H5uednRGcdhErKBiWkhzVc5HQuPInrfba2/gf3jXuAiBhP4mRIP6a\nXtjyx5oePieJiHKS9PFkQvnHYqMI2MzDSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAf8mHPbLFlpekY1BgxY7wy5rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzczYTAwOWUtZWZkYS00MGI1LWI2ZjItNzYyODdkNjFhNDViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjgwMWExNDAtZjgxMS00NGUxLWIxYWMtY2FjYmQyZWM5\nNzc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyo97mWR/gfQMqSPXzOWMhwUV\nWpE8T42jzJ+sG3vBLa9fp9HjjayDsW5SfOeMaaDD69t18fxwk/hA7a8er9I30aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU20M+dpaqzCuGPu2KI9bdpVq1JI8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCICJ7o9Ru\nMtdQfWp/GSM5RzW7Pko4/sdHzKe2v2Eg7AhmAiEAw2uxF2AByygRmpmu5+P35JeY\ny27sjuXMGl6ZLsk+gR8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7212", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7212` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAQ0Abc6bUnZ1n2j0Dceo/VyPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmMDMzMDJlLTdlNmYtNDljZS04MDRkLTY2OThjZWM2N2E1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE5MDhkZmUtYmI2\nNy00ODkxLWE3OWEtMTEyMzU0MjE4Yjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6jJB/uleHlOhbI5XTs6jNR8I49ShyhpRTe6u6y9xowYR2fBaruoVWewXnKbr\n3HuTX+lMb0cMD97UmuOsCl3MgaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEm9yYN64jqKdcVo8aV5ItrCjto4wHwYDVR0j\nBBgwFoAUowxEK8fTpaDGnHKhYNnc9nawWDMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCHYJcCVCufjDpnqMzMDHmUSjZQTPshNJgrckkd\njmVcFQIhAKbPZosTGgQbhIk2yr1pAzuUnmH/2iVnCsWrRQ57JCtX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUOHWH0KgZEIiH5zT4/9QN5oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjAzMzAyZS03ZTZmLTQ5Y2UtODA0ZC02Njk4Y2VjNjdhNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdvB9HbRAniArilGutjKpBMlF/7C0u7SVwj+IIHSscDVdr\nv/iTJKqpLrR9MKL86eFoECrfgtnvWv1/xMqnG0Ego2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUowxEK8fTpaDGnHKhYNnc9naw\nWDMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO5XkwQuHyWLssmtMXDTWQxYaRfD1+uJaYPIhyyxSRj0AiEAquAwmjjW\ngd3+1NFxlC6qbNYzwTX0Pqy9lDAtxOxnOIE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASNXFfdcyXHH5XtGWCoQ1i6bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE5MDhkZmUtYmI2Ny00ODkxLWE3OWEtMTEyMzU0MjE4Yjc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWVlZjFiNDQtOGNmZS00OWRhLTlmZGItOTdlYTQ4ZDc4\nNjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfcslctvP0CQvMEDKBv29EL6R\nAShsTXmpNbqHLG8UHrLxVh1CqmTi2U0H9bIpcMJoG46LZYMx6cr3s+KyC+aneKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEm9yYN64jqKdcVo8aV5ItrCjto4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCZWZJn\nMo4y18L56lrHw9dqBVVFf1xAg2w9tkxsKqAOEgIhAMQgFWr7Q4VWitCpcJWQ7I9N\nT7IJ3teup5CQeULPUeRE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7213", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7213` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISATNlt3u9OTtZ24dehYT3nNuUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzOGU1NjMwLTcwZjItNDUwOS1iOGE4LTVhMTgwNDczZDg3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFhYWNmZDUtM2Qz\nNC00YmNiLTkwMGQtOWVkMjJiZjk4NGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzzUmgUO9spYNdvJeu/+UoweyZnU7CIdyJDDbZoUlvONxztKCBX228AvLyYsf\n/OJEpwgUUajGhxU1jboXThYH76OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiJSbz+4ambQWfPpp5yAsAxYffQcwHwYDVR0j\nBBgwFoAU5l50J3sExqhCRhZrrj6ZIsnCHXYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCICtJmvmKxvtsmNAzcTMPGSQcEiOEcDSNKj6L3ADRShjCAiEA\n69Y6jzJ8yqzbhhV5SqGrdcsi3w1tsH/lUcrNfWkcYOU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARdeahQ3Yy7nfl7koo3oj7m5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzhlNTYzMC03MGYyLTQ1MDktYjhhOC01YTE4MDQ3M2Q4NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASm++Edtq9gKgbP9Vkg5W8urp9NCCECEJwU6krotDB7t1j7\nTkJICBBIdUW2wWr4d30oXB86U9DotzBATQobPqzSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5l50J3sExqhCRhZrrj6ZIsnC\nHXYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbs/yQJ7vA1eQC1mTYFFbp5gtks/YYW9zHWgiUDRTALgCIARbVIousWLR\n2caW0IO2OgjRD52+MmLA2Dm1n/4gU5Nx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARESvMvziLOwzUb36w/g59CIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFhYWNmZDUtM2QzNC00YmNiLTkwMGQtOWVkMjJiZjk4NGYwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWZiYmI2NGQtNzE2OC00MjUwLWI0MGUtYTgyMzNiMjgw\nZmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHBIFKyJAW5IHEQA9FMX730RW\nkmuUo4PBFXRxmYyZt8CHfPHjoadKGOyaljkPlky3aBb7bC8iYGhgNFvsp81CvqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiJSbz+4ambQWfPpp5yAsAxYffQcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIB3pxerU\nKmPcib/8URjOAZJN5jzxgndtWTe/mYQSVKw/AiEAvTE3+cABAI3xw/DiB+Wt75bT\nzxaBXFg8fkDhUFuWYfQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7214", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7214` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZYHAGdULSR1lyxDNG+QDZQ9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2OGExNGUwLTIyNDAtNDMyYS1iZGI4LTBiMTE3YmJmNjEyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTZiYjUyOTEtMThk\nNi00NGE2LTg3ZWEtYjk3YzJiNmZjNGY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsdh3yhhgARPZAI3tApbG7uOzvsf1IXnaxy6wMUKyFoeKNWdUFhrxA1qQ0IFJ\nsSmClRyHfHtqWF15wNVZbmvlVKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYWKJWgzqPw7yYhnfVdGmSXwzgmwwHwYDVR0j\nBBgwFoAUZWqYyIwq4ISqPCpZgJQQJKoDwGAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAbh1ff4HuCp3RNlSGjHr8WOUGJmU9XJ\nHdqjprkYLptkAiEAyWG2uCEEu1Xa2k4E/xqY1iAQBWvSB91Hn6qsnTNFu8Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWBaKyR3FFTcqE93/IWIKJT2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjhhMTRlMC0yMjQwLTQzMmEtYmRiOC0wYjExN2JiZjYxMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAsn7fZWbou+0dOCE+Fk8VDHINaYh6VecqL4TIutsH6ziv\nnlNBUE0M2TssRjsMmq6/3NX3c1d3e2T0x1WDiFfro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZWqYyIwq4ISqPCpZgJQQJKoD\nwGAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHQj1PkJbzMpeyMjlxRCG/9/c6ob6vEMgUTQjy24AUM0CIG85gRPwmI+X\ncJF3HgRQZKxkt5XtOegWbaL4X9B4MN2F\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAROYQOxfXOJk15wgK2dI/lLwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTZiYjUyOTEtMThkNi00NGE2LTg3ZWEtYjk3YzJiNmZjNGY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZkODZmYTYtODE2OC00MTM2LWEwMmEtZWY1MTFhMzEw\nNGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIN/ASDVJgJAzBbCTT9yi4g6z\nwouCNN4zy1t5EN9j4NWX7tP/MSjsCKdrt1MmhhK+yx+ZCxCxl2OFC9l5tpnkxKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYWKJWgzqPw7yYhnfVdGmSXwzgmwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCC2Yng\nvgdO7sffJc8vF8cBh7+oKbvL78UTuCCdzmN1/wIgSkCXcLA6NJjgg6uajSoXt9Op\noGIhzAvOb9n6cvoTzAM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7215", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7215` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAXwy3wDWZj9BrKcUvMqIXQPuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1YTJkMjBmLWM1ZWUtNDAxMS05MTQ0LTE4OGViN2QwODAxNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM1NjVkNGQtYmNh\nNC00OTNjLWJlOWYtMTcwNzkzOWY0ZDc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8/My5NJQC0ABkf2uK9NuPrJkAgtKSD6BjncNCjmxfQLQBlcFVDIpkhSRq30+\n7Fc1Y50npChOG0PKlysCmSU5pKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvZvxdhE5SEqKZNKenVgDpheWVPMwHwYDVR0j\nBBgwFoAUGw8Ouspc09N1exhhL55YlMqIkmUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEy5FuE3XRe76/I6jY+F/zH7fEqTp5sV\nJOZPACxfKaFuAiEA5emD+09yBRgU3eS/pKshiNmO0341lIsgPLH324R6ow4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaSjA5nU/iyWY7fGU+5nM4rdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWEyZDIwZi1jNWVlLTQwMTEtOTE0NC0xODhlYjdkMDgwMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNwo4B2F0Mo2rWhinaMilEeYaVQIdQ7FxuKsF+RzGKTju4\n+19B2ZBMqn0rScqVQaXiufdcP5vFeLIQvarbBjdjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGw8Ouspc09N1exhhL55YlMqI\nkmUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGwl4bRhcgd617xJ5NbBMcqONR8++idIBO06Sg41BifQCIBIg+taRIpX6\nZ2HLZV95phAhiEYf5uDKCYmurvHRJCke\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATjX5qVYQlqraoKB4fJuOBNRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM1NjVkNGQtYmNhNC00OTNjLWJlOWYtMTcwNzkzOWY0ZDc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzQ1ZGVmNjktMjJhMi00YWRiLWFkYWItZTQzNWRkMDdj\nZjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELUT7/BhjK8TGbls6HhmE/4jr\n7QeANjwajIVntn/apIVir8+KKC84V5Z2uhcMVWHrlsqALGvyb6wH2ureX3oo/KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvZvxdhE5SEqKZNKenVgDpheWVPMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIE+gzKMC\nG1oqofvpvyFrkGQxMLmDbvPTwo5k6ioE9XlaAiEAjsUL4gE2IRz0eVAe5KhLK+yp\nxHyvnRdc7OLc8m0PM00=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7216", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7216` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAccsyC5FzbmWYAMyp3fth06HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjZjdmNTJkLWE5MTUtNGM1Ni05MjY1LTcxOGFmYjE4ZjI2ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNlMWNlMTEtMzY3\nYy00MTVhLWIwMjEtMjBmYzAxMjFjOThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP4ab4hcOi6NXunrY1yE4QScm7nFzyQxrGQ0EmQlpFCWmpxZh2fs7varHk2oE\ndd52XAJU+QgJIh6MTfrHlL9wH6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPv9QuBKe549sNuqxmK3uQ3J08rvMB8GA1UdIwQY\nMBaAFLyaYMXo1o4Xv9Howk2k/JM8VVfMMAoGCCqGSM49BAMCA0gAMEUCIQD1qk8/\ncbqg89Up4dJk8Wt0/6Vpxusf2negRil45RM7twIgSQ0ZxWGJAVXv6x61K6ZgMM4R\nTZ1uzhWhuFuRGZZiPrA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUNwfu4Y+OyrtKzE9v+9pWmIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2Y3ZjUyZC1hOTE1LTRjNTYtOTI2NS03MThhZmIxOGYyNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUGT18kFV8VEFdTOiaXAdk7jIji6lybmWMsVqYQ1k4SwqI\n/dzVanyiK/tlDIfnyr4V2xFp+FnIFeFbdM21JNCao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvJpgxejWjhe/0ejCTaT8kzxV\nV8wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOmR95E7qr7xuouXVqbsnc2M0dJCD6XdgosTubAeHVzsCICez2vn9G6Qr\n6mFCuxDUJLB0heuD+kX9LORmtofps66i\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAedo25igTLjLHKuF6j3eA8h3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNlMWNlMTEtMzY3Yy00MTVhLWIwMjEtMjBmYzAxMjFjOThhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODU4NWYyOWMtYmFiOC00ZjMyLWE2ZWMtODIzYzM1MjZh\nNzhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgoyKdW8463TwB3Arq25smYth\nntviDWbaHfHMhC6T+Ozw9htxgNpGn3e6MJ7BQo42n/ByoiEJNq/dDWbcxddcG6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+/1C4Ep7nj2w26rGYre5DcnTyu8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCKSf0+\nXbuD0JNuPcRxVEzHesVz5mj5mhJUuTiSK3AY7wIgZhB0+kZ2IDA+F+JdN+rMrHx/\nLd3DnU/Wy37ntUIIXrI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7217", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7217` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAR3sj/VRhDCk3pO4vWEscw19MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxN2ZjZWE0LTE2MGMtNDBhMy1iOGZmLTQzYzZkOGIwMDAxMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk1N2IwOTAtYTQx\nNy00YjIzLWI2YTUtODI5OTlhMmZmNzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3e5N4SgvDtF/tWad/EgKc0vaAQ4Oh5XlbSRs1vjc8RAcQctJ4bDsmEGGTBvf\n4/oVnOdAzSUKBIBWP7Qyb9/6B6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCIW6mDUhLiaCX/+V514CF2wHllSMB8GA1UdIwQY\nMBaAFJjEJogGOagKF+ReHtfynadyScgTMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAcrWNqeVAK5DNKNlRxqLUgw8ASmnMt6RXV\nFcYJ5QbD9wIhAPE1C6afdVaR0puW61tM7BGUJW3oC6FsXxjAkQbBLnz8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdXc0IFNlsMVxJ1wvEHaAwdWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTdmY2VhNC0xNjBjLTQwYTMtYjhmZi00M2M2ZDhiMDAwMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARokOmWu/Lc9vlDUYZgTbmTc1bT2ZLOmSACGj/oaa+QLA1s\nmp9w2IsRB8oMvQUzek4gpnX+AyoqKwyjKWEMT6/2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmMQmiAY5qAoX5F4e1/Kdp3JJ\nyBMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOxTmT8PQ5uubsDb+CyiyNdMllMdxA5lq4T7edftrmmYAiAJf3xqtSIL\noK5ubdWaNNjli08MtlSLLMI3toXWW2ML+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbWDx+FREhXT4OI9Cnn+9LcUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk1N2IwOTAtYTQxNy00YjIzLWI2YTUtODI5OTlhMmZmNzlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk2NTdkYzctNzc2Mi00ZjA2LWE5ZTctOTZjYTEzMmVm\nZTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJQRUD9N9TJ9N0aI9mJ0b+dIX\nA7MhXh0xK79zmWeIrVbkBj1IHtVRFaA6GaQVJ23nzbamaDXNWRCRuOCZKUVn06N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIhbqYNSEuJoJf/5XnXgIXbAeWVIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIF/ZVvqE\niE2FKT5bBAK1ggA5c87GMfdZB3VRrxlZx4d2AiEA2kpJOK1FXQS4NlO2wm6uyZBE\n2/+ZmO1AM1CtBu1cK8A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7218", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7218` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAeNfwEuTYUb7X17mcO1H4sCYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4OWY3YTU0LTk0OWItNDBhNi1iYzU5LTMzYjllOTNjNDM0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTUwNDUwMzUtNjAy\nMC00YzQ0LTk0N2YtZmRmNWU4MTViOTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES/Y3373n+ajCWuKARF8N6qxPwhVK21qH6kQPDCQ93OZnGuo/jveL2shF7doQ\n4S+KuOnAfcYpbRqZ2zqAxpDfCqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLaAKRfgHfgNbEudGe4k34OqVoQ6MB8GA1UdIwQY\nMBaAFN79J25IcjoHASGtuE7kQyn6NldFMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA2zxqo41tSjpQhiSk0S8Hxp3BMr4Wjm9aq\nhSDd/AeJPQIgKrlP5pcMCXvobVqLazxs4++fwFg3LKmj/Kg/4h94Z2o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS4xcFNQdu/ozSdNHe70b5CWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODlmN2E1NC05NDliLTQwYTYtYmM1OS0zM2I5ZTkzYzQzNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0n1PJDXqQgCybtTo3+sgXMFKem0hRyUe1v8JD1Cal80hA\nz4HhdRHxABxUTORJZTjvnAQMR9vMmsY7ec7OKm6to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3v0nbkhyOgcBIa24TuRDKfo2\nV0UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKMZlHplHGwlZoxSxnhE2/Ke+uxurtSDR8dgr8a644RoCIQClAVYTD04C\n+wzneCIbNcAH0I+F94zw/4HUyaWuQ63TUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISASWFc+sQhCiqPo/z2uebOFKwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTUwNDUwMzUtNjAyMC00YzQ0LTk0N2YtZmRmNWU4MTViOTE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQzYzRiZjYtYmE2MC00MTUyLTk1N2MtNmZjYTY4NmMx\nZDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFh2S3taotmvQfDaOg5/169xd\n2CZi5keMDzkbZ4gkS5XXG0+yiDzQjvXCNxz+5M7H03Uz8wMqRn+XaFXdpyIQHKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtoApF+Ad+A1sS50Z7iTfg6pWhDowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCSI9dk\n8WlxmnmtioLnSVxARAIBhe4iKvL8yjeKLyWfewIhALHDyDy+bXjuGvaEfNBfRlKA\nYI9S8V57kfd43KY4CW8c\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7219", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7219` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATy01wAVvZMNPQWUV6hEsHpTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3YmM0MTYyLTI0ODYtNGIwNS04Y2FmLTM2M2IzZDA5OGE0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZlNzNlYTItZjJj\nNy00OGM4LThjOWMtMDhmZjJjNmZlODQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE23cmwnukhsbGNRT8c4nxBcLZsHJeLMCnWX1B3meuU0jVtI24pekB8LsOU8xT\nfSXT0hwhppP+7pgxnqW5hmXLsKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSLm08KMDViKs+7x6/7PLjZR2jtUTAfBgNVHSME\nGDAWgBRnW5qd5cYFPgHLQzVRL8tMMFNGSDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCrwpHOS3W8spT3WNsm6lieSB0fxpJl\nVv50C8npkyeVQQIgbsTZ3yquiSupju2pbG/hsnzzzN2rs/gGd769TWO5r/Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbJCZio4m/M5Ys4rcED52IgyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2JjNDE2Mi0yNDg2LTRiMDUtOGNhZi0zNjNiM2QwOThhNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpFx9aFhTkr9o7zPxJbbjgiFk3YYJgHGc3Aj4N5vMX/+Fs\nRsjvV65NJq/1Y6iDST3i5TbCv3cKEINLoobugBQao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ1uaneXGBT4By0M1US/LTDBT\nRkgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfVlg69WWaDkLPkhEGxZMhiqmP9M09Vtr+ttd9DW14aQCIQD/gXiwT+m5\nfTMnQuGQXT0Bv4vQEWvd6VyyziAk7g2XTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYI7kI9QabvNZpwHdQ9NVLtjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZlNzNlYTItZjJjNy00OGM4LThjOWMtMDhmZjJjNmZlODQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDNjNjhlMWQtMGZhNy00YjM1LWIyNTctZTQ1MGE4OGEz\nNjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy91vzP92+Dw/BeqW8BzXGrnW\nsIM+kkBvvfcEjCLIaUhUiX4LwyE4R4n/UdlPpdUBQxOmQmqRgM55nbbvcffMJqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUi5tPCjA1YirPu8ev+zy42Udo7VEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDrXziU2\nQeJVFg30+bQ8SbAKWHNl5seeBXu37S3Tgf2GAiEAqvjrkG7TtpqY1+w2IhCEiI/I\nAvzJMcfXknWGEhfvUOw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7220", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7220` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAXGEFoyrqB7a7meY3Vhm9lx4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1NDRmOWU2LTJjOTYtNGExMS1hYjNjLTNlNTEyNTU5OGMwMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJlYzUxNzYtZmJl\nMy00MjNjLThmYWEtMWRmOWY0ZTMyY2Q5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2veVx/CGAU47EUUkLxrJib75Zjv/Gi7ZuSoMxB2CHqY9e4VpHrbBbnH40p/0\nEgVRceQl40wr3O5/e4L7qtsFIaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAhjd8tqlMkQfz9i6zyLvkNSMyAwwHwYDVR0j\nBBgwFoAUeAfB/WlsrurRd+vnMUgtt5/MezwwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAtZcNUPD2VGCZ2\nvMsjIRuCCTUWajnLuszdulUJ/vQDQwIhAOkdHSRJYvSl5YI+BKD2COqyiGBh/ugV\nA+4YlyJ2VM7g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV60nwNS54mE0NdRzo8IUtS9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTQ0ZjllNi0yYzk2LTRhMTEtYWIzYy0zZTUxMjU1OThjMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvfaZCP0C4b6fhSlYKUoxAvEcNz6EUttFKyKCxIyyGAwRj\np1B3a9u0Lm1W5zlUo952H3wIRTBZe2Ogj4Ia7Gzxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeAfB/WlsrurRd+vnMUgtt5/M\nezwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVFv550pOEki9azJJoKS9z5X6if8jAIfpzHL1l7eh1QgCIDcQV4g2Qrc1\ntKFkj0fVIV7GiPzJwO+YU5FBHMbRCvU7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAa2aFMuKka4kfesyxxhBbzIMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJlYzUxNzYtZmJlMy00MjNjLThmYWEtMWRmOWY0ZTMyY2Q5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTUyMmY0ZWUtZGFhMy00NDhkLWJiMmMtY2IxYjEzODcx\nZGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGe3oimY9pezUvU6YAdN2NFUF\nz5hRJKAnlXm0OfJdWJOcHx13WMCMT5lrJ/vShBXIAZF1Rw8rWeM3atrsn8By+KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAhjd8tqlMkQfz9i6zyLvkNSMyAwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGyWb39k\nTjbomPYRXdJ2x6kBoVCZMa0ShH4jneIjNy5DAiEAlw9aFYFgwBcgy1fIzl2osuqU\nO1sJUAGzgGI7mTQrEOs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7221", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7221` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISASIBMRDflCur7fVzwUqZJAuPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1ZGFmYzAxLWMwYTYtNDcxYS1iNjkyLTZmMjFlMDFkNDBhOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhhNDI0NDMtOWRh\nOS00MWQ4LWE1N2MtNTk4NmRkNDAwMDc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6NM1MFGQBlXgaWsI7x7Ace7yITRJZVdvzOZl4EQd3OLHW6NVfFOK/ICVMhYi\nqoZcFwvuMYXiRKgL99g8rva/VKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6jHsfUPqyOGD0risuIS9EX6yq2owHwYDVR0j\nBBgwFoAUC42Uv3HoaQM70P+XHYYiYpDKvWowJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAWl/OG7jIfC3nW\nixEg/hJum7uEQ5i7uAYPPwP+ICg9ygIgbd/V93FWjMXG0LPlsmofee5s5+AW1Bfz\n/W7ibT3OcbE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX63OB8n3U/FJ9MwUkelvYZaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNWRhZmMwMS1jMGE2LTQ3MWEtYjY5Mi02ZjIxZTAxZDQwYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQo9UAYw4UWjk05DgLZoab1QWOtTWW7/cevnFc4Zuet8QKm\nCAsjhnpWEJNaQMYMro6Xn2wqvtXT9+hZPdUpslOUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC42Uv3HoaQM70P+XHYYiYpDK\nvWowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI7aq+ZlOLPnvvd0OUqOCrK/SdsngMYJLvfzolkC+bEKAiEA9/qbkIdx\ncShGvjPL66+H2ZnWjU/1SUYb9O9GmrZbqpM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUGPoVb8iOw3k7Sax3zUvv7qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhhNDI0NDMtOWRhOS00MWQ4LWE1N2MtNTk4NmRkNDAwMDc2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjJjNGZlYjktZmM2NC00OGIzLWIxYTUtMzcxMTJmNmNm\nMDIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEc0S+uEpAFqboEAk2eiA46OLK\nw2sM19gS/UhSQqk9lkop2uO6K9BMWgO7ecVNGr+zGiHmFYINjmsL5GjUSCtucKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6jHsfUPqyOGD0risuIS9EX6yq2owIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQD01Ujw\n2UQXPRTGOTLGi0p2De2fo2TUQ88YObeiYD+RhAIhANLRj1WXAtVipHtT5Wty2s3C\nXhQoQgKCvJf22hKTaj+o\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7222", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7222` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAW5jAk9QOoxBOarlbi7kJLqhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMTcyZjdlLTA4ZmMtNGEwNi1iNzM1LWFlMDcyMTYyMWQ1ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQ1YjdjY2UtMTUw\nMS00NjczLTk0OWYtYmY5MWI2NTRkYzNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXLdAcAa0Djq5Nexz8WinrRnnYwSxvCWU/5FhkNwaxOOhRbdJ2Z82hlQE/tZ8\n0SW/NwM/4USenfXV7hSW2OHvdKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbsMNcZBnXNc4AG/37JQnlBbNxdAwHwYDVR0j\nBBgwFoAUr1ZHWmGbxEiO1C6RaW1XeH/L0D4wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA6nK6gsG3IMno+kHGl9kJ\nAL/5PJMpiyAo/kGd8DTZwQUCIQC/IjCIhaH8si9DExPnMWtO52zZrTuZn2+N8Evn\nreMLrQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS6m+0HVWBJpLSOr17kD3Di6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzE3MmY3ZS0wOGZjLTRhMDYtYjczNS1hZTA3MjE2MjFkNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ07U7iWak/Sp7Di7vemMWVqlOGUnUCK1sZA47Vbfz0PTDr\naG244gLzgLjrerIWtUgvwMtxOko/y6A1tKphcO9Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr1ZHWmGbxEiO1C6RaW1XeH/L\n0D4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYgRzKx76YB+NlIlZevZYvtgvg6SW3UIay4fk5ISe1VICIQDRLQ12jf3D\nj+z41N8vh4wMpwOCt3PosRcs2j1oCvWiew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASDMOR0pY9htqfFbV8/IfktTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQ1YjdjY2UtMTUwMS00NjczLTk0OWYtYmY5MWI2NTRkYzNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzdlNzhmNmEtMjJiZC00YjFmLTk0NTQtOThhZTBkMTRj\nYWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5qMtt5/LEQggFfZ82w6VcbZI\nv0kO+CHsPNFgk/4Z4BBsCEftfAhNsFe7NL6XQyWSHzOmJJdE8+gLIqa37HxEpaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUbsMNcZBnXNc4AG/37JQnlBbNxdAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFglfOHo\nRVlNgzAHIV+MHsJKw089xSgXaLKGYMqPSRB7AiEAlVH8UFb8TOSAS74v33dEC0mI\nf2tZZH79h//5pGAeMso=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7223", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7223` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAcw4Pqygo0zGHwq3IMivNx28MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNGQ3NjIxLTI1MTMtNDAwMy1iYmQ5LTg2MGZkNGI1ZTY5YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDVjMGFiM2EtM2E3\nZS00MWQyLWE2N2UtY2FiNTFhNmU1OTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVGRFADx6LAjwwxzeB9J9G3TZ9EGXI9sONIaB1ZLn3XLiyHpuFWcocCjKFvZK\nhAg7R2CRr27eGjlEImC621hnG6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURkJyUrrwB4uzghVZ2G9KIS3Hqb0wHwYDVR0j\nBBgwFoAUQ+GZI/3X6Te6HxzG3xaFMjwTHgYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiB1xN9E\nyhtfMfRxjhWFwJUzlQvtLxNVfDrS1yaysm4M0gIgI7PkwD73kY98bpWp2UvLvo64\nMyQ13MGPr1SAa2hH584=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUbEMfW1ESYr7lXd40+lzSwEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzRkNzYyMS0yNTEzLTQwMDMtYmJkOS04NjBmZDRiNWU2OWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoWrWsVuSJdM0JhRP5KLIvZMhxJYPYftO7pi/3CIOcUa8O\niBTkBKA+Myn3GYwYvIi2pcIW+4+MZOvAp6zO+sfJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ+GZI/3X6Te6HxzG3xaFMjwT\nHgYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALr6ET5NiFfpEk8c0x/zUekwbh8fywcNEhksGaQbuXEbAiEA8qk+/vgi\nnv3RJJGw+jMX4H5urvVbSsyBnwUPPyDd7yc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAYpx3V+anvfbhQ6NrLBtpDhNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDVjMGFiM2EtM2E3ZS00MWQyLWE2N2UtY2FiNTFhNmU1OTI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjVmNWNhMjMtZTRiYy00NmNlLThhZjUtM2FlZjVlZWU5\nZjM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0Vjq9HwtOJ6D1Q/1K0VEApk1\nUgu9JAxkDHyU5UDLiFpZ8Bf6sIxcX6cPjmBa/WCRMX+zaxTSa7+x0zmQaVMZnKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURkJyUrrwB4uzghVZ2G9KIS3Hqb0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCID4CokXp\nvT6gyHaCxS6rkICk+2NVFzg5WyquvXJcBmCOAiAr9JJJoNr1/Bvg3ao2U9mvhD/B\n/FTA+13+UBqUS6XWRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7224", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7224` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAZYDLCtVi9L5qOgWrdbnooGLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyYjk3MTYxLTZiOTgtNGEyNC05M2ViLTEwYmVmMzYyMmVmODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWEyMGQ4NmQtZDk2\nMi00ZmIzLWFkYmUtODRjZDQ3MGVlZTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHT7hGvXlDfh16yb73qZ8rd/cOVVEXw3N9bJD7/Z69+nRFI/56Sf4qQHsTbLl\nUvGAQTWMXOB7Qy9rgDHsnSVqZKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcJFSmHW/7otfQshGNllReVLYy3kwHwYDVR0j\nBBgwFoAUylAFee8tSjr9jcagZ5ZRo5dTThgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA7KbM\nzCjS0g2rd8Q8qJxJN8J8K8uxsPWDFISLDonWa0sCIB7l6cKNVnyjYx73Q0NbU9DO\nQGps1F0eMqzDSYEv6oM4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd9ywCJ14Qhl378z7g8bO8GJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmI5NzE2MS02Yjk4LTRhMjQtOTNlYi0xMGJlZjM2MjJlZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhI6He5yU5BbiBsYfaAYafs7zhbeHngyDC//atqS3sJZCw\noCiPovK6t/Qg5qTlyRk3SLSVtV5EFxtjr27SsFg2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylAFee8tSjr9jcagZ5ZRo5dT\nThgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANrrQHGMCqHz0NMMU79H9P4T8V0nv7KVDEGUbBhGsBBgAiEA4Y/XukmY\nfI6opS6g5r1BhLQRIhhK46r3Phb6M1bRDRo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZTi4za6xBNxPcqvcDyX9UebMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWEyMGQ4NmQtZDk2Mi00ZmIzLWFkYmUtODRjZDQ3MGVlZTRlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzUxZGY1ZmYtZDRjMy00ZTM0LWE5YzctZTE1YTY1Njdj\nODQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcWvh1vIPdkLZkCzYMWEy/0L9\n3mBmCiaFXzsc7LjriYenJRwcgj/YqViF+QwYudZHyK5vf9w79fS+Dpy3LmTasqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUcJFSmHW/7otfQshGNllReVLYy3kwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDObWoXv\nhZ464SWewrg0tlQLsCNkbr3Tdy+UxX1xN9vgAiEA+wQVUSBkSHmz5ZNnFzDAlHvj\nqXKrKpG6uRSPAZasRE4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7225", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7225` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAYElyroRe7zyoIgtWecuLS8uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjZGI0NmQ5LTkzOGMtNGExOS05YjM3LWY3ODNlMGUwYzE0MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVkNTQyYTAtYThl\nNC00MWIzLWFkNWItODI3YWMxOTg2M2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUUXKoH4TdORlYvcZu00kgP4+HNKUOTTsol+bbWCn4d7Kp5tVT3ebfwW0j5TY\nn45CIIvBens6k4j7EW6ymYefQaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFK64FKF2i2aDnOETg3iFXGlqKK88MB8GA1UdIwQY\nMBaAFKjGjIY8Bek4r044qR4kzsS9aokRMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA2j85N4vhUMkT18Csk7S+Hl63aMfXcrqc\nc8nm5EuNOZ8CIQCLIMkeU+nM8znopZYmOuMTXAMe9WYj13B/x9+znMF8Kw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ2I2YwpTQoyiAGHA0VADbzeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2RiNDZkOS05MzhjLTRhMTktOWIzNy1mNzgzZTBlMGMxNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGlliUJMDh9LGGlh4l0534e6LIKmGgPNj33gAvlWfIfrWt\nBIG7BZ3c4WEUZ59DC2yHhg3c1S2RgqMJ/WCG8q8vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqMaMhjwF6TivTjipHiTOxL1q\niREwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJbA0Y0WWmhpuCmzBEbBd4vYWyiN8NnCzu3qh32Q2i6cCICgLw6SISMks\nX4RuTQ9AQ014UFo+Sa4LyvapRdxsah/9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAdEqb4ZEnhkxqwY6T0Bdxo7mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVkNTQyYTAtYThlNC00MWIzLWFkNWItODI3YWMxOTg2M2FkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjlhNTUwNjYtYzRiNy00MjI5LTg3YTctZWIyMGMwYmUy\nNmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoIYL7Qwx+HDtww/dJWxnaUvY\nb51M8XXHjijkeVg1d4EpC8XlrXF6P+Hv5wf+kVpA9hO6LfZ+kRk9YGneRy4DaKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrrgUoXaLZoOc4RODeIVcaWoorzwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDVXxoj\nKika/dyCw0tw410ide+dKXWxyXnu/HouGsY9uQIhAJ2rVlUogfc9aYvHpx2Cbinh\nw7D9hE72JELg+89aH3yP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7226", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7226` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISARbRN66AwsE8tVrwdXYs3wwQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkMzE5Y2JmLTMyMmUtNGQyZi05NjMxLWYwMjMyNDNmMThiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA5YWM0OGEtZjNi\nYi00NTg0LThhYjctMDI2MGRmNjI4M2U2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwBCeggOr+KLas1NSPFF6C9oY3aml/CV5p1P8mLqJwuC2YHlRgdUsegRoC1XQ\nbylSwINkJjHILT/fnupu1WqraaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS7125tJxyJ1pqSWN+YLCiV8M8aMwHwYDVR0j\nBBgwFoAUnWD/Hb73bW/aAmvYaYTnHDW4I/AwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgXAVA0clehtxj\nIKJNqx+1FlOufaBrkKQs3iqpPhu9hTUCIANPwlnN71YdzxuBAK+rGn8xTuwtFZx6\n7ChtrJCektRG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATu9oEDByWv29Ux3qvzFpfweMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDMxOWNiZi0zMjJlLTRkMmYtOTYzMS1mMDIzMjQzZjE4YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARb7H2FLhWh3TjP8YXAyofrxRfrbT/1nTjX2xa7W4kG7KQ5\n2b4Lir4iltvUliE+yElkzd9jMvKRlt6pbF3WIbQEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnWD/Hb73bW/aAmvYaYTnHDW4\nI/AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANo2PYkCL95C8Jjb2pf2KJCO4GiTq5B26KoVqBj/tc+eAiA24jqh0X3d\nI2vAs2LAlbGu/nEaAel0Y0DbVDJcztgG+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAR9wAoxiBhylldiE+tz15SttMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA5YWM0OGEtZjNiYi00NTg0LThhYjctMDI2MGRmNjI4M2U2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWZjMTdkN2YtNDFhMS00ODg0LTg3OWUtN2IwYTIzYWQ0\nMGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6zAp0BpGP6gpnxupq76TOeku\nyiy1j2GhIb4s0bhM7TPY18wXXF6oBnDTDQGIHHREXOx33GzN+6WbjBdGSL2j6KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUS7125tJxyJ1pqSWN+YLCiV8M8aMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIA2iMYaV\nOd8kt1TKl5eWU8iAgYpx9GmEmdmK8AIonV2RAiBIwPerzL0NbJ/qXuinL5AKK4+X\nOhDr6VhdK8S3vfuxng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7227", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7227` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAYEpfJTFqX+mHU+K6vMhjQHLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhYjFkMTU1LWM5ZmQtNGRiMS04NDc5LTczYjYzNzM3M2NhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNjODBlYmUtYTkx\nMy00ZTA4LTk0NmYtZDQxODBlODI2M2QzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5/uEcPEE9Tjr0/5fTZIt0gbmTXLs3rEP99FRZMa3cpuV2sd4umzqYGBVsYOb\nXoeMmGBMbw13wwBcsovcbXk4KqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULBWArcXQ+OzU5pJcXjqvcmTlrkcwHwYDVR0j\nBBgwFoAUZMB2QcZHOsHD1jGjXySUpu23SE8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOHtSSZY1svG\nXiDFssOumS49wJMwJ90pAOeNBzgcckbbAiBevT8gfnyI4mQ+UrmtqzWr3sOmlQ1O\n5SDqXwqoDHuRwA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUTaPqrdz2hzTaXHxBigboYpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWIxZDE1NS1jOWZkLTRkYjEtODQ3OS03M2I2MzczNzNjYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3if7/4cylxYYv1VJSIi42CiSwnOjAd1Zi9arC8YrYZEq1\nkDcwM7jOPi6t+vO9jV4Qk/J7K8Nu+GuEUrD5AbL9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZMB2QcZHOsHD1jGjXySUpu23\nSE8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKQJRjVMFJGHDEXrgSHgpm+giEIfz61gBFwtw6e9sB5SAiEAnZm7Ubdi\ndWnoxmAYQdWCDEs3NEEqJLbD0HH6Kw3nHHU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWPS7eYddcroH/Yljo19dFQBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNjODBlYmUtYTkxMy00ZTA4LTk0NmYtZDQxODBlODI2M2QzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODdhYTBjMGEtZDkxZi00ZjVmLWFmYmItZjkwOGUxMGNm\nMzBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYDPbcKOF0C6Uh+xPJihDJ3RJ\n5a0wVvFJ1DQCPijPpFYDzhKvhYItl8iPcdARFYtD0i0W3btE9tJrHlTc8FL9v6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAULBWArcXQ+OzU5pJcXjqvcmTlrkcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIDcpNWmt\nthfPdS5+kfASkM9w7oTBeLd68VHDWPjdJkC8AiAzcFxwtqb4UatZGA26kbnz2wJK\nBWlSdyInyJqjbqUXyg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7228", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7228` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbqDau81musBdlwRSWVo9cDIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzNGY3ZDUwLTlkMTgtNGQ0Yy1hODQ0LWMwZjA5Y2FlZTdkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRmNGI0NTgtNDY1\nZS00MmZlLTkyYzItNmVjYjkxYzljYjc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERJxWOlxhUrc9rt+zz+V/dC++e0SnaQdB7JlQK+7kqkC+hy27Uq9ZDtWKFldL\n6LTEyR2W0balVYwweCTh1IH9JqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDBVW2/6pDDoxznnRZGqbV7z4kHkwHwYDVR0j\nBBgwFoAU9iAQoi9knMizKFB2J3ECFicsJ+wwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCAKN+jA2Uh\nCa9yfIXvIKD7diLK0AqEpEX3ejWXW4KfAgIgeNBfNDSS72tAU7qS5jmLUeqlxDFV\ncsrxwUcu5B0CJp8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZdgLLUGm7dv5hapQWJYs1D8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzRmN2Q1MC05ZDE4LTRkNGMtYTg0NC1jMGYwOWNhZWU3ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQtmNLR2M1F5CSc/6WoselVoNfOhz8XCnbzy8kT/rG8SB6\n+TUNlPRH6+dJN+Wa85rgT2pJtWwg9rx6V4W1/ABco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9iAQoi9knMizKFB2J3ECFics\nJ+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdgXAuR/QwSaiCJxyMZ81o12EXP357YJLJ9s5dCkwvPUCICKKL7/w3Lbc\nrhfWycGtihieYRMmuHcHMKsAPblCY/+k\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAaSU7uHuvv6tmdpzuenNGKdxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRmNGI0NTgtNDY1ZS00MmZlLTkyYzItNmVjYjkxYzljYjc0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2NmMmM1MTYtNDI2NS00MmYxLWJhMjctYTY5YWI5Zjk2\nZjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECcEIgPYnvVOd1UZfhoIBq0Xv\ni0sBP1GfT0tZkf/zrag8YImuOBOuIgZM0afP6gHN001MuCLdhDAJSgVRqftIP6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDBVW2/6pDDoxznnRZGqbV7z4kHkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCa0Jdu\nbci4oV+XTP8ECTnax7TN/6tmm8/dE/vnxfzmBAIhALXzPwk8c7HGJZurLv1Yt9Z0\noM7i5TiwyAoKPWkOc8ol\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7229", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7229` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAb5d9uoyN60hAuOf6cFeEqeEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMjk1YmI5LTExNGMtNGRkNS1iNWMyLTQwNjA1ZWY2YmJmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ5MzcyOWMtODEz\nOC00YWY3LWFlYjctMTkxODhjMWJmZTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0SAoa9UELB0nBptKeJqIC4171R0Suj0193iw1pcjAY0GqfK9eHGaTBCwI37n\n+T5f2FPfcN2N/G6wgUzbF2j1J6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUga8R1j4nnFrVIF/sSk/8euYmNvEwHwYDVR0j\nBBgwFoAUxoolliUjOQCaD3pUg/4LikRIQy4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC5kQoLZhQqjwY7f7GMT1d/ChFfCcVGRROXu0GtU544WwIge7WpFpBCQrnK\nkWDdK9Mjxz1PDnAwYcvd6sxvax6kqMI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVzK8MiKMs1PvK/vyGda1B9EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjI5NWJiOS0xMTRjLTRkZDUtYjVjMi00MDYwNWVmNmJiZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARblx7g8t+ZGsYAgDyJkYzN7w4fbG45Iez0Uyu3vVwcsThE\n3bBBfNrfC4pPWp0sIQnfGo7YhaoLcJGVl/XDjdvEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxoolliUjOQCaD3pUg/4LikRI\nQy4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOY1INLzhCCOPAOi7kuy11sJ1x5drZLqfIy4wuU1IVwyAiEAoTrkNapx\nkmTClqFyqSPQO9Mc7pagOj7eFcW6EHLlGAU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQQyCBvXNb3xDLvor40lLvAxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ5MzcyOWMtODEzOC00YWY3LWFlYjctMTkxODhjMWJmZTkwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTlkN2RiMDAtODRiOC00MDYxLWIwNDEtZmUzZWNjMWQ0\nMTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAhbdJtJXf2nuZyScNszG21+A\nkIQ22cfXWJ8J/MBGq4QK8V4p8cPmIoYo5OBsnZE6ZR1FNt+dTjP1UP00LFgzEaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUga8R1j4nnFrVIF/sSk/8euYmNvEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHq0UcwC\nFobdCjN5+bBtYS20PpqUh4GIboEGV103DHq2AiEAmGrmPTVppkT2sr7jnJf4PJuW\nJB/a4VIYqFNjUJle0uQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7230", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7230` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAf+hFfeOA7OhemY/oRYTkJesMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyZTFjNDRlLWM3ZTUtNDYyYy1hMzJkLTI4M2JmZDkzOWFkMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QyMTQ3YmMtOTdk\nNy00NjQ2LWJhZjEtYjBjYjUwYjI4MTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO9YApROCUe1wX+zRjjSZXAVEl0ka3aZX+IHkOahHR6u/6Soh0GSN0dBHnZu7\nDcBOHtO4x3pgx48utPqLjaphRKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/2YZird54ijrhOuVt3SGUnyVhcwHwYDVR0j\nBBgwFoAUHznDxr9S9vnl09U8tHgSC3muAGAwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICJe/N+Kffwx8MAmEmX1G3beFFiEv4f/29UrySfQg0gqAiEAipfoftbWmGB+\nADBcPT8hw944WT2LqTvVKMOqd+C6rHQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5MtxBMILyInj4fnO3C9mRtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmUxYzQ0ZS1jN2U1LTQ2MmMtYTMyZC0yODNiZmQ5MzlhZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnG/DJNbB557j9z0ORgsddCgt2bRq3TSA5m/NnB02x3R9q\nqDbhYmO/UQT5maYxNE/WPcFRcPoRrczpH20xlQtHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHznDxr9S9vnl09U8tHgSC3mu\nAGAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFq4FweZeRcMlxy001s1irCJV0UMNAYGU2KEhJXWtnDgCIQCEo7JW1xag\nW+/97pesXmXrdb48vgO5CH+mPjhJNj0YAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAcAL3gzhbpCILVwEp/zKmWWVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QyMTQ3YmMtOTdkNy00NjQ2LWJhZjEtYjBjYjUwYjI4MTZjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzM5Yzc4MWUtM2I0NC00NGYxLTkyNGQtZjVmYTk2YWU5\nMGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/nhv+F4aq0cywbFHoEwpsWRe\naYlYrhnGBLF8nPdJ+TIWavY+W0K1BR4JUu2hOSLY/QJNor8ZcyUkGwj075/X5KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5/2YZird54ijrhOuVt3SGUnyVhcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHHj+HvW\nZH8G/Vd8PKmsh7b4mvkH+zm0n4J60nlepNNsAiAuTYABZF4H2bkBFVwlzjhIiezZ\nl2/377bETPUDGwV3HQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7231", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7231` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISASjy3hYmn8WVSiUM+8cy0eACMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5OTIxZTMxLWU4MzItNDA0Yy04MDgyLTZkN2E1NTQ1ZTZjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE5NDcxNTItYjQ2\nOS00NGQ3LWEzOWQtYWJmNmQzODdjZmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmBEfOreMW7jl/2T65G1KPSswbljzMlCtsOECNDVEpVBbCpQEykx9DMpJNMwi\nvP/OFzjz3cFHwsao5+l+6UOYb6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC6nsG0O8vvxSonnYMzWx0HEdjHwwHwYDVR0j\nBBgwFoAUwvUlLXbdA3fvkgk7Q75moJwb3tcwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDq9\n8T2wA7X7Wnmp7/3v8O3pc/JvgVUmQJt+UoZmlFfLAiEAnCgZ+0t150ZT6lR7F7lY\nNfUxf74ooWHxm43cXE582FM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYEEszmKAdUx8y2lFFFU04gsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTkyMWUzMS1lODMyLTQwNGMtODA4Mi02ZDdhNTU0NWU2YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKfBKh48R29n50KHct8rN1gKGRIQksaPeHlhLC3XZEn2VT\n3xGIfo16BOv0ob9th4yx8XkAq5PLpui0mkd4VhOBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwvUlLXbdA3fvkgk7Q75moJwb\n3tcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIBIZxMfpQbJxGen1PMNmtbtiGTi25dL4vi7Izb6JKjWAiAmoqFPaoh7\nBwwaqgknYZTOW54Rm6PI2x82QJYmNVmurg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdPlk3O0XPyVabFB94ToI+tBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE5NDcxNTItYjQ2OS00NGQ3LWEzOWQtYWJmNmQzODdjZmJjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDI2ZjAzNmQtNzljZC00YWYzLWI0MjEtMmM0Njc5N2Qy\nNWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMoP9ny9sAOFDEZ7dkfWzWNVS\n4ceVLmmfsPfD9FiLzfX/6Lq9pPVKTm5i2qbjgJwIORN6iO6WTnO0O2Za5BvNLKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC6nsG0O8vvxSonnYMzWx0HEdjHwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCDKSbn\nQ/e89FnKFRsXH/m+P1FfsPRJWCeiVmLo6Cr0EwIgV/VJOHC9z4o0ufp9L+e3HhK+\ngSrhFt0wrgr+boiWebI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7232", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7232` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAaGosugqxS5JfBvq4QdL2mSSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyODNmYjY2LTc5MWEtNGZjYy04NWZkLTgxYWYxOWNiYjAwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc0MThhNDQtNzJm\nNC00M2MzLWE5MmUtMTM0N2NjZTYwZDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjK6siNB/P3E3YqownTbcLap90ySr3CTuEzZHskaylLvmLcRmum2bFg9/dmKy\n9kZCxARmLPUa/Cxg8JIrkG3QCKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe1dN1MCWu4A2gKLkKjLnWZTIt8wwHwYDVR0j\nBBgwFoAU/cyB3OnC8L3nzzahdzcVYk3dr30wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBe+iQpXCFgi/3JJLc+4EVquRtrg85pF/yFZSvHrNqvzAiEAjZ6u\n30A0X6ab2BV2kME+qHaA9tGgqiYQ/sQ3f/+13yY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYFaPKL70kTxC2+jKB0KUwBpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjgzZmI2Ni03OTFhLTRmY2MtODVmZC04MWFmMTljYmIwMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyCo1K2T8uPT1OTmBjKU9JN6uM3qoK/y0H1cG41md+GLQn\nI98DREylR/6etYRccCraanzKZkYSvlwY/y22G6fGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/cyB3OnC8L3nzzahdzcVYk3d\nr30wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOfl6aBeO4MFPqq8dezvY0zvdvw03vuuxR+b1t/3ydMZAiBvxygeRaDX\n6IiPbXIcOqn42cCMGlvhE9tIeTDoUWwsLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAb1XVD60PlP5ITiRJzYpmpMKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc0MThhNDQtNzJmNC00M2MzLWE5MmUtMTM0N2NjZTYwZDNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTdhOTA5ZTEtZjgzMy00NDBlLTk2NDktMmJiNzljZjM2\nNmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETnh6QcVjGnRbsIWHLje2zj3+\niG615M4qb+AUP567Fjy0kK/9rs21mpsnpwc5zYJouxn+fNVYLzIDiJASiGVVhqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUe1dN1MCWu4A2gKLkKjLnWZTIt8wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCuAijG\nfbAgXhpguqZi0RhV8gbaY8f3C98RWCZ3pJw/9QIgFnrNsg5hJmWMAXPX6PoO0ApJ\nuPNnCf7XESYVYgQy0K0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7233", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7233` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISASF7qxTnGavH61nIUCUFaqzcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwZjJkNzAwLTUzZTQtNDg4ZS1hZTk4LTM4ODgyNWRmNGE0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM1MzZkZmItNjQ3\nNy00ZTUxLWJiOGYtMTA4ZDczMjNkMTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvNQZtgkDTYu563Oc8RlmmjkBl4q2UYpV3lVXMN6oLRKbGq26Z5SDlfIUFobB\nG+qZiAeCoBwl5MHTVqQuEWbaKKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgtGXDijrAsErScFlMacC6BWauSYwHwYDVR0j\nBBgwFoAUpqBSdIcswvQxgR+WlI4qFSZ6nHQwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIB+R3dOeqzAgDE0jhl6czo9Msu3rPu7D2V2UIqvujCyKAiEAxZI4\niDXi0FcSfw3F3vujiGpS6ffGZWKn0YWlMshozcc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWlaupES8pvmuji1nxiSQcPzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMGYyZDcwMC01M2U0LTQ4OGUtYWU5OC0zODg4MjVkZjRhNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwfRcsBG8k5v+sOA11UtuM7V4RO6qwcFlY4ynEL0JzTnYc\njMgjsvp8NwceoSyqER2D3nQDjxVjajKrKAKX+eALo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpqBSdIcswvQxgR+WlI4qFSZ6\nnHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANuGj+Lc3DaD77/w66ju+MCPN8AogmZjCX/wIacgnc9DAiB4ZJu/y/wA\nephnhrvFm6apXc3SndygfHWaWnGo9Jccjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAc96PkOm/VKUHpXkX8YvxqR5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM1MzZkZmItNjQ3Ny00ZTUxLWJiOGYtMTA4ZDczMjNkMTNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmIwMTZkMzMtZTBkYS00OGE0LTk3ZmEtNDRlYjBkODY1\nNmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsOYgbCZRDbtHpg0ljYpkwKCz\nPVdL/oYGvjKKvfb4G8MSD+zJ6X7BCbJg4Y3W6DMUUDYqAmrDQTGb2F+QLiKxeaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgtGXDijrAsErScFlMacC6BWauSYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDRKO9W\n2vlhkEKJNPQkXg0HhjMPMSrLbXUG2cMbBhuOOQIgK32Y55fpaidZO69zlO6memb8\n4rTQ5Yl6vUrDB29mA5U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7234", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7234` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVi8JjcVkoHM3BPW+rfXzbGBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmMjNhNDA0LWViNGMtNGVkYi1iNzVmLTAzZjM1ZGNlYTY0YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE0MWFiNWQtNTM3\nZC00MTYyLTlmMTItNzBmMDUwNzk2NmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9uy5kiVTZMxuP1LJ7rCzl2zj0zTDfQzJduewgdsqmBCKWbsMcaPLfIXXKgOJ\nm0sQLZ1nkrZ/+1MWLlAFm7mD/6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPoSbSaoEQtonAsRBHYb4BTDFegiMB8GA1UdIwQY\nMBaAFKHQK+6blLK5BHbZ97QdZZY16iT9MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAwuP+d6aW6N6xwRk/lkkA12YpME1iNZf2\njsoOuoOvSbwCIFmvXykf5VNzBKNFkOFsopDYRjDpshFacp2K1CJYNlBd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX2vUSeqXdSk2x3wrdvJbe4OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjIzYTQwNC1lYjRjLTRlZGItYjc1Zi0wM2YzNWRjZWE2NGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOqhmn2J6NjHDAMREUuefM3z6r0svwNZk/AoGbCPXU5hr+\nf0HmD+KhaFwGCDt4H+UGpp2HF2Hy3ZpApldoYxt+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUodAr7puUsrkEdtn3tB1lljXq\nJP0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANzsPtc5NmjgZB7S6CzzKELDw67We7cBXY90/XVS8quAAiAKi5uWZ3YQ\ngR2L1Ae/arKAjwhcXwmMuniTs48FPp/30Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISARfNoVGWwMdpNJJIm1K1avUmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE0MWFiNWQtNTM3ZC00MTYyLTlmMTItNzBmMDUwNzk2NmZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWI5NGUwNzAtZTAyMS00NjFhLThiMGUtOTNhZDM0MDVi\nN2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBj5beqpisUo6V7RqrSXlawEf\nmiA+xPzL5M9d6S5lhincaywmjZFxh6K31jkvYivky0xn4TMMM72SSkg2OwWzeqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+hJtJqgRC2icCxEEdhvgFMMV6CIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCICatu5I2\nXiz3LhtZUQu8kmGB0JuNF0D67tqaNZLzKdowAiB7NsmGHJ8EIHWsF7eGyWOqxIsV\nzePAPjpfL8E2q/R4iw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7235", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7235` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATt94gYdvE4jK2NkONJJvLS3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0M2YwYzBhLWRmNzUtNDUzOC1hNjI5LTg1YjEzNTYyZmZhMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2QyOGE4MmUtYTg5\nNi00ZGU5LWFmZWItNGEzMWI2ZjRjOGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE48NFXfm9CxHLl2LEnc6fe/fZw4ri4vGiQqBHNRtgWSC8Lf10Qp5Qmavl9Eer\nzZ18jQypFO6tiTWHXBjETFwZk6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp7sHrs2JLIM3KGE5ONXXij9TK0UwHwYDVR0j\nBBgwFoAU3OuOQr2FOEbcX38AadXgGkUDazMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAO7/lIpbG2YA\nj1eKFu9CpRJR409yFqwwinuHwLBSHD+yAiBfn5CS/jN0oexxjRDrmJrErcdcnQ+Q\n5+EkK37NolBzBA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUYcHXIVyA3/Mn/bKXJU2REJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDNmMGMwYS1kZjc1LTQ1MzgtYTYyOS04NWIxMzU2MmZmYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvi7GfPIlhHqsKoprnas2O7eZ5XiUew6exlm7CjeNmPZWg\nOJwt/V+dkhDf4LLxNcQ6S581ufRsNa8yvyj8Oq3Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3OuOQr2FOEbcX38AadXgGkUD\nazMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKfCe9LVUXK8I+EpZalZq7VTi4B96GpxNKn00zWgKvUfAiBqPffE4e08\neVLoYptVPYvvZm1/n1GgndnruDGU21bNqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAcBoaOuAcU9AxaNdeYjvyuCEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2QyOGE4MmUtYTg5Ni00ZGU5LWFmZWItNGEzMWI2ZjRjOGZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMThlMjkwNDUtODNmMy00NjFjLWJkODctZWI0ZmJjZDE4\nNzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnkZ0aY5hK3cSaaPTQmrAR63O\n6KTkXIQyWwWzcYsBsBUhpISSdJKyindQrIwh/L06ZCzIMyQo2TbHTFE46GflDqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUp7sHrs2JLIM3KGE5ONXXij9TK0UwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDQBV99\nGMRgtogI6VmdjJrdKKFKs2Nrnd5GXLEyv9dZOwIgXdsMRIeOGkcMfQ0o6L72+WV5\nuoqBGqM/+80eIXUWna4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7236", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7236` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWOOR/LgXJKfT5lF7fmHT/G3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkODg1NDgxLTcxMDctNDhkOS1iNWNmLTg4MTc3OGM1NDE0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM0YmI0ZTQtOTcw\nZC00ZGE3LWEzNDktNTY2M2I0ZWNmOWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJpDC+kuurSSWJ5SEjMFWBgkoFUTBLNcboyF9kxxCjxps2mAYbf0mzOUce4Ml\nO1jbTuP/jWXDEasRK1hdJKigRaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTjR7IUZsntIEw+8PhxigL5VMu/owHwYDVR0j\nBBgwFoAU5zziLzhF1Uidl9wBGIML20T/1pMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgLJpSk1JJHnkl\nUdC5FRD7ZRqmAU0XyBQTDllDI11H1p0CIQD2+8pkBlpV7oj4AXb4i01kCrUHzhzz\nhEhjWdShBOgbww==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWGN0avOLNJ8OubAJGu9euRMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDg4NTQ4MS03MTA3LTQ4ZDktYjVjZi04ODE3NzhjNTQxNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmvU4VpfTMlByBwU+yImUjfANVUav4YLiGKPRUWkFeD/CU\nQYa64Bii2dsqcpUw5HTsXYCwWqfG0GzcKIyQA3mgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5zziLzhF1Uidl9wBGIML20T/\n1pMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL/DoXHMEWzaML1LrZVwUSnKakyZZ+deBS6CNAknetNgAiALgo6a4WJH\nJq2AtAGgVXVrHACx/BtPWlXkvr+I0X6boQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbO6mtcZwpmPYuGqlmMFSr4ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM0YmI0ZTQtOTcwZC00ZGE3LWEzNDktNTY2M2I0ZWNmOWQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjVlYjMwMjgtNDI0Ny00MThiLTliYWMtMjY3Y2UzNmQ3\nNmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC15mRDvntQ8ywuOqCftwEetp\nLtvd98tDfa4iBlfvfqbRNW6G1ydsAs4/wQjLlNMJQ8j+70lkuZ7aPn3Ftub9a6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTjR7IUZsntIEw+8PhxigL5VMu/owIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCc55rI\nlysmWsebR3EeagfPGnB6UC8AouPn8VaCcIdN2AIgLqmnwooKaAE4HzoEyz1ZLuHn\nD98V6aLtV1qMTEv4bn8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7237", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7237` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAT52XqJNWulVzkiXPrDRw7SiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiODllOTZmLWU2MWYtNDcyYi05ODJjLTFiYWIxMzRjYmE1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBiOTAzNzUtMWNh\nMy00NDA0LWIyNWYtY2RiYjAxNjNmNjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyys0nzh67TkAmB09EuXT9Qvym0g7YG2KePZDgeNDumn0wRm3KDWKC86jL5Px\nHvtJHQ/P7BY3qrfsvbsB8vN6W6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHoYov1HzVfkETtL4vQp4fOKL6QAwHwYDVR0j\nBBgwFoAUba4O9hY0C/QJDMXaM2LCyIxsJ2wwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIH5q+UOEDGkV\n8H4XnCEie/xRuMf2SBjxGEb2JeLvj6m5AiEAz3VYwxHt9BAGxLgBez3QxtQZzWZY\nTq0cwZOCa7VxMl8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWpKKmCh8bJDnUDUGf9MxF10MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjg5ZTk2Zi1lNjFmLTQ3MmItOTgyYy0xYmFiMTM0Y2JhNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7CwSoNjiNC7a1atzetUxSD+mW9kSm/ZapmaeNxnm5Caqi\nMdMi+Z9zYuEVkYX7++QEl78VXQOreRee66SpJqolo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUba4O9hY0C/QJDMXaM2LCyIxs\nJ2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPP2x9j8W4/gCpHMQX+8F1IvJm7L0b82XC7Ew8vf7dmQAiAibQN5Pyx4\nOWS1WN12DL/xDhKWGuHljqA65K+eltlMDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAYJnI1/j7Sq4KEsFLwn4k3WDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBiOTAzNzUtMWNhMy00NDA0LWIyNWYtY2RiYjAxNjNmNjBiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDQ1NWJkM2MtZjI2MS00ZDU1LWFhYjYtMDAyNDM1MmI3\nOGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7MmaYT9fkLW8iXt61bYzC3dj\nqzzafYfCPW3lEHuBKFGMfLDtNjgKegC57e3/+tQVnZ8bZPCgprZfQAQGncbXk6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHoYov1HzVfkETtL4vQp4fOKL6QAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHVyKQZV\nUV7iRN1LWtOBc+7oua8XWa3c9UJ7kD5sXC0JAiBrJW+kK4AtEHO54ODLxO23Zb4m\naPYXjwnR5+o/3PSHeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7238", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7238` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZrkt7ezg/BLCnjeRHRPZ82PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjZjkzYzFhLTQ3NTctNDc2Yi04Zjg0LTA4ZjE5ZTY3MTA5YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQyZWI0MmMtZTYw\nNC00NzcxLTk5NGUtYTMzZmNhMTRiZTIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPpV1txgAuYQfl0sFPQfnmT7p2WOtJi9x7Gv7JGHvUze4qtMsxbwTmAG2qzZP\nt5NNpg1rct9FgVZ614uGlNoNTaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDY1bud/Eh1VEH5Z7TVkcwgmJFyUwHwYDVR0j\nBBgwFoAUuFJbhH3KkA+7d3eezBlhryoWsrkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDiuqKyTkVl295IpZlItLHAe3RJuNqNFwsIM+N8OBaZJgIgJutEWlez8iqj\niRoR254CchsEXg1fIioeY6JlirUzJX4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcRgd+EGdlDl4KzuhxuGJ9ygMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2Y5M2MxYS00NzU3LTQ3NmItOGY4NC0wOGYxOWU2NzEwOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZZoP0X4eyvMS1CcF5LAzZyLTjmK5x20HqMjzYR7cEelav\nQ4uwGOW9pc0DMpVXYhIyzKQQ8YG1txYXWUq9D6nYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuFJbhH3KkA+7d3eezBlhryoW\nsrkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPoT6nkw/pFuNQvmqqs/OdZIfdL4k2dsaf+KsbQG5qGfAiEAiFNeIIVa\n5yZiDmnVNHWFdbQFQLf+EQCzKVGTj8s7yyI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWy40QTwWhXk6JBKjTL/thp9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQyZWI0MmMtZTYwNC00NzcxLTk5NGUtYTMzZmNhMTRiZTIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDU5YzUwNmItNDgxMC00NjQ1LThjZjktMjgwMGE5ZTZm\nNzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoc150Qv1963v+5+DnrmlfRr7\ns1677Au1cWAlOStuZQ3KYBQBCWghpQQrGrMNaGO/pf55qONBm3HGxPgq2UmjFqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUDY1bud/Eh1VEH5Z7TVkcwgmJFyUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHsAuSQJ\nnyef70/+Gn0O8bBFtXDupFodIWWvtswAEdXTAiB0vOIfKwBE180oc2WmHmQudUva\nFvI17/GJJzrG1KBBIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7239", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7239` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXwo8/C/TmZ8kFiJxR53q/fZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiZDRlMWI4LTg5ZjEtNGE3Zi05ODdiLWIwM2YwMTYwZjdmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzdiNjQ1MzAtZmU3\nOC00ODM5LTljN2ItZmNjMGJhNjYyNDBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOJbkfP5mTOpLuLNcOU2e8/OWsgPvgZhF3VJqI8KioWIxeUP+lQsKQc6pj1Q5\nD2teoNPV3cYnR59n87qoaCT39qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/gFHThtd5unnDM/zN+i3IMmObq0wHwYDVR0j\nBBgwFoAUfPioFmXThSArgB2xj0ON1GOgPRYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCev37nOxx4sfjBnuABkc+JMIz/1+fJQmMmuriUrdmIRQIhANbT3SFiHl7h\nBoKO3fMticEdJjOnukEMwJS3nCANlOLV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVOhN4uCJbVVV2clZS7gU34uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmQ0ZTFiOC04OWYxLTRhN2YtOTg3Yi1iMDNmMDE2MGY3ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOFgLkCSMTHhZNDwnK+mGm4hjOmpK27dwFOfEwM5ta065c\nuUOqHQXgH8o2KaXPGPDsez6dgRHYmGbx7h6IMhnko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfPioFmXThSArgB2xj0ON1GOg\nPRYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgd7fRFAmGt+WKnS9KS/yQE9bzqke6DH1SxxxdkjNnTjcCIQD4rV40nevn\nN2WqzbdIpeU9Wq0Eis36hDDD/+ElACEdcg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAdjrU1KATfKFC+hnBig/AN5FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzdiNjQ1MzAtZmU3OC00ODM5LTljN2ItZmNjMGJhNjYyNDBjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQ3YTI3NTEtNjllYS00OGMzLWExNmUtZGZjMmY5OGQy\nZjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENN64wybsHyeT8m9j5hHQL4H5\nDcsLqbdUOqQjbpgemw5Pa/reDUWECded250Utka78TLjo8TYDLF09QMJQCYTUqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU/gFHThtd5unnDM/zN+i3IMmObq0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDNgHsS\nuiub5PLrA9pcVuh0Acrn7R6jiIzk4axZmYXkjQIhAMN9h0A9OIrcXdQDhAlj9cbM\nkTeDcFKCfcFiPh7ffW3v\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7240", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7240` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAS96L8CfTVwHZH1Unf/cQEUmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1MjU1ZTgxLTA0MzQtNGExMS05MzEzLThmMmYyZDVlMTBlNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI0MTQ1ZDMtZGU5\nNC00NDZkLTk4YWQtMWZmZjcxNWRkYzA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ8BqbJSM1v6hNIEujZQ00v8nKo1u2RbAbtiATjaoxRRf5Kv0dl1xGhYNh4Rx\nZdHSTWN3V4sOzgrWpx2xeKSFsqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh2NR4UXXC6jsAe/yusL8WGBcFZowHwYDVR0j\nBBgwFoAUk6gwPMYdR2skrLT96ecH+CQ8NYkwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGF5\nIp3UsYF1P0/aD+3/9a8gUA7AY2rl+QrgGRpx/thWAiEAjESnruCKyKco2XUQ2UV2\n8EsnfrRYdJclriVfpTwjqpE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdQwt38ldVwbCIb/Cm0AKPzZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTI1NWU4MS0wNDM0LTRhMTEtOTMxMy04ZjJmMmQ1ZTEwZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATF5ZBtRf0ptytjvmZuYCL6DjX+ABRauiRKhNnqcAUNSvxM\nFe8ascXqQxzZwrSUhNSEtEeu92TNdbmjnAEFZxw/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk6gwPMYdR2skrLT96ecH+CQ8\nNYkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB1QOTxI0Lf/CS6IpkcDvvJ4MaePzVA9tfymmFNX1tY4CIQC0aMmrrKRm\nq4dsuzwCYYYVS+tax2jHCaCMy7jj1h9O8w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISATxyIhBtgQUzhvl70cOOrclnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI0MTQ1ZDMtZGU5NC00NDZkLTk4YWQtMWZmZjcxNWRkYzA1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTNjYWUwNDAtMDJiNS00OTU5LWEzZmMtMGFhOWViYmFk\nZjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGg0bHeddiclCgNvVGIXTJ/Yc\ndboIBXs0TG/7MnnatIhDxVsIymUFhVI5pSjeKJsjypzkDXIZxYyAaEC7IiH4JqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUh2NR4UXXC6jsAe/yusL8WGBcFZowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAHHQS2I\ncyhnTOxr6xcmcgbKGsd5RRp4sJE6x1J0nTBmAiBpWKpEjVFUvy5JPvn1ALEX1qrZ\nR8R+QDWy/EtVv8OSiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7241", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7241` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAfV7AsfKmf/8+ISHIKl/F/zwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMzYyZTVjLTdlMGEtNGQ5ZS1hNDQzLWFjOTU1NjA5ZmEyNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDkxOGQ1NWUtNzkx\nYy00MmRjLThiZDktZTAxZDgzODQyNDU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbjZl9eqArMRv5C3bKApPeyuibmicnYMGh83qH+qWIYgxYapFHK/HzfAHrs5s\ncBTvfFbJZkhgyeMDimSKQuJaHaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkehZk5Z4TX5w6mGlu8tYY7XUBnYwHwYDVR0j\nBBgwFoAU3UEnTHz09ev1WtpDGR51DrtFAGowOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDCJrtgFYHvLQzYMFKzdndJy0BryuIHtWhonwSwQtasAwIhAKiv\nqQASM09+lHM43r6D+TKeldQfdxsRG46UedawmVsy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXgZQz0LbOI5HOjZOLvqK6uHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDM2MmU1Yy03ZTBhLTRkOWUtYTQ0My1hYzk1NTYwOWZhMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdfcVlDcHKrgCp7DQsaEkspfSaAqyPNqWv4AquV4+67yPR\nJQR+FDhhjFzwQuUMBD11oXSk8belcBdvkVloPqDMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3UEnTHz09ev1WtpDGR51DrtF\nAGowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGrwN4UuuUyLvE01ViJ+B7w6pFv7NOqqhYrzxm6mTJdkCIEHO/qYVs4Ct\n06Ek0TXl4fsYmpst3/xnP046gRjnsLwV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISARdBfD3kaQBEifVFw/AuVz4uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDkxOGQ1NWUtNzkxYy00MmRjLThiZDktZTAxZDgzODQyNDU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDBiMWYxNDAtYjVhMC00NDEwLWI0NWEtMmFjYjRhMmNj\nODMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEW8ldpajb/SK4FIZzsPk4VCoR\nEO5YXeaPvu9RK8KbZzgtwxFuglUqEgiwwiWuCtMUitqfdaDLicqcB0MIGeTkuqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkehZk5Z4TX5w6mGlu8tYY7XUBnYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGO1mbkI\nHi8OjIcnhUq20vmOcdrSjpjdWQo/b1wASlGdAiBKHI+pL1vRVuJ357vyn56hfOi7\njHnSBiIDdr2FpAaI0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7242", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7242` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAUiTJcxJfH/nGRptDslRjNR/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlN2JhOGU4LWZiZmEtNDJkYS1iYmMxLWM0NWE4NmM1NzMwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM1YzIyOTktNWY4\nZi00YWI1LWJkMjMtZmNiMmIyOGMzYTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhADWymwOJqAGfycuslrz5bwVAs9i156jniifer/wBxXQBBuhzOWHOzLuV203\nhf8oHx/7/3BdZ7g78VGz5jVdhqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlOJbT1wvaM13grYLb7LOs2d969AwHwYDVR0j\nBBgwFoAUIYMImgLHxC1EemmpNIkQLoaMPkMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBroEQmvEVFWf+4RAVI+WvgBgm8M1HshwEruZSBTBfjtAiEAwgtR\nGvOjw7Zu1h8YKAfDGBUww98f3R/6o0noVSL0uhQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQbtrike42wdSQXTbTWeK1BaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTdiYThlOC1mYmZhLTQyZGEtYmJjMS1jNDVhODZjNTczMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/HnlaghBwTYsYIDP+gwc9eQIXzIazfl8JtIUqrtKrQavK\naTz0CAKYlr6rEjT2k7bAJgZT4fYUqE+g2rXVul/eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIYMImgLHxC1EemmpNIkQLoaM\nPkMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaXlYKSrs+glcCeofuenBcpXAdAWvOxXTrM+cvc5ZNYMCIHtduvFHBvEO\n/tMO5ur2oQFo3TcsnNBAElFxoyNNQTj2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISARN9QaUGdfFCOA8QnYRDG7WKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM1YzIyOTktNWY4Zi00YWI1LWJkMjMtZmNiMmIyOGMzYTY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDZhMDZlODktOTgxYi00N2JiLThlMjUtY2RmZWQ1NWE4\nNWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErPivru/jHZXAKBestyyAry9F\n0YHw2+IByOLAVCj4Ac1YlzZEjnowP+PrtQhJGYSvE/9pwwArBZRDdoSdLQJuzKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUlOJbT1wvaM13grYLb7LOs2d969AwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIDz5aKlf\n5+0r4Va8rhI4nE5U8sF39qeYehSDTwIc5kksAiBC2IwpLiCvVzQ5xon0ApNVnc99\nynni3enUwSPIm2O3Gg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7243", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7243` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISATeAE/OkafTJ+vFcaQ68PQ5cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3N2YyNjI1LWNkZGItNGEwMy1hYjQzLTA5OGUwZDAyZDA4YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNkNDhhNjAtMmY1\nOS00MDk0LTg1N2EtMTg1NGVlMjhlMDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1r3wvzFpXtcAi2mcxENPzIuQO5Em0LO/K8sNsL3p/+WTgUSpspT51DQayYs0\ngTt5LCGZuabYyQrAuvuWdBATr6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSgEJ8qWIzr+JrvCsJBW/YYSMLZDDAfBgNVHSME\nGDAWgBS3boPkaGMjvmHHkUm0nfZowV6j1jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDSf3raeoJ1L1cjL2ToqVKib6khoVHE\nfPput5YCsclX3gIhAMovrrl0KjeNdTi4Rjcvgo4vxrNepFftNUlva57xVCS1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU9fVae28lQm9moZdbvDYsSiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzdmMjYyNS1jZGRiLTRhMDMtYWI0My0wOThlMGQwMmQwOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV03A2nZJXF8+AmK/0gpXztlJ1wzJqQcqCh/xjbvwB3eRF\n3WYqmQVQo+/vIiTEZgV3glXATR8Z8rq2Mp7fXmI3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt26D5GhjI75hx5FJtJ32aMFe\no9YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIFJpekaBVsVfO/4LY3QwCGbgTJGWeTe9lsp0KYNhydkAiEA1UKNrsEZ\nIZIZ3wckoX7fSrl83KjdjZ9LJ4IgmDQqyLY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAX4r3bxFDCETiVrXy+4g97hfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNkNDhhNjAtMmY1OS00MDk0LTg1N2EtMTg1NGVlMjhlMDQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjU3OTU0MDUtYTk5NS00NjJiLWE2YzEtNGUzZTZkNDFi\nOGY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUZ8zusybx95s4lYuKrQNabzd\n4UlJn02gZAOBTCkkNzCAIUPDUHvFLx3z14dJ9bfGxAXmNj7KNHQPPRHIPhpQx6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoBCfKliM6/ia7wrCQVv2GEjC2QwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCP7BoD\nztHxlIAyBlLZlDFQCRMy9NVKS1oTjr4KPlm9ewIgBIagYDd6seEfJdF7VCIxLFCr\nxRL2qLu/9IK/0s/qhNM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7244", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7244` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbQQ0Y0sqfixxhj93vz2NAurMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMDYxODQ0LThhOGMtNDY4ZC05OGNkLTliMzM2OWJiMWZjNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdjN2VhNWYtMzMz\nZi00MTExLTkyNmUtYzVjZjQzYzJlMmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnVZCt88Mqvd2oy94JCgN8+DYBmGxBm9qc2q1+xBrwZffC2yFnxTBmxdRQwZF\nF2/0INj4UAtaGw0PeKgiOPRqyaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsKq+jsBAevHnw9loaACHcqYVDfAwHwYDVR0j\nBBgwFoAUl4rDqMqBz9i3doEWxEu4QEEgkEEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC9bVV4oGd+\nCHMqLncjNeB9fs1XfIXnKryBQIWuP6OdIQIgciYYNpV/7AV2xfJ2iBFvtgEwNPEH\n4+WCOdGrVaSKCpc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf1MepN2nENpHdU6La5ZzBTTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzA2MTg0NC04YThjLTQ2OGQtOThjZC05YjMzNjliYjFmYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2fjWTKJOgqg0+Mf8lfCtYAGrwheJi1mDv5BVrpEx/28ar\nbT03/HlBp1R7XpUa9Zzs0Du8uSFqh9pwUiQQ/1gNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl4rDqMqBz9i3doEWxEu4QEEg\nkEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOgHxiLOYjMh8QAKkE66QUtjsGkiHRwPpwuy3MTPfKagCIDuYO783fVIG\n3LTfdgEm3qvcaoxPklv61O8dtXrD/rpH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAa4FfjphEIBNPQJMrQjI9jfMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdjN2VhNWYtMzMzZi00MTExLTkyNmUtYzVjZjQzYzJlMmVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGVlYWZhZTgtMmM5My00OWZmLWIxMmUtYzY1OGY5ZGI1\nMTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkBOm7Vonu2foNOnwJghn0flg\nVeqzmJ/8znEUAYAoOJnXo6FN6BYBHDexsR3y3ZdPiQHfbwtV11JJ/kt2mDatyKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsKq+jsBAevHnw9loaACHcqYVDfAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHiebcS7\nX31G1vpnbK0IL7y4QkAOnI+O1Yad2HrPTPJgAiBhtILVypNusnSZTYjved0vdQsD\n3Od5blTn7Ky9A3f/nQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7245", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7245` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbQKYrkyz0V4/3RRyYyZu7ytMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2OTJkM2YwLWJmOGUtNGUyOC1hMmY1LTZhYTExMGQyODJmMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JlOGZkMjUtY2U1\nMC00ZWE5LTk4ZWItNmZjZWUwNWZmMDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEERZUR6soJgfZmdkhdCQF6if/ERm2aKdNst+oxkfponbKc1ttxQvhLEsDoDVN\nbauPbsM2qjcVpSpZC4lEptW2CKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMH7WCq3cVENJyTIA0r0oPfbYI8AwHwYDVR0j\nBBgwFoAUQnvkAfsAAGNUiQb3jzshK1ncNo0wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIAE7PxaAmYYK\nmCtLjU13Emmzc/wIbeFjM7GDVvMDedsoAiEAnVAnZOfi2HsVd1+CSLjyay6r6GnP\nyKmLHz85HY7YYE4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATwlmyJL04NwVuYxSe78iToqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjkyZDNmMC1iZjhlLTRlMjgtYTJmNS02YWExMTBkMjgyZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASN+kVG2F7qLcBbB8v9WaEzTcoAGk1Giw61b1Jlfy39UNcV\nj7RQyoPC0rwSKJJ7mIN6BdWhrFmc1KdqHY05kcdto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQnvkAfsAAGNUiQb3jzshK1nc\nNo0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOYON5kxxET7TJNcUHEN/z4kVRNKi1E/YBGegIagNz2aAiB+uWg9lyOI\neHUdlWUBDIK03oimCsfMXlz20kX39xp4jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbVEa4giaZl8c55JN46DhPenMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JlOGZkMjUtY2U1MC00ZWE5LTk4ZWItNmZjZWUwNWZmMDA4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzk4ZTI2NjUtOGMwNi00NmY2LWFkMzUtMjUzOWJlZTRi\nOGMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE6WUlklqi/dHPaBSLyvw1U0z\nEacSSoKjVJLrHup8Lhmc8SVnFHlz7MPi3jqGorQipFBa5x5zeFxRZU7KMqgKjqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMH7WCq3cVENJyTIA0r0oPfbYI8AwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCtUdd/\n1wrCHIw2020Qvw357Y6cfc/zrDybnKLAYzbKCAIgEmrNzFZeG+n6sqBtipbSMskg\nlHxLDphmf0SytAYDQXs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7246", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7246` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAaJ0WVx9ZRCbhPDrsWvwk9uXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzZmY3ODFmLTdhM2YtNGIyZi1hOTBhLTAwY2FkOTg3ODQ5MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM0NmI0ODgtNWNi\nZC00ZDEyLTgxYzAtMmVkMTY4OGI3OTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAg/HeQwGcn+56ajFhgCquPMlbN05XLZZ7+1Sf6lpJd+2/FJawU69pRNF7P2S\niHmO7VqH8D/f+0zC+ppYloGsSqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiBCjHWL02Cyqvm86tIIOwz9smL8wHwYDVR0j\nBBgwFoAUeNS3Wm2cEr5B1AMZxV31RLOy//EwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAwDeA/VSQ\n71tW08zdfkqj4euu8H1C2V5RuORfXU8MtEQCIDYAIwijrsIKNeCMed0qnyOv+UaK\nPlWE1oalR0Cf2k+n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd9HH2I2HxOHwpmhETcINLLBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2ZmNzgxZi03YTNmLTRiMmYtYTkwYS0wMGNhZDk4Nzg0OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARalh6Kxx+YMmL+PlbSygYncK+NuN30h2pArVEMJY0fYLpt\nq4sNqPwF0z53vDkGRDq7VOClswvMLvDL9wLmafeio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeNS3Wm2cEr5B1AMZxV31RLOy\n//EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJhP9BCOGVgfyYc26dtDJZCghUUMVXWhDchHX63kh1f+AiEAwfBj1SGC\nFhF0HZJzzzWQGIlf6u0UACMuS1d7FACJV8Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWBw94lbWDHVx1yORLUoDnCtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM0NmI0ODgtNWNiZC00ZDEyLTgxYzAtMmVkMTY4OGI3OTllMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGRiYTAwMjItZGQ0Ni00YWQwLWJjMWItYTEzYmY2N2Iw\nZWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQL1jT9bOckW1H8cJib1v2R7l\nRsxQ5BTuPAaQYlAmbO9kiKjnlB2GzJ5n4CFfHIE4RsXUUi19U5Jc848vo3l+f6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiBCjHWL02Cyqvm86tIIOwz9smL8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIDFMy9Og\nGm1xdAQ+yf8sm6DO3qlMdVAxP6/SkvIB9BN2AiBHnQ48nNSLwPw8Ajc4nI5hmHgL\nLzISKeXM6KoIPyXeTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7247", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7247` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAQClu0wgaKKNf4d2A5ox/ad3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyZTcxZTEzLTlkZjktNDEyZi05M2ZmLTlkYTZkOTdjNDAwMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc3YzI2MzktODhm\nZC00OWU1LWI3ZjgtOGFlZTExMmFiMTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFMj1bHlg8ar9hUQgk/wyOLBLg3RphRN9i9lBJV7m632xdC4yM7XG3VtMXPq/\n8LwRb86B8gWhWDTjyG1/MJoTCqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQiOHtKAFIkLlLS1M3qVqldgUBocwHwYDVR0j\nBBgwFoAUjStGC1GmrwkBY0uA6h584V5KXnMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAminpx14eZMruCxLHyE2up+mVSYxYbwO4bQyHVfMTBOkCIQDIcxLXkD/1\nbGp1/L4q/ClpE3N3Iz5ocS9fiTOjvdhpaw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbdlaafzBSAwfGPnwnDoVXFkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmU3MWUxMy05ZGY5LTQxMmYtOTNmZi05ZGE2ZDk3YzQwMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThe1LWfrg154lAlJtVioHckwJ7u3B2dZN/PXPpBEMHuXFN\npRr7zKrJLH7hbyGkXncquvBGW8SuPQYmF4LUkU5+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjStGC1GmrwkBY0uA6h584V5K\nXnMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMJiu5rYZTGbiDYT5ie19rbcgEDxLlgzmvZQZ6ED25ygCIEFF+qJUOf+h\ngnJ1UH7EbVKP7e3AJF9RCbFVyflvv1y6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZ3xekl7w2iMFReilx/cPZBtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc3YzI2MzktODhmZC00OWU1LWI3ZjgtOGFlZTExMmFiMTA3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2QxYmE0Y2UtYTEwMy00YTQ0LTk2NzUtM2NjYTA5NWM5\nYWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1tq7XgfLPuGnU4qvus3I4XHI\n9a53OUtT3hRDzsqMWXkyPr8sP+3gAkXDwtlNE6wNJIZMQKElRq+t/0aeirGYy6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQiOHtKAFIkLlLS1M3qVqldgUBocwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDhQ4Us\n0Wt4HOMUbH1+eXtHSSMr6pvq3cfQohXdm5qAywIgJF/wYQ143B6SKs7mKDrGX3yj\n+Wgt9ADvsNlP/ZeO+MI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7248", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7248` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYVb/eB1XHBKexGIkn9/ZrFUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3YzFhNDdlLTFlMmYtNGZjYy05MjY2LTdjZDBiMTgyMWI4ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhlZDZiNzctYzVm\nMi00NjAxLWE0YjMtYjU3MjkyMGRiMjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiyq4EvfWP+EN4C8WUvvmFkz4SEVVV2UOsQ181TDw3RyjJklCmK/EhW5yMyQx\nHrU+Tcv+CS6tPkBRLmpeEIPEa6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUthUvMPE1PY9RdHMSqt4WyhvnY0gwHwYDVR0j\nBBgwFoAU2tjPZCq+FWmqpB3ia4X6HxO0B60wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAuAejg7/ebXPKvEdIjBKXaXfgUF/vQgb9dM78nLGVuagCIBX+vutU1EB0\nxwqC8652koCNYCUfe727+qRvil9Zxbxc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYwYEw9QzK7n8F2bs05eNKSNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2MxYTQ3ZS0xZTJmLTRmY2MtOTI2Ni03Y2QwYjE4MjFiODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVTA/7N2caZkLLR/NLFNvI6hfgMlyj5UYw8WTVwIB5rX6B\nxbguXf6Y5Rd4VTqUyf3YGgaS58XT/djAdvTWvbCro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2tjPZCq+FWmqpB3ia4X6HxO0\nB60wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIarwTjS/O6MiTZfBhdPVELKj3jaw8I74C9pjogJ7WY7AiEA9cf0x144\n36zZVpXyy5G5jh5tNgBbbCR00S1/i1cS78w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAehrGY53JgSMakU2P+anR74VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhlZDZiNzctYzVmMi00NjAxLWE0YjMtYjU3MjkyMGRiMjMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmEzMDg0Y2YtYzViZi00Nzc4LWJlZmYtMWQyMzYyMDkx\nNWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETteFMiZHezkKqNffHE8Xy+1k\nBFAWHc3o0fT8GZOTFQTH8kDLLRPUdXzwjz/7gn2v0syJMtg1rDfjcdoSl0v2m6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUthUvMPE1PY9RdHMSqt4WyhvnY0gwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQC5Arq6\njAMz87KBd1iNrdyGM7np17c4WBOfGQpCzX2/zgIhAPMo08dULhzXZ7cEAKJS5GKq\n5LNgI9bmSB7lONHd0ZmQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7249", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7249` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAZnXWLMZjXEN1xMKCsboFzyGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NDExZmQ4LWEwZDgtNGI3Ni04MmM3LTM2YzA5N2JjNjVhMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTE1ODE5MDItZWMw\nMy00ZWJkLThlNjgtZGE4MTcyY2E5N2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQgBxiWEMsaDQjaYvS7LSjfU3YKX8SeMazE1Jx4zt4gdhieEq1dq7N29SmYD6\nEklKcGhe54md9P9+3gUa8r5YHaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGZ4WWixRFIbLBTRWHt9iFzIzfhswHwYDVR0j\nBBgwFoAU9I7J43UDXMLr0cgzo1Npr0/u9+gwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n4dZMr3HZncJfF6z5/8E02LzgDGjpPD/WIuRroUzfsSACIQCa0aRTLPJppu9d4/ll\n4kElyn16rSnipxNB/s8/H3ivvg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQNrzlXiHJY8GBa0cv0m6s6dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDQxMWZkOC1hMGQ4LTRiNzYtODJjNy0zNmMwOTdiYzY1YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPGtgF9fh7FaHaJ+o37NeSqTiQ2yNrZPVtI07oe+obiz3Z\nccTy2t3DviziFXpdB8ozMSCbGVW3s49vPFGOoFvjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9I7J43UDXMLr0cgzo1Npr0/u\n9+gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANlCKb6BfIlAxsjCnqjx84pupTy8SzZ/ZhsjaSoA+1RYAiBy7tvTPzts\npgteqzIHcOIMOYZjRdVcR+d82E7WWPo+XA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVE4YdEwcxTsdAr8ehUvi2RzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTE1ODE5MDItZWMwMy00ZWJkLThlNjgtZGE4MTcyY2E5N2Q4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTZmM2VmOWMtMjk2ZS00MjU4LTgxMmItZjU1NDU5NGMy\nZjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESk0IprvgfwMq3YzooOI5KE5d\nc9M2UjyPKWpCY06XfC44FoGEsKAvhiHl9KJv8wj21/Ual7ILt6WvZ+XY/lGlWaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGZ4WWixRFIbLBTRWHt9iFzIzfhswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIErg2++d\nBmnIaVRokbgpgHT+SoHzBLGi/K/N3m+mZZWeAiA0Bgc5Tl0/UkH8ssBjt515gOr9\nVSOaQTSBsDkz8zxbug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7250", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7250` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAW5yeSbGddA8EjMZsTjc89okMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1MmIxZjFhLTY0NTItNDczYi05YjEyLTFkNWQwMDEyNTZhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQzOTI0MzMtNjI4\nYy00ZjRmLWEzN2YtNjlmMWIxMDIwNWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf+Oh8clY4uDy1YcH2f53QcVdZwwkwr64Q+lzIGShlM2Qyii+zEbLkh0WtgCS\nvDvw75xmIkNxJplqDqjEnN4wC6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT2Q2KHAPNOOY3L3EPGWXJG4t0VgwHwYDVR0j\nBBgwFoAUix6Mn4PmI9aPimn8ycFjG+b0u0EwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAOb9zV2KXi0SQyUMXle5NFyNEizzSNqeTe7xyoV0AN2gIgD5Tx\naJ2ZBP6+C/lswd5jNPrndj4jvzU/Ji2npjthkh0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb8MHQ5aQb3wVgtBt1BBvxVIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTJiMWYxYS02NDUyLTQ3M2ItOWIxMi0xZDVkMDAxMjU2YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJS/MZCRwTDGmXn1HTMVAohNPnK5Wrujg2J+7l8OS0gFfd\n3+ZEA98U0DXDm4KnN7ibvhiyzXWyyC7J4xggSjTwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUix6Mn4PmI9aPimn8ycFjG+b0\nu0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN2rrRRZk7gkFvmd/yTHCrsEsWfOWbIuIC6GKUj0J9vDAiAVBIL4NBf1\nQSC92NVxdQKK130yQ4J7uGt6VyuZEF5vCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISASgZuv2eXlfU0p3hrkjT4nQAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQzOTI0MzMtNjI4Yy00ZjRmLWEzN2YtNjlmMWIxMDIwNWVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDJjYWNlN2MtMzQyOC00ZTBmLWJkYTktM2RmZjI1ZjJi\nZjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0LVf0Ygi2gjBkMUw5otz7CcV\nvM0i/LLfJuy7TfmTt/dbPVeHtd+FKJ9MB/dcKwKU8pYzxewBnjg7FmfQS8Q+jaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUT2Q2KHAPNOOY3L3EPGWXJG4t0VgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIFoHA3uh\nxTqMzEJBlhjkLKneAe6r9pckdnAH1fucY2++AiAEiP27ZixnqsI1ZSx0hs1idQLm\nvqEedJJRUrLuClAM6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7251", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7251` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAXctxwWVYJb1wPLYYKgcV9piMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMmFlNWQxLTRlNWItNGI1MS1hYzk0LTBjNWJjMGQ5NDlmYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM5ZTVkMGYtOGIz\nMC00ZmFkLWFjMGYtNzU4YzNhNThkMTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5TDf7LlnTSVAuZndoiHYENyJHoLlr8vEDmzAG/3BSoHcuI7fwnKh2f+7IuZ7\nwIkb3B8nddS266iwG6t1mVdU4qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6KHu18BBM1+ENyQhYaFEGm7oz+EwHwYDVR0j\nBBgwFoAUpowEg8smlc44ict2lseTMBVPKi0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiASonyYe79iqBc80CGc+qzEgmkWDh3RGyZE3LwLmerUgwIgQbGB\nCMPzIi52Kb0wpWyXzyLKP02XL7cOZ4xoBlggy8w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARioJiNcKKkJQ5qlb9gwTgDrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDJhZTVkMS00ZTViLTRiNTEtYWM5NC0wYzViYzBkOTQ5ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlq8ZrPCporeqzTFxJZvTHu78TcLYQDsHMMM82gQeOzW02\nDexVd3cYTH/8ouM4+kH6HWnhTeg57jYV8eyOFBqHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpowEg8smlc44ict2lseTMBVP\nKi0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJeVguCyMbtzot6hGaW7Noh+Ne85G+Zzh3gY2QCSAB34AiAT0LhydeKQ\ndSxtJE7TnSE+An82+o4YijXff8OmUTEykg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAaRZsZXGgSZzMC6dDkYlukRFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM5ZTVkMGYtOGIzMC00ZmFkLWFjMGYtNzU4YzNhNThkMTVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzBiMDlmMmEtOGMwMy00OWRkLTk1NTEtYjUwY2NmOGQ5\nMmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBkCtrzSjFhYhyE5OYVU/JAU0\nH/CYF57tusP282aTDEQw9B2Z2/fi6hAxp3SrvXDXHm4LWecRkW13KPYM44CvcaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6KHu18BBM1+ENyQhYaFEGm7oz+EwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIB5JtkWy\nB1h/5LCZEfJEORRa/x1o14tjd449e+ZVoBsuAiEA0+VQj4fkV0I5XcMtth0NLhZ6\nGBRarTxCbaEMM/xcTwI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7252", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7252` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAUlKTnztND9vvUlkNf18qSYvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzNzA5MWI1LThmNGItNDZjNy1iMzMwLTUzMWY4YWM5ZWEzMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZmNzE0YzctMzBm\nYi00ZDViLWE2NjEtZjFhMGI0NTc1ODExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuW9m1bw4qDgUG3CEPBj/818Z+q5amSh8YQ/o+AWzi6pL8PiFTr4ZMZ+Z9SJg\nkMP7v5GaELtA6KaU67xagAreaKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVebqha0+f7bqoV8je534V1b6SQswHwYDVR0j\nBBgwFoAUuB9+d6cWOOsPYpr+PPqSXKVXlkEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAoLgSMK8ypsO6\ny9xjlUi50mPldcFaIt3KNKrvewfP9ZwCIQCeMY4sqPuJv4Qa4vg4vGjH31ejJHFG\nu0p7kxUcoAzMZA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZn6SVHpEYdKXGrtuxfUSb39MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzcwOTFiNS04ZjRiLTQ2YzctYjMzMC01MzFmOGFjOWVhMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDthCpJfAN8OrnbIZtnytUpCw7ZhBOoVesyl188PTaueuH\nArlJEBUJwv2kZCiR9g1iXFYakbL5EYYfQKfbO0fDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuB9+d6cWOOsPYpr+PPqSXKVX\nlkEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOw93p3RrqHICS/kMbSZy8u4FqpGWGgO8N4XrJGEu7WsCIQC0RlS2gr41\nMYdZkE+cSA4j1v2I/BnedjKxqlwmgUf9yA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARMEjiKyrMgNtQtTr0n91lw7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZmNzE0YzctMzBmYi00ZDViLWE2NjEtZjFhMGI0NTc1ODExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmFjNzUxZTYtMjVlOC00ZDZkLTk4NmUtNjRkYjJhNzlk\nM2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP//HX8oTUtaWEfMbuw10TXut\nw0q/6DJPKBLP/vnLcGj6eVrrkJ7Q0mnp22LuxG0+O+tkEBNPtVjSFO9jcqBCdaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVebqha0+f7bqoV8je534V1b6SQswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDSOvja\n9/ppWkDev1pEXaSPcZpfhXU/Vo4NcovserglHQIgQImmCvO6AG20GZfZEAnsdOGv\njjX4oHjYzCzzS5fP8Os=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7253", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7253` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAf4sSeIUZPKh8mA9kbFC9868MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiMWVkMTFjLWM3MTYtNDdhYy05ZGI4LTYyYTUyNTFhZDk1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg1Y2MwZTQtODI1\nOC00MmFkLThhYjgtNjI0MzBjZWQ2NThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMEr5ZcP0EC+NA3TIRcaemXjaVFhWyHzsv2LroLKYSj879VG1DUdqHLbWs4OZ\nBam8BKPfFUTkE+hZY0y2cgVNU6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWBuMsxzFyIbLynTIm726o3J49IIwHwYDVR0j\nBBgwFoAUhzgDyMKUyHClluc40lxpxDg3oxwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCG6pwhrFW/q6awkMT5Q7wAmy2MypwwKuyDY5N9ftUYiQIhALD1K0dv0hcI\naQMJzOw9cXi93ul8qjKK3rxoJqEHgzo5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARqX5e1oYLV4vI33JwL7SssIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjFlZDExYy1jNzE2LTQ3YWMtOWRiOC02MmE1MjUxYWQ5NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8SpBAmm8KGJh209pjgRzAHXF1tJ/LBtLmV85FiR5uR3md\n58/rAeStJs0Zxw2M2jOqP8F+gSCNX5BHm4Lc+xeuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhzgDyMKUyHClluc40lxpxDg3\noxwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFGn9IyPkNX5MyHnOWcoIsSWXj52xboPnxiaaWxvkPdQCIQD5xbETCxYG\nOhZFnv/Kwk/n9eV75HgBS97aiZOpdS967w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAWW+5/rYf0eqx92G/kFIGWfjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg1Y2MwZTQtODI1OC00MmFkLThhYjgtNjI0MzBjZWQ2NThiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTk4YmI4NzMtZDQ2OC00NTFmLTk0MGUtNjdhZmEwNzhl\nYmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbs1b3JBggXGA1lXnHlQnCLnH\ngEFEl1M5C4AyBg4jrlDj0tu2Mr29NCBTf1XYd6n9FSgMnA1VSTXKSOoWqnEAsKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUWBuMsxzFyIbLynTIm726o3J49IIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHfucXNc\nnDpJRSug2d2TVr0yDj2gsXhNtUxrTzP7UmGDAiABW3WHRe40uYjJ+WOdGnBmnTdI\nDqyVBMTZ8ahQYBxzpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7254", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7254` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATwHaHI9EEJMwuh25N/ESbMuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZDU5ZTczLWRhY2EtNGQxYi1hOTdiLTU0NDQwMTdiY2E0YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQwZmQxMDAtMWU4\nNC00YWE1LWIzMjUtNzlhMDMwYWFmZGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG0SDXkdj2qhM8rGmopgbfrY4Ug7WMb/tpoGM2lbN4+XnfDlLpSdN9yH2psc3\ngNs9cr1Obf9//hRX1wPPF3by4aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV9Vwq+GOgff9RF4J33QKpgCWFDwwHwYDVR0j\nBBgwFoAUPVvHCH9qEyCsw/1pfK1J775Q+sowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGZy5tALHD5HNgZaSywOwf3DhzHpxH+zcYpVCRLNP+b7AiBnh408ITC0KnNz\n3RfJzlsmtC+gcf8MTiMUpzbRaGrRkw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW7zlIQdb4Z6YUPW7/XrczkSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmQ1OWU3My1kYWNhLTRkMWItYTk3Yi01NDQ0MDE3YmNhNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCQfn6NbvKzobI2ZZKglLWxYRLrhmtd2aqven1IwTGLKXN\nooGoSp469KzkoxXv3tqwIMQgtrvp7B+QRNzDW7myo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPVvHCH9qEyCsw/1pfK1J775Q\n+sowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANRzaBY45eCp/he4zRL6o2GEhfkPPWvt5fBSY5tifksjAiAx4p4wVGr0\nHzItbiTCmPgk3XC2JHHwu/QevHSIVV1icA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdNsVqz0ESYgYeQSgmkmJJcOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQwZmQxMDAtMWU4NC00YWE1LWIzMjUtNzlhMDMwYWFmZGM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTE2MDc0ZDAtNjRmMC00YjhlLThjN2EtYTJkZDZhYTI5\nZDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP8ZMChg25BsSjeSXiV9IBBfX\nsYZ2k3cT1rvlcoYY7Zu1rICOcSFZGXmmlxZDNVUAQrUcY0VFQQpACqIfB2N+FaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUV9Vwq+GOgff9RF4J33QKpgCWFDwwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDrtQtL\nfrT8Q8wtjVHR+L5VER++Kf8G4Sb3FtRhdajZAQIgTMJlFhKHVtyYzDdsguFiKuKF\nIsopo6ThPFAbO4iPuTY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7255", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7255` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAe7QjAgOobyIMQ/DMCDVeqJjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1ZWJjYjI2LWFkMjQtNGMyMi04Mzg2LTY2ZjVlMTYzYmI1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA3MzYyMTQtMWRj\nZi00YzU4LTgxOTAtYTQ4ZjA2NTkzMTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk9Lfm3SlU4pf6tBiSZcqoOpjVvfWEyL8eOAoxWmg18btPmehJhTmpOxk7p9A\ng47CIQFqgh+HjzVv6oR5jZ3jIqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8/cNXR/MJaNU8WVvTo5Kb4rJsDgwHwYDVR0j\nBBgwFoAU3J6YUrxYdoswD7/ugNSa1v3RkP8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA6nSE9f7iBgb+rcsEPgqgWrFCS3OCJ4Eyc7rIoehT0yYCIQDSxGYWoTj7\ncS16Vuq/UrCLGEGY0/qDa9MOqOsYepVxTw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU808N7ozyXkxrUut9XB+csFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWViY2IyNi1hZDI0LTRjMjItODM4Ni02NmY1ZTE2M2JiNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+O4YJSH4bJG0iDca4+hQ1PQbiQtrRaHvOaKH2mTMuhrcS\nc7qA7wOR0voh8BnZfYRpr6JV4+sjl7LIhP+OSt/Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3J6YUrxYdoswD7/ugNSa1v3R\nkP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKlvgDywuxuZbd8R8AYKBvMxcUErJ8kmdONDddeF2XbFAiEAzQJlQv3A\nqAfmG6HjU9aaExesX1uISpYn4qbkPHRaPi8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAW+6h+tLA9BzAyyZ1HMa5xfaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA3MzYyMTQtMWRjZi00YzU4LTgxOTAtYTQ4ZjA2NTkzMTcxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDU3NDM4OGItZDY0My00OTIwLTlhN2MtNWE3NGZlNGQ2\nMTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZskFDLnY9D73XH/lAG3E7A6/\ngCwDUAzPscvQHbdEUTC8rYJncpo12k9wb02gz4FJXb13AMG/5z1y/2W5a7LgUqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU8/cNXR/MJaNU8WVvTo5Kb4rJsDgwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHxKW/R7\nFF1nKHdmciAAVyED9wmxxY4bFpWyTtLT42anAiAIDOX2pcj5KvQ4VS9tXoXE5uj3\nxjqkqUqI5PcD1hX9/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7256", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7256` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAYXZ9Rr+BgKAiH5QjFMB9BEaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4NmVhZjA1LTc1MDgtNGNjZi1hNzNjLTlhZDU3M2RhZDY1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFkZjU5NTEtZDk2\nYy00MWUxLTljY2UtODFlNzM1MzYwMWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAwdIHYbF1cGHwJJQhPaOjzEti01BVs3dTGYF9/wdQ/xO2i5AuRDgZZ5JFWcY\n+qvoLwg5NSa4hTTSht4wYJAHmKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpADdmEsZeZwM9PUzBjfx1gOilkkwHwYDVR0j\nBBgwFoAUKUbPah/DRg3cBgbVL0RCuGzkO3owQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiB17Sp9liJHR60ArqczeBMScM0GGTNlgV/1We0z9hie\ncgIgTtVOr+hQ2PF+zvXlW+tXSOrxwDyMv5GMbPpjTtCjZc8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATgfGEDFSmv0lfzEjSrHpJN7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODZlYWYwNS03NTA4LTRjY2YtYTczYy05YWQ1NzNkYWQ2NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhiIu8omk1AhJXn0Pw4TvhUgItDjEcJGLNnNkppC0zg5dl\nqABQf7RDcgNkQD8UwgGu5CSQOK2XkDq7ZKFHxHX/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKUbPah/DRg3cBgbVL0RCuGzk\nO3owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKPBR+dMwLc7BE/W48gOcxuF5p1RxF4/GuKJNFWLNyQPAiEAg75Xz/Be\n5Zb/T2C8oAyrqAX2V0BXQnnyiM8yTg4znZw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASQlW9HtczadksfA1cLb8MopMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFkZjU5NTEtZDk2Yy00MWUxLTljY2UtODFlNzM1MzYwMWNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWYxOGQ4MDktZDljNS00N2Q5LTkxZDktNzU5NWNiM2Y3\nNWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP+UlIPQmvOy0YiySxT3hCti/\n9aPybx3U92fPklmwHyLctACgAXwcMgOX6kjLKKTW6mGa4QIPoHTkG6LOtXmjiqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpADdmEsZeZwM9PUzBjfx1gOilkkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIA8J+Ip+\nKet/KjXW+pq39ykfI8g7PwCfpRLUOjknAZIMAiEA+awCPl/sIXoGi8a9E7R9egTx\newoaLvxZWWpoB90Q+NA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7257", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7257` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAT+mEYMwEfqBNeSUgV/SAQXXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MzIwNzk3LTBlMDUtNDg2NS1iNzBiLTE5OGJmMzkyZjM2MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDM4N2JiODMtMGU3\nNi00MDMyLWEzYmYtNzI1ZTFjOGY3OTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYx0JKdi81Hms/lJDcSS5thQ025d2b5W5CO+IUMNus7pIYVYX/VuZbXbThyto\nsdmtbb3OOmSnLesqorL+7owVgaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrSEMVhzDkcjn+0IhlvjWPDs8ZbQwHwYDVR0j\nBBgwFoAUMyzfSSmKPQys9qbuD8KN/RLjCtUwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAysd1IbM17vVQ9V6/iBRXHlNyFusw+bcqpBnsbk1ma\nigIhAISRFoNUDl31WEj5S5JqLD9aEit/1vJYCacDc9plsVnq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXqqG/f89qmT/3ExJVFR8LtBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODMyMDc5Ny0wZTA1LTQ4NjUtYjcwYi0xOThiZjM5MmYzNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/ArT93CR0JZ6VNQ00uZs5UuC1+l6x5NpLbLqbMUsXt1cP\nPFZlQPmL26It8y7rsB4+eColgPQl1lnjhkg5ppYro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMyzfSSmKPQys9qbuD8KN/RLj\nCtUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCqQ1iaSwd/znJgpQfJsK5cqErlWFUO1AwAgZYIn88BUCIQDVWgnd1/+4\nJ4mxrYzd5BqD62/AsozIP5DOmDBsWeFBnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAWC+uBIkxMJF5zAaKD9Lbj9oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDM4N2JiODMtMGU3Ni00MDMyLWEzYmYtNzI1ZTFjOGY3OTlhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjYwMGQ0NDctYTVlYi00YTdiLTk4NGYtMDA1MmNlMDkx\nZjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER+rIlgliGmhxR/6nIdNDaRoj\nuNr2+CVNVeOUxvxI8Zpli3M2uEOK+DF6OF8MC9uEUPJQ/6mYIQ0/E9z1whZqhqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUrSEMVhzDkcjn+0IhlvjWPDs8ZbQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCmmvhQ\n1Xq03xL+rIRNVUy6OCt8sTWZzp6ryqRlKJW9owIhAJ4gdKVmgzzrahzhWejQ9HSp\nqrC+zdWoyNeo8QzKj+5Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7258", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7258` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWU2bSsxE5vbow6AjiKBxrl8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhODU0ZDMxLTg5NGQtNDgxZi1hNTAxLWVhNDAxY2Y3MTkzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYxNDlhNDQtNzAw\nZC00NDYzLThhYzctYWMzMWEyZWE4ZDA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExJ79HNJkGh8Gdnm+QCmcA/OJ0k2uOxuxhpO76TOLdnvIpfL14F/caeW9w8es\nedwRhOeqkrg8tPP4HKaCpggZzqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnb2m92+Uu04cDE/Tq1bq1EU4uU8wHwYDVR0j\nBBgwFoAUv1jYfiermoAgv4KL03R7dATdjcMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA/Q2P6cCBLAK51fTUTdQiZOv6zHu6/GIdZFrj8Be4LOAIhAOxF\nl5tkL8MZGCEJmw75tBjzQftOcT6pLnJe5HlK4V0K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb2SfsqbpQbRfg2DsCMWxth8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTg1NGQzMS04OTRkLTQ4MWYtYTUwMS1lYTQwMWNmNzE5M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCHnhGjG7ZSIGokPDk0Ek6aT9pLVH1cKnjqcJfwGOqr/74\nEVdb78aYg0mAXWzvRlzgSTXkK0yiNpTRC9Xuvxbuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv1jYfiermoAgv4KL03R7dATd\njcMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdgDgUalHUeXr6huSeeRrQUTyoGO1M1AFYO9V+sxIPhoCIQDmYGW+w2HR\nJ6KqCLeAUzhWTBINDaLWHp9XNBgkt0nV8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAW8y3Ga7yOe8whw8smuGx5rIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYxNDlhNDQtNzAwZC00NDYzLThhYzctYWMzMWEyZWE4ZDA3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTQzYWQ4MzItNjZmOS00MzNiLWJmODItMjg1YmU3YzAx\nMWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA5X0lH7L5aox1tUE7gvb5SPo\ngjdDUiSsd1n4Zru/px3wIF/+btjuwAKjayv0TO5oGbsp7IhJ9d9HPUa4v8Ee9aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUnb2m92+Uu04cDE/Tq1bq1EU4uU8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGzGK+sb\n6kQryUUcSIdcScXpulL0qKCRffEbKKFmnC+mAiEAr3H3u8p35aU7qndetGu2277h\n3perBpz7HNwwRyZguR4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7259", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7259` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAfzyqx4GquBevJSRVQXNH+rnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1YWM5MTVjLWFmM2QtNDU3MS05NzBjLTNlYjNhNDg1NTYyNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM2YmY2MGUtYjI3\nOS00NzNjLTkyM2YtYjE0NWNjNTBhMjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElTiyqwng5SmewsG9FEGCiJWlRmb2oRSwBjgSNqffj1m31urnj4BcWFh8dOFi\n2DPHgmYLzjFL2dOTaF3nQoN/8KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy0KY7G8N9kjsk7p4FSBMv9yjoiEwHwYDVR0j\nBBgwFoAUOj8jx0txPpB4h/aoO8FgvaleymowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA7wMxUIwWPbZ/BcEovONxsL8HKEjM4HGB\nKsaw0oaoYvACIG0JTEhelQ5SpUi/pcBB3+SFPwAQxjZBgFqKxD0awR5N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARusPf/rVVVT9e59wvV10zS/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWFjOTE1Yy1hZjNkLTQ1NzEtOTcwYy0zZWIzYTQ4NTU2MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1R/O/toAzrgB7G1ooe2j4vjhQkGGOAeXlquQtVB7cZ6Lk\ngG6A+HZ4goX+yIOMb6kuHBTFkmDfxN1K1TjoEuaoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOj8jx0txPpB4h/aoO8Fgvale\nymowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALbuCGBPHF36H4F7cz8jQjdP9SwschnLVYwYxkOsGJKsAiAG1TycCBgC\nwJma81JBUddt+AkUbAsyFUAhjaQkokwZOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAT7/oQY5JDDZxzO+lyMuA/QsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM2YmY2MGUtYjI3OS00NzNjLTkyM2YtYjE0NWNjNTBhMjhjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjNkYWJiY2YtZmI5MS00YWQ3LWIzZjEtN2ZkODJhMWY3\nZGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5PmoYWlpvVaP7oN1r9VHAeTV\nIaEuR1tEB2Rp73bDDkpT2GVUCAzekmxcZwBV15FxrXD/ZBJbor6b1DTOhQi1haN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUy0KY7G8N9kjsk7p4FSBMv9yjoiEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDf2r1l\nTtksaiB+C+I2+n36HSdSCnySa87PLUcXD/1jMAIgMa2anOQEGvl+/ZFYAQs+/ker\nZshpRPRVTCGi5h+wY8g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7260", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7260` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAYqvspXgn4V3J4OKcjJIfZfcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZWQ5Yjc3LWUzNDUtNDI1NC1iZGFmLWI4MWZlODBmNjA4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODIwNjMzY2UtOTBm\nZC00MDUzLThlYzAtYmY4MWFlNzk0MzYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiTAAIIGT4zr5KbJ017TnSQ5A9rgiUTbXhEKSm6lSwI5ikmw+W2AsSGMFTZWM\nrhm/QfjXa/MAVgrf2fbrYnUDg6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9fMcvMvD/5oAhXf7motlKphSY4swHwYDVR0j\nBBgwFoAU7npvAqaaPsruYCMNQHo6t0n8Z1swSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA0DRQ3OtCqukYoteF2W42WnHYbdOOoQ56\n7JDUAqp1TNkCIQCwSHUvKJp5NZQvlSLVET/Y1EC91JTwUqu2p8Gn4QYpeg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdaqkB/z2rdhMDAFZeJRIFOoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmVkOWI3Ny1lMzQ1LTQyNTQtYmRhZi1iODFmZTgwZjYwODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAGaXXfPEiJqQiAZA3lot3hTrxTEiImBp2R7p2H//wt2iz\nEjIiGdSTK7VbATciKQPSAIsB5f31RtctdjqnUzvio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7npvAqaaPsruYCMNQHo6t0n8\nZ1swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUH51NiMwztzHXdvsd2v81gPzJMVLP0a7kuIKIRBRgeUCIDzkZLCezzKj\ncm58F+/K2Q9C24XfHTwinCPG5hY+WzR0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWBHe8ybr+9aStE7dkO3EHUUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODIwNjMzY2UtOTBmZC00MDUzLThlYzAtYmY4MWFlNzk0MzYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWE5NmVjZjYtZjhhOS00ODViLWI3ZTQtZGQxMjUzNDQ1\nNThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENHJLnKcLZgfCYpIvc8sfmW4U\npdZh5tBkWZiJX8VIXNk8O2HFRqAkAso24fttgw5mZDr6x6vcuTp5URMpTvvPN6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9fMcvMvD/5oAhXf7motlKphSY4swIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIENLZ1gb\n+iU7c06ESABO3lM0dYt0YYMn8wClUnvq6D9WAiEAlC5NuC3pTkk2ZufHbhUun3VF\nqR1GqjkUrcOcvcqQ1lY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7261", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7261` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAfOqUbX6aY3f6pZWPP0OfH6nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyY2VjZThhLTA1MjItNDM3Zi1hNGEyLTE0ZmJiYmUxY2NmNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVjZTVkNDEtYzRj\nOC00NGZiLTliZWEtNDQ5YTM3N2IzOWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQTYL4NX80uOddR8G1XiLjlPa+vh1MyhpW4RR8rVARjUm0bErHLVz2wuEpZSR\nWtiGD4RpqqlrhTLSnnYtbZ9dbaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJmEzxFStqkCKOKo4G6bTBUs3YNswHwYDVR0j\nBBgwFoAU6lr1Ffzd8FODmqMaWPZx7cReEpEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAvc/Bs68mJpdl\npYuquNzhgVls6II1O0P8Y1Yhy3Iv6o4CIQDn3SyIVDbfNxPzAcsK4A4l3s3I5r1K\nfj03D65X36sQSQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT1OKiNJKLUcAIH5P/JCoE4LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmNlY2U4YS0wNTIyLTQzN2YtYTRhMi0xNGZiYmJlMWNjZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATz5UOx/q24hKYiu8XUfgQlayWQKqAOhiRU8JaURwTnwNqg\n4UraZbYeQE+FpwqB73GbyvkNs4ulrcOXqjmreglfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6lr1Ffzd8FODmqMaWPZx7cRe\nEpEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJch5bR1hIr+3ajoB0cW/GMR9Npg2qXiJmH0FUk/NKZIAiBzyni7VM3/\nbluX0M2+BKq334Z96dMSunWczXBqO8/JIA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdsuCSoNLH6vQWb3mHGkCWRHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVjZTVkNDEtYzRjOC00NGZiLTliZWEtNDQ5YTM3N2IzOWU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDM4ODc4ZWUtM2M4MC00YTEwLWFjMjUtMjY2OGRkYTcw\nYWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyQrrjx83YQide99gBx1ty+jJ\nY0gtu3TNn+zMpw/Ltjb8UY7YWu59kkdbWmClYgi6ai2U0I+gHrv+aouC2wJiUaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJmEzxFStqkCKOKo4G6bTBUs3YNswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQD+m1zm\nJ3HAVSVTY6gb4B8U+/5HLytvy332d7mMmemNBgIgPOnobgXlpugTTZAGGEbQp+oX\n53e7xQOMwwY4sZb00FA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7262", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7262` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAb7RCZX9B+6UAynHdfeZ6n/MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5MTYwZjYxLTQ1NWYtNGYwNy1hNTIyLWJmYzI5N2UyYWE4ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY3NmNiMWEtYmQ4\nZC00OWVhLWIxMjYtYzU1ZjYwODcxNGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECB+JXXjHxphm8K+XFOtuZ5xhzLuh6XENHuZCpt7M2gUSHJXGXsGRzjDJjUFq\nZkceeJGdFRs1mQuYuJI2DUpxu6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC8PxQh1U52BZV442alDE1zDZFDIwHwYDVR0j\nBBgwFoAUoeJ7MjiW0M09bjjgafidFYqnfyQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIC7HxfkLtXsmCI5X22vzsW1Cy54avH6uhozlgvkkkGDeAiAUTPBPvDSk6Z7u\njuv1/0U16MmrzYBoD14mcHgZuNIqag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbfMZacn6InI6bN3sbLzf8AlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTE2MGY2MS00NTVmLTRmMDctYTUyMi1iZmMyOTdlMmFhOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5jwVBObwe6RLWuEHW1wJVWPJttzllHDFnpfSPEJXSRScM\nJdnfn2IawWnx4AvKxgCE4Estg5Zi7c2Nws9pwDhCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoeJ7MjiW0M09bjjgafidFYqn\nfyQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJYzP8Qruz8ZHQwlCBnquiWsoVJsVmn6QDjmDvYWFhj4AiEA99gf2G1g\npfA9mNgFsIbzTv+1LAnmqozDzN4XjS7OkX8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISATbrZClpsvLDpsnrqNf3PIcsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY3NmNiMWEtYmQ4ZC00OWVhLWIxMjYtYzU1ZjYwODcxNGIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmYyOTAwMDAtNzg2YS00ZTVkLTkyZTgtZDQyZjc1MDRm\nYjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcs7naVslrzIKmGJ30+nrVh2O\nA0bw/9VzCsgsCdHWHu1rjYxWwN3mNJNgQCuOomCZ4X/oM/gxKzYKFOAZ8FG0X6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC8PxQh1U52BZV442alDE1zDZFDIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAngxKPJ\nlabCHV/lUBKp+U+YL2tV8laEdyPfjh1ljf/3AiEA0dROV2QsAbTQAtiV0K5tZz46\nbFa40B+K0cwIiOX33n8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7263", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7263` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAfFUIDD2mcxBDo6GCMTNN1SqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmMGFjZjBlLTk3ZTctNDE4MC1hOGNiLTQ0NzBjNTkxOWM0YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM4NWE3NmYtZjc5\nMi00ZjYyLWFhMGUtZTg0ZWY5YTNkMWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX5KT7o7vlW05DQhxhzs0A/FIDVDWv9Ryfq+04xVocvC3EnmvR9l+c8Rfo/lQ\nSlEuomWBIuYxUvswJNdzf9GsN6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1KuFj0oTW5o9Htr8Wjrt1ITsVjkwHwYDVR0j\nBBgwFoAUY/ebQfhyXA6I72Rq+RPRfUGG/qAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDar/YOIONuYVj63tdqAuSuazIFXwyvbOoUtnBbOLN9ZQIhAOtClvqn7woU\nC8REqMwA7KMumsDeMd8MAVptSNrcnCG1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfY4cO/b1k+aNjZIxgCGfK02MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjBhY2YwZS05N2U3LTQxODAtYThjYi00NDcwYzU5MTljNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxb+CUNQzZIZiJiqJ7TyRrl0Zr6x7rki0223SCo5KDm8yA\n+gCnSHcKZPKMJeT978q+1TJDJX8ruZcfdNhDv2Xeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY/ebQfhyXA6I72Rq+RPRfUGG\n/qAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALgpcCDZkdmt4pbhZGUSgn4qQCiWzxHUa+w8UHdtJw1VAiAMFKPQsdC+\nAQgC55fXj0ztiVNFzORSQvTaB2cVJGtUFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQBWcsxAH9Cm/lF9fHERC+VXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM4NWE3NmYtZjc5Mi00ZjYyLWFhMGUtZTg0ZWY5YTNkMWQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGUwMGQ0ZWYtYWJlZC00ODZjLWI3ZGEtYzUzN2EyNGQ5\nOTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYWrVqUkWMWrPeJa7uj3lsBA8\ng59AVuebZ+qtnZcjsFmO4Fe7TNR7u9o8jDxxaU5500VbUcTFTJulVaunOPFUGaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1KuFj0oTW5o9Htr8Wjrt1ITsVjkwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDScgSd\n15J0uLKlzs7oPwAfL4imfvFpNA2PofXm68p/hwIgLqCKhl2H9oESFhAJeqgyxigb\n4z9XLcRzh0CJ7GcB7dM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7264", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7264` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISASJOgTgNzHaqPKCUChY3hoxRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjODliZDc2LTg3YWYtNDVjZS1hODRhLWYzNTZhMDU4OTU3ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODMyMGE2MzYtNDYz\nYS00NmEwLWFkODQtMTBiNmQ1ZDE3MzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeDe3qoOuQzLrVPs4wEmbnlSdBFfdRrLbQwinIl9D2bo3oLuoIjkcELCp58ah\nNrXNQNAGVV8vrV1rtqJStJnSNaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJh+54hjRHLL+2ja69SkN5hAPBugwHwYDVR0j\nBBgwFoAU/i9475iUfyqKITIKtf0I6SypUC8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBdO+c4MUvifsCUcd/jXPuMcJmO36Vm89hOEZkdNPQIQQIgcavCWtGdrjHJ\nX94Q8ApT95DUI47bFLRRj5I7FrdI0vk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV9J9JWMBuXRov8H9kgFftX9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzg5YmQ3Ni04N2FmLTQ1Y2UtYTg0YS1mMzU2YTA1ODk1N2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASF5nV0PLa5teh1mfYe5RA7jwY1hSgHuEIQ8+2PUX0uOySU\nQb/oC4UEL5S2hkpermbQO1TdHXpT3bnvWgoar0Gbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/i9475iUfyqKITIKtf0I6Syp\nUC8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdfbqz+mL3j0gV16zsw1iiseSL/4P7YROOJne419Y6gYCIH9b7Vs8xtzN\nyOFPr39TO5TKcg8kIuPAnmmcJXbXanMH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISASyKQf+TzF5mrQHTEA49FnMlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODMyMGE2MzYtNDYzYS00NmEwLWFkODQtMTBiNmQ1ZDE3MzA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzgwMDc4MTgtMWExYy00NmM2LWE0OTQtMDkyNzgzZTRk\nMDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGNlDwzxaGoi1KpS8PbErnanm\nsf+lxvXW/qKap50OL6OosP0wfheUhfv4cQV9ai1GMtIZoC7t8VVmCy+JQs7f9qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJh+54hjRHLL+2ja69SkN5hAPBugwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIB26/hXQ\nhuCuSLVJb2riPEWjWWI1O2RMIcEvSAK8Mf1tAiAb07bA0uDlvKJY6/vL3wMQlh3a\n+PsJKm2Ex18WKiVPEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7265", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7265` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAUUiMmONj5NS4TTlXAY6/NiKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiYTAyZWNkLTEzMWQtNGNiMi05ZGFlLTEyYWYxYmE3NDU1OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ4NmE2ZWEtZTAw\nNC00MDQ5LWJmOGMtNjhhMmFhZTY1ZDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEusIoC/pujR4I2+fBPc5FRwKsZjFg1QAjfhatu8/MOcRsvPwjms4gujOAMk53\n+MGoCTgZZVxpR9o3sM8kdYCbeqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc252NBt9UhFbqMyPJSjG66i2dKUwHwYDVR0j\nBBgwFoAUYiqsigDFl/C6O6Lf5WqURsUmbbowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAwkyRpouhCPIS0DKqtGTiy+uUoZPSFCRN2gS9QrPa\neJUCIQCUbFq56BIC1u0NTxZQZRATEpXuH7yu4/IX4yOa3KmRKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVTcWf2MSChNeiluG8k49LojMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmEwMmVjZC0xMzFkLTRjYjItOWRhZS0xMmFmMWJhNzQ1NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkRDTpJOGDgyabUZlJFVcvfozrqCltWFLMhiLjFVVV5TiZ\nsatdrGjBV6PWum9VrMsRpFoFOR4ctpuqyCmgWTS1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYiqsigDFl/C6O6Lf5WqURsUm\nbbowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJry21Mf7DnFlT40g4LOjfQCLfjrdq19w2qVdgWLuooVAiBeS+DafjQM\nff9GN9Hv18ToU5aid7H4SBtUaXq409QsPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAammfAUgS4azz8teaOU011CMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ4NmE2ZWEtZTAwNC00MDQ5LWJmOGMtNjhhMmFhZTY1ZDVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTNjNjkxMTYtNWNhMS00MzY0LWExZTUtYWFjZDU5N2Ez\nNzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEohFXFsl0WdNsjLvo/xTnYCvz\ndIdTHqAYwfEqK2j5W+5Mq9U8l8QLO12cuk7Ra47o2MYjmrBVrfEBdR3Mp1hK5qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUc252NBt9UhFbqMyPJSjG66i2dKUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCHGaOB\nfGy7QzgOQ98XQ6Lyb7M6qXCMvghCO+0r1RXvgAIhAMa/6seL3J8DIlbAlwRx8oiT\nlxlxsofo+oJ6cMKpAfnN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7266", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7266` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISATDYfQ7GB5WbGn017c1MJcBJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5OWEyNjY5LWEzNzItNDBjYy05MjA3LTI1NjQyZWIyNGZmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdjMjc5MmItM2Ey\nMS00NGNmLWE3NGUtNjFkZWE5NTAwZDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzCNE6kbBBSjYoD/KUTiZXRJzBLoE3shgFbQA2JiPu04Nw95Ic2ZEPAcksZ6/\ncLkGLeNC/zUmNAE6Fwdp73BCsaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHFa6FHto/9qkUJcwzd4Rwx64h5IwHwYDVR0j\nBBgwFoAUBPbkqPYoY18aQGt1mNgR6iMjUXcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBN+cNu1T8nhDrRnAhNkzCW3AcHBP+SWRDNOTIYxRls\nUQIgaIHWHk9dBcmXmiTZxb8ZB8aQA3omeIWFVRZGpW90LCA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdCu+vymFqYa2Sd4j9XmmFTzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTlhMjY2OS1hMzcyLTQwY2MtOTIwNy0yNTY0MmViMjRmZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWs/K74cbvL1EVUhMTUn3r0VwCQ6YJLu55whzk/zu1FDU8\nRKmsHcILrzL3DZtoEsdPSXkk16VZKID9iAXwj4Rmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBPbkqPYoY18aQGt1mNgR6iMj\nUXcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPLF0NfkGpR2TF0SIn+b7IbhPyN2fuQF9ziS9abZu62+AiBds007EJMr\nfd7lU2V4euH5E//R06o3gyZShkAntqqUTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAVrxPUrX3eg588hd9y+H6LmVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdjMjc5MmItM2EyMS00NGNmLWE3NGUtNjFkZWE5NTAwZDY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjM4OWFjZDMtYzk5YS00YTcyLTg3M2MtNzY2OTg0NzQ1\nOGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuOCS756odSDZPBM/U2tb6ctm\ndC9QSGhiTQc0mtAZHeHLxkvtx6E5R3srg9QvNb1qid9QarWNJfsWZaLl1LNuuKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUHFa6FHto/9qkUJcwzd4Rwx64h5IwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCnRU9v\nL+M4Hgfxdwxro+OjF8XMwkYBFF2ZWE8l04N6agIhAO+8lL4bzmZGHN4vMlbT2/wM\nL8aZq7yNjKjGkaF4MAmo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7267", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7267` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISATiZr9Lprq9iUt4w0jp5HC+LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1YjFiNTZlLWVjMjAtNGE0Yi1hYzY2LTMyN2Y2NmMyYzVjYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVhMTQ1ZWUtZjcx\nZC00OWMxLWE3MzAtOTc2NDNlNjRlMmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXF8pGNmwLrBj3sisXU7c1PaysIZdiX3HQUrjM1Ui1nO/SePZHKJU/odQqPNQ\nFIkxK/uEE+4ZcCfvl7FbQ41k/qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMG2McxmEcSLokznQFBxZO+elEDcwHwYDVR0j\nBBgwFoAUsEe4UVNKvvigOzf6Uw9gDqrjguYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBwYLD/X//Up6jwLpn7fZ/Xz3FmXNUnYn5K0XjT/4jGMwIhAIM8\nP7AEoUtbdVNOpcU6VFC10PyDRqCMKMaVsh6Ga2mn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfHZX6WnJYk8Xw4xDD+hMTL6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWIxYjU2ZS1lYzIwLTRhNGItYWM2Ni0zMjdmNjZjMmM1Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASX2oUrxbcB5bMekLu9h7SwmhSEF/jUBVcNBkDyQIrzM7C9\n2MevA7o4utOui1+ZrCxgmaZjiFCW50/nKvu/WVhDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsEe4UVNKvvigOzf6Uw9gDqrj\nguYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRbMjOi/H+nuq0R53s0KfbbfsDf0cdq/woDRFziNPV4ACIEV31QFHCXIY\nqqDbEVZmRCcUXRxV2lK1ZGK8JRvvUs4J\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAd68DnRQugBLwpPRfQaVvG3EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVhMTQ1ZWUtZjcxZC00OWMxLWE3MzAtOTc2NDNlNjRlMmYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzdiYTFlM2ItYWIzOS00Yjg2LWJjNGEtNWFkZDRiODkx\nMmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzte+tRVL3JnHovblLkRmW8+C\n2VmPaaKJt6MQ8VhqoJAYBKYQJpAIgfrh3RGXByCsE4GT9jeLoCiPVOBJFE4cWaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUMG2McxmEcSLokznQFBxZO+elEDcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDTtD0CM\nwHnVOvEuJNzoeT05jZpbpbQFopOl+ajVnPpiAiEAzmjD7xkHmycg2urjMJXRLRPg\n1ruZyAVQxIqt5nS1VUU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7268", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7268` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAfD91EnYa7h3WWedjfn6p0zoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkM2NiNTE5LWZlZTItNDNmYS1hZTZjLTYwMWFmOTdiMjg5ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk0ZDg5ODEtODlh\nNS00NzQ1LTkzNDAtZjQ0OTUxZjNmMWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENfaGE7fIWL5QvAHqEWufYdqn86zLyM1r0Oz0qeqO9erPpb5L7/Zw7zURO8u9\ne0NjJiwAKEdvoLl7Fzt6aycDNaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC9m15Ua0JlCxSZqD98RigZfNEyQwHwYDVR0j\nBBgwFoAUf/twj9eLlRNETAKh29vXfF5l1f8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAf22dOHlVpJgofmUnYknmhulAZ7mr58t+/\ngSRKLSIKjQIgRG3MvX6SE8LgGq3zE4OvWDoOyrMtobitlgPR2bY0IBw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZxkwaGWZvEqga2tgoTE6J+cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDNjYjUxOS1mZWUyLTQzZmEtYWU2Yy02MDFhZjk3YjI4OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3/KcW14CIwsi9qFwrBtU1UbUxxzbqBiR5UO3WfotItOTl\nIUOF/LrvGEV7o7GcUFK4w03S5nnQzSHx6VqhKme4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf/twj9eLlRNETAKh29vXfF5l\n1f8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKJCV8aWqCSjaknnLyWagFN7oEtMszDpNusmgxQNt+SMCIAxuRhk8/0Ux\nuXdKiT4JcpoTkVr8dI9ZDuHomjGFMdvT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAZV2zghkBmqalj47Z6QCI2m8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk0ZDg5ODEtODlhNS00NzQ1LTkzNDAtZjQ0OTUxZjNmMWFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2RkYjYxNzQtYjJiMi00NThlLWExYTEtMWUzOTIxZjQ1\nZWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJMD0w060J7AoIwy3GOCIPzlw\nfv+3AO/FA0PI/IbB/Upj5VdWOsrD35sS3Es5ZWTfdr/edwuCP6MSkbpjKiLEe6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUC9m15Ua0JlCxSZqD98RigZfNEyQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDN+ZKb\nFc0t06nAbD21/dEBssNuSSsXf+s4v4yKlsDeFwIhANlPewUwZR0WqOAR146Cmpyk\n4q7yrdJzS5f6YCJG2iFQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7269", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7269` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAcqdfvJwhRs6LevvyJVEzMRzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiN2E1OTU1LTAwYzMtNGM5ZC1iODZlLWY4MDhmMWE3ODIzYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRhYTEwMTEtNGZi\nNC00Njg1LTlhNjEtMzQzMzgwYWU2ZjQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEvLOWNId/vuYElFy27Hf5L97RG/pGWfKQjFUUGNEjwts4HtHs3CLCi6ZhYYE\nXe9hEc0Sth1gaCG2bYqyV5gJWaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCVXQvM/7HLDU4FWMf+iDzPvarQEwHwYDVR0j\nBBgwFoAUVK7LRP0s/JZoXS/g74plrbkHorMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA+brfzqZhBsVdWSPnDQ7sypcYbDKa/NpY\nxGN0Rkpi8DcCICLvIo6CiOH/af3XmCM731DbIXmctFiYIdJVDxiJEIGZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZnAy1kqb8STmtYYYISpWkvoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjdhNTk1NS0wMGMzLTRjOWQtYjg2ZS1mODA4ZjFhNzgyM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVyPTi8cJsmZxNEzxIJ3JZcncIKq3cMEKB3M2b27fkJL3w\noT5NpuK95TV1taxl/2+oJ0Og/ovEQq/3l2wjTR+Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVK7LRP0s/JZoXS/g74plrbkH\norMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOFqRdH0zxP9AWbLFqm2H/olBPkhNGxFYW0w54gH23/jAiAyNjdjW4Fl\nvomFRpqzqPbEDcSBp0Yja1fWTo+LHVfG0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUoh159w8/2TYHnCygDR9GkKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRhYTEwMTEtNGZiNC00Njg1LTlhNjEtMzQzMzgwYWU2ZjQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2VhMGM2MzktMzhiMy00Mjc4LTkzYjktODBjNTNiZmMw\nNzI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENrMrRqhQFmk9jN39e9mYleDW\nbKJIzovKkUNBUK6DxQDb/1BQyezaZ7UDSOKWLEra0H5ozZKEPXui/UmkAQdxC6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUCVXQvM/7HLDU4FWMf+iDzPvarQEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCWtQA+\nHEqfn/pXJnNdLtRDtwavpylneN5xJpTYqFL08QIhAL7tp9p/sbzbYT2PC+LMh86S\nriPT14wSNk7ulu2mfOeE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7270", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7270` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISATGUs1X2FQEDwUxtCRc+C4DJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhYTc3N2JlLTUzZTEtNDNkNC05MWE1LTcyNTQ1MGY3ZTBjNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc2OGUxZDMtYTli\nNy00NTM5LWE2ZjAtNGNhNDEwYThlYWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp5oxNa+qKKyEL7VTWkhoHEgzavkYCJ0jvvJurS4Kdf6PawGD/2kvK6cxVEn9\nyCIFWMC8hZegBUfPUISKU/qXwKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBrwGLye1Ge0msxp2eVyzaM3TuqAwHwYDVR0j\nBBgwFoAUc4O7bE2jTGazucEvF7e4zCNINCYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD/2kHjiedNP+abA9pMn9ukkip1\n/4xMN7AbxOY9X93E1QIhAMRYwUlk+pAc8xh7lVANkPMEe4NBBqiQMOTThmwgL9S3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa9UBvZFCtpa/RzhvGIv9cwqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWE3NzdiZS01M2UxLTQzZDQtOTFhNS03MjU0NTBmN2UwYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXJsrGsOSZNZ90+KR9WOsVJ9LMKyhvqaafRBQs2m9SjhYb\n+bAFgWnTn5BveVTaTnbAhMboUZZBMqEe5i6f0OPMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc4O7bE2jTGazucEvF7e4zCNI\nNCYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOS0NYPbBm6vuj262Apb8F8hK3E9btZrtu853MPvtHykAiEAjUZi7L6O\n7/RfrJOI8GRpvUiDIs3Zhcad5odoLIbkGGY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQDZYt1D/Z3ggbBXHGDLIjxDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc2OGUxZDMtYTliNy00NTM5LWE2ZjAtNGNhNDEwYThlYWY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDBiYTZiODQtMDIzMi00YTc1LWE1YzctM2M2MDFmYThh\nZjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9TeM0bpwTj9so+3i4uDZ3V7E\nmod/HIOLgjkDC4/P2exzvJUenD+Bxb6kExy1bQ6gZEvMb5hI2zPypNidCbU016N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBrwGLye1Ge0msxp2eVyzaM3TuqAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIE4+0+Q/\nCPkb6qaelN5hOaD4QBiMsnU0GDLjbuKj+pOqAiAXQtudzb5POhPKrGrrwYbLwGSR\ntwKsbZq5T6szSEAkBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7271", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7271` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAasnMuQ4yXQPpBdhybksM/XkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMDYxMmRhLTliOTEtNGViNC05MjczLTA5MzUzZjVlYTg0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE0NTQ2ZTItMWUx\nZS00NjU4LWFhNzQtNmQ0NjNiZjc0N2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiEv1MU2DtqffIXl3e9Q281GJnDyNp85HqukOV1LAPEu5cBkA11ZgYtki8AWZ\nxvT9VOV/M1T034AtXrcrZqCrVKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURNnGoeORiATskMIQ1Dv8v4bpKDMwHwYDVR0j\nBBgwFoAUltvRaFvMA4lNKDftdlkMzvQNvp4wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgQTtDD1/7\nFjUSk9tSjRYlHdNob+t7u1mVB3Jmpdm8u9UCIQDF/q8FTUzetCc5iEYw4bAeaQe4\nqDlOOJ7heTmB/Ago7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ4t/Joh9Z8+GeA3SsN4NGyHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzA2MTJkYS05YjkxLTRlYjQtOTI3My0wOTM1M2Y1ZWE4NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARe5kKx8zH7fWVRcJ2Mnlf6a0zM03GRr+2PPUTRetvHk5z1\nVS4kD3+HVlUmrgEXAkMWWIIEH/3EwcM7+JcncN1Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUltvRaFvMA4lNKDftdlkMzvQN\nvp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKoLRN6B/EXrNGbRZq82HqapOS4XixfL0HTj0xa2MCsBAiAUHIXbrssa\n4cz3avRza/Bbt3GG+tlKU8Ocia3rCOaPCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAYhPb1zg16g886bLTBVm6XVWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE0NTQ2ZTItMWUxZS00NjU4LWFhNzQtNmQ0NjNiZjc0N2IzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzgxOTU4YjMtMWRhOC00ZmEzLTgyZGEtYWFjNzc2MzRi\nYWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/48J0/M9x3qPzpOYMWldNVid\nnGIidWvDEvbEpDq5MzrVKAjzfOdohHIN1CheVlUEsoQET12HsoyTTx1/8E3YSKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURNnGoeORiATskMIQ1Dv8v4bpKDMwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCiVfT0\nkU98GycOnibJXFUrTJvgmcABwwtvMp8uohvGWgIhAPNj/hgtHwgPAATtH9VWxR0g\njb0JdNVk32YG5yxH0Cg1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7272", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7272` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAQc4VxeANbpqgcHVw5BfEcYJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyZDA5MmI3LWY0OTMtNDU0Mi1iOWJhLTFhM2VmMmQzNTI1ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUyOTM4NWYtNmNh\nYi00YjNiLTllZDctMTlkZGZhMmQ1N2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtyJNjmBZhE3P+mh9zQiM13Ld/CH8TlMe1YsM7lP9whDN62iQH3pVlyf1zInG\ne4ZnG5nfCZm8ioe7AaDEwPfhyKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfxSjIFPymtOwoalfuJwkvJqlPkAwHwYDVR0j\nBBgwFoAUlPdjSIoVdmFJ153a/OqIucYycdMwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgRyrHVHlO\nIZ5Y/YgcZPL8s87oKMmX6XfV2nWGS28xwP0CIQCBEI5AheV9k7jno/SBVo4uvTde\nZ5R+aNaLgnxASJ63ig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX7n7fIx5SMbpU6ZDLjUKehRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmQwOTJiNy1mNDkzLTQ1NDItYjliYS0xYTNlZjJkMzUyNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjDHe7DizEgc9gYDQ9xLW1tDh9zfcFU+6uud10ZoxJvIVJ\n3lJicXZ4Mce4ZvQDz/fBAFNBESCtf/E1z5/A1/doo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlPdjSIoVdmFJ153a/OqIucYy\ncdMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANo3LqBFHC4oDBCnmQC0oD9frrHko58IuslyjMT28VOqAiEArTPiUYRM\nWVbDQZP7FDQTYcwlwNeSBkMPKV1OqD8kf3s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAXig2H2T6lpzT9SaW8beDNkAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUyOTM4NWYtNmNhYi00YjNiLTllZDctMTlkZGZhMmQ1N2YyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmMzOThlNTMtNzZjNC00NWQzLTg3YmEtYzg2NDVjODcw\nMTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUzOnpKtBMYawTt8B2e75GxWC\n4+M0ExgKdnRsZAMKVvqHPisJnXbN+zWlVK23hXukPejzTB5q3ixebZjQisQmcaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfxSjIFPymtOwoalfuJwkvJqlPkAwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCQg/XX\n9L0rVOHKUab5+dskwZQ8fBakYvr2VLG2+TWekwIgfpJHT3yk9jrsTOQy9MNBoNSM\nGGENn1YU6u3UvWhPxJ4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7273", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7273` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAeh1YQ8BRp19tvmC41fFiEQwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0MDc5MzIzLTBlYzctNDI4ZC04ODFjLTNmMjQ2NWM0MDkzMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFiNDlhZmEtNjhk\nYi00NjliLWEyZGEtOTBkYzg3OWIwNTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElbwwB6mAT5gNXrnDVc1e4gP9qYg3rLOJrE/M/4VuMyVT878PAf9ry96f0sB6\n5e1epF/ZfnOR1qB7mEjSv4nrcqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVqNhjzJpXlMWlPIRm+mEB+LDHWQwHwYDVR0j\nBBgwFoAUm6uT5m4LPsa67dkSqSq9OJ1PVIIwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAzpFZoF\nfgv+ZSz31vE70zlO/OoZLzryDqr3UBkwYH0iAiEA9V3WReogZBmTbQrQ1acoJTvo\nuZl2swjQ6+ocxr6jD1s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc8dTWBENoy27DiV/Hey3WTwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDA3OTMyMy0wZWM3LTQyOGQtODgxYy0zZjI0NjVjNDA5MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbQK6dzlQoM5VRLHGsgbEs5J0S9nxH/4AREomEC9swTJWD\nmWZSDweuc92eo4hWFYIrBUyFQr+TQ/ooaDnbAXxto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm6uT5m4LPsa67dkSqSq9OJ1P\nVIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP5vSMvC/t6tTx5gMRTRkzbVpx36IPuIMz8+xKmOPts8CIQCdQR0tKgJY\n7Wnxxo+AQ0Tos/3lsd9Nw0w5G4Vdvy2rFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAfJhYLwuvWkiIA+V2NCLRjNjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFiNDlhZmEtNjhkYi00NjliLWEyZGEtOTBkYzg3OWIwNTljMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTE4MTBjMjMtMjhmNC00ODRjLWFjZTUtNzEyNmNjYWQx\nMTk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWQKQryRY8Ahu5X+9Jiv444YE\n3iJ+subjXKThn9IoYamZHBjWuT1Vf2iZ1GvqTQqOF/9MwxfDlry/OTpBrdTviqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVqNhjzJpXlMWlPIRm+mEB+LDHWQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGrFlrts\n92qMnZYDlp8urnWwDUxvttbOr6HGdQx2fSBqAiEAueMI+ndaut41ANbzUzmWjSJ+\n4Yc/hFP89oki2tb0y0U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7274", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7274` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAQO5sg/094EIaQCXZLqA3cboMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlNTI4MzM4LWNiZTctNDE2NS1hZjhkLWQ4M2QwNzE5ZTg4OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNlYTg2MDQtNjZh\nZS00NjExLWFmNzItYzk2NmRhYjBjZThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA3lSw0iuj5O6tmw4Rd54epxhXSzKqCrbqmSCLtTXc9v+d2LTBfdRy/GwkrDi\nIQSp5eUsF4Oai0scOXqxy7uHNaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxT8Fca5O96I8uOngk2JURuHHKB4wHwYDVR0j\nBBgwFoAUNkW0nFxDUN6l/7FLY1bztKzaocAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQC+q6KL7RxoDYeI8/VOeMqLiHOLm2R3q+Wkzsg2W+J+DQIhAKCJbXRn\nzJWDNYyIjwVzsv79DLYjgnfEHBD8Xe95TVQ5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZf05FeQUfuz+qzEj8miLg4EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTUyODMzOC1jYmU3LTQxNjUtYWY4ZC1kODNkMDcxOWU4ODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0ElwHVqB6hoaslnTPLtr8KMuHD6dcoJN8EITgcpeoBQ/P\ny7xThtsW9wokLCoRMZHKI9dkqUVo9Lu6N19bPXVMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNkW0nFxDUN6l/7FLY1bztKza\nocAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUs7mfVtzeYLHflzut/CMn2rpXhnMVK35kl8MYhCuIM0CIQCtmgWkEOAv\nEAJjrvAQM7fsdfO1FciQ5a5hqnToVMD5mw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAccPco2wvdP66faM0WlrDC5AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNlYTg2MDQtNjZhZS00NjExLWFmNzItYzk2NmRhYjBjZThmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWVjYmU0MjgtODQyYS00ZTdiLTkwNDgtZmQ4NTY2N2Fh\nYTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkV8RZu2MgXmMKCWa9dycLHCl\nm+cQJVSMwCNZWanx5NUtiyI42AF+efDA7FxJwFZ4B+EFFOvzmIPq3PHSzmRr4aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxT8Fca5O96I8uOngk2JURuHHKB4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCx+K4k\nnktIHccVC0khCGZs1QXq2xKNm7weG6hn6KA/HgIgJCUjkdIbRR/pllQVxNekER0I\nlCeZj93jPBXVQAJt2Mk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7275", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7275` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAZCLV/gYicttxZwEd0TZmh3XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhN2FjN2JlLTlhMmMtNDNlMC1iYWMyLTFkZTUxMmVjMWQxYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDJiY2M3NWMtNmQ5\nNC00MDNiLWEwZjUtNWQ0NjQ5YjdjODFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE7nuRysu5ThvbUjSIehc0xwnVKkVtekfgMJqdFGMg+E0j3M11dba0r4lPOha\n0t4/d0Z3CJ7Rov5h8mwyBDX7N6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEGbXLrtYlBdM3cyq3BxI4DKaMkQwHwYDVR0j\nBBgwFoAUXQuGGeAfE1akn0ClPZAqVjbtFSUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIBFDQJmAWi2yT1pZEpo3AhNfVS58ak63Y+cHFXr5x8xCAiBpw/6VV6EJ\nH8K0Ab+H+AcEBD3vwS9wfOOeL9+K1Nt0GQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQhv7EWgebVb2IY9WvTlEDFVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTdhYzdiZS05YTJjLTQzZTAtYmFjMi0xZGU1MTJlYzFkMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0ZUy+QkGZSWzYXYfngG8NkJioMLl7Dx283Rb4NIHbtVKv\nlxXmzq8+7zwEjQtdfux99a+S2p4LJYAFuzLRcaMao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXQuGGeAfE1akn0ClPZAqVjbt\nFSUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBjpd9s+dXrBwZOhAzxSJXUjURmMJBk12xWxHltkEFVgCID5eDuhQh5cA\n3Fb/q+nS38BmVR9HN9F0YDCcTyK7dCBO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdBpYTbB3I0tta0WG8yp3+gGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDJiY2M3NWMtNmQ5NC00MDNiLWEwZjUtNWQ0NjQ5YjdjODFiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTcwYmY1MDYtOGVlOC00MTkwLTg0NTEtOTBjMTgzODU5\nMmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERPB05zhmUfsivTlK3Oc8nWXi\nEdCcVRXo3n24fAv8W4+k8YH1UCttv0m8mhBHE/rOsG/1IIe88TdfbEtpybYvsqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUEGbXLrtYlBdM3cyq3BxI4DKaMkQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHsSJuzr\nahn1AKkCEcgKjNURG/EYHLgbykwIpse3c596AiEA3moxyA6FLjAv7jPT7hexAmDQ\n0W5IR+RJGIU1804M7hY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7276", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7276` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAWngJY/YN0jZgkrhE8x/+yjjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzZTk5MzBkLTMzNDMtNDBmNC05NDZhLTFhZDc2NzJkMmMwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNiZjIyYmYtMmVl\nOS00NGQ4LWIzZGUtY2YzNGVjMmE5OWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdP3bE0bCyxuciIDStCgVic7270/KlSS50KPI+DRnDF+71ufLHIpZe70wTU2V\ngtbznEa1Gxt+tgBH9X64p6fU4KOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1bhE3ShZYcl29B3KeNObafwnWc4wHwYDVR0j\nBBgwFoAUO5GvCgsWksHxjnTLLm0sWw0oRYMwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIBQf6iseKPhwxKu8xJQvyM5Gle4/ClsXcQV2cQvSUtHpAiEAolxCpxI6vaafyids\nljqVL8hDniGOS9uJkgzjXmqU6KY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYq3SODI6REohqcu/k7Kr+OAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2U5OTMwZC0zMzQzLTQwZjQtOTQ2YS0xYWQ3NjcyZDJjMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCocAUSHH8hYAuBE4MeOxoZSuNjPfGVrtEvDVtIY0EnAiL\nNcctAN/Mwb56HFu/onGUTJvp661La5tIod5cu3Xto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO5GvCgsWksHxjnTLLm0sWw0o\nRYMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfpRqooohyRaa8V5ZfARbPmzPwyfDHPRd8RzejmSdTHYCIH0x+lBZ+TuA\n2tbEczhNbmwjclrMCdBeKLpOGN4TbpOc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAfLrL+k2jzXsxGA0tzCiH/ZqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNiZjIyYmYtMmVlOS00NGQ4LWIzZGUtY2YzNGVjMmE5OWRiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjNhNmE4OTktYjU2Ny00MjIxLTgwOWQtMDU3ZGQ0MWZm\nYjc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEU75og2R0m+2bjoS+RwAwhOvU\nY4+iJuwvyPHkYf6eMO2ic+TMqPb9MQkYvW8fOksKJ/9ZqYMFRenNdQHOcQFmg6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU1bhE3ShZYcl29B3KeNObafwnWc4wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCv2j59\nq7/6xZA5AWshxdcts16Vtdl78qvUHyygus5RTwIhAMX5N8LBbeaAQACIRKWOzU10\naCEcTtKljiC1wirjpqoq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7277", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7277` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAQqQERZAqvtv7JGXBLWrl+7EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZjhkODZkLWE2YjktNDhkNS05MzQyLTQ5ZjNjMjc0MThjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ2YjczZWQtYTll\nNi00ZTZiLWJkY2MtOTFkMWI0NDRlYzg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgDWu8ijuSX8eBZI5PuipFAW/Ae/KrTVEnQOQTlYr1zSAaNJ9fjmjCJYjHZYa\nhyjGoEYdXE7/mMKfwjGWShb9/6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvFBLz0GUKlJbF11gOuKCwrE9ICcwHwYDVR0j\nBBgwFoAUH5hKH+IMBoHv0nz8ZI5yqJvKSgIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIF51Hz3HDTwegDH1zW3WBn5/5aB7OkpnYl1ZuLfiRjBnAiBR\noznDpWcUpKGimvi8kocxfoYJJXVIK5J+hT5YbP3Erw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWIXmuEcunCJIFAuuZAJA1cUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGY4ZDg2ZC1hNmI5LTQ4ZDUtOTM0Mi00OWYzYzI3NDE4YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiNNwbObbhZvPAVEmV5mJzm8qisQLXMZWTE6HFfwUGwzYZ\n0zQ1yJCRTaiibUvBIwMPbpYObOp0PdVdUO5M6U9Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH5hKH+IMBoHv0nz8ZI5yqJvK\nSgIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANyWWrwFFb1xQVq/JirwI+mnDBxdglAkCP6FHksdCtSaAiEAwcBDosOi\neZNXELxaQhv4PSJHJol5CocG3DWdProhAHo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAS0Fh54u6/cuKRsXEz5jmmwjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ2YjczZWQtYTllNi00ZTZiLWJkY2MtOTFkMWI0NDRlYzg2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmNlM2I3N2YtMzFmMy00YTMxLThlZTMtOGVjODA0MWIx\nYWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEt/4Y7hSjdjY0LqkVIO65ZRZh\n2mCKQJfARO7CkjwZf2dNgyLIGGcPzSZLFa3rSmxCNRC6foxgbs7m1n7+ZRiWraN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvFBLz0GUKlJbF11gOuKCwrE9ICcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDYF832\nOXCNn9q2BqmoSK995BozMMZ3aHIE5OEwxNIeFgIgB1aiqQbgAcCPCuqUgF0Bi+Pf\n87/J0+DadHJGeppzjdE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7278", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7278` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAV2JDmYBZZVOFi8NpZglGrtFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhMTY5M2FkLWMwNTItNGMwNi1hMGI1LTE3NTZjOWMzMjRlZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVlMTFmZTEtNmY5\nNy00MjIyLWJjYWEtMzBkYmE1NTY0NzFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE19IbX2aMDPZzYv0wOqAdiWwXx+UT6mJuSwT7lf1GnU4HQ13eO8SzqXEWqPOM\nOliMU0G55MQ3QyPVhdY94IKPBqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt5j8AR6HMvdJXnDOdm5SNbyzz6cwHwYDVR0j\nBBgwFoAUEJjZ6G9ZzcuMlxRZHHLJfjLvPucwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDcdfO/Vbp3PJ3QO8yz2uUmd0jMgzPu98Q45d1cOgowhwIg\nF2hO3D5Lym8HdXSJDDnu5zXOlrYuBbafiHt9+EbZSf4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATuuit4zOdcBEm3klWiPPhPNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTE2OTNhZC1jMDUyLTRjMDYtYTBiNS0xNzU2YzljMzI0ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcqqigttV6MfFIT0JN4VUxgSjsxc0S4+yZyKMTvBK6DQYh\nDfczZ5kK8CTd+73VgePS8DUyG/jJNRwTB+sJZOxso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEJjZ6G9ZzcuMlxRZHHLJfjLv\nPucwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ2/XnK5HrqtSwZApMpBRMgVtO89+SvFMsYgEwIN/tGUCIQCGMoEEe3k2\nARvDylxTb9WLVaknSRW1KPiIGCih1vkCxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZHNboIuwvMrrJ0klnIfaLf1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVlMTFmZTEtNmY5Ny00MjIyLWJjYWEtMzBkYmE1NTY0NzFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDVmYWRhYTMtZmRiYi00ZjU0LTllYmEtM2ZjMWM2MzQ0\nZDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDowQUVzzRd1mf4vIHragI+fs\ny2r1b/OfBf2G5gpgbYRDnef1gZFgIxqkQANKjaaAL5suK2jE4mtUUw7cYu9iTqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUt5j8AR6HMvdJXnDOdm5SNbyzz6cwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQC8gPBv\nKPdqzWoN29EJ2R/hz3VvuQSVTHMH0NizN2u1vwIgaoVD4w3DH5umiTINbQhB4xcJ\nWx/rejlskS6/eX/pKac=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7279", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7279` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfZTSV19b4W80ImmOrfd01AYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhNzY1NzQyLTVmNjMtNDE1MS05MTAzLTIwMDNiOTY5YmVlZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE1NDMzNTQtOGQz\nZC00Mjg1LWFjMzYtZDEzZTEzYmQ4MTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhyB56SvqJOel1YhbMnaU3lNkxSn5sbZwFarhh3E0owRZa01tJfj68TZvy71V\nIoTaG5w0dM5yhUijTVQsyKy4ZKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGQWTLTDeGeks/tdYWmumJ2xS2jEwHwYDVR0j\nBBgwFoAUhnUb+09LKQBmSB6FPeCyjctKaB8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIDCOMeeXQ5Zq\n+GT05/7AuZV/psoeaBlkziZ9JW2A68+lAiAvh75nXLj6xVqMmu4/isQfVjYz3UlZ\nZ4N1aumjSyZJWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX3IzeutvGK6fkKG6MqjWL6xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTc2NTc0Mi01ZjYzLTQxNTEtOTEwMy0yMDAzYjk2OWJlZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7Ulmt/ygtP6+zA5xfI+Hi8atg2GtUi4eBC4emhvOKeL4S\nxprU9g5iu6rNO39SWSBNz/P+t6Y/3OQdYGJ6C/uro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhnUb+09LKQBmSB6FPeCyjctK\naB8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOh9rKFFu57YvZ+1rLYWQ4VKfQblIRYnLhED+3+z0mccCIAC1Z1YSSwGf\nirG9kbi7bO64+HQ+G/lM3mAln17cuNqI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAcB2dhfX5XQO5yCHXUH6b+wHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE1NDMzNTQtOGQzZC00Mjg1LWFjMzYtZDEzZTEzYmQ4MTAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjliMTRhOWYtZmZjNS00NTkyLTg3NTMtMjE5MWE0MTRl\nZmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQDJEUUUxkWeLVf5P3eHN/WBV\n1OOpz6K3maaOoVz8+ZF7DS7GjFmozHWgnNUXwTVGY8tGFynM+stzLHc/iMZb6qN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUGQWTLTDeGeks/tdYWmumJ2xS2jEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAyCcJoW\n53LTbH69Wf8CItetGSImvYIfSeziWvsIdXShAiAyLXH28ilK9CGRAp+boIgOaXpC\nT995X0VTkW+mn1zZOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7280", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7280` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAWyeis2O6bR2t/udYO0+CKeXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3NTY5OWM2LTYxMjAtNDdkZi04Njk5LWM2MjY1ZjM5MGNjNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZjMzZkZWQtZDEz\nYy00MmI5LWI2NmYtYWUyMzUxOGZjNjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFPQH9CXGz3UvRdPVHs88RGxFtB0K8YkHmxA4cnAYhr9uFQ1k9yTczms9R/oY\n+yT/4YgVGcZ1EOldyEI2CVsd/KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOYtzXzbvvijmC1asBPRfs8Y4FNswHwYDVR0j\nBBgwFoAU6leozfonnkMGOdEYD8fVw/IkL8IwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgV/y6ak0//6qA8hO8S7d/M0MasfDsnc1JfP8fbpXBz/ECIE/ijr9WdwYR\n321eulfmdFqxpagq39jO5cy4MFNNawPZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa+eHIrBmjmYIT/PFVA05SclMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNzU2OTljNi02MTIwLTQ3ZGYtODY5OS1jNjI2NWYzOTBjYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsX6nNqDW7kFDrie2sWNVR81EehNVIM9AA0Z2/pOSO2Zdh\nERzb2HkaZYua4A6HoM6phvd4EUQ/6k7IDVxuAh2no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6leozfonnkMGOdEYD8fVw/Ik\nL8IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgatNGUqDvYCyBcieIS9ditV8p0tdLBxQh/dQHLqSEowkCICuw+hZKjvOO\nGr8+TNLGV0KU/a3T0RCDAHY7WUWMlgUv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdWjKmDrR6aJLd5SP6uvqQsCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZjMzZkZWQtZDEzYy00MmI5LWI2NmYtYWUyMzUxOGZjNjA2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2I0MTk0YTEtY2UwZS00N2JhLTgyOTUtZTcwZWQ0MzZl\nZTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgSvXH5L2LDMuJHKPgpLIjVlp\nRbG5FMs/h/unG5qWpr4ZgPDFQcDRdPqm85h+Pj7BC8wfZOZW760UsBRgVVILlKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOYtzXzbvvijmC1asBPRfs8Y4FNswIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCICLmwixT\nulStp8O835JgI1LZjb1Xa4YW3GpcnV0wGoiAAiEAvWaoqxaBkDEt8J2wWRCSoLV/\nraR8DWBO++eXW5dSKNg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7281", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7281` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAboG2VLRazF4YEdV2pIWi0EEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzOWEzNmIxLTU3ZWEtNGI5OS1iOGQ1LWZjMmU0NGY4YTZiYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWVmYTZmOWItNjQw\nMi00MTE4LWE4NzktOTc5NGRiOWU1NTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE18urvBnAQcKZ+uEkS9IMRE+YT6nCjDXgXhexqZcX9vZHTQ13VFCKTuEZZft5\nM5lkHsgwHM2ovbwt+fzsQoaV/qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxqRipC/oxHenv3oMKknkrjBGLvIwHwYDVR0j\nBBgwFoAUvaiAPi03/QOF1LhbXzYNrPCVMMswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAPiYHa7gfKjMKKkwDUiktS+ObUD/YlCabQ2ZEyG9UFNMAiBWYu2n+95e\nFMBGDVPcRPbwuX9ysyTdidbrWrRwRnhAKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATRSMfFdo0/ji+FXybkPih/NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzlhMzZiMS01N2VhLTRiOTktYjhkNS1mYzJlNDRmOGE2YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2WSXV1M45JRpqRxa3pryXm+9Cx3aqwnxa6snYnfnuEd6c\n3aWHUvuFt8f/+S+NgpzkSa64e9LWStJ8z70sUutNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvaiAPi03/QOF1LhbXzYNrPCV\nMMswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKwbQiolTYhn/ohA6Q1AjkaFJdFoa+pxCg5JKdq1tgQdAiEAulmlrn3J\n1D4w/sM+BLoxFWuHLqWBaLp9aOSybsJ5n68=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAY/bfXTK6R+ulm/jFGEOQv5tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWVmYTZmOWItNjQwMi00MTE4LWE4NzktOTc5NGRiOWU1NTczMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGU3OWJiZTUtOWFiMy00Y2ZiLTlhNWMtNWNlNzRmYzhm\nZGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPByM1w5GIYgHDU+/xS6KwAuK\nUFXEqUhNcVZykXnNKfzbOat/5xnsmzPLb3wrSa+hl1lQEjeFsLGPXMoVoIDZHqN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxqRipC/oxHenv3oMKknkrjBGLvIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDdeZP+\nEdFf2irNB4VuA6HS0GjYwlI5usQ5ytN+aFT6NAIhAP8V2F+U9ZOg0Kj9gXRSceM0\nPYC1x9LbKEM1rtNSJVg7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7282", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7282` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAc3X57x4cctG4RBAwu7fxBjcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyNjQ2ODZkLWE3ZDktNDU5Ny05ZmMxLTBmYjZiODlhN2U1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI3NDMwMjktMDhl\nNi00YjM0LTk4NjgtNGMwYmQxNDgzYWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5mJ9g6SdbNulcgWM+AHxvfcg/QoUYsk/fWz47fGt4QXcLTrcmVlhshspWFJb\nP9gbJWAtDi6+yODxjDcSSq3BN6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5x3NYmbd92d6xVoOIabKZGhUACEwHwYDVR0j\nBBgwFoAUHwWBjlyJQNWR1JEpniSkZofVPKcwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDYSA+zo4+5aKeuu+kIiQRQVQhFG5+nQNKu6CVHBxGzmAIgYmZwvZGa\noR9pGP5HL2bfwLez+R4HNwdvXZb3X/yIub4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXEC9pBFfc2bTKYbJ1FAFEfdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjY0Njg2ZC1hN2Q5LTQ1OTctOWZjMS0wZmI2Yjg5YTdlNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwOnQXx3pP/N/bFyP1bYQwFksuqVfF0w1Tc7ggNbRKEyhk\nnitfp3saTSR4HQGQekfj9Rqlu/YgxZePiG8EtDkRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHwWBjlyJQNWR1JEpniSkZofV\nPKcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDtUy8nfp5vvWzE63JQz+S2nQbg+7gEzS6OuGyhWy5pECIQC4mt9BXDgP\ne+LbDumJE9CmQBk3tLH5657ZPH8Eg9gmQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISASmFSdciTdL5LXBfBd2Y1XJvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI3NDMwMjktMDhlNi00YjM0LTk4NjgtNGMwYmQxNDgzYWUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDFmZmJkNzYtYTUwZi00ZWZmLTlmMmYtZjU3NzM0YTBm\nNzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEX7awZ+xmyMdYJ/6kF7A14IlE\nWypnM4TrRT2xr4Zo5qsbeGEuD6EQ48w3TOSbxfrDQvjGfapivkmX1yOhzHZFPaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU5x3NYmbd92d6xVoOIabKZGhUACEwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAXHZ2Xb\nqNXEfEQTjgrV5+kqc4xKPB+H7VtLWohMXUJ3AiBbbZvdLPVPBnolTZulp6mYFJ65\nL1AA92gFZpCfOEDrzQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7283", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7283` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAVmx5sRnAU7FI2+RwwTrPV9iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4NzA4MTFlLTAxMTctNDViZi05OGFmLTdiYTliNjZhNDJmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThlZGNhNzUtY2Uw\nYy00OGI2LTk2MDAtYTcwMGQxNWUwMDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO5NL7CqvfM7iDqC4jgtMSHpYqhEgTh1wZeseD1AT/ZgRx0+IICFwAuTEEaBb\nYvBBGDvhD/v3GhYb15n10fauZaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaUq3LElkknuC8vaVjrFzCK5fz60wHwYDVR0j\nBBgwFoAU3FP3zvrdLJ+qaOqpGtXsPpIs9F8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDrQbACLyv9F4+Aw5lS5BwQw3iTJ1R4QgmeJAcA\n92cvxAIhAP4vth+1Gt/TGrl6ldw6b5B9MQdrRyMChZdpDB305yR6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWzU9xdfkQAxVZqeFaWEfW6rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODcwODExZS0wMTE3LTQ1YmYtOThhZi03YmE5YjY2YTQyZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpTrM5GUHjlt5wVUvj1PKaWjQCAbD0mlrG0a22t9C9iU1t\nLntPfVNlruhB2ram8hKDGZaMma5+R7QmnZwWSJ8qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3FP3zvrdLJ+qaOqpGtXsPpIs\n9F8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLWSA4pd6aSQtGCjXrwDZanZbEHkgRKZZ8zkUr+SwfNwCIQC6curWcu74\nQ4e8aE3pyc9lXXttf1VyEeYV0QjbiZEJIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAbOq6eevvkio5zJdyK9yZjKeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThlZGNhNzUtY2UwYy00OGI2LTk2MDAtYTcwMGQxNWUwMDAyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODE3YWIxYWEtY2VjZi00YmNjLThkMWItNWY5ODg4ZDY4\nYWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGavHHq9dJfXmzHAESTyrtYGv\noysFfcAzglDcJSoFDV/gsKAUoZBVuMkkhD+1J8krzvHzU89gvEtZVBZPgtXm2KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaUq3LElkknuC8vaVjrFzCK5fz60wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIFfa2+re\nxw5jwcLT4E9ssVfBINsAxnsrM4Dw+yEnCjqoAiBQRK5YZ2sK4IaCnUTsdDWciKsG\nDTyvMd+UNTH9yltsBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7284", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7284` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAV199hcfLWu6OAVpos7lu/asMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwN2IwOTE4LTQ5NDMtNDljMi04NGE5LTBkOTJlYjY5MzFiYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU4ZGMzODktM2Mw\nMS00ZjRlLWI1NDItZWU2NmFlZWMyMmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+54JKsO5rzZCHZW5QQuLIarn0lnDpzeV6QolBZl/1HIM5osZiafWxM5FLkGG\n/my6gFnm178m3jyg+sGgZq7R7aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+6NwLgKo1oVy/ls2POWpxtg8Wm8wHwYDVR0j\nBBgwFoAULzdRAPepRifqCRbCt+dC4McSRJIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCAEFv3hPeFLUL4eVQqS1KjegZLgOLATwNPOZz+\n7RHw0QIhAP8Vt2rC0jwFDeGT/i4WESPuHbeZy2ev/iMkIhkee5bK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASVdkPrlUURPEAp3GkKccKIlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDdiMDkxOC00OTQzLTQ5YzItODRhOS0wZDkyZWI2OTMxYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3eI7N29ttsLbSkBtq2Ga0cQcUsUtvd56NkPHumuloIJcb\nS7TPImwq/UiG3/PtuwUvydlddFyJA4qWFhQcQ/jgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULzdRAPepRifqCRbCt+dC4McS\nRJIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANydPluehdtKhUTPPhyRRW8IEmb2gZ498bf2NZ+jwAuYAiEA8Og4Gd7/\ngGetYuLiRIvx13nR/pdaRNk74Oy4FSfV1Pw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISARsPuclmf9TmhWi2PAz/Gg9uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU4ZGMzODktM2MwMS00ZjRlLWI1NDItZWU2NmFlZWMyMmQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTdiMTFkNmItNDM0Mi00MzM2LTkwNTYtOGZhYWU4NjA1\nNmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZOX7wpFgQ+9nOLspJ/mKFkJP\nvsm/c3QRdMuX9/FODQsL2thmqmIb3fCRPmT/Xw7Rw6pebo2ix2iupLvqgfOryKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU+6NwLgKo1oVy/ls2POWpxtg8Wm8wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCPwIAX\nnxfAd29PSbYVX9K1gkf04bRIrfRd6gVSdATMewIgQ08L3m4rU/90Odefc0Oyzg4n\nuc14EcOYQ8h9OuJfz8g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7285", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7285` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAdBZw7fBMa9d+f90X7fdJagRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjMTBkY2JiLTIxMTUtNGVlZC1hOTc5LWZhNGZmMzU5YTQyMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRjOGIyMTktMGNk\nZC00NzdhLThiYTMtNmIwOGQ3OTUzNDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV6+0AyOEWdCuz/SiFnk4BQq8Ub5IUFPOvRptxZ6gmWCk9Ess6L4XXoUyoCHn\nIKuMb7TXMrzpznSUmCNuG8NcvKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtKmgxIOpdQlaG/DMExDQqJQyP0gwHwYDVR0j\nBBgwFoAUd7g7YhOvM1Aq+DZKsUVoNeSEyswwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIFMfL5hfqet+De0NCKCSL5mh+dHw52SlDL90YROx9D9TAiAs\nwQWuM++wbXqmI23OS8aC+5CjCnT896s4Bk3ZEMS81Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUaYm3RVW00boeXXkQlCBaQ0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzEwZGNiYi0yMTE1LTRlZWQtYTk3OS1mYTRmZjM1OWE0MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBWqwxGEeQbNT/72of2/qttaEmo3oNqX8NaGz9HaHVnxEG\n/rOmZyIVEjtC6EKI5ct6sx2RgVDhMno41gDZhMX4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd7g7YhOvM1Aq+DZKsUVoNeSE\nyswwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQaV+jW7itdTKBmrNA18QIT7tPQ555ewdlIoXmV+wft8CIEFRpUv7gze1\nnXfwoh4wITnLdTZ1HlToCduNRUtJhuaF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAUGe+CFwzAzNKxVDXRDpTetTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRjOGIyMTktMGNkZC00NzdhLThiYTMtNmIwOGQ3OTUzNDg3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQwNGZiYjEtMjRmOS00NWM3LTgzNTktNGJmODE5ZmRk\nN2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESbJAYNFr3gT5P9YU7CXShKDm\n35psCNvnh9i3qd4MYphfichzPbvldgJX1+ylBa/ymggOX08LrXCIpz+A6DCvD6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtKmgxIOpdQlaG/DMExDQqJQyP0gwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBIdEMvT\nmfuUFPhPe5RhHHy1YX+bht+TuJfo45p2DTVwAiBv78iLhPBZkLHWaVIWPQhjWqSs\n1vdPiOwxpkShjRcq1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7286", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7286` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQ5XvL1VNMlb6AIPQ3Ch3UOJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwNGJlMjFhLTJmMWMtNGVhZS1iNDY1LTc4YTk3NDRkMzQ1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjNmMzY1ODEtZGY5\nZC00ZmE0LTkxMGUtMGQ0NjI4MzdiOWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtqpXh9wQpwbns9PZsAsXWuzgFebw80ycXR4I7d32tLePp06ctDtDRNW+blyk\nXK63cvkxnwKSsNrxeAnCj//CoqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn1onvx4lCK0/l+TxemYSuK+HxWIwHwYDVR0j\nBBgwFoAUDV6r2GhLNWVamr3P3IOEPSSyK10wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIFsfzUi4BaHzdYYheH7627o14jMwFpzK\n1LQZVdIB3ge6AiANfCPC3osphx5zE4zreO8zZCOE+71z+kP92Nz7gDIa6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXmnUm2zB9zz3IvAC8m/sLCKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDRiZTIxYS0yZjFjLTRlYWUtYjQ2NS03OGE5NzQ0ZDM0NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjsvfHVLypwFR/omEGYmZx9BBq5F21gpLMCD3CVlNdRRTw\n0mgQpAaz36aYCUQe3MKU34F2Zo45Bp0pIWlw/559o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDV6r2GhLNWVamr3P3IOEPSSy\nK10wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPXg7jI7QurTOdSCfKVMMtG2Eqqgw+Eim8lTwRA6t2cOAiEA9yG205Cc\nrGXrHhdc1Ln3ZvyrHTjMNcLwlL/HtO+9Urc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAdbeKxxr6hcLw6lOeE6uEuQnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjNmMzY1ODEtZGY5ZC00ZmE0LTkxMGUtMGQ0NjI4MzdiOWY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjc5ZmFkZDctYjlmOS00NTZjLWIyNDEtNmZjNjE3M2M5\nMDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoUIP0cR7q+5AjdZWDlYBaAVk\ns/v6318WU3mtTvVJ565YH6y0FX8focu2MaRHURVdlpOl05br8gU/WGuKWx0goKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUn1onvx4lCK0/l+TxemYSuK+HxWIwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCICJA11vS\nYbkg3QpTown+6GOnU+Szkvx5BHQMYrZDpP4eAiEAqNie4kcEojSoUiYD18jhOVn8\nph5IJUjpZDA/g6dbYwc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7287", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7287` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZQrjX/6qM/fy/VhJ6rpVu2GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhYThlOWIwLTU5YTUtNDAwMC05NDZhLWFiNmJlNjMyNmIzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVhYzg5YjQtM2Q4\nZC00ZjdiLThmMzMtMDE5NzNhN2ViOTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtyrOjoS79CKgyqEP/6i8bGPQ0BxnGiEWTSpQ6wAKvb4kOgjP6VH3ksohTbqP\nBjyhqf4zLRMZTsTLk74B46cU9aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpMw5qZ3rTUKBo2s8MtfVwxD90z0wHwYDVR0j\nBBgwFoAURskDbBwswczLcFR8PMDm609ZEd8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCICDBUFbrZeqx+HmWe6N1o/htdUaUkJWF\ni0do2n1YtpkHAiEA6ORE4y2/YPlWZvTG3pBAsi6rGJinTTjsFBgQwESmvuU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARE9CNEOngqPEiUszYNtwZEAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWE4ZTliMC01OWE1LTQwMDAtOTQ2YS1hYjZiZTYzMjZiM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9WHjN8NyKZPDdqaGGvyfYve7eckpezR9LgeJl5fxdnbXK\nm9jW8xEVPMToXg96i17KNXuDe0rA7ScxSt0L+HZ0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURskDbBwswczLcFR8PMDm609Z\nEd8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD7GvFtzYjyYQi2n74U6/MgVtBjQi5Znw0c1hUVDt4ksCIQCOi21Mg1Lf\nO/0itSIaiQDPdNRyWJqNv5BproPeVRVa3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISASPueaLHT/NSQqRZjlEb0DnaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVhYzg5YjQtM2Q4ZC00ZjdiLThmMzMtMDE5NzNhN2ViOTUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ4MGVhMjItZjA4MC00ZThlLTllZjEtNWY1MDk0YmJh\nM2JiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQc2Hd3tbLf4aGHD+IRrsPiyg\nOiTmERySBdZp42vlgxp4ZPShOxUbvWleXkXTu9NlgFvDzqZM5VMzNSf0KsboE6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpMw5qZ3rTUKBo2s8MtfVwxD90z0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBIxNKrg\nMvkzuuZhUbsGHaJktFg+t1cDriJDlBdFlhnXAiEAnDTod8aO5HrrAV6ej2RKopPI\n7yLQYoAIRvnAEjY9uag=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7288", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7288` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAQBhP4XiPFCPVlI08Um5ggL9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhZDY3NmE0LWJiY2UtNGNkNC04YTQxLTg3MjNiZjRlYWFkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE4MDcwYTktYTUy\nZS00NTE3LWEyNjQtZTVkMGRmZGMwZGQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEldhPgkSe9Eoq1uf/9LXQadF4PguH5GbIrbr49BJnvscAjaZBs7Bu3oVWUevF\nhJPfiR7qUTt1YsDfOHEBq02dmKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvjZknXktRZi01Kk3+HJgp4rkwKUwHwYDVR0j\nBBgwFoAUZorwdhMwXFsVnWc3eK8+tpwlfVkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIDUVmF4wyPX+\nyHy0nibvKOigUSO/dFjTXbVfMmk/T24eAiBpAUgIP7v1HPVYwMo1EsTGTh6yxhyX\nTwUTcu1XPQyuxg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcuawYtFvY/m5IjsTxQODSRiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWQ2NzZhNC1iYmNlLTRjZDQtOGE0MS04NzIzYmY0ZWFhZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6jJWb5LpUWcz8vSGaYojzk/o3xWetETK8ewdH8Pq7/c5M\nIAE1/h32jcl2g/QSRmRl1JTXk+KQv5Lx8nt4qqZ8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZorwdhMwXFsVnWc3eK8+tpwl\nfVkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgR1XG+VHsYEZE2Ha4sDByZXSNjfacufB362yc+lRjxb4CIQCTY9KfeRZ6\n2+nCXSQLcGtkXKxCZntRoZcwhyNWuBPZiA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAYR/wPq5DZmsNe5PficfemtTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE4MDcwYTktYTUyZS00NTE3LWEyNjQtZTVkMGRmZGMwZGQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTYzYWI3ZWYtZDRhNy00Y2RkLTkxNmMtNmNmNWNmYTEx\nNDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFDpSysk11LhHEe+DSCVtwOH/\nw06S2aZE8GyY3n5gWOiy98lr6sQbcxwhJLZL0xRpK0U9H7VYNDLcUY+zxP+AoKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvjZknXktRZi01Kk3+HJgp4rkwKUwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCICMwcA+w\n9I46KNI9VFcc1WM/W7xPwvV3LWMZRDKh2ikeAiEAtMJyWHsOiRiAaAILX+lkip9e\nLVNc8CvOP74hHLXcZ7I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7289", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7289` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISARbQ5C/aIgh8TU3br7o72bncMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyZTRhN2ZiLTJkMzktNDUwNC1iYjZmLWJhZDIzMmM3NTE0ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY3Mjc4ZGUtNGQ2\nNy00ZTFkLTg2NGYtNzM0NWM0YTg4ZWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDgOImjxyyINNbaNatKFWX1K/zfE3lxcopS2MJYk1sHaVHpUo1HvgWxRXV+Nf\ncd7+6bTztK/y+3vtpuTxLHe92KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzKWsHQ9FFpBQTidf2yJNYEVNQcQwHwYDVR0j\nBBgwFoAULUE6OTrIO0MLZUWM/vaVpc2+npowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgFtYBVLedu8D49lAZlw99jPnl2EN++sYrR2dHb2Ro3w4CIGweIrZUBu2+\nWyVLgHBDKSiAt2zEh/qjaYgKgSM63fk/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYW03cg5W3FjXPF4jwgnKAC8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmU0YTdmYi0yZDM5LTQ1MDQtYmI2Zi1iYWQyMzJjNzUxNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnjMiCA7vQPaj3KVv6kJ3L7xkPR9mJ/5R29WYytgf3MZ+F\n18hTYabDoU4TjOVIsLm/1kR77amj9XGrrRX7R7cio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULUE6OTrIO0MLZUWM/vaVpc2+\nnpowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANL467tNlYSZwJOI+1S8UMCBrwdkM213xDQqt7knUBizAiAOnD39QftS\nY9KWhmh2E1yHqFcTFdTODrZqdZA9Oj+0Cg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAfioGakXdTgYtnKkg2uIgtG9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY3Mjc4ZGUtNGQ2Ny00ZTFkLTg2NGYtNzM0NWM0YTg4ZWQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTczOTIyYjgtMDE0ZS00OGU5LWFmY2YtZGU0MTZkNzlj\nOWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElQeGU8AagceCGIuS0kEMqXIN\nygKXlMpqDnp/FAoKJDicSE81Fojem0uSak92lWvMewVrmiRPA0CupCQ5zbpG7KN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzKWsHQ9FFpBQTidf2yJNYEVNQcQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAFpYuiG\no4yV+qkVS7L6+YoGw+Ei6PC2H0P3GuO7N0EFAiAY7pKEf7KvjgvR443Us0cFfMbr\ncRaSqQ33jumwVxtjcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7290", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7290` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfidVPz1ljuYe4EAzS2vX3XWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxZjg1ZGNkLTc5YWItNDRjZi05MTJiLTRkMzg2NDI0ODA4MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIxMmU2MzgtMmFj\nMy00ZDFmLWJhZTMtOTE5NDQ5NzE3NTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf8uBbxr7e3YIfXKy1E3Zb0z6mXYbouYMOGT5HUeBVThF/uyZSegBO8ScRIMu\nMJWRrPz9wbletcpkYrnu0wVs4qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0NH63MgG/5sz3I24sxGW/mN0xqcwHwYDVR0j\nBBgwFoAUtMdveNhezqcw6az5+skC1uwN4FswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhALsBljUYwuInDF63hLUjVRbocliQMm7tJEOPO8Lbe26oAiAVyWl1VHIZ\n1oVrDmdWoSOSDB62PDcOfKCxj1WpT0Zn5g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYFIzp0mYIf1G+/l1H0sSmtuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWY4NWRjZC03OWFiLTQ0Y2YtOTEyYi00ZDM4NjQyNDgwODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0QLjl3SZUEgpasZWRX4PbTM2tV5X6uB4KEIvUeahN9sYt\nDkoD2iZVjugiLisZnIPxnE/AfWkVQacLhhmWwgG4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtMdveNhezqcw6az5+skC1uwN\n4FswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLAyaIxaX6F4PcXvutV3CYiyOiPVsg601QrLDDjqvt6sCIQC20Z4yuMh9\n+qtxIBydbdDOA7ajdpVJ2t3vOittkpCJRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAbS0bpAlrp4gRshs6wJyQplaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIxMmU2MzgtMmFjMy00ZDFmLWJhZTMtOTE5NDQ5NzE3NTNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjNlMDMxNjItNWQ0Ny00MjdmLThhOTYtNWJlMTlkMzk5\nM2RlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQARMceDDyrSTcPRMpPWVvq5D\nnK6U6NqcoVoEEoaFHo1SREz0QKvGxbORvmZeATb7/S0ew/J7yKlfAqC/6ccC0aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0NH63MgG/5sz3I24sxGW/mN0xqcwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHoj2qns\nCo+5RcfiTfVnHIPwcgJUqtgl47ZvUGMiWRyOAiBxVuHKDzzZVwkhJijZXChjdjC3\n0IuT+AEb/cGxQ4RETA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7291", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7291` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAYCeUj/jqJrNWxPUgtWQOQr/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiZmVkNjQ0LWI4MzMtNGFmNC05MzlhLTJmYzgyNDUwZGRjZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzM5ODgzMDAtOWJl\nYi00MmU1LTkzM2ItYjQ1YmIwMGVmYTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1ck1I1FLQSCZYF2fbElS3hkfNYsKSkcbTGwrXg8fzFiYQHhaPlte9GVUYao6\n3Prk0L2yzWyDwReFUmQs7Sq/saOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUovPHKWftZcYq0kmFgNWY7dSFMQYwHwYDVR0j\nBBgwFoAUA0+zsaLuOedX+KxwtydmD6NTwnIwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDq1a20MvILSJDZsPER5USEirDB32VADLRyv8xeG0GOwQIhAMH2Mfxb\nPR9f/UKI0TQdKCHz8Kg0pjP9rqd+287iKaJE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR9ZymbJlLvkl20v/czJmg1EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmZlZDY0NC1iODMzLTRhZjQtOTM5YS0yZmM4MjQ1MGRkY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrSZ98viQF4InSA78DfaV/Q12P6W53pk6wNqATrPOzQHn5\noAkrEyUrV6tR0/jjCNDojoL2zuu4hZwJZYtw1mM0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA0+zsaLuOedX+KxwtydmD6NT\nwnIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVidhSEtiDHFLO5BbXGH2OH+TEqxk5TPGV55DrOdKnXYCIQCX/+7j3sz5\nDsERCJChfY6T/UUQCaOz7GxpVx9dJWOuHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbcbEwgkLDC2vc/c1dDYvmG2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzM5ODgzMDAtOWJlYi00MmU1LTkzM2ItYjQ1YmIwMGVmYTJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGUyZDFlNDYtMjEyMC00ZTQ0LThkNjAtNDc3ODQxYTdk\nYzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE14+HsKVUf71KhBKl2jYu4NLq\neUXrDeBsxlQhb+CTKliBDs0fwfZwXv4QFyry4oqZaM7Q6PlEIbBAMstORqTkx6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUovPHKWftZcYq0kmFgNWY7dSFMQYwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDNziG9\nXFzSGPKP4dW+teKROYXq36c0Qfv9FeOgKjhniwIgfVFt2sVg3uy9TaR5XJJkBJzH\np8JBBlryUAyjiU3cokI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7292", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7292` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQ+e2MTY6KlF1MwQhTsbxui+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmOGUxNGMzLTg5YWItNDgzYi1iZTBkLTA2YzI5YTEwYTkyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODRlM2VlMDUtYzhk\nMy00MzY4LTkxNTgtOWQ5NTJkOGZiZDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECn23ki/Aj5XJMiHtrwOZ2oHeB23fn0ftXm7ZrAl5SpNCz3jhFoP7mAEsmcsv\ncIJNF+iKoJrvknjIhoKHJq+Go6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfI+Rg7HSc6ZgDVLmlAQYvQukH/wwHwYDVR0j\nBBgwFoAUiB2V/bNI2E1j8cKqrVGj/8q1gFgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGf/0TmRmOO8pIjoLWke8xCeZus5yfHOntGh7F08\nh1DXAiEA2iQCWqOgxRBPxsH0MXj5YV39+oqYzBCL1b4vuAd3iQY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAboFoojXfAT6O5Pl/O5cm3T3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjhlMTRjMy04OWFiLTQ4M2ItYmUwZC0wNmMyOWExMGE5MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHUv2JBKW5zoRe7Y/1klPT7OgcUcRCjHM+bCPl8DpzWlyB\nTBTGGj8IY/HvwFdPhzPUSNfFlOcRna5Y0hs2ca+8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiB2V/bNI2E1j8cKqrVGj/8q1\ngFgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOZvv1cVZmVFzm9VPFd153oViAxOXXfX0DkDV+mKIaF9AiEAw97AeHje\n3Wj9sXygt88m04gaK8kbsz1F8LI2BFpjaHA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAS1/vxwnK62gYJBemBKzELxqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODRlM2VlMDUtYzhkMy00MzY4LTkxNTgtOWQ5NTJkOGZiZDkzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk2MTBhZTktZTdmMi00MWJjLTg3NWEtYzM0NTY0OTMy\nMjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVKvyHnytpSswEvPSsfJM2nkJ\nZF/ZuL5a2uyLaBycJmx7Vgv2XFLxI8C+ERQXHyWAW78Oe7jsCMGKk1SLsiFUmaN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfI+Rg7HSc6ZgDVLmlAQYvQukH/wwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCB5Uz1\njxOCzvYZB5NHEklxvYQlZETNuuphhduF5fUqkgIhAK4cGD9LnfDmzgvnpvPZGIci\nd2M5/JxlGMlGrYhSh2Vm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7293", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7293` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAZS4i159cN66fjWyKrP2iyxcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwZjg2MWM0LTk0MzYtNDdlNS1iYzFkLTM5NjJlM2I4NGRjOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY2ZDQ4ZTItZTJi\nNC00YTgzLWJjZWQtZjViNjFhNTY4ZjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0x4xnXXy0yIOF1fJaomQ3sOG3Y9ALkaX5NNBGHptfDG8DlUUaw1RSBg7AX0O\nLp3pFBdkxzDu9yh1I4yuU8lKm6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6SDv25YR3GYcEP8TQcI4XuNK5pQwHwYDVR0j\nBBgwFoAUSI1dE5p7xsR+zB32DCNECu+p0VcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCi0WWxzqGkY4VwH2W+cxs80w1qMhFdLlguDMwE\nzCTrTgIhAJPxgk6/DxuB5DCpN2yjs875a+6t2o35Ngtj8IngmRc3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZpQHT4UHY2oPFZYAP71CoPVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMGY4NjFjNC05NDM2LTQ3ZTUtYmMxZC0zOTYyZTNiODRkYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQC8V1sRUv7sIUObuxDB2SMZ/cDB7uMILQie0pAP4rDBNfd\neYqFZOlC0AqmmV1QmUGpWFMdCSzj4WUVPNFpZBp4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSI1dE5p7xsR+zB32DCNECu+p\n0VcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKROkK0biTjELk9JPTtLOf1ueiewdyhIY3XBvrGNsZf4AiANFt9cnGLM\nrQoIaL+uQCheVXGoTn5wWQudNFu0TZRIQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAW23eZnGRfhHVhgsOcdu3iZ0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY2ZDQ4ZTItZTJiNC00YTgzLWJjZWQtZjViNjFhNTY4ZjViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWZlMzU2NDktZGE5ZS00YmU4LTk5ZmYtMGE1ZjBlZDI3\nYTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKhV617rC8QcDy+Riw0w9R5j+\nAs+GF1epB5f7DjM9A+9MYg7ahdICyR6dVyzDXIPryEzobKhdD//iF4yDcIzZMKN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6SDv25YR3GYcEP8TQcI4XuNK5pQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDoXWdW\nr5HWZ/wkofWIThOR1sdKMQu1oyMFizC5hpIzXwIgQX8QVDbA3Fh555UcODeYnI9l\nCXprH6yv6bN1iUij8YA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7294", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7294` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAXUgYJF2VbV4uRpcsT+eOWblMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5NGEzMjc4LTJmNzctNDI3MS05OWZlLTQxMWYzYjMyM2M3ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzljZmMwYjUtNTY4\nYy00YzZlLWFlZGEtZGVmNzI3OGUxYWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuqypDlS4SP6eBCUbVNJawq/m9D2j5LOmdSy4rXDH05Y891aXNCo+N8CJsZ4t\nzOTXt3nWYmKly1A6wSsZrzwYnKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkfiNu5fou2H+pP1Ih9MQ0BNo0CQwHwYDVR0j\nBBgwFoAU72+x8Ku5g1pJRU6fLZKdUQx5fiMwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDY+pHX8qkO1KL//kYNQH+UIlu7/4l7ZNxZyTFMFznK0QIh\nAKkwCkB+5ON5pgNWYaryn6MIuIjeG7qcmwof8RJQ/+k4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW3oIZieNkFXrU5S3h8fUp6yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTRhMzI3OC0yZjc3LTQyNzEtOTlmZS00MTFmM2IzMjNjN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqdKtYAdfpGcK8pMwWmEECE+9VEpFJf6atwHRj5UKP/13t\nvk6zlo2izqo80bOFVgJLN2N5BYa8ne0DiArwhsDto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU72+x8Ku5g1pJRU6fLZKdUQx5\nfiMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPrbzbANRM8wiygPsRcnl811ivwwRegTFVyfEAjnWWDKAiEA+IkNmG/8\nutyz6vlzmNruVp1UrxY9Vlbcpe1FPyaYj68=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAdUFThxblldtjuInBq3EHq7nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzljZmMwYjUtNTY4Yy00YzZlLWFlZGEtZGVmNzI3OGUxYWE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjk3NzNjMTMtZTRiZi00NmZjLTg4YzAtN2NiNGE2M2E3\nNWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmPUtWO1QYdrzO2wakOOyVKKD\nQ1183DsGHf+5baY2/4DbZwSZiU97WnE9aUyWHZP2LsZi0FwzC0bcwpNkDwg7I6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUkfiNu5fou2H+pP1Ih9MQ0BNo0CQwIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIEJqva3w\nHdtKXjL3UYS0yBzlVI5f3tTXYqyeQkyXEnoHAiByi45u1tcto99M5OdQTjq3T6Ya\nT0JJEWrqzWCJMNZvNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7295", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7295` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAaZqHNdg5gdfntzFVBODssKzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNjBkMzk4LTVjZDktNDEyNi04NGI0LTg0ZmVlYTRlMmIzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWIyOWFlMjAtMWQz\nMS00ZmY1LTg0YWUtZDEzY2M5MjgwMDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQzrFfL0iOxKvT+S45mQPwphmrelbgIVpQwattsZIbxgpBQ6zmSk27UW1KdMq\nnYs8juoxkgSwb9aeLz6kx8uIAKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFf3ru6BASqe52YgDaKEU5qPZFkowHwYDVR0j\nBBgwFoAUMqah+r93tXo0UZkEzhNPaQhfoHYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDC9KyXB1c9oRlnm7MuhsnqTxLG/Xggr\nhmMDCeE5sAiyAiEA57GfWBIRwBPXz/0WlawwKcR+lle1uMLFSCXhxoJraIw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaYiPpLWsQKdJ4M/hzsC7SLRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzYwZDM5OC01Y2Q5LTQxMjYtODRiNC04NGZlZWE0ZTJiM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq0xBXzpvkdYg31EqnsdogyhiesnqFzypD+Ql72sZQSezp\nSdAOQZFoA2CyMH2ydMCRu8vdf91JXG99fOxXRY5Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMqah+r93tXo0UZkEzhNPaQhf\noHYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ4zpWFWtnNJLuPPRaNJ26e2rFLea3FFAC1rfWPmGpKgCIQDcLRAJpCsB\nlyc0G9u9KNLTx/gj7rqWCy9lEZwYX6JMug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAZmlB2XTXpNiWixzEUUo8JlzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWIyOWFlMjAtMWQzMS00ZmY1LTg0YWUtZDEzY2M5MjgwMDA4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTJhY2YxZmEtNzQ2MS00ZjQ3LThlMDItNmQ1NWQwZDFk\nNzhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETq84LefKmLlda8A0Ngd7FTwe\n3J61PalcSkHJt6nuZoAHFnCZP7sPZqRQEN+d9bOz/TsRoQL1VBWoFhD6XX307aN4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUFf3ru6BASqe52YgDaKEU5qPZFkowIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCID0ZlOXH\nW6sQlnC7nt4cbJzcFIT26aoc/gleWeSZFl3KAiEA6K1UzA/cq/yunBAiexvC+QhL\nJJi+L4nGwg3pOd/iuOU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7296", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7296` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAUkZ0Hip8CWN/79dzRIb7dYBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4N2IwYmEyLThiYWYtNGJjZi1iNWQ3LWJmMGZiYzA4ZDI5NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU0ZmM0NjAtMTRl\nZS00YTgxLTliYWMtYjYxYTQwOTVjMzg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB8x+jIfwF3JcjeU8Ap+HRmWBIiplTPu+vnkidd52Ue2gwUic7uMvwTZ00HIL\ndrGBl2lcwTOy38ZIloMzGEwmS6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmUAhPighaPpg2w8ju1zruPyINd0wHwYDVR0j\nBBgwFoAU53b14iLzZwjq7ZVnUu8y9SlmXHgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC0tULg6GNwNb0DrlLH51/r7J2e9fF5\n/G06MYhaXCdJxQIhAN/9nVhAOtBIatrS3z7hgloR9ur4CJ0x2JfaV2gjipRr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXr5mDZppJ9lNOGwLkBsBnypMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODdiMGJhMi04YmFmLTRiY2YtYjVkNy1iZjBmYmMwOGQyOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSBgPoqoASDPi54ANZCt3nIDvthFvhWgAZBBEubovvPg2d\nMexmn74DuOBG3Pz0hvOqI46EEujRVTVjCPo3ziB+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU53b14iLzZwjq7ZVnUu8y9Slm\nXHgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMsRA+D6oKJo8UYGRFqNRJNsnfP1I6tkQlmriMDv76roCIQCDNxmTKPFQ\n/7CJ6TPiiUn2zYLyGFntA1587rq/+M6Pag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAfvr7WKWKqvwvTt7FM3/DNaMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU0ZmM0NjAtMTRlZS00YTgxLTliYWMtYjYxYTQwOTVjMzg1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQzNGQ1M2UtNjAwNS00OWNiLTlmYjYtMDA2NjgzYmUy\nMzUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj9CgFJWIrA/lMuwMQs7a5LoC\nPHvbBYgUpB8zjeYps4vfxfA6vPGt4IUmtYvuaUg0tjW5SalbblQg02rI4y6jY6N4\nMHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmUAhPighaPpg2w8ju1zruPyINd0wIAYDVR0RBBkw\nF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDV3Uzf\n7EzEQy/PJoti2p3Gaxk6XfjsrsGK4D8zk5VNggIhAOvJqc10RwqTFc3TCCcfXs8V\nTtYAMEDle2xi0OapYDLb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7297", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7297` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQPCC60yqc5ZDaJNHwVz2421MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZjNjN2QwLWE0YTYtNDk4ZS1iNTg0LTRhZTkxNGNjZjVhNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDVjMTU5YmQtOWNm\nYS00MDZkLTk5ZDUtNDFhMzQxNjQ0YzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8ZzHyDIavPx2G4rFCwaxLDzysGFLYwzjDRuDeMwUPWWBUEpKO36Qg/ylmrNE\n7YQ7A3XnpgGut3XbgXg1N2XiBqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCfllviHdUM76RdoxDGpfe1jk2lIMB8GA1UdIwQY\nMBaAFIVHQpR6BPbK2BxIyZ6NS6uHhcKzMAoGCCqGSM49BAMCA0gAMEUCIBT+VSS+\n3HXTc9g6ARXnL1VT3aYBAqyVFAxFBruuv1N7AiEAhBaNgt7Rdlzy5UDVBR7CrVDS\nYwY8tkhWOQEMfufhPgM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZWHbSq/0acu/yRB/8NHi4R+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmYzYzdkMC1hNGE2LTQ5OGUtYjU4NC00YWU5MTRjY2Y1YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnwQxcDXY+0UWZWHhQZGjrQNIxsDVpQ+swthfSb2xf97Hs\n+JeLCkSaBlnO8xHC927ehZzmaXEF3Vw9Pq/gNUKEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhUdClHoE9srYHEjJno1Lq4eF\nwrMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGapATJ8MQoGnPXNWS1UV4x4Wqo78zkkDEfqY1yezO4UCIQCCGiotL2GF\nPw+J7Wv7bzfIi4S9dZHE3jCho/YybgNyKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAeplTbHGrOxM7RGPnHxB721QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDVjMTU5YmQtOWNmYS00MDZkLTk5ZDUtNDFhMzQxNjQ0YzhmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZWMwZmEzZS04ZDIw\nLTRhMjktOWMyOC1jZDI0NWNmMTU1NDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARJuH2XG5p/jvSbTwUyTMBmzh5IOaSOko1xTwbbu/b/mhb8X+eU/2gJj+0+iepi\nZcAtFpOGXbgskpRvEfZseis6o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQn5Zb4h3VDO+kX\naMQxqX3tY5NpSDAKBggqhkjOPQQDAgNJADBGAiEA4oIwWmFTPCenqHIFTso/w5NI\nziJduYqXVuauKET5Gt0CIQDR+73OpYjkVJ6Wl/Fb6zj84rUUV2x5VVeZF6KA8IO2\nQA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7298", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7298` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATTQSUX6ar3+81pbj8yN/zlKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ODE5YzIxLWFiOGYtNGUyNi04MDdjLWUzZjg1Y2Y3Mjc1MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDVhZjdlMDAtZWY1\nNi00MzQzLTg0OTItZGMyOGIzMjhhYWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2ngkb3DawWjI4gMpUg+ACQek9oJfW/hojJvyphUecwo4nt8fv88dGOT2VKDD\nd9IbI4mlv5UjdwZcarjYxdP9OqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJE+iAgUmsNRg7TkwFB2IaggmteuMB8GA1UdIwQY\nMBaAFKTLSdKx6WjidUzm6Yn+HWkVcdQYMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAfyabVYoGhg2a/5XMjCz/tFqtP/dq7ufy/\nX/Q5mEOz3wIhAKfLIrJdlACn+324K1341tpCj0JWrBQDZQI0fcCu/WdD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAch44MtTYAQMWgOARw00oXzuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTgxOWMyMS1hYjhmLTRlMjYtODA3Yy1lM2Y4NWNmNzI3NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+7vX17D0alXQz5JAkzeujkIbYaRFielzc8nQjakxklpDf\n9yJKrlqIu99q8zCzXnL8s+my+xFFa9uNdxlnV0Uyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpMtJ0rHpaOJ1TObpif4daRVx\n1BgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcSHCp1NqAeWQ0IK2/i/KEPzfoKwmFbpzKXSrhLG9AGkCID2C+0/dGoOE\nlPXIbLCodLJKjC9eMNz9hWZtB2ItCdxd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAVUgV3kV19xFiO+PmjzXd6C0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDVhZjdlMDAtZWY1Ni00MzQzLTg0OTItZGMyOGIzMjhhYWQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyODc5ZjYyNy0zNzhm\nLTQ5MzMtYjY3Ny1kODM1OTIyMjAwNDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARdt5Ht2J3yUL0izmjk+x+Tz78P/rLBupPhDdg7QwV/UqUQFNvvJ+lqyzHmycFe\nQa+VXu9xC2ySCR6cs3H0TqZPo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSRPogIFJrDUYO0\n5MBQdiGoIJrXrjAKBggqhkjOPQQDAgNHADBEAiBpvx9WTYQBGJfzCkv4CGJ8ArzJ\nXCVNMt+qKYxPMWU/twIgAa4KKk1rs+pmHk3WpySeujuBo1luBckC73zv00jzTGk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7299", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7299` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAfD0yPlxmtQ8Qsn8H9jOlOuKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ZGIxYWVlLTFhZTUtNGNlNy04MTdkLTU4M2RjMDhjNjI3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTViZThkZjUtMThl\nOC00ZDhjLWJmNzQtYTFkMWIyMTYxYWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeswRcZDQSQVijDZnbb9kMnT3K2ZzuSZZ+Irp97e//44vMLdxWzlMrUXF6KA9\nhVlep2w3P4Z1/s9m/fBKosqauqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAkGKoYe/x1FoYOz5UnNNgpWaoTkMB8GA1UdIwQY\nMBaAFG/mCylT7gkFsjSovKblWrLNXpT4MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAd8fLQfhQXUWOjBDwS5IhguInLHqu2ehB5\nZHFFwmCkCgIgeET6zaqBWr+ZRkPWL+NAWpRFqNGuNPsdU58B7CjNyME=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASyRwm2EbWMesFx4a4NcRGWPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGRiMWFlZS0xYWU1LTRjZTctODE3ZC01ODNkYzA4YzYyNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1FKsjIgNx2C8fHOqAj/bGGlrBfHbOjvlNWJEhPoYGVJqS\nvTX+SjvWwW04Xxx0vMtdOHuHzBekkhUxZzNAHhCPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb+YLKVPuCQWyNKi8puVass1e\nlPgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMRbgvRYdaTZLnmTBJ2TBnxDT4tmCQitC62x2fghMqTyAiAUl5/V/CFX\nf+quloe7r9CyBC9tfgQCLcrJ5gZn4k1cOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAYlU8/sZHkaykjEcgiB0J6esMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTViZThkZjUtMThlOC00ZDhjLWJmNzQtYTFkMWIyMTYxYWY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MjNmYzhkOC0yNzVk\nLTRmYzMtOTU5NC01NDRiYjhkZmRmNWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASSq3ppAxcmA9mvqKcCfEM5BP2sBvkzuhfIF2F/j8XtNQs0Fi6jE/9+CmSdtASG\ndL31J5Q5YO/KhFG8HlTo/USNo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJBiqGHv8dRaGD\ns+VJzTYKVmqE5DAKBggqhkjOPQQDAgNJADBGAiEAglyaSFuQtD/CnJPYbUASoUsG\nGUdymTDjOVGB8dzm0EUCIQCrkE+3WA+cZ8Zx4Uf8eDiqZrsxz0bsqxMKwoO3SpuI\nzA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7300", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7300` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAbX7cLXYGbUqmJA/twU7OEz4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MzJjNGQ4LThiZDgtNDJjMC1hZjUyLWJmODNhMGFmYmMzYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ3YjFhZGItYWYw\nMi00MzlmLWEzY2QtMjY2ZmZkOTJhY2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEydTE2bxJEQ/bNVv0YshaX0QhRYUm2fpzFPL88EwMfaSNJ5u1WE411j+yLrWS\nXCidFI3RmrVJ0ffTO88icgzwIqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTdCjrBnZGUbPEbUg1rXINjR7WHDjAfBgNVHSME\nGDAWgBQ0+j25uHEWoxqVswn8u4TVQonR7TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIA+R+w9pBW8lxbMmkaMNtu0UEiK0l750\nm/0Fzk88+kXpAiBVtibXxjOdtoHwfsiLA6FIgbqdk5Hxcb+B0DwgnOKWRQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQHz0ArMdD/a2p980tDh1hOtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjMyYzRkOC04YmQ4LTQyYzAtYWY1Mi1iZjgzYTBhZmJjM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARl5YXM8XT4b1jEbd5N3iVtSDH94g7z6UqcV15qaeAyuU05\n9hhZGiNaBsb05MN7L84j8tEc6WUxRX49oRz6YZTVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNPo9ubhxFqMalbMJ/LuE1UKJ\n0e0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKZj/7TXSiRRpXfZZEsvFecqfC6xCK+suu9rHxmVh20JAiAo73OibDFP\nhBE2vG07D0uz+3zEut6FFOyZ4v40kxzhRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAQl3kghiZX+KF4HoSBaBbJifMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ3YjFhZGItYWYwMi00MzlmLWEzY2QtMjY2ZmZkOTJhY2M1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxODU4ZDljOC02YzNk\nLTRiM2QtYTIwZi01OWU5ZjljYTY4ODEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASV4Qd9SUNNfobhb/75SjW2AuWTz1YmyGstCktf5DGiPg0LwFp9rB85XTOqvc5J\nVM6WaRt0/i1KG8VDfpCS1WkVo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTdCjrBnZGUbPEb\nUg1rXINjR7WHDjAKBggqhkjOPQQDAgNIADBFAiEAlZewoFoZ7kD79HnZ/HINzwx2\n/ZikOAOVUWVnxNFr3gsCICpjHKyfoolLZ9hcvldNtquL02lC+P55sltiKL8kzLkL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7301", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7301` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISART+dlodq1ZYDLCurZjtLxdEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZGVhYmZmLTNiNGEtNGQ4Zi1iMDcyLTA0YzllNmVhOWY2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBhZWExYzktZmYy\nYS00NWRmLTg0MTUtNjljNmU2MGNjZGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE64PvVh/kuBCW7H8Q+p2YcQ2vNxJlnriYr1UrpcHRW+M/tAPB9ahDz/8+BiCM\n7WP3qM2BnawycC7n7s7ZAM/vIKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUatpJNlBzMt/yree2ByvyGVeD0qgwHwYDVR0j\nBBgwFoAUpcITHYJGw4hz0jPwI04mMZelUA0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA/KCspjkNn5Fh\ngephtyYKOhcgXMpBhGKVgMqi9vU1JJMCIFgx60Uy24//Vkxvawsl+4IJPNAw02Rd\nco1B7y3UEnLm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT+nA6jR1q4BJkUK1k6svtcYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWRlYWJmZi0zYjRhLTRkOGYtYjA3Mi0wNGM5ZTZlYTlmNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqSiUxG0myVj0y8FRUgDJkxZc0wnDMjktLUJAhvVsR6gQ0\nKRUpT92wxxUJBvhOBkp/FR5QJ5rAODBs3refG+/Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpcITHYJGw4hz0jPwI04mMZel\nUA0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgObc2CvLeKthWoJNf9SGKAN2EKGmcJmuKwZsFpd10RB8CIQCewhCQibMP\n4GiRTx6NIqVEc7Q/clyapVZ7LH4u3KaS3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAYMWt8KnzO/1qbLC8vMIawRgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBhZWExYzktZmYyYS00NWRmLTg0MTUtNjljNmU2MGNjZGFiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YWNiZDkxZS00NThl\nLTRhODUtOTMxZC0zYTA0NjAyMmQyZGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATg0RSW0ObDyhQo9keUNcvl+E5eIp0Q4fXsvdPpZb7glKUJs2ks2NGO74bFZFkx\nExZ4IOKJvwb9yPJINn6dIpqlo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRq2kk2UHMy3/Kt\n57YHK/IZV4PSqDAKBggqhkjOPQQDAgNIADBFAiB26VHVnRW+emkrv506I48SQH9p\n0IeHfiNfqaXDxNKEbQIhAJBIICZsemSBtbqAxnE/xHV3AXp20oT+yCFWEFUArjLr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7302", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7302` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAbp/GWbH+eKd6tbiEbh3WMULMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjN2E2MjhjLTg5ZmUtNDE5My1iMzE1LTU2Y2M3MDRjODUxODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI0ZDlhMzItNmZi\nNC00ZWQ5LThkODItZjFhMjkxMmQ5MjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7LMGKVTUPEVw/gZXl90UaQkIb7PDJ0R/WNaYJVLKmzhgxBkbiafSOPTEboCR\nmVG7ynQhC2KQdu2cZAuviMa+baOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC71oxgP5eOSzraAbKXdrhZVaT0YwHwYDVR0j\nBBgwFoAUD+mUnolg775i91v/Dkuil/08qrowJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA57/MqvKpXDJw\n/p5dFQCKRkXhG81ijR20L1KmL/+vY4QCIQD2wyPsUNELF0ciMPntL6zfOv7oZMLa\n2PIFbRHrVkluAQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV1xQBVx7GLK2pffguLlG+G4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzdhNjI4Yy04OWZlLTQxOTMtYjMxNS01NmNjNzA0Yzg1MTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRVl00djW1lfHdi6af4RNuZYMNu71QLfp/e6huFxkyohly\nwgJK3GEHwXd45IcMvby4f6lgA+EnPNbf+mJnOe+do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD+mUnolg775i91v/Dkuil/08\nqrowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWM55xAUoKniCKs8rHoykVcgVzTa7dV9xxe7oJFwcfBkCIQDV0ZXkxbeb\ndMHCa7IhvNzTwO8slDFe4rYUDzgLoJNFcg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAXQk18CQeVyUv/SGHRjvmS4vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI0ZDlhMzItNmZiNC00ZWQ5LThkODItZjFhMjkxMmQ5MjM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMzc5MzI2Zi1kNzJj\nLTQ4OTYtYWQ2Ny02NDJkYWUxYWQ4OTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQcBE+Uhr0xrt84EAhxhAMYQfqMNoLQk72TQh7Ltiq1caAyodcwkiMbOYnjPAFu\n/EZcMKsOoH6wQLPs+xo6iNCco1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQLvWjGA/l45LOt\noBspd2uFlVpPRjAKBggqhkjOPQQDAgNHADBEAiBOpi7s+n3WmlIQTHFY6grx3kJ/\nxSkHD7gf5mKeGqpZrgIgYxthL+ofIWkrRpmt/Yt2F2uz/h5T+2vbAAR8dWR1UU0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7303", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7303` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAWbsC8aSDliRgehHwdVQLesbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyZmJiYjNhLTNkNjItNDY5Ny04YTdjLTdjMzM1OTQ3M2ExODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE0NTc1ZTUtY2Yz\nOC00NDg0LTk1ODEtY2VhNThkNjIxMTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkkL3lYkRUPXapyV+F2vt/eR9waADI1c6zM92AegDpTWaWOQ3seLEaNWapFnz\nRZTRm+USeAn7IkCBpDKk/Q4nLKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZuQFZ1CZMsfMMEZfZOGgAM6BrIIwHwYDVR0j\nBBgwFoAUzZfDblYr+Ng6Z49UxS+UNwCMyUMwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAhFx1xBp3y86g7W2vrbHa\nGEohiuh2UJONDJcm16dW1nwCIQD3efzZCK3QnR6c/3N9sWl8K0zaXicautGEBN3O\n9poOzA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAft0MSsQVl9NK8oTRvlyIz4fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmZiYmIzYS0zZDYyLTQ2OTctOGE3Yy03YzMzNTk0NzNhMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy00iiUxu/2/m6/YLd5xGKQz2cnzHPkSLn/9+5xOFbqmqg\nQyGIbms888in5VuRd1jdcUd1sVFZJhKtKaLwVFPPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzZfDblYr+Ng6Z49UxS+UNwCM\nyUMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGXOx8IhCC6qwFVDL5VMT0PLlJnH582QrZ0cofJeYYmMCIEKI/Xo99a1t\n9N2pAgCuGf3vs9NhE2xu5l0gGzGLMw2M\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAUWCdEbLhA+UXUhQxQ+tiryxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE0NTc1ZTUtY2YzOC00NDg0LTk1ODEtY2VhNThkNjIxMTE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYmRlNmFlNC1iZmFl\nLTQ3MWMtYmY2ZC1lNDQzZDEzMzljOGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARB9MRFyPWz3OUpbPGF8Oq310faxJDIt1lCLbNVr0mBBH9H6qWZ2qLr0n1LwHrU\nz/JHJMWO8aGWGVRDzO4DLK7Oo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRm5AVnUJkyx8ww\nRl9k4aAAzoGsgjAKBggqhkjOPQQDAgNJADBGAiEAjknVZ+FJTsy+uPFdeVAuDZOX\neDV/a15S9W56XSTHRrkCIQDcvxSzxgG1ZHcr/zWNnGUaLbcrCYlWGqgaRj/AZsCp\n/A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7304", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7304` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAej3tqAHqnmuWIskE/HvMNrBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMTAxMTRkLTM1ZDYtNDI1Mi1hYTY1LWU4ZjJmNGEzMzk3NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM4YmRmNDMtZTYz\nNy00MjA0LWJkMWYtOWIyNDQxMWI3MWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAp/crgba2GNkRaKC+U9BdHv4tWykI71/31FyPDcb2OvgxqaXKQ9tHet+3Vey\nViBhiAbAAa4PF8+aiEvs4vZH+6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0d5PaYIWoUFlME6nXxCYWOzCD+wwHwYDVR0j\nBBgwFoAU7Q/AdDxSnFhvy7Kc59op5t4FobMwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAN+QEq\nFAtSWLiRF82WbjvNAMOXw1XBmJK7lCEh+t3rsAIhAJvTOainTSVpj3riuCBG3cA+\n47hyNFd716oZlFww0j3S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQRt/mqFTTnxP/uOfvQuoYmMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTEwMTE0ZC0zNWQ2LTQyNTItYWE2NS1lOGYyZjRhMzM5NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpS8MZHCHABKRPqLDZUJYaPwV5rgK8r1eDNJ+st/JC/KLm\nq80dLHAGnNKOyT0+vU04V6pDOVrN8OMPxh+5MLk/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Q/AdDxSnFhvy7Kc59op5t4F\nobMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMscKWjxr1Er1EBRimwflSEBgW2O6uY4l/dGzAmbhcugAiADPCUXyMm/\nZSAUnYW7KSchN2hOGK3FhIyD1aHFjiXJrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAc+wENgQ4PZneJdBMmLaJXimMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM4YmRmNDMtZTYzNy00MjA0LWJkMWYtOWIyNDQxMWI3MWVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMDQyODUwNi0wNTY3\nLTQyZGItYTU5Ni05MjlhNzUyNmFmZjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASCBh55gPQ5WvFGIiaNSuPsD+GMs05xrivSNcCPtRnjQ8FeFd/IFfOxhVfGlmb8\nJ6M3rqkje35eLoARfxfjh9ILo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTR3k9pghahQWUw\nTqdfEJhY7MIP7DAKBggqhkjOPQQDAgNJADBGAiEApy2J/Cm7sikG5wH3NB2fkU43\npAxbq0ZGID/xM50sfRwCIQD44olWGKsNznJl/WfumGZxfsi02DCLZOAAwGoQV5ar\nXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7305", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7305` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISASy2uxC7f1jpZazs72zQ4eEWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhYmU0NjRmLWYyMzItNDBjNS1iMTgyLTNjNjQ5OWJiNmFjZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJiYThiY2EtZTg5\nMS00ZDJmLTk3YjktMmMyNTk5MjAzYWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERkOLxLulCZEkStdCGUidNdQB3Dh8HC4fOEpzt18qtv2LNqcNMz8GOoWKP71I\nfic9pMsqo4tT+75vmK+yqGdAsKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPXpayjwgVoTWybS0Py5WmCfn6UcwHwYDVR0j\nBBgwFoAUSPXVrpQy3DRSGZX/B64wjPmRQH8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAty+N\nrvKUpbrOjRNxo0xl8PArK9jRnY1dSkqlGe5wv8MCIF409zIATQ2rGjqM23MPYIW2\n36ucYH6la1ffqvKKgxiW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYk6nnOXzwfAL6ZJpxTi1v/aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWJlNDY0Zi1mMjMyLTQwYzUtYjE4Mi0zYzY0OTliYjZhY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTRHaeKu86Ka6CmtyashBEGgVA+9bYQk2L29PaFC7JJl2c\nRYU7pCrwkQP5BlMiCfLDtYEH+WPjjNbBD8MnUUfyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSPXVrpQy3DRSGZX/B64wjPmR\nQH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO02jdy3C4gBZGHJ+c4WRoNfGgXjxTlcyuLuRAXD62M1AiEApU58+fYQ\n/i2dK74w2u3E4bAhpRUwfZC3VZL8DhkNOhs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAY7mPkBfFSozsrtT2Oh4F9M+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJiYThiY2EtZTg5MS00ZDJmLTk3YjktMmMyNTk5MjAzYWRlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZDMyMGRkYS1lOGJj\nLTQyYjMtODc1OS1kNDNjMDZkNWMwODEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQSKQF65q5MXhb2yAc+WGS0KIAO02sigQERzBKmfR9Jh2xIoMa3JxHbC4nIBKQ+\nKTlzIzSJpZSSo5g0YF5XMzaKo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9elrKPCBWhNbJ\ntLQ/LlaYJ+fpRzAKBggqhkjOPQQDAgNIADBFAiAUGq+9eNM/H2Uyxsy0n0FcoFAd\nM2jOcvApDBiXrXp4IwIhAKvyE0z+8DE+y5SGV829GmO28U+yxPPHHuwHKdtGr09d\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7306", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7306` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdrTevvOKf5LQVnCOD1XrbYWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkNTU2M2Y0LTkzZGEtNDc5Yi1hMDdjLTIzNzE5MjQyZWZjMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZlMmRmN2YtYjI4\nZC00MDJjLThlNWMtNzdiYjVhOGVlM2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERp2lpyDF8KeHsdfBWlcSLaxaPtshSxYqa3ITaRNB4vhL7tyZhV1C+F8OuGCP\niJ+R+MpRox/pbhUrvEJNaNdWMaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOguBbe8b1ExGPhSVkKsynyhEUvZMB8GA1UdIwQY\nMBaAFJzyPQPGKo84WaWuZSOwLez7ahKjMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAukNNvi/OsTeEnH4udku8jNI1uUZAr79h\nSWukZz/BucoCIHz94WAzIjJtCiJ+FVthvwV15ppyJYmQRD88q/fxuAaU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWIhVs1j8untlmahN+oo1SpRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDU1NjNmNC05M2RhLTQ3OWItYTA3Yy0yMzcxOTI0MmVmYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQP4REShuhbJQfMq5Im2u/NR3lM6hDN5b2VNTNetBJ+5a6n\nao6LJA7BTvioe/JLPEdW7zn6zs6vsSY4hjqnUu2co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnPI9A8YqjzhZpa5lI7At7Ptq\nEqMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIowsd8WasNWuqKTeIFtG2eaVnD24yzaVRFTwkZjR8OBAiAndOKWi+AG\ncc1mU8LABk3Sep4TFx1EX7oy9k65EteolA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAV+EmQxR9mEMuX3YeLdZ0QGuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZlMmRmN2YtYjI4ZC00MDJjLThlNWMtNzdiYjVhOGVlM2NhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NTk4ODNiZi0xNTUy\nLTQyMTAtOTdjNi0zNDQzODBmYWZiNmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASiWXhxNklMmMYJQn3xo+liRRcXH6hyMvHibPqsuY2AEpivk/pOzv8bG0KOM2E1\nGNq1MioM4Iqe3HQu8lr7ngeAo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToLgW3vG9RMRj4\nUlZCrMp8oRFL2TAKBggqhkjOPQQDAgNHADBEAiAHLszl8yH17JYyCqxz7UyA44TI\n1DIr4s5K/1pWPbE3HgIgL5e3OJCArderfeD8DfM1qAAySxey/KrRb2aBgI1X60w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7307", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7307` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAWWtJf973ofKleEffXPipKLrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2OTE0ZGZhLWM0NjEtNDcxNS05NmQ4LTU0MDcwNjI3YWY4NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhmMGViYWEtMzM1\nYi00MzY5LWFjMjktMmFkYjE2OWM2MWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4roNOPqtrnfnzGkx/uHe0X+W1VJb8KDN2EuefY7Qync+EUdte10NjwIusTST\njhnF6odyMoMXyFh0m99sYKMYUqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeiQ8uMAfofkVChCKnMgcUZGt9iEwHwYDVR0j\nBBgwFoAUPxJaHHx9ulvct/k6hqCVVZuNWVUwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgGnHIs6qKLS29\neXV1jnXsjjNqNKNvZzMFNIaqfYxleHUCIF1v4qLwfaqo+lWZ7t2FSKCv2NnL6x2V\nJlH21j0S1qdy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVzwSiMLLfKa/loiDlVd4tTkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjkxNGRmYS1jNDYxLTQ3MTUtOTZkOC01NDA3MDYyN2FmODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2lx2zwm+k2VATN4G/63QZMFV148B4bHF3eDC/x4q0pSfP\nZxRZOGE5tPwFcWfVn1yH+Ro4QAyuthCIeDw9QRHto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPxJaHHx9ulvct/k6hqCVVZuN\nWVUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO+JFgFW5GqTMiBINPy7hWX7GSKITGtj9ZZV4VBAyx6AAiEA5Yp0Ipnd\nU5GXQ0m/1T/bHRA1z+umSPU9m7jT2rt68M0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAR9EmMBGqYMlcHzXfdPcWoTUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhmMGViYWEtMzM1Yi00MzY5LWFjMjktMmFkYjE2OWM2MWE5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYzU1NWIxYS1iZTQ5\nLTQ2MGMtODg5ZC1iYTNiYWYzMmE2YWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQpeCshks73rJCrXuVoQUPC4wQaGmTGM56RDKRhdghGFGePFHpWUSDVmRFNY5nZ\nvKZ3NvL63TOh8h2zN+XtAPq1o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6JDy4wB+h+RUK\nEIqcyBxRka32ITAKBggqhkjOPQQDAgNIADBFAiEA6naarbph193cUYzi3QQzJS2z\nHwt0CHbsVxW3vVyNiMECIC+dc5r2vANcehaHdAlIn0fTDqPCbJg8aX1ST0wrckc+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7308", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7308` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAc8StcJHIh/Pov7a4Cv7xynqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0OTgyZWEyLWNhNTUtNGEyOS1hYTJjLWVhNTMzN2FjNWQ0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGUzODk3ZTAtZWUz\nMC00MjI0LWIyY2UtNGZkYmQwMmJmZjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU5UlhndO4GF+VbvFUg9dmhX0axRD19kIWn0u9v9+0yyRc2JoPshckIT24KlO\nNZvPSiRMq1Avf3bQzzex6O+snKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA9mORoWFO5EUNYNBxywZQm/3bfcwHwYDVR0j\nBBgwFoAU+X+RKOhSP9t3rAmJyr+dl2ukUWgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgXcqeRoQAC9st\nrqepZaq/ZpZy83BD/L4YQ/1DX0aAB5ICIQDVh6S4NsIkYkWO3RIze3zMDFsUxBRK\nhecynDY+sRkI7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYFNNrgWwA2g7xmnMpe32a4QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNDk4MmVhMi1jYTU1LTRhMjktYWEyYy1lYTUzMzdhYzVkNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjaVJYn5l4+3tEdrrv2F7YSb57BriN3olGIMoe4VgxPeCK\n9roHvX87bC101wFUDxfXMabbMg08VzdJ/xBBsEBCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+X+RKOhSP9t3rAmJyr+dl2uk\nUWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMz3ejUWA0BTo32JX+j07/IVgRBvIkeyvSCfyBldpsqsAiEAweAdeWy+\nKEtO6tQgVlBjnKATeZtON+56YZLZpmBRas0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISASAdaBqyZ6rRJBp7dZLJA34oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGUzODk3ZTAtZWUzMC00MjI0LWIyY2UtNGZkYmQwMmJmZjBlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZWMxYjMwZS0xZDE3\nLTQ0ZjAtOTEzYy03ZTJkOTgxZWE1NDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATBHHE5LEgqghCQKgXNrKxOhhqCVMVgC6XkVUfAcOmcYldVO3G0Xa1RRIyrtVRW\nKWCuO8QfvADmFeqhSHXBcO6ko1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQD2Y5GhYU7kRQ1\ng0HHLBlCb/dt9zAKBggqhkjOPQQDAgNHADBEAiBqXJ0QAC7QdEScUoeWIpkX3D0G\nUJX+CDSqG1l41u3cMwIgUcgFaanMTFU0yoOaB/ntY2Go2H3lcfuvMs9XEcfvzoE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7309", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7309` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYQ3uZvVdT9rGPjPwVgH9qFWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyZjgwNzgyLTU0ZDAtNDc5Zi1hNjQzLWM4MDZlMTk5MzY2ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg1N2JlOWQtMzU5\nNi00YTUzLWJiN2YtOGRhNTdlMjJkM2IyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEarFGBuPfOclBgj42+7Hov2LS2PAIxB+bIb7tBG8NepH52x0cz8b4EM7Fdrdg\nvac9LtMylrkZi0/8Zrfn0yP7hqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmmN+y/Vcd9vcaaQx1TYo4onhDGUwHwYDVR0j\nBBgwFoAUsI8rSfh9AmW7rkShBB+vBZNPX2gwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDdmkV2Af+z\ngAnmGgQprWgzRgE5ZWo2ybpntL90M2CvXgIhAIIQiDZ2GKZeqwuTp049nucBKPkU\n0c6W8dgOcYCIjFqI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcPsjMX+BmJI8nrlQODc0pSoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmY4MDc4Mi01NGQwLTQ3OWYtYTY0My1jODA2ZTE5OTM2NjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2zdZFfCjXuMUuKt3mGWMGoKf44LXTlTtfYzJ2YRZCwjpG\n2E7GUkn8vlJSYAyCTQthDdcz/4WIw8QLZq0ecem0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsI8rSfh9AmW7rkShBB+vBZNP\nX2gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOkWW+0EXMIaZYx6rccn/iyhPIFkBlgDVLbhoZSorui/AiBJlDzP4ZLF\naPlFExQWKuyNTJs9SQqB/dxPDlQJLE2oWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISASKUfasuUpaBoyJcYFiEpdzGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg1N2JlOWQtMzU5Ni00YTUzLWJiN2YtOGRhNTdlMjJkM2IyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNmZhOGZmNi0yZTdi\nLTRjZjAtODJjNS1mYWY3ODQyNDlmYzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQFUocYKEJrulGTvSuRAf5Lum5BWt9Rfd++hSaYcoxU+FjGSEr9HS5JzsTTRabP\nWrqu2d9gdJ7fIt3AqBB/K+tFo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSaY37L9Vx329xp\npDHVNijiieEMZTAKBggqhkjOPQQDAgNIADBFAiAHHIW89zEP/eBsozep6p9ULErD\nPg4Ot1g3syTCmbQxMgIhAOd69aJCYHILiA74bU3qaw4lbxVWuf0EVEV7A1gfUhny\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7310", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7310` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAXxjOPkT926ZdLk7zrmVSQRsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxN2NmY2U3LTMxNTgtNDBkOS1hNmE0LWMzMGY5NjkzYjZjMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIxYjhjMTMtZTEx\nMC00YTU5LWIxODYtMGE5ZTEzMTE0NDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPFwv5cwrReTqs+1gT/jW4ukuzPAc3U/2NNa0x8wZF2/t7bVW213XBDt98s5L\ntDUG3ikkeLKT9tqJMJP1WHfv/KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhCl1VF9BdIk3rTXLreWTim7vqMgwHwYDVR0j\nBBgwFoAUkT0SgPiX+C3PP48FiG2t8q/O728wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD1xt2nRYCtHqq4dAUalNDupIzq2YniVmq644Hmp5kgBwIgLsboLCJZVIZV\nftOPHq6ejT5Mm+WqDYVZbH5nMbdwW2g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdmb9i2htQPq6tQVHQ73hjkQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTdjZmNlNy0zMTU4LTQwZDktYTZhNC1jMzBmOTY5M2I2YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASE3HtkOhUzHQ3onaz99Ol68CsVpU6HXecUAqCT4/Itvy8Z\n6R3oqKKjmnngH8Zksf3DIa/7+KEJxxXWcJX3Qtv7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkT0SgPiX+C3PP48FiG2t8q/O\n728wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPngumVi3ZIwAMtpk5+HfuuO06ivTyKpdl+mh8pzz5MkCIEpiQYrHq/G4\nB/4qLgI8YQN3fVJy8ewqg+nazxvYVA0X\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAX01ywQ/E3IwdTYgphMoW7cgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIxYjhjMTMtZTExMC00YTU5LWIxODYtMGE5ZTEzMTE0NDQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMGE3ZTRiNC0xN2Qx\nLTQwYjYtOTUyMS05MWQ0OTAyNTJmZGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATz0sTzYUvd6kZNZL7HD71PtFXAGdpPe0FYnhyd9gIWjV67RcBwXZ6ItjJJZStA\nYUirVOme71s6B9lB/CPRUdDoo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSEKXVUX0F0iTet\nNcut5ZOKbu+oyDAKBggqhkjOPQQDAgNJADBGAiEA756gqg9z24tfrtUgYWMBXva6\nfAN/iMXOHASgWhy5oisCIQD0dcT1gKMuynoQ+Z2Y4mKHWqldhVD8Qc8ls1EbmWx4\nLQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7311", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7311` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfdiZPYowSX5MCmy6S/iQRH+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxNjI4MjIyLWMxMjctNGZmMy1iODg3LTdlNmFjOWUwYzA5NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBiNjM1MjEtNmZh\nNS00MGEwLTkxM2UtNDE4MzNkMTYwNDQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESbMIudbpX/twO3feCXDFv0UR89kxtNKwgpUG3juJ+xoZOJ77+ht+ecQrRMLY\nojD6Z9t7RnC45P7JU283S1DDKqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP7/xoOaNhLad4PrML2OvZWXf288wHwYDVR0j\nBBgwFoAUsQH+FM6NZ4r5rL0fKuqI9i+Lp8MwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEjVB1BFI8xj4gyKvuQNV1/5laWOmWjXAklV7vFAEfZOAiBPBLzto6/o+wfe\nbdDgv9asFc3BpS5kAzYSg/7iUw+27A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXtyfj0fUqnlZ34s3zNiHU+NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTYyODIyMi1jMTI3LTRmZjMtYjg4Ny03ZTZhYzllMGMwOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARA/G08oyxwQLpn2HwqlKv4YjXAsAC59kspRPoRBxWfLfyn\nMIy3AZICDcw3K1qwSdRXRDHoNgjkhUBnY6lJ0+UNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsQH+FM6NZ4r5rL0fKuqI9i+L\np8MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJRubyLcfDAPlKqSblM+f1LStvugNFIX29ybOXjBpT5zAiA5O6LuXOSc\ndEriEaVkLXoxs9egelBMX+nCCLNr+75T8w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAUQt3zmbLikONeAB3f6IE/8ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBiNjM1MjEtNmZhNS00MGEwLTkxM2UtNDE4MzNkMTYwNDQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNjQxMDc3OS1mMzNk\nLTQ0MzgtOGQ3Mi02ZTc2MmQxN2VhOGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQU3w6kC6J5v9kBmKtW3nVFuoFwpJyJozODXI+oBsPjj2WyI6VfYZhyWJ7swNJk\nPmbG4SbjrBnpq9T+n+Np5+rMo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ/v/Gg5o2Etp3g\n+swvY69lZd/bzzAKBggqhkjOPQQDAgNIADBFAiB7Q3nSatvdk3CmvUTxCNOqYgiB\nsh4m2RBmKTDL8B7hygIhAPkcGu1iIHSxfVIB4AB5HDdTICsMz//Lp94HRiIFxDMv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7312", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7312` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAdVJv+lnSxFto+zVubCQoi4pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliZGYwOWZlLTcxMDktNDE0Yy1iMzY4LWRkMGQ3NWNkMTRhMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU3ZjE5MTctNThl\nZC00NjMwLTg2OTItNjNjNjBjMzJhZWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp3vQH/p9iyFm7akM5kVQ97lbrKZBr3k0aaEEuwgQpxS9tMeHoIRFB5AyQfho\nsYS55AL0LPWYAwlYv1Vhc3dhRaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjlN79H+jgqYmfzfKK+LfLzgOGvIwHwYDVR0j\nBBgwFoAUXVRRRmgMdiZ2yqmuNxyj+lXO54AwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCe\napGYbdyoSb4fW/NiYn8D0ke2eZmo0KG/6h+WTV9v4wIhAJx8Ie4pjuy8s7JWpfgG\nLy15hW3sjyZCJ1p9i652sLp+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe5zwJOZn+ek6PUSNDr55kWMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmRmMDlmZS03MTA5LTQxNGMtYjM2OC1kZDBkNzVjZDE0YTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwiGbIFsiURpbiK857YRM9AELbADRDeNM452tZFAw8qPNq\nm65+qwrYWJ2hZwD/jAbkLsTN02e58bUvTUqz0Sc/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXVRRRmgMdiZ2yqmuNxyj+lXO\n54AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ9m32iOBLn4fWcxagCzpMNc/UgYWyNk9/sCLD3O1SXhAiBi54KK+lOL\nWdOU0CKxkc0k2NeulXvW4ZyJcYKTpNvVYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZKR+6Ix3oR33pLqDx/wsDHtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU3ZjE5MTctNThlZC00NjMwLTg2OTItNjNjNjBjMzJhZWExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNDI0ZTFkMi02Mzky\nLTRkMDUtYTljZC0wOTRkYzg4YmE1ZmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR185E17i6SlPCH5DcrK9aLwV24HkhfS+H5Q+sr551dcyeHu0M9oo9gX6PQ0lVe\nXZSKe3eT6taCbv3lmQtZci5+o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSOU3v0f6OCpiZ/\nN8or4t8vOA4a8jAKBggqhkjOPQQDAgNIADBFAiEAgv1p1uFmR63BvRsRCVWiTglJ\ndXgMtIz23+Xa32kP+HoCIC3jzvL+KiX0TEiKEJmyvz68JohNG5i2/RjTBAtk11wx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7313", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7313` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAdISwOyC6fb1bpNdkyUqo4ztMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllYjhmYjMzLTM5MTgtNGE0Ny04YmU4LTk1M2Y2MTc0MTQ4YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RhMWYwMDItOThk\nNi00YWQ3LThlMTAtZDc1NWM0MDg3OWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETbn87R6E66pe2xk7IF8MC8cQJ6EkkQKootlxDYiy7t9slUWGUx2nMJhvZNgx\nlP1XpBMhEYm3FFJsg/+j+obYfKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs8u4AmI2HQLFda3PxJs+EnKZoZIwHwYDVR0j\nBBgwFoAUvED+cU9YYOAiRdJtMPYHHDWgejgwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDMBVh1tWUaQPPIS1WjIuSkkBnnsq3jUKz9PNm3rN3yIAIgcway\nGUlWpDzbaasXYXjS84GR4q2j5mDHAtrQE/PSTug=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa27EM8GIWuKS9wuWKK8cmJHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWI4ZmIzMy0zOTE4LTRhNDctOGJlOC05NTNmNjE3NDE0OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoJd+M0Q5tRYC7vdv287Ca3V91y3/xu/UVKySt5E/XwdL6\nSoPYnFozzpH5P9jYCflXK/XYHBKJBm0s8qJ5v0y6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvED+cU9YYOAiRdJtMPYHHDWg\nejgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJP+RpxNCytizHzY1BpGNXbrQHMjUIWDGSAKnk+fCGWACIG1LOMx35x8P\n2MryHGsL6YLXwzc80hvkIo1B3A2Mip8y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAY2ZtcL0uPYLpXpWrODmw54VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RhMWYwMDItOThkNi00YWQ3LThlMTAtZDc1NWM0MDg3OWE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZTYxYmYzOC1iN2U4\nLTQ0MTUtYjIwNi0zNTU5YjA4OTYzNjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARdPCoedS1DVy74gzk2SbjiPlUNeZlKaCGwgb8UhVbv7udVXyJ+mH0IKEvv6IyI\nOjwfKwwQy5nX8MkEdp85XWswo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSzy7gCYjYdAsV1\nrc/Emz4ScpmhkjAKBggqhkjOPQQDAgNIADBFAiB4kmioj5tgQ9wERmLT4dL4+PVC\nwYJmhEbmo1oN1KrFNgIhAMiYtN1YlFZsZ5ZmOxzAOz9FAnPvASC2Lqu+INNp8wC4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7314", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7314` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZHhScyZ+MwLsngPrwUtSVFEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4ODE2YmQzLTYyMTItNDU3OC1iMDBlLTY5OGMzMmU3NTQzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTAzMmUwMjYtNWM4\nZi00ZGQyLThiZjMtMDg4ZWI0YTYxMTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZGnYw5DSXpsj9EUe/lJt7NQeo34pJXLYY8z6fv+GWLAXIeT8l/44qjB7G9Mc\nqCKnq/KXkvkO4ZXqsEtrtILpzKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwPZftd904rpFlnK0oia/ygiJT9wwHwYDVR0j\nBBgwFoAUsuCbD9lAvGrV9O4ZRAAXw1esBBcwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIEINaSiqHmzTDCuQ3QyIVHrNoOCMaknOXLAt05c7L0UCAiEAtX1c\nSVtgY23NbsDn4h+TTCskZHictAtHn+0MV+LMXMM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeCWgp3s4lN3peE8c4VYwCMbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODgxNmJkMy02MjEyLTQ1NzgtYjAwZS02OThjMzJlNzU0M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2Rl3Ju2fMDTnR3JZQZ2HtIym13YlBt3ihl/fbn/XVYNZf\n0jGHjfYg8rIXrnU9S+z6lozRqQJZgHVh7lg6W938o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsuCbD9lAvGrV9O4ZRAAXw1es\nBBcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMUzaaotKK3SjuXtocnmTyTGUy5xUtIYWw2Fvz6wH046AiAUOtHKbIcU\nfbg4diDVkecqkp7c3OunuZUH5bFD5Wvmuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISARVPjKoYyc6DH0z3teKU5v7CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTAzMmUwMjYtNWM4Zi00ZGQyLThiZjMtMDg4ZWI0YTYxMTg1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZTZlZGQ1MC0yZjQ4\nLTQxMmQtODAyYS00NDNkNDU0NGM5YjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATFjPnDCcCA05JRhVqM4vXp5tBRv2DGOPzMFNXnGAqEjQSXCDJmGf0zuPm1IVNw\ngsKJjG3bv1j6fSUuDu7uZkqQo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTA9l+133TiukWW\ncrSiJr/KCIlP3DAKBggqhkjOPQQDAgNIADBFAiBK8Wh0PqQhOrt2U7d2ht4z9Qam\nkdZc7OCosDHaNU2/zAIhAJ7GMRSwr5TmM9i9EEGybL3kh1a8omz1Vq6w0l5AASbC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7315", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7315` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYElKJXHh1NxuwX4Mx2UiTzCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1YzI1OGY0LTA1ZjQtNDE4Ni04MTkyLWJjN2Q0MmY4YTk4ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA0MzM0MmQtNDg3\nMS00Mzk2LThkZGQtZDQ2YTI2MGMzMzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErFNSYfG8hBdM5gg8MGiGm72c/WgHXsaa6DP/qiISOx1cwcEZ2rz48wJV5+aR\nHCkGFGzJJEV6e2A1QSGr8g7BwKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOOVE9Y0ejaQvJpdnd/W0JpMhLYdMB8GA1UdIwQY\nMBaAFLbGMhVmDGWpsCqeAoDKTa+rR4cKMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3z54s+qrVc3nHzu3K8/VTLpFkBoZM3Q2\n+YoNCxzbmmsCIFKqjTypjE+BFHg7UXFUmYnuZcmkOV6CuiP8mMbZstks\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfbcL0Klpax59dQgySWxhp4OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWMyNThmNC0wNWY0LTQxODYtODE5Mi1iYzdkNDJmOGE5OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzPtymycl9SmMBJhOhtsAMzTxX+k9Wp5Y9TtExLx6xEjMG\n/WDFOVHmCPRvXy5Gpbn7ZV+Ze2x6nFIyhxLyqDewo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtsYyFWYMZamwKp4CgMpNr6tH\nhwowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANESgelJy0GZsQSbHic0deR4zRnzf6Iq7UeA5nYjmmeOAiEA8D5KFQGQ\n7OwvDPWjIosr/BfF+4rF/Ixk82FSiqi+v9Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAW9VPQU0komu83mu2Drbn/p8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA0MzM0MmQtNDg3MS00Mzk2LThkZGQtZDQ2YTI2MGMzMzNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYTAxNDdmMS1jMDdl\nLTQyNzAtYjI5MS1mYTI1ZTNmN2MzODMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQAwFojBJR99yKwGRBu4dbENZjGhLL1oueP74t45ipr08MI8gRA9Z4mzL1XbaFo\nNLa3eG8DVLTZi0bC2E3EHFb+o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjlRPWNHo2kLya\nXZ3f1tCaTIS2HTAKBggqhkjOPQQDAgNHADBEAiA0oG/7bq1nHYsnd5eAZUdyvRwf\nyoWk2fpnXzPxen1WAAIgLC+eL5CkZAVeBk9ORjHCYj7hHRiz8Vqq3Y/8hOdcdEc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7316", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7316` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAaVuYTM/Yb7VLN84ARahZRzrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhOGU1NGE2LTBmZjItNGMyZS04ODExLTljYTJmNTFkYjZkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFhZTlmZGYtNDll\nYi00ODZjLWJhYmYtMjFjZTUxODkzNjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwx0kmeSS8BXs/5F3JkVxEJBUmePAIZgAW30oWwr//OJ8DC21BTQuvZXucTVm\nftbC7nW+kFpnuiKph2WS2QUdMqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUha5zmrRDs3mvFM9gIz4+1Z+jgJAwHwYDVR0j\nBBgwFoAUkg+D5wqj1ubvqe0Nry6+5iVzzvwwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAImNOUg3z4ES\nh1wSYgHRpHKh745SHqF/XYPmbSY/OjtTAiAYzAgPAUbkjyskQ6kwZqR97rC5zRHr\nic2c6hfMxe0Ojw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ5emNU5ftJUv1wGzTpK9b8/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYThlNTRhNi0wZmYyLTRjMmUtODgxMS05Y2EyZjUxZGI2ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgEn2vD50cNo+jh042G8obUeDeukCN8b6+ghAwmnAqrklO\nXTlzBSbrZdMOzgzKBCGeqv5GzUgJxaBmwL0JED+eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkg+D5wqj1ubvqe0Nry6+5iVz\nzvwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOk6qvGEKg16piZjAUn/WRTEREPZtfd/ZLCo3HQIszOXAiEAwd3RUkUL\nopk174J5RWm7ytjI/XDJKufn/7UsDnuEDW8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAWxN5e9QE+RcXlz0vMjcx3TkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFhZTlmZGYtNDllYi00ODZjLWJhYmYtMjFjZTUxODkzNjlmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OWZkZmYxYy0zYzgw\nLTQwOGYtYjc0Mi0wMWVhN2E4Yzc1NWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASyVuiBrxtxEWVmzVN79dWkcb/MggfTWFhfuNLf2LWi5tUURapzUgdkbGPJKAXK\nbo/6PLvud3REEHgfo6Ug8hazo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFrnOatEOzea8U\nz2AjPj7Vn6OAkDAKBggqhkjOPQQDAgNJADBGAiEAiFzaBXGGBaXZ5u5gRE0A84J7\nFGZ7bRfmWdXXYSluih8CIQCixvx8UU8+vNN2ZMUlm/HfAANU07ReS/86kSEeGgM9\nNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7317", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7317` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATdlTy+nLmskXRfLI448ZJypMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyMmQzYTcxLTIzODUtNGNiMy04YzE3LWVkMmZmMjZjNzRiNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWM5NmIyYWUtZjI3\nNy00YmM0LWJiNDItMWE4ZDBlMDA0YjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExUDcHP5rIxSzVpIfaoLsSVti83aWPkFh0YZ0wt3/VN9t32UCrBCnb50DEpmw\noWwVhDgqJ2y4KuXFjbAMWAf5EKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSI7/6jNadmTLPjCBn3I+SLh2pY0wHwYDVR0j\nBBgwFoAU+7gpBovWI3McznpiAzDXXpA8HKQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIge6hyLON4zTab\nr1Uq8c9HtArrlwTQeDdyaJZC0eg/FvgCIQD/4FBUQNmksNXDgrA2YcGowawHYz7Q\nLpW0uztLziISzA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWGcjU3mouQoxgM4IzccpQ5dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjJkM2E3MS0yMzg1LTRjYjMtOGMxNy1lZDJmZjI2Yzc0YjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTIo8esnsNN2Z2ghIVEgA7Nsc6/HcxwtBPrfH/dcxbDmPE\nYYSf81osaen6uyjLCubfc+y+6OgjSsJBp14kPMS8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+7gpBovWI3McznpiAzDXXpA8\nHKQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWddsGnR2nXL0IILZYFBvAE9UQt2CB+KsK6uu5Rvo9F4CIQD5NXWHHr2Z\njKQ6MMqfCxPBztP1e2orRgOQMIvdsc9hHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISARqTdhCFcbk/0GUs4FoKgzFwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWM5NmIyYWUtZjI3Ny00YmM0LWJiNDItMWE4ZDBlMDA0YjI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MTBiYWNlMS04MTIy\nLTQ1NzQtYWI1My0xNzQyNTk3ZjNkNzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQEHwNpZMNeuxRtU61PXvZVlPa7dZIDjTKp1hgRtqSwnBg46KjPY466L5e8zAjQ\nk23Lje+HVGLLc9QCPTuMv6JZo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRIjv/qM1p2ZMs+\nMIGfcj5IuHaljTAKBggqhkjOPQQDAgNIADBFAiEA8WEPhEE4T2jp6aFhUy/jbRZy\njQMlpAzepNk8JKD/M/MCIGtJD7jbUpgnl8AHKiUUv36iLewAiLUx1hdj5QLCD7Dq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7318", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7318` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfCJTN+/2CuHA0qMvbEeDA57MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExYTg4ZDNhLTliMjgtNGYxMC05MDI0LWQwMmQzYTc0NjgwMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJiMjFmNzMtMzBm\nYy00MzdjLWJiNWQtNjAwYWFhOTI3Njk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtIHrAHDldj/l+gx9+aE9+dIajBIXtAcqlDC1WNDTMMcQYpd+Ek0JPNpoeaE3\nM5BnVgVrqcYH1ch0bU/5L7ytA6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlfdw6dXJyV0gPM5NA8gM0sEWCnswHwYDVR0j\nBBgwFoAU/3etojNsDHB/8SFAA9JXM/rYKzcwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGqhqowjG2V6\n/QuCL7rzqC0pyzQFqo5/VsUL78YaPmT/AiA6eCc9wPQWTxZB7sRXhn+HcQmhy6SU\nFE/CXmqkUtExjA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeU5N28YO0yOpUaf6eivinGCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMWE4OGQzYS05YjI4LTRmMTAtOTAyNC1kMDJkM2E3NDY4MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMXR7PoBSBACEEkhGfuLXdQxudsI7sIcpgjghsmj3y2SLb\nlZ/uVgNRln/VFM1CYgX0A7uHc5KmE+oBjSKl/d+wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/3etojNsDHB/8SFAA9JXM/rY\nKzcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPZMSwxy70UTNhqCsnSUp19XUKNx64rjFsAQtHKzTyO0CIQDVU9TeBu0m\nwvhpoAiNkR9JAufaDGbk4uz2chEGY6ST1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAcbH5lgGMtG14sTwi9du4i3EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJiMjFmNzMtMzBmYy00MzdjLWJiNWQtNjAwYWFhOTI3Njk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMjQ1NmM1OS1hOWYw\nLTRhOTItODZkOS05MzcxMmVkOGU3ZmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASSGrClZjz1Km1vvfxAj7hs3mBV3Vs1d9xcxninKhdEJvLFUWNOhdtP99CuFX50\nGmgolXqTWoIqiVhpVmUtym/Do1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSV93Dp1cnJXSA8\nzk0DyAzSwRYKezAKBggqhkjOPQQDAgNJADBGAiEA2wNm550D2PBdaehH0FBZ/NGz\nto8vL+DdJSq1rEgATN0CIQCRYtSmNjFi1nzyo+nu6da22MuYtA1+stN8z8Vn1aWG\ndA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7319", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7319` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeJ82OhaJL4vbbYo0AGMdEfWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2YTBhNDZjLTMzYmQtNGFiYS04MDJiLWQxZjZkODk3Zjg1NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk2Y2Q3ZDItYzEx\nYy00ODdlLWI3ZTAtMjdhY2RiYTUzMDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcjmXERTA+AtGNYTr46PVY2saINBbJRpUYy3d31LU3NAh2sJAHOBba8F20vEK\nXQzAbFwy89meYWokJrqtexM9zaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0v9jvSdEu/FJvvQiBlB3HptjguowHwYDVR0j\nBBgwFoAUguOjYpWOxMSnGPP2vui1b4QFvfQwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDdE+laXXpbBTOn+uF47iywMEUChj9oFPL69dMB+z8SHgIgeHTeCPaH3fxT\nES6ZM8qQ3dEGe280s193XFEDeJ/TsQk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY/0Q0vLe/buhGbZF1fdCEi4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmEwYTQ2Yy0zM2JkLTRhYmEtODAyYi1kMWY2ZDg5N2Y4NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATizgg9C6N835VP8Kel8HmuZLssaZDkzTZL1iJblMIGR8Mb\nyOWTPC2BF962Usw5gy19Sm+Vzb98wFqJ5N62X+pSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUguOjYpWOxMSnGPP2vui1b4QF\nvfQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUq2NG14NDEowQxUbLF7qBSL6mr/ZH5+yzGFIHWoP8sACIEPUWz60UimV\ntMj87UjGUWvX4jz8x8itVSDk+REmo04d\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAcFIh6rzAXcRBhv7geCZAs9CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk2Y2Q3ZDItYzExYy00ODdlLWI3ZTAtMjdhY2RiYTUzMDBmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNDkzYmY1Yy0yN2I1\nLTRkNjEtOWUyZi04ZTVhZDdjNzk3YjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQGDjNAKGru9VVjWC37xAGx8MzgnmU+1Ww/19/+IJ2XckX0Thj3jCrObPtxHvoW\njMuT95CHvZvXVNI0j45rblQ5o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTS/2O9J0S78Um+\n9CIGUHcem2OC6jAKBggqhkjOPQQDAgNJADBGAiEAj71o9A1QQfHh3gkEeTKJca6C\nZaKYSb/hNIYWSWGDeR0CIQCWFXgz1Ps78Q8u6KaPUkY4jWnHPfwJH+t+NuhW12tC\nKA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7320", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7320` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAe4KQVJciggWGs56egrTLkUxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxODJmMjc1LTE3OWYtNDc2Mi1iZmE5LTJjZDRkZDlhZmM3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTcxMGU4NmQtZTcy\nYS00OTdmLTg2MTItOGRjZjlhMDgwM2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGkhi8ooYpqxZDb5F1XpWI/j/FYbYZVywMbJfJufJBublK74JMzPpZ1k3f+ug\n6zWYwSmqZ/tLOgJnnO78t8VWRaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Vwnr2C4ELCOaCcW1oUbWQFY2JgwHwYDVR0j\nBBgwFoAUDcn9CvT3T4GpON7rhKN5pVP+jAswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBAEzjRteeBPXuaeYSu9vEQ/PTSk4NEsiVj5e9WCM9gXAiEAjoo/DGKSc5Gu\ndCvJOBHl1ZBBkom6az25nqTbF7x0Snw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW6vlZWi4uaYFAcOrerVfMNfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTgyZjI3NS0xNzlmLTQ3NjItYmZhOS0yY2Q0ZGQ5YWZjNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsOt2/ISmuWvPdHw/RdXvYcFucnnKnMoJ5HklvJhLOiLGj\ndBBf6Zw71bpQldN5LjtrJoyZBWTdHTCHQMUz8ZhOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDcn9CvT3T4GpON7rhKN5pVP+\njAswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJny/2tmZQSHtJuy+kA4mlbZg2E0W8mDMrWxhBfQaNMfAiB0bZvTjbMm\nfVA1Zz7gwhJYdcY4nI3NjrJdaDXDCQrSBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAUf0DMuZoJ97DrNcg+yZdU6uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTcxMGU4NmQtZTcyYS00OTdmLTg2MTItOGRjZjlhMDgwM2U1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNWJiN2U0OC1jOGI5\nLTQxNWEtYWFlYy1hMjhiZTg2ZjJjZjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATXBxo8LQoedbEfiEs2fU8a3YCY40QGgRPSTaxHSArUGEymX7zyerXl45X8gXDu\ncM2+S0845XvGhubzStPIOo3Bo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBThXCevYLgQsI5o\nJxbWhRtZAVjYmDAKBggqhkjOPQQDAgNJADBGAiEA3Wo6JTyEV/KcpMlLlUiRQ2kY\nwhJS4UOwnMOWtQXzt9gCIQDxUhnpysET14G+RpXX+lGcI1ocmu1hl3bVy0MkGIbd\nIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7321", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7321` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAc73/Nzv6X1YfUYPJ/XDemEOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5ZGU0ZDI5LTk1YmUtNDZiNi1iZTJlLWEzZGJlYmMzZjE5ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJiYWExNDMtMGVi\nYS00YzNkLWJlMTItNmY3N2FkMjYyMTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkuq4rfLTKxeFjE3cbPqIx8gLUGXx3GgQk3RERglw3OJX3l72XI0i9wW/kpeU\nSISrdt5c+yZxfGgGhCzaA2Zty6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYFD/nrfBbjWeE4kP2K2X8s6b2rwwHwYDVR0j\nBBgwFoAU+bRXu5pwM7xEJ+ozUiVFOgKcJg4wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGoV\nk2NJt1H44Fx2bT4QD1+PqqImZDkgj9C5c3pRGJd4AiEA+IKkWdAcUUsHTD+Dvu2T\nwOMluRBttDJJLqr65ZlILD8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT6+y9dTjaRQ7r8aBVgi2tvzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWRlNGQyOS05NWJlLTQ2YjYtYmUyZS1hM2RiZWJjM2YxOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6v4RMGrT3dmygdAteYRMuIUddV0eta5kjeTmVDDN63jwu\nv3eOfx1/IttDGj9liBlqWVPrWV1fCWIeZVTwQhD4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+bRXu5pwM7xEJ+ozUiVFOgKc\nJg4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMmo5+qkGPnhGw0D0z2UlC1HY9/un4eFzMxEj4+CeL8uAiADPjrZFp6I\ng9pxlQAHa7Wbeh0FgThAg6Fp8iSQp8vUfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISASmpvtAw7GqF6T357rOihV58MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJiYWExNDMtMGViYS00YzNkLWJlMTItNmY3N2FkMjYyMTQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMTQyNzFkMC05ZDg0\nLTQzODQtYmNiYy1iYzY4Yjk5MGU1MTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASCowwh+3rjD0OsjJJFsz5i4HeRaRroZDeimQznZGLHC9xoNTtgx1wJbcF8IHLt\nVzEidKahiLYqTTIHT/Gu6ubbo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRgUP+et8FuNZ4T\niQ/YrZfyzpvavDAKBggqhkjOPQQDAgNIADBFAiA+E3PG9mR4JfhOnzkPg7N2rznT\nyW5NfaQdvCB+qqMG1gIhAMhLA+iGHqm2D9FxGD6p2b4faFwzlIJRSHCDeNMfZHPp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7322", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7322` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAY9Cktd9gcm3o5Qr1HU3UAkjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0NWNiMjRhLTdkZGQtNGZjMC1hOTA3LTYzYjczODFkOTI3ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE1NDdhMzUtZWY2\nNC00Mjk5LWIwZDYtYjcxYWU5NzEwNmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtEeKvK0cNfgDuOZ01VFgTAoOkiTQnAXPBtaQR7rac3Jrc0YuUZyPFkDyLFA1\nncT2SPs7NPfy6BkvZwW/XGzU7aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlyttjApBFWQBsOZxlH1/HS4BnI0wHwYDVR0j\nBBgwFoAUGOfqoJ0gwfIvfFJsuXyQZvvUOR0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCK2eim9uZtHZc8UPNVCyzYpQ6oxZ+e3r9OfySTKbG9eAIhANac\nV3izfSq5wEX1tnATzqSWXuSIORSxkcm4z98GTzWG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdPh8xqbZTgqRnai2HNCdR8oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDVjYjI0YS03ZGRkLTRmYzAtYTkwNy02M2I3MzgxZDkyN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHGNTPNHE4r62U2SO8KC+DvyK0f1h9IgdagWaFXRjHzruU\nxrbaBShWQ4cokZXUzG0j9j3OIgNMWiO8Qu39cGl+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGOfqoJ0gwfIvfFJsuXyQZvvU\nOR0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMpdO42a1eVoPAae5ri1ivm41TqG5eHkramc1G34oSrTAiBVngQ2C+pY\nVRF8jBHBZ8u3Pd1HLWU3s3EwdEPLFDPHSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAZ93hCD7pj1qiy0xTZXoH8iCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE1NDdhMzUtZWY2NC00Mjk5LWIwZDYtYjcxYWU5NzEwNmM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNGI2NzkzOC00NzIw\nLTQ5YjktYjE2Ni0zY2E4ZTJkZGIyZmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQieXYEwAIlEcRCdIZOQx2Aua0s9GCxQwO4lqAEGkmNXMBNwS4KkW/IXO6IJq5B\npQpvkKU4AB6rlh7SXp23X+Qbo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSXK22MCkEVZAGw\n5nGUfX8dLgGcjTAKBggqhkjOPQQDAgNHADBEAiB1OgXnXDUSjSklpQddxx4Uls/r\nARjZF0sqduTPDP1a+QIgeObFNnSgLTSmo/ekIjdfu5PW3NzvIIWoum59MxghMqI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7323", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7323` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAWC1Qd3VXl9jTrM02kA3qzPiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZjBiY2YwLWJjZjgtNGMwYS1hMmJmLTlkMDgwY2I5NjExYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RlZDE2NzYtNzQ0\nZi00YjYzLThlYTctYTQzMGQzMTM3OTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEySnGN2srRp4mvw9oTNcSlpYSmAmYevLY5LRZRcAaqX1u8TS5C4XERKQAEayI\neeuLVA62nWoOPWvShyvvRfyqPqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqb3FpmeHxaPIK8l6bN5lZIFaRtwwHwYDVR0j\nBBgwFoAUdymJJgt4WhBXtvgfm1/+Waz/V2IwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCkuXO+qZV60oKX7akk5p8S0n2JasYBAGYt6KTxBH8jIQIhAMYY\neNPCnlnAuJCKuiDvGxUffRNXLWkFfuFU50RVb/of\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaFDRCAannFmEO/DhkBEszrPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGYwYmNmMC1iY2Y4LTRjMGEtYTJiZi05ZDA4MGNiOTYxMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzeVw+8UgjIuElDRZIv1KX+bi+qO4Co80CLRAU6ThR0Ek1\nevJo5zebjR5fizn/0bQrMzeON138w9xC2SlL9auyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdymJJgt4WhBXtvgfm1/+Waz/\nV2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOdKx6P5l/+8O9MnUz2/v/kgMoqE6uuxLVbZ+xsrmf1sAiEA4GfSZLzF\n7cfGKqiSm0ZhinS8Hldef9r8IV8sLrMziY4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZe1RydLS2UJKL4xnHRlZCO5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RlZDE2NzYtNzQ0Zi00YjYzLThlYTctYTQzMGQzMTM3OTM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OTkyMmE1Yi00YmY2\nLTRmZjMtOGQ3Mi0yZDk2MjljNTcxOGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATnfv4jS6+guHqal33hj/+048vJPc07hJS+Yf3Xv8m/Klq452fpYl2qprXQw2Lc\ns1p2wwZvC8EXUVVgYDZYDfVJo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSpvcWmZ4fFo8gr\nyXps3mVkgVpG3DAKBggqhkjOPQQDAgNIADBFAiEAsJr/AdCsA+zt04mvu3OdRAir\n7x81haUo7LKWmjiPE+MCIAC170crSqsWvdzPRaST+kMY1FXaA3eZw1fAFSLr+HEz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7324", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7324` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAZAouzni9jmwGZg8d28U+FXGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyN2ZjOTIwLTgyMTYtNDc0Yy1iMDU2LWJmZDVjM2Q3ZDdmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdkN2YxZWYtMWZi\nMy00YWI1LThhNjAtMzg3MGM4MzhkNzhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvQU2K++19uIZolH/itHq6YhRJIzaTu51UoI2sjxGlA9KfG5nVrfpHnT7GxYU\ntRRkmJaRaPXh42tRE2/GjriFnaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQAHyk/wA9Vuqp2SOEM0K8YDRJi2jAfBgNVHSME\nGDAWgBSEMjR5GbpBcJPLdyL2fjg3IAz51TAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDroBPkjWGfYpqtPaqkxYTUGMnq40wi\nNEuBZhQPIRZLJgIhAObHmJeOX6nUjh/yL4ngWcvgdr937AT06B65uS/KVzTI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcTwhgkjee+NygOCKPZmHobpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjdmYzkyMC04MjE2LTQ3NGMtYjA1Ni1iZmQ1YzNkN2Q3ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbJ71RGxjEmvOzogl7p+Z00nWjcDRhnMduztY126ZSITX2\nhLLNEn6B4o048xYTPBjQ7ENofAvxNnhnKkWpjjnxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhDI0eRm6QXCTy3ci9n44NyAM\n+dUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJpyqHfM4Od4TzsVHR4ynTARsGu6Y6AKYxBup5ZV1bAYCIQCpUKx3Z4l5\ndZ9DKZl8Y1qG3o6j6zycu2wPj6OmNyvzAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAW0NJ5EW7zhrJdeRT4z6XDttMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdkN2YxZWYtMWZiMy00YWI1LThhNjAtMzg3MGM4MzhkNzhkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZjU4ODY2My0zOTg0\nLTQ1YzUtYjMzMy0yYjVhMWRjZmJmOGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASMm5i/VDzJ1ACy/AvzrRXi7PUptpNQU1MUA9fTw1KBF14oRebQBxphUexkqsQG\n8OCp91wbPULd2UssufpSmeZpo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAHyk/wA9Vuqp2\nSOEM0K8YDRJi2jAKBggqhkjOPQQDAgNIADBFAiEAoQtPeXWLaO/oSgmwg8igHxWn\nW34fiWBJ1UhaKUzDlM4CIG9LcSV7a6cUjQYVmD7BEMcHd/SFs8WQsyWreuQngsEg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7325", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7325` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAaOayrbyEQCUDsgWiLUcn8rhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyZDk1ZDQ2LWEzOGYtNGU4NS05OWU4LTYzYWE3ZjIyYmNiNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIxMjkxZTItMGRh\nOS00ZjM0LThlMWItMzA3MTljNTZiYTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm73KeuEEIYT7o2EV7f8SmPOqpt/y2lKC3z2VvD2UKuAy2lnETEp9t8DwlbNi\nai5epbYqRx+cUvES14xihYNx+6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqnsU9ZkogHq8k4k2zojiFEkaCOwwHwYDVR0j\nBBgwFoAUI6eoOHcIk/bU+me/PmhV4fvYQX4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIFfcFMLgQx3M\nKvbLPt68txJD/AQDK6hiTZZVs3DtrMiKAiEAvixxp7C0x1FidP3hj7c/kIBAs9PW\nOS++cuezETvC4Ts=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeuhCaMh16hEvCsgRicloyBrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmQ5NWQ0Ni1hMzhmLTRlODUtOTllOC02M2FhN2YyMmJjYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6xB90tAwAz1m3pOcTPt004YYzmxu9yYMKn/vMr3DBvh10\nIFXRNPV7knLhycGi2knapXbX/QxqhcER8Reh+PsQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI6eoOHcIk/bU+me/PmhV4fvY\nQX4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTis174V44My1NPhSkW+GQjgcA2sGEmvEVvNkd/sH84kCIQCUlu+SX8KW\nVj+rLyyXb1px17KRQTOCVq/4fmixAwmPkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISARiehmcusfovSIhliUdgw9niMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIxMjkxZTItMGRhOS00ZjM0LThlMWItMzA3MTljNTZiYTBiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2OTBhMTAyYi02OTI5\nLTRjOTQtODgyMC01M2UzOTM0ODk0YTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATBiiXrYsX6zVRbCL1JOEF71/xQ5Oln3HuyE45NNX0yzTp5OFj4rdydII4YlMS0\nwkFA4LbuCKLLq7tfRsHm5FvTo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSqexT1mSiAeryT\niTbOiOIUSRoI7DAKBggqhkjOPQQDAgNIADBFAiEAxNr0radNwHFTJrLIpHXqJmmY\nEvqG+uAG9t6KY4cz8GoCIHJ2A8wdYO/ykDfk/HBM3dFcSvEgTxHDhdGM17GgfDjR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7326", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7326` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWeMmnVuAEr6qGVzHPay7DqMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0OTRiZDBhLTI4YTItNDljNy05MmI1LTQ3ZDVlZWUxM2Y2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU1MGZlOGQtNTVh\nOS00NDNkLWI1NTMtOWYzNjZjMTgxMzFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnp6PM4kMk8zCjWo8pJiEoLVLOuzsSiRq5CIgJylyxCmL5vOk7OChycPHnfIR\npJ56Dytc1pxfKjxOgQuhS3FfpKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9cpzxdCk/abZMikqJo9+wlf+7gowHwYDVR0j\nBBgwFoAU+VgxMuopRqDGB9n4mG422Y5ssPgwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIF6JMM39ZkU8\nupNAjMXoD+opfYsagLmlVpTwu5aOGe9XAiEA8xh+t834wVFQyZCv88b5w6kQCFFF\nUUz35mBYj/OtHwo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVElYXdkWJ/z4vn9CiiFWAhoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDk0YmQwYS0yOGEyLTQ5YzctOTJiNS00N2Q1ZWVlMTNmNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARteYRx6n9av5dK1TqcX6rIJdpwjjfgTUtnb9u02OpJU2Za\nyfXqPU4gWqBcJFhcAVrRYlehZ3Zkkc79MEJC/Y62o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+VgxMuopRqDGB9n4mG422Y5s\nsPgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfXCSRy/s2NrtPuSx6j22o5hrfBtkPWmq0ldtpJ3uQBYCIEy8aZGpAFIA\ndGUhzWsqPqF7ppFYgCNam8LEXzZJ3k2H\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAcMUvUSTNKKHTLGXYLdsVFTgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU1MGZlOGQtNTVhOS00NDNkLWI1NTMtOWYzNjZjMTgxMzFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZmU3YmVjNy0xMzY4\nLTQ4MGYtYWYzMi1iNTU0ZjBkYzMzNTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQOTR733Q9wAdzI3HFOg7PU2Wh/mhn+flIwhhmQGsCi7WEeixtXo3AadbFAN3dt\nKwJlzsMOYHaPPqnCCs6R5joao1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1ynPF0KT9ptky\nKSomj37CV/7uCjAKBggqhkjOPQQDAgNJADBGAiEA5no5Qbd6rgs4Y4TJcCk3QXdw\n5HxPXeh9342ErWpPNpkCIQCX7xGW+ItUZayYNfvcOOvl2QCAiDSkTmYEZ5Q+bGrN\n5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7327", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7327` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISARyoPKnxkOCYSeunC8ndS+SLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZmQ2MmFjLWYxMTEtNDlkZi1iNTE2LTc5ZmE0OTdlMmM2ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJmMjEwYWMtMDkz\nZC00ZjIxLTgxMDgtZWZlNDE0OTc2YWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5qItfKdh+v9MWBtyN6ZVFBjFsiLtbSzCBzzIBRGae8MJDmXAOzzAu1f1i2g+\nT61lRM5AteBa94qhujgjh+7WI6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHb0+HKDE3mBV03hNDP0YGqTU8Y8wHwYDVR0j\nBBgwFoAUDiaISQIq9Cjgh/h7Bv0pkQ8gmcUwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAUfe3QuRlD\nP2jl6JssZa9cv0eR+v+FMLesAl4IxGLYmQIhAOXZeovvpKBCvYq4hP/QCnrAOCtJ\nSjtEs+oKek++Hns7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ9woCISFy8bYaPAYI4UjFEpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGZkNjJhYy1mMTExLTQ5ZGYtYjUxNi03OWZhNDk3ZTJjNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTU4Dh+EL6JIqQCEolAA3UtekAhZBYK5bTsTIe/q1Brc+8\nB5h6zi20OYPtKN0p1Hhp+LFAUiw1PFqmnr1T/zUJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDiaISQIq9Cjgh/h7Bv0pkQ8g\nmcUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc3wkTIMDJgEtIr/os9E+vNRqeKDv0MI4XiTBmMk8NOcCIQDSoqUNawl0\n93GUAroOf/HqXDI4VY7pl+K+n+FdwrV7Pw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZg7KpfJTWCxmuBDqECC13HQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJmMjEwYWMtMDkzZC00ZjIxLTgxMDgtZWZlNDE0OTc2YWU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZDI3ZjA5MS0xMWQ3\nLTRjYWYtYmQxNS1kZTNkYTJjODIwZDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQNvJRWnXyt4PBAfzuucA25PcRuygdmp3kj02K8RdUuePcljeksANJ7IPbQN6oe\nEbz7gtHobxyT2ROSjseOvP+wo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQdvT4coMTeYFXT\neE0M/RgapNTxjzAKBggqhkjOPQQDAgNIADBFAiEA03OYUQg11idbZH/sQkNYnKVx\nFN2mrj0v/bRO/DUtJPACIF3b3BTH6MyFAltAY2+taPBfJZ54XZTZP7BjvSay9ksy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7328", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7328` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAZInNP5w4OTUSpgYE+YMDKWaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3YjliZTUzLTkxMWUtNDBiMC1iMjFiLTdkZGY5M2RkYTkyZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY2NzYyY2QtM2Jj\nZi00ZGEyLWFiYzItMGUxNWMxYTY0MjZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEETt7U/IcR+YGp7VPrkMxS95qgO2V2DrQlsM/+KDACxIV99XH+zSSgpIPJiL1\nu9XuFMtkUI79+KqTBQx9puUMraOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQvo+QtbrYXauN2Tp9bLJcdtcv3AwHwYDVR0j\nBBgwFoAU5RI0s6kfh0KLm2zb7ReD6DwQ9vowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAr/m2Gm7wmtBQ9mgyU6uWjpxvMW/8z0tojeWGKTV3X08CIQCk2byHiR9l\nYJC6az0VbHx/Mavu4tnlF8cUSGOIy5k//g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQAJwmLpJUepbofHrkwapu+bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2I5YmU1My05MTFlLTQwYjAtYjIxYi03ZGRmOTNkZGE5MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCrrppM92/TNXTB0NkuLosdOAAe6l0xy/z5tE49QV5YDEU\nGy+4YVOdopt+wV0XV7t+4UkGIbvJDenBmFDYfBG3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5RI0s6kfh0KLm2zb7ReD6DwQ\n9vowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJjgvyljNTZ6xKrBWM1nBXhi/WmqeqUfrCR8EVE3XUFUCIG/Ek+zH3+LJ\nZPyNGvasOzE0IbtGZOBt0u5x3ffMTRVz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAcbqDrgVLBthPtW+gEBUWtNiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY2NzYyY2QtM2JjZi00ZGEyLWFiYzItMGUxNWMxYTY0MjZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YWYwMjg4MC1jNTIw\nLTQ0MGMtOWZhMS02MDIwNzJkMzNkM2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARquTUaA4sl7Dk1TpIgyKJtsFqta3aLhSB7LWpMTETbEvyFOvd4Mys/fblRSiAq\nRdqz4xElLcFJudl2ia4C8YJZo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRC+j5C1uthdq43\nZOn1sslx21y/cDAKBggqhkjOPQQDAgNHADBEAiB3kbhL6TfHE73d2xg+5TY14nld\nHMpDX+3B2MbEWChELQIgKJ7FFJnFb9OqQYyj6VVLTA/Z645A5cti0gr4tG3cs+U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7329", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7329` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZYnrdOT/jtoop1G1nWzl3BVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3ZWE2OGZiLTEzY2MtNDA0ZS05MTM2LTY2ZDJkOGY1MWJhMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE1MDllMzQtOGNj\nOC00MGFmLTgwMDQtNDNlZTIyNTA1YjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGeMLPtqcAlMnMdmjvqcPnJRRuJELuWFhFzHmDdE1kKWVv49JNRpqyoOkCUAt\n/9M1vzOTeZlFIJDh6RPHQRjizKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUodS+brwPu2Ai48d5oOnihvwgJwwHwYDVR0j\nBBgwFoAUxj4FPGj0RgixaLwwUWbEClTAEYIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAxpQJzy/iY5n7lj/V80ltk2kMSzrgAduFmLRKdH5vCCgIhAMidvSzKgXd2\nsGQPqel7KlXPYGqGk9mmz+scZ45zLZ45\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdsxqMkQ1X0Ee7aM0q+qu7MPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2VhNjhmYi0xM2NjLTQwNGUtOTEzNi02NmQyZDhmNTFiYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWVkoNoaah+r2FGayvPie6uQTYfqkIaU2keYU652o732lj\ntc85XM0S37UeCTc6PxjlNKmgTt+YjuWShY5lhsAko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxj4FPGj0RgixaLwwUWbEClTA\nEYIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ0DspuBVy4pxAc2PSm2/Mv57ywhM9gb0pOwkHvVAWaHAiEAnab1OptN\nUG7uZgi+KdEBg4AMdP7An95g62vFmSydnTU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAVVvYtSACqa7lQG7gt1vCv6OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE1MDllMzQtOGNjOC00MGFmLTgwMDQtNDNlZTIyNTA1YjQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNDIxNzNlMS0yODlh\nLTRmMGUtOWU2Zi1lOTMwNzFjZTM3YWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARoou14kM/WmkqGdy5otCllXXmldRy02mZAfZWUQ3gaaDskpg7UYrh6cCoFP6wq\nguiFfNNkUryIkC4rLmq/VMRvo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSh1L5uvA+7YCL\njx3mg6eKG/CAnDAKBggqhkjOPQQDAgNIADBFAiEA+Q/Mw+CU0Lpg1F7ovh9tWz5+\nQz5tK9/etxE8enehyZ4CIFddSFkYvRWcIAE+U1n1LM+wvwEP03OLkG5lz4eSVVrS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7330", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7330` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAb8dMWEyZ9VHjfLqVQqfF7FHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxZWNlMjExLTk4YWEtNDVmYi1iMmI3LWViYWRiMThjNjJlNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUxNjVmNTctNzA3\nNC00OTlhLTllZjktNDA1ZjE5ZmJiNmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESY1oBP7XxnEKIog4sdBlSu/HYvLHsTDTvIdi1tzzOt3wBk7LdWy/iaX5y1Cm\nDGXwKHZKcS+VJf5iq5gyS5raU6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq32SFtKkpvn0QsOXdCwWdapHtiswHwYDVR0j\nBBgwFoAUB+MjPxYyHTl5i0DIwIgqwzQCLM0wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAM\nkxrxikRu6eFMu71bZx9F+UT+YSZCDf3aFOu6eM/WsAIhALA1m6PcoT5k06tA+DhE\nU1mFIY9ZRqE+0/VuVUfJoAxM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQX3j/hoRbxLF+j1rVZoBrBcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWVjZTIxMS05OGFhLTQ1ZmItYjJiNy1lYmFkYjE4YzYyZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ93AhjFcuIHoiYudZWfBqlySm4/1TauC3v38N6FsAvCpW0\nIWyjBKJ+lXGfUCqVT18GmI8q+iUmn2tVKbIei/Yeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB+MjPxYyHTl5i0DIwIgqwzQC\nLM0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDnHepn+qAZZVANIHiSdtouilvEFrHffk2mSO+pojluwCIQD3XOVMXzMu\nZn4ecfPua2dXraYXTvpEmpd48ayBFUwV/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAYNJ6OVnMvli/2dCzpTYIPIvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUxNjVmNTctNzA3NC00OTlhLTllZjktNDA1ZjE5ZmJiNmZjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNWQzZTRjNy0zZWRm\nLTQ3MTgtOTBjMC01NDAzNDI2OGQxYTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARJeHoVUo0S7OBs6+di4QyGmXudA3jQmYR3ieCPdSoY8oaUl6wQJsdsFG4UFIJn\n9d29a1Kb8bi06V9v16ls0G7wo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSrfZIW0qSm+fRC\nw5d0LBZ1qke2KzAKBggqhkjOPQQDAgNJADBGAiEA9/d9bbXLkTbPndgBru3L7/Eq\nnrRuI8qVaFtb9HdtXfsCIQDVgAQ7Zkfl5p6VrLSB52GEgLiU3AKqP3Nw6X0O4ZhW\nHw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7331", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7331` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAT8FMkwgj5aMDGCIxr7TdhALMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyODk0MWQzLTE5YmItNDUyMS1hMDZiLTZkNGFlMzM1YzgyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE4YzFmYjktNTU5\nOS00OGE0LTg2NjUtYjY5OWE0NmEzZjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwWMjTUNsfCQsd5QYYgraMHFBb5mL1dswHV/iHzr2uNo8v6CdbpsuApRJIMdj\nbGdn4niJGysAIXDq3HxGkirn56OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1jikD3YsbCsL3nor+euLSiPkc74wHwYDVR0j\nBBgwFoAU7C5xFtHnsD3NlGMQ5IBenIVffM8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAqK/RrItp8/VPvoeewI5pZknj6ldODuBlSJDYDyo+mZICIQCa\n9tlISO3yeADxqjnO9/fYy5swSOTuZybVJEA9zAhJfg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR3Maq0tnZq3NpLzGMf3ITVnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjg5NDFkMy0xOWJiLTQ1MjEtYTA2Yi02ZDRhZTMzNWM4MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTHKUJ/CKa1EIGMMghfTt4KT5u3w+ooSNxdzgI6jarXZ9J\nSn6omXy6acZp5Sx946XuPgNmbWa8+WwRT+KOksFuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7C5xFtHnsD3NlGMQ5IBenIVf\nfM8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXI/ChpyH44/D981GZ8Sk0cViFd9Pvji7Knjidj6RYmQCIFB3L7MWv4kv\nfxHcZuZkEReIHd6cSjrR+XVk78zBNKoB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAaPWLZ/kRPv1MDXyI32OqWKvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE4YzFmYjktNTU5OS00OGE0LTg2NjUtYjY5OWE0NmEzZjJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlY2FkMGQyYS0xOTRi\nLTQ4ZTYtYjdkYy0wMDlkODM5OWM4MjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATmTPwcAwRpoPbjbNhb0VFqvcxRpBUEz2AoRfeHOWTqGKOp3p2KKGzA/ckAJhoe\n4CEqtrL9yb8EinJJFfJrN9T+o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWOKQPdixsKwve\neiv564tKI+RzvjAKBggqhkjOPQQDAgNIADBFAiEA/j2Cmu4eJ/jpGjqcXrCRa47j\nUXlKbWS3XnAdbEG8dEsCIG1+CmIeJJJIfGHemUBAgj7aOO1IRWyAlr7iMLHpEnTE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7332", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7332` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVVAWMkWP4NsZRIMP/jrgVuTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0YzgwN2VjLTM3YmEtNDU5MC04MjkzLTEwNzY3NWUyOTE3ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQ3YzVjMGYtMmEx\nMS00OTQyLWEwOTUtMGRiOTE1MDU5NTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBrj45FdCCueJqICq+Bc0DKvxCK/uyhUrZ16Hi5wSy5RouvUsPO0KtIIocrzn\ny8IPJfu8R/PG+xTrOJE0trng7qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJH0XUnMUDvZBGRXG14UU7mcV+38wHwYDVR0j\nBBgwFoAUrw02k7sE014p5tgUQC0S1xG6EyYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAljkgLbeBrBVDYRtrfZCY6o/E+ZxjdGzCJNA1W7g5OBICIDn/\nWf9esjZ2AZuHTnTMSBFcwYGg03rLTvM96kLSqaWe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUrmwfQSNlBCHXhj309hcCwCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGM4MDdlYy0zN2JhLTQ1OTAtODI5My0xMDc2NzVlMjkxNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJ7aD5q+ye//99IZaRnkCeWsU+QkJFldZAcdlKnUIO2jXh\nregyYnb03Fq2HQq5lV9X2hEYZ9yp4rHB15PaRfrDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrw02k7sE014p5tgUQC0S1xG6\nEyYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCbD2okCDVroCi/wvTuasTJpsZoUCAbVSweiFYf7jGkUCIQC7NZhNVz6+\nvsYSWJltljijc6KkIvGgLjbxMhLvZHJZIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAVNfeKx7g/5KscqP0NtyBonUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQ3YzVjMGYtMmExMS00OTQyLWEwOTUtMGRiOTE1MDU5NTliMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NTU2ZGRjYS0wNGYw\nLTQ4MzItOWVkYy03N2ZhMjQzMmU2YTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATONXgDpoHjMdsM60JqRIVUqHQ7MSVC2xRun8ZxLdj7MAoD1qQ4RiZSAjE5Pzbw\nWxZnw6m1BluwxdavSMG8IGZRo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQkfRdScxQO9kEZ\nFcbXhRTuZxX7fzAKBggqhkjOPQQDAgNJADBGAiEAtZZfh0I8Pqa/dIUM7H3JNx7n\nTurHfbTYrl5E11FBdpACIQDGi88TV6Wc4hHon0Oplg6cGxMTIG2hHiNeVw5rNSH3\n9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7333", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7333` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAVNF1I5F36eCi4dZCNxw74JsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmYTA5MzViLTc3ODMtNDExNS05NzhhLWVlMGEzOTU1NWJiMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkwNmRhOWQtMzg2\nMi00YzJmLThjOTUtZGE4ZDM4NDI5NzViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl3jQ5ufFecGoiQqUTROAkhkLUqC9cNkI4Fj0ssrFkC0O3fH8CllAp7ohFkM6\nGUE527Pc940N23xiE6hYIULNIaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2pzVeWyC9VIduBd4rY5vqyRQY3owHwYDVR0j\nBBgwFoAUMX+PuyZBUpSwSq6ofJJXMUJ2gc8wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAjbdSci7WvDBj\nlKz0Hmy3vRAHUD185wSvP4B0BU76oMgCIGZhKUwYiWlTMMBNSwN/FcTZZcE/rb8e\nevY6CLvpuD5o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdh0A4mnHn3O9yuR8Z75veGgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZmEwOTM1Yi03NzgzLTQxMTUtOTc4YS1lZTBhMzk1NTViYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKWuPNpwYM3PMr2lFDA9GAzdzFoXtSW8APzpCd79IXSodo\nfKk/7dMRJqUpHaL2kPe6DiLspf/y4XKciQDvEzr2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMX+PuyZBUpSwSq6ofJJXMUJ2\ngc8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAISivsj5/6dPRKgJPNxF7PYb0nRp1BNcjkGc6g8ZYDbdAiASsv7OgrKM\nNgccQx2LjJ1lwZELiPOl436W2g3cwJJkmw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISActtARJ0bbYJeIJY5BRkwKVtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkwNmRhOWQtMzg2Mi00YzJmLThjOTUtZGE4ZDM4NDI5NzViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NGU5OWEyOS0wNTg1\nLTRhNzAtYjNlNS0wMTc2ZjMxNzE5ZDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASCkMZiH0eQfxigbBCscA1W+lNxsDwHeA20Y8PF5TA9gbX1clzCzbIE1dMuBkt1\nHztx614IfNZiwHxPygmwb64jo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTanNV5bIL1Uh24\nF3itjm+rJFBjejAKBggqhkjOPQQDAgNJADBGAiEA8DAwrATChtk5k/jOf/bLqsEw\n92J5HgTLZwSwYvkrk2ECIQDri2dxzuf47n8FWv/xbpurOJvsQiN2l/PKtA3GF5S3\nxA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7334", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7334` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAf2vz8a3gPVaJEgcTOsId0ljMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMWYyYzY5LWMxYzctNGQ2NC05MGVlLWExODllZmM0ZWM3NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBjYjA2N2QtMWMw\nZi00MTU2LWIwZDktZjljMWE4YTNmNWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnIVbRJlV4Inl6g9fQTFuNiDAxomj4MP+sam01wvABY9ImMlkWRws0LXaydt1\n8ErdLScoJRNHRtCE75CrJ6BKoKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdc71rmb4d2gNQ5AUix0uGFYhiTIwHwYDVR0j\nBBgwFoAUHmtQdSLrTa3RXNrbJlOlKqtwtRYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDZW/sVRhZ2Ix3iTwoFBci2wmnjybQKr8U/TCm5frl8wAiAQsMIYycKX89O5\nOuRIbeYqo/0tJr81B6nm6SHqvaGXRA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZIjbWAMOJ9JmckEJakMSjzJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjFmMmM2OS1jMWM3LTRkNjQtOTBlZS1hMTg5ZWZjNGVjNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpv5TUGm2LkKRtT/sKG4mIKdHcdwjMi8yuGDfcD6OljEfA\nxcaZ5rVtihAfOh/eA91tIZHvBvyix4Mso5ONvxCBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHmtQdSLrTa3RXNrbJlOlKqtw\ntRYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK7+7/Oe01XVmKa9UCqUpzjXeeP8pw5JOFqx+Sm5ykXRAiAhwl0Iq7ZT\nbXpQ9eAMEvQgR8UkCAXZV0+Sleu1AwQgtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISATYnmWmNxkzExgo9Sz7scHaYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBjYjA2N2QtMWMwZi00MTU2LWIwZDktZjljMWE4YTNmNWU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMmY1ZGNlMy1mNmVl\nLTQ4ZjktODlmZC1lYmFlODI3ZGQ0NzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARcXAAsSAlqU6b9NHcwYbHp+f+z0JN3Ie3e0cFML8gwvFLxM0EnFK7V2riErYg1\nJfCHegcXBA95VSgFlMDDgSRPo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1zvWuZvh3aA1D\nkBSLHS4YViGJMjAKBggqhkjOPQQDAgNJADBGAiEA7b238xe7mSazApJXD3Dx/0HE\nNJIvMvr+nHYjeOT1F5YCIQDvJnCsblSf6w8Cr7hoDUKcZHWKMLq+nOxQiB+rup8g\nEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7335", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7335` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaWW+m35xmeqiteQwQubSclaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3MzBhZTJlLWNiMmYtNGJiMS1hMjE5LTQxM2ExNDI0YWU0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBjODA3YmMtNTU5\nOS00M2ZkLTkyNzMtNTAxNGMzNWY1NWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEypE3XB1jCPdOZ8U8pWAnkWzQPUqRDIvDCfGYh9yYPqFWZ6A5lUhIql7iqxId\nB7pFcuELm5tpxs0GP7sa8v5Qk6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/jaSaVYCXJzbgcOWOhwJBdCjVXwwHwYDVR0j\nBBgwFoAUChYCUqAlG81zoYa3PLM0EEaGMP0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDl3HKtaZMTM5T4lYpFulcw06mVEhqnfvElWMM9Bq0MQAIgM7MRTCnjyQzZ\n5ip2fNGyxmVajXpIAhWst0Mri62awCk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdPfCEWbBdzla3fsRqjSEYMlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzMwYWUyZS1jYjJmLTRiYjEtYTIxOS00MTNhMTQyNGFlNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMVWntdFpCP4lz+zFc5bEy6MGwmfaEGW/vS9DrBcQnOCwV\n77cuAktQ6GQrHDpZwuneyqG26vnFiQZMfvJQ0sA+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUChYCUqAlG81zoYa3PLM0EEaG\nMP0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMyVzQJfUR1bst6X3eojYHH4zmsHtaG9gnJvenlZVTVGAiBBAnd0PqQk\nMh6/f7oyTI8GXF+pkGT301STDCGGIoA3uA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAUqgFOz7/o8oXYLt+xj9fmHhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBjODA3YmMtNTU5OS00M2ZkLTkyNzMtNTAxNGMzNWY1NWRiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MzYwNmNhZS1jMjgx\nLTQxNzEtODJhYy1iODNiYzhmZTc1ZjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASDwrBW0a1c+SXbCR+7YPrdR45qY4ItyiFmXH3+M9YrAp70RpDuMyc1AzwEUfG+\nAEGGZ6YNZPP/H+flfPZKGmXoo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+NpJpVgJcnNuB\nw5Y6HAkF0KNVfDAKBggqhkjOPQQDAgNIADBFAiEA+ZsRB4o5g+BYV58y5frpWeSD\n1mvpk4cYxE0w6rzVXf4CIA71vuOo07rHDnH694LMCfcDXGJNk2YkFmRdvMHJ5Mxr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7336", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7336` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAUUXCmRs2NbzrVWUDKWB1LW0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViZDg4YTdjLTZkMjMtNDlkZC1iZmU4LTdmMDJmNWI4NGZhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY4NmRiMmYtOWZj\nZi00ZTU3LWI1ZTUtOTVmYWYzMmYxMmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV16hghPqTT40Z20lp0kC2xRPb7DibQdnjVea5KAHR7wXpY1Q4a/LJnvUKLQ2\nza08bbk1NSYo58ODuDFECeS2h6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1NltMmGjJQJfqbUFByEcRYfeJj4wHwYDVR0j\nBBgwFoAUxingoltohiBffa/5ASwjajd9nI8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAhSd9yzeQDU+PM9RuAsugH4UOI9nxuneDAWBZy25s++ECIQCv4Dg9HwQ+\nfJr08jEEEyIESFgB51GVY+oDT0sdlFhtfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARtYH+FQ+Ck2wo1gDE+9KFqrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmQ4OGE3Yy02ZDIzLTQ5ZGQtYmZlOC03ZjAyZjViODRmYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFQL8sPRT8wex7U5rBdDKSN2GCq0eNZ8Rhy94mHTkUwa9Y\nkTYiJJfSK79YNsuuUmTv92ZKl9Rn0xcnwzw4RMxJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxingoltohiBffa/5ASwjajd9\nnI8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIFB/om8g2hEYtR5Qawfp+AKIDKTZAp4DUwhu2N5253NAiBKaHK6oadG\nzb8N7m6pbO9Qj5k51Uou1/e6orb1aF6lJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISARlTWiw5QFiifiJDiNp8WrM1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY4NmRiMmYtOWZjZi00ZTU3LWI1ZTUtOTVmYWYzMmYxMmVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YTE5ZjQ1Yy00NmE2\nLTRlNDYtOGQ1Zi05MGU5ZmI1Njc2ZWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS9fnoBDCNe5KTYmLD3wkgo40AIGv4LxdLLt+IGPomyV7xsNeaZ2th9rfnEpeyJ\n947gtbnkpR7fhQgw8nczdVhJo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTU2W0yYaMlAl+p\ntQUHIRxFh94mPjAKBggqhkjOPQQDAgNHADBEAiBaq8Dd4RN6G5F1yyqEkLlpg2r8\njB34Z2AHRfo6BsuX4wIgCX1RzvFBPtaHkhZ9XBBL8F70KW8/Nje5zMH3pf5AOfE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7337", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7337` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAfY/AkwGcEv05xO+v8wbSg6RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNGIwMWI5LTBlYzUtNGNmYi04MDY1LTUwZTZiNzg4OWUxNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjYzZDIxYTktM2E5\nOC00ZTdiLThlNTUtNDJhNzQwZWQxMjgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgrbp1DO98zUnrJVq1uj7OvNzmCw71i+GSVpZsCbsq8gbvURv09g2BdL83i57\nhBt9CNZZ2LjZZQV7cp7UlNnsjKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU73z/1IJ3qg/+LfDIqohYsgEEVR4wHwYDVR0j\nBBgwFoAUep4KinZ1VA875GS/ltKYISPI+MowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBUqYRRapJ9zYZ4Up+yyp1r3bUtVUyRoqk0VJxHYPj4\nMwIgC6esdMly/RrMos9reqm7reqD9e6RHgtYYxTpiCnf/cE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVeGECdyjF1tDQQHZy/qSQ1uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDRiMDFiOS0wZWM1LTRjZmItODA2NS01MGU2Yjc4ODllMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdjFejwSoQU6Qwmqqi8/l29zynVfnhPvP9BeTleYrE90vB\npqlk+BfCzu9EovJRPgceQCBcNbwOAssEqIazZgb5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUep4KinZ1VA875GS/ltKYISPI\n+MowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYV9mt0jAX+KXjKnHNRsomgRt+UGZStEkeiz8WZtkLvUCIQCZZBcAFidv\nvZPSu4pkNQiQz8pqCuD5d/3Ggpf4BqTMFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAWGesencwT3pUV91KLeXzfbZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjYzZDIxYTktM2E5OC00ZTdiLThlNTUtNDJhNzQwZWQxMjgzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZGQ4MzQ1Ni0wZDVi\nLTQ4MmItYTZiNS04NTNjMGEyODIxZGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQraYUAAzhNTSOsIsusauEzcYZiLSRqI75tZ7sjR4And/N0eUMcb6z69xQ8fehd\n1IQXvFk4wqdouunurUhdpEZbo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvfP/UgneqD/4t\n8MiqiFiyAQRVHjAKBggqhkjOPQQDAgNIADBFAiEA3J0jfRK2xQ3iQ9IiRFOamuha\nU0x3k60DGMohLHimNcICIAWUsrq99PVW+GiS6LuddhFFbozOsz6YG8q4EYyNIvx5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7338", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7338` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAf5jp7tDsHMevGIWbhdosK7iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1ODBmOGQ4LTc3OWItNDgyOC04NDkwLWViN2MyNTg4YWU0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE4OWM4MTEtMjJj\nNS00MGUxLThmYmEtMTM5Zjg2ZGMxNWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp6zKbAGc9loxN2GxKMkOdJ6SzCqFCcvIJG/cX1TOG6CAp/pJQH/qEvCWGNpg\n4085jrC7u16CD8rYDYx6D4o9LKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdiCbiJp46BnbAVcEXjEU66jh7z8wHwYDVR0j\nBBgwFoAUl5Oxl5BtPF0zl71WhuiJ9QYjLBowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBY6kZGlmYDowCyKvd7fZvEx2FPvb0FxUUwUzG/fuOf\nRwIgFgGW4Rb0Kbtcg57TyTAHZiGp0CmQvSF0QD7ucBDGpbo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZXOHv8Ghl2g01BQa/K+8jTrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTgwZjhkOC03NzliLTQ4MjgtODQ5MC1lYjdjMjU4OGFlNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIfdqihT94fURhMl42JHZFufp49N/rKxt1alj1ieypB2ux\nPzU5gJFWgG/6sC5R7v0GYMUOkiHwPm8K+rbsSXvRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl5Oxl5BtPF0zl71WhuiJ9QYj\nLBowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG8XQkk0rxmS5WWeWsKGOLww2AOKIjfzaSyi7kgoJOfoCICpC+u7NXwNZ\nK1S8a8aTbrWSbmXToZ3qOPzd/tJQLv5P\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISATNpCfV07rkh6LrbLCLpgwg1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE4OWM4MTEtMjJjNS00MGUxLThmYmEtMTM5Zjg2ZGMxNWNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YTI0YzU1Yy1mNDcw\nLTRjZTgtOWQ0Mi1iMTQzNTU4ZTUyY2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQdSR6GKP0BKBJp2UG2jGzNgJXPYJcwq3MsEnmjLMHgXozQv68RIXLYdY7NYrXY\ndNa71LN0we7vRVx1EUT9fVgKo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2IJuImnjoGdsB\nVwReMRTrqOHvPzAKBggqhkjOPQQDAgNIADBFAiEAzYDvJHiPGMXSvNmzPzOzPPVR\n9OGh5M/vv1P2cQqyc5gCIEurg7wEF9jYr2N21OZp/2atbUG2L+JQpmnQQ5JEo64W\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7339", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7339` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAUCNQir3u7UDbavZWw7gW6M/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxMmY4NWZhLTM2NzMtNGNhMy04NGFjLTYxMmVhNmJmNDA2ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJkZDI0NDItOWM5\nZC00YmZjLWJjYTgtNjAyMTI2NTA1ZDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETfaYxMHZk7+TjLbpdvrTjKIUqNEQ6jgwj7FfJR0Nb0FtN/d6pgXA4AmCJRQD\nvns7ikHp/FCiEv5MHLuNsKold6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNSVhRqskzlWJVbNaeObip+rxNvcwHwYDVR0j\nBBgwFoAUqqxNi/7RwGkZiJb1CZDsSxyhGU4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA6jtg5RK66Ibm6I48xW09p32kBwi+W1aGV/W3Q851j7QCIQDh\nnJXBwwebFBbTgn/LBPPh1F1tl4OQMczC+Fg2c/+9fg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbvKwY5Mah30fw6zHMVKV1NNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTJmODVmYS0zNjczLTRjYTMtODRhYy02MTJlYTZiZjQwNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCGTAfnWTKj8Z5EUg51gu3HbAKTVHG1bIzDmSulG/ThoVL\nlPc6F9IUJCAwd93irQXeZ+JKJ2DPMF5i6FijXVzko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqqxNi/7RwGkZiJb1CZDsSxyh\nGU4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDXUKLRDgRZ9J4wduNIFaNImjcZEB+2xGmHGM7i7ASFgCIEpU2reAyWox\nR9YS5OEG4hqtxsEJFYe6eVV7Hg/9PxmI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAdMtk/9Sd7/EihWVNmfCBPbkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJkZDI0NDItOWM5ZC00YmZjLWJjYTgtNjAyMTI2NTA1ZDliMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZmE4NmY2Yy0xODIx\nLTRkYmItOGQyNC05MTAxOTdlMThjN2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARzfJThPi4Po5XO3Ncp2H/pE50DdjCnmsOaCG6ZKNAcfiyQVCmHHCJ8c32ExN0v\n0G3SD1q+4lLIlMbgPie6yGsFo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ1JWFGqyTOVYlV\ns1p45uKn6vE29zAKBggqhkjOPQQDAgNHADBEAiALGcLS2kwiHrfLA0udc4Rup+om\n5QVmaYentIUxXWiczQIgcygpn1n1YS7BeF/B/fTP369BJJ8HFzrdkRY1IJex+d0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7340", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7340` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAQWWiI83LJ9U79m1ZWUHrT4GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2NDgxZjM1LTdiMTMtNDI4MC04YTRhLWRmMzQ0YTZlYjgzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJmNmNkZTEtMzA3\nMi00MmY4LTkwMzktMWY3YWViMzEyN2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvvsgLdt1fjPSjUNQ5wXA6ChG5abj4SPjCrqYXPcXwV163lBBJlLW91XpgD2O\nn4xL79rj2g9xVvPzryhNLDmt9qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUymSBRFKOpHInvtOEjSOOhNI+n6YwHwYDVR0j\nBBgwFoAUK8qJ1+O3ycQutSVsobkbpPyMikIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA8yE01+2XqBrR5IWCKyQkCo8aeZsbpnqL\npc7oz0cK6x4CIQCA85NIG0B5FURd/BFShZ+doo/OEerowCkwHzr3VjPjEw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXw9ddZhbYVokMSuKfn6F6SiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjQ4MWYzNS03YjEzLTQyODAtOGE0YS1kZjM0NGE2ZWI4M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQx8B1OHQT2M0vEqo59o5xR36PiuISb5Zwg1V/SXbeTM3ee\nvX4GU0SoN841RMGn1ifpdd33ST4tYzIABnlrXzOLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK8qJ1+O3ycQutSVsobkbpPyM\nikIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbzlWyvWJxWyicHrnNaOcnzwUNDm0tURCZnDJ8Lqe9qECIGiI6WW/rmQz\nUbwb3Qp4+w2fUhj7CQqH/4VX1z6USwr0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAW469W5A+1jnIdi6OXiqFgafMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJmNmNkZTEtMzA3Mi00MmY4LTkwMzktMWY3YWViMzEyN2IzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZWMyNWUwMS0zMWY3\nLTQwY2MtYTdiNC02MGRmNGVkMzdmMTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ+4U995Vf5esPdU4Vq0eKXSm4DmNPDN1eoWLjoD7MFUcxi3miHNqEfzPGrVdS6\nVV0thJyv4ls+TuV54yRoVNyNo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKZIFEUo6kcie+\n04SNI46E0j6fpjAKBggqhkjOPQQDAgNJADBGAiEAygX+gf0pTsbKH+l/Y6UC6zXE\nnSi6+9SeU+WoVlkdAx0CIQCgMMj9NRbr0nY+lfjDlwHvaOVmj1CYAI0Kqgu340Qi\nWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7341", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7341` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAfQksQ/GZ3WMFMfojMa3VTPvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjOTZlNDY3LTU2Y2ItNGQ4Mi05ZDE0LWFlZWRmZTlhMjlhMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZjOGFjZGEtYzVh\nMC00MmQ4LTliNmUtYmVjY2IyOWZmNGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY/14adBmAPdFYUAlU0XJP1gXf/TjBYXEdmc1wCRbzyksMYGYIDBIJye19TwY\nIloKh0y+Di443I/2yTOh8c1C0KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs5v1ur190wtH7Hknf2sQiNJDyoMwHwYDVR0j\nBBgwFoAUSuiJp29f8u6RkHqq6+6vTjZ5c8cwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAjKmIZe0Wd00sF/r7oEMomC4DfnrqK1J2\nIILDboYaKcQCIQDKnhf3eX3rthjNk1cz2MQBLaWrzbNNgq3v8j8idT6YJw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASx6Ro6AnuVGKp+91utD+PwBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzk2ZTQ2Ny01NmNiLTRkODItOWQxNC1hZWVkZmU5YTI5YTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQLkClecl0d30Uo5DuLd95PypioiUtU7PstntXibR8EBnt\n66b3XrVIeoyV5YHXLcDjLBm1y8hlJFkCuzeXN8QSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSuiJp29f8u6RkHqq6+6vTjZ5\nc8cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHSbs/4JAaQy+3orekgEMEO/LKHCuROp9+jl1ESSkTMICIBlCnow0IfvG\n9NDCe/tysj8zhl9A9UhfNauVV6QYCsFK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAXoFVGjI6jkexSzAmQx48b0vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZjOGFjZGEtYzVhMC00MmQ4LTliNmUtYmVjY2IyOWZmNGFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYjUyNTQyNS05ODFm\nLTQ3OTQtOGNiNS0zZDY2MTRiNTQ3NTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ+0J5/hyeLljDSE+JXXP0lr1Wkt1mhMg4JSacI2+hJ0UsFfXvmdqAUX9mD5Mav\n+ONWT8jPSBYukpZD6u5dxpWco1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSzm/W6vX3TC0fs\neSd/axCI0kPKgzAKBggqhkjOPQQDAgNIADBFAiEArqhs8spEHSnbsnKxxCZokLI6\nrsTzzVnt91V9+cGj8l4CIHbTlEatQRjRNuw0LjC/W+/Re0WleysUf95B/xcSvY3t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7342", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7342` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAWk3WJ7vXzJsOrQ0qnViPXehMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjYjlmZGFiLWY1ZjQtNGNlOS05MDE4LTU1YmE1ODM4NjQxZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzYxZWFkNzItMTg3\nMS00MTg3LTg3NjctM2UwYjFlM2Y1ZTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5ft/38CdwITL0cApLVOtuyws5Ov+5H2kkqDxLlSgrjP2Vn8Ip5AhC36pcymK\n+bIjhoolWH31Me5COUZ5WvuXwaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuJKgyE80+ZackfiFyjI+muvzW2wwHwYDVR0j\nBBgwFoAULvZSjVn0Lus46Ozj6bBq6eH2zKswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAzvQpTR6TIZ/D\niS+pICbbQbOEkDksFbkyPddwjcVskcMCIQCeC0FCOGzq6wkYi5dymKyaLAJnKqOx\nn56RXBngW6Qi4Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfkuac5Ssek/O4pPucUoQn8hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2I5ZmRhYi1mNWY0LTRjZTktOTAxOC01NWJhNTgzODY0MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWGlcRXS2HkWsaiZF3MV/5Y/XD80ZdlvQZORPhqkT+bv/o\nW8nd90ai42VZV7P5wTz2Q8iXVmE4SBt0ICaarN85o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULvZSjVn0Lus46Ozj6bBq6eH2\nzKswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKVJBUtpAR342iHSDegx0LIWOUyJSO8AuWpQdXFr27/xAiBPJ2dXf/il\ntsH8eOY7PZJwQjI6Pq78YBN90b+3vWP+jg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISATb/aM8yIJ1cJkC4HE4M9LUkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzYxZWFkNzItMTg3MS00MTg3LTg3NjctM2UwYjFlM2Y1ZTNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNGJkZTNhMS04MjRi\nLTQ3M2QtODk1Ni0wZDAyNjdlZGViZTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR4JFQraIfwKOHU4uXwO5RhTJa+3jGjtve/MZYkb5DHAU6RfyX+ZqOJmNpIEqp+\nOlhB2CmVYOD77x9FNOPkLIWMo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS4kqDITzT5lpyR\n+IXKMj6a6/NbbDAKBggqhkjOPQQDAgNIADBFAiEAzgzrLVrnVTlLyUjAXW7Uz4bQ\ncCkumnF063L8NbDBMv8CIGcFoIj+ZHNLJjzZkv+dspSClcTtYe9Z0jMzx77xjG+V\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7343", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7343` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdO80/nY7AZkdpzEpFkUKeAfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhMzQxYjE3LTllMTUtNGZlMS1hNWU1LTg1OTZhNmRlMWZlYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJmOWZjMTktOGI4\nNS00YjExLWFmNDktMjIzYmIyZmJhODdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4KhJl4uzt+O9Ujoqrc/7ycI5tmJXzl7sQ42vAjdhjnsyJkun73d6vevPO+8p\nY/JawVAILuIARwrvAMVhoiDJW6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAnvTYCrSbU7ZSIsnW8qTEKWjIA0wHwYDVR0j\nBBgwFoAU9VMkBrAljFnQKM6eKL5lU8OCfrgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICvPhHy1TZ8zW7uBWH8tyoBt/sjRfjFB/C5HkgI0ru6+AiADuiKO76/HZffr\nxsuki7NQNOLppZF5zzVKCJFh86EDXQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZoleOtK7f5YW9IMdXgSE/WZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTM0MWIxNy05ZTE1LTRmZTEtYTVlNS04NTk2YTZkZTFmZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfkf+cN8uVGHpG+xviOEVC/UasZomJduauxFeEomxeMiQP\n37enmTJKCD4Ff83ZQRbmVhlgX0KpcIumPrzZZ9WTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9VMkBrAljFnQKM6eKL5lU8OC\nfrgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYdiHDQcCOz8LrTNXSUSlIjlnmjEHq7PizVUQJqfdHsACIE/YZl+Jkjhs\nyGoWWJRtobPrO/0SRzLinjzUgNK36xIR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAdz8vF366mWSPRkRGyCQZvWcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJmOWZjMTktOGI4NS00YjExLWFmNDktMjIzYmIyZmJhODdjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4MTdkN2EzMC1kNmI2\nLTQ4ZTUtOTU1MS0xYmY1MzU1MThlYmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATH7S1AzRtF/ehC4dT0kt1IRAMo6fVHgrzL5GzAqCHAbMbDMs2i2a1NP9foUXnN\npNgF0+f9CU+FYcAJmXepQ9Lao1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQCe9NgKtJtTtlI\niydbypMQpaMgDTAKBggqhkjOPQQDAgNIADBFAiBdUCV5FKui2ZxSD0BQcPC8ucWz\n8uAbhLK4zi/vMMymdQIhAJWSV0VicDdFQqxTyaaljV3MnWDGiXktGOdPPJcc239e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7344", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7344` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAalVlzRyCA7y1tfIcLj/XgS7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3ZDEwMTI2LTI4M2QtNDgxMi1iYjk5LTM1NmQyMjA3NzhjNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBkZmEwYjctNjFm\nMC00MWViLWFmOTQtOTU1ZGIzYzc3YzQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUUd3Zn6Opw9GIYqfSWq95VFmuetWL16wv5PnB8mKIhtuJQ7S+ylZRcau5qZD\nCLFSripXRDjUdxfJGxhEblWVJqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Bibsq9LBEZVrmYiy5NEGUvU0okwHwYDVR0j\nBBgwFoAUHxUB84pTFmAUOFR9ZBvS8+9SQjowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDBKQG1I2uRCcqHa6pUyk6VBMzTY86yu67BvpIDCRJtJQIhAJ8zAsVP6V7H\nnofZLZ4Ud+VY9pxpFkfjvPaKMsiZrxPh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWTfRAn+quJA8opg/j5yPtOFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2QxMDEyNi0yODNkLTQ4MTItYmI5OS0zNTZkMjIwNzc4YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARC5jnAXZC4ZJ/yYc8pN/WVFLZmyQx5Pok/h+GWUKvrJNVT\nL/hZQNt3BpP8f0t5xUaGTokP2CoifVrSorN3SPLpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHxUB84pTFmAUOFR9ZBvS8+9S\nQjowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPF5uyuZL0hfaRq7tvXtkrwO186ynvwSCDbU45Sv1p6KAiEAmeUgH6Mp\nwiBVxr3pnzYPn8pZWp5jX2+GpFy3da8N+cM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAVWPtn6pA9WVk8Sk6VPvgWszMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBkZmEwYjctNjFmMC00MWViLWFmOTQtOTU1ZGIzYzc3YzQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MDliMTRhOC1mM2Nl\nLTQzYTUtYTY2Ni03NmZhNDNlYjExZWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARF5Fr1KP55IeHjkfb56RKvzeK4Pfxcr2cNwJLZ7M6Xz8qLjzAMHjO1kxNKN4xm\nn0wj+5TC1XDrGaltUcnsVrSco1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4GJuyr0sERlWu\nZiLLk0QZS9TSiTAKBggqhkjOPQQDAgNIADBFAiEAn8WFra/KKqmHYVZK6wkcx7O8\nIde5W6rktvK0wvHZSawCIDoWzfWnUqCxC4nXCVot/FDMNnbA2FOCGIzg3K3EvECF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7345", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7345` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAX4gR0gJ/ptnmaVrTBDImI+YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZTQ1ZDU5LTkxNmItNGU4ZS1hOTg1LTU1OWJiY2ZhZjI2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNkMGM4ZWUtODg4\nMi00MjQ1LWFmNWUtNGJlNjkyZTM2YjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvpw/m119oOnzvmBL3shBCocMTB669d5+EK+zIDr3LPUYMEx1yqxJZk9t3vdZ\nlddSrniUINmzp54vSwU19aZi2aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpI7OtXYh+ScOCPh0bRK5jiTJ6dkwHwYDVR0j\nBBgwFoAU7FiqRjBp7PtbJY2M1vDk+koCrY8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiACsOywdqLce+9uO7aeRYQMyua7YM4dcNRzsrf4W/7EBgIgZRh60ucviYzT\nJBYYCqFK4LxB+AFOdeKR/MX+j97SaTE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZdFrQMco3bNJqmzdrz2B1wzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWU0NWQ1OS05MTZiLTRlOGUtYTk4NS01NTliYmNmYWYyNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/0qBgPJk1n2Fsm+1yIZT5WfAV4tM6/Xkfl9phjsSC8oLT\nGo9hKD4/tjv1qCKkPf8M1aOpy8UCc//qP8EBQx9Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7FiqRjBp7PtbJY2M1vDk+koC\nrY8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfBtQS6DhPG1+MaIIdfhUMO+0xk1tlf/Ahhywjj1grRMCICBDPfCii+xi\nMy+NyrOVmaE+pplw2gEJ1DvBrHHZSr/N\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAe/7NZFcFSLHFqnaxYnxbZBJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNkMGM4ZWUtODg4Mi00MjQ1LWFmNWUtNGJlNjkyZTM2YjRiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZDYxM2ZiYi1kZmU3\nLTQ5NjYtYTVjNC1jZDRkOTc3ODJjNTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS7ANVxc7jCj8j9X7uxpfjii2489wnaVA5LjEnSpEPFa74AByOKclF2v6MOshK+\n9p+rd9AQ8+bngLvMGhEIZqM/o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSkjs61diH5Jw4I\n+HRtErmOJMnp2TAKBggqhkjOPQQDAgNJADBGAiEAyzi6FfBjf65Pi+D9CXrO3Pc2\nKo6hq03uZj36b6hVNFICIQCBP7UrI853tr+O+S2YEo78Z+lZYj9SdOVh2IJmGAVs\nOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7346", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7346` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISASKoVSHDtrH/hqG7g4tirmMOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5MGUwOTI4LWI2NDAtNDk1OS04NjM2LTcxNzUzZmJiYmI4NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjYxNDRhNDctMDAy\nZC00ZDEzLThjZDctMDYzYTM4YWUwZjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExa8EHZ4I7z7ubI/79bE0fJiHM6S+Bx7Rpj4puG1n/yFyTuONMTy2OVyjdLFc\nC4N9NZhTXtuffsqBoKymxF334qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpwQj6QEX6k3GjVQsGX07O0JQ8pswHwYDVR0j\nBBgwFoAUylc6DeRNejJNyMuK4Gmw8eQ9QpQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAkUwiIzqe8eGa79Qb/wbKto1iv0KPpCVcyQDcYucCu\n3AIgPDyHwClUObWTZWK+HFOS1v3XhwIjWqfbeeOl6W2LV6w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUFLkOqpG0pGp5i9qvKz1iI3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTBlMDkyOC1iNjQwLTQ5NTktODYzNi03MTc1M2ZiYmJiODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMI5yP96NjTppCq2pcf+wZ8WjOuzx7t1bT/MLpNIBVrGBc\nu7A7NyeyR+tEVuKBztAyiJBl1gz3YLt1K62fFqVLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylc6DeRNejJNyMuK4Gmw8eQ9\nQpQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJlOay74ybK9jCig90wd9SZ3ylwC7QgeMiZvvOa9dTCHAiA/ZsaXNumA\nZJ48d5W5TFU7V7X55oSPxJQ/lvbmA/uobw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAYobuVabMz7le/RGTsGsoyC4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjYxNDRhNDctMDAyZC00ZDEzLThjZDctMDYzYTM4YWUwZjcyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZjY0OTNiNS01YWM4\nLTQ1MTAtYmE0ZS0wZDJkNjc0NDg5NDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS5kV/YyyaAAbEYMfMPZ9Ogs7yzFtlCCjcJuA3eEmaDIkMIk0CpKAZpGo5MIFD6\ndqOS8vdpzFJDOCTCoHfjPnNno1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnBCPpARfqTcaN\nVCwZfTs7QlDymzAKBggqhkjOPQQDAgNJADBGAiEA2XySgO9wnQ2Ys2JDzo5TzTRv\nSpCsyPQXveTJ2yYYTTQCIQCb7/Uc5NGseyCTWO94Byp7w/JPEaT5o9Elp+DH2oPO\nLw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7347", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7347` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAa+bvm70jTdACZeuqGLAh+64MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlODI2MGIwLWM1ZDMtNDBhNy04ZDkzLWZlZjNjMDlkYzMxZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdlYjY4ZDAtZjI4\nMy00NGYxLTlmY2ItNmIxZmQ4OTJjZDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJyPWaFmDFJTBOA5yZ6GV9M+J+T8Ntxo6Ui9Nv5lK7YI+oyNFHEx9QBTUXWCC\nk3YfjBsyJU1h5YWzsaRdpe4oLqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfsRM01H7AB2aGFB7ZBl0XXFjqVIwHwYDVR0j\nBBgwFoAUSoZfeIpHLKqQ8lbP6D6x9mMmIvIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAk9T0CoSdGfOe+DAIwsbZe3UQ3ZxT3wTCh+PN9vNC\nN7gCIQDJAo3NpLzQ+W6GQqehRu3vT3llr42eC4MhVmEpc6mRgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ4dsmioL8aQdul/zXLnbUWyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTgyNjBiMC1jNWQzLTQwYTctOGQ5My1mZWYzYzA5ZGMzMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUpkN4euz0QEpSg8QClW+TJnQUB3bIdbVxm3pBNJY3JfHO\nLEWM/zJ3LI5YXpCuiANqkvTpO7zdLHC9MzQdw/who2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSoZfeIpHLKqQ8lbP6D6x9mMm\nIvIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPl8w3MRNJrKUGkW+WWH8I2897hW3TtmCtcgCjDm9VfXAiBJKAQFIzBA\nAQ8vYmlZsl1xAStlYTse/L4/MRqVp4pTew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAar1A4j4TCjORSbl5JEaMaURMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdlYjY4ZDAtZjI4My00NGYxLTlmY2ItNmIxZmQ4OTJjZDZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiZTgxZWVhMi1kNTlj\nLTQzZDUtYjAyYS1lYWE2OWQ3YjJkYTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT0jJv14OI5HP9jGN/fymR/Yo4NeS9BBxYO6kRSfH1ySv/Np7TacbSZLoaIP0xA\nLUcTtLCK8p3ccbHBJqp0r1OMo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+xEzTUfsAHZoY\nUHtkGXRdcWOpUjAKBggqhkjOPQQDAgNHADBEAiACNb6XDj4LZ5B03n32w6SkWWzk\ngaAKd1w586x3cK5OfAIgdBa5vBjm2tjHFexdDHdj4lb5iurgdJ9I9ErBnCtEIcM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7348", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7348` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAR6VH5sDtC0XuKN0HWaiNyQ8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmNjIwOTA4LTE4YTMtNDZmZi1hNWZjLWE0ZDhhNDEwMmYxZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU1OWNiYjYtNmQz\nOC00NzI4LTgwNWQtNmRkODdmZTBkMWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJQxQp6AznMLG1V4P2WQD/G934drOSjGmT0YDLKSGuh9CiqAzIwUBeUbYzEgV\n18YRWvvn8VTtMdgb+clgG7XKSKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmQpQ6/n1gfrwpUubd7Ro89KxvJ0wHwYDVR0j\nBBgwFoAU1Bzv40Ufq2PlodjxarRbH1YRshowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAnwJSUY85bdm10S0M3Be6q1reNAwkJp9lprfM7cdjhYMCIAeg\nXgSY3fIlM+3sr+hUfI2qBasjfDAkvYoU+qzmiG6U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVOSKV3AKrx//zMXWn8DZ5ecMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjYyMDkwOC0xOGEzLTQ2ZmYtYTVmYy1hNGQ4YTQxMDJmMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6zAmNp+pXP3GuepaV++YJaL3lDnZTdC9YTQC+Lwc8NQPn\nWI1Ccc8Y4BJTleE2vsfLT8U9As6q8wm6QWK4Sucwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Bzv40Ufq2PlodjxarRbH1YR\nshowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIr7boSpFjybj5+aTAe5ROIguhiBd+Pe4A2rr58kinKsCIQD5KdfG36uU\nQrn8On4BOX/W+a+XZ4BKld1ywby2ISH9XA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAWCPUi23KwxWJMIa3OekhuEdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU1OWNiYjYtNmQzOC00NzI4LTgwNWQtNmRkODdmZTBkMWNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzOGM1N2I4Zi02NzE4\nLTQzOTEtODFiMy1kZTE1MmQ3MDc0NGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQZtUG/Jv1o5BlKT/Fi6I27Dt+6epdyNmd2gjzVQcMajcDs6WCR7+x+NqC967C/\nPtlc00WY4AwGH30GxpABYV9go1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZClDr+fWB+vCl\nS5t3tGjz0rG8nTAKBggqhkjOPQQDAgNHADBEAiAgMj0JZUmS9kxl6B0j9AGPN8O3\n+ANF0MTWNBqwZs6e4AIgPuNOqxeGAkK8MD9fxQFTNpAhvp97l6ga7DW9NmNJhRo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7349", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7349` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAaTW6pcR97CIszs46g/iziutMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmYmM1MWM5LWRkNDktNDUzZi1iOTFhLTg1NDYzOTFmMWYyZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThiYzAyOWQtOWRj\nZi00NWZlLTgwOGQtN2ZmNDBhYmFmNGMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOh0/9lMb+cC2iK13d7LjQEPuJsvs+Y29rLWtI7e4I5LCxcTmoHpbRD5gzdiI\ng1EX4Rx9XPBEV9K3CeL47ajZtKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmiYl18eKEqmSsSCAYRuFt/0AunkwHwYDVR0j\nBBgwFoAUN2H0AxcjDs7BzXyaxkZUvOm/D28wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiB+glJGikhh+IxGHLofH/WglAlDCXEYAmYB\nv295mkiqHAIgQ7pGnH6AC7eZ2HgiiRJkn48jpMZXx7wCSDcnQak5Hrc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWB3V1wd82SKfGZsdlHYVsI2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmJjNTFjOS1kZDQ5LTQ1M2YtYjkxYS04NTQ2MzkxZjFmMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQv8s1AQt93bEfSLj3xb3lbTpFjYcc8pifgrCGqLngvo/JC\ng3Y7DqqwNRu6YnuKP6y3rL/gBmfd5mEAW/9WXR6Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN2H0AxcjDs7BzXyaxkZUvOm/\nD28wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMigH/OtT4UuI/Pld5j/6Li0uaPQg5Cgq7fah4mbHx8AAiEAoXUANnbz\nFr7PlW1u5JuIxdVQGzvfBu4Pttww+7nqTfQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAfR1txBLkKAkSRes9C3pv1TeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThiYzAyOWQtOWRjZi00NWZlLTgwOGQtN2ZmNDBhYmFmNGMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZjllMjlmNy04NDdh\nLTQ1MWEtOGQxNC0yYjQwYjBlZjY4MmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR2mJ7ougtPRKLAHbSdHGOfY+shkC1vXjR1hquTVbK7Y0Q98gcd5inhQbPWh6Y7\n5crn4rr3zAqp5rbKhOgWomVWo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSaJiXXx4oSqZKx\nIIBhG4W3/QC6eTAKBggqhkjOPQQDAgNJADBGAiEA2/W4aCI0A/JWdPQwxylAxj54\nvKGClGRX/csfma34s/0CIQCxOaEHhk60mcvMMP9F1GlUYRZPUuohgYRpGcKQk7t2\nJw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7350", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7350` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAWts9xnhWhHaybcIiMN0zaB4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMjc1ZGVmLWUzOGQtNGVmMS1hNzZlLWViMjZkMDkxNDE0NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU5OGM5YjAtNThh\nYy00M2FiLWIxMDEtNjJmMGI4ZjVlMTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELDZQ5gRD4MZGAB2Vlk23KUZrTCRN4hMQFeFcdit2gsPmOI/YgpxIKbwdcnGZ\n8+x9jfrtzpDyQa7+S+GvEjf4qKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2FKLgLYP+F2qQJRyjmBRBJfvnBgwHwYDVR0j\nBBgwFoAUS1XGRXtIyV/RDyeAk8eYRC89dO0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA7EtdKctm6gPINofXj80YAMPlJ76eB0Li\nI5CtT73o6ksCIG2Jp3q7SSLF5/JhkiNFANd4Ha/jKgzJ3ZhUUcu8+oKZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfQwyOv3C4ISPJXAO7IKYRYwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjI3NWRlZi1lMzhkLTRlZjEtYTc2ZS1lYjI2ZDA5MTQxNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuj5qjKi3DNI+abX26EV6it1i5Fjn0V5Pcl1Vl/4kq3J4E\nsaLKoH7AlnyplhWeZlNEQpc0sdv/kJetizhyotHro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS1XGRXtIyV/RDyeAk8eYRC89\ndO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALps/qMrn3REwk8K6pMjnX0ArrMPP3s5fLEPPerq57BjAiEApxMXKBdl\nGvIpyXlLTHPq6/fDEqZcX2Fv34Rc4OizJYk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAbSON8JJ8SY8qbyeug39tefJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU5OGM5YjAtNThhYy00M2FiLWIxMDEtNjJmMGI4ZjVlMTA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YjgxZDQzMC0yN2E4\nLTQ4NGEtOTYxYi1iOGExZWU2MTIyYWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAREeD6adO0UEERKleXJuAyCdMLETEyGFior/9rjQGV5g/jwnbd1N+XaeDFuAzz+\nPJxeYfjDd4Z4tmWebDSU6X9Go1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYUouAtg/4XapA\nlHKOYFEEl++cGDAKBggqhkjOPQQDAgNHADBEAiAl1KUJiJaD3+0u5y4SmtHqCier\n9QR+Z4R5y7+iAB0gwwIgZhoZMTEV3Pq180zADbI1zKrZCGmL8JS6ysqyxp8uj9w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7351", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7351` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAftwIhgjaGdwuoAVgjb0prNfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkNWI2YjAxLWU0NjctNGRlMy1hYjNkLWE5MjI1OWMxOGYzYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQyNjZkNzEtM2Qy\nYi00NzNmLTk1NmEtMjVlYTE3ZmI0ZjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+Lrl+pi0DcO0QofG/9fhfy2+UW8zkQD7/OMx0lgmOZjprLt5OXdkjV36MFWa\nyHFAO/KVvUTxj8jFk3i2da9gO6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9DwXDZZrSQVqcAEH8pqleZulcc0wHwYDVR0j\nBBgwFoAUW+mI9K3xNfKHmhpsqbM0TRlwuvcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAd+10wfixHdQA5xYvvcgjzkAi1C\nbhEO1xzmnHOCe76sAiATm1RAZRFsEvHto0eFBrPrw0xjibNgvyhMQIFyOh8J4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATd5eWP5S2VsUxOt3HoiStQbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDViNmIwMS1lNDY3LTRkZTMtYWIzZC1hOTIyNTljMThmM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATApQ1cGB2mna1AHfdKPy/1cwOWMYnNB0XNqU+DFTjZJ2Lq\nruiyiS2AbXghGhCw0I+Jod9OxJtR33nt3fXnn2sTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW+mI9K3xNfKHmhpsqbM0TRlw\nuvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOsVDR1HRXJ7Lycepo8zdUgOBQI+nQXx7+zp+hfBWlUrAiAHWSM5L/1S\na/z4vmdQYlqUqUe7YUunTh2dQfz/QL204w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAfZ10GNo9Q03I9x6tRrjcEjsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQyNjZkNzEtM2QyYi00NzNmLTk1NmEtMjVlYTE3ZmI0ZjY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZDVkNTg3Zi00MjEy\nLTQxOTMtOTg1NC1iYzgyYjU0NzY3YWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQHuND17y6FNonaN2qMamGUzfPiy4l1BpqdaHgEZCJlpKFJbAlBisVAPQVwMK2V\n1IjJ7lZ+zUR6tOVNIx4bMqqto1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT0PBcNlmtJBWpw\nAQfymqV5m6VxzTAKBggqhkjOPQQDAgNHADBEAiATAemZ5ZEoIio3RaZcI5B+6moD\nNCTGczoSeBR92p6l9wIgb169O0S0PorxYjZt3rzINQZOKt2apIZ/zqb0su+XdAs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7352", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7352` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAUdp6QG5rBS9OKHflWbiC2WMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5ODk4MWU5LTQ5NTYtNDhiNy1hYWU2LTQyYWI1ZTZlOTg2OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTRlY2U0MmUtMDJh\nMS00OWExLTkzMmQtNmZiYTBmYTIxZWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgeIkwOY+o5zmpaJLNqElpPQ+aV67oCXWhVYeatzMxdgX7gJYpPYvCBpHtn/I\nQjC/JXOKUBeONyxIr/MILoU4lqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGe325CsyTDjDdfS2H6CqF+SWGMcwHwYDVR0j\nBBgwFoAUjJBC/N0+6uyu3POiJ09THNVbvnUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgKOIJSxH9\nyiWsoc6buU9u8yJLvp7almDl3pZP3zIJo7wCIGTpbO/DS/LBcmQSw4kw4LmZvwFt\n0WcxwNM4gRo80tze\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT2U0C2/nflQeZTOOdb5qVhPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTg5ODFlOS00OTU2LTQ4YjctYWFlNi00MmFiNWU2ZTk4NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdvHQ92i8E2FRdQV6UYcvY4ZDzjKm9OEaeuDgJTVsd5GQw\n5KVMelOQQ8zQcOlpJJxOZEUhS+uFyUieSHgdUldjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjJBC/N0+6uyu3POiJ09THNVb\nvnUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRtU+G787fEK03ytpDPVV8Q15UHGavtqiupfYXOtyoNICIQCIdvvPJpsN\nZlKjmqJVixK3IGMKtRZBJSSpQa86pcqgyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAffXcSt11VqoyKR8QW4zX0F4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTRlY2U0MmUtMDJhMS00OWExLTkzMmQtNmZiYTBmYTIxZWUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MzIzZWIyNC1iYmE1\nLTQ3OGUtOThlYS1jNGRlMGNmZmEwMWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASgIpdWDb/gRgpBJYIgtuWaNaLyyoeTvq6zymNuicMfcn3R+6vdr7QR9sL4k45G\nAk8xC8Ee+dk1unXNOP5EBjTqo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZ7fbkKzJMOMN1\n9LYfoKoX5JYYxzAKBggqhkjOPQQDAgNHADBEAiAoZIjwxsxa9LQT2jZhIFVxV4Kt\ngo3ZIPWEcVAvpBRIugIgBt41ZsQfnYlF5kFADLIYelPe1C6i/tFCilHB8KDBy9A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7353", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7353` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAbVbnqKTYdKGjDz999e/5nMHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0OTVlOTVkLWNlNGUtNGY3Mi1hODIyLWFiMjE2YjQ1ZGZmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI2M2RmZWYtZTJl\nYi00MjhjLWE5YWMtNGU1NDc5ZWEwMDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0zQLq3IF4Sd8dwQ7uJGD31q/KlNfCy7fOut8wFy/L3oxLrDqc9LDXfcv7ckX\nHfXA6GpIZFZbIql2FlfdAEYF2KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQD/ESTz6po0BIuRpOZb8vEkxWGEwHwYDVR0j\nBBgwFoAUZRjP7dpT5WVSFMfk4j0VT2o5g2AwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMzn0nso\n+0ceSoe2R4OaS5wF/sME0jhH803F5KcfJ1bPAiEAro8BMD/OkO0MJEawZAXWhyr0\nuWAQoUbHFbkhiZYfeGc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa89GJ5fqCLiw/42uIbXDIdVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDk1ZTk1ZC1jZTRlLTRmNzItYTgyMi1hYjIxNmI0NWRmZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrITZwGo118UT5XxQaJi+UcskVsUUtWPfSMB+G4Fyr5tVw\nap3b8FHRst3kNBPlqMAuPwEAMDMuPK14UAipOsXFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZRjP7dpT5WVSFMfk4j0VT2o5\ng2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALHOhzUcQ8htvsdbVK9XiNUw4D/tYbVZdhTSLtmYkaz1AiB/z0AmnFQS\neiz8OyGj4pWMLqKyZ1SKLgR/dM5aHkmNRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAacEILaba+znma7MbFRKIw5gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI2M2RmZWYtZTJlYi00MjhjLWE5YWMtNGU1NDc5ZWEwMDkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNDdkMWU0ZC0wNmUw\nLTQyMGEtOGRkMi05MTAxMDdmOTgwZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARtRVSG59jWRIbLMW6z+XeDpULkTrO4/x1P4NVNcRvU0mKZF8VwXd/bAfB0vP0q\nSlIMp4zhK0tk6TVYzDosgo13o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRAP8RJPPqmjQEi\n5Gk5lvy8STFYYTAKBggqhkjOPQQDAgNIADBFAiAJu2o5YZFaP8Twd9XA3cTF6F2c\nfuimD9OcZQKSFz7ZegIhAP1XMFqjK4QKsfD/Z3GFsiuAJk9WTWvyDXhGwY78r22g\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7354", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7354` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAV1xV+DHq7QtYWVJNiLr4fduMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0Y2YyMDM3LWE2NTEtNGNjYi05ZTdmLTljNDQ1ZGRkM2ExNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU2MTQ1NjgtNWU1\nNC00NDJiLWJmM2EtOWI4YjU0NWIxMThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzV3X/KJmXeikkcg3wcadCvhkgmMKD0p8quIi7yDJSTNkmNhHzyjySeOclTBP\nsjZsry+ghsq6sM735s3vOEb2hKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEOndHfKyWPPgZvLEk2+mDPYe/yMwHwYDVR0j\nBBgwFoAUkAEhphOAhlQu/Uua1HI8Qg4ggYkwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC1PHnL\n/CXBZTfNkoW5V9FiUbP8xrMX8l1LEjuySTqk1AIgIM3yA9p/OVEMid1yIqEsflPQ\nnu9NHAH1on3vsNSlpaQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa9RLnHn5xVaFWsByPAAYFBNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGNmMjAzNy1hNjUxLTRjY2ItOWU3Zi05YzQ0NWRkZDNhMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwEge7Fz0A5ogqUHRrVX/NpdTW/eAIecRlWOEtSLckWx0r\n+ViSM27PvHQBENsvY6FO6BWuF4bdeyZ9+Qi018Dlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkAEhphOAhlQu/Uua1HI8Qg4g\ngYkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJyMGxWnW5s2sFT0Inz6wPvFGF9cqpJZVwf5KWX4xOuYCIQCydZChc+7B\nYVVaUG61xZi/MY9TMBtrxj1OMIbrmH9C1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAb39SaQQl4VoD3ARtyhwVV79MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU2MTQ1NjgtNWU1NC00NDJiLWJmM2EtOWI4YjU0NWIxMThiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMjQ3MmI3MS1hYWJm\nLTQzNTItYjFjNC0wYjE0YjRlNDdjMTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARhyJ1IqbksO6HG1QnjF7PaRgVyXkBo/FOQHRwa/uJP/ivqZH4Suix23kFfWS0I\nhXeqMpOLOX3V68mJJuFjVbuHo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQQ6d0d8rJY8+Bm\n8sSTb6YM9h7/IzAKBggqhkjOPQQDAgNHADBEAiAdR2tdCRrCGiTJl39jYm9UNpKr\n74aacjh5IOFT9MU+jgIgOq1kViO3OlFXZlQdBblbwmJXrvZAl9JZsAhj6AFoV0w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7355", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7355` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAYVWyhHjhlrP+Z6ypK8O7GCaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzOTA4MDUxLTc4YTEtNDE1OC1hZWY0LWFmZDEyZWIxZDAxNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgzNWFjMGEtOTRl\nMy00OTMzLWJiOTMtMTk0NjMyNzAyOTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtl2NWwVG7ACxRxP2OcTOrLe+qf2963Gg+mw+qAalXVo4B5BDBcRCze2FEYLl\neFQDEylwzEox3/V/yOy+A98HBaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaSc9wZwZXMgwVpl2UcZyjto3Y8EwHwYDVR0j\nBBgwFoAUTAo1wdYQt7QNl2uAQUQJGJSdrwEwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIFoKpOOWN5E8eiJOaCo4frm/jF10EJhebLIZj3MWMK1sAiBWQnwQsNVr\nKZ/tJ9Jd6YTAfueC1Kc/mD7Md9q5yvVc2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYttDvf2QbvCGrWmXefdn1tEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzkwODA1MS03OGExLTQxNTgtYWVmNC1hZmQxMmViMWQwMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJQKeg7vEy3OtUFe/ozr6iIO+tOPawfn5LkZbni8zMaBdC\nrNYm/Ssw4NfgAykU3qcKutWXxX0FHOX9zhC81jUEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTAo1wdYQt7QNl2uAQUQJGJSd\nrwEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSBA9NFdg/ezsrXDNhHo/g4fbxP5y7iMhozXmrsbtZpcCIDWcbv4YHzxV\nOtkJ9TA6yFKy/daMz8FA8vjvUpMtwHvH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAcj/n+nA3yBiFifIyqhUIVY7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgzNWFjMGEtOTRlMy00OTMzLWJiOTMtMTk0NjMyNzAyOTdkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2OWU5NTc1YS1kZjdi\nLTQzZjItYjZjOS03MWUwODZlNGFkY2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASxYv63pv3ymgCE0mXmw7V8C5v7oVflF5AxNOSQfSrQkxZ1cew3E6ZBcKOQmoBf\nP05dlYzdNHwmFOGtOLwJ+J/to1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRpJz3BnBlcyDBW\nmXZRxnKO2jdjwTAKBggqhkjOPQQDAgNHADBEAiAIzU0h5RDx+H9ssbssBJ/krpl9\ntFjkXpPEFN2YwySymgIgJmqUBtYOw0JlpMyjeTakFnlLc0tVRui0aMBsjcOMer8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7356", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7356` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAc1qWPnXY9mRdw9h49Z1RurxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjNDY4OGI0LTA4Y2YtNDM1Yi04YTFmLTk0NTJmOTQ5YmUyYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRmMTAxYWItYmQ2\nMy00NWY0LTlmYzUtMjI5ZjlhN2JjOWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuNqnpp2NFkAFgEs8uDW6ur6L/FwdP1sqCJZjZ5+WDHTtKBhXSjL9Zel7imCu\nrmRuW4tiDf5XFl5AVeyuWcgDIqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7U9u5XgMD3ym6tgYYULkie3UVlIwHwYDVR0j\nBBgwFoAUgBrGigrw8gRj8PQMuz8uDTXVvGMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIHJstRYdZW0ngjB4eWs6g40H03Y9y5POoAiTzylpigWoAiA2WshEMtsJ\nq6NBODAma3SSjk12zOZ9QHboeKNToXoA/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYbvGEHL0+25NOFuZyqwZcbgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzQ2ODhiNC0wOGNmLTQzNWItOGExZi05NDUyZjk0OWJlMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARy3bcPrauQHraFH4I1yLwV09OGBEhyzR3TCmEk3epEfF6Z\nojJc4go10N6+lbdJeBNsA909EqvDhc3cbguPPOh2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgBrGigrw8gRj8PQMuz8uDTXV\nvGMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJW+qZRh1zvHkmi20gQsZI4LJjsCXqb6xuZni0zOMgGMCIQCEdb8afLEv\n/am46jI59Lh7WvM2zWRYJcAl1hp89fkrJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAaBiztKZ7xQCXQcTvq4XDBzHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRmMTAxYWItYmQ2My00NWY0LTlmYzUtMjI5ZjlhN2JjOWMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NTA0ZGU5Ni00OTA4\nLTQyZDgtYmI0NS02NDA1YTIzMDUyNTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATmiqR5sRS3vnc4r9YRURs7PyBmQQ7XlvwJNXFqfW90IFe3W2swxD5pm8uiSPfB\nOUqO2154aOxFI/tAhv6OxTf8o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTtT27leAwPfKbq\n2BhhQuSJ7dRWUjAKBggqhkjOPQQDAgNHADBEAiBCo1tCp0ucnFRFD+6+37yyLCAV\nEwphbEKfMmVQ5xDbSgIgZI/8gykU+eJDZVNFLNFNTXX+pRPfFLmTJYetKrDTUTs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7357", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7357` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAWA0LkHc+FgGOcYcLBM40K9qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlZDIxMjQ3LTg3YWItNGFmZC1hNDJkLTMyOWMwMTRlM2Q4NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E3NDA2ZGUtNDUw\nNS00ODhkLThhMTYtMzRkNGUyNjQxMjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5CvhY2BbJv/DWKBU4UShInF9WEESmFonWT6FV4zcF46YEjbEPtqFYEW1Osjy\nMSX+D8kQUBtmrvW8Il+66TDo9aOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcQ6xYcGJrVbeOn83vGwtQ8usD/8wHwYDVR0j\nBBgwFoAU0AzAnw/e1tUMSW9h/ZOTnI8slP0wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIEncliAGwpO9s7NSF4T6xfRuEX8TMPdUfEjVXNmiK2AUAiEAmgGfgIugXoyn/Hm0\nX7OHWIH9FY9Fpm5CBlHRyoy35b4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeeaRtgruEa/e7Yhr216vwh6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZWQyMTI0Ny04N2FiLTRhZmQtYTQyZC0zMjljMDE0ZTNkODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1EWE8uEnGcHg1Y4fkfwNX94AY7QMTgBdtP2o75JU93BR5\nbNLxgsQJ1uqGMn7lvnA6zoJsMiBbXJtvRxmciCM9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0AzAnw/e1tUMSW9h/ZOTnI8s\nlP0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPwr/xgOzONDklTqhNgqZQpNSOmE3cUbf1w0/keIwf+UCIQCPrIA9/rZO\naIyJDm1PmylUwTG6ZhHT0oMKYeq6hNqdBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISARajNGx/Qym7POo3sTl+1YVMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E3NDA2ZGUtNDUwNS00ODhkLThhMTYtMzRkNGUyNjQxMjZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZjliM2RkZC0zMWNk\nLTRlZmQtODMzNi05NmY2NTk2NjRkMDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATAFH9SWPf/gHJoJSb/HYtyuAjKgphiy1YGPCB7nYyiHfWNe/RwZQ4Ho33XW1F5\nDtFSwU8oFjn1ubBn7m/Z+bzko1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxDrFhwYmtVt46\nfze8bC1Dy6wP/zAKBggqhkjOPQQDAgNJADBGAiEAss4sJIO8MEQaLRHpNywjmUnR\ndKoRX3aTNwI5JxaLdO8CIQCzGqOKyqybUYWqh3qk5i8obi0YWXBekogt8GFYtCtp\nig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7358", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7358` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAXXpGr4YfiW9z7NU84C+OSnNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3OTRlZWY0LTkxYzctNDQ3My1hMWRiLWNhYjllMTU0MGJiOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFjNWRlNWMtNDA1\nNi00MjQ3LWI5ZmYtMjRkYjAzMTBlN2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3v/1yAbpFomMwvYf/+rTlZmIOT6dMo8/2XX86Ct7XLQr27lkW7R1jdZZ2XM6\nMoMjRzerR1D+L11+I7jSu0WIo6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1QBz3EjIw6eSlnxR9caTIjDNYW8wHwYDVR0j\nBBgwFoAUYJHea2jj9q7hp9EvWjhYOD1r7u8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCNnr7OlccTFYJjkA7j4LEhyZl3rKRrybQwTf6q39iyBQIg\nB3bK9eAoZnFqiOmVosqMLdMOh1bhBTLWhwNZrpj5/Fc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS/0igNvpMYU1ciSpyEhNYPhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzk0ZWVmNC05MWM3LTQ0NzMtYTFkYi1jYWI5ZTE1NDBiYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdZpk1V9lbP6BXUhPAOjl7noDpxj9pfIVw7wspCJGGBxGp\n6NAwrLC3XUy7QMmX3XayxJKVZtzyAPU5kzyTiD3go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYJHea2jj9q7hp9EvWjhYOD1r\n7u8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM1aUc/aX+Bu/pqhNWGr2uVA50ItRNDius51EluEd02XAiAoyCLsACpR\nG8TwE8KRUYC/TB3N5Ym4ScTjTL8s2PQ2WQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAV9TuQu3mFV+WH0XwDaM7x/GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFjNWRlNWMtNDA1Ni00MjQ3LWI5ZmYtMjRkYjAzMTBlN2NhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MTZlOGZkNC0zYWFm\nLTQzODUtYjVlYi05N2UzYzZhMTJhZWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT9ChvMhb4/Srh90gimWAJUDM4Au2st65XD4R+OYgNY230HTNZEPw5BSt8L92zE\nCshXqqwMe6+IE0R/Yhrm6mIpo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVAHPcSMjDp5KW\nfFH1xpMiMM1hbzAKBggqhkjOPQQDAgNIADBFAiBT4ZMPH6WpKf91PvL4IV/9AsS4\nKFr/1O/FYuBsJqf2KgIhAJ8XhCTda3rFCMy/OqrUKdh9c/U9vO6svXoA4vgz9T74\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7359", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7359` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUqqSQIa/zy04XhoDUAIidIXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiMzI2OTQyLTZiMzYtNDRiYi1iN2FhLWM5NTY2OWZhMjcyMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE0NzUyOTUtY2Q3\nZS00YjJiLWI1ODMtODU4YTg1OWVjZGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+OfbRCOfF8I1piEfW28K2d1ZYPiYmZ92/rrME5uwMrjwspH7k/JELsi+2NJg\n1CRYv151798C4M6j3uwfJstIJqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4CXbAW1PZ/DXUPI0wMU+TpZO/RAwHwYDVR0j\nBBgwFoAU5cy3KyLtIdlXfHQsewtxa6kVVv0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQD0GJqEKne6lY9zBFYy5SmcPNLzuUajsilBbKJMZUkaqwIg\nWCJMp8SWAQta8691lg8A/gbFxGSCNZ7ea/4GE5/HV1I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATy0M0lwTGdeCph6ZyP2H+eOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjMyNjk0Mi02YjM2LTQ0YmItYjdhYS1jOTU2NjlmYTI3MjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk6OW4erurMUJ2rtCQmnlQjsJR2cNuVyZhM5kAtMLutcCk\nBd8Ck3np6JHuKA+ofV00LoQ4l9Lql/sPpJg9lBRpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5cy3KyLtIdlXfHQsewtxa6kV\nVv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI2RcqbjW+gW17nfJZa4aBTkyDj2FcgeoQhYZyqMw1v2AiEAkWItJxQU\n/2k6o8PVO7WK9nXQ86vmQBmK/y7enKe83bw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAcd6ISLH80FGeV2ACTirWZnIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE0NzUyOTUtY2Q3ZS00YjJiLWI1ODMtODU4YTg1OWVjZGM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMjEyYWRiZC00OGJl\nLTQ1ODQtYWMzMS03NDY1Y2M4NjEwMGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATM496I6RVK0CTrJoA9r7ERz311+SVNRIfv/zj+vMKegdSe+ZCyjhBo0S3jq/HS\nxKwi8FAaQD9z4oeUhRU7oDKvo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTgJdsBbU9n8NdQ\n8jTAxT5Olk79EDAKBggqhkjOPQQDAgNJADBGAiEAh3Qkix/ULGF8C2tMGg2dEfK2\nhBeHQpYru7Wiv24yRhcCIQCwSnYoCaJTfAMGdcmtPLdTNkuQP/By4x4QeH0w0z7y\nMQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7360", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7360` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAf3j0EQH7Xz4p9k7AGoOPY/RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmZWEzMDYzLWMwZTItNGJhOC05YThiLTYyYmZhZDE1M2JlNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQzZmQ2ZTItOWZl\nMy00MDU2LTg0ZDMtYjdjOTE2NDY4YzRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtKg8fosMBfL2wjtE4DU4Yo38MZq3mKfZtatiGGKoJzhDiw1AxJw5D3DPf8BY\nWsHbp+PXDbuuNkbW35aATlti5aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF7H8anvFrATJekyxm8tOgZeBf5swHwYDVR0j\nBBgwFoAUzGZvBOeZ6BcskPLYHq4rKvopjFAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIE0qVwKqhXJ8\nxx+owqsZbbrGUqQHuwDUOnEf8G2nQTIaAiEA/Tg34LT9OzaUG3V3sT7AEcDip4D1\nNj9SkfIUgvhqu/g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZMC4ms98MNdDuQiCqu2wu+WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZmVhMzA2My1jMGUyLTRiYTgtOWE4Yi02MmJmYWQxNTNiZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTgbTn8buO/4wC26oOItB/DE63Wc9S12Ddj6/rzyzMEf0+\nwNY8hxdbbJPxAMjebxO8QZNPp7M5sKNz5fqtKpk4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzGZvBOeZ6BcskPLYHq4rKvop\njFAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcFjusuVWBbxRRUgZe3P3UstK1ZWWYdPD/S12jONmMccCIQDhkD6SRoGo\nY6sp8wjNzkJOoyoQkFpZH001wI2dwedyNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAbghSKRMvzm4cXFDwKiTrGbKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQzZmQ2ZTItOWZlMy00MDU2LTg0ZDMtYjdjOTE2NDY4YzRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMzQ1NzkyOC0zOGFk\nLTQ4NWMtYjI4Yi05MTFhZDZiNmVkZWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQlGoJsMy/ldW8WjsnCIhq1ZRgxqJEnv3D2VmQHPxRrvApQsJxY1HRdavopEEof\nGN90ZDaiD/td/8hym+5KJgMBo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXsfxqe8WsBMl6\nTLGby06Bl4F/mzAKBggqhkjOPQQDAgNHADBEAiAlP8t/kIVM5reOx5SiC4nTYHTb\n60a+75qa7UMwuNGKrQIgUY2SFA6GCm0Xh5kHj884QNPyHG+MioM2WVs3K6EEdWY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7361", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7361` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAVDK+ZTW9xZdThU0OiQRu88GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlZjczNmUyLTUzYjQtNGQzYi05MGNhLTE5ZTQxOGJmN2E5YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIyNDNkYzktYzlk\nYy00ZGFkLWIyODktODY4NjI3MTY4NDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUfpEE1BJI/FYDuqusxo9MruFVa0U9B4tFBwfLPDuuJL2luw+sy1wb2ah9iIZ\nEjWD39WY7vVNyjZF3UQgcnZvHqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZluW+he4E2I6qzIr+8wLk57q2akwHwYDVR0j\nBBgwFoAUbJrnABqUrFnguvGhELSeC2RSZSgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgTwJT6YpXeMDC0YulvtER6X2PUJ7M4y3v6KmWXLN9FQwCIGPTvD/qhNRK\nHh8OYrDqGbgFibKk1Gd7Y+kXuAFsZ+fZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaqoHM1RzM77mdkgdry87ebgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWY3MzZlMi01M2I0LTRkM2ItOTBjYS0xOWU0MThiZjdhOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8lkQBrkCGtRvvdKs+jKG15URSHew0fw+pTVo2PUkUUlN4\n0eEgHIjIqKfo/akQ99lVYsZ2GYApM0EDnF5YMHDKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbJrnABqUrFnguvGhELSeC2RS\nZSgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfD5KqqFblCwyflCI+5Si1otQH8J1rY6C7CM7mvrt7lQCIQCUe9s1z+6H\nnwG2BwId1oky3zQw3OPjHUjWiJBc67kabg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZ9kMfSq2QW7MMg4IUQtIbQHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIyNDNkYzktYzlkYy00ZGFkLWIyODktODY4NjI3MTY4NDAyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MjVjOGQzNy02NWM5\nLTQ0MzYtYTJmMS0wMDJjMjNiZjEyMzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATSJvuzGVxDlo7EdgFhjkpiSXcBMsKq1HhUsEpyBMWQn515nTJWQFhJUsM0BKWL\ncZR9P+XSK8OCUBRFCTB1eEMFo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmW5b6F7gTYjqr\nMiv7zAuTnurZqTAKBggqhkjOPQQDAgNIADBFAiEAnXjzSnU6L6CZ8btt7TTBKvSw\nBLNxW6XDYOp06uJQcU4CIFtWk5n4PMW7YqeHSaPnu0kuSfJPTFPT2NSPNggMsDta\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7362", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7362` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAejSKI4v8YqHyWTfxMWh2RfxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZjQ1ZmE5LTBlN2UtNDlkZC05MzQ4LTk5NDVlN2FlYTIwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJkOTkyY2QtZmY3\nOS00ZGMxLWJjMGMtMDFkNzQzZjgzNDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQB++QbMB/VMUMfJ5AjIvA9iwlOD297nINDK7CNH9inisdGS3i5Jsx44KzEcD\n19xGnKfeHAMjU+vHGs0lPlKm8aOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM6tt11sWnOnYPiPBAssi+KdwY9swHwYDVR0j\nBBgwFoAU11jT47XNgJUM2JKeLCEqECJ3RxwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAO0vpbfAOqx9kH0MbxdkLZtaefi2duW/tdbsBqDCy+ZnAiEA4cN+VOX7\nsvl8h3vOejIrcvON3deDdvDpeiWeXZ6dFfM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUSdzj7oLwrZwOT2FXs/2fhuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWY0NWZhOS0wZTdlLTQ5ZGQtOTM0OC05OTQ1ZTdhZWEyMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuOZrkxWtNZnvA87Trtb/8iXBvq950x0ay81N8IIMyFbCH\nM7EWq6vbaBXPuOA9n1BwWIXmOUolQFl7CZn/YwI9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU11jT47XNgJUM2JKeLCEqECJ3\nRxwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOyUot0YytCWkH1NAZvS/70s1RtfN2fzzUMQOw2GAkBtAiEAvGUpCCvQ\nFmyGXYKv0bc71kFvyMKl8HfnQOwpKZvdHSU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISASS0LVhKW48gBIVmf7+qrHMuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJkOTkyY2QtZmY3OS00ZGMxLWJjMGMtMDFkNzQzZjgzNDgyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NWNhZmM1Yy0yOWNm\nLTRkMzgtODNmYS02ZWNjNzFiNjFjYjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARyhxtbTh6VqLPx4nnpZFtk58VVMp7fRvOgCKrNyVeKdWwwecC3NWIJmPla+E3r\nYvn0sW2XcHf9VMNl6vE9R6QUo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQzq23XWxac6dg+\nI8ECyyL4p3Bj2zAKBggqhkjOPQQDAgNIADBFAiEA+Gb3s6hASIztzeB8LESSj3JE\nSsgOlINmM0HCBYLbYSwCIEVukg0MQCtqqT80G+o+2qFctgsxQQoJMMV2SK4MuxYC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7363", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7363` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAcyKLFK8iFFBvGhvmS4T19jBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiNTJjY2Y2LTU1NmItNDgwZC04NGU2LTNkYzE2NzE1MTU4YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFiMjA0ZTgtMmNj\nMy00NGY2LTgxODQtMDc3MTBlYjMzNTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhfl7l4EqS4P73Z/NRXjPvmQ5H6KmVihuFlssDE1h5SOAIEp4Sbd2i8JPwUf3\n2OKACftLUKKeazN/DQxV1XeDB6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVkcYRtESfWn5fndBViyuhXib8f0wHwYDVR0j\nBBgwFoAUeVgreEB2eZcre6KnWbX0ZN+ChMMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDUGAJzkUWK6oifgabXJ1VzASht4rKYv4E+t9ilq3YxRwIhANrU8Wo2\nlBaddLplKvJRwudS3vBA09kxKubxvnJ5S7pN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcL9ru2BGyN89ftbjyr4uooSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjUyY2NmNi01NTZiLTQ4MGQtODRlNi0zZGMxNjcxNTE1OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqy0dTIk1Ya1RSw9nz0p4pvKaL/tLV7T2eTm+zJJid3AsW\nDoz+7FMqOEHoXM2QNul0G+pg13KXXz+dyWeXHAMao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeVgreEB2eZcre6KnWbX0ZN+C\nhMMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSCOqMa/GHpxlnxFw8wNwaPcr9vIqZDuoSp8CdKaipXkCIQD6tYuR8h8m\ndsseOC8L0SI0FDHWhZPTwS+J28WuUfZt3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAeBWXk+GtECQsOKmP9gDZOaLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFiMjA0ZTgtMmNjMy00NGY2LTgxODQtMDc3MTBlYjMzNTBiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZDM4NTY0Ni1iYmQy\nLTRkZWEtOTViMC04MWZiZjlkZjQ4MzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ65VAFwY38MtLKLEhvturB1dq6xbcnZU9Z7D84KxHNG4tnJsuWEh9MBQiJvtj7\n4PmTDYIHTyNcedTssVwtHGalo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWRxhG0RJ9afl+\nd0FWLK6FeJvx/TAKBggqhkjOPQQDAgNIADBFAiAHjhiS1erCyg9qHp5sxPclGjT/\nmZIqf3+D4qTHTUPSQwIhAJDjxSQ+GH6T3MItO/7Ci/JuoEDj9L4yQVAorfUOEmAq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7364", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7364` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAUUzH9jC/jF3R9CZjRlbsk8nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkOGRhZGI3LWNkY2MtNDM0OC04MjkyLTdhYzQ0YzNjYzg1NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhmMDc0NzItMjIz\nNC00MDhiLThiYmYtNzI5MWU1YzYzYzVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp8EWvP3opPdgxcYYVqjKlHuaRT19vKSJL6oyshIEXzA8Xm3aYnASO5cZOEFV\nGUwwMqidbFsgYH1YRWL/LMgVCaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjyhRmA+BTIvewtRQa+MAWxQyUoUwHwYDVR0j\nBBgwFoAUtPuQqprUGwRbDsRO+o3tHRuWjt8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIAua4voVEwOHfJN9lWrPq9bvKXarFrou72MFfmZu\nD6R9AiEAgovjyjwSNdWfzaVSs+/6jBpyELeg2J6DteuxwmEUnTs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWoONUXwBVZ1EeFNy2/kTjp2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDhkYWRiNy1jZGNjLTQzNDgtODI5Mi03YWM0NGMzY2M4NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvbn7caIBdjOxMce7JDNEJbnHKDOjz9Ga1U+MEzs57lj0F\n+oKaO/HGXiNMOdGe929mgadNsXhI/oHFNSYvoDjLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtPuQqprUGwRbDsRO+o3tHRuW\njt8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPgChZVYQJ43LFoQw40YddwH+iJ2gx0TihQrkKacHiIcAiBegbUUspg+\nG90Nb/PjODNprD8D83SSuh1tVBbqxuPSpA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAQL3T4XbrAa/ulZspW5ZevqiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhmMDc0NzItMjIzNC00MDhiLThiYmYtNzI5MWU1YzYzYzVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZTNmNmU2OC0zZDYw\nLTRkYjMtYTlmZi0xNTBlOTE4YWZiMjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATPc3FcC4c7lD2GOp+0qnb+jTULgJJhjjUdpXS8H4D6EC8Sw//s1GhejpQMg0Xz\n2lWjbbYTk+ETDBIM+vmSxiJ5o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPKFGYD4FMi97C\n1FBr4wBbFDJShTAKBggqhkjOPQQDAgNIADBFAiEAsEhhyi9htnxaWNRvz53or8xo\ncDz2V9b2fyfsQ+PVwd8CIBSpL69PQqkstL5czY7eQwspHXcRH6KFqz4GCnRhocCD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7365", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7365` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZMWD14INWER73G/DUCmgmvfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2MWRiY2NjLTIxODQtNGE2Zi1iMDJkLTNmZDFiM2Y0MmY4ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY1NDQ0N2EtYWM3\nNi00Yjk0LWFiNjctNjliNjI0MjdlYmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvSG/rw0fdomM1IRbGK6linysnbAlw29xU2lHo4NNIQ7By7v5MreWi2kvO6tC\nVnJzml1hVATGCZjAJl/5YdG2G6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUriJy4sIACR8P0UDKjGAxvQeLi18wHwYDVR0j\nBBgwFoAUI1OiMhkrGpfuZdQXjCXPA42Yba8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC7Bp6a7qy/kc77SHOXLC3N0skhySWW2pLEuIQF\nGl0XeQIgbLgWgOk/oYbSTm8bxGjIoTbKlx890UD/WRKpCtCZSXo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbiRFNHu9ZmuXezCcJlNFVRlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjFkYmNjYy0yMTg0LTRhNmYtYjAyZC0zZmQxYjNmNDJmODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaNgPqn9FnMGtOJp+5gnucr9cntLxWww3naFyavU1gOHP1\nHgTu5+fO3089ZLJ5bIEGtjKMdwAo5PnKdgyvz1rpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI1OiMhkrGpfuZdQXjCXPA42Y\nba8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAILyh83gzZFntFqCvMfaklfuebMAZ8z23yomLthDBTdBAiAzHJsvL49J\nqfIFwUkpemC9pTGK2LzG8bJ8V2Qfj2YmtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISATaXWDRfRjsohYsbkAZh2s2yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY1NDQ0N2EtYWM3Ni00Yjk0LWFiNjctNjliNjI0MjdlYmExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYzliYjFhYi0wZGE5\nLTRkZDktYmM0OC04NDVhMzQ0MTIwZmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATW3bnLlkaX2EDvq45tEX3Roof2GuY/4hF3KUq8QIvBjIfgA+AAtm8bR1byj/1t\nEXUu79lShJiiwUGtTemk2z5Io1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSuInLiwgAJHw/R\nQMqMYDG9B4uLXzAKBggqhkjOPQQDAgNIADBFAiB0aAWGRaSLQkmhmmBJlqwHwNlU\nPRLsVM1Q9aOtrvL21AIhAIlzi9kQU0AfHCSfwyvjssyaDqEDMzArCXUj8/49FEol\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7366", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7366` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISATEE9SQJsmBVv+FQBd+/2b9aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxNzU3MjVkLWMzZDAtNDY1MC1iMmVmLTYwNmQxOTAxNWE0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmUwMWM2YWEtMGRl\nMC00ODFiLWJmMzUtMjE2NGFlYzJhMzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErf8Upy0m5m7otCPxi5GdX2KiTYXv4koqVs2lefI3/xSFJF+cXb4Do083VOw2\nzosGp1jhlmvFpnyKITzO279CqaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbOAHAhz1R8HcjAI2V8h17fK6IbUwHwYDVR0j\nBBgwFoAUfKkeprhYsA2xOw1uLBjGOHjk5F0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIFxLR+dEQXbXVwz8x6x7YL2sSnjOkhmBWxm3WBqzoP3QAiBU\nCMPp6ZxR/CUdNzshxFNnhisFKScdtEvQl8k4CisUQw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWm1owM0PmXCVhioKu5aCP+PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTc1NzI1ZC1jM2QwLTQ2NTAtYjJlZi02MDZkMTkwMTVhNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAYQ48+b/EF++x1gsk7hNrcq1FZeuEWBaFXVQEpIJnl8X2\nU9wGl/IsvOlSsg9K4X5YGm+kpo+h5wCNPuUE/N6to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfKkeprhYsA2xOw1uLBjGOHjk\n5F0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU2YuTLt/bKTxK5fqBRtfdKyZ8DgDkaCZPN8D0XKmyKECIQC7BTyL5h26\nNEGDcOvLIdDxJFi2YmNlCu+3l7t46iLhgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISARepl77IqOuiDZhRg5CLSeFBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmUwMWM2YWEtMGRlMC00ODFiLWJmMzUtMjE2NGFlYzJhMzI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwODZmYzgwZC1kYWZi\nLTQwZTMtODZlZC02NmJhOWVhYjYyYjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASIw7MMIBXmlsZvD3gMN3lWySsq06l5u70uomCHPfRUaWeB3A1ZrKrvKIGEfela\nhIISghi5L8scWi/yqv7Hk6xvo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRs4AcCHPVHwdyM\nAjZXyHXt8rohtTAKBggqhkjOPQQDAgNHADBEAiAVWQ5gq1IImNniS+QIlU2kgmTZ\nusci8LQuPPKVyigl1wIgH/JyTFuUuu9k7s9ZSIYBKLvy6oh2fyWr/Y8A+8kY+0M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7367", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7367` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZKFF5DLlTtQXtpuVLgqblh6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkM2UwYTZlLTdiNzItNDFjNS05MGUzLThkZTYwNGFmYzdmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc0ZTVhZDAtZjEy\nOS00NWQyLWIwNDgtMzM0MzcwZGZhNTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEahARJYqwx2U7K659qu8vpkNxHZtTEmCQRsLbSq6nJTQH7rA2pu2pyr6GMST2\n2eBQPTKI7VLIvixPRu+N3JVHpqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSfYvPo2KRbCnER3PfNnp/SjCWzMwHwYDVR0j\nBBgwFoAUvM9XFKdT2k7UOE0nJWLm6C8lLzwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICulCmPFtmoX8LRccpx8CNZazqs9l8/V\nGkGYsG5Ais0TAiAu/gF+l5oAcum+3+lopG1yYYCNmOjfm3I2i4kQFn8nJA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASCmTHGK43Kw/RlndosdJqkTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDNlMGE2ZS03YjcyLTQxYzUtOTBlMy04ZGU2MDRhZmM3ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcRnk4hBUsBOh65c/rOy5WRpJu81t1TRWJL/NU8ooVMP+j\nJDCzHr0bBTxJBfCw3sQhMcmCO8YxAbWUDybvDqS6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvM9XFKdT2k7UOE0nJWLm6C8l\nLzwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIge2cmylM8xrboZhTgbMfMbp+oqpjjiQB8CZXftZNlvjQCIQDSOmLFFBXx\nexoPDEC7vExEDGfNGM0LMivjzZmeRxkh4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISATv1orlBtICwzMnUtC+Lryf4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc0ZTVhZDAtZjEyOS00NWQyLWIwNDgtMzM0MzcwZGZhNTI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyOTlkNjVkMi02N2Jh\nLTRhMTktOWIyYi1mM2I4NTRhMjgwOTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS1euMY4b6uDrJew9f6EUueHhXgA97z3wMQL0todjKtXYfikToTA3d2iCJRlcho\ne1/EKuCDyNEnfaoVivpz1/17o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJ9i8+jYpFsKcR\nHc982en9KMJbMzAKBggqhkjOPQQDAgNIADBFAiB28Zax9dUW9W2EL9D4nfawgHtj\nqWtLTjKzF1mjoeDSMgIhAKvONG+R9NoRH6v7JpBocvc5k+fb7R1QzJ2iDRoTRHhX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7368", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7368` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAXdQm6taSycXyml5n4ZW/dAUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiZDI0M2IwLTI1MWItNDJjNC1hZmI3LTZhODIzYTk2YzFmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNkYmFkN2QtNThj\nOS00MWZlLTkzN2ItMTQ2ZmMwYmEzMDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEoIPM9MGkJ6ots/lMFNrPL5ufaO8Np/ep9hPZKw9jyLPFvTfzOyLo31dWcR6\n9qQXBkDe/J6YpT0Sf+Miyoun8KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2OjjTd0BcF2DrwvaQFaNe9jEDMUwHwYDVR0j\nBBgwFoAUDvbLJjWFiDHy+w4gQOVCFvuI/oYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIEVKrDRHRFLaMR/H7cXRvTHelagtvlH7\n1lR29PIzqNBfAiA2EzlPjr9GlXtOMQ43LCN/qX1khLaKnjFDafJJ8+TDsQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUTgrAgtWCOAanypMStkg10TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmQyNDNiMC0yNTFiLTQyYzQtYWZiNy02YTgyM2E5NmMxZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARs2yv8jyfVL9HXVbHxqbTfP3X1pGDpA9G3vt7iTYG5Gt0l\nHm4BXVYOR4Kg9sA+REb5U/bn9iQsWFWsBFRZgjrGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDvbLJjWFiDHy+w4gQOVCFvuI\n/oYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKDoaWHXvXQub73cWAxMVJJNk9Mgxk55VyS8ujcIpYV8CIEH257Gc5xJ1\nhT2hfZfhEnvaVJI/xJ5AeVJXj3xyGsZy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAaBkFJEjb7mVHncq0+BxoMOsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNkYmFkN2QtNThjOS00MWZlLTkzN2ItMTQ2ZmMwYmEzMDc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1OWNlN2NhOS0zM2U0\nLTQyNmItOTIzNC0xZDBiMGU4OTBjYjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARXu/prGWLg5iBpiWV8NHzhSPGJDpEUajs7MHpxqf0vYUdQxNHrIriwrA475Gcn\nrq9Qt2Yjn9+Q2S6xMsQ4R1PYo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTY6ONN3QFwXYOv\nC9pAVo172MQMxTAKBggqhkjOPQQDAgNJADBGAiEA+USagkHbs7F0SmFF94MlWJjN\npivTZ3jeIQdOIbs9qiECIQCMHN3sZJtF8Zvt8sX3nnp11vx4c/NOzaom6mk+iSKh\nGQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7369", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7369` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQ80Ix9KICALo/Fjdi5fvl/FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5MGNlMzQzLTljYWItNGNiNS1hMzgyLTZlNWM1MjM4ZTQ5NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY2ZTg4MDItYzE0\nMy00NDZhLTk3ODgtNjYzMWNmZmVmNGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuATbBq8X3LUD/+/ls1rPkGTR2N+40Rv1XTM7iwRfDOVApzRuUY802Ck452Qx\nUjJ52dI/172awEjRS8SNUyAJIKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiByPNfbV/9LbpmCduhCMi3vyk+UwHwYDVR0j\nBBgwFoAUaTrt4OkHWLufU4UK8XyLtSktmRYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEQA0wr9F1/q\ncSjxA6u4+c5aFxvOJlXES9HLq3dvw+oCAiEAsGfmqxW1wS/XkjJJnBu2fq0d6g+q\nI1mCR7K6/sCs+Ds=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfYLbv5mv74vVv/urW9uB3sWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTBjZTM0My05Y2FiLTRjYjUtYTM4Mi02ZTVjNTIzOGU0OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnK+scB6ZlzG+XNgzji4lvwfHj9prwKPtwStOvrneBfcu1\n29vgD8Q4bp4S4H0oOIEF/R7ftzfGgxXGb5BSWEZ0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaTrt4OkHWLufU4UK8XyLtSkt\nmRYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANJyqT1ZdCVkgfc8YzRN7Z0NP5AlYh6+CWJNQkP5b6uBAiBp96fVhsFQ\nKf178QYrBmhgZETBh0p7M30ZJSQtpspp+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAexa1yhVSSm2unOHu6eGZwXeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY2ZTg4MDItYzE0My00NDZhLTk3ODgtNjYzMWNmZmVmNGM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYjM2ZmJkOS02NTJi\nLTQzOTgtYWRjZS0yZTkwMjRhNmNjOTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQBOSup4jMyuP0wBmSiqBTOc4HoFYSoAUZjbIyT4VksmT+cXdkaTaTZEtSOcOtb\nIFAsDlK5yMut5TkbSrEYwDZeo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSIHI819tX/0tum\nYJ26EIyLe/KT5TAKBggqhkjOPQQDAgNJADBGAiEAo/fWwHNQQJ66qGFy8nbQ01uu\n+0vMklGXzJOj8vqNSawCIQDow36JHlY8gH5XuJFZyjy4nvROLzygfS20yfqdDobk\nAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7370", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7370` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQuxyzrH0/bjhhtP3PhAbv+eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjOWUxNWE4LWUwNzQtNDgyYy1hM2YyLTc0NjRiMDUzYjA0ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhjYWJkZWUtZDI4\nOC00NTE1LTk0YzMtNjgxMWFmZDAxOGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4LciiZSDQQBXvwR95jsCu0YF2cgS4T+1r8QePmLo7JiwDwfCtNq8p1t92UVZ\nF5iRAsOUlvlnnrsRdORcL2w5IqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpxrIcUdiruMnQZ7kP0V1u3K2b2IwHwYDVR0j\nBBgwFoAU4bOC5rLGcxfLJAITK5pATSLdaLUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgJ+/6gsTHueMUT0CMvyTzEOdMzYUDtUe2Spfc82jz0rQCIQDTgOnaz7S8\nuSYnHfPeYKThRwH12gKFa0CI1EEGOSU5mw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbZe2XzM+19ExiZrt7A86n6+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzllMTVhOC1lMDc0LTQ4MmMtYTNmMi03NDY0YjA1M2IwNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxcPrsiFCWmvTUyz6Bojf7PEoxnTmKO0hix2CdWqLRp0tt\nuAIz+vAmFqEhN3MWAO7uLcQJreJII1e3cW72rk06o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4bOC5rLGcxfLJAITK5pATSLd\naLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANvTvQcos5rtjzdpe/Pz1szs4CGUSuCCyZLEOX4gI0wtAiAtt9xwJoP6\nsbprcaiUVfVk+8YwxYFWx4RYGe4UcZ+YDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfnrxz8ff5oEK2GRVmPoCLHXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhjYWJkZWUtZDI4OC00NTE1LTk0YzMtNjgxMWFmZDAxOGZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ODgyYzE5ZC03MzY4\nLTQ2MjctOGY4ZS03YTliYWE2YzRlZDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQTLydlYFr9QSWZcDZq3kzHOVcIpYhGWu2GXgT3OUMw2nRlsZpX5Q0MVPDj4kyM\nfgbumV5NBS5+j1LZre0th2vUo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnGshxR2Ku4ydB\nnuQ/RXW7crZvYjAKBggqhkjOPQQDAgNIADBFAiEAtO2OBN1s+wVC4c/LinN6osG7\n0VzXvb37IiMPFWdB+HUCIDyoKXbKCfsZ5vCsuEgt4r7u6MGX3ojUeeHc+awB9OcV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7371", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7371` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAYctDL5mDkBXYuTI+0RQ4MkBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwYzUzZTI0LTMwODYtNDJmOS05M2U3LWJkMWFiMjBkNjEzMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRmOGYzYmQtMzFm\nYi00YmZjLTk1ZDEtNzUyNDg2ZTg1OGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENWsiPjg1+y3ALVoNz0aEAIZRNfuW5ogDZjY9Itvv9D7u6dLUOnkCdqhrO4Rg\n1b+P8YdlVItp2gnAeS/pOfM9CaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHJIqbA3u7wqWUVIhhpzRjthweiUwHwYDVR0j\nBBgwFoAUIGciEadBGBGb5UtbzuCWd6kSpkMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKEHvxHD1zIHP8VZ0PfdTHANtoWHPTq1XdfpkfK0mMWSAiBhVjhJhSDT\n37TpN8ROPTpSIDRBSTc9sKuR4/ZOVjlx0w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAW9zAHkQe2svMPllQsmyKZI5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGM1M2UyNC0zMDg2LTQyZjktOTNlNy1iZDFhYjIwZDYxMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1MJ9YBEi80HndcxPl4N+AgTPeBMyzTqiwBd3104rREOwG\nEkBR9TNxXBSC/kS3oSk5wfte2Q/Gs1agmv2zfXFfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIGciEadBGBGb5UtbzuCWd6kS\npkMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALBAl0z81FFuYluObJyBbkU394Kr0kEkEottfOmBv65FAiEA/b/FYLA3\n3bxIMg48YFFyaNEURnHdScgu6r3slhUmAXQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAav7pBIA2E8uRqsZ1t0mlhHxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRmOGYzYmQtMzFmYi00YmZjLTk1ZDEtNzUyNDg2ZTg1OGYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZjA3MjE1ZC0yNmJi\nLTQ5ODUtOGZkZC0zZGJhODg2MmE0MGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARqNIbAGmwlssc8crBePaCqhHUPKpnlPXB9FTPkSfkFyGryNbEfGawv/MTzUFWl\nAHe24v392+YPj+RjZ07VTP0ho1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQckipsDe7vCpZR\nUiGGnNGO2HB6JTAKBggqhkjOPQQDAgNJADBGAiEAij4QexfsqiZhWl98gy6ID4Vy\nrpf0qdjV59hRLfP9bDwCIQDuk1NmGqYCspAe/NDuwS6+h1YxV62vOj2NZBt3DNmT\nsQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7372", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7372` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAYXhcacjtL6SZz2Px6+AkkwHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiNDk4YjllLWEzNTktNDQxMi04MzM0LWRhN2U5MDU4Yzc0ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2QxYzRlYzItYmU4\nMi00YjJmLTgyYTMtMTk2YTZkMGYwZWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVmTdpaL2XYZ1WAuS9LQ6AzrWy0IKYbjwH/B0xF7axX+7Pwke4Q/mDXZ3sN0W\nOlnyqJw3GdPqBRR9XuRlZyWaEaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFv07/FzD05XTAEORzZFd3ZT41vkwHwYDVR0j\nBBgwFoAUKq/X+Qo9mbMHJ3XaG64S7OGTVMgwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDEzEGbqTGvH/TI0iX1+3FR7BqU60xOxc42vm00LIyuJAIhAJW2OLI9\n3o56Hh1a4mIbeACCVVNfBPmFQhDxlTjPjzKf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXB7fJpZhqsXe0MOe/5R5Kn7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjQ5OGI5ZS1hMzU5LTQ0MTItODMzNC1kYTdlOTA1OGM3NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTdBka7Fcgcbmsb1miHg9ZxUgMaZcDv7n6ENBGhM6A87d+\nHNEQHQCPVIxdAqiE62uJI7tRk3/X+mb/1W+1iI5Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKq/X+Qo9mbMHJ3XaG64S7OGT\nVMgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNcVjFHmJr7fZKcXSahImYuc5OT2nHNzNylarfsKbM6sCIHzuBZCzirw6\nLmR2A5z5LOaqkurY6ShGxWc4Z0LubQba\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISATH8IiCpDXEbDauN7AMq+02TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2QxYzRlYzItYmU4Mi00YjJmLTgyYTMtMTk2YTZkMGYwZWNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjN2Y5NWQxNi0xM2Nj\nLTQ2ZTUtYmM4Yi05M2MyNGE2N2YyY2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATbBXSiAeY4uiDMhZ1LhRJpNgR/Pqh0WvEknSlilc/jEQuGNoPfCLL5k289QuuC\nmymXOWcOdl26DjYnWdkbOBE4o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQW/Tv8XMPTldMA\nQ5HNkV3dlPjW+TAKBggqhkjOPQQDAgNJADBGAiEA0YTjKHvw71y6ohQO9L5aDs16\nylsQmiUTBiCsYMZ8VOgCIQCShkMc4+pwaD7PwEXjh3mKvx/4AHNuOTIAhdY4loO6\nwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7373", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7373` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQ7MvlNcgNZAnNqtTArrneMrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiZjJiZTcwLTNlN2QtNDMxMC1iMDViLTEzOWE4NzgzN2Y1MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk1OWY1ZjAtODA2\nNy00ODdlLTgyMmQtYzk4YTA0N2Y4NmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIoV9QEgeeFrHx/GXITlR5gRTAODTs73wP3M7sMLITEQ7YZp9Ib7ia+TNYc6y\nvnYB+B9IU1a+W08ZyjQKqmgX0KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpUT05Fj4zOywYea+b5uHj01eOUgwHwYDVR0j\nBBgwFoAUgsWDJ8JY2DdnDkTsxhPC2bOiewAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIE0g1BFaqwKgG75/W2/6Ufm5EeEZ6Le89IPDJMH1\nCy3XAiEA+ehikphvPpoO4uOMcF9grKAFQ3IMQGU0nU8obYhf0S4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQsXdskje3rbTNRXkdg/siiQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmYyYmU3MC0zZTdkLTQzMTAtYjA1Yi0xMzlhODc4MzdmNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg002cn1lM9lGrdYg0ycPWGmbyoArwkEjtZhLbe/JHPp6X\nDWEecUrih3mHW7e+uFLGCr0p6TMmRcNXCKLXOg1xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgsWDJ8JY2DdnDkTsxhPC2bOi\newAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ0OGJyHdpLW3CwE1lb9W6GnkJB3PjUZJXE7zNV9eBLiAiA92tdlCA0+\nmidgjUQCNwUnyqk3DUc+AiFBD7GOAS75/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISATH/mEfLr95aXaEUIXX5elQrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk1OWY1ZjAtODA2Ny00ODdlLTgyMmQtYzk4YTA0N2Y4NmRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OTcxZGJmMC1lMGVm\nLTRkMmYtODYxOC1hMDE1ODYyNWRhMmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASf31rybWh64Rs/g+rbMaQKqCGHOd7sKD30jESvP6JXUqPjo7qBCNy3i9vTJy/v\nTN7af+1vks/GEAsn/C4y+bfTo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSlRPTkWPjM7LBh\n5r5vm4ePTV45SDAKBggqhkjOPQQDAgNHADBEAiBuXc3xKgXL6ZZ7EyzSO1KSuKL7\n/WwSlSi+6HdBSc0qYQIgW9WkBwlXYt6x8nwQu4XH6U2FSfCRSSW+Nv4gxshDaYA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7374", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7374` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAahGbWKe5bZ9WFbiQlt+dB0SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwOGU3NDNiLTUwZjItNDJkOC1hMzU0LTc4MzE5ZTBlNWU3NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZjN2FkYjctZjhl\nYS00ZTNjLTk4NTgtYzI0NmRlMjQwZTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1/aAWg6RQjDDyiLjsHJ/d1/VjBnMipCb0l5wMgqRPJuJmubVMfBhEfgq2uPN\nOmZhj5DZHRr1Z+GX60lEsjIHaqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9+7HxiM+F2jDl1MRaYsscwxMmmgwHwYDVR0j\nBBgwFoAUrfHdoMi1l8r9oDN5zrEmR38BhaUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIFiEUo8xWR/1kT5/MZJ5cZ+GX7vr4k+ObuXQo/6U\nIe0AAiEAlRVfbDhGo0bzbZc80VU07SM77V3VNa8Q2o/WlTaSszg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXLfA2zZ7kOwt9iUBPojd19GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDhlNzQzYi01MGYyLTQyZDgtYTM1NC03ODMxOWUwZTVlNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDWP0pp6ez1Ap3MBZ8abM2FT3/m/dgHDndYtBF4TFNVpnY\nxZVVjW5pfaToMvM7xOWUW938Wrb77OKdbP42X9J0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrfHdoMi1l8r9oDN5zrEmR38B\nhaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfLcZfa9ts3p3svTODGcvDSG8Cs/4pLpu7fb8W29q0BYCIQCYj0u3ttiH\nVCri8BhrLvIsc1cf6uNmCMvXVOdm0KcISw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfHDkLqTB3n8NE29CsJMBHZUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZjN2FkYjctZjhlYS00ZTNjLTk4NTgtYzI0NmRlMjQwZTFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OTNkMGM0Ni1hNzIz\nLTQ1ZGYtYjUyZC1jYzRlMWYxZTBkNDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT7q3ShMYNdWxuh3duuatT7RDj7QFjo74JGW9G5J5Zk5RS0+vvn3PTkXNJdsR8f\n/COKZkbyi4BowfgHzvdeVJ42o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT37sfGIz4XaMOX\nUxFpiyxzDEyaaDAKBggqhkjOPQQDAgNIADBFAiBoEMWv8Jpj5qvVTjZ2yXoFEWgL\npTx0nP8NHu31VTK+uQIhAMkfWStOqw2wiy1b6jVdOOjkpTrtRphoS76+TImU/WQA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7375", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7375` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAV1u7tsgUmVDn5aBrxk49qISMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NGRiZTNhLWE1NWYtNDFlZC05ZGJmLTk5ZjExMDM1MDNhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWRmMzQ5OTMtZGE2\nNS00YzJhLWI3MjQtMTUwNzFmOGExM2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGJaGQ5IegiW8I/IYR5GyafAm48PeLMY1psJghVljGOqEkATSYtRmHw9ba7hE\nA3MY25ub71eb4quGfjEu9Ju05qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgQ+PGJ/m31N/7WNCewdFDwuAh6QwHwYDVR0j\nBBgwFoAUJuXwcI55xWCiBaQ6UKit6JWodcIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIHJEYlEIIi616T+dXIiqvQatyREhIjkA/DkMcaZi/Q9KAiEA\n3F7m7ZAJnbnk1wSlRJfwuoD0p+g4HbwdDlRaE7VfW4M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATSUdKdnbeov/Y7AARd6jQC0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODRkYmUzYS1hNTVmLTQxZWQtOWRiZi05OWYxMTAzNTAzYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeZKpISB1wpz1qowE/bUFIwwwx8NNy8AkYbwjl5HMYRA1E\n4SDhbKTqRNMTTxaRup8zTwr5zsEJ/79kBx9syWN5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJuXwcI55xWCiBaQ6UKit6JWo\ndcIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANhRMZJWGNe1vVd1JM/FsxKq5glwORUNuKdXAmBPjBB+AiEAg/zldlJV\nnOlvdeL0NpgePV0D0z6Y8FE6Ej9vGj57/4U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAaKvTzu4d2kzegUZZVWhWfHYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWRmMzQ5OTMtZGE2NS00YzJhLWI3MjQtMTUwNzFmOGExM2E2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MzJmMTYwYS1iODQw\nLTQ5NGItYmRjYi01OTQwZWVhNTEyZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARomDAj7GfW0iGtmlCmpHrN7it+a//BotScjCl58mu10RBQ2xIVHiAxgiUcu0fS\nAy5UOoqNZsADl1LcTLQuuZ0Qo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSBD48Yn+bfU3/t\nY0J7B0UPC4CHpDAKBggqhkjOPQQDAgNJADBGAiEAqlTUb6YgJaSbD9jWt14H3GVj\n9goMhb0mCejf8OitcdMCIQDqrLx4+Bv7vFCz7cXuQwKkb5eFP8/l1pMHHQNrDWIz\nQA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7376", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7376` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAXSNwCngs3DCVhiFDqDJCyuhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiYTZjYjE5LWQzZmUtNGFiYi1hZTAyLWFiZDBkZmYwYjFiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZiZGZiZDUtMGU3\nMi00ZWEyLThlYzEtYjgyZjZiYzlmOTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHB1TjciZYa1yP60Ge/knfZLIDhkTmM1/QXm1YwgV+VmwsXOEUUbBT5WtdnEw\nIFxtVS15ugNyeOSsfINjZE/2oKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN8ctEnnntWPyTzwzo2pndsVVyB4wHwYDVR0j\nBBgwFoAUnJfdlIJHtyPz3ccWkFZjYfrYK8kwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIE1/6SzoXSaLxHRo6R4Fr+WqvQ1ociKY\nyhYuQfUxxIdRAiA8qCbGKWHz55tX/UEPKNz0dqWiglu3OuDuWSoN1E38UQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcfnbkU+Oxkjuzw1WWUT3qXzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmE2Y2IxOS1kM2ZlLTRhYmItYWUwMi1hYmQwZGZmMGIxYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+dY0C7lDq0+y8+uKZkB1SfgfIasZ0gdZ9/RZbxqYC47kR\nPSdgZXfUDB8VaMiv6PtDa5wqz+m4zs60Jj3vUHpXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJfdlIJHtyPz3ccWkFZjYfrY\nK8kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPKc0iUiGk6SaHyVZ75mb5+pdAzV8FNTlISJkwcHsHhWAiA9LnX6kAzn\nRYuIa5itohvh/m44AlWvRDAzisuJcSUvBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfsOcR3/CaBSK6FdMQ2cFsACMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZiZGZiZDUtMGU3Mi00ZWEyLThlYzEtYjgyZjZiYzlmOTJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MDkxNWE3OC04ZDM3\nLTQ5ZTEtOTdiZS1kZTJkZTQ3YTIyYzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT+SwT2MQeKVbQjyMFWGgzpRDmOyPuTjuWQ93x+KnPoaTe6UL1vvxO0Wu+Y8Jd0\n+pwsuiuo7hfZw5AaAGUUp2o+o1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3xy0Seee1Y/JP\nPDOjamd2xVXIHjAKBggqhkjOPQQDAgNIADBFAiEAiMKiRLeFtlGPhWMZDao+FO/M\nIDbIy23Ci3p6fwxR4rACIEoDIWEHfUutS1LhDRnFNU3UepcKvPfxjXXFxNLlqQyv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7377", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7377` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQQ8wcsx2wOC/r0g+w1IZ3e9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4YjllZmYwLTRjZDgtNGExNS04YWFiLTM4MTIxZWMwYzY5NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I1NTlmZWUtMDVl\nNi00NDU3LWFkNmQtMjAwZjVlMGUzNDllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENENwL+HpoTO03/qM6MXPkKif3UZkNlmQEERvQo3z1vP4daDj22dtXBk0Y+Lx\n6fo+tadzWWlPXubm8FuKKszcP6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU27q2qrSIAmoGmG1z3MlWp3RA9IYwHwYDVR0j\nBBgwFoAUu9DYG7IDYHQm4kKNdMBPAzEgWTgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIH+C2+tCf1xvH8CEpxKNfvnsHmqUylrs\nA90zDIy4Rsx0AiBqC68/B/K+e6fOXezm4Ur3g9NXcbPFNNdeyCdncdXoFA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARkBVTFkwZJQWTZcgh1YvP5fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGI5ZWZmMC00Y2Q4LTRhMTUtOGFhYi0zODEyMWVjMGM2OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0JrfrtchQ4SLWHCih0VyjcwOMZoNUxy32xnhoIhipVmE0\nGZ+PKcevXRHL17tmmrgAQoGBVRwKZR+a5tZwvl20o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu9DYG7IDYHQm4kKNdMBPAzEg\nWTgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbwj4pvkNYr9tl2tlsUkgPVhgkrIgoW01p42Z+Tn804gCIBTxGyNsQRFb\nmrUNDQc60rc3cN4jAJNILP840UR1niCw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAaUbZwdxniJyP0b4wB129r1zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I1NTlmZWUtMDVlNi00NDU3LWFkNmQtMjAwZjVlMGUzNDllMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYTQ1YjA0My1lMDdh\nLTRjYjYtYmE4Mi01ZDJjMWY5ODdkMTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQlgq2ULTFtAFoZ54ygyzNnTDe24we40oRhwzBDsC5yjHXqtykgev65zcx2WgYo\ncU/F51HrykAHRIFR1xAQApBjo1YwVDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTburaqtIgCagaY\nbXPcyVandED0hjAKBggqhkjOPQQDAgNJADBGAiEAmAF2Rq5fvJGyx7Vy5bFd+PHo\nHvGEVXQ9+Ab1RleLeScCIQCXfd2Wtl6z7FYIb2mklabVSMbCNoyurObQaS/E1H7W\ndg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7378", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7378` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAXQibbdDI3Nsx/tDDrn0wPg4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMjFjY2Q3LTA4NDktNDYxNS04NzhkLTA2OTAzNjc0ZTgwYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFmM2NkZTYtMmI1\nZC00YzcwLWI1ZmQtZDg5MTMzMTIxYTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL+LTIXHhYqzn79vwthP4psbrAjUlWcES4iyzH9nZRD7ikwYrywFSCIMvutIG\nXwomRDxd7qnzSXLtLyVFHaJE7qNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKY51o+tMGcte2uGJrq6HyG5VgJeMB8GA1UdIwQY\nMBaAFE/kwFL1R+1gERCnVrymdZgW7WkVMAoGCCqGSM49BAMCA0cAMEQCIC5j3fzL\n3mu7DxFSxkIlyJcV7mPkQ08Zl/eVUt0S0N5JAiA7pnZkagldIwhV8Vs/OYO8/b+E\nUfR/psRbEiplSICIlA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU3sC0wM2ymnAytH0Om9zQkqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjIxY2NkNy0wODQ5LTQ2MTUtODc4ZC0wNjkwMzY3NGU4MGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARv8c6TXp44TqfgAZHTOHNIg68jJb4U0cpDs1h2k+Q7Am6/\nnE+Xx0934bajH7420YuIKdAcCZyJ6Q81JLmdIAgNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT+TAUvVH7WAREKdWvKZ1mBbt\naRUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMfY7Wnu/HnuVoJAxfT5jYLnUUywh1ZKCLG8QfGzArtQCIQD0cDFwpz0k\nNRt7wXrxy3kxJGwCqqtYWhF3LMUo4cwxjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAbR+WIEUwj/Jj5EO03Ui5baDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFmM2NkZTYtMmI1ZC00YzcwLWI1ZmQtZDg5MTMzMTIxYTQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmZjlhM2M1YS01MGQ1\nLTQzOTEtOTJmYy01YzBiNGM2YmQyYmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASoAj/iLbphp24utBvwSpAmy+mAAIH3sjiO8v4/OforuInyOQ83KAE3MBBgcBKa\nKiL/w/r/4yC21giMddRwd03so2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmOdaPrTBnLXtr\nhia6uh8huVYCXjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCe\nFUe/9wbMxTetwhlzy8N2EdE1PbOr8oQzrXqguZFVEAIhAL2GZjFTc7YWpwQKqooN\nS8xsytG6Dk8fo0rAeqw5DMgw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7379", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7379` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVWfkRjroVV5f++fMZrxzNnwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MGVlYjEwLThmYTEtNGZlNi04MzUzLTRiNWYxZGRlZjc0MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY1ZDM5NDEtNTc2\nMi00MGJjLWFlNDMtNmVjYmZhOTBhY2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3d8R9aU1QVaVDq9Hs6+bC/MjZkQsPoErqOS8sgnXuH14adcC2+pDMA2dVPTr\njJgQ7R+txyd9yIyrVdG0gK2hAqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEDeO+HVjrF6yHSOmUtOgeE3f52AMB8GA1UdIwQY\nMBaAFFOODsYKgvQ3pf7Cgv0nSLslcMQxMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAgbYylI8eBhtCuuZ1cEf8RWuQxv/N2H/Uc\nCAj7F+/HiQIhAL1HhQsq9Apc/3K3t/t8HAq8Rq8jfTBe3T34ThnyZFca\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUH0RRIS9/SIBYOg+L0aUBR3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODBlZWIxMC04ZmExLTRmZTYtODM1My00YjVmMWRkZWY3NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrmZJFC6dAMwDQLw0A8zlVCxLqAMTJQzRQ5E5FRiSFHez6\nPg6mHzqbSKtsW95ydEgn7QDUQtl9l8X2z5Q1stjqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU44OxgqC9Del/sKC/SdIuyVw\nxDEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO6jAB9dFgbsWcHLlOkrM3Cd+pJ6lLY+7EokZiyNxpaLAiBoHadORs+a\nvZJY3WhMZf2UjDsX6FSkC1WUgRuhKutGzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISARdxCxhhYGODRgPiYkA/+m4XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY1ZDM5NDEtNTc2Mi00MGJjLWFlNDMtNmVjYmZhOTBhY2M5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YzU1NDlkYi1mZWZl\nLTQ3ZTUtYTIxMi05NGRjODNkMjUxMDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQMThXY5D9wn4FDXWl44FnKvzhANfKkjDog8uSBcb1LILQdNn/kjVenIOSyhyE0\n6NzRdeUAeNsB91nLepR1aRYlo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRA3jvh1Y6xesh0\njplLToHhN3+dgDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC0\nRkOVWKOOdxBObioUPuWaMPz6EWNKXhG5qpmdx6NrZAIhAOZL7070XuchxyyQ0ZuN\n8EC3toen0gOMIqZ/CRrdeWvC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7380", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7380` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQL6oXLkbcnqKHlv6ui/y+yOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmOGQ3Njg1LTIxMWUtNDRkYS1hYzU2LWFiYmI1ZmZhOGI3MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ2MTZhNWUtNGRh\nZi00YWU4LTk5NmUtM2QzNTY2NzEwMmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE58z9x2on2H9Lf7JooTBSkgLtz94zZk4WMyq5oAkPCBuedjl6N8y35h556TBY\nAFsiiS709+YJC8QwpbOQ6994P6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKagKKO1vN0dyq6WQ3MSwYJUbaSqMB8GA1UdIwQY\nMBaAFOZImT0inYCeGygR5xa7GreepISbMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA5fIZGfEnf5K6xTsVK/3RXPPJxSd5uvao\n49KyB6SDRCQCIB/c/+COLE6uFtegZdoNDlhulxV2M8t+9Z4peRoj6ZcQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfJ7cyEFwIuzi5parELLAzbFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjhkNzY4NS0yMTFlLTQ0ZGEtYWM1Ni1hYmJiNWZmYThiNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9pNVHsb//LNIEAQq4Y5raDiUvkXYd3R9kAr/ekbBHapBc\n8bqa/BkeDcKJ0BvN/RWKEXQboIll3OTytvWlQhqio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5kiZPSKdgJ4bKBHnFrsat56k\nhJswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJoi8dRsYaTHYZrV5SwFeBsNU98CLLnmQE2C76eH05yYAiEA5UM8uzS5\n+lNChfiQT+BSuyF+z4DnWBeuK+oYT/Oy/co=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQ1bLzy3sBx3DKqy4AXMdFHaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ2MTZhNWUtNGRhZi00YWU4LTk5NmUtM2QzNTY2NzEwMmM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYzlkYjAyZC1lMWI1\nLTQxMGEtYWY3Zi02Njg0ZDFlODAzNDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ0ZQe39lOmml23AQ/wXNGL+/DXH4C/Rc6oZR5FYDUOE4WtqiRDxgum8fTcfZGr\nkuUJIA+r77amoLJjC1XU5t24o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmoCijtbzdHcqu\nlkNzEsGCVG2kqjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCn\n5nVE+8CpBohDfTe9296ssVGC79D1gY6q1S2iWTNaHwIgDs2eK0GRpV7uIBU3KRBT\npRG5ZwKM6hVgQFOqYzDMWYo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7381", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7381` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYntqtJoOK8NB0RskXPTR0RXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4NGM0MjExLWJhMzktNGI1NC05OWIyLWQ1YzA4NTAzYjNjZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVlZjU2NDQtMjc0\nMy00ZWRhLWEwYzItMzYyMzU4Yzc2ZDQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmErLGtmn12Gy4LxQL2by1sRsUzwH6Sv51f+TWEfaQq/WB6BUdbMZ1XNEa6CX\nK9DQ5/zD1qeg2GS/dSIjIwOExaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSigG6chhUJ5xAApJbLQy/+uGwCwzAfBgNVHSME\nGDAWgBTvRFB4sKSeSNQqvKQ1Eq96E3ti+zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDoS/J0wuXSxfKC1CuqIR3yJAGIfuUr\nabYMwvFyhneNcAIgK/uTNpFPaVOSY888GgcA7hRrccw39GLwFjISm+rz79o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ4b+8fpSlMcj+4BIoKsOkG1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODRjNDIxMS1iYTM5LTRiNTQtOTliMi1kNWMwODUwM2IzY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnOVJHkgsr01VpkA+Wtx83V0zdnwP5fIqeJ6E1E8N+7ipT\nh26dKjUv/i4qx2RtaLdYxrbo/mMcviJPxQxsLnwyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU70RQeLCknkjUKrykNRKvehN7\nYvswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUvXhO6ISEnTbrZCgqN7xumOMG44SF8xhcBftCwUbfJ4CIQDVl3bwTGP7\nlAP5KBturat7+24TvtGbWVapcK4fVCev/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAeZN8Q1i5bYid4VVutgtgYoYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVlZjU2NDQtMjc0My00ZWRhLWEwYzItMzYyMzU4Yzc2ZDQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMmQ3MzU0NS04YWY3\nLTQ1OTctYjQxOS03Yjg0NTQ3NTRkYzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATBj/u7bAY0oq6boRdIBabWUiq3XvkXvPyugO+188opeL4Pb2EZRPkLrZ7/KprV\no3YNquqXmqtXbBfHKm6d6948o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSigG6chhUJ5xAA\npJbLQy/+uGwCwzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFGF\nhnhWekSYcx+x1NLOsqEKIlNPg2+KEbUfk+H4cUnOAiAfTLBEidyGx9FJ2nN5S7tq\nF0mAJv7LbK9OiPBRU3gs3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7382", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7382` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAa1S0DHeRv90lTk/1vBsz3xoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYmVjMDM2LWZhMzktNGZmMS1iYmUzLTFiMmMyYTc0ZjFjZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGZlNTdkZTctYjAz\nMi00ZDY1LWI4M2QtYzg4ZjU4NDU4OGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQYTcJR3OGkjFhXiTm5J+Zkx8pSczH/z3S7dxk1UTQve3gT95Nm6C29lCvmRO\nl28ez2r0/8pEVlgL0ZVted9YP6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlp1FQjsUbyMv7IKB7qWOuAQxA8cwHwYDVR0j\nBBgwFoAUtXt3crH3fzry5z8HBIdzUAYyHsAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiB2VEUr6i3SVnw+\nL40A/QNa7Ixl3r0Lw1BTsWVzpmpNOwIgMv4JXN+dgk2djGNvkZ1Z9YEp/NMFQIyM\nDnQGnsl29+I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd0Xch/nAWHFQ1xwbF8bGk7JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWJlYzAzNi1mYTM5LTRmZjEtYmJlMy0xYjJjMmE3NGYxY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+yVoMEqVGxDCdNNvo6vqSphsCCrpBb8Tgj7iD5kpttiQM\nu4UYcP9G7bK1WOFUZeBqm+PkrFHVKhHVrtLDxRUJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtXt3crH3fzry5z8HBIdzUAYy\nHsAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZHMQOJn1riMk1nAoNGNbYApB88uDpanrVgubMiFKDcoCIQCS4kf4E040\nAkcvsOG8cB/OilBw0l+0rvq9J3lcHrA2yg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAR1drejCuAo8c5tWugKVmYt8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGZlNTdkZTctYjAzMi00ZDY1LWI4M2QtYzg4ZjU4NDU4OGY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNTFjZDlhMS1iMmNj\nLTRjNGEtYTdjYy05MzI1YzMzYTFjYjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATsIsKaX0PqKTAyjztNpuzaFPW1LvMGKpl4XEvMo+PLk69lCj6LyrUJ1NyCEE3C\n0Yl/QMou05dPsK5gnih8/gM5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSWnUVCOxRvIy/s\ngoHupY64BDEDxzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDJ\n09pig3AE22Teo1I0LfCQY8BdKOs/kWNYixhztyULlAIgP+BeK0jVAZHG3yXJZLTR\npHJWRFM+t1p2WKhm3mNGHko=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7383", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7383` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAXMLujpP9IrR9aZCLp1hyEg4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5YmE1MTA2LTk3M2UtNDIxNC1hZTdjLTIwMzFjODEwZGI1OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM4MjMyNjYtNjEz\nZi00ODg0LTg1NzAtYjgzYjM0MzUwMzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcPtCGXhncdl87tUm6yO6bjrtOUAAJen8pjl+QBPe9IUkQMNOGjPRHB6XQ9uL\nt4UE8NfyoXE2z9j4/TjMf3omjKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvmvi3yp0wRFGCPteeBcA2YtxZQcwHwYDVR0j\nBBgwFoAUPe7ZL+AZhD01v8z+/vjEIFswOLUwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiARIBC7AmYdsjx7\n9QHZKwADJ0z/PvXVqX72c8dPMZwk6wIhAKuV2hBH0ErHGCzIn5FOnqTGGvFh6Bk3\nzb9cEhlre1Zn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARQEuuBSgG7qKoppQwKwdD3bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWJhNTEwNi05NzNlLTQyMTQtYWU3Yy0yMDMxYzgxMGRiNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPcdfZoALOKJa4rhYSglYePnqWZJLFQIzGDDvUldgb6k4+\n4z1Uq/IOFojNtQ/HGx6Rth/QBMtflBpJYHaamAfqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPe7ZL+AZhD01v8z+/vjEIFsw\nOLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgI/04cFUqc7Wtl66PxNeJ8tsQQJUnhBLPOS3GN0mVJigCIQDAwZnO8hPJ\n4sAaDxEcVEk0QfhFS+A/VHppZE+mLv158w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAcm4NkHyyiQ/NGYRaDV8TIyFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM4MjMyNjYtNjEzZi00ODg0LTg1NzAtYjgzYjM0MzUwMzczMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZTJlYWYyMS1hYzJm\nLTRiYjEtOWFjMC0xYTFiNjU2NjcxYmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASiLDYN+DWga7H7fAIhsOwLIM7EF/joqdOVZubDfrPcpxEowSbodz6WzpqdGRTc\nhWjjzkFvFiHby1XETfzklIuno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+a+LfKnTBEUYI\n+154FwDZi3FlBzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCy\nCENo+VttFUd5gPl+YV+R8jRwD8cbGsiGUNAExKLa1QIhALgac3oN9Hc8Fb0MlXgz\nQLkJ2UrZQSU4576Ln/H2KoWE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7384", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7384` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAf0OnvBwEYOGKxBFw1TeruqsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwYWJmMGMyLWY5NzQtNGE4OS1hMzhjLWFlZjVmYzEzMzEyMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM1MmI0MjgtY2Q5\nMS00YjZmLTgzMzYtMTk4YTIyOTBhMmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEidpYnXQUyU5z8qkZgHzGiQ+K4xWsPsu4zXJ3ljEMTiT78naOLjbjOwqk63CA\nenllQ5dE6Ymvh1FyjSecVT4t4qOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0/PGone6hgVHiv/OnZ7zFpx1BzEwHwYDVR0j\nBBgwFoAUiBvBIUDm4t5mm2YmBpNWUq3h7kMwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAmh73uiRI2MDg5dmAwUL8\njDyNRWDyL2jTlf5mUr0wWCYCICZLIhk9A1vAUksfmwPk9yE63GhjPmMYtaRGAQVk\nBMoI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfechuGoCZQPQESosoc9sc2oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGFiZjBjMi1mOTc0LTRhODktYTM4Yy1hZWY1ZmMxMzMxMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQL7cRM8O55dGLeNNuxzKCQagjPUvo12yHzihe/4qJQJvqj\nxdX9fECd934r0Cs6oCPB+otb6YUXFpVt5pDQoGULo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiBvBIUDm4t5mm2YmBpNWUq3h\n7kMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN234RoVIyysNJylezTAh1l3pE1C0WYw6BqGuYRiOJfQAiEArCSo/Ci7\nZ7R7D4xZYkx8VH7XSJk4526zkleGrfllWos=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAW0AAYNBfCLLP/bw/ar6BzigMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM1MmI0MjgtY2Q5MS00YjZmLTgzMzYtMTk4YTIyOTBhMmNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZjU0MGJmYi1kMDNh\nLTQ0ODgtYTE0Zi02Y2ZlNjI3YTcyMWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARd5wgnQTvyJCHde8xwjaxgT66VXvkMGXUjwiBD9+rDlkwKz3Cc9TrMiQjsLSQa\npcszzAXmBByG8JfCv5gRaSF/o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTT88aid7qGBUeK\n/86dnvMWnHUHMTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCc\nLFv6vxv2/yK8f5sY21JUlRQRrQZEkxPt/wupsINfswIhAIW0Q3g31H9Y08fiWhU3\nqrX0vwdxJj6lP/97DQDzn1AV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7385", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7385` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAceMNtJzXqEVpTqRtRZF6yv5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiOThhYjUxLWUxY2UtNGYwYS1hNmRlLTlhNGMxOWM5MzRkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQyM2M4NDctMTdk\nYi00YjY3LTk2YWEtMDVmY2ZiNzM0YTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKlIxdO6+RgUvQ1xAbd+1an/qqwtBZO9MLct7IihKb6LbP8lLM5vQJ0LakgYQ\nJvPxta3fGd43f7NdJbkXUKjDWqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVMWPII11LqNb2tZA2s9BG9YjSSswHwYDVR0j\nBBgwFoAU3jywKViGFJNljq5z6sUisYMc7FswLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAXNNgH\n6UW9jrdxbfrLkZB4BJUcdqXGeaFBO/AdSiHo6AIgWLc7Hlm49eebPQWK1seTEqD2\nwmUQTIMfUNkhvd8Nmik=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR5ZHQlxqDZH8GPL16u2GRhTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjk4YWI1MS1lMWNlLTRmMGEtYTZkZS05YTRjMTljOTM0ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQbQipWnTgJRCDkZDQ4+RUC1D1Ld/7/Oqrid9x4cSMDI0R\ndp3Au6Y2bLLutOFoKdqmNDVVNbpNv+oVui76lMhEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3jywKViGFJNljq5z6sUisYMc\n7FswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBLKpovGH+BrnqqzO2vY+Gw95P0QEE62DxrooASByPQkCIAy7nKJ+iW44\nZtvvyahxraPVy9AOnglD/MuB/FCTYpyq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbLJOupnfDzwXT/Aod0Z5O9MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQyM2M4NDctMTdkYi00YjY3LTk2YWEtMDVmY2ZiNzM0YTllMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlM2JhZDFkNi03MTMx\nLTRjYjItOTQ0Yy0yNzhiNjRiNDUwYTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARBp6CzOHciLaVLo3foK866/ZgP2OpB/HSXcYZiQaOqppswjiHkhBMDpCFcMIW+\nQApGcyvMFZZQAc7maGIphXA8o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUxY8gjXUuo1va\n1kDaz0Eb1iNJKzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGx2\nIGIDaWui36mt4qcGQ5BkA29BUXRx88iymwM3q8IIAiEA4S4ir4RTWX7KXzQIjMbs\niQBOaW+zlswqWC8lWcUZeOI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7386", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7386` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAUKzeqf9LR1adzE002nnLyzoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZDI4OGFkLWNlOWEtNDdkYy04MmRhLWYyYjk1NzFiNjM2NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTAxNmUzYWEtZjFl\nYi00ZjUwLTgwYmQtNGJmNWJhYjZjMDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJAQCTKOUQogA1SkfA2i6Aajb9+I0he5LWZ9dUndsiyji8ZfvUauuUUW9DGqJ\n0YtxyBUwvZDNbwHDnDezUXoXN6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUogzvBXhpusQCskI8gBqby8hqqhEwHwYDVR0j\nBBgwFoAUKKuqS+3MQjO70udtaPoSQzpypDswLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiB1nel5\nmDnFM4AOGTNDDh2zu4RY7Bc6kndlzWoD6tHPgwIgNA+AXLOsVDU7oD478yMnrvmy\ndHBLinb3TCdAW7VvJts=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVjJq7sgl5HpjPBTtRP37w7QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmQyODhhZC1jZTlhLTQ3ZGMtODJkYS1mMmI5NTcxYjYzNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASr6vikRIf7CzAIklcq1WBakAE3uM/F+BBPlGSi4cKlZnri\nWn1sZizTBlSDQXpDYnsJqC0g3JIIa2gDqxD+OXa+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKKuqS+3MQjO70udtaPoSQzpy\npDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANJaIK5VKv7TX7hhaA5+Uc0ffREGz87gtzcwJVa/Aq5mAiEAyxuoZ+l/\nm+fVOOlhmjmi8gBgYlmZ+O88GWOOZrldBac=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbtTK27VllIq/G/iVfdmL2Q7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTAxNmUzYWEtZjFlYi00ZjUwLTgwYmQtNGJmNWJhYjZjMDBhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZTdiMzZjNS03MmNm\nLTRmYjUtYmU0MC1mZDRiMWQ5M2ZiZTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASuRORgf2nZLVrSz5NP5NBGOY941qMFDK/pPs3OYRMkbFMZTB9ZczszheaBlN7S\nBfJKuZx9jJ5iivNoWOyh4BvKo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiDO8FeGm6xAKy\nQjyAGpvLyGqqETAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD7\n0R1CgO21iKJ7zkQmHh92dNPMBKg0GqF1tUiSGyKadAIgX28Yx/0QzdBJDzSzXGYg\nJWyvCdnxVTUIfjU+YVBJdRw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7387", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7387` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAU7POuW/zNYMbhV8OESL2uLqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNjgyN2EzLWFmNjAtNDhmMy1hNjQzLTUyMjNlOTM5YmU4ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGUzNGNjZDMtYzJl\nOC00YzAyLWE2Y2UtMjJkMWQ5OGUzN2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEokUnUF/PnUdyv9Cr4s2r7uc2i/CMrNgqjz6FdoIgc/QArRBSv+t5hrwp8SSf\nBdbHUIY50AM9O52uTkawHgQ/kqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJdVDfjpL9eRxWtIL115Uk7knLv0MB8GA1UdIwQY\nMBaAFIcb3OX8Ws+Vb43XdFN+xv8yiHJAMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvVfrviY8gGwuXLaB0K3ydz1mpIVehiRz\n/e2iuhbs4w0CIQDKrvphxp8Uc/G/hXgJZQWun32+J0SbWboFN7eP20pmWQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVi5xMCFvSi8xf38SDFTdrW7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTY4MjdhMy1hZjYwLTQ4ZjMtYTY0My01MjIzZTkzOWJlODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATl9CrpSY8uqSaaMe1KHYZVDX32OmdLnBZSJZnlQC6Pqczi\n4nctqBo8DKlUn55+FHlz6RErU2COh558o4/HNNbko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhxvc5fxaz5Vvjdd0U37G/zKI\nckAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMD9ikxJHnTOw3wygWsitwr0/I0nj2r86KDl7hGAqZZiAiEAzcZZ+gVZ\nk0+su4fGDkk/6RhMaN44yUbSt2bFPFDiHIQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAb437CQqPKX+38CYcmgza72/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGUzNGNjZDMtYzJlOC00YzAyLWE2Y2UtMjJkMWQ5OGUzN2NhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YTViZGM5NS1kYzUw\nLTRlOGYtOTY2NS1hNDMyMWVjMTk4NDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQMGQnic69XbAEvdcoXJpGTOHAi/JJ71pQQ/hfI8X1Zjcb1967U9X2RB55lecuk\nuEYbwBE6YeejJcItvPc+WRH2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSXVQ346S/XkcVr\nSC9deVJO5Jy79DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIEI9\ndjy7K+5s5D5K35mTl0PyYwlxIJgBm0X9UYKeSbJKAiAy4CJe6u5xgxQi1XxmHxo0\nMCbuRWqZnyo7t5BkJuf8mA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7388", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7388` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAdcdyoGUmnkvltDrIAMXSmOfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MzhjODI3LThjNWItNDdkNC05NTIxLTZkNGY5YWU5NzE5YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThmMjFjNzUtYzcw\nZi00NDkyLTlmNjYtNGM2ZTNiZTRkODRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjlDTV3ALINFrNJeT1U0LMPDSGy7deUtlfvO5IfPfMdX/pVbBiQSWmtHG1NIt\nKjVNQ+JC5ggdw1P1SfBDo3oWCKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ueb3s74kfqIEb/ag9bYzExAXK0wHwYDVR0j\nBBgwFoAUxtj8jiDkYmYN5wztVOVAxthaigIwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgUZhuXUB2GIV0\nx5lOMj1ZNuC/+fS9/1Fsb7fT0O/Nn0sCIQCh5VqK6k0qJVI8FHstsJ38mHPtZhwu\nhqiDUHWBGXXqjA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARfkCu0aufSLG9boAMo7GgiGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTM4YzgyNy04YzViLTQ3ZDQtOTUyMS02ZDRmOWFlOTcxOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNW2eaxyB5E5AN4+llvpO5/YDvcfTLhLGJrQtuMGl6fEoS\nzfjwW1UqFHKcVqG74M9ZhkiQuXVt/8apfUDM19VDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxtj8jiDkYmYN5wztVOVAxtha\nigIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIbHNSzBK32chVwzqslggkFM0XEFkpqxfKVz4lvC4205AiEA/+mIVKOW\nf6XO/C3CjBCA9d0PvtoizuCqpLTsthQfnJ0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISATWe/MTV2uz0PusfU7ajvQJnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThmMjFjNzUtYzcwZi00NDkyLTlmNjYtNGM2ZTNiZTRkODRjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZjA3MTNmMC1iZmU3\nLTRmMTAtYWIyMy1jZTkzZDg0YTk5ZjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARfthBuiOcC7fGW/SJGmmO8vSHM/8zKZvdaGd0JYVED4p7d94nFMNfX9EeDtAm5\n+5Al7bsRPnjxjN06oaYVjixpo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTq55vezviR+ogR\nv9qD1tjMTEBcrTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIF26\nCMoYDJD4EYY3NNB4nQJtVBTssn906ciMDS5ZxVN1AiEA+BqrrD9aM04+1SUAxLd6\npkIcb3nRysks5nkjNB+7QNQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7389", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7389` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAalvkTc2yxy4oAKwBOIc6uWoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmYmQ2MzAzLTM2NWEtNGY2Mi05NjY4LTE2N2ZmMDE0NGE5NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNkNjgzMjQtY2Nj\nYS00ODZjLThmZjctMTYxODYwZTRiZDJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY4fz447UudMfRYCxVIEs8meW/N5ajVaP5i9i1yFdie/q7MNOWCWSlUdRa/+l\n9ezav/oHLRf5RqFi93lLY9usT6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7tOxz8lYrciDgtYk2oVZ40uiYJ4wHwYDVR0j\nBBgwFoAUzVZtDSXecY8ujIC12T8nCr8x9NYwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANOHgZxJoU09\nJrdAH5R5EBmuUY0XS1/jTR8ug1mmM0FFAiAOuGaA/qU5xdDe4gRZgNzTYOlFiVZd\nTYejeibdrHRIbA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdeaznn3Cii7x84zL3ecDFNXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmJkNjMwMy0zNjVhLTRmNjItOTY2OC0xNjdmZjAxNDRhOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPNSY1PX8njwierUaowil9Q2RKrPYAemXtgvIG7b3CeC7b\n9mDmk5b0GXdJ+ci8Ok1cS0PGIheuVdp4KJ70B4npo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzVZtDSXecY8ujIC12T8nCr8x\n9NYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfexvspmUNw3oK44LXtmaL7SM/0BylSYUWhauUL1vfRICIAX0rlisT4bm\n/L9coKsg4ZpfJhCzpeE6Ssgzik3Tg8N/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAf3UNNivB6cilQDkOf2eNt/nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNkNjgzMjQtY2NjYS00ODZjLThmZjctMTYxODYwZTRiZDJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYmY4ZDc1Zi02MzA3\nLTQ3NzMtOWRjNS1kY2FjNzcwOTkzMDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASKaA58qrX6YbxrbloiM/M9eHQSGPlGkIywFe6Xv96lXFCeIp31kK861WhnTrlq\nWFRJ6L5aaBeMipicunDve/Lbo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTu07HPyVityIOC\n1iTahVnjS6JgnjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHhc\nrlv2yVZNHPARfZtz6oAz9v02XaHrXNb1VC1nEUNgAiEA+X6h/iPPHvaEZ4zF+JPd\nsfcu4+IibLZmVYZG1HO1T/4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7390", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7390` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAdPS/UmSBZwM2+J5m2gbDg0GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYzY3OWY2LTZjYTEtNGI2NC04YjNmLTliMTEzYTJhMzRiNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODM1NWJmYzYtNjMx\nMi00NWE1LWJlM2YtMWQwMTFkZTcyY2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE46Q2e4NzZHhjHJ7Zd5kcZeH6e9x0ZVxchke6xLC3FWNYo5PDHn8EY2/HoLpv\n2qVySY0iG11Ww+KmDXTIon9rJ6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUulvRjQCcyN8VbxldFvH43VSnJTUwHwYDVR0j\nBBgwFoAU07YeuHcN+CMRQeczeUk+EX3rogswKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEoUH8jkp6AU\nTJqDc28cFGq/qcVKv+JNQEcDR4RxKsNMAiA24ZacdXMCvAIYlsRthI0xogA7ldu5\npSFfkFgMdrqpKA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY+HtuJ/0Kb6aE8N5vhXILz6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2M2NzlmNi02Y2ExLTRiNjQtOGIzZi05YjExM2EyYTM0YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4vMFrmCeeggVK8KX2UQ2GXh1W9b6uCku0yKWzwIj6FwKz\nSJPS0R0z7b0u+nIpBMTOEvX5hn/HsxwPULRJB9UCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU07YeuHcN+CMRQeczeUk+EX3r\nogswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM9Ua44L9KFFVDlFuj2hKUYFrW7ZGsk2fjG/qHeFYBzgAiEA/af7MYvy\nqqvyQ+l6p6SEZbP7aRyJqFi0YyiE/yLppgM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAVH4uGFxX6nvc+E7VC11b37rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODM1NWJmYzYtNjMxMi00NWE1LWJlM2YtMWQwMTFkZTcyY2Q2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2Nzg5MzY2MS01YWZk\nLTQ2NzktOThmZS0yZmU1MTU4YmQxNmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATrEYAVdlfVQzYBxlzM5Q7aiHW+pQHhaMwEENVwVQgaoXtf54dcDv2XvjWE9czw\nrHqyUXj6RmxWgy3u3/C+moloo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS6W9GNAJzI3xVv\nGV0W8fjdVKclNTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIF/s\nRWu8wfUjZmCveZcgN/ZmIYTO3J7YvMoRlRysezN+AiAHGiEHAuUHGO4rDJF33aRS\nEe9kDLISlaz1CJXO00z3Mw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7391", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7391` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISASB7lO6GG3WfCf31udJNk736MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjYTNlMTRmLTU2ZmEtNGY5Yy05MDBmLTE1NGFlYjgwYTVhMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU0YTYxODMtYmM2\nMy00ZjE3LTg0ZDQtMGIzZGUyM2ZhNzExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+c9HLJBttzmlo1jFGdZCEh8IitTyDhBVAUN64o+QQjanJb7kxXkvI8yyL1xs\niZlFFPd/sFj6IvTBcoqsK0DZvKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUucj9oCmuUHESdeUf+ozNVmNxgNswHwYDVR0j\nBBgwFoAUJzENpHzjSIbtfTxc85XBUnnNl9QwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDZlK04mH0afNqgY7XtnK31tV/PwvoPN5EL9Qr2C0/5pwIhAJ/qrrVXDX1q\n17ppBWT/Bky9uuV9qVlfcyoeZ25/lsjO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbfWdzyRZFsbA1P3mwamSgIUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2EzZTE0Zi01NmZhLTRmOWMtOTAwZi0xNTRhZWI4MGE1YTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8LNAWpwsn21TIXLHWGwYnNa0R4Tc7fxGcijeMYTb6VdBC\n3BHMzZtQeWzahNe4TCLYCNVHWqkGLPSV1YTY8F5Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJzENpHzjSIbtfTxc85XBUnnN\nl9QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY5+5kWaqgL1YJ/vaDK/KzgCBTlAFPZY5fgqEDM29rhgCIQDfNZMdBXeh\nNuDPr1+AGDjrMnzkW3fQ7dVLtdWP+ueapA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISATGFUx9aZQ/fagFp1mwGl/9pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU0YTYxODMtYmM2My00ZjE3LTg0ZDQtMGIzZGUyM2ZhNzExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0NjYyMzI3ZC05NzM2\nLTQyOGItOGNiNy01YjY3YTdmOWQ4NzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASdg3BKSiOBwk0rvvfmgCI2drWmjTvxfqem1qyracv8G3RwRp7KjHo37kOcf3Jl\nT00/H2rWDTI6pG7jJ/1Xgx7zo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5yP2gKa5QcRJ1\n5R/6jM1WY3GA2zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIEJA\nWfxHmNOFUcMonbqGvvfB5bqs6ImoiheLjP1mDRWiAiEAyQF0u9xNaBJHvqzVFA9g\nvr1Hr9wCG7aNMrF1jJQrgOA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7392", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7392` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAb8D+mfG6+bimFM+SI20tU1uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMTFiYjE1LWQyYzMtNDU2Ny1iNDVmLTgyNTUxN2Y4ZjYyYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRjMTdmMzItODg1\nOC00ZDkyLTgwM2UtZGVmNTViYmZhNTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENuFbVpDrfMUc0aTbJMe5VNRxdft8/lWmRZ4WFtD0nCH/UjlhXRdwWtOXx+Y5\nRCEvrXuHW6/LBxzhDK5QZE+/66OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUal6nfi2rfLoiju27MGJ9wmKQAlcwHwYDVR0j\nBBgwFoAUb0vPSCl5/IKF6QZk7E2U+TXdckcwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDj/zOZjZE+6ZKzwKwx98j6BCvdpJbT3Y6IpZzU94th9AIhAIcWhqEK0/ye\n9F9zbzLO3ZRI4or4XvQZJkRYtKh8UIeu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARmJ4IrYzREpti2+iFOuMKnPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzExYmIxNS1kMmMzLTQ1NjctYjQ1Zi04MjU1MTdmOGY2MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUOvMrLEZcQ7SVn0qHi+g2BXyEYdaXn6d1LXDTYQeZj2s2\nd7ZelP6qwTbE4cRh1dNmPk7CTQMY0mLUp/IkBHrso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb0vPSCl5/IKF6QZk7E2U+TXd\nckcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOPcPgyQcUT2BBwxYy9n0cLbINOhftycIFbP3iwQxXLlAiAUTpKWxLwI\nUDMBAS6/1XmzcPB8WJ7nKTRmyTsdqx+30Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAcUvl55J+qvmlo8tKvZRMUamMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRjMTdmMzItODg1OC00ZDkyLTgwM2UtZGVmNTViYmZhNTMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMmFkNjVlNS0xMzI5\nLTQ2YTAtOWI0ZC03MWI5NGZlN2I0OTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQvDKwLq5yzD69hkpSQsvXbpRYsMC/EpeuVWbfcEmMjrxBzbutcZNfnb9q8HgDs\nZ4oDvISPu8jBgGbo6ZMRLZ4No2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqXqd+Lat8uiKO\n7bswYn3CYpACVzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCo\nI/jHaTk+pShS7SYqAd+tsldB+8Ou1Ya9t4GgEz2x6wIhAJlMfP9L5RS4jNcGs+tS\ndCl/hS6WyR6mGec8IknaBqzg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7393", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7393` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAfl4h0vcz92i9L3REpdsSlZRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzNWY2MmY1LWFkNWItNGVmNi04NjhhLWYxODM1MDYyNThkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY5NDY1NjUtYzU4\nYS00YzMxLWFlOWItZjY4MDY3ZTYxZjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETHkSXcThQpeFZZ6eBeZptSW290nRH+8rxyE33U+37H5FX51Lj8l1T7s6Zg2l\n/+Of/tsp6dTj2YYrkhyZ7stSYaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Iuj5VKUKP5Fcw6RsMNlmQMrBVAwHwYDVR0j\nBBgwFoAUEFhAX0zTR86H0rJ/5HT8edYI7zIwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGYz\nJ5GP0Kb/x+woEamQj6LvhLeq0ty+znda9isDRL++AiBnpuY9S0m1HG3TFwudEzP2\nZZmaQlc/zO08zjwrdHqUgw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV8L52lYxm7Vgg/mQzX9KhpFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzVmNjJmNS1hZDViLTRlZjYtODY4YS1mMTgzNTA2MjU4ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxBhQuVHNnXY5YxzZGXXUEEhlD5fnSrkHBgzwEEMJo6bKg\nJkA+KXF0/2ak5+o+Dj3LYGdAh8Z+/4n/BJ6esQkyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEFhAX0zTR86H0rJ/5HT8edYI\n7zIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgf8ugTBW8a9GB57onXjdEeBzx+ihGuI5f1bSkTLvdpOQCIQDW5P+LgYrD\nEYveE2EP5TS8ZsLK//IyX5f9mrlNLS3ZIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAatDyiU0keOKsg6a2mektm8YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY5NDY1NjUtYzU4YS00YzMxLWFlOWItZjY4MDY3ZTYxZjIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZTk2NjcyMS0yNzdh\nLTQ3YjItYjBjNC0zMzQ1N2ZhYzhiZDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATgULisWxD5v+VWZZMK3e0D14EE/0KU6s8Fse0uFYCWaZVIZszk2vf44eMckXqZ\nKWAPZohOdczqPOjxMMYamdL2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTki6PlUpQo/kVz\nDpGww2WZAysFUDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDz\ne2sepX45pU5X+doWXcDw13APgk1JF4yHyVI0meN2FwIhAN16bdYKW5RbnPA0Wlw1\nvaeg7Db5n9blLhUyAf98BrgI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7394", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7394` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISARCljmYPnrw/+Ge3nFlsAHx3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0NDQ1ZjQ1LWMzYjgtNDhjNi04ZDY4LWJjN2Y1ODUxOTVkNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IzM2QyNDktMDk4\nOS00MzllLWIwZWMtYjQ3ZTU2YjM3MGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDS6N4fB0wre/WxWxzG1d78iI+KTVDeoi7tfoc+XrgDNJRfPmZMIQyUbUvplE\nbYhH/VNFq5wSdneR29gsSBdUbqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeibNk8QmmQfM8yORluoUf+pWBLIwHwYDVR0j\nBBgwFoAUWrvoJLa63DsG1cdbCyYyJgo0lk0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCJEkCRa6z7lxbwVWRFv2ZirD/w6hHIWNj820lgnWMzCQIgDM8R\nyc6j5vNJxTr71740PEFxUpxHQnGFSIJC5YMRNjA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARYiIdWyq0YJtL83dIvJ3EY5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDQ0NWY0NS1jM2I4LTQ4YzYtOGQ2OC1iYzdmNTg1MTk1ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAART0x0ZXRN89nIGNoLylxjiXuaQGbCAiQNt4md5d7ioqFM8\nzmH0NiiZdzMEd2RjtjZnSYbJfTJKOA2+Vgud6HNJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWrvoJLa63DsG1cdbCyYyJgo0\nlk0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOhH6YXQHvvjikxQriSIvOlLMlEcEaPh6szLJSZFSqDxAiApiACAKwif\nkeGZdy/xvu18kQmTQiVoam0Gky4HhBIRYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAehuDW+hH1/0csuFh24ntOjoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IzM2QyNDktMDk4OS00MzllLWIwZWMtYjQ3ZTU2YjM3MGYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NTYyOThkMS1jNDAy\nLTQxYjEtOTIxZS05ZTRkZjdhNWE0MzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATril8cbafdYirX3DhSzfw/h6mlz90aikH7SPjxZ28+0posS+PO/UDwiELfbnCF\niiq4OHm3KEt5iw84MF9h2apso2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6Js2TxCaZB8zz\nI5GW6hR/6lYEsjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIAHK\nsIy/EuS/5GsPpGGxjUC6Ml5K6Zdwb11AY3+zMyLWAiEAvzuwNG2wLw6pGjJEwMVQ\nlhvtV4YNGnfrZfSk0KTiM2A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7395", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7395` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZm4EA+rByw/javrOVpvderHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiOWNiMDc2LTAxYzktNGMzZS1iMWRhLTNkYzRhZGNjY2ZhMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGZhNTEzZmQtNTdk\nNy00ZTk4LWFjNDgtZjdiNjJiNTc4YTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm+t1saIEjz8Js9QdLXQaFH0ZYhR2HE9vnKYrQtigbqEAtl1TCb8m3+CDdOPn\nzaM3CulopcHf/KQXu1tWLM4zOqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzYCO3/fe8YPWrB9UhdBYq1HvVDgwHwYDVR0j\nBBgwFoAUlTtQdftRd32WubQR1iwEwduxd6YwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCTq9OZms0R99Puvx6lkqapOi5+6KrodDnDeSA9kvTcPgIgRsvA\nzcgqKQVmOKXjq1EQJ0EnkZNPvDJdEIKOattgfuE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAantjhtWslbpGnt5ec+Q53/cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjljYjA3Ni0wMWM5LTRjM2UtYjFkYS0zZGM0YWRjY2NmYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDgK4kd58Sl85Gq6h9xgkd3ZJOMm2EOf+oI73XAgy35rb0\nesZPEEVAyqXGyvaUA6eWoo/0AwLMhRgDdrjzkwFHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlTtQdftRd32WubQR1iwEwdux\nd6YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMFRDVr2uL2op/bRhLkhMFiqIo4bHLFdd++EWqrQGwvACIHIOttpSfe27\n+K8U67uPqqRp+Cgzm5sAt+qRvnx759IQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAdkRpPj5dqm+xm270prjRXnXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGZhNTEzZmQtNTdkNy00ZTk4LWFjNDgtZjdiNjJiNTc4YTQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMzlkNzQ0NS03MWI2\nLTQ4N2EtOGM3OC0yZjc5YTMyYzdkYTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAStJBBXBElvvdyoRrGSv1mBX6N8FpM0ECuimcix9dO5FNUMMnCwImwP+TT8gAl0\naWGID7J0KB4hnsL5fDyeEh+No2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTNgI7f997xg9as\nH1SF0FirUe9UODAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDS\n6Bnidu4/azz1OoTHY7jzSPo6kmG4TE8Pob2W3hADWwIhAPscLisy4kvXMlFIb+lg\nliEa6yJSK5bTJhy7Ptt16G8x\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7396", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7396` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfDzCJrcMCdCM9jN9q//dCE7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzNDNhZjhmLTM1YWEtNGNhYy1hMGUxLTFmZGI5ODc1ODMyNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU4OGJkZTMtMzBl\nZS00MWMwLWExMTgtNzk2Mjk3YTlmMmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErTVtK36FMsBQ47G8fIFmKm8RM5o3c6L1FNFZJlIK26iCf/NtfgpF5UM2lmcr\nAaaFAbCv3W5/g4HtMedahhL7q6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDmAWeg+yIBZ7IvnqYlUiDViaPaSMB8GA1UdIwQY\nMBaAFP0CveuX0K0qbPN3CVBMQnfh5cNQMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAlDC2QupkbyFCrQfhE17S566bveHPpgnBb\nXhDkVmFnoAIhAMIBX0jjg3TesBzlgrmMVjE3tq8xqektyK+LVYSaDuXh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASTYDoz6bnbSbJQVsQEUkOCNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzQzYWY4Zi0zNWFhLTRjYWMtYTBlMS0xZmRiOTg3NTgzMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUIS1eIuc3yp5ZrQ7vFKcHuwUYNLe4/eCaPikpF3CrvtT1\nTe+fIxv4qI/lZk09tlMHaSgY3sc7079OOQBKPQ9Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/QK965fQrSps83cJUExCd+Hl\nw1AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEojfUxbJuW3luMf2e0ZxBlPMoGdaKtU/KqySrO/OaDICIDgXgJp0KjaX\nlba/kqshsHi1/QMOatuLsPeL63Rpx3OG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYYO/mWCi3axZ3DitszDff32MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU4OGJkZTMtMzBlZS00MWMwLWExMTgtNzk2Mjk3YTlmMmE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0N2YyZGJiZS00MjAz\nLTQzMTQtOTA3YS1mNTU0ZGUxYTJlYTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ5O1rbg0SDA8skVV2X9usLGtxQmQcKQxpBbLTEXUzTuGBpHmE3RqBzW0O2CENh\nfYaQdTiTPyi+vDkg9U+u+a/wo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5gFnoPsiAWeyL\n56mJVIg1Ymj2kjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDt\n7dPYIKkkozhozAGsBZMWog/2SGwBtZEQ8g1bh6GuywIgKH3r/eIqbp/l57mVrDdS\nL6kfHUIAIKjkhFwuDCgeys0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7397", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7397` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASCOJSS10+OZUYj++j/wpFk7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwYmE5OTM3LWUwYzgtNDQ4Zi05MDY3LTdiOTc3MGU3ZGI3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTAzYTQ5MDItMjll\nZS00ZmExLTgxZmYtMTMwZjc4YjdjZTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjws3mB7VhlSbSobR+KWd5f8t3CQmuOXddbaw0fhbbEdmvahLPWoDUbZKG8kp\ngi5DlazkQLRTKyJXi5ELk4qUPqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnKrxm4NkYr8L2ccpRIh6e4k93jswHwYDVR0j\nBBgwFoAUu0KxlBsfq6D3cn81nFrUstbFcfkwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPRVhDWSId+u\nfqrqBgrGNSXP947O0pc9wozjQbfy8xTXAiBH1tEqoJColGrDChq1a+2yoeIWmzk7\ngz8pvUaH/+nwRg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS6COMAhLIYHJyAiNmWzkjEJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGJhOTkzNy1lMGM4LTQ0OGYtOTA2Ny03Yjk3NzBlN2RiNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/2SVWQBQsWROjgH5VAwes+Wr9xUreLHklopqpWxcP0plq\nFiJHEcUx6c1DFbC/kKGQdpfmbkscp6TwF3MChotho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu0KxlBsfq6D3cn81nFrUstbF\ncfkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCAyRoy6I5wCK1HLFhKxpc00DOM/IIS5TrNY/HiBtJA0CID7icZfHD2HY\n5jfu/1IWVHlTRrkwlMsnikPRsLlzgJSX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAWmeFCnDyqlaEuH0BaUcciXIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTAzYTQ5MDItMjllZS00ZmExLTgxZmYtMTMwZjc4YjdjZTA0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZjU2YWM5YS1iYmFh\nLTQ5NTEtOGVlOS03ZDdhMTQ5YTA3MjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASxVjPLsqErThqf1Z8Pmh8HR9okBgDZ2/mA/zuHavLyq6xacrbeDRgTLKeNa8iv\nAgzwkDOcAhJ9BW2JfHd0qb7io2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBScqvGbg2RivwvZ\nxylEiHp7iT3eOzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIBAB\nWyIO+3is58HflQQdKUBKU3IOQdf8bfl0InH8Yoa3AiBPUfRD75x+NwB/8xF6SmF3\nc2gPlzMek3kg7ZZ2O5ak0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7398", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7398` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAXTcMRXA8z9FCv1hdFpK4Lk5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMTlmM2IwLThlYmYtNDM5Zi1iZDNkLWZhMzY1YThlNzcxZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmExYzA5NGMtNTBj\nYy00NDhjLTg2MjUtYTkwMzQ0NTI2OTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUoviZjYV3GCsFn1SIgw4N+KpmfRt5U34AiBY1Fj7y373rnCxFuuh5lV5tukP\n2im4582rLncK24dL7VmD1qfikKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcAcQ7GcA95bMhWnRkgqXnCx9HY4wHwYDVR0j\nBBgwFoAU/MwdaTSdrznEO+bcgBepvWs7e2AwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOzF15+uQrqj\nJN3UcZYIWi7hn2wRsmbdfARUS9bFr61kAiBLt4mXIY2fSmr/vUMLGr3kBCDF9532\nb1tyd+AFnewEmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfVviiUr1r9LHHJjMPrX9t1wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDE5ZjNiMC04ZWJmLTQzOWYtYmQzZC1mYTM2NWE4ZTc3MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGidyELAf4/heu/mwnajSIijAg4+0nsmQbcS4CTdJDHlZB\ny6U0aUDQY94rrAvNkJnwfWPbPVPGtwtA/BDIrzTvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/MwdaTSdrznEO+bcgBepvWs7\ne2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMM5xe9JCtrkucN5wPxMPURyHhGgEoGmPrgqGW2kPZ5jAiEAxcPe9WAT\n/MAsitCw6mxjOqKHY4e66F8XiveHxQXUjwQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAT8ywW/5iQoPk7GGbUt6iuprMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmExYzA5NGMtNTBjYy00NDhjLTg2MjUtYTkwMzQ0NTI2OTFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MjkwYTE1Yi0wZWJm\nLTQ1ZjMtYTkzMS1hYmUxOGQwZjFlOWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ//XVRxEpQ9LpXO8Rry973/qF3PCCddjInjFAdQkQruqopukmnw8iL4Dzfw0nT\nqVX9f8kjroSS9iPtMiCMx4POo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwBxDsZwD3lsyF\nadGSCpecLH0djjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDc\nVP/41rrEX5SdyaRUOK7UUG8/I4L1Z0KWG25Qy/SbDAIhAMbl0//8EzXNArIDYf2c\ny4qm+7FKf9NkTZ289LaxL5jy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7399", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7399` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAXfzxR8PdRMLwPUeznOXhWzaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4YTQ5MTZiLWFiY2EtNGQzMy1hYTkwLTcxZjRiYjRkNGI3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg1MjNmYjMtNjJj\nNC00YjRkLTljODItOGRlNzkwNWRmMTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEapQyeflsC4LKrf9uJ4UF5sTm9xBZ3RQwZxzPspCtjoBCSb5b9J/N0FkcjRLK\n8V2OqXTySWTm4ywlLwKz0U5r4KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+JvFN9nX2RBmpsCPL+zf/nIvDbowHwYDVR0j\nBBgwFoAUTZTwTgmY0FsNIGjJN/856O5g8kswKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDTlSDk0TqH\n8oWtfM4DykSXrjNTfXiRw2vXpoc6AeIQ4gIhAMw1MQqJafR61mCFYtww+Ne/LtMb\neZIYysNNX0rdJSmx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT+ATGnxmN1GqcygOIKJ4ox7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGE0OTE2Yi1hYmNhLTRkMzMtYWE5MC03MWY0YmI0ZDRiNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkwSQg7HMevWbK0G5C6jpIa1EEc3xhGMzFsKmpaK3iO0uM\nwFl2/gqCvFLivdq3ZO71uWqlRB/1E1c34L9O5D5Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTZTwTgmY0FsNIGjJN/856O5g\n8kswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUF6WHjjgtcHgbqedDY7oymsAoJSPq8hiNqkwu+wJqogCIC2Yzv58Vn4F\nwoQphufqnOREGVNVhmHfaY4y+2tlFXpq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAdCdvGPC22RzKwBnVqEvhzk6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg1MjNmYjMtNjJjNC00YjRkLTljODItOGRlNzkwNWRmMTQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4MzVlMjQwZi02ZTg2\nLTQ5NTEtOTJlNy00MzBjNmE2OTViZWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASafKEUuZRk+IZoJH7xt4CjVKgCSKBvLq6dwFQZKUh1eIgktRynQzB95I2uXhgO\nYxYmgc6iuvhUyXvVJNFW8sNCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4m8U32dfZEGam\nwI8v7N/+ci8NujAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIAUa\nGZ3d7V1gSy3H43cPH+mrz67sq6MpybPoBZE0KLzRAiB9ez9IKn6fNkSEDWIjzvBg\nVjuFX9ItLouDtb72uXy66A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7400", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7400` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAecWUS9gtZgBLNXcRu9xrw1CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllMDlhMmE4LTc4NDAtNGNkOS04NjdlLTRjOThlNTA0N2YzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA1NjRhOGUtYWNj\nNy00ZjU5LTk1YWMtNDZmMGJmOTUwNzBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnJWGwhlJRj1RTHKZkYqm+gFEvIDilAZzTs3FE2plMb3qCMjWnAFNjef3Opuh\nPj2grwqgzkOJvcdNF+9tCXdxbaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHzHWIBr+HDRJRLZQoFzjRI0La+IwHwYDVR0j\nBBgwFoAUvbtxzY16UjkDunInafcWTnGUpsQwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGHjUsM8rqgRacmXVDMtXHYHuYIo+fb+SEjGB5GpNP6DAiASEPvZOgojphZx\nKVZQOJHUvhIY65IZlXXqipzZpxGr9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfRe2B5xGwtXGLPGh8q49wyTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTA5YTJhOC03ODQwLTRjZDktODY3ZS00Yzk4ZTUwNDdmM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6pwVId2u51JjYdTk+52SuLDUkL2hnoNcO3b54Ks9sWfhz\nVj8QsFlkToasXT8ioJqo49LEaZZYiOxzw+1EGSxJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvbtxzY16UjkDunInafcWTnGU\npsQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANxXudlqZGaHwsfAMMORJd2YFsKB3yr10fAGqhvqPj+CAiACrIQKRZxq\nNAINzPLY4DYYmYQzO3d0XjoiVm0GVxMSUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAaFnn14Y7YghYNMUCnNluin9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA1NjRhOGUtYWNjNy00ZjU5LTk1YWMtNDZmMGJmOTUwNzBhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZGJjYzM2OS00N2U0\nLTQ4Y2UtYjBjNC0wZDQ4N2ExNDdmN2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATzFed47MQt0EF9xE21VHw5Bym+cbK4YFQDHzH9Za0SES3incfxEVizaGI085A+\nbCq0U56y6d2+zHkLH+wUTfXSo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQfMdYgGv4cNElE\ntlCgXONEjQtr4jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIGk6\nXjd83hUTDnFk9BGdXAJf3EqDZ7QptgftIxKCQOJgAiEAk4TJFnjKq/v3iZt5X1Sh\ndED8jqpMuVhhkKpvvhEpJoA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7401", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7401` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAeCbzeFP2DFYmBkI44sNmpVyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1NzkxMDQ2LTJiM2QtNGZmMS05Nzk0LTVjNDJlNDRjYmFjNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkzZjNjZjgtOGYz\nMC00ZmU2LWI3NTAtNTZlOGVkNWExNmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo2oA0QaFvrjmfwjEf5WAGrq1M0LcKwTeNQTs2SiWj97FWVVpecbKK3ksYBk3\n7Yai5FcoqIm8qZL9TlscOOKsX6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrhd2pgXDrtfaxOpO9aDkC09RwGUwHwYDVR0j\nBBgwFoAUCVyrbeG2RSjhR5ceInn4LR7k340wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCU90sY0W/DSAk2O95X5GUBjClsSayizprN1XDJYr4ucAIhAOSEWo0EjuH2\neae+z4kMG8N6tzBArGMZS/CsYpAhtBQH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXqwblMjIxBGhtEXgE4nLIyZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTc5MTA0Ni0yYjNkLTRmZjEtOTc5NC01YzQyZTQ0Y2JhYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpab26pyIvrGo96CK2bRAoZYEWNcaert7sQC8iTrUDyEKH\nY9xYetTlrtRdSjt51Kesk25M243BSpzFBBt7XmIto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCVyrbeG2RSjhR5ceInn4LR7k\n340wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAKqvmFQs/iJUk0CfpEAP3BdaWQSbVql3s2YZ1Rwp88fEAh8+rJ4XoCn2\n2JjuLBJ15ENbOASRY2g7lxpevIXH1frA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZcoKC8i3I7/1KXM46Vp7tC8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkzZjNjZjgtOGYzMC00ZmU2LWI3NTAtNTZlOGVkNWExNmQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NmQyZDUxOS1lM2Rm\nLTQ3MzEtOTdkNS03NTAyZjBiNzdhYTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATQ/IJOPbdSc/4e10zuk7/S2+YBNvSD3m9cK/PyZx/1IdIDEVUd/5N0G0Ve2Df8\niEXOWeMYjBKgO84eV6VbGOU4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSuF3amBcOu19rE\n6k71oOQLT1HAZTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD8\nHGydy46lfMm8AnJbJOS/oW3PcZRVIblD9txgO5dYWgIgZy0FDTDdpq7Xow31sle8\n1VTgQULOD46LXT3e6f81G8A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7402", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7402` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISARj5bBTZxB0kj+2PEbA+uEUUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkYmFlNDQwLWVmZjgtNDUyMy1hZTU5LWU1NTA5MjZmNzA5YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q2NzVlNGMtY2I3\nZC00YjhhLWE0NWQtMjIwYWVjNzM2ZDg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcLp7vTf6MY1yongzRFkRpllqetVe2mFtI75vqhh7l78BLVHRfzLPY4Cbzt4W\ni5PMNc5MURvRK3Xeg4ifvPskRqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK/K7M66PNcEY0WFfUGvC2tVNp60wHwYDVR0j\nBBgwFoAU94y+KNCmNaH9goQvCWCku4qLFWgwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICXU\ntpMo7bx1Nc0qcgRfdQCdG6+JMcTB95Azuz10xDpGAiBQ3+O265bavlhtZ8RS8nkQ\nvsqD7pfmYfKVFk/xX9k2Fg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUf8OhUckqWXsXZwfwaCYz3xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGJhZTQ0MC1lZmY4LTQ1MjMtYWU1OS1lNTUwOTI2ZjcwOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZ/aZGyCF1Jg20YzopWdKYQ5Ygv8tcvFrf82197e0G9LoV\nO7QlwK2oW/bBYHOepoDLSjlrVUgN5SErJJyNeAnXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU94y+KNCmNaH9goQvCWCku4qL\nFWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIL2MxbLJpUg1Oo4xsuQ5DI1IVXpz/hNdwNo7pEK+oyDAiEA95vwRqz6\n66rAFLZlP9F23o3Abm55Bw8ppsH9yE8gqNY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAb1ns72E2KikfU45bMZvesFOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q2NzVlNGMtY2I3ZC00YjhhLWE0NWQtMjIwYWVjNzM2ZDg1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YWM4ZDVhMC0xNGNj\nLTQyNjMtOTI0ZS04OWZkY2Q1MGJmYWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATKfsSxiKL9Nc6K33dPDMKsbifp2sc0hNKfjq/P6hiTjKRgb5EE0zmiIRXFvTdN\nVW/8tOmn6590I7FvuTIVJ4nqo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQr8rszro81wRjR\nYV9Qa8La1U2nrTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICzf\nrAzkDsw6QFYGX/ZtYP87SCAimoWidcL/T57oLPWkAiAjtLlJBz9/+YJE1gNxh6ML\nNnkzGvdBhKTVgve0e65MaA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7403", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7403` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAfv3HlWQ+RMpIIBBfeZEWlenMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjODM0MjM2LTg0ODctNGEyOC04ZjI3LTg0MWE3MDBlZTJmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNkODZmODQtMTFh\nZC00YWVhLTkyZTEtZjQ5OTY5NWYxOTExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx+z8O7U/lXqD2VwGswQypwXslg8qvWawBeeTwBb4bhb5SbOY9yn8cew/Uv5X\nMAQEsRiMzKN4q55LROt0iDF04qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9fuLqIf+9SEfO9UqT+3Vivu70AUwHwYDVR0j\nBBgwFoAUkiYvK29mZqjU7PshpTJMBLR7fq0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCgZbC59JSHU3OmIoTAaD8FaKYrAnCGovgOnJQXsQVafQIgHXEZ\n5gSMqGO/F9zO28qa/3rcNDZmEYSDrHOFC3QixTU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfueLk81m3hCtbca8kt/8itHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzgzNDIzNi04NDg3LTRhMjgtOGYyNy04NDFhNzAwZWUyZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpOwL84492UUH0/sd8XkBNaYQBkImCV8SOffqO484Dd3NB\ndn5msaVG6uApiq35bGhI4eh1+bV8Kzwhoqww/atJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkiYvK29mZqjU7PshpTJMBLR7\nfq0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgem9TkTvmIbWdpaNB1LgdznUAZi73U1pJ67YHVU5jUWQCIFPCVrPoSPie\nU44rOwOWWKL/9rsWfcDydiJouvhrXu5J\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAX4VA6wzwFhX6UOv4Y9krUNeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNkODZmODQtMTFhZC00YWVhLTkyZTEtZjQ5OTY5NWYxOTExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNDc5ODQ3OS04ZThk\nLTRjZWYtYjI4Zi03MWNkZDQxYmIxNDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASD6B03Qpf7mdu2vD5x85Nq8UcfDN7tw12hCrXAansn8LLHEpfF99Sa1Z9az+Lu\ndbgj6cxRGWQMGM7NyNLhHLyXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1+4uoh/71IR87\n1SpP7dWK+7vQBTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIALX\ndNw++XKzmD1c2N4kNJFHyCGnC1GY9y1d/ZV7lla7AiB3xRSDczLe+4d8fgOuFIg+\n4Ka+HvmDbWgEDYats5mGPg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7404", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7404` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVwCmHykraOfubH1ZBJOMYu4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxMTg0NWU2LTZiZjItNDkzMC04ZGI0LTlhODI0YzJmN2Y3MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMyNmE2ZjUtMTlk\nZS00ZmUzLTljZDctMTMxNGYwNzQxMTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWcQV3YgKMkb9CQUVmlud1ugMDeXOHFDxP/p2k/kFvNq5X/TzNEFANDI8YjnJ\n/9hoXND9uPtxBNFPFHEIbbxM1aOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCDK406St6QNkHkckk4vc4EWscY4wHwYDVR0j\nBBgwFoAUDZO7s18uMez+cO/eCNJ91PC4iSwwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIAoKOQRUYGRtG2H9Tt+iqIkGamUMzZ7xEVDe6NctOH1uAiEA0PsB\niwVfJO2OjOg5ywDu/1xWYHc7g2/oRCDf3GH7Fbk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbwfhhqqArHDFK3oVgbWcesSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTE4NDVlNi02YmYyLTQ5MzAtOGRiNC05YTgyNGMyZjdmNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARF9Li4GscQ4dsBiZgsEH/kjKbYmKaubgVe78WWvcVivJtI\nKqoCrFf9ClmzUBh91fvDheBrrjdrNa6RvUhXB91ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDZO7s18uMez+cO/eCNJ91PC4\niSwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEB1vB9zN3VCkY5MhimcsJMYQthPS3KNcXzW8ms+UpnACIBVs7tXM+jqN\nHPklXMeZsowYczbTiaT+dAZcAUEDrU9K\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAU7tGyUsUL4qSNM4aCKnpIIWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMyNmE2ZjUtMTlkZS00ZmUzLTljZDctMTMxNGYwNzQxMTM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZTllODg5ZS01Mjc0\nLTQxN2EtYmJlOC0zNTNiZTljNDUzOTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARhDfQhHMSBQ6a+1t281/T4OBSF0VJZrHgxfSR5mi2CfDFAQTjNGGqX0IH6cnvC\nx9Pge18OiF98QbZJnZlCD+vHo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQIMrjTpK3pA2Qe\nRySTi9zgRaxxjjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCF\nknjDKroRnDp5EF0jp7ATtm9OW0T7hZmkGTI82TchwwIgd1ydtzWb8r8XawKO1Oh0\nB6Nmzv7hFNUxVd1l4i5v6+M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7405", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7405` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISASKPlNcv2eb3g43mVp//1mODMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmYzIzMzEzLTIyZDQtNDVjOC04NGQ4LWRiYzRkZmZlMjBkNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTcyNGE4M2EtYWU0\nNi00OWVhLWEzNTEtN2IxZWIzMDFhMmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUyMDooOtOBYLifhz/CCnGO5J2XiLuM4TTnjnvuIVlMuqD0FKhf5fZEcTIPd4\nKKZVVDRbr7Tc+KlI6nCHFpER5KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRRyRTu6YeWEuuYEWIWOkObHaj4hzAfBgNVHSME\nGDAWgBQK6RBZKoB1wKNpxXmJWj16QROQ2TAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIB8BLZdLftnLr+mozw0F76vKrxdmDdmP\n5kdWuOoOJQzYAiBfR7GfU6eaTUT8wUBsr6Cmt8pKvkNMt0x2+D/GdkfnnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXceJQnqpJtl7J+XsMUU8dXgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmMyMzMxMy0yMmQ0LTQ1YzgtODRkOC1kYmM0ZGZmZTIwZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVS4zU/pDqTPPnuzJQfK01yWRx4rzT+H981LPhF1yzRKt0\nRsrdRxyclUjdCoay2pls6hO8xwzypDXZ/46PbEqIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCukQWSqAdcCjacV5iVo9ekET\nkNkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKMkl2c2yVn2HBPbFdEIWek9yoYgoyH54JDLt86ffQPgAiA5ud3xUoL3\naYATG0zrStTTLyvX0LiROWbx+ba5rk7qhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQ5wSIGWc2x3qe6ax/FBbO4wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTcyNGE4M2EtYWU0Ni00OWVhLWEzNTEtN2IxZWIzMDFhMmZjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NTMwOTMwYy1mNjQ2\nLTQ2ZjUtOTc1Zi1kNTFlNzI3MDY3MjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARMQMRd8uXo5QYW1geYM7JoeGRB+NmkPW40dYf0tLwXFTlpzHiY8DBY0bN2MJVl\njQG7rAFi1pM7u2xbsDOGXVgXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRRyRTu6YeWEuuY\nEWIWOkObHaj4hzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIEGY\n7s/mFWPV92ZPjBO9hu7rgQ1eBLCwsPyX9OHGhDRNAiEA/4cqvTbR9TQ4uMwjD5jo\nGLe++Yuadn6KT+/9Y9a6k9E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7406", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7406` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcyCK6yny4BEGKCzzUYCDaWnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjM2FmZGNjLTM3YTEtNDljZi1iZDk3LWYxZTE0MDQ0MGE0NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQzZjc3MGEtNzFm\nOC00NWU2LWJiYjEtYWE2ZTE0YTg0ZDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/5vcfpOzO+Oik1ReaEaHSHr4rOo3kJDjMdmS8P/sOPLmUspPq03zB6PdH6VA\n5tudFCYMX1dW3w/iaxF7pUzYqqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNK15P8Az3iYKAidAy29VesTC6cswHwYDVR0j\nBBgwFoAUpYqLysmNPEpDcPuAWHarjscL+fMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEZ+Y/2oEI/s\nbUfc5+RQohQUJOTlV9DdrSBgZYK4c24gAiEAq+sQFchOMHsbmnFWbiBi2uO9m3Qz\nFvid8sO9yhfMb0E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbWa5AvQtZUoP12tGYq13450MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzNhZmRjYy0zN2ExLTQ5Y2YtYmQ5Ny1mMWUxNDA0NDBhNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyAZ2m5cIiqYvCbKpklsJ4Whlg0eVG7katmD8ELLO9R2DE\nQawlWg0sdwH5yaHl8hXrT1KUztcxoqGyUrOFPafOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpYqLysmNPEpDcPuAWHarjscL\n+fMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOd8hSg3QF0Duk/ylWYxknZgsl6ZEGKqyaWIAsNiFoUAAiA5cJc9yDFc\nWwrP/ddFKZSPF+verNDOUTau7XOvaowgjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAfu1EYL0E78V4VWk110S+juyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQzZjc3MGEtNzFmOC00NWU2LWJiYjEtYWE2ZTE0YTg0ZDM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4MDBhY2VjNC01NWQ0\nLTQ4MmQtYTY4My1jZjg1Y2Y1ZjNhNDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATnFAAMU5VPP3286NhqZo0BoPhzymVcPcNXIO50FDEKrVbKFp5/17cnjuC/gX6u\nn34Pcv6d/4Viu8T83tT2xjcIo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ0rXk/wDPeJgoC\nJ0DLb1V6xMLpyzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDda\nGJ8vlf+Q5/MM0uAr4AMpGv3AvU5SNd1EdrBjfQZnAiB/XRnxpe8wHVUOBCykCAd/\nsxaPI5gWun2ZKVQIFqk/vg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7407", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7407` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAbE6Fat9bS7vgLwC0LghSOeeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmNmE0ZTkwLTY0NzktNGU4NS05Mjc0LWQ4NDhlNzY3N2UwMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTg1MGI1YTYtNWRh\nNC00YWIwLWE5ZDEtMTU3MGM5NTMyMTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEplW2JbOp4kMpK4SxIsRDZErK0mLLbWv7m58UFVT/jBcLpVwMXZsDor5hGbdT\nrid6SXTEvS6gxNnSyi09E/3jqqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULaeJMruXhSiBibijcdnu/ptS8HkwHwYDVR0j\nBBgwFoAURz3vbyPabz/lSKK6OTAxl7vVPxEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIEEK2vFoFJUc\n35TboSkSHdU+V8iaU/l3ChwXLdYKnQJfAiBYvJlm97SQQlrk4kK6TvfRTZzXXgtt\ntwCjvZO3tU3L9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARkcGaYgakZe0HfkqnU/7mdgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjZhNGU5MC02NDc5LTRlODUtOTI3NC1kODQ4ZTc2NzdlMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYcjUhRzeYdubi8UIGKqnb1wvipf2qB5upEJWMrE4tYD/B\n7SrQAwBI4U4KvTCAMMiv8L7/b0EJ1tRe88q8nBRVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURz3vbyPabz/lSKK6OTAxl7vV\nPxEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAORNde3LEYu6pmAPHL2Nxea8uhlZOqATFHkfPxF8170yAiEAnJPQl8mA\nPiGojFjNpF5bzJGrP6qe28yOBPkGTM2yU4Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAV+SXIMRDI86WGbecCRgd9oOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTg1MGI1YTYtNWRhNC00YWIwLWE5ZDEtMTU3MGM5NTMyMTQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyOTE1ZTI4Ny1lZGI1\nLTQyN2UtOTVhMi0xOWJhMzAxYTFiMTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATWezfpppTfWu9Rwe/CnH0TdoQznuhsvkIYhFOiw0BoyX2orYnEkSYXioEwsmcL\n27DdFjCfTjIKFoKhD1UCsSvxo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQtp4kyu5eFKIGJ\nuKNx2e7+m1LweTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCz\nCbvIVvkeAaWtrnVGb0d6IrTHlxwpXuhloGxfnlVofAIgFXa8aegLdWtbHRMZ8LoI\nYwC9/XNtFdOrqoxDMA0qXeg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7408", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7408` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISARCYkZQxwZPVDV68E54pPFwCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3NzZlZDI1LTM0NDEtNDRmOC05YmMzLWE1M2U2ODlkOWQzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkxZTUyMTMtMzg0\nMy00OTEwLWJjMWEtOTBiNmUxMTU5OGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsbA9bVJByI77NDNP2CUlg7rziiIDCrfnKtYBQj4bEIX0bVbZCGpY4w5kCNVq\n8R3VTLOOGIlZejW1MlV04PruJ6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4hpQv2kZu8n+f2YWfvHhDZ+E3RMwHwYDVR0j\nBBgwFoAUo/5BTDVD73rDIyvO/dxgfD3B2dcwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAVOZGRz6t7\nwBnzQUy6SOwwQgF+ET14v4gQtiqw/thLjQIhALh6sUzGXLMMERU5gJau7/x/0stF\nZLgxX2d5hrI5coGs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWIzr3qFgk/naMijX6jK2YGFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzc2ZWQyNS0zNDQxLTQ0ZjgtOWJjMy1hNTNlNjg5ZDlkM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3KW9/VNY+Oo5gZG4zQlfsicqv7dBe7QRAYrPww6FxLiUR\nUTxZ3hUeInlqKhyilBvjR6XjpA+3Iyy5inVGnT1Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo/5BTDVD73rDIyvO/dxgfD3B\n2dcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPdUYVKtRY/bxAWOY/Og+OQ+ABg4HjuYZ0h6kmYS0x0ACIQD9LiQF6JhX\n7zFHdWq8tUKRwJZjVkC5zPvvJ2NuhSelCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAauBSd3DoB3KbE6Mr/voEe2XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkxZTUyMTMtMzg0My00OTEwLWJjMWEtOTBiNmUxMTU5OGIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwOTMxNzg2MC1iYWYx\nLTQxYWItYTAwOS1jMzY4YjZiNzhlMzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASUX/iNox00wvNObTgdfSnVRvShUI5xJjCFPw7uBPIq3BKL9btL70Kn4IWCy8p+\nIQy3sd5uBbPFP2KrdPmMbBQ0o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTiGlC/aRm7yf5/\nZhZ+8eENn4TdEzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCT\n+QDK2XF7LDaAFXUKiQ1UTVDixmOgzjqpARvNWb8IAgIhAO0ptaITYZDyEDZ9bGcZ\nv9wJ02X7n8EjyXyFi2yl3iXB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7409", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7409` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAcaS3V4XuKvyvzmDw1YAQtF8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhZGI5NmM4LTg4YmQtNDc3ZS05ZDRmLTJlN2NiNzkxZDBiYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjNiNjE5NmYtMGE4\nOS00ODQzLWEzMzgtN2VmN2IyZTJiZGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6aTqqMh2aayGg6P+4QR8G8AstmhGwt3bDcZ7iGLs8wDpkLBu0Yv4BZ9CPjZJ\nfqr2iinqKWtcyITQ4/F5TE1jXqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsWfKBjw5a7ZgR6wKVWmFsG1qfRQwHwYDVR0j\nBBgwFoAUW0w2Ud++xTmChNRLT2haaJcYixwwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAr8y8tMUzXc2KoShZAnK0Tdly2oQk2sBsRAnKWFG3a0MCIFSenYdmEz78\n4jPYi5nbIH7PTnZXupHKDf/on34J+RhK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaj72/96SR8Nx8PiKAYNUGN0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWRiOTZjOC04OGJkLTQ3N2UtOWQ0Zi0yZTdjYjc5MWQwYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyVQLtGbyPb+BvutimgGYLShpKB8yvLxwa0r7TGlItKEk2\nIkHqKk6+3Gurymo/wJ8Opczeld+YJAWrug64sk5Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW0w2Ud++xTmChNRLT2haaJcY\nixwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIe4V2QdS7Ts18bhxIo5sQE83yH/Ps+ABJZ7a67c56TUCIQDL6dWhreeq\nq4XJ+/v2/IlFYH5xGIyviM3tDNbHjUl88A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISASWODj+dANGz26X1GsVf0C52MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjNiNjE5NmYtMGE4OS00ODQzLWEzMzgtN2VmN2IyZTJiZGZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMDQ3ZTFkYi1lN2Mz\nLTQ5NGQtYTI2Yi1kZTU4MTc1MzJiOTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARCFt5JblEqmtGKDZmqLXEnvUFPK4JNioL9oQ4NJm3JPgD2ylII1DiXkiwOk6UL\nkY8fF318UoY07429M7WV7UVQo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSxZ8oGPDlrtmBH\nrApVaYWwbWp9FDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC0\nSFrtiJtHyLZkg1MM48M9O6W1nj0fQgrQ/QtX8SJmpQIhANtEkHoNbjFATgfjmUtj\n951eBpr+WrLyQNm0mZuyzmk2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7410", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7410` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdpwQ61p2JAThsrYtbl1pUfBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjYmI0ODEwLWZjMjMtNDVhMC1hZDFiLThjNDYzZGVjMTU0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJlNjBiY2MtMmI4\nOC00OWEyLWE0MTgtNjJiOGY3YTMxNTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXO7eIds+DoiAtNn/iECRO34iv63MIgvUY4quncmwDB0UPhmHLxHH4Ujg7QNk\nCtXTZlXZRZVfrx0wF3AGI+FyNqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo52oTqPo0hleMG5SIRw0wswHCI4wHwYDVR0j\nBBgwFoAUMKYFEgaPvwz42WZ9GtbxpRWxx3AwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBS+EEVNjcJdBkZk+cFwXhFa/CxmMymiBhRQ9m1zvi5pAIhAM8RMtUcBqjh\nSV1DsKNpdA4mrL24+b73Wb72yno3c9lw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZN24+LYOnVJLofpmF35RkweMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2JiNDgxMC1mYzIzLTQ1YTAtYWQxYi04YzQ2M2RlYzE1NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8Ik467Qelz5PFSDH20a3pklStWoHnBk5tqfGQ9/o1c/iD\nmUH0V2njIZxw9+NVewbsiLejWctzhdXpdu0EP97so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMKYFEgaPvwz42WZ9GtbxpRWx\nx3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANttKUwOwSTAYIP+ZepFXUbGqDdzQtBPgLmURgJg1Z/8AiBKjoyjdcxV\nUkgPOVxrbLYIG18/MiRgDfiDM4b8wR+Z7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAU1cVPp0SLRe8ZvB0KL6Ie1GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJlNjBiY2MtMmI4OC00OWEyLWE0MTgtNjJiOGY3YTMxNTg4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYmU2NWMyZS1kMTM0\nLTQ0MzAtYmMwNi0xOWRhMDQzNGMyNzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASt3IiPgolh76h2uJddfjwyy1MJIs8O80JmEWiEqrsddaCMopDdZgikmrL4bxvB\nJdR58EdIeLy/4k+/cZ2IvITPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSjnahOo+jSGV4w\nblIhHDTCzAcIjjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCA\nAt8G5cAUQgkZ1ecjOjXH+nnyCvGF4oSj8CcalwvnfAIgOCKCoqKuuIEJ7Duckpyf\n7vL7zCBWb1yaR6/ddSdi98k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7411", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7411` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAbt/JDkwpvr+JwqSjROpWw5YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2ODM0YzBiLWQ0MzEtNGNmNC05MjlmLTc4OWVjM2ZiNzFkNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRkZjI4ODgtM2Yy\nNy00Y2VmLWE1ZjctMmUyMzlmYWE0ZjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtsVHmrrYpRRzu7lq0hp4G4cJnkczK6xAx/canCUqHWFpcconECTYB/fgLvEf\nO1mXikrxO4HJwszxFcmoit4iW6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaLZ0ubPM1Cj91UUMXVgzfGv4w80wHwYDVR0j\nBBgwFoAUIOeLxpLroLdDs8gvVjKDMhQy2vowMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n0NAeVPDzBGT6/xoLlWmW0MtAptW17qv/vGkQoF3U5w8CIQCZesb802fqziVtX43c\n4KXPxE7jaXG0NTgGtW1c9WOoDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXoOOmp8Vy4mghaAklg61RbJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjgzNGMwYi1kNDMxLTRjZjQtOTI5Zi03ODllYzNmYjcxZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkjLKXbxWJOe7o6q9w+EmyuMF402mj71hWf56MVE/8bgQn\nil8dOfill4QUGDgHlHDWTCXy3v4GBS4nVU+PUQ2Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIOeLxpLroLdDs8gvVjKDMhQy\n2vowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTeaaETHi9bdCHxsLBMEvC20NMw8BAIh/fN6+lBhi/5MCIQC811bSVAXF\nQ0/ERz0mogn/GPtrJ7aHrP/f7zWQLix3Cg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISATOgxaCPk10PXzrNYw+PHPHRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRkZjI4ODgtM2YyNy00Y2VmLWE1ZjctMmUyMzlmYWE0ZjcyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMjViMGNiNS02NDZm\nLTQyMTAtOTIzMi02MDY0MzI4ZGQwZDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQo6Fofc7WEnU9I+6ye6sExMY5W2OyFPv9XC8n7Hzsw91WrqrKETdjs/kUATzYH\nqhyRiGvCGCewqdpLr8VtJ1lWo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRotnS5s8zUKP3V\nRQxdWDN8a/jDzTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCm\nLfuHXiFNDb7iG3QpzgMG/ZQLUZXj7OTjvpayW0RlqgIhANXZpa+6wBYeVD5+crGO\niPXTjUeIhVQ1VsvUbYXkXYt2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7412", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7412` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAVegedPa5Coxghd1yfQTFRGDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5N2M4YmYxLWQxZTQtNGU4Ny05MjIzLWY3YjljODhmMDA2ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIwYWM3ZjktOGFm\nZi00ODU4LTgzMDctMDNiYzM1MTViZjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQar2cc9VZ4xOIEL3JFJJ8f5wxw12RmZj400K+D6/CzZUkWzBktBHOYxEhwyL\n+ySUAKhtCsRkg1JVLEh36SU+2qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/p39lAiPigbbRFqx2ER79ThNX7swHwYDVR0j\nBBgwFoAUgkZpjew6HRcbvfsSQdQI2O0Fo/IwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiBJqElDZq9e0OB+H8Ys6aFL59QH+4JhEm6r7DgECwANQAIgRM7T\nKN3KfKfzt6SMW2GF19207TywRd+9f1KZcew9VvY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa38/89oY65wmJAmhLuH22OEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTdjOGJmMS1kMWU0LTRlODctOTIyMy1mN2I5Yzg4ZjAwNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMGE0QJX1ug7+6f7sDo6TAEr+Q1f8HIZW9+GfmeknpcpL8\n1SyUiG7agSW96AQsrPKY89Is2OJl29nj/nSdV+a+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgkZpjew6HRcbvfsSQdQI2O0F\no/IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANhbkinutcsB3jV7N7N6DrsHWzlAwaZc0o2qv72dNAm5AiEA3yr70d/r\nGXeGIIm+sphqzzntnF1JIEZ1UDk5nlTD9b4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAbTR/WjXjjGyUOdylq4VA5a8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIwYWM3ZjktOGFmZi00ODU4LTgzMDctMDNiYzM1MTViZjAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNDQ1YzBlZi1lZjBl\nLTQ3NTQtOTlkZS1mNzEyMGE2YWFmMWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT5nL8XmBUxN61c6i46dchWx0e3o4mNtjNHnwQD/fLnIswJVaJasAXAT1pFyw/D\nEMeFLUdwYWLyAYly6PWz34gbo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+nf2UCI+KBttE\nWrHYRHv1OE1fuzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCj\nsyXZ3g1IAUXjur3Dj325I6+HOMLXHKH6L8+TpeK1PgIhAPplJ3G5sIdU4OOwSUie\ns4LUSnLr+h8L/xP9B5mQjr3Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7413", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7413` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAdvDyTrIqriOKSH6axjlXU2hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNWNmYTczLTAwODAtNGFiNC04MGZlLTU0MjM2YzI5NTk4MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDMwZWM5MGEtNDU4\nMS00NzlhLTg3YmYtN2U0ZWQ5Mjg4YWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZAqvBJ52oc2sFfBSPlS9yZQdYgmnhEDi7np+dw8wqXmg1qPQcYdXpBPTK0PV\nRmVG7sWngekyezdzRjgU2pSp2qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVg10pM4Eq6Uo8mTtMAWEk/3Li4owHwYDVR0j\nBBgwFoAU69YSyc4/XlCezZbVlckYsCjwmy0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiAyHAfMmaJo4SiJX9nsFG0J8A2hR/EFcvpavfQzhCmTJwIhAMCX\nPUh2OMAjMtl8W84bqMRYd7Xb2HmiJGxwR6KhZH5B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5eev5yNd4VWAARFSjMz7D8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjVjZmE3My0wMDgwLTRhYjQtODBmZS01NDIzNmMyOTU5ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaYGTM3pYx/BvbWXWWBi/m4IDuxocXKnAUVa/kzwyDumzZ\n8JyXtLXyOpMHwq6+tioZ2l+pOMRtI5HBj4DoGZGYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU69YSyc4/XlCezZbVlckYsCjw\nmy0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgT2TyvC+ZDLdVtj3QE4p7Drea0yCK5wVq5dWf/vChoF0CIQDdfdXWSMuI\nlGm13oEs2ofGtG1fIAO/1IxGtSlCM4GpEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISATu80shg110XcDuO75tE9JzYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDMwZWM5MGEtNDU4MS00NzlhLTg3YmYtN2U0ZWQ5Mjg4YWI3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMWVlMjEzZS01YzFk\nLTQ3ODQtYWFlYS1hMmUxOTVhYzliZWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARo2YoSFalbPQivEwBSyVJWIB+nVJILCljBgTVomU5kuv3vNigs6So2oeGda8fP\nHhBNgAQGkNY1D1BrCK2EVzujo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWDXSkzgSrpSjy\nZO0wBYST/cuLijAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCv\n7gNuGopMChcYUhFLBAwhb8OMdHJshl9SuwcTi9s+8AIhAPISMIT4oYgWIKHhSkmu\nnvfrrRlRoLUPPEjfmqVxBs/Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7414", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7414` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATy+j7R+hnBsx7t1a9KC2AhSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4NzFmNzg3LTRhOWMtNGFkMy05Y2E1LTNmZTdhOTZkMzJlNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQyNzc5NmEtZDNj\nNy00ZDYxLTllMWYtZDZiZTdmNzM2MjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMVuFzyG7f1LQBGTugmelWrxHgve1YsxTwAs46G1gTAnhmZ0OdkOcpOWrpf3N\n8polTzJQeriPGaxxEEojtRoanaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgx2Cpp2oxG0uJgHcFNLhSxq4xeQwHwYDVR0j\nBBgwFoAUk92TbG8Bw/Qe+pGfbcXAjXqry7YwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBw7rNfQhfckMVM\nyBMIT5KjNYzmXTvp4R1YM8BqJ9q+yQIhALYyAMg8pSUqnV8Kbd94kPD6AuJHiJGP\n+yqri0l2LUbk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXo6Tw3Dva8iDIQyEyd1yqGcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODcxZjc4Ny00YTljLTRhZDMtOWNhNS0zZmU3YTk2ZDMyZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsXqFb0IchIQ15DVEUs0H/t9xODlZabjDV0Q9Rgv0GLss7\nlXvxveU/bnaqLeoa92VcQwkemoy+c6IATjTE4pQ7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk92TbG8Bw/Qe+pGfbcXAjXqr\ny7YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQkEeQBTfPWc+IvUnjdJWj2H1sYzAfYPNUJTUpe7jy1wCIHgIgscxOgJo\nERKS/0H0k5XVMypyQ2eTBTQ9Fge2FT2K\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAVoDehuCYS8eiM+PKLMooz+6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQyNzc5NmEtZDNjNy00ZDYxLTllMWYtZDZiZTdmNzM2MjMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NmU1Njg0ZC0yODk0\nLTRmM2YtOTIwOC01ZGNlZDY4MzAzYWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATi6ChF/M2lt1hupoHdo5auYIe5Dm6dIqh722qmNdhC8xEEhrnVyAKgliG5MVU7\nV058Flxcd8Nkzv/7vOIm4BtPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSDHYKmnajEbS4m\nAdwU0uFLGrjF5DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCr\nng9fcWxWzyeLF0JKp1PsVFRistFDCs/N6PLqRrPc+AIhAPbyfL2EO8pNk2+al0Ye\n32i5zE4koB1edVf0AhUEZLGh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7415", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7415` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZzfIgo3zhhSaApZs4DYyqoGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NDkzMWZkLTRlN2EtNGMxNi05NWM2LTM0NjYwOWFlNDAyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE4MDg2NTEtM2U0\nYy00NWQ1LWE5MjUtMDY1Yjg5MmExY2ZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvg+eb9bPXOvVJWsJWONsPPvuoB140VHnVo7G0CGbzjrI5Hw9YA3mQnMLoyIK\n+ApvclYJDNQQH1yXjWaNK5kl5aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUom6/LzvhF8kDLAN3CaauV35j7ncwHwYDVR0j\nBBgwFoAUOSf4xpVehZNNlptHJxW1EyXh72cwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCTfrZ0ZbgvwtUdD/rFnytC15wgvYrq3UVCpBIjkmNLPgIhAN05+4QMQDnn\n/hhrdR7HSA/3uL+Ksid7tc0E1kaiz71G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcTSFhZrw2zza44yVIqtfescMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzQ5MzFmZC00ZTdhLTRjMTYtOTVjNi0zNDY2MDlhZTQwMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9Jr/ZVyaEuaGaR4E/EPx8s8MqYjH5IByebY0hTPe1dhc0\nZ0s7qWq0rxaM6QrYbVHrOqvrKvsK9xxWMoKnEG8Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOSf4xpVehZNNlptHJxW1EyXh\n72cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFtoBDMZPeeCC4CYCRVrJvYKs/tmtRXQBRTnK2M3Qyi0CIH5Dvghi+hZl\n4/yuvwGzTIFXqv1zUzPTH5h26S9VMwGn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAX5TbyVsHadJXlV/cPg1sCHWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE4MDg2NTEtM2U0Yy00NWQ1LWE5MjUtMDY1Yjg5MmExY2ZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYmEwZGU0Mi0zZmMz\nLTQ3ZjEtODBhYy0wZDRlNWQxYjU3NTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASPKVwhJavVPXDmuSiomWz3OEoJFt/NDKq490BVwQPY5tjfVs3iANSGYgrpwBOe\nojkEy6xj5GNzvwdHL5YtzJdro2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSibr8vO+EXyQMs\nA3cJpq5XfmPudzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIEVq\nwj/XZ1Lt9mJND5A6sf7wHYdqT55RFJORL3eQsrSeAiEAukdT0bmP7iFgnJnT+hSj\nFADx7MPU/aNm/FA6Fo7JrOk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7416", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7416` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAaFS0lMEM8B4L1owIK+6a+0WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1YzJkMmU4LWJjNTAtNDdmMC05MGJlLTczMTM1NGJkNjg0NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVhZjhhZTctZDll\nOS00NjU1LWJlZWQtZTIxOGYwOTA2NDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwcdAmp+mWnr7YBqvKzl18IERsrDody5W6hlkf3grQ5mD6IdL4qTlxtGA9KPq\nh7bxSIKWqEXBe8xofgbRgIgJw6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+RxjJE6l0A2iGFc81dSVI8I4oUcwHwYDVR0j\nBBgwFoAULHcrsdYr4yxqgr1vmdnQp5Kl2U4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBe3RRTg9v599ZIslqEQGDRhQAUlltNsWjoe6ifSAG/xAiA80fxmippE/Wnq\nxyyP/ZP5fyDVv3B6MnGlizXaKUAITw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaXFgpdhjycz7MiR++u1UoPZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWMyZDJlOC1iYzUwLTQ3ZjAtOTBiZS03MzEzNTRiZDY4NDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP6w06mILuYMQHW4b2asRqSWQsBAtmfgt7HgXtIaH2/T1W\nNdujpNi44w4SbxGE1ukiBjl/3Jjh2GU5cgXCbUVto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULHcrsdYr4yxqgr1vmdnQp5Kl\n2U4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKcP15SfKGG3zR6JxeXo0eQteQN9FLI3SfT/OJ6teLHUAiEAjV8khxko\nyyQFkAy22NrwjHgxqzzj54Ab7n/u8IDiJOM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISASOx136xlpfibfRHXHEXhwN6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVhZjhhZTctZDllOS00NjU1LWJlZWQtZTIxOGYwOTA2NDRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMmYzNThkOC0yM2Yy\nLTRjYzctYjQ3Ni1kYWUxMDEwYzZhMzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS7eq4Bw2MeG2z3/uLKBsO/mgU87877ru/5NJyfJF2NluIV+FFpTuwJ7jwFV4Xd\n+PisbSh5OcqCQpmT7KU48+2Co2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT5HGMkTqXQDaIY\nVzzV1JUjwjihRzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFik\npeeKJXn+wtkyoAEa3tbmJzfc4w3aR28ZdQKMWg/fAiEAj1714bPmMOPCxYVsJlLO\nUUskfjAS74ljIoere24HCxU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7417", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7417` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISARHyEJLDjZ3AdjScpC6MYKBSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYTdmOGNjLTQwMDQtNGQxNC1iNDA0LTE2NTZiMGQwMWZhYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFiNjY2OTMtZDRk\nZC00NmI2LTg1ZGUtNjc5Y2JhNTA3ZmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM09Wopt+m4E1algWULkBW780yq3OjrMbEzep+Cyouig3sykFp496Ca+WApkk\nNXXeZGaplal3B9BkyPlTOeho3qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFJ66MQ8xSyHbiCF/zHNT1VMoDy4wHwYDVR0j\nBBgwFoAUkohyTkl2j9P0k98++enzrsYcynUwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAEFVbOUb8tTFhf5EpiJ96XfWwqPRVUaRWrM3Bxu6zidwIgHO9/zz+Bgvhx\nUQRUJ+iDHCA6DVxnytZPunex1US7dl8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARZ5aL7ldJO1PC0Oq0o0T0/fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmE3ZjhjYy00MDA0LTRkMTQtYjQwNC0xNjU2YjBkMDFmYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXYnmPkf4Rl00ayV9FwqPLbPIaCnpsNubyX+FafsxncvKq\nRYL4MxZG13er+uVVPAZcjqc3782zTHKEdydwKPJVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkohyTkl2j9P0k98++enzrsYc\nynUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdMwkPnOKqH0ii2tjFcjoSrGOXtWcJTP6OOEFlM9Q2s0CIQDJWx8AvTrc\nXMYkfg1aVv1ZXZB5NIjpa1BF3OctDOfhpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAe2pdyGk0WdF401kZow6PJ+mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFiNjY2OTMtZDRkZC00NmI2LTg1ZGUtNjc5Y2JhNTA3ZmI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyODkxMDZkZC1iYmM4\nLTRmZmItYWQyNS1hNGU4ZDA5YmEyMjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARH+K/tvKxzlNgqv0MTA/i7TRAKaN8J61DUnYGkf/yfSqzcdpOBpmVtNnFNJ7td\npOVqxw0ykrNlIu9EjNPA9CBNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQUnroxDzFLIduI\nIX/Mc1PVUygPLjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCy\nK7jfueL4yKtiKsv8gfIdYkrQbqkcy+BcX6anadSMQAIhAK4ibXnYPsACsEk/INye\nNpjBSRwoDtswXZyZFc4LEdkE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7418", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7418` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAYWymgQLr2xbVgP4rZHQkMZOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjNTM3ZTk4LTI4YjktNDFlOC04YWQyLTgzYTUyOWEwZDJmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWI5ZmNlYTQtM2M1\nMy00NGM1LWJkMDYtMjZkY2VmZjY5NjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUPJiZK09yyU3wjzFEMCU+Y04S1we7pSIVBiMMf8V/o4uqdbzEuwwR0rILXwt\nR4d00S0YP2er4UE8akufGM+sOKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn/SFfJY1Yk84xBz6RQP8zxPqckswHwYDVR0j\nBBgwFoAUxkHojDU4kijQ0kcWsQ2ZlampwX0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAneLi8pJgp70eLf0CTqghD28aL/zXIva6yB4Lf2a7\nQeMCIQDWbQwDvSwMFlaBfLiYxP41wY+Duj23fri8bHMm4Bo6bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUFdcSbnuIM73JA3lqq4XV9HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzUzN2U5OC0yOGI5LTQxZTgtOGFkMi04M2E1MjlhMGQyZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeY42sroz7TlHKYj8qTgGM37PMKNJnjR+Q95RjYfAZ9Mmv\n6jqF3Ojgd2pXXNE435EFM/j7QInZ8YUMa+TwZBIyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxkHojDU4kijQ0kcWsQ2Zlamp\nwX0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPNYKy7iNUbi+YN1+JgOBo09g96manglUesGCgXuhzNqAiEArfkz1aZA\n8dXFyfG4OpljqsK5+qpyvsERlsSloqYNmf0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISATfz8q8/uK2LYjrO5xEY4QWNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWI5ZmNlYTQtM2M1My00NGM1LWJkMDYtMjZkY2VmZjY5NjRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MjlhYzg3Ny02MTdk\nLTQ4MDYtYTE3Yy04MmM1YmJkNTcwY2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR6MV75DzD91yToLaK3S7/ogbFxW3tvxzSwcIeLOMxXzXRr1GKmdKKK/QeyOd6J\n/g9gepHI5+5XSEdm2Xi0gTE8o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSf9IV8ljViTzjE\nHPpFA/zPE+pySzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCU\nnQCURAqW/WMbvMC5F/H7ACKwX3GnexB7yaC/qW3TqAIgMy5z/IWHOQtMZWX9m0w+\nk2GBPlPEGi4AgkbAtXpnktM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7419", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7419` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZjPGcoKhJUqdNFXaM8JT40IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3Mzk4ZTgwLTljMGItNDEwMi1hNjg1LWRmNDVlZDFmYWI4ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ5OTEwZWYtZTcw\nOC00YTc4LTkyNWQtMzgwMzg3ZDA1NTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELiv6I14itPFcp5sLQsm5ty9kG8I21AzHXL7bA070mDlb0G+OavFyIUOafuMf\n/qt3oOHtWv+SNfLtE8iFWVCJjaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhbf6mOmE2NvE4CnBPy3P77fo1GgwHwYDVR0j\nBBgwFoAUqpPY3IWBMpQK71UK91sHf2DuqBowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBPbduddCmg2uleQStnFVIZ1DWqUYUFPOJ6WtEmIWlX\npAIhANfyYgRsdmLAwBULc1or3dMRs7pP7NnOxpOvafmrPwH5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQB9shLbuO/uI0zKaHU3w4MEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzM5OGU4MC05YzBiLTQxMDItYTY4NS1kZjQ1ZWQxZmFiOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjzZ/PXNYDKGZkd7cvmwSbnfrwL3XKhqaA2SiLwsXF44Of\nWJEl7jCfBToOy0mDcXtBiBZ50uN+jSxxECXZVTABo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqpPY3IWBMpQK71UK91sHf2Du\nqBowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMdvwv/hVHeFnHGlX1+vr1gAj/uDNDZIz+6Gjh+ZGT1mAiEAwqLSz6SV\nFPuWdm4vleMdzPfC+vNuDqXMQzns9Ii0oAM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAZdYdOJsRxPQcUBVcXZ632IaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ5OTEwZWYtZTcwOC00YTc4LTkyNWQtMzgwMzg3ZDA1NTRjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNGQ1NWQ3YS03ZGUz\nLTQyNGQtOTkyZi00OTJiNTlmM2FkZTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATs8MYAz+BlYzyUERiVj4gE6knaEIiRaRhlmuPsCRWGMKvuywl2VVlqhTeN9dbm\nzZoV49bRlQhMp+xtRujTjj2/o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFt/qY6YTY28Tg\nKcE/Lc/vt+jUaDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC8\nuOWrwMw8RhzoYV5Hpv4Vogns0N382BajXRv1Zq692wIhAP6QE4Uhli1+aj6uAS5j\nxvWkABs3R5LkN7Bmgoa2nolc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7420", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7420` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAYZZkuN8O7BrwAiAFDHqAz90MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0ZDFiMTE2LTBjMzktNDJkNS04Yjg3LWUyZDY5NDhhNmJhYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzkyM2M5NWItNDFm\nYi00NzIyLWExYmYtNThlNGRkMjU4NTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvBdUY5t/RhOkwM1kz/vsNkQemQj1EWfqOk//NBbkVMGKTe4y52wS2strdyf3\nHZvbguersGwFbB59So26f2Vvs6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFdg90DVJ3U8L4KGfPMf3Rl5ayfcwHwYDVR0j\nBBgwFoAUccj5vUJK1+FSb4IQ1oMclCYu1jQwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAh9QedofbUac/bURpHh2MqWgh4S7DkassNpTIAwqgDYCAiEAlybz\ncbBZyKJtiCldCR11mj86LccTflYOAtwzcOWKypg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXrzr6jipIu7iaVyMiYxrbFqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGQxYjExNi0wYzM5LTQyZDUtOGI4Ny1lMmQ2OTQ4YTZiYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaFzC7YvvIwh7bjGYqb05USYdvg+QxLIMAHD/qjoSb9/jb\nC2q9/+6S6NFnDdv8PqJ3+DP2m8Sb9Br+lCQyqpSxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUccj5vUJK1+FSb4IQ1oMclCYu\n1jQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMHSMlJ5Bw5BTFKVQvZGiCwrdgZqWOLk7k6dp8614tWsCIQDTlyvCqZxM\nvQ12oSRlrKiWDQo7Ihb3skPQaYk+SpAMoQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISARi/uwyf4MzuTC18HqDYNVvXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzkyM2M5NWItNDFmYi00NzIyLWExYmYtNThlNGRkMjU4NTE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5OGU5MGY2YS01ZmZi\nLTQ5ZjEtYjMwNi05ZmM3YzM4N2M0ODYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATiAkTTLsz7fr5Av/W3QbeKYFDm9uKJzYA1Bd1f0Y3aHTHy4UksusqX7nPRohvA\nlBYrZw5VE2MqSlxDGrwJNEiJo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQV2D3QNUndTwvg\noZ88x/dGXlrJ9zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIHBU\nBx2F4qN8hS0SXG0zexnsCrYUTVV0VIcTcot3SQyqAiAMBB1nBdwlZWW7gImdbb96\nhuTjskH6FWHXDbVOsuSpwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7421", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7421` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAcNTL4G7Su7SMZQhSwpFF5T/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiZDlkMTFkLWZhOTYtNGMyOS05M2IxLWRiMzliMjg4ZDgyMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQ0MDEwODEtMWZk\nNy00ZDlmLWJkYmYtNGVkMTlmYjljZWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExT7Uv6LJ0ilmNeGPKrSkvwxfh4pynK7tfYJzZShdascHp2ffi2NBFk1jGrRB\nHJ/o82EbECN9Iq6ItDJAOd2st6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1LgC+/yzD4cGEOGGXj+jSs0asEkwHwYDVR0j\nBBgwFoAUtsTNOmmBh09d6B8LM41thJ1DqtUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBIrCvY3jo7alpuHPiESuvMJRQrCuUsAfPP\nqbFaE6mNfQIgfZ5BtGzEnpTcFKb7/bXMLpQU1t0erS0aNbBF+CIFv48=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVaghHpD49A7fFm5WTS1QxGaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmQ5ZDExZC1mYTk2LTRjMjktOTNiMS1kYjM5YjI4OGQ4MjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdNrLXfQd9ye0FqarqS1GJeEHUTtyVory34MEllLYPC21Y\n331xXWghYmWh+PofQ4/liLmmTOyqHNNaWK7EQzsto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtsTNOmmBh09d6B8LM41thJ1D\nqtUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANRbG9d+L8J5n1D7SYAgb1fkHIizYmfrE8snrl+nSb4uAiBMKnWvQ2hK\nD4jAs+5v0eRoyTAd2tYXmuMUp6u6G7+AjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAVHCLAHTniqak4OOKfZ+kydrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQ0MDEwODEtMWZkNy00ZDlmLWJkYmYtNGVkMTlmYjljZWEwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNDA4NWVhMi1iM2Fi\nLTRlZGQtOGIwMy0zM2U4ZWIxNTUwMWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQm/r341jkEEnZ53sIJhHreah6PW2N3AU4+TkLnZv0VJwo7ssXQ9PYchx+EiusC\nUX8AJkf6pGDAH8PFlfqWcxoZo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTUuAL7/LMPhwYQ\n4YZeP6NKzRqwSTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC1\nLRq/ftCyCNp8KaAOBGC2RcLQcJUrw1cUGX6ASE7PQwIhANBq5qHl+sjZRTiiboxo\nYTj/KpelZinG1inGbrCEqSeW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7422", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7422` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAdrL20gAUlOtDRo47SSZcP5PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4YjQ0YzcyLTVlZGMtNDY4My1iODI4LTYwOTRhMTMwMWNlNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQxNGFhMDAtMTY3\nMC00NDllLThkZjctODJkZGExODU4OGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm1Iv7YJxB42YcWMFXXB9I2CrKXiv8Z8uVWnzyQMq0UOmvohEf/F5HTSy81aq\ngfxNbDgfB7uwqS52xvQEL6tF0KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyH3HWfspm5Av625AxOfelsI5r58wHwYDVR0j\nBBgwFoAUZvusYiecxfnA9tpWV8O9tVF5M/cwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA3VHxFU/yrkE1vM0t0X3FeZAdplhdJXuY\nHmlDMuJtLH8CIQCMhd8TdrOr7YDJzaJbjUulNH8afGvDHfmMkbXjWFIwxg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa3+G+GfDKpAzWLDJni1RMp8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGI0NGM3Mi01ZWRjLTQ2ODMtYjgyOC02MDk0YTEzMDFjZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSDbyWsGQyPZidWwT0u1UwGSoHsESJRQRtOvy+lbukiCm7\noyzcoBbhR+ok7ccGe7Y0AO+/mCyeVOCdP03PrDouo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZvusYiecxfnA9tpWV8O9tVF5\nM/cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPckVNA/T/pgh9xb0nwKT4kIJwpkmwoRtedwc9kaLj7gCIQDwQFS3Km46\n7E+jFqRqUZgiwpsh+txJOrM7Xq4rEqnryQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAcktIw+l4h3SZ0mGhiJwYf1QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQxNGFhMDAtMTY3MC00NDllLThkZjctODJkZGExODU4OGU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMjRhNTY3OS1kYWFk\nLTQ1NTktYjY4OS0wYTdmZTJhZmEzYTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATBDv8XWArOSEfqxDaUFae8vtDsBFtO3i/EhRwAJcQiw1AzJDYE25zzGiprexeZ\nPFPHXD60dmbNCVHdRxoqKGPPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIfcdZ+ymbkC/r\nbkDE596WwjmvnzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHx7\n3sDVmWmY7FntMPQ0yqDPLA+MqMWg7Rw9Hpe+CxPFAiEA7vsDKmgF3dFr3wvWRgnS\n/wMPbXvlI0pcdM7vJSmJM4c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7423", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7423` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAeRWECc6g3kx7ngetJUMii+EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkYmFmM2NiLTFmYjAtNDE4My1iNzQyLThiOGZmOGIzYWE1MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzEyYTUwZDEtNDEw\nOS00MzI5LTkwNTctYjhlYzY5YTQ5MDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE46kl9JhyjNQ1iThQUGqj3CVUlKUDEb8aUa7oVdO1SHI9zDEtlvG9srfNeSjZ\ndHplNWA1Gaqsj8GEVyVdhxMjzaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT1WXfLeXOVOFnAJqz3h66NcA8TIwHwYDVR0j\nBBgwFoAUvOImJrHkhAVxu2zNBfVvS6JnMZUwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA/SVBVVpihDYk\nNTkB/3vl8o9rVMT+YUdCOfiUsoZ6DrMCIQC3Epi78Ljh6QG69iwOzjqCQbSJMfPr\nqTTHCzk+zDqvgw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS18a4wZw/GiASKq+jDQWrvtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGJhZjNjYi0xZmIwLTQxODMtYjc0Mi04YjhmZjhiM2FhNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvcSVLQudZ4F0EHAgrlyfCiGIPZY2JB0ycy6BV9Zy+ystv\npMCLbOH0Kfpmx7H1Dra/fRyOqe03E7lBluZCy4B1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvOImJrHkhAVxu2zNBfVvS6Jn\nMZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJBtJQ0Xk/vod9atdYx3rcyo8uzNH2tNBhJG3xxvqHy0AiAmwP+r1kR7\nWbmwpbaca1zxvaLLxwHn/rCwOiRknB6CrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAeXS9KYf1hoj5fhJF0/p6zeRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzEyYTUwZDEtNDEwOS00MzI5LTkwNTctYjhlYzY5YTQ5MDg3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNjE0Y2Y4ZC00ZDc4\nLTRkOTMtYWI1ZC0wMzRmNDUyYzdkZjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASu0W1qKymRUkZwX37uzrsuB4ud6LJWCgiK7O2DxV17ZrfboIvSYwtlM05cZtxQ\n+l5BnV0k9oWFzJPpue6kxIT0o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRPVZd8t5c5U4Wc\nAmrPeHro1wDxMjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCD\nYIFwx4QrlxlAAMNh3GEl9SLwoGiwV4zY3ctjZSJv1QIhALeVHaj2AOY2J0PGQrSs\nfVVVwzZzjebolhrmAPmElQ04\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7424", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7424` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbtF85ygTDnHoxfTyNE0typLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhYTcxMjg4LTA1NjAtNDEyYS05Zjc3LWYxNjJkODE2MjE4MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA2ZjUwZmUtOTk1\nYy00OWFiLTljMTQtMjFmZTUxNzQ5ZTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnJK5w8HApYGKncSI6ntWqAc1GmDB+8sQA3Zj0q+GrRLUXHWbi+xWQnNg/IvX\noUMFEnvHWmeWFeOCUAIOaoRcgaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0++MjPR6ZRrBf6YiGtFR2r2VQs8wHwYDVR0j\nBBgwFoAUbWOa89Tm7VyoM4J2odZI6yq4IgAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD5sRwhqEhU492Gbp783g+X8jYcOOA0DmbWOMb1luBoMgIhAMQ0iDMFuhOP\njRw7Km0sEjHZp8EZ+MQG6XYKkK0eJiJS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARwCpxtcdyaGS3y9ZLHoMCmqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWE3MTI4OC0wNTYwLTQxMmEtOWY3Ny1mMTYyZDgxNjIxODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1rH76JBfXVIkO9VAwfvf/nB6t34njnnFt8K2QrNekcusw\nOCHFFj9a9JyCg9Sae55scXNsFRgJsUyj1mbJcVfPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbWOa89Tm7VyoM4J2odZI6yq4\nIgAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPxb3Jcuu/2iyzXUKEtwrdPavHXiH4epDTLLznch/2BYAiAv9RdwTv0Y\nY2nbq7W154u3pFV2iJWpd9IiOiQUn51OCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAanc93CEmsYO8WOWlBsVL9q7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA2ZjUwZmUtOTk1Yy00OWFiLTljMTQtMjFmZTUxNzQ5ZTkwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiOWQ3ODYwYS00NjI1\nLTRkODYtYWU2Ny1iZWRiZWE5Y2FlM2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASm7CNR0uNkTSJmkbwVcez7/5Hur8yIdHjlmM/qmGzqMVY1WMovqWCK2V/0d+Xi\nUMnLDemK24nbj1dhL9RrAq2Zo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTT74yM9HplGsF/\npiIa0VHavZVCzzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCi\nLGS4pJxlunfRn0Si19CjlwuY8JnNs/5md2kol6GYqgIhAOdsilB0kXO15fj6A9hS\nBqEdHLxjPDtN9iuv0XDRLT1U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7425", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7425` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVQNKHZgU9iKqHLc/cVUe2V6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZDE0YmI2LTQ4ZDctNGM1ZC04MDRiLTkwNzNiOGVmZjFiMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA2ZDU4NzMtN2Rm\nNS00ODdlLTgxNmEtNjNkMGVjYmZmYjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjX9UTYRHfMIzH26nAHIvDitPlKbu3acA8+z94ZN1KG6VMWBonYON3MaSyER3\n8qK1vx6wBJtm7pjLRs6ZYf2a6aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcSn+xXOGOpfSOERT8KKiIPy+fDcwHwYDVR0j\nBBgwFoAUkGu1VGGwp1tPXNdliv0xnugCa1wwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDdOe9as6LrzkWlpai946ZMOMF90Hv/IcAeY+nkFM8LcAIgQiKOUm9sS+oo\nUsVmaG/vRjkhtzjla+88uQve77SggSs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVZOqmy/OU/+cMQLkQeTISVNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWQxNGJiNi00OGQ3LTRjNWQtODA0Yi05MDczYjhlZmYxYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBWf3WKuHkMF6JgoL+SvlMSER97+aVzZ+2rF4pDv+XkOv+\nwq9o5k0fIbCvMRMfOYd8UrvE+tJA6+OyF4LcjLovo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkGu1VGGwp1tPXNdliv0xnugC\na1wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgb3ltdS/P+aQ+54em4SZzDUrUfuZ6fHq5IK8GO4fu+oICIGajjWGKV8jE\nyABRYS1RyOOpkZERqipDEzw9fqaVjs7K\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAVIEu3BX5BLvnV/xMzW51pzkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA2ZDU4NzMtN2RmNS00ODdlLTgxNmEtNjNkMGVjYmZmYjY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OWQ4ODRlNC1mMWQ2\nLTRjMzgtYWY0MS00YWRmZTc5YTQzYWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ+KzvjmII2rwXvxVHAoHBZOGo9T+FgwYOw22W+j39xoECosWlfrt3RVRwioKzQ\nDcam91aAdSBcCMFt2ixkxrito2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxKf7Fc4Y6l9I4\nRFPwoqIg/L58NzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIF8k\nm0dY5nIXI5hJipWWsluk4AumeiUx23OZR8hYSI3nAiBoE9IQEOv46PBchx9flL2r\nvRzrTH0/BEalDeSPdFzflQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7426", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7426` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASpAu4KBjXzt1pfXdBl+7bBxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0ZWNjMjVmLTMyODYtNDgzZS05ZjNmLTgzZjUyZTRmOGE0ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGUzZWY3MGUtNTk3\nMC00MTZhLThmZDMtY2UzMWRkZDI4MGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF3zvUfGr4TqzwfDgzQE2B4EfQDMyMAjkf6OoBVAZwsBiC1COvPi2VyCLXKxZ\nuk2m13oP8GrgQu8GXxzh7XUT4KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb7eU5Ib6uehZjrk+4TMiwowqFsAwHwYDVR0j\nBBgwFoAUs915OvnTMZemuqNdYMzqxvyKq10wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA00sMhJxmiXRBtZnW1m1/N+CcmT3HwNaYZIHFFcfQJWcCIE9QYIdwEI+J\nUz7mnAk6f+CyvrZnfG0jwH1WrfYSv4KC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQAy73n8C9XjmGbRoI/rQEUHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGVjYzI1Zi0zMjg2LTQ4M2UtOWYzZi04M2Y1MmU0ZjhhNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQMk6J87JKxTiiGTtF071Eq4u+ojqbmkRTAJHKJ+rFEXUg\n6B4PEdyGmDkuzfx0Yu8qbMKRuPgk5YjrKdEHcW/xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs915OvnTMZemuqNdYMzqxvyK\nq10wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOiMQmLzZos1e+atcB+GDg8tLp4pCYKX1SuY2zpFqj6BAiEAg7+ORJ5T\nK+lXXnwOwecqXVq9fJT0jYceeYmu6OGwWKM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQCF9UeF2F8yPMf1wthKAPHhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGUzZWY3MGUtNTk3MC00MTZhLThmZDMtY2UzMWRkZDI4MGFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0N2Q5NGJmMC05MjZi\nLTRlZjUtOTBlMy03MjlmYzU0ZWE4YmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASZcuX209L1lGjq8oia9SzfH8n/be8Qj4J9/3cVFCMW5AyrK/I5QHAvMPbzEgZH\neFlzawgLxPlB9AKHMBwtUZaZo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvt5Tkhvq56FmO\nuT7hMyLCjCoWwDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCk\nFdJ65h8a7RI5LgPSXxuZDmX/3Qe3Bp+WaV0mzT8G3QIgUtNw6Rv2CS4t51kSwRsE\nYklAn/obT5u3YPiaAz4g9Po=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7427", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7427` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISASr6LgSdENVgfeZowrMmwA2+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNDg3OWE5LTU3NmYtNDYzOS04NjJkLTNjZTA5YWE0ZTUyMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGVjMzNlMzctNjI3\nMC00MTdmLThiMTUtYjRhZGUxYWRkNWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGHPx5X+0nmK0h1TDzVhz1iytWo0r7emRkTF7GXk0HkkMwPAK7YVAkP660SnQ\nfb3T2TPvAeZU2mPGxNqUYWiZfqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWdZq0GHt2NUXA22aZXFK60M7oxgwHwYDVR0j\nBBgwFoAUdZqelBN1bTZ0fivM71mvKDHMC2owQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAkHuyhZGpLLoBy6lLyg/sP1YNFFB5SjRggRw4SicY\nSjsCIQCLfgJJFQyJmMX0bHbGYX+ElLYM//Y2IIOwDV3t3FWdQg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb76kA47wEBEbUf/bXJr1wchMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzQ4NzlhOS01NzZmLTQ2MzktODYyZC0zY2UwOWFhNGU1MjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiOM15tSIRDoWnZWTkoMGZjffkp9J8ObJciwHwanSqS3WQ\nHDzprtdrlRSU/TaZWFLCZPn0T+FxGWJfEZ73at/oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdZqelBN1bTZ0fivM71mvKDHM\nC2owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQrhz60ZZiyT35yBAUcFHRn4URME49ji13OLEs+tPwJsCIFjJfDzF06E1\n66vUVJ5DhCqib7ebui8gZyEOLEGoCs7+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAat5ZupKPbkw+j7GH6mrYprzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGVjMzNlMzctNjI3MC00MTdmLThiMTUtYjRhZGUxYWRkNWM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0N2FhNjViNC05NzU3\nLTRlMWUtODIyZi0yOGJkZTg0NWRlMGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARFVg82jNjK3pmDqhNxhtJHGJ4plhhADNQBQ5UebKW5fTIwrh/UfhkfdhhIkVOH\nv1mQpZbWARzsiMdJ3yX9vtOBo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZ1mrQYe3Y1RcD\nbZplcUrrQzujGDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD0\nDCf35zE5gsCwHGTfUgZDn3G/LHft4p6VhPEQPBDV+wIgDIoOl9eOBxvnd2TMUUOo\nK0TkJdnYukg3aXUHKKM5vYg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7428", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7428` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISARF0uo4SlokDrEeg6G9At5lDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMTY3YTRmLWNjZTctNDcxYy05MzIwLTMxMDAwOWQ1ZDQxMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzllZGNiMmYtZjkx\nZS00OGZlLWE4MmUtZWE2Mzk2ODM0YWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEYdmfrJwcyyK8Yn5QQ0g5c06P3+MC+jRIXIXD2QblaUluUGrjbgqHiaE2mKF\niJfPnAyp7tECZ0nFbAvQ2whIz6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2bWTAKdlrptkfNiTj5dVfMcEtcMwHwYDVR0j\nBBgwFoAUN8Lj+0/KKcv+G0aXAzzGcEtZfJ4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBe1ebd+9YHKTh4jja3+2UhGy4W3KwHVoaJtSTYnd38\nswIgYtEdTrCerO1FXSwstO/FGMCZrk4e47DbreIswFiCLjI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaTciN6z9QQ/VXWtfsGOTPU4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTE2N2E0Zi1jY2U3LTQ3MWMtOTMyMC0zMTAwMDlkNWQ0MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWczfpZiSR9NLSzZpevbYgwz3QSAeDKG0QvoQcIgJio8dZ\n2V16RX9RzOLqRPzJel9O90xh0IS1vyOiQQm/9ZbPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN8Lj+0/KKcv+G0aXAzzGcEtZ\nfJ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge0jSuUW0KG4wD+OydaEtWHUQwv3tertYpixux6xhNnkCID5mkrz83O4e\nYabXjdCy3Lkf1kgigMO+qv8uOTJxMVwP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAayS0kWqKnjVxzGQcnbhPVewMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzllZGNiMmYtZjkxZS00OGZlLWE4MmUtZWE2Mzk2ODM0YWUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkN2E0M2NiMS05MDEz\nLTQ2NmQtOWQ4MC0zZjZhOTNkZjdkODEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ8oOFbxbdlFRBGMgOA2c3NK1Q2MCugONHBDxj21y4L14pspUyFiEWpHjHsqdST\nI7U5h6UFFL8pyCIiED/orLLlo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTZtZMAp2Wum2R8\n2JOPl1V8xwS1wzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIBuC\n6wKqozwG6JtaqhXrRjuSSeMVbaflnsuh3g2tlC0BAiEA+fUjsWuL1y7wmHC6JG46\nO6oA14cC+4abshXlRjOkFA8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7429", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7429` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISARoFMM/mvn8uF+7jmOEIPIRTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjZDM1NTQ0LTNjZmUtNGM5My1iYTU1LWY4OTM1NTgzNzYxOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk0ZmRiNjQtMjMy\nOC00MjEzLTk5MTctZGE0ODIyMDZjYjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkgdqC4bffarjJ1puAZeELr/W7y1HMk1j9HVyGp8jjXR9vhOgO4FBzmCuXBv+\nuS0tOr0CumIsMK19qQ82saCFC6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL9qMGZlvjS+nGCGX4FFnyqEh+igwHwYDVR0j\nBBgwFoAUpsTcE9Ql6D0Feh6nWL8I3lLEtfgwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBeV/HdlClrPImpPJVRC94a4jTtlzzAJmBGzO6UJjVF3QIgOe8U\noMCJMQQNEJA4AkeYyZIQdJKsM/QMPscut6CiN14=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQf+XOWdHWj891gHTlKvC0xUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2QzNTU0NC0zY2ZlLTRjOTMtYmE1NS1mODkzNTU4Mzc2MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS17wrrCjrfEfwlNkCJ5qH+mpkEwVc9rWzQ+ugP1Voj2POo\n7hy9XR08IaPnbd7W9+GEtTdsQ8hEzauwvo7XjyYMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpsTcE9Ql6D0Feh6nWL8I3lLE\ntfgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYFaO1o1SJnKdHMftwTk/KK9aM3iJK3woHjECyNCr7AICIQCfhtf+puGy\nicYRDXc/RkQw+9inNDDVeB506njLMUDN/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISASbPpP4YafhI6tpWJGTuX2nWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk0ZmRiNjQtMjMyOC00MjEzLTk5MTctZGE0ODIyMDZjYjg0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZThjZjZjNC0yNDEz\nLTQxY2UtOTFkNS0zMzkxYWVlNTNlMGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASOxVOyYUtaaeLelpXGXuPlB/iaZmEUVaVNP3lCFXLnL3epqfl72lygNqS4xJwD\nOKHQWcBFTalLQKLxOJNI77yFo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQv2owZmW+NL6cY\nIZfgUWfKoSH6KDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDz\nFgJNBfjL2xSKyuhJrrun48E/41raLL+Zmd21IBscfwIhAO2EQZ9iTW34pfvl82AN\n7gd0HSSlUU83wNczgQ/7qpTk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7430", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7430` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISATgmZPIy79RNbY2DlzHx+XcHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0NzUyYWU4LTkyMTgtNGViMS04M2YzLTg2NmZjNjUwYTg3ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU3NTYzZDMtMDQ1\nOS00NmIwLTg2ZjMtNDIzMTkxZmQ4ZWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa185v6wH6YIfL0jGkyQEoz/wk6UZttYPZVYlzDxszCQdqxBjbitA6Er4kdLm\nF9wvsV843uZxfB0WHIC2FsNd0qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkh8lTMUkNCjrkY32ASfDSvrW+T0wHwYDVR0j\nBBgwFoAUJjeGsyZllgeiK0Fo7bv6avKaD9YwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBi3hXrddr/cdI6s+lsCfAHVz9UPXb9sQ5y\nzNgPKWyt5wIhAMnoDubALfGgYwJXITMff7TzWODlHugXIsPKikuifz88\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcgu11atfFIpUrOBye0gMNavMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDc1MmFlOC05MjE4LTRlYjEtODNmMy04NjZmYzY1MGE4N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3L73fnmwd4P0XoK/E7EbbOmIspuRegmzlWb1T9mLTZBwK\nuG8I5Lj8a0/ym0DIk5MhcM0MMiC4pJ+TjUHC5szNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJjeGsyZllgeiK0Fo7bv6avKa\nD9YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMO48JrbzaznB6W3ZVln0DPMDtU2gBvxAaWsYOF8Etu2AiEAu0TG3oB/\n3Aocibylkjo3eOP5TNqWuOJ0bFc5ZruaGP8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAfD+9Va/yAaP/vC4uCMOkn/XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU3NTYzZDMtMDQ1OS00NmIwLTg2ZjMtNDIzMTkxZmQ4ZWUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYWRhMzc0Yi01Nzc2\nLTRlZDEtYTk0Yy1lMzNjMDE1ZmQ0NjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATIgwubPvzjXZ7zVt+3U1ig8vrniGci8bTAZE/ftT7EFGbwhWrOcPZw3uBkrvk+\nRexjzRz95Tnlu5MHC9BKfc0fo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSSHyVMxSQ0KOuR\njfYBJ8NK+tb5PTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCk\nVFQaLt39ZO5RZOdINEuoETZvSPDo+Ut0ZuW4+w0m+gIhAMPaLhNvxhLKDKfaS99H\n+yKamKmmRhMviLcSkxNE4JLo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7431", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7431` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAXT91n9x4N3GFqBOgAlvl4FhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExY2EyZjdjLTc1YjUtNDI0Mi1iODUyLWEzNDExNjI3M2EzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM3ZmRmYjUtZGUz\nMC00MDk5LWFlNTMtYjVmNGNjNmZjNDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6HkIFi/bjBK05nnY+gkvQVye9D2iGoamcS7QpihenpVq7EiVI2kX7LwJBuDt\nr8HwNI0cJFnJCk54x++wLeYhPaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJuIYU6SLpOg6zPApRyA1mUDGjHUwHwYDVR0j\nBBgwFoAUhip/N+oSh3Bw8gm7ieujlMi4LXowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAppwhpSMaGBy/1fV4C2eLcZVQ1k2Kuupz\nCDwmlqRjjRQCIEgI+M9NwjHExjZTqyfHuQuS5YyxJ6hzwNDpKtAsrpTD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbdYSz+HkV7sahCU6vVreYePMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMWNhMmY3Yy03NWI1LTQyNDItYjg1Mi1hMzQxMTYyNzNhM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqIT1SvcEhE8LvdZxYBWRvQnDEJ31DwOBM2/DOjgjczQI9\nMf27xy7R8QRmdYf8S+vKGDdw/nh6aOI9b0tY0nkpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhip/N+oSh3Bw8gm7ieujlMi4\nLXowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMy0cTkgbX2nilspIDbD0DYlPgocQeL8VciYY4i7mprxAiEAgPlc2VaZ\nlkPZjQGAJxyEr/uQZee7BG63204kMCc9bPc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAXlec8cno/DMBnup9pNMagF3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM3ZmRmYjUtZGUzMC00MDk5LWFlNTMtYjVmNGNjNmZjNDYwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxOTRlODljMy0yYTU5\nLTQyNDUtOWM2Zi1lM2E3MjViNTk4ZmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT1Ar5gERg/Sidjv0VUzYJsAs5WIi14pvSrkWsl+9X/b761x4ESdy0C+EPdkNuW\njqUtBVLW3ulDm5Wz8uYPcOJ3o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQm4hhTpIuk6DrM\n8ClHIDWZQMaMdTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDp\ntb7xCUFeG4llG6ptK6JCuxmvn9x7IICge14rqV0GQAIgY4fIAx9XYYIJkTFLtbWm\ng7izLZr6unvcxWxbmUUVaWo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7432", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7432` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAfwXfoeFZvEV3fobjGu4owolMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNGNmMDhiLWE1NGUtNDQyZC1hOTJiLWRkMGViZTBhMDFlNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThkMmJlMTktYjAx\nNi00MDAzLWFjMTEtYzIwNDRlNmJiMjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA2L1x1zR37wx5ARm3LbdkzPBiA0B7O952/xvulx8jF7Mry3hZeJ9XeNY3OLW\nuG/Gve+bs1m5GIYc3ZWuDWV4CaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp/e+ucYs4YcespTu9vYmZlM1khAwHwYDVR0j\nBBgwFoAUUi1XHJ0J5kD7L9MLTS6WCl0GkKgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBZzidqKu5U2Rn7YSzBvXp39/b8u\nmHUCY9GxIhUBvDmQAiB+P0ZzMnF85A50d8FmoPy/wc8JVOC2vGLbK0vnQ7NklA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeWZtjc6jUnWLiIz9Df+dT4PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTRjZjA4Yi1hNTRlLTQ0MmQtYTkyYi1kZDBlYmUwYTAxZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/6S3aEUcaqYTEmxshW9owICW/TdpdyjLIXc3bHVTRXWme\nlas22PAfdE2cXPnWW7GVhzAU+LE5ZRhn6u3amp76o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUi1XHJ0J5kD7L9MLTS6WCl0G\nkKgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP+n4DHUEcQIuiaJUjpbg1aBMd3vKv3N9PLYVB7y1WqmAiEAwz5/X01t\nbYhLLDrpwGbqHLmzWALM5ZGz2ETbjlgV1kY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISARrrM+QrVl18Yqz0r7HigFSRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThkMmJlMTktYjAxNi00MDAzLWFjMTEtYzIwNDRlNmJiMjJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NzlhNGZiOS0zZTM4\nLTQ3MjMtOTNlYS04Mzg0NmI1MjIyZjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ9UIj3FFXVDTNrMGZ4SZkf0rZ/rKfOr1+XH4v1YjdAMx9aHv+SaYnI70BOBq9U\nDp8PaWS4+G3XZNxYR5QvoWFZo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSn9765xizhhx6y\nlO729iZmUzWSEDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCf\n/jl42SnIQybb+F8KE07UuPghTc1VwxksAS0Tr6o+egIgDvr+LS6gSlaqKvZRseai\nyuL25s02CkiihnCoCm3qtmE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7433", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7433` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAR1yf5+XqsmuEvZ0M9MYIGiAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZDI2YzdhLTM5OWQtNDFkOC1hOTM1LTdjZTM3YTgzMTc5ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA1NmRmMTUtNzc5\nOS00Mjk0LTllNzAtZTMxZDk4ZTc2YWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB+4P6uLu9N339INEpJ/TTO628nLyseCXtueZ95V99HF9YziK1D02x4w0H2P8\nFtYdyuy8g/sbclUzR84SfVkNGqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQO/jeagxwbYjQYWAWH/d6isGMYowHwYDVR0j\nBBgwFoAUA9Zuq8h7TmBlrKFxazG6AQfZRRMwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAOksIDFT\ndnlCRY1yHT2MLgMrCs9n/9UEILNzEticzOVMAiA6ZaExNofJIBmySOCd82XPos+3\nb147MBXNdGUeq8fLzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVHDzIItCEFfwyHLFMIiwL/kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWQyNmM3YS0zOTlkLTQxZDgtYTkzNS03Y2UzN2E4MzE3OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1n9tmCxIvxWU1z/IOCqOSKFNGNUo3hwAgJ+rzI9x3fRFv\n5aiubpAyaM7HIqSwGzwaqGpvFALAnuVubNaSvFato2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA9Zuq8h7TmBlrKFxazG6AQfZ\nRRMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPMr1Nq++PxEialSo4pbjFFX7SX5IstXbW0TIrsC/r79AiEAm3qPHUZH\nliEvtcHHSvmAKFrjxxf6OmxuzZFl1ARUtIc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAfAM0TjhsSb+NB23x6WTVpeUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA1NmRmMTUtNzc5OS00Mjk0LTllNzAtZTMxZDk4ZTc2YWM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YThhZDg4NS1iYzll\nLTQ3NWUtYTg0OS1jNWJmZWJmZGU3M2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQPbdWsdBv3i0CwOqkwTW8rLbx8+FEbDu4J4n5tcRAFKtuNGr5ucka0XiTLF3Fy\n4aVMUj7mO4RI3aGB4paTaX4Ko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRA7+N5qDHBtiNB\nhYBYf93qKwYxijAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD7\nKGF6cgFMZ0/5ayYmTjAe24EeLYoN01ZDbi+jeoeYwgIhALQh3TCyG44qTnDewD90\ngR0CFDA5MCIHKukbqpudtxsL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7434", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7434` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAZQpp1Y003gQ3cTi9B68GpxmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5ZmI1MTI3LWRhYTQtNDY0ZC05OTZlLWYyNjZiMjY1NDc2MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhjNTI3ZjItNGJh\nZi00ZDlkLTlkOTMtNDEyMWI2N2RmNWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE82LpMTQjeGMeBnqzWKYe8EwxNiwS5pk1xPowBkuvk+8B+RBznxavLJ75hK+8\nZ906crnfv2zkE9Etb20J8F9KSaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlzRViDTwA44kM1rWp9+Lt0oUp8EwHwYDVR0j\nBBgwFoAUp4uYh9G6FdF7/Fha5B+2Lpa/hXswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgXJ4rkYG+\n4UXchC+1oxtpivJw3Er32JvBte1A1+7FB2cCICX8L9tXHuPuGt3XqQp6DFza32bG\nB8YvzgD26EN12per\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVn0RA8ndyjSWOd/7EnX5ObWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOWZiNTEyNy1kYWE0LTQ2NGQtOTk2ZS1mMjY2YjI2NTQ3NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARalZ8KG8XYZ8qvUPEN8HNFCUGdnx2R9NYQscBLUTSIReDW\nsFbvUkWXaw3SCwD2ZOTb4OGq4uj4m7oZwNnSI6Dco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp4uYh9G6FdF7/Fha5B+2Lpa/\nhXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIbCcDyJiEaEcwmBWKcHTXWwAXUsZWHcLZZh6K9qs3sxAiEAgYZYzaju\n/8TCvIWCN4VWwPxO65ndFWQYzvimqKDeZl0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQwQwfPRkPQZEAgGGovft8kWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhjNTI3ZjItNGJhZi00ZDlkLTlkOTMtNDEyMWI2N2RmNWM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNzNjZjdkOC02YzQx\nLTQyYzctODBmMy0zYzAxODBhMjllOTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARzTnFDSXpJtNf4fn1PyyK6oLYgKEy3VAaHjJUhpMNTm/jBhVMN3Oxj8KuWPkbO\ntAPq+3toUHWMDn6f0xEbPUP2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSXNFWINPADjiQz\nWtan34u3ShSnwTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIAWL\nSxzop/rsygv1h+SlEZyNpOXnc0Tv3MMo+2A+OurMAiEA197HnFfXGi71oHwBEUaL\njNAjqZ+PLVNdzvelIgPQyAg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7435", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7435` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAZMxZUtNV1E1uGK2MuDrauErMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1N2RiMDIxLTE5NWItNDdhNy1hZjRmLTA1MzVjMjdhODk3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBjZjEwYTQtNjkz\nYi00ZTY0LTk4NzEtODMwY2EzZTdhM2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA5jj22aXclSEl1BvQmtW15kCwPuZzY+6tIcaos7hgAY4eGpESGQY94Q/xA8x\nrjnKiBL10YCxsXOGn8kJ2ptgBqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXTWpKPwOBWTWdMV5CneCLMwJgp4wHwYDVR0j\nBBgwFoAUIsGLnOxaKuq6KSFlfpIGy7PJRw4wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDzEsYGw\nQBmPsZkZ2st8T/PlV9CrMhtGbOkvurYoRfgpAiEA5JjdihSyEUd5VxEqrjD3QVVI\nS1ULCsXKDjYAdimjxaM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeKHAzYE9dKvDjeWxhXHd972MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTdkYjAyMS0xOTViLTQ3YTctYWY0Zi0wNTM1YzI3YTg5NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjf4TVFuoqenNX/1DlwS1HiHKa8cMJnRbt1LHYZJZ1QNiR\nPFKBBmG383FTu9PnXFdE5d0i/Y6/BppovNv6ffj9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIsGLnOxaKuq6KSFlfpIGy7PJ\nRw4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBsEd5IDEwfWpDzIERDRnYVEZcvTYx2sY5TiAR3h54CsCIQCKPn+P+G4p\nFPaKMZeS0dh38WCYjYoguCrbUEhMsO0B5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAd3uKf6b2Z4lN4GIFoVk39nIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBjZjEwYTQtNjkzYi00ZTY0LTk4NzEtODMwY2EzZTdhM2NkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZjBlYTgwNy01ZWYz\nLTQ1YWQtYWI3YS03NjNhZjRhZWE0NGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASiwEIUiH0IbGDVfbG3JT6oFqoGEnBRBH1uAYVTbPdMGDehIOQiQUwV4NgQYX9a\nwrjBPZ13sMrddxkrYNp+AAO5o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdNako/A4FZNZ0\nxXkKd4IszAmCnjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC9\nLs86FWdE8XvTiY9PGfOphx0qTh2GOTzR3NSZPcWojgIhALioqfXe1kgwT2NmJqs5\nZ3sprJI+KLlna9LRERxPW/Gz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7436", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7436` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAf7Ta7gggNvqhUlh4PvzIMTrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjZGE0YjQyLTIxODctNGI0MS05Mjg1LTQzYzdmNzEzZDY1NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjNiOWUxNzQtMDNm\nZS00OTFkLWI0ZmYtYjI1ZDcyNGQ4ODBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELbIYxVTcQrUzdeGn+EP1/lTWcjd0Jnbe2ukQ11pGngatotFThq62o3McQn2O\nLQmypebSw6Pv9BbenYzrSuK0sqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaLxxk6duXNi9nj3UiGcevEo+VbEwHwYDVR0j\nBBgwFoAU3AlXqjwlcoywFzcUNGF6yPowB8gwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIFibZfN0LOZhWWCTz3UmEoFrMKilS5TABghn0atRegghAiEAowPvj5WP\nt6KuNvjQm3R5WT44HANYh6W4U16LAcbmaok=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUwbTgHv206nm1mbwDlBTiHcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2RhNGI0Mi0yMTg3LTRiNDEtOTI4NS00M2M3ZjcxM2Q2NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOrqLq2JlqVVJt3Gpfw0fhJhvlUtA1VwSxMYb36wNPoziP\nsEbUtoKCWln4grkU47ZpiCL6ug9cxIUEX2ifjK2jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3AlXqjwlcoywFzcUNGF6yPow\nB8gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGkeDqqUplcYyRrReugYFcoly5H7/YIOOjxuyZ/37XOsCIEIVy712xt9G\nUBNTaJP3XpQGP+VLUBAHyPOyBCAIfEpS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAaPAOPRKk0Q9TIxndX1KnOIBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjNiOWUxNzQtMDNmZS00OTFkLWI0ZmYtYjI1ZDcyNGQ4ODBiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNWI3ZTJiYy05ZGNk\nLTQzZjItYmUxNi04YmY4NGM1Zjg5MTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASUoCFW9pfAPPlG+NW2OZ4uBh8m2ONF2jhTtKfx+rCY7PRb5Fqg5g7XrlyG1jwc\n75UpZaKU5z/Y4QuXbc/sltpJo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRovHGTp25c2L2e\nPdSIZx68Sj5VsTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQD9\nvAwkNWqr/XkellmLoV0aY9mQgPspvJnDXHUFUhbYggIgJJZNXtJgMEgjc9CGhHQJ\nWS701ArQWkScBrbYfKb5Ww4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7437", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7437` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAcu4xCPWFqr4Kz8qobzzmJguMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMGUzNTEyLTM1NTMtNDI0OC05OTU2LTVjZjNkNmI3ZjBmNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM2ODllMDktZmEx\nMC00MGZjLTk2OTEtYTdlZmYxNGZkMGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZolyM8JoM377/ZPQCejuu72f+nAe8INbNKSlRL64lEefZ2M+SdtRN+jeBnHR\nYqmI+ReH0Mf9AX7dF1lrKNm1ZqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqxJ/I3IsDXjL+apCfCP1qru0k2gwHwYDVR0j\nBBgwFoAU5U3jtWm8lSy53o9RLR/aU6xGQOcwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIBeRCIF+kWpdtCpn8fpC0f2HVJpMlT5BCrWATF/lhFnfAiEA+SS+xr0G\naCGaskN5Q8ey4Wpbn3TAhFxJINq99mbyQIc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASfbyuKSnA/HjNzxlkApj45LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTBlMzUxMi0zNTUzLTQyNDgtOTk1Ni01Y2YzZDZiN2YwZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuHOixUofOjdY60fpdgVNHi0zkAOFHQM2PfLVCZmAvmpWq\n4loy4s5gUauBC/sH/BYvXEr/GlJWejeNtvasaN35o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5U3jtWm8lSy53o9RLR/aU6xG\nQOcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP9w3pL1I7O4lW8qv+QNLwW6qNaLiOy6yLvpiE4gVVgpAiEAz3MXE+e7\nalkIfe6sXxXylsXkondbJ2C43F0osHENBn0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAfRSV1BedyPv4rs37HRVcWtuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM2ODllMDktZmExMC00MGZjLTk2OTEtYTdlZmYxNGZkMGYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhM2FkZTYxNy01MzE5\nLTRlM2QtOWI3Mi00MDczYzQ4ZTFmMWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASNWX3nw1OEqditeZRnCttEVP/xNEnsMrrZDRkARGDqQEuaWVyhUllIClXQPeBy\nUrW+HU7WglH85QYRc/mH+9nfo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSrEn8jciwNeMv5\nqkJ8I/Wqu7STaDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIFUB\nTdwWeLli/2C0M7rrNqtRW7ALbutoO0ymI05GLWIxAiEAqZkxHbWBe+ScnkDAJkr0\nHrcyVsSCEzLi/bzFabXPRHQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7438", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7438` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAc22a+AqCcM5nxw7yNw7RBzgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiYzdiZTI2LWNjNjUtNGEwMy1iMmU3LWUxMzIzNjMzYmM2MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU0NzhhYzctMDAx\nNS00OWNjLThiNjUtZjE1NThkZTc2NWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHoOm149cABHQK3iSoSrlgobgpEBOosMVzbAD8gXVKM11f16M4dQkPsZnyZ/i\n1WprLDu6JxDqXFf8uVkl9SeMfaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/h34s/7CWncskSwlrVGX1c12nL4wHwYDVR0j\nBBgwFoAUdFf8Wzu45n5KBRzzPwfm8CEVhV0wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nICnJj5XP/9SeiN5JrDqShI5z+H8LUnI664z+FNb5Vu3cAiEAiwE5H3dg84Kb+wS2\n48hufDdcSVvX+JS6HBJ/4e4KJss=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYhN71iH4Ngy+WNgFbgQktV1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmM3YmUyNi1jYzY1LTRhMDMtYjJlNy1lMTMyMzYzM2JjNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZCcfiGAyQaQ0iOsrIYseFK9MkTZFu0nwovPMdovjiHhS5\nFiH+zXW4RhPu281qrD3Ma3m07IX6bLQpdYjFKNJno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdFf8Wzu45n5KBRzzPwfm8CEV\nhV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP9STX9hdwJ8Au/SGBre1azRgOztIrdpEbjn6DYpA7C4CIQCYgkup77+3\nD7LPJqhGsq1hVF9yT972DCsc6FGqgDt2OQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAQhFDmSsw0y2dvMf5UA+lzPNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU0NzhhYzctMDAxNS00OWNjLThiNjUtZjE1NThkZTc2NWY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYjUzMDc5YS02N2Qz\nLTQ5NWUtOTc0Yy04NGJiOGYxMjljMGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARqqvtzLQS0ibg/vIt24TQqypJLgceA1bg0utN1IcjknTs5im9zFZVDub+t5rPs\ngxmxw+07ehB40yBQ20qULDZNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+Hfiz/sJadyyR\nLCWtUZfVzXacvjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIEUX\n6vtRDUZMgMtfGAV2m9CbTlRnxAgoVFWb4lqgcv0XAiAJGHdFJ5xq6yUwjAN5b/rI\nBDLQx1OT+452HP0uFZlJ6A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7439", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7439` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUDhZiwiQl2TUwTXBB2Yy6R4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwNDhhMjNjLTVkYzAtNGZhZi1hNjdmLWIzMWI4MzM2NTk4NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZjN2U0MjMtOTFm\nNS00NWUxLWFiYzgtZDExM2FhMjZlYzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExt7jTSdPeLgFS56FBC1+wKRUvXDTNqyMPoGwMGMZvmKEJW2Q2evgPqlWPzFj\nW+BiqylcUoOTkfR5mHlhCh+cx6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUitAg1C0xPjWqqUymX9OKIm81IxAwHwYDVR0j\nBBgwFoAUMtwOw5pbwf4NPRTqnb9WErPNElQwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIHTIRoILd8zsTBYmceFAmME8yf9xRU4ME+dROuN4M7RNAiEA\nuzjTK5c3QtXsqJNsSx66+0/MoEFmm0A1aZLuEPsUTVM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVKVLy5991LYcQctzLCsJEF+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDQ4YTIzYy01ZGMwLTRmYWYtYTY3Zi1iMzFiODMzNjU5ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4QhWGglBA1Lb6F+WTWR7VxI6xN3q/dG2nScdKuqJmfA5L\nPqdFm/SUzP/q1av1RLHHRO1v/mVYrzqT/AK9KJ0ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMtwOw5pbwf4NPRTqnb9WErPN\nElQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOQOjsDd2LErxEInPPpjZcfgx4PEee16iEGFcRrJcLYyAiEA9Mgy3N5U\n//BUrY7+tYJ0Qun80b4X0w8CmEYfBx0Qjr4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAZKcg5oTNmMpDEaamO5puUDqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZjN2U0MjMtOTFmNS00NWUxLWFiYzgtZDExM2FhMjZlYzFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYjIzOTNmYS1jZGM1\nLTQyMTEtOGUzZC1hMzA4YzA2ZDE5MDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATB7EU3J1AbqYmN3xSpKJ8iRIyycpIBpOioUSMrAPtfNgZH/wcfXCbNDW/1y1fn\nQMhHMzCTlduHcV9+xGJnOGCKo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSK0CDULTE+Naqp\nTKZf04oibzUjEDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQDU\nkBZoPwfODJBXD0mRcXQxjM6rBbKgycVDIaAJ3nAAHAIhANyoyFS7rMefXiGi4fnt\nsYyuDY0zkuk2HWZmmk8p+sXU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7440", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7440` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAb2wQbYqlMROTL6wBKtv5K+bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4Y2Y1ODM4LTM4ZTMtNDZkNC1hOWE2LTRlZjQyM2JiYjk0MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc2NGE5M2YtODFi\nMy00ZmFiLWIwMzAtNjRhODJiMDk4OTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMVvfCNBAC/7ZQtA5OFoH0BzvDHfecKb24uFjG2vuYUChmgkRZVtE/ASdtns0\nw47KjF+eEAP41pK7JQbfXQip4aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJVWb8TiYEsa901hxs68zRTAhYwAwHwYDVR0j\nBBgwFoAUq5lxqPBHbNKPt/HCeZvonewXlk4wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDG/A/7OBloJmrzsB8qMUMhGnLcUJ0xuVQQyqjpziJMCwIg\ndjPwrdw/MEYAQt1596EIWFerJiJOzd+R9Ks09EZThSg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARmzhN7Pe3Dvd2w1WihkV2aPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGNmNTgzOC0zOGUzLTQ2ZDQtYTlhNi00ZWY0MjNiYmI5NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7cX8RgscLuytVozzMOpR3linDSsojaXthTbeE5t60qE3V\nUde/PcPLdw/odVJ/nMeNX0IFn0nWKpWnDSv9tCdMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq5lxqPBHbNKPt/HCeZvonewX\nlk4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYy+GvHmXrbdZPpASgpRRAIRTO5PM/OTwMjpAfGkpexgCIQCzZqO50eBX\nae8EtQHNKeB7OCO0pQ/OhBOK4QscJoyQjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAQOncyi2Z4hAmD9Tj61gkKXXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc2NGE5M2YtODFiMy00ZmFiLWIwMzAtNjRhODJiMDk4OTliMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMjk4MWExZS0yYmZj\nLTRhMmUtYjk4ZC1jNjExYTI1MTlkNzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARBA4cxPNN4HL35oYxR4QTpjZyEbahclLHE3FUAJJJqRtl5LIlUUoExE+9DPWrC\nF7N1j9GmLH41URCsmgyR5JaTo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQlVZvxOJgSxr3T\nWHGzrzNFMCFjADAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGu0\n/26kIBePmGQMN0Ep3fvrk0S2dpZb56RoTj0EQRtCAiB3LTj+APqYNZubCfY8sivv\nIH36nbT4ZlKwI/7rYUECWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7441", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7441` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVsbf8Nr5TQe4oNVOlNBiyxqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkZjI2MzM3LWJmM2MtNDg2Ny1iYjM3LWFkMjY5ZWUyNjY5MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBiM2M5MDctMTUw\nMS00Nzk3LWFkMzQtOWJjYTZiMDIzMTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3rX2dFSt8oVUl0WQgcT0my7iFdKubOomHDX5SR5bNoXJCQXUoj7q40S/wH5J\n+xVYsYuxiZe8ERhikZ1kfl50LKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdskPOmh69yxjrhbKk5yWi5bNNBUwHwYDVR0j\nBBgwFoAUx+LhuM18F2fXxvtLmisUzPTZYuMwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCO/V2t6K0i\nSSoB70e0IHIF/2ipUkyS1YN8iNj8ncIEAwIgG0O5/WPxXXiEjwQDfAauK+XtyNXI\nmj0t47OLZtsJzDw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVGhoYvt6KebEVlH/xVRTsAJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGYyNjMzNy1iZjNjLTQ4NjctYmIzNy1hZDI2OWVlMjY2OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzzQxX7PLpdOXhnW8OdPkm4G8axE6eEr1ss6b8ujLj2bPC\nT6KhQVN/naOc0Yl6CY64Yg2wqoMPfkEq5qjL7+EQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx+LhuM18F2fXxvtLmisUzPTZ\nYuMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZZPh4jTwdFR/OdqFSpV0B04xlKiPZiWZ0la0KhI54YYCIQC8voSORSB8\naSO7EqkEB4itjQCE9jtXieOFrQv66GLlOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAR5ymaCjJ1kVHV3iE6gSRTOrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBiM2M5MDctMTUwMS00Nzk3LWFkMzQtOWJjYTZiMDIzMTVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYjRmZmQ1Mi0zNWE0\nLTQzZTMtOTgxNS04ZWNjZjI1NGRiMzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQKMc3cK9YJaXRsxYzYEFExFIm2mtLWJX/EKaE6mrvMIUfLGavJY/preAHCs3CY\n5KJPf0VRyaVDdKTcTT9Twa8do2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2yQ86aHr3LGOu\nFsqTnJaLls00FTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCC\nnU5u1OYiwJlgQnk7y1JCE8UVbSuI/tsQWANhOt9C9gIhAPOL0qYBICfVJ/WJpW8E\nDTvzpvxonM91tD4lMu32m33R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7442", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7442` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAVzlARXJwY9U5tmpmqgaK6frMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3OWI1ZmIyLTJkYzUtNDcwMS04NTYzLTZhNWYwNzAxNjJkNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzljZTViNjYtOTBj\nYS00OWZmLTg3YTAtNWExMTVkNWZiY2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIJiSFuYtF2BqLugtxMs9iwhjiWOmmQTkbU4XVG4Fs6VB/LDaD1dJTXwbM08u\nudGYWF2WJ7bSv9WFVdv6sAJWz6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs/K4NEslD7p8o5ztsS5GKi40VtowHwYDVR0j\nBBgwFoAUnujjYLK70v8mkKrOpwAVykJumKEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgLb3SqvDEjB8XPbrB5wChtN23afwMXp+0ahPEEPQaeN8CIAqKo45D6KbX\nK0qVlrngMAU0gy+qFUFgaLX9jS7O5Feu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZlkB9uOU++DqfxRG7IN11okMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzliNWZiMi0yZGM1LTQ3MDEtODU2My02YTVmMDcwMTYyZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1D5SmccPoBcFMN6wzO5SySfQkcKjQBp51sORMmBjJhbIK\nM62wzw4OuszgBA288IFhqyidLE8JQ94eOMychZoPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnujjYLK70v8mkKrOpwAVykJu\nmKEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbGiqXBYzWu6bP/N6Y0VLee+vuVayWuEcZUdwi5IaZJkCIQCdHj2CwzJK\nBZYm5DzlkW5S8KPKYgsCQ8CwVaB8UaWjGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAXcJbRTsjDnfgVT5vXXYQDTXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzljZTViNjYtOTBjYS00OWZmLTg3YTAtNWExMTVkNWZiY2QwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZjQ1NmU1Yy1hYjNi\nLTRjMDktYjQ4Ni04MzAyNGJhNmQxYzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQVsKcwdLplCilk1kV0Nj5BycHqwYUKtCn0jEOzJgKhOklwECrJYpHAl5wVa5Tt\n9It+9s1SewQBopR9tNGNQQWdo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSz8rg0SyUPunyj\nnO2xLkYqLjRW2jAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCd\nlDTFJsuJbJNZe+xBJPdTa0ErXPb/Z84socrbZelucwIgHr9yHPuV4jCSkBkApal1\nvlCQm6BF6Km7PwbVCOh6USc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7443", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7443` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAbG8uOdim7iy1mWCkwQQIOAmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1OWRjOWQ3LWExYjQtNGE5Yi1iZWU4LTA3OGNhYjgxMjNiMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE4Mzg3ZDUtODIz\nOS00NjE1LThlNzYtNjkxYTA4MmI2Njg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5xKmBy+dKiG2yVCGWGX7wDgHSV+ZxQ1UX4WO/0pl7piRWLkUXnCnuj7PQxJ8\nMz7E4CGh4CB0qpjgIY895jP73qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhUQ/JfGHGoB0pajWhgDieCPsfCowHwYDVR0j\nBBgwFoAU+B2D3TFYFq0j5bSLnclEf3dmRBkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPdeSXr9N+u5+BQz7VK1469VXBIdwXYKFb7yJvHVQopDAiEA1iR2egDV\n20SzE3TA80wf+RGj6cCKVREoV1CHNQeVIEI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW7g3FfSFpsZQnPAtoZQouQRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTlkYzlkNy1hMWI0LTRhOWItYmVlOC0wNzhjYWI4MTIzYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQT4IG/PdXFfz7qutKMlnEPkNfR9wTspJ5ghSFkFctgeumY\nP7PAMT2Ryuw7+FYyGmwgx+tVEnsiAP3qDLsW5ikZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+B2D3TFYFq0j5bSLnclEf3dm\nRBkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMvilNWUotMtvSXIFUdCwz/ooP873I5ztVeYussVk9DoCICfBfAnxcJad\nmRs44KTa2rftANm18ktkPwA/6r/Thimn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQNx5+PkSqEwcUBILPCmrFndMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE4Mzg3ZDUtODIzOS00NjE1LThlNzYtNjkxYTA4MmI2Njg5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNjMxMGU3Ni0wNTk4\nLTRjZDktYmI2Zi1kMmNlZGMyM2I0YTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARV0+feu2KuTMDt0mNA/MRZakf8jL5hQm9InerkY7n80CH5BC4Rribxb1YZcKvM\nEG6Ci/0KzpafhvJbXQU33kojo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFRD8l8YcagHSl\nqNaGAOJ4I+x8KjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDVa\nSeMOaplQEx8K90Z3Dr/M/fic8W3tFKoTWV+SrOwyAiEA+dFjHqqdODGwoI0A7YqB\nJXxHz2xc8WgJptUY7znIRWc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7444", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7444` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAcNTXWXwXpZ8aItZUxJWx9+tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllY2YxYjc5LTY2NDAtNDUyMC1iYTA3LWI3NjhkZTg4ZTQ4NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJhZGI2NmEtNjAw\nZS00MzBmLWE3ZGItNjU0YWY1OWIzOTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnmtVBUKI2zhbifzbQw84F0xHVxCqRw60J7j4j0nkaynKoNM8HXFIi+0o2050\nLNRcZgGaPhFTXc3yrUlEqMcSyaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmNCUqbwkVnfRpfAZkDzW4oLIU6IwHwYDVR0j\nBBgwFoAUifcPxQFzC8Yhwyl28zoMqwoYvR8wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBV1kfc3V+irQdCa0a5f/bO/5X1DE/G6CGs3Gl+XewlPAiA+R9heV24b\ntv9937+0yXFEwjKRMipB2s40inDPPnP0AA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYAy5HwYgMc9zghTEI/7fO5NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWNmMWI3OS02NjQwLTQ1MjAtYmEwNy1iNzY4ZGU4OGU0ODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7xvmXRPPPme3obbtXWaXfR1lEaPf1yP5zr/Jinjvr0zlU\n5xkNa9VZA7JcwTmE/BRL7dap9IpnaNlCNWZm+tEWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUifcPxQFzC8Yhwyl28zoMqwoY\nvR8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJW/DuVVBFtUz0aISAad1MLeI0QcpxhIfO1w15LGP31aAiEAtpEpvMp4\nQw0Wn6JUG68yKAdVJyhRltOtpzJyBKKWv3E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAXHqVCmrdcBWeEGpruFOp+0PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJhZGI2NmEtNjAwZS00MzBmLWE3ZGItNjU0YWY1OWIzOTU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MDNlZTRiZi0xOWFk\nLTQxZmMtYjQ5Yy1mNDI1YjEwMzY3YTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQZDPACwcLLwjFIGbKiNGnbSvaloF+wXOPuu7gpTSz78t9mO4Du7emgu6xuClk3\nRy4s1/3QSbRawP6g41X+cASso2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSY0JSpvCRWd9Gl\n8BmQPNbigshTojAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHPK\nNmK/AJHHfdbUW1fgrmVAlcdjBiMJuqvRdkd0KfJ9AiEA3vGGA/mG0eXoRn31AYiU\n30hiuSL9mJQgjgZgJp6Ptf4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7445", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7445` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAerZCH4WDX/rw77SIYCcdLrDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNGUwM2NhLTM5MWQtNGVjZS1hM2I3LWQzODI1Nzg3NGM4NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTliNzAwNGMtMWQ5\nNi00ZWFjLTlmNTEtMThkZWQ5MWUzMzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0unI9yyDT5/PpZH20Y1mPYAXbN8VYbBz4ynOrInI7f5YYrPjtN51wzy+Y2OK\nfq8bQdpd/dD+crWwDjJngMB4PqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6D4Iw2X59i/ZrRPu5TGYE3WOklIwHwYDVR0j\nBBgwFoAURHZ8uIamAsaFkLvRvPgqbP8y6KEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIF9QMdnS8oJNhR/OK5cvHttIT9anArIHwoX/Djl9\nT+RZAiAkoYCoGN6X7C3bIAV9u1detS2DxAnB4o7cTHVL6ddHig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbXADj4Nl+L5ysayPnBuea0lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTRlMDNjYS0zOTFkLTRlY2UtYTNiNy1kMzgyNTc4NzRjODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYIYh34jz1n776tT7V5Fbll7gZC1167H5YwIO2NdnnFwey\nDRLmmc+vYur0a+c4LNenDHaCP+bdi5JbU3coCwTCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURHZ8uIamAsaFkLvRvPgqbP8y\n6KEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO0rXqouO8TekURLnSHc4odWWo+3M6lDf65oDR5sWcuMAiBMHq6YMIrm\nAfFCvlgt0yznFzbn0FSx8jETUuRv2lIvdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISASzsbq0Fowj+QgQhyjR1NkQfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTliNzAwNGMtMWQ5Ni00ZWFjLTlmNTEtMThkZWQ5MWUzMzg4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMWI2YzI5My00MjRm\nLTQ0MjMtYTIyNS0wNTg4ODhjOWUzMzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ63n202WZB41Rg9jKAU+q2mRdAuElUatB/Xxxi85ZLcmYcmaDRn+TYU4siq37G\n81dDAgBRumO3dNcNHB5Yt/g9o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToPgjDZfn2L9mt\nE+7lMZgTdY6SUjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIDsn\nKZqBruuZb3/gpmc3QDuUYA6ZXvsk2PWlZ1lPpFMhAiB+x8BB9wfo3q4iPuAeBU9h\nmQFDnT4YCOma+7IDQLjPVA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7446", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7446` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISASrmYnmVS6e1aZCrIjym8xEqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4NzIxNmYzLTU1ZjItNDY3MS04ODQ5LTIxMTVmOWU0Mzg1YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjllZDljZmItZTQw\nMi00MzNlLTllNzUtNjM0MWU1MmUxMTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcsW5abXuIDDm/02kcFJX4Olo5QG9KqzBLEr94woXtMyHuW/d6tuC4V40LoFJ\nWOw3IvOnr5g/x4lVqh+G0o6cQKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUokx+g0gqPuPCaWG+yEbErJryMPcwHwYDVR0j\nBBgwFoAUP+5MKezQxX/RBzcBr36lRYT6SscwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIF1qeXFoXdakB5YMbBuoRV4CFo2hkriRuWiz42iq\nu1w0AiAGJ5Aid7+aroS8WU3qKOkDcP0whNMA4qJ7VEf3WH0dZA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASB/0hxfL3AYYvBGl4vFO78pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODcyMTZmMy01NWYyLTQ2NzEtODg0OS0yMTE1ZjllNDM4NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlJa7LNq5hEWNXEcogwJBECq+VZB32WB4w0WeU4y4So7U4\nbX2x3PC0BBmO7dFqOQWwhnWc2C4XPUQykeHXAmMVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP+5MKezQxX/RBzcBr36lRYT6\nSscwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIRzUjK6PYabdfeYViqklK5Qi1eIpfTudzqQmHz3WKL8CIQCuL77M4OZa\nrrow5SoH+GvGzlYjgsree3ylZfpHu+MXMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAVOr0Zj1Uhdilp2XdVbw0ye2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjllZDljZmItZTQwMi00MzNlLTllNzUtNjM0MWU1MmUxMTEyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMDlkYjUyZC00MmE5\nLTRjYWUtOThkNi1jNjc1YjEzNjZmMDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASJSYssCHF1IkZ+zv06vRLL5HBG/BrNwo2v9fwL09/X9WYoaK43L/xkFNEmMydt\nFmUGwXQ3HeBV6fhdLa0ZqxKfo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiTH6DSCo+48Jp\nYb7IRsSsmvIw9zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCICR8\nGx2P5AGkhvzHW+4e3wbQAEcSlUJu/tKjL2rzvgjtAiACk/L17Ws/wjkoSc1lOHkn\nJj68Y//JD2Aeh0xaYLXFPg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7447", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7447` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAR2j9+rmETNenEwi2gVXXCGBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExOWNmZDI2LTE5YmEtNDI2NS1iMDA2LWYzZTljNmYwNTk1NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFlYWUwZDMtYTg3\nMS00NmUxLTlkMGYtNzM0YjhhM2FkNmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDGidUP2S3hc0gjJTV1BUqvx+IK6cC26/WZMabPlNmWO7GNi4ZbZicskZBXu/\nLCM69HF7TE301zIzC+8mFi0tuKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKA/ZmQ63+zk4nAMfIFNcznBVwPMwHwYDVR0j\nBBgwFoAUNZDH9gQbWtVBGG9FOh5ZRibYJL4wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIEoztEpQp1u8KBthxkp1hnM3M/5Ia2D/MhrZnCL+Fpi7AiBj\nvCyuyzjIPecS69EAix5CcSr8M+euGwNJGqtmXUxvTw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcqYi5jVa+YTutSjTNQdSAIPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTljZmQyNi0xOWJhLTQyNjUtYjAwNi1mM2U5YzZmMDU5NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQ4MgfurguyOdycNE7bIa1AyCPb20RyehHQ3tBkO4rTtie\nlY2wLlu1yawpFwQkiPwrUM7VAFnMicgkVwUdbvT+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNZDH9gQbWtVBGG9FOh5ZRibY\nJL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLpZGM2GAzsJwOXvZGGmHBDiRvwxHlGhZgdU927S4aSsCIFMtfrmjevG6\nOGhf+uyd+JdwSmYbj2CfCFtDf/0ePcxq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAcXu9S+YucEFMfriCzdGfHg9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFlYWUwZDMtYTg3MS00NmUxLTlkMGYtNzM0YjhhM2FkNmRlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyM2Q4MmQ5NC0zOTVi\nLTQ2MGMtYmUyNC1lMTExZWQ2ZTliOGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARvgnOYSfmGPyXPKXxLsw1c1jASSW5RVyd/HnN9v3LoAwqqHlHZ7VuzNexnPsOS\nob04Fx4mBWShXqVC3tmWxmAZo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQoD9mZDrf7OTic\nAx8gU1zOcFXA8zAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQDV\nNK+xCf7UQgIEnPchHbR5k7I4oP6XO2O7nF9/mIFh8gIgHsMXHJDkp2p8zzMoa8pZ\nSVtd26YSD1ZTr443z2edb48=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7448", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7448` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAeYIk2c43CgwceX1mBn5Hfh1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0NDlkYTA3LWRkMWYtNDcxNS1hZDJmLWE3ODRjNjgxMDU5ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzlkYzkzNmYtNGFl\nYS00NDRhLTk2NmItNjgwZDc1ZjU2ZjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELOKrOssc017xBROTZbNdIQJDg7n0UNV3HuoUeiJlM158y/XEmpGKGo9m3Fxd\nL0YhrnaCCBS+Eptlb1TA3nD+WKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyP+HNH7TVB4ELQqFo8kWzWspx9UwHwYDVR0j\nBBgwFoAU1syzpv+6C4gzv2/j4Ohof4zCFwgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDxvFZd/b4+WXWigdwBtHtyES93Lfk6\nOAxIEYXviuAUkAIhAI8TDVNC1IiYaafC1IunPkuEnu7kpcJ8cbF1vP+ZyF/B\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQrdEm9PnsM/JC9w9nTtbCjfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDQ5ZGEwNy1kZDFmLTQ3MTUtYWQyZi1hNzg0YzY4MTA1OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEpa7AZpvZ8d0GSyy6kFoVFi/kn8Cq7la6rOTOvqm+DInP\niQdQG6LYPhAK+bhQDJU3S69ZbNTLQve2P7FpTI0io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1syzpv+6C4gzv2/j4Ohof4zC\nFwgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM4qVvMLowatEe/C3oqQL8xocdYxWbJaeGUzl3D53GxjAiEA11Vfq4jy\nTn67Ca+o6DZjNxO4op4MrP6fUNWg2WgK644=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQdPCYiczZHyB/zNtUXwPgBrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzlkYzkzNmYtNGFlYS00NDRhLTk2NmItNjgwZDc1ZjU2ZjVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MGZmZTkwNi1iM2E5\nLTQwNWMtOGY1Yy00YzNhYmI5NGNjMTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATn9j72OxWms+XesLPKWzZ4Hxwb9GnrFgbf9GM4btiffEvAEr3QeFsKd0PRm5dk\nUM7qNtdx7Ff0ZoVLu1YXKElgo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTI/4c0ftNUHgQt\nCoWjyRbNaynH1TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIDhg\nZ0nIvLoRyS2Y65pnGa1AiFvmRcYTXAmMv7wGYJsWAiEAnhu7HpTh3w7b3ZPlOiiR\n+rIqCdTw2KSSCYJ3bAk3/Ks=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7449", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7449` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQLcdkxRtybrr57QczAqaV4pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjZjAyYzBiLTFlODktNGNhOS1hNmNjLTQwYzAxNzg1MGU1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFhM2NkYjEtM2Fi\nOS00NGRkLTlmZDQtNWQ1ZmE4YmYwOTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzq1WFwYBiRRQzoeCr6UCRC3U+1DdgkJTPa2iMdbvPGewT6QLx3VfsWmFrsDw\neJmj9+A/NScpp2N2Rrl2tXgLqqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGz0yUI42gtb65dzEuDM7bHzc63EwHwYDVR0j\nBBgwFoAUGUyg+/aUoQgLvMQxpesy5wFxaXcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGDups2O3IxDcueAJUnwhppy71rtRMQ3\n89IyWellADeyAiEAh6yJ64oegEPFWPuG9ggwX6EFEm+23Kamow9c36vLQFk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUzaRZlvSj2o8r+XTRJF/2HlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2YwMmMwYi0xZTg5LTRjYTktYTZjYy00MGMwMTc4NTBlNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRK10wcAQYpp/FQZ2GsoBDsQeGSl3ltidtYv++D7trq4+0\n5nXH9TN2eiPHKQ3cpbgizQNxfXmR9CmCqXanAP0bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGUyg+/aUoQgLvMQxpesy5wFx\naXcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOqelTbJ7QYDg60T/rxhZIQk5mOnpGWFTVjdxGxGkGCMCIQDoT88bLWFD\nneXXtO3oQPhEByHgb6kFegvliiyXRyPzdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAQZpDCwv6FRgs7rkWJsXBrr6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFhM2NkYjEtM2FiOS00NGRkLTlmZDQtNWQ1ZmE4YmYwOTQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NGM2ZjFmNS1jNzU5\nLTQyNmYtYWUwMy0xNGIzNGU4NjhiODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR8fdvASfYP3YFaQnXlREh4l/WZRE7t34rFdm6pqCHr3q0BWgTvgkG0g/3cGaQ1\nYofGwG3op8BzsWedo9bbe6q+o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQbPTJQjjaC1vrl\n3MS4MztsfNzrcTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIGbj\nC8vq8/7p97wczv4LhiJYls7Ys+7KH6YN7Kr9DJr2AiBFAa1zDppiPrix6JBV2YmX\n/nmhXepU96Sl0/AWzlX4lQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7450", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7450` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAd0NXiUrzwt2Ha+y/8VAdsQEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmMzJlOTQ2LWZjYWEtNDgzOS04YmE5LTAyOTkxN2ZjZTU1NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJlNjk1Y2YtMGQ4\nMy00MTkwLThlZDYtYTVhMGQwNjA3NzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW9IAuGLUc3OpDhpHh9cIgpehBj79PNcBT8/9pBRWxoN9FzKRRq88USPom5XV\nAsFbRBpkyaoF1ruYbaKLZrp/w6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjhQtBSzmGp98QnF0XVB7+aSL890wHwYDVR0j\nBBgwFoAUVyT5AiZsWlMIg4Oryz0KNChc9AkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIDtGCL0EkDMg\nJGNdD2nNZR4x/MzsfYkaib6f4xho2VFuAiAdhQmMWSfJNW032joZDxcCjmkDs7Uc\nyjclIDkqcyfAMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT3hJEk0gBjANY7j9mdMgt+AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjMyZTk0Ni1mY2FhLTQ4MzktOGJhOS0wMjk5MTdmY2U1NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASieJ1OieGNg6qoX2YXvTn8vjOrhsvLDsSYhFnWZvHQavkf\nqeak8K+O9Mzm4/2mUaJZow4JkGROQVL20+a/GHFdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVyT5AiZsWlMIg4Oryz0KNChc\n9AkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANhIP5265ZxCw2/wb5aeML5ECBKMFIhKh/QJorH/RfTXAiEAz0nZZaVv\naxbAjXscMpZhQ3s2sQ1JelLaQ/rewwqca1U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAZs08WmeeDi/VFAuD7cpZ0tZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJlNjk1Y2YtMGQ4My00MTkwLThlZDYtYTVhMGQwNjA3NzQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YWU2YTJmMS1mOTRj\nLTRjNGEtYjcxOS1hNjc0ZjA3NzA0NWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASoh3lV39RaHhgVVkTDVtAitXfCFPWlncP+Ljj0MkSiYeMj33JxTdXoBeltSTG2\nN7+RNjBypvRn6ZxeZNyA+r8bo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSOFC0FLOYan3xC\ncXRdUHv5pIvz3TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQC7\ncqlMWdi9UI2aNmGo1ywxn+oRl8eQVwe4PDx40ZwHKgIhAKRzOeO8uV2XPrG0fWhR\nxT5MN57D2ze4oep9H5RDRDeW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7451", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7451` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAZbNG7Oxd+4OuzVywgAEcj9TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkNTM4ZGFiLTY4N2ItNGM5Yy1iYTQwLTY2YmYwOTU5NzViNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU1YjM5Y2EtYjc1\nOS00NDcyLThhM2EtYjViZmIxMGQ0NTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED5pxcs+huJDCkk4r2h8OdGnxXvd1HHDZn11xuRlXXzaMATAL5XDSkOOTyUIU\n2Z3lc275fpF/WvvVkOGM56MZvqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSISzUqcnt10en96HVuSNlb+nQPAwHwYDVR0j\nBBgwFoAUc52WrK32zedwU0VKqVaK6JYhYaEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgF9hVQ20OcRQanZD3QFQjanqRmtQqtnlX0WUnRLhfDv0CIGuf0t+bR4iL\nNLuHsn8GVi3wnMjiAVQV5zLh4RJ5IykE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd3oHtmFtMeUXe370ScmGFWNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDUzOGRhYi02ODdiLTRjOWMtYmE0MC02NmJmMDk1OTc1YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsHDZu/DZgaKr6ZkhnXrjxtEAwLENkm+mHPQT2Gwoztrk3\nZra2tRvPMXXdoGMdBzCHjLSeiHZ2MPFQ9ij6i6Zdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc52WrK32zedwU0VKqVaK6JYh\nYaEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJvoxWiJb/+SuiM8EuQYXHrQaRux5s/RGTBsyoUVmsyWAiEAkNkupvTo\noomyb3FvTZWQH+ejA+60G2vTe3mDUEan3oI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAXlJI37iXy/WLhTZmtG4zxVWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU1YjM5Y2EtYjc1OS00NDcyLThhM2EtYjViZmIxMGQ0NTViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiZDNkMTBmNy05YzZi\nLTQzODMtYmNkZS1hYjc2NWIzNzdkYmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARQVhvsrfW7MOK1ejIJU6ms7hkTV077gY4KXAkNAs45wquolmSkS3QNzeSlJWu0\nqgx3jn8DRI7X+gG524xsX+cNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRIhLNSpye3XR6f\n3odW5I2Vv6dA8DAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCq\nplZDvHBwnj3Db6vnHi/LLW8Pl8hFhg5KmHiOZRjrpQIgYiLw9AnSsdEEGruKzQ1H\nyeTOzQPb1KUU3R3MJ+gSz2Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7452", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7452` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAWWd8oROI280G1DDMGOwutkqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMDliZGJmLTk3MjAtNDk4YS1iMWYzLWU3M2IxNTM5Y2MwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY2NWM4MTEtZGY1\nYS00M2M3LWFmODQtOWUzYmJhNGQ4ZDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsndoO3QMSY5Fq+En1BX86UI9nNx+z7Q2Ot/A+StwVG2j3+AGE0QBF1JTbmYu\n8ab33H+SrWqYMSi81Jusqh93LqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcwTXVsUy6Ck52SWAhIjtATn5qS4wHwYDVR0j\nBBgwFoAUhZX8vJLxUhJLnxk5Cwyo3mo9/MowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAND8SxA9LUpYKIyFuSTAXIVyukvRKkxg/xM9im/8Wti+AiEAsBfqnsZf\n2DXOJwn0YxZd+/6p/yVU07YLNIWdKViQIcE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY+qScdCO5j28fJzdYECMvWQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjA5YmRiZi05NzIwLTQ5OGEtYjFmMy1lNzNiMTUzOWNjMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqBChd2SN05jKOaPLTfZ8TsvwW0iDVRRnOqiGv4oKM4caN\nxLew9o5rr2UVtW8tuFbFTLotNQEBZFFyObiyJny9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhZX8vJLxUhJLnxk5Cwyo3mo9\n/MowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIHYGTbHrIcC7Ur54Qx10aO/lrn6PL/ALd8rBuFGZYL6AiEA8787sCAw\nf7FNfMUUrKtVRo7Un8c+u0V8pZzFrGE0ceM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbq1ya5svxRu7K6WpXmJ+Y00MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY2NWM4MTEtZGY1YS00M2M3LWFmODQtOWUzYmJhNGQ4ZDY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZWVmNmRjOS0yMmFj\nLTRmYjUtYWE4NC02N2VmZTQwZGEyOGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR9hQBQh+9reSQamVgywcnSsNUSyzblTTWfHeJGpTCm3sQDSo8mNph9Cvleg/Zv\nuCjDBl9iQ3IJFgZ++UFDQcVSo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzBNdWxTLoKTnZ\nJYCEiO0BOfmpLjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQC9\nfLpKBMQUMYviBio98MHctDK0RcdhmJMQomb/lJvcdQIgHEzB9jtw1U/hu82K89ot\nht0Vh9kDvSRDZy4oWm19hBQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7453", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7453` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAZBgXY/zkFU74SNEUggPwy+YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3NDljNWU3LWUwMTEtNDA0Ny04MTMxLWZjYWM5ODEwN2FlZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVkNzA1MWYtOTY2\nMy00OWQxLWFlNjItMzI2ZjQyYjM4MmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzRHFxt3NIvDOEW8Uxi64Icrrije7Z/h+r+8G1Cjl/BH/HwAUYi6BK7eMKICM\nVt8UvEhmhhVguyTofy7oiat/VaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxeuA6HPHxbWOumQBwH2zlGeKBdUwHwYDVR0j\nBBgwFoAU3q1GuV3dUOX2wnLDXPJPc1XK20owOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDtzqtLiXE3ZfDv83M3bpeH3peQCWeo+X6W2M8jrIL/MgIgOx/bsHZl\nagKzKtUcaxAsdytcupxlAUQ9YTeNn3pJXbo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUnCGPbxvRivOiYSPHGi7gV6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzQ5YzVlNy1lMDExLTQwNDctODEzMS1mY2FjOTgxMDdhZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqZfmq2NNP3mSVnfr8SF2+Y+SWg5yITxVA+ptpQ7aCVKhy\nxsBiMyaJBPilf1k5KcsqCjd3U0KdwWXYvTcC0kZZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3q1GuV3dUOX2wnLDXPJPc1XK\n20owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFXRmbeWVvWDxrgY+W85bx0uVY8P2fAALfpzot5XDH44CIH7FSjkgQHgV\nwDdC8zzOJwmZaImvx6iibme8+EB3gbPe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbxR8/6RlEnd5qdhJBqPluvFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVkNzA1MWYtOTY2My00OWQxLWFlNjItMzI2ZjQyYjM4MmRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMDk0NTFiMC05OWQ3\nLTQ5MDYtOWE2Mi0yMjYwNTE2MTkzYzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQRS7nKqiiWUQ4FmVKLHfbJeWiwTD25jp8USZFMrvNqVvd0e0pqvEbOdLNIZrwc\nJOv2X9EXXx7hmDuRe2ZRnu4Uo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTF64Doc8fFtY66\nZAHAfbOUZ4oF1TAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIQCm\nkbUqumUir5ztYhsXJirECae7Bg3sFu2RuXNovuacEQIgI3rpLt0PBlcfYrded3Ad\nYEqZB67CsQtQdU6CDiKggpc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7454", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7454` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAbM5iu+CuGwd3GH7XpdOPTfwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhYzAxMTNiLWZmNTgtNDYzMC1iM2M2LTY5MzdlMmU2ZTg2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM5ZjNlMzEtNTY3\nZS00YzkxLThjYmItMmRhNDA0OGE1YTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFPRt43FrBm6NG9oLV6tRF0gjrGUTsIqtACSVLGrPy5r4hmmK9JEvWYDu/xRi\nbCxHQHbdAmANL8OYh9A5LHTVoKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+/pSzu4N0zMTJRqYxmAuvgHKR2owHwYDVR0j\nBBgwFoAUSuF9+u4gdjuENMEBduqsQTD/U7MwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCY4Qh4J+wil1y9urjUcvUCby8NVBkVB9+uppYm\nn9WY3QIgELiYaELpt+of6qBUqlSWtuBnBkF3WRCE0mMwvnOYn8U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARpEIguXzkGfIn9X2xm60BtVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWMwMTEzYi1mZjU4LTQ2MzAtYjNjNi02OTM3ZTJlNmU4NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8BPo+D+17FsauHzrzPenN0mg3YlK0w6ZeISii/TNoI11h\n7KUOoned5Ka4YWXH48ADuFuSoOcf1HPekNsAhF3wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSuF9+u4gdjuENMEBduqsQTD/\nU7MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN+QwZGeQC5ScA2vMe4j5hh99W7ec6iILiW7A4WxK18nAiAc8bN7VzyS\nrAR8rwPyS+GjdGcRw7+rg9I7FTqJWrIMVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZXF50R1OQ6nKUjBlR3c03u7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM5ZjNlMzEtNTY3ZS00YzkxLThjYmItMmRhNDA0OGE1YTkwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OTdjMWU2MC1hMTk3\nLTQ5ZjctODg1OC1jOTkwMTk3NWQwZjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASXwv07pmlE7BkGPX7ywOzQRW7sJgBy0mU0n39uA4NQa03046azJMwcNRrL5/Yb\nC895jKHUTlo0eXtHa5jxIsgco2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT7+lLO7g3TMxMl\nGpjGYC6+AcpHajAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0gAMEUCIHV5\n2u/SvLJ59lnit8NkNRyMYRdW2hoIwdsrYzVMir2AAiEA4bGI9ogdhCaOgShJQr2z\noXLYM98/g7JX3Jp7XWUrgjU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7455", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7455` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAa0I1vYY6sgikl5Rksm9d3bCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1YTQ1MTA3LWQyODQtNDk4ZS04NzNjLTYyYzliOTIyMDZiNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzNhYzY3NmYtZGE2\nOS00ZjdjLWEwMmEtM2JjMzE1Yjc3NWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjLl0Bbs3bKAFqHfxNt7pt2YQeHIHcVOaF6LOjM2ojx64ZmASNeg2rLbpedSz\nm5syGYNJAcqjKXG0GMDrBA7LpaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyQS/4fkQhIYR7ELBj4GfMgVzZJswHwYDVR0j\nBBgwFoAUgDa4AX5OVM2ipRYIAmWaMdsFQ0AwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIBZdPB1XmyrZOyu5nPM80o/iFbN2LLiCovCHgmcz\n5UMNAiAYaOUqr7HF5Y4vaUOf1H2+vwRCI/xpMsL22VTr2Tu0Dw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVXOarzzcZczq/wXGip4rSORMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWE0NTEwNy1kMjg0LTQ5OGUtODczYy02MmM5YjkyMjA2YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmCNmktKN+22OXVXOM6qJXqygs/aNARIzpaDZUoAyneV5g\ns3W9FC67DN+dpSDZHizqTMH9yRcmsTCAKMDvs90qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgDa4AX5OVM2ipRYIAmWaMdsF\nQ0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcc9Q6GsBRjCDgc9egzkDMvIt/KMC2zhhFO2wGUoiTn8CIF3Zs7fdiMin\nK6LBBb4PnfqnVH8mC1M4Zo3uf2qVQ8bP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAcCnrgnWT9qwlM6SXeo2ve2QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzNhYzY3NmYtZGE2OS00ZjdjLWEwMmEtM2JjMzE1Yjc3NWU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZmZiNzAxNC0wN2Nk\nLTQ4NDQtYThiYi1jNGQ0ODMxYTY3NmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATfc3vxN60uJT2S44t8DfhKLycYuu4tj/sYilwF1T9MNZSaKEbKPo//j2AlYsYG\nuKelGHN/9dv/JWCZIiQgK1v4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTJBL/h+RCEhhHs\nQsGPgZ8yBXNkmzAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCa\nRQFdVkiyhT9FBClNuLySSkqsOcyW+CxhiW/hsW6b3AIhAIhUp0e1kgkCh4w2SmGs\nUkpdqfBIyPALox27LHwyYbVp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7456", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7456` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVVbtO/HXyCEa6VcvKBOt5wEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiODU4OTZjLTkxY2EtNDhjZC1iNjBiLWY2NTk0YmEwNjQ5NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWY4NjM4N2EtYzE4\nZi00ZWY1LTk1ZWEtOGFlNThhOTVmMjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiEJJlQuIAeIESxpneTjmz7tTGGszvXN/rWUvDRMHS6EnISd3iYbFW2pQX1ak\nfaqCfOTogCkILC1506ytqyGRtqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJenHlVixpDt98i/6tdH514wj7YQwHwYDVR0j\nBBgwFoAUdIcwMflwlmy1J89p7+oYtD+yb1gwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIAyVQKoIZs4ESAp6g5qs9sfjhJ/tinBw0GOfmEHkjnhIAiEA\nzbMbkIAIXN5Rj98Tt9uYJwrby4x663knuX5CzkaV/50=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR5Ra7eAk0qEqRtBHPWyKcQWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjg1ODk2Yy05MWNhLTQ4Y2QtYjYwYi1mNjU5NGJhMDY0OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdQNw1L66a14ZTMqSn00+puYzKOil1f23ZQ2jNsrTLRoa0\nGxDOb+h6UzgCBOMJHzazjH7oAehNnsI7QUKz/pnWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdIcwMflwlmy1J89p7+oYtD+y\nb1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSr7B7uXWikzgYRic2h/RsUoIcFRtV7jNNmvFilYoypoCIQDcVFTSnsEi\n8lAaBvXFZzCxPxvBpCX2KI6SrXlzLwtlgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAbCcE6vkJEhrmzyUyFz3xdtmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWY4NjM4N2EtYzE4Zi00ZWY1LTk1ZWEtOGFlNThhOTVmMjYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5OTdjZGFhOS0xMTNj\nLTQ1YmUtODg2Ny1hMjE1ZDgzODhhMjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS5aecmi2pdjB/FZf5R1mM3AkBl1a2CL3GjBs8CBuZ0r21CRnBf3vipJLhtHe4g\nHmPmjIN756KmfNZHWUFQ3uLRo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQl6ceVWLGkO33y\nL/q10fnXjCPthDAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0cAMEQCIFox\n7Cy+LW4ngpdDIRcXVcdDpJLMb1+uLqcuKteXiOawAiB0vTTTQsx6o0IG0+QJmweL\nWJ1UAHxoxFCuM1oEwOjCYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7457", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7457` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAS/JoDtDeuP1WhDpf8KdvuO+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1NmM0NDVmLTZlN2QtNGMwNC1hMjQ4LTkyZDFmYmZiMzk3YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZjY2IwZWItMWFk\nNC00YTVjLWE5MGQtMDQ2YmU2YzlkM2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErTOpq6l9zST9JyH+A8mE0g1Vf+geRnyXRyGje/xwyUunLI4LJNUoUmX5yHP6\nN3Lpu1kmyE2e1sD+WQthY9rrBKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt6n3uXXscrvS+zOVCmZDegfoKKowHwYDVR0j\nBBgwFoAUb9HbGKCY/zXunLKafNqktroDpO0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCyUBPGJudBMeesDdtZgSSgxwQs7xPU\nXAqPZpcHMNPcpwIhANlu0+nXN3/lFXuyfhpeJNlIKydM3FaWLvvB7np4hb+a\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAckGZOMjgm1VsKPFFyM6rkOuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTZjNDQ1Zi02ZTdkLTRjMDQtYTI0OC05MmQxZmJmYjM5N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATr1sTxkUTJpagOtxyufv5BwVSb42QauSoGeMojo+I0DuqB\nyHuz1l1MT/0XMQ8fEfIlKtprxiTc7ALAo9m4D5U1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb9HbGKCY/zXunLKafNqktroD\npO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANDZTfaykDg799JO475Krm93tmZtAryOOpEElHLNeIsmAiEAzRVcvmtI\nOhTkt5clJancitEMz27DJU8SeTrGTfhNA0c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAc/8ujSESwY9tUZgaT0JmShyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZjY2IwZWItMWFkNC00YTVjLWE5MGQtMDQ2YmU2YzlkM2YwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NDQ5YTU2MC1hODdm\nLTQ0NjQtYWUwZC0xYWM4ZTY3Njc5YjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQzrhsP5gEQtmLR3SHqmhUT064B7O195shEkQah+hX8nAjEOBlieCd1qnpsCKnH\n/gXx/uKdftQLTrT1urxMW+bXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS3qfe5dexyu9L7\nM5UKZkN6B+goqjAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQCp\nLfu6ztySOHK73PBlB8mc/zLcWhuFSTzbUIEAxBczigIhAI8YUW1h+G3VWuENx8W6\n3FEuKGThTxOGX1GjwqP5xGnJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7458", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7458` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAXPVtkYkMrcJkU5GrWO/adUCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1YzliOTQwLTc1MjUtNGZmOS05YjYyLWQyZGI4OGY4ZjI3ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk2ZGJmYjMtZTJh\nMC00MTFmLWJlMGQtZWRlNWQ0NjdmNWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcTZNbitp3+muTWADYRodRZR+/aVg08+GvsJHFrQKLT1V2g/uIdIyXkFNOp7n\nOoCloy+U1KiAN7xZevjD9mYI+KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNsNu1nMwfU2QjOeTin0BcPJJGDkwHwYDVR0j\nBBgwFoAU7s83GFusuZhoTpBWokZYT9RlpRgwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIEtOrQVLfgBHlEQz/zqoSIregHtd37wz\niVIrAx2Ox6S9AiA/yfvUbLyKYdQzSIJJUS4k3+2YnQpf855ruslW2ziVtw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWPszf5CFs+WSOIM8ri6xfpiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWM5Yjk0MC03NTI1LTRmZjktOWI2Mi1kMmRiODhmOGYyNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYYrMkyD+v82GAbUd8+IuqVOoaAa4p/TQpYXKgOJTpuX8/\nQa0d3LXFdLkb40YbFKTB4BaeUYHCXlSARQFMU+YMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7s83GFusuZhoTpBWokZYT9Rl\npRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKRf0J8nc/PU4vaDrKsckpukE3UoHdk5dTlz8GLUNgn4CIAUI71swL2wm\nPlwV8qSwL3rZjx8cd5HaJz4UEGGekcKi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAe09wq+fAI9P4UfhqZUcm8pXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk2ZGJmYjMtZTJhMC00MTFmLWJlMGQtZWRlNWQ0NjdmNWYxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYmNiMGQwYS0wNWY5\nLTQxMjUtODg4NS1mN2I4NTA5YTZiMTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ++1IABhyG9jdVR0V3Mgw7UnHeS++k66XLJhfFI70hn5giB/BIfSo0Bf0z+jvy\noSkeU65QmiO9n+zc2sqGmJUyo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ2w27WczB9TZCM\n55OKfQFw8kkYOTAPBgNVHREECDAGhwR/AAABMAoGCCqGSM49BAMCA0kAMEYCIQD5\nAYgo6kDWnGimIPUkAzR/ZqagXCW37OM4IzHAJSPrhAIhAI+Y5l/L/H+ZDxUcknwx\nLlF7unN32uhnBXYP1Go1g0NC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7459", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7459` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVSwd6azh11+YTgDra0CmkPqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmYWFmN2Y3LWJkY2ItNDk0MS04NGVkLWMzMzdmOThiZjI4ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU5MjJjNWYtMGJk\nNi00YWQzLTliMjAtOWQ1NGU1MjE2NmUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoZ3thp79q1mVHh6EyMmL97Te3pbH8R1hCf3yiEaItHYpWLGK2o634/6SRXmb\n66I+wa0quowsQSP27SEyQNJ8N6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPy7BVvgPAb/6ZfkG9OfKjttRgHPMB8GA1UdIwQY\nMBaAFBW4/BvXk+SvAZWZ4Hf3rvxtvELkMAoGCCqGSM49BAMCA0cAMEQCIClpVqmN\nUecL2UkyNBEbZ7E5j5eC4BcVcepatVu5/bgLAiBVg0+pzmzI6oyFm1rUdktL8v9P\n6vn3zssVPuXUMhIzHg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATUo9BOqLWQQ3zujaTPARH1aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmFhZjdmNy1iZGNiLTQ5NDEtODRlZC1jMzM3Zjk4YmYyOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWZm1pqWSIZQ00M7iFT1uIFHKw1yLpqH03+Bme+pzykK3Y\n6AittvWRj6ILX79GkM0BC+YL/se1k9nWxsgokzqPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFbj8G9eT5K8BlZngd/eu/G28\nQuQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaTHFQO6/+9BcBf4ohGLXKlP2aSZV0f9FAxkgtbq3638CIQDS/xKfLpYe\nb2BxwfseivxkgMdRXJ2ge4zhNf0wW5bIEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAbMHJ+Ba/yXErxsVLsqZ4S7IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU5MjJjNWYtMGJkNi00YWQzLTliMjAtOWQ1NGU1MjE2NmUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMTVlYjkzOS00MjNl\nLTQ3MjgtOGIyNi0zM2QyMDAxY2YxNjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQexQhVPm79SZ9XA230TkmlpCW0FG2dpfZQPZIcdD5XDgbGu6Bb4HNykwGcFjx6\n7VKcOMoywJtHacMx2k1ZxiM1o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT8uwVb4DwG/+mX\n5BvTnyo7bUYBzzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBQd\nS3XSlmlAQOvp1muOjNZQRRQnX6/yfZqRDGuIwXUbAiAK+BfHwe3jy4mPsXuJUOkH\nlXXAYv01Ar43PSoybnwUSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7460", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7460` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUwEEi/v4YBynkbeMmCxss/rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwZmQ5MDRjLTBiODAtNDFkYS05OWJjLTIyMzZkMjVmZGZjODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlhZmQ3ZmMtZTRj\nZS00MDQ1LWIxMTMtMTNkMTNlMTMyNjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEku9AJuMQvo9FUArde7ozbwEvF2u2lTeo1MWdyrHkXbJ1Z4KNBjRXbMNEddP3\nlVeDxYoawxwRLOprnu0doLip16N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLrzp7Tsgwb/rrFCL+jQ4UPozrtyMB8GA1UdIwQY\nMBaAFKjQxxB93CglLa7AKlmF6wB+ad9qMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAuCpDgHDyeyyqNxCwJ+OCvmmfcXogXfo/\nw7lWkrom+50CIBIrVvpheo9+Eemj/Q1XJbY/p7B9/3pJXji2fXf9yCmB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZTvP7q7PgeknUecrAW9j+RTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGZkOTA0Yy0wYjgwLTQxZGEtOTliYy0yMjM2ZDI1ZmRmYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm83xuGNc1eHQr2EQyeySa4CihWUfO1O4l1bW7aocIPQwx\nLplkQUN3YW9MRW/nyfpyHHjRGF5ox3uPcqmSMyQco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqNDHEH3cKCUtrsAqWYXrAH5p\n32owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP+mGUgZ0Lz937ytzkdJ6jtlatJh6ZEW4eIE+5XsNGbqAiBtJheZbFoi\neYbdCQ4bhL2JaIR1occ6PaxQFXpKxCCmJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAd2D4x4t5XTapWeYVphqkViIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlhZmQ3ZmMtZTRjZS00MDQ1LWIxMTMtMTNkMTNlMTMyNjUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNzgyNDA1OS0zNDJm\nLTRjNWQtOGM0OC1iOWE4NGRjYmM4MDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATjcU8JCx2hp9DKiWxzHWFr3vqUwQgks/ndQHZDxiL11g7uG/Cd9XSEoAJjknGA\nETioywFsQCnRAfJ8kLeMjFyIo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS686e07IMG/66x\nQi/o0OFD6M67cjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIB+n\ncKwTuuEEehOBj4AMBsidB8+fWfw6geCFtwJ5AXQiAiAKANjY9+kuyiQr3vSFgsdO\nGKMasGjBiqobSCCME9hg+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7461", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7461` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAboIIKcT8PaeFb8icZvpvJw0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwYmMyMzVhLTJiMzQtNGM0MS05YmE4LTUyY2JkMTg2NWIyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFlZDgzNTctOTEx\nZS00MjFjLWIzODYtOWI1NzBmYjc3OGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyS+rnG/+s2cZ5uKNMzoo9ERwIpPjpLi/6ad9Ukz8shiiXZFzHQaz3tz6RHPq\n5DvMg0qgMBXa5W90FGlfhbVpqaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOspzzADtw79SWjytgive6BgruMcMB8GA1UdIwQY\nMBaAFP2R9jniy+dPYrwEZqLVNeMx21YvMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBa9OzlEu354jMW7a84nMoTmnQplneLcagD\nYPmdWR/5wAIhAI7lCnDN+u0iH2bHNZJl3J2ZHA+nmXjyBT2RTANOSV5n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAesG9mxatAs94236JBNS2FhYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGJjMjM1YS0yYjM0LTRjNDEtOWJhOC01MmNiZDE4NjViMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZtnNoBhQmeltRrdU64+C7HGiRodqWAOxejuHpxZNVZnJ/\n8Oh/EWhzHBrPXg2flSIEd5McSnGsliBL7eQBWavgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/ZH2OeLL509ivARmotU14zHb\nVi8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLLtIJeeEzgqEuwhdyEubIT1w7z9C5hENzEXNArCsv6cCIQDSmrqm9pGh\niGwzA+k7PC9ppuGeYSTnQH08u/r+HxhFwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAfLrQKJ/3E5V2xD7nzxT8utxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFlZDgzNTctOTExZS00MjFjLWIzODYtOWI1NzBmYjc3OGUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNjI5ODkxZi00MzI3\nLTRjMDUtODcwMS0yYjcxNDQ2MzQ0NTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASVqRI1//3lwlZvf5L9t+IIA3XgFIB/4T/6RwNFR+aGvpfEphwv5Yu2I7UhW2BL\nVn8QyuPDEhRVUVciriGsrO8Vo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTrKc8wA7cO/Ulo\n8rYIr3ugYK7jHDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFWR\nF4PnNlZujrByOq/eSyqTAdRhLmkj1OfJpRFdmHveAiEA4/OTaa7JHOY8L9VlW7fO\nisgmKfgWW9jQbTAcTVktvao=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7462", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7462` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISARGpFx299sJVoKq3ke+wtAH/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2YTRjZTE4LWI0NzItNGFlMi05OGM3LTUzMDA3YjFkMGM4MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk3MDUxOGItODg4\nZi00OTAyLThmYTgtMzUxNzkzNWUwOWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+w6ZyEReYMMiyZSFMLjlh9heOt/Kvuo+pIHpIMWpJhNyR4qLWAa3aghHw7bo\nflqSw2Zhd/eZbg3OLSebkHUDuKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR6ijdVaVu20gZBcdel0ogAqBi0FDAfBgNVHSME\nGDAWgBSHZUAna7hgIwLAM6Fr3OYu5SlTiDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCICmhlRBFpUbBv7h1VHpIqrhgvPrIZ\nXNzhpQbCf9Mx3QIgQTWYntvA+Mw1xZ3WPcJllfuPMzpTwl20N7LSD6jzws4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbhwUpAPtjthm8pgQUAkMxtgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNmE0Y2UxOC1iNDcyLTRhZTItOThjNy01MzAwN2IxZDBjODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTkrlC8dAVNbKJmgKpRtyaxcPFOtOlSWrKI2+R9LNCtVpD\nuJ+aE4EFn9rsd0PfE3hxLcS3kp/cOxAN3zFwdhERo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh2VAJ2u4YCMCwDOha9zmLuUp\nU4gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX5dG2SgYk2tsP54Sb3Czy0EtY5GkUsBw+T+6ZosQoEACIQCi8LwzIR9P\n0m797vryK0iMAyDWOSjhs9Ud3vGfmqnetQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISARtZrIgXj4TqylVZ3PL619UUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk3MDUxOGItODg4Zi00OTAyLThmYTgtMzUxNzkzNWUwOWZjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YTRjZDYwZC0zNTky\nLTRmZDctYjk3OC03NjE4NzgzYTU0NjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR0oXou+2uFTEbVCw0wW+2BQ22SL3uDZZM4diwk7VNKeXVYAaDeTLbPpkXWvPee\n3j8JkRAKgLUsRchcRyhaoB2Fo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR6ijdVaVu20gZB\ncdel0ogAqBi0FDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDr\nyMH7PBc6N1QAJG8db6t6EQlGLQTNKmC9LS8J4sLQagIhAOA6IK124RxiNS7L2CMt\nbFojDsCiE4gv+I/GXc+iWuhh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7463", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7463` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAaI9f7p7xaHTSalqEji825DeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwYTU5YzQ4LTA0MTgtNDRjMy1iMGMzLTE1YTY1Y2I4ZTBmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTJiMmFjMDktOWU1\nOC00ODdjLWJjYWMtZTI5OWU4Y2Y2ZDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0d9GMxD4xs/TxYnt69lhrkr8im9QGJThY1ubfOALjLN9KSorH5eCa8CbTuC6\ncxuK/T/FrAuS5aPZzP2mj2JVQKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZqVi3yk1lPWgfrEJ5dLSiimu84gwHwYDVR0j\nBBgwFoAUIgdgXnR17rP1q9J/xCXvx8J1X9swJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAmwWhF++DLSTev\nIq7epXgG6MJ2oxopyWPCK82ZYFqgnwIgGM5DUl9ANFjSkwmewE40hOf5Mi9HQpcy\neBIxAfyjR80=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ508SxXsihL8CSBKbx5NRLTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGE1OWM0OC0wNDE4LTQ0YzMtYjBjMy0xNWE2NWNiOGUwZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTSYXXkQXmJcinufGqAJM8k87J4m5gYYYfb6I5RSpVNpBx\n2mAOjOADqSCTpoGfHwEhaFPT0GbvkZp56rnkKLwgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIgdgXnR17rP1q9J/xCXvx8J1\nX9swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJH5UMfJw4HwoDPRpnbu1pjjJb0D9xcgSLfgVMVW6ZwMAiAegW0FKxKu\n2jeuBMzBz19bifv69nlXvFR8P6TWrY+zyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZbWvYa3xh2Yte7Hc1cEnMmAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTJiMmFjMDktOWU1OC00ODdjLWJjYWMtZTI5OWU4Y2Y2ZDRlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZTU2ZWQyMS02ZmM1\nLTRkYmYtOTU4YS03YjZkZWEzMzI1MDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASOsxGkVWs7G+K2WRGFHfpT2Nq/1t2BXSCyvzaZxRWHqtvp/6V3bgvsEbtoSCHS\n9cArVHaaSvqVVPnhzwrfJqGdo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmpWLfKTWU9aB+\nsQnl0tKKKa7ziDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDD\nsYHYHxMpVXhZ6SWebb8uMF87TikLdoyYDtJrhZShxwIgJUqQCk6x0DH4YV0zxzaA\n5I3Ci30gTTC28+ww9dFiRPg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7464", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7464` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISASmLfamaaqksNWcTOMTdLOTPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjYjljOTlhLTU0MjQtNGExZi04ODlhLTU4ZTYxMjZmZDZmNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQ2N2FlNmEtNWYy\nYy00YmNkLTkyYTAtNGYxYmVlZGI1ZTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ+eKziVKtUfd6E6XqkPpe7FhhuXH4BKMNpYiaL5rifcxy8zpIjMVSYD8IWGG\nGwAlkgrcmwul4gFNSyrjoqBKb6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUasMputnfxeb2FT+gbVaeaG4k+QswHwYDVR0j\nBBgwFoAUdMTqUDQvqLB3mUOgsF4cK0WnbBYwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBRnXGl6Mzsf56T\nhHO0VZoYIU/vPXAMa2/pydh995bkTwIgPUhqoVujaiXBQKoW/SMgmiAyCJyhR9Wq\n/MvkFLwFx+g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXd8Aa3ITjIdrwxxPahQHFEMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2I5Yzk5YS01NDI0LTRhMWYtODg5YS01OGU2MTI2ZmQ2ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyxG1FYZCZQj3n+cWWEWSW9D+vNLBxBR+YfL3F8TreHXUO\n9uRto7yPWWSqdhwuSYbRK+SnwvFy9+d03Uyq0guBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdMTqUDQvqLB3mUOgsF4cK0Wn\nbBYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANzZOSW38FxcwvwlKEiFNPHxw2Wfp6Nn1jGl8zyPE/0yAiBuS1Kfghul\nATb9KkMs8KC7ua4f1wn4GonzkGEhC8H6ug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAYaqk4VumbopRGIpoBsb1dZzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQ2N2FlNmEtNWYyYy00YmNkLTkyYTAtNGYxYmVlZGI1ZTk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMmMwM2ZmNC1lN2Fj\nLTRmY2QtODFiZC03NWRjZGIyZWZiNTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3W4uXRm3b+fwf2SkikLDwsEfh5aYoy7QltU2ovIbvkYj1f9JlA2aFXfuI0I/s\nVHjgQ1WPT0GrCMdzPvw2h9Quo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqwym62d/F5vYV\nP6BtVp5obiT5CzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCm\nL5dse0wQSEgD2Tui+Al4UPt3otAgGf3a9qDQ501AVQIhAMGx6FkatMadVQ7xf6PU\n6EGQvUsnLkkWi7Vjbax+aVkD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7465", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7465` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISARyBOn2wEJPsr/BEfp/7QuoWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxMjU2ZDBjLTRjNTktNDgzMS1iZmMwLTc5NDcyZjg3ZGYwNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg1ZDJlZWYtMTVl\nZS00NzZkLWJiODYtZDQyNmJhMWQyNDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0SxupsU1D/AyyVn6v+dOQb8NJbDTrXMSNEx+fkt1bKxfMkTb44bpDXGI7D/N\ns+H32ybm2JujoR18ZyD4cm+rxaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURsbOkqsCorgICmVDOQPmzCviHoMwHwYDVR0j\nBBgwFoAUES27okTPGLafjLeeuahigwAjG74wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBoHSJXyi7mob47xEdexzhT\nRWAKIsPpwDwMqqmgsif0JgIgST8/dTjbu2mDcD2WhjxgbL+VD/fUE/d3XC5cPrFI\nJuI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAflYAeTcLSbNFPymCGJ61tIjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTI1NmQwYy00YzU5LTQ4MzEtYmZjMC03OTQ3MmY4N2RmMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg/b6ClUWMMgfVkKFy2pDIRdPBtLF/DyQjjfCf5LQi6jAj\nJeizn5TSgRTeajGXp1iwS2ILs5QMKeIsWLqhhNtSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUES27okTPGLafjLeeuahigwAj\nG74wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI/uMKQ++V8hONguzTlNXVWTFY7yCcI5pjpq2a8U01+8AiAS9uFfhlko\nlan5BotyJOHQUQRTJFhlVhiiBYwD7jK4lg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAc06i7DIZZc2fwFBCnALn+srMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg1ZDJlZWYtMTVlZS00NzZkLWJiODYtZDQyNmJhMWQyNDU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNzFiZThjNS0wZTkz\nLTQ0MjItOWY4Ny03YjM3Y2E1ODM0NDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARW6Orvz2p8T8kVjVVSec2cCAyxXxRHQmIVxh92yfuvy/o+Slak6gIJ+AyZLrNQ\nQjLNa3rdbpYUpGCsTr3YbMMFo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGxs6SqwKiuAgK\nZUM5A+bMK+IegzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIFa2\noeFvVzXJBuk2IVJ4vyZdpdrXXd2VfR9nrzjGwoPBAiEA2/nU5WgpgmJ8rsVTP+bU\nXmi/GRDCkshp732Uqt4c4Ow=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7466", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7466` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAU4Y/1vuDc7x0M2E3quNZ8AEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ZWQ4YjE4LTQxYjctNDNjYi05Mjg4LTNmZWQ2MzdjMzIzNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FmM2FkZTgtNzA4\nMi00MTM2LThhZmYtMjYxOWJlZDQwMzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUwIP7GCdpmLokl2/Ty+bYEeG7dXB/r0+ywx3izBRZOqfckGOxgt908w7Ur8X\nro9xMLdYKpEfcQPLd/n8vn4k4aOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjlzrMGogtNV1z/2nAV+rFpPm3pAwHwYDVR0j\nBBgwFoAULGji4ftOz/Awlx567fLUfId32XowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBLTevm\nw9Zcx4vEzWjCblRHMtkt3HcTcUPXU5Sz2VsphAIhAIKXEElK3VFxUingC9GZ+LYj\nEDkcrjqd8t+HkL4GkSFE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcKJ035yMhkcr79ODVn6ELO/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGVkOGIxOC00MWI3LTQzY2ItOTI4OC0zZmVkNjM3YzMyMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATw+jMaX5awENHNAbmIi9THkv6o7hFOXB1mLxVMqsRI1g/E\nHqiux8XUNECp37ADbJ3gFs14YJSEI7cC+K8rjaxeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULGji4ftOz/Awlx567fLUfId3\n2XowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOBFiv4wS2N/Wk0hnKK1tBmE12G8XhAC5jvOHY6NTeCbAiEA4m0F1K17\nVKNshFiV6jCeRZd0Gg4VU1uVlTDqqTnV8/g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAVpZ8y74BZL2QAUtb3Chlq/mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FmM2FkZTgtNzA4Mi00MTM2LThhZmYtMjYxOWJlZDQwMzhmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YjdiZGY4My1mNjMz\nLTRkOTUtOTY4MS00ZjRlYjNjMGI0ZjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASXa6rb1VL0wHrebFKHRUwuixn8ENa5TpInws62ai4PgJ9K6OffTqEouv55jBr+\nkZDDyr59ZDZwlZnYZahuQ7cSo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSOXOswaiC01XXP\n/acBX6sWk+bekDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDl\niEDftu5/TdvJDg5+F2GO+dsxJsXWqH0+m1JdzUMoDQIgUV/28ac099P55t0LigUF\nyodRfUz5w8c7ua/leUPFjjw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7467", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7467` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAcDJ07F0oI2Kw57F4fQYAIqLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyM2Y2ODk5LTRiODktNDFiYy1iODJkLWY2YzgzYTZmZTRhNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNlNWM5MjgtZTQ1\nNS00MzBiLTk5MWEtYmIzZmU3YzZmMzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWd6KjL29Z/e7vTVmW/TSUT7qo1jKsRrSYVL70A6PlU1EGS+sxsKxDN6rmNFD\ncHXDiIsj3kpJjPt73LJcEl/PSKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwJ3YEApP0taOCQDOj+uDlhpiTD0wHwYDVR0j\nBBgwFoAUvvlqOuxrWtbuvayMADXbXPJbyswwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAoF/i\nmVUCqWLwF9HgWW5R0roQO2HIxSL4NDQajmMCnX4CID+Snro/0D2Wc/NUfKfTKDKu\n6KDxVs173JR9rhvcE79N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARstP8vC7B89bKUswX+kiWO5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjNmNjg5OS00Yjg5LTQxYmMtYjgyZC1mNmM4M2E2ZmU0YTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWwUyAkhMVk7Zb8LVlfCvc7ESPpXQS3BsEhqqgFJQj1MPJ\nObzqC3HJ6MYUDMcZSvfKhBkKdn2C/6igdip7n18Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvvlqOuxrWtbuvayMADXbXPJb\nyswwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWGNe95AjD23QPul6bzetTiLsa4NLH7/xiADcZFevquICIQD6V0Bfjz4t\nc1G5FPljp9qUiG61Xa0yVdWDS7pF8yZ2rg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAUI8GjTkhKIcYwmj52itTVOqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNlNWM5MjgtZTQ1NS00MzBiLTk5MWEtYmIzZmU3YzZmMzQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMGIyMWJmYS1jMTE4\nLTQ2ZjgtOGIzYi0zMTBjMTJmYzZjMTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ5aUOOe6yhUZ0+/oMUE1HHz+9GbRPp2nehnh4iU5WCNg/U/34M740/tTyFlW1a\n53IskLxpaZUJA+DtNQYLWTwuo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAndgQCk/S1o4J\nAM6P64OWGmJMPTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQD3\nv7HG+Lss0w470Dyr3mFHs/fwbtxd77CMcQNpPxNE2AIhALQdK6yg7iEXt8+xCGsV\nHvaUoXhzijmdpnxigev2tJpH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7468", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7468` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISASyZkupgSMfShO78icXInkYUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhN2YwN2I1LWNhMDUtNDJmMS1iNTgzLTkxMjNjYTUxYzQ4ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU3NDE2ZTktYzZi\nYi00MjIwLWEyYWEtMjk3OWQyMmE1YzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENmZvY1GZvI9WvvEy0NeQHasmXOZq77+DzmCnstYSqiMEwQhBaruBuThv20qe\nNlVoHn5s6+MwwGs4qNOd/SkfxqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFB2zSxa6Vh8p2KyDpOgiHdo+tH+8MB8GA1UdIwQY\nMBaAFHHgBhqy1/2aMEf4jFsrI08fm1GCMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAZU2BGpUERYHoJhw+GSk1493cgF1q0Ocxz\nLN1275r4NgIgIX55XxKsgZSKem8ytBx3i6uuH1jlG5+nHDXycmEb2qU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAchHfoc/G141qT3Hk8rTRrmIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTdmMDdiNS1jYTA1LTQyZjEtYjU4My05MTIzY2E1MWM0OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0nGNst1cLnVq9FwkAtXVGLiyQ/krJJekhdRK0tBRgnxQL\nP/iePGMrXPhHtqk5S4QZrPyV5NEDH3sIeu5AJfWQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUceAGGrLX/ZowR/iMWysjTx+b\nUYIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYEiwItUXFSvFLLnshdVNQ2n7Bj7n57G1dnmbmPWnPb4CIHhMbGRtyYFo\nJFoAOdIeRPGI0K9scs1vcZ0pUj5OaH8u\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAWf80NeegoSOI5PYvUIe9ftnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU3NDE2ZTktYzZiYi00MjIwLWEyYWEtMjk3OWQyMmE1YzZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhM2RmMzY3Ny04MGI3\nLTQwMjItOGNjOS1iZjE1ZTg2ZDQ4MTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARgTU894Iebr/QyHcSyT0FFz99TowypaHwAAJRJ2owHbLImxDZYbZu1qo54pJAb\nQx/dKKEZLfMw+X56oxYNRWpNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQds0sWulYfKdis\ng6ToIh3aPrR/vDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIEjm\nxnRKpzICww0XCmBTG5o8dAPirQSTrea7fpsMMrkOAiBfXYXuWIZFhfAGvfmH39n+\nBSG4Jd4MVQ6BAlIuYpoJng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7469", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7469` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISARhIoX3KWtYIVLPUckV6SC9uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1ZWFkM2E3LWQxNTQtNGVmYi04NTJkLTAwYjk4YmEyYmMwYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQ4MWY0NGYtZWUy\nYS00Y2U4LWIzNTctNDI3NDRmMGQ3MTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqvRqeU2umao/B9x0DQrPzd13yoYTGvGYpwEANUaoYmUhUt0rz3Q6NRwqq7dX\nI5c+YyzgviQtSBNta/Ob/3B2LaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9WqTN+spx8v1FazTntlLE6BjtmAwHwYDVR0j\nBBgwFoAUXdr5dKpAaOmGGkuuFWM8/YO9SkAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgCLkKUz7xCIo4\nvtmK1T6XBQ75rJQscd7iH1jUnG0m97QCIEjILsbZeROJu73mMPlgwTgbqZPiqQmM\n14GE/pEnfO0/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfDZbwR5vMR6kLxRZt303InWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWVhZDNhNy1kMTU0LTRlZmItODUyZC0wMGI5OGJhMmJjMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4xwYhpuPP23wNls8bxap7224YDCtaWFZzcJ42/CZP6XZk\nJulixSE8C2S82ips89jjm0D+HkcE0IJee7aqIISSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXdr5dKpAaOmGGkuuFWM8/YO9\nSkAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKQvQWrBAV0FSiXx3nzr205jsRf9g7YsMjFZY+0pgTv+AiAg+b4yGBcf\nnjfLQTV4qEUkqXrM4UvFmhhesX6681qaGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAW+CR+Rj8deqNZ0oWqcGsGN/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQ4MWY0NGYtZWUyYS00Y2U4LWIzNTctNDI3NDRmMGQ3MTBiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYTM5MDNmOC0xYjcx\nLTQ1YzgtYjZjNS0xZDM4YjgyZWIzNTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT+5yw3ReMeZk5xq2pp/8kOGBVzz/gDNPJAa/cvyi++cJebp4VyyVUjkr6UpLcu\nTpod7bPuvf0XVUgzQYU+cUaBo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1apM36ynHy/UV\nrNOe2UsToGO2YDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDA\ns2IAkJL2LNJMaSYSN5ubee7SSHQi4gnYZMtqTTI22gIgLakooWXBQ+3A3F/d/OMf\n3kWoy2fLrffpV5sN9+hiPAM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7470", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7470` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAXP5zG3y6Pr4GQGA+umsO/PEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4MTViYTI0LWQyZmQtNGQ5Ni05MDZiLWFmMzhiOTJmOThlMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUyOWUyMTYtZTk4\nNC00NmUxLTkzZWItYzU2MmY1ZjY5OGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYlrrmC4CtTYD1lV/eFzNZL/YPY6YmPHkKknzH1W3VkYD/lWB5H8mMZW1B91X\nTQwOmIMqT3kqLCwsEw4qwuacS6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5LiFLmVjnqhfi0G3slT/3Ig+dc0wHwYDVR0j\nBBgwFoAUZyuz1oybAergPiUt/zSedqutrTIwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgNt7sboN0SNSU\n6udx4TN6noQv3Zym2y5IvomrXtmCNe0CIQClQe04iefhXdQkMevzJ5J4ZrcqEdEP\nGWq3L9svbSbiPA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASsGH0wAE3zknGqq46Xw3SpTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODE1YmEyNC1kMmZkLTRkOTYtOTA2Yi1hZjM4YjkyZjk4ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZrBgNqOM9vP5k2zs96ygu2ASoV3e7Ate3A3uUmMqw/wq3\nT8GFlyA1wOaflzfsvPLB7WSyuesE0u0F98+voICpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZyuz1oybAergPiUt/zSedqut\nrTIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfpoNSPkc36fGiPMm/n80JGzUQQ0jtlH9GuA7wYd20NwCIQCwpAaDJ9jc\nFsNDSMiTN1isZ2rlTCj/TEgBXFlgyOG0Cg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAeK44RzIbhpLLM+wJ1vZMQy4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUyOWUyMTYtZTk4NC00NmUxLTkzZWItYzU2MmY1ZjY5OGIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMWEyYzBmMC0zM2Nk\nLTQxMGItOWY1NS04ZTlhNjBlZTFlNDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT/pOCxdcwbO//tosSbIYUZkhV+28opyLjRHM+yUZ+ucq939b8FzFuRiy63wi3B\nuSDT5VimKsg+tl3JAazpA9bTo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTkuIUuZWOeqF+L\nQbeyVP/ciD51zTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDU\nqd0HqsjrqYBzZApAEkIxOYvGCnSY2IfI9zma0A/vAgIgKMTwFJZ580MeEYIGhNP1\nZK/k2HAsiGIrQt0e16IeX6M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7471", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7471` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISATVaJulhcFB3n72zQA5EWbzmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0MzcyODEyLTlkYTUtNGYwOS05YTIwLTQ1NDkyMWI1ODJmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUyOTY3MjItZTIz\nNi00ZDQzLWJmYTAtMmIxZjc5OWYzMzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf929wAKLumkgmX0nlBJ157M3GTMIoSyiVApSCNiJ0YcIcBa6YrTmO4gq+Mgw\nwjxSLmAknzc3DbC1oukF0/GUJ6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVyx8tT/YV1QIzVMrnvKQuH+V4y4wHwYDVR0j\nBBgwFoAUXQ3eRhXhV4BQsN3FP8WE8k6jGDwwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIF1HvFMgMucY\nav+76um2eDAykUvvluI8BL0dsTWI623SAiATO3dGjAgmgsugy5Aqpy62grJyWf65\nvQRKksjEJIrLGA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS8tSNz0V5ZKMRCdzrglE3+jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDM3MjgxMi05ZGE1LTRmMDktOWEyMC00NTQ5MjFiNTgyZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtnhlLqR/Akdkv5a+WBQvqZtSFo337zhb8u2oJKn/hpe9K\nhbatBqLcEW8smPKOHuQq4dV0Fcoh0WEhmy0KtvYzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXQ3eRhXhV4BQsN3FP8WE8k6j\nGDwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTsNXgkaD4w6U8JerXgxnRFDaFFw/Z4FoIEXh/T+3DX0CIQCURnkrhwot\nBywe2LSBB8TSwswWiSiOAzfftofHmUIciQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAb+/OxnfR50taReGajgtPNiLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUyOTY3MjItZTIzNi00ZDQzLWJmYTAtMmIxZjc5OWYzMzlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMTRmNjdjYy1hYmI5\nLTRlZTMtYTYxYy1iZWM5NmE5NGU2NDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAREALAqlNFaY5PHb97P6nBjIh7LCXIQuT4syejBH+6iFJXNxN6xr1WTYavRF3Tq\n/LFDro+CuvPp2IX7exMYVkHJo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRXLHy1P9hXVAjN\nUyue8pC4f5XjLjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIFc3\nKeyuMeF8eTOuEbvT12DpNoE9OHav0U5bUgTWyQUeAiBA1Az2h1r4dyApog8Kp3Gi\nhILzL+pgQHlB30ui894oYQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7472", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7472` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZicIPkuogeo1v3H0x7KgCLKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyZTYwMDY3LTBjZTYtNGNmMi04MGRjLTdhY2I2MDhkMDFlYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJjMGRjYzktNmQ3\nNC00MjA0LWI0ZTItOTc5ZDk3YjA5NjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMwpGSA+cEoeDBgcqzuQ9TsZe2jXmKAqYsD9wm8RpMJ/P75Q+ucV5AMnfDR9I\nH+5mfZhu+bIMAIpUotQcgI7QCqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8tE1mFf4IBP/skjO51sva4HwJDQwHwYDVR0j\nBBgwFoAUSROGBHRqy2QGoVxAzVsH/+GP/9QwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCfVMkLvbcZrbMuS8LEdDmB6qQbHhMq/QgqwSsNrbO4PQIgNfuDhSR3HE8P\nF4IZ/QrBwOoFKXijR8tvcNPHvPwHlYM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUx6dwweiNRbiCs44xCHdCbUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmU2MDA2Ny0wY2U2LTRjZjItODBkYy03YWNiNjA4ZDAxZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjyGQ4XbeBIePfrkz/dSpr/tKXI+vxVQEGpxY56EQ4VDPL\nupjFfkVYKkwBgEsydWY5OJP/OTPzfRDWBqrq0b11o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSROGBHRqy2QGoVxAzVsH/+GP\n/9QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKPjQztFfo3TPm7C1orCP00ebqG9itKwqcjNkr46t4pkCIQDJX0ztZ5NZ\noyMPZuBCd2nDNFkNs1QjM1Em+17Vm0E5uA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAVIr1VkgL45JtIu/w6BdX6VsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJjMGRjYzktNmQ3NC00MjA0LWI0ZTItOTc5ZDk3YjA5NjIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZGRmNTU1YS0wZWQ2\nLTRhYTUtYjg3NC1kYWM0YjM5ZjU3NGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASsukRnkgL3IouHZipZRgC6ZNNb2H2DvbLb+oQO4ZG6BKMQDNMjETKkkcwov4Ex\nqrQAmFaBXk8JN0Llb59+8XFPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTy0TWYV/ggE/+y\nSM7nWy9rgfAkNDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQD3\nby2YeQyAhz50Rph2hgVzndzXKUgatdX0Nj33ew+segIgQ1WXAGHIQ1DsXBCrHVAH\n5nMfF660EekAoOj/TxZml2A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7473", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7473` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAee1zySyYyvUQWwUVLMD4IBqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzNGQ0MjMyLTgyOTAtNDMwYy1hNDA1LThlZjk0ODcxNDNiNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThjODdmZGQtZmVi\nYy00MDljLTg5YTQtZTJlNDNjZmM5YmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtLg1/86kK2HSXN4Vugws/t9m+c9fdmojWxMhs09oCaSEnmfUxIkRSnZsruGa\nQY45F/2BNIPky179ORQlxzdxMaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhXY0opqUa943QXkhE68/bJZUavMwHwYDVR0j\nBBgwFoAUgLLhxNIiS3ymrwgjK7eUkeow7u4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDnSFz2EVoo475192rp/SXdHCBeZMaGAElRNMTV+ImeRgIhAOakxp5LLaoo\n6PdKA09xZx6ukWKOFt2smzjrHDtQRftN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQuMMLirQnUvl85ITG+sP/TtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzRkNDIzMi04MjkwLTQzMGMtYTQwNS04ZWY5NDg3MTQzYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGoPMbQGXNSLK4l6Ac8ZxpXjfT6zvQaDQd51lLFmvYqkYA\nDw0jiEvFYITn3ljPzjDhiRp8qjXazmAN+Ed4Nz/co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgLLhxNIiS3ymrwgjK7eUkeow\n7u4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ0th12+Ui3rTUOkTUOITgSh2cExqQ+MWStg9XQiz5r4CIQDe3DbJtqdP\nL/g8kMTdMbFX81aCcIumVV5pmQZLNc8fYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYV6Rx0x6CG+gzWadAC7FH08MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThjODdmZGQtZmViYy00MDljLTg5YTQtZTJlNDNjZmM5YmY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNjNkZjQ3YS0wNDU4\nLTQwY2UtOGUyNS0zZWY1ZTQ1OWUxMWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQwPACRQ1dboqkkfZKZqsTIb0cQ3FGaawC+q9urKceihHk03mwFQyRAhnFNP+aW\nFxbJE0jAA+TRb8101wiGEXR2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFdjSimpRr3jdB\neSETrz9sllRq8zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCA\n8xJBzdc0f5NhrSzkj3RepAdDWOYb1gzW/qNjg370HQIgQJnzhTgGdCJY+WkYjUjh\nYfDDwp0fWoEQFew95v3Jl5A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7474", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7474` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAboZpJtRki4VHd+pPsAJluibMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkMzUxZDllLTliZmUtNDE3My05OWU1LTg4NzVjMzI2M2RlMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y5MmEyNDYtZGJk\nNy00MDM5LTllODUtYzNhZGNiNzdlMDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW2TPf1aDd5XHExgyolnVUlvREc667aHgcM9zpFddQGZA7cc1QkrsTPQQ9rcb\nJxyI/2Yw1hN5ZJVIZ+oQc2JlT6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWbUwR+wWANvWotU2t6gdRicjtA0wHwYDVR0j\nBBgwFoAU8w+0cQk7rJCI/Hwww6TEskZ23howLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFIR\nnO4Djtg1Sc/9RCF5iinz+E6M7r9vci2GjCee6IdhAiEAvvjgn0LpyiBqNlK/dgSE\nvSKEah649Q08ZA8QunbyQ5k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaJLUJu0P6L8D4Bf+ZxxRvezMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDM1MWQ5ZS05YmZlLTQxNzMtOTllNS04ODc1YzMyNjNkZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShNgb5ihuRj++TlJAzDgty6TiJUcdXBQpkGj8UCgmLUxsi\nyEWN7PgW2dzNDhuLIySJhFhA+n7tOpvZAkNi5WfAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8w+0cQk7rJCI/Hwww6TEskZ2\n3howHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFuR77019jwB9T7qQAmwBqIJCKBl1InyWno9roG1HQbYCIQCVctEhcxYv\n4TfkJxiUpP+f8yihqXnVHMRzsNN4LPUr/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAVf41/55G9+IJ5SQLbSwqL/cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y5MmEyNDYtZGJkNy00MDM5LTllODUtYzNhZGNiNzdlMDU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMzk1MjQxMC0zOWY0\nLTRhY2UtOTEwNi0zYWNkMTI0MDM3MWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQj54GVHWG4JghpogvAAejbpFJT4USd2sfIj22hldkVPK5PixWj+iBfZfIBnIfj\nsLJrSQsyOhGcToOPArxFxdvHo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZtTBH7BYA29ai\n1Ta3qB1GJyO0DTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIDr8\n/FtuIT5MnzSOrapEwZVXH5SjbdynHp1nYgkAvMFHAiBtbQjrmJkVGtumqvFwSZAO\nJCsaLZM8VU7zyEFDl/74Sg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7475", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7475` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAUNL+7cDq5Rgv0Y6OlJaWTowMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlNDc4M2MwLTBjNTMtNGIwNC1iZjZmLWJlZTY2Zjk5OGY4NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI2NWFhNmQtNjM4\nOS00YmY1LWFjOWUtZWE3OTAyNTExNWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE06Tgn+z/eIgz58EmnTSZ4A/ZRj8y0sYlhgXpdvcKJoms6TgO9sPzCf+jrYes\nAdCtGTOgr37yxYh30RJ5UB6BMKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN8L3fUn5YW+kkvdydgLnvC5rEHEwHwYDVR0j\nBBgwFoAUH3zT0hyo9Y8WTV51ban9OhBIs7IwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIDxuMfJBknjDwkiZUrHh4JPZkjx2YUBdCqcQyW1v05c2AiBrPfUI\nNfqIDO5RaML4iCwc9g6Ja9MDFJUsp9nrKqIgHg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARED320N12vAiTDYNdZA1xnnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTQ3ODNjMC0wYzUzLTRiMDQtYmY2Zi1iZWU2NmY5OThmODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbNWMV67oesBJpRZo9KWVGw6Ug9n8arIyG39QulSZjHU/Z\ncy0LlQdgp6YPdBXj5Eb30PncBnqlhDBg1oloNOteo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH3zT0hyo9Y8WTV51ban9OhBI\ns7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMAR0YDwJjXXMWXpwpRkpdVk21kmI9HqLrR+/qF52LHMAiB3IVKVkw4/\nIZbGSXWqnM77KloIqIx+xoGexnIjSDxi0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAR7o3YLRA9syp24/DSed/gxyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI2NWFhNmQtNjM4OS00YmY1LWFjOWUtZWE3OTAyNTExNWI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NWQ1Y2ExOS1iOGU3\nLTRhNzEtYjY0MS1iZDkyODU2MTg0MDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASVcOwAdm0saa74Is4xCt9XrYd8bo2QF//CnAXZWqwCVwA6MEqO2HY2Vc1mzROa\np3S7NroSynUbQFrQ9xsuOytNo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ3wvd9Sflhb6SS\n93J2Aue8LmsQcTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDO\nqdPc/5XgtOrvhemWY5euOllt/UyJveN/RNE7Adu2tQIhANTrNJDvTtJRlPKydt45\nSuOU9l2lQ0NyUyySWqGoJ5pW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7476", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7476` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAa1S9mReaTP50C/TIbmyFTD4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4OGEyNGU0LTgxZGUtNGE1Zi05MTA3LTA0MmRiNTg5NmMyNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk4Yzk1MzctMTJl\nZi00YjFiLWExZGYtMGQzZWY0OThjNzAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZfRWvLJNN2USHmF+kAYe/tRxIR2fkI8RTNl0Z7XMXt2EGfaBSXgDV4o8qxkv\nJNlJIvjWMYmaPoAXO2Mh7zMwHKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQVA/t55UOp0yergfdbVhP/meRiQwHwYDVR0j\nBBgwFoAU/30bO0fXGhtcQfpnxxWbNa8p/XYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDE31zubtkK31oJyUsHRLaX39oTFTCXhXpWr1rhrDLPKwIgPnRh\nIUKv7ircfb8MMGRXYi+4Lfc4608JBoLcsWjhZmc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATpTSzIYyrnY5/kKbgj8r96UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODhhMjRlNC04MWRlLTRhNWYtOTEwNy0wNDJkYjU4OTZjMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3UCoF9ijsvvyf9J1y25IkaDN7ldmBbq51EjOiEms6hECt\n3cZENndKTe8iWKZ08PUGDJ89uO92AbTKDbNccIr/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/30bO0fXGhtcQfpnxxWbNa8p\n/XYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdp+SjycIQ7LlTAZGYZan07DH3PlPeSqvnTI5ICy7LxICIGj65xeWrt28\nwDJe1rwtGvZbddifsa+ElAaIN/sMKOQ2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISASWuAY9HhOMbuLegY5koj6iMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk4Yzk1MzctMTJlZi00YjFiLWExZGYtMGQzZWY0OThjNzAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0Y2Y4ZjEwNC0yYjI5\nLTQxYjMtOGFjZS1hNTQzYzVmN2Q2YjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATEqLLo19DHdLK6EHYRs3X4SN39mAfV+/Zh9rYnTb1kDYhQmiLKs4/prkQA4S8V\n2qz0ErHJRmhIHpcwE04i7k9Oo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBUD+3nlQ6nTJ6\nuB91tWE/+Z5GJDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBGu\nWpuEqAjxA8XFMCRAi/bQJF+W4ihT62Q/3kJm0B4IAiBKcCJ+SgO4GeiVh2+aW8lW\nF8qWIGvQkjcY1BP2EtFqpA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7477", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7477` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZ+kI7lhN8TnQxL2M3Xd3wWLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxMDQwZTEzLTEzMjEtNDQ5My1hNTBhLTNkOTdiMzI1ODEyODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZiNTI2ZDktYjA3\nMi00NTk0LThiOTctYjQ3MmFlOTlhZjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsYPg3HOnqEN2jpMohnwanAY9VYFOT5esw5M8Cdmk4GO4l5f33hkH9jFEP4qB\nO29qTg7uTWB3JMfxHXF749RCTaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFE4jEg+Dx7JVKbilp3DiVSoCYewbMB8GA1UdIwQY\nMBaAFHytWQsGmJZ1lZgWlnJGyaHThFgrMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA8M6z7qjMgg2fNt5UtAsrzF1Aoka/Jn99\nwC5t3oE2dCACIQDyxv8n0v2IuOOgk0szpTcBhTKFRphOxCU7DrwMk9vYjg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYOnti+J7QlqiL3J0pbsPTDrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTA0MGUxMy0xMzIxLTQ0OTMtYTUwYS0zZDk3YjMyNTgxMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0qtOUXL4fwFq5WNwrhRJ2nejFK2h8FA06RbiFe/FLcUw2\nlGXCLbK/ZGsgNB/U5u+ezHxTnpqRTigvZoLLLzQZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfK1ZCwaYlnWVmBaWckbJodOE\nWCswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOs08oKulA1G3YkcoGSjPCgANXjD6sPLnyYcU6NhaElUCIQC1bKh5FErj\nfDp8pef8WMheHc+MG5CyBrTuvwRZmi8Cqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAeTcss4T9gGec9ct/jrdBjOaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZiNTI2ZDktYjA3Mi00NTk0LThiOTctYjQ3MmFlOTlhZjAyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MjY5N2VhMS02ZWJi\nLTQ2OTYtOGI2Yi02ZjQ0YzA0MDhiMWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS13jPpGIr3eeiEEWyTx/lu9C79SVOvGQYPuWyDGgXLqQkAbzVvLXuXxPzrydpq\n5htkcFsh8DTOFLh4j2EPw2Mno2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBROIxIPg8eyVSm4\npadw4lUqAmHsGzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIGKI\ncK0ewoKVUnxIUDl/3HHWpWhxiZkGTgcXSSc/yIBTAiEA8klIvwIaEYAAZn5kULUg\nm1BsUCrqRRkjcyD1SMx/Z3c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7478", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7478` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISARAr9r9SagpFXeetx248qIySMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2OGQ1NTI4LTZhNjYtNGE0Ny05MjA2LWY2YWM0YzE0ZjE2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU4NmIwZDQtZjI2\nYS00OWU1LWFkNGQtZmI1ZTkyZjRlN2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEztkQ0qS/vJyzjhLE32qWQGLxxuHwfS6b3AF9alAa5eYgp+kKMMhC+4QybeZu\nIUoC6IMnbC2IkC1KVEY2KE2j2aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+lGn3PeKMZL81Fn5vajQtsuAx/YwHwYDVR0j\nBBgwFoAUs3LWf8LYJ9a1T8A0RZgUKO+7AvYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgAejmm0x6vg39\nX13jxVE38C3UMR6z0J8GXld+hxiHm58CIADt8qtlz/90fIDiKQF7EuNSrdBf3iHU\nX8obV9/Oob4h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUk3Va+xFkDT+ozdWlqS3uiRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjhkNTUyOC02YTY2LTRhNDctOTIwNi1mNmFjNGMxNGYxNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1v/vrKaOJbCfX8cbVIwk/mEnS7OigEvPYuOQXHrhKvtLJ\n4BReoGSVpDAOyOdodiqv1l432Vm63tLvMaHuDNMdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs3LWf8LYJ9a1T8A0RZgUKO+7\nAvYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOstTZ0flFxrzG3ro1AJr4vyJ2IwR1ULF15qY0CS2P/UCIQD7ay9S8ayC\nxRR1zaEl3ErUyQlj6FAgpUnsEGiCzwf9Cg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISASqCYPhIIaIpydfiIP2uQDcWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU4NmIwZDQtZjI2YS00OWU1LWFkNGQtZmI1ZTkyZjRlN2E1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZTk2MWE1Yy02YjEz\nLTQwYzQtODgwYy0wZTM3MzViMDJjZDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQhIuN5RSuHteZZs/28spf5sXQ678ClPaIbMYgsbxlfKZWofrXxaiTTPqSaaBMn\nf3GliLrrNWsLL4xa9FGTaeZwo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT6Uafc94oxkvzU\nWfm9qNC2y4DH9jAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQD6\ntm4nQXyw5qs4xjv92i0Kj4+uSmjW3nVGSUoqJKWpvgIhAJiKyKDDcthGzDE960Je\nd3SjWT2m+UEjTweLWymZdVHO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7479", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7479` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATWc8yVQxgsfeRIQh51OppOYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwYTM1YzRkLWNhZjQtNDEwNS05NzIxLTc2OWYxM2JiN2IyODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU2ODhkOTYtMWI5\nMC00MDYwLThmOTEtZjg4YmRjMTI0NDQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw2aa4eG7SBp3hZiXQs1aV6FgARYOUT2rsswp8RLypCx27pUtGf2xEKbm2MJf\njZSLfoF5+YZTokPqT3nyG9z/DqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMvB6p8qKLtyTaER9ZKCoE+iq9rIwHwYDVR0j\nBBgwFoAU75bJnKubrQ6WDEys3INwO9lmtJ0wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPh02CTD8r6U\nTpeEyU/Lkf9XSCGOmOPLFj8qhbmO2AJoAiApHp0dMEJaCZQbhMF8dbCgKCEfb5bm\nU5BzLvrWyu6fDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZBOhvOwCb0i1hp0eqs/ILv+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGEzNWM0ZC1jYWY0LTQxMDUtOTcyMS03NjlmMTNiYjdiMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmn5kvcS/g6HMCpR7l2jlZFdVmer0dmZ2X0NB8NMO4vIf0\nzCYVBBWANB4LGWfVKqYP2TlBZ3dHlQoDSd15625ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU75bJnKubrQ6WDEys3INwO9lm\ntJ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNmmdTCO9iUD3O6xL/cKRrWQWJIl9DSoitP037gX9c7kCIQDFt71Amd3e\ns449/t6loh/A9heJlwo2mUSBRFxmb0N2hg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAfhTF3+iHvuL5y9PfC65u/WCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU2ODhkOTYtMWI5MC00MDYwLThmOTEtZjg4YmRjMTI0NDQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZGJhODg4YS03MzMy\nLTQxOTMtOTM0NS0wOWU2ZmE4NGRkMjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARiD8/kjFV6T4NQWsTGpSjePxc7OO3TJqJZIqztcyoD1hpOnw4BPSDDpO19Z8Kr\nKVjiaGY630AzaaEunHOjqsMHo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQy8Hqnyoou3JNo\nRH1koKgT6Kr2sjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCICoJ\nhjSXws45VMwMQ0nbOkDu0z0hzkkx2OzpVpN4aNt0AiEA7Ug3zSromW0OCP30yQz4\n54JivdommgEiFi8dvEZ7t5w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7480", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7480` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYvOwgQwcF9gKJUUWhFEW8pLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0YjNkNzhhLWM4ODctNDM0NC1iYzJlLTEyYWIzODBlMDZhOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWViNWUyOGItNmVm\nMS00NzAxLTg0OWItODQ0YjAzNTZlNDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzPPJc7HWQfzjUG23aW0iRoby8bLR407HEe4oM/Nu0fbqp1PVF4740K8SjvyK\nIfh8jD2jhVzP05zhakv//dEioqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPVhdSiGtVbdLOKK3/awl3LYuwhAwHwYDVR0j\nBBgwFoAUEMCPW0QGM9GBga8AEre6acEWGtQwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCtgnYU6Sj5\nqNdAnHspJaBp99wPOUcZH/UW+fZ8CK7NGQIhAK9ayVazGdtx9tvQRf8qoYUZl5jZ\nREVLcMsl92tcydQ+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATRq9mY2O3F+FbnpwBSgkQxQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGIzZDc4YS1jODg3LTQzNDQtYmMyZS0xMmFiMzgwZTA2YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQ/D4alDYIwIdRbO7PzRYN6XPXOk/lUVsmCZci7dTbZZbE\nwEt8ZCr8NgXPZo7uDtE6A/og9E+730qkvOfJulmbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEMCPW0QGM9GBga8AEre6acEW\nGtQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJPfCxuMdnT074dh5n9oHu9UK91zQfiEGjAAYOsnlOW1AiEAw/ICYvru\nwqJrfTt97k+ghX/Fn7GUO8/TI85bLtrhPAQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAU/hOMfKmLu4E/deoTuBeiabMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWViNWUyOGItNmVmMS00NzAxLTg0OWItODQ0YjAzNTZlNDBhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNzYyYjMwZi0xMzVm\nLTQ3MGYtYmMyOS0wNTFlOGRiNDc5ZjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASltuP6KC3lExdIJxFT9kyHXUHMx4XMOInDcOvkS1nugHesVisOym8J9Ie5j6A5\nCWFVXDLKW7lMdMUhTL7pb+Hqo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9WF1KIa1Vt0s4\norf9rCXcti7CEDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCq\nyO9CoD/1pkD4dTAvovGjDy3xb6pQukS4xdVUvULhTgIhAKbC99UeM9YvldMzZaGO\nJOZCloUyiSwnLIPWNudVTmzh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7481", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7481` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeq+DK6cmC/84zz/9OTkdhu6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1MDM2NzQ5LTI0ZjctNDA1Yy1hY2Q3LWM4ZDNkZjc0YjE4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNiYjkxZjItNDZm\nZS00YmFiLThhMzgtZDIzZTY5NGM4ZjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsXw5TWrMPDoosjIoiT636Jz6IPL1LMf4Pr76aZp6+xphZMf1DuQDu361jghZ\n8JYk+2UY16OrGYB2AmsPz71RRKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8VD8qjDdU/9QiuOA3fQ7O51fIaMwHwYDVR0j\nBBgwFoAUC6ksL5tseyxArTLBXdcfZ9k2Y6owNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEEAuG2YdzOoNEosjxRjSb0HhXSMp4gdlQjSElQQY2fTAiEAyYP//c+oBVFm\n1irfbzmxJA1ROzVkvg+4rtoVdWnlQ10=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcwtsbBZbkgu/aK/SLnJmSFnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTAzNjc0OS0yNGY3LTQwNWMtYWNkNy1jOGQzZGY3NGIxODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6UVtWYlpbO+CxyrPCiRhEbjKROw3q2Uai/xhhA8j/KTjX\nK/X5pRlOshzml1B3BGbrHMtOxiVY9BtttFk9SdMBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC6ksL5tseyxArTLBXdcfZ9k2\nY6owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALMvYMlK+3DGRMMhwnZd7gB23uNv3K5gRyhRqRgnEclhAiAS2VNWtLfI\nLmWsRDIgPbOUeLkhoIswof3fT8yDqp6feA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAa3AjGxnb2Wbn3M1yfILT2VnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNiYjkxZjItNDZmZS00YmFiLThhMzgtZDIzZTY5NGM4ZjU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNmI0N2VhZC05YWY4\nLTQ4ZGMtOWQxMy1hMDQyYWFkZGE5NTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT3dPmhp8DbOTRnII119ZpwXAqeCXnw0RSuWvQgzYRKDVJtgA3BPBiqUMGYleT8\nDa5EJw/EjGZmEI8qHqMA6I2/o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTxUPyqMN1T/1CK\n44Dd9Ds7nV8hozAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCG\nlsMQ78X47S3TZHY10r7aj4f6E60UpHicKN1nj9w2wwIhALBgLHomu6Kwp/dbnLZs\nqrslVibKmQA8x28ldu/todUp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7482", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7482` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeFBJqWkfEbAx/SYCI8f1Z8yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0MTYyODI1LThhYTItNGVhMy05Yjg0LTc5ZmM1ZmVlMDE4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGY3OTNhNTAtYzU3\nZi00ZjQzLTgzZjAtZTNlMzVmYzk0NDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwfwc/iDV98sHmlgdByZ13+ja9ftXgIIedgYgr8UNYZtd178pgWKv9dj7jX3A\nTZfKgvgohKL216GZNsq7evAmZqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGsJOli0eONHSMkKHhHHsUgUTvJcwHwYDVR0j\nBBgwFoAUt5hgF5NZ2+P1c4MJDqq1/0zEYkUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIE4yC39I/aFsW4Yzq3N+wSxYlh29LwKKAUozG+pZeSHHAiBlIq1YwL47uAHJ\nAOTdmy5+5iKyc7Do8Cj7ZkEPdNMzsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeM8rq8kWYj3mUsVT/h42WjwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDE2MjgyNS04YWEyLTRlYTMtOWI4NC03OWZjNWZlZTAxODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQS1+4Z8kHh/CqjNjJoB21K6LUJqQJUqwauDe/e2r1VGbp\nxCJpPqdBCUp6WI0WHPcj96QnFUTbMRNB1khP9/aTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt5hgF5NZ2+P1c4MJDqq1/0zE\nYkUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFEOiu1e+a1vBR7ajIqhTEfWGRsU3dvkaRzp35v3K0UcCIGf5JdSDct2Z\nLFuGCQpQhAS4YuRpn8x85241kwvY9Zxz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAX/rwCMwd8yLs+U6hZpo0zgHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGY3OTNhNTAtYzU3Zi00ZjQzLTgzZjAtZTNlMzVmYzk0NDY4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZjE5ODdiZC0xOTJk\nLTRkM2QtYWU1NC0wMzQ1NDBkZGYxZGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASdVmG1DY8VDi4NWaRcaPar+krZLqoYX9+CbWVYcOmHc4MJLc7pkJEkWXOyNzCz\nsQyiqR+hU/x2J5EvaUsI+6aCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQawk6WLR440dIy\nQoeEcexSBRO8lzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIFQC\nJ0xXaSIut4vVspafJlgpB5HOdKqVaMZE+PnKhC/NAiA4b53HTJYIEp+aScp44nMJ\nQEoSLPj8dWfCtxenu8dcng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7483", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7483` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISASKkgJ991YmobRywHKCDQKPJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZThmYzc2LWJmZDYtNDNiMC1iNjA3LTI0ODBjOTdmZDkzNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZlOTg1YzctNGU2\nZi00MzI4LWI4MTktZGUyZTU4OWUzMjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3b/SstRbOacPSJUH8IDAAa7s8dT5tqLuwSprDIpNbe4+BaUgrMQ8UeYoAEY9\npXmx+he+fet7lGcutRSDeppSG6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3BBwINOMVYRO/VmCtN3Gr3rjN6gwHwYDVR0j\nBBgwFoAUxUl191id2WTmBsdB286maD3EVtQwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFMJ\nGkfMzSvT3NspYHfrwizMYckwEflN6K/V+yZfGG/NAiBoVVglX1LCDAlqf4T0Mqel\nWoYR6wWh5CUaVAkUQCuznw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAShaw4uvYVeRNkvpVZq0HZ5rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWU4ZmM3Ni1iZmQ2LTQzYjAtYjYwNy0yNDgwYzk3ZmQ5MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlriHoY7T6ox7Ms39N0OrWMPMuZmVAVvAZqh4KZr6+1hwR\n0OqrGxurlzptwB7zAAcbsmCUK7bQos9fsC+yqRrEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxUl191id2WTmBsdB286maD3E\nVtQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgch/pwp9PrEBILT93I8e9rz7kpNE7r8AxhX3QdVI0NR8CIQDihA4K1B0/\nfjb0ovXAfUuwemdwMnZOk3GHplT3YOy0vQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISARED2W+TKntgwGhDwlYW/l3HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZlOTg1YzctNGU2Zi00MzI4LWI4MTktZGUyZTU4OWUzMjQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNGMyNjEyYi0xNjc5\nLTQ1ZDYtOTgzMC0xNjFiZTRlODFlNTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQaeSwclouKLrr07twEC5NQFbU+1gIjYAFqAhLggyqbTMJE9e5qz6d8FSU8qtAy\n5PcTAbObMsVePiRPZWBf+E4Go2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTcEHAg04xVhE79\nWYK03caveuM3qDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGe4\nDiif73lUwC6AT06XmSt1KsO2twF2XH6lr6OdHYW7AiAxcwSoxsHcHym7UXbVBKXP\nw8Qs3FssNVB95a7Va6LO1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7484", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7484` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAa/aG47YuIZws7rGmSz838l7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyYTc0YTUyLWNiZDMtNDY5OS1iOWQxLTNhZTM0MTQ2NThhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJkOTUxOTQtNzk5\nMy00NmJhLTg1ZWYtNWRlZDQ5YTk0ZTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMARYYjTtBAwwkp7C4M5vp+3+RLU3Q78PYwt5pM1tWIf1WTpr0hd32P1WbT7Q\nDJ6xHB31ZwEst9xcZ1yxJFq0C6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiZzDPjMm3quW5T59PmKbXsdcGbUwHwYDVR0j\nBBgwFoAUGvmY6W5gDHedJoUBgMl8ob9UjaowOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICXr6n4uo1flVdM8v6+N+ssfu2TIpQaQloHokCOLmX6JAiAPtfBm\n/ZDtQLLMk1PgvD62iLR+uJCuhhEVyC3WHT7yiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW+4jFp0Isvr+vrJ4jg84Gs2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmE3NGE1Mi1jYmQzLTQ2OTktYjlkMS0zYWUzNDE0NjU4YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2kzcFvAQ81OlSxPyJv19Q2zTsJQMFr0XhchGpAf29Gdnf\nwMhg2Frny2Vh6TLQr/scNxBml71+KjSyyeFbi9GKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGvmY6W5gDHedJoUBgMl8ob9U\njaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUPWeuwqMcD+ih6ZE6ZlM4yfEXPlnYtYYlHtjJ1nZ4CICIQD9CuOXQaFn\nMZ5+g6/PsIRRSlOKypGy5u+9+/d47dQsEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbETX/qaqcGd9J4h6P6SB8AzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJkOTUxOTQtNzk5My00NmJhLTg1ZWYtNWRlZDQ5YTk0ZTMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMmUxYWY4OC0wMjAy\nLTQ4NzUtYjRkYi04ZDA5ODliNDcxNzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQlrY1HvH9ewuhE+m7kQMcpvv/euJryqFP+Zo1fU737gCUJyL4lRAcVXic9FP5O\nWcsTvIBn0W2QOy2vzZZ7SZ0Yo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSJnMM+Mybeq5bl\nPn0+Yptex1wZtTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDL\nskEC+wyP4lXTvfUdFqcar1vucVvmnm/i+Az6JsnQEQIgUcSehHux6ptrU4tzUCXh\nGENbRgxZirTMz/q3AldxeZ8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7485", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7485` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAaJnFr0HVoXoMUQumnMtZWrQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlYzAzM2QxLTkzN2YtNDZhNS04MTg1LTQ5ZjIxNjdmZDMwYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGY3NDkxMTUtOTA5\nYy00YzNiLWIwZGQtYjE1ZmM1YmEyMTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmaBpAdi+AaxYSTPe8ngYdP6Jo3pfXtmRnt0r0iYScUy9Sa9v7JDlID/55c7K\n1UmNZEyKn/kmyhzNWpaiw+72LqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURDfw2aPmIu5nMTcNjxA9VC0e45owHwYDVR0j\nBBgwFoAU4v+j859KS1cTjCafaM4Y6qnNF3swOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFaQB0uM8VsL3wIh7nS2w4nm60h4G/LkupRQUWX9IFdQAiB7xOlk\nLSHnWHO3CVPoBy82LPl8LhJm/Fjy63vPF8C5BA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdhAq2BEwsdjMbtDWdIOeQAYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWMwMzNkMS05MzdmLTQ2YTUtODE4NS00OWYyMTY3ZmQzMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMmwxPyFm9EGu5aDfR3BTporOhGEjDPTbn9gQhz66wBsyH\noZC9lfwgwgLZic68KrIdMB6+1gXfuOpsoKsxi1/lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4v+j859KS1cTjCafaM4Y6qnN\nF3swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMPki1pJpmVPxpVo3XKrs0PiPWw+n50YzLtrhArNWuaBAiBZtHH2QUwy\nRV10h5n9uCVovKwxVTBj96k41WUahfgung==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISASNTq96sutgxgALZ2APMhAJAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGY3NDkxMTUtOTA5Yy00YzNiLWIwZGQtYjE1ZmM1YmEyMTVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YWY4MThhZC03ZDEx\nLTQzOTAtYWEwOS04MTYyZmY2OGRhMWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATqoZN48f3msmRDWJR6Dz8eRBaZgrwg+83qYFP7MjiE0CghMKqazhe6nkd0+Mou\nBZNAVG1OqeKJv6RwfdnVLjo8o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBREN/DZo+Yi7mcx\nNw2PED1ULR7jmjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQD1\nh6ZxnwQAc5t91VLp7hMEEqLzei54n7cQwqVZI0nexAIhAPvDCCcJAXnSaM7s/Fnf\nHEDLyCqp2LZ5ZjxUNB0OlyYp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7486", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7486` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZvahV2b28ohgsKi+/5+Bez7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5YzU3YTVkLWZiZWItNDk0Mi1iYWQ5LTk5YTgwMjI5NTYwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI0OWEzZDQtNjY5\nZS00ZjRiLWE0MTYtMDYxYmVhMDNjZjEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOyh7jwf4STDEJ3161m2/YbHr/J8/mVPtliwLy0dGpTFli0Nrvw0zSLCw1Nak\nWTOMF1mNIBkVEfcfOYLbXGNTW6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTcTra0Di4Cn2hfsFGNQ0Zx50UZNjAfBgNVHSME\nGDAWgBQrhCfFlNF5FAMgeJ8bpswy7BYu/jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD3YblC907Ek3wKxho7n9WHCwAhZ/Q/\nJiZ9dSsMJLUHqAIgWyoE6FoiGHU3l9sWKFiTee63maJOse46Wh9HHu59HGM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeRwjWsBy59WLfSp9wpe+uo6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWM1N2E1ZC1mYmViLTQ5NDItYmFkOS05OWE4MDIyOTU2MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRk8dWT3rFJQzQ119McM0DQL1DHHH/AQLggtm+XssjR+E3\n9iuwiSW8Fu51xqvSrCReseuMTt/iPXXPDG7MFCUSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK4QnxZTReRQDIHifG6bMMuwW\nLv4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOeRTDtKxXQjzndnZTqGfNsV0Tq2etsz/HaJP2o/D7r2AiBxdtymTuti\nXCeEcv8Lx0ngO7z0BA38ZKf4yopcu6Ghrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISARfM1G/7EbKyqL3jpoxkJF2KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI0OWEzZDQtNjY5ZS00ZjRiLWE0MTYtMDYxYmVhMDNjZjEyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YWE4NWFlYy1mYzU3\nLTRlN2ItODc2OC05YzExNmEzYzBhNGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQBj4KdQfrbfqknDb4lguYTiiDZCCO/O7TQe6jc8v4I314ejjneWwj8Lqq93pwA\nSLeC5QVcWXIOHgbwBZZJGU3Wo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTcTra0Di4Cn2hf\nsFGNQ0Zx50UZNjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDNa\n4u/RROrKn01iF4fXG5gVJ/N17UvQpz/F5L14sfGoAiEAqaiFXKb7WXrzPehJmQsD\ncPHhKOAzXSs5ofRCO4tIj+E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7487", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7487` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAeLXD3gmkaLk33hI247pwUu5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzZDMwN2U2LTVjOGEtNDgyYS1hZmQzLTkxZDZiNmU4ZmQxMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTUxZDZlNzktNmM5\nZC00NzgwLWIzNDItY2I0MDY0MjUwYTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER6XmhPxkmQlP4WCbiBbhg/l9/7vqK7q1pN+tWoS2daAIWGsZlkXFmpJfT6E/\nOZL3AUwhz1nIwxwm5K0AeMUBwKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjQ0E+HrEf8za1mXY7xsCRiEhC3kwHwYDVR0j\nBBgwFoAU+4bbWo6yQ6BNh/IlnlL9OdIoDQcwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCID4PwQpYN+6q\nXDG6rR5F7b5iv+YM9T9ROQ2QdDxUUA4zAiEAycbKIxUQ0rUhFmHN4FeQXcRJsiVL\n12CWwLjsoMBJups=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd4e7zJWKhCSLI+ad8ezBJerMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2QzMDdlNi01YzhhLTQ4MmEtYWZkMy05MWQ2YjZlOGZkMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjSiaVqYBtdtFk9wcwuJdwjw6eQ6yWN3RlG5dBgzo2uwUt\nH/gdphhLJ9S4I/Wv81Bn6ilzTAbps+sO9VF/2eG6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+4bbWo6yQ6BNh/IlnlL9OdIo\nDQcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYbqRb0PUsqfGljbfuB5oOvpl8t0k//g6ef5uS6U1WokCIQD5fb4Bb1PG\ntD00G72QARBDW1OitRKCU/RRt2jzd1mEmg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAWu8naJ4/mnlbPa4g7RSzuHbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTUxZDZlNzktNmM5ZC00NzgwLWIzNDItY2I0MDY0MjUwYTEyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwOThiOTVjMi05Y2Ex\nLTRmNjgtODFjMC0wOGM5MTljYTEyMGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS5t7JvyLnkMWxxoN0lCWu+/LvbVe2D9lmijZ95rsyuyxkWdloz5TPTAIS3yrv2\n8D2n5Ro5r4vNy4/D9UqxqMpSo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSNDQT4esR/zNrW\nZdjvGwJGISELeTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDM\nhq/cN9RP8SR1FjqXmJtrHWNbW21vLKLyndMWCb2S1AIhALWSMjWsd2vTvkRl+uGf\nFhtXM7iwDl4Y4/8Kqi8c0kq+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7488", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7488` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUzx25GO7JXn2ZH+u/P5+M/0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ZTJmM2FlLTVjZWMtNDUzNi05M2RiLWU1MmY0YTY2M2M2ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE4MjMwODctNzg1\nZS00OGQzLWIxNGMtNTJjZmY5ZmE2MTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGnkRYH9apakH412OlKijFLZ54NbovdKUrrsREFw7mVrI+kYNUbR2EnsEIvQV\nRXs8lwunQ7aX+zjoNLhVa7SA0KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsJIGjV0EyhFrE16HWjDEn41nu9gwHwYDVR0j\nBBgwFoAUpOeQk5KPBIdwXlcsnbZ2RDdfCWgwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBTWVqs2D5px\nKqkXmZmMMgizISVqJAc6iT1aMpvjPTu3AiEAwJBND/G/FHXqOb2HjrvwKWXC2+pM\nPjUDbRrMa71xifk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaBTEXtM7NIQRG4431sdNYIeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGUyZjNhZS01Y2VjLTQ1MzYtOTNkYi1lNTJmNGE2NjNjNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShLdnjTbKVrLXQQNV5eSb9T8ps/fBstfcFNB3cBPFJmZXo\n7uIxWPf6+zI2sZna0eEgVgQhflbqqrsj5S3cFqSYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOeQk5KPBIdwXlcsnbZ2RDdf\nCWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL2+V41/zSblChqo7z0GBb9iX+z+tFEV1+YiS23DSAoQCIBBz7D4Z9tZe\nnNuLxNaJe4iLTxEpOeEqG/ntByfl2Bi8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAfFFUCrsbepkdNJqzLm+DHySMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE4MjMwODctNzg1ZS00OGQzLWIxNGMtNTJjZmY5ZmE2MTRiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMGY1MjcxZS03Zjc4\nLTRjY2ItYWUzMy1jZGJkMDQ4YzNkYmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQDcodY9mUhce1f66y6eyBWrM0HIm2VmyC30VrAqBEX7wNqAW6zBKRcA9WSQIEg\nNR7XyPnu0dp+0hzMhxjbRL7Ro2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSwkgaNXQTKEWsT\nXodaMMSfjWe72DAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIBFA\nLzQdh0B6HpQwuUkfMYy2WnuGVo6/Nq1FZG67UyoLAiEAiSOMgcsAhABzwNGpStOt\nnlZVGDaOl1CY8L4pF9j2BJc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7489", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7489` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe6gAwIBAgISATjjADMjTHiRr5WXh7UPJRb6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyYWIyMjhlLWMwYWEtNGEzMi1hMDJiLWUzZmIyM2EyY2QyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E4YWY4MjctMTg2\nOS00MzdkLTk5NTMtMDM2ZmEyZjQ1YTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBXE2JI0KILP9ECOfBVZUAleOn0Pvl/G2Ix9lhcL0aj+17/IjuvCGzBKJ4gV3\nt0tBBUep+JgfTZJJOIP7n/q9B6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+g4hlG9CHtMaH42kxSf5AhDuBWMwHwYDVR0j\nBBgwFoAU0GIh7zpIwRHnIavXNt5OdmqX+vUwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAqakIAUTN\njzHbJE5Vyw7aJWGMvgz8uGRvOzJU3IcCMXICIQD7JXMnNo6u5KO2aIVvy3lWz2Gc\n5vdjDXNQpUk2lCFUvQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASAXvzwvhWU+osTFQjmTlRlEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmFiMjI4ZS1jMGFhLTRhMzItYTAyYi1lM2ZiMjNhMmNkMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8DIBKpa3cpCnrFPDrAxxRX84FMYWaIasIsQDsHQHCQdap\nT4UtQS/pZ/xA4WWgYpA8V54RcMXo4QESod+7nTauo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0GIh7zpIwRHnIavXNt5OdmqX\n+vUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWtxVrs4ePZPGbKP9KHmSHokMt8YVMfPZ33OHLp+IdWYCIQCXSoEulZ/q\nTqn99te96GCTzmZTMKPhUAMRjBemtvfxuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAW7TugJGkly9zRknW1AX8gQ0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E4YWY4MjctMTg2OS00MzdkLTk5NTMtMDM2ZmEyZjQ1YTE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZDc0NmQzNS03M2Mz\nLTRmNWItYTA5ZC0wN2JiZjViNzZiY2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATqSH5VJ2njxPRi9FY5/TZ2LrfMem9zwtd//oyFQN1D9jOuD2vLs/Jnfg3YI22l\nCJDokujVCESem1pzGgnSsxaCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT6DiGUb0Ie0xof\njaTFJ/kCEO4FYzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDs\n45g3sPvJ9XxjZxuEz9g4Xy90DWKzmxi3mCG8fEGd9wIhAPP93BhRPGZ76dnoC2MS\nEYejRS0gHctnLzjL1KT4IM/t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7490", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7490` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAXd8NspcrCPPdxVTHPIJUtFvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1YTQ3MmJiLTU1ODAtNGIwMC04ODRkLTg0Zjg1MTc1ZTBiZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNmNDIzNWItMDAx\nYi00YThhLWI2NDAtOTNjZWRjZWQyOWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+N+JsKcsht1yST+vG6fwBRFzrzR8k+W7Fcm5NtQJfGY3XWiW8evdcisqyTm7\noSxcNE/v6Iv9ZTbQNdvGemdRiKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0iC90GiuRmaxmO1xdhFBwo4di0EwHwYDVR0j\nBBgwFoAUBrVm1ODaKPUrDETJiSsJabqJ9N0wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiAZfYF3EEsplNrb6MrLI8WGl/5c7+nX52ko85mgUqe7/QIgMtgup/FN2EbR\nbGLdb5vaAYVvnXYDb6spV0OSm+R/tT0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASYTwN8/76EbU5U3ZdVl8Q2vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNWE0NzJiYi01NTgwLTRiMDAtODg0ZC04NGY4NTE3NWUwYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8GH8rvxCZAa9goE7t4jKRUfRpxlVkFlMjyj42m8CqzOxK\nqpAOhUwzqSlGjTEk7u7+XDbWFyWhkhnB728grTxqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBrVm1ODaKPUrDETJiSsJabqJ\n9N0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALkcY+COw28hc8wFZrJ46iTtRhOfrCfcIbwy9MY9/GW8AiEAtvg6SzK5\nXXsBsc8+07mOllrfSDRb79or6Xf3WE5bxiU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAQzSismq4bwtZwH0FJTSji90MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNmNDIzNWItMDAxYi00YThhLWI2NDAtOTNjZWRjZWQyOWE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNjUwNWIwYi1hNzYx\nLTQ5OGItOTdiNC1hN2VkNWMyZjZjNjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASr1j+aIXl1ffbGPLx0yzJEtwfz6kUbH6Lra5FyGGsQL8OCuHx/aci/5HLxqRL7\n9opvkYn0TVH3yYShcbu+xpMto2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSIL3QaK5GZrGY\n7XF2EUHCjh2LQTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIGTB\nCtYC/ZQHTHyVKbiaVTvL1HlJLCVELx6cw+lJNZMWAiBb2GwptzkEaDaGJYhnyVCa\n8Qyy+LU8t0b+c9pdYrCWng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7491", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7491` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISATLykcHC0vNTTWR/NOPvjRs8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0MzNhOThhLThiZDktNDg3NS04MGQ3LWM5ZmZkZmY1ZDE5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjcyYjAwMGEtNWQ0\nOC00OThlLWIyZmItMWY5N2YzMmM1ZGEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKUDNZkm8tdakcmMtAr/9soz6eetMzR9LHH3AMAciRcUTqCHFnmfGEocGRrNc\nPTE1EfRwFu17WzMmm9TlsXXlz6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi1WMsRi8Mq+Jh6bDu+NDXQAhy3UwHwYDVR0j\nBBgwFoAUqOCLgRsAzpGWD/6SY/jTM1DPN4UwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAl9+UFJ4xJftibHqSlinWKrUGEcJpOyKAPhdP09WaoPMCIQCkOviBmGoq\nskBjeZjkx/fMFnwi178OV4lYRwhoz34PFQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWBfGntxA1n5pXxhld8jdDflMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDMzYTk4YS04YmQ5LTQ4NzUtODBkNy1jOWZmZGZmNWQxOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsi2IOQ+HQmtYmkRtUjva4u5IJCO0Zlcd0MHKLN/IdhrpV\nWOOv/waWeOHIhgJmrkZaygUggbKRdOIrV7pzcE4Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqOCLgRsAzpGWD/6SY/jTM1DP\nN4UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ7JMAaygs7G21gU1A25tl+wRWSIyWFD8HUT7ptqG5eECIQCDQprqQMx9\nbwBoIDLpZmfCwInySafSJdkdOS+HnP8n6A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISASjy+/ZlQXpylLTZZ98hC3TPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjcyYjAwMGEtNWQ0OC00OThlLWIyZmItMWY5N2YzMmM1ZGEyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyODNjNDkwMi1jMWQz\nLTQ0YTItYTI5Ni00YTAxMzcxYzhiMmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQlv4IjV8UteluTDNvPOmVuXS71G8zVtD6nrnwfqMXBzK5LKmUoCPWSnGsi1rEV\nmu9R84zPOp2Bff85leNGGidPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLVYyxGLwyr4mH\npsO740NdACHLdTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBKk\nEjiDP0a549aDjf7W5+ysZyQ4P5sm+HO8tdSw9HTgAiBgGgNBZILIC0l18mMvOjKM\nz7XCrgsBscs1/zXCUTrPmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7492", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7492` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAb9UmGDNMD2zM9PKVCpAcweVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkYzBhMzQ4LWM4ZDctNDc0MS04NzAzLTg5OTVjNjU0MjgxOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYxMDMxNGUtOGFl\nMS00ZDc4LWEyYjItYzZhZTZjYjA3ZmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+XIiMcBFkfEB9EqkwzuoRLwUdzCodLSOegu9XHoOrvB82n0OzJFgQIPNOwLI\nHxWcAwc7S4+gHr8NSVrhKsVh5KOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6GDzQw8lrnixvwx6jcgV44hjIhkwHwYDVR0j\nBBgwFoAUFD0V5sdU+ZEhp2JqEOjpLtqPsAAwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBq\ngSxBjsXNEJbPuckwXHIGuoYX7qZoVZ0ppKL/BVoRIAIgPCc8CCh5/aD1ZSaSHiHp\n9JdyOw8mN4T81Tf1gg7N/ng=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXilDYgN504yPTnHMU/Zi1EOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGMwYTM0OC1jOGQ3LTQ3NDEtODcwMy04OTk1YzY1NDI4MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTtFfhVW5BTjZc+9Lp0FekjowTYgixrMBgl3rOUvupZGnD\nrhGpvIE81GSG4pUKeriS9k4REVcKenZKiJ5rhdW4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFD0V5sdU+ZEhp2JqEOjpLtqP\nsAAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOcbMsNxa8EBsUfOJ34wKfbfGgAef5MuvBLnnGNbmXDkAiAY2J7SFZXK\nkEHhFGKarawijdHc9a/ZGIRbkPih0oxVNQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISASBR26Gy8qDOigk4XaFQQPE1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYxMDMxNGUtOGFlMS00ZDc4LWEyYjItYzZhZTZjYjA3ZmFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YTdmYTdlOC1kZjhj\nLTRjMDMtYWE4YS04MjI1N2IwOTMzMGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATr8hr2fGx3SEn34QiyfjTT7p9oz91ETLOi/9+glIxE2AMbuchK2fl2h3/WLxsU\nz50IKINR0w4AS3LoJimqENOTo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToYPNDDyWueLG/\nDHqNyBXjiGMiGTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQC5\npxKsE8LGdUfwcXcHud+KZNNDPeUmWV+yot7mpFhEdAIgP0FM0pJOr1JvY6iqVbhx\nsZaaY9LgaSc+yI0C9vGFtJQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7493", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7493` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAfP9FTq2SeeljM3enTcehdU1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkNjhkNzhmLTVlNTEtNDA2Yy05NTJlLWJlMTVmNGFmNTk4ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI0NmJjM2ItMDY5\nNi00MDhkLWFjNWMtM2QyZTJlNDBhODJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDjUK+cB5k2VpPqENCghh1si3xzBiSAEMcuOWixNyEr2zFP6PLdvUlV3Qtk7H\nwG/Tgx7QdgubWB9LYn4K7cbdf6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ljufvk1Lh3rsYlAWGUXImY0jUwwHwYDVR0j\nBBgwFoAU2gnTYzr86Y0KkKJ+tsMJQJasnhgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiA6CBM14ySHu3bvfV1BxW2dx0hKyF6XntKHP88Hy0Y8twIgL7oj\nbisghFLMpe94IqSNe5umgPWJJQtn7ZUPWO6wH3Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcBXOBJWVINiEhfFqljc1UzEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDY4ZDc4Zi01ZTUxLTQwNmMtOTUyZS1iZTE1ZjRhZjU5OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxdq+7KuJ5vDPkbuZmZ2/O+GdN3pFa03gbeRtIdOwOO+wv\niM3//V2+Xh8b22X+k41goNYcBhHp2OM+5gHBQQRKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2gnTYzr86Y0KkKJ+tsMJQJas\nnhgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN7KcURvLwrsl6Yp4lp87H+In++6wRXfrqZeDiJN4vd+AiB7uoo6WIRX\nfZMqdUvkadFfsMRomtJh+Lp6tsJVM+BZuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQB3tfR3c+u2NHhx6yqNzsjsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI0NmJjM2ItMDY5Ni00MDhkLWFjNWMtM2QyZTJlNDBhODJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMWFkZGM3MS0xNDg5\nLTQ2YmQtODIxMi0yZDI5MDk5ZDcyOGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASa8GqA9PWthuRaCY3QJWnChzhAkDBsBcxicwimx0S8w8qT4ymoWnKZJ4gKWgPJ\nn1lRKPT22mu77y0HDcTNTDwCo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTeWO5++TUuHeux\niUBYZRciZjSNTDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCs\nWwmvDA1lYkdCC6xUQzdH5vQezrJvM3trdYL7Tti+iwIgLC7XmXAGYhLOab+RSOfA\n/VKLVwlrNDdI+ARHw8saFBo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7494", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7494` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAcsLh9BzEC/IVTblI0/oW6CMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjNjA1YzQ1LWM0ZmYtNGRjOC1hZmE4LTYxYzMwNDNkNjYzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U3OTdkOWUtN2Mx\nZi00ZDNkLThiYWYtYWM3ZGNhNjQ2MzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWbGwPN468SDvPZQ7UzmFGC6cOHsIV4Irv8g3+x31lrDuRsZIFyYH0LP5ZbI4\nIrWdmH6+T91fVtDEWDiwmo2+VqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU28FRxspOCfc9cRtz5d910JsI4/UwHwYDVR0j\nBBgwFoAUqrgHEUJtUJ1ec9DRShNElWB9VWgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA1Se1JXkFZdJ0Wxjc5E5Ui1AFj42wJVScKBDGiez61jwCIQDy\nUsOnprpp+qet/iwvC1OgNWlRbwBmqwz3DuSNwsBP4w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfWO9fI+jV9ACxrRpjKllAeuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzYwNWM0NS1jNGZmLTRkYzgtYWZhOC02MWMzMDQzZDY2M2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASN0VNOZiDMRWfgGvpR57EMwK/e4tw7tpp5ayzKhFIwRygW\nsU7q47ePk4p1iBge4ie0iV7f6i8qEdvIbYssnAWLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqrgHEUJtUJ1ec9DRShNElWB9\nVWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALzsmCogzS52sA3/C50HgCfqRO1hKBF/7qKpa3zDKf3NAiEA9et/KPX3\nWGCXXXDZuiTy9/cPhPMRlt+crVdemV2iCl8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAfOxv2Br5OOO8lTcMNRgifZOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U3OTdkOWUtN2MxZi00ZDNkLThiYWYtYWM3ZGNhNjQ2MzAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZGI0NjVhNy04NzQ3\nLTRiM2YtYjdlNS0wOTNiYjg1MGMyMjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASBVUdkm0KqMTUZXIqbJn6pSWQtOsS3yqOL64F6oz8t1sgTQbvJJ1DvtdpeUq3t\nxkKCi/UZno0kPJa18/ceGvrUo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTbwVHGyk4J9z1x\nG3Pl33XQmwjj9TAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCE\nMH0apyjujjPxLDwuN9DR3x5PW5Vw+nZCfFZYF2nkkAIgA2iZMlPu3u+mZOWZkKqL\ng2ShPDag2EqhiGdwOddSCQg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7495", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7495` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAXgznBReMY3jtAu1ZEYL22b7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4OGZjMGNlLTQ0ODAtNDMzMS04M2RiLWQ4ZTNjZjhiYTZhODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJlN2QwYzgtMjFh\nZi00NDdkLThmMTMtYWJlNTA3N2MzZmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKONGwx3C+3Hol9zRug6UKPAtGtK2zgvUdyl/1e4Lt0o9QEcdG9rUBHSryAy8\ngNs4BZ18rL5IK2TFRJyg0p2U0KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu25iw01oSkAeHzTMO/qp8IhexV4wHwYDVR0j\nBBgwFoAU59R170wuGaXEjdsMAoPEH+P2V2MwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAj3F1hbBxg345\nCa1dFVTXz4R0VjUytnor1EiUPQFGrMECIGw73CZdzSqkJgkM4Fno2vyx7W2HAfSb\nMCCH8iMyF5t4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcppLriwBL9JDvE6Y2X4xGYDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODhmYzBjZS00NDgwLTQzMzEtODNkYi1kOGUzY2Y4YmE2YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOir4dhcfJmcswlxc2qdK2go8ifjNrZ8Z0kmlw5xpzeSjh\ngovVS77P/urk3N5qY/LmnvfRah9MkxDI4fGXMW/ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU59R170wuGaXEjdsMAoPEH+P2\nV2MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGmaUD5iEnVZhSeBTn5YQKmMg9rAgNZUPDT8+G6AAL6gCIHDXQ5ND5lv1\nVM1jvlrbR05wdEWvHY5AWbJyF19fuya6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAcfRcb7XfpLdjbeDOuZMg39gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJlN2QwYzgtMjFhZi00NDdkLThmMTMtYWJlNTA3N2MzZmQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMWM5YmEwNS1lZDdi\nLTQyOTQtOTkxMS0xYzcyOWJkYmJhMWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATi6q0KTYfoMsnyiEbypsv8Hc5n2puC/WnAWFYzH9e0wpYgsXFdwRfnaexjEBJe\nSlxzAcFK1XenrXBu1JUuQ8vFo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7bmLDTWhKQB4f\nNMw7+qnwiF7FXjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDe\njiVElq/uWuFw7wRZJ3foZNMLGXhEz+pzh7ijh+zEhQIhAPdMXTv04DauKLRiJ5Z1\nFAAw24rXZcMqNqZV6kgdIqXD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7496", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7496` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAYF/RcFVU+08CMG0FkwuBi2qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExYjFmM2NhLTE0MjQtNDU4ZS04OWFmLWRkYmY3MTBhMDE5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFjNzYyZmItM2U1\nMi00NmFhLTg0MTgtZmI5ZDI3YmUzOTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhugyef6Im47lswmXbOQj7SaG7zbaBQjvJx9CYTLRxT/6QwXNNqjnmQU0rtHb\nNtdGseEqUibXt8Td+eQ2QUrwvKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU4tOTaOYAFus9yUY/KdXkQOfAM4wHwYDVR0j\nBBgwFoAUyLGhm+Civ/etll09GYdBI0JayLwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDmt4Y84L1FMs2akNAz5icJPKUZISL30SJJwVVjatHUxgIhAMbTKrLiZGQT\nIOmS1P7uAhdGUBaMjom1s3UtNexdCqYF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT0AquJkxtGf2LOz35+wI5WTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWIxZjNjYS0xNDI0LTQ1OGUtODlhZi1kZGJmNzEwYTAxOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASX2p5l+9S4MZIFqBEjXnono+6OWA/JuNHAd9O2NLbLVdkw\n4syTSOwPlyu+Jikvc41SLT4Rf5R0UGcrJFrPeZZSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyLGhm+Civ/etll09GYdBI0Ja\nyLwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALWA+HBF+b64wmPaHY6TOLu9inhpVIzU06f2uSVa0GUZAiAtTIcuofUy\nx97H+dYJ6y5TnsUsQSalSGo7CPXV6Fjguw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAeFopIsvmg68aGtyg2ZR1pskMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFjNzYyZmItM2U1Mi00NmFhLTg0MTgtZmI5ZDI3YmUzOTQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2Zjk3NDIxYS1hNTVm\nLTQ1OTEtOTc5Yy02Y2Q5MjU5NjFlMDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS/2jBuxc+rcC7QTilKdfX77Uvham9gCTFCdVLwkThKHJ+7nNakEBPcw/Wsn6U4\nADwYaLq1DYKSlCgcdlmdZi2bo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTi05No5gAW6z3\nJRj8p1eRA58AzjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCy\nw48sgrAotEYP2LPsswfOl1Ned3JPVXztW61xlW6DHAIhAJlZWHk5OYWYyhR2yQG2\nPQg9qqytDGzZ+qUIwF3BxzB/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7497", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7497` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAb2ktKuZkv4JHcZIK5ALz/5IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwMzE5MTU0LTc3ZWEtNDA3ZC05NmI4LTY1YzNhYWZjMjllMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM3Yjk5N2EtZWU5\nMi00MzJhLThkYjItOGJmMzU4ZDU2MzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExC3eBLvaT5q0LxeKIpeF6Y5+h7NP5UTKTuF7kP8F0KQGjA28UGaaNKRSRC6T\nCfVqHYOxaVc3Xfkz9r4jAegQ1aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf1lmk/Pe5IDjrABtJ4eJ2ukt/oUwHwYDVR0j\nBBgwFoAU+HbmgZaDUh7fa8bPdHkjRooVOUUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHXqvgPh3wvT9YofOSFy88uh6U3R7ElgiJkmNyR2plsPAiARe633hRDPWLvX\nF5XccGNprnYT2HkwJ09Rs3q6sPY7wg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXcCh+i8tMZOr/gtcwEyY7agMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDMxOTE1NC03N2VhLTQwN2QtOTZiOC02NWMzYWFmYzI5ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOvKve4JLQXLlFzRNfWKJt+YAhrqQ6zNDs71u4Th3UsNE6\nCuQjVJhpc0j6LyWSK7kjg6ha5Q561U+WN898xNuuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+HbmgZaDUh7fa8bPdHkjRooV\nOUUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANHHikfmwZCdyWV0rooZ7ruwjGia9+rXQXkGcsNqKvMbAiBb3HdXbXho\nCB58+jtV+yKEy6sDoGJrR6jc5Z6faKRADQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAVLA+IpvuEeHF84tlgpphel7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM3Yjk5N2EtZWU5Mi00MzJhLThkYjItOGJmMzU4ZDU2MzMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMmQwZWUxZi02NDcy\nLTQyYmYtOWYxYi0wNDMyNDZmODViM2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARfXfpzlpKmh+IlgYShoc8tcuV8SoDHxbcFqkKaA0umj1B0zN7BvefI7qPqr3N/\nCeC312N3GHEtZCEoe/2NPzKxo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/WWaT897kgOOs\nAG0nh4na6S3+hTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDT\nHSHaSRAz33AGu9zDIK1qcaUBUWrV8xQnpA5UKjKt7wIhAMyWsZRjwUHvZvAzXshw\nSB8WK+PS7IEUymSv11QsnJFi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7498", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7498` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAXk3wXjYnQ5FvFYFN4FX+0+cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzMTM2YjNlLWE2ZjItNDAzNi04Nzg4LWZiYmVhZDI0NmViZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWI3NWQwMzgtYjQ4\nNi00ZjFkLTk2N2YtMDZiNjQ1MTVhNGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDRxfAFzPEjLbCUxap2yFwoCZlbWG23O8DXWlO/AoEV/IUquT6U5V8XNBJT0b\n+HDwIS08w59WZCcSVm5t2pfa76OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhTwY2LQkZE0bJtuHJTlSmlI8t0IwHwYDVR0j\nBBgwFoAUZSvt7gwd/eOBqWzgFGNngBMqe5UwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAztzA0+T++mXa5iCNsfg/dD0AoWFhGBjuG/6SPE9zAN0CIQCvydElO6AE\n0NXfywjuUz+UbO2p0Ppqy1rKlcFDVaE3Hw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdFZ52Aw1IgKKIsNQtjP29NaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzEzNmIzZS1hNmYyLTQwMzYtODc4OC1mYmJlYWQyNDZlYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATugEwIgjX6XWImqiAtuf7YYBN8AxuZj7VRe11py5gPV51Z\nri4+yidMlghWucND4QvnrF2pIeVWEiXN1SwoASCko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZSvt7gwd/eOBqWzgFGNngBMq\ne5UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKLgL/C+rKw/NIetQkmC31DIBkFDG7FZe5h8nhewWVhkAiEAwg/5m1j8\nNxpmPvC6VWHJGHuJEFMT8etY30kpf806MC0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAabhGKDvW5lwn3uFCOhUx/zgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWI3NWQwMzgtYjQ4Ni00ZjFkLTk2N2YtMDZiNjQ1MTVhNGYwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZTA5OTQyNi04MjE3\nLTQ0ODItYmY4Yi1jODY5MjdkYmYyMzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARLgxa0lyb0sqqDby4WxwecjMR0/zFCSYoSaVWXnxxDSCG+VNL9MhONBDoOmr7Z\nKZgD4+lCm6wRSyuHpqEF8lZho2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFPBjYtCRkTRsm\n24clOVKaUjy3QjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIB7J\n0adDvqWNM++b89liXASEl3V6Dzw8zw2kdz24dBYOAiBmOTBlDm9GTumoJR6SFY32\nKmLJXPpgSiBmpxE6U6pVKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7499", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7499` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQuHJO9UK6trr0rQ6nCtBq5IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MGE0OTFmLTMzMTQtNDMyZC1iN2ZkLTk3YzhlZWYzMjNmNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJkMzA4NWMtNmJj\nNy00NTg4LTgxYmYtYWM3ZjRkYzQ5NmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtUiAekxs+i5rq1fhG/ar/TrnmR1s7Lo/5bc6EP6rVc39rcSQALmjoTHfOcDl\nfzr2ZvpeS4tuOBMD/VY5y8YMZqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhPbpzZE8hNGk/y7qE73G2TjSN08wHwYDVR0j\nBBgwFoAUgRcS6i2AJWZ03CbBu0A5joxxttYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAPySYwf3fJ/O+D6Me1M+gEAsd4O5/ECIQuujh4ov6y\nogIhAMPjXVAyGSJtGsz8aIOHOT6Dw5u+GQbbXYgcX9BegmtH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZcZ1jjwoayuwPBWGh1pI4m/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODBhNDkxZi0zMzE0LTQzMmQtYjdmZC05N2M4ZWVmMzIzZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARE5efw2mvg/OeHtm/jPJmXTwql3+ut++64tA8DQaZfZvKV\n0UMFbaEV05VAjbKSe/PWvEyYR8USDk1YycynSvL7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgRcS6i2AJWZ03CbBu0A5joxx\nttYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJhwUOctK+R5EJbGSvJAxMhDyjoaGiRRrC+CuJZTteaZAiACFMaE4Cuw\nrtHhqXFk6kQ3yNvy9mhVXtWc307b26QGaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAQpD4stjs4UKLqlEVAxlSC3vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJkMzA4NWMtNmJjNy00NTg4LTgxYmYtYWM3ZjRkYzQ5NmVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MzBjYmRlMC03ZGMx\nLTRhZDctOGUxOC1kM2RiOTRmMTljZmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASmCm1/YsGBlcciHJH0bk7OR+BON+lv7BZnmDOn2lCJEv0j+pSasZOOG69UVE/d\nLtYrEtijhmTa4r+bIl2emG/Eo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSE9unNkTyE0aT/\nLuoTvcbZONI3TzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCv\nER5dEi2OVPyXbElqZsJyvp4rqS8KN4yu2QH8CTE1ZQIhAM+GvukPFcqQoBhJNZzv\njG+7tNssoSlwlqWZZWd2CJ4n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7500", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7500` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAX31sj/dRTkivyPk4AW6LpS0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwNjBmYmFmLWNhZWYtNDY1Yi1iOTVkLWQ1YzMxYzQ5OGU3NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjliZDYyZDQtODll\nNS00NDM3LWI4NGYtMjliNTQzYmViMWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE//Yuyw8X9Kh3MW9InbS8vgIinC3Kf9vdKgl1PzwqSG+7c/OiS2sZ7XknBvoT\nXLnYxMadWg3E9dA66AgTxOoUyKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO+maz0b18HEX2zrj6MGZTpgkq5swHwYDVR0j\nBBgwFoAUH3DRRCeTRg9d7yh4EvQrjrG0tyowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAx4rM5oLF5GphVETjZPSQIooWF7sj/WMAmWdmp0tv\nNFsCIQDjrFX6udhE0uoJab5kXtU0A8YN9vz3ohDJTyCPeaWpdQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc42S+93QVDuRnuF19ZVnCJpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDYwZmJhZi1jYWVmLTQ2NWItYjk1ZC1kNWMzMWM0OThlNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdLv15xu499BtamGIHg08Rsqn8hOj2ztW0MHQDF/277ynP\nCJzgBtJyy9553zTIO9bcJi9SzLanBVtSStNuurKFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH3DRRCeTRg9d7yh4EvQrjrG0\ntyowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG4uRFaYPQWJMGEPciMGZUYgvpch0bjmBG3ZVRcuEkbICICaiWmfWycid\nLy9wAEtl2EBx6kBk/NHwbgodO0HeCC4t\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISASvBxODBhWew2EP2BS63ANFUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjliZDYyZDQtODllNS00NDM3LWI4NGYtMjliNTQzYmViMWY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxOGY1ZjRiZC0xZjc5\nLTQzYWYtYWUxMS1mYWJiNTViMzZiNGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQU5yCmD9RJyRH3wUkoxNRs5xk//bZ7hiAOeP1S8Lebf0r7v7aEiPMe2ZdMs93X\nM2Di/7dz+8Yd4d0WZr6W1FdWo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ76ZrPRvXwcRfb\nOuPowZlOmCSrmzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCu\nRJiPcbRgRv3n5jBdbnGQ28RExiCHtT+CzLflEurSVQIhAJYxgBZzeI8BuhmlUY+4\nKorWE7A2e1YPRGZrPqAwgyq5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7501", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7501` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASK7tLWESyrRfRWUqWQ9DbQdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwMWY2ZDgwLWNhYTMtNDQ2ZS04MGFkLWEyNGUxNzJkZmY4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVhZTkyODItOTJm\nNS00N2IzLWJkNzMtYTBhOWJhOWNiZDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmdP6oNIpeSnPkq0LAgQMNgSjVfDCgB7TvKOJyaE4ZxM8BeSHRamVPM9IVNHh\nnHabC65XtFs+2WE0ms+GVzYIOKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9DYWBNXcxhRzid4/iR0fRVWD69MwHwYDVR0j\nBBgwFoAUloqVOsbY9EBEfcW77pBOTAfacUgwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAa3yfIv0IEZpvwQQSuCb2Dgg0+UnlqZcr0SI5J1Z7TdQIhAOgj\nG74cAAsWucrSnAO4PAHvr5L1Qc1fAOewA2jzPXqH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARoYfIN4j8lXGOJ/gyx5wubqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDFmNmQ4MC1jYWEzLTQ0NmUtODBhZC1hMjRlMTcyZGZmODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNe0bRlBWT4JtDCoNXtI9azrvceB9RtroRHC+VrJzDUXbn\nWHVEvQzvZUXSfDL6zQRGYbm/XL+L6P2YiQ+Bdl+To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUloqVOsbY9EBEfcW77pBOTAfa\ncUgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANTQQThnh3gg1E+6w5UcyZfxZQ51IDGvZNzBpOJKHL0gAiBpWhJCtCYD\naszBfRqGoYAB7rX1WiVsIOZs9zWRbLVUHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAVx+ul8pDqQ925+DShOHZ3FNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVhZTkyODItOTJmNS00N2IzLWJkNzMtYTBhOWJhOWNiZDYxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmM2QyMzMyYi1iOTc0\nLTQ2OWYtOWQ5Ni1lZmRhNjQ2MTk2MzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARPParL5mVdfm3inDVMFRM3XctJpq5CC+repHjOq20XoaiQa1YQHv3XB9FRZna9\nYwc2JQoRVc2gKyr73mtXpceFo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT0NhYE1dzGFHOJ\n3j+JHR9FVYPr0zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIEqe\nU618CFvu44Nd/66qTx/YhBqYfw+yqJwKm2LqfnjdAiBPCk+zGFBsvaXXbjTvB0Bz\njcqRdpAsbuVi1X6J9ssVSA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7502", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7502` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAQaRXLgb3hba2ikzKK1jIEP8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5NDU2MGJlLWQzNzktNGNlNC05YzRmLWQ0NmQ0MmE0OTdhNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRlNGZiODYtZTdk\nNS00Yzc5LTlhNTctOGQ3ZjVhYmUxZThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm7kTO2cLzSJNJav1uXYNv4XxQ7c9BUo83I62Oaq1EaBYl8tdGMFdpxdLmRic\nFjfC1vhC0U5UVPenWP5WzN6uDKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB699SqdJUODRu439qtzpMc2vUJAwHwYDVR0j\nBBgwFoAUpzWmWNYwh+f+oMJLkBAurc+avH4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAlrrbjjPrpXAVbmXX+ZqGipJJlfKECLX5\nAkD8GLK5GwQCIQDQlRchDPSKS7RxXv4F27KCd9k86vOhg0DlmBxvW3S/0g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAal/9J6JhueDPgbWdHhDAcsvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTQ1NjBiZS1kMzc5LTRjZTQtOWM0Zi1kNDZkNDJhNDk3YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV+oC/jlULxVqE9TJQcoaEmJwVTOC4thSX48HBgruWllGq\nkxhmvQMLiwNf++gQhsEPbhgGMG5nNrBVa0refKP+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpzWmWNYwh+f+oMJLkBAurc+a\nvH4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANRItgAoeTuJSttYKHWclpwCiVu6ndNsefRnYVPMsl94AiEAq54SUhYV\nsSq989+PIC/eO8/Oth6Sf7X0k1Y2Dk/eMXg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISATexFPeH5h7LjIvwJ7VWdTVRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRlNGZiODYtZTdkNS00Yzc5LTlhNTctOGQ3ZjVhYmUxZThkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYjRhYzVkOS1iYWMw\nLTRmZmYtYjUzYS01MjE4NmMxYjczZmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARyywHLByeLQgXAhHesQB/cg8QfomsHM6cd8BT/m8ExRY8oWp8dLrv5mugCT+Lf\nihLLsdoPs/hM/0dfBGZaNoOuo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQHr31Kp0lQ4NG7\njf2q3Okxza9QkDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQC1\nteXAgTEaQFvCVR5HlUiVC1AQ0+01azTbxy4bDjlfugIgTVf1cC2ldO2qLr5Ye3/r\n22A1z21SCRk+ZaBiX8yHhk0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7503", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7503` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAfBk7zXOclG2Qt3oJV7LA4WDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MWIyZjA5LWRjZTItNDU4ZS1iM2UxLTE3NGQ3OWM4ZTBlMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc5Zjg5ZjUtZjli\nYy00YTkxLTgwOGYtOGEwYWRmNDQ1ZjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnfwR3nZLplwbkwrC/DWPC9KYqHH+PAjWLkTzlQZF7NiParquWQCI81mrpiag\n+Z5Aco/a8RTu+Zq101Z8Oo3h2aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfjCuTCV9e7GPc+Xfi7em4dxywX8wHwYDVR0j\nBBgwFoAU2Kk3UOQqinTyQnonmktRtTFNcckwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAhgy+akb6h+EQ3JT9NKqUemLXfAX794Fp+\ncmOWlJUOPQIhAIYolHIQ+0I3YqhRMC5ILZEp0ITKM+cFHIwkPoB5YPVb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQTzKC/no/lU1Xx2w7muMJEsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzFiMmYwOS1kY2UyLTQ1OGUtYjNlMS0xNzRkNzljOGUwZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBBHIdnWW8mjpom3TtKBwUjdtrzv95EUDn6dpoDczN3Y68\nD9S+WRvQFIaZvsjUqNotf3n4IVkSN9U9Njau1lfbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Kk3UOQqinTyQnonmktRtTFN\ncckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIxPN5hd75tuP4+UsDHYM0jjf04CqLOLHC6R5xBQXnw2AiAP0U9sK9jN\ntBPbTMRHXrsm1tuwurfkcq1v8GjWMO4n1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAa1/4xE7KqKxFWeuNGgDWj49MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc5Zjg5ZjUtZjliYy00YTkxLTgwOGYtOGEwYWRmNDQ1ZjdhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMWFlYTdlNi1kOTU5\nLTRiZWQtYjQ2MS1hNjExY2NkODQyZWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARu5S4pe8BGQmvrh5xW0fTYTXViW0yoNYLnjX1vHNhdOoMlwB21lktrkXQulpF/\nOiznkAqVn3bxwSUjHR/Sn6fxo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+MK5MJX17sY9z\n5d+Lt6bh3HLBfzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIAF3\nXavIy5l9/fyPG6izs2rLY1y/GzXcgh9dAh+ZCQwpAiAVNkbFoklfmm21p9O38nl2\nBi/LWGX1XVU/44ER6QoprQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7504", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7504` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISASxajtiA9jTee0yZvju9OBzhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzM2I3MzhiLTExZDEtNGUyZC1iNDA2LWJhM2Q2ZjAwNzY3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRmMzc2NzAtZTZl\nZS00MTZhLWFiY2EtODM5YzkzMGNkNGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgmSa5m+FGjAD7lc4yzpou0FnUDgHKFVU2VA77MCTu9BjI0jh/yOHeGL8aHed\nrUVxEIIqHzL42CvylnLW7pIjk6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEWwlhjWDi1kqvxCtkL7DRLlbjvkwHwYDVR0j\nBBgwFoAUnrVjWIkL7EYgwHZ0Qk1nR3w6QgowJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAmGRO4o4bI9Ft\nAi5yPw2iwKM6M9Ras89bAL/bDDhwnRACICP0v9BqdgYxMZQa7VIMnnuPxG2duuTt\ntkPg5CXNIVLr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbAQUhNiMIb7MsgIcCmB6WGDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzNiNzM4Yi0xMWQxLTRlMmQtYjQwNi1iYTNkNmYwMDc2NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCEJBiOuc04TIzNqhsVBQsbN1MgLfBCWGdypeFRvZrbS9J\nfEtu4F+yrm3iVvx5ut/hS3mQeaEX6cfRVIpmHxR6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnrVjWIkL7EYgwHZ0Qk1nR3w6\nQgowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEcx3pQ9NuPvH9GoVVyN3V/ai+5cdIV91QeqQZQ7+g4cCIQCqDCIeNPN/\niwh6Mlxa3ocJn/6/pzxDGPpA5Yh89CzphA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAV+QVNU9x1XzRUe5oM4EFOd6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRmMzc2NzAtZTZlZS00MTZhLWFiY2EtODM5YzkzMGNkNGQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZGQ2ZWI0ZC0wNzIz\nLTQ4MjctYTQ2MC0wMzNkODk3MjBjOGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ5JUFK3qvXu1BL6u10+kbFH5BFEjmJjzUztRr20nVsIIcz4fNEantEd0q7460d\npEfBPcTFtByBoXrvThOVMGZoo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQRbCWGNYOLWSq/\nEK2QvsNEuVuO+TAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDT\n84LrTVo6MGsSyrviKkReogkNr5r6pzduOotmLtB/JwIgQIO6aiOyMfDxh+jn01Aq\ndHlPgpM1Uzxw84syAx3AEgw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7505", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7505` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbeSrCHQnFloX8Elj5SF86pcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5MjM3NDU1LWVjY2QtNGMxZC1hMDhjLTk5ZTg3OGU5Zjc2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTViMTg2ZmItMThh\nNi00ZGJiLTgyOGYtNzAyYjZkYTQ2ODJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEppdKcLxaNlyrJyexzTaOGRGuGx67ps0c0ZxYnm73GZxzKbhe59QOHGpIalfG\nnGkxrX03Hvlyo19LLUrB0KAEqKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPKsXmMdygNjvAqMzPX2S9onHS/swHwYDVR0j\nBBgwFoAUNURSt9JMOL1jLevWjEM1vOltRtUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIApvtadsK+HTcqv9oRbJDOag3fRaH9qhu8pjz9bpeJDZAiEArdFDcIBvhLA5\nP7Z/uazA6V5YaRNpCf+LvezLw5Sx3rk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd/bIwrabtuKmhw8Eh6D9PCVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTIzNzQ1NS1lY2NkLTRjMWQtYTA4Yy05OWU4NzhlOWY3NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq6EDM+Zh37Avzz4UlgVpunZTfOF3BZHGUjmwteWkLknUY\nX8aEImkA2IhIIhUxFrhfi3HUsFoALdP36Lmgb718o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNURSt9JMOL1jLevWjEM1vOlt\nRtUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ2pqHrcqa3v+wb/v/NfjcEtgV9e1Splq+bn65n2n6bkCIGycr/kSc5PP\nh40N/84Csf8unx37rf9L0lJPhNB9EkcX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAaZPwclCOhBS58vUhoktEEnJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTViMTg2ZmItMThhNi00ZGJiLTgyOGYtNzAyYjZkYTQ2ODJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNjg4N2M5My04M2Zh\nLTRmOGQtOGUwYi0zMGIzMDdiNWVjZjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATO1ASuH3OeRQViQdUcaDNoq87E9F/CE/uXLbiCt1m243FEeWHnfYtZNO1QTQ4U\nPEZj/2WViZjObnhK846Q121Lo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ8qxeYx3KA2O8C\nozM9fZL2icdL+zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBpv\nt1vH3FGemxThmpcMjMPNrTTQyqSkeDu6ML6Spo7bAiBxmbWXRmmjMJzkxmT27XQc\nAkGyU5byaw24FD4O+FMTqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7506", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7506` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATYs+ut5oI1fRVUGwrtf89geMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2M2VmMjUyLTljNjMtNGYxYy1hOTljLWVhY2E1OWQwMTMwYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ1MjgwNDQtOTI2\nNy00ODBjLWJkMzgtNjgwNWJiZDg3ZTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELiqvLdMR5Go7P1nGqed7x6RptpciIh1g9cwiZxwSzb25RJw8DwrapwyyJUFx\na5Nf/N9VrIbo1SRy68bfrlof16OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhUkrOeJvR4OLdKvl6wzmd7IMWWQwHwYDVR0j\nBBgwFoAUx/PXMaWXqOxSLFO4//61KTBs63swNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCQuypvFOn9ERlFEeRJDIPYKj4H7pbaoNswLrRb3F4hUAIhAK/YtEMFQaqB\n6nUlhi44aImkRu4DelWliR6/Liv2JpH8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXaJch7+v2AlHIkZk0nOS9PvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjNlZjI1Mi05YzYzLTRmMWMtYTk5Yy1lYWNhNTlkMDEzMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNAP2xTUlvBnYs5cH8fiPltvqQJocETZqQkC9Nmc5kX298\n6JU9lsy8TS37qw0288eCRh4AAb1xyAg130FrXij9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx/PXMaWXqOxSLFO4//61KTBs\n63swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJC81ofPt2+bjO0SevM+6AR1swxnPdCtIyzMy+jT/YzeAiACCkZPW7gd\nRJnj1FdvTtECoxRnMCZsYXuwPk3tABEK1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAeL/cWhQpFBxLhgWwGSwyfZPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ1MjgwNDQtOTI2Ny00ODBjLWJkMzgtNjgwNWJiZDg3ZTVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MDI3OGUxNC05MGUw\nLTQwNDYtYWY0MS00NmYxOWYxMDRmZTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARQ3NATCj1NIcBO2CuPQ5iJsLbFF0dPY08Vnh5+J7qwoaYyxkFIP7Ym+UvqW3lu\nISq66zY8nMFSjaCM0QGuKnbio2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFSSs54m9Hg4t0\nq+XrDOZ3sgxZZDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCID39\nhdZg7T+kZpIz9tA59ZFXSoNIGLb0173rESfPK7mWAiEA5RVTBVhS58h5R7MFuVBe\nVu5MaTCFxoHoINVytSeYTqU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7507", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7507` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAVo8PmmOl0rfJny+OY/CF92bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ODc0NDQzLThhODItNDgxMS04ZDMwLTQwOWE4ZmIwMTZiODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI4NzRjNjEtNDQ1\nYy00NmEwLWI1ZDEtNTk0MDViODBhYmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJymesqixWbnpMqgCggjXnakAM8L030OmpfH4kxqWWIgzALF8BGz6ya+4X9Vu\nc+DaiC9gRS7+b5Vcu6Al0AWZnKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvId/f3Ei5eghygqXqnPOZYpN7PMwHwYDVR0j\nBBgwFoAUYBD94W3gz3F1K7ZuIH05kDToFU0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAmd9EMDwQdMCJgNfOC2kjzU5fsp+QH/e2W9bLzXdVRKcCIQDza4/PrxSP\no0l23+O6l8xX5PifcSv/in2/6a4CSodlMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARl7jHSrCL3AxCQpJJPJmOdPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTg3NDQ0My04YTgyLTQ4MTEtOGQzMC00MDlhOGZiMDE2YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScoukRs23NshpL5ip8yRZNHQeG0FQY4SH900F9EcSRwVyv\n1sRbaO7Ccnw42ukPxb+nS5L0tfSvKjfFjaVy0a0io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYBD94W3gz3F1K7ZuIH05kDTo\nFU0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCFn7Wm6t6Cfi0Rh+ugdEa98qm5O3v01N2CKNhEJuLCcCIErFPl/SnkuG\nKCuGZToxmKy9smSjNY12xRpjjda2foBE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAZBbki7LPHY9oHlNHlEjGmBCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI4NzRjNjEtNDQ1Yy00NmEwLWI1ZDEtNTk0MDViODBhYmNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYTNjODY5MC03YTIy\nLTQ4OTEtYTk1MC1mYWUwNWYxNDhmZmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARbJS7/9V3qHsWMLN90o7zUIelXl7+z2L353nfIGHx3ggIKDrntBP+XE0I0i+sj\nkUnkqZD84DENVVnZWVe/LGiIo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8h39/cSLl6CHK\nCpeqc85lik3s8zAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDX\nCCh7GpFQn+NDn7lFT0LdqLbkKWbdigHXCzEsjx934AIhAPbTuKQK3woRj+FDic6C\n5l6VzDhocsi/WhRyhqOcjuBU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7508", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7508` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAYo3nYFtHT0PvPHtCMyOXjWQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1NTk3MjZiLThhYjUtNGU5Ni04ZTNlLTFlM2FmYWZlZDE3ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU5Yzg5YzgtMGY0\nYS00NDUwLTg4YWQtZTBhNjY5OWQzM2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHKJaLrulG2iNbQdtBfdCu/ICHCn2vhynz4SSFc63r7D0FS+ZBf39M8txwy8S\nDomZLUSE+ZzxAFV6gZhl4QFVvaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS83BzRYBFI1K9h2q6W88PESjjKIwHwYDVR0j\nBBgwFoAUvO6Lrj/N4Fu1eqi/xKO1/Fb1xncwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBHPHaqxQqmn5cWRgYvDoFcZoF34JIPhezm5NUZBZqd\nSwIgbDa1azFVbhhhWuMreoFY2wCYwhyVwYqY1vdPRHZVA68=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUh3cXPb2+7hVibrtqCk6nRQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTU5NzI2Yi04YWI1LTRlOTYtOGUzZS0xZTNhZmFmZWQxN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShOhoHyH8Z4U+UCyCveOMBw895zdROKoc/K5NaOqbzU1kQ\n21D5ypl9oil/dAW1DR5oW8lGF+n8mW5ZURuE+snvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvO6Lrj/N4Fu1eqi/xKO1/Fb1\nxncwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGhVpJOPrJ1+U1IlhVlkZM4kQy2VhVm8JNSzGHnqEVp4CIFJD57MpSrJu\n7eEBOLYYxEvHsVceXzcPj6noLE4XpLLN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAUgV0RnFtL8l9buN8qJvHTdMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU5Yzg5YzgtMGY0YS00NDUwLTg4YWQtZTBhNjY5OWQzM2I4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3Y2RlNDhkMS02M2M3\nLTQwOGYtYmQ0Mi00NzEzYmRlNTc5NTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQZXVAOeP0DJp7Axbs8MGXSKRY2/MRs/FM2riFwQYe8L/RDEKenh48ChDX2r/t2\n+0zgQ8YFcQDrUuOG9iYAk97Yo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRLzcHNFgEUjUr2\nHarpbzw8RKOMojAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIDDK\ny2dGQiYEEFpIybtA5rkTwfn2NCQQG+P5VbQsfzlRAiEAmLrh/uuOYmWyZBLHiK3p\nLtZj5NPMTTGNpp9kIdv17cQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7509", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7509` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAUzRqf0i+RQJpww/QqT7KIhkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMjMwMWU5LWNhNGUtNDI0NS05OTgxLWYxZDM5NWE4N2YyZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU0Y2Q4ZWQtZWZj\nMi00Y2U5LWE3YzktYzU5OTExNzE0MTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ5xzSd97mMxsApa+yRVz8FjJlc7TntYnoL+7zJ7ZdKhJxpx5L+bbFArw6bOV\ndzGOKLnOjWqrlGOD7mGR7/Hmc6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH4kYdpcOUQ2D/rWOwHt5ZTskeRcwHwYDVR0j\nBBgwFoAUJrWAPbwf9aB+MTj8I9UR219U8yowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAoENitAtxeX/jEN+D+0V+895tOWVTc0PzTLd/DLHv\nWHoCIQDyxkohe2m3qWx4z8oGQXXsTR0hd6+7a2PBYwrwG4g3jA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAews3qbJwwttd9kQui9gTdXCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzIzMDFlOS1jYTRlLTQyNDUtOTk4MS1mMWQzOTVhODdmMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQF//72LxDjYcwL9zVbRI/f68Fp3M3D6wf/CCCWkO1Ns/o6\nc9kQOc5d0PMLYBUK09lfs9w7TjkZCOazauQUvhk5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJrWAPbwf9aB+MTj8I9UR219U\n8yowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMuoZbsF0sGRmNQWQQwkwsbm1koca8ZNP8vNMh69ymBvAiEA5hr1K6uE\nVTduFKnwqHe4r0V+KjoGzx05lVxlpKa9MLU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISASpakGc9ocNKdgfon0Z0hG9OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU0Y2Q4ZWQtZWZjMi00Y2U5LWE3YzktYzU5OTExNzE0MTQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NTFjMWUyNS0xN2Vl\nLTQ1YWQtYTNkYS1mZDYzMmMzNmQ0OTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATaHGZNM9dUoddajE5D3nK5spFrJk93XAk2Om4mEH8xJeL1FHlC8HV+hn+RRjPQ\nuSsinlDRg4jCXvPcLSM2OK8po2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQfiRh2lw5RDYP+\ntY7Ae3llOyR5FzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCU\nktebKrDU1fME5gkY8Sp6Xeb7BsqjxZ46ZltUQBVefgIhAKsS3ra4Ni38hiEsaZ7v\ndLrviCpmgNVRNjEEvCNljcmy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7510", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7510` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWC+Dtc89cMJO5gzVHrykol7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5Mzk1NDc3LTNiMjEtNDZiZS05ZTkxLTkzYmQ3ZmNmM2MwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTBiNThkZjMtODIw\nZS00YjIxLWFlYjMtMjM4ODM5NDJiZDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZW5cUIWJG9OGGfzMTxOrIIq2Mx//Ezf5B9v1hmbn62DnMF75NmBfcp7N8Oiq\nPXu2rM6+TDTeogIcgZFokM9fq6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKr0RKx/VEPQVrQVRNkfdhDEl62owHwYDVR0j\nBBgwFoAUBj4DMPtvHznKWF/5SlGGGKwK2fMwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA1PzAZykrnbsyLlbExc79H+H71T1spgBHF1RN4XefCIkCIEjB\nR7+jyR++NyodiBJAKU2S+ZxD4bJjDfPeSL9JcI6P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd6uYMamwcVSbxT1n6aWfchmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTM5NTQ3Ny0zYjIxLTQ2YmUtOWU5MS05M2JkN2ZjZjNjMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLWYJOLYIQCYdYopl2QLwlG++rVbIqC3GHx6YCynkvHunP\nyXI4Jh6d18o4aE9nkwM8me1aQCAFR8Ql+CZqFiqPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBj4DMPtvHznKWF/5SlGGGKwK\n2fMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNzUy1bKw2uXmF3Ymf0XWvGNFQ1osdo7yM/YS23dksb0CIHtyIn0gtQxp\nWVJk8WzgSVsGQP5wdJ87BdfYTDi81naM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISARRF2u362nwTHsFh8geoP88rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTBiNThkZjMtODIwZS00YjIxLWFlYjMtMjM4ODM5NDJiZDNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZjlkZmU3ZC02Y2Jj\nLTQ3NTEtYjc0Yy0yMzk4MGVmNDg5M2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASpbsBAJEnSara1nH5huGSMVE8QFZCRp9kf9lx7X4ue2nhYCoGLw/qdq5Cg6ixZ\nT5tzPCQAdw4vgYZxKLf0oR5oo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQqvRErH9UQ9BWt\nBVE2R92EMSXrajAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQD5\n6UDb3YGyOtK32OxSaADW3Fd4+yfWpyhuEsMsjWayeAIgWkVqItnG+YVctBYZOEDw\n9jROmcsvDy8r+6j6jEY/Y+8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7511", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7511` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAaZtCxySFyrMu+UKBh4SreauMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjOTc4ZThkLWQ5ZWMtNDVjMy1hMWE4LTM4NTI4N2IwZmJkMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTEyYTBiNDQtZTE2\nMy00MzVjLWI5NDUtZTc1OTMzNTA0Mjc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEALPA1/hH8fcGKvM/0kc4Km8pGQM7hssCwJIYVjhCedEoSulV5KGPvvYzLVRN\ns62Xsjwh3/07jeMlrUw25+RklqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcQAj6QfISyT9Y89Wi1EylGQorgswHwYDVR0j\nBBgwFoAUz9d86lWRJtDWzvOXHr3He6Yrn2gwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAjsA2kp8PoZW/jgJMQUYRSppFnEu/V1bf\nyj8tu1c7Qb0CIG4/FF2gQ7wOwv3OYCahwrD1hzvsgRP3d+YhODC9P9Qh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZsCmNi6X3PAgkF9Cuabzq5GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzk3OGU4ZC1kOWVjLTQ1YzMtYTFhOC0zODUyODdiMGZiZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgt4seey6VTPtMaWfLHfsCBBn9y/YYWJkCuxvJYbWs7kvH\nzJy+3Fxw54+H346bzEzd7fnQFRTMGVMA3nlNTu8uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz9d86lWRJtDWzvOXHr3He6Yr\nn2gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMogsx38+NGHbO1Uzt5zfYoRy2d4h5uhITxUgg0IDnPUAiEAiLdeZ0SY\nCCN2u41BPjYDMDb0m9T+KQEXJWpX6y0dffs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAYqwkiW0Cfqqm+wxK9mmKwPkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTEyYTBiNDQtZTE2My00MzVjLWI5NDUtZTc1OTMzNTA0Mjc0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNmJmY2M0Ny1lMzZm\nLTRkZTctYTY3Mi1hOTAxOTQwYWYzMjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARSgC+ZqDMtqsnullOIpTbHfD0u5/rqgp483khLb1FjaD/rTq7dCfDumA6GlfTB\nKBEVr4ilr515Sl6RBCZN9/j8o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxACPpB8hLJP1j\nz1aLUTKUZCiuCzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCe\nsFvWMfUM/2gokgpzQqKr6rX5d9SsHrTv+QtpPGPC2AIhAPdLbgM7zD6H3CljSVug\nhCHyzRq5r93HlLzA7LfnHKFF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7512", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7512` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAYR46OVc/kdatTORn1KeAEfCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2ODIwOTI1LTIzYzktNDkwOS04MzdhLTk4NmI5MzQ3MWNiZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZlZWZiM2QtYmRi\nYi00OGZkLWEwY2UtZTIzMzQ3Y2U0MmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5a6R8P/wuAlvUZv9OM7Lgkl2A8S7zoeo9CsSrolT5KfmfuHzC74CPslrS0sU\nf28nnQAuf//3v7K2sJMPQp/VfKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuSuqnHqzyrdEKejFEAQKKF7v0AEwHwYDVR0j\nBBgwFoAUPFdbU90DsvmvS7oEax6epcltCy8wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAmrS35gM2jUmEzYHfRYHfylwnDwEbkJ4Hj\niGor8RZfqwIgUiplnhGwlZEN3NGDNiz+9QcMZOe0UO8AS9/7KToeMOU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5XjSZlvpBm9UC/irgNlyeRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjgyMDkyNS0yM2M5LTQ5MDktODM3YS05ODZiOTM0NzFjYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7K0e4mqiV8VXBM2M4/sN3bi9HfSMtUC9HrPIMLs4xwW+C\nX3RhMr7I+T90LiIK584Cz915A7ciilWIYE7Q8Iy7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPFdbU90DsvmvS7oEax6epclt\nCy8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfipSI5JJhxyL5IPJC1MPXnUoLums/+ADFUOw2cP0W1YCIQC8B8PpXFG1\n6S+MWBIBhVxF4c7nJC8z6pf0Lb+fCn+cXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAe37g3n6Hz/pX1VWputcTWBnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZlZWZiM2QtYmRiYi00OGZkLWEwY2UtZTIzMzQ3Y2U0MmQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMDRmMjNkOC1jNWM2\nLTQ2YzYtYjU0NC1lZmEwNWY4MzA4NzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARTNppSAojgHoVwzti/9WYu2h+57zKkiRMPgf/DNqYukdamXqv8OMaX6fwE6Xni\n9eGiegWVpXC4xX6c66WyKrfuo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS5K6qcerPKt0Qp\n6MUQBAooXu/QATAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCP\nGiN2BV+TdDGI9UBUBhUQ3ytUR9I4dakgm/6OZtFlPQIgCA2OvAKd2hyMJpvPS4m5\nN0PDjxWvIObCWBd0tS4hxW0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7513", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7513` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAcfxFcPQxWZ9G1BenYPhnO8wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiNDY4MzYxLTM1Y2UtNGFiNC1iNTFjLWZkOTZhOThiOTRlYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmIzYmM3ODMtOTZh\nNi00NWIwLTkyNTUtYzFiMzFiNGYzYjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEel7f/LCB17tNmXmxJ+UMl4mg+smasswBR8HYDAYt8SoP/AohvsHDAxQat9iI\nJKKjzTbS2YOLHP6+TKA5+/Xrd6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULB+GqhlIs2wT5t9v6Dglr0U3zcowHwYDVR0j\nBBgwFoAU8fYDl26HNl4dkz4QPhrLbhxLXBIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIQDw7GWmFLSqC8Q5qedyo1c3qz1P\nnSlT2nvqs1yU+LN8iQIfP8feIuUwexAZgQaUV+WZNEDsV5iovmU7q5On2aa2RQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR1+PY2rxPjSCFyetNa6tGFIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjQ2ODM2MS0zNWNlLTRhYjQtYjUxYy1mZDk2YTk4Yjk0ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3g50jd+7AiNPDZfVgfI3ldG4WUk4eaQZJzpCD6tukQz/w\nANjy8iliTLYcPafW1DTIfkTEG5+g6+SDQ32PpEaPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8fYDl26HNl4dkz4QPhrLbhxL\nXBIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPXOLATooSJ+is7eUjhSxEBD63u1fhY5e+cCk1c5mqqDAiEAiKZHkNf+\n1B1ST+gIkbfmDSQ4V/v+5xOEfi4iEoviO6c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAZIQaCz98oWR5ZCfGvY9i625MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmIzYmM3ODMtOTZhNi00NWIwLTkyNTUtYzFiMzFiNGYzYjBiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMzk0NmYxOC01OTc3\nLTQ2OTAtYjc2Yy04ZTAzNGQwNjRjYjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASpVIgEZcqxKGd78m27fpgc5IfvEJdXLyl+7eX9A+cENmnKUOu0g0QtDlWi9J/w\nV9/cjLoXKcOC2KhjGdtE1OtQo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQsH4aqGUizbBPm\n32/oOCWvRTfNyjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCw\nDkZvFmztsMBRX+qMP4+6xLsCjVPiHA5pe+i2JpmewQIgU10NaTaPZ4sBHO3ZeDrO\nJptGFBBOThjsBixVdI1TQXA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7514", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7514` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAV0CGEnZdN/ILgsQmpDdFufWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNTY5YTczLWYyZjgtNGIwNi1hYzY0LTYzMDIxOTYzZWM0ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc0OWNkMDYtZTNk\nNy00YzI0LWJjNDItZGIzOWI4YWYyYWM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWKSx45P49XXa3P+K3pP9LHnQ7v6AjR1sMdxjkIgRqc8ORK7bxQ4Tq/zQU+Q1\nqvdx/wBksipBpkLr9kE4d/1lRqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH1cST7JhKf4MAuHKfXSn35t33agwHwYDVR0j\nBBgwFoAU0B8gN6dbsJyTbOTjzCELJbGN1qMwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAITsZxSA\neISGbuYNvf7TQDwd6zHCeFIxrHi7FhqXxjtwAiBw9RHEpM3dcE5ttwXbKuy5/p7/\nB9yJgVlGGSqWwX1Kew==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQKFFEZvl4KYK7vDTIX9BxG0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzU2OWE3My1mMmY4LTRiMDYtYWM2NC02MzAyMTk2M2VjNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgMbvAiFnMRV2XEFPhlOj2yFX4XvwIWdKF5lHLnz7icjlf\nUylKWYeR4Gxn/FEzjKq88lEjJJJr6UZDuD0hoSVto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0B8gN6dbsJyTbOTjzCELJbGN\n1qMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPFu9Wvj5OKKVrRZoqCZQ7+b5xdoG3r+K0oLhWDwWgJTAiAvJsfnKBsu\nqBoGU35dsojiy2Px+iTcAIxwqgUN9aLFtw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAfJHGWrnALosPSL65f578IcEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc0OWNkMDYtZTNkNy00YzI0LWJjNDItZGIzOWI4YWYyYWM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNjhlMzljOS1jM2Fh\nLTQ0NzgtODc5YS1iM2E1ODljYjY2NTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARW/8a8LqMONHQVw2zWLq9JxM7DlUXZsD9wnCHe3H9WMFhncqgle/ysHYzGatkG\n/LyG57UKmmmJhvtdc+UtkhwPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQfVxJPsmEp/gwC\n4cp9dKffm3fdqDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCK\nsiBDcECWtBq+DTYprI8Mt77qIQNbJ21SpqgInzJsPgIgECRJfyNBjFED4RlYRMCC\nGcvYWIPxOOd5SR9XDgWB+98=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7515", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7515` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISATud5K2JdGgC7iP07BKD08iZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ZjBiNGQwLWMzOGItNGVhYi05N2VkLWU3ZGM3OTczMTFmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmUzYTA3ZTQtZmJk\nNi00NjU5LWIyYWQtZDdkMjZiM2UzNDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEImw3AsAKS/qV8Hnmp2I3uEjqFADnVjl3YQ4D+kdCRJIA4vQliP84BAiEwGGr\nFappgU3ZPclVRy7jPX+cp8HNuaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbzGzq1dEvoMyLm5e7jPsZTEpClYwHwYDVR0j\nBBgwFoAUplQnxhWd11wObTRqcLFjNdpUxR4wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIHuy7TL\nqRc/Y8u4OzIikcwei/Z8nHgbs3u/vEu/ZcPkAiEAnAceWcnwkYOjoDZ7EEzyZ+Bq\nJ+8qTMh0ZlB9XWuqWyc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcxD17rxGbU/zQRg1ossJODgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWYwYjRkMC1jMzhiLTRlYWItOTdlZC1lN2RjNzk3MzExZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8l2MSuYJrwy9EjouJQmwhPQ0Oc6qR++OCUgQEMMK9aKvW\niVMKQDdbNgLTNn+DYWWJfWKXLEAVp6jOO+83Bl2Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUplQnxhWd11wObTRqcLFjNdpU\nxR4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJzcHhCwTAfDvo6y1+dZUF8CXy8oNbkfQ9Us6TOj2yAzAiEAgvxQ0HGx\nXkgvpVOZF/9j4y+BJXrL2r2BA+nkd0sNnnU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAb9ZH1aEJp4YTzyFr77CxQ0UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmUzYTA3ZTQtZmJkNi00NjU5LWIyYWQtZDdkMjZiM2UzNDdlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OTIyNDg4OS03ZmE0\nLTRiOGMtYTc4NS1iOWIxNGM2NzY2OTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATQ/PxE1dB5AAEbi16C0NqITXJEYNlqMZevTcOLu+kdSDVgrYlF0EBoJ4K76T+z\nvYmYpx/PcqDRgRq2ZqPEDy3mo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvMbOrV0S+gzIu\nbl7uM+xlMSkKVjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDs\nG3B2WV1h9WWUoBlxdtKaCgtd6jTTzvixBhw9dRppRQIgKY2cvSb4bYwmHAMhEBja\nwM1nelqaeON9QeVdC4A2ma8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7516", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7516` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAUpiKfC+BtNC+r/8t2dLr+qKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjYzVjMTg5LWUyZTctNDZiMC1hYzUyLTdkYmRiMmMyYmU1NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzljYjAwYTQtYjM4\nZC00NzFlLTk1OWUtZTMzYTE3MWZlZjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGCbAzIWxdybFpnol0d5n5xmPtOJzWbGUW+IOqHyw7Q1Hmhn7WKP80sdBz1Xz\nV3BXycal7Xatlel0pP/SHWC9U6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ05btabhVl5gV/4eAhO7Qeq6plcwHwYDVR0j\nBBgwFoAUbx6MaImcALST9yHhijoHEpwluHQwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICVtCENb\nzKDbuwwyN3G1bd7wl2U5Re2kzof0FdSJx0pjAiEA2isBuKdXIzO2zpu3TqFh/thC\n7NXPxzbTfuvhs9BS7dc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeQ2u/ywZbJkt8D+LBf5aZvuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2M1YzE4OS1lMmU3LTQ2YjAtYWM1Mi03ZGJkYjJjMmJlNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIofnfNwvzRN/4kvOfIwgFbhsNEcM3Z13kXGJensjR+3s2\n85d6rueQqwM7KtZbTd0w+nRJY8gUwaH6gbDDnVdEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbx6MaImcALST9yHhijoHEpwl\nuHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCHR95MhteSaGd0LESWxA1rtN4olqiwSs5s/fEZP3Vt8CIQD7O5Lbm/T3\nf/jZ1oQLd5lNms61llMlIB72SSbUB9Hsww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAb/81aAD6zb36yzMyrnzAbU3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzljYjAwYTQtYjM4ZC00NzFlLTk1OWUtZTMzYTE3MWZlZjEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMWU3MzU1ZC1jNTc4\nLTRlMmMtYjk4OS1mMDIzYTg1M2NiYjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATNV13KyOptuS4BC2JxTBOoDEw3H9CxYSgKsdy5CepC9+KqLAEYm1J1aQ+yDk2n\ncZG/jbYuNWAGbaIwwBz1qK2xo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRDTlu1puFWXmBX\n/h4CE7tB6rqmVzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCH\nAIjbwLWZZsRwudxN4oA0ghp1oenV9ERCHt7owDzo6wIgdjvbu9YSdmk5md+Q0amR\nhzfUBbKy7dIlhyF43Z874CQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7517", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7517` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAQM7mu1lpsphbN3SKKqMotb/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjZWUwYmI4LTZmNmUtNDJiZC04NGY3LTk4NDVhNzIxODFkZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJhM2JkNDctMTVk\nMy00YmE2LWFiNGQtN2RjZDM4ZWI0YzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6hOlHGrov/ypIKscyaSfX7prFsjWgAXIJlR76dEML6wHRo7wavRta3lk3dob\nuYKRz1p3Or8NOfv0eKZv9oQLyqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaoBOups086GwT/tn+jP7g2pIeW8wHwYDVR0j\nBBgwFoAUn2xpS9jEzqvO9Ly6Hz0+d3sQs58wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCQxkXmlPVeOUpWH2SDFL5WrKXPoLVBpOY0kLP0d/cz/wIhAPWJ21Lo\nw4UgWyi3OhCPEZ6e9332IQwSAWP2pfQryseJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcANmKIxrGeshGa3moI4F/tfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2VlMGJiOC02ZjZlLTQyYmQtODRmNy05ODQ1YTcyMTgxZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyFO2mzqN7GQCQ7+fmKceu4+7wMbK0rJ10h2t6VSf+i8Vf\nxST/Em4pRL7QW4zm6FSz19GfOfqP63bRjlnaWr9Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn2xpS9jEzqvO9Ly6Hz0+d3sQ\ns58wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM3KRwC/q8BsFgj6mq1N5hJYhA7Wcb0q5ptn3m+iMUyYAiEAka0uCTLn\nWTvjgrF7SHDWJ+aLFmBb1clmXVzI2KRZj0Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAfTutT5jLPbUmnCFLOrce7H9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJhM2JkNDctMTVkMy00YmE2LWFiNGQtN2RjZDM4ZWI0YzMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkOTA5NTQ3Ni1lNWVh\nLTRhYzItOWUwYy1mODE3NzEwMjIyZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASsHJWwn5NCFRAB/j9ZO60HkCNbaBHHez66cXDV548qIofh6Cw1IUsIkc9g0XGB\nAMEeVDVia7fV++Nq1aZ+KiWto2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqgE66mzTzobBP\n+2f6M/uDakh5bzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIDIm\nhyP1ahYl+BYA9HfttKlwcYGpYxhAfezOVGnI8gwuAiAXuretm+ozMN5+hwWQdIm9\nkbIoe6HbTHnf8rLPTXWq1A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7518", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7518` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAWHVVQ+9ci8f3QL/SYbJdqHRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkMzRkZWZiLWQ1MGMtNGJkNy05NjY5LTE4NjI0NDg5ZTVkZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk4YjlkZDctMjQ5\nMS00NTIxLTg0YzctZTUyYjA0ZDE0MzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbRUQ0BI2jad2ntr/sbVd/1oUooLdtgToaceTbcvwmTAs/MnblfDwaWQYAVhc\ndvKRuhCoBGWVq+W14mAqZ0gqcqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1g/i3FbPPfUqlSQ6KamPqOUHSgEwHwYDVR0j\nBBgwFoAUZYySwRSDKQrwar2o5MAHzt3Lgy0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIEa8USiENG/WwDBxgdS/a8Xu8g0k2mcGGZM16TLm3IDNAiAU6aUHCcAN\nFAdDm6wUjPvQDcv8bBL1CthaeiZhwuwVYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASs5jxrZ3D1tJKE9un7XUyWHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDM0ZGVmYi1kNTBjLTRiZDctOTY2OS0xODYyNDQ4OWU1ZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWhDR0gtwgRiP4aZFGYCii97VNUQKUcrNm70S8mwCwkvvT\n3JJEDpeiX3QtCXdJTeOogNItC0Qune2UGplK8I9oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZYySwRSDKQrwar2o5MAHzt3L\ngy0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTZUPvjBbCu4/yY8dL8LpG8qT/bZIbVO3CIEtZBdT25cCIQCRT9dOUi8b\nKRRQtDoVGWcyIFYeu8xFffQsD1d4DUNElQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYmb1adhQEO0ASttGibm4oPzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk4YjlkZDctMjQ5MS00NTIxLTg0YzctZTUyYjA0ZDE0MzdjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZjQ5MGQ0Ni03MmQx\nLTQ5NzQtYjE2Zi0yNmI5ODI4NTEwOTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQAASSvLKmLiGG27z6gmqxanLW44nXUJQVv10qhQCydGHPf4dCMVTpHjIF+K0gK\n4gbKqAs0/k7nwqW2+OJQxmDEo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWD+LcVs899SqV\nJDopqY+o5QdKATAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCy\nbGVgtiFzfjby6i5T4569md0cdgqOiPkREL2OmO6w2QIgG6BuYhq1g60G+JoKBSx+\ncWLAA/gYo27AYPItenvlFaA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7519", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7519` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISARISB8dRIxZOstLWL/HU2bgnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyYmRhYmU2LTNhNmUtNDU5Yi04ODRhLTIyNDY0MmVkYzJmYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI0M2Q0NWYtYzZk\nYi00ZjBjLWEzZDQtYzVkNGUzZDVjN2MwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvLPIn5AvXnBS/34PSHMcgpEHqyLdPVbC4hLHl+popYn9hiRCz9qLcK2IEKhl\nJPHB8GxxqivPQgZFNjW/uag2/aOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV1uFCqUdlWzOCxYCZd5FOjxX7vIwHwYDVR0j\nBBgwFoAU2cpV+A3SlGMdxG8OLZPW48Q0FJIwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIAXMvkZMZXD8X/CScQtHTcWxAVTk+w+KvCDAeR64dfl3AiEA4HIMyWnVXhdqpx86\nowBXltOW+w4isy/Z6kj21MqevFc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARcazgGmqidU+34qzo8ezMQ7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmJkYWJlNi0zYTZlLTQ1OWItODg0YS0yMjQ2NDJlZGMyZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaKMnE9zgD2XzbcwQ5h7bBjCxpQEiQvgxAcwxm80M04qrK\nRT61JioaXxoT/LazEjXrCmBx193jsHcmob+EBEFoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2cpV+A3SlGMdxG8OLZPW48Q0\nFJIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPBLK0kkVWeItKNiQ8wpKz/bsbwnCT4w2wq3vNly1mi3AiEAtefAn/1J\nElgSeNtBslrzIAP1nIGqfb+g7wgiuTASRnI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISASVhMOZIklvJYb+qx+9DSLRzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI0M2Q0NWYtYzZkYi00ZjBjLWEzZDQtYzVkNGUzZDVjN2MwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZDdhZmEwMS0wZDRm\nLTQwYmQtYTYzZC04OTA2ZGEyZDg4NmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASILUb49zdi2vrjQ/qujJOUjiJp9m4pt7dr0ly8AKmz7La+PhfDvDYU8CkItc7l\nAjZjz8+dX68TVTxOsWvOuAndo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRXW4UKpR2VbM4L\nFgJl3kU6PFfu8jAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIA5/\nwA3JeW7QoJjha2QJrlcIyJX0fCmBliSJFSBFdYT/AiEAoZjYPi+eOZVU8zN+JYrD\nZ0Q+c0NBVEkUQ5DpuIOvxA8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7520", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7520` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAetddlt6tTQR4sxHxT6zkmaOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmYzU0YTExLTQ5MGQtNDEzMy1iODAxLTBlMTRlOGE0N2VjOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU1NWYzM2QtYmE0\nZi00MTc1LWI2MmEtYWY2ZjNkYWIwNWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECG3Z/ZTHsKGdEWhs0Uumf0Ntw9VKa1mc/m1xah+25Qtlo+W0V9BsILRBMciH\n63/A2BZSVdcKP91ptJP0g2zGe6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpgOM/9j4fqMedf16hVK90sGEQzYwHwYDVR0j\nBBgwFoAUSGdbJ/GNMnPBlT9i3tQPlH7kh38wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIGlzzOTZCV8llBC4UUWo0tOF776n1pLcrS4Mi+o2bhnoAiEA\ngJZLwd+sqkytwgb809UCORx+3sIQIqnLUnMvrS8+3/s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU4cXKK9VIZe7xhVkcURLhBOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZmM1NGExMS00OTBkLTQxMzMtYjgwMS0wZTE0ZThhNDdlYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR48DTv3hwEEtTUhsh23v/PxGc+1k1VdyHYtOlx7Qvuimnz\nmGOTbm71msYlIBIAZLQ6f9HkJe/JdrR/3c97kdt1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSGdbJ/GNMnPBlT9i3tQPlH7k\nh38wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMw5rysy7p9/CRyBDPNiaVMTAaLCponZ/acfagmF9TZLAiBaOno4dZC4\n0AHrThFypHEN+1984Kbbb2+3A/VFQoHgzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYydmrO3zAQxwU2Ik5VU3IBQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU1NWYzM2QtYmE0Zi00MTc1LWI2MmEtYWY2ZjNkYWIwNWMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNTI4NjE0Zi0xY2M1\nLTQxMDUtYWM4Yy1jMmYwZmFhZDMyN2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT/2FyUjVaLxOje9wfJSv7I6jp7O5rT5cx9yYNQ5GkKCDONIh8at/v8eJSfRjdq\nZyFnoIdv1GaHdFUxK61OCHmdo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmA4z/2Ph+ox51\n/XqFUr3SwYRDNjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQCI\nIdl/Mt7/r1EN8J5oWC6jLrQPhtLf8Oj7dUtXKdQa8QIgAfXPNkvDD6k/+286J7M8\nMplhn8AutTgL23FpDvU2HVs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7521", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7521` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAbC0nwPQ6a8zfMCUAU39p86fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4Yjg5ZGQxLTJiODctNDE0NC05MDM1LWQyMjIwZTIxN2UxNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFjZDg1MTQtY2My\nOS00ODQ4LTk0ODQtN2JkYWI3MjhlNGNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0COUAuHILOtE7I+tJA4xMkhxTse/E0GZ14J88vcG0s8k28h3T0nXD+rJ6P/8\nEtJ6PrbGiIis8xx401L8cyHQEaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdj4cgaF19bT8/+G4+ndNZaMlf2cwHwYDVR0j\nBBgwFoAUPitypFVOQzx5LdSRGGsFG8wmtB8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQD9G1m/lw5UYFOVBRrUDZpqP9hiNlzsXi7PGzZZHO/q5gIh\nANgi31DvudWR82pHSEJONzQvk8tyml/DOIEiSJBo/yA0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfLKnEuXHY6ccMb0H/Aa6eeRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGI4OWRkMS0yYjg3LTQxNDQtOTAzNS1kMjIyMGUyMTdlMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpxHXihhfTnE8Rhqv1YInoKObg5dxP8OBWLjFDhEfoBNDH\nogWBWEw61WB0tP09cRYgKyUOPaF4Cuq9uIUxJISlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPitypFVOQzx5LdSRGGsFG8wm\ntB8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW3EBxqS03wg9c73+f8KF6CyJ0VHELQgVI3vi/OcMsvQCIQDzGmc5ipgv\n1zLojMEqb4VdLBLAwqkK1czeLfXj6glFxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISASwonEaWBO2zz9mpKapxhVFDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFjZDg1MTQtY2MyOS00ODQ4LTk0ODQtN2JkYWI3MjhlNGNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YzBhMDk3ZS1lM2E0\nLTRhNTYtYWU2Ny1iNWE1ZGM1N2JiNjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARhPFVjMxhhrxgvxXssLrPYl9oCqnuZx0oD6PAEONVRh8nAwGwS9giDs2fVNHpw\ntjohv0SS7rCtlwOR9bK+gY6Zo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2PhyBoXX1tPz/\n4bj6d01loyV/ZzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCQ\nPG9wZnhVVHtD5IGLgwpO5a7WJyug4a3wi1Uxus7peQIhANBkkvUeRnIWIfQZs4bL\nQ+AErOcWwuMUZ6JtrsQikYVD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7522", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7522` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfiWP+IkRCBd3YTMCZhtiaBZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3NmM0MWQ5LWNlYmQtNDY4MC1iNDcyLTEwZWM3ZjEyN2E4OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNmZWUwYzEtYjRm\nMS00OWFiLTgxMzQtODIwZTBjZjcyNDUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfPj4oSsLVTmJ1H/2R0XtFEz/1Nuzf/Qrb73gwwfQAtXNzHPY72VBfPtVf9tg\nODHpKhZJMTweC8QLTnU4b9AqO6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh4tEzdNZxd9O3kf9uYdSTQDZ2A8wHwYDVR0j\nBBgwFoAUzaxakKv98zOQkWO/PdQrseI1yXcwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIHmqgJjSQT85\n36YAyK/hnH07/aWCEm4zWi9/hhSwbxjBAiB+JDDfZtd1mu6H9wJPY0J6jugcpxen\n2fnfCRJnCUbrag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYVokPOKQD90ONVudwS33By9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzZjNDFkOS1jZWJkLTQ2ODAtYjQ3Mi0xMGVjN2YxMjdhODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATd3Co40BL86FIhUjQuzLqivrPBzHE81NaBrh+hoittoeh8\n6i9PjKcpFh6KsOpyLfE5VfYtekYm9a8SUYLIcuaeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzaxakKv98zOQkWO/PdQrseI1\nyXcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN4RQQKAAGZQTbGIQAt4OtrewLgkZbkjC0/wVrKqYECIAiEA4kmFor4H\nfpPpdGO3JsqKm64SmOhx06qNB2EYTeC6BtU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISARL7Bw8im7US70oaiMzJhUpfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNmZWUwYzEtYjRmMS00OWFiLTgxMzQtODIwZTBjZjcyNDUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NTgwNTZmYS0wN2Vi\nLTRiMGYtYjMyZS0zNjhlNmY3N2E0OTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARSp0aTdnaApdDle1w4CYH5ZIuQ05fLtgPkgb8uccfErRQTNjYlA7tukYqyqpFH\nm1K2DS4HOZmq/Vu9OeLPgUYIo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSHi0TN01nF307e\nR/25h1JNANnYDzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDF\nZrGXgSSsSCj6TIDO+1VmdXEAfRbukKrV1IuRi4p2RgIgUWHNRMc8ltGygpv1fc9r\nzktItsjfawvu8NfNukoHKF8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7523", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7523` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZlu3KiLfMrJF/eTPT6mKHSqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlYjJmYzhkLTdmNmYtNGVhNi1hMzkyLWQ1M2I5NWFiZDMwNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMzNjBkMDQtYjBk\nYS00OWNmLThmODctNTI5ZDUzNjhmNzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDSIHpvnLFfmAbZTALSvzMGPqyA/axi/mThnK6cvxjwtss8Lkzo3c1hl5mc5g\ncBGoptsNX5EWUBvddgbrHvaEmqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7lfDzu07N+C6t+MxqRc5B0L6uPYwHwYDVR0j\nBBgwFoAUxeqe4xBWtXfSStMxaqqp88QaR04wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgfaga3Zm1CN49/UtenLpzWFKIqwMcjAZjpu+QZCpIdxQCIQDMzWLOF/Jt\nivT15r3lksXO7B0chMjRdRnRlfaHv6MLWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAflyZBfrlnmC65oIGKG1d2qqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWIyZmM4ZC03ZjZmLTRlYTYtYTM5Mi1kNTNiOTVhYmQzMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/KaS83uLMXKIr2tqwRZQJwZmoqbleDDxLhvWGylArvzgO\noO0Seleu30cKgmE/z7s3GlDDM9R0kvI8AUa6b81Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxeqe4xBWtXfSStMxaqqp88Qa\nR04wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPwOuwfNlNs2nuGh+XWgpqsBUuAVHtwLe60L/FmSWKQeAiB3H3v6Fh6o\nKbsihBA+H9lWBPGOxTVgq4fSzBcwYwnaFw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISASr5yal09ok9UJp0q2Z58jx1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMzNjBkMDQtYjBkYS00OWNmLThmODctNTI5ZDUzNjhmNzM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ODU3NzIzYy0zZWM3\nLTQ2MzMtYjA3Ni1jMGRmMmYwODc1YTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR5WLkd/cg9kh/s3htsfB3lmusjGg5/obkbVSSFMWW8FKh9IF2CF48JYQ+YPDjQ\ncI9qm/NMNe0arY4crukvd6Fao2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTuV8PO7Ts34Lq3\n4zGpFzkHQvq49jAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHfr\nnySGnkZ7b/ouoqrhb61RKgE4biKhICmciho/sKMfAiEAizbln8HoJ+sHJV7PdeSw\nFEdWDSR8pmkKkM4MYx7ozUw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7524", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7524` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAaLs63VTs2EK7b7P0eFO84PWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyMDQ4YzIxLWFiMzItNDRjMy1iMTA3LWY3YmJkOWVlNGNlMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY4MzAxZmQtY2Y3\nYS00Njc3LWI3M2ItOTY1MGQxZmI4ZmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj8dL0oaSYcU4d8Ar9hbiI8lKEkKJ04+GuarNlITs+uLuEGeRMtVgcgDDTfmm\n/Kj0TKgCKe1JaRojoyOW8gQPYqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU61ncGsQJ6CJeAg5381BYTJkqn3swHwYDVR0j\nBBgwFoAUlYyRsHygIHl9uHpDCU3Xz2B/sF8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPVX3nqfgpyjAR7kb/4dZ7v6woYmdHIaPArHT92ZR82pAiEAww2SR3FG\nCkL2kWzj1JporPrkDyBqPS3p1fpQ16+5Pg0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc+y0AaM7BEXfAePxpr6zt9gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjA0OGMyMS1hYjMyLTQ0YzMtYjEwNy1mN2JiZDllZTRjZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqvOPyymPn1eIlKwiKfdUSgWlajniMU7rOY6trMpwxQ+eP\ngU3vtRe02yV/mIssdnqKPy6wTwrwyLnaoq2Suz/Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlYyRsHygIHl9uHpDCU3Xz2B/\nsF8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKFDK8+Q8JzDhrFxR1bcsD/DaMXev1luS5o60VEEELGtAiEA976O811K\nVUzwsjOIRmrckkn46c1XWHJ2ewbPjId/4jo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAQBjFp0BdfsOYoi0DMSdytCiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY4MzAxZmQtY2Y3YS00Njc3LWI3M2ItOTY1MGQxZmI4ZmE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkY2QxYzM2ZC1mOGIz\nLTRjM2QtOTQxMi0zM2YwZDdhZTAwODEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS6U3UhN/Xen4uhe+FJfG+8jvXhzrJs2bTcjcE6OJloTIt7gmtKfnWp279TnjUH\nwh6im9PiGICWmUBmlYs6AbJPo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTrWdwaxAnoIl4C\nDnfzUFhMmSqfezAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQD8\nlVzvTRBi41rVrf1nTepZ4nPiiiA4V2OKnTF7YJ0JrgIgW1KnAyrbYNWq5EIS/Ta3\n6tP4kLwWkebAW0xFYxsWDS0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7525", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7525` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAdPXtJPBIK0LPQDmFBtEWQVRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5MGJjOWMxLTRiM2YtNGIzMC05NGZlLTNlZjQzMzlkZmJiNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGMxMGE1ZmQtYjdm\nMC00NDQ2LWE5MGYtMDdjNGQ1ZTQ4ZjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfaU48VFwV80vqjhID1AkHgzxQEIYbqngKHtVidfpgp/x2gh2GvHTuwjahJ8E\nHiBqG4DKZvpjXStP0DHWrk7Z5aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULFSectcoTpzx8dkiwln224RL4BAwHwYDVR0j\nBBgwFoAU+p2vq0IkgaDe8U9/I91YLIvDGH4wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQD+OV3Q9ovRtab283ukQyboOVcZNJeA/3s/kjN+hm8gtQIgAqpdfrIn\nrrrEeUky29UVPIr8FfKDewJOBDBsdMn/MQc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW6NSmLCtDGxVxV+0GRRlGAqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTBiYzljMS00YjNmLTRiMzAtOTRmZS0zZWY0MzM5ZGZiYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3/8NUUlopgCSFCld+ohmlZnYa0DvfMh7yGT8qdGSwRqOU\naEnMiediiunR0FGGb0gSgph753hixZWXK+Qjuj2so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+p2vq0IkgaDe8U9/I91YLIvD\nGH4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfrkK6KN+kMgRLKwVXR8vyBDRxQ/TimuwyNEp7PPqPdUCIQCzYzevx+AP\n9uol/vTllXT4UqtLbALUR8fT5ePodry3TA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYMuQN7TWnV7jGISXwS5tJMAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGMxMGE1ZmQtYjdmMC00NDQ2LWE5MGYtMDdjNGQ1ZTQ4ZjdmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMzIyMGEzNC1lMmJi\nLTQyYmItOTM3MC0yNDQ2N2U2OTRiZjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQLgpZ1T0rb5ahnlHOjT8Fv9Jx0oG2QInZSfY7UQWATk/VPWNUr2DAxi3cUVcoZ\nc+2JTa0Ha2Rwt1eMGEDqbz3Co2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQsVJ5y1yhOnPHx\n2SLCWfbbhEvgEDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDr\nkgHRIKa2RtgGtxk7lAsXJT5CXdAw1RyeU6Gt2b0UHgIgNpbDpSdLAzfDuNyK6GZE\nvkv0FepCmWf1NvAne+MpU1k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7526", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7526` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVIyeUhKIqBo32lIqlEBm8eNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxN2YyNDJjLTU0YWMtNGEzMC05MmMzLTA5OWYzMmI0ZTE0OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDVhNDQ2MTgtZGE5\nMC00ZjFjLWEwMjEtY2Y0Y2E1MTE3OGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEozv6K8+HMzNilT4GDJCl3vlrul887HRzoVyJVTRMNMnPmRu+m3F0lmdenz6r\nN6E6J51uch7UF4aW1RDLn17GdaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgqnZH9QUeCRdEvWrvO8eduDflXIwHwYDVR0j\nBBgwFoAUGlqm+QzLCbsx6gDzDP2kxcPFAOwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC97OMNsEHqqOdAeLTqVuAJoVkLW+woVFoGTPt5\n/Xc6QAIgSXMZzT22Q8bgSNGn0udoH1zYQ1ImXZOQ3/ayHY1aoQ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYldXz3IGgdHLvWm8kKO18XSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTdmMjQyYy01NGFjLTRhMzAtOTJjMy0wOTlmMzJiNGUxNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/AFU9e6nSTC/vvK4T15BHlGgsxp4vUrt11ij3ZCazarO/\nXfvAmsFiGWjp/18lQauY7+JxUUCtXuQo0TZuMvIso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGlqm+QzLCbsx6gDzDP2kxcPF\nAOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIhRpyYH/k+KYHicn7Oy8CnRcu9zDo/Y4JHBvsvWACBwCIQDqCkCEw/PR\ngzQZlQ/O9FzsXZ9bARlIrPyVHeG1nbBYfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISARvsBWfdCnM1SNUxB3ve194WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDVhNDQ2MTgtZGE5MC00ZjFjLWEwMjEtY2Y0Y2E1MTE3OGRiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyM2M3MzQ1MC04NjU4\nLTQwZTItYjgyMi02MWFkZWFiMTA1N2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS/PQb5oo3SZJ3GHg2OB0CxLftKn9mv3Acz8vztKAj5L6YswPm9pKIQJ8ZPaP91\nZIxyrU5A8AbO7ylqrAenkul0o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSCqdkf1BR4JF0S\n9au87x524N+VcjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDM\nrjK1FBtU+s4FvHAv7W9hDwdK0vzeiN2KvO2HScHzQAIhAPVU9RbZ+suJlUggYVaT\nNJ8/7H7JR1vqSjno877W1IiP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7527", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7527` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgigAwIBAgISAbDj2rq9VtlCl3tzVWgqsjItMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5YmNjYzJkLTAyYjktNGI3Mi04ODFiLTMzNjIzMDgyMWVhMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdjYjAwZDktNmNh\nYy00Mzk5LWFlODktZWY5NjI2OGRlNmJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE51mbVWcvXXsINViECfmF4evDPaevDZGKo2DNOH0Ls7nbXHRudIn73jgEsEd0\n+DnaU9A2OwJ5u87tSIqzbLpv1aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY8WkAEvAm3vt1T2RhTZTYqUGIZUwHwYDVR0j\nBBgwFoAUdlpcGK0Pj4Z0ULWUCqTH+9NOXSMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0YAMEMCIGb7DcNJv4Nq6cm/5MU9Zr5R3CFpa57lpFokR/CW\nS1AVAh9DCMt6BEYzVcHdJLHGEXyLv2Iq2r3AdERjGIA/3Ygn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWUgpfUd1ZTShPUU0Rh3d210MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWJjY2MyZC0wMmI5LTRiNzItODgxYi0zMzYyMzA4MjFlYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJLIYPgJBvXHHw/FbF0/WdTZk3CodDmKYIVjzyfJInblbq\n/iOh2psRJG6pO1aQYr2Ed7HQfde3X3zj8ED0xHoBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdlpcGK0Pj4Z0ULWUCqTH+9NO\nXSMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM0l7RsIf1Pz0KIa3f/miw16ca6lIX0gzoDvpNEVkpmwAiEAu3CuEbOl\ngv9jif9qjVT8gIfaRgROPD22b4nfNI5sSIw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAUhTSwROyNbwdwYIpyDotIV9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdjYjAwZDktNmNhYy00Mzk5LWFlODktZWY5NjI2OGRlNmJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYzg4MTY4ZS01ZmRm\nLTQ3YWQtOThkNC1mYzQ3NDYwYzE1Y2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASmPY0m3nZSm1BtJYn3XzHeGIhJoaJMIfDzH7RKOYxVyYxcmphihaCzctDK8fBy\nfQb3jUFI9gdU5L/5B7JrUl/Fo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRjxaQAS8Cbe+3V\nPZGFNlNipQYhlTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIBBI\nSSa4y2vM+xgB8PzqT7Eab5PXlp0+zF2tdsWpoZ5AAiByY+j2aT2LaTIyuS5+N6c6\noJDksIQAlEIIcwkztwHEyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7528", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7528` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAbW4PiZhRT2DCQo39YVksytnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMTQ4MDNlLWIzMmEtNDA1Yy04Yjk4LWY3NjExZjgzZDk1YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM5NjA2YzYtYzI1\nMC00NGQxLWIxZDMtN2ZhOTJjMWJiYTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9QLocNVYQuUwMWingTFid3WLbZRA2VjI03il4kYgFjeLtmpmbeGhlffP+8la\npOR6+Hdxx8L/wxFmOQ5BrVAyn6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNkb3ND3xhF5fKDR1BM04QKQa4d4wHwYDVR0j\nBBgwFoAU+kkh/gbDGazAYTEl6fDLgRWedakwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQC22En0/8YzNkAaLCP06GTVrevNSXtPuSHdSEXmXQpIOgIh\nAL0eDysbAO/LiKAte+/+yupDqaYdSN/s75+m1lSjM7sQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARQhlKD+LGNNXZFkI4AU5gi7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjE0ODAzZS1iMzJhLTQwNWMtOGI5OC1mNzYxMWY4M2Q5NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5UmpKL5TfVjPWNpETQUIMUMqzCrmuV/rSjvLptCbYSd5J\na9FmiTTygnDuyzFkQQLMbsn9krlzFO2bWRzhd+w8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+kkh/gbDGazAYTEl6fDLgRWe\ndakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaQM6PeCjDeZz/oiWrE4QkmGS4qSZ/OJWTSHAQgk7c9ECIQCqxm/bauHA\nDFmwioPwggoDCVZqch3DXNwQSF9pw7Op2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAW86ADychmm3wyCYlZTCO/bVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM5NjA2YzYtYzI1MC00NGQxLWIxZDMtN2ZhOTJjMWJiYTliMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYTY4ZTc1Zi1iM2Qw\nLTRhMjctODhiNi02YTMwMWU2MmM5M2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARCf2IMUyL/BCgRePgVizwUPvwE5RGUi0qffmr/+0ZE0lLPCwPmPm1anpLCz+l4\nh1cldDVXaEpdpCXh5hzHqbK2o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ2Rvc0PfGEXl8o\nNHUEzThApBrh3jAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDq\n0CiBWv1v+0qfd7QBaEnbYSi4PTEO3/mt7eC24Y7uMwIgZEy14cUP4+3Julk1jVVg\nQNxt//0fzERGzgIbZAOHoyk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7529", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7529` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAQwBtWqhwlt+kZ4kb7VP3cl7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhNGEyNmE5LTM2N2EtNDRjYi05OTRjLTQ5MGJiNDkzMGI4NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTcwNzg3OWItMDQ3\nNC00YmQ0LWIwMjAtYWM4Y2QzYjNjZmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmWjOc1hrAhTiriSN2wD1Oih0gRxv0JMrje1WHNhdXutIw6aPOMC+YNFtDL+e\n5536FJhjtCe9c15q5sc519AbRaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAXtIKDYETBsZ0cvRGFyLFL2p+TIwHwYDVR0j\nBBgwFoAU1Im8CD1wh3yvTiC5HqXHsNtuPX8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDpUh3Fwfou5q8OxHtbQNs3nzHhbGA/\neX76rPZCFyFvgAIhAK5n8yRLHzOi4EH30jfRmZxUxv+C9wBA8/hUmv5/4CX3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYoduQBxuoAnqcd7l2TIfuH0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTRhMjZhOS0zNjdhLTQ0Y2ItOTk0Yy00OTBiYjQ5MzBiODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREVk1l7U0/FSSjfU75VeUw60AkOyPhOl+YR46iLNbQaBnN\npMbXEDlvP6d16oYJJW84C5+odn60WVqAwfdM80FMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Im8CD1wh3yvTiC5HqXHsNtu\nPX8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPnaWptHSg1X9qDrTqgmqbJ1JeI5ZvnKTXJ2jEzObd7lAiAJWCcn1LII\n6kVTA6DwXb5Hwld8HJQcltW1tpOp/fQrDQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAWxuDa9gs2xABI4gumA2gbVSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTcwNzg3OWItMDQ3NC00YmQ0LWIwMjAtYWM4Y2QzYjNjZmQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNjBkNTQ1Ni1hNGI4\nLTQyNDEtYjAzZC1iZjk1ZGJlOTMzMzIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATMS4ySSMTGIzCydKqka+LjNFT19B0yuhD2skAAyR3QwTBbh5omzrxtq1w2tdnJ\nCFQAw8h6cF3lvi4OX0iqWKPHo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQBe0goNgRMGxnR\ny9EYXIsUvan5MjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDl\nmXoL7nrT0skEq1BnFh/EhKZyRumwLNbEEGMVw5ZJBgIgKhkJ/UBYjduHC1FPgbEJ\nX2R+PBiyGfbhUUf2vqr5Z5Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7530", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7530` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbz4GKEUQHYbXdEAwzRnwqxpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlMzRhZTk2LTRjOGUtNDIxZS1hYWZlLThlMzAxNWQyMjc5OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNkY2U3MzAtN2Ni\nZi00N2IyLThmMWEtNDYyMTc5ZmM4MWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmK9R/ExcZV2WsHRbxEd4wGp2T3E8PVwgoa59rPbd3dpDiYeYsOGGo6IiqN5g\nZW9xlMcTWqvJu/eXDCm8Et1O0KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFyK51LxPWJaQEk7BXYgWS0rpc38wHwYDVR0j\nBBgwFoAUXOr0Sj1WhnwOcSRNjmHkVoblMUswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBPg8YAreGtLD99rU7vxVyOGEMFzTldC\nmxEvzRxirzN6AiEA7vg5PAfUWuzuSMwtUX/OV5003On1fV/3eV5WKAJfqOE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9VhNlxSLR09u7LOYwJLsWyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTM0YWU5Ni00YzhlLTQyMWUtYWFmZS04ZTMwMTVkMjI3OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATK03BuDPIF5Po26c/fhLT23xaEGCLwXdFcgX8v4EOqFNRP\n5dRfQWz0TMToiLdaEvm6fv91wLEhwo8aNQ1YTqupo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXOr0Sj1WhnwOcSRNjmHkVobl\nMUswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPmw736ZQ2G1f188ce5/3/jB70s1ZidL89TNnBFSvTBpAiBFvj2kTwJm\nqPrpM20RY83fWNw/IyicII/0sUKMIacF0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAXVm+SfqR/gEI+ah4v67Qez2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNkY2U3MzAtN2NiZi00N2IyLThmMWEtNDYyMTc5ZmM4MWJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZjkxYTk4Ny1lZmRm\nLTQxNGEtYTMxNC0zZjVkZThhY2MwNzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATWMN1ip2mDrjvMePTsEb7v+AAaiaZ8Pg64sOl+IO0t8C7v3xlpLkSDN04NMSMd\nretrXnWMlRCqMe8lj5uDD913o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXIrnUvE9YlpAS\nTsFdiBZLSulzfzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQDn\ngu/lTFNgkJ3NyDQmjI3Bo1rcSzUNvpnRa//4Cr+1BwIhAKehc6kfXFi8nXcMoTDM\nmEv8lVR3avaKZeRzYb+/1DJ4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7531", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7531` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXjW/TPCUwyCyDJ8Spwt3CZBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlNWE2YzZlLWZhMGQtNDg1Mi1hMDY4LTI2NzAyODliZTI0ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmMwYTRkMzktYzE2\nNy00NGU5LTk0YWItNzg5NmVlYTJmMmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENDxMyP28XozLAyl1JcsQ2oxo8SqRABi370H2XUcwyPIZpB3igC5jkfLmvddd\nF3tFRtsHXBrtaHFcC0KkJg6boqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVqINYXIlJWrY76vZAVt4GYtSLS0wHwYDVR0j\nBBgwFoAUkDeu1pL4+6pPX9BQD3bRJofVUekwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIAy/yUgAbkwu\n9/K5/9N+cr885tU0DLYeQgJEn2B0a1WUAiEAx5AaSMzEVSdOQ3UCwhs0kui63pG0\nUPRry4pMMe0BGNk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaimSMqNkU+FFEhy/bGrm8IgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTVhNmM2ZS1mYTBkLTQ4NTItYTA2OC0yNjcwMjg5YmUyNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYrLhpxMUX/ZLqAZ5yROPS4xHk+9U4TqfoEJ6oj6eBYUM9\nTu8dRrWbXx4Rh6jrJx0WJXgp3I5974j7yJvRVWA9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkDeu1pL4+6pPX9BQD3bRJofV\nUekwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPeOH4PncND3Xe3UjhW7G2KdN8H4M7WRqqCDRU3D15bmAiAtZ1Yc861Q\nugSgP0f9Xb2M5TpNfUQy0G6aA5nMs0OUTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAR5dMhsubxey2o+4C8HpNhdPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmMwYTRkMzktYzE2Ny00NGU5LTk0YWItNzg5NmVlYTJmMmQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NTE0MDBiMy00ZDVh\nLTRiNDctYTgxNy05YzM2YzQ1Yjk2MTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASvB/kipL1Vwo64Gvig3h6LG5lJ604ylBaX4P8cjAVvbS0wVodcz0zWcrl0WZKz\nguf+WGsHUeOrxAcAfWIs4jAko2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWog1hciUlatjv\nq9kBW3gZi1ItLTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDs\nS+ZQtTzFUWPymTCdW0UAqEuvejlrC/cvzyt1Ng7vfAIgMaRpl7zV3KuZOeVVAUoa\nnHnMjo5hDEqsA+1WLkvT4LE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7532", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7532` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAeEoq5nfELVo7EcONNF8p9g+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5MGZmY2JmLTBjODEtNDZiOS04MWFkLTI0ZDQ0MWU0MDEzMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y0MWU4MzYtZmU0\nZS00ZjlmLThmNmQtZTQyZmU4NjNlZmJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErdsQ4KkI1Tvz+gW7CaGNPELVKNU8ndYuebVQ/JWfZRgbB6Gt1TkaWKqAXhG8\npvVB8i8LTFlwzHlfFz868BBiD6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE3USiwvVJdW70DK9oj4UXXiNszwwHwYDVR0j\nBBgwFoAUKAEEjrB4YyLOLU0ksYVBmQw7U00wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhALY6mwY4BV4jOo25iuSUV122cYBM8//KqL1Fx0RUHqYJAiAVw9iYMAUw\ngcproXtUaX2MODkKG5WXdaMqPpJDOhAbfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVtDqtSZh6XoFotEY1q3zbQWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTBmZmNiZi0wYzgxLTQ2YjktODFhZC0yNGQ0NDFlNDAxMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNK1mio90VATDZPYo22PSGhs77ZKQ60o1n5WpoFKSov5T7\n4uCnbi4ZIAasZF4hiJ6afO9JkOnL6tk16gnC01mZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKAEEjrB4YyLOLU0ksYVBmQw7\nU00wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNG32YIqkbJ1Ar9G47QZ/AGV+qCrudZR8eCUvx1rX+kkCIGQb9I1qs0G6\nWOGBh/V+d20qRt260D3wHLUr+VmXLyJM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAb91clJqQSVHDjsDl1VCuoDQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y0MWU4MzYtZmU0ZS00ZjlmLThmNmQtZTQyZmU4NjNlZmJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NzcyZTQ3MS00YzJk\nLTQ4MzEtYWYyNC1lYmFkMzcyOGE0ZWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATERSkn+5JOXem/6AZdIOaINUdbgGVWn+e2M2xt7k/DjgBgKekBUgKDWwTJKZ4c\nim0mWhfXAKqQ+xMhKz+tjMeTo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQTdRKLC9Ul1bvQ\nMr2iPhRdeI2zPDAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIFzJ\nuUKJhPPrt7q5DRwLy+omov1D672WQROczTmXEbWJAiBeB7Tpu9p7hj5v+Yx7mOTk\nNSqhPBt3aJDXl7TFb6J73A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7533", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7533` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAYDs+mTVJ+hYqcZSAlLax4PrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MzkyYzFmLTM5ODctNDkxYS05MzA1LWE4NmY3ZjcxMGNkMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE5YWY2YjQtODM0\nNS00MjRkLTliYzQtMDVhZmEwNmQyMTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEltEp4behynrR/KYVfoWXXDOt/0GN3jexHtXQRsmaYd45Z1Zv0M+S+B+aLUjl\nX0PbjySOjTZ7Slzr0Qi1xMMjbaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6smGc1EeeceFquwynFo91pfAan8wHwYDVR0j\nBBgwFoAUjhqusAokezwD/Zoy7yroT5SHqnUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgG01tVgCyBRFIKLQIdzgHzabj3eucsVhVcTrdXGhJiOMCIBghJfhFSiOE\nr/qZfwBEZYV0arRTI5hgZpMX7oP/bvW3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZjanvoDH5CCdXarrLtj07peMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDM5MmMxZi0zOTg3LTQ5MWEtOTMwNS1hODZmN2Y3MTBjZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhQDEtcAvfcn4nFLLT0WmTc4KCOXdhDJRQYawaHjGKTTe5\n5z4Jp9nO2TABZ0O6TWHGBId/+yrZJMRVSjpUuWL6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjhqusAokezwD/Zoy7yroT5SH\nqnUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWBuil8a+FnEkOrQ0hPSrMVZrbPL4hkcHRSm+fAlsM8wCIQDGb6FtNhT0\nOK0MBk+hEVho7F4wcL/rlrKHJqO9/dWeZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAbX6pC7CpG/95QNlNMT37fzpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE5YWY2YjQtODM0NS00MjRkLTliYzQtMDVhZmEwNmQyMTVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OGMzNmU0Ni0zMzUx\nLTRmN2UtOWY2MC04NzE3MzUzYTIxOTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASOqBX7BUQsaCU+yLZw36rQKpQZay3SU1mxYQ4kNqAG7swptndolrT4++9c90bl\ndvnPGbtDJjJ6PLlwceN5XTHVo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTqyYZzUR55x4Wq\n7DKcWj3Wl8BqfzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCICPI\nllswISY11+qh29ZMu4Qb26I6icY7EBZjw4ZMsgKMAiEAmc4+OULQHg87Y3RhPrdT\nusfaS8UmwUbUQDXnukMBqM0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7534", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7534` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAe0hboH53W7T+rVLdQc9Am6JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNTllZWNiLTA0NjMtNGJkNy1iYTE1LWRjMzIwYzRjZjMyMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmYxYTZjZWItNWU0\nZi00NDExLWEzODktYzAwZTM1ZTBkYzg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE92BhCz2I60MDdGUBaQTbzliUEDVnNlMpDsbagmAq5o4iISyQU7RzkoVSqMWo\njwTLF/aGCJKF9gLfspRVew3ZmKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfn7R/D9/HNkpuDwH8lqi0+x9mMswHwYDVR0j\nBBgwFoAUPJIqo5u2OVLUPlJ/zJAGmE2dYPkwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCmKK/756tIxO5Y54J579oQxDThW1D5rVtYHtRa8CUtuQIhAO0PaX4A\n5JcSD2JpEYCM/QwFIE048ZSvkDrmGJnsL+nw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR5sDnPszOP9y09OLbqnvae/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTU5ZWVjYi0wNDYzLTRiZDctYmExNS1kYzMyMGM0Y2YzMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTH8qOcfv4Rc51/HPrIMxU1NcU/YOIV8TrdSTklToNlzFA\nhnvmK8cr8YPJ6g6h1Uyk73pGqaeSXE/i3WfoBeV6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPJIqo5u2OVLUPlJ/zJAGmE2d\nYPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN2FMXl3ewyBEJ019sfms3EcY+mFR/Yz9Xt8+ub5/zinAiB8BVdE1jbv\npW+KeFwWyxOawd28aECHS6f4xQTrc/sUGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAU3nIAOF1F7ahfy6m4BRFnmnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmYxYTZjZWItNWU0Zi00NDExLWEzODktYzAwZTM1ZTBkYzg3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZTdiZWY4NC01ZTgz\nLTQ2ZDQtYWE4OS01OWVhMTA1NjdhM2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARXQj5HNGtdozFzNBtJinMYmyoq8VJANnamdiZzh5uPjo1BB0yJxbJXoF9NYYHA\nxtKqtJeCH0ApwALqQxwtnXu4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+ftH8P38c2Sm4\nPAfyWqLT7H2YyzAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHrY\nNQBMQEbTW04LQDtjSLk6lEsPkIuTmAeUhiUucb6AAiEAzwxTArdY8B/ApH4Kq9/S\n/hhTBjtm6/4UHXhBTBbQLec=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7535", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7535` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISASfQsvtMZBdZ6Ac/r5UXYLZbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhYWQ4Mjg4LTliMjItNDQ0Mi1hNDc3LWYxYzRhYmVhYTk1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk2ODE2N2MtMjMy\nMy00NzA0LTkwNzAtYWM5Yzg2YzkwODllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsHgEO6tpQqTeGpLGzMTGp4KQyRTvXuyecGg66VePZDHe+GgZWD6+43TRBoJa\nwsZ0V+2GqVeBIN5LKQwQcTkjuKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmOALToghUlxs4dlq3a1zhuJBFZYwHwYDVR0j\nBBgwFoAUAbkOtqhu9EJB+D+JIZX9mBBuhBMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDT7lTQdePNIIm5dV2JFVrKDu1sIpo9SqTcUOFm\n5uBoAgIhANMWA5T9I3Bd1qecYLxbIn47zOoX4U1VWDJY/zK/USNX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfS0gQc/DwXGnzAaXgbfPlSWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWFkODI4OC05YjIyLTQ0NDItYTQ3Ny1mMWM0YWJlYWE5NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH1h350ceGUne5Wi3Js1Yrrz4TqEXZS9w5qWcH2+iPZ5dP\n5gYPj+1tFPGmt75/zRSjNPRSlWCZztfxWNRUcrFGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAbkOtqhu9EJB+D+JIZX9mBBu\nhBMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYKgnsYY6i2G/Rya32u7QW3h9NFestSNmhvNmOw+ytQ8CIQDaYToGK8lV\nYix3aVXF8nh060MVf2gVNDVYypDb6FfVJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHjCCAcOgAwIBAgISAfZQNpTva7nywPcPCGgL26vaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk2ODE2N2MtMjMyMy00NzA0LTkwNzAtYWM5Yzg2YzkwODllMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNTA4OTg4ZS00NzJk\nLTRmNjMtODZmNC0xMjBmMjhhZTZmMTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS+kToaayzHj31NXCe2s9mvTOd7r8GumcoYTw5t+mx1cxJ+/3tDEbTXasRWsVq/\nlccYLfDb+y0cCqxIadO1+WFZo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSY4AtOiCFSXGzh\n2WrdrXOG4kEVljAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0kAMEYCIQCj\nAZzWCEeLoBtlcnzM9hV/peNBZ1opECIibdBmRq53RgIhAP+UKu5FICUByPq4eohV\nNNQYJn/Eyxw+/YeCPQPAfU0H\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7536", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7536` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAdPTxMdzYMrFCkECNIFB0h1yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMDlkZGUzLTkyMTgtNGNlYi1iMzczLTIzN2ExNGIwMTI5YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFmMGQ1NjMtN2Ni\nZC00OGE3LWEzNWUtZDMzMDA1MDE4ODI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw1z29hJ+ctXgggght9C2gh9fTjouOZhwZolhJLpgLar/i3cV1eELsGEZBm6G\nMzcAwxGgh+TGqQKM7EbCjxJG3qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgb9dDGv4sG+1CtRuz2vsYm7Jmh0wHwYDVR0j\nBBgwFoAU6sfB1v9gAAVOGetBUJHJr2XWwPEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIE6M7XWQJpe39Jr6gmw7Uh0IxE3U8SAtlOy2JRZE\n2zlDAiAWUrNVMsHx+iO+hNzKVFyPcWC1cRQqwCMLUDeWQcJ3Gw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATB3evq3u/pz9ow9G9kjfvY5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjA5ZGRlMy05MjE4LTRjZWItYjM3My0yMzdhMTRiMDEyOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/vCzZUCLPp7pSK5SDOix/FfqAwgJ/WUBKQMZQyM/plb5k\nU1R1HNzVpDrdKAwYq87HBXMWzmT6N3O+CKXj02qMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6sfB1v9gAAVOGetBUJHJr2XW\nwPEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANevoqqUnlsMFGIzLIQOLTxfrwzu05A9qOtFf+pHe/fQAiBn0Au3sDBN\n40q5NcbOSTLlGWUDLX/KI5Roz8+ZfxDvUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAcl2ALFiUqJdUNbbuUyBmZ1PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFmMGQ1NjMtN2NiZC00OGE3LWEzNWUtZDMzMDA1MDE4ODI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MDlhZjAwOS01NGRm\nLTRiNzQtYTkzMy1mNjI3YTNjZDFiOTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASVJVXBb6SLLeQJ8pP/smJVIhK6EXHzLbhk2K80LErmr+oMt41uzzWGZyqBT9WY\nn6xpnKn4H3XdA1Z+0BF7MuPXo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSBv10Ma/iwb7UK\n1G7Pa+xibsmaHTAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIHfa\nTWlcYlbCWMlwolh+Y3cZZPR2ER8CT+9F3UpWA6qeAiEAqZ1NK6XTy0xUkSsr4Hto\no//AIGet3R8jEhKPhVb9mYI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7537", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7537` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAaQuGgPs/0xFBmOxNmocAuyUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlZGViYjJjLTJjZmMtNGM3NS04OGVjLTFmZTg2YzI3M2IwMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdmODYwZTgtOWQ1\nYy00NzUzLWIyMWEtN2U2NDM2YzAzYWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3e70sG8ju8FZ5TNwUEc+nhYD+vnDxzldCAf/kUHRXQtMHAo/di7QjMCOYFLi\nl89Qjkk0C00X92w8fsuwYRf8MaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbwVvCWheRiepQHg2k11JHUEsR90wHwYDVR0j\nBBgwFoAULGPaRMcH4S7zIH+rn+WKdQ3tgV0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQC5Qlr7XmpEJHOUfLuEwpYFGMja3mCrF4tdN4b6qH/bawIh\nAK+LSs6tJ4MuNGZ199V0zCyuM4xGCEzOlywF0QEu1BcJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd7lxLGdh9/DiQq803LijfKYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZWRlYmIyYy0yY2ZjLTRjNzUtODhlYy0xZmU4NmMyNzNiMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLVbyaG74KkpuW5BwkimQsdgIPBHtrpiMQI+tmzORf+/Ve\no+dEkW4ATqZJYe5ZLB4FWngQ1HClMKS4tEvfwOeTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULGPaRMcH4S7zIH+rn+WKdQ3t\ngV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMktfn9ULe5B4F7uA+YTCaky1tphuIAs4ae0EqI4BImlAiBU0Z4gKKyk\n81zC3Y3ga2/R3eyhmBILq3uf2RhZzQ5hRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAehTM84lkF62qLjVZBXejFVVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdmODYwZTgtOWQ1Yy00NzUzLWIyMWEtN2U2NDM2YzAzYWY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYTc2ODIxZi1lOWQ4\nLTRjMWYtODMzYy02OGM3MmRhMjFlYjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQqUvuSDEuJ2aPjVnWDmJWASILF/I7bZ3uatFUueOcFma/dyEoK+6sOppBKXb5h\nsyhHp1inGsAH5ZrvMztQtAd/o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvBW8JaF5GJ6lA\neDaTXUkdQSxH3TAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIQDn\n355Hsut0QJyHWyWUDwo5fg2L63J/vcklQqHpUZE8rwIgI9OrMZ4d3i6DScI4XjND\nroMVavE8ISFj9avqBrOGuU0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7538", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7538` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAc3W8d4A1KdHYvjEdFiNhS7kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NmMwZmM1LWNmOTktNDc1Zi05YjA5LTQ2OTY2YWU4YTIzNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjliMGJlMTQtNTcx\nMS00NTdkLTkwNjAtYzUxN2U1Y2NjNTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB3ynRgjoaoNL0ZLJK2gINjxe3ltymcqO+WnaELRLUtgc2ov0TugBCuJEbiJZ\n8zY66AgfVn8eVaPS2d8sn4f17qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSLXXkfrJmxAl7Dwnt78TIvnTnp4wHwYDVR0j\nBBgwFoAU1tjs/RIAGKA1P//LzrL2kO8DOIkwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIHdKc0pzpKfnZquonitHwzbJtKgsmc4p\nqtn579h7z/opAiAK+fZ1QUlfc1Z3RDKZ/CmCcJFXVZ/ispg01A492V8IyQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWVK+c9bk4P1QdQtKhebecgVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzZjMGZjNS1jZjk5LTQ3NWYtOWIwOS00Njk2NmFlOGEyMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk/hXEAj1RhD8IUESSs5W4FeKkTJsfGISk29UnAeZcd+B3\nfb00qzMPda7XEBLGHEj7d1T7m4GaiKuXV1HsiXaOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1tjs/RIAGKA1P//LzrL2kO8D\nOIkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPCV60Z0g4s5rWaVq+NP8hqIu594/EAnpOcGZipQjMfrAiEAtOxFfJoR\nZKJIw39vQrtr9ul1AhwsbxvzUhBxc+szkeo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISARTA08XkEMFmz9NxFs96S5htMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjliMGJlMTQtNTcxMS00NTdkLTkwNjAtYzUxN2U1Y2NjNTA1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmZTU3MTczNi0zMWY2\nLTQ3ZTItOWNkMS03ZTY2NWZkZDQyZTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQYv0ZR+oxWqDzKxMvKJ1yKMdoPa1YQZUufV/csOxMod5bSwEL0POSHuYDHpibO\nTqZUUXZczxLarT9FHlhbv1q4o2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRItdeR+smbECXs\nPCe3vxMi+dOenjAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0gAMEUCIAfV\n4ZjnWvV8jCRGFRbwfjJeWSAMsIPGOVCGXzIKZ1iJAiEAjZ+I9/eqp3gZx5ZRe3Tm\nq3652IQ7ARVEdHvXOrT9Yu0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7539", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7539` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASqzqgdwzRxCX9lkzboztS8SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzNGE1OGI2LTIyODEtNGNhOS1iMTY4LTg5MWMzZTEyOTc3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE2MDQyNTEtOWY3\nNS00MDM2LTgzOGItYzFjNDlmOGEyNDc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnUokiXV1wtIHk4+wro910TxAW906PUo1vokEL8Ii+c099CTERPm67XRsjoht\nSy7GRrFW0w12LRtB8CsVMMAD3qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTFigDSMNkGUw4XaYVb4oG83zhWowHwYDVR0j\nBBgwFoAU18VwzuQ2UINtwkvNN+9j7YvuF08wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD60Kmip8g88VVK+2Mq9Q6/aj9PU5sf\n00vR2IWeFrYq2wIgcUEda6ubxmDeksSSgYAo/NEa3Io/t8kHZc9GXQs6IfA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXa5OP2NxGYxx5XMEr24ek7nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzRhNThiNi0yMjgxLTRjYTktYjE2OC04OTFjM2UxMjk3NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZBGhuKLagXxmiDCBd4FlR1R2gWrwcJ9jVq+9bbENEEQqx\nZj2h6b9fEi3V89TEAT5AoxfSWVGsqly8jveubE7to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU18VwzuQ2UINtwkvNN+9j7Yvu\nF08wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUgdQjfj1kFSF6T6dV4A7jfzHFtrMbk7al8o0z2TkV+YCIQCIZ2rupksJ\nYM+opNGkA81Apwnq+s1C3bOHSUPkG78BxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAU+hTsfdMiCeU6uH5o8mhbAOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE2MDQyNTEtOWY3NS00MDM2LTgzOGItYzFjNDlmOGEyNDc2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNGVhNzNhNC03MzZi\nLTQ5NDEtOTIwNS00OTI0MzQ3YWM2ZDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASgLI8IkZQ1y6jdI07yhJr7ssGHjBd/vGkUoQj3UWmEsrQr6CIxqO1lxGNzl8eN\nG3r9dLmW7nlCYg/3Z5nuoBSzo2cwZTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRMWKANIw2QZTDh\ndphVvigbzfOFajAPBgNVHREECDAGhwQBAQEBMAoGCCqGSM49BAMCA0cAMEQCIHQ8\nMO7Vxn3AYdcujLdqPbpZopEbFkfX90ZQmIcbq/UQAiAyyN0jezAwxOy9SV7se/dD\n5T53UQlKVFI3OD0M5QtNOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7540", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7540` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAdp0wGeyw+1T00ly84uF9lf5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MDUyNjIwLTc5MjUtNGRmZi04NDI4LTNiODIzYWQ4MzgyNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM3MTEyNjctZjEw\nOS00MTBjLWJkY2EtYWYwNGEwNmM5NzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4J5fPAGn66vhHYTWoXWl7RtuRZkrWhw+lTWGOoIPt5H3Yc4OgPvPRPvLSJIn\nyTbHrDuApLsZQXZ6zXDlctpSGKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAMoSDb7I+rNLIUBLSvZrvK5bnShMB8GA1UdIwQY\nMBaAFPI3z30QTH8LAEWokxIawop4LfI1MAoGCCqGSM49BAMCA0kAMEYCIQC72i13\nPxsrJdwc/zrzmjwmttuZbmz1a+tZMGnJNVF4vQIhAKs33mxocYGch4iKRIleNDh/\no8wmoL79jayxwldPB++x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATFTlrjmX46KppGcA/wGlLftMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTA1MjYyMC03OTI1LTRkZmYtODQyOC0zYjgyM2FkODM4MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxifZrE37tvaZ7d1GMzn4Qg6+mk5PuZ1bWF4Qqp0LBVYW8\n42EI/t30jsR2o8oxO0RphYehzOAReonM+U57Ngyzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8jfPfRBMfwsARaiTEhrCingt\n8jUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNRUatuVFPty2sPSbj+JIpBFY5BboGY4sydbIEBFFK3QCIQDnKZerqQpk\n1g9p11gpLjVgycgwGg271Ln8d5f6UIX+jg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAbrz/YxrmO5gS3wwGM8bVEf5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM3MTEyNjctZjEwOS00MTBjLWJkY2EtYWYwNGEwNmM5NzQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZDc4OTZiOS0yMDRi\nLTRjYTYtODA1MC1mNjRjYjE4Y2NhNGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARWnN0zKbPXLhwGhkDFtKkLKxoUs9sOOPVNa1U287RRX3uvDdNq0lOGyZ+69YhP\ndGqYnWF1yVub492gupn2B1T/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQDKEg2+yPqzSyF\nAS0r2a7yuW50oTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBBvgzJVRAitwcyc9jupTYT6GKVP/iHVb2mIF4nO0THUAIgXfElx/KG\n5/x2U0X4iMSlPXsmbxYqIoXcOyqop3opVVk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7541", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7541` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATq6mualmnGw30VV7O7Y1bSrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlZDBiYjllLTQ3OTctNGMzYS1iOThkLTI4ZjFiM2M2OWI0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg4MWY0Y2UtMDJi\nYS00YjNlLWE0N2ItYTllYTRlM2JmMTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdXuM4X9F9Rr9SSYyF71oDJswH/474dir81AmRCmMkYY0JFpSeVjzvPS6W+7/\nCD1Su1+Et78o6PBz1vdF9WZiqaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCqf1r51HaQjcg+j9spp2MYXO8JiMB8GA1UdIwQY\nMBaAFJrOc6wFj44s2G510FwcP0KqcX8HMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAvRIe5OVSX08bGeWsptEBIYgCqwWBAdvJ\nbf5RlnE3ttkCIAo5VrFKs0vJ4wCCFDeDeNRfGeaFYp9SB8vGBYqfSCHb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR6C0hnn7J3edP2hPSeUniD1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWQwYmI5ZS00Nzk3LTRjM2EtYjk4ZC0yOGYxYjNjNjliNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8TXwvhu0Nk986VKq9+g6tCBQh+xUDCIhhiQjhAGwY6dAM\nV+AgyalckK8C5hNJhsJtxiT03vr5/6ZNsDaqjzbuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUms5zrAWPjizYbnXQXBw/Qqpx\nfwcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH8aTVK92Nub4phfuc/bfsiKAwqj2tEaHuPSEMZ5kqtYCIQCZ6+2VrJco\n645fE8Mu8trHEMYSOlbnMF2OJvywDzPEiA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAdLcaiD9CAn2FfVn8LOnlTV3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg4MWY0Y2UtMDJiYS00YjNlLWE0N2ItYTllYTRlM2JmMTA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NWM0YzlkYS02YjQz\nLTQ0YTYtYTBiMi03YzYyYjNiZjM0OTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQtsryF/IGmKWyf8wjoRl5aPhJbMHUKFDVrGe+vJX5YRXosQ7NZ89D6aBnxJ5P+\nPp29tI6qRfckoP+igtjd9iZVo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQqn9a+dR2kI3IP\no/bKadjGFzvCYjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAupn06BKPMILi2XPSyNqz6HkBdOkJp72BuN6plaMKjEQCIHvIGVQ4\nk8asDJQ9Gi7+i3RBchrne/kpDKfr1Hjufr67\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7542", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7542` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATUarL0nXT2AVqlzIf11MM2SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5YjM0ZGQyLTBmYzMtNDNhNi1iYWY5LTJmNzk1ZGQyMjI4NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjgyYTFlYTItYjk4\nNi00ZjQ1LTkwODAtMWRhNzViYjQ4YWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnb2ciDjqJ5nRd9tSjZPfHl+E9xD34PBKg09S7zKjckUtzATTBhFUhTFdcikW\nuRf0Vi2bvwhm7cn8dAmlNOQLoKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFm5sobyk9wS9OAvvZ0YEPFg+kuhMB8GA1UdIwQY\nMBaAFB/ZLk7bpFh7cx7AJUILmgjpYMGVMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBT9L0nLAT6TysJ0JMiV191iffUDFD8VVdt\nx2BtGC57nQIhAJXCdvCGiiHYjIF6uMdHKWknMn7KafTT+DQCm1Hjg0Qp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ56cIQTuf19yFDY8tvXPi9UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWIzNGRkMi0wZmMzLTQzYTYtYmFmOS0yZjc5NWRkMjIyODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASg+G4ShlHSmI3mDh2Kg+7G/hM32lSFFqNHKu/s83lh5+pk\nWNkZERziR97zOBpUjmRSs81lYjNvcGOmfQhp/hAUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH9kuTtukWHtzHsAlQguaCOlg\nwZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIo+yMawPMU7tdOiKF0/T6z4GNyrr9ZHKMLrWO82JkWSAiEAsMIZWoua\n46bhYgP9EOCf45aCVr2WWL2Bro08306GknY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAUsSDYIQg+K7vMPJZF6mPzvOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjgyYTFlYTItYjk4Ni00ZjQ1LTkwODAtMWRhNzViYjQ4YWVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMjQ3NzQ5Zi01OWZm\nLTRlYWEtYjBkOC1hZDRlYTIwZGQyMzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARMAeK7Wmd+obAaaJAxm4krpvBGuiuGMkwEAcQQD9nD2k+S3u/+5sFkabHjJ6bl\nT6NLmdHcYLJ7VF/FkXOqFWHso3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRZubKG8pPcEvTg\nL72dGBDxYPpLoTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA8N+H33khs9YoGxd5BKYV/NVO8Pt2mfARSoBW+Oh0nDYCIDNQrly7\nR+zD3DfVMNJITYoGZWbIRw55aRuRqsHcU8Mi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7543", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7543` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZhMaOM4brE/iTzQNpVqXcwhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyODMxODdmLWFkYTMtNGYwMy04MGFhLTM2MjdlZmU4OTViZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYzMWU0NDQtNTM2\nOS00YjgxLWIzN2ItMjUyNGUyYTQ0OTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXlt4vtwCLMLWL5KGWLIcEx3GIYzdVwGK3+xyUOB9rOdgeIiACEdZzRx2beL4\nHiPO/0bi8+mN0cfL80MeFqUwP6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRMe3sAfCSSNMkmZAzM02tT/5kcXTAfBgNVHSME\nGDAWgBTJmRudUHL9ePPxhG8XPtgybLePPTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEnnVJKB4buKySXRRn3Jw2DS8vFVaOam\nVOgx58NB0M3eAiEA3RloXndMyoT3hKlxHJE2MHkzF4ocIV/JfVJUAEsAOJY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXsgX4Nc4bGClNELfD1MjF1eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjgzMTg3Zi1hZGEzLTRmMDMtODBhYS0zNjI3ZWZlODk1YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDE/5mWocjq6Yu4xK583XQ2UfHP1XCAV23dBA8pEILcp48\nAI2nNE4ZqrXUZ9e1RB3OOmHZe58VF0/LMr4sXqGRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyZkbnVBy/Xjz8YRvFz7YMmy3\njz0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJJklqhn6AOzKYDoh3LhF1gb4i2X22WLbkz+I5cM4+l6AiEA/4DG73CB\n0OhkOganyiz+VzegrUzfiNWe8F6w6CUqrMc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISARmulUWAoUSzVDMP/XD3VeD7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYzMWU0NDQtNTM2OS00YjgxLWIzN2ItMjUyNGUyYTQ0OTlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMmVmNDQ1My03NzYx\nLTQ3NWYtOWE5Yi0xZTU2MWQ0MTAzYmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATGSNBQitqyaLnh61jYvoRY4V/qHewzR0m8XFjux1HPh6YtLRWWwEMdn/qceRfG\nwaaddXun2Y5MAscHGcMdXvQvo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRMe3sAfCSSNMkm\nZAzM02tT/5kcXTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAy5KdSZcFo/gvbMNuI4AUET7mBgWtLQa4uJmdzm/kPa8CIAOWI9NH\nIGWuk90f33WTwhsE/nghs30uHBJHkScnkesd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7544", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7544` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAZ5Y3OBdD4gICVePEfJpE5A+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyN2Y4NzlkLTVhZjQtNGZkMS05NTYyLWUzYzk3Y2FiODZmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZjMjU3OWYtN2U1\nNy00MzA1LWJmNTctMDRmZDgzMDA2ZjM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElNl2//IhzUVkuYKMp390Df++YobHIeBXLvKYqIyuBHC/Nled9YkyClyRUQqb\np1XIL6ASGkePm6y7l8YqAxjY6KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFdnxFlHhJUwL+RYx2m0t8+eFAJswHwYDVR0j\nBBgwFoAUHjbG5H1zfDrrLs47VXxSjFjwbEwwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAc3zc/swBwbcqQ\n6U8i/e11nHR0pRfHiYih7XRSkYVYUAIgDgDOWMkWHDLU5FgDzBZKYizE0wcLbeHA\nELudpdvXIbo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARNdGc3nfH8jsDd8UqDv5pGWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjdmODc5ZC01YWY0LTRmZDEtOTU2Mi1lM2M5N2NhYjg2ZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrvqiq267GHXmrRmvEjXRDmqglh/6sQ26rqMmyJaYFQq68\nemAYbrI0dzmbByhemIquQ7vii2o0P4e3U1xUKtSqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHjbG5H1zfDrrLs47VXxSjFjw\nbEwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDp0iTX4LK1Rl5n47T+sOdALfti33SFjXKyH9hOjHBNcCIBCkkXTr96bB\n3PTxT/pTEbr7TXYTbEKt3C+adxC/osB2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAaUy6IWEmVY53mXRGFNnw2YLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZjMjU3OWYtN2U1Ny00MzA1LWJmNTctMDRmZDgzMDA2ZjM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjOTlhMGY4ZC04ZGZk\nLTRhOWEtYjk4Ny1mZDEyZTg0ZWY3MDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT8dBapYXQCofOe4owdwXoS8sEUKqCOLr560d9+IUSzsd3UqLNRbPXAmDVYyr2n\nWx1fHpcVHcQGVJ65yJP0RhoGo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQV2fEWUeElTAv5\nFjHabS3z54UAmzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAYyxyZx6dFs/SGA+cZ8EW0gvjq633BTkboZ2PL2S5a9gIhANZ5TmUP\nXZX8xuaaamPtOqvYgDMqP9siqXYGjBENRfXV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7545", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7545` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAbG4dfZ0B3HkcSciUHL0qv2DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5YzQ4ZGNkLTdmYzEtNDdjMS05ZGExLTliZDgzZDU3YzgzNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzMxOGI1M2MtNWQ2\nMi00MDZlLWFiNzMtMjQ2NzkxZDg3N2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEyUNIE0TmPq3Y3cFebUgLsB+rpLKZR3V/Tmfo5oNcnPYTdN8uj2f+5fq7mLF\nTcn+7vyYIVm/Wa6Yp3mMGdwZjKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8pVIyOfyEklTdr06TiZpU5PoC5owHwYDVR0j\nBBgwFoAUUY17JpKZfBy3Gtx2zHlyKCinfaIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAM2n2I/VMAOCxm\nZI2sg3heeb67l72AQq4LmX03U+mg9AIhAN3S45FIypud5+wpIxSCwRwXuLoXtmqf\nOFa4875Fm2SX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATRuJvBVyj+MmpR/aoBKP72DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWM0OGRjZC03ZmMxLTQ3YzEtOWRhMS05YmQ4M2Q1N2M4MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUU2hKS4AjEx/DvkN1L1MBTIsP5YUt47pontNjcZh64WFb\nXNBebX1vDhSRqwux0N/hw/le5TsEl1cGR40Ci+kVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUY17JpKZfBy3Gtx2zHlyKCin\nfaIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALFxODMxDTHJU74/Aln870NLy+HpN4JeiuPBmPTn5ZtOAiEAkabxHYXO\nMNe7cbTwU8E8xrhPRWiotE0KZ1W0zwbSfyI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAeUX+44V1qWdGp0hsa91ld4BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzMxOGI1M2MtNWQ2Mi00MDZlLWFiNzMtMjQ2NzkxZDg3N2Q4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNjc0M2IwYy1jODg3\nLTQ5OTItYjUzYi00MTI4NGMxMmZhZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARkHULFprV+VKcf28Yq4d8grjfE+pkfwS3c9KhjQD4TNF7eM5eGI2nhnNQ6Rpu0\nsKpyIY2bqrvblzXeCaMiO0tuo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTylUjI5/ISSVN2\nvTpOJmlTk+gLmjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBMfbQZYDh+QLiEYXkIVxPbLoI65IuZmU8slCOwRbrHAAIhANtvaJp0\nAApRMjenlAx+VMnlU+9h4667BuxGi+SdtF1S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7546", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7546` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAS8nFN6q7QFYMlRmOm40BkgyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZDE4ZmJkLWY0ZDEtNDBiMC1hMjk4LTVlODRjOGQ2MTc3ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGZhYjUxZDAtYTFm\nNy00ODY2LWIzNWUtZmE4ZTMyZmVlNTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElAwzpnrXNqqQ26+hQpKbHbPyI+iSPFWKp4AzCWZVsMirR0HKSwAOteFrFkpU\neClt/6WEG/U5pb12hN/diXs1QKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/b47IcX/pa0325R6y8K7DvFLW5MwHwYDVR0j\nBBgwFoAUOmNIS9NSxR1t0DKgIwCzomWqP98wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAII5tlUjPtqRmpptWT5Ww+\nu9qqrsnqve923UZjEAEqjwIgPlzn3IzKhtDPlaDQbuVJFta38Zs8UYvc+43d7dRW\ncRs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXVHzT3w7quWOlfrxlZ0WhGCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWQxOGZiZC1mNGQxLTQwYjAtYTI5OC01ZTg0YzhkNjE3N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjsA8CFkdp/GQl5Fulj/bh4/AdeqLtOCmRVsOdKY5qu5Ms\nxkJqcRCVSYp/ECB9h4dzAnxQ7TolRf/ctz1w237yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOmNIS9NSxR1t0DKgIwCzomWq\nP98wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL62jd/x789zI3spRFW7O9wa5SSB9dWg/kKju7ZZCY5wCIARvVTnbJSOp\nkAPcHH3H2TKS9MbIx96BbnqVYR6zfLy/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISATJEb2z+EViX2uWV4G2x/MzaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGZhYjUxZDAtYTFmNy00ODY2LWIzNWUtZmE4ZTMyZmVlNTUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMmMwMTdhNC0zNzk1\nLTQ4ZWMtODQ5Zi0wZmM3OTBjNzQ2MmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASJGsRjjK/Tnfxv5TPP1JJYLnICKTjo3E7JkL4j6824XHHlMug30iQxSOZkfcFx\nuZNziFmaK4Ey/oBVLVC9s9iEo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT9vjshxf+lrTfb\nlHrLwrsO8UtbkzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBaemVxUz8kTn2AipNx7S6R/CZGymMsBGmKoXCVnpuDSgIgJts9l/Sm\nOySLS7NTzLZ83yPtrT4E+CeVJvlhtAOEE/c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7547", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7547` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAeSte+Bnsl+bD1PJtlVGufM4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3Yzc3NDA3LTViM2ItNDVjYi05M2FlLTcyZWVlMWE2NmIyZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTU1YWRmYWQtNGQ4\nZi00OTNkLWI1YWUtOWM2MzkwZDliNGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPNLCK54J3KTpzwKmFSIV7hZ84R++k70OHL+BdNdqRVRlHEJtwUsi1ImUGryj\neiZNZzRhPdjXzspUIjs87Bw7VaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrKPlGn1u+fsSU3Mj1BuK7rw3DHwwHwYDVR0j\nBBgwFoAUkFW8u12pzCYBZ9ujIIZeIEWAWM8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA4W4i\nSF8hkW/B8Tw63RtVVHY1eVg+7egCyoGGFbyKVlQCIBxgM4/O0mn5J1OifvquAnTA\nIa5XaAG6ie1bXDoyAH/d\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV3h8zk9AJgRMkkSbz22HeJ/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2M3NzQwNy01YjNiLTQ1Y2ItOTNhZS03MmVlZTFhNjZiMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQd6FPxaggta4+O2Cbh89FVA5CiidTC0f0sGuBkZCd9b+LX\nuxOBgX4sbMKYleZMK7+8Wey6p03N+DFQCgVEIDAKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkFW8u12pzCYBZ9ujIIZeIEWA\nWM8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANPiOVHjsvJ5u9ZWYMO7AFpnSBG/DMxKm5aYLlP0uI96AiAq5axKKvzW\nr8dLezRxkUPdNmgj81KghNCkbH/0hvpXUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAcSDPwISYqWE52TGYpREIq9fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTU1YWRmYWQtNGQ4Zi00OTNkLWI1YWUtOWM2MzkwZDliNGU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMzIwNmQxMS0zMDM3\nLTQ1NzAtOTQ1Yy0yOWE1M2NiYzJhMDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQcRQC5pYE95MR1x3pS7Hnc7CUDcvb8i3LyHEWoxFrYFesCD5X1/XXquczMKPug\nT9XK3Kn7zFDPqD9PljugUQyEo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSso+UafW75+xJT\ncyPUG4ruvDcMfDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA0GHxMeMUZ7xe0cLSF/9aarnneZxv6ikfdU+59piQXwsCIBeRjdDE\nlCSIoQXGuGLcoqpNyNknTlQGcIXHOPtRgLEx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7548", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7548` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAUjBAHuCAtMpbpBuyS/B3rkzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMWUyOTljLWU5YTMtNDJlYy04ZTQ3LWQ4ZGVhOWZkNzE4ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjJhYTgzNmMtMjI1\nZC00MzNkLWE0MDUtNTdjZWI2NTEyZjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyYj2axZnqdWIulK5dcxLTf3z5Nepn13crSfA3Uk49LIHL/yGMspy9CFXlqN6\nKlY9npE0D4DCM8Vjy08zPYeiOaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeVM14YZ0mblhnqV6ynvYS/WBl20wHwYDVR0j\nBBgwFoAU7zwlcbqV4tXHiD2j6aMj9qScMSgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA/B5w0\nOka2AMN3IYnBDgubBamRuy9VIBlYQrbDtgVaJAIgGSyQjhAtyBWtAbbud8nAtvom\nldd2AL2hqTsZm1cfDXU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZXf8fnhyd2vRzGoeEfb4V/JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTFlMjk5Yy1lOWEzLTQyZWMtOGU0Ny1kOGRlYTlmZDcxOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVbos93VI57wqB8lqrVyF5Oce0zcnV+s1XWEBtpxr78uXV\nIeOSNN7MmSZQxWeg6kRGNgGkt16bRuXd6jIh5l7zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7zwlcbqV4tXHiD2j6aMj9qSc\nMSgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPLl9kBquhQ+5KpxMG7gTOLaDcPDwHv6UZU5Ifq8aGkrAiBtCuDiO2lb\nV0W7ixeugbodnWmqgL4wveccLKChNFHGwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAW7Lq0lWqUGt5lJArP1O8MHYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjJhYTgzNmMtMjI1ZC00MzNkLWE0MDUtNTdjZWI2NTEyZjYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MDhkMWMxNS01Yjc2\nLTQ5NDYtYjA1Yi05NTMyOWMzMWNhOGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASwc4UmThQ8qwJF/3ZWmRNxONW1AGgWvi4qxkIRLGcrUAC7YCT3xk+m3JBNCGCe\n9dzVccA5GCFhKKqhysu1VFVgo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5UzXhhnSZuWGe\npXrKe9hL9YGXbTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiB4R3G3ZYiJ2gzGl59LSCOBXC+5H+Br4EQcnKyjyvKFkQIhALwiMAIZ\nbIPfDDfJpOaLNoVKRS+wZdBmFI/HFQtflRJJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7549", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7549` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZaMZwy/MOMN14BD197EdcHKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ZDlhMzIzLTNkYTctNDc2Mi1hYTQ0LWEzNzNmYWU0MWRkNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFiMmIxMzUtYjNh\nYy00ZjNjLThkNzItMjc2NjY5ZTdlZGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfaE/Uyhq4YzmqVNFdNVFnXsHnhOGA6hmJTjqtcukFII20/yADxeg6eLZkoV2\nADF+5fcu4Wmtae0jV680+z5rF6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFO1dihKWOdPQdgGgi2S4uhp40sy6MB8GA1UdIwQY\nMBaAFHVvdUvw3UHkP5M6/yVQ9mW//TwdMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAxpuU99MWa+t/tzPCWwLa55Utcnu9MLcA\nJOUFs7jXfQYCIQDNrrnKZK9fMFlPB/oDln517ILyAmffrOvbBDLuxza0Tg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf0fgKu+XQ+5f92reERGulfFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGQ5YTMyMy0zZGE3LTQ3NjItYWE0NC1hMzczZmFlNDFkZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASb5L1V0czdRjcQ//mHCuwL/OAf5SufsmE4IBlcqum7Ntck\nbhTXHCeKTjy7o7VNNzRCNn5SurdBUaBRyaGhX+Udo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdW91S/DdQeQ/kzr/JVD2Zb/9\nPB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZB+M+DU8wzztnQALrtXlfrOswTZvh0oMpbdFvqpv/20CIFr8nhw0Lohg\nB4ofdVtmCcAgzgkN65KmK+fCxrDUNEA4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAepw9SxPiKDG62m8aypYGQdqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFiMmIxMzUtYjNhYy00ZjNjLThkNzItMjc2NjY5ZTdlZGQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNjRkYTk5Yy1mOTNk\nLTQ2YjEtODAyMC0wMzRhNWY1YjRmYTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATxYbEAFpgrDaxiEOkH7T5E4+zKEBlAWkv/j1a345rgld355T4+XmFB1gTVSg+D\ni/QduANRg+Vq3BD/39u1cR66o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTtXYoSljnT0HYB\noItkuLoaeNLMujAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA6rFvFqbVD0FotYZh1qtSRLKYmSQmFSI0WtU8lfA6V2ICIClNn6TE\n5OIWedp0XFrFMpvHTGkQ6fsMf4Tnrp6gLzNp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7550", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7550` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAdm06dv1ol8Oh1vq5G6JFtvmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYjgzNGY5LTMwMjktNGIzYi1hNjAyLTVhMmQ5YzZjYjUxMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGZjYWJmZWEtYTY4\nNy00N2Y1LWFhY2MtNzM5NmI2NGFkYWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA8RsT39NzMuw8r5NstvrP6iljeI5mfWiIKi1OBhwWWxIMHzi6giiLXm/vT24\nXYF5cMscIdyb8XdjN7XGyE0jVqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURU+aM+NvEiGXkGc/2DSfTmDQFGgwHwYDVR0j\nBBgwFoAUaqtDjrzHOSlvq1n2FxidPHf3mHwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgWMqmPk6ceIID\nBB58wp8kAntQdLN4/cgqiJzSahaivsoCIQD+KJn+86Mqdg0qwclwk09+XbtQ0qmK\nmmpH1iyZA5H6Kg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWD4zTjG6X6FKZ0SRNL/5qDnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWI4MzRmOS0zMDI5LTRiM2ItYTYwMi01YTJkOWM2Y2I1MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6QTjlD1tCg2/oMFa9Tu7uUR3YQU3w4F6KPEg7ryd4wrKs\n9SlRi3cag7dZwpJh9plB7AXjGyLceMIpbPqD0Ty1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaqtDjrzHOSlvq1n2FxidPHf3\nmHwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfvbjF+ns4DsFX3fPLnlJjrbdqlTDWpWlbtxioiTtdV0CIQDAjhER9/1o\nLTRX1accukCD0BacN8JclZwLkuByM5a17A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAeZacN1WO0uC01qF4VA6meTZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGZjYWJmZWEtYTY4Ny00N2Y1LWFhY2MtNzM5NmI2NGFkYWU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0Mjc4ZWEzMS1kM2I4\nLTQwMjktYWI4Yy1hZTM2ZjA3MzIyYzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATsg2oO91E9vzZUxzilDF1PmYo4hED6L9KliPI50YSb5UvHltQsYeuQSCIv7a8a\nyMBy8tQ7N6P+QyevihrOj+H+o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFT5oz428SIZeQ\nZz/YNJ9OYNAUaDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA70umkWrgAlzSJyJFP7ZnihzUt/2t3nOrCEmdnB9b2Y8CIDfOP+rb\nFrwOkBOWZBSp2YQFhvlH4Jac+FwRagXHjZq7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7551", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7551` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAZJhUGI6jsXRVPcZ9gPkFQM+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5MjdmYjYwLTU4MTYtNGQwMC04NzM0LTQwNDgyYzI2NzhmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIzMjAzMzQtOTA2\nMC00MDkxLTlkMDItNTJjYzBlMzlmMDg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELhwftk5LjGGJ5WSwHVQiQm9GSyMsXT0HtyQHtCpKq36kMYd4SYoWR7h6R5Dx\nxcZ0EIv8QSQtha5hEcj8C9Zk2qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUseFlToF2M+l1MYKF9BYyvU1kfnkwHwYDVR0j\nBBgwFoAUXL4Gd8KORtlZMV9q1xfXSL3qGBkwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKOwSkmvNTR4h\n+ZRSIbk8Wb+KXyX0pm7bs6jgzlWt//oCIQDnS+CtL3/LQZr+QLlNXWrwxmdzkzup\ny66qQrqpAI8PIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfJfVuBtCuYYQMygB0IOdQNvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTI3ZmI2MC01ODE2LTRkMDAtODczNC00MDQ4MmMyNjc4ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWlbN6n6RB7xQXTVDdw29Et3C+H9rR7KgNgbShizyVWbjL\nqHRnpjFEDepaV2EqtxnY5WLv12jRY4kfh5++3Zhmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXL4Gd8KORtlZMV9q1xfXSL3q\nGBkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANY+cVDRUtIk5yd5eAQdkZ8oxaVLenBBTJV2sgtXpXH2AiEA+frZyuHj\ncQ6sWHYUYMh8GpY6YR8JXs2bV8CbT/pq8ng=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAdMFuiSQ+no2QIRFTMWk2gM4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIzMjAzMzQtOTA2MC00MDkxLTlkMDItNTJjYzBlMzlmMDg1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4Mzc0MmI1ZS1hMGMz\nLTQ4MmMtOTI0ZS0zYzcyNDQ0MTM4ZTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASnsX4V/JNgerKa2jxeepg3ypj0uou8Uxa13jkDzWq6K2+1h+7kdMSyWkzAHUtT\nOE0m87tnU+jdBcThs7H7P8GHo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSx4WVOgXYz6XUx\ngoX0FjK9TWR+eTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAF5XD/dgApDlbrpTrgLFLSRIo7d4mMTj02sEFoJD868wIhANQ9u4g/\nD9xQ3Xzp+Wiz+PFU0fKGNVsdJHPCMSOtFyuU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7552", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7552` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVICoqZD6NhDS28lpgqOqmjYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiOWNiYTRiLTAxZWYtNDc1Ni1iNDkyLWUwOTE4NGM4ZDdkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY3YjU0NTEtNjQ2\nMS00OTc0LTliZDktY2JiMDg0OTg5MGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJY9n8k7v6oEupO6p9CB5ZR+SxUszWJ/P4fbHr7QOfAf6k7gYUmiwM0OK1jot\nQqWHKpRKuoDFW3K0DSXW20RTxKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa4DAD1Bs8ZigtAosigUXUBze7CUwHwYDVR0j\nBBgwFoAUyligTtsOmjszMcUJnAYgrrOLzbcwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDP8fpeOG/Yy\n9q2J133HCXA7QR1zKEL9/Xt18d3Us/IbAiEA8DJ/DNBk3rREU+2ESsGAHPD5k9Rc\n7YnD0eCzlELcdqI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVZYZeZjUE+T36S9fNRfUimyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjljYmE0Yi0wMWVmLTQ3NTYtYjQ5Mi1lMDkxODRjOGQ3ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqnnuqcvl35J7/jWW7lk987cX+peIhK5U/A1+4Sxdar6NQ\nN8o+MTc3B7Sgs9lhnT1ZGiuF6aHTlrVHslpwM79Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyligTtsOmjszMcUJnAYgrrOL\nzbcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF1AfI7vLqnplVqPNzIsWQbTKyZQfd3G1PtW/KDUNkLsCIDc18uN4fzc9\nRgBlUDKvdsPdGp+XT1VEEwQBnLjASEqY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAfIr7vaRY2LttpNGr0IqhMOLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY3YjU0NTEtNjQ2MS00OTc0LTliZDktY2JiMDg0OTg5MGEwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwOWJiMGEyMi04YTkx\nLTRjYTItOTVjNi00OGI0N2VkNjYxM2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQRfR/bMumRuO73FOJIH+Zz+dJLzhGSqNFZ5TduZqZBoKNcRwHe+Zu7bmoY4iHd\nDeJQ3ZgE8QNjvQXnfncrPzBFo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRrgMAPUGzxmKC0\nCiyKBRdQHN7sJTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAFyHxaplNUxtS5j6aSHDftT/qtJ9NdJgdLP/WPqxW5KwIhAKO84IM3\nrefYUsvvmwrUnL9pkckjOP7C6/acjRQLJoyW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7553", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7553` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZfmcoyNvO1qSA3C8JWv6tFDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0MGUzNzg3LTViYzctNGIyZS04ODkwLTkzM2U1YjhkYTI0YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E1YjIxN2YtMDcy\nOC00OGNlLThiYWEtMDAxNjM1OGQ5NDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKnt8yYGgCvhccmdeCR4MVUtRVfIZ0wO1UsOQsbWIxOgP7IyqaYl/NNoucpk/\nZ6RV/IL0OtAi50qzPJ7OXwdLqaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX0TxnaYQyzkfqIumNsGKx9kXntMwHwYDVR0j\nBBgwFoAUR/9S+Wyxj+C77MSKZSpiX+EOlTAwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDWsbmvBLeKxb2UBGxJkG0Vv0s3H4JwoGoy7FzNM6oN/gIhAKsOqZ/aiq2O\nAQFcH5BEkhq296Lv/183DgbLOzfPYWpX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARuTgT59zUIQ8V13p8J5KdoGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDBlMzc4Ny01YmM3LTRiMmUtODg5MC05MzNlNWI4ZGEyNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQP8UhHNB/0DgTR2Z6InIz59vsHT2CY1FA5Vaa6JoyZFHU1\nB7lnY8/aW37VSybeqNH4yv+RLR36p+dNGgeDYyfxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR/9S+Wyxj+C77MSKZSpiX+EO\nlTAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAeXrFmDjal4W0rnoNN3TJKxZ6X0/Gj6CXHpBKB+TU5oCIDfldit2Sx3A\nfcCimCJGhjtLozGML29HsUicLn0sCvgd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAd4dCkQf8SvD115bhx0tivG1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E1YjIxN2YtMDcyOC00OGNlLThiYWEtMDAxNjM1OGQ5NDlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MzQ5OThkNS05OTFh\nLTQ1ZDMtYTBhOS04Y2Q1MjgzNTQ0NzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQYje6NEh/bhC6RdpEy4oqtk4ulDvL+rYCG6S8T5+tqbe6gXF9kUJRUKhKvpKFy\ncY2dS5/J/oheXalsvdYj/bv1o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRfRPGdphDLOR+o\ni6Y2wYrH2Ree0zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA9xvU3At3CldE4WLWHZT9ctC1zYVODbmVOrGtVVhbck8CIQDSFvPG\nTSCAn0b3mSUQhtk4AMgRtDPkznaQeCpSr99APw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7554", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7554` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASGZAXJTsp0OspIElOP7VB6CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MzhlZTI4LTUyNjYtNDUzYS05NjlkLWU4MmU5NGM1YjQzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNiNWIwNWQtYTkx\nZi00NzAxLWI3NDctMzBkMWU5YWJlNTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEICrrK7V0gWbytBiFlhJCvFBmmPr5yRGb6nGQZhMUlTTXesuwY+SciXh4hNUb\nBtMb0xd3IhlYd4Cfev59gtZ+UqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHj0lgncic5OeqyznwTyYGgCL7eYwHwYDVR0j\nBBgwFoAUD30MlEaMV9qaJlzFFA4rGqmpO2kwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC3kShTz6+KRgMwAqbRHablR8ZEEFS+IFSKJ75u/2pjMAIgeElmlJ++K1Kd\nI/nWxxj0tEzZXMfjEnF9yFPjYmiC9BY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZv0lU+SvveeI6WCFStsUP80MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjM4ZWUyOC01MjY2LTQ1M2EtOTY5ZC1lODJlOTRjNWI0M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOmavOXkm9OdFMAJuPNIgq7FQ+hW0jGzWdYqrU3QW6qQxG\nyEfcrwGCR6pt2SSGSLIkTJUpSAKKimqYTSA1fMIIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD30MlEaMV9qaJlzFFA4rGqmp\nO2kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJLlkTc1CDogxoV1WiEu60jRuOWFzWAkv6gPdFZ9snMVAiAshtIduAWc\nW+NKrMGOw2syce8ia4D0GiS7HnrFb3T4Cg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISASX6VhC4jGCABl9M1AEM23VLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNiNWIwNWQtYTkxZi00NzAxLWI3NDctMzBkMWU5YWJlNTgyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZDM2YTljNy1lMGI0\nLTQ1NmUtOWFhYy1hZWE3ZTQ3MGQ2ZmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQtWDknjo9ctk0VAVdpXO8rKV6/jwssk3oa7zNRrA0jexMA6SlDyLjOBo5xs6Nx\n24Ew6Jvd1t6O6Tm1LPLGZYelo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQePSWCdyJzk56r\nLOfBPJgaAIvt5jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBvTTiS2dM2ludgE4x1sGVCxzeqzbvleMxCRXpmaiCOWAIhAPWW2s7F\nqc5ntYOeLxiPF8LxOTXKLw7+7rmuGq279+11\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7555", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7555` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAdC4vX3yKAAtnQ4spHHpgV8hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxZjFlMzZjLWNiMGMtNDc1My1iYTIyLTM3MTYxMGFhMzM4NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQyMzU4NDktZTEw\nNS00MTc1LTgyYWItMjYxNDA4YzI3ZTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5gpmMJsVDSuxSx92rWIDTW0FNgfsIE2B52lGAZEnRTvmqecfPwh6gYnb/Y75\n60Eu7D2AKY6S/0TtCqbMbjxMiKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhuD4VVnTfHAGBa3cgW27NvWC/EIwHwYDVR0j\nBBgwFoAUUd1Ep0inpZtNKe84wq/v4hia3akwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCD\n5Lg24S50n21MYjP/JSQ6V7Nh4gOlU1RHLtINZ/UVXQIgR5yxjBPJnrPDmMhqqrt5\nPARuimefqwDU2i4G2SO/txY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXWptp8DDdiROkq4Uc+LEm0LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWYxZTM2Yy1jYjBjLTQ3NTMtYmEyMi0zNzE2MTBhYTMzODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJuku/ruMdi15JB3UZb25fiQcaPGRvS2QYJS+qZsMKiT04\n2Pb76flnSivG/dfiT82Z92qokQjDlMSzGYME16mBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUd1Ep0inpZtNKe84wq/v4hia\n3akwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANakdFolTsFwZr77ZVW9v4j49D4EylpqyEq7StcA54iXAiAqNLHOVwpn\nIAGGzGx58998A0j2ijxGS6hzMCZ/k7Y7Jg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISASSAXtN2ZH2vjpiHGa3wKtfnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQyMzU4NDktZTEwNS00MTc1LTgyYWItMjYxNDA4YzI3ZTUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMmE1MmZkNi1kNDk4\nLTQyZmYtOWFiMS05ZTQ5MzUzMzdmY2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATEklGbpxQD6BEuc17baqhQw/VcOQtsCzqbwMdupPN4wndZ94s8c/YW/XxeOyVB\nc14ywTJZwrMISk4+AGVi9JNko3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSG4PhVWdN8cAYF\nrdyBbbs29YL8QjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAjxTVc/4VWcgrFmvB83iPP4ba8TMcdDJ9FEHqm//2t84CIQCXCRe1\nb58tz15cvsQTJIavWgMmHeJG6KBtEvHZM8Y7QQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7556", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7556` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAfFzAY8G6BDNmIypllBkjdJbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMDMyMGRiLTExM2EtNGQ1Yy1iYjBlLWFjNTQxOWE0ZjhiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YyODNjZjEtODg3\nOC00Y2YxLThmOWQtMjNiOTdkNmU2YzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyX1RMTIWrVHXfQKjE6YYOFDNCwUB4QjVM/WOJGxkVMs9MeJvDKW5/BeKXBS/\n1BbB3euFl2ellR5RGc9o5dDOIqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUaGeqCqhmfAblXeU+vhAW2VDsKowHwYDVR0j\nBBgwFoAUO3t/nP+ZoV9XFhgqfPoSyj8YKg4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDYqKiOjoIHMETZ3ARD1sNPTKlwbwJ8J7MKwoMmpKGQNwIhAKuN\nNLgQMqMmEOKsocqYMKs5uc3MifG78abG7vOM0TOu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdH6hYTMFek0tqamt82qorKjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTAzMjBkYi0xMTNhLTRkNWMtYmIwZS1hYzU0MTlhNGY4YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQafeUl5IYZGpdhv9W8xJc35Zsn0LzLibshvGwq15luB9WY\n3STjBiTOax/p1gCor9qqfmL6t+YXeTAV3mViA/m9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO3t/nP+ZoV9XFhgqfPoSyj8Y\nKg4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOb5rqJHEIfd1248oO9XTeTCcsnRmZPRJCfF52gjqJEcAiEAorQtZFEP\nY936FeKQ1k1ZjBpxCfO6kUH7ococy3N4Gvw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISARQspCeGegLCYAialIVzqcMiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YyODNjZjEtODg3OC00Y2YxLThmOWQtMjNiOTdkNmU2YzVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMmQwZTZkZi01YTMy\nLTQ3YTUtYmJkZC1lODJmMmFhNGI2MDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASzRMkmR72nVsSeg2rXQN/91aCuD0nYiMHyafl5zlV3i1QAvPEG5qdxfXdUBdcf\njXV8504m1sCAtcWirDKO7zzSo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRRoZ6oKqGZ8BuV\nd5T6+EBbZUOwqjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAwNns+nt8yMDmdAPfRs4LvrIO0f4Ud0p/fD6YgwJnsSwCIQCwGA9Q\ndA8H8AX0iNbGzxMTncJs/UWm7m3YhrtZfr9ZDw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7557", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7557` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAUAyHIY+B4cmXRnY1BZt6a7cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxMDBlODM2LWEwOWEtNDllZi04ODJmLTk2YTk2YjE1YmZlYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRlODUzN2MtOWEx\nZi00OTAxLWFmNjctMzhjOGJlNWExODgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGQgYmbAykS3Cbx/F4v0lHwyZLGzpvvym73RHBzGHxXQ4pMEkDn+aW0Yek3B1\n1rt3gmvq3Le6+4zU8axnzA5X/KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4lq86KNG9tnNlv07IL4e849eBSwwHwYDVR0j\nBBgwFoAUh35QmipE01zuJA+1aUx27AfRGvYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIG6qiWZtHAaE0s1csD5PsjEhlsNGLhYZ05bfeVfn2AwYAiAXAHXa\njFtaKiA/cFvXpAIHybkcNNK7dchpQd9NRyx2fA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeWLRUWV/RIRhxPThdQgNDA7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTAwZTgzNi1hMDlhLTQ5ZWYtODgyZi05NmE5NmIxNWJmZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIQuIMT4oJZ/rQefpn30tQA70jJ2QYocrPKDh0dnhSGgu9\nyoUdEjf776xrcLydNmG5/eu9Wf6hgE4VgNypGNrPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh35QmipE01zuJA+1aUx27AfR\nGvYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI9GCwc/qLwHAuoSWsSqJvGDR4TnAo0YuiSRNkae7VbPAiEAqo0wJxB9\nfhB0CtcWMB3wm3DXQrb5J8vRnvkphLwTXOU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAbM7sVUkrQSbxwQU8YGQO3GoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRlODUzN2MtOWExZi00OTAxLWFmNjctMzhjOGJlNWExODgyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNzBmY2ZkZS04YjE4\nLTQ2YjctYmJiYS0yYjY2NTVkNzY5ZDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATG5cWHj2cKPji6LIP0Guqb6FSojTgNtyxHqXlPECvEt+GmrIRSLhUpX6X8znlY\nArD5/aXTF17m1X7kX4+5ACgEo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTiWrzoo0b22c2W\n/Tsgvh7zj14FLDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBYP/R7V0YG3lMcWWEdmUZjY2qpms3gUaDJioQPsTOm5gIgXW6BIpmD\ntD11Bu5HYnhq60UUnkSRNS0jbEfyKPY9wbg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7558", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7558` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXyv6bH3xmlqmrL6rYSJRiMtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5M2E5ZDZiLWE0ZDQtNDRhNy04MjQwLWU1YmMzNjBjZGI1OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIwOGUxNzgtYzhj\nOC00ZTE3LWE4MjUtYzcxZjRlYTFlMTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpvF0R8aypdzo3b4UrBiun3Id/driuvWxr48tt+5gOgU8y2Idwt0pToEYYEN1\nMkSCEJQKukZHE9extkyWqkYRXKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPF/lBidt/s4ISnLGIZgHG+X7Av0MB8GA1UdIwQY\nMBaAFL6OT7V47oOcd2O9ExqW6MvWXsMYMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiB/jmTn+cvwYstBvUf2Mas9lINY2ulmKMa0\nB975vXmDUAIhAN9NrsC8lo30w0n9oU59YpdLRMwB4apnZ787gKINcS6a\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaPm4eZIMieSaadpQ4kTdwGOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTNhOWQ2Yi1hNGQ0LTQ0YTctODI0MC1lNWJjMzYwY2RiNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASD0HVxYoouP2Fc+k4BgP+Xcj26LM+GsODiVnZRiP4FlEDX\nI/DS1HelS4Z1tnizv1tULjH2pnjVV0REUXZrXDFgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvo5PtXjug5x3Y70TGpboy9Ze\nwxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALcSds4Po8vJHWudSQOagYZ/KTW9UU/GFBzdL3TaWqnHAiBApHcJE8M+\nVy42hf9e/pKW//PwpQJ2m4+oUyIcQVk2jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAXomhr8xEysWqEnzzrXYvgTtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIwOGUxNzgtYzhjOC00ZTE3LWE4MjUtYzcxZjRlYTFlMTJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OTJlNzg5OS0zOTkz\nLTRlNjctYmQ5MS00ODdkNmFjODczNTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQZgYDWQP8TojH8JTjNhLeqm75eh34AnW2CSxLjVY4VGukozTusk4o3+DnYZMWg\nEHVK6Qmbf6VyRqLyoe7VZMyho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTxf5QYnbf7OCEp\nyxiGYBxvl+wL9DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA/DsnJQph0KkuLV5tt8phluA5CV86mGcfyQkumo6NczACIHIhixlZ\nLXZPgKHWUOYc/sAt+LZEp+WD1/Ffdk30Enxw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7559", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7559` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISARGSzHGiDPdWYIWIRfLbN3f1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhNWRiMmQyLTA2ZGYtNDhhZC05MWU1LTVjNzYzNWQzMDI3YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjgyMDI1YzMtZGQx\nNC00MDVlLTlmN2QtYWIyYzhlZDk2NWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt5c2H1Tar36GcSyy6Q9kcGuSiD0zIMtL4N5Ch7Dys22TViLmSb0Z4P7RwCSX\n0L/yHOXk/7zVmRJc8x+BXXk2LaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwEHhIwfmnFlA33HIzVtAY7Ry198wHwYDVR0j\nBBgwFoAUGYe7T5KlxWjI7jJTvI2YqMRlv+kwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgedkufDu4jXdb\nhYKHhchZNgqyFNekuvojo19OS7UH2csCID0c2C1fqt15f1mqyfaaQA9ll3mghIsK\nBKQV9CNa9nq0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS29RRZkl71dvpDZMFmH9o5XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTVkYjJkMi0wNmRmLTQ4YWQtOTFlNS01Yzc2MzVkMzAyN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDkOayFq1x0U40LFaG6eYz1KG86lAYSn12MqL38n7M60nG\nKAsK/Dt2aDz1ACCkYwWcNQjC+nsH2mcajJDTbfgso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGYe7T5KlxWjI7jJTvI2YqMRl\nv+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLlh2d2pUbBuahQRPfAK5AR7qmbGDabFMT8K04JjvcwUCIEPH0tk7Dgrp\n6JpSydgkyVuSh5X7PehgA1peawvdN+3R\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAfgtCzA2VBozJRflZXTjIcXRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjgyMDI1YzMtZGQxNC00MDVlLTlmN2QtYWIyYzhlZDk2NWJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ODMzODNmNC04MGI1\nLTQzNjYtYWFkYS1mYjE2Y2QyYWYwY2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATXk2tGu9geuVYDYkCg9HSN20qxOaKoLB1H5zvta92OduPG4CfXN7RTVcFknr0T\nx02KvcAZzePTznAJjhEySqK4o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAQeEjB+acWUDf\nccjNW0BjtHLX3zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBA5dtX1Z26G7IgQOBMWeICRicXNAuujtX2K4puh4SOfQIhAPXR/Imj\nhqnla25GQ6p2s8pBHGwYeSMv4Ce6Y1frfHbx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7560", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7560` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAcgyQP1HLGvhbiZMrHBJBTvVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzMjQyMDRlLTQ5ODgtNDdlNy1hNzc3LTE3ZmE2MjUyMmE3YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBlNTIzMjUtYTI1\nZi00YWJhLWE3ZTgtMTkwMmJkMTcwNjgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEatRvjWf0Iv4xvKoga32S2Cwr81O34ixgxbeWvx2oQyU6MM+gZE8rUfDEktM\nod1uVZNAFQIxqzyfD0xznLGEgaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeKbD/YK0ahQHXN+5Cfj0Sg8/Ug8wHwYDVR0j\nBBgwFoAUHHkXxKroAal25mIzUujoR2ayFbUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIgaJv4UQqTp\nPZa5N9j7Q+yJtLfWqlQeFOFOcyIazcVlAiBGKhSATnEuW6XIjmIyV6NuAdkLR8yO\n1IGTheW3lqF52A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVmJ1Lrcst7OKZ/a3++HTVQZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzI0MjA0ZS00OTg4LTQ3ZTctYTc3Ny0xN2ZhNjI1MjJhN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlWw77wGjwBhZirm4LM/M2A5UZyw1r91qu+Gav545orhCA\nllwalnLvUxSBTZX72UXoBvphdXwT/zLRPmdE7STeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHHkXxKroAal25mIzUujoR2ay\nFbUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOiuy8Fy8/pJwBg6D6kErkJWOsEZOgLypoXo5kCYTCuUAiEAjokI+8+P\nQnQ+5iDPIp1/NcggWqvZy+ISgcJbXU4SBsk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISARu2wtTnS8H9dq9WYJeTW4a7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBlNTIzMjUtYTI1Zi00YWJhLWE3ZTgtMTkwMmJkMTcwNjgyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMjk0MTU0Yi0xNTY0\nLTQzMTgtYjRiZi04ZTMwYjM2ZWNjZTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQlO+bFk9iJNb2PXh3zGMmpt1F/ZIu8GJtpTiQYvh5fGZIDWGUZJY6DCeqwCa8x\n2L25H+AGfLt2rsQASyN/6ouho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4psP9grRqFAdc\n37kJ+PRKDz9SDzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAsb4kruVJ2g3Aw0nWNUsBmgQ89FLeOtidb1fu+qtQXj0CIQDPzm0V\nziy00XOnkgsfI+xjtOhL/pqphyYTv7cvSnhb2A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7561", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7561` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAeVSLyKVWQbUaHU6MZ5E+sVSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmNjEwYjJkLWIzNGEtNGU2OC1hNzVlLTZmZjZjY2EzYjVkNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY0ZmIwZTEtODRm\nYi00M2IwLTg3M2MtN2M0ZWEwZTdlYmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmhPT8BW5jGX4duhKJaDSD0eMDjlCuV74Wxt7uLFFThV9qktduGtZgQgu42dU\nzl4oTgA4XBq3j/qeTMTQhtev0aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQB6yOtGpaHFWq75ZL8z8ZCtOrUAwHwYDVR0j\nBBgwFoAUaNHMCB9wPnlzc3ANvYsfPK/CEPIwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCSy9vrMswT\nEunr3PkDZTT9wA8KfPOXBEWkfgSOiLiYigIhANzAyp2WbbXkT+8g+wASRxYJkTJn\n6X2yRaih4p+Ocxlj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZuflcVGitoCsGHRiF9MEFlBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjYxMGIyZC1iMzRhLTRlNjgtYTc1ZS02ZmY2Y2NhM2I1ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYq/axBh2IW9uMBISFRNmkgxqE1wo9dFZV3X1w1ydjS5N0\nPVQu7uSKIFE0V9TDxM4quBCTRqu8LoGdt/5GcHLro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaNHMCB9wPnlzc3ANvYsfPK/C\nEPIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSLLxM8PSd4pcmObOhagVGQ+PqlLCyj8ofhpIaQRf1owCIQDThHeqV2OE\n7cfaacmnL61C7L5HKWr64gfFJdxno0qIyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAb7uo97gvTzRbrFB3y2bvueRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY0ZmIwZTEtODRmYi00M2IwLTg3M2MtN2M0ZWEwZTdlYmIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzOTU5MGM4ZC1hOWRi\nLTQzYjEtYTliNC0yOWJjYzQyMmQwOTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAReiav10nwctN98hyO4o37YZmc+/zXPGw36lzClhB4S81lbIt04C5Xlkcu04/9G\nSprxtZDHZddFUMK5YR4T/XVWo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRAHrI60alocVar\nvlkvzPxkK06tQDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiB8p5ZawkSwKNolVXS+tH4I/teAVOWXjiEIoLnDaFTDEQIgJZgQqHgf\nbMOO4Nl/dDxzauyq1FUPI0wdUR8VV0OQuwc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7562", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7562` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAT+s56alc1JU4Z3N46ZrSDjDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2ZDA4YjA4LTVkZjktNGQ5OS1iMDc2LWJmNGMwNjdjOTU4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjczMDJiOTAtMGNm\nNi00MzM1LTk1ODAtMzQyMTg0OTU3YTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6RKUXlOt5upQpbi/l2xe94To3ykNmRbxCsWjol2+FKqQVX2kG15dRhJKWxeC\nJXSydfgN97kDC15+QoDBNL1y56OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlP2IEYcu5/UgjKGvDD6rWvRnD2kwHwYDVR0j\nBBgwFoAUVDPXgka8BeTIz1gJ4ZrvH3Gcp6gwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCFTzb2smWviX1GRsjTMphYr10voIYNWz1+u2GqVegC8gIgfBKpN2R3U5NB\nMC2xLk9mq6OCov5tEzvHuB+PbiQI3iY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU33a9GO9Ip1AY+wYublDMzwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmQwOGIwOC01ZGY5LTRkOTktYjA3Ni1iZjRjMDY3Yzk1ODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARa+Log3S5s/zjYsXuiViSrYr7ymUCkKT7TzI+PzXDGnTbG\nKtQWzegC6mb0bnwg5pFPUoNRZkhP1lTINkqcobkYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVDPXgka8BeTIz1gJ4ZrvH3Gc\np6gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO5chrND6bx+qMa1iq8fSotadM8qGXsUZBRGaWBWAS4kCIQDlhrhUTYmd\nSwb2xyorzBqfv/FFHIUcG/iF5KG/55J5eQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAWZKkzT8HJoEVDz1F1EAMtmUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjczMDJiOTAtMGNmNi00MzM1LTk1ODAtMzQyMTg0OTU3YTdiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZWM0NmVmZC04MDFl\nLTRiM2UtYTlkYS0yZDk0ZDc5YmE3MTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASlnUrupr6QiWrVtg7Rk33KEdTcOZb55JB03Js1S8sKvoHsWC1ahxHn0ymfPYv2\n+lBNJ3NYR0BayCbjZwuTlfwEo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSU/YgRhy7n9SCM\noa8MPqta9GcPaTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiAi0KgMfErbq+bIz4sZ9rYK80f/H55kGv2T7AUxQ0i01AIgKNX5Vtkx\n9mVXsTRs7zAVJ5xNp2Nxj8t+Oa91jbzObn4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7563", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7563` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdvNi6Omj31u1pt/JFpZhwUYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjYjBiYzYxLTZkMzYtNDczMC1iZjIwLWRhYzQ1ODg5YTI2NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVkZWE2MjMtZmNm\nMy00NGNiLWJiZWQtZjRhNmVkMmM0NmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENBoUscv8USQGFXrZw9CUO7vAg7Pir3zvJ2/F/0lbz/wJJdxRNFfdkPQwrLDd\nwiEAymoPddBeUxZIMD7QkFQx1aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi3W8zrrlgEhjBRNc59ayLIIVnE4wHwYDVR0j\nBBgwFoAUw0NlybQq2uXS57vK+wT7+kohGKMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDsAB/meh32C5JCGdbZ1F18iYfKVopo4KNxIzgmhd8cvQIhANn8v4FnIbgc\n0XFKAFyA+T69Wk0BJ8WaCt/7f2WW1SDX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARkcK8gNZ39VGYtud4DCwCLDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2IwYmM2MS02ZDM2LTQ3MzAtYmYyMC1kYWM0NTg4OWEyNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+kLs0/d0X4gRIFyYVtFI/GGEOGMvAoSFV+iLcJpbiMx2M\nOQzakssjnB7p/F8oZzc9Y6SixNjOShxA30zr8POio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw0NlybQq2uXS57vK+wT7+koh\nGKMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXa7sLZif5KZRRBuoWbUp8Zgd7CMyYj4eCb1oRE+tso0CICv6w+rxAFp3\nrPSR5XFL7CMI/kq4xGVRAB5SmEMDMIqt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAVECjKTDstFuu6Sd5X6dPoObMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVkZWE2MjMtZmNmMy00NGNiLWJiZWQtZjRhNmVkMmM0NmVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYzliNzQ1My0xMTZj\nLTRhM2EtOWFiNy00ZTE2Y2VjZDNjZWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARWWssazfSKv/YazlrmnihiL38GuwX9XGm5hEwO6M3eNS6XJN4hbjJTqc05tphv\nT4/KhfAafVhGo9CkWpg52ub1o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLdbzOuuWASGMF\nE1zn1rIsghWcTjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA/Dh0nB7C88iO4fPMp7xgf/XNvPhMnSChdmYgcfUWwVgCIDPha6y1\nPGKJ97zPtZxv1NJnDUpNyoSBWwXZ4PXMFPd5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7564", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7564` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAV30XYrzIsOPyO5qPNlqI497MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiODlkNzhiLTU4YTItNDU3Ny05MTgzLTliOWU4OGQ0ZWUyNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU5ODdhNWYtZWQ3\nYy00ODkxLWI1NDUtMjNjOWNiYWEzODhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFoQt/J7NNrjaYa9ecxpRg93HdQCuyPsecBod0qRzFSG951NQSok+ULf3zhTP\nyG5COhPc5XK0q9zGmHEl6PJqRKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF7gm1q0ksze0HEs7avHKVbvcXE4wHwYDVR0j\nBBgwFoAU5c6z9yOzZ2kcl6wQLWrx5bA0lH8wLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHFL\n68ll6XJFTQJdh2B/JL7z619cdCLOurc/LL0QE61DAiEAqUuHm0bqw5kLxDH32zjj\nsAxfM3ZqIpDPgFzctR6/JUA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZTlU4lMuWKF3hreS0BdUIMKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjg5ZDc4Yi01OGEyLTQ1NzctOTE4My05YjllODhkNGVlMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSUZCYaOBcmYCtu/GlwLcn2jWJbYkiWQnlBluHqywZQUBR\n09DnF+A535uHHokAkcPyYrMKBKO1fhWFbWQRa8BHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5c6z9yOzZ2kcl6wQLWrx5bA0\nlH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMGMIQ8fHcV+fXDNI9Xexzz3g7zorQ5KQ5Z5N+mBH9qTAiADvtS31nYE\nEPs1mhQHMycaonEoysGC+G4kKYHVNuwzRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAXi4rLYd4yOC5B0EH+X7R55uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU5ODdhNWYtZWQ3Yy00ODkxLWI1NDUtMjNjOWNiYWEzODhjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZTJlNTM5YS02ZTk3\nLTQyNzUtYTk3Yy02YmRlMWIxOTFmZmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ82fuWF/16jrFAeACXA0y3Hj/9H2G1mvhzkjYsm8xgTWbakVRNTyPo8LLwDpbm\nZse+cHYDiViMoASu+On74LpZo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXuCbWrSSzN7Qc\nSztq8cpVu9xcTjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiA2xTrn4SOuPhlrUXZtvc35lxlWHQs1kpMJ4JE2zwEhmwIgCSGpRRhI\nb1M91vE+1t60w3dpihDhJSrCM2zPIovWkGw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7565", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7565` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAeARMfnRE5T2ttLzzwiR+oU7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1MmRmMTQ2LWFjZmYtNDEyNS1iNmJlLTMwMmEwZjg0OWZlMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU1ZjliNzAtMjI2\nNS00ZDkzLWIzNTktOTBmMzljOTQ4MTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhui8PNYhyHdUDl815zMpIDcip83RyNXjLz/asIOhvqF77n8iy9HploTgJvCu\n72eo2c7Bja+szDUjCLJG9pbWZ6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7tUUIRP3p0ym9+fjMoE6TLt8dPQwHwYDVR0j\nBBgwFoAUbTSZ54cjn3eCoawWAY+d5YXts70wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDK/45T2QphQ+HjgX3TF+prldbFiOIHIMDL7HYxlR8l+AIhANMq\n/MHQ3TXK50GZzmtweROTuY4mxkCyvUExNbfxmV9m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbIKPURQpFWffuQ4TtX4YkxzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTJkZjE0Ni1hY2ZmLTQxMjUtYjZiZS0zMDJhMGY4NDlmZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0q/E8uNPedKLaWyWRf9t9rn+WBR+j055j4HTBj8fSv7g/\nzTYsCvcTKTmkN8rOk8EG1k2M7yhF69BaAJmKukqho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbTSZ54cjn3eCoawWAY+d5YXt\ns70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALfKsfyXRwncewlT3pZCdsF0M49wutfpCiArZAVytcGlAiAwYNaFKaZA\nbVKJKBCGt3sdEx79DrjDtzqX05qZDblhmg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAQvegkkBDz9OJSY1JTSOVOvQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU1ZjliNzAtMjI2NS00ZDkzLWIzNTktOTBmMzljOTQ4MTNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMmVlMWVkZC00MjIx\nLTRkYmYtODE3Ny1iMTZmZDFiM2Y3ZWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATgAQCCHdWJ8Yugn8MkY+JAf4fw+lUr0tKOuAzjvjfbJ8YGOm/vDQKP0lRzLPa3\n0mDJy7RiahmAK9dkEi5WFZ6ko3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTu1RQhE/enTKb3\n5+MygTpMu3x09DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAreumtIMxQ2PGgWEJHWojZUHlGgeIq9rvej+6FImz/vkCIFTnuZbq\nT5BcajnfI4ONTsBZay3Vv4Y4eEK7JzScqnVG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7566", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7566` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAaEPUHxAticLYjxfZTuE2sAiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5ZDY5ZjlkLWQxMjItNGU0OC04ZGIzLTQ5NWE4NzYyNmNhZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQxOGZmZjctYTFi\nNS00OTQ0LWJjZTQtNmI1OTQ0Y2MwNGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE7MtvKbZQaaVuJErwaWzzpFyMywyTqvw5JP03b526DfqfoKlkTPtR/SFH7E2\ni8l26nFnds3Z242li5GAZ9OQ5KOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdnWJiwa4sOWDMbambxQp+YIGD2wwHwYDVR0j\nBBgwFoAUC2goisUMs09tGOKnxrT4igJER+EwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIB0g7sl3zRcKr2iepMMEL4cxa89qQA03mVvT6XyedRrdAiEAoAEz\nX/7TMCJiHWhC8Z2+cGQb53CFTQgfgNZuT8bUKSM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ07cJZ+oS09v+uRd1Ri9PWaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWQ2OWY5ZC1kMTIyLTRlNDgtOGRiMy00OTVhODc2MjZjYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ72+LG0NgmoNxiKv6L1suv9pj+yONrWqNmMBLDyAPrNwz8\n+dG0FpKtEqidXVbNqQ7RE/EuF2m77LG7nluIId+Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC2goisUMs09tGOKnxrT4igJE\nR+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV8kPp+n1WclzYG8eKVu5IbX3sTZJNR8lEMgN1X8C6lECIQDHkRQaBeLu\nMb9XSrdv7r3T8EXU4IH07Ne6A+gRqC08CA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAXwYVv/kIx9LQkhmpVhG82h8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQxOGZmZjctYTFiNS00OTQ0LWJjZTQtNmI1OTQ0Y2MwNGY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OTcxZDJiMi1kNzI3\nLTRiM2ItYTIwZS1jYzVlNDI4MjI2YjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATiWY7I8MrrP9qmYrVK7Ca04DlRoEPLpGr4uvs24VZm8m7twJPPVxz5goXvmLJZ\nq1aJxizQALUqPPoECuMfTUlVo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2dYmLBriw5YMx\ntqZvFCn5ggYPbDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBrNSv/iO+JacDN1uyfxvWe+MGImbghJl2gE7X1P7mB4QIhAMjq6MjT\neO6iPe99+O3uTCKXjppioR7A+5G9YK47RXr0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7567", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7567` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQCaAmJ6YqZFiO9+feOsC8r9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwMGY0M2MwLWJjZDMtNGFiNC1hM2Q4LTk3ZjdmZDk5ZjcwMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZhMzdlMDEtM2Q5\nMC00YWIzLTk1YjctNGNiOTZiZGFlNWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1vSCXt+fkTKwCxpx5tSTe+JCL2nyUA2DrvU+USFSUnWcza6NBR4rs4ftOCgs\nX4YpUjEfydppfvtxh4yO3A9t7KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSfpV2/2OjjL7Lb2QVGO6Fw48SZ/DAfBgNVHSME\nGDAWgBQC7/SItgCXoomAcRNw9UQnfHaMIjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDyRjZ0fCuSL2NfIffB9pTaPH/ppYMt\nJbbz67cGslv8IwIgBup80Fz5A2IYI3MtezKjBCFpE7Z/W4nmFDswKgG4h1A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcC4tNRXgs8Zd3N8kqHn8BXjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDBmNDNjMC1iY2QzLTRhYjQtYTNkOC05N2Y3ZmQ5OWY3MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7SEq5X7UkFDZlISSva/CF+oC0lz+XRehqrjoPMq9Rn0v5\nsHEtU5DM6gSn/sXGH3CfQt63T/c4XhvhGMGgjSvlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAu/0iLYAl6KJgHETcPVEJ3x2\njCIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAZhjRPErzKxxLvXfRZ5iIQf8wQQ1GN3n22rbHTI8LgcCIQDSnhHCr95v\nX2cfZ8CRFO0PSh/Ttm9cjaA80kB6mLthZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAW93u95jZulsUYk5ah8gMCJyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZhMzdlMDEtM2Q5MC00YWIzLTk1YjctNGNiOTZiZGFlNWUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZjcxMTY2ZS1iYzhk\nLTRhYmQtOWI0MS02NjdlMzIwOTk1MGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASC/1fQPpeU6CD7vmbJFfl0vfXhgiZS9JxCacnvkdn/Z1IiCUH7dRGGIQ3OfCbc\n/1IO3T6H4YAvmxGg0RS0KTyQo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSfpV2/2OjjL7Lb\n2QVGO6Fw48SZ/DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAppGODpm3FdjiJOxFmi47gSqt8PBMXJPNoR8hhNoJT4wIhAPgKXxSt\n1nOeZ3R5uAg2DZS6tNWVLrj2MRuiz79WsNEY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7568", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7568` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAfz21b4HnR63W74VLX+BhOLWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YjdlMmQzLTlkNjgtNDk5NS05Yjc0LThiZDViOTdhZTE2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI4NzBhMjctNGUw\nZi00NjEzLThiZGYtNThmZTRmYmZjNmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz4YzRC5+UgpSfNfuwrcfAxTzKQ8Em7ZHVdRzSQtoM0wr3Igursf2OaydZX5n\n0J4VdowGApgWFTEbqlZoshyflaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqI9aIZSNp2HQafI/X6QSToP9N6YwHwYDVR0j\nBBgwFoAUF811TtxbboiO5aVm+XlRyyvbmEwwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCICYH9kuXqaPa\n2/7z2v8LwEDDBpnF5qG/TMjY4ckMbOR8AiBNq0ApeJCq2vvXh3X5AwHx+Rwp/jVt\nb+cOkm2CUuDK9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWpLAxa66I8gmxMdHKgx3xy1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWI3ZTJkMy05ZDY4LTQ5OTUtOWI3NC04YmQ1Yjk3YWUxNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwUUAFxR58FPPi/fNxCIfiynbF2rNMoqX1vhYy3MRKlK34\njajmu0CfQvO5zE28eiljn3IMy/Um6fm+t9aEeiZco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF811TtxbboiO5aVm+XlRyyvb\nmEwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK+vzXNIgEkWxYLWq5dTr10qaVdXDUKx48k/3smgwJM4CIQCPfsWCkyLn\np3uxGI4Br/zk+/aw3GTLFVAL364UGtOWFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAeTMcP9MqmHqe3PZ0Or1e1EOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI4NzBhMjctNGUwZi00NjEzLThiZGYtNThmZTRmYmZjNmM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZTk3NjlkMC04MTAz\nLTQ0NTYtYjM5Zi02YTMxYWU2ZWVlNDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASW7mgrxeFZ8FiW5o3HT6Klxh0KO8gOf8yLymKRJR7aIsj16hYkusQjtmY8hosR\nTmB3fhLz10fzwR6/yDXVMQYzo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSoj1ohlI2nYdBp\n8j9fpBJOg/03pjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAm64FsaBwQLIDQONMEWBJNVePRr5mhkojlcfNupf/O+kCIFOZRZyF\nk7tVn3mfJKJch/9qaHNf7LBsrFwZmsd4gFQW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7569", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7569` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAT704Us/Dshsy6inwX/cRJzXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3NTBmMmVkLTA2NTQtNDQ0NS04NmI5LTM4NTEyNzUzMDJkMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE2MDAwNzUtYmM5\nYS00OGY0LWE3MDMtM2NiZWE3ODMwN2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjzoq57OcqDJD4Bnw/iBm/eD8x+HfQPXfEcpi4Kf8ry99/mzPOVcfF9kGx7SF\nAIb8Lfmtep/0O6VWyqc4LqSceKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf6TeF0t76EkaAiXsilWfyDBiStgwHwYDVR0j\nBBgwFoAUL+WTfPDJVhik/iTm5Z5XRkBgxZEwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCf1XIS0q85\nzuhGoBuL1EMy5g66849Gq0x8+NFPvpLAkwIgD57ujTWhUemmK4b49xqKWWDGhAHv\nuO7wN3W8tdIG6iI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXs0z3hh5vHqhy060y0c/7n/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzUwZjJlZC0wNjU0LTQ0NDUtODZiOS0zODUxMjc1MzAyZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdcj/ELBu4tYg2bDPyWpa4vEcmSu2y2135HFR5rcIwrotX\naCWoYV0FAbrHXziYpzuiqpmJKpdeY/NTiVLrNaXMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL+WTfPDJVhik/iTm5Z5XRkBg\nxZEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGX5+nS1us60ebap5GbFni0uvR2KE5gqxvdy3WjmTfmkCIF7zLnsm4l80\nrXoAwz/aoi6Cd2x59HoNTrIMW4NN0lG0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAYt6+Ha9oTiUb3S6astJNnxkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE2MDAwNzUtYmM5YS00OGY0LWE3MDMtM2NiZWE3ODMwN2YzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ODA4YTVhMC1iMGE1\nLTRlZTMtYTk0Ni02OWQyZTg3ZmMyNjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATzH3R8qcLHGok+N+r0k7ICcgprTnU+lu9isB1dtDynckl+ImbHpZz7dKXpSmWq\nDlpIB9I9taEVqgdFYOWM9bnlo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/pN4XS3voSRoC\nJeyKVZ/IMGJK2DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBWqA8Pt4GlppmOqhS+5n+b+ebTacjMrz8YKXWF5l/ZIQIhANkrUdIT\nn7T+idEEQHDy0WF4oTZBcdw6VAj/tr8uQfP+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7570", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7570` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISARnJGyRo8J/eciXYpMg76FjWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0NzRjNzQ1LTgxNjItNGYwNC05YmU3LTA0ODkwMDZmOTE4YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdkNTA2OGMtMTM5\nYi00YzIzLWJkMmMtNWE4ZWEwODY5MzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUCEuNWbjhKxU4IkqAs6c22jWYl6jdAxyZDdnKzIEhsF1UGVNwJN/0LK5FM/z\nuZAvIXk5azfKrfBSCeMKPRRup6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUI0IzQx/ltID4OEwxoxkN6BGrB8wHwYDVR0j\nBBgwFoAU7FzMGGHPGUag9i2GWFH0xVCdOZEwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiB22pHWkCHi\nkz7w6shPNjoUim8xTmQFVU/NZdGlxS+6tAIhAI89rPzJseijdQ5/SiCVw6Vv/I2a\nK/JPs8ZBDJvW516z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUbDiks6FPdfP1Yy6NpN5ekmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDc0Yzc0NS04MTYyLTRmMDQtOWJlNy0wNDg5MDA2ZjkxOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATq8CcSff6IjBjp6aWSBbehy6yjYDidw9cqCfXO1gbUU9bI\nhnmCxzcszDwOf5ZM+xCBUEe0Oqg+/YTRu+1ZpDPco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7FzMGGHPGUag9i2GWFH0xVCd\nOZEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEmnQHOYQqFyXgV6oehHpEaS9s/cx7ix9fWRx1dd3olkCIQDLMwspz59f\nmJs+DWtZw9lGpVa5FmwJ1JWMlf8CrgyNdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAR4VCFQVVSzzILftk2I9RGdYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdkNTA2OGMtMTM5Yi00YzIzLWJkMmMtNWE4ZWEwODY5MzJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMDYwNDk0Yy01NjVi\nLTRkNDItYjFlOS0xYzFjZjkyNTJjMGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATtdhSABDBNFgfgMIU6wXclM8rGuExUDYwLaQYSTsbgDM+tEqDs/S6DQQBzUX57\nElOMHOHKYXlz9C+HNQa5jtPXo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQjQjNDH+W0gPg\n4TDGjGQ3oEasHzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAu/R0r8pNMrEWKcn2DjFcR10+R0Q0vLH/SzgeeSlhT7wCIQD1WHy3\nGnoCgSWNj5pMQ5VxfxMVh4Keobhk9jGYh0b69w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7571", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7571` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAfxax5RCq9ov63TQ+dJdaY/CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyMGMxMDYyLWFlYzEtNGU1OC04MzQwLTBmNzM4ZTlhNGExMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc2ZmE3ZjgtNGJj\nNy00MjMzLWExNGUtMGI0YjAxYWYyOGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+jQUa5HaD4a04Fqs2qRsvT+MSu3Dvomg13OLne5dqOSnpPfkUBZktI2kjFiz\nkBdooi2SfKwwoqbO590MUEsnGKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUddWgIY077ljpanpuje9uI6md6YcwHwYDVR0j\nBBgwFoAUDLuz55/Z7FPm46ldfvAQfJE/6TgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA/NJHcY6puuCqbC/Qt8cQQRwY+gCLZv7L0Z/c6bHeqX8CIQCkj61JMg3t\n9FjVEQTs1A4q3PaVlX0NcBqQMHUXITjOfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATm3lBRVXSUSvajxei96+NA/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjBjMTA2Mi1hZWMxLTRlNTgtODM0MC0wZjczOGU5YTRhMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeevFN05wZsKmnwq8qs39VMbcNjq9WZO51aGSiyLfYXLOa\ndDZUcrnhBfnI81huB/PCFsUCwznOkKqlB9wXEmz5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDLuz55/Z7FPm46ldfvAQfJE/\n6TgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOXqoMCZXu/fLiC/xI84bA/KcC3dTnOI0Hpuo6MJGhNqAiAR49ju27fp\nGjjreWee8AGiKwNNQ5iIaIt+SugYAINuWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAZJeQMEq8afliRIUakjn8ohxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc2ZmE3ZjgtNGJjNy00MjMzLWExNGUtMGI0YjAxYWYyOGYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMWM1MGViZC1lYzQz\nLTQ1ZGItYTFjNy00OTExZmJhMDc4MGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASYC8T9mjpgMJSFEwNkQ63+fKtCM9eZKo4h3hbswhYGqwrfcV1Niw+V3ZjkGmw5\nf8UwBJ3cI+VyooX1IioM5O7no3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR11aAhjTvuWOlq\nem6N724jqZ3phzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA1HTXDcKmp/vPROY3SS8HllGzymxdVdjUpqC0jOAHWHICIQDymGnE\naJvwAEplFAvALsWQFW2d9sjMg1RxX8Wc26qwpw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7572", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7572` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAXp4DNxI6nOvLKQKUO2cIOaaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3ODgzZDQzLTMzNmMtNDA0MC1iYjU5LTRiMWMzMTAyYWJmOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFhZTM0MGQtYjMz\nNC00MDVjLWJkOWUtMTlmMWIzN2Q2NGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmV10m82b/Kz2ULI7hUK/6L4JHcF9Ho9P2X02I/KJI4VfyQhb8ZCSJ+iHO+3h\nEl5WqSZq0Y5WSP4vPc7wKZDSYKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0lM8X8rYl04ivvwbDzTiUbyScFEwHwYDVR0j\nBBgwFoAUFHZu9tZl6aO9pTxfmAeGjMv7no8wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiBifBRHtJ3dqn40phOSZ6w6R/e6wCjlRDJmjNOvFX3JFQIgW2UREECoa13/\nvQaj8DUPiYPqvNx3nCkaW6Fo4CYvLK0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdtzWTjS0DX1Jg5FnD02B5JSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzg4M2Q0My0zMzZjLTQwNDAtYmI1OS00YjFjMzEwMmFiZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb60/L0FV54RC/kxehVLLNfzdK4ZottrdSWwz77OTRdI2K\n9rN3Re4HYnJlakaH+pjLTXMAVGZgiO+1POeCj/pqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFHZu9tZl6aO9pTxfmAeGjMv7\nno8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPUb7Bq2IYdp6oZRrwwxzA0Gfp43oTI+XPqlrnQzdsZmAiApA0f0MGZV\nsbwUFcXEgVE35Y6qKzISR3X8zBdEZfyilQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISASjftYQANPS1LPjt1hQObXE2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFhZTM0MGQtYjMzNC00MDVjLWJkOWUtMTlmMWIzN2Q2NGViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YzgxYjY3YS1mOWYx\nLTQ1MjktOTYxNS0yMGEwZGFlMmI2N2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARSKDq5YTCQlYpGUUCF01UFWGftgNuzKg07DTe6cBUeu4ubRtmmUOitmXe3DR/I\nrkrw1XP+5B44YcoQMmn1yO3Yo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSUzxfytiXTiK+\n/BsPNOJRvJJwUTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBecS5ZkpSZdrCXxwYc2K81oPfRZjHJs9dQCE7AtoH/owIgbPUjLa0C\n3pLLVdgqx0PsGnPH9b++ezY+n2hi/Gj87Wg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7573", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7573` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAdXOt6deWOdFkScHkcU1srsyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5ZWRlZDAxLTcyMzctNGFmNS04MmU2LWU2M2I0OTU3MzNhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhkNzA4YzYtMjFh\nYS00MjRkLWJlNGItMWUxZGIwNGEwYWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE09RAZnyNnfQQQ2ZhqHV4au4Wp6ADjCBaZCpSMnYw+pPKSHGjifAV/yywsZ/7\nYKiH8shSf3T+EK/8jsuY0kYt66OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSV62+ezVJNU5shXB++LmdabTuJYwHwYDVR0j\nBBgwFoAUNiTMbnwjBBNschpa5kpZjAMS8rowMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n9jtNayUJAQKl6p5VFSdFXmZU+5QPTXOIc0mfx6BrVl8CIBKdVneCcLgDrjKtLsGT\n1wVk1yxYxrcohgiz3alYPios\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASYUgTXOw8k7lappOgnDbBAzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWVkZWQwMS03MjM3LTRhZjUtODJlNi1lNjNiNDk1NzMzYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVNZybRNa+MSPGTCXHdDbaEUxccRDJz4yBRccqrohmOlV3\noSbsJUQMdbrAK2rtXfftyKErfWdxl9KRa6gJXDfJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNiTMbnwjBBNschpa5kpZjAMS\n8rowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLFPZcqUVi5v4NrVrlwF01ThZ0v+8482cKUwthApv52UCIBVgGQYp7Zfw\nNBfD5wuZhXTGipcGnazQ9couEAvhflQ1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAZWKJ/021H5oENcaQIMcJycRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhkNzA4YzYtMjFhYS00MjRkLWJlNGItMWUxZGIwNGEwYWMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNmQxNzI5NC1mZTQ5\nLTRmYWQtOWRlZC00OWE0YWViOTZmMjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARBvTjDpbWR2q5VVm+VDL2Lydi24+hDLIs6E8tpWO9n8S8lYsO5cVy5Reita1oa\ncspiNScd73vULsCzHxscI/nQo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJXrb57NUk1Tmy\nFcH74uZ1ptO4ljAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiA1xe9DkuSNCqm/WrLRwnpgXFkZ6icEj8gcISmHislghAIgMTopjssc\nLWMI6HCQaE7qSE1TjPgfuVuRYiK/SS8dLAc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7574", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7574` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISARtyF/hGSrCiOfNcEGHrfPiPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhNzI3OTE3LTNkZmItNDkyNy1hNjQ3LWVhNGNjYmNiOGI1ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAwZTdjYmEtNjMz\nNy00ZGVkLThiYjMtMzk4MmEzMmZiOTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4XAigtbr0JnkV6vmIsNiSxDs733m3/8lbNCBuOPungdHpAxP4QEVGNj98llK\na0quqpJMVimMdcqPTik/026wdqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKv3OW/uszOe4Z1hmIg+n2K1cMq4wHwYDVR0j\nBBgwFoAUUvamJgmn52OfrEpVRPtp2OuO7okwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiAW/+XdPCwC7PybWr1YyCnob0Klqc3eZoFH14ED8F1OpgIhAPQO\nnfMELC/a6TOb4NXouhuqlzVTbL5tDlOSi4gnuy6c\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASqIj5Eke+eFcdxx70bsNjcUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTcyNzkxNy0zZGZiLTQ5MjctYTY0Ny1lYTRjY2JjYjhiNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBeqqBAAbSD7t6C9cQ10SlXlqHUWYMspiUDpq2AwFqolEu\nUpsfplpKKBf/Z5+ffbsUT+mE/fV9JopDZ/4U8RjMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUvamJgmn52OfrEpVRPtp2OuO\n7okwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVD+6rnMJGBjFVeQxGFSd5xSh4KoJtBffPyey075JjnkCIEDfgM3LuJQ3\n9UCn/Yej0brDllqVqixp+hAuOPG0qwH1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAeybAVedsrCJXH2lZ2sN9O9gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAwZTdjYmEtNjMzNy00ZGVkLThiYjMtMzk4MmEzMmZiOTFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjN2E5YzcyYS0zYjkx\nLTQ4ZmItYWI5Yy1jNjYyMjRiZTg4MzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQegt25hPqAp/oJcoVMGbTysHUawHSe8qznTd1PXCONlQkb46Zg3HUx5nbquCY3\nE6u7Y47jNp98+I/Oj+QwpqPho3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQq/c5b+6zM57hn\nWGYiD6fYrVwyrjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiA9bfagOUYrvaamwn28KU0+WJtjKNWcI+hZd5n8aIfclgIgJpjhsbJ/\nBeeTFgk14jNTTzDQCoHJr6DWpSyfqcT7Suw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7575", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7575` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYEVAyL33TRwjY1xHHSpepNZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxM2YzNzI2LTk0MGQtNDg5Ny1hZmExLWMxZGUwMGYyMjY3NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU5ZTkyMmUtNzA3\nZC00ZTg3LThkYjUtNTkzZGViYzZhM2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqRccziXpq7X8IFyKyTkod/biVEiaxEUWY18i9ZSo9jsGDK8/Jz6yrjdWJiLI\nQQONRMbIJGE81uACn7HW0ih4Z6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPMQGCKsMPnQWt2XfWwsRGU28BwkwHwYDVR0j\nBBgwFoAUJlc9u7j7M2BciTggPHdGMK0eRQIwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiAmcPwho8TRVxfzxMP1xcy2L4w2i10WMrpTJcW4dHGmsAIhAPf+\nuJ+OxKU4Tn8SmG1JyKk5On2wZ0V1m9U5ZwP06aYo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeQ3NZYcIJPA4SGRYmUuI38tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTNmMzcyNi05NDBkLTQ4OTctYWZhMS1jMWRlMDBmMjI2NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHcCAbgneTBWq8TySpN5a3VNazSvBmdErsXI+yLYjXg6HY\neQJGkff1qgmUn20aFrU7IBYHY4NQ9JzBLEY9mVT9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJlc9u7j7M2BciTggPHdGMK0e\nRQIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLqtSL7aYMQNczOSNihwlXsq2Fy12Bwn6sQeQOs1c0kMCIQC1qaGUlzh7\nOZtBWdSmugKJIGTU3xWY+2wXxljdVGeyeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAT1hlhE0MC0mBk5cpG6CncvyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU5ZTkyMmUtNzA3ZC00ZTg3LThkYjUtNTkzZGViYzZhM2EwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MWYyOWZiOS1kZmVl\nLTQzMWYtYjlhYy0xMmNmZjQ4NzQyN2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATEKREuGN5mGisoiAd845IwTszzZZB0Ge4t8Fpz9CpnRCUdCkkHSywtb04Al4J/\nZPCy74HOTARvEHhByyMtuXqGo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ8xAYIqww+dBa3\nZd9bCxEZTbwHCTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAhzXn743314q503C8gDDDqpzdF1Ah3nzsEIdFzJKC75ACICwHyfyd\naDDSAzyJiZs7l5QnKZV//inyZ80oDfmLlA6M\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7576", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7576` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAdQcXaEVcaFHE6tdsXo2PVEqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExZjVjYzYwLThhMWEtNDIzMy1hYTU3LWVkZWJiZjBlYTZjYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU2M2JlYjAtODFh\nNi00ZjE0LTg2NGItMGY2MWQzZDY0MTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW0BFnnhMJESyhoQkPT2ny45YGHypHvzh53Tsa1CXaiE/MzFl8yYEntnTk/iu\nPwMEA1IFJ4SDgi0ApTFQ/ecITaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU411dy0AvxkboZNRVb8CFTvmVIIQwHwYDVR0j\nBBgwFoAUjdQJS4FF6YxJihd7mkhA0YlR81owJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA6WT37mUKOjcy\nec3vbhyLg5VPleINZvRGQq9YubTi93MCIQCA3B2lElUZGxh12UizO6R0mplglFSz\nc8URSflxcDrSsQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbE/eJJzdr0WSFhkUtIC+vhvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWY1Y2M2MC04YTFhLTQyMzMtYWE1Ny1lZGViYmYwZWE2Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARE67YRE3JZhQTVQsuDx2owJEV5pISv4JELdi0pIQkQX/fV\na1plSA7GmAKyd/E3KZAhzdt6EGAp9mWh/+5hQh4Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjdQJS4FF6YxJihd7mkhA0YlR\n81owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgagZqXZkMetAUNfqXWm24LJQLOt/EOHxm3OVzQF5yzhwCIQCSXJFdvTfO\nYLavyXiwq27hMR1yhMLJNqEqA6I0ZjHiww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAduzqwrRuq8iKsLPep2D3vPDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU2M2JlYjAtODFhNi00ZjE0LTg2NGItMGY2MWQzZDY0MTE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNTM4NWJiMi1kODIz\nLTQxMmMtOWI5NC0yNDFhYzk2YmI1MjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQqCPXOlYUr2gpC8y/4o2+VEN1vCG1XeloU5eY5feL5+lzRLMS7zgEFihMba8tH\nlj7VxbJ9zq06uqMwaQmGHzfno3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjXV3LQC/GRuhk\n1FVvwIVO+ZUghDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiA1nzKT4WPGJHdxlwOwxf4xLtdH6XDaZl1YGwPcdiCZBAIhAPYhWOrm\nUUkGgouMUxsQdT3KTInUIDqvl5miPStauCdU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7577", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7577` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAf4og9O8RjdgDyWT2xmYVJarMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1NjY0YTY2LTE0ZjMtNDg0Ni1hMGQ1LWRiZDM3Njg4OTJlNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjgyZTAxNjAtMTc1\nYy00NjI4LWI5YjItYTMzNWYyMDQ0MzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE7cMKaPCICJC+HlAGa5UE663AhO/ta+XyDjTngP3yYuUi6q7gfdn1bgutgz0\nAgyN4kqN7yhkZxhPKBeu3qOlMaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYSehE4QEbSCj73YNclTyv2cBfUUwHwYDVR0j\nBBgwFoAUDa+1Ov9zxFX1YLR5Z78knvyCLzwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIFKK40q3nupZIMMePZ6YAbNm8Ke9UyDCMwzBXVy14xybAiBwuiOusT9koBzu\n+xdbvfu4PLoZ+YkrZIOPysEACz34qQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbadd7yTEgT5T2XnDL5TBRvFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTY2NGE2Ni0xNGYzLTQ4NDYtYTBkNS1kYmQzNzY4ODkyZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqt+xU69AT6A65H4r3sVI3yQ0oL/NR0ySFm0E2H6KtF2DU\nbVm509w36nD8ysfoYeCL+YAnSMJeFbUXjTqEterUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDa+1Ov9zxFX1YLR5Z78knvyC\nLzwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMMb/Bw1pDXTU1NCYDcEcZz00hLvqAxsIduhs3fAopQUAiBslxEeuVxo\nM1VuELbShXZzm0GsvdUyP9XrCq236a9zdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISATmXb4W+LzIQUkIyJoGqiYCWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjgyZTAxNjAtMTc1Yy00NjI4LWI5YjItYTMzNWYyMDQ0MzY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyODY1YWJkNC01NDk4\nLTQ2MzYtOTA4ZC02NjI5MWQ5YjdkOTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ+G22F6B9MSDlbz+HguMUjWFWC+bse9PGPPMCJdcFEHH9urfMemwx47r91/Izf\n/5Weo0x+MfqRCbyAeWMyT2Vvo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRhJ6EThARtIKPv\ndg1yVPK/ZwF9RTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBUhHg/vBC7Ifwn44hcahrasGpurQ3r7/mTMvEoOy0YWQIhAM/ZjwEm\nbjXVli+M2b7gtnyHE5LHB6Qy0kMOUiJ46fkL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7578", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7578` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWyMHCzFSiByN2MX8Ky/snOjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0MWU2MWRhLTc3ZTctNDU1Zi1hOTIwLTVjMTUwNDg2YzM3MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBmMGM2NGYtOWVh\nZC00MDk3LWFkMDktOGYzNDAxZDk1NWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERqkCpju/c07RMbqXSdcMOksn5dKEvzAcM3PiOveq6rAKIjV5cDGgiec40Hb8\nEmb02gTCrYwiJSmwqtmWo4oOhKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSjUdtvOUALbIpe8GvhbgBvLn8rkwHwYDVR0j\nBBgwFoAUFbSJWvxElzFZEiex9WzTTxW2qvswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHqrz203upMU2oA5mVNP+IJki88S8pSPXIH9dhvuwmmAAiEA5YxVraxPP9fV\nrAJJpKsxKm8tBhaKfc/fDQ+OMOJtrNA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAexdrPBgiVssGYv8ROzw9lMVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDFlNjFkYS03N2U3LTQ1NWYtYTkyMC01YzE1MDQ4NmMzNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRjsAwa9unubpmlOTxgCpw2sZxVntPr7wkk6kBMShtAdxa\n29ykGNagGdbAIeU/UbEmOrTZNlLO0Wl2d/hKDsRao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFbSJWvxElzFZEiex9WzTTxW2\nqvswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNSjJ8EqRwqNLni22pvzjKx736YxVXUrWR383mtNO9VgCIQDuVmWkn9ph\n8xvKpm2X0peylArCJto/shME1AyRn2hTgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAVaHruR/DmPBmyYtXJng8/wQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBmMGM2NGYtOWVhZC00MDk3LWFkMDktOGYzNDAxZDk1NWY4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYmZlODQwZC1jZDky\nLTQwOWQtOWIyOS0wMWU4MGVlNTZmM2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQQ8nxq1y1nxnWLL5WlofaRHM8pSpMd/fn9HVCVCZ0qnPy9xllyql+qUfeRQnP8\nPYeojoKJ+idch7Pzk+58xo6Ao3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKNR2285QAtsil\n7wa+FuAG8ufyuTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBU+/y0alKPmnsKvqPZQ8faVXriEHp372M95tKPUFQ8sQIgbJUAVOD2\nseBdNa5LK+f+M6i2rf7Qj7V+kubwwMcAA3A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7579", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7579` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAXF1fr8VlJJLY/VC0+s4+8zEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ZWIzYzk4LThlYzItNGU0Yi1iNDdkLTlhOWE0NDU0MjdiYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE0YzhjNWMtZjQ2\nNC00NDk3LTgyMzYtZmYzOWU4ZjM1MmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2Fdj0jS6v64jrLbjPIJI+XrUu3VRUTUWVLfaoPgetxW2qHJpAFpOhdkuFhtH\nFcSK8pzkbvkja45CpHXBzDblGaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFXu0HAfYIlYLZ+vEqoJ2P+N4fx4wHwYDVR0j\nBBgwFoAUPcRa9s530frSsLX4aO/57drDd/swNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBu7d7t0xaZjhO1RVZUJNabWCBdMfpzGvYcQ9jyZIngQAIgJIZMN2SL5a1i\ncpM9CvKWGI4gG2mbM2+L2om2aMck72w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAQzQW36VLpbQ/XNNvUunJj9oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWViM2M5OC04ZWMyLTRlNGItYjQ3ZC05YTlhNDQ1NDI3YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARixIpPAboG/f3TocJnt2zDZxEsRgQMqNi7YwdEryKEgSh9\nzzc/DTX66+Dn59O2EYCPE7ohhRYVE4i/FwWVJDduo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPcRa9s530frSsLX4aO/57drD\nd/swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIgeodakrwdRRTamCbyxB77XXEiTyfQOHOoRi8Kmf6eaH0CH0/DR7YChOb/\n3HPmhOa6UShVUCe3P92cHUc73N0IOzw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISATJM7ixD0zdgYjYRQsCwRwnCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE0YzhjNWMtZjQ2NC00NDk3LTgyMzYtZmYzOWU4ZjM1MmFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ODA4MWE0Yy01NTA5\nLTRjODctYThjMi1lMDk3ZWRkMGNhNTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASv4yW+EotW1f8nyWD7RrMaqclgBQUXOmSjXbcdu7Z7w/d4r4u5/Msri0O2DH39\nsmCZq/XfbRJbiruLiyEBc7O9o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQVe7QcB9giVgtn\n68SqgnY/43h/HjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA+L5F5/q0/0ZPQboWSotHrxcXW5T1kYlUdmjXDok/myUCIQCYY6QF\nDKSLqBndCs6cYCdsYYvlCgzQXKMFPM/1IY/q+Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7580", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7580` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAQ6aiJdhUq0ObCPzmEINZPmCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1ZjAzOTYzLWRkMjItNDA5My04ODI0LTljZTgxMzQzNjU3ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY3OTU3MWEtNDll\nZi00ZDI4LWJmZmItMjA2ZjI2MDZiYWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBx2tdT6ElIW1JQaN7kQO8ygZ3dk7c33KG/KYhfxdQLejABed/vK6XCOozzMP\nIr+4b4DQOB+N/6iVYQNgpxn+yqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBXNBkF2sjXu9CmsBXm7CFU7JPGAwHwYDVR0j\nBBgwFoAUNQHtcT3YZnSWuqvQuXeRDxFD9ZgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA7j2InjZxOurdPhyr3Wyaju/PobHPqyRX4JA0lfLV\nrHsCIQDMgnlirIwJ0qhAtyelCRxnuvFfcHsw0ZtuPO8EOVsPuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa4yd+DfnhT66EA6T8woE6g0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWYwMzk2My1kZDIyLTQwOTMtODgyNC05Y2U4MTM0MzY1N2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkreAIJMKvkSIOvSCntWRSjTdk78m1EuVoLn6fdfym6GQo\nAglyexBU1Tr9BN2TFulgtAxCqL8pxJ0QvfMgJ85ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNQHtcT3YZnSWuqvQuXeRDxFD\n9ZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga4Ie9xNeEzrO9e81CakVlI4xirWX1nB0T1LIxBCR2HcCIFB2ZmQuM18M\n1nGkjU2rRcGtwIXVbn1uEj9OnTA2iQ9G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAZ17XaEy8HK1LmbpBkKRjSDnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY3OTU3MWEtNDllZi00ZDI4LWJmZmItMjA2ZjI2MDZiYWNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYjU1ZGVkZS1lNTVi\nLTQ4MzUtOGU1Ni0xMjY5ODRjYTBmOGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATrUgDsDz42YP37q12j0Hsr8OyN3EISmq8tPOnCmW/jB6p/jCTi/amX3PXo9mWH\nf02i/5KUbXC5A6E5kHIKcvdGo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQFc0GQXayNe70K\nawFebsIVTsk8YDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAwV9fftZ8DSNAxdVXCUFBHpoNdeOMGvRMD6q98AgY2kECIQDwTZxG\nA8QjbbuoJzqzbLslZGqlKEu4IJ7rSAWD1HVwxQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7581", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7581` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAScbAXAeRUmdPfDxpA/rQgeoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxYzgxYTQwLWZjNjAtNDUzNy05MmQ0LTA2ZTk1MDQyN2JmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE1MWI5ODMtNjIz\nYi00NDgwLTg1ZTQtNDc5ODE4NTAyNzYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdwp7tCOtqNq08QmXpypJDsNYbs5AlwwPctFIsPpC+Cd2d/uJ3PuR7GYgVZ8I\nErx6rAqBzuJ5hiZqYOMvHbWgo6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOb8IXHc4bW1ejNADHck/dC/vVtwwHwYDVR0j\nBBgwFoAUOA8Ax1n+uEKX4iihAgTmTf7FnRQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAvD+vr6UE++mnL8htYu7T/paZxCmcSXZMhmMgP7mk\np3UCIB42ztvNKO5F0DKmPpgQ/f36H5hVbLkpSsIFmtzfAEw6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfJoZ+3NuGx8zY3MZ7RjKWYUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWM4MWE0MC1mYzYwLTQ1MzctOTJkNC0wNmU5NTA0MjdiZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+OhWUymP/qYy6Db1cKkFEuaBptOWAjl0jXsJ98MfM7FwT\nw4RHxERnWUBXHxA1PUAy5u8NmhUVrJMJvVb72pOCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOA8Ax1n+uEKX4iihAgTmTf7F\nnRQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMiMSy2cEiGHS96s6AU0XIQp2oCUDZ+tthvg3xD4BAZQAiEAlhbQ5iJf\nrcYZgRgmOv2LjpviK1AGFa8/DyczjE+tN4M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAfN8jVXaL+p4tEImK7KWQPl2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE1MWI5ODMtNjIzYi00NDgwLTg1ZTQtNDc5ODE4NTAyNzYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYmNkNGRiYi0wZjgz\nLTRjZWMtOTFjYS03ZDRjOTU3YWM2MjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASWoY4x+UE+tJ1Qcdlaj58B/gBIbSLx1Upv9gNcsBAXsjVcN7rCY8TJjwdxGEXO\n3Vha7JZ13VCdseHv/0n0nBIio3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5vwhcdzhtbV6M\n0AMdyT90L+9W3DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiApuFc5wFkJiMczW6+Z9hOLEab3X2aFnX4BCyEPCJ/2IgIhAOqsihxe\ngxDUos/dN90+JbGhyrMmPV7x2BOBpnvjgtb2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7582", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7582` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQZsGFN91wKmYkDkggeFaCW1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxYTJhMGU0LWY2YmMtNDRlOS1iNTEyLThkMTBjMDBhM2MyMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWIwNGY5NDQtNGYz\nZi00ZjUwLTlmYjgtYTczOTY2MWE0YmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWvNqrjh0ta0O0kx1GcRJVvNXRi4+zNL3CLw+9/w4h/Pi15toVgBXpMlhnfKG\nxZHcZn5/hBb4/yKg1zTnrOqYcKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1DU02dCjFtcD5eqmVIozAVjE64gwHwYDVR0j\nBBgwFoAUB3+AOKEJeT/M2Iya6r+FFuCXevEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAm0L3yYVdBjQsnx0kXon8H235mVyCOniqCKcjXKpCw7gIhAIrW\nAhSixznw4KBMfkAc/f2g4006WlTW9H1njNnSSJyq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV03mphn1e7SS4vzW/q184mZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWEyYTBlNC1mNmJjLTQ0ZTktYjUxMi04ZDEwYzAwYTNjMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR55LsJsJPMqrlrNgdju/qOUAsEVot/v+Q8IQ5sgOnNZ4le\nIKiEj+n1xeuso7LW4PHms41uf0rrwyKmSc+uQdBKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB3+AOKEJeT/M2Iya6r+FFuCX\nevEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMFghuLxISoIuWgyAyj0j4KzHC2UEJFOoy+Vkop8oGEpAiEA030oiP/X\nY4SmY0nCworkAytfUIl0O9b20sVvA/xoV4k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAWnvYWe6864ucAJqAGlFlKKDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWIwNGY5NDQtNGYzZi00ZjUwLTlmYjgtYTczOTY2MWE0YmM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZjEyNWQ1OC1mOTE2\nLTRkNzEtOWIwNC02YzdhMzM3MjZiZTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARFmoA7LZLSxH2xYydUJVBnTKSvRN9ezZb96jB/Dqd0ufleioWG/f247XM8BUyN\nPq92l0izKT64Bq5uJkddvCBzo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTUNTTZ0KMW1wPl\n6qZUijMBWMTriDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAvlY95qMxE7prRIoOUDmXm4Jqz/UhFbjqDnd4rQ2dcvACIQCeOg61\nKSXM1DAn5XHCl4rrGYjsfE5aax4VQeYmYOaXJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7583", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7583` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAUjHjPLCl7O0c5Lo3feuKFTFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YWViZDE0LWE3YTUtNDZmZi1iYjJiLThmNDBiYzRiNzllYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQzY2I4MTctMTEx\nYS00YmIxLTlkZTUtZmVhODBhMDlmYmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr86UzARJ6+XiDeKNSvUbVo5GcQIgsiIjQ69vTFnVtfK2Dd7/kjCWZC4pp10+\nDLweHYpGqhW7+tuMIW2lGb8E4aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhM02mG5uJZrw4hgYXliADKk6q2MwHwYDVR0j\nBBgwFoAUAV5WbdLbm385h7R/vYYBdZkEn6AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA0uZhDnfpWBki1nN1GtpGe6ikErM4tdo6\niFVYQ74lVLUCIHRhunlyZ9wEVxzhZ/LICBhVR4wJTPJY0V1a9266CUb3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaACg2wMTfPA5feJsV5N1U7uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2FlYmQxNC1hN2E1LTQ2ZmYtYmIyYi04ZjQwYmM0Yjc5ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlvmtFqD21Ua6CJ93snSntham2OXeud7eXh9QW3oBq7nYH\n+c2gjf3Xa1+ad9U3x8jinl8gAecHoiE+xovHeYEgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAV5WbdLbm385h7R/vYYBdZkE\nn6AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJX+BlTzVbUs2HahSh/1zFaR7ALCs26H2wks5tms4ciEAiEA+8zSyblY\nHiNZicg/+FvjJQO5o45FuIcw/JSFKna7ahY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAXHViEiHJJVzg6SEOHTSX8y2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQzY2I4MTctMTExYS00YmIxLTlkZTUtZmVhODBhMDlmYmU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiZmQ1Zjc0NC0zYzRh\nLTQwMzktOTMzMC0xOTMwOTI0ZjhkOGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS+C6wHHrupY02uC3QQtJ5UpwUni9P+/2uflGoXHFNbGJMH5CVmDIpJf9UhQZNm\nsvw3MMp52twluDm/ydyoCRfZo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSEzTaYbm4lmvDi\nGBheWIAMqTqrYzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiB4yw8rt5goYNytqnl6GX7eFKs97aYCZV8EnhkzHxtFbwIgZbK+wrQA\nnurVKw5mety/Y/sDJwZ9u3w3Ej4EOFmV7ms=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7584", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7584` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAR6nF3Upo/8qsZX49JEKqdQ0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMGQ1ODVjLTEwYzgtNDQ4ZS1iYzk5LTUxNGMzNGIyMDE3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU0NThjZDgtNzg2\nOS00M2E1LTg3Y2YtOTA1NzQ2ZjMwYzk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuf1KczrJK/oQy9Q8VXvS7Rf7yGJOb5fNKYA5TawqRfQKtncUX/uNpWdbdxSe\nKLFM1UsLvhoOnOk3fT0418TzJKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz2MjsD3rlugWAn3ZiDhtS1PhWCUwHwYDVR0j\nBBgwFoAUAPHGlDwtGpVI/nZOYgBJzXburqUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA6vJN0IB6QcFR8Ugjfv8By/Jd3JuhtfOS\nYykpDY0JiYACIBzJiDByVxZegIpWNVz7Gw6Lh1K20g0Y/3LDPWyI0JyK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdpPUJ4B3IxPVW4OqGdn8wj+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTBkNTg1Yy0xMGM4LTQ0OGUtYmM5OS01MTRjMzRiMjAxNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiQCUq5l6ujrD+4UwRW2X9wFfcoTdmLYEVcQzaDsCleSLj\nUyDcURJ++e5jSPUx8dkQ4ReeN8mWMGsMA2KkApSSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAPHGlDwtGpVI/nZOYgBJzXbu\nrqUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKceBSbknqP9QAfGv5hZx3CHooDjHng2UKTJSrTD35nKAiEAt9k2MqwV\noavppNV9H0/TVybeOswpJnCI8UgIStsH02s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAQ9RjSqLlbNPoWG3Z1Z7Y5+nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU0NThjZDgtNzg2OS00M2E1LTg3Y2YtOTA1NzQ2ZjMwYzk0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYjY1ODA2Yy01MzEw\nLTQwYzktYTBkYi05NDhkZTViNjdlOTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAScYfdmYZPksX31rhe2whsQ8WE7hW0iH4wR+ZSAoo8ojUuMTnX8AhCZ5VewvVai\nHWT0xjBuMAeph4T1pwjcChbSo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTPYyOwPeuW6BYC\nfdmIOG1LU+FYJTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA3Ac6sg8/P3r9aejIZxHfk9NVUJkwjzDwxh5VPWtTJgUCIBF7RjOp\niimugmBEulc4YgA6G780bUMBOsoU5B9+TWCL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7585", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7585` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAcmmzKpKLkYqPz1cKUn+N5s2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwYWY0NDljLWY2NjgtNGUwMC05MWMzLWI2YTA1OTNmNjYzODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGUxZTQzMTItNTU4\nYy00NDgyLTkzZDUtY2JkNzY4OWZhZTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6HbIYTuIQsgPRsv8/CLec/9XGzF02Bm5p2iGgA/F5rIUxCEAvEGfco2FcC1R\nqQYTsDlr+oTQRMxi4VUdtBq7LaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0e4q60J4JPrNsF2atE8wqIYRtNUwHwYDVR0j\nBBgwFoAUYAOmU7783fNc69KAd1Bh8JXHo6IwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAsJTQ2LIwC34g\nta6RWSloKPZ7GY1hC1OTqgfTAg20jwQCIQCcY+d/e23Z4sG4Vloo76ov1sLxeCq1\ncIY29ET55vMzsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAScv6/VnC53w0u8S7hmoPWriMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMGFmNDQ5Yy1mNjY4LTRlMDAtOTFjMy1iNmEwNTkzZjY2MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm0/fN+pSHybYOdS3o3f4Lz6ZrAPrknwjLFjTvQFgZNn9F\n16S0yziuYqsvL6UyRYcJ/NSXFTv6uscsETcxkgzDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYAOmU7783fNc69KAd1Bh8JXH\no6IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBLvDkmktKanh+dGdR91Cw/FYyptStOjzQp88sBV7VU4CIQCZA4ZyrXUJ\nYbInCBOOITXgRo+xXZcXp4BgbsWKJ1DiFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAXEtQfqkpN3m21qVZg7Fxs77MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGUxZTQzMTItNTU4Yy00NDgyLTkzZDUtY2JkNzY4OWZhZTg4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZmEwMGU0NC02NDE2\nLTQ2NmUtODNiMi1kZmMwOGU5MWFmNTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQnCPnR56khVkcdp7Ivc5kqCXO8RYfnsL52fCiwffJXSWVMO4/CzomCaFFDmrfQ\nmfhdC3ruDooARYbvE1TsbRB4o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTR7irrQngk+s2w\nXZq0TzCohhG01TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA0l1iDq9U7GfxDA1iKj1Nj6ta6RKXikHbABkqqVfUwMsCIBAWP/Ev\nveL/iPnx+ukVKS1m34pPNfcIrmGEminVvWXQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7586", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7586` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARERwvJYTojAuf6nPw1E/HbbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlZjBkNjMwLTNmN2ItNDc0OS04MDIwLThlNDJlYmRhYTEwMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU1OGZhOTItNGI5\nMy00MmFmLThiNTItNDc2YThjZWJkYThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESEIhmO+ZK6rhc1NybffbDtQkWSU7IxW4fI8He5teA7ChpLm8VLEbC0JJxQlF\nIr1Jad/gDmVkLZvvYjiI524Dx6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlMaQROrPqDfA7KyZrwbZnOVglJkwHwYDVR0j\nBBgwFoAUUaSEe66SOkjJfPurXBdfhtp79uowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCuh3bNX8v5vM46dHxYYaUyBPunGXyuwG8vs2jKLYOsxQIhAKEWujwn2nv2\nSJZ72pATBT2aad3PE5huXKjsFy7bD0Ci\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWxJmRJEa3+oxSjszq7at5j2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZWYwZDYzMC0zZjdiLTQ3NDktODAyMC04ZTQyZWJkYWExMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKufTBmVeBSY0DOgedGtODwMgyuik8FwJ9xDerzObRMr1z\ngZAp0XF90yT0uXTgcoE15/rdKW/7CICZe4byy2bto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUaSEe66SOkjJfPurXBdfhtp7\n9uowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdKouOibMKIXiqiduUnPXq8v+tL/1TKDYoDRQxjdQ63YCIEbuXgB1gAWP\nANleV+MzrlZqD3spM6U6L1Uq0z/OlpPK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAQTBIVTKucq/JQozBOC0G+JMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU1OGZhOTItNGI5My00MmFmLThiNTItNDc2YThjZWJkYThjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZjcxOTkxYy02OTZl\nLTRlMWMtYjA1NS0yMmM5NWIwY2M1MjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARuB9oTVJr4aaOmH1bvJCq/sS9nqlFdqhDlposfWi7EgvsAFSrham8BmzYgJkv4\nm3EmU3tu5itKyljozs1N5n6Wo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSUxpBE6s+oN8Ds\nrJmvBtmc5WCUmTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAyQ4RdYFPtJZnFTwlJHw/EXkXsdoI0nbBXFhLJRVu/vICID/uHbi7\nsHMNYaON9RbZ0TNhJC4z3hcl1mvVzG/6GRmc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7587", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7587` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbqMRo3k1FaNT3eCKz/kI+zGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNzg4MGY2LWI2ZjYtNGM1ZC1hNDY1LTc4ZTg1NDc3NWY5ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWEwYjZmOGQtN2Mw\nNC00Y2UyLTkyYzQtYjkzZDliNWFjMjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELfaAytDFrKG1zdpl6cVmTGZeST9r3zX3P9u4/y2lbqiLyLd4zb9ijYaZV4o0\nPWegDfXIrPqiWstd5xjoYsNE5KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4A7n95bNyEHrXFbHzEgsoagNz+0wHwYDVR0j\nBBgwFoAUCknZHadN8fhzZZBSv8HKqwjk7rUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC+FSX11Sih/xz39BNZhLmrVvWRLF1BN0hHQj2EfvyiywIgJqmHuZr/XEVJ\nH7IjRC/XSWBqLo2Ndo3bBwjXuwDOKuA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYO7P9FGZOwXpP6IDZ6lmIjWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjc4ODBmNi1iNmY2LTRjNWQtYTQ2NS03OGU4NTQ3NzVmOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATjSQdoNX8eEwh6IBJb+b/ewcW4wo3doN8nc0Xw0e8LUvy1\n68FyXAnHy84LPR5QLXEDGBZwZ4vbwT4vubsh4Otmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCknZHadN8fhzZZBSv8HKqwjk\n7rUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPgImU4aRC15HKm+rLJgKpkZ5MynqeMKas2uWpdL6d7bAiEAoRsMRRUe\nODULsSzjbaGmDs6WBCrvokEjruRrOooQs4Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAWLRzfLRT5t/RwwS8x5qA7mKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWEwYjZmOGQtN2MwNC00Y2UyLTkyYzQtYjkzZDliNWFjMjAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OWZlYjRjOS1jOGRk\nLTQ4NmMtOTk0OS0wYjJiNzI5NjQ3NGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASFTHHWrnjuGcGeKH6fU+Q6CqTOa9Zt/ZOU3C4VAj6UiUbT+PclIoFHw/JMh9Bb\nJuqkXIZPeI5Jm0tkON5I3i7io3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTgDuf3ls3IQetc\nVsfMSCyhqA3P7TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEArw+wnKIlzApCCuB9QZdsRPHUcWgDajO6b173T/BSryICIH25KCYQ\nuIn687y02aGY3uqZqGpyGV3PsmbN2/Y5jwZi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7588", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7588` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZbuxPmHHX3lr7cFEvMCvN+bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyYWI0ZjI1LTViOWMtNDI5Yi1hMjE1LWYzOTBlYjI3NGQ3MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUwNmRmYWMtYzIy\nYi00NGU1LWIwMmUtYzE0NGNmYTgzM2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXqRqJrUOlEAjCGfTfG2iZ8d4SkmWwp2s9ER/hJKOqoZe7BhabfvmmsseXwI/\nc+qYlhOT0dIZeBoBQ4I8IhLLxKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8rgi8BE5Rwyj0ev1BySqxv6UalgwHwYDVR0j\nBBgwFoAU6E2JXy5JmuHnZgE819ydMzEHanMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAnxIzB2EsvbKgDhULyGr6W3pUfYzTWP8jGLwpSN6viLQIgFFZpnX3nvpp2\n66hMSbOMC28IjWdU7ESxxlspbAi4K64=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUiGyvj8RCvJp2TmxckOgRE+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmFiNGYyNS01YjljLTQyOWItYTIxNS1mMzkwZWIyNzRkNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdIas+ekerikFHpGm0zjj2NE63bBVFGd3TXGViAkF9tfwP\n7j3wZ5r9UUEfdCTxt9sTpKEBILoVejKJL9EBeZGCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6E2JXy5JmuHnZgE819ydMzEH\nanMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIARZOYAnwijeHE6CVAB6BpYZxdTGkIRRYk9h9Qq8EOqAiBBBDJO3uV1\nf5fymOE94xrLov9Tw9TF2olDohcchngxKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAYpRSPVrDPMA9/rsuJJJfzqGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUwNmRmYWMtYzIyYi00NGU1LWIwMmUtYzE0NGNmYTgzM2Y1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YmZlMWQxMy01NmUz\nLTRhOTUtYmQ2Ny00ZmUyMzVjZmQyMTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARgattQcCsduAbzUs40D/cVCJn9Se+M51K+VOKuF4KxrCU0cvlhWNCHmimTJ7Nh\nkjSjdv5pynqsfvV2aMb/t96do3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyuCLwETlHDKPR\n6/UHJKrG/pRqWDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBx70rYU2Y2dElzB+kbS5BJrUPlxYQz/1L4s8x/gLx0KwIhAKd7rZJW\n44DR+bq/aQy0NXfC/LT7Xrgvhh05VSEZcelb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7589", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7589` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAclhYhITPNnvX6tRgcQpm4TDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyZDRlN2RjLTBlNDYtNGQxOC05NjA4LTg2YTI4MDY4ZTgyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE1YTVlNzYtODYx\nMC00Y2RiLTgzYzgtNDZhMGQ5YzJhZTIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeXvCAAFnyShoeph66ZJfl84TveyMI9Mno5+/unMD1jziPENbFQMMWTuMoPU/\n91fyGc53EHzoHMLSslvlqYELb6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb4PGMSHiDKcoefsTK3XBvLFgEwAwHwYDVR0j\nBBgwFoAUyct/0q+uGu0JsDci5IO9fGlHeA4wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA3F0/yPNNJITyAcAvxy07A4eBqAjHzj0HSJ4+GF4E\nrDkCIQCOJsefapzC1NDekZ92nAzh+b28b9KZI82Jy24pVAo8TQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdrpbbZ2ZKzSL5iULInOYComMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmQ0ZTdkYy0wZTQ2LTRkMTgtOTYwOC04NmEyODA2OGU4MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLJgOFlkEtKKIgiyfl4BwT9J3G+kHnyjX5p9V/lvHg8lox\nUc5EsLV0mu46H3JN95VAUq9MNObNlSwKQro1VyOMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyct/0q+uGu0JsDci5IO9fGlH\neA4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLQNixhQmDmGFzozUNHg3g/bgz62B4yyP6l5PtBMAVS0CICUgvVTTB9wr\nx4EV3P/cEQJbxahlnMp+NkzT4fVjofrt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAUlwMAEA27nCEvDvkpBZcuJMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE1YTVlNzYtODYxMC00Y2RiLTgzYzgtNDZhMGQ5YzJhZTIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZmM3NDQ2NC00MDBl\nLTRkNjUtYjdiNy1jYTZlMDc4YmVkODkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQd4UbvnNo7RGxfmaxUlB/iduNRMcWVkfLmD+Rav31k/xW8vTg9uEEco8f/vCPa\nh+Iw5kMGiCbkOqNqOVPGAvRIo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvg8YxIeIMpyh5\n+xMrdcG8sWATADAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBv18mv87O398c0qPWx1jMZtV44wlsPsBt76s3UevOPyQIgZrzPcocL\nZNPGFcVAMgDeP7RR+xutFsZb7B4bcTk8NY0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7590", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7590` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISATI0EU6D9YvX8XauM0SfOUS7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZWFmNDYwLWY4OWMtNDk0MS05MWExLTdjMzQzYmQ4MzBmMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDdhODllOGUtZWQw\nOC00MzEzLWEwNjgtMjE1MjczNmZiMzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpHZhYQzJTsYzZfyfXWJB6oumsL4mYSLW6HVxtH5oPZhpMjhK7xjJKhpFhKkU\n40tm7AOXK6WBXfbHFQ/5M9cvpqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Wzb8qDPR0hB/jcFpNgiU0FUfYYwHwYDVR0j\nBBgwFoAUdLysnGQKEVqR9RrG7x01lFdvLtcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAzy0L90g2/7pqWpk+kaDW2E/L3pGjxBRKasxWzFd3\n+wQCIAzkTHc19wzRuCAJuWmFKejp1dzJBKoRTjYjB7Sk7zc+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARHY4DfAH4HkOwoYbcPELOfcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2VhZjQ2MC1mODljLTQ5NDEtOTFhMS03YzM0M2JkODMwZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTMMWrwAKYtW5wn+Kg45rBRbVVjUMwJImyJnTR9sC+HBv0\nJenrxpbH59aIhbmRFRJyvoFpaap072D/6uNS/t3so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdLysnGQKEVqR9RrG7x01lFdv\nLtcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKKWznFFLpGdWVuQw25+GXOjNMX97RleQ66FtUB7ZNyjAiEAljBDOG/3\ntU+8wGbfgnSDIuQXU11Ul9zRzpLp2a3wzhI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISARme76v5Bof3lJP5Q5k43n74MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDdhODllOGUtZWQwOC00MzEzLWEwNjgtMjE1MjczNmZiMzI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MjIzN2MxNi0yYmI3\nLTQ1ODctODk3Yy1lZDY0YmY5NGQzNmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASOl1WM9658nibEAy2S2OPwzf3x6eyb+zkMh8nmJyc/TkkocQkR/7G03UHguiJs\nzP3OXgXXT+Io50onyBzwuYHzo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBThbNvyoM9HSEH+\nNwWk2CJTQVR9hjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA3JnH7scF7GlQ9D9Ze7dlNaI7JR48nJ2Nh5QfD9t6Y8wCIQDkGgpC\n7VuagR/uRIL4cemvsE1XzCJv3CY5aVr/oqBOFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7591", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7591` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAXpLcr01SpVav/0xDFaT6AIDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2YWZiODI1LTAwYzMtNDZmZC04MTI4LTEyODhlOTA0NjcyMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVhYWYxMjEtNmEy\nOS00NjYxLWE4YjAtNmRkYjg4NzM1MDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED5OKQHDBgcJUim+7r5o26QiVvt2dGeXnRZYTKP9Ei2/kpPAW4gMeVO7TkGTl\nqvqqSOVpg9QUSlbyypkbrL77sKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFmm/g6JbxyC2MIH2uSV4vbpW6+gwHwYDVR0j\nBBgwFoAUZW18rWvtgdp+CbB84HcIkbSmUEswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA4FFPjS/RNkWn3e3/tMP1D1JYzgpzM3LxbUtKka04cKgIhAK/Y\nNbPR3RzjsHQnmJHaSNa1C6wp2EzXW8qfVftYJ3Ha\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS1MtocWGzOsltdnAuNacLVDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmFmYjgyNS0wMGMzLTQ2ZmQtODEyOC0xMjg4ZTkwNDY3MjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASz1J7dXbAQd8CvcFf/Bli7iWQPHKoiGjq1tClthyfaRW1E\nK/VZojCvuQY6lBnFWxlGNjntguac2k/en4mkZEfIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZW18rWvtgdp+CbB84HcIkbSm\nUEswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOAg7RXiS59JABewEH8cBJIMp2NNKpfBD8oVl+/OSKkVAiEA0owscVD+\nfEPRyBdNzqsOhzUk94eiO0PwXHxYiKt/UAA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAeScqQnedG9iAEIHT0ezmWNlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVhYWYxMjEtNmEyOS00NjYxLWE4YjAtNmRkYjg4NzM1MDhhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMGE1OWEwZC1mNGZm\nLTRjMjktYTA0Yy00OGNjMmMwZWFhNjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQRuCBnbIb7saQ/kPszVsTgrwp4oG4DE2d7G7vT4/wbdc8RR4Ge5ESh7/Sn5kDI\nOqD1ArCAqYwVoo2uQ3gnQMYxo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQWab+DolvHILYw\ngfa5JXi9ulbr6DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiASFoLtlNbkzm6Y1H2t2stsTXyXOiODuUznA85GtQQZTAIgQI1beKSM\n1D44tS6KZodmkdDcjcuMi5tlCJ4EcevwJjk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7592", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7592` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAVZs20ezH2SIXZVVxAql4psOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyOTMwM2ZkLTRkNWUtNDAwMi1hZmZjLWNiOGMzNGNmZWQ2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFkOTUwMzgtZjEw\nOC00Mjc3LWE2MmEtOWQxZGE0MDNlMDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3DTb1QD5e3Ngx/gKHicsx+FX2E9JAOuyvqVsaf1+Sxnn+Q8tXNjwVW4MG8oT\ne5IBG3kOvTAl4o6lZ/eTl7HOJ6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa1y0/EojP9QPDBQ7ibFhF5tFg2MwHwYDVR0j\nBBgwFoAUdC0tJ8BJ+BgPCh8z9Qz8BngAr8UwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAuyifcsEML9qH4UsPU4m90l9gHv5KXATy\ntgfEcd6AplsCIQC+Kyv8rl7yy9GIl9FyGlQGvDln8V/8V46dxKGyHMNSZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZKIQHCYSEK27N1ePc83HipZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjkzMDNmZC00ZDVlLTQwMDItYWZmYy1jYjhjMzRjZmVkNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpDT2sYFc+et4iRCqhhXpQutAOzOB1aVO80fflcdzv3p7e\ndrK7crfNfYHRStg/HC3RwaIxI20+f4wHOCVqRu5Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdC0tJ8BJ+BgPCh8z9Qz8BngA\nr8UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI2bZwg+HlLtJE/9bxHlpBekstD065K7pEMxgVHolIa/AiB614X1Rczu\nwobyXb2VTBNM9sBwPsDWfhosZxORsEc2Rw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAdXZSqW6i0K84dGdYK/PqyVmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFkOTUwMzgtZjEwOC00Mjc3LWE2MmEtOWQxZGE0MDNlMDI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NWY2NDllMS04Y2Nk\nLTRjMmUtOGM1Ni0xYzQ2YTgxNmIwOWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATLu1xThTbPvnF4Bi87dFKjtQ4tzFb8c31NMVTnNDaqjLww9A5rOuRloUaeZ5/n\nf6DOt6VgFSwy0NkLQkXzlFMXo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRrXLT8SiM/1A8M\nFDuJsWEXm0WDYzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBiy/09hTdzGAtFXBh2ifu0sGXl5XWRN5MGgdo0c7yGHgIgDCkEWitC\nr4D93m+DbtqlzbWaO7LDpFqNAFEuTC+v5cc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7593", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7593` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAertci47CbiAhk6yMZJFveMGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1YTgwZTE3LThmMGItNDdiZi04ZDkzLWU1YzVmOTVjYjIwZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWIxYjAzMjItY2Fh\nYi00NzhhLWFjZWUtNDNjN2Q4ZmQ5NTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4ERTP4OzhQrc2EDQQVgWKMLd2IPIooPpemEd4xysOFe9a9UlTtREcAy6YLkh\n1XBzmbmLDe/ZG4t4MCataGt6DaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/cijTWV8ZpCyIEGRtuRyxNn7WUEwHwYDVR0j\nBBgwFoAUIvvJiXxz4Vy8oy7l6BW0VZNWv7AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAr7RZ4GSex3K/N5up4tVcjG7Qf5FGguLh/\n35U01ALbpgIhAK7fxSZfL0ssoyb4n+c+M9q+bH4f7WyFa6I3ULaKHXPI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcHmofosSFnwIX/cfF6PshTpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWE4MGUxNy04ZjBiLTQ3YmYtOGQ5My1lNWM1Zjk1Y2IyMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6fcXvJnG+B9RK/4vN68XtrEAZeG8ZYlNvsrWLMu2+Q3fg\nS8HiqtwxH3aM5xzton+lzyFZlVYIeZor7xBLjYRho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIvvJiXxz4Vy8oy7l6BW0VZNW\nv7AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANFz/cBoCqLRKoPn7PgzbQTGsfmsfgbW7xt1xnSY/fJ6AiBRPrGQRPBE\nqhZuXk5vKIS/CYSBLXIx96PODRK8hAMyvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAcyoQFd19aHha5fUZzboKgzlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWIxYjAzMjItY2FhYi00NzhhLWFjZWUtNDNjN2Q4ZmQ5NTI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZmI5ZTU2Ny0wYjlk\nLTRkMDQtYmE1MS0yNmE5NmVhOTRmOGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATDDbm0VdyKzyWX3OtIGoz/aXUfLM8uEB532JW/F2qPwp5mWyKK1KIaRBsiEsgu\nALFvXJoFWqy3Ri/z1RvAMBp+o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT9yKNNZXxmkLIg\nQZG25HLE2ftZQTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBtch8man5mmUon/WbjjxRebEJk9zsDOX3UK9GEfrwsTgIhAJLneeOw\nbCR5BHj6p47oXCscAZtX6UFt/XkCHjc+aTP0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7594", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7594` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAXmykugd3DrQYpEvTYhwY8Q6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyZGJmMmU2LTc2N2YtNGJjNy04ZGYxLTVhZjEyNzQyM2Q5MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJhMTY3NGEtMDky\nNC00Y2EzLThiNjEtODhmMGQxZTk5ZjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdrssWrTjfx7ScFFKtv0Yl0qIrfv9zCvCGauUdXZikEjvyc2zuw2nPXmMSXRw\nPBQZdUw5M+ekQL2vgNyMxD2eKaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnbgH2pHSR9vMZgfO1oNsIpYUJNQwHwYDVR0j\nBBgwFoAUdLSNYKLFzUPXWtJEH+YEkDtsbCAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDuSmFuXk3WNpSHpfbiSW5/zU1x\nxq0r8YPsVHJuLdK88QIhAOMkm6eUtIIkq/Yk7iXo/XP2+vBPMLbpU9Z2f42uZSKu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR83/PY5Y+ffVghGaRbYmPvFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmRiZjJlNi03NjdmLTRiYzctOGRmMS01YWYxMjc0MjNkOTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+/w91umJ9le0TcdOt4tl/3dMrLphZrlf1MInbdwRXxciz\nO486UDSi6rY5tNw+U25dpkkXMzYfjaf+emnPRMY8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdLSNYKLFzUPXWtJEH+YEkDts\nbCAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOhCV+pS00j2KAhjIJf2kerzamlpNcM2vdFxdCDIvGKNAiEAymhtB/7Q\n3HK173uJXdkcUPczq3CscQadPNfGV1RWvtE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISARyDwFL6eDwqGMmV4VfRvXBqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJhMTY3NGEtMDkyNC00Y2EzLThiNjEtODhmMGQxZTk5ZjI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYjJiMzZiYi1hNjcz\nLTQyMWMtYjQ0ZS1kZmJmYTQ2NWZhM2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATKI6RrSIkHEbEAMnNTfr1l6wfrZUGGJGh6l2z+AwLI5Zw/Z+oDq1mL2/yKttOF\njHHVbggWNqAsExPCEr0e0B42o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSduAfakdJH28xm\nB87Wg2wilhQk1DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEApEI5yO9gtEEBmOYFP58mboZQ4a+VJGqMxKq4tiXMYdYCIGuFxaX8\niB8bKYuFU6twepp0P9O516QF283rTPWYclTR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7595", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7595` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAU7YIvktP5TEui3pg+K2tuAyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMmUyYWYwLWNjM2UtNGM5Yy05ZjVmLWI0Y2I2ZjI2ZmFhNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTc5MDlhMWQtODhm\nMi00YzlhLWI1YjQtMTkwYTg5ZTEwNjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhf3VQIs7U8goFu96tCyoAbM+zgEUBkSz+hIAfXHJMVdmysubM9/GXiRdSmem\nzcOV29J8ckF6VYpQZp8VT13JG6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgbcD+7E1/eM1+IT2XbgVqoirOokwHwYDVR0j\nBBgwFoAUfXHEf/JWxp/dRADo8gpu0BJKKmQwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAINZNftw\nm0bOxZbCT4TiddytKt91We4K5RXpopnTMtF6AiAhlgx+X/MHdgUl78/JfX9vopo/\n2DUoU0fVLmOrlCQrdA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWTQv/OCEaLlLIcLW5IOsDNDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTJlMmFmMC1jYzNlLTRjOWMtOWY1Zi1iNGNiNmYyNmZhYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsoccGgv1D5VYJLHopLOzmU16m1BZNE9feGjNGoXM5T/E5\nKR45BjMrXW+MqaJxavOwEom3KSzmxiSlaym8hPTVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfXHEf/JWxp/dRADo8gpu0BJK\nKmQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOOOgzhoqmi4Xof9GgeQfRZ8lvoN9MateXutJJ7zce3kAiEAzJn5WjK5\n78yLAi8l/ETkAA/UFvJtng0r5XFap273RBA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAb1ki2NU0OtLuKwXd7BTa6K5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTc5MDlhMWQtODhmMi00YzlhLWI1YjQtMTkwYTg5ZTEwNjdmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYjI5ZTA2OC0xMzBk\nLTRiN2UtOWI4My04MTVjMTVmMjA0OWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARAgVV8u+VlW5O6sQ1wQ3Bmj+KPKS3/Y6Ypg9AgI+b/6MBBy8kqc902jy5CJVFq\nC4ZsRU1heQNyo87pItnvxw/co3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSBtwP7sTX94zX4\nhPZduBWqiKs6iTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAz4OxUL6a3S01zhpLXKfppU+HSgBv0q3Y1jgJIPx+HlgIhAK8DB3HU\nf0BeuZBFkq/hg9mpg+bxWxUop7vdAf7hlzVT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7596", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7596` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISARxk65uHvvKZ8lvvpu/9CSliMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3NmQ2YjAyLWI2YmEtNDdiZC1iZGUwLWNmNmViNzM1NzEwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQ0Y2RmMDMtOGFi\nNy00OTAxLWI3YmYtMzAzYjI4OGVjZmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESNuyOJivwWhwZpX6mcSSpkJ0bZ4JkkSythjwYRlzsmhnig6Hg7MAAVZR7y47\nata6GjJd3MP3QP7+78TX7McLwqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmiHTgHcbLpH47wNmBqR81dXMZxcwHwYDVR0j\nBBgwFoAUwqyudpDEVsNxYwWAvh9WNTvms2IwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALrW4rAA\nxBu6ZoJWUyubIfoiBpeGvbj1940GQraQSFrzAiA0PmnrRxQPRpf727H59G4HC+fB\nEvTwFzl1LtIMXu4P4Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARjgiiDkcaUP8gZBi5tpHPrBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzZkNmIwMi1iNmJhLTQ3YmQtYmRlMC1jZjZlYjczNTcxMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARho6Uf2N1aWCMxmmAEC6kc2rUda9tZjalszZN/xq5iQ1wA\nIu24TS8poOdZ5zNE+VZljKF3oscigpUt2/vrJWP+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwqyudpDEVsNxYwWAvh9WNTvm\ns2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaL5v2/Me6ntqOWS944O7WLNsRaOfq/LXQRupOWXlQRECIC31ohypwVdU\nu0REAkJUzkMPExmBQYq/7+xuseo79gnb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAYUZa59ICB6OwK+eJ08bsxDJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQ0Y2RmMDMtOGFiNy00OTAxLWI3YmYtMzAzYjI4OGVjZmFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZjdkYjNkNy0xNWVm\nLTRlMTQtYjViYy1kMjhlYjkwOWU5NTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR65dUxo8aScn2nG/2aqwGfwl9qKqcnyi1biG+hT+9nMvnnkknzZXli7Jz9F+Rm\nXp5yur6vmk8V7hwSlkYQpzzco3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSaIdOAdxsukfjv\nA2YGpHzV1cxnFzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAqUPf6GsfKpGuYHmBHAh7A+X7MVCgt721BFzhbArUN3gCIQCDADeq\nnZkl3WCEHad5s0WMfhSoZGoQI9gJ6m/m3urvcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7597", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7597` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISATechBoax61HxOaSz/nx6ToSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxY2EyZmNkLWZhNmEtNDlmZS1iZTA5LTA2YmI0MmNkYjc3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIxNzJjZTQtOTFl\nZS00YjRjLWFmYjYtNzBhMDMwOWM3ODE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEikCQwISq42emNKPHGUNmxf5OJ9xr7j9bacy82g1FKZ5YploKaNaUVwYJL2yk\nIVt1XFuYdgcJsns8r0gOhqs94qOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4pivturjm5XmasoLVuF2ok/HkjEwHwYDVR0j\nBBgwFoAUlFBCeajLxoWgRw0ItYsgg12v+sEwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDbFoYF\n4EVCZNwHk7NrsDwTSRoOndXiWh7YpPDdwDOhkgIhALMADUOFte0a2u7zIu843Mux\nf86NIviyyeszTV0hEgV1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZuDT6zlXZHoK7m8HX/AU75LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWNhMmZjZC1mYTZhLTQ5ZmUtYmUwOS0wNmJiNDJjZGI3NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbfXgHcTfaD1sjPOePnvJGKbu3c+zQmjOxKIl3O0PQ8NPB\nXgsTvqFk80p72oPnGPoWCEcT3SpfkC7EIeHY6biCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlFBCeajLxoWgRw0ItYsgg12v\n+sEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaSSgHTFTmEApvlsx5YCab5QDPN46YMBWcfazn93hp9ACID0brBMyQEBY\nYuSzUoN2Vzglqwrg/ewkON2ggtedKTDb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAU9gI30LFQwhB/D2zG9nwyxoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIxNzJjZTQtOTFlZS00YjRjLWFmYjYtNzBhMDMwOWM3ODE5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZDY5N2QyOC1iYzky\nLTRiNzAtYTQ2NC1jNmFhMWQ2Y2MzZjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARPFi3IyAKmmUNghnH2KS7Sh4TjEMM6ACIQJ32GMHejxOjcjqq1CSFQlmXr2cpo\nD970R2ZybFX69C8//6qmyu0no3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTimK+26uObleZq\nygtW4XaiT8eSMTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA/I9bEQ8VeqvY5EUchqvICur6c8OROQWGOH/SNqwUl0MCIQCqQJ+1\nJEypC/9f37vUGi3qhiyKSCf0NB/Kq6hQ1pTPvQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7598", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7598` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAbFMJhlx48uJCQyUA7wqOS8GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNGJiY2JiLTQ0NWItNDAyZS04OWVjLTViM2U1N2Y5Mzc0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmEyY2Y0YzEtOTlm\nYi00Y2E5LWI5YjktZDBkNzE1YWUyYjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtQD8V21RuBhhVll3j/xV2LI1PVsdH1bEY17+MDLm/F7aPKu0PRe2VSIovBqN\n68nKrxAKWdaKR3RaxcqNOLrxGqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCTiBGOadIVUED8hLH1veT0LbEXgwHwYDVR0j\nBBgwFoAUs6oAkePeiezvmKUwyYzmkvX3cKowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDfqlCfDm2FjpFYgj3kG/Ee/loizm4iwHb+qcoLezaCBQIgBJPp4lTp\npu715/pYgN6NVSqXo7E/qRHwvSvX+s/Nt2k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT+vxAQ0XcSQ9P191gEGmGdTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjRiYmNiYi00NDViLTQwMmUtODllYy01YjNlNTdmOTM3NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXPRMBwkHCDPHJbus+PAJxgqdeIlrVOwUKaHYtd3rgQ4sI\nFtlmRkJQyQkppqcfpC8j6fTe0VhBtUCMY77RT846o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs6oAkePeiezvmKUwyYzmkvX3\ncKowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCVvE/jvx1sSD6qgoJnWtVvW7p+2ABlHvK63+HNLyJS4CIQCPnGNfOPZ6\nOYznfKgtoVGuhruBTYkb3xzn8E7Ton2Xhg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAUbTK/9LuNh9a+3HnMMdf0DvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmEyY2Y0YzEtOTlmYi00Y2E5LWI5YjktZDBkNzE1YWUyYjRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NzE4ODhjYi0wNjI2\nLTRmODItODVjMS00NmJhOWYwOWRmMTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR3Q/D9RU7WX8xu3bScMdrB+eEn727qX43zrnECHqdQP9llkR96WjllcmrrtgOu\nA2/mVdRqkGup2HSgSE785Jfco3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJOIEY5p0hVQQP\nyEsfW95PQtsReDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAnqXSEYV58T+zU2/KiNQlddJNZVZFPvDogrS9GlgxJgYCIAuCCzg7\ns8at6pi1dHsCqxUOe9abmnSpbD0WWpkIzkEY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7599", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7599` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAW6RNCuDhbrsP3vsIme0HJ7LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhZDZhZWQxLWY0ZjUtNDRlNS1hZjZhLTgyNzkwMTgwNzY1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRkMWJkYjEtZTJm\nOS00NTZmLTk5YjEtOGNhNDQ5M2YwZWQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEutvVznKqDcNfa4Q15/m+QCxpiwT/zzLchwcOuNE5GsnJSGUUxDq3k0xfiQQf\nsPxNhSRcouHdi8tU+O2g7lopRqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3+CtQsZWHVJQ7BOIBAK+Rl9tUycwHwYDVR0j\nBBgwFoAU0SAeORQki3rEG+iHuRGZObcnHtkwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDPL802zdNcSsAs8gHhuQpByUg4TX58MbK6ea5PoKNluwIgZXhNc2Yf\noBoybtl2enyDK9b5TTB/Uj/yWKsRtLjzYqM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXpLCfzkLeZZWUoY017PfWCqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWQ2YWVkMS1mNGY1LTQ0ZTUtYWY2YS04Mjc5MDE4MDc2NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaO2GlfFblL5/D7o9sPFdw6bpN5GQ4U6ESU/ubyav5apJ8\n+wsGIbt6twZsVjf8ixvKzUQuiNZ4DZ/aivTBIWHEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0SAeORQki3rEG+iHuRGZObcn\nHtkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOQlUlyjZHuuDTVQszyZCljv2TKDW3AI1kqPEgEv8jxBAiEA7IB2sH75\nqg/rf7HsGwF/wtIFNpahL6gyviZRy7NSkFY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAWI8Xl+NYWyxTd8Fw6FaLKraMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRkMWJkYjEtZTJmOS00NTZmLTk5YjEtOGNhNDQ5M2YwZWQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MDMzNDNmOC1iNDgz\nLTRjNGUtYTQ5ZC04MTA4ZGI5NjVkMDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATPuj+qTluwTJDsI6m4v9LeteI5KIStlz221kkhoDD40Z0FWM4kpoI/Oh9j52u9\njtwo8nqh8yrH6rV+RwZ2bujCo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTf4K1CxlYdUlDs\nE4gEAr5GX21TJzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiABosZjKrXhj+z0/HVFIe4uDwoaNb2o7WJf70DxHubUJAIhAJ5VIkOw\nIpXtObpms1Kulr/V/0zEL+xuXakA76XwJb0y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7600", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7600` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAWCSQRfIQSaSVPVAgj2uagaDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5MWM0OTkwLTcyYjYtNDRkOC1hY2I3LWQ5MWIyZWMwNzgxZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU3NmQ4YjgtNzM5\nMy00NGRjLThhYzgtNzFmZTIzNzBhMGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwWpHVHnOWgQ/PZEnHih6wY3rtRud7KWDE+RtQlNpM3dg4zFY7E3bVzrDKNxf\n29S+vi+hhLyzTftLDKSubqn2XKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPhbair/nV1a5UX2nWPkIF21NKwswHwYDVR0j\nBBgwFoAU7Mlb/FF2WChqG3xJfWwP90Usv0UwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIDEyG+P3isS/y5vg79u47GGckh7HR9DUGnkUzpFefd7fAiBuhR8m4KamhNaDxohM\nIjxTU+C4dIxhOPaQNz5+7Uhj6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT5s4VdFksdHGIOvz5rNOh5hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTFjNDk5MC03MmI2LTQ0ZDgtYWNiNy1kOTFiMmVjMDc4MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGncf/pjd3/2rRLsd+2KKmu7m+/o2D80fmwcRHQC8bauss\nIZHVS9NrajpKFujrnkpEz6Xqf6DKEpdnaRNZ94Cbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Mlb/FF2WChqG3xJfWwP90Us\nv0UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL/FTxEsfCtnW15RW9pDd/z/zcwxRaCS/IYbpnhTNcngAiAdnQM2QIMw\nwvDmOstW3BHcRWXkMg6OlvSkZVmWlG8JGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAVAJB9bRGgCPQcLM2bbeLpGyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU3NmQ4YjgtNzM5My00NGRjLThhYzgtNzFmZTIzNzBhMGU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMmJlYWFkNi1jNDQ4\nLTRjOGItYTMyYi0yOTY2ZmMzZmU2ZDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQqkaVHV1iht+kpm4Rh+p9RN3SqE7mtgtcd1CC/XoEScq2VVdvGwmNgrRkBxCm8\nYPzXCFV5exRdxpm/klN0i26/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ+FtqKv+dXVrlR\nfadY+QgXbU0rCzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEA0uB7AduuFsIBHtYm6idEH3Elt42VkvtEaiqnE7Vf4CECIBiN8uWe\nuHUgke7S1YdZDcp4B6xZe1vHfc0QPY+sIwx0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7601", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7601` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAQrRE87gVTDM6BdaXdThC5HBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhYmY5NTRhLTQ1NjgtNDA2ZC05MTZmLTU1NmE3N2ExOWIwMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU0ZDViYzMtMDc4\nZi00MDkzLTljNjAtZjI3Mzc3ZmUxNGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfBTiRBRLtMdUE7COxBV7bYYQhTVCGyb0IuPo74DOI4bCYOVe5KUiCpcZGmPD\nbMvBX2WVafLg9emfTckkqtnW8KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg/MALECTrkvA6kI/wZQBbFo4EP0wHwYDVR0j\nBBgwFoAUUVx7T4KttFe+GuaKmKai/mVdiNowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDn2DCQ2xIFFIhjEZACndSJS3/0ztaW9LRLrqsw+kJrwwIh\nAIy6ty1ChoDgpgJc255879A/jbLkGc7Md03I5xEoW235\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATYqeOwj3M59+CVlnwzI7ZpuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWJmOTU0YS00NTY4LTQwNmQtOTE2Zi01NTZhNzdhMTliMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBMUW8qN8y7x29e+KLEh3mmJqBI1bJp6ASBxC9JGOUfNjs\nUqCXBYV6+z3G75kPv75k3oQu1ifwLKm+FPWU9DrSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUVx7T4KttFe+GuaKmKai/mVd\niNowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYk9adls9LJYIFNNvqYs59aidjUYvdR5BBtkoKZjubk0CIBG6/vKvddjP\nmqvZGJK3BlGDQ+U9H6TD1RGcKxb0MADL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAQ4rijuoZbdhoNdMBNdyTgpkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU0ZDViYzMtMDc4Zi00MDkzLTljNjAtZjI3Mzc3ZmUxNGUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NzYwMGI2Mi0zYWEz\nLTQ1ZjctYjY2MS03NjYxNjQ0NzBmMTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS0zEva4LmFrmhJsghIwZLdw3xLGqnY/rrXMFIEVj7SNCx8/AbqIzEsoB3VI+LC\niItQ8NqKCT+XSafIfssitniPo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSD8wAsQJOuS8Dq\nQj/BlAFsWjgQ/TAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA6kR+AgCsYTWYrJdy+6Zag9T9fKVBFUY8pvM5KTtSMJACIQDsq8LP\nfplZ/waiXfwiOhxGRfTKUPuTu0CNZjhRQh4jBQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7602", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7602` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYwL3ePmXZWxu8+Zpk87Ud/FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxM2I4NDhmLTExMTctNGZmZi04NWNmLTA2ZWFmZTkxZGZiNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFmMmRhOTgtMWQ2\nZi00ZDdhLTgyOTQtNzU5M2ZiOTI0ODc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF2m2EkdHTGYv7+z11AeAhpFyJxJ//t3yKI/rM6fQkQhlJ/hmTJmM2BOBlxwf\nGB5VoSHZA4TTrnWgsbl2gmGE4KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFefBtl/iM+aMGNH0iUFttFNsEwMwHwYDVR0j\nBBgwFoAULlPmOKZHvO8FdDjIc67fH4L2rGowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCGsw0r5WSVCgV5PWRSmEXLCAj9eSJNXI5wFPFfwajuAwIg\necGnTAnrQjvTNuym+RBPyBY73R+6H2VqFQ820xE1zsk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUVj4YfOhu0c0/YiwaI9V19sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTNiODQ4Zi0xMTE3LTRmZmYtODVjZi0wNmVhZmU5MWRmYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpyDIHkPTaK54q71JKdOYs/CF42GOhsyr28p6aMtEpplcQ\nAT9DOJrA2bCHciiszaIdfa0/Hh2WUEuYXVE1urIpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULlPmOKZHvO8FdDjIc67fH4L2\nrGowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLrkREsZhZuObj7SIVtMlt5FQdq2sEZeoeT1gZRVLhB4CID4eCkK/cSBm\nmAl2C7d9D2PUR+6fgTQ34eqHpkIV+8sM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISATJfLc6b5Tl58veU9uAKOiFnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFmMmRhOTgtMWQ2Zi00ZDdhLTgyOTQtNzU5M2ZiOTI0ODc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MjRhMWU5NC02MmQz\nLTRmMWUtYTEyNi1lYmEyZTNkOGUxN2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQzzgRb4F2/7xq5R8xALCZvt+bSxztPYWCY/c54ZWYpbjNN0erkdCV+5BbtKBkI\ngrKVbJ/i53G3rno7KcyVwqEMo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQV58G2X+Iz5owY\n0fSJQW20U2wTAzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBvfcdjtpRA0Ihmuk0f3zY+309YbajWMThBUNJLt6PT4AIhAM71iUJB\nqvSWgOBofb9RdVhCeBGI6n3NkDf2K3EteStb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7603", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7603` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWokaDl42oR7UDDKzxvONxlsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0YzE5ZTA0LWFhOTctNGJmYS1hNzdiLWI4OTMzMjk1NDNhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGY0OTg1ZTgtYzRm\nMi00ZTYyLWFkODgtYzZhMTUwYTE5ZmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/VbVfRakP26TAFDwMY6u5DbQeANBzMFe73zz8kakREjf2mnSVH2fe3B5Eb1P\nLOnseSol/3jbrav2aBqkVmvsTqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+5uHSWKfmLmUGAPnyRnvsntr1EwHwYDVR0j\nBBgwFoAUWBvf0CfEJgbx66pVwi4DmeUHgfowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC3uDqSASNT\nf48BsYMk3cO95MaTnwHQvhQKvnXGyvnOpAIgZjbDxuXj3zfVuHRY4WqDbAentOyS\nZlRkRsIuL2sBkfg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARbO6hfOkLkyOoldouGAh7zUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGMxOWUwNC1hYTk3LTRiZmEtYTc3Yi1iODkzMzI5NTQzYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/DJDFimHLmkoLYpbTO6gXKjVo5fun9Eol1imKpHGJDLb4\n8t/+D2bJJtFqV1jW6amJi+tUKCulRp+QzZBqEZpRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWBvf0CfEJgbx66pVwi4DmeUH\ngfowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIlcjzPtU2EFHIPIQMB2uZ3Nx6k8sUVWecv3GxE+/NmVAiAiuzbKjeBm\nbr5MgRNb8fb7rv4l948O26eztPecylPbiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAXb+pIq6U2B8kd6rz4gjSSpGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGY0OTg1ZTgtYzRmMi00ZTYyLWFkODgtYzZhMTUwYTE5ZmFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZTk2MjNiMi04OTEx\nLTQ4ZDQtODMyYS04NDBjYmI4ZTI0NjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARfvHMEMPCpubTBUgydSCXZ4FhBBM5CB6d9XW1Sn0J7Jz+EeKg+QhjcLAqdhiQs\nUcD+FTK9sBLWFXrM9i+fLSyzo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSX7m4dJYp+YuZQ\nYA+fJGe+ye2vUTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiADlzaG+rQ6HyFLwnfGjYDpIQYOFI5O0dGsrV8fa4NB1wIhAN3ReI9D\n8djobtvZ5VupEbBWPKUce2hrenIG9MJzxkL+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7604", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7604` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISARi2tweDMOA/4HzbGyqlR6VTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxMTdjN2YyLTQxODEtNDgzZS05Njc0LWQ5ODExNGYyNjFjNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVjNTQ0MGMtMzAw\nZS00YmRmLWJkNjUtYTM0N2IzZTk3Y2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEktmn5IXyYJ2lvFz7T+eLw0DzWUe8Lnu9PhcQiPZfaXogEwqVQfaGJxvtBSzN\nx/fBNLdL7qcIaj3b3dn3SeTpoKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFvSsjNhwAyzhi8mGUH8+GcXMLFowHwYDVR0j\nBBgwFoAU/YN28n28iuJSqxL8PTRPpSEEu9cwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgXSgTkqZf4PPLpbr0Va6nCjtDehgJSy/yTXXzU8FvDfsCIFYmQe+eep3W\nHy9YAgMizbqmXflbizxmL51eP9RK++9C\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYsr36bglaop01b/RKKr2KSXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTE3YzdmMi00MTgxLTQ4M2UtOTY3NC1kOTgxMTRmMjYxYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASz6utESdvWnTbe5MXz/IYJ4raaL0t1h41OubKkYbeU9ow1\nUTcNbhjarVN3GNjwyb955YQUmZN6/6HzySkIYaTJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/YN28n28iuJSqxL8PTRPpSEE\nu9cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIEs9u/e+s2YhA4+R+Tn6TW6JgWbyPjgdiEkPdsa7yy4AiEAoJRgBXBt\nSZOsZ/nhiUQgbOId7c+Q2etfGLeDF/xWxPc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISASh+g5VLX5sn3WHlzcZ5q05hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVjNTQ0MGMtMzAwZS00YmRmLWJkNjUtYTM0N2IzZTk3Y2E1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNDk0Y2E4OS03MGM1\nLTRlYmEtYWRmZi04MDczOWYzNzk2MDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ1mTETI0NeT6pSFR1bDMXyP14nKEIvxZpwKB2nHwQfjOgWOBrWizf+etqDAOm6\nqukcHOMGXq3zBXc0uV+fWiyyo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQW9KyM2HADLOGL\nyYZQfz4ZxcwsWjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA+z9x8ulUBIRuPWzG8dkC09oKBGSL80qN7bHGYcAVR0YCIQDIL48U\nnziXKcn6SmRhfw21A/T4sGnYqgHNEp9RD2BloA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7605", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7605` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZD1N78rtMiIC5n4PaR+gKpVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhOWUwMmU3LWE2MTAtNGUwYi04Njk1LTRlNzZhYzMyOTI3YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAxMmE5ZDMtOTk4\nYy00MTM5LTg3OTMtZjdmOGYwNDM4ZGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4TRpEs8QWK3flYnLRytiW//bm3SbnQb45hRXHXbSYQXhUMViNSI4Ka99lYRa\n1zoggevKghptS1Xthws2ZKS9v6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0CizhtoXGrQRswtUoCiEGu8U2X8wHwYDVR0j\nBBgwFoAUtPB77DB2miQXg6EaeLORIqHFDq8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgc0BvpHohaqa6efGb7p2rW/2usSoTzzgFM4eBNtXpzMwCIQDvsWD3w7Ki\n9cOHFL623NoPPuJRuerJZuwtAQs6jRfy8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAez9rFo+HVgs6IDOR+ZRFsVZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTllMDJlNy1hNjEwLTRlMGItODY5NS00ZTc2YWMzMjkyN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCpc5gfHHtTVjoUmLiPKkS0P6xFnKMnPnqFVgxKT0+buQd\nuaq7GHaMANluB6Jn76376ai1s0SAiAONQv0Y/k++o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtPB77DB2miQXg6EaeLORIqHF\nDq8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMlKh6rVXCB91o67ldvDm1mu6/zKxunGWCQn9tnbquCTAiEAp2htdHKM\nVsmjvZbc/NCakDSzDKv6Zj/OfGKy/565ncE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAWMHr2mNjpUBYpgvI7ZiP/BQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAxMmE5ZDMtOTk4Yy00MTM5LTg3OTMtZjdmOGYwNDM4ZGIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZDdiZWU0My02NmNl\nLTRmMzUtODYxNi02NzNhNDM0YzFjY2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATuo0ZzoksIOg4cdJjWdSBihlv3ejI3qrkyN3mOhGogg8ZuxdYyWd/EpSIo3JTb\n0aa0QrCWqvOz3EuqpeLFXw6fo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQKLOG2hcatBGz\nC1SgKIQa7xTZfzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiAo5DnOkm7Pw3F4n0L+Apo19FiqJzH5YcX7q2n4OchELAIgeeR+PgvC\nz4ss9dmPpmdhVpRhKW28WIzJlK4FhY7UuAQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7606", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7606` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAe+CwHcFMJeXe1XU2jRwGWoOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5MmZkYTZiLTcyMDQtNDJhYS04YjQxLTBmOGI1ZDMwNDg2NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2YzM2E2ZTctODE5\nYi00OTY3LWJjYjQtNGNjM2UxZmYwNTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECTk+JMuG9tNEcZw2P6qtfdpWS/ZuZSPx5FhOcDXoz1bSOrPwDkqd4u2EyJB1\nYBoiKGi+jGxSDxG1KoUMpNYWuqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzOWStXo500Ke5f/fygcsEH5Q0o0wHwYDVR0j\nBBgwFoAUudxzM0bGr00lq3r4mqhnGdPrIp0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIG+Him5IFkzZDCoTHyEfZqGPH4pyXzbwFku/c4pa3fl8AiBXuEy6UD/D\nI6/TAsL7P2vXs031vkymE0Ozt3B+W7s89A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAblOB5VJsBIlzXsvqyp9dUXXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTJmZGE2Yi03MjA0LTQyYWEtOGI0MS0wZjhiNWQzMDQ4NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkPp2Et30KFFTO1Y6C02wwRs0KKd9WMbQPQFNdRfFcnKut\nUlL1Nr5l/nepOX7iN9jOUY2NWqnDibg6eg+IiZQCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUudxzM0bGr00lq3r4mqhnGdPr\nIp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNBpYWN0E7R8aG2J3oI1fbfhvZGO4DHb1IzMoRu+XkXcCIA3RbQVrKgzX\n+reGeY8lO1oLR0JCKc294RwYUsLBrEmR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAZfw6N2hop29kofM33ixOjGkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2YzM2E2ZTctODE5Yi00OTY3LWJjYjQtNGNjM2UxZmYwNTBjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZjkxYjk2MS01NjAw\nLTQxNDUtYmRmZi03ZGEyMzAyYzA2ZjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS0kUUfruIStIPjrxy0ImyGWyWydnT5VQ4H/44Vdhzf4t9zpWh9KmmSBOu7hvCy\n0VIF/DNtFqXI3HytrQDVf5Oto3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTM5ZK1ejnTQp7l\n/9/KBywQflDSjTAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiB4tck9e4e41IaqqRvGCmbFrt1jV0NA8w/Yt2k0ikH2RQIgNjz/onF3\n4B+A7LeN+Lk6KrY4MDERBRhv3TNvojjUYrA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7607", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7607` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAXyVmknV29MsTCuGtvVDSUQVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhMWI1YWQ3LTAxMDgtNDEzOC04ZmY1LTUxODgwMzg2MzRhOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmYxODBiNDEtNjNl\nMS00OWJmLWExMGUtMzkyN2IzY2M2N2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH1MHFv3VrYzQ0Sk3hkOmvnYWfsfcCVQmsUCm+aPzcoVdwBlWVajYeTsd/T0j\nYwlTtEOyss0A/FBEvHfwWyBz9KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGh+2QnYD1g4FSl3ewzJ6rT/haRYwHwYDVR0j\nBBgwFoAUFmzAop7gTyrdbHBoTyAgKLu7hLwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIFs00jDLdYLSGVDEoxuNr30JsFAOrU5490wxHHcV\n+BqJAiEA7/5aoDDzEcKhiVU05IRiiO9fOXGLOtznltpYNns2R6M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdREL24QZWjtkRdHrXW7zCUDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTFiNWFkNy0wMTA4LTQxMzgtOGZmNS01MTg4MDM4NjM0YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvHqXqmkbLZvOqBh2Rl5vH+LJeIKmdJzrnjxTtE6VqkiFJ\nwSuWdKHghNq3OTq1fu6aI5NL0qEtCiCrwjIV4ifpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFmzAop7gTyrdbHBoTyAgKLu7\nhLwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAItnP1iaFvDOmbWQlfrOHBSA9WMm3XRjnovmgp4tJijbAiEA6IoDSE+Q\nWLDOexS0fRu+qhDlOC1Tjm6RNmIVOZsM24c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISAUNvQwKNamwH7G9Kg5qSEhHyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmYxODBiNDEtNjNlMS00OWJmLWExMGUtMzkyN2IzY2M2N2IzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMmEyZWJmMy0xNTM5\nLTRjMTAtYWQyZi02ZWFmNTBjMmYzOWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATncRHWFmdci5RZHmhHm1Z70RlrNCeaHFYj2HGZhXK8+w4E2P6qu2VZZfyNsLNS\niTWlxwwL7kZ9tLHMoAaKPqUlo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQaH7ZCdgPWDgVK\nXd7DMnqtP+FpFjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiBc+CKbbXoNMM2mHcyIQ2//Vs98uw980p6qT0L8N7rd+AIgbwREwweX\n88IW76TsHlNjOftSY3LQ9HqjgmrBu83YdP4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7608", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7608` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAVdsnTtYJetkCQU+GaCG8whjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmOTViNWZiLWE4MDgtNDEzZi1hNjM2LTZmYzI4M2YxOWUxYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNhMDM4OGEtOGVk\nOS00NTUyLWE0NmUtMWFiODdlNTVmY2VjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+Q6U3fZBGSjCr5aNZSG3tu03NAVx7pPxuXR9mc7CutQYgQponpsMGkyzmFHu\nJmNdTlEdvnQBPOAMk0TP1Vi3CaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvrd5qQsiJLQa8R0ZWVZJVnXP6ZMwHwYDVR0j\nBBgwFoAU2O0Pq+BDCr74z9t/KK2GyUT5JhwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQD6mfNa4g5Nm0GtTNOeKsfdlz9LlQOE540qqI2Q\nk9kfDAIhALPVOeEpBy+P1ppz1VX0E8ED4e+L0PmYqgcuVJKyjDsu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATQ2nB846wDn7bbQgr6VEMbuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjk1YjVmYi1hODA4LTQxM2YtYTYzNi02ZmMyODNmMTllMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDV7lwBvzLRkjxxQYXYY3pMrRp6IxXzX3nzW4vTOfRathu\nds6IYVFZiWGXK5b964sHi3AMjFPntCRehE7qAuM4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2O0Pq+BDCr74z9t/KK2GyUT5\nJhwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCpkla4MWHfzsvcyDzBR6LideAKd69Du1dv0T66V/NhQCIQCnVq7ywoWP\ntwAAHH0r9yiCdH7WLDvtoYz0cwzJRf2XYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAc2gAwIBAgISARv+/slAJgl4K220MqVckK1CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNhMDM4OGEtOGVkOS00NTUyLWE0NmUtMWFiODdlNTVmY2VjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMzg1YjRmMy00OTkw\nLTQxOTUtYWJmMi0xNmQ3NGJhYjQxNGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATjxcPlEil3fEo12sahBJ0mZjskC4aHoJZro2Y6Q+ElDEmvsLGs5+4omJwTjn3z\n3gT23AqtusJIiMIbenGae4L/o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+t3mpCyIktBrx\nHRlZVklWdc/pkzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNHADBEAiB6ZobKtwIIaAWHHm9jXOnx2IzGVGPzhKeBvdHeNDcCoAIgUkOHKktL\nlt2gbQIbmF9GhGwtYv5UUQToCRIjvR1EQSM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7609", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7609` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAS6NQtbQgYbKIlD/qiaM6PB+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkMWUyOTdiLTgzZmYtNDMwOS04YzVjLWIzYjJlMTRhNzQ2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDVjNTdiZTMtMmYz\nOC00NDUzLTk0MWEtMjhkZmJmMWU4OWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoGeOEngRW7ItPEf1AKc73jQ2PCjOp7SYVXRnFn+CqcGCeojt1pAT2FpkfJCe\nyynt7Fy7O4MHnsK1wIN8ntsnS6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv2aMjQO+DlvLG3tmU60sbQCrATowHwYDVR0j\nBBgwFoAUDbRstra8qhoq9m4Mgv0B0Vq/3B4wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDRhm102p6HVNy5zghLyXe757/cBFfQ9gsULFIn5U65YAIh\nAIXDBIo/3ZMIv3iu2j5vuVhb7yZYrI+N842uZt2WoNq/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfRPZjLt9bx+Q3MyaLR+/wXMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDFlMjk3Yi04M2ZmLTQzMDktOGM1Yy1iM2IyZTE0YTc0NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR425vQXqXiSErlUMfMC7mgHagdRqMftfx+SpJzBVBWdKIg\nzMHc51ih9i+PGFND0m2S+7cDCDj6f51kLJaWGz5zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDbRstra8qhoq9m4Mgv0B0Vq/\n3B4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH98FhiB6H+kljmTemhwOw/jVpwPPS3FB46eDVe57QoQCIGGMGofZZFWe\nbxtoCaTnJv6/waXMxgr5NVBeIcgBH4FZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAdjItNhk7Sld0J9xArFksbVCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDVjNTdiZTMtMmYzOC00NDUzLTk0MWEtMjhkZmJmMWU4OWQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZmI1NTc5OS00ZTUx\nLTQ4ODktOTRmYi1jNWFjOTNlMGM5N2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASqxCxN2iNS5svDd2Osk4rFGl4dc4QWT4RCqHWgNGALuI8nwWVSOdt4TiO+dSXN\n7n1E6lpB7f7IaAbpXBHdbqIyo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS/ZoyNA74OW8sb\ne2ZTrSxtAKsBOjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEA/qc5D8g4jY69DhtXqGckwoqzwXvQfYJGde3q6zR9QpQCIQDRlQ8V\nduR4sF+b1Y8zLxvjugJvv3BvKMNvyKpT/Z5UZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7610", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7610` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAVpbZqYAB6RP0MzKuhCMb8qBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMTY4YTE2LWNkNWItNDNlNy1hYTRlLWJjMWQ2NWY5MDNlODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAxYTQxMDQtMmVm\nZC00Yjg2LWEzZTEtMTFhZmYyMmEwYTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe5FmG/5gAzhUafAAoyUhilg4y2IctNh5XV2axGMN3YmeKvgfSvt7jnQifCwu\nHXnVsl1s+2AHcJCQlpS5+66dpKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+9CE5/OhEzA/UOIWYneUTQWypAEwHwYDVR0j\nBBgwFoAUnvzvvL+Vgn4eiXf1ZqJVGPkmHNIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIAP2pf7/4FDIZmImaAgA2+n3pwc5vq8w\nu+aDM9mnyGy3AiBdL4H9c+eK4zD6XyRRgfNRZvg8XLKJAYG8FnGOZPPUqQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARvkBjUBiPxEy1FHpjvNuZdqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzE2OGExNi1jZDViLTQzZTctYWE0ZS1iYzFkNjVmOTAzZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgIcp6WTzc/DT9A6Ymm/yIoxP4rWMsdQbVtBv9xR2W4GHk\nlZsEDBNo+0VF8fZLD8q0uPL5Br0ducI4OOWFZ6xSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnvzvvL+Vgn4eiXf1ZqJVGPkm\nHNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOHXUjNFqhFJFHbHm3INIvQxVKeu+xnKlSFU4Z38FFLdAiEAxbHRLtj3\not4nMFbE32IBMenmPgna3Of+mV2x56QMvyo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAaVUVnM7cdsCDKhINjWnbxI3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAxYTQxMDQtMmVmZC00Yjg2LWEzZTEtMTFhZmYyMmEwYTlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZGVjMzAxOS1iY2Vh\nLTRhMDgtYWNjNi0wNTBmMDM0ZmMwNDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAROxGwptwsBeWEWPogsfNyQVsjkSPqR7fD1QBzMu/jpywBZqueTRbRbBAMtNyTB\niBjDoS0yEM2MPdbYotlMn+e5o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT70ITn86ETMD9Q\n4hZid5RNBbKkATAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiAjVKVJnrfUo3rTTsBJOfX0ckuz6R3y1PQUkrMcvBsO1AIhAO/Qk62+\n/CV/vnTVkApqvtcmXLM0rWkfb+Roam3I/JtK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7611", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7611` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAR1FOhirb+SoCAmMIN1SiWRRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyY2YwM2RlLTdiM2MtNGZjYi1hMDM1LTMyYjhmYjFiNmQ1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZlYmVjMDQtYmQ4\nMC00NTY0LWI5YTYtMzJhMWU5ZDI2NTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeEDNrGfyO10lo5+nyK4S0AEx3binbfsMwl0BU8G5Yv7vEmcZBkpit5lC6Pxl\nMbZQ5Z73Bg5J/x7Fv/yfiPJ/q6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdj+ry0YuUtU3pwWDmO9gdAKhQKwwHwYDVR0j\nBBgwFoAUB8I62CKcD4kvCsfpS1QThKcNNVswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDVF/H6pUS/bI/4yp6b7UBF6Rxqkg23\nAbPqHdnT+0IujgIgB5/eTrtVBzdQ6hw7dNUbIsfvXi9c+y8pRca4pysejOI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcg1f2T5VLXK3uwTSJjv6BzSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmNmMDNkZS03YjNjLTRmY2ItYTAzNS0zMmI4ZmIxYjZkNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASR5WR7AUjizM4URz2R4aIN9Mk+JVte5kzQJIYuGc72z6fJ\nRNt6aK4rxFImd5gBujplybgKOqryiVaX7Oi6QKEDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB8I62CKcD4kvCsfpS1QThKcN\nNVswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEqO5YNnfhkMBZfbMwfNXm1beDb7kmqdsGfISf/Lz1GICIBpnnj4uLKSU\n3A+EnGfWjozOhJfnV5eX7WPFp1wnPrt+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAVSEPBhdlguyflskYKikUsUjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZlYmVjMDQtYmQ4MC00NTY0LWI5YTYtMzJhMWU5ZDI2NTcyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2N2ZkNGRjZS1mNDQ1\nLTQ3OWQtYTJlYS1jNzU4MTUzY2ZiODIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASMFm6/DUpC/EhDYOKFKLgLUYftEhRKzzc28ySKvdUFEyK938Y0H5Cqu+4LQePC\n2hq127jsWOx1Mi0ATfvRN66Vo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2P6vLRi5S1Ten\nBYOY72B0AqFArDAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBS0DMQd2n43MyW2a6lZ+TPrVPUv2drMcMhss/ZJpRurQIhAIKo4Dgh\npS2Dp5I2FxAknTsZRymz1TYZ5f88PfLLVy84\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7612", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7612` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARwlRma9aD2a89E22dR+dkU9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMDUxYWRmLTYzYWItNDUxMS05ZWExLTViYTQ2NWIwM2E5ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDllMzVjOTAtOTIy\nZC00ZGIwLWI0YzctMjMzNWYzZjIzZjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5cg/NytSxueBEsXntbePNxznNyr3H3NbFaMWBjhTDmKqZej3WqzSXpIUArta\nngYUlQbq162yrwKhO6HlEFzeiaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Q5Ed+ED5cBHgRqcIpSN64EEpUYwHwYDVR0j\nBBgwFoAUf1TxqW9d2YUbuOAt8cScv1GKyHIwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIE+xtEel2kWd\ncScb03GW3dPAtdLyO312RCrQuWNplEQBAiEA/tu4jLOZG5K2Ale+i/L5vyY4tq2F\nTjGjiv0hu5zFuAY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASfeH49Hv+xVfdVvbxDFdx+zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTA1MWFkZi02M2FiLTQ1MTEtOWVhMS01YmE0NjViMDNhOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEwuJDV05QRmKpMgpqpZFCKvHqfvpTNls2PTXwbbqDeVHw\ndG3FI84kITG4exbv40cxZC0b5DFdeWcdJfT5CGkQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf1TxqW9d2YUbuOAt8cScv1GK\nyHIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbFrxOGOH7hx71Wmoxzb2P7aQfdHUJokhGA4jS+HfkKsCIQD1hwIjuBiO\nPMEXETPQU7y9jIbSDv9Ra3Ywe0bPauw/Dw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAekH61zvH5McGIPiCA0776J6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDllMzVjOTAtOTIyZC00ZGIwLWI0YzctMjMzNWYzZjIzZjA4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MDVhMzFkYy03OWUw\nLTQ3NTctYWE2My1jYzJhYjI3Mjg0NWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASFTlMudf2e/6t9rOGT0rLz0T9yGurffsAv0FBFfAJNP5LGEdmO0erMLouAJe9j\nqjG8hgOzvZWBjX65mjUZPA1ro3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1DkR34QPlwEeB\nGpwilI3rgQSlRjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAsO2Jf0XS5mxii5BPz9QEhxaeI4PIscB62BnQ2PPZyxECIQChDZ9w\njGju45Xao5E98qnLgVYsmVM3a2wdka5HXrhodQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7613", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7613` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISATuwRnNOSbJ9D2ohggpTaoywMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1Nzg2NTI4LWY5NjAtNGNhMS1hMTAzLWYwZmJmYzQ5NGY5YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhhZWQ4YzktYzUx\nNy00M2ZkLTgxMDQtZDk0YjNiMjU4ZWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPUTxCDkDdC2SLiA8AWPQdml5TpLwo21dyBmunupF4p2f06E/EOdOqc38Jk6n\nkee0GhmRTyWyu4PU0D9lYH57i6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDxWIkSFcQ/y8tKWA87fgvG2+x9MwHwYDVR0j\nBBgwFoAUfWp8fDtpRFtHluvNRYldmlcS+MkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJhqsKKIUYoxYzEE+CRTnk/mLBIxcQh4Nk3IBj7NI62OAiB22I69COGr\nlz0ZKUeHdzpewFY4cZDBSIetavb/FM72Dg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYBgJK/3TYPO2FuzXeJti4WWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTc4NjUyOC1mOTYwLTRjYTEtYTEwMy1mMGZiZmM0OTRmOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTSqDRLUt/r3PX0hQqjsI27Y4wkwu55FN8kEAUec5y34y0\nQviPwR/TPHoQWkAaT2zDfZ6V/Vlrg8QPU/PgPoJko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfWp8fDtpRFtHluvNRYldmlcS\n+MkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOOfmKmRUV/OX1DkJKaceu9z8RAghsoMXvR4uZe/bWL6AiEAnuFkWgaI\nziigGeyLvbbrJ5NpqYGszXszgM3XfqTje1Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAdIr7HGM1d4dQ69PKD3a4EgyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhhZWQ4YzktYzUxNy00M2ZkLTgxMDQtZDk0YjNiMjU4ZWFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NTM3NmMyNy0xZjk4\nLTQwNjQtOGM4Ny1iNzY4YTlmMWY1ZTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQSK5/aOPuhZ5wazaCmbQ5tC8Ac5XfNXj55Ctu81T94t1QTRJrldnvsIAgQqKFb\ntfUQSd+Reu10HwVWHrOs6GAko3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPFYiRIVxD/Ly0\npYDzt+C8bb7H0zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAzCNFM6YTnCkRLF2HGLc8sUheRVzCwfI72mBHgoSMQr4CIBFFmfc/\nOI2+CS1ua3sH4qEz9ExKc9xcBY0kfKJmI4ql\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7614", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7614` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAU52Nkxq7036WzPHh4BJinxIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjZDkzZjBlLWE2MzEtNDQ4OS04ZDNjLTVlYTZhYzNjNjI2ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRlZWIyZWQtMmQz\nNi00MTNhLWIzZTEtZWY2MDMxYmI2ZWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyzj+eeLtJ1F/jn9kYEmz61kEFtgm3Jb0a71jRX+lwRGlM/kBO+5/G+Au12Rh\nnQGBiExFrBXSfT4W4I2R/BOlRaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeIMzOOwz9XsR5+zxyGi/FOXOcNgwHwYDVR0j\nBBgwFoAUEo4Z6nQdm15YT4iWpO/z+a8zZjQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgbXx4sVou4FJ76UtvDOMacC6TEsTDcVqPSI8h3VcUhhYCIEYvVb2cJnZG\nHPJAy1i4Im8RvK26eysW6xoVtTlLf5pf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATeJJLkDHAQZDcI4L6gYZpvUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2Q5M2YwZS1hNjMxLTQ0ODktOGQzYy01ZWE2YWMzYzYyNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+U6dDDnwke8nwBS4jYJKPmeYgqFVfXd4cKOg8tE/vQOhr\nBWjuFiGkiq+eF/M3A+I2lAJNY96KknqhVXj5uNdFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEo4Z6nQdm15YT4iWpO/z+a8z\nZjQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO/jKLNZrF6URlQ2+Ssjp7d9cHuAfg1PbNV4jLCqryFnAiEAyqV7Yb7+\nG7bnplnIqEwPrkcUcEwdX8uzGKitskmB1GQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAaY0FyDIwBjQbW4mw/NTTqNeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRlZWIyZWQtMmQzNi00MTNhLWIzZTEtZWY2MDMxYmI2ZWZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyN2ZmNjVmYS0yNDYx\nLTQ2YzktYjRmZC1lMTgxZDY4YWQ3ZDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARFo7OHoSVlDbQXO39lYgC5z9gBca1uWaqSWBvNa97UX9C9zYS4Ao482UXDKmJ4\nnn3eRbHXYI3pQ4RPy47twanLo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4gzM47DP1exHn\n7PHIaL8U5c5w2DAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAqYMcBYtReKy7S7phPhaj3Ea+eEMX71U3b+VUXrXNh4gCIAYTK3fo\nnnw8J2sWCeZdcycEC8HdducxjNLpm5jNnG9N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7615", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7615` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAVZCGMSG7OrSM4REnPYSCBGJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNmZkMjhiLWY1MmYtNDI0MC1hYTgxLTNjNmM1MmRkZDJmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZjZWQyMzgtNGY2\nYS00YjJlLWI2Y2EtODc0ZTEwNjUxODM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKTUhDTCioU/LtmaEc3YUjgaej56vzehwY1UK3UN51pNfGKLzFum8hfLh/jit\nal5qkuqa2P2xT2/qwYxdYfmRMaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd/Wl8EvNS25eimCBv9lYW2OFp98wHwYDVR0j\nBBgwFoAUgGIgxJCjONScO28lsINrYeC6BNUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIE5jtRTEhvGsSGBsss+NMcLlMyfLixVyJliDf4Wzp0HBAiAusqjR3e4p\nxDyxgK/b21fOj+KOeXaomFtJZa+6iBfQBw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZzIc8cpMKv9JOxtSGZcX/R+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTZmZDI4Yi1mNTJmLTQyNDAtYWE4MS0zYzZjNTJkZGQyZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQa8px8iBOhf/7o8HEWAHPZKuRw03mwAff4hPIpG07Ath9M\nWxWxBsRd+U2Uj1XijAb+nFMcMWmln712AF90ymBfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgGIgxJCjONScO28lsINrYeC6\nBNUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAImei1EGcCB+u+iadr0Zd5hcmPKLrFCZZo5SbyjrBXSEAiEAiA8dIybY\nm4a7KhUw4Pt6xARKGuVmBlAaExMcFnv1bXU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAWXKRZsZtaFFKj55lNracuDfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZjZWQyMzgtNGY2YS00YjJlLWI2Y2EtODc0ZTEwNjUxODM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMTc4YzBlMy0yYTdk\nLTQyZTgtYTAyNi05OTc2NTY2ZWRiYmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQyhesxQOZw8YA+xSXMiDpL4YWvjfUxtPH7IV+Oqavq7GQVuDWI1Cc1DbuZzjXQ\n3eLsEqgC4UKIJ/WR8Q2l6W+io3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR39aXwS81Lbl6K\nYIG/2VhbY4Wn3zAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBJGSlwHQ6tUnVW7QTuGdpHoCqlniVcKgJI50J9NAg5SwIhAMSti3g8\naMr0zbN8KubelEL0cLV4JV1iQt2qMMWQUsJ7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7616", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7616` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAVxekTkQR+zXloaqx2B6ZXPUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NWIxMTQ4LWIxYjctNDE2MS05YWVjLTgxMWQzM2I1Nzg4NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjU0Mzg3ZjUtOWNl\nNC00ZjE5LWE5Y2YtYWFhODg5MzdmYmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMmCn/sRH8V+XCmoyN4Erhee65zSNVsHlMseZYp2ndJubDBSeRfeIv3at94g4\n5RX09a8dBoKIAvD/+jPd0G05NKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVJMUcSLZ9sq3xMA8QnWQ7UT82NYwHwYDVR0j\nBBgwFoAUBdHgJLeY02XmxiOCRXmYXhxwQbswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDwfa/yUgyHJ4FXNOHczubeFxFPCE0b8jKYNzfV\nHkFJMQIhAK1hlClDpwrcBnAx6D5VU4CYg5eoKzPmTz5Um0MaIf0K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY4EI4ywsZ/TKEnyEirlbNoXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODViMTE0OC1iMWI3LTQxNjEtOWFlYy04MTFkMzNiNTc4ODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfepBWaSkwjh4HQ4V/Te1f9taN7zx+ZK9pWXAoCMh/vh7Q\noTVb4pyNYrfV/QxK3UafB6Lguxx4wjs7uP5Obg8Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBdHgJLeY02XmxiOCRXmYXhxw\nQbswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhix30Cq86fs+KeC/7W3HiWc6paCy2bfigZMP/Fjmc3AiEAnCEeDMs5\nLVZSwAdW0rbOG/kxQFUUPe9okRE7+Zsq8oM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAc2jx7VMoYc9ehVbWiIY7nn9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjU0Mzg3ZjUtOWNlNC00ZjE5LWE5Y2YtYWFhODg5MzdmYmI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNWUyZGYxYS02MmVk\nLTQ1NzQtYTdjNi1kNzY1MmQyZjk2ZDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3M8TSU/vVt1l0ZSsTsX8w6A54GFbNEfcl3z7XN383WIKECl3LFFI2cbo/RD1K\n6vwJZoCz24gbECzAjR2SD2X0o3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRUkxRxItn2yrfE\nwDxCdZDtRPzY1jAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAxQ1sN1BgIv/HvnLkq+PjeM8bYcyUKkRYfN//b3b0b/MCIQDCeh0g\nG4ifysEAvMwWkm+vYfXqqUIn4PKiMUe3sYhLUg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7617", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7617` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZZM2Krlc8E0o4y39ahy/3rZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmODc1MjZjLWU2NmQtNGZmMi04NGEzLTFkMjJjYjlhOWRhZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUxZWFiNGUtNWFl\nZS00NDIxLWFhZTItOTBmM2M1MTZjN2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbJsp/Hy1cZrEdS9FE0CbI9lPVToDPS/t9wFB2AKoGI8P/+y5gk5DsSFr95jq\noqyU4J5ho5+jclCTnKGQmJc+p6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQbvzpOkF7ZjFULBqm87MHpMR+xowHwYDVR0j\nBBgwFoAUZy+C8YC+6tN7Wj5N5oJXPONxx4QwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGo1zK8n+Q0whqFkzdhXCUtoXNdImbd9qSMSoG7Z\n383uAiEA1tf9q92ntD3+wON9m3/SUYWfmsXbUYPHUgXyjnhTp2s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVw5l1/SEJP6OYvI/BOQxiBEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjg3NTI2Yy1lNjZkLTRmZjItODRhMy0xZDIyY2I5YTlkYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRHe2tJ8o+a01q4eL4ClDJPd97ZyXlxU5osu5lD++xG2XW\nyENbeIcWYZnmvlWakS2sL6DLHic2QVJef3T/NOhHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZy+C8YC+6tN7Wj5N5oJXPONx\nx4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK58yVu4gkvXlhHJemDB1ItyV3q+CEad13KG01MQc4k7AiEArELGOPyv\n+52XV+WYYF5NMoUCuWTbKKTP9UPsj/SA1wo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISATploC1yxAjkeFtKXF6ol+o4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUxZWFiNGUtNWFlZS00NDIxLWFhZTItOTBmM2M1MTZjN2I4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMzgwYzJkZS1mYTM5\nLTQ3NDctYTc5My04OTM4NDUzNWUxZTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASeFTHAkA9P6G9TpZ/uIAg5v60BJTmgqM3euVnJxdxgA+YCrm6+lDqOJ9EUoQGF\n91kPQaOPq+LhYkZrT3jpQ1Tpo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBu/Ok6QXtmMVQ\nsGqbzswekxH7GjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAmwukN268zd9+ztRM+LfQhL60zYbAxiyicgm2h8TzI0gCIAX1yg6S\ndXBGbMS71VUpxGNSbrPelb/V4JrG+XPY1WHx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7618", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7618` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISARMUsXKSAru9FwByBr1hQc3UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNTA0NjUxLTI4N2EtNDdkMC1iMTg1LTI2OGViNWM5NWI0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU0ZDgzZDgtYzYz\nMi00OGMwLWE0YWEtMTJkYmZiM2M5MWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDrLO7QmK63ZlfWiBrXkjVulbmd6m2n809xr0tdoRQ1DQFrQCUghEv3Q5QC2c\nzaUowvONpVI+S9rLsnc7vxV7B6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4JcjerHmeorqM/dcQO73vGslrmMwHwYDVR0j\nBBgwFoAUg/1uHh8dcefJgsFzjcmK31cm2ZwwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIAZ0yMWbJ91eKNzKznhwBssG/yqv52eZ4lpy9HIpuHVTAiAI\nhwyQrCr00i9z+6jfwOKHaVkic0Fx0nX0wTgNi5E7mg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZP5axdoYx6G04otU5Nthl6CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTUwNDY1MS0yODdhLTQ3ZDAtYjE4NS0yNjhlYjVjOTViNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATP5BQODBsnfQiMhM9rmqoMxpfFTrBU0lp8g41k72DHlSQB\n9m4Yzh8qFHvYt2FG64IINw5xsxQblEGsyUnxZ1LHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg/1uHh8dcefJgsFzjcmK31cm\n2ZwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIAEmIOu+RN+8CE/xIiLSe9LMytNEP5Wqrf+v7wZraQoAiEAtUEj722L\neq15R2DMx6WAg+x3kIZEclhxFAJzQJxrrQI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc2gAwIBAgISAUUZr5H9mtRmaZqfCbwZxWzZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU0ZDgzZDgtYzYzMi00OGMwLWE0YWEtMTJkYmZiM2M5MWVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNzI1YTc1Ni02ZmRi\nLTQxZTctOGFhYy1jMjQ1NDQyMTgyNDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQBPT4y6Sjf85mSBI/udH8E5dKAt/0DzbBp0/bwEBsaBGFHttKpp8XfCTazc0xA\nOyMbfzohNIR1+ho2BD4anZaOo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTglyN6seZ6iuoz\n91xA7ve8ayWuYzAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNJADBGAiEAgZI8RJlUPrPyuAehNHfpZ/No/gnBjmmt78KmHtBct3QCIQDHVLrI\nehCoGJSB8fCgo5LYP3csQ3whh9wrdVbzYXC8eg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7619", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7619` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAfmDUmDovkie9/rkfm+8JQIUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjY2YzZTQ3LTc4MmItNDI0NC04MmU0LTBjZDRmN2JiMzlmZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY3ZDMxNTEtYWYx\nZC00ZjNiLWFkZDEtZmE0ZTdhMjQ3YWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsL/EQdxqf9UDvKkLoj5f97kC0nn7N+hFA0Y4RjrtKM1JPxNL0dqmmmlMl/z/\nS/7+2xIMp0l2kHyLThanQlXMk6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAoqscWrG86xwEJFpEpTL8u/bSCowHwYDVR0j\nBBgwFoAUn+ctGOACPyWug94Vqf6wjoeRwAswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIFDju6Z+JP3+rnah/Yvs0hhbw0FLPr69\nrAH3CI8OQ8pSAiBRrAF01WQOrW5xxY+kSBnm/qYSCV0oZlxIjuNBjBDXoA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZFUnCDq4BpxAvTbr85XDyDVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2NmM2U0Ny03ODJiLTQyNDQtODJlNC0wY2Q0ZjdiYjM5ZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxjMgLu42FRzEsTYHawiqnUU73R14bmOOd5lBCvDwc5JFJ\nbqYxHxi90EL4roCrcdha0VqE9s7xf10T7t7clrgvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn+ctGOACPyWug94Vqf6wjoeR\nwAswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJzoIid8Tztu6sAfru7tNqyd00bT5HpAkK/xfsuO0IddAiEA/WBUCMYF\nBIMxsrHF5AIpfQZn1asRDVTtHa/XgOfaYBs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISASV6on5BiTPT4zdE6MfKVGCpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY3ZDMxNTEtYWYxZC00ZjNiLWFkZDEtZmE0ZTdhMjQ3YWVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZGU2YjFlMi1mMGZk\nLTQ4ZGYtOWYxOS1hMTE4NmRhYzRjNGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASLTpWk1rdXJ9J/R8b1Hr4VUlNGCCINp7DFhxUVBHkwhIGD8kvA4X+l5GIqatCY\nixPAyuAdz3R9xj667J6ASh+vo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQCiqxxasbzrHAQ\nkWkSlMvy79tIKjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiBglR93npmhcfzTkWrgK+8uyypoEpMzmmiX2ilVnPA7qgIhAO2CuQ3Z\n1098e9MQXKd2AEZ76/5GAolJRm8SLqL/Qn79\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7620", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7620` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAfoobcoSn/WBYXyvfr/AUtQAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0ZTlkZGUxLTQ1YjYtNGRhNS1iYTdiLTYxZmQ2ZmQ1N2RiZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGYyMTljMWItZGZm\nNi00ZWYwLTg5YWQtYWJhMzA1ZjE5NmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErowCg44u1HaYcSyUcZHWH1R3SdOzW99kdtEzxS59XJbBt2B5Fc5rTnzLdWzf\nHy2lmMU15pw2X76naG6niSg8uqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyAVPDckl+bNkfZp6u/4Xwys48EIwHwYDVR0j\nBBgwFoAUaiMDcIoG8xJHI0MXcpAI/y3wu+0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDYSKfr8L0leu3i3f3U5IC3PQSTVJ/a\n74rBGsKt9nSpwgIhAOvtoeZOi44YOz3cJ/ZkCwWusI3Q3VRB/riJBOCNQMu4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWrJQI6SnQDbuaPfcSypTQJAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGU5ZGRlMS00NWI2LTRkYTUtYmE3Yi02MWZkNmZkNTdkYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoVMOt8YCppZ16uTrGb01H5bJ6kdXfcr8XldXjPB9ZcMsP\nAFU94lFjfBWdTaPo100g9/GMN1q9q86EPOtqngoYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaiMDcIoG8xJHI0MXcpAI/y3w\nu+0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPKPqLUphDBsuryQxpSA8ovZ/1JIxhk9kNjKOuNoqHDIAiEA96HUwo0J\nVNhcLED/D45rcfb6cEJgvlAyzr/WIq/GA1c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAVmax/mv/rMCYgIZdI1MgRYvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGYyMTljMWItZGZmNi00ZWYwLTg5YWQtYWJhMzA1ZjE5NmQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzOWU1ZDk0OC02ZWFl\nLTQ2ODQtYWFlNS04NjYzMDI3YjRlZjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASXoq+6N26vkxVqBLnsrAXJjJbT+dik7ReenOg4Lgd9zzyEZ3s9tMF6ddU0q8gJ\n6Udwtom6GrW8HmPX0YbFfElGo3EwbzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIBU8NySX5s2R9\nmnq7/hfDKzjwQjAZBgNVHREEEjAQgg50ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQD\nAgNIADBFAiEAt4oUTzWDy9LxGlAWOb76aALgFowtR4HJQRywxzUdxckCIC7Gd5IC\ng7cIlib/Bh8QF/Cy7l4PzG7VsWEQPYpPaGha\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7621", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7621` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISARLO3xb5SJRdtAYd8aYYptXsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNDY5OWQwLTI0NDgtNDc0NC04NWY2LTkwMDVjZjQ5YWVkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYyODNiOTYtNmI0\nMi00ZjY4LWI2MGItYjA0YTNmZmQwNzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0ZdRAHwaKZ6YckI04sKzU00T4+9Psh8pjcjF6YgrdJpPw5q2taJSCDph2A+7\nB9bf0whmaoHSmHZO8YXIoLf+nKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKSNdqgeRGPK/hZJxkg48+V/WYANMB8GA1UdIwQY\nMBaAFM04+UYLIWGzmEqSfIzGpNJRFOFuMAoGCCqGSM49BAMCA0cAMEQCIHE6htX8\n+CCDkc6e6LYSz0zY3NlKqTzIloWwjD54apHjAiA989AbCoMhUiR01VH+B4HhRVYw\nq9gnG+iVIqZWjhYUbQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYYtLCIjmM94cM58g7j59YntMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDQ2OTlkMC0yNDQ4LTQ3NDQtODVmNi05MDA1Y2Y0OWFlZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARClqQBWLT6grvNyMrOO1CPyLdn8IwSjFMFPT25J4ZhTlHY\nEdvXJT985QZ53zLypfHxgmhDNEUCBvMffXmBf7OEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzTj5RgshYbOYSpJ8jMak0lEU\n4W4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOEd0PqjBBSR8OBW14HDT2TYg8ObrdnQYl3mshPBU5GkAiA3nIAtmhRS\nssPG3E0AQx7AcWBk59MG58pBJVvfy2EPjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYz2IN7OcwT7DuJ9QEQ/nu25MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYyODNiOTYtNmI0Mi00ZjY4LWI2MGItYjA0YTNmZmQwNzBjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NDczNDhmNS04ZWE4\nLTQzZTAtODlhZC0xY2Q3ZGUyYWNjMzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3WmkKTiNPf2GzsypQ0RgniF7aemEHoVyTq00HiZe28m2+4OOb7sz2cvx5chFJ\nXWA1TX/uEIEU/FfTNJtTg37+o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSkjXaoHkRjyv4W\nScZIOPPlf1mADTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAx1sUpDXv6cp+MoluB8N3lcVkwr6dcUmOEgPkNGWZ+asC\nIACQ3p8BHuH2jX9uu2ILaKPicHVmUNmcOlxYmbMRDQp5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7622", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7622` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcI8gAd/VMM297jpRI1n96/GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0ZDU2NjM1LWUxOGItNGRiNy04YTYzLTg0MzcwNjZjNmIxZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZiYTA3NmQtNzRk\nMi00OGM3LTg2NTMtMTIyYTlkNjBjOTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkBsCOw0Ofk1/eS5r08EeJCtStyQvpMVW0rp5Qk3xU9Kd63V+HbXLb6K0w1OV\nBYT8j4S4QhU9es68/zUuRFfhBaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFA6ANNq+wfYD6QvHtJTQ7k1+FTMgMB8GA1UdIwQY\nMBaAFBAY8NxMtufLIVQD+UfeuoyvgURdMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiB3ozvo3sMmQvafDlzDlv2WpsAJw85Q4a11\nakedZz30hAIhANwqOO2F/Q4PofALydYhWOGPUEK8Z3fzsLC8kbtFl7x0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaVF2mgmMm0xUfTb83QZoCo2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGQ1NjYzNS1lMThiLTRkYjctOGE2My04NDM3MDY2YzZiMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvBvEayV5tncSUrHaUs8YSvrWdKco7ZqGsKaHsRNRSbGUe\nMK+eE6U+REo+Io/1RC2hgGNeB/xT/RrQ3TIkF2wKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEBjw3Ey258shVAP5R966jK+B\nRF0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMWDqIPpWn+JNaIAycFgnPbQUcQD/VsxmdXuoGgDsbKACIQC+fvNeHjCp\nk0kk2y6NMsW66lzpnWnEN5sXITm4nj8Lyg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQAHBAKZtGPS8nWzWXSYAPjZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZiYTA3NmQtNzRkMi00OGM3LTg2NTMtMTIyYTlkNjBjOTA2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNzJmYjU0ZS0yMzI2\nLTQ3YjQtOTIwYi01YzVhYTUyMjIwY2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARhYKZRSyCac8isBXvCmvhqVJUIefDRfmS+QTHx38ULBg/pycdQbWczzhLC+URR\n/f370nDwnszlJm2JC+aFKhTSo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQOgDTavsH2A+kL\nx7SU0O5NfhUzIDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiACxcLGMPHxFIfkbFOI9MsTcQrUfSmBwd8i9ts7BucOrQIh\nAIQ2kWvOa4kbMpM1yezXljgFL/jzyP/AvvZXhg1sCNIN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7623", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7623` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbYz/uaUSjGB+J1YbB3oSzUSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlMTZmM2UyLWY0ZDYtNGNlZC1hOWJiLTU4ZTdjNzU0ZWEyZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBlZWM0Y2EtOGNm\nYi00YjQ0LTgzZjktMDQxOGQzZDE0ZWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQHeYWtMDkpvMes+bBxtSPI/OCDFh8zqVl/AGJFRvk6zCVb7VLgi9bc0K2APq\nmQgnrfKGQnNBUNmntxua+DK5y6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBsrEmuueiGSYXclNd9IEmfJU1ewMB8GA1UdIwQY\nMBaAFClWd3vy52L4T6dQs9IOhXIgh9d0MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAwNGZe1PGZZG+KLvUolgKCBVPzyw1DSL8a\n9PjD8l8jPQIhANT1lFMBeKItmazUE7Z0ghj1fWOvknx2rGWBDc4WGBwM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQCx177KQF0dEa/y08nw+X84MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTE2ZjNlMi1mNGQ2LTRjZWQtYTliYi01OGU3Yzc1NGVhMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATE8Ac4YgypQDBOY5bkH5nHz1P6nOoC5PiwVhY9rm6ntL6q\nCTVpOv8m7Y/OBkGefL6MA0AgmNtnVRrRJe9P0vrCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKVZ3e/LnYvhPp1Cz0g6FciCH\n13QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALcdgqc4BurKe4ehr0T1PohIBOeK/x+13HSjyv1wzj25AiBGZcEPFJxs\nDjVTbkXBq/XzmNOrxC0Hmnx8gDYoddoZpA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARd9oKn3SOvb2Ec70FKbRDD4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBlZWM0Y2EtOGNmYi00YjQ0LTgzZjktMDQxOGQzZDE0ZWU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZTczMjYxOS00YzY2\nLTRmMGItOTFjMy0zYTFiYmE0YmQwZWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS+O+O9JSwI6/5t/1o/fOhU4mMSl/pM1jtAZ+8y5Heos20doIqB4YRwESpmRW1G\nJnG27Uf4ruRoz45gDSBAFDP4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQbKxJrrnohkmF3\nJTXfSBJnyVNXsDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA6ojuHWCUZqzh8aVNR0z+U1ttp5fl25DCWqMV5+67VKkC\nICGJwaZomxbz93qX1fk1Mz2itoUeH1vjaJdQ6ICmYGJe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7624", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7624` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAeSPZ63h9ZDjjVVeJ1kZbeGaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMjM0YTZmLWEzZTUtNDA4NC05YzM3LWI2MWIxOTRlMDgyODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU4MjUwNGEtNGJm\nYi00Yzg4LTlhYzgtMWM1ZTExNTQ2MDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe4RVCOAQzOiJXAlTyE92+F2kg5PZkSY0XC7EdK9NWyncTPvAqWCcj+NiUibL\nSZI13udvhIr8AQVlp4wDhIePyqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTgohmyvYYF9DmmmMPOek6Lwrr6yjAfBgNVHSME\nGDAWgBRbZMzcxh96gNXwfjr0uAO1LY7cQTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIF/VHwE9SPEbBMG7LRfB15c2B+8g1o7p\nkm8r8lvUQysGAiEA6ysnAoogBiPv34sAtOs7AfQNZnj4hiAU46ndnLIGc4s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATLSB38hQPE8t3h6ir7KMxv1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjIzNGE2Zi1hM2U1LTQwODQtOWMzNy1iNjFiMTk0ZTA4MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXQm/j2RyC3lqvZ1vxP33TksxJk3+fT3PKaZjpdyemuL+M\nd6MiEQR8J9BnyMY+ECviiuAm+Nd5R2IUN8TLUbUQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW2TM3MYfeoDV8H469LgDtS2O\n3EEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK2ZWPPEvqWLdlMDfoKenCEld8W1m1B5y7fmWl4b/ndAAiBXeoLNEZuR\nGNoIEUm9rlo1EmkJiAuEXzFs8ibxLFwLEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYQg3jvR12f+KHTA98Pp7EwAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU4MjUwNGEtNGJmYi00Yzg4LTlhYzgtMWM1ZTExNTQ2MDdjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMjgzNTE1MC1iMmM2\nLTQ5OTktYjQzOS0wNTA4OTBlYWIyZDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATZdEy4fuk6ypfroUDr0E5LlOVk8e2OtNAWhB7jhx5aPiY+aSxEDFmi6zgjMYHe\nMgW2gXG8med497eNXsN/GiCpo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTgohmyvYYF9Dmm\nmMPOek6Lwrr6yjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA3J5GDRI2mX2fqqPcu4dRg/LmqTJPDUqHfIGyyZUoqoAC\nIDB0YmP5DW7DX3yjy5GeoNNTRgGs55Nls4F8S+6i3sIH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7625", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7625` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQ1H4Nrx29s1A//1YcMdzlAUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxYjgxZGZhLTMwZTAtNDE1My1hNDRhLTYzMjNhMWEzNzJlYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTAyZjNiODEtOWI1\nNC00Y2QwLThiMjYtMzAxZDVmOTVlMjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnZvZA+DFwF6S6xMAIXZIOstPKNNyVsKNy+5d0Sixa826iirNeUqLCIocxtbM\nKkXLjTv6xwQR5MSlPxetMMufiaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbk7iilogh96k838NTvuNuV09HuIwHwYDVR0j\nBBgwFoAUhZbabjl4JuDy/OxVOYeSc7e4I1cwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBR1uQNAUZpO7uC\nEX3lE7XOdvrV4uuWARbaQ8QEjIITAwIhAMalNcL2JFGHGqKwZc3Ivd7huOydgzCy\nTqgtxvNuyyYr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZUs/9l+xFPquzRY/fuBLK3vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWI4MWRmYS0zMGUwLTQxNTMtYTQ0YS02MzIzYTFhMzcyZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXCh4ffyAbLg/66wRRJTfVZfDMiKbHIxgCjyq6SrrBxZr6\n0s5jXCJ9qWBPUxXK1Tcvmsx5kaERdCHweTiWteRlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhZbabjl4JuDy/OxVOYeSc7e4\nI1cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALWg7Nwz14RJrrdrkxED24XId++FveZqE88BvsiPrAwSAiEA07nTWkOf\n9FnJjf1TpUuQ+v3UmbAH+UFInrfO8b/WC6g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASVuSKzvytIDETEYvbYLqKI8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTAyZjNiODEtOWI1NC00Y2QwLThiMjYtMzAxZDVmOTVlMjUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NTViMmZkYi1jZWRk\nLTQ2NzMtOTE4Yi01OTI5YzgzZTA5OWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATAei32NCLjhCfO/E8BqKmtZ9wvaem009oLV1LJQK9vkQISAYvTIl/pnn+9FQNO\nc6FSZpsWpLuW0iDNOMGf55djo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRuTuKKWiCH3qTz\nfw1O+425XT0e4jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA7lF5R6cqU5wZkOqrrwjQa4fL4G2BmEQVv8p3GRnAC28C\nIQCek7NpYHuKQcyXxXjDjgrsuvKMYnGHMA57U1Zrj8GRyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7626", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7626` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARUhDT5+eBKApUn1NVZLuejUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyMDU2NWE2LTQyMTUtNDJjZC1hM2M4LTMzNDJmY2NhM2MzNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjIyYTYwMDktNTNi\nYS00NjQyLTkxOTEtMmY2MzUzMDgxNDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqRu6LicP6ggme++3iEyb7dqxrjDAjc8wWbiWjwYNOut3RTZcfZyf9OxBV6uq\nfCUEETmKKhul/R263qPWuIbQraOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0mqJy5NlozzJs2KVK4d+o54xI88wHwYDVR0j\nBBgwFoAU8tnGhLQlqRY5O9p4dU8NsrF05UUwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBgEjFuVlNWLQbz\nEZ9kgf7OZI8OIMdjC4awu/GS5YfTagIhAOJLysvRk7GAYNTo5PP4suqPziTUmW/E\nGqqyesTo2om0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5eS/FDoPi+Yn31mxmNIDdZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjA1NjVhNi00MjE1LTQyY2QtYTNjOC0zMzQyZmNjYTNjMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRp7yH3plWX7X9tIe1+LvXGJ0HLebb54IVURXy2GB/JDIf\nMDW3Q91sf0qXjATHNt9SeijAHSltnDwwahHtJFEro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8tnGhLQlqRY5O9p4dU8NsrF0\n5UUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANWCRbK9mNBHmHukor7UHD6PCdMHJOG6MYcvnzADLEJyAiAWWWoa0iaC\nhQA788dfOsqgoKCKtUAcP6BOeKJ664P2Ow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAV4Nlkexk7PcjCsLQb4g2ydLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjIyYTYwMDktNTNiYS00NjQyLTkxOTEtMmY2MzUzMDgxNDZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MWM2MjBhMS05N2Fi\nLTQyYTgtOGFmOC1lMjI5ZThkZTY2MTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARQGBwRepyQziZODTbq+p3/3DBPjzKqInYG/SwkxKcN+2AvIpf9FOdjkitfEKjO\n9911tGcEezPz7osvuyaHMXZoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSaonLk2WjPMmz\nYpUrh36jnjEjzzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAmHvje/LnF9vshbxpU/38DHiu24rmYuEQxPJuBdAlOxMC\nICCw/l3CNFT2BZAfVSj7ZrvAr1HjAK6K7cGhF4TV6Yt0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7627", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7627` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAXmmGH2gMHWTzcb87vjF4G9YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MTNmODZkLTFhZGYtNDg5Ny04ZDFlLWY5YzM2YmIxMTc0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThkMjVmMTktZjM0\nMi00ZmE3LTk5ZGEtM2MxZTM2MDRmNGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW59uFn4h8feuAkYogEnVYI53JWWptJ9VeupJl9RgOa84f1myjxgm/P/VV9C/\nyyh6gV08R5Svu3dHDO3PNNE5k6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy5eMaRmU2pS2oful8fPniuGFs0IwHwYDVR0j\nBBgwFoAUlQ55vkOHQljAXj+J2pCwh+XV8UAwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBFUsOry1eJAXgYG40difv7\nfmO824uFHoFMHE4aPNvQogIgLsk3Nwz7OAXTfJsmcuporQNub6hj4YSWUnX8uvCb\nMz4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVBDeRcnC2Q9a/TDDjQVxb+XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODEzZjg2ZC0xYWRmLTQ4OTctOGQxZS1mOWMzNmJiMTE3NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/oDn1sA889HZc7SMKYfkHHx6AfwrFipi7tO8Va2bfCBAA\nVmHfCzWU4z2BrG7ZsOHOnfZUplqTpOtIwWiQIFJZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlQ55vkOHQljAXj+J2pCwh+XV\n8UAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBpwADixgy2g0nQQ8TBmzed5sIWDxXD69bF9wWzer4fcCIQCHh3EAG4Nk\nrNG03ONxPAh8jdL8zkvWVtHsxZQYmrZKOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQustRZneASBMKaLJmVjnkyBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThkMjVmMTktZjM0Mi00ZmE3LTk5ZGEtM2MxZTM2MDRmNGY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NzI5YTY2Ny1mNGMx\nLTQ3ZGUtYTI1My04Mzg2ZDFlNDAwMGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASrmci4pzipVu/yKNEpJRk4ExR06XhbdgSdGwHd5HSXXBG4QE1hKg1oFoQmRcm2\ntqAnXqVBYo5Eh2k0BvEwE99uo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTLl4xpGZTalLah\n+6Xx8+eK4YWzQjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiAw/em0f2hFs8JNEjTcb1VfOtQnIz2mP+MPsqA0sQ8KfAIh\nANZr3s2nlGrD5eTy79+WG7J5per6eu5BRTzrVgmMbTr9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7628", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7628` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAbfYMW6opaZyoLcWWusl6HweMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MGYzZGUxLTlmZWYtNDNiNi05NTk1LTkzZjVmYjI4ZGY5ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRjY2M2N2YtMDc2\nNS00Nzg0LWJkY2UtNzQwNWZlNmVkZjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEVj3QXIETlJ5SxoTuWdYAO5vluYpudf1fa0Yz29wvhKZ9R+0UNkzEpbW1O4f\nFLWfYvx+FnAsX72jGIVqPZngt6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU49KfLyFP3N8fos7SlRVhz9QnB3cwHwYDVR0j\nBBgwFoAUEV82Hg586kwZKOhPbba4m7j/caUwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAxCQq\nIlD0nA/m1jhPDaB/7U71sc/wJ6SarOW38G+QoQICIQDuxP1htF0dBgr9jHDxDqMH\noAN5GbJR1WgGZ57/DP9PFg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUdnEekbyN7MkP+jMqsZRhXGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjBmM2RlMS05ZmVmLTQzYjYtOTU5NS05M2Y1ZmIyOGRmOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVihub4sjYm41GmR+y2LFRjEggbq39Fe3cmH6A4SqHrRL3\nuXNM9WFADb/w6LeUh1hepozgb+BfOTd16NNh7xU0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEV82Hg586kwZKOhPbba4m7j/\ncaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAumd3HCVEm++mC+NZcIkFmRFyWm43PvB2uK8xoV60poCIQDnJpPmFv9E\nepyYGfAyU/6Me/1f8JsFHDAvYJc+rS9YFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISATmT0E1sLksr7e/4XebZLfYbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRjY2M2N2YtMDc2NS00Nzg0LWJkY2UtNzQwNWZlNmVkZjRjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZmY2ZGY1MC03ZDEw\nLTQ0YzctYjMyZi0wMjk3YzVlMzRiNGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASoLI0GuQu2hhQJ7b5JVTPcMZZeu65YJ5WzfDc3I2GgttD1tJa34T6ibSvA7Mve\nUuJNbO1BSK6bbR8qbDK58aUvo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTj0p8vIU/c3x+i\nztKVFWHP1CcHdzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAYUSm2jnX1bboVjH65tSYFthJW+R1Vc3qd0SwbKql3GQIg\nT7ch6iomhIWGdFFDrTp4jH9ikNJjwe83FaucluQ6KqA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7629", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7629` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAYOE7bsbYgwxuZWWriGYWJaxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyZjU5NDczLWU4ZDAtNDFkMy1hZTIwLWZlNGJmZTI3M2M4YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdjMjQ3NTAtZGYw\nNi00ODQ2LTkxODUtZDAwOGYzNTg2Y2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1WMQwG/Tqv99zPqv30Bb0keQErc9Gbv7ZwmOgwoKgw8yOSB1WEgHJTqTnB8P\nUx/hmDgAaYUxZsYUctzw1UgdO6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHBaHM6XWDHUZDCVVt1zSlsE8mncwHwYDVR0j\nBBgwFoAU/put+hpapeMdhR95qjujFJXTW+8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAjNG0\nQRK41zB0XgPAucWgxOXArL1UKnWKUECllQIopEQCIDTeGIhRjbRxB7XNGzNg9M3e\nWXUQjJqKOKLU3yTScg4h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAatx6+npq0layUZ2uBRSfbf2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmY1OTQ3My1lOGQwLTQxZDMtYWUyMC1mZTRiZmUyNzNjOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARF87lW2ezURzu9vhQza+LBHGJ73y8ejA0c/ETuwCqcrm+S\nVPTy4TQGW2Q2yAOeLPFwxkJaWTjg9oQmpXAU/+zMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/put+hpapeMdhR95qjujFJXT\nW+8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANdo/ijklibOPTRV0r/Hbf0yNFiB4zhnY2U8FFSUrnHxAiBmvbxhAQ4F\naB1PLqNd7M7ird8aspYQN1adK0XT4w9+gA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAXnyeXtPRzKuV4x24Fe3Hc2OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdjMjQ3NTAtZGYwNi00ODQ2LTkxODUtZDAwOGYzNTg2Y2I4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiODMxMTQyNy0zOGQy\nLTRiZDEtYTFlOS05YjMwMDIwZWYwNGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATvoyQQuJxslU7+qAKuHdtGWaSyBepEW90MLgpUEWpOG2yV9vcpnuCb+jrT5lxf\nt1yDX+81LhP1hfkF7UUVWmd/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQcFoczpdYMdRkM\nJVW3XNKWwTyadzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAkRDF35sscJUYMIlyVuLtX0IP0irbLXC4UIcSvVHFnCcC\nIQCgcZzTno/GV4SP+rE8xkR9EeOdPtx/VVCqKiFl3lzYlw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7630", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7630` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcSE7OlqLZ/0QnS3/H4/BJHRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ZGQ5YWNkLWFkNDMtNDZiYy05MDkzLWEyZjMyYjhjOGE3NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg2OTRjNzYtZmNk\nZS00OWI2LThjZjQtZTZkNjU0MDUxNzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE97l2YBtkMO33ysqtFTfh+X+ynsWpKgnnoLN6WB31PgOwiD0tECogHfMdjdjj\nuDw5ZptFF0gkNn+VUkhMW/0T2KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFI82ybGFk0NzWZlNpwlfDnJVi1GUMB8GA1UdIwQY\nMBaAFPZrorryBlY16ysnUDRPjilTogoSMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEArZ1GSza2TTDTabn3U++vPE2FJxHnS62d\nG+TtjQM/nDUCIFEDXfIoxDa2mi9VpzM8sIlgl2frZOAKsgKJv2Kb5hP/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb60u6DvaSaUuLt8GHG9MRlfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2RkOWFjZC1hZDQzLTQ2YmMtOTA5My1hMmYzMmI4YzhhNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9L4duM2n9YjUgtQymWJ1Wwp3Qt4Fk4de4rhUcAh+5s143\nwe/UFgb06RdBIh/XkzgwsmpZZ/fzxJQy/3HzQfy2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9muiuvIGVjXrKydQNE+OKVOi\nChIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ5o7/2ZxlkRihoRYCuOqtc8TbU1CGnZ9NtM2yrfsVzUCIQCG5FoOuELG\nMehMvWrD92ZupSMSl1RZf1U84wH3SrlxEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAauIt1CdObyeMdIXQ7C4b0L2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg2OTRjNzYtZmNkZS00OWI2LThjZjQtZTZkNjU0MDUxNzBlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZDJmN2Y0MS1iMjlj\nLTRmNzAtODE3ZC0yNWYwMTA3ZjEzMzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARzA+9i/ypKQ2L/11rFR7ol1OfC+xuSpWyLjx8a3CnJm3gbFmv2BxKWDUrucoFv\nsopz1ZmelCkOPjxMky58ZvPPo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPNsmxhZNDc1mZ\nTacJXw5yVYtRlDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBZWkN2pbKOOmu7raY+v9zP/M8rAzK2dggf57UBZ0T1VQIh\nANQfRO2wDlFpB7kRLBX0lAeHmzfvGliGrsrmKBSGFNeq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7631", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7631` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAcvUPJCrSUBVjtZScfkmcTaTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MDBhZTRmLWM2N2QtNDQ1ZC05MWUwLWVjYThjNzU3N2FhZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I3YmNiYzgtNzQw\nNi00Y2MyLWI0OTYtNGUxMDBkYTU1YWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE36zdt2iVRZJ6TaMSHl0HKoDNSGiY/PmHWY/xvT90rx7pSZXA4lDQMr+TDJHR\nKowRB1rd3wGDyvxbss1V6A1/g6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4hf3EncthDSKkqAo1EM8ZVRUMB8wHwYDVR0j\nBBgwFoAUIDgdZjn3UQYlwmNxhA3HYPnbOtkwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgCD7K3UaaB44c\nmTWtz97z2fMRChRVHKIGi+wAWVLdPo0CIEZiNcGQrZrtsGFzCHSDAvE0QKJFqidU\nrGHlxMcqkG2T\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAarCjQ3IkIK3gpyTM8Mu5Vn3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjAwYWU0Zi1jNjdkLTQ0NWQtOTFlMC1lY2E4Yzc1NzdhYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjIW4avV4vuX/4j+JPBaoJw4pIJLjvI8bPOqtTVqeL7lj3\nM6hZw/W90o9eEDyw41XHYB/wSzRI5HiUUkG5oIfyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIDgdZjn3UQYlwmNxhA3HYPnb\nOtkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWa0eVddwqOadLSzvcnz58AZYDZmn1x3c3IGlFwzgjX8CIQDlbhI68ZTM\nvtIYlYDmE3ClfS2TBZsQOKUYpttxAgGKkA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATc8DKxe7YMBtbuJlzfyvsyzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I3YmNiYzgtNzQwNi00Y2MyLWI0OTYtNGUxMDBkYTU1YWY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYTc1M2U4MS0zN2Ey\nLTRhN2EtOGJlNC0wZjFjZmFiYjQ2MmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASPE6IldjYhmiX7YRGQYQx/8voThAIY3teiccP5dGXhVre9OfTcfM2DgBHgioV9\nRVM6r45WRiqVk8mBhOVkOetfo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTiF/cSdy2ENIqS\noCjUQzxlVFQwHzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAxgOWQ5R+ZBJc1t0OyOeOZRZ/OYxOQYLCPyqzppCX7OYC\nIQDVAHCGxWQZdXsdvJvJhLIdzdwg+m0hKZ3CBuvSZqzx7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7632", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7632` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAaKYs/h6U07LD3B1JaUaqSI/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2M2U4ODUwLTU0NGUtNDk0ZC04NTJkLTJkOTNmMjZiZDE5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTczZGFkMDktZjM0\nZS00YWNlLTg3YzQtZmE0NWI4NmY5ZGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENg49fhTUjTf2t7RKt+NpP05Cso0mkoTx+/HqsRM5U71rh5ygrtINl1PKg2lN\ncHrdnojboe8FR2fIKYiNRcrqu6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURWYtQWZ/DbvaIh4ydX8w2Gc2DoswHwYDVR0j\nBBgwFoAUmXtkE2+kZT9x1UFW0Bjd0C4/qvowKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAOg2/qmBsDCF\n9zvaA/hBOKEYA18U574wiWRQbCrFE5V4AiEAjuTIYNN4T2ZadkesiJD9yHreFmeq\nxPDQvD2OLRbhP/g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT1LfVj61lZ/P+bjPL2ulF+uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjNlODg1MC01NDRlLTQ5NGQtODUyZC0yZDkzZjI2YmQxOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsMNaFJdXwM7f40NZd3xyXbSOYL6AfQb0luS/hn1t0FiOc\nxz1Oj3cweyuz9OTkNUJOqX/KwG0M3VVBnXYAD9olo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmXtkE2+kZT9x1UFW0Bjd0C4/\nqvowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIFs+RLfUSGJ4Olegg6Zg1dG3HLiYOpmYr6E6RmNEz+sCIQDrx0NMCc8u\nz58nfJ0lIz3p+Etc+8MVS9viFWVU3ikBhg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAQu6Od6e292RgzQmHc7M9UynMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTczZGFkMDktZjM0ZS00YWNlLTg3YzQtZmE0NWI4NmY5ZGFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMGZlYzhkYS05Mzcx\nLTQ5MWMtYmYwNS04YjYyMDYzNjYzZTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQZVVaYZak65Lc7QV3ITVg03FOzQSCSCdCUyy6WqEwHY+hrXZKKiFVJdvi22VCa\nPzQ2QjQSVlmBuVKlL9iEyWIGo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFZi1BZn8Nu9oi\nHjJ1fzDYZzYOizAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiArY6ftcxg5SoMpBZVq+4m0B6U2CDGlZzI2VYgNX865zwIg\nIIL6HeyO0MNTkHf0/1vIWDZEmbqgYPDP5qn+VtaPnCg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7633", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7633` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAcaYgnD8AwsrAjkkntkKvXR+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkNDMxNGQ5LTU3NmEtNGYzNS1iYjA0LTE4NDk0ZGM2N2ZlNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFkNWIyZWMtZjM3\nYy00MDliLWI5NTMtZTdlNjhhYzBjNDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBX63wX8hk+yRtttywicOqqrVU46eAySKIOOYz5aY0WSI1fGcme16iRCs8MgA\nOI93dqJC5lRqaa4l/tYPAoEVMqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlurAiz22bekUg3P0JHnMY69C0NAwHwYDVR0j\nBBgwFoAUltLD6dpFiCaHWlTAs+GKxI4FTHEwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCMnPC+e1Jb\nGIoleZEsM+hTAIijGZsWzWBRzZpgoKHxJAIhAPLRyK2pN4ddS01WeyXM7j4RFOnJ\nyKLZEO51FE2P9uNt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT2zkNHLEVTGEvZJKSePXYLSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDQzMTRkOS01NzZhLTRmMzUtYmIwNC0xODQ5NGRjNjdmZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOSLyENGPcYUW4tGQ3yaBPMu9SgUzC/HcwTfo9uUY+T1Zv\nsoCanok09Teuo0p91m8dpggTFVbC6i959Xdj2RDVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUltLD6dpFiCaHWlTAs+GKxI4F\nTHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKA15alL3K+F94revhIeiy6PfHPk9dZgD2imInZbCGhsAiEAs8K5TWHr\nKl3h1zmEjYZUzTiKFT4CbZllFIrp4hYBys4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAXNdRlAyMZpQ4M59PUCeS7m4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFkNWIyZWMtZjM3Yy00MDliLWI5NTMtZTdlNjhhYzBjNDZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNWI5NzYzMi1lOTYz\nLTQzNjItODkwMC1iM2ZhMDc5Y2M1NzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQvISL6w3jbig3JNeh58BIBMx2RKS1mrK0un6C7n2L8ikZqOkhZG5zIJ/rTTlqv\n+naXe8c0F4pwFyCKjM04CkXao3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSW6sCLPbZt6RSD\nc/Qkecxjr0LQ0DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiA5OsVtLd+gR4UznUNOyUry/KtCwtwyC6WGJ41B7WAyqgIg\nNhwkuj2AVfpe57dcfk+egiNdbyhnnAVf4ycvjKiad6I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7634", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7634` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAe14Jw8qJ5C0qjiHYANYtLNDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4NWU1OTM0LTRhZGMtNDExZS1iZjM0LWM2MmFmMjI5Mjc1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgwNWMzNTAtZTU3\nNS00MTAyLTk1Y2ItNTQxNTYxZGVmODc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEttPOMf4MHwjQGqPWRj6vDKerMrAAx0SWHuKDLXJXckS/0PCGCsxg6v569dgf\nsq84nyKr2kdepTf8kWYfOzrCvqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdOhMW+w3ro3eFU0wKNoCe1pRQ48wHwYDVR0j\nBBgwFoAU/ZdNGF5rhgYJay+XGBxrWf+/XUYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD41v+T15LqhF3yAnBB1xto7HzRZ1qcBwrh3mmm0U56AAIgJot8ph/Hiwt4\nTkB4EPh6j7cf0qOeQE9mG5vokEkjW1k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU/tM61KCMktrubk6pryBGPjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODVlNTkzNC00YWRjLTQxMWUtYmYzNC1jNjJhZjIyOTI3NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReIMxa2xvzmUOgjP9oXU3LnHCYLAbnFg73x76N60P6lotH\nvVT99sNZxCX/pDx4Xc0N7CyP+gpkstE5g29WOS7Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/ZdNGF5rhgYJay+XGBxrWf+/\nXUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI6j9C7Zb92ea1in6G1E17o/6SXc5xPvR9StZP7tVmX/AiEAhlJBvLJ5\njATEiH6LXq8lweF1MhTg4+5Kl0gQwub8qOg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbJHm9y2mwRV1daRuyN4wQHEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgwNWMzNTAtZTU3NS00MTAyLTk1Y2ItNTQxNTYxZGVmODc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNTQwMWM0YS0xZDBi\nLTRjZjYtYWJlMy1lMTVmYTllNTNmMDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATSWv/pVvN9Up5bT+49ELsPBE/kY4heHE7GqZMsj5EFW6NvHV3/4xnoEkYEnwFY\n/tI/izYgC0uG/fERg3qxGeaQo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR06Exb7Deujd4V\nTTAo2gJ7WlFDjzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiB1UmSSX1ROhz4FJ0BkwHbm4YADy1UhWlR/GarOQlG/ZgIh\nAN0g4Xqmuuwhn/8ZqVEsCivfq8rKDrwYQ2//lcxAAg4/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7635", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7635` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZxY0azDDWipkwul6rKT5GQXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1ZTQzZjhjLWY4YTUtNDUxMS05MDViLWI0MDg5NjkyNGQzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU5ZWQ0ZjUtYzJh\nYy00MGJhLTk5ZjgtODNhZjI2ZjE4NmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEibv7uAsD+J6eajM8Bbpzs4LWH6FGt54CWvqD+TrlS6uqD1I8mb52eEWW7E0W\nqJythDxi1TG0lKfG6qLY6PTNqKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaqVNvkHCWhYErACDJUUze9M6mUAwHwYDVR0j\nBBgwFoAU3QJL6AGpioYwgxLk4rN70Jfm8KowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCbqWmTs7htPXOU2vly7JJWAQdbkaNHU/i3bHQU0yOfagIgb+rBy18J4Ky/\n6ucLMam0TGJXIb8ss2TYj+T/NReqvfQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXBSNolAquqt8EO30fHhRbLOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNWU0M2Y4Yy1mOGE1LTQ1MTEtOTA1Yi1iNDA4OTY5MjRkM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATz/ssSx9ZK8OrwGIryh1BQg/94q+4EazqGlikWCArjpac7\nWHfL2dKS7igYIOvau6l5xnpXdmM2ZRDiAlQIvTRso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3QJL6AGpioYwgxLk4rN70Jfm\n8KowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJOOfD+6t5eWgdTIMC7jBqQH+2D4EeL/htmlwnEmGaM+AiBXH0bGK2rz\nFElPsyuVt3u6XxH4rkxkVw9NgY5PvV6L7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAb6VBsgfofxFaFsaCWrRU9mVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU5ZWQ0ZjUtYzJhYy00MGJhLTk5ZjgtODNhZjI2ZjE4NmE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYzAzOTE5Yi00ZmUx\nLTQxMDMtYjk0Ny01ZTMwZjM0YWE1MDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARtU/UYbkJ/H0x0C2OkNdVBlU6JQZFtPHiTseFxIRodWp5JSmaxKkhnIAjnLaH6\nb+Lcq7SccxuN+RJ23TJd3vTzo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqpU2+QcJaFgSs\nAIMlRTN70zqZQDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA0MTOYlXxMhFFEDD3CNEGZ7Rxvvij79SXj/wOqhbwOLIC\nIQDlndzl/2ZCxbhwFUgtVACrhD/NGOHRjt9tvbVuoh5Y3w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7636", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7636` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAez7w1IIiTF4h1EjU+Uovq37MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExOGY2OGQwLTRjMzgtNGQzNi05Mzk3LTMxOGY1ZjFjYWM5ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ2MTY4NjktZDYx\nMi00MjExLTk3MjAtNzZiNWVkZjM3NDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJVKB2FXWg6AuuulmcqqU1jiEETQVEIumFGyjSQBSAUM9LD/iRVsmb+3PV1Ym\nyE2PoMdURcJV6zLtNZQJtzEZaKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuOoG9wE4Qa4Crc6RUJXfZZ44YBUwHwYDVR0j\nBBgwFoAUmR8IWfH6zBm65/63H91+aGx3DcowLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIA7a\ntctEjN08imabZNJHgHvFH2o+/THCtZ2GU5NFPUDSAiA09xBoVltFsQZKDxesUjjz\ntPtDy8OXBeZ6qj+HQ/goYg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATvd+7cD/BMiUje49HvcDScgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMThmNjhkMC00YzM4LTRkMzYtOTM5Ny0zMThmNWYxY2FjOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATF+s8JT7qfLzn5JZoq60RzqHeDpfGjqTSiBxlSR/eQ3Ojx\n9DUAgVB0I4wak7mkluiiptcn9moN7B5atYFsQ3FLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmR8IWfH6zBm65/63H91+aGx3\nDcowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOpXa3vkIHCir3dPw7URKWmw8lAYRi0SfnQ4VLxb4QzqAiEA/lLsImwx\nq4RkZRTmfaWRuB6XmusABb9Fu4bPiUsLgxs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWz1FrVPnsVldkokGvVzhWCiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ2MTY4NjktZDYxMi00MjExLTk3MjAtNzZiNWVkZjM3NDY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YzQzZTY2OC01N2Zi\nLTQ0NWMtYjhkMi0zMTMzZTM3YTVlYWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQl3lixChoQ95lIpOG1SG0MuZbpBnS4ZD8aWcY5vNUc408thJWAQx8LDr92E0zg\ntaPDnt16s4DZEuB5y7rOy/BGo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS46gb3AThBrgKt\nzpFQld9lnjhgFTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAkIa8XbJy3MGebCJjJepQhFCwlebAeC62aUfKZfUi7oEC\nIHXZTrPqnejcVLiMnnHSYiuAezsqfqgqotpInMAl2YUv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7637", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7637` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAUzcZFcZ4DEGxTRkDOOcurjnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4NWE2OGU1LWNiMzgtNDgyOC1iNmY0LTdkY2IzZTEyYTA0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk4YzNmNzItZmUx\nMy00OGViLThmYzctYTFlYWY3NDhmNzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9u2rQiO7VL/oB9I/1v0zomAGRTSsDr6RuIaoTQDqdOY/q1+7oINYAL5St9co\nCU39MPglUXsYI35glnBJ4JpAKKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1arKe1uB0w+zQ3m8nVBiGQ66gmwwHwYDVR0j\nBBgwFoAUbCGu+GLQzUm0QQO1I6KGXSq/socwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCP32Dz4QfZn7seEYapbWLLKXgOBR58odhXN89tvdLiLAIgGFWm\nmRw/ly6JPGZa3U9bkIFnWlYt9F+xaR6T1GAwPRo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAebu8u3L1wXDmC7ODP7dFqC/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODVhNjhlNS1jYjM4LTQ4MjgtYjZmNC03ZGNiM2UxMmEwNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeqnDBzK7SY2hBZoygYXCvfRcilQIYaayU2oYaHcwYatVg\nZDjKa0ftLmUxVOf7U03phjv8jD9unStz2rVeVvAFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbCGu+GLQzUm0QQO1I6KGXSq/\nsocwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWEzp61am7NIbaLWCv2cWuCBDWFoqEMOfhVhtOzzTSX4CIQCPbDZOzi+J\n7RQHpXnOnUMUhOxQgEuUCXYyUCy5Hd0WiA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAem3igXVGSb2yCJtL06nd0l7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk4YzNmNzItZmUxMy00OGViLThmYzctYTFlYWY3NDhmNzkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMDRlYzEyMC1kY2U0\nLTRhMWEtYTNmZi0yMjhlYTc4OTgyZjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASQZBweEqZuDdo5i4MGKLbYSM0/zVfQQtNDOP+rrzBm7RxUQN7FFRF0QhdpBlr8\nYCcqlTEqE/4tIpM4TwHErLv/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVqsp7W4HTD7ND\nebydUGIZDrqCbDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAmzdDqLA6ekF5qwSVf0z9neNxBBqZ6cM66BoEBbp3N1QIg\nI09l7bIzCLJcC7BKv+qLwrQFm1cEK1OQ98yqHHWede8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7638", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7638` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAf4NJJWFaG1Q6GiZbEDEYMwSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MDE2YWNhLTI1NGQtNDg0NC05YzRlLTQxNTY4NmRlNWEwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRhM2E2MTMtMzNm\nMS00ZjhjLWJlMzAtMTkxNTA2ZmVmMGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw+AJHeiN+ad+nIe+Zltaiasi8CxZyZx210isTlTVcRUTHFq+Dri3b6yAeuo2\nwa1oV4VaXTYxbIfhk/jLGrla46OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUetYnCYe+Thh3HBc5cuYkuMxJhFUwHwYDVR0j\nBBgwFoAUtBNuDASFnWhKSSjOv0Venjch41wwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCONnTZYhnlfJ8O2icdbjhXHmfZtFJIFP64mEO0+ZiXgQIhAJho\nfOlfVterOnR+Ay3RLNByzuLawTHD8N9eNnznqZPj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdOWo36uKQ2u0stQu00lEVMGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzAxNmFjYS0yNTRkLTQ4NDQtOWM0ZS00MTU2ODZkZTVhMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvfUQKZu7FdCgxEUFB2/hVNng8pI19mridXV+Z5Kl+lAGx\n0H7Z1BvOJWlqCcxauL1kwgIOE14rQWGIc76t9Ws+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtBNuDASFnWhKSSjOv0Venjch\n41wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL8lEpNJlzPEIwtDhgUUnw4eKD9JPA+PE52DomcYsuwTAiEAmcKwLpAO\nfESz311mX1fk4Y6qmhbJFS8h88/u1V7XzME=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAW3iwEOx3IG/FLAeKvh4EtXAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRhM2E2MTMtMzNmMS00ZjhjLWJlMzAtMTkxNTA2ZmVmMGY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3Nzc2MGU2MS1lNWQw\nLTQ2NGItYjRlNi02ZDkyYjQ3MWU1OWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARODRTLFg1wKD9z6Qjb+lhWLIsspKUO4gyL5D6n4WYjP/46JKyRvHxtNsgElCew\nU+mosV3M82CEUlH9SKcGfFk2o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR61icJh75OGHcc\nFzly5iS4zEmEVTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAxipjhzuVXqO1YUOKTyz+OKu5qW293MA0lvM5ySWnCosC\nIQDquhhMBo/aU0hby87FtttJlxAyK8x70V0qJ+faxEC8uw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7639", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7639` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAWJF7XSWdTIYHH/wdu8zS2a6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkYWZiNzc3LWMxYmEtNDIyZC04OTUxLWU2OTRiYWMzMmViYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWRhMjRkMmItNWQ3\nOC00YzhjLTgyY2MtMTJkNGVmYTQ2MDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETtsiRhbcNnHD5e17x+PiiWITtJLNvNA0BGOrp/zjn3pki0iC+YmnjM/WjcJq\n4VBdxb+aPju2lHoMW9kQVbsyeKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJknKR6IL5D8BITjDCbUsDYppACWMB8GA1UdIwQY\nMBaAFDntxYzKrCgxk72yEXPy/2AencfzMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAk6K82ll7M0BWjyhBDS53FUS2SjdB6gif\ndpjOQ1PSNKACIQDSwrrckHzog0Oy7PiWzZWSKzSwg2dw8blGVBSdawrzyw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV3feE9+ofSNC03I9pjdiHiXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGFmYjc3Ny1jMWJhLTQyMmQtODk1MS1lNjk0YmFjMzJlYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAU6PBGy7VNoov45S4apmiOukhsXppnkyDm9jKiO80Wl8F\nQQDhgNIhA6UXoo1hi7sZDcqf9CLFPEht3sn6d6woo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOe3FjMqsKDGTvbIRc/L/YB6d\nx/MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIecfbUAABVkATxlN8x/TxGGWzI9X84bYSw4j9AY6CP2AiEA1tMMggDg\nHmMb3HwV3OU0CwZhIi7MFLX7dbAprNGZHgA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAa5yvZtroIr9A4kUb5e8N0UdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWRhMjRkMmItNWQ3OC00YzhjLTgyY2MtMTJkNGVmYTQ2MDNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYzNmODUyZS1kNzdh\nLTRlNjUtYjkyMC03N2I5N2FiNDMyNWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQHumRWAV1n7LIkv1r9Wd4lgvDUOW+Q03NOyQQjywPx10w/voe2NdWEssR2PPE/\nyG/pPQGj/fnRcbaOS+IubUpoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZJykeiC+Q/ASE\n4wwm1LA2KaQAljAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA1W9IO6UZxIyy9YXmOiNDYDlV7+G5CrU7BqBlQmpqvmMC\nIQDNeezxMqZh8Wjc2QVBs/CfwVzUDW+NpjzDWFwsjhEbaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7640", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7640` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISASaqyUc0EPb4mc/YnEdbVCrNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNGY0Nzg2LTc1NTYtNDM0Ni1iN2MwLWU5NTdjMTA1ZmUwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTUyZDA3YTYtYjk4\nMS00ZTc3LWFmYjAtY2Y5NDAyZDY5MWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3bZu84gfTAiZafeQnskaHjB+/zHuF5UrG704Jg6DZIkiIJfGPDmjYL2sxJlw\nk5x9zNSwC0t2Xa1SuZAeUPiif6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwlNneYTy0bimXvc/yxlOCirKlkwwHwYDVR0j\nBBgwFoAUFQWqFbffeEccA+kmRQDD02O+Nn4wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgQMLga4UOVoM/\nC0v3g4o5KQcqzEtb88qqz40wqucY+hICIExiZrkGaB9p2XOV3Ag8nKW5u0VhXAr7\nTcjYobwEPrsc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcIaiTIatlasIvbJaMQNaW2lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjRmNDc4Ni03NTU2LTQzNDYtYjdjMC1lOTU3YzEwNWZlMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmZg92IQClDfzZPFoJkcB19zmLg630MKG7eEBWiVIDpjyO\ntCshRrfO0GI/iUJecUYC/KvR1pRVtMytz6aXmF1wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFQWqFbffeEccA+kmRQDD02O+\nNn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJSWUmnS79mjnG8ebOQYgrcSxMaJZyPWEBEnqpllUBZ/AiA7ZySNvhw0\nj/S6YgB1MJpXqv0RlhR8y1VhfUUqZPZPCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAf4x3QOATWywOirq4OAorYRzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTUyZDA3YTYtYjk4MS00ZTc3LWFmYjAtY2Y5NDAyZDY5MWQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OWNhYjBhZC01MDJm\nLTQ0NzEtYWY1MS1iYjk2YzJlMmQ1OWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATHzQfMPWz7g7tEBiW41tTraUCKLqU6IhjT4BQqAlN32rW1z8LYnItDUsoPYCDb\nAmXgA5upllVaAyFC+1B9WylUo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTCU2d5hPLRuKZe\n9z/LGU4KKsqWTDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiApDu8e9X/aTOWa1PjQoCo5lM1S34zJCtolZyRZLAh5hAIg\neveu2pdS5O4r8sCNlxQ/FDV64utLT6/zzJBT5rHC7q4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7641", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7641` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAXHwKMAPK2Jl1iF2mbRytfgPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiZTZjOGY0LWFkZmYtNDhiMS1iMDBkLTA0NzczOGQxYzgwYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFjOWE0MWMtNDM5\nNC00MjhlLTlkODEtZTYzMzY2YWI4NDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMjZllLgX1fkbXT0fk9imTqsrB29irC+e1sT7YMTDU104YYOVoOG7BfzVtTTV\nO3YxUJSpZJGztL3rq0PHihRZvqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2A0D3hyznAdWs/FMb2FY0k9AJCQwHwYDVR0j\nBBgwFoAUiDhr0VHknch4VW1jEUQ5MgZa1rUwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJxA4PmubCns\n2O1KRvXoBFubEPi+JNqMm8ZG0zMsq0CeAiEA3W8JpjnF232EBeUbXhFkB/gl0r2s\n7D8xLlQzdALzn+A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARvheMJ7SwvZVwYZVlRJgM8zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmU2YzhmNC1hZGZmLTQ4YjEtYjAwZC0wNDc3MzhkMWM4MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWupEr9nkSWh2A1kStn3I+M+DKpsiDnNSYDSSjYf6Gxhgg\nglfP1oOFi3yI8AfZP0MC2omPqsngDiP9OeSW3T8ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiDhr0VHknch4VW1jEUQ5MgZa\n1rUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRZMTzInby/CfEditliRXZt15P/XgqshzUiKyUULemDkCIBAXn9QRGYmn\njf31ZTZN40LF0DtiPfr1ehvReJgo00Ch\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfSnPh/u+HVr8kI327tBaNgtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFjOWE0MWMtNDM5NC00MjhlLTlkODEtZTYzMzY2YWI4NDE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMTcyNDA2Yy01Mzli\nLTQyNTEtODIxOS0zYzZlOTlkMzM3MjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS3Ms4T9A630hrGzfiOZ1sQabZNcH+93o1eaJMB4Woj7Ep+15ZG/3OGmdP6LTFM\nWHftF+voLC2JZb/8C4zHyyNMo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTYDQPeHLOcB1az\n8UxvYVjST0AkJDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiA3rXTCCCLiPU1Ry+fieacyBhCnrrQyLmF0/TKEzjGjwgIg\nWxMtnC6/u+sWFZfVUyFnjBicT9FfTRW9lWD+J0Hehgw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7642", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7642` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAXtzg163qB+zntfW89yA4/DTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzYTQ5NGE2LTQ4NTAtNDc2NC1hMTVhLTg0N2ExYWM4NjBmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI1YTlmMzUtODVl\nZi00YmNhLTlhNDctZWJjYzRmOWE5NDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJCHdkn36z4DoBuW9I+VoMUoCD0XdofwAjWic1Sc1XJIanQSGpC9x+zhLztfy\nox7QpRSjHWKqiyo7giDHH9mq5qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSv6L5UBnNs7N4+0cXNBmpE6ZOk4wHwYDVR0j\nBBgwFoAUcxl1muYIuJMXgpw3gs9i8J/GB/MwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICcKj3TDozmC\nia6Brx1L7IUhEOHr5wToP+ICXZ6X5C7GAiACW9oslNeIQNSDVvOJkPlPw3KcUMKu\nAm7LaFR25ZeDqg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWyKRfX+f/ZF58YQi7YnNp5WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2E0OTRhNi00ODUwLTQ3NjQtYTE1YS04NDdhMWFjODYwZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1ZRO2dhp9RJRxNyz/Mqmosv1UvCaDOaRQYVNezapiwyse\nuKw6Jqfkc/cdnmY2/46XmpntveQkrzPDq2zANiwLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcxl1muYIuJMXgpw3gs9i8J/G\nB/MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTTjh+P4tpJGamOsVNFyYwLDFzVeFKNngCCONWYRI1BsCIEmM06ClHkOT\nHFdthJ0ftxUvUbqjHQG1302Ag3fCecVH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAcrhaYlZBzB7YqMjWwmmxqPuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI1YTlmMzUtODVlZi00YmNhLTlhNDctZWJjYzRmOWE5NDMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjODM2NGI5MS1hNjg1\nLTRjZDgtOTc0Ny01NGY0ZjgwMzNjM2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASsIFcyppHCj8benVC+8x1FA9I7sbpXBRGKCTimhb33CflfKxsP0S+ESn/ojrGC\nAhx7qbCyC2QGMUrYMM2GoBO5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRK/ovlQGc2zs3j\n7Rxc0GakTpk6TjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEApp0T/XUiHQVBC1oZtDk/9vvOhbkrqGhiXRp9MMplogMC\nIQC9qsejIacHQLWfaChfaf2yH2LetEWhwKW2KnejIkSbbw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7643", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7643` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAc9z+hXyykqUSys+frO2YvB6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5YmNiMTI2LTI5NzUtNDVhZS1iOTdhLTE4ZDBkZTZhZWIwOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NjYTQxOTgtMmVm\nOC00OWNiLWJjZTQtNTkxOTZiNjVmZDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPgwADy4EH8XmqZSwier3eE5DfwvsnsEGWm/6Cvotm47QuuvY5uctwjaNrlxI\nDbMMIHcNci/lEiYdPYGlXU0uAaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULUgeNSeb0d48ADxBytrCB3uJddswHwYDVR0j\nBBgwFoAUo97tchaOhj8ZxtFoPKfJOAqaACkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIC28jk9dfP4SuPjK/OEF+tl7wqO3v/ZPAdX2AZLahr2cAiBV+mYxMe+X8p9d\nhDN3iovZhZ5PW26LJOxjJ9vWydIIwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARcB8NBkqz2mYKMCeUwUQrwyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWJjYjEyNi0yOTc1LTQ1YWUtYjk3YS0xOGQwZGU2YWViMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQR/uqeT9HQZpH+DZJsjKCokA4gGwfUUkfhbieZTLv85f89\no0cT/+yZ8KGBplTd8gIIpEJ7aN0VgHgZ0PhowcHeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo97tchaOhj8ZxtFoPKfJOAqa\nACkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdWPqPAjm80Q0uaAj4doSmyT5SEaI7K5RKGVoxYJP5s8CIGERKgHjUqJk\nOE1O83KV2oVG9HyKQmJXBMSkwbGq7Z93\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZEjOEFW5CoQu39pFgm2xI6xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NjYTQxOTgtMmVmOC00OWNiLWJjZTQtNTkxOTZiNjVmZDFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZjIwYTVkMy1mYTQw\nLTRmYjgtYTVkYS0zMzkyYWQxZmIzNWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARgcgjRqNte2DIDINgChwQXT9m3R7/+zZMsWo450+Ll/LOH+KDsn61lr/kUrt/O\nnkgzO6dN/KDtRPIliAjKxKWvo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQtSB41J5vR3jwA\nPEHK2sIHe4l12zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA75Y9uYvhxFFU4DQht84dR5utRRzZGNyKP31nqzvM+cQC\nIQD37hBI2kDNqMez1bcEZzlimyKIQNS0wep48G6wKmxS7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7644", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7644` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAW95HKrv5C760+a+I7DVHPgTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkYzJkYWRhLWRlYTYtNDM1Yi04YWRjLTFkZTcxZDBkYTU4YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdiYTQ1NGYtNWM2\nMi00YzdmLThjMjAtYTc3MTdkYWMzYWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnju7w65CFyAyE/U9jfThq4prLhY4bWf9XqDTTvT8eN/vkCm+8AkSuFOH//RR\n3vAi94PFhOY8B4vKC/hVTzrmkaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwk6ehuLVHoHSowt32DTssg94a1YwHwYDVR0j\nBBgwFoAUMcik5ZI3tX41/1x1JKnh/q759IwwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICkBF7mq5JAECsexx2du52ukMnrdQ1p91kp6QMRQzzu9AiBgI1rpuE+R7n7T\nMNn8IZrChYWKsPdxIqcwD6CEeCyXRg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYjPG87w4nvF6yFsSbWF1WxjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGMyZGFkYS1kZWE2LTQzNWItOGFkYy0xZGU3MWQwZGE1OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASb4dvuRkxMcsfKuUcv9uX8BTdIzF4RyjrOsN9u59tSHHDj\nWiDKTEK/+Ii9oWEPD2wIFZNa2DQL7SEf3xBuIXdzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMcik5ZI3tX41/1x1JKnh/q75\n9IwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgazYeK5kQzUDQEJux/884khoRZIo1Wb15iWdlUcu3ndkCIDkeuORKaSEr\nV2xm/6akPdvO9xnqHOfbNdJAYtTNyIgL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVRK7pFQq/GDShZGNLrkgM32MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdiYTQ1NGYtNWM2Mi00YzdmLThjMjAtYTc3MTdkYWMzYWFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1Zjg0OWRiZS0wMmQ4\nLTQ2YzQtYTJiNy04OTI5NWVhZmVhMjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQaZtkAZNYs8OCPx4acwVJhBDXlV8KlDJm2DbMvjWPNXxL17cA7hHAJLLnn45R1\niqGSnMYEg9oTxc7YuUpFcJeNo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTCTp6G4tUegdKj\nC3fYNOyyD3hrVjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA0lfg1AlFHlkEoZOmhxlGFopolaT77LN1wEv6+3wou8wC\nIBR7Ms/k7uSaJI5xS9YtqU0+PUvDvJQlSTDRUZj1fZMv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7645", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7645` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAbhCFnw8ARN9ab0RtnpNXTY2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiNmY1MGI1LTEyZDAtNGE0MC04OWI3LTE1ZmU5OTIwMGQzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFkNmNlODctYTIw\nNi00YWI3LWEzMGEtMWQ4MDk0MDEyZjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP0mOu0kw6rUWjVQVxr7QKcimPXxvwcPdIQwNd96XwoP9aJbEa7unszq+V9lP\n1bgDQBDSRd/8P6zqeClSwlFUUKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtRAYKL4AxEGID5EB1PqtUZ1Wk7IwHwYDVR0j\nBBgwFoAU5xxdZ8Q9EXpFiMMMilOMJdWYhYgwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIE87\nOvgDgYXOdU/rJxFjx65a5/QXEVwyBPHLcbaoQJ0gAiEAiC+ueXISAZ1DQzFNwIbO\nNF9IHOMe8F5mDxgAQMvjiY8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWiTBm7RAXs54XO89e74ngX3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjZmNTBiNS0xMmQwLTRhNDAtODliNy0xNWZlOTkyMDBkM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhy8Sw24/lzVR6pH/je81FK19AeMvFk6KrHEKIx4oGf6UZ\n1hRXJld6+x9ciIOciympo3etcjS4QfwHKNMYgypoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5xxdZ8Q9EXpFiMMMilOMJdWY\nhYgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV/6bR7JmMW6z4MMLtivkJNGERL1W15XzmtKzkrRvd+ICIQCRPNTSxxEY\nYV0arav6LlneB6EGCp510i8o3RbUpTIqPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZJscUuw7vOrxM3qlF6loipRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFkNmNlODctYTIwNi00YWI3LWEzMGEtMWQ4MDk0MDEyZjAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNThlZDQ2NS04YWU5\nLTRlYmYtYTZkZi1mYTM0NmFiZmZlZDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS0cJCshHZ+4T0GOF4XSw5PC8BHUXvn7e84TKenpvrleSzUa/A82cmxrXIY9Ssh\n5G/D4lmfjvb2aoDZ2SiHBZLMo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS1EBgovgDEQYgP\nkQHU+q1RnVaTsjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBiYQJRkeal8pzXbu3lP7aHQobU9glGxcJnVTYSp5FsRgIg\nPGd/nf5po9yRKZj2CAta1JfzLTvbLBVINH3lMGo9zvc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7646", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7646` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATWNZAXjEtl/zf6ppgQePr6bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2Njg2MTE1LTJkMGEtNGJkZC1iZTFmLTI1N2I5ZTdiNjZjMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZjNzc3ZjktY2Jm\nMC00ZmYyLWJlNzktMTJlODE0MGFlNmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHPtrjnVnqzCYgLIwb4KHscGF5DtMCScYtulypilAN3Cgm03Jh/PL5J2nqgti\nfMOasW2GOGdFlbH29PmWGuf8GKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBAvJs3Ow9emQ7CI+u/XhgQWoIsowHwYDVR0j\nBBgwFoAU6PUSdeT/Aa2KvNADL3vGI4O7UHgwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIHz4XkaYM/LuVE0wMF98q3xARbfSXcbfkH9pUjmpZne1AiEA5YDD\nukqy0wX8LYTnHiYh1yvXDjEFdEFZUI+OaynO5rc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARXfMNwlQyxP6vrAQuTeUirPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjY4NjExNS0yZDBhLTRiZGQtYmUxZi0yNTdiOWU3YjY2YzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWEsGjGPVUbGD0S7GuCtlPmxrc+enULYu2vLjbJBf6CqWv\nUS8KTVmTzzu448ENGJqttbwEOAjK10wCj3YIBnROo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6PUSdeT/Aa2KvNADL3vGI4O7\nUHgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ2Pwkg2zDQYzQAjL/Nvbb2q+9KAZwqivcvZuhceturICIQD2ZpK3+Phz\nhBrzDARuH/Mybnggny0JHl/8K/GWyzytlA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAVxLgP25PD6aTyjma1UxXpjtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZjNzc3ZjktY2JmMC00ZmYyLWJlNzktMTJlODE0MGFlNmYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNDQxMzY0Mi0zZGUz\nLTQ2YjQtOWE4MC03YmU2MDRkZjYzMTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAScgHLx4FY8A6DZn5V2P5NsYwpfv7RhG4MhjqoZxeXZ0tkqoBVc1ymGCZ+6pQVc\nWBK01WSVM7+k8RiPP3rs9zhpo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQEC8mzc7D16ZDs\nIj679eGBBagiyjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA2LKNAFtEIQffZBU3ZNvFbl/nBkqc4Pxw8LptrTtxEmcC\nIQC/uh80DB9HHDBcFUxX+/4mIOqODTgat11hqt76t7OmRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7647", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7647` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcnEMdeoXjwRN0soT5wy4h8ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhMzU5NjI3LTRmMjQtNGExZC05Y2FhLWIxNzI3YjcyOGRmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ1ZmM1ZmYtYzU2\nYS00YzE3LWFkMWYtMjYzOTg1NWU4NDY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDzfROV/24jfuidFCIrmgEpQ5PCWZNrDB32AKgjw1ZfychcoINYl+/tJYu9z0\ntIEtexJYjH5f/71YBGWCugoewqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHEmWWYbBTJzzeWrakb126h3l0zYwHwYDVR0j\nBBgwFoAUM5ZJjK5wCMqg519RZEi/aKToyo4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCZoy6ZrFYAdxqCAK7TrtCtJfC66LSrgoNcY+aPbRI3pQIgcK2F\nTYy9l/AKeb/yvbUpzAFPfAQtr7T406+JIKfCFsI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAamW6My23l+R4hs2yAPlor8PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTM1OTYyNy00ZjI0LTRhMWQtOWNhYS1iMTcyN2I3MjhkZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARd2MOhbgX3+L6G4xOUComganxeMRwEiknN+ogZQrWSi1qY\ns7Au6ZHXWpKeYBYSfyVT0OniaYh/pCElNmdRf5Jko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM5ZJjK5wCMqg519RZEi/aKTo\nyo4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfna8X7ywgGTtG4ksJHRIMdm6cUct6s49CVzJ1rC+zloCIQD0cXK+eRwr\n1El04dbjhl0/q9Wpjxp3FsmU9ZeNyXgz0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdZIIBgErg8eLmUi2sNvRBwvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ1ZmM1ZmYtYzU2YS00YzE3LWFkMWYtMjYzOTg1NWU4NDY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZDExZGExMS01MWI0\nLTQ3Y2EtYTNhZC1jYTQ0YjQwOTJkNzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARU/IsiICmJfkDSKM+4QZVPdYVJ6hNztdVktWExFdnpa5XOelvT1lcoTyHCScJQ\nAhm9Vb3hzshNCDfYggIhDH7No3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQcSZZZhsFMnPN5\natqRvXbqHeXTNjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAjgfJHlUUPMOrp4U9QKjJAEmNdEhl4bLpvlf4sUvsxKgIg\nMknuKIE+lnphkh1yyK2hTo0k3x/iZFcU8VnDEsZ3w94=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7648", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7648` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAe6NbImQ7dO1ajBH8nQaVHiWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzMmU2OWY1LTZjYjUtNDYzZS1iNTY0LTI4ZTM5ZTBhMzI4OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI0MWM2NmEtZjc1\nNC00ZWQzLWI5NDQtZDQxOGQzODU3ZTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFcAIh3eVynvmlJKDnnEaKTE5cgaGLpKAA+6UVFY4eXaXVaBSC07wF6vqBdAy\nqYVg9xF1Oif7Oel4wlaWVySWNKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRVNzLe7a57SVc5xcSZQk05UGrOEDAfBgNVHSME\nGDAWgBQhYuTOmDeKFX3GzTQCbMUKQ4+BrDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHidxoPNT/li7rmgqmLwOUmPAJDo3I1n\nVQYQmIuRHMyHAiBbd+abgmmz0cjCdC3JmbRdt3V6VYJQf4G5QWJwK0dMbg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARdTn+6eXpegQTA1nQJo6Rr7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzJlNjlmNS02Y2I1LTQ2M2UtYjU2NC0yOGUzOWUwYTMyODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQtOZF03gB/eoFNKtRxJh8PeV7/8pM4BowxpHC3OpK6/QI\noJW8P2ZBfX+DWMxSxvnaYoYgaSbRJOxI0EmXJE9oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIWLkzpg3ihV9xs00AmzFCkOP\ngawwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKHLoolVKnKlnbHQLCEh6BFW3wO/bcKjyMSX/U9LeR9WAiBcs/UNeSyX\n1VOG9SnHxi6geHUxKNy+YFyWIde3TfVbhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAaoqqXhR0pZlLB7+SJLIT2X2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI0MWM2NmEtZjc1NC00ZWQzLWI5NDQtZDQxOGQzODU3ZTQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZGFmMTBjOC1jMzIz\nLTRhZTMtYWVlNS00NzY1NTQ3MDc0MDMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARsupIFD32dBb0JQrVkquJzg/mAe89AnOR8c7vKaF4iwgvWUmRqZUlTP5JZWrJ7\nBjTPzJdz4un909Uxxx8l2Tsuo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVNzLe7a57SVc5\nxcSZQk05UGrOEDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAuwTJq+FLid/Ho0HqwsX/R0mp0x3XcEftipHj2Du0Q1cC\nIQC14oPl7xH0NA6t2QBLMjIOvPemaIujH5HpA26yMCI9lg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7649", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7649` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYJv2guw8ETQEjCHEDW03hmdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MGU2YTJjLWIwMTctNGU3Yi1hOWViLTI1NjE4OGYzYTc2YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZkNDA5MmMtODNi\nNi00OTEzLWFjNTAtOGU4ZGUyYjZhNTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE10fC+s1SguVC1VAECd399T5cF1opRSR5Rd9T4YtgwHF0SXWojqtzJHk5Zx0D\nHAd+5FdNiHdbD0K9hGfJ+IB50KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW89ZSiqu4vDvS4Hu8/ZADDsmJGYwHwYDVR0j\nBBgwFoAUxT8GFkzbIwYy1ETrCwWDdkWlmhkwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIFO8AYqnnqP3\nF2Ae6nTWm5vNDSVlTldMcv5H+/TuZ1XFAiEA5DKjRwOKzNumKLTrNtmqQwuWtg9j\nHYSyK07gGxJEwBQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASPJlf8aWqga3WxLG7LZ2lc7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODBlNmEyYy1iMDE3LTRlN2ItYTllYi0yNTYxODhmM2E3NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwv06BoK541aDz1nwqy5SDWZ7FBH+cieZXDCXEPJKKmmFG\nPtpzsghRfjmAP2snA1mqykoFNY0tMsG7VqQO4ljwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxT8GFkzbIwYy1ETrCwWDdkWl\nmhkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcCrwecz/WxEOoJ5LDJO0g0E7Ie5lXju+2QPxGxDVnBMCID9juIakEWn7\nmQAdVEPFm5sSLYZKlWH2U7rpGFbX6ayX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAeAnMjPEgj/5wv0yAN5oDORXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZkNDA5MmMtODNiNi00OTEzLWFjNTAtOGU4ZGUyYjZhNTI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMzY3ZmUwOS0zMDQw\nLTQ4YjgtYjU3Yy1mNGFhOWUzZjExOTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ81FVJV4+WCvJu10Sd7QhocPVUTUEeCfBcfrW9c00b6pjrjibnYbfnbJvk1QLo\nec0uykgjbAa3RkN/Q1Km6H2Qo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRbz1lKKq7i8O9L\nge7z9kAMOyYkZjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiAooRoks2ngSOk43QdYf8p8R1YCbfgCrjDIhBEpTF78JQIh\nAJmtZ8Ahog4/rwaLC/AUDsguENxmQtfX9OenH62dMVri\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7650", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7650` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAeGZ108vbUoOgfStz2mcI1sgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkOGFkNDlhLTZmNmMtNGI3ZC05YTcwLTE4Y2UyMjJlNDczNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBlZDZkN2YtYjhh\nYy00NTFmLThlOGYtMjZlOWViYjEyODFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnKaqBm8DV4ByX6oyPtc+NmyOnO1fm7+axsCDAYSAdJ2gVOO29ksgEpAgXWiI\npt3Qe3FM/SaWZ2WD9az1iYh6taOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUThy0OpP6docAnTSo7SN1NeYwVugwHwYDVR0j\nBBgwFoAUr+bYvrQvDAJpflA41w88jXuRkD8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHAJp9CXWf8T\nW2Zbvmk5xNRT/qSZ2Ho2shtkxRY2MbuoAiEAlzUKaFJLSsAHCDRf+hap64oQf9SZ\nXgIUtrurBhX9Nhc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcixUcJ7ycHj0ai6uH5vocG/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDhhZDQ5YS02ZjZjLTRiN2QtOWE3MC0xOGNlMjIyZTQ3MzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQLuCizBlplZswgar7Gw/K6M8AtQAjbIAInAxupkmRpvxd\nV0FI/W5Db/0syDS75WFBaOf3cVFmvgIpp1E9sr+Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr+bYvrQvDAJpflA41w88jXuR\nkD8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHV7oUFoFUvCr/U3YTW3kLDWWDPnJjxyT8RE9yhsqnc8CIQCmxXJgIn2F\now5D8MV5b03lXPT8ANn11fSdo0MGOv3LQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfWFWATw/bC9VpFPYvTc+s5fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBlZDZkN2YtYjhhYy00NTFmLThlOGYtMjZlOWViYjEyODFiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5M2NhZmUyMy0xMzBl\nLTQxZDMtODY2ZS05MzBkMTBhZGQwMzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATVwrQMDFiat4qH4jN2lVHcgmzExMAp7aYUS0F4AcRmD7KBRQd6f7i4JLaYBgVh\nXWS/RknPN778Xlmskcx5YR9Qo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBROHLQ6k/p2hwCd\nNKjtI3U15jBW6DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBRmc1zoS6+KlLgfXPraswn0Dz3RlJ5799LRu3H30mW4QIg\nMxwLgILElvpMkuL50fBIlOjqwBlYkMmY6SYbOBQITD0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7651", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7651` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAUoeG8JenuIgLAPyP8FwOBwFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlMjE4ZDAzLWU5YTgtNDRiMi1hOTY0LWM1MzY4ZDA5YzU0ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThjYmE0ZGYtZDI1\nMi00MjM3LWE1YjMtZTY2Y2RlZWIyYWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElGClPA/MDRq/NlDfdoy33yFlS8yl5jcVIGacgr9ldLHp3goiwf7wn8C5pI9k\nAyFQSsPvnrPGVkwB2o305TiGGaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyDo0gL5smZtPWQ0ifJAeg9ixTQcwHwYDVR0j\nBBgwFoAU0AM7Ye7Nt3vYi3+T+HmiOOoD0KQwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBTMCX1okLc\nPyvw1i/TCuLwBqX/FZT5b+E2yKr9AYYpvQIgdfyZ3sN+8l4a0VT6xzrKmN8TUMM7\nJxzhIjCNMHr165E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUTskKF1CpgIBKDeJcgPmiLmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTIxOGQwMy1lOWE4LTQ0YjItYTk2NC1jNTM2OGQwOWM1NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFr5mu/yox+zMMpGAlR2NEdPT9ROZQ9jPyZ8ajY2g/oP93\nyBwvYWlyByyc1OR6leLfH5o+a+7Q/yVKfVtMbImXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0AM7Ye7Nt3vYi3+T+HmiOOoD\n0KQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM2fQx7smLg9d6IUQiwf7vUJcw019Z80rfQoBT/KOjYZAiBPYb7KpQ2H\njBNQc702CeoSjLSFnpSUDx7TXh5fwFdC0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATCl16j+93Iqhn6/WCn2cb2SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThjYmE0ZGYtZDI1Mi00MjM3LWE1YjMtZTY2Y2RlZWIyYWQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwOGU0ZDQ5Yy1kZTI5\nLTRkMWUtYjU5ZC1lMmY0NjM0MTBjZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASeaHNQ2qjpTuEx2W5/C93J16PZpWHZWnspavQLTvFp4Y9u6iXwh5tRaUvP9zrr\nKIERL3uf7LnzcG5l5bsTUcc6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIOjSAvmyZm09Z\nDSJ8kB6D2LFNBzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAt3DS9UHjiXVUp5tDBPf5H6hLlUNhRZyAkyGXHgkjbCIC\nIQCk67bhul6UqF/Fjpylgk4eKoLJK8EqpeqB80gX3Eti0w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7652", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7652` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAXxyere+5jswpSggZsqiSdUFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1MTRmZmIxLWNmNmUtNDY3Ny1hOTMzLTgzNzEyMmQ4YzZhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI3NWM4ZWYtZDdi\nOC00YWE0LTgwN2ItYTdmYjcwNTE2YThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtmE+wSCFU0C40zzOijSBequnLYdRNbl0/Df8AYLNjV2BW2ArdUGc+QBJ7BEF\nBD7V7O22oLiu1P6DGn9ZwGdMzaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAIgDxr2qLTbehIwouBQuJ2bQ/dgwHwYDVR0j\nBBgwFoAU0gPwX1CTjB+NHt6L71Hz9gD1NikwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiAwtn3Cjn+2QJCWgv36iDQvj9Fb0kHm/OYEx7Ehk1EV/wIgGuZwIFYGIjsn\nWHGge6FQk1wMEoMdyyqs9lZvCY01TWg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcXxd6mGL7I5jbpBfkKnn/ScMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTE0ZmZiMS1jZjZlLTQ2NzctYTkzMy04MzcxMjJkOGM2YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPlqgMr49HP82sIILDFutODxNHXx+R+gL0v5BjrfdKzu0H\nlCha/2GH047HFYgE9kox9rK1j22sa5T7Y46z6/VZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0gPwX1CTjB+NHt6L71Hz9gD1\nNikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMUuZJ7q7cUvXrgrAFK5lTlkem16oRnvbj20YR25GlM3AiEA4kHdiAbE\ne1FkzI6o0UStPDCQHICGpj+vk2k0Crd8H6o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAeSjfYQsUDOt4CAg/FDmhxgtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI3NWM4ZWYtZDdiOC00YWE0LTgwN2ItYTdmYjcwNTE2YThmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYjBhY2EwZC02ZjYz\nLTRjMjYtOTE5MC0xMjIzZjU3ZjFjMjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQEKiZSNUV7bvL9WVhkDipPonpHx4zVmi4duJ6nhvXfS2cIIB8/0QYOcDMAZzOW\niu/x/Lc4yl8B9R2Oqf3e2bI8o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAiAPGvaotNt6E\njCi4FC4nZtD92DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBklnrFxA91cotWx7kYci/4igphpRJP1VLepcWk6NOX/wIg\nGfsciXrkBkiV0P/fN05lZqqaodcH8WkXHgvDYiJlPeA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7653", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7653` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAUbnjBefLuBaV9KwneFHmAATMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0NTE5MzUwLWQ3YzEtNDZiNy05ODY5LWI5MzE2Y2FlYWQwOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY0ZWFjMTctYmNj\nOS00NTkxLTk3NjUtZjMyMjQ5NWJjYTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIi8nZrBijSgslwB7HERzea3ZtgwziYDsPiE1WfkmWzftmgUKsQ5Nb1ABD/Kj\nLMl/oTNUaKxDsddbXk1HL37s5qOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVrCUPaE263QObv6+WVPr71OeXnswHwYDVR0j\nBBgwFoAU4STRq6SBoYoeYExwjleoI9NH7oMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNH\nADBEAiBjlnkzBRaqSGmvSM0P1rk56+pSj4rBV0tfwJ8b+Iq2sAIgaGRnfGb+FOpI\nbEWUOO9ucXLa6aXr5SHMG4HqIYp6ZOE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW7U3skF3D9GJv5t8NHZPZkCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDUxOTM1MC1kN2MxLTQ2YjctOTg2OS1iOTMxNmNhZWFkMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxMnZ/pRnThammjoMohKgcBoZ7zVrDl7urYUDH790t+L81\n6m/W8xaxfVc6NyTjio2ZP1ePnsqADxMaHG3MEo8no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4STRq6SBoYoeYExwjleoI9NH\n7oMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF7aqve5hCPX1XyfLSFfayhcsGc28fNt8bn61my9ae5cCIARWGqODippP\n170yx71E4wmAl80VV8qrX2/Gv6CPCWJ9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbLjYQvMbNW1jitGRgE0uDEvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY0ZWFjMTctYmNjOS00NTkxLTk3NjUtZjMyMjQ5NWJjYTRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYTU0MGNiNS01ZmQ3\nLTQ2ZjItODg5Yi03ZTE2YjEzYTI3NGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQsIgjLQYfRFcqJvkrR+Mp4paAQnaBLdKM1/+lJ0i6ch7vdkkb8MfvVvwVwzZAA\nmLmbInUJiBRZgBPACMWDDXIio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWsJQ9oTbrdA5u\n/r5ZU+vvU55eezAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAhv4pkwF8zCNw8VlD6M8D9pDUYlHRNlBBrXGbq1ABer8C\nIHwWD9q4eCT/TzNExvLRXcDEuowTN3ygyt0btjRSzzCp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7654", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7654` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAf+F5N2BNOWIxUwnGeheN8pRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmNzRmNzQ5LTlmNWMtNDZjMC1hMDViLTdhMjE5ODI5YTZhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjkwOGI1YmMtMzVi\nNC00ODFlLTlmMDMtMDgxNWE5MzIyYTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkPUXrIRAuV6ujSNZL3FU+oT/Vi82XMVqqWTvq/rmJv5CqZmyt0zUR8Z2yYER\n6kIxkSmNHEFqDa2QtgipevhSM6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA6wEWwGm/mpmZsFXxrz3mi8kKjUwHwYDVR0j\nBBgwFoAUp7XfkQQpj+4HQfMo+iO1TM5usXowMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBZ\nuAsHd7uxOC0XnvNyg+hMCVnkpqQLmaoMKp1gexg76wIhAMWhFlMIRMOPx2x6K9lw\nIKcAFN9NgthP7K5bsRzN0NM+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbIcwkIYe80a1qkGo7iYnHVfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjc0Zjc0OS05ZjVjLTQ2YzAtYTA1Yi03YTIxOTgyOWE2YWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMF8Q8KV0/B7h/CP5iFFyRbRQQAAdXbl4vMX/fpkT2Bg0k\nr5JNd0HlV2RdY5pcHaRZ12sgmXpZwzEl3Xz+ydxMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp7XfkQQpj+4HQfMo+iO1TM5u\nsXowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANH7youf4L4mU6fveOGe3PjQYNjkk1BFLSEf76OqCfk8AiBH5v3nfbDv\nEeQrkEuC5oDEzVvml7tq7A2Eu32aH2fjOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAUKtvyrC7sjomhvN0l7tQYf9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjkwOGI1YmMtMzViNC00ODFlLTlmMDMtMDgxNWE5MzIyYTZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNTI1ZmU0Yi0xMDJj\nLTRhNjgtYTg3NS0yMWVjZWM3ZGVkOGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATvZ/0NmTHjr2+gC3FLSm/xsoEwEL496iNm1SWYCD7guQAEbA77xZ9gAy/uvCiD\nacml9eRXtCbNAMwVmEM/mGPqo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQDrARbAab+amZm\nwVfGvPeaLyQqNTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAYzoRuiA3Kcn7LGlnYOQlmLURPJ0x2zsTha7OwKKhAmwIg\nXggRJ3k+LZ5IMvkr9yr+QFlCEXE/qPck1i9UOf2oyjY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7655", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7655` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISATc19PeMke1AjghDmCCjXxupMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyYTQ3ZWY4LWQ0NTQtNDA1OC05YWMzLTZlM2Q3ODQ3YTczOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWE4OTA2NjQtNTI5\nYy00YmRiLWEwMzYtMGE3ODg5YWRkZDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqe9bHO8sv+mXnYtiZCb68ZePCZSeDBpXzVXSGBn2U0lWe34VYxW/hS/Tx6a8\nbRJ2CVhsbg/51Rut9TeTBieDvKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkC4nNhcRX1GpVHlZzGtTRbkY/dUwHwYDVR0j\nBBgwFoAUN7kx34fSSa+ztcn9lCos4alRRqgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAvWk1oH9PsjevJccQZoyt9P9BBNQWTbkr16EfiOIFHi0CIQDX\nWLcr0cUiUwOMEBpWmeuNd/DZbTug6YvzQDJ7VzRAnw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVCS6xK90UmgzYjW/nxVoixCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmE0N2VmOC1kNDU0LTQwNTgtOWFjMy02ZTNkNzg0N2E3MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0JsATJqmauOkvUCFRIWkk3pqBQERuXFlrHvUOANJW/aiB\nIYjVqvXHTHlLFHa0tC0skWXcXJ+zxyxNmXhXc3Aoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN7kx34fSSa+ztcn9lCos4alR\nRqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDw/9+EdwWSEc17907ayBp2MEsrGcD9hA93AkoUjqamQCIBJ9soTBJtxP\nzDoOIJEaP7FukZl9pvK3Cyx6wxLCKJhu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXWOZ73pZYF/ks6FwF7zIAMCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWE4OTA2NjQtNTI5Yy00YmRiLWEwMzYtMGE3ODg5YWRkZDg5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNjJhMjJmOS00ODZm\nLTRhY2UtYjFlMy1iNzQxZWRkNmIzMTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATXMhj/shjQ5lj6zVExI7hgdEe6YU99NMLZFnu6a8AiV27MR0h4txZ164C78EqB\nRzphxEpKJ8jJA+xoGbcHIxNoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSQLic2FxFfUalU\neVnMa1NFuRj91TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEA45Pz51ddBxpxkA7Xpifw2i8Y+S17FbXZYPsilmFLiD0C\nIGhixnQizlNdNce06D2g1ik7Dma/1CRo02buOxjmIr/i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7656", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7656` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAePvh03Rv/dVjbHeijddUe5XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjODQxOGVkLWNlMWItNGYxZi1hMGI2LTFjZGRmMWY0ZTU0NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDk5ZjFiNTUtOTRh\nYy00YmFhLWE4MzEtYzM5OGM3NWJhZWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE48PJg8x+8747iymdzHAhTCDPfUZdF7nF8JtxpPO8f8oZS6m8a/Nmy6EBfuBZ\n2qo82RqZSF390ZKp2CmXaWG2i6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6CafI3Z0U0rFt6inix3NceSY1F4wHwYDVR0j\nBBgwFoAUPLwfvBfmTi5oqrOGlntq4qGfKskwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAtNTWRvc1j0y+SrfhawEZIe+WWTOBfiituLvq9RC4iX4CIQC2\nyrRCUL6pbVwoaJNSaMRN7ltH/za5l7SiBDsJBAJYYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAexUMv15FjIU3DKPdrc/kyutMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzg0MThlZC1jZTFiLTRmMWYtYTBiNi0xY2RkZjFmNGU1NDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRrM2w7fQi+Hs5X/va0rr/v0leQhZE73YDUisH4IsHC0ZJ\nC9ZPagCQi/Z7bCxORsyNfLSx9H3CPH4i/8rrKpIio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPLwfvBfmTi5oqrOGlntq4qGf\nKskwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGDn4Op5EDGsyexg29fg7Q64LgXWC3NuRT7EYhfblE/wCIQD7UYvUBuNA\nfHn559rZnOu83/2z+PCFay9y+H0sJTA3IQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASCP8w/xUjI23OlfMzVZo/VFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDk5ZjFiNTUtOTRhYy00YmFhLWE4MzEtYzM5OGM3NWJhZWEwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0M2I4M2EzYi01Njk1\nLTRlYzAtYjIyZS02ZTY3NGM5ZGZmZjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARpxEETw3ed8nB4AiqDe3LL8nAhXoar+f4ggIRWIuZBxIBHT1NFQnXIZ3f8YNxK\nihkp7vsLHNuSFD2E5SvgTq7io3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBToJp8jdnRTSsW3\nqKeLHc1x5JjUXjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAsi25o9CEJXLBD4J32cJxth/hsJfeauEExX3Glj28tUwIg\nKvVlOFGpNAjgHXtbcafZNvl6uo1OrzIJwfL7Kmhdye4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7657", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7657` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATSiFpguaBlVeFKTKpJaXe84MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczZWZjZDA0LWNlMzItNGNkZS1iZjlmLTJiN2I3YWU5YzEyNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU4MjM4MmYtNzg3\nZC00YWVlLWI1MTEtNWY5MWJlNjBmMmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElpxT8n4c8OL6Rxf4X21WNPOWA3CHem9dIv3NPP6M6fugX/rZmNczvxvWT19Z\nK1SSYK4C8uCng2xTa+/AeE8OUKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMX29kCmCXvs5kBZNXnVidv3akcwwHwYDVR0j\nBBgwFoAUgrrhk8d2dXyo2JBh0siAXfuxvvswJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA3U24gEWbQl7V\nNRIiJMnZ3saV4FFg4tXULrtjHx5Z26oCIBARISYa65jyJ8ZHourOmhmGekKsJsun\nbsk6AOgOFxWl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbqwthdmBFqlbyMq8FNd/3AUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2VmY2QwNC1jZTMyLTRjZGUtYmY5Zi0yYjdiN2FlOWMxMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsVTsvhKImNGjoZhXSNZt2II7mjg7nbX0XR3ljvlCXZjhL\nfyNO8FgQns5p73Yh0guUC+yOWl4bQMUqqqwTtkA6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgrrhk8d2dXyo2JBh0siAXfux\nvvswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY4pC/hlBrLb+h0JmpeIsPQCF4zH4GMKg0DwzGcEQEV4CIQCVFaZxD+Bu\nV5jqsEHvh/UQnBwSMVWucFTwqs6vZW6OfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASiGM+m6tI47GwdfhqdD1N0SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU4MjM4MmYtNzg3ZC00YWVlLWI1MTEtNWY5MWJlNjBmMmZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OWIwYWQ0MS1lYzZk\nLTRhNTctYmFiOS1lMjY3MWE0NmZjY2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASVpeMhS3by9LXrxCoHAx9K5IOWuUeyHngnwuk5i/QKOKDh0cQvtm9jm3vKtkbb\nfMfFaKnAPcSQY4afI5NPWg3Ho3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQxfb2QKYJe+zmQ\nFk1edWJ2/dqRzDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAyj3D3iWQAGbnF6m1TBKIOT/NYMMRZj5ZQ+skl0trdKoC\nIQCRU7y3UR7oIejF7mOzA+py7U+2WrXc/AjDMHQ6WnKfxA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7658", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7658` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAeSfp8ncndqqo1KEwtn6NL/kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2ZTFkNGMxLTE5ZjEtNDdlNi04NmM4LTViYzNhZTU4NzBjYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhiOTA1NTQtODk2\nNC00MjJkLTliNGQtMzIzZTVmMGZkZmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf1XRaQ/AaOh2Cbqj5VaGCS5WwLm4Nk7D73kM246Vu/dWtPdGNySg+eDwb18p\nrZewouKyxI7iLRZksnCXZCamdaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWKJfeZMUYZhRDVzjcrHGzWEJQRIwHwYDVR0j\nBBgwFoAUX2BNu8tK91iVb/XKuT/q1yw6QxMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD8ZvJQcJoa0E2Y3UGZIoN0JuuMluyBHW25IzG+i/ZgcAIgLtjpFEKRXlCP\npuKNJjzFV+Qp6h/6DIlgG9A+7Fjw0Cw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUzm9MvD1giuDE2TFAPCew9MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNmUxZDRjMS0xOWYxLTQ3ZTYtODZjOC01YmMzYWU1ODcwY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQV26PXWNALqhfiRXjUxw1omRpxP5SCKfQyuWkTZEWpHdw/\n182Ffk8tUN0KNn0mDqjZ8MC56JHEtBe5IOGtMXJNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX2BNu8tK91iVb/XKuT/q1yw6\nQxMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJo9tAeYMEn/xU05LfzVRurG83yNZG9f9FZqCZPXcG33AiAg8ihJMoD/\nEuXxgfiPAlhvqOAt20BMu0p4IC8Qoamm7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZTUsqDzkYO5FInQOCV5nXqiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhiOTA1NTQtODk2NC00MjJkLTliNGQtMzIzZTVmMGZkZmM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNWFkYTNiNy1hYTA4\nLTQ4MzEtOWU0Ny04YTgwOGQyZDk3OTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQRYu1pwtoGDRxhVT69HpS21aQZEiHiGSqz+I5j2UhF5gRAmBOWGruP2EGFnICN\nOKxMc0UW5UzaHiCX5j0qvP+Fo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRYol95kxRhmFEN\nXONyscbNYQlBEjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA8NqOKNbGhBsSO5rIxCctiCkM1ntAo4dEtbZuTgucX28C\nIQDMRTrqPC/vX8BSAx+72TSoybesMyt9S829XjWii8Yg7A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7659", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7659` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISASzQdS+X1oDdwQOpWn5YRqE6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiYzRkM2NhLTlmMTktNGJmMi1iYWFhLTg3MmMwNDM0NDg2MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWE1MDdmYzQtODIx\nNS00YThhLTgzM2UtOWU1Mjg1NmQ0ZjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1+sgp+UiJI75+u58OnSnkitOC1nIB7EkAZsiwO81oLMzNakKCDVWm7XAHGnO\neioNax/ubZJmOs0k86uPAqz7CKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHQdVJUfI8AuObX+lVhldkbiJlVYwHwYDVR0j\nBBgwFoAUP0KZ64EEymzRrRdgDJ8sVet9KNUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGJEEo7bmMKynxJNwu2h0Q6yGjzkKVXyOOXw2Sxvsb8sAiAZNJMO+okHTqmd\nLMDxW2mBqJJSnZAOuvRJG1awxKAafA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUhp1C3iO6MSDVhw1Z1g+n/eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmM0ZDNjYS05ZjE5LTRiZjItYmFhYS04NzJjMDQzNDQ4NjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgYTaro9E9oqUp69pUOB11H8ivjkBkaCfteGp2C2D3WeUe\nORwK6c6U7BJgQt6TZmVtWfyf1u9/ZQn67v4//JjDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP0KZ64EEymzRrRdgDJ8sVet9\nKNUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALHUYvLZU/xautKJYbaXfyliY8gzP2DIl9dJ2CmhshH3AiEAiHRHN4Xp\n7+6oKETvy7Z4kaTUGB0V3ErioymFZu/jN18=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASFDGFBreDPszfnANTubUq2hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWE1MDdmYzQtODIxNS00YThhLTgzM2UtOWU1Mjg1NmQ0ZjM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMmU5ZmM3OS04MTFh\nLTQzYmMtYTU2Ny1mZGQzNWU5NjQ1ZjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQvKOwQwF3XYyADKxm6mhhwoulM8QxkKn92IsaYkzb5dOUmm/XGwEM57hsLrWOQ\ncbJvgtq0dGcwhbENfsX39xiAo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQdB1UlR8jwC45t\nf6VWGV2RuImVVjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA3YrKsWzG2jLQiym/7e4uqmmLyDaFfnkN6l/gS27SyQQC\nIQC8ZwKwIUy0eYQqtGGXxutTfRRhQkQ/vcqGzUKR5d44TQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7660", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7660` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZ1XyG4j0CCZS0mB/XB8KRTAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwMGZhNzEzLTFkOGItNDk2YS05ZDA5LTA1ZTVmMzEyYzc2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVhODIwMTgtNGRh\nZi00MmExLTllZjgtY2U0ZDBkOTNmNGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEISH+RioG22+TYA6a83GQngDOdOeIayekF7rRfZ8arDkli1Ta/HmJ61MMmaEJ\ngaE0G+zBg6guzMLMHwSNhKataqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsJzxAj4UITEAWZkRXPYbH5FZKucwHwYDVR0j\nBBgwFoAUNhqcT7+myuXELb6tFnUiCJ/uMA0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAYwn2dyWaFFfvfhxnmQ5l8eP3HKFTnia0dSDBlmORiMAIgcX1mAqX2XccQ\nrQqpKykKpydkHdK+B1+3n4Q0YXEMpok=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVQepEG+5zPgV+gVA1VSX7hTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDBmYTcxMy0xZDhiLTQ5NmEtOWQwOS0wNWU1ZjMxMmM3NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoWa2sv9e9MFu5FIfaKQ18bJfR35ABsPOGxUWwD9lrH92O\nVNcqpxX08gCIXbphfrO9BZmLw5pD/4j2g6ldMxPLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNhqcT7+myuXELb6tFnUiCJ/u\nMA0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJqTYMOwHn/TBIoN9ERLAYopyVeKG2UKx9I8aCMEPJ8YAiA/+MnPnYZA\nc4VjXC7dfsaYYiAj3y44BTHkAnSVMDoEqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAb7M7XCsednWMct89ECWF03mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVhODIwMTgtNGRhZi00MmExLTllZjgtY2U0ZDBkOTNmNGNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZGRlMTgzMi1hNmFj\nLTRkYjYtODRkZC0wZDc5NjI2ZDhhYmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARRQE0pexYAbXzphKdo+tC58r84Csoz1WgaSTiz2DCHk3Y29Zqj1ICxzmOt/tp5\nSH/qft6w7yeU2vpsojGsbnnQo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSwnPECPhQhMQBZ\nmRFc9hsfkVkq5zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiABIFAo7inXXcGIMFxME9fbAff6J6SmDkXIT79CUq355QIg\nDr0NeyWr+BnBza/XfUwrjFgUb1iGqQr7+MdtezLN6j8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7661", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7661` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAVJMD1OCZGsYn9VcexYEgegVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0OGYwZDQ3LTk1OTUtNGNiYS05ZWYzLTUwNWFmYmIyMmM1MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFiMDIwN2QtODc5\nYy00NWMxLTg4NDEtYjhhOWMxNzg1YzcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEak41OOpdK85f7+nTWZp4vEXKwXdcM3hQS/a1/zUu+o7fsjA3ZP9XFdq4rsdq\nOkToVWkKHdtxUJnca8v3AMUP6qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb6UIFJNGzOPYdxOSFVyXVqfy9OowHwYDVR0j\nBBgwFoAUH12RoHXVaVE9FhWZOk0Zt9MAvzYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAzGNSeif+f7+nbmPrjUKoISDmELydDHhaIBLYRRcP\n5LgCIDt94wni23usaGISDiIEPnAEqmgsyFiReIEGOADz9aVC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWy7IV8SbbbBDXom5qsCyCN/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDhmMGQ0Ny05NTk1LTRjYmEtOWVmMy01MDVhZmJiMjJjNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOLoE9ongTdKrHiXUeHdXeXTLbrEKJIqFuoPbTMj2VPxnI\nGiSKk6YN6XguTG8pRvG5bMSGILjj+2ZLcxeK2VRWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH12RoHXVaVE9FhWZOk0Zt9MA\nvzYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC4aTh4JvKWg/jySFntXmuHuMTWYg2TvW3usFHipcQo8CIQCLKctFv1dO\nSmqPL9Y+r4z2zIa9AhE32V8RtNmO/CCH+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWWgkF6QRkPhzNiq/+Qec/EaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFiMDIwN2QtODc5Yy00NWMxLTg4NDEtYjhhOWMxNzg1YzcxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZmJlYWQ3Yi04ZjVh\nLTQ1ZDctYmQ2NS1lMmVkODZjZGFjMmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATOyq0roeOfJTTSBlhZdEM9MFXtjVWwFG6/KL9lj0RFncoYtMaqW8F3L395YT+s\nZK5Ii1MRFXAy9AfP13gKRZfZo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvpQgUk0bM49h3\nE5IVXJdWp/L06jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBPcLdAvbhrcyeXWKbO8WfPxg6yVj+hgpjKmqScmOAZmgIh\nAJjLKz+l6h7FnNzk/eyRYgpDP2jlfId4ZTJcQV8J2gwA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7662", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7662` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISARdrpcp24DKMG9hkRB0yFrAsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlNzdmNDljLTA3MmQtNDUyNi04MTIzLTk3ZWZjOTkyNThmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU1ZmNhMTYtMzNm\nNS00OGM0LWIwNmUtMDIyNWFjMTYzZDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPJYuajBUaGHonceI9MjSi+XHcRldH1IX5xyy23yIPoN0+N+YEwP97VFUFy/S\nq7oXLJHKXPOcbmAlagOcIVxpkqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtPVebiRwjzXQNh7ow3sxHJwpn4owHwYDVR0j\nBBgwFoAUCL7nHQ84dxgKkSsI28J+zy7xgN8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA1IyYKqlYgzlk1sia28fWS7gkgSI5QHo0Z2GsaPUh\nVCICIQDd3Eny/5YfjLS/RwxwJLDovnQjYYyZWA3XRdfdoQqXkQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcHd2nOFUco8xblUfQuqOnjeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTc3ZjQ5Yy0wNzJkLTQ1MjYtODEyMy05N2VmYzk5MjU4ZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNP4Uv8gTEXRb+QiP7FRotSR/Oy2ZfokExhfKJyfNXSHoI\n4y88SyRRJU+ulqaj1xcwczq3zmZq6mVCXoCLieUOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCL7nHQ84dxgKkSsI28J+zy7x\ngN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHw4thH+u79Ms3cRmOeZm8jFPhL1e+ChXXfn2lE+QmVsCIBulrcqMm7A9\nKhRIaUO4OfRb5bly9Jli6If0inKkub+M\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAftnrkBdxOU70QbSPx43jNShMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU1ZmNhMTYtMzNmNS00OGM0LWIwNmUtMDIyNWFjMTYzZDkwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYTMyMDExOC0yZDk4\nLTQ5OGQtYTMxMy1hNzdlNzMzZmJmNTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARk02eBRUz86RFfsA6mqnUzHgV8Z2DP4+4u+bCWdUpSoAmnV2I3t6TtM0VQm68a\nf91wBDy/A3Wa+jbaWJETVvuSo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS09V5uJHCPNdA2\nHujDezEcnCmfijAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAj8D1b3SuNnaHtMvbAkM8LSiN03MjDHb/xMs4b800VcwC\nIBILegZ3RGrV9fU8r1LnHj0gEx/RGJOIqGL//StiAgMR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7663", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7663` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISASUbdP988ZALtZ2CrmQNpey/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyMWIzM2RmLTI1MGYtNGYwYi05ZTJkLTYyNTA2Nzg5YWUxNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA5NThmNjEtNzQ2\nMC00YmQ3LWI5ZDUtMzJjODRmNjRjNjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEliwqAFg5Vu4U+5F8mKAsLqhdsGbvCjWYYYb3L/4B2O88ireZLdAKcohxw4mP\n+s/PPjNYx+T/ZGBhyAmj49kBJqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxH7vG+XX20m75etRW+9ZC/sv0aIwHwYDVR0j\nBBgwFoAUFg6FvI4AHZtSeibshvZNqQeT0DowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiB2Qw5rrQasFI9wNBNv83HAfdynSEFAvtEESTFe5DWzXwIgKxvv\nPtVZN0ktAEl6vrQ85Hw4U6zETwMBy3YoDGwi+JI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbjFoD8D/2nR0k+PsC6Aft0qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjFiMzNkZi0yNTBmLTRmMGItOWUyZC02MjUwNjc4OWFlMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQo8rTFijY3GqTcn22dgflhTgVyZjC77cFKHLPLCduSX4H\nRp+bPNgcRiLzvcz+KSSYzkA6mz784f1MUELFMgK0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFg6FvI4AHZtSeibshvZNqQeT\n0DowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPHCezGhtxLGpKjFIbbBnUBeWwIJXyqqpBpwZvmoYTOKAiAp7T3U7Y/7\nTfoMN4idZrrnvrC+F8d9zrP8UOxCuWOTYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAULIpXLXFs/og4K/JMoXq1DTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA5NThmNjEtNzQ2MC00YmQ3LWI5ZDUtMzJjODRmNjRjNjFiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNjhhOWMwYy03NTlk\nLTQ4NWItOTlmOC04NDBkNmEzZTA0YmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ0WqhPYAFMwUH5O2S/2zDFgeQUvu/bSLKyYReIbKumcvdSXDW43xxZEtNd5v8x\nXsoydgjBwpiaeTv9z593kHUuo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTEfu8b5dfbSbvl\n61Fb71kL+y/RojAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA3aBIii1vFVtpo1WKISAoZRGv+Zb6jngQCy4KnFXBkIUC\nIQDzk7tTL9oSv0gN0X6PhgWPw/mHVAmgooAJ/zJ5aH8g5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7664", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7664` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAR1cON7Q3yX+737RxVge01XLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3OTA0Y2IwLTlmNWQtNDgwYi1iMGM1LTVkMzk2NjcyNjRmYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgxMTkyNDYtZmY1\nYi00ZmVlLWIxZjAtNzFkMTI2ZDUyM2I4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjh+bS37U0EQVzJtvTMghuOtQfmy0VT873CXMokAOvKzyasYKneB9WLiRAR8R\nNNEZqAgG9p+9YO8es3ZD4mWo06OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhUBo2nV2ittAZ6X6PPLt5oBh8xswHwYDVR0j\nBBgwFoAU5YcCLlAwrpo8dx2QRVER6yYCQ6owSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA5NQZARviRIaI2Ib7Qg5smCw22DVU2X5M\n/gAzwExTzBkCIHRCyed1W6Ar5ZMHc71DImbIYpBpIOZNs5G95xyS1+Ot\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbL1wfmPYXiF1ChEkAv7uFLiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzkwNGNiMC05ZjVkLTQ4MGItYjBjNS01ZDM5NjY3MjY0ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9mMs20UWmfAlZrz5eMmlhG8VnOfKsA+XaQRB93zBf0UO6\niBt+Q8lyQppdDK6cVWUHxyktVakj7WJ+x0PvPMx+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5YcCLlAwrpo8dx2QRVER6yYC\nQ6owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN4jmBNvBv11ATADML57qzz/miYYXrWX2RR5RcAI/7uwAiAVCvDgA5NT\nncnY65M45nssHYxPrBAjRqmEYoG9Hhz2qQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATT5sI2jCUGNYwwepdnFqGBMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgxMTkyNDYtZmY1Yi00ZmVlLWIxZjAtNzFkMTI2ZDUyM2I4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZWMyN2E1Ny1jZjE2\nLTRkOTktYWNkYy1iYWE5YjI1YzkzZDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQWBNHcKu7uMp+ZB1HJG8yhUgVU8eRqnkHPljihP8u4yyP6t+IYqSNjHepEP5Cj\ne/dYOTwIGAsqbccgukyAoC9co3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFQGjadXaK20Bn\npfo88u3mgGHzGzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEApj9FlJBsPVhufxzezEV6cQtJBdauqZ+wP+Ifyq3tNRcC\nIQDYEsrAntKJf0Z0KEeug2RX3SExCdAnV5ie1lVHdGXc6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7665", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7665` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAQ2H+TQ4BF/I2AtjgrCxAkNrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlZDZmOTJlLWM2ODAtNDk5OS1iNDIxLTc1YjQ2ZWVmMDY5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRlNTFmNjYtYmJh\nMS00ZWU4LTljODAtNmI4NGQxMTJmNTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjwqUz9guygc2LHuCDlfVdFHeh+FK2qTSPXi793Or+x4hBefNP/pN2gPXaFpy\nyJX+6pVLgTYfLZyKRv2KAh4XsqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnTNn7jSZla1GBdaMWGAEjVcQzn0wHwYDVR0j\nBBgwFoAU48yBFaDU577H3qkwcBaTXth0Ja0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB0wTwt6O5HyAdwWTwVP5KxqKz15MwSoDvU\nodNbENuA8gIgVx964RX4WGhVfljFaHH6ZB76Qh8ISmq8ePiqzhG51Ts=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeczRa4Z0C10Fgg0r7ypj8E/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWQ2ZjkyZS1jNjgwLTQ5OTktYjQyMS03NWI0NmVlZjA2OTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5vxdIq3dpoud6FgvxSMZ7oNJ52jR7x990gihyZ4wwZCRQ\nHPC9b4gBSRz/+ugfbLChlrLrEfWEKrWqQ+VJq0mOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU48yBFaDU577H3qkwcBaTXth0\nJa0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQKMjbdh0m8AkDGkiDNAC6wqMu/w4b1Ho7mKVocuey58CIQDDoSldnkAq\nPiYYSWGXbpNaSZ065/jkr4MDhWVMiIQbYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAchBtlLMJg87sQGZwwVeevySMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRlNTFmNjYtYmJhMS00ZWU4LTljODAtNmI4NGQxMTJmNTkyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYmE3ODkwMC0xOWI4\nLTQzOTEtOTc2ZC0yMDExNjhlZWE4ZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT79BiR8+tLm6yntFr0kGlBFfF11uYmwmWsKMUeJIJes2SGmb8fNIRIW609/+3f\n+x1GR5LC+mYZk50GeUR4wJpqo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSdM2fuNJmVrUYF\n1oxYYASNVxDOfTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEArqhU5mhfBReCRcdagy1wp7EQkZD39NTCUVlZXjuMMM8C\nIQCXnmcu0Y7o4sqsjv6Cf0/G/nCWqNPUXlXvt1+Ev9D1GA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7666", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7666` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAT8HJkmcC1lRZtGbcLCz5sOkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3ZTE0MDFhLTM3OTAtNDVkOC04NDJjLTJkMTdjOGE4NmNhNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMzMGNmYzMtNzcx\nNy00NDg4LTkwODEtOGNjNWYyNTgzOGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAutUcyQOLL7xsqSDOyLaws/Jqplzfr/TgVyz0Uj3cSRnGJeLLHbstN/1pL6p\n19UPLEwb+f2yD8SFxxrP26k+CqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh5lEPuhLA8SSJ3KM6oI0kBwmKnUwHwYDVR0j\nBBgwFoAUxZhr/PaqBJH6TegI/XbaYEdDLmkwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA3+mgIGSiBS+H\nuar5tUayj/QWJ47Sn9hpOcnj4pTRTZoCIACx997aGeklq/QZhcHimHJjH7TpBclU\ngucwZEzZvpeF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVqrd9a2jrZmIJOsNo+KRyvrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2UxNDAxYS0zNzkwLTQ1ZDgtODQyYy0yZDE3YzhhODZjYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASK7xyh76BKIkb6vtxI+JKynKt0FEVWxhnr7EZPv/o8phYU\nvibmiI0Vx3a3x2d5bz8XXYhMT6sJfvTgA4WK7nUHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxZhr/PaqBJH6TegI/XbaYEdD\nLmkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPXWPZbb5tXzj6pzATLIWqPSF5oBL5XR6QGNHa+rfQbVAiBN4HKSqvIB\nRelGxETOsD99KDaUQSN7jm/K87v96GbsUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQr9uM2JmbS1GyU19ApgZoc+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMzMGNmYzMtNzcxNy00NDg4LTkwODEtOGNjNWYyNTgzOGM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNTI0ZDM3OC00NmM2\nLTRkYjEtOTZiNC0yYzNlNjNhNWUwNmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATwQZL85Ywl/sOrCHjYWGSwcbgbgbEzr1fjj5XFUe99l43loEmbsj8mBxOe8wfM\ntMNHaDiJa8vcChqSrlx9QjBxo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSHmUQ+6EsDxJIn\ncozqgjSQHCYqdTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiAxi8G3G5EKwvfA9h9Txwm/yvXjGSE5JYVBoIcC3UwiVwIh\nAO6VjQ2e2iNqNJNgk0KNW+3h/FBzAB/6j+Qfvq1d2ahH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7667", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7667` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISATWtWh0tZHvfgbBsYH0Uxd4ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzOTc4ZGRjLTFlYjgtNGQxNS05YWE2LWZhNTNjZWZlZGFjYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM0MGYwYTUtNzdj\nYS00MDJkLWJmNjgtZmU4NWJiNzQxYjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVcpMFo9Oah0jkrQUCvOEqx9MAw/LnMjk4pRhvr2GG5dNe3ffnnZILWLsZwrY\nHyYQ6Vr5e0XsKl1eWm/0gfBu5qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVQKXqg7VoCfxPeLwPvKAJp//RrowHwYDVR0j\nBBgwFoAUE1/r3CCpftRZps8Ui85ufPjXJBMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC+6LaZCml0CGXssAEWcTp4E3qdO4eagin6lya1lusFYQIhAOio1KHOi/ND\nLRN+CLrahcy3GQ6g38+yYpjkN6eyIK8L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbJoPMXS4m1nARwvbNB6AiJhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzk3OGRkYy0xZWI4LTRkMTUtOWFhNi1mYTUzY2VmZWRhY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOHgewYJufZ5fVtVMKmpjfOAYp/36XnOMVEAed9+sctoDT\n21oCaSZJOvmjAGwQN6eeKnIrB4MSvFJaVZk6ovc9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE1/r3CCpftRZps8Ui85ufPjX\nJBMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWvAxo3rVjvEOoPSy1qK58IYkGbgDKriIIsNbBxdMye0CIEGY2yEIkKja\ngHh95oKFSJF+8wBzqJPttNP+VVVTJyO+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZ5lUiHwBrWmDXf+8chVKzE0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM0MGYwYTUtNzdjYS00MDJkLWJmNjgtZmU4NWJiNzQxYjMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZTM5NTQ2OS0zYTYw\nLTQ5ZWItOGIzNi04Njk0YzYwMGFiMTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARiAyyibnzSgUOg1u02cSCQMO9wnSFmTPcqRNRzyCJEULL8u1k6H8/3VgN2lHe0\n1PKvr/hq6nsLu95xWy5XYIbwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVApeqDtWgJ/E9\n4vA+8oAmn/9GujAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAzJ2EUVPfxDUB3YSpH//QiJ0HVrSSlDwvOpQPFxbzAw4C\nIQCr0rC4LrItINymNsFHq1+gHUD4JSEIIdeK5PbhRqtjNQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7668", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7668` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVLhQ9l3v9XnlRlYod8+KkApMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0ZGJjNmU4LWU3MzQtNGJjZi1iM2NhLTI5N2I1YTkxYWU3ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjczNGZmNjQtYzYy\nMy00MTU5LWI2YjAtYzc4MDZhMGVmMjJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESeebwVHlfW+edxCQ51Ah2PSCxG/fBOmNhJv0VvYaZWifijtOoSUQqwd18eys\nw4BlP/BAge3XiC3/br6Rjel7cqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR4VIBu2zWgk/8PW9RRoyNZYa4CMwHwYDVR0j\nBBgwFoAUcOBcDowgY3FYeElxdDly8JxeWJswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFoZQmYAx//PhF1h2gVmVbXIWn0MJCKW+QchZkI5l4q9AiEA9q7oWkY5H87Q\nxvSLn3yPte4WWfGMFlmwLkcjvDvEdNM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAREykVzicvkBMFVYFJR9K94mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGRiYzZlOC1lNzM0LTRiY2YtYjNjYS0yOTdiNWE5MWFlN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwqyuBmRvP8ieScFSUj67mw9cBLKkHpm6urliXaEUbxxMM\nbjw89y0z6mUjfMNsNUnXPG2CaDXmpa2096FJA2sHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcOBcDowgY3FYeElxdDly8Jxe\nWJswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDhXPcUB0QruJUEnW0icy+bHz4pVfZCI1t8kCR7KwpTgCIBMqjj1/JHbD\nA+B8frizGMxjlE0lE+eZbe1s/X2VT9B4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAcfdQ1CRRGKP7HalFBRfrASxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjczNGZmNjQtYzYyMy00MTU5LWI2YjAtYzc4MDZhMGVmMjJjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYThmNmY4MS1lZDUz\nLTRjOGUtYmI4OS04MDVmOWM1Zjc2NDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQibJldEMm84iMt4hY1XAF9KJMOXc1stbbIFqtK5s26nYcACboASZ48PVQMgLFe\nxslRo2Az8hS08AL0VtlsUIn6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHhUgG7bNaCT/w\n9b1FGjI1lhrgIzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAmOml72AXNdBbVx4xx23ofYK35OaLjrvw31gR8rzqFSkC\nIQCVH0kEt2Z5q+MTIE+hc+iN+FZaTo546x6eEGXj6F8ApA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7669", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7669` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAcgRN6iFxxVUii5pHF+hBnwqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkNTA5NjY0LTFiMTMtNGM3Mi05Mjc1LTg3NzFhMDVmZTNkNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I1YTI3NWMtYTkx\nMC00YTcxLTkzNjItOWI0ZjY1YWE4MjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMp9onDSNGgTXWLrax9W6Eyz8AxU9VNXzppJsU+SAKzZcISY1xiRp2+eUCelW\nn/S/E/58OQuCzNVoiOeN9JzuW6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8o73xmrexlBCaZdB812R08h/Z/gwHwYDVR0j\nBBgwFoAUF1oXmNiq8arkhH6n0lM0TCsOWNkwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAzNwfYKF4/6SW7SGA1JfqD8DQBlpbTpS0BzW0fGamCEYCIBXPR0RXIEMJ\nIXjAFUSW2AqRTO7wJun2wvCIAQso++nO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf0lsiT19zPIvxQ9OCe6Gu/fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDUwOTY2NC0xYjEzLTRjNzItOTI3NS04NzcxYTA1ZmUzZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASf9g+ZSZMj5kJWu8kQmaqCBSDZhysLGTXOYkGLlv/bovX/\nXYdZ2Y3Q1bBovJBRDQFh9S0QpLTzDCh4lfyt+vGeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF1oXmNiq8arkhH6n0lM0TCsO\nWNkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALgRD+P37SrAuG/A5nu8nuDGBpOCUW7viMr+VkuQDsg+AiEA0QCjSe6g\n4Hmp6WYpjSh71Ef0aqcx2H3yFCtq4WJBn30=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAWR8I5N2y3tlhHvabDT6ZBdWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I1YTI3NWMtYTkxMC00YTcxLTkzNjItOWI0ZjY1YWE4MjZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YzdmMTU0Mi03YmNl\nLTQ5ZTctOWM4Ny0zNzM4NDA0NGJkODQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATCrvgrHEx5bPDAC7jiAUOu8hanPYlk3qBcaJezTlsxj3S41VhXbmxG9TXuOHoc\nirJU9+AInqpDEtjMK8vJM+Hzo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyjvfGat7GUEJp\nl0HzXZHTyH9n+DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEApYCdQjwEF8xtBtCkTfntfUV2m4B3OWkEX/q7yLKQlwMC\nIQDi5z2RJP/O4w8yD6CXyFwwRUad3Ida1wdYJmB5cJiGUQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7670", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7670` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAaDBSgNmhsx8QZWueBVWD3m1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NzcyYTJhLTY2ZWYtNDlmMS1hNzA0LWQ5NDM2YjI2MGFiMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UzYzAwMjktYzE0\nYy00NjM1LThjOTktYTIyMzdhYzk2NWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzk41GbHDmC5+gKc7OK2MxK12/tlqqsuh+dX+yTCcdPWatkfnlVrycPPHqDf9\ndRt8eDoEoDjAIGUNNGbBTSYA+qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUsGx9FLL2l6obAmtKQTZphoMDogwHwYDVR0j\nBBgwFoAUs8QuPN16bnbHVobJy3vF8xT5ET0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAnF31PIfT6Kw+5O1//AkZI3o6hDjYOwCYxl/2Ho5b\n7SwCICmq/YLcNftYS5rvlvkv766/kylBJeyKyMEHN3OWznw5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQySKJaDoCVPVqdjj2tC5nGdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDc3MmEyYS02NmVmLTQ5ZjEtYTcwNC1kOTQzNmIyNjBhYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGNb3oQ+3UaQ/kBvwEkcoOadF0BdRrorcCPQEK1gZ5oSsV\ntvqeJD/1S6x2eEsmZImdcR+bITSE6d6vjsr1uuYho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs8QuPN16bnbHVobJy3vF8xT5\nET0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgb+flXpENGZcSpUD/pWGQhENT27L7WTRNK5b5JyjjijUCIDggGCZsARSw\n7jjJRZF1g4abNLoqs+t+lXfhhT7x8CVx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfB2e/rgArey8nThhp7g+Ma2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UzYzAwMjktYzE0Yy00NjM1LThjOTktYTIyMzdhYzk2NWM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZmRmOWRjYS1mMzYy\nLTRiMGYtOTljYy04MjBlZjg5Yzg3ZjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARTAB4Fj9Nvvo++9xh9pw+lRzHAYkF4h4E3n7FIqdgsejUgZDGFB91KtMSdQt5e\nvf8WWnq5DRQMKycC+h+1IOBro3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSwbH0UsvaXqhs\nCa0pBNmmGgwOiDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAt5lD1SWau2yuxaXfzy++/2NT0rBz+QI9w0X3NxDXEokC\nICNXNtsiH7nggflPrsEr+rcLJog+AhVi5u94OAqSZWYc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7671", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7671` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAej2DX1So4u8psI+dO2NAqefMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzM2MxZjQwLTZkZWMtNGM5My1hZmEyLWQyZjJlMWZmMjUyODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWEwZjYzNjUtZDc4\nOC00N2Y2LThjNmQtNGQ5ODc0ODI4OTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKTKP0ITQPXGNYlPC0LyOLb/wfXVS5oAjK7BHzFe22B9jOF7pDZsggCg74OAo\nX8vOshtQGZ5Cz8VX3vT1VccVTaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYwYewnSpB3EGrVf1lPbQ1T3P130wHwYDVR0j\nBBgwFoAU8sFEHmqeqOsk8GD1dN3aWNue9JAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA/ANAm9h5PzQc389XAYxYT2QTZV56c3cFe3/S06cJ\n8jcCIFISLMcPgapiHlAXjtG3HZywzfoIDN0Adhx/iJdcYZoZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbPW/hNsySdqsxfrgkiXpUBbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzNjMWY0MC02ZGVjLTRjOTMtYWZhMi1kMmYyZTFmZjI1MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATi8nLdqtI2/DTxgQ1F/sVGtqjIIEuWVFbndm9OUrvrWHyz\nCh5C1qTE+pvT/njdtuvriisKMGnGJS21TUHpDjOBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8sFEHmqeqOsk8GD1dN3aWNue\n9JAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYX70XSNgdvhtkRsTpDvMV/8K+evMqfhodHR5yQjob7sCIQDFl4qfwrxl\n9OKn5zd0UVzzogDkRBWkQ5dB7A8D9zJhKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZG9e8XW5eWCy1cE+QVeqHAPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWEwZjYzNjUtZDc4OC00N2Y2LThjNmQtNGQ5ODc0ODI4OTZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MGE2NmE1MC00Yjgz\nLTRmNTYtOWQ2MC1hNDE4YWUwOTdiYWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQvF3TFFJ6G4STwPnoVOolWA0PpOBmPunIfPUWMwgOc4p4Cker5ijsSzwIoJEBJ\ngeKjehTY27HSUQlSczvTuuHbo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRjBh7CdKkHcQat\nV/WU9tDVPc/XfTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBJwonQY4/z8lNkZSfMMjMR+N+5rFGLSAfUo9Wf4CI4ZQIg\ncplS0ag2pQMu1ImjC2nL0SX1L6lTR1abSMuXR3EU8OU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7672", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7672` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAXgN53uV36ckod6saqOHfOU1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkN2Y2ODg2LTNiMDQtNDAxYi1hMjIwLWFiNzk5YmRiM2VmODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQ3YmQ3NTYtYTRm\nNS00ZmFlLWFhMTEtZmM1NjU0NzZiZmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgGgIvEZK4cL2c966BOzkBygJ5LGjKlAErueJKu6vWJxWAs6doRmJ7ZYmGuM7\nDp3mEJwg0W95h7vaRZ+0N7146qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQaYk0pxnbvBNZHT9t2BQEZDsbxYwHwYDVR0j\nBBgwFoAUUSyRazUZpoMa7LMoM00Q1RX5Ke0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiB9bkewuD7IRux35tCvvWeX899h+IWsba7NTJHN1/534wIgEHkt\n4u0NG6WWU50fBmNi0kwOUxnceSKzU8VwfXjmNF8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcSmHDx0BfpoQeuQro5TxiXqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDdmNjg4Ni0zYjA0LTQwMWItYTIyMC1hYjc5OWJkYjNlZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDtcBrqfDqxvuzBgkHiHBrkcfJny4GVpZijxkkbCs8p+d9\n3QeOXKmXfg/dZSvso/hvILhcRU/7y7IG/dBsp6Rmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUSyRazUZpoMa7LMoM00Q1RX5\nKe0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN2esu5QQwGANVbn3A9tkfO29Sy8Nw4Q56tGt9mTMVFtAiAbLA1Ui+co\n5nNmYTR7dyyIlIlBLgHNQ5hN9qf88sRSjg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVd8ywuRqqKrp7XBU9VeCjx0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQ3YmQ3NTYtYTRmNS00ZmFlLWFhMTEtZmM1NjU0NzZiZmY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlN2E1NTIzZS1iNTVm\nLTQ0NDAtYTg5Ni03ZDdmNmZjYzc0YTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATexZHHcCzlTzj9a39rKfE+G4NH/E7mF8EuXRIgMZE+OYRCa9WI+RV76urrCn8K\nF3BmZQkd9dRRQKs/LRgWoSdVo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBpiTSnGdu8E1k\ndP23YFARkOxvFjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBuaEwqfyeQ70c+xdUfpBcUGKf8iFrCYNsvm9ZUqRAwJgIh\nAPjfyD6HOHcBZOLAJdv6rCzMA5N2rKuOxEZhlK3tDSnJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7673", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7673` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAW4JI5m0NjtcS45jQv30jVpHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NDBkZjIwLTBjMDAtNGY5YS04MTdjLWQ4NmE4YjhjODkwMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFlNmYzZTQtOGI5\nNC00OGE4LTg3MzMtY2NlNDExNDE5MGM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvUitV+ywc4bldphrZl6H0GOB3yCveekGAx//LTd+0yailKlGGR8gLjFSHzK/\nyNSKeBoO+OkHUiNvUGMZj+B7J6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdn6nftK6TEWhpaRsIeGlzaA3uw8wHwYDVR0j\nBBgwFoAUDQ2Yv2KIvZOYUh09mn2Iz11v5CcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBzGxBn8RV1aLZuS/QsICGR3/5BuqHYzDjo\n4v069MIoOgIgWHtBTmMf/v+rcWOAYAmDKZY67GDY8FA8wejZ0MZ0jZQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAReTnxSIyDLzU98nnKFzMqFfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODQwZGYyMC0wYzAwLTRmOWEtODE3Yy1kODZhOGI4Yzg5MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSzRxk5DFyHmjV/JGzJPRQ4q8B/rcVNioCHkA7FU3Q0yP3\nf6Nnd1MFKkkUc6Vn9xTtiKf7AySmDnG3Gl0aZ3j0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDQ2Yv2KIvZOYUh09mn2Iz11v\n5CcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMNWfdcv1xjkQUL/qxKBHwDfjmrmw9oetmkl5/HdHe7oCIFIVcyHMVwsC\nbzUI6uQx06sSwDpzjUkP+exzN8k49MTm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAciCP9Fp8LbGvsCKUDubyZCPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFlNmYzZTQtOGI5NC00OGE4LTg3MzMtY2NlNDExNDE5MGM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxNWRhNGE1Yy00NTI0\nLTRkMTctYWY2Ni01YjI4MTY1NmJlZGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASlIvqXPAUXl/3+J+s0usajOOAvdpxj3wNK5c3ymtIBNZ3Ky5RTzI4zJALNN2aw\nUOCHLxMngG3D94xWWe50lNtXo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2fqd+0rpMRaGl\npGwh4aXNoDe7DzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAoBJrDH6hQ3cVZCZlb6XgTuYZnVHlQ+etg4Ph2xqH+3IC\nIFIT3NAYD2ZahGGUqC7d15KyUoPysvBp4WSxcpvbGNNN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7674", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7674` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAf7iQKc0/kdEYq+2zlySkEtsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmNTRjYzBmLWM0ZjAtNGExZC1iY2FkLTBhNzEyODNmNjg1YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JiZmE1M2YtMDUw\nNi00OTkzLWE4NjItZmNhOTc3MGY5MGZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWllLW9+nWfx1hGqNqI8/+8U1wRFq67LUr6exsWvSWmbRmwebHZzrHWSVhCC9\n14Y3r4wE5jPYrI+Ns0QDhhO5OqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqIiNDvqAQPjnrgXiZDaT37om5aIwHwYDVR0j\nBBgwFoAUA7ekf8n/7k4GTCL7Y7zDqaQiA0cwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB9+IJKj90rgH2I56wup/JLVHLIP3RrOtbl\nHMBRrWuofgIgZ8RsX/83RaUYFsYFaD+03Nco9+6Ys9NM7wuCjK62mes=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV7dvxFo97YZDanH7lztMvFWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjU0Y2MwZi1jNGYwLTRhMWQtYmNhZC0wYTcxMjgzZjY4NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/tSO3smneJT+yjnaL2iDLoBwc3k3IvrJ+FHmUWKqK/4oX\ngtW+4pdf/thAQfnjeXoDMr2sGF9lZmZtnq8CSyQJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA7ekf8n/7k4GTCL7Y7zDqaQi\nA0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCiR023pbKjqmkaOXJIYvN8hr4MZk2c1TDBjvMBry4ecCICpB7PDwLZUE\nGNwhcfc4AqbuDJTSUHw9bULeLKRQ+Efm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAVdYlYbnm5ssVPMynHi/RSjdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JiZmE1M2YtMDUwNi00OTkzLWE4NjItZmNhOTc3MGY5MGZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMzY2N2YwYS1hNTUz\nLTQxNTQtYWVhMi00YWVjMWQ0ZjY2MTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARL3e0vxvhdiNp9LD0p0xKfP3R7vLUTmlyKkUJ+2ichV925vXT0Ku4oO4dN73em\nOva0UmN+blHSeP8+QEaz3Ffao3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSoiI0O+oBA+Oeu\nBeJkNpPfuiblojAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiA7pERLgI4CnqFV/BA2JiXmhTxEsqTzbZE7le6sjrtjMAIg\nVwXsoEsRA9xQnRvKHSTJEVo+19c/cXC5YkJgY5BA1TA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7675", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7675` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdF7ZBwmx7Ot1fWWT7HmkKgbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5NjEwYjA0LWEwOTMtNDNlOS05M2JjLWNjZDk1NWUzMTQ4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU2ZmIwYmItN2U3\nOS00OGViLTgwMDgtYzZjNDMyNzliYTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJflDiz+1Q/yDaFrUqfHTtNf8pbz2s/wsqR3QMWEF3SdBOEWAAcoB0XnvFMC5\nbD7/FFz2x4OSzp2PoW/0UAJwWaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr0DYnaw84b0h7/ZkDIMn3Hn6gP0wHwYDVR0j\nBBgwFoAUvu8ckv+Y3wy7b/cDYg4F5YqstLIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDjcHVRuj/Bxk20b5BwNo6VMFyj\n5DyHXTGTPSFnUU8bLQIgQhF0ck4W5m0woi0Z7JatZE+Gtn5wXEs0nikDzxCt/5I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATLXUB15ktvM9G41VYnIm0DSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTYxMGIwNC1hMDkzLTQzZTktOTNiYy1jY2Q5NTVlMzE0ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLEEjInI8wqRdOY44XUupN0ZtOjV//tgsg4cSvzzP8gd4y\nF/f2mJ/ucJcNhbK5jjxyzw8sR5i55jhH3E4kMdSKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvu8ckv+Y3wy7b/cDYg4F5Yqs\ntLIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMYOGZa7Ww1xYzHdrqrHNmU2XpMrXkulrBh99kBbpCFMAiEA1V5Q0Kpx\nQdzxPM9GwXJ9m863cdbaizCCQzWOFXwx18s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASJQrA5UjkwsAqsY6K/6DOoWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU2ZmIwYmItN2U3OS00OGViLTgwMDgtYzZjNDMyNzliYTJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMTA2NTQ5MS04ZWJm\nLTQ2ZWQtOTAzNC0wMWI5MTg1NDRiZmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATEFML4gGga4PdBWeyBs+fXZzku3Ulw3TZiun6XuZ306wqufm3d20NNzfntlAoS\nU0cBizFOPXHeRk8es5u/2jJwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSvQNidrDzhvSHv\n9mQMgyfcefqA/TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAxAA4Df8czRgrERTde1ri7/MIs+UnP4v8vq1IHpoVu4cC\nIADpjboHnJZLmOi0HCIBNt8vjLXWLLO59f4iUgcRiuGB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7676", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7676` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAQ/2CLxmgnbxwyke9AS4vrPkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ODhkNjNkLTk0MDgtNDI0Mi1hZjU0LTMyOTViMDU5NzYyMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMxYWRiMGItNjFh\nMS00NWE5LWFhNGEtNTk4OGVkYTIzMmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1ey9IzNIkrV2DIcftQioH0Pze1yy8LKx4u/3nRvmmiINVWTt3XfpmcU7bBJb\nsTnbpfTl2BGgq5C7KX8vd63NgqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9T8rfyXj7dNJpoZqmGWiSMXp7lEwHwYDVR0j\nBBgwFoAUML8bYFhb0ggqKF5XdD2m4jJZpvIwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgMP8LL/S6\n3sQ8n6NlthzTGehZLgMrC1faFAIxNPIrlmoCIQCYKMjvkOg8rfkr6TzGdDtDCaKj\n3KeIktbZvd4qNLvstQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdlzTeh8eN//ACJnD7W2pqacMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzg4ZDYzZC05NDA4LTQyNDItYWY1NC0zMjk1YjA1OTc2MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFDxVApR8SwsmvD6LpwvPhlduW6J2109Ue2JwfqVzovzGV\niTJa+R+Wx/dI3Nqvau3HgDUir6q3p6aofQPZwYISo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUML8bYFhb0ggqKF5XdD2m4jJZ\npvIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTjSweLO++ernwNv+qFrvjDG4dy1YgYvZ5OfA0ep2j9ACIQDlg3R8P5DD\nqWeDNDm/PJvbGUV87JiOvjF70K1oDU5a/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZygIV5omLjfaMiHWVGiAe+fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMxYWRiMGItNjFhMS00NWE5LWFhNGEtNTk4OGVkYTIzMmNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZmE4MTFkNi1kMTg1\nLTRhNjMtODFmNy1jODdiZTRhMTFiMjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATbjVOu/zFt5S+2Ak+tP1NkqvZq63KxxCoXknqFMlGY2wGk8/mBJCyqMvuLeJGV\nyF0B4owZ9ee1dUV14HH5esvgo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1Pyt/JePt00mm\nhmqYZaJIxenuUTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiB1aEL7KXYo/leMywnZ1Gc+aK1GNCPdmzKpvhgUr6Ia7gIg\nZVgwaR/I914WAqMSC18eIYZvNCK5Ges+ipyPaSQMQFQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7677", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7677` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISATEluCZvYqh3+Poo1sQqrYfIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkYTU1ODkyLWE4NDgtNDBmZC1hYWQ1LThmNGJiYWJmZTVkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFiYzlhZGMtMzRk\nZi00M2NkLWI5ZWUtNmFkYjIxNDM2YTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmqe8GdF3f+6z8k6knl8q/sAZossz+BVleeGlAnfxWZmCD6FyRpUSaxsB44S9\nu/MHTMx+4ln6/66sgO75KnX9sqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDGX0XR5qPZ1BSjGEk1eAXvFb0acwHwYDVR0j\nBBgwFoAUPvMmOGADsUN3bJiPybl8wXB9/rkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIge8vWIrcj\nxrgPTExpGkDBrXhpE8pp8Wd3AehrL2JQUDoCIEqW6lQdV/3NkD+dygKrbsiuonOS\nHRCGuXaJPglt0gg5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATASXEF96rI+ghb6GaE3T/DkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGE1NTg5Mi1hODQ4LTQwZmQtYWFkNS04ZjRiYmFiZmU1ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATd0tCn31EXNPjVeYGOE6dPPWc4olw4nqEm95ilRLWUl7fa\nA6WesXnrDxQsXmRmJbUJtaJOzdw9hBX0sPui0v/Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPvMmOGADsUN3bJiPybl8wXB9\n/rkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMiUy9J8WRNyFtBVcWQ2vx9+xSsc3wAfhD6kGF+LTB7JAiA2+GryRc1M\nZz5Krx5q1U5Qf2u3OHvT9JVzQ0OPczmWgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAR1UYH8IzMLEs92qToQdg9SUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFiYzlhZGMtMzRkZi00M2NkLWI5ZWUtNmFkYjIxNDM2YTA1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YjgxZjI5Ny01NzI1\nLTQ4MzctYTA3YS04YTA1YmIyYzIxOWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARJUWIb2qPgvY8bwgQoQxSA5dH43u/JmSumPlXt5UTqYJSyVUTokV/OJh1unFxu\nr2roFTjBgAVFyEG7vrE8CnJAo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQMZfRdHmo9nUFK\nMYSTV4Be8VvRpzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBaNelv8iWkmqbVMeSXE8IKGXN5jD0nhXx+L72JJDIDAQIh\nAOWdXmVWBn5Ra1YiZq8dcpt2UVwyXVp38K2CpSE6dxoG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7678", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7678` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAS+Nsa6eP8T/uutIsugXVQ2/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxMjg3NDAwLTE2ZDUtNGQyOS04NDFhLWViNTZkMzQ5N2Q0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRiNWNiZmQtNzQ1\nNi00MjlkLTljZjAtODU1NzJkOWEzNWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYiIDzOXbuVLDCn6IydsI2+3VG03ZGFd+19AM4eruQlKbCw6/QvBuaguZIhq1\ny7W4GV80Vga05E7nnFYdN7EtKqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/5LZ81pzcaCcWkFcdptn1SfOFekwHwYDVR0j\nBBgwFoAUtPFujXsIudxs5tcY8VohL339QVcwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGKq2Xqo\n5s/rcoH0JIkDS4f1tXQsz8GQgMzITOQ9ZmnFAiALJof0TzWv6CgqqGwnzn7wFzmt\nT7JzHoklUHoKctAI0g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYNzQYuY6xlHr02BYxgMIi2yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTI4NzQwMC0xNmQ1LTRkMjktODQxYS1lYjU2ZDM0OTdkNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg1Q2Niaw9uI3I5EMeK2P6kfbO7j7AwQJbQcLgUJndUm5t\n5JTFQEGVfR33SjkmFf8mGziMH6jEfpdj0O8UkUplo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtPFujXsIudxs5tcY8VohL339\nQVcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJE+2npvH2bVYrD1c5C9tww6eeyHoyRI49/ZkIyhb+kkAiAXiRjMRxQk\nSThri3/EsKPIx2sHPfENboEs1lPaVVI5fw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAaT5OpvHqOmG4mkSke4vZ3wlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRiNWNiZmQtNzQ1Ni00MjlkLTljZjAtODU1NzJkOWEzNWQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYTgyNzIzOC1hNTgx\nLTQ3NGYtOTFiNy1hZDM2ZjlmZjc5MWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATqBGKEgikV4fAMsJfqcVkJgWAmNdzK2l8AZp+C4YmX/TkQq6y8QPypMzljKQu0\nVEs/RhDaUBvrPq0v0h7SBB51o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT/ktnzWnNxoJxa\nQVx2m2fVJ84V6TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA2O8Dm3kXGTPpfHoyUI+KdII77+qZkw2mLQsHv+CvDGQC\nIQDceJiFo+VWKI5Xllcs3GegmFRhZZ0M+N2G0aVHvRE5TQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7679", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7679` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAWW+fYp13LM/r9TVajJacaB6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkYzA2Zjg0LWNkMjMtNGEwZi1hNDA4LTdhMjBmYzI1MjczNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjEwYjRjNjAtMzJl\nZC00OGJiLTlmNDctOTAwNjJkNzgzOGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECSf4Fis3WE4zOp8CjOCyVieRnUhfiGz3AtXItWTg02rXUuycaQz546xcnxin\nLB2MheF4oDcoAxSOZb0ivWB4kqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV1gdboHxcDbrIuPGqhjdCNrWIOIwHwYDVR0j\nBBgwFoAU1QYjPG0zG+/F4HNd+YSeQlBAu84wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIBIwMvCks4heItt8frqd3/iPo3ch2z7HlcFDwbDISwG7AiEAgO00ZlMx\nqQ3yyK+KsMBFA5wzkR/BkW5vp4Gj2v2j9Wk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa5Vi4AO9i2zDvVLLq/BWO+JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGMwNmY4NC1jZDIzLTRhMGYtYTQwOC03YTIwZmMyNTI3MzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATovV+peEKzl7VTda+abq6I7lSptJqcEMBGe8jXwMJywgUL\n3/Okr7jgWT15kZg3XpY8tRkF9MlDFJGPNoqAEO13o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1QYjPG0zG+/F4HNd+YSeQlBA\nu84wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL8ea6qhQl/LRziZfPQ2HNBdHY6v/jdk+fANqKeNKFjFAiEAtWmI1dRW\ni4YfoKgaiqyBgjlIggtaFZa6Qc44BQgaPms=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAfbGJQOeIIT51c9J/6oikqexMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjEwYjRjNjAtMzJlZC00OGJiLTlmNDctOTAwNjJkNzgzOGI3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NWNkNDlkZC02ZDc5\nLTRlOTItODc3Yi0yYTk2ZWUxODkwNTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARTQF4ejhmWpP/ApWbZPJegVI27zn3NWFEQKatxO8q5YKnfvEtyCXaZXl89qbzn\nngo8GF7PLlB6BQRTlWr+j/amo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRXWB1ugfFwNusi\n48aqGN0I2tYg4jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAqUluaA3KVrcPialrHhVCrCKbCepicw9WO0n88u8imVgC\nIQCGmGmrX/iofkSjkfdj2QfL6pMQikIUaqZ89fpgSkXf1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7680", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7680` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAc2LrV4qqihFbf/TV3hWqnzSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2MDJmOWNjLTc3NjItNDcwZi1iOGU0LTcyODQyMjEwYzkxZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYxOTY0MTctMjhi\nOS00MWRhLWIxZDUtNmE5YzYwZTY2OTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiYrzVYMtY7lLX8cF+k8NE9gbbv1BaBRDwto/xYyTmrItY3SC0o3+nhnTtW/1\n+64F4kq75kMGBSRFy13T98qcuaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUki98Is8NBpILBzSBpLjwhdlZkWAwHwYDVR0j\nBBgwFoAUHNrwLrz7dstxzGNzxlMHo+Bvx8IwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIEludAL6D9SXPKH/O7qlWHV/n9/JWnBe2NJh0Q2A5HskAiAjcvuDKqvd\n1CzHLiDIBE6ZzDtMaftL1GmQpavE/foAkw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbD1I56fbXZgR40VTrtQxGVlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjAyZjljYy03NzYyLTQ3MGYtYjhlNC03Mjg0MjIxMGM5MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgC7ZDBHLvlXBwXlCM0ej/1rrnIHZHMoFdbQ45RSDf427C\n6wtfY7dqb9a/LjwYxsk9EMGsO6Y4TgU4mq13oQ/Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHNrwLrz7dstxzGNzxlMHo+Bv\nx8IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKl5zQBx0d9xc7eJHbiO0GOMC9ZaYyXsxG5f0u4iBnggCIBQl3vDRfPgl\n00JezXwHiwAXyLB+vs4tulkY8nfaa3jv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAZztCajLRYJ9WZe67Dp9CJtOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYxOTY0MTctMjhiOS00MWRhLWIxZDUtNmE5YzYwZTY2OTdhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmM2U0ZTFjOS03MWE5\nLTQ3ZjMtYjEwMy0xN2JkMmZiN2JlMjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS9P8QubiR06/XO2L9R04H0hxMqrE9nzGrRJlVu2vIU2OIkoL/7EqgSgxIXk/xS\n46RE7z8l1gS/qT/rzP6DMv9/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSSL3wizw0GkgsH\nNIGkuPCF2VmRYDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAp+9HA7dj15TDODqvVZUEhYs/f9AfOUrH4VkTBZY0se4C\nIQC7Vi/ITFZhOzTR1kul+N3faITw3IXIt7EIt+u66lhmfg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7681", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7681` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAYYDWQRjj3YxxMB7aduIdbc8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjNjU3NWQ3LWNiOTAtNDhlMi1iNWJhLWJiZWM3YmRhZmJkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI2NWQ5MmUtYzZl\nZi00ZGNjLWIxMTctYWE1Y2UzNzU1OGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn1ITFysmLfJx9deykpy0HVyPoiLRyp3Wvasy0P3RqEPYP/tdq9aWOj+kxRoj\nujY7WX2IpdqC7SDupsB1tIUjA6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvqAeDY2HI3h/iQwbWiOX77UU+SAwHwYDVR0j\nBBgwFoAUOYxCqSpwip8tQPVQj3ZLEaJay9YwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nICB9rCnpsY1I+dFSzhWIoPXVa/RViu1kIR2sLb357fMbAiEAhkcSU3XDhvLRkpzf\nsnvOXNTMOWHQUtSjkf3WEDAt4jw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVArKUImvOoNBl71lKqZHNAGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzY1NzVkNy1jYjkwLTQ4ZTItYjViYS1iYmVjN2JkYWZiZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9hJlOsZor5R6C3Jm7UMjpuGIk/H5LZ+TMJ0h1irL7EwiJ\nZGzA4Yr9Dhw95Vl/dRu3HzCxxsAFlWvSBBxdB+Sao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOYxCqSpwip8tQPVQj3ZLEaJa\ny9YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZkaMUM7KW8xTl2cs030qjBL8GHyYc2bzHgBo3OgtEhYCIQCrauLh3BGo\nCjOzWCPDKBS0Tv7VGN8REFVKX7X9Pq0tZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYF61JHZW4GeQzj2HwtRKfZCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI2NWQ5MmUtYzZlZi00ZGNjLWIxMTctYWE1Y2UzNzU1OGNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YjAxZjBkMS00NjQy\nLTQxMDAtODA5Zi05NjYyYjY4NTM2MTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATQD00pEPbLblFor0B4xJH6ano1Aa+w1WCvt+V5RqqnwySreZtdR94hQU95CXBj\nagQuhZWSmIC3HpMpPGbD27b+o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS+oB4NjYcjeH+J\nDBtaI5fvtRT5IDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBdydLkx3GvHkmOBxiv1uIZ6pL6T1OKC0IJfAm5eAjkkgIh\nALW33JYvQOQQf5Y5vkWg0/hNb4qbtYY1sDjG6uQ6Ke1t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7682", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7682` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAXmEkYXSlz6OWaR5rNVzLjCVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZDc5ZTc4LTJiYWYtNDI1Ny05NzE4LTdkNGFmNTIxYzUxODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk4OWQ4NjEtODJk\nYS00NmYzLWJjOWItMWZhMWZhNjY1YTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyyfavQRxSHerIvSUm6m/P3BW+Be1Fii+YO4xxCOMu2m58CBQ9/BW6CiHHFCW\nO3ADL53QPO4AL6xBbGbzQNzF8aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUreVNnCuSdUjv85vx4EXApoR/OIAwHwYDVR0j\nBBgwFoAUd9idzYyiWGhoZvlRtKv12kyGY5wwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIFwd6gQQTHvQY3FOw9N0Mrt/q0PjJiF8f4cIyMGBVPEdAiEA\n88v/y0g7+HM+lulirQCOAhucQhyPQpdvQrkBZdqgZas=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc1woMjFAyJ07XUvPlqTuIsIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGQ3OWU3OC0yYmFmLTQyNTctOTcxOC03ZDRhZjUyMWM1MTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARe58FTCqIOzLEETdDZWqpZ7mBwVGOvaPGMc3CXqdpj+hij\n7L0p5uVA+f6T6h8s9LvYozViqBIEi0Z9NQua833Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd9idzYyiWGhoZvlRtKv12kyG\nY5wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANQ+QX8QTCV7IHb5X+9T8QxPa92WWVRDmqeHmsaI0GZ4AiEAvhIi8O4/\nM4+ds2JC+3lBZFxjnpsSvY+pcILy8WNSgvE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWkLcXqd99hFmcq4YqipaWavMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk4OWQ4NjEtODJkYS00NmYzLWJjOWItMWZhMWZhNjY1YTJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NTcwODkyMC00MTc5\nLTRhZDEtOTFiNC0wZGIyZjIyNTNjNjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASmKEeN6oeyzjpxDwpeuwyY6gztJPe5awhH1JnBSVh4aDOiVLyN5cNKrPRhNlC5\nCkxBIphIBDl5glYhvLeXeE26o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSt5U2cK5J1SO/z\nm/HgRcCmhH84gDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBGOvylBEmOwwV+C2JrDZiEe8s6lq916Bih+uwHHcKatAIh\nAKInjW1DUku9ZNs+VfDLofeYVyRxlZR1+0AAE7oQXRCj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7683", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7683` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcKcOvwK6CkzuJTF/8d3DjnMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjNTJkMjk1LWY0NzQtNDE2MC05NDhiLWRiZmJlOWUyMDJhMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk0NGU5ZWMtNmFm\nNS00MWIwLWEwMDgtZWViMDExYWMzMTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOcgafTSKKFxuRgayU9HXQ4Z4806Ds+pjJI7P5DajBnGrUNtR8nSZfLodoDmx\nxiP9sswQu0tApUqG7roM021aZ6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2t7Bnkf+0nunTbXD98SnMmvTbFgwHwYDVR0j\nBBgwFoAUokTphamhmVFl8Uq2i/EVZkDR8PwwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIBWW+YYienJpre8gOsaBV1qqoGTEODP3/wwTZgI0l5WGAiEA\nlptZCub200zKTe5R1cRzAqniLvO0ADvJ87lImFTcV5g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeABtlCMBa3CP/HpV/yyXC/bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzUyZDI5NS1mNDc0LTQxNjAtOTQ4Yi1kYmZiZTllMjAyYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEkWbTY4OWluzyTgQeFmQW3HZJPHLok7XVV6Uo1ovMbPS9\nDhTH1Ihfemcom/6M7wbm/SMErxDv2JQ/zHpml6edo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUokTphamhmVFl8Uq2i/EVZkDR\n8PwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgb5Xm5anK9QVTk83LrsfPODEnlIRMXwWY7sooqDv1zJ8CIHM+dFCBCyjn\nvl7GW9wU0CbDTV6UBEtdYR/B5cHh9YSK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASvl4oNGNxh3CJ7RuObPcNggMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk0NGU5ZWMtNmFmNS00MWIwLWEwMDgtZWViMDExYWMzMTE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlOThmODJjMy1mMDVi\nLTQ4Y2ItYTJjZi1mY2M2NDY1ZWU3MTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ/gwzFcmOaK5FKTkj6yU77t4VKZk6kx+EqpKUQnvdVuOVHuEa0er77cmaJx+qQ\nT+PXx0meAeAideUMeWEUteVuo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTa3sGeR/7Se6dN\ntcP3xKcya9NsWDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiAaC9IFTxuBaq8xbwA2PYgw4NS0XWhQsKd+/CW1xRLs1gIg\nOU+y2iHSUz12Npf0EE8axa7E0wKZ5XWzdMlmOSIWZ+E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7684", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7684` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAVnk9Q99+6kWlnuFSRQSDCKQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNDYxNzdjLTMxZmQtNDgxNy1hZWViLWZlNDFhZjM1NzEyMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRiNTEzNGUtY2U3\nYi00YTM3LWE4ZjAtM2VjZjhlMWY5MjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENdb5tYpwIMogocm/iiwmhL0B2eKNLtPSMhHh6vbes4bC+pBnxsrLUoVqe490\nfqpWRDl0/dEx712rsU8K06iZpKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwCLsU+I0MibQL/ddhUOzoG+Q0cQwHwYDVR0j\nBBgwFoAU9b0+vGD8jpigUiU8HFiANmpvnUIwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD8FwGyOqiB\nrwrScYnWgaXj/6eys8GVQd3tAFWPcc4HIAIhAIPDakYfUCQmI1xkICEfBC1s9i30\nMxw8QLhYm/9jfJe4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAftnwLeG2CbRGoxp9/9pGRJmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDQ2MTc3Yy0zMWZkLTQ4MTctYWVlYi1mZTQxYWYzNTcxMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7IPMULuyGSAuLYV9S8bjRUBJpPd9ezhqUWHqKh5buYSKo\ncdq5/+cXByugFfFJes4hFVP5kCKqTGBbb11ny+kXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9b0+vGD8jpigUiU8HFiANmpv\nnUIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOOWGTR5iBiBS6pKOW5Hno0B03ipA0mn0q3Y1uhmjtg5AiAfSzjFVAQg\nXspvvGVz+NqaP+4hNkeuybCttbp25wY1oQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXGswDlK39qphCioaKLbZmh1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRiNTEzNGUtY2U3Yi00YTM3LWE4ZjAtM2VjZjhlMWY5MjkyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5N2IxMzc5ZC01MWM3\nLTRhNTQtYWU2NS04OWVjNWNmNzQ3YTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATtZ0c7LHPDMEOuIVc5VXxKIgZQfushGVpjEewnf+5hd9xlTrY/Q19IBaOk3Tg1\nmUmQvod65fcLivphRrQFJz2mo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTAIuxT4jQyJtAv\n912FQ7Ogb5DRxDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiAgyRSYcvieoiuXEIpbRy72MO4Pg2RgI3oQ2/YAAu8lOgIh\nALjdInUVfpKXa73iMEp88EyIO/4Uwo6172/BnxmGOvy4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7685", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7685` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAR693sc1kVIfxiKIYF+xzXAsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNjJjNzZhLTdiNDItNDg0ZS1hZDI4LTJkOGY1Y2UwMDk2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JiNjRkOWMtMDA0\nMy00M2M5LThjYzUtNjQ3MjdmMmI1YWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMNnQU03FXnbYFpCF05yUO5vny5Q9RH9QrHvo2dkM65SD3IUlgnBc7jnuJ4jO\nYzXRV7Ci/jY7wr1AeaGT8wTIlKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiKuCcZ3P87OcoJrNLHuiJeU6a9swHwYDVR0j\nBBgwFoAUlhyIcyBhZEdKF/aRNt0d6wy/D2cwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAOL1MxL9kFSWeEabBjAkY6yI1OhUevCdrw25FGJthiIPAiEAvyxBpS+K\n2XK5tANYfsHZRT5thSV10EfHI7/pnURMlsE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARjXR6uOa+yaUZ1aTj/M5llkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTYyYzc2YS03YjQyLTQ4NGUtYWQyOC0yZDhmNWNlMDA5NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVvbZjF4Z2cu+qNgehX01CbSfs/EP4CBmaFb5j4+DOU+R8\n5sMuLXdrdljPV9ih7BeNk4V+Cupziehd1Ndpt/MLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlhyIcyBhZEdKF/aRNt0d6wy/\nD2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMOtcX9iPzf4yCxN4KjHfU74+gumqE5B/Kcwzv1gl3kuAiEAkoMWRKoh\nBnouLYQAthy2ZzWMid/Hi3cukACD5JTzcKs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAanuRMWj+ichDDjmgK5MCCacMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JiNjRkOWMtMDA0My00M2M5LThjYzUtNjQ3MjdmMmI1YWNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0NDZjZTAyZS03ODc4\nLTQ3NjgtYjdmYy04NWNmMzkwMGNhMTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR4rBzee/k6ouyopLXlS7LD0OnuX7m4sxFel/MhkJHf8qZN6viNxt+MKKCeKIMg\ny+Un+nDeR/Qk2ZuGACbl+Yavo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSIq4Jxnc/zs5yg\nms0se6Il5Tpr2zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBAxVv43xyJR72INgrd5O7Kw3AziaAh9MdwEmYL0FMmRwIh\nAOfT1UBTkEg0fInRJHGZ47YWh065vFBKgeQuWB8GAW0Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7686", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7686` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISASdSF84UdNHLEqw28/CIM87RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZjQwMjFjLTAyZDUtNDAyZi05YWNkLWM0MmYxYjllNWYwYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE0NTMwZWYtNjgz\nMy00YmM5LWI5MTctMzQxZmZlYWE2MzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKrimI5w4A+BkQyVUpjkAdz/myA3xULdi+eoflldxOQd12WMWrGQe7dcRrHuw\n78ejsKXkjsahsAeYYd1CmMPl/qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURhipkTRdItiJK3CoT0IPBNaPJIQwHwYDVR0j\nBBgwFoAUjYlaGNEb86XOMKyCoiyeKXHJxIswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIhALXl3KhB0CoXgjICPJWiftFEyKDUj6OJxlvD53pGhKM6Ah9HgqQD4W9g\nY030Lgyq2imF4YMkzqnU1xSz5hViGTt1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQSvrJ8sRB5Ir1i73ILoZl4RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmY0MDIxYy0wMmQ1LTQwMmYtOWFjZC1jNDJmMWI5ZTVmMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWh9raQY+ClZl4A6iLFIAQZw03D6ce5dHlxuy2xTAC2nQd\nc1B3fF+nY7uV6rFAdKcPe0D0Ka3XXZK4D+lcnIzFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjYlaGNEb86XOMKyCoiyeKXHJ\nxIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPirfT+Cuc4LF9r3Mhp/4aAZiJS/82Y2U9j2KBuwSA4XAiAGS5ltXWzK\nppepfIFFwwX0oN4uhvHOWjPvIQxGidenWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfxqbvPM4u09YB23GWUx3OLnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE0NTMwZWYtNjgzMy00YmM5LWI5MTctMzQxZmZlYWE2MzQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MjhmNTkxYS1jZDE1\nLTRiZDItYWE1Ni1jMWNlNTJjNjJhYTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASlFrABwF3EQnxfhR5LztxZ1R0wTPGXJF9CXnQdSku+15Ps4MDBKEboEWmiZ5K3\nasvfEaYUOBlaTUGkaaPnGqnYo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGGKmRNF0i2Ikr\ncKhPQg8E1o8khDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBs6vLwIanECQ6SkdYHoRd6H38N5+K76Z4TpZCu+umfnAIh\nAMJp34ZsSHODrJa8chsFvSviLSCYBIobzUUQZlE2zjBi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7687", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7687` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAb98oPBqiGT1QC2mlB9ppytxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyZDk2ZWQxLWRkNDUtNDg3Zi04ZWRmLWQ4ZWVjZDJhNWRhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMwZjlkNjktN2Nk\nMy00YTI3LWEwOGEtOWQ5YWZlMDhiMjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgGsrH1KP6VIvO0+1SPmNGWzvOLI9axhJbohy6mzyKXUy6gEPcNWK3Ge4MS5l\nR+BdNQWbtiaaQOwYk94PU1Cdc6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnOrgGBtAhDzwVyfZfkW4MgSj+ZEwHwYDVR0j\nBBgwFoAUZNaWj80X5hmyjEo+fcMrS/LZcnowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCsu90warl80RiPzLVe1nb/wdptBRa6ehXv8ev15OdPAwIhAP9eIVmK\n7IBlb5w1F5Wh337hYKeBstmGH/83prr4boOo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaCNT43Lx98bSd4NPn7pkJj2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmQ5NmVkMS1kZDQ1LTQ4N2YtOGVkZi1kOGVlY2QyYTVkYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyA2yxRG5qOWyRPjXXfVrDfOR0joZttOyQJxT2tG8+DeSe\nfz6KGtLYDxFJt0s04899C7r0wxsy5a4yTh+1suyno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZNaWj80X5hmyjEo+fcMrS/LZ\ncnowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK+wTKdgtMrh2YTBd+/ItbmDF/uEtMlS1VtWQrg7OScqAiEAsN44Sz42\nPTK3nNs7eQakl5LaGmA4t1rqow72+TPoB70=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfBY0SRHvatyoAo8ZWSbUKb4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMwZjlkNjktN2NkMy00YTI3LWEwOGEtOWQ5YWZlMDhiMjUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYWQzYzhkZS1mYzAx\nLTQ2ZTUtOWIwMy04Mzk3YWYzMTIyMGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ2LSPuXM7SLe4ELMuCZ/R4QKsp3alLI0fiYwL7PPQYkWKHW4wkwhlMjx6z5eqY\nc/vzbItTGI31Oue4RYgGBk+0o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSc6uAYG0CEPPBX\nJ9l+RbgyBKP5kTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiALQMDAGAjcLGSHJ2P3P+y27q+BmwCEZG4Lkv2xfGO5QwIh\nAJ1W5ZhFUCC7Rv+yYHagvJZ0fFEdpl5PH0L+HCimdOoT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7688", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7688` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISARWQTtr468f/GJCswsvW7rDiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0YWQ3Mzk3LWYyOWUtNGFlNy1hYTNmLThlMjA5ZjE3NmIwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM4ZWFiMDYtZjA4\nZS00MGFlLWIzYTgtZTViOTk5ZWRmZWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4Es4lt66qB29A8w2euugkjox8bgjdqxtBz+adkb5GxDgH4LX7l88M90hqroz\ncPz6oY+Ewg+8/TSto8Xp1BXNCKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg/TanU9iwZevih9Xppd1aRTvzSMwHwYDVR0j\nBBgwFoAUIEFf4/yBY6PogRuhLu0pHkff3OcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDm1opLRa7dT6AMQjfVLGuG3jNbf5gjX4JOeI3N\nUS7aMQIhAJO5yf6ObF/z3xFPUUX7TD7SeegZdY4ROw/coJjBnZNV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVymDm15UJvTqEKzJcErSWi0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGFkNzM5Ny1mMjllLTRhZTctYWEzZi04ZTIwOWYxNzZiMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASX5YPWAfVYatw8bxJ393vg7H/hXc8dPKxmc33ajzBSiuAj\ntUGYUSoamxkTVddQcKOhMOIk2PIfG+XgMpMyo4s/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIEFf4/yBY6PogRuhLu0pHkff\n3OcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFPw/7Od0j8iwou6QrdPGKTmAMYoOIzivxJXygr7/ynwCIQDETfiScUA/\n7VVElFrLeHIhpCKCey76HdkJir2bXYH7SQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWizoOFZpa2OCe5DtPjgKPsbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM4ZWFiMDYtZjA4ZS00MGFlLWIzYTgtZTViOTk5ZWRmZWVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMzJhZTczYS02MjRm\nLTQ3MDEtOTQ5Ni0wNWYxZGI5ZjhiZGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATz/Rp18HaF24gU7gHdgW7MbEuTEdTVkHmYYqNpScmiUU0ViF5ahQUm06UfciEG\ng3pMtUR9ammZC2N8IZMeiLPjo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSD9NqdT2LBl6+K\nH1eml3VpFO/NIzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBxWv6r5NEVTM2TYwGndZ6yZXA2o3hPOxIo8xeZhkWQmQIh\nAI2vJnnKnIZgJYcU9qP1BmGi4dGHtRjXJN7IEmUcc6Cy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7689", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7689` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAfQhkEMoB1nJ18/n4FsAvl7tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMjJhZWVkLTE1ODctNDA4Yy1iYjhhLTZlMzI0MTk4ZWE3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZlZDY5MGUtYzg1\nZS00MTYyLTk5M2QtNjA3YmMxOGMzY2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8Pt8aGwnGu5521hYV78BDvXbv4r0mV3T9LNPwhWSSDURNwcN7t20QQuybgBO\nfNMkInBZo/HK+zuNc7Ayf3ghLaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvSvIVi6s+xI0eMl/WIhAfKtgSM4wHwYDVR0j\nBBgwFoAUTTmaRyEOEGJvMXBx2Ler28wJPRAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCtAOnwH1YSsvy/I8xQEs8zGYi6gis3Hv9/2R5g\ntlG/ogIgOFMosiuVIxLx+OmgzdqzAI9cRXwNBCcJ50sOxblyxiY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWVa2sk8542/moDObwiM94nOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjIyYWVlZC0xNTg3LTQwOGMtYmI4YS02ZTMyNDE5OGVhNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsOUP8AEcvgqhc/wu9ZgBLYaUpuSr/l08N2hSFLCOrvNFT\nVqLAcTClRIJ+8I3fAs1+mRVzJJFXEXPyBKnvdylLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTTmaRyEOEGJvMXBx2Ler28wJ\nPRAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMCw7npu8WdzKGec7HPuqAIx4iwJQA3pcBs7WPWsZccYCIQCL3AZCyCt8\nyhwjKs+C6RcdG03Mn1K09/ucwmzMQIO8Eg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZdR53SQj5Dt7PcJUlPToVD8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZlZDY5MGUtYzg1ZS00MTYyLTk5M2QtNjA3YmMxOGMzY2NhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NTE0NDczYi1mNThi\nLTQ1YTMtODZiNS1mMDQ0ZGRhNWI5ZjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS1h292advvsazlO1cA8O2QvYmuCnI1ILFpRHAJix9JfsJ6EMWEEDrylK6i6bUu\nmYqzzcp2Usbth0zNyd038TZ6o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9K8hWLqz7EjR4\nyX9YiEB8q2BIzjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEApsY+EUX/0aTnidgIILsyFwQ9mWkZfnPmk35fDwOdhbMC\nIFoUKXAfVRbUP9RtpOS0Kq7WbRMgGkORZXkZFxhiYaQm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7690", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7690` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAVrPOwVLSEmmaxFrf4g4mANyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1ZTI0M2NlLTk2NjktNDBlMS1iNWNlLTEzZWI4N2IwMzE1MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZlZmU2NTgtNDNi\nMy00MmY4LTk5NjItNTE1NjNhNmRmNWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEntu7i5hHiNDLp6CPN19NApr+Rn0jwV67DsQFaWIY5gWYy8Oi1VjiZqZzB9Gv\nlAjhwLxeHScW9iPPI7eLYJr+jKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhcErT4HZ2sBsyEVqh2E/6m3tz9kwHwYDVR0j\nBBgwFoAUbmAHIp2zm7Oifi9A9KYLnikVSFswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIDtv4ob2LYZnCBUo1in9Fb22a9tfTF5P0xUVnooUxazsAiBC\nJ46h0y/+gDhiLAh/r2frVUY1c2hjJK8TX+dfVtvoIA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWo4qxIJyl1krD8gLquxbVG0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNWUyNDNjZS05NjY5LTQwZTEtYjVjZS0xM2ViODdiMDMxNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNxyEwzijAvpSOSanAQdde0a59pLIsvVXjr05mNXnXtpux\nRVu9l7dXA3QIodKBQvPRbUCGBeI9WWg8y+LDGRIco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbmAHIp2zm7Oifi9A9KYLnikV\nSFswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOD2VZwHW6bhYS3pW5f2EN9wHn0M/tPix2xBfKjt5dDJAiEA7rbqhKe5\nFzZZY2j+VAu2pwD6HA1zdcJwhOlubnPWOec=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAasstn2eAVhzcnyR4nRNqTjqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZlZmU2NTgtNDNiMy00MmY4LTk5NjItNTE1NjNhNmRmNWUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NTFkNzk2Ni01YmZi\nLTQ0MTctODU1MS1hN2UxZjk0YWJjYTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASaqAPZy/2LvuvEcfd/DZPjtjZLlNiIHVMs68oUOKmLmCl4GR9oQJ1VN+UwKHm3\nbEzSKX0GFmhWyBOvOb+l0g9Mo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSFwStPgdnawGzI\nRWqHYT/qbe3P2TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiA/g8KFgP+SlJBFG/APhn2eGpEt+qsNZVdx3dkubOUNdQIg\naPty/8eKQHXZK5sMHOLFhZjEOTpnGH/KBAqLiOgF1kU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7691", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7691` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAVN+ti6poGInXppIYyYdHSefMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyYzUwZTFlLWRhOTQtNDc5OS1iYmE2LTc3NjkzNTY0YzZjNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg3N2I0MDgtODM5\nYy00NjQ0LTlmZDYtNzlkOTcwNTA1ZTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHnhHhP3uhXJXQm7l/O0NBz41cfhsTxMu3qWxLCXuMHbFeqQiumkWPOPXP2s/\ncJBIquRiJ/KzaBgX57zxpRb+OKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHfxGliG1XwUXMZEH+DTu3s9qA/wwHwYDVR0j\nBBgwFoAUz/fzluSsbXw1ln00I5QkPGjAthIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIA7D9g58yrnQta0UdfrV9MkcIZxPhYkp\n25UraiiUv6XlAiBcllbMLk1qIF3wp2z3lt6BbkIcv2rOw+O/pnn0Cg96mA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfCT9v3mSfzuCotOmbpbmTo4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmM1MGUxZS1kYTk0LTQ3OTktYmJhNi03NzY5MzU2NGM2YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpLUrGbRhT7co1rn6h2M1/cs3tR0KJ9pMkPCUeB8je/4QT\nh7ZWYWtIw7fmBpdrYMXTjUVg/umNu3GBxFdhwsnpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz/fzluSsbXw1ln00I5QkPGjA\nthIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLko1dlbu+kQr8sJSUdmChvaabbBS/qR+UmpjNts99aECIEQkA1pkvIol\nZ4VrSShWZRpS96vzun8svduHGhsYYgPl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQyR0VV3+2w5pEGeGtxYKPJkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg3N2I0MDgtODM5Yy00NjQ0LTlmZDYtNzlkOTcwNTA1ZTUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiZWU3NzY2Mi0wNTYx\nLTQwZWMtYTA1MC01OGQwMjRjOGM4NmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS0Kizey+PzE7zlRN0xO2ruQDyq+lOOlQX0Kr2xS7ra/3CEsed+h1NJVAi/5/v9\nNYFAxGbRPUQ91pnORU8W83Sdo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQd/EaWIbVfBRcx\nkQf4NO7ez2oD/DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiAnBH3u2EHllbasdLhpe4VxRoZ1u7mGEKMWTpEdLQtbmAIh\nAOVaZ0AB6kSJRwTfnGsD5o5ZmQ2/fan9r6cMGgJcHnqU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7692", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7692` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISARBtqJ8ZnTXmKK+7CBljNruvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjNmJjNmZhLWQ0YWMtNGMyMi1iM2VjLWEzNTAwZjdiMGQ0MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmUwZmNmZDQtZmMx\nMC00Y2Y5LWFlYzEtN2Y2MzNkM2ViZWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE81seiGkkXJ60ft6GnqD+bm5VxA8RFEvSSp6cT2MX2keFcYMBSG8iuCfzZujg\nA8GYl7EQG0vSCPir+EtEQGe9/6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF77NcQLRDBv0XrGJfk3eMYiEWAkwHwYDVR0j\nBBgwFoAULsf6u9H+u0HXX8ZpOoz6/Qepd/YwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCrRgy0DmQZ9HAuejlJx1HhSweDORji\niU18eXF9SLWLxwIgdCaGTdHJPRSfQ/r+XbOoGw3ulMfXZ9OkgwdiRBLAyQc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY55MMbe2tiLI73vgDXLB3S9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzZiYzZmYS1kNGFjLTRjMjItYjNlYy1hMzUwMGY3YjBkNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEm1+HM0m/Ama4YrHaXASFh+4RwT02YgdNsdcH3SMZV0Rw\nJNQXYxz9Dto+LJcmFQ7NUO9eYbubafPUtHNoyFqoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULsf6u9H+u0HXX8ZpOoz6/Qep\nd/YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN7myqRA7Xp2auvdIXWJslrl0xXPy2O3yqD0LBWd9ezcAiEAyxndQZPz\nrXd72scYQ+kr7wUh8eQA34zJsinCjYFSWu0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZy8xpoXtasSTbLcczlBpL6zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmUwZmNmZDQtZmMxMC00Y2Y5LWFlYzEtN2Y2MzNkM2ViZWYxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMDQ4NTY4NS1jMDg3\nLTQ3MzYtYjZiOC1mYTVjMjg4YmMxZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARc2+DRZRrER9pnFvXNb6MQFN944hjjbkwK9FN/eZ7/XdxD/fzlMxEeTGgIoKjp\nKBiHUV7ihn4dPmi5jjxUpAg9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQXvs1xAtEMG/Re\nsYl+Td4xiIRYCTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBYzBVPW4+dEoDPTXGumjSZhCvcA64gboSvhr4rDX5ZfAIh\nAPxr+TswdVMP0yOvU+2fGQWZ6HQkf9Nc9W0m+bxtOwT4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7693", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7693` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWoKNz6Syj3Ke58bErBlUrV2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMjM4ZjcxLTNjMDAtNGZlNS05ZTFmLTRkMzU2MGUyMmUxMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjgzYmM0NzAtOTY1\nNC00Mzc2LWJlZTEtNTg4ZjIxM2EyMzMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmIpi9UUmrLRzqtwU7oYq6W2p/1nCxeIzLh/tSsV6SWx6PxjQLxP1zKZ5JKCi\noNzkipGQouNNCaBwukSHise9fKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXW+d9abCBxvY84E1f5Hbd/yvCGcwHwYDVR0j\nBBgwFoAUFMuoxSgtfPUR5qYe4EWzhBvQh7EwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEJ2eg2V+F/2\nEGPEPRft6RSuZ8WzhNNmtXwSCL9aJJBWAiEA/T7PqZ91qdxqM7c3/xrXI2VOsQaA\nWvzdRTYEwWf+d1s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa3UflN0ZhEhwe0RhAn15FdUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjIzOGY3MS0zYzAwLTRmZTUtOWUxZi00ZDM1NjBlMjJlMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlVE1J2G7M+LIZt/l2dii7DPgUuwRgwR0fVdBRlX0VkRZb\nRR4fOLe/S+gbbooD4CHStWgsSTkonkLfRaq7wZj+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFMuoxSgtfPUR5qYe4EWzhBvQ\nh7EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUm+rE+CJzHLbVWhm0Pt7e0Lw2Yv6kwKEqQv2L/PkzRECIQCcN48DY1Wv\nESNdfFIZJRmj3D/7uN0RJN85SrDZId5pYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASoaamj0Wkckh223HFya76KAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjgzYmM0NzAtOTY1NC00Mzc2LWJlZTEtNTg4ZjIxM2EyMzMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZWY3ZjQyNC03YmUz\nLTQ2MTgtODNkMi1jYzM5MjNjMmNmMDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQXH7NLiHYjaB+ihgUX6SPCqdwcytGZVsoKkLfYiWCDBlp33HaH7sVIPTWd0ctm\nH/ZeJ1zkqvi2ud+7UUnyh+Ugo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdb531psIHG9jz\ngTV/kdt3/K8IZzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAhRnXKpMLIerqlN7JMHVK7UrsQ7bxDmMpn7NnWAY8234C\nIAkiDSE+wWQ8MOZ3UuWM+eRMFtRoxiG7GeA9tqpiTxkA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7694", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7694` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAZWiLV6kHFiqfESnUOSenFE8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzNDdmMzI5LWI3ZDQtNDZiNS1iYWUyLTlhOTlmODJiY2VmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzg2NzEwZGEtNzhi\nNS00NWJkLThjYjYtZjg5ZTY1YTRlNDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/48AEPCpbtcHNVinYPzVJ/57INOloauuhDJnDi5TLIyx0kw5jlObP87+SI8u\ndTa7QpTgRyEevZQn23iM5SuDIKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwVtfyUQZJp+YpkqrmOBAZOqCeOAwHwYDVR0j\nBBgwFoAUTgHMBxQPohDxRe5S7PWPQkn6YiEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgLLTEyaAj6wEK+sv60xomD4e45r97DjU/FkSL9K4Ot8MCIFUZA8sjIRKn\nlTWYgR4t5Tvkb3FJjSetYC7lEpsEW3PN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbt9vDAq0pKP/N1ZfYPSB5lGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzQ3ZjMyOS1iN2Q0LTQ2YjUtYmFlMi05YTk5ZjgyYmNlZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5pWTxw6aSDuznkGc3GJ/kVgIkPr3Hol3/SMAWcVYTxydy\ntj/lZ9QqXVm8rHe1soRhNl0L9gLwRnWPjBrXW3l/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTgHMBxQPohDxRe5S7PWPQkn6\nYiEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfPWGjxLjdGxv0uJgToaPLeuSvDTbu48KT1DN6j26QmsCIQDWwwm9CZ/W\ne0ybqU+01du77MWTNFG1dm+0P2UmNeQTaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAc6h75xlRm+7qDc36VBPj7F/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzg2NzEwZGEtNzhiNS00NWJkLThjYjYtZjg5ZTY1YTRlNDI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OGVlNjAzNS03OWVj\nLTRjYzgtOWNlMi0xODA5NmUzYzIxOTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARbjoF5BGHdTS7r2hxErClcDE0rFZILc+Fvozy5+BDh+CqQK/qOJl5F3Df44jG0\nj8bz0j3flcvnhtGcUjCjJVsCo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTBW1/JRBkmn5im\nSquY4EBk6oJ44DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiB2stEQmCp15qt7D/ClipvpjTFW9DdJZKLPl/VvOfPBRgIh\nAMK86/be4x7GrZLHtgvn/668ulNJACKlcFm34WQXzku9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7695", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7695` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAdtCNqeYbXtC8HaaPIURrVFaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyMjU1YjgyLTEwNDQtNDIyNy1iNjgzLWQwYTdhNTQ5NmNiODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVkNjk3NjItZGUy\nNC00ZWVhLTgyMzktNzliYzAyOGY1ZjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIsgn7aKXukcgdaGpAHsEQtEgc9+OtwaG6d1zkAaGHKNBDWU4mleUkugZtq1Z\nIXrmnbMtZNAIg8UAWaXwpxzl7qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHrw9UO66XbXCVwGzvk0dcmIfGXkwHwYDVR0j\nBBgwFoAUBBmngCyPVLoAlW4RGi8covUQpA8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAK1X+jAxtkB5CVks50e4HYON4mwtWqf4UYds71+Xw0VuAiEA6GZxFwrk\niTYdjKP9oGDQ5E396j95raGRjAod7LP103I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXg8mHJySfjV6iw6tt4nmnKoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjI1NWI4Mi0xMDQ0LTQyMjctYjY4My1kMGE3YTU0OTZjYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4KwyJTLYSRSYjNycVc7CURNYzEBEVhW+n+27LINO+jtED\n1SsvN3EQzu7epqc4mU0vra939TPYKi2BZ9fVBTDLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBBmngCyPVLoAlW4RGi8covUQ\npA8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQr0d0bCXLF5UHnV/wmu7egVy+rfWGX8ZnkNeOLKdnMUCIQCy2mbUvnVO\nOPYj5PwgZR1vt1leQnB6vUg5/ULvs6on+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQTINGR4Gz/t1Rqg5hpeM7L5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVkNjk3NjItZGUyNC00ZWVhLTgyMzktNzliYzAyOGY1ZjM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NDcxNTg1My1lMGMz\nLTQyOGItYjY1NC01NjIzMDM3MTgxZDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASNh71BG0McCwqkjgA9nXyGe7jbxNrYGKwdgk0Q0hRsVPPTMr1pSGNvnMgVycop\nF0tU+K5MIOpdMYn+ovtVKEA0o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQevD1Q7rpdtcJX\nAbO+TR1yYh8ZeTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEA/3acte8cAmlyCaim/8kuO7L4jVMLQVbpGCikMAC+CNgC\nIQDYkv2CFeMh42hJEv9rl31zk8dSa3uVV7tPwilblsePyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7696", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7696` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeek/1bGzoGvMLwTg4KbBnx+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlY2NkYjA1LTJkMmUtNDk2Yy05MzAzLWM3MTRiMjQ0NzA3YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJhNDI1MzMtNjgw\nMi00MGNiLTkzMzAtYjIxNTQxMjY5NDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU97AuP5oBV+HGspUq3QWJnDjq76NSz4K79C14nfzaKP7qxcoxUkX45JmEIy6\nu1/jAPoW5lEMloNzI2/K9GM+1KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPSgxLDu3xTDqhkg9aVsX8odO5FUwHwYDVR0j\nBBgwFoAUDQLx9qaCyn/uTU4o+moZ5/RF544wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCID9HmCXQ8q4HULl6+ZpMrJGPVCodXCTBnlnQHh4D08itAiEAkQN2Lxfi\ntzBtm5F/ajzAbEDtSTy89pQsw0b9O6FVLlQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZAfBWTMDP37x9IPUNP+cGPRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZWNjZGIwNS0yZDJlLTQ5NmMtOTMwMy1jNzE0YjI0NDcwN2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwNdFdCQiwqiSrTAtuwii6AGwtlsBZ1nTnMsjY6Mj6cB1M\neg2Hh71WdRqGSyjEq6kdpmKucMrSBUQMreCDwB7yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDQLx9qaCyn/uTU4o+moZ5/RF\n544wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcvP3StVx6pN0VnqIO8nzz0otIAMmuvJUD5QXkyp8hkYCIGSqNitKK644\nxUb7S9TLxGAgafqh7oM6bhP3JJbGjKPZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUSOdqEWJcEAFZ6DDb+roN3EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJhNDI1MzMtNjgwMi00MGNiLTkzMzAtYjIxNTQxMjY5NDg0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZGQzZjNhNS04YzZl\nLTQ2OGMtYjc5Yi1jNTE0MjE2MWFhZTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ7SI/Lp17G6lcIQWonOpSbpLjZZADL5OlSgB/Nas5//mX6zEreiRNlvAocd1tO\njIrW2tlJ8MzcarWyjmjcHzJeo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9KDEsO7fFMOqG\nSD1pWxfyh07kVTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBqkAm2elN3rnpAEQh297BxBUxw2osMSH295nTAjjeKyAIh\nAMmf53FN//UlrYoXZqQb9fntptiR1RIdoTIWNbqdojie\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7697", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7697` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAZAqcTUS2ZyrUbQPceMcjkoNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzNmU0OTNhLTNlNjItNGVmZS04MWE2LTdkMTg0NGQ4NTk3NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzUwYjc4ZGUtNGMx\nMy00MTA5LThlYmMtNjM5NmVhMTU4MDY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiYp/FgEwP38qwIRGu88XwGXkJLLtUEdpqOlI1iniZ/3q+/coGcg/eFlyoFMl\nGeIxkWdjaXahx5z9uot0ZjF+d6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJC2F2jMs424mRRhPWaYucDQHfpQwHwYDVR0j\nBBgwFoAUrEEioWq7Wt1Tru/YuiHHesueSNEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIAekQvksPLr9FP8nq3uo+oPRgCL9x/jPNze63imx\nzOlPAiB5WVSskPiiwiazbngtKNKBpr3sel5QKcYa6Jvwq6LKUw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATPzd/s1SKizUAZMN3d7g/jKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzZlNDkzYS0zZTYyLTRlZmUtODFhNi03ZDE4NDRkODU5NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGGjPogoldNBMjatpkomHQRJxZ9PHxdqnHVdo1p91ht2/M\nX5okkI0wzWANM3roTVENiW2iEwtMKr8smUfAnn3ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrEEioWq7Wt1Tru/YuiHHesue\nSNEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAMoDPJDZN8Sx71ydaH47jnZw46QbktVTq8NoRqYD7c8CIQC5HwcmCqXT\nyN3E41ti2qS5bzerq+rOucLB8Nhkvw1P+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdsLR+0ecNsztBpoAxem4CEVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzUwYjc4ZGUtNGMxMy00MTA5LThlYmMtNjM5NmVhMTU4MDY1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiOWUzNWRjMy1jZWYz\nLTRmMWQtODNhYS00NmUyODAwYjRhYzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATReTMdAnEIH2Vgk3y1UDKNUKvSMYjTGrim7SApPZEAR9k/1ZUwg1RyISMshEaR\nSbWAPq8OOCNvkNasLtd6pfBOo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQkLYXaMyzjbiZF\nGE9Zpi5wNAd+lDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiBZnoYLY/HD8SMLCvC5YftjSBt06Yq7+to2uBGBueO5aAIg\nbumjMyoOL73tGzPE5YL4DFeDPoztsjT4M1Igi6t1JHU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7698", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7698` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAZnVYz/YVgmEid7VPZ+EIgTyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0ZjRiN2IzLWJlZTUtNGI5ZC05NmRjLWExMjczNmYyZDhmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYyZDJjMDEtZDk0\nOC00OWNiLTk5MjAtYTU0ZGQ2NzI2OTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtGKhtzFgAyuViYudpgKtNxV2WHd/vpmJmFx6RbohaGHLqFPjOZSB9RlFm1MN\nuE/qzS8aad7sV6wF2rQhIRn/26OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPKbEL/oy1MdF+qAhh3bczQ2gmiwwHwYDVR0j\nBBgwFoAU+0Txxn0FI4TPBHoGDB6Cnc8r9IowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICT6id4ytwEaLuj9SBmLGGCCUgxLthI6chU2saIg\nwg3EAiBrymWop26u0nJU+ry8+a8kTKREF2+cH2YHSy6BnBlQtg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAav7bqPQN62Y/C4AHzRflugKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGY0YjdiMy1iZWU1LTRiOWQtOTZkYy1hMTI3MzZmMmQ4ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIiPHv3/wXTEmKX/uISbU8KTTfXWelH9P62fSEe92x2leF\nIUmSVET/trR5RyRY0u4tX6bAu0Imw/Rkj1rzAlaoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+0Txxn0FI4TPBHoGDB6Cnc8r\n9IowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIE4IfVVCppMXKaHJzGnRaIfisAonLb3CXcu10CekURMCIEddv7g1xS3o\nNWO+SiAMY5WQJu8vC+dI2ds2slJ7d71Q\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASaCpwIBYbz6ox5+TXYuUf9lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYyZDJjMDEtZDk0OC00OWNiLTk5MjAtYTU0ZGQ2NzI2OTJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NDBiZDEzMC01NjFj\nLTRhMjYtOGMxZC05MjBiMzNiMDdkMTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ4MqFAzBf3nGiLRc0HpA9w5QHtRS3Oc+WwOEEdpso5dnVkgC/GSDE5HjAmfqV5\nHPqJ2JQHG8vpy9PgkuyNWLZpo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ8psQv+jLUx0X6\noCGHdtzNDaCaLDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNJADBGAiEAskkrIVSa2JvxVVZMSGdzGTP93KXwM3tDqIaiVIY+sZEC\nIQCMZVbtwTtbn9tGfPmsiIkneGOXG1hEQ8TaWd2YWWUw4Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7699", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7699` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZ2D2+9XH/8S0dD6nJxpnr6SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjMTIwNzg3LWYyMzAtNDNjZS1iOTIyLTczNzczZGVhY2U5MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODkxNzE1MjMtNTU4\nMy00ZWJkLTg0OTEtNzY0MmU1MTIyYWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg64dWtslCEt9waRyo0MkrOp8KuLGiRtrRtDzcVSRdYEVEYijdj3EgRPIYfHj\nd4b5QheWba9JeOTYY3CIsiOX+qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUGnIQCkjj7LsEYxFOeBG36Q0VL0wHwYDVR0j\nBBgwFoAUJfI4U8kkBSJyV6FTXKK+K4bvd/EwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIHA6BxjhD4otZQIZ/POznPtVG0Lp5ndThaGzbgihnMNUAiEA\n+BeaWxj0EttvD6PuFVhv2Z/aW95ktac7aKgrctRagd8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZhgpMWV2/Ocel5bAlyjy0ZpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzEyMDc4Ny1mMjMwLTQzY2UtYjkyMi03Mzc3M2RlYWNlOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpiHXTOhT8INqOSBPe91+hz3OIbOdhT14xS9RvLcp7dwfd\nOLYzz3OmajG/Zde2itzQmPEtTRGBLqzzvqD/hDJTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJfI4U8kkBSJyV6FTXKK+K4bv\nd/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANN7eV03kAljrVAtRwbvz8hcaEmY7xaNNS6cAC9RMl0XAiEAtR7p4YbY\nr1U1x3Ke8cu8+Ed7yVLSDX8uClgoBLmT2hQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYXl6RlYdArQg2l1CKja+pKvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODkxNzE1MjMtNTU4My00ZWJkLTg0OTEtNzY0MmU1MTIyYWE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYzY0OWMwMi1lNmI1\nLTQ2NTItYjM0MC03Nzc2MWJjZDFjYzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR0xhup4xl8oySPEmnBx9J32emRPn+3PVEgornI6O1+iDzs8JrrGjk0T9Y+Arta\nIdqmvUzqvjwR5SBlj4zDT4cXo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQachAKSOPsuwR\njEU54EbfpDRUvTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiBEoWSDARqBSYt0kkuP7Ihi5BSsfITynGCuzKnzFQGlkAIh\nAK3wq360PJFoCviHPvdjRhTGWS78Y9FLvTYFh49r8noX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7700", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7700` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZbbrGl8bRpthhEQ4JSpCy/AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3MjZhMGFlLWU2ZDgtNGIzNS05ZmU1LTEyOWEzN2Y4Yzc1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzE2YTRlZmEtMzE5\nYi00ZDk1LTgyOTAtZjg2MTU0MDRhODQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyGL3mZNiurWpogo9UqE0QMT+YffhlJuR8ewWzvjgFIdKcEDQ2h6G859faLLp\n3rcGRUKiT6xIGYufcFn6CMf5DKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkSNFrwOqlgH5Jigel+kv2Qz5SxAwHwYDVR0j\nBBgwFoAUe7j+aZTG+pOz+Dwvz6HHZCaTFf0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIHiZ+JECVlHRmyFrkiPlmILK9kj6sn8t\n/jF03dgMT3fUAiAzmtCRFwHz7EaAQEOur6Jv/HBilkHE42P6vpaWmbP8Vw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAboXCPIM3hZZQpAquJ/+i1XcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzI2YTBhZS1lNmQ4LTRiMzUtOWZlNS0xMjlhMzdmOGM3NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUyNCO0lOuKukEEMKV6QO7lg42ejzLrUrtzL8RPj+Tef5j\nuiQWA81yTdqOMPS+yqM6SEkVOcsNsjFtB/b9flygo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe7j+aZTG+pOz+Dwvz6HHZCaT\nFf0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIJUVB16jEZXL89e8k9pjNTrckMyl9RzmzDRJFp99TqZAiA2cIexFLvN\nH3PwXmTQMYJe+7SBvr47z7uJDFEgkPeM2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAblGpZ5ck9K9vwTqb2YZszZQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzE2YTRlZmEtMzE5Yi00ZDk1LTgyOTAtZjg2MTU0MDRhODQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3M2RmM2IxYy03OGIz\nLTRiZTUtOWY3Ni05MWRjMmEwYzRlYjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT0BAlCuhehCSOy4U4FSPhtC0/CJ/yTHFyKcRMlYd2ESIu6RiGYVyCfsnDV7nto\nYkyD3xsHxgwcr4cI4cK8eiFdo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSRI0WvA6qWAfkm\nKB6X6S/ZDPlLEDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNHADBEAiB1f12DMDuyhWqGfS1IvJsZbkdgV7b0UxtM85qtnLkRfwIg\nBHhhBa7eqbwVviIkOnAgWmzRn6VHdbC+7eOYcTNkIUk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7701", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7701` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAZvLipCeEEGW5c63BDb7UuT7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2MGQ1OTBlLTIxNjUtNGU2NS05ODIxLTBjZjQyZDk2N2NjMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU4OWFiYzctZGYx\nZC00OGRkLTlhNWItNTU5Y2I2ZWVlYjIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfWSYc7D1HfRbn1wvLvQyJCS1J82gMmHf35jSwJS+u0a48BtZQqLMSjncuNaB\nPSJZRtDzaUfOgNDLste2JIPgfqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBkVJ7FUe9dXxtwUIsKd44KzkZ7gwHwYDVR0j\nBBgwFoAUe0hKq5MJbDPoJ+ae8j2Ko3R4DSswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDMDjJeFFFY7j/IUCIy6V6AvjmR/3mc\nG57HZDsPmZLBEwIhALW+r9gVFe+mzNBRSyD1EyBh4e1wlillM8KsyWLy+pFV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbe6j12oC9St6xFWW41SJuxEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjBkNTkwZS0yMTY1LTRlNjUtOTgyMS0wY2Y0MmQ5NjdjYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOI7tdzfWwZgDSTQuchf7wISMewyj1kuIFF/KR5oqk0wY5\nZ3DGNJlsp50fSzZQsS/eFfxkum5G8Trknhq7zt1Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe0hKq5MJbDPoJ+ae8j2Ko3R4\nDSswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUjQzuLckCxZG6wcR9RnTCfC00mtE9zQfWyhW15FtG80CIQC5s9FqD2gV\nWDB9aJKEn65iqIIzvQlfuntFreOFECpRbQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATOORSY6w1geM5Fct75kyw4CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU4OWFiYzctZGYxZC00OGRkLTlhNWItNTU5Y2I2ZWVlYjIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMDVmYWRmNy1kNWM2\nLTQyZTYtYmI4Ny01OTc1ZWQyNTMzM2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQZf2X07QOmzSp/kMW4CWeMcX1JWMzSjtIbc1vouT0u99QJMEV12Qz4arfuc+Ip\nxD8DKy3Rh18PQwkNejrnaQLDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQGRUnsVR711fG3\nBQiwp3jgrORnuDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEfwAAATAKBggq\nhkjOPQQDAgNIADBFAiEAjXpH30sXwYQm9DbxguEXv5m3+tNABBj1ULO1vHwr5EEC\nIGA7I2+R/o433wvZdUOAu6JHSVg0Qcwz4eKbCd3k82vf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7702", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7702` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAS8Mqby6UGOfm4ccxdcQMWJxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1OGEyNDRmLTFjYTEtNDg5Mi04ZGMwLTU4MjZjZGQxMTEyZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzMxNzZjNDUtMTlm\nZi00ZmM1LWE3MTgtOTA1ZjExYTIxNzEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl5OdOTsUW5C5gtRrqf2q7hurCQ2clWMdoYFRESYD0H0ipg18RfFFQ6DT8LxM\nLJu9t0Ft3QceFx1NWlnqaQdR1KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC+4EcAQl8MggbvN3D7JV4s0KdTEMB8GA1UdIwQY\nMBaAFGPwJC8UEzKf7U20GRDhOsAtpfHHMAoGCCqGSM49BAMCA0gAMEUCIHq2sNCc\nyoLnIB8khRm8SQG3v/yR9nAEKXzC5w8j8T5bAiEAkvMSBtG/cE1BGUbod3FB475C\nNN3mh5sOBQ7zVD59nFM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZZeYz0I+iwLwRIH9SodfXJYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNThhMjQ0Zi0xY2ExLTQ4OTItOGRjMC01ODI2Y2RkMTExMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXrglqVm3r8IScL9gA7j6G/aljU3cFagzzCpNtoLZ2cLYc\nXhPV2gjOhdrn9azHGUIO4jBCeH8Rhb1jLHlIobico2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY/AkLxQTMp/tTbQZEOE6wC2l\n8ccwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZUxnnUooshyqTnWY/mzjFsmwizem1C1Wuy3mAtzfbQECIEaEejiq+y13\n+kZribkMOhQXuKMR5KEpENEC9oC+YEk8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVFcD5MiSfrNZ5hXltq1SMWuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzMxNzZjNDUtMTlmZi00ZmM1LWE3MTgtOTA1ZjExYTIxNzEwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZGNjZmZjOS05Mzg0\nLTQxMjItYWFkZS03MmU4ZTFlMzVlZWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ4IlxXRWErOAL14RcLRmi0uqQ2pzJkh7dVp5S4QCQkG6PwNeIVnO3WCHhxcyAE\nDchUHe8sKJFjfZewrsz8MuXpo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQvuBHAEJfDIIG7\nzdw+yVeLNCnUxDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA/6lqYgOIB/oyqqVojVO1irhwvZEDczosKdHxodQzQK0C\nIAio1j648SX/ZpYR2twKyssU8dglQ9XyxYNGIWJAkWyd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7703", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7703` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWRwdCEuugYwY57JbWjJ2a8GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1ODcxNWIxLWQ0MzktNGUyYi05MmI1LTIxNzdhNjJiMWQxYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNhZjdiZTYtNzFi\nMC00ZGJkLWJkNzYtNmQxNjI1ZjUzNzFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs6+Z0YgCp7EG+oDaIJ0ZNUkM1lSBgB6BoCDzCQ07kFKw09ZSDyNBUsa6L/84\nJNXq8A6GOqcx8XFpfhvA+Hw4yqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCySH1gDieCuwjOq6CUItOjCD98HMB8GA1UdIwQY\nMBaAFF4GIdhn28s8WgPh+h3x/Ab4jXduMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiACzbY3BL2GCq039tCrc0P+5uxwbJbx8jEt\ncNQAceJFygIhAOgZVx8xUR9dZWIcvB2vfu2L9SUf+4ETywfKzPNWJe+S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQGCE9UwRsJTPixTXQw0Kd0SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTg3MTViMS1kNDM5LTRlMmItOTJiNS0yMTc3YTYyYjFkMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqoxZfL22nQxIcx59Edur2J6vkgXBwO5ptlqOmULEnb7PU\nBX9KUJNweAnuNBMy06NeP1mdsmVGSu6DBkrFynR0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXgYh2GfbyzxaA+H6HfH8BviN\nd24wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgI8NjHpCfh211VEX+gdCyjLYBH8T6MjWzOGdJBiFk/lcCIQDGZLOLrKLp\nwxf6zY6x+GVGpLOdJUSNb2t6ecKWFtV7KA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYt4wuMxxVnrp9iS5Mn6V5KGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNhZjdiZTYtNzFiMC00ZGJkLWJkNzYtNmQxNjI1ZjUzNzFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MDZiOWViOS00OWI3\nLTRhZWItOGRkOS00ZTFkMjFkMzA3YmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATieGm/ww+z1B5bhPk+tBybfsMlyRp8aLxD2qzMzsC65YeOoxObMofrKx+kI3fX\n7XMDXpsfpKt/rPgABaNQ+8kLo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQskh9YA4ngrsIz\nquglCLTowg/fBzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBwuGzX6MfkULrrB2vzQqua7J321zs+qyD6vQoBxQ4pqQIh\nALvsMStpArobUe4xpHJ1RBjSRER8yYabIZY6DAybzpDT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7704", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7704` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVzyhExsmisrH9bljjcX6PyLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyZWIzNmUxLTI5YWMtNGMzZS1iNGUwLWFiMmVmYWVjZGVmNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY1MDViMTEtMzVl\nZS00ODkyLWI5YzgtYmI4ZjI4ZjVhMjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMEacr/8Dcowh5JjCwxHLPRrXu//XLE7n+jzKi89nABYDt93vw6EsQef4dnX7\nrqkqh7Q8KerFJKTOgELgoQ2fsaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFL/UWXhYwBevd13UszQe8jTCCYijMB8GA1UdIwQY\nMBaAFDv0AtBfx4jXL5JsJjnBgKxKZFIBMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiArOmBInGE4+E7Ox7X5cO834asOVxTQZA4A\nQgiVV3pY0AIgZLzNjah2yX4lxbZ2qdWDH3cbXuSFc1yP7HiJwHjlnio=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATCMXKnmrEFqTqTeJOaT0HmIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmViMzZlMS0yOWFjLTRjM2UtYjRlMC1hYjJlZmFlY2RlZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrTP/iR3qmGn6KQ3amZ+b1obVs4WfCrXioy4fOhKiRIB3b\nMA2mgzLZS01bwDYXP+2JM5LPAxjPN9brJDA8wKGOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO/QC0F/HiNcvkmwmOcGArEpk\nUgEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFrc8yf5mNwrWubz8nyV87kSaEfoMY5ePu+hKAyjMG38CIFau1ohSlqBy\n1crnXILixHOS5+n2rcMZFDtzndMOt/Vo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAU6+gnG7yjjaUA1ZtnOZteDPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY1MDViMTEtMzVlZS00ODkyLWI5YzgtYmI4ZjI4ZjVhMjY1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMDM2NTA2My0xMTM3\nLTRmNTEtYjY5Ni1kMDljODU0ZjUxZWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASc4N+Zuhb4iiprlIW8lm3p1Ny4Kbf02KGkKV8VdkjqQaTcHPAnvUARfqqrfjkU\nGuB+fhTR/qqWyOKGZT2kU/WGo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS/1Fl4WMAXr3dd\n1LM0HvI0wgmIozAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBhQy0A+7ZY8JMIRJlLJOtsIDHKvLiG/uKM0MMpxHTsJQIg\nL08uyQzIgnQ6mGkmAMKBNSw0W59u0R93g+aSSP6JccI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7705", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7705` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISATOxfKFjub4V4kvPfbNkSgcMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2NjA2ZWNiLWNiY2QtNDY4Yi04MGIwLTdkMzMwNzUwNjA1YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RkOGZmNjEtYzM0\nMi00Y2M1LWJiZmQtYWMwYWI1MjU4YjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBFfiFUwAWJOkONZCAz3bpS8LN5hMzvTgT4cXrv52pd5qIx6hd9eF1LbpBBBf\nfM61hMLofl3AFCesBdFuJf6y5aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR/tpTLE0l3hsB9lCp+D0NudrhlCjAfBgNVHSME\nGDAWgBQduo/BuzfpCMcxqWvRecUUrTB6pzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAEujN6TKz8E8sOpq5fKR53WNPwR2taM\nTsS3P57UOwkJAiBchOqR6bgvK9+fBIJxRgUKvXCXRZ4/9QGNoXpnSt0zhQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAceJzyI4gwaz7r2RcLbUOwQjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjYwNmVjYi1jYmNkLTQ2OGItODBiMC03ZDMzMDc1MDYwNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcB+fO+wdLAzaTDlN24aApy3DHC1FGUqWa94++3DkV2Md5\n7NfyHigtdBvIzpvW1YGKQjjk74UaOIWNjusI4oYro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHbqPwbs36QjHMalr0XnFFK0w\neqcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKWQ9hZebtGmka3xJfmM0PkPyomJoFoFRN8wupZiD467AiBai7VPMCK5\n2gnS5ntqRzkL8UPh+xIaLei4f3V5Qr3Cqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAY+E9aeF4ahvZ0OyI5g7cjIjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RkOGZmNjEtYzM0Mi00Y2M1LWJiZmQtYWMwYWI1MjU4YjA4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMTkyOWFjOC0zZjRh\nLTRmMTEtYjlhOC1iOWNjZWM1MDkxYjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASkCVRnuNNrPhITNYZKGKHPelFOsRdd/mNVfdfLCs7Of/fIJbtzUR3bNx3vXzr6\nH1Ej3p9n9XZ0magPylQr+PWro3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/tpTLE0l3hsB9\nlCp+D0NudrhlCjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA+8kHigfUnA6b5OSdDCq6CMaOplSIEJwcVdVAvaXBpt4C\nIAl2/EPXKASlmixsD+sREiWdS8vRXhoRCueAsCc2/qzB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7706", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7706` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARsxJ7r6Fk1BZedplXtaBkl4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkOGQxZDY0LTAyMDctNDVlOS1iNDRkLTEzZTQ5OTM5YzA4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY3ZGQ3M2QtMjE3\nNS00OGM0LWFkNmUtMjczNzgxZjdkMTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFy8koUv4lsigYNC+NbN85lxIvyNV7xCGScpRFdTAxdYUOOPZJcp+XwwUcKYO\nz2+yn6DX/XOdAXF2I2aTJdaD26OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGxsh91E1X5gekMT+JW4P41/avXQwHwYDVR0j\nBBgwFoAUm8b0iAJEGzM6jeoGvN5C8NzCP3wwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA3aBm81c9H1yA\ngd6Ed9gVVHvl/A7gKuyVXYxpK2rwEBACIB/kBHwBFChSvBlmOqk+9XKdF0bk7jkv\nGt+jRosXtStC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfNKQRJLoZKhW8n+uW5fLjRcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDhkMWQ2NC0wMjA3LTQ1ZTktYjQ0ZC0xM2U0OTkzOWMwODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS59yZUx9ODxyaQMKVdI3WE0gO5MMGWSd+cX+ix0ZaHMFLV\nlsKAPAszehKKu7onpy10nQawLCtIRsGck9/+JGNUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm8b0iAJEGzM6jeoGvN5C8NzC\nP3wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMFu/nRpgubnZQqL4SSjJexqybGKQMK0MW2MpokTNDzECIG9clnLdZVpj\nFg1g5GENQy9LzKf3/xdEV+UBoGaHvsUo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISATCgL4q7FgT/gTfHLG9Bir4uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY3ZGQ3M2QtMjE3NS00OGM0LWFkNmUtMjczNzgxZjdkMTY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMzhmN2RiNS02Mzc4\nLTQ1ZTMtODgwYy0yMjU5ZjE4YzRhOWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT8etkVwKgj+kdVagTzwtA3hSSxXeIFED1WsGL4YbFOk8LrHV6j4+JNJDu2jZxy\nxKoowKBfwuFnyxMOjtILDCLmo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQbGyH3UTVfmB6Q\nxP4lbg/jX9q9dDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAkfUGeVEdHr/GEA2kTysCCSTUpsoxdeQ8xKeS6cwK+ugIg\nZxzlvdYC5KySPT0nkb5/wSt5l3HsTMWMdTiN+i2GVfo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7707", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7707` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAVhw6fA9SR5UKvbrFy5OaYnkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2ODkxNmVmLTZjZWItNDMxNy04NTdlLTVkOTgxMTExYjJhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIyYzNkYzYtMzdj\nOC00ZDgwLTk1NmEtYmRiNWFjODg3ODYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIwJnefLUCIkn/WQl3am88pWFSfEwqUINUTbH2B79YAtdTi9+DOak9wJOCdSt\nutDC2gLTc7HaZV7b2iqWGWyKLqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4zCRjDyXuB7BSu9edrh1ptycLswwHwYDVR0j\nBBgwFoAUmIADISqroNevwkCe3JMDUq99+6owJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAy7xYbYpirlwY\nzLlD77lrGMEjCRdk7WCLV4pJJQh+MhoCIQDdFo5J1zkl/ntvI/0Iq+BF10tlJc4H\nd0cHdq9TLXRWAQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZugfGm/oNJxnndSfMPx9k4CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjg5MTZlZi02Y2ViLTQzMTctODU3ZS01ZDk4MTExMWIyYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpj7tVVF0Zw1i/89bAsVPUYHnXEZcaFe+IvqFAsQBMRUY9\nrcF0ZCf4GCSheKgpeZ8Vu9dIiUh4f6vfq9rPkri9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmIADISqroNevwkCe3JMDUq99\n+6owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALeEUjWjm3914dVsYq2EAFcPKl4U5z2F+k7y8BySmWF+AiEAmzQD4Ww6\nHCZ7U+RFa+AXDFNM+eTEHaaX1zzhm+/QVfM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAVi6Jl9a/9gXWtFp6s/frdUUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIyYzNkYzYtMzdjOC00ZDgwLTk1NmEtYmRiNWFjODg3ODYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMGJmZjA1ZS1iZjIw\nLTQzZGYtYjNjOS0wYTAwOTk2MjM2NjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARws9DFzvV0Wd3WYONKf54l9aln4yIXWHkaxrpBuhKBpQJ30AyEhhr3n9rOCZaX\nIDSqnFjlRVl2LSDFV6XprGReo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjMJGMPJe4HsFK\n7152uHWm3JwuzDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiA0r7ytPGdNUCGbPIbnVWQYdrDZRN891oQoBjf3Nm7xDgIh\nAOEOhnC0P4gvzz+wSNQhGWRrtH6tKUs2jYUdU7LuEGHe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7708", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7708` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAYZH0xyMubyXLtpfhfeI53tIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYzg1YWQ3LTM4NjUtNGM2ZC1iNTI2LTc1ZDYwZTZiNjMwYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA0Mzg3MzQtMWNj\nMS00NDA2LWI0YmQtY2QwOTY0NmJhMGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3ZUeojJ+DMr36vxb1gAh4r42Fd1Izz6FIW1+S7hsq9TwBA+OmX8cRJjmDzd0\nt0UijYJSNkZshZjo9Y613F4UgqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm9R7tXULozRz1rgPs+ohmJSQg1cwHwYDVR0j\nBBgwFoAUTSpDoQgIMSCrBuI4pRfNjSuy8r0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBsi+uw/zKpXgBKnyWCqLT+\ntjQCLWtwhT/sYi32WAEySAIgEt9nfHKGWe9N8rHncwiimOgFmyt1Os5UfJ9lXs1D\n3gI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASYylNfy69yzgt/amx2oaLLmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWM4NWFkNy0zODY1LTRjNmQtYjUyNi03NWQ2MGU2YjYzMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZRNRb4wBYu1Rk9IgJmhWoA2FaOXR5LoxFAueEg+WvxngW\n88sczmvvpfNnNO1Mlezfl0aLkkBRsLRFfZYRkUseo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTSpDoQgIMSCrBuI4pRfNjSuy\n8r0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKgMnelj5ScIjqeQAqbELlGcLu+DD90jtzanDYnsMtpFAiAQ68RBexFJ\nYmGu+e6/I74ro0t5YLbqeemsrbvmteXJ2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAR3IlJokhMzM9nlPtDMN68s1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA0Mzg3MzQtMWNjMS00NDA2LWI0YmQtY2QwOTY0NmJhMGIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZDU4NDAzYS05ODJh\nLTRlN2UtYWFhOS0xNThhZTU0MzZiYTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATHgktP5/Bq5HOJO62xu6THictIVAQa32wdkHXHwlam0OIrpy7BrseoI3ynKYT/\nkRdzEJ3hs7diwVJdzEtlndHUo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSb1Hu1dQujNHPW\nuA+z6iGYlJCDVzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA44YQPtL7/Xo1B9W6dj+SbeVBxKR8mHVMea/xdkW2C+oC\nIQCVZMkILTO1dHiOP2umeMdL5hZxnrTw6sOkN+cjUjOeTw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7709", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7709` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAVMPvIAtrUNsEaOzx8OK4wtgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhZTY4NWQ5LWFjOWEtNDVmZS1iMGMwLTEzMGM0MmY4MDllYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ2YzcwMzItNWY0\nNC00NmYwLTg5MWYtYjUzNjRiYjUzODM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPqo5Md00YX9pl8pbeT5Xlc0dNYJZoKg8xQqK9O+8oAjLQ1ojRzXQWXT9Sq/K\n/bFS1GJUogqKTRCC5o33BrBfVqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPlGI+vtCzcmB9zh547nt1K/imOkwHwYDVR0j\nBBgwFoAUqUHImoa6ae3TIah5d02sQml/SBswLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAqacb\n1W0yt0zfCzbog6JHCaU77M5n3hjLTlz9gYefFvkCIQCI7152snuYwgLwidMESRg4\nJOdU6I3FznqEngxCz/foYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYmWkXZxeeasvowexFXuuvHGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYWU2ODVkOS1hYzlhLTQ1ZmUtYjBjMC0xMzBjNDJmODA5ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBlXRAz7XTLMQdr8gvE60KXkmNo5nqDUBwPBZwy0+tDK6b\nt/Z1SHMsV6n494ZlYTXOaZNrNQeUxZgoH5a0uXlio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqUHImoa6ae3TIah5d02sQml/\nSBswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYAFW4Do9BTzjiqTfAAXD/tzBTDAneVCDc+lgbWlqjwwCIGoYiXC2MlYI\nn9yfY+DnltQLixMBNvOzYGQQFKN0hyOe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAU0PcPluEenwhUUDsMmtxF/+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ2YzcwMzItNWY0NC00NmYwLTg5MWYtYjUzNjRiYjUzODM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYjYzYWUzZC0xZjg1\nLTQzZWEtOTU3YS01OTg0NzBjZjgwYmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASNCwahqf9BqiQ0MBUdY3dvyy21+f1PFgrpG8danQ3vaZTJjuySHUVj6bQqsNcM\naaOniM4d/xDQGbJ2EFywVcz5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ+UYj6+0LNyYH3\nOHnjue3Ur+KY6TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAv6FYXyhYnHhYvPh34I2mz3Zdyp95m+/Sc96OYfPDPcAIg\nf/8btiTCu94uVyyKThm+ZKkitjDX9QrmwQk/nh9pes4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7710", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7710` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAQTsBfkncT9w/JelmDvb8/TDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwMjk1OWQ3LTNmYzAtNDU3Yy1hNTgxLTMwOTc1ZDIxZDM2ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY1MTEwYjgtMWRi\nMS00NzAwLWIxMTItNzliNDkyNWExMWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQq7VZW0w1YkEMmhF7v06mnXnluahL/teo4GrrfteQ0J1UHKP98YCjDXErS32\nmLXJMKgmxAk9PRXcsW7JoaLEJ6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSRudviTqzlEXqCez2rzXhABo62AwHwYDVR0j\nBBgwFoAU+H7GTmmdfGphu8nkNlFN3kSWmc8wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBSOGPG\nLrEQ/QKpnJj8fO8MCKCNkcwdzbMRznVKCalTfwIhAKAfg5hy+0wx0iVcjf9EqioG\nCPL0GhPm2OZM1a8kESQl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaOYxirxGj7vaznA9Exc0IIDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDI5NTlkNy0zZmMwLTQ1N2MtYTU4MS0zMDk3NWQyMWQzNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyoI38naHaYrOh4Cm3ZeK/k9LW/54fh5j6IL/AVnAdYRN8\nUywQV0Bq6eHgcQCf1WOIcVyPMU4L9rIc0z9hfVjIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+H7GTmmdfGphu8nkNlFN3kSW\nmc8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOI0EEh0H8V5EZ3wv7I0lvxqwGsr6yJgws5+CEgRYFf0AiEA/zGZYNwZ\ngxGxqzwlSb4F/EqYuf05TWOTWCtHntMPtAs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXBEWCJA9mR0hVwGDP3FO2nsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY1MTEwYjgtMWRiMS00NzAwLWIxMTItNzliNDkyNWExMWQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZDAzYjY4OC04YWIx\nLTRlNjMtODNiMS03NTYwZWFiMmQ5OTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASnvO+mp+U8NKOfSuI34ML0J+msxCxKfc94Zv5WYmld7YPp9634CktD3j3GuXnF\nrWh/Q8/T7K+P+ii9Wip1a7Tio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJG52+JOrOUReo\nJ7PavNeEAGjrYDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAkyN7FNVqC/W27gwG/tmn9sEGyKrN51kOP9Zp5gzxWaMC\nIHPA+WVgObeltZD/UHdcEgs4s9GwohzdpMq0J/a2Olkt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7711", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7711` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWFBArxuwkhoo0PW3iRTePxAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMDlmODNmLTE1NzQtNDVjZi1hOTJkLTc1ZTk1NmYxN2YxYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVlOTZjMWMtNjhi\nZS00OGIxLTljODgtYzYxZTEzODcyMzg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElS6O9/C4X0+A0+qvBpdYGndQeES1Yv4mKnHHTpLsctJHHmzkE3PQ2Jies6lD\nijIbY0pqpxxVj4cEwZQ36DnZxaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGmn0FZLdwlOUr2VGaP62prS8RTCMB8GA1UdIwQY\nMBaAFAkB2uRccaYHFTpMRTqitwJNxHbuMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAtfMduG/NrOS0brS/Os9rRX9iQjgvqmU9f\nABn0FX88LgIhAJpjw3ykMFyzrZmzHB97ceWyhH7CSkPav5+TsVbQDbeD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR0GgFxJpmlF2k13C0XjNa6xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTA5ZjgzZi0xNTc0LTQ1Y2YtYTkyZC03NWU5NTZmMTdmMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCKyckka72+2dhYZvoJhw5X6Rv5XyQXNd/Bk1XEVIx9+zO\ndd0vMu0z/L1Q8YTT3U9pEbCZsxYaxcp/Js03fY/wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCQHa5FxxpgcVOkxFOqK3Ak3E\ndu4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdnc3DZcbF84L35qMvY76oQU+bQPoqmEihqRY2YkcqdgCIQD/ccR2jNSc\npUfOQZTr/Ft1KyIy/4NIjxx9MlYH0fuZJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAY52TOTTUePWTk3gQ0Somw45MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVlOTZjMWMtNjhiZS00OGIxLTljODgtYzYxZTEzODcyMzg2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYWYzM2VmMi1jZTVi\nLTQyYmItOTRhNy0zNThiOGM0NzYzODIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATFaXBXTIhMrHH7uUlYAqkqk5sJtRW3Rc1YgIajLuA9EfBXxMhHc/NGMav4miDk\nss+wVOKkTaMXZ4h1X8WqAOuFo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRpp9BWS3cJTlK9\nlRmj+tqa0vEUwjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBCqBJjPnKBoEyG2Zhuff5r/BVaRWfYuaV5HI7Zv9R8ZAIh\nALCtgdLxhjJr+NmpEfQAdtLjbX3R0SmuAgvqhVMuf+QA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7712", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7712` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQi+ixvMjSBNtvu8HuPGQxUTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhY2Q0YjEwLTUzOGQtNDFhNC04OWFhLTUwMTcyMDA1NDBlZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgxNTkwYjQtNGQz\nYy00ZDRhLTgxMjAtODQwMzZlZmVlZjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElwSE3ipiNrtQ1vbBnqsgUKcNrFp3+psc2BfDPf7obHjEmZ2kopfSvX4WpklB\nuVpzztdog6nLDGv635v2WUUO+KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU35QqHNeaKKLMjjbo/vkG4u+1B18wHwYDVR0j\nBBgwFoAU9xpCSuuB1FC3s/2ma5G7gNx5jwQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPZDzZ27NQ5L\nrNIaYuyPybTntccS6H25TS0zVFiFCuSnAiAklzkdROrNdO54kweY9ZROjBwzD4vf\nj/f0zfvREapZEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVUHXMkwjkigm3J0Q+jGszpWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWNkNGIxMC01MzhkLTQxYTQtODlhYS01MDE3MjAwNTQwZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFQzEKeIKrbc3cxjqwpzGkgxH1WuRbkwIvHrhqewR7Ds/C\nPoMBriHlosqE9Gq/8A17OjlQMsZCRJCsZZ8m8cUro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9xpCSuuB1FC3s/2ma5G7gNx5\njwQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLONQgs5MfPcsf5HOeP80uMENoED8kLsHMESNiF/fUyACIDiI2OzGTcJt\nLiJhJ89Kxmp2i+M20qRghKETnRtejf0X\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUDT7nfLpdK6sS/GjkQaasY6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgxNTkwYjQtNGQzYy00ZDRhLTgxMjAtODQwMzZlZmVlZjY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNTY5NzcxNC0yMGZi\nLTQxZGEtYTJjZS1hZTMwZGExOGU5ZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQyibzZXrXf9RL3cJb80XhNBGoF2cLoHHake36McVS3OeLSqQ4HF8oUoh0LrI/2\nHRo0EvcAoVN2HLGfAOFDXBjao3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTflCoc15ooosyO\nNuj++Qbi77UHXzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAz4wt6Rb7h5V3nMFboL//B5gTldzlvco0yIwD2H78YmUC\nICs23wO8kL46GbqZFA57UsfdBV2ovKKk8u5K0wFkt733\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7713", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7713` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAconszsPBeWfboTjrVQTxZVsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3ZjBhOTg1LWYxMDctNDRiZi1hZjMxLTlmNDllM2EyNjU4YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDMxZDgwNmQtZmIy\nZC00MWZlLWIwZDgtMzMzMDMwZWQwNDAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHoyJR0fwM9n4Asg4eqU1D77bQAFzq9pWe2yLRW46moHPtWK5RjIYljLDjfNr\nMJovqKXgLXkIRT2rlzcdm7zvE6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUku8/YOeXj6gRt4YB+2ithuaIu+0wHwYDVR0j\nBBgwFoAUIGNmKaoUZ7EX+upJs4Orh9XCcOowKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgYNFZ8PpDD9Cl\ne6vVWtKv/Xxo/fUTIdTCJOsnRvRAWdcCIQDnWUPN9UGOX8PMaQ+UXDy4m/JyxwDB\nyLLgPy+uBgVZEA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARcNFcqf76ZSwOp2R545pFt0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2YwYTk4NS1mMTA3LTQ0YmYtYWYzMS05ZjQ5ZTNhMjY1OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcYcmjt5qtRl09Z70wLs+Q4r54SJHco2Rk9DDIQ4B+iy4j\ncLXkwB/gqga4zokRMZ32L2kT+WD76Vw9KYBgPGDoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIGNmKaoUZ7EX+upJs4Orh9XC\ncOowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgemSkOMle+LE/8AvCwkuFnoUMb9UAcZ8MdoUwJA7vphwCIQCJDyp1tdyI\n+DsHjC3EY+dlRr5YUSKA1tgZfy7h5uCyxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAQT3uXiXNu/n+wDSuhjxZapOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDMxZDgwNmQtZmIyZC00MWZlLWIwZDgtMzMzMDMwZWQwNDAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZWNlNTNiYy04NTUy\nLTQyYjktYjA2ZS04Y2Y5OTBjN2Y2YzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ4ydq3IsQW9vYQGqHh2b2NrjlF5Ehe25jNo9q22fs9HBrhAiotkn2ihusHnh24\nzWzTKHddIInXK+yJv70QvwOro3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSS7z9g55ePqBG3\nhgH7aK2G5oi77TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAKZDTQgYPBLfWgGIu1gPNaVIV7F0/I0JJZa7AGzmd8RAIg\nTy+KW6JpeUJKrnVm1w3lUe+7kqIg2q6skI1zhBuLF2I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7714", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7714` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAd9MN9QJ6Z7wb7Uxx72KWfN1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2OWQ0ZmJhLTg4ZDktNDRmZS04MjJkLWUwYTBmY2M5NDliNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWIxMmM2ZDEtN2Yx\nZS00YjA3LWJiZjktYzZiNGNmY2Q2MzU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5CvyBbsQ+R7iMitsMQhZIb9PpOvf3omog2g4GhzLPmA61aElIV0kXDP1wg4C\nqepma+JgFoOqx1XlR64TzKEI9qOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1g7T0XkoZWHkIxwrO91Zh4DjpE4wHwYDVR0j\nBBgwFoAU0BCs6OyqzLdDmDTCFCFh3CEwExkwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD72v9jaBj3\n8dQcN85H5om8jtVo9aXdJlReb+52F9bhjQIhANgok51Hcj2sz0tnAMtfIsj6IRJF\nW4WpkjgVp73+/hv+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbGKkzKuxExvEzxX11PWJ3lmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjlkNGZiYS04OGQ5LTQ0ZmUtODIyZC1lMGEwZmNjOTQ5YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVacWGZbdmAacED7NDiNw96ReH5VWGf5SpkFumowFf0WFw\n4/eQjSr4yENIRVOJaqmnsuYBTm8pikM7RFZmXJ97o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0BCs6OyqzLdDmDTCFCFh3CEw\nExkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOaWSu+B4VuWHUkCPvdCvmrm1e1e5/vj3kF1JlORGnXyAiEAoLgjQH+D\nvSR5D8CRp8aaKn5dhjWTIHDEcqa0NKO3c7s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAUk9/keEW5FyYeoM6w32yxn7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWIxMmM2ZDEtN2YxZS00YjA3LWJiZjktYzZiNGNmY2Q2MzU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZWYxYzhiZC03ZTM4\nLTQwZmQtOGNmZC00NzYzMjM1YWY5ZGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQGBqm7+Gj2zauBkYXLCAogwzqQr0jojVM1VBBi9DKbcQcTxXwkLIeYr6Xj3rEU\nN6xczX+cRBrEeJBmdgIO3Hgwo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWDtPReShlYeQj\nHCs73VmHgOOkTjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA4txv97fjwFMQvQbjMOCqUCX8TR0J4TfjdWTJnqSQ1ioC\nIQC50EbDCXBQkNpjwTYxAcxwbbaJT1JCypnhoqDB50Ggug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7715", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7715` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUNGGi9XHqbpJ9W2uuZNZzn8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MzJmZjE0LWJhZjEtNDYwNS04NzgxLTVkMGMyMGI1ZDIxZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWM2MmY5M2ItNDcz\nOC00NzUzLWFkMzItODJkYmM4YjRhZTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6oQBv6qu4VizoIyrfrjzf3gpRHHgpxudkUaVdh/VxhU8aFso59I7GDzafAtk\nXPudGLJZHnS7MhuXhNmefPRrF6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5N1BUAxXhD0AtbCvWi5TIpFnMWEwHwYDVR0j\nBBgwFoAUwiowoQVurAJboIsXWy5TMoKqxoAwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIEnPBeH65/guYk4Cw4kOW55zaFFoUPhDO8y0SY/6ApAOAiEAwPW5KFxIDgxM\n2v3pB7O4l8zMhbtrQbI0beErFOGa8kk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfeHGDUOpm58J8WMBHRYjxtKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzMyZmYxNC1iYWYxLTQ2MDUtODc4MS01ZDBjMjBiNWQyMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+UyR/2Jqz4eDoGiHxNAoHRMLkUtx5YI67ORUJxKQdBpjC\nGIhR78TMNAX5roG53/zah1U3+x/nXExyPy8Ftkfto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwiowoQVurAJboIsXWy5TMoKq\nxoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMfZ+YT0/pxcGmp6Eud+EzW8hZq1RN7OnbN4OqUEZZnaAiAeb1Im11qj\nNfgZAqROKMnOUps59e/xw7W6vkhFtEyi0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfrMG5s6krY0Uteti28QBHOOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWM2MmY5M2ItNDczOC00NzUzLWFkMzItODJkYmM4YjRhZTMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhODQzMWIyMC1jNGFm\nLTQ2M2YtOWQxMC1jMzVlZGU4Mjc4MzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATV6QjlpWHpQ36egRqNf37Cr2qxGSvFBCuXff1DA0e4IxfMW9CT6makJFj3DmJR\nyqG0gwFBvqTl0K34PCVDwyY5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTk3UFQDFeEPQC1\nsK9aLlMikWcxYTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBkm+5Hb1JfYhBh9SfwdqisNsPZ+28rZXyt68v8FNe9qwIg\nfVxRX2R7rlCl7s/F3EUAjUYIZNvOlYiXIFa6o2oYVsI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7716", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7716` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUExBvMjp/tSL5F2s6OUWa7JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NmYwMTk2LTJiMzgtNDFkOS05NWFlLTlhNTlmOTg5Y2I2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNmNDE2NzItNzEw\nYS00ZTg3LTg3ODEtOWRhOTBiYWM5ZmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtUNFc3S2RSslSVcKmun5Ov6/c226hxI2qwII+LPTp/2DtuZvEyyepVTUUyy/\noj4oPREvny8j358KEptrMw3O56OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU110DdFGFY4amtghZS0MMqQA1/K8wHwYDVR0j\nBBgwFoAUSkNx3FIHRLQ1fXKkknaLgjWXXqYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCyKCofN+Okk2s1rWENjvjcItnUmnjd77rKysFd8Nog4gIhAIeo3RgLknKI\nJbRzo59bW+fvE+U5qD50PydY3wHG/AUv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW2ekXJstQZeQrV+1GpTQLjYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDZmMDE5Ni0yYjM4LTQxZDktOTVhZS05YTU5Zjk4OWNiNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjbwdN/O+Ju2YpG0TqIWkk5KKPqbbAUV+MXjQ3+mPmgHB+\nU5oX5Dwn8n7pP51+Qi34e3B7PZmOrtwQ3zEYVSmwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSkNx3FIHRLQ1fXKkknaLgjWX\nXqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALAqmtvrotYEecAOmgIlqnPFOelsZq4TPFWCi/Mv/xt/AiBL8ob0w2R3\nyOp8sVHOS4mESoyE2STNNLxTLsL3cgqLRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfBNNBP5AH3nnPyCUCWB5KZ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNmNDE2NzItNzEwYS00ZTg3LTg3ODEtOWRhOTBiYWM5ZmViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NzZmMzc4NC0wZjQ2\nLTRlNjktOTM2Ni0zZDgzM2I1M2QzNmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATAPwzTH311tapq66LmB9PsORA8C0ULd66FE05KXsgdxgTgGWUl5rLPEyu8E+q4\ng82860CR/NH/QYrDMrhfzoruo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXXQN0UYVjhqa2\nCFlLQwypADX8rzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAhvMNFx0ta7B9sSiGNHSbSB/6JpSMwUapO6Z1E4kQzgQIg\nOdLXK8fVbpKqhYb4dnMl9MsWA04A+nW17r4HCNJieyw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7717", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7717` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAWMI5TxYqN6WnzGL7cS59qSuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2MTc5OGUxLTlmNjgtNGI2NC1iZDgzLTg4YjMyODI4NGQwOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWNjNDYxMGItMTZh\nMy00OWI5LWJjMTAtZDUxMTU2ZDBlN2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQnu8vT8yKWuQLXbuITdF2fL/W9mi8FYbEPVKjk+PoHi8yxkTgblmGPcPzblB\nxAfaDdobfYFRu9jdiCEk6ClPV6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW0UvyD8l4b6wN2CuVpeYOnpAqXgwHwYDVR0j\nBBgwFoAUxcSbdTrKAn18WJCEb9TyAeLMalgwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGFl\nFHrtwd++YSetU0W1LZcHDeBb/AZFdvf4gRl9TjGEAiEArS0Q4fpJ/S+rw67owOPa\nxtQ+r7wVP5u2/OPAxybRic8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAar9fI1hH46npkUxbm6FzT0WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjE3OThlMS05ZjY4LTRiNjQtYmQ4My04OGIzMjgyODRkMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoVHzUqjNJbXAPuPa1NGr/INDY0/RWO+ENhYsQJrE4OXdj\n5i0PR8Eq52L3XvPz4veFkkQykp77z6LfYBW9fMDuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxcSbdTrKAn18WJCEb9TyAeLM\nalgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDOroJTRcvPyJbEhe4ggyvC1rEkrIaTBZpiCqhr2KmiwCICchqcTRu8ZC\nw7Q79cOgjFUIbwtOG+6qxBMuiNzuOyWb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXAP0mvT7VRe2IA3jih7ygVpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWNjNDYxMGItMTZhMy00OWI5LWJjMTAtZDUxMTU2ZDBlN2ZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZmFiN2NjNS0xMzM4\nLTRkZDgtYTQ0My0yYWM5MWIyYmVmOTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARqOrKR3tbSSg7GlW7hNyMu4xRBtcyAUvcBcAtjCKhtQ/HY0Bt1mIPtAWuhNZK/\nELWlCWdfzx4Fygm/kdsEjNi9o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRbRS/IPyXhvrA3\nYK5Wl5g6ekCpeDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA/h5xfyHjAeCH0myCGhGbkr0XoIWiYedautfumc16TREC\nIALsf7tERF7kG9cTA9ga3cLnt/kIwBbdTOOSsjXLxTrk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7718", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7718` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISARy42w7PTNcOsOC3QpVK7e9HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1OTcyYjllLTM2ZTQtNDlkOC1iNjRjLTZjOWU3NTExOTZiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM1YWQzZjktOTYz\nMS00ODdhLTgxY2YtMmI2OGQ5NmI4OTBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbZbsDGdpjvCnQ9GhGB6GMY/+PFk2bQ1wR5fuoWUpUau52mTGCzUfxi7KCAkb\ncHM229m44fTyoVZ/TIpshQ1CJKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjFManuvIECO459ZM9O1iTW15Kz4wHwYDVR0j\nBBgwFoAU5omfxOicx17x9XSxTaoLyen0SCowOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDhFRpW9PSopg11AYaHzPOHnEf+7E1h8Ca4u3sKAzkJIAIgOjud\nMeqruy3Aq1QMw8wEC7naia9TfKQhQpH7S6SeDjk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZhx2Sc+ivwaz7bAk3Ak4LUdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTk3MmI5ZS0zNmU0LTQ5ZDgtYjY0Yy02YzllNzUxMTk2YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZzDGYlgHb+zSorQioVFK6WLJK61QSDe69j5KMVhmb4Srn\nCUzHUOPxcc5n0xv2n3I/7huajD1kpBCVxDfshYpbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5omfxOicx17x9XSxTaoLyen0\nSCowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVfd5RxCUG2x+CRxpjzH07I2xZNSRKGIAaqLtGIoGEo8CIQDqYPIa4Gge\njHY2jnkpjbay2pNKpLtt20V8iWg5ugbqUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAceVrnC1NNjCTasHliTITFmaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM1YWQzZjktOTYzMS00ODdhLTgxY2YtMmI2OGQ5NmI4OTBkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYzllYmY2MS05ZjEx\nLTQ1MDYtODIzYS04NzkyZWNmNWJlOWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASXpAumPf1lKNbZdmUWDok46Y8dOKXL6P3SNJU5A7BqpdqUkilOYStPkoZ5/Hyg\nAQwqE5Ckk7Uf2ONVBKiIEeW5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMUxqe68gQI7jn\n1kz07WJNbXkrPjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiB3U3up9cUvoKUTn/UZW4piss3MEattb2lCOiM3rT3eOwIg\nSgs7L/H2WhXxQXOg/Myr8BuFi+8uQQTOCsn78553o0U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7719", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7719` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAWadBC4Mes7popKi8Gj+4oxsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiODQ4OGUyLTFiOTctNDk0Yy1hYmEzLWE5NGFhNmMzNGY1ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ4YmY3ZmEtNTBk\nYi00ZWZhLThlMTYtZDUwOGIwN2MwNmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+QrLjyJDzsAvxIl+RpOAfFUu/elyvWTm+d5FZNeuA5H8XEHezsePJGXkwKJ2\n5zrbQ15s8GgWQqZQtH78+C96EKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU81qIhi9AA1+g1FEBA41LlKCjy1gwHwYDVR0j\nBBgwFoAUX8lAiyNPhzIJxzhF3f2QPI0YmmYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCuOXYMadU4j09+whitXyspPZtIqVrDEy6Duc/vIMGzBQIgQ3Gy\nE0rciSNqjauvfHqDP8+oN2m/agbEjevVbzX7GX8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdo94/0BeIfeBTW+UvY+EzbeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjg0ODhlMi0xYjk3LTQ5NGMtYWJhMy1hOTRhYTZjMzRmNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5zsn9HOkpkIa2lS04AzHvabEzpswrt7ocv8Gvn5mu0X5F\nrj8Y8hZyvPQeXi4NemRZInI67z0Bpeu1jbDVPo0Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX8lAiyNPhzIJxzhF3f2QPI0Y\nmmYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIo8+fpbZn7ryCIYEqMt5TEHz6jwkBJ+letoddVS2HTaAiEAoM90WSZS\n4KSVzH1zATgbJHyVJ49bFElfq6KF5Fvs3Qk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAQULZw7ycejWucD4ycKq/cEIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ4YmY3ZmEtNTBkYi00ZWZhLThlMTYtZDUwOGIwN2MwNmRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNzk5YTdkZS1hOTYw\nLTQxNzUtODhiMS1kYjI3NDQ3YzIyMmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASF+dDU+qFVujV7L7TebH98Yw6v12sJXu1GK09TmWD0gAibAZ7LI5pxy3+UsWuX\noMt9ivIxIk8Szrqs7m9QpRDio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTzWoiGL0ADX6DU\nUQEDjUuUoKPLWDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAkhP/2f0N3yiFmcTTeVs4U37ilDIzeUOE8zscpwMPJUQIh\nAKkpeampiIMYqqbPbhc/FvqoTePDKaMm+3kyRcJD6Og+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7720", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7720` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAeD5yI8SNGuEWVLLItvllWWwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMTI2ZjcyLTVhYzctNGRjMC05NDBkLTJiN2QyNjZmMzM5YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM0M2FlZTgtZTA5\nYS00NjE0LWI0ZjAtMmZhODVhY2Q0Y2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6LuW+cXstNRSWohrPa7xhaHR0U1iGQMzm8flqxrHmQ3wBFUgi86D9Lcrz+Jz\nvdVkaEV72xKo2wy6O5TKgjrbVaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFF8lXrkv326eqtdqFVMFP1sQTyCeMB8GA1UdIwQY\nMBaAFO2TJ2vSFOecaGriHoDsOZ2y4Lo7MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiArzeNlxCQYgyIo1ovshdBntD5cgPR+MM4r\nyZVlR0AAwQIgMgx5mHwlsJO0mQn9JpwF65ZEum/IxvokUHQmZMQI89k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb2WwLMr5WKDT7eI+FP+h8RYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjEyNmY3Mi01YWM3LTRkYzAtOTQwZC0yYjdkMjY2ZjMzOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUlIIkpqRcDlSAvPFfvdeRiY1aDsgpe8/ZxBcC2VOs9IdM\n3zOw7Zz2F5BJSJRv+8OIVXFnOOqeIPemlsb/CwQQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ZMna9IU55xoauIegOw5nbLg\nujswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANNjOt1x/7XRgKxKXM1ND6tTL9DjwaAdhEyvc7vsiaP+AiBVVc9oBJ6+\nTdrM8RubS9ssBbFojsgc5HEK7Rx0NyeoiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfA17DqzAsO7FRRrInGjgIIvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM0M2FlZTgtZTA5YS00NjE0LWI0ZjAtMmZhODVhY2Q0Y2ZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZTExZmJlNS0wMjlm\nLTQwNWYtOGZiMC02ZjA2YzQyZTA1ODgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS1BqZe3RMBMt8xVI0C6L+c0+9+IqA6VB610o+jqsZaaFTGip4cWpoIkYLzPEBp\ncgZHQdXFw+aiCM0U7F0o7WbTo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRfJV65L99unqrX\nahVTBT9bEE8gnjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBAr/exenKbMo81IUyAPgO9Dz6gEI1C3+OdjPbCmSQXcwIh\nAM4+tocTdM0ogPe5BGfQhOPcWgWDS0ws6CTuOlGQbyCJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7721", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7721` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAQQR85IZHwyLW2c2Z8PNWkXsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2MzY3MTNiLTEwMjAtNDk3Yy1iZjlkLTZiYTRlZTlmMzRkMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNlNDUzODktYzcw\nMy00MGU0LWI1ZjgtODZmMDA3MmNiZDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHczrgJb/m9qvbPE7jZg8WU6N1Z7WxYBpQBzTRWpM8EzOGRBdDp6178tFluCy\ngn5+wpuvFqUreTwedB5QzyyfPaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXBk9hTp6ro4GAgLtcTvZUrqSnXAwHwYDVR0j\nBBgwFoAU0MBFdWfcvY/25ReqayP64fDHeEIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAI7wA4gdubWS\nUk0MPkNxocjOdHm+fXLZGPMu0g3dRWNDAiEAuf5ydg2OOrz1KYDCCbDaNWseB/QU\nT58QJKXuJyMpMd0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaDQRC+Ll+l7igmVvtlbzBnNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjM2NzEzYi0xMDIwLTQ5N2MtYmY5ZC02YmE0ZWU5ZjM0ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQq1/enod3nlu74nt2oO0xF71CPmPNMBqBHTgWMbGKTErKC\njpOjs+zu4rtxytRG1n8G//zvJnhwpjsJYgANQf78o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0MBFdWfcvY/25ReqayP64fDH\neEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgURvjVil2gYC9XSKMInIT45s4/0kN86VGPHl3Nz2U2gcCIQCHFjvKOFHK\nhoy+dtrwtlVrhCJum3JXknHVlBFJjCEHig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZ+Ma7WYfDIy/XaWL58AfpaHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNlNDUzODktYzcwMy00MGU0LWI1ZjgtODZmMDA3MmNiZDZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNzYwOTkxZi03YmQw\nLTRmMzYtYWZlOC0zZTUyM2M3ZGQxMmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASktew1LXFL8JHMcwwYsAXORedJkE03zk0n9sSWL86XREQmVKrGHYObpnCMi9+Q\nSt90SzXsFpPHwbW32Xm2rx1Ko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRcGT2FOnqujgYC\nAu1xO9lSupKdcDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAowrrg8uZx6xNLHKhA7zm7XvALWlYLKrsRaXEBF5mZXQIh\nAK+RtuvKLtGreMQZXNl0gbKsu7KtYz6hm4R7+koAxXIc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7722", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7722` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQPMGxReYfWiNkqDLM9m4115MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5ZTFkZjQ3LWNiNzMtNDNmMy05YzBhLTdjYWViMzgwMDYwYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTkyYmFkZjYtY2Yz\nNS00NGJlLTk0ZjctNTRhZDc4NDViMjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIfiEbpB851lj4to2iWD9xm4T9XoRZotTz7RZRR1mx5LHbJNtGOhjmSKJ3Xco\nzfet9FVc5CX6AMoG00+aFRFWrKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEdASlLS7dkS/T7pZVi5qRSDgRr0wHwYDVR0j\nBBgwFoAUuvgaqn4ZaIu2lfkFZMBugFVYNGYwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALmADKK0AjZP\nVNual2eU3KoNfzrnaGDm43OZi5zHU20mAiByfIz+0M0/WNko/O5a1rmh+ZNIpJxJ\nXLJ/JBLv4rxUEA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWyA6mSyWc3F8PtmBcjakHD/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWUxZGY0Ny1jYjczLTQzZjMtOWMwYS03Y2FlYjM4MDA2MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiDK/exOgCwiILWUcBQu0r9OJbG1jEqlSB7p0NqTQPg3ps\nFyhqqeDg2yehCLnhfnWP3x+X/4ymTyp/eDCtgy94o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuvgaqn4ZaIu2lfkFZMBugFVY\nNGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCP7Bwf91NdTUdBx2b+0TpStxoEsWpMaB7flZ5ixVo80CIQC3tefJkTcD\nWJtx0SATyfKhyzjJR4U18j4xTVfMEUlRLQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASeWwv8GQRM/N3llxHuIMOU0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTkyYmFkZjYtY2YzNS00NGJlLTk0ZjctNTRhZDc4NDViMjcwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhM2NmOGU5OC00YTdm\nLTQ2ZTMtOGE0MS1kZGZiYzhkYzc5YzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATFth5rxtrMrt24ELGpqrUNJWNkDGxW9WRf4hxUucRnzf4X53NuVXsyzG9Kd3mf\nsoToa1rAHuOgpPgJn+0Ejh9fo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQR0BKUtLt2RL9P\nullWLmpFIOBGvTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBsUhhHtAh715z8VBag3LYI7j5NubpL+j4QlH3IFrxbXQIg\nXuzDjC1jZa1v3SbAcBA6s0LXgqEpBOAm8If8BwpirVQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7723", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7723` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAQGFWH1EKqn3y97BxiIDu809MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxM2RmZTg2LTcxY2MtNDVmNy1iZTgyLWNiNDg2MWQ1MzUzNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2UxZjM3NDktYzhi\nOC00OWM1LTk0NzAtY2ZiNmY3OTRmM2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkVu7r6c+l43HI89GyrWfmfglQ5yzpBFAFePV1nO0jWb6Go5lK4RMlUlVtg1F\nBrG6YeT48RP9YUq6tPNyYMuHjKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb6/OWq7T3yJqqneY9CuLagV/8ocwHwYDVR0j\nBBgwFoAUdIuRqc2s21ECYL67NNktgIw1/EswKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCN6R3h2Ege\n2gacuvT+DDiDtdv8Jo/ZFiOuXFt/e3NBaQIhAKR145S4RDFbiOfm9aO1c3/4rfa4\naMV3pS+Hizba7DpQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARO+ODQ5SCxhuOfJcocFAbAfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTNkZmU4Ni03MWNjLTQ1ZjctYmU4Mi1jYjQ4NjFkNTM1MzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7OfSrzp1nKp/MMYvWwcktVa7QtEUtGZGLiKBE9fvnQX1C\nAF2WU0UMQ8J1Cf9YCksJRJjUaZW5EiemlqqbsiHao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdIuRqc2s21ECYL67NNktgIw1\n/EswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM5Ye+vt+g187QaKWyaR7qYOMJGstjcBlWpgI7wb8PcNAiEAvbgy8Jbj\npm1d9XSE0VQPR6XqiI08PL98bOy9M7N9Z/U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISATJ11fFOlhlGPL6hNB3xKyizMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2UxZjM3NDktYzhiOC00OWM1LTk0NzAtY2ZiNmY3OTRmM2EwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYjBmNzdiNy1hYjVh\nLTQ5NTgtOGI2YS1mYTE0OWJiZjdiNTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS/n6mYHVFjrmazU29iSWdq3B6fpOrpOhqeIfqQRgkKmCDNs2a60w8lOtn1KyoK\nC4um13RhYnPngkorgib6XvwKo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRvr85artPfImqq\nd5j0K4tqBX/yhzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAp0sovzJB+ZqNSsrY0nNLumRudqPcL/NA9QkL7wwtj18C\nIQCTfxUkgJcrEyL6Ni8P0ZSmGticAUNYA/xvpX/J6KADWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7724", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7724` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAWr6ORdp2SJx2wAv27NccDWVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4YWIyODJhLWEyMmUtNGJkMi04NTE3LWZlZDRkNWVhOWMwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU0YjhlZTAtMzYw\nYi00ZmY0LWFlNmQtNzdmNDA1NDdkZDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiLy/NNUyogUo3PwiD3xdOusc7WcbPIb/v8zc7sYAiG+Sr3PF3MszXQgA1MrV\n0xDP5RkSprlboZVA0GOhQ5VDPKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkhDC1OZCVG7xRHzEMoo+rAEI3YowHwYDVR0j\nBBgwFoAU6vsNnW8RzjAe2595aS/LGR5MUyEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDvHiAlmm9HdH59DKsobJK/ZP5TobMP+Gp+rSbXKQb27AIhANZlDMZ0d0BL\nwIw4ouJ6t71k3SLS5qRT17fG1lKdQBGT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYsxxYO51ang8FunHTqo8o9YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGFiMjgyYS1hMjJlLTRiZDItODUxNy1mZWQ0ZDVlYTljMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0hJYuuhhsJblQW1thZQUX+25zatpuvox4CrhnF2reDSLP\nGrVMliJ/av9Hmj3B5V+LInBGSj00st3nv0eKFfUqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6vsNnW8RzjAe2595aS/LGR5M\nUyEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKo9PTX4JctIpkyJTkR9JZvfACVIKikRtmJgjgjO2lssCIH/yiKOzDtEg\nmpVCyZyRwfTnC3HAUOuVTxUGXw+aGpG/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZ4f640PfdkXMvdDIPflw1WDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU0YjhlZTAtMzYwYi00ZmY0LWFlNmQtNzdmNDA1NDdkZDNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZDA2YTcyYy1lYWY0\nLTQ3MmUtOTgyNC00MGVkMjMxMzQ0NTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARJ/TXXUISx6wlkbZVrmgkvkByYphiRQMgiabM7wQxk6YHj4FycMPkoMGCuWYD3\nl9QG1qE2zAoUDeJ3uXEvPErQo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSSEMLU5kJUbvFE\nfMQyij6sAQjdijAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBLWC6i6mBjDAPL5FtnYbEv7gIT+AFdAGlszEYK5IaInQIg\nMSbv4mZwwGrAQmBiVErxgSGb4G98RszE8jOLbBWW9rc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7725", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7725` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAfdtSFGDknWF+CdH82qIkm9qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNDdjMjgxLWNmZTYtNGUwOS05NDIxLThlYzUwMmJjNDA0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU1ZDIwNmItYjdh\nMi00NmU5LWJmYTAtZDY2NzRiODAxNTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQCAZsUZiK5vtS/GBw68fyaxkYVIVmP7K9yHxaqgAOc6yKvG48S9Yz2gUFayZ\n82eJI5h7iDqriFWOdraE58v2SqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/p3lELlVp7Ta+6QjuEv27fiFEqAwHwYDVR0j\nBBgwFoAUmxa+tguVfcQYzM0vqjBLvwuIT8wwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGiGSQTsKl2HZ5x7ofbJHJbwxttMI6Us2eq3wptDh75MAiBUeMYOYsRmWGXr\nqLgJGqWp0E/hmjvpxiWDx6cuJZXciQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASHkbAJ6fHzorhkh3x+n1VmfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDQ3YzI4MS1jZmU2LTRlMDktOTQyMS04ZWM1MDJiYzQwNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR57xP/zTdpdwsixvQwl/VmRqE0Lx+kGPdf/GqeeEsAzzjo\njqYFmTVEpYigOg5rBxxQPb+E9Kt01spXpYgY2Kt/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmxa+tguVfcQYzM0vqjBLvwuI\nT8wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDf1F3CZtfBBw0Fhd74pbCStdAzsCNh0D1+eCbffQl18CIQDk4ZaEJCJg\nZ4ZCN/Pfkw9c8GLHUTLriOVo0jSfqB7RkQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAR9f8dHYwJceYUs7madNt0raMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU1ZDIwNmItYjdhMi00NmU5LWJmYTAtZDY2NzRiODAxNTNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YzllOGNlMC1hN2I2\nLTRhOTgtODBhOS0wNjQ0MWRhZDdiOGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATxf+d38nComj9q/p+PFJxD+wfwFJBJwU9vItEOlEvDJUjJnDJ9nIKWlvxisdk7\nh5B3WCXQbi/KeeJc7gjCQ3UGo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+neUQuVWntNr7\npCO4S/bt+IUSoDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAzHMutYd5TvrjCheIpEp92bwnIjRWrm20Nsm9s5Ul1tAIh\nAKO25n0vKXW+5zMZfjOBv7FkBR0Zrbs0opsQF2RvsFPT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7726", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7726` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAQLOgxAFukcX0UXNN71bmGIBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViMWVjNzhlLTkwNTQtNDk5Ny1hMmIxLTUyZjAyYTFmMjY2NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc3Zjc5M2ItMWNi\nNy00NzIxLTk5MzQtNTU2NWFkYTM0NDA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExW/uEIY/2hp9JuJkws5ibgTTr9zcnzo6Hq61GDiVNn6LIHfu4uwUU/v6eJ78\n8BESQnTnDm8GMOhImEsZbD5yr6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3dWzIpFjs5gKLkcaXa6fh+zMws8wHwYDVR0j\nBBgwFoAUTdG4FaHlFErzlXKMeeZM2+v7JWQwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDZl\njbFrHGSVliXDcHPXLyvrewa5S44zOf4b/eIZe1rZAiA6KRjQBEKQo5xFPK84Umaq\nZOk1iqU8hO+SpPBU/K4amQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYNNrX8obgyITh6T7WV+3hptMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjFlYzc4ZS05MDU0LTQ5OTctYTJiMS01MmYwMmExZjI2NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwALT29ZCLs9TKm390zleCOa4r71oLa5nZCMorBiGJ6AqL\noquBpIc7vy0tut+5KYooYmonThMV90mq9vsBriKlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTdG4FaHlFErzlXKMeeZM2+v7\nJWQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM9d29qi3DM12aT8gTgaBnrrCexGNGZ9EJi6Zyq3PqkACIHsmWEEwru3g\nSPmrbw+Ja3RwGJtrI9HmaG+wS1N5IUYq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWkJRWAF8ZD7MZXNS7mSbDB1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc3Zjc5M2ItMWNiNy00NzIxLTk5MzQtNTU2NWFkYTM0NDA2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNDhlOTM1ZS1lOWNl\nLTQ1MjAtOTJmZS0yYzFjMGNmZDUwMjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATAeu2pab4PXTjujWIdrTvHu7BhWZ0p/KBaAN4k+xPFgdYOffGWOTiZ7PFUsHcj\naMNdMm01oqIdZcZVbtxJmT27o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTd1bMikWOzmAou\nRxpdrp+H7MzCzzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBa5nC1sMLpwSfXONME3vVqXB/522gipduFnxC3CHn4sQIh\nAMIYMU5EApHLu7dWDIumPNfieVtloILRrSF5wjH8qxEN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7727", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7727` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAd1r6yw3BKWzkos/tU6LIVUFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhMTlkODI1LWZhMjgtNDE0Ny05NTg3LWI0N2E0NmU4NGQ4NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQwOTY3ZjgtNGQ0\nMy00MGYwLTg4ZTUtMTc3YWIwMmQ2Y2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ2wYFWYqtut+ADuEtIKhbEaeKIXB8aikueH1V8yeva/hAga7w10rh3Mwi2qC\naePE8b9QQIhuIKZKuiAaoku67qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0RAPQafeCwhJQyYyTWYauTbdLeAwHwYDVR0j\nBBgwFoAU2iX5BN/pnxX2HKbD0trGjW6tBawwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDWVYTmV0kADc0AJgoAhn03flaYkT7XAGRhfhuFDX2ARgIgeuVL\nQoXbHGXAvrKm9B3dc0GGk+TZ8tCfNnZOe/cqUeU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASS5JLIY92fnOmShanvEiHMfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTE5ZDgyNS1mYTI4LTQxNDctOTU4Ny1iNDdhNDZlODRkODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATubX+81IYznpUsf2pG9u6VEfU4jLo4yxd5+wunQe+Z1nWb\nqo0c9cruGW+nqXzHU6+XeoOENw5MZecv1biQA9jlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2iX5BN/pnxX2HKbD0trGjW6t\nBawwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZyEPUPPgQn22wVbx4ugNO7BlryMp0vEcJUl8h1fxMuYCIQCsVPqKmeX7\niyltQhQoyQammyrqRgHFUFPt+hdPc+n0ug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAVa2wjeGH6le7HhI31B3wSp1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQwOTY3ZjgtNGQ0My00MGYwLTg4ZTUtMTc3YWIwMmQ2Y2U5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZWJmY2NlMi03NGJi\nLTQ0MzUtYjliOS0yYmFlNDQ3OGRjOGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARxdfyZL3//4kyZc72eZ8mtzCOQpN3FCpKp8PUE3+saxWtSgZJNaOWDmdLYMwaj\nGrv177fIzp6L6navZn9zsziEo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTREA9Bp94LCElD\nJjJNZhq5Nt0t4DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA73tCiRLx2P2phAJWX/+4fexhKLORSLGQdER8HymX36gC\nIQC+Z2sfibY0WNDfHpkofR3nZ7DDKG0knP96ZyNCcirH/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7728", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7728` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAfmKWzn58GYxQAEoAQSpzHQCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhMTYwYTQ2LTM5NTctNDlkNS1hODFkLTAxNjQ5NjM2ZjVjNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJjNGY3MDUtYjdk\nNy00ODBkLWI0NjQtYjFhNGFmYWRkN2ZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgU0PLSpY6KcNVI2kZGX5k0ZHY4xONdjxO/i5tb9+/eykDrGcuBAd+m47j8Gl\nLr4O9istchfocr3/3mWcnYh+MaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNQKQEroXV2p4DOGvHj1YLtQZov0wHwYDVR0j\nBBgwFoAUXBQCyP4qa31YwKiaG7kEWf/kXl8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICX/hScAoBCPUHgRvGm14L2oBVMQgeiadlexJAd9+2Q8AiArsfwM\nGgXV2il/uskjarPk5vgBX0VrfrUSwAE33MtVpw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT40OG2yUfms+XRwSL9jX0UeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTE2MGE0Ni0zOTU3LTQ5ZDUtYTgxZC0wMTY0OTYzNmY1YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2toLNegrGCAY7HjgyUAut6U6SyNaJR41XxL1rRrRNN2BS\nMK8TFHg+IAufy6KEEo7uCTQqF5BF97l6Ke96uLu8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXBQCyP4qa31YwKiaG7kEWf/k\nXl8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKA88k3mQrS9y1Gl1QsYGdjy3Z/N7wjq5WAoKQA/cU4pAiEApkm3fM0I\n/TSKMdrUWhDD0feRxmy2AKMtCv8lHFzVZlA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAbb3VEXaAsBFiQiSH/g/GnDsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJjNGY3MDUtYjdkNy00ODBkLWI0NjQtYjFhNGFmYWRkN2ZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNzE5MmViYS1lNDM0\nLTRiYWEtOGY2Ni04OTBhN2FkMTUxZTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARVfyn7c9sCqu2Rlnre49vEJCfnn7OU3a374Bf/2Ue72/jqPRY1BlstrmXCZdu7\nHfjWbNUKF3QxSF3P9BoRTN3jo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ1ApASuhdXangM\n4a8ePVgu1Bmi/TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBIvJRarguyu/i8rv6m9Azh3awj27BQAXFZEuFtZRleOAIg\nAg9hHRwrc+Ucp4H9WmdMYcgzbAN/L8j8hoJr6o6XX+Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7729", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7729` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAb3r+xIu9NP9/SzdlsWWComXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ODQ1ZWNjLTQxY2UtNDBlNi1hZjM2LTkxNjgyNjY4NWFiYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM5MDU4ODctN2Vh\nOC00ODVhLWFhMGYtOWE0YmUyNzg3YzNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz4k5K4BfHFlozjMkCpz3b5jCr4YW9tgVkxL42hA1J6M9harGaYCxyVs3DOPK\n9EdwudjyZZ33Sxyf0jxCgoD/K6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSW1TRFtRPjTuskWdHEqdYKMHuE1jAfBgNVHSME\nGDAWgBRbNoskHFh2jaIZ+4R+nCsVLsg1qTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDfB2njmsea34NKymHyQuYzOiCBuXge\nCCf7t8QYG+Yt/gIga8Bpul6Id5ELg4tQbwblBnnxL+kPwoj4K09rAFge6Rk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATpT0Qi+lS5H3QAz2dDDba0JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDg0NWVjYy00MWNlLTQwZTYtYWYzNi05MTY4MjY2ODVhYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOdEpml5AfPB2Q0ctArxF65m/RxfJg/pOjlPJqB/0HF+9n\nXVAeAEJzyQHRnq7ivhSx2cZQFDyRuJxouaVwXZvPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWzaLJBxYdo2iGfuEfpwrFS7I\nNakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH5v5hZkE/gL88w9nTPfk6Vb3FIXcKwar2gWojeev0WcCIQDneh2lN9Kz\nkYpgUUrjIGbYeqPaGGeObLbnzWaM90X5Aw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISASomSGI2Iq1Hemsjv3qm7yQhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM5MDU4ODctN2VhOC00ODVhLWFhMGYtOWE0YmUyNzg3YzNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZmIwNWFjMy02ZThj\nLTQzMDctOTQ1Yy0yOWFhNDlhMjkwYmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATCcVOFaIJ0I8sMUm331R+aTBn9JdgPwdNVQkJ4PiAREflU0wLnqHcPColVZVkB\n7rs9QtJYkpj8y9XRtxmHucKdo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSW1TRFtRPjTusk\nWdHEqdYKMHuE1jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAqlseGjcISMKQRtVR0ruOf8hBR4IQeqOe6GDF6hu32hwIh\nAMWP83na4MOnt+0VTDQi8KVFRlFnwH1J+qhwb0BSYh/i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7730", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7730` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAaCH9ruGJJy9Cs0GT/XtA5+NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxYjc0MDYxLTRhMjgtNGVmYS05YjFhLWNkYWFlMTFmNGRmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2IzMTA0MjMtYjJj\nYy00ZjAzLWI0NzQtM2QyYmQxMjZmMWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoHRSN/0gMvgrcjFG6iyONnFqEv85Gb6sn+01UBhgnIRf5A46zyUV2Uf0mYFW\n78AbPafC+n58eDaGVhzoW4p+RaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUItk9eX3UMLPAR9PbrIZnrQVzDzMwHwYDVR0j\nBBgwFoAU7l/LlOTdv9z2eVZfUN44WXpHilcwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQClQiXMvQPf\nWXs06MVR1KsudkTqeZF9YviJP5XOd2ki6wIhANfcfD+k6VvZQ1YiI2O8I2Fev0yo\nOVQMMGSy3UHr+x4O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQPqg+uxceSPqtH+FrfNzP9XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWI3NDA2MS00YTI4LTRlZmEtOWIxYS1jZGFhZTExZjRkZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBiM5wJIaLLwBlbfSY81x9Ra/iOzZMUCvGUGO0iXaRZpF9\ncGn37c7OFKtOclYSjsSF3+4S+dbckLfqJcNOon6Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7l/LlOTdv9z2eVZfUN44WXpH\nilcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPDQQwfmia9CiFtiHnFxI18CVpzbRl4QsUCUg/0szdBNAiAqErZhgmmQ\nhZ1lIVEsmw+T0Ld/BjyAcZHGtXqEYfcR7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZqA34zO5UFBcweWMXkUf4WCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2IzMTA0MjMtYjJjYy00ZjAzLWI0NzQtM2QyYmQxMjZmMWI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmODc4ZTBhNy01MmE1\nLTRlNDgtYWJiNC0xOTg3OGI4MTY3M2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASIgqS+VIe+go2OpzRm0u8/B2YLrlwVUo/emvm/bOfubL8ys9MCe03OjQaSeGZF\nBn81S+9hpZHFHg5jRSmYlcuoo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQi2T15fdQws8BH\n09ushmetBXMPMzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAsOxc32Uvutg5XYEOmkEZKTVKADkbDejP39SyAoLyzXAC\nICKojDZS4ugs/at4yQJCD5XMVg8dxX2W5cY5V1p7VBdp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7731", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7731` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAU1BJTcTyhbp6Chgin0KHe52MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2ZTIxMmQ5LTU1NmEtNDYyZC04ZmMyLWViYjk5NzRkNzg3MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFiNjA5ZjAtY2Jm\nOS00YjJlLTk2ZDUtMjljM2M2MjYzMjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE98A0ahrq1VdHGHvxdxQNprA5LWJXbyGjUY98qYZX/LuLUI/bg4VqsTeOGIRO\njI/3f0j4/9yCmaD6BBHzHqFLuqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCzn3iYVKpF46E/WCI/nLfiZbL4owHwYDVR0j\nBBgwFoAU98vzlU4VIO44AVgcWUVZrgAKy9kwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCoDlmhe9Jm\n5pRj0LRIc/SSm0bCRSgwjIPtkv1gBNHRrgIgCrbBPx/aWmAYqv7iGlOG6azqmn6D\nZEVQqXQzkaw0xXk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWnDfEWTJm8isxrwgalynPJhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNmUyMTJkOS01NTZhLTQ2MmQtOGZjMi1lYmI5OTc0ZDc4NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfdI4lpk3JpwriPCl61H4cDGJVwcJBUWVY3kGGeC+GtlaZ\nkL8hFaAtkvqSiOFqvuMf0G3xNk+wJwvLO0M49ZnZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU98vzlU4VIO44AVgcWUVZrgAK\ny9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgebXyCSArOuK7m7zN6oJzCgaD59AMOeFYznT5MOI/K6YCIFHRF8S3kGt2\nJ5+CreU05080kpA0CjTnbI3UTbJiHIZI\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAVmbKriieodZavkvdWCQ852HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFiNjA5ZjAtY2JmOS00YjJlLTk2ZDUtMjljM2M2MjYzMjQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmODAzZGQ4Ni0zYjQ0\nLTQyNTEtOWUyMS1jMjM0MWQ2ODIzYjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATHtHtaJtg/QqVzIDASrSQLxxyV3IqafAQXl0RzkNN2+Hrq2AMCC6NpJyKHj34w\n2V73xpmYnjmfu8uusTfeEhXto3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQLOfeJhUqkXjoT\n9YIj+ct+JlsvijAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAoJPalrEq0q9rGY+FKJLcpe9+vU+sVmtWbhCNGvbKn9IC\nIQDsozhfHnGKQJf9Z/LgPf9Q659vHS8FKwYg2mOGP2fTsw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7732", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7732` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAbT3RfIcaeMzo6Zytr1wUhjWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1OWZiZDJhLTUyNTMtNDczNC1hM2NkLTc1N2E2MTcwN2I0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjkyNDFiOWYtZmVh\nNC00OGRkLTg2M2MtMGMxZjRkMTk2NTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4Kq6dbk4xZPEa/0tLi4FM/liUsqUFJMYRymKFBx3/MGLBbEq2h3l87vDvxDA\nh1q+tDsOJOC1pTyjTv1b1UK0d6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsRgGxkovNp/ywRHe+bLke7VOh58wHwYDVR0j\nBBgwFoAU4QTc/VL2ZHgb/8S4onIdTRL163kwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAkqw+JgYeI\nnCnS8Mx1fmO0MJKAv3Efn5WQariXfcfnEwIhAK/coHkQ+FCIhw4QjECtEXdHv37T\nDgW/Ahl9cc7YgBwB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcQ4bJd319yi/wfdO/ubS0GDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTlmYmQyYS01MjUzLTQ3MzQtYTNjZC03NTdhNjE3MDdiNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5WwnBtZ1rqlzUIExN9JsvL3r81Ma0j1+nJDiXlpchVhU/\n1fy1CB5fd5Qbhk741E/9xDHmfjgY+y5EHbf+WISho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4QTc/VL2ZHgb/8S4onIdTRL1\n63kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJF9JV6svdrDQFj6HyuoE0ryptTzD+omZgzCTb1A07NIAiAdpqGLxU/v\nfEIDI5J22eSqNNg66t8ML4IGxSjMmu3l9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISASEGpY+okRx12nVzINvv5QQLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjkyNDFiOWYtZmVhNC00OGRkLTg2M2MtMGMxZjRkMTk2NTIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YTE5OGMyMC1kNWI0\nLTRmNGQtODU1MS0zNmRkZDcyY2MzOTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARgkZNUAwzvQ+R2IHMUBxysdwOfwnlKx8mywKxJDecMBz5L5SyhLlI7iwzFb1yx\n6IPg6OP8KOC42WHWWVPVCx8wo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSxGAbGSi82n/LB\nEd75suR7tU6HnzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA1zitsS7K/xdg9seHFEY366Wdv3k+TiiZErqJjuPL4lIC\nIQDQOSY445wuuYd47D+QzEY1w3rplnk9jYsUn6eMOqeyoA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7733", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7733` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAd+d4PZRakIRJjueJJCGi1sjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5YTBkM2YwLTYxOTMtNDI4OS1iOTYwLTE5ZGQyNmIwNmVjZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE4YTMzZjQtNDFj\nZC00YjZjLWEzODctYmFkNTIwZGY0ZGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnhI6tId2DROelfz6hdLrZT+26VuELj8TVeUPAY966QeU7cwlGtVMMgNivUvI\nzwTE35PyO8lIV4U1Xd23WbJzJqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVOr9Pk5axUlEZzNhTu0wBmMcbFkwHwYDVR0j\nBBgwFoAUuhGxzoSX3al7smrtVBWI2RUjlHowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA3E9Pl7utPuui+uRSDU6AyN9NNXgvqcnR6eEe5Sdk4RQCIAYWCq8/QDMz\nM6dESRLa87YM2+1a/e0wJc9A+cWytBq+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfquTtHyONFagyReEGdBWmcZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWEwZDNmMC02MTkzLTQyODktYjk2MC0xOWRkMjZiMDZlY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSBeJBXQGPBdwL/CGATbqGwpa/7Dmv5+pDhomG4TkUk/dI\nQ8i8UkB6J+TkQ36MsthaWDIomCH6MK93nkB/rgIJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuhGxzoSX3al7smrtVBWI2RUj\nlHowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALYiZ+XvvmHzc80nBJ3gYIop2F3lgQknzoo3CeqcZh6GAiEA/1uqtXog\nLs2ey0YpRwQo2n9GhQLHXSX4bw+L7js1e78=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAXutzZFsrtR7jqVcBrFFY2PDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE4YTMzZjQtNDFjZC00YjZjLWEzODctYmFkNTIwZGY0ZGVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5N2ZhMTBkMS01MWI0\nLTQwYTctYjM1MC1jYzI1NzY5ZDM2MjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQqowbPZvIHe7vMQFdI+w5o+oizdzDgFpRUXQS6L8dCt4off+lticYisXssmwf2\nTsDEgp1iww6/eCdk3CY0CEYOo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRU6v0+TlrFSURn\nM2FO7TAGYxxsWTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiB5TLACai/7jmGB0Vod0HWwSgZ4OynPg0E+c0WX7TqHvwIg\naj0AntdQehdECfDyD4Wc/G7zjfzTlwMxVemRrTvNKyY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7734", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7734` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAdJz3sJr0xTOIcvvpocML3J9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjYjIxNmIxLWEwNWEtNGQwMy04OGFjLWNjZjRmOWViYTljOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYwY2M3NGMtNTdi\nOS00MmRkLThiZDgtN2QyYzBlMmExZDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7qn632qYXTp+Yg/x9fnE+gj8t/xO9zsvB7LBoRVGks1IoEFYciFQWzD0zWKk\nJESltDAuZKPjHK3u/PjGRzW0taOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjZzriW318elIx5nxiW0hbSwVSEYwHwYDVR0j\nBBgwFoAUjtOTP4yd85c/lNe1RMXz3jFhIyMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAu4+CgjOW6P3qi+hFcdnOhLfPbcEG38IK5pgX1ndInUECIAJxpTDmmOIv\n7XutARTOQiqlsGjFnw2Zd7i+jgnaHn2S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaoyM/zZ5xa1XApLskOBkxcVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2IyMTZiMS1hMDVhLTRkMDMtODhhYy1jY2Y0ZjllYmE5YzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDZ+CPS9VtWL7vmG97L0acBChEnCRG96AlUgdKa4+rY6oB\nbTxqL0HXuLpPYuAXJtHraFiDIA7pVYX6PcICbexmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjtOTP4yd85c/lNe1RMXz3jFh\nIyMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI8DdAyJhSbh0ZsGke8C0i6lGekvf1Ai4sryn+5w54dbAiBUkvHQQOjd\nrV0wk99UHYJRmzARXlgCqXvwt8CcVd1Tsg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAcwdpQX7SCPYWxHyVA8YR2KeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYwY2M3NGMtNTdiOS00MmRkLThiZDgtN2QyYzBlMmExZDMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OGJjNTJkNC0yMTcx\nLTRjYWQtOTdmYS1jYjc1NmZhODVkODYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS6Bh+fgzKexdvDEpj1aNvtz/cYtwJzNrPbMGigtoo8a2O5BxTe2L5AAVmvDEmp\ngYthHEsQXbS7prOo4PpbzurIo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSNnOuJbfXx6UjH\nmfGJbSFtLBVIRjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA8gfdNBBz2Ncs5vCMH3Y1/3LLOCFeg/BOhVd1SEhQmmYC\nIQDPXXydQPWNOolF5AlI/+ayy5o6imM7Bl/1oiXlbhTVBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7735", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7735` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAZDYkArQ83uBlnBCsD+WISFKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0ZTYwNjE3LTY1ZWUtNDIzYi04N2MyLWNjYzM5NjZmMmU2MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI0MDc2YTEtYWY1\nMC00ZDM0LTk4ZjAtZDhiZWQ2NWM4MzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE27Nvm6tK36m/rWJOBimEK3WlUqGoMn2QteFX6sji1fDukEhAzkUvK2OaR+Gg\n9YMVUrB63bhIzEjLLKGgbah45aOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Ha5MakyDcOo7dY1g7YQDD68KCIwHwYDVR0j\nBBgwFoAU89gtvrCFj71y083BhvgqMaDgKJMwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n9P/CZnZViCwwJIXHzvRyXXyj5b835h1Ge+MPRIeIPnACIA+4vErd89Radw+hZML5\nBWdzA2unHDACF3Z6YS2KAbfO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZsTqvrasYBR63g/tWh6s211MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGU2MDYxNy02NWVlLTQyM2ItODdjMi1jY2MzOTY2ZjJlNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhdJP1Z/l3jfBgNiuEQ2GkiqTwrtHygwupCi/mHDT60N+d\nx0fHF0xbHEzAeI9mj7E6/46ZMbPTM+EnU0BbuaTZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU89gtvrCFj71y083BhvgqMaDg\nKJMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMoLLShz58gpfxWx81s5wIhl7GcEl0DQclcGIsUhXwqjAiEAgQFfCFWO\naWQ5+2Cl1wt6gxOccxrGsP+Iv1SWbw8QjIk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAS0U3eKsFxPm0ZNwSZXow4AeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI0MDc2YTEtYWY1MC00ZDM0LTk4ZjAtZDhiZWQ2NWM4MzE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMTY5YzUzZi01OTdh\nLTRjMGYtODY2NC1lYjI1MWQyMTMyYzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATSyqVHEJCB4m7MK9fKC5V6IaXP6gnELOFNktxjsoCRsCyeKiLdLwDgmi8QHfJT\nWry/3w8U6L69SX26c9jvQnUyo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTsdrkxqTINw6jt\n1jWDthAMPrwoIjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAqJepDlZ3czggKXY3JcLtQtLUA7/PPwwcAsDRGL6KYqUC\nIQCWv527dBsiMuF3XK32SSMrkv/liwq4n+VGNaEl7XzNAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7736", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7736` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAbDzLscBGwnDv3/zAYUVQzV8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhNjJkMWQxLWU0YzYtNDMxNi05NzA5LTkxNzcwY2VlZTc2ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODEwZTQyNjItMDU0\nYi00Y2E1LTgyM2QtMjBiNDM4MTZiODkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL0yH73IFrNeYxTnRi6MAzzovc8pVeoOjYzN379tU2MEi67mEqMEtBcRjVxyT\n6fwkuosBR/n/oHzEgYm8TiNvkqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBwFiAvTaoPuzh736PFUZP6gwch8wHwYDVR0j\nBBgwFoAUQPcbemq0v5qWvByxyNUlJ2YK5Z0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA5lrH4D4TcKBIvZbK9CyHCYQalWRK1BsIcgZR+GMDW4kCIH2l\nyJyBFcdU51WAZOORH0G+JZUZI22R9+uSInF0i5qY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeDcb/ily0JO7pMD8izP5riVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTYyZDFkMS1lNGM2LTQzMTYtOTcwOS05MTc3MGNlZWU3NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsswBTbCU32nke3qMxXUcQvIQIcooccBCU7IoalX76NgwY\nSMHVchfNKUjuBF3HgM/Ws9sK2CSkkpvyV9gP+z7Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQPcbemq0v5qWvByxyNUlJ2YK\n5Z0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHT2/qKtTB3R3BImPv9G9bdb4ysQcQeogRWevsIO05csCIDV3TX3r7qd/\nikzrYevHH6B5UKrsOzRcOA7bu80pCtLr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARWq9S9i8OjupGdm6aG0Gw9dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODEwZTQyNjItMDU0Yi00Y2E1LTgyM2QtMjBiNDM4MTZiODkwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZjE1YmYxMS04MjI0\nLTRmYjQtOTc0MS04N2U5NmIwMTc4ZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASRaeZtAHzxYd+i4FLCp4Zp+l8zzXdL3pAeYb/6OdXr4UduK9GnJOa+WpgBwT9p\nHyWgTCYloW+IDLx6pzjB3MjNo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQHAWIC9Nqg+7OH\nvfo8VRk/qDByHzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBx14m3YMXdSPokc6pmpK6jcOlPZFHztcAZQP8QraSBrwIg\nJTioVySFmid+iZAljD8S96mh7eQpj7Qz82a/ex5czjw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7737", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7737` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAfzrJ91fIC3waR/R6tXy40d0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkYjkxMmY1LWM3OTMtNDg2ZS04MDA5LWVlOTA0OGI1N2I2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI3OGM2MTYtNDFj\nZS00ZDNhLTlmZDgtNGVlOGM3MmJiZDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj/LOj7CT9+zUho63kyliJF9D3niP4kuiVJq91yapHsWiFFoaQe6nSQB7WPIF\nqC2KznggCc+4qy9ANrdKV9DCyaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPFGci2DLXeALTmyFfoug9z0gHN4wHwYDVR0j\nBBgwFoAUKOYwAhS7R4W1OexcAHwBbVoRGzgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNHADBEAiBhQDiVNR5eG2i2aLS5SxLP3bKK5AJWsGXRqPJX2rqoSwIgFXhs\nqplWdgT7Dd0RYDzG5fQ9tEgLMAePf5bUA9KLSpo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe4AbjC8vw+zvGlXD8zQ6PIpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGI5MTJmNS1jNzkzLTQ4NmUtODAwOS1lZTkwNDhiNTdiNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7QLxQicHpS1kBo/dpCJAAiaMVADByuRFVYUSXutWAPWkl\nKIJ08udyIcrxaW52H8+qAKIwInGdILhutuIb0cKJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKOYwAhS7R4W1OexcAHwBbVoR\nGzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO/YHMCJI/teTjf/3E9C6fZtkvXEow4thN07PjAnMGLaAiBd4NVyNStY\nQmF2C0tMArZWJsooxZ6x/+W/CFV3aIT39g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAXqBE7lVXOaF8OJOetIzieDTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI3OGM2MTYtNDFjZS00ZDNhLTlmZDgtNGVlOGM3MmJiZDA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NTc0OTAzZC0wMGI4\nLTQ3ZWQtOGFlNS1lMjRiYTk2NzczNTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARgAyR9NtOYnQTMvdmUzra0yCHlU6aet3ygQPCknySrxFe4S5XeXFiv9n3Mqqdf\nJWeW7eCK37OcpCFKZDNccyCao3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ8UZyLYMtd4AtO\nbIV+i6D3PSAc3jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAVoMtwusKOKN7pyycUlJm/5Xc3RZXt1IYcPvR/d3ymwAIg\nbI0f6SsvTLxsq2zs/IFRfuahBo6urV4SrT2rarwq8qU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7738", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7738` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAXAiCeuPJOTzpdJ10irXfOwTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmMDYyMWIwLTgwZGQtNGJhNC04NDQ1LWM5OWYxNTBmZTlkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U1NjQ4MGYtNmRj\nNS00NTllLWE5ZjEtZDFiNDQyNGI0MDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES9rmJzHgXnstw9Ed1aZ7qdm5ryODYESQhNcLDw7AN65GkLTJZH2gUjCRnSBN\nNGiIqLjABB6dDLiy14MxnZsVPKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTDc2H8+C37GsF7asd9ymmfQp1D8wHwYDVR0j\nBBgwFoAUXTYvERZNlTVfJBf193OHU7wpq5kwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA1UVNbtfRGfYl\nk//ppAQxgO5j87Ta1xbQQ8RouhQi7JoCIQCA7AdgTdmeP6/gHUBtacE0MjL7dBLx\nSSAmI/Y/yt7UfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbGN+70ekENyBCL6RfgRVDUuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjA2MjFiMC04MGRkLTRiYTQtODQ0NS1jOTlmMTUwZmU5ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATu9kGN0tRgtZmesYMJUqX/MIVNxixvihpozoz8c4XdsWnN\nGwfXEKIaQ0bNfOfjEced7Dml49SL8OA5q/8bwT0Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXTYvERZNlTVfJBf193OHU7wp\nq5kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIG2JUAvHKI5rbB3Wb1SoCUBU5pxtd9vevrUdToxCJEZAiAEApIEq2KL\nKK3dv9kvhzfpKm+V6S1GO3VIjkMTDcRffQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZ48tw5e7slAFyXNNZ7qG4reMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U1NjQ4MGYtNmRjNS00NTllLWE5ZjEtZDFiNDQyNGI0MDcwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MDk0ODg1My0wMmY5\nLTQ4ZWMtODg4OC1hMjgyOTQxMzZkNjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARK0JzhIQe4xXtMVL9aReYjlYxSO8I2qR7oBzlId3wSEL/WjxJwAREwHCe9jnYC\nec+D31z6SC3QpS2LBwsoE5Nzo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRMNzYfz4LfsawX\ntqx33KaZ9CnUPzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAc7YfI6AnxDxIgCEV9YFNO33hZQYsGSA4Q/k83KzpgdQIg\nMVGFXFBAl4VJZT+06FsMcgsYTp2FCinRgQmGzKf91Bk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7739", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7739` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAez1DxzU2etLN86hU3h8ETFvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ZmVkODZjLWYzYTgtNDBmYi1hNzFjLWMyYjI3NTg5MzYxYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ0YWM4MTktNzgw\nMy00YzNiLTg5ZDctZjllZTg0MGFjMTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQQOMNwyApvc4YjTqh2apxvagGwiruu5TG+MFfk9QzJ3ig9FqR/JSjp8+N3bk\nkgSn0py8hnnL09X1bG45nwA+c6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOEeQWDCamI2pOBEmqBixSAPQRl4wHwYDVR0j\nBBgwFoAUzSxirxaLAFlnOsjUzIXOzt5qoNkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDxfCDiQqwCXBFxftxbaLfIlAr1t+iE1jHRm33/gx/kvQIhAP3VnK4jQxIX\nEl3z5UeXXbUJnHyg0O1ehDH7JhOsUyqQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUTvnDP4jUiQ/sKjBqoJBP9CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGZlZDg2Yy1mM2E4LTQwZmItYTcxYy1jMmIyNzU4OTM2MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt3JeXm/19uqbYz7Ij8AYtBw6t+C3bUSXVB4kCg6mVPtCs\nbelEPhvdYYADSLVajoxYMFx6Y9exouFfKrYoyYmjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzSxirxaLAFlnOsjUzIXOzt5q\noNkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIUPNeyo/9GkI/KbgtSV0CF3qDNmRId9pTBUpCVTvSGBAiEAmIo+ntR8\nFBY6THcUmufIEjxn2f2OXVDx9lbeiqiGwms=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAb5mhgSH+0vik5tHJJL6P3kMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ0YWM4MTktNzgwMy00YzNiLTg5ZDctZjllZTg0MGFjMTM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNDdhMWNkNS00Mzdk\nLTQzN2EtOTVkZS04OGI2MmNiODJhOTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ1FdpFcaTmm2iRsCcqEX/SJqybwhRzblyUkKmAsBD035J1SQmXM3kmAI1pk/ES\njPtI08XuU+hajukQMYqmwhl+o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ4R5BYMJqYjak4\nESaoGLFIA9BGXjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiEAt/uilh3QZblBCdVakCoL/SulAmft8eKhy0dkG2leqVwC\nHxDhv7o46Kvl6ri6TxhORGxj9S0oYbmNTEXFbT1Ls/w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7740", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7740` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUh8bfb/EV3b+1IOFDso/gJJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhZWRmZDBiLTI2NjMtNGNkZS1hMDI5LTRlN2Q3MDI2MjRmOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWUzMTk1ZDEtNTkw\nMy00MmQ1LTg2NmYtYzYwYjUwYjU3NTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFvgushL1NZ/rS/FHgzW3X8TXd80vjCYGNVWOjxS6i8zqMGBgsxr+J9+iyG1u\nqvgXjLVUohq28UIit+ows4CWWaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe6lm2+jFZ/Hy22+I5NTv9s4+gr0wHwYDVR0j\nBBgwFoAUEND6qXjEgwgTXxZgDlgJyLxkP6YwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD92+ev2H8HW8a7ARsPMYjwQ7Hiq307atVDtH0Kk84cnAIhAKSIEUd2whG+\niFQ7d1+S9EKdUdhyqyIhRbXlG/urcuDb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARZs4LvYg+l/VdpaggHcZQThMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWVkZmQwYi0yNjYzLTRjZGUtYTAyOS00ZTdkNzAyNjI0ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0uVGr1BuwWpCApiolKRnSSElebiZ3AvbCIUaXhxTmPa+A\noy0RV/yyUN7PkyX3QUv8BGwOo5D+9j2VdaAq+8yIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEND6qXjEgwgTXxZgDlgJyLxk\nP6YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPRjAVe4oX/nHKvk3mdMbvqIsvUi/NNTZ3FSih2aZZR4CIQDGGwaDclUN\ntEkXQU5OBv5ppD79PpybGXcE7ZE5jyePHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWuaVZaguXhtSM8L/EOPQXEJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWUzMTk1ZDEtNTkwMy00MmQ1LTg2NmYtYzYwYjUwYjU3NTk0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZmY2ZGI5Yy1iYjIw\nLTQ0YjgtOTQyNS1kOGU1MWE1ZGRiMTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASRXfZDeNFu+6dDVt87Y/UCHBALhGY9ij9V44wIG1B/q26Fi7xSCcq0+vCyPBRH\nmFwoPw0FBajfTcMXs4X2FXbSo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR7qWbb6MVn8fLb\nb4jk1O/2zj6CvTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA9D7vUrLOgG88+HohR8mC+EPWCIU7MzDDopFsIP1AYRsC\nIHfLAoC0IN2CXz7S+qnpzZjIR07KgCn1Ou6oqAQrDdnD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7741", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7741` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISATPX3kcREmH9mEMv1322CdXYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1MzA5ZTljLTUzMGUtNDA0NS1hYzk5LWQyODYyN2I3NDA4MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBlM2MyN2MtNmM0\nYi00YjA3LWIyYzAtYTk5Yjg2NmUxN2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpCXlSQ4QSRDvqZy5yvTEXxuqB+kx9AmIi1kuApRfThI4LjhItsOu7axaADHe\nHoDTBQ8YWrBIoOMK0nma7rmpfKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGATBE2EokQHiLzwno3j9H7CpcNUwHwYDVR0j\nBBgwFoAUfBzwlAGMt2z3fFGUC+frDaZvLmcwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAv7z68eMsGpfoAgz6twcEuRHtzxM72ODYySETl1NyXhkCIA6clNt2mzux\n1WZ18RYCrBPYFd/xN0UJxxn1eoGeCGTc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcOD/q4xawOn81qyCT4NLUHTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNTMwOWU5Yy01MzBlLTQwNDUtYWM5OS1kMjg2MjdiNzQwODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFL727y8kA497rwZD/gr38r75uI/z4I05rZzHq4wuCH1T4\nG0RdjU30sxtTYSU6PVCtEGZHtFfqiunjxlW2A9P+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfBzwlAGMt2z3fFGUC+frDaZv\nLmcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLTaRm8ppsD2jQM5aKZcNQBDvgoKJGdgevv/DWk5tSvgCIQC5JMaAnOPt\npwuIgCrxLIcVKPIHDjGK+d1Gdc/cTivTQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARYzNo6fzvoq5zCYJwzlB7CbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBlM2MyN2MtNmM0Yi00YjA3LWIyYzAtYTk5Yjg2NmUxN2U5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNzc1ODAxZS01Yjg5\nLTQ1NDMtODlmNi03YjMwN2EzYWFhMDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS5+MKkl0jeyzqquF5xYMW69FT47TxBtSh8fb06UkoF4hFSkTWlfXo+9K/Be1py\nwYdsgOSySbLhONcSOcLzeTU2o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQYBMETYSiRAeIv\nPCejeP0fsKlw1TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBo3sAjYhE3u8thmIMprN3AaXXJ2TLy5pRSJ1hvDnh6JAIh\nAJYdHf6NCv0rJsmVX0LMNS6Hko3zHUR8R2jVlRkd0ABm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7742", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7742` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAS+7fn8Lffphqx8tRX2T/DBjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjYWNhMDEzLTM3NDgtNGQwOS1iY2YwLTg3NjRmZjFjODVhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUwYTQ0NmUtOTU5\nOC00MzNmLWIyMzUtMjViNjM3ODY1YmRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeA4CpRat6a8bevA07MfSTel/PxYEfVI5g3hLes9SBExYCQ6Y5CXDySBUiZJ/\ndjYAn+COdlcAg7xYuQAmLvkR96OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkLj08koqfYuqL0Um3M5F1uXPjoswHwYDVR0j\nBBgwFoAUCB3AoB6grbfcZ8WKHEuRmHeLG94wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA8NlZbCcOtKa49V1CO/L+u17411eJ152PhIY2DkiA\nBpoCIQCJUeikC//u8Xke1EpfYkysZkT5GjagVLhR+TsHcMMRhA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUIE57AmsaNpk6iut5PctojHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2FjYTAxMy0zNzQ4LTRkMDktYmNmMC04NzY0ZmYxYzg1YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATB6zceoGCVMALYFlUlY8GkjeDgAjB2YTtRTHsLQvQFgo4P\nXXXQmJR2pFmT/Qghhjio86LMq90kwGi4RVG8m63ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCB3AoB6grbfcZ8WKHEuRmHeL\nG94wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJUFGm9GgM4+XRbd/5/SGmil+RNVd4VqCDSCbIVigyyXAiBXNm3V5SOu\nEYJYHzEYQosFBUbrHwLXCx7zLrs7udFuaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAed69WhuZEF/R8JMEH64OSnmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUwYTQ0NmUtOTU5OC00MzNmLWIyMzUtMjViNjM3ODY1YmRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YmJjYjk2NC01ZjE1\nLTRhYWItOGQzYi01OWZhMmI5ZjY0ZjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATST/1gevB9BYi7GcSGiaGY42JyFu4kUC6Y4trZIpoxBjyaqbbztYZ4ZceaPY4j\nTO6UvdU88IxDieKbEUQuRHiqo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSQuPTySip9i6ov\nRSbczkXW5c+OizAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAqrLzoTMSff26KNOcgzsR6BTVw2u/ab7tcWhJugCO/ZQIh\nAMB9D2b0x70Kx1GaXkU4DnM2mX9/PgtChfg5LpwuHesL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7743", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7743` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAUuRs1ZIiAQbPb9Zp6wwIH7CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1NTYzMmE5LWQ3ZjctNGVkYi1hMjNmLWFmNmFjNmI5Y2NmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAxY2NmODYtMjE1\nMS00Mjk0LWI4YTAtZDkzMmJkZDM4NWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzj13IOHynUPq9dQFeIEcwyLAQ2HOPrIC97aqBXo1M2SEp1K8dubGAy05z+Wo\nurtm7zzy26xgcErSD6o/i5H9yaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0swqmBJyGP79puATeJcNoKdtoIowHwYDVR0j\nBBgwFoAUxYF7MI6llzIc0zVnPVsowOT+VxYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAONPVlaCGkNHm6C2/Z1Dz2EMNHdntnFBFLiAQhRJxg\nWgIgdrhqCcntKzNOsoAZyBk5fPuOVo+bwuMp3y8QiaoocGM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV7zbZ7g/4ZRK3fj6SN5N78ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTU2MzJhOS1kN2Y3LTRlZGItYTIzZi1hZjZhYzZiOWNjZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkS1Dy2mECJZ7/xbnEvdH0vP/AegE0xeVwiaD8JFJUOJyf\nMrLx1a6WzCizvw3yTDxhC/+LtBIHLlON66Mmw15mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxYF7MI6llzIc0zVnPVsowOT+\nVxYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBYLxWPPWDbcJSyUQEyTxOh3N1JlF2vDEoMa3A7kdRJQCIQDd+6w4hi5A\n6SmknbrJrm19M+M3ehyQAgmQS/jFgvfBDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAfx48GnR25E0Xg0/4mUREFQDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAxY2NmODYtMjE1MS00Mjk0LWI4YTAtZDkzMmJkZDM4NWNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMzIzZTQzMy1kYTU5\nLTRkMjYtYjAzOS1lY2E4YTFjODBmN2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR7NQbC3L6M6Ls1VPI3K8eAbjy0E+XG7yYJzfmcopKJLgPwIlSbDZbka8otkjfR\n4pdyPoWXXu+AA7vs0HSO1rS0o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTSzCqYEnIY/v2m\n4BN4lw2gp22gijAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAieI+78+97nMUw/+aqjyL5ei59HZAl9zH2SLQ9f+Q0acC\nIQD0xqSCr8kR/tBDSx181dPQH9bACiXy6nmOgGh2Of/iag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7744", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7744` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISATJQGAHm98ikPLuvW7Cg4PpqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3NzhhZGEzLTYxMmYtNDQ3Zi05M2IxLTMyYjVlMWNmNjY2OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFjZjQ0MjAtNzgy\nZC00NDlmLWE4YTMtM2UyNzFhMTcyOGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZivuYMRlkkUFSCBrj7AzTkPsHj+yjAkg/Zfei3mSRPCe9ZsBp+Iy2JTDQNI5\nJ8fKY1XUZP3lcAA3pyhGLDPZVaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQZ5v1kavGg6lif5sYVRJXxSDH0UwHwYDVR0j\nBBgwFoAUWLt/O4zL+HZhlpHAZWzRdAYW/ZowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBV94mdAVBrSppn4zDjqx+0bxkk6vF+uDerbKAjk0JGhwIhAOpF\nCKytE3z0SCqWjmvTmHVHJ9qoYBcUEu6Bnh9AvzTn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAau5+ScbsnSOSDP3hm6q7QlQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzc4YWRhMy02MTJmLTQ0N2YtOTNiMS0zMmI1ZTFjZjY2NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQI3K7KZVPa4DCDk1u210ktPhvfETQKKj4d1JGZk16/+iDN\nZtJt3KHOkpw8upm6C57TC9kxuz4qj7kilnnxlYMno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWLt/O4zL+HZhlpHAZWzRdAYW\n/ZowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI+40nsgH0XTFZgLPfiZa9Ms3WeojH+zsO1THOzaLtD/AiEA1ywpdfOL\nRaIkXoTMovGhxYa/COx5kmojTV8y4X/D3BI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAdc9+oKL9Eh/8WRjeaEkQ6q/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFjZjQ0MjAtNzgyZC00NDlmLWE4YTMtM2UyNzFhMTcyOGI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YjMyNGFlMi1kOWE3\nLTRiZGYtOWQ5NS1hOGQ0OWY0ZDVjYmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATgN9SKsuLcc2ojfVGVyKb3JpbXYqwUMGpVMjtUseg1CF9fQ8x6rTZbgwUW0E7U\nu12sr9fpr5nOi+sibQvi4r/No3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRBnm/WRq8aDqWJ\n/mxhVElfFIMfRTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAyP3RJEx+XfLh8Ke8kAvGfaImPDrQ1+nanQ4ZuSUkWLAC\nIQD0bW2wHcJygIaZwQDRqaHbMwcC2oPyfEfcvFNJ8+9Bvg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7745", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7745` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAXSB4dIU8rJLX5MMugCJ4DMTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzZjMyODAxLWMwZmMtNGJiNi1hODNlLTFkZWJjNzRkYTI0OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJmZDVjMjMtMTMz\nNi00ZWQ0LWFiMTktMDhlZDYwMDI3OWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpZ4AYXSVWNEs3+Zch9TqLEYzYBjMiorBgjAr1fUcNLVvPLF1GWJUDZRXSVFU\ny4l5xsgMNmOW7+e9euGnhNaEhaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqj4ruXH/Wv8stHEbMAEaG11eLXwwHwYDVR0j\nBBgwFoAUb00715ZHQnb/GZ+R7mE/tTVB+2wwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiA3IN0rWY3rTxpxAUNUtzGBXt9aYZ3KKLSt\nGupQr8EDbwIgE9B6qMOQ1Eh1mDFGkCd1UJunwk2sN57gg6EMgOE//xY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdAt1JP8iBWG1Y2Ay3HAfn5JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2YzMjgwMS1jMGZjLTRiYjYtYTgzZS0xZGViYzc0ZGEyNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqaylcHcDo3lY7m7Ev+6Fng6HrUabMCOF0RgEA5vq8iq5l\nXkQXttCk83WUU/e8gDXVC/dADyt3WIX8beWPhXbTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb00715ZHQnb/GZ+R7mE/tTVB\n+2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUfkkcQfOFowv7q/SfMCy+vq5XKyscdqleWpFn30jyrUCIC4NOhQu1Tmr\nLe+JGX01ji488HzD3bKEGqV4Wc77xA4i\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISARnnWd666tSXYKGlub+XEmSJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJmZDVjMjMtMTMzNi00ZWQ0LWFiMTktMDhlZDYwMDI3OWU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MzFmNmFlNC04NGRi\nLTQ0ODYtYmQ0Mi0zYjJhYzBjZTc3M2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARsBVRGDzxNIZ045Vc+YJiBj324D0IQqhdqRdZVegNC4aPfxiAODzR4DVL3APni\nGsLaGvSNHrn0kJPTXaQ5b7XXo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSqPiu5cf9a/yy0\ncRswARobXV4tfDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA6hzbB9VebW5z+OII3Uc0VLm9ueft0Pl8dXFlhMFeN9MC\nIQC+VoUOemXrnHUkHwOMDaZ4GEyHpfeHTLG+JdoEGAV4mA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7746", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7746` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAS6SXyOJOpmeWj0iFWeJMcWlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyZGRhZTZhLTM1NjItNGE2NC05N2QzLTllYzQ0MTc5ZWQwNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk0OGQ4ZjAtNWRi\nNi00MjYzLWE3OTMtYWZkNjNkOTNlNWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn8D0oDjAJzk2GQS8+NGWJWM+c3N4QAixwDxZeEh3sL5BwTSwnyKWvptAoPEJ\nO0rGHyZTxqnWk7v/Ht3HOgSWraOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoclw7OETv12Y+4vr6LlpxEDrvdowHwYDVR0j\nBBgwFoAUQoc2HrkXfzf1tf/yymCtGQ3esCkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAhQEvMo4Q7KbgDB2CGoDJlS3wP4aQZgsa\nKs7bWn75W3MCIQCGPpwBFqPHon8NORxB3at4SqWbe9CvHuffk7yXB4jsbQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWa+N8K4mVOw04c1mcP+yqZWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmRkYWU2YS0zNTYyLTRhNjQtOTdkMy05ZWM0NDE3OWVkMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATU9b3PKvVCIPpclMaPYg4nM0sABvwzsFXm77l+NCMEL78s\n9TlIFlkogKDN2zU10jDFCo8qHOpy6WShDQtOevVAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQoc2HrkXfzf1tf/yymCtGQ3e\nsCkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMzhWUnEGZAS8zldzsmDJq1gOL/JKzHeVgbDX8Us7PkfAiEAseYPxYJG\naOdBTWZD/fmAq9UOmgo2mI39+MWW9Veyids=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAbDRpEPHMOc3XU2O18QHFWRlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk0OGQ4ZjAtNWRiNi00MjYzLWE3OTMtYWZkNjNkOTNlNWMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YjZjNzUxZC0zZGU2\nLTQ5MmYtOWM1MS0zMGVlMTBjZGQ4ZTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASC6EgN99m+Ruu9Ok7nU4hFYoZ7Sr9a5WcO/w/VWJuzmM7kJCTF3XqXYppY4aGq\n5Er1xKP4TqKc3A/45n3TToG7o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBShyXDs4RO/XZj7\ni+vouWnEQOu92jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBmom+s0+/w+MGqWmA4wN24v2hBBRSBobbuji/GhkiUowIg\nXt2/JOcMVIhfjqwbrxJru5GhNST3MW5qO0klM33MfNk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7747", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7747` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAcLmue/9rVbbBnAzNSRdqbfMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzODI4MGI2LTZjMzEtNDEzMC1iYzdiLTc4YzcyMzM1YjdjZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFlOGZmMWYtYmY3\nMy00YjIwLWE5YTEtNGJlNDU0YzQ2MzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh/uEQriu6vw0TxOOEAlEQemHPexHEolrJfm3PK7iAamMF+S6jzw4jcWStETD\nED99QQ01FbPysbeAV7MX881TT6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6gYcLOpGcJnvRB608ZvocbVdiokwHwYDVR0j\nBBgwFoAU0+kJV2YWO3W37waKOrcZxavTJ3QwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA2EIhg9fsJj/p\nI233EU4ydX5a2WVs4xZ8+f76ddvzM3sCIA9qo7PBMAWOTMrnWkUoJPPpmbFNADtA\njZV5PMq4a3OU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASJSeyj7E6jUIcSJ2Z/oe7guMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzgyODBiNi02YzMxLTQxMzAtYmM3Yi03OGM3MjMzNWI3Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAWb/lpwsIX/taC5D4o5nsxSxQLY/Rj72txeQsMrHz9tu+\n7F2njziUr27Ah+3IFsvLpxXj/p2tXMOeuya5YCkso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0+kJV2YWO3W37waKOrcZxavT\nJ3QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcn04qw/j7Xi+XA/rdmKrd747vSGLe8ChfgB7QuqVTQICIGi2FCD/qVea\nvVsu+xf1iEGFMCvP1QTJvq0uq7zBaU0h\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdUPJ+lZ/vuVQMiJCtsYWJCiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFlOGZmMWYtYmY3My00YjIwLWE5YTEtNGJlNDU0YzQ2MzZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNWI2ZGE1Ni00NTgy\nLTQyZjEtOWRjYi0wYzE3MjgwMTZkMDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASk+h80oKH4hgPaZyq0A3m0FJIqm4v5PJOkxMLuht7fvFaNGVKV+f+1AAiho5V2\nG5er4JNAWZpRkWrLNn4w+c/Wo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTqBhws6kZwme9E\nHrTxm+hxtV2KiTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAUWuSZNvv5Bwv0xWPyzsRjRDpcpIpOm07nw/36BS/noAIg\nQr0aijK/buF0cvslr4nAWPyFvvuHMfEEddxLsy2pX1E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7748", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7748` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAcG/ZgvBso9zKFKlMQntbvG9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlNGZhYTE3LTFmNWItNGVmNy1iODlmLWQxZTY3ZDI0MTAxMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE0NzNhYjMtMGJj\nZS00NmFjLTkxM2MtMzhlMzk4OWYyYmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFeUZo9hmUAetltJ53ok08WCtJaPjpWb9h3Sl1TFJs1y2ZIvrSaUny++yd7hw\n8WHKfirmUzJOrCQHCqA8jxBbtqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVtA/ZQC5pJgfHNrH86gTy4EgsiowHwYDVR0j\nBBgwFoAUc8ZReNOk+2MuNKPMSjCA0Wa/wpcwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC2aGAqx8pRPb/pkiW1fXprAqLdtfWXXwqDceZ6fskWEgIgLvebqSfLJirj\nkf4N0NgtmJI61BLddlhJez+UKYzO08s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAefb5BpUI8rMpA1GqAbXGiqQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTRmYWExNy0xZjViLTRlZjctYjg5Zi1kMWU2N2QyNDEwMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8yuU2y1h9NtyY6uRxYUQUFn6m+qIT8FyfK+C1G8pkOzru\nOnan6N9Si7blVF2YcsUHQFI+3/CkXqC0kAenMGXUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc8ZReNOk+2MuNKPMSjCA0Wa/\nwpcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKvjDM11xEOKnnSOCsxfdBb5kKUhwcUT+eyVNUp57QCUAiEAkdgXZNh/\nB+1rVfanjsGg7f0L92IBYZUH3iAFMWL++sE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdbfLFTINyQBqz5OlqWcnm6iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE0NzNhYjMtMGJjZS00NmFjLTkxM2MtMzhlMzk4OWYyYmVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NzBiOTg4NS1hMmQw\nLTQ4MjAtODUwZi0zOWRjNDNhZWEzMDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQHVMruc+IUyrq4iPXzV8+AYLbu15lJkhHwsSNRLCGLeVsCIU3NVSmESbjAUxwh\nDze2fj4e8a9cay/liS5Exsg/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRW0D9lALmkmB8c\n2sfzqBPLgSCyKjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAhhonF4b2utPECrkLFsAkrRusw4HAgtm0kwhRBIoWLAEC\nIEdU+gxGTfl008xDGp7l1s13FB4g6MQXnl/hQdfqBXWo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7749", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7749` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQNC4hMhs1HFgbCeXIK0QAiMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3MTBkODY5LTlmMzctNGUzMC1iZDgxLWEyMDRjMzcyMWViZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjkwNTIyZTUtMmFm\nZi00NGVmLTk0MDEtNGZlNjE5MWM5MDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2iEnGPwWmPN1+UY1S8n22JMhP4AuGMqxl/qNIig+E/6dUcw/SAhlQpy1Pczn\nz8r+iPLiAP4iKeGaBwzj68kIpaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy6t1eA1xoHZndndx2ZtFhrysD80wHwYDVR0j\nBBgwFoAUJvYIwPEqhNH8Coy15Cnq+L/xCEQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDJV9/HFWk7Mmgx4JQwtyciS+rhekboi8ozuLwFCK46ygIgPxD4tOxhfFE0\nhr3YoEvbOU8rqXMo+De0TrtBpMB6rJQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUdo5KUPA2x8vXnomRvBZncAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzEwZDg2OS05ZjM3LTRlMzAtYmQ4MS1hMjA0YzM3MjFlYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZGusEJWAs/aQ8jYgYg/Z/8SbwX1RHxCUa7Q59ZzvrJ0m7\nSsuf5qmbIOT/GpT2Salo/vmfA8I74NDNSGBiYNAbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJvYIwPEqhNH8Coy15Cnq+L/x\nCEQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPzRTiQKGZKy0sRfnC6Dc5wc2dhABKbFAKxOu1vhHtPIAiEAnRSB3w6r\nmmD6OgvVrSnDyKfFpcE8fUomxLmdQrDkgds=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISATl/Mqv8Q5QS8B/FeybJWIGlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjkwNTIyZTUtMmFmZi00NGVmLTk0MDEtNGZlNjE5MWM5MDcwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YWNiMjliNy01YmUw\nLTQ2NzgtYWE5My1kZTM4NTRlOWZmN2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATbCSvJxbYDVRJDbhbkXQtmn3Epj9h6mKVYUMBR5+afT2dtDs36qI1429XZTUrS\nZq2ZmJ3p3XFH154iESORW+FCo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTLq3V4DXGgdmd2\nd3HZm0WGvKwPzTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBA/WtvLSm9VP/IEqRriPfTFrMxSufSHR1C8lcb1ps1pQIg\nSnOReupz8hzcjnpHmvtPFxierOKKYDWZzXqPCZmgDUY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7750", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7750` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAZnLW2vi2Tit0w/A2S2tZUJHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwYzU4ZWQyLWE4YjctNGJmOC1iZTU5LTQ1ZjA0Mzc4MzM2MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjIwMjlkNTktNDE3\nZC00ZjRjLTlhZjItM2NiYjVjNGZmYjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED/JN6Roefh6coTQIIu+TAQXenBGwn+FWzTysOv+E9YVn5021eD4zy9YTZPyj\nHHIKxeO4jek/gP+Yg6lb8jnrqKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrrij6rnOco4wfUXDmg1Ie7tPjlowHwYDVR0j\nBBgwFoAUK7qcMq+M/Pdc31tjHNeoBYeR+dowNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBiB9ygfT1gYzqAJWxi2df+0lyCzrapK1vurLpUXQfbFAIgaTuHJHwgDR8B\nvskG+i0eYm0zt4r331uSal85Xa4SaT4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS+rAqW6GoLuA19CDCMugofJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGM1OGVkMi1hOGI3LTRiZjgtYmU1OS00NWYwNDM3ODMzNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARA7/g8HM6VfO9FahdPKaN8mw5g2qouFq4kQfjOOuth6nwF\neicKXI/QowbyRWCUJ/WgruKQf1cHSRJoIdFu20Amo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK7qcMq+M/Pdc31tjHNeoBYeR\n+dowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKV/JtKnh/ET8dlT9h7Grmrxk20PS133fHkLPu5EaWTyAiEA9yCfjKFe\nmBxEYAmSiPr+ZCr5F9YrP5+c+epoFjbhuY0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAWGEeukC+FpshsPL4dxZRBZzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjIwMjlkNTktNDE3ZC00ZjRjLTlhZjItM2NiYjVjNGZmYjExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NzkzYWY5OC1kNTQw\nLTQzMTMtYTJkZi04ODdiZjE5NTlkMDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASV7nI2rsfIJL0WDifxhm+Tg/yH+4BsQtCGiU1qJIZisiC5CbhwESrNJ1KBUSBa\n913f/75R60Lr972uCTusx+vio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSuuKPquc5yjjB9\nRcOaDUh7u0+OWjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiB/pWVeMK1ZIXv9yMBPN/3QpsDqP6k9uaeNkCeqHnvEYgIg\nEWloK778GL537GTnWo2p8l5t1G/cMT4g9Aqm5OzQxOQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7751", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7751` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAcw3CTMlj9fBDXhxTMD6mDhLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkZTQ3N2Q0LTUwOGMtNDRlOC1iZGQ4LWIzOTEzZDIyNjk1OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDM4YzEwMGUtMDUz\nMC00OGNhLWE5YjUtYWE3NzNiMGQ3OTIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEufltuutOXKvdEXpyEEe8G8etCZ+YsEoXSZRzqumo/qYxZhbQvRA7yGzjzudx\nFjcS9N+rdJm6iejvZ8sjIDJSOqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPt5naqn2ZojWfFXKSyLro1zX3PIwHwYDVR0j\nBBgwFoAUKglKuUOuiEFyeqt7QfhxlewLI1EwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAvITjNlIc38uo+zzDj38hPkEEyn8nAXS6JeMGyWOg\nPwkCIQDfY3VWYhqcunwSw+LEKOD/OnWTpfyVGpIetsvbdmB0TA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUxbogpGQPuqqGm9TVa5rBV6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGU0NzdkNC01MDhjLTQ0ZTgtYmRkOC1iMzkxM2QyMjY5NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARU7zyUBMOwMmcLWtnt35PQJZVZyT+fJ/12qQnD/85prHkC\n5W3ExwpFUpp4ScP0soY4muW0npHfegyXwQk0pJuco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKglKuUOuiEFyeqt7QfhxlewL\nI1EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgONQV8K4abINoJYSpI/UL8oXei0a1x7nTL+B6tjrl/uICIDu6KYqLwuo0\nHsbTw0fzuXcegO5E7+JhNMy26q52hc8D\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQ02RntOvS3nSzp0Pfp9cr+XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDM4YzEwMGUtMDUzMC00OGNhLWE5YjUtYWE3NzNiMGQ3OTIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NTg0Yjg3MS05ZjMz\nLTQwMDAtODcyZC0yNmFkZDg5YzNiNDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASQUBUuhmwYULaFJXyDQxNgek+gIaYXBdtsgM1ATmE5HPAgTJiR9n+v6eHMr4KH\npaOjyKA0nUuE6U+CXXLPyFY/o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ+3mdqqfZmiNZ8\nVcpLIuujXNfc8jAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAkNiXZmJmh16nO17sM2au9bEgep1zkqcFIMXUdowbWrIC\nIQDNQ0useGqtxYPtGYsw76j17545zDkb9sFDwuyjbDRGsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7752", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7752` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAT1SgziTa20Tn8lror3+kEvCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1ZTk5ZTgwLTRjNmUtNGIyYi04ZmQ0LWFjOTVkNGY3YjMwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGViZDYwMjUtNWNl\nYy00MmRhLWI5ZWMtNWE0N2JkMTk3Njk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Rhk77grIGNOFd1NGhZiLzSNEnonXgsn/k4yNUc1CRjae3mVzAlYZqHojXHi\nTizI2C5gs+eZEHmDD22JeE0AuKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXx/8WrTsQR74VsD4PjId6t0wxVAwHwYDVR0j\nBBgwFoAU1L3JA+GvSYRGTHanz2lqBUgx9rkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA+/KkGaavCppWepJ3sguFD/5xZjt7n/dFC3ml1rLA\nlmkCIQCVAP2G3X7ib4qcT8T2eNzrPE65dM5utKdv8fyhOhcfsA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVUlcyzhOBKgZZfGXLQOYotZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWU5OWU4MC00YzZlLTRiMmItOGZkNC1hYzk1ZDRmN2IzMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZcsxE5zdnkMQNFqsP1sAp0YgXWzhDGNxohAKDuNvNmYQD\nfbRhYNVyLbTuRaf9NYAYuiRss66xLVsfri4KAhcno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1L3JA+GvSYRGTHanz2lqBUgx\n9rkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdCBzo6VAH9rw2bRW3S9IpFbAeaBA1QULiylUPm5K4j0CIQDdFJeMRLow\nvqKEfItRYCZDxGeu80bZeifjpekkrKhV2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAX3voc21ruV92xsihhKerkmGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGViZDYwMjUtNWNlYy00MmRhLWI5ZWMtNWE0N2JkMTk3Njk5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMzIyOTU1Ni00MDNm\nLTQ5Y2UtOTdiYi05MzYzYjEzYTAxYTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARsnzJf9YHmYnYSnw4CLCbCccsuOvbmiirdXTXcvxKsV1wL3438hvK4MGIGULDs\ncxgcJDWYOHNQL2mClMeFpQqAo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRfH/xatOxBHvhW\nwPg+Mh3q3TDFUDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA0X2jnTRJbg9y4GwRUz3SX/XMc7HatdxNhm3t0Ddur80C\nIGb8iUT8Wc8xbzBgEoy/IHdq78DKn3PuExj6SeHbhqjT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7753", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7753` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAcvwfcD11cT/XmCK57kDBi75MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhZWM4YzczLTNkMDItNDJhYi1iMjk0LTQxN2Q2MDFjZjY4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI4MjA1MDQtOGY0\nOC00MmMxLTg1MWItNTU3MWFjZDdlODU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9vFAqX/1eZAzG/LoyoMh43Ozi4xXrFcLQAZwg6Sphevyb4HTsFfK1pt7DA+X\nRGwJiDwvPiERP/Z1fkcMYtJQpaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuoQYVU8EA83tWICYtN19akb+2AQwHwYDVR0j\nBBgwFoAUN9WmpvT4g3ZJsMYZ4qfcFnECYMAwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiAAqmzta0jixEZTDNnoZsQKv4NbDtu3ihekTcYJhTkc+wIhAMPX\nhFTZJlvQslQek+z4uI7ySNFYX5kEFFJUpPqOhUt+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfN59R+LwC3UyFjQr/lUsd8QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYWVjOGM3My0zZDAyLTQyYWItYjI5NC00MTdkNjAxY2Y2ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1FOhR5zR+cCzaXfpX9SCTEC3O5cWd2am87ZWapDrsyi4Q\n8BMy8brQjiTy6x4mju1OCNK11xoEtDX/XQCH622Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN9WmpvT4g3ZJsMYZ4qfcFnEC\nYMAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMOieBfZaBkH0wpQQgAdz/+fxP+jSEa+YCkVMG4RpLFsAiABxCPX86mk\nr4zQLnF/7okLxLrL3cBw8Vf76WkwZWQudQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATgvVNQ2RT5Z3PiLJcBT7HqVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI4MjA1MDQtOGY0OC00MmMxLTg1MWItNTU3MWFjZDdlODU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZWRlNGMyNS01OTkx\nLTRlN2YtODAwYy1jMjcyMWMyMTgxNWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT5xEpRVrfdbHHDbQw6d9wXNw1WWSraI/TDLw5+klW41xVuT4M2oJ3WeBNm/Lvn\nEDUGEzsLOEgHG7xqb6Z+ivrjo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS6hBhVTwQDze1Y\ngJi03X1qRv7YBDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBMEl9Tp0fckl/3d0ZRRcZel9xHs2qjJ5PNLBbACG2TnQIh\nAMOxg2qanJDhjDeNTYCZXdFAnqY0/wLCFk7nKA7CfB70\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7754", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7754` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZ7FqGTScFVbXfN4o5kk6uTkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhMTc1YjE4LWQ4YTctNDVlMi04NTkzLTc2MDkxMThjYTE4ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg3MGI0ODYtMmE4\nYS00OGM4LThlNzEtMDBkMGE3ODlmM2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeNVoYgMdXVOIokgc8wXJwoAJTiUcdxDxD2xoiH+3s/QGwYgD680UgvG70RbF\ndz1Mn3nXewziZykI45xxMTPBZKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMQZs9WReCwy7gcDTBUduxpIlppAwHwYDVR0j\nBBgwFoAUk5Ugq3uhFrOD/VlWuZ7lGtG7NnMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAn3Tgeodjc3SM0OH+7wKtsWNkG8kwMm46\nsgWYZZYBZTECID2tJebta5OCglrvlCVYFhEQloeXFGCBW02mDQp2jNQh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXwxx598xPVEUad7kK+4ElwLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTE3NWIxOC1kOGE3LTQ1ZTItODU5My03NjA5MTE4Y2ExOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk1KV0EXlBFE/j+pgQmi0fSNXeN6fWBr9LdoD4gxfSPHx5\nUVWokkc5Z6S6q3X9q1sP6qgv9gFLbV3lCBC0xaVpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk5Ugq3uhFrOD/VlWuZ7lGtG7\nNnMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOB61BeNe9augaUkdj1zJrYodVwFxjXuUE+gQDVEUJ60CIAsKi7P4H08I\nu59ODWtxKmU1ZMC7EPwyXaeE3olJUF61\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAT9dTWtHSgKcMpdZAZtvSDoPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg3MGI0ODYtMmE4YS00OGM4LThlNzEtMDBkMGE3ODlmM2NhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZThhN2Q0YS02YzQ0\nLTRlMzYtYmRkMC0xNzNiNTJmMTc3YTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASxl62w6Ku7Ajg0oS73M12L8Z08loiJfHGvpDd1uYayA2Db27I4Xf81Clwk9zIq\nTz2L6NxDGhy9duBTW3xpyG+4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQxBmz1ZF4LDLuB\nwNMFR27GkiWmkDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBl0OixZXaKhIBCK6kLIfrtg6bVhOC7pyBqA4sBUDdPuAIh\nAIJHH+ESdYgVvufIp1bzEaZoBPH5UO0aYyx+tYjwcU5u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7755", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7755` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAReDoqvyQZnPz2+F1zxv1JDcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhNzljNmY4LTNkODctNDM2My04NGM3LTI5ZDg2ZmVmZmUzZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzE5NThjMDAtYjY1\nZi00MDk5LWE1MTctNWY1ZWIwNGE2ZWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+Ydz8eeT2ukJ7Xt//D3f/gWwtr1lOtH1hAJl9l+SNtSMwGrj+K5vb7fcKX7G\n43YYmyCsHGXHoUYWMbljgEbRTaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD8BcOAw+2OTNf+C3YYsunAjqPiAwHwYDVR0j\nBBgwFoAUL7FEK70nrh1LdDywym/xxuXl5pgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiB5XFjJoBu6G5PwaEwEQojvPYy4+AKGchBh\n8wCAUzSSCQIhANSYkIlTJEc+BJkTuAzhjLMwoqObL3RC1+iIL+ryUuVY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS2EQX5LrPLTWbfgP/I92nDhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTc5YzZmOC0zZDg3LTQzNjMtODRjNy0yOWQ4NmZlZmZlM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRpzC7b06tzi2h6EgxHgG2EtvC77TIwuqOO+FJciMT1Hux\nrfsXgDJYTu+25D/cSkoE0cl0W+nCyC17q+Ej/Zfro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL7FEK70nrh1LdDywym/xxuXl\n5pgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMd5+HXU2BB+/9g4yBmkC6NxanrPm+n1VlsUrUaajyNiAiEA6aNEnzqS\nWKZ2wKpbiILLkW2vgXn288Ah+BkI+Rx8Bz0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXpPit/vlpTpCJdOBqfCChVtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzE5NThjMDAtYjY1Zi00MDk5LWE1MTctNWY1ZWIwNGE2ZWQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkN2FiOTZkZS1lMTNk\nLTQ4ZjMtOTRkYy1hMDhhZGY4MDU2NjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASzkuVRTlRRN5BeQL3y+Oh0QCwHV7lVqz0I3T0variU5pyYFe1kpJ6osElNvOr2\nef8eHIIK/DshpgpNbWY4z9Wfo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPwFw4DD7Y5M1/\n4Ldhiy6cCOo+IDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAnQn5h3j2NXyNucKc+ceOhdktI2F90w3cvSXMIG/ebS4C\nIAYJdcpN1MkviP++VK5fL/ArYhJvI5oydaZSytsA3U4G\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7756", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7756` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAYfweJ5GV7fPn0KCwXRt109vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5NmU1NTcxLWNiNDgtNGI2My1hMDE4LWEyZWIyNWEwM2IyYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY2NjcyOWItOTIx\nMi00YmE0LWE1OWEtNzk5ZDEzOWJmYTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIHJZo5HUSuLr6hj21xgFAC9TgXnK4Gsp3CE2MR3B7b5eXzFRa3J//fRxjnoG\nwxlybD7ttoMY43gOmxAbAX5yOKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULzF7OM/u39Uo3xUT6BowOxSde0gwHwYDVR0j\nBBgwFoAU29vywImsXW6/yp2y2aG6gdC5MjIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCcfs1AYxnNQrHQUdqLjVAczqJW\nkLp1fYxzBYWSq8hjsAIhAMJ5zkeVC/L0iRb7oz1+vBU7zVEVrmj4eqj1S9g77PO7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZlhXqzwyPV7711TAAJMnX7bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTZlNTU3MS1jYjQ4LTRiNjMtYTAxOC1hMmViMjVhMDNiMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsrOaaKU51xdOdNSu0Oz/aqJ63YCDvvh97ODxSIjUSEZZd\nI2erQoVh31GDSUe2b5Mm/iq4fcRuzCvpfDd0Jvb+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU29vywImsXW6/yp2y2aG6gdC5\nMjIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgItOVXyQ+9d4bAvKICX5KAZIFAlh9kdfL/XBsjWeX/I8CIEJn5t3YVw+M\n74q/FhBbxspPWlf8BijBBW5xyRDa5b1B\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAeF0DqE+/7sxYbB+I/NLDhAuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY2NjcyOWItOTIxMi00YmE0LWE1OWEtNzk5ZDEzOWJmYTFiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNGIzMGU1Ny02MjAw\nLTRhNTktYmQ1NS0zMjY4ZDk1MDQzMjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARzXTlqXlipkoKt/8KYDeJDAw7wW64UDqe+ZicwLsCRqILROGDa44ZhO0ikhQqI\nnD+QoAZym0yRpBGs3PAePDfco3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQvMXs4z+7f1Sjf\nFRPoGjA7FJ17SDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAnWdei4tq9iYnN+pjdl/DOgn5YcJaw8ONEUxY3oU1VdAIg\nVAejLeo2JcF0Q9Wlec1mvcoCcjEWswDetoPpmPvpKxg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7757", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7757` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAYVd34lobCb8MMmD6nAdXlpJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2YzkwZGFmLTg2NDQtNDEyYi05NTliLTQ3MGQyY2M0YzdjNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjEzZjdhZDMtNGRi\nZS00MTQzLTk1ZmEtNzIyZDRkZDM4ODhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2vGAwb4fWXvAWuYa8aKch89yJOrBc0a+EFeZb8uB/O95q9Rpu9glVNbA+uDq\nVNvbHfAc8RlfribgvJNL0IVpZaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCpswju4DL62XaMRDAVyOBC55kXwwHwYDVR0j\nBBgwFoAUU3jdspiOMX9O3o8EWf+juPS3y+kwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANkYB4Rn\nFwPLxkVv3Kmeff4QNy6CYBlb1J6GUtmy5loaAiBpM986uOjzogwaKcoZmB2VqonB\n/UHQ48kQH98izXFGUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY1a532b4uqoaVjIqv54u8Y5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNmM5MGRhZi04NjQ0LTQxMmItOTU5Yi00NzBkMmNjNGM3YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQy13BA72O+KbeKWiwjUmf86GDq1a2L4SyvwsoKzYib31U\nLurIjGTqVsf7UltlJw7sKe0tfv8szylgz4wbAqkHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU3jdspiOMX9O3o8EWf+juPS3\ny+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX+gHv7+mUnnml6VgpLqtT/2rVDFG0RIZBqnSaXQV8eMCIQDdY+It6a5s\nyVE10SOz+bkYFCCPA6UNPzxcgJPQ3CSpEw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAcekJ7MN9VCw7BPGrkfYthhOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjEzZjdhZDMtNGRiZS00MTQzLTk1ZmEtNzIyZDRkZDM4ODhiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZGI4YzViZS02MGUy\nLTQ0ZWItOTk2My1lM2NiMjQ2ZjQ2NzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQIidr5I9KMvBdpdaD+sulysCLFrsr9PCC8+VNSyB9i5cYW97OQCPk87kQODKwo\n6s/Nr/b7SWZzs3sMEqOfgxf1o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQKmzCO7gMvrZdo\nxEMBXI4ELnmRfDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAj/1VI7eOM8B7olxr+uT3HS4VtRWziFwmwVfRZcikc7YC\nICnFyA2IaFG4TNtCv8ISw02N1JXYIMCced6ctIwFNh+M\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7758", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7758` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISATRk/czdWdz2VrmmFTuxxK1BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1MTg2NWRhLTZhOWUtNGRjMC1hZjEzLTRhMmVlN2NkNjM2ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZhMzc1NDItMzVk\nYi00NjhkLThmMGItOWI2MDczMTU2Y2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECuRyHYSQJURW/TmxnTyicBiErnLa3KPHRTaFL0yxUM49HTjw8MtnyrjBaERV\niouGMASM4X8767Dw9XF77/SI5KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURckDzGUYvKUIfpeo16cz8IWhkG0wHwYDVR0j\nBBgwFoAUITfs0vE7JyZHFI+OC/NWLmeATtcwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALsQLCvr\nQNLWbcunml+JRS2wlvaaPS0XsfL7F6lfMcvZAiBPvp7IOTnHkYFWwGDDOt/WNHrB\nBjv461gL3Uc3fdR8kg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASwpQsaSTed9gmDR8st/xB5RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTE4NjVkYS02YTllLTRkYzAtYWYxMy00YTJlZTdjZDYzNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARf7LT7bXMUxtFfftDeomdcFTMF/3W3lQkHgavnTG+m28AP\nmTxiAnJpGFUvyVj3nn+/wBifAUX3R+2XKEGEEiHQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUITfs0vE7JyZHFI+OC/NWLmeA\nTtcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBaj+B2hZGTUBiAzq2L5Brh1X6q2iV83kLn4AL6DCxhQCICyqqwvCtFTa\n7BcHgy+lTuBEGIuACJV214tNqv7GBSBQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAeyBbcIQMo+PT+ShVUaMZEI+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZhMzc1NDItMzVkYi00NjhkLThmMGItOWI2MDczMTU2Y2U1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNTE3NWUwZC1iNzdj\nLTQ4YzItYTlmZC05M2Q3ZTRhMjBmM2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATVKXXtkjsSaCnbFAy0JcNDTJNpgkFvcWgom6/Of8i5i5R2o+8SxCOwm+o5oir8\nnpu0RuDEVMdHcKaOPHQ5MhY5o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFyQPMZRi8pQh+\nl6jXpzPwhaGQbTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA77suwUJ+scm1FNnk/nIXe7gncSy8Q1MlYdHIGjfUs/YC\nIGCatZC65SQgBNQCAHiSD2Dx2NoRiQ7vHt6zfvEap0L7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7759", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7759` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAenS1s31PyJsGHXxurM32sf/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2ZmQxNDAzLTVlZjMtNDU0NC1hMWFlLTNhNGI0NmRiODFlMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdkNWMyZGEtYTg4\nOC00OWQ3LWI4NTQtZTMwOGViMTQzZGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGF4rD5DCG12OJ/TEe6f/HJUormZgLM8lFrmABUxhBlCVtOezVoOixEwfLIn+\nxFxImk0wlOMi5xC+Rnxn5z8qN6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUazlM5SfPw+cH9lmaUwSlbgexg4MwHwYDVR0j\nBBgwFoAUA/iDkWsbZh6AUOIBw2CbI4wF9HowLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDi7hiN\nM2oWuhPeeF5PcbX9FE9/rMYRsvlPOaJ2GUA8VAIhAIY7HImajD6vPPTL5StPbZxu\nPpewDUuWyBlkG5/9L9TG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaEcYjtrYqa+mOxe0MUklDdPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNmZkMTQwMy01ZWYzLTQ1NDQtYTFhZS0zYTRiNDZkYjgxZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtq6zNG4PrWdqWaxxkiFqWKbfB7IW6xSVQ8xScq4d9ei9J\nxf6d0LO9JD7M28So0mSloRaB5CzyQr1LxbZmOJnno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA/iDkWsbZh6AUOIBw2CbI4wF\n9HowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLu3zPwSoRi8iaz4Ygr7sulrq2BacK+8K6rJ6PCTTnTICIQDn4CD0McWB\nKo+NJd4CYTsxyuJD1v0icHGSamBUVF4DTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfl0oHX7RVAiM3tvthMlVuFqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdkNWMyZGEtYTg4OC00OWQ3LWI4NTQtZTMwOGViMTQzZGM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZTQ5YmFiYS1iZDY1\nLTRkMTctOGMxOC02NzYwZmU1MWQ0ODQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQb8Ue+QvBbACU5r7iX61Yk14yn4a1WY4CAA8RVTZc3n9tO6dA9ygGyRASAlQv1\nG7X92/yn9z7Mb3SX4Fyhm6KHo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRrOUzlJ8/D5wf2\nWZpTBKVuB7GDgzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBLfGFxRVeBDdYbRbU5+TQ178gHgHYo+HG/tTq91dDw+QIh\nAKrRmJy7icrg8hmCDs1NrfuQ4gWpHkuVl+dPMnxzLSsa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7760", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7760` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAerQyyX92g+L4FqC2/npunMDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0NWY0YjdiLTEwMmItNDk3OS05ZWM4LTQxZTllZjlhYTQyZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhiNDg3ZGQtZjcz\nYi00Yjc0LWFiMTgtMDk1OWU2MWQwMzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENMZzq5dIvtTeRMBS5AWn96rmRXjcJIi3EWLhLLA5+7Q0tqwCxvpMJd9Wciyw\nWjFCfAlCv/yDQlcwhRMl3K9WyaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1spTGMx9q0yDZgL7HuPYOUqDUXgwHwYDVR0j\nBBgwFoAUjZFPbZwfBnyi+Y6cB7KOuyRgOWQwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDlTaKziDJbZhyl2RzvfdWpbRE4oOtkxXxzu/McFHgmuwIhAKxj8GPT\nMQ8Z8wbu7G35C0BXWVu1jCF/d7rB3FEELfqH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXYP9KKd1+PElIYc+nmvBdvGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDVmNGI3Yi0xMDJiLTQ5NzktOWVjOC00MWU5ZWY5YWE0MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQs2kPpdOGRKSBjERbdhE314SEA/gGZ2RiHn9TV9HqZm6Hp\nm2p2y9XjjftOHE4vpP3URrSReWTw42xGJe4K+XPOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjZFPbZwfBnyi+Y6cB7KOuyRg\nOWQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALGpMhRSfk9AuGBYwWwAWUVcXLv2QgL94BpTJJyZYOt/AiEAo8g0dYKN\n7mHICzemNYoGnFDeqeFDWUf3p3EhIrtcEEs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAa8WQV9aEmERmZM/jrkCdSVAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhiNDg3ZGQtZjczYi00Yjc0LWFiMTgtMDk1OWU2MWQwMzkzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YmQ1ZGY4NS1mMGUx\nLTQwMDEtYTEzNC0xMzljZmQ2MmVlNGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQQCrkfJxfwEpkMYY15vNkFPj3rxBSZVl6Ijd2t88dgzP7CTVEry2i9mu6z0zRj\nTD+WE5zXE4n51L14WhqjGuZDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTWylMYzH2rTINm\nAvse49g5SoNReDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAwMlOzfIesevzm2CI1NhozvwUa2nrJGgn2eDZYUbid7kC\nIQDGRCdgNr8lPqiTJyAZlHKE/kC5R2yGSYVVdBpGct5b5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7761", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7761` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARTbnUaw7XktwX0NfpTsL6SEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZGU4MGNiLTI3YjYtNDI0NC05ZGQ5LTEzYjc0ZDQ2NmRiYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg0ZmY4MmItODMy\nNi00Nzg0LWFhMjMtNTkxN2I5MDU4NzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8JKKNbeXmkd2CJgWyFsb9fs3cSnM1FuJoPSkXJ091oErJciPi9XFzoG5ixY8\nXSxshxy3LnlVWoYx1rLReZCqx6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeUSCxI/qjlNhUNdd8jFXQmQBvxcwHwYDVR0j\nBBgwFoAUy/AaflAnVV+pViXh2bQ5kZU1c0EwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIFmbGUqMGlpc0qPdEl658Pk1Qqlb+S5vNXQiUUWsApWsAiEAukP5EwfH\nSJ2fkA6Lq52hNbVZAZg68t9slXmDR0A6HSY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARVU0FTI1XOVT/Wa9I5tZf92MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGRlODBjYi0yN2I2LTQyNDQtOWRkOS0xM2I3NGQ0NjZkYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5kfGTKus+/1TbA7ypGj1sGEGRh/oMaTEpd4cT5rGP3LbL\nh18vu3Jn0lHvNOCcLXnY0eynO8jHKwukeenriHm1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy/AaflAnVV+pViXh2bQ5kZU1\nc0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALanTIlNyG5N+2ieM4xxTzOuVBP1ZGo9U9JuG91V9It9AiADrSWgQtyQ\n3H4I4fgGlEH6fxlNYiC8d8bNd8txpccBSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAdpguED5NcT9J13QwN5AMo8DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg0ZmY4MmItODMyNi00Nzg0LWFhMjMtNTkxN2I5MDU4NzgwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZTBiMDAxOS1lZGRj\nLTRmNzQtOWJhZS0yOWM1OTU4MjY0OGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ5WmbhYywl7VM5+CJ43nQLaVJrdya9VbLdZEtXHcVWCclV75v9tHwb+EOuVfI2\nQxJLKB8QPsLYSxWi7RjBs24Uo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5RILEj+qOU2FQ\n113yMVdCZAG/FzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiApsKpSmzk7lSQdmT1JjQnWix//Nr6BhILQhPIA39FYiwIg\nCFmi5zofhnxX3X1j2ZSk7XhWnheTgO6l89kJ/2jkmic=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7762", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7762` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISATUORHD849QxV2M6UcOPdm6OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5MzY0MzFjLWQ0N2ItNGQwMy04NTA5LTQ1ZDBlOTJhMDg1YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdhYmQzNTAtMjMz\nMy00NzljLTg2YmYtYjZhZTBjNWY2YmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENeKjll6ezlN8TzWwhLqZbCzzIzs+8U3dWu8rzE+zPkZ4OZYrdtexZoL7SYfU\nHyhldr4HOeGiCxH1BvRDqAVqcKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDOnqLWaxfoU/2J+Ba7wGc8qWDA8wHwYDVR0j\nBBgwFoAUk1Vj3LrM6fwq82/puVhO6S5IWKQwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIC5tis6ujUhFB0lsd2GwmYS8AVQwEeqa0JyEcWoDEMXFAiBilDcNlCSkDBqf3jqM\nPgK4OBDwPSwTKIlhUoLy1mNlag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASlPcAmIaP015GZUKNaWm4CLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTM2NDMxYy1kNDdiLTRkMDMtODUwOS00NWQwZTkyYTA4NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGEvq0IiQ6Ya9i14tEQ843yDEI4jnaHfDAH8u068wOu2Pg\nLX0OOxJCnNPWe/yw6yh7m5XthgXW8QFKowYPPNoeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk1Vj3LrM6fwq82/puVhO6S5I\nWKQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJShBp2868NegHUwDhRMlTGyOXEuZEnV0OAfxxwifQreAiEAoXhzS1LG\nbYZokUUJZwAM2BcoiGwaYGhNtxTeVNB9exY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfWSWmoHN1lkiLcQCvM9PQHfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdhYmQzNTAtMjMzMy00NzljLTg2YmYtYjZhZTBjNWY2YmY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4OTYyN2JmNy1mMjlh\nLTQ5MTEtYjhlYy0xMmFkNDRiZmRhMzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATgl3PIgG/Ul5YFmB1JsE+TNP/cgCh2kwZxzvza4zWYXtqW+ltmJis5ep34d/OA\nXXFWO0HNsqIsC7XGm+ei6u5qo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQM6eotZrF+hT/Y\nn4FrvAZzypYMDzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA33LECs7zx2uXiH/4MLtCIKhZtDmy3W2Wsa1k50hCIssC\nIGSrHPqbbYib2JAcTxM2t1srLlmuyfqkfNGt1Oesioi/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7763", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7763` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZWWbgXJEYpTPJn8ZEGCFRLIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxYzU2ODgyLTgzODktNDM3NS04YjdlLTIzZGMxZDllM2QyNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y5NDlmMmQtODRl\nMC00MzQ1LWI2YzItMWNkMDg0ODM4ZTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERfx6KhBDJgF0u/1NmL1cxyQ8sIbOxK54b9KLIFKqpqphBxyMbhnkidgRu+DC\nb6FDbYt84o+zUBO1Zmt1/QGhNaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/5e+NvtTPvs7Psr14yYNEMCYDhEwHwYDVR0j\nBBgwFoAUGtXqjisQXDOmgW70FNh197P0/jUwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQD5w9LsewTXRd9D3UYhvhhjX+dy0Shw75MpvlWf+g7kUAIg\ncPfMMfK5a8PP+6LmEVZposwKZ5GNf5FdvoheQ3InsKw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUxQAHrXnJjyjKgBfxTGkreKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWM1Njg4Mi04Mzg5LTQzNzUtOGI3ZS0yM2RjMWQ5ZTNkMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATB5sx1zRFD70H76ja4rCcr0bUoD8d7McwbHCw6X80Qy0xT\n9KyR1GGOkoZOCJ2+uX5fMrVWDcbCkj5qLXKSp6K6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGtXqjisQXDOmgW70FNh197P0\n/jUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL4xDuocSb8es9otwqnicCD8pIEn41RH/mWjIR0AS8MoAiEAxAdo9A9M\n4Qn77UFZX5m5Gs90CC57Lm+F9bJmHwttA7k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYUCp3Csaum+qnN6XzZhQzpyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y5NDlmMmQtODRlMC00MzQ1LWI2YzItMWNkMDg0ODM4ZTBmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNzc2MzY5Ny1iYzlh\nLTQxZGEtOGY5MS03OTc1ZmFlN2MxMTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS2hJO2pK6j79wZSaM0d952j6ZWyWMVtPUT6Y6a2Woe294R3shOMEmU9D3vUhqT\nxBWYWMRA4H5CtSpIjNaEvtPRo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT/l742+1M++zs+\nyvXjJg0QwJgOETAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiA9OUYDuU6ElbBEEpigU+GRjqk7fUfpWi4bz1QWMrUF9QIh\nAPvouYkh8I51EcH+OK+1rle+P24nNRnQYaGK1uFGURsN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7764", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7764` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAVIGRI6cF/HuDdi+Yz9nTsppMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlYTAxYmQyLWI5ZjgtNGMzYi1iYTdlLTY2YzIzYWMwY2NjMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFjZGRmNDktNDlj\nMS00OGY5LWFiMTktZDA1MjdiOTdjZmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEypEFvm9XhZAoSF+Ozn6dRjFUIpD/RdUApypCuZH06ouwuXOYdZ/O1WWTsU9m\nbOdEt1l6HBgiPScwpbzT5HY3PKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmvHVEBJFDDAxSOcFc4vYFQ8NrBQwHwYDVR0j\nBBgwFoAUEYAqRfb2P3vwUpxamsnoKRQCmNswPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDW9d0HOVK73RdLykJg6uf6IHIOZk7a868DdedMFuOqewIg\nc/glN/FUxfCYQLz87opZkFXanxwdvQquGDgW0luruHs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUbKJ9z7MwGsfqM2j5rgRz/wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWEwMWJkMi1iOWY4LTRjM2ItYmE3ZS02NmMyM2FjMGNjYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAgD/1rw5f9HL+sHUIgoc7xZGfCiZOAQjQxDYCzTVnYGjN\n5WdZProO48vjer4vTA1rxXoatzyOjRAj/KOiEfdvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEYAqRfb2P3vwUpxamsnoKRQC\nmNswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJZhlOtoKnos/u3dLU6CwP4PnYrzHLJUV+dngMgcm83kAiEA+5rtEDhs\n5HLbIFACHiAFgD6clipqpx2o4kq/9Bp41WM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAUx7mkP11xIWjk7makgM1QpOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFjZGRmNDktNDljMS00OGY5LWFiMTktZDA1MjdiOTdjZmVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzOTM4YzZkYi05MDJm\nLTQ4NTYtOTA4Yi0wMmRjYWQ2ZjRiMzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS0SsndZjqaOmGZTeKGVw0C+S7gKxM1ONm0XKC5CpoZ9xB+SHDpEZEZB+4zw+VU\nd+A+Uv73gsy4lVcSN+NeN7dQo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSa8dUQEkUMMDFI\n5wVzi9gVDw2sFDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAkLpCI0Pyv0NurKzC7Vvku0HQ46ZAzvkC1BNT2F+MvKcC\nIQCfV8/eHFNAmv2fDqMvQAuqpx5OHcV+wNLnthm8NaGzrA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7765", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7765` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAbILrU0shHBwUX7B69LoNYasMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhMGJhZTA1LTZhZWEtNGUyZS1hZmYzLWViMGY0MGJhNTYyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA5ZjFmZWYtOGY4\nNS00NWMwLWFkYTktYWU4NjczNTcxMGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfDGuwcDvmLG/tE7bwgqv2mNmW/xDctggin64b07Do1Rwo2jojZ5KSZ/Ie0ZG\nyQMiJyWyN/EuWPcWeSwCd6NwJqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUow1lM6MK9bTLf1dHuRowqTmBHlswHwYDVR0j\nBBgwFoAUQea0eSFTIVp6j7+l+B7VshLZ0aUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCaycoGoiEB\na8NRRj4/BZGp9c59yb6LfR44C+97WeAbCgIhAJK2P5Uh40y2Ak/Jd6eT3UVTUlzO\nYbBoGum2CIEeVnfT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdK9rAEmiffpn5tgpPZpXjsHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTBiYWUwNS02YWVhLTRlMmUtYWZmMy1lYjBmNDBiYTU2MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUoANXGd79ctuWH0FDTEQ7uhkw8ewOTGIkBFjaUAxMOtcH\nRw75kPSVyWcZTmYKr4itNu6zkW1Vqg7wTiVZxeRXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQea0eSFTIVp6j7+l+B7VshLZ\n0aUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMETaHwmF5Sas4/U4Cn0YpSWxy0sWjSR5GBpoI6bcFJsAiBJIflgmopE\n2kturkQ9ptlI4RexZlJv4XjEVUzPmjY9Nw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAcA2AXA9HctikiOK3S7VHcYpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA5ZjFmZWYtOGY4NS00NWMwLWFkYTktYWU4NjczNTcxMGViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNWNkYjI2My0yZGJl\nLTRiMjYtOGNiZi0zMDcxOWE1MjlkNjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ11706Ydi7Sckb/1qPXNEf+99dH7l8cuaOJRoXcbaW/KxoK5UFp3NgvE594Qnb\n2p7wlxq3+cfQQhMV0vGy9E8oo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSjDWUzowr1tMt/\nV0e5GjCpOYEeWzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEA9Jqf/YJYVwIQhbfUJqSFoOX+MVq7LYPrVgt0NjVUW4QC\nIEctMCKMz1cXom6dRlPlUsKj3S0zH8ymNEPzyuj0RPGu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7766", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7766` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAf0u8uL7S/Uj+SHJ7qJxki1+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMWEwOTBhLTc1ZWItNDk5ZC1iMjczLWE2YTY5MjY3NjVjZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM4MDcxNGItYWZi\nOC00NzY3LTljOTQtNGNhN2MyMjdkYWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKyy1IfMfGYn3TZRaNQ5g5VyWJop7UNeHKcIzR7FK0wBJfd+R3b8GLKj8bhg6\nLomk7nrFQ1gpqSRNKQQWl+y8h6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtNJH1roL0X0DgfxXDAqTqZG7+gowHwYDVR0j\nBBgwFoAUZd7baRRN/JGdwfYRdM+iuPIuXkYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAP1sRt2KthL7nlIN2ZPreU7llq537k76hg5UgzBTfPVJAiB/fXCnnFiD\nWXoTgG9V63kGHEcYH5t2/UQlxG3rrtb0HA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZKAU9WmYO9kfV9JGk+95ImOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTFhMDkwYS03NWViLTQ5OWQtYjI3My1hNmE2OTI2NzY1Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKsW+HF4NgJybLjuEY52XhwYSY/sGE4CQZPQU6eRDzQfma\nDSeziCQf4rA4gZ0dv7cF1iQRzahLbZUaA/ComBaBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZd7baRRN/JGdwfYRdM+iuPIu\nXkYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIzu8PWdjzq5phjpoFVBgY5BIK+RhdoUb9gPkqKBhUa7AiA2yMvwmTy7\n3DlUIRcQafTiKSqdD0sNwJl3jIBU1Od9LQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAeHF0sfU28WOLH0tNNyZXPuEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM4MDcxNGItYWZiOC00NzY3LTljOTQtNGNhN2MyMjdkYWJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMTY5MDVmZC1jZGYx\nLTQxMGYtOTJkOS02NWIxZGQ3MjlhNzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQeOA5dLv/DU+Is9CKwydrCJPHn2Liqyb4AKZhXWrCYK5L1siT/1fU50fKwuPF1\nnk8Ikkc7bY2DXHf75msLGsvQo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS00kfWugvRfQOB\n/FcMCpOpkbv6CjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiAy8vt7KW6QHn2CbmgT2aIPnZZzJ5q93jV4xAe4S+o0NgIh\nAK9cCsC1tkeXqDeO/do16JsGrAvCCF0f8zS8o11iuScB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7767", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7767` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAYAJ4tOoSYSDXJV1kBlYDk5NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4ZmRmYmUxLWMzNzUtNGIwNi05ZTIxLWM3NzA4OGM4NGQyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU4MjQ2NWYtNGRk\nMy00NTIzLWIxOGMtMjMxNmY1ZTdmZDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOy6WUxmItdRX4NlwpmBoEJNJc8PyJRGtUH6kni/n3zCBCulD4UDXSvJ/Q+BV\nruG+kWG0b7Bmjwo0kVshs28N4KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUouL1lVD1TVBbxl71N+LC3FGkskwHwYDVR0j\nBBgwFoAUMGfi53hiIlpxlhq0u+42MOiQADgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgZVFOd994pO7KclykdYp3NsckZXD4o4KC8d5h3yGND/YCIBG4MFtW9sjw\nq2F/hURprrDqANHyWG7wmqn3H/nBmz5u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV1OEtx3qKzBDyh8lSFIlUziMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGZkZmJlMS1jMzc1LTRiMDYtOWUyMS1jNzcwODhjODRkMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWpOmZMIBLBZ/oJAWvWUtZM0L/mhmXuEd05rLBSMPaplwx\nBFR1JCQJH4gxv4vK9f/cjLgOXopep2u5x0h5oWoSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMGfi53hiIlpxlhq0u+42MOiQ\nADgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM64wtLMRaOB7lOzFR5iMJX+G/FocXMdxJ180ScJ4hLwCIAJkKRNkxtwv\nyXiyHkrgV/CNTXLKb3+kXv5TeNXbDg9F\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbsjGmjJwYfjpxmoo/zFTWtZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU4MjQ2NWYtNGRkMy00NTIzLWIxOGMtMjMxNmY1ZTdmZDhjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNjE0NzE2YS0zMTVh\nLTQ4ZjgtOWNkOS03NWI3MWY5ZGViZWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARR2pNuYTfp+AOlBHldHJzI4x8WUsBqseYLP4zba6u3nHhTwuj0kQDLvuV0JcFt\nRsnAiTWLZ2XiiyFnC8PdZgkAo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRSi4vWVUPVNUFv\nGXvU34sLcUaSyTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAwu5sT3aJHKZY3o4SWijINtxT85Y8F8UuoF89dNNViT0C\nIEBuS1xjyjeXM83ozxEVUak6SwDbrk/2JsicPQV6y3Qq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7768", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7768` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAR7UneYQaxx3GYIC542TEfrqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzYzYxYzQ1LTljNDQtNDE3NC1hN2MzLTg0MmUzOTZkZDY4ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJkOGQzYzMtOGJh\nYi00ZWI0LWI4YTItYzg3MWIzNjg0NDQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu/si/ZoAK5JIBuqc6DKjThEXC0fTvYG2vRh80u2KO8Xrx4JN40OzvU/IX5pi\nWe3YymCwcAQP2RTw+XoQxpEYt6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1SDg2Dnj/4UpkjyUV+gxdNiAluUwHwYDVR0j\nBBgwFoAUxmNUP3QYxM+Ih8sqNFp7jdwcdCwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCICldlSNVhUpPqiu5VlIEkTCRO/LscZI3eIR95XYrDZFuAiAypdrVvCEY\nE+dsRj2sxbGLdo8AMIuGlP4nld9vwwe2fg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASB+3950EoBdmyE6CKm9njX1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2M2MWM0NS05YzQ0LTQxNzQtYTdjMy04NDJlMzk2ZGQ2ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9ytM/KLZUWTQzx+M6xFEdJRdVUYyIsbz7BPRQ+zJvuwwG\n0MS2X6XyE6eLFu9Iwwb6VzuNJdNSYqJJ9XqWVU2Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxmNUP3QYxM+Ih8sqNFp7jdwc\ndCwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQXhrCYP9TGT1SDtZ56Z8WHqA0zJ9U/NGYT6WrghoFx8CIQD+BCAs+7xJ\nk9wW45oEo72N0qUJDkKanGE0WfKjg4ctMQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAVb2mH3lnb5D8tqy5Szqsd1eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJkOGQzYzMtOGJhYi00ZWI0LWI4YTItYzg3MWIzNjg0NDQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZjViNmIyNC1jOGFi\nLTRkZTMtOGEwOC1hNTA1YjI3MTg2MGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATR17NllBlcHfPnaNKWYLLRsT57NTKxZEkV8KSLCD1AGo+leiUNDokiybByJTzd\niotZTBKczv+elm1JODPzKgXxo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVIODYOeP/hSmS\nPJRX6DF02ICW5TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAMN7Oo4hlgvZw8Jd2moMpKFCF0tpuebAUKwGwsf38b0wIg\nHLUsaQ/Oebgp1dgMf30RMZWQkdeSUCIHp1H4opl/R3g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7769", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7769` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAefcK/8FV1mBD42ZRwEuxlqkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNWU4MTAxLTk1ZWMtNGM2ZC1hMGI1LTFlMmY2ZTZlNGY3MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGYzMWMwMWMtZWE3\nMi00NGViLThhZjUtMGU1NTUyOWEwZGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqPWsVqNykQVyk8wfqSf9jjD7sxMXu6NR85A55g+pLbCJ/cXTwgm6UqCYijCW\n20GND7AaJ8s2OHswzZjWL8cLm6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX9Uz+3o3g6YWae461Va7bSFDyLswHwYDVR0j\nBBgwFoAUA0H626fIBu5Z5RPevUM/b4TWF1kwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC0DlymCtL9sXal/k+EWAftSIz36u29Z6j+/p4F\nGWvY4wIgLS2xdJQ2op29F+Z6DpJBmE7afpvLmO8tHkFfCB4iLE0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe6UUKE9tIIzDlFVsAGJDrysMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTVlODEwMS05NWVjLTRjNmQtYTBiNS0xZTJmNmU2ZTRmNzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjsakrqB+jdiaYyg8hORR+m7smQUjIuGH13ftaFccHX+ol\nzwtqwUfD2mdPZ+/vyhem/ELf0KA0b0faAoLeF7Fso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA0H626fIBu5Z5RPevUM/b4TW\nF1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXLh3gvBjv4HO2uxSShlpFwTGjwQ+Gy74mD+6Ei5bMAkCIQDatj+B5F0z\n1O0Z0bu+7jTfTpc+3wTpCqmppXtQT3YaEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQeH1lyAS6uaWeqTiMG7G805MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGYzMWMwMWMtZWE3Mi00NGViLThhZjUtMGU1NTUyOWEwZGRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNjA5YzkyMC1hNDU4\nLTQ4MjUtYWY4NC03ODFhMjQ3MTNmODgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARUB24gjd3I2phOKS6jHFY6+D9pFcmbdt7K070cNgEJd9cCKgI+9z1HiR3bPrSJ\nYYLHhPH8l1Nny/FC1qvRt7FHo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRf1TP7ejeDphZp\n7jrVVrttIUPIuzAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA6iEe30XKTIWkh5MrCghas7YuCestN1dcovsKgd9F4TAC\nIQDj2mLB9B/TJg1NH1LQHbhuN0VpP17Nm7BozU13Djk2Qw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7770", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7770` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAYZUe6/0kF4fAJeFfJeSzx8KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5OTIxZmVhLTI2MTUtNDFiZi1hMjRjLWFjNDNiYTFhZTU2OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNjMGVhMmUtMTUw\nZC00YzU1LWE0YzktNDZjZDczYTRhNGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKu7UcKLutEmcE8REGNvy59ECQHkXxqRCGhu/gUxm+JI+yTshZbE57o2wwhUT\n/PaHvcsUcvmoxTLsFDjFWr59x6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVbS9dq324bcD8by5/OTAXHL6XJEwHwYDVR0j\nBBgwFoAUh5fJiGsk0WPBEyt/R28gKTl/3JMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIGBeX9YLjz02TtDH17LQUCCI+81RQrGXddPQ0QC1\ncscyAiEA23yJxFl66pojz4XdqGJrvk/jahAuh6txtx/8a/oe6b8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARKb6NwphuONTGLSy2qubzZjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTkyMWZlYS0yNjE1LTQxYmYtYTI0Yy1hYzQzYmExYWU1NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyOsYQVgziPFdgeJ1uaevo2OtEQ3dTmdUF49HZWKDtIrk4\nyvRHZX/U2vl3TiELAyrizh8rMBvhDJ5PzdtFJ071o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh5fJiGsk0WPBEyt/R28gKTl/\n3JMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAImSnAkcAwWW+5si99aSKT3KInE6Ex3wxsyYyjeKfJ5SAiEAv1Cf/YZr\nAqtJtk7GWw+UVyVhXvIGEAG8+ixorxolfto=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARI9gwIOkKFQbSYTA8nl7UtWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNjMGVhMmUtMTUwZC00YzU1LWE0YzktNDZjZDczYTRhNGVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZWZhZWUyNC1lYjIz\nLTRkOTUtOGJlZS05M2QxZTZjNjI5ZGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARpHxEcLPWRZGTpN2y5MbLDb4M91yO52a0sHiwZ4x24GPxowy4wjrwXKO2FAIqa\nIemOEDa4ByIL2FfO9H2Z9jfWo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVtL12rfbhtwPx\nvLn85MBccvpckTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiB8aZhaLtuf+29FJGL3myked8ea0wSdS9kWrGNteg9+CAIg\nQHzwnmsoh2BS1Tg20zJrDa8mxsxqorNxcebRVfljQqs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7771", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7771` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAVFLsWxVHaM/MS3cBcMbWXY9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5OTVhOWQ0LTU3YWItNDBmNi05YjkzLTI1ZTUyNjU3ODg4ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI0YjVjMWQtYTIz\nZS00YjQwLWJlZDktY2VjZWE4NjgyZDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqVZVmd0VrC9vZqogUTzI2LUkM7VNoBWtYfzXAB8qKy4gb3duDpFxjUEd8QkL\nqA6XbcnUxX5Df38/UyXOpmPN1qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTLBb2mKGoktfz5hf+FdhHdEUuzEwHwYDVR0j\nBBgwFoAU0DhyAE295Md/9Lh+OdZYkljZa8cwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQDegg7Nl+fqkpt07ydgkbFLfXxPjfpPUTsztBqw6uwI5gIh\nAPqcZivjD57tS5jl7vAxKbaEc3XKMTGTx5/X2jIZSy3W\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU5SYEfn7VVFQtGntPWtJmUkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTk1YTlkNC01N2FiLTQwZjYtOWI5My0yNWU1MjY1Nzg4ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5s7BLZPKSFf1hfuFO7il4MSeg2lpznIcsEJoYShG+fNGS\nJ2DjbxT4Vk6XKzC2vabhyH1gp00JAVsi52Qs6bXWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0DhyAE295Md/9Lh+OdZYkljZ\na8cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL1n+oK72tQ2JKudupOBFJ3wZ5bCeOnai1A1AOllqvlEAiEA4zRaXXko\nhthwIFjNDLWji/nwK5dwaM+kt9fOgN+mynY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISASyLnIa0liIcy/vbd301qxYcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI0YjVjMWQtYTIzZS00YjQwLWJlZDktY2VjZWE4NjgyZDIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OTRlZGMwZC05YTAy\nLTQxZDQtYmNhNC1lZjczYzcxMjM1NTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATM0NaWrasRqe4O2v0t/KmvJ1ysXlMLSYP2LQtaBXK3dySymDhquIbmS03Ckh1/\n+WnfOkR7/Q7NGrN6hgPWzB2Ko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRMsFvaYoaiS1/P\nmF/4V2Ed0RS7MTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAPO0JruVf69+kPyDaXPwTU/DOfLlAJpjuFPJHaUxsJzQIg\nW8srARuXHhleUmmYXAYPQT4TZq+1arb3g14NdrfSPQA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7772", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7772` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAVlSr+j1sOJ6A1YCdA5DhRfEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0YTI5NjYzLWFlN2MtNDgyYS04NGY1LTgyOGZkOWViM2RkNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQyNzBjMmUtMjcw\nMS00YjMzLWE2MmYtODVhYWIyZmJhYTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdmLvgH64qYxusGXT516PkC72ct/6/hrt+GTxGb3MeneIelUH3ttChbZSYWhv\nvlkugEMfJMf/r6whzDfBVIMKeqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU90xlvqC+A1/NjaFiqd/YETRtk/EwHwYDVR0j\nBBgwFoAUsSKZxVv3ccLAM8s2NNTBPztFeTUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD1H3H2Gq6yZum7pL+/1/czzORqz+q6\n+TIrGguUcJaUNAIhALrisX2uDTHE2jPANoGYk4xT5izruc9TalaoH+brsk1L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQGkU51HiziGupa2o8amXKOVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGEyOTY2My1hZTdjLTQ4MmEtODRmNS04MjhmZDllYjNkZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATACNfpIL5K/nwYdcw5gB3jHtELat7CLmON/0Rh43deB03L\nDXJe7/9EkBY3NWKpfFPRgyjT+/Z6bKQx+r8wzHAeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsSKZxVv3ccLAM8s2NNTBPztF\neTUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPUUsXCvY1PYe3x3AKxBlpGfW0EsOnRsoMv/AmqzgPiQCICbU2/Q9PoQP\nUQ4vVsxz7IMv6AgwUgkT9dGrMPG4wpEx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQ/GFf74uvs6XC4PgjwAfdHdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQyNzBjMmUtMjcwMS00YjMzLWE2MmYtODVhYWIyZmJhYTBjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYWZiMzRjMi00NmU3\nLTQ5MzktODY1NC1lNmY1Y2RlNWIyOGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARw/vJSIeKzkhOrOf+6lrHiIenmO5z6rPEu5cC6U+q9MgCmzuA66mZKQPpwa/OM\nbxGIy0FFrp6FcFAncfBKBMXHo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3TGW+oL4DX82N\noWKp39gRNG2T8TAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEArpyLGMK0SmMHtN7ML1UPDkMequxM52zDhIqgDF/m+oEC\nIQC9AVpqPYZpYbckg2n+XPtxM/QVc5U0rgAdvkpSVxFyyw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7773", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7773` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISARuVKx29BkwGaVslwg8ZVH9YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1YjE3Y2I4LTkyODctNDQzZS1hNGY3LTI0ZjU3NGNkZTY5MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTgwOGY0ZDgtOWM3\nNC00MGI2LWI2ZGItMDFlNjUwZTUxMjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY9NRzFPOL/dnszkTVHi9DlyZIoZNC0DuGZ7SW7LqTIidcIVx5bbLF2XaStbi\naudTSrnlCQ28p3h/NkQ4y73ukKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+9GvSK+XioBAjlIkP1rDBFO7czwwHwYDVR0j\nBBgwFoAUrDHn3fZL6UweYdC+yATgNMyHOpYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBLVuN4y3PK+wV/d8wsY1Z8tKHpngeb7\n0alPXsQ85x+wAiEA5tFzOnIk7wBneJkkSE/ClEtVrlIizn5koFwsY+NR83o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYBNPFGEn6aQxR2L5//mTcWeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWIxN2NiOC05Mjg3LTQ0M2UtYTRmNy0yNGY1NzRjZGU2OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ03H60Ig2TeGCq6l0zekLTGqVWsHCblTd8aq9k/2Wb6rS/\nhhzNNZf8klJ+9rQiDqvBSxl7zOqzYMaplMBtKJbvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrDHn3fZL6UweYdC+yATgNMyH\nOpYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCP89yIJuQc0+ot+xTHSLCs+uYyASYOkLCi+QqhbarkoCIDbBXywRVwrM\nerAym/YNO3jGWr9ExeBm6LPy2TFeJfzY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAe25gXpwy3MXe1UBOd9vuHFhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTgwOGY0ZDgtOWM3NC00MGI2LWI2ZGItMDFlNjUwZTUxMjJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZGI3NzVhMC02OTIz\nLTQ0NjgtYWVhMi1mZmJjNzNkNWQ5NWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARiAKuJJuebjZ5zmJk7IEYYJc/Iq5Q+oksqqpd1SLtezbW8BSZxjr29E1NgjQnb\nKlX61IswAwKjtEiZ8zQ7Ohd+o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT70a9Ir5eKgECO\nUiQ/WsMEU7tzPDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAln0gFHa+zW6bCYdwMOedxzZpDiQihhzM0YdYt72JBOIC\nICbCm3qtnu/AMd8+oqZLAMSzaGRapzPY1wUB/OFP35sh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7774", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7774` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAYTLGrAaZtbuJkKgryzzelMnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlZTZhNTAwLThmYmItNDg5OS04NzBlLTBmNTVkNzFlODQ0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNjZmY4YzctMDdh\nMC00MDU5LThiNmYtYzcyNGEyZDFjODdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErwlkUfsYAdMdE6r+CaxWz251H6o1XFdiWdnYI+Z87LewsJNjg4IqfDaMBGC8\nIdNL1JOxPkXzCaLocTDfRSwJPqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURNnvJQnkXqUhEsDrrgQOT4tHQZ0wHwYDVR0j\nBBgwFoAUXzT7IPEnktB/YYnMO6sSP9g3GQcwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIHXfP4X6450v\nrjtblpShafeUpJkjztqPiyHG+bAQ86uCAiA86U4ScmVuvgvIIedR8fTjxcsks4/J\ns7fkU50ZTn0/yQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZuYtBwt564oC9c5NF2LtoxLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZWU2YTUwMC04ZmJiLTQ4OTktODcwZS0wZjU1ZDcxZTg0NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1GeQTpS7UcEIxOMRudYCVTxpeaAPfMRiaRGCb27kICAps\nWEV6pIo4DeFDYGjDKcnNtXmkYG7b0Af9s2jS1X2No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXzT7IPEnktB/YYnMO6sSP9g3\nGQcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL+1ENQFBwN47Fs8Q6qE7xQrxQR8vCEctFbjqc4Yaq4IAiEAikQwUN2w\nWIqtcnCchFlPYDNU0Sw6//phL1k4b6BAOU4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAX5cfhDtXHgXUMQUv3CGM+jqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNjZmY4YzctMDdhMC00MDU5LThiNmYtYzcyNGEyZDFjODdiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MjRmZTBmMS0yYmY3\nLTRkYjMtOTMyNC1kMjI1N2U2ODk1ZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQM7ka9MEIvkeHuSJlUPD9v9i9z8nwdlLEvpYratTHiCrsxK8UJB5cliWNwZext\nDOqdGlu/rulu0yv851DZyndDo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRE2e8lCeRepSES\nwOuuBA5Pi0dBnTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEAla+0QJCemDn0asljSkRk3bXpV34PLsedeaY+1nQicA0C\nIQC8fwqfQ61du3pPPpTCB0EPHsln7wfOJkLZmJNoK2QhWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7775", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7775` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAbrXTdvn6LLtenSVz9Od6CxaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxM2YzNDYyLWYxMTUtNDM0Zi05OWZmLTkxNmU4Njk1MDNmZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVlODRmNzAtOWFh\nNi00ZDkzLWI4ODYtNTQwMzdmOWZmYjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGRq2e8lsFuzVAjZ8CNjie3r5q58ZpOLm67AuJGtyzRDLno4fEmm39nX0lGd2\nbQS4o7JNFjaCHfsKAkSitLOaY6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUttSNALCtboCykplouU6SSmRSn1kwHwYDVR0j\nBBgwFoAUA+ygcKtaulrg04fQ6wTheDW4Fw8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANloiUi9fMMSkc6Co4JvCamSp0qv7X2TSpyTC4vigLKvAiEA6V7WkjsU\nqsHyWAPjT4uJAKJJphJLjyaKlfRJI67O/hw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAblOg/H5SeWxZ79tsgjVYCbMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTNmMzQ2Mi1mMTE1LTQzNGYtOTlmZi05MTZlODY5NTAzZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVfSFUv7aZqnel2LC5hsMAMeEWvxmbZmO51PBHnzzsGNbh\nnJaJipcR+HMW+ecGzCJIJbyd7xRh9/fqPvidEiudo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA+ygcKtaulrg04fQ6wTheDW4\nFw8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaaoXj9xyJtvXKCLOZCx+Sy/dG9j3lXmKpJfLSTzn/zECIB4TOx3z2VJC\niertQD4IIeegCoeyzrgb3MR8kXQeeoT2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfY15LFCzZ8cvcr3Huh923NFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVlODRmNzAtOWFhNi00ZDkzLWI4ODYtNTQwMzdmOWZmYjMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxOWU3NjY2OS1kMDI4\nLTQ1NDctOWU3My00MTUyNDZkYzQ3ZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATTJgAG8CkYw3zm+AYryGRCSds7jJzs6dlCtu3Gx50c7KeAK5Ybh5iZVeWioIyz\nV8Vy0hfyW0MdcCToiGiy3w/ko3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS21I0AsK1ugLKS\nmWi5TpJKZFKfWTAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBcfs8PDrcYfCvYdyzSVRSqJBLLc6e2vyFuPDssplQYNQIh\nALmTvKo47GhMR8EK5QJrFSyjIGElknm9w6ukCYOcNr0z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7776", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7776` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISARsfIfWWExxlAE4wlRFbZiF+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYTA0ZjRhLWE5NDYtNGEyNi05YzVmLWFlYWQ4ZDA5ZjUyMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODg0ZTdiMjEtZDg0\nMy00YzUyLTk4NmUtYWJhYTcyNzhlMjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpZnqXtuG8ZMDI9QtYoGeP9YA1zu7CT6zsVEQQ9YJsZdnBFBuh7OKLfa1Ynnl\nx4j9cR8yq0s3/AS5av74h6R8f6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8oceqGXmxE+0cuVtHY8pfblpDXAwHwYDVR0j\nBBgwFoAUmw3s+0fBrIiaLUtTPeTWAeiVhKMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAK5hHE/n/O0wcgVfS+pY3THAq0GYQ+ylzOEdTjqiNIWvAiEA+WrJU9np\nqeTw0TM5jNWeKcbEvVzDoMRqh/b1c4EjHmg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ5YPML6TNwtfuNz9zfqAnBOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmEwNGY0YS1hOTQ2LTRhMjYtOWM1Zi1hZWFkOGQwOWY1MjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZtyHT2meAo266Qz1Qv9HUfs7iEB8daYgOrl1PGjM2WIb/\nV4i9LQHvL7HMqTvjLUxb745qOq7ANFzU6FM/ZduGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmw3s+0fBrIiaLUtTPeTWAeiV\nhKMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIFSUQ9pDRarso8GuW890wb4MdjKzbw9f4xBAjllF/OfAiEAi71GN5I8\nAaVTkZOa1m2j/xUJ6LPx0sjzPqie2m4X0Y4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAfbObo9u37n1AGkbItxj2HmMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODg0ZTdiMjEtZDg0My00YzUyLTk4NmUtYWJhYTcyNzhlMjg5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMTFhY2YwOC01OGJh\nLTQ1NTQtODNlYi1hZTJlMzQwZDMxMGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATzta/GT8ePkIWaO8nFCdch51uMDh5afsjzK9n8cIGU6jEauQKfU3pwM44C2CXF\nm2VaNxzzdjwZAIiz4qdiLibto3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyhx6oZebET7Ry\n5W0djyl9uWkNcDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNJADBGAiEA3CKdHwOMzpzGJZqeL40sVD5fcHEr0m9q0K0J2+bUnIwC\nIQDobTdDGkaKA2el/Gnsk2JDo/Y/PTsukXXceyAAT5vW/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7777", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7777` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAbtmWv53lPfMoeNTZ5i78EPdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmNDJiNjVhLTExNTEtNGYxZC1hMTQ2LWI3YzAwNmZiNjUyNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ1NGZmMDYtNjY3\nMC00N2I4LTkxMTktOTQyZDc1MDliNzUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1nH0X5A9ZcWzixZKiMuTmmnacHuVJB8ZdRfy7im83oxONdqM7zPzcLZpFqwj\naN/feyV6INQUto++Pl76cuWuX6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcy8Or3diqRWHzlIeFYTFksUaJeQwHwYDVR0j\nBBgwFoAUKs18I+gwoXcd0KvqIsDKVecq+ykwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCNzlC8QRFebtHDU3sLX17EpZOPisd9x5hTDt0oRpI/2AIgWdLabnaS\njuNEcirf8lqw2bRkpi8j1PwbbeuAPsmrWY4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASdsLyDE3M7cJAZfPsOwr3aYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjQyYjY1YS0xMTUxLTRmMWQtYTE0Ni1iN2MwMDZmYjY1MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXSK0nOmAIv2rK+Fgn75c5GboRgJvcrRkPuO5jr7OXE/cc\nfzN10+BQtIiMaBGETLDT5+Ius0Y01dcKE4PkUiMEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKs18I+gwoXcd0KvqIsDKVecq\n+ykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAILaF8MiFAjy/O06DUN/N2/qq5OhWWxAgR7pEo+qSZrhAiBze28Q6K07\n5aJneSmDVwQmU/JR9VphlLjdv1kKvPfAxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUhoBVpfsFphlHjMB+Khzkn7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ1NGZmMDYtNjY3MC00N2I4LTkxMTktOTQyZDc1MDliNzUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMzk0ZGVlMi1jM2Ez\nLTRmMGQtYjc0Mi0zZDI5ODk2OWUwNTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQpUMERpr+pWzyUsDgOQpjYIDU7opSGXnD1b+OBFkoLKHtjed62Cew5pE8pCSqf\ne2xA8EppEWNsEmMl21woDbc4o3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzLw6vd2KpFYfO\nUh4VhMWSxRol5DAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiBquF6NeOGgK6WWuswhDEbjZI0TVZvElNiEOKwa+b9hJQIh\nAK43j2lYquGwbA0tJu6zKCgUX5y4vezMAxh1e9HrFTAS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7778", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7778` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAYCDsFyDZa0okIyxZF8AqsTTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlZTc2ZTEyLTMzMjgtNDkwMC05YjNkLWQ0OTU1Mjk0MjhhOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQwMzRlZjMtYWE0\nMy00ODZkLWIxMDEtZjc4OTBhOTYwMWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzGflm6/TS43290tmuJCCNSLNxcQHsydYcRiDuImGs+sXACE2yRWuovIuenyb\n2Ydcoui0/aR+C1ZRt8pwZXLI/qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylzU9+eBAfuTswiAg/1TAExjkxYwHwYDVR0j\nBBgwFoAUuGg9RoYpAE1kqV3CcSIEeGfzveswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIEM+32O5W/59mh53xZVWmZRnt7LPiIlj/WxRym8L\nWCWHAiEAv7yogRlQggfBlxNndLlSo5+4ziJgffcQAKXScOM/hW8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ8yQUJ5q6Cb88RHKomXGNLtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZWU3NmUxMi0zMzI4LTQ5MDAtOWIzZC1kNDk1NTI5NDI4YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9mGcnzLcMMsc4h8Z7h3ycxJIKJKVRw7Xz6KDP6hCKkIkB\ny7lp27sZcBA9r+t7r4LsBytNl2o4eVg5Vv8jYH+do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuGg9RoYpAE1kqV3CcSIEeGfz\nveswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOWyTcJbtoWK4yokTaIVN60nlNZiHjCmkp+N1tFCKMpICIEAVK6qv+Pic\nvQnH4c89h9K5GnC8WMjKGqLH+3vECjQv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAabJnbEsYhDv8+jrVYN1ntrNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQwMzRlZjMtYWE0My00ODZkLWIxMDEtZjc4OTBhOTYwMWMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNzBmNTlmZC1iMjE3\nLTQyMzktYmU3Zi1jNTYxMmYwMDU5NDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQfRSXVNuFOol71LFBKpnwoQG5WAqyOKMLmFXeXRkVKin7665yOje6yDBhF8inO\n8azDdhxbaxD6xS9VnmzdWbVio3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKXNT354EB+5Oz\nCICD/VMATGOTFjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiBldL4imRH168pxuwJZPuSXJqq7PS8ei+1rGWB5S+NLAAIg\nQHkr2EGDXa1v6dE1e3GGyr6aB0euTYEeKbrJHcU6G3E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7779", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7779` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAccbvDWR5TWDUWZuu2mrGUQ+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4YmI3MzBkLTczZGYtNDNiZS1iNDRmLWIwYzdmY2MwMDlhODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTVkNmI1MzYtNmU1\nNi00ZTk1LTk4ZDMtMjlmYzgyODM0NTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhhEEkoZeTV+zrAhp1DicNs+WUpkDsxQRknnp/6NA9Dm2Gu1N6xjHdLqBB6cd\nQY3DxG3PI5W9r9iZewFkEEG4TaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYFeh3xIVm8+gq5d5ucy3b6+nBuswHwYDVR0j\nBBgwFoAUdmie4btpyMaXwEFE/AqugMyGfRwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIC5lOA1Rh6WcGbfIxgRr0K8TYvsu5Fux7xkFU/R+\nrW/qAiEAkNxz2WDZH9h134o8AJmr9wHrB1Q3FqZ5xtLyAAVtGXk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZUQ2AU+D68g6aSiZ7hkkhhaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGJiNzMwZC03M2RmLTQzYmUtYjQ0Zi1iMGM3ZmNjMDA5YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtrb0LAnl7OfKbSturU3SUiOKguWTNvkL4Uc1Rkqxi9QxY\nlkEkV4ChwcGzdDsd7IxIa8m1ZjRDU9klxNeGVhkCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdmie4btpyMaXwEFE/AqugMyG\nfRwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANw3zh0zUN65lm7BfIaYL5AlSgRmJCgXyvN0mWLh/LEhAiBxKMcEgNsb\n9PM35OM2RtHiT6MYqlBcsIZ7aiuA85O2+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISATfA++Q63Hk+FkZ7I/VaDYhxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTVkNmI1MzYtNmU1Ni00ZTk1LTk4ZDMtMjlmYzgyODM0NTg0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiZDMzODg4NS01Mjg4\nLTQyZTUtYjgzOS04MTliYzcxNjQ3NGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAShQ89L7fXPtl6gjG4ka9xgMRgLs99flmvI+6I9yonNxZ3PsbnTqhJ7M65vbBp1\n9IeA8dwkjgVFt14YLd02ScFgo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRgV6HfEhWbz6Cr\nl3m5zLdvr6cG6zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAPkUEy8bnTltsFcY2pqd+cP6B2KriCrF2rRdGZg1vmowIg\nMq7nSL2KGR5Ao504SZFS7NCTpWLe3zkOIrjLq6J6EGc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7780", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7780` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAVxItXl+te46wfquR9Rx/tjeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzN2U5YWM3LWUyYWEtNGJkYi05MGQ4LWM4Y2IwZTFiYmZkOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2UxMzg5ZWMtZTdm\nZi00N2YzLWE0NGQtMWM2M2UzNDg5OTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG1XRfUmULDwywdCP9kyERQ0NkfdyXFmOkVVOYyWwk0G9E/xnWKQHv3L08SPX\nmA39mr6F/9HpJrBRI8AAL2FIQaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqMTiCKDVHRrbXZgHl9o2PrwHu3wwHwYDVR0j\nBBgwFoAU427Vibd0SqEnVc9h41IjD5L3DbIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCBjT/QY6flzv2PeIz3COGRRGtLbbqT1gUj71f6oQpFKAIh\nAIM3D0DW5ZliuW9wg+1JNcn1UvAvwacufdHYT1QJQgbr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASCdbFCpWSUTTpyiDrjcw8R3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzdlOWFjNy1lMmFhLTRiZGItOTBkOC1jOGNiMGUxYmJmZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/UcKla2SdrfIFIXeWOh37jNGzRIpeg9mbi62qCPg/SIgr\nVlGinei7HIEmxDtQKtTktVzqZUarSiuGAnnPfgW7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU427Vibd0SqEnVc9h41IjD5L3\nDbIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPLixDaoBL0GrEX90sV9MdmooP+xrpTaBrriswbXXWgYCIDB9LdpKCsn3\nn7wft3OaqNN74BsMsbw2VRFcjrrUjDAu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAZbcIqj5/4XGwHhxAn+lieX2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2UxMzg5ZWMtZTdmZi00N2YzLWE0NGQtMWM2M2UzNDg5OTc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYmE4ZTI4Yy01ZGE5\nLTQ5YzAtOGRkMi1lNDdmMTdlMWQzYTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASfp759Nu5XYdcX+JVz0Lywg39R9kK4FbMlfe1j9GZqGGdh9FY+ONZrskANKzB+\n5wXk/HmWuhwiHmhl0kdUrE8Mo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSoxOIIoNUdGttd\nmAeX2jY+vAe7fDAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAYeNmqmoptDGWoWX3J5p8wqclM6nyoALyiFWsmkrT8kQIg\nc8Mwbw6Eks4EyREZYpE0g1bB+t3efLpV3U9XfSEAQZc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7781", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7781` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAcT1SZOL4kYaZ55C8I+2AMXpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4NjZjNjc4LThhZjAtNDAwOC04ZmMzLTQyZDgxNjRmOTQ5ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhjNWEyYzktYjRh\nYi00ZWY0LTk5NzgtZTQ5YmRjZTE3NWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUWo/7Ua7PWuyqooQCchJTJ1crHCF613lIRKBHlmeaAYGTXpvwMMNv+OotaL4\nJyuTs1MhjmD/MCpUA/bhgcHcW6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiTZc8vcDEueZjutIJeTswTkPLf8wHwYDVR0j\nBBgwFoAUymaSuXVGiUVl3h2Fc8tJwaqXUHMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCcCoyzvNLRssRP+npuAc9WKURpeRay\ncTzdGhoGGc8m8gIgRkpKn3Xa+581n4XnyWfSeFZwMp3AvKUrDbj16XMh/zI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfW7ZeM+blFhr4GczBJLq50hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODY2YzY3OC04YWYwLTQwMDgtOGZjMy00MmQ4MTY0Zjk0OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATS+sVB1/buH/+SwS3tzTjjTPXBULL4TNpasBdMQe356lUY\ncV7cZyHyG72VwN3XzPWzgx4YoHuYFoLG4nTVyuuao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUymaSuXVGiUVl3h2Fc8tJwaqX\nUHMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMa/fq98hFJFy5slrjzYz5qXM9MnKdnhqV7kYSXEv258AiEAh8YFzD6r\ngUmcGWp58xu96dK0IeaSX+vCvqwTSaKWljE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARMSvruZ4VgbMyy38IyUnR0wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhjNWEyYzktYjRhYi00ZWY0LTk5NzgtZTQ5YmRjZTE3NWJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiZWUwYTVkMi1jMzU4\nLTQzMzMtYmY3Ny0xNTQ2MjVlYTg4MmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ/gShNaODirvwnKE8S3aMG4vj5K7gyyRPoXNSWbczADn6dbz3JxqV+sDqa6c26\nHjaS7nwgLZ3dI42MP8jnpYnXo3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSJNlzy9wMS55mO\n60gl5OzBOQ8t/zAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNIADBFAiEAqZMLZRpelR2I9pd2ViRnFbNcTXacnCQu9WiTvoweOcAC\nIFBQB/XwcwGDeqpKgxcpRTKfqnehv9sv3qPK2DDsqPgM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7782", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7782` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAdmwqbGYNqbI8wwtBj56o1V5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwNjU5ZDg0LTUxZWYtNDUwNC1hYmQ2LTdlNTYwNWQ4MjdkOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQxYzUzZmMtNjcz\nYi00N2Y3LTliYTAtOWZlZDNmYTYxMzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERVWAlaD1E32l7E0K76pKvoShx3YCVKdVV6t6VO7c8wIEP3qtvBsK5dnTwjQc\nIxmplQHVaLgxsfXWx3fwgKtXYqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxreAA6JKrbVU9ILvKKtDJyLByp4wHwYDVR0j\nBBgwFoAU3vnCXwYWVyzJwVm5Nxs5pjuHNIswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD3IWU/1h/io7SaJSGLoXTZBQtvK2l/\nfMspqrej6xvEUwIhAK7Z1ujT7sAW9MUpvkvxQ2wW5ZhIhiTHNuR3Y82GGRGI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaoAWllRi+OKpAq34MN7XkZaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDY1OWQ4NC01MWVmLTQ1MDQtYWJkNi03ZTU2MDVkODI3ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaCGMgKwzDJ5aCfYO1LGNehVUPWzuwVpNkDOntYAs4LvKX\nRZ948AEnY7lXlFoUKvHKMtzVVoqtxwbVjdnWpnbfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3vnCXwYWVyzJwVm5Nxs5pjuH\nNIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJXMtuHfS4iKo3rlG+spv64HL10QUWUD/KMymYG1cxecCIQD0b4GAbDGh\n3UIrZOFBnPwpyrZdx0Ralt/rD+mExTstgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfPpiitSOgyJ9rR55UueuIVTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQxYzUzZmMtNjczYi00N2Y3LTliYTAtOWZlZDNmYTYxMzEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMzg2MDMwMi0xNjky\nLTQ0ZGQtYjFhYi03NTU4Y2Y4MDRmMDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ0r3yQ66dmGFcn18oIBBjJWOhtjI4ZUgAriQQauG8z3CxfyBQc4o5TbUMm0pXO\nOhe5WQwGcxOV5tqXlbO6lvego3cwdTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTGt4ADokqttVT0\ngu8oq0MnIsHKnjAfBgNVHREEGDAWgg50ZXN0LmxvY2FsaG9zdIcEAQEBATAKBggq\nhkjOPQQDAgNHADBEAiAWpDLWK0phx5hv5XuOSuSd18nt+k9ocZE+yIrBQXBf0QIg\nR1Ippe5Vcg/1tQ25AxU/0wjlvp7CoJTu9dUMBr4Y6YY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7783", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7783` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAawYPTvxrg7wIP50okYnZGBaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0NTc4MjhlLTZmNTYtNDM5ZS1iYTViLWZiZmRlYzI3YjkyMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFkYmFjN2ItODBk\nOS00NGU4LWEwOWEtMzA2Y2FiMDBkNzZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErdoUEnF3DuUcfMKIF2ELfXR8WQZu3wnihyEW3MxUzX/Iq4RTnC6oXbgAB4f3\num6KHWR/AYZgQN5s6b3fpB0Ke6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHVc8nm23rO06DEEwJHP3bANrkTMMB8GA1UdIwQY\nMBaAFNnlpkbiVuo1HYla2y+5Zg1RomcTMAoGCCqGSM49BAMCA0kAMEYCIQDkhmoQ\nhzSKJpR9ST0NStylpkspWuCRHoVhwlkDJEL/NQIhAJfNp/rlY+NryJXhe9DtPhJY\nxUdIj+jzXGKUcnygzCaH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT7t67Jku0JYW6GoRspgiLSeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDU3ODI4ZS02ZjU2LTQzOWUtYmE1Yi1mYmZkZWMyN2I5MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYU32SFvvxzIp4umH7Z+E7kGL6YSw45Z/qoI8Q0kDqvTAG\nKunl6QTnvdwTQfgo+YRE9uuILfdzUXHn5SncppoVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2eWmRuJW6jUdiVrbL7lmDVGi\nZxMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOpa87OHqCX6Wr7CU/KVLdlo+AV5de16zotbe109gHmYAiBa3pTKU5Er\n0PLyRHB1xEU8QqPO7bUX+ChkpxNDra3ZMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAUTEhMMhaIx4jRdWPGPfS5/ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFkYmFjN2ItODBkOS00NGU4LWEwOWEtMzA2Y2FiMDBkNzZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNWQyNDBkOS1lOTM1\nLTQ4MGQtOTRmYS0wZWJlMDEyOTUxOGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASrMFgelS1HoOZEI4q6ud3a4LWJkJXgrEaJO4FzwobSIxut2ooj+GXaqEOH1X6+\nb/B0eVYp56ajjt6ib+Y3fIT9o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR1XPJ5tt6ztOgx\nBMCRz92wDa5EzDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAIjOtRHAviqqlIahXbeyXqSQHYXi64gJ9l15N99yvjBjAiEAh6mn\nOiJ1w+8FTE5DbcUapilnzKwFhPbidP4aS6CV8BE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7784", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7784` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbA8eLwF9u3ca+R8ML2ed64pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiNDhmZGQ2LWViMjEtNDM0MC1iMGIwLTdhYTU4Nzc5YWEyNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY1MDdmMWEtYmFj\nNy00ZGQ0LThkOWYtYmYzMGQ2M2QwYjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV6xZqQhDe21gNlXg7AFNR6mgXUOy4SRZDH6KJUfZw0LrdPpo2NZNcPUH7s33\njciuTTHMzUPjWBjFYYNOzXSG/6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC5wVBE76NgMgKyaoRzFY/O/sIl8MB8GA1UdIwQY\nMBaAFD69kdJ+Rp75GysJJkKjfeZ5YwzAMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA9Yo0KQRR+OLlc4/TpqJaAIIzN3A3CPtq\nKKHBs9m+8cYCIGo2ESFLGW0l6wrW/WuiIom0HZi5+KnEJ4GPjI3vzRog\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWy7zc6Il7DzKbN50uL984gfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjQ4ZmRkNi1lYjIxLTQzNDAtYjBiMC03YWE1ODc3OWFhMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZQdncl8FTFohtXNw1f8kiNMc362muppQwE3UHTGHt/t3f\nU9dXzQLocwkxqqazD5XJmS8Rd96DhO0szAoHnTRQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPr2R0n5GnvkbKwkmQqN95nlj\nDMAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOYAx8Gyw69aeu4Vje/jhKNdaCx6xD/VboT8tdTcNcs3AiEAgpFE2wZD\nYaafGdpGwjMzT0bMw4ji5PxOPtDUWo0GU/8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAReqEZpCGrK5L2+NOozE14ZEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY1MDdmMWEtYmFjNy00ZGQ0LThkOWYtYmYzMGQ2M2QwYjQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0NjViZGM2Yi0wNDU3\nLTQ4MzMtOTMxOC1kODBhNzJkYWE0OTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATF5NWuchzuPK7wSTy4VzLID7Cl65uC1nMDMKomzBch6T/wgOyZfB5Gs0EzRTzj\nWpMKPUjQB6qjYXGwCxhRjUFao3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQucFQRO+jYDICs\nmqEcxWPzv7CJfDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgWrFicPMZo8t6yf4hYGLRyxIcxLypiRBAT/J8JSrYVH0CIQDQfmVU\nSZ6ioCr3Kt2tmZopLRAUq18orlBDZXeSND9mKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7785", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7785` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfOmD4cl7N37Jw9h4+0Ao/HlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkMmRjY2ZiLWE0MDAtNDNmZS1hNGQ5LWM2OTI5YzU4ZWZhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU1Nzg3MmEtMWU3\nNy00NjYyLWJhYTYtYjM1NGVmNTdjMmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnTUPltlRiVRkpLSGPggBdqHOiK7HmFG+4HWM3cUDIohTlAPmulidHcwI2UOO\nj3aVP3qD8jYdX6RKpKLqIT7HC6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHKD0e1AQdVgLunknppveCSeVdMmMB8GA1UdIwQY\nMBaAFPB5JRhmpqe7t7+sMmn3Mae6D0TtMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA9IMc20RiiR7VvLlPJKTTza90N4s1nWXJ4\n8bxJrCIn+AIhALT6Kxbms102MrSyS7CfhriCL66PhhK0pIFf+JNy+jDf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdqmpGgUFNNe6HnD8c3FCy/3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDJkY2NmYi1hNDAwLTQzZmUtYTRkOS1jNjkyOWM1OGVmYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsxe6K2ngnYiwHRjeKh0QJCCvFjeKU7IsnXJDR06Z7lAM0\nZosZ6y/AEGSXPKNo83ZetrPi3JR96CGGhYNiRMR9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8HklGGamp7u3v6wyafcxp7oP\nRO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgefmhc8FKj4keSzFvHVW+/117Nq8PqAAewCk1/AU/Y4kCIQCPb8d6x4Fu\n6sD1+G8JZxRC8BiobJmhumHvimbipC2Msg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAbBeHN+M3bdRyHWV/HEJfYwRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU1Nzg3MmEtMWU3Ny00NjYyLWJhYTYtYjM1NGVmNTdjMmVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMDhlZDg4OS00MjU5\nLTQ2NWQtOThmNS0zOWQ3OWI2OTUzYzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAStNFi9GOaO4+rFOZNxn6doFhR/au+hNWwmQLN2zdnnREl7rhO93C3CKnlNUC//\nbQg4ftAOB8aqlWalWNrmNM/+o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRyg9HtQEHVYC7p\n5J6ab3gknlXTJjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAO74YCNcQ1kZQ2JDWSa4sxfbNciEtnr4NgWuavweZCitAiADLbQa\ncsb02s//st9fhAzn9AtmxiJWQNb9BSJ/H+LZjA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7786", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7786` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAd4bV4miKz7MKOKofjQSCtj8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0OGY0ZDIxLWJhOWYtNGVjZS05NmFjLTg1ODlhNjU2ODU3MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZmNGM3OGQtNDdj\nYi00ODVlLTljYTItNTc5NDBmMjUxOGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE95VWdvyMzAZnVrQAentjCfibTOU9xnyT0lH0suabKQ8p8opG4p51BArjYnrs\n1c+JBsvhXNqUKr6Lcy9YXmtvvKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRNxMHI7sUy0xa+xcqkGpG9xlJ0DTAfBgNVHSME\nGDAWgBRKM5BZA2iY01m5cIt6LkkrME7WKDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBozXkvsMBvvKfag5vh6+/H0CrLiEnPN\nGom084M53V+HAiAiI5elmevjwA3zUk+k3mZgSnsjdyyAF7VzSdHwfn0IQg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWQ/y0UJBrU+qxJcVpMoe2w+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDhmNGQyMS1iYTlmLTRlY2UtOTZhYy04NTg5YTY1Njg1NzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrXSVsPbGICAdQVm79uQlPm/DfkIb89lY6VZfQ0geP8w1Y\nWRr9Lw2qnfQ0+9g6iq6XFFB5rZI31tX51rUjU9ogo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSjOQWQNomNNZuXCLei5JKzBO\n1igwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN3XmJsMkqQJFboysRO6XnTe6yqAGHkXHmgxgpoxIGgZAiAM9jYXxSux\nhR8m7gwPORQnAxvNcGLgalUyUY4jAoDoBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAY5mmzuixDJX/9CDlO/saUKKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZmNGM3OGQtNDdjYi00ODVlLTljYTItNTc5NDBmMjUxOGY4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2N2FkN2ZlMy1kNmQx\nLTQzZDQtOGQ3Yi01NDk4ZjNlMDNhYjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3n0qk75g7AkyRBujuMUwlxYaj0w0FAvAxaqTwzuP8gmxlIq9HamC7DGc/tVbN\nS7J0SxMPqAxpsJr63XQ8fDGNo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNxMHI7sUy0xa+\nxcqkGpG9xlJ0DTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIhAPP5NYE1aBvRaTNRgE9IUxf5AoO54p3WBJ17rIzR6Dm4Ah8cwk50\nN9rxC/YEuLudMEDCcRwVjZ3elmn589BQn6mE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7787", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7787` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARGbW7CjrLRLSzf3abyN396jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhODBkNTBjLWI1ZDgtNDBmYi05OGRmLTgxZTFlMTYwYzNjYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTUzZGUyOTAtYTc5\nOS00YjU2LWE1NjQtZTcxNWUzZjI3ZDQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0EkgJD1IHk67+Ogelrnv5xGeqtx/5Nc2wWSH4Fj+NacWUZ5c49nir6/a6wDD\nJGvHqLpa4oRs8q3VNepgtAhiq6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBdR2DWTS2g/ErjO8hqkQGm6MZKowHwYDVR0j\nBBgwFoAUTapPLCPYvBMPE8ee6hZDouh6N0AwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA+Nd2EUvip/V1\nIpCpsyRcIvG8/FEGpiElvnP2Mqm8PgoCIANfIOTsWmFCh/xp5F88pl9hiXDjIc7N\nBQYdNWET00jk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAacrk9EAxLUcWU0QOzZBmLSlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTgwZDUwYy1iNWQ4LTQwZmItOThkZi04MWUxZTE2MGMzY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHmXC8HC5wB3nOyp2dOMeiEMQ6YHdu85AqfQQWB/1e/zV+\naU6mc4TgiN1f4cIjhEsP+xWPpjcBnNy+GUYYsR1bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTapPLCPYvBMPE8ee6hZDouh6\nN0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAzCd72zCcl9dx110YC6b3JhXPPkd+R1asYUZiOcXXrECIQDPlAUxQCpR\nRLYiBAEOGwIKJwuuKYWhJK7nfW1vfo+Tpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAYf9v7jqfSr4oraZW/zhXVrhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTUzZGUyOTAtYTc5OS00YjU2LWE1NjQtZTcxNWUzZjI3ZDQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YzlkM2IzYS1lODNm\nLTRiZWQtOWVjOS02NDBlOTFjZWJhY2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARfkKkT8paFEoeDOqWnVQMC0UfMu/0aIaa6FbFQ2M6RY0pEgr8RYJui+7V/rd9O\naQzOniA/tuE6n8m4vd8ZBkfuo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQF1HYNZNLaD8Su\nM7yGqRAaboxkqjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAPL9Z2WowtwawqTvceQ+ATYCBJ6mpk11OBaJHIDk0BBqAiEAtCTG\nHsFipFa6HrntqTXEPGAbrHbEbeZSRKkkBC2hHEs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7788", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7788` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZrgP4+m1tGQ3/zdYjHom5IRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiN2NjYTM4LWRlNTQtNDIxYS1iOTQ1LWMzNGQ3NGI4MDI3ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA5YjYyYzEtY2M0\nYS00NDk3LTk4YWYtOGRjNGM3YjZiZGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE+SVNKhy9DLIIjumIOVyUlBxMTJLmgl3FsLUWVHdD+EgGErkvgXS50MbyF0t\n8aMv1yHyy0NvfRrkAp7d1SfoKqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm48x3I2V/gwBc5Tsrk9WmyphtG4wHwYDVR0j\nBBgwFoAUq4a4jq3TIZZJEFzaMvUHbBWjSO0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAVRjeI0u2CzZLH\nNKE+pOzcSvLAJzV+MfpMOppPYj1eBgIhANhAznQ8VJa28KtmWgNYgHwmZKT2Svxl\nKifoi2bP3a6w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQsFXQEkg93hWug+DAS/BQtEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjdjY2EzOC1kZTU0LTQyMWEtYjk0NS1jMzRkNzRiODAyN2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMd7AfWZsIcXi/i0cTTX7x1D9fWxhb6f1O3H9n5UFh6rlT\nEVz3q7eF2YA/y9OKO7+gLYK6Wo44+ABWnpv3PzvBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq4a4jq3TIZZJEFzaMvUHbBWj\nSO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALPzjS4iTJUzZAbm2RNj1L9IxZckb8QNAGPTZYQuc2lGAiEAofvsqTf2\nMHhLSPEWdgnwhzsnt85iDIUH920fPjMM2v8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAYyrr0L3m6+eFY011uh+ZMuqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA5YjYyYzEtY2M0YS00NDk3LTk4YWYtOGRjNGM3YjZiZGU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZTA0NjczOC1iYTFm\nLTQ0ZjYtOThjOS04M2FhODliYjBiOTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATVmU1WxlBFPPlPOt1m/Gx+xs/jHd6315eyAkJNXjtiPpyvN+btik1EP4E3C4hV\ndcMBDWknNqvUvq1TF9bEq9mho3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSbjzHcjZX+DAFz\nlOyuT1abKmG0bjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgKJU4nq+oYAanwLTTwtwiRRXbeS9JNOGm5QQGl9OMe6gCICNO3daq\nMBECETVvpfgA/pM5/k0Vf4wnToHkxtNq6DA+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7789", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7789` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAbLksXgucLqBx09Ra16aNP0XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyOGJiODgxLTJmODMtNDY5Ni1hNmEyLTI2NjNjMGE4MGEyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NkNThiYWItZWQ5\nZS00YjY1LTkwMDItNGFmMzFlYTdlZGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESHaDJdIqUWIhHYgW2aCTGjH+O3O+ugVW2/W+/doltd/vbt890k9ADTsrXQ+V\nZ3F4C3b/hxuWHiZ8E2IqABtifaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULW5uPFB4UepPDUgfkTh5l9YwaNwwHwYDVR0j\nBBgwFoAUxqJcUAAUwNnOBEEs0KBHYeTfrl0wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBN9nRdtHMtBSxjv2+Ajuuz\no41FLyq8Epq6zD0A62CcswIgb/bHgBB4053l0CqqFy0DUeuq01NYS9RCYpcK84Fu\njXc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASKi0X/I+JX0LaLSzscjTXV+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMjhiYjg4MS0yZjgzLTQ2OTYtYTZhMi0yNjYzYzBhODBhMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHCosMm8M3+Eofj3nCTUH6NL7aAdzdeYZGGQFnw8Rv+m6V\n/l3kNznGhLOfTjlKEDDzkupIEmyHiLrJmxw9x26po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxqJcUAAUwNnOBEEs0KBHYeTf\nrl0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFJpuYPQoju4e4oj0p5iR5ngKqyMz2OvyRmib1G1OzhMCIQDA3jfp94xG\nVAj1y1hMJoTkiZB9dY71XZwYN4qOIGp0PQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISARJEcSzGS/B81XZEopqfOf/6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NkNThiYWItZWQ5ZS00YjY1LTkwMDItNGFmMzFlYTdlZGU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYzdmNTY0MS1iMjBi\nLTQ5ODktYmMxMS1hN2MxZWQ4Nzg3MGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASIUkiIFL2d0RuAgKoipQ633pnan2a16qWSghxdRBZ7DcgiZpWoRabZNNm96fSI\n3PQDw0jf98Wb/qNCz0urT6+mo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQtbm48UHhR6k8N\nSB+ROHmX1jBo3DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAI2G1SRpnJQsSPfjIH+qbnSVmXok+BRR//Vwl0Ad1/PAAiEAjfCo\n3sHq6x9q3sjBpv0sA7mlXkz/+PwVZxetdCcIXPU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7790", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7790` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAc5KuB9BDQjEMz6qJY1kIUNnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmODk5M2JhLWExNzItNDZkZS1iZWJkLTY1YzZjYjQ1NDk5OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRhZDJiMzktMWZi\nMi00MWYwLWIwODUtOTA2YTM5OWI2OWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+CPZ9XHm6Lpjv1KkLktoV/YlQBT5Hr5Rezk4Uw6GNBaGvG+BPVUIud5b6+QZ\n+3oFN/zdsuckfRRt3Z3RTjcfnaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh5Jq28oo9PrbKpIb3niUKLPIUoAwHwYDVR0j\nBBgwFoAUmBm6ASdEU2g2O21Hx5SLBfclpBgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAxLFA\n7Z3+iM8Du+M0zGqvvb5oxd3JC+jiyepVhX3Z9JMCIQDw9IdCQ3zLCqh2oF8SDc4a\n9j7lHpFKqNehTaYVOj7nAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQi9NUb2c2Rg4x6TAjEv5jfPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjg5OTNiYS1hMTcyLTQ2ZGUtYmViZC02NWM2Y2I0NTQ5OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjJ5h+dyIoqBv57MzoDeBfWyhVH9PT7gaOOV3uVeLQuro0\naO3bdI5RxBQmboZ1UHtr0nt+yh1+0OwWAikL+Ycqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmBm6ASdEU2g2O21Hx5SLBfcl\npBgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKAmsJD8ofMQ9FpDhZKyGQzkk4uMe6l/cOH8FKTRsVo4AiBUeOLIOSlc\nlQ//PsN6xu08r/dWzzf49KeKZMe3VfckCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAekpF1T5Ddr3SEb5uWZskpkVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRhZDJiMzktMWZiMi00MWYwLWIwODUtOTA2YTM5OWI2OWExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OWY4OWFjNC04NmEy\nLTQzNDItODgwZS0zYWI1NDJmZDBlNWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR8lsNkiS47V9Rs9SlR1PaZ5dpFwVpoSL43K3byo34/sw26hWhhhjW6qZ0E1Rm0\nm0PRarrjB0uv+2EWElCDW43no3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSHkmrbyij0+tsq\nkhveeJQos8hSgDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgRapkb8cYKqpkLMw4FQ+87BG5rRX+93HS346riEzQ/a0CIGDgEShE\nRrO/qRwbqDLVYdcehWTDnt5rgmcRAR37mgYu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7791", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7791` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISARCO/pt6WgSotVOKrmTv0ApiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiOGM5N2ZkLWJhZDQtNDYyMC1hNGQ4LTM3ZWIyOTI0YmIyMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVjMWY3M2EtMmNh\nOS00MTRkLTlhNzEtN2VjZjkyYThhNzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHHBsLkKKZ8ST1d7SiAF2qT1afv6Lxrv6UhJ1iHUFYJo9iT0cqWeM8kj11s9M\n4aSHLOWj3mZx3+00AJgmis3RkKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHYio1gKedvYvFxd1KzEShSWkSnMwHwYDVR0j\nBBgwFoAU2JCQ+IG9y2qp945uDlNCYvNlSU4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAy7ac\nKmj4d6IVTpbUjjL9rKWjLm23sIZRobs+BtKR7u8CIFcj+qTww7m13kXrVHlXSdq1\n1tKULm0myJig4ArPN0wN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARXRUaqUyg3Vc3lVqZ5t0cVvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjhjOTdmZC1iYWQ0LTQ2MjAtYTRkOC0zN2ViMjkyNGJiMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDeJYciyUQxniW78J4q3KVBfH4gy8GlP2PJ20dcKxWxYKa\ncGJHHNL8S4X29R78fRlnPzMmFl4VP8YGHl8WTVk9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2JCQ+IG9y2qp945uDlNCYvNl\nSU4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKwFUOVB4dBZesosNMAuNcxX5c7fRt1WN7H8uDfvGWAKAiEArDTjgzYi\n/075E3pHvaABV8KRezc8woIStSta9lnMoxU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAXzGnEb7IhAzAHlDdFDLLp8IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVjMWY3M2EtMmNhOS00MTRkLTlhNzEtN2VjZjkyYThhNzRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhZGRlNDJiNC1jOTEy\nLTQ5NmYtOTI4MS1lZTE3MDkxZTMwOGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATSMi+dLrfJiy/nRQR6obixRqLky3oZDaRKLSIY7vHGxvgW7CB3v9lF4YbwS6gF\n7z8XD+6h1B/bJwwkTUnFL0Npo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQdiKjWAp529i8X\nF3UrMRKFJaRKczAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgJVx0qgjxQrRIy0aHbD0UGGxxSp9JDqA0iIj4sA3dFNcCIQDTU9t3\nMe08flqchN2Pq+y52I6hz5KVwfNBXEbY5RXM7w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7792", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7792` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAYl7JVaJX2+6MOlmIr4Y0+tCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2OGU3YmRjLTNjNjAtNGFkMS04NzVkLTA2ZjY4MWRmY2RjNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc0OTVkY2ItZjMy\nOS00ZGI0LThlMWYtZGJkYzg4YTM4YmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvS60IFfaNm6tEmX/ptGXVw7bJ252ki1BTXaNCBGFbp5n6WrLpib2pSqtXAFH\nBoPylsp419odwWrrQxpp4TZmbKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPX+gitWSNjVQNRAkOHblVy+izeoMB8GA1UdIwQY\nMBaAFHiPqakjjug15nsNC/4zuXPFcSKkMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAosh5tXnuW8KpaLqxF9+AlwMVdb4ITWev\nYEMPiZ0YwKYCIQCgHcpVIKAy6hBinyHpIpHOgpd3/5203AnsKBNkjFxs5A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUA8V19eMKIbgv+teVCfQKFnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjhlN2JkYy0zYzYwLTRhZDEtODc1ZC0wNmY2ODFkZmNkYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEeenAm80U8oG/ws5BXebSwHn+NV74vQkuKW/Zgf4aaByX\nlPLK+oyQC0RmSsze+2THyvQa0q4j1nMH9YvebMhwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeI+pqSOO6DXmew0L/jO5c8Vx\nIqQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPpvmDbNFw8b5ThKUhDlQMRfId+AQ9OIs1OvYcSTHjFrAiB39nXEcUZf\n2wzl2IVlIFMf/D6F4tITb+47o9BrChP4mQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAS8sHiXYJxbJB3TopwLu6iQ7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc0OTVkY2ItZjMyOS00ZGI0LThlMWYtZGJkYzg4YTM4YmI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZjdlMjczNC0xN2Zh\nLTRhMTEtYTEyZC1hNzhkYjg4ZGVlMzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQtfipG9bUypXILld76AwLXAtIr6kEVqaz60T4+gOccBEngMbNUR4RSXRgBpZDZ\njm9MlnjwSTDp1MRAY26Q1Dpro3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1/oIrVkjY1UDU\nQJDh25Vcvos3qDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAILpZQSEMP1O2UXKXZvH6ncYKEkfdFzg8rfTsvwGsmiiAiEAtCGQ\nmhce43A+s4xASVoulGhVlLKi8mNM0Qm0czMBqSs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7793", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7793` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAQq9W+Z36tKfi7v7sFqZPJkHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyMTE0YjM2LTkxY2QtNGY2Ni05NDM4LWM1OWRlYzgyNWY3ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDAzOGM4ZjgtZTM3\nOC00YTFhLWJhZmYtY2JkOTQ1ZTQxZDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAHuC/O8+4o61qyNY5vibfN18t/bca1AFKEbO2L8huQT1yAB2XD/Wtz5Qg9x4\nxUkmD6Qo0/cnAQGOvqtMfIzLoaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu/OfGIa95dGWZnsG1JYk/u8o8ekwHwYDVR0j\nBBgwFoAUAwBqDGLIoHTa97Q60w+28UQqjoQwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJGkhefP9Tor\no+bOxRhrMRJLktwD0xcI50fn8bzBrjxHAiEAwnVaF0R17o/Pw+A9kIxfX11pPgpj\nuLC7TGDhqvqDnxo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARsesfvqluGImCyz6JDwVldHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjExNGIzNi05MWNkLTRmNjYtOTQzOC1jNTlkZWM4MjVmN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/dTvKU8Vzhr9My1EKwSISX3LKVxThMDKUMoAJb2NszmTG\nLvAHNHGEl3I/CQPPE2xfwBSd4HYmLxSaSOmDBN+ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAwBqDGLIoHTa97Q60w+28UQq\njoQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ7+GAPDqcUphN5BLXwngmlhYaZg4bUPibAjmQqRsmCLAiEA0ujWvyXk\nRK+2KD1f1bhKilISpbNCaqrfZjgj5OcuFXk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAZR2WoUoCas/RT0wHHRrU6xGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDAzOGM4ZjgtZTM3OC00YTFhLWJhZmYtY2JkOTQ1ZTQxZDA1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkODg3NmUyMC0yN2Ix\nLTQxMWQtOWJmYi05ZDU5OGI0YmE3ZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARH8I+je5YhBrJggf9W5/bdZ5JrLVqLSShTjCCNfwXZCWzohQgM0B4Var0djBM9\n3XFXSAEczPngK0NmF9gkAyRho3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS7858Yhr3l0ZZm\newbUliT+7yjx6TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAJfu5y+Vy0f+5Zvnf+f4GfT7aeMhqvyfLtCmYjXqgHAiAiB3O8WA\nROcSABXGsVKiyQCoHRG1YvE1ZtbGpLfxQ5t2LQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7794", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7794` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAbEpMgUb1B/V7WnmQb4UTWK1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViNzMxOWMxLTU3ZWMtNDVjMy05YTgyLTU1MzI2M2U0YWQ4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY3YTIzYWItMjZi\nZS00YWYyLWJlMTgtNzZmNGUzZjdjODcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMfkEZXY16raA4DR7CCvYiTEdmkaZO9eGqD+R9fvZswdBIg8AoL0gAJsJjrTF\nyo1Qna9o8Eghi6mZZVDTMnpDgqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJO0EbLoH1DwvjXs0pNcFtSnu+JYwHwYDVR0j\nBBgwFoAUZMEB0Re7DOxg2UEr8EJGXlro5JUwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPmp49cMVO65\nuAveP1BGOsUDaaAwGbEKlZrI1EneuHqTAiEAoVGyx5LqtLQZ21RAiR169seSVTit\nrogdh7+P2wYBqwo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf030bfUr2DdtGNJfHtwtsRBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjczMTljMS01N2VjLTQ1YzMtOWE4Mi01NTMyNjNlNGFkODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRrykk5mjzHASeurjbt0TuLy+Ccr5opy84JGkkjs9R0fP1\nk8P5AT5N+gTC3cBmZPZB3DzpUXfnmIL+qciLIcJDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZMEB0Re7DOxg2UEr8EJGXlro\n5JUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANUmb+O1DcVgVUOtg515JXdY0qiMYioUs4RfzZLAF1mGAiByFJeDF7u+\nqg9C9JFK9N7Zmr1D5OOeXkUAAsWHCkM76Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAS+dPT2dx2SosI1yHZoLCSdWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY3YTIzYWItMjZiZS00YWYyLWJlMTgtNzZmNGUzZjdjODcyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhYzhkY2NkOS1jOTA5\nLTQwN2MtYmE3ZC1jYmIzMzQ5ZmJjNmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAShuYiZ1cObdGpX76hrGpF00vLETl5h8z6a/u/uIP/OsqpMb3Fa4iE5NKR8zgvT\nJdeCyq3mAIagp7z7/LQjL7/zo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQk7QRsugfUPC+N\nezSk1wW1Ke74ljAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAO7f0F7pTKJ3WULObPU2cUxGjgAp42cbM9jk5lP2NO/SAiEA6GDP\nZCRjT/P9jV7rNNkS8zGX0/B7q5xr5IJ2ANlYoQY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7795", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7795` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAWcaGV7zAecc390fyNXUb9/JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ZjJiYzc3LWNmNjUtNDlmMy05ZGY3LTZiNTQxNWU0ZGQ5MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E4MTNiZWUtNDFj\nNy00Njg0LTgzMGUtMWFkOTU2YzMwNDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWabFLhYGZdOfVATWLsgfHo3swpbGHmJdtSetI+20DECWHWZyDPEsplXcQE2k\nafeoPoEaTt1DpfRmUcPiK29O46OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURokk0mIjMWMvZNvCou9eb8TzJhUwHwYDVR0j\nBBgwFoAUnv34ThflG8Hp7NLSJTaXU1N3VKQwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDO1DHdX7LY\nbF7AzJHZ1i0DwJiCSJDg+hGJ+sHH88UXrQIhAJ1IEC+vn5UQsH58NxiW3RNbW1cf\ng+LgAqIVtrOjpuz3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe1VIc7cUqkI5yW3zaGFIjjUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGYyYmM3Ny1jZjY1LTQ5ZjMtOWRmNy02YjU0MTVlNGRkOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARVGA1cIN+n0La/vA9q481l5x6d9hIXc8DWnIfXkBk87yqc\n/jvDAvfI/5zHzTo1HjwCylqKEZZI7O5fdarUgkZXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnv34ThflG8Hp7NLSJTaXU1N3\nVKQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYqITOlFSgDV0MOV+8gYPNolMmS2eU6Ad4xRns9asjL0CIQDLfz5gtUFl\nNPrnCLND9EJAwWE8RE9xaLJptf7LSGhKPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISARUWgR52vTbWtNS7mpQCKHzFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E4MTNiZWUtNDFjNy00Njg0LTgzMGUtMWFkOTU2YzMwNDMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZWQ1OGEyYy1mZWYx\nLTQ0OTgtYTc0MC0yYTE4NzJiYzVlODYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR7J5irPSTvTBnjZCmlkwNS9cF869ZHgdGER2R9pfdd9e1its0mi+TuhK59fxww\nQTiEXGPEALMbhLvM4LAYxU2Ko3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGiSTSYiMxYy9k\n28Ki715vxPMmFTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgTGjdi6OZqIdB9/guyGgaQSBEVn107o6FH6+LCsV/LGECIQCxhN1b\nlxkRxGusmNbgGS9kEM2cMLFxErgGYDzRmA9Tew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7796", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7796` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAR+nf6o3f8Pbjcon7bMLrg5aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5MzI3NWI5LTAyNmYtNDQ1Mi04NWFmLWE1MTg1MzRlZTRiNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZlNDk5NDUtYmMz\nNy00N2ZmLWFiOTItODZmNDEwZTJjN2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuYtZbOCTh+mJ1I90Seq/JJgCc/UjRB8lFHk3TAP1NqWfKIW+UxRCbyz+cpyj\nkTbgU2Jxhy6Saw/YTJeGYYbEtaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBfdc4pPdTuWog73SgDKMlgqihQswHwYDVR0j\nBBgwFoAUg6PDW5Bg3uaYshvvLSJ9FxcngfkwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCeFpDgirxHBKaoueYChAqrxgelB2KfKNQofuzR/3tV4wIgUSHBcjsaEuU8\nu8WYwjghq3z2tg3RnXjlhiABiEesll0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdM4l7GDA0/0g2VjO8weCznzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTMyNzViOS0wMjZmLTQ0NTItODVhZi1hNTE4NTM0ZWU0YjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/pLaJ9OI6UtPzDX9FawHAgyjXlG4r1QHYsSEG4xQCf4/f\n3LIq2sjCH8H7XGo2GULTNVlREBUqBUUdPrgGh7fvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg6PDW5Bg3uaYshvvLSJ9Fxcn\ngfkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPNGG/e9NGUj5jOMbQSZOZxwbvNktQIt4oFOruG1cyIzAiEAvCf94Fgt\nLM/EC5VN1fgsopQVP0e+lC4iyJqsxxS+HVw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAat5CNMAr9Yc9/r3fhPnqXB/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZlNDk5NDUtYmMzNy00N2ZmLWFiOTItODZmNDEwZTJjN2MxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MjViYzU2Ny05OTBm\nLTQwOTAtODMzMC1jNWRlNjM0MGU5ODMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARypn5yM9JnrS7Lz1Oog8fqbOWpsgNtu9GB9oXGawE6QeVF9Fw8umJXScEPXYUg\nYfhlWAAvbOgG9sPfo2eVe0kFo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQF91zik91O5aiD\nvdKAMoyWCqKFCzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAObfhVe88Qkpb5Sm+Os7EqCSIsnNWIkP1Khsyad64KKBAiEA3l15\nXAVLb+vHBsrnz077mknO1dPRNaS9dA67sBvu+0c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7797", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7797` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdK/ncq+FLbx5XNDy6Fgx7VuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2ZDE5OGRiLTY2ZDAtNGQ0NS1hZWQ3LTVjYmU0Yzc5ZWFlMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJkMThmOTMtOGZm\nNS00YzYwLWIzYjktYzkyMWQwYmNmY2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyz15Hk2Wd7k/RHKfMOjLdjNGor3lHxb3NW8EBf6bY9V32p1a2VShRtOWUzhR\nfVrsToOqnBbg1Vr/dfGg2bi6hqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnLsc6TnAOCRjkQ7RsDH9aqTcIWUwHwYDVR0j\nBBgwFoAUmkMp8jvyEBieVROMYM406yZPfUswNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIHwrzYe1Yat5kRLCUntXRDND/Jt2UrqgI/tR6a9jS9fPAiEA/rPdQwEQWFM4\nnKBSAWQSI9Iujt0Q2Si4whQVWwYqMm8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXPgnsL2fVBRcUVWfMEJLIHGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmQxOThkYi02NmQwLTRkNDUtYWVkNy01Y2JlNGM3OWVhZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu/BrtORDY0i3WsK/amRTKGGY+HYH7z7dg9Emc/ht6wQRb\ndIJ/6+gtKGy+jQxJu/R7FtD6upR8j/2PxPgl8KC0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmkMp8jvyEBieVROMYM406yZP\nfUswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJa9ucUYIa+IZpRd6akyd9/9mJhW1L/Z+Olmz2wRECoxAiEAiyq+i5yP\n5VdIkkGi1kuDO4z5YhMkzBQTIHIX1wI1AaQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAaBNXpzDZ4yJj+/qug7z0lnFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJkMThmOTMtOGZmNS00YzYwLWIzYjktYzkyMWQwYmNmY2Y1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YTJkZjNjYi01MTY4\nLTRlZmItOWFhMC01NThiZGRkNzc3YWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQSlHbSwd1f3186XXDEYoOIM3t7UKXgIpNtlnrEevsu9WmcqhHNWQGNXUDJo+uW\nFOfD1gQ6dZZiBqXpkrs40Xjeo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBScuxzpOcA4JGOR\nDtGwMf1qpNwhZTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAO6ClPIZOMWnuUy1FUIUuZgC6+SxxxGf4i/XzW8BbYeKAiEA2Mm5\nA1Ms0DBLL9T8VsZsqUMnNSLDmM4ryIhUMeoX0Hc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7798", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7798` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAf9B2OrBTAf1wI1m7erxqHnBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExNjhkY2MwLTM5ZDMtNGUwNy1iOTM5LTQ4OTVjYmY2MzVjZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM5OThkYzgtMDRi\nMC00ZTNiLWFmNGItN2M5NmQ5ZTM2OWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz4iuaZjuGYAMt95DN+ek27LRDHpjskJ2jVG+XpMPaKLuO5qZeFBPYjGEvUxf\nsqC/H8zDtyJG+klTcFH2wzSTgqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzz3D7ydJ2bklqYhrmDfCm+OXHRkwHwYDVR0j\nBBgwFoAUS0EZ2hRBwPUIrgW8OCdfHWIbQaUwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDT\nWPaPjDXrLqR7UQUcRijguPBQ0ELTVvBWIrtD9jpDrwIhAOEkrsk6H5zOBb9ZDKnO\n/7yfMW6/gq6zV5ed3GHDhiAz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZrDcvFw0Sc/57OlXSd3FNGvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTY4ZGNjMC0zOWQzLTRlMDctYjkzOS00ODk1Y2JmNjM1Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMEcSyknljv/0VzWVHejPUjfN3+tTk7jdCAl1aXrEI4l/6\nZpik99tx6tGC9LYlK7xgYYktapsbgpTtzH6kvgmUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS0EZ2hRBwPUIrgW8OCdfHWIb\nQaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYt87rx/pcMKGmxxQ6KY5873OEcAUls64OAATN4QjLmMCIQDJTXfYzd2c\nldIz1mYBifCPZzPqwjNzn+2EULmXbEiJoQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAZuBA4Q8XMarTbddZj5P1VZmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM5OThkYzgtMDRiMC00ZTNiLWFmNGItN2M5NmQ5ZTM2OWU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MmU5M2RmYS1jYjJi\nLTQwNjYtODZmOC1mOTI4MzRkMjVhNzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASWHI3jUmXDE3GIFBXYw2HPc4UnDgex7yTSHsWcZoMQkLtCfXY69/b0ZUKMDY1F\nOHTcbV7y0WxADxKHV+3ur3hlo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTPPcPvJ0nZuSWp\niGuYN8Kb45cdGTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgBtC+F8G/DYgNN1PSO6jSedaUWNyOhAKUXNowNSvpwdICIGSdKMba\nvpsfK/HFvcBIH7eTJLvr6aIc1tVIvxQOujcF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7799", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7799` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAZ1eN5h2GMvMtgegCjrYFSLoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczYzhhOWE3LTVmMjQtNDE5NS04OTZkLWFlNTRmYmY1ZTE0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNlNWQ1YzUtNTBi\nMy00ZDE2LWI5YTAtNzhhYjM2OGQwMzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5keYnZhWJCDXhjC6Plz2rYfcpQSm0rkFq++0uYUdM0LeYrUpEwD3llM4fEGp\npWEt2XyoNuYEDCzBT/on4s85gqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyLafWvHhlyauWpuBr/LtiuqWc1wwHwYDVR0j\nBBgwFoAUBXxPMQJMkp/8OtDS9GHECOX4dBswOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCQ9FwYKrCL5c53jh3uz7ktYGstuqUVpYXmhmwdXZI65AIhAJm0\nFWXb5ClMz6yFgCGR2plf+mPmfhoThP6TfGR7Jdz2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaSJsV0T/ZbSAz8ZiIwvjMysMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nM2M4YTlhNy01ZjI0LTQxOTUtODk2ZC1hZTU0ZmJmNWUxNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0nV+ntIsZv0mniHrFHgjKFOTK4ykmi7QCDUj3PDm1qYp9\nxvN3CB/CMUtzmhH6w/bOUIvwSQkQD9E/C9C6hQeXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBXxPMQJMkp/8OtDS9GHECOX4\ndBswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTLfwfms5lchAIM9f9502t40JJKdQclw0lUlFxBI89YwCIGyfrK3eCf+Q\nCNfty//4gdkMT3m5gSLHCy0rQQjjaky0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAUCBrS5m2rCGwkITc1Dw+gtBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNlNWQ1YzUtNTBiMy00ZDE2LWI5YTAtNzhhYjM2OGQwMzY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZGFmOGMxOS1iOWNi\nLTQ4Y2ItODEzMi1lNWVkZmM2NDJkYWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3cvQc/e5/A2MdccP759+o9spJxbUQPTz7jZPTbflMrAkGM5oaXDJNoRlvHlwN\n1AbYubGW9devQMZ1HGeE7z2Co3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTItp9a8eGXJq5a\nm4Gv8u2K6pZzXDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgaf7QXHL/eKKO++spCqNMc2NlH0JLqHoR7QosLq3FPeACIGSyc3DP\nGe1XC4qSSC8RIruAxpUSeFh5yON3MZ4mpnQS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7800", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7800` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAfknSEpBxs0DkW8UcvtwfyG3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiZGYyMjA5LTM0OTQtNDhmOC1iMTVhLWYzYmE5YWU5MDg1OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZkMTUwNGEtNjY3\nZC00MzdlLWE2MWItMmI3MDgwYzM4MDU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8mmPZDDGkB8XUQs8DG/2w+DWw2qBDw4XHB9gClVLajO9MGGZDVJpIBuI2GxL\nqx1APc1cHe0wwCbeB8C4clUjRKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx0C63dzNVoBfS34gaaePoCGiR3EwHwYDVR0j\nBBgwFoAUg3zIhwHkkVXiG6hTURwuNrCQ6oEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDSUaEJAUp0gm9tLpvKuYS4kHes+8m3Q/dbNebXVQu+wwIgF2yI\nT+LH0JAWMxBrAdjqK5arVXuOZWWlbOG3yqvz5Kc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXBphIbNDeSTEI1Zpqf8K+V9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmRmMjIwOS0zNDk0LTQ4ZjgtYjE1YS1mM2JhOWFlOTA4NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASb/biQZjm+Hz/uU8+OMs4Y+nYWOtDMKQ6uJjCozFk6tnLq\nmSmVe7ULJas2evG4xpB8J0kVkF1lgHVZSbwJPZGSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg3zIhwHkkVXiG6hTURwuNrCQ\n6oEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIflHFfkZljRt4R8/n2IK706cL6huSbBZgEETIK3Fd1RAiEA4OYjlSrR\nTKJDZ7+HcOgBtffn0UjB4fMFNfXCnvkj0iM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAZlDCHOu8zojE/8Sx0CaBdkSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZkMTUwNGEtNjY3ZC00MzdlLWE2MWItMmI3MDgwYzM4MDU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYTI2NjQ2MS1iODQw\nLTRkZDItOWUwNC1mYWE5ODVmZjY4ZmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARic06Th9cEmGTkYN9N0z32r6bRxc/SYjvkmqENKQ5oe5eLij0yIFyKNk2Oj7ye\n0Uz1M39EbA85yi+5UZXMdQp4o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTHQLrd3M1WgF9L\nfiBpp4+gIaJHcTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAIO09TAerYIvRlvuhnYJJchEqfnX0/fNoM5ZZB+MZ80jAiEAl/v3\n2iaumK3m8yoPxOYh55GlL/02THYK7Qwvl6BVDpY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7801", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7801` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAfsuW4lw1wljcvuFWuxx5PKJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwNjc3NGI1LTBjOGUtNDRiNy1iYzI3LTI5NjExOGY3NzA1MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZmY2UyNzMtOGMy\nOS00YzkxLTk0MWQtMTE3YWEyYjhlMmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6PmaFpBvvnycWKE301NCslAFjf8uT/LbSGW+LrBoeXiwe6Yl3M7D6GhXsuge\nbM1OUoAmhRRFpf+k3AyxDWfMEaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPG1BqQFQM6tl/WGYv6wfWJmUrcCMB8GA1UdIwQY\nMBaAFL6RUGysc6x8bHYBCoEF6xYSDvtsMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAl2srUL7MYrOlYpiWqZ2+e8ytWkbOaLiBW\nIWNJf+Oi8wIgHhGrCFer7jwMg4rSB4onVEER0wE1oHs8n/MDw8T77Yo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdU1E2ykSzzcK0CHK3c5/JbVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDY3NzRiNS0wYzhlLTQ0YjctYmMyNy0yOTYxMThmNzcwNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXIV7XCntY2KGYL5VBUJPUBF9HWWBVztrHLSiBxOzNIGsh\nuGBc9dGV6xBKBcea++HP0VWP4ttDjnY05qtw6y0io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvpFQbKxzrHxsdgEKgQXrFhIO\n+2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRTqUdn9eyqvJ/QvP8B558H05wLqpH2EmbVTfHYXnLCMCICNcgrn3/mlJ\ndTamtcl59Uc4aQMdLDIwygLcjscUgwuY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAaj2tTKgjrGvkflhCIwmJpMnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZmY2UyNzMtOGMyOS00YzkxLTk0MWQtMTE3YWEyYjhlMmZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYmM5ZWJmMC0zZTNj\nLTQ1Y2MtODAxYS1lMzJhMzUxZDU2MWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASVyW+JfGEvygnGFUPkcm5EPTrmCdAohhCnqni0b4SrOQS9tUrX2fJTfG2FcXsb\nDUv42o+BZhjnQpBhiXqTRSQmo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTxtQakBUDOrZf1\nhmL+sH1iZlK3AjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgJqOHQfU4jsD5y+Pk24s7b2glXz1D36/NX5/QmIdMteICIAxNpfYP\nBaRz3FeNSYf0K+u4PnYL55X9ghRJMkGqidsX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7802", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7802` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASe6K2YHJkUWYyaPNxWl6hQ/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0YjMxMTAwLTkyZDctNDU2NS05ZTNkLWIxOWMwNTk5NmQ0MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNlMzhiMzQtZDY3\nOS00NzE2LTg0ZmYtZmE1NjQ2Y2Y4NDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECPgZQ+mPP/lrttxovf8V+9IFxED4LcA7vkaZLiQQqZi/UUEDnBP+luko1olb\nGDjnfMtqUzr7Wn3KfcZjkh5BBaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEULEuPoRCiwzgyif0Yrj9OGMlvMwHwYDVR0j\nBBgwFoAUscx7ohl7L30STL0e0W1Ms0xHW1YwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgCarQfVINbDxq\n/odoEga7nBIx52uJy3hvbWf6YyaMCrMCIQCWkGBBVCeJGXZiPuLAjjyAh9jmAGZC\nzbTBNfX2uD4gbw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa65KOL5Ki+WnY+/3z5x2C+sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGIzMTEwMC05MmQ3LTQ1NjUtOWUzZC1iMTljMDU5OTZkNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRYEzgSr6AkF25qmRPyhBKVpkESU7utkwnco6jzLnRCJRg\nIZdLEUdfkUoPgisvZfEoe1VB3Yh6woKgwbS3yAwUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUscx7ohl7L30STL0e0W1Ms0xH\nW1YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFwS2WHKJACilabnYFAB1bIvKYGiNVKm5GeWniFPOwKcCIQDPRDXDIezZ\nkAyQ6qvlKhXw3bEse+sX4mlSCKbSrhICmw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISARJQe3ycdDbqFChNjGh2Oh83MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNlMzhiMzQtZDY3OS00NzE2LTg0ZmYtZmE1NjQ2Y2Y4NDkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNGM0OTM2Yy05YjBj\nLTQzM2UtOTY1NS04ZjYxY2EyYmVjZWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATsBB0lZIFncKU/B3Gy9WL4cpq4L2Qfi3QHEkMHcpb49glgvVf2u7hfFoMSw/0v\neIAJhX7jftnbTsBZKYIzCob7o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQRQsS4+hEKLDOD\nKJ/RiuP04YyW8zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgC01TcTHggxoReKysk1iArUdJ4NuK5BJJSz24W/0oAlMCIQDfkhhR\nUvKR9yQSLj6MaLekvkGnWWqQJE7OXtiBckLt4Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7803", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7803` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAechrmUXgWw1yLX+rnU7ywHZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNzAxZmE3LTU2YzAtNDQ1MC05NDRkLWNlYWQ4OTgyNDA2MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE3ZTFkNDktZWFi\nOC00ODA0LTlkMGUtYzFiNTgwZTliMjgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqYzA3HdXI57UOhEZSkPScYV4z2OmXM45Hh7AvvSI9mwv3uD/iSRJQidSRcsK\n4Wr1uZxjC+s2bs8fTuJzGcZNeKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjMRVg0id770n4dk4uMA0ZU4vmV8wHwYDVR0j\nBBgwFoAU2lUc4Ma6O/l2VBH+4icsywA5zuIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJq1nnBRmZI5\n+MrF8nuN2MENu0v35SjwSxmWv+8yHp/GAiEA8pI1504kWlDpXc/fDgHL19TNDqLQ\nj81A7BqoQs9n2yo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASKzMVaXxXiKPqwczW0lFHysMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTcwMWZhNy01NmMwLTQ0NTAtOTQ0ZC1jZWFkODk4MjQwNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZ8Jt/8L55N7K9KDkBXMQvSm3kZiI9M9NYsWZqtYLdpMsQ\nlPFcSuUuY751lLPU0vr0QhuVCPFMQcEeHzLOKBTLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2lUc4Ma6O/l2VBH+4icsywA5\nzuIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKlSMh0eUtE9Lea65Wm7sNVpZZ/XZcmbZCBYbhi0ZodiAiEAjV3TKa+2\n1D+pBmuEPf7Ftgw8OA8vKax1N4UgzZpW6q0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAVGl+0BjE79b9Y2AJa9PmrtGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE3ZTFkNDktZWFiOC00ODA0LTlkMGUtYzFiNTgwZTliMjgwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMDExMzRhMi1hNjg2\nLTRkYWYtYTFlYy02YWQ3M2E3MDVjN2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS9NMti12qsslSb/kdWmRKumAzIe6wKx+fwh1J5VPl0ad2XhdRa9HLz7anI1R/s\nsxv8q7u3pSUPdV48N6lVEUFQo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMxFWDSJ3vvSfh\n2Ti4wDRlTi+ZXzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAK4K2L8ZR5X1C+0k0IATvmIeUFmT1c/ptFnhf71cBUbWAiEAk4GC\nBq9BQOP78RyZKpfr7gqWuqR7OlvVVNJuEi/T1Ds=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7804", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7804` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAe2NTSjhsCvM4QA4pTRH3a86MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMTNkZTBhLWJmYjctNDk0Mi1hMTA3LWNmOGQ5YmFmYjQzMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE1YTQwN2MtMzYy\nMi00MDhlLWI5YWQtYjM2NWFkYTExZWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmOUsdIVmVYBwFpseUK/K3yeVlvjLOT33s43rRrkr+AVATO/KhwQWz8mN6XPR\nvGtUb7lrKqFp3pYLSvwHUXEEBaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9u+Btfii8xGClJY5mLA4JrcfuZcwHwYDVR0j\nBBgwFoAUFw8voVYpjHYBdyXAD/AVuok3M+EwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHEjO+msbcTa\n0DSfuI56PJOKeQXk456R1Gyuhh0Lxt2xAiAN9/SroKlXRMiDTUMsWw5JHcqQAsKn\n8gpcgpA9L4P6qQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASapXd8SitPh0MykSnoZgLwJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDEzZGUwYS1iZmI3LTQ5NDItYTEwNy1jZjhkOWJhZmI0MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDn5KeNabbSYBvv/EigYQo13dCrOouOJZmuNxhM6tl7Ud9\nhfaRRUoNkV04zcwyD2VG1a4aCFZW4TcYsCbJ8zMNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFw8voVYpjHYBdyXAD/AVuok3\nM+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNgRQp0OfU76dy5X6KFrT8icF7jPnsgkTBk1k0cTgNSsCIQCiR686aEEI\nHduQ6u8tTsMvjmLKmMvH8zj5N+fMeF2yFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAe3OzMb3ZIjPUQMpBg1pXH62MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE1YTQwN2MtMzYyMi00MDhlLWI5YWQtYjM2NWFkYTExZWE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZmYzMjEzZi1hYzA2\nLTRkNGItOGJiYS1iYTQwODczNzNhYTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQZhM+bWgxy74GBqnhBLyfIlZ30+CkHB9jLqEjaq8NfI5++yR+9oN9Xddmdz9MS\nzU7QRmrmq/8bGKI0YGXOTdF6o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT274G1+KLzEYKU\nljmYsDgmtx+5lzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAOEAWfY48SxccVJixYF2rQue8n+ZBFW/sWRjMQabyxuZAiEAgDLh\nyZV2Jc5wZc56wnqKYWkFlWnYpH3oQ/gCYQksJPE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7805", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7805` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAa6cpKPqKPi43TJpIZ0WqJiDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhYjczN2NiLTM2YjAtNGZmOS04NmM5LTMwOTEwNDRkZDUwNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYzNzE2Y2ItMmIw\nOC00YTk0LWI3NjctM2M5M2Q5OTMyY2FjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEis12vAjDuun22EBlY9/1Ufe6mGAI+NfyTTgCxZBlErKii++F7TXQzgmFYEKn\n5HcXJJ0GNimCkt+L6s+EtLvT76OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtH0G+RMS5Gm6tIhssmOtt/1k8f8wHwYDVR0j\nBBgwFoAUWyITHYBiYJHUo7PABqV64ZQ/TqUwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIG6n1+9XbHkY/LfYaOq7AI0S8d9R2qDJSpnlnbpXEfuhAiBSGIFao4G9jaxR\ngUnPZQM8/zKZiTlL+CT+bPOPz7vK6w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQHT0glvoBnGBpVT1Ca5rHXAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWI3MzdjYi0zNmIwLTRmZjktODZjOS0zMDkxMDQ0ZGQ1MDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2Ku0aQYHciNeFyhFN8uoYzEU6QRm2Y0l5P7Qq59i0XK3D\nlpuxLkIVy+q3ggQO1rntG3lSv5oMrXUW23BqgUEro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyITHYBiYJHUo7PABqV64ZQ/\nTqUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP/BaIBODb69cQvyyICAnecAydyIVWXTb+0k6ooyiDEPAiEAmRjv0dYz\n3CJ7vFmcQPVoHoIZlp+ODq8WmQ2Rkh4r5Kc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAV63VZcqjcQBsGD5d/iqJbX/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYzNzE2Y2ItMmIwOC00YTk0LWI3NjctM2M5M2Q5OTMyY2FjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZjZkNmYyMC04YmJk\nLTRhOTQtYmMxZC1iZTI1ZThlNjQ5MzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ2o6GdJvS83bT1pfACklu2Sb+AeaQsbAyy2Y5VxPIdXUoMlrKXeFPmzKJc7WB9\n4l+QaGp7D87bl+Xh8zhpLbCho3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0fQb5ExLkabq0\niGyyY623/WTx/zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgXF0LBYPpRbUttvg0wzqlXoNUa/PTz2zoJQB7UEwqVCICIC49VMIa\nECWfNGVccpeQid9cf5EDBoFWXRcYj3b0HsWE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7806", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7806` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAWBI4FIojQlVyf2+932GkIdXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3ZDdhZmY0LTBiZTctNGFkMS1iMGEzLTI3NjM4N2U4NzBiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDMyMzVkM2YtOWFl\nYS00MDBlLWE0N2MtYThiNjk1NWU4NmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELV4l44Z8CJb7vQ2VXlEqgcPzlPhHquVPHS4eYOlR4LC20tRMicG2wzrorMpL\nb20l3hEXPWkwYSWluTGg6OmNLqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnGEDW2DOqDof9wnaJD9yycEWdTgwHwYDVR0j\nBBgwFoAUAUCLsgk7I/oAw7vPnTGG9xDPM5UwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICQVaT5hADqyD03rSlIGU1m6e2k+ZwiSGv2VXe2JI5wwAiEAzZ4wDDoamdLl\n4Z9+3IOyhFcPO+SfrgB7nX7IGt7h5j4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZjTvUHQCuss/iiDZLVyXLH5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2Q3YWZmNC0wYmU3LTRhZDEtYjBhMy0yNzYzODdlODcwYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1kzTKNgHPrwniMeeJU/+NYwaLFoARdfQk2hfEecDxiyBs\nUKU16S/ttQ55YwVFr8Di//8/D4Wit8hLEnx00JMYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAUCLsgk7I/oAw7vPnTGG9xDP\nM5UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN2UGIfjp03Vb9a23owkey6s73kJEimaKGTOAP31yu5kCIQDdBcx8ZXzn\nopumoSFZ06OUCv4La3+wvgGpFxlYcxwHTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAWCVIomip5/m+iO3Ajt+EapjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDMyMzVkM2YtOWFlYS00MDBlLWE0N2MtYThiNjk1NWU4NmI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMjk0MWFmYS0wY2Y1\nLTQyZTQtYjkzZS02ZDEzNTFlY2MzNzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS5a+ZOUA77kJruDiSKjlDnNgX8qPt84ONcGGSHrNUl/S86hfh+hnLiETdaxXtN\nc/pTHcWhHQp+PpHFd9ru9lIso3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBScYQNbYM6oOh/3\nCdokP3LJwRZ1ODAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAMekVoxeWz8luibGkAU+yeqUfbohgXUPrccCfkLLRttfAiEA57Qb\ngprWL9a7Z5UH14aPWA++o3PNiYj+aOXLTE+aJeo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7807", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7807` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAZbqbqEBykv8Cqk3AN7ThfoeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3NjFlYzRkLWZjOWYtNDZjYS1iZmI1LWM3NmUyZjIxYjJjYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc5NWZjZjctZGVi\nOS00NzM2LTkxYjctNjljMjI4YTUxOTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhtYxwDBMkJg/9gD2p4zgtrmhgibiZhR23dryAo5S5neFxpn/VE7dEWkkuskO\nKDJ8mM6WsSPDtKH+Qx4eg7k/k6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiyc5uO6tBfeIDbY4TpHQUJmVu1gwHwYDVR0j\nBBgwFoAUnjTGJO4+NXZJSFsqpJHKJxoJjrYwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDM\nE897vfU6Fewh7BDFH0LlK7LErKkZW3z+3yHtpHrEEQIhAOTqU6AWYm0cTO2K9Ypl\nQNAeZXw1x6E7Vcaw6A6SYS43\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ68wfZ75lZQ+6jnkhUXt0bOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzYxZWM0ZC1mYzlmLTQ2Y2EtYmZiNS1jNzZlMmYyMWIyY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYuKwxwkhsqLywQmIGdSpaeoLVPRw8C64iWOMjFqa0dNKh\nS0lVqbAVgcCtHlI1fHyKJ+EMhkCyP3kAorgAl/aVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnjTGJO4+NXZJSFsqpJHKJxoJ\njrYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALMYpuJohydPR19xGH6TOdF6VuOuKLlI78/ZsZAW9HUPAiAcmS+yd1/7\n+VKbT7iMdFyycARwh7WHYGBPCsoq/lLNGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAbyt/6J9TOgx3GJuFeul+bl9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc5NWZjZjctZGViOS00NzM2LTkxYjctNjljMjI4YTUxOTdlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYmQ5MjRlZS1lZDYz\nLTRjMzUtYTAxMC04OTUzMzQ2NWU0YTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQuJzxOM5Aw/WM0h1hUs3OHo0p6TCqLIa4FjIrEP6/7o8gOHTZkWe22mCf8LZMM\nN/PTxg6ZG4U43MLddbIt/ieXo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLJzm47q0F94gN\ntjhOkdBQmZW7WDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgCnj+DzxXpJE0Bb84unfZ5196oQXRASnQ5YvHLIT3bPQCICqPHXPU\nx51JFTtRI5XJd3ez7ZPwSsMg5QtSVcK5ux6T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7808", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7808` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAfkizutZq7ro1zTl1U81XpB5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0ZTkxODFkLTVjOTAtNDcwOS04YjEzLWI1Y2FlZWJmNTRiMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdlNGM2MzgtZTk3\nMS00MzI0LWFmNDYtMTlmNzg5ZGMyMWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdXrK7Saltt/Mb/A0VKRYRYC3fouN0u9VfzZEstZFesDKUBrHuQF8hpm6xGtQ\nB+K+JEvF4Q1MD3ZCT5/tGz/Ot6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmgIWljDoMuYKfU4YIQyX1EvbZ9QwHwYDVR0j\nBBgwFoAU+u8F5bqW05KJqTCyCQqG0xpJLQowOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIBxUcR9O0o9IGlM1bkPDub7nHmhDGECmNtnXblvqlQ09AiBSepFF\n+0Z5FUvl2sZuGyNoxA6vF1o5u9LE47GQNmiQ8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUr4B4MozuQMTBRCdt0rqEhBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGU5MTgxZC01YzkwLTQ3MDktOGIxMy1iNWNhZWViZjU0YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLYK6mLK6jFhjnmBUuVBLyMD2z4WpXgaJ3BR8nPRbZZ6b6\nWRLsFN3lFtOrvrYRgG/NF/jQfBx2ZJm+iXMqNWolo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+u8F5bqW05KJqTCyCQqG0xpJ\nLQowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIfL5uE5gfx0+cmIYx3BjGbTMKwQ9dz/uuhXLaHL6K4nAIhAKKwhNQq++tc\n2ylprcBSZd2j0gb0ztvv3op+2YaVnnY8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAW9R4EEO5VG/mx0kRJchEBQkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdlNGM2MzgtZTk3MS00MzI0LWFmNDYtMTlmNzg5ZGMyMWUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMjcxN2U1MS1hMDMz\nLTRiNjItOWQ2Yy03YmJhNjM1NjdlYWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT3SKxMu9mPGuBqvjiOn9H2C6QCjgdeYFMmXiXoNXgA9otEAWqIET1D+XhqE//y\nPFIXxvzB8zkbF+OyMUfUtpYGo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSaAhaWMOgy5gp9\nThghDJfUS9tn1DAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAJ8o2hzr4eo4ZGxcmMFhIgzmM68J+8J2hbJpV/XCFEhDAiArmjN7\nWDNDdrtXwIAs4RUIW2kjwzFKBCnOeswOxyMaHw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7809", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7809` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAXQZe+2HxnwdU8P2OnoQEut+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3Mjk2NTFmLWQ0MDUtNDI0My04MGRmLWUxOTY2MjMxMWYwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Q2NGNlNWQtNjg1\nZC00ODllLWFhOGYtNmM3OGYxYzk2NTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/rsmIqLbziLq6KKPe47sySUG4a8J6Rg6A1yDSvSJiK1QffG9U1gouaD+1FcG\n6E40f/MH2L+YNrNhV8za43lNnaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeB67lcLZkfrveqLW8487DUyQQAwHwYDVR0j\nBBgwFoAUXxTJ2+f3ScCWLzSMeuMbyD/g0I8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIC9QDAXqndrBf0A8IhZ4jP9AVgYcFBb10xiGjyx5O8H+AiEAuuQc\n1fhjPSDFzgmNCPL4LWcu9VDHuy8HFoAsh0WMv7A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb4Xmylnh8bAZiSEP23hgzI/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzI5NjUxZi1kNDA1LTQyNDMtODBkZi1lMTk2NjIzMTFmMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARg79cysj8ewmXTBIYZF5DK42fx6mDcv4E4L24p07AEJC79\nkHGP/fw8QzolOpZpCgDbSOcwizw3XJLxTV0M4b4Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXxTJ2+f3ScCWLzSMeuMbyD/g\n0I8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOfpISocVknad/qMI9OpEo0j5YKXJfWbBY7hHwUryDMMAiEA+2MwW+JH\n0WGx/kUa0UxtKXKm+kaxFVlbGmkrdobX6Ng=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAXL0Fi8Fp9GezjTqQ+zxkeqcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Q2NGNlNWQtNjg1ZC00ODllLWFhOGYtNmM3OGYxYzk2NTdjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiOTg2M2VhYi1iMDU5\nLTQ1N2ItYWUyZC1iZmViMDA3MjdiMDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATwSXYrKJoQDmWm5Z0DUPKjd4Q9RWys+8mkhUcGI8WyhE2mJM5Efd6hEIhPd8OU\n9XvRhEsDw4stERZVk49QW0Vfo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ94HruVwtmR+u9\n6otbzjzsNTJBADAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAMo/fJBNYEE96XsT+tE08hpuXtjeWlZhBWET4eJvPZgnAiEA7d1v\n1UpFGxZ9qm0iztJtJnQ8gwrXTuqRIdd6MKzTPxY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7810", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7810` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAezk6QBKFW+nG+F6aC4ByqjGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNzRlYWJiLWUzYTgtNDljNi1hNDkxLWM5OTcyNTkzZGMxOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIxMTBkNmQtY2Zi\nNy00NmY3LWI3MGUtNjI1NDMxOTJmMTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXxGZ9RShSAVsJGP8riChtPfhpGrp5CowLsZjcqDMyy5nI2gs+/DZgHpkEBTj\nUraLPzly0nAsIJqd3YiLTnCa6KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRwKzAmRwSB77jzT06US0wCIe7HhTAfBgNVHSME\nGDAWgBS/0cyq7jqJBiBIGGjJZo5IuhUy3jAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICSkRxaDXeJa+l8BRQz1KbtOPfA1VCRS\natNB7o0cEGU/AiA3J+wN5EBDTAHO9IhpEEwWey6D1euB3Aa+AGope2q5Pw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZTj/BuFXabh0IeTYajm97A/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTc0ZWFiYi1lM2E4LTQ5YzYtYTQ5MS1jOTk3MjU5M2RjMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0fMGbpP5CvekgH8CUcAjq2se6cCGQJM0zenIH6OGDt0ba\nQKLBiReq2DJY/oHtdQ5UUZ6IUF+/fQbtilPTRiuWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv9HMqu46iQYgSBhoyWaOSLoV\nMt4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK6Ujew19tVDWZoH82zJGYElpvWN5teM+55Z+nT7avTWAiANOvQ1C0KF\nD/LKV+8/Pj8gHCViDIX3R5XorrEOYNrsrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAU1JUw52D2/myJz3L1PplBFBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIxMTBkNmQtY2ZiNy00NmY3LWI3MGUtNjI1NDMxOTJmMTM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NDUxMjdiMi02ZjI1\nLTRhNmEtODY3OS1iMWRiMTg1YTU1ZmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3pLu3XoLjONObelATxDyjU3oi6rwTufkMZJJSxqx7u8AsIHqwrwe01HY8qdHy\nnTyTpKtNitmylLAzJswzZglpo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwKzAmRwSB77jz\nT06US0wCIe7HhTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAKq0+9x8mvOagiKO/JEQjMfw02VGSW4hgjPZrHAdFbquAiEA8tfq\nYcnNFaoNQVLVzZLkbRLsVhVVUNTfEtAmFV1WLTw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7811", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7811` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAemjNLZTRWA1SCx4jEGXiGM8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljNGUzZWUxLWUxYmQtNGMzZC04NDY5LTAyZGRjMmE1NzVlYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjMzZTdkMTEtZjli\nNS00NzMxLWEyMGMtMDY2NDgwOTQ2M2M3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzbkM+J/dA6HLguAgHdV468Jq/xxnPEJu9IKIawaLMBmB+m6HTjDzppl7fUjZ\ncJ+Dd/GZF89w29N4arbbAZHre6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV5YOpsQRxPy1ZTNVi3zRVPnqJDQwHwYDVR0j\nBBgwFoAU/taDx2fLYc/A/PfYI7XL9V+N8XYwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGCoyaEK64qn\nHz7YCEsujg3WIU9C7ayvpWMEdn4KKGTgAiApWf7UpEPjo6164jR2Rth21qZaChSZ\nGy1VSdN6f++Jyg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQOY4BoE3h380U3yIi39Oc+QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzRlM2VlMS1lMWJkLTRjM2QtODQ2OS0wMmRkYzJhNTc1ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfB7WsfphOhsu7Irvq7xvnRnJ7pJy40HIvzcICGJMaHFcX\nTa2hFvkS6Ya2c47OPd8tmmB8GUfjUJGVBsNI+sJXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/taDx2fLYc/A/PfYI7XL9V+N\n8XYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKabNYv94dyx1bShgN4sP1BuuwtVs/+X1Vclc6wwM6DyAiBTBwplWdfw\nAcZEWcxG542X6jRUd36dDh91vFC+ws/7pA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAYFM8agsgrs2W760ron5+CJoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjMzZTdkMTEtZjliNS00NzMxLWEyMGMtMDY2NDgwOTQ2M2M3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ZjY0ZDRjOS1kMDk3\nLTQzYWItYTQ5ZC1mMGJkNTQ2OGMwM2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATDunXDFRI7tZmnhSopnnilIfJ4tm4vGXuVBkado/nLXkD0Ob4UiBg8EoX/WK5o\noLilCiIQl04PbDu9RjpMHf/To3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRXlg6mxBHE/LVl\nM1WLfNFU+eokNDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgaSFhY7GE5ZpsQVyOcDGo+jeNt4OZBlHIICbIPQBTnLcCIAOTVBcU\nXbveZomwB3TVIBseJ2fSU4SbBF9MlkA58Kti\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7812", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7812` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAd1an+/ECGzpwq7YodMDN3EXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmNTg5MzZkLWY0ZmEtNGJiNC05NzQzLTFjNGJlN2M3M2E1ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgxMTE4YzktODQx\nMS00OWVjLWE5MDMtMjNmNmVjMDI4MmUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExHVx28rqqpy31SIoUJUdNhnlsGlSol1xd1n8Jt+0/+ckg27Aq6FDOMH0jWWB\nA1sVW2kEe8CXAZdwV+LMsx4LRqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX7+Q3ys8GKgPzcyJDzKYJj889nUwHwYDVR0j\nBBgwFoAUBHCjP8O4CjzaX3FmWS5NrV8tFzswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCBjg0FvLzh\nCq2KBtXOxDeYNimbJiW/QhdxBt+GXiQLqgIgMkM3ccsvpmE611L78hIYqUgmDspW\nJfnZGoSqdzybuto=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYjfHCQUz/rB0nOxHV6nJoNZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjU4OTM2ZC1mNGZhLTRiYjQtOTc0My0xYzRiZTdjNzNhNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwLh2Br4fgO1DV3wc9nIHmVAUPj9aV/jTieOcqCH5Vkv/+\nnbinZSHhxd7KoCSApXqJGXta3bp9N+/b9yQdsaXDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBHCjP8O4CjzaX3FmWS5NrV8t\nFzswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKYOFBQliKlHsyaMwL7/D/XxKHatdVqUqZKIydSRnzRQCIQDua6eW7xST\nOWJp4lm+cPMHDWspgLpT5bOBRhLhDeQpnQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAVZtezTkijGYK/ImIGQDCOqDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgxMTE4YzktODQxMS00OWVjLWE5MDMtMjNmNmVjMDI4MmUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwODAxNjU1NC00MTA2\nLTQwZGEtOWQ0MS0wMzBlYzczYmI0ZTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQqUKCLQaR0DInKK7c/8IHXWVK9IT58LNPklId+m9qQiwNVC6kAOxQODQzzqLuU\n1Una6pcBEkEoc24S7ZXTCCtPo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRfv5DfKzwYqA/N\nzIkPMpgmPzz2dTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAOqoLGs5QgOSa5dpZnMZ1NkXIE2zIt7FAleRu8SbTIwqAiEApm1Y\nuzhmVbKIZLLE2paMThqA8bmavhCz0dzbNgYErBA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7813", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7813` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAUx6guu5DYrlRmjeYTZjWDJbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiYzUzNTg4LWQxMmQtNDFjMy04ZTEwLTFlZTAyODNmNTllNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQyZDEwZmQtNWE0\nOS00ZWNmLTg3YzAtNWViZjkyNmZkN2MwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBrhpwiy4JioCZnNM8bff8kbQR5oq/uvaXr0RkNIOtlOCxUHqzsd/2TAcWtUd\nQk7FxXO3RU8YQecC9bsKPPPD96OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYJRSTNE4uI1dWhrb3zD672Dz7OEwHwYDVR0j\nBBgwFoAUs/6/XNZWFM4kz6ZMj1kVqP2P4xkwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBFh1wbKt/N\nOW3ffh0eT+SWdNETlAG+P0Mh5PfCoZtehwIgWPKoqtRDpm52buRqHcZf6OhxaEf1\nOCuIMp0pQS5wluw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATDyd52wsASFebEhMfoN+MaXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmM1MzU4OC1kMTJkLTQxYzMtOGUxMC0xZWUwMjgzZjU5ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFsaSj/COaS/hg/T953kOSHo7hhye068pAdWkE36lnELGo\njVsmvmqRBt2ZobY2kg9yh+yGX7/s7eG11nDuXqNCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs/6/XNZWFM4kz6ZMj1kVqP2P\n4xkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMDSC339xpm+5+GpiWPQ0gFCikeELD9nBmTywGGZ1lg8CIAFqy9fjOUny\niVS1VUnzAEWKPXMDilc9iB/Kx2wIQ32v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISARx+KlSvUa3RQwau2Vpmm5snMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQyZDEwZmQtNWE0OS00ZWNmLTg3YzAtNWViZjkyNmZkN2MwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ODMyOTlkYS01MjQy\nLTQ2YTAtOTNkMy0xZjIyMjRiMzZmMGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQn2e1IZNav49/txnvvVOFN/ZPEJATcC698WLP2isyRVyhIBluQ6Pv6AnNZ7B4c\nO+nXymlBN3j+XarGvKiTj/zto3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRglFJM0Ti4jV1a\nGtvfMPrvYPPs4TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAOSJ7OiznXIyVbh9gWrLsMjMF1TCfy4ibqTdcJEQ5t/SAiBrdwG5\nrf2teS+EEKven0zNKbZWC5SK4NfbRrKE7/d9sg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7814", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7814` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAfhEHEVVa1JLiYtDZQTOXhRoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlOWQ4MDU2LWU1ZWYtNDc5Yi05NTE5LTM2MjNjMWM3ODNhZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRkYzNlZGYtMzFh\nZC00ZDU0LWIzZGEtYzY1ZjdiZWM4ZGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGv1WsnZL0fOBRkmp8kB1AT0dSLOSfGvooEke8fTecY3guHzQWy+UZ047KUz8\n3sMslQILMKU4JwjloLI+OHn3+KOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgtblzRbGUEpZ0SsiAA1lfzQ9a2EwHwYDVR0j\nBBgwFoAU8LwHLStj7NXHMkk1e2uG/N6ebIswNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiBd0ojzSwneE2eJ2KEudJdmCBImX9cihFafAAhnx1AZCAIgLS81B7g1lcaO\na+4ZqdrGy5LA5vuVKu5RPLV8bTROJjY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXla+sNB0FxYekxIhWbr0NtuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTlkODA1Ni1lNWVmLTQ3OWItOTUxOS0zNjIzYzFjNzgzYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOHWA13s/hIpkaeIH7eYQZ/7fkgnPnjKEEpDmrqWrmAJS7\nAQFtpyfOG2ySHUNdB1CiV1v3lL72u4fXgNqfAejgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8LwHLStj7NXHMkk1e2uG/N6e\nbIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANnmr6K+Da5tCY7yocVSpH+mNFkrUi3KJtPAOGArdUMrAiAR11DxYPPd\nbdoiuh4LAZ/xY4/sSH+uQ3vsVOyj+8xl4A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAbm3Pf+4FjvOvqSW+nf597IUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRkYzNlZGYtMzFhZC00ZDU0LWIzZGEtYzY1ZjdiZWM4ZGE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MDA4MDEyMy1mYjAw\nLTQyNDEtOTYzOS0xOGY1YWUzM2JlMDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAST1cFr6BBbEBKksiMwALF1uU8W6lxr9ovhSRGaebgu3+IanOvRtvajXH+6kAg8\neCylIpSdKLFlPUO1slA/zVBvo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSC1uXNFsZQSlnR\nKyIADWV/ND1rYTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAOeYWgouwDRpn1TdWAobU+8o7A1Q0w+uXOCc+tBYJq3RAiBIvDzf\nI21PtqCSe3St0DcXBSz0JQ8/YQG6IGLNJNV3pQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7815", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7815` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQntkoCWYnngBMG8jbXakHmoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiZTM1MDc4LTU3ZDctNDdlMC1hODMyLWViMzM1ZWY2ZDNjODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzliNzNhOGMtOTRk\nZS00NDQ0LTkwYzctMjM5YWVmMDUwMzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt/Heh5BNAjgkobUH3497p5v7y5Nxm6ZBnkZ7DHlzAe1sAIYGWVybsiX680kD\nzZPTKJOmJ0qHRucEBarmDeY67aOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmmhgTN2TPzc0FP36287BMZ/yVEwHwYDVR0j\nBBgwFoAUhD2ucNgAwLqcNfV4l2ENyxRCUyUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA+Wj1dOiCMOFM0aYOqOfOVdEFzdqIsrONMp0lx1L+nnQCIHyMUeH5q/c1\ntgMCP2csqnImctEGcLaTD/eywDrPMS/G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd4hF9zHGfhcHfng+cBviSBzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmUzNTA3OC01N2Q3LTQ3ZTAtYTgzMi1lYjMzNWVmNmQzYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOM9y+ICxNiNwd/3kzoBawOXHiCbkQiqtXqWiSl9+OWVYm\n4nVxMqvsINRW5rcsBnsDsdSP28+gEvqz9YwuK5QKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhD2ucNgAwLqcNfV4l2ENyxRC\nUyUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPzxq7S3ENHUx5+cOeLUwTMTgsAlX8MQHAtGR12VVTJ/AiEAqXM774PE\nZq2ni5n4PdDgSu1v52YHm+rYRxbjIsrrpq0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAQeTusOkwlT0jhn3qvbVg2JDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzliNzNhOGMtOTRkZS00NDQ0LTkwYzctMjM5YWVmMDUwMzJjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmOGE2YjczZC1iY2Y5\nLTQ3NDEtODEyMC1lOWZmMThhY2FlZmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQUSBfXUMi6yvFbtM5xaC2kuNiudJP32OOGat0Lrxi6QQKTn0ULWzwlOzOZX9+e\nNeEiyjL3zAiQUqFHEAPMR+Bro3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSGaaGBM3ZM/NzQ\nU/frbzsExn/JUTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAM0zllKWR65KllZNwg5yYeyyoTKxSItmJWzokeRdtyHnAiBvAFAz\n8zmN2vbLM5NQIiGxMj8sVPGgwzEJhPJGWnMw1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7816", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7816` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAb39PMhn4ZT9hSoeXs6rJiiXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhMmY2NDY1LWExMDgtNDQ1YS1hZTU5LTBjM2Y3MWM3ODI1YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZmODc5MDctY2Y0\nZi00Yjk1LTlhZWQtNzEwZDFhODMzMTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIxTxyERmZCP3Ul5N042KVyjy1t0oJAjxD8FzPxA1eFPIturkkHGwooH/yqaQ\nxt6S6kPPgD6YHgTzkqiIto5Z4qOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxw+rDymQpXY9mRYTOTJNPxRvvbAwHwYDVR0j\nBBgwFoAUS0dKOFcKRxppHhYTaJfl5x+bAHcwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiB/\nO2ig7ikyXNE2RI7pZXGLX63eX7hJRSXEsIdujnqkVAIgATdsY3fiyk2GtHGSFW+1\nhV6kUfYrCYNVvTqjwfkdT80=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQIzLJyDsqXSphazmNk2d/iJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTJmNjQ2NS1hMTA4LTQ0NWEtYWU1OS0wYzNmNzFjNzgyNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATO3Y6R9H9KYuyXxxDeGtZ7Z5m7DVH0VokoXkchT7AB9INH\nPORmkEIBulk28q3FiffBL+ZVRJxVEM4jVSfxcac7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS0dKOFcKRxppHhYTaJfl5x+b\nAHcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANm+DIb4uxt/9/w72CV+nd9eZik4UkH/lJ8O6GjHvopEAiBMpary394A\nJ2m8pPbski1db0MavMVD7phIomz8V7LS1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAd8nn83Re13DhoOGbasjOTu8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZmODc5MDctY2Y0Zi00Yjk1LTlhZWQtNzEwZDFhODMzMTBhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMGQ5ODNmNS1mN2U4\nLTQ5ZmQtYjI1Zi03ZGEwNGY4MzdmODgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQyc79SgzMKVyjQiwus3bvj3vSfcoHP9uZOTsLFU0oBOAm6LQti6g2HFX3/X1SZ\nJYiXEj0bz5HduQIm1ePS9hTco3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTHD6sPKZCldj2Z\nFhM5Mk0/FG+9sDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgEdx9Z8ml9Jv9fxlmoXBVzjnSisCSmDK6qr6dv/ZA3MgCICWCEbfN\nIPNpd46SnaNBpJZEtYuqYQghdxwBsR+XzW0k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7817", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7817` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAgCgAwIBAgISASghGBIvD2ENsYqv3trEYeE6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkODFiZGVlLTM3M2ItNGU4OS04ODA3LTYzNzM5YzdlMDQwYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDMxZTU5NTAtYWYw\nNy00Yjg3LWJlYjktZDk4NWMxNzcwNjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsNhf2z1GGie0efvgUq9yoIkq1XEgJoSDp/zv3oy32siRIMA2wZcIjyK/aKAH\n8JPIWoKmYkHwhqsDJYRKDzC4pqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWhR+FohiL19ZsjNXF5NwqhZD6wkwHwYDVR0j\nBBgwFoAUkO50HQsxXmC7UFvV3sqRdJzDSE8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNGADBDAiAuHcziT39dhpZeFp4sn6up89dsNTWXROWPe/v7HVbPZQIfCzk2\nnwkfZxhVhxwcSt0n1oLhxevSfY7HBuK3hKFcyw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARbSLeOfbs97gcjay5cCrj12MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDgxYmRlZS0zNzNiLTRlODktODgwNy02MzczOWM3ZTA0MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaIp5k5tMA8WwEthCr7ciqknkzBGVenLnWpu2KeHOFcTK2\nKtANFdaxV/3KnS8OzLGUR3fl4aJdIImcL5VTULd8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkO50HQsxXmC7UFvV3sqRdJzD\nSE8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEA/FfcME4zT8y6XaxsnwVT4DmqrUvKdJoSd4Lrezl7gCIQDBbSv6U5w0\nxaxU8OaaSN9D7a4JERNR3C4ix7EX8NkfYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAYIeDGM70icwCegAWnYmN3czMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDMxZTU5NTAtYWYwNy00Yjg3LWJlYjktZDk4NWMxNzcwNjAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYmY1NmYwMC03ODkz\nLTQ0ZjAtYjlhOS1lODhlY2I2MDhmMjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASxfDk3I8lrJVzYaQsJ0bDnDvUyl5ksMes5bdqMEkX73qMUHDGWma5hc7zwO8c5\n2WwuJ8c+q3Yrx4qiLk5menV1o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRaFH4WiGIvX1my\nM1cXk3CqFkPrCTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgZvJ78CRamkaIsntckPPmf0xjq8Lviz97mOnhGwQ8RXMCIQCzs+cv\nnT7kVZuzXAfJe6ZjK+IdGmZkbwbxSTwJDrSp/A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7818", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7818` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZqqE2Bb41JT8kEYSa1D45U+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5YWYyMTA2LTQxZmItNGVhMS1iYWIwLWEyMzA4NTI4MGEzNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEwMDZhMTctYzcx\nZC00NmE2LTgyNTQtNWM2Y2EwNzQ4NWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs5e0UTlv5BxkAMVjcCp24Zb3w6/RGIhHLq/SL+WKzrEm78HAaWPhmJUuWdTP\nc69edp56FGM2r/fJpMnMnkM6bqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqLyYjNCBvrz6DlOFk2gOSCveueMwHwYDVR0j\nBBgwFoAUlEjaqY5SJdJ3/eetutyMLa+tI5kwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA7yvDZKIrnqgqpqzhQMv7JwbSjBk3mqy4z6OsDgeHSr0CIEuG\n9wCe1IjX5+YkCnHAyTgoPNEuz9dPOW6oyMyIShQV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb6TNjymyiEddn3uUc7RU587MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWFmMjEwNi00MWZiLTRlYTEtYmFiMC1hMjMwODUyODBhMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgYKayeFKkl2a1MaOI0/lz9qpD68KDPdYvx09kX5UQTN+c\nQatpAe4X2SD/HThQns3iv3HyyNOQnlHRCfQxhfAho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlEjaqY5SJdJ3/eetutyMLa+t\nI5kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVO00q/t6+Sc6a3MTF8zK0JhDP0rBes8Pc0ufwfFa40ACIQCGt6yhvN7Q\nrLFGGZqA/ii50VI3KizGoBYti1zFRvNOnQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISATy1QVyYaOUBUUmynj5poqMPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEwMDZhMTctYzcxZC00NmE2LTgyNTQtNWM2Y2EwNzQ4NWU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYWUyZWRjMS0xZjBj\nLTRiMzEtYTAwNC1jMjdiNjMzOGNmYTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQYcyw2uVjwjzy8JGgMZwyCsGYDyK+ICngH4AzDnUmBEwlDRhXNkw1Utg4cE0bI\naIE/LwugZsHA7fz/9tPddLyoo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSovJiM0IG+vPoO\nU4WTaA5IK9654zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAIMbVwF7RLW2uEBI1ZXSkvGNsmh87FadXyA0NMfqKszVAiEA/JAJ\ndsyXAth7dK6QNSu08i+CTCv+kjpHl+iIcxy+iok=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7819", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7819` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAdgN9ra8LW3dWOAqFwc/WMXeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiZjViMjVhLWY2N2ItNGJkZi1hMzcwLTZiZGI2Yzc2NDZjODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRiMzg2MzMtNDFk\nMC00YTlkLWIzNTUtMGE1Yzg5Zjk0ZWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKQvQBqrHNsc/Oh1CTZ/5lbFW9iH7KHwBJkLFuZvodNifVb5E6oa7oTS12P/Y\nZ09NKToY4IF8g5VCBMz85uZ15aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyz9z7SKGAy1B8n8fp9X2/eR1vqcwHwYDVR0j\nBBgwFoAUMbdTJqJzx7r1v1iWw6SemFfCk88wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAlNtCZsAz9yV0\nuj7V5eeb4fzivg6tWZI8u3x//3RnKy4CIHEeD4u8z+dfTz5K237nDx4/XZoCFpgl\nItOnxhOppQ0s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcWDenARZ4+o5zqpt/DgM0dfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmY1YjI1YS1mNjdiLTRiZGYtYTM3MC02YmRiNmM3NjQ2YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATj2+MS28DMXG981F64kfnC8Lc8I+TpUSJGG6+FrVjxeaos\nwGvFdNMpz5RpPG/M/x+T6VdRlAH37DlwDrk4XPdeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMbdTJqJzx7r1v1iWw6SemFfC\nk88wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZIC+tXLMPWoyfRW/uUfy6zBbhLcKVu5JficmGk7ob80CIE/rZu+iEDlC\nNqhaR9k1OHTNqldBD0P+wulX/aMdV47S\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAeUQxnjjzlfT3fD8UWj/D8RLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRiMzg2MzMtNDFkMC00YTlkLWIzNTUtMGE1Yzg5Zjk0ZWFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMjRlZDRlOS04ZTg5\nLTQzNGUtYmY4Mi0wZGI2ZTkyZjkwNzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQWBBBo6loD+TKL76hXklE+iEZZFqo6X+L1q5H4mqsElvoDjQGXPPjqvAR9A7mw\nvfrm/gnRJv3n5JGQtbELm0YIo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTLP3PtIoYDLUHy\nfx+n1fb95HW+pzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgdnO8EKC7UDw0VqIY12K0uhYtpmnoCchZ0br+7db05qYCIQCpYEXH\nGhcTRwbnDMelIiV9aSOyNkLo2wMvsH5cnsIkyg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7820", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7820` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVLr8fUKwIT5HPm7n11aJYEcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZDdhMTYwLWZhYzYtNDk3Yi04ZTYyLWM4MWFjNmJhZTk4NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTEzNTQ1NjYtMDBk\nNy00ODgxLThjMTItMTY2YWZhZjU3ODQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm/4LbeBK0XoZlAaCnPe7NThTFVBe2BPwpSSqGpiOKFlzcW/1J4VEw9uK15KC\nYY8Ow8z389YaNl5XoYTszNrFC6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR7HbxI4R3ZvC0LgF9LdZ+9kXdC4wHwYDVR0j\nBBgwFoAUQ8PGFloksUzJ4l7CAcRfmVzuFa4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCB9Y54m6ssLkzzIGj3XDWWP9Offm4mXIQYhJTiC9hzQwIhANJjOI6bvtlu\nwhgS5wUQUVFgByj3aBuoqnBTYg/pKwSP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdrRgdPPSiYaBpkxLv+dRZ5CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWQ3YTE2MC1mYWM2LTQ5N2ItOGU2Mi1jODFhYzZiYWU5ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWW3GXS6yHTSZroZT6linebGH3lKmfE66UwiqOigFRMze9\ncLQkf+n7piS7afEJW9ssaW2ZNvZ2HGiDO43Q6a++o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ8PGFloksUzJ4l7CAcRfmVzu\nFa4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFmCWeq/gNHX8AP6krFjCI1A3Z6sXJt06iLzhL1iKJXgCIQCvcq/FCcRB\ntUqFgj1hEzjRj5jnjhECc3V5V98OjNmvxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAVTxSqjXBteNMVqqF5Vc2wN+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTEzNTQ1NjYtMDBkNy00ODgxLThjMTItMTY2YWZhZjU3ODQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MzZkODc4OS0yMWE3\nLTQwZWUtOTZkYi05N2Y5YWU2NGM1MGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQq7bDkiocqYRzZcmiQS5erQdVH4LimUD7HDSar5SIoL7H58DBZxyN1uSU8QWb/\npU+fDqNMz6OkxgAOy1/DCV42o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHsdvEjhHdm8LQ\nuAX0t1n72Rd0LjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAPCpwKKdm1ExpgGTWfu7oN6fxep0JJscHKnoiF4iXRPuAiEAvuv1\nDKrilRUUSa7CwErFZ2LkzZpqVKoOQAaLbButCbQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7821", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7821` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAXLb2tse/7jV120JqvDu8+fvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjYzNhZWI1LWJiYWEtNDEwNS04ZjkwLWE5YzZmNmU5OTFiNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc4ZjlkNzAtNmJh\nMi00MDAzLWFhYjAtMzg3ZGQxZTNlZDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaUWnr67XdZrwptFG1UvQPY5sGviHntu76OkzV1pk41umGe2kt8Fq22fdKBe1\nP/0VncuSpTU9+TH1Eqy5JRUR5KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Xh57N+LBHPlHYIuf4YbKJojfukwHwYDVR0j\nBBgwFoAU8z23FMiJdPW5nwPcHx6wo66JuMQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC5whHg/yx9hiAsTW7E1O3vZdtSO/g16EqJ9nHJ8NRPIwIhANZCRXgwJPv1\nn/qbA0+X9orHHLYI2jpwyi2c4/I4pIR9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5bcmYubIzD7WE0cYp2S5QKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2MzYWViNS1iYmFhLTQxMDUtOGY5MC1hOWM2ZjZlOTkxYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjUF+JnEoppeAdnjsCSviMo3R87kz2t9LD51Q5mp3VOJwi\nymMCPTzLFhsHK/yTshgrWj1BfpgytXMJfSB9JQb7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8z23FMiJdPW5nwPcHx6wo66J\nuMQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKOz2ed7+3r88W5FHEgERPOLwowKnTVmSVWUX5GkAc4yAiB6O6wxqX+y\nYzpsrdABesfueZHYbDSWkSdKkN2oh8pKtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAWczVx1Sn2qSb5doWyx6BMfuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc4ZjlkNzAtNmJhMi00MDAzLWFhYjAtMzg3ZGQxZTNlZDZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYWRhMjJiZi03Njdj\nLTQ5Y2MtYTBjZS00NWU1ODAwMzQyMDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS8qjiZfO9lrQnbH47dVOqe2rwX5pTG0zFTN0zT81rlECMIR89yOpKNKot6hXPy\nV2/V4TcC3y5jBhQLueePJdmYo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT1eHns34sEc+Ud\ngi5/hhsomiN+6TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgfu8bu3PuZ73tVe8bpxpB0/qqRQJtXbCMFNjGoZF1CF8CIQD9Jax1\nHPLhkx61pZjzwnwxJLLgsRvja2CAYdGfPAKtUQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7822", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7822` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAULZyHVUYzKLqbfzvpe1bpuTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzNjQ4YzkwLTljOTctNDllZS05OTA2LTVhOWE3ZWJmMWZjNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThlYzI2MGItMWUz\nNS00MzgxLTkzMzktOTFjZTlmOTU3NjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsq8/9rgGOzQIJzskdaXc+q+y7J51UxzMEhRaSRBffGybErWrlLbsWKPZsEGa\nvYADAeBoakSl42HUjoPRfH3pYaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj8uaHmimUUoW0M8rj2U45iIuy8cwHwYDVR0j\nBBgwFoAUf+6aKwItGVglaBPkvCzkPRZD5ZkwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAhr1FXnxLPaEKnCkrlZKoqjTy3LuI665kf66K5VwfMIMCIQCMJWKP5C/K\nbXySGfYvHOkkcEKTFIto9O8JDSRtpkSJDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf4eEN9QQ7MuhQUQVEt+ma6/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMzY0OGM5MC05Yzk3LTQ5ZWUtOTkwNi01YTlhN2ViZjFmYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV75PSYC9D8pLGwkKzYuUP+wUh0HhPNZ3o8d7L1GgGJaPR\nxWu69XgYpVzM7PK3gNd+hm24vRJmEBGnTN68V6BVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf+6aKwItGVglaBPkvCzkPRZD\n5ZkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVWeJndYiUe+ddPQnkZaV2PCxsWovcMQcr6KzUVlZ5oMCIBVWUixtK0kP\nEzkjRPCmoovbUOqrVX3ekqnOfRs7Lbfx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAfgnrvF+CNsM8gbZ3+joyrPGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThlYzI2MGItMWUzNS00MzgxLTkzMzktOTFjZTlmOTU3NjY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNzBjNjBjYi1kZTY1\nLTQ4MmMtYmRhYy01ODIxNGQ0MTA0OGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASKeEreOmyLd/2z8vsG1pasDWVs/9dPc27QqyMOp3NGICBeQPLzDFwARrpuV7vR\nrb9mmHOIK5cy9BFqf88lDk5Ko3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPy5oeaKZRShbQ\nzyuPZTjmIi7LxzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgBlSCVAUxKJrougwvavp+vKJCrjkly/2mt5uQrwq0MlMCIQCJqAQm\nfRBXsyA9pper7h5dDPdSqdxa2XLlrBlUbwoXGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7823", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7823` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISASSkViymYQ0hoG5eudlHmJGgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmMDZlYjU4LTNiYTUtNDVlOC04ZTJhLTFlYTU4MjA4ZTQ1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgxMDdkMTktNWM4\nYy00YmZhLWEzNDgtZjYzNGY3ODMwMWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6MdO0bj/URqMS+BOfo1znr+PqfWXZ8/b5dV6NEJ+UVaC0l15CsuioX3zh+hX\nScVlyWCc5dxtHyHRjzZIonlcIaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0tS37wiYAouqJAuuK9/rD576srcwHwYDVR0j\nBBgwFoAUzUjbplOE9V9JKrAIBtNxbnj4FgAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAlGDkvHuiZy+G56vn5cYCQsgQadwXiN0MxZ93Pzl1\nqZQCIQDlacZMGAdzOcCwRLgZ6cD/o6Xn89ZD0YU3lF0VQ6HI7Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXXuc7QQjPsExGdpSQBUJJvcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjA2ZWI1OC0zYmE1LTQ1ZTgtOGUyYS0xZWE1ODIwOGU0NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAu1Bh6YU1TC4n7aNkMinGgs2/YttKNsWSd3iB9mjTWUJ+\n6iTI02kCc3V3Ye61OjYb4+kK/Z7HnS+VuVLCjHR0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzUjbplOE9V9JKrAIBtNxbnj4\nFgAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM6kF7JQ7nYZTsXEK9dakhBr6sWVRmRgOxicu0fy+fHjAiAHklXaQScH\n7yXcBH9tLjWN9oDQvvPjaJigH7HUCU1w7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISARquF4HSi+v1YpbfnzMB+2VwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgxMDdkMTktNWM4Yy00YmZhLWEzNDgtZjYzNGY3ODMwMWZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiZDIyMjEyYy02MjM0\nLTRiYjItODk2Ni00YWI5NjliOWYyNzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT5gqnwZYP6REtUDYApLtDSe57RJYFUTiphmcVyFp4zu/uyqXIvSn5rcsDqYv1l\neN/8QMGIGUwudz7fKrP0M/zoo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTS1LfvCJgCi6ok\nC64r3+sPnvqytzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAMFbvPIjoF6PjWQ61idAJTYazWwj06cNzM4VjCoD02dcAiEAyQ4l\ntsBSA7D0ruVG0sUHcGflzEuCrsl0QWLdcwNrK3E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7824", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7824` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISATw8I+2g1VZ0ttiUxu0Gh167MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0ODA0NmE4LWRjNzctNDRiMC1iNDQ1LTRmNmU5ZjczZTI1ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc4YWViZWItZjY3\nNy00ZDY3LTlhNDUtMjNhMTAyMGY5YWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWtOP6qd0rczgBBU2VDwH5fLxbal8Jydcmvzqxgor7jVPrzBNb5mZXGljxmzS\nFOUDWE/SxOEZFWLmXY5TtRTCT6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm/bv8pUO7W3WJ+aplYXvsZAHfQIwHwYDVR0j\nBBgwFoAUKmEMt2p2/HV+s8ocbikOHAOAyaMwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBU4VMTJUyIvyEPAI3S3uvL1YpJP86MONvbMI5k+TXv\n/QIgYsjpLVQQPxAyjQJEL/8aBr3PsP5nkdA6SCjBSZ98Bq8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfOMlo7HB/HX0kGKfQYnU/YCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDgwNDZhOC1kYzc3LTQ0YjAtYjQ0NS00ZjZlOWY3M2UyNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4xVc0ledHSbHwjd8BQzQGl7wG6G+SIZ0aO3pZAgt18l+A\nJUiNmH0olq2esjf7N6QxwMPnPevjCL+dNJBVZUjpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKmEMt2p2/HV+s8ocbikOHAOA\nyaMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdb5uaAjSvFiVK49P90teDGYEGfpiYdNJECMjhWACETgCIQDARWwSpZ+h\nOtqxH14jRyoFyaQRnngD8pdR1ZscKRVuIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAbD6EG/v7mftyCIgQ3LzmcTaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc4YWViZWItZjY3Ny00ZDY3LTlhNDUtMjNhMTAyMGY5YWQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MWQ3ODFiYi1kNGQ3\nLTRkNWItODVmMy05ODk5MGFkYzgwZmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS1v9HW/xTYAqxA35Gi5KXBOttVjleM9I9wexv77oQgCBKlxZ6kcSpKUm2IBE4D\nog4N98MOVtup5e5jCttys5+xo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSb9u/ylQ7tbdYn\n5qmVhe+xkAd9AjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgb49E34Pb/ruhQQSOLsjqw/aMR81+cwCyM4YWZy5x5BYCIGIltpRN\nwpB5oPA8AzeBYfzeBwcdBdEg/AKd3FRK1GFn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7825", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7825` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVqLLNUCXigZRiZ91FlOUn99MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjZGNhYWRkLWRiZGYtNDg5Yi05YWE0LTQzNDIyMDE0NzJlNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZlNmMyMDEtZTRk\nZS00MTA4LWI0NjEtODk1NDk2MjFhNDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdGIDA2dYAVUQPvu/mKucBkwc47xoDYebJBL+CPq1Ir2on0/xJpH4IOuIOhxq\n6geCd0SIQKRbjSpc0KN4ct+peqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5DKZ67plA/mzCB1PMduF+RfIpIcwHwYDVR0j\nBBgwFoAUqAOaFYKzcyP0M1rxwqruHiKAqMwwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA+lZua3Rcvuui3AQwAFzJnPbF3h1kQmnRY45iaiU9kGQIhAJa2\nZIQhjqYN8b4kA2EUp0JzxE9wivKsi00p0phmS1ul\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXlwbAIi9rpFBvNWW2SJajfHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2RjYWFkZC1kYmRmLTQ4OWItOWFhNC00MzQyMjAxNDcyZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYIAQHTtAGFRqg1NoDD2ma4MXjVI4RpjJ9Q28OuJDBkiYr\n/zKJ1ywVGrt0q7n259NJKAeOVtucee+eYVLOffEgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqAOaFYKzcyP0M1rxwqruHiKA\nqMwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSRX3MWX9Iydfx8wAv3ApIomXLOTCpO4o1cxBgpm6UBACIHkuXidX8Bup\ncgTHXV3oi4jnDf35jP1E3daxDU1ZdBkS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAflFfezSWzKh+OFKW483zvikMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZlNmMyMDEtZTRkZS00MTA4LWI0NjEtODk1NDk2MjFhNDkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYmJkNGY4ZC1jMzYy\nLTQ0YjItOTk1Zi0wMGU5YzkxMWYyM2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASu8Zx6r7OVsydytEaV8Lceuh0AuhLnQB8hkH3UFwosKZWC0DPHsOpcjm4xxx3b\nGOI7JFfhmCRuT0FJQbX8QBWmo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTkMpnrumUD+bMI\nHU8x24X5F8ikhzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAIFEBLTSIOURMzdkCtOErNLdwYzUyswTLGSLBbzXBm1nAiAlkOVS\nVNPMVCjgum+cJYCC8CgkB8yfkZGPBtDs8TPT9g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7826", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7826` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAQctqVOJ3MYd0twXHQgNDA9fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MGM1Mjc3LTBmMDktNGZhOS1hYjViLTVmMTg2NTZiZTIxMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTcyODNjNGQtNDkz\nNy00YzRhLWJkY2UtNWJhMWU3MGFlZGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3Hq6i0XX4saXJJZvo/twUggctkoBzDnXFXIiHA3MFhHrfR+bzP9G9hY/9Qhs\n2Ev/ktWqHhcm9lDD9d/olhr3+6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfkpCIvFIv87BeUxJDEEEo5+bU/cwHwYDVR0j\nBBgwFoAU/JVcmByO2aU3sn3awcLcoNJFimAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBCE8CLi5dSizInfjos4aXBKy3WJnmDcxVm\ncA0PmnKw7gIhAKMLn60RnmMemkUl1x8V1FT8Q4N44eSBLbakl3goXyHz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbQqLk6TvADHdldoa7xeLjkuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTBjNTI3Ny0wZjA5LTRmYTktYWI1Yi01ZjE4NjU2YmUyMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKrydTtv9zpBsTdg9VtJ0cqNKD9hwWhvx7TTVHg4iKK9hf\niybO9DxPsBzYiyig7Gi3+xsbjYbYpesoPrt+ThAMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/JVcmByO2aU3sn3awcLcoNJF\nimAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX8Gh49Gq+qmp0Jn455BpA3q5blhhLK2/9bz6qUcLhf4CIQCemxS2S6WM\nW46aG4kgzXeeUyDLAFlcqobMHJ+h0ku5Qg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAfciEQMe1ClWbBb3H+EuK10eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTcyODNjNGQtNDkzNy00YzRhLWJkY2UtNWJhMWU3MGFlZGNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MDI5NTA5MC1mMjQy\nLTRmMDktYjRiMC0wM2RlNDljOTE2Y2IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARJhqqW495G67oO3Hi98lGlocxgz1xAt+QGAWizRXin0rpau+Uv+s9fPzKRPGFP\n7/NcdGxHlmiEOdvjLRRBu7oxo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+SkIi8Ui/zsF5\nTEkMQQSjn5tT9zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgZNdWN1QbFvOdJkDvADjvMskz/mf6X8zDjuyB1I8hvpMCIEjbzhLv\n+fw+Qf1Cy1wobxnlI/YWmWsQtO88T2CZXpCA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7827", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7827` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAR2Tyuo/poYwE+YQSGCGRuA1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNjA5ZjZiLTAyYWUtNDEyOS05YmZkLThjMGQyNjEwODkxYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVlZmIyMjYtZDE1\nYy00ZDI4LTllYzMtYTUzYjU4M2MxYjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1JYSon3zEn7a7Ls02JgHh0re9lTWlxCzpEJYsAmngzXqWWYUIExXDRFS2gpw\nWD61ffWWstw4wjL+5sP2rKdfb6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKNCbENZSwbX5ctENNLMJsIlSn1EwHwYDVR0j\nBBgwFoAUHw1NFAQP+DPcdnpCUFQs/pOCPXkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAOMQfSAJlC4ZwdzNVIg7qAUmuPo8f/to++\nAwcLwSY9XwIgVsKUS01Zd6X6K1YD5I+7Wv3MQXhH9Jllcp5Z41tk/+0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASFtQjxSCJopIW1fAA8x1s/xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTYwOWY2Yi0wMmFlLTQxMjktOWJmZC04YzBkMjYxMDg5MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR36gYuo0dnmqnR/oEoRIGMKGIX0sUx9J/r0669ZEbW4eww\nfVg+gXcoZUAQepftJHBFxPQyf+dlvN8LEivkZpxSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHw1NFAQP+DPcdnpCUFQs/pOC\nPXkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD9+LChSl0yIFQDQ4dR+gFQnG7l4vd+DUp4UHFsq3hSYCIQCWNkZ5UyKF\n22nJP8gPrjYpdsD0yZHBR0uUeJ58O20Olw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAY5yhiVXu++ZODxv1NwQCZu+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVlZmIyMjYtZDE1Yy00ZDI4LTllYzMtYTUzYjU4M2MxYjU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MTkyMTIxZC1jYzEw\nLTRjNTgtODFiZC0wZTI4ODE4N2U0MGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ+aEjboovsnbRoUB2OwU3tTRU0TiJWooxowP+niFbABOSrrAfzozLt32T3Z6N4\np2kJHBwxnDwTd1seTLNd8yZeo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQo0JsQ1lLBtfly\n0Q00swmwiVKfUTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAJLNScT9H9dPHS3vYVoqsAL0Ecow81l2IepmnXBO1bxMAiEAo3E6\nO6VhMe3+aqzr1s+S9X1yGwDeab0tlGcywUdie2E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7828", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7828` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAW1+++DIEmVi1JLD7Rxr1xkkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0Y2VkMWVmLWUwNzUtNDQxYy04OTY3LTBlN2Q5YzdhMzk2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGMwZWYwOGEtYzc5\nZS00NDBhLTllMjMtNjJkOTU0NTAzYmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ4LiVChx9kh4ePFNX2rWtaQ5TjHyJGSko8NErBcwlj8l9LwAl4XYaEDVAOtW\nPYTZHSXf5HOulMGd2lM+Owx246OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUU7Kv42fsuAzaNIFVkJW5XEXaO0wHwYDVR0j\nBBgwFoAU6pdo6wBecpiIWMRUJhMNmBjBUKgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA80xJUxet9JZ/\n0OzbG1XlIfMF0TgknjUkXzMdMRdyfxUCIBAa5Vybt68SoJoqRLBGzI80GYgm0wh2\n7NHk/+y/44MR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUXxzMqx28h8bSqRXp3EkF0IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGNlZDFlZi1lMDc1LTQ0MWMtODk2Ny0wZTdkOWM3YTM5NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV5rXuLQzz6hy2xwhtCvLLetAY1B4/bZZ7HJtXSIN5UnOD\nHxQMVjQIldHliafrjeCuxO/GUVabm09cyFJ9pZ/Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6pdo6wBecpiIWMRUJhMNmBjB\nUKgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPtcIssSPqH81TB23ZuMQfEAdZgAqDHV/2qeZHQ5+mnRAiBYAwsz5Rja\nvPUC6F8saRtFb38g0KM47NhuhcAqrWtIAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAWUH/sJb3iF+AyZIkQjNmYNAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGMwZWYwOGEtYzc5ZS00NDBhLTllMjMtNjJkOTU0NTAzYmZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNmRjYTE5ZC05NDgx\nLTRkZjYtYjk2ZS03MTEwNDZhZDZlNDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATl+GIBHRZ4y9iGc1slmE/ltJI/swUAbZ7Zcc5gPCV9ZKJ0t3PUZXnIj9CTW6zo\nrIs+YE3xIDGNoZVuRVSez/Svo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRRTsq/jZ+y4DNo\n0gVWQlblcRdo7TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgfstWpplN0XI+qiSi8r5kXXW+lb/FZSbje/C0Z9NSKVwCIAMFqAjB\nw5gpmdQCc1pPUm2q2B0VM4LvufpJGmHHRCNw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7829", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7829` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUsfSKo4mMKT4QFT6KYkva2gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNTE3NTZjLTVlMTAtNDlhMC05ODRlLWFhMzA2ZWI0OTM1ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2UyZTZmOWItYTUz\nZC00YjliLWJjYTktNDg5MWMxODg4YTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz2BjMPHud/L0NCsYkeVgEkm00qDiBKLrOiklNmc99ZRX2xOvSvdD63xlGSAk\naNjpUKDEvZRfg6NHCr7++WNVrqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhEr5l+reAMGdw1X1ZmEuK/QFmmQwHwYDVR0j\nBBgwFoAUFxUzRIJJMoYenfcZRUj1vqPCRGswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDgJEhOBmGR4/F0bd+5stTSYaePes5f8zY0vm8e4HWrWQIgWxl++rnFm373\nSEh4x3ez4vva7TtHynJYOodXc477rTA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZWO6F708nhX38c+oWaZYHIQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjUxNzU2Yy01ZTEwLTQ5YTAtOTg0ZS1hYTMwNmViNDkzNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBrwuM5e4fP3+ZMTKSwJ1iYPH9W9SR83NW85NSSit9UMtq\nGAlg9RLaMqr3WZrvtS7K8LD2UZoBfXRfSND8hR+lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFxUzRIJJMoYenfcZRUj1vqPC\nRGswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM9k4EhCFme9QN6zWNO+M/HVw0yiY6ghZIbYpIkoSBrwCIAjCQmIWC5ik\n7Qc2h/W/zL12wounHJeVqJNb7LLd7eSe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISASEJTlz3DgM7tzyTyjsGaQHGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2UyZTZmOWItYTUzZC00YjliLWJjYTktNDg5MWMxODg4YTczMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlOTg1NTFjMi00Yjdl\nLTQ3NzYtYTliMC01MzA1ZDc4ODFjYzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQOAKzOcSk/lQ65v4waKNKoKPTBd8sBjucAwjofx6OKWHOk/9GCZo4g7vzynVY7\n8c9rhDejkawFKWyU/Szin55Ro3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSESvmX6t4AwZ3D\nVfVmYS4r9AWaZDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgfKM3PIvw9h4S9Tk8RJPN4CoAxscankgYW50923x+yhQCIQCI1V7Q\nJTdgP8Lvm/ZHb8bEWYltcySQlyanf7rCBgw+Dg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7830", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7830` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUyqmIXRwG8jgeduIPV5sy5KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYjIzZDJiLTZiZDctNGU5NS04MjU4LWFmMGU1ZmFjODRhNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFiMTVmZmQtY2Vl\nZS00NmI2LWI5ZjYtMmI2OWU0M2NlNDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW0zOEvPW1g3HOtbsKQYVbperiEpPcT0NlmIhDsS1lmairzI0kxVgME4gzU38\nU74g9yOpb2OIWRgHFIBH3BIFkaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzGkfsKHkQfT8uWfu82+0ld8CXDswHwYDVR0j\nBBgwFoAUC3fOnCraKIOOSZCqR17qqtvyhmEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIBGAIUgoh+oLIrkCJEM/Ho4BMJWhsDTqhwSNVlHXOrDFAiEA55CYyOPgM6q9\nCDbSnhLYaq10PmFJ6F1Mtr74rS9qwb8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQvVFod1Gp/IUO77qNnQylqsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmIyM2QyYi02YmQ3LTRlOTUtODI1OC1hZjBlNWZhYzg0YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHo1mNTHGVm8NqgVWvLKSNVSeRshYZmArLUlUkasK3ypb4\nKjvoOX4hFkmzEwS/oDDTPcPpLZzU1IgHTQlO/ckUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC3fOnCraKIOOSZCqR17qqtvy\nhmEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC/S491uuHogCFit2pa8nJa+V3laoqEsvSa1qI8V7iXcCIHKZXNWS10ki\nxLCY9QO4iAWsypQxKYOOeTcbPnq1L/Xw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAa3BFC8OYDBSdz/Yf49b8Wa0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFiMTVmZmQtY2VlZS00NmI2LWI5ZjYtMmI2OWU0M2NlNDlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxODc1YTVmNC0zZWJl\nLTQ2ZjctYjExNi1kMWQ1MzliNmNiY2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATCO4i3T5NrvWZGI+A5QULQ9kaFrQxWa+c/92IfsgMVGTnONLo9QUEc5eGLLUON\nc+vfmYEJXQ+u0i7S1Y6EzgSHo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMaR+woeRB9Py5\nZ+7zb7SV3wJcOzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAMTgQlITnuwhbZGep4ReDUInyso1pejfQI3WTGhNd/sCAiAnmfL+\nlE3RD3nEXlJL9RunbTTavpPfvzxRiUPyJ1cYzQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7831", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7831` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAchsB95jEC8gkZnbm16iSm0+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MDNjN2EzLWUxNDctNGEzYy05N2QxLThmMmVlNjZkZjYyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUxYzVmMDItZTE1\nMS00Y2JlLTkzNzktZDU0MWIxZmM1ZDZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0fMxagecjVXTdbPsI+/0TM8ZHgq5ce0ATUefaK2UtFxsqnBlOvQUT3+XiUpi\n2tbcrteEFpAsCB46aBknCbsIEKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs3IWEVzl3+6fDXo86xEtX8YfoE4wHwYDVR0j\nBBgwFoAUrk/STsikbO4EZnF1ma6irzW+TT0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAyVvy3YxjTXsPP+8T4jDSOWOPu4oyjwer1oL5AkGFPcYCIQC6MFFRebOu\nl5MR0Ed0bq2PaCSXQdc1594up6xedCyWEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeLpG5Qo7F5IDMtTCYIZMZOVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDAzYzdhMy1lMTQ3LTRhM2MtOTdkMS04ZjJlZTY2ZGY2MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIeOR+Afm7x+TEnex0YMDDJOe34yWiPXTkpH+haNrOHwpn\nx+8RADeIfjPgc8BuICnhreh28pkpN+JdwjwVO+8Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrk/STsikbO4EZnF1ma6irzW+\nTT0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJEzlW9ysMDPYR66c9Qbzqlgo5mTTas6ClDsgRYXxdUEAiEAjGznmEXT\nRKAirlC/rNJkrXuGK/tjvGrt3+xzQW3EUGI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAR2vHCPbMXjhXMIREsT/OIvgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUxYzVmMDItZTE1MS00Y2JlLTkzNzktZDU0MWIxZmM1ZDZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MWVhZDRmYy0yYWQw\nLTQwM2QtYWYwOC1mNDQyNDNlMDhmMWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASOvrymgDkdTxIVlOIFUeSZafzwUUdtx7/GNofJ9uIANeaHZqZrNLpEJE1I7+lx\n2Ph8UEvLQjzLKYPVHF5RokECo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSzchYRXOXf7p8N\nejzrES1fxh+gTjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhANEpxoOzB0He+R3fChqqGelTxhwqFfa5uYnET4TdqNo/AiAZl4An\noZCL9i2vyIHuZhPp3QhakCYLxEWYcKXAMgt5Fg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7832", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7832` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAdQIag4+aZZaSfO1fKlTN6JnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2ZmMzMWU0LTVkMjItNDQ2Ny05Njk3LWFmYThkZTU5YTg2YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJjMzQ0ZjQtYTYw\nMS00ZmRiLTliYzAtNTUxZmIwNzQxYTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg3Cnl8mGP5Lz8QnFgPL1a2P4EiYiGUwmZ8oIXUD/YL+MZQmDvDkXXoJItVK3\nJ1MADnUDGEZc+Pk2jE/ByCs8gKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPJO1wsbqd3Sgdeh1DGF3i709mxEwHwYDVR0j\nBBgwFoAUOBYJjSdrdWM1PjG+0SWZL7Dct7wwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA76mCi0jEise1nnVk4frJh2n5JgS0q/Nf9fmhX9tK\nnssCIDxEoAErjFIPgc5ViLtlQcYCRXFp4NUR+hVE18Ia4+I2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS/G6XqveFX1xPhSxPEIkXggMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmZjMzFlNC01ZDIyLTQ0NjctOTY5Ny1hZmE4ZGU1OWE4NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkT1JTtnjleDOs/7VfaNh3XODSLxqelXF5IbCJ75MOfxW7\n4aVe3xMp9EEnZ37ENBcSTM539sIFkeeC8pMGU7pxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOBYJjSdrdWM1PjG+0SWZL7Dc\nt7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN2ZM0LTxb/uGvhLjMFmmKzQD3qhMDx3p4c0S5F1fwllAiEAnZHWtHTD\nT9Re0qvGNuTiNkl8RG99Ru35RMGwM/GkY2M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAfZCLMgcYg5L2ITDRU4nSxOJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJjMzQ0ZjQtYTYwMS00ZmRiLTliYzAtNTUxZmIwNzQxYTk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0YjUwYjM1MC0yOTg0\nLTRjOGYtOWNiYi1mMzE5ZDBiZGFiYWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARBpoy1qQoF6BRozwp7Onpk9wcigGf4I2KDzm8EwK/AaXy1P3OsrDouEw4LEhRt\nmI2aRrKeQFM/EZXlWCGJQCxEo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ8k7XCxup3dKB1\n6HUMYXeLvT2bETAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgM27OIH+81qYuuXJqGvsP6L15PClCDsp+jR7OXdoIFeQCIQCAZ6zF\n03R2pnRYD8G/aXPwcH1Typ0ImW+NKDPmOJOA8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7833", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7833` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAVMBEHZijEkmrfqRkX4mV9pzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2Y2VmYThlLWFiNTEtNGQ0Yy1iNGJiLWVkZWNmODhiYjhhMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE0Y2E3YmYtMWQ3\nNi00NWFlLThmMDUtYzU4N2IyMGViYzU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBgZQqqR6ZDCvBsF0CcLuPiKINr1YvRYpeXsCL1+xpgujVmWeqFJxsX1mPbL8\nAAstvQAMVkCO7xXjKxb8UL2bQ6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURpXdea92Z2/6PHPNqi3NhvcWrkIwHwYDVR0j\nBBgwFoAUWOfzkvAq6sOy+7oktPT3owNC+N0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiA32tASlC0EAvLbF1JfDkP9QBtuc95IRZKA69FybDQL\n3QIgZgWHsBRryAmKlzIfZN7wN82Z2LRR1Y9Mgzf6VOl5rww=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWpMqhYSmxYkHBZBWqcpj4LJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmNlZmE4ZS1hYjUxLTRkNGMtYjRiYi1lZGVjZjg4YmI4YTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASx0zVLV6zKFASETKNE3UxHBi5f/B+QYB3gKnkQLxaMeWZO\n3UkUF2KPUzjIUuROpFdmENcnZCmwfWlVWUcdhWNdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWOfzkvAq6sOy+7oktPT3owNC\n+N0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIAfBMCxhjn1vjpPyJ25d96XZbblYp/mBGUv46mvrguxAiBGkuNBVPEo\nB53+n0mdw9ocbxb7UumYP5GQ+bSWVuzLew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAXBKMRkdpdp2eEjHETOnCYtcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE0Y2E3YmYtMWQ3Ni00NWFlLThmMDUtYzU4N2IyMGViYzU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMzg5MWFkNC1kMmI5\nLTQxZTItYjBjYS0wY2ViOTc2MWQwNTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARWRBoh//FF9JwaopPNeDCiMNWazZYMKygwxIzW7GnxT277TbvchLvo2jf7uePb\nEdHRZOSC7kPxgcWMn5clH70ro3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRGld15r3Znb/o8\nc82qLc2G9xauQjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgevySpNWtZDnOjNXvycVD019E/3pRa4+xKxn/AowZJAYCIQCugR7c\nQumVNiGZifJ4x3PhHqRpKzMCeM1zeLq5e9RnTw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7834", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7834` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAbml1yTBMmxvoaGh9t0HaYHoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4OTI0NjkxLWMxODgtNDYzNC04ZjVmLTMxNTM4ZDQ3YjVkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM5Mzg3NzMtOGFm\nMi00NmNhLTgzMDMtOTA3OGJlZjk4NjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbWj7vl87mJG1Mhx0lhvzJj7D7TRTILlaN4XAL+z9CrjOBj/2kLqn7YT2CIcE\nn5endyLsaTFiK/7RslHwySnnzaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUAX7N7ftoz2D1Yvynfj4Ajk6XRowHwYDVR0j\nBBgwFoAUV1Wzt6MCd15r4b0b0J2Gt/8kloIwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA3S7eA86M1KzZUNf9E8OzIx5wrxMDIGQoz8xTDEdgHIQCIQCA\nslEYMxX9uK0Y9xidpeKKnaPafgB/hEZy5R2OIHDFMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQo17/7COcK/R+FCPw/SzVioMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODkyNDY5MS1jMTg4LTQ2MzQtOGY1Zi0zMTUzOGQ0N2I1ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZVg1WlxFbGxM8NUJX6CR1VCF5mizi67OUCdATtXnKydu1\nU8xeNUSH5jgKwkmotpTHOxZikA76UE3Y7P1f1Qkzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV1Wzt6MCd15r4b0b0J2Gt/8k\nloIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEKgA1+p6girMtU0DnAkqrEJQik+eAqlo5VuqE517RQoCIGAKyO2P4XDA\npBVPg/z35/ZGh2oVLRCG0MjKeWlPQYol\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAZEuTp2MaDD/Ae84L0QEB5xdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM5Mzg3NzMtOGFmMi00NmNhLTgzMDMtOTA3OGJlZjk4NjhmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZGVkNmI4Yi0xNmZj\nLTRlMWItOGIyMC0zOTUyZWY2ZGUzMTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS9fnnfvhVJpfqO5xm5AWE8rs3Z9TB+uO6fNOx2yRm8iPg1+X0O1JOM3HY0OOBJ\nxQjHGP1H4lH1OdwC87S4n/Vco3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQBfs3t+2jPYPV\ni/Kd+PgCOTpdGjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhALmUThOgvfaWcg+rgmdPSUC7JB2+rHuO4M3LB5mHYbLkAiA+kXPG\nsdJVOCijthOIkE7LwwyAKcJQZVWCUlYfXa1UFQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7835", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7835` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAfdQWJ+8GtPMn2vE++5BucJHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0MjNhMmU4LTBiOTEtNGEzNy04OGIyLTAzZDEwNzk2Y2QyNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRhMGZhODMtYzUy\nMi00YjZiLWI0NjAtY2JjNDY3MzRlMmNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv211AM5Umk04Sc6z7lb/x61jHmmN/r3tmpVgZCDg0NDbxhBAUukLy99PwpZ6\nqoefZY8tv/2VuHlZVn/ZOZpr06OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5UfiA/FU1AtrSv3KaA5uHuX9VfswHwYDVR0j\nBBgwFoAUPYk0OmZHVj6/hRMh400UF67kqXcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAbTZq5AUgX72pztLbaomEDNoDOtqLBsOr4\n/mSN9bP1tAIgOMygzkM3AUzDKjx4nYHtAqoOjjkqn2sEgUL/i4JSVIQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaNTRa7wFlyxPnzaNqgyZ2eDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNDIzYTJlOC0wYjkxLTRhMzctODhiMi0wM2QxMDc5NmNkMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlNiQe1OMgs2cN8zMoOJyoyXDw3OL/o6TEDwF9caw/PIRg\nwZ0byaPbw19CNVaM94Qk8r3XSfjmT8rgUaZLN+yNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPYk0OmZHVj6/hRMh400UF67k\nqXcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIcwDvBy3C4EpOWeBkI5ZwSxOv73e17C6P71XcSgdUcXAiEAy8AxUhct\nJ/Cg6O5eugo+QJ8zt13tzJtFSJn0J/mC058=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAasDTJMX++jlKF6Rmwxi16KQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRhMGZhODMtYzUyMi00YjZiLWI0NjAtY2JjNDY3MzRlMmNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkY2EwOGZlMy1jNDJk\nLTRlOGYtYTA5OC05MDczOWY0M2MwZjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS7Xu9roXc5UPMVYGgRMBejF8Ba2pEjuNP7hhMDHz3FCn13Vbobids9Mlragpcy\n1srngxi7pTodJrSw91UH4HWgo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTlR+ID8VTUC2tK\n/cpoDm4e5f1V+zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgMVFhEVBOyNHyWWODBV1Is+vNcKMmpBnHUVvfiFmp/fACIEog2GJl\nxykq99B+OgrbJfbG3n7yDZRCqj3fJVgceMgA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7836", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7836` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISASpPQMeDcGqLTLYQiX2YPnNaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5ZDM3OTZkLTVhNTYtNDQ3Mi1iN2FiLWM3NjllNmNmNTU5MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM4YmQ1ZjEtZDky\nOS00OTM4LWEzMDAtNTFlZDNiYjBmNmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhg+z2NY/TI80s9BGmikDpeI2X7oL2z876taJkOcqESeg0W/VclBhPilIOnrT\nqT+r+ouXmLrVcO39zjQc8aOdoaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDkrzc6M9KdoIdQM70wd6SneUEEowHwYDVR0j\nBBgwFoAUlaGmGPEkxvm2/D4QpZzHVMRbt2YwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBhXohsu+Pw1bVuiNdnDrQ6ZWyYZi7ZKNPQ\n2E25cx+LrwIgOd9FS/HNQHCsqgzqU3r1Nc7Hgom8hw0EVIZMw0U8+Ig=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdgPsSa2LshBkZylpdk37ZQxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWQzNzk2ZC01YTU2LTQ0NzItYjdhYi1jNzY5ZTZjZjU1OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTxRuoNya7o15btddXelUv1iAvehBkwDAmPqmlyOJxbNkh\njI/dOBkdWnRrvitnLKPW8Yb3aScu24e54xKRY02+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlaGmGPEkxvm2/D4QpZzHVMRb\nt2YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVea0oK2TW1VU01qqS7TnVNuVrEB5jxFuNTuGDDCFi10CIQC1X50D9ZUc\nS8CkiHuHGpUcb+GTeMf/ofY1ndbnAeLu2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAeveQTEiPUgyZ25CJEqJi++hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM4YmQ1ZjEtZDkyOS00OTM4LWEzMDAtNTFlZDNiYjBmNmM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZWJhZTkyZi1kNTRi\nLTQ1OGMtOTkzNi1mMGEwYmNmMmY5MmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATYLlBI9Xl9C0pB6eEY2LfGrowqdEiJLI8t5LXQzS27ZqCwoeDEc3yR6ACt5hJq\n9D2px1yeBWkle110+zDlyWcpo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQOSvNzoz0p2gh1\nAzvTB3pKd5QQSjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgdDn39JHrkAma/YVYdI7lVO5bQUJjxbfdHunwa+c+6mgCIQDyz9AC\nUuMWTnqriCIPGqDRwZ/a1eU+IiGUbcNSz5fn0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7837", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7837` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAXMfbUiujr1rAgVpCb0Ws6SgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5NDhjZjNiLTgxNWYtNDIzNi1hZTc2LWY4YWNjZjMzYTJiZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQwZDkwNWYtOGQ2\nZC00M2UwLWI1YzUtYTBmMDE3OTM1M2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0wf0BekORcxH0swdCTs6Ifz1KqQZ6M4uDy1+n5STlxyddjK+DBng8u1JXWji\nxXy4S5XkPqHq/UDD0+uGVwePPqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlCywUC8Eks36iQwWuEib8CDYa0MwHwYDVR0j\nBBgwFoAU6oh79lM+i4I/dhM0px5Vzj9DGQIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDDFHcUUTaq7owHHXWM06ZwiVVR\nZMsp5J/sOoUhi4fcAAIhAMXLnUNIU0hDhctH8xJiwwR+Tj2Q/vcvzDqw/ZIHascu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbf/lj9hCSRJ8wFCx66qQyA4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTQ4Y2YzYi04MTVmLTQyMzYtYWU3Ni1mOGFjY2YzM2EyYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnr4+yxx8J+uu7zSVJxwh05EOs0DPg1IJlJAskARpo2nE6\n6Hp7eGCYhK3Uzlncq1xWrEXIV4Hwx5oUwzBQeOCQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6oh79lM+i4I/dhM0px5Vzj9D\nGQIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRDOm6hBCzOQhZH9hnjbidlHvWCGFVYof6CkfyrD9Y8UCIA9sG/66ctnN\nCfizEwR8bLOmk0rua7Y6688VOPtx93e4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAefJqSgyGeclIdmnZtVaoZwrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQwZDkwNWYtOGQ2ZC00M2UwLWI1YzUtYTBmMDE3OTM1M2EyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZmYxYmU5Ny1iZjcz\nLTRiNmEtODZmOC0xMGRlZjhmYzEyMWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR/Ps2p66q53IH8Vwmi0UXtN6v5JUhxZyMKUcbNPLYLUMVAVFtvTWevkCX048IG\n7KBAO+O+1G2wiDNCRN7yRId+o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSULLBQLwSSzfqJ\nDBa4SJvwINhrQzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhALfXmLavaPwjMf+OiBKImnNLJfYyiFVByxfvMIAoy4T+AiEAtwhZ\nhaaFOCFVrlhKrvypn9ZlzFGofmkzih4XCEN1O/8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7838", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7838` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISARTYhF2qrwY5xb1nm7MD1uTcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxMWQ3YzJiLTEwMjEtNDMxZC1hYjI4LTIwYjM4NDk3Njg5NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGUyMTBiODEtNWFj\nYS00MWU5LTljZjQtN2ZhMGRkMGJjODYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkDV74r1KUPfhFbACnSHcqaak9UyFPlYn6h89/DqBxkr0261k9KdtjttgYir/\nsCEWana5SKbwPS0E6wSku2AzDaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCQOjlBWITiehf9w/6WdxgFa2JqkwHwYDVR0j\nBBgwFoAUz7OrtLLyj7nhX8BflR6n+NRO3WcwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAP00s/XU\nA49/OXuOp0avJVMGWCbKa4KW49km4s0WFPWkAiAj7/2N7HIUKelAAB6pLK0lhugM\nN/jgcQS6YPnXuJUr/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXe/BUFdicjrwLm6uXvBerXAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTFkN2MyYi0xMDIxLTQzMWQtYWIyOC0yMGIzODQ5NzY4OTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHaxD2jcvDPS8M10iuuhU3EpJq7ALDxdm/LbPwIdQspjmG\nGHybJPJp8QRXTM8b6OWMj66DYCjXFT+JosmYWetOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz7OrtLLyj7nhX8BflR6n+NRO\n3WcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOQjyW5bEFHEBIYGK0UVGomJsOAuzEU6At/ngoHzev0IAiEAiVyeF2gP\njNSbGHM53Eh1pOG/7rU6wBRpVsVe5E2s5Rc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAf0564oLmtCerrWIyj6a1+aZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGUyMTBiODEtNWFjYS00MWU5LTljZjQtN2ZhMGRkMGJjODYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhOWEzZDJhZC1hOTY1\nLTRjMTAtYWI1Ny0yZTQ4MjIzMGIxYTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQTnhaSFWlmeWHFY7IypMwPscr8pwDZf+3ZDI7asIvhIvI0utVSQEDOtWxpulOE\nc7MYu/psZR4mBfi2tQhl4RFfo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJA6OUFYhOJ6F/\n3D/pZ3GAVrYmqTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAMyHJ7AiXbL31F2wokreuGmbicQWw6+pJ/6h4osRy/5VAiBl4X7c\n22PeJFJJAUKg/NBOTwF6h9LswKv/szqZKozm/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7839", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7839` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAal5Ybh2ISxXyH7wIDF05FeWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyZmI2ZjcxLTZmNjUtNGNmYi04MjEzLWZkMTU5NmI4MmU2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFhODkwYzItYWEz\nMC00ODM2LWI1YWEtZDhiMTY3NmEzMDFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpobUe2vkGi3RBoJan62zl1CScWEP2NrzDaCA42YPv6YNkF8o8GmS+ooUobQX\nMnLtQm5fQTyeMsjD5D0eRduXj6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV1GL+V4wufmSW+B4L76QvT2gw6IwHwYDVR0j\nBBgwFoAU31CXpemTAONXUTNVHm2JBmpKJ6QwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIg1keFa\nx2D7qSTze0/pMK1UxYPVI/4zDuxwW3lHbwTpAiBSJGRUEPwvHVV8DrHIzdHECF7i\nDP9vg83bTBEpDDl3mg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT3wIhsRfQnGQdLDNBaLD4chMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmZiNmY3MS02ZjY1LTRjZmItODIxMy1mZDE1OTZiODJlNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/8pPaGuLyFGwZ2LLomtHbEEtCbEEc55ExeqBQe8RnEld/\nriaWEYCY64xCe8QdQG4zVgozVvMKYPJA+NSurfzFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU31CXpemTAONXUTNVHm2JBmpK\nJ6QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUweBbmGx/f8TxSOAZgzj4Oa/hC1Of7rOixfdZkzfsPgCICuO/arWyFwK\nSuDlEDsleY+zhvLHwprJMRCKghamg+GM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAfyLxxMHCjim6wVfRvm2Ho0cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFhODkwYzItYWEzMC00ODM2LWI1YWEtZDhiMTY3NmEzMDFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjOGVhOGZjZS1kYzcx\nLTQxMjgtYWNhZS1hOWE1ODMzZmRlYTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQBxbbsmLt9PvKZyn3AuWq3P9qDpzx7qRwDiSZFN6I1ss570YN3QscDm62EPWNQ\nybGcUv2PQJz/hk+DlIgjYohno3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRXUYv5XjC5+ZJb\n4HgvvpC9PaDDojAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAM6SIS7Izn+tvQIJuSNe4X5k7kGc98S6HAAiBmDnFE74AiAW1BHH\nokMCr0aCu2ODaVi75WbLb8pbRtYTzPkMRsc+sg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7840", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7840` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAZBYsadu33AWYQzrP8pKe1N8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwYWZjYzlmLTkzZmItNDY5Yi1hOTRhLWNlMTM1NzRiNzUxZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU1Y2Q4ZGYtNjVk\nNi00NDk4LTlhMDMtYzY4MWY2OGMwMDJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQy30UWbfoEkJT0zn8zDUZOhuEOp4ZUUVukgmrb3gKFmQi3WhCEiZPH7uRnu8\nnAEdXfDWeIccOTs53ILrL9H4UaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAGtZvnems7YmeihCvUecMJxhSNcwHwYDVR0j\nBBgwFoAUPycg1KRdMiS6Wkyt+fbEk3OUc1cwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGAP3adC\n+x7mYyXigw6xgLbGQDylXIWtVi6+yZKoRG3KAiEA+qyu+zxk6dYsIc7Qaxi+3VOC\nKFSVLV6sOv2NprlsBWk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATTi5vkYsUE+eCwfLXyc5UezMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGFmY2M5Zi05M2ZiLTQ2OWItYTk0YS1jZTEzNTc0Yjc1MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLlAQsqjw4juoOxWan38AusHKxdd4ZHUHDnH+0GDjtuO9F\nWZE5DSYxi5OcpPu3P9w6tEhQrhfKuZjdBsgNvaVno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPycg1KRdMiS6Wkyt+fbEk3OU\nc1cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVMLiXItroYQi4TZynOFTVOz4tXBIP6w85WYY9MBy70sCIQC8g1FtAS2P\np7cBlxJJcDO802z9T/STQlx+yR0u/P3Ajg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAezFavXaddKeO4lOYR0YEVMTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU1Y2Q4ZGYtNjVkNi00NDk4LTlhMDMtYzY4MWY2OGMwMDJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxOTNmNjg3Mi1mMWQz\nLTRmMmMtOGExYi03NWY1MGQwYzY2YjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ6VfB4fOPt6qDUqYi5hC9E0L4taoVOTnH4rqV9He5Q1XdwIJ/r3ypCc9m5+0xB\no/sg+Ypbk9qpDECRMTyxClEMo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQAa1m+d6aztiZ6\nKEK9R5wwnGFI1zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhALkM7ZzlqDbJrUQiJUrRIdKEXFC4KkBoxcPtiXgfWJIMAiEApyio\nCgF9TGIJkpW/SnhNudKPiTF7UO8Pidql79q9Ilc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7841", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7841` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISASzJX3eumSrosPjZ9L5YdTpSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkNjNiMzQyLTJlNjAtNGRmMC1hN2E5LTkzZWM0NWVkNzE1MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2IxODcyNjYtNzRh\nMy00ODRhLTg1MWItMDRlODQ2NTk1N2Q5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvCW9HiPJGs4vxRohB6OnM6J4XLhRhCBkt6N7Nz8TvxCxQ8lQN+b08lt0EDCd\nO/cCiD69j1vZSKswVl63Aj8o7qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe3JA5sddfxZdf6suVwdI7we8DxkwHwYDVR0j\nBBgwFoAU4kWGvDft8p5SLE5keuA60nNz99gwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCTMlHdXByaQBn3cX329Ol0VRqVe/2h315Yt++ofcPNtAIhAL+fp1rH\nftbLYPsbcZa/RsdIkJBABXZRz5oryjfoCkxo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV7B0H2J5yL5EC0t9YsUNp4cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDYzYjM0Mi0yZTYwLTRkZjAtYTdhOS05M2VjNDVlZDcxNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmuNkIt9ftqzUfXcwwhsDGM37zeWReeBHbMRdlLMecrKDX\nRgkTWc768W+i28iIhneAr+zP6uQtD0JcMWBJejlRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4kWGvDft8p5SLE5keuA60nNz\n99gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANvK7HNh+vslG8g/753xYxTq97kO0+w2dwEIuDIj7QeSAiEA55CLaD6v\nj/kDcpp/uBibj57qliwqNJchQyMF55BDJdA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAUtbewL4D1uWnNYesArvbi7cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2IxODcyNjYtNzRhMy00ODRhLTg1MWItMDRlODQ2NTk1N2Q5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMTI4N2YzNS01ZmIz\nLTQ1YTItOGE5Ny03NmE5YTA5ZmEyZTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATxnXpgY/EIiixxyJtxCd+eDT7rCXOoY94RyUrCp8jya5G8Fv/mDQQJrqAaaETj\nuAEE0r4TLNuyI0/KQ8RsUGzlo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR7ckDmx11/Fl1/\nqy5XB0jvB7wPGTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAIPjlTlTZhXJTR8+ygZ4reHKT1vXAmTcMEzznjrC0Wl1AiEAiA5B\n3npiIB45p8ID7M8QHaLfVlIAcEujNn85nXZ3S4I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7842", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7842` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAXRocuco4vwVO2fkUwgxgVgzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNjE0ZDNkLTIwZGItNDkxMy04MTRkLWI2NmU3NDZjNTA5ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjljNWI4YzMtMmJm\nNC00MjRmLTg3YTItNzRjNTYxZThkYjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBIamzaCB65EW+pIc5gDP+18PiagciAAX+JQScGBOu2OXI2oI6oqP4KO6k8W+\nsZSaSqx91b8foZxY49WYzv8Gq6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlSJTxgGfpc41c1ReN7ljg/WtyDIwHwYDVR0j\nBBgwFoAU6ve/xWgpS1YaaJGe/fkJ4NQhLKIwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIAdQzvx44c8yASFtu1edJnJBaVPkM0wnaxFT8swR/zt/AiAirdtexadF\nDuO1UWmUcahdhJJa+JiJRAklDrYPmT2/1A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf7iAymdGXW0xUD28xt8xIQUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTYxNGQzZC0yMGRiLTQ5MTMtODE0ZC1iNjZlNzQ2YzUwOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPFkplH3mmkwPW8m7qaaGKBAy1o8bn4u7yzVW3VjaGtreh\nmuMRULx/F4Xnjlh8xhcrD6i7WirJiK+LlHTTe+jAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ve/xWgpS1YaaJGe/fkJ4NQh\nLKIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMn6SFuUFyGCc8zvxgDeWzWiDAQRhvFx3K4i1AVo9bJ4CIQDtgwktwESQ\n5ZDv70MwgRMR6bYvVw5wGRa/J7FJgzTizw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAbe0vYW5v6YtfFve80ILv+WcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjljNWI4YzMtMmJmNC00MjRmLTg3YTItNzRjNTYxZThkYjIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZmI3NDg1Ni02NDZm\nLTQwMTItOGE1Yi1mNDNmMmIwNDI0ZTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASgW7AjaXAucKZL5Mu/RpdRAIOEWgyAMpZtb+mkL3GMhVMmyp6n2kG0YYAmTKMj\nmu5UHjEK9g43iNJSKkck+VM9o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSVIlPGAZ+lzjVz\nVF43uWOD9a3IMjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgNr0CXR9o4+BaMPsFOXYaolphMNvN/rN+owlcuKeWHGcCIQDjlMZV\ntKYd/3yXLjYyHEsvqqGg10rTFmfZNci6owecpA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7843", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7843` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISATXUrL6Vxxs0xUKNVic97PZzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmMmZjYWQ5LTA4YTItNDdhMi04YWY4LWJmZjM2NTViMmJmYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGIzYTQ2ZjctMTY3\nNi00OTdkLWEyZWQtYjRjNDZjZDdkMWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEo/5gZRQZxUmgnbsCzE1Qv6vr0+/tXiRl5SIfmkADpjTznUwgeCvNhA30gJV\n9Av0tLGUGS/Tfa9hTcivS1XicqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULtCBXi7WK0AbaO7TBWbu7M0V+BUwHwYDVR0j\nBBgwFoAUBUKvM8jJOXFIYKGIr1OhY57LPn8wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQCsMYTfqAsptbgQrabswErco/scl3GzNTMk2g2MSarg+AIgA3RXBXP6RUgmu+jR\n3tZ6xu6vUaYikIAn/Gh791RJW+E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATa+V19kc7QM6xOSccNHiXPBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjJmY2FkOS0wOGEyLTQ3YTItOGFmOC1iZmYzNjU1YjJiZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFzbF7uAeepx+ezBHDWfMU4ksDkufsEbLe63wg5YOd2o2d\nzJo4ZY/5O1RPeUhVldoAcXTi7i7Qjlr2Nkg/bxhlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBUKvM8jJOXFIYKGIr1OhY57L\nPn8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO7N7SpDQ1dfMZrd36vvuBDF8b/ccec3om44uhA1EcqGAiEArR4uX1nr\n3R5sdSAcW4ZkLAGkWnaHVmW4yYKWVvZBQ0w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAUi314TpjUNNF34Q/V/YF7dPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGIzYTQ2ZjctMTY3Ni00OTdkLWEyZWQtYjRjNDZjZDdkMWM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZDZmYmYwOC04MWU1\nLTQxNjItOTM4MS0xNjY4NzY5MWJjNDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASDilvEFlS8nR5EtH/67v79+3Nwn3VzrLOYC4k/qIUTC34kPcusQWg8OVWW2liz\nhCMVlPZ+84J5b/H+6zEphp9fo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQu0IFeLtYrQBto\n7tMFZu7szRX4FTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAIzShcHXl35sHNSt80d1ddBK/kHapq5OLgv3flil301hAiEAg87y\nkWoz7Mh2Ts7vH5zu/Q9TULtYO09gSgrVXb+KgAU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7844", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7844` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISARg0dlkYqPVjafj6YVFihP3DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MDkzZThkLTA1ZmMtNDk1ZC04NzE4LTkyZDI2ZjViZDYyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjEyZjZhYjctMjRj\nMy00NTJiLWFjZGUtMjc2YjU0OWY2ODA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcGBgThDk5FDg3chqc6zuzZBaMJDJYOPUXFWbZh4NW/eHJZlbRjtzoAQn6wVx\nuKH1jN6jmf822dcsFu0i46l+NKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW4bd2AhzX4d3rarqDYjJPAhd8I8wHwYDVR0j\nBBgwFoAUs9ci0ZfzOlknWaoS8JQj6EqPqc0wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDwoGlU5xaACNb4c95mcCm3tYnF2+g3NmDQ3AciEw8QFgIh\nAOCNh+fgJA7uq4qFoBep6Ex2TJxIXOX3KKETFtaIehY8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfsV5j6xkWtCJLpQJFMtlshBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzA5M2U4ZC0wNWZjLTQ5NWQtODcxOC05MmQyNmY1YmQ2MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASB10cJNzKkbnArrzQrBx3tUR3YkKfe+I6Bq23oWNl5MFBk\nlNZox5uUFvmbA4ltZk2SG3aIKEvbT4gbnsnD1dPJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs9ci0ZfzOlknWaoS8JQj6EqP\nqc0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPIDQLMJI1up3/z7wSE75NpfUSrk+1N/U0cnSSNmdEjNAiEAgsGBqp4S\nzdXybLew6IVNQY5+axcta542pMzpzQgZcBM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAZk9ar7HIIQo5c1MjabL5egIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjEyZjZhYjctMjRjMy00NTJiLWFjZGUtMjc2YjU0OWY2ODA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YzUyNGE3MS1lZjA1\nLTQ2MmQtODE1OC0zYjhmOWRlY2ExY2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARnZcGAqxuwGLIrW5MGh59A+npT3eEiM3oymU5kNuUSN3H2nuK1PdKOxf4fHz6V\nY9C0ft1VvbYh9Aeftw2DcF22o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRbht3YCHNfh3et\nquoNiMk8CF3wjzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgWvQyJmg2kt+cmxi0YTEq1uUHWmFaZ6LCeoYPw4s7xXcCIFeYssYP\nBjcit7/jotfROS/qORTHMJrqsQBQAeyG0pso\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7845", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7845` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAUK1BPWVbv2cczKyxkRvbKiIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhNTA1ZTgyLTBkMWEtNDc0MC1hZTU4LTZkOWM5NTM3ZmQwMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY5MDA1NTAtZmNk\nMC00MzI5LWE0OTctNGMzOTkyODA1NjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyB2eujLhbWs/KHqG63QCGpxXrlVilGA4LnydHWCAhW4/NAilXFtuT7WQehnE\n8zYpFwtg5I3s8fMCIl9cDBhegaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYeTtSho8c+6yDJBnXhn4lPtuEm8wHwYDVR0j\nBBgwFoAU3FD9v017dSQm2zPUYBGOr6w6jokwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIEaSakqQmsm9nfd/B/44Sh684rFRazhr1VSIukMlrBCwAiAY\npsre1YJyaH82v8ve37khTNJG0nCen4Qg84ZM/GYWWA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdbMQzw1fz8GEON8H8cDNXtaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTUwNWU4Mi0wZDFhLTQ3NDAtYWU1OC02ZDljOTUzN2ZkMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZQH5nfOKO3kKpJ5fwsaBtk5hLC8d08V3q8ZA9Ob8kiTFv\nlAfzVQ2Iyjr7qfMNvUyuhzJs2ibFvdCcMMGw9Rp5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3FD9v017dSQm2zPUYBGOr6w6\njokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOSrtSqQYl0mhaydphV3sL2DI48AVWOQDExwUTtDmhhfAiEAluSuAmQ6\n22v5sTbkz3hOvOdU9zJYkDbFHqzxGx43SSc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAZXc3tU+iili8DOfVtNlgBcbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY5MDA1NTAtZmNkMC00MzI5LWE0OTctNGMzOTkyODA1NjU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NjYwNzM0OC02NzIz\nLTQyNjMtODc0NC05NDk3NzliMDZiMDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARDKDhzjBxbI7XFdK6Io6IIImKuG8oF3g7IsCYPIk4NPtUDTZQoHGYG8CzDs0BJ\nTUw1hmtBjGl2QI2v74YpNvpOo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRh5O1KGjxz7rIM\nkGdeGfiU+24SbzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgEPQw7lihc5oG2BqbSIDMndM3F9296ih6bmG78RuY5+oCIAmVSmMr\nN5ZCHhw0kDik9xf8Q9UiR4xkDefYvwjC4GSq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7846", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7846` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWB4lcVUl2CxpenxmXVX5uXFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2OGZiYmE3LTQ2NzQtNGY2ZS05ZDY0LWQ2NzNiZDc5ZjUyNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdjM2YwZjctNDI5\nNi00NzgwLTkyNDItNGE1YWM0M2Y1NmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuDF/lFDheGjsoyi2PFmE8sFrQeztQsXOM0ci67VBWjrJJKVr6VPOuW+ssw/W\nWpr6L6ZOzY6OM9ofDfEkAMkZSKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrq1KGB3ItKVqaXOr8GZZc6TD9PowHwYDVR0j\nBBgwFoAURE/rFbrGr+OnXYVLL7IXZGYQSvAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCQaJOPyHQJ\nLvb92TUywMRTHd6dchMKz+Onm20G07QJrgIgMJUCJ8JyEP2pxfWwD86psrfPjaAM\niPM4aW675NFW4jc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeixjdMt6KLh9FMNvhsk0OENMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjhmYmJhNy00Njc0LTRmNmUtOWQ2NC1kNjczYmQ3OWY1MjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+9t3jNSxZHbjv2bPzKuWeLvRTY2L+x7mxP5L+2pZaK+Oz\nQ6iCoEpr9UEiZNOkoY2FztKFe+oLAPeiuRdIAW1ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURE/rFbrGr+OnXYVLL7IXZGYQ\nSvAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIZntjLgY5r3HPQv7V0j7xX/g2Y8JnZteC4ozWDLQmWyAiEAk/GyVk+v\nUhxDeiDXFgOS6o4rEucX8QAdLSHEnT6wkeg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAb3ZHwmkCxgTpKeQ7VRLhhdtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdjM2YwZjctNDI5Ni00NzgwLTkyNDItNGE1YWM0M2Y1NmYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0Y2MzN2FiMy1hYTJl\nLTRhNDEtOWVlZS0zODcxM2VhNTkzYjkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARSKMKJf0J/6BC6denApBsga5Sf3AETRlmvOPbpz5221lpuiEY06/A/4hF+bAh0\nVJuPbcoqIJHdF5lxtbsM3FvQo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSurUoYHci0pWpp\nc6vwZllzpMP0+jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAJG++q6WAytF2buEURANf9nXe3fNCcypV5ouFkw6eNw7AiEAjcFL\n1VyLDGxssbRTbBbUdmQ4S9vUEwc4RxZB+FTlH2k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7847", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7847` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAYth7AcAwVgRB4fBTJDzcH+3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxMTlhNGNmLTRjY2QtNDVhNS1hYWEzLWFkZDVjNmEyMzEwMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZmZWMyODYtYTcz\nYy00MmM1LTk1ZjEtZDZiZjRiN2Y3NzVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEas6BIMJf2KZcE11igh2LVNjxFSyvwBsQh19D63vkV5L3hXnKpQJELefcN1JN\nHM7eKQPJ0oszp8KwQBDwlBZ94qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcWzffOnRQ1NT0mnKhk+pHgPfSVcwHwYDVR0j\nBBgwFoAU4Ovs6t2k6ALewG2NBXkIgLhq0IYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAOWJGmaCFEeZr6eDroOEeTB0hivPF3jaVohAD2Vk4HlSAiEA6pIasQYZ\n5lONDQ7VZq/y4FBGHDyTQZAU7NPHSS5tO7A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAficYh1K3yjDK7h28xX3m8irMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTE5YTRjZi00Y2NkLTQ1YTUtYWFhMy1hZGQ1YzZhMjMxMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS17Kang3Ms2t1iODsrccPkXlCBpLztCBnm8mOVVLxu5pEO\n5rQPtH3R6q9NKVI2UoHdQJYJ6GFllvw2OWe+eMmOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Ovs6t2k6ALewG2NBXkIgLhq\n0IYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTy7Ve/6Ve6zgsPH0szq4JtOo8lWgB7rLx/qVtNfPHR4CIGQwWUqmoPoR\n4E56k2S3SnonoQy6HWpCtBCV6N684yS6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAY9Iq7QIaGLz/C3EBADELX4HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZmZWMyODYtYTczYy00MmM1LTk1ZjEtZDZiZjRiN2Y3NzVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiOTljNGU2Yi1lM2Zm\nLTRlODEtYWI0NS1hMjE2NmZiYjJiNTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR9GwFXFFvO8UVm7aTeRA12hsxNoAIVGDK33MMvVoXuXaEozE/Z5vHXWoLMvJqp\nq3iE7V6CTD0llSewNKMFyp90o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxbN986dFDU1PS\nacqGT6keA99JVzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAMw1HgcQ8ZhjeIGyZ1baLnduWJMkAexyCEUct/P/q0r4AiEA0iDy\ngTPharqCu+XIO1dV9e8gdCaEDL/JB/yRFJw8IiY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7848", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7848` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAYJhYaw5Hq95DL4N/US7InZiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNDI3NTZjLTYxMzAtNGFlMi1iMzljLWYzZmVjMzgyYzFiYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY0MzRhNGYtYzI4\nMi00Nzc0LThkNTEtOGViYjIyMTlmNDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHOEtpsMrbwZ68dubIjqhbGDykV6wttgoFlTxrmXxGGOIjbd7Vn6bO1uxOrlH\nlqaRAieKh5PTSpAs1bggUKTkwqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmfdUImufu89XRbwZLrc3MqR1Z5AwHwYDVR0j\nBBgwFoAUHEQbM5KIaMnwszuPQaoDiIzLBBwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgebblvbzRQJ+A5iVvCN9CxXanx/ZyBbuhXoDdbvvJt/kCIFfhxCXKA2/m\nBNzyFYV70Pw5xBWZYLlEUl3/zJsCGAo+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd5qteCFNwcM8t9sv7/y7+/PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjQyNzU2Yy02MTMwLTRhZTItYjM5Yy1mM2ZlYzM4MmMxYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQR3p8kQZZOu3mOjSEnmvMYUOW0ngY5ds3tm7MwkXdzXSY7\nKWGKqoIYwpVK5B7ZtNBlKUG1pbWmnUSwSlsp50xOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHEQbM5KIaMnwszuPQaoDiIzL\nBBwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALdlcytxY15jXdJfzaWEE6QPnfkccXz83UQSeEFh/i3CAiADflCeSaRD\nmHAlnlrsujGv3n8nvj5O6oRCbMjbB4fPcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAZfL5u9Iwswt2YfTr53QSP7fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY0MzRhNGYtYzI4Mi00Nzc0LThkNTEtOGViYjIyMTlmNDNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzOTAyMTlhNi1lZDBh\nLTQ2ZDUtYTMyZi02ZGMwYzA1NDhiYWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARPRo2OYZbndBwSFr2ILlgkm/Gr7D6hZPXgxKQMjJ/vKTYn2/J4f8H9O+zqDNDN\nGDnv8djd0tl985jEndtW2SGZo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSZ91Qia5+7z1dF\nvBkutzcypHVnkDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgN2Xzv7euJHZxiLyPLqaBJ8EsqRIeruR7dqO7/sC5AOwCIBjaONQi\n7JarOFO+oXlK+O+JLKi3qBtJndQdLI29jMmv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7849", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7849` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAUCSm+1So0m8Xlxu3+ISXjf5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxZTI1NDlkLWNjOWEtNGQ0MS05ODdhLWU2YTdjN2RkNDJkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI5M2NkODItZDli\nZi00YWI4LWFkMzktNGQ3MDlmZDdiNDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgbS0LXJatwW3T3RYUBb48hJViEp+QZOGMQWEsQBdCa8Eci9AcQM49IPuL6jv\nx6Qzm/1b8yHyTP0D/VItZDgGYaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU/zdCl0ztHXxyPLFQy66OCczcvswHwYDVR0j\nBBgwFoAUFrcD8C10Z5PgiJ2n2wUQ9WOHFYcwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQC7anrJDIX+KtPwSzw2tCR7lnprzZ8D9ZIUapcL3Tr9awIhAITyq5F4\nL9ifojHv29mSsrFBScZtJJwdmmn0YPAkO7x3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATNFZ4SkOYTb4M4JkQYz3wWCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWUyNTQ5ZC1jYzlhLTRkNDEtOTg3YS1lNmE3YzdkZDQyZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ12/ros9V3i+S1j7u9lsAM2c0RCYuNBaFXlPQSz7WqJHBz\nCqwyThUe+3sZYkRjzXi1PUnsE5hc9W4dkXEy9+D7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFrcD8C10Z5PgiJ2n2wUQ9WOH\nFYcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMVDN7ME4g9zI89fuqKkkemwXDnAmb/7dcjDodYiYM8xAiAE8+dHtBhc\nKBdvHu0jn5N8Jf798ggq9ps7VPKT5X/Rnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAeSWbL5E+nA9g7TClAlzDxcdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI5M2NkODItZDliZi00YWI4LWFkMzktNGQ3MDlmZDdiNDYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNmViNTJiMy0wMTRh\nLTQ1ZTAtOTQ2Zi02NjAyZGM2MTQ1NGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR1dp50qYRcv7q/Qv8lCikoRB/l53FwWTsH06j2QRynA/7ysRYghclGp3EaaKCy\nHwTgG40CHI9FriBJecTfkYWMo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRT/N0KXTO0dfHI\n8sVDLro4JzNy+zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgdfRZnf20IgRokKH6WZoJkO/DISETFYqV/ZN0bymOkE0CIQDIEUHB\nJwFc0p695TgxKArDZcaZGbTfzePX/v+MSaz0dw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7850", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7850` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISASjDpk6YT/8xpnsv7csUQVO5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyZWNkNDBlLTA5MjgtNDZjZS1hMmRjLThiYzI5ZGU3OTNjNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWY1NTg1ZjktNDVh\nNy00YjhhLTkyOTctYmVmMGExMGFhODA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEymgMDoLCLvqH/mWHYcoajK4qbuU/MCFLVeVQdPJ32sY7H36GqC7xQP13YsZv\nnqPkXWp9s8zc5ACbsL+mkyd42KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTbDKgi1x33UovhEr9BDLN3uXgHwwHwYDVR0j\nBBgwFoAUPQXuE91mv7ifazr1JRgz5sgV0BswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDtm94U40+rVDCAFf9Leb0Yjy0a9DN7nY9zsetn\n0KgmbgIhAMrdPULIvomUBiALtZtOR6fJGjg9kmjGJVPJhEOf9f6F\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUIWoP+XFLvNVEfJimaCOJBFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmVjZDQwZS0wOTI4LTQ2Y2UtYTJkYy04YmMyOWRlNzkzYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASl7RDtbLzz7G/+FFYlqFMECb9cEwQ6dZQWuEoXLS4eFVRK\n0v9RreOGj7NPF0kJQ+HX7axooO4JvN0y9LoG7fato2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPQXuE91mv7ifazr1JRgz5sgV\n0BswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOWsamsorMTVgKC5DTqVrlzJejzaQUPqJ2IZN8Ty2v/9AiBjL43ST9D3\ny4qM/9B3BV0VDqiv6XcMy/9fiDIwToNNsQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAZVasKwq8AXZ0M+HF14fq8MBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWY1NTg1ZjktNDVhNy00YjhhLTkyOTctYmVmMGExMGFhODA2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNmMxNWE5ZS1iOTA4\nLTQyMjAtYTQ2MS05N2ZiNjg1NjgxYWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASNjUNQtf5odYHyCz4hsMdgPDoJG/vpkhQF7/WntzaDK3WvAZ/vCBu4ewBNExX7\nStKY9/yct30p71kqu0wjYkdBo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRNsMqCLXHfdSi+\nESv0EMs3e5eAfDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAKrQsF0o58SBcjTd3EoBGPDwYUPcokpZLHK7x41f6mRSAiBMCHn2\nWXN3TB0/vf8nz5AZ7NgoEbwqjMPqj40N3ne/HA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7851", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7851` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQIFfZVnMrpYsZIoGUiMRf92MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyN2NmZGNjLWI5ODgtNGJhOC1iMWVlLWIyOGQ4MGFjMWZhNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQ1ODVhMWItOWJm\nNC00MzVmLTgwNDQtM2YyYWI2ZjUwOTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELqKNpJrZpbS9sFr/LKO1+i5BL9lFv/CeTIFdhgODKQM3zlMWdOfRgpCwuRpL\nL77X+EscVQsxtTUgW9vLYvj8cqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsSUo6yu/hPiwRQQCELkllfuCHsswHwYDVR0j\nBBgwFoAUdRot8YC0FKX0l65Bc9y8n8sfUiQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIAa6doqu+cvRcbHGaOi84Nb9aJwyj38BhPwywvAH\nKPXkAiEAynMN1aaCliAvMZq+DQdGSGuo4rCqDpwsSXCdlTaLxQI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYpIuAFq9Je7iA+SENssXDnIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjdjZmRjYy1iOTg4LTRiYTgtYjFlZS1iMjhkODBhYzFmYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdXWLDntmbPmGxtAlAiaEuJmxM2Bp4Tm//PVXWxB0STIWC\nTmMWmRQ5TXe/DMD1+ttmWKxzZFWvbNgMIvCeAOuno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdRot8YC0FKX0l65Bc9y8n8sf\nUiQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDPOewGiQPYr7e33lVrCyqcOGiCXzVuI2/lWd5LzlabUCIF/gCCaw0441\nbDUftKNjtrrx+mJD3UjzGXreYJgTmCPP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAZzgRBd8wlTYLJmzkESBSV31MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQ1ODVhMWItOWJmNC00MzVmLTgwNDQtM2YyYWI2ZjUwOTdiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNTM2YTRmNi00MzAx\nLTRhMWMtYTViNi03ZGRmMGQ4NjZlYmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS7C8FLubiRzp1O3+gX1z/mMdLqpRs2fouw0IF8lbgGKE8M4+yqqXIxZHRr7/tq\nPu/MOKdl7/T/H89GCWLEv8Xfo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSxJSjrK7+E+LBF\nBAIQuSWV+4IeyzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAPkWYs8SqjTddCLLbzlaWE+iB2/13o1v9wjTKaFEExmRAiAKs5j8\nAqz09KAa18B+LuDsvc5Wh8ABtbLvgJeJHrrkYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7852", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7852` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAeCN4IDYclXx714X1jmZTuYoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjODM5MzIzLWYzNmItNDJmZC05MGMwLTk3Mzk5MjA0OGMwZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGYwZjU0M2EtMGI2\nNy00ZGM1LWFiMjEtMTU5YjQ1Y2ZiMDRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK4Vzc7yWBaiIL1VmYUfwdY4j3md/N8+Wv338ySnZfiUbHscGeOAfmmNSt03L\nV/eosA2cLhLWDgqxp3fw9ZNXvqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfl/w+5dG0GftsQbUvEHblkwXZuYwHwYDVR0j\nBBgwFoAUJd8sJxmiN25MH0MNluUmIC5DABYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCICmh54Hq0NoUwo8UH6vhhySnt2+05QMfjavUg8q7TiGCAiEA\n+pWqtxytXJ1qNUNvg91Adt1MtQMKNZkCz/JMccQhJbU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWzY5RWSHLYy17OhZH9DUNW8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzgzOTMyMy1mMzZiLTQyZmQtOTBjMC05NzM5OTIwNDhjMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQU3nhPA5t9yQNMAGzJchmplhMdeKo2WsFKIdN3tXJN7Ely\nE33sIW1P2kH+7AmBhDmQ2qi9NwixDJ8kdi8mSFkto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJd8sJxmiN25MH0MNluUmIC5D\nABYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVqJYPvlOxl1J0aXOi73KueCLonCQ5jdFcE9z2w290jYCIBI8IWK85i3l\nFeh8MzJ7ULCay4y8+OvFJlK4L1m1aGrp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAR+KiAiz3BllT3BQ0iwpbq2KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGYwZjU0M2EtMGI2Ny00ZGM1LWFiMjEtMTU5YjQ1Y2ZiMDRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3OGE2MjA3OC0xYzNm\nLTQzZjQtOThmNi02ZDc2ZmE2Zjk1MTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARdZ3RQl9NHc+YQ6tKen6aUHJBLylEwW3CwknqLnyIN2UbV4RuEV96WK1ht8qhM\nLpXUgIGFVzEdGzniZEp5Gleeo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR+X/D7l0bQZ+2x\nBtS8QduWTBdm5jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgAx20J250yjmv8cZ8KCf/Cfg33vjKKLV4zwq2xS62j6UCIAzH5Dw7\n/zwy3EBcLCEpVppqOTxGuBPMxsJrZrsK2IsU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7853", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7853` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAWgkvURPCeBC6B5dbt1APNUxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMDNjM2E0LWM1OTYtNDVjNi1hNDJhLTRlYzMwYTdjMTA1OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBjODg1Y2ItODEw\nMS00OTcxLThkYzItMjgwNTNiYzg1MjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOCj45oqWOmkA0bZ/fbMUNRwbHGFd2HJzyIWlWY60g9XfPMBOzps79rfE7vMf\nHAxohYVG5vupoo3SwNBgHxWAbaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXDDTog9nQxSX1W+UbM5G3tCx64UwHwYDVR0j\nBBgwFoAU6WtcGH6YQ6q02IOFVk3bSk3fHg4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIARZ2aHW9VbHiQwhsOjKNwVESBEh2xrl\n5KLpt76h03GzAiB30rFkPYbZtCVS1ThPeW/SFmIsRYX+8VP79fmhy3HIPA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWZuSR/wDvJrAkuyUqInipsMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjAzYzNhNC1jNTk2LTQ1YzYtYTQyYS00ZWMzMGE3YzEwNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0PeFvhIU3XDZmKYccbWlzqyK0EVKKIo5TpOPTTarkRsh0\nDBOqhMQOLgd/V4dGF1bZ3KOF5qtJ2Hw/3D526gwFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6WtcGH6YQ6q02IOFVk3bSk3f\nHg4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYvoJpXe/LRBQdWgPOWDwTgMbRNPV/njYwjncXpTuVtQCIEFEWlVpkRlS\n+vgIa9u2BVcy5/ib/1lNSoFMoIR2v0ak\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAZwGKHnYMdh/f750HBn7wC5ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBjODg1Y2ItODEwMS00OTcxLThkYzItMjgwNTNiYzg1MjIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMGQ4OGRhMC1jMzg2\nLTQ3M2QtYjVkMi04YTkzMWJjMTY5OGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATP5sH0HEJlvxtuZfVp37bUFL0Lyxay0ITU1WUd7BggrjsdWxg6VUIBk9KdZyM4\ncdeY+VWV2d9f+jD55r7wBb3fo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRcMNOiD2dDFJfV\nb5Rszkbe0LHrhTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgMrPT5N9duYHV1lWiuoh1f+YErsYAj/XpHip/5dHdae4CIDkqliYG\nw+xI5OECMTgUCDXgkh4HqpqoF0BbDvP6SFMy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7854", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7854` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAeBgMYztRss1wPvQXjcD2Dj+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjMDI1ZWFlLTA4NTQtNGVmZC1hNmEzLWQyNzlhNTVlZDcyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJhYWVkYWEtMWQ0\nYi00YmY0LWI0YmEtNGJkNWVmOGYzYzUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuN46H3IMMjB1woxR+7fiMFDQm6m87mgM9eOmr9VJxFuBN262/Wx6mqhVBKFF\nlMzIqD00S+2vKrNPi5hlYSCvPaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5X/O4rnqfYj3qTkoH0ePSwoaP1swHwYDVR0j\nBBgwFoAUeB1ezt4dYhrBfx3oii45q3JaC+wwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIFI9vMvrhx5rdA7Y9wHOro08afqZhdUk\nROtHEiSDDtSNAiAUJnu7ll7QjXaW8Pc4NaCmO7oyfqIJ5yO+EE02x6UsuA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf/j13vExVDcCX/LDISGV3DsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzAyNWVhZS0wODU0LTRlZmQtYTZhMy1kMjc5YTU1ZWQ3MjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTtzPflYMNRFYwTtExlXkNtAL5uiokY9ykn/L6gKPMV4W/\ne3uyc4zT/ivtt+nJ72Yra9qYnfbleKzls/cVXclHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeB1ezt4dYhrBfx3oii45q3Ja\nC+wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNSxUpz+TGAZOrny1aj5/fhGpK6NxoLGd7Vqsb8mRoEICIQDiZdGm2pSy\nFZUO8FxEMUaKzx6vHxex7FsyBqzbqNh2zQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAe7XEkRgXGnwW4Qp0Lh7OAWnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJhYWVkYWEtMWQ0Yi00YmY0LWI0YmEtNGJkNWVmOGYzYzUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYzBhOGRiMi0wMjlj\nLTQ5ZTMtODgxMC04NzFjMmVhYTMxYmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASLp+n35AbOnOkNoSnoxIupmNRSiNqHw1RP2V7fHb9mTCw+Cmh2Sd9mHPdMHn7E\n/Jag4kMPHnirTvJ2/GRwajTWo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTlf87iuep9iPep\nOSgfR49LCho/WzAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgYBsdthyXjhqjajDdc2sGJOFl/h7oCrUIZ2bs4C/F1s8CIDmGNQ2F\nO2gfM27hN6zqM9+7SS8H4vxjoyHCg7cShgtd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7855", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7855` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASK3rBlBGNHCGEJiYIG/V8JhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzNzMxZjUwLTkzMWEtNDA1Ny1iZmRjLTVkZTcwNGRjODAzYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNlZGYyZWItZjBm\nNy00ZmUwLWJmZDUtMzk5ZDg3NmFjNjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFcW+YN81fBEumQ9jecKamzE1AjEuZErWbe1Zlf5j/u7jGPB6cDVZNKXew9gx\nW1wBcWM6pZob+HUwBuDffPGySaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK6BfSCI9oPyGGFOT18lsmrO4wO0wHwYDVR0j\nBBgwFoAUBxRfir5kOtIhLiu8gfCKWSUKfQUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIGv2EXJ2E18P\nD6MTqBkYJ5MqlvkaHbMYruDblpYSU5C+AiEAlv/4lPWTvwBWlHbqi7gZKjtR+P/2\nhKPhyoSu/ypwhl8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcvmhym6n5LNbsBvu2IgFfSoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzczMWY1MC05MzFhLTQwNTctYmZkYy01ZGU3MDRkYzgwM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt+tZwOQA842s4uCFaq5+4fKlQT+OkG7kNMJDDl2fW6fC/\nA6MGhTjhRRd/K8IrdBHRnCNDwVv88xX9QysBIirro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBxRfir5kOtIhLiu8gfCKWSUK\nfQUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALMxvljbUX/nrIkSjQ/b9IQAJMr9M3lRecbbcGNYqrr7AiEAjdvG5+F4\nJOOP0hkMpEkLDJR6eEbNDtryK9cYqe1gYkA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAej3BOieadzVon+SdSBHau/PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNlZGYyZWItZjBmNy00ZmUwLWJmZDUtMzk5ZDg3NmFjNjk1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZGZmYTUwNy00Y2Nm\nLTRhY2MtYTcyYy1hN2M3MjZkYTBiODgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAThLa+kVaxH9DzRc0K2RLqGZEqi+6bQi/+5EDVsjVK8nAUpZ8nEfLAvY52w+87+\nfBaMimRQXytVN188CU6pWVT7o3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQroF9IIj2g/IYY\nU5PXyWyas7jA7TAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhANp//t8Q4dGgiaovFX9HudoPp59oc5yiuFZdwjjQHszGAiEAvQ7N\n9t58nb6ozNFeHbXa1HPES2X4+9325njGWzw0RTw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7856", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7856` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAQ9xN7IfV9Ka8eeNOUyQ9KH7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4Y2YwYjUzLTQ3YTctNGJhZC05N2E5LTQ1Yzc1OTgwZjI0NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZhNzc2ZTgtMGQ2\nMy00M2UzLTk0NzgtNGQ0OTAwZTAzY2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw1YKjB21PZzfqGY7nN1jEEsn+pvPE7fZPj2g+SDQAuGIS3rxZt8hLdv2+imA\nWK8n+uyTfcOs3w7k/VDzioua+qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyys4JXqyMAHz1J5z/bp/MMvoFcUwHwYDVR0j\nBBgwFoAUJoDRKA9y55BZXK1HhUOcg+m4qjkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgUbWKZ8QvoSJBgzvxJJyIOMZfeTrr4+X9hhCPrnTk3cICID763Imw3jvb\nz4SAUYZs/KccgFi7a+aUDu2qktEMSFua\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbpF3eeLMK24kPvBCsQbyQp4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGNmMGI1My00N2E3LTRiYWQtOTdhOS00NWM3NTk4MGYyNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/q/ROKYhzPXjHCss0IeLisKp967Bua/ddjn3eLTtGteto\nfxyw7q8MXltau/Ql853prF/7mlz1x280WmNndfVNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJoDRKA9y55BZXK1HhUOcg+m4\nqjkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK1cnUWKk3QGhM/xFEwMtWNDsnIeYU+/kNsDowrCLTYsAiEAkgKm6Tf1\n9n7PM59p3pIfWrkNo9qk0BJPILsMtcKbOQA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAd4FmL5SW9xhsZYitlic5t4aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZhNzc2ZTgtMGQ2My00M2UzLTk0NzgtNGQ0OTAwZTAzY2FiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MmU2YTA3MC1mMWI0\nLTQ5ODAtOTliYi0xYTQwMGNlNWZjOWMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQMcSdYK4KyYERpTToxW0PWXehZfsEg5CQK0hh1A8W19SqLrrSSzk1+tfRZBz5r\nz1x6v0QKMxfjdobwVsxjmw3ho3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTLKzglerIwAfPU\nnnP9un8wy+gVxTAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgO1UUvTr17ZqPepe8nYdZIZVt81Yvml+Ac9tddKIhmJACIQDacyNw\nG8F+4FehCdxbusLgZVmC5Ro0TVqTL2Xi0DIuCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7857", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7857` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAdpUiNRdYu3X5tGvonmJNzpvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1ZTgyZTQzLTI0ZjUtNGQzNS05MmMxLTM5ZjU3ZTcwMDhlMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIwOWU3ZDItYjhi\nMy00ZTFmLWIyZjUtMTU4YzViYWFiY2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElYkQpaPKCCTS0ZtZLO56qL+zdKTo271TDVXhnt34XgygGOhUTSVR6cxUSwgt\nSzmXn3tD6uY40LDrJn8IfAKgP6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfRLBXoy7rhMf/JVBz5V6RNzcR8YwHwYDVR0j\nBBgwFoAUiC35leSnKbsxc9xtN9gsZSH09+4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAOLDaxqrDsO4EtL85Qkm/j1I8JjQ+sRvtmB0IpyFP+T9AiEAgBoJ2GLU\n3Ub7EmuH3koWGEu5UmgO2iOkjf0zm/5hWCE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaecVuhkptHUk3aebPZV65YXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNWU4MmU0My0yNGY1LTRkMzUtOTJjMS0zOWY1N2U3MDA4ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdpa0IrFDETwJboaQqqZ97JTKHk85/jjPlxgijFRFqapLm\ntL2bNoxRr9MevPqCvzV1hxmB1pd63qTbtTKViSr+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiC35leSnKbsxc9xtN9gsZSH0\n9+4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYF+1SDDoA8ZwIzRQvPzOipjQGRkmK+awYEFgooc9sMECIQD2YdbPEyWV\n2X7tb8wk+tVqHsbtTYQZQCF4VA8qkMjHog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISARrxlNnjXHDL6pO81o54iYgTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIwOWU3ZDItYjhiMy00ZTFmLWIyZjUtMTU4YzViYWFiY2UzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZDkzNTIzOS05NGM3\nLTRhZTItYWIyNC0xOGJhZGQyMGY1MzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASktga5PIjiPHPQczmRI17XBRc5Q0H05QwyI0lVawqih4LmOFIiyfk5W+uK/lD7\nOjJdemAJlTPCY+6SVwgh0ZIvo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR9EsFejLuuEx/8\nlUHPlXpE3NxHxjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgCYTtXCxPPGoWghkASvzbZoLkD0jgjUghjH99oKYJFAkCIQDodaU9\njoeYYJkABPwMtBcuFxS3ugqEIynmKMSkW8bUjw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7858", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7858` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAbQhWS/Wu5BKYhoU5JPQdGxSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwNmFkNWEyLWVjNTAtNGI1YS1hODEyLTkzMThiNzBhNDAyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVkODYwYTctMDhh\nYi00NzUyLTljYzctMmQ5NDRjNWJiODc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES0kU50wCuBYi0LNEdZ/H23fMhDdMmHz0nncy+SOt95RfOYBpvOIFh8/esQHL\nd004YDHyYsXsHhhL43xiBu0hVKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU4BDf8PU8UdCLyIMWgrUfofnj1IwHwYDVR0j\nBBgwFoAUdXqqxp00/YbQ5Qxblh7GAkOIIU8wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIBclA70/L9VR14vwYq/8vvO0G3o3xIOW48C+U7G6yWa1AiAAg/aTmgWw\nRDUMEx3Rd/NoQVmasDsooipVdyDvJYYSAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXjHzanPUj6C3WdFLzQc7fQDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDZhZDVhMi1lYzUwLTRiNWEtYTgxMi05MzE4YjcwYTQwMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/1IIqPkf/ASaJiro8rZOVLsMQVhv11/H/XtkZ5bq8G2GF\nyDFi5RKzURdks6/6v7at5kSzTgdTYWJt3v+WIcCbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdXqqxp00/YbQ5Qxblh7GAkOI\nIU8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOGt8YiRTqTUdT0GfC67j9/ObpSgd8LZyHdKpET5WoMxAiA/QgNzhG28\nUJk48vNvK8dK6CxwfHQ68y7zrbE9GR+JgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAU8YCPrOPiJDwIq8KA+G0dP6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVkODYwYTctMDhhYi00NzUyLTljYzctMmQ5NDRjNWJiODc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNzk1MTMyMS0wMjA0\nLTRiY2QtYTA4My1iYTBlZmM5MzMwM2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQtabXu4VFJFZL/LfFfjfCEWhZkpL+l0aqaiQEe2IQ/wlEJXiMrjPMURGGk/vZs\nMwqEPcKAQp1oBxVbAK0z3Ojyo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTgEN/w9TxR0Iv\nIgxaCtR+h+ePUjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIhAIAZ4NpOGy3W+gNM+1/qkgJG03VIIzArOCl4gc88xlCrAiBi5CYM\nUW60uhvuU9i9o/maluAAHv69SjR0nSNuSytxFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7859", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7859` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQin+l4PowZicUKgnnst+ST+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMGRmMTViLThhYzMtNDAyMC1iYWRjLTg0MTNiNTI1NjRiMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQzZWFlZDgtZTIx\nYi00MDczLTljNjktNWUzYTUyM2QyNDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcztGwBNPU/Xoo0INYVUUn1j4mFzpjVQ3W3Ky62WvPzs4mCyX4UAph/UldFf4\nqy43QOO+8EYacZtflyIA3DU2UaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1R9HuDvpSs99XIA5Q3S00WUYISIwHwYDVR0j\nBBgwFoAUaATg/SVZQu5o8+Gio1DM+9n168swRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCayqdwJlT6DmXXyprEDETv3SyvfF3Fef0WufrH\nFSjHFQIgTYily+P/DlJr9V5SYjNyFJXuI68kFwo0ndfdyBQt9jg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATv9X+2vWfSJ4/IAPP5upAYtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDBkZjE1Yi04YWMzLTQwMjAtYmFkYy04NDEzYjUyNTY0YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9XVNvhs7cLuQku4v8nuISBTRoumgWKjwUsW68kmlZK4ZJ\nm4B8ykJMTDDAa4PSCVddNC78dK7NBQ2hOuTfmUpBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaATg/SVZQu5o8+Gio1DM+9n1\n68swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANlg6HzfcO93Z01ATWfIEkIL+PxykfFlkKDSxi75461LAiEAqokFszC/\niEb++z11aFtwu+qdJWtuZfNukQOeQKUD/HY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISAQbgskZA92lmiGjhVyX78e+GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQzZWFlZDgtZTIxYi00MDczLTljNjktNWUzYTUyM2QyNDg3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZGVhNDdkNS0xZWEy\nLTQ3NDMtYTE1Mi0zZTZmNWQ5ODY0NGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQl+10U8InmzTqHrhHHcsi3GvkWuYsmf0Jv5DK0SEUgtExdMgM0ggCq50BZswUW\nE0wiT6yAkK3GiTKY1Mg18sqdo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTVH0e4O+lKz31c\ngDlDdLTRZRghIjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgM+ViB0RJVKGqEZGgcHGV6JEwUk7MnOWSrPt9o3/Hd1ECIQDedSMY\nJ6gdxbWIja9FTPhawA2t2Cy/B71Nsv5NEEvz2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7860", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7860` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAUX1MHeVnLrj6rksFBKzxbXhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkMDNiYjM2LWM4MWYtNDUxYy1hNTRiLTM1Njg1ODhmZGUwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ3ZDM5MGQtZmE1\nMS00ODY3LThhYzgtNTgzYzUyMzZhZTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBSa/Rli+knId+2vUateh/S35cBJ5Vgkqh4ajeqmzXNOHXQ+oN8f9CEggzGh3\n/8NKIn486+pwVdwJiyAKx5Y1daOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxDfmoYu30itJ7QQ3rAi8ITdsdxgwHwYDVR0j\nBBgwFoAUOp8G91SkpEkO6APGr5wod1efqwwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIA6J5lxo7LxK8ouAFLK1k2bYJFC1Dm9+PFYH/+Z2\npOYyAiBSyx4UhH54Ys6MONGA/wEuM2OjMa1Ov468w+mfPsLwxQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaX1rt3MjYTrbE/KvUeHP4RuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDAzYmIzNi1jODFmLTQ1MWMtYTU0Yi0zNTY4NTg4ZmRlMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwN6SbGdsUy6J37IAomkKgqAQ9aeV7DMzo/muMlCXajAJp\nHtb2r08D+rVF18H3dIfBua1/aqStBYhCBV2pVJ1Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOp8G91SkpEkO6APGr5wod1ef\nqwwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP5wM/M8iyPd0OXe/CNIiETdU7FeC8Gz9wFLAbBPvIMzAiB1CX26+CQ3\n/ZWCaVLXzg2RjNJes7bGmqL3o9gYFx239g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAaPMkAPx4cjap8ElOZpa/SsAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ3ZDM5MGQtZmE1MS00ODY3LThhYzgtNTgzYzUyMzZhZTQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NWM3MzAzMi04NTEx\nLTRkMmYtYmU2OC1mZjM1NmQ1NmU4YjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARVjVDQ6T5qCBMujPN8y9pkkomXHROC2aVa5SdVRX04YGdC57CnleFCqXk0NnfT\nVo0TBsqa0nMXp1YkMJh/clmTo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTEN+ahi7fSK0nt\nBDesCLwhN2x3GDAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAMNOR5eebVw5hblIKpwvH1Ru3yZXL9dT45F5hbTcwHAyAiEAxp1q\nv/1LTavl8vEv1Rd5R0vXeBGlJTmh3hTyFH87Co4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7861", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7861` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAeS2K6m9/jJvyYsP3Bt5iol4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlZWFkYzA5LWJkMTMtNGRlYy1iY2JhLWU3YzU0MzcyMGUzYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y4NDg5OGEtZjFk\nMC00M2MxLWEyYzAtOTdhMWY4YzE5NGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWZi7c8wnefnkyNK8abkG+4X4+ubziQid/wki+CF05pgQnJ2/iuLqfyJ2BcSJ\nyzKbGdvoAMGUj9o/ypb6D3v6paOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzfAPe6dJQVlaTJKdCO8+xrI02lYwHwYDVR0j\nBBgwFoAUdyuH/HnP+DOIhtj9XCI2dYL1eMowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCHyuYzbVZqpYmIMztGy5ywTsl3g+eTqiHhyf48IvhfCQIh\nAJvr4lmO4J0pHtOXgIhoQ+N0LjUUVpwdYotIUEYUpMY7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUpem0HnfYRGJnRYs1TDU3/7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZWVhZGMwOS1iZDEzLTRkZWMtYmNiYS1lN2M1NDM3MjBlM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaR3+yidCb+GupL9zFkI/DXZ19qBZS4e8DM70XzLROfd+2\nX4vGusYN2FXwNicaR+buKpl18WCizvVOJcx26re+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdyuH/HnP+DOIhtj9XCI2dYL1\neMowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCiLpdfKLPJ0FBdAYjC/wnG3t2Jo6o0KQsrCQb2A8a0cCIQDpkudC9c/S\nhdZQt6GFEPlwX68+N0HPjbk7wUrcH2etfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAc6gAwIBAgISAZxrnxB6vg638qRh6NPPBO/bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y4NDg5OGEtZjFkMC00M2MxLWEyYzAtOTdhMWY4YzE5NGQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYzJkNzA5OS03Mjdj\nLTQ0YjgtOWRkZS0xMzkwYzk4MTgyZGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQdn5NHJMm5LS137NgFM1VHxS+vHwRkGE2xJHqDzjNQZyJwuafM8IAVj2X2qdl0\nAUFRtxYzL9EgOHibip7PeVECo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTN8A97p0lBWVpM\nkp0I7z7GsjTaVjAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDRwAwRAIgLCOg/5MS/Z/zq6io1qUdUFOAxsFHh/r3p/TnQdlr83cCIGrwueD6\nJ7/SvyO96Rjpb0folPiRNBPkaWFrVp9w1hyN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7862", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7862` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbsP8DmQ5sZAjaLso9ximHi4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4ZTJiOTUzLWQyNGQtNGIwMi1iYjBiLWEwODRlNWVlZmI2MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRjYTIxYzMtZjI1\nMi00OWZhLTkwNmEtOTVlOGI4NTM0OGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU0niofroaIen75l4YBp/A0tsUPEcWcyHyempbE7AINlVQ3QhgahHsXnFItA8\nJaoUgS5n2NbKOPRcxmX4eIpJLKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsfFv40CoDs8t3g/LCwHbj/Co194wHwYDVR0j\nBBgwFoAUwVuV1jKFVPVbBPWTA+hReI0WpKEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDEa4fDEdCncCbUbKSl3/y4B+3s4eUc\nbnVIsEIv7uLnBQIgTx/wPLWAmsbOEsCKLt870tU2LAcPIocZyk5TO7EDG7E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWMxVopI2a/tHcRE8qfkVnHFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGUyYjk1My1kMjRkLTRiMDItYmIwYi1hMDg0ZTVlZWZiNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNw3ougqUGoz3MBkCG16N34jN04CMwhmxFaP/zCnQNFiLJ\nwrwDaeuAGJa7XHKv0YxnbmgNjRzOu5UDtP/0xnAco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwVuV1jKFVPVbBPWTA+hReI0W\npKEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCM071MYLj/NqlizCzOa/IQlgRnD0XPkBGh0EJxHAN+0CIEWspnYYtDYH\nqWLAo15HPUPEbN5RrRjDZyRpK65SWFIi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAc6gAwIBAgISAWJFtGscjxYTJ3eMh1ZXrRw2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRjYTIxYzMtZjI1Mi00OWZhLTkwNmEtOTVlOGI4NTM0OGVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMjFkOTgzZC03ODZh\nLTQ3Y2UtOWY0NS04ODlkMjIyMjcxNGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATKZ/9Sy2rq1Z0zkAidrzhAkrb8OGkemZXxf2eTEG/nuzKgG+0UUiFXlnW83I7t\nJRb8bwQ+TVgrpoqKkx63ScDTo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSx8W/jQKgOzy3e\nD8sLAduP8KjX3jAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSQAwRgIhAPjUwK/SnOYynjO+njuKB/5zWkP8xZ1Pzw38JRIi4xbAAiEA72T8\nh6tXEjtbF5aKeCBtT/Feyluyt31om+2Za+L50tI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7863", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7863` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAWyqwZoeCcVXPrJ5uZ+zn0HUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwNDZiNTRjLTI2NGMtNGI5OC05NmExLWM3MTA3NGY3ZmZmNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDAxM2Q2YmItNzgy\nMi00YjQxLWJiNzAtMDFhZGU3YzFiNzkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK5GNauBAyIypZTPa1m0dCsmpKRUQVSBfc0IMbEmFVzNLkH2OEl+LO0CPpZAk\nH4HWOVdGU/ENajeYvJWOHbukNaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU12xmz+ZwrKFaUY62hbCQd9etu/MwHwYDVR0j\nBBgwFoAUDCEPL0hq8p7UNLsbW+bVS0onR9gwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD+pUIIbMNAiQH7Lv6La508r0+5q7zA\n+EAYROMDBiQLHwIgLZ2cI+xA6V3ySAk9pskoanZWk4vm0gCsYmimuAiY5Ow=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUYa79O7LLPu694u/IJLXkEvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDQ2YjU0Yy0yNjRjLTRiOTgtOTZhMS1jNzEwNzRmN2ZmZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4OtVYGMb/Gdq2YCX+Brfq9CEo4BrmMZIc+O9qjKEql1Z4\ncW/X8TG5JSBmnovd2JhNsUywhqCguwdSJRjUmk5Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDCEPL0hq8p7UNLsbW+bVS0on\nR9gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOYyujIGuebdvkXGWqEzgvFrkMdi1ha7CkfPJrvoDh+nAiEAgss6j2Sl\n33wqw8q2AvhGL66zvHiQiFfFdTx4gnN+j5g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKDCCAc6gAwIBAgISATr4lNbLkGdEDIOVfx5Pk+jPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDAxM2Q2YmItNzgyMi00YjQxLWJiNzAtMDFhZGU3YzFiNzkyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyYWY1YjkyNi04OTc3\nLTRkZTctYmUyYy0wNGE4Y2Y0YjQxMjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT4MIhW16WpT3JjXhGa7oL7LHqMRW3s8dhj9Eyez9zj7fOR20atY4CM4n0XsO+g\nlHMVNN9pdsb9y3hxOLvsVtzuo3IwcDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXbGbP5nCsoVpR\njraFsJB316278zAaBgNVHREEEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0E\nAwIDSAAwRQIgXO84vrszOqx8yEtpTq/HlYL01vSOzmqLC6/pXDLkOlgCIQDAAmbk\nnT3yKAPp591t/+XzbuHOnt/Y/eXprryI42N+FA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7864", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7864` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAerik1pSiFZepcEBuE90qMh/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2ZjdhMzdiLTk1ZGUtNDFkNi1iYjNjLThjMGMxZmRlMzA1MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc4N2FkMzYtMTVh\nNC00ZDcxLWE1YWItYjFkNWY5MTYzZTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/tQdXhuWX0NRk5rMZo6c0QZGzzcF35aAZqPudyKjePkkih2P01U3ZtxSTy03\nzxO44wqx25XALYWOzNRAimjcXqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFH/yda1VAI9URjFmSOYx0BUo2ICWMB8GA1UdIwQY\nMBaAFOxO6g+NC2MkQFrrE64XdgTxWXhFMAoGCCqGSM49BAMCA0cAMEQCIDLngKnZ\n7xGpVow9KYb0SREjilOGscOchAvvxwxz+0DZAiAha5Tazb8itmyN34E6vhVGFOqB\n+aeA0jWc+fKM849TNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARs8AOhf4dDuwT5ZWFsWb3yeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNmY3YTM3Yi05NWRlLTQxZDYtYmIzYy04YzBjMWZkZTMwNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvJ7+fgr1Cjd03vKKgTnKdT4sJembiEXR5gs8mZV6Hgfew\nmO5H286VMVyqhzIbfQ7Q1noaui+5uZLNkg4o6Jrro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7E7qD40LYyRAWusTrhd2BPFZ\neEUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXefXbkvdqVa1bByN/uJCp4OhCCp4OE6HCc5UkUBVfGoCIQDylAr4Os+r\nJZ9L1OTmrl9c1n1vw26k3tEuEmT1gtNQcw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISASnVazA7kAOTONYCRYFwnA8NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc4N2FkMzYtMTVhNC00ZDcxLWE1YWItYjFkNWY5MTYzZTM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlODAxNmU5OC1kZTk4\nLTQxOTItOTFiYi03ZjA2NmJlNmZjNWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQM/27SW1Fy7droB/MG6letKIFcQ6CWImHHosMD1wheES5lnwLLQlUItfCaTpk3\nsGSrQDd+QFs1IdMYyzoXbhZqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/8nWtVQCPVEYx\nZkjmMdAVKNiAljAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAIhOuTCDVydQHlcVih7zT0DOu7PeZzstQvUKQtHW7+XS\nAiEAoTvcNrI4RHsMsh1j46da2Jn8XoOXfVCAUWygIqa4hWU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7865", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7865` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbP0gRYK6NE9+s8I1f/x7p1AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1OGYyZmY3LTZmZmEtNDhmYy1hZThjLThkNjAxMGE4NTFmZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzk4MzkyMGMtYzk5\nOC00NWQ2LWExZTgtYmI2MWEwYzRjZWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaOZFAcjJECFdnREpoazdLT7Ag7MWwQ8ZQ1PgbzsQoel5oOdJb7+AE2G9IST7\nXZ0lACIR8qSh2DKVG4cziSy4zqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEI/ZABCJDR+e3WvfaBNV58sDYqrMB8GA1UdIwQY\nMBaAFOwCFg/AAioSoMjiPcRL+9DNeUOlMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAyrrfLL3wLwSuqyIU6tYEbNWzla7FdZEO\ntqGuAuJvYZoCIG/LoVFbkExXcH/knuotGjyJmU4rfBgJIgrE5lbQMqKA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ04Vtt5giO22jaxXnNuvnP7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNThmMmZmNy02ZmZhLTQ4ZmMtYWU4Yy04ZDYwMTBhODUxZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTWQBfdrCXVpXfdJU/6PJJDRb+s17UDcjzBL7ZQVaSFbwj\n+TPD0//ejefLS0kBAWsmbPWz6pLT6vWDdyI5usAYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7AIWD8ACKhKgyOI9xEv70M15\nQ6UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVW4TQIGJMyHv7FOm/gjNCfJ6iLKD4WCVRT+hXyu36VUCIQD/l1GD9S4W\nerMk/t9Gqj1yf5Jm4Ec2oeeJDHVTrgATlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZcFVC69DpQV7fS5B8QyPJ54MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzk4MzkyMGMtYzk5OC00NWQ2LWExZTgtYmI2MWEwYzRjZWUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZmM5NmZjZi05MDAz\nLTRiMjUtOTUxNS1hOGI0YTg3ZDk1YTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ5O8BZ3pL5Pu1esIw/tgNpkb+AEnNRXwGVpAKTljRe8kteU2VAWfi9XlR0PTBb\nl2Q6KeD3UP15CTK+9y94Q45xo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRCP2QAQiQ0fnt1\nr32gTVefLA2KqzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAPD7fjPUto4T04xJwbzuHIA3huCgIl/Xe34dN/pxFVV1\nAiBfpAKogktH3hROVQLs6FoXZ1fHhnw40iwXbNvuISxI8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7866", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7866` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZwltcHE2L+GL7trF/AXV4o0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxZTQ2Y2E3LWJlZjAtNGMwMS04NGFjLTYzYTIyNjQ4NGY2ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcxMjQxZWQtZDIy\nNS00YTNkLTkzOWEtZTE3ZTY5MTQ5M2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER6BOjzMUvwu8MLW8AV3Io5kO/5GeQoMO3SOh4PjpoD8XHwGe+CY6DMIvPHX/\nH3JEvGz4Nrue4UXf/7mfNwKmDKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLwIoLEksMVen62xzKB5uGW+6MSHMB8GA1UdIwQY\nMBaAFAIhztELJIYgWl83QGF11r6JIkXGMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAnJ7akU4ZmsVxja5E7h8anZp3qMZdQdAg\nbhT6SVNHhsgCIQC7fHyB4dO5IO0nnVdpYiCTyw4uM0dU8h3CWP//JTJK9A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfC2CmTqXGmR+V/NvKe7p4GjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWU0NmNhNy1iZWYwLTRjMDEtODRhYy02M2EyMjY0ODRmNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnUdsxdHPPUG+RXUy8ddYfjF4Li0r2aLdNkS1QIuTulifw\naetdZw1fybTHbQ6VC077NlOqzkV2qw+dWHP0NPIfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAiHO0QskhiBaXzdAYXXWvoki\nRcYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI3LRxw6R/WMxW6GiRKdkhAyLa+cxCzdW2UshtiMRzXUCIC2+qAX3GBCt\nN6v9rShizfhFK4Iigm97xVAsOUOgk+eb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZ0w1faXo+ZCxzSDkwgRza5YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcxMjQxZWQtZDIyNS00YTNkLTkzOWEtZTE3ZTY5MTQ5M2E4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmODBhMDJmYy0yYTk1\nLTRlMDItYWQ2YS0zODIxNTZlODY3MmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQLFjIyNnbI0ZrShqRmfGw7MVXI3wQv1lqxNFfIGt4TyI1ZaHw/riA325RzQrPl\nG4p6EQ2E+o/XB4n4dcKJVYaVo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8CKCxJLDFXp+t\nscygebhlvujEhzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMy1sgOaPmPpX9jVn6qm/+6skdPwVz8mU+sZzwWPJlu1\nAiA9GYq5uxqUh2uB/Xl/9ZchCoeia/oM3iaEPLb+n+AJ5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7867", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7867` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUU1GhrBlbFRjNhVsB3s0bq/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlNjFjZDhkLTY4MmUtNGZkYS1hMzhlLTM3MjYyNzU2NzUwZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA2OTE5YzYtNzhl\nMS00YmY5LWI0NzMtMTQ5MjNiNGY1OTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPcehtCYBTc4VKA/VvNpp2EBZoLARRKV76cabme7XoY0hg99dCT9Zb06QCKUN\nC4xrImSjqqRAMlkxUrRnDu9Jd6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR4X0tORM8fjywG7h9Wo/TT0x56FjAfBgNVHSME\nGDAWgBT3OtaXBeBmuYglkzyHr0Dqy5EewTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCGufhw4t4NFxEQAgXGPTF3O9RZSAAE\nJ7MoEspX5j4fPgIgU9MBtmUr1kUSYnFMiOv20u3c2Aw4S42S1+eOeZLygSA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATiAGqBgsHTXsoamxtZZvpjwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTYxY2Q4ZC02ODJlLTRmZGEtYTM4ZS0zNzI2Mjc1Njc1MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR71QbPCNh/GJzqi+K9r8iPpO+GyUqMyr0rqWcKgtGv5b9+\nSNbSL/abEokOpgjUZEeHSDFa9PvMQQkEbFi8BXNco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9zrWlwXgZrmIJZM8h69A6suR\nHsEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaRGddxPWCiZY3aIhoesR2uh9A+7tm9sm9/5EcmeUwWACICJPiUfXGSO0\ntvOrqK6w000XRUioA2IpM5Ssd0xJPv4M\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZfghJSxbQr+wxYciUhwK8eUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA2OTE5YzYtNzhlMS00YmY5LWI0NzMtMTQ5MjNiNGY1OTFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMmI1YjQ0MC0zODEx\nLTRjMjktYTZlNS03NTVlYTlkYmUyMTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS+HT8jk5y4b01kUaILnkyUPEhWWokeSq1tak780svoZWpfCEebX+jhsG/r22nK\nz7FVXMJCMg/Ag8berelPpicjo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR4X0tORM8fjywG\n7h9Wo/TT0x56FjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAPD/cuNO3wUAY+CdTV2/U7btHU0+clP+q2dUHIf5kmlw\nAiBr90APATkjUn3kbAAOavRFxpdxRIdMEkDB0R9z4J7LnQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7868", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7868` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAVc/MFPIi54SNo27j2hsEIerMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4NTYwYTQxLWUwYmMtNDZiOS04OTFlLWZjNTVlM2FmMmQxZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVjNmE2MDktMGZl\nOC00NjA4LTg2ZTctMGM3YTdjMWY4MzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEhpKocLhJWGFzewynnFTm0E3Z15hXVRGz/QohLorhApdr93Y+uEYi8YCQWmA\nJzPg8K62H6oEuT5QXgllLpsOY6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGAn83M6/7oxNevKwZEGk8/v0TPIwHwYDVR0j\nBBgwFoAUro0yfbdaw6zgUB++LrjRcB1eFN8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiALeX1PFvrq7wOR\nUscajf3Uitdru1dzT44a+riKB0STGwIgFyfhSqNZ5WtfDXdIX/1fCg24wv0ZC+9/\nZFFyXdh1YW0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeiMPnAoWpj6CXmN/TnwGoQzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODU2MGE0MS1lMGJjLTQ2YjktODkxZS1mYzU1ZTNhZjJkMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhR3PR5wdng1TjLfP98x6o9QuaTqmBKdscG499ZmjQVkFu\najyqFTeWr19gttzPCZr5p7d1DNOWC3z03rwPScoho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUro0yfbdaw6zgUB++LrjRcB1e\nFN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMlCuXT+xizpvKmNcTuD/24hnfjue6gb0jXVhqx7xU6ICIDR48mgFWN+M\nFr1xO58g57VEqD1tpBF6rEDgiEt9U2R7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISARQqCWLsfRdSBu6q7CdUbP9eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVjNmE2MDktMGZlOC00NjA4LTg2ZTctMGM3YTdjMWY4MzQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNWQzMmIzMS0xOTQ0\nLTRlODQtOGE1Mi0wNmYzYTQ5YTg4ZjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARvyKtWOtLgQEPwQX4I+mD/db4HsPp7QlbVKqc7A4tEwsGNem1S5vUsd5Ynth2D\nXiKd+ptaZ7MguGf4kB5DNc/Vo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQYCfzczr/ujE16\n8rBkQaTz+/RM8jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAOjXUNNaistlh+kackExr5I+gSTQ/gg6M5oWINjXq3yV\nAiEAl3/03A/QeX8vW1M5GzIg/OUcw7gyNZ2F8u3h1pZosnM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7869", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7869` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAShfYOvdrys2KpD2IydvUOZKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZmEwZmEwLTZhM2YtNDJjMi04YWU0LTFiZDliYWY2YTc4ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzZmYzg0YTktYmM4\nOC00NzY0LWE2MzUtNjYwZDBlMGE2ZDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWQ0tVf/W6mxIBWua4+Lf8LklE28u4a/4iChyr1bJRkA8F+RvdGpsgfOi8Iz/\nQc5u+5AZjs9mGVmyA7cP9XJPXaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyj37uotcgUjpD5LihuDoWSLHnd8wHwYDVR0j\nBBgwFoAUIeB2ZfouUHy5V8Crhj9QneAnWWswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBSRM/1Htm3rfAC\nCIkvDBMlj0rIMpORG1aHZfuRbqMaqgIgA3TEj9/W5GLCXq8krgiFkqe38kx/lqdp\nBF/+MgbAyvQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfLUPFmUIhyZTshYdCOo6jf6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWZhMGZhMC02YTNmLTQyYzItOGFlNC0xYmQ5YmFmNmE3OGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkZrGshz3IZzdwiVuQCqw1M3hBHssDJteU9h1o8+/xc6aL\n7bqD++rbrjqi81+9yKWcGVdMMfsS3sdnYehFsIOyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIeB2ZfouUHy5V8Crhj9QneAn\nWWswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbVTisBIuXktGVVY5aueaaGNN9yAdnn6mUsdZ5QEu1v0CIEPKR+X13o3l\nsvhf/A0eCQ+6O1OK5YAflbE8afO8wVIa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASz3qmR6GHFOwoyqg57gggOGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzZmYzg0YTktYmM4OC00NzY0LWE2MzUtNjYwZDBlMGE2ZDE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MGIzNzFmZi0zYTQ1\nLTRjOTctYjE2MC03OTJjZDhhYmM0MmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQpnvfxdPGLe3LrcrbwT5DEqX6tXSL4SZi3hwQ+NQ+HtsXTi6c+0ZAO+7YaZjn1\nwTTp0UlVDeyS6etJiP/CHJZ7o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTKPfu6i1yBSOkP\nkuKG4OhZIsed3zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAN+H9MdiHP6CMynjwWb+DYipZJEF1O7nUtEbs7LnQ6nx\nAiAvBDHPkR7tdjKGSFp3Dgin8Opvdvhvlbvpj7Gixg8EqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7870", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7870` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAafx2KpzZibDdLFbRFta5k0bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjYjdmM2VhLTRmZjItNDQ1ZC04OWZiLTAwNjUxODIyYTQ2YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk3NjBhMTAtYjk0\nYi00NWNlLWI4MzctODI2OGNlNmJkYjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDPLkeJvZvF+GLpHx1zAg9eGQUZSyB5ifJrohiPnJyZ8XN8ihM6knDbDt7/L5\ncAFWyAdTzplwSA/gwUQL/KBdYqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJBOn5KPThFGFx+g8LmellN8fDi4wHwYDVR0j\nBBgwFoAUpvjsnzs9lLbnCFmpReibdQOkp8owIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA8R3jsFOOCngaii+zslTB\ndZG+dr/rW7tgvFztYrb355gCICvQ5HC4VvTx+CKUxyHiHKbiMPOrG1IGhaQXLFsX\nHBpr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaWE4OSSsfwho/yHwTbmk4odMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nY2I3ZjNlYS00ZmYyLTQ0NWQtODlmYi0wMDY1MTgyMmE0NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKTzWft29acw+RSXQXjSvl4HNmtJ6yL0yLyz9GK7e+Nbnu\nRs4LfKvY7txeT7pBgGJ3DZdlgBe7lLAim80WdsUVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpvjsnzs9lLbnCFmpReibdQOk\np8owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKybOx+5C3aKBmvsGKr7eQ8ohrYV3M86P+gzwG8f9XQNAiBnyuiGRy2V\nv28iz68rWN3bMLjI564o+gmVj9x4Pn+fAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAa9JUH/91Lpt3EJY3vrXGCMRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk3NjBhMTAtYjk0Yi00NWNlLWI4MzctODI2OGNlNmJkYjQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiZjhjOTY4Yi1lYmM4\nLTRjYTYtOTk4YS0xMDFlNDhiMjc5YzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR4yMzIQy4P4EJ17aoHkCVHL8SLCFpj7+z3R5qNTomVpCUOb71lM5MBNOinvpim\nEb2aRuimPEjg13xKsolXhSH2o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQkE6fko9OEUYXH\n6DwuZ6WU3x8OLjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgf8PeLDZN0nzfP3ZaAmLZYpMC9FBFnS0PxBDlFPWXVfwC\nIQDEoUMCwpKlfCg4KyIZILr+UEYBbK3AShycLQsgAB9WEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7871", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7871` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAYJf7iUiF1xbrHhQcXH/MEpSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxZmU4ZjcxLTU4ZjYtNDAzOS1iOTczLWY5NjJlZDU5ZDFhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE4NGQxODMtNjdh\nOS00YzQ1LTkwMDYtMTgxMDE4N2FjNmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Im6SA6XvqT4QHEPLsLJ5hEjdxsBr+R1W5HrxHix/CwPwiMDiUIxZyUV4WX9\nHMauCmNnys3rW1qdMdApyP/jkKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBc9pRydmWrCwE3XL3BE9cN3f59owHwYDVR0j\nBBgwFoAU7KzSzZojofdn4dYCpZTNz//OWlkwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA0hbP\nEfRWRkF/keIZbPK+U4fLMAKiCsJcjSxP+dVofAYCIF3RA6/P2ayvVWnmduLyhDXY\nru6l2a0RS0YpmBLWtzW6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfhmPRViYkr7J4pySvqOsyctMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWZlOGY3MS01OGY2LTQwMzktYjk3My1mOTYyZWQ1OWQxYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXRJfu5IqCl1a4alsUTlIDrCW34nEYYBFvXAOp/2kZEo/3\nZU0ouMi8RdecGo5joajnRdITr6zh2bZ6cukoDmgFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7KzSzZojofdn4dYCpZTNz//O\nWlkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLWgRPF2qDHHq2dHsWuquOP7xFtaEHXJShZVO+XG1BWwCIEvquOS0dCm7\nwGKCNLwTOziu5AUlxaYH6LZvuy3nFIWv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARUwC49N5wUsS+hsIoDab0ZLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE4NGQxODMtNjdhOS00YzQ1LTkwMDYtMTgxMDE4N2FjNmQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwODE5M2I0Zi02Y2Nm\nLTRlNmUtOTk2ZC1hN2U5OTIxOTAxZjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATEgCgqUGK7HUMF0QqcXHmS8FQLWbgygiqJtnJoSM2TlhyxiysFu7j9Z8glqbRz\nXpK8oPC+YxcuuoZSDZpqk5Nmo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQFz2lHJ2ZasLAT\ndcvcET1w3d/n2jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJ1NsQ25JUD6d6drK8/v1QAGLC9XmysUmvWxwdgYyf8W\nAiAylO4rBmbyjDU/N6mZ+zrHS7uXP1lJev5OdzVajjcTKA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7872", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7872` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAQvXelI78WDL/MBzXM/rJKAhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjMzE5OTBhLTNlM2YtNDAyYy1iNzY5LTY2NjBjMmEyOGE0MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY2YmUwOTYtZmQ5\nMS00MDI1LWJlZGMtNzY5YjQyZGQ2M2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu+xllvfw6jJY2Bk560O+Z+6k2MhCnH7+EpAkhORSbZ1Sc8wtiQHDJaOdWt+x\nZpqLz/jLHVshHXE82wQ/kP1LKqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpBfS3ymxnxSLb8jsHrc2YKU1RxswHwYDVR0j\nBBgwFoAUmXbC/QJmWZ26J1eDBupRtcBjVYwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAkDcx\n4QF7oDDg3sy+XaMDY7rFcj9z9FBweZNJhC4hEY8CIQD3eMreOxublAmPHZRyZs0Y\nSDAvJPVEYt8w172EoAuPIw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcoyYlmP0fnYinujLFpd7W+nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzMxOTkwYS0zZTNmLTQwMmMtYjc2OS02NjYwYzJhMjhhNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQM3P9lrrpr/3OUejpnnadqrHZdXzRzMytHScJ12Z/dF7YR\nBUqPVM2uVeCF9Dyg5fR86VkTPORkdFjSF12itiHco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmXbC/QJmWZ26J1eDBupRtcBj\nVYwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCqr5vhHKtA0mewg18BmSGTQM0X2PXaOOw1NeQENskRQCIQD56hK98F5n\nXevV62KgW1FYRoJihdY3exNwtHyHtwPMGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAeHbzjDyJz/J78GyDrx1qxfnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY2YmUwOTYtZmQ5MS00MDI1LWJlZGMtNzY5YjQyZGQ2M2M5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YTA5NjVkMy1iMmMw\nLTRmODctYjlkMS1jNDA0N2UxZjQzM2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASMWP6X1srvEMvBYrvQLVIS6TUjlBk8iB32WFas8RyllEw0wI5632al7cIDVKGT\n1Ka+Ym2SuPSWVFzQgnIVGfEso3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSkF9LfKbGfFItv\nyOwetzZgpTVHGzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgNL7/t5JMqvBPVUr1wiaOo2Gj90vSDWCFJnLz60CqguEC\nIQDIj7yCbdm9YLbq8/zpYVJKmh11fgzgKHtJGiOgP5auKg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7873", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7873` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAWRW7J5fg+jTmMF4pVw5tvBMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlNjJlMTBlLTRiMTYtNGY3Ni04MDI3LTk4MTg4NjM5OTcyZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE4YjIzNDYtZTU2\nMy00NWVmLThhYmQtODdkNDJmODQyNTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYdLH0S0aYCJ5tQdiAc2eT0t523I5wLxMrbR8AhXq0ntiEPlOAahaW/It2Os5\ne3wwy5flvqZuNyR0b0DBXNkcDqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGS2Q9F1MH9evdYVd8YiWepyAf1eMB8GA1UdIwQY\nMBaAFDIBmV+gdI/bbQ02wJK5y/nbsCOQMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAhfoUDP7N1ACRvMSCfyJlMigjrBvxyQEL\nk+EWW+OrPysCIQCXXYNmdsQ5CdwHByGvVYNEWLsbmYYL0zLa6MhmPyoJEg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf5ZqjjcMaC28VGbZ7fRMdqDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTYyZTEwZS00YjE2LTRmNzYtODAyNy05ODE4ODYzOTk3MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/p8TRpBMz4f+SNvzCkogPsjOP1ccTAwFx5hvG4QRwuFTH\n7g9EMRbprAvHizNcntP7hGZVUGJ1Hp7rKRPft98lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMgGZX6B0j9ttDTbAkrnL+duw\nI5AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALrl1VU5rwrPoALTijPU7f+v2T8DNMagiSzspGLIufjTAiEA0zuwSxm5\nSKSMZhzW81AF0sAj1IOIJyTHuansJcL/Y2o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAcQnBhBMOQZjIDLN5PDWvo9xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE4YjIzNDYtZTU2My00NWVmLThhYmQtODdkNDJmODQyNTgxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYjhmMmUxZi03ZmE5\nLTQzZjMtOTFhNC04YmJmYzY4OTFhZWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATBsaM75wCpHcWYq7j6BJho3zm6HiSsOGjyx9a+ZuijOAa3pOzB3Jttrjyoys5d\nPI3cVUAPVyuNFxkcBqDqxV98o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRktkPRdTB/Xr3W\nFXfGIlnqcgH9XjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgfzli8GoR+RSK0V1sRYPWS6t2fl24lJwU1CzrZI221NQC\nIBvA8ix+M9OQ9HFekEp8aw3JRqmquA3QBYRYFMl3isKt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7874", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7874` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISASyt091UYGWwUOyZF+YkVQMIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MWI1N2ZkLTBmNjgtNDI3Ny05NjY0LTE3ZDk2YWY1NDY1ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQwNTJkNGYtOTJk\nMy00NTk0LWI2ZGUtY2QzNzZmNTA2Y2NiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+k7+gQX28MXw/q1Vv4DMS1ki3tLZ7OjhbVkz9ueUsAXYrBzbUdZY0uJn4747\npBmsBa3SRxuVu1YPOd7B9AjImqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHfUlv/9n2Cek1EX61st4ai9VFTkwHwYDVR0j\nBBgwFoAUeihb1YIBDxYUwUxW2PlE70a8E9swKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgHOJcD2SshmoY\nPdw+SjIuGgCO0D5K3HVuBKXSrqik/0UCIGC2ISLij2tGYoXDzOGfzlzDRPjcXiu5\n2LFOXdhGOPds\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc3VE2xRP4d0zZqiQWnja2VPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDFiNTdmZC0wZjY4LTQyNzctOTY2NC0xN2Q5NmFmNTQ2NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUdjRyeh5L7D5iNcQ76vF2j76vMkRkMzi8o11xytKgbFCi\nDyFcNKP1m1JsUXFIH7PQv41T+TknSzfQ8mwBLKr6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeihb1YIBDxYUwUxW2PlE70a8\nE9swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANaCD7FBqkH0b6KOefdwP30FOBKeynqZr5nzjCD+ylyyAiEA9i2d7IS2\nd8vgNqxJuTHKP5p+nM1f6DlLRhQQQyBISwg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAdVuEcRCemS9brLAIsRBbrPEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQwNTJkNGYtOTJkMy00NTk0LWI2ZGUtY2QzNzZmNTA2Y2NiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMTUwM2E3NS00Yjdm\nLTRhMDYtOWI2Yy1mYTgzYTFiZjIwODYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT0+Pp9pDkdxUzHcSxlefiDauoSKqcoGMSdPcLj+sTxa/04E7Cgt8NXrGSLJfSo\nOTrzAVk8a/YETOqnyNac+smOo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQd9SW//2fYJ6TU\nRfrWy3hqL1UVOTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAOwgHUQV8PlRewQXOcgsR/KGXq8SSGZtHVfK07Ob+8pO\nAiEAny15wgHNuHS2yzV+f3OEIfuIMnbERFTtVeoep+VDTk0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7875", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7875` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISATk802J1P7UWVxIeL/nCEiGWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNmMGMyNWQ5LTI2Y2YtNGJhZS05YzQyLWI3ZmI3OWE4ZDE4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgwZTk0ODAtZmU0\nNC00YTBkLWFmNjMtMDQwNGNhYmUxZmMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPw5PNsJiidQZCD+ozMrpCadTcgfN3z9SEIrq8PXTeeHp8mcupY3R3D9/ri41\nMT6JZCNHfkJj+lgz2C73pv47PKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAWnYgMf42ofI9x9gkQxdKIGrjgswHwYDVR0j\nBBgwFoAUWlJJ4DnPzvp1KGkd8r75bMq1e5owKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPW6mqwFY+/g\ntzSbfk/9ipZXRAV+6eL7rLF4bgdmKDxrAiBeUophVfOxunW1hX/xxrQtNAd48UlT\nSwXr1GKfk57cPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASYQzLcxO/TAMSh7GxaXEUy/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZjBjMjVkOS0yNmNmLTRiYWUtOWM0Mi1iN2ZiNzlhOGQxODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEOOFHbcDcxVxCPEhhj6E2LkcPbZB013PP04EUnm00qi6x\nmR7e6zCULWZAavb5emqBKUmcrTNvY3ME8Ol+QPe5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWlJJ4DnPzvp1KGkd8r75bMq1\ne5owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANQ3Rxt9fWjB5rR4r7I4csOjWnh7++rU8UVGqe+ckmwOAiBorKLUmAv4\nuRN41ovkO9zSkAI+7FfG0bVZLyXg2s0PAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAeCkIOnduSKLQxbcjlR4pmNrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgwZTk0ODAtZmU0NC00YTBkLWFmNjMtMDQwNGNhYmUxZmMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZjQ3NTVjOS0yYWE2\nLTQyOWUtYjI0NC01OWE1OTI0NTNlNTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARrEzVenmJhqLOX1InTLrHLv2PkfU36wl7kmVDcnIFRypZ+20wncIPxz6vyOmFx\nB/Mmx7WMVbFmAUT2l25om/KBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQBadiAx/jah8j3\nH2CRDF0ogauOCzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAOocNla58A9slMtwresSp23vjMcafUrqIobADW+OW4qT\nAiAupuzVwi2NPme2awLDUPz1gTMFj+tpMQ+FPfY5/yOddQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7876", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7876` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZuHfj8ainXxC0M2GiXiIZuBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4MDRmYzIxLTMxMTMtNDIxYi1hYjI5LTZhMTAxYjc2MmUwYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWMxZGUzZWEtMmE4\nNy00OWQ4LWI4OTgtMmMwOGNiMGUzNzQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiSrdv2LXsHBkd/T7hlJ1xhhneQRUvbhpREH22UjBQV8gzcjhF8MVe54XLJQr\n76cda2V6f74+9QbSkF5FXSVS3aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB1SMgXGvNWVv6oRCWjkj+q523Y4wHwYDVR0j\nBBgwFoAU0mHxT6JdPN11edwykpAO2+cY+UYwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHWOfW4pyCbk\n2bKiIrcOaC3EosmYzA8iXQF8bO94/v8gAiEAp0vkf5LdcnI0O3kOvcR5E1KDN/Dn\nDP3cfZ4UvnhtXxA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAavCA47MYZikOezGcd8n4zd5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODA0ZmMyMS0zMTEzLTQyMWItYWIyOS02YTEwMWI3NjJlMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+R9ZEva9yuNgYnLkDrYkp6I/prZXlDakefu8MMmUELqFN\nRBJ8Ofnii8quIiJ+s6t+Y2uG+RuopCroW7nd7gYdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0mHxT6JdPN11edwykpAO2+cY\n+UYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANj426qgOP8aWuICZt6lat72WFU4biWoKcpPam3UVIrLAiEAlS5HUTIy\n1H5VuhhkW55aIgS49KqgVDqNF39GSuu5DXU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAc9Ro/p/1smSqKqd+4RnHgE9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWMxZGUzZWEtMmE4Ny00OWQ4LWI4OTgtMmMwOGNiMGUzNzQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzNGU0MGU5ZC0yNmJk\nLTQxYzItYmEwYy1jODhiNzAyOTk1NzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARe77wjmEXLsYE6qgJJ9aQ3xzayBCh6Uul7vs8rm3kxkvYFwOSPVyMX7YFCIa0t\nCuAGpNso2q0jvx4LhfQSbhn0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQHVIyBca81ZW/q\nhEJaOSP6rnbdjjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAKOQm82bwJ+tTzDeAyGb2Z03YA6EW8hJakHbFfgRoEUQ\nAiBpTjz0GD+t25Nut4PCz7uX+4Yi39UxbARnQ829EkNUBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7877", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7877` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAfN29bMtPwtItTHhEsnxNzbEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiYmM3NGZkLTkwYjgtNDBhYi04ODRkLWUwZmE3NmUxNzVjNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc4OTZkYjAtYjlj\nMC00OWRjLTgyNTYtMWFmMjYzOTU0OWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyiCB9s71LA4qerYxKKD7VfTD5DIVzdcejWluDTmeWhR35Zp21k+MwGbPuHK9\n1PV30bx5+SxfOrJPEUHzvYbAEaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp2RemOiEqj6A+SSMTLdInxfqCfwwHwYDVR0j\nBBgwFoAUzssA+Gc6iMfahjGbNVo40lRsWTowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD6tOFsCfZHvG+z8rYhekScOu8OImREozrNIJ678XphlQIhAMR7sD8it4Xt\n/62eye4kethusBzDyhsNRyWyQBDtg+4a\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASfzWF6LxHkAspYoq0VyeTRlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYmJjNzRmZC05MGI4LTQwYWItODg0ZC1lMGZhNzZlMTc1YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATt3/mhLcMaflIEPsBrwav2sNQ1MuOYLOgEuxOH9ZBfYp+E\n/XIAFfxHaM2MUaQOYvJVD3wPYBk8itzN+fYDxBmko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzssA+Gc6iMfahjGbNVo40lRs\nWTowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEyS8SyflPQFmv4Qheg1ILlwfBy1MDeOO4Rxc+LEar/0CIGHPlUr+W3Xk\nGDBCu48OecoLDpEmwFAzeG1hgVxbo9Fg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAQVEZU91TGk3VAkz/gRAfOkzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc4OTZkYjAtYjljMC00OWRjLTgyNTYtMWFmMjYzOTU0OWMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMGExNTM0OC0wNWYy\nLTRkY2YtOWIxNS0wNWYyYzM3NjAwMzMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQjQlA93mTzFi72A9XvRcECvlnnRajaNr2xdQYAaeWo527CX2Dkz39ED2tyTO8M\nuAs0XqtlW6KzFD5/9aXi4Lxeo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSnZF6Y6ISqPoD5\nJIxMt0ifF+oJ/DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgMy+tzWstboWkqV/l7L5qWd6MatDUxOwhtWXsDHyyZAsC\nIEnslgMrlwo94gfIjXz8N6eC6hQsIvn2dYePnuemGPxb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7878", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7878` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZUsJfo24grpATYamL4+rnjXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzY2RiMTA3LTA3MGEtNDIyZS05OGUxLTE2ODE3Y2M1MDk5ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFlMTg4YmUtODRh\nZi00YjU5LWI2MDQtNTQxZjYwYzU0OTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEasg4CqvtG8ZFwfRGYNJJ1dXBOwCRJJJyk1eaxbcu/4z523ibbXYgV2DhJtSU\nYcjX5rmLdzYIbvbS/Xg+Yl9bhqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZNRznuHnZMEYtEo5mg4kmUFArnMwHwYDVR0j\nBBgwFoAUZzVGjfybPsFoRrDJtOTQ6a6fqWcwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCD+6mIp+lGwUvwhzNfxrn9nXMf/e2fSndGvpAxfggHGgIhAIR2RX837Hp2\npLxlkbl0ZQiaswAfdgywfAmJfoYI1Cy0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU/DxqTL6vD0MY2ZPYHWXmi3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2NkYjEwNy0wNzBhLTQyMmUtOThlMS0xNjgxN2NjNTA5OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8aANnLeFOwt5l7lPhoU3/lnpTly2lI0xbrwBjzKKYlswT\n2mVbVa1b8MqHe1ac/0zdC0Pthp4qc3h6INChPcsao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZzVGjfybPsFoRrDJtOTQ6a6f\nqWcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD0BckzkVRTlASN7C5JEXJQMnOluGjMls9VBpf+hZxccCIFiNIM2z4G2L\n21UWjoyLsrJ8+8wiPVnj2xKbx+3LGQTa\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAd7ZhgEPfnYCtOKvHwGOwkpBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFlMTg4YmUtODRhZi00YjU5LWI2MDQtNTQxZjYwYzU0OTUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzY2ZlZGQ1ZS0yZGEw\nLTQ0YjktODdiMi00Y2M1N2MyNjBiNTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS6TVf5fJiFnZFvLIIlR+x+chaD4WEejRGKhkz3ixUl9EpST/B0fXtG2edBEdOe\nhE6JH2kOBkqHNZMRCKKDGAPvo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRk1HOe4edkwRi0\nSjmaDiSZQUCuczAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhALrd5JgIM0cuIJYBT0N6oLmwqwklj9ddXpfcnRPkkj2M\nAiEApdKelvZYJGF1XEu5daWcKetwZaOVfx2K6M55bHCEp54=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7879", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7879` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAZRoLD3iNSJj00opiz96l5taMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxYjc3ZTdiLTRkYWItNGFkMC05Yzc3LWJiYmYwOTJhOTMyYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZlN2M4YmEtMDg5\nNi00YWNmLWJjZjItMzk4MWQ2OWVmNzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMHOxjrM97c7GDbqXKuVmUi/WEZxr6LBI1kIkFqvmKNQLaC+DqxmOWvfo9VYI\nNIenNsuE7AqXTuAko67JIxSKjKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3tFkKmhOOZ2z321LoigEQvEox+4wHwYDVR0j\nBBgwFoAUNhznPCNVl6frBjRYRt3OJ+M8KOYwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCv\ntIgBv+ccXfF/DNZ3iFmN2FYo2Mfom4i8frqEgnXJiAIhAKdtr56olY+Sg6EuPAL4\ni6sPYeJfQT8KWgFbXE3Sag9t\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR14vQs1Nq2Ls2MHzYI17aQPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWI3N2U3Yi00ZGFiLTRhZDAtOWM3Ny1iYmJmMDkyYTkzMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwOv+Y1ShaaTJhxyn+K70XygewwM1L7PdQm83rWrG+yyTU\nGgX34szG1VtfEY3j4efiBdpSSAhSBc2/njakA6ZTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNhznPCNVl6frBjRYRt3OJ+M8\nKOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaWQc8O14wOB4B6cFe/SxAQgq5N5qArZYB/uD6fXUtrACIQDVFrJs4iBq\n72cY/VzSo3RdaauzrVbItWdT+QyhvZlnpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAaHMi5kj+Mr/PKV1Lo8JUN/bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZlN2M4YmEtMDg5Ni00YWNmLWJjZjItMzk4MWQ2OWVmNzhlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYWI1YzExNC01ZDZj\nLTQxMDItYmEwMi00YTZiODdmOWE0MzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATUIawQsrG6LFpgRCX+6zLtwphrvmUTKohRgGAEhURMff1N71A5BqsWwt4fvlg8\nBOZee0Qrm4krAaZ18DuW+pO1o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTe0WQqaE45nbPf\nbUuiKARC8SjH7jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKws55+8BQEFPJ2C4FYAjsQFvH6nL+RhPzyA8Y3P4QJU\nAiEAhpCQIXWDPaCEC9ozHVS6l/192DsE/9yIWl5CkZu9Lbg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7880", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7880` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAT3GLpYH+PUBZ6Ya9DqSTyS+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmMTU2MmJiLTVlZmEtNGVjMC04MDUxLTlhNGM2ZmYxZDRhZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZhMDM3MDItYzAy\nMi00ODhjLTg4MTAtNzYyMzI2M2I4MGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnPKBFz55upVL83/DaCLFHfjOTyhdehlvZg/a/1kJ4XOEvL63nFx23FIC6zc9\nxnR2DiTOl84V0zJ8I2mHey2SM6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzKMJxqjNA8uuOGz34SqMiOF9DY0wHwYDVR0j\nBBgwFoAUkL5c9TC705WGcIYQG+Ip5mdPaSYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDliy8rLLrWAnl0EQmck2fTZK7qjx2VKQ4Ks3GYix09jAIhAPRG\nMJC7GnnkvLDI39P4j6+oEhaIYy8p+L2gROZyPfMm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY0QitVqZLm/Wbw/59VCPZwKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjE1NjJiYi01ZWZhLTRlYzAtODA1MS05YTRjNmZmMWQ0YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKqkQ+H3MTeqTEWp0jYyJg/v58pKIgfqOfgpplVolRjPXC\n3A/MeUORMhHgi1aeow23qPyOS2go6eIWihoitBQXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkL5c9TC705WGcIYQG+Ip5mdP\naSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVnkgtLVz0emMeJpmmy0BZ/VgC62uWjybdtXDzXVuNNkCIArptTT4JmBs\noVBt4o01VDQbUmqi7eFjqV4YuRFdTuQM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAcaT4xt8Rv9mc0QF6lwT7yXLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZhMDM3MDItYzAyMi00ODhjLTg4MTAtNzYyMzI2M2I4MGI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlYWU0N2E4OC1iODc5\nLTRjYjQtYTkzOC0yYjQ5NDViZTQxODkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT9LkISJ7IafsAVuJGFaOQTj/2q0iFO357sMXjufaUrlnm26K5DyaKU1G33Ors9\nn5X0wP2pjiDpRnbc9PyChu48o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMownGqM0Dy644\nbPfhKoyI4X0NjTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAPaSywvVV0YqcLDHkE9kmEErLQhIGTIGFfaPEMJYAlGf\nAiEAv6ed3YVMN0IHp3uoAKV8Mf9bLGsOiPTd5ddAi2P0GVc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7881", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7881` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAZ8LyOo6Ho769vV/zR8HYvOnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2YzQ5NWQyLTBhOTktNGIzMS1iNWNhLTM5Nzk5MjBhYTMwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZlNzBkOWQtM2Rk\nNS00NDJiLTgzNmQtMzliOTIxZGRjZmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVFI1VeI3QUHxK2E7hBEhRryRWcixzi2UffFX7/Oq35+AkOiGfn6bzYCQyvwA\nD/8ursIB/uHrFMqMSvOOlH9oI6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSshuEcQRa0EhrZXIJIA2tvdq4DswHwYDVR0j\nBBgwFoAUnxaEiTobqSVvcx7OFwyRQ2v/VFwwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICJqExSRXJKPe1kCxpLKXmBPKs5Z1QVYfA2C8rSnlMzCAiACRd2H\n8ZYaICBgnUIpGOSNCtrggFjxlMwFiZenJvbUig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQy0fFF7c0GrBPOtzFhrL9sPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNmM0OTVkMi0wYTk5LTRiMzEtYjVjYS0zOTc5OTIwYWEzMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEmz8DYm0fhxSoLQgc/V1AO1IXDcHHhWHkOOW/K/Vx3+C/\nt0vbsaqktD5r/PKhl1Jb+zKUEjzE0oaje92AENmVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnxaEiTobqSVvcx7OFwyRQ2v/\nVFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOoCZtXYN/IWoe1sSrNOX6jcxGe4AEM7wGGfxqFn7aqRAiEA9b2O8Po0\nF+fzuh73EdkiJyrr9TRsbznyDJUz7rkN/QQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAR6+SmklVz5IzyXBKYpFcL9+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZlNzBkOWQtM2RkNS00NDJiLTgzNmQtMzliOTIxZGRjZmVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyMTkzYmJkOC02MGQx\nLTRkYWUtYTFkMi00MzEyZWFhM2NmYjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATMpf3mi0SyyIuEc4wt5Yfp1B7m1Scck2uOA+DSm7lx9VbKfanKAufSa61ex6Rj\nIREIUr6gmVWjyKkJwabr4yXAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKyG4RxBFrQSGt\nlcgkgDa292rgOzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgCAWkdkof5rv/alSExvjvNVsbQFqcRnYU1gG2ACOP8dUC\nID9yUlLB2GhWb5AeoU+LE20OOPHAAjNjTgUQ0DGeYW1T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7882", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7882` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAfVgzJ7mhmQeAsvgcsQWKymEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhNGJmNWY5LWIwYzMtNDM0Zi05OTZlLTRkZmE1YmFkMDEzNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQzYTVmMWQtZGM1\nZi00MmE4LThiMDUtMzFkOGFkM2NkNDE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkZx4Luveck7FhmiMFTV6q6Ji2hmeVwjFqqWDbEtP+UKvB1r1llUiJD7/ql0H\naAylZglkph6Jcy4vkVL5hqUjHqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOuD0/338C9GKHxqUwRTOQNmpkLlMB8GA1UdIwQY\nMBaAFHVb8ns3XHMj38G7So6pyz/HiMhCMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAo3mKIElXvVezwk49GU90ZwNgZdMHBSRpo\nx6olu7EQAAIgHdT4YiH0HQSUfYSr/wbiZuhT+w3hJmd31bf4qlV/ovw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfmBfnkvgwADs6We80Ir+84VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTRiZjVmOS1iMGMzLTQzNGYtOTk2ZS00ZGZhNWJhZDAxMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS02+vEO3SAezwt5WPtOjDcIHHMKyZmB34VPllA+Mg6O7Hz\nFgtCb0zmCVp/4HCWIdkUgLTO+YCSQkM5HF7kZBu6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdVvyezdccyPfwbtKjqnLP8eI\nyEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMjbwZDtxfawClr8s/6GDjPz7PgbwGRF6LJO97djTe9vAiEA4XTWOAlB\nWAs9haK77mA5dQJS3qA9JnPEnmBgWzW3TAc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAfcsNszmb5gMV8rN0kRrTpZlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQzYTVmMWQtZGM1Zi00MmE4LThiMDUtMzFkOGFkM2NkNDE5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNDhiMzQyYy04Njdj\nLTQ1YzYtODJhOS01YjZjYjQyNWZjOTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATUvtuxlqust4bna4lYmXF6UyJAkGu3my+Ei7prSAOnqjZ6gsvlssAyjv/B9Lqs\nNrkX95+RJUlpclwmXxHsPNmMo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTrg9P99/AvRih8\nalMEUzkDZqZC5TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKyExaHR5rya39f123NJFH8kUdNblxy+1X3pLo1Rk7ba\nAiEA6zbwyvV4DVPlSgOBEyrsDAkJ0bzqbW9V1ZCdaK4KtwU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7883", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7883` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAfFc+y+B3h8P3YaD2O/GklKIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5NTFhOTZkLWUxNTgtNGE0ZS1hOTljLTNmMWNjNGJjMzUzNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWEyOWRlZjktZDZk\nYy00NGFlLTlkMTgtMjkwY2NlMmNjNmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuztr3SLkJYsW4f8osffhAN6Av5LXarXI4fhBl3vC2vK8amCy1bwOm3fHvYv6\nFO+DZ4E3fxm80WwEEKfdL3Mo9qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU35MaCLNDZNsfDg7dJSp57JFrTuMwHwYDVR0j\nBBgwFoAUnxqYJ1CaTiJQE/a/JCTaKlQQX78wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgVTF7Z4qfYm5e\nQrTuB0y4Y2OMxqYHfFGiOJbaJgv6L9ACIB0T0gqX0P29WSb/uk/R6dCQ9Ha3I9Hr\nJ2J+KCZfl/n3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARohvfVWaCqT9QQ4k4XcNPIxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTUxYTk2ZC1lMTU4LTRhNGUtYTk5Yy0zZjFjYzRiYzM1MzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhxBpUll094RsW28JA7OuUryRkwKtNrBrpRlqKmNj113tb\nNJ0GiaWNP5TpiTHJ3pEqQxQErrlHcknTvT2LiYY4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnxqYJ1CaTiJQE/a/JCTaKlQQ\nX78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKt5PHLD1Z0ij3PcE0Cd4R/eExq3L7O4KiNhuOUxNILgCIQD29hvWgyl9\nj3eR32oBCgGKXqsLeq0YZbOfV6uEu/ynMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAV/wI/Lbdq8fIbC8k9Id3hjAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWEyOWRlZjktZDZkYy00NGFlLTlkMTgtMjkwY2NlMmNjNmEyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMzVhNDAzNi1hMjcx\nLTQ5MGUtOWNlNi1iMzcwNzg3NWNkMWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQBAydqMJaTxCIveYXqxXynfqByOkF4w9p5jJ+JNokglqPh1yfP0V9qFI9y+AP1\ntXArOZfZukueZsv4UoGwuWuHo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTfkxoIs0Nk2x8O\nDt0lKnnskWtO4zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKZGg2qj6NHQF3HbNH3usFUsYfS6yxOA0AlK8+sqQ3/W\nAiEAqL2EhscZy540eUGHSHsKh8oTdCFMATVqnOs56fM+mSI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7884", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7884` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAe47M3biDf1s66WMxhgILXhDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5YmVmOWU0LWEwMzEtNGMwZC04NjcwLTBmYzhhMGU4OWFlNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQzYzRjMWUtMzc3\nYi00NGMzLTg0MDAtYjFkODI4ZmE4YzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErmNkNr+tS12xjNbX69ymKrVujwgTh3cuY3Ugm8RDT4xFL0aIOlFE2fPi0nqd\nPR40zGd2+kVzbqHlUR5+NFA2D6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Tk6JJ7YrJqhYgNX4eVsot7dfGgwHwYDVR0j\nBBgwFoAUVxo03gGcQEOZSu8er4qp4CSz53kwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgT2lERvcybVxl\nNYzOleJ0fWHJp7qyEMH9Vbngy7vyBfICIQDWkkU26PAuY/sfhX6vIwDRybtEEJAX\nt9iPqUeEKuPxwA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQfzBuJmvtCkYQ12CpZnasysMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWJlZjllNC1hMDMxLTRjMGQtODY3MC0wZmM4YTBlODlhZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJ48hokQBD96MFB746dTQkHEXHQmFegEzVG+KtZ/gByxQL\nx+mW+Ucw/xzJZDSobdNlNB2KOb30wj4qI+W+8odbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVxo03gGcQEOZSu8er4qp4CSz\n53kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKNhC8u/eLV26bp/nOSGP7P025EqtdBtDPSpH4+FQJt9AiEAyM6kxssW\nOPh6DcC9ot7ilsj3Cm2M1wF9OfyzbG2cRgI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAX8YEv/HFEZFNgCV4DBfeZ+bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQzYzRjMWUtMzc3Yi00NGMzLTg0MDAtYjFkODI4ZmE4YzhlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjZTI4MmFkMi1jMWYw\nLTQ4ZDEtYjM0OC1hZGFiMmI1NTBjMWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARQUTFocUnekBQJdqXM9ZqPh5JT4sUo+n5bnIopMwWJkkkwhvR0Ewx2J0pmx1Dx\nho26/Wd7HRgxh0LLArP8EnSFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBThOTokntismqFi\nA1fh5Wyi3t18aDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgGTVYEu9YOUxDREcLDsQwTqLNOFCVfvA2PQEni41IiTMC\nIAQag3ELgA1vLKx8Ka7oOwKvAbWBE+iP7aclu7ESqCrp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7885", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7885` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAU6ph67C3C9kJVWh1kqYjEsnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmMzIxOTA1LTQyY2UtNDc3My1hYjFlLWUzMGUyMzk3NTliMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJiZDRhNTUtZTEw\nYy00MDZhLThmNTAtOTFmZjAxNjVhMGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFKArUj3D0AhqEhSbFV8aGhCIcYaTjqPW4vFuno5pgPEMXQhMwsr4mJzBC0cb\nq5IFMBJKdkmUcj2f8xNkELKktqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2mNVnjWZezvx6Dnd86n4jtH0JyEwHwYDVR0j\nBBgwFoAUaaTaW72Kwt2u1vrVzlEb9Gn2G4YwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCrXBwYOjtQ\nyha9cI6DS8npjUQxU99SkqX+seVdze40DwIhAJskvdmgv4rfg1Jpk22VI/b4+DHA\nU58I9ZftmpmEHPSs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWL31/bpLiY2fprE04IyU6NrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjMyMTkwNS00MmNlLTQ3NzMtYWIxZS1lMzBlMjM5NzU5YjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQblzpjF1/1qaFD091UURbZ2agBCkWZiXXCPVvgx/4p76Y1\nOZBz4K9PxAbqgopT+WvYx1F85mPhpXWoSzmfss4Yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaaTaW72Kwt2u1vrVzlEb9Gn2\nG4YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaak8hHetCn7wLK/mEEsCOfPtzzmNeozzbrdUc+fiiwgCIHRIzwIB9Mf4\nxNP1wMA4RV+m3Q5gMIy3w6+h/umLeUt2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbR2y+4KETdz4/twbrFsbakTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJiZDRhNTUtZTEwYy00MDZhLThmNTAtOTFmZjAxNjVhMGQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NTU4ZjQ1Zi1iNGNi\nLTQ2YmYtOTA1Yi02ZTRkMTVmYzZjYjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATbPNtywxgKrPTdkW9wr2OtzIKyyP8v5jfmMcltaRTLiqW0rxwvjgiUDIOvm1jr\n6QpNIVWVaKcEPiwlDsAMOioSo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTaY1WeNZl7O/Ho\nOd3zqfiO0fQnITAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAPti+3gKdF98HBBXiWYDnaP9VuUzv9zBQQ968Ygj5TO3\nAiBD1uLn/JVhT50VQmY5glGjefuel9d7ufZmW9zsY5gzyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7886", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7886` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATcZT9xx7kny48NisgNBfmeUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNTY0MzdlLTMyNzEtNDk1ZS1iZjljLWE2MTRlYmRmMWI3ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOThmODZkZmMtYzk4\nMS00ZjZlLTkyZDQtZDI3ZmQxYmY4YzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp/c8u5mZFmwbt0ktzhtX4Y6gpoVVkTqsRY/IzgWdNe+ZBRaX8+3lfPNR6J/1\nzoLfEhmL2nGugsnMyhc0gpBTiaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAVvbFhYEoxGsbz1cLJeC9//hD4MwHwYDVR0j\nBBgwFoAUHj+N9QelgJV1xitJtjgb+H+P8agwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGTizpYrRAME+aBpg6VsPVOsMQH7ELcj2xiF7Uq0+AEdAiEAlFz25hcAaWro\nXukD5w7yCgbpi6V6dfGP8A9G4NmmcqU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa4qKvgIZ5k33sgX5iBhxYcAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTU2NDM3ZS0zMjcxLTQ5NWUtYmY5Yy1hNjE0ZWJkZjFiN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR1rjJXdsICcwC/JCSYlHKkXzlk1h+F+6atlEbrTOZwQt5\nnNoerlw/3EfNyClEKC7wfkQSn4ehAmgLmUkuXcvco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHj+N9QelgJV1xitJtjgb+H+P\n8agwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH9e1P9wRfMNUR+DAAsf4JLvUK3rrjbbHtWFlDUjKf2cCIFsMQGazgNa6\n7scmaOBN5wcQZHB/g39OOqg03tIPdH7N\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAU/16JTwjPoi3N0ubgvxvTTyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOThmODZkZmMtYzk4MS00ZjZlLTkyZDQtZDI3ZmQxYmY4YzlhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYmNkMjYzMS0yYmMx\nLTQ1NzctOWM4NC1iZWVmN2UyYTY1NzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQR5dXedzRCI0DuVSXu1fXJDIxdb8pFcpXKy5Uou2H3NkefcWle2ingj9nW4I/A\nmYMXrbQRA8JdYBgQcmDsgnJHo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQBW9sWFgSjEaxv\nPVwsl4L3/+EPgzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAP7JfWp6mIvdC3jzLyb5INZI4jOSz7Fowp2p5RQyBQbG\nAiEA/Riuqkqf2Ch1r6eK8ESTCqjSXVEszflhfrcXtV0SrAQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7887", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7887` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVs890SoD563zDwbUVj2vaBgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMjJiM2U3LWU1NTMtNGI4ZS04NGE2LTAyYTA0ZDMwMTAwMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJkOWE0YjctNDYw\nNy00NWMxLWJkM2UtYzIwYmI0NzcyZjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2QrMz1mGramnjp9+X0XaB01oasA1Hj7PagnoIrJxSDVlFj6o2hhkjh7iohj1\na9QDFQqY6LKjNAXmbwv0GyJ5sKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBYkm164H9eeoEAPaOVKCK9MRev8wHwYDVR0j\nBBgwFoAURfzmybdK/qhw73bSXr0orC8nK78wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHzBp0e+WQ+vWWHmlYV7d0oi1EFiBCFHKN5dzHMY9jc/AiADNQn1wVuDUuqV\nqLU+p4ju7thp/qIKLArdmnfRuUHADw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ70hpLU9+I1Gjc2AJGnpkuJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTIyYjNlNy1lNTUzLTRiOGUtODRhNi0wMmEwNGQzMDEwMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLhm1mSm59oLlK43BRMWtZkkFA0/ycboe0x+ZYmTecr/hH\nA3iZt45UAj10zQ+kshBV4/k+uMgJdd5xBEJESBbCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURfzmybdK/qhw73bSXr0orC8n\nK78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbreGRQ8as6G8DKCde1u4Eoe/wo6GhXjbU+VI0G4rNUsCIGzIY1aknSf3\nhXre34IBpHZxM00BjDpB4gfCiy//InUU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARnuEUcVFmfgVNmn2qujlAHFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJkOWE0YjctNDYwNy00NWMxLWJkM2UtYzIwYmI0NzcyZjU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkN2IzY2I1NS1jNjgx\nLTQwYWYtODBmYS03MGVmMWIwYzg2OGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT6gplGq/HKNHOZnYYnszh6psm/0s5kRe5KrLn8vx+UR7rHkYhwIFyjjoVos1wm\nqdwVnFADzIFk+OIKwdbMJJ7Qo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQFiSbXrgf156gQ\nA9o5UoIr0xF6/zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAIisRGZCzpcJvbQRFC+BEh1aOmWhx3kpRmWsTsGnGt27\nAiAVl7cpE7GsF9c750GIt/el7EVuOyqSTUp9k/58QagoRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7888", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7888` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAT0tAiOzuPyCSr5O5KzUxjdfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNDYxMDlkLThkODYtNDQ3Ny1iZGVjLTQ4YzM5ZDQxMWI1MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAyMThhZTgtNmRm\nYi00ZTk2LTgzNWEtZTAzZTBjMDk3ZmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElMCEqbfuzaoS1ptNJ4oaU0jQNs5gm8CiTlWrwDSQiZxiptnNlo8OY0cg/kv3\nrxj4nnKraUD8to00P0nf7MBmOKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi2QnEv5EZRq3/SLiBLp4nSjSGM8wHwYDVR0j\nBBgwFoAU8b+4b/z/NNA48hqL/WkdsmhGF2swLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCr\nBdWRNrlgSkSzt8kqy81ouSlpW3RNjUqZGN19HwUFVAIgPnj0NXJRi1BuIviWdF1L\n181QPVvecu56AHolUjKH59c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbBVSolHhfPKTeGunczDsSI7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDQ2MTA5ZC04ZDg2LTQ0NzctYmRlYy00OGMzOWQ0MTFiNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTpKsOh3ZV1fwwqOfT0BVVCJ0D796/YQa1x+dGpb2uyEnV\nH39gn7WrRr0r8WlK8pTBKKpw9U37yt7smgy75js7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8b+4b/z/NNA48hqL/WkdsmhG\nF2swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgR/N8oEAouxFtnQowNqzJLGvDtI5mMLgE9MyDXunSLqYCIQCmZsXJohN8\nwNzvZN4DR4GQTjwDgRddJYmtaSHR24SP+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAQOCI88TeDJjX5Xuyh3yGrm9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAyMThhZTgtNmRmYi00ZTk2LTgzNWEtZTAzZTBjMDk3ZmVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NmRlZTQwMy0zNzg2\nLTQzODYtOWFhZi0wZTI2ODc2ZTc4NDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARGbm6cbjvOWjDYGyQcv73jvrNp8klNrZCXv4qSgNhPCHHPxKCOmSQbrgVbnfyO\nOC86nH8qSz5lG6vSYctHf61xo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLZCcS/kRlGrf9\nIuIEunidKNIYzzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgQI5zzw9kXsHqtkLa8D5rzo5YiVI4EJGRrTsweU+TwjgC\nIB7yFNMjGa1N7neZAaUG8NS4bYZFe+Kd+hrB0y2+xS6n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7889", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7889` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAQecKEy7YWRIN4HJ4pGwjrkVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MWExNmVmLTZlOGQtNGJkMC05YTNlLWE3ZjI3YzdmZTJkMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJhMGQwMWMtZGI2\nYi00MDUyLWExNDEtMmJiMDYwMGI0ODM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfKagaSs5QTIXoOhkoTn4DRd2tSDXSfy0epF+Jr0XCjBIb59lZ5DZSezj0KF5\nQQR9/hbJlz+hUMRSxkP6saFzP6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9/XdiLnH17faoqDqN6R/k28TXLIwHwYDVR0j\nBBgwFoAUyg9O+dI6oKn8Ts0Dpw+r5H/2Rt4wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIBSzgHOg3WJvsrzhoPjR4PdSNdh6/Ew5ikC3yHQzMl56AiEAnUqL\n8mC3RPTyEahuEr8Ud7TiszqREypawUD0Na4SWTw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAURHfRfpylSMJDsr8grqKC4/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTFhMTZlZi02ZThkLTRiZDAtOWEzZS1hN2YyN2M3ZmUyZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASW+4GGLjFGyARoikjlI8XCfZm2om0bHwkeAlSlEBey8OQC\noBwJmvYhp+00uFM5RTxrlirw89Bc4htcsqqxdkwro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyg9O+dI6oKn8Ts0Dpw+r5H/2\nRt4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJmix8mhzKrrS//RijWL9tDqmyQI7iRXr0Dz+ZXfCgcKAiBk8v4kQKLa\nnkEQ0ato3HcMFIxs+n6TMtGxVduz3+B+1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbfBm1nfupC5hzqLRKhaov4EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJhMGQwMWMtZGI2Yi00MDUyLWExNDEtMmJiMDYwMGI0ODM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxZmFmYjlmMi0wMDUz\nLTQ1NWQtOTRkOC00NjcwNjQzMmM2MjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQymh1IfsrcIDBeinhrYBcSVsnBzyNenFD9VavjynEVLK1Ov+mkwH/NMl7weVFW\ndCCjuGrv4tcZfibyBjq+Hh5bo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT39d2IucfXt9qi\noOo3pH+TbxNcsjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgNq1nQQGU+sIDn2v1OtZAn1jlFt7Ae/zO9cNVBDCqsSwC\nIQCjto4Ch5sgH4kuK6Gm9OVC9po8Yemo50q/t/Y+SDvRhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7890", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7890` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAURv8f92veQCCvcqpjYp0KagMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjMWNmNjc5LTBhNjQtNGQ4MS04Y2Y3LTc3ZjhlZTE3YWVhMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM4MDUyZTItYzE0\nOC00OWNkLWFkZjMtYzdmYzM0Mjg4MzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE84u3V+I28vb7QR9CRxAn8fVmEoDdlnWxGMJ/ygZtUPgH6WwlcE/QQN+x23Yk\nD5cKnYW/3sxCJ9n21tmhicMof6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbnwiMo2vvHZRLLgLfWsEEvzw9mowHwYDVR0j\nBBgwFoAUCb/iSmIjJqMLMx7dqm7SxgV1SskwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIFQbtwTP56vrbmS6GWW0tagCxNQNGiao2w5hfTNw6+spAiA8Pwp7\nVRUcCeccyBGiqtkXuORT0DCwIb1MI6ZZZx1wmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATS/dDilHkmlUeVS8C10ioyUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzFjZjY3OS0wYTY0LTRkODEtOGNmNy03N2Y4ZWUxN2FlYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfOHgK9hoSLPgL6q0oMAg7uFFPZM8b9LebElvZepLtjRZR\niXiVWuBmhh64IDgry6m6iQr2xPRM4Wg3D+7cqOQBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCb/iSmIjJqMLMx7dqm7SxgV1\nSskwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIqD+fxCLFbcHk1tTAE31C9RtiEqLlhbWduc7CmnBPHGAiEApvo/WPP1\nVxIlujwtHHxMAnCYD/GmXjwc2V3sjn0uNVc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATeqxTweAXs6HhGT1brMtzAyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM4MDUyZTItYzE0OC00OWNkLWFkZjMtYzdmYzM0Mjg4MzE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NjdkNGU1Ny1iNDg3\nLTQ3YmQtOTBkNS1kN2RhMGFkYTllNzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS5RGQnuIuWtqbvZ1nGK7E90HJ8OnLQUB/dsnxqj2XvTW0Z+RsKKciIvoOvFWmL\nXTFtbuPo/wjOWrlYbkrV1VhUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRufCIyja+8dlEs\nuAt9awQS/PD2ajAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgDKE10DSt4CNusuo4PE/sSABU049eMfD0/ge3QqNXDQcC\nIQDKM5OuBF3OUQdXMmLbJpzjvKQG8mS2WFMHn0FasFitFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7891", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7891` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISASMqh/cjvQYa8q14WHXvt5qmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1Nzg1MWFlLTczZDgtNDE4My05Mjk4LTQ4ZGJmNzgzOTA2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FjOGQ5ZDktOGFj\nYS00ZDljLTkzY2MtNDQ3NmE1NTM4MTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpGqdaBoXFReI/PFh54BNSUxntd6JRr+esTZMXWEl8D2E8oM8/vWxumBkmXbR\nolfHpHI+zxC3RCrVCSggu+kmBaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRDXUBo2OZJNb8uwSe2JkyGYtkwijAfBgNVHSME\nGDAWgBSjZbHpg20yEkXycjJLX0HKyuQGQzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDlcPis9t2jQrVoXKSmdbtloFZ1YR9Vt\n4WG4J+AeCzBnAiBEd/moUyNLeYuhSGX1BhBvdCsNazFgoWz77HNKFKWKmQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATv/TBJ3pix8o+ZshIQ48VZyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTc4NTFhZS03M2Q4LTQxODMtOTI5OC00OGRiZjc4MzkwNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARC0YaEPVlDydUvMA158GYAp0/BA2rTkCrS1Rmo2AhJcS6V\n7tCOKywxY+keiXebB/9r87+NqqOABmGpDupB4FZao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo2Wx6YNtMhJF8nIyS19Bysrk\nBkMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALU6txpATacO8GEuP74ssPSW8to0r5gRwP/DiBtY9/ecAiEAgnQD+Nv3\nNIJWuKuYwLuYNVmXyvX9rEEKGJ4pnX+eHtE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAatBOvn2a/O/ycTlKjkPtwlDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FjOGQ5ZDktOGFjYS00ZDljLTkzY2MtNDQ3NmE1NTM4MTZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNWQzNGFhMi1mZmMz\nLTQ1M2YtYTc2Yy1hN2RjNGEyMjliMmMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARnhEjMT6Go5lPkmNCh4erF7tk4RWwvOf5hvzKfOnT0Sq09mQHVIf3ndd3FFiW6\np1H/eqMmU4zIkTpmrDHk2rJYo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRDXUBo2OZJNb8u\nwSe2JkyGYtkwijAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgSmPoSxmHN+HQ3okC23B8wpx6zY2H6K2ryuNvzmRLkdEC\nIQDYCzKsx7Hzl/DoxiPj6krF6+Xzvua/tOAz1x8X+dJsTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7892", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7892` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZxgtNThWkcK4yJRQarCvJJaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0YTBlZWU1LWI0ZWYtNDI4YS05ZWQ4LTY0NGQ5YTljYjViNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTliNTc1N2YtMmI1\nMS00ZWQ5LWJiYWUtNDlmYmEwYjcwMjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZS4elK/EaPQYkTtj8dBsYTkj4ocGFRNzm+CSyZEUxq1617LslexpwinX3nws\nisHG39m0VQZmEOTzRDddtFS+2aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD8IDjyYT1rtVxM46uMlt2UmCuH8wHwYDVR0j\nBBgwFoAUFBSeDwAv4He5ghVgill+SBPq1H8wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIEUzQ/RBdVfT\n40kKRt2cYo6943tvrjvobxipAvnDDg02AiAL4sZF8D0BH1jWS/gNXdbT/vwTR2/0\nJGciGYd+SQCDVw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZnS6HdxZWDql8Ayp2W5qle0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGEwZWVlNS1iNGVmLTQyOGEtOWVkOC02NDRkOWE5Y2I1YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASx/BdXszWO8M7lHiZGyluEr3fq8xDrjLh/YAAtFgmEC59I\n+96KOjEhca9v47M8HZqYJckDHKOMH97QG35AAggyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFBSeDwAv4He5ghVgill+SBPq\n1H8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRKHj0oTIJNVYIG6dACL8ePUgUazvQS9aZktLqPzVwIMCIQDKxRpKCR5V\nspOOLg+Qw8efC+u4QsDFfqKqbVJbAOaNKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAY5pghqr4Fer8KWiySZ5hnOsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTliNTc1N2YtMmI1MS00ZWQ5LWJiYWUtNDlmYmEwYjcwMjhhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmOGVkZTc5Mi05MzAw\nLTQ5NWYtODcxNS0yMzVhYmYyYjY1Y2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARvknB5UqhzenmDe5WdVaqXckhvsPFFJfNojJ0ynRR322DvcEm99UvTdiNUPv3t\nghJcqE1bLTMu3fH8hfTsyGFKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPwgOPJhPWu1XE\nzjq4yW3ZSYK4fzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgQxl+yTN9r75Ys7jX3UdmofJ9T2B4q0P7aL1YW8Q7RJQC\nIQDMhc18JM5YQUalY4/8Wtfpc91sc0197tUUUdCk8eNlfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7893", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7893` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZ4M4mvXP05pRt8vkt72cxZzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyNTYwYWEzLTNmMDUtNGY5ZS1iZDk0LTg0MTZmMGFhNmY3YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VmZmIwNjgtNWE0\nYS00OTM3LTg4ZjUtODliZGZkNTFjZDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe4a62NHRnmIhi6Hc1Rr+gjlFhLKhI9kWy68dEeBemSM47pivWTLlCjtLz9Kb\nnL1Pl3xLRT7nu18LrtoPcug826OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf7K687C9MZe8PuxgdK55vWTCbkQwHwYDVR0j\nBBgwFoAUaOJYehrGxGGEpCRY/wCzYxqyMx4wKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIAZaPdx6PkLS\nv9DH3e6zES6nBSjsxP235bMmvts4HAEZAiEAth4kbKiCBLqFwWqHHh6mhRpyOUJA\n2lsOeeWcrZrTpwg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUEEbPpoLqVggTn9DaCfurc5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjU2MGFhMy0zZjA1LTRmOWUtYmQ5NC04NDE2ZjBhYTZmN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiFSypmTh/UFCovWxG6FkzcySn5DU5A8DBcKqbTmeMRV5Y\ncadhK1sJp7Nr/RZFwdj5/VvJZo/UfuhnAAAdzoKKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaOJYehrGxGGEpCRY/wCzYxqy\nMx4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJQlNRCgfxb+wdC7f3YOzxU5UyPRGDB1LuJIqKvFvH5sAiEAn3kPbBJ0\nF0bVJlXBxSxMyMJk3WYGzG5E8jDKU8mJU80=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISASdQUtbh7V4io+QedpUvwrkKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VmZmIwNjgtNWE0YS00OTM3LTg4ZjUtODliZGZkNTFjZDIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMDI3OWI1Zi1kOWYy\nLTRiODctODgzMC1kNmM3ZDg0MDY1MjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT1qSEFdChZsN+0syUDlhOKOMfxUNKuPJBkGBxCXNWaiDIkMGrcZeUl1nx/9/ab\nw/+29o4UhMrKvRadZCVMy1vNo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR/srrzsL0xl7w+\n7GB0rnm9ZMJuRDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIga+mmYq3LZFJhk2WFzMlyBQ8mB4y4bGTSdogMsub9sakC\nIAIoaPqoVEtZTGFAB9HGe9WY6nKvUF2RLdIAvfuNJJLb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7894", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7894` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAf/gAR+DTTNd4BjU2kjp71RhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkN2YxOTBmLTdlYzktNDE3Mi1hOWEzLTg2M2Y5ZGEwNDQzNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc1ZWFjMTQtM2Q3\nMC00MGMwLTg0YjItNGYzZmM3MjdhMTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2TrsSeBo5Z9wfxgojMbWPPzLpHacwo3NA4Zb78xx+awjvs82KYKJP2WKNvf4\nCXFNoIV7Isq9tW2j+za5SYpnEaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnK86ol+S7v/eb8x6iarMQGHqgGcwHwYDVR0j\nBBgwFoAUshIOai5xMUzIVo+uCgpu7ZM5n70wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBBvxDOwP5j\nVfGD1MASmWnpU1HqES9MpmAGhtr7kaHFWwIgUY1BNjdknIJv3kswkrdwycxFNqdm\nBcD1IraRO/LIQVQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc/gQe/fdWMSRqf5BlrFiFI3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDdmMTkwZi03ZWM5LTQxNzItYTlhMy04NjNmOWRhMDQ0MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAy7cU6mUlfZeLdxD0XejJrNOxB+aL6WUTkYFIiNVh/rxp\nu0RbA5w7E7oz29/WaEaiLNNFJOx0YfvtfJgVNp63o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUshIOai5xMUzIVo+uCgpu7ZM5\nn70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAML29VPgGfnOAPDIUCDZ3iboDHzWaJR0sYG08pCmlaaEAiEAno22Wx8q\nMXbgBx7CsDD7aRHF+4PzneWFunzYoXqavfU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXEKKcfZeSyB86uKhOWwYacLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc1ZWFjMTQtM2Q3MC00MGMwLTg0YjItNGYzZmM3MjdhMTA1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZjI5MDkxOC03NmE4\nLTRlNzAtYmYzMS00NDk1ZjFmY2VjMjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ8uNQGh/zweV6wNsBoqI+USAUWOXlUunGzWQFYaqX8Gguwv9tXH89xRuTCQegI\nA5Jx8UkRe4Lo1XmE+4CswFYSo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBScrzqiX5Lu/95v\nzHqJqsxAYeqAZzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJGRnUiub3xYEr7ANOTjE4ytBElumzUgubf/ndehld9y\nAiAGPtlItIPrB1etYxo5Rt4GAoD61a5g3Bs/EOwtLgB4wA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7895", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7895` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfwK3PjzbS62GghX5X+daUClMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhMzgzOTIyLWY2NjUtNGIwMi1hOTA3LWQxZDk2NDg3ODc0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2M2NzgxNjAtMmY4\nOS00YjliLTlmM2YtM2I3NDdlM2NlNzZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJlGNHzVLgFSRYj6ri8hofZ5pQ87cH3+4AGHDmhoackaPHwXvn1PuEUKJkqv+\nCzFt5J61+SkyTa8pSLxkh5Ve56OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt7GIa08k5YdrCZRLlFoiCbAcOFEwHwYDVR0j\nBBgwFoAUhjkWigjoxCvSa3Wnh6w1ilCRINYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAovHz8VRLpQzTPodvWToF7XElIIqfszq815gn140cMIgCICbZ6WpWDMc9\n1FnXUhxhtB/zqQ4BzNlscCV1JMu+NiZN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAREA9b8GbXz7ig73O7k9VooDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTM4MzkyMi1mNjY1LTRiMDItYTkwNy1kMWQ5NjQ4Nzg3NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYEZkD4XAgWWUaoJXFBbMdi0a6fRliSBqKc5VS+4kUaqOk\nIiXvRZw373lZrEJSisJK3TCnjv65A0r3CtGlm3xLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhjkWigjoxCvSa3Wnh6w1ilCR\nINYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPCm0GyEZ/6UVD7PwLPFE9LfBye9yLM4XuxAWr18aTl+AiEA10xPDCJB\noiDXaInecHIRw7MW9X0zGJQr+fs8FPmchGM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAdDczJ/gYOOKSYX5jULAzHJ4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2M2NzgxNjAtMmY4OS00YjliLTlmM2YtM2I3NDdlM2NlNzZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNzAwY2M2OS0yYjI5\nLTRlMTYtYmU5YS00MmY0MjVkMDVjZjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASO02mJA5qhiiduUxL4PxmSefZmmyza26N16IGzV2jiUQUzhPx8pqrID2KAc+B2\nInTitX8YEvvTBLYWteOhn1BAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS3sYhrTyTlh2sJ\nlEuUWiIJsBw4UTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAPaW+3RQcG8Y0hsF7+k9r7vmc6D4H6xXbwTW+FRcf4GJ\nAiEAorKnk4o7KYZdBcs/5YPU8Wx+tGXpcmo+UoVOUS3sWv4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7896", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7896` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVC2iVBOV765fFS7V+v34nZzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzZjEwODNjLTI2YTItNDY0NC04ZGEyLTVmNDg5ZWI2M2Y2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTcxYjUxMzItYWRm\nNy00NGVhLTk4MjEtOWQ2ODRiZTMxMWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4NP5GDMFgHuz+U47R9qQMGTwL2Mizr+VCZynQPsvq3wSDOJgcJ7afR1klPp2\nWIXVtPG/Tinnm+JHOJRI8MoQbaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjLn4ntgMkfHbtZFv4uIIM1KW8Q4wHwYDVR0j\nBBgwFoAUsG1VlEZqcs4FQvSDLeng8a+cvFEwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA2hlrJ89yN5CXr2j5xUQa57wKkEvQwtdCe2/uSTL5IXACIALvtlll/GT6\ny7LIDn1qUF2v04YKgmcz0GGXWYtywy7J\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcY1iNzXUVgqcWqj3/D1d5dBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nM2YxMDgzYy0yNmEyLTQ2NDQtOGRhMi01ZjQ4OWViNjNmNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZnfkwfgOGvv1pu/C2YnU0mQfG4o0qIACT3E26Lm1QuIbM\nDZE6jyQkUbwMZLG6zmPw0XDHDgoK3fHcaIOx//Dmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsG1VlEZqcs4FQvSDLeng8a+c\nvFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAII456ejodTKKlSU+/TMG4EvF9woOjIUoDW2k1W9MEM2AiAmZhyD/SQS\nwl2yxS8WK0szVllbLkKFX1o167m0SCL/ng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAV3SewP1TF7rPSc1mU4Hf7k5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTcxYjUxMzItYWRmNy00NGVhLTk4MjEtOWQ2ODRiZTMxMWMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzODIwNjE0Mi0zYTk1\nLTQ1ZjItYmFlNy1iNjQwYzA3MTRkZTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARLXnPup26NIBWOSxpHZn9UicCNUWrtEeTIjmk/cgNC1vl1phV8hEOWh5jV10DP\nk0q6qDgIf9qbs8g+nN33hhlBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSMufie2AyR8du1\nkW/i4ggzUpbxDjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgVpGuZSN8YXd781m+lJoIJ/KASDU2UMZJeS7lVSPFD2UC\nIQCTtZgqJ8/w1rHXvKEMJx/bCDBRjdFN/IAPIRMe7K4v4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7897", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7897` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAQCL3dwPrItNBkH6hnXNyQLsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlNThhMThiLTFjMzEtNDM4OC1iZDkyLTU4NTAwNzY5YmYzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY4ZDlkMjgtOGRm\nYi00ZWRhLTk3NjItNDkzY2YxYTEzZmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn4J2vEnOL7eRoqgWgmqOJCQLUpXb15olpeSzjWXP49ZHmFK7/XDhd/VciEAc\nlG5SNWBmOzRZoK4IJemdVNsHzKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrWNdbWw2lTwcwdbvfaaU1BfRhzswHwYDVR0j\nBBgwFoAUYk8CUlg29jpk6hgNIoSVVvxX+xcwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBO\n9dbeiw/dxfqVMOpdcDwy9r5J7J1kKiyusv9/Hh/rMwIhANecCMSAPdoKKeIrAONQ\nSKNwt+xcHsYI+rcE6kerPUBL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU/71WVyDVlSqIz5JK0OIMG4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTU4YTE4Yi0xYzMxLTQzODgtYmQ5Mi01ODUwMDc2OWJmM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfDm8WqO25I7V0pOQent/Vf2b9hJ25Iii3G/4Cn4w8NPOB\njrKfoBbeYnlZHw6tmNuV5ZbNoSGXr5qxGCz2Qq2Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYk8CUlg29jpk6hgNIoSVVvxX\n+xcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga1WWofq0yVpIcKvDRoNSZReIk5PO9g9M0Ghi7DOB7CsCIB1tXITHpgmN\noCFlucZpkyyBzJxCOdRhJQ+hlOTAgret\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAWl++T6zT3VAHelmncfL0OOFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY4ZDlkMjgtOGRmYi00ZWRhLTk3NjItNDkzY2YxYTEzZmEwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NzQ2YzcxZi0wYWY5\nLTQ2OTktOGYwMy0zZDIxNTRmOWZlYjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASLi7KqBrF9QljpnAr3YpIkYJIqCYFuBfWtaU14V+ACsw7YFoNabFElQLvhmQEi\n2fM3X9+DnmVRopnNyoTR9K6+o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBStY11tbDaVPBzB\n1u99ppTUF9GHOzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJxnot5OSsSluz2/bQ5Ex2xZvTX9oIDm8TXMaVIr2cHO\nAiB7gMNzTSFnxJrfONQP3Wu7OniymNFlQrd929cYy0t57Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7898", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7898` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAeDspGfEmsR4mo1cT4+k8qyIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhZDYzN2ViLTRmYzAtNDQwZS04NDhiLTI2MWE4MDVjZWNjNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDcwYTFlYzMtYTk1\nNS00ZGVmLTg0N2MtNGE4ODMwYzQyZjM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE30Vea42uiEyPRTI6XUVoYTTF+YWvTCz7jPhW2kWo3l//lgY8FiHQrXkeB6Gw\noNJ8ieaxPRn1QtvtIPygICwoWaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOSCxNVaRGTmDUoEYC264nC7ccEcwHwYDVR0j\nBBgwFoAU6wI2E32raN2wGeNuNia/S2IYNIMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiBh+SRv2yQcj1eDpuupoIVNXoSCERRr8w0j85qyCSXuTQIgJ3Lz\n2E6aT/uMug+Yl9++mmBBSJzJdNOomUQrMWy9KD0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAefIafqsznFxczNv6Zjw5rvFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWQ2MzdlYi00ZmMwLTQ0MGUtODQ4Yi0yNjFhODA1Y2VjYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASaZoFJ1gN0Fhap+fIIRtsEmaZX3x4qyKfzOhMBuVfcPL3r\nCghOMCqbCCi4BAzs7CkcqhZUTQIxQPfvuvKRCvdEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6wI2E32raN2wGeNuNia/S2IY\nNIMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALcEgciGsEjvQb7pz/FUpbc95VxGAtpYe6ofcOdJCbVuAiAI7N3eiroW\niDCaYrWo+fql5etq1U66OBm+LRRCuggmhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAdnZ//Ejo7wCCCb4uCnWBrNEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDcwYTFlYzMtYTk1NS00ZGVmLTg0N2MtNGE4ODMwYzQyZjM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1Y2E5ZDc4YS0yMDA2\nLTQzYzgtYmM4OC1kZDU0ZThkNTRmYTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ2vBxb5I9oWvKc9CrZWfMR+O5F+ypiXE+uLVHcB0KsCRkadMpfCm9qt5R+SS/i\nK85SMbr8FpA+Sp5Vg6G7aSzto3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ5ILE1VpEZOYNS\ngRgLbricLtxwRzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAL4BxfuIPZ6WeQJ8Yq/hN3jQlJ8hqcNFvnhDks290G0U\nAiEA9922aJnrCQGGOo2mS9WIw/XPWBavjs/xBXckjGuh0N0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7899", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7899` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAarO3soUEa9XfR17dcLCiVMbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzNDVmOGE1LTA2YzAtNDc2NC05ODMzLWNjOGM2OGIzZmNkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2JlODYzYTgtN2Zh\nMi00Zjc3LWE3MGItZTJhNjVkNTk1M2JiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHKjDP69XfQq7ox9j+uN/cKW7ajtS9TtGTXur9KJh/eCKHyyJgoPCIoqD3jAR\nGdztVnO7zoZv6NOlNLuGOdLqy6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7K2fWOt63udaui7xdSPqhOAwNcYwHwYDVR0j\nBBgwFoAUAunpUOVv2G3vP56neooPgmsFMjwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBYYoz01cZs07yrJ4iKVfHC1cDzYS+aBkPm6PZAUdZTowIhALVe\nvTF/GwIRo5Ciw1uKT+hELjuG7+8SPEMG07gE7s3w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT++1U0CT9+yvDwc9OzjZj04MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzQ1ZjhhNS0wNmMwLTQ3NjQtOTgzMy1jYzhjNjhiM2ZjZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkHRPBWTli0haukLXcqOp8yEU1PYHsmZWqqQp6CJPHovZa\nbzLI5tTHAJC0iRe1FawoS4Ry6hJijA+P2edeFzCZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAunpUOVv2G3vP56neooPgmsF\nMjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdsQsEdogfjc2xrv3PRPj9C24Eb9NO2vo3owxLqhTzMwCIQD6UtOlGo5Y\nRXfJy5Jj6Vpu8VFJIoBSn3LJiWTtLdd2rQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYQl3ItVfMjWT2NhtZgnI6POMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2JlODYzYTgtN2ZhMi00Zjc3LWE3MGItZTJhNjVkNTk1M2JiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMjU5YmU4Yi03MDFi\nLTRiMmUtOGE5Yi1kN2IyNjRmZmYwN2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATGZiYJkvrw2g6Yu7FPTqheJoUpCXtRDrWLGkfgjONAtZXQAkoxK30Q+AFqqEAX\nval+LwbkGssYMyplxm6rIg30o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTsrZ9Y63re51q6\nLvF1I+qE4DA1xjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgZCh6RvkKhgSAPGTrIjmDghIM8++LWcn2B1eSMKm9JYEC\nIQD5Wz/saQj5EVL1qaHoKh3d0R+FhgyS8P/Kos6Imju3VQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7900", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7900` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISATyzNVej7rRBsBvxZnKVaEaVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViMDM4ODYzLTNmYTEtNDlhOC05YWU1LTg3MTkyYzk2MzliZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWE0OGMwMWEtOGVi\nNS00NDU3LTg5YjQtNTVkMWQ5NmFiNTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGt7zKU8AP0bpI6H+6dlIHdU/Zs1whgkQXz5iP1UNw+hxnxUTM2TF4zqRapbv\n2DKf8ZHVMbLGP5qCoV/v/0UkhqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ9hkMYi7q0ygRh0QhcLSoizCNHswHwYDVR0j\nBBgwFoAUjAxzsCzyJscrD34DX59RlmVNW7gwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiACFMucTKdyWxYR\nNcJNMssWowsbkfEeLYzqItjr4ZqP8gIgXvrKGS7ulMMwlgFOkmNbVr7G8RjA5NgZ\n2YexvX1YXU4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXLn5kA8y0tee7dE37p5Ux6JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjAzODg2My0zZmExLTQ5YTgtOWFlNS04NzE5MmM5NjM5YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATldZr/9Io+Q8vxryNyICi4hFCTzOh2FVYPKnhnpNVL6+cU\n9heOzkSgYRKV5Z96qfGUCU9qtPCukp46my1QaoMQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjAxzsCzyJscrD34DX59RlmVN\nW7gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGirpPieqKE0pwJ6GvLAnRk0X3EvnbohcdWk6v/BGz+wCIBBtD3p9+zPl\nor/dtsA1W/SdGHwmVMz8yo4kplDyBUD/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdSgAwIBAgISAWhbgGnhgLsnEz/qkf6xpyeSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWE0OGMwMWEtOGViNS00NDU3LTg5YjQtNTVkMWQ5NmFiNTZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZWM3NGQ4MC1kY2Ix\nLTQyYmEtOGEyYi1jMWFlZWFmNTVkMDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATaOhAK9CEuRAzvLDBbOHLo1Rgww/t413MG9cCkH7iTf3cAV13RTLl5uTCJHQip\nDj/ezmn4YJmvO/YwUxPbT7f/o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRD2GQxiLurTKBG\nHRCFwtKiLMI0ezAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRgAwQwIgXy4oHWCp9uwQJIshJRZzWf81C1OuE6apFxiUS7VJPBIC\nHxzB8vTs/vfibYJkaHE67mLwzyjPQh3mq3Xyq+LZqzg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7901", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7901` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYA2QQykD+AadxOYwWfGTxMpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4OTQzNGI4LWEzZDYtNDI2NC04ZmI3LTg4YmMyMDUxMDExMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc3MjNlYmUtYWZi\nYy00ZDBjLTg1YjEtMDIwM2E5ZWIxMTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKroo6hdcJMqTTFXBCoVR+OEFo4g6yc8myjiNKrzV94R9L1UHc3KCZnAU+dWm\n08Sd3Z66s1l6mzY+lO4L+gsL0KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/mdRgHpHFkPVAeKh8kvaU68xzo4wHwYDVR0j\nBBgwFoAUEEtaoKCh4zHtsVlheqg3qOt8EpEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICwHPrgiQHbTmAon7g+VEYhers7EJDA4NylpgJOvP4IVAiAOp9Xl+h/nOzwr\naP5I8gAWOSNAG1TJxyRyzLS5xf3CGA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVzpsidnqQkp6C9gKZt4IulBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODk0MzRiOC1hM2Q2LTQyNjQtOGZiNy04OGJjMjA1MTAxMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzNggd9hTSTqrA4eOeQDfEDVV/Np0XBPrUsXM1WMHTbH4b\nRz+zvRj4T/CTePcWzvIU1CHAA33257F5O9WMEsNfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEEtaoKCh4zHtsVlheqg3qOt8\nEpEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfcBYRzd2Sh7BiWd8Ad/aekyHPY15+EgvL62rSBfh/WECIQCiVls76y/N\nQMyD+LYhuUTIvSOMFmhYjxaG7LaI8oELbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAckrgqtJXgTx738sAhvi8SxwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc3MjNlYmUtYWZiYy00ZDBjLTg1YjEtMDIwM2E5ZWIxMTY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YzQ3N2ZhOS1hYWIw\nLTRkY2ItYTU2ZC1lMmE1MWUwY2QyODgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATPXphAod6C/x3+k4jPVWyKZuZskNSnNQo3d4v7/tN+xcOGfxY58AKTm/FKeJ7o\n7aUk3TtJ0Oc5u+v2r4PF6emko3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT+Z1GAekcWQ9UB\n4qHyS9pTrzHOjjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAPDkoBJ+FiNGRNv4SiHjcdYMNO0Bl2jQvKmFI+4Oy8kG\nAiARFfJNvsUMUi0GhjEGnDzIaBWIaJtk5Zsbz7zI0KjIVQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7902", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7902` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVPb5fQ+BDgSCGmBp5dshjcCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxMTIxNjU5LTY2ZmEtNDhmMC04NDg0LWJhNTdmOWU4NGE0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI1M2ZkNTgtZjAx\nOS00NzhmLWEyYTktMWUzY2EyYmU3ZGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbvHvscqg6i5tlrc0xD8oQKRxTi5GeQymCT3B7D2Pl6Z56ygRCaiIsIB4rW1P\nrn/KP8d2X7vFhmokXpTiR8AKL6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzAujexaDlnG9Gix4fVFeu2voyEIwHwYDVR0j\nBBgwFoAUk1I7sSc9JU3K4IWkZ+XbeZb+XhkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDqyqJFwPHkqNGxqD3EEIHWAod7WAn17CTiVSUHpvzrJwIgU6iiGzeWezRN\nK+ZGfIXugR5ooP740ET5xF2UUiVgUZA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUsesFuTw2j8SvyhLdAtvPk1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTEyMTY1OS02NmZhLTQ4ZjAtODQ4NC1iYTU3ZjllODRhNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaw/YMkq+ajWHlBUf6PT4lY44ISRA5CvLqxs6Ttna/BH9J\nIGWTLxgUjqAPo3L1I1GbjAbLWJpZYpDw6bG+ZAtoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk1I7sSc9JU3K4IWkZ+XbeZb+\nXhkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUsJLX4Zz2f6vWlvGXotDBJggqZrNNon1I3fvHlySfAECIEkX1jMD5bSc\nYrCEihtdc3eXN8oveC+qTGjefCH2cJ19\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAWnjVtlp1S+FXoEhBYMx3MFmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI1M2ZkNTgtZjAxOS00NzhmLWEyYTktMWUzY2EyYmU3ZGQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNTNiM2YzMy0yZDUy\nLTQ4MjMtODdlMi0wMjM4YmI3ODQyOGUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ5h0XoZg1Kf9kF3nb4imCduxZx/XR6CXtkZqSGaegCyXao7I0NDKnIw0ZDKtMD\n6V3479NBeimVRTY+G2LBdW3Jo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMC6N7FoOWcb0a\nLHh9UV67a+jIQjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMFugKC97cMR9Spg2ef/P1VdapqHOxsr/c9zPg0osJx1\nAiBg9Zz7B924uFNuDux4johgH2fK/20K3a2rdIi8dTgvpw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7903", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7903` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAbLtWjQzWL9Nr9ToINZFvAGQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhZTYzMjczLWNhYzItNDNmNS1iOTAwLWRkYWQwODRmYWQ0MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmZmMjVkZDQtY2E0\nYi00MmY4LTkzOWYtZWVlOTZmNDFmMDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWoKNu4fihfbSl/rgsMhFkblCPb2N+zJlcp/ny6f6IsFYxoh1Zm2kCjiNCWcP\nhjTP9QbgT8/C/41ngk9r1jfzW6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+RMYQ70jfEE3jQvr1QhNhn0d/owHwYDVR0j\nBBgwFoAU4F4GMyi7GVU/CZCF0jeRTmURbL4wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAxtdyy1/bjcfcxjJex9ONBl23+1pOLofw0NK1J6XnwxgCIQCsS5/HKSyH\nx/YP203evVQUz6rbmJm9G+s9p/IPdf01OA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaXxgmOnZJ/IEqwOWcx8eBsyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWU2MzI3My1jYWMyLTQzZjUtYjkwMC1kZGFkMDg0ZmFkNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt7rHJN948NQJKCRGM1UB2zd3iYIUT641SjGVeqw1QPKsK\notdTOdpbNHomdJq/St2Ana2+1hqKfJsQD0nXf+qFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4F4GMyi7GVU/CZCF0jeRTmUR\nbL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRblRZ+ja9ntJPS0gEnIZ+tcdjooV8e8nUhIRGi5Bb0ACIQCCERDyu8rd\n2WFV+UHn/7gfoa0n8pS8FPOPqkk6UExG+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATi5fBb4TUZMukLzYcucIEdHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmZmMjVkZDQtY2E0Yi00MmY4LTkzOWYtZWVlOTZmNDFmMDcxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YjFlYTM4MS1hYTc0\nLTRkNzQtODg3Zi01MTQ2ZWE1YTMyOTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQcFxrcOgXj+IY6NWjeU7WnU/icW75K7de6HQmVheAj1AoJLYBwGd7OEBtKaiVV\nYLum5SZZ01cPi23F3VO81ncwo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSX5ExhDvSN8QTe\nNC+vVCE2GfR3+jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJzFlewKZSj8ZKIlRKCLCRbaCmPphLzNSBjpaNfDHCm2\nAiBVeNSBhE1GOAQsa1jrral7odukzQaxy7oWZfvYjbkXlQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7904", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7904` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAagvvB/w2yBbzmLXKdT0GeURMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1ZjZjMTcwLTNhZTQtNDEwYS05YTZhLWNiMTIwYmFiZDJlMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGMxZjQyYzktNzk3\nNy00ZGNmLTk1NTEtYWViYmM1MmNhNGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeXUpt738o7BP/UILwtrRE+jxKVubpJqGQwWXB1ru2w2uVZRFV4Ox0NrMTD6H\nsU34vfZf1cYxzTmkFjrBpaaKyqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvHbLQ8TDpjBUWZ3WzDSN6uxkq9UwHwYDVR0j\nBBgwFoAUu8WvZI25jGHJ4SUm0Z5w/j2OtLIwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiA8QX9p5NJlibTT5UKV48M6eVfMcNeKGM7aXb3mYm2T\nYwIhAIyo2BZY11T5gRUIkMOXZR4GQD98r4OaclpjVeb2M7vN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT5jWDMD05jS/uAP/zFlLMDwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNWY2YzE3MC0zYWU0LTQxMGEtOWE2YS1jYjEyMGJhYmQyZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4spl8wiTPc4PgUQDIJnFUL8yEQ8u/R3Up6KypUHqW20uV\nstxFB2S7fvOYDEPxotJRkKDdnHPLB1l7Njgt6kBCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu8WvZI25jGHJ4SUm0Z5w/j2O\ntLIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGwvCQfuLgg24yxEN8qJ9hn/hIFn9fxK1YiP5nclE7/4CIFo6BcOxG/Fc\n2s2Jt7yi+qjogtktbjIZpoYHDhpcisCV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAV97JI13e2xhQsepo02cABfCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGMxZjQyYzktNzk3Ny00ZGNmLTk1NTEtYWViYmM1MmNhNGFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMzI1MjM2Yi04NTdj\nLTRlZTQtODY4OC1iNjRkNzY4NGM2YjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATJooyH9oVZER4Mz7qV3/ewA5ZXg2wcsWeBwNaxmkmyHYl7wZijF9m80wNbk7+C\ntq+NJdKfEL2d5o/q4IlaBpACo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS8dstDxMOmMFRZ\nndbMNI3q7GSr1TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgfDkKgTP7SHrYyGADVdTWv1yuGP0kexAcLuiWPKgNEUkC\nIQCdID7H7vKDF0f7weD9x9mi4Se4y9iNiJvDMvrJ/0PXjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7905", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7905` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAS16TjfULzeyUqVp80qlE+xFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzYTIxYjVjLWE5NzItNDEyMC1hODJjLWMxNTIyYzVlZTA1YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjlhZDhiZmItNDAy\nOS00OTJjLTg3YzUtZjAyMDU0ZDIzMzVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0I2PEkXHWt1Bv7peoXgcIBncvUub+68ACc3H9XKYIsEjY0h0M/HK8rMwsG7v\n7TMjVDh5tL1aKM6H95Ba0o4TE6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc2BCXQEolpjhrHv9FL8v/8y3+TkwHwYDVR0j\nBBgwFoAUpLQnB+hjMFncnA0xDhQxzF59ya0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAscPwiWLMRnAXbzEAxW9jWT/5x/TmowW2So+SV6L5\n9lwCIBqy1QwKRWELW8EZ5hEWLVHdWcAfWZd5ydmsQaK7C6Re\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXO6VhlaT1WNuJBb+Qg99SCmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nM2EyMWI1Yy1hOTcyLTQxMjAtYTgyYy1jMTUyMmM1ZWUwNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGO/buAAwZ1tIvXhysUHrfcC6um16LuEQc4AY0I1//Ef4e\n6TvgkYcYH8YUBTqfBqdMkVD41MRsO1m8dNDE57Xeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpLQnB+hjMFncnA0xDhQxzF59\nya0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAObIZZGo4Zc74B88saeGQu7z/fuP8t7boPNe7BXZId9dAiBDOWbCzr+o\nkRSouaktGeN3yOXWCYwTrVXr9MmB4OSDfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASIdHnfQh613RqVjYPV2Z5CJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjlhZDhiZmItNDAyOS00OTJjLTg3YzUtZjAyMDU0ZDIzMzVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OTAzNzVkMy1jNzU1\nLTQwMmItODMzMS1hMmJlMzgzYzViYmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT72ugrZ26JYXavSMJRqxfW342pEswDfGuRWoDfQN/xsDdwIMEY6G8SXQRiVyDV\nlzJfS4AcO9yV9D9bfIieFcWqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzYEJdASiWmOGs\ne/0Uvy//zLf5OTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgEn6+XIuGhS3PEG1mlgEp2aQ+JaT3xbg2av7RQKwc1iIC\nIQCrbvHhgyW3TBgEl0bfrDFHXuskBbjQ9m6hJ5hDJ9aeqw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7906", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7906` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAbodBXp4Y6//sf92kqtsumbTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyYzY3NTNmLWY0YmMtNDkxNy1hNjZlLTdiYWJjOWZjZWVkYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRjZmU3MDUtY2Mw\nZC00ZDUwLWE5NjEtN2UwMDM2YzA5NjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJDLBeGShD5mez9IGPqm1V6d9seAqzYMzS8pLHtAabXWnR0bdeYPHqzRo/hAQ\nTaC4Ld+uZbODWaT04O0GsMaml6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBu+s1VD9nOBFDs9p56PX4qDsCH8wHwYDVR0j\nBBgwFoAUH1yYNNktXyQ2dXTXEl99TgV032MwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAoeMuFYQxfu1IeAQwOvljW6BXhQVar6maVqAgRF017fQCIF2R\nEkDDgwJ3zASXuIaCjX5gtHQOSJeph3jdaL4POvle\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX6UHY+z+Bb5ArLBFPlT6OTZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmM2NzUzZi1mNGJjLTQ5MTctYTY2ZS03YmFiYzlmY2VlZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYFo8kuSwIrxXUoeAd+0U1z9iDuq1d51tQiiHG/4QKmHkN\nfZA/Nsm7lsGAMrKfz2EZhOJWlVsCjaHxl7Kq+aYGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH1yYNNktXyQ2dXTXEl99TgV0\n32MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK83ca0SFGLZ60eUCvLcb/AOQM/v3oMJmR2DCMsfZvM6AiBiAgEJ9pUg\nNd744PRuFOP4LlVmlDlK8UcawtavsqWW4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZH1DSXA1KS2X6ThCPhOixTHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRjZmU3MDUtY2MwZC00ZDUwLWE5NjEtN2UwMDM2YzA5NjQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMTQ0MWRmZC1kMDhl\nLTRiZjAtYTAwYS1mMDYyMmJiN2Q2ZGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATfgNk08Zx04SjhGzp6icCuGu9MR207YT+uQRjm+SX9g02vPANRA1zT4OcjJzmk\nMNSsFl6mSlJezhDHs9hQHhRpo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQG76zVUP2c4EUO\nz2nno9fioOwIfzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgGaWTPdoWpBklWJC3Syufy8SzpF1hFU/cJtjMGmRTSk8C\nIQDPXAwiXVdyMd4ZKNZsZgjpxo3aZ8F+lq7LO+wkP+wcuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7907", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7907` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAWOkKuOmKLnpPcLo8qtxipGTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjZjRhMWI1LWE4MTQtNDE2ZC05YWNiLTJlYmZkNTcyNDIyODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQwODVhYWEtODNi\nMS00MmUzLWFlYmEtNjI0NmFkMjhkN2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEciUzuRHjMmYTPWAn2IxMQ6KV5ex4AC6WD2vA2h/qfhchCr8NAWfOKDF2iO5t\nZEKfL7SYqyP/EubB4o3XitNpUqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Z9xQl3YagsRdSewyOawWacg+dQwHwYDVR0j\nBBgwFoAUXySiKqIFIpPmP++4CfdaozlpP64wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEArcjI0WYE6HpDzp3PrqM73esw1ROfquR0\n7OFmvde319oCIQCuUAh8wExm3yCe1sVbuvadz8WJpgWdIOPk5gV3LrBM1A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYoJLooZelAhf7VIyQAb0+9QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2Y0YTFiNS1hODE0LTQxNmQtOWFjYi0yZWJmZDU3MjQyMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI6c2CkfGHiWS6p6c/IYWzKfDMRW9vDPDljdLjdUxmKTb8\ntWOIwqZn6Mg6wtc1I5n7HurRCygZkXv1a/aFLIOno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXySiKqIFIpPmP++4Cfdaozlp\nP64wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUKdewxfoYCe/6EnomVjd6qVvBZpEkyoqPjqWaj1+sYMCIQDKMTQwfNj8\nsaVoWAFToI3D0XIvhSlVerWNbi7zlDZ69w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfQpvCAGwph3gOKGgjqjyb03MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQwODVhYWEtODNiMS00MmUzLWFlYmEtNjI0NmFkMjhkN2NhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwNGJjMWQzMi04ODZi\nLTQ0OGYtYThmOS1jMDQxMjdkNDJlMmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASHykmY7qW6iVVdR0ozWCXNlY8zxHsjPwpt0PP409dSYmCAOh0s0Dz14ncBzTd3\nhK7h48uGHlXz5/xVEiHBz+Jjo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTln3FCXdhqCxF1\nJ7DI5rBZpyD51DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgLJorhK4jn1FwgVm7GgWysIKrogzkAqSVvCknq18M72kC\nIQCpqFwpOcqp6zW/L35x3irt0sXOqOb+bb2sLh9sH/3n/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7908", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7908` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISATHEe1rJiA3YIdsXPlebX9KIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3NDg2YjEzLWJmODAtNDM5OS05NDkzLWJmYzcwNGI5ZDBkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkzNWIwMmEtZjVl\nMC00ZTQ2LWI0YzctMzQ3M2RlOTI0NTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpJXEpe2IXaJw7LAUTGwXdXTtiWbi7t36CR3SAJUGApOf7PuF34Lheq6WzcMY\no52KVI2vfoYF0CgUA3VkgI+G5qOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL87FjCPI7OOExhi4O0eSsXEVUu0wHwYDVR0j\nBBgwFoAUQ9VOuqAdtQKAyfj1rUAm5NoiyOAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAshnUCKndhJlk1+H4p0fooPGJhPSoM7gi\nZDKWVrPBRHICIQCdkMD4HCGQV/b7UGNcnSeLQqg6aUXrP1dy8VItEBoDAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV5mQvhRvcDHi/5QUiBi3v9LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzQ4NmIxMy1iZjgwLTQzOTktOTQ5My1iZmM3MDRiOWQwZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARimKCIQS83CoiAqZT4JWEqYlQiOQtGjWMVQzfc/l+kk7hS\ny5jgZAWRRMkiJW2FCs4ZGWS2pHSWnij5ezpZH486o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ9VOuqAdtQKAyfj1rUAm5Noi\nyOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJx0tlVJPSzPvjGDPkd/zalBt1Jdot1o+OMzkf6RowtgCIQCgy5SBEDk0\nC1mK+kk57fNl5WuU7PACoUeQ20/ir/z4CA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAfDg68NXIu0kcY1ZtnKptKPHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkzNWIwMmEtZjVlMC00ZTQ2LWI0YzctMzQ3M2RlOTI0NTI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMzE4NmUwNy0xM2M2\nLTQxNDgtYWY5Zi1lMTc1NjVjMTVhNzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATNtkfMiJ4KfxLVBzta9Qf/MVS4UzcMNzba9DdRyCWcMgS7IpuadsZPnMyPWZWf\nJhbmixciJea2g1k3pmm9DHSyo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQvzsWMI8js44TG\nGLg7R5KxcRVS7TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAJZLOTkidXJWrdCM+LXKRo32ynFwSlXAX9hT4fC02Gq6\nAiEAli/fQwzsi9Z11BzbnPGBFIzaOgtR5L8vzF1wY1/ELv4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7909", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7909` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAcy0nVoytjLK7LQB3YyYVWySMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmOTVmMDk0LTkwNWQtNDMxMi1iNTQyLTVhZDAzMTFlNjgwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU5OWJiZTctMzM2\nOC00MmJlLWJjNTAtNGJmNzcwYzNjYTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhJxdHiC3osJA/xX3f7m9ktb/VHXtNo2WrqiM6GAqBoQmqCbFRan6LElp+beA\n/iitVQcDK9e3GizPBLzlpoRAfKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU/Yn+NcwYufDhOsqTA6RSQYQfW4wHwYDVR0j\nBBgwFoAUczRrz0DmJ9d8FfL1zKJi+ihfcSAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiB8AGV16w2L4Th4\nzY1TB5HxDIoR8cN6Buep9b5zVzl3MAIgEFSUJCNa9JtGgtGwtv8Oq+NmdeUtES/A\ns99f7gKeGr8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAajuyK4ubv4ZC9AdkOgDCPFCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjk1ZjA5NC05MDVkLTQzMTItYjU0Mi01YWQwMzExZTY4MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbjXlNcCqfCT94BEySOOyGxKXxJRHP2Gey3AW084Ui3PK7\n0zNR6hoEQp53soCXZsx2yi+S/pVHsY7me5ZcPEjlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUczRrz0DmJ9d8FfL1zKJi+ihf\ncSAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI7H5Jm1iXOi3X2jgNZjXH6VUzPaiLIvItCYGXVq4vIVAiEA+3P50Zy0\nVEb92YowfFeiVv9C+T6lemNf9cVfUwcKUdU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUOT7nIUoPZEGDaDleB4VV1OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU5OWJiZTctMzM2OC00MmJlLWJjNTAtNGJmNzcwYzNjYTk2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyODMwMmUwNS1mNmQy\nLTQ4NGUtOTI3MC1mZTY3NDRkY2FmYzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARq8RMGxkKw25aDRHJBmsAQziEmZ/s7HeFGW+T/cjM9u/3R0d0awbVNOCSxmtt8\nzs7FctYF6rsOpWkSlqilXZGFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRT9if41zBi58OE\n6ypMDpFJBhB9bjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgLxZSgGXd+EDtTLF2ENPoAuDzgGk0+IDIAPhOHbvHcjcC\nIQDV6sH7uRnE7Kltuoo9iSZzL3A0jX3Vv7b7vFQia6CPAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7910", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7910` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQtA6KGpscaAac4WlCxuhH5UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyMTZjZTY4LTNkYjAtNDkxYi04OTFlLTFkNjczYTFmMjkzMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdiNTVjN2ItZDUz\nZC00MDZhLWJkYjMtMTBhNDNmZmJiOGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEANj8O2OIk7SnfoB6rQtMV84vhiw1IH/VvuFo5FP54FAWLZiQK+KzxT3qVy5z\nKJyNhHj8GAL4TvAb8ZNwzM2xS6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2NmKyZWhOnC2NoifcotjGPxtXS0wHwYDVR0j\nBBgwFoAUTea/mqMEATMzlHbev6e0oOyNYSwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIF3yHT6osyBGU3RXe2buNUzsPJtnbWoICwGH91JskCVkAiEAg/CH+r1V9w7g\nBsFO+SwjWArxyMdBLs6ynhfxyKZFjl0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcc1kEY/u2of/Ao5IHZw6tlzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjE2Y2U2OC0zZGIwLTQ5MWItODkxZS0xZDY3M2ExZjI5MzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvkq9iUpxilljWhBm/rWf9AFjBRX9/nQvNaAy7sXWuGNUT\nqTR0wl/ml7swCaNtaWh9V56L+OyKH+SHAk6E+8r4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTea/mqMEATMzlHbev6e0oOyN\nYSwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKueHtTmVKjeSsrn+5iZsAYiAvv2LjXlmNt8aYJkG6ZMAiB8LdzQNEan\nxuTGLFhNHKo9YMOfwpZ5OE/Rd+Vb7aahKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAStSjwWnayNBqQfX1+/0i0UOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdiNTVjN2ItZDUzZC00MDZhLWJkYjMtMTBhNDNmZmJiOGIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2MTY2MzRiYS01Yjg2\nLTQ3ZTctYWQzMS1hODA5NjIwNmE4NTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQbIA4U4Qkii+bDOfDxvu4LiuQNUHyqOKqxNVPpsFf6TISvq2fY+pEGvuAdyqA7\ntD8W6bxehVi0x6218S/0zt8qo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTY2YrJlaE6cLY2\niJ9yi2MY/G1dLTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAK3tXh3rIqvIaxsWmatW8WAYb2qzBlnPJp/ws86PEL5M\nAiA8wBlPFfja4xIn57G64B78Gb/4pBwuVgYIjgDmVi7jAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7911", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7911` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYPAo/UJdQKQ4msZ+WqIspfOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyNDMzYTU0LTBiOWUtNDQ1Ni05MTFmLTc0YTkyMzI4MTg0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg0MzljNjItN2Ji\nMy00MDljLWEyOTgtZjQ5MjlhNzk2YzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb9W4bMCElno/WJx8yxhrvLvrVG+nkN6IaAKLUBMaVsY2b3GQrRNRLD+1Ps1U\n4Ua/Bh9PfTK8N/ErRGhkAy1esKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWk8UFD7FdbCugPUlzVndya6kkiswHwYDVR0j\nBBgwFoAUEGpmrg3bRk9pf9iXyQiUZHwddDgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBY/MATT66O1BmWTApv8yT3ep6a08XVkeQl2BzttdqebAiAJffPMG7vrf98L\nZmfZ36ube7a1Br2ErQD+ztM2mJlA8A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYqE24f+H3gj9lxjoLmYDX4eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjQzM2E1NC0wYjllLTQ0NTYtOTExZi03NGE5MjMyODE4NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZq14JGs0qqmk9TXkXgZtNRYejiGIYc7T4MpoeUi7OR+ur\n1Jv27wfN+uFckVLkHzj2kWq2G0ARRIsXa/vYBf7to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEGpmrg3bRk9pf9iXyQiUZHwd\ndDgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALx+GMws32f8U6N3QV1HSUKcor4n6w+Vbgw8gQ1ysMCiAiBIWpMq6ju4\nHmyXgPJ7RnH80/DP6ZibE7+EYzthQyFVcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQiL6Kksj27SkT6QyoHR0x5qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg0MzljNjItN2JiMy00MDljLWEyOTgtZjQ5MjlhNzk2YzIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OGQ5ODU1NS00MzA3\nLTRkMWEtOTY0My1jZjMyODVhOTFmNjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR6TNpkh/Z/P1690kesNlh2dccmr7LF1qfKxqD4Rn6xPtGVmzyIveTYHhOrKTS0\nWn3AkgO8wA6qZfRhFejTDG7go3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRaTxQUPsV1sK6A\n9SXNWd3JrqSSKzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgH781zGyCzZekMkyFyDwullO58LBXlN0V8LLqxoK4p/IC\nIQDtf2diBxHsSHeX/2ydRn/t9kUXzN0Ym/hYA0ew+Ts7kA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7912", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7912` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAfdkS87pTjvZRrV4tmllRFsfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5ZjM2NTNlLTZjNDAtNGExNC04OTFjLTU0OTY0ZDIyODliNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZmM2I4OTMtNDg0\nOS00ZThhLWFmNzUtYmUzYWM2M2ZhMmUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvup2X2EC2Rpedw0UEvpwROm/E4rc+gWf/2z//jpoFLYWA6UeO0NlS39X0B8g\n9RHh00cnpyaFMH80/nnwc3zmHKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlIUmi92qHF7pvWtJA6FiUIuHLuswHwYDVR0j\nBBgwFoAUHwjXByTnNbyAMzImdg82rRyof/8wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAnnMJXDteLbAY/R25lWbMpsnKTnD0yto45VqZfNBzKfYCIBg+6oUtLniq\nHKKwnLS5pdzmaAY8PuEjJ+/HgqC6aNjh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZhd8dscRl781qFDCzke1OxAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWYzNjUzZS02YzQwLTRhMTQtODkxYy01NDk2NGQyMjg5YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASws7e+wc1JiZQ84mUU/+z1+pIxUf86OyVwppBWZDZfYb/f\n0i92jmoG0SMseSGhRxyRxMegaLaJxzhjpiIj4/6no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHwjXByTnNbyAMzImdg82rRyo\nf/8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOS+/LiLIHWPT1XXe/J5uIKOihO4ocpxClC4qkHW3TwYCIQDYtE9vGVMO\neJcZvxEnyUiUBTyoBZVD/3kdGhWjY08M0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXPa1mvFatpo316spSGyHSM/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZmM2I4OTMtNDg0OS00ZThhLWFmNzUtYmUzYWM2M2ZhMmUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0Yjk4YzFkMS0yYzg2\nLTQ2ZTYtODk2Ni04MDI0OGVkYTllZTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQsnKccyhOZ7TkUB/+Y5BsnJCHrUZ1zl4qOyp+PoKvyU3W2RpIDPh6Q8BoWnt8v\nHhXPXjKOU4e8NxnOgU43xNTCo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSUhSaL3aocXum9\na0kDoWJQi4cu6zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAKAUlY3yOtN0zFhIKKzlxphIkIvngO52aSUp2Itl6Whz\nAiA5osGKkmcuQvDyUlOz5XEyBabO1pmsS++oxL8F9+EH5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7913", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7913` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXo7zPEjH40kWTpJTyDsHURNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkYzZmNDUyLTM4OGItNGE0Ni1hNTU4LTJiZGQ3YTc2Mjc2MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWVlZTIyYWEtNzRl\nZi00ZDE1LWE2YWItZTk3NTRjZDVmMTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3ukwNHpoPtVPxbwNewZk1+S8Hfyq4gLZbfZD3jjU6REpi2HWJuDY5uJmf5T7\n2cdvCERW+KuxZi68g1GbDmtUzaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyAX+hC6npIrw+paRmuIUL3RQ+w4wHwYDVR0j\nBBgwFoAUnRC6d8KVZ/Rv4ixgEJhIgPXhfH0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA8T24ApV+JuAbR8IFIT3IyLKORJw8QEgRnnU4Wd7E\nJn4CIGbACydJq2vZFcFo/Wnb+tEt/oisuD4uXvcYwHEZMRZU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbTWq3uyuCtjsQwLNKcZvvsmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGM2ZjQ1Mi0zODhiLTRhNDYtYTU1OC0yYmRkN2E3NjI3NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzjLmzC0TVyQd7Mzy+pobfXsZkqwu3g0DpW1rDtIZgqrVn\nDu02+Ta5Khz02caKaU96EUMnTAgoxV0qUPvB2VOIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnRC6d8KVZ/Rv4ixgEJhIgPXh\nfH0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO7D+AnEHOa8xvfbKelNr/dTus8XGheebpyGa6JgEz03AiB3Tn8nnPzF\nmFmTLNthVT9BEvcht0KnpLYEj1DFzN0mrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAeaiRs3XNjjvUb9jz+tom2VCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWVlZTIyYWEtNzRlZi00ZDE1LWE2YWItZTk3NTRjZDVmMTE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlNzhmY2FlZi03MTBl\nLTQ4ZDYtOTE2YS1iMDU0NjE1NDE2MDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ1i64EEpDNi/VczJJFMk5otxRyWcODaStjLgCCpLTVG/6/jQzz2GhxtSydpphK\njYOkOEE83sGz2KjWW3TnMpKuo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIBf6ELqekivD6\nlpGa4hQvdFD7DjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgJtvT7M2J6XpdtHUumKS6E17iuTR1OdbfxxWDRM1bpTEC\nICgA6GbtjhIDe/RDTB+an0AXufZ5hQ13NLQjHp5oG/OK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7914", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7914` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAfaKFNDuJEBy4iytZERWKMWEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2NzM3MDZlLWJiNmMtNDYxMS05ZjgyLTEzNGM4ZGMxNjQyMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc5ODkzNDUtNzBj\nNi00N2ZlLWJhYTktYmI0MjZmNmZjODQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzjolzADh+kqMOPr9sSQL6IOezfrUzk9TVS4jPZ3SrVJVjJ463BBZMbgkYhco\nNsHOPCimJCTDk6tV1NTvXV/6/KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsEppcLbXsugxo/eg2ysR6gnyyZQwHwYDVR0j\nBBgwFoAUYjopaqJWJFq+XXgbjx9KJ7SNVVEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAyOSQCR1W7D9spJsPsO0gzNP2zxhBW77rF/oFrL/LG\nRAIgcGNOsUIdvMBWOrFCvIlrSdnldnQu+YnGkLFX4nXV6r0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU7SN1P1YEEHIBIJpMfER59pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjczNzA2ZS1iYjZjLTQ2MTEtOWY4Mi0xMzRjOGRjMTY0MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAMKi6dLvvhF0CGiz0qdDDiVRtU8KcKgj7T2wsHwLOoh5A\nebVi51s6s4XcjX16+DvAsNRCoL4tSVymJ+ToTn2to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYjopaqJWJFq+XXgbjx9KJ7SN\nVVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOeadunR2UpD8bxrbygWb1tdHHCu//mEct7Hyhx7i960AiEA3cxNaHwP\n8JPV9NKrCIkQMrbDKVKrOXMiwho5a9T1QbM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAam6IQgOfhGWQdbyWI7uRMlgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc5ODkzNDUtNzBjNi00N2ZlLWJhYTktYmI0MjZmNmZjODQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3ODk2ZDYwYi01YTg5\nLTRiZTMtYjA4MC1lNTBlN2RkOWY1ODEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARWY3NrmU3hMaqwgQxbE0Mm5wz4oRvfXkONzElHUahzZn2rHQmYTw42421Lfa27\nrhe2zemjQ9SliDA4LnrwBqG8o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSwSmlwttey6DGj\n96DbKxHqCfLJlDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgaWAb6OZ8DKtvuO9W10JQ6T+IgAElppHThBSGZpmtHeMC\nIFvrmaVmA2dtA3ILz8qTco2uQ5uLCpSQlNp2yqqx6HKu\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7915", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7915` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASKU6AIx8u7kQ1WNPlfLoPEAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1NWJkYzIxLTZmNzYtNGMwYi05OTcwLWU3YzkxMTViYTQ3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTNmNzQzOTUtYjJk\nMi00OTNlLWJlNzQtYTI3NzdkOTAyYTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESiprLulX2Fa72bX8H4h09pKzrktgCwuf9jssxJT0WBDWzC+7DFsLp5vpJgFJ\n8MTBcirZHvo1ifWX0IdiQXN63aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULWrrAhFLUrMk528xfmu4nV/mpJowHwYDVR0j\nBBgwFoAUKiBOtz+CirEzZYhDYPyMvKLnJXAwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAitPeVosgfIW1pKHlB+aqY4OBoHyyLiuCU0/sdSC4k3sCIEIu\ntTbYDDH2LqJ5ZNuG3IOj0wQ2gPRD3G9+0sa3xSSz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeVLB4ye3SQqNCZUBNxcHupGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTViZGMyMS02Zjc2LTRjMGItOTk3MC1lN2M5MTE1YmE0NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARa2Z/tZF4Ae4/YBKeU7WDkrEQ7FPMRCUCzrD3Y2INXwKoc\nFXNCeWD/TiimALYQA3WlGT7itBI9ipVA24tFBCR1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKiBOtz+CirEzZYhDYPyMvKLn\nJXAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfch38y0lELgu+mpyYY3IL+BLFdbI/nl1QciA2z718MICIQCHHpgrfNTL\nfXj+L06zQeqVidzX866nJ3ByK+dza3FQDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAcS6cEYF56LqDT5oN3Ey1LjPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTNmNzQzOTUtYjJkMi00OTNlLWJlNzQtYTI3NzdkOTAyYTZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjODVkZmQ4My1iYTE5\nLTQ0MGEtOGE4NS1iYzNkZWY2YTcyNDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATKEybZX1lVnkr/2eQlX/fRiyJ6Ea1Fglj3k8VodtsTGejPO95pOZpKhmuR5uyW\nQMv31KS39Q51GymMe6UjKuECo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQtausCEUtSsyTn\nbzF+a7idX+akmjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgcz5B+/ffBm7ULNz3P+gg4lTPNMlr8KiWHyoYGOndN3cC\nIECYN2OI++Bn3n/k9OcgR7YrtMZ4wPixYOC3ZtMqQFRN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7916", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7916` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAatEMRl6pcSnX77zNkm4dE8xMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NzQ1NDEzLTZlNzktNGI5Zi05NTU2LWQxM2Q0NWE4NmRiZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTk2MDMwMWItNjQ5\nOC00NjUyLWE3NzItNTA2ODE3OTU5MTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEElndNlEIr8if03mWrqvwy2fwR4TZrocwDTXfWf2/llKLnJ3ytPxib+x/s/AG\n/nAk/VJAND6BlZP3bW8JCOtwwaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3pC3NYc+JkA08AaRG4OGBQPmYJ0wHwYDVR0j\nBBgwFoAUKzgSzFsbNKGHccJujaWZEgL5a9kwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAr493vp+/neM4plvLJG3Erqg1q5IqHiI0\nZPfpRnPgj9ECIQD32niRwKI6jGYV/JvwdiBq3weGX7ibQV/2sNfyuJok6g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYv7cmZgzdoZCuBeVJ8j29/ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzc0NTQxMy02ZTc5LTRiOWYtOTU1Ni1kMTNkNDVhODZkYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5TZe/qTLvYA1fZ3pbjbp8xjen3OxpBHWKc+ToQBM5YnjJ\nX8IxWfAJwPMG3fNNq8UqvXqVTT4uFdtOoWGkvc/fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKzgSzFsbNKGHccJujaWZEgL5\na9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANrKcQeqIWTCN8Bgb1f0zQtA3wYZwwsh242GQqXmVu9bAiEA8udUZUe2\n6/3FdiUFkYmaptUh+YSJb6ZsaB2Ja8NQWXU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQY1uZ8jO95Bga33ybgyBIRAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTk2MDMwMWItNjQ5OC00NjUyLWE3NzItNTA2ODE3OTU5MTc0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1Mzc1ZTY0My0yNmU3\nLTQyZjYtYTE5MS01YTQ5Mzk2MmViYTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASxDRR2HihlJ4NQAw9INNNM6yNfBW1OtOXWGTuOOUViWeX8EnaQOlAFV5+0wAxO\n1j5nqOChCfNn43dVBVNL3LEVo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTekLc1hz4mQDTw\nBpEbg4YFA+ZgnTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhANSW3nIIjhIuJksVKcMYlS2AkSTxEq/Cf81/oQuiFbbg\nAiA48YyLgoOIwOiIBzxfTJCydz6t7IFtducpIPUFSXtenA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7917", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7917` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISATeOV4cJnjxCkAIDnRd8ZUyNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiMjA1ZDc5LWVkODQtNDQ4MC05ZjBmLTQ3NzE4NWU0M2QxMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NlOTk1ZDItZTdh\nYS00NGNhLThhMzktMjczYzJjY2Q0YjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZi1jjTxBB2NmZjvQ+Ag73rwJ3qgzqqC/TSXHI3Sbcgi1540KKUbCGFKlnrPg\nN9fvEQULmrm0z+rjbcYMdVQHFKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm6DJbjSKq2BDt2INfS9dXFRWZckwHwYDVR0j\nBBgwFoAUi+tdSX4S5NdT5O5F1m71zfc14oIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAlNf8SafyDUqI/Ey612w0H2kvy2pOIXec\notrx6J6iaQACIQCzq7cvPvzLSJvK2qSVytKAuc4s2Ij1IjD+Odo9bY2AlA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfXmxnbh0e3PxeuAvy0ztFQxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjIwNWQ3OS1lZDg0LTQ0ODAtOWYwZi00NzcxODVlNDNkMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwTwSPPxax2d/2fovXpIjC21ruTyPKDoWITXvJ1NCsdeVP\nffAnw0WriISC8SHsR1g2XDoMmxoH2R6dT/iTGTMJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi+tdSX4S5NdT5O5F1m71zfc1\n4oIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALlGvquuSosEGvjshpIcZFv/N6IoGsT9YkZVOjuvt2myAiEA3a1flSCH\nfmjMJyzgKxQb8D3NsFAZI1EpUwjDH0qHoo8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATc1nKd35ZbG47NkbmqYCJZ3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NlOTk1ZDItZTdhYS00NGNhLThhMzktMjczYzJjY2Q0YjAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiMzg2ODVkMy1lNjU1\nLTRiMjAtODU4YS04YjI2OThmZmJjNjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASXdkBFlKmaEXCp2w3l2dQtwxSAYPeitffj1IFpWr26ve7H2IxhW5qfbn9uM14L\nGYSlmuBpdvj3b/qr5yHsL/Hgo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSboMluNIqrYEO3\nYg19L11cVFZlyTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAOYXDFPhBDZinS3zZKpOYCRWhuQTmQD8XLYxqr4q/fev\nAiB8fT99j44BFZ8GhFoMniuZJJmPk5AdVH/54UEb5HLESA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7918", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7918` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAbPF4tnG4Vu9eZYQUhBQgf6rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2ODg5NmJlLTIwNjctNDQ0MS1iNDVkLTQyMGJlM2Y2ZmFmODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGUxYThkMWYtMDJk\nMC00ODJiLWI1MzEtZjQxMWFjMDM5YmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn53TVG+bG1O2/+iZ7TNvQwRwaXpSLJ88baepZw8FBj91jE2Iq2+beK0BxwA8\nTHf4Ol5tRPUC5Ai3Tb3FGOJ3MqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVWXxagt04vMO0ENQ/iW//VGKCvIwHwYDVR0j\nBBgwFoAUEbGhdjP+5he+A6edWFkCZ+69eAwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDd0yPz02Sy2YBY60ISmXRRh5tCx\nEbPZShRHKQBVPxcqAiAqEFsua/llArtr+MlxKrDACfRbhT9TFYO56smAf7z6zA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYKrZ7/ZoitxxtV4/GRChA4RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjg4OTZiZS0yMDY3LTQ0NDEtYjQ1ZC00MjBiZTNmNmZhZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDdmnhuMdT+Nn7i2U95fYSG64eRGtt83Tjosvt4MPRhVoi\nl5kqhgVvTBnT/gUkZLkZIMApAJRRdE0N749G79yNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEbGhdjP+5he+A6edWFkCZ+69\neAwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWxCYz5kdRCWGlkPHe2lr1iqG/bB91qdHlCxVXXdl25MCIALqg7ziWYs2\nRHEcwBQ9E/NavxUt453GI3iznLWrMQuh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARejC6YRuMN935XzzJ2kTR5GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGUxYThkMWYtMDJkMC00ODJiLWI1MzEtZjQxMWFjMDM5YmY4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZDYyYWE2Ny03Nzg2\nLTRkNmUtOTNlMS1lYjA3MzQxNDdhNTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQSZjnKxcj4KNKbQPWCXoR5NSjd+4AMw5PNahlN5aieSW09+Cp/8YnnsNh8R9S8\n6gfYTzQfY/xiw/+ekLd2tQYHo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRVZfFqC3Ti8w7Q\nQ1D+Jb/9UYoK8jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgDgx7p3O33x4QIZpbyudEEnn+rmQwK4pjoSJ+TxdfXi8C\nIQDbELi/Qr9HDsQ313GPBEpBTsxyhHWqC8hccdTTqCtooQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7919", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7919` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAdZ0Go8slY7QQbpg36ekpcmVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4YWMxNjZlLWE2ZTMtNGQ0Ny1hY2NmLTUwY2FmNmRlNmE4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI3MzdiMGMtZjM4\nMS00N2Q2LTk3ODktNjljN2E4ODAwYTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/P/DgSTfmEWUORHOXzy4RvGuryXB8uo0lut3IUy5V0XS21wDO2idCwvKnyK/\nq3AuZj6UVAYXf6fzxGaWC8D/6qOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmO2ImVO8EQwcg49lnKNEJQXpV40wHwYDVR0j\nBBgwFoAUyzHanhwC6fRCT5gSoTln10aqlLswKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgb16+Y9SJ\nWV61o37Oi27ppeseJuqV/npkYNdRay0TV0kCIAbRpG9w1PVx4EcOD1WuT0ZoDzxY\nU2+EQm7HMs0zZCbu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARDC5gIqMpIV4tZ1IYysFyNMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGFjMTY2ZS1hNmUzLTRkNDctYWNjZi01MGNhZjZkZTZhODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpgMwdidsbsH/I+9r0yhxGugaxXnwo3fiQ2IoIqxyuO8lx\n9R7V1CJkLb9CcmowwFPEY6g18juG4TuwSTP8GxRjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyzHanhwC6fRCT5gSoTln10aq\nlLswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbZNJAYCBFhz/fAmvTPj2ax61i+An3H2k5Z92dztPEFkCIEwy/eHuFstZ\nez4G5AMIU9SYbHrUJKmrwq0k0s0MSw/p\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATRr9eIVFuBEs3KGxQgRyE12MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI3MzdiMGMtZjM4MS00N2Q2LTk3ODktNjljN2E4ODAwYTBhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZjhkYzlhYS0zMzcx\nLTQ5YzUtYWUwNC1kNzUyMzJmNzk3YzkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARfxtu30X//+afDU7md5XGwFXptDRnLaAas5vZW/QOnK88N8MdXYd7JRO2E5hH0\nziYPZwRIiyZXYtEB+p80pQLgo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSY7YiZU7wRDByD\nj2Wco0QlBelXjTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgA2djfsDCgLJf51Xtiu1/mwQGdNtLjfc2X703oWYB1AgC\nIQDGmWavQeRyHtfyCXyj2uvvYhA5yc1CPLJVTsLJ/HVZqQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7920", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7920` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAbFqeqbFU9byet03zHR4nkGBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxMjI4ZTQzLTFkMmQtNDMzNS1iYTY4LWEyM2ZhNGZkZjVjNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVlYWNjY2YtN2Zl\nMi00Yjg4LWI4MmItZDJmZmFmN2EwMGI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoh1E/8P7zNfgpAMmzynZhyiA8zlUcygybSJr7BPZJ0ClD7PTjFFugVzYrcd8\nVsilPPm6SJCfd7QKN1eFnXfI/KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1FlrFJy5d3RDuW3ykc1WnJKM1SUwHwYDVR0j\nBBgwFoAUnj5J17fzIGN4OjoUNCW845dKllwwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJe1BoQv\n1KMCWIIuVfm+jYJHkF4tHKAU3U+AEp3gubxNAiEArScC4+qZsU4ATCaQZWx1o2Q5\n2h7qfPu0aivPI2hl6BY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQWjdi0GOPga7ChDTF7PXEIbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTIyOGU0My0xZDJkLTQzMzUtYmE2OC1hMjNmYTRmZGY1YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFOWuR5jfcBKezpeS8xkEDZllnEs86lhN8cXndSHxAfRQS\nOC7CLONSSON7tSj3NqaNBLiCNFKFiP3Qu53xtRkAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnj5J17fzIGN4OjoUNCW845dK\nllwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALJJSLR8VpDKbtsl39oNFCOGaRb9NtksHDodNt+Qo5TvAiBq9EeEHOMY\np7RBtZhXSOBoKfLTO3Sqp3rZOAZSai2EBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAfdHpJ9G3aCslCTohj05JAgcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVlYWNjY2YtN2ZlMi00Yjg4LWI4MmItZDJmZmFmN2EwMGI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MTgzZDQ2NC00NDI2\nLTRmZmItODU0NC00ZWY5N2Q5MGU4MDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS95naBMN/JCk5si+K5Cx/xNgCueOqhMY4yhi5dDayVIsCQaE2vVs4R5dW+fFU9\nl50uYmJKsNXi9cNFnLpQGFeOo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTUWWsUnLl3dEO5\nbfKRzVackozVJTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKEpIJnTR3rv5ST/b3ybXDpU3wy40JbmLnyGiTVjrg8G\nAiEAg0v4di92b9UMJBARKvHhYk7tK6jdEDu778KxlBqoYmI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7921", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7921` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAYEO+FlHnkmXmZBymb8Mb3Z8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlMzVlOWZmLWVkNjgtNDNhYS1hOTA3LTk4NTY2MWI5NGI0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFkYTMzNjktZTEx\nYS00ZjIwLTlmYjYtNDUwMDQ1MGY3Yzk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy5wxer18y7pQmtxauFWbYpiZh5Bs2fLVnvnz4kVjDl/W4N82Zu6AK0TLcR+Q\nKBRyjYZL03Kd+BTWsDz6PdOie6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8jvK1jlRlzCoWl8sctTzHUVcXhcwHwYDVR0j\nBBgwFoAUZTbFBu1Em4ftYSgaiynIQL9v+e8wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEHMgBZL\nC1UNKpmN9XLPjuKbC3x0w3nWIqS4YCEU5BMOAiBOrJtfobfQeNZpgBwK/Xk6q+oE\ntNsEBpX1O3yCSGBF0w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaSrsPobGOqYPIVxxsvE+VdaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTM1ZTlmZi1lZDY4LTQzYWEtYTkwNy05ODU2NjFiOTRiNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyB13oyVvfTon2VFCgEbR3B3pnXpGCx65awakpc6lyIALn\nDaF+VuobddkQtaVDMrw23ehi3GfSVYr5jsyZXbLOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZTbFBu1Em4ftYSgaiynIQL9v\n+e8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKdUEgEIJxshhTlDkfO8R/frQ14wy7u27dIy8WHdafgaAiA+GCS+ZDHL\nmGv8/NtvSmQscSlRLHQDY/a1GVsYJ0SPcw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAclUS93GCGnrrC5LghVdYHFpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFkYTMzNjktZTExYS00ZjIwLTlmYjYtNDUwMDQ1MGY3Yzk0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5N2Q3ZmVlZS05YjMz\nLTQ1NmEtOGJiYy1jMmYyYmEyMDQxY2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATNXiz+bNrFVp5osVW11BKHAoHpkosVgBHwzr101YYppmKVJRrxoMOM2dXwtXX6\nAD3PNqYzuR4IVht5aW5JAVMoo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTyO8rWOVGXMKha\nXyxy1PMdRVxeFzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgeCJ9g8VZZA9XgZbA0eSOAFSQ6RNnTvSHbXElfmEoBKgC\nIBcm5XfZ12LXOMZilKrU83U1ltxBQdXO3n1CAijFgxeb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7922", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7922` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAfQh7pWe0ulpmPa2nUAJGRRQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNGM1NTZkLTNhOGYtNGM3NC1hMzM5LTY5YTE0MWQ0N2JmMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM1ZWQxZTktYmYx\nMS00NGY0LThiMDItZTZlNzNhMDA0MjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELSbo/4i0DO5loZDvjg+ytwrD3/dwl9hUKEDK0GVCrs4/ZeAfwK9OoNh52up0\nvFTfatyvAIccz+xTY8k4lb4PUaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZm2ffsy35Q4RwiRRlLs1Iet7i/kwHwYDVR0j\nBBgwFoAU26glXrd/1dGm+TSFm1eeJHPt5HIwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDULXzb5ZOkKAp7CSX5cA3M37LJtjd5aYm94rCsqK+oqQIhAJuETDj3\nuFiy9H8MTWCTJyaxC8p3GU7eTEfij2BAHXPz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXHHBRhYTME5SXe7S7SWTfWeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjRjNTU2ZC0zYThmLTRjNzQtYTMzOS02OWExNDFkNDdiZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe77SVx+/1cIgbbxEbkUbFi6vwCfINjOjGtE+suCKNjEhz\nBsFe4pqnv84mlSz22daPugj1utNykgBft37wcoiRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU26glXrd/1dGm+TSFm1eeJHPt\n5HIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaOlBXvlQt596/ZFq1kEHrFXehTOhf9enzco6sqQeUfwCIQDlt6HS/ftp\n6BQVSO3Exa478ivcArQkPulhLpuz4sZWoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbDHTofrVRTgjKYWszEXqfZ0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM1ZWQxZTktYmYxMS00NGY0LThiMDItZTZlNzNhMDA0MjliMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMWQwOGIzNC0yN2Iz\nLTQ3NDgtOWU4Ni0wNTU5MDE0OGU0ZTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQTqDurd+kGnK6M6T76JkhVE8QW3Phs01naPVoiCA7llQ3lXFdgVJ8PpKhtSeYc\nHkB5dtUT6ukeY9qS9wQ5LhFEo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmbZ9+zLflDhHC\nJFGUuzUh63uL+TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgEpH4utYLApNYoH4iMH4wiO9cy5pGSKv3GeGu5j3yQSwC\nIQC5S+q/2jAZS7LCflEzgVOEzkeIxqmIN+b6yFvD/POvjQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7923", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7923` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeoE5JdIFbr/ndqjTp2C/8JNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0MzAyMGVlLThlNTQtNGU3NC1hMjg2LWQzZjJhOTNkMjdiNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdkYjgzZWYtN2Nl\nNC00OGJhLWExMzgtYjllMmI0YzllNWQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYqHRWH7V4W6TLxc/ZO6t2Dl+WRJdVHXjnD6B+/WvPpS5fdgcAJLr5hALuP1y\nFEsyFAxQHBDqTQjQIPkHj99zaqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtJ5tTul1QT2TqS1w8Pcc7s1fIA4wHwYDVR0j\nBBgwFoAU3dzK4fWEwvc3hnWUVyYAq5DSNBMwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDLpj0CU7aK8pZQJ8AqWb4gka6oq0DTniVLB1gV8eRIMAIgXaQWPcOV\nj7hibF5Vm5p1szJHjtEVyIa3rf+26SBikOI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYBicUuoPGiLDBjqHUWYprlHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDMwMjBlZS04ZTU0LTRlNzQtYTI4Ni1kM2YyYTkzZDI3YjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGyqskbkcAqTS7FmASPeoZ83Lu2oOK316PqX0Pr5ZpkEJG\nJ7ClxSlvC7nafpBIpWFqLmT8szGvpR4CC9w05VCWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3dzK4fWEwvc3hnWUVyYAq5DS\nNBMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAIN9YxmDGn9h09pxKq9TOh2g1d7NXLIN5serJrTOa+vuAh8pid0wEEs/\nzxWP7JoFJPEh9YyL5jhTu7SK5JwiFYFQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAX9Ef7kR8HDSfzdPMFKTAmSmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdkYjgzZWYtN2NlNC00OGJhLWExMzgtYjllMmI0YzllNWQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNDUzMjJlOS04Zjc3\nLTQ4OWQtYTc0Ni1kZjIzODMzNTM2YjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARseOEOqJkp01zZQ2XyQquIBDroIP+nICqTqdb4f4eCE21agJKowEaD5q06Iehi\ndK2ExQ7yBHjOF3dGZu8ATeYbo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS0nm1O6XVBPZOp\nLXDw9xzuzV8gDjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgJ/4eJarOFGj3PX0DnU1G9NgQjzmoO2v1KqmMVZ+Hdq8C\nIQDGf8S5OT1hPnyJHXtvGxnoZ1Esa4Tb7dSopdD/LYkLag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7924", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7924` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAVlh/o7pJD6qFuuowhR2UP02MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxMmYzMTYzLWVmNTYtNDE3NS05YmNkLTJjNzhjNzZhOTVjNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ2MGI5M2QtZTRh\nMi00MTgwLWJhYmUtZDIxZmQwM2EzYmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHX0Ve05whOFYlzBMUqjR+immRbSvA+1H1LDpH2Kru/zWNwtcWDsMzEt71xuT\nTso1vFH+M0ZOYGd9TnCRrXBMoaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCOOXnzGFxk6PsXBj2T+XyQs/MT0wHwYDVR0j\nBBgwFoAU+JAtBH+5hrSVAdrwky/yjDmMS6wwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIHcMZ5UoOTYH/mvDUyb2+as4b4XufC0a/vDwPrt/Ix9OAiEAkGgFl3qd+JuKPFr0\n4Ta9rglPcEGf4ZoN98V4emI6NO8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXJp0+w/PJJSNL7lAeRQpyJBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTJmMzE2My1lZjU2LTQxNzUtOWJjZC0yYzc4Yzc2YTk1YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQd0cIDDP4JSdnAa3/XkWRD04DQsRwIp+oGqgAjSLUgLeDs\nKsoT6e9HKDLT0Kgx/zvPFWeRnBxbFaLU4kTqLH0Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+JAtBH+5hrSVAdrwky/yjDmM\nS6wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWkAuHKiR1pI06JsTqN5+lTB+mKAJQ/oPC3HZc3WPKNcCIQC0DhKsxwxs\nsQ+pFXNQ/niCN7Ae+qwDD8/oVxIo5Q1vwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXqwS5TYSPUuGf05JEu498oSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ2MGI5M2QtZTRhMi00MTgwLWJhYmUtZDIxZmQwM2EzYmNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZTFlNzIwYi03OTI5\nLTQ4M2EtOWQ1Mi04NDM1MWNlMDgxYTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS2wkSd+Ei4HKF4fejTp+e6zjbPIsOLC1CowaSptBpLSQr+g9a9zFnCtSusBEar\nkJ3P+/fKoXIo5gJkA+X53JZdo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQI45efMYXGTo+x\ncGPZP5fJCz8xPTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAPdCvL8qh0UpePSDCRDNEsrn71AzBVZhNU0NZiQD/csv\nAiBCtU7e03nd9QBUi5WuUIXy4bhColQ/HBCjyX4zyi2FAQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7925", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7925` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAfeqdZdfsVO4sBizRdlyl9oQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3NTliYTc4LTczMGQtNGQyZS1iMjRhLWFhYTI2OTc2OWMwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMyYzE0OTctYTcw\nYi00YzdkLWIyYjUtM2I0ZDFmYmY1NmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXqvmgePgWn47998Lbzs4vii2OvaPEPdLemBZY/bjJFzWvOUOFD5vTF8eE+Wj\nl0dfbFkB/FHmUEulxoLzpDaxsKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpYFsGE3A8pD2ICDRdH6mNYflxbUwHwYDVR0j\nBBgwFoAUjiFdjNuIvxcE533IkQbsgU0SWTQwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIHIIRscPlnkQ57T9NYLvHlHrJoX1pEhxmjAnO4iOvGLZAiBO\neaXtdkPIX9s4+OmfPIH3op9dEhUJY1gNlMOe1IzfRg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQd0zqwU7Xq/DmCdiZ2I2LAgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNzU5YmE3OC03MzBkLTRkMmUtYjI0YS1hYWEyNjk3NjljMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZ8h+7xN8lDeOOgghUk0ojacL1DrdA38C/dX9dOJGmsO4G\nF09idCPKmaElz01rdGyoGEi1Map0I0ARh7joewvEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjiFdjNuIvxcE533IkQbsgU0S\nWTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIRdaJe0L+3IWtk+nSO+fVhOCo+moS1NTfNFnlGgUkBgCIQC3g9D251q7\n8P6lCnCqRv9XlTSYGkUkODTBtqMp7rd6pg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAWEr5RWOBv7X5VEEf6VzaMvyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMyYzE0OTctYTcwYi00YzdkLWIyYjUtM2I0ZDFmYmY1NmY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5NTFlOTRkNS1kNjEz\nLTQzZjAtODRiNi00MGNlYmNmYzlkNzcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARxGb7JdH8dneRoWohJcAU81L/NB3utspdCKdmDJufqvj7Xn6yzXrVB6pBrMEdE\nKcDHPvnTaOv6I1fXE4Wg06Uio3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSlgWwYTcDykPYg\nINF0fqY1h+XFtTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgBl5o0qss2Fog+Au6pSiPJewVMGrHZaHCNXKT9cs9dm8C\nIDpJnAnVwbdgeORxL97Wqrxdm6Fq/+bgAMhYgpiu9RaI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7926", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7926` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAXblmxyhLZ53rafVRg5bLc9vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MDA2NzE2LTBmODctNGE0Yy04ZDZmLTM5MGNhMjc5YjJmOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWEzODIyNjMtNzcw\nOC00NWQ2LTk3YzktYjI1OTRiNzZlMTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqXX2zioQrKNgiiMJEWaQ+sp0gNcHa4Y+cvnLoO9QqbowC0leVG1fQBluszMr\nOUMUWQQ7vAPyoRbVXNjqO+VtAqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvaQIfWGMu1g4plbkDzfYKk3RkXAwHwYDVR0j\nBBgwFoAUD4Vddxeke6R+8xHkNTjRsOA+Q0UwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDZMioQmCRhjlAIQ9dq+/GUaaA6HORjc7DPfGUHNX6vNgIg\nUBHEDUBnII21PB5qoIVoYvBxKFC4wnVc7VRhNjEG9AU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARcOOZF62M2kgSPEkKrlI72rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzAwNjcxNi0wZjg3LTRhNGMtOGQ2Zi0zOTBjYTI3OWIyZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQY+1i4lkGo6bR/eiCAUCxsEWkCljIKk6hdUz1sCewjEKFI\ng7F1xIjsak59Lx+4RY0sdfq+6yymnCi6dh9HKCWTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD4Vddxeke6R+8xHkNTjRsOA+\nQ0UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCu+WyL5l9Gf0PUOLRPS96bSsEvT15OxIHiAQN/h/TyECIQD6Rda4ZNZK\nFOes897wXRInDY3B2Oy64E6kIDdjIZJxzg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISARwfYNCnsflrxCjupI5ASRJNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWEzODIyNjMtNzcwOC00NWQ2LTk3YzktYjI1OTRiNzZlMTc1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlY2M3OTFjMy1mOTAx\nLTRiMjYtOWUyNy01ZmIzYmFjOTdlZDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT2OmFazJ600T6rF2EMUzqMCOzn9wozFe6vrtlskocXCki6jyp67mbcL82bzxNe\nJsQxlGpy4eB9ycc/fpNVFPVno3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9pAh9YYy7WDim\nVuQPN9gqTdGRcDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAJh4FUintEZJffCGygjVEaXO+QiO2eSFrORp2ldN9tKR\nAiEAyWEXSa2HzGJ8mxBZX/xAy6B6/gjMrTvCv7YKua7RLCE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7927", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7927` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATNz2xLP3l/b9NjZ+v0FydrIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MWU1OTU3LTFkMDEtNDkwNy1iNWIyLTg2OTgzODM5MTI5MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTMyNjQ0N2YtZDBj\nZi00NjIyLWFjYWQtMWM0YTg3ODBlNDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7ic7eUcRoYKyWkbzzJJNnQxF6VKLYb59evkbkd6hFsLLBIvCPnIDKHUp882F\nXvSZc0IbJ6sB87hr5RfBR5tFD6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZr8xVaGcVijg5QSIaiSx1YlTHqYwHwYDVR0j\nBBgwFoAUbaSyCrp6W/apAwOnGxJPLMUrWdQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCICmS6uT9Pj9B\nILOqYzZuNcf4/gH/pnjLh2pfBIPZXgPjAiEAx8pEcOzVAvNdTRw0+inpE2FbjMC/\n0PEihEcFZgsEt24=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV7YvoYVWrECXC9AAHVq2ANqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzFlNTk1Ny0xZDAxLTQ5MDctYjViMi04Njk4MzgzOTEyOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlUjU3AOxpcVGndRkIZN6tdt7juysTT7Xk0bXMrV7/jr6x\nOE6YldX5nPQ7JumNUrW5U/jNIAhRglLWGW264Eepo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbaSyCrp6W/apAwOnGxJPLMUr\nWdQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGe7k+4YFCkWOHn9KakuiGKogZ46JY0FDCIKIg8gQpwECIQD36Dpjwsw2\nwZ/cAWkLQnguUsqjtR/YHs516CK00Nkrzw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVupYrYt1xc7US/LEIo9KBs0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTMyNjQ0N2YtZDBjZi00NjIyLWFjYWQtMWM0YTg3ODBlNDcxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYzljMjY5Yi1mN2Iz\nLTQyNDAtOWUwOC02ZTcwNjU0OGVlODUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATy/BhDRC1iMyLUVhMQOQ1+0DeLi+Vc/J3ER8lNgZLbS2K+0WmRcSeo46SvZP3I\nD1RPqT5T3XuaA4MGDWW9pk49o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmvzFVoZxWKODl\nBIhqJLHViVMepjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhALCAlM7PGyGDxWH/sqTa1/NUXvHkn1KV/oy53iH0/Jz3\nAiBeRyTOnWBZ1Jl4687aFIKO6JrdPqvcGGmyviotuaaqkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7928", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7928` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfKRs5i9asae/FaDdidTglyjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZjM2OTczLTNjZjMtNGFiNi05NTkyLWViOGNhMzg1NDY4ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNjZGEwNWItMGYx\nNi00ZTA4LWI0YTktMDk3MTY0NTEwZjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK3GXlBw8amNLbzuhrv4XP/EOWkBn6hff/zJQkxmNMJwmaf2aelLyd7g9WhVk\nN4VHg5FBbwhWQw2DrE9Uu33BtaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFHcYxys0qbbpYtVPCwZugltJ78EwHwYDVR0j\nBBgwFoAUtLE6JHRRuMMjSf6LP+MRX/E6qmowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJcqmivz+P739TM9ucOurNRKSx9f5r0iB8oftXJiaDgbAiAb63ClkGEB\nRNL6O3LbDQCHOhZTnenztWDmiRb6XReeuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdzg5kohAIB/P8cIX+qV5dEBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2YzNjk3My0zY2YzLTRhYjYtOTU5Mi1lYjhjYTM4NTQ2ODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1YA8FFkmka7l1T/EOoP0ljlc2dFZmyS5uOfFVx9iLS+uY\nTZG/cipF0sO5XaTAYw1H8UOmQJqy7pZfy5wULKoHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtLE6JHRRuMMjSf6LP+MRX/E6\nqmowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKNMnl2XqRE8aWG7Rw+HJBmr1xppJTOECc8I/A+GownnAiEA5E/jCdV4\njnqdUfE96ZS1maGCEhht8t8s+l0ESez+a68=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdmHVcvbFszgo4ZmP9/C06xcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNjZGEwNWItMGYxNi00ZTA4LWI0YTktMDk3MTY0NTEwZjAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZGNiYTRiOC00NjJm\nLTQzNGMtYjMzYy0yMDExNGY4NjQ0NzUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATMzpCKDrqn4s7tvW2Id6rIROlfdFV/8QjkrUvwJ4egT1m/J6ILUudHZDr8wbBv\nQy4bTyBIWqa42tuH9PGdCp+do3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQUdxjHKzSptuli\n1U8LBm6CW0nvwTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAIqO2jWkrHd71RLDv0PvEjC5Uq+fBSaJDdncSSuVTJWF\nAiAO+oVhJBgcoVGS5RHq5QAH3gVRMErlVg0RO+7GcOXhAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7929", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7929` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZ1QtoMOQxqRnL3QJo3jh7/NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMzIwMjIzLTZkMDYtNDNmZS1hZjdkLWY0NTBkOTkzM2YwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQ3MmU2MDYtN2Zk\nMy00ZDlhLTgxMGItMjAzZThjODBhYTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGGFql2K8w6LSa2OKvpVJrlojQrk8oc30suFX2pGAMQsTNQqMw2JIErAiGGbS\nNjbbxH26M2QXLoG50jeIktDdLqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSgLtfTE61fvAaBcm1sCpiKrSB8wwHwYDVR0j\nBBgwFoAUk9xTnuYmQcq2SjiVMZHUIEOSYeMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANxUvXUs7Lu9j5wXpQvyAarQq4G19xJ0ZapkWW6vJq8tAiBF09BDBshU\nTIWgO5APtcRvz1SGGNNRVkMMuR6KWcIq3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfHWzcMab4Spa7WcqFVvwHyjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDMyMDIyMy02ZDA2LTQzZmUtYWY3ZC1mNDUwZDk5MzNmMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDVAlQrfvEk2aORIPe06hXpPjiTs1NkwR2yQnVioKc9dYy\nPFw+9djDlfYCc1K5MMItHfp4vXP+OSvYFtV4weq5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk9xTnuYmQcq2SjiVMZHUIEOS\nYeMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIRtFkLhC6KhaTB594ecgnyEmxXjW+xy/i7Rbo9cqml/AiAl+fxee3ml\nr8Y043/6+qmX5su8WqFchDAsNFaZ6oKtUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISASYog82f7BB8+BSMFG3aF92/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQ3MmU2MDYtN2ZkMy00ZDlhLTgxMGItMjAzZThjODBhYTU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YWQ2Yjg3Ni00ZWVl\nLTQzNTAtYTc0Ni04NGVhZDljMDIxNWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASvY2Risvus1YswjWK0edrrRKhKJGQ7d9I0M7Lpn5a1B92wff955aVYTGx23yzK\n7/Uh0x1svB4z6fLeRiZ07JjVo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKAu19MTrV+8Bo\nFybWwKmIqtIHzDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgNy9XYt4OOuf5LsAcZ6ZRfxrfMP2UsQkpiCkudzXnwUoC\nIEvaglU/8Bksfb7RZWAGmBZaKp6pEfcn9qlOCGi+cBVv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7930", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7930` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAbYLKy1QyjUhGO2YypQwX7bIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkZGFiZDUyLWRiNDktNGQxNi05ODM0LWFkNGI2ZTZhYzUwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdkNWYwNTctMzky\nYy00OGIxLTlkZmUtNjNmNzMwZTY2NWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeXUs6sYqipMpPHCAyqHkMvmFZzbJ0WKhGP6JgtRcIMKNKVntC5iQl3KT5DLS\nqfLS1qSa5UxmFPtyYhZG1no2G6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpNPcRRW6BMhtox6hHYrndO9HTfswHwYDVR0j\nBBgwFoAUGR92TbMg5iuRCG391Wy6GNOmmVwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDQwfWKvwJbYu+yqc/SQZy/1wSAjzffQLfm+8By8UUodgIhAKqJs8Z1\nPpY9Bo38WzWCEXu6hNnv6aht5Gf4OAMvikvU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASZosgKtPSFwkQx1Lf3yBvLVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGRhYmQ1Mi1kYjQ5LTRkMTYtOTgzNC1hZDRiNmU2YWM1MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbvQzKbCP+17d6Lb/Qrgnyo/8MmIMemNYoFKLGpmWQGUVw\nqdPASUyUs8+1eObwHTsQd7DlsvgrfLqX55LoIIdSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGR92TbMg5iuRCG391Wy6GNOm\nmVwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIga8lA+H0gXOBIuhjrlRv9lBqp5BSlEm9ll3ghHIxCOcMCIQCHlwR2r7xg\nNH0CwqufMhwJypkPJJDk/XXQRlX2ibnq8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAU2NFlur3G9sNfT37BD6W60/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdkNWYwNTctMzkyYy00OGIxLTlkZmUtNjNmNzMwZTY2NWE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMDE0ZTU0Ni1iMzYx\nLTRjODUtYWU0Zi04MzJkMTFlNDg1MGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASby2g+djPtMJ2tMdtVav4XdcXxUVSdcdSM3aCHD8bEg3w5rV002jsLfi5J2NC+\nnKiM1Sk6C+DDO0zVChL0sdJOo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSk09xFFboEyG2j\nHqEdiud070dN+zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgHNPdyFeh6UjMnfEMzIAIeC+aq3jeIdbdHchQRHrvKi0C\nIQDy4Ytnen9TmutCaNbSiR+Olj01nq/3SOzJoTts2ffvsQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7931", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7931` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISASQmad3Y8Mrf3MxDqvBjSZnOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4NWI5YzI2LTgyMjItNDU4YS04NWIyLWFlM2UzOGI1Yzg1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVjZWY5ZmUtZmRj\nMC00ZjM1LTkxZmUtMjc0MTEwNThlYTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhMMh8NvWBxt2/ZLEvZ7nJPii4KfowOttKfoXgSo9PrrmZV2gTFYDCLIJXqE+\nXuYQwTpgQhJhjQnDXvQBhRf9TaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7IsKr6oNPFXY1esLX8PtBIazM/UwHwYDVR0j\nBBgwFoAUp53hiCDmDRFS5lI5MI8S5y8TxPgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIG89+2aE+3qgvaU4vmtSqT2Rjl+aD0g9yZhSUtoE\n8gS8AiAsks3cGNINy0AsO752WBvl+tk9jttBL1ixYhD+RDbHlw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcUzh3IGQQs9XBH2AcLxasYYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODViOWMyNi04MjIyLTQ1OGEtODViMi1hZTNlMzhiNWM4NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzaCVI4FEb4+mwvTaIc5HWttxrn2b79TOqlbl7AbEcGmXz\nbDC0FSbE633v+AK3usVKNxi1SpUiUvU78IEOoquFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp53hiCDmDRFS5lI5MI8S5y8T\nxPgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFdIRN6RZ3tsnZZ34JDwt8WeLsp8A1zXSpfCbcvWk18UCIHz4MkJc5MdX\n65HWb+fi8oz7QHBsovS9KCByX6cgODfR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUUyFwKdjIgtd8+b8/WimcI2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVjZWY5ZmUtZmRjMC00ZjM1LTkxZmUtMjc0MTEwNThlYTQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YWU1YjVhZi1mYTA4\nLTQ4NGItYTZhMS0wOGUxZjI2MTQ3MzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASkvDDMhppNEsY10bnTo9+/E/+UVtl2Ywp5WqQLUJ1W+uVy4qAMWYiNnBeVLvHG\nQwiSf3NIT/o1Ic7S9Y8hlpeMo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTsiwqvqg08VdjV\n6wtfw+0EhrMz9TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgEE36SU82+Fjn1PE0PboiK1ZOOwJIkZuLmpFLIw5E+TkC\nIQCUvumgIRg1jkkC+0vzy931wL6nf+GSy7JscIQuGC1dsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7932", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7932` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAU/VPSOE2x/M85gro3UvAapWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhMmM0MDcxLTFkYmEtNDhhNy1iYzdkLTU5MWUzNDRiZjA1ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ1ZGUyOGYtN2Fk\nOC00MzBhLThlMDgtZDkxNjAyYzNiNTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhlKvhKS8DPJrSxZ+L39Bxtq/mlxATxpvYNeF5weB/FkYZD8B7c2hOdf2O2Pl\nY2MTgu/aCTgmMbLx5Pe5td/yyaOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzvZEt4J6JCs9HEV5Qpr9pz3YWpQwHwYDVR0j\nBBgwFoAUXghnPkIuC7OyZMsJD/IhcKpNqDkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCkzIKsAV09LfcMFXwulVuQs5jQywL9OwePp3UB\n9rcL1AIhAICsns+TP4YavVWEDBrEV62X9lNdFWQkGWcqeAi1F13u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASHgLQXXJSg9QJwge23uxWz7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTJjNDA3MS0xZGJhLTQ4YTctYmM3ZC01OTFlMzQ0YmYwNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlbp5BnGO4RNPY5Tme0V1I5MHbGx5zlo8i0tHAV0CI0Bau\n/7WkH+c8x1ui2qWpZ4pwS/EaFxA920E0snbpykR+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXghnPkIuC7OyZMsJD/IhcKpN\nqDkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEYTXGtwd0iCz3V/vO+mDkurHqEfehGf39Pt56/V/caECIBfGgKRZ+riO\njCfT0idlf5tCvKSAddV0sJ18GjZBir2X\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAe2hreTlXek68CMG778SMGaWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ1ZGUyOGYtN2FkOC00MzBhLThlMDgtZDkxNjAyYzNiNTdiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMTg3MGNhNC1mMDY2\nLTQwOTctOThlYi1lMDMwNzIzNzNhNDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQUqygYUvfnFKlWsHi8jD7KGXo0Q4t7Kslx+oJQlYxdvR2tsw496+AakPIOjbU+\nNRWWfPxIH8FIUZxzOe1l9VOqo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTO9kS3gnokKz0c\nRXlCmv2nPdhalDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAPOX2hYkr0wTD0r697UecNmSx2uy0maL8fkd+Jd7rXJu\nAiBF87yA1n8tSq6jFwn0s5V+t5uiuCZOIBOvbDb3927zDw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7933", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7933` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAXv6Kx2lUAE+KHGGkU7fGrbkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxNGRiZDExLWQ2ZTktNDdhMy05NDAxLWQxNTZjNGM3NmRjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDMwODJjMmItOTQx\nMS00MjgwLTgwZGYtNDVhMTVkNmRhOGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7E96caGtBk0dgZAYQKOOhAAionDZhZh846GdHF0unUtnSG8dVF9Al7iGotbo\nNubO+EwenpeY4g6wYWP5Q0JGW6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2hNIfD/vHrstHGJ7fTKn5Chy2/4wHwYDVR0j\nBBgwFoAUgtB4fv6ociQSQmgolMnNbqMuTVUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQD71/jLuES45EJ1DCAX1nsQxZGNXmeRpGPpABYo5EDwTgIg\nHsOTAdDi+cDvswiqsgmFWscMAMRBkFvWXl3AfyXLx6o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYoS3fqZR48gN8+ybz6b+0FeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTRkYmQxMS1kNmU5LTQ3YTMtOTQwMS1kMTU2YzRjNzZkYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXD/hLHBoHMMwFG93Q1O/8eanq/zWlycRwsSZJlHlYFUKV\n7FTNs7+wGA0n5JJWwqevAdhrZ84CTwhTqWiOilpOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgtB4fv6ociQSQmgolMnNbqMu\nTVUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPl2B4OS9rvr00/Sf9rdemAk/6ZRJtM6PzejQ9gJ7w7QAiBOf+DiCTbz\n9kmbw20Rv3VxSRilWhxQa3hTbbAEbTvcGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAezTkQEX6iBTik0cMC96ETlnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDMwODJjMmItOTQxMS00MjgwLTgwZGYtNDVhMTVkNmRhOGNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4Y2RlZmJkMS05OTQ4\nLTQ1N2YtOGRhOC1mMTBiN2RhMTRjM2EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQXMhodfGsYv077EWm6i/84YInGA6ySvTL+/Z+rnDvrQZD3bWDrwPX+MarZpE6C\nCOImlIptuwN93TEVovMnlFp2o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTaE0h8P+8euy0c\nYnt9MqfkKHLb/jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhANvOeuJzTQFZki7PVOfYVVWWR+RVD5XxbrPErjGpEGbn\nAiEA9OjLbjxhIMp7oa25EhrD4hs0537AgbQ1B2BXNuB5CRM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7934", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7934` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAZkZg/tuHy2X+1/T9ICAV/c2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YTNmZTllLTAwNzgtNGI4My04Nzk1LWQ1MDUwYjhmNmM4NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ1MDU0MGEtYWZi\nMy00OGM4LTg5MTQtYTBmNjdiYzUzYmUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFqBfB1Aui6v9/FabUNNpjh0naHmScdwB+9MSeCILP7KD5ZyLShXr49AjO177\nqPQdQwOgvVD8RRgNP988229zf6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr/54j/Mpy4B7awnsSWPgiKjwJ1wwHwYDVR0j\nBBgwFoAUSrS0RslhUY90tjz/xy7G867QiMIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCWvmzwMiBzu7Lm+akXNJlbNj5k2my0\n+ghBAi7/F5h5fAIhAKNW8rSSzLg6UHpfhsbHar1gR46hDw0nCBZpSyoBpbFU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQXYa2jfo14pIsZQMBS+UO0gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWEzZmU5ZS0wMDc4LTRiODMtODc5NS1kNTA1MGI4ZjZjODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZwaGMxYFhiEhau4i+WR0JCxqAIVcOoI5p4oRpoh3d3vE6\nbXw5Bqoy7s5Q5jzokxq+O2Dpx5hRGQjcb8GIpD+Ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSrS0RslhUY90tjz/xy7G867Q\niMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdF/R9srWR4tGjapriGG7d/lt58GxMPOHkjP6pObKWUwCIQDUldAWjjmj\nDcVYPvZuJoye9sGsLu91gdNqFNnfgmjtCg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAWYt4XzTWM1i9ZBAAjawXbynMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ1MDU0MGEtYWZiMy00OGM4LTg5MTQtYTBmNjdiYzUzYmUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwY2UzM2UyOS1jYjEy\nLTRjNDQtOGU2MS1mMDg4ODg1NDE5MzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS02+/wWuKyrbrQ+MUdXHwQi28YTh3Fvvl5qPBX7KXZOEP55XMIMdRQxRnlWrA5\np0gFl4irTcCH8CPECYKt2qbDo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSv/niP8ynLgHtr\nCexJY+CIqPAnXDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAKVjegPhCH3wezkwq4gJRGLB4e/uGuHbWzZ3xomHcfT9\nAiAQqocnvz93OA5ppvB3PtN47a4OYidUle+rIZ70YcAYdA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7935", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7935` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISASZ+l2k/qDiByOhjc1rmvTiUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyMDE3OGU2LWRhMjUtNGIyZS04MWY2LTljMWUwYjUwZGIyNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc2OTA4YjQtMmZi\nNS00MDE2LTlhZmQtOTY2MTE5YjBhMWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+QtQz7eEFXwHH6C5eoXG6LeQGRdq2MiHImbppSFdMFIdVcdn2eBlX92ogwwA\ng/1GRvN5DZ+4mif7FoJEpSiveaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCxpfOiIFXMnmI/NuILD2df31zNMwHwYDVR0j\nBBgwFoAUgu/HK8fSQr9zAbOKOX0RIkpe+5swSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCIBSRLXs0inIYWVAkUlu8AsWxepa2j\nccHMOe2wYg7QwwIhAPBK9M7r0rb85B/nTGmYxBrlyboROswOf2YpoeuFaxsa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf3U745+IZpoTxMoTFkqWC66MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjAxNzhlNi1kYTI1LTRiMmUtODFmNi05YzFlMGI1MGRiMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNX6ft7Pjr/47mlR/HIcxr5Z1czOPD9M3gFPkqJwoQbJI8\n0wBDPrQF04RGI5rrZOyXsxmT6ISsIKoOd3+AZu++o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgu/HK8fSQr9zAbOKOX0RIkpe\n+5swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANdJAyoGGqYn3Srbn/T0ai2XteHEdMMZRFemblOAiql7AiAU/eIjtnAD\n4zSevg54uJXIOXdcMT/hzDl3LgSQHdtBaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAWIhw6Ik0apgCztwdhD+tiLOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc2OTA4YjQtMmZiNS00MDE2LTlhZmQtOTY2MTE5YjBhMWI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjNTIwODNlMC0zZDQ3\nLTRkMmQtOTY0Zi03ZTZkZjhhNmQ4OWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASemRAa1JQqJjumZ6YSXUwtR0B8kNSLfEtRBf3ILDCy2W2tx51uqdqjUDqD4SKq\ndmKV4rSVsl+zw/raYy1GOpe0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQLGl86IgVcyeYj\n824gsPZ1/fXM0zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgPqMmQB79lhzhX8luxMmMwFR+R4GntKaqyOq0DkRYinkC\nIQDRa5/l2rKceXLRwXMOmpa2mHC7lPGfR0x02aYpS6V/Iw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7936", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7936` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAWpDV+EDzRtlraLp7Eyyel8NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMmE4MDliLTNmMDktNDFlMi04N2M0LTMxMTQxODlhZThmZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjUxNTEwMzYtNzhk\nMS00NDY4LTllNTctNjEyOTE4ZTE2Y2YyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbae3TRDAJWJlLnZgBcuQUykMFV5G2kHjTrzL3WeR3I2rocPYs9Z5QLA6NKHv\nc43mn0WsMsOiLlkaNLGkDStyUqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEdobGwppxWY+DXgiK+zJxhb3KJQwHwYDVR0j\nBBgwFoAUPSsWWBQ03RtevknJGZja5msNg8QwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCSYDz5iqia\nnnUf0iJeCvYPMiYgTmo7+3BVaNdsnvWegQIhAN8SbvTIzq5gXcesMUxLMJhMjqcT\n7oHIFbgwkUXZ/C1e\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd/qSItGRBYiqJ3+5Lmo38ZoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDJhODA5Yi0zZjA5LTQxZTItODdjNC0zMTE0MTg5YWU4ZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+6svwxbCaxvxsy1osvWsQcaFkqsYWOxVaNUbm7sx/E8Ac\nFrOiZ2C4bKCqsqqC54zu85fHipvYVHMc2ebap4OEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPSsWWBQ03RtevknJGZja5msN\ng8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMRAG7rfNePIHEGAlw8aUJw7dyA7mV6XYCd22hSsUaVGAiEAhgBjiM7O\nZDIWeRDoj8xzCwCvOpxoGtgJ6mcAsWKVczw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAauzD5u2X4DXDDyYZUoijjIiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjUxNTEwMzYtNzhkMS00NDY4LTllNTctNjEyOTE4ZTE2Y2YyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNWEyYzE3Zi00NjU3\nLTRhMDItOTkwZS1kMjY3MTQ4YjY4NmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARf/ZHTnzedjj0p4IRfQaaCL2Q1X+C7mcR9D8S7wWfv+QVuX47xWSQaMQSSN3Hy\nAKFY890CJ6P5kcGg2vtBXeL+o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQR2hsbCmnFZj4N\neCIr7MnGFvcolDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSQAwRgIhAMMxYpXIBZxGv48ejLLYNvIN7cQrHRXruff99j3ZBo5O\nAiEAzXVVH8e1P8s2iv6rJcvcwxMntIUuKnlLSgN9HEeU2o4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7937", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7937` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAUBctZC6ypQqzSaC7rr6AN9QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkZWNjNWE4LWE5NTUtNDc3Mi05NjhjLTBmNjA1NmFkM2ZhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgzYTE4MTMtNjY5\nMC00MGMzLWJkZjEtODQ5MTFiMTJmNWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsEeUX9x86fqnkAmjjfE2MnAEUYoSecsJRQnttTVG4Iu49ppkas7Rt5ew4sqD\nqMYlADqNXpDK7DtnPTuFlJETbKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkF45oKn1m7x80k5VvUcAY1KsxC8wHwYDVR0j\nBBgwFoAUFCkbqOZsiZc8PqdyMA7oX2z+QhkwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgPQJch2XTpg10DaQHoTtlM8Evk9CJJDV/m33qx6gLnvECIDX0pLi7sv7m\nd02JVLQaO+ZlylanxgdpYwyU+SR2ca1G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdDHON50j3bI/TI+9PC3i7MlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGVjYzVhOC1hOTU1LTQ3NzItOTY4Yy0wZjYwNTZhZDNmYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQ4bKxod54yqURy68L9R1C/iIjkL/7HcreJkLCovWJik8d\nLvxEaAYn1XHM6aJ2QmalyekibboWeZvUPaCmZwGFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFCkbqOZsiZc8PqdyMA7oX2z+\nQhkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAuUpy+9ukFVmYo7+UBg0H75sJlWvIiZRFMAZdKeJfwwCIA/esTa2ArDR\nOeFuZ2cSsVzUIYHaMiCgPSQjld6U+H5W\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAalImSlp/GO/iAr5q6t0LuIoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgzYTE4MTMtNjY5MC00MGMzLWJkZjEtODQ5MTFiMTJmNWI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYTA3NDc0Yi01MjI3\nLTQyOWItODgwYi00ZTExMTMyNjVmODAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATWkreT02JYZbt5O0qzgpTWD2EvFAf6ld3Cy2w+uq9uzuaRvruEnnWHy7u9qEMJ\nrn+QYYyfIoEYB/lb5x2Nz9w6o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSQXjmgqfWbvHzS\nTlW9RwBjUqzELzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgP1WoiR2BGEQe/0DecSLdJTIghtWTWbrVoOKXOrEFJKIC\nIQCzFtpIE0PEOeWL8px4laBXE2Jiz43CEiF/CHzj4Dmdkg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7938", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7938` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAZM4luo2GoelqAuKkLd4i6syMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExZDMxYmM5LTI0ZmUtNDhkOS05YzliLTZlNjQ1ZjJmYTc5NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RhMDRmYWMtZmE4\nMS00NjZlLThlYTEtMDVlMzFlMTM1ODJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGIpfSJKkJ7xgvt+DUDbVsYw8Bw2nt7BniOeDg7bu0Mm4Zmnd8I/mT5lPN7+2\nKTKqU8um9uZwJLKa7PXjdoz5kqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnsoGRa5wS1yzxFhENJLCZ8F5VnswHwYDVR0j\nBBgwFoAUuPqYhjc/DaTn0NTr1wtU4M27Y0kwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIi89am7NvF+VprgdD0CbLXsrRYbTto46OdcDwV+ApnZAiEAjKi+J0lL\nbgH2YmAAWpslU8HRHPE6hIc++XIRm+kpiBg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcghRsD7NYc/yM9uBcrpQk/QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWQzMWJjOS0yNGZlLTQ4ZDktOWM5Yi02ZTY0NWYyZmE3OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwKedJlBjfAdggdCXhsMhqoihJkmwFJSEEWQemA8omAJC7\nLr2ceGqA68Idc/Mca3cjzBzbCFoiYAVYM3uu57/Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuPqYhjc/DaTn0NTr1wtU4M27\nY0kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIB6nsqirW51Ih/VdjUbJao6wOJi5vVUbSUi1XovaWBYAiEAytSompwT\nd6Z37HDsL45bIeAiDTn1WZDDXYI+W9EZdd0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAYdwbUCNAQp085EeVMCxRBFdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RhMDRmYWMtZmE4MS00NjZlLThlYTEtMDVlMzFlMTM1ODJjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzYWI0MGVjOC04N2Rl\nLTQwZDctYjlmNy05NDcxZWVjZWY2ODAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATa0XoNngSIGpo+xLCQf9CedcFVcgJ3iaQkZ83UmlndWuw3wNbaPiDPHVR7HPSy\nl46dNWNRqWX7lnOpaKRVcsVNo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSeygZFrnBLXLPE\nWEQ0ksJnwXlWezAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgQyr+GThVMH/Buo4v79gm4JV8ZiGx81N8PRpQtsib4g8C\nIHPva786JVFNM3+mVXclhs0tzpblRk5KdHxEutzENu77\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7939", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7939` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAZP5faS6AkcSw62h9B7TILpHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MzhlNzI2LTRkNmItNGUzYy1hNTBhLWEzMzk5MTM2MDBkOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhjZWFiNzItYTU0\nMC00MjI1LWJhOTktMTFhOWQyYTY4ZDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzRb5v4m5LWXzlzVjdR26vBi9UaTfbH73phNaSHlUwbFq4NKxn5TdF1xZp5S4\nze+x0EMEtW/8n4n9p6HcwBJFtqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyCR16A2J6fGyVM8uT5idKFXak1EwHwYDVR0j\nBBgwFoAUjbGPIidf08WI3RSWEsYvuks4cWQwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIGBxk4pNc2j8NVzZuPklaKkSa/yxvCHaegOfUscj07yyAiBZ6SXCUIOJ\nSurFCv7j8e9EsnHvJ4ipX+E7vOYId2mV0w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdVxodlD1lfal1Ge+woFc1rWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzM4ZTcyNi00ZDZiLTRlM2MtYTUwYS1hMzM5OTEzNjAwZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATf4Y3NvvNfdvvQVZrQk3vy97GFpDaxXzkyMJri/TX9C+y2\nfN+osRABCUXkBD/i1tF9WOs0m31j5ud2KX4kbUd/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjbGPIidf08WI3RSWEsYvuks4\ncWQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALYzlo5XYDP4A+7Lrl5pDrzc8YGyv8oA/FKredI6jyz/AiAwXOomLY1x\n+s0v/fmhSf0kThplLTlZn1vSnTyX+ZY+1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdYKFNYn4NhXNZW9swhQY+m2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhjZWFiNzItYTU0MC00MjI1LWJhOTktMTFhOWQyYTY4ZDkyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyOWZlNWMwZS1hNDIx\nLTQ1MDAtOWY1NC0zOTc0NTJmMjdjZmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS1Nf77LdH1uUWdZv2AIu1HJAUvaYDl8EMJf6JivfWK7C+ysSBSVjQ/KFXrf/9O\n16OahxznaFXRgSV6hFS2fAQSo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIJHXoDYnp8bJU\nzy5PmJ0oVdqTUTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhANXRC7orSXQ7QUoldfixd477pf8V0ISdKHgijxmDFsfP\nAiBzrj8zEpkN1Fm/4z4rfP/kZgAFp8H6HPsC6N5TnMFsyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7940", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7940` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAT8GJLEn0aIRGMYAVF99CyRgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3ZGM3MzQ5LTY1MmQtNDdmZC1hOWUzLWFhNDA2ZjdiYTdjOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdlOGQxZWQtMTkw\nNC00ZTUwLTgxNGQtMzk5MDEzNjMyNDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH4mQTg0ZlrU284L4aWJ/T6LFZNBimdYf/k2qnSGaPlKrBCfWc6XZtd0M3HI9\nk3XHgCktASBp9WpHH55S/ZG64qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKGWBdtcxQUFc0WbqqKola9aZY00wHwYDVR0j\nBBgwFoAU8vZEbIE/KHBIVy2LRAICMitw8fgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEsoFOzyWW1EgQzgQJncMXm9Nix2htfbMMKVk/Qv\nI8oZAiAAu7WWx8PX7gMkYmJce7KPFheBlg10jWsZrY5HkkSb6g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS7WkzESZ8/oCathFqb9ZKpcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nN2RjNzM0OS02NTJkLTQ3ZmQtYTllMy1hYTQwNmY3YmE3YzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXZFqPnGuimF6b06Oz39XwhI3nSps0eFdwcLrLxFEjvUK4\nhZ2CNhX3PPhnvS0Esyw7A3/EpyAOstm3bn0VDAl/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8vZEbIE/KHBIVy2LRAICMitw\n8fgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALsrORDvsgn8StwJbwdLuitu7tkNBhIw7zooc9+hnrN8AiEA/HfJsIyw\nH4jZPK3ZHBvgz9ZNr75OoDA1VIYR9CeMSyk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAfDhyvvfnrtMBn+xBEq9EPHwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdlOGQxZWQtMTkwNC00ZTUwLTgxNGQtMzk5MDEzNjMyNDRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNjM0ZWU4ZS02NGJh\nLTQxMjAtOGQ2Zi03ZjYyZTUwZGVjZWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQgStDWVQEnehARzgzJ/IJIg86Qy8jvvH84akNyI+Qiu7aO1LHINMX1U8UcTTIB\nlunA6ISroTEXaAIiGL6A5Xkho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQoZYF21zFBQVzR\nZuqoqiVr1pljTTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDRwAwRAIgJR7IXcqMeCBYiC7rjKxfb0FYBJ0nBUjYof4Zxmget0cC\nIHBOC9OQzjd91uwh2qpahyRlEiwsle5VPWbdykOnb0PT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7941", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7941` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAXttuMydnSo5GwiUXarwA6vDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiNGU5MDk3LTg5MmUtNDA0Yy05YWEwLTllNDM2ZTMyYjQ1YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU1ZWU5NTgtNmE0\nNy00NDU3LWJkNWItZTE2Y2ZiNmE1ZTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP/FyQF3zowZNFkXLAhPNlnXSdBuL5tQhdE0cV5iVakMBtYKz6KG+/eQUMAVF\n9HzYYl0p/HJjagdBDHg9lV03+qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsqj3+JIRy8cV/oAG2ZtIpabOt3EwHwYDVR0j\nBBgwFoAUbRdc3ePbNHr0Qksb+uWSvBAwY04wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDODsAGOGEjg2w7wb7oJaTKfyV1cPuqClYP50LX\nmLV1QQIhAJqMMD6KsaNt9dk5sDu2PWjc1h1l5z5kpbn1f4g4B8dm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYC7ni8yJBKOaUe+wGhr4kGuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjRlOTA5Ny04OTJlLTQwNGMtOWFhMC05ZTQzNmUzMmI0NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT854LpQ5cgd0I1FGk7RXg7UB5Btu5PCB6QrloCVDNLKiRS\nOOqi0KEHFWl3gwaW7yo5i0CvgtKW6qMc/cseOgwno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbRdc3ePbNHr0Qksb+uWSvBAw\nY04wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ/3RbcgPniEK2xgrLNcwTE43NlQc7tiwBYLwQyi2+AQAiEA9oMmgpXw\nmOPW4RMGGRaBOK4/giGl9RYCSs6iTrz4Tro=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXMDr8HKY1Ji4PTrMz52/TnyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU1ZWU5NTgtNmE0Ny00NDU3LWJkNWItZTE2Y2ZiNmE1ZTM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4NGJkMDA2ZC1iY2Uy\nLTQ2MDEtYmE2MC0xZGI2YjAzM2M0MzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR7632eFdpp+kliWHWGAnaLp9SRA4CWImN4Kgure1+hGYlHGGlLL34wVINTY3/M\nfv4kup1aH7LtC3xXZqNXyocOo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSyqPf4khHLxxX+\ngAbZm0ilps63cTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhANcl7m4NLmqLlqHEWdURkf0hsSxUSI6B3WlEmmyungkB\nAiAj4GzaZngaPrfqENF3xO3/94//DkGKSMlHH9vY0TyKMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7942", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7942` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAchnLDPaNizpT4Kd8ALipYuHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNTlkN2EyLTk5MmYtNDNhMC1iMzM3LTcxOTlkZjllNmE3YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDdkZmIxY2MtMDY1\nOS00NmU0LWExNDktZmFmN2VkNzE0ZjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHIKi1JZW4Pk7TTBK7nlloUDzuMRMnmVhA0QqLlhk3XkIzVSVyXxQ2sbrnmHl\nVYF+FCQAEj9vMyvvHysgjD7OO6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGepofFNoU+cmrlATM4rAcw6KcwYwHwYDVR0j\nBBgwFoAU73Z7C+N7/ge6yY5M3KFWSs/FYfowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCHED/y3MStJPUWE3px1tWqtvrabdYFsVV0Bbap1DQsKwIh\nAJnhP8+1dMkKUC7meLljCNhjOPMRUoY932BzF+UTRD8R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa1W+t74/OnfinlDAmCv2DWmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzU5ZDdhMi05OTJmLTQzYTAtYjMzNy03MTk5ZGY5ZTZhN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATYZeUvbZx1kkDz9O2DIB3pddpdmNXV8EhwyMXggcClR1Yf\n4ZWig/v4D4hVp7kL6zxBlWZINcEXbLG5XfaJlQ8zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU73Z7C+N7/ge6yY5M3KFWSs/F\nYfowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYqFf33Bh96hEcTR4R3LsRQDqth8F6XSTPbKK0dzJ+dECIQDBIHKMt1dW\nqk6HrsXmFmSbUVUAlefXUXwRTFE6ukyUGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVOq0Ysmg8WcDdcMO1Vcl97fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDdkZmIxY2MtMDY1OS00NmU0LWExNDktZmFmN2VkNzE0ZjUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NGZkNzYzZS01MWFl\nLTRjMjUtOGM0Yi0yOGRjYWM1ZjFjYTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARy0MW9a18lH+5dZ2lhiJPuVqf/8pWAY8vwR8aiISoTYRueQB+wwKb1Gd8M/pvl\nxj53qmGxQwfjxzTgenjVGTT0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQZ6mh8U2hT5yau\nUBMzisBzDopzBjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIgb4R30M+lCyBth0u1pdVnrX+5ajXBQ/af2YbQqrdFMWIC\nIQDNkr1Wy091ffQrhKT5mrO1+68ljyBa8hRqwGy8GaLePw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7943", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7943` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbOKNkY9trtPeyO4DX9OoxRCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5NDA5ZWQyLTFkZGYtNDc3OC1iNGEzLTU2YWFiNTBhZGY1NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM5NGFkOTctOTQy\nMi00MDNmLWEwYjctYjFmMDIzMDc2NmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs36zjgxbT9L6s2iocrK6eni1xXnfItIPpABa9WG2cWr/BEIicBazutbdJsA0\naBtI2IQ4ClQ0pIRvsXtwIdyrQqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL1Z5WAOv2L8bO5eI+wyIxGXvwp8wHwYDVR0j\nBBgwFoAUH2T0P80OWdDBYMdPjGvxytXxsGUwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIFZhj57R9Yzybl1202UOyH3bR1ZvLBV4\neYgI6lAT8K9bAiEAnDNw12om7Yg9eIQl91ODHxXT38/HkxByVP3cs5GgM3Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfWWi3uYWcFQQmgqDpG6PEeCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTQwOWVkMi0xZGRmLTQ3NzgtYjRhMy01NmFhYjUwYWRmNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsLwCi7oePPCg88ebEgiu9kAVrM4yCagZ7AdAPlaikLJn6\nmJcWwE4DwIl34R1SODU0KeyAka5/174FNLJrjCdWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH2T0P80OWdDBYMdPjGvxytXx\nsGUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJLjqbjhHM81DIXHqtdpLTPAGretwbxgPPq2zxv7phcXAiBN5LnnkbEW\nQpHoz+rRhzspXvGamkYHEYUhiM0syvBIag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQLcAr1gVax4wc6BAhs6m+ouMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM5NGFkOTctOTQyMi00MDNmLWEwYjctYjFmMDIzMDc2NmEyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4MGJlNDU0MS1mMDFi\nLTQxYzgtOTg1YS0wY2UxYWZjZmRmYTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARUHS9YOdBHY9khjDcxdgkSk3FaX9bpucrJgcpC1iv6Brip5IlfIOGqhZY9YIN5\nI95EKoaBBNoPvMSM8eU/16two3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQvVnlYA6/Yvxs7\nl4j7DIjEZe/CnzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAOJ8GisiPhxqO4VKJZU1xn62aSTizver4tepPVkGgoiJ\nAiBV20g11EGS6u+jZBFuzmyFjbpRB9DhEMjxf3XTm5VzeQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7944", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7944` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISATjt9Us6wMYeSbw1+gYChDyKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3YjQ5MGMxLWQ5YzUtNDhmOS1hNzNiLWVkNWViNmE0MGZhZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg0YTUxOWItY2M2\nNy00NzU5LWI5OGEtZTc0MjdkNTQxZGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzdv+NVbW6fg4Y5BYaWCkAUCLqLHUBWKAetJK274LTVrH82kiXkkTKM/XJi0N\nAjiV/PKBiuHOZAMLxjCppyf9GaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCXaX5fMl9UPFuC1ZpGsvidfY5QIwHwYDVR0j\nBBgwFoAUOjiHuycsDTq2X7FmgWzOVYTq9eAwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIGrgqIi2qi1+1VxJf3OhXDQClz6QBZkr\n8qy7XTujc7uLAiBiBC3QBYEJ92arA/X62iy+8MKQrSftRX1R35YOxtycog==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbtvN9PCGrtuYi+6+AKVLbviMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2I0OTBjMS1kOWM1LTQ4ZjktYTczYi1lZDVlYjZhNDBmYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4NVIgbQZqrdKMoCtVSX9Q1WJi7Mqrwc2TyX9T0EgLJUT/\nJlXQMiXxmi6WZyWJUFXpKugByFrZ1NcerwBNKCEMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOjiHuycsDTq2X7FmgWzOVYTq\n9eAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLsgDb9TQ2htuJAJo0g/wsbZIbYX/6tY1jqJ4bX1tRYkCIQDZ69t17ecX\nJ2QgtQaRzeLNk9nMQYiPulu4PYaD3wgX8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbWmS6ubbwAUKTlz+kNtaypgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg0YTUxOWItY2M2Ny00NzU5LWI5OGEtZTc0MjdkNTQxZGEwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1MTM0NjMzNy0yODQ3\nLTQxMjgtYTNhNC0xNWFlYWI2ZDhhZTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS93T5ftGxQiKyLEtVOi/04rvf0HBDa95bUKSSUgumidt61+Sowx+lMAQgQC0gw\n6zifboMCPE9Xt1VQ5EEwCS39o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQJdpfl8yX1Q8W4\nLVmkay+J19jlAjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBH8AAAEwCgYI\nKoZIzj0EAwIDSAAwRQIhAICZKJFvmj6KAdgae5ITrs64TfhzMJVcd2/p+eyd1Vp9\nAiAZE1275U0Xz2YzegBwGMBbmC2FyOKYLOhqj/azeT57SA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7945", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7945` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAQdwjNw2s0DL58PweHVbywvUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyYWZiZWYxLTI3NWUtNDBlZi04NzI1LTE2ZmFkNDIwNjk2ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzliY2I5ZTMtNzUz\nNy00MjgxLTk4NGYtN2Q2ZTRkOGFkMjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiA+i01hxrCW8Atg39t5r/d9Ammf4YeYM7dwxcgYoSJlnt8E83apGfz/eJCix\nfFF7c5D4yEsyXmkm1XWaMG8joaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFG6afMmXj8kiPMRN74AExT2pgmDUMB8GA1UdIwQY\nMBaAFIQTIFXYnba0MnXRitgrWWyzDMuDMAoGCCqGSM49BAMCA0cAMEQCIB+EjbcJ\nU3440cEqJZNMDXdIYBPoz/VHc5A+Z6QOLYy0AiBgOIdMdu6tOB1nbRrk5Hlj1syn\nZHSO/+EOt41BfTsLUg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd2oURA6ik8j1djPxGTHaTooMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmFmYmVmMS0yNzVlLTQwZWYtODcyNS0xNmZhZDQyMDY5NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6loDMXG5Ypce56UUdqkNeT1yfHfmj4QDRPypmC2J91xDP\n0KsJxKLfdGgfpK0AdMzOJBOotiaC7EdjjnXsprwHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhBMgVdidtrQyddGK2CtZbLMM\ny4MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPj596iifd4hVYucUWpw2avv2qygNLxiOCl2jPXG0LlpAiEAqeKQP/Iy\nOL5Xz/TSkSHpi+iYovp9tuOxrqRyToRTzTM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAVa0pRJK9lmJtECigwmanl43MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzliY2I5ZTMtNzUzNy00MjgxLTk4NGYtN2Q2ZTRkOGFkMjlmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiN2Q2Zjg0Yy0xNGFm\nLTQyYmEtYTY5MS0yNjVjNGJjYzg3ZWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQxggcxU+3uvi7LwTsPqGfECfmQTrz+i65R98KCeO7re8dL9YxAUGLKJlVMBjka\n3ldh/4BlfOSTaTuKYCxKtmKUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRumnzJl4/JIjzE\nTe+ABMU9qYJg1DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgS50ceL4PxJ5VgU5hrkrROO9Zx4KrhK58KcOI0e6H04UC\nIGWFCyGJaXcp3oYDoly5wBhgqYYbvVtUhoaRSD3FwxnM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7946", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7946` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAQGYpEHNol3HQxHjccYwYES4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1ZWZhYTZkLWZlZTgtNDU2OC1iNDcwLWMxZmY0Mjg5ZGUxYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzIwZjZlYjgtZDdh\nOC00N2Q2LWEwZWItOGE1YThhOTcwMjVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV/HqhSa1Twb273vt5gZh3w1798Gwlwj5Csaicm5hNCqCDwKevO9YnWMYpP9H\nNlWZJ8Nc66oWeKyjdlqRrYZgM6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEdXOhnXsdz6RyS/eZHG1Imt1HE3MB8GA1UdIwQY\nMBaAFIxytXlmCG9tN4jRBWntN7/d/uEWMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAxMPK01Rvz8PXY+8LabdHvQqURF6JSDBf6\n7dNK6PZhuQIgMpUhkga5+G7jhTrWMGZi1GYHs5d6PbeFfC80Cwxx230=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdh73VdyoyzVDCX6CHedj55NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWVmYWE2ZC1mZWU4LTQ1NjgtYjQ3MC1jMWZmNDI4OWRlMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASolpKU1k3Lv3efcVhwTzVm/NOK8U9ka5PwX5Af9cB2tiuN\no8Mk8Ma0kIVgm1itB+U63eMT8WDwpQsJNtoy+0Sdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjHK1eWYIb203iNEFae03v93+\n4RYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYvSckAKphXJ0TA72mE2dDXLeyZJh5JsZGw19BtGqvRICIQDELIAE02rA\nwLZKW+UffoN4pM4pkoi5vI1evAQRXxwnkg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAemGTSxjcPmS6sn0wEZqXzD4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzIwZjZlYjgtZDdhOC00N2Q2LWEwZWItOGE1YThhOTcwMjVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZGQxNDVhNy05N2Y2\nLTRkMGQtYTkyMi05ZWRjZTk1NDExMGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS/LKKxQ1CCGAZqLrcvkGrAVepJcV6nmMe8ZinECxyuiGyq4koqUYkRQaHNfJ8s\nPtw/KKvUbgoL2mcrrJ7aNPJio3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRHVzoZ17Hc+kck\nv3mRxtSJrdRxNzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgXhP1QjIUyiYcBZv7iZEDJ5FriMlB1xmmJNaJ8AaqWeMC\nIQCo4QE1LmeB9vlSSJ9CORPoi53CzaqtZ4bT7KcyFwT5+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7947", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7947` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXgY7764TC4FJsbb4DC+O/AZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxOGMxMDE4LWM5NDEtNGJjYS05N2ZhLTQwYWIzYzVlYWVjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjBlODE1NjItYWEz\nOS00ZGI3LWFhNWMtZmM3Mjg2NjdkY2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEksR7pPICczSGlGwZ2i+c+D8QEo0KcKqcgo41zemyFKTfFQZ3hAw0YaT7VTKZ\nlUDCbXhLReRh9kZXWrV1b3LCq6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCIlsHqbfXJCR4B58wW1ZCMd+06AMB8GA1UdIwQY\nMBaAFAhwYDN/vmz+8GVvdZFBXGq6LLdiMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA8HO9pTplYmCYY9Hwq7/q61XkarVg9WHt\nBdY9odtbpaUCIEWkxqIYowD8I7Jy9zuTusAHzipnZjUDWuX3l/YiIdkM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeLdouNf15VQUpqq3Gey8KB1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMThjMTAxOC1jOTQxLTRiY2EtOTdmYS00MGFiM2M1ZWFlYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLQzVbaF3HgxH5oWikPEytVWHSw37uVR2cT4Yem+T6bnYe\nXZkNp6rD1i0ijAlNjl+ruHHajDwc5oVubqo6nqMco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCHBgM3++bP7wZW91kUFcaros\nt2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKJ0JC1dtDp24rSz/eeTDPYnqGbX0JMIjWcOFswMBAyoCIQC7VlWbaw2F\nsbgpuLz10YF0nXkNW9RVGbpRDXJfzbghBw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAc4sDf56OHM7e/SkuAl2UeWXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjBlODE1NjItYWEzOS00ZGI3LWFhNWMtZmM3Mjg2NjdkY2I0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5MDdlM2Y4Yi00OThj\nLTQ1M2ItODcyNi0yZjEzZjgzMjQ4YzYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARFAaWfG+QOQ62DVA9QNxRnU2hQG3LMk67fRWxOBxPQh011VkDktlXOta94HIjP\nU6lbo3SvgUC/VWX/hPB20YmCo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQiJbB6m31yQkeA\nefMFtWQjHftOgDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgSHHFg77BiTOc3j4P6zdykICYGWaeaQdB+QEsThxObOgC\nIDC/JS/GMw2U1ErTPYyywLk3KroMdoCIQmmosFD8amPY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7948", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7948` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAfF7OO87SdeUZgLwnqeEn+ZfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhNDQ5OTY4LThiOGQtNGM0OC1hNzgzLWU2ZDQyZDY1YTEzYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZkNWIwNDktNTMw\nZS00YTVlLWI0MTUtZWVlYmJlM2I0MjYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHDlPBf1fBkioZqAyFaY0PiJIERVqnPlfx3E8gdZqYrUhmv+xb9YMn1UU3YIx\nY33CiYWqeuuz5rEZ+fmeWwyTh6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR2yJ/QrCny3oNGkOoAxbXDmZMffzAfBgNVHSME\nGDAWgBQ2qEx8pDWlntRgIFC3czLjWGByXzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAP6ZWLr+Px6Vt5Cf7eQmt+sl3MhzN/P\nearl1cPqf7ilAiEA/nJOQIisM4o59RZQs5NScmJvCubN6AlW5kwv1L7pwt0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd5E2JGYr1AZSmQIsHs/u0utMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTQ0OTk2OC04YjhkLTRjNDgtYTc4My1lNmQ0MmQ2NWExM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAzeDcq1xpNTaiyxde+BH37Vw6frHDASH1ACrN81j8z4Sp\nY5Y5oVm69ztZrdHY1xGCqOe8eOH7rXuVT1zmq+AXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNqhMfKQ1pZ7UYCBQt3My41hg\ncl8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEMDU1SspYQeSbUp4jE0DUnaLnTGsgJp6HCEgo5vJXYcCICYmCVsf1xDe\nAtoYKQB/EEhFrp8c2cVQOu5in98X6f4g\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQPs6G4vUXEC1yNWSuwNrDanMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZkNWIwNDktNTMwZS00YTVlLWI0MTUtZWVlYmJlM2I0MjYxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMGIwNWI4My1lMmIw\nLTRjOTktOGQzYi1jOWE3OTg0YzQwYTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATvQEKWzS0ovbbek2bWs2aDhTfODT8YTq064QqDi/89jAqKMFlBzLtlOhnn3mBL\nq7qr3GmLR3IOjnU3E6SQPE+Vo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR2yJ/QrCny3oNG\nkOoAxbXDmZMffzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAPDVwGEnrAC8oY3n7WeoW9IgFNRChlrTrplc3NZCGitM\nAiARYMXLLK4+CY9Jm2lemopccdYtkVOFsDuvLaU+t3SzFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7949", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7949` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAQRr+2MEyPaS2bndaxswrlhvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4ODYwYTA2LTlkMGQtNGI0MC1iNGNhLTEwYzAxYTc0ZjRkZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBmNjFmNTEtYjEw\nMS00NjJhLWIyZGItMjRjNWJmNTM0NWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1KTdo35U6Ube66K7iS/sNqqSkZFazvgg1U/QLs5bsPKcOulnDstQRGLNJsZX\ngbZSe80KjQ+z8FQLEcHgBlYbVqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0JGgu5LlkqtpfAnEOvhhUdYJeeAwHwYDVR0j\nBBgwFoAUGRzL5iv3MGUpHSzG1o8UAo6Fo5EwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBDAUvQvjDeWmZB\noB9n//NcjL/5Xc/196qqeOPTm/eLAAIhAPcJ38zVW5YagsbxSYLXZhmmGQmKn9UA\nqlF2gfZcXnvJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfwE6cvHmVLPFpdPAXyFCnvhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODg2MGEwNi05ZDBkLTRiNDAtYjRjYS0xMGMwMWE3NGY0ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGIPMnRZ4v8JOC1+HENqG3tIsG4OteUQv1+t02+uOuSwVy\ngeH6tomA5io3vZ7qxxMzCUhmZTx2aNvtE0P1Yt8Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGRzL5iv3MGUpHSzG1o8UAo6F\no5EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI2S04WTBoxxR44vvyEyPOuiq66yWkL59a7eTzq7GYkzAiEAipy8Lzqh\nEWPUhPpLg6TUbW2+l0MtwhYpC0RBf7lMURQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAQ6MnqbEhbNB7uC3ifqdIDBSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBmNjFmNTEtYjEwMS00NjJhLWIyZGItMjRjNWJmNTM0NWVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ODAxZjVhMy05OTky\nLTQ2NmQtOTE0Ni04N2RjZTk2OTcyY2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR8nWpQ82xXDaE6KFgIaBU3PD6Qsu8i6CSpRUJKEq7PiZoecnQvwFreWcBMd2v6\nyFP8+xuvAP4DRW3Zq3IUzSoro3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTQkaC7kuWSq2l8\nCcQ6+GFR1gl54DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhALKZI4YRp5hiDa3smLQa1f4uN4M5Kb2HRr6OY824ffPQ\nAiEAiX6n7JlvAeJQR63oQtXaOGiEaCD3qxp0KpeQS3Q2zOE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7950", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7950` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAcXOIfvwJhqNUhxVK41acqTaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlZjJlODZhLWM3Y2YtNDlmZi05ODkzLWQ3OGM4YjQ1NmVjMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAwY2NkMTgtMmQw\nNC00MjQzLTgxZWMtODM0YmZiMWJlN2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMSxVbD0BfyHXLyHE/BOAcPOr1b2a1cxZR3DoAP1BiFij//7gcCNRM9H3znaD\nCGI+26p3Qg/cQHOiWMBUHqFwgKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZAH0ghTrTu9LqPzYhpOZSKfJO7MwHwYDVR0j\nBBgwFoAUORNWmq4tY7bHw3z5ndcxrJAYXrwwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEArbaJuXlbB69y\nI1ba+LCwrq2O4mDVodTqrIu2XNKM33ICIQD/hEaB+PI0mqPTRow16v4aSNZHOy3O\nSM4Km6TQpDbAzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeNP1pp+oQSrP7G+IfPIQE1gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZWYyZTg2YS1jN2NmLTQ5ZmYtOTg5My1kNzhjOGI0NTZlYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9Rayfmg7h1JveR0uCpv8KFJ5XE7s/aelmSoQhUawpUtTc\njWzV3a6ElKsHe/byX4t/xJilW7EShDrX+zs+8isAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUORNWmq4tY7bHw3z5ndcxrJAY\nXrwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIXreDHqjQUIGVPp5xW0JKnMnK+HADoJJG+xEAhDCuVuAiBzI5r+P2RR\nKqU7pl+kwI2wL/IKYgsXxLvSopai3lsCEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISASI3EVJsOLXzerY0huhmmDR9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAwY2NkMTgtMmQwNC00MjQzLTgxZWMtODM0YmZiMWJlN2Y5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmNTU2ZjcwNy02YjBj\nLTRjYWEtYjYyMi1lODlmMmM3NTVlZmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATS9ln6mow0PurJhREpNy1TjefKRQG/S2bVzTP33dkm3RAAdLdvF72ML1F6M5cP\ne1sFb3DazCRs+Xi9qr1QWXcLo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRkAfSCFOtO70uo\n/NiGk5lIp8k7szAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAOKFBiAUn/gweY030z/fjXkzA/DNoN8rt6y3bXuirQtu\nAiEAtiSBpBXyflyr/EuGhI/KOvW1wjc08jrssxRyq/TPcjI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7951", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7951` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAawpumoJluaXCH5RPUa416gqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjOTZjYjY0LTQ1NWItNDE3Yi1hZGNlLTRjMzRhOGE2NzdmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRiOGY5OWMtNmU3\nZi00YzdhLWE3NjEtM2IyODViY2ZhMTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzE2vdYS8h3Kpk4xMJWYf5tM0ofMyED+Wregil1zXxF9IoVt4owAFTm1qf7IE\nGlvWrA8x+BH7A/qfvtD/GOHGh6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDehgmSlCQF7qzEwJ135NL2Ll8TcwHwYDVR0j\nBBgwFoAUYloh9O6d+jlMh9hwxwNEn3uka0cwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiAQcTwgL0V1mfcM7VWQpztu\nQknNl5w1j50MpnNJo/A3fAIgG49MgRamMN8mogEKP60FH1vA3HZEub6hL7oFOQ0k\n2Ss=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf8OawEM4mDBgoWzJbSEcXgLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzk2Y2I2NC00NTViLTQxN2ItYWRjZS00YzM0YThhNjc3ZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkTFNDg6qiEzEeYRZcsxZRw/UJw5QHFuH4SoHtKna/yTFx\nuknON/jj7GKo/+a/8JM4teZDkS0OmBDhVUIpdInho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYloh9O6d+jlMh9hwxwNEn3uk\na0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUWWK5KM/wEZLRzz1rxfhNMFh88pbE7tEvAaKvMIOrUYCIF2+jCJibmoB\nPGpfFnl+/HeYFTnYOA23oXhlVH4Kr9aR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAU/j65yumnWbJzw9k+9u45jdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRiOGY5OWMtNmU3Zi00YzdhLWE3NjEtM2IyODViY2ZhMTIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMGQ0M2QxNy04M2Jm\nLTQ2OTUtOGIyNy0yOWJhMjFlODA0MzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASV5Lx5L3YSMkoZcBAXZ9Dh06Z9ud4gpDCDvP/TBukFeo9gNA1k0nEAeqKJiIkO\nECzl5g7DAmnX8+cQHZvci7too3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQN6GCZKUJAXurM\nTAnXfk0vYuXxNzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJN+5SGXYu8Tcx6C+Hc2bld1/KJvWk+ltbSSq2U2k2kr\nAiAhGqz+2WJpwaYb0wVdB5jy2rrx1xVUemVHHuU/rrx8Bw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7952", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7952` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAf0+XoFfWrpFO2Y5oNJ6bjuLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MDQzYmUyLTM4M2QtNGEwOC1hZGZhLTM0NjFjZGZlODg4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBhOWUzYTUtNmFk\nYS00OTFmLWE0YWItNzNkODVmZTQxZjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECKy5sKdT3L9cpUOqUY5IJryTky0TBXUI4I974GGPAXwimqwC5lIq4bE+6D1u\nMWmWm5BqvV8LNCijiafPZzx1CqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCoIzvX+YhNj6sjJH8+8oOIXFbyMwHwYDVR0j\nBBgwFoAU1qghvx/XDEsTYHqobtMVYqsLLfwwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEArkxX\n7vzNWZ6AFcZCO8zlf6KvHJOIfkneelH0dFYnQNYCIAk5mOylJDDAcnpsfc36jNNA\nROtENRwP/6kiURvuRlAs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcO/JayiP8ur1HXOQDE932NQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODA0M2JlMi0zODNkLTRhMDgtYWRmYS0zNDYxY2RmZTg4ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/NX0/1tSZLuGDCBzKxgGFe7a/9zu/3l2Y/gdAHil3C6Qg\nQaRLMq2AGS8Qe6A3RMEMFZhPQdyBtzXP2TVyMtWIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1qghvx/XDEsTYHqobtMVYqsL\nLfwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMMSCTzhBwTXZlCl/9VN4JZrFtjzc8Wxct6pJRBz0KWbAiBftwztX3YG\nDHS26kEIExYvzI3ymTLkETJBHAlUs3zQow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAffyygxzIdzc9+FiAPPM4BSoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBhOWUzYTUtNmFkYS00OTFmLWE0YWItNzNkODVmZTQxZjYwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiODNlMTZiNy1iZmNj\nLTQyMzYtOWNiZi01MzU4YWRiM2EyOTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ+45qzT/5jtJ/eBhJgnJRNGKcous89vsZYSP5VxV5oCWVBVW94t20F05V6DiOH\nl18Dar3BksbGSfGfnxmhhKeUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQKgjO9f5iE2Pqy\nMkfz7yg4hcVvIzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAOKBWNPM+Ss3Ye6aju07yXSx+Tuxw5tYlX1Q5MksVGY1\nAiBcPbjHhZd4/2tWjKYEJIFbbrEICL15z0llZJ2kYq4VvA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7953", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7953` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAQSwdzl7G+d3p1E03peKEHzGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwNTg1OGYwLWFjYzItNDU1Yi05ZTVhLTI2ODU4OTBlNWZjYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlmNTEwNzAtYWE1\nZi00M2FjLTliOGQtNDYzYjMzMDZiNGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw5kKIBm35o5BS4kJehR5pVUUNaZ6Ak01sRCnGHKLdNQcxNffss1pyAd7qHWt\nJeU84FQ5/FS48t4Hcc1bYO9rJKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMu37JBM1W6fgodLOaCJAp2Cd6QUwHwYDVR0j\nBBgwFoAU8+uWkT+33yhWc2PUIjxSB6ucsZMwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAT9mc1\nb0DYtPKRU1OZ1+wuTSXsQSlTSeKGghkWzW0+PgIhAKVA6w8gUX+7uGtZq0NqGrS1\nWVu3C1Uie8UGqIB0RZwV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVxjTKD3xJlCOUjXlOYB1CmTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDU4NThmMC1hY2MyLTQ1NWItOWU1YS0yNjg1ODkwZTVmY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6c2UEZgdb6vkTAqFsiqbM9/5YK2Lls9HgYOPsJCk3Y7dH\n6Q8oQMbnXjB5LRN62wpOicxmBHyrsCH3BkzxH3fUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8+uWkT+33yhWc2PUIjxSB6uc\nsZMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG8X6b2WBL9+z7+xwuxEN/o92l35+gEFmInuXX8C2RaQCIQCOZehfxpyB\nHZiZ3kvuuzYjx20mVqLbzWKIEKIh3jG9UA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAWf0ehQ11J2LgHDyXxhbCjlbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlmNTEwNzAtYWE1Zi00M2FjLTliOGQtNDYzYjMzMDZiNGQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZjhiODI4NC01MDll\nLTRmMjgtOWZlOS0xZDAyYzgyZDFiNTQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASyjUa0/3zcBw7xNm+I4cmh+rnn5BbMgRm4c0lBnJuM3JmLNzlCQ0HfJAMoFYIx\nfsf8xaMoegHdt8iEG0BiRszHo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQy7fskEzVbp+Ch\n0s5oIkCnYJ3pBTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhANWb94HxeBEr6IAqiQFkvXfOntB8kzANAjWJdXA0Vav/\nAiBGT0BVVWQg0U5Peev1enVKea9vBlGMZ0s47MjI8wPXQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7954", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7954` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAa4qRAbNKqUBhoqXuTXkr6k/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhYmQwMWIzLWEzMTAtNGFjZC1hZjEyLWE1MWJkODAwZGQ4MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRiMjU5NGYtZDgw\nNy00YjliLWJiNjEtYzhmZjIxMWU1NWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiG3zq5al3Py2Dagm8siSdfMyMWfXjVMi2lrZkCrStHIR89rxpH5mmxawG7nP\nAMqOCo+bO9km5sZmU2H4DnyVeaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN1+Jeig4Ijm05w0G2KvkaiF4WGGMB8GA1UdIwQY\nMBaAFAFrJOl1/7UM1kcEjacocm9xpuMHMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAuXbkRCR8VzKFLLV6tdhCVPJn0k6CW8sb\nWkRp1e7D6wgCIQCK1aqrK4SF9ww4V+Aocggfmp3GMnlcAnBcxsPmh+29eQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfExX62Y6y6n/yBMtGi6o9fKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWJkMDFiMy1hMzEwLTRhY2QtYWYxMi1hNTFiZDgwMGRkODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZV02xUPVTjOf97gqtfZ7l86ljJ1vcL9EPIi1/5HMOPzxN\nox+lFITW7vQhfITLjeJYGOHqz0FMIYAtwTGAU3uko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAWsk6XX/tQzWRwSNpyhyb3Gm\n4wcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPDKb3nVx2vrwg38AgMDEQ1U3IIcFwp4K9G93C2Rjs1ACIQDg9TkrblbT\nCVRPqLDA8Soe5FyvbCEwxhOip/AicQQgPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAZNvR4eCaW5AqIitHDXPMLsbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRiMjU5NGYtZDgwNy00YjliLWJiNjEtYzhmZjIxMWU1NWNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwZTE2Y2EyYS1jYmNm\nLTRmOTgtYWJmOC0xOTM2MjQ2NTlkODkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQwF4RY/mYWulp+q8E6dCydJ82K4sNQUFuV+4UlQcCCKu4V+jN81mm3fLg4FMRg\nuwrDLLiePtyd3hgMbp11lEwAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTdfiXooOCI5tOc\nNBtir5GoheFhhjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgYptcGlXn7Qv8F5w6M5FX83wfAAhklSnBdsuNYygXfp4C\nICMrMb8qB1ErnSxsRKhKa1q+39l3S7sPP3NXQCPq6qzO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7955", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7955` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAYmo5k8WLPxKMH28YzbntIWeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2ODI3MjhiLTUwOWYtNGYyNy1hNzcyLWFkZDgwMmMyZGI4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA0NGJhZDMtOTJj\nNC00NmVhLWJkOTctOTQ5ZTY4ZjgzNjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE27VJBTaGdjQaQJugjiyoAK9qNJbfPwMlAOADngPKEqC4ijzbVFHW0V8q5gDy\nTB53vCrnz0NTHSXu9J7e5NmgTaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7x4ZzMw5XtOF2FHQNEtH2CxWeNMwHwYDVR0j\nBBgwFoAUjN9o1If6V+/7m5eg6AuBfBnERqUwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgKBw+eQBa42mD\nTEyrbVLmdi/tm/PA+7qYhr03aaOoyd4CIGbUWuTWcY/g7B58DwtqeDMIllB2Wtmo\nxzxlOip1comR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR0I+AJYSuae66rE07e+cqDYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjgyNzI4Yi01MDlmLTRmMjctYTc3Mi1hZGQ4MDJjMmRiODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXeBpZaOQ+EvmdJzTs4w4kcb9MRinZDFRQosXxVAj05QA8\ng2emfdG/4XeSw0gJwa3qZj6C0wFgvDGT5xl4Af5Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjN9o1If6V+/7m5eg6AuBfBnE\nRqUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVRd2MoTQI78pXUkUrthJ1yRIu0jPL3TW/ghAcjAKgUYCIEev7qzWGpR8\nigz0WfR8w2r17o2yC2myywbpvJ0T59dl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAYiQbUXKOx/iqgitj9ws5hmlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA0NGJhZDMtOTJjNC00NmVhLWJkOTctOTQ5ZTY4ZjgzNjM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiNDY3YzI2MC01ZGZj\nLTQxNzItOWViOS00ZWU2MTI3YjdlM2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQjFhIFgw2yLTghuxO+k4DERRnp2BS5bRI1ITE2OLl7XKLtzyxv+skV6GTodkhm\nx/0zCzwWw2/o1n4gnGy+YoXHo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTvHhnMzDle04XY\nUdA0S0fYLFZ40zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAPYKdOIkcWvDQtJkYOCkt920hF1Xu/SWopk5mnRswKFa\nAiEA6Cx+dJu1EslBvcvhGv7kpx8Fc65p1NHux1u9xHS0T1U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7956", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7956` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAZjt2FCLzJgvoTD05fmzKyVoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxZmEzZjAzLTcwNDgtNDdmZi1iNDZmLTY3YjgxODRjYzQzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE5MzNmZWUtYTZi\nOS00ZThlLTkxZDAtMDhjZmVlYzY3NjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYHX+o3tIHBGHehfpShWfJa2C0MMteC7YmCZnj3lyxmTZvkMDKe7xXVpwpi+l\nblLgp88jfrucKgws55mHQRQ3H6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZtBN7mCd+32HqGSmgaXRz3VqI48wHwYDVR0j\nBBgwFoAUi4D5p0wB6Dfu3VXC0vRnQ0UccwcwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMLKwIfIhy46\n8/edCM/Snz82F/BNT1X79TKMxUE90dTLAiEA4PxOLMbP7yWAiV6HN/X/5oAykkMQ\nsUVv2br7vRwL5m0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYqXkHN4ZSz71UflElHnmyU8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWZhM2YwMy03MDQ4LTQ3ZmYtYjQ2Zi02N2I4MTg0Y2M0M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdnRs2dTCp+sObTGoAIn5H9uJBxELvpd4J/PlJysQRX98g\nLrgC9qXtD8SJl9N7Axr8nPppyh28+Mi2Zjau4Rpho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi4D5p0wB6Dfu3VXC0vRnQ0Uc\ncwcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMQGKO+nQA7LBzTlOOtT3cSyDgoRpGEjmILGsG4/L35fAiEA0FN/6Df2\nMrRavGYxAVPqnVH/t6kw8HmF5aHmtE3g80o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfJvWQQ8wb6q7FysPXk1rQnEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE5MzNmZWUtYTZiOS00ZThlLTkxZDAtMDhjZmVlYzY3NjFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlM2E2Nzk3Yi03MWEw\nLTQ0OTQtODdjZS1kOGIyZDk2NjBlMmEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATJEBGcveqh42Q+HO1TM8nd6Qs/cVwcb2t2KKZnziIcCaz2LLM+akDv/U7y/2zI\nCYuxCqw3ANxAwgoH0y0Myvupo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRm0E3uYJ37fYeo\nZKaBpdHPdWojjzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgF9gcVF25kPcNMRLytObmtHu7eJ5nKyUQ7zuSD+g19m4C\nIQDpJoeXSFOuqnhoIe76oWbjrOYvNRbL9H2a+6q4E7mCBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7957", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7957` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYRyo2M5YkbecI/LOhOc/Ob9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwN2YwNDYwLTg2NTMtNGQwZi04OWIzLTlkNjg4ZWFmN2Y3MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM4MGQyOGUtOWFj\nNC00MTJhLThhNWItNGI5OWY4YzJlOTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESj9KcdvXIvcjnkP5PBz3zRLo0ptUPltDpDQ0jFNT4qIDmW/umjAMWi3dYK6e\nbb+6Wt/HD2/fq9IMbPvIS4mBiKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVwMRDHOLBhPb8LjvLunJi7OHNmUwHwYDVR0j\nBBgwFoAUtBx6O7X1r3hCbOKkcqE8t3fCHmswKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCM3qD6ijQl\nmkj/uRP47iqE5OrW0UBOjGtPvNs5AaU/kQIhAK6Ii2/SKGTDk6FouHqUqkMCfA3+\nj4lOFMn4d0e4Dgj1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVDBuo8ZYSfp3h48Ont5iAQxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMDdmMDQ2MC04NjUzLTRkMGYtODliMy05ZDY4OGVhZjdmNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAorqJsUlO8Q/CTbLY+OdhbynAiCq7d3Fp1zl14ZCJXf5i\ngsbBbqZw0PjsY55HPROALYl+1MMtpBLP/+dT02oqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtBx6O7X1r3hCbOKkcqE8t3fC\nHmswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMSwyoyd+5LBLMBk7+IsG0EAZ1NV8BeY/tL6K2VaRE3QCIQCzVm2i+BJk\nVIvDikVtiNaEEfSPOyIPc3wYEVVJh3Sjbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZhk8kAJECiySStBUZ2PN3FnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM4MGQyOGUtOWFjNC00MTJhLThhNWItNGI5OWY4YzJlOTc5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YzE4N2RjOC01ZWQw\nLTRhMjUtOTQwYi0xZTQ4MTQyNTg3YjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR9yBtrbe1mFMHLGPn57lFS9mhPN5Gup2lvrT/UhjCzK2h+NPvFksrCVQJb+ZCP\nddZm2o6ZGUBG2HvMcPkIPJW2o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRXAxEMc4sGE9vw\nuO8u6cmLs4c2ZTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAOXHv/AvGtuSJckdBlk7n4icQc9jINFnPnoC1SqQGUSE\nAiA3dlqBW/aL/nsenVdFwmdEnOqed8HqoQfkwVCMf9ePCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7958", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7958` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVyhxg5b2HmEiN4blMJ9u7iLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxM2ZmMThlLTA4ZjYtNDM3My05NDU1LWZkZDUxYmFlOWE1MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTk0OGQ3M2ItNzEy\nMi00MmEyLWE3YmMtZDU1MTZkODUyMjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPxDsT8rGIakhmkPnA5CgYNszhVcp9R4i+2FXI2rEJVF36vFUgbvlbdTpTqJU\n3pT35u/K2172uHgLtgbTkkNWR6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyNF2MLByN/um4FlRXdaYEV2T1gYwHwYDVR0j\nBBgwFoAUJiJUjXq+xn+APK8jYKcJexbDPc8wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICaNtLKYWm9F3YRPHCwizfDPcW7CIrzq892fiqQmeKDhAiEAvZ/pMhvgEeUL\n3gK2FvJBLKWNu99sg9GUG8bRwIwCXiM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZuiIJ8h39masZaKAo7fEpq6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTNmZjE4ZS0wOGY2LTQzNzMtOTQ1NS1mZGQ1MWJhZTlhNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR08Ws5US66VLkPDqHfMYzANVrJvXfaIJugqgPR5q1n75HH\n7IjyULC5Li9qMR/DJoad9pImi6tESQjalfgtZ/aIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJiJUjXq+xn+APK8jYKcJexbD\nPc8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJUQOcLvpiLuUCBYh1WcR5nGCK3uSbptohZk/iK2FLRgCIQCZ7qaI+Xlg\nmDl1cjWKH8NBg3IUyPRUXYWq+U4N14BcwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAX9At4Q0ZZUYDLFkZektnfHhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTk0OGQ3M2ItNzEyMi00MmEyLWE3YmMtZDU1MTZkODUyMjAyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5Mjc1MzY2Mi05MGZi\nLTRkZGMtYmZmMy0xODg3MjJlMzgzMzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARWnXm8S9bUMRHDCgmCmd34fzSPVXTtSPIXa1/5YRw82jpS+4kegxQ2kF+c4c1D\n76qsFIGR0KDQaw9XkEShohHYo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTI0XYwsHI3+6bg\nWVFd1pgRXZPWBjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAOZGLmszPTcDKoGaniPgU25WcmlbGAExcc01sDISafTC\nAiEAiR7UlvwJkl3erVIMrTGvytinn2nXGfdF3ceyZ16bSDc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7959", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7959` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUlEBtRefVl8AxM3VVn09ceIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4YTlkNjQxLTI2NWQtNDE2NC04NDI3LTNhYTQyY2RiNmU2NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZkMzYwZjQtOTQ2\nNi00YTA4LWE2ODMtN2ZlNWYwNThhZmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc4SmvR9t3ycfv/wzCqoXzrsoI3XsMuPJKF7t8gzvVJLydR6HTHLSkVUHOdt4\nzRWrsupeU/HPbtKECV7H+pxxXqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+PBmRjmReNNf5WJSOy9/Z2z2K6EwHwYDVR0j\nBBgwFoAUhLHZ5gR0KLS0Y/ebdVkJ75hJCOowNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCSKLd5a1NHTYKsgXEMeubmd0HEdj6Au3A7PREBbjYHbgIgcxqobe8vtt0H\na1v/e6PUMGIYGRi8Ye6a/NaVpJ7inLI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASI4lijDsHLQ3f44Gq9hZNKfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGE5ZDY0MS0yNjVkLTQxNjQtODQyNy0zYWE0MmNkYjZlNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+rjQVAG3JNQ31clt0+QRgJVuzm5zkmZO239XiotuKqk6A\n3nwGhlcLhorsjayE9BVA9+0vx+jDcJo9ahZzw8tUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhLHZ5gR0KLS0Y/ebdVkJ75hJ\nCOowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOMoxPbBOJXGp2l8a08jGlQk6a/ZK+V4D/0nR1vsXoLRAiBnu/xnmQXo\nPsQox/QCcbSJ7Ltsq7bsWtjWhCqPW+ulRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARA2GeuclE+InqdnGNQ5R8KvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZkMzYwZjQtOTQ2Ni00YTA4LWE2ODMtN2ZlNWYwNThhZmM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMTYyZTEyMi05Mjc4\nLTQ1MDctOWZmNS1mNTUxNTFmZjg5MWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATSUjtbD6VBb4I1W1PUu/2qRmHtpE12wlSCD3z12Tl+JMyrbVmu2jwRO3DRXEf2\ntdWTpdi0L78QmcY9vDTLyjwdo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT48GZGOZF401/l\nYlI7L39nbPYroTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJRsbya1NYe/bOI6k2RpmvmSKJyXjrn4wdEOW3RBkPQd\nAiB4WAdY3r3feG0f5P6WIRIYrZJitU0+A0+DR6NO6UO4ow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7960", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7960` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAf8gXyyt0EwSH0MSsjFUliI6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNmIxNTY2LTFlY2YtNDNmZC1iZjllLWY4NGNjNTU3MzYyZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNlNzVlNDItZWNk\nMi00MjlhLThlOGUtMjU0YzYzMDVmYjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE4W87o9fpIRxYWdcPP3x+zKf0KWXl9rek6P50AyBQhNP4FvzWY6HJf96hvvS\nyiDCmqBEqnNEytJVsxxJ2VZwbKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8uroq9PafVmRcqXR07wnrl8Uj0YwHwYDVR0j\nBBgwFoAUf7SdOZ0ShBF1bos+dL8cUn/L0M4wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICV7\nfPnmkyss/64k6LcLe3hJmcwmJ8kcmur+mbklwtdzAiEA2O2jYlu3DnpqJqFAEdSf\nBlXEtDprM7g2zgSq73lLqBs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQEkxdJBd2vQwPZ+J/soz3JDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTZiMTU2Ni0xZWNmLTQzZmQtYmY5ZS1mODRjYzU1NzM2MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbYQ2Wi7c1O4OwTKMneF+T6z52uXOKBwYzO9EIsNspnF5I\ndmCS5DVGv5A2mkMUmT9feveUo1ZRkors0jNiLAQMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf7SdOZ0ShBF1bos+dL8cUn/L\n0M4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIU5I3YBBKiO1vIw04JTNOfjjKqHzYl4N10bBJoe/iZuAiEAzvqoB860\nlGWkndP4F87JpCB09BrCdXzAazd7+JLue5Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASSHaiE6jwTree7idmd1gGC0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNlNzVlNDItZWNkMi00MjlhLThlOGUtMjU0YzYzMDVmYjc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlOGQyODFhOC05Zjcx\nLTQwOWUtOTJhYi1lZjJjOWE1OTE3ZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASbJxGSyzB3xjxSerL1YBxMG/7mwPyzB20SRalzhjQ+Jiu1QtPOILqFL/N+SrrY\nqaeknokHdfHQ61WG0ObknC7ho3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTy6uir09p9WZFy\npdHTvCeuXxSPRjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgcVzxx7Pu5X5G9gL/pDekWEP2LlW7QFt9sq7LdLbvwt8C\nIQDQVqJ5+dM/y8iBQ00w7Zv2f/fS6Thsc+Pedbaovj+I6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7961", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7961` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAdVd94XpJD5b/usj7xOZgeCUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExNzZkYzJiLWRmZDUtNDZlZC1iN2Y4LWQyZjIwNjkyMDdiYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdiZTVmNDAtOTcy\nMy00ZjZmLWFjMzYtOTk2N2EyNDVhNjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPyA4q8Qsea4r6WKzpb+WpHM+LR6OpVSYSB0kwmwyBOEqtBaalffJPSz0ocoh\nZ7ltUcovFlo58LbstMiWn7gO76OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUogpyG4oq9aHcdgmaqOCsJ8xPgxgwHwYDVR0j\nBBgwFoAUV3JyyHtA4L7KOmbLSmThQLwqmScwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIGGJUY26eadkBdz6B/TKTR6Hnx/+mVZwUfBCAzSXGe5yAiEAy1Oi\njAhR9klp2eO0vpyh/P29yUKzN+wmTp/lUReKDYU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc9D3TOwGi2kY4k7vMGoMuupMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMTc2ZGMyYi1kZmQ1LTQ2ZWQtYjdmOC1kMmYyMDY5MjA3YmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBrDIiatYNI9AGVa7zzYkPZBLW9FQT1mzbahoTarSpvslw\n+PzXAu/tfu24XB36n1TpUs0VDzCqQQRy/qD0fKxdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV3JyyHtA4L7KOmbLSmThQLwq\nmScwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRVfbmrpJ7dFeU4KOmy3riXeJUnaQ+vrdfd06kQWNaioCID0UfEM05FPh\nzJK/W1W1YF66L5oDeDIijyvJqlxSfsWH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAaacJFutkYsc5CKIkQAvXhoNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdiZTVmNDAtOTcyMy00ZjZmLWFjMzYtOTk2N2EyNDVhNjRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNGJlYjk3Ni03YTJm\nLTQxMjktOTg1YS05NjY5YmMzNjlkODkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQRQrDXRfRjrSuXhQbljO7lr/+xBdgXd2VKr2O6rhNJL5puoEWhJLNJFcU4DkzU\nAdk8RZ07y2aMfttozVSCQubbo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSiCnIbiir1odx2\nCZqo4KwnzE+DGDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAOr3DgHpiusI6bD36/PS2brBsj5vRpbNkqy7GN7NFhLY\nAiBfsjGwjCBJohlperRUMTBvGodQsv8H0flzhDF0+VvOJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7962", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7962` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAQMmBcF37WxYhKe859iWzQVDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlMDk0MTBkLTM0YTAtNDc5Yy04MGIzLTU5MmJkZDhjMTVlNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZiMDdkN2UtY2Vi\nMC00NjhjLWEyYTUtYmIyZmE5MTE5MDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBvRHuFv1wnsSxtYOjpkrmC+VgUxrzmYt2/GpY/d9fxOn1XPax8Wjzncgckwv\nGLFoXGDdf2yXg45APotDYIfQzqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3BEE8jDM0VHcGF6hc1iL2avhn0QwHwYDVR0j\nBBgwFoAUNIxY4AYf8SgR2Yy0k3+Xb4pGRyMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCICQHtnC6Qbqv9dvYjc5rnqqj39mW9hHYSzb7msvC+84pAiB6XJ/M\n//zmc4D867sLdv5f7tq9eqiffbXr2QUU9upnAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdnBSCBi98mvsNd/z6ecSERiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTA5NDEwZC0zNGEwLTQ3OWMtODBiMy01OTJiZGQ4YzE1ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnrNvPSmDBPUQQ6rH1CONITTVi2fk2fS/qxaeRhwbREHty\nfKQXvHRMpMksPExQtNuGKy5BOnjb42FeJyo+JGrwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNIxY4AYf8SgR2Yy0k3+Xb4pG\nRyMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIryVLySOJNl9qWvTj5289ZXwCn2tlA3+zeFl+PDNJwxAiBlnWf6qnO/\neoIikn/PlpoOIpH+JR6QH9mVoulUMHWReQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAckDKh1nGoyjm9z+cXMdOTvKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZiMDdkN2UtY2ViMC00NjhjLWEyYTUtYmIyZmE5MTE5MDk3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0OWM1OGJhYi1lNzlm\nLTRhZjItYTgxMC01MTg2MmU4YzFmOWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATE+ac1P1sPmtIutfeQnnlyHBQ4z2+XG34ZnTj2fdJMVuEE9QrLDt5MnDeUmN3i\nzoPAB9h5IJ8HQJB+aIZm2PwSo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTcEQTyMMzRUdwY\nXqFzWIvZq+GfRDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgX1DN82Go9nfREIpn0QvwSpkca46sYLK1Fyas+7wb/GMC\nIQDXb4jmPg+rJfIBsqf4c5Byk+4JBBQiuJAHKEucJAuSMA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7963", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7963` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATs64izOpvuqifXFuKSQgef2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlZjkwYTNmLWNmMDgtNGRhMy04ZmVmLWQ4ZjhjNzc5MDBmMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzcyOTIzMjYtMTIw\nNC00OGZhLTg3OWEtMmVlNGVkNDMyNTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdlMivVF+P1w7cCLUvbE4V7Ey/Tc+5HG427oDBKrOdLqIDU1q4kw0MaxVyqAI\ncNd7ODZ1MRkVWkkvxCCZFcCOH6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEmdg6uh02li/HiFlG03LE/Q80C8MB8GA1UdIwQY\nMBaAFNLm1HRD5OL1nsAawaeghgEs6tDEMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA2J9CamjSHZ5XKgq7asqdiNkUCUxz+41O5\n5nsy12BEewIhAOcaDy/g3QduWv29+WTRedF2P+zND8PQbzC/ptrjeXI7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUvbKQkMZwG/IRILEDBvRIZjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWY5MGEzZi1jZjA4LTRkYTMtOGZlZi1kOGY4Yzc3OTAwZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe4+l3ybkE0m5CR5VA9EWuY3Yd+QKqV3+zPvI58DLBwEny\nJrb8I7i2gv6uZvVo9CgxpsL4rl3O4Mm+T99IBoICo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0ubUdEPk4vWewBrBp6CGASzq\n0MQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALqV4IwhOB9Jj5/eYVrjbDE+uMq4WBm/lLz9i0vbwP9EAiEAviTEWxw4\ndykMkIRMUukOxcPgHGmQbUR7ZwgLTpYM2E0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISATMNcuc+3mHWL0T4oFX18eTaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzcyOTIzMjYtMTIwNC00OGZhLTg3OWEtMmVlNGVkNDMyNTZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlZDM0ZWJhMy1lYWE2\nLTRjYjUtYWEzOC0zOTE1YWM2YjY4ZDUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ8aSPAOQmSlE1einvr+gOe3ZvsiXryykpRO1YI6TY0jjmhJ2gPa52d1lCFQYgz\nbrVhqO6JwsTBAt9Rh8Tg61DBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRJnYOrodNpYvx4\nhZRtNyxP0PNAvDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAIkeF7vHqUBVR2nmrHym2zUFonHX9TPKzJyULC6y6eFv\nAiEAv5IqUPeU2wwk9otA2YFHhrKi3RR334W47K6Qy2fL5sU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7964", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7964` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAUJ3HI2wkaPqYTKFy/cu+TJ9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmMThmNzA2LTYxNWUtNDA4NS1hM2U1LTBlYTY1ZTg4NWVkZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmI1YjIxNzUtNWRk\nYy00NjFjLWJiYWMtNTY0NTRiMTIxOGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ5figYQIZjChazRDTI7XTxOkrFEH9yiIHgSTIfOeP7Ho/U2lJuF2eibB1Bck\nZQUvK8+5d8fhWSAiXOSXzWrrB6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGNrtFeEwavNbzyBLQpfp4cjYp98wHwYDVR0j\nBBgwFoAUm9ZzGgyKOqTYgeUCiIk85IxJ+EswKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgDrhC66akGo9T\nnefxGCdUyByatfzJMnS7t9uLb+KsUOECIBFoPy4vdQ6szogVVhC++ONcwgDSGU26\nDBewulYEOFhZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcJ8YmTQMpOEwCFFGC6WpawuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjE4ZjcwNi02MTVlLTQwODUtYTNlNS0wZWE2NWU4ODVlZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdwMCKT6uDVdPzf0bZ/7Mh5aK53UU8q4UhZJv9fqN4nh/f\n9nPzHdh/NKZ//JeSq/E1w+9tzoxozqVFb4AgQ5T7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm9ZzGgyKOqTYgeUCiIk85IxJ\n+EswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKnIGADyg+iXvZ7qWKwj1SxX3vqic/J4rMEJkIIryBHTAiAy+HqA5LJN\nv1GEaSAImKTMowN3Y9eXLvE60++h2RHrlA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAd4MWA0O7m/cSJ9HhscA2tc1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmI1YjIxNzUtNWRkYy00NjFjLWJiYWMtNTY0NTRiMTIxOGJjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMjUyOTM2My1hOGRm\nLTRiZTAtOWFiOC1hMjEzZjYxM2FjMzgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASeBSw39RIzkoumYsl9XS7BDu2jKI3spNULWBIgn6tcpp3yOzOUTM6HvgrC/K6o\naZaQFiUbOpOWbrhJkj4KWo4Vo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQY2u0V4TBq81vP\nIEtCl+nhyNin3zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhALPnc1TeX9w4d7w9X+qLWmjudZys8im0CsIkANWPfbLz\nAiEArOUpItjcNU8wj5Nv0GqdY6KD3RB1J85KXez4Z7MXOHg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7965", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7965` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAUwDbZVhhxGsJgcOfvEpALM+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlNGQzN2NjLWVlODEtNDdjOC1iYjVmLTk5YTY3MzAxM2IxNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTM1YTBmOGItZDY0\nOS00YTk1LWFhYzctODVlZDlmMDhjZTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc194KGfktSpjW1DxjXJD9kq+koM4FxO5bg4G8h0h1cl5qJ1cJW8dfnlGoQDq\nh4KJ+a2swMxbKvOiNsGFOklVUqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD1OaSfOFyRbmOOU2pkG5kpb7+/MwHwYDVR0j\nBBgwFoAUDwhq+5r0yuOiBDkURaYzlQAvPfIwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgLRnmER9kcdDA\nVdnCEJcG90Nl5PEIDT3XuJbgm65F19oCIQC2+04NHnJ8HHGUOd8tlegHCf6VqBnp\ngXsx1eRllKR8PA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWZTCH53Cg4E2aaHroua57quMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTRkMzdjYy1lZTgxLTQ3YzgtYmI1Zi05OWE2NzMwMTNiMTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRo1Nv7LssY13Q73/jTl3OdVXI5vRNYJgQfkvR5zNMY1AM\n+ZIB7dKtS/nhwaQgO715C8gXt6tm+jkCUx8Tez3ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDwhq+5r0yuOiBDkURaYzlQAv\nPfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKSsnQ9QxSps8U4MnFkcGym4445W5GO30FiGp26aYGUdAiEAkGJhjizV\nSsA3JhJkSj6+UcVWa/FwrU3Pcc6BYT4AIC0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUTuDfGMOJjLR9mNJsnVLQ2KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTM1YTBmOGItZDY0OS00YTk1LWFhYzctODVlZDlmMDhjZTRjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYWQ4ODBiYy00ZmMx\nLTQwZjItOTliNi1jOWQyOTdhZjc5NzIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR6Jy6AdIe9xTvPV6/yAMtDtAifecXsW8//Hel4khbJb0vf+sqy4Zthng6or61Z\nSK+6Ct6mah0yhgpm1UdvCymUo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPU5pJ84XJFuY4\n5TamQbmSlvv78zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAIWwIgTPk6HNzFmTWHWZkirTYhZSNDAFVLEGg9IeV4+s\nAiBZ7hD57ccRnrjAYMtzGxdbIFewnSBxuwV23tynBAaKpQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7966", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7966` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAQp7OqbWj6GN0hFEUYV86h7WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiYTQzZDI0LTEwZmQtNDBkYi1iMWQ4LWUwMjZkNDYyODcwNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVhYWQ0ZGMtZmZk\nNy00MmIyLWFmNmYtMWQ4M2UwMTIzZjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnRmHoNGRDAYMN29smYoXVAp28wPOIAYKDvcWydlfluElxkH0tVOtLusZNTR+\nLqcgotajgxCLxUtMquSP5vlv16OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwARC4ZOEkMox7yRYD6mymLjtciwwHwYDVR0j\nBBgwFoAUgUsAroVlXmnlwJEUEdEtNEy7BO0wKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFsWEL9wDVHY\nyqD3rOflrTAtweot6A9UGpci41vWxKjcAiArE/28Az0OP+riPhOwpj6n2OlorhJp\nVxtD7bB9q+OGTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdDaZOFO1S+lkIQX4bFh40JUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYmE0M2QyNC0xMGZkLTQwZGItYjFkOC1lMDI2ZDQ2Mjg3MDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiy8vHzJkjDuKFALaBw+rr9PaHm0aZyBcbKNsIOYvQp2FQ\nlFhUx72u4yddQ1k6QRAkbGBQULi4jG2mRB7ZLLdDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgUsAroVlXmnlwJEUEdEtNEy7\nBO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOQuw0jSublodDbOX9amUL3U6WQq3X5KkBf5Fyc7YIQBAiAHPUTNU4/M\nKO9pB4QG+IM7ouf3Fq3F23BY2EIB9MyISQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVgbJZG/wKq5qgIpuWLN/AEwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVhYWQ0ZGMtZmZkNy00MmIyLWFmNmYtMWQ4M2UwMTIzZjFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwN2VkNmE0NC0zMTBk\nLTQ2YTQtOTBkYy1kMjI5MjE5M2NhNWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARDMBuDLLqCWNXxFECDxpDYpaE6WW98t59wZGz6q5ljMTeZ3q45aUTIBOIdW4D0\n+u7ZEBWyhYAkaFG2k52dO3Aso3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTABELhk4SQyjHv\nJFgPqbKYuO1yLDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgfyqkYskB9ZyKjCDhYaZXvVywf1JkkGnJ8DfeBz3id2YC\nIQDmFBSAEITWrqqlPrGDLn44RHRwe8E4N5MkcTPgjQyEbg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7967", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7967` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAe8tDD/rrHEZvX0lKKg8fL79MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlZDY0YzE0LTdiODItNDliMy1hMDNjLTJiODUzODZkOWUxNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGMxMWNiOGUtMmNk\nMy00ZmRmLTgyNDctNTc3ZGExMjQ0Yjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYLdUQdmmgR3OY3FiebwgohGafDttCIpZpdcJhugE9ElpmILmKA1gGZoENJnQ\nb+A1EEmNZ7J01iiO1EEMhOzte6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcEi+jYVMqkr+O9siRGluYIFmuP4wHwYDVR0j\nBBgwFoAU2frp+Dzlf9WZbpsjYgbjt6LW3QYwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIB+lKEeds1MF2zLvFeL2Rz/BBT3Uq4IsDSUmIStzfnPFAiEAvbs0TAjq79EH\nX0rYEcof4u9sJtMtgIjRH8UWlHA29c4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcdwrqPdjaan8KQ19Tb1AA59MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZWQ2NGMxNC03YjgyLTQ5YjMtYTAzYy0yYjg1Mzg2ZDllMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcHanzWpsm+hYl40XYob3U0lCHZR9AKcXT53oZvUF+QZ2P\nihWDQAIAJ+4XYFOINFFm9ys/CWXncio1WP8mV+n8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2frp+Dzlf9WZbpsjYgbjt6LW\n3QYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM1FFGux89sZzMc3kxsAJmsoZdGCSpmuwbm0U8Ugh3RcAiBLfktK2oV+\nGjal2sTKqwCmRNs15IUaxpTYCs6m837JiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISARBjCFXLLzIYbXZCnF5L9w57MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGMxMWNiOGUtMmNkMy00ZmRmLTgyNDctNTc3ZGExMjQ0Yjk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwMmNhMTNlMC05ZTI1\nLTQ5ZGUtYmExOC00YWI2MjI5OWEyZDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS6LreXlcGcE9rN3GXy0dmVTN113ir7tmV0vMlChsWa1yObmlURu3zMM6ATyWpX\n/leuNl3mbABVJYxU9KydVSh2o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRwSL6NhUyqSv47\n2yJEaW5ggWa4/jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgViOUPgP9rh8Ir/m/Ehs9FF2ynK1BziuNeerAPJjuLVUC\nIHVjWNezmEg6Cwh4iLJ1FYBj+WeCfQvNy/FeAJ/9D58v\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7968", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7968` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbhuLV7tffpaWV7ToJO5wLJcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMzdjZjVlLWYxMTgtNDU2Zi1iNmI5LTcyZWVmMjYzODk4YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODMzZjJhZGYtYmEx\nNC00MzQyLTlkM2EtNWE4MWJiOGJlOTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/FQpZt/bk14bFK4E/l2XevL+BSjzWMM9kJHChc1SMMBS3HCg+G01RDNkrE9F\n27oQuPcwCD6T4CFGXP3QxGRQx6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD8ShM2udgqIDmE+Ka5ldfgp7ruYwHwYDVR0j\nBBgwFoAUmxl7ZoS+wfjZbbhLZ38TqzeSow0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAwt/bg9cJlU8aam/fXAkf5QeIjHW5YAJ+Pij4pWO0hmAiEA7uMhctBw/Ltx\nOeNcyYKQrhiqm1dbagrDHDuOAHYmYVg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYEaFRoRj2BVXegmDJsB2pDsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTM3Y2Y1ZS1mMTE4LTQ1NmYtYjZiOS03MmVlZjI2Mzg5OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtqaLRR1MTRtGFfkh/xFzbWW0ZqVeS0wp+q4FBWqmlBmxS\ngzg+ghIOhgoKQRZp+vc/RYF65l+QvO8q6UjUVXozo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmxl7ZoS+wfjZbbhLZ38TqzeS\now0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOiuC4yYaaDmG1cQRpJugDJq5bm/kY37oRXf2X8nlsyXAiAalql1cr9R\n+VjQF/B5WlCVbcZRoGvTYYO2+nj85Uj4HQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAcuhIrH38YF0PD1vbiYSuNLVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODMzZjJhZGYtYmExNC00MzQyLTlkM2EtNWE4MWJiOGJlOTVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMWE4ODg3OS1mNjc1\nLTQwNDYtYjRkNi0yMTQ4M2NkNzFkMjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQjsxkmDs7x/yHA3PfxXidzVXj9KG6llG2/l8Q/qWHB4fQQfxLX/+5lzHtvX/eT\ndl2lS7czcg9Z4YmsVqSJ8Khlo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQPxKEza52CogOY\nT4prmV1+Cnuu5jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAK3t8cRN1kzPRlVuF9Dwl2JVwHv4vCsSomTopfKW7mTN\nAiEAmLTtUY6X0FKqetna1OrJp6F5QZ+JDlY1g0+lIPoyjUE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7969", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7969` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAX0ovU7WRWnXWAOoakTi21qvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4MTQzNzhmLTE3MmQtNGIxYS1hMDY0LTk4MmQ2YTRhZjI3MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRkNDcxN2QtNTdl\nOC00M2I4LWI2MzUtNGE0NzkxZjkzMjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER0FJwSYiyGv/zeEJSAwXcbRhzTCIPDzPAFyle9lleXAla5BNI5kcATNCGRJM\nWGgJ1lHqgi/lAHKppDTAURK7CKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe/hz2erMNGXo1msYke4veWNMnhYwHwYDVR0j\nBBgwFoAUlTNrDMc0N84EulP2fMTCBZtmBBgwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC7\nz4sM5y8Xx+RN3L9MIU0ZyVpRNP/XXvtOr2FJz7OdWgIgJBQ/mivep5+U3fdNQ/xh\n7aL7fzVfpwEM/T+umSxPMUQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeLdfyY9X+5G3WfiDM4i5dWHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nODE0Mzc4Zi0xNzJkLTRiMWEtYTA2NC05ODJkNmE0YWYyNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrbTZPHoro9WB0l5Qm1r4kNhdpLW72if0CwZuuwY58wV5i\nukhG4SVYzZerEXKXxAtybH+SV8vPYj5NY+cOL9Flo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlTNrDMc0N84EulP2fMTCBZtm\nBBgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEN/Fh8ivsUo3WOW0eQtBe7NVs49BnnvdP27kZtzT4+oCIEPO6pCudIqo\nE9Rkf9bJKS8NeDJAmoMp4o/9kQA9XEJe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAb/lKDjUgyU1jwlYjd82cYEcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRkNDcxN2QtNTdlOC00M2I4LWI2MzUtNGE0NzkxZjkzMjcwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1ZjVhZjc0ZC00M2M4\nLTRkOTktYmQ0Zi0yYzc5OTY2MzA5OWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATQxRCZaKrMwOosmS00fofqtmWc6V/dBjnAQ1AHW0ynwr0/p0jnY75XDAgzx2MM\nBtikJc/8yLmchv+raOSd/UPFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR7+HPZ6sw0ZejW\naxiR7i95Y0yeFjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhALXy5T7dYVkGM9ym+DP3gzKPnEMaV5AUmMtb/4xMMd4x\nAiEAnqqNFrfso+il3oMP27XqnPiy2dy5V3svlYPmxSIwfoo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7970", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7970` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVmO735bSXH5TRydF5enorz0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhMmQyMmVlLThjNGMtNGM4OS05YjZkLWQyODcwNzdiYmEzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVlNWMyZjUtYWM5\nZC00YjAzLTkzNWUtYzM5ZjRjNTdhZWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw98epMiyH8S7HbKLIoRaOIgSZAvz4zpohJMX7Yqt27jIdPFlcCHMRQ/i8DV/\nWdw7l7m8/Wb391aUBt2W5dELd6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULFwW2MqpVtivVJ79SnlsEaxm4k8wHwYDVR0j\nBBgwFoAUtb+BK8yggToHoK0FRd0VpgnB6B0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIDKqMvvQiFGWgkoKSpofGzxYnc8t3Bd8kmWv/jQc4HVuAiEAthfC\nreHAdmNjbkAeCk0YRFIVzJ2etCPZ4LLaLGHrhbw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbq8XsAzpRD2IQUCrWPgQ8UxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTJkMjJlZS04YzRjLTRjODktOWI2ZC1kMjg3MDc3YmJhM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKnNPZFNOFU3m7lVE5MCSgpHE9fd0G1KaIEgFp44fNerFi\nKxTUXjUFO6F79Fs/eOyYQLdK8Xz/le4dVUZnxb/No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtb+BK8yggToHoK0FRd0VpgnB\n6B0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLpLzCIOyWVpbUi9IX6ELPCly0xXh6oXDQvkSOg7Sbu0CIDLpg4e95cpI\nHrIlidHkpTC6zhSdSs8mJsZMN7tiIEk5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAUrUI/beghfGd35RrZLt0TuxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVlNWMyZjUtYWM5ZC00YjAzLTkzNWUtYzM5ZjRjNTdhZWMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxOGVjOGM0OS1kZWE0\nLTQ0ZWYtODdhZi03MTMyOWYxNTMzYTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATkxshFlf0iqI4LK/VVIeORhjLmot+tQaFB39+lZe463p/8nN1DUd5H/2eQ0sNP\ntJKuEcHIWu0S0Nr9NrufyHp0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQsXBbYyqlW2K9U\nnv1KeWwRrGbiTzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhANbF5yj5jXlewJjdYNh4LV2/L0bvNSOyZVX78V2ojTQL\nAiAUdLfbMLv48qgMeIqXtMbGTyEgr5HSYri36TVU8mZaHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7971", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7971` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVMrhTJ5GMaDxjOE5QYBUab7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhYWIyN2ExLTIzMDAtNDE2ZS04ZWNhLWNjYzgwNTI4ZDhlNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y0Yjk1YWYtOTAy\nNi00YmVlLWFlZjctOWZmM2M4MTc0MTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5bYUF+4Im1rL2uAxtmqeScKYyoqeaAI8cejmza9R7LCSyxNZWxyGdZWdFBbV\n6xzZZrYpvGxUNynPpuuDWjxBtqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS+ljZ+DPM/fOxwGmKr3ua9lqcaowHwYDVR0j\nBBgwFoAU6XbsH46+0f4jTcVq9EY7eWA3FBEwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFcUqDW7NW+3RTY5p5fbAG4CLEzMxKfbuGnHSB1P628EAiEAxlGg\n0qPdm3bHo3i8O9qabyTAtWsCpKtkqlwNnUJjnwg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWjPhkeWrMmsyme+ks0q/9MvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWFiMjdhMS0yMzAwLTQxNmUtOGVjYS1jY2M4MDUyOGQ4ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfhEGJjIUu43uOeL8DMw/Kjut/kDVVMSWlzqTWBEuTnghO\nRiB7NtWNAILtyGvImBtz7QauOYsq9mlkSe8OLqVso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6XbsH46+0f4jTcVq9EY7eWA3\nFBEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLYZFJIc8k6ZaNtv/Paa8BDBzUVQN8Rbyaar9NIrihHQCIQCfItHRQYd3\nA4BQbEKB3ZispIi1gAlxiiV2whqG5J1/wQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZ8UrpHiM87zMpeP6wUkByh8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y0Yjk1YWYtOTAyNi00YmVlLWFlZjctOWZmM2M4MTc0MTMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0Yjg4ZmE5NS00ZjQy\nLTQ3N2UtYWUyMC1hMzAxZjU2ZDg4YTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASjdaUFM2dNy1bSSGbAZhGzXzqdZ/RYO52pLmgAA93ebO3HVeIMHD+PrkLocXJI\ndXh0t9kphxbqnSqX4HJGcSrto3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRL6WNn4M8z987H\nAaYqve5r2WpxqjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAM7GlNBoVQ0e+ifOsP6zmw4mgKVmrDzt70q/BjBcWQLd\nAiEAnkE8WEGYVeXEcN3FOMoLSh2+Eua7HofGd/juDZ8o8Ao=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7972", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7972` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISARB+HLRv8rtF9/SLiqCFNEJbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjNjc4OWQ4LTBmM2YtNDYwNS1iMGE0LTRhMDE0MmY1YTllOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTVkNzllM2UtNWJh\nNy00YTM3LTg2YTgtN2Y5ZjBiYTQxOGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyzDG9y3OOwdCnBN58uDxen3E3+mPGLe0eFyjA4ay7ofATDEUcs9P+V8i9K8k\nFxjjnYCLTkUzOCQPX7cNwdMd5qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSY2oHIyZ9nGsGETYyNVoYproXtaTAfBgNVHSME\nGDAWgBTbXuW9gLwb3uLrirqfYHYv7EjcvTAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCPr9XjPA2YFNGFTB2p8rZwvE2AnlAK\nDTN5SB9gBN8xYgIgQ9gvXaQ5FbOI0ssg0QVhDeT6Zy+BiZN4zIZWPt5ZITE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWlZAwxeRtuJbQyTYRv+sIPAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzY3ODlkOC0wZjNmLTQ2MDUtYjBhNC00YTAxNDJmNWE5ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQItB5vVztAlJQSuSL4nl8WSKdqwed7M6vC0fge57bEoQDc\n0f3L0/0bf4iModRjTnmDQu7dOt6cvbqCi9/eVd0Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU217lvYC8G97i64q6n2B2L+xI\n3L0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXo7YGr/1ObPf939pYVbu9JnzqOuPR0RohKRalnLQ+e4CIQCdHOUcTeMw\nFGmyUMdtEmFVovIFcTGJtB3ltnmyApwRVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVYwLpl1oXk8WwqenPU0t1MJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTVkNzllM2UtNWJhNy00YTM3LTg2YTgtN2Y5ZjBiYTQxOGZjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4YTJjYTE0MS0wNDIy\nLTRkZTctYmM5My1hZDBiMTc1NGFlNDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATUuAfmxi5UlBakPdr6thBuzhBZNQqK+bKzy20Eyj0UqG6esStQOm50J/pdqgv/\nd9Z9Y+LohWKqOBz5EB9cCR55o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSY2oHIyZ9nGsGE\nTYyNVoYproXtaTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgE2UZc7V3jwfiXr7Uuas0MLsyKSebujdKwOpARJ1SLbcC\nIQCxMRWQHUpQQnAleia+wW7E0OG/ly2qhf+00I4IgpL6yQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7973", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7973` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAZGOW8U0/+r+xW8qCN3WpFVZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjNWE0N2M1LWExZjgtNDcxMS1iYTVmLTJhZjdiZDg1Zjk4YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMThiZjRiNjgtZmM3\nMy00NTI2LTllYjctNTc3YWVlYTM0NTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8a9XXdaKvV7ksgO86lSA6l17sD6xsgL4+U4SmCmB19OWTC0b/PhAyx1yMWyS\nMiFhkT7ikqUNbchas6dVvBTbO6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj2+CcW/uwei7qw7x0IqQWY/8h1cwHwYDVR0j\nBBgwFoAUy4refpGPUhlNtBh7y+PEN0R/s0YwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCID50goF0OK0C\nEpFUlaKsY9KqE97YoHwDCfKYdui86Kp+AiAVEBbfbeZDwlpUGvalgXWGH6r/60R5\nDJusS9gJesaxaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUXaZhtaKZsaO8ftTmTYgP+6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzVhNDdjNS1hMWY4LTQ3MTEtYmE1Zi0yYWY3YmQ4NWY5OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGiD63K0icgZjkPk83jAYeSMhqPbvRCc37eIYjBNpEndnZ\nhISkWiQEZd8NL9AKdyTPJVdVcRNKxNWlMeJnMEIWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy4refpGPUhlNtBh7y+PEN0R/\ns0YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALzZtKPny/O2J4SZqjIAzmx4Y78jm08zNzJH3ULizLmTAiBxDl9K1jEo\n9wAeQft3zF4gLkrhM7LK4CnO9DGzS5Z/sg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVqNGBryAvwSjh5MbazJxoN0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMThiZjRiNjgtZmM3My00NTI2LTllYjctNTc3YWVlYTM0NTQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3YmVjN2FjYy02OTYz\nLTRkZmItYWU4NS05NzdmOTBlOWJiZTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARQvYaqmWY/SbVA/ogRUBz5wE+HJt6tKPwgYxeKXnPEjrgtgRuk3rhdrSc8VqOb\n7Xlr+CluER1MWU3vrPl4CUZ3o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSPb4Jxb+7B6Lur\nDvHQipBZj/yHVzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgTeO4prFGlgeKrK6FI71kb83IQp5uYjfoLg5Ig0q4Wt4C\nIQCiEQOLWXgjthmFF2LCfI8+ftg2e42cRcOZTchxfS+7hA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7974", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7974` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAcZfABKu2RZOwxsj0GASKy+FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxMjFlYjMwLTRmNWYtNGE4Ni1iOTYzLWFjMWI3ZDBiZGM1YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y5M2I4YWQtZTJm\nOS00ZjY3LTkwODQtODRiMTY0ZTA5ZGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/IHNu7bjYmr+dMtMpsKJtsdPngVjykynoU6Mj28i0yLmYfPSyF3N/EzalaRJ\nSJwppxuToMORu9/gCgPuXJVmPqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqS22rJ0qUeTssWvssKWuA6NmS3wwHwYDVR0j\nBBgwFoAUqaGPJy9Ygg2Ju2p6T/RsWVnXZ0IwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIC3Uktf9EoGe\n1R956pgeRUj21hZi7GdP+QBo6Qdd8LRSAiA4o2gcm1OqTuwD0ppgu8pBqjdWWcRt\n5QngrKLNeQfjmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAca5OLwgAcrMv/Q/inVLFfuGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTIxZWIzMC00ZjVmLTRhODYtYjk2My1hYzFiN2QwYmRjNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJ3KiFsTUN25GejmJ+BGmlednJANfLpHzoqIe1CPQp03SH\nbjp7LSo7uWTWZV0/Jqjc981Kz2ld01GzOb3RSxHho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqaGPJy9Ygg2Ju2p6T/RsWVnX\nZ0IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgX31gy3xjQ518OfeceoCwEH6RJPjtgPD25SOh9y3XgjUCIBrpftUyCCLR\nH0jcsDp85kJURpUYSOakQY0SdKbGOgnZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXCZ2j1/h0D2q6yY3cW/V9m+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y5M2I4YWQtZTJmOS00ZjY3LTkwODQtODRiMTY0ZTA5ZGFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1N2JiNGRjZS1mZTg3\nLTRkYjgtYjlkNi0yMjIyNmM4ZWFlZjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATZaFEtyftCRb+QURHdagfCmQygxpyAVP6d/BJDviMMyuskwwVoOTot0bjE4i5C\n0oqKymGQmhozbvsK8JbLURSmo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSpLbasnSpR5Oyx\na+ywpa4Do2ZLfDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJpWMhPdPEBiHSPhW+AVwCqMUpnhlL3q7e0r9CXLfXor\nAiAooSBBTQiMTupj0nkmaGvl9ivqETo+7jrbEBRiLNH9Kw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7975", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7975` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISASNTuUYCvIryvIRqbnqTGoDeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxYmZiOTk3LTZmNDktNGY1ZS1iZjQ2LTMxMmE4NjcyZDdkNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI4NjJjNGQtNWNh\nZC00NDRmLWE1OWItMjk1N2QyZGFkM2YxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGOUYz5hDh8WJQovds4cahbp2LoCZvFbetsb7PozoIdF+GA2EBZ5kMsc85i6T\n5cMN5ZWDKdYMX24K/HalIqkB+qOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7+WCHMcnE9unMA6+A0eaDs/eaLkwHwYDVR0j\nBBgwFoAUM1USwA53Yv6EWTKwEflxQYOpZeUwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA2bIEC7Sv\nLJ3RowmTtR49kyghhZJkVJTeW7FR0F0WuxMCIE1rWmGSJOUl+gWL+S9kQfZMpH9B\nCXFBQeOwDh3gQlnq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAakxfon07/Ri/cXzvd4ih4aTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWJmYjk5Ny02ZjQ5LTRmNWUtYmY0Ni0zMTJhODY3MmQ3ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZzHEZT+cRtQiIFrpo9P5gjLbArhh+nrRLVEUgAWNg219v\n2HEO6xh21kwwusCYjKgOAhUCkjFIdHcYJarX27gBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM1USwA53Yv6EWTKwEflxQYOp\nZeUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHqodPdkwZpZTVf86qdpCbmRR7P+aA/llsBkGtrQBizUCIGof3+/sVM3s\nOHnylXY6HMUzhaRd8fIxN7aqpTPjIGld\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISATzUFjIsGyNS/fuof5/BFF2WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI4NjJjNGQtNWNhZC00NDRmLWE1OWItMjk1N2QyZGFkM2YxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZGYzYzI4ZC03MzY2\nLTQ1MTctYmRiYS03MTFiYTYzYzk5MGYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASV2l8m6CZzvtcJDnMfPfQ9npEQqk/tjjV7P8RhpB7JDjMLCtwiwSRVq05PdVia\nVQjBC9gtAZSM3LBBr1d1a9fro3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTv5YIcxycT26cw\nDr4DR5oOz95ouTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKe1fTev1o3zyGWdreu4HyczPVba01eZekRTgwYzRQ/T\nAiEAhGki0P6P8oVN5JRlNHI+MKJwoFwCU25zT2c5IjPzUaM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7976", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7976` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAQIUAI345h9DuBYwWltpJ1FZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0OTc3YmEwLWVhMDctNDYxZC05ZGI1LTRmZDliMTk2OTU3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU0ZGIwZTctMDFl\nNC00OTJlLWE1MmMtZTMzODM5YWVkM2I5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjAO2Vt7hYSyc9VIwu3fGv4sP+t61x429uS5IRzYvWdB2vExumkvoiHNc+DOW\ngU2w3QYG9b5zYJWEY6AnQjkcq6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU7tZDQ1N97R9SVTUj7hHTgUZPIUwHwYDVR0j\nBBgwFoAUvlTU3cF8PwZTrvsOpysMX/8+ewwwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEA7+Im4hk/BOK1xzW00G80rUoRfiDzuVku68ByRiE3CvICIAJkl8NMbF2r\no7at7ryS/aaVlhL7j+hwKVcV9ObNfwHs\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXjYszIZjURk/vXXgh95F2foMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDk3N2JhMC1lYTA3LTQ2MWQtOWRiNS00ZmQ5YjE5Njk1NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7AhClXLe5kQEuR3Txz+GEmSPVv4qbN32K8OOGxP4IVvHC\nWDbZBQNqOvbUseoG77WlCxKN/zcxywKl1VhslTeAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvlTU3cF8PwZTrvsOpysMX/8+\newwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOa/k1P2KxGi0l/XrRr1rKP4sOdSJHjVtO2XemgKs320AiEAiKFHHmRk\nht9vArDPTAkSV0gfVG/PJtXCU8SecQXE/tk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAQZEAK13jEWIDLZZcvIK84mpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU0ZGIwZTctMDFlNC00OTJlLWE1MmMtZTMzODM5YWVkM2I5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YjYwOGE1MC05YTE4\nLTQzNTItYTM0ZC05NmU5ZDIxNGFkZDkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQRpGzKU2y+YMdAQGMnUjbNB6fPDoPZ/FxtcQNdTHWhgXBnLT54EY0HDJmYkI1X\n4XilWQTyBEsA7hk2zKj5gFhjo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRTu1kNDU33tH1J\nVNSPuEdOBRk8hTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKr5+EEwQ7oe02gR1E5OQRZ9vWd6dHJiK7RHoav+N8LP\nAiEAoikICywaN9yplJZnbYBdMviTN6EFjr2Z2cGJMEmbmws=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7977", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7977` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAbGeyFpaH8Ux3wqcyFlQGB7GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzMTdkOTZjLTA1MmEtNDg4OS1iNGMxLWFjNzMzMjhlNTVlYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDYxZTQwNWItMTc0\nMS00ZmNiLWJiNTMtNGY1ZDBkNzlmYWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDQCKgz3z1lwLqmNape5l9+zqd97ox0GOGPKED2/cFfV1qwkESSN6akggMv5r\niRUvssvT2R+hJmE92XFe8G4qSKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwp2+4VYbDAPZG4wwg3cO9TUmx/MwHwYDVR0j\nBBgwFoAU7z/FacsloehLpNRK7EKLKRCU7AIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAiosKrIxBQb+ftuhbG1Stwl6WkRdgpMSw/I1bdZbMwzQCIQC1aCP6IJ/X\nJpkH701oN+rASgu0em0l29e2qL9EZQwg7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbzvGGLf0/cOM5MM2q6D1uLrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzE3ZDk2Yy0wNTJhLTQ4ODktYjRjMS1hYzczMzI4ZTU1ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsaVqT053uDEbhLOqNFivLoB861N9qc2f0tXu5tkUmhCwV\ngD/51PuEY7G5EuxAOL8YHTk7ZKlurm/jFxkPMGH0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7z/FacsloehLpNRK7EKLKRCU\n7AIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD/Q0y0O9A3AH9j5jTWH41yiaa3lfCFEdSHRXkEpurhQCIQC2hvNKWhzY\n0tQ828iHN9hys4/76nxvFBG1wcqJt5di7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAb+3tsSbmMowOGEfjNNDzAoIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDYxZTQwNWItMTc0MS00ZmNiLWJiNTMtNGY1ZDBkNzlmYWM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1NjI4MjkxZC1lNzk4\nLTRiNjQtOTgxMi0yNDJiZDE2NWQyZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARoohVcS3dhUsOvTw5+eG5WjX0KFDXtz039Sw1c9gOwnJVpch9Ct+GwzpBLFkG9\nLfLSzH7rGalMw8OWjWl0vIb3o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTCnb7hVhsMA9kb\njDCDdw71NSbH8zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgefua7QQg6YpPvB+YpusgluNKcYGBZKlcHsFJei8bdPEC\nIQCByMsIhZ0wPLfjIf+Iwm07fPt/hNnYDxckBXq7CfRxbQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7978", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7978` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfSgAwIBAgISAf5hz2JAwbGP/uc5tBq0tKLLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkYmU4ZmQ0LWMzOTYtNGE4MS04ZDBkLWIzNzE1MDlmNmQ0ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDc3ODQ0MjItNWQ5\nNi00ZmU0LTlhZjgtYTgxMzkyZGE4OTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkpgsJQ653Ej1rEmxfV9p1i3SBm1lCpYlyUUmQZ1uendEVPxDkxpRjf0530rH\nYsWufrWJF/oWdUcbYZI8zEyoT6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6TMMbZ/4c9TttKOVvyaetMMZFa0wHwYDVR0j\nBBgwFoAU26w5QvXTfm/VL2FYkvGdw0Pm3McwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA\n41pG4YQcsQd7UxIaPSV+sJlXENYnPkuavVGUekK3qgYCIQCK1/3zh9MHALvC71F1\nfHqo2ninNlILonBAt+fSJ1zozw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXxUCYC87dEPeDZuHgUEukhpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGJlOGZkNC1jMzk2LTRhODEtOGQwZC1iMzcxNTA5ZjZkNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmt2BhH01jAZPKH46n8Ru5AkuFTU4jWrGI3KGbNZ/UaEep\ntstIDR4eMsnaFm0hYmy5IeGbVLPB6GUcJ/1WZlXuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU26w5QvXTfm/VL2FYkvGdw0Pm\n3McwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOyuNxU/NSiu8GW0OHZV3XZPYuSRbqGCsdfOVBMZJOZwAiBDkIWSFMym\n44GPTOe7puT795QGzvPMPMls8Pf9K+ixpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAYdd1WrTim968XtVf8F+BzSjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDc3ODQ0MjItNWQ5Ni00ZmU0LTlhZjgtYTgxMzkyZGE4OTVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmMmZjOGQyYy01MTdj\nLTQxNzMtOWU1Ni04MDZkNjBhOWY2ODIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR0tGHl7mItRrErW1OdOQVhZzB3PNppcR+BD3uIoauqAumiJhFd1jUiGs2/aJwO\nQVfQ+BWdzpkT9jjhTu42N1/Bo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTpMwxtn/hz1O20\no5W/Jp60wxkVrTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgakgeIcRM6Yg/+GJL84pDBzybcBlmCr+Hz9W6YLg1U7wC\nIAXie8rEFp1kg2UHnZdVqo5XySP8dKDWJqzMBT78B6Wf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7979", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7979` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISATFHz0YkeAGJNNr27TXny1ZGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZTcyMjUxLTAzNjEtNDE4OS05NzU1LWM0MmYwYzM3OTVlNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI2YmE2ZjItNGNl\nNC00YjIzLThlMmEtOWExMTliZmZkYzYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6jSo0Qv1P98kyhPCEtzOkfC2j7ZfJ6OxGPzvOHJ+0En6RrCTX94VjP4oaKPn\n2DgXFGnQBpQ/D/53uL2dYye6BaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnzen2hr3MLIEzXQ537oh8w20jIswHwYDVR0j\nBBgwFoAUJNJPvMuQIkGLNpcLmxIcZTW1QuYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAn1tqsh5da+IYr4g+rvcuziMavw/fKPRbq2otT3sAp0ACIQD6\nvuqnbh6cku2WKLxq+e0Ylz1Gz41QOHcYTGXXoP9i7Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQnT0Z4DjIhm3plBnFHf6WffMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmU3MjI1MS0wMzYxLTQxODktOTc1NS1jNDJmMGMzNzk1ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkTKHeIEn8qcRGTNWvN0+sQISXxhKMniSieR0zasvsvsoL\nwtWfzgAlr150qFF1I8QIAcCH8h/wt/SW+HHv4Smvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJNJPvMuQIkGLNpcLmxIcZTW1\nQuYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANvhKynwUrFM3nT0N4R5VyQ3VYKYQUwisojZOGsUDnAHAiEA2/HdjkBq\nlPlOq/DAwlJX6TQOnpMepI8HCfYzwNzIeSg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAXCME+Nybh+SOwoyEhKzZWYgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI2YmE2ZjItNGNlNC00YjIzLThlMmEtOWExMTliZmZkYzYxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzM2M3MTU5Yi00YTc4\nLTQ5MzYtODc2Zi04ZGFhOGUwZmQ2OWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT54KS2rhsVPIDWJyVAGnbxhUIsqybk8w3LCcnB3hO4vY7t7HNvoLHUk9HNJzVH\nJMXfL7JbrdLs6mCs2QWet9Gfo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSfN6faGvcwsgTN\ndDnfuiHzDbSMizAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAJeLBvgYkfHCO3sxChmGLvgj9TSm4qLaye5tuH47/Xpb\nAiEAnkQZEmLGmm+KT3GVs0i+VIKVLwsyD533KRP3dfsynXk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7980", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7980` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAd+36mEOhPmMCF8TO7AbojtkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjZjRhNTExLWQ4MDgtNDY0Ni04ZmIyLWY4ZTIyMzExNzJkYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg3MGNhNzctZjUx\nNi00MDk3LWExNzctNzkzMzhjMDE0ZWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgE6UcF2lZBPA1W+L/iGoWlseAo8HB8hLIigzCM2prO9EUBAbTHXUvOVazBxU\nBAAzrswQocFP1sfI6q/FuHlhIqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlewAz2/nwe0GXviShuo3Naic2GEwHwYDVR0j\nBBgwFoAU7Z6A29VkCRhV6/Z8GV9dPaIIuNwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAhGV27DExpDtkRkVKZ4LfNutDugPVpVbNvIJweeYFkYUCIQDh\nLojYbrpc4Z9v27DWX6JKFr4yRz22abahOKrV4mgE0g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAakH7LkcoonCTSvRnlv4LaIQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2Y0YTUxMS1kODA4LTQ2NDYtOGZiMi1mOGUyMjMxMTcyZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATh+C0Ej7oll5pu4ozuxqrGz9ttsObzt/oo/Gns+5gjpp+s\n1wJze9zeBTEuHUMN0xyEl2u+uX18MEdc/H1hXB5jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Z6A29VkCRhV6/Z8GV9dPaII\nuNwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIC323KbpHHrKkU8l8E9XzFjBVcu7h7kTP5UDdvqEk83AiAQlLjczK6Z\nro3kxexPdEKmmC2h3K8VsP8S3rWxSvduQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAf/OVgZSkPcOseH4Lz5+0Z87MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg3MGNhNzctZjUxNi00MDk3LWExNzctNzkzMzhjMDE0ZWFiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0MzRjNDkwZS0zZTVj\nLTQxOTAtYWU2OC1iNmM4NjJlZmQyM2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQu7A2hKRU6NA6KSbbEk3OD+Uto/ekWK80vHSGgAeENg3GnN4wby2ZCWiKDdtVS\n+xxAUUftUVP7W/MwUUszhvoNo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSV7ADPb+fB7QZe\n+JKG6jc1qJzYYTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAPuSb2WWiY9XTywmZDljJkvidPh2Nmr7fj5q5NsWnnK/\nAiEA845l30MqUdy1D9i/aWl517p3u42mwdte2Ym1Yp57G9o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7981", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7981` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAYNwT7/RQKio0iuy9wYf5tJpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2YjY3MGZhLWFiN2EtNDNhNS1hOWY0LWU0YmJkNTdiOGRkYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQxNjhmMmMtMzE0\nMC00NDNmLWE5MzQtOWM0NTNjZTE2NzExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY/vMpbDGUwRYsfjt4193JNt/H4AZrxv+O5MeC/cVBrgHI90cVnF3yebbXy+O\nPK63dz7Bo0Is1Fgi3GhoBDTJLqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU14vtnpX4Z76R9lLciklYZ1vfZq0wHwYDVR0j\nBBgwFoAU0kNX1gwL9MmInOgjDq/O976fQ/QwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBwHHVHxck9h8fz\nXCLwYqX9qj3v2/HsU9FxhZNzwDNuewIgMwlECeQR/BNO+9C6p867UTyZP7J9RzOz\nOUMI5p8vZRo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAffyjWUpWTfWw70Rbf628UgMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmI2NzBmYS1hYjdhLTQzYTUtYTlmNC1lNGJiZDU3YjhkZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASirKqML56HGPNCuls/lxIHVYvQ+65AKU9r0CZ9Az3W0ww1\n+5TJUbKBhUvPHMEnMQrndkyD5LajaQiUrtSIe5CRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0kNX1gwL9MmInOgjDq/O976f\nQ/QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAj+aAsLyoKdfv6B0Z6Osf3WCHcsf0xA1+bjbEm1ZersCIQD8s3zbt7bL\nN4dyJlO9qKf+hCDBvk311Ov+5Q0REWXfgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAasbVchwj+DNpVlh2UrmzCTNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQxNjhmMmMtMzE0MC00NDNmLWE5MzQtOWM0NTNjZTE2NzExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YTM1Yjc0Yi1kY2Fj\nLTRkODktODg3Ni0zOGE5MGNkMzdiMWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ3cO9Z3g5SE7/Gvy/MLopJzJZSzyNG8g0mPWQpv+HT/L0aRLRfI97S5b1DNSyb\nhY897w6u2s/qNPhrFYZ8+kBbo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTXi+2elfhnvpH2\nUtyKSVhnW99mrTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAPsM7QQn9lLt9M+lbnWv9bAQ3hoFRvQbl0LB7qkbH9oX\nAiBFV6J7MtGElPFCEgs9Awg+gsy3zeItQK3aEGM6p1LnsQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7982", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7982` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAZ90xZmA6rCZkUIaCWxXtLKQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiZDAyYTUzLWZkMjYtNGU1ZC04MGNiLWUwZTYzYzhlMGZlMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRmODE1NzctMjJm\nMS00YTUxLWI3YjQtYTJkNjk2YjA0MjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx9HLT8M1Rel5ey9Qi1L712gG0Tv9buX/+whADtOUOtBufp8Z2LQewro1r6bK\n0gv/+nQ1bwT09wyXJqtH55XFH6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw5aAGBT4we15H0NYWGFVC+1uwdkwHwYDVR0j\nBBgwFoAUCME/nf78frqwLMbH5CJmhHuDe3gwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQC1LYB0MG/l2lCc9gjgbl09zxHo/CjhAglM6UiUOsyptAIhAPWT347Ik1ro\n2L+qW6kWuVQh7WZTQE7gTgZjq5GPdxY2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUgJm93Kh1BMpq2D+mkcdQYpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmQwMmE1My1mZDI2LTRlNWQtODBjYi1lMGU2M2M4ZTBmZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4IUPutJZMNWcI1ehKuBEzHwODPuBC/EMdC9rVwWXBy6aj\nMI0uXPyG2Y+GmOXLFnri3fACZqezPUOYDEiCsNiqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCME/nf78frqwLMbH5CJmhHuD\ne3gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK9Xfw92ybrYrhgX1wqIg4R7LLHFPymhj2U1YQsrNOGxAiA7Rpf/UT0A\nlbkNWTFlMBI03sWA13P5Jtfhs3wBvPKzqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAe46RTAuE7D8A1oPWIIQdzKLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRmODE1NzctMjJmMS00YTUxLWI3YjQtYTJkNjk2YjA0MjYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZjNjZmI0NC0yNDI2\nLTRkOWYtOWY1Zi1jYTJmZGJhM2U2YTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASW8g5VANghX5sfu8UCsHvq3+HHh+wLSMD2QqYT7MFtkDfcvu7exEDGGOIBotJx\n0PDGgIoD+W2n91HPweNSzUwco3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTDloAYFPjB7Xkf\nQ1hYYVUL7W7B2TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgA9ArKE0JMlorjAyopYnK/pFQJ3cD+FlISQUgKXgh7UQC\nIQDZoK6OycEU2fvI8Rfxp2cUJqaWJ+S8ByBTNyWFoiGd/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7983", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7983` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZq26/B3KbS0jsFwYSK3MESSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmODk2ZDY1LTJjYzEtNDE4ZC1iZDZlLTY3YWRmY2Y3NjgxYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWJhMmU2MDgtNzRh\nYy00YmRlLTgwZGUtYTJhNGQwZTkyY2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn8us5UlVb7bD3p1BTJRYAGF0md7XjRIuSfp7+tLnxNJc7Oh+IuOePfz/ESJe\n+LNurMPJPKugGG1n6s+NRz9+hqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuPFfM1ok9QeNIgXWOtYc3oTfnH8wHwYDVR0j\nBBgwFoAUZqwr34aRL3d6vpSRnw1k3HzY83QwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHBngUtY/52LTx85KyGi4OxtBtVe1cJl0uucUTC95iP6AiBb6oyW4U9NUpyP\nydwMYBjpPqdI4JZMseTx4cNNctyQfw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUUh998+Fpzu3BgBQnxOWvkhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjg5NmQ2NS0yY2MxLTQxOGQtYmQ2ZS02N2FkZmNmNzY4MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJiUEOp12sCP6Q++6Y6Cma1or7jvJ6fASrSZn7Vr5XL8D6\np0hEVqmqbjxexdTzrABupT/8tndUyy5lfocF592so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZqwr34aRL3d6vpSRnw1k3HzY\n83QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMMEDxgm5Jpexw1o0SKP3BWH88gJtKGxD3m1sI3c2blRAiBk05lpC01J\nxyH8t61r8evsNDBplYpADCFs+3QI988WzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAXfE3M8doM8g2IQlZBLqDgtAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWJhMmU2MDgtNzRhYy00YmRlLTgwZGUtYTJhNGQwZTkyY2VkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3MmY3MDkzZS05OWJk\nLTQ3NzktODQzNy04ZTA1Y2Q2MjgwMjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS/gPcP8Bnz7IsHb4jccPhU7pHUMVO8/jZnNagZvkIRuFo5pSF/wsnIXjE2POQS\nCREybzJV6xd2rQKx+bNll73Mo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS48V8zWiT1B40i\nBdY61hzehN+cfzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhALTDNyB8xLTWyCGpCN5bG3FuDJoheEY5+Zb+XP26XT8o\nAiACYaC+FHdkxTAi3bKMu0SiaWTGLV/cqTxc9OWCD0VGAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7984", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7984` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAffvuHZucSM19WZzzx4LCnaQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3NTI0ZTgxLTVmYTEtNDViOS05ZWNmLWFkM2VlNWYzMWUwYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYyMjRkOWQtOTM4\nOS00NjhmLWJiNDgtOWNiMmM1MTQ0YjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM+j8P+RTPaz7mUsH5VUjjsniIYHPogenafmInTjc0n+7fXBT7C1g6Ww29mAQ\nzJZsnhRVOF0N7FgLVA6EvahjAqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+jGl/yVA5AMVOggR0pUf3qLi2ZowHwYDVR0j\nBBgwFoAUCkmkwkGrQvzU/Sq3vRz0pKxIPt0wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAIyqalYroGRbGRGyTh7+wDaKjmBD1bAh1yO9BifpQlCgIgNo+KjfYn2VPK\n1L+nJCnymBHm8VAysaesaAF7oE9uZTM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf0q7nWM4hTK4uW4fE3eAHHvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzUyNGU4MS01ZmExLTQ1YjktOWVjZi1hZDNlZTVmMzFlMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUuDxey5S09f2Y+Qzn4xgv6Yd56cqy0MvS1ibqvOehOGcP\nJ5BQBM1eecGzrkBoqvW6jTSQv/YS5oBY92Cqfrpoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCkmkwkGrQvzU/Sq3vRz0pKxI\nPt0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWYVkwmyv1bDNn6kTLYO9to6yX0rWat0nC0mOaEn/ah4CIFIenXGD2qxK\nenUJN6vCjqyGok4Ftt6GXTEEcAnrah7I\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYI1V0ez6NLWrjDu7Tv7QZcjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYyMjRkOWQtOTM4OS00NjhmLWJiNDgtOWNiMmM1MTQ0YjM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ZjQ2YjIxZi1mNTMx\nLTRjOTEtODA5Ny1hNDZhMTFkODc5ZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARLb9YemQj7jlr6ayzn0EqP2FyE3c5Wj7Vr0f3CRiQ6N8mpiqNuRvoCUADs914P\n/Vkmu4KmQqdeHy5F4jQgzH0Ko3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT6MaX/JUDkAxU6\nCBHSlR/eouLZmjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhANFIJPXjr5ItFMbq4CL0Q0n3WpIveqnE7TAgG9RG9Pw/\nAiAsMqoV70CHE/nmhhW5dYuuS0EmTpi+gTic+oxsi4S5xA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7985", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7985` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAdLt3b8tjpUt7gPYj3DNCt0/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1M2I0MjA4LTQ3NTQtNDM3NS04OTI3LTRiOTBkZjcwY2VjZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY0NmJhYTktYTBi\nYi00M2QyLWFjNzgtOTMyMjRjYjgwZDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6yV4pBoQrnIbfwUjiYS5R966NTkQBPFxItE/ns69bb8DBNaZkRV36yiE91p8\n/6YnHPi3lsELwcZ/Y6sH/A2EoaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyKbZdYj3DpC6ydkw0NeJI0QQnmUwHwYDVR0j\nBBgwFoAUr/MO1+UQST85toJ1V1Ah434G/FkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiANgEYMrmYR/h6o3VCKFPXYGBUxNoeVFP7aKKhxVbjk\nHQIhAOEnNJR8ya7HgsuHZa8xgqkIHN9AGpFat3vSFG0Z7O27\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQTlSt5acW6OrMZ5oOsydsA6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTNiNDIwOC00NzU0LTQzNzUtODkyNy00YjkwZGY3MGNlY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQ18BMcXlEXmTpCN4mSBUk5tW5G1K+1ii6aCHOOmqFBvhs\nH8sllB27hgznibNmZrNQTeZ3hv7Z5GmRrSlysCFdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr/MO1+UQST85toJ1V1Ah434G\n/FkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIM1vXEA2OL4LQWR9B4+b1lPqAwtDJaGI5r3DhQaKYr7AiEAgXeo5fu5\nvjmuH2F//FXT/fmXeW+mi7a634e/JbiuqPc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAcDuPvA3c5J0F31TSCCN/BPsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY0NmJhYTktYTBiYi00M2QyLWFjNzgtOTMyMjRjYjgwZDIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNDg3OWVmOC1kZTBk\nLTQxZTktYWEyOS00MzQ1NGY2YzE2NTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASTlSA1XgkJfsizbfEDhmZNGF9rdPOaLsn9DKPTt3J3w84jWnCuD2HeGuIoInel\n6P9yoy/yqpkC4Q6wJKZ6bLHLo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIptl1iPcOkLrJ\n2TDQ14kjRBCeZTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKZp2aDYPMhynUi9euoKsBmCtRKXyzNdPx84jPNqves3\nAiEAo3qSm6kn8fy1lk5krBlD7N9ErYIRynxesZ69mL7y/xQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7986", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7986` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISATA+2tGIkg/F1gTlW24+ojqGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjNmJkZmQ0LTdjMGMtNDkxMS05NzY3LWVkN2UxNGMyZGZkZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTYxNzdhNWEtYjhi\nZS00YzIzLWJhYzUtZmI5ZGFmMmFmOTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFE+G5tRjYFsY+LuKjXzH0Tcw064DcYdmQPFg9hSPkU64/PfLzDvkr0ISQLlY\nZOpvcWZOxTKsaN7McP7gUBMeLaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNZLvAql/ZT29WmjRTF9sK3tsqRAwHwYDVR0j\nBBgwFoAUF+78paIg/DGhhb8I6H2XoSvXOeAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAiNUSxE4MV+3QSOQklaC9ikFFbesDHqXbjyzZh8OZ\n1p8CIDS0ZLa5Ync+Q1eTXAkWQPleqRD7Wf1q7jgX0ZEm2dtK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAelIpcZTs57eCJl2NOB8/lLFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzZiZGZkNC03YzBjLTQ5MTEtOTc2Ny1lZDdlMTRjMmRmZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOFzP6w/R/Imk4LQlgrIz74NgqrjF0mfFGMv2uVM2didYF\nGmA/bGkyF9gUeIWXJ//Rqv0Pv65RKtsRucVVUwado2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF+78paIg/DGhhb8I6H2XoSvX\nOeAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUszOLSM4+AgGFUX4YMMKITkhprgixqXAQ6dlpX9EljwCIQDtjwuWeqUF\nxNLjMIbEHLnT7dBn2e7TdalabZXFtx3thQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAc/esVRnAY/c1UwPtS2OQVnnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTYxNzdhNWEtYjhiZS00YzIzLWJhYzUtZmI5ZGFmMmFmOTYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1YzczMjUyZi00MjJj\nLTQwZTYtYWViMy05MTZlOWQxYTFkNzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATzg1SldyXzQY1hpLXUo8Nzj4uwdmC5Red7bhYJ8RkHvPQ5h7KZ2fmUAAGYdOcx\nFozs2uGgFJ/f5kUcmuksdFzBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ1ku8CqX9lPb1a\naNFMX2wre2ypEDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAK77EjsKf5vFE+AU8zyQ/Ux1sRcAL+VcCNaxiE7pQeXh\nAiABeSx6hpPma8ytYm/rq+pOLNnm1lHi5w0uzY1WUJKhfQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7987", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7987` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAe2CTQEXDPFL7paA8Su1ht8BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3NmMzMmUzLWIwYmItNDY4NS1iODE2LTBjMDc4MWE3ZTlmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODc0NDRiOTktYTJj\nYi00ZThmLTk4NGMtOGQ3ZjFjMDEzZjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKMjgQE73P4bSFCZ/A0LSCnA7g2ja7XwUNmOHUof4VqyxhB1ZOImhlnw93oac\ncJnSYChZGHMBIjfDXH/e6qZuRaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVjl8JTUy/sU6bQSYHm9pq7ggTtEwHwYDVR0j\nBBgwFoAUxnKLsWcYjvwu0s5MKJRMg7LFSxswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA/qUvdJpiQe9lNUN7S+FyaMeoMOiC81yR1OvikwqBk0UCIQD+\nXVb0KqL9McUOez99Fqgj5+PW2ByqzRKjaLyqVpRFgw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQANMcgOB0O2R+bi8a/1Vna8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzZjMzJlMy1iMGJiLTQ2ODUtYjgxNi0wYzA3ODFhN2U5ZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPrIgfzY/rKYWvN/UG1lIP1DCd9a+mlTC1vDLOUgNP/5nn\nLjmt2KapG5qLIhfOv+CLTD6OVzMPdM3STvc0z+7Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxnKLsWcYjvwu0s5MKJRMg7LF\nSxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgccMz/bU7BaEo34iMvqjFiWH5vCNN6XTIPF3qdlykPVQCIHozkWQadkkj\ni8wFYSkieYHSI/WHNHmY3BI/s2LjlzKO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbiVzgdiRGoXiHleqVedYufNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODc0NDRiOTktYTJjYi00ZThmLTk4NGMtOGQ3ZjFjMDEzZjExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5ZDA3YWIwYS03YTUz\nLTRjZTQtYTZjMC1iYjExZGM5NDRmNjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASmdZVIFFUn839UoH8wT+5CGpARvPDvxojc7Bk1d7SBxAtBRSh4Us1m5vcrfDqe\nxAoT8tHHRnT2HZY4XbWxN7Q+o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRWOXwlNTL+xTpt\nBJgeb2mruCBO0TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAKFwFLuAeBdDaC4VQlRQQI5brOjjGCsimURs7COIFSGa\nAiA8WRLnglx8cq0Z881AttsDtbdqv64HcsaXSOopFQYTuA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7988", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7988` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAZ0s6QoOgVm8ZOCUs5c+gOqWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkODljOGNhLTMwZDctNDJkMy04Yjg0LTdmZTJmOGY4YWM1YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRlZmJjNjQtZjUz\nZC00ZGNhLWI1YzktYzI0YWRlYmMzMzdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4G77clR8OhyENitXVLcq6woZ9StYDkgHq6sDh6PIhcspZmLbIWed40zlNqVB\nvWkRXQdZWZnM8R8arEq+ccqLGqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIflNMKJ/KLrZfBqVneXM5hpSBPcwHwYDVR0j\nBBgwFoAUvR0QRfzqPpkB2sUcjlnpHyx6HhQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBrXsoSUUXyUrpK5dEuKOiVEzLNOFA27bQ7\nB+f/sFpwJAIgAkqZvqDK9Rr9rjm4Qw7p+LospYhdnQ9AOlOLKbTiJpg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU/APE3i1DrCBF2lJBU9Y0ThMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDg5YzhjYS0zMGQ3LTQyZDMtOGI4NC03ZmUyZjhmOGFjNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQy93+dHJmSoxILdL9GwS5AW5G9bd7UXrIQ0GTIHRbEH7Yv\n5DGmMl/Th1OK0Xinim2nR79PmV+OjPeAhEQeQe5Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvR0QRfzqPpkB2sUcjlnpHyx6\nHhQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJQaAPPKJ28Q86RJG4arfpnuFQkm5mHYHSesTvvKZzNzAiBnIcR7CRRD\ny+MSQ7SLGMYNt+vsdpfgXAkK3kHbuNIUsQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQyvxFG4ZlQyhSZDhcZzppmnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRlZmJjNjQtZjUzZC00ZGNhLWI1YzktYzI0YWRlYmMzMzdiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzMjAwZjRjYS1jNTkx\nLTRiNzMtYTA4ZC0yYThhYWViMTkxNGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ6nr/w7Bt5drN3E0Ni2khu1T8EnKpT2gHpuGkJIWUBVLD/uUaG+4EU0eru6DeW\nY+Sf+nEgnUnro9s/bWYWEHN0o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQh+U0won8outl8\nGpWd5czmGlIE9zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgD2Zl0/gfETI624ZTThn/4EvIP2D+399moZC5LygwMZAC\nIQC96cza0DOeN5BPFPRmQYQdrX1NrBCRAfRdJoze/mVqNA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7989", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7989` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVm7FEvrARzdWjYk2aH6IS80MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwOGE1NWIxLWM2YjMtNGY4NC1hYmZmLTk1Yzk1NTNhNGUyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYyZGFhOGQtMDZk\nNS00ZjZiLWIwNTYtMzY0MzYwN2ZlZDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkZuudaHBHXU7G1uVub1YyG+m2g+tnDzwRXEr0BoYzkG7hVKvnov93ayagjyh\n3TsJAnF6nD3Tu0TZsTBk5W8JrqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7N294Os9FsCU4KLourgXyJ78xzQwHwYDVR0j\nBBgwFoAUZbqQ1K9pPNMJQ5hCJ0CehrBX1JYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAljAmjCOhPjN2HY9QsfBLdqEV8HALAujwB\n1C3xq7QI/wIhAKU5WTIc7J+RuUi9qcAW2LY/gaxEEztmCcnWVyCV7RxP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdfA+XlhvVW39nC/C6CHr+RoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDhhNTViMS1jNmIzLTRmODQtYWJmZi05NWM5NTUzYTRlMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARI5JEkE7tCuXWTf3AmLow4Kls38NpHW2g2rKl7UonvDQwe\nF6GofomaYVVomKnccKCzm32KX2HmU2muja4HcjW4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZbqQ1K9pPNMJQ5hCJ0CehrBX\n1JYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMN9ksncwv1OP8GwHug0CelFV6VeYkxwloF8JVb/LhNqAiEAkvRRf2eu\n5/ktVlYc6yBBiN85KcMW2HBu5s3Y0VQAYaE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYBkWWLnJbDMYP8GmQhFeLIIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYyZGFhOGQtMDZkNS00ZjZiLWIwNTYtMzY0MzYwN2ZlZDcxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZjc1ZTA1NC0yNjNl\nLTQxYjItYWVlMy04ZmQyODJjZTFmODMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQj6krHkWHJ/XOeCHKwxJcGOBJyxbzZNG2gh2Do9XdQ5A/Y0wMTDX7GBCmoDgtn\nRqCKMBBnONBt1RHkKA3gcYBFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTs3b3g6z0WwJTg\noui6uBfInvzHNDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgakcGVA9UU/MCmR6VTn/aN1iEUcKlt92Gm/kYhLYVNeQC\nIQCDPAo43LOaK135qvKF04NlQbbtf2Hwh1YMVyoylJvY6g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7990", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7990` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZpbtG5sUd4drd9c0WBkGV64MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4ZDcyZWI5LTM0ZjgtNDkzMi1iNTZlLTg5YjM3ZWFhY2IxZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE5ODJkNzItMDMz\nYy00ZjI4LWJmZGEtNzI5NDZiYjk2OTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZQc6ts9CxWgZgPZcNw6lNIOP1l3k+4Pnsqp2xea3BkLsjGcPWk7t72tDMfFM\ngn9YlB/7ogK9hLcKPnQmTBXjrKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlwNKhEW8z/Uj6i6AaZy/DB/BQN8wHwYDVR0j\nBBgwFoAU81KSHfulcqWZK20ZEchT5vkuVBEwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAqtilPyevW0kNj\nicz68gew6VWU7RrAI2KLdwioUBr1cQIhAPiNMyPevvg6qvJQslZt+6R47GY3Cgr+\nsdDCdyUd/tZq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU8+nXlkqESXYmnuaXlrPtwwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGQ3MmViOS0zNGY4LTQ5MzItYjU2ZS04OWIzN2VhYWNiMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASszRzDbbN8FW5/P51peAONljge2Fd4BtxI6xfpuDPh37eR\n5dhpFM4GK9oqWCCmV1JXCScBzT/Lked6fQcjtKWro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU81KSHfulcqWZK20ZEchT5vku\nVBEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbCaa6tgsgFzBsv9YvlzA1lpNGlYSOO1rx6ktSqYKxGECICxQhLLRLJce\n7sRXvwhQt8XQAuJKXjnkLYdNPpWmRNOv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYXf4kugUbrLogybpcIz9KpbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE5ODJkNzItMDMzYy00ZjI4LWJmZGEtNzI5NDZiYjk2OTM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkZmFlZTNiNC0xMmQ4\nLTRjZWYtYjY4YS1kYjhmNWEyYjNlNzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASJtFfhv0qAAz7ML4JKg9x0MQ0prQOSkdpPnYv14xx1SF0dVoDj3j/XOHx3EqHb\n3eBh8kAHDedgd6QToSlThe4Fo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSXA0qERbzP9SPq\nLoBpnL8MH8FA3zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgLtWP6Vss96wkAonWRqN2fSXjW3GZm7waf+tLLzFJTnsC\nIQC61ugTH4ET6Uq7w33SYHV4ez366+8RC7F/v8f/4Cwyog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7991", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7991` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbkoMQc0CC0UXwSTiXlmU+fuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjY2E4YTc5LTRmMzgtNDRmNS05ZDg1LTdkNDc4OGQ5MjI0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMThmYzVhMjMtZWY4\nYS00ZDYxLTk5YzctN2U4ZjQ2NTRlNThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH6GFiE5NwOkCUK1gYDsw/MC1hj3FG+tNaZT6zktObyp00qj6GAVB7L1N/+fi\nPNDV71oZyBH7paYEa6HCeXbeTaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt62L0oE/oCuhG9mJfZ+wC1Cn2KcwHwYDVR0j\nBBgwFoAUXn3L11kRzt2S6DbYOtTc1YWVtTswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFZPJ1nr4twd0smS1dvlsNKQOePgZJnmezKofK+1CB4VAiEA5BFaJRI1vjFl\nZji/Y/hAx0BGF4f8to4iKKLQIzIfJEs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZFxODlwVagdNp2KUTIRiJHrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2NhOGE3OS00ZjM4LTQ0ZjUtOWQ4NS03ZDQ3ODhkOTIyNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7pcOpKPuiOz2zqxH2vE7ZuKdf0KOGz5pImxUyH2CctsJH\niAJgGnZmKfxyII1Mj63wRVR7DnbAa/ICJ6wRXFD5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXn3L11kRzt2S6DbYOtTc1YWV\ntTswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIHwbMvWZtqcMdydtlHzvnE468xEiphrPPOU22KYlafgCIQCC7kxWM7E9\n1vLEWszlb0Uss08ovpXDUl8DGmONZ3UKWA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAWxJbi8o0Mm1BJcU8/4e2+tsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMThmYzVhMjMtZWY4YS00ZDYxLTk5YzctN2U4ZjQ2NTRlNThhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwYmIxMTViOS00ZjAw\nLTRjN2ItOGI4OC02YTk3NmJkZTQ0NmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASaL1jUMyHHf1xmv2iVzdeMR0d9h6ci6ln4WquFtP7nHiY98T9rFlMMfgRtxQfl\n0h442FoChqZw3QxQdf/L78eeo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS3rYvSgT+gK6Eb\n2Yl9n7ALUKfYpzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgCJ9HTOdzZyDIZ16Wzge+hN+pIwOPHtdlRTg0TOC13+gC\nIF7wV1casf8hUju8K3Xwd/j8sjADxvjXqNeodUKiDV6H\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7992", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7992` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAb4aC4ZTOkYq2kZLIlcgKa7KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxMzEwY2ZmLTYxNTYtNGNiYS04ZjUzLTQ0ZWNlNTBiOTZjMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQxYTI1MmYtZDhh\nYi00ZTYzLTk2ZDktMTQ5ZTEyMmM1ZGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi+cKnMajUgmhmt+MSm6ThppD+EL5AxI8kXKuqADVTmQsKDk431wBaawkMkKo\n1uSnoB+lhIUXAjhaiq1M13omb6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2pSTdUUw61Bpz0PnMtWWRnJHyqswHwYDVR0j\nBBgwFoAU6QQ5ugBnd/ghC8234NfYLtcnLGswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDTMZfzLsollEHV7ehZKsS+w1FeHT5y7T6G0U1bCojKLgIgP5PKk0J5zkWr\ne0xpddFDCT+S7SrP5bCP2/qlqTXEWr0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeZnZSjhTCILOHE13aJD0U1UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTMxMGNmZi02MTU2LTRjYmEtOGY1My00NGVjZTUwYjk2YzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASragPESt3m9Oq9fRBIVSGXavnHAKY3lL9SpH4QC/hMDJoN\nlWF/DlmYCCYsLY3/X4kQG8BVMWUgF970/l3xbXFpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6QQ5ugBnd/ghC8234NfYLtcn\nLGswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM5BEdD4sEf/swZZYG737Qa2Ohk1bQsXDmHgScLuxY73AiEA8jjG0NdP\nU0XMCgujj2LoNDnKRO4qzYwjQuTCREv550s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAUbqVyM5GrJlKSCPr9ARXtNtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQxYTI1MmYtZDhhYi00ZTYzLTk2ZDktMTQ5ZTEyMmM1ZGE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0Mzg4ZDhkNy00NTc1\nLTRkNzYtYmZkOS01NjA3NzI2ZjkzYWIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQvmd+wYoAk58eKAqrAYajeItj0GlpVqv14o4phy/4YDguY51GzRYB/2YnYiRcv\nA03lqDltNVdjd0d/GJn91sE1o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTalJN1RTDrUGnP\nQ+cy1ZZGckfKqzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgX7hF9IhNJ/UcMPo4uioXPThIUBJCUXkX5Nlmj3pXhtMC\nIB3R+CNz3kdtnILwCMJKLjrxP6bGG88mmoPujsoDFgzH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7993", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7993` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAYXtJX2Nn6RD2y8bdWOWs/mdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwZDA2Mjc1LWEzZmEtNDNjZS1hOTY2LTE4YWZjZmQzNDdiOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM5MTlkMDUtNDlj\nNy00MDE4LTlhMjEtYTFlODhlYTFiZjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMT7i5qGhe9dt+A9KNE/XZkiQCfLjhsnTm9siko+vw+EvwwJT1v//NPCVGK43\nkWQjaJmOQdZ3IuYfG+iw2V3kOqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpgT7RZS7PGZf8UTfdZSWYDWTIXMwHwYDVR0j\nBBgwFoAU7C5LwzBiJ6b9aVcWAryDpDLOaCIwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA19epwPDUda1M5IVD3660LKIopPvN+VLsACX83Yp6KVsCIQD+l/nFcVpr\nQuuemAk4g+nffL6F5/PSKzERk6JYcfA9Kw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeSzPt/FKXjJLXr5/vEzmB2oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGQwNjI3NS1hM2ZhLTQzY2UtYTk2Ni0xOGFmY2ZkMzQ3YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+Pt6yip58+yA9cnnLl1ypIK95B92u7dx3CJbeC3smj6rD\n/RpAHfN0MX52KIpeXOtze7ZQLWiXvT25V2W5sTLeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7C5LwzBiJ6b9aVcWAryDpDLO\naCIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO2T/mTdnU/kR5SDzawOWsuE77qCHhv5xibmd+rQ+uMcAiEAy6V0x9vz\n+UA1L7cln3/GGXCrTmF0pd3agV9bPYZUXKw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAXUPVpwjBIcCzchL1uS7thp5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM5MTlkMDUtNDljNy00MDE4LTlhMjEtYTFlODhlYTFiZjE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2Nzc4ZmFjZC1lODY3\nLTQyZmMtYmFiOC1mODg0N2EyZmM3MjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQDm/dWVI7+rgNpNok31frrwW68IWbhHjPylyyQfJw02qXJt2v7RxlaKgRIfsFm\nKqQh9KaPJb41j/eU0c5nVkTKo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSmBPtFlLs8Zl/x\nRN91lJZgNZMhczAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgO+ZN9xTMIO62DZYGyvx80ZStoi+KBkTqrV1j7LkNuHgC\nIHx3rBL1gJ+iCeO+3JmSrucmGF9wA/MU6qXgAiMDUc2N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7994", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7994` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAR0pZDX01dL0vaywES+zyWTJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjMGIyOTk3LTJmMTAtNDk4Yy04NTIxLTZiOTlhMjQxNjdmYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVmZGE3ZTYtNGM5\nOC00ODE1LWI0ZWQtYzhkNTkzNjJmZjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoyXL/k4MMtdhCv6e0ra/Hr1yGT8XEc36H1MHr9wvda/hC4vLROxN1Xw0qdNo\nLcmO896HiV2DsdwjMI52+jyqQKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPZOcu0dsX4m8w26NtJEAm4HO/qcwHwYDVR0j\nBBgwFoAUuWePXlrOc8b4jAi8OjEfYr4q6MAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA31G2hX3WIp6TZ54y6DNinradC5QHyHBsSwxvs/KJ\ns4UCIQCj/G2Owv3LmimSxR+ttx1yA3+hWrCwE3/bra/tYd6Zdg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcZedXJzrt7PKRGHMAfHIiC1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzBiMjk5Ny0yZjEwLTQ5OGMtODUyMS02Yjk5YTI0MTY3ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjI++AFT0BGschNo3NzmJ4YELbRxbJP3iiEkNlJH8Z46mY\n1B4N4MZE4VES7WvRsl8Uwk67chqLtRuPVe+5GE2ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuWePXlrOc8b4jAi8OjEfYr4q\n6MAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJiI+02Zbycw0TOanhyFCYIFMptH5uA2Bg8FeAU6n7pmAiEA5eFziEDC\nT/Q5DeQ+0Dj0/9n1una+Q0nxfvK8PuATMCE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAcaanIU6k2aUMKJWd+RgV0c9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVmZGE3ZTYtNGM5OC00ODE1LWI0ZWQtYzhkNTkzNjJmZjU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ4ZGRjZjU1NC1iMjJh\nLTQ2NWEtYWVmOC1lZWE0NjRkZDBhNmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATEZCkCpcrEPl99cfUuhWWgU9HXVf8IC/i8tCi+4N+FEdbCIJsAZSwFAjihfbBH\nBhn38+uZnTiGX517QAnTQ9KBo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ9k5y7R2xfibzD\nbo20kQCbgc7+pzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKU5hDjD/D31c2bj/ySRzjFhf1ZYY0B80jbrwGrUNykq\nAiEAvFOFybG4S5oXMPhMTMJ5kmVussUZbOqJN9Zdttofoh4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7995", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7995` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAbM3Yn5QFFZdk1/bhFDhPOBqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkMDk3YzRhLWIzYTUtNGE0YS1hMjk5LThhYWE3YmRmNGFmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE2ZjBlMzMtZDQw\nZi00OGE2LWJkYjItZDEzNmMxNDljNWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC7RmfNDu/uhdM18Lp0qBmIZao/To6hpF+baMSTQo918RzEKAikPggX2DEMXl\nEhQU7Egt+B3lCLIrdaguOP0TtKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPwrgfVRbE9J1/gc87OJUGDT5QCcwHwYDVR0j\nBBgwFoAUI5w3ADErWtFDcuWnpFS/zVJGmb8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiA9Vp3TuWF5bboKm5lad741Yore1cdK4plhCGsAUK1B\n0AIgQyQ/ZZ3Hs3wkRBg1FFtrBcWT1csKEge3Cqt8mirSJiw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcrEnQtvNCjyCz8Rt1894PulMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDA5N2M0YS1iM2E1LTRhNGEtYTI5OS04YWFhN2JkZjRhZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQyfdqTKTr8dJrU3yui45vMBNS8sUunxEjAj6A2g8eI36n\nIFJD9WG7o3jta/geOq0e6wX//sUJy2Wf2v1XeiYXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI5w3ADErWtFDcuWnpFS/zVJG\nmb8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK+ZtbT0Tfknap9G06InIny0+2XN5su+hO+UR6cGvQ6ECIQDgFpEntvFG\nea6egp0js+xhlepAnEWFw7PWAWMVvlBq3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAarU6X6pzGKE27ubs8PIaKP1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE2ZjBlMzMtZDQwZi00OGE2LWJkYjItZDEzNmMxNDljNWFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyNGY5MDBlYi1iOGZi\nLTQxNDQtYmVlYi0wYWU1NGUyOWFjMzIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS+C0QkViTbI4+CFwlmtTk9SHZc+igzKe/gv0N71Yq93gMPBjYgu010HqxrtkMY\npVC/FV0JX2CnrpiXl/uPKzCXo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ/CuB9VFsT0nX+\nBzzs4lQYNPlAJzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgfGaIrnT8QaLT7HxynWxZn6qxOwMQfwLBfnqVz72jvQkC\nIQDrDBOmB38Qxh2CbE+f9qLT2ozIv6JYvSB+DPbrrPf7tQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7996", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7996` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAcgqgjgeZauMGrCKhCNP4K0WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NzllNjliLTQyMzEtNGJmMy1hOTMwLThjMjIzZWI5NGMwMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQzMWZjYTktNzk1\nZS00ZDcxLWExNDgtOGEzMGUyMDVjZDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Qgcqlt5SOEidR2LqHSdb+kE4T0dFhl/fLObUG7y17evDRkCNxP55cZsl37O\nlvWmfzYG8SHu2nG2mtDywIXMMKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURQjCT8ZlANQ/6uVvyvsxavwxaDwwHwYDVR0j\nBBgwFoAUzBTnsTxrAZR6v21vpLY5vWy96WowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA2W7/iD54A4K4f2GBT7qAlEIuJjJlwzmxm4FM5CI/FsQCIQDd\nu5qarwtRFeoFHRRQp+QkaAeh3c7HbGbLDI/zpIxEFw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYoVXeWZN7rSIczO9VFbatmkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzc5ZTY5Yi00MjMxLTRiZjMtYTkzMC04YzIyM2ViOTRjMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKCJXJREBDaM2imAv2wOH4w50XWclrXHfOrszYebJfmMNX\ncF6p76f4mv6dtabVOqEMJ6xHc9yQKFthsph1p82qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzBTnsTxrAZR6v21vpLY5vWy9\n6WowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPIsHhwuRZfWLFdbQQ+ZFepoFawkwed6RhCKGhEI/KEQCIQDOSz9BnNkd\nqG5X6Uxihc8L3bZgVXndo2vIVY4GZeHymg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAabD25UO58fsNJeQnOoAiS1LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQzMWZjYTktNzk1ZS00ZDcxLWExNDgtOGEzMGUyMDVjZDgxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYTIzZTA4Ni05N2Qz\nLTRkNGQtYWMxNC0wN2Q2ZjY4ZDUxYTgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARJOmEc0DI99+9F4wiQZMhx6157h0ALV2t2C19AAGw2TvHku10QzrDhMh+qBYq3\nH9vBfrW8apUxHUA8Rg8A9/HFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRFCMJPxmUA1D/q\n5W/K+zFq/DFoPDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJpS2L7bX1fQdid5v3e1OJ1uHIPzK/fnu0goyGH8lXVO\nAiBp7aVkgMj2JTNmmK3HwV/RA9LEiUvNWcWeKXMn2eCh0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7997", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7997` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAU94Qrg/JHNA/AeZqZTvvNdvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4OTAyN2ZmLWViNDgtNDliMi04ZmFkLWVlNDk4YzU1ZjQzMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVhZDhhZGQtMDYz\nMi00OWU4LWJiOGMtNjFjNGMwZDZlYjAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzYbQcRVvG6ga5Htwq8ZudMWizqWlspKrnKUFVlJ5kZK09OQWkmonroXupKU/\n77rcIKF9sbWkQwHhmGrONPhQGqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvSDhr61oX2H1QslJUphEfqQ864QwHwYDVR0j\nBBgwFoAUrFKcu3iaLTzVIiwwvhfKGLxPtDEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBZW44y6wNHCFBB1Q4tYHcODZ8Ikh2AGLnt\nfUFOC9TLcQIgfMf+qeId+vvmsBZled1qzjUUcaFV+JN3CnU2A4OT4JU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZKc/bgpK2B6PitJCGZsR3pxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODkwMjdmZi1lYjQ4LTQ5YjItOGZhZC1lZTQ5OGM1NWY0MzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1LyKjJMXPHFY9/wwuOSqHFmFVh5L8wzp7UZl8rRpquCm0\n+IZgZQWPgAH3//6Mtj8LItV8i6hhnOuKPPFaku5io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrFKcu3iaLTzVIiwwvhfKGLxP\ntDEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY1ohARsRGJqI0YOiuRUpDiTFbKmrUKycEyy+Lp4OLqACIQCWa43+2wPb\nJCi0tVqhOdWfAfzKENT0NQq9Yj85RwXBbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZDWXNIuhX4sj+li+XulEoKmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVhZDhhZGQtMDYzMi00OWU4LWJiOGMtNjFjNGMwZDZlYjAwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2NDk5MGUxMy0wMjRk\nLTRjMDAtYTBmMi1iNWVmN2E4YmEyOTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASsDalyZxas9uzIgrvC9bNbQSvK9wc5rlXV8YOAuCveU0tdpT0PaMN+0MhGyHE8\nkJ1FEVSgnBbIO1lAixsJ+jhoo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS9IOGvrWhfYfVC\nyUlSmER+pDzrhDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKF7/0KknbaqlEejrQvNX3IwO2wJQAKTXj6CsgVDoLg2\nAiEAs3XFe+b2agulRzG3l59ZnRAieKNzOAgb3cnw4QaaC8U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7998", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7998` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAW6NDXBIjczB0kOGJy4QIvvtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2MjNhZDZjLTZmY2UtNGU5OS1hZDMzLWRlY2VhZDk1ZWNjMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RlYTU0MGEtY2Zm\nYy00ZjUwLWE1M2EtYjc1MDE4MTRjZDlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3Sr/cP5WIG5EGuBgRUP/aFooVMx89RKanTeeEcAWWsYDbznpFqdt0eGf8vX1\nWa77EyNnYbvOhyDBpdkfOa3WN6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmggHq8FH2FKW8ubyr2y0VY2UgrcwHwYDVR0j\nBBgwFoAUXzCMUlcjhMi9UGBDuyN4SserYEcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA+9rB+PPnGWU5Lbh65CfF7xzWCChT/HQq2\n2++ATlhX8gIgRLWmZKdbhZu/zUcRPKf8sLzTuVKMlFFbMLC7R7CmiPU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWcuM8KTFl+A1yw2Zt1P/c78MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjIzYWQ2Yy02ZmNlLTRlOTktYWQzMy1kZWNlYWQ5NWVjYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEkWztVlMupXogSb6TkFurd5zeM7Thqp9cI9GXgmQ7A6iP\n3B2FR9JdogwCDdAGbpdzIEsKgVbCj69afaWMpS/+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXzCMUlcjhMi9UGBDuyN4Sser\nYEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKmVLP2iNfWz8T+2//QsLPh3BXAcWiRFTCTVXtmgJlMxAiAwOGkDhUDj\nFJHV4h3RfcKWamY0ED5eB0v23dg/j2HCSA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISARBvh7DZbVmV0A+J0EFrz/msMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RlYTU0MGEtY2ZmYy00ZjUwLWE1M2EtYjc1MDE4MTRjZDlhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMzBhODAyMi1jNWE4\nLTRmMTUtYTA5NS04NjkzNDlhZTliNWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAR4hLumHoHTKER4hkuyg4OhO29TidNjpzqLlkDKFHa4iw2I+EaGd1yGCZyb4vyq\nWM0fRrdIOxX2P31lGOhsJBN2o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSaCAerwUfYUpby\n5vKvbLRVjZSCtzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMflGhZjcZzQrr4nOsem9V4i7BGxwuMB2wW6nn/0+S7A\nAiBy6OXXcVP193ihMo9JoqcHX0K+5oINlUhIc3xFixoRsw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc7999", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7999` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAfIXUwApu/xQC1hCazSecEH0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlMzAzMmEyLTNiYzAtNDk3OS04Nzg1LTYwY2ZiNDBlMjA2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE5ZmZhNWItYmYz\nNS00YzU0LWFjNGQtMjNlNDEyODljZTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER4ff4Oq7tFfDeA4/9rHmthFbaquvF/b6XBcpBh0rBQ3cBm6nQC77tlrLD9b7\nzEyjKQPEdCrxDZF4xbm+VD/fMaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi4WWbk0V8jpjMHVzAYX9MUOUaLowHwYDVR0j\nBBgwFoAUPP3sKRfT1GgYJKDWmDYp/6cRJuQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC95Bn/wU6iVrkMmCdWSpK8/Rdj\nNlDxdt9043Mj9q7fqAIhAIDVdq/HUehprLttq7oQjXH7S3zsA/HY5cy96cn3Wky/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfV81pPKTEoNM92vcdmZU1EWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTMwMzJhMi0zYmMwLTQ5NzktODc4NS02MGNmYjQwZTIwNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATo42tEUC8RMg26SORidF9jQHKTJ1+8zhidGZHkcfwykb14\n8RnI606DEeMFXiYpu/GJSt+Yc2a0M3uov//N6TTBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPP3sKRfT1GgYJKDWmDYp/6cR\nJuQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVE1UynLiXFQ51J1KmNh94fOZe9y0J88bkhjTvqkI71ECIQCYi4Bp7SqY\nv3f8vSKfxQtsDsJn8QxRIsMNXEAA9nkZJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISASRSZvqXDff0cxh/TGg6QoLSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE5ZmZhNWItYmYzNS00YzU0LWFjNGQtMjNlNDEyODljZTNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQwODkxMDRlOC1iMWQy\nLTRkNGMtYmY0ZC04N2Y4NmE3OTc2NTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASuf0bpQamE+nzRbYxsttb4yKnjVqg7DABy8DL6W+jkoep4pF55SECJGKT2CXJy\nsxoaNnBZrWjgwok1gUs8U1rlo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLhZZuTRXyOmMw\ndXMBhf0xQ5RoujAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAL5Qd/G8FTuMr8F3kcVSOQGgQomDffuYc28VnNR0Oq3r\nAiEAvkgoEOBvcfcuOJrx2WBjKZpWip0DI6WWvlzbRtXy7tk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8000", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8000` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAdP/RR0y+6KRV/XJoV7jO+2EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2NGQxMjc0LWVmMjktNDliNS04YWI1LTFiNGRmYTJhMGZjOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWRhZjBkMTctNDFj\nZi00YjU4LTg4MjgtM2QxMDk5OWJiMmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl4mIomZGNrBa/7hP1sf2t84gZTmHtv8Q0fvBBqWxqR/ontK2pB3Mhvzo5+sK\nYd9boV5yNmQfK8VIHrhv/BQAaKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULtQ+jHP48qZtAdDq4MF5rk4LeV8wHwYDVR0j\nBBgwFoAU/7PCENbDe/M2klYAkaQPl2/6HyMwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgFJPKF8z6\nt9fJJsqjcbZMuuETbjKw+6cryRSY049pbCwCIQCFzHEwlBQ7O3S4t1F8+7Jq3tKz\n/4dXsPTLYmHB9/sPYg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQrpdOsVUDboovi53DBOS98lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjRkMTI3NC1lZjI5LTQ5YjUtOGFiNS0xYjRkZmEyYTBmYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREvrH4rbydDtLnD6nsHDVQ+kREut5Us4KntHJvN/GapTEZ\n86lAMTBH/YqxVAn4RO4/Kpbz2/5dX+NHCx5bQwx2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/7PCENbDe/M2klYAkaQPl2/6\nHyMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALiN7Ol9/iMRPk1S7pCSkuyBVyYVxJ9q6VCdHpEY8KuUAiB4b02nue7a\n6JDzDOMtqD6L7KRY/Svr3yfEcvN2rcFjpw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdGT6lfKIghqR2UkyQziskHRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWRhZjBkMTctNDFjZi00YjU4LTg4MjgtM2QxMDk5OWJiMmVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ5YWNmNGVkOC1iNmJk\nLTQzMWEtOGVjMC02YTY3OGNiZmE4ZDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQt6Ht7b6ak1TO1DUgipaNXNjSTlx5dKRSYTSS1SGUPaD3EovLYlxSX9tNkWrMd\ne6lNjMaU6D3Ve2dS2mownSf9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQu1D6Mc/jypm0B\n0OrgwXmuTgt5XzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgZRTwhtinT7RLNvU7jtqGGjK5SE0MuCndFYbkzEXMpAYC\nIQC3OWWO8LJv+vEo2KEks9Ec/+ppVgwg9177ZgP1wk9SLg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8001", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8001` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAZ6diBmYtGnIZtduBvEJzYGjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxNjZlYjgwLThlZTMtNGRmOC1iZTdmLTgxMjE1MjNhMDBjNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFjMzg0MTctZjYw\nYS00OTcwLThkMjctZGFmNTE4YzI4MTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEETaMXmTLeyDmLvtqy+Ji+9s/FQRKn2XA5gkAxkJ4h7cZGc+xAYfUr4juAWaY\nWs/99kf7lhW361w1tMMgcE35w6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUje0MCA0YI6vvm1fx5l/4z23lw8QwHwYDVR0j\nBBgwFoAU1jdXGsqmj+MEfO33WgqbYQPgaqkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgL0HOMpF1\nF+Fz3owlJ83HErDsfKGRjUa8FUCKHj38qMwCIQCqZb5oZ6dfk10KhtbNQKokXznO\nDL4UxcgRxdmTQLD3xQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX7+gHLCZe00XIFA5PmQEtZPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTY2ZWI4MC04ZWUzLTRkZjgtYmU3Zi04MTIxNTIzYTAwYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbdo7rCduz4PqBaCadNRVMnAsfNMxmV7LRFGCXT5A1CWCX\nDLPy/FQXD8jJ3uwVoqxXGH6IBYQKj1JJawdWCvTQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1jdXGsqmj+MEfO33WgqbYQPg\naqkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO2QmOXSSThd2jTYm+w+HWn4D6dtL0Rg3Wug3IgJtVxAAiBxuR1HAn6R\nMpI++CpNLXwszAH54n/MWbnSdNrGe7boNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAR6y3xwDk0iZXxdEspBwhyDLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFjMzg0MTctZjYwYS00OTcwLThkMjctZGFmNTE4YzI4MTgwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmYzRiMTU3Ny1hN2E3\nLTQ3NGQtOGM1ZC0zNWFmYzgzMDgzMzIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQjvgYYlwUX4vTI4F0hhK37k4M3aEXeQziQKx4Hg2RzWgovn55xXkrdlHW55hHw\nQMyeYZZAVpUL/gDLYb02qgZWo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSN7QwIDRgjq++b\nV/HmX/jPbeXDxDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAJOJXU4Dv0/DyhLqF+nsZMSL/6KtIx9d2nr/PX7lMtGl\nAiA8GdH0d3YsAq03xk2jRrC8F5c+/ML44RORpPH7FroqHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8002", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8002` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAT5W0emu8+ZvPngV1teKF2XmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhODJmNWFjLWMyOWYtNDlkOC1hODNlLTY1ZjFlYjk4ZDYwNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2IyMGU4M2EtMTJm\nMC00OGMyLWI5YzQtOWY4NjRhNTdmMGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq2kzQQ16n0y/8jpcxAb9XGabQkOUKLnTbFFa49wpvjcYzp8DPKniGq4di0dj\n4acxUoVlNHDR4lrLqGjHlYZNMaOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAo3h6PUPO7gqcTmmEFRFig6+2vUwHwYDVR0j\nBBgwFoAUtTUCE0vYVP/LV6Ajiun1042KfGswLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFZpGQU+\ncV7LvqfKj7ZULR9BQOw3qV16LG0MSDuLLXdRAiEA9K8wq1J1xL33agPEKpaASUlA\n5QLoh7MOee+i0ycT2L0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASuknK9KSZElvNN8O79tq+XVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTgyZjVhYy1jMjlmLTQ5ZDgtYTgzZS02NWYxZWI5OGQ2MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiibIphyZ/Mopb+bDcPxNv5dAb9B8pCtAWEoDPc2MTIBsd\neOGe9z96G3BOI1v2Apk1UqDfiGyY/JsWwTbhb/hRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtTUCE0vYVP/LV6Ajiun1042K\nfGswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL49GIOVa9ZoYblA1ELHX0P7y+JkiRo87HNrlWDwevn1AiApcH7eEElK\nyomtlerjKWiuICe5VeFy6o4Sd6SnAXoF+A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAarTR6+sb3O8FnThc2e7x817MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2IyMGU4M2EtMTJmMC00OGMyLWI5YzQtOWY4NjRhNTdmMGRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhMjFiZmYyMC0xYTA1\nLTQ2YTEtYTc0OC1iMzBhYzMzMDk4MjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARXU3S3vhFaTe3Mex3PmVhdYLqV4lu//Sdb27coRePEq7R0UpOiDGWNrswo0x42\n0aVW9p5KA38Bm864rD81YQIjo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQCjeHo9Q87uCpx\nOaYQVEWKDr7a9TAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAMjxzlzpiXQawMot7wvy8Byc1vl3rqikGAMtPDdCvwao\nAiEAm8mZ/Mr840sXH++xRj/KQUGiRGHlWwmYm+yhvH+zBF0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8003", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8003` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISATRvKXI7Dgp44X7iTrSRCB65MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5NjJmMjhiLTZmNzQtNDU2Ny1iYTMyLTE0NzAzZDcwOGRjMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg5OTJiN2ItOWIy\nZC00OTVmLWEwYzUtYWVhZjJmY2M0MjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5UICIuSgYS3Fg9Cw0gB4g26jT30hUiLt8cgIwYN7EL2Z80ANdysQtA3WeGv/\nBxdDIaTYj9+vyCYXBIas2lUOE6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUajnJA+ZtrxBPOURWcG27ErxkiokwHwYDVR0j\nBBgwFoAU++qDhmwuJTl7P4DVHlBTenDfr2cwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDEId/d2be/BKtP+qCQawKFA9Ou7XX/yXsJyRusSwUROgIgSDMyaFHB\nBk3+r9FKQcfLjjp1XR3tfwHzYyAy1qH9vfA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ5VoiaaEzwxZoJH/RZOdYusMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTYyZjI4Yi02Zjc0LTQ1NjctYmEzMi0xNDcwM2Q3MDhkYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkCdN9L/Oc5dJeEcscM8SuuZ98jRSy7iF2M4wtujBXetBk\nEQqAkdlXsUCPSpjLhutBragOrUbLZ+ArmWQVmczYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU++qDhmwuJTl7P4DVHlBTenDf\nr2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIWNbwA4aT9fDSGyTtrJ4CInNE2ZamlTCAQKkZTdgvpsAiEA3c7BOTKi\ne+a06AC9u58VRb7iGCC516qibW13anRWHu0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVFk/6cCj0tPmRDUDKnZDoFHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg5OTJiN2ItOWIyZC00OTVmLWEwYzUtYWVhZjJmY2M0MjIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZGVlN2JmYi01ZWJi\nLTQ0ZjktYWUwMi05ZWZiMWFkNTY1ZjgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASn4fDI+tYEFEB+rYN/Mg3H+Cs1+dwMluKXtaQ16v2JgzDZj11f5nu89B1vUuH/\nEHclqjplkGVOm2Bqb75K5k0go3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRqOckD5m2vEE85\nRFZwbbsSvGSKiTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgW4DYcFGEciPr8BlBhTgBKnFAV3P013oNwz+DO7/UdnsC\nIQDxh6LrhKQeKqzKXNQdNekuDuRURmeVa1VQiEvZ3UwF0g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8004", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8004` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAaVy1tk/Fe6xaNEWq5ox2ifhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZjEwYjIyLWMzOTgtNGFjNi04MjAyLTUzZmM5ZGUyZDhlNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM1NjNkNGMtMzQ4\nNy00ZjgwLTkyZmMtMTNkMmFlZDkzMWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF1qzwBlDKda+ECHt77sYHF7VpL8wCeV9ldHJUUaX/hOCmGdRi4w3KKg0S5jN\nL/dXkqBKyi7tswscv1+mEZMN7aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzEt8fjqcP1UUGPtzQJDBnBMC+FYwHwYDVR0j\nBBgwFoAUeBXllE3R2qwGnCvHwtmrhUW4woswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIC/0I//TR8V6YHSJi912AWZKwOj5gSf4GLQEcP9/WkOyAiBb9z//bxeM\n6eFGtaDDf0f5xe7BHeXhwD3u/q+Ro0yL9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZihig4cXE/Iw4YyKgMV20KPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGYxMGIyMi1jMzk4LTRhYzYtODIwMi01M2ZjOWRlMmQ4ZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIIrL2BjYtz4H++T9tWcRNAIzlQZSIa4duTUbc2npXKQ/N\nfvCl5zTc4IDkzKhoSDWvCAnrvpAXWLcuGgc2cyD6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBXllE3R2qwGnCvHwtmrhUW4\nwoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOLAYY2a07W+s1X0TWXiPDjxXDVTWUOL99yFT1UQshDfAiEA8UoewtAx\nRJxzkv4+/leoD9V+q/BaGUQiuX06UJeG5qk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQqsYJNt9mUQBBGlWv/db34oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM1NjNkNGMtMzQ4Ny00ZjgwLTkyZmMtMTNkMmFlZDkzMWMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiYjQ3M2U4Mi03YTli\nLTRlYzktYWJjNi03Y2MwMmU3MGRlZGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARVWYI55/uCHGiRgbMhZUj+RiUHTKf6ihU6z2gMFgqupklhoeoSABWS/T0Kbb2R\nMue4sjFag+oXhifUa5Oq858so3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTMS3x+Opw/VRQY\n+3NAkMGcEwL4VjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAM46l//nw30xSq4UL/h4JdtLd1dOnont3yUJ55EWg4Yz\nAiB/h/1UG76mS1RDyUS82iat5uto1mZXxIwLhh+doHSXWg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8005", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8005` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAVP+R/FUxCOMzjH1tS+HCZ5cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1NDk1NGExLTIxMzQtNGE3Ny1hYTdjLWYwYzMwYjkwODRlNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg2MjkyZmMtZWU2\nZC00MjExLWFhNGYtNzI0YjIyNWY3YWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw3NTKAP8MWLQOxHlS+9oxHhd3UhAdyVF3Scu2uDWEi+tizwXiIShAwwMwBYv\nWuI/TVXfaDU7JOc8DRWUs1cZ7qOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoL+t1RZIulRerd9M2GK/IWoAEPswHwYDVR0j\nBBgwFoAU9T/yC1RCNSPgZLFH4xvjL6p/i4IwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIB2vSRgelgjit/80ttFVXurtt/CgXp/bNLFeID9EDdqLAiAstNCu2IuVjXAVEyzW\nhS8llfOsAC7qgqSQm+NidvYZfw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcKzj0//e7JgOL+1n3eM2KAMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTQ5NTRhMS0yMTM0LTRhNzctYWE3Yy1mMGMzMGI5MDg0ZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSQd/56MsI9O/wWfzDZVCieJ8RSRzjxMoxOc5CBHaAH2hW\nZ2qBw9QPptRChHUILjCUPCyvr1bvi2HtN69J4cKQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9T/yC1RCNSPgZLFH4xvjL6p/\ni4IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCOTpqR2cx/AhmjMRAGwUGhxM0HUFGsc/tbEDwciu4RUCIQC6/oEhTe5b\nMuL4KZVl+tCqScgc2dEVIGV1ru8/kGRpQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAQAB8mdMgMxmGvz8qhWvhbzpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg2MjkyZmMtZWU2ZC00MjExLWFhNGYtNzI0YjIyNWY3YWY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRlMjAzMWVhMi1kYTg4\nLTQxMjUtYWVkZC1iZjM1NDhlNThmNGMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQcfV0Jk23MBfrWFvqS7ZaBCSn7/ih9hp8/OTo7fZ/UW8xGlN/4xhfasbevB2VK\nNBk06F4pY1kJQACO/9Qxwt5Jo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSgv63VFki6VF6t\n30zYYr8hagAQ+zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhALnvC6WE1kFc2ULYBIzFkzpo0Cs6w1djY0vq1VYWfLKM\nAiA8YMrHEZ+k9NiTU3YKkPpI2qjkJMpAzQ+dSZW7r4PHCg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8006", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8006` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAecu5YHc97aA3DwmoRllgiMHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYWE5MGU2LTkyOTEtNDQyOC1iZDQ2LTE0YWM3NjIxZmYzNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhmYjNmYzEtNGJl\nNS00ZDU4LTkwNzUtZjU1MThhZDhiZmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf4jEQN8kcCXdYAEAhDd8dQUC5bsh7fg1mFYI8MSt6LTYLwhayFMMEOyME44k\nuiE8/JV02yPmbIEw/hdrlvuRo6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSilTUzDGDcENYcKXsCTZsoGJLsAwHwYDVR0j\nBBgwFoAU8q215edecWM6cAojxZucbgxi3wYwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDjjKeEAhgOtV/ySnRftDpvT4M2jcjtMJFPh4T51XC7agIh\nAIvq5GbJCAALfPCpexjUkiaD+DeavcohI33AK/IBPius\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXXOMkPif3d0m5w/5Wz2XsCnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmFhOTBlNi05MjkxLTQ0MjgtYmQ0Ni0xNGFjNzYyMWZmMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqqwA4Kg125ZfkhVOnQlsuQwFPhdbAn3DpeLRVNtVDdxx/\nMfL0UQmEs58YGkP09s1z27hZH16Rgb0WLVZvl9Rto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8q215edecWM6cAojxZucbgxi\n3wYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAITpbqles4jx5y5OAzUQtlvVsD2sH0lXL8KuDtm/dm77AiEAomsgWrP4\nNE6DvH7PUuk4XzSyjz2VXIPIs+QSN9LNF0g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAU6jqgcx5XzMmEN4GJSIAVbsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhmYjNmYzEtNGJlNS00ZDU4LTkwNzUtZjU1MThhZDhiZmI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRiOWQ0ZmQwOS1lNTVh\nLTQ5NTYtYTU0Mi0yNGQ1YWJjZTcwZTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASOI3QggAcs1s7e63MXOzpfW6wSKY7bEokOx+jTcXdUcDeoNtBxj+WZ/wCb1id+\nN7FL8zeN5igiPzrqz6YNOG8jo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRKKVNTMMYNwQ1h\nwpewJNmygYkuwDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgPEkwKsD0zIn1rOxq8EnmNAHQWW5XgO14TTK1ichvpxYC\nIEn8SMDiMJwzvwAKoMzdNEOS8pmCETwPMbXPt9OFQmVX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8007", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8007` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAfN+EuUQi2K1eC5CDt1fCY1mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiYTQzMTRkLWY3YzktNDJlNy1iZGQ4LTQxMjc1OTA2MTQ0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzE3NGZjMDktMTEw\nNS00NjJmLWJhNmItMjM4ZTEyYTY2ZjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDOJHXbDQ/twmkeG+SJ1eMAmIuNHWasHiJQOqjOK919GYA+9KXAae20qRikIS\nQHzkf5woHZspX9AxO5XfgytQxKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5TkAoza5e7aIWSjCK0RnYPmFpNswHwYDVR0j\nBBgwFoAUyfSQ8GtGAupZOdiV/aNAcHTIZbowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIBr7jSnFJIvDgom3aRo6osBSGFKGHl3w+p6gv+6YLFpUAiEA\nodoZZqpeqLVGcjU6AZmlnYa/urlTezboveaxb70nKr4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZP66TvZuB7OKQa9qH/TsUCvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmE0MzE0ZC1mN2M5LTQyZTctYmRkOC00MTI3NTkwNjE0NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhUagm7tcGHl3YDWD6aRv5uDlwZu3S+nhwVpVq4noeK2hL\n5nOV2ClWWnAkOJFWj7glAqmyc6Zav5zbNiNcpg1Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyfSQ8GtGAupZOdiV/aNAcHTI\nZbowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF+OcgSxG8q5ElWIetSVVDrWqeCjtWNmgBhb4Guc3YDoCIQCGeBuo3YyS\nB3GwDBx/l1GvpFrh1lXSjdAcgbqE5xMnQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAar1/r5mw0bMq+uhYbBj5Yt6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzE3NGZjMDktMTEwNS00NjJmLWJhNmItMjM4ZTEyYTY2ZjdjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ0ZDA2NTZlZC00MmE4\nLTQ3MjUtYjc1MS0xNDVmZDU1YTFmZTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS/D+uv+sBQMG36JlChx7ml42t691B1af0Eswt1F5veGkbk6Q8+dVyXnqSV2hPT\nfWrk0jZym5JzaAALF3fYp0bAo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTlOQCjNrl7tohZ\nKMIrRGdg+YWk2zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAKcyXzMpKyAIRc+iEuOLyMyF8gHohEYj921Cce+UR4oT\nAiEA7uNLB5wC3AOLmYGD3rHeuDMNztVoyWAJNDeWFUVZJfM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8008", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8008` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAdkm1RrkoghtdnibkPFJzAKZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3MjUwZjZhLWY5NDYtNGJlMy1iYzdlLTg3M2VjZjM5N2RkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNkMTJhZmEtZmFh\nZS00YmQyLTlkNjktMDlmOGE1MTUwY2JmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXMex3qf2WyhxWZxuP18YyhR21knz4k6JggEKFvcmeVp+y2gGxvhrbplWmkkG\nIeeKoBglraxaAAl7ajlou03AHKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbCJT0EqbK/6PJ5l/uGifR9ZPlsIwHwYDVR0j\nBBgwFoAUiO0GJQAMFd5SQvd0tXpnQsRljfkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCUvN60lP5L\nT4Rv6FA7wd7/CildiDq1JG3//EGu0bYpXgIgbdjnwdcuHA6xEFy6c8bntdn+UYz6\n7SGufYlC8u5Wc4M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb7q4JqdBQgqT0dTR1mWh9zNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzI1MGY2YS1mOTQ2LTRiZTMtYmM3ZS04NzNlY2YzOTdkZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWZQX5kjC47MGnu8HGWf60LuxYvKvLYacb3wZn1m6UrCtQ\nILfNaXZOn/dRpVNXgW5GwxNcFX96WTpUc1QIVQPdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiO0GJQAMFd5SQvd0tXpnQsRl\njfkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALp95MyogPhUIpAYA3fxlZTi7/ygkluG6nJJgWo8vV+9AiEA7BafWjmA\nwrFyBGYbvXmrVyWP1QGnSkw+sjnsOU+mNoc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAUNa+BrXPH8ZZGVeSZaxQMc3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNkMTJhZmEtZmFhZS00YmQyLTlkNjktMDlmOGE1MTUwY2JmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMWI5OWRhYy0zNGVi\nLTQ5NDMtYTA2My1iMzYwYWZkMThjNDgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASYDGtKbZZN4fY4FDlvbo+2Pz2L8ivsxSosJUsJshU4/p1JSeFxyQb1io5hxEt3\naEt7K0VLrP0QX35bJuWbV07mo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRsIlPQSpsr/o8n\nmX+4aJ9H1k+WwjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgI+cmW/DU67Yjg8kCEEuZZHdfBJnxvF01U6enQ1IDhgsC\nICEA1+Zk0cbItYMlPlsdWwx17k0TlQNW+sz4MXpQdGhC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8009", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8009` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAfX7Oad23gT4yE56IaVW4FGBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjMmQyMWIwLTNlZWEtNDkwOC05MDk4LTM5ZmJjOTk0MTlhODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjcwODc0NWUtMzA5\nNS00MzZhLTk2NWYtMWY4MmExY2U0YjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr/J6fVwdoH2/H27gWcUPlLgzcmZ9ZGeZskf0nlhPUdZbfUL/OYBndeLZWK6Q\nH5nR4Pk4W8LHv5RoI4xqfhf2QKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkydqxgXM3d7Eq8uOyHfCIvVs2/AwHwYDVR0j\nBBgwFoAUDo9pGiPWXG8Dtkr7dLp4CN4SofEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgefAUk1F8w5Q6VyDRbSUUoS6snD05rvzt+quE+ex6hvACIQDyv0LNcTWm\nfT9WYZL7XooCbX4x4IfF0LUUEk/HkscEEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS6LYlmW+EJe072CmlDhSc3DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzJkMjFiMC0zZWVhLTQ5MDgtOTA5OC0zOWZiYzk5NDE5YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReLOd4FtfZhJYXIx4sgx7tnBP6tiTQnHfPVjnBwEfHXuKy\nFdsNIu43sLktCUW64eiF1D6kAsO4LxE1W8f1G1WXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDo9pGiPWXG8Dtkr7dLp4CN4S\nofEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEjjVgAF43QWtDnPYWg60eyA0D4ETpQZ4UnHUhWR/UfICIAILqEOwUz7G\nY5yF7JMyEpnFHKz/yQVb4bAHkVAnWdP/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAao7L92+5f9/Vkt6UHHNyvP9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjcwODc0NWUtMzA5NS00MzZhLTk2NWYtMWY4MmExY2U0YjQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2YjBkYmQ2NS01MmZk\nLTQyZTQtYTZlMS1kYTEyNGIzMzRmZWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASVc5C8oasarfeKA6Hoo2f7/hQSb7lyJW0UL8G/1LrE/R+huCP2YbnFTajgGLEi\nRP7pEgnV+fTe7noA27vmzrdxo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSTJ2rGBczd3sSr\ny47Id8Ii9Wzb8DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhANKBEW6uGBMrUSVajWYjE6qj1JeFI+gL6KyfWvTktX5S\nAiBiJp8ENOEk95tydIcaK50YDMTdOHoMFMAfqmWwD6z/vQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8010", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8010` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAWi59BhfwZ+4uatjHGFm9JgRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwNjM4ODA1LTdkYjUtNGFkOC04MjEwLTYwMmZiMWYwZjI2ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I1MzdiNmItY2Rm\nYy00Mzk2LWEyMjAtNzRhYTE0MGNiNzhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7imHP9MVboUKfvcAowO8hJimhmQLrIkm6pBhGROBM7ECf1/La3KeWkj9GThI\nUFcpRAgq8eNblCW5SBvxxTTiEKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE34fy14V2+xtLqVgBEs0OlSwftMwHwYDVR0j\nBBgwFoAUkwnqaX2e3jq/Hx6D7FYb1e8KmbMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAPyiNejYbsDKn+MzBy5yTVB4PCeszqusy7iaoXmSuRgpAiBokc2EPeJF\nuHb1xZ9WVnscUNXQjSR1dMttYVfOMxbwjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbB4niAu1YhobgoP7L9GckubMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDYzODgwNS03ZGI1LTRhZDgtODIxMC02MDJmYjFmMGYyNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQf+lSzwh4FYkzs65xVrqiyL/efBv2o05mgnj9px0ChfZwN\nZrdgoQJ/yCAXqNcG6jpHUhlNK2sS1QEN9PQNqlI+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkwnqaX2e3jq/Hx6D7FYb1e8K\nmbMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOENnJw6jdaNc4AHtIPX/rN5yTyzSrP8UXT/QMoaaD6gAiALrgEilS8X\nwBtHS4JO0lq0y5m0/+7DT2VXRevcDPsY+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbDQ6qAWPfy2zKG9cFNFh0EGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I1MzdiNmItY2RmYy00Mzk2LWEyMjAtNzRhYTE0MGNiNzhkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkMzM4ZDMxZS1kZDJj\nLTQ0NWMtOTNjYy03OGJiZTI3MmIyOWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASXsOVH7uVKf9LCLMbwOVtGlQRjFDMBtqE1EihBgIlf/6bm0O/ctg6sXtKS6Ugm\nXJ9zOK8mLd/5Glain6U8DPIYo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQTfh/LXhXb7G0u\npWAESzQ6VLB+0zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgFeLx9WUd6CBdzOFf6eW7O7iOUjaO/gz0HmrliXCH4fQC\nIQDHgNck69sglUBmBYuXWAmh0FjgyeVlzpn0FUYgS+0ydw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8011", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8011` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISARbFiAV9hYh6xchoJ2UcZ+IYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwOTRmOTg1LTNhZjgtNDJhNy05YjhiLWUwMzIzMTE0NjNlNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjMzNDhhMjQtOTYx\nYS00OTg0LWExNzktMjE5Njc0NTM5N2I1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKBraByqiDu95I9ukl8J1zFjlmAPaSw5jEuQXka6MnHQ9JkYhanRfzfDzGQrC\ndfC3WCJmy3DCaqI22HS+MK/2yqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyHPZRUGsnKBQmrqCD8QnGOc/L2IwHwYDVR0j\nBBgwFoAU1Uc7X7erE7hx6ElzAMzNaHU1O6kwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIEv8XeLrORq8IKAKVb2fn+qAT3F5KpqFR1Pt+ES19FqmAiBF/HQzRqXV\nucsxpx5iF1W8mX3w0ZOIsdi4VZ78uxoscw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdzXdUvWimQwIws2cIjYYYIrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDk0Zjk4NS0zYWY4LTQyYTctOWI4Yi1lMDMyMzExNDYzZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASite17ysTVxdlN78DEk+CGYM1jOr8lGlylly07wDDq5eBA\n+NqCe1JrMlx+r4LsP4JKZqrP9KDKf5rS2sJuQGuLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Uc7X7erE7hx6ElzAMzNaHU1\nO6kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANbLRd8VIf7MFdMOIHdLYG3Mau/ypmgzwfoZQP84snieAiAyI3suZqyA\nC7q6mRMm/JPEMM38AKP47FtRf895jRUIDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAZFH2eAVVFPMrmc+yiOuYNMpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjMzNDhhMjQtOTYxYS00OTg0LWExNzktMjE5Njc0NTM5N2I1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ3NTcxMGJiMC01Yzcy\nLTRlMGYtYWRjMS1lZWY2NTg5YTdkMTUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATpWp4fTnnmZkLnXa8eDUOe9nPqrvxLA2NMOio8qAF+fJoQMCn7Xij/lkArs0iu\nZJ747eFLwaCHzDgxA3E1c4Who3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIc9lFQaycoFCa\nuoIPxCcY5z8vYjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgVJjaMKXp2hJXcnbPM7dzN/fJY+qrgAd6wPgff/Ymr/cC\nIGCK2o9W+DYRPoFqksyXjGvDd3OWzhSo353vg/JOQEm6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8012", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8012` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAd9wvWw97hT+jn4n++bYTYjmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxZmUwYmZiLTJkYmQtNDVlMS1iMDQwLWNhNWJlYjA2ZGZkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFmYWYwOGEtNjYw\nNi00MWM4LWJlOWUtZWZhYTY1MjIwZThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+87ATilX0Y0m9q7VZa3czBYSWvnXokU3lkSY6xXtnXtVDvsJbuhLe0pMfAr6\n0e/NvHFtEfIUvt9u33iA/1VFMKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUIwkhEbCHE7M4k6VIyaAL4znMN4wHwYDVR0j\nBBgwFoAUVzqJscdfXFggKdRn/P8IJxAStegwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDgD1GjrbgjAUgeBdJ0VMbn8732jnaYSA5pG3R0\nEw9cqAIhALzWWTGwddYHnQHPTam+/ue/CB+aUMXrpy/gw6jgD1h/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdKjGxt/Q2JsTtUgmLUPsxmHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWZlMGJmYi0yZGJkLTQ1ZTEtYjA0MC1jYTViZWIwNmRmZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkqOwY6EhFDaZTMg0olKb9E3kU0IiKn+uV1gxaUPvma6Bm\n7pb4/8gjqBcdy6yaI443aKpYSgvYuVBaE65m2/CSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVzqJscdfXFggKdRn/P8IJxAS\ntegwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKkzACU4E7w7rlVwx3THDw16tv/Mqo1W5Lii1p1DhsOECIQCsJf+TXWhd\nPrU3ZLlO9zBLwuke/37ebBKO6oeAmPGKTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZHcfftKv7HT3+eal7GgagJPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFmYWYwOGEtNjYwNi00MWM4LWJlOWUtZWZhYTY1MjIwZThhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjMjM5NGYwOS1kNTI3\nLTQ3ZTktODg3NS1hMzRiZjk3OGJkMzQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAS9s5CeDX1ps9sSbhDUWmv7DjMTyAG3EvzWOP3T0KYZoAkQtuBENq78oXipluzC\nnW6K51rK/2xuCJJZwD1xeeT7o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRQjCSERsIcTszi\nTpUjJoAvjOcw3jAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAMu7lbKYx3W1tbt+O3oAkRvgDeoYrZe796EU+WOZAoMf\nAiEAmve1dt64Uuw3/eKuLuZ4qZVYLHdhp+ZjNQANYcS6JQI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8013", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8013` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAYCqQyceOtSzvcMWUSS7tJjWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiZWQyYTEzLTdjOGEtNDRiYi1iNjhkLTAxMDE0MTEwMTE1ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I0NjZkODAtZjg4\nZC00ZTc5LWE5MjUtMmE5ZTU0M2E0MDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7k6Y3mQ74VGGtjDcWEdX3InaDFYoEXmyE6Bwpzufo54NYJBvhkUoN1x6LLy0\ngdMr6qwrKmK1THwkrPLh6j9neqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+I/Pj6/uVTDdMJ11dUyf6LBHfGYwHwYDVR0j\nBBgwFoAU96tvUPHz39KEbAHBDLcIj51TXg8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCdUn/aelAvO5ax1RCkr5fnq1iZgCBA7gYMW3o5\nt0tx1QIgYM2efuiZ/3dxdG50xB5v5Ge9zKoykQyCvvY9D+7N9CE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATVm9Fs72JyE/H48ECZb+MpdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmVkMmExMy03YzhhLTQ0YmItYjY4ZC0wMTAxNDExMDExNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcK29Xs4hxkx096q8RDrEveRp6EGlcikmW4mAH30vDvNA5\nfTBcpEvE9kgVxo9D2O89g7qCX3VhcJ1dHgOeLc8Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU96tvUPHz39KEbAHBDLcIj51T\nXg8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWzXiuUhzFZwFoGSTRRiz2ypKUVbdtVopQZqGIo+QXocCIDYsB12hVxU2\naC2n9+zeAweHbH7xZu/jpP0f5tx6HIbn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISARMtCCe7oX2Sgf/O1mSrlfHRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I0NjZkODAtZjg4ZC00ZTc5LWE5MjUtMmE5ZTU0M2E0MDhjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRjYTNlMjQ0NC00NzJh\nLTQzNWUtODkzMS1lNzczNjllMWJhODgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQgqxlpaL1PxtFTmqHzh1ONMe+1bJIHZJ/tIbrzK+VHIXnHPH428cFpTTuwPx3t\ndd4kjWA9RbAOUEKHZQPSoWMZo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT4j8+Pr+5VMN0w\nnXV1TJ/osEd8ZjAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhALVBdy+ssJyYE5E5BJJW2QdAkqmu/vzeNGTV5+6XpNCW\nAiEA/meqRmv4M63Axf/UGwdsQ1CtXg3FaC/RU2WytXltybI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8014", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8014` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUD/lfg2JcvNimbXTol4Cu3TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NzM2MGZkLWNiN2EtNDEyNS04Zjc4LTBkYmU1Zjc3Njc4YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZlMGI0YTEtMWUz\nNi00NTRlLWI5YzQtOWMwMDBmYzg1YjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe6dpLmilT6Hc8ASsQoQ1HTLBbN1gN0ta18LyN/7oK7tQ+79hMv72ZN1m87ZR\nj9FDjGuDQeFsP0gspFGzEhtCSaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUknPVrK64+mhhhDBZ2v+YhjIsJr8wHwYDVR0j\nBBgwFoAUh6EfbRec+uiFTiZtZTVkp5FUvwYwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIHgz6mxSIkCy8gAIyCTu5/X9ywY9vQ0w2ji/OPMuVkY4AiEA\nlwD3WOEPV9C8Dg/27+xlfIDyno/mOWu4vgZUS1+P01Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaeCah7RbUn/3KJ/ID/vZo3EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTczNjBmZC1jYjdhLTQxMjUtOGY3OC0wZGJlNWY3NzY3OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7U8LzsGNEHxU8rTNLTg97eVONSdjpJhI5vm/OiRQw0RTQ\n3WVmRA3XG/HlAlbOVX16l8QqzjMX2VFC25WABdIfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh6EfbRec+uiFTiZtZTVkp5FU\nvwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL5ky31kNpXJfJwDlibuX1/Za/LWuL1U/p/2S0MEuckUAiA8yNgKwccX\nBrzYZUYwUJkv9x0Qll2YiymDxxuGRzF3Qw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISATbyjLdjO6PJ13U55DWo/k/UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZlMGI0YTEtMWUzNi00NTRlLWI5YzQtOWMwMDBmYzg1YjhhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRmOTdlMDNjZC1lYTg5\nLTQ5M2MtODA0MC01NmZhN2NkOTM0ZjAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQvxm0BmIf2HTLWPzYJEsC9KVSiXWY7M0ZnxUdiM5/44KY0Em8d3Pi/yqvQdJfS\nAb1MpAWQRVyf6d/ZF1QemEjuo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSSc9Wsrrj6aGGE\nMFna/5iGMiwmvzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgTR9WTytmcfCxHZMw2CRbWwTR08XudNhSSxrORUBMikkC\nIBdCISsv/gptmUC1mFWBg0hjnY0MER3838IzFZdUgFX0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8015", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8015` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAdHz/bY8ehznOfVeUb9wLcjMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmYTI5NWEzLWY0YmQtNDE2Ny05NjI4LTZiYmMzNGZkMDMwNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDkxMDliMTEtOGQ2\nMi00YjRjLTljMWYtYzljYzFiZmMwYzQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExFvNAWDIBYPr4puBShkUUHKOteDrry4v0hVsdp4JcBvuLG+0+2wQas/SvgrT\nkDpmUFGg4jzy68MrHLfUaKjrfKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7TVA3kMFVjuE/i3HSd6kmPDG5xAwHwYDVR0j\nBBgwFoAUJr2kImb/UQ6uyDh8nR5ZdelAndQwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIDBnqqJ0FF9hmuaBjPhqnzJdoVFWvVCW\ncZ4zQJEYNMsFAiBlWpsMUPmkOD4zhsQOoEWI0NX886dgnPk+zZ5JjYpgWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV/79JF2z7/MwcZUhoPbMR1wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmEyOTVhMy1mNGJkLTQxNjctOTYyOC02YmJjMzRmZDAzMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8UhZvHXQYMltXChGpDaVk5xdO+Hw8emDXUajjsGc+xatV\nuCvV92fo471quIarfH885zR1Zs7kt+hICuOOUhFto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJr2kImb/UQ6uyDh8nR5ZdelA\nndQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK4cShL8ztHCDDl0mqqo7Rr4Wy7SG9kRpWZmgX4aSp8IAiA+2ekHFK0z\ntgZC/aYW/ARvNtssldOF6gm53uMAFXs11A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZAOZKZ7Dr5Mwlt/l8vaz8l8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDkxMDliMTEtOGQ2Mi00YjRjLTljMWYtYzljYzFiZmMwYzQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxYmUwYzUwMC1iZmEw\nLTQ1MTktYjliZS05NDQ2OTA1MDdiZTAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARR8kAkkeAn3cnKLBvJ5CXmeqJPICDo0iYF5rN8yDLxu7qL/z4nERst30OSyzgc\ncG4Gi+oMQWrL3MVmaXvweS3Uo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTtNUDeQwVWO4T+\nLcdJ3qSY8MbnEDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhALKxMIJ3G18KS1v1jd2pHdfrIjy+SIWgoBzb7xek0BwO\nAiBAYS4cP+hGAUD9MGR95suSNQ62DeZkoGKrka0sjgO9+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8016", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8016` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAZJBs+fJNiPiSs0qcj32WpccMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZjJmMTU2LTE2OWUtNGQ4ZC1hOTg3LTQ1MDAyMzc5OTU4ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE4ZWRhZDMtMDRl\nMi00ODM1LWE4MmMtYWY2YmM5M2NjODk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8Zwt/clkJL1QfBOA95OensXGxJT6U7Zw/ehLhBOE59ksKEFacjI7cEYaPM4W\nTanlPPm0glXjtQGQszYmj37QgaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3vvcSpbJiNtIHlS+1DYOKA5UMFQwHwYDVR0j\nBBgwFoAUkGhWG6OmAtYDfaKtgVPz8N/3P8IwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDeCYlqxTRXfAMzLaWCT8SGmIqfkyy7\nCD/7MJYuMfwLcwIgTDEJ2jkC5tSMfNqyXapBYvlQHv11WcSlStBwRDadNc4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXonLw7XrzbYDKwJ94lxSuGLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmYyZjE1Ni0xNjllLTRkOGQtYTk4Ny00NTAwMjM3OTk1OGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTuKcINIw8Mw0M02XwTqEvARPwOkzjM0qvWhFrmU0NIyS8\n/0vq/2Vfm7IxqfnrDNFhplK3wFiPiuj2U/2GaOL4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkGhWG6OmAtYDfaKtgVPz8N/3\nP8IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbsXBRogLZmUbTSbg9tNFadzGXYGGLPhxQ3ikVIAwoTcCIEEM4xIW4MEE\nYbWa35vm8ueA5WbOiI0K9LyaMkME5j3y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAZScE8fnD4aKtUu7Bw1wrVP8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE4ZWRhZDMtMDRlMi00ODM1LWE4MmMtYWY2YmM5M2NjODk3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNzdmMzk5Zi03MmVj\nLTQzYzctOTgxYy04YzE4MDFlYWMyYjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASEFAaBQ8WJk40qbaV+agBUJZMudt8eNoSdISPlE8nAjeHbCeaFdROx6isJCDzm\nIKJtLM2TRfbnsaqN6gVjbTiFo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTe+9xKlsmI20ge\nVL7UNg4oDlQwVDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAMc8i3ZedWGEs4sJIfDv9IDfrha5KDoMbPSaLC7K2ziu\nAiEA9USloloeIwBsiwelHDrxPppjbTVczIBio2dJb0H0s6I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8017", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8017` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAU6cMfH1TgPXmOVcpvf/6OHCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4YTZjZWU3LTkxMTgtNGVmNC04MjBmLWIzNGIzZTQ5YTE2OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhiZWQwNmYtOGE5\nZi00MWNiLWE2MjktYWRlNjk5NGI2NTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEicfw3448bQKUvjne8sJ4TRKT1cjs7lbxR6bj7jQw9wtc97p8VK3seDhI3IZy\n9qpGHc/Bta/DZ8RR0/QVqrrUqaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoJZ0Dw7h56iSeFMiUtoE+BlR1ZkwHwYDVR0j\nBBgwFoAUY6Qt1x/YR9FbKla4LXFRDebvCowwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC782L09Y61\n0IBTs9hSul9lhPGvq0u8iOPY9FeXPJ0+nQIhANvWxjo+9l/f269MGEOfN6HCFBsa\ndaSmUtngtW/HrAmP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAThNLn2t4Py+3xHLqXQ4IggcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGE2Y2VlNy05MTE4LTRlZjQtODIwZi1iMzRiM2U0OWExNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQY2ByeSwsZVsqzkEouYGLUw4iAWM+qjUDEi+/KFWXynS3\njKZV0LJ2VoRRsD2oPeqfd0UoMmwHAPMeY/rhvCUno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY6Qt1x/YR9FbKla4LXFRDebv\nCowwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMnZow4ndr06XShl3AeAr5J2p1nWw6fMn8P4W8CbLLXbAiEAw5+iofcL\n0H6T+9f5oEZqO2Yx4T8RE+6v+pMWxeHvSn0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAVQlxH4OmB7fNLrNbfM7ETbKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhiZWQwNmYtOGE5Zi00MWNiLWE2MjktYWRlNjk5NGI2NTE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ2ODAzNTc4Mi1jYzhm\nLTRhODEtYTQ5Ny1jNWE2NTg1Y2M0N2UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATqw6jpJ/MaHhRVYkf6lzNZyyI2++y9V6/4Grh3w3PimCdJfTmpQvj172VAx8cP\nlW9GnhIzUIfVeyDkbnN+ng89o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSglnQPDuHnqJJ4\nUyJS2gT4GVHVmTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgEzS4dbT3SwYzhKWAoL2GTYUd8JnOs/mOflRK+Uxj76UC\nIHeBE/AST9dLwEC3/aEeV9gR6Doer9slouX0FJbTnawA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8018", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8018` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAftwytZRC3o/W9Um9OHsICTKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyZWVhMDkxLTdiNTEtNDBhZS05NzBjLTAxOTU1YTJhMjdjYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FkOWQ5N2YtNzc3\nZi00OWQ3LWE2YzAtZDQ1NGJiZjg4NDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdx1AVPorl1j7TVVoKPyqnoT/wkpEH3ie1QqQEz7bcuZDLksaFvdio4nXBA7E\nOdAmi+AbasBvG4lh0iudApCTKKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDtd5JXRC4jkdozm6sDp5YAytKHMwHwYDVR0j\nBBgwFoAUjnsZDy49Z6sFHjAFPlbfToTL1m8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPWlS8dlPf/R49fqUBEwhNfnyfT95dcXU+xZfL+KYEWjAiEA6L/wnOZA\nfi9OHfDof9zGw2XH3aOk/qaZK4AKkjFQP4M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZV/r77XQICOa40QhZ3JddX3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmVlYTA5MS03YjUxLTQwYWUtOTcwYy0wMTk1NWEyYTI3Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARStvXByTFGzT69Q5kNfzIzRekkRreqCNtIkqWXlS14E48T\n2vTrgU3uU6uvN9Fvco/s/2AuTl1C+5vMNMW1onz9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjnsZDy49Z6sFHjAFPlbfToTL\n1m8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMFIntTgPl9J1TwtUqwxwFksGQZoLgdcb8nrmTftPUKhAiEA1OeHFzxe\nt8YYHGfHRTnKRywFohpV4sK6MfrsnPT2C+U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAefYfbunpocAC23cEzZaD1DQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FkOWQ5N2YtNzc3Zi00OWQ3LWE2YzAtZDQ1NGJiZjg4NDRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRhNTMyYzQ1NS1kZTll\nLTQ5ZmYtOGM1NS0yNjZiOTI2MjczMjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARaCep0V49wc4B8iAaDbjt81Q6mOnf8tAO+huT+9Vuwc/A161jF1RNdRuvr84p6\niDvlBiqGMq1PVrAAS5JNGkvzo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQO13kldELiOR2j\nObqwOnlgDK0oczAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhALviUNIoK+WBZBurAmJ5QsFf+5n0W655/YRzsZ6RXeew\nAiEAteJ7V9debwCjW03b5nygAz6AgknnkyzmM34JvKL80kw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8019", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8019` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISASIrZpuOsunbNGsWiJP7iByAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwODBjNzE1LTMzZGUtNGNiYS04MWE1LTYzYTY1ZTg3YzdhMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg2ZmRhZjItNGMz\nZS00NzgzLWExZWUtNTc2NDBlMzVlMGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYNJ7cWcDCr2JYzIWRGZwaQAMRQYWLWNRwpozhbxAjzMqRkwdH3f136T/igfC\nsm/vJ50lzUg27z3G14btGBn3xaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrUYZjm3UrDTkX4q7hHdyYmUUWZMwHwYDVR0j\nBBgwFoAUUlLR1iupg5SRDRh8Hsrxy7j4FUIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgWCRYhpvQuKiuAyOYa1E03usZ0smxx8rmGLH3i63xV7cCIQCyJ+p1fvWp\nMTDfD4DqakjWe9h2rkoufTNHOrkEaCvpqw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXYrrH65iyMnWN12NvbXQ+aOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMDgwYzcxNS0zM2RlLTRjYmEtODFhNS02M2E2NWU4N2M3YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0zZiRsxXDJ//uo3/4H17DV5z3bohyFMF4wKcbZLAyjdmn\neBHwHi3ogNYrty3t2iqk/lRpUls5e58s2Akk2RNto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUlLR1iupg5SRDRh8Hsrxy7j4\nFUIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZKYi1iUPXZpacQdXB4qfwXbeA0rb9ZMlemswf2Y7v2YCIGH1Ubix0rY4\n8ZFua0wZ1AgY06YM4bOW1FmCcxqaBpdV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAb11KNRJdpIYi3GdaeLNlDNrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg2ZmRhZjItNGMzZS00NzgzLWExZWUtNTc2NDBlMzVlMGRlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkYTZiY2ZmMy02NzUy\nLTQ4NjYtOWU3Mi01ZDk3M2M4ZTViYmIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAT3p84GyQmG+dlvu1Y5Csa4aIV8+gg41vV5r0vMuh7+mvU7j5SXQTCY2FuJuhj/\nGmBXIrpMlT+TvMtXCXCBaRkRo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBStRhmObdSsNORf\niruEd3JiZRRZkzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgSEO4Gd6PqvARY66sUKHTtEErDENE8IDwqbrcp264zpEC\nIQCNpk79jf3ikseod/ZJJh0i0U2p8T8JsAZr8fad7Jnw4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8020", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8020` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAet4QKO0dAHhBxYqSFWv2W3UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1MmIwYzMyLTRiZDYtNDhkMy1iZTQ4LTE3N2I5ZDMwM2E5ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDc5ODQ3YjQtYzcw\nYy00NTVkLThlYjQtNjk1NzgxZWQ2MTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmygga/HvtFfFXb8i6V0KDEIxJ2QfBBaaWgwzdbW+ppooCo30gWbp5m6LNKSk\nLJwzanl+nBNdBCJk4gyp0tgD8aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV+5lvonbPjcJzrzPQAk/zSGwXU8wHwYDVR0j\nBBgwFoAUwqQDQtQww1pvXcPZRxQfssMFd78wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQC9/C9Epy6hQFBaTBfWWnF4+RzehTS8yzw5s5bLy0SMoAIgewaUjV2e\n+K5WeeCtDSNbkfoKHOmdLGzSgWTF5Czae3c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUWXYhr/UkntfxsgrNCHnkQ6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTJiMGMzMi00YmQ2LTQ4ZDMtYmU0OC0xNzdiOWQzMDNhOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkFabMQk3aluV8Pp8SBPSeS+IL/v4uQLYvDwA5/VrDlU3e\nyN0nXeHU1VGrREYou2B5WpEPDvxbLlKrzEH3WuNUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwqQDQtQww1pvXcPZRxQfssMF\nd78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGP7X5hxj9jbbmdDAgl7Q+e+cIwvmULv1gwpKw/W5TFkCID435CoZel+t\nxtXfcSCgg8EwPeP3nW+dsUE9oI6egn1/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAbDh3ZOe+nEZetWi1FFnUxeTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDc5ODQ3YjQtYzcwYy00NTVkLThlYjQtNjk1NzgxZWQ2MTg3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyRkNWEyMjFhOC01ZWY4\nLTQ2NzktYThhMy1hOGJhMjFhOGUwNjUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATRSiwx3twxEiheAfhusEa0PTfEqhgSRQkE6nGAQxN/uYzKRcnggf4cZPmewSBc\nQnUqmQz/As4NxJQpLtX4pK1wo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRX7mW+ids+NwnO\nvM9ACT/NIbBdTzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIgGi3hbyJQNH2xdFKAx5euplvDp3n4q+DUfo17OZUHgkAC\nIQDgy1y8OvziuHGHzWTS3OYq0Ql48iKbhJFu53c2SWXhSA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8021", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8021` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAagvW8UOiX5yhIqt0VkTKsiWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMzA1NWNhLWYwNmEtNDE2NC1iMjc0LWMxMzMxNzM5OWRlMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTgwZWMxZDAtMGM0\nOS00ZmU5LTk3NTAtNDU5MTI5NGMzODEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwDPVNdopFgnNkwIajOr97gmNhBghjDiDaGRRmagCoqDI1Ts5zcg+G1VC3oKj\neBb4m6pQW9PtVTJ+oox5E7wHSqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU95I3jIHPtVgaveliJt94UUS8KewwHwYDVR0j\nBBgwFoAULNvPntfwzqfEb5pO7xczMoxYiKAwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIEgouPmroi4vkxaEQLDN8iIinWd3yoRIwgfwUIm2\n9seSAiEAnPi5lKxlk+5fShQUhsYJ9HSSD/MKwlh/Tnm+hCbpBbE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAat76MtfNxGtE3fUFoqmhlpwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTMwNTVjYS1mMDZhLTQxNjQtYjI3NC1jMTMzMTczOTlkZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3AM/YvwZLH1rTigbUab04LM8zCz4NYncDdTXsMpstqG9v\nW73aj7LPxczpvaS2mcjkrAXJAW16gboy5XpJmtj/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULNvPntfwzqfEb5pO7xczMoxY\niKAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG2j5e4Y1Y2AFsqhRcjqvI9HCm2SPS9y7yamq4JI3FasCIQDLyBrZotbr\nltPZc4HI9NzQqxM1I7fJJ72WrYSOSYPJeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAQDJEP12eDZCjHvWylOnY/XPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTgwZWMxZDAtMGM0OS00ZmU5LTk3NTAtNDU5MTI5NGMzODEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQxMmVkY2I2NC1hNmVk\nLTQyNjgtOGMyZi1jZDJjMzk3NDE1YjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAARS5fRRgPjcjmapUcNf+knhy4YL3GjsZIZy7N4Rl8myeWC09gv15mrhBE/btYA9\nsDJVC4mGwTSYURmTk+t9mvQLo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3kjeMgc+1WBq9\n6WIm33hRRLwp7DAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDRwAwRAIgVad90m/E5AEmqnr6WTTG7QTUKaTw6l0qYkEwaflTE5MC\nID81UBavGMvBJis9C4bh+glufZkU8ip5VfadFFHMxog7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8022", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8022` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAXopvZtnj4YB5T+X9iTKipmcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4ZDYzOGM5LTU3NjMtNDRiZC1hMTIzLWMyM2EzMmU5N2Q4YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjczNzYxZDEtOTU5\nMi00Mjc0LWFjMjMtN2Q4MTNlZDdkMTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFx/JQx5xOSNX3V5V5UQoQBrgvc0JJjqyu6TPexKldupV6GwFDXdGwL+6urrH\n9aETPz/TzNBPLhp/paVTlMttraOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU95W6gnYYAypa1XMw+pCLbdJnBdMwHwYDVR0j\nBBgwFoAUtW06Q0Ku1U0ZBJ20oHYZQxSGnKEwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQCArbRvQHA0Z2TK6Q+Fzwxh1mxujkqUonUV3aHb\nnlWfIgIhAM2Gc2HayfgUhuxeKhQL/epvD2VPV6+6eVRTOKEcsTYT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbSJ1UlfH8QxLZdeUdhTAXZDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGQ2MzhjOS01NzYzLTQ0YmQtYTEyMy1jMjNhMzJlOTdkOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoEglKWI6CNYN1PJkGfGfi8tTDiuJkUU3V25ouyqbRSJ3I\nQ5t39SxnhUIte7frE0yQxQnpHRXqnHEn7+h9hW5Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtW06Q0Ku1U0ZBJ20oHYZQxSG\nnKEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEU18I0n+hTvFg5tAykOw7aut5b57FOoGZ60pqRKA76MCIH56WFMSX+Ya\nkhmupH6YVp7QlTD259Ni+OnfRmaCLuBr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAe2OawIvWuFRh5i2gu8ECf9jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjczNzYxZDEtOTU5Mi00Mjc0LWFjMjMtN2Q4MTNlZDdkMTUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQzZmYwYzYzMy02ZTRk\nLTQ2ZmItYjZlMS04Zjk3YzJjNjQzNmYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQ4MJEGJm8OgrRw2iXwH62QCqfYCrhVeCTxzAGq0kPSQBN0b52miP5jrHN2DGgh\njnEpmRBvAAQ0ZJGB33oF2Tq9o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT3lbqCdhgDKlrV\nczD6kItt0mcF0zAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAObaQv26BxSF74D+N1sPeh1lYBAO+nuz6ABur4FZIp/c\nAiEAmVDM/dsE/NqKGd+69frnIc4kzDOfs8hj4l+sjbpBpI4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8023", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8023` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAfrmDM41LZyTAqleUfcy41FxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5MDViNDg5LTY2OGYtNDJlOC04N2JmLTFhN2UxMzExMTc4NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTEyMTRlYjMtZmM4\nMi00ODMxLTgzMzctYzA2M2FkNTBlZTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHghAuwn5QRZxuvyYbXUCx/apH9eD4XAlogz8YT7wYg1bP1UyuW91LJMSrfVh\nhafrFBPviRf80xnX62zl0AvLCqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNtoTwbrqNjaRojIWJjgdPNtRZTQwHwYDVR0j\nBBgwFoAUwx0u+3bu/TS/CA7nrQZco5GUpjswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCTplnKN3A79RHv5Gse7Pj/oC8YVIAdEnbOKOAX9uprIAIh\nANl9FnRxEmwHNHZcupj81ULlyHyWgLh3WFBd3ooz6rXK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVa2Q/VAISp/eAJace1YwVTmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTA1YjQ4OS02NjhmLTQyZTgtODdiZi0xYTdlMTMxMTE3ODcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATErIUsBTQVL81w4UNXgaND9zKMdv4ICSIvP0VBwQMvQC1e\nyuX+WdaNESaFjYcJAkNvrizFU6Ccp0tSmEcqZgFXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwx0u+3bu/TS/CA7nrQZco5GU\npjswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIga8vS0hBWZrg2YemLfcMot8BqohzTdhLCHi48SMlXNrECIQD1ZdXsfig6\n9zeAe1qGJZV4bPwNXM+kRN2vokSFyP3y9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAc6uZeoeDaPMyfp9E/nHlL98MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTEyMTRlYjMtZmM4Mi00ODMxLTgzMzctYzA2M2FkNTBlZTRjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQ1N2E1NDUwNS0wMDVm\nLTQ1NzItYjZlYi03ZmE2MWUwODBiMjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAATr4WY5mkKi0HqNpaYdaTd/ycodk8T0juvHSoBNd3PhQdv9KPfVPbmOhAnsGcjh\nbz2RPWgJrbLt6VbjOW9jZMj/o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ22hPBuuo2NpGi\nMhYmOB0821FlNDAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAPm5VysHzLmiv8EyImHCGnXm+BIi5BiAbZKPZDoFcD93\nAiEA3jPUANY3fIS6WxILv41Z3WlqqnUnuBp8tVwuP41rsv0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8024", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8024` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAeZKVSFEqWHPuN0Kz93ntFr9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllODNlMjhmLTU1MGMtNDk5Mi1hM2UyLTVkMmU1OTNkZGM5MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMyNjRkMjAtMzRk\nNC00ZDBkLWJkM2QtZTkwOTQzNDk2NDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsegfB0r06lItIw31ST+knGsial18aiBxoBGrW2u/9V5dut/U+Xo81AjwDHej\nec8yXKfqEAayQK3/PaSm4yeEv6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtNoNb8wmhpippZX5ULUKRerggMcwHwYDVR0j\nBBgwFoAUIln+bzvcxJdgcux78E7vjzpE88QwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDfy5FY7lKCUEuCnUM43rDgv/pix4ya\nnrDf65XSS3q/BgIgEP1vivbl1EEE6LiP8qZvM+eztLWvZt4/vrYpWE2si2I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYng3c1f6N2JkqoTIeL3oXJKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTgzZTI4Zi01NTBjLTQ5OTItYTNlMi01ZDJlNTkzZGRjOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASS3RmVoddqWzKqO4ESF8AtQTWy3sKT0fVulbieXRvp5L6a\nw0I3/6KjNDPE+2BzQ7qo1p9gY3Y1vzz9rrlN0VBdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIln+bzvcxJdgcux78E7vjzpE\n88QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK+WJCxDLeN+anpW4+gfAQHrKib77ImSwYChCpW1iuPyAiBd3TPK6wVj\nLlTQv5A8jiL8hlMAlWIWJbXgno0rOVCwsw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAaj/1XOL6yPuoM6mMnO6btRhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMyNjRkMjAtMzRkNC00ZDBkLWJkM2QtZTkwOTQzNDk2NDE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyY2EwYzk4YS0wOGVh\nLTRmNjQtOTA1ZC0zMTFiMmJlYTdjZGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAAQW3fbiPkvxMHy9MAUoVl2a+mMXQ5p936bLwNpRUq/qhhdW4yGkYvyq6KD6WqTn\n/m50XZ5JdxqSH9JyhgGjLYy5o3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS02g1vzCaGmKml\nlflQtQpF6uCAxzAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSQAwRgIhAItS3KP9XCQx9TZDUFOF2G3lDKiTZC98aTgKxAT5JFf4\nAiEA55DqRjl9+4SCsF45bMNIMGPgR2xFF3pgvEyMpKzzJWI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8025", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8025` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAeBK3BsQ/h5jNipHik4ZHyIUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiZWUzZDViLTc4OGMtNGY2ZS05ODhiLTYwYTM5NWY2NWU4ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDAzYTFhMGEtYzlm\nOS00M2YxLWE0MzgtY2RiZmUwYmI3ZWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/FlZH7xmakqLMeVt3KRNyxNvo6mNQtG4XqoguCH/qQ+vjy9ewrKKMqwqngJb\nc9cWM5Y3X3Wrga55kurPbjDxIaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrPDwTgXag8lZBygyY3ENsET4EBkwHwYDVR0j\nBBgwFoAUJGrui/xBmkmARz5D7CMh+Pxx/vYwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCdLuFL7tl32havlEVpMGieYfCnrQGp\nHFMcWgDJ0WJWpwIhAImkBsCY+L7m4xInHrsdNGTAcUTiv5RB6hExI+0Pyy4u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV/LvKcHJ0/F7zuwh42SLA1XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmVlM2Q1Yi03ODhjLTRmNmUtOTg4Yi02MGEzOTVmNjVlOGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKfyPVWXgG8l7l953LrY1iLL76IACKQyEuv6qCdZT6P78e\nDT6atCQz1AsLS/zQW9Uy6uvi7iulEdBdC0gk3T0go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJGrui/xBmkmARz5D7CMh+Pxx\n/vYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOuSAiQPMZJ700kMle0HLuM/5qcpYMLaOHsIJ3Ymj6EoAiEA9atkp8lc\nmozT2UD0EZkwmPNjDlbaSqOYqKjh1JmOVSU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASjm0SUK47eHLzP9Hng13TlJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDAzYTFhMGEtYzlmOS00M2YxLWE0MzgtY2RiZmUwYmI3ZWQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTESMBAGA1UEAxMJMTI3LjAuMC4xMS0wKwYDVQQFEyQyZDljY2VhZS03MzEy\nLTRmYTktYTU4Yi0xNTc2NTM4MzVjZjQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\nAASREzHedPfRsKOQwMVdpTQ2bN7MS6Yo0rOyQPakNMkIMpFSFsLz9HUDM6SWaejc\nS42fzmXsvv689RJakUMpfn9yo3gwdjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww\nCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSs8PBOBdqDyVkH\nKDJjcQ2wRPgQGTAgBgNVHREEGTAXgg9iYWQuZXhhbXBsZS5jb22HBAEBAQEwCgYI\nKoZIzj0EAwIDSAAwRQIhAMhNLjCSvtHiULFDH+8bTISW2qXlwoZVPibXMXPEdQnC\nAiA0s4MbfHf1IzxDqpIycb9R5X5R8vr5IuKGQbTv6UtF9w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8026", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8026` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAS+Rpn9NO0G/UnGX9zLMvE+aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM3Y2ZlNWJjLTA3YWYtNDBjMi05M2M5LTIwMGQ1YmI5MmJjZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU3YjBhYzItMjEy\nYy00YmJiLWFmMDktMWNkYTE2NGUzNmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVsXUQecmPKwpsGQtllp9ay4z9U0KMILL+ggTz5VFJmddtxrMM8NGE53KyqCh\nEZphPrusRTbVXeM+8mMLpQDlEKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEtDVXwuYdsa8LJ703oAJXZXBq/yMB8GA1UdIwQY\nMBaAFKFbn/JCP1DGxaLyJSuYTZpLhB86MAoGCCqGSM49BAMCA0gAMEUCIQCtpgkY\n58Y0R1IvDVsEwB4gc+gLFIpNxX8elEA5Y/4JJgIgdPk052DD3QW/z6dQ497XMpzA\ntNsCusqds2W6uo/RrXU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfUZ/q2XB3bz+Nt9MQrsHtaFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nN2NmZTViYy0wN2FmLTQwYzItOTNjOS0yMDBkNWJiOTJiY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZwlc91yMfAqe5TI0sVPD53IZ7n3rTjoY1asgEJcpagkaN\nRs4FRbae3QIztkGurfRZZvI+taCzMpVJQzPhO54Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoVuf8kI/UMbFovIlK5hNmkuE\nHzowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANmhANg7gSJ6BsUAL9GZkaQ2PRTkLhT6fFiw4uxGyKFZAiBdr3uCuPJQ\nHfNSfA6wgpKUY3awDlj2G0/vYIz5C+08lA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAaiQ2+Bz1RS6l1fv1TPqKu6JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU3YjBhYzItMjEyYy00YmJiLWFmMDktMWNkYTE2NGUzNmI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWQ2MTc2ODEtZjllYi00\nMTU3LWI0YTUtMDVkZTg5OGJhNzRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXZ7rYb2BWqDVGBARYzHH3t2H5GRrr1busTNVGbcT/lmR0ec2a2p+PGgLLlQ01OGe\nBTrubKjZUZm2on1dC29+PKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUS0NVfC5h2xrwsnvT\negAldlcGr/IwCgYIKoZIzj0EAwIDRwAwRAIgFXmwfu2L/XzPmOE26BCmzLLTWEFf\n4U9Rs0pjYzqzgyACIFjedWZlhUoMdWP03XPs5kb81rsXFGP/X8ZanZ1BIGgD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8027", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8027` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAe2IZF2gooSlOH4iOx4N8dTXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwZDhjY2VhLTNhNzItNDdhYi04MjZlLWRlODJmM2JiMjMwNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QxOTBkYjctNDM4\nMy00YjhhLWEyOWQtNTlhNDBjZmJiMzNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZJ+daqn0/9ICJW+9bCmDECTrcMdy74YT5QpmMYyj1WWl6gGj1CoFWxpoO9HV\nZ2xleLyahvrrYhUSoQH1+dP+e6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDQBTxb0muOjtoJqBQemFQD5+K0/MB8GA1UdIwQY\nMBaAFKN5dhc+OEkGEMQiFgUBWkNPa4o0MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAs37Lfiz6s1qCDqT0Tha8mDJxdWwG9r1n\nmu+ww8olASsCIQDwAtx3oIJsTyGQC2Pnc41YnJkTo4NzL8hl41jaHZUZTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXx9FB4jzfFO8n17XIGRFUfTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMGQ4Y2NlYS0zYTcyLTQ3YWItODI2ZS1kZTgyZjNiYjIzMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQsRwSa4kgMooQB1j7LuKgnzLI/3va1dNEoOKHroJmenQ4\nXBcVVzt0XEWb4RjZgcDeNTAaHLBr9KtwKo02BPYuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo3l2Fz44SQYQxCIWBQFaQ09r\nijQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCe6JmCg29DXA+M6J7Ki1xSl7Fx8i+vA2mqsiviDCdOYCIQDjlEdauB+n\nBk8d78XIxCrrtvwwKe61x70ywwrHVqBNlA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAWSTdJVYlHxhmEAQCguuBDK7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QxOTBkYjctNDM4My00YjhhLWEyOWQtNTlhNDBjZmJiMzNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmI2ODM5NTItY2Q0YS00\nMzliLWJjMWMtNDQ5YTJmYTQxMDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nl4XXygiGtnwz3idj4VUco8WAjUqQzDXvs+q6tzVzg31Al8AYLw+Skg21wO3xPpAU\nRFYB/5Ul5kD9USIvn+BmBqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNAFPFvSa46O2gmoF\nB6YVAPn4rT8wCgYIKoZIzj0EAwIDSAAwRQIhAJu77mr1g9kuxavuVw0BHGxOYUpZ\nQyb+Iwrca5gAIcBgAiB+PBsFXC6KcssE/qK+eBhXFt+9frZuRyQBRM7vpRb16Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8028", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8028` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISARGpxi836uT9ZGFV6M0eZGlQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzOGViZDNhLTU4MjYtNDA0Ni04MzU0LTdkZGFlOTZiYTgyYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ5NjI0MDktMjI1\nMi00ZTdiLWI3ZGQtYzk5OTRiOTQyMDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4OtD8bG9kVTZCi50cq9PD6v2PG0ombcfCyMHSIOw7AP2xgmYwTxzonWlRDz9\nmPdyLnaApT4fKru0oa28FSBgIqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFik1NQwExqlXx7FllN247bZrUsnMB8GA1UdIwQY\nMBaAFM8zr3EFQ6GixK1xOf2q6IdhT5o1MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA7pDg1qADEKbAwI2EG2HZWCEesKpgfHeo\ndfQ2kyGCldUCIQDqkeOB5iFTRRUVtmInE+ICBb3aDtescCkyJXEPlfdyUQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXVNraWWjMIObLsZuBk8EB3zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzhlYmQzYS01ODI2LTQwNDYtODM1NC03ZGRhZTk2YmE4MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcaBTffPbWx6ehVpFpEp8VMwgrHryME/Bt2pPKMtZsPpRb\ng5aqjumSK+KprT2NLtgDGndUuDXOAw3vljFIrByno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzzOvcQVDoaLErXE5/aroh2FP\nmjUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbyWFxWpjbdeoubR8Y3AP00TgNwxgBsMhZHunox0ce6cCIQDQyHRDhKYg\ncAWx0Wka8XLbvyyxFwGn9mlL66Fmr2JnvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAasRAsq2VIAYjXiCcv6A6erCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ5NjI0MDktMjI1Mi00ZTdiLWI3ZGQtYzk5OTRiOTQyMDNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWI0NjAwOWItZTk2NS00\nMjg4LWExZjgtNTY3OWI5NGVhYjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBgSQSKDdHIKHNP2MkTpPLT4O3ypDH0wMMehwcQLmNeFiE4LQaWN/znadC4W2Fbck\nN5YNedzqk/Y4N7ROprVo3qNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWKTU1DATGqVfHsWW\nU3bjttmtSycwCgYIKoZIzj0EAwIDRwAwRAIgCeYxShQ6qsYol1MWkFgWuZGiwjBg\nUpDdpdy/Ipcx3DcCIBNYVvv8QbbVP6ebvfhkMB3U2jEXruM8PTiLJR065/Me\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8029", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8029` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISATG2VfhKtFpemsEzRvCiZdrzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwYTI3NDgzLWVmYWItNGI3Zi1iMzUxLTk1NjNhNjljMmU4NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzkyMDJlNGItZTQ0\nZC00ZjYxLTk1ZjEtZWVlNjU2MzMwNzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIL/uSjxo+fHeeefkBfnFurZm2VWMx+yb81uN7mSe7A3NcNJ2SpwF4vGl0/if\noGcDjVoVuUrmK/lXAX0j2rNPIaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTm9/IT6hp8z7dtWbCTPiznjl8OzTAfBgNVHSME\nGDAWgBQUp5t0luJ01FNCpJXzw1t5yDFFUDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD9BPzr0w+sNkKr6QiV6ibgdREgpCJv\nsJ98o2BOBf2oAAIhAKRVO1rnDyZndMjeRa6zqnwlzWSN6ymJwC6Rhgh3TfOZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQuJKwL/PpC+plBW5pnS9c6TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGEyNzQ4My1lZmFiLTRiN2YtYjM1MS05NTYzYTY5YzJlODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrpddh35W3YxBNeL0leVvvoGsJ1cifagF2FhcjON71ZCMz\n5Zh4tgRTJ4d9j/mwv+LC0LM3DsmplI5ODXxYw27bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFKebdJbidNRTQqSV88Nbecgx\nRVAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMvwBBrVIBKTom8dTtFO+yT4yRsyQFbZPpJpw6Q2F4I4AiEA97jHiJA6\naYohkj1gZ98kWVtKsD/YeLiQQ5H06B0mhZ4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISASusrGZ/bHpZLpOCfgfGMHxLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzkyMDJlNGItZTQ0ZC00ZjYxLTk1ZjEtZWVlNjU2MzMwNzBmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzk4YTMzMGEtMWU4YS00\nYTU3LWI4N2YtNGI3ZGQ3NjZkNGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nphkZ0WLgDbFjmdHVQxvDsYjm7YrTNQq7WCqLxW2fpTGKaluuEHtmJi5MB76563l4\n7R7D/owm+LqSZOjoxQWcgaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5vfyE+oafM+3bVmw\nkz4s545fDs0wCgYIKoZIzj0EAwIDSQAwRgIhALy2GuSobvo0OnQ9W76+MjOBLkua\nAYbSkRH/Ki79gTbdAiEAq/U2fuZsTfHThTyD45cahcfIY7v2kxBfFSa4oNuggL0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8030", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8030` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAX2C9dYej+ivs+LRdtHmFU5hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1OTEwMDFmLTJmMzItNDBlMi1hZGU3LWJmYzY1OGJmYmVhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQxNmEyZWQtOWEy\nZS00MjFkLWFlODAtNTMyZDYzZGUzZjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEifDKmPf+TBzar/jKf2bVvHWhkx5BnK/j8wOwScDPCoqihWkKb7vL+qJkXvIT\nn/MBHs4mEnAJ0jakKyps3avIX6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9+niAkKam2Qioz4qLq1yQTO9G78wHwYDVR0j\nBBgwFoAUkjwNIKgdJDJNjX/hexVz19JVH0gwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAUXfBMtoHfpM1g\nqdw8aWQtW4KiEZbDlSbkKrb02gvrXQIhAKivhZwMhJoioV4x6og0YrmAd0eWXrAl\nY3/YDY3GF4Y8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcX8K4/odutCZcSZsqS9lsNpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTkxMDAxZi0yZjMyLTQwZTItYWRlNy1iZmM2NThiZmJlYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbiNvvREeQnXZ1NDUHWYW8WDziRuKSS9eOj21HoXW6zEFT\n/F3mtR8QRFEKJbrV6w4Y7xeDnTQ1366p3EDGK2SHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkjwNIKgdJDJNjX/hexVz19JV\nH0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdOoSj9T1PXydG6JDBuWgjHcNYnmlUsojGQ7L3j3k7tECIQCWo3JOjq2O\nt50X75Et8rKmbNpVTMUTDJCPJU9oaX5t9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAcGL8PbbU11s4yBNXB2ZiTB8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQxNmEyZWQtOWEyZS00MjFkLWFlODAtNTMyZDYzZGUzZjIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWY3MDExOTctODYyZC00\nMTEwLThlMDQtZDE1ZmJkYzg3NTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJwfiWlxWn2EWnUA8L+96Lrb4GKBLQ8NaBkrSyTItuaYLoRvLqk5WG8qV9VVyFS5T\n7O3J7SuiKE7lRJ/q0Ht9z6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9+niAkKam2Qioz4q\nLq1yQTO9G78wCgYIKoZIzj0EAwIDSQAwRgIhAOvqWswFI82aeYuEL1XpUmZ0v3qX\nabdjV46cJWfHxHuLAiEA7XQFyCXWTe/+EtXBS75nX4pUavc3+g5PQd+wCDMwMDY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8031", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8031` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWBPpqJa9hIo/nS1pYlTUmcbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3MGU5ZGRhLWEwMmUtNDJlNy1iYTI3LWFkNWUwMmFjNWEyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FlZDhmN2UtMDAx\nOC00NDFiLWEwNDUtOTZlNzUwYzUyNDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAAsINbV9LFXUwAFTdg7djHCs4J/lCYf+0hFxrI+LTrWPO62nNU53EexbLIcw\ny31gvY9u+gV3cvqpe0JYGYNuQ6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgiPWqKmJ/579D+MhRs6OQ0xnb5wwHwYDVR0j\nBBgwFoAUfrWoSjY31Vbp9DvQB+4GaB7cRDkwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAplFiThy/Zod1\nQTY/rxKXrgDMHC9LKGXRRUpBWkuRS2wCIEEHiVbrvQe4Jg8zyGc186r8hE0wFb5+\nknBpyI1Bt612\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT2BSAr4ItEoG42SF2f6c7eOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzBlOWRkYS1hMDJlLTQyZTctYmEyNy1hZDVlMDJhYzVhMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATphZocOMBfa4TQepSPPajxMgsMNf6ItvZzbp9S1ukusnUF\nhYkpjJRrmtmmtDPCv20dytcY3cln0LTUjGsl+3Hco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfrWoSjY31Vbp9DvQB+4GaB7c\nRDkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKlhvTxoWosurmVb0tOkhhhZZ0pNNv2mAfBcMwuqUBSJAiEAqH4kgPcc\npB1ssPjaYhXaNPhTR5YWdqoJg9AkiOoVJ0o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISASilV3tuBRbuu/LL9VIq8V3UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FlZDhmN2UtMDAxOC00NDFiLWEwNDUtOTZlNzUwYzUyNDE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmRkMWI4ZDUtOTI5OC00\nZDQyLWE1NzgtMjUxMjg4YzU1ZDM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nm3DkVVAjufvuGvaHHrnZ1mxtzCvxgGtCjfdPkIu80XAt4RdsrOLGt7R5r+vhcmNL\nxcRZwZTT0Zf+4GeXOVoIdaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgiPWqKmJ/579D+Mh\nRs6OQ0xnb5wwCgYIKoZIzj0EAwIDSQAwRgIhANT+U3pMCQfofP/lrt84sDdF5uQ6\nwtSyCZyRXWM9z3e2AiEA/qWmZlZ9ET4hmZU+thWTHUI+azFsySvIe4NnDn2+mmY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8032", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8032` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAbcWWiZwZhnAxNBKREonR0/4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZjk4OWI0LWE2MjYtNDNkZi04ZTcxLWM3Yjk0ODNiNTNhOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWUwZjIzNWUtYzc1\nYy00NTRkLTkzZjUtYWE1YzIxYzhhMDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET3640HF39md1/0KU57s0VQXggY3jKHBt6fZzGQQBOIuKmnhzNt+OuZWtFCsz\nVNDMpmdgwLzvspiWqr9k6JkTGqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCjqRL87qv7qoNPD92YoceuP15+8wHwYDVR0j\nBBgwFoAUtx82NJiv+2dQF79Wjpqgg5TSWB8wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBomLQs/6k/w26s9DYwjknB\n1J8CZasmJv9WkbEYb7WZwAIgC+EqelLZ29ihGdzZuJoX6w0695h9D5K44FqMpZw5\nUAI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYP1R4kaTz+zwIhp/e7QNBD2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmY5ODliNC1hNjI2LTQzZGYtOGU3MS1jN2I5NDgzYjUzYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/bwvOSe88uyLvb9kDaKg1qB6kQ66HyTbsw6QvGoybvLWp\nqBQ0OEeaYipcefzxsIuJg1R0TK8YSHrqwdAR4IhNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtx82NJiv+2dQF79Wjpqgg5TS\nWB8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPShBbL4OO6EECS+uIX7XR/Cv8deyEXUbVNFNt1F0YsEAiBsV2Hz8J0n\nphmOlea43fv4EhDdcXhBWksoSTB8i8scqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAQNfjV6f6VOdFbMVicxdURkpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWUwZjIzNWUtYzc1Yy00NTRkLTkzZjUtYWE1YzIxYzhhMDUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmFiMmFlNmQtODAyYy00\nZDY0LTg2NDgtZTYyYTM3MTY5YzAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nF+AYaKUb6GjzQCHxOKyPalr5qBJddAFUeeGvA4vNNNNAhvFdgz/qZIjXlD6roFPK\n8L58J8FehtPfd/EtOLIjsqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCjqRL87qv7qoNPD9\n2YoceuP15+8wCgYIKoZIzj0EAwIDRwAwRAIgHZ5uHVX/IrtPDyD1gX1gI6ETKxH1\nYbwqBjVQO46MawMCIAEMge1qF6vJ87bYG8UwGFX75TVKExqzZ3mxz5h5eTY4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8033", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8033` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAdET97W4ji8Rmb+PyV9fwFhjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlOTZmOGYyLTI2NGQtNDNmYi05N2FiLTEwODY4NWNiYTNjMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAxNjc2NjgtMDE2\nOC00YzJiLTk4NDEtNWQyYWI5YWRiNGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPVo5SIhqL3q8qnttFmqM2CoWZlLcqu06iVQtTrpK6UK4zolgfmU879MBZIBs\nLiqZoyuLsRKMiukkAVn3ok7g9qOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQaWYlHVm9sGrAP8+Ejmt6aWe/scwHwYDVR0j\nBBgwFoAUT4ikXb9LXNi0+3YVj8PIy2abZGEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAP97OI\nJymnVA7F7lP4Z0VfycZKe2OHOEGj2TEB0RRhTwIgSF2J0ZDJ60M6QwrM7o/dp1Ib\nmQUdFepM27t9HUKSWzM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATedTc5mNbF4K2sJxaaKWw0PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTk2ZjhmMi0yNjRkLTQzZmItOTdhYi0xMDg2ODVjYmEzYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLqtQcCe1O2B/OteX8N3R8e/1kQ1SwuEsmDC9SIMaVe6k2\npCds/uygHtlCyAiEXH2XOwH1LlnrATAuqJoB6z4Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT4ikXb9LXNi0+3YVj8PIy2ab\nZGEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcV0u5LpEu9kfZEIg96zYUGfH+YGwoX3hOoRVqc0gJfsCIQCnGsBdYuaW\nc6Py0R4jJ7C8h+y7McgPdA7HRVZzss8pBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAQGM2BDxKsIKNyjYSWIils2WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAxNjc2NjgtMDE2OC00YzJiLTk4NDEtNWQyYWI5YWRiNGQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2U5MjhjNGQtNzhiMy00\nOTYxLTkzZWMtMjczZGY3ZDc5ZGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/K6BBQU+zrZj7i6sbepFN41lVn0NpYkyjlgTBs9QFfOb3FNoM3yKsRwsXeyV+IWx\nDC2/7W/S3AB2boxsYAyTz6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQaWYlHVm9sGrAP8+\nEjmt6aWe/scwCgYIKoZIzj0EAwIDSAAwRQIgR8WEy//2pn3R5kJWO4kZxlsDFTAo\nrnpNk7KS+pg3D/oCIQCOlHJ7fdIhWQu717MutitBlUCb49aAt2rZTx91hphYSw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8034", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8034` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAVVBl2V+Qcdi6nPYXSoGGSeeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzYzY2MDAzLWMwOGMtNGNkZC04ZjY3LWFmZWQ0MmJiZjU2NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTUxNDQ2ZDItNGNl\nMS00Zjk5LTljYTgtMmE5ZjBkZjg1YTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzYW5ijm0zL3/Qp1fzzcpoKPpWoPq0oCZODcA+/4ZYZcJuUi/+IHmDo7hw8Op\nGBQNf/r3JOJQRhIAIDyEm0dLd6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUTgzo1Wfh10A0FC42LM45pWVyUkwHwYDVR0j\nBBgwFoAUiaLW7tlH68itFgS8ECAH3jh0pKowLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAQVb+o\nQcJEkEz9jOY64AydGBlZp83+vr8OKX6KM4ddxwIhAP5SdYCaLA8r76ldyGUE2TC9\ns3iS5uktG1Lb9c+saQiw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbT/gROLKkRai2OyzHjUh31JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2M2NjAwMy1jMDhjLTRjZGQtOGY2Ny1hZmVkNDJiYmY1NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/nq4O8QHThlQqrQD6FTk4ogVtIu3eqmNa3nX3RInhUONo\nsl5XBAsT3bjpPJAYgAR6hJpHJu0o6GnUGWI7vtwgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiaLW7tlH68itFgS8ECAH3jh0\npKowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMUa7Vki6bIIfEMUqCmrcuQZyjrWqf1WWwMx+OA/Ar8qAiEAxIabgj5A\nKrPp7IXZrWUAGZqn71j8G8K7R/Dn+gDP7hQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAc6Yipne2P+35LEY6CGsREpJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTUxNDQ2ZDItNGNlMS00Zjk5LTljYTgtMmE5ZjBkZjg1YTQ3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2IxNGUzYjktMGNhZS00\nYmQ0LWEyMTUtMTQyM2ZmYjZkN2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYSST424jy6Hje8cu4lbhGbGVEvvDJxjrI27kOuIO3hdOLVuE2j72CBm4+LOsHzPA\nFEFFIj+P4t/oJhpXwyfYCqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUTgzo1Wfh10A0FC4\n2LM45pWVyUkwCgYIKoZIzj0EAwIDRwAwRAIgNttwmh6KZFIQqWr8E5Y/JOnYY631\nGURPQvyaZvHFx4YCIDVSf0fC10XXPb/df/3OTYhXIsN0uJmIMfiATJZpSkc1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8035", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8035` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISActObtgM6tKD+S9pO4apL5BTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMGFiYThkLWE1ZjQtNDc3NC05M2ViLTk0NDZkZDQ4MTQ1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkxNmE3ZjAtNzhi\nYS00NjMwLThhYmUtNzM5YmM2ZmJmYTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE113kSje4BXsIIbKRFJg4LZ1IKs/k/HAr+WTyp0YPvQhzwVI/eT8K851uIlkN\ncenghv3SfDKL7y8GWDHBAn6yX6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKV4A2TDj1IORqPLwgB4OJj+GDJSMB8GA1UdIwQY\nMBaAFM2epDHkoqjtV5AHxbSWerY0hv2VMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBoKmSJyLd560hYxEXHweBzGplCc9M2W5lY\n0VfI84/IlAIgLC6ZWHg6Kd93oT6SVnLMlgddUggagJ3QXvxhs+mtvPo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc58mBvSM+JfrvwlHVmGA2cBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjBhYmE4ZC1hNWY0LTQ3NzQtOTNlYi05NDQ2ZGQ0ODE0NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSmR5aEX/PBeknk9bBqEA3geNLSAMPNrG96pxrjQwiJMBW\nBjnDMn4jDpjF1EsOCD9qCiZVjlzaCXq6m1RjaZXVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzZ6kMeSiqO1XkAfFtJZ6tjSG\n/ZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP6NHsqZFc0k6tn00aoD+VGUgAlXFi5zSsEYuB8qVUCACIGKHeiWHdcVD\nbih6CufTwibr9kyQLvupXEzNDnM2ygiF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAX/8niovA+6upm9HAbMLdxA6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkxNmE3ZjAtNzhiYS00NjMwLThhYmUtNzM5YmM2ZmJmYTM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDRjYzU5ODUtMTVmNS00\nYTYyLWE4YTAtZjFkZTcxMGExMDgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntr7hUe3KTfYKhrN2/Hr+d6IAPOUJ4nusP/ZcYJt3896y7R1XBqaVdSmxfP9L6Oe7\nsqNjEHB8RnKzB8tbfb5aQaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpXgDZMOPUg5Go8vC\nAHg4mP4YMlIwCgYIKoZIzj0EAwIDSAAwRQIgfYqlW+r56I7lqbZ/UqcNLbIoR/XB\nh6l8qH7Q+NocZKQCIQCwoPQD/rmKBUDPdPdtJVYsnMmgxFfN7jD3Io89hnIp+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8036", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8036` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAQ6RJzEIf5mw5EIkUOCIpiSqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3ODBhOGY5LWEyMGItNGYxMi05YjExLTk3OWI0YjY3ZjBjMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEwNmNjMzgtMjdi\nZC00ZTk1LWJhMjMtODYyODhkNTg1NmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsXPuUEEDLhyxJF2DhT5/XTpHICIFtkNNdoDTC32U1Tk+68q6nQpZk8i1DPKx\ndxtyZoRCBEvMa1pdoaKpAkVkxqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw3cCfMJfxfLzJIWGTdKkwxHn0DcwHwYDVR0j\nBBgwFoAUOn9aS8Qh0uNytPRxfVajmuchdIowKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIlZBCIj8nBN\nSR4R7du5slcO70YZmCTLJu/PzWf2fcY4AiEA8O/8q8wLzWBdr6zYY0aAXaeSh4Ck\ndcMAeexKOXCyC1M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV6Yc2wusE5TeV0yI920EDBsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzgwYThmOS1hMjBiLTRmMTItOWIxMS05NzliNGI2N2YwYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpGNWjq7OjDMmXNU3FMNeWRW2w8+5pNsxA/qKxvgLHFjiU\njfwDEIgeGgBnCRrpY+Bw6qKaWU3cm+JppW28MAwBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOn9aS8Qh0uNytPRxfVajmuch\ndIowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOE8tNvaxj539Ws7SDsFgrUn+CzgbbZ7Lrrh2rg6oPi4AiBVV6RMAmoW\n2+gUGThWxS0kr8NR4nfH+mC8Rcum9VB2pQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAQTFnzAAB3eRAqCbBRIj7VicMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEwNmNjMzgtMjdiZC00ZTk1LWJhMjMtODYyODhkNTg1NmYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmE2ODU1ODAtNTMzMi00\nZDkzLWJmMjEtYjIyMTFhMDVhYTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ng4zWJb8n0Vfdj46dKpc6UAts9kI17C+eGABtcEVS6bDG0jZ7aE/5FoZgUWkJsirW\n8JmlLJJgiMkeh9en664UgKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUw3cCfMJfxfLzJIWG\nTdKkwxHn0DcwCgYIKoZIzj0EAwIDSQAwRgIhALjRPOyyFO9c9Jet76VYAIKNblAl\nQ77mlj1yup6fRY7AAiEA6JlJMOpNHS4K1FqAkJy1QvQwS6p6lxONVWfoqs29Ng8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8037", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8037` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAeJDLHL5gUa/wYIOPYDxmO/WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhOTk0NzUzLWI1NzktNGE5Yi04Mzc5LTRiODY0Y2Y2ZjAxMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTllZmNhNTItNTEx\nMi00NzY3LWFjZjAtZDk2Mzc3MjZkNzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElyBz2BOnfLTTfu/5G1NNpCT7rXmCyyKB4gDiVD+B3qqvyBvQi4bkIVvhXcBc\ncaf97GDYmCsWZygsQivYN48UZaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUotDBO1k3XTjPXcYL8RCBUYOwBZEwHwYDVR0j\nBBgwFoAUNI6rsXhgMxWs83S86JUVJ/ldUl4wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgBItrUQcoHzVt\nR3qyhrwGUGb/svqXSaAo3q5D2YLTlBgCIQDZzTmi4v0DJWYYNwg+vKxXsF8+efia\nPvvKulM/rz+lLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAefGNMfx21/eI3Hj1K45kurAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTk5NDc1My1iNTc5LTRhOWItODM3OS00Yjg2NGNmNmYwMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzTz9q/hLDx76KA1MI29fQjoh9MHGxFPEWnkKAlbrRMKaj\npQ5YF5zCsF+ZF3/3bAbnrmr6RmLGfp+iW7ADacYno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNI6rsXhgMxWs83S86JUVJ/ld\nUl4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPMaETOTbxRVHynvrN/n+7gffUWCQmhw55E1RWw5kteSAiB/Omx+XKFy\nItqEeLF/9lJXv2gF0cH3X5I9HIHsGi74Tg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAe1kVPyK+4O3M5d6SLl+uf5hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTllZmNhNTItNTExMi00NzY3LWFjZjAtZDk2Mzc3MjZkNzI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjc0NDkxZWQtN2UyMy00\nZWM0LTk4M2UtZGM0MGU3MjEwZjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxCVpyXb2x4u+NQCJCNsythV3cpAkVEYTv5k7XTpxL2kvHqesFxiE5liy44fvl2FV\nfZu0MF/eqI4JeXrd7MOIvaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUotDBO1k3XTjPXcYL\n8RCBUYOwBZEwCgYIKoZIzj0EAwIDSQAwRgIhAM8OAHKAyb2ccyi5rrJERpj7MZmq\nNJtP4u6bKg3QFUQJAiEAvYwilpAUdZnIWgaDP4V2Hrx2QnSgdKPgGs4bXgNJiTs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8038", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8038` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAU2gf5annwAk6gbffssdhLDJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiMGNjMDQxLTYyMWItNDA3MS04NDEzLWRjZTQxMGFhNzkwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VjMDhiYzEtMGM4\nZC00YmI2LTkyNzItN2YzM2M3OGFjYjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI6lfR23Wrb+8SbXVUKssphI0xfePqLN7zWTWZIc3Sn/HwonuQc0+hSEMvg2L\nCi2I00FEPbcK1QIzveHbWWBTA6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ43jmLcZBKGVCyF8MwqWduz7ykgwHwYDVR0j\nBBgwFoAUnatcnwij8lr87YghJifYmvfe8uswKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDfM2XPVCgh\nSHN/CkaJu3dgY0Pvp4Gsy6vtMLBy9LqtOQIhAJQoJRTroikAsf2KMzIPfTYB0Qsm\nq5gQeuRFQ0n/cCx7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAerSpXiQiGBA/7XemS9Hml4MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjBjYzA0MS02MjFiLTQwNzEtODQxMy1kY2U0MTBhYTc5MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPPRzFcsuQ4M9RrgtdUOzneCsoSjHmOgIegP6g2cKsmL9C\nMQfDRdHAqYrOEIe7Dnx6ube6CS/99RSVrGJKXX+Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnatcnwij8lr87YghJifYmvfe\n8uswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYYRmcQGTNerLvcFjepfOY/qac3M3sM7y1zQqzJhNFMUCIAhnNZnpT0gw\n3KrLxcNC2a3lr9zgp2tLBwjXIxgpie6j\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAVV5wgFw/BjWViUtRuVIi2G6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VjMDhiYzEtMGM4ZC00YmI2LTkyNzItN2YzM2M3OGFjYjQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjQyOGE2ZmUtZGEyMC00\nNDU4LTkxNDktMzI1MzM2OTYzNWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0hBsdHKaswx+No4ih3DQN4B4D6kbYJeVvtHr3ftL5F9kntfz6plq1RjdZu5dLLbZ\n+gRmltPgNSh+Z4HjhLdeP6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJ43jmLcZBKGVCyF8\nMwqWduz7ykgwCgYIKoZIzj0EAwIDSAAwRQIhAOaF6WKI20c2Tie/mKJTbpbPSFra\ng7Od0ja8BpVDRQknAiAcSa8gFZ/ITVQlGxfYtCnNkBXG8SXgUnRKlDd7zxY5dg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8039", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8039` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAUcRfXccr7H6y8Kes5RPHLHfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmMDU5NmY0LTAxOWItNGZmOC1hNGZjLTVjZDJjZGUyOGY0NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhkODgwZGUtNzE2\nNC00N2I0LWE5ZTUtOWIyY2JhNjYzYTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkpT632NIyhPPCI9cQLSAf250aljxyCdporYyULs3C6r+NJieM4v2ZkdHJahl\nQ1Yjlxerz+0ui8QktbFvDKwUyaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4xquZpp7f0YR+cIgGKBtt4Dr1scwHwYDVR0j\nBBgwFoAUTe+/OhWv79U6frh/5UDXAP3BmJYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIE+o7SIg4kV9NH00qqPbrJaOv4jN5PyBy63O10rOxpIzAiBPyyAWwi+vwTui\n5zXGAfNLb+n2yd4fp7aBqrCfpJw3tA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ1cLi6xw3j7ZawBdhlMxi6pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjA1OTZmNC0wMTliLTRmZjgtYTRmYy01Y2QyY2RlMjhmNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQDs9I4Qp9HxYG8bmjQMCobD6PIWSFhUF5QYOBga4mlB2St\ngMW65NdOI8PaxFw7m2JG4ZXd626smF6dEJ60PS7oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTe+/OhWv79U6frh/5UDXAP3B\nmJYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJrOigICABRegJFg0LeneLx3mbeQGI+r40Ysf4KG/mY0AiEArUlxzmAn\nKnJ/l/IGDMgWJRloKs1Ky1cB6IvLX4HLG6M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAZ1WcB8ZtN+TcRI8jfNt6fbrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhkODgwZGUtNzE2NC00N2I0LWE5ZTUtOWIyY2JhNjYzYTU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmY0N2E1OTgtNTVjYi00\nMGRjLWJhNTYtZWEyMzBhYmZlYmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntPSM4hhWvhV3MzEcGwCjAEJMECIGYohdTBiL45UJQWlOuiT4uFnEv5mwD13wMA2r\nUSWELZkqEbapT7RKBTjbXaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4xquZpp7f0YR+cIg\nGKBtt4Dr1scwCgYIKoZIzj0EAwIDSAAwRQIhAI8Wdd9070K4xi/780urGe/0UAv4\ncEaC654hVwdiu4OSAiAIskdT7CVf/VEygnCD/Psq+UGPtZ2tVEchpQ9gASEdeA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8040", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8040` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATRRJLtziQjPBd10elMX3cqtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4N2Q2ZGY5LTJlNjktNDNmZS05MzNmLTA0YzllZjQ1NDQzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDUwM2I1ZjQtZDA3\nMC00ZmQ1LTljYjktN2Q2NmJmZjg4MWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ3Q2ljv9nOp/Q2UVLdlqFYCSfqdzuUPxXtgE+mjmkHKbBCifie/EbuwG11ot\nYSIizX+eMD/RzyoaTS34lE39maOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxsdGLXR0tEM1iAgdFlzimo387OowHwYDVR0j\nBBgwFoAU6GfRc1A19fKdCeumijKIi+3qEQwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCdCRltSc0tcboKoy0uz/AUYKkBivGPxzgAv/8TuIYiQgIgKCbJlKpVyE0L\nuS+y5tbyVAGjarsHFxAU7+U54cWaJtA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdmnKJvnDKxMLl0gkp6ZI4HKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODdkNmRmOS0yZTY5LTQzZmUtOTMzZi0wNGM5ZWY0NTQ0M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZnNLMcEoLmRLORZCLdV8lEkxnO/6jvEcczdj58fhGYi88\nIT6pbxoFmnbVXerF5OyIop7t5z+5zO4fSBsxnjtDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6GfRc1A19fKdCeumijKIi+3q\nEQwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMtZLx4R1+Xt0v56BI82rgGMttSe9/PeBI/T6pXzIcNgAiB/KggNX6aX\nbqHkodLgSLfU+HD0yDlE4+iC13Brc1wMqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAZ2J/DWVmvJIoFYzf1dgn+LCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDUwM2I1ZjQtZDA3MC00ZmQ1LTljYjktN2Q2NmJmZjg4MWIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2RhZTBlMjItOGJmZi00\nOGMyLTk0YWEtOTljODQ4NzhmYzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nx2zg3LLCnBe/Oz+MotVByTu9OrgJzSYPdSlYkBGTCz962LCqjgrGDWG3OSqoCfRc\nBmYTaqsY34Y16DVfwo6J/KNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxsdGLXR0tEM1iAgd\nFlzimo387OowCgYIKoZIzj0EAwIDSAAwRQIgPuqzt/IWwQCsCfkyJEISMV6RxpGy\nLu0fUFWKGgIe1koCIQCy/WjXTiU7QHPJmNYewH0O8TlYP6kvb8FAV/igEuxoJw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8041", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8041` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAfgf8zTnBIChnCVCweE5DXQAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZmMwOTVjLTY1NDMtNGQ5OC04YzgxLTFmMjVkODk1N2Q0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQwYzQyZWYtMzQ3\nYy00OWNmLTlkMDUtNDAxMDUxNWZkN2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHa3jON0ukNHsnqb7osoUhv518/VnD+iUkgpkPQjiPY8SoVQfsUW41OHOSWsI\n0PoiUXP8OXvIw2L6Sm7+Gt9Nl6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxLWh+BM8/jMuhIg+2SB29UT6GuwwHwYDVR0j\nBBgwFoAUSU428JFDfb6acv49trDmEu52yGEwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIARW\n4+V4YmPboWnGTEA2wYQAblt4x+tfz+zrJQwCszkRAiEAi95R9xCE3VHHaHAJy3JC\nFltzZJFCIuIi71T84eXv3L4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT6OcngBnI/w5wbln29SrTTgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWZjMDk1Yy02NTQzLTRkOTgtOGM4MS0xZjI1ZDg5NTdkNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdaoWViDA/mgVqrP3Wa6T/P4KzDcyyeuE+kfxcVscyEQ5f\nra+c/oiRj74cXzZICd/SfSBveKf/Qn4X6G4hDWn7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSU428JFDfb6acv49trDmEu52\nyGEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOc/scRtUbHtlXsGbS3QuFPxJ5X0qWro1Aiow7hofA24CIQDvqRdnz3lM\nOcoJxqSSDiqlxDYiqWv0bq3GaI+/7nZulQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAZxPKxokCSrTMQv6nO4Zo5bhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQwYzQyZWYtMzQ3Yy00OWNmLTlkMDUtNDAxMDUxNWZkN2FiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjg2MmQ1ZGYtMjdhYy00\nODRlLWFiMmYtODJhNzY5ODk0ZDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmahF5zQzVms1Vkhl4tTFrKW/ZNWQOI/3No5cqFqafvOX3eWA3iEQgRhtHWHampHB\naefpTZ8VUzITN5kzFPfp3KNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxLWh+BM8/jMuhIg+\n2SB29UT6GuwwCgYIKoZIzj0EAwIDSAAwRQIgEFSeuflAjGlOrT/I45syy35rQ731\nL9s+FEgsedhIWGYCIQDcYhWeXl+cVoYDmw+sZgopP4R3J2VbJGddHQK0r2HLDw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8042", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8042` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISASrqBaJ9lGJj4QQMLeKSNmQSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmYTlkYzg1LThhMWItNDk1Mi1iNmY3LWRjMDYyMDBkMTI2NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE3OTRkMjUtMTlm\nYS00YjBlLWI0MjItMGZjNjAyNzAzMTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnxZgubciZmvj6Owl/zRyeqy8MXqbyF5xFCFEG/958SGhsA1tLJheoPQgNWnt\noiatGL9tNa0wvKVXERws3y83yaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbkPhK1cdjI0oZnXl9UFYhXshK14wHwYDVR0j\nBBgwFoAUx2UTwgMV1sc3pBi8nBl7DM76yLgwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIF2jmrO0dFDAGsCs54DSM1H1Bm8qkLfqaJvzuf3/qBJAAiAraVm7\nyN4qIlHB3y9HDgsy/T5VNj+3sYlCURObrNw4yg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQm7lEui2o4r/rre1qaLRUN3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZmE5ZGM4NS04YTFiLTQ5NTItYjZmNy1kYzA2MjAwZDEyNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATPdNbtEM7/YSmjtL0vuiX2vrdipszJ2g3VdSm9iRJsk0sX\nxlNSBZkjdR6ZHF0TQanR69g2aaGK3UPhthEbffCxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx2UTwgMV1sc3pBi8nBl7DM76\nyLgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB8P+hjAqe1X++ettEB9D2dA/1UV5ydlL/DXpQHRRDvICIBkKgjKVjBIz\naLdbdyRg5UMqzJAhZWYK4PZbrrgaCIuQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISASLlWcSKYszkPrVTOCQN11c6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE3OTRkMjUtMTlmYS00YjBlLWI0MjItMGZjNjAyNzAzMTg3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjg4ODgzODItMTRiZi00\nZDkxLWE5ZWQtOWIzZTAzYWRkYWM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/BH6sq0E3+GpvspoOghqxuzt9RTf6e56Nla0oXFKt6QdMCSevNGh9HVXyOKL5MRw\nkbWmXi5aIhFfr6tB5OGoKKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbkPhK1cdjI0oZnXl\n9UFYhXshK14wCgYIKoZIzj0EAwIDRwAwRAIgV29HviPXsRoBzVSlkE0ty+G/0kH6\nw7+Gze8rmy/dxI0CIGwhpfcXlulgDkKU7RU3LZpWBkp+24WcbD4IkNdXBSYm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8043", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8043` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZCwXRQfewHau+C3Ga0TVcvkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0NTI2ZjZjLWEzYTktNGUwOC1hZWFmLTljMzllMWZhNjUxMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUxNWE4MTEtY2Ji\nZS00ZWZkLTk3YzAtODI1MWIwMzQ4NTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJqfgNj15o1irg6YmugKzbGgmaBUUh3BLN/+X75htm0xRHvngqAqVC2PShKxr\nKptisUMy85K94hsjQY16jMPqx6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfyuiZiJiQTE45ma3zr/hp7WsroMwHwYDVR0j\nBBgwFoAUQaWhFZLPm6Aqz7BL2YznZnVvkqIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIAWRs9XJy3olvvpzbSLbjMJarqs+VhNG9okPzKq78iOnAiEAmFCN\nVASBUYD6XKB6vx/tibkXdc8ICTknz/WrvAfF49g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQsIznGI/U4zBiwyzxZU9T+hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDUyNmY2Yy1hM2E5LTRlMDgtYWVhZi05YzM5ZTFmYTY1MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9B0Zteo6dQ3LBRkohy8w40V2Z6keb5u2TScRSmWaw++PS\nU1Dn1gA6IcJQcLboY2Ub7atYdk9s6zeYuAP1fGTto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQaWhFZLPm6Aqz7BL2YznZnVv\nkqIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSN1lVFgao6uLP5mxSz2SwIIL16dQmqWykgztvzpTxPcCIEAiOQmxYdrC\nRz8jKuprhl+dsWZ2NkOG/VsQKU6ERavA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAdoU/o+GxHjCqLQGXjmk09yIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUxNWE4MTEtY2JiZS00ZWZkLTk3YzAtODI1MWIwMzQ4NTczMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTA5YWY0NjYtMTM0Yi00\nYTQ3LTk3Y2ItYzhkMDhmZTMzZWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUJDGlHCg36/6tGQqWNodmByF/M5QSiHejuwJrmsMYKz2WhA5Zzom9KMeY/UaKL4S\nSX5iH8RtFdsv+F4D8amq4KNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfyuiZiJiQTE45ma3\nzr/hp7WsroMwCgYIKoZIzj0EAwIDSAAwRQIhAJhCFEwxT4yp4dsGAM/HRqdnIiP6\nRQ11gJ9KkJNlsQezAiA+5jQY4KvX+tKjy7FTgZCv4Q86+JIPXdKZH8Z2d7G3AQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8044", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8044` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAXtaJ49LX50uw9XgqrStaPLDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3OTM3NWM4LWMyNDgtNDRlNS1iMWMyLWY1MWJjYzhhYzY0ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFhYjE5MTMtMDVm\nMC00NDJmLTg1YzUtZDI3MTg3MTI0ODhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO1H86krLi2i5FCSyAfuDyzu4pqjjSUxCStC9wdcwT0vl8tKqFGgZuNvY0WbD\nQocVvmYjSt6zB0UcdG4DckO4waN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFE2bSRzknLgXbhGcMXTTOJ5mGK9kMB8GA1UdIwQY\nMBaAFOeb5P6JiNqmoAzcesA73f2eOUvPMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBG7ClwgrjsjfwFZEuPU5Oms5/UW3eWsBi1\nSlSEhrfDBwIgV7AdHnR5HWrvpxjaXfxC67Hk83vzvazCa4KddecLnNg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfGF9o0sXkwNMp2xQNwQzMkoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzkzNzVjOC1jMjQ4LTQ0ZTUtYjFjMi1mNTFiY2M4YWM2NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARW20Sd2e3nKsLdeGzC50IBoWLlP0kXZbkKakDIByJjjeT8\nOV31LtEgue5ibqoLS3NrfJIXbs221JABlJTLVz4So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU55vk/omI2qagDNx6wDvd/Z45\nS88wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALpEQYL5CN5an9vWQKeHBylgW6igF1Sa3DNWKf2+ka+xAiBhqj3MbJrs\nIs2HNJyzwKxUyXPvQCwYreYWbRIBkWZ2vQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAeO7isX8M2g7O1vQ4xiPleXdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFhYjE5MTMtMDVmMC00NDJmLTg1YzUtZDI3MTg3MTI0ODhkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDE1NTdlMjctMGI4Yy00\nZTk3LWJiNWEtOTBiNzc4MzQ1ZjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nW6QbcFMfma1vbLSszs1+LN2uyJ4lvHXHScPraTkMxveK5tLs6hLyDIo+0LzQ5XiD\n3+qG06XOG+3K0KZwplo68KNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTZtJHOScuBduEZwx\ndNM4nmYYr2QwCgYIKoZIzj0EAwIDSQAwRgIhAPv0jjatswaKwBhhozgK/fBUOhLN\nLqD46C9G17m4rJrgAiEAjpextgoWLlj3cMS9rXBGy7TPDBZhYRI1zSdZgarogdk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8045", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8045` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAR5rb47wkvapjXBm38sqwWpJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4OTY1YTMyLTBiZTItNDZjMy04MWYwLTczNzdlOWQ0ZWQwYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE5MmM4N2YtYjA2\nMy00OWRiLTk2YmMtMzE4OTU4YTJkNzAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuab9DUmvHmgCDaqiLRKbWhrXk5AiFy+8rQvdn/jv+Kmy8lhNvTLynAuKrmp5\nq9Q74ei0BMG1ixrSisrICmKWEqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc2hMHsD7oTwWA44uOBj+VTv1ACQwHwYDVR0j\nBBgwFoAUVmlImjTG7tb6RU6wfv593HDVzv0wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIWowXmvai4P\nIp5iNTYpd1nOjc4Pc8KAC1AQgvqnhy/gAiEA6yPIgNTbb4s+WpEJJ6q1WJCUJwl1\ntoGOE0Qmxm+JZy4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAewLTzzog+miMClAOjl3viVRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODk2NWEzMi0wYmUyLTQ2YzMtODFmMC03Mzc3ZTlkNGVkMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5uGvC9Yrnq3VRzWsHhbykIXd9DLXQK2WudD23Y9v6D5UJ\nMedz9j+LKVaeg0qUy1FQGY2lGM0Xs8l/aemRwyDqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVmlImjTG7tb6RU6wfv593HDV\nzv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALK+S2wqfYi//69UgNDXv8owDmqXu7J/TA1gnrIc3o/lAiEA4/ehn9+C\nDF73Mr4lInl89PDemJaldpo+VqERnkuG530=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAceR2AHTdpfZrQf8MQd17g0LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE5MmM4N2YtYjA2My00OWRiLTk2YmMtMzE4OTU4YTJkNzAyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2YzZjI1ODYtYmNmNS00\nNjEyLWEzYjItZGExY2ZmZDczNmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLulsn8QqLMn3ahAD613WtoEgPsDqvMjr2/jUyaqZ9O4z505Ysk0wO4DINeK7+LGg\nmPmBQk3AzdYmhV25v0G3eqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUc2hMHsD7oTwWA44u\nOBj+VTv1ACQwCgYIKoZIzj0EAwIDSQAwRgIhALsmxbBNz7ejPIbo2rSkkXGCSQns\nX1xoqtZW9dTzf/YkAiEA0hflh8hU85tWbI1RX7C0z58YuSRAWS5gKFPUauMEDrY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8046", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8046` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAW84IPtRYJ9SdkwQ/JmipNcyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4NjkyY2ViLTU3ZjktNDk2ZS1hNjI0LWY4M2U4ZTQ4MTQzYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUwN2NjYWUtYmI3\nNy00YTBiLTk1MGQtNGYxNTQzMzY5ZmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErKeHiyW8kkyKBijo2gRgGyIXRaPaOIPPuQ0H1JrbDBuz8JGFZ2IOIEBgProk\nObnC4eCEiD7f4/I8WYUf6sAtvqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqhLZaBwzXDxbxHO9/IHh0TOq4J4wHwYDVR0j\nBBgwFoAU/fGZCCPbCt+BlTJSeT7pu16GQiswKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPx2b6l5bk1a\nIJoe+MZK2A4ubm1VrpAKqEcg0Yn52j3hAiEA+dQNX0C4hIT9oy1yYiDjzZ8DhLdo\n7AQGt5NPnDa9+kI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV/dmgBzoPOPvE1sbQchN50wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODY5MmNlYi01N2Y5LTQ5NmUtYTYyNC1mODNlOGU0ODE0M2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi1cj+HJF3WIwITXpEZAqHOu8gvWIkSff6vsWVGNPd7gyd\nWR5x8Ox0CjrtkoTDkFP1nzAgJHv5BAL0Q4+5yQvWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/fGZCCPbCt+BlTJSeT7pu16G\nQiswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO+DmPhDksaLqmyLotdw+RxbCO0RC9EI/2eV6SPMX5OgAiEA1/+jFUA6\nQV6WaoNph51qo3FtiU+OvcddiA2nJblQzWk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAaGjeQjVrdL+2EWLWK0Q7ZQfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUwN2NjYWUtYmI3Ny00YTBiLTk1MGQtNGYxNTQzMzY5ZmNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGQ2MDZkYzAtNmQwMC00\nNmJjLTkyODMtMWVkNjMwYjAzOWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nee6nxeLopyExytzgoQCjH9gW8HlZmoBfbtDa/P+1cf6GRFiIfkRJi0/eF9xzD7A/\nlR3/DRLLEhiqroeaX5YER6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqhLZaBwzXDxbxHO9\n/IHh0TOq4J4wCgYIKoZIzj0EAwIDRwAwRAIgYexKhG4Lj/etw6utvJ9P/Wh2dNQv\nCHxI288j8PkIZhkCIE57yCZgI3kOPE4Bb7etNUvz8/clalcLNaVePocCvQT5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8047", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8047` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAd1EHspK/QkF6kv/GaXFfxV7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzMjJhZjZmLWEzMGUtNDM1ZS04ZGM3LTM4MWE5ZmQzZjM1NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWQ4MDdhNjctNDI3\nOS00N2FhLWFmMmUtNzJlOTA0MGYxZjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYVxVy1ta7Je6rmfue34dsMqWrRJH4vqJEGCn7YRatjGsDsvHemRkVh3TRpfW\nVjiJMVQUVcf8UPjI59hgTTS8wKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZJydKbP/fFCeUR1Igukc8faR+gkwHwYDVR0j\nBBgwFoAUqSsK86uFcSygFWRaUqRXi+uYN1owKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCrY3MQRkO+\nmve86V7YXRAraOZaOp4F9O2rOurkrE0f2gIgMM26UJoWlhy1I5njc3hgj91OYgwj\nFaOLyV9IbTguO8Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAftQz2ura46uTTWPXBJLiUIIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzIyYWY2Zi1hMzBlLTQzNWUtOGRjNy0zODFhOWZkM2YzNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4isC/FxOOBKEs34saWPQKT/4v+euoXtLOrSZbcNLnaHOB\nutURmcygr8p5JdoLZr9oN1tyaAPrVGnr7AnLzAXco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqSsK86uFcSygFWRaUqRXi+uY\nN1owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOe54WfzJLkeYz6o8caLjzKWfhG/xA/eLJB8d2PACTXMAiEAq6arB8WX\ngjzLwYo8xWtw1109YgQpfbFJm/a8uDYWDQg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAfXcpGVgMY1S+NPk7shRgM8pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWQ4MDdhNjctNDI3OS00N2FhLWFmMmUtNzJlOTA0MGYxZjIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzBiNmU3OGEtZjliYS00\nNTVlLWE2YjMtYzY0NGUxYzQ4MjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngmhyRWDHwMZBpjJ3dARhlXX1eyvekgl0Lj+w47WKD1hYCvqfqC/m7ObrnDpHCcqG\n3IrOrRz6CNxZqN/C94wV16NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZJydKbP/fFCeUR1I\ngukc8faR+gkwCgYIKoZIzj0EAwIDSAAwRQIgSUx67eih2Ob7xvYHiAqt/Ljpn4PV\nt9DPpJCX5U8yyj4CIQDadhkqkMA9xUdHge+I+anSn7cf5c69xvbJDu6mdVDdeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8048", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8048` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAX3lEpvWkojjydq+K7dINrssMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmMTU2OTdjLTdiNDQtNDlmOS1iNjllLTYyNmIxNmU2OTFhYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzY2MjgyZWMtYjEy\nNy00ODA0LWJhMjctYzNhNGJiNTZlM2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErKO3Gp5YQiunrSrEJDRRezqF5uliQ5fyekAaPjHqoqafTVW1YWiO8EZ1f2Zz\nOCNk+9se+aN74+jfrVlQzSgLlqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDBaZQACWVujeXBhdKao1NhkrPjcwHwYDVR0j\nBBgwFoAU4336Pcdk+2AUb5DxdU23ATpHH1kwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICvc98bHUcJpHSV8HHS23JuHAEmpjVJEt1YfcWCiUJNhAiBpvby1J03HKMv9\nP6ULecfz88SBUl7ojc1BQqKLK5Qzmw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdGMzlAK9SDl72JU8+9HjSrQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjE1Njk3Yy03YjQ0LTQ5ZjktYjY5ZS02MjZiMTZlNjkxYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKqSH8CvBrtdnmpDBQca82VB+Fgqw49Jv+fvdeoTZukgsP\nPpOd6Wdnu4ORH0hBs0gsfyiKqJJfapdbi7cOw2lDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4336Pcdk+2AUb5DxdU23ATpH\nH1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOX7k2OxahsnHaF13RFCp5HISmUMrtyaMD017449wO7EAiEAyplCoBUR\n14/W6ZZoYIN0/sfuhSxTlhdhWLtFkwtG2P0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAYJ0eYYKHnDTrVFqLhtw6ZIBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzY2MjgyZWMtYjEyNy00ODA0LWJhMjctYzNhNGJiNTZlM2MyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDJmY2ZhMzctN2Y4My00\nMGUyLTkyOTItODg2NzVhY2JmMzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFuqOR5uLuw9C8/gtIkavPubDVGiCBvgsw4ruz+nMtRmBX6+rCqGuOvSeBVIuV7+s\nEx17DBLgJe/C1KvMD/m4NKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDBaZQACWVujeXBhd\nKao1NhkrPjcwCgYIKoZIzj0EAwIDSQAwRgIhAIAdg5l5jC9iI+CMLPpRtoCJF0ds\nCzM8Wmt159GPowRzAiEAktXDtvgryGDK/TxOueelgvG7YYK5ZJ9hq9LBomsSSDw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8049", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8049` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAS6/hF1GfE60RsRBOyd9BCL0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5YTc4N2E1LWRhNDItNDRhNC1iM2Q4LWE2ODE1NmQ5MzZkMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRlNDg5ODUtNGU1\nOS00NWM0LWEwNmQtMjhiMjU3N2U5NDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/zxE9vESsyft0dPthp3GCfGienK4eLzlMc9M6lhyDBbfvVf0upfk3Cf8SQ7X\nyETO1E0kibIVJwMj46UyochpxKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyLvDoyLa0qkzhfvBwFolNM0VxEowHwYDVR0j\nBBgwFoAUnVD1TskHoBXMtYy324/6b/IPOfEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFsGWRgbCndSzz35Q7LHhv8M3ZExnMBDzbrSQ8n/gOq0AiEA0lrXbNOrzpCG\nfl3GJx9mnLpFYZblgssLys7/WLWmjjk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfJR4580b3MVoTWuPFxDaRlkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWE3ODdhNS1kYTQyLTQ0YTQtYjNkOC1hNjgxNTZkOTM2ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcan67MxjbaEwN5fIeLwfXAb1vrZKBQMa/5Iku58677D0o\nRfL3ni8dyJDJodI4979Eto2zxWyxCcl4qbDED+JIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnVD1TskHoBXMtYy324/6b/IP\nOfEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWq3SDFK7e9OhYJkvDGyddgjX0gvEdsvIB9EwnO2kZ6cCIHZhq8lWcIwV\nJIOAuRXkiUXbAlU7rWsLoqmSSeO+4d7A\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISATd52GhRvuW0AzhclXo0wkcqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRlNDg5ODUtNGU1OS00NWM0LWEwNmQtMjhiMjU3N2U5NDUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjRhMTc5MmMtNmUyMy00\nNWM3LTk5MWItN2QwZjVjM2I2NTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfjaP8Q7D6DnqjUqdhqTwNCWDMLwdHB68AQNs4XSB4HTAuaN3Zi5SfsVHvkgLPaH9\n0WGBaP44vlMWT1zzPVRysaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyLvDoyLa0qkzhfvB\nwFolNM0VxEowCgYIKoZIzj0EAwIDSQAwRgIhAKWyGB/KVD6PxztdPGws8RQN/umb\nZ5zswSma5XwZDDwYAiEAl/vpvj2/7GkpYVTLppJN29mHGk3LV/bHv+tgvynRqBM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8050", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8050` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAX2fej+TRKT+H2vh3t4WueWVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMjYzOTUxLTU4YWUtNGIxZC1iNDViLWM0OWI2YWJmMzUwZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzUwY2Q3MzAtODU1\nOC00NDBkLWEwZTYtOTM3MDMzZDdhMjE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq7KvOHjuw6eVx6ZhuXjP9AeRdrEGGVcTZg8PWtEscTxlgqTO9lW84zB6RNMJ\nLBqcEx5MX3mwxX0+wnulRNQsoKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCik43AkvCzCHFllYGSI56amuAMcwHwYDVR0j\nBBgwFoAUoaOvlMiuoltTJj0SNPO5J4S4t3YwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCf\nh9ule/MSn85+DtPHHAVDtaXWd1+5V2lI3sDbfWhIEQIhAM9p0qd4Xd/jngAkkdmw\ncoGheqtutgXQ3RRKjct5YQ29\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWKaCvUzCoG+bHwqzISWFj52MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjI2Mzk1MS01OGFlLTRiMWQtYjQ1Yi1jNDliNmFiZjM1MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7bQbfAiQjWrYf3XzWIbSWtNYQ0mK9e9fbNh4U59q/SZus\n4ODhVnEo2rNDD1coNkcnNd8zh6zVo3GNBGpFT+6uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoaOvlMiuoltTJj0SNPO5J4S4\nt3YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ54GOdVGWdtvhtx1w/IgQIbpPSdFAil1ZZKj4lmSs6oCICwlqhPt4N4L\n7i5UkEP7InUh0XQ24l4HSR5ynFtcO8L9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAfGO/tHUjJleKLz6NMVD0X7gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzUwY2Q3MzAtODU1OC00NDBkLWEwZTYtOTM3MDMzZDdhMjE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGIxOTA0YmMtY2M2Yy00\nMTYwLTkwNzAtYTJlMTcxMmM1ZGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nx4aITOGVu68KM9EbEP3fDi4ZPlV3xzkqFfmzcpbCwioKrCIUmlKDoch9tzgiq3jz\nYRnNtv9xCiTF3erb+CLtKKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCik43AkvCzCHFllY\nGSI56amuAMcwCgYIKoZIzj0EAwIDSQAwRgIhAKuBUIXdsS2L6L9cWW1vjU1IQHHN\n/E38LGw5GyOLHWfCAiEAvotkXoUj/OxQ6lYtOfyldrBx93X+Lb/d/OLkJWP/Ieg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8051", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8051` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAb1IqDB+85rVKdqRvZyon4V9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4Mjk5OTJjLTQ1MDYtNGZhNS04MGRmLTM4NWIwMmVmYzAyNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE3ZjIxNmUtOTBl\nZi00ZTJhLTg0OTgtYjM3OWJiMDU1NWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKtRuLyTJU/9fnaK06O0sKlz0a7JcuTuvkw2tPD9xqbadP3lC6gA4mx1RcFnA\nDvauYEII0DO9Pq8qEJuUXlYBaKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhJVWf0PCGlU8p3RprN/aLNN+EVUwHwYDVR0j\nBBgwFoAUQuQ6VlihVlVZYQ3mIQX8AwW7AM8wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCID7wmnMZAkn60tN2Ef2hxJ7EO5gjlSeDuoXdEJXVR/QPAiEAoIux\nW0WP0sTs+X6WGiEksW7ZFWlx189tFS/hfjZ2bHc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa6lwIxtnPEkpzHVEtPZV0s/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODI5OTkyYy00NTA2LTRmYTUtODBkZi0zODViMDJlZmMwMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4YX7zbYxhmHZqwXP5gdlOSfTDyFZUZfouSJM/hl74+COM\nGhj6CzU9j/6ixRC2vl9sQc8ss2enL1hJy5yI0D8ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQuQ6VlihVlVZYQ3mIQX8AwW7\nAM8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbqECVmBRs7Nera2DouG4dWXxJNcXnzAPL2+mcQbaPgYCIEoBChR3RkCc\nkgKm8m2pfCg+UcfKGtSFYuM/BMGEHM/x\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAemg3QJ7TTxqPpGc6dcTjOdKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE3ZjIxNmUtOTBlZi00ZTJhLTg0OTgtYjM3OWJiMDU1NWI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmZiODA3NmYtNWZjMS00\nYTQ4LTk0ZGEtZTZkMTQ3OWE1OWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfmjlydQtoucqkcHfuDzJG4y1YfTQUBQra2cO+DGkMINLFOi+l16tAgAcvn9lM71j\nObk+kHp437tnq2bPoTIcuKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhJVWf0PCGlU8p3Rp\nrN/aLNN+EVUwCgYIKoZIzj0EAwIDSQAwRgIhAN9pZno3Cit+ItlLj34F+FoyiU8q\ngImsC7FlQM+WCumzAiEAw3LvfPplS9mCgiosS9csceZnyltGqwniW6XSVl4b6BY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8052", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8052` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAYue6pdDaPt2beOTFSkukGJdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhOGRkODkyLWU1MzEtNGI0Mi1iNDMzLTkzNWI1YWZjNTk2NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDFlODdkYmMtNDFi\nNC00MjI1LTk2YzMtYmViY2MwNGJiZmJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgRYtl8DPyNk03AQaT687aZTZYPRA3ELKv06SA5CNHPYGZAKq2nliaFJay6Ii\nL9K96ZsBgkZDwPmV916DzIPvyqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKjIAFdQcs1F19eoTseqJzxN+CvkwHwYDVR0j\nBBgwFoAU4r7+lnVMHwCaliLX+WQmIwFdE2YwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIBsbiiJCQv7gMmE4CA+L+gzqepkrjQKMMSZirDmDEQOGAiAYLcVU\n6U+mBhtQg4EgDQtUpmsWonxM57MVtnJTWQ+/kQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARdhrev6frlvDBvGKIqsxCDWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYThkZDg5Mi1lNTMxLTRiNDItYjQzMy05MzViNWFmYzU5NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2LZeuw1mza38SCRsztGqAjwikVfyJbx4m4gcPa/UvZo+f\nM72GkmizZNUbL18XJG0X0OiH5WzOB2D/KNpvn3o/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4r7+lnVMHwCaliLX+WQmIwFd\nE2YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAoxUxJNy+GvcYeJ1xukcz/BxWIaHCDbrCfi47REWZAwCIGGvFy+Kuh2v\npSgfTs6HmoGZGojLsuhkFncDCu3aKEu2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAR6pTbTFzOMERVVGPnekINg3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDFlODdkYmMtNDFiNC00MjI1LTk2YzMtYmViY2MwNGJiZmJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmMwYWJmODItOGUwNS00\nY2Q5LWI3MDYtM2JjODAzMzE2ZmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+EODLlu/PsIXQc0sNPjDzYLnCBh+Xdxiunj4JLcsH8jeYVgDgrzW41k0t+9DWKIn\n6clTXuB9w6jdXK+ki8bqVqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKjIAFdQcs1F19eoT\nseqJzxN+CvkwCgYIKoZIzj0EAwIDSAAwRQIgbPb9oWcu4OYxlWnQMXFnsNQptrUQ\nBuqEFXcdyupenRkCIQCVvj2SmlleDX335xeLUMcMJB+hVu/kUCzKSB0zYeAeZg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8053", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8053` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAXtjkZ5hmlYS1tKxYlpMNXw7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2MTYzNjBkLTNiMzMtNDE2Yy04YTAyLWVlOWNlN2Y2MTllYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgxMTg3MjgtMzU2\nZC00NDdiLWE3MzAtZWY5NjRlOTkyY2E4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDfX4uzvyH7fvZpT5E5VH1AmLcW/aej8Xestpn8/jGGz04+b5L+XoEBXqi2MT\nLgSA11OcP5sS9c4TAsQdPw3bBKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRM9kvRmgqMeBjyHxs++tdx3hN80DAfBgNVHSME\nGDAWgBSG2ogCZgtoVD4vYi4OeHshuMp8VjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBuHeW/bkBIpua5SJHvxlnO5jIGehyf0\nutijtocShZwZAiBepL/oN7KSGwKxqh1GaeJ0ybc0Fqg+QL+PxLluErjLNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUCJvIDwIe7SRcc2P6moNj3wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjE2MzYwZC0zYjMzLTQxNmMtOGEwMi1lZTljZTdmNjE5ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ67nVEAcQvk652ijE8lb56NYP0OVj+5hZQaQYiJuTRJCdM\nBQ2FdZW3Q+cEc//kTGuaAFDRixODcfz7fVAFagrgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhtqIAmYLaFQ+L2IuDnh7IbjK\nfFYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgScCpuj8jPclTG/PTBW82sr9Fajt5eQK94GOwJGDBtlYCIEutcZzjheKD\n7Mp+3D6Y3q9DJYKDRQ7grzxN+djBlkVW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAZ7Kt1IQty8yzmAO5J0RC0RtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgxMTg3MjgtMzU2ZC00NDdiLWE3MzAtZWY5NjRlOTkyY2E4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzg1NjViYWQtZDdiOS00\nZmQyLWFjOTEtNGJhZGY0ZTVkMzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nv/kFDwl6CwAo97RCcfAJgxxXkqVLFUsMjlJ39Cqyy0OKRnLAysh7e07+M29PnU5U\ng9Ceo02qLvOT5J5Wd88LO6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTPZL0ZoKjHgY8h8b\nPvrXcd4TfNAwCgYIKoZIzj0EAwIDSQAwRgIhAL6EYYpAiR35YdtY0sJocj7Mn8dU\neOIUGiTphrVA323gAiEA4wL2INGCfMq7q3oGHJj/YQ6EcVAgSGMDZkVJBtqtMRE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8054", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8054` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAfrQX7xIhGvUmUBwEZFY9VAkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1YjgwNDljLTAwYmMtNDI0ZS05ZmJmLWZhYmE4MDQwYjg1ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjYyY2Q3MzktOWM2\nNi00MjI1LTkzODgtNzU2Nzg4ZTk0OTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBTZlMEhBQfiqrgEiaAIAAIzwNsxsnGtFVNn21eVuXHeieSpxxbNWfnoCTl/u\n0YqTCsscA3KPFAlUkv6j4A7RKqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtsule2byyOoFpYQLOb4nZHnvIKEwHwYDVR0j\nBBgwFoAUnikoH11OJtjdwdWnVre+LWU1ELwwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIHsgC0PjlXWH\nKqk3cA+2fu66L4eYu5O/LRf+xWtZKQRDAiEA0zwzACPD8OjU1QpdV0nnSabSfjsN\nkw77ZHilB/XKP/Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXn5wHsf7CuusrN3Kb9Tp7u7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWI4MDQ5Yy0wMGJjLTQyNGUtOWZiZi1mYWJhODA0MGI4NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR18o+Vq9DJUP1V3DbvoVVjYg5Xckpzy1KTte9d07NyBjUC\nMWepvaiWVyguLR0Pi4qdIoNjzgSrJlUayqRV96sgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnikoH11OJtjdwdWnVre+LWU1\nELwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPxtBUt/MjUAl24rOActQPEEF2EmktXuJ3wGBe7yjEy8CIDxqj8ysWWDc\nHC/9PSnlPI/XCPdJAV4qTUgPRH+0H36G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAe16qw+/MSADFzdD8F0hkG6+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjYyY2Q3MzktOWM2Ni00MjI1LTkzODgtNzU2Nzg4ZTk0OTk3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjUyMmMxODItMGQyMi00\nM2UwLWIyYWMtM2RiM2U2YzA3NzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDiXKFBkY0giHF1Uh6JTWwBMUNWWpSk63fMoSjVEoJz4kB9qdA/5qMsod5YuPv0Yg\nAaAwXOMJYTEbV8aosgyPQ6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtsule2byyOoFpYQL\nOb4nZHnvIKEwCgYIKoZIzj0EAwIDSAAwRQIgC7JkRlRI/aLUMZCsHT1WiDYxWRXZ\nvlhaOFNbCxzeEpgCIQDntPGN9hccNZpZrP+oLRXHa9vm39eqLX9qd7dcV45TDg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8055", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8055` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYP/VbpT9qCvBE0iQKJhWVrDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhYzM3ZjFiLTdkMjItNGYxNi1hNzA1LTljZTdkYTI3N2Y0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U4YTgxYWYtMjY2\nMC00OTYwLWEzMDctMjEwNjE3MjI0NzQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhhiR3xbv5o0rvgRTBL5/3sDEY3mvI0fNgPFyjMOLtWe+6B4CzqioLe3jwQxZ\ncBFluDLmcERQuZog01dlqLxmDKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzZPtJG6h7vyLDF9YZltqmxoKLpIwHwYDVR0j\nBBgwFoAUnNgYtqmsQysoS+2+KDpz2d/zx1MwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDChPTZJ/MZ\npqAu43mUGJcCZxcY/y4j3Br+q2MB7j+3aQIgcrJB1uMaDxLXvEG9iR0q3ydxEuf0\nQRpA7SH48O+VEos=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATxPcQUubLdgJYOOl5SU+93sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWMzN2YxYi03ZDIyLTRmMTYtYTcwNS05Y2U3ZGEyNzdmNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASR2mumhRKt6GiuRxaGv19+ytIzc3yN16gPiZQTWL5kbjE5\nmj4CdMEoQwTwccEoXn0ufIEL7hC01FCndjpmbKMbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnNgYtqmsQysoS+2+KDpz2d/z\nx1MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgI3wo5Qz3j9TG8SmlzN/d1Lko4juM7TEeG+11Nuuoab0CIQC2rHVBpqpO\nKkIb/6XQEgeiaeufnCvCTCC9ERCkcp2uZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAZA5TU2CucogOB2L9rkFi+ObMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U4YTgxYWYtMjY2MC00OTYwLWEzMDctMjEwNjE3MjI0NzQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODhlMzgzZTgtYWU4MC00\nZTBlLWE1ODktNjJkZjc3Y2UzMDFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8rMdvWDiE7taOcHwPffchuMukGkGi/MfqflmOWc4DP/EbRamHVouVXcxYeuyoJvc\nvPdrhsQ21+kbaQ1rMCDogaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzZPtJG6h7vyLDF9Y\nZltqmxoKLpIwCgYIKoZIzj0EAwIDRwAwRAIgLtLNdOi4CDnr76x+5fIUFyPAmY3Q\n2GMdQUygglvLBMkCIBUa8DSLp2NUZtXUewALZ8/idJTQ1oVIX0ms5iQhUr6L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8056", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8056` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAUkjnF4IV2cFSn9MSJgnBOjGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0YjQ1Yzc0LTljZmQtNDg2MC1hNmE1LTU0NjBkNjgwNzcyMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJlZWFkNzEtNjI3\nYy00ZGEyLTk5NzEtYjVhMWE5YTEyYmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIk+7CyFwhyj9n2x2OYTu17xRVG0MhvwujNfHlaNbN/KLqgbeLwqoBtRGguHq\nPYDzfryTay23wy5oCtV8Md/KUKOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBRXzS9sZhcdO5KpLL6wRPhrefZwwHwYDVR0j\nBBgwFoAU5tr2y1QyePVjeBRYJUHHpthekT0wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAWVhlDVMUA\nKep9psXpD1j+vSmrNRyvODdWNmrvfU034gIgS4EjUhre26DXp9sNycLorbUROGy0\nxfgmUDiyuMJ6mVU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAajBEpI1wwRtguBmlDXGCDlDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGI0NWM3NC05Y2ZkLTQ4NjAtYTZhNS01NDYwZDY4MDc3MjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOQJf0SuQr+h0BOTDGIyzVgIrqAv4TFgvGNZ/kqiyt3995\nRjUucoAhdUf0W8gw6Smc+LlGYk8/EmAhGn2Kf0QBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5tr2y1QyePVjeBRYJUHHpthe\nkT0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK6Cf0XISG7KO1b7YF4nfF27JxbkmHmcDDbCyectqhjcCIQDIGbnfNptv\nnRZ1bEWEU5GEzuV2YRFwOW4XvD/EiRcAMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISASsdlpN/ISM2Nd5DGUe2OlQ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJlZWFkNzEtNjI3Yy00ZGEyLTk5NzEtYjVhMWE5YTEyYmQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmM0NGYxYmMtYWMwYS00\nMTlmLWIwMWEtM2I5N2Q5ZTI5OTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFiN42RJ0Go8hwJ8njQrTxbvZmGqKhd8UoAafzgw4xQioyUQAp2XUGh+eVzcZjjWm\nqzj9vtDXZwpFyNVIj/qtqKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBRXzS9sZhcdO5KpL\nL6wRPhrefZwwCgYIKoZIzj0EAwIDSAAwRQIgETRKhHqr+HUtWwNaU6wRs0nwtXfY\nBRq2cI9XZElry+0CIQDLXftNFmI+a+e47Jrym2PeSP6k8v4qKaqizk599D1PuQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8057", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8057` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAVy5NgHFsgADi8vIETnP35IIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwZjdmNjMyLWQ5MzUtNDAyOC1hZGZkLWY1NDQ2YTE3ODRiZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZhYzkyYzktMjM0\nNy00YTQ3LWE5NWQtYjFjM2QyYWM0ODg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoO2Z1FMlYYQnFP+Jnaq+3rgTusj5pkPrVHhtqwIcTfj+lzSiuj4onnaZYZg/\n+/q+WoPTv3wvlcr67Qg+v3H7DKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnIjVbv0Jbrt6rKmB8PRcxSvgbO0wHwYDVR0j\nBBgwFoAUZi0FOCxRKK2J7KivadZk9DDff6EwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEArFXbOBSoCFeFbXqu5KKaipTGFfWJAQpZPs8gW7DMBxQCIQD291sk7pbf\nhZ0TDdpensBhKpFam75BgLitkzGNEHxVzw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARDxr6+kpCIezRNaapWW6Z5tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGY3ZjYzMi1kOTM1LTQwMjgtYWRmZC1mNTQ0NmExNzg0YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2AEoR73Hzk6ikkL7M+kmHDZLHD5Dg5huW69oEETF11bxC\nCSFHT5czsWZvc7EjiVNfatjcEDLiiM+nc0Vvpm8wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZi0FOCxRKK2J7KivadZk9DDf\nf6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNWz2CaEJnTWdwEpfeLe3pQ4BEpUTvhnHC1o2EHok3M0CIQDwUivkUD3H\nl/QPGEB+MNstCXo52EVMvFmPIJic4sFdzw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAdM11pKsKKaUsE70MWuSzYrUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZhYzkyYzktMjM0Ny00YTQ3LWE5NWQtYjFjM2QyYWM0ODg2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTA2ZmE0MmEtZTg1Ni00\nYWY2LTg2OGYtM2U1YjgyNjZhMjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4eCtbz4nesltmAOm2/e4twJYtELEravn5QEZ5VoteQkuBiEZN9iPrAZ6rLYjZf12\nJeW2ioKye3n4Bk3tKbY6wKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnIjVbv0Jbrt6rKmB\n8PRcxSvgbO0wCgYIKoZIzj0EAwIDSAAwRQIgAXEg1QplNm7csOVRgZv9dY4xunn/\n8gHo5Y5zymD6ez0CIQCNUZCWmGnJ90A3AaVFApkTOfrzASew4G4DvSZe+DELAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8058", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8058` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAYTVeOxrZ7Bidei04XBeXx4sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhODU2N2JkLTViZmUtNDk0OS04ZDcwLTdhOWY0NmQ3MmJmMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTczNjViOGUtMmE1\nZC00MjI4LTkyZGItMTI0NTcyY2Q0ZTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0bZKt/6gklNgvLeatEjl9kj+uz3klLsWyKzNotHfZMz/UABuQxxXyxiSKOiN\nopCtsQzuoCN7Av/ABBYg5LBGHaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjnBAEFGM2/y6ujhzzjQU8CbKPScwHwYDVR0j\nBBgwFoAUcHwlirpkIioGJPKE+rxQx/oVvNEwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA3eJrYQm18Hpo7qrggwJTM0y0pvWVwpQQiFY6ibnmSHECIQCgkJptkTIC\nQaMUZJNvVk0Gn8/Eb1jBeAggEtJExi+m0Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXi5ifAkVlVqsEZYPN+dfgXLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTg1NjdiZC01YmZlLTQ5NDktOGQ3MC03YTlmNDZkNzJiZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRxANmUHxr00VLUrFImw6LbhqQONwhdSOmCLVkF2DnPQR8\nFPaiJ+pDWqm1dBNVvXnIfvl9mQlEAlITQ7B7aebWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcHwlirpkIioGJPKE+rxQx/oV\nvNEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMW8VgEh45XUIcga/6PyZg98zIltl6wBb4yXTTWldCrMAiBUJ5BLVRSm\nIs/o/mIbxRWjoIYTMweGosQPVZ2/KnnhAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAZ6hCy4BGKe97JGjtlkH4Wo5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTczNjViOGUtMmE1ZC00MjI4LTkyZGItMTI0NTcyY2Q0ZTgyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDAzMjg4NzctMzgxOS00\nZTlhLTlhNjItZTEyNmVkNTA4ZmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nocCGDdXLYpLNToBhF2ZiPKRuyBHfWzlQzcE4bsEal3exe+XvKwPJbtS5Uda9zrYY\n2B+Yska1jlKpdVovyhKbU6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjnBAEFGM2/y6ujhz\nzjQU8CbKPScwCgYIKoZIzj0EAwIDSAAwRQIhAIleHmmlj3mtlFISnZ/SIRd8dv7J\n6oqlgSYGCJzMa5OjAiB4XnJUTOSh3zncMPZUi3bntc5XbX0dCCXvi6NMd0noOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8059", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8059` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISASsT337Bkw8ZAeWqAQygmN3JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5MjZkYjVjLTNjNDUtNGNmOS1iZWRmLWUwMmE3MTU0Mzg0MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTNiMTI1Y2ItZDcz\nNC00MTg0LWI3MjYtMDczM2ZmYTU0MjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXx3R/nM05ApfpTq/YYeuyR5Tcc7v05rAdcBYHhu9ISejbNlGzpLgdkJ4+dt2\n8xWQ8rBNbfwbgUlbaDcNZ0EDRaOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Nmr0PAydsUJicRBJJi3LWv1g0QwHwYDVR0j\nBBgwFoAUNqiNF7M7g4jJzPU8qXe4OUfJvIIwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\nrvCLS/7fcHMpZlHsuSfNIysT95EFhciWtx36c5YfHroCIGviW7o8H9htNO0u/EYL\nMgUbAAbv2BM1EemWpiXKFjN/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfNRXulgG3SrXlNdcqU08G9zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTI2ZGI1Yy0zYzQ1LTRjZjktYmVkZi1lMDJhNzE1NDM4NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASb2FfH9r4Pn7n6ooewa//V/0RMQuf2YDX5gvo4nQmudMNe\n/66xDDQyhi6fzC+vGAwsZ40tfXNuPY6W3FsIWlQio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNqiNF7M7g4jJzPU8qXe4OUfJ\nvIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOGmh6zlSI3OJ2tt5sZTllJJkv00ACBhlpQQbhs6Vk/1AiAhi1QXrc0d\nsCuNVWvpJhGSF28xVbI00/DHwnBWzes37w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAe2IROVtw2oV7tKjx+XQSULqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTNiMTI1Y2ItZDczNC00MTg0LWI3MjYtMDczM2ZmYTU0MjljMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYThmYTljZDEtOTliMS00\nYTlhLTgyMDAtYjI3NjEwYjU5OWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAXmWGKLgwn98HrhfoLCxD9upVfq8RjwetBesgWjNCwNLRDKLHT4+IYX13Z3xrquI\nL7PyDiXjQ9KHS/R3D/xbNaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1Nmr0PAydsUJicRB\nJJi3LWv1g0QwCgYIKoZIzj0EAwIDSAAwRQIhAPMCix06W44SKTWXRGYhbW+m1tm4\n1/4Y5oMUgCuAkDl9AiAZmS/egFnF09xZqbCEbr18U0qxBjemr2ydJAePHoIlJA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8060", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8060` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAUairuNiJF3lmEjN53yTUcx8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZWUxZTZmLTRiYTMtNGRkOC1iMzdlLWZmMmI3YzViMGU1YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODc0YmY3OTAtZWFj\nYS00Yzk0LTliOGUtYWRjMDI3N2QwZTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC4SeMIP0o0CDka6d00GrvM9AW/7H5E2RY0zh5xJGUudFBWgetLt71EBiqLLh\ntbURlCA8kQRxZuCpvJ0owekC5aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2P3BboNsB7mR3iUugVlZdrtWsqEwHwYDVR0j\nBBgwFoAU4JYSbfh3GDbiv7a1SaF5qVS4oBgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA/15XK3P90HZ6Jkv3ajtSiIqDWjV/Se/988Kz2Mc8ItECIQDt\ntVCGqeQx/URqXm2amnusxj10foLlY0Yx+/XEjI8kSA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATSS8Ajmm+Xainl84ajlynv8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmVlMWU2Zi00YmEzLTRkZDgtYjM3ZS1mZjJiN2M1YjBlNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdw9ud2JS50NtfL+nh3Lp5AB4VzMzzMlbc0qD3FAgULjib\nDXt9Gdb/Jt4rX/i2+CT0Z3qA9GIO/WPDKK2KEhImo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4JYSbfh3GDbiv7a1SaF5qVS4\noBgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJqfV7oYVtPpmXG9fieS0BvL8Th4BaRzMWmL2i58mk44AiEAvpNaodH7\nt3fTuPRmwU/XL8K3WUHkzz6VN/L2TU/+yHk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAWr3qnImp9IQgRRzBXcwCkmcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODc0YmY3OTAtZWFjYS00Yzk0LTliOGUtYWRjMDI3N2QwZTM1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDJhY2VmYmUtOTI1Ny00\nZGNiLThkYzAtYjkyMmE3MzBlZjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndumWC8eu/H4uxMAjV1PfPjppHlgbuA/kGzYgWzsJOvJWWYBX+6gv7P2tMOIKZ4SR\n1BwP6YOfFkEADA37T78H06NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2P3BboNsB7mR3iUu\ngVlZdrtWsqEwCgYIKoZIzj0EAwIDSAAwRQIhAL0aNBk2FehihR4PAGe5JSLkx8ea\nXrBYs9weVxovZcaRAiAYDiHast9zqiBW3Wo6+yh4r6ejCdRL4yKVDnKn+nJdiQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8061", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8061` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAWAUKs9PtjGE82EhlrXsZJI9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5N2EwNzBlLWY2OGYtNDJlZi04NWRjLWFiNTQ1MmFmYjM3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ0OWY3YTctZDdl\nNS00ZjJlLWFmYTAtMDJkOTdhMjY1ODY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEdr+QWalBB/qL8ltpR5RcoLhqqACr+Zto3HZLBxBACSXy8ZvStiDdV6EkPro\nJgNh+nqUSCLFrEt5ZhjZBHZnr6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH7o7YSz9Y2LCAj+EtcJy8GjwG3UwHwYDVR0j\nBBgwFoAUgAp4hF/yvJPG/AFe2dvfa7/XbcEwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAuoI6T5/V6ELk/C8AypD18aMvIJYqJx9dEPJkzIhvXvgCICbI\nUInEOu5WTFaB/p4BZBZ+fD6MUZnkqGYjcby1wAQH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAROtX7YdI+Y0oKByYb0v9+9OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTdhMDcwZS1mNjhmLTQyZWYtODVkYy1hYjU0NTJhZmIzNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARErWz7Mj5f3xebUuxi47aHhF5Shd0RLonVxYQZB3mRh2d8\nuvrtdL2764wNJe/THLd0I2mb+5RHCIpicVQJwMMdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgAp4hF/yvJPG/AFe2dvfa7/X\nbcEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIGc4v+OFK+hjb1oLGEyS5UjVQsJbVKrYHQWn6tfoL+/AiAoY+mSsvGV\npmTH3uHfmmjVJDhs/+QrECeJC0jrhritkA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAdA/oSTsQEWvrKTyJO53+muVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ0OWY3YTctZDdlNS00ZjJlLWFmYTAtMDJkOTdhMjY1ODY4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTc2NTk3MDUtYjkxNy00\nM2ZkLWIyOWYtZTY1N2QwODdiMjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n08QIkqBJVPd7GekA8nbhDZkdNMScfNfWmgn7fsf+DNHPG5pAfFv0ccDWX42a0EU2\npYQDW/K6TpAL73SqKWQVUKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUH7o7YSz9Y2LCAj+E\ntcJy8GjwG3UwCgYIKoZIzj0EAwIDSAAwRQIhALk6QzSPmgFYHhOcnymmFYlpOUW4\n4QspQKNgrXgitd6IAiAg23vfcYUjrjw7mk+EHKSggv0Omcp99gffMYLcxSEiwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8062", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8062` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAeHMiF/26CM5Y0EhJSYw9kxeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyOWMyYzNhLTExN2QtNDU3ZS04NDM3LWE3MzcxNDk0ZmU3YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNhZjdhMjItNTJi\nYS00Yjc4LWEzODctMjNjMzhhYTg2NzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHOPy0iuCaKinALJt2LjG77RntyTEJC6kuvbAch3F6RUFEffP8h4lxnCLcDKz\nI3GNdTILFMRNN8pw22EG7wzUK6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIDMN3iibeO/DxCuUn9PL1FCqfYIwHwYDVR0j\nBBgwFoAURw4M+37MB3KQUocjN3NVTWc9PSUwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAS/U2xJjSBsyaF\nS/uYsuoB63QCUBkS4UWkt76n0DIeIwIgKBi1SpwZYswB0wuRccO8yDuI0jvw0CW3\nguW+E/fm8KY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT/VokWmqAbaiuOd4UE3udv7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjljMmMzYS0xMTdkLTQ1N2UtODQzNy1hNzM3MTQ5NGZlN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1j42Q5CX3d3+J0vdWlbK1XrN2kzuqkiWgrou9fppZ+hce\nNuMHUmgeQJD43xj0MK4TgjwfoOZVwrKsRvV83jPAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURw4M+37MB3KQUocjN3NVTWc9\nPSUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAJrMMlXrWKQQh8IucMNst2VXDrFIPy9JyQ+L4jnrFfMCIFIupZL1bUnr\nCbdpttuHLapBynTpaP5u9/Y5OMTykdTn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAci0CHnj4edKqQc7UmP8MRi6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNhZjdhMjItNTJiYS00Yjc4LWEzODctMjNjMzhhYTg2NzliMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjRmOWE5ODAtNDU4NC00\nOTg3LThmMDAtN2ZmZGE0NGZmYzNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwY5HzeRkAsoGpDaADmqX1FR4bfNI6KSUbtONSb/lxUUJvrFHpHOSrz2jYXN9lcMN\njg8H1rQY/nRon+nEAehlw6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIDMN3iibeO/DxCuU\nn9PL1FCqfYIwCgYIKoZIzj0EAwIDRwAwRAIgUQTYWH7Ohvr3To42jIHshbZzvHnx\nf2OIgIorzV0n9YUCICevfz+djckg8T3yY6OWQ6KNBIz2tJn2wj7PFx22Aman\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8063", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8063` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAZxnPbAdaVUXhYwqiTp2HIoOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiNGQ1OWI3LWU3YzktNDYyMS1hMWU2LTcxMDQ4ZjE2M2Y5NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNiM2FlZWQtNDE3\nNS00OTA0LWE3Y2UtZGE0YTIyYjllOGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElmBe9W+psxV5JkqCSZ2IzUIthCmJ07QvWuoc/6DsLi9CRwIrErgMZlYjk67b\n26f2s68B+PcV6Ynouu8ruI7aAKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2kdSh1whBpQxtYmfCIZsWN8JL3kwHwYDVR0j\nBBgwFoAUZL3O+r0E4Z/SbRzxFPPP6K4/B1AwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDA4HdCGvV3CBRgI+fi3zjoqcsKdpdQryu9wP2301iMsgIgHHRmaA3QWMNo\np9SVvGBLBg61oSqPZ0uf1UUkMIk1FiQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWVIu4pa7VtGPTvxM71eFm+aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjRkNTliNy1lN2M5LTQ2MjEtYTFlNi03MTA0OGYxNjNmOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWTLrcZDih2sAEf/j44slcK/PHbhgPFzYATv+tSqC9V4BL\n4A7eSPaw5ilvrgYRu8HfBtBLBxOtCzKq+z7rQpcjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZL3O+r0E4Z/SbRzxFPPP6K4/\nB1AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKGpYeFtEbFSe6QvIsZChPQOvRhMw24qTWQ+8n2KuTXKAiEA18ick/+V\nrdKjLpDRcnR8soF4KFv5pakn/fgANOB/5xo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISASfRlRxsg8c2NS05W/KcwNOmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNiM2FlZWQtNDE3NS00OTA0LWE3Y2UtZGE0YTIyYjllOGM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjM1Zjg2NTYtNGRmYi00\nMDdiLTlhMmUtMTM5NzBkZGQzMDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwC9z1XwOHbmoK1/0e85MYsYOslDqJNMeB3LrrVFqFUJMVGl5FV0dZ1hwm5nUEmz6\nV/gSgu67oneNUiLnGGpjFKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2kdSh1whBpQxtYmf\nCIZsWN8JL3kwCgYIKoZIzj0EAwIDSAAwRQIhAIa5DIUevN63H4cdzJYbgcJz6hdr\njZiHfn8INxMaf6E3AiAESc4kfYuPsc2ZWycDJlCxUfaKDi/Pnfngd6xsiXwuEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8064", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8064` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATlXrKUj5QTQgNBrLdweQOJ3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiZmFjMjIzLTE4OGUtNGEwOS04YTFiLTkxM2FkYTY5YzFkMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIxMjE0NWYtNzlh\nYy00NjgwLTk3NjctMWMzNjgwMTU2ZTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQA8knhnxUIsz4yrbXIf8dqJlypKvoX6g38HQFnOpx9fnv6V0obsmgE3vsPEF\n2/rii4wcDowjQYBRsO1QUZL1AKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURNUhlJyINA0qVAcbNFB+zRnt6UwwHwYDVR0j\nBBgwFoAUyU5xrG07tDw861vCy6byaVgXhRYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHouIE/C+pOQQdW+wQNGeuLAjQGDWj9sEQ4gZ/okSJ0DAiBeSvB472hTYa5s\nhH8rMLQ7Afay3FyPH7AUcARPLHY4gA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVVjicPvHfGA6G3zKzmgH1k3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmZhYzIyMy0xODhlLTRhMDktOGExYi05MTNhZGE2OWMxZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdkZ3hzKVmrvK2yPxXBbY7mne7mTQARJoKsogzFFaMJDva\nu2zM1h56DGd4V5QdkkFg834reQFH1NKrLB3X8s5Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyU5xrG07tDw861vCy6byaVgX\nhRYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPbpY5IIJyrBbX1ffdzry1ZaUPRfc2Me3zTNj+CQzT3gAiAU++P4pFOj\n1TU68ltK0i2+pQRVm2+iqpAAZuB+x5KW8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAdzKi3+hxdwDiXCivGgUiLgIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIxMjE0NWYtNzlhYy00NjgwLTk3NjctMWMzNjgwMTU2ZTUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWZhMGYxYTUtMmVlZi00\nNjA2LTlkYjEtMjgzMTM0MzlmMGEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2XJieKUsJrScWsSYcFNPxGEUwF+L21hWUHxS7/3T4JPZak7pySxcTWav30pMLV9J\naxmwts69raCnXb/mbJ2d6KNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURNUhlJyINA0qVAcb\nNFB+zRnt6UwwCgYIKoZIzj0EAwIDSAAwRQIgJI6xsuCSH21A5ZfvJRTZTI6VR0uA\nMTxSue08BKFA4eoCIQCs8323NzST1yic89rnjECT+xdgLGolLs+DaFrVR43zwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8065", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8065` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAWpuxgDlKZpZ4fiswIx7O5KXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljZGYzM2Y5LTZjN2UtNDk4Mi1hZGViLWExM2IyMTU0M2Q1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRmNGJkN2QtMTAw\nMS00MTI5LWFiZDctM2NiNGQyNTViYjdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0+0Z2GiS/jLgYG8rspyEnx5uiKn4MXFrG8AoZOTNiXcXkOfd+FmRfCakTt65\noTw6qQAhNS9KrhPIxIViGipbBqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSiZgIqW0erdD/S+bgeZONF+z8VUwHwYDVR0j\nBBgwFoAU2rw0SCQysIRfais9SqH3V3CWyjEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAvsKBqM/qaiDh0QtTnnTjH44J+zLCnSLdsygTWcIezxQCIQCEOeRdNpoO\n2RF0nnhINSYvn/Kn3vMZNFCW5aeiUkTVQw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXXzV50CdyOn+1csM0glDi0KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nY2RmMzNmOS02YzdlLTQ5ODItYWRlYi1hMTNiMjE1NDNkNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxUIzRKcoiY7p8D6O8InRWDs425Rbaq81D6pQkXpAS8rlO\nkOHKrmbj3gXulOkD/xeKipmcNwoeqHML0PSAPcsso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2rw0SCQysIRfais9SqH3V3CW\nyjEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgA+u4r+L7TkUWf2ZUArlubpRyyt9+groHK/7eh9ytnFICICNxXeU+jYoV\npGWtOfZie9fiyTi+u84clp76w6jbCgPw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAZCzPxvk1/+/BlN34QlhTxngMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRmNGJkN2QtMTAwMS00MTI5LWFiZDctM2NiNGQyNTViYjdlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTliYTM0MDgtOTFhMi00\nOThkLWI5MjctNTIwOGNiNTA0OWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAEcsSbfQoMncwYAw7YGWwGDDNKmMXq0lkHBCViaa8Rq9pN9Y1pNeAnvO/I4ByuJZ\n341W/vF2aEsXrezXCjwRWqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSiZgIqW0erdD/S+b\ngeZONF+z8VUwCgYIKoZIzj0EAwIDSAAwRQIgJl/wp/1FKeT5P7GKtJ/pWWUI1U/z\n3izfsYHYI6/i2usCIQDqsR6hDQys8qkvTAIOhD8q0Z3XOfnzd/Eb4ryWcUQcdQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8066", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8066` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAbDdDIDfGtnPANZBlQRaPai8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmNjU1MDE1LTQ1YTQtNDQ3Ny1hMzIyLTAxYzhhYWUzMThmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ5YjJmZDctNGU4\nMS00YWM1LTk3NTgtZGE1ZDI1OWZmNDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENpW8FKMMnHa243jAp2uvqbkrs8lkr+CMsFOotqNFk3E85S+Ri3HgNskEj6nH\ncXoASTxksMv70+YjohFRf+bTQ6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxdYqWUoIRnGDIurFLkT3F/j9NB8wHwYDVR0j\nBBgwFoAULrl9gz8ZLypBEQK+7HpVKrtQ+5AwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiB5Nl79IepVuwVDKzWIpIIiwmY8CClpaG/mOgyzgtiM\n6QIgfiB2abGa9ogdef20P27qwYj3AuS8eYEzYAk4Gi9Up2A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWPJLeMQ5gyLPlXJt1VVKA0cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjY1NTAxNS00NWE0LTQ0NzctYTMyMi0wMWM4YWFlMzE4ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1rGbqohNPFOOo5G3VgKQsLPED241CtL5WXJ6ypECKhEUc\nrUTHe+8F01LSw/7rXR/Fvl8YEuzZO6Gi2Z/ZERs6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULrl9gz8ZLypBEQK+7HpVKrtQ\n+5AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPuIdLPFBQpZdUJSeSKIq7sZKLZCXMkMh/Exk4n5u2FDAiA74/n8gXXb\nAByfWZk8OVunLPIFjuX3mqhhJLCLia77wQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAVjNyh7kbkOvgrpeAYaAZS4lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ5YjJmZDctNGU4MS00YWM1LTk3NTgtZGE1ZDI1OWZmNDNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGFiNWE4OWMtMmRmYS00\nNDk0LWEyZjEtZDhhZjg3MzRmNDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noQXVYTWUlX8V3ASZIm//D04vhN+cTMiLuzxL8xaZW2BAForA9Lds6h7zZGyTrKjy\nrV6AuMaMt5SBDFM6/iOJUaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxdYqWUoIRnGDIurF\nLkT3F/j9NB8wCgYIKoZIzj0EAwIDSQAwRgIhAOnb3cOLB3Cj90w2LplNliwQA63z\n99l5yL2prR/SX6h4AiEAy4qijv091kp/Q6jl57lmM81z9DTrbdsOSxqsvkLBBcs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8067", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8067` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAa2J1wQcHmgHaHhYJWqZJOdyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlNDUxZjQwLTFmNzctNDVhYS05YmY0LTNlOGMwM2ZjYzNiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc3NDFmMjktNGM5\nNi00OTJlLWIzMDItN2Q3OWRiOGE3OTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwx4AEqUYx7QgakQ0c7XWMgUagMyrFJQy2DQgqaG1AL+5bw36Ao2j55BcrU+P\njdE90b67ivvtgqHj1PxAhR/XNaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlrdvba9pmd7Q38T2AH4fd+i7FrowHwYDVR0j\nBBgwFoAU3bEyD0znFl+0p+AxQBrvdRQrH1UwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAsSPhA1rdKd2PQPSTBTKyHyyUoJ+R68/wtVb5CgYo\nR4kCIQCcaYl0As31kVfuFqiNC4/KUNwSQWw3DMCwpcVyAq4yZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATvAg1Wzh3LUsstevOMKsiX9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTQ1MWY0MC0xZjc3LTQ1YWEtOWJmNC0zZThjMDNmY2MzYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR3PZggMHWTJiu5McBK3g+qgMP26eAf9huP1qST56d6ckax\n3kRZXMfEmHD4MgyZEIyxnpxO1lzqPLQ87r7bq6/+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3bEyD0znFl+0p+AxQBrvdRQr\nH1UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZMGHBbREYp04y6favFPkPPhNUMusSCG0TiwZ1P5DwWACIQDv0P/v+a+N\njwczRWE5aupjAELn4wxZIad4DLnTNEXqLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAdI3q7/ID3HL1aRKP8EjYYzfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc3NDFmMjktNGM5Ni00OTJlLWIzMDItN2Q3OWRiOGE3OTdiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzc1OTY3YzUtMWFlYS00\nNDY4LTg1MjgtZjIzNzBhMGU0MGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5CgXi5+DrlSUMX0o8P04rmLd2ab8bEm0ZRQxQgKSfm4id/XVolzdSYr+FuOxMXVz\nsTN8tMFU0HQDd0U3t9Nw8qNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlrdvba9pmd7Q38T2\nAH4fd+i7FrowCgYIKoZIzj0EAwIDSQAwRgIhAIbI9iRS4JQ2WVtYmyp1p+KGnKfg\nbyCH5Mdxnql6ex5OAiEAkGkhIcS+Rs2/Q6wxAi2aSFavuaYQ1+oTpX0xuDUk6Xs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8068", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8068` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISARkKajJfi7KrlHPY74+VcttaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5OThiNDhjLWZmNDAtNDg2Ny1hZTQ3LTlmN2NlNWRkMTZmZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQxMThjMGQtMGIw\nNy00MTNkLTgxNzYtM2RlNjc1NWUwNTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwKOawxmZrXFaXbqS7OGAvixVV2HHB+UM8GDJfPk8PGSLC4hPGueduMnB7oSL\nrQgsFjq50tnatDnGQg+OgHUpLaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUslbGxOlX3yHk3TDXIhz1zcAjHNYwHwYDVR0j\nBBgwFoAUNFWZbjgB4icXjeD9/timP00bOXkwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBDqvE1ZQzvuJIYFQ52m0Cx5VrZv0MT7aKUTif2hmMZFQIgL1WF\n9DOTZ/ycMgJPUZovimEcC/+thq87ntvmUDL6tWg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdtZWJL5mZUgprMf44WPD4G4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTk4YjQ4Yy1mZjQwLTQ4NjctYWU0Ny05ZjdjZTVkZDE2ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfz8QGqmDU+CyO4fsoAOca/03pwlPCHI95qxZR2qElH64q\ni/XcdbkEKNp97kVUGntrCgCWkN2w5YHjIP9Svgiko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNFWZbjgB4icXjeD9/timP00b\nOXkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZQ6WUXBoX+lIP67WUkeqw+YgZXhTT8KOXTSjuxOpKJ8CIBPBCQNLByfY\n9sWKcekYPG2GeHfYjv1FfnCsRY9KH3oy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAfRaOOpYFTsKoa/qIRfZi2wcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQxMThjMGQtMGIwNy00MTNkLTgxNzYtM2RlNjc1NWUwNTMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWE5NzUwNWYtMzVlOC00\nMzNhLWFhMGItNDVkNzBiZTE1MjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyma2z4vR1XxbQhewZAoRhUC05EEIWWHNtFTVju0D+XZbOcjfYjmgvZysuTBwicaO\nWXyP6TZR6+hT9d4X1UXc06NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUslbGxOlX3yHk3TDX\nIhz1zcAjHNYwCgYIKoZIzj0EAwIDRwAwRAIgSbqUVd8dbRRZTwNsvKRuqDiv0Ecs\nnIsDcGl/BE5Mq4ICIDm6DoBQSRKDbOKfbnpRoQeGdMDbsK+2PEaJbTp1RITP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8069", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8069` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAZI76iINQBXC0VLM4m85vLqGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhOWRmY2QxLTRhOWUtNDgwYS1hYTRmLWExZDJkZWIzNmU0YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ0MjhhNGEtZjBh\nNS00ZTlkLThmMzEtODA2ZjkzYjEzMmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAO8n78ubRSlQjETOqp87GCkm4dx3Q+Awh5Y3Z9FQqjm/EiU/zNAfHhBVLuTg\niehbQH28XMP+W6RKJk4az+u8UqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtQXwUdqV0MN5fqJlGUzV0CF1rX4wHwYDVR0j\nBBgwFoAUAeX7Kf2JGxc7wMmzm1599382OxUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAl6DAnP840ivXtS7TCgoQ73gbYhQghd2DK\nZbGQkMwB2QIhAKWILBriYdVYiSjm8/jRZFoDcsjInDWRvtb6C7o298ll\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZImTIajiUPEY60LfAxVLbfPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTlkZmNkMS00YTllLTQ4MGEtYWE0Zi1hMWQyZGViMzZlNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLwcY9AbY6V+X6DtUGDoAOdAoMsB6jFdXhhaPlMGY1iDpn\nAXwyUvmrFKKZg7xjjJLF4OlpB69mArmR52mS2HgYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAeX7Kf2JGxc7wMmzm1599382\nOxUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKnUGV1ykfMmnXVnmsxVV6FEz1umZomJPp0gj0enomDpAiAeE9FGNtim\n7KMqEhYOu1Fn8hjEvcBTgX9qGBhXbky5qg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAd/sUMhafkY7CzMc5Xl7MvfWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ0MjhhNGEtZjBhNS00ZTlkLThmMzEtODA2ZjkzYjEzMmU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTViZTlmM2UtMDYwMC00\nMjNiLTg0OTYtYTc0YzdmNDRiY2IxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nC9okHZQ43Dksv1C7UH/b1zqZx1+vQ1hPSziSIVPHyvE6PtEx6tAGNqNk5CXIp247\nD6WX4viPWmVJaubXROku3KNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtQXwUdqV0MN5fqJl\nGUzV0CF1rX4wCgYIKoZIzj0EAwIDSAAwRQIgcjPqNE7iBbaLv3HqgCwQQ7rUR2Xs\nNMbu+Fi2BnkUGRkCIQCiNZNqq/lOnF79gkz6z3UJcPDFhWhtMPnKTDNHVw6MdQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8070", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8070` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISATR3z6ScWlZQOFv9H2PNFZ1TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4MjZlMGE5LTRmYzAtNGVkOC04ZTYxLTA3MWZlZjU2YjIyZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNmMGM1NWEtYzNl\nYS00NWMyLTg5OTItNDM3ZjIzNDE4OWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG5Ylekzq3NsOg5dDTYf7qBYKjQFKK3In3FLtna/7gAD8qNTAYxUJuBsSVzAH\nPCzRFYB2tZYwOa0hpCn/vWFMQqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5WghD8BIWCgabzPCSO6jVzTIbRIwHwYDVR0j\nBBgwFoAUBEfLASsDp8hVPvybnEA5rQD5TNUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA7kzHem2iVYb/axUuPHNjpqsbSOz7tEX8\nz4q73PlWnC8CIQDxMy8pxilUAEn0DCdJ2Y60BVZQ/UcF5zwZtaK4K3pfqw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe+aHhDQoLPhXBy1nHVZUbdWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODI2ZTBhOS00ZmMwLTRlZDgtOGU2MS0wNzFmZWY1NmIyMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSjNttWfTRSAK6wCyYnsb2SdE4M+XKwpiVx2VBySWzxaAe\nnH/VpXWDxpwkBvOph29vFzCnrpKl0cvhK1aBeB8ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBEfLASsDp8hVPvybnEA5rQD5\nTNUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ04cQZf3JbOMaKRjM1yGB2mhhH4spMWhfoBchVnqWSsAiBxKrPtE7nd\nZFfwom0uZ1fhEeF/N3lVAlzh8pJeAlrC+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISARsFXARS2ipDIVxphPwtw+N8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNmMGM1NWEtYzNlYS00NWMyLTg5OTItNDM3ZjIzNDE4OWQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDIxMzVlNzUtYTFhMS00\nM2ViLTg1NGYtNjdmMThlZDBlMTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0TlmctpqK4xlpTBztwvIWN4iGw4NgEY7qpSW6jL7prnqK/hg8kVdGkDrevABXhkD\nXEpnu23E+mpwvixVlWnJSqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5WghD8BIWCgabzPC\nSO6jVzTIbRIwCgYIKoZIzj0EAwIDSQAwRgIhAOZigvvYGaJu/7q1s8p9GqZGnyHB\nqCJC3z3ko6xMevrBAiEAxB5ofC2RHT7yxVBNEzQw/fsAXhCAfQ4e7nHU1Ta0aYs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8071", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8071` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAYdu/LwCGZLI+LkLQ/vctyo8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5MTU0NDAyLTFjY2QtNGFlNS1hODNiLTAwMDVjYWM4MWFhNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFlZDUxYzQtOTdl\nNy00MjY4LWE2ZDMtNGE1ZDQ5ZGU5YTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvsxUYGYrXNomtEXU28AONNW/WrSNl8FF8Nly674mMB2+7GMLPUUcu24PAA4P\nGrQZuRR1UYpuDGs8MhUK6u80vqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGzlUQo6M74QsCyDhPKmoryxVzcAwHwYDVR0j\nBBgwFoAU2CQeVPnGiBXaQvOW4/xFFR1BfKgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBDUfpJxbEPQDr7\nqY3Q3C2RiG6Rq/JfEaP3PVRe1UbCVAIhAJ83VvYglHlBCA1NPGkGpsAe7PyiDfmR\nKGq3mkTqR+rU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdoP3J35kBXXrWHExrxIdcQTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTE1NDQwMi0xY2NkLTRhZTUtYTgzYi0wMDA1Y2FjODFhYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/CgnM6c6uKFPIdPH6idDbAgApjgo1dxHfnfoK4gh31441\nLWN5Ol5ek2yETXdhgtrkhXIqH9+kBNu8eXe9FObCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2CQeVPnGiBXaQvOW4/xFFR1B\nfKgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG1YD3RrxwHDLqLP+tbVv2orTE60EIPxcA7AlVasXmGoCIQDhOlUjE0i+\nqEVnVOAFXdAabvoA2YsplNn8//qEbuh0WQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAcbar8KC47iAvMI7da835qVpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFlZDUxYzQtOTdlNy00MjY4LWE2ZDMtNGE1ZDQ5ZGU5YTY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjdjM2Q2Y2EtM2IzYS00\nMmM0LWEyMjYtYjM5OWM0ZTZmNzdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQKtNx2ZkUvPcEsqNtWoOJEbePDcbjTIbcNrIhkcHbwT+56n7QhX8rkNYONXMLSY+\nbcidfvx5+ct6KH5X5JooAqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGzlUQo6M74QsCyDh\nPKmoryxVzcAwCgYIKoZIzj0EAwIDRwAwRAIgUTs/co0+An4ADe2ke4Nh4QivU0Gn\nIB6VcPScyofzuIQCIG9WD27XVxmaj5t70pfwHSG1cQ54vMlCgDhOMcsp243T\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8072", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8072` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfnLs6nUiRugMPlY+0qS8saEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwNzBmYjk2LTEwMTYtNGQxNi1hMGZhLTgyNTQzZGQwMDdhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQ1NWNhMmUtOGIx\nNy00NmJiLWJmYWYtNTYwZGJjZDBjOTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwtU8jnro4LToCuOBx7srZ2sqIpfrN5K+DF5codE0409EkeAkcWk/m2sDoKk/\nZCgoJv8Et2jY4yE+OgwnQHZhCKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy2uGd/R7F9yMsbddvc1BY8SxAc8wHwYDVR0j\nBBgwFoAU5P5QtC1WN7JxtmgHqbZAZF7MSdMwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDOyIL7GBmDlg1UEJuF7HKz7/x64MQdOrmIO9oI+PegdwIgcKq6Ud4pPxPC\niN/GajHxVJ6fIrm+UtCQjFOU2nEy+40=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYde/2x0AgHFvM6ANBF2qHPeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDcwZmI5Ni0xMDE2LTRkMTYtYTBmYS04MjU0M2RkMDA3YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROrY+mZqBtTkvdXjf/1OGKy/X9OLrU9m9UmTdIHXZvgwmE\n+pFnAVMBPCCgxUOfW5h92FUS9KaV6UWK+IaiMPKEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5P5QtC1WN7JxtmgHqbZAZF7M\nSdMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOYGljFsArDWZ9zCQrfPxT/aFDxu0EX+6dtko1gDYkWYCIQCgjp7uSABy\n204Yg2SWS0fFp/3pSUkFuxVCqgoPGvrq5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISATR9SNIkBsw9ocYvwt6kRbFCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQ1NWNhMmUtOGIxNy00NmJiLWJmYWYtNTYwZGJjZDBjOTA1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjBkNDJhNmQtNGYzNC00\nNDFkLTkzYjEtOTBmMGVlNGQzYmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3Q5szYBva9aCKpDsEMJlebyrnioKYwR0cEDMIO/OAXVRIXnw4CB4Jix802jtlRJg\nQoeutPA7R80N1oHTIqnHV6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUy2uGd/R7F9yMsbdd\nvc1BY8SxAc8wCgYIKoZIzj0EAwIDSQAwRgIhAMb3ua/wxtpKnt+yk524yGGicj6B\n81hNZ7ZjOZ76ZakrAiEAkP1U78nICMjV1T0AttT7tljY2ubKq3942jkNx3xzLi0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8073", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8073` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAc1JhWvJPr+OIvluxs7T0oGiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4NzM1ZDAzLWRiNTktNDc1ZS05YjA5LWUzYWE1NGY3NzhiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBlMGI1MWEtZTYy\nYi00MTY2LTgzYmYtODY3MDlmM2I4MjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8WFxBMaTopUjY7vKqZa54+r/NN7y4CRheUfvNC3m4wp3GfBXsYnIzNIX/lBS\nTzCrv3McEDxSepI5f2afl9kmaKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUEwURiZGOhJnNqyCqEBfPWiH/ZUwHwYDVR0j\nBBgwFoAUEVdpJpit3JDT+eEoZq5vnd76wjowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIE7GlDKE9xZeqLQhlDL3zXK0+bY4hial3RPHv/u0NI2KAiA2cvtjVKY3DsfZ\nELJQtK0pbNJ8S3opy1uqif3VQTvBgw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZiIQdYriOjoMo+dJCNgWCnMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODczNWQwMy1kYjU5LTQ3NWUtOWIwOS1lM2FhNTRmNzc4YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/o3EZk+pdcHTaQ749WpEfrjs3C7bhu2y6iXbKsPYbDJBN\nKlFC4K3LmA80gTI4Go+4/z/vi7uPjscTLAkPI8mvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEVdpJpit3JDT+eEoZq5vnd76\nwjowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOvXUYTgorDk8ZUD3wUZJC9otGkXBXLai9gJupSsvSx6AiBGhNj04Btz\npd0oRTQqqHqIgUXPzJ70VUS3wZugLuWEsQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAXjcPqZIF4FgOiTc9Xgbqo4dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBlMGI1MWEtZTYyYi00MTY2LTgzYmYtODY3MDlmM2I4MjdkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDU0MTUyZWUtZmJhZi00\nZjQ4LWI4YmMtMTZiNTg3YmQ1NWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n36twJBsfn/Po3utFXIXx0aErXd50Sij9kCil/joydcM29GJUpiGUiIkVGb+qcrTs\nIAsnuEWIdIQhN465BRkU16NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUEwURiZGOhJnNqyC\nqEBfPWiH/ZUwCgYIKoZIzj0EAwIDSAAwRQIgM0tQKZ9WsRWggrSkAe846wyrrfK+\ntYfuVeaHDOFg44oCIQC8SjrStl0Yp7wzqg3Rz0zmtIvmjsogvK6iLoEDzeXflA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8074", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8074` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAVBvJutQpH50E2EBEBAbsyMzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5YTA0NDhhLWM1YWUtNGJlMi1iOWJjLWEyMGVlYjQxMDY1NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjFlYTc4ZDAtZmU5\nOS00OTU3LWI1MzQtMmYyYjFhYTNjZDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDpxiH8ENlJQVGeQUo8BdnLPZ2ndNlm1bsjR/UuyCLnSxpeuMSANPDXE7ffCG\nI+vVfz1kN1pwuAsGWsYIFM1gR6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoLfqEiKhki4C62M1FmRtVkyiwl8wHwYDVR0j\nBBgwFoAUSbyGFK0ZITxuWS0S/GlbO3XdbeQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiBQZHWBhdztB3IY32HTPIucN5ci42VrA6gCAY4V5YK0xAIga83FfsARWL2E\n/gI1E4B+gJqZYn3LtdBbYzdOf0P+Jr4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdvK5Q1dQ6a63j+UwASU0tGbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWEwNDQ4YS1jNWFlLTRiZTItYjliYy1hMjBlZWI0MTA2NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARk6zsOgGq4kGuS2xzGLp+AWPx1QNXMZ5pWyLS4lQE7E89A\nJgxQ9KU/156B/1GNOONQFS3yxGvzzrrjPLpWty8co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSbyGFK0ZITxuWS0S/GlbO3Xd\nbeQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTJPfektqnkm+GiyXKm/qoo5iIyUFd4W9w37c8XrGpgMCIQD2h+bq8B+F\nO+p4NFIuKlLjXV3a47ufATr1PUMZkx5C3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAQjEWytglkmfjodHZOTZ3LrCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjFlYTc4ZDAtZmU5OS00OTU3LWI1MzQtMmYyYjFhYTNjZDI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzZiN2VjZTQtYzVhYy00\nYWQ3LTljODYtOWUyMGU2MTJjNmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4BjDbDcNwA43iZXxf7vGX6kyE7VHiWDWusGoFiN0uU8zDf9liLKUpmoMKa+EE0EQ\n2h0qmikjGJlWNeUD6u5CMqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUoLfqEiKhki4C62M1\nFmRtVkyiwl8wCgYIKoZIzj0EAwIDSAAwRQIhAPfKzxaeWgFbhYvio3KijCmTfZ0R\nwpXuS7dparKCnHtoAiBh4KMxDuM+MYLrgnK4Bk8EUUD5L6XZNISdCUjKO7veWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8075", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8075` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAcYrF1uqQvQay7Q6vFBIUqYAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4OTMwOThjLTZhNDMtNGVhYS04MjlkLTdjOTU4YjhmMTQ2MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjM2ZWY1YjEtMGYw\nMS00ZDQyLTk1MjYtNDRlYWQ3MGI5MGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOlaQ/29V7hjXIUBA13mZlp1loCdZe0pYXrkeeVKkKECx8sG3alVrgsQNyv/l\nFuIDaPs7TcVZWCHxo87vNf3clKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW088Vh7rr/rJe/D1tjxQMpg/MokwHwYDVR0j\nBBgwFoAUQzLwZzu9r+1+rEMDzuOaYB06AxswQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiAn/dCGkGj0b/Z5Sn9fy73QzP73XNI8iJk83gTdSNHo\naQIhANFfD2OV3Xqd9f35IKOYP0jvdtz4bgQLTN8VfzKmpNee\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARkib0KZf6XPQW86WJc2nXQiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODkzMDk4Yy02YTQzLTRlYWEtODI5ZC03Yzk1OGI4ZjE0NjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASenNiKYWASmhAClXRyHVwiKnV+tn1EjjgbRWi0lecAhk5v\n41gm8KbM2FumeJScp939rUPpfKtn4JdTmkVKl+2Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQzLwZzu9r+1+rEMDzuOaYB06\nAxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPSOvhTG0VPBgnEqBXsCZSehKd9+G5f5xmMkvKSzo4LDAiEAvN9sdoKq\nvH+DvGtg5dRXd4JTSQA0OO2zxdT798wmr90=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAW2QvgeRoAt2Z/MRqNz2Qka+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjM2ZWY1YjEtMGYwMS00ZDQyLTk1MjYtNDRlYWQ3MGI5MGYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjQwOTUzNjEtMzY1My00\nMTA5LThiYjUtZGY0ODAxNTNiMzBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nErTSZO7M7UhGmaIxLuOdbkknSpbpNSZrXOthI7RlqbPA+txattOqe1u2Vrg2lHJA\n3s7lg9rIncreNsboSsrBf6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUW088Vh7rr/rJe/D1\ntjxQMpg/MokwCgYIKoZIzj0EAwIDSQAwRgIhAKLmRSbP2j1T952u6zQHA+zWBpo6\njIG5czu1NXGTeCi5AiEAgLbqs+PkcS/3v2QlQQnweedDv2ovpcUcmt3qGy40Fqg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8076", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8076` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAZllU/23s+uEoAmdKEWTdjeCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhOTVlOTM3LTFkNGQtNGI3Ni05MGM1LWUxYmZiYTRlNjJlZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY1YmVhOWItOWNl\nZC00NDk0LWI5NTgtODk5NjU4MjA1MjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkxukuH4j+pwXeg1g/T8HG7ZYytlYwyaVzusAiW/MgePTKHb36ddDSdsu88or\nFGqVkRNcYqD35yYKo/M4vbY50qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7g9PzKkOQT0ShTykaPEDhaiAAKgwHwYDVR0j\nBBgwFoAUdnHxb4Zr4YAZY8N+YoQle4nEjQYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAx+9oayZJ/tWvlZ/WcO4D09jWgsK0fvbswsnBTmIc\nJoECIQDaEW+HzpMuDzmntvrShAizMlxqBiuCkwlOn6mZX71viw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATIk6qBBvFmvRso2Ts13RR5NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTk1ZTkzNy0xZDRkLTRiNzYtOTBjNS1lMWJmYmE0ZTYyZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASM6RxK8xUK2m2oHFG6NQT/xF04wDwwzx5qCan4gBR8DVeN\n79QVdXsh0uebCKvgbvIKpU2GdbGjGiEK2se81u/po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdnHxb4Zr4YAZY8N+YoQle4nE\njQYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALAwwJJ3ZrnfpELgLFylpAWIk/0NjFcwlxWcct4hbhdlAiBJ6idnXTrX\nMKRsgBRqxQFLStds1OOxx3AS/E6J3IhyDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAY3Q5IAo0Br081NHBW7U5DbeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY1YmVhOWItOWNlZC00NDk0LWI5NTgtODk5NjU4MjA1MjMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGQ3YWI0OGUtOWIzMi00\nZGMwLWJiNWMtYzEyYjljMDY0MzNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlYltF/jgwItal2EhuAcuSnpEBTMnB7tTW9/KnJZ0QQkjVVgXXVZrxJM66y9nlfq4\ntnzPzOYgQ3zYiwtngm5BV6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7g9PzKkOQT0ShTyk\naPEDhaiAAKgwCgYIKoZIzj0EAwIDSAAwRQIhAIovh47ssWvz4f5q+H/+9o861/mY\nDuoMW0JAvSYAH/boAiBTJToD6SzqulHaCxKWBj+fhubnE2SrGEN04ZOT/rx72Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8077", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8077` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAR+oLDTWLAxYkSgRTNDtXablMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2ZWQ2NTA4LTI5ZTYtNDRhOS05NTVkLTJmMzFkZmNmNGVmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVkNWY3ZmItNjA3\nYi00MmI0LTk5YzQtNWZkNTkzMDk5NWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE36rR+vzb9VMp+MCnjMlyFvTc48Vk9m6U9iQ3bz6xNOsq4c+DpI8Y7SpL8XGN\n18aIedjI/VIH6IhpugBzOW9iYKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJM3/BKi3ZSOCaUJbcJGTMiucQZcwHwYDVR0j\nBBgwFoAUmLqpVm/exQ5nH263dds3aNN89fowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAr85khbqi3hSTcgY4Ma2a69FzsuyG1Jw9mAn0QICPq8wCIBh4\nn7RlyRmZcwB+2D/w1PjpugI/SfgF0+mMQ5BmokzF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb13Fja64j1xRk41PdzqkGwlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmVkNjUwOC0yOWU2LTQ0YTktOTU1ZC0yZjMxZGZjZjRlZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkhirPuHIWKOuE7lYwQr/JUS+VXu3vgv59OW3zrKlLNRTx\nJ8Bc0Pjphsbt3TFAog8SD1PoKB4mxMN+WDmo7XoNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmLqpVm/exQ5nH263dds3aNN8\n9fowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKhwLiQxKNhW51HRD5kqpyRQ5bNYu1/0fWv8SiNsJw5pAiBwzzN7C7tZ\njrvHRIkk9hs4OyZnJRz8myBsNuq71N/P+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAd2I8bRRAUCO6UMcT3Xh9WqMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVkNWY3ZmItNjA3Yi00MmI0LTk5YzQtNWZkNTkzMDk5NWU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzg2YTdkODQtNzc4ZC00\nMjAyLThlZDktZWM0OGFlMzk0YmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndc84S7CM2UnZ9CmofqWFNNZqT8bnjk+BovmLqRf+Rns4BuUVlnQ+CHRJ87hWb5f4\nEVJVPSmsN0E4clmJ70Dv4qNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJM3/BKi3ZSOCaUJb\ncJGTMiucQZcwCgYIKoZIzj0EAwIDSAAwRQIgbQkYzeGZgUoQvN70PgFsYhbx2btF\nK9912y+UBSOhBT8CIQDfXX+PA7X+pGGRuwyYK+V1H9x6AdU9uHm43LvWngf7Ag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8078", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8078` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAYhov2ep5vgFM6DnIZ1xBY9HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5OTNhODcwLTAwOTUtNDMzZS04NDE3LWI3NzEzZDEwM2IwMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRkMTBmMjAtZDY0\nNC00MTk4LTljOTEtYzY4NzIyOTk0MTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/H7UJJYtQHWtgNDPm2p8CBUc6EYIRIEv8HbRmAt/9gCJ4gML0TNdPH26YCe1\niRRcjrVVTKxgYzxtXjOI6MZlS6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdzzoEo1Oo9oRI6c/OuSeMIf4tTAwHwYDVR0j\nBBgwFoAUIcIDloiCrNKtB6VXDL2bT7P2pVwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiABpp7FOq8gGCGJAm1h8ugq1hM0LaoaePXR\nHna3Y1qdFQIhALhKFmldueXnHsEQ186nSE9hyJnRGLCQSTEFMCotJHz4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYwZh2ItoII082i4t3gt4dhQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTkzYTg3MC0wMDk1LTQzM2UtODQxNy1iNzcxM2QxMDNiMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT06V4xWCoQts2LHHizU48XYtjlm96h0//TzLXLu6N99N6H\nw8FzweZeCGu1VvUKpOnEPf4/241EhOUrVSgfUJT5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIcIDloiCrNKtB6VXDL2bT7P2\npVwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYb23E1JcS38nhpoli47/zYJbW5nlBXf9rSRyYjkj0BMCIFtOKfs8BaPA\nKwbX0tq7OnlDMfbNtg4Srt7dpJkCZfcE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAaS+JtoYP5Eo6ffybP2Y/WP+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRkMTBmMjAtZDY0NC00MTk4LTljOTEtYzY4NzIyOTk0MTliMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmE4Zjc1YjgtNjFjZS00\nYjExLThhZTItMzZiNDk3MjEzMjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4fBAuaXQbQE6GC6zUZwepzvU8qLz4tZTr6z4r0Wsrq9mAYNxhx8zaQAc3933wmy8\nCqyWDOFfg9y+1GrfvY4AYKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdzzoEo1Oo9oRI6c/\nOuSeMIf4tTAwCgYIKoZIzj0EAwIDRwAwRAIgClvRLXREfOzqHDsdHO5NcEdFbway\nlEHqr2ArYwVf+ecCIAYYi39IA13pwdoZ+M6tdlpggoWmngSfbPCe5Zo0xEDg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8079", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8079` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAQiwp2phjshRq1N/Y01Q+mT4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2N2M2NjQ2LWU0MzAtNDdjNS04NzhmLTgwYzM2ZDJkNWU1YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU1MTE2ZDEtYzZj\nNi00ZWFjLThlZjQtMmJhNGU0NTQwYWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq7GbiuzmaRliCpRULb4bqeAEbn1IsaHQr/tKKzpa283I8dyzsHZNlRLjMS04\nWMgxTfK7RhSm8y+eAA+7uVcJOKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEIn0G17QqQI/UCfEMEGmIGyqusIwHwYDVR0j\nBBgwFoAUne9UsJfCbvfeUpA+1+KdkhpPjYswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAmY1INpTOx7kZ4FBxNBHCfcsY1atsdixw\ncd4J+GLTwqgCIQDbkysI2KgFicscBwj6Ds+JYB1h7GLVP/aH0xo42Kz3yw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcsbZxIsQ0VczbEnEek6qDjBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjdjNjY0Ni1lNDMwLTQ3YzUtODc4Zi04MGMzNmQyZDVlNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQf1UkCCstAiUCLBjZkHZC1LqFAD34GXwyrozw8qtuViW7l\ncrG8FpCJsjsSEYHbErDIQDiQlvuEMiMEavtefhRdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUne9UsJfCbvfeUpA+1+KdkhpP\njYswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANoyfsazSQ8RTpS669Aq/b8EWKRxkDxP+OdPWYMmz8AUAiBoG8EKFDv3\nk2xBGSQhHkxSZliem9oHY7V1RCyR5DHwQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAU8zuq7hlY653uuDQeDgruMcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU1MTE2ZDEtYzZjNi00ZWFjLThlZjQtMmJhNGU0NTQwYWY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzBlZTQ3MDQtNTRmNS00\nZmM4LWJkZjEtNGY3ZWUyODM0YTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMvObNKJpdDdcwAmqQx2rWhzOrUBMHNuDC1gCVS43u6F/0xDNj3U7j7GWHcooAvXB\nC3i/32GUKbSyS4jJu+WpMaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEIn0G17QqQI/UCfE\nMEGmIGyqusIwCgYIKoZIzj0EAwIDRwAwRAIgOuIdRjmlaFCKen5a6zZdIlLMumxm\nvnxww4++O6kdEsACIAMdtsA3MxK39vl2dMebexrBHUWlGC1qfvQkdNhPIhpH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8080", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8080` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISARVfkvkGYz2bv2UvqBYLwsBhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5MDZlZTg2LTgzMDMtNDg4NC05MTgwLTI4OWJkNGNlNWM4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI5ZDM4MzEtNjgw\nNy00MDU5LWEwNDUtZDBmODQ2MmU5YTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAjTQjTPdYrwbtjwgeApyuqMoFpFKzyvZv1yMOhu7sPjKd/StcWtIazrwM3MG\nw2T3CRLKH0tL5x4Udp4/e0VokaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtueEG3n9j7ukjs2BE0Gfx9/AkB0wHwYDVR0j\nBBgwFoAU8ZagWZi7xz3glCIUBAQbwiR4OfUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD5s9cnR8mmZI/zYbFge5WIENpT\nlSLPBucb8qvJCswllgIgULBE0idj4ROTvV3DX7P+gcP+0GRFwTTxE90vSlEqzvo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUvIetRgNRHvRUW38vT5cNSBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTA2ZWU4Ni04MzAzLTQ4ODQtOTE4MC0yODliZDRjZTVjODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUPvWBoMmZv1zGm82cSRxrxrI5+HHVpCEf6Zh5FchKiua8\nufhqmWuAJpwMVLv1mjppDJtshRHvgVp80V7DeglUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8ZagWZi7xz3glCIUBAQbwiR4\nOfUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPbU8wud7HB/hl1iCAeaXoubd3o2x4DcuzhdxsaozsaICIQDuoGaT2dPM\nQmOfWvtwQ4U2KI6m0VJE1NjkSxngGpoeKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISATSS3d0xQYywCUxxlYqxl0yoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI5ZDM4MzEtNjgwNy00MDU5LWEwNDUtZDBmODQ2MmU5YTNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTQ2ZDJkMDgtODRlMC00\nNDVmLWFmNmEtYjAyMTBmY2UzNmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2muZqfMtpGoZbckDYsTQX/HuqUIabx+MYvW9Y5MPbAcfz1EeCAQxsvc7LeoPdMRh\n+c/BTfUZwoMrhOwMrsVW66NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtueEG3n9j7ukjs2B\nE0Gfx9/AkB0wCgYIKoZIzj0EAwIDSAAwRQIgaNgjRDyRYthEtt329QPOunkZtAMh\n1JjJFVIV16+QWD4CIQCHpRzNwHsewTxbPIRXe0ybycGlGVjO0NFpK42J0d9NNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8081", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8081` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAUKqEzEEECgGn8y424q/R2fkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1MzkyYTU1LTQ3YmEtNDVkYy05MmE0LWU5OTNiMzIxN2ExMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM1YTkxZjMtNDY2\nZi00MjJkLTkzMjItYTY1ZDk3YWQ3ZmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKEP3Zn/zSHdbnfCeDMaoIhJWRdsF5ek/65x5h0hsL5GwX767Yww8aZR1ecxR\nYNMqpNtLkwxHNeLdHyMy0oQURKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0BkuJGamdBi70rsQVcG6Atp2S2EwHwYDVR0j\nBBgwFoAUkPEFrYGSiq/5D4v/HLko+rbA9lUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAMKipYZE\nguA9GARFHlurzg76rhHq0K/fuYztU+ioFN9uAiEApVMHogzCLKOShmCbdDfYaBQA\nNWWIDWUrWrVY4djfuY4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeUqSzHz/ubJQCqUuEauMLrYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTM5MmE1NS00N2JhLTQ1ZGMtOTJhNC1lOTkzYjMyMTdhMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgUN311dwJULvmHMIpwpvYPyTEvS3wVkW6u1zvcnhDA2BP\nurMFI3BxvWOAQ1tsO1BPf0kn6T7ZiQT7uxQki8e9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkPEFrYGSiq/5D4v/HLko+rbA\n9lUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI1Cy9sTUEHWeBW/OVobkTLdmwYkkyc1k1VRgS+K4qDKAiADH314NXip\nPf6mdKp0sLYsvbO1kPhhP55ws0i3YK7rFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAdTKRZsWEpV+oEcPT0cbPs7fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM1YTkxZjMtNDY2Zi00MjJkLTkzMjItYTY1ZDk3YWQ3ZmY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWI5Y2Q4MTUtYjg3ZC00\nNjU5LWE2NWQtNzFjYjU5NWE1NGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nW4vKbSizyXN26T8riIC76cvmAxuW43DUfsDXJiYGD4JIPgnV2NAFthFJGhSeH9Yw\navzh9jWPafnUy7vLROuvEqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0BkuJGamdBi70rsQ\nVcG6Atp2S2EwCgYIKoZIzj0EAwIDSAAwRQIhAKVV9yLVJna941VqGdR7U1BTpWrT\njStQ3FiWvBkl1ZqyAiB9koBITwdysUJufyZN174Ao6euT/jcjdd3eMEyZ8CCqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8082", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8082` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISASIUGoTDNmCUv/8Fw7V/4a2hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2MjE5MzQwLTQ0MzYtNDhiNy04ZmZiLTY5MDI0NjQ1YzYyMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M5NjM2YWQtYTIy\nMC00M2IxLTllOTItYTUzYzU4NTNmODU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZG5qF3SRLHm1vsLx/pQ1GPxpeNZH8hXDVgff9I1IrDI/JrRdQD2DrV9/a4Mw\nSDnpMDvyIa82oAkkqQCKPBADq6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGo3ovU9HYcJxlYlHhKbBMlLrE1gwHwYDVR0j\nBBgwFoAUSEtoh3+7HPLEoZHplbfXWhObsA8wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAK9Z/Hqi\n+osT+LiIAzpYy9V5E5c6DXNJjxlQKtvzkZOrAiBphifXg98m/hroT7LFf5HMoWRo\nFFo5+ZLwT0IOH7YWKw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUMglh0vX1idX8So5SG4MKDzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjIxOTM0MC00NDM2LTQ4YjctOGZmYi02OTAyNDY0NWM2MjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCG7YmkNta9wZ8V/CruWhiKjE7aY81HuG+jCWrt8Qa29g1\n+d48vDiWv1bLhuFtgNg2ELYo0ysRrzl+zCcBhnw1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSEtoh3+7HPLEoZHplbfXWhOb\nsA8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKn6QDWT1asjaoYdEI2aFQHH3i6pN3a+/VLMziOGnISJAiEAuWvhfLoo\nNdZNiqiOxQNzlkphANy8huJbmmjE2iDnh7o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAVg/kw+n0ZNsTc4t7hYtiDHEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M5NjM2YWQtYTIyMC00M2IxLTllOTItYTUzYzU4NTNmODU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmRiNmU1ZTMtNjQ4OS00\nMTUzLWFjM2UtYTcwZWY4ZWJlY2I2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYKTjJLtbzRIABEuv9//CazfVxs/iHNdWNwbfI175NC30McTJkZFBqsZ8lFiYtykA\nTafI6qRt2kqVBO23BvfK/qNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGo3ovU9HYcJxlYlH\nhKbBMlLrE1gwCgYIKoZIzj0EAwIDSQAwRgIhAP5QkVmkz5SIzyCyCExnpEInG9w4\n/OKeAQa9Slj+tiqAAiEAjKacdKJnMeXujUPre54uV3GeRb/gMBNr7fexxrFhuPk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8083", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8083` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAZVOr/aZKsdt6gfOT6gzc6UZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmZGQ2NGNmLWRmY2UtNDFmMi05NTlhLTUzYzkyOTIxZWVmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI2OTEwMjUtODIw\nZi00OGFlLWFjZDctMDUyNGFhZGI1Mjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEksw4OvQDa+7NjPMTp4Y9LNwhAK4HGfLpV+Kqf+HBkPAtf2xK02N/+sTWRd9n\n3HHnv+CRQFNgYu2lPXnnKkTNCKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUej5Ln7zj2xxzcpzr7Yi9WhH8ZBAwHwYDVR0j\nBBgwFoAUhsBgFpa61y+XFwhvf2Mpw6fR8BswLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQClKO1h\nh3OU/ccwCsLMKdJHb1s0z+UhnVIO2HwAaKCYjQIgNAeotKdgIJz4unvgTZqK/7AH\n/p4zzT7Snt2LS2QKyQw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcoUF0u6u8i5NvP8sDZR258YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmRkNjRjZi1kZmNlLTQxZjItOTU5YS01M2M5MjkyMWVlZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQt4KnHWBxL23FaN0C0ckZ1SUo/W44oqVirVHkdGORp6W+l\nVjNfmcsOMIUbciAiaepXCSdmKcXB392fO9Qzr272o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhsBgFpa61y+XFwhvf2Mpw6fR\n8BswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK/vLkBe4obTiV36SVLYw6NBCNvlqzrek1osUb8ImPI5AiBjl/a4UFAn\ndkWrwcB+StT945Hl71eUPoA8lURx3VL5Gg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAZWGA6SDZwHKgqV5pXirqvZ2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI2OTEwMjUtODIwZi00OGFlLWFjZDctMDUyNGFhZGI1Mjc4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWE3ZmExZWUtZTE4MS00\nMGE2LWFkY2YtZjQ1N2E1NzU0N2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmqhQisQUmD5TrDDEmtEO4JzynxiV3aKjOb238Dt48qcEFS8eSoszivyhN2qMgsP5\niOfiupbVuelBhCFtuB/mJKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUej5Ln7zj2xxzcpzr\n7Yi9WhH8ZBAwCgYIKoZIzj0EAwIDSAAwRQIhAKitJS7sr0KalDYmTnIX2UT23lgA\nGq3NEFO1D9KxCYCaAiAsTR8KVm8TAyS8hmfQ4xSyeHwc0fIY9fI48l7Znj4BFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8084", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8084` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAWCJv2THZNMPq46Qs2QPvmhfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiNDFiNTE2LTQ2YjQtNGI2YS1iYTU2LWU1NDE3YzlkNjE4NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhjMTdjMzUtODFj\nYi00OGM2LTljZTgtZjdmYWEyOTlmZjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVdDsjxw1TnpePij6cOt4X7QqjApVF5fNOHXY5TfnefrE50Rcag4/6h73QiT+\ntkgR3S3UyNc3WEJcKU2fr23JNqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTFNHYm/QqIciVLAzzuPqj0DrVAcwHwYDVR0j\nBBgwFoAUU9gsbs4YiMn44r00JmCWajiYMYAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQDMhwom+ysM4Sx0ct9UUZua5JX5Jbz4XuZAhisf08TunAIhAI56qAXL\nC8WgAQayH+IkLVBpfeuST8pv3HQ6fWAcETR2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAagLfe13HD2XhqX2Rk569tmJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjQxYjUxNi00NmI0LTRiNmEtYmE1Ni1lNTQxN2M5ZDYxODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFg9wlAvuGaOarzjaPL1mDsysMrT6JgWjl0qiZj0Y6cNRN\nz82M/N7ZyCGVJnN+hlfxrlBbUKpKQOK/IdKr05ETo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU9gsbs4YiMn44r00JmCWajiY\nMYAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfa9+O3kvowSNYxn5Fkn/JLplXJQD6TOgEISIEFUb6XMCIA45E/zZlF8E\nnJT4+NjzfwS3gwAVmF6lQPE0ZuXhnem4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAQzwyUqG2iYjmECxT+NdK1aVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhjMTdjMzUtODFjYi00OGM2LTljZTgtZjdmYWEyOTlmZjdjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDYyYjZlMDMtM2JiZC00\nNjBhLTlhZmEtMjUzMDY0YjBlN2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDyV25zgGu9d3ArkGEpsDDj9sCFk2HDEvnVFO6u4yXgsHEeeJ3fRLn/B2vZdrO3jG\nX4M7pS2Tn0pP/M2dUcFWmKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTFNHYm/QqIciVLAz\nzuPqj0DrVAcwCgYIKoZIzj0EAwIDSAAwRQIgBjbWIAbM+T5Hx+Gc5xkoLymOIU5b\ntOHURxNm+Qpmyv0CIQD4cGjtOTjEh+WOYvR3e/jj/6xpzpKql4gkWiFvS1S1bQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8085", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8085` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAYjhjchIWdEtlhRuxtKhX/h4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3ZjBhZWRmLTgyMzktNDg1My05NGQ1LWIzMjExZjVhNWY0YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZlM2M1YjEtMjhj\nZC00MmM3LWFkN2QtMmI2MGFkYTc4NDQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvBDqd/zj/IwaxJxAuDvGQj1C3TjsurzaK24b3A7pY+AydWo3x+X7wrQrrVzc\nKLlG1a0C/sn1JX3FOrVbzAv50qOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJSkfZT0F4+36oguRU6d9esKjQ5IwHwYDVR0j\nBBgwFoAU3L4qjfT3OrUMds2t6T0IMY999W4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQD16WzCLIOaC+4CDTZ0bVWskb2urezm90mxWXsMkLOe+QIhAI01II70\nh7r2XD9r/G7cY1KE95vBrh78RhCGKNo2afAO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR7pWAzY000UO+XHkAVumYI3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2YwYWVkZi04MjM5LTQ4NTMtOTRkNS1iMzIxMWY1YTVmNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2MQRVnNiHktRP+JEDFMlSJpkJ4mcg+PXky3i2pDUkxNZR\nGtjRjHZc59e/UbIuMB70aqT70j+TFDK7YWr5opjgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3L4qjfT3OrUMds2t6T0IMY99\n9W4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPDRaujg0h0X5JJ8xSo1qhGlWKqo7YO1NYHLI9PlJrTlAiEA+J+9rZDT\n7xAq0PnWo1jrAAHZkVzx25PzrI26PdGMJac=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISARlo1+dLID4RUQSIvaGNfhyiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZlM2M1YjEtMjhjZC00MmM3LWFkN2QtMmI2MGFkYTc4NDQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzUzZjU5NzgtNzAwZS00\nY2QyLWJiN2EtNWVkY2YwZWZhOTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4QLgFtEz0p6clsCOt9uzU9uqzcTZIH3nyUCprhh1vsQew4SGtiZqnDzcro5b7YTJ\nS/Oiarzr4cI+XuBYKbC5yaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJSkfZT0F4+36oguR\nU6d9esKjQ5IwCgYIKoZIzj0EAwIDRwAwRAIgAWLsihtAibqZqRRziHoj+1YWmaR0\nx7U3Vm+OIf9tqRsCICSUxiR1l8TlS/Xxr4EiddOl2XEO1wPLSZeTJ0pFtJhO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8086", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8086` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISARPtFQ+0DCX2BLQLNLLdChZWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNjBiY2U1LWVhOWEtNGJhZi1iYTE1LTQ2ODRjY2MwYmFjZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk1OGY0Y2ItMGRk\nZC00ZDUzLThjYzAtODIwMTcxYjg3NTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ9bEM386NrAssFP6pVSWAJoCJwXT85wHBFeRUIHqn/1aFcwOJSNEtBNbG5dt\nhCSLfOMoWpCKHrSOxHeaoH4iuqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ3D2L1Yt2dmsPuOTQGMwwcmBm4swHwYDVR0j\nBBgwFoAU06gdureupirHFlrF0qWt1cgFYhswMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQDstG/J8AvhSBr4gn4M0LmNMqJyf4puTk+4fRxsu/vDAgIhANOMQSOQODNQW8wE\n2p/usqzDjkNiowyd/UPpCTL3m9Km\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfxRP6ZL5MVMcSeHS/hRfZKiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTYwYmNlNS1lYTlhLTRiYWYtYmExNS00Njg0Y2NjMGJhY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkV1sn+BqOcmkF4sK+vtDcqwMTELBTBWxMNxv2yBFFDwMO\nNQs1hZAJkb1l+CaFuq28LIhVA6xLnjZnBGFtxWoZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU06gdureupirHFlrF0qWt1cgF\nYhswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMu/qfDldc7AKYMHVhzYbs65bJ5ib3dOOSxHMSQ3c7UUAiEA37gO4Iy+\nx7wHqN4zBp1hv28SqARbPjZz5SL/R5tn+BI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAZxkz9UYcNTCeVZvjn4bhmydMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk1OGY0Y2ItMGRkZC00ZDUzLThjYzAtODIwMTcxYjg3NTJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTBhOTcwYmEtNTk3Yy00\nMzk5LWI4ZTgtNjk5ZTIyOWY3YmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nErifUdeZ0Vbjlfrg43D4+0hjK9Q6OW1QXWATitj3qp6nyQnUi2Wo5TUPbJScvknm\n6TIwk1SbtVsqwFX9R1yGTKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJ3D2L1Yt2dmsPuOT\nQGMwwcmBm4swCgYIKoZIzj0EAwIDSQAwRgIhAMh51RidcV4vCA/ndPFKxHaUE9nc\njcQjenEaihD650McAiEAm8WZPL1L1pJfw+dgMGDi8Yqmw1CdOgDjzign1WEfKgw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8087", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8087` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAe1Hb+iW/r2HnIVOxLhShLigMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjMGI2NWVhLTM4ZmEtNGRjMC1hZjM3LTQwYzc4ZGUzYjE2YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThkMGNjODMtZTdi\nOS00N2M3LWJmZjAtNzFhZmU3NmMyZDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaZuFt5e7tu78twzj1PltwAqRvyCQALEe+Z9d3unT/kImCSOVqH0SOvUMt9/L\nKnFhqXYXN/bWJ9aHmjhjo0uMu6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUthrYYpMm0HAZh4LfCnYkQxCwjd0wHwYDVR0j\nBBgwFoAUMAuWqJL5XDu4as9kyXRujMc2EjYwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCeuzU4DgSqig2If5eS0t/8XkpQOoMTiGIGj2hi6UH2HAIh\nAPzLykdPA8pWBvzXjiAVgGDU1mRttFKHAmX3tPBXF974\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZc9uxpSULkSjruDGkBGYdRcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzBiNjVlYS0zOGZhLTRkYzAtYWYzNy00MGM3OGRlM2IxNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/Q9WWRLxIOz8fG/Pzwu6HkVGQYazQkztnxjkjkIWfNxbL\nOiKzyrWPtqOIgytQS7y3rg0UwnZ7XTMeAfAcYNE/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMAuWqJL5XDu4as9kyXRujMc2\nEjYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALTi3BJ5+K1dicy5VLjjVLWdn43vgANwbTzTkpXUBUfRAiASXANlKBab\n4JALVYmrojFLuIQMpyjKOr420ufmyj55vw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAb+jC7oPEX2AQFt+kvms7CA2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThkMGNjODMtZTdiOS00N2M3LWJmZjAtNzFhZmU3NmMyZDNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmNlNGRjMTgtODgxYS00\nZTVhLWI3ZTUtY2U3ODdlMWFmYWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYvAYnkB4gKEdQWxCJSLNmHTTwDkqR7u1fvJ+RiB8C4iA8EIsTh4URuEzZrKgs5Tt\nW9/D+HCiHoqEMUxCdyN3MaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUthrYYpMm0HAZh4Lf\nCnYkQxCwjd0wCgYIKoZIzj0EAwIDSAAwRQIgVTYcI0wZq4iaC0HlW5aiQWDNJ9Cs\nFQX8D2Z9QM+KtuICIQCPZR/WyPtzWlLZCLixcAb9o1416rjhh7PBYOtMgLsI/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8088", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8088` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAcid3U7m1q2agR3c7LRgWdoJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ZjdlNjhiLTZlMTEtNGRmMS05OTY3LTEwZGY5YmY1ODJjYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzNkMzM5ZTQtZWNi\nOS00N2FhLWIzZmEtY2M5YjhhNzI3MzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIzvm/mugBVvltCop9qRZCD8jxBd/2wdV5NL4FnT0U2mwhX9fXimtjiIclreu\nY+Pxio+dln+CMORgRqh/WhqkPKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbC0HxQipY7tWpuEbOp2XM1h3+pIwHwYDVR0j\nBBgwFoAU6PEUKDUsIRCUYZ8rXLirEvs0nvcwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIAbsM+Ez65H3gkfG+Nri9vkT4vxFQN06nvz0s2tBcSDeAiEA\nvJqMFkSGrPUKt2swvkKFxRqFREbiifr1NuRHChIbvYs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ6NgD7o3Fm3TcWmF/ybBBR6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2Y3ZTY4Yi02ZTExLTRkZjEtOTk2Ny0xMGRmOWJmNTgyY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCIat036rwJ79yJttoqbVUsxvJJYoEhoowpFMr9YFLrH+L\noNIpYWQSiqW/DYY3mw8ghdKQ8sntwewfF/muudG/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6PEUKDUsIRCUYZ8rXLirEvs0\nnvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI0WW+EMadgDKv3YIH997B0XDqqCHp6zDCqviMiY6TJaAiEAiLdoek67\nS33HhdHpZpdMXeDgXhR24WrmATu+UC1g6LY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAY5cygflv2vF/n1u83fKsZV4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzNkMzM5ZTQtZWNiOS00N2FhLWIzZmEtY2M5YjhhNzI3MzZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2ZlMDA0MGEtYmExZC00\nZjNmLTgwOWItZmEwNzI5YjMxOTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\na2YR8F4ctAlYmsVSFMyfGYQHmuEqIzCg56WCOwehO5725jutG6VJQXmg+5Xph7qU\nffeCBMja8lOSxWCL8GulXaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbC0HxQipY7tWpuEb\nOp2XM1h3+pIwCgYIKoZIzj0EAwIDRwAwRAIgJM3JeoRLLIN3NvF51JyFcDry7GMj\neppDkETpDZmYgQACIDO2+coFTgTAiuOKhL5p6wnW0HAWqhWBH0QI2BQzj/Lw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8089", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8089` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWfq2gQticKooW8zNq2dkUYeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1OWE1OWQ2LWI2ZWYtNGMxNy04N2M2LTYxYTEzMmM0ZmE1YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDMxMGFlMzItNTc3\nNi00NTEyLWEwYjMtNTUzZjJjZmZiOTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB9YpCAe8lJnTwvxKOGg/nPMevTj1pfSstRNiZbkXdZtkF+kPX6W3NaqCgXjo\nmnRDmZknXZXJDNmVJTTsL2tfPaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ7hpF/1SILECan3tftxJ/VbMiyMwHwYDVR0j\nBBgwFoAU+5ytHKnQbUMgHk51SJzpFp1bFfEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCohbnHPMxz\nNELY3hIO5BO26MUA8mXHijcYycxH/FkfhAIgEXKG5T6pmYcPIuyyC6v7j+EcG51v\nSoWoj5Pjs8gO3lY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdjL0/qLGvxPbwtb2A01vFUgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTlhNTlkNi1iNmVmLTRjMTctODdjNi02MWExMzJjNGZhNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9rdD/H/srOBgAVWCMWpwm+S0HNNn2rDV1/QlRzvA+od5/\nEtXSRtxbJI1c+eaJeHeudLF91Bf5F5d5Xp1V7k4Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+5ytHKnQbUMgHk51SJzpFp1b\nFfEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKzc/vwBkVH66cj35vKGK0joVsotZSs3eyV0nW+y9Uw4AiEA5g0pfMGA\n/WzFb66C5frEZVfHho0NjacZ+3IkNKZz76Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISASsK7j+1bF4eRSkND5pk6PQIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDMxMGFlMzItNTc3Ni00NTEyLWEwYjMtNTUzZjJjZmZiOTFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2FjOWY2NDMtZDQxMC00\nYTY5LTk3OTUtNjg3NGJlOGRhYTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1c1+5+7g+p3XgN3yCwvOoiGqN+B65gXybi1BUSs0cG8dMnBphtz8/FzyZm+vOfVp\nGFPyfgKFxGn3Gp76favUHaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQ7hpF/1SILECan3t\nftxJ/VbMiyMwCgYIKoZIzj0EAwIDSQAwRgIhAN8r3TVULvDbTA6nMPlfGoU5R+Vx\niyHtieorpNCKiV3AAiEA5Wd0/u9+OX8UNBAOeZQ6v98bH3k2G31h/i4uqWXZUp4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8090", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8090` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAS3CVjPOFQjwaPFxQQ3phxS8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMmNhMjdjLTc2MTMtNDM4Yy05YzkwLTk3ODhjOWI3YmE5ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzkzZDJjMmYtYzQy\nYy00MjBkLTliM2QtZThiMzZkMTRlOTI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYPLOTz0ak7Nve9SvqOhXL2m4hIg3RSHu7XsrNDvqSDT6I4TKU2fLDbWayFPc\nzcQR69Mf2mhMdJZKbEm5e8mMbqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDZkenTnzmpZDyEl9XeHoFGoSVqEwHwYDVR0j\nBBgwFoAUHeR/fF+CfbO1N3xs6uwelfJtQ1AwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJxi6cIOB2oHQZpcwfs0t2/rOkfC29w9EtSAqcHFJn5YAiAQaxov3fId\nWZC35FYRqUbMCqrIdSSy1kr01iBzi9owng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARR0grIddzYctKsGZx79+vp+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTJjYTI3Yy03NjEzLTQzOGMtOWM5MC05Nzg4YzliN2JhOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQc33U+VIO5Al/k4T9GrxragFXfesGaKo47af780xX0t0g6\nrII363tl+ALf9sXx6ngGoc58EkCXVOv3KyrjM5zko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHeR/fF+CfbO1N3xs6uwelfJt\nQ1AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQxXedEAEZWa424DJF2gMu2N8qZBuQ5BMDtnJyNMg0jsCICxMs/zhbYhw\n5MERQoXs1RzPGq6FUnVsK4nZtJ5WwJaV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAR90M7red8MAcJoEJO7MZEPCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzkzZDJjMmYtYzQyYy00MjBkLTliM2QtZThiMzZkMTRlOTI3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzk3YmZmNTAtNTc1Yy00\nMjNiLTlmNWQtMzM5MTI0MjUwNDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\no7YyVfzB3NiX4Hyz4KemX1pqm2ww5QbOA9CoMxGoEs0Z35CVXm1U5TNHG6KJN8g0\nVa/zB4JDl2m9zsYH+hZAh6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDZkenTnzmpZDyEl9\nXeHoFGoSVqEwCgYIKoZIzj0EAwIDSQAwRgIhAJRv5R9n8a0blbmJDaMbWA9i8iiC\nwAW56PH81RbZvKkxAiEAxQJ9INtx6hFOH6qXUxFyeq4vkE92HVnV0+Q7rW1/Cqo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8091", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8091` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAQOLDmFPs2Opl0rKfTx4Ln4cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjMjFmY2FhLWUyODQtNDRhZC05MTdhLWZmODYxNTViYzMyMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDdlNDIzNWEtZTVj\nOS00ZjEwLWJlYmYtYzM5ZGQ4NWEzMTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEySpxMGeQFN7FQtkLiIYjmV2R845EajgG/ara+UZIEsl0GEgA3qcS+InOXqpP\ng4IBiJ7DKy1xA20SGqzqIZENk6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSZw3N9Hsukh7shHopynFpjNwt0owHwYDVR0j\nBBgwFoAUqGphRqCHqReP5yPdG5qQ3O7JtqQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgA3kSNV6F5rZzeJoR4VSdjqgfPqw5ZIrlsv8oVWq/H5ECIEZZxyWWvxgn\n0fR2Hh/q8r9gnSAkhbTr1Uak4Hd25wK8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAamPg8YVSkcwHiLCcfSEUyleMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzIxZmNhYS1lMjg0LTQ0YWQtOTE3YS1mZjg2MTU1YmMzMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8cknBi53S3m2XRsNcw49soThyLNNd5S9Mkux+E+FvMWfv\nVeBItQBJyYzW1E5MfPshsJF91AI5ITPyPXW6mTb2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqGphRqCHqReP5yPdG5qQ3O7J\ntqQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTaogfukqhux8XNZy21iRb3lMoEANAsvfYug2za18S3MCIQDRq+5unjU6\nDBckI+IEnHFHX95Adjdl3TEkeFlE+f5TGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAcDlzMRzZ7BU5/ca9FNtK1naMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDdlNDIzNWEtZTVjOS00ZjEwLWJlYmYtYzM5ZGQ4NWEzMTg4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjVhZTEwMzktYjU4Yi00\nOTRmLWEwMDMtZjEwMzVkMjkwY2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVN0crkguCIUjmlXh9iZ2JGS/wnnWtAg9n52d1g+wpkkeU14vNj7VgqP/EHjo0oqC\nXbICvgUYnAFAmTbX0EAXJKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSZw3N9Hsukh7shHo\npynFpjNwt0owCgYIKoZIzj0EAwIDSAAwRQIgWlX09S9+TLyyB/uLd2g75198/mqx\n+OOQeYKmwENB9ucCIQCFoOSbkroPLaVLQbXbLF9cm7TsJHZkJA91lI9avDadng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8092", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8092` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAaxi3rTXDUTDNPscJ0joImMHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjZTg5NzYyLWI4OTAtNDQ3NS1hN2Y4LTZkOGEwMmY4ZjVmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjcwYjE0Y2MtMDIz\nNC00YjFkLTk2YmItM2Q5ZjA3NGUyMGFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIpzdIbCCiOghlp8m0tcK5Wgd3WDOYmt6dmzmMBlM/LUKLT2+Oxx4jBDMCgmZ\nI9i1HyBcAYHq1Rv/0ISVkEieZaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmzO1dXw+eUoOh7tW/SUFCfmXbiAwHwYDVR0j\nBBgwFoAUeFJlUEhkDQm/tUzg3zKKn8JmWMwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIA/SAqDB2nVj3iXmbZbUyu30apaxBp0oghaz/o1MPItCAiBwawDP/Znr\n61hQVk4j+tAOVsbHwSYub5hOViP2/DA2aA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAURVHevC0Z9LCx9jMsWGg4zxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nY2U4OTc2Mi1iODkwLTQ0NzUtYTdmOC02ZDhhMDJmOGY1ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1sIHB1i7c5RBe5TaigLm/wka9hAL3HE0Tp13zYsfJElHA\nBSOxNZWCc4j0MeFZxzP7hBiCfI5s/032vKUEB0foo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeFJlUEhkDQm/tUzg3zKKn8Jm\nWMwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWgkVu3f5lLai2HPczcx4Q5xwlZUo1ypFjrRTjT8L/xsCIG3yirMn38Hy\nA4vt96ycLd0cGUyxqxt5jpkB0JP9T2d8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAaIcoyUhn3V844QY1QxPHNpTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjcwYjE0Y2MtMDIzNC00YjFkLTk2YmItM2Q5ZjA3NGUyMGFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmNiNjFhOWItNzIyOS00\nMmU5LWI0YTMtMGQ5OTQ5OTY2ZjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5e5lJjUYZ5zHhuqCgSUTRedZcemLTcfQg3aZLQMhRmpE5sK2S9vKMIynEvjT8lvG\nuEaqqEIpPztFtunF+hVRtaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmzO1dXw+eUoOh7tW\n/SUFCfmXbiAwCgYIKoZIzj0EAwIDSAAwRQIgYa4JqByT3hupXoQnllcvmV1NtjQS\nhXehYjWO+wvofIYCIQD7quYeYsHHvyBe+oZdkRvctch6UNrlXJXbQb6FpBRQqA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8093", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8093` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAa3EUQxTAI0pHEPwPYHv6zFiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhMWUxYzA0LTk5NjEtNGYxMS04NWQyLWEyOTA4ZTMxN2NhZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUwMjk2ZGMtZjNl\nNC00ZDFjLTljNjMtNDRmNTVkNGNlZjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE77tkoz+UNzk+GD4KmuRvNd8StRu2JILVr3ZSGjd+CS5rjcI5XUpRG8MZjkRd\n3RWKCvXxN8EDH/aP41XrfG1ImqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQL7j61jpPvHTf9+56nPDi+PQ6b8wHwYDVR0j\nBBgwFoAUoTwFUjTbGHuqI0+VCdBmEdgqRCkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD8DmyGLV5Qra02zE/79DgS2epPqJAp9wlb4On0\nJr3ylgIgDBgX5Z02ADjpo9uhR5SRfNCP5C2yXIsmKOvCsDaY2hs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcz96wTKVcUhgLx0dPn1YSqjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTFlMWMwNC05OTYxLTRmMTEtODVkMi1hMjkwOGUzMTdjYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwomgLQoS132UjMZnlx3o9JRCCKL5dvw1HI8uKj8ptLjrp\nDnWozroVsJRCAFQNsyHkIq48JLOa7xQPze1NVN/lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoTwFUjTbGHuqI0+VCdBmEdgq\nRCkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIsp5T9dYM6YvH2ZfQhlRwFCeExoSPlNckTXI0Ba5M8zAiEA+sPVFosF\nzo2AnsoeC1d3oqDOxBIXhqy3kED/W3B+GSA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAeaQ+JxFxpx1K+nZ5pGyRcB7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUwMjk2ZGMtZjNlNC00ZDFjLTljNjMtNDRmNTVkNGNlZjkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2Q4Nzc1ODAtYmZiOS00\nYTc2LWFjZTUtMWNlNzQwYjJkMGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niK8jyXpT0LFJZVaFdeZmcjDnbhp26tzhOkb0uJ7O+qt0sxruCBulFXEMOGXIX5Hl\nHSblFGvP4GWAg6Wat48eHaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQL7j61jpPvHTf9+5\n6nPDi+PQ6b8wCgYIKoZIzj0EAwIDSAAwRQIgVM6SniXjrBSYGCWovQi+2hpusMgt\nT9DB+pdAALEGp88CIQCzMAKTKo7P9YtCj5kC+Dqq2ZsmKic+AG+yw6jV9klf3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8094", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8094` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAezKFvYBPfKDB+dNVE//qbLOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0OWFkYmJmLWM1NmUtNDgyZi1iNDMzLTgzNWU4YWUzYzU0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYxZWJhYjMtYTI2\nMC00NjRhLWE4OWMtNjZhYzkyOTc3MmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEv/GeoHsA8153yJ/cWr5hwuZ69Me5b3ySSizyJ8tWHqq3eFM6dl9DNIH83sRf\nFsXckcWw2R9rlPDvB04z6WAw6KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKcchR3c2bqbS6csPvhLDkCDU7y4wHwYDVR0j\nBBgwFoAUk7lZs+k/Rgm/r2njOjGQ2cu9KagwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCtucLlq0ZcXj3R6TiQTpUAAn1IH1J3OdVQbwdr\n/n332QIgFwrw8crVJRraXut8Z3/9JIMkNJkQLKNZ/gu7Hzv2FsM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQqi1ux0oIwbh1MpnP3BKAKcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDlhZGJiZi1jNTZlLTQ4MmYtYjQzMy04MzVlOGFlM2M1NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJ+0WFF7RH8RUB8+DLN+Dy7CIv8yXBp4xKoO+HPosU67gX\nAfvZCTssMX7EHAYovVHGBJhcKHoCj+Rm6bHKJwFEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk7lZs+k/Rgm/r2njOjGQ2cu9\nKagwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALoqNTtL/isA+O1HimxCVe17AagN9xSI0EQi8elRGKyCAiEArRDV+M19\nnSTyYuuNHh8jhzECLK274jx/H8pusxcusDA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAQnK2jY7Z0maqOh99VeUKyN5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYxZWJhYjMtYTI2MC00NjRhLWE4OWMtNjZhYzkyOTc3MmQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzJhMjcyYzQtYmIyYy00\nYjAyLTlkZmEtMzEzNWM1YjE4NmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDawAMm6WmQz4ApyVSDrez61S0LhnSmuXImLAT2GvPnpeRM/CMAeNJxRkq+vEabyA\no7icZioUh8nGs3UexMpp/qNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKcchR3c2bqbS6csP\nvhLDkCDU7y4wCgYIKoZIzj0EAwIDSAAwRQIgBS7ynS8bO+dwj3yYC7qI+S03phwJ\nZU2M7eJN03WCjIgCIQDLSsYcFnwe4E5eP4ecwfn5RTV7sYVzAJdgnyS063z/KQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8095", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8095` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAa0oXVZl1hSc3goQuwfJWMIzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5YTZkZjQzLTU5NjYtNDkyNy1hYTdkLWFmODE0YjgyMzg4NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQ1ZjAwNDUtZmQw\nYi00MTZjLWIxZDUtYWQ2NzUwMDFlM2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYs/O4xx+Lhuwc8DbNNdSJTLw9D6B0ZDtLrlMXDVgJLOG1CjeTANh9dOtDZPD\nGOhw5SW8L1HCODA/pTcjiuctgaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUba1Nr1t1G7NxSkCP7IBb8cMiNm8wHwYDVR0j\nBBgwFoAU6u/wEHHnbuMshrli4LKh7wjLh5swPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDNkk+0vxdS1tyl+1ocWbVT7ES3epug64BAjbIyeTL/pgIg\nJRfRFWMJYtoaGnpWjdeuOQREddjXVH9a4NAPzjqTBYs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATKIcfIsDH6hjeiWwkAuTsQZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWE2ZGY0My01OTY2LTQ5MjctYWE3ZC1hZjgxNGI4MjM4ODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQG2+gBKlVoMGS1+0UXkn+XnmLTUqhszX92Xzfh2gfgFc7+\nxvggOb8LJbj9DOipZBrJ7kj3jqzCUAyQISjHUmhKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6u/wEHHnbuMshrli4LKh7wjL\nh5swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK/7k6DJT/D2u2n+KuRrZCHubON/UJiLDN03LSiZIe/dAiAP5qapq0yc\noDpLE92on4uvXyKP+1r8DYRW6Baq0eleKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAQsaUzPo3664ORPxOKVuKc2tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQ1ZjAwNDUtZmQwYi00MTZjLWIxZDUtYWQ2NzUwMDFlM2NkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGJhYWI3ZTktYzc0Mi00\nODY5LThkYjQtMzVmMTE1ZDMwZDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9SDtsLtVjj7pg/T6gfJR6wzG9IZQTisN0vFcP3GHU0D/hwFPpbTD4n5dSQGMy8Mp\nIY4BBj/ZB3JAD/ceLsff6qNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUba1Nr1t1G7NxSkCP\n7IBb8cMiNm8wCgYIKoZIzj0EAwIDSQAwRgIhAP3edT7CetKIVO/T4lrIf11HlC85\nOHxJea0nYjO2sJyyAiEA1sTXkV51rsfI7EWsAqO36VQlzyTxQ6KvGrHSBAQNHc8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8096", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8096` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISARfWJLE4I91OrWf42qrtGOKjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzMzZiODJjLWJhMjMtNDQ4Zi05YzhmLWU5ZjUxMmFmNzk4ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA2MGM5NjctOTY1\nZC00OTc5LTlhZmEtMTA3OTU4YTBjOTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErbg4zxg39/K6+cnUZpbrtcgzd0h/3ncUitnyQjUcfXhAwH0jvUc+TLlg6GrQ\nIBNV8pv+Kloqg400BR1sfr59YKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8V139khpq0DLt6EAf5ekDZzHfwcwHwYDVR0j\nBBgwFoAUZ5XeUZXgugKvkMRcIekUF/xCAMEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGJNiapjHdsi/w2jUCF9Z9eKgycUU1K/\nNwj1QoQPI/ZOAiEA25J6rVHKGmGumQO2ccL/9mJ5yF9GNvHKRMUiACENpcU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe8GINZU8Ef9mV77qb1S8thuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzM2YjgyYy1iYTIzLTQ0OGYtOWM4Zi1lOWY1MTJhZjc5OGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjn2V80mtg9rgL6Ltd7fCUT3pBM2skXjA1uPOnU+WLcJNN\nSbbZk/5vp9ixCuW57g9s7z9Yej3B8N37TCezkIEmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ5XeUZXgugKvkMRcIekUF/xC\nAMEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKuVelhFbj0h8itDh6Sztw+GLRMnVgjMTpJzRnNMsq4LAiB8O7fWUCrc\ncHaLaUbyrCAsEsqI+2LUpVeIfn2yqDxWdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAVIM14JEl1ZBwzz1E84kTaf3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA2MGM5NjctOTY1ZC00OTc5LTlhZmEtMTA3OTU4YTBjOTVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmEyNTcwNjEtZGVlYS00\nMTY5LTk0NTctZDQ0ZDg5NWJmYmU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCNaC2jAdU8oluOpqoWhXCN4lIW/XfMwPcnFcdMO0Sr7LTX3D+yvuY5eD2eu5xIYb\niD2RXDpKnyc6NkaJVCnktKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8V139khpq0DLt6EA\nf5ekDZzHfwcwCgYIKoZIzj0EAwIDRwAwRAIgT9may/HwqyPzoT9lwptgJxf8ro1S\ngzQ7YtNsKmCLdXICIGVv2ORb4H03RQ/CAh0h49HK/P/9NtkHJLbxxeVK1V1f\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8097", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8097` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAWr6NsEWVDOaq8h3QNleXMiXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxNTEwMGZkLWY3OGQtNGI3MC04ZjQ0LTQ1ZTg3Y2UwMWY5MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTEzNzU4YWQtODY0\nMi00NDc5LTliNGEtNmM5NGQ0MTU2ZDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvRSlBIIXZahPG/YkKAK/ctOGr0uMQ77nyngCYW4MuZ7x+fuwF2yRXtuQE9wQ\nVDcxUuU+JSsiMmML9p45EuhBcaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJv4EBGyQ7nyeLSVYofXjOqkQw70wHwYDVR0j\nBBgwFoAU1p2FI8c9d9VCZrbqEAn+bSskYBwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIHiieH2hkrgwV6Fs88i2DnreA2sc8tSu\nTSItdKZAfmpGAiEA+k0Pbbu5ntjcUd1lSQp6uE42hSIhPuLk9P0Rn7tf++4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUYdIqG4+qlbUhNoj6F6ruvDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTUxMDBmZC1mNzhkLTRiNzAtOGY0NC00NWU4N2NlMDFmOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIkzDDKgXo+Vk1ZyPlpLjZ+REieJ23t3csCMmvuccXHQh5\nUEYoiI2SmgZ7smjGqrIAVttWRerJk15btg9jxFGIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1p2FI8c9d9VCZrbqEAn+bSsk\nYBwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYV+OZ/FZWt6N37oQ5Jy6zjCrpluj/1hcRVMliqtJOJsCIQDYH7H+bZsm\nxrLGXBbCCLu+ODcaN7MSSa4A2E9axnphLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCzCCAbCgAwIBAgISAS0389/+vKfKbxO4TvQcDumHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTEzNzU4YWQtODY0Mi00NDc5LTliNGEtNmM5NGQ0MTU2ZDhiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTAzNjdhYjYtN2Y2NS00\nMGZiLTliYTAtODgxYTM3Y2Q1YWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nU6rmJ7DoKWIMGMYp4Y9grepGCpXk+fsylix1kCNzg6mkVux/3TGRDpo9a8ct0TN1\n2R7sXNnLaU9c2VdNuIN+b6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJv4EBGyQ7nyeLSVY\nofXjOqkQw70wCgYIKoZIzj0EAwIDSQAwRgIhAMdj7MUgYhtRTvwIOUBwzyOHCVXN\ns+dnU7IYI8wCsdICAiEA8erCoJDJ1wc/8/ysKL7t/iIz9YLLisY0hALWD7JXOVc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8098", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8098` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAdWubyVWhc332N32Q3kwcgamMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjZjdkNmQ3LTBiZjAtNDdmOC1hOTgzLTkzMzBkMDFjYTY1MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIzNTUwZmEtNDZi\nZC00ZGFlLWJkNjYtZjY5MmJmNWUxNjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOwB3Ntc0I7WJvsB5ivde9GOHJj8Xuq8mwyu8wAmwuWIKjmELANMXdglojNIJ\ny6YtjAk1tr06xvLQc+K9BxTkmqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCgqk5Ja8s6rxrdMXBSpBS6IwLeowHwYDVR0j\nBBgwFoAU3ne3fYU0d/XkF1m+AXvoAuJolGowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDcjDHsQ7Uy\nKUXDoBg7lSrvFrT1mvD+U+MnQtmC70P1RQIhAPcm7aENncfHlB6+R/IbZ+mFZYtw\nm23BnJ1YKdt1JNDm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT3BJ1j0D5Ng+3HASx7w+iNKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2Y3ZDZkNy0wYmYwLTQ3ZjgtYTk4My05MzMwZDAxY2E2NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBW51QDPbUBGF/KijVusfhXyTW6Q2DeyDxcD6mSVfMr59k\n+wCuLKaQS4jBMbuH+NsQToVDSBDJCY+9UkBzOo/7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ne3fYU0d/XkF1m+AXvoAuJo\nlGowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGh19Ulty40ICpRXBwvU2eEVNciixHWBQMzRfKCCr3+ECIQDkhYsVZwsk\ngcw5YNLm2Xf/Dnd9a0Hc85xzMwWUCd7XqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAa/E4xWUDz7iowRLns/wewgVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIzNTUwZmEtNDZiZC00ZGFlLWJkNjYtZjY5MmJmNWUxNjg2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmQxMjc3MzUtNzE3Ni00\nZDQ2LTgzODUtZjM2N2IyMThmNjgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmSyOWJ3UEWWEV+0b4I1FTXMIsA2Rj4lelYTLP3ldeiZRasqh7R43+u/NxOb4fbwV\nwa3oUqlHt/A9xpJwgclwAKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCgqk5Ja8s6rxrdMX\nBSpBS6IwLeowCgYIKoZIzj0EAwIDSAAwRQIgSEbVKguSJThLmofx0r4mvK409muk\nldIlHceUykW2qNUCIQDA2iK5pushmdfinz5G8+Ui2ha7ZtJNCjOB8/fqUP4xdg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8099", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8099` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAcwZPlo4s2f3HvPALGM7msUcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmNzI4YmJkLTk2OTMtNDEzNS05NjhhLTUzYzhiZDZmMjA3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY1MzEyYTgtYTVm\nNi00NjM0LWEyNTktNTk4OWRmMGMwZGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUppi8C859bqw/ZyxJhqZF6eFBMcDQdFbwyl0sXLlzaJ2iwnqaO4c8EqSv1X6\nPlvgzlySrEd3g5UAClPTgwnAb6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTvW2N8e2AggjJaNxcCm7zpMBU28wHwYDVR0j\nBBgwFoAUVPrPRoN8Qrn+An4RsxxAUyMmszgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALCJeyFPX1DbAC7vWMnJ5TOskwxvIvrOfzF/dp/3MkBaAiEAgI0wN8Yf\npD4y5/JrBeZ5JCcuyvQHTDVKxp8HMc/h/w8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe62A+J6FhInfUGV/f3SfuAEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjcyOGJiZC05NjkzLTQxMzUtOTY4YS01M2M4YmQ2ZjIwNzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlFE81nRXfyUV1SW2iOeOgYwVHJkNhG95H5aOgXg3Og/qj\n3DHv1l8YRVkiiP89RRPM/BnC9X6tfRfmEM4vUV4So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVPrPRoN8Qrn+An4RsxxAUyMm\nszgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJAqu+DIMUDq71Yura7MilbQH+EFhUR/lX5hoYBV++QUAiBc98cB4GHJ\nw9ERpjPnzpnBTQgggNLoe6LQ3ZDuVHVSwQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAQ8KWfCLEFXEJbt7O0trwOVsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY1MzEyYTgtYTVmNi00NjM0LWEyNTktNTk4OWRmMGMwZGUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDc3Yzk5OGUtYmQ0Yy00\nNWMxLWI4M2MtMTgzMzA3MjU3MDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPYr2Rxdmi08lvYM856ywgQixJe9KprTBuNnWZk6KOYKluL7vmRFrFwgmpDa6fUIi\n3mWCzed/1K3S22S0NIUTgKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTvW2N8e2AggjJaNx\ncCm7zpMBU28wCgYIKoZIzj0EAwIDRwAwRAIgBhBGZs16tQWnjrMPup9yMSiNfHb3\nRIHUpzRruoyHUnMCIHg/LP2814fCBRYf/0GdUbJk8yPMRivbQy0aE92/8DgN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8100", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8100` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAQk7FEq5ZaAkDNnf5zbx7zrfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3MjhlOTEzLTA2ZTMtNGM2Yi04OTFjLWNlMzQ3MGIyNjlkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODhjMzNkN2QtY2Vk\nNi00NDNiLTk0Y2MtMzQwMWViYjk1MDFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL230aJ+v5+HoOv32GwgxIGb66v1exWdvzqm6cZAlBvktKQEmet0EOACu3LLu\nsaY+klGUvPIpXJCm7/GjR/O5TKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0PK6+BPd1vuy+v07T6aV+k1NJo8wHwYDVR0j\nBBgwFoAURyPAVRnFBZDILgc9PFEJ/r+fSZMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAIotSDaiVBlvC9rsW/N1ca6GjabtgIpTOjQ64iGmANI0AiBjmNijtmqw\n3X1OSxKJArUp2TT7fw5s7iQ2oVP3k8/tCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXct5/DhbxtLJxC2/n+OYMb2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzI4ZTkxMy0wNmUzLTRjNmItODkxYy1jZTM0NzBiMjY5ZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpVd6E9JRW7embK3zJbLJCTDUv9FWTu92AfnX4382YpcHQ\nttWsda+CMqHU/zVeC3u/qw8RhuQrEW+gatnuMzHyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURyPAVRnFBZDILgc9PFEJ/r+f\nSZMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVvowwSiKT6OBzwh6eFyMzBOGD3XHlSRllXmveCgui3ECIQCY21w4F8X3\n+LqgG4X/3pYlqq4Mz/WVFW3lkVY1ZepMeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISAf2s0CWiZUByZKWw+/QJ/fZRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODhjMzNkN2QtY2VkNi00NDNiLTk0Y2MtMzQwMWViYjk1MDFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZThlZGQxYzEtNDBlOS00\nYWI1LWI3N2QtOTFhMjhlY2E1NTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njHyIGx4iSxdwUoAFJUyCoAd6b+NcFKs4/0JVAfJ0vsYr6Pfjj4jiiEdstrsJCIDy\nKlGSM4jI3HCndIxWrNkGZ6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0PK6+BPd1vuy+v07\nT6aV+k1NJo8wCgYIKoZIzj0EAwIDRwAwRAIgANW/QY/FmMKr8mU0JL/CrPACX+x4\nEhYhwt8jLEbKocwCID48pZWQS8apiqnP5JJLTqkcK6p29EPSvxsbGu53U1yn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8101", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8101` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAdPnH6OZoYzF+TuNcIhdal36MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhMGEwYWZjLTAzZTQtNDMzNy05ZTM4LWYxOGMyZjQwMDIzODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI0ZjQwNzktZjcx\nZi00YjYzLWE2NDYtYmMzZjFiYzg2ZTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9/rxn/WBxUZO4QaYyoS9g96OitZfxis86PSJluqKpdGEhF6eK9MUeyKQ8T7A\naXkAsZiqk5JdaPhDeIzI6VnjUqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcFdqvOdx4ILzw6E22EGPDKhE44YwHwYDVR0j\nBBgwFoAUnm+5mLGFdSOTTTx6xFpr0/XHBywwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQC/nMsA+vFEhW8UGjNPGf9uYvTBPSG3PwQpPcAKuvAwNQIhALsqmwJy\nJZdDlAOuXr3n+0xQ3Cf5Sv5u6U+x7FuvXvvH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVqm3r6I+JZR2Yvj8iqYchvWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTBhMGFmYy0wM2U0LTQzMzctOWUzOC1mMThjMmY0MDAyMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARN5YPF44SRxhCayp4cyAqy20C3kVD9iDstlEv2RQVW/YoP\nZxjjKPxp5A4QV5njcDEl7iacutMa7wJNI5RZZoRvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnm+5mLGFdSOTTTx6xFpr0/XH\nBywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeKC9/RftYamZQQDT1BssA5lyaoLbTNMYcp1wPhSPFfICIBb4e05EbBZI\n8lxNxgQLTkcbO4oP1m7lgSg4GUlOP0Da\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCTCCAbCgAwIBAgISATJnK00/IZ8kdZyRx87447MLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI0ZjQwNzktZjcxZi00YjYzLWE2NDYtYmMzZjFiYzg2ZTI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWFjM2Q2N2UtYmVjYi00\nNGEwLTlmMTYtNGY2M2U1NGRkOTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYZdJaxIQ96b40x477K3jLNn8icy2ap6+w6Vu0QkDiBL++TVUrN9CTpDCSMMnidQ0\nE8BcO3/UDa1+SrLVZedFvKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcFdqvOdx4ILzw6E2\n2EGPDKhE44YwCgYIKoZIzj0EAwIDRwAwRAIgIrmPT8XQvcCgmcvDx5jwdQZwQl99\nyzL7uItJ2fULxr8CIFqR+1T1lQ54ye1f1BcEeNfJ4dCRElOyTDV6NV7W9b0S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8102", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8102` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAX/72R+oFP4+t3hnoA1WpuCZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkNDJkY2ZmLWI0Y2MtNDM3NS1iMmY4LTEzZmQwNGQ5NzhhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUyZjNmOTMtY2M2\nOC00OWVmLThkZTItMGM3ODk1Njg4NDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETmMkbAlE6ctrn9tFjGDP4NDOvi7yYwLTkpJo0xELgkbtn8JOkamea40/cg5W\npJruw/IrhICNGb10ecEzoI0KcqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrx+DHjLQkme86wb7fK+29GP/FO4wHwYDVR0j\nBBgwFoAUyJGa3+PfL1ZkJheClhdysj5JJ3AwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCZBxemWYAMzF8cIHmFfJiSNG618o5k5z9r7Odi\nA282AgIgYlP+g4qbzKmoiaznugXl0yh9S+R6jvQ6I1ChCH7l6tM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASIWIT1qyE1zj0r1ym2GWtT4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDQyZGNmZi1iNGNjLTQzNzUtYjJmOC0xM2ZkMDRkOTc4YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARf1583TrCKIlqN77c9Ovr07L0t2BCoiUBshV4wLiEsPVQa\nlkWqzMM6F2DvOL/AahcBJ3QeiRsQTTVExK6Z+Li5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyJGa3+PfL1ZkJheClhdysj5J\nJ3AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMayiU16Fk88WtE7JWUL6n1Y2dzZuwXOYukyKt5xyunfAiA2u9j1dzK0\n8r2p6iuRD2mD5y4eLEi5wz4iHtA35+NCig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAeRapsmyBHdqi3VJ+CnxJCGcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUyZjNmOTMtY2M2OC00OWVmLThkZTItMGM3ODk1Njg4NDg5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDlkYThlZDQtZGRjZS00\nOWVhLWFmNDYtN2YyMmI4YzdlN2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRN3rPUP7y8dxI8kAlAscT+gErq9O08MMJ2y+XkVh2cfYB7ti9MCOKoB3f90Xoh1d\n+V6IRlYWKu36kNkJgAKK8aNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrx+DHjLQkme86wb7\nfK+29GP/FO4wCgYIKoZIzj0EAwIDSAAwRQIgP+FPpkfeXwiGNReVTL1EJdetvYaS\nXz/XYql/n/NZv0ACIQCrQwgQIUTOMkFow2680OFPeW+RMvXfRUJHuoHnPdSQ+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8103", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8103` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVw7BpiarggK7ljmr9ILCbb/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlN2Q0ZjI1LTM2YjQtNDAyNy1iOGNhLWYwNzQzYjI0YzQ5ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDVlZjg3YmUtYjMy\nYy00OWQ3LWFhMGUtYjhjNjVhNDkxZDlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvXBn02pMsUtxZNU8nysBSkWObIcFAgX1Al84lF88F5QJ3K/THhtd13i9obvJ\nmggKnutIhFQIwCfKaNK9MmhokKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpq9LbB9gsztSGKes88sOQjuCliwwHwYDVR0j\nBBgwFoAUJdPkHUTNjlNIP+uCXXk8w8Ah0d4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQDaR7uzwn5LEbYE1Uy0X4xYT76Rk8b1jUkUROvy\nOI/YTgIgFfm8Aczt9aTl3khn4ng9RXNlmLPsQQL0cScfyB74wgg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXg65/lAM1322joj1ALLAHbyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTdkNGYyNS0zNmI0LTQwMjctYjhjYS1mMDc0M2IyNGM0OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGpMce5tuMbTwTDEOS+wF2GJn2aaqJaQMdrS3rWTyUCHX5\nGO7HL+iSKMvxYu84ywiA8nkSR6fj+5WQvD5ARJrDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJdPkHUTNjlNIP+uCXXk8w8Ah\n0d4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPldaBMG5qgNxyOoP+NzbxRVU9tJti2bu7f75VUoT83kAiEArxHMqRCO\nfr6G9nyQGnxy7RCPN7amW27jZX3PWDB7LbI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAWqgTK1DCpjL/QWkxYWtm2XWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDVlZjg3YmUtYjMyYy00OWQ3LWFhMGUtYjhjNjVhNDkxZDlmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDVlNWVhYWItZGEwNi00\nOTAxLWE0MmUtMzc2ZTNhNzUyYTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niHwNKgUOICoxM+DDdSTTwJC3gHsMOC5KdX5WJGTqMx96WjVcukBVLNSlQz+wNHny\npgOE5xIdk5SQQRYUUr6EFqNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpq9LbB9gsztSGKes\n88sOQjuCliwwCgYIKoZIzj0EAwIDSAAwRQIgbdMMyT4jwmohotPP70/+nbAQty7S\nfaz96qxRrRcpyVECIQCPbKqfuqQhu3o966Nw/iDSzlm3lh7UI1HP+0RoRL0uWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8104", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8104` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAY4W8aNxvW3e0CvBeD3pGdCfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzZGU5ZTAxLTBlMjYtNDQ1OC1iZGE5LTBjNjQxNTFlNTllMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODFmMGQyYTEtNmUw\nNS00ZjYzLThhZTItZWU5YWM5YmU5Njc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDYvoK+rUlT3HwX2EG6ftWJAogDj6B/MVyhdoJs5f26KF+GGYlBI4DAwSfDPR\nONyPNhHUDYc9T+xigNvItakPG6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZS2B/GgOdaavbXkT0mmvdSpkDvIwHwYDVR0j\nBBgwFoAU8NcisddkP/+3IfizOiIVR6JW7nswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCXLflQEpIjqbA/gjKDg+tWRdsaNMuTCwCFWazmWnG9lgIh\nANeJtFh52JiKFCepv2QACwHxYs0q/79BBoecnhlkqsi9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAemv6cFWioOnJtdbCGHy3G+pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2RlOWUwMS0wZTI2LTQ0NTgtYmRhOS0wYzY0MTUxZTU5ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQb9eHhto+drBeF2gpNYfknWV9ncP/KMQPerU8pUlTdzKph\nTY8AgcrHYS6tRAKWSH6OJ6utWk4Qpx6Y6I9Z9rGbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8NcisddkP/+3IfizOiIVR6JW\n7nswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALVibXLyJDqLa/0v9Wr9n7X7LIFGlK590mYcNbM7kmI/AiBCw1rPaFbN\nm6dDjieu0LgHxuvP9MejfqQqph33SZxSsg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAczaZtEV+iiovV6Cc786ZRJ2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODFmMGQyYTEtNmUwNS00ZjYzLThhZTItZWU5YWM5YmU5Njc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGYwMGVhMzUtOGU4OC00\nNjYyLWIxYzUtMGJlYjhlN2RjMGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1WRIU7a8/x1EH977uOWtEFzhobyRBlbyLjQn5Vu4j9LIO6ZNrEkK8izWchl0na/p\nrDkhzNW0usON8D/piCQoiaNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZS2B/GgOdaavbXkT\n0mmvdSpkDvIwCgYIKoZIzj0EAwIDSAAwRQIgQlbUEdsCiPMFRJXxI6mKvXIn3Wdj\nDWAZnGLZ6vMHigcCIQCeiz1Wz0gsiC7qMY6TxTG6SCxwe1AYa9qCuE7/9efbQw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8105", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8105` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATklpEWBQUBhzWAbaX2u6qufMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzOTQ0YTY2LWZkNDgtNDBmNy1hZTYzLTRmMGRmMDYxMjVjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA5YTdhNTMtYmQ5\nYS00MjE3LTlmMzYtNzlmMzMwOTZhODNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBRmwH4Kj8Rd6HOgKSKm2eaqbPFvHOrMXqRHmwU30vcQOgGfAW+KC3wTczV5p\nfgkyrXmrlTkvzTDPeSk3cCf+UqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6SWUVZ7ItAa15slTp2YYrwKvOsYwHwYDVR0j\nBBgwFoAUrQooUY+pQ5vq/Hoa4G8TyZK+dl4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCwoPUG+QXh+0Xbn6ZjgJkVLtjuZkQd\n6ydKIsWECOUagAIgdokYAxPNErU+D2w45LGxLdP1NJ+dGpw8hsyXx97eXtU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU3CAj+nDpjt9eL3CBjHh+jAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzk0NGE2Ni1mZDQ4LTQwZjctYWU2My00ZjBkZjA2MTI1YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4bBx/y3wGpubJy6DotVDtmjiEJ2xlFUkB3dJEcKnOtY4o\nNrg1lTifTOCC+9u1MVo9Zogz7jYwir55DMcoVeNFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrQooUY+pQ5vq/Hoa4G8TyZK+\ndl4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEH8k4ZkoqN/o/Z1MN4CZ9Z+OGFSCUOfM57G8zE9lCxYCIHIcF0/lPND4\naC+JqP+z6Mk6EzwgJ3lgQCaV3SkWMeZq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISASWDNisRdQdpJR27YbrG8o2KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA5YTdhNTMtYmQ5YS00MjE3LTlmMzYtNzlmMzMwOTZhODNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODg4MTZlM2ItY2FiOC00\nZDg3LWJhNzAtNzU1NzkxNDlmOGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKUe2NCy4mg8fFUnbjGukj/1vbOdxbpgjYbBfCVkKe9pVMKvSqZBH9KFgHZFVQI+w\nPOh5eVo5C2DmpuYvfXdmk6NWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6SWUVZ7ItAa15slT\np2YYrwKvOsYwCgYIKoZIzj0EAwIDSAAwRQIhAOil/GLQcV+iL/CT5USnlqzYocPK\nXZ6tuoIQz2dtDBfcAiAa7a3+Slx+caLEU0lpl9WxR/9RwyjJnNiy0A9A+MuZEA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8106", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8106` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAYxZ4KVR845VdfFH7d3Vana7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0YzZlMmRmLTJkNTItNDFhMS05MzkzLWJkNGZmNDUyZDE4YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdlNWQ3NDQtN2E2\nYy00YTQwLTkwMzYtZWYxZjMwMTA5NTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3A7FyYFnSHfmSqo42USQ1UZMOcoa8FG4ncJn0se/1CPD52ZorXbaIsfOnn/K\n6JsluGWhExwNUEbJcgDTa1u71KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBI33ejsuU24iadl8HEjhbTp19kUwHwYDVR0j\nBBgwFoAU9zxgI8kiVJurzLBpXwTYYUbuqXcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDmhjwSfB6SOwvNO7ccIZCjm1Nbqvnq\nS+0fY1rkLD95awIhAM/byiQoGswGWkzVWfEYB9s4uCeUdvToWjEdjH8OspJF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZFhVbzTSZIkkbbRF9nRiVpVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGM2ZTJkZi0yZDUyLTQxYTEtOTM5My1iZDRmZjQ1MmQxOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxIjj+YdkbwO4cPt/Y1D2QDopx68/blOmtDqUxMXXpNe/Q\n/ojONc/hVCfP7fuwJrzjXN4pH7XQl9pfk3ZiJawno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9zxgI8kiVJurzLBpXwTYYUbu\nqXcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF9iw1aoEAoxtuiCSSuInEYnuGIEjALPe61BvJWx7HNsCIBVr6guRyYbf\njPi5WoDTzXZVjwkRclQqysb9AcDt8/PT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISATBSsUC3DOG67qBqlGErqGf6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdlNWQ3NDQtN2E2Yy00YTQwLTkwMzYtZWYxZjMwMTA5NTUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjdjODBjM2MtZTg5NC00\nZmE5LWE4NGItMDYxZWUyNjVjNjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n90BPfF6XWRU+OxapVgQHRgLwpMaTCrYhpo9d4eLtojyWHHzVjD4Xk7BHkUw4Qo5n\nmteAG8NEwnMcdprBYsWPYKNWMFQwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBI33ejsuU24iadl8\nHEjhbTp19kUwCgYIKoZIzj0EAwIDSAAwRQIhALIQYdwcVQoYxoTVLHBHZmBIfCjK\nRo5KuMQ6PZUcFa5oAiA+UENijcVHJ0NQrSThMPR0Y0J0deTeXT3rOD4F2C2Jiw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8107", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8107` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAV3TT9SeRZD0xopXSnqm+/OTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiODY2ZDlhLTJlNzItNDNkOC05N2Y0LWQyYjc0YTFlNTM1MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzUwMDQzOTItM2Iy\nMy00NTFkLWE4ZDQtNDQyNzg1YzA5YzNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE04Lp5H6+7efCL/EAtk8N/3mt1GzV6j+GRJzDvaSoROEUDevopiF8pnig2qaF\n8s74se+PS5lglodbM6cL37cnd6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFBMxXLEjukBfIkj7jLiCnNW6HOiMMB8GA1UdIwQY\nMBaAFMBYECTsMMIWk9bPWuGNvt9kwyv6MAoGCCqGSM49BAMCA0cAMEQCIDx7ZCUc\nM5XMPmOapXhKEVPAqStYdRuvB5cOEpGw3jYEAiBmjTtS7Smyzt545D1rKE6J3U3P\nGa4xIWhiuybi4+0thQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe9WD81FVLDmP0ja23rlimTBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYjg2NmQ5YS0yZTcyLTQzZDgtOTdmNC1kMmI3NGExZTUzNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWR+BTx57JBMuusT4bHzD5tM4dgRDYUlIpT7dWWmFAUs3h\n6Si98a1kUKYPuWq1FbWOhuLtj5otYkC6VoF8Ytmko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwFgQJOwwwhaT1s9a4Y2+32TD\nK/owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOpDkEEZ20VaIVQOWzokpyqy06bd1u8zpchKNhEIwPGZAiAwnJUxY3TG\nhFxvV9ZIWmrcD3OHwwh/SSjbgohltzPoSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAR3CF5N+ueL18IrDGaYigDP7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzUwMDQzOTItM2IyMy00NTFkLWE4ZDQtNDQyNzg1YzA5YzNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzllZWQ4ZGItNWY5ZS00\nOTQwLTkwMjMtY2QxMWJkODM3NDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZbfedyKDY4FcJqmg1DdqVmxrQ8Q3LLvDmWkPSvGKIYKEokkphpf+eKkAl2VuJjlx\n3wNf0WyaBIgPcwuGp+3NQqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEzFcsSO6QF8iSPuM\nuIKc1boc6IwwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA8Cm0Z\n7J9Q+w2fj9/oOuUWufnN+UZnYuyO+t7qb1qjigIgHEfNjcVGOz7B2xKj1JarKNwm\nDqOPzhKuwzrzCDIYXNI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8108", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8108` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAYW98wiL0jzIr1IB2+uW6TYlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhYzhlMjU5LWIxYTgtNDZjYS05ODI4LWY1OTliNjQyOGIwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmIzZWY4MTktYzQ0\nNS00MmViLTkxNTYtMDhjMGE0YTEwNGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpvz7wvfZEI2OZG053HCfpnmW8lfbyIgddM53MAIcxW8S4eXksToehz/feImx\n9aBPArYOyGihQB/685dyaospUKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDTyQgbZgmuCBf798K/OKk5ElYkqMB8GA1UdIwQY\nMBaAFEi1zyo1QzOFO5UmLughG82dZzghMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA43+Mxs8HKIZfSkJV9dduNYD9r7AayC7y\nm3UeSSo7yAECIQD6cL9xEX30XC0xUHWJcnMh77aCJCbc5VGr0oET9PO6gw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUWj6Y3buxsHOdJnvj31sGe0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWM4ZTI1OS1iMWE4LTQ2Y2EtOTgyOC1mNTk5YjY0MjhiMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkPW5RxAoAhurT2ZbaAJrjiTuUoAUieSK7VNWEy+pRVCSQ\ngZhab9ZJjIxcn9jjo3ClVQHpd/27UgmYDQE/+Wgao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSLXPKjVDM4U7lSYu6CEbzZ1n\nOCEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXYz3U7byWHWmM6hIYaO1Zkxzzlr0sdr7QBBPrRRjTVMCIQCIaDg0yuU2\n2XuocgHwPPRv5uf2OCuGTDPzA4TdmpqIcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAUSXs2G/c9vHYLvrVGkGNMExMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmIzZWY4MTktYzQ0NS00MmViLTkxNTYtMDhjMGE0YTEwNGFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzcxYzU1ZDEtZjI3MC00\nNDMzLWI4YzktZjAwZWVlODc1MmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ni8gXQErG0jlKwqQ/H6lsHX0uBQfzsN4GeHPRzwbrRPMeoM6+cReGzt7+yd1F6iH9\nkvfFi/662gssJX3cDSpihaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNPJCBtmCa4IF/v3w\nr84qTkSViSowDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBrM4Se\nlU1pDnX3ns74x+eHCBtzUEAgGYOlTD5jBDrDhAIgCOaiOF0CUsTRIOYtPpEBSCNF\n4CZKa21MPERmq3uALwo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8109", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8109` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAcQA3sKAlWZrTAbIlTGDxbLwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3ZTc2NThlLTVlYmEtNDdhNy1iYWJmLWJhYWNiY2FlYjhjYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFhZTJmYjUtMDcx\nMS00ZmM2LTliZWItMmJiZmZiZTA5Y2IwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWTlZzHSS8qEtgUALMiKgc271OnL+iZXyUUEWK5at0z1W68/4YfTz16jvEsza\nxjr2epRImkv2rwZQU5GLDzukb6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIew/FPRyVf3lY87Xhg2zsVfNmp1MB8GA1UdIwQY\nMBaAFHuaxhxk8ipfubQaPb10TKmjvSeVMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAEMODvA0fwfSnLrEzQ8DNwh4k6eNZc4p3W\n1wnMbMe3lwIgUeKDP/7i/ivG/5Gc4rTYrIuaSD3sHgPM42q+p1BPIIk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWp1V6aQfFGRUxocnYiaD5F0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2U3NjU4ZS01ZWJhLTQ3YTctYmFiZi1iYWFjYmNhZWI4Y2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASB4iui7ahxMLJapxm9/2gym1Reb6vubTLH+Nd9zsn7tn8v\ntbTPQEqSJUW33GacypJ63SO6p5uCj52r0W6UmGLDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe5rGHGTyKl+5tBo9vXRMqaO9\nJ5UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgL8uFWV+6exouglKCrbeyKnXDEcFUWnxJduiKQD7oLSoCIQD12/8bP56h\nxgSaLAL5Is6fot749H93Yd2XawHTlczU1w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAcc14/hiXXkW8AEdr2uqIJpCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFhZTJmYjUtMDcxMS00ZmM2LTliZWItMmJiZmZiZTA5Y2IwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTg3MDEwZWEtNTZkZi00\nZGNmLTk2N2YtMGZlMGE5OTY4MjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsI5WIJbXPZWjgraE5a/EYzBzRnEimXBq5JUXw8mR07jS8KFVOu7DssiXB7SnlIKL\nQRTPOPAo6MdWta/J4vqqzKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUh7D8U9HJV/eVjzte\nGDbOxV82anUwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA9L0F\nf8hvUtedDaOpd3m1lvJ9nwvEEC+7CZ5xSI1NgOACIEvYJUtCB125RMzzPYw000/U\nyCOXEnV9YwrDK02ImRtV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8110", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8110` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAfcXrnhqO+pNVbcBuF0cFYKIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZmM2YmUxLWQyM2EtNDBlNy1iMmYyLTJiMGU1ODkwMjNkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzE1NmI4OWQtN2Q1\nOS00MWYyLTg1ZDItZmVmN2Q4OGFjOWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER0cGXzp5ZLxdDch9xRotsijJFqtKCLsarc3DcAZ7rR1EhrqDA0HgXwD1G9LW\nN8rWbZZlJ+1EiHZSPP+YbQbaHaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ52zKyH+tC9aumt79D8wAzqhEJ2jAfBgNVHSME\nGDAWgBQc2cKxbfT+v5IqazJDG01lkZvJyjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICksXEsuvx7mNw9tfRisCv9ebSZcjjQR\n2iF55tIYtlA/AiBJJZrD/D7ur45+mlYAO1ikE1xjVGxi/V1EkW/i913f4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWSF2QczUTLqGh4Lbr9Kz46xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2ZjNmJlMS1kMjNhLTQwZTctYjJmMi0yYjBlNTg5MDIzZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARs25z+vPjrn+Yj1sVdjwYDzZV6zyhuvI3hFudkDrSbLJoI\ntXR25lKQmJiQTDz5ONj+hUqKuRMamOqCXYO/G6sLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHNnCsW30/r+SKmsyQxtNZZGb\nycowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANwrPCKSdpxBTf2sejeXhCivd92W4+s5xZGFUpNosaosAiBB+ESZXIrR\nG2NIudFBlev3wqJ60kq9UwKSvSegPRbPqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAecltFVYHuU0Hh/JbJ9ZL2j2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzE1NmI4OWQtN2Q1OS00MWYyLTg1ZDItZmVmN2Q4OGFjOWRjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGFkMDRhN2EtZmRhMS00\nZTE4LWE4NWQtNjE5NWYyMjYwZjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEjvxKQHGtBdLS/Yk508J8fE8WWVY1peIOArh/pWK0/+5gmzqUth5mMZ1vVngwd+/\nO0afIeGX/zQXBcM/A/fBPqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOdsysh/rQvWrpre/\nQ/MAM6oRCdowDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAnITA9\nsbrGOxw2gqjeyW6vQ1PXkJhoGtJ0AAOg1F+JzQIhALiBzh63zVEQ1OzbDaYoNvjm\nmjGsQQwj+pzvwLrxAMY/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8111", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8111` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAZ+FDV83/uQpxcR+/xoJRvMXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzZGIwMzRhLTBlZTUtNDIxNi1hMWIzLTI2N2ExNmExNDdhMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBkNjE3MDMtNDhl\nZi00MmEyLWEzMzEtNzgyODdmZDNhZjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY6adY8/Q16sCEjH7+5EyHRm0e9FoP5O1k7TqB5CGDjfjyS3JqPcbmCazwM5w\ng7IOqwN87tOoy9W+abxAGVIXcqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqOZGLaQBnmyNdnhSA0hPsWNH0V8wHwYDVR0j\nBBgwFoAUS1K1bovcvDe1+gYnO1q/hpYaBR8wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA77fb/ourQxz8\nuwkiVw7yVaY3qPJ3QFo6XT0c3+QHN2YCIQCGh4qWCFhhKbDuhQsDDNX74KrAWDAZ\nHQzN6NjxSwBbkw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV6I4OnIq9oL+oUJcpyt4DTuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2RiMDM0YS0wZWU1LTQyMTYtYTFiMy0yNjdhMTZhMTQ3YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxvzM1dFllAc9u6hKCCzGX/fV2oyd8VkW0FPyj8W4d+TGI\nUwgs3WoZCBTKdy1HNUh/RtkQ62Z8bCGS3/KMUDsWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS1K1bovcvDe1+gYnO1q/hpYa\nBR8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU4rWK0icZyfTjlyPg7m5+0XE3POZXZtGdQHHPxpf3f8CIEHMw0ANWnBk\nibeAnSkbclXLAZ9RibJNcIWYlsLB1M40\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISASGGI899OYcRaH0web9QiM7WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBkNjE3MDMtNDhlZi00MmEyLWEzMzEtNzgyODdmZDNhZjFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTcyMmEwODYtNmViZi00\nNzllLTlkZjMtMjAwZWExODg4MTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nko2AJ809Zq0FfjCI79Ih2mzn7gcr0rogTVjwSsgAnjkQnkyBXDcAgYWaloFGjMmy\nvcrWmrvomvKr/Y6Ucb6xQKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqOZGLaQBnmyNdnhS\nA0hPsWNH0V8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBKcQAY\nP3lP+kQRa+DUN+fuZlf2/Y7FrmVl6d8P7loTHgIgTmMftzWZpMBDC57G7l9m7MRP\nCuHH9KOidQuq03C+KSI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8112", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8112` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATHss88iiLktKep3O7hVgMaLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1NmRkMWVjLTAzNGUtNGM2MC1iMmJiLTJjMDczZWQwM2ViOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTFlMzQ5Y2UtYzVk\nMC00ZmYyLTgwNTYtYjQ2ZDJlOGNkNzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0k4gl1y3dzaAUInQR3yqtAmmEO5bk7JSv4+VoFlFI3NDpqoPGuvP55a4yY3s\nS3kG4iZahQ5NC1qE3YUIMPisX6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP6F+eAaJpsoVjjQeJjEel9yQQ2gwHwYDVR0j\nBBgwFoAU+l7UBw4eFiWeEwDFWGtlsbyTOU0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBXrgmHnAhynjVm\nSLeaPHJoSf63HnWA810qOc0/WS0DqQIhAPltxSF4ucBBBrm11LCF+kxhbZPf8VrJ\n6MBuJdmqLVLw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVZhb4FRaWyy8F6IpCcJ7W7QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTZkZDFlYy0wMzRlLTRjNjAtYjJiYi0yYzA3M2VkMDNlYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPM3Uj42BfjqjZP3DyYSrJhMx7W4WpmMNk1vLDruBPw4kD\nq1kWWoRKU8rjliBnF8+uWX/fh1Gsl0ap2nQuGpLTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+l7UBw4eFiWeEwDFWGtlsbyT\nOU0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbBbUlcM7XVpaYtpEO8HGJspUpQ+TruDGYTl+DNMeqtMCICVy7q1EeeuC\nIAy04kPifcxczWmQWoGY8SYhzNbW5v7V\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAcR5kvefwXY060dzWtIcrgNlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTFlMzQ5Y2UtYzVkMC00ZmYyLTgwNTYtYjQ2ZDJlOGNkNzg4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjViNWNhOWMtMjEwMC00\nOTUwLTgzZTAtMTNhOWRjZDIxODNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVauFBbWmXZCGrX1Ms5F8Aey6FICDLJ8DUIie8QFtIYlOhm9ucJnRoLxn3lmcDTZk\nV68kaTgeJ3JnGKYwDVxdpaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUP6F+eAaJpsoVjjQe\nJjEel9yQQ2gwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA8q04\nmybXHnvufDN2qM9bJv/cMkoSpE4dG9ZfsAT9wsUCIQDqOduamjNZEIfMOwa2amEi\nUwm6ry6LotDSy/o7Bz2q4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8113", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8113` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAYXYQWKn9k8UFO9cjUWZ4L7eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMGU5NTE4LWJlNmMtNDcwNS05NzkzLTEzNGMzNmYzNTM5ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE4NzQ3MmYtN2Yy\nOS00MzkzLTlkNjktZWU3NDAyNjg2NjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER1NwczK85AOFwiRIgdctooJ8LPcP2dpMcBxmXSY+NMg1BVbnk/ZNQlpNIYzU\n9gDRF5zO8WK5gQDQ373RzOw/R6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI+M/KB27dJ2IA+OVN5FZpinCHPowHwYDVR0j\nBBgwFoAURhgTU6mjRlOnrEAa6TV9TF7yAkIwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA/ZQckZd0qeds0XXLfWoc\nbAuudvgOW5JwxFv1JMGdV4gCIEmiL7SRWPW13e3q0cQshcZShtrjnplUk/W/0Uuc\nNEo9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUDC1DzKdGb2LF3vWML6+mRUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDBlOTUxOC1iZTZjLTQ3MDUtOTc5My0xMzRjMzZmMzUzOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGQqsbyvdz3zg/q3BgIECCLCCh9UFgV1QZbd6/UGAK+PfK\naqyvLJfaQ42NULuhGbH3fXYdLieeIPJO1hz0hn/Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURhgTU6mjRlOnrEAa6TV9TF7y\nAkIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK26oSd8b+XziRKoLsdan4Z6XegS5YQKLZ7KIjCkBGGaAiEA4VTrV3nc\nDpclxBfminV9xKIoIzp8kXOG3W3rshWAmk0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAaQpbu+Du37rV0SHtfZYClaNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE4NzQ3MmYtN2YyOS00MzkzLTlkNjktZWU3NDAyNjg2NjI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTRhNmFkYmItOTNiOS00\nYTM4LTkxY2QtNWIzYzMwM2EwMTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFDeNV1nV3Otkkhlvl1XBoQcc9b2lMI0n48Z7oPR198sUGZbzhGrwBD7idtPOad52\n4UidZB11AODqvlaGU/YDDKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUI+M/KB27dJ2IA+OV\nN5FZpinCHPowDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA4aWH\ny3Lt4SWjmdCvlC2XN0gt6+AsLK7UV3i68jfDTuACIQCEHcRSU5senybrIUYrCiAJ\nUbRYFoAtVsXUuKThwQpHMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8114", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8114` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAXI7G+bYf5BYk447eVtd4a3PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjODBjNjljLTAwNmUtNGE5Ny05NTZjLTMxODY2MDdlNTMwNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdhYWY3NTgtOWEw\nMC00YmU5LThmNTItYTVjNzk1ZTNmODk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESDhLW4+yWRlZM/xGd2zL0JAKj1ykpewD9Qsvv67HWhMW1sziHME+hF6Fgkbe\nkhyq+6Y7WxG/zMnzer/lcswYmKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHbXIt9PS37A+xve0iaqEWDEy2DcwHwYDVR0j\nBBgwFoAUEUOAqjN5e/jo/1xlulh2fL8H5jkwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA8yc7\nyUT9NvU7WNYUqw7s0X8jDlqf9BzethytWpkaY0cCIQCq4h/s34slp12UetbJcRZ5\nWfYrps1o5h6H3L3YYhTnNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXyu7DaQrc1yvNX6ORptbvSXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzgwYzY5Yy0wMDZlLTRhOTctOTU2Yy0zMTg2NjA3ZTUzMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATisFqqfnpOHFzsk4hiRysfjEZ8SxmTGN8yxeF19Lt4fJ85\nGQg6N2u3vWVTOphAlX5ghxiAYi6g3Iq+8cZ2ssy9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEUOAqjN5e/jo/1xlulh2fL8H\n5jkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIzHpS2vGNz3i8/BFeSSC04PDUPR8t4vc+AJQVJFAt6mAiBR+PuHPwR4\n7yAKZiXjLo00l0+bTfbL3fpkuNG139rIzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAb8+0Gkg4WzsRlYBzArHpQ/YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdhYWY3NTgtOWEwMC00YmU5LThmNTItYTVjNzk1ZTNmODk1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2MzYjU1NDYtZmRhZS00\nNzBiLTlmMjgtYTgyMmJmMjZmYTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOUtznTmL1kVYP2fAy3FIoUO0Sojm1IErs5Btp8TWfvs7GjhE/BaxH/xYsTPkBxLK\nyXfVQvMRL4Z4GtLmwV4A3aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHbXIt9PS37A+xve0\niaqEWDEy2DcwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB3IduB\nIfIQq0LHhGW9RIgCotKdcP++7G0k3uXBMqXztQIgF4qnvLeAQjRq2TMJGhZiwiFB\ngXItScnuJXkJwK/EzUw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8115", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8115` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAVpeVoLuL3sfnWdawq9EDeziMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhZDI2ODg5LTljMDItNGQ1ZS1iMmE1LTA0Yjk0MDFlNmU3YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNjOTkwZTgtMzkz\nYy00YWVmLThmYzktNWMzZjZhNTg2ZGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8O78Qkm8FNcIyxKzmo1isafZm4l4BbFBo/VMxi/LB5kbaCLqJ8lbRQM7SzeL\n1Wh3thrnwFhIdAI58hghLkWhbqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG91lGxKtTXOY5jjtLwkV+4S6oNQwHwYDVR0j\nBBgwFoAUf1HxaWomtd2nottBUjnkVqW47JEwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA4wCv7\na7fUOucBXqlMWaT7AlkG0h4XsQEH452sEMeITQIgKs/BMgtBFFsVzfVDzUzldSdr\npUFyLv4pcBL5kPO1qBQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfa3Wnok5I5cgtsa/aFwHx9nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWQyNjg4OS05YzAyLTRkNWUtYjJhNS0wNGI5NDAxZTZlN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcVIEHkooZqh5cdtlzKggoJsMQbDyDC42JllZ09qeaF3qd\nXS8kVCuO6LXzCMDdav6rHHwCecyzwaKRVDgmNSWZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf1HxaWomtd2nottBUjnkVqW4\n7JEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB9u09XFL32epm+vyoTkcVIWg4b7gSZVTrTnYQXfGz0ICIFeME6uv5Ck/\ndyeRBSvVXQb5FoP/7AhKnhuJ/JNAROV7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAcXHFWY4Laj1JkFd7nHkdHNNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNjOTkwZTgtMzkzYy00YWVmLThmYzktNWMzZjZhNTg2ZGZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGVkMjhlN2EtOGZmMy00\nODYxLTkwOWUtNWU2ZDc2OGIyZDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndqgfLFY3FKISwAXwECYFACtV5QNyBLH9OITm2TH/i4FinYpEAquk3X/I6R3b2zk3\nv52Ta2nR+B6c35LQQS3R9qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUG91lGxKtTXOY5jjt\nLwkV+4S6oNQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBUhe7+\nsioDoOF275VpEsCgsUBpWMZiIoWwJ0HBBHVULgIhAPG9SxCFvPOWEn9m+s4oatLo\nUDjP+3YGaCEnQQD5oTFU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8116", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8116` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaPpqt5POw/Bv1h6CBjHItrnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1ZjE0MTUzLWM2MWItNDJhMi04NTY1LWRlMDk5YTI3Y2UyZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNmYjE1ZTYtZDU2\nOS00ZWJlLTlkMWEtZjk3OGY1ZDdjZTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhGKfu9UKybMoboHrIhuzQxVpD6IxG/3W1809+6hRXJUB71ryJFc9kdBs1k+I\nLSPInEli/KtpUQgJ5D+82mH1FaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEItvzrTwpo2O5sF/NQ+uUzP6tbHMB8GA1UdIwQY\nMBaAFLsWMtuaZAlVKnfxxDvXLMbZB6FSMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA87RlOhHolhKjyr6sOhIwZh0cNyOtOFLL\n7sd18IT1UiACIDxQTw9pYYZiy+JT71nNGhJQjuD71Y2ZsWygY6AG6J+h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWn9NNaymaFHBPkMwx8uEVAFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWYxNDE1My1jNjFiLTQyYTItODU2NS1kZTA5OWEyN2NlMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqHOYNQ1F5D9TxGzzj92FlfyY09g2VAkNmIX3Jf8RiHqmG\ncx7lqnnQlxmzuPoPl/sxUGh2HkUvsVGb/vFErISpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuxYy25pkCVUqd/HEO9csxtkH\noVIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPq4AD2jGUQwy+v5ogo12eXk2mpFty1XGEWQhEEUNwLPAiBDTh0IRatX\nIBko+1tFUQxfSNBRsPRQpNmtgSnrJvDvOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAcn1Vvi1szc5ZyPD6cP1p9FGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNmYjE1ZTYtZDU2OS00ZWJlLTlkMWEtZjk3OGY1ZDdjZTNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTA2ZDI2ZjItZGFlMy00\nOGY0LWE4ZWYtYzFmN2Y1NWVmMzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYFt0IeOzNloZ4Znq188dgTs9gTGibTXfOeRDNp+wv4wx3Ak3R8ORWA88NF/fn9Ty\nTiIfCItSAc0MvXWCgxENvqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUQi2/OtPCmjY7mwX8\n1D65TM/q1scwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAl7Pq\nCcp1ZuVmEsR01kBDteM6HTDMoMWyfJA0HZx6Pt0CIQCx3A7FElNT0nm2VpJ6GVM1\n2NJ7jQ52u7pp46WJc4c5og==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8117", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8117` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARxWyCOjVMwfxIk94BwS0bFLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlOWM4ZGJiLTUyMTgtNDAyNy1hYzM0LWM5MDFlZjJjN2FkYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJmZDlmNGUtMDk1\nNC00NTFiLWE4NjEtMDg2YWRhYmRhOTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAL1aNUHsR8JyqvKQYBZZCRaDSgU+Y+6fYbyRf94Cu++jxoNwQLyClKU6tnGP\nLrHlbQ/LZm5ilLCXsY/VMh8rnaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnA6xD98qNvDJZPURahmHeGkZ66UwHwYDVR0j\nBBgwFoAUlKa9VEeMdjWKY5JvunLDVs7tGx8wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKUaHGZSUUi21\nJ3VTFDGHr9MiDL6YGzhn4/RbYBajyGMCIQDc6HrAvC5vKdBk+EqeTgIgHFQdABpP\nrMcr4LbyUCP6TQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVTT70PzeXmxaldgJSNwzdsnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTljOGRiYi01MjE4LTQwMjctYWMzNC1jOTAxZWYyYzdhZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgEahCn5VzgsO5zz9VQ5nN8hkAuFrHNFhHpHxBAqoWoylU\nWiTMrYPHMzsen884jJKPPI2GcpXfSnxCqzhBP2wLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlKa9VEeMdjWKY5JvunLDVs7t\nGx8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKZ6gueycEMvM1+u8lTDx7+JTb8aoGUdRx1z64jF5oOoAiEA//E0ciwD\nRS/QbQsAz4RiKcpMqnoMFad+vRtvMlLwVCc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAWYnCl6QI8YFqCX+/wrqw3WJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJmZDlmNGUtMDk1NC00NTFiLWE4NjEtMDg2YWRhYmRhOTA3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTQ4YWVlZjItMWI5MS00\nZmRmLWI1NmMtZDY2NjI4YThiZGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nl7uBl8h0SdjSDH/tV0NCrH+i7ACFIPj515yTuLykqCFS0Ac83j0bHi2bntm6dSQt\n2+Qj1BvpjrZXbfOchnyCwaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnA6xD98qNvDJZPUR\nahmHeGkZ66UwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA2TE3\nvUBIT9OvWk/xgrKBnWldAVx67sZEDrPVw3Oed/ECIQDwnTvesISheTApLDmaBCR1\nAE+7c5f1HnH3Ezik10EeFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8118", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8118` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARgYKkbN4iW0sa06Q0SoI2c+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxNWZlZWEyLTgzMzEtNGI4OS1iOTQ1LTA1ZGEzNzJlY2Y2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBkYjM5ZGQtNDg1\nMi00NWJkLTg2N2ItNmM2OWRkYjc5ODkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWzBels1JXZEZFc4A8VcodRqTKnJniCQGCJrOit89Ou2sQ/4bHDKglXJz4QR3\nDoS/X6eQLzxfHMUv03dk6KCfQaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUykMUt4iExn3y2isrN5/Flb32ioIwHwYDVR0j\nBBgwFoAUPXPvb9Z0+NK3ep+Xb1Qx3DbefzswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPIXbqFZt5MW\nLfUgTyXH0EmAnMYu9mpZqVgk5MMV9rmvAiATG8P1/liw/sULtz/2jmO6v25vimw+\n6m7H2V1sALSNTw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS/q74y3LiVdYDn/66V39EKNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTVmZWVhMi04MzMxLTRiODktYjk0NS0wNWRhMzcyZWNmNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTjU845OXix86/KWR0UNero0mgnuw3eeart6D6VPefFO27\nzm+5e+QPpgCcfGgzfagMHqrSRXUBJHREaYdp/D48o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPXPvb9Z0+NK3ep+Xb1Qx3Dbe\nfzswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKCnGp7MX4IPiEgseDNCw431g14ZRm3dEtz4k1inZpC6AiAYZxDZFmvP\n7ZiYvnuUhWePqs4mtHgUwaZWhRyfG5tTog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAaMAtvCndK70G4ZwCc7BASF7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBkYjM5ZGQtNDg1Mi00NWJkLTg2N2ItNmM2OWRkYjc5ODkyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWUwMmQ1MmUtMzA1OS00\nODIwLWFhNzctNzZiMDBlMGQ5YThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nchLB1LJS9Y8xdOWmC1EYmhqENlaNyREcb58nUGSw7iIcVsW36+D+75AoLmNWKxeK\n9R8mk6zSwjBvCdZil7B6/aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUykMUt4iExn3y2isr\nN5/Flb32ioIwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA8w2c\nIvFVTiaDZ9TjSv+cVRFpq7+rnDwXVQpSA5orFZUCIECTWfEkphi1SCh8SJwlaffl\noYvvBaLTKM8drBWKdwVd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8119", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8119` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWBLEeUxm61yLnJEdRWoBpgiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhZTM2ZGVmLWRhZmEtNGI3Mi1hNjRiLTBlNTIzMmI5YTIzNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdiMTQ5OGYtNWI2\nYi00ZTI4LWEwY2YtNGJiYjliZTdlYjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4V0KGu6gEdP9fn+ky9onEqoRxhVU3Gj69/Uh2pIgvK8MO66b2chZAjmPajxy\n6PF83+e26pneEtocJieiAC9GBqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3u4ZlGbNxtVOcW5lpnDE+Ri+bWgwHwYDVR0j\nBBgwFoAUhnK8Q+AjnzhrVkqyc237mVF9MkkwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHfTjCB8Dczy\nTvQmqbkP06EHNZBr+zYzA0JBXw9trfa4AiBOCG5JIdCkYJt+tXeiRG2CQDCRQXVS\npQW5k1oUfX5KZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU3jo4cAU9XWoaK4/3AQQ/vZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWUzNmRlZi1kYWZhLTRiNzItYTY0Yi0wZTUyMzJiOWEyMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH7j/4ro8A1u+2jVa4xE0IFpMxAWDawrT4OnFMw/y7gRD3\nAdzar8go6nki0loKcvF8XlyW5d6I+Z8vv3C3Xm5Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhnK8Q+AjnzhrVkqyc237mVF9\nMkkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJl3OyASV+Dei5NRY9pN7SS7TyXt3d3dfjCMPDe6c5R1AiBZ8J4ejCkE\n2X+9ZaDTrwNQSdWEER8YeJCVN+T2hFtSDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAcGv9XUQokgR5Ib7aC6eJm4WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdiMTQ5OGYtNWI2Yi00ZTI4LWEwY2YtNGJiYjliZTdlYjcwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGY1ZjlkYTUtM2ZiMy00\nNTJhLTg4ZGEtYzhiMjA5YWEzMWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nL9U88JZkEdn64/uVTJvaJf/yncY8EmiN3+LOuVnCi9AQQjJcp6c5evD5XQd1qXml\nOJfxx4QsL6DRW5atqco6Q6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3u4ZlGbNxtVOcW5l\npnDE+Ri+bWgwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAgtwoP\n9BDRdwqRISvwIRAh9bFBBTaXdADVZXfMCBCVqAIgNyQzLiRYMAqLWy3iWnfp/kzK\n9Vp4s5N2/R/QKa9crRI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8120", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8120` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQX+4ypefMoCD3Syi1Q1P2tKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyMTZjMmZiLWU0YWMtNGYwYy1iMDkzLWFiYjAzNmVkZjAzNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2EzNGU5ZDgtOTIx\nNy00NDdmLTk0ODgtMWE0OGIyMDc0NDUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELPsCK/1hLMKTeHxrMPnTxKyl3yygjocN/zxw1wSHjGiici3ruNIyOM2nwTXQ\nxBsgEKQmr4EueD2alzdssHB2JqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgIycj0bpJXs20TevdlBpFf327ykwHwYDVR0j\nBBgwFoAUr5nqRl14WLiZT7VK8flXnQ2D/nwwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCPQbwQx7TFIvvjpaUdhgZmav6I9R+95FeUw8Q3k4XXdAIgZ6bviMJs1r03\nax1URo/Akmi9+8JvEuxynIieWSuoeTM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeHqR3ytYOnfFPuyzDc0Axu2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjE2YzJmYi1lNGFjLTRmMGMtYjA5My1hYmIwMzZlZGYwMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQakQ+D+i7ruYsODdbad4LgBdOcAg1iNF9zTH7z612wzFZr\n7vSM20Vntq5uVipkKvbKMRubBXK3S+xOWmYQhQkOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr5nqRl14WLiZT7VK8flXnQ2D\n/nwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM/5dwMzLTDZ9Tb5LhRnCCkRLTaMo9dVCY5ZmBnQuVQJAiBs9Wfc8kc0\nfIknEpjIA1CpnbGhy9dN2iMRbt0rcysMxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAatGY2xL1aF2H0ev0ZP/md4JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2EzNGU5ZDgtOTIxNy00NDdmLTk0ODgtMWE0OGIyMDc0NDUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjBmOTVhOGYtNjNlZC00\nZjUzLWFkZjAtN2YyNzUzNzg4MGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHMyZXSLU8RU6fGV14ybKin+tdzmdU2jA6/tsFbHUGlnLMq/UfwfmzhteffOD+gvJ\n9jKOFEE41UChn5EdV+JTtqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgIycj0bpJXs20Tev\ndlBpFf327ykwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAaiwQP\neUH1HxX9xif5w0YDJM1CAR3yrWHf9Yp67vPsmAIhAO/hw4JeyGb90zNq4E0WWnz6\nVfPzFvf+Jpl6YX4E3X3P\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8121", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8121` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYcfG5xhgk5KTj3oMWw4rvcKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2Y2U1ZTg0LTEyMWMtNGM4ZC1iY2U4LWI4MzRhMWMwYTRmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGU5NTM2NTgtODEy\nZS00N2ZjLTk1NWQtYmJkMzE0OGZhMmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO5EdW1eLIYZkixYk5cs8xTpj9HoW9wO2UUVUMhclIfrnzpE3GNoAHIS8YgOS\nzJIN1ccDo6s8tNAmo4f0b+1On6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzp7PstYDSO6pqGlrDrDu3scgyJ8wHwYDVR0j\nBBgwFoAUXis43YR5CTP840/nkCGXh1LPIEcwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIEcAGbt8jKvKKQE+JOb5S3LBj91XNmnKbZNar/JrjcmbAiBDN20ZLLYLkXTx\nacwM4ud1W9JPheqSNQdHslI2p1Foag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdwH4I8HIti+g3RrZcYkRijEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNmNlNWU4NC0xMjFjLTRjOGQtYmNlOC1iODM0YTFjMGE0ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlxAxCqGitp6vdRiURoaEOPTSfWPvpqMCdNHWtoVrNraQw\nauXaS3zDZLkIXO2n7I6RkNr5dKU+6k+w9CyUVMpxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXis43YR5CTP840/nkCGXh1LP\nIEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAua68wxzcWhA/hSiRfLJCYH8OD6UR/rETUu4zl+o21ACIQDGUBK9Fvb9\nGNTGvVpNRBhFYlJs6gLoeVGbJTNdHjkhyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAewnm2po9jcvDuAiSVFgky6TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGU5NTM2NTgtODEyZS00N2ZjLTk1NWQtYmJkMzE0OGZhMmJjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODA0ZTZhMDMtMzRhZS00\nMGZjLTlmNjMtYmMwODQ0NTNmODM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nq+RlaxDDrhjkLBk9ajB7oF1TVi18iUW3QGwocOh4lLeHampBSJ1Q5VP7H83MkYPu\nOafc2Z3dbia0Z6PAEgskEKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzp7PstYDSO6pqGlr\nDrDu3scgyJ8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBIge0o\nzvDtw1vk25ietxqhMh/xVGrR03Q7g/NG0fy1TwIhANPR+BJlGeFDVUecRentapq2\nyTkbXQKLkazqOZxSADTh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8122", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8122` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAX4fBvyIbQ/XFJNDCdtbhCb5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxZjc3Y2UyLTM2ZmItNDIxOC1hZjJmLTMwNGQxZDhlZjA3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVlNDhjNGEtODAy\nOC00NTljLThhZjItMDhkM2M2NmFlZmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGiydXumX9PGfObKO5dfNgJnuSxlmgmr+hTULtZPVEIGZC+s+NwrBTLCmxgIm\n4obPgUnRbLj9BoTMTSwkPbM8QKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1cQ1m2LgE/OnNEBTM09sB7UMnVAwHwYDVR0j\nBBgwFoAUQnY2v74SIft2qlCiJefYEdASFfYwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCt\n6PjhIoFP4OpeHRCRD3s4mxn1w2/LGND3ci6+A9KANwIgd66LjYGWgkY23ObePlZZ\nJYZrE72TONB8qbwf6vpKFzo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ/nkz3h5Mc3DZtecJBHz9z8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWY3N2NlMi0zNmZiLTQyMTgtYWYyZi0zMDRkMWQ4ZWYwNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiJQz/JusIHVJPeqh4O5hNb0fMBjguhY8ANWvs5H2ZFcp+\nl2LxNXnYHIHXlW+8f2iTv6m3pbeqm711fFQgrZu9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQnY2v74SIft2qlCiJefYEdAS\nFfYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKaySUFP7fPULgCGsrbfywRg0fPwEq2UVAt134uxB/EVAiAVyzPb3IkM\nVF2qIi/3NpDxpqXWwHxt39jhPrdAaMWvvg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAVcbb936KmaGD/gdnzG/mNGIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVlNDhjNGEtODAyOC00NTljLThhZjItMDhkM2M2NmFlZmE5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGU0OGRjMmItM2U3NC00\nOTA1LTgxODgtMzM2MTMyOWYwMjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKNUBKOw17wKyBVmpUECol/sCSx4q8kV2kHaGTTA76/W7L2ZszQDufVzZkxppnjxm\nlzVd9rbjFI1pF7kINyOsQKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1cQ1m2LgE/OnNEBT\nM09sB7UMnVAwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBeTLJO\nTcR+PHsimR3bjDkRG5pEPM6EcnnsJLioqbe0XwIgcfqxoN28JES+a1KrAh1+oWdi\npJAAHAHTVjLOUwG3oMo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8123", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8123` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISATGwPxOCdlRqKYwZ1ubbdrUtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjZmYyMjY1LTM5NTItNDNlZi05Y2I4LWFiMWVhMzk3MTBlZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVjMmRjODQtNzEx\nZC00NTM4LWFlMWYtYTQyMmIzZjYxMzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4LhgFWB3nDQgJV+dacU0D58mLx6oPcXeBMgODt93pQN7BzmYlUwWH/Ux2Iet\nVPzt7xZ9OxBd+mdkqiBH7LatkKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkGx5Iu4EiWNk6D6e8N+nZn0vCFAwHwYDVR0j\nBBgwFoAURjxd2E9NluP8w0yCbUNLR2dNC1owOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIAeBzQzj7bkxiCb9qydkta1ujffZ5HOiXH3BsMF0F+RiAiAcOS4F\nVH8mXQaA8Yp2w0EcIZgrdYJL9sSXvHio2+hyEA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARXY7Gr6Xx7N0N7fIOYX48qrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2ZmMjI2NS0zOTUyLTQzZWYtOWNiOC1hYjFlYTM5NzEwZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsZ98ALuYP19nmAwsF9FWT4FezItuLvjlY6VMHaA928Bje\nngsRKBve37youqQzqdEb5Yv50MgkzdItBbD/v4G8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURjxd2E9NluP8w0yCbUNLR2dN\nC1owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIXi2ga8qRKOLnp4mkTJ7kOe5NE/aqGp0dIoKQOpZcxlAiEA5r3mTBg+\neohWoO3zwXfL2lqQirsTL5IAoKa9ky7oZak=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAeIRhH5U9htBbxj3SqHNRU3vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVjMmRjODQtNzExZC00NTM4LWFlMWYtYTQyMmIzZjYxMzIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDBiZmNmMjMtODNmYy00\nODM0LTgyZDQtNTVmNzA0OTc5NjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEbTyRzbgaQHro2rCRYWaWKU0fDZHC/lwtKtQyIyZt1PsNHINhY9whmVmThndml18\nind8ah28v4mSu5mgI3tLWqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkGx5Iu4EiWNk6D6e\n8N+nZn0vCFAwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiARIecj\nT8S9lxxSEmS9DbWDY9YlNG9Mc+NuF6d02pkCtgIgTCcBecomnxYao3Ih2OeNHA6l\n9jupvrhCbM+F0dxvl/g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8124", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8124` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAT/sJoMiVxlTG88qJBfUpm5bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3ZWI5ZTkxLWQ4YjQtNGRhMS05OWZhLTBhNzMwODM1MTU0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkxYzFjMWItOTA1\nMy00MGRjLTg4MDUtOTI4ZDUxMWMzYmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiJJol1DyNBDQJK2W+2u8sUan8WTi/IfSeB7nyhyCbAzjX6xReqHSkRPU4/nz\nyto0UQHiE2xCoqVSnidGdPnKvqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9fESmfcnp5j9zjopELrM+X1pAogwHwYDVR0j\nBBgwFoAUvOJOHh8V2g+H29KV1OEcdmpac6AwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCB71KSz3vaRXa203LbrLBj33m4+c97+t4m2Q+nT9KligIhANF9\nbf5N+DDuRYqzEYowI+LKWosh0uU8h75Rv6BCntGM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU+9j1WRyTT7luCDHufhWjvlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2ViOWU5MS1kOGI0LTRkYTEtOTlmYS0wYTczMDgzNTE1NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV7zoTU+7hVtnUsHtAeiAghKlngC8NSB9D3oocy6hjIfIx\nBQz4i7maIqOyZzL6t9ywX1bL5OeZ3EPADHhKzFEao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvOJOHh8V2g+H29KV1OEcdmpa\nc6AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO2uyTibS71P1tauhugi2o1PLQluFDNI6LTYr+/R5rHeAiB4YwffdHK4\nODIrl5hai1MyfGOO1BkW+IHITAIEYqdqfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAbqlFioyX7FHgNuDezmJjV5zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkxYzFjMWItOTA1My00MGRjLTg4MDUtOTI4ZDUxMWMzYmNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTkzZTljMjktYzMzMi00\nN2IwLTkxYTMtYjc3OTg3NjkwMWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFboP72xhxXPj5YS17K4rAstlbA/tZg0T83l9gUFXLotdzRry424KCpKXj931YuB8\nTcKyUMOk2iFPFxIqYXMQ+qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9fESmfcnp5j9zjop\nELrM+X1pAogwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA4yQ8\nWxL7N3UZf0208EWoupSXIvJDbGPCZ1tgNw5jnRMCIGB4aFw3JWth8hH1UsGXZ4Nj\nMUmobej2YIyr6FbE65lN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8125", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8125` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXJTGr5ghYi3Q5LihQvANvORMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyYjZhZGU3LTFkMGMtNDYwMi05MzAwLTMzNGRlZTQxNWFmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzAzMzlkMjUtYmZm\nMC00OWFkLWFiNmYtOTJiZGQ5OTJkZjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx6m7aZWywuN21QBMNNkBddjzbUyjtS75fu1SIGOZjRA1GXUpnqnynIxbaTHo\nHLaIjo3og7lAruINvcri85rbPKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGeSWrD2k4Al35NobkUHl+Xe2RnfMB8GA1UdIwQY\nMBaAFD4weWpgaYz8SZreZHh24ySVtpe/MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAqcG16mSVCFQ1kIWU9fhIWwHK9YFaXDRw\n5ZBdXFuVFmYCIDMEqXnD2lrD3xg5WsP3b/68WtKX78kxUDjsRN5gNxpT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARKAYdXKCK5BpYKsc9fgXd8wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmI2YWRlNy0xZDBjLTQ2MDItOTMwMC0zMzRkZWU0MTVhZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQA21s3pyRhjp1sbJC+/54zgNz+uK62oNFeFAEWJwTdnj6k\nCww8OLPDOcMAPJRvCMeAMUmWeRhueYlawo3jnq3Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPjB5amBpjPxJmt5keHbjJJW2\nl78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANN/gzpelFN5BcDrnd8mEHiElsBcbw4D31p+P2M68PNhAiEA6rYe8/TU\nHny0ITKQ/dAzFrKHuFYLErcMBht+MkHWNOc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAXIxfxsagGMB8sKH4NvHd89yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzAzMzlkMjUtYmZmMC00OWFkLWFiNmYtOTJiZGQ5OTJkZjJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGExYzQ4N2MtYmE2NS00\nMDEyLTk1ODctMTI4NmY2ZjYyODRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nT+eH4htqUVl9hBPLgCHrT+n5JRMxGaoNQcHLUQUcCVHp87cfy9gAE1FmbR38xc6S\nmpNCxvzPexeUYsHD2tuzEKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZ5JasPaTgCXfk2hu\nRQeX5d7ZGd8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBu/Duo\nLoOfkBUi2fACsGbR5YLDRXPVmDWo/D7RNflx3AIgYisXPs1nKKnWiFybU6z3fwIK\nFNOYsehidhfadLUtCMo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8126", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8126` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAWpf97JGIqPgyLi+P1Ax2OU0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjNGUyYTYxLTcxZGItNGYwZS04ZWEzLWUxNGI1NDhiNDA0ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhiNzM0YzctYmNl\nNi00ZjViLTg3ZTktN2NlNDYzY2E1NDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUoN6ABNSEYxvlh/c0VOlm4AJcOMp0oE4wZ2tXxdYvcv/eT0+YxjS2Z521I/H\nLfRBl1i2bBGPT+lvloh1UxgJxqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiU+z/9ojUQCVD9iExvY8ANsdgOswHwYDVR0j\nBBgwFoAUrwbxEk8yuV+yicVQR2zzZ9bvqiAwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgIRctg9bEGVtA\n2pSLmw9cGMb/vFd1jOQ1qw4aViiZt7gCIQDSrOOgtlkbupy9bQ7Iw8OdFexk+2Vl\nC2tk2j0/CTd5Nw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaY4uLS+hXsQ/9quRQuFkp6lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzRlMmE2MS03MWRiLTRmMGUtOGVhMy1lMTRiNTQ4YjQwNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbJLL6eSbMCobIyxnmXjvrnEdd9HsYsU8PWYA7+S4rgo7l\nfVijIyJjTh1AnmKP1ntnqsB/HZzxEbiFiHlMKDuCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrwbxEk8yuV+yicVQR2zzZ9bv\nqiAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKcVKYd5PkH56X5QO61ef1E0Vg7cEykSOB2SKRETuYs4AiBUw7Eb3j19\n2O/M+dJqx2mxXg1ifDJZgkhvqh30H/0jdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAeESntRaGcqFJCCBOzC8YT03MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhiNzM0YzctYmNlNi00ZjViLTg3ZTktN2NlNDYzY2E1NDg5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWM3OTBlNTMtNTQ1Ny00\nOGI3LWJkZWMtZGU4NTEzMDRhOTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7kJkCZIxbN3wBdwpVqsrsNKIGtywZ1wrGRe7tLmPZhzcSfYIjaa76LGM+sF9LBQK\ngpcXr+B5VPKqk1ArrNyBlqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUiU+z/9ojUQCVD9iE\nxvY8ANsdgOswDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAptOT\no7AVmze/9cSo35IpT9nhHS45YK1S6FJ36s6rJG8CIGwXOsf9+YTjhUuhin/0tGJU\nJ+uzeM6Ku+NQTs2zmc0p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8127", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8127` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAYHDbGXYXio+deCq2j4DVUp7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkOGNiYzc2LWIwOTUtNDcyZS05N2Y3LTExNDdhYTA2NzlhNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzdiZTU4NGUtMGY5\nOC00YTQ3LTlhNWEtNTNlNGE0YmFjZGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEViCEm22Ozz2QMd30Y69z9skQbHBPsZrlHQyz5ekyB0glcR5Xv9d3kklo6pZ2\nZ6ZyJPm9PO72yyO2P+tPoevcsqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKRSenLH95wOx+1i/i/XI695f2bkwHwYDVR0j\nBBgwFoAUZmZjHvatsAzksSOAL+hcMcthZCkwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAIki8EHBaNaz\n0zyhus4izNMtQJu9kkCE7PpGQRyWAGwiAiBz2DLtj49fLT8ZJk3cBLS37BOv6LvN\nFR/7XC1LsrYNwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWn6b2fFb++9IVpqMpVYmVGSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDhjYmM3Ni1iMDk1LTQ3MmUtOTdmNy0xMTQ3YWEwNjc5YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXBh8eXNeZrNioBnbAIXuwWq88JnDpqRaYDLZjfo4eNnjx\nhYFeCs4Abz/jX1cZJCvmg3EXi+3biYCp+BIYV3dso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZmZjHvatsAzksSOAL+hcMcth\nZCkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOc24DHbHRaXH7yIrEZvYYLlzD1mAWkcKqGfNmHORhbUAiAc+YTS7PMa\nw1URmYdOcu0OYw0m2601GOfTNAjVEaT9Og==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAfR6RtYEChGVCbwSUNbFk8SaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzdiZTU4NGUtMGY5OC00YTQ3LTlhNWEtNTNlNGE0YmFjZGY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDM2NDBmMzktZjRkMi00\nYjFhLWJiZTMtODNkNTAwNGY2NjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsgUVUKDgjTVWVredBdsrThzXeHizs/VmLMY+oxx0X8HHDO7T6xnMrouhryxqrzOL\neF4E9qIF7193wG0z2EwIdqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKRSenLH95wOx+1i/\ni/XI695f2bkwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEArN9n\nFEyK5s8TjnZq0GUOdy22SuUZnz2nWEbtK0giZdQCIGgVasiUDcH70gUYnbPQySCG\nharkZnAY3wP/7SnubLZy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8128", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8128` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVVm68vbSuYAA0WuCPzhVE5sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliZTg2ZjRlLWYzNDgtNDRjYS1hYWIzLWI2MTMzN2E0MjkwMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDgwYWMyMTQtM2Y3\nMy00YzAwLTk5MzktMjM0MGE5YWFlYTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1ihiMsoQZQCsqQJImhT/erk8d2flEY0KvIoNU6jNi/eRGFEUKeZ7ha5zTEk9\nci+QM3QW5C07QRJvhZjm6MiEY6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkOne2SXbajxY4DZttagzSwYHqywwHwYDVR0j\nBBgwFoAU++7TkrVcIvbHcgLRcZRz1TmJ5MMwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC8OADe8gzB\nKRIl6DQ42m8KsU2Wh+ZiAR7lxKdV89dQ+gIgDeC8hxT6i+gwCF6ug+IzllLc6ts1\nrVbNJaswkQulgrI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQSfdpN+qU5FpfkYVt22lcsyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYmU4NmY0ZS1mMzQ4LTQ0Y2EtYWFiMy1iNjEzMzdhNDI5MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmA6n6lpPDUIxQWi2obvGEwQ8BNDhJ2j2vIdjv9DuT/CBq\niwp/aFPkURHouGrI5Z9wyNrQk5Qs1UbMV0S/6Axjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU++7TkrVcIvbHcgLRcZRz1TmJ\n5MMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPdSCIv5OLVZq59bWZy+d8vqTmxIK5zPO2veXyKWoXOECIAC8wo6H7pMf\n2mmkMlDRm1cvYgwzeFUwPs0G8lCdzQXb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAcO+c7bC7gIznHoHtMU31ZRrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDgwYWMyMTQtM2Y3My00YzAwLTk5MzktMjM0MGE5YWFlYTUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTE2YjdkOGYtMjZmYS00\nOWQ4LWFiM2MtYmIxY2I3ZWIxYzhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nijz6RG1JNdac7zVEbsPVyNU/ePwJJqLXC8DifOB+DDfEbjMRLfIxzGrdoW/WEffm\n272K12lFrspJiw4G3mSdiaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkOne2SXbajxY4DZt\ntagzSwYHqywwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA1tV8\n0KUyrtUJK+E06ep0BpRY+JLXFN8v6XMZH+xi6VACIQCMJFRWnt4hFAh/jY5LWRTr\n1lw3UbC8/fQmuipRrcBPsA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8129", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8129` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQvjtlAs20Hjg2j9ap6iPdu5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhMWVjNmViLWNhYmQtNGYyYy1iZThjLTBiNGQwODc4OGJjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzNlYzhhYTItMzFk\nMy00YmVmLTgxYzQtZjFiZjdlNDZmNjdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEE3UZXo7ib0fLVU/KfCnb4mawKPWWCW9V7QsAg6xvCK1YLeZ0zAmJA540XJYj\nvpaRStljZcP+uXnbEqUTbU5ZYaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7NQ5KTnusuKCFkVTkYZlIVFAKyIwHwYDVR0j\nBBgwFoAUA/ML5wsJYY83YmprPcmN2pNKhhAwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDNRpr0FSfcUBkekkIhqm6lSMzvKPJnYWCFk+0fZ3CDyAiEAiJWE+QTUYGfU\nlu0q8ULFUr+Isj+7VdtG7YVRl29hApM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX0XOwrqU+OaXZtuMB3cbhizMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTFlYzZlYi1jYWJkLTRmMmMtYmU4Yy0wYjRkMDg3ODhiYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0jvR5e3Q5WJh++feCx+M7lfNzSmC3hKTIGHlD6C4AoDA2\n9HG5vgbRtCXqO2f91qj3js79qIvuJo7QrZ0QXtmAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA/ML5wsJYY83YmprPcmN2pNK\nhhAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMJCytM8EYRjTH3rV1n8aRgLl5iHaJm8QvAAsIQZ89imAiEAjo6Z/c9F\n0q0P2Tev5FPTY8E52twJXQghlCP5nTzAKw4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARiephDleUcT/brdFnP8Z/81MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzNlYzhhYTItMzFkMy00YmVmLTgxYzQtZjFiZjdlNDZmNjdlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGU4MzUzYWMtYzllZC00\nY2IzLTk0NTctOTIxMmVjYWZiMmYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nj+tNK6cgfzRuywPsQW5l1GyI3DkjdVZ1yRX9Sc/hBXBK/h2ruA1QVd6SmPeuqREN\n+LlkqsTNDFhHgP/mgF+IzaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7NQ5KTnusuKCFkVT\nkYZlIVFAKyIwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAosz1\nzIfj361j4qWNcGm83map5sAHhMgDvhPXB7Rrh10CIEI2bRKBGI7DCwVpjlwMowFa\n453qDXS33RbGPFO0JSb2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8130", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8130` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAanafKMH7kORUf7vck0nIFToMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhNDIwNGMzLTQxNTMtNGIwMy05ODRhLTVkYTZhZDlmNDRiNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIzNzZhMTYtN2Q0\nOS00ZDY0LWFjM2YtMjgyNWUwZThkMjU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET6au1fTTVEVhse33GsRurXjgz/q9q4i7CRn46UOp9QB4V2WP9uY3ZfFQA2nn\n1jok3LF/8O9FiQxprBS+fhLfNqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW+3rwPhXFmmOA5TJEcpbzHdM/5AwHwYDVR0j\nBBgwFoAUBLXFDgNHdXhvdohPZKlVHDtwBfMwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGbF9gewBU+7djfs7CmZCczi8ftdJZM6cIDnIar/TTe9AiA2Pn21G/b2OULw\nrZ+Ev0zTSyiqeQClvLmxzxuj47hLPg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeo7s5aCfSIXWqx/PxYEmmjPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTQyMDRjMy00MTUzLTRiMDMtOTg0YS01ZGE2YWQ5ZjQ0YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPZWIXkrtQaIy30LtPqLyYMRYMi5DElkyIObWUEUlGnDjW\n1OKrICjH6HJGNqGda+ed+XxJ31zTPZflrpfCaikeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBLXFDgNHdXhvdohPZKlVHDtw\nBfMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc3SXVdpmG02hT8PeBDX6jppS1hv1Zfp1fsRulJ1BI1gCIQDZmZ8vfr7s\n9o5STC5+lGZrvkAGDm9fygHYZMBx5XFNfg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAdX2OOuo5dgGjR6/qkj8r7p1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIzNzZhMTYtN2Q0OS00ZDY0LWFjM2YtMjgyNWUwZThkMjU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGZhMGUyMDAtZGY2Zi00\nZTkzLTkwZTUtYjUzMjg1MTMyOTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ns4hNWxIgqxrmGYMeqJXRvnlClaWHpcUpkjau2DhVVk64J673MMmAcLQ9xMLV0T7y\nXhU6W2aecIp4UdkgwmgCS6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUW+3rwPhXFmmOA5TJ\nEcpbzHdM/5AwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBHUney\n/woCOAN1f4ZEbL2Mhuo/trsRpr9GH2uzK/ICWAIhAKK1/LfxCggEyNy+jbXQiSz5\n9zK/fXG9N/myPnwkXVyM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8131", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8131` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAftbqkHzAjFPmFwEdPl3jtTCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmMWMxN2Y2LTJiN2YtNDgyNS05NTdmLWQ4NmI5ZGExZmI2OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDg2OGU0ODMtMDlm\nZi00MjZlLWI5N2MtNWJhYzg1Y2UxYTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtIuuJYQoOkhJNU9L7mT87TSxYHLc2bCqqxc2uWr3eN4rV62RlHFnPJtQw5sA\n53o86f3U3iXwqa1WGAZvtnKSIqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkPtPSEFkweC71i5apxwR5b7NwsgwHwYDVR0j\nBBgwFoAUPHrWJzIG5bFMzaPIO5Cgdz+1MdowLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICOS\nePyvc1wMbZUO6B0qXGkQaVOtwp7F3Vte69jwX6HTAiEA7I/Qk9knIyoiX7kDOwKM\nIIv8Oc13PuNhneGytK0KgRE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYMf2HvhP9ay2A9x1CBvBoC0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjFjMTdmNi0yYjdmLTQ4MjUtOTU3Zi1kODZiOWRhMWZiNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCodL4pdc+/CjxGtyEc1tPY1JqOkNhzVbJvvLssISou2MS\n5jbXjtu15fU64I1500SknHL+YEk5dZOVzEY/bAMIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPHrWJzIG5bFMzaPIO5Cgdz+1\nMdowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMcJlHLqKWH0HhXfs2Giq9NLvnMjSK4TkrhMIOrfvYFJAiA1qkS0ij4y\nAbIVWmshfqRM+XGBAtxKCyDDE2lYLPqJoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAWxjxJHmNxYSth6Rb5Yyh9rCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDg2OGU0ODMtMDlmZi00MjZlLWI5N2MtNWJhYzg1Y2UxYTQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmQ2Yjk5YjItMmVkYS00\nOTM2LTlkNGItNDMwOTIzMTFmYTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nS7MkZsuWLp9tLPy3VoyhQWh4WMV4DZKUpNoEyWP1ctyapQpqsi8/1QJfZugwYpUa\nS557fOyUe8aaSwMw0VJCi6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkPtPSEFkweC71i5a\npxwR5b7NwsgwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAv0v6\nzPvBAABKVEd2t6cESRYW/iuPkpyVX/F8sK0XnikCIDawNYfEBMH3QEaNahxw0J6H\nbwBI24cfOiY3xI2a0k0w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8132", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8132` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAXg8eazP0h3amx0Ht0HlZTX9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZTczM2FlLWM3ZDMtNDU1Yi04NDNhLWUwYWVlYjNlYjY5ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjYyZjczNmUtMTc3\nZC00NGE0LTg5YmMtNGE5OGMzYTY1OWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsoodpIzx0IDx+jgGR9tSIjz0NzUbRulujgrJGrubIHJoP2oJKwqqzfgiVRKe\ngjtl4E6Ilx6rJ2z+meeL0ALgAaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7LvxCQDTT+pM2k5JQDWpQd0FxtMwHwYDVR0j\nBBgwFoAU7cB72RCuE+s9ARsx8R9sDAPLubowOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCID/Ojxug2dp2H0xXvw0tgyMUb7+RUv+DqYpy63ATpHgnAiEAnF0h\nv7WfHZ42i8RZas87Dn3YNac+/z+T454bR6KxH/Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARCdFc87ieKLHMRI0Yagi/n3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2U3MzNhZS1jN2QzLTQ1NWItODQzYS1lMGFlZWIzZWI2OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkZ46MhRXZK5EKC4ybwKSnfIoKdW5k93RZeoRb2LxDGXJu\nc7tuPpTLGaJW+6L3gvkCr6cGaTzHq7+CLUM6YEooo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7cB72RCuE+s9ARsx8R9sDAPL\nubowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIqgGl91t9NGs5v3l1FUuSunP70+i4u61TCDxL9UDX+zAiEA7w2cYF0B\nk+hPTPNme5IhhG8MOARTSO3/QevdMQqxGBE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYQ3EP+FJKxzeBBjW/05HBsNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjYyZjczNmUtMTc3ZC00NGE0LTg5YmMtNGE5OGMzYTY1OWIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTdjYWM0OWUtNDg5MC00\nZTgzLTljYzQtZDEyZTMyMzIxYzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nF0uNKybtwJ5I8yGoZShi2jh6l3WE6Knvv/APAJmXg3UgBpj2uMaWDIeiFcXcKZ5t\nz964yy/EbM10GYHPMZidGKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7LvxCQDTT+pM2k5J\nQDWpQd0FxtMwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA5L6r+\nxeXcFwx90P+Vrvjpo+g0TVzD2npqlLBk7uAcRgIhAIDQsQ1zGLoxfP9cVLrU5/zE\n4gU8j+LDzsI+2ChSuXFP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8133", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8133` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZGOQlfQS6885BMAEY+u6ipJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkNDAyMmVmLTYxYjEtNDBlMS04ZWQ0LTFiMjAyNTAwNDcyMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhjYjE5M2ItZmQy\nNS00NGZkLWFmNzgtOGMxZDYyMGI1MmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuX1+zFPhcM2SxL6WsEdjr+Wiw94cGuc3TLJpI1nppXZ5Lj1PxZviV/8jSDqu\n3A/0Nrz37woRV0V9HjLBVXx8M6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1v8U2FsJ1rxCSGqq9WRTEcSJV+8wHwYDVR0j\nBBgwFoAUBpnURAKb8kPlatk3f0InaxYZlwcwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQD4s+PZeHsN/IYc2UcU0PjKrBAyA1Nl021tW2osXMdMeQIgPFEA\nSZBda1RwZwAOUmhFcutxSUDOA2iJGyBwWwOPxCM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATT1m883BnLj7jrAa22mwioTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDQwMjJlZi02MWIxLTQwZTEtOGVkNC0xYjIwMjUwMDQ3MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFgGCVjErl+NO/eexYXRW+4G4A+UgpHq0U1C4EUFI5JPro\nyWQEBqxemlkGH5fgYDB+xa5/fJIr9IAsV+c/xW8No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBpnURAKb8kPlatk3f0InaxYZ\nlwcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKifPntF7YRbuBnVrIosfytfBmQlS8bDvyFiMg25mz58AiEAwIFqMgSK\nOpEA1oC+eKBw7HkrhxTf2BQkPJH6pWQRZhQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARj41uencGxLbc7+nXGdcW/cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhjYjE5M2ItZmQyNS00NGZkLWFmNzgtOGMxZDYyMGI1MmVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzgxOTQxNmEtZWFkMC00\nOTczLTgxNmItODYwMDhhYmQzOTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n04EywagN/4CGA4zsdZJvTZyiWlupw+BordVVhbE5qQN1KFZSKJbYLBlv8aphqDe2\n7ZqZWFl163HQbHJUUF1snaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1v8U2FsJ1rxCSGqq\n9WRTEcSJV+8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAbTidd\nYXUjJGWwwK3TTlHw/5J0Ba4ELrVo7zTZLD7U6wIhANu2G4NSbn59KE+v+LuLyLMU\nC8NTWwa4sIfQnhIiTW66\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8134", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8134` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYTQdUbDNbhEN+7SLuF/i8brMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYTFhMzlmLTFjZDItNDY0ZS1iNGRkLWVmZGM3ZWNlZGIzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U1NTgxYzctNGM1\nMi00MGY3LWEyOWEtNTVkZWIxMWM0NDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0T4Ta3urTfcjMXqke7UGVy45483voxHUzwTvR0yulE1nxUQgCYeUcfbraYcq\nmCpZWMuR3L3XMqwwCFVkofk+8KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ/bGWPKhCqJ0c8D1g4nfA1clQX2jAfBgNVHSME\nGDAWgBTpcMUQqW22TV8sChzw3Hjdb7CfPDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAK+SXV2j8JO7Fh/lh2TC//F88hlNK9P\nU4aqf5bKr1v6AiEA5sxOz7SGugDA2akNC0QZ0rf/om1w0wxS2WyqesmeFG8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeXWHd506Ins8OhMkUiEY8tuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGExYTM5Zi0xY2QyLTQ2NGUtYjRkZC1lZmRjN2VjZWRiM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR02GFzo6qU3UThkWA7zRPJzBr+eMHpOgruHNbSWcl+BQM3\nlf34QEFHvMveeayEShfxMe1wBVctQs+1IaDbtaojo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6XDFEKlttk1fLAoc8Nx43W+w\nnzwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMYsmfRzueR7vU9wZXwf4IlcvjnwLupBnbRYjuGUgqqFAiAkyRNYcfkQ\n1lt6qlCqXrDrqtlZXgeuve0hMUdFsHVzuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAfJMtflBt7eQ3OQeE4/sqyHFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U1NTgxYzctNGM1Mi00MGY3LWEyOWEtNTVkZWIxMWM0NDE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzBjMjcwZDYtZmI4NC00\nNGZkLWE2OTMtOTg5OTc5OWU1M2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4nHqdjlC3C3FlYai+Si6qeuVyte+sHUf2d3zDjEgVzL63OTT6pRN3LovFLGhFyLc\noUCQn+yo37/kvR7hDEO4RaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUP2xljyoQqidHPA9Y\nOJ3wNXJUF9owDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA8w+O\nSUgyJsfAOZUasL/nowVoq4wlm8fHeXJvMyfqr4kCIB3OFCnGxXLWwgdefV0R/ATK\nwiP4B5xI7jqXd64DeT+G\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8135", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8135` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAYI4U8mPUcLmsDdmjnXVMSqzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNzg0YjgyLTc0NWUtNDUzMS05OTZmLWI5NGM0MDI3OTE4MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY1Nzk1ZTItODc1\nOC00NWQxLTgyMzItZTZmNjc4Zjc5MWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBDknJ89LS8n6dT3s3V1083pTIu5Y/Lr20FpKJGrSahbp+T27ADIYmrz7RmVB\nH4/4wwgRl+ISlTUKDFK0P2FiaqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyH0MEZWUVNUoL3+mM8/yV5wmBzYwHwYDVR0j\nBBgwFoAUgB149XuWJ2FsVya1wjvHPfzj3CMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIGexqjG6RRNA\nHKU9hiQJWjTH23EG9DZY+INrHYrAUBdWAiEAo9HJLvplE1NbrITw1j/9NYtyq59e\nCwT1c7c81ArsnXA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQJLEppe65PZJ9BeEEEIoDXSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzc4NGI4Mi03NDVlLTQ1MzEtOTk2Zi1iOTRjNDAyNzkxODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReouO0sKG0jsO2F2ywzqHTbgk1GaZjw/jYTpPh/j58DZfJ\nXiF8E2jr/55DiuAeiRDicJZZn1I6pNhfCatkESYGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgB149XuWJ2FsVya1wjvHPfzj\n3CMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTQGd7BNbcr50dAqMRsx8Q8MJgF6zFPIA0VSSHA6fRLACIBabLoMXrgqM\n+r2Vi+38sgyxyMaU1D1DRP5Yo3ut7PK3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAV3PAXmvcKLUy4A+loDsYmOvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY1Nzk1ZTItODc1OC00NWQxLTgyMzItZTZmNjc4Zjc5MWIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmY3N2Q1OWEtZDQyZC00\nODk2LWE0NzUtYmJhODIxNThmNmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2AIa6m2ApHjLaYMOplZ9imXgXlRU1tCLefdtM2sLM/mMM0UJcuu2IWaDL8YAaWDJ\nD2e0xKECvwRCFzY1f0dFRKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyH0MEZWUVNUoL3+m\nM8/yV5wmBzYwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBiD40h\n5EZtIWuGu3VCgP/PMl6Qz8mYPuL2eAshSBddtwIhALLO5E9Ja9kNxhv08xEaaGl0\nNe322q9TAxpbabyjaFE7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8136", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8136` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAV6N64h/UXN7KiHcLlbN1GRMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxYzNlNzkyLWYyYTktNDQ3NC05ZGEwLTk3MjczZmEzMjcyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdlMTg4Y2UtMGZl\nYy00ODQ4LTkzZWMtYTZkZmFhOTI4ODljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+SWtUb0TFDdkXhAUfqdNGUYDimNk/W+pPa5IuKYbGJqXKVJLXtjnDgIW7rJb\ndVMTKgo46frXCedilPJHJi5DjaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjw068NO8lpZG9ppTAg6eziefdvQwHwYDVR0j\nBBgwFoAUTQ/Dmubtisv4NIom7tofjwtLezowKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDG/yN+DbIK\nW2oOrT/VykW019CDOUYsFBk/2z8tYt+plwIgQJ1DlHRp2Hq2CZiYxN4MPbHslu1s\ngRuS+dfgkIi53V0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa7Gfk+5sQQMsJ9E4zyZL1sEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWMzZTc5Mi1mMmE5LTQ0NzQtOWRhMC05NzI3M2ZhMzI3MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQj5L/sTcxtdkCc/IMGnFBtezaOFI6KnIptwFy22PCEkFwO\n2aBSs3S7IJAvdDlfARDUgMKGjtzLFvjp9U5dWWRDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTQ/Dmubtisv4NIom7tofjwtL\nezowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLcekIEdEw59ydzExCPNz6xA9utSIwcvxUPYSABZGCl4CIAEKdaW/546O\nutLOlWvrZeinKqY5gnZrQ4xz7LY4YZfY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAZ2binn1E9mt+OVobDF7vkazMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdlMTg4Y2UtMGZlYy00ODQ4LTkzZWMtYTZkZmFhOTI4ODljMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzEzMzZiY2EtMDhlZC00\nYzFiLTg1YTEtYWJiZGFlN2Q3MjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNCWMOosrRQkDAQx5JbviPipJ4c2znv+ApjvLpvQslXo3XH7E5bkUy1oI2ccZ9KfZ\n0lefZWeIBiU0fM3uKgzqaqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjw068NO8lpZG9ppT\nAg6eziefdvQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAwuKWm\nYnxgc+1yFcaGQNxY51oLDwb3FG3CTyrrgav58QIhANtGTEseISYLJYB6thvXrsGg\nIqTrpwGLsfyVqtvhC0jl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8137", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8137` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAcTcweXM/aICb+N2hw/ImYUEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4NzQ2ZDAzLThkODQtNDJlYy05ZjMxLWU5OWFjNWE4OGQxNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdkMTU2MmUtMmZh\nMS00YTljLTljYTctMWQ1MGJlMWNiYzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOhDSCu3na1fC9AAdHvTQOgC0kTofEwt0QtX3ORIDF0GKfC1dNc1W79d+YuHB\n48niOOvEiv8zgGJn6HCP0vvc66OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ttdj0c1MOa1J9OrDDPvVVIK/akwHwYDVR0j\nBBgwFoAUVPIIz0hhiD2RjawCEfLFGcHLLFcwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBohdVx5faT\n+LKa9ys74Yq2iVSufchCaeQQMTGGfWwxBgIgFhC+KAWSpUnPBMe7QdKL1VVP6lqG\ntdq6XeCK6q0Wquc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQmkQDk5u9wbqFWekhrbGhK7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODc0NmQwMy04ZDg0LTQyZWMtOWYzMS1lOTlhYzVhODhkMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARft9exlZXbIFcJas0D0VuC/vPYKRMb/fU2thjryeKjplmF\n05XxjTauBm6pab/ctXmsiTcVIQHhFLwx8wQhl5aso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVPIIz0hhiD2RjawCEfLFGcHL\nLFcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPLaO5ubYnmUL1ogv/HnziTmH5GPZNtjVkJRp4OHq2jKAiEAhieKPHbY\nL9OlZVk/0B25GqPyM/WNgjHpg9ruZgYF9YA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAUP2J+NBCXmbPztfbfoJ5KwEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdkMTU2MmUtMmZhMS00YTljLTljYTctMWQ1MGJlMWNiYzJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjlkMjcwMGUtZGM2OC00\nYTllLWFlMzAtNTA3MmIxNDc1ZTFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nATkFH3BgsikCD0C+XaVWQ7JvCpCntuU84SkE5oyoqq5DTeNw5K7au5I6T5qlo/qN\nEoXV1YYX3RoUzF+FATfkz6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7ttdj0c1MOa1J9Or\nDDPvVVIK/akwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBXc5Vh\njJKFghZ0mYUjSxoae7TqDBXajhmEh+UVT1ZvaQIgcOo+TBOBKEA1QN1DX/Uf42Hs\n+zHQUJeTXuId2taOIw4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8138", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8138` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISARCEzsb/wEmUHg3SBHZ/uPyUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYmMyNWQ5LTZmZTAtNGQ5My05OWIzLWYzYzM5MjU0NGJiODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNjNmM0OTktOWYx\nOC00ZjNiLWJiYWMtMDZmYzE2ZjhjNzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEebb6SB2gE59Xg5yD8h6Zuz5ex0sbim32Fqqx6/mZLmEJ4kmD2pUXVNnRtx+0\nr2IdY5CpkmMHz3YkRnl2zbKxJ6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjba/ioocKi2U6UwH2RfJr7m6ywswHwYDVR0j\nBBgwFoAUsXuyCwHVBr8PAawS3HuXTbC0RFAwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAs5xwW+gWaiQkXf3uCBZTZMwHPzksKEXMpU1GxU1RGvMCIH07xXK5XTqS\nGju/BXZJTDIJdJ9a55Pq8ncVhFUsg+a7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARWTO+oS+yAJoGpsAIsFUX8RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWJjMjVkOS02ZmUwLTRkOTMtOTliMy1mM2MzOTI1NDRiYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgVn5u8NmiZyMS8oJUEZYTXJfcaETF1C906wYC3wfDJ5OK\nXnkzMIxbC9ZAIkmmWcRf0XAJtkx22GwDZ88RFr5qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsXuyCwHVBr8PAawS3HuXTbC0\nRFAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQcY0l6i57HggaGOo31jCCIHNP9PAI4a/AkoZdvj2g8MCIGsaAFK7N1Ko\n2nzTObgkavM14xquGEk24sJvzieFjmuW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAeCa7gKXVtpxXZAcZmmxCpFeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNjNmM0OTktOWYxOC00ZjNiLWJiYWMtMDZmYzE2ZjhjNzVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWZlYmQzNjYtN2QyYS00\nNWFhLWI3ZTAtMzM3NWRjOGNhZDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSVZgk3kVqTzMKacBZXlXZtNJxQyDhz8Q2MZyxOaWtK0+DEgmRSWncnTK78zrsnZO\nxtJNimENvjCm71LGTotsNaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjba/ioocKi2U6UwH\n2RfJr7m6ywswDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBSjKY3\ntApNzejZs3F9jlzYvxJdZzozm3WdClIoI6R35QIgHg633MNnf8sf8XgCIdCv9UPc\no0rWTqnfJIbX0rV59xc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8139", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8139` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAW7DWSHtkGIMv/sf7dhxQFYZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5YzgwYjI2LWY2MTEtNDRhMi05YzQ2LTliZTUwYzE1NTNhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDE0NTlmNWEtYzZl\nZi00NzU2LTk5MGUtMzY0NzY2ZTVhOGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ2z7yijQd4HZHMuNtpbhQXbDMw2fzjEhk9DOE04bjr0PEYaI5J6w4Uhgx6Yz\n4J1Mm1fMJoVtwrpxve7/B/RJUaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD0riteQnXUTwtOIrAx9v10EpFpUwHwYDVR0j\nBBgwFoAUY+rulKk8ZLzcbcoKyFB1jK8Ao24wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiAdFtWVC5FwsrIQdob9DIInkAgro+8DWG3bntd3CqMjjQIhAMkils0zZf7p\nWkRHyOuasXvZl2JN372Hl4Wlj0gyeWoj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARp2DeEQzRu6t1G663NsU3IXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWM4MGIyNi1mNjExLTQ0YTItOWM0Ni05YmU1MGMxNTUzYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQh5KwUa8zO4NjtpslRWWd13y4hZDr8IkRvcfOzHaX4O6cs\nUxMy5gnYcRm9jmIgOD7n2lb4ucOBbwqG8Uzx+k/ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY+rulKk8ZLzcbcoKyFB1jK8A\no24wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALm9yQXUt5qRF/nyg/0qskuZ9qSheyZcTF5pDQLxYZ9OAiA8VsMVZ+1i\n+VrMKYwPCkN4P9HCYNH7aBJtiNzuJ11rIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAWqpp0JT7fHA9NTde71crHzrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDE0NTlmNWEtYzZlZi00NzU2LTk5MGUtMzY0NzY2ZTVhOGI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGM1YzUxNjUtMWE1MC00\nMzQ1LWE2YjAtODQ5OGZjMDZiODFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\naSBalJOMrOkqLI6BBPkvA9J8AHSnLBL2N9x1Eey28CVfMjTLzLd2GZQgx4Etx6Mf\nL+tBSN348UxUHxLEHXEzo6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUD0riteQnXUTwtOIr\nAx9v10EpFpUwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiB+ydT/\nERDVOE45eUSD9o7cHyV3QKniRe044eK22fe45QIgD/dE48Sdz0M73HaSOHcGuj2G\n9nKWzb9BAfiv4l+KuI8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8140", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8140` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAYWVmWvcaACAFzDjbwQFgqNLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0MDY2NDBmLTBiMzctNDQ1Ni1hMzBlLTc5ZmJjY2MzMTQ5ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUxZmI3YWUtZjEz\nNS00OWEyLWIyOTctYjZlODJiZmYzNDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEieoPBhQt0k8DIj0OP5s/SYGML8l2MVWGimCz3edHTZiHq7fQ95ijsyal7qMv\nQmko48DmJyhTaDtLKXYMZAqiN6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0OQdrp++zwsbwWWvYrxYSLv7vJQwHwYDVR0j\nBBgwFoAUT2W+93Qj9zMkqUiGSUJIN78zBxYwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBO\nBJ0+X+5UTSKUWzaUix6Ka44x6/m1jyJ6cAT/I2rJ4AIgE5QIfRrvpOSckGR2vlJL\nrFt28U0O5opilT+QlwB4+Ao=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZNMeLNmHALaIYEJe4/v1GF7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDA2NjQwZi0wYjM3LTQ0NTYtYTMwZS03OWZiY2NjMzE0OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZWgtJE/PyD2s7IrGPYcMYXRYACI0dDmMzrQ2zGpemZyzy\niSZFoeAjgC0GdBSlpDWJFdOKlXbqQreIL1BmOsxQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT2W+93Qj9zMkqUiGSUJIN78z\nBxYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI4RrSyhspvO8TAXEHSSz7eafQry9gGTCwhDAwgLhL7SAiBZRoluANrl\nTW0VJEQGegFk6DB6D7r8xnF9Bl7+7yScUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYbnVeGTllEHyz495PHqFX5UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUxZmI3YWUtZjEzNS00OWEyLWIyOTctYjZlODJiZmYzNDlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWIxY2JkOTgtYWFmYy00\nMmI0LWE1ZmMtNDRiNGNjZTgyOTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbggIp73v/kv44fo1SDKfNpdhPUWbHuPI5FvsDN/J4xZByN9gnWs0zfUCRK+plitv\nvHb7oyUC2Dm3GCqSFI7PWqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0OQdrp++zwsbwWWv\nYrxYSLv7vJQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAk/31m\nGQeB9ohxhX4RgvRvEJJLX8aSDuLYmaYozivO7wIhAMFVtJ/zutYrUEkFrkAJZWwx\ncaHuedaWxrNTN956kevg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8141", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8141` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAYPqUUSm6xCqiSRDTqWp/LnFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkMzZmZWRiLWU0OTMtNDljNy1iYWNlLWQ2MjYyYTIwMTAzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc4NGJiZTEtMTll\nZS00OTIxLWFiZWMtMTk0MTg3MWQzODI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjUqwYgqNPhPqjPXWhjQr+uR9aorWbh7Un4b2Z6H9UKsSRuO45TYd7F3DwVYe\nQP4fFQgFgOC8Gig22+s4EmeFg6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIMj5pTUjNsRM4lgC2+23rq3XVLUwHwYDVR0j\nBBgwFoAUrBDHTMVOqaiPfahLCeR6Hbl0Y28wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiBoLSc4svjZSxK0TqM2fAPvtis25ju77jKBOADyQP3PdgIhAMld\nK2Q6a9hpD6SkkKcax1p7JXscFx9BEC6gPjPR3qMS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeuJFO8fGIYIBj0VGANzo6qRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDM2ZmVkYi1lNDkzLTQ5YzctYmFjZS1kNjI2MmEyMDEwM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuynaB9jqHON1DE7mXdN5kyzm7kvcPg3DEkNYkg+WB0mQN\n6IkH+mcOJtPUI796zR2oG+Xc5hQ6/2YCuGWtcGl+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrBDHTMVOqaiPfahLCeR6Hbl0\nY28wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKwDhd818r6Ohh1F/oghgJyMlAVmT5m7m/w9bR30/7f2AiBJuDF+EWjB\nrYWHsj0SzwhHMqEYMvMJlPPT1zACzgNvQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAWZK4Ar1c/ueRQfyzwKnGng7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc4NGJiZTEtMTllZS00OTIxLWFiZWMtMTk0MTg3MWQzODI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2FhYTJiYzgtZTI4Zi00\nNGZkLTkyNDItZDY5NzNhZDAzYzYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzBviX0PmpxLfQJZZss+88XDPHJWZIeKvAfGwbMjEQAbSGmdXgXFyW8FVRYEAE8O9\nMgafKmeUbcvuAjPoOGmQZ6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIMj5pTUjNsRM4lgC\n2+23rq3XVLUwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAuSip\nQ6xHWl6xtKY5X/w09NclF4eTGz58k9ufgcIpuhMCICsic2CRELTTYWI9wKqXtm15\nlChau/bh3qol9XicMN0S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8142", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8142` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQA/LVi0H3ivHeQb4EPzxOwmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxODYyOGEzLWFlY2ItNGM1Yi1iYjA2LTY5OTEzM2E5M2JhOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdlNDUyMjgtOTc1\nZS00NDRjLWFiZjAtMzg5NzgyZDUxZDAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3V+AHUIcXkFHxvMcydD6d3LPwz06A2Pyo2iDJVuVDuhrl466+QQmugiDIxTL\ns211P3fIqyOS1kCUVSB+aQzUxaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS+Go8Eu85+dp3uMszCCxl63fhIUwHwYDVR0j\nBBgwFoAU/aHausplQlP2QD+UX+WL1KLfqg8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBWLIHbFbPUnijZL72eBEoZWGNd36IdOXgV/Aruc6NvcwIhANe5\nAD21g43YyB/F7est54NRc6zdYZqyjHf5bQHtoQ9U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATzeF7ghdsdDqN8vCsMPSc9xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTg2MjhhMy1hZWNiLTRjNWItYmIwNi02OTkxMzNhOTNiYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyfMq57FFPM9Q3IcHolx52B3sQEl3Q3gcjFFo7q1S9U3RY\nvXVokjOAoxEnZnk6hyau7aWvSXrLpzEJkBuxqFHMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/aHausplQlP2QD+UX+WL1KLf\nqg8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMsDUchzL+/VYumgk4VO8QCy6LEJTwE277sRCxKj9DyqAiEA1cv4aRtO\nzfugVs8+S6j115dH7kD1ZZ07kFaLj2bBNtI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXhKouhgxTQ+133zhhNz9KrDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdlNDUyMjgtOTc1ZS00NDRjLWFiZjAtMzg5NzgyZDUxZDAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjMwZjdkMTMtOGU0Yy00\nMWY2LTg3M2MtZWYxOGQ2NDg5MDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nglJ7oamj3lcXcMDZCfnUWp9Zwf48NmuU/9EtqY+wM0pMNlc354uL5omgiP04kR6a\nXFrV9lkyg1bME33DGDZIaKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUS+Go8Eu85+dp3uMs\nzCCxl63fhIUwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAZhf3L\ndeggWdZ+qsBPn9WXGL/duV6Qn2fD+xgdUxSE0gIhAIRzH/e9Fw08D1nau2d06EAa\ne9RL9LealfCcL1DlaRZU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8143", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8143` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISARDSf8J7MP4jts33LfwxdLtGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmOWM4NjA2LWM1YTktNGU3MS1iMDA2LWUyNDZkMjQ5ZTQ4ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY2ZmQ0MDUtZjNj\nNS00ZGZjLWJiMTktNmM4NmE5NTRmOWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf3GO/yBO/maCukgMVKHEHogd71aE+ydkosPIMLaqQLOso/4lQTLGmdmP0rjQ\n2eaRnMBSglLqJ0OgiixCrwsaYaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKAnwILYq6CPFX26VFgqPuW+wuZ0wHwYDVR0j\nBBgwFoAUrxyKr5ClXO8x5hnwVsjZ0kEfjZ4wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAh/93w1m74lH7\ni0GLFoE3fqMrs1vSkhB+uNnnljNt6NwCIQDP3oCWVUtQbassBEilok/YggtFO8QV\npySC10fU7lF1Qw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfHA69yEEMSa31h3uiFIVzoWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZjljODYwNi1jNWE5LTRlNzEtYjAwNi1lMjQ2ZDI0OWU0OGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPir1Y+XVyJPod/RatPS1wNMC03EYbBbxgP/e9e2ZBhbBI\nheAuEVVh1fs6eMNcUaOV/pIqiv0CcySZQDwp235+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrxyKr5ClXO8x5hnwVsjZ0kEf\njZ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgElrEypcKr31B6c70Z2S+nLFmy3ABaq0r2sPinFOXW0MCIAl8QkEKiHVj\nrvCutpjlUOvaZ/XD73AeWTwJkHah/3Jk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYNkHl8xDXABhVHOffYfbqulMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY2ZmQ0MDUtZjNjNS00ZGZjLWJiMTktNmM4NmE5NTRmOWNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjA3ODE4ZDgtMzM5MC00\nZDc1LWEzYjctY2ViNzU3ODQ0ZmI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWr3jPOXjTeK/kzvNkJjPNvBFTDwYtNPx/OWnEYlcT+CZODSyiXVrocmMaXBC+6fQ\nJfJhHOV1Xydwol9dig3bV6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKAnwILYq6CPFX26V\nFgqPuW+wuZ0wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiByk+Na\nb+z942Vl4YX8u++CeoctClnGhxv8w6Sa3PvYNQIgLElRwUI1pdM6/r/x2/E5Ohga\nYfdZcydOwu9bvCNjck4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8144", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8144` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARLyqV8dLoiwb/BC+jnw9KB+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3YzllODAzLTBhZGMtNDE0MC04ZjhmLTVkZmMxZDY4NzVlNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjc0ZDNhOTktZjcw\nZi00NzliLTk5MTEtZTEzYTMzMWJkMDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpwZrbKSa1Jx+eLBlRR6mbwKkj2TYdOaXPaEjJ61EWGJJmdo+yB/T69ePfwKc\n3kKoPIoDtjBhFyE6jcC87Uue66OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw7eTIqzZjGbbFH4n0Nea4+5sz9kwHwYDVR0j\nBBgwFoAU38AKTstPfSMRklAyvnEfXbDlUd0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCqxJHotmhmvnt1QaIq9tll61+rwiPXc5x7vthdufarcwIgZ3yabyRolhb3\nMa5VSzRxmNG4bTKCPBUiT0t5cUPua6o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaM0kRAu10BkMrUUZ/ZL5wzGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2M5ZTgwMy0wYWRjLTQxNDAtOGY4Zi01ZGZjMWQ2ODc1ZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARv6wQGobTwlVUxkd/z6HhrCBkyE7BdLMM48Amm69YYirxc\n5B7mbvPgMAZcyAxgE0JvP+9JKb7XHcrJrUlflo9fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU38AKTstPfSMRklAyvnEfXbDl\nUd0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUyJkn2VHEdNbleq6+uqdQKUsP0jRN903X5hvcFFnjywCIQCzXyWWutqg\nSosWUfhzdnd/nlwaqbuyaV1t1BfXWgYWqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISATgi7/3wUIy8l0z02N5IZHc6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjc0ZDNhOTktZjcwZi00NzliLTk5MTEtZTEzYTMzMWJkMDY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2M2OTc3NzItMGYwNC00\nYzRmLWE0OTYtN2QyOGEzMDFiMmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbi1nLQZ91N7vEc0fW3xeZBJ+MCC9BE0qASbLGVeJ3IjZ/U4IAUGhHGDrPEGT3dTt\nTIUNEx2xBGw9EXSnySy/rKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUw7eTIqzZjGbbFH4n\n0Nea4+5sz9kwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAmA6Q\nLKV0SFmsbMt1FIDzTpAIxghFoMyEHj3RBz6A29gCIFi+JlLRSVVFFLvIwVG/dAB3\nTWayqGlgWnT1mPcDL1l1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8145", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8145` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbu0BsdtGdEmRqjGCXvXNdLnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3M2M5OThlLWYwMGMtNDEzNi04ZWUwLWMzZWVkZTkwM2U3MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDYyNDhlNzMtM2Vl\nNi00YjUxLWFhZDEtNWVlYzUzNGExOTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETMh7PQYpvtMrFOPNHCmp9gR3XvHYn+KFfQUgTRXNAjc0qLiMf90uOZSPpBid\nY4Y+kEwYeNV5G/AuOTIB0wlMfaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPzV699F+v0Jndt7JM/9yF6lqGQYwHwYDVR0j\nBBgwFoAUFXiiz5JchJVg8pCseezcaoTbfMIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAoeNMzSLWo7HHZ3InEcbbs2jxOvGlV/SE8V6O5wOfVRAiEAmPH4iViKB9kv\nhCsZABpCjNnoqH4TQ7Rfhh6EyoIGRKM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYTZpvDZqeSuSp5JMeYzb1E3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzNjOTk4ZS1mMDBjLTQxMzYtOGVlMC1jM2VlZGU5MDNlNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTWTx72VtdnokeUfzp++2Oag6ZxXLqyA2NORlBn65RKHc3\nwfSSv/HYJEM7aMZYyzZZ34bgOfQZy0+HupyyCkHPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFXiiz5JchJVg8pCseezcaoTb\nfMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVhwI80sYDPxezqA2C/U5rzilmoRI8TUhZFGwQWyXMNcCIB+vlw6BYhtR\n1pgrgMFjG10Lt5GtFNXJsaRj8THNl56E\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAduJ/cT4Bq70BnJv0GtcrQ3IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDYyNDhlNzMtM2VlNi00YjUxLWFhZDEtNWVlYzUzNGExOTQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjM5MjQ5ODUtMzI1OS00\nM2IwLWIzNzgtMGE5YmVjNDYyNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfQZ4PBWt6X2+Nw/7fgZJD30LfrBpCb6lD/7SZSdcJ+rcSU8jAbZ8HeJi1V+rGfwW\nlGAm6ZnfmnolQu4S1EpjMqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPzV699F+v0Jndt7J\nM/9yF6lqGQYwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiA4sCv+\ntiO6A0OeakTTnYobeUZjKc2MMNvhCmbN0uMgRQIhAKjBGkt6P5mYe61Y5+pzG90m\n7zab1OD5RGQk5v7g8vbS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8146", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8146` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAYO03jnFqBqw4mHVNKvecl8NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NWM4YWE3LTE1MzAtNGU2ZC05ODk2LWZmMTkyNTMyZTVkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBlNzJiZTgtNjlh\nNS00OGVmLTlkNmMtMGJjNmFiNTA0NTIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIvTYb2av3EH/5A7U5yiXPA3BTBIAx2Upcx1iGBA7Cq5T7DBCku4q5+s/c/cF\nhUErlkuYf222NALMHpE06HedJaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmA0645gxy607DdOtZ14Ae3nKjKYwHwYDVR0j\nBBgwFoAUIxqqY9+PRqWAIEjzHLAyPGyTdvUwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAwgzUVu8h8IaYEzM5yDuqPdSiuBj2EsFTkouo+Vu4f8ICIGUpXihMqePZ\nVnVX4VjP3b24DoqD/CYNPu+jUPCuRNOk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcbuNCvzuItNiGl47jyXRk6rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTVjOGFhNy0xNTMwLTRlNmQtOTg5Ni1mZjE5MjUzMmU1ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9s8juN1ddpIqXYt+jdXci4XQNm1MhvTiqYiegtCrCqUmA\nuGFSGk0EEVENk2PXWtwi+lYl4WsIz0K2LbrFcjFqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIxqqY9+PRqWAIEjzHLAyPGyT\ndvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGo/hJuIS5kxCfdR7FlrJWImT6YegZIPPtx7Whoe2/tgCIQCAkjRqzABo\nwds2t+TFtyPXeNreuBjshV0E8DykdUNWYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAd+PUyIANRMhCx0QUvm0/QM4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBlNzJiZTgtNjlhNS00OGVmLTlkNmMtMGJjNmFiNTA0NTIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWM3OWE4MGUtY2M0ZS00\nZDk4LThhOTYtZWZhNTg0MDBiMGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ng3ZyFfhLF0r9HpYNTjFF0oMuzhX6C5Av53+DPbGSPw9bQleO7gKraNdT3zG2ek3x\n15EOtodGnOZ+SymbeG5tpKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmA0645gxy607DdOt\nZ14Ae3nKjKYwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAhmjJ\nX/zD1GwDYzbj3RHesQUQF5OGxMUr1Z/SX45n6RsCIH3YfSEOkY4lADDm+20sAuCm\nuHhCzV0n8qU2LTFwcBEv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8147", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8147` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAZ7suQ/bpHWVu3jEsV5Jnvr0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhNmNjMTM5LWMyMGEtNDgzMS04YmEzLTg3YjFlOGMzMDBiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI2ZjQwZGUtYTZk\nOS00MjE0LWE2NDItNGMzNDUxM2ZlYzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8gfYttko+V8y88BPeYEoe2hHZewU9oJWgtt+i5X80eTTHualy/Ewx93UMEdj\nw80pvlKpawirYC/J2zviBsGrRKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtiO530wferms+556rAfrW26uKtMwHwYDVR0j\nBBgwFoAUqVl4BJrN1LwlHMXpVUMxaKhMkkYwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA8UQsZes0ADT7hoIflMRw8yb0eCkgHZTV9XjkErBz\nMHMCIQCPUEU0tV1vTLeYW5WGwZ6PwE1fP7GUcduWSYLvkFJLqQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfW1DunvrJs06ck3sdxNxGDpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYTZjYzEzOS1jMjBhLTQ4MzEtOGJhMy04N2IxZThjMzAwYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARK5wwL8lvE5RGUprUnmZpdxEgnU8MH9V3wgTr3iLbtuhB8\nR/zyuE6OTbqqHwBo+S4O4zn9zkpUfaWd3YE8NaPwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqVl4BJrN1LwlHMXpVUMxaKhM\nkkYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgf6X8mozJhZBq6tRgPwTesLgz8M2DwZ0h4fzsBFFL6GQCIQCqKss5WeXn\nrT1ReeQHQc1xM0yu5KeSt+bRPSqsKY2N8g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAfdkrKSgYVTm6mxFcR0IUWmEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI2ZjQwZGUtYTZkOS00MjE0LWE2NDItNGMzNDUxM2ZlYzE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDQ0YWY4NjItNDE1NC00\nMDI1LWE5ODctNmU4YjNjZjg0YWQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngTPgbxyit4nj6UGb+4DqKRI0EWPsWzGbZzWgcoAH2YFKm2DUsV5rU8wOS9QKdA4L\ncc8uy6uPHawMPitq/ntulqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtiO530wferms+556\nrAfrW26uKtMwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA2dAE\noIAFcynPszKEfmv5CAHo6X3Rz+EqdPl2jHM775wCIQDOHHUiYWYDgkphBzqF4uWy\nWsqxwGs/b3almIrpj0AWxg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8148", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8148` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAWZ5rzMobyDVol52UROXCSUjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0YjU2OTc0LTA1MDItNDY0OC04YmYwLWYxZWM2NTU2NmM1ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBhZDRmNzctZWEx\nMy00MmM5LWI4NmYtZDUwMWVjZjllNDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuouj5mQTxFy0aYM/a9UQDGU8atAmD81I2R0ZVHmsviz5Rdov8+QTEY8J0XlO\nAozTbyjtPGoSVF0agFKPsfmDoaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJXhZHzIw4rS38rRQcYOqcZqg2EcwHwYDVR0j\nBBgwFoAURqooLsnAJyt2xmRwyPuyivmTZF8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAgTP+4tdhPce8ZL6E0Zjkrfh2ld0WEC0la4aPReFa\nQ/wCICt376BKjO4iQMELPYzi1Y5F2o+I0vW/zMOYJtdzuw5q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQT2jD9zy95b75JvFpsxJR1RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGI1Njk3NC0wNTAyLTQ2NDgtOGJmMC1mMWVjNjU1NjZjNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5koglJeJ9xsUW7+Ez+0kIRJuuKbewBl1x7w14eZGwQC7I\nzoplo/uYOks0ruE/KHefIEyiuOoLKQOxtn8GEi2ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURqooLsnAJyt2xmRwyPuyivmT\nZF8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFoKC/vMemifx+0lPOcfBHKTa7Petv2pkMz8zei2UIoACIQCW7Y0Ji3RW\nQC0kU3vIl9I5rXV9x+D9QOBKznc47Si9DQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAT29zWd53z7vPvWrLyZdVtdmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBhZDRmNzctZWExMy00MmM5LWI4NmYtZDUwMWVjZjllNDc5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODM4ODM0YmUtYWU0NC00\nNGU3LWE0NDEtNzNhOWVjOWNkMDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6twk3z5ImS5Q9fv1Ud5L6EDxeylsK4ceieSGjK7WGNgswk7enkSlFUJYcYn1sEMt\n7AM1ab/7YK4EInnF8vfsJKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJXhZHzIw4rS38rRQ\ncYOqcZqg2EcwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAO5Twg\nmeQJwhiTU8Xx4Nf/CO9cR3MxoqtFuSWIqDUQxwIgaoRWRbo+erbF2Me6q9ZDd+B6\numHUY0MoBBbnkl3Tg9w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8149", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8149` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAbtv1pn5azLC852sQHW70HMQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExZWEwODI3LWFhOTAtNDE0NS04ZjJmLTE5Y2M3MmYxMmYxYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQzOTA4NDgtNzgx\nNC00MmQ0LWJjNDMtNGQ3ODQ5OTE0MWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm4fzwEvs4BEyAfXOp9gVhfeNquKDxALcf9jloyvxmIQ2UFcW/Fi33qj1xXSG\nVMBlPcKwjBarrBkpWOsA6AOhcaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlzugUJL17frl8c0govQAbN/m/WIwHwYDVR0j\nBBgwFoAUJgw12/s9Tf3FWdiWsp0Nznf8JXswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA3ZOuHwtJU6+LBeKeRF7dWeQ+cS78jH+Z3+Byg7+tZv8CIQCi\nVuLY21ng2UZVzwCLeeQ99gTo5RbLDfEvI2Ww9/syaA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWve/U2c1K7dWxdqFjQ0wZ3vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMWVhMDgyNy1hYTkwLTQxNDUtOGYyZi0xOWNjNzJmMTJmMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHflqcK+7QpT17c7diy/wFZMXdfQW3KUvHU0rjduF86gzZ\nCGEAHIdE6cS+NobVQ00Eq0m7cziHD0V8jSDxJ9WAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJgw12/s9Tf3FWdiWsp0Nznf8\nJXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJUJNNcd6fOr/5eOHPfP54jDTCH2F1ojOgnB/DauizEIAiBG2bRHSLcA\nkVVRTlGRxXDXyLRSQOv7nkVZjxnrvwEHMg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISASi8UKYmQY6VL5iJR3L4QKP/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQzOTA4NDgtNzgxNC00MmQ0LWJjNDMtNGQ3ODQ5OTE0MWE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDdhOGY5NjAtNWM2Ny00\nNWIwLWExNDUtOGEyZGZmMDdhMjM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndg7CfzAgbdl8TLsIQPw/sJOaJsVTfrIbh2mJecCztMWrwC1hdpJzZFPO84EpppqP\nkXZpg+DAzR2j/qug2c2hw6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlzugUJL17frl8c0g\novQAbN/m/WIwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAgRKiT\nJ1pDfb6NBLgqimetXIAi1QbxGRGFwyBBqipZ5QIgPjGPmaUSupElOsUN+XLSIpO9\nPiTjxwk2/ZmaEylDi1Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8150", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8150` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVxe5x8ZDcAmF040HyzDziNuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxZTU0MDliLTY3ZWYtNGQyNi04NDhlLWY1MjQ0OWEzMjUxNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdmMzVmNWEtN2Iz\nOC00NzkyLTg3M2QtNTBmMmRhODFiMWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhJwx9u3EJnFk8H2cplwvHEjG06V1y4Qo9SGHqUbl7er+ypEoGYxFp0Nn2h8B\n+sgULXprHprHAgS3UaXWg52HoqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7ngzm+Cv3Dl0+HPxa/rudL+D5CEwHwYDVR0j\nBBgwFoAUeCUf9yuH1Pjv+eTt3NpvEuKS4YQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAtdyYoKeq7lcHg1d3EMreLiVT1+3/9Vwh\n58it12MKIcYCIGCUlnBj59R9nhxKA3ePRg3tYf/4DabTae8+Ry8RoQBp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX6LsfXYk6Kxrp3GQOpPHasrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWU1NDA5Yi02N2VmLTRkMjYtODQ4ZS1mNTI0NDlhMzI1MTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQv0WzizbYWRBtWMP0vRRskabVu1Wrxnsmc2mBqr4TxpXQC\nhZBME/pHY/mglDDbOEFJm0qAYb6UEQxq4nx7biaVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeCUf9yuH1Pjv+eTt3NpvEuKS\n4YQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOW0lZBiDX6qgeBj8RE3tMz9214p5QLTJuGWc2OceSfRAiEAvXRIqclq\nuBxJbbQNVwHzkTQu2wMRMKUSNhRmjb0w6Es=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAZmuDGHoBYAVVC5VPQ+Z1m3ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdmMzVmNWEtN2IzOC00NzkyLTg3M2QtNTBmMmRhODFiMWNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzJkYzhiOWMtZDRlNi00\nNDhjLWJlODktODZkY2FhMjJmZGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9oqkBUiYvtDEWk9paCMW/D9V3L3hKcXTwAsRokfI6Smy5E39yu6GTElj9P0+OCiC\nkW5mKsqt3UMMXg5fxly086NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7ngzm+Cv3Dl0+HPx\na/rudL+D5CEwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA9j+w\nY03Zx2FQr/6NfSaYq89gLsQVMcmx23SS2MhdFdoCIQCPy5vutjPehh+nuIsjE3/l\ntN1UnEgBLpMbqnn8Ycy+Tw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8151", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8151` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAVVvQ5nXDf5b4OlEG4ZWhe1aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0YTc2MDc5LWYyM2EtNGUzNC05YjUzLTUwOTRhZTMzMDFkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZiYTFjZTQtODIx\nZC00ZDAyLWE0ZDctYzQzM2RmYTZhMGU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECttvw97Dqx1cPeZ4WLvUqnKRnwuXZ8rdmjgsYJmuMYDy60zXsriFVeIE1SQc\njqc2UGDV9OJFHcvW0XyWktMECKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURxE3DF9xnoGX9WSeVPuJC/z98ggwHwYDVR0j\nBBgwFoAUUUHSVNsrgowbqTn7+R9FrNhTeLcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiADIPbh6huLUMaK/adiyPvqzRP0aCBhLE80\nXR7/zEPbpQIhAP+fuEOulMZhdBRDDP+YcAk80vTgD1A6GcmTjHN8oWuZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU8aMI4EV9NPP4EGfSx9RLGjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGE3NjA3OS1mMjNhLTRlMzQtOWI1My01MDk0YWUzMzAxZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNj/22qLorSSaSSKHu190AdpUaftqfKThHUnHJ98ghFxoR\nRWx93tAECplIG+2TajmfPmVmlA1C2FZZ+/+KErCuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUUHSVNsrgowbqTn7+R9FrNhT\neLcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALE4J4pkawJnwpzuHS+fPV4FgBHbET3QoGe1OvqtvasYAiBiyVknSKR7\n8CNWcGjO3D7dR1/cVeGwDIC+RmsiT0juNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAWbsOurIkJQX608q83MOtIDmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZiYTFjZTQtODIxZC00ZDAyLWE0ZDctYzQzM2RmYTZhMGU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWZmMzRlMzQtZTcwYS00\nNzM4LWFiNDItNTcwM2QzMzEwZWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nIAB2kpL11WBLQCiPBaDXigNA5frjWjJDG5yKmUCH6zw/mjYn4dseyQ9EF83YhNVx\nRVIPtyitMuDz3/iAbW1RHaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURxE3DF9xnoGX9WSe\nVPuJC/z98ggwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAP9x+T\nUasroacPA8dImj3OcwMkCWP606v3n79R6gnZfAIgSXgarphg1ZVe9O2qi92cblvx\nDs6XKJLhZDhdCvAbrjU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8152", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8152` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAc0/CklfUGucPDX/exeYZrJsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2YjE3MmY0LTMwN2MtNGEyZS1hMTZkLTM2YmUwYjhjMmM3ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRmN2NiMmMtZTQw\nMy00MTA2LTg5MGMtYzBmZmNmNDU0YmJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEierzNV+bnwdyObci4gWaRSRf/us0cua3kfzWccHclSeU+V1LQBVl/P5cllcx\n0MwZ24If5DLyzBsuSZbxAdHa0KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsoU/fizOrQyk/KFVHr3OVOJZAHQwHwYDVR0j\nBBgwFoAU0HJsdfORz9JAwAv/39c4+CY3XEIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA8ZiqB4HorV+J\nY6IFRqKqE8F7d1PmcDZh0A9b+MNRQNQCIQCjzeHMT9lYOpx1voiSiy6Wev1wgIIm\n+nSaU6htOupWDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXrMLiwuAu9b1T5G1L/nAqLOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmIxNzJmNC0zMDdjLTRhMmUtYTE2ZC0zNmJlMGI4YzJjN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBpAFranKP+bCIUMTeSdDUMDFlAxayruW90YT3SA1qnluS\ncn16Ku4wg56qcgGn2A72tPGSIP9h4hj7I16wj7A+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0HJsdfORz9JAwAv/39c4+CY3\nXEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMhxB9+Xtcms55oFyYgUY4zbFwmlUgNK1bAvWFg1vg8QCIHzbx6ma6hcc\nWOjrsAGkWdSKdKtl3eTjul8/q5qkfCqF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAaCDP1QSVUx7xR47N42SZwcYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRmN2NiMmMtZTQwMy00MTA2LTg5MGMtYzBmZmNmNDU0YmJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWQ0ZWJkMjYtMDhhZC00\nOWJiLWJiNDMtMTZlM2U2NTliZGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nD82k8jvGGsUf4jO6kEUxbaB/pJbCiQXH5EZIIjahvxNiSXWysuEDMZDBvESMurOJ\n5c4Oh61NiFjhWUx3Nrk7EKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsoU/fizOrQyk/KFV\nHr3OVOJZAHQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAR/KAP\nfYrtzc04nJ/PoHzvP0IBxVe4mCh89hgLaWNY0wIgEVvrFluHn6BhrgFB2jFM8XMz\nKUGzYzNKbYBRwLrtV6I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8153", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8153` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAVoKr0lqOmw/bR0itw4wCug/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3ZTY0OWM4LTU5NzItNDk3NS05MzI5LTYyMWI3OGQ3NjIwNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQzMjIzOTctOTBh\nMi00MGE2LTkwZDctZmYwOTAzMTFhMTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ99dsbtViqJs+oDKVcAR6/XjGY5JclYcQvD8/aRpJ8LVTXP3EnpFmY6voRRB\nSueJVnUmyxJCGGDfuvtlFzNy1aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI2Yj/KgcnzC9azGQujzh8q4o0v0wHwYDVR0j\nBBgwFoAUX1+uZl2B6RGTCBhR2hYKEb09YSEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCUENyR7v8nE6U7CJvgOQIRiysTcbHOc1qTWCJRHhJN3AIhANqyiMkGWnJh\n5I7aPaYZWvHuwkqoVFlYnIe1+2ysMRh1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAboUo+1OlAqXKEyvUd+kDqTXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2U2NDljOC01OTcyLTQ5NzUtOTMyOS02MjFiNzhkNzYyMDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBnWnnEUHUz6OYkEEG41LBNd895spC0B5UMOztmt3+wPTN\nDlEyEdCiVJskIqv8ekK4t5nFpCcr8OTL+twYEhEMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX1+uZl2B6RGTCBhR2hYKEb09\nYSEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPZD6D0yI5c3xoO+tsJ6PgsYRrTCksPfO74xl1D5VVs0CIQDF/GhR1ack\nqULCklT6vjuWOEIUslsQ89DLaTCGCHyb/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAY67DatnqycI7MaElQU72mR5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQzMjIzOTctOTBhMi00MGE2LTkwZDctZmYwOTAzMTFhMTRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWUyOWRlZGItMzIxMS00\nOGQ2LWJjMjAtZGJhZTNlMmFhMGU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\neGTr17zHO9tURI402A+SQUtQWqWBL8yVjGUdXoBlHKgUsWBPvd70SelnsAebVmq0\n+hJJ31Vw7ueWBqcuiPYtX6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUI2Yj/KgcnzC9azGQ\nujzh8q4o0v0wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAwSXV\nnp7tdDvBI7A6MNAhDn/V30T5ifxqLxRUfmcg3eUCIQD1cDj4oYHR4Owhuf5E8ro4\nnTCTV7BtqlXLT4ybP4EAYQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8154", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8154` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdk9VQ+Lyr0E0T1MmC3N0tEBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkOGUxMTYxLTIxZDAtNGU4NS05NGYzLTI2NzQ5ZDlhMTdhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE5NTQxMDEtM2Ey\nYS00YTU5LWEyNmEtYTQ5ODQ5MzIyNThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4Bct2bk+eEP/Ep54FlinbaDy8hna1wUtLhT201z17mKbdsDnCS9o96A7f/Is\nvhRD1tpsXYoIEsz5V1M5zslll6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOzdRS0AwGtKgZ3zhnRUximx/BRcwHwYDVR0j\nBBgwFoAUt6f5Oml+U793qXccsEIv3oBtaI4wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICDUkxAUAnHwMIh4qbdVZp8wcqGLfrvKw8ekkBaKUUFHAiA2LaqNlyvDfoHT\n31Zhk3q/guSkTENphohKkKpgbpSKRQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT+h0Q0xWQe+7UqkK450o94vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDhlMTE2MS0yMWQwLTRlODUtOTRmMy0yNjc0OWQ5YTE3YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToRuyIbbapYnbIL9FknQ8Qn2sPRRICaMyesUR+PR9H8uHM\nHX1BMcXVfAsGfKrjmXddwc06ifF/zOeKcbM6yXeIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt6f5Oml+U793qXccsEIv3oBt\naI4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgI+mjzCShwjRUG+LY8WLWbtzgGf6vrZKRc0r0IL3MCEcCIAhF188Pu2z0\nuu3LaeAORh6BsPfsQTZkQF4x+iD8xGYw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAT7YxTnh4ZoL6Cc8KzObFC2eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE5NTQxMDEtM2EyYS00YTU5LWEyNmEtYTQ5ODQ5MzIyNThmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTdkOGRhZmMtNGEzNS00\nZDhiLTkwZTAtNmU4ZGZmMDg3MTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nePttx9a2kV4aMcGRHI2O8uOT/kPd3MKVJ8tvRk5EBWWoHAVFiUAPEqHcClL5Rr+b\nwtZRRgVn2UZWGD8g/9hGYaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOzdRS0AwGtKgZ3zh\nnRUximx/BRcwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA31sl\n9YPlcEBjY4bt6YilB/NTfiUxUK+r1KZEiSuavgoCIQDh5w6R1gsn9bcUCcL0M9/g\nMTR55zf3muTi7IycDTjoPw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8155", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8155` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAWo+BVxc874otV+Ut0lYTY7HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxMjU4ZDllLTMwMmEtNGMyZC1hMmI2LThlMTQwZDRmZTM0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTJmZTU3YjYtMjE4\nOC00Mjc4LWI1ZjQtN2YwZjYyZTQ4YjZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeQ+SQ8qpUGLK4QL9RQXG9CypghsPVrS2t1+Y19s/ly4luvMQZMgkMF6hLL8N\nRvmCHCCllFpYk6C40I285MchqqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2JAKOKOaKZLf/Q7Ydp6cJaztTYUwHwYDVR0j\nBBgwFoAUVfLE/AW/Mqqba3GhV75aEkgG1IIwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAlo6xEE67iEnwUQPveMLpSM68V2nHEJN0ARGrfJU8OOECIGahD0Zazw2k\nQ6OAXZk1qpf75qQ26OLm7ECjMajxk0sf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT4UFmpdA3f+0gwJxEhxVzqDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTI1OGQ5ZS0zMDJhLTRjMmQtYTJiNi04ZTE0MGQ0ZmUzNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMpfB57xfDkJvl3OVHm4WnEkxuOAc0BhhmUw/D/CvhRH73\nPmDODpqoKF0W0zUi+rGR4ostJe54J5Y/duZLAYB9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVfLE/AW/Mqqba3GhV75aEkgG\n1IIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQdKaFcyxn8gbAJAWzH5o/brN21O9VwXBppEnV0Cn/ksCIAY3VgVoex/M\n9zt2cDDxRUJ2AfEeN9KRThQh1+tDu7Lu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAcBrjdeLJiQ65CGRw6royyIMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTJmZTU3YjYtMjE4OC00Mjc4LWI1ZjQtN2YwZjYyZTQ4YjZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjg1ZTZiM2EtMWZlYy00\nYjQ1LWJmZWQtN2NmYjc2OGI5OTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGG6Mnua9Xpq6167VqRez3ZpseBx1VMkcOCdoRn17yVmVF+ENAEEhtAr2ne8FYlAg\ne+O3S2wp2VxweL4n4w9egKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2JAKOKOaKZLf/Q7Y\ndp6cJaztTYUwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAwSzb\nLTEYDHMO30YZvRZ0l1s2YL6n7VafNdNCPfuRRdoCIQCffTkhVL6ndLhG+b/Or+5Y\nlfvh4m+1GaD/D1InoanePg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8156", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8156` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAf7kBGFpVGmqGiOEqAE3btbkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0NDJhNWIzLTJjZDMtNDg2OC04MzMwLTNiMTcwZjllMDBkNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk3NzJiYzctMDMw\nMi00Y2QzLWE4N2EtN2FkNmQwYTRjMjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+SQh2LxILuJsPuHYtEzaKEbhHaDH/COOu5EuQ/ixR7srQu6hQ9MBiLln2oHc\ndIwNBEeQHcJYKgP85Dgv7wRly6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfsLdJV28nY1B/ZE3hODxaHAdRREwHwYDVR0j\nBBgwFoAUONCrBu0A8G0Wf+tf9Vgs36Qr/0wwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA9kSKeqC8BEqehAD05KuXv2egLoZf2MPHV0QpXJud\nbXECIHit9Pbl+zBeyixTINl7ZrsM1Hbj4j9rpt8dAopsJNhK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdfmdbHrQ9MJi/JBLf4kBsxaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDQyYTViMy0yY2QzLTQ4NjgtODMzMC0zYjE3MGY5ZTAwZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZ6wF69sTMLHmOUncFgHqg4pU3wgGgLCy2vi4aDlt4Ri8w\nT2QMk7Bo6vKc/cCRmO/7aWSDIxEwkmnK0ku2lITmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUONCrBu0A8G0Wf+tf9Vgs36Qr\n/0wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIpLsr9HS4lODGVGFmbklH5Sp3M5wkkns7xIwb2cdX5mAiBSJhcIexhG\n/va1If6ih3znqCcrsW4M3EZAHy3Pn9mvgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXore1Tgn1+Y0fZR81m7HFi5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk3NzJiYzctMDMwMi00Y2QzLWE4N2EtN2FkNmQwYTRjMjQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjRjMjg3MjktMjU4Yi00\nYTdmLTkwODQtNTE0YjdmNzFmOTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFABmRv96icZsgsK6QcMUEhc4u45Czt+OB/5oOKrWqctCw59viKYQXAhvvfW7a8bZ\nL1hwtL0HBcTkPEP9Qk7UqaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfsLdJV28nY1B/ZE3\nhODxaHAdRREwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBsL0cW\nK3mvETSB9efO9KovXHGeMV/lUNPAYQiKAsX75wIhAMrzB4QjrBojYUeoSosnbsx8\nToWbW0i/Yie1C3753uLx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8157", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8157` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZmyMg2oBe3ToL4omvyMfs7jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhNGYyZWMyLTc4ZTQtNGE1My1iNzYwLWNhZDVhMWRlYWViZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWVmNjg1NmEtNTIw\nMy00MzQ5LTljODQtNjA4NGQ2MjY5MDI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE46dOVbXFUkiCYrb9c/EwwWqBRaAhl7lETuYUWIUICUq8FTUdst9CnWRwCtU9\nPQQfLd37tb1fVnLpN+tZfWBfiKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqPnPxMrEXh9ut/aCTdS1rrgdGEcwHwYDVR0j\nBBgwFoAU6ss9vfYunbdP3vBKcjoupy9AwlcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA3yqwe5CMM6I8y0LrKVcBLy4JqIoHY3kiXdruOQiV\nQ7kCIE54Epdp7Qn4UX0l3yCDN6JPjJ3P/BjH4zhdJYmDlW4I\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaiD9Ka1mK968+y9EQs0WO4mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTRmMmVjMi03OGU0LTRhNTMtYjc2MC1jYWQ1YTFkZWFlYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYkANDVFELnabSRaOIiivFWdAjx+l0Nu5CgcRcsa/misnN\nFXkFpPjpvY/GsFn4z6aHgdVNTdibAiZl5/uuo/TEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ss9vfYunbdP3vBKcjoupy9A\nwlcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJeMhyIBqiCrhgqe4CQUrIxcGbTaa1hEu4bDs7Kubm7mAiEAmF0moBLd\nMl5YYec1UX5eQX70ueQqdq/OxIZF239QRM4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISATIsQdd5VCx5z+oXRBkS9wcBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWVmNjg1NmEtNTIwMy00MzQ5LTljODQtNjA4NGQ2MjY5MDI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTg4MDk5YWQtNWRkNS00\nMzMwLTljYWQtNGFhZTM3ZDNkZDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\naTEDWLlMRbWhs1cRoRD4XzSRtqO+v9xJ9VrdjOhAdjcwQKmqznXwL0o/kHzhpOme\nZb04wV26PSfgi466zm/RLKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqPnPxMrEXh9ut/aC\nTdS1rrgdGEcwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA1XVH\nZ4rZA+twCU6GHglcNS7vfhBs+GzWHgALbGVDoboCIQDaoeuuNSWBlSUcNts2i9+Z\nuRF8Vj42rwiEwVv89ZrO1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8158", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8158` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAYvsFU41rf46pfIYMJVr8MdNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwYzZlMGJlLWU0YjQtNDQ2OC05ZDVmLWIxY2QwNGJjYWY4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ4ZjI3NzktYzY4\nNy00ZDgxLTgyN2YtYTY5YTFkMGYyNWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPYgCESE4nWLDaUv3QKDhD8mSyIYyN9z3A9cC0Zj2GODMufBFKRY6eyzxLuqf\nZYLhQiWpoAYputioFtCnMzYUZ6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9+U/8m9KICUqfD/skBxNedpHTf0wHwYDVR0j\nBBgwFoAU1HsMkxAJqgullvN2dJF115+BjRIwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEA11BCz9j5qsr+mP/s+m0CiY5JmNGieWN9f0afy7joIEACIQC8\nwXz3+byCDWrvayNEU3xcL/FZwFKVIfobuaOeX8an1Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfAG4Jp3mUm1mmGdS9PjIf0aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGM2ZTBiZS1lNGI0LTQ0NjgtOWQ1Zi1iMWNkMDRiY2FmODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOH47teywdh5Rn56lowZrJ85XrERT6gRRf4JClRc7PXHMh\nUH9HYWg+14NLq5hj7gY73FKpxo3Ob4jXQYpzLfXEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1HsMkxAJqgullvN2dJF115+B\njRIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALq/FTYU8L4hHcTsTfZP2/589irJOZV7HxYglmU+SwOcAiArGDiu1hGq\n5cCTtug6W2nH0SwjWFQQcBHvQ4Kx3MnP+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASJZ89Jd/HHN6I/he3cjaZN2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ4ZjI3NzktYzY4Ny00ZDgxLTgyN2YtYTY5YTFkMGYyNWNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTdmN2QxZTgtOGE3MS00\nMDY5LTkxMWYtMTBiN2MwY2U3NDFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nutRiCAHRDl/WPpdOBB6ZkBXRInB3egLkt4ZRh0A/0zm+qSG52jD1+jDO3sXQydoM\nihgDZ8MvCo5w8rKOFOTiSqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9+U/8m9KICUqfD/s\nkBxNedpHTf0wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAk4nL\nLnwPQ6phgpXbMfXjDof/fk8XVyjVtEyUbhwaK2ACIBI9qyM2Kv2WXc6iH4VyIKQE\nQVKY+bY1nFc8KjLOySfe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8159", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8159` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAad/j6q8uakZlizLFOtj5WWuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYjQ2MmRjLTcwZjYtNGZiYS04ODMyLTBhZDlhOGQ5YjY1YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRmNDMxY2EtZDk4\nYy00NmVlLWJjOTctZjQ5NTYwMjg4MTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi8wblYKILBJ8XCLTm7st70jCVLJJOQ75aiozwzE/1MVdXsmCwBCdK1abSmJk\nvEm2CQ3U7eZx/p8XdvWX6DAJ3KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxUiqChnfZDSmlAp2jAgrwYo8vm8wHwYDVR0j\nBBgwFoAUlYg3nxyf5kcpPHaE0J+DbDyu7UgwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBg5l3ATbfKN+XSNoaGyyococdILYQKkHpH\nPvnrGC/GdQIgVOyUCssWI8OaD7a9aFNaMAemuhpG+iMwL0bAxR/PRt8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYOlSdBBdvwz2MGFQtHRzPIkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWI0NjJkYy03MGY2LTRmYmEtODgzMi0wYWQ5YThkOWI2NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2J/UASf5bFkqveEVkI6mH8VuWrE+2MuBhafpDdZNBrEox\nyD/nQ1NjZ1E+0MTx8kSSS/YiWBi1zyiOgi8zgtino2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlYg3nxyf5kcpPHaE0J+DbDyu\n7UgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGKXEKw3GcmcyaBCeMbh7Vh9iybxuQ2wPLjlyqg6xo9wCIFeb2p0EjlRM\naWAJtmXckUzt8oTYWRkHwyxUDGcM+ncD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAdwHsL1UmLKD8Qzr8KyC4ZOqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRmNDMxY2EtZDk4Yy00NmVlLWJjOTctZjQ5NTYwMjg4MTFhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmI5ZDU5ODktZjRkMS00\nMjVhLWJiYTEtOWNhMTdkMWU5NDM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZZDBTEy+8X27oBzEvEHO1Hdg3JfSyomRH5Aw3enzP2jxFlF4OIDICDfJTKTAVPnH\n/y/tJiQN30d0Gf0QJUz3PaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxUiqChnfZDSmlAp2\njAgrwYo8vm8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiB/lvNx\n/Ya+gAMlY63SZM5lP2+xY/GQyQOT/D3sBN+atAIhAPUU5XHdh0DpoLwQz0UPCuZn\n9aGvi3aELGecJQxw9s04\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8160", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8160` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAS2Gg0h+JylWpbq/6h9h6YLnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1ODZlMmFjLWY4ZjQtNGZjNC1hMDNiLTkyNGY2ZTVlYTFmNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNlMjVmMmItZTVj\nMi00ZTNlLWE1NzQtODZhZmQzZGJlMDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZtVuB/zrpTWBG+G+3rK1HBeHBRLRBfDE3EY2utFX1JID23+zNisFHp80dnT/\nRHdgNAHPm9DQTtOFnJ/Xr/LILKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAohvbq+OxJ1ApdtYBH1OOA710uwwHwYDVR0j\nBBgwFoAUqjDJbhCdfC62AWBxlqAg380zdjEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiADGzPhlwOZgaABb9nraARJY/yMOHDOIKzG\nCPS+SFu45wIgdxahpUeHWkZwAg5AGxIyOX502nVAEtuP2CFYOiOoKKU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdnbPpe/VY9Y69ZYtmiGrtrlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTg2ZTJhYy1mOGY0LTRmYzQtYTAzYi05MjRmNmU1ZWExZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNDjI7TZH0dx13ho5BdgCd6EV3v7fG/Smuy5wcsc6FyGPH\n67IiIvXDR2nRcr/hg8bpx9OlPGyLGVypHUIYk7qho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqjDJbhCdfC62AWBxlqAg380z\ndjEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN3tLJCBe1awTU47x0h0PfSusUpui4RlWawSYTktNwD5AiEApTKmAihd\nqiiVgB5bZL4Hhp0x0t6cxE5EdwGovshALus=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAV+8Ghzfk58L9FdYA5/8pff1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNlMjVmMmItZTVjMi00ZTNlLWE1NzQtODZhZmQzZGJlMDRiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOThjZTBlYjYtNWVjZS00\nODg2LTkyMDctZmYwM2E0MjZlNDQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBYNNdEE+dF/JKh4ufUD9EZ0413q25MorhJ+aO0pxGIofizq+0fcGuaOcn4Rmm+xB\nGRz5RHYIcLj3bUTLckYT5KNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAohvbq+OxJ1ApdtY\nBH1OOA710uwwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAy4Z7\nW3d0n8Vm+pViOIUmsAcyI6RQ6o3K1DTYF90DPzkCIQCHdII0MM8yARycf6yfrfQE\nRJ6G7BVrOLgSoWv22VJLXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8161", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8161` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAbzvySZV0HJlASOZlKZwhSWMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYmU2ODFjLTE0ZmYtNDYzNi1hZjc3LTNjMGMwYWM0YzlkNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzViY2JlODQtYmE3\nZi00ZGQzLWFmZjAtMTUxZjE0ZGZjYjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGs38w/o3MSIyb6bPZbcnIJm5uQQ/pAApv2g5DeChdSgtATdNx87T0fqdiqjR\nVlxKwzat6W0FFmGua1bRywQvdaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5iVq7O50KsTd98Si2d3IEnLaeM4wHwYDVR0j\nBBgwFoAU8FxHcGkseBZxf3Or6HxpEzZ/C/0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCco+dVhwikt94+VZhHBFrAEG44\nw916AkVLf9QzY3l7wAIhAK8/JUlIBiidLWstwgihgavDeUaC1uO2/2E7CjNBsa9w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATgSsbDuPWUDvUpdHAjsAq2EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2JlNjgxYy0xNGZmLTQ2MzYtYWY3Ny0zYzBjMGFjNGM5ZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHSrdOH3/uDjuvf7hgCyVEeSRufWJHymzaQVakHYbioVr2\nzlpMVSsyE8rZDsKXmDJhMikPIAKyp65YaBkBEqvBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8FxHcGkseBZxf3Or6HxpEzZ/\nC/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANNVDa7mIW4L/yCAO1NS+ZSmMqZOmXyBp/oNItZvSQIGAiEA/YfE48FM\nCncfhVGuYq8P22FOCZq7unv/HLdBA/xTy94=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISARQcacHFXSgabaYD6vgNjCqdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzViY2JlODQtYmE3Zi00ZGQzLWFmZjAtMTUxZjE0ZGZjYjUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzgwMWQ5OWQtNjYxYi00\nNTA4LWFhYzctNzY2ZGViZWI4NWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndY2UBzV6kj2wVxDcQwG9NzlpHoKuGR34BgSxEPB1U7Qf8u2GuNuC+7GjtwYmGz8U\nDIUkCqTlWxYyKtR86wCdNqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5iVq7O50KsTd98Si\n2d3IEnLaeM4wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAtqYWn\n5sR0hwwjLWCRejrFi0Urf+mO0RompNad60+rOQIgOO/uWz0Kk8l+zDnCxwV0wFKb\nLSQptrKcWhNIobawkgw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8162", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8162` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe+gAwIBAgISAVdXLgHMqhFFvoXziH92ua3hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2MzBiMjUzLWJhYjgtNDFkOS05ZGNlLTFkNjY1NDE5YzVmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmVkZDFkMDQtYmJj\nNi00ODIyLTkwNGYtOWJhZTA5NDdmZDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErNOcR/uM3prqSiSd1QuCAAqdWgzS6NvIhvi4POaxStFnd++S0SGmxOhRtU4r\n6VAze+HMmZbEw2DswrToTatB+KOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU8XBHpitpRYR8UhV59vvA1ozTtQwHwYDVR0j\nBBgwFoAUhEgqhS/9TXFsKxST0Qjdwj/Fj7cwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRgAwQwIfTtzzYxVU\nvwkKuQGkpdEBbF9gZJjtf0J/6leXD5zsPgIgP0Wf//2yqBYnwpQtubTVBO8LjNxM\nZLqLKJK530omni0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQZHmcSdY+u7RhIeOYqTzUZlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjMwYjI1My1iYWI4LTQxZDktOWRjZS0xZDY2NTQxOWM1ZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBEEj0dL0TBWsXKeIJuEQF/xGflVxCZOHD7ELgiO7bq14R\nlou9Yo7tCm73NQ8VL3qocdLkpQLyUlSaBYel9f8Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhEgqhS/9TXFsKxST0Qjdwj/F\nj7cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANu2p9RkIYHMeK+BDTSUclJ0N8A1KKyPMqp7EUptawgDAiBxOmiqGycR\nj/AYyJBmfQEoZA/EeaYT1cNZUx2wApQSIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAbm5CGHFQhspk4fF0aaPyWTFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmVkZDFkMDQtYmJjNi00ODIyLTkwNGYtOWJhZTA5NDdmZDIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDk1MGMzYzYtY2Y4YS00\nYTE1LTk2YWMtZTM4MWMzNGM4YzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJbMinyV3zCiBbgQLd2K3PJkTsCOGkqX/eZFROpEkQ2FsfUfRaGEew6PpBd8sQHRh\nTk/RpMbUK5O0rgrlSDn+waNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUU8XBHpitpRYR8UhV\n59vvA1ozTtQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA6PoYg\nwB+J4km1Ni3DInytj3dyEw5j3jq9mfpB53MUZwIgOioI6JtbWCD7RwfaldBxCWf6\n+/VT6dMnDCEI25IR8sE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8163", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8163` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAbOWTCPH4e1B0DDM+KmvT5ckMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMjk1NDA1LTJhMmYtNGIzOS05OTVlLWQyMWI3ZmQwYTViOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDZlZmI3NGUtMjVk\nYy00YTU3LWE1YWItMjZhNTA4YTQ0ZmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAkMOoN/CSKPIMoDIQKD+Puq9xJ0nqmC7IJcplSskGpjbgEJVRyJaKSKwZm2r\n7eUmuz45KYp7EZZJqm0l+9GAwaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj8ljF0A8Jglv2YjPEmPyZT9RxHkwHwYDVR0j\nBBgwFoAU3OjSVcg95jTJqooIbdQkDB5SPDAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMmzwN9L\nSKoCE173FJRtJfn4fIte2BCS6JmKJW1GFs3DAiBrKhOpO+FyPtbuksnQcNv7YMWp\nzdNx2lEtTysqzloZaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdJHaVLdekQ7cHdEx4nn9Zo9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzI5NTQwNS0yYTJmLTRiMzktOTk1ZS1kMjFiN2ZkMGE1YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbVE0NO4FrrQrEXNTCD6WVJzEeJleeXqbS9nfUiE+Mw88M\n1+BmuVR8r+GF00DVnvMnIMkIXgTP8TH5SdmECBt1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3OjSVcg95jTJqooIbdQkDB5S\nPDAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgf1yGYFZFvCR8584UIeyam4Cmlodlfc2EaBO8fAvSd6ACIQCh7kHbwp6X\nP2ut/tlb243UqHGNqvAeH8CFPwNqe2LLGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAcMvrDOQmeW705crUozJiOV5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDZlZmI3NGUtMjVkYy00YTU3LWE1YWItMjZhNTA4YTQ0ZmQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWY1ZTczMzgtYTFkNi00\nYmRlLWEwOTctZTljZjk4ZjQxZWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPF7yHzJc6d9p9OmjuLiOMtv/NX/BTOOIVkefeJ/dD99l24N/+/z+BreU6Esyfl7Y\nrXXc6+ITjCeNeuG+vLTpmaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUj8ljF0A8Jglv2YjP\nEmPyZT9RxHkwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA4XuL\ndqAYgdGLXnu7CNldygIBOpUgLMCFXVSxCmiYU1sCIQDcjvbuJo8f8KU027zKZM8+\nh42X3Yq0tIBjoGSVaj9iLg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8164", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8164` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISARssS6zGl4wY4VhIOWIrP+89MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmM2Y3OTdjLTQwYzMtNGU2OS1hMmZjLTA5Y2FiMzI0YTExMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY5ZmQwNjgtZmJh\nZi00NzBjLWJiZDMtYWFjY2JhMjk0ZjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE49yx78X2F7QRX6Gfri3DR/LYOqhxzgeqcAy+JhELsfBqSA0y+M2dynLKATps\nQuG3ZUsFSZ70vDoxDPXBeaOQtKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULZzRsYbWeq0sDhh4C2r1jv9MAE8wHwYDVR0j\nBBgwFoAUYiUklQ/S6dnqBkmqa10duBLZG2wwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDGE1uJ\nWpthGqDs6PgZpe9RpK4uA9B14oQazcFiY8V2ywIhAM6bWEm1xHX3jXcNpK0G1zJp\n4KviVKsl40ryP0qCvqO1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdokXciDSTLlys7UD/Xzb/K/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjNmNzk3Yy00MGMzLTRlNjktYTJmYy0wOWNhYjMyNGExMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2UMm8rk9rJIQlGem1ymHT3ctj4XdDVZU5+YxH3LUhDWj+\nlkqybjnmDlsffpKlLjxfPrPwL+MNirceocQtgFiAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYiUklQ/S6dnqBkmqa10duBLZ\nG2wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK3wDdY+HEmli/D3d0EzTNhnYVIn/tnGV0tb1EZMWe78CIQCL8mBFmcsK\nwQc1BMkFrk4L8PDLKPreqOcGLApkKyUJUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAXm3WcOVI4usn6DPgj+FZNxAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY5ZmQwNjgtZmJhZi00NzBjLWJiZDMtYWFjY2JhMjk0ZjRlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTg1NDE0YTEtYzA1ZC00\nYmI1LTkxNDUtNGRkNGUxN2NlNzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nL3JBoX1Wjk4MrVUP8wODUZjoos33uXBnbQ62XwiYze2/XWT+/NH+RcmtMyRBK4ZG\nX1TAh43ih0nlWMW0CwlkGKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULZzRsYbWeq0sDhh4\nC2r1jv9MAE8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiAnsx5Y\nmaOFRzeAuknGBDQO0pgre45f4Aj4ffi0t2TE9gIgadGzaLFF4zHdegWYhMeaAC1+\nJ0cawfVQh0bDTdB8SbM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8165", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8165` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAQYP/wGtpE71vzN5H7Bp5A5FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjYjBmZWJlLTA0YjctNDllYy1hOWZiLWRmMDg4MTg0ZmZjYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc1NWVjZjMtMTYx\nMi00M2I3LWJlNTUtZjhjN2M1MzcxZDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8BvHRjwxFlEcjMQw6K04TpgQ4/r8DghgfX/3LK9Eo+CphUDrQIxxw1m1LL9C\nwSn5cbJjTK7WawJKme4T6OhOG6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTZrfZ4hUqME25Rv/HnkH2/y4X6kwHwYDVR0j\nBBgwFoAUZL0gPHXR644aEWK43VcEwB0keW4wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIBCp1UEn7dH++T6KOpYaezt/XsKtTcL5Ck2bOCuui36fAiEAl9l8DbKD\nqBa81/FqsGZN+2wcpv+08H24M99rIJEowYo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf0jsp6oajD0Bo4i1ST2z6y7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2IwZmViZS0wNGI3LTQ5ZWMtYTlmYi1kZjA4ODE4NGZmY2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb/GHmn3elRH+5jZUczivnjaZvFW7k/IhXeSXd82+ggWg4\nCv6wT5uzXHscFbqk98bKBF/P4hPIPx1Ojm4cVU4qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZL0gPHXR644aEWK43VcEwB0k\neW4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIdR6Q/rTHoM13uTTnVuxVqIrvV2XsRyclPJDgd6+2yHAiAZTyf2e8Qr\nd0eb+mCBCei+R8jqFZbOSXCacO1ygrm9Jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAcmzi6fUQ+L1ZUW9bCfpaZB6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc1NWVjZjMtMTYxMi00M2I3LWJlNTUtZjhjN2M1MzcxZDBhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGRjYzNlOGItOWQ4Zi00\nYjUyLWJlODUtZWI3NTk4Nzg4ODM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/WDPGq945Z2V4fILJMiFEbdyYJ9fNwruKxWXCRUrV0MEBID2jATj9hC2bULgATXG\nOv8kjKnwanL1nTb7mBRENaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTZrfZ4hUqME25Rv/\nHnkH2/y4X6kwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAw+7B\nv7bXwC3GIjEJxAsla+LqXoX4tx3ChAbtAlaXSpcCIQDubmg47KeuXX9j4yZK81SV\nNUib17mne4KaNFzwLkinHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8166", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8166` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAaGX+tB0q8a9tbar5kbFGUVkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2OTEyMGE3LTJjMGItNDQ5MC1hMWE0LWQ0ZDY3YjY4YzU4NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzYzNGVkY2QtMDQ3\nZC00MDY1LWEwNWEtYTY1ODQ1NzljYTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeTDorbJt8bc8w2DxM+JFMfHU9B8GKOw92LznCnKqVLtJragYPSALCdvjBl26\nfIqJWyUA5mFgauwdlta66/Gny6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU81JXzQHugL0zXvr/Py2/U0PqbrQwHwYDVR0j\nBBgwFoAUTWdifhbHEC8sDBzYesUfmqazTlAwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCF9SPmz7l0dkXGz09g/geUbBSrUra71hP1MprQH0rCmAIgTyC6oS+0\nJfmZ2WIslpI66in7dyZXb6cJSe8I8uqTryc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARf3kAgNuaW104ddiSyJqrtWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjkxMjBhNy0yYzBiLTQ0OTAtYTFhNC1kNGQ2N2I2OGM1ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGHpofxzeJlNXdcV2KHem0teTlji6RhjHdbDzgu4bH3mlW\nBUbc9WAQXff2nTVUnfRe3xdrWjuwGcB9+9sLcnavo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTWdifhbHEC8sDBzYesUfmqaz\nTlAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAiB03ksYQe9F8BjaVx8sIav+NP3KKZK753yiId4NjGcCIQDvFxYQ2KQM\nTVysfNK1kwEKEdF47uW3Av4EGjM/4C7vKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASQS7nbvKwrLzUvUd3c2gmY+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzYzNGVkY2QtMDQ3ZC00MDY1LWEwNWEtYTY1ODQ1NzljYTNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODYxMGIzZjUtMjZhOC00\nMWE4LTk3YjktYzg0YzY5OTZmMmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMjzSnGDJtgvARZPVrOa6DCFdiWLqPeH8EDKcTK/iVJOkEI5b0Tw1aB9NeaT+Ek6a\nopX7mVvCZ0mmrynhcB/1ZKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU81JXzQHugL0zXvr/\nPy2/U0PqbrQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAmuxn\n6ofbPAUWWRCC2MaOP0zMo362S85q58XLc/uekisCIFEpyqhDQ/poNfSzn00YBpk7\n6ZdX73k2UzMQ34GN2FrU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8167", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8167` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAVmI5DxwPhdz4UHQ8ikmNYxdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmYWI1NWY0LWFjNzItNGZjOS05OTAzLTNiOWZjOTE1M2IxNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzE0OTRmMGEtM2Fk\nZi00ZDlmLTkxZTMtN2MwMDhiOWNmMTFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWMjQAITcSZ3L9iWC4tj9Wr5+J8EAbDljUEl4vQlT/ZpFczy8Z7zZehA+jk5g\n042rA+dNx/iLNKUaJpvKIXivLqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD3sEC8YQPHhU1ctXNpo/qPx4miEwHwYDVR0j\nBBgwFoAUdPs/YGnap6POrLec6N8XKFIiSc0wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDnhTHB6zuW9FDhj05xPZtFEQbXILz8wdSZ/JxRrV9zZwIgImm4z81AutMOval9\nc6NKXQFP1a7dqAtBmGvgO9yzxC4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaWLvWHwIbRSqbykoNWrLHQvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmFiNTVmNC1hYzcyLTRmYzktOTkwMy0zYjlmYzkxNTNiMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAcUAyjd6pXsZQ5bcOFDHOvQaejBvsrkn7cCRvPmuIeM2n\ni9QAH/0XROM17jtw0uwxUV4CTP5T0qCnO+s/50dJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdPs/YGnap6POrLec6N8XKFIi\nSc0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIMMA8nZafZMiVIxjre1TwMmn79kc/g7mlJ/dhpNWie8AiEAhTHf8Z+G\nigDSXiCK8LnJ86LR2ZBPqgso5RGEEsF8M6M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAVgBdkHJHcWpfejKz90/SFtNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzE0OTRmMGEtM2FkZi00ZDlmLTkxZTMtN2MwMDhiOWNmMTFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWZjZDY5MmUtZDNkZC00\nYjI2LWFlZmItM2ZkYzk2ZTUyNGQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\np29KtYHAjESiKefAl8G+YDn3s/Gcl2boUuTY/BnSG77qQTB/y8IsocgBUtjvkeYu\nn9Uckz6utClm5RK/2JQItaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUD3sEC8YQPHhU1ctX\nNpo/qPx4miEwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBrrCn/\ng1/Rif4bRbgZk+d9mFP9qtK65r5+tZG8bMR7eQIgMQNE3yyng+aJFtkNoE7f6k7q\nObF0FaaUfwoInNYSjLs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8168", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8168` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAUnBH3kFy7a8+JSD1JSDjg2IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3YjE0NjRkLTg4YTctNDg0NS05NTcyLTk4YjZjNDYxMDFkYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTZjMGU1MDktY2Vh\nNS00OTRiLThlNWMtYTU5ODFkNzEyZWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiaKURq4k3llz5Ne2MLoNce7RoHADfdmB84u8tGLWJC8tL7Hf7vRvesyn28az\npnIc3wz28zrcvdRdIDw9Sg7DrqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWq4CSJMiSkOJE6sZwHOsNXRZdHswHwYDVR0j\nBBgwFoAUxr8GVM/7onvbanCPslUk4owJ71YwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIEOfUtNYKhreAMDH+A5X2EphAIko4Q50sKu2bRRXyOv3AiAK\nv7y/a9/CZGa3LRoqDHugkuIyBGqmwWVkEc39uPpkuw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYmPIlyUkRDWUqV+lE/6PdjAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2IxNDY0ZC04OGE3LTQ4NDUtOTU3Mi05OGI2YzQ2MTAxZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXE3Ld4cL2TUCSabzhKuj4fquC2fk+sI33D9MaoIGYkVn9\n1bdojefC0SEhfVSnqrHLYeHYd5M7HTPvYuAMtgfko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxr8GVM/7onvbanCPslUk4owJ\n71YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP4KSGVWlkY++9RHdfreAXe/13olMZYJNvqZlA3AAcpdAiB5vxPWKa4r\naZdfdxbcHM/G1bEF6L4DM+TBag70Ztal5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAbNngIpx2jSaLnzLOFjOL2THMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTZjMGU1MDktY2VhNS00OTRiLThlNWMtYTU5ODFkNzEyZWRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjIwZTFhOGUtNDRkNi00\nOThiLTg5ZDItYzFjNjZlZDg4ZWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPUGSg3cwbcaxnlNdHNaJa1mFTW0bZ3RgRIYHU311+Yf7pXCM8hqddcuY4a50zHnU\nl/ZddWngyBytjOhRE9oIjKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWq4CSJMiSkOJE6sZ\nwHOsNXRZdHswDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA5wzB\neEN0pM0iGGIlBF+tmhf+DTkdHXBipL4TMZzXKGUCIDQ7q/q5rHobe8KRMMgdzgIF\n/eONQylQnXk3tR/7r3Q1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8169", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8169` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAfHm8ZIR2ke0/sFr81L8RXbEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1YTcxYzY4LTA2MGYtNDliZS05YmQzLTJhZmM3NzEzYTYzODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFjZWFjYTktMjZh\nYi00YmVjLTk1NjctYTkwODMxMDZjYmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXLtz9rDPofhhdaLqT/jUDGv8wcjq/TKwracZBz3CCRBEbiwVApKhZMAlWu9U\nJX4hsLro7KJLlXsGzF3HOu/CJKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwt2z++XiqqKNQyL5+kAHvdn/CTQwHwYDVR0j\nBBgwFoAUj+n2d+OerW38rXRIo68h9n9ioqAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQC5Hv5XHAlSJPSk7Miaw0RxUZkgDG4cS3B0w2VjqM+EOgIh\nAM27D/SZRoZa2szj9D6DTkfeH+/EfQi5T/cwlY5AdzER\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATIz4XKazv03FCkS10cwySG8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNWE3MWM2OC0wNjBmLTQ5YmUtOWJkMy0yYWZjNzcxM2E2MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR59lgqqNhTJkotPGAqGFhvs4+7mml6PYO0av6PCQdKd+8L\nXy+m1UtHUEoUE6GcGSrw0B4s2wS5BKv05YtxfD/Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj+n2d+OerW38rXRIo68h9n9i\noqAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNh/xQUc9TGX7Oo6Iqt0IAqco9zij952ywY/uRc759b0CIQDGH0tTsjee\nJQHsbg3WI4C+ufXdHbk2gU6kQaVw3bxyKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAd29lZVila/5Tl9tttlFzrtUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFjZWFjYTktMjZhYi00YmVjLTk1NjctYTkwODMxMDZjYmMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDUxNmM3YWYtNzg3Yi00\nMjkwLTg4YmYtMzEyODBiMjRhNjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nV8+oYkHR1EEKUxQc3lDEaIoIG2hGHXgPn2fXNDiF5VPCdgfR3MOARChD2fnbh3/W\nrleBjmmb7jFnYcioGsh956NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwt2z++XiqqKNQyL5\n+kAHvdn/CTQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAq4Qn\nG5DGRNLrYNWCgrF2fqXJ+z0yaRRBZC99ahvAsjcCIQDD2UYl4XP6eNNyhYop/sQ0\nzcAs0fWCDlINs6IdQW7I6w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8170", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8170` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAZ3UtUSuE20mpIOOHkyVv+9zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhOTkyZGE1LWUyM2EtNGNlOC1iYmJkLTViNmRjOTJiODIxZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNkYTlmMzktZTY3\nMy00MGMyLTgzZDAtZTE3N2JmMWZhYzdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzPUdUb6Oe52UlODYgy8ka2Jmn83GdaRQL3ffsPAOshzD2Q2TqO1BXh5jl2q/\nacPkEWdqcMK42SaNRJ9y9S56VKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYwBobk9kerrfUQ/LhUVhFTBkhegwHwYDVR0j\nBBgwFoAUaXl0Sst+/vlLMiAfHX6gbjdBrsgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDmf1+omN1P\nA79VTnVSb3eRD6VUqO37qdrwrxpu3ep0hwIhAKpwx7hrUiIDrj0e1cecxQvQ4vNd\ncRoosH0qfQob6m4h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARKIVATz3XWtaypOZjjJZpEZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTk5MmRhNS1lMjNhLTRjZTgtYmJiZC01YjZkYzkyYjgyMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYltruK1hdZM1gZAKFrHVusZrHP98Hg7/LIOsZlWy2BB1O\nIueGtw4pK+rfp4sSYC1cjp4uaU3olIQ6vBslkJ3yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaXl0Sst+/vlLMiAfHX6gbjdB\nrsgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaBf0tyxRTDDGhUaxJU6IsoMP2Z5svgVPX7xmY4PUACACIQDxMAa0pTyN\nO/I5orwawlF+uQAyH/Jl2VfmzUwiwQRXEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAfsKRgvNEi5hJVpMsxEx5v0MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNkYTlmMzktZTY3My00MGMyLTgzZDAtZTE3N2JmMWZhYzdmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGYzYmYzMjUtMWM4Ni00\nZDdjLWE0NTAtMTYxMDZkYWExMzU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMv3aeLKJ0dobucwAEMqVt6BmJvUBloRigikQXhhxlVP+1Z4z8aT5sXQ5Ru3XfVtB\nAjVOdhQMW31N3NDIUYfBA6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYwBobk9kerrfUQ/L\nhUVhFTBkhegwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA2yIO\nJ3qb41zfdSb1yspXJuvN++AhIO++BVNYAAOawocCIQDnBpBfJwdqRp72VVtemyOx\na9pn74zh1cOVq10FmonnQg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8171", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8171` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAbkRrqGCgERFdht7Z5WHJGYaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZWM4NWUzLTM1ZTAtNDU0OS05ZDIxLWY4MWEwYWRkMzIyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjUzZDI3ZDMtZDIx\nOC00OWUyLTllNWYtZWNmNjkzM2M1YjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWXS9Rl/g5Vmg+K5DGxH24bGJPEqjQM9jEz8CtqlKd8NsP3b2tUq3kOegtK4m\nngn5kGOqzai6gdvrKvuqkSJCfqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCY52tx9MBeLRU+OHjR4UZ7IMBoMwHwYDVR0j\nBBgwFoAUVtEgazPVLpleey++AOGwvFu/MgEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgWidotenEgwk2Fz/MsjPmoVUGHmaymSggVGpmASgiH8ACID2fxlLdT3f6\nxm+NruapZlO54wz+S6VCUQCMv5AB+5f4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdEcApBQBWMBKnMoijI0Nr3eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmVjODVlMy0zNWUwLTQ1NDktOWQyMS1mODFhMGFkZDMyMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvg0KWUES07LZVeGrKjfVmwzTV4wsX6794qO69RE1MxpzY\nwPRAdf3SFDSq3s7ZDmifpPigyHnXdv2Q+fhNBmOHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVtEgazPVLpleey++AOGwvFu/\nMgEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMPBTmj0+g+cGGkQOfYgcONi/DO4ILSMD8vnPvUYvMgnAiEAi6/Oz/pg\nNyTku62+XQjZ1DFOkLZIyXClmEpjr2JQMqE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAVCq8VI0iIaxC6T/+eVE4GciMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjUzZDI3ZDMtZDIxOC00OWUyLTllNWYtZWNmNjkzM2M1YjA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjZmZjFhYmItZjljZS00\nNjZhLTkxNTQtMGZjYjY5MTJmNDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyscvpCpqj/w0CuDA2fhbIJMId2Qm3Md6LC2OL13OOzld7lw5Sv9AJX+pNeiBwim/\n5rbAjADPv3kJfyzwDflou6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCY52tx9MBeLRU+OH\njR4UZ7IMBoMwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAx1P2\nTIzC3Ddln5E8tqgyrzeINcd/wgMovuZIcy53q9ICIQDe+m7MDXHOSuZufPA699Bb\nHVgmDaH6gNDWCiEV9Bw7Zg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8172", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8172` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAS2mGG3wL1H36lxpo4M2GU2OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkZWZjMmJhLWRmN2YtNGM5Ni1hN2U0LWJjMGI2MjEyODc5ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhlMTJkMjMtZGQz\nNS00ZDQ3LTk4YTMtZWQ3NTc3ZjA4YmJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoKmi047Z9LfDOyirKC2mV+Qqw09NNr2ho4gAgAdRMKJGCcuOl1zIOQK8Kh4K\nRkDfEhGch1DzVKBM0yaJEwY5eaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiNyyNprrFg/Pxejn/4fmyhXqCe8wHwYDVR0j\nBBgwFoAUxp+2jqPoKhiWxfnFb0pykzHrI0cwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgZe8l1q5+iJhA6R14Mf7CvM5soO4RFf/cE4CmDF0NEbICIQDggdAgMvOi\nbfg/pjhMhAuRAGqCg5kTn2MBVZBTTJInYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQC03HowYwIyHovwNYdYJn4tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZGVmYzJiYS1kZjdmLTRjOTYtYTdlNC1iYzBiNjIxMjg3OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASddB7yUmR/rtPRVkApgD2Uri0MChPdHiaRgarsMqoh1w/w\ncGkE81uNHKFo7upIHdtYX5oOQY3lDK0J2/ODurxyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxp+2jqPoKhiWxfnFb0pykzHr\nI0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP3y2d4HYQl4KH8rKoKJhG9DuRUHL0kXhbEFC4i2ovP7AiAFMX3ht2BK\nH+2Wblo7uTbcWr4bRnoT81s5TDX4QgK53g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAcXsLcZBlrj5Al1vvp2J+xj2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhlMTJkMjMtZGQzNS00ZDQ3LTk4YTMtZWQ3NTc3ZjA4YmJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzhmNTJhZWYtOWM2Ni00\nYzAyLWFlNjEtY2QxYTBhZmU1NDc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwxjELpH0M3l29fqVkHLNI2+qe9j5CI05Uy1misMVlGwF+hW+BZ5HQFHRxqX0hcMz\nyMKzi9+Mare9IJFkPRpj9aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUiNyyNprrFg/Pxejn\n/4fmyhXqCe8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiACzxaM\n10UeGeekBoLVrVdXsUcihrI8kEP5Q0wSxJvNOgIgZ/Xe9w65AoZJnyi35zh75w4j\nQdr52UvHM7bgKseOsVk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8173", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8173` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISARZ10cHiDSKmNwXjvGQnzB4+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNTUxMjc4LTRhYWMtNDE1MC1hNTlkLTRjZGEwNzYxODA2MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZhMjc5MTctMmMw\nMi00MDEyLWEwYWUtN2IxZTVmZjdhMDU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYPm2qFiGuqT+LUpbOSLFszDCQVXt8mKiMd97g3S3Zgsf64wZdbSdvnMiVJpV\ntEYektifGeGDuEN5hofBiQ95oqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDsSsab/lDP2x1dovv/5umsvJy+0wHwYDVR0j\nBBgwFoAU8Nfsm+eL9XAEJHWhaqUWn/cDEswwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIFWqCgXwqF3Inr/bled3YhBptEo/LqJPIdKAorKzZTNpAiAqqRhE+9nw\nGg3siMWJIp6CUd0OAfzXUUItZMPWR8Op5g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVIv7/KWg+A4/obw7sHRmKykMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDU1MTI3OC00YWFjLTQxNTAtYTU5ZC00Y2RhMDc2MTgwNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcwpYklgzj9ovZD7tfdEVTKX6x5MyMDKMGZQCMT+SYyLa7\n/baKRng7PhCGuoXsRHZ7btnXbb4/wQrVEWkDCpqBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Nfsm+eL9XAEJHWhaqUWn/cD\nEswwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOLoLJTSApQIB5BCvS5IDgcjO2UgyggzHadY+5lghR5AAiAXBsN9S6Yi\nRX1IOdX0Zbw7sl3fVsGafVhDtOXndsHKJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAS7T/LkYjG+qT+cxyh7XlHz9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZhMjc5MTctMmMwMi00MDEyLWEwYWUtN2IxZTVmZjdhMDU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjNjYzllYzgtMTEwNi00\nNjVlLWIzNjYtOWRlN2YxOGNmYmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZCU5am9A8Z2GWAH3QOQ/9luaAdFQQtJ7YFvIIDYww92PfWXBauDKPQ/LaMA9B04P\nXqD3gaVs57NyIKJS5U2cu6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDsSsab/lDP2x1dov\nv/5umsvJy+0wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiBJ6iHT\ng3hmbOCTCNPcR9kKGSEdqXE72rlMbzsT+lseZgIhALJ5V+/10C47pX96lPRQ4UeP\ngU4U23CPgbdGXGXLBBbe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8174", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8174` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAb8BePkkFBIjQJNA1ThJmF3zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3YzI4MTVlLWEzZTItNDIzNS1iYjliLTY0YTY2ZjhiYWFlNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUxYzQxZmMtNDJh\nYy00MWU4LTliOTAtNjFjZjhkZWJkNzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvyt83XwoYiF3ymp9D74f9lMkKxOiPVAOKG8qwCJchH9qvGwDAvmFrfxyz+PM\nmHOKcL80GmaK/KoEz35q53xWB6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKoYVz3HM0OOInLBAZB/WcEDG4bgwHwYDVR0j\nBBgwFoAU4GyN7MKmEpiUQLtvEQ83Nwu88/swRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIGHnEX5kvcALlptHFMFiIY7Uo/ZQ6Gq5/EnTmsp/\niQuoAiANOvx0WUviMBTNs9PQDwLmXDxLCFtycoB2JHil7rw9Jg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATXH9Wf3XFwwTSOExJVOSHpmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2MyODE1ZS1hM2UyLTQyMzUtYmI5Yi02NGE2NmY4YmFhZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrC46LDuXWWQXoEVJzral3kZIaS6h3EHQ7XJT98Wvr33An\nWAE9ZoMtrMdFmxTz5ZCzmXiMUF8bZJflf4DdaONgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4GyN7MKmEpiUQLtvEQ83Nwu8\n8/swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgO1ZxlsEWGoEuVNkd1pLmuycvrN2sh23qY6bfbvSZf50CIDa3DtyruEop\nGOonQKzW75P3glTjtkTA5xBBbF34YZgV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAaMCI5cf/GT3KiUU7stszZm8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUxYzQxZmMtNDJhYy00MWU4LTliOTAtNjFjZjhkZWJkNzE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTJlOTMxYTQtNzBmOS00\nZTc5LWEzNmEtOWY4ZTI0NzRhMzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqbSQ+qDn5b25XkCRa0MsxxALt1hlm2e/xZSnobs5xUYdXJGeqja3bkXfV7jI8xT8\nGVbqyUiM6Myegyhg+fnEP6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKoYVz3HM0OOInLBA\nZB/WcEDG4bgwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBqs9T0\nKjACn0deLyyrAP68jgmHF9bA0pUvYz5yYWERpgIgYj4bc/Mionyb2y+2EsWC5+37\nFbYErIiST5EtDmSHo0o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8175", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8175` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAZdZCpt20RP19yo48Qu7FuOCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViNGZlNDAyLTUzZDUtNDRkNC1iMTQ4LTZkMTQ1OTc2Nzg1MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJiYmY5OTctYzc0\nZi00NmZiLWFjYWMtY2UwNTFhYWM4Nzg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJCPFEmneAVorgNSq3PBVWDxmI/K0RvdCo4UkuuvoZuWVmSJV+Lz0fJqBxVWC\nBkbP7ylz40k//zz5kyUo/0c8kKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU90z1O9zyzut1WfbDcyu7OsY5eEAwHwYDVR0j\nBBgwFoAU5OgGTYAmDbJKOwQNStuu6ic0LWgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCICk9S8ITkleRk7fZ09NAoxDTxaOdY6QABeqI9Ham\nk7imAiEAz7V+HofbQiHIt1tYzdM0cpS+XqShy99H5VXjsw87f6o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV2WOYxZCtPUdTZ0MX8+nMouMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjRmZTQwMi01M2Q1LTQ0ZDQtYjE0OC02ZDE0NTk3Njc4NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKM53CtXuJ8UPxX5sK64Hcj4HQfAaPaBe+FEdyb31nn6+I\n/KKnYMIAkunXZLrfwf8PTAcmPh1szPehqavK5PYEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5OgGTYAmDbJKOwQNStuu6ic0\nLWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKLfj8gEBYWMMOBt/563jWEjOohq321z+SPcR0W5uIIFAiEAgAQr2sIi\n6l4o69MPDSvaZlMIAkKcoHmLCjIr2UxBNeM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAcMPTWpI+K29HVlOgF1cqyeKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJiYmY5OTctYzc0Zi00NmZiLWFjYWMtY2UwNTFhYWM4Nzg0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTM2ODA3Y2ItOTFhYi00\nMjM1LWFiZWQtZWE2NDIzMTlmODIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkUj6ATTwzUFNP6mRNxJswlUu3qhLERvb3grLmMbRWIv/cMPTUNgOOCBlXc5hF91Z\nr7NsKPf94/ojxf1AA3Bs96NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU90z1O9zyzut1WfbD\ncyu7OsY5eEAwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAtGzl\npDnhxp9oEN4crpQTMReXzIdIjg85+ETMLvDu+PUCIQCA7Rov6D3k2z5vaH5pXjef\nrdsyqVMAVbVbwr6LC3n6tA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8176", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8176` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAZNLKbhaBU61qsV9w9jgfbTCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwNTQ2NzdjLTZiNTEtNDlkYy05NzA5LTdlZjMwMmMyNDc0ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU1N2I2YmMtOTEz\nOC00ODZhLTg4NWUtNDMwMzhkNjIyMzc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdSXXF5kpAqwgXDvwZkp8vfsGGsMMwGWclJC+v5XRB5vMhtxG/6Ae7Qf0PHW7\nO2Yj8bKaDzird6FpbzupJoAJWKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+yh+/yC4l2s8rvFyV7Bzsr3UQ/gwHwYDVR0j\nBBgwFoAUZgrpDyV0s6LULCjuDgduD/zCqsUwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIEBYwPj0iaHVH1mBqFazjbbAtNyw7Rl9PCkeKJdGICJ3AiBT\nYV00vk+dLVL22lmdQlDA/PLV+q7LnNxqC4hW0EG0bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASih7rJsSTgmXhFXkvU099hbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDU0Njc3Yy02YjUxLTQ5ZGMtOTcwOS03ZWYzMDJjMjQ3NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTZ5ck8ewskvy26l4RBz9yh0N+QglZxqtQ2YQNLK/ZjGrI\nO33Q+nHVvlbRZOYZNA2kvZ//Mr+NbOSODITwq7WKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZgrpDyV0s6LULCjuDgduD/zC\nqsUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV/Z+2v60+DI499AStJd3ExeC2OZzJDdZQ/dDy4XrVUsCIQDcgb/TYCB3\nzoVayWN8T4ZnseWjNu1W49cffXNJJYWLYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYv7gxvh/zrwJ9bqFQVLcwaKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU1N2I2YmMtOTEzOC00ODZhLTg4NWUtNDMwMzhkNjIyMzc1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWU2Y2VjYTMtODk1ZS00\nNDFjLTg5YWMtNzcyZjFlZmMyN2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwlCfm0fH8jOwDmEmFFJeZKJq8FroHsmUAA1EDdoirJP1icu/7YIkunDVE9sdgJ3M\n2/9WrQr7hAhh52tjlx2M+aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+yh+/yC4l2s8rvFy\nV7Bzsr3UQ/gwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAs5TQ\ngodLLjMDMVA5pv0Ug77K1mIEdMrtg036RR05XiECIAojGBQ0YzAFAhZhQk3vkckS\nAE/O6pxYBZwYKUGQiWPn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8177", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8177` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAatN6CboDsfL8Zyx/ZgMaPTiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkOGQ0YjFiLWQyOWQtNGFkMi04NGE3LTdlYTczNTkwNTkwMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY1ZmRjYmQtODZh\nYi00N2RiLWEwNjMtMTE1Y2E1NjBkOGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQZ7/CWtvkPyapRE191Ro1aFMX2XTs+v9AroTzqGAryrrxF5MNi3RNCpqQihD\nlQ2R8Z7D0OBIu2afp3bXWhkIsaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXo/4KRuapSLkWJm0lytNCYtYAQQwHwYDVR0j\nBBgwFoAUr5jdDm0rR2VnD1KYmNeR9AqAgz8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCn9frSZcV2rrSfgyD+Vn9zpPdpSWQl\nTtV3w3FVPImhvgIgPxpXnb7I0afX826tlcPdwccYoM1zfVZCumuSVuo+0Wo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYbiR20IxBJ9qrn7nxytdKH9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDhkNGIxYi1kMjlkLTRhZDItODRhNy03ZWE3MzU5MDU5MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdDLK9JzJ2JLF9h5RqhAuydPHzQvqCNt4UTPKUoNG6ZKJs\n1SxkkDTwsaaD5FJnLsszeeCbguzsIHrFA+e6zbVxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr5jdDm0rR2VnD1KYmNeR9AqA\ngz8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRJWjHemWkEp0u4V8asUHkSceibNYsjov16O1YzkVgbECIBwGDYc7Pxqd\nnn/F4sjwfjo7Rp/bCcUtyh2CPJdjrHNf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAQ5G+OFZB9mcUf/jc20h4gQBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY1ZmRjYmQtODZhYi00N2RiLWEwNjMtMTE1Y2E1NjBkOGE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGUzNzE4OTUtOTcwMy00\nMWU0LTk4NTUtNDk4MzI2ZTk5ZjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0rx+PR4Xa2RBQforQkVmHhhoDhv8yHMtpx/2EUcPkUy9Gju8qHkMJhL41WW04KJ+\n44xKxMl2kUbb8Ki9+Rz3i6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXo/4KRuapSLkWJm0\nlytNCYtYAQQwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAhhMH\n/Dq1hebXh1D6m6/8ztcLd+UyeF6TPqYHhSfF9ZwCIQCafyng88QX/oe7W8+5O0YB\n0Ea/5w5WfcYTzn3/FIK1Sw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8178", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8178` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbxw7rSIf2ycY3NSOg5zqmD/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwYzY1YWI1LWE3MjctNGQzMy04MGYyLWIxYjA2OTRkYjBmYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY1OTg2NmQtNmQ4\nNy00ODJmLWIxM2QtZjU4MzhlYjAzZmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjDeBSPlRewItzFwHzMsBQ/qSJB2oGAdmF/npHI/plLStD4y27L9YW6ygPTGN\nzlNbl0xQN9vuh3omcHuDr2p8YaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+bDDnOW2RgrRdAcbvjiK7cg9NAUwHwYDVR0j\nBBgwFoAU4Yj8ATBnLX8Ck5uDigggnK+WUS8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCFBFbzVY/Vqz55aGcyB4ZXlYrW0r8m\nO8Ysu8AhxQTodAIgXk9wgqrJcPAZuhWFGQureUUFZX+/C1DxWgOrpilIqL8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWnlxsAxK06lwfEW+lGnI1VWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGM2NWFiNS1hNzI3LTRkMzMtODBmMi1iMWIwNjk0ZGIwZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNDiJT8Yw8yPCwqH89B8Pqqy4Hy5kScQjgColbGyai96AM\nJ1/v6t9kmAZbngOo4OM8NLVS7G+0xwtVJr9VM2j8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Yj8ATBnLX8Ck5uDigggnK+W\nUS8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOEdkMvVisGi3CHY0J+99k/kgyFEvHPfNbWhsyr5R49UAiBcuRekXTKH\nEUZb76/TK4ICA7g6d9AhcuQoZWWz1qascg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXfRYx3u0wuXD+9HGI72QFRCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY1OTg2NmQtNmQ4Ny00ODJmLWIxM2QtZjU4MzhlYjAzZmZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmE4NWQ4NGMtYzdlNy00\nN2NlLWJkZTYtMzk2ZmZmN2RjZGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntasPuqRAvMcYFuSnxkNTAvwJUJycXHPlWLa0GMidkH1R9Bz8Is0krj7tunHMUNmY\nMUuvEhh2yqRZcbx+USkCLKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+bDDnOW2RgrRdAcb\nvjiK7cg9NAUwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA6CYA\nr4xalyoL/cjZLpI01ZZxKcuaZjf9RpSepTYmrSECIFrA3w1l446AY9c0Fy2hTV7O\nKoPK1PjvrAa7OdSaajrD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8179", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8179` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcPY/srl22vegU/U9E5TG9IAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkYzgyZTI3LTYzYmMtNDFkOS1iOTQ2LTYzZTRhNWE3ZmFjNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2VkZDY5ZjItOTk0\nNC00MjkyLTk3YzMtN2Y2NzU3MzUzZmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeKqPjs3B9/1A+B4+fhbSnPpmm2RVYjoCkrOFLcajHjMB6Xu/DYt4Hk/w57ji\nVtPk6tbGOdBOVG42BKkdOr7EPqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP/qPHj/VUQodvqRplgEcxGomRsswHwYDVR0j\nBBgwFoAUqcbiuqAlDpW0nb9VEtn74ArXB/EwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBiN7jikYmlO\nhgRoWVonW7vrT2MKUvKFhVDA1HSu9uODAiEAyJuDHE5OLlYMz60s/YnxZ2B5t1PC\nNkdjxqeiDq1Di5M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS9qA5e9QepnRsS5vjoLcdYfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZGM4MmUyNy02M2JjLTQxZDktYjk0Ni02M2U0YTVhN2ZhYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2yKkBZKUpHp1Dq7WAqjWIKdZ0gOFvLrbiPE2zujRrhEjz\nupMa2RPEgvBAb+8AwVRX5WAdBYBoPRJEqdQyfC2Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqcbiuqAlDpW0nb9VEtn74ArX\nB/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAINXOMdEHd7Vt2DlIw1ODzg2XEm8pcRt565QJi/Auwy5AiEA5+BrUGv5\nKDRW1OURvOJ7TktqZiAc51zm8RaAaGcWwT4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAUVkPND+ByUN9Aw89fpb6Ri7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2VkZDY5ZjItOTk0NC00MjkyLTk3YzMtN2Y2NzU3MzUzZmFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDJhZjY1MTctMDkxNS00\nMGIyLThiNTMtNmFiYTk3Zjc5ZThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCZHQTiP134KYiKZMKVZ+YLY52IAZF7cexyrBghMgwzVRezgqhzaI97p9hPQa9Zgb\ntXqseKfEOhKtb4EASK53d6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUP/qPHj/VUQodvqRp\nlgEcxGomRsswDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA6s6C\nG+gqIhmyUbEfmswq89utS0nI47Ykdc8LS1yfXt8CID6ATjhDK1CfkoFi3c3dYafn\njM+mSDDJm3VpqEzItMc3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8180", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8180` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAUc+0EWyu2cYdQYgvkziYDZ0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5MjdjZGY3LTViODgtNDg1ZC04MzEyLTY2YjIxYjg3OGQ4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZlOTU3MDUtYzNi\nZS00ODNkLThjMDQtYmI5NzI3YWVhNDRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESsR+AwkSH6l2nJAhXSYXoc2r/y5+/SRYU2NgWbvRS5eOJ3D8/vgBf5s2ZIwS\n4TJPRqKIlR0MhLp8UrW7aCr33qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURBTmfgc9t2sLH2iENXsMB5aacXUwHwYDVR0j\nBBgwFoAU1RiXKt2C97jODofLpPP2qnYAuAAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJ1fsmd8NeExP6HA5SBKYqyRDQKkXMXdghxvkgt0if6RAiAWSXvAgbAL\nk8UHvsG6HVZIHGOXCvV1eTXO5f5noS8/uw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdnJbM+e1qu0JSligwk6C1z6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOTI3Y2RmNy01Yjg4LTQ4NWQtODMxMi02NmIyMWI4NzhkODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRmuh7/BWPCYlkZ2QLE3WB4bCGGSv1mLB+WQEY5Tm3gF2J\nr7T1nyOyiOVk1pxV3Fk6Dut2tiSCg2GXk/WcBCkro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1RiXKt2C97jODofLpPP2qnYA\nuAAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBLBxLrUSUGcz008X6AiC67O/MJqRoCCZapdsD7r6p9UCIDzMJpp4bbFq\nO3+3JXKumAkRrhTAZ4Uucx/BRqpWDo0J\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAW29Lq3OpzoZMJLTcjir3RJ6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZlOTU3MDUtYzNiZS00ODNkLThjMDQtYmI5NzI3YWVhNDRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2NhYjkzMmQtOWQ1My00\nZjg3LTlmYzEtMTFlNzg4NWU0N2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2+LuYr3IgdIIFvKxbZrwzvOstJWZhZZpDhCFazT5N2jymfIS1s6Inuk71j55U1I/\n3iL2b1NYSs9t7x28aPumkKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURBTmfgc9t2sLH2iE\nNXsMB5aacXUwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAgeZ6\n94l/CW0asH5Ldzo8rlD1L0xjMxye8QcVTfFcUiACIEuhmKwL/2jNM1OMwsjn2D+m\nXvvJjjfW87vs5kXRo2nz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8181", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8181` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQw62Gc9zrYvQXtQAvfVx5i5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljMmU3MDQ2LTM2NDQtNDI5Ni05MTIzLTc0Y2YxMDlmNDJkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmI1MTFiY2UtNDU0\nNS00NTllLThkNzQtYWYwNjdiYzQ3MzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVbHK029BDFhDbuRe2tP+2iiFjqAPXoRLDcwvOkZmNkXRzIz9hNqtg26RWRqp\nEjLoL4BbFNoHfTGoEAwXo4DhR6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm39VcUC7ouAvVOtpW8t9O734Hd4wHwYDVR0j\nBBgwFoAUTRDaMjehdF/F1do0s4ETIU01RU8wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJFXZhwgg7bUgsFPH4OaeZwZ7/ifDJAg93XUUVQi2PUBAiEAp9V0/ZWH\nRS1BF+M+qSt/nKunOokSr3m7JR+XTXBtgeM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdmFt3ZLy/NlRT9UoGEWJWKWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzJlNzA0Ni0zNjQ0LTQyOTYtOTEyMy03NGNmMTA5ZjQyZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQL7dQnH/hY6GPMKXS1dfszbXFOP5e1bcEBVXKn9SXs6bBp\nTJBTPdubhnuWthTVyiAQyyBKKS/YS7duAOd1nOY4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTRDaMjehdF/F1do0s4ETIU01\nRU8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJrdAbLGsp6icueYJjVZ6pWLHNAIh4kOfw44UaD37kR7AiBVvnuBrvkp\nMM3YizSgB56Chb0gnV24M08u9XVb0W5D/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAXwC8gLJ+HRC79vBIxBR3uu0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmI1MTFiY2UtNDU0NS00NTllLThkNzQtYWYwNjdiYzQ3MzgwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWFlYTAyYTYtZTg2Ni00\nYmE0LWI2NzUtYzEwNGQ3ZmJkZDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1yedpZONS/uwdopUAS9agcYxDBtiXcDHft4AxyM6qed/4fvmGhvllQNdfm2/enW8\nbb8ASgq4qmiX34KnYDOP/6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUm39VcUC7ouAvVOtp\nW8t9O734Hd4wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiBI/vSj\nGUFNOmjs9/kRYor3mOWhYAMc6QCnWBTAkBqsbgIgBxakv+hmGpfmWH9nWbEcKz44\nga55ieznkrtMp02KbaQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8182", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8182` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAZUEgdCGK5Ll4+E07ZQl9GgbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0OWE3ODNiLTI3YjEtNDNlNi04MjMyLWJlMmY3M2E0NjgyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmMxOTc0NDctMjQz\nMC00NjE4LWIzNDUtMDE0ZTdkOWU2NDNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAWSyrb0fJaTpNyqlFgznAjYjAlhPVXK1i8lrh0ztl6RDDFIjydrRdtdYSQuX\nRcaW5ne0RwydrClh0yn8KIOOHKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj1+zSh1Slouq12OIDxcJzAIygiIwHwYDVR0j\nBBgwFoAU3FOsgccKlg0otaA/XFchm9ONgsUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIEp3QxWzZKpYD8Jzs6PU0/AhFxPvVjzVChCX6E1xjDG6AiAD7VS6gNF4\nSCDnCpqX8nVeV3p5aQKzTf9haFOzyxSf0A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW6h03om0YgvyKz9y1768OkfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNDlhNzgzYi0yN2IxLTQzZTYtODIzMi1iZTJmNzNhNDY4MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoVoRdmXOS2kXu/vgXYmfhjqIrYG1VBGzEL4YxXlgatoIw\nvRGWljJpUOmi8sZ91n6n0dJVbFFO79PdzmAMEBqOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3FOsgccKlg0otaA/XFchm9ON\ngsUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBYpPEEzMaVkAZDvLjrG3FV2C8XCPdYlou1+G33lBs/gCIQCY0PpwtauB\nsfCmc+5+JcbGolr3VXCvkCZq/Se209pjtw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAdFfiGECNqXSBEJ+XGWy2xp1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmMxOTc0NDctMjQzMC00NjE4LWIzNDUtMDE0ZTdkOWU2NDNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2FiMzZjZDYtNGMxMS00\nMjlkLTgzNTQtZjM2YmFlYWZhMzc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhT5sq7iAviLY5kCLs8SCjYDSBqWrSPVf8f2KTZefqc4dD1yixYBjT/URr+DAGZb2\n3g5Yy6uGe1b5u6k2hsfQPaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUj1+zSh1Slouq12OI\nDxcJzAIygiIwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiAi2dCM\nPsutP9ENdSFu9y4k7oyiFTvwawmV/zwdNPb5ZwIhAI5LmK9PiIt7o185erI8ZrEd\nhE+DdKwnXCjFFSZ92/Id\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8183", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8183` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAe/trJF75Mj9ZUr6wJL6uCP2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMzhkZGNkLTQ4N2QtNDVmZC1iZGFhLWZmMTQ5ZWYxYWI3ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQ0YzJjMWItYWFh\nMC00ZjRkLWFlNTQtZjM5Y2YzMWMyOTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE09G3aMqU1JRtwZBWpbNmDM2bzdVvQAAHYXHVrZiq1r4lKNPxhykLdeBm3NA0\n4aFUAQ46G95k9/4V194EQvM3+aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1/qxi9Y6IGg+OCPNcdsJrogSn58wHwYDVR0j\nBBgwFoAUPLCqouwZxT9ShC4a3+y5YIH5l6IwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC/n9ZVNZDXGwhPK1ek4cb2ls25/rkmz7ek/09y\nBZQliAIgAllLIdcXRSNP5VaaJ822bRO5KxcfhWEGCeN0yMwr+TE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUUSN739pCtioLt/p3ZgtdMAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDM4ZGRjZC00ODdkLTQ1ZmQtYmRhYS1mZjE0OWVmMWFiN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNUvmHY5jqP0I+CnzrMVUue3dIOKzM/+xcONkdS3Z3uVuh\n6oDdnO0mVwAf92SeV+E7ccWQPqv1satN9GseqDPbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPLCqouwZxT9ShC4a3+y5YIH5\nl6IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJO8AlnXcAKwPSgvxWgjmipBDg+bHFjs4bpxmNkngYKnAiB6oEtSQP3u\nKW36BPpLgu26O6clqpe55UcdTECoal02HA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAX6Oc39iyggoJv3libbhPI+8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQ0YzJjMWItYWFhMC00ZjRkLWFlNTQtZjM5Y2YzMWMyOTdkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjg5MmM0NzktYzFlNC00\nZjQ1LTgwYzEtNmIxZWE5NDg2ZGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlHGeRq06dJYPE1dK1kIOi3EYYesJLPrmgHGJ6cAsee28+NozTg1d2AvOr5iTOMR9\nUzDRYfEp/n1j3z1CfNm+gKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1/qxi9Y6IGg+OCPN\ncdsJrogSn58wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiA7Bj6u\nIjUbjRAFyt0GU/X6QKDX9akidrfC4GGoYvR97AIgd+vmgx8uGo2Lq3wHH//Sx3Y8\nXUQ/vbldFSJ6GVvv2d4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8184", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8184` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAa4BmkLWI6ry5AZft+uUN3mdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhYTM1YWRiLTQxMTgtNDBlYy1iZDVmLWNkYTMwMzdmYWNkNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWM4OGU4ZDktMWQw\nNi00NjEwLTliNzAtZmNmOWE2Y2E1YWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMuunz+W+UNaH5KBB1+EOM19X2lAlb4mSHEt0TPnDa1t/ekLfwZ4JrjaenBVy\nn+5Mr3MRnWQX7cOnotkNvhXS2KOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKeKls08UjyEeZwgIPsfGT/GDab8wHwYDVR0j\nBBgwFoAU9CglOexfdUBu2BHdnnuURdWnjWwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCLexZ0BbzY7hqZejMFn03l9QEwskpvOeYXALPG\n4Hu8/wIgVW74XjLcXAdx0VxLS/n4fj++LKQnZWR7G0NtSpkFJQ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd6GTmJNWaC3KjvPUvoAwq9DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWEzNWFkYi00MTE4LTQwZWMtYmQ1Zi1jZGEzMDM3ZmFjZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNmRRp5/f0pSeuQMpFmS8Zz0LMfreMFOr7OxZ1hpkvZPRA\niBpYCiy62l/O/f0+v/TQx/gO9gth8tGrvGBlQN9lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9CglOexfdUBu2BHdnnuURdWn\njWwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZLhsnQ5VSHlVUB0bHCXxd51xoA4pwbQUnhPaUE6DjToCIEt2BVuqN5Pq\nUSC9t/FJF9eXA7VQdF5QzcXa8gVFGcw0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISASnSeHwYZ8FXIPPwBOXdXdmnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWM4OGU4ZDktMWQwNi00NjEwLTliNzAtZmNmOWE2Y2E1YWVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGU4M2E0NmQtMDg3NC00\nZmIyLTlmODctMDQyYzU1ODc1YWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbt7lFJ9/I5FuaUfDwGlO9xVYrSs+FlCbwzXe5ZRo7jwJGupSlbXFyiUhxlBMjGUd\ngux9fium8vTEBqNsSbXfdqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKeKls08UjyEeZwgI\nPsfGT/GDab8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNHADBEAiACFRiz\nETSjg6O7GXqc8YLXdJfRkR/YMGj1YUzZCK7i8gIgfTeu5vROWkEYE13XZeB5MTCM\n/8oOYy+keoRp0otseVQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8185", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8185` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAUMVTM8bPg4yZccI56ojzL2zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MjJhNjRkLTgwOWUtNDUwNi05MDE1LTc3ZGQ0Yjk2ZWZjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQzOTIwMzAtYTcy\nZS00M2U4LTljMTktZmY5YTMzNWFmMDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0t32xKD9kYhkkFJJnFXCFDbppgG9+b41IHqjq7PFHMA+yI8cfhniQTH+GBgz\ne1ulJHxwzQ2iSyGuJ+1dWkLqRaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJFM5rO6bzqBcgmhbCeaZOyoVUFEwHwYDVR0j\nBBgwFoAUcqb42aNaDbsqiDhL0THIsq9NVNIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCICixWMyhXqmTXk6Y9xV621DCGlGu5WeBbAxTqcPjP20VAiEA\nr8CeXXYGfld3v0uYgUlyZ8c80ilgRKAET3pc4nkmb1M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY9mCIkCrqPtPWYOlQIe7uSIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDIyYTY0ZC04MDllLTQ1MDYtOTAxNS03N2RkNGI5NmVmYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNACB9ptpYrrb6Z5YnpPNwpavcAisImXIgJ/Is/J6BXAct\n6IVm7f5U52N3EHMb7QemfiNb96ZaT/RhFyQO8n+wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcqb42aNaDbsqiDhL0THIsq9N\nVNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIg/9iIrkWGWHxkjrcPnaiGhaWf0cVqqOYAn18dliOwBAiAH77IDfdaH\n3SFHBGrq/6Pp/Yqh7gNHR0IxpSq3STTcsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISASvMyvMpV7SRmIYhbR2ngYEqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQzOTIwMzAtYTcyZS00M2U4LTljMTktZmY5YTMzNWFmMDk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjJjMzhiNGMtZWM5My00\nNDk5LTljYjEtMDQyZjQ2YjZkNmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nx7wpA8Xn3QVvNB6XB6w2ZGAqWPOE5YP1iuVnzRjX2j0bmLUWW9xsMIvLdQuSFheh\n+Y+EO4SyCAkDIcYKNJrxYaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJFM5rO6bzqBcgmhb\nCeaZOyoVUFEwDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAwGug\nvU6l5BK1peaHcpBsIXMXD0mQGkBMuy5Y9xvK3sQCIQD51akwls+IFm4r9VA3vbn3\nbwvI+z83BhI63LFZwpkrrw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8186", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8186` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATtz36Okgx3rSUza+R/r12HmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0YzZlYWQyLWJlMzgtNDhmMC1iZjA2LWM4ODRmMWFiNDMyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRkMjJkY2UtN2Ey\nYy00MmZmLTk3ZDQtYmRiYTBlMWI3YzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYykoi6B8AGgGrufY6NJNXFIm0Yv+40RJS33c1sMYUb2DbIr2bPa5IXXPYxAB\nkBMFkqGQji8UJNU1CMIKWv0v76OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvtkkGwlZduNUEHaehqFYiw+Rbf8wHwYDVR0j\nBBgwFoAUDh7C8VZY46hpUzOYDdcz36WjntswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCVVTPlqPQnuYNGnX6d+iSpZYUtA02H\n1k7lnQg3myTTIQIgXasvYRbsSqrstaj8HMAL9JFKpYc8N1un1hnA3FCHytI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdjpORKa9+j6+2KAUta2+/NBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNGM2ZWFkMi1iZTM4LTQ4ZjAtYmYwNi1jODg0ZjFhYjQzMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKvLUKmiqBFFnyh7zSuDtvfTWmBd2hHefItiCH3OXOehhe\nyyXMCS54hHjf13uJuFjvd+hMLxNlHbGsnl7kGqOGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDh7C8VZY46hpUzOYDdcz36Wj\nntswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALDifKLH7cB5oAc/HEqM7aB7qoVi79fSxV/T2lIjC57pAiEA+ihmToLs\nEjE/bmay3/paq/Y7KeQlUpDSEVMsZTJKFd4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYY5Z/yJTFdXYqkS2RyEimRNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRkMjJkY2UtN2EyYy00MmZmLTk3ZDQtYmRiYTBlMWI3YzlmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTJlNjBiNTctNTc3NS00\nMjkwLTlhYzYtNzY1OTI5MDE1NmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQ3oOrY/cvdr7cN1R7Lf0+/hXTGeA8bMFl2G8ubzMKEbMV3lkLa5k5wEVWDHBjFo0\nP4ZON0y6EjDC21kAfQXp8qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvtkkGwlZduNUEHae\nhqFYiw+Rbf8wDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAjvKb\ns0NaRay/yB5El3c51XZkpxOLSUT9OPTXl4mDRvsCIHKR4Yv/jj+bU5cSixE8mz63\nuObHm8fQCgZAeDHiPyuK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8187", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8187` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISASjPUOXhfMBdiCr8Ydn4K1QjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxZTBmMjI4LWM3ZTYtNDYyOC1hZWNmLWQ2OTYyN2VjMjhjYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI4MmJjN2ItMTc4\nYy00ZTIzLWE0NzAtNTEyNjcyZDgzNTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEILFioQpkhKeSDtwjv1dyjDBinqIPra93TtKxU9rzutNnBkygMOt8JE8MOWMw\nFH7+Fs4ccI3dxXkoNkV98dCtbqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDydf0p0WO4EHyAcYbvwvjRnkWCowHwYDVR0j\nBBgwFoAUgGO1bDYsqYtWhjO3hrKf1ov6hx0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDd1s+EF1Ws+Zf5+A0qHD+FfqCoirb7\nUVXrPGxFOagjJAIhANfuNCAKAUb59SpEFg05UEVvbqxF2rmLKqjFH/Gvdh3t\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXoLplDPO20NPX7slmeEljcjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWUwZjIyOC1jN2U2LTQ2MjgtYWVjZi1kNjk2MjdlYzI4Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3HSiZGaeAJp2BKsM1H56DupH3UPmlHxyZiq0RQUZhEDYb\nNxBMFS0nZAtSlCrMcaTOogxN7wdhYRPEC10yH7coo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgGO1bDYsqYtWhjO3hrKf1ov6\nhx0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU83ITk1YNCgtUKkIqAhelCoOxRExMX34iAVfnuqUkAUCIQCAvUkuk3z0\ntDdF2SZD7RApLlapwMPSmS/mNIIOiW7Z2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAaY6/7LdlpoAOneFP6bEfET0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI4MmJjN2ItMTc4Yy00ZTIzLWE0NzAtNTEyNjcyZDgzNTBhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODZkOWVjMWItNmZlMy00\nYTM0LWJmNDAtMWJiZDdjZTI5N2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ned7qN01oH+UPv4dOumJHkr6Zp4sdO0Gm7sKVMVih3D2J1LeCtlnkXZaVaopql+eJ\nUOBOj4ZElYUhxw0w+trpYaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDydf0p0WO4EHyAcY\nbvwvjRnkWCowDwYDVR0RBAgwBocEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA6uOx\nZTnLtX9f9Fem1FWDnhtLkxmpSfmB9rdqxdJs72YCIQDrnhY0CaPzeJTxSJryiZ2t\nWLLF1aU5nO3M2s7UF/ThBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8188", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8188` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAWtJ5KsC8Umk0tfApLCThkA3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZGIxNDllLWE2MjgtNGIxOC05MzQzLWU5NzJhMzAxMTY3MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODIxMmY4MDctZjU5\nMC00MWE5LTkxMmUtZDJjNjlkOGI2MWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/DNG64P3I/IWB2kFQGovO4ey+yYaTRzikpgOVGvjRbn8HHHuIyk+jvVb7F5J\nA4m9kEBJG1vPJO+78uH94ku7EaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFK52sv13U5sUfAIpRXWBkKOi2QC5MB8GA1UdIwQY\nMBaAFMXUR0Ww4YP2JJxgOW1idCFOdlKmMAoGCCqGSM49BAMCA0gAMEUCIHBK5ohY\nah1mVSmOwgQQi5hGjp3pKqrFGmO+hRGSoIfmAiEAqGAG0jSSfRV15dTQz8pkvUuh\n9E9ugTRtrlZ5tUFcorw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd5wbOVuW17BR1juciDQ3seQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGRiMTQ5ZS1hNjI4LTRiMTgtOTM0My1lOTcyYTMwMTE2NzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJ/hUAr+qhoDxDLNdQa8IkssoBPrr+557kEQ5ePTfiomAQ\n7U4PKp5rtaZKnnZv8h295M15ARqhYT4E6KazOPaNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxdRHRbDhg/YknGA5bWJ0IU52\nUqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOMcOe27jowbBiOupoRjEGShMywYlnGf8PcN5jPhPl8YAiBFLVMWWfXo\nncGkGuKbABtvxDXPAAmA0CsyEnELqvQ/4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAaEZGchApo6dgwnzGIy2TTa1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODIxMmY4MDctZjU5MC00MWE5LTkxMmUtZDJjNjlkOGI2MWU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDVlODg5ZjYtMjE2YS00\nZjQxLWEzZGYtMmUyYzQ3OTY0M2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLIQxUco8ANe4cZH5BP9NzwUnP2I0D1Ew++fkslKaEirOJBXi8254uZ/GQZ7wFG5y\nY2dXnHG3R/RRlXUYVkdstqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrnay/XdTmxR8AilF\ndYGQo6LZALkwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA2UDj\n4DlmdnkaMsBi9i2+CCsACOA4+rIDsuPv0kRNSCoCIQCoO12lC+4VfIWnc0O+1Jeh\nRr/HXHl8Nuwu9D1uBo2Tow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8189", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8189` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISASwwBjX2pTdNs0wl7IrHneWZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5Y2NlODVjLTljNDUtNDA3Ni05M2NjLTZmZjUwZDk4NWIxZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjJiZjU5YTItZjQy\nZS00NGU0LTgwYTItZTAyZjAxNzdhMTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETabNtel21d15QEF2EGBYSKM7PDlAEtOK/Ct2QHmWOxx6w+PV35oKWUTvtEs1\nFma748B05HIodfk/Iyy7AZp+iKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLy5gAXZ0RZpOcjDT/8g59BIdoJMMB8GA1UdIwQY\nMBaAFHLjo7QVqvCehv7Z1FqjinL9alrEMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBg/IIvUMgohWOPDkqGixWnc3AkuDoZ7JOW\nlsbpV3nk1gIgD7nZ5yaVumEsVXZoKMvNEKx+GFo7Unln4nz/ezVGSt4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATqIa4Y7Y3uNm81caFZFl2OhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWNjZTg1Yy05YzQ1LTQwNzYtOTNjYy02ZmY1MGQ5ODViMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjgBu8NpPsyqBICG3+SXgQwUiB/hKGzB+AqZGzsvEiGZmx\n8Vqw1E6Pnigg2l6+uniLu+Be03iT6YncPChX3FH7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcuOjtBWq8J6G/tnUWqOKcv1q\nWsQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcz6pYD0a9t2BB0ki8BtmqfLW42DS0gB8acgiaJtZYrcCIQD3e5ZqQpr3\nIvasPf0v3Udl1/jCaPAtKHoFdLKloMIB9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAU7sHWVcXIqC0iE23TEi+kzdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjJiZjU5YTItZjQyZS00NGU0LTgwYTItZTAyZjAxNzdhMTIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWJmZWUyMGEtMDFhYy00\nMGVhLWFmMTktZjA4OTRhYmMxYzRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7Bm5QRargydE0pw6/AqmZ+oTwozJ9057rjZU70kW2w8EI/ORNOlY1oRKoktWeVVf\nzs9OA/L1Se9mHrRWguMGzqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvLmABdnRFmk5yMNP\n/yDn0Eh2gkwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA1mOn\nqiklx1IXOCE7KAdqb0NodMzGuibJvMkTYFvocCQCIC4Bi9MMi6chrrsAGmaXlhdX\nm9hpyM3DmMUTQleLlTYG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8190", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8190` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISASbC38noiic9XUW5y8iWZIoWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzMTdlODllLTkxMTctNDVmOS05ZGVlLWNmMTZlYjE1NTU2OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgzYThiNjEtM2Q2\nMS00NmQ0LWEzNjMtYjQ1NmViOTEzMmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX5ZQgm8udfWQuXlHatPysZLABfG6ktEcpnR90Cin7iZFq8N4fe9NApul8BMp\nVaC4xz4OlAlIf9OkX7aQsctx96N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDM76Oabzoek6UO9etxGgsW+Q6h5MB8GA1UdIwQY\nMBaAFD/D52gm8ZTH2woIREMN6A78qK1EMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAX2ZTDC6NsS9423CVKz7Kx6wNNpTsxd4e3\nc6nq92oawgIgTdd9pmVHjO2eBDKBtjMsn8ctUVTaC7llNn+5CbnMJ04=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaUtQaXqIHCVkfPEUU8nioacMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzE3ZTg5ZS05MTE3LTQ1ZjktOWRlZS1jZjE2ZWIxNTU1NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXGPTTl4pM0vOU/7aPPjCY0LZBahAOLqsDY38nQuKzOdmV\nM71ePmL8rLWuO6WkYOs4n6Cmotq6tU7H0R4ig3Xfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP8PnaCbxlMfbCghEQw3oDvyo\nrUQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRGtlfopmLr59Z0EqiMbsC88npgNe1ceCMPhG8dgtq/8CIDUhlLH2+h++\njvBmXDoZrg8aGIkdgX+2YyqEww3vNXZU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISASJxcRIIv0LzNMxA4DEc8wfQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgzYThiNjEtM2Q2MS00NmQ0LWEzNjMtYjQ1NmViOTEzMmIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODk0ZGY5NjMtNWUyYy00\nZTdiLWI4MmMtMTFlM2ExYzVmM2M3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyp6XRRzKofIDma+iFWdhSL3Hee6Ucq10GZxdyt5k+iGkgde6zq1Y4RcAzNFm1nHr\nkJeOA0Pu/LDEgr8RzWSfi6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMzvo5pvOh6TpQ716\n3EaCxb5DqHkwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAj1wP\nIXOgUmR1zGMPbf7SK+rvPa+tPZ5e3YUasGa8T4QCIFBt0OwY7f7eIt8Fqm3Q/+l0\n0XaMHy2Fpv4L40cNdkdK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8191", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8191` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAYOeVDcLzl9ams7GwKSnKI26MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MTdhMGE4LTM4NGItNGFlZC04YmFhLTNiMDI2MTMyYWQ4MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTYxMDJhNGUtM2Ez\nYi00ZWU5LWI5YTItNGE4ZGU3ZTlkY2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcI9jGRI31oEuA+BgaESNDlDSBC5D+1pnO5e2rrWw/mpUEZofCrqKQeKUyNno\n3Wa9BwR/8lJaZ+6vaHSRdvw2vqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSji36OA1k2jUgosFiNqOPKyeoS4DAfBgNVHSME\nGDAWgBR4CY+pAQAtv/L3qLXfLDdOzSFdUzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC/t155Yy6hvYjyjtm4NxBwRsjH4L0f\nPH16V8AeywIQHQIhALBG9KQbNOVnkSWXRbWOTHnpHbszwEG+RxTPpmNIX0dL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARl75+1kFpZ1YhVxx0OeKjVzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTE3YTBhOC0zODRiLTRhZWQtOGJhYS0zYjAyNjEzMmFkODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWadXBM+MT8wuFv78ZlQvVO0cmhU+TKJEkqZ4onj2VIvvu\netFnZCfo0+0jx1w7ogH3jjmcmiJjFU0h0NYrhRKZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeAmPqQEALb/y96i13yw3Ts0h\nXVMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJlsMWQMzFeVB+DlbkoHSFFM/UlXzngtf1N6ERg29QrGAiEA/6EnSUjW\nT88FL99sFGjTDpZAjTfFwCR2mlSYR7NzlwU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAfN7VRtIKC1zO2SaLNQYx1AWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTYxMDJhNGUtM2EzYi00ZWU5LWI5YTItNGE4ZGU3ZTlkY2ZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzljMGM0MzctZWE2MS00\nYWQyLWEwZDItZjA4MjJkZDFhNzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlUahCNOZzmjpqTd5qZ/x9H3OYrOoQ4FCKaBsRmWGEvx4E+gx8O02SuG6DEFVUM8w\nWdc2v5ml3X9uAMahbszNa6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUo4t+jgNZNo1IKLBY\njajjysnqEuAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA0sFm\nNmsaLb0DXnHy4e2kLWMnnPcaBjXOtK91ZI/EYxcCIQCjrUyKNZ9SOojvqVLYyTAu\nggwf6XjCgzyRtcN6sy/A6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8192", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8192` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAYSLvJqdZwly0Z/wYzggRTjKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhMjg4MDc5LTZhMGQtNGFiNC04YmQ0LWI2MzMxODE4ZGY5MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRlYzkxMzMtNWRm\nZi00NmQ2LWI0OGItZmRmZjEyMjk5OTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa9yDYTjrOKnPiHAIcKYlBV2viYAvvmMgEfec7WSZ4kjsUbzsTziKmxZZRENY\nCjGvmHzWYxJplpH/0NDPsOIMAaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJZZpYZ1ZlDDRYfiAbHSoi1EbriUwHwYDVR0j\nBBgwFoAUuhpx4LLJT8UJzKDcwou0R/IbwC4wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA8GrbFf1NqbUj\nHfG+/hVjH4rSFFaKDO6KdLCyEyurHNcCIQD0xNtcQ2OGFJTqcYryZIBU5s50epwt\nGu/0JgDRwNFFhg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY2/R0mGNki/Vb7md1OKKI8EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTI4ODA3OS02YTBkLTRhYjQtOGJkNC1iNjMzMTgxOGRmOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHkr0Rhc/PEvdpCjy+pbTorhniCUCbTIoq05nsTJHLY4uj\nQ/7Egm2zpnUyDtzXFvkuBgMj1aExpXVhiMg/raWco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuhpx4LLJT8UJzKDcwou0R/Ib\nwC4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAtox+juTTr7XHDiIEYlhgxLm1vf8/8hXMJnZSIjpFxgCIASJZrAevKOG\nXpQ5UZAPkjWOCSaKYmq7b+dCMcz/P39V\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAVID0IM8MmmUokt9lCwiCMhAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRlYzkxMzMtNWRmZi00NmQ2LWI0OGItZmRmZjEyMjk5OTRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDcxYmM4ZjItNjczMS00\nNGIyLTg3Y2ItYzYyNDQ3ZWYyOTI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGER5RZqYXKdYj3/eJXDP4pXae/53jhcjd10sUmZCfJt/11sZW8Y+keAqGda8+FHI\nCceLO+VckkdRI7JxN0UvaqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJZZpYZ1ZlDDRYfiA\nbHSoi1EbriUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBPI09F\nucryMgIqocICZ7dLhhCuAMJ8ZD2wHC+WS63OtQIhAM177eG0WPpw19bnTrRrSTP7\nYRzjTzQ+oxUBSZ7x/gAi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8193", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8193` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAawZqWh9pHuoWBPndS0C/ClcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczNjBmOGFlLTkwZjQtNGIwMS05ZjNiLWRmMmZlNDMxNjZhOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzVmZDk5OWQtMDEz\nMi00YjEyLTg4YmQtZjlmZjcwZjc0MzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESrZiCW/ccqHGsimO8Bf7Y05pMFlwnTF343GZdErNoQ2UsQbAjpYevhGaZG8T\n7fQUOhjUqe1krHX6bYCmFH9rhaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjCo5l/0pThmkVHwvA9DlsM+uClUwHwYDVR0j\nBBgwFoAUhnM12NVFVR/iJL0aEF5OMqrzJLAwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBJUBVL4/RZQpE6\nkDWTjdxK6QV6Mlmwjp6TfNff3e7AJQIga5LKXJdgZC6sXuKt17OPg7F3UT/eQsCf\njdPVlaqvoTk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXMbBLOIeMiQ1yM5ceADEyiIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzYwZjhhZS05MGY0LTRiMDEtOWYzYi1kZjJmZTQzMTY2YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9XrC7qIKUFHDSrECcQRWyN9YWOXBK7n+HmBjznl1ms5G3\njtGgRs7oSXUz2mk1ZdPn2dgIRrmLb4JhvAEosvoHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhnM12NVFVR/iJL0aEF5OMqrz\nJLAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP1NW5cbAPbsmIAEwW2mfuwmntaXPGo7JORJx6e/4ikhAiEAgIwxbiDo\ncz7yzLF3bmgfgexUq7lHs2ItOWZXrfW7lPc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXYt+C3evFOulGQx9l4zjlp6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzVmZDk5OWQtMDEzMi00YjEyLTg4YmQtZjlmZjcwZjc0MzRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzZlNzBhZDctMjA3NC00\nZjhmLThhODAtZDgwYzRiMDhiNWYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nu+sQW5+UvKgZFILm/pIxNB2uOJrngGgXAZQWh8bqgQOa4SyoiDz6WYOPpbFhAL2G\nboNvL6D+Xwmo17bsKMDX7qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjCo5l/0pThmkVHwv\nA9DlsM+uClUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA6Wii\nGiAEcgixB/Fu23uMm97YirvURIo+r/gut2VZNt4CIF1JS1r9AV8Em7Ep1jsWGO/u\nKDq16QPhHi54M1xeqDoB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8194", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8194` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAX+S375YrX1SnL/G+x33CqGCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhOTNlN2Y1LWRjMjUtNDhlMy04M2RkLTU5ZjMwYzBiODRjZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzJlYzM3YmUtODVh\nMC00ZjdjLWE3OGQtZGFkOWM0YzI4NWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7UEQdx4frl/4LGNdA6KxfAqA/DecPIz12WJcNH6p3hiKWoOeqwX+xD/GYEaT\nJ+KMAy0g2HZIOW+Gx6GKHNZuu6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9OF3mF61cBmzmKZGXaHq1rn91C0wHwYDVR0j\nBBgwFoAUr5r1kt8GUFPW+DXw4/lvdM9KICowIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAqWkfHgvURjfZUcPOMc5m\n7tEui5lDKdi2CDzUgAGPhAACIHUFbaUDB6XKntY/4kPf+PWZ+ApqsGrj3J+i01My\nrmKC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5Xcdr8ZqbMB8fi8efoXMkqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTkzZTdmNS1kYzI1LTQ4ZTMtODNkZC01OWYzMGMwYjg0Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIIzTt2UPktRCV17dZaxEJTzUGPR00wYmrN+pAFbfeiK9o\nycOF0SfUlYlZa+Nx1n0qUfCmWSbGGD7UrACeW2TJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr5r1kt8GUFPW+DXw4/lvdM9K\nICowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVkNcc+C4gon/ba2K4P0GWi3MRQ9rIBKS3Adld+pxWTkCIQCaFd2UmnvG\niNKJ4UM5sKqHhDwr9Xpfh65a+kimTNTfxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAWy5Asw95xEk4C4y6wqrIZo9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzJlYzM3YmUtODVhMC00ZjdjLWE3OGQtZGFkOWM0YzI4NWQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDMzYTlkNDEtMTY1MC00\nOTVjLTgzNWMtMzg3NmIwMGZiMDlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzASDuFq8LPt/QH50DSffkdKdF5Q6SmXzZ/uPUjLPuLldUmT4exE2vtfT8NaFkjOU\nFRrt4AGwSzFmoswBQRQrp6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9OF3mF61cBmzmKZG\nXaHq1rn91C0wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA84KG\nkt1gHMyFDorM43/SLVJpbFbsWG00jTY5pXZuUv8CIQDIacLS/zinT2FRRsdlhqaS\nfcBDjk1ijImbGXOSIFmirg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8195", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8195` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAYzjS0R7e7j6oHKTCDF2ZoX+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkM2NlMjc1LTZmYTgtNDZiZC1hN2Q3LWYxNGY2NmZhYjlmYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdlYjA4MWMtZDA2\nMC00MTIxLTk5OTEtNTY4MDQwNTc2N2QzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5C3A8wKtwKXRGo0XqUH/pxAVysTqIMCrVE9sTd5AfMifYSlBkp98G2UjyEtj\nAAl+GGNIrN1abzIdoG8hFaoiNKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs6vz7GJ7+KiM/SeqrTJnQ9z4KnEwHwYDVR0j\nBBgwFoAUqVxGlM7kB1Y5mBStupiWguICZUAwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA6EJu\nwM8SGpLoRkThSYqL2UfoPan5v4dFAA6xt11R9ygCIQCNUwbSiwcNuiOTZeuSYtbC\nPFTOExFsM5z+0ZaueKjY5A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYVYcigmjFTUgTb+MelEM2xIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZDNjZTI3NS02ZmE4LTQ2YmQtYTdkNy1mMTRmNjZmYWI5ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQysXZ1jl7khzCXWz1kcaDcDr7HmVyZsjIvPCC+Ci9eeyDv\nVAuGwFsKFt1LTcP3fKSfvAr7nNLh2Ud14sE693/uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqVxGlM7kB1Y5mBStupiWguIC\nZUAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD4cHPry3+KCXKr7pUccVGOQiLTrX+32l3d8g6kORbV8CIG6upUu6EShE\nZk2DIUtCmdv0vYW8kkBX1iw8748BpfAU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAS7i4P15vZY8W2L70YKAndKyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdlYjA4MWMtZDA2MC00MTIxLTk5OTEtNTY4MDQwNTc2N2QzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTAyMmE4YTMtMGViZS00\nNjdjLTk3Y2EtMmRkYzAzOWYxZjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6bwwem0fBMjREccXsIS6XQSa3++lD4zJANXJS1IRUMN7MHmclFQpHtAiHoWdCLit\nZfqEZwgDWBEekGeo5RywPqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs6vz7GJ7+KiM/Seq\nrTJnQ9z4KnEwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAjoz8\nYPWATMhpUCYQ9jmrNaHc0jP1HBnUV8K5olBEcjMCIFdSf+vhZDxznAGenx18JlbI\nhHBMSNHP+GEKy4dGYCSR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8196", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8196` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISARsxsfcTddUANwEcidyfoOmJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyOWU2MDczLWRlM2UtNDhiNi04ZGJjLWQ0ZTQzYmU5NDViMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZiZDdjZWEtOGY2\nYy00ZjJkLWEwZjctZDVmODNiYjM1ZWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcTsjH/ZkpP911yxnkjnu6G+7cDZySpIj7ezGxruE4j8vnMTFaWiv/Vs0NTi+\nXcdkb83zXMwKBorD/pFmeAlu+qOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxyT3R5x1oHH8b7xe3fX3Rb2O8NAwHwYDVR0j\nBBgwFoAUDDQ9XfUFoG5E+9ZN0FT1ys2qjPYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBhIPkT\nMfbOF5krwL8oHsNSScx8ukinpImph08O0ENYXgIhAOMCkj3YOSYo9yTjUsG92sQA\nPsd+TRnYqj5yWz/JK7l4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa+SiKeGye7xanJyiEHm6S3xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjllNjA3My1kZTNlLTQ4YjYtOGRiYy1kNGU0M2JlOTQ1YjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6CXEgKaCYt6Wj1Q3tOlM1e4st1dYETeowFTYFvFnF2Vo9\nzKXV/L8wREzCJm1b66Q4rAzPDx2SHWU00d25TtSao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDDQ9XfUFoG5E+9ZN0FT1ys2q\njPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOl0Ijj67yU2vzaEAHqPQv0UbLBRrBD2tNBSzEm+AXQdAiEAzilHHQHL\n1Bmgz9+lpWUtG4xsS77tLqvLUFY0jgdUD4M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAeu3I3Vnk8VH1TSWjodb+cHGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZiZDdjZWEtOGY2Yy00ZjJkLWEwZjctZDVmODNiYjM1ZWFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzQ5YzBmMDctMTE5ZC00\nMmUyLTk0NjMtYWM4ZTgxYTAwNGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTz/C+kmlclWRpxSKLJgrK/3J+YkRmkXl5Y6SjTXJPAxDwRNjYbH5XHHBAyk+b/k1\n3Sf5UTKuUxPT1gbsDYaJGqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxyT3R5x1oHH8b7xe\n3fX3Rb2O8NAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA7LRVP\nwYL4I9qHtqe+edDQYK5EHsD+VaiwzYQ/Q8NjWAIhAOsUOBx5cLoG0S0yDpQ1Jipf\nu10jBpo0ujAT2L4PXFMU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8197", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8197` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZztckv7YnZm0oj+hdhJKPUkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3NzFkZjJlLTMyY2YtNDg4Ny04NmU4LWNkOTJkNDlmNmI3YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWVhM2ExNjAtYWNj\nZC00M2I2LTgyOTAtZTFiMzYyOGQ0ZTliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECpfMZni8uK6nqm3LJPsazong0OC/oUn0yeF5f0BaTFIGb/j2ynneL7EbQCWQ\nGj4J/Xajl2hVQzC8x2MzwY2AYKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFpWOXpgt73l2wSEMGEV6hkeUBQ/MB8GA1UdIwQY\nMBaAFKLEAgyzFj1AWKtztOn04+AEZ6ZVMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBarkNZEixffzleho0EtrBgmSI5XtUv5lsz\nv8h8xPSclgIgMN3Yiu9aFf0KE7Y1SWM/PKYjAuvLFMk77EPUC9YzmiQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcb9eLJ2j8+oj+3RjZsfjNAdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzcxZGYyZS0zMmNmLTQ4ODctODZlOC1jZDkyZDQ5ZjZiN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATA5mZtj20eFgamld/ipRjVyg63LXJZ25NMoTybtmJ6lPo0\n4ezuD5YMm5K2Kf7VSnWAgGMcVCIZCnoFe3NF8EIBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUosQCDLMWPUBYq3O06fTj4ARn\nplUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHVP9L8eBk6TWvNHXAzJ1w0ZTja1bjnNrJXSzMdu6gHMCIQDkxCBSs34i\nGLq/O4I1pWiV9upQlHNTzWY9DE1Ds/tgdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAdpzoL1cHba6X/bk17+lgcnXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWVhM2ExNjAtYWNjZC00M2I2LTgyOTAtZTFiMzYyOGQ0ZTliMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODU2NGM5OWUtMTgyNC00\nMjk2LWIzMDItNzZlZjc4YTRiYjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niG3WL4X0zYK6NcBzCMHZJl6K7O1DKYJLulO6FV0c+5iIk/0Qj0xqK7WS3/AqNj7k\nK2hhzETc/MMaolMRsNFJL6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWlY5emC3veXbBIQw\nYRXqGR5QFD8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAs8HQ\n2DzYwcj0IPayjjjYbPO5u/aIlqfx1CANow+Y8h8CIQCrtAz52mqXH5UDcnTAzDPe\nde2XXvvekgOv0JzaeQif+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8198", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8198` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAV8WKMihnDEO1NrFjXQThzucMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwYzZlZWUxLTlhOTYtNDQ3NC1hN2QwLTE0OTQ1MDAzNTgxYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDcyOTI5MDYtNTQ2\nOC00MGZiLTkwOTYtZDBiMzlmOGU0YmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENWcjV40WripYhNj5w0GsubrAYUow9h7xCaD0O+tWnZxv1QvU2Ga67vryyjdc\nkxq9fUn3Ke0C1SsMjbVfIWPwxaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAAc3099g8MsMIdNCYJ6bPxQ+94QwHwYDVR0j\nBBgwFoAU0/KHdGmtNoq2Uv14pCehf21WO6EwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAPbviqu8cI2A\n/AnJBOZFcd2dnxlqztnJ8Djd1sMDaBv5AiEA/Fj5aRrj1wD/SVH6NydwiuEcpYRt\nW6X8R+OCy0A3Yy4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdKx7MGG6BhJY7bZ1zfQnDSPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGM2ZWVlMS05YTk2LTQ0NzQtYTdkMC0xNDk0NTAwMzU4MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9SrOU9c5Mybogh1Am3OPPx4EW+m2aHWsjpXS1v7e18Ufi\n3tEo2b788jI9rF03QBvaeoK7FWaLfRggFHph0nhZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0/KHdGmtNoq2Uv14pCehf21W\nO6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH7pMLLaAtdWmWFQ9FgXWIG22hSemUMnQD5rn3ZaJamoCIQD4uG29HRQD\n8kwMZqJmUGvP7hYgn9CSlCWwsiXJIZrN6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAZEHpAWn9+TDc2L/6rJdg2wWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDcyOTI5MDYtNTQ2OC00MGZiLTkwOTYtZDBiMzlmOGU0YmM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTY5OGYzNjgtNjQ1Ny00\nOWJjLWE4ODgtNjFiOTE1NGY2YTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\npVOpAxCwHJH997lAr8NLEB1T6Nyvtmyj9o/6WtnEEYGRMen14P1MoOKTRhsThyr0\nOZdyRoKISZcYvTW81lP0ZKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAAc3099g8MsMIdNC\nYJ6bPxQ+94QwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAmOZM\nKMwBeq4SaFJkdevtK98Wlf1H/+iYTAJNb3kxwdYCIQCJ6m8LWU6CCRSCZ/aFBFhm\nOdQ0TWjXwsNyjkGqsyywLA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8199", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8199` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQ9OFq2FSL81ZpEluF+XAUnpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4MDg4MDk5LTYwNzctNDM0My1hZTcwLTUwZjBlYjIwMTMyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVkZjkxMGUtZDY1\nYy00NzcxLThkZGItMTE1NThiNTU3M2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0AS1bdxZ9siK33slm5rrqgXqNq4yWHsnyrgaa4ws1ooSK0J6rmW1ckJW3rVk\ngiT0mjYmfC16BVZUqzejDWxkIqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuh5eKRBYn+VzXazb3Gi4rGUJwK4wHwYDVR0j\nBBgwFoAUAvIM8ab3GcgkGbrG/nCC6xP9MDswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPTHXtMXNbPj\nX19lm6hQ2dLkqrljQaF1/mgLQ039OTWRAiAch7fn7BB0iXI89is0pLPIYbXzECPy\nXITjtqRA3KjDyw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY/jt8VkTSUbtapvO5mJFhvJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODA4ODA5OS02MDc3LTQzNDMtYWU3MC01MGYwZWIyMDEzMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQxqQflNDjkYZfcEVVC0i9Yq+enHZy7gXhbyFliWrP7gBt\nQ/w+56d0qblNPz5hVCySSBtje/IB7i14O7fwVpxbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAvIM8ab3GcgkGbrG/nCC6xP9\nMDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCGk8AX8prbsDzN3vTr5qw4qI9EwYQ4uVR+fKHRIjdosCIQCajwxpqYC7\nkn9FXBaTFHNGETHmiW9ZKwD7jB9EFcupYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISARvbjhCWyZ/xWzHwDUvHmhdhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVkZjkxMGUtZDY1Yy00NzcxLThkZGItMTE1NThiNTU3M2FiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTY3YWMzNTctOTA3Zi00\nMjUzLWI4YTAtZmVhOGM5ZTNjNDk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nER2v/eCEw6PqAbfD4Tw0sRykG8qOwWa5MStaHdh7srWZXpuiaxW/DV6smpJkq/3I\nJ+IpUUbUkRmNWjttFd2QRaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUuh5eKRBYn+VzXazb\n3Gi4rGUJwK4wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAwkdd\nSr+7XVhQ3x7KnoP4RChqpizi8DBe5E98qzv3o7wCIQCFlRe86iS+fsP0i+aiVu++\nsiBzCOIi6pnqDPPiKNODog==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8200", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8200` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcGVoMiINf+3/Sftb0G3PGzgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjNjg0YjUwLWRkZjctNDNhYS1iYWY3LWQ2NDZhMjMwZWZkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjYwYWRkYTktMGZi\nMy00MTM5LWJmMTItMzgyNDQ5MWFkNjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcs8WL6uuIVfFaH0qZliy7oofYDRErLfxk0br7O8NR9Huc5WkPTtT+0ZTPCJB\nyMwIzdXsahldOtmYD5u+wSvHyKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyHROcOt/Dm09kOKyAXtOVmxAq+owHwYDVR0j\nBBgwFoAUB3120ujn8Kbi4+X0BWXqLdGVCc8wKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDv6mnFxtF+\nqsizamDTM32A/jsQGh1OKTOF4zR7mbo73wIgZfa7RzdXLLnre+C26mqQY13jaMZ1\nLEUZvTCU972g6RM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQcEEKzlN48Xz3VnAHsK1IWgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzY4NGI1MC1kZGY3LTQzYWEtYmFmNy1kNjQ2YTIzMGVmZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9S84qMeb0yZOa6x80qm1EM6kGCOzdPKfUBe1Ewo+S3H7k\nWizBHMyFXEOu5k51CFY4+XLhzzK/nB5gDFEB41+ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB3120ujn8Kbi4+X0BWXqLdGV\nCc8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZvJ9mgH+3Zs83ttX6duGuGZq5+Zl+/a9tUoS3IaZViICIQD2eLwdpX4C\npAicB2ECZT7Uxe7yOn7u03bBzMX1PSgptg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAWK8qJAdXyS/WdnRP4eXMdxuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjYwYWRkYTktMGZiMy00MTM5LWJmMTItMzgyNDQ5MWFkNjQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGRlMTVlYzItMDg2OS00\nYTg5LThiZjgtYmVmYmQ2M2EzYzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njyNevPYNMftxWksrWkvmf8luyo9Aq+IEBPTucNprncpqAgIFZJa5VkQYbrhLah/J\nJoIN9SwYmJySeRy3L8kFgqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyHROcOt/Dm09kOKy\nAXtOVmxAq+owDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA5d5o\naD12zW5uxlDcBfUDm27T6aEnuyZPgueGFJQuMT8CIAVCaK48uN5VdbsJ0OsbSYzD\n8rBRXdHHrWk8Qnx5NpSn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8201", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8201` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAbEp3/F28VKmy/sucPR1cIPbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2MTY5ODQ5LWY4YWItNDk5Yy1hZDgyLThjZmEyMThiMTE2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDVmZjk4NzUtMzI5\nNi00ZGEwLWJiZmQtMGJiMzlkZDQ1MGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE319uszXTWs5c/CYDE3DoVEORKkdsIBxjs5kQ6eolNx3PJGweYRkn2ILGZ3pH\nwqJZGYma1MnxgtqbhoCn3ewQYKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Aa4uJktNuiiVx4YrQGonff+a2AwHwYDVR0j\nBBgwFoAUj4UCAZpJgGpd7xIOLMDtxuCKuN4wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIANJCsLa0LBAKitdsy7846c9ZAB0KCyWl38ZGml/QDDpAiBFd16JHxRzSYdn\n42BFnS4YwRneaZ5DmotqQKsDTIIySg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc7WfWjWxU/ijAESKN+rpq2oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjE2OTg0OS1mOGFiLTQ5OWMtYWQ4Mi04Y2ZhMjE4YjExNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASByEwEAvPk8vXqBeZZq7l1GW3pEyX0se6O8mEa3zTuT0OA\nUncS0JbNZQ02TQ+SMnYAfVKgfbL9FpGn1tLSYftRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj4UCAZpJgGpd7xIOLMDtxuCK\nuN4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSuxMYt5K05cR8mJtRU/QuDwFJdwnZGTeTnRgoDPPIYwCIFA6nltqDzJW\nDb6Tvg6uTjn+rSRxRf8E4Z70XEXHp08F\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAdVyX++SA9053tC1fivUCKZIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDVmZjk4NzUtMzI5Ni00ZGEwLWJiZmQtMGJiMzlkZDQ1MGQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTRlYWYyZDUtMjQwOS00\nNzY2LWFlYWEtNzkzMzk1NTQzMDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nESqNwu4d7eit2P/uregafNrYjJQiDghC6wLMUea+y5K2pa3/FgzfQyN+KkvTxo6s\nsOEbhgQmAwje4fbtcqGebaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1Aa4uJktNuiiVx4Y\nrQGonff+a2AwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBSxTeb\nD/NYhNro/2Lw8n0tOu1+e0d1x5JiLT3j45E4wAIgCuP1kCVA4iRl5Ax29zY56FHR\nONBmc/ag8sXjIHHVkGI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8202", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8202` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAUfnjC16hSXM7Aoz9c0EQHsbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyMGQxNWFlLTIxNzctNGM5Ny1hYmRkLWVhNzI4ZDU1MjZmZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNlNGMxOTMtNzM1\nMy00NzI0LTliYTYtNzFiNzVkOGNiMGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENNEHO1xo945li2lDNWS3zSCRNXJGrjQR3wa3gKhzS68yG9kG0fY2615x58MX\nS2V7/jg2W3+vcIBqZB1gk4HPq6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTTZqBEy0m0Q1FpvgQdglN22tG0kwHwYDVR0j\nBBgwFoAUOCaMplJykn7w5k+u1b7FRPteRsIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDqL8U3LtQk3RiqXtQJsUUs1Ei9YQqHqefALvf+uUEAWAIhAM2HvioWf6J8\nT6yNMmbPx4hA6B2mi4CB7FsUVGJ3zmPS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWCrix+ZyZFUJv7d7uNRHXeQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjBkMTVhZS0yMTc3LTRjOTctYWJkZC1lYTcyOGQ1NTI2ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASTQky8eVR+q8K23LQu5DDUxF4s95kauA2QqNC9KBjuXxZL\nFqa01A4gRilabX73AvJ0YTGdbssV7COthAZNqZNzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOCaMplJykn7w5k+u1b7FRPte\nRsIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYKdmo7inZHA9Sr+Po5j5kubd1YCDAg16SUfaXny0/7ICIBtzKht5UFZ9\nOZH5clC0lxa38LNfYNc0bUDjk7rh5Or7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYbCcYZHr1f7v1wl4ZXQCBTzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNlNGMxOTMtNzM1My00NzI0LTliYTYtNzFiNzVkOGNiMGJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWVkZTQyZGQtOWQ2NS00\nODFhLWE5M2QtODQ0MGUzMjdiZDI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTUd3IYmk7sSti23nxuMrm8oCdoTu9SgvTbdONqwhEdKMo4uG9XlNqBGhemc1dhqS\nddkpe54bzSPprCbiQCLupKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTTZqBEy0m0Q1Fpvg\nQdglN22tG0kwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAZ5pZb\nZcgm4ZIjhDrJx63S7hhRH7fPshZUUYdA7+TwPQIgeUZIBBN5xCg5tV02ksPq7m0K\nNlmXS8Q7gS3khBi0eKI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8203", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8203` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAZ6s1gR+lSvGF5DsKso7q++2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YWMzYTcyLTFkYWQtNGNmYS1hYmJjLWQ0MDI5YmFhNTIwNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY0NGViMjgtZGQw\nMy00MjA5LTgwYzEtY2I2ODcwNjU1ODQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAE6XRgIMiWBOJeFoH1hb7pP4PoxZJZci8+4xrSfNm8nXjXO4fNi5xuHhVzNH\ntyFw5zRzquJhYXxqn6zWAqwQXqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeznzaFyOPGL9tN5rYKQQtNZEtkEwHwYDVR0j\nBBgwFoAUMuc2Qs9deR6Cnn1AkKxuicPiHVgwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCS\nJ7ZLRosIHTaPRESSatTFaqDTaQaQPclqkR222FGq5wIhAPYMtIOug2tExDIgf+yh\noyDPilkYm4O63K0/f76Qt7OY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfj4wCyPmwMNZ82rNIKKeEfYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2FjM2E3Mi0xZGFkLTRjZmEtYWJiYy1kNDAyOWJhYTUyMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUOjSOTBhbEXBDUnJMcktxjjT2ccQXdIQpPuPzoy+Eamyv\nSstckI/Ow+fzSoJTCZ76JCwupR2vwbEyB7/Nw1Iuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMuc2Qs9deR6Cnn1AkKxuicPi\nHVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQI/jxpflw5wOL6iNAt7MGi7ZRE/v+f4uLuqVTWNl0mUCIAdTY39o6640\nm1jd9IEtzy7YvrxvuxT3p7zZhnw0kYfm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAaYmCZ0x/2YSwZGV8dhlr24DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY0NGViMjgtZGQwMy00MjA5LTgwYzEtY2I2ODcwNjU1ODQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGFjN2FkMTQtYjQ5Mi00\nOGU4LWJjNDctYjA0NjMwZDkxMTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nI+8h7Ssj7aDOmgAZSp07SlS1v+NDHnvgEUWGdlEnBT1f30xjN8NslJhNhbIl5bcu\n9yc2Xn03gj83QvZrZFx/4qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUeznzaFyOPGL9tN5r\nYKQQtNZEtkEwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBbaaYY\nQSjwajTYWjpHaBoGkHhdnTxeRB3oQer6ve6L0QIhAKm5y95MxjQb7/crgLPY8I9S\nC16By1CZEoZ77dow1TR7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8204", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8204` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAV8kI+o4PTmmgboC06UB9oLJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwMDIwMmI3LTk1MDMtNDhhOS1hMDNhLWM1ODQzNTQ0MGIyNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQxZDYzZDUtZTI3\nYi00ZjMwLWJlMWEtZjM2YTViOTM3YTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcCLa3Mmnpn3FdJGQ0+bmPWckeZ7jrrmeqJf8WlVoB3kPYqUHVawTC+vnEBwb\n+OpI4EHz2TdhRWvMYXB1m3ZsnaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHatY7610c+7DOkYQGNKwC7ZksecwHwYDVR0j\nBBgwFoAUf/gF6MQm0xVIpbSUu2sBXP+k0fEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIHyV0JMDBbGyfmfXzpIzJ/a2A/rWt+nIiImZ3S4E/Iz0AiEAt8+c\n8oARA11M8N0jJQS39ChmGfNhpR8zS4oh+2rvqys=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWZBQEjhT+WCMtz1M35X/ZLVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDAyMDJiNy05NTAzLTQ4YTktYTAzYS1jNTg0MzU0NDBiMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT72sGy9SAU1zJtO04v9fxIl1V0rREKlSuyCK/TLNUECAAi\nLoHShqKNjbWW/SLna1zLOHNwmf9TydCIDU1888Rxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf/gF6MQm0xVIpbSUu2sBXP+k\n0fEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC2dZJaI5qDKZl1DcQ0rioZuWn89Ejk8sXhUvFDvBlg0CIQDyuTRW+6Oj\nnc9yzgOHsiLpNJWuj6LJWOimZwG76hd2pw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAalSfj0JKU0NrJD+P2NurGSGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQxZDYzZDUtZTI3Yi00ZjMwLWJlMWEtZjM2YTViOTM3YTkwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjU2NTM5OWQtNDQ2MS00\nNDRjLThlMGQtZGJlZmQwNDMzZGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvFdzdM6YejRIvPgHAz7d6KvY1nUNp/AmJRyb9TeQJWrDsPdA8QMyom7IFFIBqFn7\nzyLCaGmEPG6D6uhc8bofpqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHatY7610c+7DOkYQ\nGNKwC7ZksecwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBXNSjU\nAMT/GuTN1WyjvhMJPnhBim4R8LFwBe7m5icPOQIgZ1i1vqxstTRIzNOmk8gFgg0A\nOxEKQmXIAWzJBR/dAVM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8205", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8205` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISARJIrkL0loFNbFr34bCVDshqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlNGE2MThlLTNkMjMtNDJhZS05MzQ3LWVlZmI1ODZjNjNhNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWVjNWY1YTUtYmNm\nZC00MGJiLWE0ZTQtMDgyMTRhNDZjMTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtIROttVGwk5vE2RiJeJgnXsMuM4qxv/1ws2O0UcsEauesKz+h4alBmp15dKW\n55c87aG27bCoC540lpx1I+GloqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4U3VGoNt/vAX6WqKI9roQy6ciU4wHwYDVR0j\nBBgwFoAUM8ZXfoIa4KODYiusNkSE84j/izYwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQC8vlk1H+Aky8Vvv20oj6U4jU5R8f5nOiOWuOHrL09qtgIgKfty\na5k4XRHmAzohIksmw89EV8E90d0bY9rU2FR6bMU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc1jelP7t4UPnpTQomBhvM4jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTRhNjE4ZS0zZDIzLTQyYWUtOTM0Ny1lZWZiNTg2YzYzYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzQk6CJvTj0Q9UhPkGPXRS8edUDL6fko3UgNYa20HNzJKp\nMXQBLBPMKdL9I+NyeQnGl41LhPtTdvBg41VxLKFwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM8ZXfoIa4KODYiusNkSE84j/\nizYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPv17vvTwt7K5IChHJgkdEnOVfG7p+ZeoBSy+8dqpiLnAiEAl8SSCCpt\nlc9F+Y3YayTemwtm4vFom1EEeryUjxkAQEI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISATS/ji8jUF1o2snCr8PcrgFjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWVjNWY1YTUtYmNmZC00MGJiLWE0ZTQtMDgyMTRhNDZjMTUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzc4YTNiNTUtY2U5ZC00\nZWNkLTlmMTYtNWRhNzc4MDVlZTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQEPivb2NJd+4kBBMJHz9eh0Z2Ga5Nk9l5iPDpqw6dXsscusAiag2MmBazFtGvdor\nvPP/MxC1eKHx/sAuFEnXx6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4U3VGoNt/vAX6WqK\nI9roQy6ciU4wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAkOaC\naSfWtv6t4idbHkk47/n7WjakOEulMYo9x2rjP04CIQCdDZRa9Qj6h8LeAeV6De7G\ndldrt/2lxggBQVBU8yHYiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8206", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8206` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQebx6+yFTiq2PAKXWpxy/4RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzMjA1OGYyLWNhNGMtNDkxOS1iNmJmLWQwZGYzZDExN2YyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgwN2IzZDMtMzJm\nYy00NGQzLWFlNGEtYTMwYzdjODY0NWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB8hUODgcpjkHqQ7cEdUuu82BtnFxBu2/GdNmUoXSNsN9LztL8GSKRpv9lttP\ne2kS1XuGwY0ZqQuoSArDR1aXkKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLRNT0Qz1w07LtvVje9hsE1OY44MMB8GA1UdIwQY\nMBaAFFVZA4bJHnGMPeiruE/XAsJdp8TXMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBCc0tcxcVq1wpqBG6Pc45v1aqZuApWs52z\nnPMyArrjYQIhAOiIgIQHXMrsnll955f5EqEIDZAbwqp63BWTEZf8V+Pf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWYdCjbRvy7uLB1IK3NZ+Y0XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzIwNThmMi1jYTRjLTQ5MTktYjZiZi1kMGRmM2QxMTdmMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkH7C62Em0T/IMWcpsrIc1r3IxIzCGXa08+nVkfDghf2p3\nTlh3FMP0Z63gKw1sGmppLdjbqeEfBi/v9bOUEn/zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVVkDhskecYw96Ku4T9cCwl2n\nxNcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALvplZKSqOpgzw2EVBTXh027QFu2gAXFwsXzWd85raAbAiEAt3ssxjox\nOc9+ZQKsFqRi0x54byhYgozq8HS0Sc7fGs8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAZmXuyvtt4MRCjlkWvtnpgG0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgwN2IzZDMtMzJmYy00NGQzLWFlNGEtYTMwYzdjODY0NWQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjI2YjlhM2QtNTFmOC00\nNmIwLTg0Y2ItNjVmZjVkZjllMmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsx07Lo+zk3X0vSwnZN67KIkqssXb7OUy77g7Jl6wADWWf9PFTeUQ3pTtqCyPBy5z\nlSeh87tD1UerFETTUum7M6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtE1PRDPXDTsu29WN\n72GwTU5jjgwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA5gAN\n5oJkvbpTrCCJOFDAmXFDEj5UTFY5un5VE/KW0+wCIE+9G+3M28BZspfDwCsAwBq9\n/5kXRjhYca4cbr58hSel\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8207", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8207` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAeGpPOIaCcECpG/WFdp3/x68MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkZjJjNWUyLThlMWItNDNkMi05MzFkLWVhZWU2ZDkzZmExMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDZlZjlkM2UtMjA2\nYi00OWVhLTlmYzctMzkxMmU3YWU5ZTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBlMzH0Wq41mJbwc+Otd3Ik2HIU+MwmAw1qAD0y9Zf+7wkPESZo88nRoyFJhO\nNjUggkaxADcOEypWvk7UofNZa6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ktnBfbh7aDWdVGnaPQvqPkCA9AwHwYDVR0j\nBBgwFoAUQW+B7bYVOCWT16Z3V1vtZeuXspMwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALmbJ8thMTnE\nUU8dnDPaMM63WETcDdiVm5upqq/4j8ypAiBmlgoBjHZt1YM3ArdcbhzYY1ln7eeJ\ndaW2Fvws6uCEPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATQFTyBhqpRA1AGlNUVmgZZJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGYyYzVlMi04ZTFiLTQzZDItOTMxZC1lYWVlNmQ5M2ZhMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ+5sEoC7JlF4PlhE5QUQw9c3Aut5MqIk0d/Kf0GBQsI8HC\nN1qfcW73hPOkXhLYeYNk5o6t1Ia/IUwycHxEwSDfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQW+B7bYVOCWT16Z3V1vtZeuX\nspMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBjvW1iDF3KFE0OAHNDtHYh5/N/Dku+Y+efB/bCoR0WYCIQD5aqCvVUZW\nCEL4UJWmA+blqH8PcvwaMXBIF9I65tc42g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISARby8ETOPCsjngGDfASt8McxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDZlZjlkM2UtMjA2Yi00OWVhLTlmYzctMzkxMmU3YWU5ZTYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmE0MTk2N2EtNDM5OS00\nMzk1LTg2MDctMjY4MzFlMWE4NmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nS+mxbF859D/BexvSQARfqaOMm3WI6Novip596DHBxQh1opiHN/b5I188HAva6TRp\npbgx4ThCV/NJDaR6Q5a1B6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3ktnBfbh7aDWdVGn\naPQvqPkCA9AwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA/yQe\nVtILiU0x9zIwlT5/Ie+f7Hh4M/vrirg7S27yNwQCIQDYNfBnIvBKxYsURErOvkiE\nea7MgKEhSWQF2sjOeBF+Bw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8208", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8208` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAcXdEdXIE5jt3VXnJZ9FJkydMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyZWY5OTlmLTY2ZWItNDNkYy04Y2RlLTZhMzU5MzA5YjE0ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFkOGZiYjMtMjA2\nYS00YzI0LWFkYTktNjZmNGFkM2E3NjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6pSdcAL1fkNq3XCG30nCfX3BkLs6JwE9/QYu3Co/45tSZcdbn3c7ZH7YTn3c\n+uYQrS6VxpPjgLUs3vegN9cZ1qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdijl0ZLnnzIA+34buEi2i0hIT/IwHwYDVR0j\nBBgwFoAUUygzgizuYuUqmnDT5VTCcQmOkzQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIH7LLRkf8RK\nvTkY3zMJHsYG6QZ2KyicvyxJ+3GWG+j4AiEAwxIcbB52PGSTS7HNsCb4ss6SVe0H\nHN5sXd8IjC+5hZs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUIXeB/Q9XeztnptuL3rNXZrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmVmOTk5Zi02NmViLTQzZGMtOGNkZS02YTM1OTMwOWIxNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtuDY3xw42TJ64DqSlT+qHvOpfCQ3cIcS1gQ+SvBetvDK8\nwAwx05DszN3R0OY+vhX/g3ujB9+jtNHWHEX15ZYDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUygzgizuYuUqmnDT5VTCcQmO\nkzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV3jrPvgwRu6pp0QxC6EqzitK+Lt2f8ZAZGZYEsTd3LoCIQCduBRgPblu\nqezzRJB5xB58kTKMPW7aiNnluiXBTEigSQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARgSV9UodaVRS9H8X1e6b+ISMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFkOGZiYjMtMjA2YS00YzI0LWFkYTktNjZmNGFkM2E3NjE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGNiMTIwNTItNWY0Mi00\nOGM0LWFjMjUtZGZjMmRhYjIxZTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJDxBmHxnCh9McrTt2wcwodq/cJJWqx95j1vXfIKSKWCmiP6WWX6YTr34k705eb/h\nI5VtqtTVPWkDLk9l3CV37aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdijl0ZLnnzIA+34b\nuEi2i0hIT/IwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAY25yZ\nkzLe0EaonRsMyp/0hEXlgAKnRYrCdk6UnY2NZgIhAIvesWEVYY3aB67Il9HECiJR\nMIT1Rdb+Z9WcKsukOoI+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8209", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8209` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAQgBUne4vZlyDuELfTo9mQ98MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0MDY4YTY5LWQxNTYtNDk5Mi1iYWY2LTUyYzJlODIyOTJmMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhiNTkwZDgtYTI4\nNS00MjdmLTkxOTUtMDQxOWQ0MjNmZDFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIbFTXorDvrih6qr9yWq49FKH4r2jWxlX84fmu38ARENpVnfDag1fpf/oPGer\nFyuiH4JkuHjdFxbCNFCdLwDvf6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7un/p4tHYATknSZl9Jld5dOXl+EwHwYDVR0j\nBBgwFoAUp0gI9tjmh+gVvMZsqzEhqyda+sAwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHNyI4EvVoBJ\nNKIWenkLv5O6ckezbaUxP7wb7nCmx9k8AiEAjJA7YD43HfgRO3t6z/e+P2zEy7ZY\n7wYbhtm3/0aED8Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZkziEVoHWcngu5PoBeBVt0VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDA2OGE2OS1kMTU2LTQ5OTItYmFmNi01MmMyZTgyMjkyZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSW4xo2kLbMNBFpjbgJKbAOfqXCAidVD9ietJAJuSXO4Tr\nX4HlsgZt1oCuYKdV0O4qLHT5GtUCamyshrC67phdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp0gI9tjmh+gVvMZsqzEhqyda\n+sAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIma/3DfmaDMA3M/IdpPtcKXepakvvmcO1UTAvkFF6d0CIFWVlDrYmUcE\nEL2i73IffogFEpOKBoUhJT+mVGwubcfm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISATBRvZ7RHMkwJqxVB9p5nr1tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhiNTkwZDgtYTI4NS00MjdmLTkxOTUtMDQxOWQ0MjNmZDFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDgxNTVjMmUtMTYzMi00\nMjRmLWJjNDgtYjI1Y2QyZmViNDIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noL7XxWVWRw6oBF5mTD/2ssMt6p/7lCSasqEA18DLtuutfB64M5QPnuOeLFwP2j6F\nxCfs2fyhLQznJJjqr+BH4qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7un/p4tHYATknSZl\n9Jld5dOXl+EwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAj2el\nBMxYWuF2px8iwqEVtzM4T+yMYKPABpBRXyW0LosCIQC46V+M26jo9DSbQXSjdRnT\nSDMlCm0HBLM4Iwz7l1YZTg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8210", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8210` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATtigh8K1iqccji0PP8QUzgEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4YTUzZmE0LTVjYmEtNDc4OC05NzZlLWFkMTQ1Y2ZlNTFlNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA1NmIzODgtYjZh\nZi00ZjM1LTk0ZWUtNGE5ZWFiZWQ0ZmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwQS7o8kiqrj0SKea8F5kN/o10sVKkZbbcCamWLc9NCioALlbZGI8bua/x5ia\nX53zTwT6l4x3Rxrco3Ph5bw/taOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvotKsB5jL7qD0MwR7uVN7Sr0bXYwHwYDVR0j\nBBgwFoAUW8dcNGGaQQzGsDxCRNTVMLSdq3YwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDf2/a9JdJAh6adV4KwisoZlAQA1nQI3J2teJNtJNM3oQIgbg8NMDGG7c8E\n/y0goOPaFvrhMgGQGxeGXHiRWMn4DxI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT1wfK5hXQ6GPkZlLeFqCfNbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGE1M2ZhNC01Y2JhLTQ3ODgtOTc2ZS1hZDE0NWNmZTUxZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOLax69AIiB8YADZJIOi3mtdooiQqKqeaYVX+qUHkRKoxA\nUZYThxj835GkvLqRiaaJOoizdKw0GD/f0Zt8dHvZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW8dcNGGaQQzGsDxCRNTVMLSd\nq3YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSg8apjy5hfiwGHhpKky74bxiaw9t6hf9YnSMuB5J6ZkCIHpsq4KG+NRO\noZuwnryvTvGVMt77lHU/0vezHpAsCWFg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAXcF++NA5B0i8f10dFll4hm0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA1NmIzODgtYjZhZi00ZjM1LTk0ZWUtNGE5ZWFiZWQ0ZmRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWJlMGZmZWMtYzNlYy00\nOWJjLTkwMWMtNDQ3NTVkNDRhYTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFM7ut73ucksH9A8xHKV7mJy64Ir0G5psTnwZSpmB/EsjkFfSIjjHC+x0dtbWtLGR\njTNFv04+Hvp/42Z83qg0vaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvotKsB5jL7qD0MwR\n7uVN7Sr0bXYwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBgucxT\nCDbEy1UbKeacweTpK6PeyhKsa1Cw9izO0gelXwIgcAxMao8SMbP7pjBORtUBwlB0\nKbHt4B2u9nCKwdd2CRo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8211", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8211` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAYixyACMadLFb3I7uKsU5YU3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0YTdhZWRmLWI1MzQtNDk3ZS04ZGEzLTI5NThiYjc4MmQyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU3YmMyMWQtN2Jj\nNy00MjhlLTg0NjMtMWUxMjcyN2Y2ODBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVyBocrNzbzX/5kWtRT1+xQ0L/nu6rte7BS/5ENTskvLp0dsFDrWLAtMpITXI\nJkHmxWL+UMziVO3jdkfQPTUMoKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5ROauJxh8pacx0uLPmeMf8KlK84wHwYDVR0j\nBBgwFoAUpntydhxOvt9l2bcM0bjHQdBOA70wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHZoxRfaM2b5M/l1a9xrIB5WXcLOWHCd981zQINc+YhjAiAd7998Pb8InMo5\ngtQcE8QxuupbayV6fUOMvW3GLT0yQQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARIP7tngFxVoMUUwOevyN6YcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGE3YWVkZi1iNTM0LTQ5N2UtOGRhMy0yOTU4YmI3ODJkMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDKO29ToHnFU/iH+Fguwp2668HxxmVJowGFfVAijS3scJ+\n0B5Q67mDL5x5LyllNRmyket9GPSf+c9svJoIN+J1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpntydhxOvt9l2bcM0bjHQdBO\nA70wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQjDojzVf3FAyxzEPCPeaf89AbU9jFRFtoPIAMnEDdZMCIQCCaJ++KX/5\nK7IV2ZEM76zwxfVQPfXDSgvOzXTjvjhJ4A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAb7J/B1gvnRaedNMFZS+sBmhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU3YmMyMWQtN2JjNy00MjhlLTg0NjMtMWUxMjcyN2Y2ODBiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGVjZjgyN2QtMzZmOC00\nNjE3LWI4MTAtNjE0YmJhNDEwZmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncoj50iFRSMGC5mt5Akd/mSzuFZzHAHHsbRhgOc7WqMN5D94VrJUAjqqWiZcHbOhf\nRi1bqfNIcTBZnaMkDvWC96NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5ROauJxh8pacx0uL\nPmeMf8KlK84wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA0Br0\n9EdtkOndh6SIo1Ce+GeOzWZ748njj+ccjAtAQf4CIQCWHZXAYATA2A7kCWIS3Sis\nd2TobHuoQYa2jpyfxbs2ow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8212", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8212` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAeqqKOjl8ZYT/KB70c9AkoQPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyYTc5ZTkxLTU4ZDAtNGZkNy1iNmE4LTZhNmFkZDFjYWU3ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJhMzIyZDItMjNm\nOS00MTJhLTkxNjYtOWJlMzA2YzAyMmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnNzOmECIaPUl0BiNV0HHCp0B3RM7upKhBMsHpK5vLrRX/1hN7bUJss7k9l3W\nRFFeHL50Flatxmy4QWqgu235p6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu8JSP4tosjvutStPVU5444dS6NgwHwYDVR0j\nBBgwFoAUvr5YUFCja+YCxeLitpqKz87eeGIwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEGA\ny/FN9c9K0l8csnVj5wcF8d4qRMQGU7mryvRgMJfqAiAZ41JmMhAKmdY+f3tdf3m9\nWXFLFvg6lqjn0IG+hAlREw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdurgq6Ubu0PBynva2YmJrqNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmE3OWU5MS01OGQwLTRmZDctYjZhOC02YTZhZGQxY2FlN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQst8WDkH3Mazf+GwFqabZh5d7PV6C/COsEemqUaL3TNs73\nvUDgwt9arEBfzlZRniPiNOiaj0KWsb9yDoXy4S9To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvr5YUFCja+YCxeLitpqKz87e\neGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGnZvsYzFJB40oTYoJdnwrpCvPX5XpgQrT1i9DMAk3lgCIQC6kl58pvpF\nyCJFknPJXUAynuId761qfqrjZ0Q/XlA15Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAdysupnFpFtQ//hJhCvfGNQbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJhMzIyZDItMjNmOS00MTJhLTkxNjYtOWJlMzA2YzAyMmMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODMxNjZiZTUtNTBjMC00\nZWZlLTg0NjktYmU5OWVhNDYwYTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvyRILIiR3qKiUSVHO0KbvLqpy+yeEevhzakHwbsPI/cCcKGqNghq+QBiu4z0xk6q\nWBadptWEUzMbKd8byOSHLqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUu8JSP4tosjvutStP\nVU5444dS6NgwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEArp4L\n8Ii9Chqic+nWM8DaVWLTsQ4UCJ2j7Wst3GFPz0oCIBK8XRHDxu8kXo+xER2h49G5\nBYlzJcNCsiX1JFmvCw/W\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8213", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8213` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAZ1eY6ZR1BZMxN9uBNrRCTcgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZWUyYjMzLWMxNDMtNDAxZi1iMTAxLTI2ZTFiZTg4MDc1OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI2OTc0ZWYtNmFl\nOS00NmMyLThlOTQtZjU0ZmY0OWJlZGNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUhjuAqBcOTbe9ZgY3zCJlYWvAzrFZNuJ9WpmVgKjDeGlrI0XQmF4vojvD1cH\nUUVAinfn+POSU0O6DUlrSBtqBKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUktFFCaTRgji9tIiTtGFKLp4y3tAwHwYDVR0j\nBBgwFoAUai5VkrWeAFt9vOXrpSSI2Yg9nvcwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDR4vvOJihyfFO/sSMvdvPjSgBk60T5naTBq3jN6MtX/QIgeuom\nMY3oQ3A4tgAjfroI1SicHqm2PEOrJ8RsOlmftoQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe7LRxnzfE0ET1dJWhjAUI8jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWVlMmIzMy1jMTQzLTQwMWYtYjEwMS0yNmUxYmU4ODA3NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4PHF01t6U4cQctNRA0OCBNx/3XQiCApNIXiVrFNMJNgx2\nW8Kx9f3zDk2dQncpph6nndYaNVi5+CaNMpXWSn0io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUai5VkrWeAFt9vOXrpSSI2Yg9\nnvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKqWhgDmDxtY5YD2e0Cf+BzcS8jag/sV5TL4nm320B5JAiAoyjmfH7Zj\npotZsnqVAIDegdY26/zaf26DZ2oYSaQMXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAVR5JDynZ/56MnX6q3ngmQ7AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI2OTc0ZWYtNmFlOS00NmMyLThlOTQtZjU0ZmY0OWJlZGNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmVmOTQ4NTMtMDU3OC00\nNjIwLWIxZmYtYzA1MTFhMjg1MzgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQEeQBtsOBzL5diMuee768j2gTkWD7yDTwpCXdyFd/9dpiKa+DtpILXQSjmF8d/kx\n61wWa9hjPvo/c8WhIL5Kw6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUktFFCaTRgji9tIiT\ntGFKLp4y3tAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiACuzcA\nymmdH7DLFLloeW1OEUYYq3yE5b/1pIhUzQfj1wIhAKo1dJ/FS3KJZtkcwx7+AREw\nZz1T08zqEfYWf721OpFE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8214", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8214` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISATBunIXCJv74/NoxVUNEhUh1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkNDY2NDIzLTU2YzgtNDUzNi04MWQ5LTAzZGI3NWZmZDc2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNmZGI2ZWItMzY3\nNi00YTRmLTllODItOWZhZWQ0NjM3MGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeORpmgwm0XeTujvtYPBDhp0JQyF4XiTRODXdnCqwBMlDfvyLzh7DEexgC9aU\nTXYO4S24n1ZbcoMLpbF8Maj8PKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUGG5fE2vU1YTCN4u/+QUV8fVIUcwHwYDVR0j\nBBgwFoAU4LsvrUNrx2tki04qdlzJqUCIJV0wOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDZ3FNIyNbDW/qB1P+jKbAFYBonLDfzPW8o8tCAEiBu5gIgYiC+\njMSc7mn5AVxUlU0zgA3QMv9KcIF0DdxdgRicaI4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQTSbZrDtwu4ZXb87qvQbMJzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDQ2NjQyMy01NmM4LTQ1MzYtODFkOS0wM2RiNzVmZmQ3NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4cW7zPZiR507sp9ohncgJudYO0jeZDPyZn4zqs7NYyGjS\nq8TCmHy/vglpWFUYUZFV4xMz+i86wIG5B0n4RruAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4LsvrUNrx2tki04qdlzJqUCI\nJV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKcbNDpzmSXEqEa4yZl60XlKC/zLH2Aa6EqiFU8WnFv4AiA+ZdjUqtmz\nGY/27/HmZp/8ve5SAnGf8vbrdtN7OXN9+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYssLQnHYEgGZTSLGrDNELuEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNmZGI2ZWItMzY3Ni00YTRmLTllODItOWZhZWQ0NjM3MGFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzM4ZmMwNzYtOTM0Mi00\nOGY1LWJhZGUtZjc0YTFlNGFkY2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMBlxE1njTjUOXf7tNvHvpEgwHTiAan2xQ3RX0uuFVoR2B7qkbQuDjgzrsRNdn0t8\naVNa6lhpQC6rQl4/eIvRfaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUGG5fE2vU1YTCN4u\n/+QUV8fVIUcwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA6NFnl\naku4m4xer4kUbcjxE2S+PxZ/mhw1WSilq21itgIgabhG/kVITEY9ki5p5MvBdKmG\nw9650L1wyq5TIgBnDt0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8215", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8215` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAUX77hEkehEXtp/NMpE1FhVkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5NjgxNTgyLTEzNTgtNDUwNC1hYzEwLTJkOTUzNDE1OWMxMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNkMWVhZmMtYWVm\nMC00NzI1LWFkM2YtZGFkNTg4ZDBmNGNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe2dmNHwIEIotqLVeNgZk7GnzKi1LNBlq0DtEad7+770XENwJWkHU2WPibwWX\nrKNhac4XD7tU4NgpZr3eW6mjjqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTAm78WccgddOJnjE3HVhl8TGiJ9zAfBgNVHSME\nGDAWgBRgVK9LlqxkXYO87me0a/c3H1vQajAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAMn9sGXuiH6/8G/Xyb5a6E9BmkejoI2\nC7fr2WUrgiEeAiALI6yd8PU40S4sJlcEV5c/xib1EG0m0/NVUCeH8Q9FJw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZVVxTVrWCfKWkDFZMBFB9boMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTY4MTU4Mi0xMzU4LTQ1MDQtYWMxMC0yZDk1MzQxNTljMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTFYINZcrVdGNcd/uzX5NiEfea1JiG9KWe8thYzEtC9Dai\ni/n6K1QljaBj+TilxtKbltI3nuY4A5XuWe4RcDZdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYFSvS5asZF2DvO5ntGv3Nx9b\n0GowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIVb6+s0/PSxdsTtoXmDqf4F07iZKPe1ZZRAan0bIkodAiAQncoMVFGc\ngLHqubvrveG4wEkj3tmAEvNERmFpStYZWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYk5SQMXWELMVvsDFR9n+NKqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNkMWVhZmMtYWVmMC00NzI1LWFkM2YtZGFkNTg4ZDBmNGNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjQ2ZWQ3YTctMWUwOS00\nMGFiLWEzOGQtYWQ1NTViNWRjYTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFCYX0g6qQMsIhjr9t4KyigtR8pyXwstnHOYGQVNdHPV9Zi4hrPn13D8mXUap6WTM\n44CFhke2JvrQLc7sTc1zK6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwJu/FnHIHXTiZ4xN\nx1YZfExoifcwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEArAUT\nXX57xWZeuE2QX1y37AGphdtjQHc+Ks5XlpoAoGUCIE3OZg2uil5cl+xfvGAJtVaT\n37VxNNTE/LwIhxuVctAK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8216", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8216` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAaFd5IjgqtsOhl+EShyAo/eFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MGRkYmZhLTU5ZTMtNDQ5My04NjM2LTExMWVmYWQ4ZGQ4YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZlNGZlYjAtOTI2\nMC00ZDNjLThmNmEtMjA5NmMwYzZjMDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc2w6WUAIvfRaIQSbjs7rKcZcix5h30UTjmAZaehIpExYAGltFLAfaMeH9GFl\nj6RePQ0my3koGRACHowo8jKJHKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyIEEbDcVmKFRUSF/Fgz/BbeJZ4owHwYDVR0j\nBBgwFoAUn5P11YiZQGf5qBYYo1vakwD4IZAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBOIH108ap3m\n9pvpRrm/MjKNYWKdYxnuY4D1YvT686f+AiEAiYnOVOR20oYax/nZVjTL+EDre3Es\nyEKJjJe+nGDirAg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAffpj791yqh5kA2SSjuD6TeaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjBkZGJmYS01OWUzLTQ0OTMtODYzNi0xMTFlZmFkOGRkOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRjZAKda7dvotpKVlXGUN3wdSJB8Bf0Bqi0825eq6IuVX6\ncdM0V4v8KEVotKpfzQAqlGrPwCrM69gqvvAUUX0vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn5P11YiZQGf5qBYYo1vakwD4\nIZAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMpGcgRtwFSP7lzxHamvFw+XMLcSz4Sv+iLE9Bb0PCtTAiBLny2Lu6N5\n69z8jnBCyusi4W8GASj6ZN8/vWegfPyN5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISATE9LranVlloTEDbts2zVrv/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZlNGZlYjAtOTI2MC00ZDNjLThmNmEtMjA5NmMwYzZjMDJjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGJhZGFlN2ItYTU2OS00\nYTBlLWE1ZDgtZjM0YTkyYzQ4ZTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nq/cXzlidt31CIg1ug/2GQWjzQTrq692UOzqm9HfgUbPNcvD/A+KDeLTSsn7Rkd0f\nGF+XQMUMH3eD11+c0QgNq6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyIEEbDcVmKFRUSF/\nFgz/BbeJZ4owDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBLZaXP\ndiGMFRaJ5ekQgsVXCgu6Wgvykzf/CYQekue04AIgc9t/l6j/h6spChmDVxRarqRC\nXpZbYWcZc3i8CKieB00=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8217", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8217` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbGJj43jxNqxi0vnzOGlji9TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NGRmZjQ2LWIwZDktNDMzZS1iNzM4LTgxN2EyYmQ3ZTA5MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U3MzkzYWItZTdk\nOC00ZDQ4LTg1OTgtNDM1NmIwZGY2YWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwv3CZLOdtOGoQKL2tN8zV6zj6pTXDkq8+G3Z8fvaPstIOSgk4J3t0QuwTGKS\n5p+MnUwydsPV3kScQijt9ABL26OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzLnZIRTn/n1xM7oEn8juc4SMRH0wHwYDVR0j\nBBgwFoAUdziDyt500ocYSAd0EL8xvjikfrIwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDJEAJHpnbz\nvyiniG06tyrBvNVsdm9hWj8DuGYP8v2NcgIgC/kw13Ym9p8HUZ8JTBTQ7S2KPvSX\niDl0vmds1sJXZWg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZOmJ85HfSqCIAzbmwYTEYs0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODRkZmY0Ni1iMGQ5LTQzM2UtYjczOC04MTdhMmJkN2UwOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBx10cmF72yp4SYRfj3QqnL/sYPSoqfQGU2PDvVGxAINjO\nU1OdQeI9XRxzpNfLua1FyrbA+qK0L2y8GZLJwQbdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdziDyt500ocYSAd0EL8xvjik\nfrIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZVdEf37hkB/KgCUuStHfP3mz2jW75yaAjxnxbyI99X0CIBxuAxu3nj7E\nUSKGTAoVhQguf0qOZDNB8bVKtx4RV9tm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISATlyds2f7C60o9tjYiKvS1+PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U3MzkzYWItZTdkOC00ZDQ4LTg1OTgtNDM1NmIwZGY2YWU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmZlYjgwNzQtYTFlNS00\nYWFmLWIyMDAtMjNhMmVmNzhkMTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nB/e64k0gmVP5fvGmR3UKg2HIp8LuFLKqDHeF/tZkP5QHq5PSUlVW6lPleqgM1BXR\nh5D1N4x2udQfG21R/DJc66NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzLnZIRTn/n1xM7oE\nn8juc4SMRH0wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA00/3\nXPWBYeE/3Fx5cKZ+BQEuqUG/JqAniP0GwHHHeRQCIQCvpbUmfMJJnz3OnHCzcpb0\niHxykKAFK47yDQ3D0QVnjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8218", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8218` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAVLl0wnyFyusMQtyYn56xGJ7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhMjBhMWY5LTc2MmQtNGZmOS1iYWUzLTNiYWU1OThjMTZmNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQxZGQzMDQtOGZl\nNi00NDZjLWIzMjktZGI4MzRjM2UxZjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzc/mszqfRoGZVmlUsLsgWR6bG5eMPvRc46XwqGdZ2SaZQiTKcBCbHT6MgMNA\nBC1NvhKheE3NzleySrBm7kAuPaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ1eoc7wAIXfSot2hvtO8jBM/MekwHwYDVR0j\nBBgwFoAU0xQRoXV0vCA3hZbAu1zQiD5MfSEwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiB4T1v0T2mR\nPRNv9CGPG5BO6B4RhUyCkulCV8LzTR/pJAIgb9WuGBTk+7+dw41UFrmN+vpjumdB\no/TakusVB//O998=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAauPDOcnCf/iD4t5QaIEpyxDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTIwYTFmOS03NjJkLTRmZjktYmFlMy0zYmFlNTk4YzE2ZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGZc3PPlfxFP0IPHJ8QU6VFmX94R4trNUGF51NBob6KHVi\n0PVJVBK54J13UrAXD6NtYX5OYwUQsNZpP1ynqDzuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0xQRoXV0vCA3hZbAu1zQiD5M\nfSEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC4KAtIwJypfRho4/rK6ewuDQdf7Ssv5QgB0rUWNOtoICIQDMnRzFKTSy\nPYNmkhVoFkKIH4lALz2lY/uvzoZwIU0Bug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYrdvw/CJuvm6rMRKYDREPDFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQxZGQzMDQtOGZlNi00NDZjLWIzMjktZGI4MzRjM2UxZjRlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTVhM2Y2NDUtMjFlMy00\nZTlhLWE5Y2MtMDZlYjNmNTZlMTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwJXtKYgvVxjrSQxGZeEqHEm8ydznN3bEmyK9gr2sPatd9PNzlCW7yO+c7JjWb5r0\nWpMTjAlGBb2itWzmKwWYxqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJ1eoc7wAIXfSot2h\nvtO8jBM/MekwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAlus6A\n6BIhQaPX3/R0U+P09O/NAuSyM2YgnaV+ISyzcQIhAI71OWdWiBDtadPHLZz/DR6i\nQ+vfvVQgAWKnP4V+MWhi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8219", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8219` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAa0PWNeG1O3JDxDJvC1ZTlerMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQwMzFkYmEwLTg3MjQtNDI3NS1iYjFkLTQwYzE3ZjJmNWYxYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZiN2YxYzEtMTg1\nMy00NTljLTlmYzUtMTZjOTI0Y2UxZWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgHeGYMCO1e+uuYG8yLY9WAC607goicIIQlGfQpxSoC+ABy+7hSsdfZRzo5wJ\nY1+KAjNbQxJVJ1dtF34lCZsdLaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxN0xadBs2pI6xuEqSVQ7fBRnywcwHwYDVR0j\nBBgwFoAU8EUhwoH/WLAEqPSt4M2bnptsUZUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiBIl1qsYjUFT2qoqwwHey1btwX7qvsz8GhOxKBy/L/YDQIhAJk6+KIm+wCF\ncyMD23HGaWIP1zLEDnEsbo0Mwy+Q9sE3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAditDRHTqV8E/IfIEbFli6XVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMDMxZGJhMC04NzI0LTQyNzUtYmIxZC00MGMxN2YyZjVmMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlzXdkwa1OXwWjXxOqYfIYezvqqu6ZIdhOWmwbxBWxPMre\ncYZEKjLrcq9MgNhLyQS6QAxOgR20M5gcv46mBv4fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8EUhwoH/WLAEqPSt4M2bnpts\nUZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBVzsl+7G8RR5nBXtPVSAN/K+gSOeX0qnyC3etCDNa1kCIQCDfILPSyif\nhN2kEcIwl+ToaGNkSMRIvZvIka40lBgoBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISATVjuPGd9hK+m4hcBLKiQAHcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZiN2YxYzEtMTg1My00NTljLTlmYzUtMTZjOTI0Y2UxZWE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDNlY2U1MjUtMzg0OS00\nODVlLWI2YzMtMmU5ZGM2OGZhNTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5rp8H906nk7Bs/xRrL4QoqF+6nvwYEgZ7Whc0LMbYHtUtJaXYRB93Y4cDLeYcO6J\nDRd+bPoKJUNwHr5U4kONGaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxN0xadBs2pI6xuEq\nSVQ7fBRnywcwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAjDSH\nO1IRGRQkbS2GPwxb2CsXB2Zi0Zx50kjKjtU9T/ICIQCQUGXy22yyjiKrk131nkas\n2+Sc3TEN/VUQShKMcRcAjQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8220", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8220` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAU6d9T/G+fYrmV2ZGD6AEMB9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2MTZhNWQ3LTdmOGMtNDQ5OS1iZWI1LWVkMjBjMjNlZGZmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NlOWQzNWItYWEz\nZS00NDQ4LThhNjEtZjQzN2QxOTlmM2Q5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDKqpWIFBfrQ9bVVxGBaDg9p5OAjCZQHMtJQIi8VICaTbi0Hc1ARh5HaA08BK\nyI/02QY6uNBmK7a5AKFWPSTViaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIalq4njgkQO1JMT/SNOLmP4xw9UwHwYDVR0j\nBBgwFoAUO6t6n+o3PO7jBAso73LlxMeyXqYwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAwNUjSPKelXl6nj7KHUkhyjy/pw59fsD4WAZ2wVKdVEoCIGY7Or7gbnyz\nQ4KBSA6jDYu2+YmZD/ikq1vNfVQHPhFD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeTV5Rj6Zbjb1DdnBUDjdBHTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjE2YTVkNy03ZjhjLTQ0OTktYmViNS1lZDIwYzIzZWRmZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjzOVndPTUEnszWUVD6zNlO/SceyrgXfGFMUdlp6uP72pm\nn6PVRdDoiczp7EWwjOrJdJDU6+SkdiPME9hhcvEro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO6t6n+o3PO7jBAso73LlxMey\nXqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSCLCsIGG7/ky4mv2xRJkWpU40B5RhmURhRuCkATAEQoCICAJxM7DngVv\nALoKPySbTidPiLHApOC2HGLMWFvm0iT8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAQgVRuiYph9oBxC0EkJz1aJVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NlOWQzNWItYWEzZS00NDQ4LThhNjEtZjQzN2QxOTlmM2Q5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjFlNTc1NDAtYTk0OS00\nNTNhLWFmNjUtNmIyZWFmMGZkZmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWI4u+e99PrvGXcgcQLahuQYtzaVCvAyZp8vjILXUKVHwKEm4ynTRxgj3L9r7uSdD\nIkTY9KCInBG2K1tKAZ7bLaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIalq4njgkQO1JMT/\nSNOLmP4xw9UwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiALZdmp\ni5iUFcqgJwer3YIUgZdOfPj4TKPTJt5CZXVa7gIhAPVvLNznsKbVJbfEnQOv4kM0\nm6medbHAhdD+wSWSMe4V\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8221", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8221` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAfYKBL6Zh+mGZoTe0x11zQDmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzOTE5N2E1LWNjODMtNDk3YS1hZDMyLWJmYWMyYzVkYTdlMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FiN2MzYTMtMTZl\nZC00MTQ2LThkMDYtNmIzNTk0NGUxMGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAbVhHrFMJWvepoxeafO97mdwUJJjm9tLzUCTJDU3ZtltwXCFYyaysz7mv1ZS\nhpjG3GiImpi9I6st+0DefCldVKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGA/picN5qsK7TqCYvtGM78d+xIkwHwYDVR0j\nBBgwFoAUC1//haPdFZXRdbs6XvTEhjLiuCQwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiB6\n2CtcONNqQOKqE692ZshZxQRsHN4kUOq5yONXb+R/mAIgXtrmjN5pPxV67Kk1Juow\nZwrcXn/WlYO/DemM1tTr0y8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAckBmELXaGJ7dP+FT6umcX8NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzkxOTdhNS1jYzgzLTQ5N2EtYWQzMi1iZmFjMmM1ZGE3ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbz363F35cPLzLq2oCp/H+c1FLaPldx2aYSZyW8yYEFGuG\nEstBdgj+BAjtiirjCUTIlPIjXdTEf7/FhOibxDQVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC1//haPdFZXRdbs6XvTEhjLi\nuCQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBebr6cIKD/rM8T85E1JX3EwbHqEep3kqXxWJS/39ynoCIA8O19skv6ph\n1n4bhv89sQNiRCfIuL4yMAi2m28kB/oU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAbmeoC1OI2Tc+Eh7wJqsMZwBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FiN2MzYTMtMTZlZC00MTQ2LThkMDYtNmIzNTk0NGUxMGZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWM5NTdiMzItYTk3Mi00\nYmM2LWI2MmMtM2IyOGRkMTVjNmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyYh/hoG0mQCE5pIDFSieWrSjfdr1ck1ksevelk96lQrrrOqt5WOa76S3IlLKb1oy\nmc7xXfbaYW/cWkDw4LnR96NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGA/picN5qsK7TqCY\nvtGM78d+xIkwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAlLH9\nOjnRBbq0r/5wrovap5t5aRYBbhGZLVET+D84EKICIEC+OVpnZ4ZYXbasbLqrWhBV\nnno0SU2qtXX1c3ZGnFd2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8222", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8222` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAfcMUiUqhqfEiBAK1HMWqqPOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjMGFhY2FjLWIyMjUtNDcxYy04OTJhLTNlYzRmNzA1MTNlYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY5Njc5NmEtMzY2\nOS00ZTY5LThhZDEtOTM0NDRkZDRlMDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElNk+0gKtjyzooN+XIDUPgfhTsABgAhqt7BaSv2+963qxedNJnlHVG8TvAyh/\nyGPAsh3b0aQhpbR8iBZMg+dElaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxxTjVAq5RMYATkH3UVu8lqm0FMcwHwYDVR0j\nBBgwFoAU/fGaq9Fx3iXMC/TVz3RiCqr3GY8wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAterRKiOCMivs1tRFsqRQsrSGDyJwj2CAbkoBOAQmT1YCIHGb\nHqdZ9WKeNvB0ehTVdfKVK1OunKYpjmgd3sk70rSS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcya+nehFwt3a6BvplqmfO4vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYzBhYWNhYy1iMjI1LTQ3MWMtODkyYS0zZWM0ZjcwNTEzZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzZo5/SEcoDfkH3YlV4FzccZMQqdagb/oFsO9Evo8lyoDq\nOTa66EmaB53475AQz1LdWebOVdDBZeId7bQVMi1oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/fGaq9Fx3iXMC/TVz3RiCqr3\nGY8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJkQsuhM9Wna5gm7EOJg0kVEaiEMPOhM9TuT7DsuwbIdAiEAzG1Me8d/\nJ2jBdeCFyTM7RlplyuEi3FfVJj42+EEjRVg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAbj2DZebB5swtOt7SUBlI+n7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY5Njc5NmEtMzY2OS00ZTY5LThhZDEtOTM0NDRkZDRlMDc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmYxOTlhNjItMDFhOS00\nOWU3LWI4YzQtZDYwYzM4ZjVjMmYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nq2DEnHdsxCB/IPUCVXaT5VVRv1UQRInaqmtHfFS7y6s09zFCyecXX2OEJN948mSc\nh/ePJtnQsOB0GI/77FxoDKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxxTjVAq5RMYATkH3\nUVu8lqm0FMcwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA4dOh\nxX6IoN231qr4lhFM4Rx9W33/PgK7QDhUBdzGLUICIQC1ld9b/PF8T+y6ByhMO4VM\nPLDDNyUHWHHSXiBcUX0QiA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8223", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8223` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAUMXhFMyoYDmcBaFOLjGL51hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0NDY3MDRhLTQ5MmEtNGMzNy1hMjhkLTVhYjE4YjI1OTA1YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgxNDQxYWMtMGUy\nNy00N2YwLWE3NjAtNjNhNGUyZjIxNTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJM83Za1l5BWs+HSsFAbSklOpHMYAXdRxJFmspQNQjgl001zc089ueEwsucni\nORAzHpLW+XqSRncT6VLDw7frQ6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1zgwfuvLAIe4kJS6jMm0MXilVPwwHwYDVR0j\nBBgwFoAUzdH5TbaJmhFjT7AEYQRnt4XiNRgwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA2nkxMdFSB3il01VHQXcAAHSqPcNJiZNAjvgSVa/3NFQCID96\nrRlhMvgxM/Q4m1CBOoYADCGOaxxSXgiywqFvsFxU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfsgMkwlxOw6mFL4dje1FO/YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDQ2NzA0YS00OTJhLTRjMzctYTI4ZC01YWIxOGIyNTkwNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/5QRJofa/kUFWSc1FryxTpyA/vvUuyMLogvU+I8FAszm6\n1LpZxxy4z1dwk0fC+Db+f6IUO43lE5EIsYzMtsgao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzdH5TbaJmhFjT7AEYQRnt4Xi\nNRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKxMmg9VOpm04u6ZpCTqpIRgGW3AGM1w5cT7AgH+IGJ0AiEAy1K1ZBA7\nhcWdYma0q6hdNwBydwKw7UuCBk3+cEMEM/U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAZ5qkialCYn7tx86W9fIo7NcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgxNDQxYWMtMGUyNy00N2YwLWE3NjAtNjNhNGUyZjIxNTViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTJiOGEyOGUtNzFlOC00\nYzczLTkwMWEtNWVhZjkzZGJlZDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngEvK3kRF41KgVXO+8scIdlXobzFHPUrk1/6CxPIvd+N9CYh5lPERCRSmpziVPZ/e\njs6Fkj6Q8GKLQ0QLUNt1bKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1zgwfuvLAIe4kJS6\njMm0MXilVPwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA2CnWJ\n0Sdw3hM7o1KGgU4ZO/8QOviygC5T5N9eMHczegIhAJWrvb7CLf4d9Q+Oj9pOtcLP\nZJA8AjHveXLIiZlUZuIt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8224", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8224` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISASF6HvSplbq7eyFpN4SRz7pSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNWFmNTBjLTkwYWUtNGE5NS04NjUzLTUyNjA2YmUwOWJiYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzMyMmVhZTMtZjli\nOS00NDg4LWE5YjItOTBkZjliNWRmOTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESZNwZE6Jb9BZA8TEqz//bE9o2/L+oE+z9bdhtrl7sGFuKvh+NBK+pTDOsaQK\nJsnRxtuOpkwYTNsln51U4PstFKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmGPiw+8L1tPfTTeEaK+1LUME+rswHwYDVR0j\nBBgwFoAUn762DxyK2YzY71j0UooV1UUPK6gwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBL3hlH6YUkplJS\ngSZgIMy8JQAfmx0UJ0S9etvvqRGqwAIgHxhj0EA/54ME7FPxCvUKQ8pseyvKJ8vy\n1ygdO1ZQYUc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT5xdljJa3p4iR4nLNbDwRTlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDVhZjUwYy05MGFlLTRhOTUtODY1My01MjYwNmJlMDliYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhpwNZSRYqhD6fJ8ycFbN+Gm4aTw1WNJLB9Z1lwMKclIhl\nYaV55bdHU5y4owKevkotT8lJcWRf776fwJ9Ml+nNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn762DxyK2YzY71j0UooV1UUP\nK6gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG158hMpi78aNCX15N6WExFKPnnJurhYN6PTfRpt9yxQCIGURHmGU4IaN\n+7hKyJioO1EkhQns6/35EiTRzOICGymR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISASylOadJ3b/Z6SUYHLiXYK/SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzMyMmVhZTMtZjliOS00NDg4LWE5YjItOTBkZjliNWRmOTFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjFlYzRjYzktYmU1OS00\nYTIxLTg0M2ItZTc4ZjkyOWJlZDlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nviNOT2rqawbT08hytbvIr4mXCM1yUSn0jSW6YNa8Z+65Ei8mJ0H7QwdO46aS18T3\n1G1ICNtm0dnkCZFFkjOAGqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmGPiw+8L1tPfTTeE\naK+1LUME+rswDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA/+VD\n8N8Ql7muMzFDJvBTqxnv2h7W4nHn4RyFhFY3FTgCIQCDsqoGZOZ9TYc+7PlbwqrL\nk+JsMgXkG98Iwbo25v+0eQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8225", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8225` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbedKuabDC15GyUNw74YJeX5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NmRmYjE1LWRlMTgtNDMzNC05NjczLWQxMTc3MGU2MWMxYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUwYzRiYzgtMDdh\nNS00YzkyLWJlMTEtMjVkYzRiMjA4MGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnp7DNB2vDSVs9NSJ4BqGqSJiWJwO9jHV9eW6hh5jauLgEN/EMOHUvn0IMXhz\ndTsEJ5E9GfSsquZUpN7vot9/6KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU53rrgBuWXhg1nEeR7sr9vlwMA+kwHwYDVR0j\nBBgwFoAUd9jL4rJgw1XFe2lcwj24tQhEHXIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCRXBSVJxSTZ3WXgvcQZXcW89DO5NJAfpLqD9Gux6h3ngIhAIiOaHStTsI7\nMldXbgM8IsXThuCcYi2A9HUoD+uV5IDe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT/VvmY9Q07cZk1e2kwYDKQUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTZkZmIxNS1kZTE4LTQzMzQtOTY3My1kMTE3NzBlNjFjMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXjgxgdbq9GjQPYrjyWJ1Z28bFxliRQDJuFuijm1mBYLWe\n2xYcD9omYhBl2iNNpGEqPs595hF3DL9D71QYc+7Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd9jL4rJgw1XFe2lcwj24tQhE\nHXIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMPbbwqNeVYuSFPCa0VAZtKHRjFUlBiuCTYflXmlrg6nAiEAnozAX9qJ\nsAZyjWu7IHnpFc0Arkdf7hThKGUIwCIshrg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAVpclUqLovdFhA+DWktoysV9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUwYzRiYzgtMDdhNS00YzkyLWJlMTEtMjVkYzRiMjA4MGY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjEzZDc0NTMtMzIwOC00\nYzU1LTgxNWYtZGJkNmM0ODAyNjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nt/6K5vC6b9JRbOXG+MrYnkjlV6xG+nqthK6f3NXJPMErDuVs8kM7MrRj+ettzCXU\nelFb8vDW/ShrTl1SIQY1yKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU53rrgBuWXhg1nEeR\n7sr9vlwMA+kwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBFleza\nsMOeK49cImsYy4EFtqmBWTI6HzQTiymYzajK7gIhAJ8M9Zhcg/GHgFi7hW9WtnHo\nrJDg7MsSgbBcYKZv+r4B\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8226", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8226` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAahAVzmdm3hoKAGrdN3ywuNiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNjczY2M3LTA4NWUtNDg3Mi1iYTBkLTQyZDM1OWMxMzM2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QxM2EzMDgtMzg4\nMi00NjkzLTk0OTctZDBkMTk5N2IyZmJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH3bciQD1OM0oV0Z6ke/MFVCIoocr9FlTq3W7RAzVo8KtKNRhQYacISzAZawJ\nPQ8gmo6j2910U/mMmnTdw2WKxKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKg5RondEwRwHGHPowcgIvnWIbhEwHwYDVR0j\nBBgwFoAUwAb2Ka8KGwJl9Vf4OjxlODpaq14wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCMRtzgUNVn5d3sm9aMMEosRMTsonhX7myOJ4Mw0gUxJwIgaRPiyoDASS87\njSiWRlk3B2Jm5ec15ewgrn56ZygDXqo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARNXDEPRVqjqm/bx95cJJ1i/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTY3M2NjNy0wODVlLTQ4NzItYmEwZC00MmQzNTljMTMzNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2I6aRufsEubD+dKplEtEkUUmLs3DB5MbFcpAXNZshlDSk\nGVAxJ/ch3JY7G6Q+9BKfiWQ1nsitg6re0ElvaCTro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwAb2Ka8KGwJl9Vf4OjxlODpa\nq14wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH6t4KJiKpaNrWDn8otuNuecnjg7OCpYy3BBoXnor5GwCIQDbqrr9xMQb\nIg1dnEwTprnSwLKnKkFKhzMgaeUzqVFVsw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAU58AuLFbMpMq0v4bvwwW2mxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QxM2EzMDgtMzg4Mi00NjkzLTk0OTctZDBkMTk5N2IyZmJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTQzYzBlMDUtN2MxOC00\nOTdjLTgzZTQtMDJhNjRlMzcwMzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZ6YiEkwRkfYJe4urLP4LGJrOs8I0Cd6xVtF6LXL8hT7IZsk4kHXFAMhFyD5IkXrc\n4d12ZiOhkMuYgDcnyPHnq6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKg5RondEwRwHGHPo\nwcgIvnWIbhEwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA8K+d\nl34QBUAkVZW9h+ABOGsq9kk0D2QNtXrvXlTVD3QCIQD62w4n/2hoIt8ACla6SHrQ\ndyHUQ6Rt+WS69a4a7mwTmQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8227", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8227` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAasbRIdG+cqZOn4HedTprrNuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViNGVhZDIzLWY5NDUtNDBmNy1hMzdkLWNhNmE1Zjg0YThlYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2UyYmExODUtOWVl\nOS00MzViLWI3OGMtNjYyODk2OGQ1MjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe/n9W58j9I96z4Ytv/dfFfaQcS8bOyF+L7qZQwqwxtDotiJ4hNcT0kYB91IE\nkTHa6HFSQKvy9S5Dd9sulxpYqqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTC01bq5r6yhdpNHdfbRRowBo0JgwHwYDVR0j\nBBgwFoAUNJTRSd8aUq26GvuXL807oiNMikAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAKVvNFp03MzTC2GaAUsu2cMEx0E7ZKbXqylitVpmYfAQIhAPNP82dWDpmK\nHw2x+Fz7xxmA329ZuxZZkAfJ+siSIdV4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARJgGAnuLZZ0GptoHf/o8gThMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjRlYWQyMy1mOTQ1LTQwZjctYTM3ZC1jYTZhNWY4NGE4ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATY5g9f301GafjXDNx+07FMPM7NjWflE41ehmjAgtNDV7Ec\nhbDsaKr7bTm6iXRBcdLBhbfuYl+o7OR+AzhzQg4ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNJTRSd8aUq26GvuXL807oiNM\nikAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOPMnHgHSUTUW6WyLCnCrzFudN8PsfyDOR1LEpg81th+AiEAk6m9scYa\n7sMGcJsAlBowl06Z/sYs7+Aan4s4n2WoOLc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAWmb9kHiTRtgrWSX5CkHYlr1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2UyYmExODUtOWVlOS00MzViLWI3OGMtNjYyODk2OGQ1MjM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2NiZmQxNzYtOTM3Yy00\nOTkzLWE0ZmEtM2E0NDQyNjBkNDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXobX50G2fGPZC0rKGoz9OmRPT52w2cyuEbe0neGLWt1cTYhDZWhjqMnt1OM3FABh\n9NMlf4r7ekAuL2FR+nNWUaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTC01bq5r6yhdpNHd\nfbRRowBo0JgwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAgFkV\nacUwLcGYtsg3gs8UUqzg9AAxmuu0HFhki/oJVfICIQDuDOdueJb/q26H3pXVO9mc\nmM3YSVph7l0bv5FHVJqXkg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8228", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8228` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAbwncJG1PXh/GvW6GkFZWC2iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlYjkyMjJkLTBjNzktNDMzYi1iMjM2LThjMmQwODBiMTI3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg2OTMzYWEtYmM0\nZS00MzIxLWE4MzQtOTU1YWMxNThkMjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHvUtF1eYmgGvf9ENOQU6qOV12zvGRPgEdl2c68iGlJ7qulYsrui0bD7GlGOX\n87dXr9UEZrCDyna0bMD6qQqHPaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0z0YhfbCddEebGYbZoYR1klm47EwHwYDVR0j\nBBgwFoAUUXzwWT0+ri8ANH6i9t1FalkvpFcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA8F4PmDnwcMWZsui6RzwmGN4TcXB+LDjc2YrPImDj\nplECIEXC/l6pSzvHjWIiZhOSxiL3qKagfdA0hFLICPFvN4by\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeD6C8TXVV0qAOpadpTlHl9/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWI5MjIyZC0wYzc5LTQzM2ItYjIzNi04YzJkMDgwYjEyNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmVpi8jWFCk1urt9H1ySmRMiS+YU+pxV22MVkBEAa1n4do\nSSFwjtkX0WnI0hUMXtqwndEmz7oRu4gwatk1k0bVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUXzwWT0+ri8ANH6i9t1Falkv\npFcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge5QI9BOrsovbshEAYVAd6SRKW6Pqo4fK7AjjvRHRX/gCIGiEymZNU65V\nVjir3OW+kY9vvGUqzXtAnGpQp9loIne1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISARtP++DPQGp49cyAErD2wO14MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg2OTMzYWEtYmM0ZS00MzIxLWE4MzQtOTU1YWMxNThkMjJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjViNDc2MjEtZTAxZC00\nZjg0LTg1NDUtNmI3NDk5NWYzOTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJP7EvbtkBC1w1n1WIEQfPPmN2fGEJ5in1S9gVW1M9za0QEiOsUDr6YRoJWlkJuMf\nBCbHWBZEdwLeXN1VFbVU1qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0z0YhfbCddEebGYb\nZoYR1klm47EwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA9/mY\nnjSEusx+uMwgIBdRWUygvWTqmFApaEdPSIN/iuwCIQCrb7azDmdA9uDQIEh1H8MM\nxWpmqLA55c1cZlNc5mG1hQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8229", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8229` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAUL2svW92sP6cQE+9z9XoeDLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjMGZjNWMzLWRlMTQtNDExMC1hZTZhLTY4MmY5YTIyN2E2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc1M2E2MTctZTc0\nZC00Y2Y1LTk0ZWYtMTM5ZTg4NjJhNTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpTdbAE6W5VJob05jzTQ1EzYq+PIhw666eGwkZjb/0rd/DVE163duX2xQ3f+w\nzbddRVz2+cdwQdOtcq3YBSLaK6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzWlbeOEf7emJQowlzW8CwVjCzeswHwYDVR0j\nBBgwFoAUSOzD5cUw7qIWyPILU+/QNl1pRXowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBRg2jNNaYB3mNAJ4yddF7HxqrZlOyarC5FZSBEMH/T\n0QIgNnqaR5S0RZQ6f6oRbrFUss+I+RfA89MgQbeJHeyNBRU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZstRl6dcKrNM0QI+2QL5d/4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzBmYzVjMy1kZTE0LTQxMTAtYWU2YS02ODJmOWEyMjdhNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS15wOF3gLfPUjdmPtg1HC3c1K+lBv4wfFOOF025UIoz/AU\nJis3x4ZcbA49oHgunOiLvQsQND5+XIQz4wnYjK1ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSOzD5cUw7qIWyPILU+/QNl1p\nRXowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALFGpYONLqxMv7eSPn+YmNhuybg/aGuFFa9MzcyPkk9eAiEA5+ZUtkvy\n0+w4Xeji4HNqJXh5V452C0DQk3B8JI3QwxA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAUo0xDSIBxmrnlJhNNObw/QOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc1M2E2MTctZTc0ZC00Y2Y1LTk0ZWYtMTM5ZTg4NjJhNTU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTBkOGZmZjgtZjUzYi00\nYjQzLTgyZDAtYThlYjdiNDZhZTY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njoWhJoOX6CuJeQpCbAgUraSaxBv+qe9Re0w7CXNSFGo9iq0TW52f72BEkh2IDHxi\nNOyVnO8cxxaNWt3mvk4kDKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzWlbeOEf7emJQowl\nzW8CwVjCzeswDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBfsY6l\nQ6aii+g+Se9Wdmat5KZHzOFS9VPvXHn4JoprjgIgGITDBNApzERKnntdbsZxGjs5\n8RI1vozaXoTFkO4VF44=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8230", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8230` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAROP720lDpSxJiZ9xeO/JVLaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0YTE4Yjc2LWFlMDUtNGQxYS1iMzgxLTlmNTczZTM0MjQwYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzExMzY2YmItOTRl\nZC00NzRjLThiMTQtN2QyYzZjODI5YWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeeZEXCkycfxk2a3+Mxdh6lMtWoHhQ85UG+goYEe5I59E1EqwI8DR3MqfWTyO\nr4vDIV0WS9bTQwG0rqGRCsZOGaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2/3YSIXIgvcZpLk+mnULYs2GUvAwHwYDVR0j\nBBgwFoAUXES6WULBCwAgUmOqbQTDF0CkPjEwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA7s8DQwMMvC2YMddH/lgHH0Ee8jiCvzFe1K4xLdJE3wwIhAMnU\nBn2WSvyKVb0XvUigrOhzv/2C4rA7W5w+r0+NubMQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfm5d2Q15a3lUTeJl5ppIAq/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGExOGI3Ni1hZTA1LTRkMWEtYjM4MS05ZjU3M2UzNDI0MGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcUCIWiJmq9rey/M8Bn5fKLLDLvGcPSjIXSMwj9JrNHJ2x\njAuzLYmmpd3FV8sBwA5c6g1106K9c99C5RiKPNDJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXES6WULBCwAgUmOqbQTDF0Ck\nPjEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLV2Rq7AEB0Qd3wu5ybxCfjG7j+INO3k6uBTAgBzhyaUCIQCiszD9QPL6\nE4TQslfKomtLn45yuRN1vzp8pGElT8Kchg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAWUl9yxHEQd6jYEuxxqImDgkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzExMzY2YmItOTRlZC00NzRjLThiMTQtN2QyYzZjODI5YWRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGMxN2Q5NTUtODJkMy00\nODRlLTk2ZjgtYzZmY2QyZTc0M2FlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOI6+WlYgis4GUJJYVwNCaDFSAU8ZMo5S2D5jxbGkYxOAX3UMk9RJPkiT59pLvol3\n668+Ucnv8SYh1OMGKLgiTqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2/3YSIXIgvcZpLk+\nmnULYs2GUvAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAoIDy\nEdMSIBHm6hDAzmriW3+AaKr3w9Tbc2y/j+RELmwCIQD7TTwJas4upwVVoh06+Ojh\nwky7LIFK2PLj1gIlLRgdmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8231", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8231` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISATZ0n80yggc9v7ZtUsFvPokEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiYzE3ZTYzLTU4NTAtNDNlMS04OWFhLWJlMjU1NGIxZDQ0NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI1ZDM2YTctNDc5\nMi00ZWU1LTgwZTItZDhkNDlmN2E3ODA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEShb0Nd9KDCF2No/aTWr48oqt3/eU5ZCLOu3hX2qvMDsi6zKH5xrcAAkRE7D/\ntfhm1SU+gAHZviaD2zn19Ypvb6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS57wiZeM4cHe/Cfd/y1LgyuSMEMwHwYDVR0j\nBBgwFoAUJmLE+HE6j2RcJrvIdiZ7ZAIY5q4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiA9Za9kvqKiIdtGovJtX07srkinAhHig+zI\nUh3JEbPY4gIhAOM6u4ktb4YWzlRsvNa1+TOzlRTGLTWcJ4oY8YhUC0UF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQv+oMSAkzcpC3jW2Wu4t0kFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmMxN2U2My01ODUwLTQzZTEtODlhYS1iZTI1NTRiMWQ0NDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4Ceaz7My4/SHfifHWISUHoaZV3D08M5mY5HdDSo5aF08/\nAiAywbTFZ2Wu7zRDcnlSGkJ86tu8a05CsYJjf3lTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJmLE+HE6j2RcJrvIdiZ7ZAIY\n5q4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALu8BtiE49S/okl5sQxcTikDtv2FHaVb7Er5RhjMr2fFAiEAn+ZgzpX4\nNerAx300sk+QKdEgDVUYmFZXncjSXniUvmA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAWBrvjZqnmLhWzzOuDpg4xRJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI1ZDM2YTctNDc5Mi00ZWU1LTgwZTItZDhkNDlmN2E3ODA4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDVkMDI1NmUtZTNmYi00\nOGJmLTlkOTUtYjI0OTM1MTMyYzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZz52lCFdkAv9ySRHzrA/MSlpF3ceWJrWD9AcAxbKS0TPEA7kHCQ2QEPDMRxWN7Cw\nTCy1JG5A7A+RpDojWFMsVqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUS57wiZeM4cHe/Cfd\n/y1LgyuSMEMwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBvnuvT\nlh0yizuK1um2Aq5Kjl6SWMD2SOcESuAh8metTAIgZsGatTeoFTmHor1pbSvDoyAE\nRceZP/aokOx8RrDphMs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8232", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8232` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAZch252Z+iMBAqEuXtu8oZt8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MjlkNDA1LTJlNWUtNGU0MC05ZDdhLTNkMDI5NGU5MDk3ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA1Mzk1YTctMGQ4\nNy00NWFhLTkwMDYtNmQ2NWNkYWM2NTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQFV8IUyVIZHc6r6Pg0lPfg15UESaogaqc5kpLUZ0pnah/fsDxSOKgYXZ8Zpl\nmG0WOyoADl7Vb3tQGsESLxU1z6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6OE3/dU6RRQbiBS0LnvUKcS9xhowHwYDVR0j\nBBgwFoAUNsDiZ9nO7n5hJyG1MaXLZ798ImEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAy0Uo8ki+mK6kxAj4HSisW1nsv4dRFxDs\nuwgIkbuaL9YCIQDOCWBeFCNAY3P5piv/7MuJysG9BHaxGcOk3WB1Nd/nWA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdXc+4h3Hs5DL8jEMoce07NYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODI5ZDQwNS0yZTVlLTRlNDAtOWQ3YS0zZDAyOTRlOTA5N2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBtvSga0EWNTt+XQGvcADMl8DCVlQV5ohSa0A6Ix3Hu1QV\njyrGyayfgfzEbxxMruBQi5A4BStF5dAVwK7EMfZZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNsDiZ9nO7n5hJyG1MaXLZ798\nImEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJAqZ4b4ndJYoQv+XmudBO6/wBj+GpS5qczFnvwsow27AiEAvL31+ulW\nl0qMQLpGIKacrJrjcKCFqaFZehRnuYzemOo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAScfymK4x8Q0qdrS7MJfNY7JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA1Mzk1YTctMGQ4Ny00NWFhLTkwMDYtNmQ2NWNkYWM2NTEyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2U2MzVmNmMtOTQzMC00\nNjYyLWIwMTktMWMyMjc0YmUzNjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2fE5SMOjjW3QH9OFph6w+bQK4xCrM4kH0jUG/vrdourT3uQ5CzPNR5OWN3QAPO63\n34L8k+ERipKqFDfyPajaiqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6OE3/dU6RRQbiBS0\nLnvUKcS9xhowDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAljKp\nU/QMdWfIthI4MbrjpuuFtMbxcy7lWa7rAm1Ab/kCIG841s32/bMBBfU0k5PRoSLY\n32SIGAQbgKxu0RN6g3JJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8233", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8233` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAcp47fUS6sGIroVKgknvkhf5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyZDU0OTQ0LTZjZTEtNGQyMS1iZDFjLTMzMzU0NjQwYmYzMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjUyMDRiN2ItOWRi\nMC00ODA4LTgxNzgtMDA4MDE5NDQxOWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBsIWtfl9naw0zYrWaLfXvpSDQk1IbyAU6tHPEj+d5FYQFnEfkTxYTUeSpwSx\n+t9NVJvh9rH8QtGxW4jLVUcSvqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIQa8mRBIk5Up32fS1SOOm6N6ymYwHwYDVR0j\nBBgwFoAU3tA0U4yCLT8Td4afkhQBSFo0VywwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiA7jPR1NpU2MLQL\nT5hbL5fZxQmft49vmLsHkyeEYrbARwIgCQg0xcmE+Uxvs52fAsfohiB3IzLnO7iG\nYJGc2+Do80U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXSulj+onTPRLuaI1aJvgLfYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMmQ1NDk0NC02Y2UxLTRkMjEtYmQxYy0zMzM1NDY0MGJmMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATblEKulXgFAuBJmFcUT2zyd4qxpapT7HzIhre+BEh73uvG\n5EACgDAunJK5J1DAGej6mxDX9u8Jhlz/39YbJgMto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3tA0U4yCLT8Td4afkhQBSFo0\nVywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAONzwKhYVY/7us2TF3NF1jfNaE4czlaRIf1VOccgC3Z7AiEAqY6VrskE\n7AlPY63xV1YWSo5w7LIMkFNnoZwmG7BKLOE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAXac9H7KUl0ArHUy9OFROCLIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjUyMDRiN2ItOWRiMC00ODA4LTgxNzgtMDA4MDE5NDQxOWQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTU4Zjc1ZDAtZjdiMC00\nZDRjLTkzYzEtZWY1ZmJjNzI2MjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n07QeZFcBfljpiTs7O31v9Zp1pOFdPgs4Mm85YcoX6EDthTkQl3YM2EAA8EXThdyL\nDfy1X3o6w7D4Z31fDv7sUKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIQa8mRBIk5Up32fS\n1SOOm6N6ymYwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA8uag\naYMn0et3FCi6TBb/21V1J6VuubDXIx9eNxL4mMwCIQC/jy8S2dJ3mCGnKGClKu2J\n/ytRhREyjBlifd746mRhkg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8234", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8234` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAYhJ5ajCsYbzOuya5b1cS3ayMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmYWNhNjM3LWMyMTktNDBkNy1hMmZkLWRiZjE5ZDI5YzY5MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ViZWY1ZDItOTNi\nZS00OTZmLWIxNzMtNDc5NmVkNWY4N2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWy38ZZ6wOxFwp2adI8M3HI85XjX5O/BjmjEY/rg8u8MU0NwsfpPa/n8pY/pa\nU9OLakSEbBFs4NQo6On7r7p3EKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmPYQyjlGU0mxuMzd4TYhcMc9CYgwHwYDVR0j\nBBgwFoAU8zctgnXyPdNXIieoNcFVg9eCVYkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDM04CUNLn6sQmsPOkvWtMMax0rRJEBy5jjex33HI8JqQIgYMA/F12Y2+a0\nn20Mn0+aOXitM5WCp9bY4bzJAkToPAA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaEIkMcd6f8L9cI6U/I3e5HmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmFjYTYzNy1jMjE5LTQwZDctYTJmZC1kYmYxOWQyOWM2OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsQagqaJyW7c9VrSXMlFEWqzgyI8DCC60IBQP3DUXDMIqN\n4jpR3HAFpK08VWXMzg0jqpaY2PXIAE0AM1TVcb1zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8zctgnXyPdNXIieoNcFVg9eC\nVYkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGPm9VxVg0Do8XqIiH85naGYQKqGgADbNLAXfP5DYpZcCICkLJas2Xgsj\nLic2pgHF9bghQ3RonE6A4lVC0CsQQ23/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAUFx8wJymHDalyhRoDo/wzZjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ViZWY1ZDItOTNiZS00OTZmLWIxNzMtNDc5NmVkNWY4N2Q4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzdhNDlmOTAtOTFiOS00\nZWUyLWIyN2EtMTc0ZWUwZGRmMWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlq4UkEqgQFToyvnfPoHkFiNaxMALERwT6LZ0iaO9NaKWTXu+yZhwqByT1RZFtmqa\nRfLG6Jd8IqrgYpcjJPWSPqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmPYQyjlGU0mxuMzd\n4TYhcMc9CYgwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAhYrF\na5RXNU7+IgwkuTUdPcQ4xgMHmGtZgawPb5fcNzYCIQCJSZwxW7sxh/o2w+DoBvSB\nSt1CF3XOfZnPajmc5VV+Nw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8235", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8235` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfHmfbnR3lrAw/4fcZcmhzcuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0NThhODNmLTA4ZTktNGJjMC04ZjllLWM3OTFlYTY4YTVjYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY4OGJlMzYtOTA2\nMi00MDVkLTgxMjUtMjEzNmJlMjc1ZDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAQf3bQ+QZ8oGoXg1UJFG4kr8ZAYFQUH7irMwwr2jOUnN75RyOmrU+iY+59By\nNCZFyWoGOWY8D8u8893JRKPPqaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVmtPUpPOdgjk3HDPueBgo+/WUPowHwYDVR0j\nBBgwFoAUgSsjqJrZKEFUdF84byHJRob7kVgwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCnd7KjplPJgj2WNiACPxm2yoKNF+huEL4cX2AvTCfMnwIgU8PrUWi78zRB\ntOy2SdGBhu1xiKB5ms5jRHZ2gB4TmNI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAddELXFf3gYx8xXjalHvKxy6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNDU4YTgzZi0wOGU5LTRiYzAtOGY5ZS1jNzkxZWE2OGE1Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjoTZsyYJjgDJSKz5HdU15zld5wISNLo8kc3lxn6P/c24A\n+ronBd7kfBUOxEs4RBzP2WwPWvoNdbI1efmU7LjWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgSsjqJrZKEFUdF84byHJRob7\nkVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI37rMcruzZb5G64BoLYsjwPgtp4XyNrbhnBnV74Naf+AiEA8gbRTv9q\nhpaHP48iaPRPQHg0FpRLJm5vt3biaBvtcE8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAXgcA/iQmf5tRzuCzo+ju15PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY4OGJlMzYtOTA2Mi00MDVkLTgxMjUtMjEzNmJlMjc1ZDM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzU4NTUxNTktNmU2MC00\nYjdkLWI0MTUtZjI2NGQ5MTljN2FjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncPeHqbFPNm0P841QYGvNO7eLjLLk66WHSq995w7ufShgB+p8F16PeUKcllC4tLRQ\nxFso4bP7PzfRjfjrV4hd4aNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVmtPUpPOdgjk3HDP\nueBgo+/WUPowDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA7hWl\nl0cE5UcuGM0dVmIB1WewlQ4E9GO1nWa5k+SGRfMCIFyE7U9HVJ+NFiO2uoMka/2O\nz8L+92bazzUtv0XqHsp3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8236", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8236` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVPkqh26BiXwvuu04WlMptVDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5NDA4OGVhLWZlZmEtNGMwMy1iYjNiLTBkYTI4Y2M0ODQ0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM3MDBhNDgtMjZm\nMi00NGE3LWEzMTctZDg0Mjc1YWQ4MWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXa08TQmawtprWdxoF+HVxnqaNZvE47TBKsykTzGFvif1l8DM51Fqwai30VMl\ngQOH46KMfg3OcKn5TUjoKM5tSaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGcOh9ulxvYpZ5ExUqxNMLwfydjkwHwYDVR0j\nBBgwFoAUX4UlDA20HMptLOcL0inLUGHkkMcwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAhnninCHWtE9P061KI0nxKmqyFsPT+weAra0Kpw47AUwCICQBgSw+lakg\nE5Ww9KtiSUU6WE6Ss1xdLjwxSiAnLhe0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWS9946+vZkSfzWfIGhocF7pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTQwODhlYS1mZWZhLTRjMDMtYmIzYi0wZGEyOGNjNDg0NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWuKcAWelX4By3KkHs88ccBFsb/x831Tt14pTxoa1M0ryJ\nmxM5aT1lS40SLehAfk3TbViL/fbNwKONJSWp+UCNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUX4UlDA20HMptLOcL0inLUGHk\nkMcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJfHe993clKeHJy09OcHPAsXkPLu7MH9wH+DIhjAooH4AiEA2WV9F58w\nRZp1ezSvTVyHeZVRbJ4AET5OJa7vIijsE4s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISARZ3Ybsq/r/cyml7UwR6oX1GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM3MDBhNDgtMjZmMi00NGE3LWEzMTctZDg0Mjc1YWQ4MWZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzg3MDgzZDktODExYy00\nMmVmLThlNDctNTZmYWNkZTVkNDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbBaGmeZIKTm/hYrdr4sITTHIyt1gFXX+lgJrCgBFv1vmUi52UxwIWw6wU/jr6/Ng\nZ4DwUp2t3vxAvM+c9/cZAKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGcOh9ulxvYpZ5ExU\nqxNMLwfydjkwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBIH+3z\n4/qgm5MDOBt5DoOAM6M8wzUOj5Ci6i/tStyiugIgLFSCRBvE8YoU2WvYp1Ib4R25\nyMnBx3l1Kmzz9x6o1r0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8237", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8237` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAUg8GODFYKZ/j2R5rPGDfpH0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyOTI4MjNjLTg0MjQtNGIxMC05ZDAzLWY2NmI1NjIwOGI2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQyZGVlMjctYWM0\nZS00YzM1LTllMzQtMTIyYTM1YTc3ZTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3JYCNxfx6JFvlsYC3WC4StB5omylQGbgbRLYxGXwuR+6OrDiNGJi7C8bcLrh\nW/2t8hlsoPM9sxaNlqEYL2omFaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Cf0qguWbuq6g9nKr50ZTPMIDYMwHwYDVR0j\nBBgwFoAU91zB5TBG6Ye4Rjr0ZEKcV9YogwgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAywuwb107U0KNrO6I/SJQnJRhHKb24X3FKi9cVE+q\nhhwCICMkO+CSoCd13v/4rvpIwt+MP6+DwVmWPytUrJV1Z+o9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcwZIm6te/F5SkTbPIoYfLUmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjkyODIzYy04NDI0LTRiMTAtOWQwMy1mNjZiNTYyMDhiNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATG8RLExz2VWae0qTsm4bUjnbKs4nKWgRQ+WlPjdNtL6iCC\ndXguFxL0iY5901g0vonTNGHkYocPT9vpqeJIlmM1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU91zB5TBG6Ye4Rjr0ZEKcV9Yo\ngwgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL5p3KeOcN7doA1aLzIa1V2R7JJuJmbvNHQpQYapkoZ9AiAC27d2q+GT\nmdcMnkW8HhBgl9/8AcU8lMhLs7YN9d+CjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISASsp5GTpGygs+9wZpBDFfd17MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQyZGVlMjctYWM0ZS00YzM1LTllMzQtMTIyYTM1YTc3ZTU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDg2MTI3Y2ItYzcxYS00\nMmUzLWI4Y2MtMjVkZTNhOGU4N2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nClUAzaFuHB+kbK9TXGYO515s6xKetszyEY/dKC+YJsOKVYlqgE4bdAh8AScbztgO\npHbEWEtuEEsr0J7azowCS6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5Cf0qguWbuq6g9nK\nr50ZTPMIDYMwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAEsxm9\nMXAjGyDqbfvlMQVDnTGXI2ru2asDdFNNKIpGjgIgDR4SLe3Gf7W1QJ1rYll0d8pw\ntGwDY+DF/4iyejOLUh4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8238", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8238` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAfrkz4bSrsSK+Ujj0JCOTBkpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MDk3NDljLTdhMGQtNDhiYS1iNjAwLWU2ZGQ3ZmVlYjhiYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzUwNjgwMWItZTBh\nMy00Mjk4LTkzN2MtMTdhM2E3YjNkYzA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoBH8jqaB8WhaWJWn+ia8G8iPYTcAT/vW0uXF8A1qK3OWYYtZKlsFoC6SYL4m\n5W8Pv02WZs99WL/PJVnUxZLE4aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMYuLeHhybgMloIriLPq8Lm/FacAwHwYDVR0j\nBBgwFoAUE4fmEAWPFwKRrsCndXclLeiWbrAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAtfmxayfczIfcvo331TPGi+mkLqjT5UpU9CKqQF23\n2PECIQCK5+KKoQPL11ePo/PyHt70UnFgqYZ0It9Pni5Usqy1ag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVa6qmXP0lgxaza227c1g6X8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjA5NzQ5Yy03YTBkLTQ4YmEtYjYwMC1lNmRkN2ZlZWI4YmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdywjOaIUAoJj3idH2cL+3rzr7w3ruIKxFRiay+OtCb0Wj\nG7S++4SrbS2sbXscNLDS09Ax6tTvQBuCN0EafEfTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE4fmEAWPFwKRrsCndXclLeiW\nbrAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBUqTyr2WWeufCuyV6YW1bzLp1SVG7mE0RfkSwWTWNrYCIG0WZ0QGs3l3\nrH61Ho46df23uD0KkGz/4kutDCHx8vwN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAVe1VofDYsnBma9p1RpJg35uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzUwNjgwMWItZTBhMy00Mjk4LTkzN2MtMTdhM2E3YjNkYzA4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmJlYzhmMzQtMjFlYi00\nOGZkLWI3ZWMtY2MyZmIxMTg1NTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njKeWvlrMBXj9cdzMO0i23CSxdLpYH4zdFBDmfihzZZU8jkkibYXEBv0dPzUWM0dP\nZ56jpbxMUPBcCUjbPClnm6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMYuLeHhybgMloIri\nLPq8Lm/FacAwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA8AfF\nMbJyonTAr/Qlt3ejGTT1YKNoUwewuhjktSSJvIACIDQENXCInmHtMCe+Jx924bCm\n26EAywRXadiKZv5rellW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8239", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8239` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAcN7T7h38Cv5r3bTxsfMN4F5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiOWRjZjAxLTI1YzEtNDY3ZC05NDVmLWE0NmJhODRhNmE3NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdiNzc1ZjMtN2I1\nMi00NzM4LWJlZjEtY2M3ZDM3OGE0ZWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyz8nTyh9Bb+d8uUAC4e/2KoQAm40zHiXACyIPE3Te7M1ATTgPeBGWXTwGuXr\nbfa3t3djdbToMYCq4faDfut/1qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp58Y6NWBUM6YpcO2nn11/t3Ha/UwHwYDVR0j\nBBgwFoAUIMUWjNqbkh2TJ1KtWlRuAxpXguQwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAmMjODFytY5G7v0XfCjKvj9wHFjEUJmfjIqJFRHAayT0CIGOw\nZnjD+ywsHdk50ZFgfSWtfPM/bknffcBoIxbDODTi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa5rmVHDg2iByza3E+cvqV8nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjlkY2YwMS0yNWMxLTQ2N2QtOTQ1Zi1hNDZiYTg0YTZhNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQREdbmaUndHDRyLOsddlPUFVtQ2HRIYYPZJRmZAqrh1CfG\nywQzr092VYPQccAUxYD3GtdDBvCFzuDKs5FmQk0zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIMUWjNqbkh2TJ1KtWlRuAxpX\nguQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAICNwSVMRsBIee7lfqSpUU/PNPNO2ff4IPOo/5/mDBnFAiAXPC1kLMCy\nUA3i5MdKoWXxwlioxNTRyUtZ5v22H5rEmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAVdTVG2zA2Pv+y7BsxJ3VMPPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdiNzc1ZjMtN2I1Mi00NzM4LWJlZjEtY2M3ZDM3OGE0ZWExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTM0N2Y3NGQtNjA0OS00\nNzgzLThjMTItZGM2NTg3N2EzY2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlSeMmVuXY25INCluTeDaze49Yat2cNgdefzFVAHuYJm8L7PCSPMzHnK57tJo6MML\nl21zF5QDWAUerU2xd6kgD6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUp58Y6NWBUM6YpcO2\nnn11/t3Ha/UwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAwXaj\nABImq6lo4t60uQIigSDH1Pel46IEBFAZSFvPNV4CIQCGcepiCn6SeGkzJXoqa/CV\n3pMu9QvnP3jlmhn7kxksZA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8240", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8240` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAYb7lwVdfGOFcUkoGShYDZu6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2MDAzMjZjLWM0ZWEtNDM5ZS05ZDBhLTI1OGU3ZjYwNjcxZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM5M2Q0NDgtMjEy\nMS00Y2JlLTlhYWQtZTQ5Y2I4MzFiMWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+tMa0b6nBK0RV+nUsbSRzFQVFWTtYy624QxF+227M0+3CNpXs4j28HbZdxe7\nEy9wzeTN6Fifc+xJdk5B8l+NjaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiqMl1sAXcDn2+guJMfyi2ezKXEEwHwYDVR0j\nBBgwFoAUu0t7Hm03Ql5dsGw5U0qmLENGnjwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAzndagfxLZHnQ+BqkPFtu8MvFKQXtbMD/\nklVD1dMskLECIQCuMwhamd5deWwr9839EsG2rEi6geh3Iq4FJl8IYqHJHg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXOeyQb6MkTbc0bRsrV1GkJuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjAwMzI2Yy1jNGVhLTQzOWUtOWQwYS0yNThlN2Y2MDY3MWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvighUNB9cGFj65RANpCHCj816l7ME/6+7uIbxsXXA79Uz\nOc3WdMTb8Z3PB8S5t90FuuGTQNxwEm/17IFed3moo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu0t7Hm03Ql5dsGw5U0qmLENG\nnjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeQqcGI5BRWGSsa8LwV6fqMKPw32bawlsutiV3U/anIgCIGXv03q1ou6l\nIf0fNowJ9hhq/jV6apMNRCskMIBeiGT+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAQbO3JaWdI6LyJKXidcgUnoDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM5M2Q0NDgtMjEyMS00Y2JlLTlhYWQtZTQ5Y2I4MzFiMWE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmU2MTYwM2YtNDFhMS00\nMzM4LTgwNzYtZDgzNjk4MDdjNjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nw/2GrVdv7864Xu7mrlLo0rJGnqcGTK2NCVTgI84V8JNluW7FxrDLNFeORlvFi53h\nRvA4EP2JX4vW88IxTa7/rKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUiqMl1sAXcDn2+guJ\nMfyi2ezKXEEwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA4v+Z\nZEXCbBhZqUhfLtuyvdZKPhNlliA2Y9rhIwTe5KQCIF2k3Vn7XFSWholZVpo0syAE\nLLydBLpzjAVBugDE32iX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8241", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8241` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAQuZHRIol55O/aVW2HWDQckIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwMTUwNjU1LTI4ZjQtNGI5ZS1hNmVjLWFkYzJhZTRiNmQ1MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFlNWUyZDktNmM4\nMC00ZTc1LTk2MzktZTY2NDMxZjI1Y2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE41jiL1jr4mo1t5n9vg4ZLJSY7on2tmlHtIcq/vi2xgyhwiFWK+vBmjdhvn7g\nS0zUKGhYrXHsT1WeMk7PG2CWOKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEyedR5vhOhbHW29nq/bWxiyFxl8wHwYDVR0j\nBBgwFoAUIzEd0oqVAuz3jwMmnNQiZJw2kcYwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBxeVckAjWHGWP6j08feL29g8/x2VgFhIU3\nOZhuxS7BzgIgQYTvzILF4q4z3NFNRzRtnfgDRwVBiwgif9PmZVK13Q0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfJuUZMrXW93J3C1jR/ewk7dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDE1MDY1NS0yOGY0LTRiOWUtYTZlYy1hZGMyYWU0YjZkNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzxHFqfzGdsObpU5eFqz4Sq8k+K8f2nv97wHwwA+7llo/t\njW2Q7mhMhHAC4ebMaqbiQR4zv22fkOdAFmB0Nwl6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIzEd0oqVAuz3jwMmnNQiZJw2\nkcYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYDewKD/G1XxtMEn8luvqqaiPM9Yp+RTbBUKmvMg60UQCIQCNaIiQNT8q\n0QnBb1KUZXwE3Sawo1gh6dzgC1zYqR8noA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAbdQFVtRysU6ha1NNVkG7t6JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFlNWUyZDktNmM4MC00ZTc1LTk2MzktZTY2NDMxZjI1Y2M5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2IyMzc0NDEtMzJjZS00\nZjE3LWEzODgtZTRjZDg4NTJmYWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nw1h7p+glwD8nMx4w0M49X683uxVCgLOadUHxwqZJsnepPGRPf1EFor+y1r2kzioy\njam2jy0XNQ4b1yb0rwF0BKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEyedR5vhOhbHW29n\nq/bWxiyFxl8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAo1JV\nQiH7RtS42aE0D7/7XRszoofIVhGCE4+4RljJ2jECIQCDn2Eli9voaBFHIyoCiaZy\n7m5CkmVFc9sYksHaMbHPcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8242", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8242` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAbaZsNN0zvOaB6/4Ph+77ft7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNDA2YWIwLWU1NzctNGM2Zi05MjRlLTQ3NzkxMjMyNjExNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ0ZjEzN2QtODE1\nMi00ZTM5LThkNDEtMDE5NGY4Y2ZjZWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV61j7ugCj5WX/k89EGJgzWge3OG0Aj3Fsc0b2A6F2kHWdCbod1/d7Actkl58\norLTtFdLecFdV0jYSOIBpF4dR6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBKxMyVAJrTG7NSOU4HdBu/B03UwHwYDVR0j\nBBgwFoAUBIiGw3xRbxzYHz1dND/u6FtpbuwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGtneEb5TdSGL+c3438z54BsCODv\nYBuOMdN2Sz0T60IjAiBHG4VCks7UrFA60/ti9kulbqa5wGu/ezOu70ZrbewB+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbxCJm5/sGUWh4EeWByKxmDGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjQwNmFiMC1lNTc3LTRjNmYtOTI0ZS00Nzc5MTIzMjYxMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASb/K+OfdAtLv6QdqWYr8oHveH7aPsvH6+dSJTyulu/FT1I\nEpkR0cEvJq7uhjZNGts11aTHp9nLSqZCaC6jnJj5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBIiGw3xRbxzYHz1dND/u6Ftp\nbuwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALGmdEn4WtZVuvcruKdSnuW95maQ63390uiwX3EEtW3CAiEAy/eT6+X9\nMrpRD9+kKo2VGSnh8rm5pEtGT7FWXi5uGPg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAX058ImmgcucgDNVsFjnJvX6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ0ZjEzN2QtODE1Mi00ZTM5LThkNDEtMDE5NGY4Y2ZjZWEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDdhYWQ3NzAtODc3NS00\nYjFiLWFmNDMtMzc1YmM3ZTFjNzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUU/3iTkXdReGOWZjww2N2WM7HiAov/L+L2IrV7VEHyBr60nZHiG+GrelprHFA/po\nyN4rWlXcMNRJYPCXbzKqBqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUeBKxMyVAJrTG7NSO\nU4HdBu/B03UwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAkLnA\nKXw3ujCl6SxcaJjTZc1AcGvPJ/YL1V6BF0NDj80CIQCYl96fyZ2V++bUqBysvCOk\nWI7mWUBBvuL+jydnf267SA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8243", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8243` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAcXgudnB4/8+xGUY0BzzafLfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZDA0ODg5LTA1NmEtNDg5YS04ZjI0LWUwY2RjMTVhODZkNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjYzYjg0NmEtMTZl\nOC00NTI4LWJjZGEtYzhjYTA4YTQyYzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEayBvXTlboMcQbJ5B8Y+0vFCrt9rdeSpL9GGY3TAIfFEOGuVXy725GCMbHQ2o\nELZboYDnx/uDe3vEZv78abL93aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFy8Ew2Yxozd1zyWpPc5g21WuJkUwHwYDVR0j\nBBgwFoAUO4fFTlriVfJDdz5OMimijBwePVwwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAJW7bhYZ\n2IJNrJbRynfDNzAg6/I2LE3qd8pQUH3rlBkRAiBPsnhJjELoODS/F4TeAlVVIjy3\nCRP+UfEvonwSEq2BdA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd3pcVPbvGAEk+tWHK0KFhIDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWQwNDg4OS0wNTZhLTQ4OWEtOGYyNC1lMGNkYzE1YTg2ZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATY2fyxXsJjK1oyf/quARCXqoK0JaXaKfeKe2R3UsR9lxtQ\nBXfBCXz7FjngphTYN+Wzrm1PYVjrFxnc7tVOck3Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO4fFTlriVfJDdz5OMimijBwe\nPVwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWs2d8+CJc//kRmRueo03yHuyiX96Aa7MnRXOh6tXL/YCIQCiqY4WxA9/\npdejnZdy15p07dlAQVFGQTFmn1ZZjaE7jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAc1FvxZC0FfYdwF4mSuA+IN8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjYzYjg0NmEtMTZlOC00NTI4LWJjZGEtYzhjYTA4YTQyYzQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTZlOGUxZTEtYTcxMC00\nYzYzLWIxMDgtNmMzOTY5MmVjYzQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTtm4WY7HATkHmyYUorFuuiESM1fWKoqSmCQoHaVWMygA0H0NFtLP3pJGqLLzKbw0\nYz3Y+zvaE8DZLQcj8N3pG6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFy8Ew2Yxozd1zyWp\nPc5g21WuJkUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA6+Nm\n74scCBXUDEZJth9H1jXBrbxyEAidSfFlcpqDsJoCIFCRYchkygTBIPEgqp/xgG6G\nqaGuqdsZHewzOGFZoS0d\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8244", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8244` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISARX27J40xnF0JDhS1rqc1Zf0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhOWZlY2QxLTUzYzYtNDEwYy1iZGZiLWQ4Yzk4ZmQwNjA1YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ1NzcxNmUtZWY1\nYy00MGQ4LWE4MzYtNjMxZmU5MzA4OGJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzyWvdTit9T0VCpNCzEbC5mbR9JPHUeWe6Y1vUlvxiMoZS6Jypm1OSqWF7GXV\n3bX4STo4TD9vjEEfH3bNExU6aaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJFBY4ZzGhPAnUWddwNXSEKDgmZwwHwYDVR0j\nBBgwFoAUCtYk2HxywSxW2aZ8cBSuDL7U+wUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgTdPAla3r\nCHwlxJTwRBmpX6g1rskk1SChBaUoXlprW1oCIQC3nmKxT8XWEGW0HTYQ2fTZh7do\nbzQ3x/OIXw9W+U8Zww==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfRjBij+f3EvGz9Dy/Y+phrLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTlmZWNkMS01M2M2LTQxMGMtYmRmYi1kOGM5OGZkMDYwNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxjiasDMn+rb+uc5/U8sbZl26ffGOUJI2iDXrbMUdF4qIE\nHEoR5yoqJBn3U6LOUqmSO4kSLwn173Emodms7Icho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCtYk2HxywSxW2aZ8cBSuDL7U\n+wUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZwGUvashv91Qmhppktqy/FmmneCqzEugZ3+xnzVtOVkCIEqzC8hHM/gN\nQn2YYrkoIZElM59s/BP7BTajr3xSGFU5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISASnkto8gbc+dBfDmP+UZhuXGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ1NzcxNmUtZWY1Yy00MGQ4LWE4MzYtNjMxZmU5MzA4OGJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjg4YzM4NzItOWM3MS00\nNzYzLThjM2EtYjBjNzg3MTVkZjM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzhCSr1B6dJCoT1YLL6naJmQw6Fm+a7+xoFHyVc2A/l1pOK4IN4tOO41TiI94Ioi3\nLonobe16R8nXGbzfNLa9kKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJFBY4ZzGhPAnUWdd\nwNXSEKDgmZwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA0pPV\nume1fW2Tqy8YHZwSTXRq64J63WTolSYyw/KYNF4CIQDXxrHyIh57/ozx11KJh2O0\nwp2RjYiT8A15BcU61SPyRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8245", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8245` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAWaQ4663vBTqOiw3ldIpHs3JMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NmJlZDU5LTM2MDgtNGI0ZS1hYjJkLThhMWEzMjUxZjI2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk3OTkyYjEtYjVi\nZS00NDMzLTk0MzYtMzMwZDNlMGJmMWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE39MPO+od69yeaP7XLyY9XvgnWfYRDwRyATqh2+YIIr/vB2DimN/ByX4jbn1m\nMEl0f2C1sq7HKwn/epeapfSv8KOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVfZSA+EeTYHyhaFcgJSy1rBYSzswHwYDVR0j\nBBgwFoAUfodjP0NUIk2183fqemR7J4QiwoIwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGN3sgkL\niIaZxY3iFQ+1FS/e7RwRCSydfUvZ4Emv2uScAiEA4igMUPFdpvnjJa6Ww5cR9WJe\nMGtn3KDSSgPvKPJopn8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaM98JMZYI0k4l7Ok36S+HeiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzZiZWQ1OS0zNjA4LTRiNGUtYWIyZC04YTFhMzI1MWYyNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAnjZ94u/Qws3cRa5cheRUJ1fyh70JeybfRaxVWFb3E0aV\nLZI/VPvbD4c5dkz0t6Vn9dk7yg+RDiD9YnS2XGiRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfodjP0NUIk2183fqemR7J4Qi\nwoIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJOqtAXnHRHVCAcWEGjXs/iKHLeYJgIlLFFbwNav8sOIAiBKaGLYDIoF\n/jQFh3vFpnqVI0jbaag6Tdper5qwbEEdPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISATmjuJTnIMkgV2uQTT9pJD/aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk3OTkyYjEtYjViZS00NDMzLTk0MzYtMzMwZDNlMGJmMWY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjI0M2M1MDctOTBkNi00\nNjNlLTg0NjUtOWJlNzlkNTc4ZjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYR20m+CIbathuIRDgLvTmxBeQZSSKk3MMISojw5tEnGQdN8ozhA2H6y54w0Xw3Vs\naEKlzrVOlK49XoQUDNHv46NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVfZSA+EeTYHyhaFc\ngJSy1rBYSzswDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAwPMGO\nj6HNlQ2zr7yeQE5ltlw1z134EZ9LPWbr3ShLCgIgYPGa2T/Zk0yImGIk9twkUlT0\nXrAg5l19y2LQ0Vk4wBQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8246", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8246` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAf8YKWYHa7zdO7LbLbnJNb4IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYTZlZGNjLTZiNTMtNDkzMS1iZDBmLWZkZjE0NWEyZTY1MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTEwYWU3MzMtZDNh\nMS00MmEzLWExYjItOWI4ZGJkYjc2MjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvl3FGH1KsFheIHrgmS0JVCT3qN3bVh8QM6WUK2CxMFZ35sDxW2qmKaJJdQrp\nAd43AhQjsChRYgwJnnWQOF4Lb6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt9nIevu3cpWoIEz8zgKIjMWNuU4wHwYDVR0j\nBBgwFoAUusVs0MZTeJdjbuchrQNnSCojx+EwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIGgx2Z+lInHNtD1aJs9syulJKWqRis77Tjr4EjbH/G0cAiB/LjWLIci/\nXfNdOnShUPh+59qalzeCibMWqILc/ZrbYg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU8tgddtffmZM1nmZhSmqUpAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGE2ZWRjYy02YjUzLTQ5MzEtYmQwZi1mZGYxNDVhMmU2NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgLyPAMNTJttAxSdZWHtxYTS1J7tsbNmrDA9Y21ugkEqoS\ndTaOYorAjXyxG9CzsUZhvFACRBa6fRHXRQihH1oyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUusVs0MZTeJdjbuchrQNnSCoj\nx+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBeToaTs4GXi4QzLW0mlUXI8GcmQLECffw1NuL7T6u0wCIQCwjso25eDh\nhrRVqan8uGqnqyh/sKFG43h3XfxLkEPk9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAX+yVxmt4vy/tUtymKRNrlSHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTEwYWU3MzMtZDNhMS00MmEzLWExYjItOWI4ZGJkYjc2MjQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGZlOGE2ZWMtNTIxMi00\nMjdiLTkxNzktZDRkNDNiMzUyOTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmGLZmWnSx3FyVSAUYKsInxGM0UvrFouuu1syi7qbtMpdUvR9xYXqq3SdF6sDkAVb\nxuQ7jozEoKRQdRfzRXZYIaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUt9nIevu3cpWoIEz8\nzgKIjMWNuU4wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEA8ahq\nVB6PzOHV0hAwwj4TKtUDyoQfqO6+BN9ObfPF4IoCIHhgJjMlkhi58f6WAZUWE5jK\ncRbHrVEt6DT1F+8Nvs5v\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8247", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8247` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAcn+oS8XQPpA84AHg98eNiwLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1MzU1MDc3LWQ3MzYtNGNiYy1hY2Y2LTE3N2M5NWIyNjY4MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUwMzRhNjgtOGQ1\nOC00NDRiLWJkNWMtMDQ4YmExOTM4MzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOUt9X2Gd126TLy8XgG1B1CMl4IZSE3vA0UJ0rngy6SRnO96GUmfcFutx9h3X\nb4KKFE+Zp3wxMMfrPRRSnGVyXaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs4bq9SA12J4TZAqe8WzURbqW6CEwHwYDVR0j\nBBgwFoAUo4JQqo2409qsoehm76su4U6Y+TswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCbfWwsW8I6Ad19nCB3+CUtnytE3HmOqaB9rEUGSn4cJQIhAOOtbH3I\nsmOOT4D1L2ImZVOXxAaG8GnWveXIlfBPTreP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc4uZMM63NMxJMxR1Q/cQ81oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTM1NTA3Ny1kNzM2LTRjYmMtYWNmNi0xNzdjOTViMjY2ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNUNEYh3ImrN7dCNd/QYmQ9u+tkLa9e9DX1KLvv5CLi/Qd\nvOXPcrEfCeONkCyljGhwgiuy5PEEwc0RsnNlVfpQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo4JQqo2409qsoehm76su4U6Y\n+TswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVxWJsVhK3+BcJQVNVV3H+BebffULmjK95zRIRtrsncECIBOV+v/5NfZ1\nDhlbB4pFG7Q93TGu3J0MavM2RCW7Ud7v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAS4epAASQJrAaA1b62nO+vnwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUwMzRhNjgtOGQ1OC00NDRiLWJkNWMtMDQ4YmExOTM4MzNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzg4MWZhMzQtOWU1OC00\nNGM2LWEzMmUtODY5OGU0ODFiMDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4iK/LhrOtrdVPHb1v7XS+qDR7LDUddhUd/m2/jd9m9GEEzyZnNrSatzWPM2w0RR+\nrAIH5qd4TycckQ9eTftHSaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs4bq9SA12J4TZAqe\n8WzURbqW6CEwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA2H86\nNoSFqBcGsxcIl1CbyAYiuomeSSxVgDts8vhFS/QCIQC4OQmQlYqKTvSqH1SQMgqy\n+K8ogp++SbcBCUuuFXcT0A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8248", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8248` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAXXqXHhiQrHMAE7px/8f3cwVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzOTM5ODliLTlmMjYtNGQzYi1iYmY1LTg0Nzc0N2ZhNzBiNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QyM2Y3YzQtMWU2\nMS00ODI5LTk0NjUtY2YxYjg0OWMwMGMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI09JkYd9iEqDIFnGNmNz/uvVPV7/NwdL+SffUx4JAmuM+z2VlBkEmV6BR95K\nBg3SXrfVrSKQD8ociK72NRXpEqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6A9CeHfTADOSOH4RmSp7h5+DZE8wHwYDVR0j\nBBgwFoAUCSTPNy3MUtyhnC1CkvIfAWkYh40wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQC/Fxxpb6FcmY7iT1C42iKibRQvVTuycMiSpsLauZXhFAIhAPP7IJZ6fAQ9Ml90\nMS/cZDWlj0SGhtFbZl5/aBNYi9mY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbMKK+1V6d/y3xlZTQzQBsi8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzkzOTg5Yi05ZjI2LTRkM2ItYmJmNS04NDc3NDdmYTcwYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTxQeYCxl2k199qQTPRoupPVZWM3qyaCGGCrey/91eNOd4\nqz3K+8uq4AR3B5mlPkifnJ+POwzQXCQkzFk7HrlNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCSTPNy3MUtyhnC1CkvIfAWkY\nh40wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN/bzLO233/cg9G3Ra5ZgK0bJSGWukrS/8Kqg7cFC7+vAiEA3Q/xsXqq\nVgr/mtr3XcklPSxbMwuXkYPmYPBMCoNvVkI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAQzLkmXkPR4QOYMQbplazQF/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QyM2Y3YzQtMWU2MS00ODI5LTk0NjUtY2YxYjg0OWMwMGMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWRiNjkyZmYtZmZhMS00\nZDI1LThhMjgtM2RkZTYwNzRmNjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzU+V61Y6QovT6AUKh2KFKxOjjKycPMHRVtFbuzyT3wWSuBngH8RVr/HnN0zc21tE\nwK0pucz1dPKLDG6CFhl9gaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6A9CeHfTADOSOH4R\nmSp7h5+DZE8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAkFE0\nSnSeyZwMrRNK95eKhOYDlb5uTYuYC2yihYKY1H8CIBqBiQdP+ihYKeoh2O9wyfI7\nJRa803dTtlzXmByhbWDk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8249", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8249` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAXch2Vip0yayf2IwFxzp2WybMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljZjEwNjg0LWYzZTktNGM0OC04NjhiLWRiZDdiY2Y3NzJhZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDgxMjJiNDctZDI0\nOC00MDY1LWI5OGUtZmQyYTQxYTUzMmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFN7tEwtqFe92WGyiLToJ+jmxwfka9p+27lsramc07IYvM1aqa5Xddplyl4fE\n/+8ZqnkheEVt/njFZcyz0L/c76OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7PYsvargV5PDEk7BbZrbzCUNw+0wHwYDVR0j\nBBgwFoAUYtU1KEbgviUheqfP3R8ksqaoBQkwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCZQSOKKwDyCGvLTwCjMnwTb8vW5T+0h+LRDPsM6U2mzAIh\nAP2wQBl5zlycB44HMJ6MMUk+vjMV1Xqf9EndaOqKVKJu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVoV5IW6/OExMpWM5JjkF59iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nY2YxMDY4NC1mM2U5LTRjNDgtODY4Yi1kYmQ3YmNmNzcyYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdrlmGth0Abgc3MV9ldtnUFOKctbHoxNeXjh4yCbYQXvjG\nD6Vzyf//8tP/stWvfx6cuRl0sr6WE2u7lOSjOBTeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYtU1KEbgviUheqfP3R8ksqao\nBQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTbTx2pTyQVs6Wna64OHQkbYeYKPk0nX73j9o/HrmoksCIQCh5N1aSsIV\n3p0YpjyuZv7rr8S2ZLiuT3Cnz6U5FrRISA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAWeNbH7WPtuMxO/DlenMiiaXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDgxMjJiNDctZDI0OC00MDY1LWI5OGUtZmQyYTQxYTUzMmM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDE3ZTk0ZjMtNGUwYS00\nNjJjLWE5NjQtZmQwNzRlZjg3NDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrVT3OzlhEknHSsPfOO5WVAiFsaK6rJd0qu4bI7A8WpS4V+RYWF6H1xmn6U49ieyg\n6GiozYHy7+jINykzUXLKV6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7PYsvargV5PDEk7B\nbZrbzCUNw+0wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiBuV1Bg\nDk8Ww0dENzJT5Hdk02oR5aF4sD4QPf79emI+WAIgNNDt/2aXuTN8gZiXtFgK186m\nWTSVPhvN/YRaNSwc00o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8250", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8250` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAdSj3GGaTgfGHKcGYqz9ZBDVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1NGQwMWUzLTA1NWMtNGRjNS04OTQ1LTg3OTRlMDE0MDZiNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzFmOTExYzEtMmU0\nMi00ZGQ2LWI0NTktNDAyMTUxZGEzNDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE877zHynVpJAd9rRlv6x/5xC/RqFvJ54+xFgOCulubGW/VCbsALpBQs5KCAxh\nVLX45pHHpVDJ+KVLjGDguHMuQ6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTc/07XxkEtBc9oJgaA9+7OzV2hwwHwYDVR0j\nBBgwFoAUpcJ2dwmUb2hjadR3JPC7CJqBzLIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCh5zu8U7eXJHX8N5i8aRtvJvk38Ws7ttpD+WgULzHVIAIh\nAPakiK+EBoHOaC+J9jfsNR4QmBU1RyeKfFB6a3uqoDU+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbdPEY+MLFc1lbItWGZ7tNV9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTRkMDFlMy0wNTVjLTRkYzUtODk0NS04Nzk0ZTAxNDA2YjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3Nh8+fDdmV+TIqTA78yIWBMYtLXUfT9e0Hf6pZewU/Pbn\nzDQ+7FTStkcNZmMulqKMyFiBNtZQCurDi7vTPQUqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpcJ2dwmUb2hjadR3JPC7CJqB\nzLIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXXR4sKo5wuHkq29fN/qObiKns++iow9oAoigOphT9NgCIQCBnyCyJTR4\nn96zM7JD4jZ1Eb3RAG/irx1qxpdI2FtWYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAamQJsotJA1U2tFTKl4GjiwOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzFmOTExYzEtMmU0Mi00ZGQ2LWI0NTktNDAyMTUxZGEzNDNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWE1OTkxMDEtYjk3OC00\nMGRhLWIyYTItYzk4ZDFjOTc1MjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOwB6ShNZhmojN0Tz/ok3s/nPwtJK/DAsZehGFeKMy+qI6H/I/pkRMELLwgNd77QI\nCwZA6U+jE692iEx0nudQPqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTc/07XxkEtBc9oJg\naA9+7OzV2hwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAhPUa\n4oXOYTBnycNzKXFrJqT29LujhlxL73ObpWxXw2oCIAs+t/5bdQqNdR0eqYOkRzSp\nlQVXCzPaJGOx43Zz6O9s\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8251", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8251` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAW0h+uL+sxDTXZ/X1S2Oc9QJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkODk1ODUwLTQ4NDktNDA3Mi05NjZlLTAyNDNhY2ZlZTUzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNkNWM4YmQtODcz\nNi00YTE4LTk3NGQtNjhkZjJhMWJiOTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn8h+q+HQB7cwf0ge8ZZvCVIcNzEiTfLKKMxGAMS8mNyy6ZUZCDmvS0ozFzgZ\nkBwzpYK9QDgD7vLyZFIkntvGDKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxkhW6JuzqabCaYq3bJBx6ZVCMpkwHwYDVR0j\nBBgwFoAUY2QJxUMucRmymKNfbxHMqvPYvJgwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDuYrDEgXJB\n2KSgE35tVSEHti3UEK2gIT0Liih+WI+tKAIhAIxImeHID8TTKhAMd2gmKbeVITQ3\nF6JHPdyVlHXWqcgJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT3Uv4oSVR066tFsI5lMDAkNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDg5NTg1MC00ODQ5LTQwNzItOTY2ZS0wMjQzYWNmZWU1M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGA28Sc4i7B+5vp62ktCr6kedKlKwdiWtsxbw/kzGSfTcn\n56CQN3NnD+EoXWD430XAYTBRFlTf6BXJW8GBLodZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY2QJxUMucRmymKNfbxHMqvPY\nvJgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL/FPXrfOPqLSv+HbEYU2GDkiHsmxw0mYQExnLyMWAiXAiAKTfoPsf5X\n4YNx4kWhHp0Gop2X7qM0pklffG48JXM0bw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAVA1CWMBUrrPIGdf7L6SH1jTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNkNWM4YmQtODczNi00YTE4LTk3NGQtNjhkZjJhMWJiOTYxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzU0ZDJjNDUtYTE4Zi00\nNzg1LTg4MTctZGEwMmZjNGUzZGQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndl7ulZs84vK61FxadZ7WWtmGo0xxbgesabOClIKqLbVnJtek5Q68GrsijPbSRI3J\nuRPpbM526orQYVdbGUuSl6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxkhW6JuzqabCaYq3\nbJBx6ZVCMpkwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBE7LUH\niX3CKVSRA64MLVI4bk+jwulPhRR3k7CiLEpGcwIhAOFAHg7K6OGoDpRRww39QHkm\nO+iclpMkmg8KaDdFuAcW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8252", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8252` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISASe0vwSb89/1n9oFrOj1WU21MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhODY5NDIxLTQ1ZmMtNGVmYS04MjBjLThhN2YzZDI5YzMyMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE0MDZkOWItZWM5\nMC00MjdkLTkzYTMtZjIzODAzMDk5NzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi+a2Dvn4DgucTA+ljv7wi4hQJbHlwDd9McSpg9hpCzXMBZPMCVQjsWPN6n30\ncsO8yoXPj7fl//3RympmfjQ4yaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU46JggqN3BKa1rbHAOp7jgXXzNWYwHwYDVR0j\nBBgwFoAUNL537G199RU7BkL1t/kItO5x7JYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJQsoBHBrPbJwhOZY6yfKDa9nCipAL40diFpPP+/Y/wzAiAr49ey8YyH\n6vlYxmQE+rbs1eSfxBoMJa/OFCp2d5mWfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASrZJM5aMyEsTLBaSGbARimPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTg2OTQyMS00NWZjLTRlZmEtODIwYy04YTdmM2QyOWMzMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQd7g3A2DACeWR0wnuDMYV4dKFuG4lCD7g2atFXrQvDH1St\n3LykWznxkGzXcbc5iE1I3Wzhx1K42kFCSHup3Hh7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNL537G199RU7BkL1t/kItO5x\n7JYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNFJjphmT4sVlrN5MFbLlZY0+fRE72Xj+vRqNfg27JncCIHfdaUvI3XdW\nyB3GvHRp/LAnA8flOycw1+DpM17J11AE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYfPnEp2zpfYaU/4bIQsqbktMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE0MDZkOWItZWM5MC00MjdkLTkzYTMtZjIzODAzMDk5NzJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzU1ZGNhZjctZWQyNS00\nYTI5LTg0NGYtZjE0NDhkNzNmN2I5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nk0hiq8gWDYWiyVD58esG0jAO2NFVmsimxDUR+a66W1ZJu7NXAvHIp0yZVSSuiGE6\nMoOaSrv6NwpKCpfKOSmmPqNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU46JggqN3BKa1rbHA\nOp7jgXXzNWYwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiA4H9mc\n7u4ahKLui57z+yr7SHVEgHRBj9nCXIwtezwVUAIgYUJvCOU9frqKGWZa+VQPwLQK\nxTQk8qbOV+nIGjbLEMs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8253", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8253` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISARvMx+RqLbTpIemSZvPmHFs/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxYmQ4NGJmLWJkM2UtNDZlNS05NmYwLTZkODU3MTE4NTZkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJlMmRkMTAtYTk4\nYi00YjUwLWJkYzMtNmFiOTFlYmE1NmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElgUrEGgMFn9p8niv42YhUl/rpiWv1vwgjebOfLEWG7l1KHMht9XVVVKuCG05\nvrpl77f23AFAunTPVS5M8+Rt9KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp8SqbnXhXqRjKjQofwLEl5UIvmUwHwYDVR0j\nBBgwFoAUpPQGiRNUT87I0FT0vYAH3ioBzSgwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAJUp2n8g7XS1GyAs49IcOqc+V1gP2uVT0sjyvLPb819/AiBT/y+Huugm\nETnkcSUWSgxvF5HIBggBeTcOpdo4jOXn3Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWpblVGsMnkmuCTYskCpUHd9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWJkODRiZi1iZDNlLTQ2ZTUtOTZmMC02ZDg1NzExODU2ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQeRgm7jaGIZj11C7ZhvR1P2zGPVc2BFfGun08Ebg/sNFo1\nVA+tmV8Nt/EOzdYUXpmtTi2YBJ9T7K7GADBd8lgJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpPQGiRNUT87I0FT0vYAH3ioB\nzSgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTF3Uzonydqowow/3VykTfaE6SV3g0//pJgQvZMJnLQICIQCGN0Z7g/NF\n7CfPuULy7JK/WzjO3n6tDPXGTzfuiHGfoQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAWj8RmXc9y2ocWIMjhXYSXxmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJlMmRkMTAtYTk4Yi00YjUwLWJkYzMtNmFiOTFlYmE1NmIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjFlYzg4MGQtMmMwZC00\nNTczLWI3OTItYzU1N2M1YzU3MmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFwh7rzaF/us/8Wz35AR0Jb2TsTHxDyVlo5cvQ0I4HjC2bISYVXkP5ilIOR7XkvGC\n6cJ5ZmlitChG1L3RksiYn6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUp8SqbnXhXqRjKjQo\nfwLEl5UIvmUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAPBefw\nRW21UJOJd1Aolzp8xF9WBgJ7fmKvFFeZJIekZQIhAO7GEYBK5mvitIPlROs/+BFD\ngNHFeku9UwVT5m1NV+5w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8254", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8254` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUDNtNBh4WPazZ4d2HQF5zT/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmNWI4MTIyLWRhYWQtNDg4Ni04MTA3LTEwYWI4YzQzNTAxNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTQ5MmNkMzYtOGU0\nNS00YmNjLWE4N2EtOWY1YjkwZWVhOGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAES00wBLVGXFf12H4CoowvDySyKTkJnpP/THgCHWQo5pQq2GGz6ik+hA4+cU3B\nt9yretBRoJL5AXxZZVLFoHyxbqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhPSrp7N9p3re9dFy5S1pi8resq8wHwYDVR0j\nBBgwFoAUuBfZWlfBRFi5G/fAJ2xjBBIOOWUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDLoocl528cr/EvtrnHzCJSGckVLAq35IZylgFFcZjsDwIgCBnaFkLR\njtw6nek5nRg9/0vmH9rCIlshsy7n+hLSTM4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX00j4fxgSEevNPDuwlvOhREMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjViODEyMi1kYWFkLTQ4ODYtODEwNy0xMGFiOGM0MzUwMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqO1m5DS3kG4bVcyK93Ze49dkSIlIy6CF6l4zh7NGkarvj\nfT5QpuVc6/75SSg/U1LPeYdzIEsSQZzKCWwViOcEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuBfZWlfBRFi5G/fAJ2xjBBIO\nOWUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALNPcF3lGcVK69zw1i7nytfNSi/AUDxfoLuBGNkZzz3nAiEA3Zj+9XJz\n5xiO567THQ6EqqcS85NVv9EykChPJo00xEo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISATIgoJWubakl3sGSr61Tx5grMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTQ5MmNkMzYtOGU0NS00YmNjLWE4N2EtOWY1YjkwZWVhOGVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTY2MmY3ZDctZjJlMi00\nMWQ1LThiMzktOTJhNGIzZDM0NzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0nWzvWg/4etiink2rP060umKmneOEXz7ByLzo9i/ACYbZyy3k/yuICJFASSpw+3P\nG3tEDDq58Bgfbu1A1TRpCKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhPSrp7N9p3re9dFy\n5S1pi8resq8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiAzC0rB\nu8qhQwTfX0D+ZaohMXSfPC6/WGw0eu/UhQnbkgIhAJAa/1G5GCYqQ7CEJc1GWivI\nxVEfYf7IKx39NHRIow4Q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8255", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8255` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISATADUDItYm2jOtU1X4ZbQeH7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3MjRjNmQwLWQwZWItNGYxMC1iZWNjLTdiZTUxMmY2NDM1YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM0ZjQyNzYtMmRj\nYi00NmY0LTlhZWYtZTYyZTEwMTQyMjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF6GQpzOLcxHfPm9Q9Wu/GE6SkpKJNBGVvRbG2B9l6UNgBoM3ykVpZXgIBIUc\n4/m1SHIqkNhVR29kXEvUmct5cKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjJYbkO+O/oUgaKuiX29veoSCtrQwHwYDVR0j\nBBgwFoAUFYaaoWSZb20DvTNOtQDeJsX60EswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC8oUIHxRMfNIspakzZtPWiD3gVW28cIjoTXdSo\nmBNpGAIhANZaUq8U6vq+ZugpOQlyE13oOVuou0x5pib0feYjuhyB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaQhqDZ2nBqiGXdh5lAvYtbNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzI0YzZkMC1kMGViLTRmMTAtYmVjYy03YmU1MTJmNjQzNWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhGcqA7ski2hVitOQ1ZI4V9W03DqSVw4J8y85QucuILf60\nEbG1o4zZuxxGQ3HhJFgjfu3uKtyWD+Mllxw82h3co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFYaaoWSZb20DvTNOtQDeJsX6\n0EswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKVt11E8HwEQPUfFFHZAG4fAJ1xcy9/agQ6PQhL5kK4ACIQCjKmGKX+uN\n2gP6QYQ6eJK05Fq1bxK4lsyUCgaB58Ej0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAUDMUSE/7WgJ2jIc+WfWcQScMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM0ZjQyNzYtMmRjYi00NmY0LTlhZWYtZTYyZTEwMTQyMjQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWMyMjZmYmMtMjM2YS00\nOWZhLWJkMDktMGM0NzlhN2NiZjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDP58E0PETDaI9+q1J+MlUF6qc0mbPTLUWt3YtALu5XJbSFDdbCo013fcJOKjlPn5\nhIAdL72wVq/4DXCpMmmQhKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjJYbkO+O/oUgaKui\nX29veoSCtrQwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAhnkt\nJjeJrbNywvCY739cZmrjVVhKUydLH4ZC4uAhSKkCIQDZygM8yWMuCvvRMLmppqQI\nfGMXOPvbCTRxB0izyKYAQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8256", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8256` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAb7VwQT9irGTHDNkAHBeHuKGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxMzU2MzU4LTk3YWQtNDFhMC04ZWIxLTk0ZjhkZjc2YTE3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA5ZWI0NDAtMTE0\nNS00NmU0LWJhOGEtMzlhMGI0OWQ2YTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYo8jZ1N+aO1jN9KOJSu++tvt3t5Yf78otc6Xyr3tJ5m0XJmW/X3nRsp3QKcv\nfjxML75Psuq3ji26flFLR/7hAKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi7T4GMRMCJDfGHZLogTHwFnBJm4wHwYDVR0j\nBBgwFoAUr1bBPZARqe6XgZrAzwYO54LUktkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIEQyHr4fbnFejbmS0ZOpStQbl5dR6T0dCvZmPmdT\nvOr2AiAanzrPWy/m7jrjEej3UYWjrzm+YehtcNDPtlHfUQBHCw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZdqF/FrqldKPnsXutAsvJCyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTM1NjM1OC05N2FkLTQxYTAtOGViMS05NGY4ZGY3NmExNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARB0KPBasgtfoQMIR2OI21ZCufJz/WDdIbK+zO6v/rBNv2v\nm1+fsxl9QUvwcBFRVb2H/GcSqcAgbabRunIyEzrVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr1bBPZARqe6XgZrAzwYO54LU\nktkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKU+kbbnQPukGHMtOGeyxAr03uBKgBuT4seMI1HirkJQAiEArpTkBQuu\nTjpKGYztERw/qRTrOMVpjlcb3veCVM6PDQw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAe6JXoao4vDFP4gYF/NiNLd2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA5ZWI0NDAtMTE0NS00NmU0LWJhOGEtMzlhMGI0OWQ2YTI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTIzYzhlM2UtYjJkMi00\nMzcwLWJmNDYtOTUyZGNiZDhiZmNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+m5g6D5sasDNosZ5v0gEGOIWZ03vQ10BUgh/cqPZo+v5NOqC1ZvSDjNJa7xw6LMd\nfcGgh0REvOd8vS3mTI7Nf6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUi7T4GMRMCJDfGHZL\nogTHwFnBJm4wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAl/Us\nqdmf9H/WAS+xC0VO3zdhpYrSnmQSXDrUUAO1h4kCIQCqD0Ty7VFySaeEDH14c3Tl\nrGGI2dsO0eKeuKsytRlojw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8257", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8257` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZ0OJpUBfDZviGMEd0mG3m2hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhZjBmMDgxLWY1NDgtNDYwNC05ZjlmLTBmY2Y1NjM4YWEwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI2MDQwNDEtNDEx\nZi00OGU2LTk2YTQtY2RhNTAzMmIzYTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZW4Sl3lu5cRQYti2IHg34RdO+keqz39euiSxmpEst95WVw/OXWNTO7EwmNdN\nqLmzlsRzY+u1pVReSRnglBHX+6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtsVOuVA6WeToZPDLQQFvvv8V8rIwHwYDVR0j\nBBgwFoAU0d0E4NjW4Uxr/BFiFAjVm0Nm8CIwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDB+mgZlE9Zckia3crNEBhJW1eCm3B3lc/X1QvtPETZwQIg\ndsZgeO7PMoEHqsHdABeTUEyIWvl4hcxw/qX0RvtDIz0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXoYf8xFvrjC5YVqFI4QXwGcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYWYwZjA4MS1mNTQ4LTQ2MDQtOWY5Zi0wZmNmNTYzOGFhMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpT2P30CjOSKJn30y6piKUfQWd2+tFnDASnnmqM/g1N+eu\nLC3+/zViXcHl3UbOKcI4LRe88ZyVgmnX9pwP6L+No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0d0E4NjW4Uxr/BFiFAjVm0Nm\n8CIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOXPZtzk5IRMCu5tI+viopmSDHCxr95FqzscF740kqvgCIQCFmbdYqkEe\n8lIR8VBAZKsQcMplgaNCEA5cCG/I2R2uhg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAaN8/M4ACEbW/TLUTSChtCLqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI2MDQwNDEtNDExZi00OGU2LTk2YTQtY2RhNTAzMmIzYTNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGY4ZWVmMjItYmQ4OC00\nOWQ4LWEyZWEtNDdkMDVlMzFjZDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBuCcGCU2aIaBwt00p8Iyh0aCOjtuS3XECnwuIQm01AAA9gav3IXiwNJbT5guXCrm\naRGJiAMGWViKa6UQNMmnp6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtsVOuVA6WeToZPDL\nQQFvvv8V8rIwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA+Jov\nOWhsDnaDnbivJzCHZ/IrP9qzmfkqLBMpNzxqXqQCIQD/WNAenkKr4roO5Uu0HHrY\nyODTOodsylwMD4F3DPD8tA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8258", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8258` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAYCKOAkLV9YPM0+7Ukr8maAgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwMjdkYThlLTNmZjktNGIwYi04YmExLWRmNDg3NDlmOTY2ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U3NzQyNmItZGQ4\nNi00ZjdkLTg0ZjAtMDAwYjEzYWQ5Yzc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZjnPtq5syTkHLKCoErsADAR1Ne6D+B6o5UYU7YkOTXPqw6gt3rrdn7/EYYQ7\nhDgwbssr4tzjAlO2mTuTCkavd6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyHI29JPOUE2PtmJjxAc7fWe4lvwwHwYDVR0j\nBBgwFoAUIip5Ofm7rMxUiExleke/ybIp4O4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCUwJepqoMxy049rf+ymBKi8Sea2QB1\nHtc8JnZ0fDT9ggIhAIEQtPD6JZffD3D7srUeXOsNlqCSEwA8PFoaEXOKKq4G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc1o5Wp9PCkrsu46bpdjkaXcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDI3ZGE4ZS0zZmY5LTRiMGItOGJhMS1kZjQ4NzQ5Zjk2NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7l48LNBdkvCM1Rg5sY4e2/IfSB1lR0B1185vI33lc/k17\ncDrj1dJCvDcL+1RiFQNpkQMLtfyChV6PYAcoF4auo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIip5Ofm7rMxUiExleke/ybIp\n4O4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJEEjBawaciS60sZTPEA2qyy0HnsN2Q/iqaEVIIN4wOSAiEA8PBR+sFH\nlxxzVQxMc3YiTnpTpXbd3FNGgWGcWfLkd00=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAYfeYeVGmZMERlAN2b6mlyXpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U3NzQyNmItZGQ4Ni00ZjdkLTg0ZjAtMDAwYjEzYWQ5Yzc0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzEzMzUxNmEtNGUwYy00\nYzdjLWJkODgtM2YwZGYzZmY3Y2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXdQtI65QBkXM9nmQaUw7lZCqdW81TN5mwF+4gOhS9jT2tF6NcjFUYSJuWJn3flpn\nWr2GBGln4aElCF/THwVxPaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyHI29JPOUE2PtmJj\nxAc7fWe4lvwwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAiKUf\np7GhMR3SByGgoGsBcZLdAhtlrDLqmv9KVnnZioQCIGl91CQAh1GmAFeeYWoHtCWU\nm1EaFzESxv//XMw9wmYy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8259", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8259` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATTkLxoVnpMSb16omjlFKRWKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYjM0NzYyLTkzZmYtNDhmYy1iMDY4LWFmNDIzMzVkNTI0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODMxMTkxMGMtMzRi\nMC00Njk3LTk4NWEtNzVlOTJjMGQ2YTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEixSpnu8BzrnCxGnn6TEMxppQhv79OWvy7EYBs6aTdc8PzZ5tj9M5R5dQ/3Sx\nbt5lb/7h2vFqfIpITdBRvtmSmKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXSUnZJPkmJ4UTJoUzRccWne9m5gwHwYDVR0j\nBBgwFoAUJgkhRlPFUy2zQWILznm6mB/kDAIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDOc8YMle+kTZQy24NxRs3Aaa8Ygc9+Q\nCoGfCsQQS05DAiEAigNfPNNqRIJne0D1C4RReMa9aQwk46Gl2NKu9mo5PBk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdlZVi2ZArWgoITC9nbmh7CyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmIzNDc2Mi05M2ZmLTQ4ZmMtYjA2OC1hZjQyMzM1ZDUyNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ9FyMSztbsRaO0S1m7z4Y7ey/AnERZHd7HCrFX++Ee6IQv\nBEnIL0itTdg3K8Vc3Ej107xw3WB2AZQtWbpNLg7Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJgkhRlPFUy2zQWILznm6mB/k\nDAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEKVAVH0Ar2s/sLDWQZu/cdA9oA1ly1DaQDD6wRkh6SUCIDPHiRu+s6zj\nfYUdTWEqLC6nKrXSMugAfSOWvV39DCn2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAUY+FakYcW7PL7sCEZUSUHPHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODMxMTkxMGMtMzRiMC00Njk3LTk4NWEtNzVlOTJjMGQ2YTU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGY2YWQ1NGEtODU1Yy00\nMjVjLWI1MzktZWM5NmQ4ZjNlYjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9JNts477PgfkvmxiVb9aNWhnOUNp6Ui72ZKCVRqztc+DicB5fJveDfwykNgfvR2C\nWxxkUb2joW6v48pTz6LvhaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXSUnZJPkmJ4UTJoU\nzRccWne9m5gwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAzN0lL\n2aApRJpHxtVjHsKOq0eeu8yxtqcqcNlc7rK2OgIgfjWHTlB7qg1oOXD8olG1265m\nhmReg/OC3oCzQIaPkBo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8260", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8260` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAagYgCigQ9zE65ra03QWYTeCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyMmI1NTg2LTAxMzItNDZiNy1iYmIzLTFjOThkYmYwMmFmODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQzZGY1ZTAtZmI2\nNS00ZGVlLWFjNWYtNTg1YjFiNGU5OTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtvCI0QXpOibkLlrtqq4d8m9QNkRYX/ACuTfqY/Zpk88SnMk1PgTfIDLzfQmU\n6UKZZHQysunlROdLIRw33YfgjqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+JJMt+pDA9CM2wNzP5X4Ecs0+PMwHwYDVR0j\nBBgwFoAU5UaAJLxT1/C0mQpyGL2v7SDeck8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCPq1pezSKt\njVOCqW78bS72Jch7/aC0K2w8k5GO3zaJOAIhAM7Gz4OB7O7c0vo3Ahm3GfpIMonm\nTvMY3y7R3Mvu5EKQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc94XzP44xs7h7LNbk+YyXckMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjJiNTU4Ni0wMTMyLTQ2YjctYmJiMy0xYzk4ZGJmMDJhZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7cs0GzwkBVh+XXNM5IyXUg6fflpcOLNN4HSp84CiULKfL\na3+5XN3eJvHePMdq9c7W9wBkV6Q3n495GtTAAuGco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5UaAJLxT1/C0mQpyGL2v7SDe\nck8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG9m4w/UG3do2bDniwW03N8H4wPyMW+91sgftkyjRVg0CIHzVzOAj1qah\nnqzZgNlZUd8V66R4scHVGwgfmLpuNlpM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAXQnN8Rh/FDvykCm7ZDG1xTTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQzZGY1ZTAtZmI2NS00ZGVlLWFjNWYtNTg1YjFiNGU5OTY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODk2MjBlNDQtYTJlNi00\nNzJjLTg3YmYtNjQ5MjIzODUyNDNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6XChjlRtKCgayOdtFN03timoAnTlGaZTFHnvw6UiuIxNfY/Y2MBteRZVsfL/Ej1s\nmFARmskusW/B/CiDaE/ojKNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+JJMt+pDA9CM2wNz\nP5X4Ecs0+PMwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA38ex\nzpO3fyPylL937Nutx31QA0dEe727LEASDGXfcDMCIQCRj0T06C9hQwfNhGyP39E7\naCYXCOvDUkiT5vcPNsH8yg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8261", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8261` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQIYrFa14Uurwz+cuJB94yV+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmNzc1MDViLWM4MzUtNDJhOS04YzNmLTUwMzAwN2RiNDE2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY0NDlhMzMtMmFi\nMi00YzllLTkzZjYtN2FmYzQwNWRlOGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEojkADuc0iLrxERjseXvDsvugIKQAA6Vphv9emQDVBm1w/DJ2tbm2XHI9/QN\nupSzHWxb8sOSYaTtiWLIxVCwm6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTL0NkUMnfwaRWpepiRd0vja6sD8wHwYDVR0j\nBBgwFoAU8rvDgHh6CtX2qhQRKBoqlNaHUiswNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIM3t3MJOD986ZAMP8wKnZ4/UtwqtHhyg6OlBNT8grgIAiEA59QENlXZ\nLes+ISHvttUXYB+59a4rxJ5CSmgwfYYnV60=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXu1kR/Y1dR4y7j50tUT356LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjc3NTA1Yi1jODM1LTQyYTktOGMzZi01MDMwMDdkYjQxNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJTa0/0mYp+0AoV28LGWcd/yM1anYmqg47ZSraXvSWAJ9e\nrTFWUfTTkDaSUs+ja49CreXqkFvmzW+nnWbJM4NCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8rvDgHh6CtX2qhQRKBoqlNaH\nUiswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaXJLGjdpWN9gv3FfZWhErnORbowW1WnkX+tVl8bZEXkCIHn5JyQ7sRFs\nMwg+eLEKhJZJ3s4Zz9822YO7p2VJH7Q5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAfkwjL9U9ppbeZAjAmXtcsI9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY0NDlhMzMtMmFiMi00YzllLTkzZjYtN2FmYzQwNWRlOGE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTVhYjM0ZTMtZmIyMS00\nNDlhLWE0YWEtYTljZmM0Njk3YjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkd+YzQV3XbMU44Wogk0gae/OWLMGJ2B6dMBKp+YaL4vnQuL6gEzP1m1t+e8hPfgf\nv2NwVN18IuMZq3iwG8Yn36NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTL0NkUMnfwaRWpep\niRd0vja6sD8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiA2CktX\nhQFgNeOp5LVL7lZ5hMT1o4J5W7+BvQrLEsvEeAIhALKjhPa0dSv2JpVjJKWpY1ni\niQXpvOoBPFIbnpSEiAYz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8262", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8262` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAQvbZfQDdDQNJbKOLTqarrYRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MDZjYTRiLTE3YzItNGQyNi05NDI4LWMyM2ExOTEwZmM3ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJlYjhkZGQtYTc0\nNS00MmMwLWFhNWMtMWRiOTg5YmNlMjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKKaUtfLP0t6aVI7z9gqTkKafWp7//qMsfGoYwdpTP8jiF9L2tNdhgDXjjQcj\nqVWqDdkbxeO3UiU516BQn7yDz6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd/PECpSi5CbyNCd1bJAm0Loxhu4wHwYDVR0j\nBBgwFoAUft0mzZZMmJj/KQxHUHWU0U7ExmwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAK6JdkFfVN6mMPnifRhXPvDCQ6BzHGI/Nb7OiDZtPWwKAiEAyWzzWpyq\nhojQdXRon98VhezDjP7kxWHQ0s5yVjMawKM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQYWkNw9bMdgEbWTKRPuaQNXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDA2Y2E0Yi0xN2MyLTRkMjYtOTQyOC1jMjNhMTkxMGZjN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARDy7tVhYZPgyXmxF3jm5jjT6XS6LRwuts3oTO1suoRfYnb\nuNy+kUwHKXRC/aBpCei9QJT41HKK51ECY4aG+Gbdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUft0mzZZMmJj/KQxHUHWU0U7E\nxmwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCOOdhDIlemeCeFJnz3yFHKyUCad40YVJbghPot9whqECIAj+2Cqqxr01\ncKYT/eADfbFShGkcDcIx0r0q1Ii2zeoP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISATMpskB1i2CgXOaRwcPPrMJaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJlYjhkZGQtYTc0NS00MmMwLWFhNWMtMWRiOTg5YmNlMjkwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWFiNzkxYTItOTlmMi00\nODJmLWFkZDQtZWM0MGU1MzcwNTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfoWKp8gfnwKeh4Mh2aqm5h11CTorLcS8R83MtFqrnMVtkJLtw635QxeADTePHBe5\n0OTRvgp+Tgq6LTCukiwqQaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUd/PECpSi5CbyNCd1\nbJAm0Loxhu4wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAc3mFl\nI2ed9PlP6UngPynN/oosyE51/vmUnxz+kQlmTwIgbWj9SgTvYAacq3/8Vo13cnaI\nh7zsmcabszB5CSY5FGk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8263", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8263` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAUeHzAU+tM7SVmyYaGF1zDzdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkYjg4MjBlLTg2ZTItNGUzNi1hMzY2LTk1MTJhODAyZDNhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWFhMzFmMTEtMTQz\nYS00YWZkLWI1Y2QtMGJmODEzZDY4ZmJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa4xUvzSJzqgxONmmNpS677okPH3GjnKrxndIwya7sxBXF/Kduc/BStQH2xVg\nnLAgTRtXs3pmzpkpaUnU5TpKC6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFy+phYz2IbCOux8iv5qaad2dnR0wHwYDVR0j\nBBgwFoAUZ+CJFmajw4aW5zOWdO/eneXuHHswOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCPyEn5ot92Fb7mTZohVp/lnKf9xjwQLdFzNyJjww5d6gIgUT/Pphn3\nrKTLYl0ndG4mQHaOQt4oM5o1K56Pj1wmgj4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVzJSoESBFmU5Q5hyzTXHImFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGI4ODIwZS04NmUyLTRlMzYtYTM2Ni05NTEyYTgwMmQzYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHvGIi3wvTLv362m+A+DlEIH1i8RnhOkKZ8OMm+vw/79Pj\nuBLqc9eOHhgIPOrsXB9HMXuaDatOSGlDlI/tEBTdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ+CJFmajw4aW5zOWdO/eneXu\nHHswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALEoINcT0dTHb533o4D1FVE/ND2UrXTvlfLa6FS+fpzTAiBSVmqu5hh4\nEeWR6bFsusK6QxBBJNckpxkafLGsEGfHQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAYP3cYvj1xB0DOlJS3vKEXpxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWFhMzFmMTEtMTQzYS00YWZkLWI1Y2QtMGJmODEzZDY4ZmJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGIwZjkzNDctYzJkZC00\nZTczLThlMmEtOTA4YTM5NzY5NTIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvf2+Z0D+4XjJC8RkVeIvDdd3z12oKKEuU+Ac5AGXAmOJWg/A9iHAaB9XSx6tN/dF\nRKLzKkJoideexeWnW5GGJaNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFy+phYz2IbCOux8i\nv5qaad2dnR0wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAxuYeo\ny3Y9OSJIB1F3ivSUQnsLYxG3ymWcQTCCkEmoeQIgax92B/J7IBjuqu2vDAqMqELD\nArehwSso5hzMVLWAW8M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8264", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8264` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAW8wL15JGpibHmxEHOwoIV8iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyN2Q4ODdlLWIxNmEtNDdhMC1hMWVjLWUyN2IzMmZlMjViZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhjZTNhMDQtMWMx\nYy00ZDk4LWFmMzItMjg5NWFhNTBhYTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbyDx/2xYplxiLhncOY/NUToI4mccnNs3N9to1meyOKPTumVj+QNUTgMzfUIn\nSnEQf/iC+D/JZz1yHa9L8yTiRKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2OksbLxq/zsdkxTBUtoFFjutxh8wHwYDVR0j\nBBgwFoAUc0OrSc9uS73EHpGgUX3A3OyNjdUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCICD9/4sjcjkMchlRb7OwTr9haps3cJl/Q/OJoF8F\nZXlGAiEA9/qZeAvhUs4lv832xylOuaikDRCVI/O53pf1yahTX38=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcHjKWM7Lme/iWa2dHX41En4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjdkODg3ZS1iMTZhLTQ3YTAtYTFlYy1lMjdiMzJmZTI1YmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPzNqYk5aGQw2/gUvU2Gf9tFd+WI6FltDNWb79oJ4ARR1s\ndJ3cYsSvc7yjHtn7ub20XpQbYDZoqlwsBuMqOiXCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc0OrSc9uS73EHpGgUX3A3OyN\njdUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP6VX+1a5O/a2/66h/JQWg8TTvse/sPblKxkhSQXoc/sCIGDD+pkVGP6G\n24yx0egTQisS8A4bmGTZ7QgulctPHlYd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISAdxJSI3NQ8OQXE5qFzdtIAUSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhjZTNhMDQtMWMxYy00ZDk4LWFmMzItMjg5NWFhNTBhYTZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzU5MDkyNWQtOWQ0MC00\nZTMyLWI4N2QtNzJkMmNlNzFhNGE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndsmoMsPFCYEwysjmd/EgoCmZXe0F3ZWAmGi8FoCNOpRyAtV1Q3VdQ4qI918eaag3\nhxu6VthAM28zkvQFqbzkV6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2OksbLxq/zsdkxTB\nUtoFFjutxh8wDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEAgyRL\nvjF7yduyI51+9AIjB0PhOhGTciwLUUP4HZlpM2gCIQDgQp0VL/l5Z322UEUfpire\nwjXrrTssebsoWHl3NV5iHQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8265", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8265` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAaEaR7FBN+1IPYkJiq0PowRvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0M2JlNzVkLTUwZGUtNDI0YS05NmUwLTc2NTIxM2FiMzFhNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNlMjk2OTMtMjNj\nZS00YjMxLWIyNzItODBkY2ZmZWEwYWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5EcMSaJeuZm6Qxrx2LL2JM8d8RTSiBVjZzGq12iwnzi2OfCREGjExI4mI1dR\nbZ8ujapKRiOjPDNAO65XfCT2hqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWxHKlhM6YaN5CLfdJSb6RCityOUwHwYDVR0j\nBBgwFoAUDIST+h5wSpuc77V8jA/OGDzR5sgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDlPNqwLkh5L95P2SqrGPHGrGcfXu6jrCbjlTXw\n7GlxBAIhAL3pVGV7vxuRUj/M/2RShcyi0J6np1V8rxGvnLmzHury\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT3Q1/Pr57Fx19Gxq6eOKbMGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDNiZTc1ZC01MGRlLTQyNGEtOTZlMC03NjUyMTNhYjMxYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH9R2Wme0LZ9sVnLLIt1YV9ekVSgaE8Egw8DSHBnumjQuJ\nffImqp7aQiQPU0EHRr99pD9hRI1Nc5PuoEL3IEITo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDIST+h5wSpuc77V8jA/OGDzR\n5sgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI5s1hF6D5kGeDt8FcyzHN5mFX47m0AmkfZcR39ZiDGIAiBoxmkk7ovd\nGOu0jdtI3GuxfD3fBLkvHtZeXqsSRrBGig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISARiMKTSL8oc2LkusF/Wr/TByMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNlMjk2OTMtMjNjZS00YjMxLWIyNzItODBkY2ZmZWEwYWFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzBhY2I4MWQtZTMzYS00\nMzFmLWIwNWYtYzM2MTVhODhhYTA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntIDUGUzRKCupUNylHqRlSqvt/B/D9HXabzbwadgaYHZoFJmO3ra4ZlI3LroOHNd6\nFHcR+VS30v2HiteCEL5046NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWxHKlhM6YaN5CLfd\nJSb6RCityOUwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiBGnTyA\niMjY3GFRwmaYSU3PZygP+Bl/ZNCXOeciHXN+1gIhAI1prNh2bdfgjxEpFh6REAHW\nSsyMlzEwSTq24gr06YD5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8266", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8266` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAcKNDkh8JLpYKl8+YfpqloteMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0ZWM0NzkxLTA1NjQtNDc0NS1hNGVkLTMxMmEyZDNkN2QwZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQ3OWM3NDktOWM0\nMy00ODY3LTliNzctMDY4MTNjNzExZjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPzK/eiqbpycP93HWluYmn9LT/Ec1B0roChsW9aYf6j2mRwexx/9djTvo4kl1\nhKAYeI6aN0EJHILs7q/RkX5nPqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKW6pF+gJycQi1YtU2ZUnLrYxTVowHwYDVR0j\nBBgwFoAUNEWloDRaPazh+5d6BFXmsO4ledgwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIEyrXpKLX1wODpnOEQ+UF98s02DaofmYrR0gKi1wVTKpAiBm\nFu5ZPNEFYVgLraamaWg4LGFzSAk4AANxs5sY10eq3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASzNrmmkYMGc8VvuYaeIGk0SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGVjNDc5MS0wNTY0LTQ3NDUtYTRlZC0zMTJhMmQzZDdkMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR56ckTXPZYGN5aFiy8jI1mv1I3NFZOnk1uupIP6NC/kJi\nVBbC5lhSLOrRxdbVI+jMZl0HnPGotC6hJlgHC4l4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNEWloDRaPazh+5d6BFXmsO4l\nedgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOF0R/yyLJ95uAd9a3cDxtkf9D6H02o9PnKJRlV+181TAiBx3AHp0agU\nClJCYycS7qQOL112RLszYyzhKPwBs/FJOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISATa81oy7IWmVU0Yf0G864FX8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQ3OWM3NDktOWM0My00ODY3LTliNzctMDY4MTNjNzExZjI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Y0N2ZmNmMtNWExNC00\nNTM2LWFiMTktZTQyOTAzMTY2ODRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nv9DFFXXKGbEEoemLXUbyZzYcG9he8QqlH+0SOmreZKYQKRNgPTxJlklNoR8cuO9Z\n0+6M2Aqcl9ptvafbgPwey6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKW6pF+gJycQi1YtU\n2ZUnLrYxTVowDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNHADBEAiAdBvsY\n4v38d1ZROJz8+BRLAEPNiIi01By45NRvQU6unQIgUMz8IWEQlJE5+JHHhAest4Bv\nx1/HCbo8Y0TZLlC8qv8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8267", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8267` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAZIQwfbQvdNXgPLyWe8xxFNtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlZDYwYzI2LTY1NzYtNDZhMC04OGUwLTYzZTJiODAxODVhMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzM3ZDM0ZGQtN2Nj\nYi00ZmNhLWJmYTgtZTI1NTBlNDc1ODNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7xQmGWHqvXX3c2QAkETkOs4VEXgsxqwYXE4EliSQHF80cWxeH5kituor9rva\nu8u56LK2aC6Tb8OzDY7U1GDPXqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWdwJT4UrOrKztjhFwHkSYfOcTngwHwYDVR0j\nBBgwFoAUTLUFQ39ssq0inMldyLb7+O3kPgMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIHNfEjzrJRXb1mQuhYvVi95GuZteLAIb\npEQ2b8+opmskAiBe6RwlllO8WXObjQub/BzCxtByTexM0WdoaJ7ERTOmsQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASdvdPPAGGW655esqZ/ov04UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWQ2MGMyNi02NTc2LTQ2YTAtODhlMC02M2UyYjgwMTg1YTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq+lqVKFvjk+XAmZ95VXFYgz7140+cEDtP4YfKFuEuUtmH\noLwteD049wBIsuBFRyOKJmy2Jv8rnj3wB8N+VyZyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTLUFQ39ssq0inMldyLb7+O3k\nPgMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT56hRzNK920VOz+qC/8kRPVKA2vHp5YV6Jq9vBqg8cUCIHG5HoM6KZvp\n8/22vKyQK770xo+aaUIUErr6H1L702Ro\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAUJcL7YOOcTyNdxoT2Je+/V7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzM3ZDM0ZGQtN2NjYi00ZmNhLWJmYTgtZTI1NTBlNDc1ODNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTU4YzRhMjYtNDAyMC00\nMmNhLWEwYTQtMGVkYzEzNjdjNTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6gUuqlmWM2ML3l38mdQ/UJOmy+57MFMdjvQVa1apf9eu+V5AdXBtbTArpQio90M5\nXlTKFFAEQ1CeyLZMUZel9qNnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWdwJT4UrOrKztjhF\nwHkSYfOcTngwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNIADBFAiEAkBCR\nUzDm4PTN4x+D2ApfdUob4vE7iFDOrIYETarCAyUCIBunYQOF1tFsaLT9kcax0wB4\nxbOSdnnl6KQ6rlsVpa+u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8268", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8268` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAbEhCCxoyHac7cRM3xEl7858MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ZDMzYWE4LWQ5NWYtNGFhYi05OTZmLTM2MWU0ZTNlYTFkNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQ0MTAxMTItNTdh\nMS00ODRhLWE4ZjItZjIxYzA3ZWIxZTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPPpTt63n8VrtnyXYtzUtW82U09MOCTAs27PP/rYTrv6yCSlhnceVDmXQhXsG\nMeUz978ElbmSO1wpkE4gm6mBLqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD8EOkMeMjK7kkuM/fM7fxxAQyiQwHwYDVR0j\nBBgwFoAUJfKC/MLQjzE5n1TRcLIf5Ow1snIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC6wOrUOOgZ0RSraEsBQD52amOv57VS\nGFROpWHIiazKrwIhAJeB+8KM9HOMWJND005eghmUjINGgjpOXY5q7D7a8SRM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdoCuRNprG7n5kvC7aLP/dO9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGQzM2FhOC1kOTVmLTRhYWItOTk2Zi0zNjFlNGUzZWExZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8uSIdgFXZMbwdALRGrIWlKyNCWYhJ1xg2M/VW3gqTnT7I\nVk2M6WIQMrdeRzt4a6oChnt63FVHq96zXZQFuGzAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJfKC/MLQjzE5n1TRcLIf5Ow1\nsnIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgenwGRRfsxhExhyGb7GX+u0PLDE/mChWSyasO1PvdgsACIAeoeIxVpQ6E\nHYTIJimLP8mqwE8HfGkiQQ5iGICVOi0F\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICHDCCAcGgAwIBAgISARwosuoFHgEiyNcyMqxxS3rdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQ0MTAxMTItNTdhMS00ODRhLWE4ZjItZjIxYzA3ZWIxZTM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjUxYjcyZmQtYWU3Ni00\nZWUwLTlhNmEtMzE3MmMyMjMxODJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nK3WIlpW5ZC+8ESdTcFyUhKeepWFV7i47dTzeJbPk3yXmzwHE3MdTHuspKquGoC8d\nhTf/O0dOiXxAiFnYppmjE6NnMGUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUD8EOkMeMjK7kkuM/\nfM7fxxAQyiQwDwYDVR0RBAgwBocEAQEBATAKBggqhkjOPQQDAgNJADBGAiEA/zhV\n/GPfBQPVknAEtQyEABC7En5g33X28k3pUkbr2EMCIQCGrbFbDF4JJ9airziQ9CcT\nDHiyy9k22U6MVpEJTW6GVw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8269", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8269` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAQR6vZt3+DD8tqDNDRAEs8HLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyODI4ZTFjLTZmN2ItNGE4ZC1hMjgyLWVmOTFlMjU3NTQyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWMwNWMwNGEtMzBm\nMi00MmFkLTkzYTgtMWRhMzllZDNmOGZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0c0VcXdvCr2sh564Zb5LflBMDuH2dpefdou95+SP4fyu0SG03V9pz1wlrJya\n7yhCO/F+N9NyUJdmzVgiDu1kq6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMZdTXeyh4K2QwVsIxrHC1Ydlb7pMB8GA1UdIwQY\nMBaAFP1+8dwuZPffKmeF9xNhYFpakZi8MAoGCCqGSM49BAMCA0gAMEUCIQDkstBi\nhPYx4VR0nRZUQbYI7/YysEEfm2m3XSau9XJePQIgVTnpN0oLU4XXWEKj7LNrOYkO\nRF0RSxBU+T5kkgQ8Mzs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARvMzTwkn7RiJXKN2kGJ8OSoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjgyOGUxYy02ZjdiLTRhOGQtYTI4Mi1lZjkxZTI1NzU0MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHRkrJHby6bXmYQYi7jcWi7Srz9tVb1Wvp9kewH1t54vkx\nyZW2asxmGN+Z+LBkMWidivDbEDeP/j3rdKpi19SJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/X7x3C5k998qZ4X3E2FgWlqR\nmLwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALsdfDZp87C7LtKuLveWvFG2ACEnVheC+RFXwpWqj8AVAiArGoaFDDhk\nYyJx8IufzSMx2ZdnvKS+3kZpjI9ChbkucQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAafFjuZDGT67y/2gK1DoTej5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWMwNWMwNGEtMzBmMi00MmFkLTkzYTgtMWRhMzllZDNmOGZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTAzNWFjOTAtZWQ0NC00\nMWZkLTkzM2ItNmFhMmYzOTJkNDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ns1xivM1mnO+F5D9icIRfaF4hi9HsicwaERGv9pFbF6Eci7iCi32ohKHx9iAENr7H\n+/DG87LXeRPhO9RfCK2iV6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxl1Nd7KHgrZDBWwj\nGscLVh2VvukwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgMT18ZFurQypq6fWUD9Sf0AbxFeFte8HjU47bbVQ4XNwCIQC4L8VfEE2z\nAheRLfeRPjqktDW3GZllG7jI6YXya5yDCw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8270", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8270` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAXBqo//MXsQsAhnbqGj0/tYLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxNDNjNDg5LTQ3ZDYtNGEyZC1hOTUyLTMwNTMxNjFiM2E3YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQyNDdiZmYtMTlk\nMi00ZmJiLWIyNTctZGQ0MDI4ZjkxNmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoHfJraZKVqqQfdBq3+dt9ROxjKWDp2bEAQ/J9jjeKSDx97n15+ZJzq6HD8vJ\n3JIPzEO+iTAYh4KlJ+h8Me9LrqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMnU9M+idkhrRNIqUVYsDzcQQrFDMB8GA1UdIwQY\nMBaAFN/52PdsG33z/P9K9GijRfF2mHPFMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAUaFaJ5qWOUwVmt5gxJT9eLcX+c7RxirX/\nmmiUt8CbcgIgbnMCLNGleVy6oL/lcCUKWnvETvrQWCfA+BpztZOhjUo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAebUoLjLk5QojsDEr1ddMvXbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMTQzYzQ4OS00N2Q2LTRhMmQtYTk1Mi0zMDUzMTYxYjNhN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJLcoMWGHu/S2G2CvdaVQKDVYYhmEhrrTHME7ZhMQnifj6\nPgdrtONfRW2471f7X58nzB/7f4eU3Fz7XggE3f9io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3/nY92wbffP8/0r0aKNF8XaY\nc8UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPYkUfFpBTpYUwFfYhcb3b2xys7osbwODxp5/d2sGyQSAiEA/54Zpcuf\nRlS/H7Z/DCnjRKpc6GWV4B+VIoJKL/RATO8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXzc+agOfPgUGLQvHHf9EtuLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQyNDdiZmYtMTlkMi00ZmJiLWIyNTctZGQ0MDI4ZjkxNmIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2UwOGM2YTgtNmYwOC00\nZjRmLWJjMDktMjU0NTE2ZTEzZWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfFuBRti0GYewjc4RTLh0HckPGooSfNaH19MUDeEuYAYZ1KmZKf4IOZBRLMOXjPgI\n+whd20dpSI1xDeHJ/JkI1qNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUydT0z6J2SGtE0ipR\nViwPNxBCsUMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgMz26Awhrbq8tc14/U9fSHyoowI7ouPpfMlVz0X6+3HQCIQDjdJOY7JtM\ngbKQ4AXvrd7JrV/fmtvf6VgKbYhmbv7rWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8271", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8271` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAd/gY/WLXU0TnFBnhr3NbXZDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMDkyMjBiLTUxNmEtNDViNy04NTU1LTlhYjI0NDE2MjM3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQ3ZDgwZDgtMWY5\nNC00MTk1LWI5MDktMTI0MGViY2ZlNzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdyWrh6U0FMRDthKxYFvf5Px7mj2dLrSIa9Bv6t8Za+KEZrctWI3h+ziRDGry\neyXontdnYy3bREHKGjSu0O/32qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLuyb41j2mpXfkIuILoP8+IDiaB1MB8GA1UdIwQY\nMBaAFGUkduL879iW2dmWAdnkVEH+jSvKMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAF1VD89rkkFxMIB9OGvOmz9taL81JFZUqr\npzecmmzrXAIgXB3PdRaAXXB0XCJ3lwsyEpjfwn6wJu9Vek6mG7sbfYg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASc2UrHXr+IUFPZv/87WHZsOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzA5MjIwYi01MTZhLTQ1YjctODU1NS05YWIyNDQxNjIzNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS86bRNic+tLiX83dr2gjyxTSX+3+OXeMwaGBq24ZN0qD5L\ndWbuXyBNsQfZS/IUxcOy4MhOm0WdpNtZdc/ho1pJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZSR24vzv2JbZ2ZYB2eRUQf6N\nK8owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgf0h4nv1Ls5fAXEp6KnTXj/1PMBNLQWxpXqd5ayPX4G0CIQDuE9OuPrXU\n8ujF7ghQh8fQ7TkVnh0ar3mWok+RzJNZCA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXAk9gABD2MtwpFvacLA8w1HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQ3ZDgwZDgtMWY5NC00MTk1LWI5MDktMTI0MGViY2ZlNzJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzU1MDBmMjYtZTZmMi00\nNDkyLWEwYzEtZGJiNzgxNzQ0ZTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/s+bwDKg71eeWP/pf3SxvDfGOmrdlgSnnM3XE7vITBR4zWDmJbfA4gUp66ZpoA3Z\ntYttd8bPRB1urm0jkrqSYaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUu7JvjWPaald+Qi4g\nug/z4gOJoHUwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgJaT7OBKZZNevTqdyFokPakNLsvs1Pyfl1K1gjjx2r1cCIQD6dUed6ul4\nDouOdbrJoK5gzCNG5rPB5FGsrBRRLgylBw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8272", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8272` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYW+KfcnZDipRnUh/olMyXhfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwYzg2NDJkLTllNWEtNDFlOS1hMzAxLWI5ODk5MTU5MTAyYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDNlYTUzYjctOWNi\nZS00OGMzLTg0MWUtNWMzZDk5NzkyZjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyeHnfVdLuSuNS+tBss4TXJPHu7RXP4Rthej6HutZoXECY94ulttTCSu/bS94\nbtFK0VxCYORgk2pAVyvDlU0idaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTR0IWvSOIsgRB/sZLgQ2ZWKRc30DAfBgNVHSME\nGDAWgBRu2hXGHJkXUJhH85IHmFzDcNP3djAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCzTtnaC7X8KJnC8TbYI4foTagb7CYP\nINTEf+PkXwEJaAIgB1LFYDLNE8XrLvpn3wzoVeFFaA3SW0gHIz1X3iRVjas=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa/viWZoJ/BUKadXU3cadyBDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGM4NjQyZC05ZTVhLTQxZTktYTMwMS1iOTg5OTE1OTEwMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATi8e1SGsLLmilrC2CAnuZTXs0A7xjZhEI1HZpJ9nM8OW9H\npNncBM6Upd6xRbPPn6hJRz0XXD40G9OT2CwuS2Tao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbtoVxhyZF1CYR/OSB5hcw3DT\n93YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJS6Nq50K9kMJrYXOKQ01oYoM87qy1ktkk3+l1LHrLQKAiB+moVb2Vby\nhltExzNqTnEH0037vrRlN1zUXgJMvGp8lg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASnZ8UHa+gqFoUnP+uAn594LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDNlYTUzYjctOWNiZS00OGMzLTg0MWUtNWMzZDk5NzkyZjNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTQwYThjM2YtNWQ1Ni00\nOTdjLTlkYmMtY2NiODhhNjQwY2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbNV8Pzvmh4x+qJC9pWxBZ+fj9egltabskBxi6mU7BwkJCLX+gYss7UcFuBNEdwKE\ntyDdfOKnmyw64nVOHmpDPqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0dCFr0jiLIEQf7GS\n4ENmVikXN9AwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgdzxusmRAoCry4LNgh6zU3O5XRW4veG6Ul1m4mAJw6a4CIQCFxit7Gjvw\nZdGv7XAK7AYgbY3bM708UOIqEbORWvdNBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8273", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8273` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAYR6Qm0JUWP33lg4GDkvgyXXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZTY2ZGVjLTRiMWEtNDUzNS04ZjM5LWUxMDJkNDhhOWFkZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjY5MWY3YzctYWNm\nYy00OWFiLTkzNGUtYmZkYzc1MzFlN2JhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsWZ8rCgDK4PMCGwk1Zf+LQihDi7hyA0JHqOp4S8t+aUVd3pgweqM+NlIOqf/\nbHmmLxdcTSPpRUXMvx1kxxeb3KOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUacSATIfHFF6Eywd9+jZkWBBY9WswHwYDVR0j\nBBgwFoAUyqkWwAN1zf5wJ6Jvqbkmn6wiPb0wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBibHoFmSuipDPi\n9OChosKPlwlBTF82+Gpb8IjH8cFEZQIhAJiWjdS3/r8wdmI5dTvgbd6MdqnpsO2g\nlVJ3kVCjdr6t\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATY25TpOk8zdWKmdFrWUY+4dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGU2NmRlYy00YjFhLTQ1MzUtOGYzOS1lMTAyZDQ4YTlhZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzqda4c1JGyHUZhNlvxAp/LWdJwxeIY8P93CYfEmS64lfu\n5wZatjcNUaogjTrYmqnCn3LQD0ZMyS1bt6DDpjQao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyqkWwAN1zf5wJ6Jvqbkmn6wi\nPb0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANSMxM+4B+CXKpqW7O6pu4IwM5QZiuCzJy8Bw+5rp/LFAiEAgmHVqzpP\nmzAgA3UlxBRtnBR9UEVcMAUqrn5t587xrFg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARh1qexznpLecdW4qP33RHcPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjY5MWY3YzctYWNmYy00OWFiLTkzNGUtYmZkYzc1MzFlN2JhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjA1MmNmNzAtM2ZkZi00\nNTA1LWIzODYtZTA1M2I3NTc4MDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWEYTgjdDO2MYpjJhK1U5x5T1D5QPR87Rrlz5xksMppiDnzI83ZP98Ndi3cJLkSgC\nC3Y5Az7oUb4yp2kz1GvB+KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUacSATIfHFF6Eywd9\n+jZkWBBY9WswGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgLwHCtedthNeFU/9Eb6Rw96vYyEg12ceQaXU8Ys0mu6MCIQD6d+bCPvga\nVAqGTDnSEmTTFqoEgZh9ynLohOTWPH79bw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8274", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8274` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAZA7E7YlpsPu+5W83eCUXFqTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyN2VlMjk0LTljOTEtNDBhYi05ZDdjLTMwMzY3YTRmOTBmZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQyYTMzMWQtY2Q2\nOC00NzhmLWJkN2ItNDgxNjQ0MGViNjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPY2rGQXVyWh+gm/9ZOUcwRnvA5Xw2zef1lE/47UCEnifzXSNfoSjl6J/x044\n8zoZFE1wNBTcb7ElH2sFnxb/IKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURXGg/mk3Sr4ELAGWv8SKxT57DM0wHwYDVR0j\nBBgwFoAUff6SfoulS7DcEPruunzqIkFL2CwwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA46gqg1/PofvX\nJRFMJiKU2FB/+0GNwaq4XQt8/UWHqFsCIAP0hnRwDJA+Q3u7Kppf04tw99MRpSdy\nVVHz999tEQ+i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdN1XjMxdhr0ykJYnzMCuPsXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjdlZTI5NC05YzkxLTQwYWItOWQ3Yy0zMDM2N2E0ZjkwZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR14/S5oFkv5q5Wa8bGtUH/f0Pv5fByhhoL+GkwaZI7pn25\nEnEqc0Gpjr5Eo8bzLl6nzHcelBrZiUyJYgu+WymVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUff6SfoulS7DcEPruunzqIkFL\n2CwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOqCZKz7yihChJxWGSBZ2e3LkegFsvR1epFuYqm3HYREAiBGI31GvrfZ\nR0Ck8HJBMqSi4TebkeNo3zJKCArSe5W+Yg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXNaKkpypXTjmkOGfWjS2DPPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQyYTMzMWQtY2Q2OC00NzhmLWJkN2ItNDgxNjQ0MGViNjNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmQwNWNlNDktYWQxOC00\nZGViLWE3ODYtZWM0M2RiOTYzYTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUS2/4jJ2iOWoAjfg9U9M++CJHGQFo+Wg5bygaIO5NWYbiIkUp41LrEDj/kr1W/4G\nAvS5znsub9WR/YtWEgvEbaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURXGg/mk3Sr4ELAGW\nv8SKxT57DM0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAN+zyvUx55SNYddhnOviz3jek4ELv6EOPPI70a9MbQGKAiBg1tndXjpn\nwCNd99c4x85rjXhSrGRqZZW83nP2Tv5ojw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8275", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8275` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAXW1T4Eb/A5nHStGbFMxel+EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5MmRmZmIyLTM5YTUtNGE2Yi1hYTY4LWQwZjBiNmU1MWViYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2E3NjRlZjMtNDQ0\nOS00ZmY3LTkwMmMtMTMwYWQ3ZTk2M2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExceTk49oHgeGhEihuvA87agwWE6GGgiFx753blre7HrMuvQLBRVyiNgtJhff\nUuBoh0BepMe6DemB3BL+jlVybKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAa1MTkyx+++JMVD4emyjiMHIgLgwHwYDVR0j\nBBgwFoAUFMZ263b2O77YnGpOLxr91upp7HgwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiA12teBV1XXiPq3vyLfhvrA\ndf4CPcuu6kZXLNNOcTsWjwIhAN6//1wn6eCqq59d5NJV25387dRQdG1jk5JVJ6kP\nF6WT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdnBkokPDjk6fNbWJWpPIHAdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTJkZmZiMi0zOWE1LTRhNmItYWE2OC1kMGYwYjZlNTFlYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNGvt2Pnr0YUEJGzrPWy/YVyPfnOBl3q5qKwqUirsMwNiY\n2MP2rFUJUaHU4mug/dm2h0p1X4nchGMlmHkHUfA/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFMZ263b2O77YnGpOLxr91upp\n7HgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIIxtkvG83LrPDr+6zg7mWsKi4xb1LhRBLpXKSzxB5f4AiEArOBICNJW\nKrOMPtSQfJ7x/hHKfO2Sqj9Uy4so/a9BsaU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaSS3tGBHlk3TBddy9CWlApmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2E3NjRlZjMtNDQ0OS00ZmY3LTkwMmMtMTMwYWQ3ZTk2M2I3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTkzZjk2MDQtYzQ4NS00\nZmRlLWE2YWEtYjI5MTM4OTZjMzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nV2NM2+fe/52c1nE5HM2syQ36WO6QG+ZA9fBsFZWsVZkUAL7kh9u244LupdfNjpgp\nlaXM/LEkDoU9ZlsFis7oo6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAa1MTkyx+++JMVD4\nemyjiMHIgLgwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhALWLJlVuXhvv30/8nJGdk9hSdveaqfzZ+rdfFmjQAN5ZAiBkwVW3+uHm\nfx1ChRgkz/V5zp/u9MvVhp5cdEShnsEvzw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8276", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8276` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAZFmtSGOPpxIUojZTMBuLaC5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiYjc4ODBhLWNmYjctNDM3Mi1iMGJkLTYzYjRhNzMzMDg4YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE5YWVhNGItZjVh\nZC00ZmIyLWI0NTMtYTk1NWRlYTQxYWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/7/L0yv2heVSSPxNO9dSXfNp8FIW5NbtIZwN7FTzXSAJrNa7XylxwxsCONvy\nLniBEMFIH7sDYeLiuuQFz37H2aOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9K2OzAWh1vs2/IVNojmJJWtE67wwHwYDVR0j\nBBgwFoAU495txJ7JgRXdaTX46UsLErHZBp0wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAy++7\nXLRWbC4GxWbEhGWAc+7VCrqG0+U6RIU3ls15rF4CICdv9lJUVleKfUa3ca4nJSKx\n07hnwwmZWPVoQBNQtuOW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWoueKpKs6WxDPjuz2AmEIwjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYmI3ODgwYS1jZmI3LTQzNzItYjBiZC02M2I0YTczMzA4OGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/fU5hZsjL00WJLF6x7t9/dETleLJxFfUKKx1sWoHCHWyP\nSUPiLSZoKj+HFS/EhwZ2MkCtOmrImH6qhdd4Of6Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU495txJ7JgRXdaTX46UsLErHZ\nBp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANcR5F34InQ7yE9OL4Tlg22JEugAw3b3asPSccb2Bit4AiEA60VPHzx2\ngRfq02nqnCPWlljW8eU9UEpK25UfQ/fyNEI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX6LaFqa7AQSM95Aqh6Nxv9kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE5YWVhNGItZjVhZC00ZmIyLWI0NTMtYTk1NWRlYTQxYWFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODJjZDI0ZjAtYmJiNS00\nYjhjLWI3OTYtMTE3NTNjZWI3OTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsCUPiKvdee39+CHXwwbuoTzY3lNW8vZ5c8AqP0E9kXvcEfjEE2Q2+Sm+kxZJRBuu\nby1QK+gDvkDd97lAWMN6ZaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9K2OzAWh1vs2/IVN\nojmJJWtE67wwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAP3kUiDD7fc+5XoS8f0fuXFcqX9AuFUlDK8FjNyuj2ibAiEAiKJpFpUx\naaOW/ltujRXXvFu0gpm2lEy8xc5LrdSO3Bg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8277", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8277` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISATTfLv0JfXnmwkV4ZQ4yZV9lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4NGM5MzVkLWFlMzgtNGVmYy05YjRkLWY5MWE2OWVjYzIxMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTA4NjA5ZWQtNDkz\nOC00MmRkLTg0MTItMGM2MDQ2MTQyNzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmh+YcKC9Vueqo9acLIeiZ6UpdR6nzxDHionDpgXbDrchhovTzV7T2zlT7jDz\n+t+ap+C93SnnNF9pzclLgBLxD6OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPaIfrVqn1JPrW8a7CWk/lErwgRMwHwYDVR0j\nBBgwFoAUUna4VPUoDKxbHMqAvQKWm583vLgwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB0Xl6v\nWQj3/JpcxJnTxV/9CpR7V2np4snYO9TM4J2DRQIhAPGVo7hZjO/73Wi7C3f4ZJ6v\ndQR5fFi7RfNAUoW8x45A\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfWNYoVvlt6DXQsvZWU6v2U3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODRjOTM1ZC1hZTM4LTRlZmMtOWI0ZC1mOTFhNjllY2MyMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6qhay8pFxjPqkRLyUJlWi22/UhepjyqVWVC2ZzgMgMngq\nEFJ1OdlwRzIwBKyG0qMRnBylbrJJPmVrGXOV0CVbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUna4VPUoDKxbHMqAvQKWm583\nvLgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPb+Fidh7AYkXhQjTA/rlSCLj075voGXi5qHe1gGRn0cAiBy2nJhXGbm\nNbvN7TGOtVCY3lS+VGD49OliHM4+BzvPfA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQGmjQ04oRUjWCl0ZeMt5dfZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTA4NjA5ZWQtNDkzOC00MmRkLTg0MTItMGM2MDQ2MTQyNzdlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjQ3NmYxMjEtYWIwMS00\nMTliLTg4MGMtMjRlYTljNTMzZTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nONPHI7sFxH1WpN1bKZ3ncCg7+8C0B8XiuFrp0Xk3VppJhZe6wrMmU09jtkPGXKjx\nlgu/PafkVB8JDs0NL3Al5qNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPaIfrVqn1JPrW8a7\nCWk/lErwgRMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgMSDbOIEB2yk0hN0GfJFLn5JnGV4XE7BjR/71wmifRS4CICv4lItMACq1\nHA0crWNAP0TE1Yhzi1lcUnEdlicjUXbS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8278", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8278` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAUKk5NSCzlNHbDWg9APr7y7oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YjU2YzM3LTUwMzEtNGY5NC05MDg5LWM3NzRlZDY0MmMyMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBiOTNmMDgtMzVj\nYi00MDZjLWJlMmItYmU0ZGU4NWZiM2M2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEliUWOWZsmSlKWL61OoX3fyRkZoCmFtg73uWL58OAa5K+kg4i1hah1zWaJf8x\nDJ/vrEFTFxXip1EXPa1uQBF8dKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNIeE1piGk/uXvhL1tTRLXooQbwDMB8GA1UdIwQY\nMBaAFMgnF+jeBVvlxun52JB+dk2czi9GMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAIAaiKTqwkBjPlln/0wa31lCcQRjQc2JIC\ntGEkIt0L9wIgFuEUyzUuqM9Wix+nEpK92bjqn/TOPnjJv6AQccXC7T8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATnKh83UpF1M7/gFKQ/9eCNoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGI1NmMzNy01MDMxLTRmOTQtOTA4OS1jNzc0ZWQ2NDJjMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUjmSeZJ7CEijIlqlr77mjLGi1tKxMA//cjXHLXoczrNWl\nS0ptxiDib7ZMiQYBgxCUfxY8CzVGZ8LsBkPLOtFXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyCcX6N4FW+XG6fnYkH52TZzO\nL0YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIoA+E3PnB+pqLv3zoaVQ5cUb1Y3WhjqdJJTEbKQ/JPlAiAdNUkFFWW+\nKGrTTc/pKQWuaw7AzNQtc402xt7kP39RAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT1KwTeJ+D5svPKew3tefxqHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBiOTNmMDgtMzVjYi00MDZjLWJlMmItYmU0ZGU4NWZiM2M2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTBmNTU0N2UtYjlhMy00\nMTFiLTk4YmYtZTUxZmJhODc5MWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nY9TjK4Oq2+eMRFNN1ZdILf381hMs+ih+o8eZ1EDL9/Y+LW726/+r9rve0c1OR/W+\nRYsvEj9L0QkAFIgi6UXKJaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0h4TWmIaT+5e+EvW\n1NEteihBvAMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgBBmKdXmsfN8MbhYBPRrRhzbauKUUz3rQaBWo2inObr4CIDL2exmvkObh\nt4XlWjCwWcFVsyoP/a8PWWhy8hp8Jinc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8279", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8279` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAVQRH3r7GF7XY85aw/EqFglHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlMDg1NGUyLTE4ZTMtNGVmNy1hYzVkLTMzMWJhZDljNzdjZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA2ZDdkMDMtNTcy\nOS00MWFjLTkzM2UtOTRmZTA3N2IyZjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsDp7StE1WaniPgJw/yOhOPKvx54Pthv6ZDAJx8yrKXmSguh7Z9PG5nTnxNg9\nuaxANDFBtyVl2sgAOucKlWdNWKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwpQLPBXbiiY86nCOjim4Du+dwwAwHwYDVR0j\nBBgwFoAUKkbN0GdaoyqGWP05e/vDdt5RwqIwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAL6O8Vv7/roC\nCAbY0ViFvxSgR+/dadi15SfIqfHGTAumAiEA9xmnwye3R7vBYIrsreQvD70wm/KV\nlUY9XRP3mtzDM/Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQKa2km0PT+Uqm9k86oOALAyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTA4NTRlMi0xOGUzLTRlZjctYWM1ZC0zMzFiYWQ5Yzc3Y2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQg0ZtNVPG9EcBc2rw/XeD0rl4GhuaCiH26y8xbnloqXYB/\npgDb4ql9oDw499RxAxENzFmsceayeRY3jI8uutzNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKkbN0GdaoyqGWP05e/vDdt5R\nwqIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANEE9hOsno7M2wKa2sIQ1cFLomMHe9Uq7LfDrBViI4u1AiEA14tTPTB3\nfcGT81PzwKiIXs/rF3iEZgY4NlaphUUIq4o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAewmSQeu5ZvLeS4o/9dEmvKrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA2ZDdkMDMtNTcyOS00MWFjLTkzM2UtOTRmZTA3N2IyZjMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Y0NmM3YTItNDZjMy00\nOTBjLWE4MzgtNmUwYzQxMGJlZjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntE6bm9THl5nNyh012NSa9ScPalzZCHSBQVsNyVVAHRrnULDZLz7dflX/iZ9j9ftg\nQ7Q2Dl0FpUhqd9G02CmTK6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwpQLPBXbiiY86nCO\njim4Du+dwwAwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgJaj+k9zI/pFGrmBAZEWv4xRaAy7452J6o0JxV8AJzX8CIQDjaRyzE9QG\nXZ0gw19X/tG5A9JmmXE/ojGaLOpLnTDrJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8280", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8280` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAXw1iwQpA8aQzPVJg37tEqabMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyNjU4M2M2LTk5MDctNDYzMi05MzRhLWE5NzliYWMyNGVlMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA2ZWFmZmQtYTIz\nNC00MzhiLWI0NmMtZGZmMjYyMjhmMTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1GyTZQLYNRc832DhT0PtAW9PcAQqHu1CTJBsp5cj7Jgf2Y9lIEHRkiEXW4G8\n3zqJzCHKWSjnpaS1C+7+oqNe0KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJxWy7Uye0N9IOzA8Lj/LhhjqpxowHwYDVR0j\nBBgwFoAUlKiE3BzrVXe/4+eBf1hNTglFj20wKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgbqh15qyfQQKy\nccXzSXAGgufp7+vqIKuyHvziZXladjgCIDPKZ/KAIDPRfY9R5u+uP9SS7t98IYEF\nEw4g6SDZXdrG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaTXY7rUKgmQHr0jr2tSMUmWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjY1ODNjNi05OTA3LTQ2MzItOTM0YS1hOTc5YmFjMjRlZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLOM080kWr0fe1CIhRSySp/fa7LsbMGem7LaIeAO0h2oKm\nHELvfDiLAXZcR6S2+kll01dcTnFAydiya2xYq2vco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlKiE3BzrVXe/4+eBf1hNTglF\nj20wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQBrNfT1yYxBF9F31AeOJCdr1Y3DzbS9PSk/YlOMzmB8CIF4NXv1j8VdQ\np5v4mJBPT47UQK/5aUovOy/2HmbdCfYG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWA1MTqD/HA4mO2q9WhyROa+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA2ZWFmZmQtYTIzNC00MzhiLWI0NmMtZGZmMjYyMjhmMTg2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDFlNjk2ZTktNDMyNy00\nMTg4LWE5NTYtODNlNGRiYTU0OGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nX50H5FDUe7pysu6XpfNdRpWaCEif4GrafvDz/Wgvi72bBlzcIwFQgAfnRkGv53WG\nlOeOgfYyRTUTd6wXc6B4kKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJxWy7Uye0N9IOzA8\nLj/LhhjqpxowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAPhuD67wYVHzcDYf8q43SMWuSW3GRuoDk+l0sH2SyTkMAiA8V84Eic5o\nlbSpJ20fcOgl/VvWsl+J20ERpYn0w0zEPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8281", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8281` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAbSxQd/3hxYwiLW8Dsg+7TTSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2NzkzYjFmLTIyNjUtNDIyNy1iODBhLTA0OTFkYWMzZTc3MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhiZmU3ZGMtYjky\nNy00Y2JjLWJiNDYtNWNhMTczYjgyNzdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1b5kiv3DqoECVsdjdNRVMUXjR6bb4qNk6+IFc++aOqmv1WCv8yDZkzrBnUjy\nY2vQPXKgES5rZGxwgygWMb1g4aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUguyapOVCUPwMg2p/It2RMQWg3TEwHwYDVR0j\nBBgwFoAUyCOLN1NNhxyhnGMb34CmRsf4GqowKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCRFWyquQAb\n5sDjGAaxdmOv5NRJvvBSFxZ6rbhhs2eOyQIhAIcN3Q1l3GdeU86peqQiRfbUFyfG\nP309+KJVIk4IqzFC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXz0L4rSbagAc68ZQqeQwaYMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjc5M2IxZi0yMjY1LTQyMjctYjgwYS0wNDkxZGFjM2U3NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJbm2/i3x8/pIXAHK9QPHuHWax/pRO/7P6MpA8z9XjuvCO\nddFN3VnPGRK/DMzgCOzy0oa8WM3fsq4yuHy2t+KNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyCOLN1NNhxyhnGMb34CmRsf4\nGqowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKeA7k/iWKL8LfpbBH1qL5PHqLUWobzxZCtAs44WxqwWAiEAnbK8A/nZ\nHCaRJo3AhQ753+GPItsSZPlkj9vvWrn5Pd8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARso5VSLClhiYKY6Ll9QGG+5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhiZmU3ZGMtYjkyNy00Y2JjLWJiNDYtNWNhMTczYjgyNzdjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTJkOWM2YjItZjc4NS00\nODBjLWJkNDEtYjY3OTI4NGY5NjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noZery8zXvT4yL/wOX0pNt7QxqkIVupkh3FHSXEx5u7wNMi9X6b+OFytfDXJcqn5A\nm3IkFVRcemefV3kRPONxI6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUguyapOVCUPwMg2p/\nIt2RMQWg3TEwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAKYzJIj971q176rDqgh7jNiGbJoAgAKebvrdbcOVz/5hAiEAsj45i0Jx\ntvx2GI2im2s09tt4osOJnqrAvLo5NM7a/kI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8282", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8282` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeJmRSOld1qjXpjdUAcrSV2FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1MWY2ZTYxLThhMGQtNDYwOS1hNmE5LTgyOTc3NzY3MzEwNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc0NGE1MGMtMDcx\nNC00MmRkLTk3ZjUtMTk2NzY2YzQ4MjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiboivCAdYnMsW6dBjPUk72viQPhYFtdfnaG6lBrBE53Rz9JU3PR7aXbk2tq8\ng+OzTscl+dLG6K1JUr/KqedRFqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI++ZWSW1qy914b6WyqMe8Blz1b0wHwYDVR0j\nBBgwFoAUn8K8PIv3kfqusyviFK9dnD+8W2EwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICY+keM9LikI+USHZzURFu/GSE1SdAC8eMV0OC46MQyTAiBgtVweaqVYtjK9\ndSqTnLZZ6X/6ZC/hU2NYKoKZV3ygXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ6So2llZSD0bGQYZiWr4J7xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTFmNmU2MS04YTBkLTQ2MDktYTZhOS04Mjk3Nzc2NzMxMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4UZr1J2JxtFHsC3PhalsNWxqMtEC3CtzUKiJwQmGeEh9L\nSsGog1uzBwMy7269eG995jq9TE2xqlCYsh6z7GTWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn8K8PIv3kfqusyviFK9dnD+8\nW2EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMuRiqQi28RIzsmlY63uF4SKruoIalvan8JKRKL/hfmKAiEA7MJI5sft\nsn1rCN+VSkdv7OGflUH+qQWq9G6xhR209n8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWanEN6fRUg+80x28Tg4roRZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc0NGE1MGMtMDcxNC00MmRkLTk3ZjUtMTk2NzY2YzQ4MjNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDg3ZmE1NWMtYjU4NS00\nODExLTg3ZjctZmMxMmY4OThlMjNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n05lHP8ssaeNHnKsFqdLfWCJKMwVf7nX3jdIbmLsIOeQGPrz2JOgXQIuBNyjyeydW\nr2BghFfEXFSuxCyt9uND9aNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUI++ZWSW1qy914b6W\nyqMe8Blz1b0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgR3/ee2I6hxQr5Ogc6tRFJb0s6879R+XA82rm+ySP4wcCIQCw04BH+FhU\nMHZ2lcSo2LcmBVrIe1M8IlK3SYjZRfA4+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8283", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8283` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAR/wURVd8GVqOwdWisRWMu21MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhZWY2NTY5LWQyMzgtNDk0YS05ODhkLTlmNzJlNTM4NTQ3NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMyYzRhYjktZTE1\nMi00ZWU3LThjMGMtMmM1Zjc4MTRjYmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7kg9HCDp08TIulBJyNpM+lALgVkFCCIHBrWSa4vXaa/54/Q5NDm8IieuK5SP\nIdyOD+ukkj19gfVJLVO3MgppoKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNoWl593mAJHTMM1vEDG3pFaPiVMwHwYDVR0j\nBBgwFoAUQfwLSdNHHOweVolr9yU0Q5JvhQYwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDFQ8QsaYYQd+oKH+ku84JoqTms0BUkF2hmS7QSEosfcAiEAiaUDXamqa5X0\nD+2VUzDUQVpTQVCq+niRgIdBRFJujhs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYg/bjJjINwBrWZ5ikC6cIhpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYWVmNjU2OS1kMjM4LTQ5NGEtOTg4ZC05ZjcyZTUzODU0NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASok8A5BUKXCXyElLFPYqEsdLwl7Y+Cu0TtNrGiX9au2/F4\nW+y3ZTZJVsTrqVhhNU5IbuEnCmgKdADIlPwnJiLuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQfwLSdNHHOweVolr9yU0Q5Jv\nhQYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAplSD/9wUSJwlmvcDRHcVIusgWx3aEdavN5HeWpXg5wCIQDRTD/YmRXp\naVev+XuqJHUJ9qixWriIOipJJQ4DL/qbgQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZdvKnh/E0xDOWuoqqfwpY0gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMyYzRhYjktZTE1Mi00ZWU3LThjMGMtMmM1Zjc4MTRjYmMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGZmYTk4YmQtYTRmMS00\nZTQ2LTliZjQtODAyNDI0YjJkOWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nu8ZWMih95FPTpF+3wUEZ4RNF9r/kBq7shOmKPMqFNZ2/9q1CgxeK4RGfZ8eSF+UB\nVunW9HuvHx3U0owLYb/bfqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNoWl593mAJHTMM1v\nEDG3pFaPiVMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAN5zg0m1ouUyIhANMFrVhuPqc68Vo7+HX3owRg1FN7VDAiEAxV2XvNqa\ngcMNhf+eTLCXHemtAnEG63d7YDKuNmGY5pU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8284", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8284` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAcm2aRnt5/lVtX2tg66D5g4+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5YWMzMDBjLTgxNzItNDc3NC1iZDI2LWI5YTIzOTg2NTU1NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFmZDBmNzYtODY0\nMC00YzVkLWI2NjItNWZjZDY0YmI3NTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERFQIstq0rCgftUTnOf6w8zCk7+Ms4jtFnbahD+/v3FG7sD409oqTmc7sauwn\nNMUVJY/9JjXA7IbPQjm1dFRJWKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxQg0VUM3oKIsL7IccGpmGlLMdwowHwYDVR0j\nBBgwFoAUACK7zVNJGnbAQ2UcWKCQ5QFShZgwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICz+\nZxCQHYD5Akerm+6EyqDZZHw3G3PooO+KVxOTNkx/AiEAzNyEnY5ixMPKh5goxnWD\noVyMpi4pAvk16LKsF9m9Co0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWuXEeeOPPOQtLpGzV9EEBXPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWFjMzAwYy04MTcyLTQ3NzQtYmQyNi1iOWEyMzk4NjU1NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVsQhf87TI7W9VtCXWNNYjvQgrCoHuDen1gKK+vuuNCR4f\nDzJkStaOywubgRni3XA3M12YxLNfCKxKe4NYXckAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUACK7zVNJGnbAQ2UcWKCQ5QFS\nhZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBTcnRj+bnMQl9JS3vp2eohRc//i3gWmhMX/IFD37Fi0CIQCadIfIzixh\nmKnjS/a1lJAIcGGsRDfCKV9pBVMZG9lq4Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeTwqdokC35HUQ0ZwLyXZj+JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFmZDBmNzYtODY0MC00YzVkLWI2NjItNWZjZDY0YmI3NTZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmUyMjg2ODEtZDk0YS00\nZmJmLWI4OTEtYzU1NjQwMmU0MzhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ne01i44NJ0j4RLkcPG6BAWQoBkcuABKAMpnoLYXU2F1oEAN8dPmFFaXaYubkdcHS3\nmFtRl767aEGWZWAZ14woPqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxQg0VUM3oKIsL7Ic\ncGpmGlLMdwowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgd8H+i6vLINs2N77L158pHJtYWS+Lls0vNCvRg4Jp7IMCIQD4Mb+8eRWy\nM/fiU+KILAa4YQXO9RIi5HwQRyIJnKcBZw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8285", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8285` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAXmh0othrPczkAkMKAeiKv1wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwZDdhODY2LTQ0ODktNGU1NC1hOWFjLWEzN2UxZjJkYWVjYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZmNmQ0MDctYTQ5\nMC00NWJjLTgzMjAtZDFmZWYxYTczMWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW8baSHhRpVhaUBUWSxVvHkjt4lnM093rJ1N4rBclgWkJPgb4WtcD6IKea+4U\nvUFsjJI19eMViI2krPHJFgVgbqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUulK5lph3zFwGRWDn1Y1BhFio0lgwHwYDVR0j\nBBgwFoAUyqknTwWzmdKAzYSR/t5WIvJS9i0wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEHVE8Fz1DzhQprBSPxtk2G6j7iNtMClf2x7wUuJn1WkAiBJbQ/n\nymCN4YMG1u8OsxiQLM5osV/mmMZ6x55m+6r7kQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQd8hTZaoo6RmkejQCccvYyOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGQ3YTg2Ni00NDg5LTRlNTQtYTlhYy1hMzdlMWYyZGFlY2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdFqKqj1ARMqVq5g445mSsMgHLfMIefhKFDbwyF1aBMkT9\n39TFYlDUDVFXMdA1eDRzzgX4P/xj9wwcPS8wGG99o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyqknTwWzmdKAzYSR/t5WIvJS\n9i0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfSpMo2zLV/YeMBKD6gVzZOwB9bag75dPNKDP4IjyVJUCIAz8N6GBxMMk\nZURA62xtfutgEMioh9PlQgwkC3mtq9+N\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZU1MvvfXJLCHbC6zlRNQnMxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZmNmQ0MDctYTQ5MC00NWJjLTgzMjAtZDFmZWYxYTczMWM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWYwYjMzNDQtMDA2MS00\nNjZiLWIwYjItNTM0NDA2OWRhODFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nse9pN8cWKaqBakMbTUS76qPdQ2nWlUlqKWt3kLbxDa93dTxz1rgeUBU9P8yBM1vI\nyUM26j7XnAAz1S9Hd9h6x6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUulK5lph3zFwGRWDn\n1Y1BhFio0lgwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgbGW6OLEZzUdgr883ooxaTFgSYi7Tl1ci/HeniJ5cODICIQDHEpS1jzX2\nXqWbMIl4iDRCYytzZHnPPJ8nB4cLNQkYPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8286", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8286` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAY66vicT172koxOiqxomlFlYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNGRhNzU0LTE4YzItNGNhNi05NjZlLTJkYzNlNzA0ODAxOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTYxOWE5NmEtOGY0\nNy00YzhkLWI5YzUtNDJkZTA4Mjg4NTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2VHnzVmnjmhVr767o8th4ipk29jl7r8CVJIZxJi21jcC7NoYaM6X9GnKWtrQ\n+j4jzHuDXNQj3yh/TGp9Zl2GO6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDMfaiJCFXzgp4RLhzf1oEgnKFCQwHwYDVR0j\nBBgwFoAUeG4ErjxA7q9tsHNA+qEGGrVmWB4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDxY9CW24UpdfAo0JZa0zMkbMXZeBQ8kd8IuM6R09M2JwIhAP2J\nPDrDnZqpeNuLfrThbZeVwg30bJ4wJiSh2WXU5eFp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVTKPbL54RSgp5F7DGjaD7GMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTRkYTc1NC0xOGMyLTRjYTYtOTY2ZS0yZGMzZTcwNDgwMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfx9j+dkMiwmTDwQzzg33/F28TtJFEp81kh6KI9/fK5LU5\n4FLC0GiJ5fZLINpJTUJ0uyISZ0oPGaQG0VpxdkFEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeG4ErjxA7q9tsHNA+qEGGrVm\nWB4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANLw+I/RfBI5TK1ggFsmsBIX+r5fzJUXQcdylDYIdE0yAiB6zurY8wmv\nD37PKYRUudazw1SxeI6+VIfcMLFTgpKiCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbz+0fsYvjaCkD8ElilXE0v8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTYxOWE5NmEtOGY0Ny00YzhkLWI5YzUtNDJkZTA4Mjg4NTk2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGY5YWMzNGItMTYwMS00\nM2RiLWFmZTQtY2RjNDE2OGUyMDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhCzj80H2tvo/LQzVQoJKn6lG5GiIXLp9Ie70JkyZvBfThs0qpDklW8rTojxbI2sa\nElBD+ElrErL6ooPaTEBi4aNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDMfaiJCFXzgp4RLh\nzf1oEgnKFCQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAOnTxTBYB+DB4iDWAzRZA9/Xhy0DYp0NJaBAZs5lJdJ5AiBXi23qY4Rm\nv/23Q1KmpecsUO1znBKEdHcOOs4ndQTQXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8287", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8287` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAaM1SsACIG2a2XmJP2R7vc/OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMGM2MWU4LTk2NzAtNDQzYy1iMWZiLWNlYzg4N2RkYTUzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNjYjc5OTgtOTVi\nNC00YzYwLWE3NDAtNGRlNjc5ZmMwOTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmKDcfLNedshnLYGEzxvGb5oM+iRoLnZelYw3Ot9S5Q5KVeTiMN4srZTGh2kC\n/8TqdU7C6GZgXe4j3OAb4/jwsKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMrf7gcJRqYPCoRk9zBsyF4HWbM7MB8GA1UdIwQY\nMBaAFLaltN8xSHmLaDcfQZLej3aIM96uMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAzLgl6Zl1cUkRxOd6Du+SnBTS8VJs9QQP\ns3nJrlbnfNwCIQCzB3qH3TJckmQf5wVMWmd2nlYvgeh7JZDF6kYe2M1SEg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQQR78XG/poOAjC+2Nt1G1bxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjBjNjFlOC05NjcwLTQ0M2MtYjFmYi1jZWM4ODdkZGE1M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrUKBZ3sxK4eQtjugs+xSfQ+svFGiliLN2zk4/QCnec4cw\n4i2+Ava9jo3YKHnZE2w8oFLB9Xq621ZFO78tb+Bjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtqW03zFIeYtoNx9Bkt6Pdogz\n3q4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJwKkZ85LLEPj20tShZDYTcxpXLHRNNOwFekwGjYbjCQAiEAuGhlhFBJ\nGs2xKtAYBSRoKU0h7njZ+QAP2obnZn0QGus=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbF3qLbAF57bt11M0H65ePhSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNjYjc5OTgtOTViNC00YzYwLWE3NDAtNGRlNjc5ZmMwOTM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGNkYmM1ZWQtYzc5Yi00\nMzlhLTgwYmMtZDhlYTA2ZjNiMDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRHtU9Uf6dpgd7rHOmFcUvic0HLqcPz3q06DKToLqTw6k8A8C0rP59HC4VPBb7A0m\nXzaCX7xyN+jzIOPrXB+aqKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyt/uBwlGpg8KhGT3\nMGzIXgdZszswGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAKY8orLt9FrLffgErx68sn+jTHqk++t1kmfmfHeSOmj0AiAmuBXFwsb8\nPkFsO4RRyQABnG9IV++3isyRFjdECa6URA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8288", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8288` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASzM+CMkinXlDdHzNahaNWXWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiMTU0ZDJkLTE1OGMtNDVkOC04ZjgzLTNmZTFmZjMzZjIwZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY2NjcyYjktZWRj\nOS00NDRiLWE0MDQtYTk1MmQ2OWRiYWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW8Nb70nY1w9A9/41MS3jWqTbi+CbfvUacEYmamG3/m/KM/XdAo9MzcDWaGTr\nGKaJ3EPqDEioAxAbdCIJg/pO4KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMuh4B9NNa8szb7mWC3AUcEdF5xkwHwYDVR0j\nBBgwFoAUzPhZok39F3bHlQdi82g2Jx7r5RcwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgAq+xJnRs1pkX\nLOSDOtCRjJxV+pgAFe8yPpmhGuaC8nkCIQC5tAaL/4Zv0N6XQlhbitMlYSlE6Cch\nElagstTUsFOoHQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW+QLJ/E+HKMR3OiL86Xdv/MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjE1NGQyZC0xNThjLTQ1ZDgtOGY4My0zZmUxZmYzM2YyMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlGJ3OJBxCsU89CGQeYLwrpjGBZ5gdSM1sYvqddZUNT/7+\nOXSgYYMu9eanzicc2HDlajQ1HS1KWTS8nfgSyb1do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzPhZok39F3bHlQdi82g2Jx7r\n5RcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPf4UiKi3zVoMNtqd8TjkWWFZSTsb8hH1t/TFKE3v9JwAiAZ298pkNFa\nKCDsXMw/sa0Pyroh8feobVqRc6pxd41klg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWX07JYISB+ivG+2zGLSVBf3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY2NjcyYjktZWRjOS00NDRiLWE0MDQtYTk1MmQ2OWRiYWE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzliMmEyNzctYjQyMS00\nN2ZiLWFkN2EtYzgzNmIwMjVlYzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njt1i1Dq735h6T4rHdBLJ7dLSEQB8XuN+1Ve2DpQ2OTfvKnuXo/kDfRiy+oZnMhtn\n9YlOY9WnXLEcpMQwQMEZ4KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMuh4B9NNa8szb7mW\nC3AUcEdF5xkwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgK0a27ywX3TlIU3h7SpJnhcVtNUT9ERmujKfZVPfY314CIQCy5upi3Ey5\nRd2NNFpi0qndi5AE6+dOJRXAr9M3sPpCXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8289", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8289` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAT47OJNmHtgX4gW+jZJ7gFg9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmYWE4NzFjLTA1NzgtNDEyOS1hNDU0LTdkMTNkNTQ2NDMwOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjAwMjQzMmUtOTg5\nZS00NDMwLTgxZWItNDk1M2MxYzU0YjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7ep7o0IY+83M23cdgSpRgZEulYCImDe9WmmAulfbciKo84agLwIvrq4U8fnG\nCNSBHoI22DoAXaKHy0ARYr5y06OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcSuhrCzuOywOUuO7R0e/jbXEu98wHwYDVR0j\nBBgwFoAUB8gnsBedzx+oAb1j7BGLAo4076swKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAO5+jGkDbZ42\nuN5EP6ENerIwO2ozg7BAkAMkiWk94T3ZAiEAhaIz3Dk72c0YK8hs5u+iD12bhNXg\nDpOAjFaJm/tdMFQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVjYrSv/KsmBaT9PnyWU3sOHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmFhODcxYy0wNTc4LTQxMjktYTQ1NC03ZDEzZDU0NjQzMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNmCMIQGIERRFkzisoEqaK3QL9fnIDFSjFiqIJRzZc0dwT\n5y/boP927RQtUh0QSsVhlvk14JYfuQttc2Sj5d4Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB8gnsBedzx+oAb1j7BGLAo40\n76swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANH0az4ROBJfVYWssM1/KBsOBLdpSBtO5vzd+YR+CZaJAiBPGfDKuIYW\nx4n3COKt2ATqOZJ8HVbZrMCH3LgVvdipVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaFXL40bCid/bYk2Z7wI5N/VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjAwMjQzMmUtOTg5ZS00NDMwLTgxZWItNDk1M2MxYzU0YjRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmIxYzg5M2QtMDNkNC00\nY2IxLWIyYzUtODdkYjFmY2I2YzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ny03Gk2wv8OklHYVF7yztmsYQFjghh+LPttH7WtMj3wtzACZK8X4l8nN+OZw3hlVi\nXUmjtDxNpTl1t/7QeO18IaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcSuhrCzuOywOUuO7\nR0e/jbXEu98wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhANsyGsIIhcANV4BQ0RPE8J8WGrzM+Nxp1DQ2InxQsSXSAiEAxlkEHIym\nMZlCg4VAZ4srYfWjA1RA8u6p1j3qKHzYG0k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8290", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8290` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAWNqprPAVqDi/tCigPz2Z2YvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjMjgxMDJmLTU1MmQtNDdhMi1iM2I4LWEwYjM5ODZmZmFkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTJlM2NmMWUtMWY1\nOC00NDEzLTk1MzItZTkwMGRiMjFmNGEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETNYqYtCll9mZY3bIAiZKJIfglk5pq3wUFrRlxHdF9v1TsYOlqthYvT81tTjc\necWzS8yrfCul4HU/DNflE6kmCqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdbqnqnOFe2EK1oSRY84DweeqxsQwHwYDVR0j\nBBgwFoAUD2qcCWgIvZ9RqlsE4CBwd6EaAmowKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHYqGdyzO4Lq\nO47iVktXudQYo5kx23zCWES5J1ugkMkxAiEA4B0doEKouiBvMGUSb6kYhphORbVK\niDD3hOUWbcMtax8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQVEfPhkAIoUuP4HRIwjaBf5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYzI4MTAyZi01NTJkLTQ3YTItYjNiOC1hMGIzOTg2ZmZhZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFCQBlrVLiY01H0WHf5jzpH8hZjQ8CCftX55RrSq41u404\nN7SyizrQYcDmXLxwknHLIulLXFnQ3aWDiVy7c3Kqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD2qcCWgIvZ9RqlsE4CBwd6Ea\nAmowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM4rEeejqrEaSJSP/kwG4JZ5dLvSbSqOlGoJ4fDwIKILAiB4cYArW/G7\nV0whkEGRG/Vm3Ue4WXRPCHm1QuUCMdPYmA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATAlF/e7R8QknH50aKiMO38iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTJlM2NmMWUtMWY1OC00NDEzLTk1MzItZTkwMGRiMjFmNGEyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmNjZmI3ZWItY2RhZS00\nNjc5LTk0OGUtM2FhNTM3ZWFiMWUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlCBzSyczyz/GlKHT3LA8RrqNSoy1OL1+VLu7s/7Yy9AhD8r0CFAGzHrsTzSxd++N\nMIudDlYN8zkCjIODwxaFLqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdbqnqnOFe2EK1oSR\nY84DweeqxsQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAOHTkkU2uI2Rq9iYfl5cgZSFh0jj0LJraGXddRZZgZHGAiA9jqSV7mdu\nvnRG79597tL7/q4MaIQwRJsXvLLTyv9NkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8291", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8291` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAdjDrUZg3CP8PKwbrijkxv7aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiOWRmNTY4LTkwYWUtNDU4Ny1hODY5LTRjMWM0OWU5MmYwMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGM3YjhiZWQtZDE2\nMi00MWFkLWJjZTItZjVlMTQ2M2EwZTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ39nTrHkxMvTYcma/Lf0Ils/dDhFTF1GbFD0t6pW3bZVaoRHelUxKuFm4DUY\nCG1Y/mlMksyGhyDB/dUhCvEY46OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgbtc9KsEp/hNreUz/Ioyulf+Gr8wHwYDVR0j\nBBgwFoAUpdbF1xzjrpKnXqg372CJBhNDB/4wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICOX3EUtUBWM3kC9NfXF6IW9xGKkTC9wMe/8dBoEMSWYAiAp89fbVn0sz+xw\n1CHdg9XuYGJxs9u/igBHDhWb0W0rhA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWrIbUWMVcy3C0Dt4faNKDW1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjlkZjU2OC05MGFlLTQ1ODctYTg2OS00YzFjNDllOTJmMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATX40vdzqMrEn7XYainRXZJOckCYvKjtDRBPyGt5o4E9+iz\nO+ERWNXw7KghIO4mh6NvEtV8hvEVymAQGDT3eZsqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpdbF1xzjrpKnXqg372CJBhND\nB/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWAucZnwKjwIpfyFbA4tTeEa8cvyiEvo7RzogQgaNqp0CIQCp39kK0u6t\nEioGDsNn5yrFw8GJh5MIwHkWzDXNAVsSpg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYsb748Gm5cfaeJlAQfkTZKfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGM3YjhiZWQtZDE2Mi00MWFkLWJjZTItZjVlMTQ2M2EwZTJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWM0YjNhZWYtZmRhYy00\nY2VhLWIxNmItOGE3ZTE1MzgzMGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWu/m83dz65TZoV/JkDUQrYmWUwGorvJX5kGGKTRhiR7JJBx++eu4UONI+xMsEW6o\nJiy5NCm6G2Z+hv6lsotqaKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgbtc9KsEp/hNreUz\n/Ioyulf+Gr8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgUa0BpO3LICEsjyueIBmVzEBs1XN4nF3qqsc8OTHqwQ8CIFB6xJtoqzfD\nxcr7hOuFUW+Fq9Kw52KkzYxk4T3HDzku\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8292", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8292` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATClsn2R3J512+Z5LGKsh+WAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NWI3ZDVhLWIyMGYtNGVmYS04YTA4LWZlYmZhZDlmZTBkNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I3NjVhMjUtNzRk\nYS00ZDQ3LWI4M2UtMzMwNDQyNDNkY2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWAOe2WbHhyBKIEIe193ySMA7C+qGwDt54u7DiK11j++x1vqhsw3Fh49y0T3v\nWb6OmuZnNLdPeBo9d9PA7y7ojaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8iuBHyGLKWXgAqSTq3QLweMn0owwHwYDVR0j\nBBgwFoAUB1La+fzQRFMamoaqH4uXL5U0chcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIB1iF4YXP6cUOH7KBtaETgx/4gH4d2n2GL6GYK1bs0WnAiEAo/0kbNCmt7Im\nX6ctylaTaUuZh9vERgFQbTar24veFHQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATWAFF07AZWssjGoK5Hh+F3IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTViN2Q1YS1iMjBmLTRlZmEtOGEwOC1mZWJmYWQ5ZmUwZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFVJlKqUOClmek39mPeP1KgjdBzihgXqBKIJx4SBxzTID1\ni0x3Zdp/Y8F7OcnMljn7Bc9gwGEmYcJDFwEHUatlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB1La+fzQRFMamoaqH4uXL5U0\nchcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhodj+O37QRAiTPVFJby5A2nSYyXOx9DC9fRNugYTSRAiEAraXwKdGf\nq9S+XQDNznbj6l5ExNT5/R2gjz79AN7kp5I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd2W7Tjww6ALAr+oV4ct1j6JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I3NjVhMjUtNzRkYS00ZDQ3LWI4M2UtMzMwNDQyNDNkY2Q1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDM2NjEzN2QtN2RkMC00\nMjE4LTllZTgtMTM3ZjMyNzEyMmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZ/f0fhr9xhwlATCBWx/HEGGG8z0A68Fz+0e2OPJd3L3qyC7sPSSKVoHqp3gIj453\n18ylPv/q1FNg0DbH9RixmKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8iuBHyGLKWXgAqST\nq3QLweMn0owwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgYMN3t4aGmKsrwNfa+N/siGWxlga+cUe8bhL2cL6h/LgCIBoVL/3kb73y\nwCYtgbfz9LVaOVkosSzXqIVzIWmSXa9L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8293", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8293` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAU3tJ/2ow7pOHdas7FgJsAPtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjNTdkY2NhLTQzMjUtNDYwNC04NWM2LWI5NmU1YWQ3NjhiZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdjMTkwOGYtZTU3\nZC00Mjc1LTlkMTAtYjhlZjc3OWVjNGU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgUKJybmisPn2cg8nF6nwIxUDsWawywXMVqi0VBhfavJdWg3vTe/aWSvZZqQG\nHmfWa06TQNsew1QCZHHCp30Ur6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpT3HuLhsUZbEe4LMot0PeMz31YEwHwYDVR0j\nBBgwFoAUrhfrcQrHlYj7Lu1JcWnFXv0GnbUwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHJ5\nGdRlSPEZnE3zh8X/9M9fgVZsNYKehYrhRUlQPd1xAiBlhT8C4iJbx4QBLC9te/aH\nhNTukGJMmaKy3uiWsyK5Ow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa3FiW6F4+YJmLXAkFHJCX4fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYzU3ZGNjYS00MzI1LTQ2MDQtODVjNi1iOTZlNWFkNzY4YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASknZ1pr8bSR6XgwNkodIOl638fnQ5tew1KV7J4nZqFcZLm\nsmIvZUF839Nxm5ALWPtVjFAzGFCgvUrni7pV2NCqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrhfrcQrHlYj7Lu1JcWnFXv0G\nnbUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOu4wZCZHOzysz/TzusIeeDSCKo4/lOwfXEE2bTDIgNPAiEAgIxpdyqM\nzLq3uWvql7Ol3vm0RGE4MovEPK3U5z4MhRY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXAGPR/s+QVi8CwRu36+RAeNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdjMTkwOGYtZTU3ZC00Mjc1LTlkMTAtYjhlZjc3OWVjNGU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDdhZjI5OTAtYThlOC00\nOGFlLWFlMzUtN2QxNmVmYWMwMGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXH/9fKRw50N0olbgplim9KPpLH0+xjbZ0Yck+NHz2iXU1PlWDBPjDRJn0BuyGgc9\npKgwi1NI6lyqGxeWiqSkNaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpT3HuLhsUZbEe4LM\not0PeMz31YEwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhANk6UZCxI95mNvY/IvAytKIkCgsC0YjZm8gyOGo/AVNlAiEA+WvcfPko\npuFdAwMYqSZNrlFJUcSZ9kRtT1bt8+/YCWI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8294", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8294` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAd12qTWv6kX3NKa/Xa0G4zH5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzNGY4ZmUzLThkZDAtNGM5NS1iMWUxLTgxZmIxNjZmZDNhODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTllMWY4ZjUtN2E2\nNC00NmNhLWExNWYtN2ExYzRmMDZkYzBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1De5WbELAn+Il0R17O3y4m/ct7It6Julp73b+Brqm5cD6avTHpHMO76T5ZpF\nyO3WJYaJwIJ7XmXwUG/08v7zsqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU59Yv9Im6orOHkAqM7Fptjd3Q9L0wHwYDVR0j\nBBgwFoAU890rgju+27nrebRMjqdw3eHpFLwwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIAk19yw9HC9eJok2hPblM3e6w++4TtTpiwfjPKSOZzFTAiAQyFPe\nB5lypr66we4zSxgobzz7YeRen/UBziQTPzqt5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARVhdN2TMPw0KYaWHpQ2bIRkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzRmOGZlMy04ZGQwLTRjOTUtYjFlMS04MWZiMTY2ZmQzYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzX3o0X1H+UnXLZjKKqxJjzqEk6ut0Le4e+VEXz3BG8X+S\nhaDheWhT8JHE2melwBob+PK9y3B7oY92cxyNg8QLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU890rgju+27nrebRMjqdw3eHp\nFLwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALDB3kfxsJcPexgnSHnCLC+KWRJljDLOtnXCFALUeRnTAiEAiDA+bTCd\nX9w3R1QSCwa2g+BseorNVg8Sw3CJltaiHuQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAepGUqstvHcd6LI0wd8nDQvrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTllMWY4ZjUtN2E2NC00NmNhLWExNWYtN2ExYzRmMDZkYzBiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzA1ZmEyZTUtZDU3ZC00\nYjAyLWJhNDUtNDZjNmZmMWFiM2FhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njS1rnMwoiiXhiNjOY55uSiD0rZzj3OPLFan+JJHK0YYaoSWQSjIputqdWJ+RUk4I\nKScF0cYpWeL1FDopDpjOsqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU59Yv9Im6orOHkAqM\n7Fptjd3Q9L0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgMbZdrCtRdQDLQxZzb51EaRwMLPnZfrgu78M8/kKkt+MCIDJyJz3QQG4T\n/IXv4NHcBs1y5lbOXCXTwp1NuzLXvYTZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8295", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8295` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAcpdtLgnEw0vryTCUkOB2tD3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4OWEyYjEwLTBmNTUtNDQ3NS1hM2Q2LTE4NDQ3MTMyMzdmNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ2YzVmYTMtN2E2\nOS00NWExLWE3NDMtZjI0YmE4MTU2YmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqC8yu47qBa5zfZZRCsAH8lqXVHhEN/sV0r4bt77EfTX69SW59iky75v59Yl6\n5xPEa/dMmhAGbzQ0wxfKCqG+MqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtSjHJdWAniwwLGFAu7yJDXI2CK0wHwYDVR0j\nBBgwFoAUswt39ksjId4vFW72g6gs/auz0EQwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFWE4+Yd8h25337H1iQTDNFMzBa0C3ef8xSOsBjPj14xAiEAr7Uh\n7fhcvSIKrzs6B1tMy3d789c97pmxcGTGFdLXmUg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVpl3iYgOPKQU1SdJuWznrcrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODlhMmIxMC0wZjU1LTQ0NzUtYTNkNi0xODQ0NzEzMjM3ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARd7Kv75ofL6HkJ96NgigvwnZh8HHVrtX1m7bLAiOvdoeKJ\nvbsmPnDHzbuYNzGvqHogarZ0fsQrdgGIQvmxcj5Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUswt39ksjId4vFW72g6gs/auz\n0EQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSoYIGLwNQEIT4dti+2uDDtcoASR+N+0pvI75ncMQh5oCIQDctMw6HC9H\nrkZ2TlbWLq5Lo7pw1T13TpoXIhBoakez7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATIztc/hUO5se2Tj03LfQa0NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ2YzVmYTMtN2E2OS00NWExLWE3NDMtZjI0YmE4MTU2YmIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTM3YmNmM2ItYjJkMS00\nYTlhLWI0N2UtYTMzYTE4NmFiZDgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\npggSFFF9vI4NiLj9hjjPm92cD2M8LbVHiiqt8z+HXRdpQ+SOVP7zmZQPpeS4z11/\ncEcuNxj84cvtuJQG/XYOYaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtSjHJdWAniwwLGFA\nu7yJDXI2CK0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAMr8ZC/Pdgnodjh55RC8c95vZf7CuHyKAo91o+wbz2qVAiAi9rZuS9ru\n0aNPgXMhlmlUqx7XyxJMXOo/m4PD1RS/Mg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8296", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8296` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISASu5+LTaY/gZTNpudmauxFQ1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwYWI5MTI1LWEzNWQtNGM0ZS05MjZlLTNjY2YxNjI5YWQwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDA3NjNkZGQtYmZl\nOS00NmRiLThkNzAtZjU5NWFiMjFkNmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgUNzB5j7X7j5ukEQTmq+YqqwdK5C2vrFDCBxFXZkZ5RY6Q55O1Ah9M4eyuIM\neIxLgCJq3kFS9b14KRZLWrlXEqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR/msqwO0ZhaTz3BKkDX2Dmpme4vzAfBgNVHSME\nGDAWgBQUJx/2fSsH/HTzfjqyXkVzg5TpHjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFdcgHOi0a1GUIzUxtDLUnOMhUjBp6+k\nvFDZvGEl4SncAiBy4mgYj/OCoTF2hp2Gil2vIgM3VtVsUf1UAzihB2hNVw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAce2Obl3A4dopem1KY9mxeyqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGFiOTEyNS1hMzVkLTRjNGUtOTI2ZS0zY2NmMTYyOWFkMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5Mg1hZD2EAqb+7TBwka9kRQ6sIqW6iR9F4F/dph6Sdem/\nhQDWShZXWy4vpJm2aLkcjcBfDB18FDoTQOjE1j3wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFCcf9n0rB/x08346sl5Fc4OU\n6R4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZkXwcTZ66XukRxkJQl5gCzi4HKpPcvdjECHA7feDwiQCIE1uefPzRgXq\nWk3vZ2g5o7TVWJsx63iCclvTQjISSO1G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdRFVhGaNvG6EMP4qeabUSMAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDA3NjNkZGQtYmZlOS00NmRiLThkNzAtZjU5NWFiMjFkNmRlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjQ1NGYyNzMtNTE1MC00\nYmE4LThhOTUtOTkxOGNhMWU3YWUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niLli6Flfj/DJoeOlX4N7nX61jZud0kGEwvJFjk4IdAbIP53sqeAOR1d/EASMmr+a\nV8dVQXZKzfIRjL9UmK6Hz6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUf5rKsDtGYWk89wSp\nA19g5qZnuL8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAInz5noBhb/TqU7ik+XUCGt6DgmkB3y1/wxAHqB6G7xHAiEA4U5MstYu\ncSbGPytKoMea0IeEE7tG6SlPZB1xHgL1TX0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8297", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8297` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAWge9uR/+VHiJbEPOO6B++lsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyYTlmYWU4LTZmZGEtNDRmOC1hYjlkLTA2N2M0NWU4YjNmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U0YjE3OWMtNDE4\nYi00MWRmLWE5ZjctMzVhMTEyMDUwOTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5YFM6idYos9RMoN1nxtOCn3yM0T4bFGNUswrOuTbkxaBXVm+QSsBwHqF9NFI\nI4tdaAlKayn8Xm5Lqp02RxEBY6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJaPzzk2dNp1k7jqv/7ZzfjWxI7wwHwYDVR0j\nBBgwFoAUjmb/civGMGevZxd00ZAfbDyCCMkwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIA9wr1meRema\nHx0Nv23iIAj8IrSwzSE9cjKY38BgaNTbAiAOZVj+6P9FHNUzAt9jC6BAo54mf1j3\nMq5e8hWZWfLqDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcK7/Cv70soUsqdxI0ex8mBBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmE5ZmFlOC02ZmRhLTQ0ZjgtYWI5ZC0wNjdjNDVlOGIzZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATggC+WIdozPu4MHiEKrHcXLPZ1cEFsMRKSbb+y3sAjuv7T\nU7nfsx05mqtrxwalov00Ef9HZVaU4UlIdSVPib3To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjmb/civGMGevZxd00ZAfbDyC\nCMkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIPzXkL3REORSTdDBNfG8I8F3oz0i3bfA4Va0SzRoPn8CIQC9mjqzePaV\neRSjbJQrAmlCXs93OUIt3C23pCuzDgnpBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASt3TtY29DM5K9CfUVCeagcYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U0YjE3OWMtNDE4Yi00MWRmLWE5ZjctMzVhMTEyMDUwOTI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjc1ZDUyNDEtMTA3MS00\nNDRkLWJiNWYtNDUzNjM4YzQ4NGQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noIrQMbtJ7ILHPqsc4xNBkLWMxCSmwK/WLTQ0qgn3+V3XHEJivMfOopeQJApnO0/B\nF0odcsIgJPI1thPl05xsvqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJaPzzk2dNp1k7jqv\n/7ZzfjWxI7wwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgH/73KA888HVeVgQYpcD7L1jDTTMk+t/ZwOXtFgF0A6ICIBee0nebkwxO\nBGQhSu6v5IfftYfm+C+zc7Tb6nRDSnxH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8298", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8298` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAS011spjFw1NJEyamGsPbGaqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjZmU0MzU4LTk2M2UtNGEwZS04MTkwLTRmZGRlMzNjNjI3MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBlYjRhMjYtMWY5\nOS00NWZjLThmODMtNDNjYjIyZjhkMzc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWf6GA2YuXC5HOsec6Tsl/zxB6FsEb/IDhhLGXfB0D6tzUtckQCOZ1h+K+er7\nAcX0a1sqbU54ExbTgl8BW+xjjqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtyrqCRZUIf6DeGvSsUXt+ykwFj8wHwYDVR0j\nBBgwFoAUJ618mLYLncOwTwDFZXxx/u8wIuUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDv/R046Pz9\nQxh5KR/736y76rkeC1EHH+N/lRel7/4d/gIgM8tdAD+dpGMkUMfzo3phWF9UYEjO\ns6JVGwNx+oz2Qfw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASE9xcq3IswFfSkxoLmjNPHlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2ZlNDM1OC05NjNlLTRhMGUtODE5MC00ZmRkZTMzYzYyNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlJwZxrD6VUqqlxCU8uEMBcWCQJsSFJIKyWmJFpr18ViCa\nSTA+A7/sj/VXOVUG7+PmIgP2bb/IScxH57J1ePrYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ618mLYLncOwTwDFZXxx/u8w\nIuUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMHPVovKVOZGmzO8c9yX+nlvQsYCZWHQisdk3EqagTt0CIQC3cyZES5tc\nQHoBWYhB/mL0A3fWujKcfYpdj8EkKtxFNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQuS5yalQSpj7+XkFYYTTQJ/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBlYjRhMjYtMWY5OS00NWZjLThmODMtNDNjYjIyZjhkMzc5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTZjOTM1MzAtODI5MS00\nMTQyLTllNmItN2E2ZmZkZmE5ZjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEzpiEc+1PrDizEPsceJMO4x+7jw24gyJoHTpQvi45F4CUGNO3D5g7U8efbkqZU5v\npLdGH/LBkDj7PdgA//T6NqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtyrqCRZUIf6DeGvS\nsUXt+ykwFj8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAI/afOU7Yxfbj0Af1ixOrSnQ39D8WAskicofEmwQLT4+AiEA91s99bA1\ndC5OtVsPMUYEYvlDt4rykcOSYfCjpdPxUWc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8299", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8299` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAR2YL5R1IWHYnKi8qdrVfSubMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyOTA5YjM5LTgwYjQtNDVkZi05YmVlLWE4MzkzMTYyODM1NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA2NGIyMWItZjM2\nMC00OTkyLWE5YTMtMWJjYmY2ZWU3NjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd+TvQBHgb+iTmsYMgQLbaueqTEOcEXQqbn1V+zWnM65f/7HwTOggI5RHUS8E\nZL44gGMkpmSJaf2SfDRu9gYQJaOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG5OAmGL6Qr2cvcRXiZuHa0Ik0NowHwYDVR0j\nBBgwFoAUWyH9s58p16akssIuvneNkhtmJ+YwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiANOIb8tulb\n7qz8Dq6zRg6EHgADXSk657WH7IJx0KuZ0AIhAI3OFrLsk+8awqcejTKyOkZfQocK\nrt3xRldeF5AS2QI3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUTJ5ZjwUfhVAC+hparMzHkWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjkwOWIzOS04MGI0LTQ1ZGYtOWJlZS1hODM5MzE2MjgzNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSoZkPbLbdi6iMYMcK8zhx0XADY9xwrlozAUVJhglq2Hr/\n/74oH3mH9+iFwVzMi+mWLJ2KylVyIVqdfqcCbrbNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyH9s58p16akssIuvneNkhtm\nJ+YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOoDZYeihguuxxCJaX2MDPyzX0g9j6UmYv/qLaUlG62LAiEAk5JHzMcX\nZgujsV04j1OIkU/zBgoBySi9sz2BWW3G4gA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU499jozAbswMPKxjaSFylyrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA2NGIyMWItZjM2MC00OTkyLWE5YTMtMWJjYmY2ZWU3NjcyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2M2Y2ZkYTgtZDBhOC00\nNmM3LWI0YmEtMzM4MjIzNDU1NjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n44gzcV112Ay0kiLcIK/zsrsIUh9+td4+EUWLltlb+/wlp7RAR3/A6lg+nnwwErmt\naWKW7jOSkLc9HMNmJrBaL6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUG5OAmGL6Qr2cvcRX\niZuHa0Ik0NowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgQp3F5dKppGa7x7pNiA7d73gJ8+c/5+HjulQHZQqr+3ICIA9Ea9FJiZO5\n8x1oaUPjS+nzzgiNOMnOZlTKDGhqN4nq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8300", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8300` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISATa53vM7sUTrkG0H9K8XLIidMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiMzJjYjk1LWMwYjAtNGRiZC1iZDU4LTFjMzc3ZDVmMzcyNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjFiMjFjZjgtYjBi\nYy00NDk2LWJkZmEtM2Q4OTdlNzgxMDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAORbgQbX05dc6U3pWAJjap69vlSgdR7PoUEoB4Prm5Rzp/09cEK5hFIxPWdN\nLgt31nBiEWZrgE+Rrpv4A4ftzqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3PGI0+zf+GWqQfRSezIjNPPV7vMwHwYDVR0j\nBBgwFoAU+EnNKDpRHw2EeH/PInzS3uwDPSkwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAp0M8awkpzNkV2Y6+5AyynCDcbEMtkmfIJ9pUzuvdhvECIQCTdWDO4dJv\n4/JUQLRpPw7t8rm5XprEb/OgIL1/E7IOiQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQsoj+Pjqotama0G4gO6kofiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjMyY2I5NS1jMGIwLTRkYmQtYmQ1OC0xYzM3N2Q1ZjM3MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiop7j5s+s3EPreDFqRcYX2/IDvg48JcEjOOCEAJPLxgFV\nzo7fppRX6GZHsoFTA8J/lIujKHFpv5qXkjoL1bPAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+EnNKDpRHw2EeH/PInzS3uwD\nPSkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALCM+t2waHmjQVJm0OiTkzR5jxpMOwbv7J0xEpMmdQZCAiEA3PgMek6a\ny1wljPX64h7R29GRRcEZilvTc+HLkx/Ra+M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAarU5kYSDd4e++OWJv89mt1FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjFiMjFjZjgtYjBiYy00NDk2LWJkZmEtM2Q4OTdlNzgxMDc3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzk4OGVkNjctNzgxMC00\nYTFmLWFmNGItZTViMmJmMGE3M2NkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nL1/BlagZ4mUvIpWG9m9xKRJRQhJ3x4rWp1+coTmwieZSMFJCUoaVKYCwL2Hxkf40\nuu59uD6Kuu3m69Zf8iL+QaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3PGI0+zf+GWqQfRS\nezIjNPPV7vMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAOQVs8IlGJfTXRKwNfihh7uNaG0NP4H7up5yKuvFtsTOAiEAqeDubaDu\n/po2icteXob7LbPa8CXnFoXaGNIdg+LAmas=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8301", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8301` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAeIWajhJcAQUjHGcmMQQu1OBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyZjcxYjRkLTQxZWYtNDRhYi05YzgwLTY1M2M4YTE3ODQ2YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTlhYWJkZTAtYTZj\nYy00NjI1LTkxNDYtYTFlN2ZiYTU3YmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXJx1XF4czYu/z9aokW830dRnP526HbYXmwUDcAH86VWECIorHIuy3Ljsxi13\nafRYXtQi2pZrfMJXHwSF45YbyqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNoR3qoxD0HflHwtZ61/XDbS6XPIwHwYDVR0j\nBBgwFoAU+Gu4BPB+1TmAgw2SLeM3YYrjQwgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBvo+C9yqj7PfkZGWgJV6ZSLGNsQGsE+Ms3R7Q10EEcEQIhAI+P387i/6nc\ntsnQwRwI1nEqCYZsZlWC9LQEeSyE19F0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUrCv5cmrjpjsCNh1fvWNvdkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmY3MWI0ZC00MWVmLTQ0YWItOWM4MC02NTNjOGExNzg0NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASs4CXvm6lw204mf56vtudEMrh8S/iXXm25K5PS4XNOfJoD\nEM8I5fH731GqYc6S8YTfloDbzpH0MyLiWjrYyUoco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Gu4BPB+1TmAgw2SLeM3YYrj\nQwgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPZOYNRiB/92WlvHKfdODtLWHiTzQ/u0jhNauXwxvmO/AiEAifNcPenj\nPv4vxDksRE/+zK6/s2QZsy1yVZRq4ydcdCk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATrBGufkLEnwk2TvFFtWPuRDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTlhYWJkZTAtYTZjYy00NjI1LTkxNDYtYTFlN2ZiYTU3YmQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTgwNGMyZDYtMDVjNC00\nZjYxLTkxNzQtZGI5ZTk3NjQ5YWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCho3y9rkfBvtmIv6hz6xtfflWfqRfclHukt80y3hQOXuqxkG5rvpnhxmNkDO0gxV\nydZNQvgGJymCQpCEJtZF0qNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNoR3qoxD0HflHwtZ\n61/XDbS6XPIwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgPZfC6K0if4oJMJjGGOkZE9iUUSUz6SGVgO+20viEreICIQDyRLtpZTS2\nkViCl1MqkxU2aUTu+9dXsUewXv1fKn9PnA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8302", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8302` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAbq6GPGVfPM7NdwGLHOnAqgnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0NDJlZDc4LTc2MWYtNGM1YS04NzNiLWU0NzNkNmFkYjVjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVlMzJkMjUtZDVh\nNC00YjliLWFjOTktNjBhYTc0ODg3YmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHeGIDBlZG/EHltzX9PA9YPa26bTrR7cx8OZiV8ZskuRsOFpPJEcNhEwPHBj0\nOY3lznr4UPIl/Fy9/NqWixAV16OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2BiParOZg1crCcGBGKaRxN9pUgswHwYDVR0j\nBBgwFoAUPHCQ3qUcpZOj3JedDbFNtf5Ii5cwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBb\nvOmSyCf0EigFsfBTPu1wby7M8hRWzT3YMZfjD0hxwAIhAODj1Rljlx+AFLMlz+vT\nK7KBuzb+YrYTvSl8j8578S/l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWYIn+FijZNUWFKxzUeyc1MGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDQyZWQ3OC03NjFmLTRjNWEtODczYi1lNDczZDZhZGI1YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQtCEiXLM6KE41WRQRqW/jjexvKKsZjfiQv1EJ9m9fP1CR\njiU63gGv53KoDVoQ5mmrkKRyoXRsI/Lp0D3MemGVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPHCQ3qUcpZOj3JedDbFNtf5I\ni5cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfj0gPNpaHMrR/Bz9DstFvOnBB1yrZTD0vjkgYfcEQyMCIBX2LwVWNW8D\n3skr2HrvwLFlIKu25c8zuqnfb4dB3NWf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb9qTu6RAt12+L/vKRJClsM2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVlMzJkMjUtZDVhNC00YjliLWFjOTktNjBhYTc0ODg3YmQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjNlZGE1OGYtNDNjMi00\nOGExLWFjODgtYTk3NTg3MjlmYTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvYfLjuLrErzxk5Gl5z9CapcWq4IKwQq6MJZy/Ic8N9f0r8ZE2t08QMMa6QZiU2KW\nmkIQiPqRwedHGDWvsSjWLqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2BiParOZg1crCcGB\nGKaRxN9pUgswGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAPFIaH1SjgBjHTNySfW1enIl5zJhXTbS1y76TQ00NRLqAiEAjpNDhyor\n2a0KaTHNQDyXypb5MiAtrVEWIZ28UIqPDn0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8303", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8303` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAT8FXesPy+InIins5uuen25qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3YmZkN2IxLWI4YTYtNGUzYy1hMTUwLTJjOTJhOGZmN2U2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUzYTMzNzMtMzUy\nMS00ZmIzLWI4ODAtMTAyNGEyNjg5ZjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9sSQd/xA05hkuHueLY8cwaTWwGVvf1rRHC1PDGdurD+nJuHSybGAgTJs014m\nQ+P07iV2nQBnncIw0EogXQOlwqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo+rFK6PpyE8qd9eBJPdnUA/bX44wHwYDVR0j\nBBgwFoAUzVdBtJsykg/WDpp6zu+A6n3tF+swPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA20XNC3QJFbQAnoC5ay9iFLKT74PmLm9L34zW+7e9SQYCIQDT\nbifxTTvfOewOCUPN06unoHS9UJGiTaWF7nvDPEyrWA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXRNW6gnN3coJWPJXOXIPL8JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2JmZDdiMS1iOGE2LTRlM2MtYTE1MC0yYzkyYThmZjdlNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5Oo6qMCXXYdiWcALp00o/JSJoA2g1r40g2UfPzSWAfkxg\nvEr8TSLHZd0OWZG4XtNTuVAtzHHUatXCdHgZCVRJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzVdBtJsykg/WDpp6zu+A6n3t\nF+swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYVB+mVZCtt2PlcSGMY6XfiE2iJLsyBwvvxviTfo4xv0CIDRcGnA4NZ4z\nPAAHJDea4m14IjjOg1wujFj+P6L3TIag\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARqy0o1efxhAqc/2ZCojm0LsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUzYTMzNzMtMzUyMS00ZmIzLWI4ODAtMTAyNGEyNjg5ZjE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODc3YzczMTktODU4NS00\nZDkyLWExODgtMTZlN2NjZGI0MGY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuA9R493YKUuqq0pVmuS9kYNRKusMkZYBO47RwUTnFSdBN3Iwr3CdA3oUMyc51Hpn\nrO/Uhw09SBVORY0CoVVN5aNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUo+rFK6PpyE8qd9eB\nJPdnUA/bX44wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgIyyVg7Jb3uOBPbxi+oJDTAtz1+P/BmVh5nN7HRJgGUoCIQDwEczU8LU9\nhgowDVhNiC4dZ1xAYIv3P8QvNB3LwwSRkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8304", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8304` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAbJyLrWOkPpYKO3q/3fV/wJEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxZWM1MDM3LTYwYzUtNDQxYy04MzEyLTc2MzU2YmYwMTEwMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FmNmNlMWYtNjBl\nMi00Y2IyLWE2NjgtOTAyMjJiM2JiMTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZzmrLn54qk1pko+xTm0JHaDlH4F+QN+ZqgiNTgQxHJShzuIN/U/sLSxIV7aS\nI29dZwestoLmzFdDVJxwIsuNh6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhHpGaMz8WlHIlYoeg9dpesDlyJkwHwYDVR0j\nBBgwFoAUS6iymtJKWRSPmUn6/cBaANPIhpMwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEA3NXbwM52xjr+Z5gC8kTx6jM/GQN6JBD8Qfb77Jn98eUCIQCr\nNEAv+nPhay8EEczQwD7cZQFbPiyLG/xKMQSXINXsjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARyR0JGzAfc3lAn7nsmh5TuvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMWVjNTAzNy02MGM1LTQ0MWMtODMxMi03NjM1NmJmMDExMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3/ad7tym/NsVIAWES0P028IAqctNPQBXRwNCu2qxsum8w\njhFjGhSZBC3Am/ijeQahFrIv2oY0Y4/bWzgaG52Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS6iymtJKWRSPmUn6/cBaANPI\nhpMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMBuC0xXwT5bfv0ZA/GamuG+P/3J1+8roDM6n4l1lKBkAiEA6Kro/4/S\n6cxKLSrRjL2hKyy5lEmKg+dBRFnPcvirwSE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaXjvp3Qm1L2FPrf2N1D7cKYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FmNmNlMWYtNjBlMi00Y2IyLWE2NjgtOTAyMjJiM2JiMTMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODVkODEwMDYtM2E2MS00\nYWVhLTg1NmItYzVhYTFiZWMyZDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njOfuBjXXVPx2EGzgUfFMRG3QQKFdMsbDycvsMx9ihAN/ZKFZxGoPpr5LIV11dtAE\nuKSJ/vKNBIdlHIoI61/ouKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhHpGaMz8WlHIlYoe\ng9dpesDlyJkwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgJ84DijAfY/ggaLMbOpP9o3MiZPx4N58czUNnX7Qsl+sCIQCz05OsKkqP\nszSmczfeZ2bAuP0AzkQLseYs/ZSA7ol1mQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8305", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8305` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAWLIl/CNpcZcNejVxhv6b8mJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViZTU3ZDM0LWM0NWMtNGUxZC04MDZkLWNlMjQxMGY2MWJhYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmMzNmU1ZjctNzc1\nMC00Zjk2LTlmNjUtM2Y0MWMxNTE2NGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb+BnR4s28gvGsKBz60tU9Olgfi219C/WP96EAQplqR8t7gm5hmZiFMnpLAHp\nGx6pD/kHtQ21z9pv4YW9omIUvaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH0s2OOErMrfkINMaUsxqcECS4rIwHwYDVR0j\nBBgwFoAUD00azi+2ZcO80KggVqVa8asguecwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEA+LDhThZOTfqV\nU8X/8n/3qk7AaPnFNkkT9EE2DhHclYUCIQDOXRAMlF8UYKg6a8UhfmFuRPTnChrw\nCYM5dzT5V1qtBQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASPfeQlhz+RxycOjRXZK3C3bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmU1N2QzNC1jNDVjLTRlMWQtODA2ZC1jZTI0MTBmNjFiYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQouEqazfZo3OMd0omQPdNLOUlxhOMBCOi9Eevk0Q8L1YCx\nghBUSN5nHrBPuLH8MMnA0XZs4UFgSNvIM6atgEGho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD00azi+2ZcO80KggVqVa8asg\nuecwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANi9EDMsOrZ2hrplzHKo32oNdITN7efCrKZO9hcziefSAiEA26xdTZVk\n5dIb9h5y850kj/W0gNGtTqgdudNZpwaZyA0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAavPGx1DqLAo/+iIJFrV88zdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmMzNmU1ZjctNzc1MC00Zjk2LTlmNjUtM2Y0MWMxNTE2NGVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjc4MmNkN2EtOGY1Zi00\nOGRkLWI4MzEtNWE2ZmE1MmZkNjJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSQNc0glfu/8MgW8F7BdnRveMvZfKQLVOw9Zfm6geCCae3ki9uTatjL4hY9YRhNr1\nOXPsqymgi/cckBz4P1877aNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUH0s2OOErMrfkINMa\nUsxqcECS4rIwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAIMCW7U9uGhxCvrkgskjI4KgL6fv2NCX2wRqXTHMSTYHAiEApSmZcrhS\nV+ksz6jbdzWPN1ERgPz30eO3z9wDNb43KLA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8306", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8306` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAax/R6tvZn//wQhyc3p6iPtiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2ZDYzN2MxLTMwYjAtNDJmNC05YjNmLTZiZTY0MDcxYjlkYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDkxMDQ5NTQtNmJk\nMS00MDUzLTgxMGItZDAxZThmNjEwMTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnxRhePxglPUIfHUOFdYAE7Yx+yQ6KJbkTFcMG8JEXQ0BLLpYe/2in89X3el1\noREfuqncPO3/oOX1Trxc7dg+dKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmjPFMw71Q8hLKQJtWth5l2gOzMkwHwYDVR0j\nBBgwFoAUC1Aomzkb4o6FzSmkXTqt7xJ6TNIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDk2p3PZCBQk3o44TKeLbFSJGlIYHnnZsaWwSajFL8YdgIhAK9N07eZUWyp\nzoXPdirJnzzx79noqpVtAqkk7VVjKwOm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZk39JD0zE7lrp0jSAIiIJIZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNmQ2MzdjMS0zMGIwLTQyZjQtOWIzZi02YmU2NDA3MWI5ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHZaWusoYPxhDM7l4gx44YxOcpcLnYKoYf2cPhixIqn/gg\nuNGkDjRW70uysUw9LwZhOop1eA3OwCUwJOXb3yiAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC1Aomzkb4o6FzSmkXTqt7xJ6\nTNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXw0FbpweJgkhTKsLbDS3GmpqpPHRPoR46miicY6GgzoCICiID0Uh5jFZ\npKqHRbLisJ3Rv81CZGt2x5Bs/F2kUE0u\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZJOKJJ8laGrU3z7u5vNxPLAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDkxMDQ5NTQtNmJkMS00MDUzLTgxMGItZDAxZThmNjEwMTQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmI1MDgxODItYWFlZS00\nYTc1LTljNWMtNzRmNzkwODVjMmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nG0l1zkjw8DAnCdMdsyHh+TaQNMIqZN5V57F60yW71BJzYO0netemd/nrCIoKctgr\n7vZ6ab27hYZsT7CzoSz5C6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmjPFMw71Q8hLKQJt\nWth5l2gOzMkwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAKVFq5M42o3asV+sCwW7yQB4jEp5uZfEiCIgyNxUt0P1AiEAhhbdQ9Sq\nTHFJPYLyeBol2bpgv7RpHhHJUO0zD54nSwI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8307", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8307` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbNx75CDncr9vHmwljsyA1fTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MTk4ODIxLTIzZDYtNGNlMi05MmIwLTUyNGQzYjA5NzMxYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI1YWYyYWQtMzBl\nYy00OGQyLWFkYTQtZGZmN2ZkNWU4MzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC7rGZ9OiqV3zBX9kfXB6JrXTXwZULoh/BRjazYTBjnyAfWWCHGYi9x2Z/ZpX\nkfqDVYyf+Gvry4liByooy5igeKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULxuq4h+/7rdwrjSqsCdMVH6cXqQwHwYDVR0j\nBBgwFoAUb1EUVdYFDicHYCF6T2fIXTRJGdYwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIGsfCb8gcFdSOL1uwun/J23BsluQcbqExROp+Bljdcy4AiEAoqNqPEX8x5iG\n45aeAgvp0nKzODJZLOVI183fqul4Z4k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAds3V90YFnIPlzUbikrFIgs2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDE5ODgyMS0yM2Q2LTRjZTItOTJiMC01MjRkM2IwOTczMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARe3IXlgS4P8FXU2S02hpprYozNVkwYSntua6mq6d9XG6QJ\nSEKCCTpwVmgObBUltoVmIgleDWnrCj7L0CXupZy+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb1EUVdYFDicHYCF6T2fIXTRJ\nGdYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKqhSbkI5WZU7l5/gf7yOKO6H0zKm0o9+SyQuo3qEzqUAiEA2bl3P3iM\nlTwWUXQ75EURcqWu5P8Kf6ETqXZT36tijmA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVpbcFbNsaNPD9QP64ZM7t0eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI1YWYyYWQtMzBlYy00OGQyLWFkYTQtZGZmN2ZkNWU4MzM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzkyY2JlZmItZGQ3Ny00\nYjEwLWJhOWYtNmNkN2QxM2FkNGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzfYPoidINPjEwRVrU+NeHfbMGNtnBt7nma7gB9BMmgQXae+MJ5bCBLC8nIbln7p1\nrrsAUhSh0b1+n+h6RO5B3KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULxuq4h+/7rdwrjSq\nsCdMVH6cXqQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgX/BtKrcN+PFmWzekk6Fm8bPD0AJ7zzcoPYfCARpQ7rcCIQC4tIHkOB2l\nwVhGPuOdKaZ21Xna2fDT+dZnJbIa0srOXg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8308", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8308` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAa05jU2Euc0X0cIinvKl2Xu7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4NDE0NzNlLTJlMjgtNDNiNS1hMzU1LWE0YWNlZDJiZjVmMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM2MWRmNDctNzgx\nMS00ZDdmLTljMDMtMjc1ODk0YjBjNGNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMqbjWvf/Ze9f49Bg6xUX+pS410X148QnIlfWtk+Wsu9s5q5Uwe7o9IoJj8bx\nCsQyRfddz0OXVNBv5y6b/Tv3yaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUogG/qLEdYoX/Qim4tzUnp6t4FJowHwYDVR0j\nBBgwFoAULB+y375hDGzC3BonfuPcynOi5PMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAg9ommXEy/MI803vU1C6PTaVa2eMlQiHyWKZXOnSTBoACIAHtBIG5iW6r\n9wl6pgQtCkGMn6nf2BylOd4gwYNcPHE4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVa+IcoXDJ0sysXhju92h+CSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODQxNDczZS0yZTI4LTQzYjUtYTM1NS1hNGFjZWQyYmY1ZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJOr5YoxFjf47F/uTDHxyb3EXHJgSKcFDwFNE77bhdZ920\naMUW/7UnJRr3tD9tc1AH9KKGiNl23EG4MkRmbxXPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULB+y375hDGzC3BonfuPcynOi\n5PMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhWlFSN10Sl1dbp4o+LJ63WwrzHGnNWR06p52/ZqK5wAiEAqSKZuYaZ\n1Kbgf9WscasJ24JOVo++B5sCAWQA7b/7zkA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATNeQAShB/xtOUGMrE5DYU3XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM2MWRmNDctNzgxMS00ZDdmLTljMDMtMjc1ODk0YjBjNGNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGRmNTRiNjUtMTBmYS00\nMDJlLWFhN2ItMzZmNzhjNmI5ODM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nru4y2Wf6g3bpqy5c/Gz/FU/5JgV11co2hIAQqI0QZFqgOMBIVaGaSaXuu2OUbJYq\n4pPXh9zX2zUiIxF7ripnDqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUogG/qLEdYoX/Qim4\ntzUnp6t4FJowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAJMA3ODuZ1t6mSMtS5j33hyNVtdBn8Ppkkf0eV1H6NahAiEA/m9xTDKS\nbrXSKxysntw3ITaXSt66fS4kahX1lsbFLlk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8309", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8309` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAbXBh5oC1gYJEY5EDnXESpDeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiZDllNmRlLWQ0MzMtNGJmZi1iMGViLTgwYjg2NzQzMzg1MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg4NTE0NTEtMjVk\nNS00NzcwLTliMDctZDYyNjgxYTk0ODM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+6hQhcBSXGN+GEpJe/MZKERQdZ+27a0DgJPkDYIS0Mltmaj9lr6kwJU+kxpA\n4to+NVa7ByN1JDR6DPjL0LNYwaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ5R/DCoNyuLXFzB9QJlg/xlIkpwwHwYDVR0j\nBBgwFoAUhRZ/jTOHBvCtijYOCi3JMCLeA40wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiA2l0H16gVMrWWFcaXgjM6sk5XkoOGgsgW8cBqHTzuX\n5QIhAM6Eh/2kZIWNn9ADuI2wyG0J+KmpIbuq+M0k6/hR/cxP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARgqPp7a3CCaZPZqL8EJKxfnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmQ5ZTZkZS1kNDMzLTRiZmYtYjBlYi04MGI4Njc0MzM4NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEm1W0U+qK6sVTLbL6sqRV7E4Qpw84V6mEFDOQiaLXT557\nCB+upbmdBgMbLOZ5FbfgY7JnYz2+buXi7ZyubCJYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhRZ/jTOHBvCtijYOCi3JMCLe\nA40wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdGqmwOig9ntSiGxPL7V+4Fy+NH/ZgeHSEEZGaYyyqEQCIQD4krfYeNHJ\nXt5abmOT/tJrgBYUMsjzT1dXtseUViFudQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS8JrYKEjPZGnov4TFK5nfwIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg4NTE0NTEtMjVkNS00NzcwLTliMDctZDYyNjgxYTk0ODM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTg5OTcwZDEtNDdhNC00\nODc0LWE2MmMtZmFjOTFkZDU2MzBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGHYKhLg+Md0EDiAf4zm1RHnU7JJ6CjtSKZgoPmC9n086GmFj8BebfmPqAtgPQtww\nt5apt0q0jNLv6ckEqT2ErqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJ5R/DCoNyuLXFzB9\nQJlg/xlIkpwwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgPK46BTPEns6/HMckaVQ8v5kGuUg9BItFSI/9NXYONi8CIQCRPqJ8Uki0\nNwbg52kmUa40fqp8fMeBX6V1pIDkyYaWXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8310", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8310` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAQw1vJWa4WabyHSQ89Dig7onMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgxYzA3NGVhLTIzNzktNGYxZi05NjMzLTczOTcxZjlmY2FkMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTE2NmM3NzUtYzRi\nOS00ZjZjLThmMmItNjAzYjg1NmM0OTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERkP9y4rW6bNS4/r8+XEl6iCOk0TgaoyWwkS2SHdkeJ/7x1a/knsO1vjiRH1f\neARNawKf32s3cJnsMsEOC4ZeSKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsUIWCdmXmPsOntd5wBSzthh9ExUwHwYDVR0j\nBBgwFoAUGwao0XoIAK7n5bx2goXGgUdIZygwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiBkRSyIXPof2/UsW8lqfagirV+kHDkwE4Jjd+fZISNV\nhwIhAPLmSUW4zbGCEPb8cwd6EpC2lbIv9IMJm7YyLAJgPj48\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAclWYXCxK6Il8Rd7nkOZiAENMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMWMwNzRlYS0yMzc5LTRmMWYtOTYzMy03Mzk3MWY5ZmNhZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvARkQmwM3XgUVTD2fniTkZqBINoKvYJ1tLPiHGAAqP+eS\n38TfQo7W6V2rlAQlspXpt5vk/O/19iaczU6fL/tWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGwao0XoIAK7n5bx2goXGgUdI\nZygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgczPv4lM7Cgujv4WltvD5nmc+bb0xLxq6+XEaY5kHLGcCIGtqz+yohrb+\nSSixxoeKSY1OokSM4CV+3r8jWAdXkLD8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXmJXKvnLCKY+xwlbzg2L5yWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTE2NmM3NzUtYzRiOS00ZjZjLThmMmItNjAzYjg1NmM0OTM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODcwMDkyYzEtMzkzOC00\nMjg4LWEyODAtNTg1MzhhNDNiZTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDJAkcXkcpoGOL9O8LyW6NB08VkIT03VR968j2p09PJa9+EFz8Icu8kx9XZIjuu3D\ncJ0VED3K5pkR6SBF0pGybqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsUIWCdmXmPsOntd5\nwBSzthh9ExUwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgUR2eGGqgKVH+hgoB+e1G0w6iG5cn1N4FvM5EVQ3b/FACIBf6YcoIzWC+\nCQXPLQON7JcCW89LRBXkf9elj9nLMQjj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8311", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8311` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAXr1Oikt1dpNyJmJbBgFGZNtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmOTU2YmMzLWQ0YzEtNDQ0Ny1hMDQzLTEyMGE4NmMxOWM2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJlOWJiNTEtOTQx\nZC00MTA4LTkwYmItNmU2MGVhZGI3ZDhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEswqfmee7fj0zuca9Dhr8b/6kdEBnLAx27c6+iJyWTAzVygVbjEZ0JmDUIK+B\n2/8rxHl7OIuwdQWHewHUT1qSG6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj2EKyKWnAYnDWBwCMNAc0aCTxb0wHwYDVR0j\nBBgwFoAUIz2QkMFB5bDwMVumULMnRYVkD68wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA19IlkRFHpmQEBnrr2U+oebbTDd3w6lYzrBwxUSt3fCQCIENR\na2n6BbPHSlXS08qcdnX6ruAdhIs5lXoWE91nWL8q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZJiPj2Knb9dMYY/01vDMzk2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjk1NmJjMy1kNGMxLTQ0NDctYTA0My0xMjBhODZjMTljNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaiRy/vIVcFA0fZQlNmU4pmtu4vO/PDnTkIHgvp6+mEwaH\nxHxqg20O/o8vva8D3CD5aF1/Uzff5r18+mfjlzH0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIz2QkMFB5bDwMVumULMnRYVk\nD68wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSZNhmEfLa5VCOR7SZFEutQfpQ0QJHlZgVshYg/T6KHgCIQC2jvhcmfFT\nDD4shJvzfKXa9sXnu9Zc8pDeMZnYHgT4nA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATofPMmAeMy4nOqN0W+IeIWVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJlOWJiNTEtOTQxZC00MTA4LTkwYmItNmU2MGVhZGI3ZDhmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmY2ZDhkYWMtM2ZjYy00\nMDFmLTkzMzUtY2FhMGVlMzBmNmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nP8kWm6WS3OwMW8Ah1hqyGoZ8ZCszatRPYEAD0HSNHN5YREkFtLn3fVVSXJ7tFMlN\nd983C4nWtOnMgiMol59zKqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUj2EKyKWnAYnDWBwC\nMNAc0aCTxb0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgZSFFOaPuEp3feTnLoWz66JPaaJj7/1kXO/fAq/8/aeECIQCja+3e46HI\nME+icKQWBiUcS5eoeV08PKYjPAQXZ7+Rng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8312", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8312` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISARyiRhDItXwOfTBGC6nfqDG9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlNWQxZjE4LTk2NzAtNDQyNi1hMmRhLTAwNDBjNjk0MWNmYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI4NDRkOWQtMTZh\nMi00NGNiLWJiMWYtNzUwZTQ1Mzk2ODM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBaPsPBoNiOuhrah/ikyp2UtP5L7cZj/X5O8jRu+hhz31Pjy5GGopB1LG2LxQ\n/lzW/Bv8o4k4yPEzf7OB2N5LFqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe6q/SjEmGV6dVwsAOEl3qA4RMDcwHwYDVR0j\nBBgwFoAUdJWiK32gdmJBbddJswJPsh8MMkkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAkBkkJ/xiXAngoXKdeqZuJPLmTlVgXpPzX\nmbUaptmLDgIgM9ZugG1B2O/7+4QNgvOjTOjyO9APY+8xRVUtAZKXjPU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdZm0magOnxTUBw4VZN10FqbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTVkMWYxOC05NjcwLTQ0MjYtYTJkYS0wMDQwYzY5NDFjZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATICoaWp9ngcCwVxoTfIJDJWErY+jB3UTVLpPG2f2qUL7et\nlJd+Tox5bizOUqCU49dPsPQnm3uVBqKgc7DDECJGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdJWiK32gdmJBbddJswJPsh8M\nMkkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANPnoqbagQ2WXseZ2BNkTR2CqsSOnI9rrjUhJ+jVkNqVAiEAsqRgedvt\namUjPS20OeltF6OGlBFeJfdsmXgkbDpHiPM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVc1HAwO+ER0eGwGCfvPU6RlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI4NDRkOWQtMTZhMi00NGNiLWJiMWYtNzUwZTQ1Mzk2ODM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzY4ZGJiOTgtMTljMi00\nYTM4LTlkOWItZTIyYTU5NjQ3YjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNkvmQkrdq4oWMD1qXj/52Noh+9EHiB99IpTIIS5S0VgI1oFRqMlQNcPy+siheoQP\nJsqxKlIT/83Yi6NLY6U5ZqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUe6q/SjEmGV6dVwsA\nOEl3qA4RMDcwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAIrI/Ba9dkQtkywowuxQtDfJCW+d8J4A+Tp4aiJqlIxcAiAF7kdO2vqd\nkon/qRRZzbIbh9Ao9B6x7+C6ruLcQ25e0w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8313", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8313` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAXnxvSZJHLZJ4b3jJ5kw4TPYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2ZWEyNTI0LTg5NGMtNGE1OS1iNDk5LWIxMTI3N2IxNzQ3MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjI0MWE1ZWUtOTlk\nNi00ZWMwLTk4ZWEtOTljMDRkMmIyY2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3lI3C+UW3QOdhBBDEwCxN90Y+P7k/cuMKWlBg6mTWAz7Ulg/WaTp/kwuBkMT\nKdWshbO5RJK3O7zVWqhjAYd0q6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU3JADaUbzxD1zDR2UPl4dkna/pAwHwYDVR0j\nBBgwFoAUNhbyjeP0HP8rL5CyByBmu2bNVbEwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvtyuCysSJ3mnyuwXDA7lm0k5Q6FL0b8v\nwCyLFFyNSFQCIQD3uzOfXX941AJSx3EXW5ZquC+pDrO/EEtsW65dleSW3g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATFl29X5pTvMoU+afSsnz8HPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNmVhMjUyNC04OTRjLTRhNTktYjQ5OS1iMTEyNzdiMTc0NzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuV5hF6gytMcUHLfvTeISm/tyHigZ2tpGL6CVATD7EGoRw\ny/W+AJFIOxTtb/neW9A0WfxFWkst74rmgmtfXz1Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNhbyjeP0HP8rL5CyByBmu2bN\nVbEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD/0Tg0JFT1pR+dXvcvB4V8pLVJprAQ38DZjdsQV3wZsCIQDFmiQ8j0sC\nNIUkbCBzDf75FLQwjfhzVkn55jl3suXr6g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcqbT/n8qQKDUl2SvZXbHo3VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjI0MWE1ZWUtOTlkNi00ZWMwLTk4ZWEtOTljMDRkMmIyY2U1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjNmOTVmZTgtMjI0My00\nMTBjLWFhYTQtNTBhMTlmYmZjMTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nL1h9UW/6XphngxIM+iZh1DVM4c5f14T4Fcgf6IKo+JDNXqXn+FlfYDhYvR0S0K+2\nExYrpywJigKPy8X83RRjyqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUU3JADaUbzxD1zDR2\nUPl4dkna/pAwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgSwsqGhvMzcuaDVeqUg6fRIrui+z1FZO2WrO0QRKZtrQCIF5BvorqEV5M\nLfDbvG3SCEgSNjs/t/Qy/YkaLB/s5Uxm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8314", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8314` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAY4a07dhzNsbQoSzM6xvl2OyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3NjEzZjIyLTU1NmQtNGE3ZS04N2FhLWE2MWQwOTkzMjg1ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUyMjAzN2UtMTZl\nMi00MTE0LTk5MDItNmJjZjBmNjkwMDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH6fY/aygW2CbVEU4b2dT0ywwDrzcK4edGtII2aTgx6bBb0u9RfQMUtbLyD6I\nT5lmCdFsTfC/PN4det+1Bkz3aqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcR3/u6pBX6SNvaNe8nmWukHHHRQwHwYDVR0j\nBBgwFoAUgRwOJJol4IAtDIQEXNJp6betdecwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAEFavoDx8ZuSrj\nC4xt9M4Wi/Nx1Po5rDittsso6VDzjgIgeFwg6Q4FxhVls5RP1zu4ZMcbvI1IpPl+\nzfLoo1hkxd0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXeBTeNqvQQRjNAMJ/4DlMsfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzYxM2YyMi01NTZkLTRhN2UtODdhYS1hNjFkMDk5MzI4NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBb8An6HXXDyyuJZXUXkUXdAl6zwZwNKWH71/88oz1GBHA\nBecih/8K36kK3duPLQWitqDpVhMGobRvFRBUu0NQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgRwOJJol4IAtDIQEXNJp6bet\ndecwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgChgdOyYSgQ58GG4zbgYw9mcUlYdX69qGhhAfo8jNvvMCIEzb1Qliveeb\nQJU2abgZczi0PjRTo7jgEysMeQdNRf5s\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAamkg4ALqbMRXkL3xoQsv8PpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUyMjAzN2UtMTZlMi00MTE0LTk5MDItNmJjZjBmNjkwMDU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzVkMzYwYjYtYmZmNy00\nYmU0LTg2ZDYtNWUzNmNmZmFlZWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0Nhl8RImnbg8JQcfPN5nwK04LH9JaLPcOVzPBtW9kU4K0hlcMH/svaZjIBiAPHzD\nYShZMLOyBKJujIWaQujGl6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcR3/u6pBX6SNvaNe\n8nmWukHHHRQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgVhu4ykmnfGcSlD5vrmbU24+ktjPM4JY0TqUgerqu9UcCIHbzt2uiiAE+\nABSeBpV7BhIGE9EyTjHZqvU9Sc+6Vi7i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8315", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8315` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbxEjSU0xG+7qEGlqSyhdw02MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxY2MxZDM3LTRlNWEtNGMyNS05ZjIyLWU0YWU2NjFhOTcxMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk5NjE2ZGItZDFi\nMy00MjMwLTk4ZTUtMWFlZjliODljZGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMwxKH9T2L6wj7DdEYot7avwU/L5ouJxaKSMXdNR3MdERC7B1AYAwSoEwsGYV\nvRA6MeSvjHt8P85gxz9gV25sjaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnt6JHCUpJIT/RCO9Jz2jqYS3LgowHwYDVR0j\nBBgwFoAUbjyX3RmUf5uD0zJgL6qZHzDvAecwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDmREEbjJVILzvnWupnMaL8GVHAFHX+p7IkP4+CzQl7oAIgNjsNhrJQQaW7\nxPg3lvwNhK1sjeEKv7+q/cDRhmU/6bk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU5okw2pJjs+YgIa1m+B1hhNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMWNjMWQzNy00ZTVhLTRjMjUtOWYyMi1lNGFlNjYxYTk3MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTrh/sonr0SAJLvFgsIuXaVa5HBj9XYsHwGg7moFMhWva7\nR9grf1j4N7VB4NDh+QGYLOPfuB/9HG9sqWRvuC97o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbjyX3RmUf5uD0zJgL6qZHzDv\nAecwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeZds2oK8A8I8WHtTUIEE6hPHotBdbcqned7srgmx4QsCIDYX3Nh6tt0O\n01ET4Ag0L6IXZerY6uuAIudcp434Pw4a\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeP19E6Vw/MzusshkIeMe0e0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk5NjE2ZGItZDFiMy00MjMwLTk4ZTUtMWFlZjliODljZGE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzJhMzQwYjctMTIyYi00\nMTM2LWJkZTEtMDMzNjI3NDYyMWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nnARYEUl0p8DDKQz2I0GDfKXvHEjSDQ0RKN7vt3fPViByf1zHC56rxydzgbi1SMAx\nTd/+Mycldqgarre2WLBVEKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnt6JHCUpJIT/RCO9\nJz2jqYS3LgowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgMhIF9zfsr0CVjg33qayUuptexg21n/BILdQUjfO+vdgCIBAbsaU6AA0K\nXixvfuS+jnTHOLFsOEY8f8ZS85Fb7qjt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8316", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8316` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZvS0h56lOYE7orfRhI7Mr+qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ODg4ZjI0LTRmMDAtNGZiZi1iMzZhLWFhYzdjM2EyYTcxOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZhNGU2ODktZTI5\nOS00MWI0LWI5YTMtMzU2NGZkMzYxZmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErUPIK1otxrUJCLqSzKnMYOKnmZ8RrsEcTb9Qg6aOVJKJILAk/+WsRAE0BE+W\n7Anx3N95t3FH26KmgfMDF2MyOqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVOr1edtteg1taTIJV58PYPZCIGgwHwYDVR0j\nBBgwFoAUjNBw9LZLy55IVv17bJtvb4mpozQwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIC4GVL31pbrUee296+/IczxnuzOY0UiYlowujZTRzJ8IAiBjZbjTT995vc9J\nxr611E6ViXTRnOHB1rNpNdkTqwrxLA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfelW28Jpx5ttaGbI7sLKf2FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzg4OGYyNC00ZjAwLTRmYmYtYjM2YS1hYWM3YzNhMmE3MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvCPf4P/iQZ3UI4b1sDAEU1C9Fvcq3E+5OA6Q8ULqZ543u\n/ogmyjI7LXjmevz4Qw4cmWHv7HI9IPUWPK+upaXPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjNBw9LZLy55IVv17bJtvb4mp\nozQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR7DnXAdAtJgi+hvucBLT8GFAlntKB4TsZO/2E+hKnqsCIBTwGT9Jlh2d\nX6PBlRJ9TalGNdU/0exCkdBrNhd+IKza\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARLRc99hBroLxbYGPYyBdiFcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZhNGU2ODktZTI5OS00MWI0LWI5YTMtMzU2NGZkMzYxZmYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODY1ZDFkZDEtOGUzMi00\nNzZjLWJmZDItOGU4NDM5NTJjNThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVJcxapfsK4bcIs6p991CFD1I8unTZzuByDAxkc3sJxOKPgBcta21blmapNMM8hVh\n7hvY08qwvHHGdpMXJjIiZqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVOr1edtteg1taTIJ\nV58PYPZCIGgwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgEnsOPn9X+Jhwa4kQUn+NB4EOLTd+oz7/FfyqvgUp8h8CIQDBYOFbHS0P\nz3mxQ8YnyPGq7Z/s+bzRBP75YE+o2x/AbA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8317", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8317` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAVpsicxiupSKoyqR+Bdx1Kr+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwMjg0YTYzLTBlZmYtNGM4OC05MmFmLTZlNmIyNjk5OTRhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzRiNjU5YWUtYjg4\nNi00NzdmLWExMTMtNGZiZmI5NTlhZTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUfYbHEMPSjFgzKSUYPnrPaijfomabIzEkA2MdWcz+egd6RAHEelVA1b/rva5\nNY4q2uVbKFicLsnygGwjTo7zhKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU40Du+6AUdpciYL5GjKINSPjwf+MwHwYDVR0j\nBBgwFoAUoOsJqOAu9zQRT0AYaMmRoyTcvMIwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiBKMAtGSKELgjnnTOZOhW8pDBZaHt2DySswlLZiMTwaowIhAJg739r14NDq\nHVuEGTUs6qlt106qtuXc88idcYvx8CZm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUaE6XaLrnv27c2SKUhj6WuDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDI4NGE2My0wZWZmLTRjODgtOTJhZi02ZTZiMjY5OTk0YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgcZ1IvqfOOJLaYyYufVt37rlVlUAFxAvGY/oOJuQuqLag\n46n+zxLIAeIC2YvA+QPAQNhH+PgFnxKHBPavsF9yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoOsJqOAu9zQRT0AYaMmRoyTc\nvMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgR6Xa12N4tekyU4l4Uyjk3iJPmb0hjxGAxWxy7E3bu0ICIQCtNgLkfR1A\nSvffabkzMkV/C0y9d2Yqu7JNZqCH8K1lig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZVSy9T4W9iYvCy60yGwKXMFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzRiNjU5YWUtYjg4Ni00NzdmLWExMTMtNGZiZmI5NTlhZTY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTdhNTM5ZTctNTNmNi00\nMWIxLThkOTItZTg1MWQzOTFhZWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPJHJEeEJccQPAHSy7xZGUeDnsDVTca7WeorkuQzbj5awnjYGiPEl2cjxFaldrBbu\n/LnMdPBe3wugD1nl8zclYqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU40Du+6AUdpciYL5G\njKINSPjwf+MwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAI1cWNEwMc24tRQhft2FwPL8LV2ik+/f/97YBu44XuPVAiB5sjB9pOXC\nbhwgbS+v//dL5qOKoaeTByE40Dpr/7LKVg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8318", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8318` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAf+8ELPpnSJwOvcgzYlnyfhfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwNGQ1OGNlLTU4ZTMtNGFhOS1iNTViLWVjMTNkNzI4ZmRhZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGJiYjM1ZTMtNmYy\nOC00NmQ0LWE3MGQtOWY4ODJiZGJkZjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKI4+iG6X0g3Dnd+WHCrjdsV9Z0s5OkLQQVpo0Q7g0JCW3W5D1dwDNOtHeGxg\nPRI3VKK/DHlfoNGWKjzuGp++4aOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvUe0TeSTWFz/TAwS7qEEJvaOtLUwHwYDVR0j\nBBgwFoAUYEpmAHAVr6Fo02KmodgFsP1ECOEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBG46PXXBWlDXjNgtyS3wYkaUIWgprY6bnhURxSWGUw\nGgIhALbNfHMSPss9XuER/28DLaEcDhMyj0dEYVsLMFa0goWl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY3MBABaDhRd11OjiZicuXfPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDRkNThjZS01OGUzLTRhYTktYjU1Yi1lYzEzZDcyOGZkYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeu7Ozx1hiRshfifD5BCrW08Pbk1RBq9jFsfay/N4FkXQ0\ncnTc4BPw1LLFQcj+OThoVEQj1zY5p46aLlnx10jBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYEpmAHAVr6Fo02KmodgFsP1E\nCOEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKhDAhMUThJMXCmxYru13jVm/63l47MiBjyQi/CUNi3kCICCIaPSy0q4m\nwvWxYKdaSU3BLKio20zPt8QLzTn4UpqV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR9jlKqxVeJxv+mRbi0Da13eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGJiYjM1ZTMtNmYyOC00NmQ0LWE3MGQtOWY4ODJiZGJkZjk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODFhMDk3YWQtMmVmOS00\nOTE5LTgxNGQtMzc5NGY2OTM1NTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBrnPmoE2O8+sRwZV+ZSfgf3v57J45EA8x0bpMPz5ieRGm5OUv3jMiZUsV2RMF1ky\ng/xU7m+Nf86QvldVOxPnWKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvUe0TeSTWFz/TAwS\n7qEEJvaOtLUwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAPcnvXIfMPZhAat5bdLuQPrmSslY5ZKXX9potpjBfkW9AiBhsppqko8k\nztfkstjX7hONAcpwVx3NfBWpMVOUXQqiGA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8319", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8319` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISASRGtCZmHg7p+0dtBmTRGOP3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyZDU4ZDQ3LWZhZTgtNGI4OS04ZTQwLTQxYWJkYWRkMjYzYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk4ZjFjZmEtMzZj\nZi00OWRlLWIwNWItN2Y3ODNjMjY3Y2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbY427mNFseEzN/1NEKBADkMfxZMlozk6UkkVsg3XnGkCp1v0xCqPs9a7erbc\nJAN44MXsCo/rka7XT4PQ02MkK6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaikFLdff5qutQNuq1gYnqevirQMwHwYDVR0j\nBBgwFoAUJ6JdN38P36ES0v7yfuI12qF+ysAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiASVK3L/ggfhfLcD1zxngwgByYh3P41BL6SpGyW4xAl\nvgIhAN68SNqfoj/HRu3led/HX8QvS5LE7BrhGS4EG4zS7YA2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQXipUtVqZhiPz4BxMZXhYPJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMmQ1OGQ0Ny1mYWU4LTRiODktOGU0MC00MWFiZGFkZDI2M2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4fYhxuvU2NEeh1Un5gAM5VW7b+enSdtGoarWVFr0LzFKi\nAzbG6+KMqwvlLWVwLatBLnkElVc1GPJB/UicTzEvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ6JdN38P36ES0v7yfuI12qF+\nysAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKwAgb0nfaJ2HQOf9gu0H3JoIRt/l0svyiZUjrgfwhhkCIQCeKx/f2JDP\nsTLQn6iD0kph0p6MGb+2E++6VIpCvzUKNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS05zQ2gSAx9tjJSzbeJNiZnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk4ZjFjZmEtMzZjZi00OWRlLWIwNWItN2Y3ODNjMjY3Y2Q1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjExNWFlNTYtYzM0My00\nOTYwLThkY2ItNmE3NWNmNDk3NmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDgNmHSGF3Bd/Z/dHNpKVBzgge6WMDjy8gG2C+LtfFkbCcXeR4JFC/XmMVb8LspoZ\nQGMsl16tb2grr8X1D6kDeaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaikFLdff5qutQNuq\n1gYnqevirQMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgYf6eCbaTJZo8PQnFiCBqzSgdmFc+Xmmo9O+2G9f20zYCIEc0bluTZnmS\nEVHwKMR5XMJvJQUoimBr27DmJG/5tW01\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8320", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8320` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAUREtauTF68Tk3W0LKnQLIjxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3NzBjNWU1LWRhYzMtNDdmOC05NWZlLWJjN2NlMTMwOThmMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBkZTE0MTMtZTBi\nZS00ZmU1LTlhNzQtYTQ1ODY5NDg4MTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl69a8ZQzMXmX9DtZGEflanhbnkCu5vR0dr+mBTn+ZO8KhjRZjW8VsnS3/q/0\nUTZ9etkvXe2V49f9V+ebO43VwaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjSgM1tESfFjxsRTELI0CQVBzEPwwHwYDVR0j\nBBgwFoAUBrXCiOzOGd+pPLbfUpdw7pfpwV4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiA5zr5GiQP6SQGfo+1P2i0U8YytPG5sSxfOzaYOv+txOQIgRd9p\nrq8UvpHCu7n+zSx/ZXbYi6cZB0gcFWA1L2kSnwo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaONIDAK1GqMjEFKiHdoUidsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNzcwYzVlNS1kYWMzLTQ3ZjgtOTVmZS1iYzdjZTEzMDk4ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQn64P1JWR9PAfDWUKJuk+H802Q1v1bgiV2xURO3jaS4exg\nQZOzACr3IbQ2I/2xXKy8QylpFt9IhNGOxJnAeFNto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBrXCiOzOGd+pPLbfUpdw7pfp\nwV4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeQv9bUV/PnElQiDJFZsmyGS0bfEU2wp0uHSA/eTsvj0CIBwrivFg27Eo\nlqyR244ZmoYiMw73+9DDyn17Jp8EaPvF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWfDp4DIhVF7d+vhtOHdwy0HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBkZTE0MTMtZTBiZS00ZmU1LTlhNzQtYTQ1ODY5NDg4MTNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjgzZGI4MzctM2U1My00\nOWJkLThmYjItMTU3ZDJkOTRjZjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nd3fj0HxL0QuWKA0Dlb2FpOw/5G7qxlS+nju8LjrapHrNUhtws/n+YNKxDk3Pzx30\nAr45/Cu94lIJl461Mr5QqqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjSgM1tESfFjxsRTE\nLI0CQVBzEPwwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAJ/hKjOeEmjNasGo/FfZ+3d8Vd6XS2xlbim0/Dhldtu0AiEArIij3bOP\nyrqcpxTnolMEKuYpj7VuEe+Eym5Hbdqw+LQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8321", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8321` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAf97GjMrkDFw6KtnY1Gsu5rqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxMjEwNTU2LTRkYjQtNGJjOC1iMGE2LTllNjgyY2MyYTk1NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM4ZGU1Y2ItNmM2\nNi00OTQ3LWI5NDEtYTY2YzcwNjYyY2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiYSe+Xi4ue7D5P1F311dV2ruFYqVVpyofx6EsXZmWeg+yZulI907C2Sp0X3f\nARf8I+m5P++aT8YjsQsr3eGA+KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcgzKtz9DcXQJCbgLR6uooztj5pgwHwYDVR0j\nBBgwFoAU+AjlswBFDp5JK/Cp42yy33poIscwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAmI1dqEqhJ7tyiuKj7qnNNa+eSeWrtzPG\ndxvHJDaKpvgCIQD6e40pFJzR33coR9MKRR1s56FFM5CMHiQjFSBSUdIwTA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZGbNDtgbMi76YGkwXbjQFVfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTIxMDU1Ni00ZGI0LTRiYzgtYjBhNi05ZTY4MmNjMmE5NTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5ZGeh95q3e0/AAvPSPVBOG/xKMuDcOj1glSyVWzvmX8ZD\nT/i+Wv0g59z3ZSx9e+R9BfV/tvHLZdOOBvtU2fDRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+AjlswBFDp5JK/Cp42yy33po\nIscwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL48WYOBqB8y+oZrZriTJQ3Oazxtn+R9pG5fwdY2Ju0YAiEAktr3xEAB\nRMxAXpQ06WX9286escCa0nRM+7fWActcfkY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU0hPZB+40rGwUFor1jyyXmxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM4ZGU1Y2ItNmM2Ni00OTQ3LWI5NDEtYTY2YzcwNjYyY2MxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmMzOGZmMGYtNDljZC00\nZjRjLTlmYWQtNjQwZmU0MTY1MzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTudyVozbPMBg8/It8VVDO1TmZtfvrGZEK7L6rD+Fwo60Iwfh00EZpdIKwMwyApNf\nDGWORZXGFgBr7G3VO5SxE6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcgzKtz9DcXQJCbgL\nR6uooztj5pgwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgeRjhSd6QmkIdw/LCLersiiQkvhGRBibqMOJE785mk6UCIQC+fOOfjC3Y\n9ofKo+bzau3ijzv+Ka/yilqbgdcYPQvqew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8322", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8322` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAdH82u++VXhMfx7yZH5CYbBGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxMWNiNjNlLTFlMzUtNDY4Ni04NmExLTUyOGFmMTAwZDI2MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA0MzgwMDktNjI5\nZS00ZWU4LWI1MTktOWNmN2I1MTIxZjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5HO7dWatEYTorl0uLw8Bu9FSY13L+p924mit58iDYCyTZLLm8Beg3DzGqg+1\n9DopmLCoqdNHNR9qOMaXPGSm5KOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIPgWVilqZeVh/D7Eb5DGxepmNtYwHwYDVR0j\nBBgwFoAUOdkLyG4c6YHRDXYFoNs5QznK8kIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiA5JQvNOaxNcML0O+8M8dEFrbmAj3vSRwuK\n1Yc/WpgEaQIhAJbfsij1LsvW8520nI7POhX8KJuV3kLsziOKeatguvWp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdig6Pn3YayJATZCIo7tZw4TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTFjYjYzZS0xZTM1LTQ2ODYtODZhMS01MjhhZjEwMGQyNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyep2VRUu42IZH3Bes2lgCzkFu22cGmxAJVzQki43kjfif\nUSJqgfXFKD0Rx8Yf+NHQY9RBILSL9/mBCNmBIDBxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOdkLyG4c6YHRDXYFoNs5QznK\n8kIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLMVw1KI6oO37ip2l1JL5fVgIm/EGuF29Y17pgOqLApQCIQCwnljCRU6E\nLCxxhtSooiG7D+1MjU0m1/LfkYWptnDyXQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaqjgP8VICyU2ovOhj5WkHLjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA0MzgwMDktNjI5ZS00ZWU4LWI1MTktOWNmN2I1MTIxZjEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjI0MzhkZGUtZWUzOS00\nZTFmLTgwZDktMTYwNTY5MzczYjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKMCwEtvodhMdNJPUb2hRbuQ0Q+ldjd9WY/6VlrgeMWLI05YLxubbgYJBx006/YqX\nyop7zn16Pre8Y2wtoXSq4aNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIPgWVilqZeVh/D7E\nb5DGxepmNtYwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAOYUtVY5j1wwJQu/mZHVbmsH0XjuWLyQ8myDoQ3uujO+AiEAyFBodk7D\nK5gamJ18GjtOoeOaoc/3zVFQw38c83DCS28=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8323", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8323` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAc8+KGZHDQ3jcpNmAy3T0sdpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzY2RiNGExLWRmNTEtNGEwNy1hNzhmLWNhZmE0ZjYwZWYwZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdmMjY2ODItMTA4\nYy00YmI3LWE3NjUtZGE0OWQ1YjQ3ZmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh9yG2WLkHxgOtfSbArbKd7w3nM3EWHwbvX3IgKXyObyGUNdzX1Dp9W+HjTAQ\nxk17mtX56OsY86gsP7qOvkA/YKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfclSq6ACK4EGZ4nnoykljicf45EwHwYDVR0j\nBBgwFoAUGqCyWSDQdn7ECUVgFaR2jk1Ouy0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEiCs6sacj/cXbvLrM394nNbwmSh\n1j/UA/6I+JrDcnvOAiEA0NnOXQrvlVjpG0Q5280zw+qIk2Sr6+eMhHdyr+zN9kg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS217tqHHRN0+wxdc4LrKdO9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2NkYjRhMS1kZjUxLTRhMDctYTc4Zi1jYWZhNGY2MGVmMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3q5MsIkucT6zLlhs+GsEWYDOY78HRxtOUHtEcnYikdzFl\nx9nVutX7esSIIjyyT0B2gfS3sOMYulbetUeitUTpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGqCyWSDQdn7ECUVgFaR2jk1O\nuy0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOJif1QG2NvR4LplBlUrahmil73ZmXToGCjMV/yfQAUmAiEAkBKDMYAq\nFAyL/XdSaRAuNFWmYEvLCANqtGRHFC7NyPc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARjYGIDS49KRPrSwHJs5v4X5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdmMjY2ODItMTA4Yy00YmI3LWE3NjUtZGE0OWQ1YjQ3ZmViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDkxZmI2NDYtODgwMi00\nYWViLWFhYmQtYmQwODQ3ZjNkNzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nIis+vyjAsJqDCrz8cLDolf+LQtW8sO736TUOyfWCgAzyspi7IK19EukUl569JZU7\nd/AzDZXRnQ9X1jDWt46QJKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfclSq6ACK4EGZ4nn\noykljicf45EwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAM2VAQIn+PXUU1Juwheh0X+ZKJLRoEIH1xyoG1jjx0dOAiEAjDHQteVS\nNgwY+BSUQmwLrnLuo8a+ja/OKeRYS/sHenA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8324", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8324` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAcOVzuElZgT+U9DZbB80qGFVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljMGQyYjIzLTBmNjItNGM4OC1hN2MzLTQ5OWYwNzcxNDUyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFmMDEzYzgtYzMx\nOC00MjQxLTg3NTUtZjJjYjg2NTUwMzQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENH9VHxJfup8QvF/KsDqDYYa9xioAL8TyG7gGSfiSsIL1GX5lrr6pMSxoG+Rh\nTSXfeNR8Fsqzig+MSj1fSFh/KaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqmwV55Yn4M9KHoRvPMHGSo8DIVswHwYDVR0j\nBBgwFoAUAbdNi5s9qfy4dKO8K/kLRwn3DqUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAOvwoS9E\n2XUQt1f/iU6tCb9PYDonY59bECJBoG6iHTHAAiEAvDgTwfJNNVU6HaruKrjkA4lJ\nC1nfMkUabP+rWZc9LI8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAba1+LjEOua6EAyukhAfeqiTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzBkMmIyMy0wZjYyLTRjODgtYTdjMy00OTlmMDc3MTQ1MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnz3HT/GEbHLse3rR1BC6ftGJDMOwKBy2VhVJyV/HYBxHG\nzt3gQI713e79Vb8JX5Ekw+umMdembdD5vYEp2Z/uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAbdNi5s9qfy4dKO8K/kLRwn3\nDqUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALiOnXpR6cJH+OMZ8yc8sTOvMHniXdRv9l4iIs51uvlBAiBJJnQDq6tV\nCAUQGTmSnHEYl7v+3AtDTspkUo5szq9wEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXrOOPUqGM9w1L64PaybSQJnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFmMDEzYzgtYzMxOC00MjQxLTg3NTUtZjJjYjg2NTUwMzQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjFlZDY1NGMtMTQwMy00\nOGEzLThiMmUtMDUwMWM2OGI2OTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhH3VdBZJwvbyuMvOabjnPoLTa1/II0kkUKqq/O2pVwdgS4CelwJH+vv1WRZ9TK64\n7eF50XoFHOY6eVl0xkpGjaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqmwV55Yn4M9KHoRv\nPMHGSo8DIVswGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhANHlClcxlJk2VwD/pJ78reUNmIQP/J4DJt2plr//CE9BAiATztnA/71W\nAzj6a+PKZva5dL2SBbd8Pzfb3qWa1is5Xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8325", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8325` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAXp2j4TBckxGlaKCOZySASL3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMjA0Njc0LTYwZmItNDMxYi1iOTgwLTUxNGZjNTc4MGI1YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJlZTY1ZDYtNzMx\nYS00MGM4LWI2ODAtZDk3MGU5Mjg0YjJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjNVWTcyxiN/1LVlvN/ODFdDQ4dCtHp/+JmQbQhR677hUXz/Qs8cZscsBeKSg\nYrMHNZ3p6EmtzmvqiSWjICLb86OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjh8raSBrN/eKhCGltwVLFaXhNxgwHwYDVR0j\nBBgwFoAU7WObzcLIinhHixwZgxt4b8dnukAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgcy7wcKgc\n/HzKVYXeIf+IZWNT+yaPsn8uWfsfeqRtCk8CIQD5eWcY7sIQr+Ks7oLET/aEVhiG\ndcGEJWyBCY8VhJlDaw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX7EdERmUUXLfpfFe2G/XSnrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDIwNDY3NC02MGZiLTQzMWItYjk4MC01MTRmYzU3ODBiNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3u9yNPXgtuYKRzT/osKSQHIS5aAt8suVDPpbZV/P/GFPk\nBcikuUjsUyo0H++QOdI7VvEvafDswec4Jc31SKB0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7WObzcLIinhHixwZgxt4b8dn\nukAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOHkdy7g4k/KMsFWuczKKNqRLiM/rVb2Ln6bR4ZbR2l4AiEA9MN1DTW6\n7OdzvXW/YOWDurcSaWTS59ZtzkuTd6PkLok=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQf1TucyUlz04bAgwyVZknAbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJlZTY1ZDYtNzMxYS00MGM4LWI2ODAtZDk3MGU5Mjg0YjJiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDljNGI2NjQtYTM4MS00\nODA0LWFhZjUtMWY2ODliMDkzNTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHq+xL2IPFcpcUQK4MB1eZDjjBmGP2j3QiAztBZ9sTA2g/GTOlxfLqkX3sCchGNtK\nZS0jrWopcOQxTTemEjaERKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjh8raSBrN/eKhCGl\ntwVLFaXhNxgwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAK92vWtU4ITP7/WX2JcHrJ/+hlKXirBcL9hHqiw/YY6mAiBCGLeXVgwZ\nA5Wx3hDPTZHSECSvUKyC8+PNfR3DLFug7w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8326", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8326` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfCgAwIBAgISAdRw2m1LXe+R27pq00ajPX14MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0MDk3ZWI1LTk4MTQtNDMxZi05OGQ1LWU4NDIyOWU2ZDJkNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzg5MjM5OTktNzg4\nZi00YTRlLThmNjYtY2FkZWQzMzI0YTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy0VMPQC1zx6N9NbJPrwjCaUOywawXZUF0BEtKG9Fx81jzxpmBG94Y3NNsMnq\n7LT63l58UONobDXS36PhF/7lV6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU74PhhXoG8Kuf7o3tIlzJap1rEbswHwYDVR0j\nBBgwFoAUre69DzsnspQ5KuqL2/l4b+LrRQ4wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCX6gIU\nhvGF/7+Qd9jsR7VP8pBaiM15xCs8lLGHvFSdeAIhAM4tx3b0SOv2tkuFhPaWmwGB\nJXn6RklSZpgjRLsbKQsa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbZuMny33ihlb56N+PD+4WGgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDA5N2ViNS05ODE0LTQzMWYtOThkNS1lODQyMjllNmQyZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATt9adFSEN8BJm60X41L9f3QmiAWx051hdmtJeowpZEgDPj\nvwCNZRDESc+pOlEfVBXwCXGLEveOSe6tpsRoZY81o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUre69DzsnspQ5KuqL2/l4b+Lr\nRQ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL2g7nwQQ9CLXboAeNg9jXsi0Muv7FNx26ZbB7Ko6/DKAiEAly8MB+RI\nWm187K0nDZ8+2NkK9m2EjrH9qZDuCz2Rp5Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUV9VHsZEHXC0cJXhzTyguj4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzg5MjM5OTktNzg4Zi00YTRlLThmNjYtY2FkZWQzMzI0YTlhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzM1ZTFlMzYtZDQzNS00\nMTU1LThmZjYtZDdlMzkzMTM5MDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrYgvM///6jRgU96eNCSSmYO32u0Me409nvIFAIgLLyWhg5czjhgrxwH/1/WawY9D\nWZ0oNHoMX2DQJsaurDXA1aNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU74PhhXoG8Kuf7o3t\nIlzJap1rEbswGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgArYaZOFI26RV+trD8dgCLpi1rKs0uSIx/0NLPPJZREgCIA7sIruvvMWP\nVjdON7aVbQhJ1zsDRQIeVmnkYXTMroUY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8327", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8327` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAVUComfAlMOYq9fDLlZvR0s3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3NjIyMTVhLWQ2ZDctNGUyMC1iNDUwLTcxZDY5YjAwODRjNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRjZWIxYjMtMDcx\nNC00YTAxLTk0MWMtZmFlZjU0NjQ0NzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkucb/xTrqyKg5HiMreqlNpqZsoI5Q6kAlbHe9/UUSfzsa/AqhQkWSlosYRVs\nInoqhf/+BwqOrww7TZWbUtzHcaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo7I4HWBzB2WKFHWPeRReqaN7hEQwHwYDVR0j\nBBgwFoAUrWgyN26/YueJKCa0WmJfVXzpD5UwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIDfi0IheL0mFe05K0uwO1X+8VLlNvk5LaQ3kiyPBoMNFAiBAI2azShrB\nC0AjbmVwaljp8t3KRPOzfIpT+DeGxJne7g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYYiZpQ2Afi0F6CfVBB//TJ1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzYyMjE1YS1kNmQ3LTRlMjAtYjQ1MC03MWQ2OWIwMDg0YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeBWPhBCN2xxCFb34meVy9JMZVuXDyL2iO7ShzPHpUlTLq\nprcoc/NfiU7JcpclDOaUkXeZI4w8b0X6thiGGgzMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrWgyN26/YueJKCa0WmJfVXzp\nD5UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM/eW4SjpJSNvZmLYcjyKZV8YjAMoYODLmiUxV9YJnSzAiEAqLUdrSRQ\nOVRv6SkfjYVyrXv+2LZpEQVu0WoVzX4c8eg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARoU9vWYyVes7clvNZuFUKwPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRjZWIxYjMtMDcxNC00YTAxLTk0MWMtZmFlZjU0NjQ0NzE5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTY2NjUyMjEtMDcwNC00\nMTlhLTg3YTktNmYzYzdiMWNkMzQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPodTQ43pMHWtT69JdiURnr80TyHZN9e8icA9nJKxWPYHBPiSgH2hBCRhZY/vdP4L\n2S8DBEIBgxSnsTaKq0ga86NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUo7I4HWBzB2WKFHWP\neRReqaN7hEQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgU4+hLkoEIZYY2TcMJ4hsU9g8r61yE/GIZIUPVwN04DYCIGjHy5DdAzpx\nye8SzB1VB5G5kyHAkoCOdPpcjiQzlJsg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8328", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8328` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAW93LE8YZh00z5Crap4FXRcCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4YmQ3Nzg5LThjNzItNDMyYS05MzZkLTIxMDNjYWU1ZTkzZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzgwNWZmNDEtMzI4\nNS00MDdhLThiYTItYTgyZjRlYjljZmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZX1CHOFwPGSS5NQNcYbW3ShDKq5S2vW2TYaptOpMnMqaQ6+MCIOGpf4vr+wj\nrRKp1CsOr28s0WSe3TQ8fDELBqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi68lQ6zia+p8w6nG6k7pfCqK/O0wHwYDVR0j\nBBgwFoAU/bZglQ/QtrUURdiqFKBV2wbzuVowOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQC85lC6VhM3NvV5y3zL6rF2Yf+1KS+r8tsUZgGajCyspAIgfkJgDHC7\nXURrhHt4x1y3KkbqKggVt7fOQA4gpTSVxdk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATcQpIZTPVZSsA4s3dGZlDKiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGJkNzc4OS04YzcyLTQzMmEtOTM2ZC0yMTAzY2FlNWU5M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASydkNtL+sLILO/2YaQ1mYYaKVH/G1AmRaYlHFZjtm93qlI\nhWvmbYXFaLnOVYf5aEcfE1K5hSxe9XlEssBZB9Coo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/bZglQ/QtrUURdiqFKBV2wbz\nuVowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKHIwMopfA9RhCj53BUm9Ecnk0Fez5b1dmfv9N7i9YO/AiEAx7hlhJSt\ngBXtPcwI7Vgs5JzrifsF5jfvLBNEKAg6eE0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ1kfifAy8t/G6cK7f+JzSOHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzgwNWZmNDEtMzI4NS00MDdhLThiYTItYTgyZjRlYjljZmNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjY5ZmRkNmMtNWZiZS00\nNDBmLTk2YzUtZjRlZmM4NTBiNWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nA5VXzkDesyQEisA5ialA4Hwxvv56Rtnwaj6RqvX05cZp8WCxeQX1RPvT5dX8xqOz\nk95u9NXGtH4u4UdlEo7YNKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUi68lQ6zia+p8w6nG\n6k7pfCqK/O0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhALdgweJlg9a2LzwobyVRyjj2O9z6O4VrESIzE+zU5K7cAiEAw2j34XnH\n2+fJ9PexJrxdsL4WU9jzZRECYtFv343KTwQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8329", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8329` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUTCCAfagAwIBAgISAZri4cdNp9EPKqL6WWLHcdtsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2MmQ0NGVmLWFhM2MtNGNmMS1hYzk4LTM3NjJiYmMyNzg1OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2QxMGYxMDUtZjdl\nNy00MGFhLWE2ZGQtMzE4YTk4NGM4MjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZsP01NEMHQ223ToslN9zXs6q/JevXhEc3LXex+aPw9VI9myYMWUklSeeBk9a\np2Cv1/A1M1Z+J559z2k/82ZInKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMy4TVbYTX6wyRs04Bf/+/veaI64wHwYDVR0j\nBBgwFoAUiqUKQkMwDliPm3LA0xxEJnNZ8D4wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYC\nIQCwHlco9L+I/gsnL1lBAJI6CB/ek2486yQvXYYDiNFesQIhAKjWteSak9kuBAQP\ng8zRueQ0tKrURO6kqiSfs4ZAjUZE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcxnaYtJ6Bu1bcONuBYZm/azMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjJkNDRlZi1hYTNjLTRjZjEtYWM5OC0zNzYyYmJjMjc4NTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7yr+QhAhJJRlewEpoKqiqRScLExb4qoR+bsx0QGq9dD5T\n28/Gqb6cKw0dVWc0UfeYCCl/fniBQ0kjDY8vGHhWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiqUKQkMwDliPm3LA0xxEJnNZ\n8D4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJqM/S8Py6hIaQxQcAndod5xvFnznjQYNXiM/VNlhdmxAiB6B16kV0bS\nFZTP6UPd8YxKiZ07tMrtQDWtoh3ujMhcHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATuZwmPyNHqvs64Ht/YfJQUzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2QxMGYxMDUtZjdlNy00MGFhLWE2ZGQtMzE4YTk4NGM4MjRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDM1ZjllOWYtYjViZi00\nOTcxLTgzZDUtYjExZmFiZDBhNjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCULIfiTwZsaHO/+0mlAodwy9RnGPhiVPC8/hILO4FSvCs+NVQzZtNqWHnwVOmeZz\ncrQBesAZAuxT+ximTwe9YKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMy4TVbYTX6wyRs04\nBf/+/veaI64wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAKci0M5GHKJMXLCfkh46cfoQSiCEoaA8DG/aQGoEPMTwAiEAwq0EWlFp\n/glcyuqhSbiC4JQ4nvM95/hmhB4i1aS54GY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8330", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8330` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAdwrfo+e0oQWexUcHFquR5uLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxYzhmYmE2LTVjZmEtNDk4Zi05OTA5LTcyMzc1MzQ2MGFlYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEzMWMxMmYtYjAz\nZS00ZjcyLWExNWUtOTU1ZWJiNDVkYTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAED+1BFpjgkZNqDMmXZDVkluyXuCO7n9IDK/Fp57uXjbeGZTHISSxcqIt6aqK+\nPwQErxvlH6gsnZsY5ROz8W4TwaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMhOUJqx2DShAU4SsfvKI64Hs4C4wHwYDVR0j\nBBgwFoAUyO1I8zl0xyNVNx1btj1+EezVppQwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQDqLHw/RPWyveKLpiIKptD5a81si02ReK3ol54FH/MBJgIh\nAPwoAPXGVOq4VmHy6b/cncn0r5QsFL8VHU1GYUeFTH90\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ3t5WigcEqCITcJGBXgQ5asMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWM4ZmJhNi01Y2ZhLTQ5OGYtOTkwOS03MjM3NTM0NjBhZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuwccyfFWFg8BcQ1SXclkUoEgvU+wDFVE9uk3A2jxDURwd\n2j4x/+zNGyvTtUrQIsKdW1zUHZPoTnbOGjn+SvN6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyO1I8zl0xyNVNx1btj1+EezV\nppQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALbNBLa1ERUOOZVGzTL4hjOuKwRT0H+h0LRyCqkWstnyAiEA/IGaLxLF\nu2UqyvLq/b7QDok06TBefSdzAQbj9KGsBpg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ89NyVB92DJ5HJBRPjl2utnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEzMWMxMmYtYjAzZS00ZjcyLWExNWUtOTU1ZWJiNDVkYTUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTFkYjQ2MmItNTM5NS00\nZTMzLWFiMjEtMDAxMGZmNGRkYjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ns48Raui8HgGQCDEDkDIPsx++al5JD62VGKkZ6u4rhvI7Segii+8zJjy8Mj7x5NhH\nUnkYHzzJWmoIlLdNEWpe06NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMhOUJqx2DShAU4Ss\nfvKI64Hs4C4wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgUypE6VNIXWI1GUxmKHfIi1giR+tIkmt2V68xqpxJcDICIGC5CzJh/qgv\nLN9vSQaIwfAZ9UKMAj9Z8+jra76FDqS/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8331", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8331` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAbKLLaWVKd42QtV+I99TBa7EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwMDBkZDdlLTUzMzctNDNiZC04NjY4LWRlNmI5YmI3MDQxNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgwNmQ5ZDQtMzg3\nYy00Y2EwLTljY2YtOGZlN2FhN2NmYWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvPvWyDhj7SaD7/LEQjwGPnT7vgm+PEqpSQVkfrrXTBXiUiEifS5NTuYG5Lsy\nngKNstOJGkOGXhFAEE9dXv+fnKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKlpq8KicqDhPkK/kvYy6sod8tFowHwYDVR0j\nBBgwFoAUkDTxIaEHeJHcm1rY0mM9cdLG++8wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIDInnIZf2pk6L2f9PawGw5DNacP8Ja1B9/To3zTNEeGxAiBr\nnZLBAku4wOeKmhzNNxnGhSWu+KBKCgpHgQ2L5xQcVQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASMfju+v+4SCdRKIpiCMukbQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDAwZGQ3ZS01MzM3LTQzYmQtODY2OC1kZTZiOWJiNzA0MTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASg0ddMNe0l8V3mIRCBSz3PpZ7RbcABz+s+1snqpgj5KKD8\nvCKcFmPEInF/N50HNvTikQHBtACoz+qHtAIt8O+Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkDTxIaEHeJHcm1rY0mM9cdLG\n++8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAODSPVk0GSKvM6oZ+Xy2iEfUbJXI5tMCIPkGUb4vMj/MAiAFLeF8qQTJ\nT4gMrsxCdB8dz5iI0eZHTz9vPXe3r2uJMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVfR7awTJKFgPNPlrPaXDaMkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgwNmQ5ZDQtMzg3Yy00Y2EwLTljY2YtOGZlN2FhN2NmYWUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2YwNWZjNWQtOGZkNC00\nOTBiLTkwN2ItOThkYjUyN2M1MzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+rRyLH11/AMB99TkZWim2NiokpUFrSZ4ceW2ZL5jOOUX9PH6WNNwRx1eUzMSwmOM\nfI5TeyZtun2UcNXVE2HkbaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKlpq8KicqDhPkK/k\nvYy6sod8tFowGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhALBasZc7namr/rwto0C+kklvDPMBMqBaGjPGgabWYogLAiBaCJIHAe5A\nC/5MBIBWK0zz+tPC9hsNyFFCOejcLolYyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8332", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8332` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAW+yma1kmdIpdxod1Jd9E7y7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmOWI0MDdjLTc0MmItNGU1Ny1iYTBmLWQ2M2JjODcxNDkwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA2NTcxMWYtMzFk\nMC00MDMyLTk4ODYtMDJhYTBhMmMzOTBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXe8n/aAqUT8qlbTHHLtFETv1pmFUEylttRA8oECEv23DVSmGj0T/sODwAGaX\nLr9oroIRvpKOSRg8xKeoD+ig06OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsdzqtYNloo9sqpgxj19foSm2D/UwHwYDVR0j\nBBgwFoAUPDsnSn9tEMngbAxbP5UMMGX6hcAwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDOzgvdKjU2\nGFo3eFSx3hXCHOXGBkaOS7HVridlyg9xKwIgfZf5yNnFsVS8r71qbWX8kZQnbgbx\nhUagsezuuhHomMg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZfPvgosRMtIvfnhSKfKoK7+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjliNDA3Yy03NDJiLTRlNTctYmEwZi1kNjNiYzg3MTQ5MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4DDlxJ18GQX7ceBNbdgihQ2qEfmbsHn/c06yUrBRdBl7I\nhEBXiYuv1AzWtUC64oXzr/DoqGWKVVZZ8dsxn8Fro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPDsnSn9tEMngbAxbP5UMMGX6\nhcAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANj6vMt9r4EVriU1lFH6ehHbrd4h+Ra88ECxtI8UAecjAiAzWFYNLh9n\n2UfPX9XrSFGfcPcA37AyiTDuT0Gr06jamA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc/p215e55czy8m50gnrPB2vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA2NTcxMWYtMzFkMC00MDMyLTk4ODYtMDJhYTBhMmMzOTBkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTA5OTNhY2MtZjViOC00\nMmJkLWFhZTgtZWVmYTViOGU3ZTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+Iq1qSuRW7MeJ2dq1B1PlodlrebKaKI5NKJImhGkyduFOCbmfKKAKS+movVdBOUs\nFeN1Ga0xgKBGPVyRwMo3PqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsdzqtYNloo9sqpgx\nj19foSm2D/UwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAOhPOv5FZxhnx2aDxni+qB5PerH5uIohfNMFvexz2YO+AiAX2astMJ1K\ntiyI/m5j8sk1BmXeXKLP/lVuafdC5fkeJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8333", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8333` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAY9+n6vOndS6OjwPuFjQjWelMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5M2UzNWEyLTlhOWYtNDcxNy1hMjY0LTRiZDZkMzhjZGY0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWUzMDMwNzYtMGQ4\nNi00NGEyLWE3YzktNmZjMmJiZWIwODgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMeqLdp7Mz1bIIxcRQiSJFmx39edvG6jVd5NXoXMEbMsTAiWDEeCNACTpS6Ec\nnx+YH29SfPBIBbWEpgu+Emep8KOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo/GkzlXdajJlyRLL6FnWIBvwRfwwHwYDVR0j\nBBgwFoAUTUyl56nF5cmqgb+R9pLHs97q/lAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAM2wnnSSrr1X0OvpsYsVc+ynUbZchfxPZA+tiHkGlt/TAiEA91Nr7rpA\nWpr1JJ7dSPvLGObJbqVl5YNC7gEpoYDd17U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfkWaSyC7+YfHSJv9aTfz7j7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTNlMzVhMi05YTlmLTQ3MTctYTI2NC00YmQ2ZDM4Y2RmNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrcPDd2vZsRn5N9sfrGKP+dX5xrdLYKCCZJcjrFsuOHet3\n09zD1AXn+J+TLDhTGdshTF70DxMVqPHZXgh3lQ6go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTUyl56nF5cmqgb+R9pLHs97q\n/lAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN3ntjiP5zKXvBRA8gYxkfKsYFxsPVEXOOcXc7wqAi4ACIFSw+wJmDgFD\n8pVm6TrF5uGf+MkM1m1ThPia+CIlHWJ5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWGu+5k2mukRVahv3RsURRnvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWUzMDMwNzYtMGQ4Ni00NGEyLWE3YzktNmZjMmJiZWIwODgyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGVmMzM0MzktNzY3YS00\nZGEyLWIzNDQtMjQ2NzQxYjNiN2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/B4dBLxXK5n7FIQiTzkDijLwhcTM2KalEiYhU5jW6KoKvozwmopN9US66wfk6FUQ\nCWBw8fgK6cNzW/9rJuj8caNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUo/GkzlXdajJlyRLL\n6FnWIBvwRfwwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhALTUKuUo432b+h/CEI6unkRN2IbbRKZ2JR8FhRswz3CBAiBSMLxqJvL+\npj6hK/bEe/Kt8gkaUYgNgLvDLfsgZ43NVw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8334", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8334` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAW/g4xxicYvx8IIufNd0nSWrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxNTYzNzI4LWUyZjItNGY4OS05YjY1LWUyMmY5MzQ4ODk5MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAzMDg4NzItMDA5\nZC00MDM3LTk5ZjctOGM2YTIzZGQ1NzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnbgZ2TWbo0mTrQLzQONpubgQLxTUI6Ess9ydn/FksNuBvdl2dhNn+OzNkywZ\ncvC7Nba93a4Ac4t3yBczlfrNZKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtjW86YxXrdXFR0Oh1e3z5ldJg9AwHwYDVR0j\nBBgwFoAUnHWkfD1TbwgjBQrtIORhsBrnxmMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgKHzgKggR+gzHuNPPg01oqQp1QIUk273n/SLMkLabB6oCIQCZyBFTZKWo\nlxoWmrEmq+F/SmbNakePgUOL0+LWCIfh8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeoYydi6abnLRWZpTkQ13/GCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTU2MzcyOC1lMmYyLTRmODktOWI2NS1lMjJmOTM0ODg5OTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVzzT0Gi7JlnEZnU0mW/YHNX09Zff8afgZmj8zhXeXDhsF\nZpYe7eUIehAK6FlOZNLmVhYCRuMgbpqAFlfsPuQeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnHWkfD1TbwgjBQrtIORhsBrn\nxmMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRh07gSNU6nBG4BdF34h3Jez720zUNo53BUdHAzyo4TACIQDWRaL0yVYD\n4oxyEx/m4+uvOymYWkbBuuxSVvjyF9GPUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARuJ7XmM54KHUv8RbS7Iy6fRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAzMDg4NzItMDA5ZC00MDM3LTk5ZjctOGM2YTIzZGQ1NzgzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTE1MGNkY2YtOGI3Yy00\nNTJmLTliOTItNGZlZTg0YWVlZjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\neU3BHgwDCcspc5z2OOUXRM7o3U7jXj52QhmEDNNXV4MYbZF6jAVfO27IbgcyX62a\nNGBwZZzlVy/joqZC+etFbqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtjW86YxXrdXFR0Oh\n1e3z5ldJg9AwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhALATXQ9ZbqxN3l5SYPCyWbKzE3VhGGV1LDyH8DZn+fv5AiBIaTxTlouk\nAh2MtR2XlNqTQmEQ1F7Y/i5GuCxcmBS3Sw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8335", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8335` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAX/Yo5Ldz6EqOMW6TJdmcAdvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzNjZiMWM4LTE4OTEtNDRjZS04NTM0LWQ1NDA1ZWM3ZmJhZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlhNWQwYzctZGNm\nYi00MThkLWJkZjktZmY3MWExNmVlNDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbQ1gAoq/SOo1a054E+k4xhL4dlLZYIkRNsz7YRmMcGL6PzAhVhOq66qAeblH\n6hba6rZBL7RvrBjTPMSMjKuKwKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyrCUr4bfAsQLUiIeN9oVRnaCTZkwHwYDVR0j\nBBgwFoAUaFGF6AMmxx+xrxuqTGsCQRvCOpUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCahZ7nZTMxqSffZYVWG9giz4TLippYgX4TrDwyCgPnzwIhALHO8c+z\ne4pKSD3vStMr6Dw+cpsUax3dqed5KCJl05hg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZJzS1BLkJ2Es6cKEGFXrK2kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzY2YjFjOC0xODkxLTQ0Y2UtODUzNC1kNTQwNWVjN2ZiYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdAnOr3QshX7yK2S8kcloEw15OAvbRrjxrUWFo1N2q3PeN\nvsg6QJuC844+jdVI+lFeR9Zs0/qjldlNDusrmHwPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaFGF6AMmxx+xrxuqTGsCQRvC\nOpUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOelasULNsk4THjXJuNjHJwMQh6El1+pelZC6Y7r29cmAiB8SUALl7pT\nkIgqH/W4NGkHocbV2q9y8fT3ObOWmNuzUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ32mQ2MT5C07tYmSwp5xUGsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlhNWQwYzctZGNmYi00MThkLWJkZjktZmY3MWExNmVlNDA1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzg3YmQ2MDctZThiOC00\nYWYwLTg0YmUtODUyOTk0YjFjMzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSEgU8APwBigmgmIFpmtMuuDkDzbV2ZGfmQj//XGI6w+vK+1CZyg4RnncAuYG00eJ\nwhr3XbYkcO3wWfhT+P7n/6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyrCUr4bfAsQLUiIe\nN9oVRnaCTZkwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgXj2V56DhM4s8jRJDrEeBB48moflR2npKvNqonEI+Z8cCICeTJ4oQYCCU\n7FxYGtnGBmAdCOylRfIUwLd6oUn3WsUN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8336", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8336` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAR4UGNw3EjTAu+ZlUC1DZCcxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NmE2NmIwLWE2NDUtNGMwMS1iMjU5LWU1ZTlhOWVhOTllMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhhNjAxZWUtYjll\nZi00OTA1LThmYTMtNWE3MGRiOWVlMmUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBXfvmEMjVuHN/23fWnIT5rysHWTVO4to1xQ/VCERWc6N6QBteAs+mITbo5nV\nRlvRz82qcF0Ffkeg0/OqXgYep6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUusLLKoqVWFKCHl1Gri4ZbIDHi68wHwYDVR0j\nBBgwFoAUDpx+pR7bc6tpzj1OL0SJttZIYY8wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIEG0XCk22UfkG01EuNZDXSLk8MnPFAWvGkr6YKlg\n9DdFAiEA/457bYSqS9q0iFcC2SXK/cIKiggG2Jw1GwQYXLsZbrw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARM5FwiMYHnlxtljFdQFa/gBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTZhNjZiMC1hNjQ1LTRjMDEtYjI1OS1lNWU5YTllYTk5ZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV5GNVxmV9cDVAz433Cxf0YBvISVJ7gVk1dPtHpqdxPDVD\nUVTRWFJg+krlNpevXOmxDVtU3ZzDTAmC3yideW7ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDpx+pR7bc6tpzj1OL0SJttZI\nYY8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfCU544LZWbXD6Cm6vnXUwkjkm0nwNS2knNvitbSS6TwCIHGz62653saU\n9SFacJlGBrwowbja2qS+v+AuSaDodmpw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR6qPVP7QcTkYh73mJD9aZqFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhhNjAxZWUtYjllZi00OTA1LThmYTMtNWE3MGRiOWVlMmUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGJiMTA0YmQtNGE4NS00\nN2I1LThmYjAtMzVmODAwMjExOTk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nM69FOrFhW0I3p8AVBWtcaeAJ3gdWGEJmwqrhJ7gbUmhtOCNeQ/aUePn+LF5Pmv5x\nx/WtNNdk4KVx3+AnBrkl8KNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUusLLKoqVWFKCHl1G\nri4ZbIDHi68wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgeQe2vQBv2pvzkyvqyeFZsSxyYAIY4N/EUqqBurN4Nf4CICEXXZpLT+Wc\nXQ2c3YjQvB8GkqFDVYcCT7+HuwpAw4Ww\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8337", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8337` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISATML0Qn75BCSt7yL/WaThQcGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwNmE0OTAyLTcyNTAtNGMzZS04ZGM0LWJlNDA2NWQwOTA2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWM0ZjlhMzctNTY2\nMi00Y2Q1LTkyYjAtNGFhMjYzMjQxODIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJWkQYHgS8Ch4BC3A2mHEnBuHXuf4me4QS6DU18LDTiGbmy0LCP9U7Hg+iQzc\n55xysNs9+oRvNZxkYO11Mr3e7qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF2Ei92FXhLbTkn7J+evkkgrUnL8wHwYDVR0j\nBBgwFoAUqhYF63wOIiiT/OMjg0M0zV5xgwkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDisyz26NJUMpFF1s550051BkHeX1OK6W3S+LUU\n9GUvjwIhAIXdqB8GVGNHJkpw0/D1gNKAyoBA5KI8D29/gBU9Ad4s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXs9p5EkZJUq3NSLasZQZdKuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMDZhNDkwMi03MjUwLTRjM2UtOGRjNC1iZTQwNjVkMDkwNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqYmsJQ0rgLCMEBP6ylTN+uAl51mVPTxPUgRhdTVPy3DtZ\nagnJa1i/26xhmPeE4hHHg/ry8I1mdAE8ojdo2T2vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqhYF63wOIiiT/OMjg0M0zV5x\ngwkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJoLb8Yv1wF02YQ5ZnCi3pxmLlalM3JgVWp4Lf9mTImcCIQCU5w+xB7Py\nRiPx0zKMvIznTvzDDQFlX/cjm2zNmH8Q3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVFlX/Nz2Is0tNmVgx52KrwjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWM0ZjlhMzctNTY2Mi00Y2Q1LTkyYjAtNGFhMjYzMjQxODIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWE5Mjk2NzEtYTRjMC00\nYzc1LTg1MDQtMzU1MTQ3YmUyYjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/X65Nq1jKQGlZ6+AiEjoeZUAlO/1HUYaXEl+YSfpoNwG7u3KEQKoRGTu75ibodCM\nGgzrD9hjC4ZxpEmq3o2kz6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUF2Ei92FXhLbTkn7J\n+evkkgrUnL8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nRwAwRAIgON02Pc4hXiAy4G5OlgF6SNEr9I2ttQk5n8qtyusoLHkCIGJyEJZFOinY\ntnJE8go7td4jAc2x+v//yxJOBOxt0O/C\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8338", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8338` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAdpJGQ4a4qg/NJmiBa+7uTtMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2N2M4MmRiLWM3NGItNGY3My1hYjNhLTVkMjdiZWQ3OGViZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg2NTdlOGYtYTcy\nMi00OTM1LWIzYzAtOTAwZDM0ZmU4MDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUwtEn1X3txiR+rX1og7rdL36rZJ7i82x+EHzfTpb+I9Thiiv4W1T+T+9QXak\nJ6NvtFA3u+HO08dVs/XYFx10XaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUczpOZr1RZb6RHSdE7TQs2oIuBggwHwYDVR0j\nBBgwFoAUNFkvR2eFlyK9hC0Cr/86EN0Ya0AwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIHVkXfNuPzH6ZCJY4ALKFuxUsiTth6U7O4/gh1jHVla2AiBN\n5gXk68pcrUFZ7BzGcYjG0gNouQuMLYSTtsJ+c5rTzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbJ08h6a2gXgtHcXN3CSf9zgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjdjODJkYi1jNzRiLTRmNzMtYWIzYS01ZDI3YmVkNzhlYmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTo7kNBIUHflY9N+BGM7ST6uu/xsUMc0rAJL4fxAkV06pF\nAtNoiyjWGLUKmUldKNBtSOKIUUkX8RMfbpIyljFvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNFkvR2eFlyK9hC0Cr/86EN0Y\na0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK6Ps3qlWDJYrT+/yriOjU7ixwDny/5HsdgK1Qf6f0UwCIQCP4idM7Uzz\n0pwvBcAtHfz/sFxLEV0tjqOi0d0XGeQBZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV7zGXe6tViHGlZgJPbAAjmNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg2NTdlOGYtYTcyMi00OTM1LWIzYzAtOTAwZDM0ZmU4MDA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjIzN2NhOTQtZWY0ZS00\nZjMyLWIwNDQtNDljNjU2ZGVjNTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nK2w5pXeitkIqWR+3wYM99ZX56/Q9OjptVBHNJilGnMibkOK1YFzfyEtA/8umIOsx\ng/1jgEbFXEpuM2YBRj3DGaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUczpOZr1RZb6RHSdE\n7TQs2oIuBggwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgKDyNFl4x6OgmwKZ+FhZ8trgkzi9ziJmmowfh30dwcBQCIQCrAcLuEsFk\nUJl6iAlp6iNGp5dX3I8Fu0XnjbogFDWfww==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8339", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8339` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAQIac2wgGjkkixpUCOdZV720MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5Njc2ZTg4LTA4YzctNGVhYS1hMTkyLTUyMmU1OWQ2YjZiODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGUxYWIwYjUtODBh\nNy00YTBiLWExMGEtMWFiNWQwYjk2NDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEneBkGdFkJ/vyqJQc3NR2N++PiyPCJpcokTJnWPbVfwKomNws1nuV79Fe0vnn\nrv9ieH5Yf4mz9W1HnfqU4c6DaKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2ivYTeaeYh8/PVpcjAuRKIzU6AwwHwYDVR0j\nBBgwFoAUVXZHA9SMl0VfIX4J3bqm7GPCZuEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC2kfUkw4y6ns9Y5DxIbTDKlYTGqhQv\n1lkAPQm0vSZCLQIgSIMvV8EPtx6Jy+4N2Xx8h1ceTtT7YflQUS3TahC8uc4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbtXbaLeDhvMaB1vxxlOkF7bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTY3NmU4OC0wOGM3LTRlYWEtYTE5Mi01MjJlNTlkNmI2YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQea9vligdpeo+ObRgeSgRhfBBq3k9p7Mb9mQyNK4vobEMn\n0F4t9UdjD4NmIt4HTt97OfDPIT+zI12qrZ1sMz5no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVXZHA9SMl0VfIX4J3bqm7GPC\nZuEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKXyXwWmycX3h0RPAxpMqk5VcAFy8CZh8myJz0Vd6tvqAiBWY1ocP8uR\n3IuKsegsr5wwXtY2Xa2LmwvO0Vzx+u1IfA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdj1st3tOKcclfeasW69RLa/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGUxYWIwYjUtODBhNy00YTBiLWExMGEtMWFiNWQwYjk2NDIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTEyMmY2OTItM2Q0Ni00\nM2E5LTgzMmUtMTE1MGUxZWQzYjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJKJ/aRdi974l8Ab4wTpKoBRJcM5kj1DNfglrBo60AKydOtgEHY9TDLMl3RQUMrI2\n57jkbEohNCi5lZv7q2f+O6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2ivYTeaeYh8/PVpc\njAuRKIzU6AwwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAI0qbqYQo7MwH0IeO+3SllTE/dIrrHYFbnjcfeHfL9W8AiA6qc9J4W9u\nXk2ZNs6rVAwg8JrCdPKt7z57VmjDWWAjbQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8340", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8340` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAaoYiXwVKyyDD/ynDxk83ZZOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZTNmMDdkLTdjZDktNDM0My1iYmY5LTg0MWJkZGRhY2U2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDViYmJlMmYtY2Fj\nNC00NTRmLWJkYWMtOGFhZTFiMjc4MGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe7B5NQoR2C7TQRwnCHT7+kVUH8oN3lJFVktXM0ofEx24+jGtoL6iGOtiIZKK\nGPh8tFFLZ9meWSzGQk7OMl1x+KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKjm//mrBhHK2RSn4K12GZczwCqQwHwYDVR0j\nBBgwFoAU9uAi5BzMVZXbDQgCSFWsczSy21kwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCICBZepT2gz0kBdMGHoopg+Fp3x5htOeC\nurVSkJdhB0zMAiBNsD8/yR5hRXvTdDX+6oKMORuqSsCjE7JCbMofFvufNw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYIHVLJcvQ0uQwc/fwzwAIE8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWUzZjA3ZC03Y2Q5LTQzNDMtYmJmOS04NDFiZGRkYWNlNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQswvlmDS9RltvpcJ+LVHpANeh9JTf2dtLhVF7/uvzf7UXt\nGhJtv0bmEonmwtgD8mS7WS0fcw0IRfK8pxPlv6JSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9uAi5BzMVZXbDQgCSFWsczSy\n21kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJr3MIFVr4R0GVLIjx3+R8LmvgCepZHHzweZVYCgSZNvAiEA2IAguO4/\nhvKpGwu6mfFoPU4tE7Zz3STMlswpqy7ZIfM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQMbZ8ha7AknL0kuGs4220SiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDViYmJlMmYtY2FjNC00NTRmLWJkYWMtOGFhZTFiMjc4MGUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjliNmYwMTUtYTkwZS00\nMDkxLWIwOWYtMzFhNzdlMmM3ZWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\np2+Sp8YmttZYkp/JEdfEJ/U8tHyYigVbQ81a77vClRjMOrLCdLtfDUeVaTSLzT7a\nvsZWf/E7Xc+AXPgpp9RDR6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKjm//mrBhHK2RSn4\nK12GZczwCqQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgQLZMZPo+Eu8guefmAIA1BuzGc1Wlc+l5iMbnsTIyEs0CIQC9OkUYYzBw\nOf0MwnlAbGhgSARKUW7+NGUThgGBk/mG6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8341", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8341` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAdb5Ub/q541xzwT4ov0yE2qoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2N2E4OWQ0LWM2ZjQtNGYwZS05YjAyLWNlOWQ3YWM4NzZhNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJjM2RiOTQtMzQx\nOS00YzljLTg2NzItNmViOGYxYTkxYjY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2jcryYFQapWkRULbwK5LDg0xs1CRx5qW1RikMMFS1ZmG2MnC3ODDZvr94aZv\nXMROnB7lZR7zxfmCGwIi+VBDMKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdy+nK8F9OgMTy25UQyknbxiicFMwHwYDVR0j\nBBgwFoAUK0y+8+6s1RRKouCBPidJ1M/YdNwwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAc17IjXxxLU\nO6OBnlS3IZ540UBmpa5ey2m1Dq8o1CnEAiAFwqx0SgIXp4C/HHViVb9TCnzrzOVb\noXdsprW0Si9W3g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUyiNHB0zDbkpjlpiAA17flHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjdhODlkNC1jNmY0LTRmMGUtOWIwMi1jZTlkN2FjODc2YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxVzSw72nAU1Qcufqkrn4qV6m7cAd0dlYXUbk92YRkGFLx\nZqISpCgCiscOzOrzmxvpqXuFBXYqxhNvAhNCBvfQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK0y+8+6s1RRKouCBPidJ1M/Y\ndNwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSCN+R/MkCSj/MrIYH5Jk1LPlCZFtNhao/JH5QbjAEPkCIQDGME0J8fL1\nXkaFWfSp324pDC7ct91p69eZzyvSPKHRPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASKG+11yV2m7e4kj/9BY5ijHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJjM2RiOTQtMzQxOS00YzljLTg2NzItNmViOGYxYTkxYjY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjgwYTk2MWUtY2UxYy00\nMjAwLWI4ZTUtMjNlMzNiMWJhZDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJiqCtloTKLrJLzm2lf9P4Wi1Sh3ctOKYc3g03MtIBueHJiNAKaIKKp1UUKrYQPE6\neM5guzLBmBjuHvVbb68NP6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdy+nK8F9OgMTy25U\nQyknbxiicFMwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAIs9glhhA6AJbZlc/j8WG8AMCnWw/W+HJgt6n7XZ+f5HAiA9ULRqXhUK\n0sI/6FQY0cv1uyNpGfxtUYkH+7BPNOJxig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8342", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8342` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISARvqsvchzU/D3PCqPQ6JvUuuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwOGI3OTA0LTY2ZjMtNDc2OC1hYTJmLTQ5Y2FhNTUwMzY1YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM3ODA1NGEtZThh\nNy00MDRiLWI5NWQtNmIyZmU4MDRiYmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyMnySDhqIGO5w73D8JNX1nJmNuiB6V/v+TSFgbpTANnlQHT3/69ROGyyeNqG\nOj+Hh54SflKJCr0rJzvkpxXjxKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK336v3nEH6XotLR4Ni0fyGp8pTIwHwYDVR0j\nBBgwFoAUdnIVJU0fnCvnIm/V69J5ZQlIXkYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAPgBu6KjRE3ujBDwTAR3PJGTlOhp56s8STeu3uc+1KyYAiEA4O3/RdhZ\n1MxNnsSVUCrb6H6KA9cO+DfFQgil55nJSZw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfgigeAXAuPcFqiH+LI3Tmw1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDhiNzkwNC02NmYzLTQ3NjgtYWEyZi00OWNhYTU1MDM2NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvXbfd8njzeV2VMiATyPWa1kY6viAeuXgoWc8vLpFP0DqU\naYqe9Ty0I2NRWN2HEFns0Vva9GcKjhhgZVqgK1gfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdnIVJU0fnCvnIm/V69J5ZQlI\nXkYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMwb053kDnjEgl5ycsbhpETJLC06cS0AAFTRLzLs6+mPAiBHbtjHkpV6\ne8tBDJV2aV5V/YHwUnfEzNL4ldhA7RF7jA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS0+kOnR4ydykmMIbltJ0hISMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM3ODA1NGEtZThhNy00MDRiLWI5NWQtNmIyZmU4MDRiYmZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTdlNDZiZTgtZjk1Zi00\nYWQwLTllM2QtNjI2M2M3NzViOTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLSuG+S7PSkKVOKpP4STFQQdqJ4b4PBB+3O9CDp2gpQyoRkebYsf0BX6FuyAu4zBH\n9CSN9NsPlEP/M3dYSguuyaNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUK336v3nEH6XotLR4\nNi0fyGp8pTIwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAKnWK+y5TQb8pRY1x56QbDAyVkl8Y5QZt0ve52ISMHaBAiBRxlGmo4ut\nFargW2SxY5lCu+FjRy1Z0QlPZqrxeJVDAg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8343", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8343` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAY1YnwWqFxl5srRFtDPktEYzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4OGY4M2Q4LWJhYmQtNDI2ZS1iNTlkLTg1ZWI3ZjBjMzZiMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTEwNzBlNDMtMTNj\nNC00N2EzLWE5MDQtZTYxZjdlYjU4ZWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExJdznu42Uk/Ah8YLG4B57byFOZdZnd1Pz6dtilyfBzWzS2HAirOl2ELBr+I8\nPjzWKM1hMb8Z82v7eLWAO0X5GKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB5Eu11LBURDy8ZECXmgslJOVVXQwHwYDVR0j\nBBgwFoAU4bZqsN1+O9gXNlX22mFOuMcpqvUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAPLORvARopMVia1Nj6T6tah2+NZUNbbWgzWhoqHD568XAiBJsSiv4buR\nYEVFyFH+ci2F1qwC6OFr/M9el72ekzoAoA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ6G7UI9YD179YiYQdcL2YD3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODhmODNkOC1iYWJkLTQyNmUtYjU5ZC04NWViN2YwYzM2YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASr8HHQXYLoz0N84SVvBvNawfVyrHfKscshsC0amwqU11eO\nyAqpJIizJIT4hDgKSqvHA01Zhr/Kk+0ezDQi0D+Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4bZqsN1+O9gXNlX22mFOuMcp\nqvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOtLzTHGKi685MsBh4apPvvTKFa9o3PCZ1foBhGFOyK3AiEAl2P2JcSw\n9A0iT0wI/02k/KMmCZNp/h+I/OcPAw2Ze74=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXvgaloK7rVDMzHj9jLSIMUpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTEwNzBlNDMtMTNjNC00N2EzLWE5MDQtZTYxZjdlYjU4ZWY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzBiYmJmMjctNTExNi00\nODRmLWI4ZWEtOGM3ZmNiNDhhNjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqJ9LyCUHCg5T88AfHQjNJIp8Oe6cHc+UWwl4QkWtAVflYZiWqNfz3GsRH5nCKVIb\nkBbB0t8/dpGGEbOFbHl1B6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUB5Eu11LBURDy8ZEC\nXmgslJOVVXQwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAK/5hNn3TPBDgFJLUDwWuJtbt5bMWJv7LU6uZEEpC62JAiBC4MuXQg6v\nFLG4vXqB8XGcaknHsqRH+vMqLLK0yudJsQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8344", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8344` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAWF9EIGytoQ+0Vi0OFQ4HcK6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiODFmM2E2LWUxNGUtNDFkNS1iM2NlLTFjYTIzYWFhZjA0YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk5NGVlYTktMzlj\nNy00NTRjLWIxMmItNDhiZjEzZDdlZjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg6ijAh9v5xkgksOX+B15hiF9XOZwca4egi4NrJ6d/FrYr4MbDHnGVaqL8LXJ\nKR5tKxHjwA+jPLQ3xu6gEzlx6KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlM0AjANjLghp8UKtbLW4HI5RlwswHwYDVR0j\nBBgwFoAUXIjfuGbkVsXoJcD8Mayh6JCdq5QwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIGDrEuMnKOqtnvdqJHWCkwRnM8++26REaUjrxbSzhRJ9AiEApQOCaW2V\nDQ1iat4oOtpO65LoTQ9XuY/ZEfiH2SPCrJY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcJU/7sIR2W3x/Fnha/uUnYnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjgxZjNhNi1lMTRlLTQxZDUtYjNjZS0xY2EyM2FhYWYwNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATILIIqRXEVJ1EQP83nWEZmikJwKPipqocbRxOY5vjnK8po\noBhPQfVmrZ1FU86buI4+SWY4UNIw6IFWJ1cPt5uOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXIjfuGbkVsXoJcD8Mayh6JCd\nq5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMoCnSfjU59jRvND5cjfiP023mPy2q/5urFZQae9Op77AiBKlEA6Mc1p\nUGjudG4RPKF2oj6SpGwvJL8Sr0kNysHoFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVAtYTbcoQziMIqFzvYq/vZaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk5NGVlYTktMzljNy00NTRjLWIxMmItNDhiZjEzZDdlZjJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmIwMTBkNTgtZmNlZS00\nMzE0LThmYjgtYWZkMGExMGYzZDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niGeZtBpetwsoaE6EGZjtov8XzezxD4gkCV8eSs2szV9gZcy91f4iAmuga1DIixRI\nLROeThVhz/APvR5e5Au8+6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlM0AjANjLghp8UKt\nbLW4HI5RlwswGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhAOfkA9BvUpuK/WEx1PkVnKaVYdXvyaezgUw0erCssyY6AiBXsf9p61Jc\nHIo4KsUHtDnZZgP6p/d2VoPYiilx4x6y1A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8345", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8345` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAdsom0jhxnrNw3ArbNsAFZV1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwZjk4ZjQ4LWY4MzAtNDZhZS05OTNhLTBkMmE3MjVjNzdhMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmQyOTdjNTEtNzAx\nZi00YTA5LTk1OWEtNzM2Nzc2NDlkNzE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6pnR7hpxaV9mqLIk0nKlcFF7c96A8To92eYB9ZfWY7aGgpOUkDzYWt7M8c6o\nOpThRKJAEjcnQMr4aj86b2s33aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0byGj8gaqJlY/KL/QLVwqVs+9RAwHwYDVR0j\nBBgwFoAUZvyJv4Yrbcg2N+GcBFiR2CCgrLowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIGRVDCiSSG5bkUkF9KAtxGZW8MtO07uJfZtoXu++\nyt3bAiA3YEfqVJ6D1q0UvjNAY1sk+jAgeoIfnPVUEtVI0nDqvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZP1U/pIsNyMlCa9ibmvVqjLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMGY5OGY0OC1mODMwLTQ2YWUtOTkzYS0wZDJhNzI1Yzc3YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0FBhq+rPs+pZ1QoRdwCiqlbAsOi6ZavmbT2J4qurv+ryg\nfwP/cYFMqBB4K+ztDbHQb4h+gSWimV06dKPf2cxjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZvyJv4Yrbcg2N+GcBFiR2CCg\nrLowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWMHpM3q9fAy8lmzuI/kZimLnFv+16dSrXz1JNd/+hPUCIQCUaARsI1eb\nRN6ItrDUohAFp2AnfbdjLDqlIExd+WVPAA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeRDo2SYsmfBVOxklY8Mdbh7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmQyOTdjNTEtNzAxZi00YTA5LTk1OWEtNzM2Nzc2NDlkNzE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGJkNzNiNzUtODQ3Ni00\nOWM4LWI2MWYtMzRhZDFiZDMyN2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYYypDzG3cwBXmMXUng6wwFhZZOW/LuFxd4O1fqC95Xo9O7JDjxcajFWxy6A6l3ZI\nm3UuUxJq8cd2XcbH75Vca6NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0byGj8gaqJlY/KL/\nQLVwqVs+9RAwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgYYv62K7ZIL7W2em0Alq2dgsXOQm40GBZrGi2B4BsS1oCIQDJMmTkufEr\nWf76vGzT5ElolQjzbXCC15Svp+60j7ZVTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8346", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8346` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAT4f685EkEb4z6A7bTaoo27FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0NGZhM2I3LTVkYjQtNGVkYy1hZjc1LTM0M2UwMzU4OWMyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWI4MTY4NTAtMGY4\nNS00NGUzLTkwMDEtNDJkOTc4YzY3OGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESXQ45e1jqWxmrU3/N6h1NfACnt8xR1DL1YAXen6MbouiV/wsCoEB8MFeYAFO\nWaN067RX7Tf95QC9yFiKA14aPKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUneG6EdrqMVrEMzogs7axP25mSPwwHwYDVR0j\nBBgwFoAUNz1BAaxfwH67iZ6OKOk9C5bREVswRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCovnA+CBk2tzHJa572gtE2tdycLK5ML+UNUq2V\n48ADIwIgab/DemFfo/+mSbDXqhpxFalboXmv88cJKlE3UaYwYpc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU2m7FdR6SuMhh0XdvboqAC9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDRmYTNiNy01ZGI0LTRlZGMtYWY3NS0zNDNlMDM1ODljMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARD3+U9n0M/tCjOyL8fYoSabouaFSm1huAWA3tKIAl8+Xzq\nqZO+tD/ozOeMa0naKp8vL/keuOVHaczNgCucHtlZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNz1BAaxfwH67iZ6OKOk9C5bR\nEVswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK81CRIjdUvQSqGVSCbhFYRptCxeW8vVz/VPwg1MA1sACIGlVHbIErPzl\nyTiUdv5QAxpNXjl9PhHFr5wgSLZZT8h8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZTFyhmZlodivarQLTyntNr/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWI4MTY4NTAtMGY4NS00NGUzLTkwMDEtNDJkOTc4YzY3OGM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTAwMzEwMzAtODJlZi00\nOGUxLTk0NmUtOTBkYWRmZjllNzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvvSgFPFIViyQcDoXfpwuP0BI7z3vs6tSL8T8mUfBV9Kbd75hxaqWOdVdO94QXHXc\nOPtlij187VVwuNogWqeoRKNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUneG6EdrqMVrEMzog\ns7axP25mSPwwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgBzgqeb8Lk3EaqTgJrXpzQ0yrpKc9KREXj/nGdtgDKC8CIQDkTxAVQZPM\nLiJNh4GiZQqaEEWD3CyVNoKjVq2qANtp9A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8347", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8347` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAYe2G2mrIaOiirARI9P/u4kKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1N2VjZTA0LTYxODUtNDU5Yy05YmRhLWFlNDc1OTcyMzAwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQyY2Q1NzYtZjQ5\nNy00ODhhLTkwYzgtNDg1OTNmMDJiY2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE63p84FRoxznAAyEam0Xfg5SaW015jPCohhd9AssqKisS4KmcMH7HZXFTYf/m\nvQqRdBroe/KW6zmtfAXsiEdJ+6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAS3S25Y6i7umoizUbmU3wkED9u0wHwYDVR0j\nBBgwFoAU+GRqLeeh29UXZWT5YOXLlEKrpNcwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIC6UIRn7nB/IHfsJUkmE2X/IP/70FkaCd1htTO9ZQGBpAiA7\n9+HNpiEybKVRWtWumuHmL/cS9/Lteq9iUdE+0D/gVg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATGvesiW5vzsJt2y67bAPr0zMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTdlY2UwNC02MTg1LTQ1OWMtOWJkYS1hZTQ3NTk3MjMwMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7aw7m0j77G4/7H5XtRVGBpFuhLhBxEQSnxeY9j4CKiE6r\nGEH4JaY4JCysCjw0CVkgK6acQFlWAWfsOt8gonIHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+GRqLeeh29UXZWT5YOXLlEKr\npNcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLg++URGP4FUtlUxao6UgB//t/2ZZFYOBZ3OyrZV3ILoCIA4FG56FAmql\nTQpHQ0GPFtN2UwKNZTazJMCLLGDTUI8E\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf8+f8da0c7Gx6NrZY1lpnE0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQyY2Q1NzYtZjQ5Ny00ODhhLTkwYzgtNDg1OTNmMDJiY2Q1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGIzNTIxZDktY2QxMC00\nYzAyLWJhNDctMGM0Mzg2MGY5OTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRKdAGOJWoTKIFsts2OH9nE3nd2tTzAVm4CpCi5joYLe6Xkhs1Ux9TqFvXFUvv1Td\nPffk1VXhrH/i8ASbc0fErqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAS3S25Y6i7umoizU\nbmU3wkED9u0wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIgcffLYZoFHviwQ/5WlSbbeq6+bJXdyLqi2voRP5i9bGYCIQDcp6Oa3aFM\nLOCw4qvfALRFIwdBevKXVVEvDw0BYdSIsQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8348", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8348` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISASVeC6xfUAdTluFZSReC8j9dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4NzQzNTA1LWU5ZDktNDBjZC1iMDI5LTAzNWY0OWQ2YWYyNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWViY2NkNTYtMDhi\nZC00MGFkLTg2NWQtYTY3ZmM3NDdmN2NhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM/VRhBy49hhJUkmUyDu6FoLmAWqHetwabljz+a3rJsD5pVBAaz7ceV6t2gtP\nEI3uoXAKXXXE/QeXwQ8B64DQH6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEgGrkMRIQ4sYA1o1pM08eVz7BBwwHwYDVR0j\nBBgwFoAUHuBOciQWyzjZPaB6o4gMhVrmSO8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIDtPCpQLsr7Vnht6sHwEb9YUUmq8zyj2\nBpeE/JiKeAG2AiEA2h3qayGGD9ze5Rg7raYn+5PtSPA8DL4EtX6mUYVM2O8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWidej95NObFoS2zk8oXcDF2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODc0MzUwNS1lOWQ5LTQwY2QtYjAyOS0wMzVmNDlkNmFmMjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVKonF0ySAbGJtV4YZhwS5hkToszzXg61UQbEMzXj6+n/K\nys4ANV/jOfqT/vzjJsKeBgiJ/I3VLxoouWXvss6ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHuBOciQWyzjZPaB6o4gMhVrm\nSO8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMRTwnURyAhdIAi0zXVAcSeJLPZmoxIdRgk33nt/oK0kAiEAyTVlbgdN\ncr+k6GwVZZFn97gM19wYoX94X0eCawGIR8g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQAGQnSJUWG83Fp/JiLa0K70MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWViY2NkNTYtMDhiZC00MGFkLTg2NWQtYTY3ZmM3NDdmN2NhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjhjOWI4ODItZTVjMC00\nNjY5LWEyMWItYTAxMmM2YjY1NWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nv0mFo+lFWFNtOJnmK5jRlPObCozic9Qvqp5ROY6nJBtgdrFy8eGjWgOQWpr6dkPs\npSxuCF/dzeijZbH6O5gL16NxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEgGrkMRIQ4sYA1o1\npM08eVz7BBwwGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSAAwRQIhALM0nX5+MPkR3BChxG8FHFxNN5p96MIlgIaTT5/Js0ZLAiBghzHJ2vpY\n5jmmflMqkyUajy4mjikF0Ln/9DdtIsy+EQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8349", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8349` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAeZL6ohKXpu1CGzlrW60aX+4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhZWY0ZDE5LTM0MzQtNGE2MC05ZWNjLTNjMzk4YzQ1NGU4YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFkODdkYjUtNWVm\nMy00ZmEwLTgxZjAtZjRmMjJiYTI1MmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAER3ce50BIw3/ebDCb+khOnv2pPOv+94UypRgB48NP+3gjhzkm+esDwEvpE2Ss\no2f2zGErYRGQu9MBtkxqF0qvc6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2mcnfyQ4xnOH53eUzvxpBSHXrS8wHwYDVR0j\nBBgwFoAUWXC9VoxSQTCFZayzDx4S4/t3gSIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCUnr5YEPAN5ZXoEvzxCNmgudUpizKD\nfSmFEJ1qXs1UdwIgE7pxzGyO2U29vgf+aQIwqkLTos61fhVWxlcuLNDzEwE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcot0WD1189ijNesEeRlub47MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWVmNGQxOS0zNDM0LTRhNjAtOWVjYy0zYzM5OGM0NTRlOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJFXaepH0LGuL93F7mJraExDPKfAnAuqzjmXEH8Pf0RYz4\nFyWwDapeCfOJi7LlhfF2GQEOLSqmAyz+/YQ6Yywno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWXC9VoxSQTCFZayzDx4S4/t3\ngSIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPtutmLRA2Ej2cZ5V8Klq1DDbcbf8eXZLwH5T0Yj0bhxAiEA4HW/hnGK\naOoRImSpJI1UgOiY0x40m9VNL1gkfRLRMpM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbR4mS2L0cpR8MEDFRhsoQsTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFkODdkYjUtNWVmMy00ZmEwLTgxZjAtZjRmMjJiYTI1MmRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjM2NDZlNTktZTYxNS00\nODkzLWI2ZjMtMGQ4MDdmNzE3NWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQY+Aajl8jiBx9FbbOuBvIcqXxM5v6/4R2pWG24CpCdE4JU+ZSGP7xuuuPepTWs4c\n5eIw7oY9ABAIZJ2DGRhFZqNxMG8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2mcnfyQ4xnOH53eU\nzvxpBSHXrS8wGQYDVR0RBBIwEIIOdGVzdC5sb2NhbGhvc3QwCgYIKoZIzj0EAwID\nSQAwRgIhAMAyZyjBgypUQlnUOVNwtFuY4OVUYzjlIaSGIM1jQLHDAiEAhEA+FQj2\nl6xkPjG0PAnoImDGCqVFzKhkYH3VzUWuA3Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8350", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8350` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAaabP1Y7tZyuWxAxWaguNh9ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0ZmJhNTYzLWQ1ODAtNDFkNy04Y2NhLTBiNzdhMDE4ZWRhNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2VhOTg0MjEtMTcy\nNy00NTIzLWIzZDYtYmZhMmY1ZWNjYThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAMPWeoroglw+euEiW6lfVzNBWIPWQmFlUZFtAoFy62KS3Y3OwUR9FNd82pVz\nuYUyRPXbpMK8whgE/wkOsjquSKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPsOnwjooOn+Wd50vi3mXFFNjC2MMB8GA1UdIwQY\nMBaAFLmf6cbwVtX3Lmuf6/+yl/ztBQO7MAoGCCqGSM49BAMCA0cAMEQCIG2+EqT9\nrbXmkmm3uzAvVuGAknTZeMtBAEyCcxcx9bEVAiAolrtUNHo08Kp+3nZLWW7hiM2A\nrsSp3LszStioNwkvPg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATZmqvr/yi+MiMnGRSNHgTGvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGZiYTU2My1kNTgwLTQxZDctOGNjYS0wYjc3YTAxOGVkYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6a+e2HloAtOXaJdaLsRHEhsMqkmKsHxiL+3jMDk/uER3e\n1qkVBVShJj8PyyEjsZnvz/vJ5LBNd8KKWxHdeRqbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuZ/pxvBW1fcua5/r/7KX/O0F\nA7swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRon86wvovg2mj0uaLTDMFG+ttSyC8JIPVb0A6Z2noX8CIQC4VQSenq+q\nmsYdWuRNNkFfj1nHHcCR0qdaSmUfuW3DQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAXxSE66hV2kTiZ5JSTpaaMRoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2VhOTg0MjEtMTcyNy00NTIzLWIzZDYtYmZhMmY1ZWNjYThhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTc4Mjk3YzAtODQxMi00\nNGRjLTk3NWUtYjAzZTc5ZjU2ZDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2qtrGCPQUekCQYFPzMeldPNNdgsNld+13Bq3SVyGZuibmfSbFm4+fvKjacSokBQK\ndDTJ7TT72lrFJzJ8yhjyYaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+w6fCOig6f5Z3nS+\nLeZcUU2MLYwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAIWeFqOy1nJeBgEdRrxV8Zk8IJ1Ych9ipeXLDlAA3D43AiAY\nKRVDbFmd2J28Joyp9K1Q1YrNI2V2iSkLAf1dL37yIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8351", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8351` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAYirnsGjZv4YqyV9APMhpTYgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlOWNkNGIyLTg2ZmItNGYxYi04MjUzLTRiNGNiZjY5YWFjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM3MjhiZGYtNDQx\nYS00ZWNjLWFiZGItYWQ5NDVhZjBkNjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENY7pQxtpPeW/e1oehXtvDcvpkm+3XbCIyCVWVt5944WzInrwAnPgr4BjZ5cJ\nnGdBOGmaP4lrwMvmJfNvcHVrcqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEkTo24Jy74wnLJjifMWF3Gobvb7MB8GA1UdIwQY\nMBaAFLO8yAknBZ+nWPoRTgXW+Z+W1RvNMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAD6wyCXwJdUU/Ixlx5YQdRWJ5C2QozPjnj\nELIll5divQIgRcYLr9dV7FJcwlT/rzgRF41n1wRBacsBPl/H04Lcnnw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY/DNiouDs+utJg+8NZzf6UCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZTljZDRiMi04NmZiLTRmMWItODI1My00YjRjYmY2OWFhYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUM1hnELoLniHSYWR0LakgYI8n8jjcGEQ6hiZy7MXUB0tZ\noV7tyJKC4t6ihrbWAYufBtGVY3rvll7fmeyFBB6Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs7zICScFn6dY+hFOBdb5n5bV\nG80wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIw43LnsqdjDpEHQmLxpzCpR82Y/t7dYrQDDCGLnz/GYCIQCQe4TfkA04\n73Ga+NBM38E8d9dtsCGIrGLfpcuddmcBbg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISASF+ic9v4Ps3IVaA07B3yniGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM3MjhiZGYtNDQxYS00ZWNjLWFiZGItYWQ5NDVhZjBkNjY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzRkNzY5YjMtMjdhNS00\nZGRkLWExYWEtOGZhMWVmN2IxMzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nd5MDccMnCjGvHVebeu8ZOTHwsUHbT2EKm7tcZI8MUe75ZU0G2qqEIN3+LE6SaA58\n+NBozABrfj9cTvJuQ+40iaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSROjbgnLvjCcsmOJ\n8xYXcahu9vswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgJj2e2JtmVOZxsc8/Yr4aBwrjpH6AhdCr4Jzho6cqVpsCIA8l\nkkFXp9TCeU/GcE3nCHkCJDfr2PMKurGSntgs/0hT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8352", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8352` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATdGvOwWxvkvg6bzOsaD1fDnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYWEwOTMyLTRkNTQtNDNkMi04ZWJkLTA0ZGFkZjEzMGJmODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTllNzAxZTYtNjM0\nYy00YjRmLTk5MGItYzNkNzhjYzAwMTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnH8HZBLgf6RWTUQCf1GM+cBusBJipB9cCyvo97qaz7tXpU1Kf+wn2NGZLbr3\nO+iy2jA2tLRsLQx7Rcn4L4IoP6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCscbJHJvmkh3PpuO5DZBTmou9ZLMB8GA1UdIwQY\nMBaAFCD2f2WX0pFEntI8ZvHCssBcP6uWMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAmu7C82iB5C1kCrEuKDgl1IAz6/vZREjQ\ny2SgvJ1n+okCIALLod1V6a6S7RzypO/Vmgv0TSKZ5CIcaq/18snr4QvE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQcjvJyyJWb+hhuJ8McI02TmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWFhMDkzMi00ZDU0LTQzZDItOGViZC0wNGRhZGYxMzBiZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrSgMl9mrAk91lo1PQLFs9IuDqaAi8CW52Pf0Jkhu4PvRu\nhITrJEOrPB/u0vICy+V1mSEjNWgRC5J0KFvHK7kjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIPZ/ZZfSkUSe0jxm8cKywFw/\nq5YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPcKj62iUYPXh1yV82j/uUkOOlIuG4P54WWPxSeVMj4yAiAreXL2+vRn\ng2HF0mcPC9SEghnG/EgHjZpA9Qc6cp9Rtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAeFtO6cv/PJpaRPXC+yLeYciMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTllNzAxZTYtNjM0Yy00YjRmLTk5MGItYzNkNzhjYzAwMTlhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGE1YjY2NWUtMWIzOS00\nNTZkLWFhZGYtNzQyYzFiOTdhNjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHDiQU99Lg+Aol5x1cpAj0DCvstq9GoIHqOkcoY4vQTuhBBmYZeahGWL1Iry2uaiw\naEn7dHg8RxsmpC4CjJyxS6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKxxskcm+aSHc+m47\nkNkFOai71kswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhANTGsMq5x9dqnQDOouZldWt1xwjSJX1K+18Xake2GoUtAiBp\nHMr0wujwVu2UZ5XZrIFcGs2NePl9YSIs/rY4+tomQg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8353", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8353` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdO3K9hOzJo879+0AdRe/ozYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMzkwYmI5LTUzMDItNDMxNC1iZWI5LThhOTcwNGNiN2Q5MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU1MDgzNzItZTIz\nYS00MWIyLThiZWUtZTc4NmYyNThmYmViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5ddgV8qqE31afyOzhhwfCKWyPDu+RjkdQAUkNJxAorpJXorrubm1hv8PYseI\nW3WnlBPSD1TAZ3NT6cdWKq+sh6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQpvLbMpMm1gUZEAUW5VubrDKFZjTAfBgNVHSME\nGDAWgBS3DfQl2nPqMkaI+2pb6REmVmjlmzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC3LWFYy7QIi54o6I3rGCKeUBgnitzX\nNMqYmYauHjP8mQIgdTYbWdFiSaPp7xPqpNC/TZA7tniluJO7gkApAqU7VXA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcoyB+Vh6rcQy1HD+bS68MmAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTM5MGJiOS01MzAyLTQzMTQtYmViOS04YTk3MDRjYjdkOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLnI/nmMaL44cAa/TOE8gOsHQtEn1CFYGOYLPS+uymPqQs\nLrWWlmb/lJ0ol4F2mDcJWRkuQdUhjlMLoYmXnzpPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtw30Jdpz6jJGiPtqW+kRJlZo\n5ZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRteTYeu42diJxnFP6+WiVfO4NEqYQHwCvMiFMmh9x7oCIDa3t4vW8c7M\nbihllATTsZVjwhZ7CyUoU4EzMUwUUvoR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAX+tdwIXoPX5TgEYh514EFpiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU1MDgzNzItZTIzYS00MWIyLThiZWUtZTc4NmYyNThmYmViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzhjNTNkZDktOTI4MS00\nOGYxLTg4ZjUtNjVmNjQ4MjViNTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndL9s1Jak2IXGvabPi+wrpA8GNoY5gkw70haBSMOs9ydel/svUXvcIjCNpKznkp3d\nBYmuFCVi6aFtHFUKD+aLEaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKby2zKTJtYFGRAFF\nuVbm6wyhWY0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhALc7GjGsP5ytxMCzV23GoStp65DJXNqiyyqz9ZjC4HzFAiAj\nVj0s0s+3Q9BLZxvKMF91sJ3glRVkDu1n7V2j9KoCWQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8354", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8354` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAb9RfjP4xXYaKW1WTRvnovHiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmN2EyYzJlLTlmMmUtNGZiZC1iZWU5LTVmMGIwM2IwYTZhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjVhMzY5MzMtNzZi\nZi00ZjE2LTk2NmEtYTJiOTNmMzY3Y2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELQ90WEzdTw7sa0Pj2yME39c0bXGMT4CMIld2C7C7SBXTByfqHgAgVZcz8A5r\nlXsZevA4wxthNY73OCEVGqu/kKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs3ezGKzEMUpXiHXsuYUHCRm1mjQwHwYDVR0j\nBBgwFoAUNtE6JDdP1RVRXFPDXBzxLdAb6kQwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiA6EIhQCu89rwqB\nzjWiqHxnryo1gjGNGGDeRBZrWNwgiAIgYof5c+sNVqAbhywyLpZ5k4YTBVYMq3qe\nMys1oal+rEM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdELcskpXnFmiC3kPF0h3x40MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjdhMmMyZS05ZjJlLTRmYmQtYmVlOS01ZjBiMDNiMGE2YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFbPQJax+qPNDWsSAI1cRVTXihoBKO358d21mOD4UtrykR\nlOSjiEJJgtDVTJbN05NVkKT5UP2LyXf/P0s1LFsCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNtE6JDdP1RVRXFPDXBzxLdAb\n6kQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOFe8Mn6deqXFCDQsqHM204z+X1gS4mQ5feIsKw43eypAiB8tL+QYsPD\noFofvihpzDm4pBObSBSGneJxjvGUyhIenA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAahzwcZwmrH9XakhaqpUBdnRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjVhMzY5MzMtNzZiZi00ZjE2LTk2NmEtYTJiOTNmMzY3Y2EwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTkzNjEyMGQtM2VmYi00\nOTliLTgwNWMtZjM5MDhjZDM2YmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCJ2GhJuVWBamn8Yjn0CPIB2dTC6k9AQ/TVgvdYGhnvhfVNfcFKoFuOhEffJnB4+Y\nFFthkYe+JfTWjHZOXxRkT6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs3ezGKzEMUpXiHXs\nuYUHCRm1mjQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgbae7u4FYrFBOOz9mzvegN/DGVX/tR+Cjf79fTzmJkPgCIGFX\n8dNmLuS0e7xp0sYlVPTliVQtpYKCYMQxh5htBVNt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8355", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8355` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISASn0AhM22gXIBtuwZyKjd7REMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2MGRiOTU0LTM0NTctNDVmNS05MTkxLTdmNzRhN2ViOGQxNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYyM2YwNGQtZWI5\nOS00NGZkLWE4NTgtNzUwMDFhMzE0NDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESDT1Jg7SGVEXu5c04ASwCHo0lQ9t3kyyQjM42aTfMhVFnJL9yzdP/JD4g2rr\nduW95GBMycJI3gibrMk6r+MNw6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE8H0kurVwkeX/2kuHT+GTFqex0kwHwYDVR0j\nBBgwFoAUFUUmQy4D7kdqaH4M79vQThHiHNswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEA8Z0tCdmgebS7\nbkSkVuYx0BQoQVvxPmRuh0gCD4R0AgwCIQD0GvktZRamdo+6IQejojYDllya4Z2I\nesSHJAwlBOKisw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc8omNKwbP4sdGEqBqxunxBMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjBkYjk1NC0zNDU3LTQ1ZjUtOTE5MS03Zjc0YTdlYjhkMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP25sAbU7Gn2+QAjOgt8yWeX/2yW+2MFylH8PxpgYBJxt/\nyZTak9umVB4+EflS4u5YHM6iDS44Xhy42TGJNDN+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFUUmQy4D7kdqaH4M79vQThHi\nHNswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOwyvwBAFAbiDm9e790nEs5V/apo04bfsnIWyPVZqqAqAiEAp36G7WUX\nxgwhJtUvUq53Z8wGan4KtHTqkNPQy9GWYcs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISATMqly4wELj1MhdR71kjn/W2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYyM2YwNGQtZWI5OS00NGZkLWE4NTgtNzUwMDFhMzE0NDA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjVjOGMyNWMtOTk5MC00\nM2QwLTlmYjktMDRmNjcyMDFkNWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhSaLQMUr8T2Gj5zuvfAJzKxBIXcVBD0zfIFI/14Aibl48iCNWlcOTjXS07SICvjA\nHqG/LdvNchnd7NyLQZzjUaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUE8H0kurVwkeX/2ku\nHT+GTFqex0kwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJzQdSJNcSeBCVowbdMIPJ1lSpSugJw3E8FDB7YdVZ1NAiBe\nDNm5nDC0/dr3KQRPpmTqHIkbtZ423zOf57rdUNVnIA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8356", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8356` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAXCZaMIlqmxs0N6rVWr52PvEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkOWMwNjI4LTdiMGUtNGNhNS1hMjc3LWMxMmFhNzcxYWJmMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRiZWQ4N2UtYjM2\nYS00YTFiLWIwYzUtZDk5NmEzNzdjYTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAIQqU7QF3ztFTDgf5+USCRUw44skHFJI+ZFKMXIfEZsZvNoclfTbuqK3HD+o\nRpt1WgKDt79+pwIphOQD/fvth6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiyzFBgyimecF684O9fN5WwdL6wYwHwYDVR0j\nBBgwFoAUp7BtiwPDzhQ5kknTf71mGJtE5S8wIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiAkBCLLeICF38e2ht9zdUIT\nUdNZztnbMYEEwtDz8hBFxQIhANi40tN03WmszrAawmQ/oUmExiV3G4Opb4tx7BXw\nZnje\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS8LtDHX2jKNR85y/zzyWWikMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDljMDYyOC03YjBlLTRjYTUtYTI3Ny1jMTJhYTc3MWFiZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6GuEzGjGiNev8zQhR5OW3uVZapRfeEa76JEJz42G/Ess4\nUE1CaqbXDgfIEpnryF7mXvd0hysGM3XagPvHA8b0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp7BtiwPDzhQ5kknTf71mGJtE\n5S8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIffmpI3/jp/24XwxobOsjPZWhtJWbrtyYVdAlcsDrK8CIC6mblpS7Mnd\n17yJne4yqqV98dni3t8K2pmKDlkreV+/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAd5gQvg6zdXBAl0QfWKdNjB0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRiZWQ4N2UtYjM2YS00YTFiLWIwYzUtZDk5NmEzNzdjYTc5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2Y4NzQyZDctMDk0NC00\nNWJiLWI5MDktYjQ0NWNmYTNmNThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\naqBxd+2HiwmEYObZQyD9dIbBD3OHyy0tB6Lx0Ups6UqGLeViBVoUKkvTki4g5hcH\nupfz30YtY/afcC0OqefC9aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUiyzFBgyimecF684O\n9fN5WwdL6wYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAM2f/Iv5aZ0oQY3gIGv+2LbXAxVUuIO5qL33giiFi95aAiBc\nrmHAEVtDY1cWnwiuTiKdTSrotA7UZqe7cl8TlfivDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8357", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8357` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAQiuVBVD5FGQT3ysngKnYVmoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2ZTAxODk1LTk5NGMtNDBiNy05ZWNkLTI1YTM0MDdiYjVhOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdlYjdkMzAtY2Yx\nMy00ODZmLWE2MWYtNGFiYzAzYTEyZTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHBe8A1WRIctM2iuMO8WCZGMTopy9AWm23bpl5+yfP/fdwPR1xBx2MmC+ZOFq\ne+3VpDMfmP7VtxaDPFvLi+IWAqOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjg9kkd0s7z0IlZ/h+dMABsZWTuAwHwYDVR0j\nBBgwFoAUQcD6eBar6T4I2Yu75EnGHx8hQzIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAh2jS\nXJ9OyZLK+D5+yoLGUYJmkm/Sjj5E11+3jacXw8YCIHKsuIZ3cFoBpDvR1sUueUxQ\njnEbQGvv4rqDRlniNiVV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVXNSS9/v4i9eW4b37k8FPmtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmUwMTg5NS05OTRjLTQwYjctOWVjZC0yNWEzNDA3YmI1YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCVvBeHPcRIjH8PWZi7SvWs+iRV4UxDHmnmlRIoo/YWtrp\nF1KIwL0e66+GAexxZ1qPOH7nm+3wI581pOPVcvoGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQcD6eBar6T4I2Yu75EnGHx8h\nQzIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRmakBHbqgP2fDebsRDHek24xbYT3Et1n2ExJcOH/edsCIQCpe5zfS6MT\nEltnNAspjmrkKkscNClnfPak+NeuVjP/5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAS+HNz8soMhGp/nn8NEMoTGrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdlYjdkMzAtY2YxMy00ODZmLWE2MWYtNGFiYzAzYTEyZTVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzhmMGNjMTAtMjEyZi00\nZjNkLWJjOWMtNTA1ZmE4ZDM1OGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAyc5yCxcDfrD3N8/vmPo4HszVdWZp1Kif9hO/okAM8N2fK2Tg3EdMWJ3Y79z7pCs\nJrmbT2f93SAXqlULgmgOrKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjg9kkd0s7z0IlZ/h\n+dMABsZWTuAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgczOZChQR/GULjnGhSMcAG4Jdx1g3lSj+7c9F95Lynh8CIQD3\nvfwBr9WhX1pn7a3zdpKGSTJJCI1ZNkW2X7aa90Q9EQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8358", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8358` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfGgAwIBAgISAf87vOlcjiQObnbGkyWy71ItMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxYmZjMjJhLTczZjctNDg4Ny1iNDk3LWM4NDIyOTk5MWNlMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU0MGJlYTctMWEz\nMi00YTdiLWJhMTMtOGYyYTk2MjMwYjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGysNhv9J4c9UQltQRJqIaORO5PIFBUHcW9TIKsQwdaM3e7EUI5x5FkhNoeSO\ncLJV+zwoe3WtaouiC5aFohLWSKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS2GuTyV+K2uM+Tx64AbaIDqP3/YwHwYDVR0j\nBBgwFoAUuaEsls7xpFcBqQ1MRHWgoTEwM1cwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJADBGAiEAuPeA\nHroXCwARoxJJDwJ57jodufp76uH/x1R/0BzxO+wCIQDNSc17EncX7guZKwajAOUm\n7ZS/4GlrkOdE/c41Fk+sPA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY4nSCBIgiSroJqqdZjjCwenMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWJmYzIyYS03M2Y3LTQ4ODctYjQ5Ny1jODQyMjk5OTFjZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfLCDe0eVESg+abGiy6aU67wJehihOgT1u88+eKRWW7PyL\nHwC0pCMTKZ+VscgZthOtDB8uDAH5oamVdw4YZoUFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuaEsls7xpFcBqQ1MRHWgoTEw\nM1cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMOYBxMLAh+a6Yr6Ta8RNiVqLcEzMzxhCzIetI5IYHunAiANAzEAtYzd\nqi1LX6h/ChtmGjJokObXWjPqmOcVIwKezQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAQiOlkhT5gv/Ah6CHS8JGMS1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU0MGJlYTctMWEzMi00YTdiLWJhMTMtOGYyYTk2MjMwYjJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWY2NTljMzEtZDI1Ny00\nMTQ2LThiNDMtYmQ5NDMyNjNiNzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ny6q0RDgZQOZqjUWqioYbYJwJnGEjX8G9VINimX5h217l12SVByW7SksIM5p7D0bz\nY6ok3ZpL/92r/MMA7EaYt6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUS2GuTyV+K2uM+Tx6\n4AbaIDqP3/YwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgHzchb4IZ6wrd0ITaC1dYsM//9cBEbU+xMH/D/tl5kdECIBp5\nxt8HXv25V+8HfhdxAziSm3RvKdUoH2aZ7x1K+3US\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8359", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8359` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcjmhuJfJO5U2yXnEN7bhW/lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0ZmUxMWYyLTVjMjktNGU2Ny05ZWZmLTBiYmYwNGE3MTFmZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIwYmNjN2YtYjdl\nNy00MGI1LWE0YjktOTE5MzRiMGE1NWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB0IppYeDxGj9P4he8X+NMoxKz6+7iWI77lkauyvshFRcTcPVnOJzZrPokcss\n7RzGll+bCDz6KB4rv7YcoC/3lKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOX/Qe5IHJhHgV6bEj2pkgygJmEvMB8GA1UdIwQY\nMBaAFNC3oxpF/6VO7DhbrgQTrmN8uzDBMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBLssYTxvgOCgONl+Rs+diSb+IyS8nW2N2W\n8eEa0ljT2gIhAL3lfXjFg8faBj9cmI9lgNpUW2rElvX6sfuI9/ovpEmT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATUUh0GnFPUOJLLEQ2LO1BEbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGZlMTFmMi01YzI5LTRlNjctOWVmZi0wYmJmMDRhNzExZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASj+tIDm68FqcYxG3m7iVL27JM1lJhzuUBUkjxuZkgjr4JG\nwsMI/ODDNYI4IcYPj3HMnM/Ie/ORSyIrh1n+4i28o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0LejGkX/pU7sOFuuBBOuY3y7\nMMEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIga1FGF3iN3qZHUAgrOsM9wWA50Z/hGIDQPUAd+FhgUdcCIQCarHjYwwWG\nqgm44hkxmOhSG2cLqYJHEiT7AQaSLfSNuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAVykSSI3kRfz7H8/zWhDgw9cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIwYmNjN2YtYjdlNy00MGI1LWE0YjktOTE5MzRiMGE1NWRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTY3Zjc4NjItNjZkMC00\nYjZhLWEzYzktMDVlNWIyYzI1Mzg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njQ/RIUG4pekSAHkKU/qP5WvkRQgLAEMVKsNIZkWbybvXI/+yUgDZl6iVG9Uc5fCp\nxqavmp/shN4D4RVk+0KAjKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5f9B7kgcmEeBXpsS\nPamSDKAmYS8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgHIp6TlzcCpuOulmVN7lsqPAcHjyC9c/TD0OlfxTe7D8CIAsG\nk2hiOgjD6PWgU5WVVFh1nbdYu2yWN9ZJFfKI/i0w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8360", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8360` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbTzLDL9gymgGXxBixBmKkNtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljMmU5ZTMyLTJmYmEtNDg2Ni05MzI5LTczYzRkMjc3ODU1NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM2YTlhNjctZDky\nMi00MjhhLThlZDAtZGFmYzFhYzIzZTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETTUgnIR8rZoKtqZHTmLpu3qZ7gW2Whh4TWyPSre5QXFToSAI/M4f9hfmCZ69\nFmw8t5CXuWkJEOVWTfl0lJMbuKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWFCmxd6iWdezmRjoTSrlPje+YAswHwYDVR0j\nBBgwFoAU7f5iSZSDySm+S9Ah8xhWmr+D3gwwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgKisPX9leAc+9\nYYgyD8f77pXEpAF/5C+VmqVe+kWNTWkCIQDrJ9kB7Jz08a1XQd+Yz0IS0jy2kkX8\n3+NWboKMUGE2tg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAefmKX1qB9dY4K5SrrBeCFYwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzJlOWUzMi0yZmJhLTQ4NjYtOTMyOS03M2M0ZDI3Nzg1NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScoLS3MVCcb2KdbzQvf6xFcjpe+fHfrhlyj0qwR65gE0q8\nYQ0qbB4hGnl7AsM6TL4fp2BAGgnb3vQrU1TxsKpuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7f5iSZSDySm+S9Ah8xhWmr+D\n3gwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO5fRwilimTO0gk83kW7V5wcLojFGY/geoctFR2Gv8RmAiBVlrskr9x4\nb/NwAydDDYOc+BC/X8SqYPzurDEW1CHiUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAfnVY21YONTdtKqCU35yigzbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM2YTlhNjctZDkyMi00MjhhLThlZDAtZGFmYzFhYzIzZTAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGYyZTdkZGEtMDAxZS00\nMzBhLTljOTAtMWU4YWVjNTk2ZjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njp/x8tSx+LFZXt457c9pBaictsTO1caxBYr3G4WmVy6TEg+5GBozgnBeQ8xmksAH\n3OduMQe5b2il97gM5APuSqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWFCmxd6iWdezmRjo\nTSrlPje+YAswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgf5546qc/GHkAhJeZmV6Haey3d6Y8VmkqCV0+ftob5zMCIQDF\nlkFeSE8r6V6TZGA5SxvrmXQjRGAkppmTE6pYzNSRWA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8361", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8361` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISASVp4xegzV3m+f3K4qZoU6NhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzNDg3ZDNkLTE4ZjUtNGNmMC04OGM4LTA5ODUzODRhMDZkNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzMzNmIxM2MtMGM5\nMi00MDU1LWJlNGItZTc4ODk0ZTcxMDQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Gb2ZKdVHz+Wfq7q4GWzL7iSXiRwesFEIjQITisYXWmwce/YQ5PF42RhhbTf\nvk3G+GIAigvvJbauIh6TaW1KxqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjc3u7ntFDLZ5h3UvPMspqny2p94wHwYDVR0j\nBBgwFoAU7kA8XNzGTwoVp92I14fdnlwaHgswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAK6IGhH7Xs6F\nj7WFy3IzSE74cd9sOTnCM/KjxfKswb83AiEAt4q4PKfQ9Pbp2xRnNAjZSBrZHESb\nC35vAD+fIToLf2Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa0x+ewo45eshjnRQcdBZ8UaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzQ4N2QzZC0xOGY1LTRjZjAtODhjOC0wOTg1Mzg0YTA2ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAL5MCMveQBbFtOc/I2hr4prYaDIrW3+zinYgWZfdcKCp2\nr2HCE+ivOgLLMPq1VKrvBcB188xkfN4xMhBu05aqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7kA8XNzGTwoVp92I14fdnlwa\nHgswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPIikAPGNBmX6slo75LCB1ca46TiXBVgxN8v6h3akPM4CIQDP4H+gzfLv\no0ndfNB8Pea7tEJs3XwGOCNtciOvLkKTQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISARid1vaJg965vUinYepVsj6BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzMzNmIxM2MtMGM5Mi00MDU1LWJlNGItZTc4ODk0ZTcxMDQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDE0ZTIzZmMtOGMzNy00\nZDkxLWJhZWYtOTVkMDFmOTlkNjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\neM6M6vQZ5AVBHYIjL9pj2NWv+LNFoOXhjnspFWV4XLz3R5yYYPLMp6qPJqu6XX37\np316jS4iEdBrFzx0oFiuj6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjc3u7ntFDLZ5h3Uv\nPMspqny2p94wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAKzc1V6WZb+hdq7gmyUV+to6oWSFo9YMJ9xmTR2CoekZAiEA\nheRjOWVo1zs7Gf/2RZrIrJlmeLNca0d4UwIO90ZLbag=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8362", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8362` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAaOtxa7EQznG/J9o0cRCDUDvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3OGE0ZTU4LTI5ZmYtNGU3Yi04ZmRkLWNhY2VjNDJlZDlkMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM5MDU0YTYtNTA5\nYi00NmJhLTlhZGUtMDViMjY0OTg3ZDZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMXYbkem12xMXyrmdLf5Xe1tNlgoh5yz8k7hOd1G8Iq2/B1db3GHfYaM3dcHj\nR9l/BniTzZh7T4VMVUiWFna3aqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJeh3cpxHot8L1l1bB84Ile+LstQwHwYDVR0j\nBBgwFoAUDQebi9dTue3BYtXnc4Qw/XPHH4cwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIE9Ds1jThV/l\n4/G9OL26UY6J2QLEnpH5DYTYw+n3YFYMAiEAy1lDQgR6cW7nXpn0tG9kRDgsk3B9\nMG0y+werHjy8NqU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASW4KzyJt7UibH1huDLn3zOdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzhhNGU1OC0yOWZmLTRlN2ItOGZkZC1jYWNlYzQyZWQ5ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeaCTZNCQBhc1LgExrWTLM/Ylju3aL8wj/HFg5wkA++O/B\n5xBkbrzlWuYoA7GDddrOqmDSHeCpd3GLUmA00Yg/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDQebi9dTue3BYtXnc4Qw/XPH\nH4cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPbEB1YC2ZjcPK6XNt9V8EA6ggarPN3055FmeBYjMPKZAiBMVh3CLSrq\nzr45MoZvax+D4cRE7X88i8PXZa7lSbfYQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAaxxNpUn3XbQH9yMHVOPhGiWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM5MDU0YTYtNTA5Yi00NmJhLTlhZGUtMDViMjY0OTg3ZDZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGNhNTNkOTgtZWRlZC00\nY2FhLWE4ZTktYzc0NjRjNWZkM2E0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/s6P8OFzGP2OmRW+fqclbif77FDujNklQyHKzz4k5U7a7VkG8HeGDaIWzieK9KwS\nUUg8Lh+rZLX1FZ/tCE3rfKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJeh3cpxHot8L1l1b\nB84Ile+LstQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhANRcMh+Gp8N4Sgo8udsWLGv7Inpvqg0feYjCHUhpnrisAiBW\nB4iDPYPg45be13xmLL3OYao4s4q3JnH3OWwYEfPurQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8363", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8363` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAY66i9cs5iiWybUpp7SDrDT7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMmNmYTk4LTA1ODktNGNhOC1iMDkyLTcyOGQ0Y2IzZTE2YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RkOGZlN2YtNzEx\nYS00NjBjLTk2YzgtMjQ1MjVjZGUwM2FhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcA+erdlQeFTSoealHIuy2yYp6a4FuNN665SECJr74FKgN/AA4FVUej/misDo\n1y+qTvgwXk0ZjDYkyZZPZvi4y6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3OmOQzyNbHi1SC/ieZHl2p2557YwHwYDVR0j\nBBgwFoAUI+kk36gvNA/KUO/VFqZjPG/3MYcwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD4966S9blh4TCGb4WrklKL9ypw+2+ycvxguagzKGnYsgIhAMFWUxQfDlyT\nED/I+HG5/0ka/CLV7oL0CuhDSgDCor2m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ46uqr9C/209gw2zWdUkDXPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjJjZmE5OC0wNTg5LTRjYTgtYjA5Mi03MjhkNGNiM2UxNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZ+aV/dPt94L5fiDraCx6XD9kXSqn0MqX4wDjMYyO2jQx4\n+0SxihfZglYA9kPGBFi+JDff6mse84bZWpnQU2Zeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI+kk36gvNA/KUO/VFqZjPG/3\nMYcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALs8DcozKbx5bNwFzevli5x895oMtaovOIFTDNOtUZGbAiA/596kw5Gj\ny8OE3/eWu4l96XOkDqCWzOmckWm6l0ESyw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAWk0kSfJcy/dFHvK6CzPZRGtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RkOGZlN2YtNzExYS00NjBjLTk2YzgtMjQ1MjVjZGUwM2FhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjg4OGVjNDktZGJhNy00\nZDFhLTk2OGEtOTU3YmIwNzQyYjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFM8ezLtb0Fpcc/8UXKnx/7OUfPHLl1BZcr0XnGsM3+o5H/DBk0sPOSqw4A1wR51k\nzGOrGXY5Rn9pu4tGu4GueqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3OmOQzyNbHi1SC/i\neZHl2p2557YwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAPEWkwZgrUWmpIz+jSONOVA3JuvLsj/BiJpcl3VKVYmzAiEA\n0p+wa0m4EN/+Rm9JN/nRcSfA1h/79L4nWu5b8g18uWM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8364", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8364` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAVsmH62zr/W5TuaehxKU/UpFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlMzc4OTk3LTViNjEtNDQ3My1iN2QwLWVjYTY2ODgzNDYwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWNmNTcyMzgtZWYw\nZS00MGY1LTllMDItMGNkMGVhMzhmZTg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvQ2mxckUEFrWvJDwCvzUnSBDlXnjpkaDeZRGW7vyvySXK8dt63ClSQPWKLJk\nPYPYwFO1NcBvf3H6uyzYRJn256OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUolicUvs/AWVwbpyc44jcpmTxSZ0wHwYDVR0j\nBBgwFoAUl3RfuHPg0RVi72Mjx8Ob2TIr9rMwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDw8vUhu5TJmGWn/UOKkXKZ/5p0c7Ssyun/3O9UXu4CzAIgOEeqRSYYxG9Q\nclXZjWV98gj2lnXkMnjFZFe1KhgM5c8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXk/5rnCgj396rsPwH5MpWm7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTM3ODk5Ny01YjYxLTQ0NzMtYjdkMC1lY2E2Njg4MzQ2MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvHs+dUAQ8ZZWzeVuwhuN88fOv4YkyjJC0809akIMLxYfh\nzC0fpdsAegcovgz2XdA7/dJ8ozRCLJKlP2kMLiOno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl3RfuHPg0RVi72Mjx8Ob2TIr\n9rMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOk7EygB0tbjMiaDigPY+bAAlp2y1sufajdkNAf0uQhwAiAnXPWMyJuL\nlNjZpUVhN8MATVHuPGQhpjEpaT0FQHFh/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISASCYPbUTSGwfsVb/MqLhWd7EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWNmNTcyMzgtZWYwZS00MGY1LTllMDItMGNkMGVhMzhmZTg1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDk5YmZmYjctMmFlZS00\nMmM0LTkzOWYtMGU2MGNlMmZiNDU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nnV8tpoO7T8ZxXQEh54xT8X7FIRqsxuD456qlFIFehjvWU6Yfo9CtiVRGdoW3p0VQ\ntHIXgmhn1KDIQeDLU0E+JqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUolicUvs/AWVwbpyc\n44jcpmTxSZ0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgTwIn8NBQjfbWfLJtriyesRou15l6D+rUgPpm3HqT550CIHZy\na4VM+9KzHiPyMK2vewlK5GYwwd4cpBEmvBnIO0CO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8365", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8365` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAR/LLocayOhZeC6NOY80QENyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhMGQ2YTcxLTFhNmMtNDZhMi05MmMzLWRmZThkMzU0Y2VhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjU3ZDExZDktYzc5\nYS00OTU1LWI0YjYtMjU4ZWUzMDk0YWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3TvssZoLJ0BnV1KX/kkbUWY0mvUFP+u+X7RerlgAhuJk23EqB8PM+iIeIIOo\nEJyI7/5LesiG7ZBm//M3YYF1caOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiCHrYgrv8mPqqXgIGI6pqFunfIswHwYDVR0j\nBBgwFoAUiYsBu/IirJp71PMVScpNWOeFFPIwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGpc\nZan6IPvX2L49csBOsis5dDXqFvBP0LO6MdbJkz/kAiEAxDtm8cXnkcciYwFAjpxO\ncI4dzdmKwgjgHtwqz7SX+wc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbUJEYQl7ebWMGqhNNNCC15gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTBkNmE3MS0xYTZjLTQ2YTItOTJjMy1kZmU4ZDM1NGNlYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR4mqjl6pYP1GewF4NivbfX3DDA292v37Vsi7BnJU7LsmUO\nmp06mtJ4M5RPjWp3OoT8ofzS1S4Miq6xnK2zqKTEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiYsBu/IirJp71PMVScpNWOeF\nFPIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLgH5OVx2FjP5WapUc7YM+qceXO4aA573VJ16kQEKf+sCIQDvk8hwYxH4\nzG4g4fCgVPJftcOCIqtmpUkKeIoMZ5Eypg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAQxOIewI3ZdJa59U5Grs599DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjU3ZDExZDktYzc5YS00OTU1LWI0YjYtMjU4ZWUzMDk0YWI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzBlNzBmMTYtODcyZS00\nNmI5LWI0MTAtNWUzOGU2YTRkYmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVcnYDp9fksns3F7mil3HkVm51BFzTPlstHJwizmfKZ7NQPEKUj2SyZMubUajVdOm\npF4+JWwxBWkcDWAyft3BqqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUiCHrYgrv8mPqqXgI\nGI6pqFunfIswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgW21DaCZy9bDZvAw3ToFYnGiq2Srby8GYTVqeyqEzm5UCIFOh\nLBNP/VSHzzl/uKyMroAp59YA+EHruKyT6Ug+VE70\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8366", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8366` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAaYy9ftcBA/8XyCT64Cb+g55MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5ODc3MGNlLWRkZGUtNDkxZC05ZjhiLWQ4YTk2NmVlYzAwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA1ZTg0ZGUtZWIz\nOS00MGE3LWFkNDEtODllYjNkZjE2ZmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4idU4VhMNa/yV6wdtxLRKpIfV0/fTYU4oKviOgD+bd81sveMiatQV5oQv1k4\nX3M/MtsIUjrGNZHSbaaFuWENUqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNgNoFw5aG7jVX5hdYSqNIeRWKH4wHwYDVR0j\nBBgwFoAUDbBS+zrK741cjStjbdBO6SouDEIwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQCM6gXmCTsH8fvpSwp7mCL6JL0PMRD5mlQSxpxnHFNPKQIgWfPx\nn3Vl0o5IG45IKQpeO8DkM1tYCn42c0MeMu+U+Jo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZiibkXsUhkMpS+yx8lN7RFKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTg3NzBjZS1kZGRlLTQ5MWQtOWY4Yi1kOGE5NjZlZWMwMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2m0vTmNPg0s0SpM28kiz7ItPh6cMs4RA5n5pIysfVSOX6\nfJFS90vAdAwVx9XQzsSYSl8Kj740FrAtWggDtnnYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDbBS+zrK741cjStjbdBO6Sou\nDEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAx9yNLN6r4Tas5VENhZAb5tWhkKz5LM555jkrM60cOgCIQC/1/4jsX/W\nxjW2huXp+5hekug65iWV6eQu4xmi1fkBYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAccaMGnyoCNqa692c0OUxCpNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA1ZTg0ZGUtZWIzOS00MGE3LWFkNDEtODllYjNkZjE2ZmI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDdkYTg4OGItZDVhMy00\nNTBiLTg2YmYtYTA2NzZmZjEyNmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQXtTVWUacOgc2QAvY7Bv1FkBAA94WUJxRbu1oaG00UxlseZ1mjAHHz57PlQA8k7g\nw3UDSKIxdRpB4BwdnG25PaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNgNoFw5aG7jVX5hd\nYSqNIeRWKH4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgECvux9d5bt5LofO3cCCb5hbnTA91wfgsh7xrkj5u4JoCIQD+\nxM+NBDEhBQZrczeD48kBU37WGHhu3LRpbIVZaKTT5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8367", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8367` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAQeDtuwQe4QUuSpGngVhRaekMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhOGFiNTYwLTUwYmYtNDdlYy1iOTdiLTMwZTJkOTUwYWJiNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg3ZTIzZjktNWY5\nNC00ZTQ5LWI5MWMtMjg1NjY4MGRhMGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx+JFJaEV9FwKkcL88skp1MepkeROe1ekcriHLMU4hbFGqYa7xz2RNyTo3bYX\n6/nCGKAs0F0wtq3snF2sSsY1xKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFCNukTh5dD7/XVqiphstqMC1sAUwHwYDVR0j\nBBgwFoAU0I1FdZd7NfPaXbcULmmUEwbsNjQwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCctTKL8Yc7RU1935drvAL8IgsAuT06lISTzXrJhLtKvgIhAJRO\nbooBVg/uFRQVI8Y7rF5XHbVeJ7TsdrUBiaKquQjG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVNxO5xxsNVmr9bOSZuHSQaVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYThhYjU2MC01MGJmLTQ3ZWMtYjk3Yi0zMGUyZDk1MGFiYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnDWLFpOcWJT7/W3WREqp87WO6+ZHWJccnjvwOYT1jttnD\n9WXwj4xKBPErMl0aY8+hyi2j5yulAeQRu5E6Wi8fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0I1FdZd7NfPaXbcULmmUEwbs\nNjQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLMs729SXyJo44BdY3IbeU3Es2kKOvFW5cOzIXToQGzECIDdCSPbaZhgc\nJ0NURkMrfzAeRAVjOaidhTkh8MgGtPV5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAVi6SIgCQtkUbl9uUulNvvdpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg3ZTIzZjktNWY5NC00ZTQ5LWI5MWMtMjg1NjY4MGRhMGE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDUyYzViMWQtYzMxMS00\nN2UyLThmZjktYjMzMmUwMzYxMzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWjdwtGJAhrsDkDGcDh53nuYLeg4azRQB8OuLCflTr7DApaXEy92uRUstdOV6i1VL\n8xygicjeVRp1Vi+pTYaCJaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFCNukTh5dD7/XVqi\nphstqMC1sAUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgVD0d7ddKerz/CpgWGUofczuGvdPvRPBXQV/5PExxm0QCIQCi\nKxptRzVTebGevz8c43wJAc/ECTJJWqOdnORlTVSNwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8368", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8368` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbPpgIVlOSfe7wfM5L3UdnKLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5ODM3NTBmLThhODAtNDc5NS04YjY3LTk3MDk5ZDQyYmRmZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUxMWRkNGYtODY5\nZC00OWZhLWFhMDAtZmM0YTE3MmJiYzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECt+z9g2DoZlTb/FD4gfmwkp8I8T/fnU4MGyJ2B4cW+o446vZIxXVjgL2HsoC\nTVRQo06R5AXoOLHUXCVkbpBNpaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAZy2wij42P8I6rbAn50lGs7l+4dMB8GA1UdIwQY\nMBaAFLh+9LO0MB4WnFjIV663mKwocVtbMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA6KYpIpvaZnvXtKTieYRdVVccA8C/S5AR\nQfwBiVyVo/QCIDp0x/soXwc6Atu92+zFV+9vhh4X06wpEVyC9EsHoW/7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATXtj72cjo80+nM+w96qCMSoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTgzNzUwZi04YTgwLTQ3OTUtOGI2Ny05NzA5OWQ0MmJkZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASw3Eoc6X+X0a9N1abTIom3+W+y8K9ycD5TWm3EN1wazVxM\n1ubbIsP75tCmZ4qZRzBl6AiSUclm3+oyCTA0eUnUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuH70s7QwHhacWMhXrreYrChx\nW1swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANoyQI3dH7XcKqxMt/4M8bIM5f9Ypd8WuNt3IKwSXiScAiEA8o15e9ge\njBzs2Vxvin937GCZOWvMLHECG6nAk63LYRw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAbfNe9p5xEC9xvPdz+ZhVv69MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUxMWRkNGYtODY5ZC00OWZhLWFhMDAtZmM0YTE3MmJiYzMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODM2NDNiMjgtZTFmMC00\nYjdiLTlmNDktY2RiMDNhZGM3ZWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqerQIygMDB3bZlf3nXXgcylUZpM0UMPtDqnewre35bkT6plb915H6XFMRu+VjbSU\nCzx42Mov6H+XpBc3a7nC9qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBnLbCKPjY/wjqtsC\nfnSUazuX7h0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAONA73M+nxKsDkShqlxORg6x/tMTy2Ok9u5Sou97RqDHAiBe\nLFF5FLenP9kZhpgAb3i8GImJRgr9GJf+QgY/z9xXaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8369", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8369` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAVZa2zHKiefxV4eKG+txoAawMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMmQ3M2Q1LThjNDAtNDM0MS1iNzcyLTEwYjhiOGViOTQ2YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFlNDVhMDItODdl\nMS00MjY4LWJmZTItZjcxNGU2YWIzNjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwziVWwXswAoHks1QN9LhqfvDhx+10mK9PQ5KN3vjuj8bjpoNUFOcoLW/f7QM\nsfkRkPbLYGTpFuM8hM6L+ZYM+6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUifoOkIlIFTvyvFm31phBFcLieZEwHwYDVR0j\nBBgwFoAUxEiodbv+cSWmQlg8vxdFRhCJUZkwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhANXRq0LOWGqB\n+bqzr84N3GzoYho46NUX7yy/6ncZHt0SAiEAi5igAnlFT+Wo3KFGA8yaqMH0101n\n3s+qwPz9ku4cgXI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZqDaAvx00S5ozrSqz+gZ/cyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDJkNzNkNS04YzQwLTQzNDEtYjc3Mi0xMGI4YjhlYjk0NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIb3m6+VnYKNOoXQGrxxvRj5Gieg+gSGXguZ/0Q++kwUtv\navGk3u/FQ/L/u66G3/Vy/m1Qe/02H4NkTCUyV+j0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxEiodbv+cSWmQlg8vxdFRhCJ\nUZkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRCI6rGXKyB2paEVC6457T4p11+ZxnRZd+Yg9E/+JVGMCIQCx1CuSV58c\nhrJHMBmU8aqfJJSiGf0IQWCr2Djt6+IZ3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZB2lZBSJztWR3jAP0ed9HjEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFlNDVhMDItODdlMS00MjY4LWJmZTItZjcxNGU2YWIzNjgxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWJkOThiNjYtYzk0ZS00\nMmMxLThlNTEtMWRkZGZiYjNlY2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPRCzlknO80ggFbMLMQFUM/siAgkJtSQFWwbwDHB+HClyfoL8Z3NS6wbaBHq+vgUR\n8KfKkbq9xEu7eQKVvkiIFqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUifoOkIlIFTvyvFm3\n1phBFcLieZEwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgYfhL3woYWAbDB3v8uOS1zI8+6+fSYNTmcDtImHutY/UCIG1D\nEtv1yWQN5oNWrQUIfD/mnicC0MCgYAWmcTahbKz6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8370", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8370` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISARPmDrwUzVtNaAM5dTJ/ntrgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlNThmMDY1LTA3MjgtNDgxMy1iZWJmLWVkNjgwNTUzMjQ5ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWU3MzEyYzYtZGM4\nMS00N2NkLTliMzktZDEyYjhhY2MxMzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH7pUKvzA1I7wLa6s3d6/gzUVZKuSVvbJbg5tngcN1FCG+ioFa+a1YvcM5DNs\nk9I7qZWl165KpNfOAOEPd0i+dKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY//b+qt9kBfX7ZpccyMfHwsIKTMwHwYDVR0j\nBBgwFoAUxTJQLUT40I1l9kVG8SCfMccOa1YwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAI++NNI4eQ8y\ngiNSARtCYJ8n/6njqYKyvqJLu0lXHC7YAiAkDQcf8uV2zy850CRFhhYA/4nUthDp\nyUfOpumUeOqe9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXevwIOeJYg/pggiEVdIoPLNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTU4ZjA2NS0wNzI4LTQ4MTMtYmViZi1lZDY4MDU1MzI0OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQx+m9muvg71e1ytsSBKyVBm1UvRclsm6yOL6ezT0lATjpp\neqRsxX+eA9gk3JO8Rul29cCkXQ4fQoncp3+ZGNBVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxTJQLUT40I1l9kVG8SCfMccO\na1YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKPV/L/THuGPBs82OhyYDkI3D3JlCwsRifgwcHBXfGvAAiB+Y5xk/8ok\nH629Hiw0r7um812jGjjz4X9uSmgMwJg3pA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAY6WYmofahMbIhVEbnxFpqhuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWU3MzEyYzYtZGM4MS00N2NkLTliMzktZDEyYjhhY2MxMzMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGM2OTFhYzMtZDJmYy00\nNTI2LTg5ODAtODE1YmEyMmNhZjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\naaCs6IbhKcHdQrImm83gxrzxoD5YYxQT02GLyeTtfkE7LD/f9UdZtUPLpIvNEPt+\nFFBuxksZSoS6k37Ml6s5b6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUY//b+qt9kBfX7Zpc\ncyMfHwsIKTMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAPAwoCTV1TCd8/oo+mno5LDk5A+W4iT4wEbBfG2WZan5AiBF\nHbDxp8uOB6ZtPF2MQY0a0L6WbcWhk8qq7huMWF5jZA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8371", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8371` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASntc3x6bk5o8re3WrDi4md6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlNThkZmVmLThiMzAtNDBhYS04MzlkLTJkNmM5MTNhYTVlNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RmYWZlZGUtOWJm\nYi00Mjk1LTg4ZTAtOTUzMDczMWQ2YjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/rZYopKwbRO1EWisJz1lanvzhQF1ETwzCKCKH4ZBYzCO9oaSVjVvCMbgqjHi\nREJnVUMH3UH8+NxTXISLduuCcKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA2ayhueV6MPBEDuHDzXjU7FN5zkwHwYDVR0j\nBBgwFoAUOIotHoI9Q8iPvkC1u//h4bWs7pwwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDqp+LlNKYFw\nQ/RUbN60cWxdStdSPwOt6hOg2FMB0X6mAiEA4z/JGQ2PAErKnyCtsX45tqcHGAXX\nY2ZDTAVQv4+jesY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARHVitO/xaJgmiXCq8/dsCCYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTU4ZGZlZi04YjMwLTQwYWEtODM5ZC0yZDZjOTEzYWE1ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNUjnu4LCYC+TUqrwYfB0JMZGR+y44LQDn3fd72l2fTKOZ\nIKfF4+do6HQzDzEjFodAZ2q52YCcqCXL0j4pzgpWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOIotHoI9Q8iPvkC1u//h4bWs\n7pwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgelDwuu21aOrtGrrKJKBdTfP3sEB0q0a/mzeOIIjai6cCIQDfGnoGxq4b\n6Bjn3YLmI2C2P+QsQ0Odechp53Y9tw0mUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAV6QQ2cdtJllAqBxLPsGjh/EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RmYWZlZGUtOWJmYi00Mjk1LTg4ZTAtOTUzMDczMWQ2YjRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzgyZTUzMWUtOGIzOC00\nMTliLWJkYjEtODE0NjRlNmY4NDY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOck+8SWb7hfsg7GuZrwzQU1gcUJPkyP/MljYJ8l99ZlCiYjKaUiHJqzzMimdbW4n\n0cb//yoV3Ir6RekokxWwBKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUA2ayhueV6MPBEDuH\nDzXjU7FN5zkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgb76BY5sJZUt7JIZAAyxnSkFx62giv8CQ3m0UXuejpVMCIQDk\nrlt2EVA5+/Oeb+Ryq5hNp47sBZ87LspQ4Cy8wqg57Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8372", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8372` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAQg17tsbwcZMkw3gNoGUgUhFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5MzAxNmQ0LTUwNDgtNGRkZS1hYWU5LTcyZjQ5ODkyYTU3ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDRhZDhmMGUtODRj\nYi00ZjdmLWEyZTUtZTk4YzYzNWY4M2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWLTpO/3zjKZTABI976HQ1Z4G3y1AnfLSZNz3LIIZ61RpjU24x+B8nuB/jadv\nPhP3JVp5HNM98oGgBvF/UGS8uaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwxfmx0w8geWcYPkDjPRBiaYEt0wwHwYDVR0j\nBBgwFoAU/f2r8XBvv1ajVpbCqwy30f5PE/0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDDa3WJLWg8+6Mk5faVCydrEpjT6sTSZpa1ry8yUW1TgAiAe1PEcztOeviEI\nZuBankMmDr87xGWyzBTG4dTBhTpyRA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY+2atAbBvb0+cytKypK2/vzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTMwMTZkNC01MDQ4LTRkZGUtYWFlOS03MmY0OTg5MmE1N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQL6vUCVlkZ6mAqmTUBv1u3H/z6Wn/XohyLVOwNMBipKvlA\nOtwBxXd01mSHEawFY7dWzl/d77Pwfa8d5XmDmshdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/f2r8XBvv1ajVpbCqwy30f5P\nE/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIaanxvSz5fEsivArvHsL76AGzHVQQny/rFgqe/Kob1VAiEAhSbm2rQG\nHhDMa2o57wNkwiH6d+tCwD07alIPJVjXDUo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAbas8fpTEqsOPX/nJdmmIDsXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDRhZDhmMGUtODRjYi00ZjdmLWEyZTUtZTk4YzYzNWY4M2M1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGYyNmI2MWUtZGZiMC00\nZWIxLThjNWUtODFmZDg0MTU0MmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1a5kkkTM3FOJR+okRldZkKye0tLGnvmhgch1C77qmj/iayzjKrzBrOPgya0jY7WP\naVeKDJCFen8imoVzwyr9jKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwxfmx0w8geWcYPkD\njPRBiaYEt0wwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgVCG2WKOFIEv1BOFlP7xQxqPF8SeC3UJWi6K2FWG6WLUCIHAc\n+8TnlfhW0ldEypKRT5mJig+p+dZVW2i2DsPEAMic\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8373", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8373` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISARPFF3pKZfRxl4Z72wVzLj+yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwZjcxYWU4LTAxNjEtNDhjNC05MTVjLTUxYzkyMjZjYmUxNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJjZjE3ODgtMmVh\nMi00OTNkLTg4YmItZjBiMDQ2ODRjMThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmQTmtvLioGYOI0cFkGVZ7VxVKQI/c7bqcZOCek1BkO5Iq4HnWlDtTjOWhmLZ\nOUgXmAnNMQzVAmx/zOmWJj9bZqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2XuEqTCILeWhpo7+LW36EMrjAf4wHwYDVR0j\nBBgwFoAUk2hvW02LGPfqjZIyJPVzHSbSu7gwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQD2hUVHBRkYuwx7q3nlbo5lOxEDJyhp6m+JL/04t/gj4QIhALG5RIvf5fT2\nf1ISZj/aDBT+In3c94M7OM+A4Oo2XOf5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQlGGGjMuuTwaLyyJ3EG7Mp8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGY3MWFlOC0wMTYxLTQ4YzQtOTE1Yy01MWM5MjI2Y2JlMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATszq+qtJqgIt+nbjs3RGnFhZbqwKFQh+rWqP1DKRsGXGYa\nxS+1J84sHEB6rMvo0wyr8GlqAoE+Ut2X6Lu8q9pNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk2hvW02LGPfqjZIyJPVzHSbS\nu7gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgN4EBQGaQO2GmKxly+JZgI6rg+9xjyU7FjbeeFImbrfwCIQDVsvSfUcMy\nVfLPdgee5kmZblmsnXc5T6F2V9TX2dVOjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZr018ImQDowLVyWTW4uWEJpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJjZjE3ODgtMmVhMi00OTNkLTg4YmItZjBiMDQ2ODRjMThmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWQ3YjBlZDItNTRmMC00\nMDA5LWI4MjUtMzEwNWVmM2MzMjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRi8ZqxBtvdxO3kFZ9nzO6vMXU4w22g2qu02j2WXnk2Wjxoq1WOeilFfc6UGySxmj\nSdg9jTzgoxiNWPUwnctcQqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2XuEqTCILeWhpo7+\nLW36EMrjAf4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgLvKVjM4MOcN4zy7/8aYAfesrKenOAM3X7eay+S0SAvkCIQCF\nSalPiCu49asGFxdi/+wgBxWoC4NgV7MSVVhoEoLmHQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8374", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8374` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAZ8pv0SQuLHJ7Sas6i8FK7R2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0YjYwODEyLWM5ZTUtNGFmZS05NTk1LWEzZGMxN2U5ODRlMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBhMmRhYzgtZTI0\nNC00ODQ3LTk5MjctYmYyODFmMDg3YWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyXrverTO3dT1xoslojsqNqUXQb9i89sAWOCLRlsc1aLBqz0kBlnFj0d9xri4\ncsuf4i9Rg0W1eCBxLFnEcut0/KOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGnZ0+O9D0d6fL1iiYRz1T9Bv5sgwHwYDVR0j\nBBgwFoAU1T4qkGPvvBiCZDkFfZXMlMhmyoAwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDe\nKneWUGxl1T/Wx9nvQYm244QlBfRCCBBIUW/3L7I3SgIhAOHmKthdPBNfqOa7Hu7R\nKS9Sc/kk+JqirzP2jZ/ID2nk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWP78b5O1xmY7OF2Ddq6H576MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGI2MDgxMi1jOWU1LTRhZmUtOTU5NS1hM2RjMTdlOTg0ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+oyGYeh8YrAOJXE8J341d2C0niPLG3wRBYLrlpTxe698S\ndC3EHFLaUTwC6I6U8Rs7tzfjwi/orfZvCBnuCDUco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1T4qkGPvvBiCZDkFfZXMlMhm\nyoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK38ghBeruj5L+2KoE8Keu/Bb7JM1mVT04+3xArNg8qdAiEAoFd/NycY\nsRqb90jVWlZTj1JAWwHSqZBpRj7I9dwbYYc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAWW6gIYuUCJ3Eq3hzMNdxWBsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBhMmRhYzgtZTI0NC00ODQ3LTk5MjctYmYyODFmMDg3YWFiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWIyNWQwNjUtMDAyOC00\nODM1LWI0ZDUtNmQ2YjRhMzRjNTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ntgTTq/zoGrEtrXquKbKI+kepLdFYRJxX5Ab2/QYzPLoSonvKQu3jEBMgfBN602O5\n1RzZ6jU/nPF/FCthH1hF8aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGnZ0+O9D0d6fL1ii\nYRz1T9Bv5sgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAK3yEJQLRkXg6WIB7YjtbR4/2NsoAOubacs23Ho586xYAiEA\n206JE8b2TnUZpLvho6GoBxx1s7IIj5EwIDn8dF8+ZMk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8375", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8375` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAbQM0LDqgoiZr+span6VqRwFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxNDJmY2Y2LTg3MWUtNDllNi04OGJhLTY1N2FiNWY2ZTY3NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTZmYzJhN2UtMTIx\nMy00Nzk2LTg3OGUtNzkwYjIyZjE2YTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENG72Lkqv7c7YY6BijuYbL7tbm+PUGacxuh8Era0Zhnl2HGG1JmfpTMNuY5AQ\ne7HIqvrw6GCyDP3rr+fmAkCYu6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrTsrkyMxdVLgBp4w7QFiFGPbVVwwHwYDVR0j\nBBgwFoAU9txputhufXLI02Ism4/EB6my21IwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDIH+5363ezVr1wuzED9XTDN3WD2385z3C7zeiNRmcMkwIhAKAI\nR1Ep2cnno6jqHqJpw10NzG98HxFTXuUifGfDQI9S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfQu1MWQOZMAuDcXQC9mF7WjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTQyZmNmNi04NzFlLTQ5ZTYtODhiYS02NTdhYjVmNmU2NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrbIHClkOPDKqJA3iYHqdEb/EoSdFdtAgARqvZv5EzW2kl\nNonhXa4VzpeLY/H+tIKfWQsP+8NY1ixOB/zw5pGSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9txputhufXLI02Ism4/EB6my\n21IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfeiMSxZQ8/At0rB2o5NXYlrEcrFxLC2aBInRYgTC4ncCIQC1NTSO8uB/\nzGyy1HEqMejJ33OnAS9d3kZ5r67bwfNRSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAdBNCdCfrHYdg+8+j6vJhvHjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTZmYzJhN2UtMTIxMy00Nzk2LTg3OGUtNzkwYjIyZjE2YTYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWJkMWQ1YmQtMTA4Yi00\nNzFhLWEwZWItOTFiZmFkMmYyMmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nACaSVb0/cghs86ynYfuK1wT4SzMoVnp7860DW/v1KizFJ0RKVmhor44xf5D+HTZh\nqeGvt4rovDcmUdUipP1lzqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrTsrkyMxdVLgBp4w\n7QFiFGPbVVwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAOI7iyX00M7xUlsbQqv6S+DZ3OWVYCmp1zeYckWvktXfAiEA\nxHac6/pVEscguaW28C/rGU/pX6PIt2yVYAAFpM8ofg4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8376", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8376` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAbdPXyc3D/uQXlJpKZrngQDwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0ZWJmOTZlLWIzNTQtNDZlNC04NGNiLWUwMDEwZTVmNDU4MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjhlZWUwMjUtZDE4\nOS00ODZkLWEzZWItOTRlMzBhM2JkNjE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsgauJrIJMcxWdL+C/tkjsUtPwAIC1VvD18vTW3f2pUwUG0gGF5dQ/a8jvpPw\nNvtW+zf4IkOfTwlOxSyOgGxFYaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7+HZ08jC9f/zHgf19j1zOxMxtyEwHwYDVR0j\nBBgwFoAUSFdhDbRPogkeInCK1XrGxu5mbMEwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCRcyzv7a+SjWHfzAljtoEgfUDxRiXs5kPhanFThXdmBAIhAM4j\nn3eRYaC6AppKiyesQ5wpq/rAryIPIrwMKOWWizwp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfZ1GncvaXuUGuaeQN944nUnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNGViZjk2ZS1iMzU0LTQ2ZTQtODRjYi1lMDAxMGU1ZjQ1ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSi1zEI/ICHErwM7sXIOgHbTq8/k8+x8vAI/uTx6bv7Lkd\nCwtb1mdXartR0EjErRsV3p5XLae+pAP6wxF3PrZRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSFdhDbRPogkeInCK1XrGxu5m\nbMEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCEhibvnmCW0bzBRim4GJSt4sqrV3e8zHfNb78sEUXsoCIGSaSpTrStb8\n4LNl9o6PWelb97SzFvSdckL0Y7WLzCt2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAVbG7lW8ZZzIh0SCNDKcwFs4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjhlZWUwMjUtZDE4OS00ODZkLWEzZWItOTRlMzBhM2JkNjE5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTkwZjVjODUtNjMwMC00\nMjE1LTg0ZjgtZTAxYzYwZjUxN2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nE4+DYml7tOnPjmlPRifBkYxCnhrhPUL6pLwMplh2ks3VD+CGolG/BC8f9pRvAveA\nqjOX8JWBx7kmG+2BqZ3feKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7+HZ08jC9f/zHgf1\n9j1zOxMxtyEwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhALrLiBqCV5BaYvZLSuDEztssOAOSJaAq69b4Vgvtlo8aAiEA\n31Z1HCk+oBMYk1nweReWCnvRUnxLawBJLqTxldlHmAo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8377", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8377` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWNFGNxG2w+fo8APH+onak4XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkZTAxOWYzLTMxYjctNDMxOC1hMzBmLWI5ZDNhMTViODZjMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZmZGU0OTEtOThh\nNC00ZWU3LWFmOTgtM2JlYjRhNzY0YTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHGHhgRLvMos7P6IDOqdBx6eQp8iTZ7h7wrh0FkKb8GfNvQmHsHxEdwZ7Wv4w\nar3YmufFqCsvU+j0Z33MQCJ+gaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQe63eDle9mB+nlgdriENhlYlzCHDAfBgNVHSME\nGDAWgBQEBCsChoImEM34Im8VVLD9Ocu3BjAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBa7HssYAnlAR93FG++6ivPN1/S8psfc\njIqjjvT6KBjDAiEAhTDkjOoWam5kWrlLK9wPClJvDBGY2QEf2fwRmaFq10Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcnDMJwasiR9drriWh2KIoWoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGUwMTlmMy0zMWI3LTQzMTgtYTMwZi1iOWQzYTE1Yjg2YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFY+fykSF2atZVlYeM1YrVLBJv23OR6iDNwo7471j8SgcQ\nDFAT8YjildLQiFB+X8iUURxaP7tZ7IJ2vVShxY12o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBAQrAoaCJhDN+CJvFVSw/TnL\ntwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAbSVZ+eTkMnuM7i7PWB/GqOVKPYnERf2ltCFkbH6j/MCIQC3qt27JpH5\nskJJvCw4/0PE9yBymTiWoX+sz/DOn0zNYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISATV1Za1UZqNRP4G/DBLsbfGeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZmZGU0OTEtOThhNC00ZWU3LWFmOTgtM2JlYjRhNzY0YTQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzhhNmVjNzMtNDc5Yy00\nZjE2LTk2ODAtOGQwMzNjNWRkYTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nM6h5nDO3m0OLoCmvcOp+hU5ED74Pl6jHacxyKNo//t8bcP5aqNcXftq6KIL4qN1E\nDeW3lH/54027CRMyHK7B2KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHut3g5XvZgfp5YHa\n4hDYZWJcwhwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgVEW0DvgHX1/4TUYdznHZHL24zUtB0q8M75bu8d8KSqECIBD8\nJtXFmK4Ws8rkwEo4g9pfRwHOv8vGtcqOTxJbgW/B\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8378", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8378` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAc55WmL6/Fie/oa7MIUnm9t9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkYTdmYzU0LWJjNjctNDkzMC04YjI1LWJkODhjZmM4Y2U5ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBlMWNkYjYtNDIz\nOC00MmZiLWE3OWUtZmFlMzliNTY3OGEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkf1QQr+sHrgsEg1CSS9aTiYvKxcyDPlDKIfSzlfJOum7axaou1KxnN2Bc49b\nv+xMuy2hfKwzGveeWROTO88GBqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqhKlwON3qC6U1J4QulhUoeQd8AQwHwYDVR0j\nBBgwFoAUF21y9A1vtuR45rpZKxmqYu+NplowKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCpE2I/XTHF\n4SSik6Mbs+kmHkOpwGU2W4GPut/wQ8cNCAIgIWv9nlIcuUbwegIl6UwI/Ni+9RYA\nnjs7L0WSu0WIzEA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASkDSgUP2uPVG7xKvlOhGenvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZGE3ZmM1NC1iYzY3LTQ5MzAtOGIyNS1iZDg4Y2ZjOGNlOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkaMDtddgbw0zL+9pdJeNqJTqVlbJFECE1shLd1NCOdnJc\n0+9ws3oj4DAn/mUwZ6VIrinLzp0y3XLQCKHOxNWRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF21y9A1vtuR45rpZKxmqYu+N\nplowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcX69i+90M89zbszFISP8NZOWm9qxcttgPDVMhq3boYkCIGGl3HHxb13U\nV/cx3pio0EW+OovHM/bAUceKKOvk5zVB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAciwrt7HzTo2FXIWqMOuvqARMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBlMWNkYjYtNDIzOC00MmZiLWE3OWUtZmFlMzliNTY3OGEyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjRjNmVkNDQtZDcwNC00\nMDU3LWE2OGMtNzk0Y2NkZWVjZDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nU1p2T6HLHpqcXueIhA9Z9kBrlrTsr9808GZTG5FckhcruWQJoBlxTgH9bnVnFju/\ng3h3hvckV+g/rdiFksguvaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqhKlwON3qC6U1J4Q\nulhUoeQd8AQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAN0tNL89WzpiX0htR2eVIMW8sGdSiLiajwGINhBY8fZoAiEA\nmU14XzSRxhTMTwovXTDcr9Ki37a+AEsNx7iHuf31riM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8379", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8379` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISASTeA7iuYsS7huiBchidQVx2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4ZmFhMmQ0LTI3ODItNGQ3YS1hMWU3LWY2ZWY5MGE5ZDEzODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZjNzhmZTYtZTMy\nZC00YmFhLWE4OTUtZDI4Zjg1ZWQ2MjViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEodWDMsh2N237D2e5AfRjY5ZjqaCfL5h1L0eM3IJ2L7F5N/qilCKJZZdgV8M\nWFcOYhm596HaxjcXv0sRLRM6JaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFWJJqCsnIeRg6tXvVgJVhqGXS8IwHwYDVR0j\nBBgwFoAUctHKCl0ydctEJrZ7prHIkoAbXfswKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC+PcDe+nTV\nMUqcR2kQzLTkXZyZCv94AVRJ6ThEROrRsgIhANzUJyfQmszml4AbdGF/cuhwkS6B\nEUawPyMwPdvPmJ9a\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcl8WM261pcwz1bl9VQs7l93MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOGZhYTJkNC0yNzgyLTRkN2EtYTFlNy1mNmVmOTBhOWQxMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZt8WAPMycx1AUNZIR0Pww+F74MY7Int/O27xxiSshkHd4\ndlkb/Ik6mKT48iLpa37m1HbkkcooDaAIldhnOhRPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUctHKCl0ydctEJrZ7prHIkoAb\nXfswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ1+a04u/qfhWxNyfSVZujaV25/GHie/jtqKxWh/IYjYCIF37j3K9tKAu\nRinbM45oapuaj0lqRYi8TcdWWigIHW11\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISATy4kZtamCuM56h6SaTd+LvfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZjNzhmZTYtZTMyZC00YmFhLWE4OTUtZDI4Zjg1ZWQ2MjViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjhiNmQxYTMtNmNmMi00\nZjNlLWJjY2EtNTVkZWM0NGE2NDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRcX3baLG1nashwgfrjzhzCGsCQ0iDMRJMzmk2j00dKvyP2nNttKFLVsfl5JkfSx+\nGf9AmAwJcycekCbDpKyKD6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFWJJqCsnIeRg6tXv\nVgJVhqGXS8IwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAPEljktfkHrg6l+7L7dqJWxHncdDaxk3SOaJkfx3hwNOAiBW\ni1WX0AATrs9ae0Is1nv2m6Ji0gH2IlXQlJ0huPRf6g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8380", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8380` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAZaLm83vqxiGksTtyrzqpBckMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2OWExYWY5LTI4OGEtNDI3Zi05NGE1LTM4MTIyYjM1NDY4NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I5ZWMwYTktMDQ0\nZS00YWY5LTg1OGUtN2RlYTBjMjg0ZWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWzX9LsKFjlty0oli9lY1SshJUz0/bjhjOrEwcpzXx2zH1ZTUrn9qkFJLY982\nC/sIodt5N9hyi6OsR7wYeu1A16OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUWGbBx8lP3whhtT6Ms81mOiT9BgwHwYDVR0j\nBBgwFoAUcmUBgUnHe5euaLKvAkppty0IuzIwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBnZy9pUB5V\nyANE1lkdx6lrbcccleU/k7EuGmv1fatTFAIhAK6V7s7xE5mGe0rta/lK0piissH+\nvRXet1DfbVenloeO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa5gSM8fcuvTByEChRftsOwuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjlhMWFmOS0yODhhLTQyN2YtOTRhNS0zODEyMmIzNTQ2ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASzHYegQMFmS1JoOsqIgdwNpsmizWa9412o4aDpLYbXmzPh\nLYdQ5YV35BsntOz08UcRouwkJxCR+Y1HyWAcOiOSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcmUBgUnHe5euaLKvAkppty0I\nuzIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUwQvtBFkEWoeqEKAG3AtHx8InIscpii4joNIJsgQ6FcCIBS2GOtfFr2f\nGdVYSl1lKpgpiGBg/tnktbvY4JwGwmUo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAYRy8jVTsEuvqWLZIVFf9hDcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I5ZWMwYTktMDQ0ZS00YWY5LTg1OGUtN2RlYTBjMjg0ZWIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjM3ZTU0NGUtOWQzZC00\nOTM5LWIwNGUtMTI5OTJkZDA4YTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPw7VnabrTHqf+yzcGHXoyJPCOYfHYCyi+TUlDwqNd1WZKttisKBbIfVXyMHTbugk\ngLRZ5BVBPJHf7V/geuaN1qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUWGbBx8lP3whhtT6\nMs81mOiT9BgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJSttSYlFLcL8sl1Rk0KSF+fSwGvPJvom9uvvgET9JdgAiEA\n2nqy7prJQq44UuCETGJdYvdJpRbFwCys1dJcCvP4ipY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8381", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8381` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAdpZ7avSxgCLtAOm91i3GmzvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwYTdhN2I5LWUzMDctNDQzZC1hNDRhLTc3MDBkNTQxNjNhNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGVjNDMxOTktNWQy\nZS00Y2VlLWEzNmUtZjBiYTI0YzI2YmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpIm1hO02ac6WERtwIrQ8KVzi74yUdhfoCuqIDD6Jy48f0cb7JPC5VH2WQIxe\nwQhqqyGlS8gutM/9gl/UjMXrXqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYU8iWDxGSr0UpJ4exJLzbkLy8JowHwYDVR0j\nBBgwFoAUc+MZ7pkywRKY6W/Psj2pQVqAGaowNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNH\nADBEAiB7ybWJ9/KMO3vcsoim8PgGkg1anh83Qm7F8Px9xDceSwIgVPxUQoyK8EbE\n0eLttywfGiy2yK512vPZwuS9i6sxux0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY1qL5jIAQJsV/YSeoP/nZRtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMGE3YTdiOS1lMzA3LTQ0M2QtYTQ0YS03NzAwZDU0MTYzYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuvRmZvdbpsbLp2mXLpNLj7YJi+vcYypEzjv5eqBZTgAhd\nD1iCzgwgVQ7NgJiHhbl6sdF+HojPf7DKYyx1Zy1Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc+MZ7pkywRKY6W/Psj2pQVqA\nGaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLwesqXu2ec0LndbkiIIqvVUzBDMVKLMNdwro60XuhqACIBJmVGyfZ5UM\nYmLq11ib3y3lf133mlZ5OsiLXbxGvH9d\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAWKCVAg6deuVLxiSuwX5w7+xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGVjNDMxOTktNWQyZS00Y2VlLWEzNmUtZjBiYTI0YzI2YmM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDdiYjFhMWQtYjdjNy00\nN2RmLWE3MjMtYzM5ZmZlMGJiNDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrIudZXY7IrG+OzQlSyf2hTknffMaII+6nNbYWnaxg5PvAvkiqGJylehVb/2tvCwJ\nBXP4hsK72LyTGh+/mJFyPaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYU8iWDxGSr0UpJ4e\nxJLzbkLy8JowHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJJBPXcCOZPqb9sRi8JSj6bwR24yLkq3O8/2GirimHFRAiBg\ncZXatr1FuyEVyEso1htP9gQHTmUTp5OCbzGjUkI8nA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8382", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8382` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAZPCT0UMaFt70sHxDwWRtoOjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5Njk1MDc2LTM3YzAtNGJhYy05YzQ2LTZmNmEyYWY0ZjMxNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjYxZWU2MWMtMTVj\nYS00NDk5LTk1M2MtNjQ4NWRkYzdiYTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYUDoBnH1ot8zbxGj0epDwyycrL4qEo+MYVEoJ7GbdhtmRAS2Ut1MG7Wb1J77\nhYb0HeTMFLM5V+66ae1WyRt3OaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK4KXxpvMJ+zy8mabltCNbxapOBkwHwYDVR0j\nBBgwFoAU9tkKDoHVS4ZW09fLXPM3qEMxcbUwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiBjcFUN2Qlq0hcnAwOUv+KP4dGRHI4lBmdLbBNk+JfcygIhAPXd36MLla3L\nLEPq//nojR3VTJlsiPXLDKGZ+rycyhp3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbbanqaG9Rydamq3luBKGOCAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTY5NTA3Ni0zN2MwLTRiYWMtOWM0Ni02ZjZhMmFmNGYzMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIk58XESahSm4sxOYF9Lmhg9WBk3jvCkKvrpiWW1BCvq+t\nGS/MecQTxBZkZ83uIcv9Qf+nCycRrV063VZ+oEtto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9tkKDoHVS4ZW09fLXPM3qEMx\ncbUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUGHRgEIJkZ9cghnCNBUxVb7zfQ6OZ87vQ84YMryKDn8CIQDgtIKFZI56\nE7jfTBDqyOTtHG0dkPrq6r5NkRlzFZsWuQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAa6etfVRXs0skdK1WsyOSfXzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjYxZWU2MWMtMTVjYS00NDk5LTk1M2MtNjQ4NWRkYzdiYTUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDA1MjRiOWUtZDRhNS00\nMTk4LWE2YzctMzc1NzBjZDJmNzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9USo7mmARTKX2p3E5jD4D7m2+T4NhW9Ss/R3sGFxo7YMcHzHj2UpTPHBtft37Inj\nygb8aFFTaNeQvAkOzlNazaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUK4KXxpvMJ+zy8mab\nltCNbxapOBkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhALxJ/AhBPVeTl8/tCe+Gbui60Qbk01o2Le42CVh2WalLAiEA\nmo/ttOG2TXhWRpx7Te/7w+FFUKnNB39fInNc6NRn9KU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8383", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8383` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfSgAwIBAgISAScU84ptzZLy+ymQ42v2WqfVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzNWFkODM2LTE5MjktNDcwOS1iNjQyLWYyZWU0ZTJkODEyMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBlYzQ3NWItODcy\nYi00MWQ3LWJkMGMtOTYyMTUzOTFjMWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl3ozjaOPv5T89Dru7CiPsebl13QW+eSDSFKqHYJqYH9emtvAjFj+l2HlQEAJ\nYd0OcY5TG4s+l01xEaOAqUZkHKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUomeh2t2Bb8CbrAL7X03rHNVmu9QwHwYDVR0j\nBBgwFoAUhF5rpexMvYx9H26+oXr58eS2nvQwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiB/\nQ2MVgWSf7UzFTZ0FB8K4sd0JyqOdhb4xLl0CrNYjigIgT/qP9IOSdMd0WXfgV2mN\n6BWiAticzeY+g+d6RY1hw+I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf7u+lj8TUhSDTfZa31+eOtLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzVhZDgzNi0xOTI5LTQ3MDktYjY0Mi1mMmVlNGUyZDgxMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATODACUAoHh2TNqd3jKxacdoNf+1kTNBfncR3J0meMnh6W9\nrmWAuyi7bDXD2LOs1NHu3UU980lgZ4o4k9rjjeY+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhF5rpexMvYx9H26+oXr58eS2\nnvQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSRMZ5nr9QmAATKpOWXMDgaOpDy7ZPj0++egEqe8TmysCIAF+iLsqlhxs\nAFVw+iB0R/ZMlkJag1bX3Y5IJaJjHX68\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAZxDfsGpwnOTZMp3s7rK42oZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBlYzQ3NWItODcyYi00MWQ3LWJkMGMtOTYyMTUzOTFjMWNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWY2NWM4ZGItYTI3Ny00\nYTZmLWEwMDctY2IzNzQ3OTJiZmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLL5Cb9IpCpGKHfORzhQO2wlST6Nkrbk/KWQutURnAyRVce/Jsu9583mVLF5ZiX2Y\nY+gKF3E9MdFpvXXLGDvpraN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUomeh2t2Bb8CbrAL7\nX03rHNVmu9QwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIyLxrcYnwg32PDS/DjqNinYJcv55Sj21zn2sSudfLH2AiEA\n7BZ37G2p0qy4QzDZx0SG1+Bk4E8osMeS/TdAFRdumfM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8384", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8384` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAbAV2L3c0ywGdroerbyFQwwpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxNTQ1MjZhLWM5NDktNDBlMC04ZmM1LTlhNmZiZjY3MzhiYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM0OTJmMzktYWFi\nZC00YjY1LWFkNWUtOTBkZDI0MWM5ZTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM4MTIDT+diD91QSSyKxIngX+Ht6l1fCHRpuGh/YxoCCPVsWeGHwjtkLY4EmW\nzlBqi7UoVWFaDxL1WvXBQutUDaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuB8rSVrRgD/xs51KF7yMAchac4AwHwYDVR0j\nBBgwFoAU21ubJTeY+EOwegQ4AxrUV4NGMeIwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiAugWlq9cmmnZ5ilNnPaP3ce8Y8eGuw97VNyAOjNATswwIgbmwU\nHtdXftS1BJwI/G8OHzmqeslACV7CCItQXgnxs5M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdRN5UOBFHSjvRvMqEWgtSF9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTU0NTI2YS1jOTQ5LTQwZTAtOGZjNS05YTZmYmY2NzM4YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmmCF2KfhDBPso8R4IQLPQ/Fa6JPDaZTGs++etXojufp0C\naUfRnvviXwgIbj3yLy8C15Qh950XUymiJzZ97u9io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU21ubJTeY+EOwegQ4AxrUV4NG\nMeIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN2WTNN2oR1fOpkmoFLB+EvuELepj5XLAvSaKQZoG3blAiEAzxd3E0Xl\nUxXZuLO6W2WEC7tE+u2bWpDA0cSugypbVtk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAWMC/q/ON2PmDctWy9SYLGTjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM0OTJmMzktYWFiZC00YjY1LWFkNWUtOTBkZDI0MWM5ZTViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTU4NDNkMmMtOTJkOS00\nYjhkLTlkYzgtNWM4YTFhODI4ODRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBjMPqLS3jU3/c8Cbz5AQvysfWTY3pPgY+tjxqsSpB4O2V0g3rdF4AzuNasnsBhL5\na8fedXHOmpm6tjrAyeGf9KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUuB8rSVrRgD/xs51K\nF7yMAchac4AwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAMxgGLOrsEhdtqPhQzowgsLZkGq1CoC18rBA/82dCywpAiEA\n6/XtoNNb0RUGXkMdBFk9W6ZJRfxBzQsL6yTufUaq5bE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8385", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8385` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZRb/RL6KnNe6rR7FVcrEFwbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4MWYxOWFlLTU1ODMtNDhmMy1hNjg3LTE3MDQ2MzRiZTg2MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM0NWY1NmItOGZh\nYS00ZTYyLTk2ZDYtZWNmMDJhNzRiNDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUndtob+Uk6ppC3VfQgYQRc1hM+WtXTBQfqZNnyMuRzmovwrj5uuH77KBLGad\n37r2HGueyh2N0Uh/O7fOki5MeqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+iDJBt/6t7jF9lcIOZ7lrYzcxR0wHwYDVR0j\nBBgwFoAUntW17sJeg+pvz1wa3SBmiKFEGKwwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBrtceksi4ZLiwEgUvIQxQLI2GFZhQt+crTRLc0x25DaAIhAPsh\neDNne8w9n5aHnpdqfkalRS+c+2Sm2RWVrELSdeu0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU/V/nG9e6soP4C+ZtAx6NVpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODFmMTlhZS01NTgzLTQ4ZjMtYTY4Ny0xNzA0NjM0YmU4NjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyo7pya2HnhYulWsr8oerDKV8TQoDMKVTEbK+KiCxmlyYZ\nuep3ldAcRLXQukFGt4MCx8ZCcoIyuldodgrK2KeQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUntW17sJeg+pvz1wa3SBmiKFE\nGKwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALHvXJXUkCz0rB/g3sAj6LUzw0WRIm+tsBBQuLlAvWdLAiEA0LqV3RiR\nt/NH4GxLxc5+Ol0D6QNMTh6G0e6Av2z1xxc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISATTM+AR0T53Azl+/fBGsUcUgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM0NWY1NmItOGZhYS00ZTYyLTk2ZDYtZWNmMDJhNzRiNDU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWJhNmFmNTAtMWJlYi00\nNjJiLWJlMWMtNDY0YWExNzU3NWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZh1J5jU6Pn5oQYftaqi9wQhWsO3LEjMFlLNPrVLda/ag9w6ZeKhqMLxz1QihhjOK\n+OOgyJbQWnWX17NRVM/i4qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+iDJBt/6t7jF9lcI\nOZ7lrYzcxR0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOtj3nyvJbRarqVvXCxwQajSI7AaHBVg3eXrTZb++xsuAiBk\nh6E9nfAAuWPNSZjWhaXE2WoUpmw4N/PaIa5vK6+Y3A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8386", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8386` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWdxJZOOlrJDhwPo+2qCTBmGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMGQ1YmQ2LTYyZTktNDMzYi05NzJmLTFlMzA3Y2RhNTIyODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUzM2U0OTgtZTc1\nNy00Njk1LThjZjEtOGE0NjE0NWIzZDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvhlgwwtlFE30K6xYGrWjI00Kgbr/i7mAvPd/AxZk2iPY/SohcNpnXrqB5aZw\nEaMpfcdzV97NQ3Sls1c3qSSgJqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFsmZdlYlztXgYbotAdFwagU1bFwwHwYDVR0j\nBBgwFoAUTRtesVdBtiqvL6Xc2/UAc7Yn8k8wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAwEJiZxJ9jIEe\n5QLfxU+8K5ezf9uH2hiO33O179PdcnMCIEHqGaq02MpIPD1RZhhvNxVDCSvdZhy5\nITh1C4ePXDL0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYxh3BUjhfNkPhgViyQboSevMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDBkNWJkNi02MmU5LTQzM2ItOTcyZi0xZTMwN2NkYTUyMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUC03zLfv05szLSNneyYpeXSNiTvYXfpJULJJlfHC3Rfwk\nPypxsM7jNUHdv5c9+vfJxe/SK7ClOp2MM3bRE/soo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTRtesVdBtiqvL6Xc2/UAc7Yn\n8k8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOZTCae0BKtv2BwflHuHyb900A3nLxC/1Wy3BpfmL49HAiAHTiJci0QY\nqUDOQjs249xji5Rhpi/eG46WJgsaRviDOg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISASsup3rAlIOb0wR2qVcGewlBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUzM2U0OTgtZTc1Ny00Njk1LThjZjEtOGE0NjE0NWIzZDZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGU2M2RhZjAtMGQ1Ni00\nZGU0LThlMDgtNmFmZGZiZGRjNDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYfeUjjUkhaV/7sexh+3Z3uush5FTDH/gFTddmpLBVJLYn2H/UHIQ/fHGJyyGwXUd\naq10TFQM2sA9EY+64cGIqaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFsmZdlYlztXgYbot\nAdFwagU1bFwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgdopgNSRXP5KFw2qYgeTaBqre7bBVKNDuINpqBJDcnIkCICT3\nAsHzjd8B5jV29QLlzpJZTvKVrShNO0Jk2ObABNJR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8387", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8387` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfe3vs7Vqa65B4xtCNgJayPMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiYjBkYTQ2LWE0YmItNDFlMC1iZDFlLTNkMjk3OTU2ZGU3MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmExNjgxNjAtMjIy\nMi00OGU4LTkxODMtOGMyYjJlMjA2ZDI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6KEf70YN3fO2gZmkjeb5mEB1fuknFpkX9ol8Ar7XevND9q0QSIRfZ4r5E9pC\nRkpXINFCxaG+w+xVg6NyZuJFzaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFnAbOXmKjDezYc3GB/5QJi4qJ4swHwYDVR0j\nBBgwFoAUj/8AXXbgCyDpuF3/PCpnZkKTgrUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDAw1x/nN1+AyWpxnCqiTf0/Lq78Am5pzkhv4a7CpMMFgIgC3tFbc7pdro2\nT40zjOjgz/VImK745DBO3EBfR6L3uaM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATUjDR+RKSMcBEFzD6MQzGUeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmIwZGE0Ni1hNGJiLTQxZTAtYmQxZS0zZDI5Nzk1NmRlNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwAYakc2b6t/llUjCa9m5sAfSmhcwu28FnJXtUI/jPnSYk\neKMLefGh8Wi7Mv3DlhPQ8ANR4e0YbGAUyioboqjBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj/8AXXbgCyDpuF3/PCpnZkKT\ngrUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFZ542VpKtXuuLYqI3FOpMijc2E1LdST33QBOHbYrlJUCIHnJADvaFV7r\nhaWdRiyiOZtzLLLpA4XG0g7aLKmO/0E8\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAUL5tKKPq7jzYCzTxZh5LZbVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmExNjgxNjAtMjIyMi00OGU4LTkxODMtOGMyYjJlMjA2ZDI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzI0YzRlOGMtMTdmNy00\nMDU1LTk2MzktNjkzNDkyMjc3ZDIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2fhcgDFsBITVF35WXdJ6jyJOp/1CMIRJGATcZ6rnyhqCJmvRO4ORtZkPHm13dWm0\nXjDTw6nZO8gVg2UGTFUoy6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFnAbOXmKjDezYc3G\nB/5QJi4qJ4swHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJ/gwXmvAknvn1FfKqlTg7SpAbD3chTzc+OqWK4NiiSlAiAs\nkKLlo2NTE4QeD5KM/WAu+ZBBMQd1bGujNjR4334gcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8388", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8388` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASV2bfLmeKbck/M1KCI0cHu/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlhYjM0NjdiLTE0NDAtNDkxMS04Yzc1LTg1NmZiZWQzZDQ3ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNkNmVkYjEtZGM0\nNy00YTg4LTlkNTEtODUxNWQyYmY2NmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELrnaa2bhfLEaQ9/i0hfO4s7ptuzj5aSuMNGgVqtjojVg58a5knd/aVnGa/cU\nWJo8+Xcv99L3YwnoqOsPoxUYxqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs7HDa9KRk7vOudN1Ls8k8Md3azcwHwYDVR0j\nBBgwFoAUEuM7PdxAfc4HAzDAzRB4ez/GSrkwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIFj8MGspTpWIGtrFI4IJNF1ChLlK8gOCQgo85Li6dFPYAiEA5BP5i7DgJycT\nzTIgUAbgbPktrE0hnGxG/Q9BpOv0mDc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARCY7eYAxTerdnJGedXsMO94MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYWIzNDY3Yi0xNDQwLTQ5MTEtOGM3NS04NTZmYmVkM2Q0N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBIpct+EXzg8l1J4LR3DcAQ0mhmrwsDEmrl3k5xfpTg3ML\nZOU4QWA6wzO3H3+BWWvSEs2QFqC6VhSpWhCPBl6co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEuM7PdxAfc4HAzDAzRB4ez/G\nSrkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPcbr0D6CfQbXMaXIcahEtqlJ9fX2IY8gQne66fcq4NmAiAXOwCOgdQb\nOJVjz8fHSeG1c55yI+b1I5QJyEwDoMbaDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAWMXKrTzNk4O5ArbrgLNScQ6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNkNmVkYjEtZGM0Ny00YTg4LTlkNTEtODUxNWQyYmY2NmY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWQ1NDc0M2ItMzU3YS00\nYzU0LTgxYWItOWEwYTk1ODQwODU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUDOY5aloLZY322ORGYT2NYfFas51OC0LxSz0l24i1WZWRcoWIEFKz8RT8ZCioDHs\nUhDDJw/lGs0MVvjP2jRY6aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs7HDa9KRk7vOudN1\nLs8k8Md3azcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgHXPVOASdsGvSLXg83qicH/NqNil+/YJwZCRdiZeere4CIQDU\n+yOXmPf7pnH8I58JakywjgGkM3kGPazUGUbNuFEc0w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8389", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8389` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISAXDBlWyXGooidsJCXN6yMNxFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1Zjk2MWQ4LTQzMGItNGM3Mi04MjBkLWUxYmQ4OTAxYjRkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk5ZWJkZTUtZDY2\nMi00NzA0LTg5MjgtMTYyYmUwYTIwMTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVk5VDR/oIyXVsNO6z86KKN7NNyeRvu+AEZEj/joerEIzCks6h/UuK+caHgGT\nTBau4bksl8V36Jd88cSOR1fKbKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+W3PPjzm5CLCmk8BGhNkvvsQ8AQwHwYDVR0j\nBBgwFoAUyb7Gm/3zT592VOL+a1vv7NyT6NMwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiB0nZjpl25iR+J7UYRGvEM76JleBs8JPClgducipoKkyQIgUacNHfITllK/\n/rmA3wQbvDwUUlAFIlEfeD4wecA3Crg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAes/mB1uVGD7f4dlGWMwf8n7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNWY5NjFkOC00MzBiLTRjNzItODIwZC1lMWJkODkwMWI0ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/jsQOCCnQm1++o5QobTQXSaSpdkOWNn4w3liSFg6Ibflo\nRVqPkxDoQq6/X+3c2k9qkMVHQt++g2zQcauzKyBno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyb7Gm/3zT592VOL+a1vv7NyT\n6NMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVwmqi8HX0JetWRtWHh5XPQCr8LOAcaP2G5Kgkty+GRsCIQCw4KJNefaT\nzMt7rJsAIKmGApj2aJIPDeXeFd0viI520g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAfiEAOhqthcTiK5HbsVtCtjHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk5ZWJkZTUtZDY2Mi00NzA0LTg5MjgtMTYyYmUwYTIwMTNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGJiOTBiMTctMWFkYi00\nMDcyLWIwZDEtMWNlNjkwNjA0OGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3IlVWfwsaWcYC3U8NaV5NcCLGAYq/u0N1GDTbqizqnJZ8E7Qf1Q2R01JT+47gu2M\nahJW8vJevE+PFaBM75p0uKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+W3PPjzm5CLCmk8B\nGhNkvvsQ8AQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhANCHFdLLsG+cKWRY7/cc/mVxB1LQsj35me0qeUw6JTbmAiAk\njECRC3tt0s2/8WYBL29CzSiLtzJQlBgHq2xIIswyww==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8390", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8390` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYPtjFeukX2vWSKVJ9ZrYm0UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyYjJmYzI5LWNjMzUtNDkxMi04ZmJjLWY5NjUxYTY2ZDgzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc2ZWJlMjktNDZl\nOC00MWEyLWIyNTAtZmEzNzgxNjhjZDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyFtObkBc5PpK3xkxtKBmu3AYOCaBzWmaQqlUth2C41u9Jj40jMDJmjhBRAc6\n/kvOTks84zy/l7sqqEYbgbdhs6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3vWANuOMCTDRkeElv1Cd2vgD/hEwHwYDVR0j\nBBgwFoAUAPh2vKWO/hDExDJbB5hm03A/f+YwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBKMX2/BarGrJfxNNiYKZdRyzA8XySNUezTCgU0u//J\nZQIhAJi8+KxBZF4uTysPWM1xrki/ELhSeWvw83/ALoAbn2cd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUDYD6bWYqULx3Fhm9kd5eBZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmIyZmMyOS1jYzM1LTQ5MTItOGZiYy1mOTY1MWE2NmQ4M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkH5uXDWYVXS03nrQomuHky0PXzG5tlBtWJZ6hTIWapiKj\nLtZ5zXHFGdHreIJI7Hq9tzcYwvaDABvvclGNMTGNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAPh2vKWO/hDExDJbB5hm03A/\nf+YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCIjnh0TBMmcLQWRHHRwf3xXxdmi0g06pHS04I8LTEGECIQDIEU0vrP0I\nSASgnG6L4w+z7RDe7GDuI6tCv17fqSR2NQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAYSLusmdatJITuBQo9SfM1pkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc2ZWJlMjktNDZlOC00MWEyLWIyNTAtZmEzNzgxNjhjZDYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2JlN2I4NzctNzM2ZS00\nNjExLWEwYTAtMWNhYjg0OTdmZjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8VRZT3iVWgXypZv/81nywUnedhjGblC0qaIDlDMGxDLA0P/b6u7FEiZjaru0pHrh\n7KROYFYNJxE1SO6veS/1tKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3vWANuOMCTDRkeEl\nv1Cd2vgD/hEwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgebrzlZF9FedSi0a6X+0H9Ed/skgVM1MR59YcD9RVC6kCIQDS\ngLDjAdftMPfSXxGXI/CUtQ9UQfPvm8bL4ktktXC/gQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8391", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8391` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISATs7jBgasE31J00qncBSUgiqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxZDA1OGNhLTMxNmMtNDk0OS1hNzgyLTdiYWFkNDI1NDY4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDlkNmExYmMtMzlj\nZi00NmFmLTkxZGUtYjUzMmFiODZkMmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4W4sGFuARla/FM9hd/8XI6DA45WUDYxu4mffjwN80Qk8M02iqvnLKKfrNEh+\nOQayuOHOISfyFXUOueVYM7C6i6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKKjBvWhIYjk4xvRaQkGl8nA1JtswHwYDVR0j\nBBgwFoAUQKNgNSt3xRBbMSYvsK7d1BCipVowQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiAsg/e01v3sTdZxp9v0Aupa+DGrF7nRyxF7jZcPvmMU\nfQIgX/Qu/DSzNPhpkawBAYWqmj1UwgmfEj2FO3aHzMfnTLE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARzVl+ftaTrwxi7/toWfa2teMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWQwNThjYS0zMTZjLTQ5NDktYTc4Mi03YmFhZDQyNTQ2ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASBXbIUPPMwatp3GAWXH0iy5JckX3LZsmT62utPiWPF5Ad3\nLZcjRfK2g2u++GvkMs6NNhhNQq9tNw4XfkeEv4Jio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQKNgNSt3xRBbMSYvsK7d1BCi\npVowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVNY0kbogUk5MISEo4dZ2H/OobgaUfkbv5Yl87DccR9gCIBW+jwnMfLpe\nwxVMcI9afQRxCogliekgS+XFfEXQ2fRk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAU0pl44vbVMHHaSrQuakz1JIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDlkNmExYmMtMzljZi00NmFmLTkxZGUtYjUzMmFiODZkMmYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWE5MDUzOTktNmUwMS00\nYzhkLTk1YzQtYjEyMjZlNTM3OTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFg1QHvr5ZOyzFVtRIMxVlzXu1xdlLSuXAqg7DBZYDAXAwuocqIor+pEf5TbyjfBn\nBnIKsZPo4+4Tcw2vlVWtHqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKKjBvWhIYjk4xvRa\nQkGl8nA1JtswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMVEHhpTM7qRZVnkIDf73Aj7fwwJOVERECNEOU5PJYGsAiBS\nsJJ4by0u3QKhlyrhfpRDYq6afKp8vESkakcMyc9a6Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8392", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8392` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAW2Jv/QiI/n1bsJHX3zFd5TZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5ZmVmODY5LTM0OTAtNGM4MS1hNmNhLTc2MWVmNDM5ZDJlZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDg4YTY3MDMtMWJk\nNC00MTkwLWE4ODAtMzE1YzAwOWYyOGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETb9QKReOXvSKo4WiPo+ObcBGSGzyLmtfP5WoOegYoLIRU8SfYy4fkZbh8CgK\nrXxC8pNQ6qRsbdo1dWYvNRsoW6OBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJsyTmuXEoT4VWARvLg+dvysJPZYwHwYDVR0j\nBBgwFoAUJy19qvbyatroTIK3i+5BbbVcrn4wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAsHHO/ozqsiVdDmCwK5yqCyabDMDBtanLzWCd4u1iOEACIQDy\nU7q0jLlkrJ7m/zdN3AKLUnAJqnKj0XYJscE5r/17lQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaItIIovqNy5kb6d4NB5G04FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWZlZjg2OS0zNDkwLTRjODEtYTZjYS03NjFlZjQzOWQyZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvaX4x4XboxXmr72uLlMQVwSRayOaDFIDBOpkzkAB7ge+D\npiyyDSORqzcOlyo/uEwlSIU60Mcleq0JdtjiiB5Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJy19qvbyatroTIK3i+5BbbVc\nrn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOP5r/rtGMUkhPz5AXhJWD7yUo1g0ng0lHiS8Sa8DQaeAiA2vr75fgi9\nLInkwmqi3INB6RHjsoYqglkNU4Fxn01p9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAfzgHYcL0oaQwnl8v7sUwURGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDg4YTY3MDMtMWJkNC00MTkwLWE4ODAtMzE1YzAwOWYyOGM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODU2OGYyOTItYzcwZS00\nZDVjLTk1NjAtM2VkYmM1NmMwNWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSS9z+2dwWN5tcTtk5Lrzy6e1qIYFZwCZ8+FoIL9VWW6bKqz0wY9zGJmAOa+BwFr7\nNib9TxLNehdBpnVIAvK8JaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJsyTmuXEoT4VWARv\nLg+dvysJPZYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhALE7drQMvknG0GP8ei48FTlYG8gRuMolqQzZeUKE+aO1AiEA\nua/CfzkZSInJQaepldGgWB9HLz6FW0dlkkrQ3TsSnz0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8393", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8393` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAYA8kl7MB7XMt0ca3wI7a08/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MWU0NDk1LTRhNjQtNGNiYS05YjhiLTgyNjM3YmM3NDIwNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjlmYzcyYzMtNTFk\nYS00OWNmLTgzYjYtNWYxOGZmYTdhZGZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvNWsLqpJhBS4hgWqVtFdtwC3DyQHQvLM4NZ4bxV/EvVPigUgBzKaQkv0kApS\nYYFa6EjevM7iEsatpq9PDCC+FKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq+rYpPmFTj/9IluOgHjW7qQPF9cwHwYDVR0j\nBBgwFoAUaXPEKGW5HlSdQ8SAQBRFNHo6JBkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiB0ITw2VeHOnIwjGMmk9eiDF57ylPU1BxLy\nadA2CCj2LAIhAPbcLbYEvLL8rlgpSU4HBwcRIXt89h9qENNrCT/d/W2d\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc28AaKjeFScTVEsyf+wSyndMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzFlNDQ5NS00YTY0LTRjYmEtOWI4Yi04MjYzN2JjNzQyMDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSwQ3uN+xtbARjSp8XAsVWa5i6ZUrF1QwsVIvkg9cub3gO\nzdmX/SGoNrAxVYaK1F0qwPdueo3XPtkGgNvA2v21o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaXPEKGW5HlSdQ8SAQBRFNHo6\nJBkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP6e1C2jPbJLtzsFatU2p7J3J/MTC81tqqB3kQak+ucBAiAsDBZXOied\nZL+uZmwRY0loL6mwl6KSMdDz0uuYGmGQsw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAXA2OorHCzA5Hr0Oe9UlOCdTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjlmYzcyYzMtNTFkYS00OWNmLTgzYjYtNWYxOGZmYTdhZGZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjBiZTk1ZGEtNWU4NS00\nODFiLTlkNTYtN2RjNWVkZGM5ZDRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsg7M+iiBpkgr/U1+43TazzxAVPhHCyFtgN+O63CSMqySlV9Y0LQdIx7TmgZFPnlM\npytXBzxk3vTiH7gzqExmz6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUq+rYpPmFTj/9IluO\ngHjW7qQPF9cwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgTMXpMIYA0unZFcl2myhkoPYAv4RW9+CF0gXpM248xcoCIGEo\n1OFh3sUGY+NJ4bB8r0SaqaWMytLNFzWS5yEQYvn6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8394", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8394` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAdwyGNxbMTrza0+1ijiODunHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3N2RlZjdiLWJhOWMtNGVjMS04M2ZlLWQ2ZWUxYTQxZTQ1MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY0MTMxMWEtNWUw\nYy00Mzc5LThhMDgtMDkzN2RmODFhYzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPlipshgIMDmYsp6QJLSIlWGHMQ7zHDRIMBcq/C+/L+OYRm7dqqNdZK6k1Ss7\niD2Oo8MNESpZgb9hObr0k7jIQ6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbF4sOOgUuCFagAtnGNIuf83MPS8wHwYDVR0j\nBBgwFoAUdHgDNu2srEksLzh9mNzKuf2Kr5AwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA3gPOt16RXRizdSbUJImgJxO8qYo/SSYp\nt8dM0SEEeqMCIQCi3osOW1pPZdFWJuGgMhheWFeSzUJfbJwHDbNbrF1T1Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa9uhY+OZSOBsWmOP3MvEQXdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzdkZWY3Yi1iYTljLTRlYzEtODNmZS1kNmVlMWE0MWU0NTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiYyzer3yW136E0Mf1KZvRekBCwMlRhg75fIkz07U1XLO9\nXXIqCvpCOevFdDDqAiiq98/wyqrS/wVYAlk8qtj0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdHgDNu2srEksLzh9mNzKuf2K\nr5AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL4YyPokhhcJ7RLqVNsKOVLGhx0Cj/oU3LNaq57ovbITAiEAoWan0fOV\n1ygimEErHWRvim2bk+2bfRbN1LuWcbbG4qg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAYafCrCp0Bi0r/23tbIeYylxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY0MTMxMWEtNWUwYy00Mzc5LThhMDgtMDkzN2RmODFhYzU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODc2ZTVhOTctOTc0My00\nNDBmLWJkNWMtYjYwMTFhMzEyMmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngl8cwzOL5nrRraxIKyF5Awo5kElIa2v31zUdiT/wd5ENR1LeCzsWOMPnYkcHK7EW\nvBo+7MjpHgCM9RFjnhlLyaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbF4sOOgUuCFagAtn\nGNIuf83MPS8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAMKrCg17OBoELZCTXPrAW9IFcHA4UeEH1YgbU67qg5LuAiEA\nnVUs9Kd6rDbgeibQGAzRdQJ2Jfl5oOUwPq7RECyLJeE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8395", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8395` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISATVqK3ZAdIX/de2z85Add9LaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwNGY4MWU0LTFiMzItNDA2Ni04ZmY1LThkNTg3ODk4MDcxMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYwNTU1ODQtMzAz\nOC00OGM3LWFhMTUtNWRhMWRmNDBhZThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE660i1pJs1VoJSLr2LhjGWRn3FU7lNOxHCqOIrdT5LFQCKocl+JNgiLtwjIwJ\ncmm1xL9bfUSExZdXy7Lj66ZJfaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlqXL3ThCvqdOdhL3yDckYthKE6UwHwYDVR0j\nBBgwFoAUWIIHoFE4RCtMnSGGBhnKVx0eT/MwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiA2uPr5lxaOfGZO\nOtn0gS78UrPXZBVmx1kGia0ASbr4vwIhAN5v2ZHlt9Y+y0127HXmxtfHF3eWgQKj\n7kkAhT7pKxMZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU9ZNxkQdE88kNiF7b4mVne6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDRmODFlNC0xYjMyLTQwNjYtOGZmNS04ZDU4Nzg5ODA3MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARK9PXGvDlL4KcN5Kihl8IY5Og+qxWx9BOm7fRwbwGllUNR\nrEsPsIv7oDqjRfNi2VHAC/3esAX0cfAF1Vf1p2bQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWIIHoFE4RCtMnSGGBhnKVx0e\nT/MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJJxJ5CNiZX4Kkf3jU7mgoDcmXpg68JL3KOlhIb93Zn5AiEAt+WdHQqz\ntnxlIzAxHdPcqZCMVp1/TwTllSdyS0JD9as=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAf+CNjNTzqunAOIxPIoqCY49MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYwNTU1ODQtMzAzOC00OGM3LWFhMTUtNWRhMWRmNDBhZThiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmVjY2E3Y2MtYTNmOC00\nOTkyLTllYmItMDM3NWVmZTgxZDUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuBb4eDpcp2aWz1D8j09c03A99R84vskVaukQ2HmWx6tnXKntAZlnWESPo0Nx9IMm\nJsnpC9lCLVUiVQgVO0+oFqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlqXL3ThCvqdOdhL3\nyDckYthKE6UwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAIw6/4o1wK1bCeK/LLggrxxPZysZmNrL3JSnPheEmijUAiBA\njru23GR28oNSz+CD4v67dwH5Z2MxywkIliY94OB72g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8396", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8396` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAeKAUQGACiyLG2q6+ebzoDAzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExZGVmZmIwLThmM2QtNGY2YS05OTM1LTYzODliOGY1MTc0YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDViN2NjODQtMWM0\nNC00OTk2LTlmMWYtMWZhNWE2ZTNhOTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEamXRNohy+3o5jqVLAxtoq8YaHXn5NAUMNSht7VhXOlvhcRDYmwXBE9HRYJzs\npdr3+QPl8PMwLbfsw7a1lfB9r6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHHb7KxWBZaGJZADw/Mra9o2msrAwHwYDVR0j\nBBgwFoAUPMuu5B1qZeeFDIY6PqfjWJZAYdUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBbFaAxHnc7wGNCl7d7Dvjk8OpCi1GcPMSuj6Jl8QqeUAiBnG7zZ+cMJgjUQ\noVdWnYUo031YrgTwMgoT2JS8Lf6ZWQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe0/Co0ZaVJB4Qe+s9Gtz3evMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMWRlZmZiMC04ZjNkLTRmNmEtOTkzNS02Mzg5YjhmNTE3NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9tO2J/PeBYXqVloUllIiT5B67NJzGOcqbu11N5E4eiiSP\nJKeDuiZfVieICoXQW+e8QXWNRxClqt1n8j4Uib6qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPMuu5B1qZeeFDIY6PqfjWJZA\nYdUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR13SWIaR2Sz7K8DtIwWKreoqJaC6ExC2B5ShLTpJwfcCIAhSD84ezVxM\nRVSUmlCz4ZRRyQmj5EnBkyK0miF5WHYm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISATvRpnLEuhFAHvzLXElpGUMSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDViN2NjODQtMWM0NC00OTk2LTlmMWYtMWZhNWE2ZTNhOTMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjgwZjAzZDktODllZC00\nY2QyLWE1ZjEtYmM1ZDMxODY0NjE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSIvV7ue3hWOFW7N/8U4B6xdcOOLGDHBnyI7yK0/E7W4w6e6wqcMX8CqeN7Uml7e9\n/p3qq56AdJmHiLA1nozfOKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHHb7KxWBZaGJZADw\n/Mra9o2msrAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgezLMRBoWfpSM4NjhIxFMGbqSnDLWaTQbjDzmh7Chm/ACIQCH\nPUXce6qzkW/i+uN3qvEaamKWW5DSlUoNFw31WoQ0Ag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8397", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8397` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISASr5p8n6ixKCiNhCxSVcSwk0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NmRkNjhhLTdiNDAtNDNkOS1hZmJlLTE0MTIzMTZmMDJlMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA1OWY4NzgtYzVi\nOC00YmIzLTkyZWYtZjg5ZDM2NjdhMjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUxHCX84G24o247RpvyEB9nwb7fshhxLTOArzTTYs/yPy87Ks7sJ7fr8CNhHF\ncpmXmFnpwY1jCr0wqbpTsvpR1KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk4mSYmrsHjmMCM5nvcfzfNFGmFgwHwYDVR0j\nBBgwFoAU8EOKCWWVl6VhYo5wVEzBDmX4bGAwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCICTQx8NEgXVdBgx6Mwr0aQbiAolLLZ8MLuRKpJ54wnalAiEAlxVLSz41g2zV\n0qziY98FSPvLBZh2i0k1Lp4K8dTq1g0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR74U15pElbPgJdtgIgcr4qKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODZkZDY4YS03YjQwLTQzZDktYWZiZS0xNDEyMzE2ZjAyZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8shoVH2036DafPtWCjdfSh2AZJ7gj4hP29FFC/z0Y8NE5\nU6XIqWXUQ/WHkyFYWlecKSz0+yoQftHcCjhj+vUbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8EOKCWWVl6VhYo5wVEzBDmX4\nbGAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCLMVg7IMaKYQLMSM+ZErCMFcof/TMQUCszYcCWUCyk8CIQDPZyJlRALz\nKnCx8LSYsssgtrgWi8dB9GgpDpJZ0iGQHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAXQqWDHPdUEwYOnN1cTyT/l2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA1OWY4NzgtYzViOC00YmIzLTkyZWYtZjg5ZDM2NjdhMjI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmNkMWRmZTEtMWYzMy00\nYTE3LWJmOTUtZTE4MWFiNzAzMTA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niLLYDtDvqrxkEyDkCj0g0UWLHrQZhAuJ1Yq6in/nTHlWpfkPlQ1Rc90WkTXrX0tA\n+yYV7kPLTAEUJqyAucxYp6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUk4mSYmrsHjmMCM5n\nvcfzfNFGmFgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAL9RHNwhA5EnYoDxndWRJKRTIBnb7NC6UKIguEPyFC89AiEA\npQMB/nrMCRASVMh9gj2MV0kLqxn8Fmn0UjbPP3sviS0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8398", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8398` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfqgAwIBAgISARukp6v7dj/mUcY1xs50erIyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjMTM4MDA3LTQwMmEtNGNiOC04MjMwLWNkZWIwMjZlZWMzOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNjNmYyNDYtMTA4\nZS00MjE3LWFjMWYtOTBkN2U3MTQ1NTdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ/iiMItuYCjt0aUXq41K0g3GWQdtKgW1DrqTgvDAp4AnA+ImnQgYt1qqx6j+\nK+KzsKAHXxUqxpPf+JIOKQZAGqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY2rZkhPMfvqH76SXKFGWFbsecSYwHwYDVR0j\nBBgwFoAUH4kqD4IBVirNt9FVtKqfWXO56mQwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNH\nADBEAiAByBM4PGZ8rky8Yh9wYsv6e0U0n/0mgC4xk5sYySDcPwIgEksnMqFGcKU7\nWC1f40imWtZZ5yNYOw0mhs31aZu5q7A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVDdzazACHRJqY5jtozNHDN5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzEzODAwNy00MDJhLTRjYjgtODIzMC1jZGViMDI2ZWVjMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8vAbRezEhc34Tx/nQywTxfkVHUjS1CuGP4AUalX51Og9/\nFL0UizmlMrhVtu/I27sABC8qR05BwbI74Z70gMrgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH4kqD4IBVirNt9FVtKqfWXO5\n6mQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLYvnnrAWEMQ0CkfU1QU4mtwZ5rgP5wK7GWm7rkxUwuYCIQCTxy6c3tpk\no0cgvjYW9e45IzwGryqVWErh5n4Y5vn7EQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAVj2JUilDvk+xHmeIM/bVwu7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNjNmYyNDYtMTA4ZS00MjE3LWFjMWYtOTBkN2U3MTQ1NTdhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWM3YzEwNzQtOTQxNC00\nNjRjLWFiZDYtZDBiY2JmYWUzMDQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOognz2LsUPFQ4HEkgeHBCQlKFr1rBdZuKbO4lNgQxz4ZE8DOtPMfymyK12xKoGsj\nWBIsAixR4T41QxzzM+gd3aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUY2rZkhPMfvqH76SX\nKFGWFbsecSYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOJFvILlTCY/T9/XfdqM1F4ylhBEeSG3HoJqLzbldydCAiAn\njCHxssmPybWGmlxpy3Rj3yXqNAbeCLDdDF2T6lRC+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8399", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8399` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAS3cKDhUn8T49ru86+qMt16sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhYzU5ZGQwLTgwMzYtNDhmNi1hY2RlLTczOTM3MDI0ZGNhZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVmODM3MjItMjQ4\nMi00Njc0LWE0NGItNTlkZDZmZDhmODcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKfQRBxEK7zTvnguTny13te340q1DrtPpd5d0e9j/KFibu5GmmINfUBhshGp2\nFnWGIxTeZHKHq58Y9bDIWOjyUKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnAcvXl7u8e9Esa8UlWSf4jeSNTkwHwYDVR0j\nBBgwFoAUVF1K2f5i/G9wvwa4UUEIuMGeOVEwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBu5gWKrujgJZx6O5JpDaMIjSuBqzZS35HYVPJ3Ucth\n5AIhAODOnL8bFSXaILyLcK6n+9FWbsra36Xd+zdo93VUIx/y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfcXLxlRvkhQyAMTtkzjBJ4RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYWM1OWRkMC04MDM2LTQ4ZjYtYWNkZS03MzkzNzAyNGRjYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0DGJFYaU45QIbL19QwC0Wdfw9jy6yVES9BWzm93GN+uqI\nXtSfCHqx3loyW3ArAxtiFeo/KYPaCIw4kPJkhaQJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVF1K2f5i/G9wvwa4UUEIuMGe\nOVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALIq29axAEGUIjY2x77HfUsohY3wPSSYifgSH5EsbfqQAiAoskEZHGSt\nTwsqGYZcOlqDO+gM5cHYs5lpBbD5t9BP6g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISATwbjqiWU7Glb31pSQFNRpGgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVmODM3MjItMjQ4Mi00Njc0LWE0NGItNTlkZDZmZDhmODcxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzBkZGU2NmMtZTI2YS00\nZDdjLTlhMDMtMWRhZmE3MWVmZWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7Etv7Wsg6Yr9m+i1efPEcFp5RyGaKZrLaQde1dgzvSKzXm21BgQIWdx2FIB0Fzu5\n2IYPvPvMVP/ut3wAO5k3CaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnAcvXl7u8e9Esa8U\nlWSf4jeSNTkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAPERjcXdGVrQCxiKqddmlNa0HhuAapMCC7AohA5GF9yEAiB3\nmpuSX/gmkpMbYnS5Bj/hwvbBCzfVu1NzW1Ui94kI2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8400", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8400` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAZ8dIWKJfYTum0/dOMyYMw7RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNWNiMTcyLTMxM2YtNDc1My05NzljLTA4NTk4NDllNDhjYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBmMTI1ODgtZWVk\nNy00Yzg0LWIwOTgtYjM1MmI4NWIyNGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERa8bPoFvfmfUNEPW7odPkJgC3pugyLcqmuNskwZWwLDVBtnqCQIiS4nI5vO3\nK6S0TdLPfOyKWkDNc8o49MfGS6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVyc1dD7zkH7B2u55gT0LXGf7N60wHwYDVR0j\nBBgwFoAUh0h90uNh+XVpINc/78IYLYvbSJ0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAk4OtFFKXP48s+7QoYEZ7y/NWyyhZ6pVVWPsk3DJ8\ntoQCIA2Ct0VuKNouTW/If+Siltpw+p4DmryqkcMMCs4T7vxW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAddARrnmSBBgqZhLx0Ddhm4oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTVjYjE3Mi0zMTNmLTQ3NTMtOTc5Yy0wODU5ODQ5ZTQ4Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8nLG1HEdU9i18WXuP7kY6Ge6I0luTvs/HYbexUfDdXMT2\n+ohZ/8wiSwtPZ3KbqMEt/8a0EGT/5fxDLIGrJQVro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh0h90uNh+XVpINc/78IYLYvb\nSJ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE26kSbivGY2Ay+Oz7oCBf2CUzneVbnrAmU6P7tR/38ACIQDECWL4GeOr\n+kZ1aL8cmrBdNhEdCKNgo/PUc3L6tFL1/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAXe0LFbWRS/+0bsPo77S51l8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBmMTI1ODgtZWVkNy00Yzg0LWIwOTgtYjM1MmI4NWIyNGNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWIzNDY4MTAtY2U4YS00\nNGIyLWExNDktMWFiZWQ0OGUyMjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n48UFbJYRI0qkgIm/rP6FPc/5g15GMo1IK34pVj46gv2MFIalEpkEilHj+oc3++Oy\ngz6OAkappPuxmPqh03Uco6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVyc1dD7zkH7B2u55\ngT0LXGf7N60wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgAveamb482LWlxqm5uMkJqrb0n9ZzkyIUfKqpb2eGn9MCIHF9\ni5kiXKERJOxtI/zsFgDosvS9dMKkcA7W7dH8SOlN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8401", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8401` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAelKf2EUuD6IAUApB6l2gvExMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzNjU1OGQyLTMwYmYtNGZmZi05OTg2LWQwMjM0NDEwYTE2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFiYjE0ZDMtYmFm\nYS00MjQ2LTg4ZTMtMDAyNjU5MGMwNGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAuSFFKDfRA16YHYBcKTKTQce1by9jo8ZyAdTrcsaHqm3HuSkhkvl4SsXnp64\nMARLwRjBFCP30iMR+X2MGdJ2TaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkiusFNah4P3Ixi1TCFziKIuKBv8wHwYDVR0j\nBBgwFoAUT5seBId/G7Pua70T6wq/h+3DYJ8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiBf9V3eTbrbYwkD8rras+DOV3BFiCyuLkYwtKnE7qIhSgIgNxxk\n5N+Sy12+DUT5HwWINwgkhu9btLfiqEuNiTVO8y8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAebq8bd5BoPiiSfbwD27lyoOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzY1NThkMi0zMGJmLTRmZmYtOTk4Ni1kMDIzNDQxMGExNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYbtbUTnigj75DGxGoEJOKrAfkLhgyXZBbKBxCovl7SYBH\naVX+nxAoP6FygKYt1K5ACbfw/b2fXSyWizvJeZSto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT5seBId/G7Pua70T6wq/h+3D\nYJ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALTYp4DwbE2BXPsP8SjasZYmLGEu3VlStzgwzvqp0j+pAiEAomIoskWr\ng2iMFkCIzZ9sySzTGr4nQvC2VTI1/ykv6j4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAei3FxhrFWi2A8nzIQIchhEoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFiYjE0ZDMtYmFmYS00MjQ2LTg4ZTMtMDAyNjU5MGMwNGJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjQyMjJhZjItNTUxOS00\nMThjLWI3ZTUtZGI0OWZmYjIxNGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfELiGVZhIBtoJYdu209OdgMhFJEVn2n8OlmcvuACnh8olYEslVzvxYixb/SnabhV\nEncwoQ3w/VgEl4olju7QAqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkiusFNah4P3Ixi1T\nCFziKIuKBv8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgfW8BLhr8E4x3lf+v0HXL6VMkV4/GhCjEiBS4kSUr62MCIBU6\njIfHf8rAmHCtm/mU8+SXPaWgI/ElX8e4fgJe/Zqe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8402", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8402` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAawpSD0REWdRGilG/kPN1+ZcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNzE4M2ZiLWNiZDYtNGUwZS1iZTJkLTYwYmNiOWVkY2RkYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRmNDVkN2MtZmFi\nMi00NjczLWE0YjYtN2EwMTQ3MmZhNWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQO6igTT7a9O8+WYjnPt6DW0qHYT+GVpwhR6nC3EMezhFCKLYihJGEsLgCUNF\nb1CE/t/SSmNVqn0dJ+BWgfOIraOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHHQOwNDOsuoskbOqI+ntHQ1cEoUwHwYDVR0j\nBBgwFoAUeyc26D2XXTwehL214oxMJxSZhVQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAneXweFUrOOLYLqksw+FRVISR4mVzTC7J\nX4pCRp0dpZ4CIHtre8orpplepOTgYJND6QEdnsLWDEzwI7P47dhpywcS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUPtpswQYd/ytYy4kNxZfrShMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTcxODNmYi1jYmQ2LTRlMGUtYmUyZC02MGJjYjllZGNkZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzIBpq/aMePx9JPVAXapGqRg7+AuHxUDLEqiLQAMFmxX4/\nFUeGjL73zioUlPWU5cGM5KVD4luL+sC5SqrVvdXQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeyc26D2XXTwehL214oxMJxSZ\nhVQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOZHjsmsecPNhghFbrPClLj5+ubpw6MgHfGGxRozga7TAiBRde1qCUIJ\n/W1rvSXJn7qK+maB+ckyIQS6OFH9ROrkZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAYgc9rIFMRxbAEJ+yW/0hXEOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRmNDVkN2MtZmFiMi00NjczLWE0YjYtN2EwMTQ3MmZhNWMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjRhY2E4YjctMTJjNy00\nYjJlLWI2MWQtNjk2ZWYwYjBjNTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWU/sD/eIqnCj1VjJygNhqje+GilNrbqGNa8HvQq5IcCInIVEKnmV+QaC7Jw43fPB\n1B6p7ArxA6EOU2XBESqCQKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHHQOwNDOsuoskbOq\nI+ntHQ1cEoUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMDBNqkCEhMHji9EVhPWxekB1o0zU/JIGLGC06OuanL9AiBT\ns6qbTGBzaxamI1iMP7vF2C6xrPAb81l33wmsZvIyiQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8403", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8403` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAeb2KuiinVdHlzgZ4BihLSOcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3YjNlNjVjLTE4MzItNDI3Yi04ZmVkLTU4YWNkZjU0MDcwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYwNGI2MjQtNjlh\nNy00ZmJhLThjZmUtZThiNzNmNDE4M2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVX/M+tkZa66Jp6HhyhAT4ePHJs/aCI1toJ+aYqVj854gio1ciq7GHmG2HO5Z\nyAp9MP/1wk/BvMizD1nar6NR56OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6VK8zwFN9BiW62DC8e6Tk8CF0NAwHwYDVR0j\nBBgwFoAU73Ruf9qm/OKEhshMWqV4NgZCcRswSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAQmlJPlrsqMLY5JaGyos3zwvuBrP+L9k9J\nt+oIlsivOAIhANuN4tyPCS67MxBixV/xH7nGwXB+KJx+Ot8TtnzPOFFr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASHtOzOzI9MkP7J2a9xSsPuJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2IzZTY1Yy0xODMyLTQyN2ItOGZlZC01OGFjZGY1NDA3MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASMbL3Hyjv6G9sbpMKhxreDKh+vRNFBwDqRJiWRhZ9hewgH\nZylgMhqO+IghScm4rD3ukpJwdqJQeMsdn4WqXXQKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU73Ruf9qm/OKEhshMWqV4NgZC\ncRswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD0RGw7hRX4GGBPzFhV987SAuriik0AOReGZS0CnSLUwCIQDBGzvmOHwp\n1BYnNpATfy5nyDIBXMnkUzG4qrkkg7Lndg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAQAxJGj5flGU+d8udyFhGH7JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYwNGI2MjQtNjlhNy00ZmJhLThjZmUtZThiNzNmNDE4M2Q3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmY1YzVkMjUtMTkwNC00\nMmVjLWExZjMtYjVmMmVhM2ZmOGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0aYfmDCZNtAiRhaItyu93kCUsYviklVIGZID42RWl5JaZgyC43sJZjYVxoDWMGwC\nIgv01dPlfdojf+qtwRsSRaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6VK8zwFN9BiW62DC\n8e6Tk8CF0NAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIPQQIGDnWjB9b2rl81xIHih/JU/QAwY6TqBAtd5zl58AiEA\n7Hzo2ASI14vAdKpmCsvUvxjrcDEdw32s5jcahGY9NmA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8404", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8404` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAenT4N87CWrrkGkrciWuuZTBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc2NGJkZDg5LTg1NTEtNDJhMC05ZTVkLTU4Y2JkOTMzZWFjOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZiYmJhY2ItNzdl\nYS00MWNiLWFkMzktZTQ5ZTliM2RlZWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU0z/689yGjsK4uY125jDGEO77QOnPsvK1o7znjeqKFUJ/cdadY5npDTXztEE\ny+vkP707Cdl8rE7ZwR7IMCjX+qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTYH+ofpgVzD19DdMtE6bLekU3XcwHwYDVR0j\nBBgwFoAUmzm0jL5hs0Jy202b4EfrA+q8hbYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHUt4L5QabLmpZOv1hDdNwssNDme\nZseyednQXNhdKVLDAiBx0OqgHZ99ZeIdbTVUOqNvwJFnJOqJLXSuHI0BGt5KgQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARsr647c+1uNdbuV1EZ+fjDmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNjRiZGQ4OS04NTUxLTQyYTAtOWU1ZC01OGNiZDkzM2VhYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCGBtAMBLBKvF80EWpItIYi4CGjgBN3wMRiZeAZcOvqvfC\n1gKrxEqMVtsHg+pnRlY+wNc3bS7+v6Bc55ou8RzSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmzm0jL5hs0Jy202b4EfrA+q8\nhbYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC8sx9aY61yPG7BOdvB9oD+PjCO47wZXqK0vqgP7RegICIEYKEN3/kFBG\nxdzpZotiRe75+sDC0drVhHBS5ccSHMsc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAS81B5cfqrqNU1pn3LGpDhSkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZiYmJhY2ItNzdlYS00MWNiLWFkMzktZTQ5ZTliM2RlZWEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDk5ZTFiOTgtZjQ5Mi00\nNTk1LTliMGMtZWEzNWI5NjUyN2U2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4pTgX2yxRaikwXSUEM96j5k1fFl27K1kVi+RKYW19irdnJE4Bsw/wILEu8pz7tUd\nUim7fr4MIntrV/u7f97AX6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTYH+ofpgVzD19DdM\ntE6bLekU3XcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhANeCfXDQkkTXksUoVuO3cSuBrltlyof3rGd/TCXdSdaoAiAQ\nb7GnemXaCsAlsUoiGPPkv7zaBCmGNOzQ33D6h84xYQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8405", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8405` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAQz0bjfPPbkt7WkIXwrAPu1mMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmMzZlMDQ5LTU2MGQtNDJjNy04Y2Y1LWE2OTUxNGFlZGE3MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc0YjE1NWMtNTEw\nMC00ZTgzLWIxYzgtOTEzM2Q2NmU4NDI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGiX2W+pjyQTeC48w/DNf7D6HKGikb94iumGWjENM30skep9B2jqtqjtgw+zt\n8TJ8yRMspK54ODAE3N9EP+pTL6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKi+TVW1inkD7IlQGNZO/E2etXEkwHwYDVR0j\nBBgwFoAUhWCeZLwyVT4sb1Baf0wQ4vl2QQAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgCyLlMP6t\nBaoNAUmpwX8SgDIBkRqhQZ1xAoMj4156YtICIQD8zHbv1ktlw+mHiRdT+YN1q3kY\n7sBjHKV2W69Ytlx22g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbJECtCMFz5jZiuQ5wVEzwEOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjM2ZTA0OS01NjBkLTQyYzctOGNmNS1hNjk1MTRhZWRhNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGoODaoLEZwEVf4oLIFvhF+C8kRZDp3O9NM4NkOWkdmR/1\n54z8lSNow6aPjXLGZswzEV3I/IMws4jdXD/pwhfho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhWCeZLwyVT4sb1Baf0wQ4vl2\nQQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC3nj5FE4/GvsHg3pyk+cPGxk0UtsUuWCD0L42ET5o5sCIFzk2pyA6ji9\nyMOP4mZVwNNQM7xFALHaOLfoUoEbUwUE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAVi1P7arPZ72oAsFGPipqG74MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc0YjE1NWMtNTEwMC00ZTgzLWIxYzgtOTEzM2Q2NmU4NDI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDJiYmY4ZWMtYWUzOC00\nM2Y3LWIzMDktMGJjMmUxYzMxMzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7e4Q/KkshO6/QW+OjJ0TzYRpJqmoO+ku+eAoaK6Xh3mhQapKf+ynA6oSxNlKW7oZ\nLRzjKwDab2xfNoyztYCdeqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKi+TVW1inkD7IlQG\nNZO/E2etXEkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgTazY5wx9z1Zv+EQwnYzNpreuYlXxDC08UHphtSYKacUCIQD9\ndNe+l8Nq3gZlRc3EukBRJaLJh7r/CVLod27uYdBOXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8406", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8406` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAdxDeIz6QHw7iRsLLxaYq4PrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4ZjU0NzMzLTY5NDEtNGVlZS1iYjQ2LTIxMTk5YWQ3MDZkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTVmYzQzNDktZGQz\nYi00MTI0LTg3MWEtNThjZWIwNmM0YzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ1CvssxIPbOBaIvT8ozZFQ3CggWmdZNkaLo0rIPGblYT5z8Sq3kukPONTR+f\n5qFwi+MwNaLFz+vBzE4W09yf+aOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZIaZcYhbU+AgfiDliu4Ji2SfwyUwHwYDVR0j\nBBgwFoAUSX2arK8TgO55DXFfD0nMXlxUdmAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIge7INSwpL\nawPZ69d0YIP56t72tMicAF1dEuZu1YBBavQCIQCANjMEDBq3LUuBmwnN3DPNAm75\nyWuGrUjcVN5TfA0FnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAds7aynorNwK010p5hST9qS0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGY1NDczMy02OTQxLTRlZWUtYmI0Ni0yMTE5OWFkNzA2ZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxPV20YqJYFY+cSvukZva/G3QkoQzr5hCO4Icrb1EFJzKM\nsNgojGNardi94wzJ+La5uzHqlmuI9CVOILdXVgD4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSX2arK8TgO55DXFfD0nMXlxU\ndmAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPO0QOFvE7bjzImdlCGLip+BjImjxiVU1EWu3ZqG/GPJAiBWKBXxF84E\nJYtiO23DT0dKrtxxxRsP4reVur1HbrBSiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAd53MC66SH6U6QX+OtALwWhtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTVmYzQzNDktZGQzYi00MTI0LTg3MWEtNThjZWIwNmM0YzVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzBmZTY5Y2ItMzcwMy00\nMjRiLWIzNjAtZDU1MDAyNGFiZThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndntRJ7w0S/3SNSolBj3KlCk9gqIh7QA8VU7qVe41AwSYN2ahrMb3dwPHahcYSSdX\nhf7q+X+JcUXi77B21kPANqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZIaZcYhbU+AgfiDl\niu4Ji2SfwyUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgZ3Pyg+5QbWt13389A9oNeFq3/ZuIxU8OBOkWvPQjzo0CIQDC\nWGzvGJjv18vBCSSTr+G1CLKTOhgtxmOoqd9K12ZHQg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8407", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8407` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISASMY2h03s7PJ1T4QfTHvAb/qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhNTdhYmU2LTNiMzYtNDQ0My05YjViLWEyMGQ5Njk1OGQ5MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIyMDhkZWQtYzhm\nNS00ZmQ5LTk3NWUtZGJjYzQ3ZjdmODkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd/ijP/h3XRwAlv/y7NVoxwvJ2+xs1NfXX0TpoYjFzlwQxQHLaHDkBv3iSmmB\nwsH7ev/R9hIxgTtQFZ4IQwwqv6OBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/tLIXVETx7h8EzCDZXdMyS1dI6cwHwYDVR0j\nBBgwFoAUkzeo5741ClrkJCvUGNSRLvPnAQkwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDsY2QW\nljG8xzJRoLNd+2wz69u0wVv75H/iKhH0kMCt9gIgXjtxyEJ6vbVlvylcsS24CYCE\nZW9v4uLw96cpw5CV4c4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbVSuiyOu5AtHFQTEtre5wA9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTU3YWJlNi0zYjM2LTQ0NDMtOWI1Yi1hMjBkOTY5NThkOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwvXC1Wgdsl/uxrkHE7H6TlJnu0BfNGcKDDS2Y4H+mvICI\nCigB/jT3/SHd3yQskhkG8g+Ku9GQbS1Pw41QgrUuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkzeo5741ClrkJCvUGNSRLvPn\nAQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJQJjpYhByNF/jaTR3j5XMKqzU9tvkVn8X30Rt3Qcz9sAiBSjWmaJd/Z\nWGL9MJ3WtT4fGlbLiPnzhmExl62TVbBdEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISARsdlKXHb4OcDMnOs48JmGMFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIyMDhkZWQtYzhmNS00ZmQ5LTk3NWUtZGJjYzQ3ZjdmODkxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjZlMGExN2MtOGRhZS00\nYTgyLTgwNDItOGNkZWM0YTQwZDQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+B8KllZCkq5tZQyjG1px6KZCu30nFpxYfvO36TK9NkyaK6pjFRcF2T0ub9EDavui\nADt2o1h7GcTnwbDYIj4F6KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/tLIXVETx7h8EzCD\nZXdMyS1dI6cwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAK8G3VaZmdfXAJHOzSIm3u1UQyBMdSEJUZXXDNEwF/JmAiEA\nqeYOG1DrgtnlA1+OeTYbsaphjKforP2+7eMFWY2ROgo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8408", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8408` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAcWBE/tLcXUjRFdhl9C7/jS0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzNDExY2NkLWUwNDMtNDliMC1hMTBhLWU4NWEwOGUyZDUwMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM5NGQ2N2EtYzUy\nYS00ZDA2LTkyYzYtNTU4MTY4OGVlMzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtB6+hOn87ZSbFXsknUidxaFRbcom3hb6dAwqJ3s2snYzTJF8PQqERTFmX59R\nmw1vFzJFhPpVBf8E9wwMcoOEvKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6s8kf4z0ih4GF6BILx2hmh5vDLswHwYDVR0j\nBBgwFoAU8AYzWuWjGTSzHnpjgCbF+t3scsEwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDYGzkPiJ1ooNQAkp818gKnNjfYBvO7KqbGkfj+rAYzFwIgXLIc8u9g\nrSMqdRJrdHBigRbl4IHwM1NT6uwVYLFS2dE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASfAvm5uEiJa91ilrx3D/IHrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzQxMWNjZC1lMDQzLTQ5YjAtYTEwYS1lODVhMDhlMmQ1MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+BWz9JrOQsS9ECf2vP2yfsAQQoklPnx4sFuGse5MbDCuq\nbAiEVSU7iWY9ViXrE+3GBnmVVJQkyVWWWtPB6ywro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8AYzWuWjGTSzHnpjgCbF+t3s\ncsEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge+TN80YECfuMl8tfP/GovFRIzNio0KFz+zOjRZ343DcCIE+rIwlHYQ+3\neosC30A8rxjFXZg18NkVHUWoQoPRnar4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAWbNSSVgRCJNysdtQcF+MXMRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM5NGQ2N2EtYzUyYS00ZDA2LTkyYzYtNTU4MTY4OGVlMzM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmFkYWQ1NTUtOGJmNi00\nMWYyLThhN2YtNmVjOGE4ZmZhOTBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6mLzMJjnE1EYHqsaoYcoq14cZVKYcv8y7nubCCglNhRCPsWSz+9Wa9KhEvaRyDc+\nz0N5Y5E11WbXqHb2bAJL8aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6s8kf4z0ih4GF6BI\nLx2hmh5vDLswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJszAn5dDhP/onHaxTCRu+9qDIGYQN9AWcUDVCqJeDdVAiB1\nxOB7WEm3UB9ZHorZdQsghYjZ5fBDf2Sfv0af35O2Ow==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8409", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8409` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAXefC6voX4HHqoiSkbHhLamnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NTg4Zjk1LWU0ZWMtNGRjYS05YjJlLTRhZmI0NGFkZjU0ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQxN2IyZTItNTUx\nZC00Y2I3LWJjOTQtMmVmY2UwMDVmZTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBFs2FbTRhsapZdkTJ7x7JsPXIxrvQ5qYSl3cC5k4aOFYfo152xTRQz3PK/A2\nyRZwaya/3kQ+5au6dGwBBhn5FKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvuaT7DzDglQHMWai4NWTffuyVh4wHwYDVR0j\nBBgwFoAUcGRdvXOFD38gx35gilFfP+rC3WkwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0cAMEQCIFPhGTi6+53fwbAmmlAB5VY6SI8O9X4sTBwkhEn3ZnqOAiBe3y+ZZN1Z\nCS5v4v5ke46CnqTJb1iMpCKWmJ6bulaL3g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARvtjeL70+kOH2OYM6+s0573MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTU4OGY5NS1lNGVjLTRkY2EtOWIyZS00YWZiNDRhZGY1NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASx5EH//h+6R+1P1UX5jUi0gC3RsKht67fpZ0VDf+YykO3X\n9rCjbl/8zBIJr87SmZNjPa6E2f1Imf1ZGXVHfyVMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcGRdvXOFD38gx35gilFfP+rC\n3WkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXQSmcYtXnmnze9ZfQkBgSdoBKYAD51aW5Gh0XWJMz9QCIEsmRWI3hag3\nPU5GePM5DqOzUvBCFNdy1XWv/16LF9jQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARKscdl8Z5iscmSArFXAiAExMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQxN2IyZTItNTUxZC00Y2I3LWJjOTQtMmVmY2UwMDVmZTQ0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDg0MTY3MzUtZDI0Ny00\nYTc5LTg4NWQtNGQ5MmEyYjE5NzBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nndQfRtErBpN3aI+LlPSBwy4EC3j4lOWLil97EToitARQ56CSvESZzAxTXXpFRPyj\nWnNcOTsf052THCIRbO6Cm6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvuaT7DzDglQHMWai\n4NWTffuyVh4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgXBgm13+kVgroUjxbe36KTEhm00AaGx+/sDGp4W8KxnsCIQDi\nieunjtfyEQZMIm/ITYpbN4bStxtTavobkq9IwHkQRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8410", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8410` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAQxOS2fVnpckeQBp+mtFGiK0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlNWVhNjhlLTI3YmYtNDUwYy1hM2IxLWU5MzgyMzI3ZGFjNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUzM2E4NDktM2Ex\nNS00ZmQxLWE3ZDAtZGZhYjUxYjcxMzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5C17qcn6HUHwwaMAvAdpgOYwwnKhvtAjYRmix0k2PFCJHZxbbHjryN8cVNwL\nVV+vtMBagsG+h9kapvKGYZkWtqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+gzq3eS6SaZcek9h7iWgK2weu2gwHwYDVR0j\nBBgwFoAUmWZOZD7B/iLUyrugwU1KypfNv1QwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIHdPEGgC3kTpDjkqw9KTcqbUfGws3rEiUxulv/6Y6FI0AiA8vQlpP4ChrgI+XSIf\nwiPxDOahSLhsUagI8raiLT5srA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa4qPvYA7wQxE4uPzmrZf4v9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTVlYTY4ZS0yN2JmLTQ1MGMtYTNiMS1lOTM4MjMyN2RhYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8rCCT/yKWB/ueGH8pT29G1Zj+1oQqPcKpYMNnxOyG76HQ\n93arzDp89eOd30VwjcRhhO1uCZCUj+KJBBdvcKjVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmWZOZD7B/iLUyrugwU1KypfN\nv1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJgqm3EqMtxUDK8TwQU1ov6/9nL+fvCOlTWDbLNCKFK8CIBi/fPNHAmdQ\nzUKz/J0LKG3FqNaHuXctgWWzW1TSu1aC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAaoctlkL/bcKNWaiCnOZgt8KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUzM2E4NDktM2ExNS00ZmQxLWE3ZDAtZGZhYjUxYjcxMzI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDg5ZjE1ZmItZGZkMi00\nOGY0LTkwZDItMTk2MTJiNDE4OTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+QzDWHWNFdwBjTdomCoYloQkH7aT2p+FfVhypAfEWg7yOnH6S9Eolp+YOR9aTe/k\nPd+jcCiMBkoXoRYeHMUGCqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+gzq3eS6SaZcek9h\n7iWgK2weu2gwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAPRolSLCSVUaMtPF6fYpqXKpRaNTJnIr89SdMByLe/9eAiAX\nJ/DFFfef/GwFXwH+N/8adB+0+pmEfTDdyIi2ZtWTtg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8411", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8411` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAcvWEW4LFwEb5th8Q3TzttOHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmOTliN2QyLWMzZGQtNDYyYy05ODMyLTlhNzBiMjZiNWEyNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkxZGYyY2YtYzY0\nMi00ZjkxLTk3ZGMtZGEyZGZmNWM0NzhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf74LWqWSP8+geAeLrQ4A4OkWdl0Dub3OSalVKcVxydC+XejVW8VivnQukKEO\nyz65TzAUyMmT6Kn7yrqU/Ae476OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXAYFOnONDNrOnmepunASsuTFOKIwHwYDVR0j\nBBgwFoAUVul/xEff3ZwvNzafP33YQWIcFxwwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0cAMEQCID+dJOIONyzkt/ez9v2isufFap9n6u2XcjbS2jpvNfwaAiBK\nwL7WWXj5WXS9DQmqHCUhBLlbGjtD30Rcc8dGaHm3Pg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYZvf+2IB11QchmwOJ9UnvWaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjk5YjdkMi1jM2RkLTQ2MmMtOTgzMi05YTcwYjI2YjVhMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgFMLU7CNUEUlCLQwQ0C1FpigqKXmWdcYHp3xLZPUHX4Q4\nEc4U/bEqC4CKpR6mfmK18CPNURbqfC6kSyCArvzdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVul/xEff3ZwvNzafP33YQWIc\nFxwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANCsQ2hEc9OWuYSffEt5/6OyanzyamMg4fC1z8tR+fhdAiEA2RVD/1rz\nIpcfDrnNbdWhGlejBotK0V+5/bNnkhCqZ6k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISASkTKvtyyNiIjZtJSJVvGuOLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkxZGYyY2YtYzY0Mi00ZjkxLTk3ZGMtZGEyZGZmNWM0NzhhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmQwMWFiYzUtNmEzOS00\nOGU5LThlODUtOTFhMGQ1YjZlY2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3Wr4/u8E1NshBwdP0NdY2fZZubW+4aY3RU3l/kd6Ox6YTi7BhLZaGzis8VifDeyJ\nB+cxhXJGGoPqQsdMHknE8qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXAYFOnONDNrOnmep\nunASsuTFOKIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJWrcO0qeeBSJgk+aMeoiWQjrAaqJakL9mIxIQ8S8QXGAiAE\nrm0mXl0xVV2/baWlttEl15RgjNHWgaxu6PGO6wZjpQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8412", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8412` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISASRvjxt0fULL8mPGFU14Ho9DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZjc1NTQzLTE3MjQtNDcxNC1hMDAzLTdkMzQwMGY0OGQ2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTM5YTg2N2ItMjFm\nNS00MTQ1LWI2ODEtOThhOWFmOGNlZWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaL9bb6g3FFQEiv3f+vI1d1ly2IR3DAqpxNA0JW7uLJHAMISs/QtmjvKTtgfY\nfzX9uZmvpNTCOlT63f/AZXDoxqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbdhq9GqFaHhpN5kaWfmdMtaCNjQwHwYDVR0j\nBBgwFoAUeAVLcRfokbg9f7k75mh9d+l3LqYwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQDFZDQ0ffMrJZP+5/2VOO9Ew6dPAaXhXrX+qvRllXq3DwIg\nZBunTWjnz3vdQ+igwGSN0+qYBuf91ZB6QtYSFPXzi3k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY0XtplKBPh44KBxrLzuaeTeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWY3NTU0My0xNzI0LTQ3MTQtYTAwMy03ZDM0MDBmNDhkNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYtITUSV0hcK/reoWVcNQ/y9al2IQvZJQAaNoyzLuH5rny\n+mmIyBkzMRrTvV7ESVLk8PjFhetNKh5vgxDBbnOko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeAVLcRfokbg9f7k75mh9d+l3\nLqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcY1ZqgfnRY5/0/ohql6fis1q/wWplsugHHmtevvj3HoCIQCRTB9ok7Lk\nHbdfiYhC6cSCwXzevfbf6jkKxnu5ukfMng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAcGkJAbE2ID9hvdQElDNlNdqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTM5YTg2N2ItMjFmNS00MTQ1LWI2ODEtOThhOWFmOGNlZWU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWE3MWE2YzMtOTJjZC00\nOTJkLWJhMDctYTVhYmRhMzM3MTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDH3NhNtiyWbPRUIIjN1j9ywyc/YqrpUc3RCMZznJcMG7xdRmCMICwsqbPnc2Rfv+\nn96yeL2lCwYiwBfxsVyXE6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbdhq9GqFaHhpN5ka\nWfmdMtaCNjQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAMicxlSZlUrfZfS1z3jCU4W/hYgZ8SWC6sDrODHaRb7FAiEA\n5rur3mh8AtYDXZ8nqvdiCCyzUm61c8itNnnkFxqaM4c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8413", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8413` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAVRkaIUwnyL5E0+03j2ZPvM3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxMGZlZDU0LWU5MmYtNDc2ZC1iNDgyLTM5MzM1NmVkMzE4MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNjZmQ0NDMtZWIx\nNi00ZTc1LWI4MmYtOWYzMWRiNzgwMDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZteeAoxPhU9tUD4YF7pGX8SVIGH7N/ztBIQ3+yyjIdWpiszAZWRGJ0/AJldM\n9Rg4E5WUXcXw46KbETxxZqaC8KOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwR841auY8tF3LBxej4EbZW8oplcwHwYDVR0j\nBBgwFoAUDeWzg+r5jon8XZMkzLFiRk9Tjd8wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDJUmoy/WoX\nyprae1uiu+O+M626APSvhUCcGehudWaPMAIhANGcyJWRWCIKnHe+RAOa82xA7RlI\n2ayVRd17RRqV76o9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcP3FIWQN7MRdhjT6ZfOYQwvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTBmZWQ1NC1lOTJmLTQ3NmQtYjQ4Mi0zOTMzNTZlZDMxODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUyHnshsY9oCXIs2lOscr2xPAQq1ZFTzGb2iWiNkBpxa8C\nRtjjrkivaeVivluXm7wVtVQOUN3Hm95+wLw8QROxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDeWzg+r5jon8XZMkzLFiRk9T\njd8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGd4+7jOlj2S9zwj/3CF92J0k7aumho2gxXlhWdyonDMCIQCQYfPxyrud\nx8DiuveTxtB9l5aw6kzW4GIm8K5jsAcgEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAX7b+ANj+eMO3akkCeCtote4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNjZmQ0NDMtZWIxNi00ZTc1LWI4MmYtOWYzMWRiNzgwMDIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjBkNzQ3NmYtNjRhZC00\nMGRhLWFjMWQtM2RlNjk2MWU5ZGRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nq+uW/RtqLT1oORh0vaMUFe1KnO+/rAEqXWeNByJKLattUvh35CxujLEn91QQGLML\ndreyatsdDH6/GRAcLkMnCKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwR841auY8tF3LBxe\nj4EbZW8oplcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAJ5LL+i/Eg+YepDNzVY/LXPYeeaY5Mcyl1fpmzWVOtHwAiA/\na69cLaWiu5FJ4X3NAnT1syBn0FzftQC+Y9mJ/yPwmA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8414", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8414` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAeHTZCmHFdCdu3OzRgjOe5uHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4MGM0MjVjLTUzODYtNGU1Ni1hYWI3LTRjNWJlMTNhOTk0ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzA4ZDk3NDktMGZm\nZi00ZjFiLTg2ZGYtODA0OWY3OGVkYzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESbaPxACfLUvnW9x47LNKzcfzJMbhRTAtitVC4vgE1Xl/5rramRChXphSE7jN\n6k78Dyf+ZqmcW/pkbofyWKwjYaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi3qnhrK0zzAcwV0fdV5r6Uk8QKcwHwYDVR0j\nBBgwFoAUK1ceRwI11gwT69XTrTYaqIkASIMwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAKxAsJiK8QL2SsM1cNxViA2wqPZl5CMfyTCWOYSoxQbyAiEA+E7lnmce\nQEPRcQNHtdWPnL6n/Tt0EWcfVG5nw0zN5F4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASIxDi6FvCEfcQ4CPylxGUHEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODBjNDI1Yy01Mzg2LTRlNTYtYWFiNy00YzViZTEzYTk5NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV9ojNSDDgAw2YsRUYx0gR0ymmZ86rU4/kx/UBgTWhm6iO\nMYgR6dF+J9HdwHLgJMJI7XeFrnAZJxoO8ENgUuBdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK1ceRwI11gwT69XTrTYaqIkA\nSIMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIqSsP8MbjlGWs3BBi0qimucJ+RUdLKZ0wwzBj8yryAAAiEA2Df2tkO/\nBLoAwJWfYcLSeEbZ09tPJz6XyElFh1yT8uI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISASZnAhQNcw63JFgDSkcqpvDqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzA4ZDk3NDktMGZmZi00ZjFiLTg2ZGYtODA0OWY3OGVkYzFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzg3NjcyMTctZDkxMS00\nZjdhLThmYTQtMTEwZTExZDNlODQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njXa5TPXb0Y44FpJKsWGSc1J/c+6161whV4jbZ7tR9Lxma5r+mpFJJopaFDNygT9B\nX/BWTdujoDbAKa90BOYZSKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUi3qnhrK0zzAcwV0f\ndV5r6Uk8QKcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgf2hini2za4umhzOEA/v6XaccE7wIzdQDsKHZAmEFoiUCIHPv\n8TSToE5zy1OVaSY2q5dtfTQ/C5rRexJTUq+tqnhb\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8415", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8415` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAbC8fDehyLXOxDSvbHa8gboAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NTBmN2MwLTcwMTEtNGRjYy04Mzg0LTBjOWYwNDQxZjI3ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU1YmI2ZDktNTUy\nYy00NmI1LWExNzMtMDRhZmJjMjQ4YWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElWyUJRc+UTsJyagnjWXeKuzEKCTDHnC/uYMHRSRkvuqHrWC4AptKKFUUe3kJ\niclVatblow6IpQKOFzM6iVzaLKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpmHOR84nloqJy78xi/RVxgDycFswHwYDVR0j\nBBgwFoAUB3VdGu8RRGXdS7uhwFSCD5CfC2cwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAL0PQ1fM8WxF4u61mXOaH57fxb5V8F2IA1g88LdTX4tOAiEA9rKztUTI\nMH8FqoAVMcCwlgjycjVjYfSPz7jsy/rC1WE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcqnpzCHjSKu3a2OGh3SUW6BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDUwZjdjMC03MDExLTRkY2MtODM4NC0wYzlmMDQ0MWYyN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaCDOcuiWfT5mBbeyx2tl/9fkA6HZZ5qWSRC9PiBSs28Fz\nTGi2y1SNLxDRXGLJMDiFNQiK9qbpfyVWuZiIBS/Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB3VdGu8RRGXdS7uhwFSCD5Cf\nC2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcHPUjQSV0B6APttvZ7YBGPPrItMSBPPqiL4j2sKLN6wCIC2QRsBC7Ccu\n1L9rhR2HSkk2RekyepJo6haHY2xd9J4h\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAT+57xLpURXIXBgpvGm6uMNMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU1YmI2ZDktNTUyYy00NmI1LWExNzMtMDRhZmJjMjQ4YWU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjlhMzRiYTUtZTU3Yy00\nMTU4LWJlMGYtNTdjOTMxMzM4OGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2E4ZWC3iJqfLeWbHIw0gwwzOK/ep+K7lp3G7mQ9lbOlRk+McxMP6Cjn8Cf1QhM+j\n5h1B3E5QXyUywzmyFg/5mKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpmHOR84nloqJy78x\ni/RVxgDycFswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgYITTKuh2UZipntl3yzc2I3X8xojLtD9bptSafJWGeNwCIEBu\nuaPNwUDJSjq+o/VdCQMu5rNPtJZtBUxALhhXHpLB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8416", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8416` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAf85RruprJ3alv7k6y59dB8+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3ZDE2ZDdmLWJlODUtNDAwOS1iODZkLTNkZmZkYmE1YWFmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjcyMGQ0OTUtODg5\nMS00NDE3LTk0YzYtMTY5YTZjNzUzYTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfIDwPOHB3lwjDRoVZ4iHPS+ovZ4IJLT/I++aDWXKriCf/sZM2XyS+uhJl8zp\nGYCfJGm+smAmAAVdaM29aiCxvKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI4LhvFpN3xGqDIE44NY0Gz6zlkIwHwYDVR0j\nBBgwFoAUbHX0NnjXR2WzhXYB2bZhv96hTtMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDl0LO/SGGxXzgEYEeTjGYxVnOrUlgna3de3sb0giNEKgIgYjjpbzXU\nIxH7mvr4Lq3/hJiBj6M2tDzH5qu0eKBPef4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARlgXsq03F+SFnfzjTRkmdKxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2QxNmQ3Zi1iZTg1LTQwMDktYjg2ZC0zZGZmZGJhNWFhZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq2aooMVwsk7EaqxVA/WHbxVnBlLAMhwpFuWAV9Qu09oYP\ne+kuUc4f6fS1DruJaJKSCd96tnWsiMQSejrcA6ano2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbHX0NnjXR2WzhXYB2bZhv96h\nTtMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALSl4KCUEmgl9gvkOoGqnWjpxKUC++gU532I5zmrXaORAiEA58eDXdiH\n7EmcoZomvtck6IpFPPs9VRFEbz/WJf2SK1o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARMRloB3qmjwqAorTGnoUy0uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjcyMGQ0OTUtODg5MS00NDE3LTk0YzYtMTY5YTZjNzUzYTQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjMzZWY2ODgtNjg0NS00\nYzk2LWJhMTctNjk5NTQxNWU4MzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPSlbO2r6orxwDha7wosHS3WpJ3EXf6SNIB8Rz65SwNhlGc7+vPaHtmLmU1pOZc4F\ntwkH3LabskhP7Gr/7nWUAKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUI4LhvFpN3xGqDIE4\n4NY0Gz6zlkIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgHHj60/Ur0T8ua2CnAQHrsf/MMtn+uRR1g8PzE4pHCIsCIQDs\nQzShVfR0lgRxqi4vGnpoGq2lJS4YRAXiLMISPWXV5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8417", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8417` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAdsqL9TmMmrgq37z4Y9u27svMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzZGNhODc1LWU2NDktNDAyZC05MTY3LTg2ODhmYjAzMjg3YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTViZjBiOWMtMzc1\nMC00NmVkLTkxY2QtNWIxYjlhMTZmNDFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBHgADzszK7Dd/Kbh8w85utVlcp6DGvvrSf8isUxrNOWSBUiy3FfylIP0wyR0\nuB/uK1au5BxQatIDXXYOLf2MhKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL5TGqsL0f9t2Wwkh4wTCT7RqFAUwHwYDVR0j\nBBgwFoAUgIiMTfBvK+xJd+SqcWaoUc5q1LIwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDyaMh6NaA5kDBRIWRlf2s/UeWLVk1ejbGPjLGU\n5nWMEgIhAPTOFwbW/KotITgZMEmVqsgMc+m7Yl4Q+qMS3PSAx/c2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYCnsVoNp8Fg3+3ILEKdVpiiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2RjYTg3NS1lNjQ5LTQwMmQtOTE2Ny04Njg4ZmIwMzI4N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARN92GTeQ5/OCy+hzjMQPiIRSusOveYp7ps/7GJISpYgGz1\ne2PNcXVgnz3R+Ywv9EjuIPqsYE6N9r92c5h9RRl1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgIiMTfBvK+xJd+SqcWaoUc5q\n1LIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP0u9EYIL66/B/k7WeFY/03KsnXNKcUi9UDvcpZJYTyQAiB3u3KCtXTh\nfcCMhZl373eoSrzuYmJjkC2gCREo1NI3xg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAYyp16gYlYYnRL554CKUorfFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTViZjBiOWMtMzc1MC00NmVkLTkxY2QtNWIxYjlhMTZmNDFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjdlZWNlZjAtY2I0Ni00\nOTQxLWE2NzgtNjE3MWVmMjVkNTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nU36byA9aRrdqTHSbCNjyqMsoB277Ot53fzwgkZD1E1yRPG2+GyoN4jFMpXhOmqfx\nY1XNfSadp/q9z8e2r1ItiaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUL5TGqsL0f9t2Wwkh\n4wTCT7RqFAUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgNseWm2xWTB1SOjnsln1rtBQ0VeGB5SeKep8UmgtfczICIQDr\nEVCH2zHHY0q1Hd4IK8HfBQyA6kOxjStJUeUxM1WaOg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8418", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8418` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAQpE4ZEypgjpXfSqwnmlhdhgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2NDU1YjZkLThhYTctNDViZi1iODQwLTJmMjY2ZjNhMThhNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWFkZWFlNjMtZDNh\nNy00ZjczLTk5MzEtZWI2ZGVlYWRjMzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfXrVJL/N74Ix/u1RxrnZjW1M3xbHKIIY3sBweA9DjGaPLn1dz8Rijtdu8Xf4\nu/7vNLf4YSGCEcOYfHtAchkdJKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIc3nK+gvrZo2KUE8jGNpGPOFAM8wHwYDVR0j\nBBgwFoAU9QqZlO/0lYYHjxKTqlnLIeY4FlQwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC2zLLJlsd85azZbKOcUrGvbsmMXqIdAT1z4qdn\nM3EMDgIgZhuaivcVhtyc3zBegGSxIHK4WG0QOt7AxzkK/ghxC7Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW0kB35ZcaTGF/lrlp7Ehyr8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjQ1NWI2ZC04YWE3LTQ1YmYtYjg0MC0yZjI2NmYzYTE4YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzsiz9HwczcOjvLDZ/KiecGt9GtN6XH9eg8O8hCYDcUGnd\n+O2R9RNC449b62hndMu3K+FgIN+fgMVir6MMSIvho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9QqZlO/0lYYHjxKTqlnLIeY4\nFlQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFPTE8hic9neT4rSsX9AXeTkBZkb3wfPUY7vYcejeJNYCICuyPhd7lvE0\now1qQuhlMtnGIz0JT+ptm0ZFaoCEQZHm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAT4KX7St8TGH6lmOG1dU7vu/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWFkZWFlNjMtZDNhNy00ZjczLTk5MzEtZWI2ZGVlYWRjMzRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTEwMmE4MjQtYjNmYy00\nYTcwLWI2Y2EtNzhiODNkZDBmZTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1Kjd40xr2y+aezK7LwPqsMqUABiHh9VOXX7hPEwDMWOXfjm6jdoCOuBv6yluUxJi\nc9ddwNmYzOXVLwMgBdxg7KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIc3nK+gvrZo2KUE8\njGNpGPOFAM8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJ4X8HaFTerdNFzk8Vx3MbRRvZTGQ5/VrTf4YrYNUHaOAiEA\n+YXe2g247evrYOxSWh8wESzGjJjrT+qjGMIDkwonbRc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8419", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8419` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAZgBuDFGYAvfcRfbbIRIqlRBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NDQ2NWI1LTQyNjAtNDYxYi04OGJiLWFjNmQ1M2EyYmIyMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzliMGU4OGQtZWJj\nNC00ZTBkLWIwYTgtOGIzMmRhMWI5ZGUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFjM6QdoBSsRrhEA9Mniy3H+x0y6F0eBbwn2cXYD/hkoBybxcyqITzL/V11Ix\nd1keg94cyZE/d8jwPQsqyXig+aOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6Lr3L9rGqq70C5X9LeV70hem4RAwHwYDVR0j\nBBgwFoAUNeoGm87DFxnnMrccwkt5+MH1p34wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQDjwYvmY1g8Czf7qkm6niMvqj5Ln6hdOPBJ73Qv2aD5NgIg\nL7b8tCJSLb+PEIyeTI2d3bu3NxxP7N5WclZL99DMUnk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV3mQqlfG6Sn+Fgf5xBBiZBZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTQ0NjViNS00MjYwLTQ2MWItODhiYi1hYzZkNTNhMmJiMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/Yo+nKgb2NoL6IpF76/IsmdpoCGf/IfMJhZbOMmqexeLy\nT7kvbQmreuJ9vmAaOWQfmoI6Fhx3hiuGzN5IOvDso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNeoGm87DFxnnMrccwkt5+MH1\np34wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOOP6nUjf4Cdr/TRG+OWS8Et5bqA/cvkVX+4+Ws/3/kuAiBI/p8CNzSK\n5A+oiSnNHANNLG8AN6zgvr5f0yjLJy3hSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAYMCbGW1IqxP6lMx+5g/U3EpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzliMGU4OGQtZWJjNC00ZTBkLWIwYTgtOGIzMmRhMWI5ZGUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGUxNGQ4MGYtNDcxMS00\nNjI4LTk0ZDYtNWZkYzdkZDNlNjNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlxNxD2WBcz1eotNDW1ynIu76VGn2QLfx74XtC6cABcn4ronk0Vi97wUf+WOfJllL\nOKb+wmkdpWP8fmUSZptUqqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6Lr3L9rGqq70C5X9\nLeV70hem4RAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJu1tlwXho22BZSCpz4+zomrSudUZhib/3udePCQ9cimAiEA\n976Q6uwB1DYEQ2qq7mCNR6J3vJQrjR86cvsVXFq8qTA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8420", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8420` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAfJKvhLLdzeWMREWB/wK3dmEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3NGJkODI1LTgxNjAtNDU4YS05NDZmLWQ3MzVjNDU4MzVjODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGExNjJlZDYtOGVj\nYS00ZTU3LWIyMDQtYTdlMTZmOTljZWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3PMyKkVy+nkTqSYfwUON97z4fNE09IFp36VcYqwcmXOOkZ+KsibpsJwn/cGJ\nN5j9rLZ/ykODfaLb6b6te/GSPKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrYuLcjS+zaRrXKgm1s0S39OnpJ8wHwYDVR0j\nBBgwFoAUDODOAMOJl5jlgBCl88tV64qMwTcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQC5R5h0ma4m0vt3vNYeq5mZ8Y6mkz1x\nrEmPg0Wj9ujGiwIhAL6o9Y/HfsmUSU0gIjnL9HRO7DcpCMQVcYwK77Ztv8lc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWL42HpIs3nYR7BtOqpM91OqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzRiZDgyNS04MTYwLTQ1OGEtOTQ2Zi1kNzM1YzQ1ODM1YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2Ve5AIhfe0Hx2x/usnx2m5MpQKG/PkmV5t4eYJTjVmXoc\nMVkUsUh7TVWjZYDbhcbDP/L8LnhJZN8pZhJrHVMuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDODOAMOJl5jlgBCl88tV64qM\nwTcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM+RrK3bT10sjW+4UVwZYe0sEpQs428sEcNRZ8mKK5dTAiEAlfkRno9r\neaEFVwQS45Le86ze4BuCvs/U5fTzEeO5rHs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAWD1zghwMJyYK+CMOTXaJadMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGExNjJlZDYtOGVjYS00ZTU3LWIyMDQtYTdlMTZmOTljZWIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzhiNzQzNDAtMTk1NC00\nMTAxLWE5ZTEtY2RjNjA4MTczNTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDqEC/ozHbsH4GT9O76ZAKj+nHWxGAbCHjVOmXCuUyiB/QcS1mMsRk4Nc3UmrAMV6\n/MxnhstwVpCl17C8Q5GZ9qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrYuLcjS+zaRrXKgm\n1s0S39OnpJ8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIhAIiv2HYNseZ8iBYsa2G2uWyeGNucjoxtymDNyilOJQ7fAiBv\nL+6XEW+OeL9FaptLiL2YpqGDuHzRHCcTBlYcrJDSZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8421", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8421` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAd2UlQraCCC5+ny6TBNaWLOiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3OWIwZjRmLWIyZDQtNDRjMy1iOGM2LTBlMWI4ODI5ODM3ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY1NjNlZTgtYTk2\nNC00MDJlLTk2MzItZjMzNTA2ODYzMmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoRg4YF5vWZBrR7S/1SEuaiEcODUdHL5TWCtQSDHsZ1hBGGX2jt15qhKzEoo3\nIoYFgkZbjYUGpfKkqMf0XQt1sqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/vWuAMaFYi2qvCdjbRLVYN96lAEwHwYDVR0j\nBBgwFoAU6e7XGO19zPfyvROKhArfbm16q0gwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBdBr2n2O9UFWOsIHDrfyqzMjUjLLjG/\nij1AZcJ5MzIQAiEA11cZe5UMBwAP9O9TsLDDEmXULufk2byw0TQnUf1iycM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV8+0IxiucF9ZpxeBkTcXsLQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzliMGY0Zi1iMmQ0LTQ0YzMtYjhjNi0wZTFiODgyOTgzN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjv+4CxMlRcaM/G4kEa93p3pOgqd8Yi84ZaFa0kt4XaMyx\nPDj+rHk7wm1XEVobf2Lo0FJmydUZ4uvmy2WFEA1bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6e7XGO19zPfyvROKhArfbm16\nq0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDRsGlHKNCCTgLeiZjZuunTZ7AbBnxxPZVyeyE+IbCCUCIQCL0iovc9Rl\nZJUGF6Vbz6RqiULtKsmmb+BCSOcj5W8LSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZ+KgvfXPQVNQhqOQpquL+GyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY1NjNlZTgtYTk2NC00MDJlLTk2MzItZjMzNTA2ODYzMmQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmUyZjJjM2QtYTFhYi00\nZTZlLThiNzEtYjY2ZWFiMjk0MTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkQLQmN7iloV784wyA7gMJvCuSW+0EJp8m93QhypP2eUrAH7TiURdlGNsmcLochnf\n/GojD6ZgWgsbNjcpgkMn2qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/vWuAMaFYi2qvCdj\nbRLVYN96lAEwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgY/mnxCNrQzWvsssRVO6OlA1c+bHD/RrhbJ6nyarGIdACIFKK\nTKew/LLxirTnNw5Jh2Ov6mEe4zdZ+xE9WYoJOf46\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8422", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8422` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZHNoSwRKlW9xj6kmj7dvZiXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVjY2NlMzJjLThlNWItNDZkNS1iNjAyLTFmODhhY2IzZmUyZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDllMjE2YWMtM2Iz\nMC00NjMyLWE1ZDUtZmE5ODhlYzU1NTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf87U0kGlR2m19ahU8mV2UT/qaYCGaM20szL18xFRts6UOzal7ttuPU/1J+/x\nyjOV3uCE0QwKr8AA73//IfBysaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpBX+syJZXWU2FfkO7NOfhXlbT1QwHwYDVR0j\nBBgwFoAUUIvsY1UVM1M26X68bOXnOp/KoQEwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQC24+1ISf+C\nIAhXAa0+0nTEI/QRBeJtdxNoXG+lla9NWQIgdIQnN2tpBSbC6R12Bd3mQYrqxcVj\nKYlAmrxvgcvdHQc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASyP6cCsyK8BDmQdD7NVV0y7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nY2NjZTMyYy04ZTViLTQ2ZDUtYjYwMi0xZjg4YWNiM2ZlMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASybdFquz3Qffx75o9G/6qY0EhU8iPp790f7vEE4y+ym3xE\nzG359tI71mJCWfXj8TTCpvNXa8+AOyH5U9BMNrxGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUIvsY1UVM1M26X68bOXnOp/K\noQEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNCKPA7gilRPxXe0AFb7UqQ+apDI/QjtgUJYC8c6x/74CIBmHvUiYuAj5\nJPmUJj+v0/VtxSn2A+Z7JYJtJQhtMfUl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAQanEPmfRCc2mt78BMMfyXStMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDllMjE2YWMtM2IzMC00NjMyLWE1ZDUtZmE5ODhlYzU1NTRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmMxNjNjNGItZmFjYi00\nYTIyLTgxNTItNzA3MWQ5ZDc1MDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmIP6VVvsfmfxnWEOMl31CvRIwWkQWaY3THNj1kzlISp0AW6hF9XnCHoSdyynFOd5\nc1Kt8PcqWVObp7ZFoynDlqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpBX+syJZXWU2FfkO\n7NOfhXlbT1QwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhALEwsd6HSieBK5cWJDncKsfWYcCNEcyTRfEUrchmuWjaAiEA\nt9Rv+oRLcR971CncSq9GikU8BXSATdH/wjyhLDbn9eM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8423", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8423` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAdN0C9O1PpZ6iu6R3Jt3QVzQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzMDBjNGJmLWExZTctNDE5Ni04NWFkLWNmMjQ3MzkwM2E0MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU5NjdlNDEtMjU1\nMi00Njk0LTk3MWYtNTNiYWVkMTFmZWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjTFY5Howl7biO4HR6CwmqyLzMN6DTF+D21OlB6TtlcSlHy/7a8eWoayGrkj1\nLnaKoji+uQOUEBb3hQP+GKoHTaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKXH+W0fUX6eBF73qeSAr/MHUk/MwHwYDVR0j\nBBgwFoAUQ08gRgP8tIu3/fwnfUKnInUWlcIwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAN1FcNHIUFFTGRoSP2cHmJx1SVHRezBpzy4NhL8A7KPBAiEAikH5UHOY\n7+uLSXW6mfNbe3ORZnhZDH/gsqu4SjakguI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYdu8V5y7/T+Gc2Qrs5QoTLNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzAwYzRiZi1hMWU3LTQxOTYtODVhZC1jZjI0NzM5MDNhNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP6uwNUHuW8EuwXDC80M890b3x5LohZqZF5Tv3lazRdq6W\niZdeJRLAU+QoSMafS/s/363jL5jegN2B9XxgX3oEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ08gRgP8tIu3/fwnfUKnInUW\nlcIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPTSQLH6VLFsSHRWVER/7DthB+uybqf4URoV2jt65rToCIGOKW5dbkc21\nfjxXcMaD2s3uoYp0q7OQfPV7DkE+XQaC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAWCswbo+Jo/9zGnxwn9B0XysMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU5NjdlNDEtMjU1Mi00Njk0LTk3MWYtNTNiYWVkMTFmZWJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTVlYjgwYTQtZDQ5ZS00\nOWEyLTg2NDMtNDkzMzZlNWI1NjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKAyL1FlXviASEQeEPT3kQNzm+dA9a1RZrdGtLyn/L7uAKSrc9MrWgzp2gaFWTMx+\ny9GU5B6rBRkhcsv2tv5lfqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKXH+W0fUX6eBF73q\neSAr/MHUk/MwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgPtophcNEB9he47Z8Lcm9HucR+YenqQnveV+BaYiFu4MCIQCN\n35CGtL6gIRYljAaGG0jdNxrF8H39+82i8T97SsMDQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8424", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8424` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAeZOmIpkvj6hIYNhX6qXtLd2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkNWNhZTA5LTA1N2MtNDMyMC05YTk5LTExMTNmOTNlNWIyODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk4YTdiMzMtNDg2\nYy00NWEyLWFkODktNWE3NWM3M2I0NjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqL5eZbI1qIcLVprurTOpFa3OD4mXDagy43yUqTkBFpTt24LmZlmv8XAKaqc4\nVsqxscByRUDcxfE1VYMFCYqi0qOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhkRD7Uwm2wHcTOAGMiLtbb5633IwHwYDVR0j\nBBgwFoAU11LCwtcI3dCBVu53iPjDsWTMoNYwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhANcJ3bWF93+zUOwGLgbj9zjsGerBWYjRcfV6Q0RKnXQkAiEA9lRvVam+\nPomvnXxZSchY9NvOBcRXf+HZYfkxrAhag9A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQnorCSlA97vQowS2Ehs4pEbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDVjYWUwOS0wNTdjLTQzMjAtOWE5OS0xMTEzZjkzZTViMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVYhzHLOMpzFArJA1pQMAnKDF/rKlsVuUSIQFkAX6lEyut\nnPN1Pa1UC319fPxWaTk1ACcTE/KCNxWtlg7VO1GKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU11LCwtcI3dCBVu53iPjDsWTM\noNYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKG+LwO09Psgb69iwjS9ylo4OKP+Y+8f3K3vLTyTjkP5AiEAihBHSAdG\nPX80gJfq1Ibi7gs13ywFAPAtLxTtv0+CtUo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAcxkPgM/WvdLxBIicbL9mHhbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk4YTdiMzMtNDg2Yy00NWEyLWFkODktNWE3NWM3M2I0NjA4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGViMDQ0NGQtMGZkZS00\nZDU5LWFjN2MtYjQyYjBkNzFlYjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCQaVuidJaHNuSPlb9VWuXNSmbYnNBnRUcOg5QXcWXjdSkYZBbENd7JAziD0w8CV8\nBPmViizk5GDtxBnpSYYAuaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhkRD7Uwm2wHcTOAG\nMiLtbb5633IwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAOaZx+s0bqnEGj23grsKH69TOGC8ls/lMX3uSbfWe3GXAiEA\no/BUwSR5C4U/Krj66VOkONesO88LfsCHleIXyrOt6Kk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8425", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8425` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISASRUOtrw7xVKzVIPx71tPVmRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4NGQ5Mzk2LTc2ZWYtNDk4Ny04Yjg2LWU2ZTlmMjJmNjYyMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdiZmJjN2YtOWU4\nYy00MTdjLWFjY2UtMjVhZmE5NWU2NTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnrRcAsMQQOwgpf8MKdfxzuEmsn8GZsYC5TXlETR8GbBY9GCl+wKUuZdWyXSX\nocMwPKPkCTD2y4lBh3D4LO0yyaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7okNg6wTUn49DuyxiGuzBy/MUg0wHwYDVR0j\nBBgwFoAUs/wB0N0nGlVEOxTiR7rpDCqwnu0wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCmZTXptUt4KoumZct28CJZlQy0++zs9roTjRv+PFEQxwIhALJ1H4K4\nhxLfN3F2DcafZTfqky1ZmMgPGM7wNYfVyM6S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdtYtNrAD+RQaM2RYtqX788FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODRkOTM5Ni03NmVmLTQ5ODctOGI4Ni1lNmU5ZjIyZjY2MjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbk43IsOHLdWwEDmZFoDgsZ1x5N7lcT7AK4mwH4pjCFmZH\ng75cuqeUQl5j1VbDAn1Stoaon00m/+PWJ20xy0tao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs/wB0N0nGlVEOxTiR7rpDCqw\nnu0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIh1su1QWq2fSRzIazNQdtHEUY+19V9haiQ4DRvsE80xAiEAkOAt8y5/\nqYuJgsTgjLgFl7LrG/7EsIfctVyOuDF0YWg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAaUN1HS6yrQAIDqKbWAtGGe+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdiZmJjN2YtOWU4Yy00MTdjLWFjY2UtMjVhZmE5NWU2NTNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjI5YzJhYmEtNDAxYy00\nMjJmLWI4MzItYmRkZmFiZTgwYmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBSvZa8wPlrI0PDH2QTTSYjKKuLNtlnoWnOQK+6w2e6XNHVmaEcZVuiguZ7+nz49W\nRlrEgp8mHRXt2vr8OVaGp6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7okNg6wTUn49Duyx\niGuzBy/MUg0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIItpLPkfpV8Wpj7SxOBqfeDW3E/GQZClWSOcyM9AlIgAiEA\n0OA27aBmqGSRJPMJXDDUb4I2q5+/fIjiDSOjqoVYp/I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8426", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8426` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVN+Z3twv+4vjAoDXsI72u9BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1MDUxOGQwLTlhOWItNDA5Yi1hNDk1LTJmMmMxOWUxYTZhYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjYyMjExYmEtOWRl\nMi00OTNlLTg1OWYtOWJkNzZlNThlYjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE99MNmqTfTsdqC2jiyRVMGGnvaTaelZigKlEh/uPo/G84RVh8ZJb5owpHkLL3\nSoJZEirPcBRlG/fUHe6Ubha7caOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsnOG6N3T18ig0Du7VIxXTgnjEbMwHwYDVR0j\nBBgwFoAULQKv6j2NRh01kw4qrWWqZ5M6ZhUwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCE69D/18SC7POJM3omJn5fCranaNxaRpSTghLP\npAugLQIgLVowAl+F0KcogLJS/OG4UYlGl1Do/xqmsem+lGgavCg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQLxUYO7R+R4kVx8UoaqDI5VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTA1MThkMC05YTliLTQwOWItYTQ5NS0yZjJjMTllMWE2YWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRxoCfvNIBLWQTCODoBE9aMJSaOEXlhe1yvgu5KFLbzKbo\n8EF6IJ34ohpcpqnNIHIv49QFcNE4j4EPuGWtC5kJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULQKv6j2NRh01kw4qrWWqZ5M6\nZhUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ5LIoIAtdgaylewonoQG6pd9DQ5rLzL79ZY84Tpij+vAiEAufiPjgY7\nIk/7CiQfACIMiIyQT0XTnULE2k0wenWMNR4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAYoRx+FmmTP40s7QNsQzxO35MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjYyMjExYmEtOWRlMi00OTNlLTg1OWYtOWJkNzZlNThlYjAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTRjOTg3ODEtNmM1MC00\nMGVhLWFmMDItZGE0NzkyMjUwZDczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\neWXAnGVRYmOoPyN/UGMWYMfQuZmCwh04qARVq0kgLAJJb5eDjo7V8eKCiPRUFfvF\nuvgEBq99eoiTfm8hLGU8t6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsnOG6N3T18ig0Du7\nVIxXTgnjEbMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgRYYnmVYFHrKFRzZE22z9KWsrdJv8zX3ntcDftaXeu90CIQCk\nfTPpsSr1JMsR3KcYIgPlF74xsDwK75NxcFSiIvwflQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8427", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8427` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAXoVvWuyehns+pN27BZcTEuxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4YWQ4OGI2LWI2OTAtNDgwOS05YWY2LTIyOWM0M2Y4YzQ2MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTE3MmFmYjAtYzRm\nZi00NGZjLThkZGYtN2IwODZmN2ExMzE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE966v1P9cjJQldNu5Np2GoK462sT+SboJdEvGPRNfMZhfb8NAtZ1lCI7Z7Uhy\n5uMaN3JR+TOKBrGQSbMqzCl39aOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhVn78Hx3fdwnnGNVK2fVI3F1JUswHwYDVR0j\nBBgwFoAUVBsvbfn2u43o0AKXyb6Cz/Dv0zcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQDnGN1X8AkUYZytm/OxtpQp7uuN25ah00H3zhq9\ncaXtBgIhAIjZsLxTeSWNsF9kiqJu4moGAKWKYLkcSZ19YVjpXPOp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbP/tIWfRXYZl+UcXcoQgSa+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGFkODhiNi1iNjkwLTQ4MDktOWFmNi0yMjljNDNmOGM0NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHCsj5aDLKWFmlAUwOpjUdsHcfzACTmml8P2YBkOB9sOf3\nuT9JWh599MwRas67YwSTdRNHC/FnLoftVXmVw+q8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVBsvbfn2u43o0AKXyb6Cz/Dv\n0zcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSpfE6w+TwNqa3Tb04SQkWFjzjbYOk7/r/SZNkDXAfJsCIQDCzr1127MS\n+Skyj2PYN3gUqhgwOAwvbjIiRTETpqiETg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAXxYW/Lm1ZvqDfQBAFjYPxdTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTE3MmFmYjAtYzRmZi00NGZjLThkZGYtN2IwODZmN2ExMzE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmJlYjZkMjgtMDhiOS00\nNWJkLWFjMTItNjgyYmE1ZWU0Mjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbZPXqPDWzfhJ1DctnFgGFhayYMXzw3QgC039FPCNWsbUecCCHg6rncoaxfrMh+Hy\nc8HxmTHPskvKPX4d6NR/zKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhVn78Hx3fdwnnGNV\nK2fVI3F1JUswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgWmdTwqoP39gi5H1VyAqvfnAgPE2bxtXbPFGwqGRwGNYCIQCT\nHvl0mXvpqtVUFchdhE/PooA0JQWeNJMzvuvJ/Q+V8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8428", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8428` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISATCnpEKp62LIf/7lgnXlT7cRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzYjQ1YzdkLTVhNTktNDExNy1iZTUxLWE0NTE1MDZmYjY2OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY1MjQyODAtZTIx\nNy00NmE5LWE2ODctNWEyNTQ5YmFhN2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESxbmD5k4xquz04BTBHWdGCkhcvhRjkcH/X5BIBbVvKfo2Q129td15158+vr3\nXJPFg7D5HTV2QGxLWZVgSigSZKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTWLs3oKgV8AlIzZIo5voYyfEfHQwHwYDVR0j\nBBgwFoAUTuYicJzSSdIUgbflz1GrAcBXiKowPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCviEYv8LQ678XmJmFADt5+IJoJN9VR0ex5DxI3OKe2UgIh\nAKGJkG5PssZpP6wmTWiswVja2q9Exdg4otSdjKfpvG9y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAd79ro8Z+aPFef7uLBfcu5d8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2I0NWM3ZC01YTU5LTQxMTctYmU1MS1hNDUxNTA2ZmI2NjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwnvNwUt3+6RL0w7Zd5cdrdu2J1VtU9u88NPBMMaW+EgoW\np8/INLkbPQ0HXf5wyTxQZYRT2NlJfr210vXCAN77o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTuYicJzSSdIUgbflz1GrAcBX\niKowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCUTnOjLCa2S2C740jRN/Z25e0DN8fGm7qI7Ss9i8qIMCIDub2pUlicjs\nDgKDhJNUIomXT0ebY/FR8tZdylUJCWwZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISASZ3MZFD3sdk7/urIyb1dOcpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY1MjQyODAtZTIxNy00NmE5LWE2ODctNWEyNTQ5YmFhN2MxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGRkNjFkODYtMzJiYS00\nOTdiLWJmOTQtMDRkMjdmMDI5ZmQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncL2kZ2WlzJBEsQysJGZpKUatCLQB7DN2bXZ8c0pMRFHH+Bbixy8JCE4uL8hvIAJs\nCfbPgSUZyu5DqF3BINUt9aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTWLs3oKgV8AlIzZI\no5voYyfEfHQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgRoZ89SmilGlQihKE5RRhV4dUIY4lREZssprSfhdi19ECIDjl\nbgoMgeUE/xeR/8Qr/2KRKGsmyKpEgSweWUbu8qKQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8429", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8429` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAf5xo37C7KfN1beDDYaK6iy0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzYjRiMGZhLWM3NDQtNGFhNC1iN2U4LWVhNzhhNzY0ZTZmODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE5M2UyYmMtZjQ5\nZC00MDk4LTg1Y2MtNWQzZmU4YTgzMTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBONNtRN/CmoUdQse7uDCd38Im4vo9biqHyVQkCaoMDCV0jgUjXMOIM+Cas1c\n6h68C1Jr836ZCCw4BOjsNnbN9KOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiM5dzw+E1ObIWMztGUS9EFzvCaswHwYDVR0j\nBBgwFoAUkCriVsfZjzLxDQQGcT11PIAiuW4wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDfqbA7fL8sbA+n6gRWmTQG7b3Qay0p\n/SIewfFNj1TtsgIgeolvR0IG/oWnszpIjV2hRrLAzjbNa3JV33CTl7SSJJI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeo2iiQPSoCixQOsrZ8Nbk/GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nM2I0YjBmYS1jNzQ0LTRhYTQtYjdlOC1lYTc4YTc2NGU2ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFcmicDY4u8nuV7AlsGiVs0fu9EFPG+vzz3aTeMkCvtSkI\nOWg1Iqss+nMc8hJe+KZq5ajrCK0sZVO+Wcql+clEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkCriVsfZjzLxDQQGcT11PIAi\nuW4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCBeYborjUVA5U3r4cH0k7X6GSNLrd6RWCy+2vcT3DhgCIHhH1oAmPOm9\neYaDKOUhHxSfdeR+MxMnWFmaQe5bU1ZS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAa7yCGj81xmnXupESpnwey/pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE5M2UyYmMtZjQ5ZC00MDk4LTg1Y2MtNWQzZmU4YTgzMTU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzI5ZTMxYWUtNmM5NS00\nM2NhLWFkYzctOTdhNWZkMDg0NzdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJVG6+9Af91Xlz5LtnFquyRE4Wjec4e3OqgFLgUfRmZ80KtVZxP6mTS3FME8iIxGy\nOY3c7VjTZeUZWQt2DHa2qaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUiM5dzw+E1ObIWMzt\nGUS9EFzvCaswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDRwAwRAIgEH5kU0qCeCNJadLIJzskSWCNV1/o+mVpaIiJNCisiB8CIDHq\nfFkmwAghcconfXJvEogod8Z+nk+XTiDDxEXv3NW+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8430", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8430` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAYfJz7sMegeccOZpsRDJPy6aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiZmI1OWYxLTM5OTQtNDAzYS04OWUyLTQ5YWJiOTg3OTE4ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDJlNTgyNTctOWMx\nMC00NmFjLThmYWEtNzk1YTFlMDI1YzFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcXkyO448azKwUEZQ5FaeijTjWsZssaM/VAqOCr2HYO+ORDCThkjPRoT50mHx\nffMMvFRM3DDTwY4gxx+FZlR+UaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWOgTFHpS9aAiP+WUid5tiSpiZQswHwYDVR0j\nBBgwFoAUa1B7RbfbRGaq9gsXucgOiQS5vmMwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIFYQUccuxB1MfXsWKFTQ401RhKFzz+oD\nRkY/RXV93zF6AiAtYw52BPDtBthdMb65rDjJvWdCkD1pa0MlsxQR1gYHlA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdAKqHUr1qk38ekuha50/R+tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmZiNTlmMS0zOTk0LTQwM2EtODllMi00OWFiYjk4NzkxOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1am6tkO+FL+g/1lY+nCroxDF9cGCDkrYUW3rp3tfroAl2\n2nC02DUnk6MktW25N6NvMvvwzk24bcjmY1Bj7nHCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa1B7RbfbRGaq9gsXucgOiQS5\nvmMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOtBvLac6kRDnavMT2uPp/c1C9d715dv9Zb2ITgBvCVZAiA3kWO2jwnQ\nOGqKhRJsyX6wf3tz3IalC50ACtyWAPDVNw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAVJg92Rrkp9xYJ/onVoWlaFnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDJlNTgyNTctOWMxMC00NmFjLThmYWEtNzk1YTFlMDI1YzFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzU4OTM3ZTAtMzZiYy00\nN2NkLWE1MmMtMDM0NGU5NGVkNmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuFCX3KgdF4bjmnAjgALRPDQW2H0iRk4MlLP8tNUj1LeJbiFYN66VV3ohkQB0Ad6W\nVZQTpSA/kp5dE7wDsABInKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWOgTFHpS9aAiP+WU\nid5tiSpiZQswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBH8AAAEwCgYIKoZI\nzj0EAwIDSAAwRQIgFJ421zOzgQor1gOVcoIHyzmtMyr7QirHcUUiJFN0NkUCIQCp\n80mlfGLWDImge2WOvfSMoIxAwgIADT2j+G59Zl9IlA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8431", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8431` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAW+2f00o1487GFQmr5+pplECMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkM2VlNzA5LWUwNzItNDg2YS05YzMxLTI4NGEyZDk0OGFkOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZiZWMzYWMtYzUz\nMS00ZmRiLWE4NGQtYjY1NzRlZDdjZmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4EOlK1ZPvSV9UtZq3w32lghhGlTZkc5N/5YhlSfyscq7wyqtZh9YZn7VzMYo\nAoSgsqz5Gh3h7feXbuePjqvuVqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCerudLr5sq9TFhzXZHcHmYhn6SsMB8GA1UdIwQY\nMBaAFKw7I1xdFj5l3x7OlPYuZ+f1csiaMAoGCCqGSM49BAMCA0cAMEQCIBePt9Jk\nrGSyn3/nODqxGuQux0XZgLf7bqeewL5g2V1GAiAq0rup5BxuiX2S8NfyHSdQQeFI\n4+yIJM/yXyztGBpdVg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASm3/5benhmtAl57R2bM4LKUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDNlZTcwOS1lMDcyLTQ4NmEtOWMzMS0yODRhMmQ5NDhhZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKcBFcuY4tdAWo05KtpieecsMCHrzc4lZfA9HGPOEP8O/e\nAJmGuijF2luXYIs38ZLwMcco0DSsxaGP13fL/U4wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrDsjXF0WPmXfHs6U9i5n5/Vy\nyJowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBF7rAS0X3mFyVQ93/z4qb38QGlpMormu6Q1ec21ko7sCIGWn2GsyhDL9\nXGZsi7FMmbO+zmUNXekPh7RfTcItL3iR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAZk5ZH8sXeZMFVs1pnIHuHieMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZiZWMzYWMtYzUzMS00ZmRiLWE4NGQtYjY1NzRlZDdjZmIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTNiMDAzM2QtNWQ5Yy00\nYTU4LTkxMGEtYjVhZmIxMjc4N2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwlSJUH/fM8ZjEckH6GNUKyAHFqOXrSWTJ9Rf6SsHjL/nYc3j9HAIkUuoTkJEU7BI\nQOrzhcfBb+RWBlewt8TWkKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJ6u50uvmyr1MWHNd\nkdweZiGfpKwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAODhUeEGU362yXVZJcCrazHdmOH+zPVkTpMq+uajaAYUAiEA\n4Lahz1CctzH9ZxBjOTyL5a9qcuB7yrlubaQcAaYHDTg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8432", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8432` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAfbjHu0tNn9Oi8WGloolVA4kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiN2Y1NjZjLWM5M2ItNGVhYy1hZDE2LWJjZDUyYzQ2ZTY2ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNkMmMxYWMtMzIw\nZC00NDU2LTlkZTUtZmU5NmMyM2IxZDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElXybXfrEk5zHPgjUemL6oPD9pqDcOdIBe7QNNriu3k9WRgXkLuHrX55H0XoK\nD6oXlhCZB06RId/hCGm4hJyrKaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC9VuN3eckOA5VLJsUouxULyY9DqMB8GA1UdIwQY\nMBaAFFF3xm7XZhnhOhYNWGLgo7GGHKZ0MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA/Dpde08wqueEpz30u5Xqq1SVDnKsAsMV\nif2lNrZkteECIQDx73GiBoH70ZqKWGehu2rKwm6oQba9YYmyR1C2LGhVGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVow7TvO64FWmWPbci/y/Q11MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjdmNTY2Yy1jOTNiLTRlYWMtYWQxNi1iY2Q1MmM0NmU2NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdK0mG+V1+ISgltYjo8uGngDp/PQtcONww30yIgKs1rT3U\nTqBmXMa7xEloBkot1oiNS6EGsSUJ7uDSwiMB7zd5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUXfGbtdmGeE6Fg1YYuCjsYYc\npnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIym/8RX7NL08PAFq6ee/83p+7SpLz2IWbAkt+knqbKWAiEA0nDEwFGM\nxAG7scfrEuRU/YhEHO4pAHyok/X/fpj1m+4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAfWWJN+t5yc8tsYRXuNlybHHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNkMmMxYWMtMzIwZC00NDU2LTlkZTUtZmU5NmMyM2IxZDdlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTU1YmE2NzctZWI3MS00\nNjMzLWIzMTEtMzdlNGEzN2Y0OTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6tNBiz0uFwWf8Z/hN1U8EVNoMxIAGBjA8hY3EQkytnYTP2Px6JJ7kNJR7RZpOSqL\n75PuR6s23ASnhlMeHjlUpaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUL1W43d5yQ4DlUsmx\nSi7FQvJj0OowHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAPAhSXyJIoEzsCAdxnoKF8auj/uSdMNE8+DO6yDB2PFhAiEA\n01pKJ1Tl2ZrhDVBrk4zm+NbKRWjLTCscifu0VFiKtzw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8433", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8433` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAb//HHdJ2X57xy/5k0GN15S8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkOWEwODBmLTI3N2YtNDhiOS04ZjlmLWUxOGRiNzQ2NjNiYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjAzNGU0MjEtYTUz\nNy00Y2VmLTg2YjYtOTIwOTc2NmIxY2EzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHONYbU8xGSYjLxlLab5ouyLzejN1Amsr0nvoC/eCA6DvVQPhbLxC8k2AGPwM\n27/f+9S2dsoqoPSpvhaKnFL6QqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCnRKQEyKDjQAdtE0Vo7nLHoqtFkMB8GA1UdIwQY\nMBaAFHkoTgC/IJHIbM0Tnuif48OXc9W4MBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBvV18djt8XsT/5tK4rSHknzbcyT5YBZuSD\n/z2TRy3UXgIhAJ2PKzpRk6nIPFEmOiHHHsRsLQfENG/TxaAiKNaggy5T\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQfCqMBps/TiyC567eES3deMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDlhMDgwZi0yNzdmLTQ4YjktOGY5Zi1lMThkYjc0NjYzYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjFEyvl/jCGHIJd1LzoQdEQekfZXMybBkXOYXdKs7i5SSO\ny/1UyWSixgQXja71DxnAOeS1JSEAlbl2zBNJz3FOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeShOAL8gkchszROe6J/jw5dz\n1bgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM8j7KWloowXYNFO2ekuSuURa8m9aMT4MyQCezOKHtxXAiEAu55eyWRV\nH/s5DqXPtcLNFZ2o08fl9AHt4Icak1eOWF4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKTCCAdGgAwIBAgISAVxOTMo+FARWHKxtwwsGvGoEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjAzNGU0MjEtYTUzNy00Y2VmLTg2YjYtOTIwOTc2NmIxY2EzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTllZThmMjEtYWFhNi00\nOWQ2LThhMmQtMGZiZDIxMzk4YjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\naA6LZpyx7Du8+3Pc35OSlByIWCaXccZzHmGhZxlfJ+Gx2U7j6kOYlyOR8Kdylxxy\nApVvyRRsDvk27H/sBZ9eG6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKdEpATIoONAB20TR\nWjucseiq0WQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRgAwQwIfSwfq+sk+LWb0WXDNK4Khz8NaiqAn2hxZIwUqAunttwIgIkBn\nMBqofqb2dQhC10WhicgJZPghWiW65J80YbJ9MM8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8434", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8434` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbxsGOIPPfec0GfZxHZtbNRQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNDRjZDRhLWQ2ZGItNGIxZS05MjQwLTc2ZWVhZjMxNjYzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTgzNWNhZGMtOGQz\nMC00M2JhLWI1MTQtNTZhMWQ2NzUwYzIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl/ZVzfBbliGgjO6OM+mT3TiyWozyB8qXVyjLqGqMTCSPFS+U9q4tNE1t6UMi\ng988kQn2F1IxbNjgRoazy8JWLKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTKp/qPjvbuR7BWY+l8ojEbpHtwSTAfBgNVHSME\nGDAWgBRSw27OoVOjDP5BJjmEwN7WoXhcSDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCykCNLxBK1u57cEjpBueLbnibxWU/A\nsbJx1rLmqE6CFQIhAL00o1Fhrxe8FpdJ/kVyOAF3plDPhZ0wRQioC2ZBZNul\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATyfOMm3wLPxDuXwWDfiiEUSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjQ0Y2Q0YS1kNmRiLTRiMWUtOTI0MC03NmVlYWYzMTY2M2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpuztEWUqXtLc4wQNjqVXYb73M3tPYMT3HidiJtjIKQDiY\nfj+UFtOZGn3SuG1NgU0WoN6Cx3eSl00JnSffa+AMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUsNuzqFTowz+QSY5hMDe1qF4\nXEgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJSym4A+g4y87aJdWZW7xBJSun/VSEGKOUJiPbLvqIgnAiEA03uBmzAT\nlQBX6fTOaNqEBcLUnD36fmhK9sSss4UxXGc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISATp3sGOXrm0XE0JQPBg8AyYDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTgzNWNhZGMtOGQzMC00M2JhLWI1MTQtNTZhMWQ2NzUwYzIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODJhY2ZjMjMtZDk5Ny00\nNzBmLWFkMzItODk5NGFhMGNkYzdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1O+REXXptZ4gzWSAmhITYZ9FAA/P5FDb0XdB+n7y15a0m9jFwPogdehnxdk92pP+\nPQ5Xyk/0lXcH0AE99p870KN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyqf6j4727kewVmPp\nfKIxG6R7cEkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgblvO1C1dexSjEiMhnXX1xFjC8tcQ/hNeb/mshoHqhNMCIFAb\nxrJjbt8V/LiRNekkVDB0iGnnf/SxbS5XTDgBtl2a\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8435", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8435` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeugAwIBAgISAQUWbCCeRg5MMkuADjvbqAmmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkYmYyM2NjLWNhMTUtNGE4Ni1hOWE3LWVmMzk1NDU3MjJiNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2VlMWNjZDktNmQ4\nZS00NGUwLWFlMjItYTMwYTcwZDgwYjQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsWojgBWY0x+i/6YIv2UsIf7IDt9fI6UGpX4H8W04URIciSU2imc1vVbB8HhH\nwTesS2DlYGIJmmYGcRs9KrIO4qOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5uexO0Le58t47+MO9SloV0lCODowHwYDVR0j\nBBgwFoAUIFbeR7438q0l89OMfdwGWHUqheIwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNJADBGAiEAvxcBYdpQc5de\nCpApUOH5oX5buGaONCqzryYVF2EwGAQCIQC1npfP0q0ZQc1nWJYp+rS9Mc6OJRIV\n6if7AHZQDPF7Jg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVnHA1eUaFAFa2zEr4U2MKzQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZGJmMjNjYy1jYTE1LTRhODYtYTlhNy1lZjM5NTQ1NzIyYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtgv047sax0/sERO0/tTrbbKY9TSEuaNqZ7WKyh1LkhShN\nmlIpAzfX9aF09MUMBHtanTGM+kulxGoPkB6+eVzgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIFbeR7438q0l89OMfdwGWHUq\nheIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUqGIW2M/rEGIr0A/BXM+vE/fJJlmQaLCZRBV0QUoY2gCIQCTway7MBtW\nOpF0Y//xzR6LHXsl2eIr75bdVQcxM59Y0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAUwk+jxrF0JfCwkfiDZTBOC1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2VlMWNjZDktNmQ4ZS00NGUwLWFlMjItYTMwYTcwZDgwYjQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjgzODQ3NGMtZTFlOS00\nOWE1LTg0NGEtYThiNWM2NzAzMzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEp760HjEunrkpLAG5ttBKk4Qm3bYL+C+M6yTCGq8KjC2AgpKzDKkAuAo6jyh2efA\nIDseREGg96d3yuiZzW4f/qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5uexO0Le58t47+MO\n9SloV0lCODowHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOj6jKnohQEfPiNGsW1uH+naQiQZEWHUsahu2ZdtynHCAiBQ\nR81NncDVifV+tS1dlmT90mqW/DfEmjnd7Y9H63r2hw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8436", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8436` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAWaAd/PoC2zhiYl52ZdTPEv4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2NjZmNTM2LWU2NTQtNDRjNi04NTJhLTRjNmQ4ZGZiYThlODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM5MmY4YWQtNGI0\nOC00YmMzLWI2YzctNDQwNDU4NzBlOGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJvDFI/Qp8MDCTx+XAnwdJQFYsYnUfKtu+RSKT1rUZiIViiPSq+hfLhbY76hH\nFSGNY9F/jTJ6lu9elWT/2z4vLKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGpeLj2v5LLGddHsvex9lifDNeUAwHwYDVR0j\nBBgwFoAUECyX34XyT+Ov4K41n0xi6KSPt/EwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiABxauwObtl1fKq\n3fYLHz9TWV4oU0iWfqA6mOx1dGPE9gIhANXgIAXVBmh8TojVPuZ0KuaUvZ8vlQTI\njfRY75aKHqu8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYlDdJjUQ864hHPwC+ytEHbnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjY2ZjUzNi1lNjU0LTQ0YzYtODUyYS00YzZkOGRmYmE4ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARU7rWF+D66Re7pUFOzWg1fghKqYdXQ7gzRsUMiBIXZWjeO\nPsj28gBHl2yS02+IV9+O5f2Kve6pqJ3m7Q+uFBFKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUECyX34XyT+Ov4K41n0xi6KSP\nt/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWKyM/V2W5nhQGbKNclNViBvf1ou08xgujtRBk0+VZa0CIQDDxcHHYls0\nge1/5EQdgpxnw7w3jfLLavabOqZ9Yv81jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAb41xA6hjI71aJqdXP6BUWarMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM5MmY4YWQtNGI0OC00YmMzLWI2YzctNDQwNDU4NzBlOGQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWM1MmZhNjMtZTUzNi00\nZGQzLTgzYzktODcyMTlhYWEyYWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\npz+cUSMRF08CftVe2NSP4fO4pEUpTUDgjDdtHRyksESGh+kv1KEZ0XJ7EkE2C5Yo\nVJIXhnvwf4FFXexGgMvpWKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGpeLj2v5LLGddHsv\nex9lifDNeUAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgUJ2tWMEd/EnK0LTVwEdxmLOEO5iAKcjq6HtsmzWCXXICIQCR\nhY1AhjMo+zempKOC++BSeb5FJyiNop6vsQ39bTHFRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8437", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8437` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAVajr6nQurbnDWLE2W2YbBXdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyMDAyMTI0LWNkNDEtNDBkZi1hM2Y3LWI5NTdhZjliM2NiZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIwMjQyZGItNjNh\nMS00ZjkwLTgyYTMtMmJlNDA5M2YwY2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHhwN9j4IGcrFZVxct3zTLTeQkw+15yB0w6pXQjSnVfiW1udy8HDgIkoazyfh\nmDv8greP9eb0JpLb/1footWZFaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2/b0cwwSa1IGdXhxPuKP1DuD030wHwYDVR0j\nBBgwFoAUXgQPSo0EXVpnUv4DLC2hOirhouYwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiA5YFr4JNAaeT6ifNwWT/Yi\nBI1/4YrNHzP/Mu08Fbl2VAIhAMQhDGUc8LS0uPyOqb4GcMhOYwOZoPH7tD3Ziwge\nCHae\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASNBOPcR9/D58QpLjVuQIl1qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjAwMjEyNC1jZDQxLTQwZGYtYTNmNy1iOTU3YWY5YjNjYmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5k5jPX7W9qfV+75MDxt3e6dYjYfvMO5mvVQHe4CkQwHCF\nNaQAKdFH2i1N0qMAAcJayLciWi3yI/kxYU4n/zyfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXgQPSo0EXVpnUv4DLC2hOirh\nouYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN2nrImNCk0IY51MDgfr7O/wB/23mptfuGdYSY3QVcdTAiBoQN6B4BKq\nDiVW+cIpiu9GzQPZzpZhR4I/XITzuKPbIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAanO+q7iw7Y8z+RTI3HGaW1hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIwMjQyZGItNjNhMS00ZjkwLTgyYTMtMmJlNDA5M2YwY2Y4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODMwZjg5MmEtZjIxMy00\nMzE3LThlMzEtMGRmOWQ5ZGNlMzUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nV2a1GkuRMi9WlL92b5ZxwBncUuOS2FIy2Pq6fIkgCv/+gThSwralrF4jslCW/wVF\n/xm2AbBt+rc1uEmRoe03b6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2/b0cwwSa1IGdXhx\nPuKP1DuD030wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAPdrD3w9W4M40Px3J0za7IighK+6PDDMt1kmo/2jla4iAiEA\nqB9ONaQYxnM8Yu0GlwkPLwxYYDMmJpVsoF7ANxd3IcY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8438", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8438` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAc1dxExLQAUKFEuMJP8/w6LNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyMDQwNDUxLWNiMWQtNGFmNC04ZWFiLTFmOTM5MzExMzAyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBhOTFlZTgtMWMx\nYS00MmNkLTg5MDUtNTFiMjQ1MTBmNjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyA9EjpUbYM1mpMucdQ/dYreanDxxWfUc796x6ESHPy4zS2q9xg0k5DqvFVcw\nHrjH+KNWEa6Tr0h1hef2FiYkWKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/3oFewnPUwYEqp2WulEOQ6iGhMwHwYDVR0j\nBBgwFoAUI4+WTNlawaqVmRhDHWPXk7AzvJYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBInIGh\nGdlqcouZwwMwvVrjPkhoU8OEq/IZ47XHReKMIAIhALj+4zP9UblUu75eMX2M4ItF\nFnCXVsouDWGMR/xO6MA9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXs3skllxfozVC2C2aI6QHJpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjA0MDQ1MS1jYjFkLTRhZjQtOGVhYi0xZjkzOTMxMTMwMmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPR2VMeNg5b/B9+mxBd5NoSIoCWkrKkEe5pz9UqDVZ7E+e\ny7ZVRlMM91MRdD1JDDL/9/pCwFRWmedh6RTNsvvBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI4+WTNlawaqVmRhDHWPXk7Az\nvJYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALIGJzRFdeB6D2hr7ZqL+V+xLUMeNPOogwTIAyX+XodFAiEA/FjPy9y3\nwwV5gxhQaBVBNKUsS3d2iN4xGQaoRbOK6jQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISASe8oeX4H6EhETWaoMox2O0LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBhOTFlZTgtMWMxYS00MmNkLTg5MDUtNTFiMjQ1MTBmNjI3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Y2ODFkMmQtODYwMi00\nMmFiLTliOTktNmVlYWMyMWRiNjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQ5F99Wv6QLOGJwjGg0u15uJaxlqHtrowVsQ/SK2xoWCEYbJfdgukHsM1LN1f99jP\ncF8dcklMRAEe3mgKyZWb+6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5/3oFewnPUwYEqp2\nWulEOQ6iGhMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAI5mOs5JzG+eHcYN1v3aNiaTwHXKF/jLKgbbhARrRh0aAiB4\nHcaMwYjNFj4z0PRnpSGCtNBpbWxL6VpKUTC7x27lwA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8439", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8439` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAVImhYH3242Vdgvb9aBnEIgQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4MzM5NGM5LWJiYjYtNDNjNC1hNGFhLTFmMzBkNDdhMDU2YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWViZDJkNTQtNTM4\nOC00MDhjLWJjMTUtNWMyODU2NmIzMzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/qzd1OcnhryiCETMRyA5Xn/7ZZEX62cXluP4sjJ+95SFaZzbGx0iLBodtAHR\na5GaSzcd/uPJvJ4Ee6SaphsGRaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWwvZUDCyYNVB4q/NjzwjhvjqSWQwHwYDVR0j\nBBgwFoAU9xju5yIswnpaNzGdAS/OPjuGWnIwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBAYK9m\nSvZTs2gJHFJ7tDYoVHrBTkzOfA4CcY0bVkwtFAIgXBpJlvJbwb5tBVqCDEhEUWw7\nQXfSy/gSe2bkcoLW6Dk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbvbgFKu3Dlc+SlDgc7q52cWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODMzOTRjOS1iYmI2LTQzYzQtYTRhYS0xZjMwZDQ3YTA1NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROs3Q519D5Ej8d+xw4HDODZQYYD2YuwI5F9/P1g9Uu6p3y\nKI5W2tzYTgPjJ5xvRz4Cik14yOKsdETtJdtEb0jLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9xju5yIswnpaNzGdAS/OPjuG\nWnIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSbgIe9xnl6wbMWtickgmgTqDbRRFG56o7RjlWbuPD/wCIGO/yM7AIRr9\n0AeS9KaUEQ8uj2zkfEtBH1o/EZfGBTx4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAV1Z+pdjFrHCq2l9jiVYFgahMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWViZDJkNTQtNTM4OC00MDhjLWJjMTUtNWMyODU2NmIzMzNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTVlMThkODMtNTMzZS00\nYjE4LWJjNjQtMTEyYWUyMWNkZmZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYHY07OqfKFyvK+oU94nE/a1agCULYqYdL+EtHnr8hq6RUdXu6D/7Cbru2WbOxWZM\njV+fxQ2zNGN0oEH9y0aV3qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWwvZUDCyYNVB4q/N\njzwjhvjqSWQwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgHxPNc3XJRySbNpGSME7KcDud9Mq0id1WP/59sR+92ToCIQDu\nkM3kdKD0o00HsKMr0JbcF17kHhOwbxzI5XCO6bcY+A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8440", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8440` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVh0pOJry5Ij+tXM3RJhnMHxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4MGFlZDRhLTZhZjItNGJjYS04NjU0LTlmNTc2MThlNzBiMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU1MmJmM2QtZjZj\nOS00NDYxLTgwZWItZjU0MWQ4YTQ0ZjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHSORvA9hjvQJXccPVutwLl4bUTXg5bKzRbQQvLjDmTg7OI8Ir+wLUTfgwp24\nOCqV/WOjhvNTxK0kQg2HW3fUaKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPUXm1YfguFLZVGYHYmIZWLrPxYPMB8GA1UdIwQY\nMBaAFEOqba/8X+NNkHEs9d9Agcg+Cz08MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiA5zFPeKzKlWxnL6U2x60TgQZHsb8Csknby\n2vYtS4HFjQIhAObUEyGa+MKVWj4W6TPTf/nUaQe55lT1lpyJMmopX0lU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ7RDqdjFw1JOAd2NSEtBoE/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODBhZWQ0YS02YWYyLTRiY2EtODY1NC05ZjU3NjE4ZTcwYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASFphOQcWjMl0dfECsXEV+uEb1R/WSwl9LbZPZGkrkF4OMI\nO9msi10IZFcZ/X2bHOY+w9J0CBD6dO+IIWIf9uhxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ6ptr/xf402QcSz130CByD4L\nPTwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOeWH+JuIVlpEf5IGG++4h1HH7MhHhTDrYWv7nDq0iyaAiEA37zHZBbs\nIdUZIWIn3TMaoCovJzCUqy2ghI3wqVPg83g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdvT4wQGmQHFGCxxBPjs1nLSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU1MmJmM2QtZjZjOS00NDYxLTgwZWItZjU0MWQ4YTQ0ZjE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2E0ZjA0YjgtZDBmZi00\nZjg5LThjNzgtOTIwYTg0MmQ4NmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4w+VMc29GRoOHMudFaTQjrSIdeCcbugq0NU4gs5UCzPREZR7YU0PlCGTujThiEtO\nqHi3WMzzZw0TuhbzyADvYqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9RebVh+C4UtlUZgd\niYhlYus/Fg8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgZCJW4SvnVkI+qR2zaqUISiYAh/cLsM543/QUsyZ8ZlgCIQDT\nTwtuNt7AsPfssCXX4IDtl25FWnUEPN6bf/HPriTsvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8441", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8441` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISASwnMKOaKScnj/vlvkZkqf7RMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNWYxNzcxLTcyZDItNGMxYy1hYzc3LWYyNDNhYTg5ZTE5ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIyOTY5ZjMtYjMz\nMi00MWUwLWI0MjktZDRhZDE1OTI3Yzg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnT3ffZ8oKlKuZoyUnECHFktEVPWVLqrQG0fqk9lU3HC+lyCoV1pt6OhMn/za\njWbLkuZaSCCLqvtO8hyfa3BI7qOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd19TtjUeWV0ya1KHliQQc0/QVgswHwYDVR0j\nBBgwFoAUELEcN/XHWjhUxAGWttx0pYCtwmgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgT9X0go7NuYi/\nKqr21zgIOM0DXiv082uK3qUkO7ztl/MCIH+lG76Wux032KGBvbtIOU5m2DHRRDm6\npg6AxrCojPos\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXDoY91RAc7GK3HGfHPQs03rMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTVmMTc3MS03MmQyLTRjMWMtYWM3Ny1mMjQzYWE4OWUxOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwFsSBwoHNx22oGQpUrAkv8LfOHXUUK+DFIDhzDRqmuEVB\nswnSvX0xZjVohnBIdGXU/Vc3L+2yO6DaINKIKwnAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUELEcN/XHWjhUxAGWttx0pYCt\nwmgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCo5yGPzXM0P3SfHbqJ0/I6uBll/FirwYxLZwUWfJYFkCIQD+m3mINjSb\n0WOfPerXNvorqSa8a7m+UGdyuu1bsGqlJQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZwH8Lf+rxQ/iNq3MUbLuTaAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIyOTY5ZjMtYjMzMi00MWUwLWI0MjktZDRhZDE1OTI3Yzg3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2Q1MzJkNTctNjAyNS00\nN2E2LWI1OTEtZTY4Y2FmOGQ0ZGY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFhntstZXjg2UIbvC6j5BERDcptYy1UlmSqGjE7B6iaHUIRMuqdm9WTM1m8ou/pc/\nb/FsrmNmuv2d46Bm5tX2iKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUd19TtjUeWV0ya1KH\nliQQc0/QVgswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgcUHgkIv6RPiQRm6r55revMpXRpkYzqYyn9ebew4nSi0CIBEM\nBvJQwo07XouhQT7Nsgpbvswebe5ebl0vxy/LRNXi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8442", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8442` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQsNyNiZ9VZNM8xOygtu+B9HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5ZDVhM2JkLTZjMzQtNDQ4NS1iZTVkLWMxMmU1YmZmOWNhODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDllZGQ2OGItZmEw\nYi00NTFiLWJhMWEtMGE4YmFlZGQ2Yjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYqHBgRwMG0rbi4lkL8wQoeVb/bAtiOuK/f/vQlKSivkFl4lHbY5fyPCqwGJH\nCh0UWgNwLDWYi1uwoHTEM628FaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDUVU12yQI/PBYC7rQQG5bDX64/wwHwYDVR0j\nBBgwFoAUMZHGhYHjEvc73pX0erCLxQRsyyswKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAM5JKG67uoJD\nZLeAjCeYd+O3SJs68roF4SEVEBomN3sfAiBLScDNcvWYNDGP/3mE9upOBXHyZYOA\n43CV9k/Sb1nUDw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZsyXZVlhTyeR1f9MzobT1J+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWQ1YTNiZC02YzM0LTQ0ODUtYmU1ZC1jMTJlNWJmZjljYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6SbmA5Cb615uIMSgZMeKaBJ2Ybel+/PQypwYazLZgaoJM\n8AiElPGvxM0bQHJKYz2pAQguo7M3bRveeygAtkRvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMZHGhYHjEvc73pX0erCLxQRs\nyyswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUZ6KOlyMClRAzxlEhzfFEzFJlUusd4lnI763XUknb1MCICCC7mVpejv5\n/+IWvFj4Dg+16c+G06vOOUCfsTT5tvfb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQI04EKVNFBYS3rqLufxL8OfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDllZGQ2OGItZmEwYi00NTFiLWJhMWEtMGE4YmFlZGQ2Yjg0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTliYzBkZjMtMTM5ZS00\nNTk2LTk3OTItYmYzMjZmODJiNzUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nk5ujkyAwZog0wC4XXZoueyreGu+/DtOxKAwWEsj//6pCgK64Xe4el8OJlwt9bQE5\nJYjlW6LtKi4vvBwUvqX1q6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDUVU12yQI/PBYC7r\nQQG5bDX64/wwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOv61crfrGZxkrHp1OEr6tmc7qJ08VvGXF+aiCLhj08QAiAD\n/RnCwPSid+MB9JlQvFGaRJwUhsP4hfi8xr+7xAL05g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8443", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8443` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAcgI5p5pJEJldqYxrtmZqL94MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhNTQ4YzhmLWRmY2YtNDMzZi05NzAwLTMxMjIzYjZmZmYzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTAyNzRkZmYtNDNm\nZS00N2Y0LTk4ZDctYjkwMWM3YjJjNWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjhzWbtLFDTnEIHcHVLPKkFuF7aHgI2599K1Hx5cUNDWV+fpdgprUVuoBB8wS\nTgbGCwI/eF65rCJGyIrEWyL9RqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOLriB8VV54GEa4yXOtzpK3KW2dkwHwYDVR0j\nBBgwFoAUWkMBvMJ5ix4pM0PsF6Q/K+MsLdwwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDJ474XLm4M9\nQArNRNKJ6a2Dv2npnih6U1EtChrUQ7vFAiEAyI7bJQQRCsvDEsBiGb0/8eSd0LKn\n/ap0Z9PK81Qsof4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ0xbmu6U4aVgqRqtd38NyMAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTU0OGM4Zi1kZmNmLTQzM2YtOTcwMC0zMTIyM2I2ZmZmM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgV6fzr9soMCL08oa0+dC8C8fj+6FvvQxOLT8dtssXBNUv\nZzAeJ6ZkvRdh+1E6Il5yd/e0mYrJOVa4DHYO5nh/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWkMBvMJ5ix4pM0PsF6Q/K+Ms\nLdwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKASflCNFgQbKcpxmiU2tQRa6e31QIkWHDHljxoJk+EMCIQCDiS9WKED7\nlDDdVBUedpXF4skAXvwj230eqpHam37nvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAZFYDbKKPPqW7rubzYypA2wKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTAyNzRkZmYtNDNmZS00N2Y0LTk4ZDctYjkwMWM3YjJjNWE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTdlNzUxNWItMzAzYy00\nYzJjLTljMGYtMmE0YzQzY2ViNjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5mX+JQBEKpdqqwrIsoiWDUP/IWatbQeVlRH9MIJqbJNyVyQAzkybiU2FeaBbcg0X\nxEgbBnVzsXLenYn7Bsv5M6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOLriB8VV54GEa4yX\nOtzpK3KW2dkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJKbQcweo50zL4Tr5XnLqMIGWCICYsNSDzM9POPWW3/YAiEA\nq4U5fq09L5dZApKxb6GDqh52rBf78MoxfFndjUqXHI0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8444", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8444` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaM3YNtH/K/pkg/Bnh0OapoeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGExY2E2OGZjLWJjOTEtNDQ3YS1hZGE4LTYxZDQwYmVmNmRkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk2NTdiYWQtNGNj\nNi00Mzg4LTgyNjYtYTBhMmU1MTYxMGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7MzBwtvhS9VB/7c9igaVl1HryVB4XZEu3hk/c1v+mBd8T0ZdM0C3uKxDBzBH\n09Bx4e4t53MwaaZFQWDv3jwl+qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8cumzvAaktNIIjT0STCVMWnqWr8wHwYDVR0j\nBBgwFoAUHWmoHbRr5lpPZwuuwOoot4sgIa0wNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCcMfO0Es1kqebgXFIj1PnPOugeYysYohck2qKx0q3oygIgR0D1OQZTgNPM\nPW3JYdxq0RQvZzLH6HKTC2ZNTRxtXiM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV69K+uZkRslnTv8yvqApMBTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMWNhNjhmYy1iYzkxLTQ0N2EtYWRhOC02MWQ0MGJlZjZkZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvjq21CgzarR0gTqeqBznfwWwRSf04MsQA3hIiQlDpcFRW\nw+/VIM2kTO5B9VEmjvvR88I/6JT+7BNn85aMCfe7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHWmoHbRr5lpPZwuuwOoot4sg\nIa0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcwQl49YTjfu1RU822UlHn/WZ5YtIWlYmfiSbUDc+MDsCIFP1Kb5lhitz\n2uQmv2KT6do/vM/NhFMwed3SeJmwXjE5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAQ6h/IdIo3ayjMk7AFZcXEULMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk2NTdiYWQtNGNjNi00Mzg4LTgyNjYtYTBhMmU1MTYxMGRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDIwOWMxMzUtN2RlZi00\nYWNjLWI2M2ItYjIyOWQyNGJlMzRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/U6PaGB7jB04fv4zAkTz77AsKZ1oMRoBCZann9uAi5JM131wFVY3Ho7SmopLRIlp\nJY2ylTGIzHWgpPRwgYSA56N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8cumzvAaktNIIjT0\nSTCVMWnqWr8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgbOr+bDhD+qPUxfcbAysiPqIDqD1mZsRp77Kw2kPQMkkCIDfg\nkylr7LVqVAPXuNdldouQXCNbaIQXsLhvCupTzc9t\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8445", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8445` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAafBRa5kV3NkTWSEluV4aRbQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkMWZkZWFlLWI5ZGQtNDAyNy1iNDYwLTJjMjNhZjcxYmFhZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk3MDBjMzktYjk4\nMC00YzRmLWJjMWItMjQzODRhODI4NDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhx+7k8Qi0su8713cYUHV9lcSex3aXNKES6ZKp3qvUioEbxQ7ZX8S456g8J7X\nhNUu4T/4jpHLdFrP5QYBXTB26qOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPZfG0WnK+P/zEiWFa4yPx+q8KvowHwYDVR0j\nBBgwFoAUM1aXsc08VQEuPNUmaZ9GqFmAzMIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDVtfD1Xtc2cCYzLtXA9N8yRFiGcpKdhNN6/uNKm3n2eAIhAMXGxLMu9yIK\n01Ljr/2APQaogltuvudTY9mb73s/nhds\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdRHbKZl1eTMUEty9D7TmSNzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDFmZGVhZS1iOWRkLTQwMjctYjQ2MC0yYzIzYWY3MWJhYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShFJZvZ5YvYzPhOMFM3KBP38raOf0RXJCj+yXw0G9wzKFd\nBU1Vnb3KuoIcnjsTpeShqJBk0AuGIZOpn4Kw0uCbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM1aXsc08VQEuPNUmaZ9GqFmA\nzMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJs/Z6tJAmIq01l8cM0n2/EbyzydZWV+jPOP6VzfUGSLAiEAnwIlTcy4\nGgMlc6r1SizH66lmaXBEp2zRM+iTYFLXR4Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAbT0TGcbEihTaIfH8Cik8C4WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk3MDBjMzktYjk4MC00YzRmLWJjMWItMjQzODRhODI4NDQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2JkNjk0NDAtZTUxNS00\nNTE4LWEzZWItMjY5Zjk2MWJlYWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOATnFiiM83xG5l8Qq0Nu0pkCH25SW2CjNhgfRx3/G8jkC3kLttUKUR70NuvXpeLo\nxBuxgGqOdZcjSvfQNR7sIKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPZfG0WnK+P/zEiWF\na4yPx+q8KvowHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAInV3GkMVVttF5nFSIu85OigdKoHf5tB2nIScN2i4wqxAiEA\n5H2aG+KYrq1lquRAq9tvfz1kRc/MaXfpd7DsiR861YU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8446", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8446` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAWjWZ0TfCb/gur9vzS7Y4bk7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZTVjMWE5LTAyYTYtNDg2Yi1iZWM5LTI3MmNiZjk3YWI4NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE0YmRkYWYtMWIw\nZS00YzFhLThiYjAtYWFkZDUyNDI3NGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtwyfyrHHitS9jtxb23BGtMFQa4WVLveFoF31uzSzi/S07TRWq+KWnQ8qVBKm\nlXZzgK5+fdnASIQ1Vp7/9InWLqOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6NhuCy1CU6QUllN8zhdDBCO9udkwHwYDVR0j\nBBgwFoAUyz31d6XoJ0fCF1VbtV3isx1e4gUwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCk\n9LA/YTAr2+QOSjarP5LPGCbcZUueTn9PPO8N9gon2AIhAMqtmQk2QH2yBFwa9oaT\nCqZ18nkX1D4ARcVJC6rrIV1O\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR7fh8vDKEAJfL+MUEqoaZl+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGU1YzFhOS0wMmE2LTQ4NmItYmVjOS0yNzJjYmY5N2FiODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATz8m4/ituDxUVckraVKLpdqS6HaYDugXLChjyxNoTX2Soa\nzJRwwKSgHkNZCaM3zLx8KVs9sjgbwe3NCAvjFjeko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyz31d6XoJ0fCF1VbtV3isx1e\n4gUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfbF0HrBfR73BdEclpt5FXyVZznEwPn0R/F/XaOvPLTkCIAfSoVbjRhKq\n/MFKptNELxz+0xMOz8tH2DGSwkLJN0hD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAXuvL0JGNcxuSFevYZMED0W4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE0YmRkYWYtMWIwZS00YzFhLThiYjAtYWFkZDUyNDI3NGM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWVjODAxNGUtNTRhZi00\nYzNmLWI0MzctNmU2YzkxYmQ0M2JmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nn8ZOUTIhmxWuOl0ydtl81vgbW/AWDdXKjA0UwvQ18apWilYNB+lQwjiRkcCBitE1\np3egAU2LpwdnjNZLmBj5OqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6NhuCy1CU6QUllN8\nzhdDBCO9udkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMeuRmYJK7/L7qGIXP7xxbvDyZ0ByWVYbjwCF3cIDMMHAiBy\nG+2mnQUBz/WMN70DdRUbHfb7g7UD3UF9+NWJWshn0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8447", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8447` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAQ1JDbjeW6kjKFK7dqlNNgc9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjM2Y0ZmM3LWRlMjQtNDg5YS1iNmMyLTcxZTQ5ODg5ZTk5MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI5Nzg1OTMtOWNk\nMC00ZjcxLThiYTItZDdiMDBlYzc3ZDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETQ6w4XNvVSNuXp1ddRzPEx/f2/kY75ncaFyq/iCudXkfKAtoIoxz+Mtf7Y1i\nemTTOvlt0GZrtJpQ5voatmoZtaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULDNuQobs2DY3ck32KIJcIAJ07A8wHwYDVR0j\nBBgwFoAUnJFRf0U6ijSTav2kCdn2Ouezfx8wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIH7m/Ll/5Tp6qmnEFMlezROymxA1zMnhJRHI4mWKnGDlAiA10hq4\n0ES2o1WVCYer1Fee1OQe/wIq5Xx1MiXP4Q8m/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATx4M85mHvuD732yaB63Ge9LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzNmNGZjNy1kZTI0LTQ4OWEtYjZjMi03MWU0OTg4OWU5OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgFvA/Xmz4svT5T3kiM5U7+OAdgUCXe7pxO/C92ND0UzJ6\nA9R/lGV2x9xVbfih71KnwnvGGfREyoXw2I3qBH+Mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnJFRf0U6ijSTav2kCdn2Ouez\nfx8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIAn8ZhUiJpxXL0e7pvvjEeQZMqTWQHXlDHYtjkM3KWcCIQCuDotbM37b\nEX56SPsFnKQC+P1uPYpQlyNan674+9y9bg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAbgbHItv7J40lxPLLLHJ4EHCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI5Nzg1OTMtOWNkMC00ZjcxLThiYTItZDdiMDBlYzc3ZDZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmJkN2I1NjQtN2FkOS00\nNDE3LWE5ZDYtMGE0ZjJmMjIzM2E0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nm2DPIKL/KFWUOYDbdvWv2TjGx40bCOpXtrwSIlnQhatf81+QrjplCeuhOySwNprr\n41c3xNaXc2EQaiMkkFpEV6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULDNuQobs2DY3ck32\nKIJcIAJ07A8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgcurn6fv2w/IAFN7g4UdlforNL7x/dDPwBqNtqIwh20cCIE/g\ncxYtPI2I9eeBzBnHPYV/DaHEjjdquZjy7un44QcO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8448", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8448` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAXjKHUUYjeneZoM0f+SU1TM+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNTMwM2JhLWQ1OTMtNDZjNC1iZjJhLTE4NTFhMzVhMDFmMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjg3ZmIxMzktMjY1\nZS00NzM2LWI3ZTUtZjI0NTNkM2ZhMDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8mJZSUUOFIysFqYjnp+QYbh8In8CPPdOLC5yM9Q6BH1s6telQbwJ+/FIdGVE\nXDr/FhnLN5wuSa3dtvFF8IJnDqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAxzb2dib4hSwaxlSI18ON9HnYHIwHwYDVR0j\nBBgwFoAU1lvic7jS8V5d9fsJlC1IvntIzqowOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIFfgpdgjj1C9Fjj9GeYtWHRZVVFGVrmrQsnjH5jmygyNAiEA7rkT\nBp4iEpGSaAOVpXZlsMvm/19HNPkjb77VXKCzQhY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQyfU8skZOKltjxIVIUGUXYDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTUzMDNiYS1kNTkzLTQ2YzQtYmYyYS0xODUxYTM1YTAxZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6wL8Zk/UiqJJ+ptaIn2VCFH15a8r3J9svqbOWiQhURlrY\nPzgqyDC0guvXIFLvTkxVkhrmyXkm4f2Z8y8AvCORo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1lvic7jS8V5d9fsJlC1IvntI\nzqowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUq04vIwBZv6n6qIa+ZiGzX0qhXOqk2GZAXTiwq5kkbgCIQC0eqnbwdSM\nFcS1KbBbdESiEH/oRCFEb78g3r7CVQgUzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZUx/RaCLPoGe3f8Fd+mX44yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjg3ZmIxMzktMjY1ZS00NzM2LWI3ZTUtZjI0NTNkM2ZhMDIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTczOTFjNmUtYWYwMi00\nZThiLWJkZWItMDYwNzVmZWM2ZThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvjuOrDVB+b+t1FjGZy3lxmH/DOc8iJUJlZ68L9b+3F+S8nWisUK+recN2LB6/wna\nUbJ5GwEgHPGlp7oHGDrGyqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAxzb2dib4hSwaxlS\nI18ON9HnYHIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgAmP3uIXi70GbpsCNnAw7bDHOnhwXeRa7Wg6foGmCz9kCIHQ+\nOJpb7cIOLER6X24Ob3UE0BHV0+I/uda+L5S14S9o\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8449", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8449` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZo9vAPt7TViejVz7TIe8uVtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZmJjOWNjLWRmNTQtNDI1Zi05ZDBiLTdmZDQ2OGZmNzFjNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZiNWEzYzgtMzU2\nZC00YTYwLWJiNTgtODc5NTQ4YTEzNjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvU/NMc1xeTj9DmT9IjEFMeKFRUWHt4M/qjz4V2+nRy6K+iwvUpNZpwaprpIr\nkRmCMTSNCeY0tGgMGbRvVNYtRKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFD7VDKIBc3mqMkT5s/juSC/1KnFmMB8GA1UdIwQY\nMBaAFLyCq+Rgwpz5YEDgluiawNT5CvVRMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAjdv6C6HlEIOwBvnoxYrOxfmo8fdiQuc3A\nutKKdnEMwAIgLQ1nP6io5/l/5RFDgMg94diTspEmyNqSQ4E7InSF40M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATAEgrTAjC4Oq/ojXarnYdRoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGZiYzljYy1kZjU0LTQyNWYtOWQwYi03ZmQ0NjhmZjcxYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8gBGsVRX/roqTI+34JGzOfLb2ZynNe+5Dg730hW05o09E\ntTRdQ7+IQaElLrxxvCezAUSn6JAq7i2nP1kY9kepo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvIKr5GDCnPlgQOCW6JrA1PkK\n9VEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFoTPKJu4Pq0/hIQ7cplNP3DtXsdZUltcg8dcVqWbjyMCIBJ0KlFodE68\nW6FhUQtGmfz8gxWmmlaDJJ4VZWzSI/0T\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQTli0CVhrASkCw4HTEalhIkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZiNWEzYzgtMzU2ZC00YTYwLWJiNTgtODc5NTQ4YTEzNjExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTRiM2I4NjQtZDQ3ZC00\nMDE5LWI1NjctODQzYzMzMzZlN2VlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+BM+Y6fDvaNA5+q+TMvbEBwwmmEB8t/9DmaaUbeMtELe2vZWW1RCxx1NDR+Io+1q\nPvAyz2Q3XVZzgM7TQNgLKaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPtUMogFzeaoyRPmz\n+O5IL/UqcWYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgPnXAzAohDOYZZGq4YSsR3M0F4W+VNRS9LCEaIESgYhYCIQCK\nYbhUCjYuW6qEht1UkdkDSpk4jDvSMJ3hu3czCwG9Pw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8450", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8450` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAbUQ3DRGGEHz20cpaoiy2I5vMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyYWFmMGYxLTZiMTEtNDI0NC1hNmI3LTM5Njc5ZDBlM2EwMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVhZDk3NTEtNzli\nZi00ZDc0LTg0NDgtMjViMzA0OGNlNTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Ebrb7VlbliVZfxCL7Qr05A6MFQXbkGMwcPxjXWdgoEvtSN8WbqXnFzRm0P2\nPjkoKYrULvky/iK3oJlOB9mXHKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWUARZvqOVKluVY4DPxHddGfZnSgwHwYDVR0j\nBBgwFoAUz28JNzR536JBJpHIFRryEURj5QEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIrRFuTm7Cqv\nmCa7amRgXlpmdnfxiCorV1G9s49+QcP3AiEAqT5zeWFBDvL8aqm76+amhXS/NClI\nt/iTvQe0hd6fRkE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdqRbO5fVPoPeSHjKSsJmKF/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMmFhZjBmMS02YjExLTQyNDQtYTZiNy0zOTY3OWQwZTNhMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEDZ0avsdTPxO1QBxZUASK8ep3W4OEn1UVxnZTkncPHFAj\nTsKMlHijW/md8C9sp5UkAdf2DEyAiytewRADMa0co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz28JNzR536JBJpHIFRryEURj\n5QEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKLVxCNhHReJg4U/diYLiymDY6KS3FEdnnbxFfyS88alAiEAvO8H3uPv\nU7MHWgxx407pS2JXFKD17QQhmYhsSnm7fR0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAQQW4gQ9DpOhLcZyr+5Kd+WKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVhZDk3NTEtNzliZi00ZDc0LTg0NDgtMjViMzA0OGNlNTU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzI0Mzk3N2ItOTVlMS00\nNGZkLTgyNjctMjM3OGU4ZDY2OTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3ko8nRfQ8jZqv96OiEIlPhVcpMZGKxjL8H/xqhHaOsQFRABFas6xM0HuJgjDZn+K\nJ425rkLeFPJufz8Y5kbSSaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWUARZvqOVKluVY4D\nPxHddGfZnSgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAKeItAu2zu40I3xXVG4AbIcKUwr/eJH+P4BtcaY5CNRmAiBJ\nZrKWOUUsIdqCybomE6bwpJfrPUlIQf3eTS1mi7zWyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8451", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8451` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAUMQf5MD2TQ6blf6NjuiKnmaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViNTE1ZmNiLThiMjEtNGEyMC04NWZlLTAzOGE0NWMxYTk3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBlYTRmMjktM2Jh\nOS00NjMxLWI0NTQtYjNkNDRmMWJhZTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqK5sqS+hIq7filCA8yxqgEpF3svWUc7URUKUfP3WLkBl1IgJzYpjh6KlvGB9\nKbTykQWQZZvPZx9CIZ25hNv/aaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUthwvupPGN+M++urD37bG/v9PPg0wHwYDVR0j\nBBgwFoAULt4oKU3uOcFp7citMrhb/OXAUT8wKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgewbIIgS5BUIT\nx4kdA85za/Ww0Pv3ozTWEBEj8MdMFWUCIEv7yAGGXYq4PVLPBpRkZAydZcv15YeJ\nImYFLKu1rIUF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcxrc84Oay7Cjn5q7rQjXNnVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjUxNWZjYi04YjIxLTRhMjAtODVmZS0wMzhhNDVjMWE5NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHOYof6TxZ2BDi26WE5xYSG8LIYM6dMUyXLizrxFYFNA8u\n6U7K74MTxlNusB16nibRJFpcrgIH7dDifiKQIAJKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULt4oKU3uOcFp7citMrhb/OXA\nUT8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIQc5yDYOLRQdjZrnd2na1d+f9GRt7Ua2oWV+SkEpvAnAiEApQ5qIgNP\n09iLtNT2NwyANKquT1yokkuyPT0uXAFJJrw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAaDrvEOpnukeLxVI8q8y3vA7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBlYTRmMjktM2JhOS00NjMxLWI0NTQtYjNkNDRmMWJhZTg3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzdlMTEwMzgtNzgxZi00\nMjVhLTk5OWMtZmI4MGNkMGU3Yzk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncQIDns8zSK/TkfbL8O8FAUJx0pUtlTBMsLf8lwVw3O2z2tqEnFXr6WAaZIUev9fk\nLnvrnNIgvdMhlu7Z1fFxDaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUthwvupPGN+M++urD\n37bG/v9PPg0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgWUExfR/cPdqMqG0aeaFDwpffWeJk44lyl+IMdrtu+cACIQCi\n1TIkma/UIRayeMqd3Gxr07OrZaE3uD5Pxf7C/Xzxpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8452", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8452` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATClaS2Rh9khY2kw20E5yxlaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5OWI4OTdlLTRhNDEtNGEwZC1iZDI1LTBiOGM4MGI2MzA4NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjAzN2FjNzQtMjZi\nMi00OGVjLWE1MWMtOTVlOGQyYzI4NTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBb1jCABj5LPrP7hz3Wtp3aGYGvNnOLLKUkXs+DRbgSAJcBedwdTSX9vZogAb\n2dNTDz1RIQGtBWUIjnzYuUVgh6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXAASTk89i6pIRcbEJv3vyB3q6DgwHwYDVR0j\nBBgwFoAUYvamXsjBVZa1QtWvekeseg4hlmQwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD+o2rx/7ug\nPGwX2ZBH/XyHzcNUMOSIWqqOisGYQUS4iQIhAItG0Zv2X4V49D73ucK17iKJYlkq\njGACDj2J8+IWfeqC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYYtkk0lREBImmil19FQefh2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOTliODk3ZS00YTQxLTRhMGQtYmQyNS0wYjhjODBiNjMwODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4TbMKz1htzpyHR+oOEoFCWQ1aXe82qbWJjQxj54Q6SS+8\nstky8oYeY4VH7Q1VzR62EmvQ+l9I9R+RxJkMEUrEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYvamXsjBVZa1QtWvekeseg4h\nlmQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdlf2St1Tzi7d48mHM8n1kT0irareMFX0lc6TWEqsK+ECICw/dc+eiqld\nno5xPefAT0IGDVQ8hZimRW1j7PwtWefK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISATW8TSnp8tX0MbkIO/vA4ufKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjAzN2FjNzQtMjZiMi00OGVjLWE1MWMtOTVlOGQyYzI4NTAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzM5YmVlZDItZGFiOC00\nODU0LTg3MTMtZTRhNzQyMjNhOTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndXeC7rRGKhzBLyEeygBXAJt8PFmFTsYqM+x0rwh0xwJIXBeq/fLHPeXyB42bbZ9C\noXkpe/j+TCfLh7ZpIbTGtaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXAASTk89i6pIRcbE\nJv3vyB3q6DgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgE06p+9oQ/sxownPFg40FGKU9OKAOyfHqN1pB9JUBsswCIBO4\na/Bb6arEm2Idmya7mE7Fj8u/cFEXlYz8yR6A3jsi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8453", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8453` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAai51s4NwLr+sDXLSiB9CoJZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNTIwMWM3LTBjNTctNGFmNS05NjIyLWI4NzVhNGVlNDk1NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M3ODBjYTgtZTA5\nYS00ODNkLTg4NDAtNzQzMjMyNWExZjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELvpfm5TLKTRO1DttXR71QCzBDqsf1+uTHn8XN0KUA1wlRwa0Q+ZHG/oz7/+I\nIRBosNbXufD1zGNqJQ/NIskPeaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU60XbrtVvKNDwBjLRQfndnKYe3DwwHwYDVR0j\nBBgwFoAUSewUTK6yY80TzMLGA5qVVMcDnz0wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIAh5jcSPa3xV4iBBgNUEdFbErkU3o9Da33gbnnBJGRV/AiBkpRNKI+FYWnfH\nC5DKQkKKR09XWPZsfThOuDhT4OSD1g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXq26lPQM5VvGbdQk2GBSzzdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTUyMDFjNy0wYzU3LTRhZjUtOTYyMi1iODc1YTRlZTQ5NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4VijIDAxJKXDY+dj4qvAs6kM6DbHzrwH0EkbymIeP4ziu\nGIiH6OkTr+9Ni0tvmZt/4WVrvHjlBFCJC6NePBHlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSewUTK6yY80TzMLGA5qVVMcD\nnz0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIkcw1SNND83VcGKqKwGp5MSf+Z4dKmsNK6XRPr1EImmAiEAt8UyikGY\nlMcqs+AJ+hs2AfyNw1f6BI6bllll0TFkPkw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAQ/eRJpNBYIfWb71cTnMcu/IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M3ODBjYTgtZTA5YS00ODNkLTg4NDAtNzQzMjMyNWExZjI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDBkMGEwOWYtNDBkYy00\nOWI0LWI1NTQtMDNjNzU3YzBlN2YzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRSace/sq0oyj5sz8AJxenQsnlf9C2e+QWh2l+INTz5INytB9ULHdU7pSvs6WuNel\n8v/xx7sx/NTZFJILNQ9aiqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU60XbrtVvKNDwBjLR\nQfndnKYe3DwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgb9BEE4E5sXFrS15ZWf8J5Ata9XO740JPxTvLikAVsY0CIH/t\nyPn+0j5s2RNM/pQYGH4Iol8rYnBibp49KfIYIjfn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8454", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8454` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAcf95xudt6iYQcupnabA2ZesMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2ZDI5MjQ3LWM5MzYtNGFkMy04N2RmLTdlNDI4MjBjYmU5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk3NzRlOGYtNGY2\nZS00NjRmLTlhNmYtNzJmZDg2OTE4MWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZYHInoOO2PlfIjWL1IxQZrYHvzKK45+m2numFKaAsGEY803i8QAHfOmWaAE7\nBeZRwHeFZq4kwD2yLNJrrQdK/6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVL/hW6t45yAcJNd5/Qxa2KaRl2UwHwYDVR0j\nBBgwFoAU1KdjqwqZTMW2RHVdSkiFa8Ro2o4wNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDTCK/GTYFuWEOOzYbI2AtVcwVAtcBvdQ8OCAyxQ4JMjwIhAK+nij4yBaCo\njNGAmjXObbIMpZvBJPBZ+0Ci32ofyYL+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYjZOCoBIBapTYK5of0whPP7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNmQyOTI0Ny1jOTM2LTRhZDMtODdkZi03ZTQyODIwY2JlOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqbDyU254Yhy7gg7Etm+u++jeJmvMOYo0GiYpinZGXw+w1\ngG6ze4TUJy0I/S9HH2zZYu9xmZAaeJPBRLtcsb6uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1KdjqwqZTMW2RHVdSkiFa8Ro\n2o4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKxNQDubD+IF46nQGH2fvNXTNxp6n3Y1x9LhdJYmW8meAiEA1ihpHldp\nC0ucy5AipwPvQam7IYvdOLDV2Hq4bBOr5d4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAZBLI11+BFndr3dAtUHlHeKEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk3NzRlOGYtNGY2ZS00NjRmLTlhNmYtNzJmZDg2OTE4MWZkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmU1NDBjNzYtZjhjZS00\nMzUzLWE0MTMtZTMyN2UzNjE5OWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVTExDfeK0VMA+IgWcbYU2WFmADpSmJzewotK/MYmJ3+zCQmDPonyS9v6SKk3HfsP\nAQx/ywtNWNPrsBmB744YX6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVL/hW6t45yAcJNd5\n/Qxa2KaRl2UwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgdUHs+0N8+w05tHgMTxLJumN+5ClUzt24AdU+rIUGpjMCIAGp\n26CogigxDd8a6eK5fqB8YQG6Aj0gE87CoMNjPJwE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8455", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8455` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAYz7ql8WyadnXqiraVpzeDdnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZGUwYTEzLWM4YWYtNGM5MC05OWRmLTdhOTM4Y2FjMTE2NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmViM2RiZTctMzQ2\nZC00NWRkLTlkNGEtMzU1MjQ2MDAxYTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMCXkZoYFJLb5Ewd8MqmvEjJ54DwC8fsZGCLQlIw9y3F27bTzErPaVDgf4ecn\nIhXE9rluuc8N7JDhc/ucyFmfg6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs8S/A2bKx9krxtzxKN0mnlH26X0wHwYDVR0j\nBBgwFoAUGot7F2+PfsLWKQCaBarVFVHZe7swLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIC5f\npMxxi2N90odEOKrKKIqAS60aXrONdn1XmLJwEY5NAiBRtrYQ3mhL/TxtR/9a/9xX\nhz1XixyoyQaiQErvJ5iLWQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb9sun/os8WirAFl25xf9VdVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWRlMGExMy1jOGFmLTRjOTAtOTlkZi03YTkzOGNhYzExNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdAJK8Pozf9BECV9XvFvylGux8HWB6XoPhwf8psBDL2eHt\nRB09fQ3O1CyFhbT9wn1mP5Fx5g3qMLkYIkwRhXGro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGot7F2+PfsLWKQCaBarVFVHZ\ne7swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ6W/7uCZhVwVc9gBaYzMeHkBf+/vrFNObai4M+YQq3cCIEM3BBiyVx+n\n38Vepxwbu1Vzrj6FqgafKOGSkCxCjo6q\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAfRz5Y4h9Wo3iZZK3N4AasdEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmViM2RiZTctMzQ2ZC00NWRkLTlkNGEtMzU1MjQ2MDAxYTI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWJhNjZiMmMtNDAzNC00\nNzJmLWI3N2UtYjljODRiMDdlZTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbQ8qY0c8ThFRmhzg3AcYzSZ1rLAyNIvU82ae7tsqg/VddGVVLcS60dHdJ+5oUeQc\ncwB9uVLcw/aMMKox13BMLqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs8S/A2bKx9krxtzx\nKN0mnlH26X0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgQPjEYXhHen85na+2DKKOF7nPZ4sk8WxO+Et94oEdYCkCIHan\ntL+FXFb5EezQBrt9cBq8hsNz5nbVZgNfF0zDv+DT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8456", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8456` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAfo0mRkJRI1/YEeM7HeQJF0iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmMjQ5Nzk5LThiM2UtNDdkNS1hZDFiLTJlMjJjZThjMzcwMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWFiN2Y5MmMtZWM2\nYS00YWYyLTk1M2MtNzFkNGY3ZDlmZDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpL9ls8UX58z9C/jeuTIxiW6EHhU39cEUngtYP8u8YegHz9Q7ezmkJ0HF1/vk\nRCAqo2HfNMILkJ3Avi3YW8y/Q6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8RUyTBjCpFENePgGDV+0vHUhyaUwHwYDVR0j\nBBgwFoAUA0pUTo5OPkjhJx/oN6xWbVWza2AwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIGESjiNEDW12D8FfsXaelqEBYHJ0nCLA+7VvGCNLYjFDAiA68WbE\nIMjgbGYywE9Is/VjTGt738uMN0qhYdnwMyJ4WQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVTymRXYmmv+iySDjUlmlu5pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjI0OTc5OS04YjNlLTQ3ZDUtYWQxYi0yZTIyY2U4YzM3MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT04R6pTYYFjMQAVq1wlvD9WTprc5gcp7MRh469/lxGTGsz\nhI/Knsl1hJfWPG9WTXet2SYO+huTrjE6wr6QA+rdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA0pUTo5OPkjhJx/oN6xWbVWz\na2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBuPTt1dE5bW/GpmphPsOKCYlG+Inrb1UFVRWVa+klrECIGmWYRRaDMZI\n7NJ8OdPL7eAzMdkUg/4wVrJlJKAaEiuA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARxcxnh3p25ucjfCnCZBL7NzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWFiN2Y5MmMtZWM2YS00YWYyLTk1M2MtNzFkNGY3ZDlmZDY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTZhZDM5NjctMTk3Yy00\nZDg3LTgzNmMtMjAwNDFlMzZhMmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrlIpHBt84S3FzJouqhvja3szdM6JlmbI0sNd0a43gOEPnQjhRYzrsLfmOCcHM3eJ\n/iZx3HGVULHSuXukahnDoaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8RUyTBjCpFENePgG\nDV+0vHUhyaUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMQKC85L3IvwkHQqvL0ag2BsXfcjiGFRreZUAkitUSukAiBa\nHH6amkwOqxtdCmiaoI7y59LN7vZ473rl4kF+jz866w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8457", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8457` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAYk7wZZ18IW+lBsR8ETjupk4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzMDAyOTU4LTEzZjAtNDVlNS05N2FmLTkyNTRkZmI5OWQwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmNhNzJlNzYtZTM1\nNy00ZDQ1LThiMGUtZTcxMzgyNGZhMTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFDlhuZpUptkUDqF4h8v216G0x+s70tzgG18MK97PpRWY+JAVm/OOHPLrzTbh\nCYEx0I3IbpoTfbZLcOoa6z+pkKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiJbFoE0/gnhAs0zLJpZoALsxA4wwHwYDVR0j\nBBgwFoAUqBxS+RpG6mAiijNudsryfX1saOMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIEhZpEXzW+Crujnu9auPebapneHPwQgjOlhob4SJPt+UAiAMsCY7\neLV3r9oiDfNSgxAyHitQXHBZPfsjkBKHdqVYyQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR7SPmZe9ethODE8e0sXwCi6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzAwMjk1OC0xM2YwLTQ1ZTUtOTdhZi05MjU0ZGZiOTlkMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd6R9oXIJCgCvbSLbXSkWna0XuqrCyMz+OKPo5eXighgXG\nsY/A+jie6+JdZUFYuWniDVANCW3233NCIX9XqusXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqBxS+RpG6mAiijNudsryfX1s\naOMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEgz5S5KcNQL9NFzNEvl1+vIT/zMKc7zktuaK7qFh6isCIQCMR4BHAwrw\nLtdxUzR8IdoldE5WCAhnvBETGh8RLNUGJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAYWO0K81vfEA7kfmZNZWzQu6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmNhNzJlNzYtZTM1Ny00ZDQ1LThiMGUtZTcxMzgyNGZhMTE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjUwOTNjNjAtNTc2MC00\nNGVjLTk1NmQtOWJhZDExZTZiZDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhhHSiH5o9IzH7siWtdDnb62Jw0cLo8osTvq0NZfGP9huU3yqCTRcvCh19DnaP2OM\nd3AoNgn0BN4WXYlgQeQJx6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUiJbFoE0/gnhAs0zL\nJpZoALsxA4wwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJG2dsFB7ln85jQRF0RAn3JxOEs7YY67a1EzyF0+819/AiEA\ng9CmWzcWp+Jkb+bPptaZDhaasB6xP3OZnExBOOpHYqQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8458", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8458` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAenx0nf21IpY1h/nsog+sejQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczNDIwNDg5LTFlNDMtNDA2MC1hNzBjLWI5MWU5OTJhMzQ4MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTk0ZjMzMGItNDk4\nOS00ODg0LTg5ZjAtYzBiNGZhMzRjMjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1VCCNbS2u3sy+wMV1Xb9/PuabLlhhcmlmXjBcTgCz5i8LDWMfeXNRF8RuPIR\nMUTGwFemFx9O8nlev8lgffDvYaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTVfoTCFlMUpRbxLXGcttpC1XHcJjAfBgNVHSME\nGDAWgBQDHj2j2F3Ir2cOUhzd94YJGWHv6DAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDCb7Stb8oKQ36A/RepXgWGRva0+SZp\n5s+VlBWMeuAEyAIgasXb5ZE60yNBl/lltvVNjxgZh4lB6I5gZqFCcBbGiIY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWKLntI7TYg6FzCHlzqyuE8wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzQyMDQ4OS0xZTQzLTQwNjAtYTcwYy1iOTFlOTkyYTM0ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLdV3s6XFqXp9lzyFM0nrQMexie7VeOe0ZURPmX9WJCklw\n0eJFJpFz5+rLXzMFNY7yGcbLXEVxiju9ImXlxJvbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAx49o9hdyK9nDlIc3feGCRlh\n7+gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAM9g4zaeYAulz18wf0871bU0EoKPIAmWE4Q4/Dlc7TWpAiEAjhnc+3Dp\nDnFG7KqJ5jwzJkZv3p4BkQRWtqpYiOV3nqQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAa4LgtHRzpHnT/uy3aazR0CYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTk0ZjMzMGItNDk4OS00ODg0LTg5ZjAtYzBiNGZhMzRjMjVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjJmNjYwZDMtNDZiYy00\nZjZkLTk4MzAtMzc4YzcwMGZmNjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6SO+QkOi31xgQCgiY/BReHivaxgBgiKl3nvaMAgzvsttFeflKdkkik5GSx15Xi/3\nmS5G1tKLz0LEGKm+35bLO6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1X6EwhZTFKUW8S1x\nnLbaQtVx3CYwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAPUYHAOa32FzVxoklzxiZDi1T7/G8Ppy287xvTP6DfSWAiAe\n9XZbljbImdE9UbVh1lNVixhZ4HidGStb+gj0whlzhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8459", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8459` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISASOJKKcNOX5taRdeIBlza9NtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhZjg0MjZjLTZjZTYtNGVhYy1iMWE0LTA4NDZmODMzZjhiMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVkZGZjMWYtM2Ji\nNi00ZjJjLWE3YWUtNDY1ZmM1NDA3MzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPcDYHr5ZHsk4tSC2GMnJt5qrxRwlia8PZBEwzGmHqUmOzeJzVAAaEf+NDIfC\n7coGQTeSz2gBTgGa4AFuP11zg6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU64QCZZrYgGztsi0pDKeACN5W6BUwHwYDVR0j\nBBgwFoAUAjsCPh/1P9rl5PQAyRkE15Xg4JAwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD+A6pxiI5u\nJ82N0ZIGkR7G5hMKYWa1lMVMIBfWcCX54QIgfGqKLHaBCv21cGAKoq2usoZwAjzg\njjUU8wrJRjn+Uvk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcXJ5Ukb/SsHvRLR7NnSD3e7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWY4NDI2Yy02Y2U2LTRlYWMtYjFhNC0wODQ2ZjgzM2Y4YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5W5J6MHoXDcZlyoS03qST8PrBHm6gxnePUY5ceOgIX3yD\ngZMwtbgBR8YwtdIhrPYI67fxuwZaOn2AeWaKYHWKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAjsCPh/1P9rl5PQAyRkE15Xg\n4JAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZYqrXLtcdT61oZLdS6+5QYVUf2vAAVlTDMwI9HOMRg8CIHkK9nQlgIxV\n6cNtIg0G8FnPoLtKTX209/kYqPTaIOSB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAcSqgqhoqc8G334bVySK5WG+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVkZGZjMWYtM2JiNi00ZjJjLWE3YWUtNDY1ZmM1NDA3MzVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGM5YjdiODctNzk1Yy00\nZDM4LWE4MzgtNGY0ZjRkZWJkYWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nw0T2x8NibVmMgEPhKUnFq3KNOEEhoaJeOhvzsJDCmwGh1Yg2mUWbkNS3itsmAgJe\nOINsthA2r6S2tCI5coIKa6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU64QCZZrYgGztsi0p\nDKeACN5W6BUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAJ6vkN5vWxGoGkzLWlE7pXF6Vzah5tTdTBS/0mqFz3s0AiEA\njyL6bj3cUKINvjJdBcQWBtgAOL/mOBdwVCd57yr5mkQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8460", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8460` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAZqGhsRhWQ9w9kBb+nXw2rO9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxOWViZDhkLTU0M2UtNDNjYS05ZTg0LTE2ZmVjYTU4ODI1MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjYxOTVkYzYtYTRl\nYy00NGI5LTg0N2YtZDhkZDliYzM4MjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWQOLDPkwxk9JLHnErGSBsjClKHcxsuuLYfluy3C79OQS7EqBeINDHWnlXz2u\ncd+1+hWrTB45INbRpigWsTQEmaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzKZOkyWrDI0si52ulhMnLtMtlMUwHwYDVR0j\nBBgwFoAU638PwywAM2xH0PCcA911EPHXLmwwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIA6Lkrk781Ow\nPMuQZsVl4gdw059qcJ565bCxfFAt/8zCAiEAiVIyLCoz2goXPHAKzSJu2P/coCTD\ntpuwWO7fejk3DbY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT+pzZn60UfR5I4sijD2aXYoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTllYmQ4ZC01NDNlLTQzY2EtOWU4NC0xNmZlY2E1ODgyNTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKc5JQSVo8qaZkBs1WUpICmfwrLitf+O4cCoTH3Xp2S2KX\n6GRe+Ydpm195xwks/3mx0XejXA59l/v0eDSAECOto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU638PwywAM2xH0PCcA911EPHX\nLmwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKL8H+nOUExMDK7jFfUvXrnqGvWMlA8q9fb1CDtJPwm8CICOgqoVpIAZ9\n0953SXnwwK4douMWmmikO+iGTKtzOZ71\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAbIdxcClKj723pnY/ucT3i6+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjYxOTVkYzYtYTRlYy00NGI5LTg0N2YtZDhkZDliYzM4MjMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTUzMWYxMjgtOTBkOC00\nMTgxLWE1YzUtYWEwZDg4ZDQ4MWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndNCqOF84248mPrgMd1tYGhI/Dv6X9uGpjGqdKf9hHVO/afXk5TxTS6LFpbqtmpfn\nJ3eq0UYQVQ9tRj+e566HVaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzKZOkyWrDI0si52u\nlhMnLtMtlMUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMwCG4uCkPVBRPE5jvM/TmW82LintBakI8R6wSWl2FvsAiBY\ncHPdH1EDvU7/bt7FDhxt/m+Noy76ABbSaCarhWRvPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8461", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8461` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAXtlf+HYp2vyzZAXXtCO6UPfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNTlhYjNkLWIyYTUtNGI3MS1iNGNiLTZjYzFkMjU3YmJmZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM2MWEyMjctM2Jh\nOS00YTVkLTgzZGEtYjk2MDBiZGUwYjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpTJaKCBxgX4lkpOKH9le9n3msMxknMeZK14QqY2HpkAvhflH/Vmj2EVT4wdf\ng/X0uvRgdX50nvSeSoYMA2XfJqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCPrp03FWprwihRgzsMQWsDzevmIwHwYDVR0j\nBBgwFoAU43rECg/rBUv3VEOt22tbuoh9m8AwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiB4zbsBzEih\neQl5jrr0k5+RKuz34Vawx8TmBRtke+ALcQIgaJAF4grw85htSBPFYGk8ghoQU1DL\nsIRSAr+tLjTm5rg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYgYwXRych0Ebq/oAHmeqALEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTU5YWIzZC1iMmE1LTRiNzEtYjRjYi02Y2MxZDI1N2JiZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwSFazKokHoHp2x7DbDiJf//heHJQ6xb26jFKaxxhaxVPG\npdnu+gQMox6RZ6dFrzGBcVEEtgw7G+6o8uX08ZBjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU43rECg/rBUv3VEOt22tbuoh9\nm8AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALruyhL1DQ7YADfD9eoNb6ouLnpHxyURhMlLIgk2mPdcAiBTmbO5BuFs\n6ZoKsNVGBcHbxuPeeecNjUy11DkylfCRfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZ9mFyTRWQQJB1xo073MyDIUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM2MWEyMjctM2JhOS00YTVkLTgzZGEtYjk2MDBiZGUwYjJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmUzNWViYTYtNzYyOC00\nOTRkLWFlZWUtZTNmZTc5ZGZkMDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHjKIGcY0novwTaDDaW9QoaGCNuPQvgnn45ZfRSA83ouQFepa3S67aOdz37/9XGvV\npQm6smc0VQHjjkRrrDpZ76N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCPrp03FWprwihRgz\nsMQWsDzevmIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgTbbLyOGKswLko4DaGwRa1lFWQCnV6cpOepxSTqYRdSACIQDT\nB0mSx1AuAh7r21pBiZqsYW3AaWhCV7rHjY/vf02kpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8462", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8462` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAf7DfFaSzQgXOLz5N0UcwVUHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjNzA0OTljLTk5MDItNDEwNi05OTlkLTJiYTJkMjZlNTAyOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2EzZTU2MTMtYTMz\nYy00MGEzLWI3MzQtYzQ4NWZiMDIyZWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+cwtLWsBxoM0BP/mJb3EB7jw0oY5OFTiPC06EIN2CnV3xdOeRSbTGCViyVXZ\noVdToJLxxVkWctno3y/eUSAZjaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0xNwQH7u8viuMJj8NK9Wwn9TzRcwHwYDVR0j\nBBgwFoAUiOMCaw1k/EG8FjjAl/+GkF2Ye/wwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiAcI0hgBF+g6S0T9CEXYGALbYXz7yciq7JgvXEgkKocywIhAJ6NdYjFSdC6\nryF9lsPk9cJ9+ylj4s3GlcTLfgiSZ/Py\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5gz4xO4g8vavAaWn0f1hxQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzcwNDk5Yy05OTAyLTQxMDYtOTk5ZC0yYmEyZDI2ZTUwMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkgJ63m/cQYK2Et5Q0GpQS6OMJ7B6hAdIzSRHAI+hYaf8S\nJZO+Utui8hLYv06hCj/t9InfW/FFqRRHDD9nJ+tTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiOMCaw1k/EG8FjjAl/+GkF2Y\ne/wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTBI4xrYLvuP26LX60JngClHnHxUxAaGWZBDISV6PptkCIQDgFu/1tJ4C\n/18+Jysu3QZASR2i+oPKCnlTf3dXEMGG6g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAXyRXoZYB32jfN5En1EEOIk+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2EzZTU2MTMtYTMzYy00MGEzLWI3MzQtYzQ4NWZiMDIyZWU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWVjZDBiYmUtOWQ2MC00\nNDEzLTkxMTktZmY2NWVmY2NlZjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nskJwuqfJL2G2aANKXmsIrkN0HjtclB9RbHl85PPjv80duFAFBAfjgGdXdPWWKXxK\nrw6xHv9WYG9OEXVP4fGDXqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0xNwQH7u8viuMJj8\nNK9Wwn9TzRcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgeS7nKsNF464o6hyRnXN9Efg6i8wG6oIg0IkJn92+BwACIENB\nLc+z+2QpXUvTaStLzpZ1Oieba496mUSFpzQjC466\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8463", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8463` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAQnIITgQMoonTV9kbKys53xcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMmI0OGQwLTU3MTMtNDljMi1hZTI5LTI5ZDlkMDRmNTJkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhiNTJiMTEtZDQ4\nYy00MTI5LTk5N2ItMjNjMDFkMjcyY2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkT70sK+lMBBjJmSjGMMpVCqlVdWnWfdx2kwqQgfdcR3aJrwoAtmiRYNm8DWv\nsTtsAEtl/sCuFkZQRcHedOy9rKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPySB5PaYtOAy/HKlPzxsl9WpmzIwHwYDVR0j\nBBgwFoAUh1J3W+3mCdwRMd+Ir16oUnBg/DIwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEA+a4kXsLWG9sVBn1i3TYUM5qOY9s/ExtceOyeDkAlXZsCIQDqX9etJDAE\nGOPgGLxg5djQd8lEnz32HW5ha4puTsrQNw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATilU0DX1BejYm+rP1ep9h3sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDJiNDhkMC01NzEzLTQ5YzItYWUyOS0yOWQ5ZDA0ZjUyZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXHQp1Ivvv3FA/kt0BaL4u7KQNkoev4XETiIiikibNeRf+\n4UPbrhNRdgOHHmfhZDKGVVAwsK8lSOMR0w+qoky9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh1J3W+3mCdwRMd+Ir16oUnBg\n/DIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIEqF7Rqt3YDVkijav3+F+rwxTvZHC6oIyd603lsnBz0CIGRUeiL8jzZo\nncCK1pAoE5V+HivR51Ec+dsf/mf1GdM6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAe2+qMlw2J8/KY4rPI8rdDo9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhiNTJiMTEtZDQ4Yy00MTI5LTk5N2ItMjNjMDFkMjcyY2IzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjg4NTYwMWUtMTFlZS00\nOWRmLWE4YWEtMDZmOGRiNjM0MmUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYekf4ZTJQoBeppSH7JBqvjh/FcVglf/fCtrbdsj9F8A19jBRj9hpwkvP17fkW7MQ\nZ1LAG6T/DH1tXTHwUFty06N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPySB5PaYtOAy/HKl\nPzxsl9WpmzIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIhAKhB2u5RtPtoWeoA2RXENhWVaVDWhyv3WrcllBHmU2uaAh91\nSrAZBRP9VcZ+sYp2TYVOVBakem4Z+WN+hDR0rbsx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8464", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8464` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAY7Ecew0GTxTiTqkr+nwrnZ6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMGZkMGJhLTFiMTYtNGFiZi05N2ZmLTZiZGRmNzg1Y2NkNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFmMzQ4OGYtNmVj\nOC00YzNhLWJmYTEtYTQ1MzAwMzMxNjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM4xu43AqxDsWqfRwsGD5O/1nX8/iAHHYm6nLYHLyfFqprwL6OSeNjsBAPWEY\nnFJEx1FvxWMMIq4tI8Q+ksPPhKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNKMxJATODLTJstO4W7x8w3jvO08wHwYDVR0j\nBBgwFoAUphYZ8b8PpvOzqygq7tF8oic+Na0wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiB7\nzHY8s5nuKNPInc1BkNSWYgoNmsDVVhGkg3qlafd/vQIhAPlVemttCWsUmX8PdZV+\nhcnhMiqypRYrh8aXunIIb2fQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVAXltmoZ7BuGECs90RG08mvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjBmZDBiYS0xYjE2LTRhYmYtOTdmZi02YmRkZjc4NWNjZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATy9Ku29Jg7ay2NLnjhmkJIWm3remzgJtaXR99P1scpkX7W\nl8p7Gp1RvIP5C+LZjfKN6CZnHYQklhfWEH2xDJZ7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUphYZ8b8PpvOzqygq7tF8oic+\nNa0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQeBID3HbpSofXo22Gs4GDea15OAuALPMKIpjZ2t3WK8CIQCs1tTsDFNW\nefUjH2XEzSBVTJHl2sAjSkXgHzEoxojxSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARx4KCiI0Gq8HN+Ye/3/4Q1VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFmMzQ4OGYtNmVjOC00YzNhLWJmYTEtYTQ1MzAwMzMxNjUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2U2NTEyYzAtNjQxMS00\nNTI3LWEzNWMtMmVhNzhjM2EwZjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nb4jc21qr/GBRasKsbl7G5vLRf4ad4RcCnoN/li45y7sehRzQvG9yTaSGRUXhBp1V\niWbhnR1ckiRFKRN8Ip//JqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNKMxJATODLTJstO4\nW7x8w3jvO08wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhANkaqcy8zUvfNdrchjVOCxbtmCJ76HK01NUUfD70Wm2LAiBN\nINyRWjanOYOjWprlxse6639FPyJnf7W0Va8bLk/yUQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8465", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8465` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAX0howM2UFXejBpUVxoOxHmLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxMDhkODhiLTgzYTAtNGFlNy05ZTYwLWIwMDg3MjI5Y2E4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM0ZGU2OGQtMzZk\nNS00NGNmLTk3NGUtYmEzYzk4Y2M5YzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb+duWTYbHAUvpeGCur3ljvpnvN8tAb4YVtGsS/hYMZpiu2PpsWx8BesbVX0k\n7FrWTrV9x+eqM2vJGg8RcnaAAqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlwjHcMueEG+4NfNFEjXjcmAWAfswHwYDVR0j\nBBgwFoAU2P8VkWqnog+6AWGYtuWQh9GO4/EwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAxMoy7xZGsVxD5KhVfDpFQMxeXKr9AC7lpOH3UgCrb04CIQC7\n9BrD4lWp7DbPkoLHXtMqf258vlHpVN1ym4EHHbzk0A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZ04Rzyp5Em7Lwv43Aw92WGRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTA4ZDg4Yi04M2EwLTRhZTctOWU2MC1iMDA4NzIyOWNhODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ572yUQpveitngWIqdpGQupP2d67uAxj71iMm9yo8D/ATK\nXWD5oW7oTo99L2DvvUkIStm7G7D+QB2FKQhPQnWXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2P8VkWqnog+6AWGYtuWQh9GO\n4/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOXFMtHnhuo3fDYyXwLeP4E40n/eB53SqKTWjhrV+iMUAiEAt1/x9mXt\nha+0j3BjJf1GziT1F9H1XO3OrIeTUNzKJrg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAeRZCeTrEmuBFCulm7FNc3MHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM0ZGU2OGQtMzZkNS00NGNmLTk3NGUtYmEzYzk4Y2M5YzI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTcwY2MwNmMtM2YyNC00\nMWEyLWI5MjAtMjY0YmE2NmU2MzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDFMF6Uw/NYVeXJsUFmOkIzvlptIZpSS2lijbZJzcE5kmfy328+UbZ1owwQHUXnwa\n7WuTFXQKz/dBXfbHD76NLKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlwjHcMueEG+4NfNF\nEjXjcmAWAfswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgWZ4rwu2GjnUkzmTrAspYMmG5+C/dS6m4YavmsVSKUE0CIQDo\ni1BZ8WiYtC/dR3fFpX37uVyjSKr+lO+O1D5lbnP31A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8466", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8466` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASRfkLDuU1MceyE4ZUJmY9SFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlMjk4MDI1LWVjNzMtNDIzZS04ZjMzLTdlZjM4NzMxM2NiYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJjY2NkZGYtMTUx\nZC00NDA3LWE4ODMtYWRkNThkMGUyMDMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVTbr4HWthj7u72TyYBj0Qc6PpTMkq3fp6e05lNS7KttmGc4dxHd27yvCKfmg\n38YDxd+6PJiilxNxq+8iEimjPKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU8g4mc63O192QD8tindZW9ox0+QwHwYDVR0j\nBBgwFoAU+BF8H8yvDYW4cVIMG0nq2xHsxd0wPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiEAhqyEBgS2MvH5S5OUstR2e+RkBvlhZamAjkvaUG++/WcCIHg/\nxcKoEY2f5RVLzeYhQQtgU2MNweh/IbSeW2zQJ51g\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASge4uLGDxB5ZSexxx0IM707MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTI5ODAyNS1lYzczLTQyM2UtOGYzMy03ZWYzODczMTNjYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwhORuvY3VoymRV9Oe4uJiOokxqrf05kUpGV6BVwhZq/rL\nO5vFXcqw2Mhq6SzyfLmzm89sGTCOw5EIJG01VCXto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+BF8H8yvDYW4cVIMG0nq2xHs\nxd0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPgsBJyJ2vuXJWuUuXLy2h6y/i0hIL4mHnjgQOZbw5niAiBm1ZL2GoEX\nt0jfrlitYWVVzeJmJeT2UzHCJ53FvW2gIA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAZU6aURJrlhW00xaVwBv9g+5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJjY2NkZGYtMTUxZC00NDA3LWE4ODMtYWRkNThkMGUyMDMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGViM2FiYTQtMTAwMi00\nMWNmLWEyMjgtY2MwZDliNmEyMWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxopPridijWCDEOMThU5y2TwtpPfhmUz8pRi/ghq67nNzIHyekR8qqVJ7E9heQCpY\n8Uk8L7h6vjIS1Nr/b77wLKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUU8g4mc63O192QD8t\nindZW9ox0+QwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAORZz11LKtrBfrk2Th19nOzu+J62bz7TZa1hV3RVz+lVAiEA\nv7+CfvzBtpEiH7M7b1O6yhTDAzZ19EnDgx/wkCRJVAc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8467", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8467` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAVGEQbI3xgVKVgfNKWAuKbOMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0YWRjMTQ2LTYyNTEtNDJmOC1hMjU0LWY0Y2ZhYTBlYjdlNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBlYTcwMTUtMTE1\nOC00ZGEwLTgzZjUtNzA0ZWU5ZTllNTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEYNaC+5Fs9AsR2xrtDzTEyBt4FLfXpfWsmPH/0OY6uATyeLOh9lmk8ujxLRt\n3oJj3/TCnvM7u1XRFo3xfcFecaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1jGxf9I0pN5rlFfi2HFRaQBdUEwwHwYDVR0j\nBBgwFoAUp0m1Ux25x1+SoIh4JT1udFY2BbowJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAxhyPFOWyfuL/p\nHlTZx4cMRnWCtgXZ1+GyzOTlhUimOAIhAK7czUWVRDoH1TamsVqzTaLoMXN8hzTk\n85ZrLzZ7ZGzC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASAUBo4JPZ+B2huPWnfccqNEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGFkYzE0Ni02MjUxLTQyZjgtYTI1NC1mNGNmYWEwZWI3ZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBAjtwY21uYu7oW3ibDsceSHp2obfYdrY/yKsf72swYKdG\nkxEM4cYScf8e01B4iaq1aR9VKQuqVogm0QVUzUCoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp0m1Ux25x1+SoIh4JT1udFY2\nBbowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOR9H6z+aIlUzs0CjzTbcK335Lh4/EYinZtLd0XaA+9YCIBAju9ArVx9B\nJPC19UzgNPFdVQ5mUtgoHzrRJ691Bl6G\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAeNGtRv4xrixnVZZZN+WhS3ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBlYTcwMTUtMTE1OC00ZGEwLTgzZjUtNzA0ZWU5ZTllNTkzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGZiOWZjMzEtN2ZmMi00\nYzZlLTk0OGEtYTRlZjI4ZWJiMjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKXzkmVH6qkU3flRfSMY3m85e1JTavO8CJTfl9oL/NQI5Q6YCVFZfqo63FWixPNQP\nBXdL9BzfGcynrB0KvLmBuaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1jGxf9I0pN5rlFfi\n2HFRaQBdUEwwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAI6zuU87PpMyuRyPoqNoNAVn2Xhx7DEsQOHVPX+kKvtpAiAo\ny0ct70zPJxLl4r36xXIxJEcerdTCS0oc87DCKpuSFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8468", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8468` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAR71U0xGvIlsVrXnjgVbmBYQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1NWFmOGNlLTNmNTQtNDk0Yy1hOGE2LWQ1M2FjNWE3NDBmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFmZDc3M2YtMDRm\nMC00OWI3LTlhMzctZDljYWZmNGU4YzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj9I5e6Eqtz39QD6od6Cq3z/krvhbHfsJzx1d5+5pLHLJ340KfpPu8hnDfnBl\ncCAJg4U8xE/l840UA5zOOR52dKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr5CN1fDHASroTzM1k1SpkLBU110wHwYDVR0j\nBBgwFoAUvN+5jps8A2yWVGOwIyv2QdDOEZUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCtBSewPgXASps2njOQSDk+QVK8FfvJs0lpXc/L5nT5YAIgXz3wU0Vn1pM2\nldOSNdWPF3wFggRW8CjhGVNzdVHWfks=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU4g8lKQfIAwLNgpHjTP5ts1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTVhZjhjZS0zZjU0LTQ5NGMtYThhNi1kNTNhYzVhNzQwZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAv3Tcm6P6HPvOfbvaEurrfFoQAujL8ojfVU5HIzzx6OiT\neff9IwFifiG31cg6I924ktd4veTQzpcB58eiXxY6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvN+5jps8A2yWVGOwIyv2QdDO\nEZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdYlwwobT2VjBsRckeoEfzK/0HoAeOO2oyU/Zokk8iR0CIQDIPIAp8dbD\nb4YSCktFv6qPAaUtRWk3NhXybkVBne6H8A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAS5ZdNiVN6+yOcJtaZ4D7rNSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFmZDc3M2YtMDRmMC00OWI3LTlhMzctZDljYWZmNGU4YzZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjY1NTRkNjktNTQ2Ni00\nYTYwLThjN2EtOGQ5NzgxZTY1NDFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n5xOQHz/z1D6/mukMt4DwSDVUYfBYOYkI/rpLVlOWNKJmUiq/LVXo9bWfdDtmD0Fb\nuNHvUzmiUV71uFIwActbKqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUr5CN1fDHASroTzM1\nk1SpkLBU110wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAOqX96KO2hHOXtACzvFa7VWeUq1Q0QYQ11ja5ISWfH06AiEA\nyAA3UyJv0O5RI5JEaHHyn6U5FUh0QTHv0KmKNJ5LTvE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8469", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8469` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARCRnDg2Rs0dhEYMD1sbx/qLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4NzU4M2Q2LTkzNzAtNDU3MC1hMzc0LTczZTljNjJkOTM2MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNmN2RiN2QtMGQz\nZC00YTgzLWEzMjYtM2NjYmYxZDRhMTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExt5lZ9N7zi9UqsaTaRDVM5daeJ05e0g6AQE2guRtvFcXOIQj3HZMRlEdcJa4\nzR9itZCzazFamY+FqVQRR4JPRKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoRFnpxgiJPZbC+HDsOBnHaXCjOAwHwYDVR0j\nBBgwFoAUY4+izGisntk6XKu8g2pETz2pPDUwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQD3BFi1o1KoZazOJrI1ohjru5xVZdhRNh3rm9k2G8dTjwIgRJy9kaIZuCIt\nmQRg9462Y6+000XVA2C1iuDyHkuTW7o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQJ7e4BYtgfsHKIs8vkfOOloMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODc1ODNkNi05MzcwLTQ1NzAtYTM3NC03M2U5YzYyZDkzNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpSgsh4ZQqOqjlOpbBtuX3MtFWJF00Vis+uAbx+a27LIZH\nXcICwj+8CzripRCntdfZeBgwBrN48UjkogTeESV1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY4+izGisntk6XKu8g2pETz2p\nPDUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJ5NA/c9Ajt/YhcQm0CakMTZtJh+v3VVltH5tSEsbyGsCIAE23GlFudkJ\n9SKEsEfPLL9zgVX9UwT+xK8tO543nqve\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISARd31lXvgc5Ldjygo1tFKwioMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNmN2RiN2QtMGQzZC00YTgzLWEzMjYtM2NjYmYxZDRhMTQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODI1OTI4NjYtYzdjNC00\nYTIxLTg0MjktMWZjZDY2ZTI5ZjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nl7dc2vGVgT/Yn20ewDb7UPrwNauZMpCA5DG54g5m/golU5y5IBG3yWd3PISG793X\nYXM/CncSsIpzPcQcqSmpWaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUoRFnpxgiJPZbC+HD\nsOBnHaXCjOAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhALR8gwelwQeBXXHpWd/9Tws8b4/Ljg1rWBwIVgWBAJfvAiEA\n7B7BZgXX+O3piunDBstr0ID1Dl0BOs6Cv3nB5Dp/qwg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8470", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8470` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAXhfkBaEBUDZadlsGAVHoraFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNGVjZWUzLWM1NjQtNGVhMy05OTUzLTQwMGI1ZjVjZDhjNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTcwNWIzYjctZjU4\nZS00ZmIxLTgwMzgtMjg3NDc1YjgxZmU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL8h1JmVXFjIhSZcVgbdtE2bWIRg7NJ0TLiHRiue6P9nyuaOOgs/TIegHHIv0\npaWowZkLbTn+Hkko3tV86jirC6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6YFj2JNQd0GW05u0+//Afi83xAkwHwYDVR0j\nBBgwFoAUoI9A1ITy5Q4vRB3O4KFZoPBgZIYwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEApNo5aNV98s+TPB2v5nyFZkGD1eOy5joL5OppzqT/pwcCIQDDkt0Xtyoe\nKP50PoG9RKjYiw12O2eOQiJPAMlO2YaAjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT7N9tlp8NOpxHORfRmv2CuZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTRlY2VlMy1jNTY0LTRlYTMtOTk1My00MDBiNWY1Y2Q4YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWWJWX6gOAL2HPrQ2k1d8bSqEuXPyhn2aMXe/QhtCq8XR+\nreIzfqVmPSjMIBhHXWn90SQu35sKFthyqJGbRLijo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoI9A1ITy5Q4vRB3O4KFZoPBg\nZIYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIfFD7yQQMq/KoPIW8nrVsOKvKspZ2qGi2pOj3zEHooYCIARwcp8SrnDF\nrzHxaMYHbGpgTONp61zO0BP/vfCk8nyk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdtI4ngREb97hFmF9NpJmaq5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTcwNWIzYjctZjU4ZS00ZmIxLTgwMzgtMjg3NDc1YjgxZmU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWFlYWNkZDUtNGRkOC00\nYjE3LTg3MmUtZWFkZTY2ZDMwOTdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvYDpT4EiNThaAezVJ9/DOcITMLgi6vOiklw+hGpR2tVJAVAVzbedak8BncO+d2KH\nE2pArdlUpm3fm4/clQSCXKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6YFj2JNQd0GW05u0\n+//Afi83xAkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgDg4uxFndqDqV53rs8W+57Rye4geD8pu9EJBMBNZ6VMACIQDL\nuhoLPoppQ9V4CzxJFB2z6hGDK5zwAkH3tW3Yc6Eu5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8471", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8471` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAVVZ2uPtrz5pFJsQNhcmt+HyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYjBhNjM1LWExMTAtNGJiZS1iZmM2LWE4YmZjYWJjZjZkMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM0MDdkZmUtMDhm\nNi00NjRmLWFhZjUtOTE0NDQ2MTMxMDdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ4+aAgEmneJkNbYAgDa4e2ShCFZE7YMxjtguAXlClWuOooEQ7J0s55jeUMX1\n9dje6IKK6ncix7tKasYN2Eh7jqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBxXR2b6/A3a+l1etSbAh/RqNHTkwHwYDVR0j\nBBgwFoAUN/oF2DQTT66MmVt2XM1ViQoH58wwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAlWZG36SgE3FHt13Gnyc9AMDM+vOvZ0PvWgE3D5g1\nlhwCIQCJoVCVL4DQ5RPA17AkL9KmsQe8+cPFdFfHiADB38eZiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVLEuvP0Ho5VHIdqlkls+E0lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmIwYTYzNS1hMTEwLTRiYmUtYmZjNi1hOGJmY2FiY2Y2ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu3qPMSgDTXODksr5u8P8nGEa95AQUgfLcMdJH8Uq265wd\niXFCuo7qTOt5uohfE250IEun6wAdw9BpxSt4Jzdto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN/oF2DQTT66MmVt2XM1ViQoH\n58wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU2hJW+dWE3yE3MIudUzvmuxx6fyz8FcjMoj5VdzcHJ4CIQDN2cb/lblG\nkT1qrKXzB2C6f2BcJvF8ZarNxNfFza4iNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAWzXM3vdujmgKxKANumT+ggYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM0MDdkZmUtMDhmNi00NjRmLWFhZjUtOTE0NDQ2MTMxMDdmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWIzZmE1OGYtYWRlZS00\nMzMxLWI1N2ItOTQxODc5MTAwYjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzQBGrNMgv+VunLBfANnUUg1P2p2yU3HEt7Omtz4PjP5Apqxqa6PyXsair2MRQitO\nfiCMFlBlee2i8jtJtUCIxqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBxXR2b6/A3a+l1et\nSbAh/RqNHTkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgalU+0a3/IUqvsLeviLCenyF4bfysOj1YaIep3e2+DZMCIQDS\nvtwiFHkSGqwJYTw6fdS75rIzINKAchSD9oAsfgxQ7w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8472", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8472` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAb7FTRBt+38/wMuaYhNxrFWtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmZjkzNjM4LWY3YTUtNGIwZi1hNTYxLWY1YjNmMmQwOTZjNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTYzZTcyYWQtMzI1\nOS00ZmE0LTljYmEtODkzOTk5YWRhYjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPDrwhAWpyD+jXBJ07FrKHkQBlvz6/J6M6khlsGrrWLuoyoZ0Ukfj0kwb4LvF\nKIsQiQrl2PAXMnk6keEZT6tS/qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlUlDyLsscbD8ffbhvkbly6yvAfcwHwYDVR0j\nBBgwFoAU9pG/OyOKStdYh9rgDnWklgc9y8UwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA+6GTvpaAdRlWJwsAykxEP9XAfaqN0isAX6RcQuoA\nYD4CIHWzaedYLT2FvLE0YoWMmG0hFcbnaQD9LzamwnT03D5y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWRmlNjWKOSgmHYG4MkPjjgyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZmY5MzYzOC1mN2E1LTRiMGYtYTU2MS1mNWIzZjJkMDk2YzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXjoLiiJfuESfwnnXTinmc0b0uVOWWKPuRO+8WZz6YWiPy\n2rsM9lZEw1ZrsiZSGxLYVIWT114RDXjCu0IFdJwno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9pG/OyOKStdYh9rgDnWklgc9\ny8UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKjwmBfpzhb36B2xjhAGouvxvUkYK0Ntdu6UUgBtvuhoCIQDje6Aynik+\nYjN3sSVMvBO6S98NV/B0i8pc90yuiE+DJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdXqtFk1yyQ+njk06yM48k5oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTYzZTcyYWQtMzI1OS00ZmE0LTljYmEtODkzOTk5YWRhYjQ3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjI2OGQ3MjItYmJmMS00\nYzg4LThjODgtY2E2YjMyZTcxNGQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niOHOKAAo6WMpgXolvdwricmyj2tTfQkt9f+0+aZdSV3n2mB98ZYqgWZCNVLNEIi3\nJOc3qECYq0cfwOCDBzkEkaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlUlDyLsscbD8ffbh\nvkbly6yvAfcwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgARC7sOZ37khK5AK3vobW6ALDorwlJSwfUHob9LE5VSUCIQDf\nCQtlGBJYHXET613VCym/zrhIgHijV8dzr8ihT+aQqQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8473", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8473` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISActdfAOuR1dJ6JpWR68XkHQkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjM2YyMzNkLTNjMTQtNDUwNy1hZjMwLTM3MTg2Yzg2YmE1YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTdiNWM5ZDMtZDNm\nMy00MTBlLWFkMTMtMzBhMjRmYzFlMWI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi+cb+o1MnoOZ7s8hsgIaz96i8w3cEmmEsF6HUv77FCuis9ybDffNVX9G8WyP\nLN7yF/AZji6lgdH3G3lQ0w6YiKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkHhY6zNpIBPD0WSb5z6VDnsyhf8wHwYDVR0j\nBBgwFoAU6GrDVcMD4vnprPLTf6mWsDk7x9cwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEAxDLazGmZOjyhcdnsGx84Y+yVNlQXoCHhEe8DnJhZR/kCIBbM\n515HDCisgIFep7HOEb33AsvBffPdm33BTE587cTL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVgSomcXE1MSX+H/Slu+/gMiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzNmMjMzZC0zYzE0LTQ1MDctYWYzMC0zNzE4NmM4NmJhNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATi3gUXOLR7nadb5UCXuBUr1AsrS6hduyasuDxmqo28GZn4\nqT3Ug3ldeQIPIO8sufpZc9Gvf8rkPU5iq48iD4Gno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6GrDVcMD4vnprPLTf6mWsDk7\nx9cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGkQVBl5cD0DOeLgqgDLhK/8XIQwuOFpQmMEHvaQnB8oCIQDSitNgZshY\nhJxK6D+tVHpfp9IiNemZ4NRRTDNdziuZrA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAfVUK+oPgI6tMEHFhBdy8vE4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTdiNWM5ZDMtZDNmMy00MTBlLWFkMTMtMzBhMjRmYzFlMWI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjFjZmMzNDctZjEzYi00\nMzk5LWI3MWUtMGJkY2ZmMzliZDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n07ZIhX9QXZUM1fiGNVefaEt4LushQnvHm1+33ReoZyRhXGpT+iNAdXfFye4UV61+\n37u4PxoZ3IxkqgilWomfsaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkHhY6zNpIBPD0WSb\n5z6VDnsyhf8wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgBX9h58rtcDV0x0P3wVtx4eUz3uC562Ygu5c8hJoDb9MCIQDJ\nPC1FY981sOUdIMjgIbj8KLbkEeuU4BK0Gn1xVerJyg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8474", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8474` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISARD+rfi36w2QCaXBIGvQyT6oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxOTBlYzU0LWE3NTYtNDlmNi04Njk0LTMwZjUwNjc2OGQ1ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFmMDU3M2QtNmY1\nZS00Y2ZjLTk2ZGEtMDQ0NGUxOTNlNTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDp+RWabTg/felNHDhfYpNrCtBk/j7ZKNxFE90UySZUL3W3hjCMSohu9qZwtz\nyMO/AaXY5VnNeMfyYgGH72mUV6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVbLqqgzS9UqopEhCYqXWMxAEj6kwHwYDVR0j\nBBgwFoAUwooIgOOlnDT/SrWFB+65RJQZckMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBldXakJNT+EekcLoFl7xJps2sPjiIRYQxu\nWGhZgmH+1AIhAK2V0o9xLCuiCcXrnqIcpnn3q/t+PK2pFOR1Bg0hemvw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ4rBrZrPL0PNXdaA3McqsxyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTkwZWM1NC1hNzU2LTQ5ZjYtODY5NC0zMGY1MDY3NjhkNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStMMoh9rBhAd4SeztpOf63RLvW4rv1aBXDKDTDASrI7gSb\nOhBzVBSVkhWgVlPomoztykkN5Sxnr+vuECF67CZxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwooIgOOlnDT/SrWFB+65RJQZ\nckMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbzFqWjikNnZvhAftZ/tLd/k88YtQ0XadYBCTBFCHiZICIGbNH5EhGApI\n1zpJ9MIA90h6k0mLHwOwNMIjVlz8ikg2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZ0/pkCLHRiRv/R9YX/fGRzhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFmMDU3M2QtNmY1ZS00Y2ZjLTk2ZGEtMDQ0NGUxOTNlNTI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjJjNmMwMmItNGFjMy00\nYjk1LWI5YzYtZGMwZTAzYWUzYzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlop4WpqriWLQVOEexLFhfVScRbhqnhXeKrKi0WUS7nEkvnbBozFjLAdPuvQfnmqt\nSBtTuYWa29DazbVoIoc3+aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVbLqqgzS9UqopEhC\nYqXWMxAEj6kwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgFFm9d4wtZ/ChMusu6PsXd9FCISUC7TF4z3JEP/0QxZcCIQCd\nI2+oyfAZgQXjw+oIJPxa6CP/JJ+UMWYm1HN+WN70lQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8475", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8475` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAYSrGAxHeXh9aXdwgY4wswCYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzNDlkMTNlLTJjYTEtNGRkMi1iOTBjLThhNTNmYTdjYmIyYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQwZjAxMTktYzdj\nZC00ZWFlLWJjNzAtZjdjZTBhZTkyYmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErpb8S+uz34vTozOJBqOWftOz40Xao/N3rxlRlI4TdsL1Fo+pM5oCvxzsziIX\nl3rJLd0CKMSmwr0NKq3dWjbtL6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj2biKaARcpwQDKH2sfRZj/685o0wHwYDVR0j\nBBgwFoAU+yUTsGpjkK5DRqikXqN997dnhIowSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAhbJ/do9sfdvR3cyK6ThDisXaQLSUsHMj\np+sL6tOD/jQCIGlpUQz/JrEZ+EUcnrH92aDlcxciFGim+gy+L/73SoPU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW9elobLFyZwRu52DZzp6Cb1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzQ5ZDEzZS0yY2ExLTRkZDItYjkwYy04YTUzZmE3Y2JiMmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlydFlpE/jxQAnT3peZEqO772fPr73PIzsWFyLYsR1OGGt\nB8oLrzVdV0ToqEZ6rhDikHv8HZMwRJZB9WgQM98xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+yUTsGpjkK5DRqikXqN997dn\nhIowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL4t4qpz410WFDMQGnpdYDaH3mkxwj2Mcz7Y/+7iNajQAiBimBOV7fvg\n3bn5iUIeurPOY/SasICWj9yAoc1qP279Yw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAXFJMEj5v8/I/zuBGb0/+DXoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQwZjAxMTktYzdjZC00ZWFlLWJjNzAtZjdjZTBhZTkyYmZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTVhYjZhN2ItZWRlNC00\nMmE4LWFhMTMtMDk3Yjg1ZTc4ZjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nT1NTVXiLMfY5lJra3RgfsKPaIBW/pMXVlT39m2o2ne++r2laIGXOa73WO4P6W9q8\nFAIWtCAUzi/wNKb/UEA2lqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUj2biKaARcpwQDKH2\nsfRZj/685o0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgYU6/RdfVdvtzyX8VGv7g2+BTz44MiHK5bN4dLw3dBQUCIQCl\nMkq0gN6X3Ya1b7JR1RgjjDA71YUBvJD6N4f0tqxT6g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8476", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8476` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAYM2FlqJFYEhbcC6klQ4WSGrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5M2JiNmEwLTIzZGMtNDRmNi1hNmMxLWM0ZGQ5OTdhYmNiMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRlYzY2MjYtZGRk\nNy00MjBiLTg3MjQtN2ZlMmJmNmY3ZWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8VCGrFTEipx5jvzjiOWEXqOUVC3Ba6d9qc5r8w4boeUDbfuoLnnqbKcK2f1o\nQdMxMdFZjVsFxrQnwkX4apIXPqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs3RSe9I8G/b/lb4L5VqMp/e+n7kwHwYDVR0j\nBBgwFoAURn2wmMaoxcgBMyGH53gtEqG9Ak8wJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiBwDCaQMxc18qSW\neRsmIIwWHAEGVAFs5jqzq08nLdNVqAIgJytCb2T0FOqgSJ3dPs6OO1tWRG8BaKo2\nWlbnO/u/3Qk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU6UH3Tvm2Fi2MDce8wb34r+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTNiYjZhMC0yM2RjLTQ0ZjYtYTZjMS1jNGRkOTk3YWJjYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8LSxbcexCOaTPddk4sU6vcgTiIW7JKGeZV9puqVSVHHw2\nPGdEd0Z1r9dqqXB9MFL1b1IL74u+LcbB9eEP5d46o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURn2wmMaoxcgBMyGH53gtEqG9\nAk8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcVGT9wccpW75I2Iu825Dud82AgxOgiei6FbvZ1EX16UCIQDhyJHHKIoS\nkeJ6vslY/h3NdpJ6mMqmfrJFrsgRpTLErA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAfB1t8XWbYF2+9Ub74k4ltSCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRlYzY2MjYtZGRkNy00MjBiLTg3MjQtN2ZlMmJmNmY3ZWY0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzhiZjZiOGQtOTEyOS00\nM2NhLThiOTAtMzNmZWJjNjQ2ZTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvaNpx/rrJED8HVIQFlD8OR+klSLJPk+2SJnZ3EY1nkRUFb7uhf535hJp9AN58kfQ\nbsuUJapS0bT82vogsfEKB6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs3RSe9I8G/b/lb4L\n5VqMp/e+n7kwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAMelQBxMgxLDVo/wgwvzbZKYb7HuuNObSjo+whk6/r/MAiEA\nwkx6bx5QTyf7XbmarG/PwnUcGPuULUATV2lgfZS+V+w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8477", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8477` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAaRjYnjL2Ms0pzdHrehqz4YqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkZjU5YjQ5LWJjYWUtNDFkNy1iODI4LWFmMjlhODFhNzY0NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI4NzM4ZjQtMDFi\nYy00OGRmLTg3ZDYtZTdhOTJkMGJlMzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE309sjTXC5JqmuG4Z2dLevNkT8Du7y2WQMnaDIhyF7qKLqOjloq7F4+CbYTPA\nLE1GSw/6fU6SmFzKXrliwkcP76OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf+clH235X5c4v2hHQbQFqpic4NUwHwYDVR0j\nBBgwFoAUzCvhcXlRXLHxAeKFR+Kh4LPbR/gwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDY2VyYkDk4sP2GUJmn+IKzAnFS0KI2Gozvd6NIM0liSwIhAJ38HirjfMh3\ngsilCG+ww9oKpnFwJRUaMYQn9k/Yiftv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeeoCep3PMBE3rccmrDkNgdgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZGY1OWI0OS1iY2FlLTQxZDctYjgyOC1hZjI5YTgxYTc2NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQP4+dryMucPdD5vPzplE1E903ctctCfKbhJn3P5e6bmQ7h\n7vLIiO4D+PQUZtE1MXljPi2mv5yygKdQbxgct7H4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzCvhcXlRXLHxAeKFR+Kh4LPb\nR/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPFasBMV0FSWqBcUQOI6csb5sCCvmxFnrTDa7Pq6dkegAiEA03WrQ/xx\n3WL6hamBIcUx9Q6NIJT7/FpikjNt5Edn+50=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAaXS03rIB9hkPtRWORb3Du50MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI4NzM4ZjQtMDFiYy00OGRmLTg3ZDYtZTdhOTJkMGJlMzI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjY4ODcxMzctODJkMy00\nZTc2LTg5MWUtOGYyMzA2NDczZGEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbWWYH+6iVx3ownkciyNdl36dyICDImFTgKFT5V/Mn1F0YyYUQlSD8Z+opU7g6Ucf\n6NK2JRzXZPvE7NtwlYnlAqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUf+clH235X5c4v2hH\nQbQFqpic4NUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgPh+Aupmz7gHI9uG1Vvh7w4K7zAdYgrMtu93qkFusPvMCIGZL\nsoPNBi2zfYG6QbORVKkqjM0esK4930v+YuX8pIxl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8478", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8478` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAe1JuwVAX4sn0jvmsS+HNStQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1NWI4NDQ0LTdmNDUtNDdmMi1hNWNhLTYzMDYyOWMzYWFiZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU3NTMyYTItM2Vl\nZC00YWI3LWJmOWUtNDFiMTkxMDRhYTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3lRUj9RTLQjwBc1bqbeK5vsUdXj5YlXFFcustruL9hvdcSnbc7qit85VjXMA\nBrx5NhUD+5F/ue+C/rL7qa9Rn6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP4KcxTTnZ6FtODC5XggJ41ZAnbEwHwYDVR0j\nBBgwFoAUh2iLeNvImUectPLlImyXX10cMvowNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDvps+QaLRu8MBrDqwgaz30LdtJJxtKO8GpylFBo0aqMwIhAPxDwmP/C5VG\noJNr6vwlvAAWLzgLFLJvs/vkkpF/XQ+2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX/No32FvaBHBcMEchsUzb9MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTViODQ0NC03ZjQ1LTQ3ZjItYTVjYS02MzA2MjljM2FhYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGe6MgWmIyBUWksQHYe3a6J4XIwEPsQoVhCFaksgYKuIHx\n4F/ejkvGXC268skFTGwhV1PKMqa66TTmfrDqlPFro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh2iLeNvImUectPLlImyXX10c\nMvowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIga89N8LX5FAGU6/cBpp9tQwyFhr9uRv4c1lsWF3FRV78CIQDTmUQw5bIx\nlwyNPsr0EDWbdpbgbsnGcbYXES6deUujRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAeQmvsMpr1RWnAtsDfKEy0bKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU3NTMyYTItM2VlZC00YWI3LWJmOWUtNDFiMTkxMDRhYTQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTA4YTY0OTQtYTM1Ni00\nZDM2LWI5YjctNTRlZjY2NWQ1NTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nq0YBN9SyPw00wmNwKZQJ1ay0R3iwhOJI3vaRi4K7UysZfJLgzTYfVDgzxLtHqS2r\nKtY1KbkMMsi4gihqDRvoNqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUP4KcxTTnZ6FtODC5\nXggJ41ZAnbEwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAKNUKxuYV6FO9cRxyiznL4awyIjNJuohOn+zmKLGCMPbAiEA\nrR/ClFbhCydt2e3ARyt8yUXznreCp01qgs6482OssgU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8479", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8479` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAeLgbjmHe1Ioxw1Q3dlTXWwgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4YzkzMGFlLTk4NTAtNDZmZi1hNDhmLWQxZGEyMDlhZDVkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI2OWM0NTgtYzM1\nYi00Y2NlLWI3NDgtNDk3MmM1YzcwMWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOTbTcyOtHobwNtay5LU3qUileQNnzL3p32F5CWmUBA8Vi/ykG78bqFIYm3tg\nU3e+iUstjHv2S4FqOOYbaIhLeKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB/DWjq7VYX5iwq2DRu/vne2NyjswHwYDVR0j\nBBgwFoAU64UVp0kAhuQ5Aqhbaro+IZKED0cwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA7qo/4ySXj0RnsdxBYjy5KgGYGKeoyrwSidnYriYpiwkCIQDk/4YRlNKw\nTsfLeH8P+20Lo958FKHw9J9MURRwmbZCOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQs6hIe7fWJ8uL9r8es0mivAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGM5MzBhZS05ODUwLTQ2ZmYtYTQ4Zi1kMWRhMjA5YWQ1ZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZ5kGwPRxZoYR47JjLCKLLoyeQyMK6XYMDVmnEFN+mjjdA\nb1tgUGeT8hUwWXFiG81QzI6jncbBSiDRScsD096do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU64UVp0kAhuQ5Aqhbaro+IZKE\nD0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKY13V5ghrBwl0jBV9zt4Xf6cPedQgAM3wZwJNlnHPWtAiEAg1WVEle1\nbMNKNPOkV1TyuOFesRTLYbW33ohIHELp0m8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAX5fqPUdyrs7iUyga5Jo1JGuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI2OWM0NTgtYzM1Yi00Y2NlLWI3NDgtNDk3MmM1YzcwMWU0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWFlYWE0N2YtYTIyMC00\nNjQ1LWE5ZTctY2U3ZDkxMjFlMDczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4b7bitaqHtQuTTDbf97bhJpoiYf8YJnNQDa9B9TrpnG8mdIHc/9+GVQDwjBZN3/g\nKoUbomnWHSTwZ5fNdnFWcKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUB/DWjq7VYX5iwq2D\nRu/vne2NyjswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgDw97DluK/zvK/wCN14yICx20TTPuz4omj8I65GLSoOcCIQCD\nvMqyG4RMZwD5dp7T/uWV1JNDImlFjynIkyWElgAo/A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8480", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8480` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAaZtPD2gz0SzreOogpI88V/5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3YTM2M2FhLWRhOTItNDE3OC1iZTg2LWFhYzgzNjg1N2IzNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmM0MzZhNTEtOTRm\nMS00MDJjLTgwNDEtMGRjZTI2ZjBlODA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEk/mt9OQ/TEY2pSp1j0/D+6EA4Hyt8nFwBYYDoK5UDxyW85mmmtKI9/QBQZXy\nMfbelksWvEvypJi5HWTbaDfSk6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9hiK9zh4q63ug6tZSAXCUSVq2MMwHwYDVR0j\nBBgwFoAUe48BGQMI5levmOsMjH4C3S4uuRcwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBZId6RAOUhSnqEodjk2tOqrZQdnzIWnmbtjYK4rvat\n6wIgcOJb/kumANsmxL9U7KZIHQtTyfFnMgp9oQhH1nD1uQE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdAzTe5nazdFED3r3KbX6cHcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nN2EzNjNhYS1kYTkyLTQxNzgtYmU4Ni1hYWM4MzY4NTdiMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASlKb0sn/j2JrRKJTKJPFsuNU0h3a+3M8se6Oc1OgClwzqK\ncinUJkLszZS9A5jPYy6FDj4lrd3VKM0EAVU/WHg4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe48BGQMI5levmOsMjH4C3S4u\nuRcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTYKysnXqSLDGLZu8vIAwBJxAPIR+DyB9gxVbz6pIWCkCIC9w3yyzGP12\nhbu11ra2JLxwaypDadmj39ccUiiCigzp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISASncuaOLqttvT0EDLT9q0ZiIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmM0MzZhNTEtOTRmMS00MDJjLTgwNDEtMGRjZTI2ZjBlODA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWVlNDM0NzUtNGNlZC00\nZjdkLTlhMjAtOWNmMThlYTliZmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSLxAyu0gp6lMyrYreyhjfGE4T8dkFqK8CRhbiMijzcOkesVgrJ8dsMMgl5mRGQHY\nRC9i5hTprbcEu12oIdX7pKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9hiK9zh4q63ug6tZ\nSAXCUSVq2MMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMdBfXNgqPaavMbktKuLDVSAJUKF9B5eHRJf80DCaaMWAiAj\nR1EWc/WDYgMH7abw/2394i8dyQi8Jv+Z4oaKSyxPTA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8481", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8481` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAW2SlIQClA0BxSmgv/91wlOnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzNDI1YzAyLTE2ZTItNGQ5OC1hMGJkLTI2NTRiNjhkZWJkNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQwOTRmMjQtYzI4\nYy00YTIxLTk0MDMtYzZkZjMwYzExODMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBaTuHkdXaTldqy3RgUTvurlNWZQLpvFGcaEmIK2CpwSF9Hfnn0GGtMbLX2kQ\n3yBtZ/3GSBf2OIetrqRUG0fw9qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrjDOZANBxMJEfqv+jiBk5hZGIo4wHwYDVR0j\nBBgwFoAUbOO83VExJE9lfvPhqJSGPakv3DgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNHADBEAiBmOg3qpqEzbzO2l1HhuITZuXAe++ZSyN+YxNPYp7Jp\nogIgZ3r7imh9VkrNq59OodZWNQzQh0O691OqkzZWyfyLjoQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX1SaoANqIkirMdHWg8nQPjqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzQyNWMwMi0xNmUyLTRkOTgtYTBiZC0yNjU0YjY4ZGViZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5yL/OksItMAU9EasnVn4+2L5IH/EXHhWfAcZPFrjFsd3z\nBZPcL+9S309e66uBM1HkxUSGZ9tKkUr3ydBUzHNjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbOO83VExJE9lfvPhqJSGPakv\n3DgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgR4CJ3losna955EmxY29Vkz4ln9S4O4mEBSFEH73Hd+wCIQDiQlEFxLM5\nlJ6wbMzEHlGcfLCvU4ZSnuKrdNgcKMO7Lg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAan8xEhIWoNef2cIh0K9PobvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQwOTRmMjQtYzI4Yy00YTIxLTk0MDMtYzZkZjMwYzExODMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjE5NGI2OGItZWM0Mi00\nZWUyLTllN2YtNTk5MDUwMmFhMTk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noyM4B10ME1T0eZwflXMbYEtMVu0pdXkhpylNpkBa9wD7eV+D9pruZw9XUH3Fes13\nI7lcU4a543I+/2ymlkQ5YKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrjDOZANBxMJEfqv+\njiBk5hZGIo4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAMts2e6tYDisuChRjOHJHA4e03IdofFCVLl5vLP5PHzJAiEA\n8V3vzqPDnHYnSMgRyQp9x3ShFfnZY3mG1H5R1gdYulc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8482", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8482` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAdXK13ybSE9xDXC0HQfNVVERMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxYmI1YThmLThlZGMtNDRkNy05MDMzLTg2ZWEyMWQ0ODQzYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMwNzVmMGYtNTQz\nZS00NzFkLWJiMWItMTM1MGJkOTU5MzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIt2AEl5/dI5JIz50ZWwP77sbAG7QSQgKnvSLAxhHT2IQR83mgwrLmW37ddiw\nLYFK86WLCsZSn9evl+uDh9WRaKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJxL3HtMKj2j3uy7EKaVxisQI4n4wHwYDVR0j\nBBgwFoAUvqjgs/4k4xlT5r266hPChwbKbOswPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEApNdCuUafY/97MZd/j04A/5edvzf62aHqlC8uKZhu7wYCIQCN\nZ4AQqKBr6i4xxM+7fYGR534SdkLXYjjz+zQMYycj5A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXPnjo7eUg/8cMHpFAl5OpZlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWJiNWE4Zi04ZWRjLTQ0ZDctOTAzMy04NmVhMjFkNDg0M2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgECmrS3GlLGPHuRLoxLNPXopnXfJ2KAneviJCf4aWG1j1\nvffk5eNTFspm8x2P7LYRn/IDaK3KCoRVrQ1QioIUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvqjgs/4k4xlT5r266hPChwbK\nbOswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbKyGEq8QiJa1IwoWR9Hmc8XZJP4gCFi9RYoMuU/AKh0CIQChQjITntSv\n4GmTDYUhYnObYlo8ho8CmcmVKFcx7BV9IQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISARGQPf+U0jVlQkDAszQ1FsMkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMwNzVmMGYtNTQzZS00NzFkLWJiMWItMTM1MGJkOTU5MzM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGQzZDk2NjUtMmY4OC00\nNDBkLTk2NjAtODI1YTY4OGMyNDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQTJDoEt/3gykkS0kvb3R1QO4MLef9OyOTrEqccW/d3eN8spAATuhM9XZhaOAopKj\n0fwFQK15sHamBNxskFSnUqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJxL3HtMKj2j3uy7E\nKaVxisQI4n4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgH7g3nQ6+bU6MK/fC11SNoluYRCggGQPQ5V6NYJv1f9ECIDxx\n6LsuZwF6X1+D23KrF+i4uJOLtH8FUpeWbzDL5agx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8483", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8483` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAYQ/QIjBuzjbrY9yKzLoKUv6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMDEzYTcyLTJhYzYtNGZhYy05Mjc2LWNhNTZhMTJiZTk0MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE3M2U5MGQtYzZl\nNS00YTdhLTg0ZWYtNDY3MTI3NGFkYjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2iuor2+FmWehkYedsfRlSBpE3lKc1k8wZmVJ2n1/n3lW4iKbympOacnHx0ao\nVcCFIxI2sojilHiCLiQvPj1636OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTm7PIft1Aev3qvsAEVTKFUReojUwHwYDVR0j\nBBgwFoAU0vkCiWkaPHualQQQgw2W599wcv4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEApqw5OnOPReSWPCOmGr1Dm2TUZANCS9Xm\nux1O6RwBNr4CIQDdzbzd4VWv+l4OQCYtPlXxxNk6bD4EAT6dbG4IF5XXrw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXxZ0nJQuOFereLUg89Rj+wdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjAxM2E3Mi0yYWM2LTRmYWMtOTI3Ni1jYTU2YTEyYmU5NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKBcpVfgK2q5pNUuomexGyj6EOKKBrDmO05at7ASKDRznA\n8ctYneF2T5afxX0T4RUv0KJ49twi22mJube8nsM0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0vkCiWkaPHualQQQgw2W599w\ncv4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKqjyNkqtOTwGvwzyw8+55emf2UVkmQWNylV+UaBLS/gCIQCEqtf2hTjh\nMc7vdUg8MqOoX0pnkYvADA/+u8FnJQ5h6w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAX+G6pn8hJvBw1GTYqUII/zyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE3M2U5MGQtYzZlNS00YTdhLTg0ZWYtNDY3MTI3NGFkYjczMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2IyNDY1MWItNmVlNS00\nNGI1LWFjODktODRmZmZlY2E1MDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6FkqW2jE3qfDTti7Bhhm1ECFrAgJ46ZucoHh/sZtyooiRwlIEiOKRJrCiKtdBfjQ\nz6ONrkWYj/rMLRyu13mZjqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTm7PIft1Aev3qvsA\nEVTKFUReojUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgR49oE/SFVrV1v0xbpv1Q4BUE9xJ0LEsutsEA9JsAqn4CIQCw\npg34mO20Bxe+lzsymwim2yYC5PnJWz4HyvwUejoESw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8484", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8484` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAfFUJKKFoOjrCAcjJiKdyvZpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmMTZkNzM5LTQ0MTUtNDhlMy05YThmLTMzYzhiNmY0MWJkNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFhZDJmZjQtZmFl\nZC00ZDE0LWIyZGMtZjhiZjQ0ZjM2NTFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcR+CdZY/PxiSfVbgY6dYACEwCywIGjcJcLFs37x51ZU2a2DMykJe3fq4xvoS\n2IBcEvbpJyKTbGzQX/BmmkSV9aOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2CW7cGgqbIxRamPXxV2f9QKvO/4wHwYDVR0j\nBBgwFoAU0y+/wky1efJaDywxoCT3K3sQ4qkwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA0AWqtWVLHPTVyDe+zcXV57bm0B7zZyXv\ntPkqVaDAxXQCIQCLml0nOnzjzZP29Dgg0ODBmorhIEJZZkhQ+kMg6jAs1g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYFUzR5HmRzVGW65PKkBCyZPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjE2ZDczOS00NDE1LTQ4ZTMtOWE4Zi0zM2M4YjZmNDFiZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDp9pzdbjlgcov3YZZpQ/HTmVIKvz3+43Vs7odfYlFQMFB\ngMlpVUKLqKQbR5CHMpzMfNzBo2cVzVCVzV67YCN7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0y+/wky1efJaDywxoCT3K3sQ\n4qkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE8dobPkKqx2wtXte3LfMvGOq7JlB16u75rFzXQlezdwCIQDkwb6t0NIC\n9SBs0R+yARuijV+dvskz2V8jasDC/6UqUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAYwiNV+5Ez25OjCZU5/Ith0GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFhZDJmZjQtZmFlZC00ZDE0LWIyZGMtZjhiZjQ0ZjM2NTFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzBjYWE0YTQtMWY3Ny00\nYjM1LTkwMjMtMGE1OWNjZWJiZTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njPPCvGxg8Rep6Jh1NuCrIBiGyYmJ8nszSd74jwsN43HNyMKNxA1M3LG2BLNUMedk\nZX5EJbJgxZesafxSNhrLp6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2CW7cGgqbIxRamPX\nxV2f9QKvO/4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgdtZnOiJ5d0xMP27Juhr7hGcSPq+LHpL5t8dIexM3y+QCIBN+\niEnnQDfE3W4DrwTDR6zw6M1JRL4ZMeQbThFPs19E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8485", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8485` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASQrVGEn5S3hOAbEv9+8DsLsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiYWFmM2ZkLWUyZDgtNGEzMC1hZDE2LTkzYjVhYjYzYzk4YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThlNTYwMTQtOWI3\nMy00MGU0LTkzNjctZmFkYTFhMjcxMWVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjQxIlbghKw4YAokUZiMdjwOPQSo97cp2FsZW/tQ+exfYBHfB38yqUR7fk0EA\noyxqpj7h41PcAdZHsRGoJTEkt6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUao9IkFi9iAbLH26iPn/vnjAWfJIwHwYDVR0j\nBBgwFoAUMLXjFqv1BK+YCd4KSYEeZvWh52kwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCBhJF9irT2lpPsE2duEmaxW8mE\nR+tzZb/tDizPvLswSgIgVOZarju60x7YxZ1ksaq/+0eLH4yzTAIqNUDCUGkGav4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXR+u7PohMIg3HbQSk2n74ljMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmFhZjNmZC1lMmQ4LTRhMzAtYWQxNi05M2I1YWI2M2M5OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwuNc0BAnp3AYUs6zHN1s1i4gVP9JqWquiyLxA/TFam4Nf\nHnTJNwfdt5jNHL1AZ2i3PkI3z32VFWedN724/vXxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMLXjFqv1BK+YCd4KSYEeZvWh\n52kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKqdHktRiHYqDT3ytjQei34lL+T2Qw4sxToU9QGpQcpwAiEAgk7qgKuN\nakTr6+FOfXIls9UWbesExchCZ++I7aqNGCg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAdJk1VMcQeGy0yHwREUcDCLAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThlNTYwMTQtOWI3My00MGU0LTkzNjctZmFkYTFhMjcxMWVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzZjMjM2MGYtMzhhOC00\nNDdlLWFmNWMtNDg5MjIwNjJlZGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbf79cxE+R6UDy79rhMP3wB2PsxQzgqQHnyZkdO4HZqrUuW+F77PG1uik5EsbRNL3\nfgwNqYZ4+4K5y4YVXGPmQqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUao9IkFi9iAbLH26i\nPn/vnjAWfJIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAMHvR+K2H6XABoIcOjr+dtzFY2qBjiECEWbwJU2dFUwkAiEA\ng9iHav8TI2h5+uOCB+cZouHBZMX+ZgI5K5lHiLwxEm0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8486", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8486` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAX1qHD6UaHAtUZF0c+Xf10yEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxOGVhM2UxLWQxMzAtNGM1My1iZDZmLTlkNjg1YzVhMTNmNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2ZhODU3YWYtMjY3\nOC00NmE1LWJlNWItMDJlMDZhOTM4NTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESTtYSLAjKyDEb23c0/ewD4pfoE1e5h1qy2707b22wLSJla9pnXeQ5VkgnW5J\nS4HZ5OztdQbncMGo/0arSs01dqOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWDBA4toqZI00G+2hBiXY/DxsBsIwHwYDVR0j\nBBgwFoAUyIhfH1Lk62UNCJ2M2Iq84PVstFcwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAIz6Q/Xr\nai8CllHTbElhEZkNsBmVh/i7UPyRY5TLSLgFAiEAwhc5XI95NbNyHGl1tmYxtsI6\nJ7li1m3BmXwVltCch7I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZxkEjspBPkigha7DRHYKTd1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMThlYTNlMS1kMTMwLTRjNTMtYmQ2Zi05ZDY4NWM1YTEzZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmPp/mYvD1gPbBiOsgCwDuNT1KalSf4e6fCKMMxUHYqFol\nSUkKEo4OQIAobjsXdp/6M13sIZIc3tfQMRS7z2VNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyIhfH1Lk62UNCJ2M2Iq84PVs\ntFcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI2YfrguBUnijb9XABct46633GLCBoDheK6rlVCpiXHlAiAohWrmXSN3\n0qMo6Ml9I4SMwmJrAvgCGov9IpaGWdsQ/w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAban5nAYaJ3Uf2dUpp7ezcSjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2ZhODU3YWYtMjY3OC00NmE1LWJlNWItMDJlMDZhOTM4NTE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjhkN2JlODgtNWM0NC00\nYzY3LWFhOGQtZjFmZDQwMmQ0ZjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3L44/81kjWaTLCwpru/B1lBO1TCOVefN3Dy0dAB1P7XurHglpsMxf2xaaTjJeNXz\nk3V/SzZ1jVBBm0g8sy5I/qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWDBA4toqZI00G+2h\nBiXY/DxsBsIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgEHNBaxMi6HguRS4bVaSev6wEdlDnoc4LZvCfRmO/KosCIQDZ\n3TaL/V2j4B33XEbKvhKv8kVcCChlEUGZVEZzo6yScQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8487", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8487` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAUk8ANPM2Fx/Q1Wwpy8Udd86MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiZDhhNmQyLWZmYWYtNDE2Yi1hMWI1LTU1YjI5NzlhMDNhMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM5NWFhM2ItNmZl\nOS00OTg5LThmMDYtZGMwYTA5ZWY4Y2IwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPk+MbuRlB73dKauQCFiowkUahta1rfPtyvuuwp+oUt3xzZEXbDNIkcC/AwPA\n2qqGeO3VbCBjHR/JhHNPLmhQV6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVpMhoTYqGQGCGsJEG0Ywte5F0XUwHwYDVR0j\nBBgwFoAUxpChtVCGji0dIkl351EWIksBfQgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAJTSxtV2\n2ZvxuBhd7rpyyQbHH2JB+s33sjndobOt32cnAiEA0tdngo+hPKGdZ8YCDXRy04DT\nKY2EXvn6+rChOwju1W8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY9uC2Dim9oAi4gaf83B6eMWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmQ4YTZkMi1mZmFmLTQxNmItYTFiNS01NWIyOTc5YTAzYTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNMCVAb05/LhGuajhj9DNq4KBzmqxeK9ndvuHMPzaKNYV3\njhyCgM4OdOBIAGSXk02520Hz9rdlhEXBzdusNNJco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxpChtVCGji0dIkl351EWIksB\nfQgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNVK1CIaAeYo0CbVazJDq6065FSLfxTfK7ng9b6dY57QCIBRFNX2zTBbM\n4lXcXEFwLaDOfnXJeEXyWMtvMbrR+tcG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAYGHsiOeNSVxUFRvQtOr6/V0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM5NWFhM2ItNmZlOS00OTg5LThmMDYtZGMwYTA5ZWY4Y2IwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGI2ZmRkODItNTIwMS00\nYTllLTkyYTktN2RmOThhM2U2ZDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nait8UKpVH3fnevX12l+EV3mo+sZR2TuFJQRPPsDJkDviZH16Ht2KrxEQjKq8DXpu\nKBUZ0nqhSmFw9cS1ltS/G6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUVpMhoTYqGQGCGsJE\nG0Ywte5F0XUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgZGqGGzmKxwg1arIz2DV7Ve6G+ekraDxWXVRaZkrd7TYCIQDK\n0LRhkWlXN6bIlaqbNIMHjf/AIGR7znyVKHlYXlGKXQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8488", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8488` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAYDwjA8jPJ6Y/NK4Mf8i95YjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzMTgwM2FlLTQ2N2YtNGU1Yi05MmJhLTYxMzZkMzhmMDc0MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc1Yjc1NGUtYWI2\nNS00NGM4LWE1NzMtZWUwNmM0OWFlNWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqlrmptmvGww5JX1KOGql+cul1abqraJAO5TKiBNguejS55Fxot4iMjiMdtq7\noFXRcctZTImM/JUXMUx47bSTQqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkg5+4dVH447i4HvA3xD0qrpn6CUwHwYDVR0j\nBBgwFoAU3FFDoOZWgbeg/ZHbIc7jWbeOV48wLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIH04buiP\nlKuKSCCAdY3Ly3Dp4OTfDyR2a8CcouQr46NtAiEAtZWExPb26cySsxmoQQ37G5ST\n9fN7rXqIkQu9Qf//cmQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ+ne0YkX2cT8xDxFGKXUPj/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzE4MDNhZS00NjdmLTRlNWItOTJiYS02MTM2ZDM4ZjA3NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREXsNx3YSiPcXsjd0qEZE1v2VsaHiFF9fNQD5COyB5u3xG\nKeNooIx2RmE/PZLeKGY3Hvl6j31AcE1akbcxWyGyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3FFDoOZWgbeg/ZHbIc7jWbeO\nV48wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLT4eLnWjAFCrFCAX+XsB5tkVNzwLsTv90gh0xw3xkCcCIEAzDxedQZxo\nBHfK9W7pnBggnLloCVWQQEUZo2GI8Eos\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAefm/UwoZ8hG4ZaGWnIbqXbqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc1Yjc1NGUtYWI2NS00NGM4LWE1NzMtZWUwNmM0OWFlNWQyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmJhYWE4ZjAtOGU0Ni00\nY2Q1LTg4NTAtMzUyYzZhMzNiMDI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0xLMVbH50Mf47rIMFdb2eWFu47ICD+ZfCogwlo+P1tADrB4mJJnnTJJ/uEmTdkA7\nIeof480NnoFw+yXPeJ9coaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkg5+4dVH447i4HvA\n3xD0qrpn6CUwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgUsbRuGzJWG777B4Rv/U9PK+gI65Jh7kJylQLe3XEEzwCIQCh\nPvS6f9+xpltrglHtE/PJpAsw9iAiWCQ/4Bsw72FToA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8489", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8489` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAZRwq7spfu0XW1ycq6y0vjUHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViZTY5ZWJhLWU3ZDAtNGJkNS05MGMxLWIyZWJkNjc1NmQzZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ1MjdkYjAtNDI3\nNS00M2NjLWI2MGItZDQxMDJlMDMxNmNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE11KhE8QhmF1VNcY6xst6lkogScwDM/H9UayAM+GiByObTXQe8+qs2KSTPkch\nAFruHaXHjHUovVlEYr+UdvbkT6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV9l6+UosGvvuzNosMF20+BHDGlgwHwYDVR0j\nBBgwFoAU+upyBbM7Bvc7uY7Ausns175VdkUwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCOILR/ObVfnsXMAuifG+R4kIc2sDiSnsQkL214aryfawIgWn8fPNwo\nNH4RJseIj/YB5sHOD2Sbt86ETwZh9p4pXfo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUT7O1ELbFKy29JHy+PR3ayQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmU2OWViYS1lN2QwLTRiZDUtOTBjMS1iMmViZDY3NTZkM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATm0kZhVLT27NtBWoAoUPATQR/VAYlayG3Xj+4DcPAf3uuj\nNALHyfUI7XHY+XZaBtq5gYJEwTpB7ad49NddeuhZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+upyBbM7Bvc7uY7Ausns175V\ndkUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKgQsEaKSZE+LW1iB+UL1F+1yyDn7fv/Lui4oFEfps/kCIQCHHWR3AVLR\nOLmHhwN6twjaFZAtpFXi/5C4Ij8GH9lG5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAb/ZtbEcLWm2FJnvu3uouFLYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ1MjdkYjAtNDI3NS00M2NjLWI2MGItZDQxMDJlMDMxNmNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDY0ZTNkODQtMTQwMi00\nZDRjLTlhZDYtNDY3MjA5NTkzNmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDkHuwTuIUPMdfg0VJOEILuHCR3rPgZfJw4oADQujfBvTe/Feq7sVrETL7rRnSLS1\n4ELJsVtMLViNp9+rDfcQ8qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUV9l6+UosGvvuzNos\nMF20+BHDGlgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgBDXSQHbMAexGY8jxdLwuSstmZsYsVPhhHWzvwc8nGCcCIQC/\nvS2LrRGqpmAqnkH0JImwtDZ1mt2IwV5sXxUoB/pI7g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8490", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8490` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAa83yIZ4e7mdpfV7+/vQCmqvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyYjE0MmE3LTM0MDAtNDlkYi05Yjk0LTAzMmMyODY5ZTM5YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQyNzI2OGUtM2Rm\nMS00OTM4LWEyNmUtOTZhZGNmYjU4OWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFJjwge1LUttz07PnxvHDls6kaQU4IdKXE0nHL48ZBa//OgDQIh0eG4wM7odJ\ntLrMj7RYr15F5xGc3+45U3M53KOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4bjN7jeBZLM9JTN/03jCnnpXZk4wHwYDVR0j\nBBgwFoAUvpkrV+2gT1KGlS4ip3ZSkx0Nrj0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIAvglLuCwGTcIWoqPzZ2ogHBxGEPnrO28Ls37R12X/tIAiEA/rhbf9aO\nnGWXBUzosLFbqfBd8dksFGien6/zSBw85A4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcJ8u+7CVnIsai/5aDB0s2BAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmIxNDJhNy0zNDAwLTQ5ZGItOWI5NC0wMzJjMjg2OWUzOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6uMVar8d/qkyiHuXWfoUFIm3t46dSwO48cCUGP9/oRfvR\nLO2UYvr2K6WGmJmp/7nRWjMpvbTaUoxa22uPRbkso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvpkrV+2gT1KGlS4ip3ZSkx0N\nrj0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgV/zJTLW2YzkQbyLhja8hPKdibjGR423/eh343iB5BmECIHD0hXRsXya6\nAORqKzomgOsSrMlAnq1qgwwseAho5TRH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAXe1UGumPgqO429D8P1fJsMeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQyNzI2OGUtM2RmMS00OTM4LWEyNmUtOTZhZGNmYjU4OWI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODcyNjM3ZDYtMDczMy00\nMzE4LTg4MTMtMGNmOWY1MWY0ODM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/ht7s9em9yflpp+PovotCJx7zkeno8nch7+x1Pz3MT2BmJswoJzMB/i3CB3m1hfr\nLyHr/woXxqgHqtD5RfG2s6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4bjN7jeBZLM9JTN/\n03jCnnpXZk4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIge7xTy1rkVyC51YBETKEYMvW8qWHL9TghqZVjlpARL2QCIQCh\nWjnnnfs2AWs7lcpGA5CHpDH5BK5/AdM8itmHX/vKjQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8491", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8491` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTzCCAfagAwIBAgISAdtUlIONaUqW6Pcn8RrdB+AEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1YzY0YzNiLWMxODMtNDI1OC04NmEyLTU0ZTgxY2QwMWY5ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJjNTQ5NjctYzFh\nNi00NDYxLTkwMDEtMWMyNzg0NmE1MDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjzAY40qxV++43vHbEP6iM4NenL+UP+Pjnm7E5TYi6mHiXA1XBF+UD7WzzH9d\nwBzs++vc+0DKxpThqlmfzhQto6OBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcjd+hK7I+MKvAnSyDN4bGLM96KkwHwYDVR0j\nBBgwFoAUmFDdu6OYWF+6VPIq541XAq+2J7IwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQC\nIFEAWp36niyT9sj7OCG5L3QmgUPa6uGjuCRUW6Z7h/r9AiAU53MBZWwvbmzttfWl\n3MAa6/4/lL/N6ojf2Oyk8lF/fA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAadlox+rVjvZ+5joaMhAWYQ+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWM2NGMzYi1jMTgzLTQyNTgtODZhMi01NGU4MWNkMDFmOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFGcM0+vObylIhjDXGCQXzbGvJ+Y490yY6/4TnOiXRg8Wk\nn9S0XXtJ5Y22TCtFSFM1e4OvM0lIKzdxqtzinDU4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmFDdu6OYWF+6VPIq541XAq+2\nJ7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIiuaqdy97L9jDAQRa//oWpsqT++CBm0HZEmuPq02RZxAiAk81HrbJfK\n5D1ewN3Hm7iT5L3wNLw9S72GA0jNMG6amw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAWJFg8Pjb8Q/2nj5yfO44CBUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJjNTQ5NjctYzFhNi00NDYxLTkwMDEtMWMyNzg0NmE1MDM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWVhOTBkMjAtODkzNC00\nZDZiLTg1NjktYmZhMWQwMzY4OGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEtGoAv6qZ1gR2MbkgIvXRv47rSrRebNvnv8m6sO2gnAFegGbRmyr7OKe10aDtmEU\nWXejiI0Yd8Cqu0HFnayxgqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcjd+hK7I+MKvAnSy\nDN4bGLM96KkwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIC5ERFhTrvXp6cmXy/sLqj4vkWHTdsF/x1T2XbofpDuAiEA\n8s+LD0H33D9sWfmMk4qpVR3zCPWhPG3WsnXAq6FaTl4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8492", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8492` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAVphSAtIM1ywXalLQFPz6GemMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlNWEwZjhkLWNhZDUtNDczOC1hOGQ1LTVlNmE4YzNmMTEzOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU0NGM5NGYtMTBm\nOS00NzE5LTg5OTctNDkxNjIzMGQ2ZjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECJ/2H2eAMRGsMV0vd3wTIH+I5zEuWy+4IO0nfn8NY4abF6ySvUJSGMg4onof\nwyxSg1M2lD0mzpYxX4aNre5C36OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhE3xP4fn1XvsECMTGmTb1QQ8DFgwHwYDVR0j\nBBgwFoAUHjsZsJ1SwX3HyEFV88weQbeoBIwwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCVg865+paOIZfXZi2wfoO8F52DCXBJcQha6StZH4r0ywIh\nAKfgFbgZQ/MXG4i8vFBtEWtp3K3nJ0Q9jdzF9Y8ExDF3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXWsXA+vlYz+Y9Mw8JU56B26MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTVhMGY4ZC1jYWQ1LTQ3MzgtYThkNS01ZTZhOGMzZjExMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASa8rcY6uRw7+kq7WGTHggydO6o13r1FnBoPshWf8y7Mp0z\nVOVhCnKT2aejG8YuRUPWZ+Xcjjl/O2VF254IFevTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHjsZsJ1SwX3HyEFV88weQbeo\nBIwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZyn8uHDcDpWJDSWxwwmEWm5cUwhxoa28dB1uaDtQNtsCIQDwYlfjlZZG\nnyEQzmByLzdQwOC4HNsoalKG4FgrAeSxog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAc7VP5QXwKDwz0AIqarTgL2wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU0NGM5NGYtMTBmOS00NzE5LTg5OTctNDkxNjIzMGQ2ZjUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmVhOGFmNDUtM2NkMy00\nZjU2LTk0MTEtYjMyZjcwMDFmZTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nN+mz42MXhhiX78OdIZ/aO1wjnBciKyejB2imFbovK7G6ea6Bpp8HvpFgC8S9Mkj6\n+QzNfkfHhYbuuNddsiqxSaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhE3xP4fn1XvsECMT\nGmTb1QQ8DFgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIMU1yLu/Kkr4vrcIbVTlK3LfY3wO2jK+XA6gwTwjvj4AiEA\n1+nqWMIYF1f5TpmYd9RvVSyf02Pk1KqOMGhvNVDNaZY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8493", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8493` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAYr+UitaBsU2CeKgfFEpm81TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViZWI1MDcyLTg5MDEtNGNlOC1hNGJiLWY2ZjQzNzI4OWZhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjU1YTJiZTctM2Jj\nYy00OTZmLWIyNGMtNmFiNGYxOTAwOTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGssifSxetr90EnlX7GSug0xMPabrQpXswL1XmWhLdDUo8Xyh5Qji2ahZSwJX\nkm+CE7Nuk13hh+2SdJAZgSm2waOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU64EoO77aUhO28a19OddT8K7U8/gwHwYDVR0j\nBBgwFoAUW94Myz/9AV6MRdvTMzgFMVTwG40wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIAz5TTzskkkFL7uwlanqAeLSE4zxGDPtc/NHk7Q3vPWRAiEA\n4hUZHewvNFn/TZkocJvnVzX285oUQkhIIlyz/2w4Les=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAShasGwpuLViST/d7sJwOhZAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmViNTA3Mi04OTAxLTRjZTgtYTRiYi1mNmY0MzcyODlmYWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmiZh36Pm04YXYhfcCptyWjFE2hbcQ35P0QvudFbCSWDlf\na7cZxviB//O57LHwbHwBTNCax3MUZqN72+PF3TZ0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW94Myz/9AV6MRdvTMzgFMVTw\nG40wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMd8A+afqB2TM9cKrhB437IkcF5j8Ar5DGUV9xEBlP5LAiEA02FWto9c\nxUl9TCTSi3oXuuiijjYcMhJre6mB27Qo4CE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISATcsLDLosiU+ObNQsoIY0yH/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjU1YTJiZTctM2JjYy00OTZmLWIyNGMtNmFiNGYxOTAwOTU5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmUwZDFmNjMtYTgzZC00\nNmE2LThkMzEtZjZjYzQwOTMyOGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/dfREPQRjzG8LnlIXzRWAuGK7YwTCxU/iw3GoW1h2a5IUVV0IOf/DAAEHMWH4AhK\ncXPHyfQZT/6s4OD8u3cGqqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU64EoO77aUhO28a19\nOddT8K7U8/gwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgShbVBJI6dLoATy3dgZ+OC2qKh8nZNEiamXn74CbZNpQCIQD5\npuUYPh9ty1ESI6wYyQJhrd4KFkwmt8Y5iF9l3ZuUEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8494", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8494` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAQeM3otkTM9A2+Cj1zOWObOGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxZWNhYWIyLWU3YWUtNGYzYS1hM2ZiLWVkZjA1NTg1MmIwMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzAwY2Q5MWMtNDFm\nMC00MWU4LTg3NDYtYjM0YmE4NjQ5NTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1JayaMkFCUSmX/3Vnu3dH/9aHWzqPnaPmAyb5hDI9A7kKv0L78JD2PJUmvhv\nazQIxv6MEE+2KPfHaZ+aVNQ4lqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHj4unWVHWNs3Q93MSKy9mZkRzPIwHwYDVR0j\nBBgwFoAU0c1EoeOqMOxBYeM4WnzZeRuFPXUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIGCbOl2kucnd\ndhbb+159nFqeb/cbCvaQhUsHAb6Zo+6rAiAwG484mra3sBaGZxh2mbyNToJjKDl6\n1zBllVyuwHymlw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbl9yytFKAfz0vmuiRH6tQK+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWVjYWFiMi1lN2FlLTRmM2EtYTNmYi1lZGYwNTU4NTJiMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIDm552cY8vBRU127+src6IRsxBTs6BdIz5ypmNSguBM6i\nQvIwhgqDAZ7ALaUePANCN9zDQCpkDEt5eKss848ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0c1EoeOqMOxBYeM4WnzZeRuF\nPXUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOiRvunNE5Cl2AUcyiu9dqGSVReVaapiOWiXTGULIuEZAiAtAUs/hCrQ\niYuShigf22vij94b/SI8eLVQY/xcTUdYuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAQSYZbppY3vhYBn4IJTVyNRHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzAwY2Q5MWMtNDFmMC00MWU4LTg3NDYtYjM0YmE4NjQ5NTNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjY5OWQ0YjYtMWNmMC00\nN2U2LThmNDYtMDU2Y2ZkNmZjMTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsoyYx2c77Lq8VMCyZRehW5aD+0EQ/FhghdCreLsxeO29foen3rvfSLwcizTg+403\nfcARlWCosB0TeY0XCMnwUKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHj4unWVHWNs3Q93M\nSKy9mZkRzPIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgLwvUtPTvnwxj1XnBsG0RUyHfDyrJh1xtUysH+iCBKdMCIAEk\nuM56EjfIuUpAKIEuZ/ARNWwpY3THK+6iQCABcEol\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8495", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8495` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAZ8CpJ3u7JDeqZQrDF4+DXlAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2ZjgxNTE0LTJhNWItNGQxMy1hODY0LWVhMjIwNTg1ZWJkMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTY0NzMyYzMtOTZk\nNy00ZWNiLWJhMzctODYyMjY2NzY3ODNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN7rkkOqFC1zyn+o2R6ELHS11pdbnAPAZ5ra9w7vqVsnmgbRHjuUgyjbdJPeX\nlwTnPO5vf45DvTsnl9Ndu9HMl6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxeL4e0AzN9/StSI/4mm+SHrO+4wwHwYDVR0j\nBBgwFoAUWj4cW1GNjiPRFNDpOBjv5LAZ0aowNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgbc8GplepOGuFMrKFyouDo2x3VuTOR8J0yrH1lz3i5J8CIQCJHpfIsmq5\nKqc1k3mQnpHCWD/CUsGLP6QgkaD3CcPVKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU8vkaGqM0PiPVW8akmTvyt7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmY4MTUxNC0yYTViLTRkMTMtYTg2NC1lYTIyMDU4NWViZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi4ROFz0h21xTFduIZ1Bh7ZZCXWhwiJMTr5BxYyl3MpbmE\nLKd6tTff/N2JN8MQtiPkMY5/rPBG+a0qSU0RvlIio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWj4cW1GNjiPRFNDpOBjv5LAZ\n0aowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPCUn5q0FkgFL4ZW824/MKRFHnBNlJILhkLugNTAoIW6AiEA/UnNNk/C\n3WghFtxBC5YqfvyQRZlC71x35obOnAKnGp4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAV1iNSAskSTzfwDq/+FHe7OBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTY0NzMyYzMtOTZkNy00ZWNiLWJhMzctODYyMjY2NzY3ODNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmI3ODRiN2ItNjM4Ni00\nZGIyLWJmMTctOGU1OTE3ZDA4NWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkc/tPpwY6TZafIa0DTrBtpHghOtBByjaYfFTsxtepXSjdBdvqm/rufS7vUPSEe8C\n8DANVJElBamgkby4dh5MiaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxeL4e0AzN9/StSI/\n4mm+SHrO+4wwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhANLnEFXp1brPx4WR3x/ZN5rMrreQZCWQhOb58P2FtINfAiEA\n1vYS1GaQA1c0grsaH3bNkdBQWbHeLPUutKDm+Ijyz1Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8496", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8496` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAapBG9h+wjhM04VFpAlFJKMBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmYzc0Mzg4LWVkYTItNDc0OC04M2YzLWY3MDAzMTE4NjgwZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY3NjA5ZjAtMzQz\nYi00M2U2LTk0MTAtZjg1ODBhNzk5YjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpj186VMG+MvPORqpq9UZOY+Ps8LhppgOfu3KRUh0zSnOPgNFX4dL3DwJKnLX\nfZ6NJG+d4DO3CyJvvT2b3iFSJ6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrlTrUiWHRNOvf8XB6ukusYXlC0EwHwYDVR0j\nBBgwFoAUY9b9W4LWOqy83nl4Mgp1MLXS68swNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIfUfY0euouFN+5cVcubdHHHXFPnzcqhge+QxoicM7S7AIhALWgfLsAempu\n0rV8npenx+hPP/e6tLlN75Ss/1gq1Q6z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdebBhfkl50X9XuUxFkKj/diMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmM3NDM4OC1lZGEyLTQ3NDgtODNmMy1mNzAwMzExODY4MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHxyoLJcAUPwO55jgLeuAjqII0l219Q5EZxisNF+1LP2zQ\n7hxn76e7nGoGseINPbJl7cmv8Z1kNfHzeHipDdkRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY9b9W4LWOqy83nl4Mgp1MLXS\n68swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP8kCgvKNa7PSGaWkHKmSCkYMqX42uHjlduocw2VQqeeAiBF1cyokxXX\nG+Ci0+IsuZY6HfRoGaAx47fe4noXhYQhOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISASFPQVXen/mg+zvktnFzUmOcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY3NjA5ZjAtMzQzYi00M2U2LTk0MTAtZjg1ODBhNzk5YjExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjQwNmM1NDItMTUxZi00\nYWY0LWE4OWItY2RlODA4NDk2Y2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3T08cBJD60Yc+xno88Zk0CqYRIS28NMOoy7iLKvfDDLIyEw7EywJlmLOknUDfx+R\n9987fOe/fxiIvRvPHo1ZkqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrlTrUiWHRNOvf8XB\n6ukusYXlC0EwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhALg3hTbOQ1SOsOSpomj3HCH01K/SBDogZq1QnEixWjhSAiEA\nqvuQ86oZqPdbtxYG8dgh98HAS5p4LHsLkuqgdbQQtts=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8497", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8497` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARN46Hd2u02HdTYwud9cXsC+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzNWExZTIxLThjOGYtNDJlMi1hNzY2LTExNjE1N2U4ZGU0ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhkYjczZDQtNzI1\nZi00MDBjLWJiMzAtYTc5ZDIyNzhlODY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBW1e4mi/RBWALakwb+aHBMXuSl+9reJE+BXz29XyWwyJpFCTBztcnmyEwiaa\nOvJpMgXeyWHNSdPWKE3bH4vxfaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcbkMDaqC31B+cTt3qFonma/rx2kwHwYDVR0j\nBBgwFoAUF2WGOYrFY4dE5qLJPiv3IXVRKYUwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICHQIyXcvrIFZJPfV/DCIWqUy1OyWKjynP9lqKZKOewbAiEAk7M1heaR\n2RM036isl4+rj/GKGVynwBRqjzikxhik9R8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeUAoiI8yqTAy9BtOAb9E7glMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzVhMWUyMS04YzhmLTQyZTItYTc2Ni0xMTYxNTdlOGRlNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT66EsMrq85rwOJBHhDT6D2vpPskI9QYkAFmVk8clG9MIIC\nRIoPs4wn432qX/myw1VQx53C3qKt369ZSxDcuwi5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF2WGOYrFY4dE5qLJPiv3IXVR\nKYUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBx9Cc8nZv5g1Pqlmlf9cxztaMZlBYWDu11w3Agq9g5sCIQDnu/7oKc6s\ng7HKYBNzG9NqCgqIYEcq7QZsmeZE5zY5hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISARqMZ/ijh1lfNCy9fURhbGD9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhkYjczZDQtNzI1Zi00MDBjLWJiMzAtYTc5ZDIyNzhlODY4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzU1MjQxNDgtMWY0Yi00\nZTg1LTlkODYtZDlmNTA2YzFlNzViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDPbbTUdG8YM0kqIos6dkqF9zAoocpy+KRt0+DfDSFiRx9kXy5o/DeyWbg8CG+fwp\n2rbclLKQ38snx4raaz0K9qN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcbkMDaqC31B+cTt3\nqFonma/rx2kwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgU9NgNoOiyXg7pAVi/M1NscUww+TyHsc+1gLLfJ3vkQECIQCn\nER3tyuea9yppDmqpsAxHpC01ZNDUng9qqNknEV1BxQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8498", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8498` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISATaaM6sIeEcCg+o1DJzVkhH2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkZWM4MTk5LTAxNDAtNGIyOS1hNzA3LTBmZjYyYjU5ZjAxNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDgyZWRmNWItYzUy\nZC00ZDFkLTlmM2EtYzhkZjk4ZmZkZDFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESeNSiSuxer8MIsISteh/vcQ/NtUwVhV1JgDpCuy9F55kKC2L/beZofcDPhvw\nMwKi+uPQ8f7A37wAyl/tvmaK16OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Gwr9+yG/WYeoQda6lZIx9g6nxswHwYDVR0j\nBBgwFoAUr5I7Z/pOmWuR/oW6BUcrgLcc8+kwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIB+nvR4DsuIIiW1Lwyf7vUnIY7gnd+tN2ZtIXbKI\nHXX5AiBa1NgogZerWYex34L9aebzfWzetTwW1eBPuzJPrTY6tA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaYgEKK+o+3Ovs8Q5jg+ekItMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGVjODE5OS0wMTQwLTRiMjktYTcwNy0wZmY2MmI1OWYwMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbPMx2r7/54//Sm3Ns2+t+V5l1Xiyx4ukgBTseRdkltiWT\nn9AH0LqTjek6nNmnzlLZv0rUg7cRRqvXIBZQ7vRAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr5I7Z/pOmWuR/oW6BUcrgLcc\n8+kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMrenAFIKoneTxet696FPh75sPAf05xTNueAaopN16zpAiAbaghF109E\n8Ptp1nSEx/Ib0oSmmmetOmbV7jeVaDtEGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAcV+npas8liG4m2p6OTieGyaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDgyZWRmNWItYzUyZC00ZDFkLTlmM2EtYzhkZjk4ZmZkZDFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjAwMzQ5MTgtMDBmNS00\nYjRhLTllNjctZWQyZTExOTc4YmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCzUxZ+bKXTZPVujhDrsSri+BYA4cmDUPTkOrZwnNkCL5FSSMFrYknMAeb0eDB30V\n0Blho/A8h3UdudfATrvykKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5Gwr9+yG/WYeoQda\n6lZIx9g6nxswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAM2YZozmm4tfzv4bJHEkxTrvQce+bugJr+25uqmk9TsrAiBG\nAVyamRYEz7Wd6Nggu/rcopYk6W1RaUMgS4dH+poZIA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8499", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8499` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVeSMqJHAEU3JZMIp08l8RpMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxN2Y1MjFjLWYyN2ItNDg3Mi04MmYyLWM3MjUxYWQxZDBhNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE0ZjBjNjItMzU3\nMC00MDkyLTk0YzEtMDQ0NDg0OGQ3OWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGb877meZ1JteG653azhsqJXCjqRSe//iGnMh3YWkK2y2MYhVDtKdP4c0Xo9K\noK7qX9OIYT6OqHTC9qPxu92mtKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh2n6VDwCNiEHKnRhDK4+uCfyCwowHwYDVR0j\nBBgwFoAUbh8bHZecJj0K44ZHPw+djU27rX4wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQD2fcBFzRMurobIm3yp0pkj7uPpbf4/Xu0a0RM3\nxURQLQIgeUCMKakZZ51KOaz9GVdU1yNiaU1lvu8ZZ1xqVvPGyoY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWvZs16A3VeRdn+PNc5HnHxZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMTdmNTIxYy1mMjdiLTQ4NzItODJmMi1jNzI1MWFkMWQwYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZ/Q/TffCnengB3vrGurYRjRqSHf3qylOUnsSjTrofK1+O\nBJA5oyqez9Vlh9CVGDQ0Dre5yLuTjXc2gTOmjbtco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbh8bHZecJj0K44ZHPw+djU27\nrX4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPt5Cedt7Wc7gUwbZedj9wfYDiEHLEovWvLKWwMIIBONAiEAts4ozKwp\nbNXj3K8EDGXoVPkPqn8043X6FS8UtGlBC4I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAcOszu1kcT6v2BjEWvXhRmchMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE0ZjBjNjItMzU3MC00MDkyLTk0YzEtMDQ0NDg0OGQ3OWJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmI4ZjNiMWItY2VkMi00\nOThlLThiYTYtYjUyYTQ2M2Q2Njk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMQl1Dg6ZUOyWW41Nk5Geuud+iK+pBxvSBHGzG7AgBwwJW9XMsI7pR97C+og112Cy\nn6qi25EMEd1pFc4Bs8wWCqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUh2n6VDwCNiEHKnRh\nDK4+uCfyCwowHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAPwEVuat/SYcwz3i9CsqcRht0HBRNN3/YnUhchoVUA2iAiEA\niFoSlXTuRelpajc7ki/hXV1OPOdvCmDDEhkGcPVWQMA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8500", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8500` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISATaBaYkEcPDCWl0ErPXe5LtHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQwN2MwMjhlLTI4ZjAtNDdjNi05MjQzLTE4NWMzY2Y4MmY2MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZlNzg4MTEtMmMw\nNi00NjJmLTg2YWMtN2JlOTkxOWM1YzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIarJARu8TXRX2VXiwIULj2CygyxbmYUTtCRlVD3mT6WSp/P0tY6jvWxAmsiu\nj85OjzG9bKC2EbPnN4Uvlp8FsKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc0fIvd7+IWg5TUof9FYU5o3ofaIwHwYDVR0j\nBBgwFoAUnH9nD82jkL7AQ8y4w8X9lfB1CCswPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCObV4H25GsQm0lcxFAawCCgk2f9OpWaqEBcZELwZM0fgIg\nGzdaFSX65bSb9pFqQ3oT3smd1DWt9vyDzgXuuMKNrJM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWxvRhMb9lO5gBLZjIDkvEeDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMDdjMDI4ZS0yOGYwLTQ3YzYtOTI0My0xODVjM2NmODJmNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASvumgsv2uzzznKKG8mOJPwJpyaH3O1lLzDxV8ybBvU70ye\nyKDhOT+ZkTgK5B/ww6xW725JzgS/MK0VJ2KGgxL9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnH9nD82jkL7AQ8y4w8X9lfB1\nCCswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLNmPNS7u+35WNjDw/hQSVndNGuqpu4OjQK3sYEnC1rgCIQDmXgEmeiO3\nmvQV4tkBXlzQcJO4alYjuQG4hzOqBGMx/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAdNGyraCDXWtbbnmY9yA+sAeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZlNzg4MTEtMmMwNi00NjJmLTg2YWMtN2JlOTkxOWM1YzgzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWMwZjczMDQtN2I5NS00\nZDYwLWFhYzMtYTNmZjQyYzNlOTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/W7VNp5cpuqzBI/dC0Xw71WPLsIJGthh1Nlef9bHtQ50vorhmLIEz9zbAhZoS1e/\nICL3b3v6ZnGxmoigNa5mxKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUc0fIvd7+IWg5TUof\n9FYU5o3ofaIwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgLm4E5gNOnzMYwqafU7MX4ZsewY5LkDPOjlZFal2mwhYCIQDf\n/iJs4JbOLETrKGbUanh8lxE5eaUwPqJOlXB9ZM/wcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8501", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8501` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAbZrZ4KULf04r2J9OGU1fpkHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhMDAzMGVmLWRjZGYtNDJjYy04MzM5LWVhYzE2OWQyMGZhNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2JjNDg0YjEtNjA1\nMS00Y2ZlLWIxN2YtODIyZGQ3YTA4ZmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJei06N4D4uHEqFXAs7CGNnBx+xuyVokObh1GkUiw1waw5WmI/8Q2Bf/8czNh\nVH0bgBq4dtPAwUrnElb6OGU1n6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYwRwWxX5u2huA7Ueu9CWInIlChgwHwYDVR0j\nBBgwFoAUaHmUbn2r0JEobaitW7DdTT5E3l8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQClM2jtzq/LU+OkYaAPirTHBR8sxIId\nrkpc2cEx0I+UhAIhAKeips1s3ol79gxYqWUYcMWvVYwSi7/4cxXsstr5ERqm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXao0cqpxOFUSfQ0t1evPAthMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTAwMzBlZi1kY2RmLTQyY2MtODMzOS1lYWMxNjlkMjBmYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5iSANg9GpOqR8z6lYENiWZGPISuPgMwiwUXU22eUZU+ke\nRU6E/vWtk3WNhkMXctO++Sj/2202QY91L+vxAm/0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaHmUbn2r0JEobaitW7DdTT5E\n3l8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK5a0Bej19HgV/pLvs+3urxjXFj528tnrhzuXcy2yGwcAiB3E43gFy77\nRMVg6UtNt3TJ9iPmlQm47HLaxn3oOsgY+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAWpi6xEr8sVCdhSELHjcaZJxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2JjNDg0YjEtNjA1MS00Y2ZlLWIxN2YtODIyZGQ3YTA4ZmEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmM5ODE1ZmItM2U4Ny00\nMTAwLTkyMWMtZmJlNmI1NzlkYzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHfkqBvBfhilBeZrfIlJc0zd/BvtsEQxINdrGTOkSWUWWu/e4JJPB825vSLi9kTQM\nukYRVK14VwyD5F3W7jr0WaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYwRwWxX5u2huA7Ue\nu9CWInIlChgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgVbbgC121JeX/9wLQIWA0edOeUwvbW7sKx0lS7br4rAkCIGi/\nrY/HE0btcjEr/qOAfmHy8XtYXszZZi4+Mx241erw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8502", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8502` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAR8k3EB7kX7f1YTcNcZOg6ygMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkZWEyMjZlLTcxYjktNDc5Mi05NzhjLWQ2MzBjNzNhYTkxNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk5NGQ4YzUtNWNm\nMi00NWFjLWJiNmYtZmE4YTUyZjE0ZmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOpb2zwXJCkQHvzfuOrKptWboCtnrbmH1jqmc3t7QE6FBp7jUI27IrKaeKXnp\nEkFwtd8dzbQkJMIVZxzzgyqF0qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt7HAqs1ro2Zd5cDiwQSYTrrm/ncwHwYDVR0j\nBBgwFoAUH2ZWUFvYgRCBHotgTnXIeJ39QRwwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQDBENJNc9OVEawtFVSWr1dj15/4wkGK\nG112v77kaY01UgIhAJ11gR6xHpOMOX2DHyRmlC4wW86Q/eLJdZfsF/lSjUm5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaPSOrBGUgR8ds0BN9jI1rTsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGVhMjI2ZS03MWI5LTQ3OTItOTc4Yy1kNjMwYzczYWE5MTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZUsQ59Skyl/Gzd3nFXHbWKsVfPfzfQsEluWpNMr1bjJNe\n435veaGjMtLuR5kHfAz0KHE4qACw8zuz8RoSo4h8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH2ZWUFvYgRCBHotgTnXIeJ39\nQRwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALBJlnqSpKg6kpb0y82/9e6PK2NM6TbWtg3gqV+2wJk7AiBMZLTTC1Qv\n8DadL24T69oLk9OF0GiVf4YpU2Oz9eGhXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISATn1Sol42+JQ3RncouMJx5kgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk5NGQ4YzUtNWNmMi00NWFjLWJiNmYtZmE4YTUyZjE0ZmJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTI2MTJjNmQtMmJlNi00\nZmQzLTliYTktMGZlN2NhMWUxMDYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTcn0eODOWA+nGMRt2bUqqz7/VJURS5LOL8AYNp+AUbOKW6tZTvihkocyz2VQcA45\nbl1cxF6IH5Y59ikIa7LSrqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUt7HAqs1ro2Zd5cDi\nwQSYTrrm/ncwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIgcgAfXanUKXRB6Q1qCIsdS39FyuI190zQKHIYS0u8sg0CIQDr\nxdI3JALx37BOTYAAKK+LdBJ4N2uU9z6JESJ6bptMAw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8503", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8503` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAbTRKeMIe21Gd8318pKqO0jqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YTVjZjg0LWUwNDgtNDMzYS05OGM4LTZiZTRmZGQ3MGIxZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY2MzA4NGMtYjQ1\nYy00MzkzLWJmZWMtODUzZGJhZjFlMGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHySZfOIpk3Zx3U3oQa42CtpHZNeF8VYLozKQJPXqF9Zvr/gLEttFWoK0TuuB\nLQI1AgJ+F8R9MvTrWlsvwixeU6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUELSBEHNMeLT/FZwdNLZsXdYsFi0wHwYDVR0j\nBBgwFoAUPK+weQzCRl8Phs3+ZVP0Rd8D/vUwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCICpdzFCQW48p\n54ngM1kkGWD/9PnHkMM6xtNEOG4B0dgNAiEAuEnaPQDUsCGP4bxvu39yuLHClov7\nhDoMrzh21MmWYhg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcXXC7yO0roToDrix24N16TuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2E1Y2Y4NC1lMDQ4LTQzM2EtOThjOC02YmU0ZmRkNzBiMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS3RRdxZpw+hX3LvgCpjE85jR/FJwhgOTSi84FrFyMfwpxj\nznVHnKvp+OTgSU3nVThM657iKP7cQODQUzsat++no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPK+weQzCRl8Phs3+ZVP0Rd8D\n/vUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO4caMn4kI48+1v+M9odahi4qQLOS7iP9Jz629VELuO5AiBRHmR8GpwQ\ntYYdO2NIX0zjDxdp9d/Xir4ESALVQ110Bg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAa9vGo+LAu0Ek79lDk4CvwyrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY2MzA4NGMtYjQ1Yy00MzkzLWJmZWMtODUzZGJhZjFlMGY5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWJmMjk5ZDYtY2QzZS00\nN2I2LWExYzYtNmRlMjJhOGY5ZDI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4uN73cJ0VgYwvDJI/MrSi18fC0XMxlAylUF9Mlqyd7YzX1aA5BdoWFklXZt2Xg3m\nSiHmsC3+pcLuuI5T3uxu1aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUELSBEHNMeLT/FZwd\nNLZsXdYsFi0wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAMR6oWQFARMjxgV/mnO90JSogX6Cmtveu6GbDAkTUHvrAiB6\nAzoWPt/ReodqzTjhpW3YluXzaXp4JxMGHW+DJn3HcA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8504", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8504` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAeI7DN9AlZrw8pqugEII6waRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3OTlkMThjLTA5YjItNGJmMi1iMWQ1LTY1ZDU3Y2I4OWVmYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZiNzE3OTgtMjBk\nNi00NDY2LTg5YWItYTJlYTNmNGEwOTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdu8hNv4tEwj16Oo0Ksv1gqKZUz41IeBpd9NcQMCZT4ULfdsNQhEEBz1B6Pt5\nZLkIlhmtES+7kJoKpNhBYF6LSaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Qs11BMR4Vq0rkWOUaEmyjXWpFAwHwYDVR0j\nBBgwFoAU44YG0XQ/3KjbTfjsq1G2rRlXyaUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgIvd7EllJCZo2Ekszm6uPm8Cv26UTdF0/P1rrRWrYUTYCIExJXCIufHd2\nC4HmO30xAe498DVF8U+hLDiAA0ny3XRb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdc7m138LBeeN17kyzosImavMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzk5ZDE4Yy0wOWIyLTRiZjItYjFkNS02NWQ1N2NiODllZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/2mW3hOQ6xgFRYFcj/sdoMqBfHibS3nRYoJIGWGDr4m13\n8uh00+7OsqebiVEd8H8N1F9Ir0VaP3DB3grqvgs6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU44YG0XQ/3KjbTfjsq1G2rRlX\nyaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJgdZESdoK57zdXvc1JCidmbvYeldyNefJFRjqQiAAONAiBI8B3OVwik\nveJyEZR6kW+mpO4G1aoqPFUBBO51MGzwMw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAaV3lp/+YEZzmTt0aAHFCFJzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZiNzE3OTgtMjBkNi00NDY2LTg5YWItYTJlYTNmNGEwOTAwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzkxMWY0ZTUtZmU0OS00\nZTBiLWJlNTItNWI5OGE1ZTQ2YzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJlt1ouPk9hhe/C3ewQjBuluOEovI0QjQprFEblfwClFC677P0P1dm8U+9aM4CA3W\nxzRK75d9Bxck4dNuL8AYG6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1Qs11BMR4Vq0rkWO\nUaEmyjXWpFAwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhANYN5qgmdaCjeO5HdlxXBCBeAK/2pZREChIZ7Y36UorWAiEA\nk+oz6317+QSc0QT4PMJxALhYUhj/MlFDwg2Y/aXw6s0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8505", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8505` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAS9wSiaTtmSA+Y8uCm0sEiCpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5OTA4ZGZmLWY3ZDgtNDdkYi1iYjE5LTA4MzU1ZTMyZjViYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM3NTIzYWUtNTU1\nMi00YThiLWIzZmEtZjU4NDM1MGM5OTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzv1hL3ONIEESxRtxlr923CCgIL9fxJMu14lPUlm+2v7Ko2SuXCiWwD+gou9c\nwJSUb0NRn9Hopz/K2MnpZk8DCKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYWTnqutvPk4FhNE8r+QbitnvGVswHwYDVR0j\nBBgwFoAU25/yDpOVrb54g3eRxt0y2uJQ3SAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhALxG8/DAwo2aCCQCizgyFoov6fdVQFSOFAi+SS6wjElsAiEAr39EAvEy\nq+2VC4OPkRx9f4flhwIG22SecTpB6RlrVDA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUWZ8ovInjmVC8/+iA7NMzb2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTkwOGRmZi1mN2Q4LTQ3ZGItYmIxOS0wODM1NWUzMmY1YmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/y0DJ8pJeSJ5mznicKi/NvhM3bBJsAYoee/vcd+CCPbAJ\nNz9gPR+5ukHdkkaaptewCS7a4JcqdFA3ysE3ef8Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU25/yDpOVrb54g3eRxt0y2uJQ\n3SAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUHScawZCC9J3OgWngGdQmPtAuRRt/1z2gfP01tR9KaECIQDBkSuKqVTP\nYxnFZ93a1+sFmPDKSPWUw1X5u5nlS+vCyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAcLJnAH9O+oGnY2okYHsE5kSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM3NTIzYWUtNTU1Mi00YThiLWIzZmEtZjU4NDM1MGM5OTM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjk3N2U1OGUtOTM4MS00\nOTEzLWI0NjAtNjU5OWNhMmJiNWIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4McaxcR0nuMIS87yDMPGaJY0fURbuVSUnMdFpmXB1ksU/EbM2muTowtElYEOhSux\nMaCb5KYrTDwibzkGZM1ZUKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYWTnqutvPk4FhNE8\nr+QbitnvGVswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIHJJ5jYPdMmoDp030MGBfoTTlXIANaXqsoHpvZ4sYE6AiEA\np6YClPTcs9wp0PnypqUgpPuQLCC4wIzs5CxmHEQP57s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8506", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8506` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeI+WQqGb4kokwasUH0Sqr08MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4YmZiNzBhLTI1MmQtNDBhOC04OThhLTcwYTRjNmM2ZjA2NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGUyZDdkNjYtYWQy\nYy00MWFkLTkwYmEtOWE5MjgxZDYwMWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERU6rw4EI5V/X14+efs0rhY8UaWxSoE36UjFTVEU+D9QizyAkhjDARepyB1ZW\nwhleWrhqpAlWs7yNCGricO1rRKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEdm2oihXtrzlCJN7T4p4dv6ihvMwHwYDVR0j\nBBgwFoAUPNrc09SALBZWJvHuUPrwft4o2nswOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIB9E75u0Nm9nEDmWGNeUmK944442jXajhs1T8SLbnLr5AiEAhmyogLRD\nKHeIQu2JYbx0j2WCRRkGPOrsan1Cjla0ng4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaQT697K/HcT6VSQyXoi+9BfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGJmYjcwYS0yNTJkLTQwYTgtODk4YS03MGE0YzZjNmYwNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARO36Q3+8IIZ/52J9UeG6UWbIPI24LBXqLyo9MUb/GOi8SS\n+KT/b1yBi/xFddCsyDi25IDutM3Uw1lipoeWHE+lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPNrc09SALBZWJvHuUPrwft4o\n2nswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDyNYr+gTMSY02xWsQawoPEKN1W5qQc7uW6ZcHS58oTkCIQDRQ183uIX1\nhh1q2Kol2GhikEn44SfnT5z2AduZq5sEtw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdGgAwIBAgISAZnsaXxAKSVK5LqOF0Jlg5pXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGUyZDdkNjYtYWQyYy00MWFkLTkwYmEtOWE5MjgxZDYwMWJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWIwNzQxODUtZGIxNy00\nYzU4LTgwZDktYWNhNzY3MzcxNDUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXvs4EGHEC28uEXnW/Ap3jl404dxz/KvclXKFfXLZNOw1+J1pPSgKiiOkXdS5cHme\nfe9pXK2tO1/1r51dnlw4XKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEdm2oihXtrzlCJN7\nT4p4dv6ihvMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSAAwRQIhAOGcsXY1XFq6sBIlXwXih3vBx6krpPGqE6izB8wz3RQ5AiBD\nfLsrbJhPt/aJhIyKeWh5YYDZqrSdXFJnu7KG0BSjoA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8507", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8507` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAaDDTaccuWnhCsU0bVtPuPVaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4MGZjNGI3LWQ3YmUtNDc4MS1iZTA3LWI3MDAxMGI5YTFiNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBkY2FhYmItYjU5\nZi00MTI3LWFjNDktNzY0MzhhNzdiZDg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERhS0sRz8ELAMC5bvmJd++5kPzbnZk1u/P0j7a6V+xfq+yqBJ7BloCNKG/Mby\npUleQbFlQlwTqFbd8PGHs6fHraOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUocLLwvQC6rI4BNrxHZ96T/q5rL4wHwYDVR0j\nBBgwFoAUU6o/Qh4EPCTdT+eeIlcaWcCw1DgwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIHH+KzbPn5MJHe7Ux5p6Bkb5IvfPPtJQpeI8NQ/D\n+xuxAiBcwTsAif2t9gCRdUBVt2OvEqoGr09m5cGC32TWDND8IQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARxsZ3ILeHgsd2rIrZyWI5neMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODBmYzRiNy1kN2JlLTQ3ODEtYmUwNy1iNzAwMTBiOWExYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSMSJRJoWYc8LUVfE6nw6nbsXVix1d5Fy+9OXT5hcK/rEO\nPmTKyY9IFR3L/80r+KlV8lp0/HkUlvVLyVRMkwgEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU6o/Qh4EPCTdT+eeIlcaWcCw\n1DgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBV9XYiKXbz420ymRv0HreUGB5PO6jt+8DgJ8TPsD1TcCIQD1uLRIC5zC\nbJLLbpM+fzggXOw1HamrZhWCo2Qc93G9Zw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAZSEv9FDizgFM+CFqzqt5XyhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBkY2FhYmItYjU5Zi00MTI3LWFjNDktNzY0MzhhNzdiZDg4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTEyMjE5ZTAtNzNjNS00\nNjFkLWI2NTItYWU1YTA0NThmMTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqexlWKZmCze8Et+BrGwG1DOFFn7+jhkSpRkk99gpVBUsNUxKfo51WS3uMWskVFK7\n98bG9NNBf/S3OR4MY+BOmqN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUocLLwvQC6rI4BNrx\nHZ96T/q5rL4wHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIvwDLFitnmpcwfLHvx0x4PzRPuFtWKrnsi4c/zMoHFpAiEA\nna5R8zoyOlYAztHc155i6DI8lZbijCvUVFKVBJkibmY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8508", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8508` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISASxzf6AH8daHV047ef35z3JoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjOTI1ZDA5LTQ3YTItNDhhYy1iNzNiLWY3OWNiMzBlMzU1ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFiZjhhMzktNjhm\nYi00Yzc1LTg5NWEtZTU4M2NiNTcwNGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE13Y3E3QGCcveATVilhgkqomQtvBPjsSiLRgaGO9t/Kr9LHnp4P9OAjadVLZb\nTM80f2i8pSxGHoePCuqBdbRtC6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA+0RTar3Ft9MJgk4FvV5EPjVPxMwHwYDVR0j\nBBgwFoAUabIkQA7mxgF5zG/+ynuNDtN2mPkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIDNk3CqxF9t98Q9g2Q90CBkp18l6PziBmNfrNPic\nElmUAiEA+DxawCHRf3BmfIaI4f0ykkVa4nCYYhE2zDCGqrPW6bQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdU6tMuN9A1itohiFup3x9nyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzkyNWQwOS00N2EyLTQ4YWMtYjczYi1mNzljYjMwZTM1NTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwchYv6pO7XZH3eikNGzw5HDzH4tlPW5SQQLpKeoOfRsUJ\nxwec8tubRHQBVn5be9TySr6f0GAEfYeH4EmDlJBEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUabIkQA7mxgF5zG/+ynuNDtN2\nmPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJvzolpGN9OBEKfndrlCbv6XAYBbnBIisP4/2imUGtImAiArWGQxFzlo\ny7OHd01ZvQMp6DyP7G8hSEJR3BIxtMwZWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKjCCAdGgAwIBAgISAWF9Fjvsqex++FCuD1zSKRcZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFiZjhhMzktNjhmYi00Yzc1LTg5NWEtZTU4M2NiNTcwNGNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGY1ZmZjZTUtMmM1My00\nOTIwLWI4YjUtNWY1NmY3N2VlMzBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsN2MawtVepgQvYgOEy1hCiXfWTPSWrVi9SlLN5zSn9/t5qqG08U4VgJPEF+8ebC7\nAMt7X7zWCEHaJ0xPRoPNjaN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUA+0RTar3Ft9MJgk4\nFvV5EPjVPxMwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDRwAwRAIgD3WC+agd29p5g6zpDARu+it226Xp+ZkjzUoDRxd9V3ECIEHf\nfKocVJuagZk7I3dS9fv5SJcPDbJTUtMJjkORu6uQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8509", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8509` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAb+5Bz4LtXjfazBNSGqc+ronMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5NGFmODRiLTc3ZmQtNGNlNC1hYjM2LWMyNzk1OWVhMGM0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGNkOTkyYzAtMmRh\nNC00ZGRhLWE0NzYtMzc1NmYxZDk3N2RmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkjvWVrmcrDPEZC43UZ6UmvsiViiByqvHT3j0O0RhFSwb0L1iELQDScNlsK/h\nP3y179ZlHBhkXkwH1Wn/6DU1y6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY8GOdERy0hAMUiIi/BV+Rvs0AUswHwYDVR0j\nBBgwFoAUwuHC33w0KJtBS30hUk9oH5dHq5wwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQCpP8B9Mpij6nEckXUsbMZuwBh++yoZrc083c+h6cJoIQIg\nG8uXiJHLcPZqkGdDo+aU08hSEnUTZPipQSjqu6s6joc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVT112006fPSXG9B75XhVo6NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTRhZjg0Yi03N2ZkLTRjZTQtYWIzNi1jMjc5NTllYTBjNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9/Ff0czR1rCUjlzZsQUlY193vtBwdvGc8NlxwqaCj8skc\nS/bqMgeoV5FoEUebTI6A5HLMK5aC3KtTZAM5wpoKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwuHC33w0KJtBS30hUk9oH5dH\nq5wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbdKK3Qp0ONky/SdQtpI7ARsLjaXW4ACDuyFMpbC8wjsCIDZ2kMwjHhk3\nGaZwrqE5K7uBU651ESuR7KkcmbzsPAZ6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAXVu05NKOM0PWgz50WQW2F2+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGNkOTkyYzAtMmRhNC00ZGRhLWE0NzYtMzc1NmYxZDk3N2RmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWEyZjNmYzUtODdlMS00\nYzBiLWE3ZmYtNTJlYTNmNjE3OTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0ttyhSve1cf5K2BFUCHWcF7tmYs3BycY77+eWLCPP8JJWeakFjm3M1vLExc9ZfTJ\n7zsHdjW3BSZhuVhq9kUx6aN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUY8GOdERy0hAMUiIi\n/BV+Rvs0AUswHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAIC3c1OzYPf4rGuCcBk/B4kbeeTN8QeVZz0pCEpxviqgAiEA\n6yWxw54aTjj+AP9Iat6qXYvoSnZj+pyhTq+74+P1mRQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8510", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8510` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUNY0ubq4+unPAaqJnapkEHvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlNzY3MGQ1LTMwMWQtNGFiOS1iMjczLTdjZjdkMjRhMzEyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGE3NTVjMDktNGMy\nNC00NDFjLThkNWQtNDAwMjk0NDBhOGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDXbp6W2CnNE15TPdZrVde+dsi2d9dhKKJ9VHJv9Z/Eg/EyhKCvqakDT8k+BU\nNGVBDCQem6y6IhXIHH2LfPX9jqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWU9QhcnoXKHnjUbkKFSvK2CvJOgwHwYDVR0j\nBBgwFoAUWx+0RMaY8KoVQpFLw8UbS289P9kwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIAGHUv0Sv41Y5cT3C+u1+gBDhrbXM3P7\ndUxwvej4tBfmAiEAp0DQBgpVbs5s0zVJqjZuRUx+OyTKUbBZAiEnjxRbxfU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcmKx9uBBYlLKYvV2otr7h0KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTc2NzBkNS0zMDFkLTRhYjktYjI3My03Y2Y3ZDI0YTMxMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1zRl6uVfeDpFUZjv7DQkc6hKx7oK74TdydrHSjN9n6xLn\n4U/KNWiVDdAuKUcUhh8l7upOtLlPiucg99MAX+R2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWx+0RMaY8KoVQpFLw8UbS289\nP9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALBf2vI5erDvzkCsnDatd1gghgynEsNT53LQ9ykqgOaeAiAYWUrc1Yx4\nAOU3VUFtsYB2EyD1z/zQh7VHgRFVUUHqcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAfSpH49FQ3i+IQ0/CpEbsCoFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGE3NTVjMDktNGMyNC00NDFjLThkNWQtNDAwMjk0NDBhOGI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2RjNTM2YzUtZDhlNC00\nMGRhLWI5ODMtYTU1ZTg2NDBhODJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxhrLYIFxROokwTj6nzkYF0yzCqui++mYRNZm061uAU9+aMCVzI3/cMv2sNYcs+WV\n4GVi5ef/YYwfYpTupzXgA6N3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWU9QhcnoXKHnjUbk\nKFSvK2CvJOgwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhALPwS1m1NDvktDC1qOpykEKFHURfldpCAVagsC+TnlteAiEA\n2Ejx9tu9YJGy1kg6g+DqDfNt8CpWrDTlxEKbQsmnNzs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8511", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8511` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAWCA6okjx1ibDLyByIpygCyBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1MDU0N2YxLTg4YjUtNDVkNi05OGM2LWQ5MWIyYzgzZTVmMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc3NjQ0NDYtZjEz\nZS00NzA4LWI2ZDMtMjIxMThkMjE1ZjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWIOMWBn5nGJp9QAwi5zhMkM3852LaeAj/m3KXRP8WY3ZR077sOfaqUbzgaNu\nbch9PIPtSzZP3C6/+VIunoGif6OBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAIAOdckXyQLl5dC8hZ1cO4pbf4cwHwYDVR0j\nBBgwFoAUE5sA0aj0ExvPRQ5UlXbRfnFIbV0wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIDx13bYLG0U9HHmm6fq1EG5v/4/q/xEm\nHPVjfbRPZpcqAiEAxbOOG4OVfTptKbLKgoHQ7aGeYArW6QvS1bDQENiikI4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb+uS/iA5Ys/Q5uU0PDRdjLpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTA1NDdmMS04OGI1LTQ1ZDYtOThjNi1kOTFiMmM4M2U1ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQz5RKX+r18OppK2fo93zjJ5YoSzqe1ATeM5KbPqM/ZjJWK\nIZCgk/mFvPJuW21Q+ETdKGRSiIoF2RwbWA5hq/pIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE5sA0aj0ExvPRQ5UlXbRfnFI\nbV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQOr9B8jXrwosWByXjWBHq6yBOhwe54FtgtUQQe5hwKcCIQDrTNH2HZNj\nebx35qt0A/NYvXA/ugpaKIwxiSc0j8r6jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdGgAwIBAgISAT5WtVg227yLd3V/j3RlQ3MZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc3NjQ0NDYtZjEzZS00NzA4LWI2ZDMtMjIxMThkMjE1ZjY1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGNlZDBhMGUtZWRiNi00\nY2MzLWJhZWUtMmJlMjY3NDczNTI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyK0Buz6eplbv62NmFzOx0WlYlFXcOJ2IMHFQwPPXYdpjG8e2kZN8nMfhdLMoj5e+\nle0mynk5te5x3NSL/QnGLKN3MHUwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAIAOdckXyQLl5dC8\nhZ1cO4pbf4cwHwYDVR0RBBgwFoIOdGVzdC5sb2NhbGhvc3SHBAEBAQEwCgYIKoZI\nzj0EAwIDSQAwRgIhAOX/jD9x0bY6e5ZwcP8IhbMv3EDIaWcMItQ5ENoQzDhoAiEA\nwaQ/ILLG8iXWEjmKVlSU7gJRQ+Ds5WREaT1JRR9B9pU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8512", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8512` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcCgAwIBAgISAbFcfnkRuLSCS6Q/dVWi+HUKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4NWZkNzM4LTlhZDctNDYwZS04NWVmLWJlOWExYmVlOTk1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIzYWJmNmQtOGI2\nYS00OGQ1LWEwZjctZTA2ZmE0N2UxYmJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVlaZ+hSm9cukBJ+6duJ9+D6KrUbEJ3DyvFxE+oaJCj9Op8o1cjbt1eEjRSP2\n412RQaYfmm6qy2lFmLGa64PRUqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKbFfFWeJBJjj0HGD5nbdOMyrVXVMB8GA1UdIwQY\nMBaAFB5gl9+4VXQqIHb5+Gs8OZu9E4wWMAoGCCqGSM49BAMCA0gAMEUCIF4tzZZZ\naAcDsD6ApwK17UiHl8/u2G/KAnmZtZKfGNx4AiEA4gKaJRHpcNmpkqIbZmPpq83f\nyrcOxb89k2fwpnn5mC0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVxldAlh/2xS3aK070SUTeKAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODVmZDczOC05YWQ3LTQ2MGUtODVlZi1iZTlhMWJlZTk5NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1Eb3KhIsI2fO/JCYlGs1mXMtcnN+doQtnx0uO7fCqHfUl\nW2ct4YVDvnMCnoh0BK+thUfB7j0oggx3yHuvpPxPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHmCX37hVdCogdvn4azw5m70T\njBYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANmNaunCE0snZar/W2INP24FbfuKXSxD37moJgH4FhTaAiEAiRMG/ajT\nKQs8XSakP+8yd8avVw2/2/B7aBZosoinRLY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAQu+Cn71JZm4m56LhD5b9C0AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIzYWJmNmQtOGI2YS00OGQ1LWEwZjctZTA2ZmE0N2UxYmJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODczMzAwNmQtNzgzMS00\nM2YxLTg4NGUtMmU0Mjk4MmUxODA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\npOCoetToluJoSuh4coJ1SrbHoOBYmlAnlB2fKE+JmXJRL55b3CVzhHTVgypMh86u\nmO2QhOTJKflLrCfhzlqD9qNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpsV8VZ4kEmOPQcYP\nmdt04zKtVdUwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIEigz4dxaYWCcKkyAaSVLbGUsPeKfzjHs11yL7h/2SI3AiAk1O+N1u61\nCikUwRKZdKxWKHmJ5lziO86mHYy8/qZ4eQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8513", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8513` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcu/FmwY0Nkoz+QtsgUZObsCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3NjM0ZTA3LTkyMzctNDAxYi1iM2I5LTllMDA3NGQzNWY3YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjIyZmJmM2UtZDkx\nZS00ZGZkLTgxMWQtZjdmNjIyZDExMTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFzNjZIg3fcwwvE5wBJfIHE2ItgtPJZxhqp0DeUN7W7WRdIHQ+Lex/eJPY+ES\nMLtOagcyd7lJ7rkte4ogwlHvg6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAR09IYnCtpBbrfc+sBWF9RkJbWeMB8GA1UdIwQY\nMBaAFM4fF4wzMLunNLZY4tj/VexEmCAaMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiA9no1uEHcguz9rqsVMR9K3Wt1o6+dMA88t\n3CUlX1AUjgIhALMcCgu9CwEcaQKeHsa1FPugMYVM+i+pOWZQHId7qBQS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa2NYepQvKP1gbVWK1bAFJ7eMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzYzNGUwNy05MjM3LTQwMWItYjNiOS05ZTAwNzRkMzVmN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhwF+OqMGVAxrd+0eskE1H10+XSoSavStglL6lh2SawsEz\nidkabQ+vM+ZYfwFpxEVgzojkpDCGLhGMs75gDvhZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzh8XjDMwu6c0tlji2P9V7ESY\nIBowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIlCytbZ/pJQvlkar7iiiBBAwlgIOPyX5xZz3GG5Hjz4CIQDlMPDobkm5\nE9SbwZDOxarsiMC2lYFs1EBWx2SDIAPxbg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAQ9XM3W+1j4B4rrpkmvoTcVAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjIyZmJmM2UtZDkxZS00ZGZkLTgxMWQtZjdmNjIyZDExMTA0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjUwNmRlZTctMGQ0YS00\nYjhhLTk0NTAtMzc5ZDVkNTFjOWE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nClyH0smcR+3YTF2rBOGPTmSZWdl9D4zwZaxgOMD26ras2JVrmjiaQ6tUIPYMFgwa\ne0PBzMSBxTW+vjdOfeYYgKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBHT0hicK2kFut9z6\nwFYX1GQltZ4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIDaACbPhN3iGRJCO0okbeI+zAuTn8C2AfVKgBekSJBQqAiADc1mpM3BP\nMCOTnnus2mwDgzYIYuk1RBj/Tt6d+/matw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8514", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8514` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAaVeiuJPlcyn6U4+784/Y2FUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YjBkMmIxLTUzODMtNGM3ZS1hYzg2LWNjMmIxYWJiODIzMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjYyNTQ2NjItZjU1\nNS00ZjFjLWE5OTgtN2U2YTZiMGZlYjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/tNzX1Nrp5Bv5gWwB/hvPqZVYwPve9UGMGaSiANtbSsMXPWyGfbYggNNKIWa\ngZ+uvy/WtbJ4a0+h7rBpSuzq9KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFEvV/qtRNXhL4kuZ+XJ56vqlmUDMB8GA1UdIwQY\nMBaAFK0zCh6JOjzbTkv43ENZThSCvOtHMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiASp2uFoRLtvKUwnGRB2pjHPgVwY1hwjxl/\noXZA9QqbaQIgZaMOwfzIBSLqOeAA6Up3ILL7wJi3IbCgC1gGNqLv27I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcnGfwebxGV9nepOVDxlJFS7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2IwZDJiMS01MzgzLTRjN2UtYWM4Ni1jYzJiMWFiYjgyMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDddm5AflhNXsP+E2MG6u119AiSvpEI9OgSjiwCLl48KzD\n6OXXfSD/wjEd4WempAOo5GyMtGNrt4RXF4HxexTxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrTMKHok6PNtOS/jcQ1lOFIK8\n60cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMZjioWb/lLNG3hNfPNnKaYwJ55XqYu3G6KFN47hSsTXAiEAscc0wbc0\nkV/7r3ueUXysyIQxXLlUb7+JJ5XtxDv3KD0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAV/n2s8RVZmik5lAcQE/4qRgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjYyNTQ2NjItZjU1NS00ZjFjLWE5OTgtN2U2YTZiMGZlYjAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzE5YWM2NzYtMDA4My00\nZmMyLWE1ZWEtY2Q0NWExZjVhYTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlkrSVdtTIRvvvzbWQuopP/K1MLVnSIuQiJbgccaZ5dN/WpQsTaQUHBEjhpWMRBIW\nN5X0MrrrndDPW1qzJOO+UaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUS9X+q1E1eEviS5n\n5cnnq+qWZQMwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCuu+QGs4zsBA5Smp9ieAMy2u7DOV+eWdwy8IM0aQUeBQIga8bfHokr\n/I11NV/RUUp7FEkG6r+ilbazQ3OEDsrpHs8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8515", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8515` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVecthyEIzVqkeiirIJ6QfvNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzZjczM2EyLTI3NGQtNDA5ZS1iMTBjLWI0MjNlZmYyM2MzYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E0MDU0ZGQtMzlh\nZi00ODU3LWJhYjUtMjRlYTMyMDgxMDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHnP5lKi2KwNRzNHXn/72869A2xF47tPZMH5u2Y/vWMYA+depz6Enpe/+diQZ\nfepSWK3AQcG2BBKim7SK+BfS7qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTqBawmPsJy39rxCJhgMlnh7W8VGDAfBgNVHSME\nGDAWgBTce1I4xwJt4zZPVdLTlF7g+qpopjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDqfChalMaHcUfNvVT8vNN68Zkhl+5a\n1kLrRwCyJnA+EwIgOTzbIY6/Fbiwt8M5PhrsoUXqlpasWNuVhp1uwYexLeg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAehGX4hVqkYBtCGcPhg9WtuqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2Y3MzNhMi0yNzRkLTQwOWUtYjEwYy1iNDIzZWZmMjNjM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVCHI4NwnGnNUydpTmfcT/TcqIiwxsIGIIN4l72IB7XsAR\nRS/jd+qYcUNreaRttpvQzFrmIjK1TP1ydf6+Te+9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3HtSOMcCbeM2T1XS05Re4Pqq\naKYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgITbHaWsbSrbY7Zgo/jjfQnDiOdkyXGVZT+/qB8WAv9MCIAMWGx3FICSd\nllnsT7CZRrfkqWa8YlbDBLmfpSlXC3JH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISARLC2JeuBtfiB7ui1x/mtQqoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E0MDU0ZGQtMzlhZi00ODU3LWJhYjUtMjRlYTMyMDgxMDNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzlmMmIyYmQtYjY2Mi00\nZDZiLTkyOGEtNGI3OTRhOTVkMzc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nAlS6QASsymqsm+/TjxZrNCfcRJh4yzY9ojXBjS7ulWbrC+A1ciFfImx2kmm6uvSp\nYnY/mjac1QHhG998AT6W2aNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6gWsJj7Cct/a8QiY\nYDJZ4e1vFRgwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDqDUaiS5AAxgD0uC1oxk4NOjpgo5lZmapRiQ8sOBeY3gIgKdakNxRI\nRAn1WM5tMrEcHXMydN5GmP5pSmDdYC/vx4w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8516", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8516` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAdRzLwqZmH/XYfVsii18QpsZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiNTYxYTRjLTBlYzctNGYwZi1iMmIwLTkzZjNlYWEzMWQ4MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQwZTg1YTctOGYx\nOC00OTJiLTg5NGMtYWQ4NTA5Y2ExYjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyeB8wOCsGIPbBJUkVbYE8iZoFq2hxK0OUiBFNg2t3o1+VJhQ90OSDiQxJVhq\nU6wP8Vq3MQnwdiA6r0WfKu1AOKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFOQDXdART/ClzcD6WtweyelDnfowHwYDVR0j\nBBgwFoAU1Ib6Q2krLMJvAfqluIr5gFelA1QwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBH+K1j2c+9G8cy\nbOtEo11SfxWSEJocbWmMR5yuXX9nSwIged/7Wbazscl8rbLON2Irln3AJyjdXJor\nmBPA0Lzk9Ko=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdZcTimaMOyvxSmjeGZOhzFrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjU2MWE0Yy0wZWM3LTRmMGYtYjJiMC05M2YzZWFhMzFkODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDT/aM9TLO999SdgaoNuc8emnlHx36M9k9OMq29ZIUtEtM\nGdvGGOwflntud/Zf6roTQYrCXWUUbhiwj8rYOUtho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Ib6Q2krLMJvAfqluIr5gFel\nA1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVD3g6AA9H8hLdbVueuwF9eRS9/aQHiMayhBCHE7HVnMCIQCfxh+Z51GG\ni6EkQL92b4mH1ooUCsC7VBtPlEZQ/UOXvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAfdIt8sqEOiIejC3TkfyW185MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQwZTg1YTctOGYxOC00OTJiLTg5NGMtYWQ4NTA5Y2ExYjI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTk0YThhZTgtYzgwMy00\nYWVkLWJiNTItNzU0NDczZTQ3NzY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhxI6HoS8CmZgQnVmpXZ+ShB7AnHYY8W4eysl9iby8d/OqGiYs5POXa9hRb8pXm3h\nMMFEi+qzomjtE+Ss2ISDRqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFOQDXdART/ClzcD6\nWtweyelDnfowGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCJF1EX25Lj6qievyRyNErgvDGMsgIEd8JeLCyvuxvQOwIgUhwrrdwe\n2KUWcqkiiNMIyfwsGWXxDDzId+W5+L12i4M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8517", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8517` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAavlEVdk7zagIONsp3CTaEQbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzOWQxODZiLTdkMTctNDYyZi05NmMxLTc3NjZkNzA1M2YwOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2UzOGExYTItODMz\nYi00MDM2LTk0YzItYjQ0OTdiYmYxMDU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEElYtpWga6Im5dQyYYrR3AnRS0fibwl2yy3KR1QRiRbtJFiJt4iv5Oz3ktLyc\nQFbIQHzxw3xczwh654KigJsYkKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkfxGa5Wz97xx0DYhWGOvLA6lInUwHwYDVR0j\nBBgwFoAUnNDFQn4ibH9Fq71/ku2hjcsPTkowJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBMLdcI+y7R0gYA\nsphc28cnCt9vUZXLLJIfSodqfXPjxQIhAN78PzeCgYQUrZieerFrSOe+XjDS29gV\nHuMe1V3dDT01\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS/65M42O6CEn77shkkWIyOsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzlkMTg2Yi03ZDE3LTQ2MmYtOTZjMS03NzY2ZDcwNTNmMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASk8rgGnOR3eQFZ+gDBVcfttAbG43YZveDp+fDsrrUwGMiP\n0hC7K0w+NoAq5A9xaZtt3HXOALTRHNJPBaSq43C4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnNDFQn4ibH9Fq71/ku2hjcsP\nTkowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAvb2DVDf5KGRPPJ6IKqMmHkNPLg5rRlfLdYSMV1RN0MCIFKyixx9ukbA\ncn7e4lopbiQREspYUjweAyn8Ytjg7Xwz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAZDgLH4VBtZNGANSSt5q8C0yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2UzOGExYTItODMzYi00MDM2LTk0YzItYjQ0OTdiYmYxMDU4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDM5ZTBmYTYtYmIwYi00\nOWE5LTg4YmItNzRkMGZhNTFhMzhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFJfmksomz+R+k43VGOusywMQD/Xv2jEEXMWVyI02w3RXIPXn7Jzbr+tOwQbUrPTC\nFWfBORatrzpWDeHnsLXF0aNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkfxGa5Wz97xx0DYh\nWGOvLA6lInUwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIDB7Hz/x7L5RGutZZNZsaYzrXRj27OJWu4g7FIRKDs1aAiAVE2XM+ejl\nUV2goSS391v6lN3Kvp05h+E6ku0d95/npg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8518", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8518` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeWgAwIBAgISAakTJJoE13TSN73Do1KU/RNwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkNjJkNWU2LTEyODgtNGIxMi1hOGVkLTkyNjk3ZDkzZTI4ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDFkY2ZhNzItMTdk\nOC00NDQxLWE3NjYtYzg3MDBmODAwMTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELEROQBQeh5AKv1NnwvC4FXt90acw9TIU+XxZm+iJ/QjCcY8adCWcAPvz4reB\nqFD5qfU/O9fAYwP6oAkLXsbedqOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV0Gf1fcwPqGVFoXzwOLtQ0sO3Q0wHwYDVR0j\nBBgwFoAU6YLvgsUQJ2d73ImUWUC7Y5jQ8PwwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEAvyUOpC7L03uTkzTBF6iQ\n+zQ81sXsocuT90I4jHtWYVoCIQCE53ZqgEKQYHO474a95emTEqXgoFGZKp/3PxOe\nCQwgMA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZMo997EpSSSHogRoog9XZ7KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDYyZDVlNi0xMjg4LTRiMTItYThlZC05MjY5N2Q5M2UyODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIhIcxtYEEnpMIoHk0QMovSRIw1a7zveppNM4rR2BkqwmY\neR6TVP5jnfRJev7nl89gTW9Iq+doAv4Ib9bfAHMRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6YLvgsUQJ2d73ImUWUC7Y5jQ\n8PwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIom6NvjDkcPafdBHtKWxBK6AMFl+rpWPTneWJdS5FygAiBHGBrYPbMz\nvfKrSCYcJRj+LQ2hhoQdPUES3Erj913Z9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAbFx2k1pUzQ7rm0XUSIgG+ULMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDFkY2ZhNzItMTdkOC00NDQxLWE3NjYtYzg3MDBmODAwMTUxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWIyYWU2YzAtNjZhZC00\nMTc1LWI0ZmEtZjdlODNiNjQwZTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOQUOwNy+ioCb1lgHpya8fNS3jOtL/Ukt4Pbq1+N1vee/bH0reMPW3Ywaw/bQ7QW8\n1qVCD2GWe7/xvcY1L/Pf3qNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUV0Gf1fcwPqGVFoXz\nwOLtQ0sO3Q0wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIED4A3qrp1HB55t5Ko1M7bPqpqVxjpVnnPiDjxr/si5AAiEAjxPFT4Mb\nCLNVARo2mG/L+xsXjigLxbPLu3fw45PHb6U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8519", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8519` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAXG5cpHVU3YoKZEL0Od0+NowMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4NjZlOTVmLTdiMDktNGM5OC1hMGZkLWI5NTQ2NmM2NjQ5NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY2OWIwNTctMTY0\nZi00ODlkLTg2MWItMmFhMmI0YmI3ZTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm/EkokpCfzXrBdTf/5DwNdldxpZd/CipEpZT7F7gFEqxsRMRN2XsbXp0jZ0G\nP8nINwNQbU0uBJ2YMxPoZC8o56OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpzSQurwHg7VtjWsbTFt4drf4CRkwHwYDVR0j\nBBgwFoAU+SYTlb7I6E/e+T6JHJLgfXyCM1swLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiAxXq94\nTFj0L67DVr8dc0cgnXbp5ClEFaj4WJJmAYAwqgIhAOj5WQDcSP/UOtNQmFxExT/k\njL7C/iZLH2C2/+3an9AM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc4Q1o2sjRaS4OfyiRjtBgJeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nODY2ZTk1Zi03YjA5LTRjOTgtYTBmZC1iOTU0NjZjNjY0OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfUKq53choEquqW2DBM8VapbPZLu77EIoGP79qJQSfRFHZ\nh0DR+XDzH1fZ96cbCPLZTBEinQJnarHgYUdZpqqQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+SYTlb7I6E/e+T6JHJLgfXyC\nM1swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFPJDaNfJ2ZxpnDYjKwrL/ZjSmB0IcxXH9JDKPndzVYoCIQDVhO0VQSwT\nrCbkCNC3wF8GpVr7wH1+YSOwApmvC8jJZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAayZSF8BDGbEE+XcRheig1BkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY2OWIwNTctMTY0Zi00ODlkLTg2MWItMmFhMmI0YmI3ZTE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDczMjEzMTUtYzI5ZC00\nNzM5LThkODAtMGVkMDIyYjViY2QzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nIHjkibHvWkXzRh5w4q5k71EoY+5ymaXGgyMv4kRLBCbFJvvAM4QFW6LzMZ5Aoy9j\nJF9iqG2e34QNlL3hq3kMyqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpzSQurwHg7VtjWsb\nTFt4drf4CRkwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCxCg4jUPc+am0xDaY9V87D5bOfY0dr79bkaj6+9kwR4QIgdU05g0uY\nTGU+A1mSU9r/s16VJWH7UKDGTwh86WD5Jbk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8520", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8520` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAeAKbv+ksWp6V1YdR/GN/gS6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwOTIzZGIzLTdjNDAtNGVmYS05NmQ3LWFiZTEzMDMxYTg3NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE3MGM1YWMtNzFm\nYi00OGFhLWE3ZDctMDAyMzhjNzdiZGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7+nRwHMgy40pr1QnuPEZYcwvwQpS4SFYHD9EgURx7mbQL48oufVift/anPL3\nTmj77gheh7I7vVm6JtN6QYfJ66OBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU78ecJsCT9Rwz7gy87KhlxPDBMjkwHwYDVR0j\nBBgwFoAUWXIAarwQrCxkDDt8neQu9+tT6/4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB+fSCI\nc30eFZdOlFv0Ie2WpwiwGUBEUS61pcZZ1QRWIQIhAI8K34ecrK80p1qYYp8QUup3\nSXH1U6iQkH6PpFk3vlc1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWvbT1v+NDtdLVgb/JQkkXCeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDkyM2RiMy03YzQwLTRlZmEtOTZkNy1hYmUxMzAzMWE4NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASt7q/qmjMUgCff3A0Y6L/ZsOWaRQo6Z4NsHNx9eMKdveD/\na1J390s9BWeNgulYigdmP3gIVRbM90k9TLAKh7iro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWXIAarwQrCxkDDt8neQu9+tT\n6/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKcA5ZFxcExKEeBM/r/X7dvJeYrqHTvHvqBzEGpFBqiACIHAyTv/azS9v\n5/QrUG+Byx39SRv1t5ARwA4aXOuoAXcq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAZsOt9Ta36WnkK2juiywJWPSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE3MGM1YWMtNzFmYi00OGFhLWE3ZDctMDAyMzhjNzdiZGM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzllY2NhY2EtMWRjMi00\nZjZiLWEwNmItZDRhZDI1MmVhYjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8ribJTfbGkOw+pFouvjsCv+vHZ31gyO8b1TzaWKPDQGthRBCPS90h2gsi27suaXJ\n1ZbDOcg4i7Vp2hV4NRrVM6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU78ecJsCT9Rwz7gy8\n7KhlxPDBMjkwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCi4urttdLQp6e6ps363dzjGirRPubfxGy3BohAEeHVuAIhANiK/tVl\njBWkvZxVrAFYnJY5fTYGp9TDLnS8YKP5SuF3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8521", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8521` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVJcjPQhoKfq/65JpWloUQcMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3ZjllMDY3LWE2MTYtNDVjNC1iYzVmLThmMTAxMDcxNTdkNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE2YTUwMTgtNjAx\nNS00ZDdiLTljZDgtYzU0MTVkMmNlODgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXvXRsfhwbUrREXZpz/ybeiX1kqDG+8bPAOGBsfeWTdBTKey9bSWq41qM+4J6\nk6kvkTCHx2zYI6cMKTUjEKRLEqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNxioiZPRROcveS1Obkjw7nsGt+BMB8GA1UdIwQY\nMBaAFHKbCgcO6CWGDOHqkeCgEF5+U24OMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAMbte58zW7WXj+5qTjJF7mz7sENYCRJn5l\nA2naegq2uQIgOysHt9JaLIvgkSqTGu4f/5BnkbRRjZNnB0sz7h/sF9g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf/imQLB+RCmhwm1iVDvdBoWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2Y5ZTA2Ny1hNjE2LTQ1YzQtYmM1Zi04ZjEwMTA3MTU3ZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCWNOKY9B74NgomTYo2pweUpY58Zrnnakv6kzdUYWl4zkH\nrM/kvjUWsol+tggpXROV/Mug/n1BUyZCVd7P8n5Co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcpsKBw7oJYYM4eqR4KAQXn5T\nbg4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMvNsRVst/cxFJZgk7faEzKcsn8vTchV3QsVnFn3MyhmAiEArFLejBxO\nWSQgE1YDR/wh43V/1fIJuV4OxAaWH3MyrGs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAXfakm4oCndjGDONeogGeEb6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE2YTUwMTgtNjAxNS00ZDdiLTljZDgtYzU0MTVkMmNlODgxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYThkOWFkMmMtMDc0MC00\nNThlLTg4YjMtY2MzNDk1M2U5NDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nq+IojylmDUYnHk98liCURyqxImctuxcu6fY2ce5PkQAgzBgktaOvfvqzg5waQsZk\nIwSy+lnZZpFLh5EtaloqwaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3GKiJk9FE5y95LU5\nuSPDuewa34EwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDY5XdMijOHfzF7BGDYU/ztDR9JdSrnM50X33q2C+CDNQIgBjy13OnU\n6cXKmg0q8vXry1bNga6abmOtNuZ8m7oJLec=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8522", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8522` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAQFtZBkCWo4EfC/gcIvBeM1tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhN2IyNDU3LTRiNzEtNDE5NC1hNThhLWEzNjY1OTM3NmE2ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY5MGYxYzUtZmM2\nZi00MTY5LWIyMzAtODFhMmEyYzczNmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE99l/BNG2bW5TE7JSsYhVSr7iOF/EZsvgWSWBdSs0/96EJLXIvSTqyVB0vPcK\nNpnZGfthZ354KkstT7iULxpPY6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr40u0sqYI2WyUyaOiAak49ouSVYwHwYDVR0j\nBBgwFoAUDpV0c7T4nMwPNfso8xLnmmvxFgcwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAN0NNv1HkqLP\nCaPcFVwZwtR90KdRTiPo00Czu05EVRESAiEAre90RjJr9IyUj3IEBXh7zVlBk4Vs\nvOO/QLkU9qwlZrs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQT6ui2joCnnBD9iFp17j44aMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTdiMjQ1Ny00YjcxLTQxOTQtYTU4YS1hMzY2NTkzNzZhNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQay8nHA2zO9FPDMV5vPFsFG7EGaJ4c+E0dKK2iYl1TbYhB\nJnPmOehihFR+lzV6ZxJRXwXE6aWtEjRVVDQh0/0Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDpV0c7T4nMwPNfso8xLnmmvx\nFgcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKqCF95tYC5VqP3gr7K4c97lGUIECvftigXQ4IdVAmpKAiEArdz8nb3a\nHAqvcWCD/L8i2FF7Lb0dlJ0S5AJsbf7mEQY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAfzgwhdsLDOj/L+KoG2iDnjwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY5MGYxYzUtZmM2Zi00MTY5LWIyMzAtODFhMmEyYzczNmU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWMwYWNiMTctZTM5Mi00\nODllLTg1YzItMDIyNDM3N2YzMGJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEemQUI4z9pTUjViIdq6PySvzhy5WgMVxuk7zsBE60FRbqCi96R8VB3a7/gQ6ZQ4T\nautXXi3TnPiqHCZP0Muo96NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUr40u0sqYI2WyUyaO\niAak49ouSVYwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIEIkpAOGEPiSGn/KLtWgdEefXY60kZnTg4q4XblTIWI/AiBziRGvhicN\nVkDoFjPWJyP1L1F86AB5FAzzlFfZXT+gdw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8523", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8523` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAQrYRhlsU1fs4MSDYjWFF3XaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ZWRlODYzLTU5MzYtNGQ1Ny1iZDJmLTZhYzdiNGFlMDExYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYyN2QyZTctYjFk\nYi00ZGRkLThlZGYtYTA4NzIwZWFkN2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELf9OUlBlPP0E+1zcuPFeZUlMQsHXrrnjH9k+GtOF3m0qwGrHT+zGcg4p6U21\neDaC/dZYhpDxF6fbjyr4Kg06tKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn5hbntgNgHkBmwkRvcyL9jJjmCYwHwYDVR0j\nBBgwFoAUJuaZ8VKONVD8XGRf/E8THoaJmLAwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMAzL4fzN1yD\nuSjjs5UmYR+t2z+VV648ve0CBeBVa0bJAiBNVqwvrxnUy9JWbUMvl2b0img5okZV\nHEneeVRjEVjAPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaUA3IxOFr9SdWRaGWFP7CO2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWVkZTg2My01OTM2LTRkNTctYmQyZi02YWM3YjRhZTAxMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxLaJVhWzBeaBunik3dXYkMPHPukBQEG5HvZtkiUtTEcMb\nios7k8ERvQ2oz6GvQRpQoA25GlLQMcdlrzegckO3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJuaZ8VKONVD8XGRf/E8THoaJ\nmLAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJOB+WkR8/gIvsW49kwEt42O+GpelvG3I9d1KJPz+nOaAiEAnUhCQyjs\nyr6TxZP/dWBrs66J4iQMeheSmkzY9OhPjAE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAV/+kBz+LbPd1C+KkbNjqT2SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYyN2QyZTctYjFkYi00ZGRkLThlZGYtYTA4NzIwZWFkN2YwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTkyYWFlY2EtODNlMS00\nM2RjLWI5YzYtNzBlMDIyMDJmZWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsI7dfAN5GNazNFy6ncsyOuwNFJvTrocz2Rb1YQxdN8HGGmH+J2Qpn5Z0dtgKytq/\n0hz14Qos3X66Y8c79fvmP6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUn5hbntgNgHkBmwkR\nvcyL9jJjmCYwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDly2XHMKP9FnOnSS6x+J5vPHC1WFhmU1bIfR5ueuOgXwIgPeDYFJsC\ndvPDRg/6FClbbG0f6Mp6rSlWPFFQlBtDgz8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8524", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8524` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISARZEjyB+EfuOyKu7Jp2YHjgjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzNWNkYTE5LWFjYTgtNDgyMS05NGViLTMxMzE4NTBkODAwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJmNWQ2ZTItMGNk\nMy00ZjkyLWI4NWItNTUzOTMzMWZkOTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Q/ATLzyh/QT0L8iOhGQgND10cYyM7KyyHZkUKJ0XLDGdtWfvIdfwcBFBrsL\nxOCc41+Eb0/UmyVjIDkfxK5aQaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULKu3ePnF65iP6dj7GoqlLHqEPUkwHwYDVR0j\nBBgwFoAURgVIFZ9A8Pdutdm4ACWkRVt/BwcwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCXG4Jdr0mn\nyrejRczwhcrvSW3IoMMOHqQatnQbaUugvwIgfzkQqVyjHV/pSvqHnFgJLQvDtCSA\nwospC0V2xSD3uHk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb5PTDdcVdcuOF2I3ryhaHd1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzVjZGExOS1hY2E4LTQ4MjEtOTRlYi0zMTMxODUwZDgwMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASk2Q5Yuv3ZvaeHLRvQfD04nZOm2ccvySd7Y9tJfzfLkuj7\nCJxtq6qawSMWWq02dIUWpNF3q3pxyLRsRSyVSYBqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURgVIFZ9A8Pdutdm4ACWkRVt/\nBwcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIG1ArYxcwHhxZF8WDLWzg0G3D8cNr1U7Ex6eTRimYvLAiBa1t7+ejhQ\nznumsMRItZS9OZw4f+fTsyK6t4qVo/Sikw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAYLbWz9ItG5A+NHoO38aBZ67MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJmNWQ2ZTItMGNkMy00ZjkyLWI4NWItNTUzOTMzMWZkOTE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjgwYmQxM2QtNjhmNy00\nMjFmLTk2MjgtMzVhNWE2MmMwMWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nn452FmY4M6JmdMWvIlgb/Dh/qQbW5pkZCONoG0AT1/mHZTjoN0Ok08RND61ntSBB\nQqT99MbQie3c3R7TkS/VqqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULKu3ePnF65iP6dj7\nGoqlLHqEPUkwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCZcij7d8aa13M+WV0WidYwNiO3mANH5koHDuOLlkJrmwIgBNVCl1zZ\nmXlX5wbJMtiBgUauh05s+MB5g2SA9QT858w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8525", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8525` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAR8Y4uU2ql58t5khsrNSo+I0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1MzI3ZmI0LTJhZTAtNDZmZC05MDI2LWEwNzdiMmMyNTBlNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTY3ZmYzNjctNDQ3\nNy00M2JlLTk4MzMtMjFiMTE4ODBkZGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYfQbyV2l4ASNXcgvWyiirHxX7FvGZwu7i2uXG5kludHAmM71jj6AH4k80Fo4\nVSOQFgkJGhJ4XJQv4dmKH92vQKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs5txZSJjTRjndk6uer/XHSQ4aG0wHwYDVR0j\nBBgwFoAUrZC1kqqnMraOIiBQkLGUSgeZzzgwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCijRRuKAOb1orSQl8gM71DT3KehpRNLx6mA1gNG4bCGwIhAMkAXgcy3u+b\n6LM6K7MBSJ5zNTePRw5FHYrGTMGng+Hc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfIJKqm+QPm91HU8zG/t7AtBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTMyN2ZiNC0yYWUwLTQ2ZmQtOTAyNi1hMDc3YjJjMjUwZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9Nzieig7nvVCLzXM7IXizkuB2ZGVmcp6xamX6Ga7OQN0l\nJ4c8Vbh4cEuU75siQL7sNpMwSnJlOzPMvRusDLGjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrZC1kqqnMraOIiBQkLGUSgeZ\nzzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE0qz1NA4/dmcF61aS9KEv2b6V0WxPAs8uAyMV8Gy740CIQDnpfXSbZd2\nCRNYyYQp0/oOlhiQxdfVN340qP3sfkF00w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISARhTtCO6yFzXtgmDl17+XZ/PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTY3ZmYzNjctNDQ3Ny00M2JlLTk4MzMtMjFiMTE4ODBkZGFmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGZhYzAwOTEtYWM2Yi00\nNjJjLTkzODItYTZhZjc0YjkxOTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngxZwGy/s4oQRPX4QKvVE4KwEro/61q8SXt5Z5mOc3j1F01oGAxOkWxGbUIqBAF9l\npU+bNqvRZLzzH2MabvVGgKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUs5txZSJjTRjndk6u\ner/XHSQ4aG0wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIB6LMmT7hgYgjd292Qb51wFyzlGD16ZJMqZf2bTmeViwAiEAyHkb+cUA\n77pkLf2bWyw4zs9VwdY8f1VaLf7IEEE9lgE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8526", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8526` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUUtZn1PRYTcvw2r06uAlLxZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3ODU2YzgwLTQ5ZjEtNDE3NS04NGQxLTBiNDhlMGM3Y2U5NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzllMGYyZjUtMWNi\nMC00NmZiLWE4MDItYWQ0Yzc1MzUxNzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERgXw7nrgZDwRKhw2OZdDUhSFi3/tqUQGxcxfePxhqzaHcShNBtqaNowbApee\n3od2WNgKsHCgtLWB6CWH6YG/dqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0uL2USQ/xjAVaAIklFSQ9jeY2X4wHwYDVR0j\nBBgwFoAUVToSyvflsmX5zb2r27veHenDXagwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDwkq5CdvWUfTNms4aorJNEXIS0c87YfD7/ppNPUWNGQQIgKkqJ4i/ZcWpY\n1UXUfVKI9Bj7aLKbYoOBDEU60q4vCEM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeOAnupOUSdiBKfbBV/n2SJtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzg1NmM4MC00OWYxLTQxNzUtODRkMS0wYjQ4ZTBjN2NlOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1aJ//U2rnkQzPo+ab283FvuoJmCf5mV66kHOI1Q+1la6A\noGngNBp+hzyzLQFiUw1wFVKUzIndoOQisRXI1E67o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVToSyvflsmX5zb2r27veHenD\nXagwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPxjz7PyHB3DVA3xjYgSilQrrgVdYlAx7UtvZUVh/ToEAiEA8GE6GybD\n1fxMZTOftP+2fh75n200FrIBX3H2Fk+dWC4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAQiVm7SHb0XimvpJySoVYbibMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzllMGYyZjUtMWNiMC00NmZiLWE4MDItYWQ0Yzc1MzUxNzg4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTdkODJiOGMtNDdiMy00\nOTQwLWE1ZWYtNGM3ZmViMjIxOWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndL/93hSDmeRtwYUglwLe4kNirNh7Kd5To6xsTeuWkHLxoInRdGgJBDUrcfRcOD9A\nP4qP3CApiWsJXdmZHt16zqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0uL2USQ/xjAVaAIk\nlFSQ9jeY2X4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIEv2wrludeRWzmY7/67X/KIo+H4OFwEIKTALTECvZhQsAiEAugBhltII\n4Wm9laoqR7shLDMHdyMrlZM43z4TLpKmoqk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8527", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8527` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAcOEhtLtZKU5Xflnu/GQNVxNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3NzY4ZThmLTk5ZjAtNGE3Zi1hNmJmLTkyZWNiOWM4NTg3OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgxY2ZlOTYtNzNi\nNS00YWFmLTkyZWYtYWZjNzQwYTUwOTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgSK0rqodEL8oFj8h8BTxdDzjnlbhx/idqcodceFm7pWK4gq4wTEpTkwMg6yx\nX3vIZ5zDMLeHXnKVnHllpz76h6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkng6qyX1tPJ0nvrkDikvJTmtLU4wHwYDVR0j\nBBgwFoAU7YAEly10dCf0sLXvgGKkh9OeMQ0wLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD6\nHm+DDduCPbEJMoG90cmmM4THSiyRcWbBYGY78jQcEwIhAIAcKRYKY+cdDIdwS1QL\nZYM2Xe9awoZthirpd9D9kdmV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARuPDBsr4iCzph3XoEnUqPwaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzc2OGU4Zi05OWYwLTRhN2YtYTZiZi05MmVjYjljODU4NzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQURkWC/jXwSKBySarzkn6sxfDBvOPMHK1r5TJRfbUt85Ga\nTHCNPe8diyiXJCSZWSPQeye3vv+Mhvow5yAXaFplo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7YAEly10dCf0sLXvgGKkh9Oe\nMQ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMUKvleUrzMKYThMpnIiYYjxxeE8/2mZxh8wmrl6mVAuAiAPUpTQmJPf\nE8glTprX4QhUWKpirxJnJPOg3CSI0QBACg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAdFCE2PUXV7jDai1fzk9nSgwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgxY2ZlOTYtNzNiNS00YWFmLTkyZWYtYWZjNzQwYTUwOTAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTc2ZGQ0NmYtMWQwMS00\nOTBhLTk2N2UtNDgzMjdlZmViYTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3ox5dTBYEbqH95Kk3ZCwR3MZa4GWvdYLsVjTOIiSiLKdT2maQpIyiQJpsSnzAafx\nNOPUZ1tMY2fZa+j5VXj9kKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkng6qyX1tPJ0nvrk\nDikvJTmtLU4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIH0/WK5zEjc5QoUOlSUqFOLCuqUJA+Ezb5cAwnn7A+RZAiBA8cpiff8Y\nHqApXzoIrNBlovqcd48cL7Vw/mdPWYYCDQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8528", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8528` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAcUGq52i+TkN0dmr5udOFpcJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjNGNhZDM1LTZhMzMtNDM4Zi1hYzdjLWE3NDYyMTYwYjU2MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFjNTQ0OGQtNmM0\nYy00NWY5LTk2MjItODkxMmM0ZThiZTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAADjYaUuAhGzRir+YQYs7w9PDHcX+PilbzT+LWNR57W0zrpiU5fNkCYAfGG7\ng8JGfKN1FLSoS57HpTg4wJv8paOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOgWpXRMYRK8vOnJE28zv6sm/IwowHwYDVR0j\nBBgwFoAUjNpjxJHGIp/aIo0i8E2zkofaM10wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCL/kdG1buucoiKnDFXk+XjLwqNfTLUop7vVeFVvMPm7gIhAOYo\npM5HytqlsWDEhhY9HT0xuymtjfKn2QAA+Z82E1mE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVHtVtR/8mZr6BZ9aHnGdOONMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYzRjYWQzNS02YTMzLTQzOGYtYWM3Yy1hNzQ2MjE2MGI1NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2/STFqOYEaym/dkPN2dLJ2fRKiyxapNnsXuuX3/i2Jw6q\nrEZhFc9wSNKLBhqPEng2cx2ff3c7huWqzG92Vn7Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjNpjxJHGIp/aIo0i8E2zkofa\nM10wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALIhkq4biDc2IcyBVBHjH41IQWw6vJTLBZm/yY4UoQ2uAiB1DM1b5uIi\noN99LQvDLsOTrsZI5JSG9KP9jwfo58XeOw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAYLg6JCw0p/2YY3zuJ3ulWV9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFjNTQ0OGQtNmM0Yy00NWY5LTk2MjItODkxMmM0ZThiZTgyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzFlZTc4YTktOGJmZC00\nYWI3LWIyZTYtMTg1YzdjMzY1MjEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMGQNVSty82Z6YBtyhHDKm1MytOB9MEWr/W8TBBxwm6hf3uQvN/HPjFMpGyBjtOC0\nZ7huwbWcfcx78+ZalfIqlqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOgWpXRMYRK8vOnJE\n28zv6sm/IwowGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIFwrx0ZVyopMO1r4PZCsKLGZU5KgpH2JFH5YngRDKJywAiEA4SHm+6/x\nj/SNcOb7eApdNvOa9h+KtXLqKqQBNT6qIc4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8529", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8529` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAf01HrgeRB/5T4hM/YVv/NIZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NDUyZGQ3LTRlNTYtNDE0Yi04ZTA4LTgxOTc0ZjRmMzMxYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjM2N2M5ODYtZWVi\nMS00M2UwLWFjMTgtNzg0YjFmMGRhZjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKoYTQ1EuLRhAoaOO91y9r7zwnRybQkuiW0wVVLazOfu3/L63DJiw0q221uNb\nUF3O7DzXx5CxX/lyyXaCqlsTuqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURAelumV19gCy0aOLfb3YhmaXCpUwHwYDVR0j\nBBgwFoAUTkGgr7EIjtsfeCDb+fM72ng3yakwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIAhPq48jb2j4hB9OCqm/4lC2TK2IyJJjHZaTnfl5zwlZAiA0AKR4\nk2E/flWhF5Ox3sFVBGRee69bOBtiZxQ7FQgdJQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY1W+O1D5DXW25HinKGyRlDuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDQ1MmRkNy00ZTU2LTQxNGItOGUwOC04MTk3NGY0ZjMzMWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0JWxIXFUyBc3C3oJgpEa5wthlinXi1JJ1El7P6E0bvSTm\nsYCxFbrDdvCefx8Ki2F+C8ZlmnSk0dDICt4ibgL0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTkGgr7EIjtsfeCDb+fM72ng3\nyakwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKNpXxAOBAynM/KczWY6IxNmJk6ccG/k8eAOs0nhE8A4CIEmwcXNsbjc+\n5qBGysbrkAVsytJgqYzZxaxfs7LBoMs+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISASgz8ojbzGQntVrhEexV6uwUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjM2N2M5ODYtZWViMS00M2UwLWFjMTgtNzg0YjFmMGRhZjdmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGI3ZDZmNGQtYTllMi00\nMGI2LWExZjctZGQ5MDk0M2VkYWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nt3bgw9GrfOlniCB/3sVSmTBl8CHjPLYPBSUBrJZtj4o9t/IKKMkR+stjucb/d20C\nr2qQ3mrqTbe34vjv9fh0uKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURAelumV19gCy0aOL\nfb3YhmaXCpUwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDLnXWR4cscSaSZCsAxgIUmXyXfDaHkAA3fu5IhdevUsAIhAKj9buEH\nxq3p9yYdxlTIB3FWM4lnMxdNr3FH9aQ2MLYG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8530", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8530` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYglGgmoLkHpLM7JAsajrMPqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkNzA0ODQxLWJiNjEtNGExZC1hZmZhLWRlNDJhZjgzM2Q1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2YxMTYzODQtODc0\nOS00YTJkLThmYWMtMDZkOGU1NWZkMWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuSHpWQ5eqpMEeUJiHmZInkzmWEATpOFnMutj1U3H09zRY8BUEiSKgb3TQSgQ\nvUlZfrWLL7g/uBzzAbiK69S/uKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGwH5Wr+o5ov2HiBKdWiWEAWVchhMB8GA1UdIwQY\nMBaAFNslFvRf9uK4gepkEnx9Ilcc1ITfMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAjWdlghZ8Jpa2bk/rOKCSvXQ81R5GRXgQ\ncbaH8pZSISUCIH+ptvuz5RstY0eH+pQ1IT7f8Qn6UNSV3lMRRT8gGj6x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcBDiZ79L8zqzQutYn1zbOQ2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDcwNDg0MS1iYjYxLTRhMWQtYWZmYS1kZTQyYWY4MzNkNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYQr00RHJt9wCKGJfQkCXNVuOnJBJSNueyKztQZu1Oiu+a\nIvin/8gd+UOG7taA8exKAuhJBLsxWcTLtjvHl9Mlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2yUW9F/24riB6mQSfH0iVxzU\nhN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW5FQxx04UD2IRI3nGYNJzctDnO3XYo4POwK/J8YZY9UCIQCYF0mrHAXp\nIuI9mbkP12UnGGaBbxi2zX1FFJH+oDrSxg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAW+oZiubOnmClGzHBB6swQVpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2YxMTYzODQtODc0OS00YTJkLThmYWMtMDZkOGU1NWZkMWQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZThkY2M4MDEtOWRhZi00\nMjQ0LWEwOWQtNjlmN2JkYjI3MzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEWk/4GE9fSAFeCBKKOBnHG2ZOfUTGXKBvgtKZNDEPrksnR5BAS2QlPidepo/TCQs\nBHM02mrhy0XZcRA1k8HuP6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbAflav6jmi/YeIEp\n1aJYQBZVyGEwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCD4ix/0DMM+mUyVMOa37RyHoMkXRrlUsNB+W8Ai1UzxgIhANh89Cn/\nfcCthQRTBfGAmKHW9tLPOQDsO0q/xKYVXC5L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8531", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8531` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeygAwIBAgISAQVqWQYPsvRJlufbIUI9rI7LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwOTBhMjkzLTEyYjktNDc0Yy04ZTM4LWI5MmZlMmFhNTRlYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVmMGEzOTgtODI1\nYi00NWQwLWIyYTktMDhiNDBiMmM4Mjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE40cLCjLlRdZx2bPE21u8i9BL54fxyTrIQrHryUNL1Q60vWAZ7YnXbcvK58iz\nMv3pPe/unlI5MGIsxLa/0RF2XqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsdxhemfbHBnw87bfYb2E+NqyuBcwHwYDVR0j\nBBgwFoAU2i8mfv6m6NyOHw5AXLa320xKlVEwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgcbKMQ0AdtDx/\ns6gIciYlCFAoNjx5DKJzuRpC46VEHe8CIGw5hLGUxK7MFXAgtAYhPh/f7DjDWJuq\nz+h+7d80sOAi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcajiQmmVkfKYS5H8VHMBe7kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDkwYTI5My0xMmI5LTQ3NGMtOGUzOC1iOTJmZTJhYTU0ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmF0TsQT36Cx6a/RXCqp34G7/SyURYIck3msHAbPH6s3u2\nCXpktfRBhHTbSOZlx1edqjk5T095E4l937vuhHFUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2i8mfv6m6NyOHw5AXLa320xK\nlVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJhtgeT0qZo5dT17qqpfFT3NHP3BLf9Ze18jx6y5DnbCAiA2kHFEHzT/\nAwzHuigR0A0G1Eg0f4vF1IQcjb8NOf1eqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAW4oBLhu9P+r+n1MTw1vtJUGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVmMGEzOTgtODI1Yi00NWQwLWIyYTktMDhiNDBiMmM4Mjg5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjIzNWI2Y2ItOTdjNy00\nN2IxLTlmNWUtNTc2ZDczOWVlNjE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqKAuTfAT5JEEZQ9dNJ4L5uR93l74gYcjlZlO/K7eXNBFnfvYuoJSqzgX6GoTKhWK\n+pq2yn5fTpd/awQQyuwMR6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsdxhemfbHBnw87bf\nYb2E+NqyuBcwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIBjNf/DBO4EKrHe96NLJYuK2KEgSqf1hydrUzFUVZThFAiEApW9qyiRK\nPQPQWU/rKwWFmL/xV5E2zu64+81qNREWwoo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8532", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8532` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISASCVp2g8yvSRlyNsXEt9cMpgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4YTM4OWY1LTgwZWEtNDJhZi1hNWY3LTUyMWNiMTRlYWY0OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhhMTJmYzgtODc3\nNi00ZDg2LTgwMzgtN2Y2YTViMzU4YmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjjkH3yGY3Y/n+AntpeosRGXdZjOjKtQ2y63ZThRHHHBjBITBuT/sik6KKmrp\nL79PSnuS1hUZ1uEVLf2zS8wd/aOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7wOjGwqTJxAhfQ5qZW1NfxquTi8wHwYDVR0j\nBBgwFoAU+tGCbj+MLS/HLKiS1q+CAbgXQ0EwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKbqyuJLHKyM\n0BYbBu7vJbuxRUblidsABBm8xX7Xg3lpAiA+3/r3gnWkJ/i0kzLEW19I4k3BUNpN\nPnLiJQ07iyku4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUWV57ll5cgxJ4H8Fl8LHyGqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGEzODlmNS04MGVhLTQyYWYtYTVmNy01MjFjYjE0ZWFmNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzdVX9GY/G2jx/KikzzWQIpwNMD/Xe1uR6JYNncsfDCLAk\n3YEC4cMd1a16cUkrcDABaNOUsw6xSM8/F35CQm/no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+tGCbj+MLS/HLKiS1q+CAbgX\nQ0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZgcUHQKXwxDwocGXbZ9fYe+dUVVp7NbgMiHT3vbOzcECIQCL7bdQzNrp\na80g8tJNtRP0kcW4QWH/DNsKDdthrohn7w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAWn2RYKvGlGOQd+Ipic4HTbDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhhMTJmYzgtODc3Ni00ZDg2LTgwMzgtN2Y2YTViMzU4YmYyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmM1NGM2NmMtY2E2My00\nOTZhLWIyYzAtMzE1OTA1NzcwNDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nv+zmqQFXVQoi8nVqhCvsC5uWZQjyNr7ef/p8IHBui6yGEBDcU4je6q0mMDobqkK4\nYxLWZ8TPeZN6mX1nDvGJRqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7wOjGwqTJxAhfQ5q\nZW1NfxquTi8wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQC/NeTluEnR8C0WYOI2nRHjDOxY7VZCTdJzaU2iHwY+UAIhAJXSG+mv\nQyL6S/VoKlh3bZbC5S+uSRJcuJ1euFwSkOMV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8533", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8533` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAav0Ko0wWwOKamWh4JWyT0lPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4MWI1MzlkLWMxYjctNGZhMC1hMjQ0LTIzOTRiZWY1MWRiZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZhMDRmZjctNjhm\nMy00ZDFlLWE1YmUtYzk4NzcxMGJhM2RmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOOv5tW/n6NyoXGeMwSHYxjEchUPwOv6wSFv89NQPpSjI7h0F6yGbHK6tZ1Jj\nVMohzqfmtjGa/fvo6ofviQ58+aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmD6NJJWj/Dzb51khllSNYwy3KjUwHwYDVR0j\nBBgwFoAUCctC0dCls7noEIahU5VgZ29AJ1swKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIENB6ZCHRamA\nUxiJltKYHnA+N6utz5fZz1d4shpA3YdwAiEAkNcjK9M7RosoMU25khff0L/akjnC\nT+yXHBzZ8fC6ZX8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS/GlJ+Y/chB5BPcO4vVpVZ+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODFiNTM5ZC1jMWI3LTRmYTAtYTI0NC0yMzk0YmVmNTFkYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2952m0rTHX/4lW9C7nQJ3HKWWw+XSH124mCIAXFSc06vL\n8fI27BUdqz6Ss5idDIltEaCzKhZw6qKKpJ/c28j2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCctC0dCls7noEIahU5VgZ29A\nJ1swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJTIw249p4fre5YH4ZLLnGOK9zYFHKO8uC8VNoegBUeHAiEA7HgVLLfG\neQfsTu9nEvIPIxIrUHGSAMY5u7V7M5azttA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAZhX0GFj5ZEkez5M2Lqc/E/NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZhMDRmZjctNjhmMy00ZDFlLWE1YmUtYzk4NzcxMGJhM2RmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjA4YjI0MTYtOWQ0MS00\nY2RhLTkxYWItMGEwYzg2OWQ0MTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njMjE91ipTE8ckI+myMRG0SHzX4Y3GlztqZAkf0SFhJ4uODReKR9MFYc8/Lqp/an0\nulbFTdkGruytCkwi3HSXMKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmD6NJJWj/Dzb51kh\nllSNYwy3KjUwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCwU3CfAoS/IWigRiQlA3WOVPPmKxUcaGW/6OGb+LZiDQIhANOkEOie\n5qD4xMCkpyMklQ92T+E7CeaxVC+qx8htMiuW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8534", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8534` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdeHjjT1uJhLt4KkPw+jOQDyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExM2FlYWU1LTYyZWQtNGJhNy05MDFmLWY0NGZkYTA3YmIzZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhkNTQ1MjItN2Vk\nNi00NGNiLTg5NWQtNzI1YzU4NjkyNThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEK123ASXsXFWgv2hyLtIMS1/d4mQDCEjXPqBqUNuE2WYEuHhccnfJtVigjuUZ\n5vBs90zNsfo/DWFnQc7cIoRssqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAktbv26veF7snmYswak/Gt9Sf2gwHwYDVR0j\nBBgwFoAUqbtCW9owqpDin4WGKu1fvSjEFQEwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCA+EFk0QaBszobm1Yd5W9sRyFa/OD/Mn+S7YkMunk0rwIhAPqNtPhm0zk6\n3P7rfGE8HTpKTfKMjxZjyw5Dzfh+1P29\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbpv4tmruauAjghBMGPWhGj2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTNhZWFlNS02MmVkLTRiYTctOTAxZi1mNDRmZGEwN2JiM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNWZ/4Zgr2b0Z8hqWKI+bO3efsHBpz9yK4Vsr5xQVfZ+uY\njuNJ4vTb9i30iP0ausrnsIigEAIosDaZBTfPqhVro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqbtCW9owqpDin4WGKu1fvSjE\nFQEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfqJdoqfn+os9dCU6/DnG1p/7AZk3OqSUbRrCGyuQz50CIQDfqNDrkrU7\npuMITnm52tX4O+gLbLBsps/k9TDD0Oo4Og==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAV0nRZbu9MXvyB/ywEV/tKsSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhkNTQ1MjItN2VkNi00NGNiLTg5NWQtNzI1YzU4NjkyNThiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWFlNmViY2EtZWQ2Ni00\nNjE4LWI0MzktMDc2MjQ0MWM1OTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHLzCjgu0TK9ErZ2hZF9b5F/KUpqWk1rYXrneuOeowaTwfx4ldysd/Qj70F39/yuB\nANdmiiXRnBKYLw1ggEWmnqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAktbv26veF7snmYs\nwak/Gt9Sf2gwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQD2MxhJg97if1G0t93ctOrttHy5EK42uUCzLVF0xlVhCwIgPqgg7uhw\nbqxmO2r/fgjdA2dtmgQ8kPalzvb5m1YTWjw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8535", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8535` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISActBiSYGvutFjwpd7iU5JeBOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZWZlMjlmLWRlYWItNDA2YS05ZjBmLTIxZTIwN2I4MTc3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTRiNTI2ZTctMWUy\nMS00NmU1LWE3ZWYtN2FkMDU0MTBjNTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfaTLDl6XSjMN63e6qNd8mp3Px8AZIFwxksib6FCRcGRS7EeTnfKxQyGSDaFh\nez5aQrNZX1e1wEQjF+OJ+4ZxyKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpWPBk8FraFdWh0vPD62QnDlNLFYwHwYDVR0j\nBBgwFoAUsrxc2zbS01rV6RRTBPkg5qxG2FcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCygsnloGnFiN/l467XyPD+OGJHFJQ9HNu5Y7aCekeKUAIgfLUF/fgOoGez\ncDqvwJTT8MyCq6CBkAy8ZvODps9pJsM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQbXTH2E/5ONj5lrhnmLN7mvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmVmZTI5Zi1kZWFiLTQwNmEtOWYwZi0yMWUyMDdiODE3NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQa2GraRxT0dM24ahCPNPYzt07WfQZXvZfpaXrLiAVCZ24x\nluzpaEsT3lG5gCsycPUkRoK85+n6Y1AeIk9YdQ9go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsrxc2zbS01rV6RRTBPkg5qxG\n2FcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMxZ1cQqdYHj/cpcJMo0R5h/UlruHWp2l3XA+bIYKRCkCIFL2GeuBX+P+\nrVjwWifQZ9OKN8FklyoKJwJNQDJmluUd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAVHSlS88rT56GRalxxZ7oGGJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTRiNTI2ZTctMWUyMS00NmU1LWE3ZWYtN2FkMDU0MTBjNTFiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGU3ODVhMjctN2E5Ny00\nZDVmLWI4YmEtOWJkNjkxMmZiMzkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9Ud1/b2vx6WLxOVxgKj7kSbaBLRRb4Ndv8QDFW2wKG/skh9ut7ZsIX4MUW5TXXxe\ndHCIXkhO63aySEVz0OCLz6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpWPBk8FraFdWh0vP\nD62QnDlNLFYwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIGW8rzrOcr2ES6LrwbOcIRkKzuY3yH+Al1ZRx+Y3FdEjAiAGld+BGVEE\nK2MD+y7ZGzQmC54NRCuMJQLApHikzoKLgA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8536", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8536` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAT9dD6pC6s8po4U6aUtHPoVHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4ZTg5Nzg5LTRjNDItNDFkNC1iZDc3LWI4YmMwYzdhZTM2NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk5YjY2YzQtMWVk\nYS00MGVhLTgwZjEtYTI3MDU4N2JhN2M0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+/jqvgsEVLnQp1DsiGlvfMCgbNbw5ktAiaG1ufm9gRQakrk1glsuUMshpcUx\nFjTyH+t3PWLwSL55Vmn/OfN6SaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHvLIA1AObNVZjXRtmAFixvoQobQwHwYDVR0j\nBBgwFoAU1q1yXN+PIYDPh4Y9AGuBBSB5YckwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBsb\ngIiF8V6NAtYd4b0+tnBOonDszwg0VY38mQrGVkswAiAtdH10/iVHrzCPV5uvEWyc\n5GnJC4HZX2AizNtoti11Bg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU1EpSzIWBkz6TfQw+Hwz8csMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGU4OTc4OS00YzQyLTQxZDQtYmQ3Ny1iOGJjMGM3YWUzNjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiD4PpFaS9peKDgiumqNMTWe0tKkqLevKBb8NUtsAH8Jbn\nvnZo0ECrVzw5s1A+GEGyOfLPohc3QbVoJ8gMZ4G6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1q1yXN+PIYDPh4Y9AGuBBSB5\nYckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYSQWQ5WXu4bkDINAgQrACAuAG7Yp0rxE5cUSCofUTl4CIDGVBdKtBL3s\nz5iJ3q64txu6nnLRDCJyCeweLD6sHY/z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAWeHRDP0xVhcSuKa+aG+y7X3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk5YjY2YzQtMWVkYS00MGVhLTgwZjEtYTI3MDU4N2JhN2M0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTEzNGQ3NDQtMDcyZC00\nYTU1LTg2MDYtNGMzYTFiNzMzNThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nFU39cTJLuNj7VudlT6JXtvai9z2rnBqyVvhqy5jmAqI6L65kUY9SIJC0hf4xPbFE\nstjBkRpvpgHxcooEBwfX9KNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHvLIA1AObNVZjXRt\nmAFixvoQobQwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIAuZ4D1qtVTEqNx15Z/4cT0+o1zedUvpiThKmB/Y3p0WAiEAhHMZuB75\nJtod3hivTk2XxCqMX6PuQl/biAtLTkbMi3o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8537", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8537` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVBS8aHV/FwKdAQALFAcneCBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjZTZlZmQ3LTI5NzQtNDVhZS05M2RhLTU0YjQzNGJhNjU1ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZiZjk2ZmQtZWVm\nYi00MGQzLTgxMzItZDQ2MjI5OGVjZmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV+fEo0fSkmYqkKn2tm1SGs0USvCi4NMYWsaSqJiUZRvg2OpC/TQA/7GOX/V9\n47cake8GevKLzKFIlEy6EwalvKOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7arv4l16OpTWlcgZiNQosDBNnwIwHwYDVR0j\nBBgwFoAUDomu0x/HLXtUct852k2ebhQvxUEwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCICoEg7xbm6EicOG6N8AbCdU1tv37OVxtrhRcrDdtc5jWAiEAifTy\n5h8irPp2PmlPa8KDngAs0V6rMMa15CyQjEt0qHU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASTb8bepSPYRARAKIN/fFznuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nY2U2ZWZkNy0yOTc0LTQ1YWUtOTNkYS01NGI0MzRiYTY1NWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMSZQ16n63DVcpnyjs2POS2t/lVOQVqXrkf8CpZ86T0tD1\n01NyINbci3Y5zS3Z2xyHnFESNrQjgrShsLej86GCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDomu0x/HLXtUct852k2ebhQv\nxUEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPvx1sO/QLH73Jbg36CBwsPikhBdnf9/xHtMgKKXFsdCAiEAp1hzYLUm\nGbaBBckDB7lz3Mu9uE1/UceHWbyqimHxoxw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAbOscj65cEfoQA1HGMdvSweIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZiZjk2ZmQtZWVmYi00MGQzLTgxMzItZDQ2MjI5OGVjZmI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzZmMjU5MDgtNjdmMC00\nNmQ2LWE1ZjQtMzQwOGM3MTVhZjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nV4kgxbApxvYcV+TI16/K7bNmMzrWnNiB4zP5dJEmJORO+wjkHwhqO5U/+uSY9ekG\n6be2tZtmAyHY9lxu3ziaU6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7arv4l16OpTWlcgZ\niNQosDBNnwIwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIGcEqMdDGVVGmV0jLOOMD9OyCG8nWpwLZVg8P2CzGw3eAiEA5QaahpQo\nXje7nOaXs14fIloJ17bCrqQrWcM6wci6MYg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8538", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8538` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWDCCAf+gAwIBAgISAdyMak108rR5PRyRkj1g5ATsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlYmZjZWQ0LTJjZTctNGU4NC04MTMxLWU0NjNlNTAzMGMzNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTE0MjM1NDYtMDQ4\nNy00YzkxLTlhMjEtZmNlYmMyOWQ3ZGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6qFRb1u0+dAZXYXDiAtYTnF4suErkUzxhYTumECkbKtCVYFMwdHVzVL+cf1F\n3uEndlPMhS+09ApgwNb+QUGhZqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbv+198wy/f3ygUDd5kDCn5jEEbwwHwYDVR0j\nBBgwFoAUz3LuFkFPvdOwGzUb68Gp5SIyezMwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0cAMEQCIHutrRoPXlRPv8JAC9Yppuj6g+6yVJCWi5jFB4L3GfwVAiA6XRWX\nFgi4U6lxycJF1o1+7n81+qaGEApswVbLVdU1bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARZXj7iUnM9ei+5Sq/W8KzCOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZWJmY2VkNC0yY2U3LTRlODQtODEzMS1lNDYzZTUwMzBjMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQy9a2mUXf1oC4L8KapK27WDfmTSMl/CWVZaWquDH86rsbS\nscXP6DokN4ScrZHuDoR5bhLO6piMW9n20aHrPGA1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz3LuFkFPvdOwGzUb68Gp5SIy\nezMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOrstrfyss3sYKbDcVRncnCIZus7TPZ09hUFWdRoOhBEAiEAmfFaP5e6\nCodWZh6bZGLoBJcZHF/jKm9ytuaGrNshRj4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAe1ITqR8O1SP41J1g3rzpbARMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTE0MjM1NDYtMDQ4Ny00YzkxLTlhMjEtZmNlYmMyOWQ3ZGU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzQ1OTI1Y2UtNDk4MC00\nMzljLTk5MTEtYTFkNDE5OTM3NDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nROXFB73jyL4zpbdbUg2+hww0BhlV/qyCnAcJfp36MUTPTwGrYYXDzksBehgDteYP\nlKrGQYiHBjFPUb63R5z6sqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbv+198wy/f3ygUDd\n5kDCn5jEEbwwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIG8GCgqsEV31PtkBo1j6jUq3iCpNhuUJqsb1fZGHIZTCAiEAlFuAf9hQ\n4yhSWbztYxOe+C30mTJOLQ2KYbNajfPe5PY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8539", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8539` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAZsO6kDSIdViTSIQDxwmJZ7iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkYmJlMWVjLWRiZTYtNDE3My1hNjBiLWMyYWEwZTc0MGZkNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNmODYzZWYtYTkw\nMC00NjE0LWEyYTUtM2VhNzk2OGJmZjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkuxc7rck3g6LUJmy/Vr9yPyYCyZ3Zfe6yxQxr9dvFnM5iLLd5u9eRIAQ6ZJy\nvx68BnEMDxrb19aruawgZwMNIKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBScvdwPIInB3B65HYZ04fZD0Wx1tDAfBgNVHSME\nGDAWgBRXgaNhrtg98m040aaSb+IuL68kQDAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCapn7WALnzTFhsOyoARymv0RVLEd5+\nLMq8SpOiZAKdEgIhAKtbNLqO4x0op829R47f3EcqSMv0qSbrBByrErtqOc/p\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcWb2bqSthPmCLG0H+CBv2iTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGJiZTFlYy1kYmU2LTQxNzMtYTYwYi1jMmFhMGU3NDBmZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIjX0x1H329EEJqG+eoy+Vu0+MIyp6LMAwP1V24V//sby7\nxun//HhvfU6Mi3S0wgKRP5zMSCGyZAxrU2ZYJRDto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV4GjYa7YPfJtONGmkm/iLi+v\nJEAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOuBw6c0U4N4ovcKLXflgYD1U3USI6rCGe2+5KmSb8rNAiB+LSyDvzY1\n2vrN6Z7xiG4L8nZaEpaeDUesJkzfTISZ4A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAVcS+d9HXbkyO+sjWoKBCaCcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNmODYzZWYtYTkwMC00NjE0LWEyYTUtM2VhNzk2OGJmZjAxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDFhMTZiMDktYzcwMS00\nMGRlLWIwNTktZTAyOGQ5MGMzZWJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nddUPzE7trx0KefdHDjRpM7W6FjexZ8GjXxBKf/QS4pZUFWBOl1NyxbfxhTxS6hlS\nR7ssO7aPRUWTXjIWJUdS5KNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnL3cDyCJwdweuR2G\ndOH2Q9FsdbQwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCICgShqOOjFXtHEZaRdfiCpr/wIdftusp1RTSC/evIwIQAiBPOqZJYvV9\nlknoo8nhoI93mog2nrThCNvm6Ebeg9turg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8540", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8540` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISATrlmmAPmPT6Q5gYrIX+98UCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNmZiMTFjLTlhOTktNDQwMy1iMzk2LTcyNTlmYmRjYmQyMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAzOWQ2OTctMTQw\nNi00MzlmLWFmNjctZTYyOTE0NDc2YTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+WawryoI+5lxDXtTKiMQzK87YuYI2BdIWeoO2G6tIiJPEdHacciVTC9yni4l\n8UEQpDG7PnzgNB24dgpWgzpSrqOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdweC6ORIVn2S9/zFS/faPA5FCuQwHwYDVR0j\nBBgwFoAUMdAu0hM20oOW7hvaoxVo7QDc8aUwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIBWieAOaxu1s\ns3KGfXzBaoNk0GDOKd7C+Xieha5z//qpAiEAjyTBUSrcBtxVAu4qPFxkSc22WaR5\nMaxvJyZ8oujdRAw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9YSHdYhuRaM8qkpv286tRIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDZmYjExYy05YTk5LTQ0MDMtYjM5Ni03MjU5ZmJkY2JkMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeQXxBvlHvsRFD2jn/sD+QfaC294uDmJ7iBs7LzBigQLsY\nzruquVJ6qk7IxsxoOvU8TJekAMPTa+h00P+FZKq+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMdAu0hM20oOW7hvaoxVo7QDc\n8aUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWC5h8bFKuJoHWFkwPBpQT+XxJDcVg6AaC9AMwJqfDDcCIQCJ9ohnWp+A\n3C32PHOC5t7SqJCmEYv0sAynPnbRXUXsGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAdSy/dQWvKXMkVws+aVNqxqhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAzOWQ2OTctMTQwNi00MzlmLWFmNjctZTYyOTE0NDc2YTM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDVjN2JlM2YtOTc0YS00\nNTZiLThiOGQtMGFiOTYyZjI2YmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPOeUXZ+CB4NE/NvYHyfZFXuyQaW1QJxwLUfDuuHVEAw2SuqES7UeYJrzRNt7b8fm\nQMMSKNq3EHmk8rLn6fiPpKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdweC6ORIVn2S9/zF\nS/faPA5FCuQwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIDex5FS+p4Z3VImbp7FE9LWaYJiZ9rcmaGlmlP1UnQEbAiB1PWtg/roC\nWdJC0dVI3G/8EkT0/pdKYzywh4KWYxlzYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8541", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8541` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAUbZFUW4TgP4JU3QCLAJ99zvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2MWYwMzgzLWMwZWQtNDg2Ni1iNjYyLWUyOTA5ZjZkYTFmZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQwMGNjYWMtNjEw\nYS00YmE2LWFhMWUtZmJhYjk4MDIxOTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJTBUM0l5KON+cP4RQqU+qgcy2OC0kdZyYBl90nTbL0WIJwcbB3BRugY1wrls\nxeDcT2E5Eg99dxW31k8ySH6Cb6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhezLqdl3YkGtudlM/iz3iLDgcMYwHwYDVR0j\nBBgwFoAUHTuN936QqjV5cCou4YsuOnZZ+kwwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCAULLdprAK\n0CBZAfwcr4HdKkBLQESpBJ+D2FLminV8twIgNaAnAxWotDoznZyCMXI3UU24+2uu\nWTjrEGdiq92FxVQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYxBGyzNiJWPxb/G8QLS4tArMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjFmMDM4My1jMGVkLTQ4NjYtYjY2Mi1lMjkwOWY2ZGExZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAulwfmVomgAPXk+MzS875J2TaClCzlkAwBASonPOaGUoc\nF6w7Ujac7dH71H9z4jpSfDDBqSoRn6NZFSHm3l2ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHTuN936QqjV5cCou4YsuOnZZ\n+kwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUuhE/zPnx95uadaxZ5m4gEvgzGKdhaP9R/QmThpIz0YCIQDz1RJBhHVt\nO7/WeFQ3e5IL7PhvjQ46WMAzLdpebKy/AA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAS790Gm8fM2o2E2fZucSW7loMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQwMGNjYWMtNjEwYS00YmE2LWFhMWUtZmJhYjk4MDIxOTU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjVhNDZhM2YtZjc3NC00\nMDc2LTkxNzItNzU5NTE2ZTBkYjJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncEESELOvnuEqO/RJoMqje6gDiqgoPuBB4VF2rNW3qbaKwA/+Qg8+JQifmxSCEDzr\nkQxV48f+AN0FQzfgI/Ymf6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhezLqdl3YkGtudlM\n/iz3iLDgcMYwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIAxjjAuiR9YUiUilJfYR1SrDBh0z/6oJFGn/dCXKNcMDAiBR4WEZtskT\nnyJHOi3PDe1f7kx3i2e1GCGzRFqF64SSeQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8542", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8542` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe6gAwIBAgISAc0k85C5tyMjFkLnzm9snISBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzYjNlNTQ5LTJhZjUtNDYyZi1iYTNkLWE5NmRjZDA5YmQxZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM1NGQ4ZjEtMjI2\nMi00ZWVkLTk3ZmItMjExMDc1NTc2MWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHfMXjlkIHJxnyd4XSv58J+ihY19IQ38RoZofx2V0HMFKmGroIWQc8prhLYav\n6XpElcOqJdpuUQbizDDIUT1gT6OBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIi+yyZcnSZIaFCRv0TXm+afZ4GAwHwYDVR0j\nBBgwFoAU1zmHorXrlFT1qiSarks898usX78wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBw0qlD6xDw\nJdlw5gyxAaZm6qLZz1F5l3Ee4J+8cuOPqAIgS1wWxFaJOAMZVeZnGfqm1RIm69SH\nq/ABXsU3EUH6tIE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUmZ4/eUrcmr43NgQCv8HHU3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2IzZTU0OS0yYWY1LTQ2MmYtYmEzZC1hOTZkY2QwOWJkMWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGYSZrYl2rFxsgYbvToCStArlVwYhrosxVThXrQHyUcDFH\ntBcTPEQ53auj5aAFS1Ot7Q8tDQaoVTu0v+EKxz4Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1zmHorXrlFT1qiSarks898us\nX78wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNL5KXX39qO/QGIMsIk4IAHa+6k2b1yWV3ex5yjZ3O5sCIQDseDs8n9lC\nCflVhtyvknJlM+PlZjbDKJz5RxSKZaa5ew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAQECBVuBZjs6ZllnGeP0Cft2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM1NGQ4ZjEtMjI2Mi00ZWVkLTk3ZmItMjExMDc1NTc2MWI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODJlNjUwNDktYmQ4NS00\nMDBkLWJhMzAtZTMxNzI1YjNiMWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nNd8IWUk07wq3i8RdDNn3Rt9mgPcYF4O+Pr/s7dAINoiuxEd7yJZ6wPj4tvWvJM/D\n0S/t5cPQAcsJcj3ldgIr4qNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIi+yyZcnSZIaFCRv\n0TXm+afZ4GAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQD4C/O+DpCHD7lMyoE1h7g0Eta1R4ujvynO7Seop7TQ9wIhAIzD39Ep\neqVHTqRgcBlo/L2BJcHqHRQomGxbhpqGKhNd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8543", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8543` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISATqfWHM2OeF0EhDj0paBnVkmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5MzNhZmI3LTAzOTktNDM2Zi04OTUyLWQzOGIxYjA1YjA4ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQ0OWQxNzUtOWJj\nNi00ODFkLWJlMGMtZDA1NmZkZjhmOTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEizXE5UO6gteV0lHMkARKwuXfaSKVAZONbx2Nog5z+rjvNuBpWGYgOkuXHChA\nh7EWkdmHHyhaR3N9bLOYOHMGl6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrsU51lOyilZBHQUeZI0APnB4pKgwHwYDVR0j\nBBgwFoAUnh/W/CC0LQRPMLN9/LlaJ8hP2N4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAyccSJKQ6p1wfyoF3eciCpPHzvhepV0zZ9If0jUrC3s0CIAM8OKDA/kXT\n4XSeZqFST2e1yxvrveA+I2jqUwQO5HS/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZkpsRkx4YWQmbNLhMMlyW2kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTMzYWZiNy0wMzk5LTQzNmYtODk1Mi1kMzhiMWIwNWIwOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3Kcluol4u2C9fLRPX/a9fyooWoG/1f+z1kzMFKyo9bvfx\nWz6h5HO8y6OiSyIsI0FkTJhQ/+wb3HCPdTok92Bto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnh/W/CC0LQRPMLN9/LlaJ8hP\n2N4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ1Ij3RqXKm2aNIlbY9eF+iQsHPR5+y2tOoEBbOquFsICIFmmY/l9Tz+a\n1k8kiDBzmZbAVEuztOwHap1raotf3JJu\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAc3Af/zGHhCFj06PYcweKfiQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQ0OWQxNzUtOWJjNi00ODFkLWJlMGMtZDA1NmZkZjhmOTA0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGI5MzczZmUtMjU0Ni00\nZTM1LTkwOGEtZDk3OTYwODI0ZDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncUar0WcyznvGt8dibLR90kVo5Qhn7LwDXjKQfgUrbGijgwYn33Afsu8ekARfESXs\nrHxsuraB+h7o/ma4SaR7MKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrsU51lOyilZBHQUe\nZI0APnB4pKgwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCiPl1wfzQvlPUQt71yrdr+cVNxWFdWAaSxEFt2vOU5vwIgJMYxoWyl\noPGSQ6NoKXQL2y+7l8vaJsqZaDGcghwVD4U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8544", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8544` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbeIfItgAEXDHDagM0F4HIS0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3MTBlM2Q5LTNjOWEtNGRjMi1iYWQwLTgwMTAxNmYxZDA1YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJkNWU3MjAtZTE5\nNC00NjdmLWE5MmQtYjE3ZWQ1NDExOWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERghQE3RzI6yH9SL4eJ0rVOhmFo+P5YlPJZI4Tr4B96utPVwP3Rf8mE9atCWi\npGX27Wv0LTqYrVEXEIpWAz2MNqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTUrvcBYGNYBucIUpXz8CZNyZPR8wHwYDVR0j\nBBgwFoAU5Rm4hqZVCDG18dqvC/QVUX5TFocwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAzSJnTBT4176hSTNZGBug+QJDRNYpPsyyFZKM2VpCdNACIA7/Irv82YkE\nzo7bPs2TI0DBmKOwJb92ZKP+/fuR+0vg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR5xx4sjtCq+0b+CC3Bzfyv0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzEwZTNkOS0zYzlhLTRkYzItYmFkMC04MDEwMTZmMWQwNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASssRUeRsdkeTTQwMzhubkhsM4iTMkhJoKrKRH8VBFi7AKv\n+mSQoHtC11ifePs4mGWOh0dyuaAw7tXFlj0nL4wqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Rm4hqZVCDG18dqvC/QVUX5T\nFocwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBk3oAr1blv+35boBhJm2lB5fLx+yl6Ok42Yl62AowY4CIH6vz6Hg1u0m\nbnPfoLeKopCe4Dg9c5X539OK5rfI1i4Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAQ2sP/CsUb0xt5VcTq6Bwx/QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJkNWU3MjAtZTE5NC00NjdmLWE5MmQtYjE3ZWQ1NDExOWQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2Q1YzcwZmEtMGZiNi00\nMjMxLTg5NzItMjhkZTE2YjIwYzA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nibTYSY26aMnMNJePTD+AhyC1/CNQLzrcz8ES9f3X83HSlNKImMteNiBuEepZj5iw\n84T71BNA1w4UP5YGcwhbZ6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTUrvcBYGNYBucIUp\nXz8CZNyZPR8wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQD57R8kc8pbm3t3KTf5JUuXwW09KmbQYHJKA0+QduXNGQIgU/GkP/Pl\ncTpzm5/pPWYLADB8wN6w5As55l2nocNh/6A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8545", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8545` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAXsLeMlw7Pct6OXs87vcwDr0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwNzE2OGJmLTUxMmEtNGY0MC04Mjk3LTA2MTBkM2E1OTM5NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEwZGNiNmItYzE1\nZi00NjkzLTlmOGEtYzk3OWIxZWNjYTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzWwDW+C9hNQVRjs6iWrxpJvIXDWD/ULfP3UoB3MmlfXW6v/FEkzU2DB13na0\n1F1vAuDgezxrx/reEgnsWCh+UKOBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL7rqNLxrrzghZCZq6cIZP9kcmqowHwYDVR0j\nBBgwFoAU7AjtJUNEDGrHrVPsjJ3MEdE3jO4wMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEA\n5GIld8+dxeiacZYOdE+NQ342KT6jx0QT4o3PdYHC2RMCIDPKdrpF0mv5fJjyUczc\n/Hslz/I8EG6n/vf59M7rs0ec\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbyxew85ZBbmHb96ks+v/QMOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDcxNjhiZi01MTJhLTRmNDAtODI5Ny0wNjEwZDNhNTkzOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATme2suTF3iuxJHn6FMcRtGMWm3ESyXp4o+SgPMUd2pUGTP\np7NhCpxsFm90bU8QSy3sKwbVmGLe/s89/FW9yaLRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7AjtJUNEDGrHrVPsjJ3MEdE3\njO4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJi9l+PtKt2QMtgWUX52ZlEG4UX22xvdrm8kUWDeJUWxAiB/+kCPErDD\nHH1y+o4a8JGL6Z0N5hTO00e6EpmCcmc+hQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISASQ+vGA8RFrA87N8ScBIfVY8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEwZGNiNmItYzE1Zi00NjkzLTlmOGEtYzk3OWIxZWNjYTUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODE0ZThhOTgtZDhhZC00\nMjQ5LTlmODQtYjdhMmFhOWJlMjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nP5cHGgrQMQdi2LIQk3jokwa+voMQLZ6FCIX9OV5XXUg0O0LtueXM7J7NUkYktcjs\nUqU8EP3taIjeqYzgn5utm6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUL7rqNLxrrzghZCZq\n6cIZP9kcmqowGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDN2+DGrmVrdj/kUsPVjg7o2ZH2OO0zrUzFjqZXGBw6GQIhAIdxJyLh\nAmrMrYO5S6YWlKM2viDDImnEuL+yIcd+ZKh2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8546", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8546` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAVS+r3Ojn9JLqEvAx7QQh2wHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjYmYwY2JlLTE5NjctNDcyMy1hNjNlLTBlYTJlODFjYWU5NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc2NGEzYzgtMmI1\nOC00MWFiLWFjMjctYjA2YjY4MTUxODJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoNCUT4c1LVY5QEOazjP6McKO6t+z87rhd2Mr3swpGaVUyS+cqX2AIC3C+cVf\nPEDlqQD5JIZ9zVXdKQQXM9rTOqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8W5KpIrpvLTRuXHtdojm40HKnKowHwYDVR0j\nBBgwFoAUTujqDfo25333EcZlmBhABVSv0SUwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA5DilrksdfcgeopNXxTuLgFGRDGvwHk1TIT0a1ls2ikwCIGJw\n/t2DJrGxZMRsjXJWYaZsOIvA1Hh0P8I8kE/GW+ED\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWl8MqHYBJAELVRhDdS6y3lBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nY2JmMGNiZS0xOTY3LTQ3MjMtYTYzZS0wZWEyZTgxY2FlOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1qG81C5VbVMeVV5MEk98TtKMDhf93DDPZ3bhZLDT0Itaw\nfPGT7Ftkt001XGY7gsze3lpnxJjOabjCSOg4A4Gpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTujqDfo25333EcZlmBhABVSv\n0SUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIuGDtVYe2pIawHnq1KMa1MgKINEphXe0R3etykWCmQACIBNwPw69SSTW\nqqgU8c2A4RHHFkeYwNj1V8LkrzqnmXTG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAT3cCs8LPLECji4lpGKF6jPZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc2NGEzYzgtMmI1OC00MWFiLWFjMjctYjA2YjY4MTUxODJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGQyZGFiM2EtM2NkZS00\nOWU0LWI5MjAtMzVhNzBiZWE1NzZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGe9Q4TUmo5IS0urrr5bnn89PJtm3FVBEuTVX/6nB39pO3drMZ5+6V3EgZC3VWJS9\nAMhrIjJm0Df9v9W/WRH7rqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8W5KpIrpvLTRuXHt\ndojm40HKnKowGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIH8rFVmsSdnODaP4V9n7iBBrtRViYIwWtDV+eCoGrZBaAiEAu7nyOLGw\nb+Jo152rfGD2aSeg5Hd3qe//zPJRCoi8+3M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8547", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8547` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISAZPxj6qxMQb8LqZGFCcOm/puMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyYjdiYThmLTM0MjYtNGRlZS1hMTA2LTZhNjJmN2Q4ZDcwNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTIyNDIyZGItNGVl\nZC00OGVjLTllYTUtOGJlNzYxNWZlZDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBezitcmBVB2zO6Mi9O0NP5MwyeIEDEFf8yR7IPxiidNFcoWKMebuYSN3iL6G\nq6JxSgVEnuE9IgEqPc+St08iaaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8joeNZN9+6JKnfh/SHDSY9Rx2jIwHwYDVR0j\nBBgwFoAUvOrzudWY8ao+P3rwd03P/JntjGYwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNJADBGAiEAoTjNjJB+oPvN2C0bA0SU+dQJEXqdAgYQOI0hr9BBqI0CIQCc\nu47ep22LOvbtGS+JrpppZEEewACBPLO88CJpvqK8ng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV6+vKAI5cC77j7LCX6ZHdrLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmI3YmE4Zi0zNDI2LTRkZWUtYTEwNi02YTYyZjdkOGQ3MDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJpPy1odTXtWCEYrog8+JehTyzjvHfqFdn1Hq0wvZGdXSp\n08ql0X3uNJQ/gDfre7U60WZ3a1cjR5RtzWKR3+Opo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvOrzudWY8ao+P3rwd03P/Jnt\njGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJlkhDBXdp5iRY8+wT4SIRvPD3rFbP/VZSIRBqrkU6DECIQCX+gKIhoij\narzNhanyT5/GgjxwiSN7065BQT9DN55S6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAV+3n1PuNBV+XuyikXjxpxr7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTIyNDIyZGItNGVlZC00OGVjLTllYTUtOGJlNzYxNWZlZDRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzVhMmZhODItM2YyZC00\nNWQ5LTk3M2ItODA3YTBiMzAxY2QxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhel2BHeHWJ1rL5wH8jLhi8QBsVF/+EL8xTjxa36GpiI5u3ZY5Kefc+L3dh8T+tU2\nbTTpY2WcuQtqpJMXX1lxvaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8joeNZN9+6JKnfh/\nSHDSY9Rx2jIwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIH+5AWsuIR4QY5a9425EvVTTMIyxPs9JDXlYqU8GJwWDAiACq6PN64e8\nboonc37LWdPMswWAd1KljCw9zSzYzWYgRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8548", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8548` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAXHLyvqGKMBFVW6tgPTifuZ+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5NTczYzNjLWMzNWMtNGQ2NC1hYzI5LTkxMDY4ZjJhMDkyZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFjNzY2OWYtZWEy\nZi00ZGQzLWE1YTQtZjkxZGM5YmY2ZmM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9beptGwwhLTu5qECJKjX3jgBr9onSl3GVvIEuiv1/MvEXXirbWulBJ69dRaJ\nj9zCuiuawdHOJv3OY32Q1VKny6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjipWxnEgtkuxG7yMy47LS24pF4IwHwYDVR0j\nBBgwFoAUqEZX2zrL2HBXtzyEZ7YUOAaV2KMwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAtqbtHFDRK5vv\n2BwDvKSpfOwCXLBzWtTNsz1O0vqH/oICIGc0U69yVJwwFGCTmr39mMc0ds7Byw5p\nXt/ERAeyPh1f\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeyiihuwhw+DbKH2VUUQUfOqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTU3M2MzYy1jMzVjLTRkNjQtYWMyOS05MTA2OGYyYTA5MmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR36wDYJ3cEqATuLnSQImPzAa5/YRY0DwIqMWsopopOsxYo\nciB3/Xq0uCJVl5a4keTUJcjj9wHcR6V41mZnpKL0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqEZX2zrL2HBXtzyEZ7YUOAaV\n2KMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaFvN2nxwXlIGm+LXhVlpWio/ehBJ3iU2hQT/yrNH01oCIEFm1nmL7bsb\nHgg2gP9byIdWKkd2JZFeew/HMnEDesoY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAYNHH/cU4D5hnZsN2PTmo8cGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFjNzY2OWYtZWEyZi00ZGQzLWE1YTQtZjkxZGM5YmY2ZmM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTA1YTViYjItMWNhNC00\nNTY4LTgyMmItNDljMTVlMTdmZDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n9yUK6UEbLf3bOooLK5a85GvBug/2SrudAZyqnxQSdtd2hgkAw6yoPxshWAnz+Va3\n7n95WYeD0RhiTW66obl2GKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjipWxnEgtkuxG7yM\ny47LS24pF4IwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDq0mnxM/tOby52itXlmOLDQqjEKHHQ92EZbvD0PSajZwIgQTEPdjxM\ng2GPbPmSxgeVZ3w9c5yBDNMXYeEy1hCnLGg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8549", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8549` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAZrBnCfbZqce7VNfeEV3eoDQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMTJkZjUyLTIyMTMtNDNhMC05MGJiLTQ5MDAwZGVkODIwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgzZjUyZDMtZWU4\nMy00ODkxLThkZTktY2I1NTJmODQwNGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEogVG04/2lhMUX55FreEj/nchhiczkhfW0G/lXmZUS+dKU69uhgDOCVJJ3PYj\nZTqLbE4R04Yzp+h9sJ05ddRQZqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdXxF0hJldHQRy/8C0ZsdhW3jo2IwHwYDVR0j\nBBgwFoAUkWLy4T22iJgJIk9ZXHOHLl0ZXbEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIHlSbJYafJsmKKvp8cMAa6UfGeQMoQ7LcGC6/EQ4MjOUAiAZN5q7lvx9uleG\negcWTHKlOEecNDbcX/oq5o3cT+OrAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZIUvU7vCqGXDbfXPk3NCs6tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzEyZGY1Mi0yMjEzLTQzYTAtOTBiYi00OTAwMGRlZDgyMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFbk6HwroRaY3YwAeTYpVosFzrNWNDiYzxVIh0oo0tLqld\nzBqQjy04G0K0lBAKLUjfUwxlRPB4cizTQKQZZLsLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkWLy4T22iJgJIk9ZXHOHLl0Z\nXbEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKGe0iq/XHPK6nY1cZ55FEpmMfgrJX6fgGpo4WMjF1SFAiEAvIUK1gY2\nZVISC3zH2yvlV4kZ2diOV0DucXeQzeHnTlY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAd9i+yqoWsBBUwI4YYnLJ+94MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgzZjUyZDMtZWU4My00ODkxLThkZTktY2I1NTJmODQwNGUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2VmNDc0MzItMWQ5Ny00\nMWYyLTgyNjQtODY4ZDA3NjlmZWViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n861X7gPo7w1/YFmnCgaUj84eKmOMguO6+3mG4Jdbsehm4fuCepe4T3XRxeMoGFHq\nSlJNWKo+8CcSaTv1+IXtFKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdXxF0hJldHQRy/8C\n0ZsdhW3jo2IwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCJTAEfBrzJol8sj8zlE7BzKuKoALELtgp8/zmpmDbtagIgekzhiZOA\njtU+mpklgJflPDRP4soDiY5cbxCvq+7C2gE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8550", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8550` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISATivNOPGzEuj7s4fjKTzq0NvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1MmYzN2YxLWFhYzgtNDgwMS1iNjVkLTc4MzVmM2RmZjQxMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjgxYTlkNjAtNTY4\nMS00YzEwLWJlNTMtODhkMmE0N2M2NmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+2BdaWNUn07y3PKQMVo66uJHpS4hde9aK6WaLT5LT7ggVF7xR7DRdyzV0J1R\nP7pViGZ+JK6emkFn1UW/P4tjYaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHblhrih85BWjBf4xapgYjtoa5+IwHwYDVR0j\nBBgwFoAUjvPjHu1XcCygcwwaDgVc6tHHBjwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDzRU36L/Q4axlyn1NHAF0h0DMt98jamrnk2aPe8VayVAiBXL8orL1wCadme\neOAtLILO6LfWZA3hy7vX0nkwVqyz6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASQcSUcLNt/gBP1S5KLSqm8hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTJmMzdmMS1hYWM4LTQ4MDEtYjY1ZC03ODM1ZjNkZmY0MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6ksuXMskMFtisgbXAtR21oGGHrdnxdJSIL476XAXr4FE1\nz+x4IVMn0bffZy/4iy3R9GrVleWbi9Vycvraq6FVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjvPjHu1XcCygcwwaDgVc6tHH\nBjwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgf5WOMWKDsqCgax6m4qDl637Xfmp2vn5BjPXk3ive7sgCIDp7zIC3jmyl\nvoJUPQSkNaVSGklt5sIpH8AdTmibL0H3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAQmKIfevNjD/SLruHIqZUUR/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjgxYTlkNjAtNTY4MS00YzEwLWJlNTMtODhkMmE0N2M2NmE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmM0NzBlMzItMzQxOS00\nYzhkLTg4ZjctMWNhYzA5OWE1ZGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrJoNt9WvsxqsYRWqe19ZeQpC6sdwPXiawO6ivC96kAyvNGcqNVHxUksIiHRE1sIM\nQOP/jL6J6dKHwynP4GjJQKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHblhrih85BWjBf4x\napgYjtoa5+IwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIBbitB6ApzZSTf4Yag5J1u7I14mMRlT4ZDUPFPEWkdY+AiEA2jQYm/o0\n7lw31L+lD9+2yFHjvZQFWBv2CrUVWSTZviQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8551", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8551` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAS/0J8btS4BNOKvr3Do3lZ8LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0ZWVjNzA5LWM4YzktNDgxYi04NDk0LTI3ZDQzYzNjM2E5MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIyN2Q5YzMtODk0\nMi00ZjZhLWE5M2UtZjlkYjBlZmE3ZGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeDWU93JI0i1FCxAaigKjfyIcgdm0D+vNN587uedmgD3AkSvlKZOfpukVh/gB\nv9ro8wr3xRZsRUhIZ3d9dcBoNqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDF4Gnhgc0BlBkyiblwtKM3ZfvC8wHwYDVR0j\nBBgwFoAU1SRcB1GhBWJ5P1VCGXjUiD9wwOEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEAz9BSHGqSQP4LXZzaTq+MnnaXcAC64yI0N5ElpLVIZ2wCIGG9QaJ+RzD3\no0V3wmREfxRovrNmh9IzMVmKtrAUlmm5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQDp55yEtfOhifp7DpxGHNolMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNGVlYzcwOS1jOGM5LTQ4MWItODQ5NC0yN2Q0M2MzYzNhOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZrgsZ0NgpGGtcnwybpbrxaaZMZmiHa9rsMa8nQg7kJW9s\nK8/MUt+opH6ujr5JWx0D8Uhvx9tUeyN3SmRlZQxuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1SRcB1GhBWJ5P1VCGXjUiD9w\nwOEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDLBNgx0VsKshqsOSVo/9A60sS/HdI+ATz5MoWePRl5gCIQD2gIiBQw9c\nokF6oj59hmAeAIFelmeCRQK7oSCmhCv0Sg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISARodVpgeWNYjas+yy3EjCd1pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIyN2Q5YzMtODk0Mi00ZjZhLWE5M2UtZjlkYjBlZmE3ZGE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDQzOTljMTItMTJjNC00\nOGQwLThjNjgtY2QyN2QxNDE1ZDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8BATZovBrMKBUA6iOws5WzQy/sOtGuw8PITU1uTThValD/p4gCK7ZBMLqUGjdmiA\nXwjVG6fno3Gs+rE+02eQHKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDF4Gnhgc0BlBkyib\nlwtKM3ZfvC8wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIEoFTQ0jzl5NhlrDIQcx4tgxVmE/bzGysua5iONUcYFQAiAQUbQEWd5+\nG1h7rsvwnTLx6U5JL5vZ3574fYmLzahFQw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8552", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8552` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAe9NRoBHVT2JJvzT7XY/Sb0kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwNTE0YTM0LWFiZjYtNGRkOS1hZmIzLWVlNzdlOGFlZTdjMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU5OTYwNmYtZGYy\nYy00YzJmLTgxNzgtNWVjMWFiOGM2ZTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7CNdJRlrSApDNN95uOWbc5WirDeatDuexglhXvmtddJAUKF38/5OlSEepe+x\n4F2i8SF0xC0bkQ9d2m4wL5a56qOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULlrRl/aQWZd8kJcOkmjs5tisc10wHwYDVR0j\nBBgwFoAUZg+ZfCDuOBVmspcyH8I8Lc0t6JAwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiBIaHmCNp6kTltMYhi9AbPcKKrqPvLUIsioD6z8D3Xt\nuAIhAIUpHe+xOKUoV2vGxo3o7Q/SyexW9Bz+tGY/uc+pAxPY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAURGOl2ZmEAjBhJTAW0PW5UQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDUxNGEzNC1hYmY2LTRkZDktYWZiMy1lZTc3ZThhZWU3YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLgw86FVZpOUd5eSBCa6hHeLrKKAR/76Y669lXQAsYaxOS\n3U9cGSG9bFWQ9EN3GlGYGPlOauij4CrAbRIrQiAfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZg+ZfCDuOBVmspcyH8I8Lc0t\n6JAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJXx7aHFU0ZyQWlNIY6/fiZl2yGm0FLriysOllvRvBJtAiA0OeOaLm1n\nN+5Nb/qenwGBzIAB2t+UVCD2aHbYun/8FA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISASLJvxjPCG9StVeB0Z7AYta9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU5OTYwNmYtZGYyYy00YzJmLTgxNzgtNWVjMWFiOGM2ZTZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDMzZmIyZjctMGNjMS00\nZTUwLThjNmItNGNiZWI3OGYzODYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6x/EVCsZLJ3NxPCUhOFjPBJiEds5hqNaTW/9SO7END8uw7WBWFHswalEqZSzXa53\negcTVdNVjR8rMrVlgvCkbaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULlrRl/aQWZd8kJcO\nkmjs5tisc10wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCvGXw66LlS3R7D+yS29iUhhO/+y34uRn0zIrxR58huHwIhAKX77feU\nn/bvgoQIFMWMBV9BH5L7jJJ11xUtCV521bA0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8553", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8553` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAbUuBV/HSL3fOA2ZXKt7GPZ4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyYzMxZjcwLWMzZGUtNDA1OS05Mjc2LWM1ZWViYWE1NzNlZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY4MWQzOTUtOGVl\nNy00NjdjLWFkZTgtMmZiYzRhNzcwYTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnNloWlnFXgaXFqb6zwvR2zcNpyUd8oV0x5WgOpT64Cy33IqBijJOJ1Mzv9xi\nv3hxNFXpMfRz8yAqZr+YgpmgGaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuNrFCAAj81bilrIeDt2V6KuZCmwwHwYDVR0j\nBBgwFoAUj+NfRCWjf2qP2sCRDXEJpsIPtsQwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEArhpwR0Hi1QTrbEjnJI/VclyyvdFPnd0Pm7ffelX1\nGCsCIDN9NpwZZvAXJGAkvq0FByL63kV/DYzeAyDPsNhDQQAl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASDbXAurUEbOcn8+pzZ7JRXOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmMzMWY3MC1jM2RlLTQwNTktOTI3Ni1jNWVlYmFhNTczZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSCKJy+698YbJR+1ie1ELv18sP/nekDnwdCTSuspQwv93d\nu7pH5RwVDpUdDBgNSPfgxBEx1No/CdWWCRE43sJeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj+NfRCWjf2qP2sCRDXEJpsIP\ntsQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAItQTczGS2HicJJQ3EtB820r+ZkjEspuzgcpE2qu1N6aAiBK0mlHTu6c\n5A72PtNFII4HDPE8Qnes3EQA/XNMk8rcDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAdavgd+/vmDTXyGVPOIhNrFLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY4MWQzOTUtOGVlNy00NjdjLWFkZTgtMmZiYzRhNzcwYTJmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzIzYTg4ZWMtNjAxMi00\nMmY4LWI1YzktOTVhODhkNGJkMDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nM3tJGOeLitl1GG30Te+GcGQz41B/x6jMn6ocsWusXAAczkmrRSuZ58IIY/fL3lgh\n4bvEnyJWlOQR1HnIc7PbTKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUuNrFCAAj81bilrIe\nDt2V6KuZCmwwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCyKHCsFqdi5T0yX8MpWWk9OVvWxokOzTDZrV2JXAc6rQIhAPdycgnG\n8OjRO7QkUx2Ik8hueH2dA/Ox2dcuRy0TSH7w\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8554", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8554` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAT4yH2dcdexpFQi9j0pnvofdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0MWM4MWIyLTFjZjctNGJhZS1hMDIxLWJlYzU5MzZkM2Y0MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU0MzI0NDItYWI4\nNC00N2IxLWJiMWUtN2E2MmM0ZDU5NWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXefe5x0VTS1JmHJ0r3ULb1m99gyLktc8O2/ZpbT3A+pxci5O5S/kgrroXIA9\nEn8rCa9bE9cUGIO8uSTpcT56qqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8iy3TYoX4GlKkda8rFeOoC9kwc4wHwYDVR0j\nBBgwFoAUkO1JAY/mtGNwu0RRw482TdIZfCowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNHADBEAiAn7LcC/h6Yyw44yf/BkDFz2WVGf8oEFTEZLU7WKUWHigIgYWgZ\nPmBAR1MU0dEhz/On0CQUyvhlJd5jyC9Rh5aVrDg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXcCK/oEq6UbzgObegjRiRSzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDFjODFiMi0xY2Y3LTRiYWUtYTAyMS1iZWM1OTM2ZDNmNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqPB6lx7Q4LP/UkU/2vgoizxEfRShtX2RqBdY2suxTIQGN\nKSg591yZfYY20GeMP1t10FXVKRp/3XzPXZ1hKIduo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkO1JAY/mtGNwu0RRw482TdIZ\nfCowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANvNb7iXC0FLUbD9DnbnvWd2TmEFYkp2Y4GWke7NlPY+AiAekbym6Sc3\naw9tQuewGP92SsS+JN5A4cVBZXiI8HDI1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAb8sQoNmyCxtun9Pi1zuMsonMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU0MzI0NDItYWI4NC00N2IxLWJiMWUtN2E2MmM0ZDU5NWIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2I3ZGNhNTAtOWRhYy00\nZDZmLWJkMjctN2QwMTMzMjczMmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEGh3U9KAzRGaliM7VEszFFmMFzqN3HRiEPKA59phQ2uzKwthFWu8i+nuR8pHlvsE\nPqJ/I+1+LTmnZqPzfyGC7KNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8iy3TYoX4GlKkda8\nrFeOoC9kwc4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIB4YpIPO9Hs9x7LM3L5u8DwBD5MhwquIcm6NzV8rl/3mAiAHSMdJxmrM\nPsIFRkdKfym3lTmax5gkbsa0BfP4j5veYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8555", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8555` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASp8wNeA0KAH9/fhYk7+1tD/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg0YWZiOTcyLTFkZTUtNDg3My1iY2FjLWIwNzI4OWQ1OWE2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDVlN2I5YWUtZDA3\nZC00ZjVhLTlkNzMtYjIzYTI4ZDA1OTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+qO+7MfCWcBxlO7eWECwjjX67vN+s0DG3hVuZ/o3OZ5Xh9O24Hv0t1QLM5gA\nF5HYsnbJU856NEsUi+/+wWAOnKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyhWdnLv2WLd4HKrRbg6fBAJiJI8wHwYDVR0j\nBBgwFoAU4zUVpnbRqtLzzgw+1vWWyP8KDF4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAqE3Sy1uBudZ2qYv6WfU7lSgjgIYDBn5e\nkfuk5Wz/L/YCICQ9usBhBx7G0ZblSahOHltL4RZ50a1OmnDlCaDF5HwM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbgLSRCLidIv9bCS250607t8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNGFmYjk3Mi0xZGU1LTQ4NzMtYmNhYy1iMDcyODlkNTlhNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQks0lXQiOx7RmJPOLfCXeAwwOFCjE0E7tdeB/85La497wH\njsWGLC4+F+uKkP1WxCy0r/bKm6oT9+r4FlORMaeCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4zUVpnbRqtLzzgw+1vWWyP8K\nDF4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKZ+Pd5cmNu4gs8oKF5Dr/oZxEH0duXx0wWcHeHKu67wAiBixSCUbX6C\nqPkRzbp8/QZ1dNNW5r0IuQMo8vFpK2/Q5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAZsFR5VtXFwj34HMcD8jWAGYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDVlN2I5YWUtZDA3ZC00ZjVhLTlkNzMtYjIzYTI4ZDA1OTUwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODFhMzU2YjMtNmY1Yi00\nMWE4LWE0ZTItNGRjNjY5ZGQxNjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVZj/TCp3SzEpWlasblQXF/hwMdl29lBpPluNyOfn27kLStb6M92zYkMZ0UoMtAfd\ne6HztGyKVM1+8tsIWxmylqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyhWdnLv2WLd4HKrR\nbg6fBAJiJI8wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCOxNKoL7r+NbAwr/Tz86jV53IIhPGXW2h7FCXdTxizPAIgAPsDNquL\naiCHb66g3tp/q6lAe0n9wGMeBH9rZQwI2yU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8556", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8556` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAYnUSTwnK8uAN4z2NrPBGVjaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0ZThlNTJlLWRhNmMtNDdlMC1iMjJiLTdjYTAwYjc3ZDQ2ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQxOGQ5MGYtODU0\nNC00YjgwLThhMWUtZjcxOTJjNDU0ZjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd6UkwDzYfFZCVAKqwC6BPZv/Y0t7iZ7F7hDdCkrlcmgGb080B7oYn0Z1UvPn\nvQiuqjRHuCDi+NfJ334ub9kfWaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZwvVdLn8VZHCZocpU4mlcptvl6owHwYDVR0j\nBBgwFoAUonM7dz9NYe5yGvZA4zXNZnI2HO0wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAZaB+Fqr0Cat4k7YqJabrf/pACiZ7QAZg3\nDkO3ZO0I2QIgFzmlcQT1R3f7m1c0dcrisgYsobqbx4wREPc9N1qK1HQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVIoPNaBW5MnyjIwIkjxejuIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGU4ZTUyZS1kYTZjLTQ3ZTAtYjIyYi03Y2EwMGI3N2Q0NmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR92WkQmofMPcsnu7GJr1eQOwJ4qBtPVlMLVyE2ZC5lXUOg\niATeulSXN3pdYpRzoPVHxK5ygqc+pInS70K1OP9Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUonM7dz9NYe5yGvZA4zXNZnI2\nHO0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN7vT6wAzZEv2YOVMDpU6asuj6ayX2x3PeuVHxhczRkcAiBretiAmYEf\nGNjn9i4t9qhCQE2IQD37ZjaAex2+zd9oQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAaqXIYy4PqCHIFH3MxsUogSsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQxOGQ5MGYtODU0NC00YjgwLThhMWUtZjcxOTJjNDU0ZjNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWMyNWY4YjQtYWJmMi00\nNzNhLWJkZjktZjkwOGFjNzhiNzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6jWtQ2e3OGlSU855HuxAmRSPcoWf1AN44YaoCez5azGYgI0UXVmStSoT2xtiqHAb\ngN+bOlrBJm9oJEQytcR4bKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZwvVdLn8VZHCZocp\nU4mlcptvl6owGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIFBWyX1NypkDXVPjPbewPtSDKwWXKczqE4XgwnZ0TzLuAiBdTOLVYRd/\n8i5QWyPsJxNzr5RzLdUu+aO9kCPj0a8rJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8557", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8557` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAb+bfxIgiOc+r3GbpX5Lv6mrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZTM4ZGRhLWNkMjYtNGQ1My04M2YzLWNjZWRmNWUwNjQzZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE1NDZiZGMtMjc4\nNy00NjIwLWE1MjAtNTNlNmFiZTZhMjI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVmzXJGlgh2tsCFB16he1PbTstjbVaWkvPSnLrkBLPWwWxBz/YBV38raDZPAR\nSJVNU3wMX8kOYk+wzP0H/0MweqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH5ql0xh9WK6S8x+IKMZI+OltET8wHwYDVR0j\nBBgwFoAUs2fOaPvE4iSHlh3/Gl9mfO//pGgwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEA9c8z1l3pty06\naNxavBszoBWHZHM7DF4+bdoWlfiRbJ0CIF/guws4x3sIH8QNmYdAXJWZL37USJgN\nuEyKAbUvIQha\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX0GgLKzU7nfRzT8LRyF8G47MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmUzOGRkYS1jZDI2LTRkNTMtODNmMy1jY2VkZjVlMDY0M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyaBjm2UL20VNEJFeZQ/DTF5EaRh/Ciz6RPLQXaEf6Fya2\nVg8bYVeHF7AXUFT0SU5jL8RHzkL6DE9Fq2cLuBUgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs2fOaPvE4iSHlh3/Gl9mfO//\npGgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIfEkKgWP7OK+UKe8HRyurk+Bc9l0+Gu1M2L9y8NMcrUQIhAJvmn8RxrKsp\n1X1tFjNSd98o8Xdm1JPCRRIqayMw32Ug\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISATiePmocV0XF4A4xCgHPNUM9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE1NDZiZGMtMjc4Ny00NjIwLWE1MjAtNTNlNmFiZTZhMjI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzNiZDdhZjAtMTZjNi00\nOWZjLWJhMWUtYTRjMTBmYjc1NGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nehuxQYsgW/eUmYwP9f/79+dOEJRtQZfpJMjPJ+7nHdY8cJOirNdlIiYySFjk1idy\nKGT47xfCH6gnwlCzdR5T2KNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUH5ql0xh9WK6S8x+I\nKMZI+OltET8wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIFUQgMPTvFqAMvU9csovH0qoZeiZUlrGG39enZRheR3JAiEAzDjO60jO\nX+6+do7NTT/BUjsl0+DgSWMXw4klF1GEkM4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8558", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8558` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbOi2Ywdvw9jxUG7N/e8LPEvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4YmU0NTc4LTFjZTItNDdhNS05NTJmLTNjMmYzZTI4NTU3ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmM0ZDU4OGMtMGVh\nZC00Mjc1LTkyZTUtNGJlYjNhZWNiMjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOxYYUQf52x1xX7WYzFRpLMZ4NejaIf6iwTC3Zly1nLMd3uxXsG4npalwbanz\nmv0eMG+NXswLz78Sx+GTTv+vGKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+u42GgQ3zK9GaZiA6cqf0N+nWQwHwYDVR0j\nBBgwFoAU86Cm4HNz4Gt15+1FXDV3yO9N3nIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDQ/J6yiW4o9b3uhUXITxbA+3XDNU2s+WDJLY5x+TDoMAiEArksTE6jO0fYd\nfbBk25+5PJ7X/Yq2w132JMXn7apNLH8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYETXK1b2KdJGOIlJua4wFdtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGJlNDU3OC0xY2UyLTQ3YTUtOTUyZi0zYzJmM2UyODU1N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUST8EZXfyDChqZ6ARCDgRrI9xzOykHj/G898+UHh4qCt0\nbZ2YusaCRvoIx+7uONuy32usm0mD9ij/8CNAUrMVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU86Cm4HNz4Gt15+1FXDV3yO9N\n3nIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO60A6A4GXsBWADDmi/aBNKax28A2EhvO6MC4eqKIDFDAiBstv+0e4ef\nJAJv7EO+tUxCEAn3LTtagVIEJaTwuWeScA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAVYBd8akyfb54aXWqULdBNjEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmM0ZDU4OGMtMGVhZC00Mjc1LTkyZTUtNGJlYjNhZWNiMjZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWFkOGM1M2EtODY1Ni00\nNzlkLTkyOTUtZGUyNjBkNjg1YjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxJjkW7lXabQ0Kl+bR3ZZBxc+Q6EDo6PbAwtANxLwcEjikENswGVjkRcdhvc9Bzzo\nuzvaYJEPR71mVF8fqdskE6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUu+u42GgQ3zK9GaZi\nA6cqf0N+nWQwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIGb61YmN4XjCUV6YmZLHzCT/GC5keedscvSrpvhgaEfpAiEA06MpKpNj\nHxaxk6ui1ojXuBDoIXJu7IL25V9C7YJgJg4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8559", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8559` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAa5azbuHOGsrfWq7Obg7Vc7uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxNDNhNzM1LWRjZWItNDNiNC1iZjAzLWVmOWQyOGYzNjBmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdkMmNiMmYtODEx\nOS00NDNhLTkzYzgtMjg2NDg4MDUxZTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8QMwFj8Z+CRYtigVRNB9Vlq1HAibzY5d7WaFaoCXhihjUnV9w6qjrKmle6w+\nLKBLyMOd5yr/WMk5OAKKtYUKNaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI7xZnIk0ohms33Tcf3BYSxO6jrYwHwYDVR0j\nBBgwFoAUqjr3hjqO13PFgQIJK4L5oJ/Q838wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIDuVKDUARkLLuv8eP5BNv91VhbLUBYc681vqJyN5QkMOAiEA+Jl4r0j1426s\nWMb5XTGUf2J/jOC8O+STBVVSJajoQF8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR6N/ZQDoYnT++lVm45Zp0qdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTQzYTczNS1kY2ViLTQzYjQtYmYwMy1lZjlkMjhmMzYwZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPA5mnWH9QqKsd7p3mh+61+imfnCDSbKK7ZfWsYClgauda\ntXeXnk7icJILCyk7m77MoU/CZa1jiTRBY5GLt/Xmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqjr3hjqO13PFgQIJK4L5oJ/Q\n838wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK2ULCod378oxINQ/OXezSm3J84m6W5nCaFGCZyPGxJ+AiEAtqpnJzvJ\n5dPsct4DKUz2+1iBZOIkmbDyROR/U95lU7o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAd00VxNQfjum0uYPiXrJ22LCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdkMmNiMmYtODExOS00NDNhLTkzYzgtMjg2NDg4MDUxZTUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2JkMzBmMDUtMzcyNC00\nMzIxLTgxMDQtMGFhZTY1ZjdiMzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nhKwQY3N8V/m1xwbJSu4p7iENRPK4F2bVFbN800OSwK6kI1g6AdeGmU1lqPA9cfDP\n7jwLKvizXuGz6RdJTbP1FqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUI7xZnIk0ohms33Tc\nf3BYSxO6jrYwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIGGXPyNwtAuh3wijhbMkGlIc62ROpDrl45y5lHCx3JYrAiBRzqAKtPCt\n9eOeDIZhuXuPEc4Cayp5XRFg7zH0DJYtxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8560", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8560` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfqgAwIBAgISAXgVfo9OiCrjRbHo/BqlZJEsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3MDAyODg4LTdjNWYtNGQ3Mi05NzJlLTcwNjNmYjgxOTI2MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM2NjU3ODQtYzE3\nZi00NWE4LWEzZWEtMWFiZWQxZWZhNGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+vdHakipXjUpgOKDHfeTKNZFuxMb3A2zSue1Y5LBJfOQgknnBQDiv19St+x2\nGJV5z1MEKpy+R8m47BiT2SLRdKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhL9kYjw7qaUPghEZqdt64EkT91owHwYDVR0j\nBBgwFoAU+kj7fB/jm8y5XfBuz4WBLAFqcrAwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNG\nADBDAiBGDRcXYqLhwUFG8BF39IpMdiXgjPKzcXy+SmZ3NC0STAIfLfqxX8tJoQKw\nJZysHW81BtRlrVRi9OzhG1oqkZCJpg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARP6Ubt/g/JIr6AD8dUTZwbwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzAwMjg4OC03YzVmLTRkNzItOTcyZS03MDYzZmI4MTkyNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQELFc4sH5wG9fh0N5SUSvopwIBJyuyQfynU8q7/VMaMSTv\nILtEr0YmU7XphcZBbIk13EDSJ4h9KN/gu+V6bmhqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+kj7fB/jm8y5XfBuz4WBLAFq\ncrAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSGmfkF8Q7dWS3PZ5SIJMWX8TOS7NOm4SgRYDt9gh5j4CIFElGrGSHK9H\nZ0gmub4hP9SZKVmDQRmn3K6VFvV2eVAZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAVkosXMo54rfBy/LBtImBS1eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM2NjU3ODQtYzE3Zi00NWE4LWEzZWEtMWFiZWQxZWZhNGYxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTFlNzA1NWItNGRhZi00\nMDU0LTk5NTctYTUxN2JiYmNiZDhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfRbO9I8qEQfrXQnBvMlOx6c2tvIpFB1/3cruQaLtjbtwkSQhpoV/7coOhZ582QOs\nR1w/sCyYxneHuXm1s+6HV6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhL9kYjw7qaUPghEZ\nqdt64EkT91owGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIC0f1UOyTdgdk0+PaHhKs+UytO/O87i7Q2oLRQzJiHs4AiBowLJpuXAu\nrmEDzejpiMhoRELDHfNITaZeRKo7vhYmzQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8561", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8561` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAWzmkByZLgqPJAzSX4UEtx0NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlM2Q5ZDkzLTg4YTEtNGVkYy1iMjI5LTY1N2JiNmMwNmUzMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTUxY2UyYjItOGE4\nMC00ZjliLWE3NDUtZjFmN2Y5ODJlOTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIUkXRxto1+hoHoOgaXXvkYdGaWRPlkn0GECS3kjrKGCn8eIMHW2s2jSq6ArA\nQ8N1X0F2+E12y/Jjh+syhvZVgaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUylhTahvP/Cdbdf8OmCTULxmZZQ8wHwYDVR0j\nBBgwFoAU8VsPX7Z+NRNmEMTaR/0ZbB1+T6kwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiBOI1mZpgZPuykeiMuQANfYcZo3SyUBl+aUtEFhVwUY\nXAIgfqNNJbJ9T2C3D7aE4J1Df3WOV/ZjOItNX/b9XX6px4c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfAd6SPQ654OcCYiRYquFpnWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZTNkOWQ5My04OGExLTRlZGMtYjIyOS02NTdiYjZjMDZlMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnnG9dAqPZa4zPdsuelyldstuAprByy2pobOvnrsi2cPHK\n+ueDldTDR9GfttVg/Hn2nvth/6dlQKlmk1Cy3kP+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8VsPX7Z+NRNmEMTaR/0ZbB1+\nT6kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXQwa9eGQl6O3qeS8wdnVrkniBkeunDmAcrwnQ2fFBZoCIA+xI1GAuuM+\nzqQ1CGfv9ETb3J7RorqYGWjxjg+rhozV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAVZmMblaIK4UznITir0zSe22MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTUxY2UyYjItOGE4MC00ZjliLWE3NDUtZjFmN2Y5ODJlOTE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGNhNDU2NTItNTkwMS00\nZmU3LTg4MTQtOTQ2MDY0YmMyM2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTEmmCe+b6Pu5Qc0B7B6nW/hgjKXwac7yRR5K41+mFtqK6yP7Zd6ZTculuYYkYzZI\nRLcPVZb3YwgvzbRmvE0AaaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUylhTahvP/Cdbdf8O\nmCTULxmZZQ8wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCqJU+2EG2cE3okwoN0KIo7Rt/Dcyyyu7zSo0avizB4yAIhAMt/ECv1\nt8xGyrHDLN2yTy5GXyJ0PJ3z4jGpNZ+IaZDk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8562", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8562` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAfTo+di1sLZmwWEtLm7zp4lqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhNTRjZTU1LTJhYjctNDlmYy04ZDU2LWMwMzgzNDIzNzc0ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzdmMjczYjYtOGE0\nZi00ZmZhLWI2YjgtOWNmYzg2MGMxNTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn2YhpSJ/rJRLG9z+J/jrNcO3v5pT+lWEuB8jMWRRy0SO+mrPTlQiVYcA03xg\nG4YnEHwyYw+8OkSOGmZK9qDGVaOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUamrgUzDLcyTy4beWOJfu9MrdlkwwHwYDVR0j\nBBgwFoAUsM7cxNHkT8gYSwyXBSlpj5dMM9IwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA6gLHd/Y+/X+/kRYtTfAF51Nbz4cWmlK57JzHiNLY\ng9wCIQDwQim3IfLh1forJKNOsBGOl0ZDQWHvNrM0KavGNTsV2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASXGuTtQ4I6w3GWFFcMKXGJlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTU0Y2U1NS0yYWI3LTQ5ZmMtOGQ1Ni1jMDM4MzQyMzc3NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnoqflzt9E1yaI83fdwllUAW/9+g+BU8QSWNIY5MxfNrYn\nrwCLYVYKGOGUxIlPaDQMCCvRmgOZIzsqqt34Mln7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsM7cxNHkT8gYSwyXBSlpj5dM\nM9IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIZzyxFlIe629FTc56QLCk5Rg1hjo4fLii6VzwOYfcTlAiA1JOnATR/0\nm5vmc8LY3a/q8lS8og6hplwPJUaWuTd10w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAZPAPkbgJ1c6FfAmtpGEQlJXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzdmMjczYjYtOGE0Zi00ZmZhLWI2YjgtOWNmYzg2MGMxNTM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmUxODY0YmEtZDkyMC00\nOWE1LWE3YTQtZDExYTg1NWNmMDdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niySZIVokYlmXPOvrA2HAH4qze4cE/dnWl3ocYdoYvKVoiY1brVlCpHMmPPN75wUU\nnPXDxljB+cufQ6KCmj1S1aNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUamrgUzDLcyTy4beW\nOJfu9MrdlkwwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCyAchEuuWJgEJwYitcHDLYUJo3KeYyRERe22M55yDNLwIgGFmS8669\nOTeNQrKfRBrluwhKtAAA+07iO+0avY+gWa4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8563", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8563` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQUqPktA53hMh+cwrK3+ubSDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5YzkxZjk2LTg4MGUtNGExOS1iYjAyLWIyMzA3MTI5NjU0NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY2MjkzOTQtMTdl\nMS00ZjRjLThmMjQtNmUxODhlZjUxZDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOBgU6moSx8Ggjpp8PUcT+VO+nzvdtxuL5mRJxieo8yqfJIPlF0dP3vZBWkBu\ntgP3Hv+nIZf/tUw2fj6MgGvU2qOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUffs1moChZRegBmuPCURqKDM0bacwHwYDVR0j\nBBgwFoAUbro3jAc3CnlXK/OLTaL9tD8Z+f8wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA9ZtDx8Vfr7ChGzo4M6sE6umW+7nrltTn+kaYen1UEGwCIE0P\nD9TjjRRJzOxu567wauk+2RUkvi4b9HBFkJ4MNoNE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR4YyL7Y1wD/0ekRchrQPXweMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOWM5MWY5Ni04ODBlLTRhMTktYmIwMi1iMjMwNzEyOTY1NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPw+kAonLMtKMmcDx3StqxJ2DMEa42fzJgw9yB97t4tuSh\niG4vjOIyqLys8uni6RLx3F9dGRfk5zNR2FzhzX2ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbro3jAc3CnlXK/OLTaL9tD8Z\n+f8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJVz0fmNg56qmCrmRHrrlIzkA4NcAE95T3j02jNUO8PnAiAfHm9WInLw\n/JcrwzJLoobRroCtur/ZMX3P7811UNNvwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAUWrkEpXarwPLspb+fIbG72iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY2MjkzOTQtMTdlMS00ZjRjLThmMjQtNmUxODhlZjUxZDlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmYwOTljZjUtNTNkMC00\nM2IxLWIyMWEtNzczMjlhM2NkMjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzNn8r09uYe2h0P8VhZkBsH++z/wq3NVkpNCleF5aKUzcwfD+Domo0ezwe+FYzRB5\n24iXJ40Xb1vZu/CK9G3ZDKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUffs1moChZRegBmuP\nCURqKDM0bacwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCICgo1+4kO0iacnRPTwCcOi0SxPgja0CaAviLmpgMSETnAiAtIfXGmHKe\nfnp7DPej59RzWepVLx+HL8P2FqWw25560Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8564", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8564` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAe1yPf/VyAcshevqGtj52VVZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyOGFhNjU2LTgwNmUtNDViMi05MGFjLWNkNThiM2ZjMzMzMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTI3M2M0NDYtMGIy\nNC00ZDNmLTg5YjYtNWM2OTBhZGJiMTMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/hvpQxITPGd94iuD3uC6DUII0rraShNRAJDT6r8FjYSkLkDC74rs+Uoa/nff\nNOXNE2LaIuBO+tvjaWWYq+XEo6OBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULn3TSj/EqG0hkHvo2PkFix6FZ3AwHwYDVR0j\nBBgwFoAUJrlLTfbuSB3i4q8duuh9JlIlZXwwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiA5KaACWf9bCeQdeSmuB8gy1qFE7cz61Ex3\n70YwZHyGgAIhANAEA4OxVRnEhYs1NYUB/DW2cv73EKKnFvAmtnE8/c4r\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARWmpeK4UcopW4ZnnnBsnsIHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjhhYTY1Ni04MDZlLTQ1YjItOTBhYy1jZDU4YjNmYzMzMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUcaUeSkFxi6d4Eg8g6e+xzvBaJA3PXsyShtVOToO93q+G\ny8bv6gZ6zxcvAZEws7WU8fH1WNykUcDRkTJn3+bpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJrlLTfbuSB3i4q8duuh9JlIl\nZXwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIhAN5UDK93TwrXviyOcgIsWvKaI0kunkP34D+3SZRVBW/6Ah9k+/TVCGR9\nlauoydNUQO7HFANF0SlOK7uTKgLuY49J\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAb4pe8UMMx7Q/mdDT+qjcxxZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTI3M2M0NDYtMGIyNC00ZDNmLTg5YjYtNWM2OTBhZGJiMTMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmRiMmQ4ZDItMzk4OS00\nZGY0LTk5YWMtNDYxNTM5ZGY3NGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLqzAMFX8ZxRWTyjsACC2xpgDqU+sRf/CcOPH3izJWOinolyOiRATZYbeqLpidwx9\nlMxy8RufLvYmhZO6GML0TKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULn3TSj/EqG0hkHvo\n2PkFix6FZ3AwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIH/D73uJGfenffPNapE1UX0obsirjxiDThwCTS4dnbxoAiEAvVTva3XF\nkreb7o4EGLhDD7Qxu4psNGDBcRyjC6NUOxY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8565", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8565` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISASmUqXmhzkham7QdHO55HhhzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1MmU0YjlmLWJlZDgtNDRhMC04YTlmLWYyN2NiY2I0ZmJkNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkxNjFiMDctYzgz\nMS00OTkyLTg5NWItMWFkMTViYTM0YTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEai4oQM43wMgjtMxky+kRvdI+c08GEzpCWbXybb5kFXF/oiBZ0kbPqJtjNOSJ\nSh76uXRQBryN98zRDasQ02feyaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeqWPi2wa8f0iUuv+LEqfh4kpmrYwHwYDVR0j\nBBgwFoAUFprzqhDukFutFDi3mCWgWJdVL7IwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiB8mhGsWSd+I5WAjwNof2+ne2/YVUMXbazs\nmyZ/HPZngwIgBzDLR+nl9uNv6TlN6e6ZtgAMi9ePillwrGqWjLHYFWo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeCCYXRKnC12j1YDSVfS0cfVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTJlNGI5Zi1iZWQ4LTQ0YTAtOGE5Zi1mMjdjYmNiNGZiZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXEFSK3c7LNHcS64xw8cChq1WpBcdJx8Xi/0Bja/5a3qh7\n9RbP3PiEyHUhDrTOB0M897n/dgnmpWEBpVLxDvJAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFprzqhDukFutFDi3mCWgWJdV\nL7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBi6V76lP0um6/vcgu2DlUbohIyGsl/tucNIitnnaf4oCIFo53Y00F4he\noTYmHODVpBe3EoYxzm2kF7TSillwCOzY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAcmhrgqDp8tT7eO9QkhGwlspMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkxNjFiMDctYzgzMS00OTkyLTg5NWItMWFkMTViYTM0YTA2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Q4NzY0ZWYtZDAwZS00\nNzQzLWJhNzgtOTM5MmU4MzY0OTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkW6YB0Y53JidP9CuNUXWo6UFAhs5VaqDxc8MX/5Ss2kG/crO7QSdke3otwiGo247\nOhxgSwJNG87O6z4t3Nhk+6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUeqWPi2wa8f0iUuv+\nLEqfh4kpmrYwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIEHlXEo/5kqRIMv2ZtALSxxbBfwJQ15cFE4z0iaFLr8CAiEA2mp9Imi4\nOvsiApsJrramkv52T8SAxL1pnc0/yMpMXjA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8566", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8566` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAaA9Pg8okX4z4URoGO2hS4m1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2MzFkZmVjLTk3MmItNDU1ZS1hODg5LWI4NDRlMGJmNzJmZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQwOTViNmEtMDQx\nZC00ODE0LWEyMGUtMjIzZGZhYmRjMzdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUb6GwQvZgVZ7ZcTocglZrBtdEkCTZHwmhKff97N1FlvhprKvcQtZ6e2hNNkc\nZBBcdZXNtjMm54NV1JfVP1l+g6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4mUy47ZYI596261jhcU4WSIE8WkwHwYDVR0j\nBBgwFoAUs9LSOIO3ibJtKBgU6609CwlB2fowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBt1NqOLtshXqDwAdKQ8P8+6zaFd\nX0Bsc55QBEZZdw5PAiBm8NpiWeT/pyxI5sUfI+SiTWWPjO5t7LlSNMsIfcUjkA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaqtXwgjL2z/TTf5ht+/b0JFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjMxZGZlYy05NzJiLTQ1NWUtYTg4OS1iODQ0ZTBiZjcyZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASy40kKdr1SULIz2BTieSJ0CagRPKkXwk7QuZtUHt22b92p\nLoWhoV/fnS27zgqy/wQxuDBQVjWGC3wSn+pg7Xy2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs9LSOIO3ibJtKBgU6609CwlB\n2fowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBhRg4bSPLk08/aQb32HnhivAMBMyi7DNGr6qu7u5xK0CIECsI1yzNie0\n6Pa3X7jhSpC63lQH1p36RdUzSxvLCg2d\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAb+S3kfF2FRLEFcj/+bxJ7bmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQwOTViNmEtMDQxZC00ODE0LWEyMGUtMjIzZGZhYmRjMzdiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjVlZGJlZGQtZGVjZC00\nZDk5LTkyMjgtZTQxOGQ0ODAxOTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlfiTIjq/17ZyF+7jfYfFdSUmrghCNtxU/g14OMf1tg+JUOKPYUInASyfbWN8sbc2\nKkZOktQFfMlZLCuxHVxQFKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4mUy47ZYI596261j\nhcU4WSIE8WkwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIGNcQqK5ZhyDYq2YCaOE9hMVxVOUnuUkjeE5lJMaH7w3AiEAiD3+r2eG\neQk9QNKedajUYqIZ3g+nrOr0oHr9zpV4hRI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8567", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8567` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAXwzjB3lo8HcYzQgyvUcUoqpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMzM1ODJhLTI0Y2MtNDVmOS05NTRkLTQ2ZjNmNjkzZmM0NzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBkZDFmYzUtZGE1\nNS00ZmM2LWJjN2YtYmY4NjNmZjhhYmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9i1VVrq9qrf8gWxgdQXjwSzi+B/eZ9qUFcGMg/lhmBJiBbNyIxyMzJ9Hd0Zh\nVmB2ZRFwLidjvGYDUP5QxTqaR6OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq8A0ikHggUe5UXDMJqrPaPsOOhcwHwYDVR0j\nBBgwFoAUU40VqrBX8GcyV9QtzQzHu6upadgwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAN+ODgtK\nbnnW0cqjGMJ9RS3gf9UDVa1CNprrApE0ZKDRAiEA/hL/sG/RcQ/tr5xW4QYo1OWd\nrwydYFUXxv9gADm+UUQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVakYXuRi7HAkiYhqSDato6gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTMzNTgyYS0yNGNjLTQ1ZjktOTU0ZC00NmYzZjY5M2ZjNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgoyBOt5kohYYygFQ5jalnG6onDcfylkyEOrCDDFxGXpel\nvHIrxEM7RYK198CIG9GkFxd5ud6TKL/iuN1VKUQ6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUU40VqrBX8GcyV9QtzQzHu6up\nadgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMfRPPORGLb5qjLR4j1BFqgYksGWvUufzXUAwux9+2aICIDyJopHlOhGp\nlNd+GLI+CR7fouAF0u4l1WXATe5dtf85\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAdy9XQDZHYkEEi4yzdnYGUEpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBkZDFmYzUtZGE1NS00ZmM2LWJjN2YtYmY4NjNmZjhhYmZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkY2M0NmE1Y2MtN2QzNS00\nNWM3LWJkZDItOWJiOTdiM2IwNmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7/6V/QyWzFQ0cEzX1OhF94eRk7130i0XPxa/G7e/itHf1AfFKBWwOk/RbEPUz6yG\nePeyYqOoMih3mwptAShtRKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUq8A0ikHggUe5UXDM\nJqrPaPsOOhcwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIGZ54/MNc0Wsd/12yHd+BSzTHQFZ062MrEtkuzeD6SGVAiEAlo3Y8xJR\nJ6S9UhpzC0ntukswv0SaolOg0KdCjUvG4xI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8568", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8568` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAR2yctkF0FEtB1+Si99P33enMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3MmFiYWE1LTU3ZjMtNDMyOC1iZWM4LWNiMmI5YjBmZTNlMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjI5MzZkYmQtNzNh\nMS00NjE1LThmM2UtZjEyNDI5MzZkNDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0xWXOv5z5P2oRMqPFqZmsL3lwQcaSxOLksoDJgKYk+nGN+Pvcp3MRccJE7yg\n1imGtPenr9oo/GoMRvYBfhRAmaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCRKXwGhWu7KSt1g0Cve99ww8hBAwHwYDVR0j\nBBgwFoAU9tMe+uvxEFDvO0umaZ17QgneZoAwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAPxNJ+dI\nWccFZn8fPMAj9YWYRpG84U+b36suz9/c3oYqAiA64rjN8nOR8hIEdELmd7xV6crE\nuU5PBm6N4wZ0ANC/Bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATd678STxBzsRXokhct+08yKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzJhYmFhNS01N2YzLTQzMjgtYmVjOC1jYjJiOWIwZmUzZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqD24o5A+YO1x7/7Zc5aTPCz6uNYvubb6rFbiRlRnsHHXN\nF95wB3HtTZ/MBT3X7Orrm+Oos1rmcSN9seI5rSJJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9tMe+uvxEFDvO0umaZ17Qgne\nZoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKhAJkNzu/ZX21hsaFqy4A1HKg9U2xWS9FNmSZkg/3rdAiBV2657VlHx\nQVaZr+rtCJoaMp0RxApgh7Al0K7hjRUfqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAXpqBdpBXbKGgbhtpfb55K18MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjI5MzZkYmQtNzNhMS00NjE1LThmM2UtZjEyNDI5MzZkNDNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTUxZThhYWQtMmMxOC00\nMjA0LTlhNmEtMjA4NTc2NDU3MjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nnz2m3vBp+KZ+BBjrRVGPP8znrQQuJMewkBfuFQEzfDgG8k465eqstuVq8Od0xKjN\nelv4ttCL7L28EBEc8w1FaKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCRKXwGhWu7KSt1g0\nCve99ww8hBAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCICtY7AJlTXbuXE8EGvK2i70kJyN+hz4gxetb2HG2ABgmAiAk0N1Y5F3j\nUSXHY+2AQCeGz2E/2bON3J6Uoznc7aPREQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8569", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8569` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfCgAwIBAgISAbETyh26whYYp7UvXWInNm/kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmN2RjYThhLTE2OGYtNGZmYy04ZmE2LWIwNTJmNmE4NTNlNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzUwNjFjMjEtNjRi\nZC00YzE5LWI4OTAtYWE0ZTBlOGIwNTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENMTPY2QGbJhOtWf3ptAs8cl6g7rxRZtHfQ4o02eeKlqRS92l1mjYDtdSobCo\nk4yVtTtqtc8FGfZUY4hqm9c2VKOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkfXhoAD5Rhnqf9NXG/AXvTEk/kUwHwYDVR0j\nBBgwFoAUT+6VEAYbuwF/No2mIw28iTBuSFwwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCmxfbA\nbuB3e8OkAciL83JOM4NqAvFsAqdqFWWkrWppJAIgLqplrNtY35qduJFEa2WPwYmE\ni6mUOD2WY7+TO5cc3E4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdbsX/4ZDj5K97o8P1C2YJ2EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjdkY2E4YS0xNjhmLTRmZmMtOGZhNi1iMDUyZjZhODUzZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjpA59EAUN9C3XfsKFUYzSzk+wQ/4WSPR9Gr/uHKuMYE7e\nkOMGAEdOkn7BmfXhFpJPYa3Ntpfww3yzaa7Fr/ajo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT+6VEAYbuwF/No2mIw28iTBu\nSFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI5SkDWTbX8TZurfz/fgyRVPMk1mvpTov7till413AsgAiBFnVvERomd\ndruCPw01+OkwRAkWF8rVBfKt7uO4zZNoZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAaGbCQv3+suTqccodvfxXctJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzUwNjFjMjEtNjRiZC00YzE5LWI4OTAtYWE0ZTBlOGIwNTU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2FmNDJlODUtNGM1OC00\nMDc2LWJkYWItNDNmOTdjMzI0NmJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSy30oSn9jkRBDwf4W/K+wUQa13vGoYA8p10YQX0b5Kzw8TKJhXdSeujngm5e3xut\nlbbWuCE/oeclOcnh0Crzn6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkfXhoAD5Rhnqf9NX\nG/AXvTEk/kUwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQC1/6ChZi8/q/WTncDjBjZVQD5yj2GYSrgTFs8rg9QAkAIhAPKxWHXu\nVlpbOKyU9+SnKU2BtzYZhmM86pagzQdQwtX9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8570", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8570` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAWLOhXRHUHcnCsQLBtsxOLPkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyMDFkNjRkLWM5ZDYtNGIwOS05ZTY2LThjYjM2MDYxNWZkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGZhZjU5MTYtNGNm\nNi00Mjk3LWE1YmQtNzQzMzZiZjNmM2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1GoCn6MUI2OcnsfS6wJZmst0XY2PxyQNsRAePrX3v7+OuzfFadvnJ24UEi4i\nsqLhgbmhxVULJPDJ2kIbLg0S2aOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOoPcYeKgBqLYQYT/GNIua1V9PdYwHwYDVR0j\nBBgwFoAUnKknfQZGr+i4rA9cIxTwFj3V7s0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCggG6/RnF7uHNhQqNcP/e3pP/NPr6uP+6xpwylT77WxQIhANAckvRB\nnGy3tiqrbsbPJI3NtIj7KYRdSBdiBT6lZgOk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS0tDUnhcSk4Aj5iaOVxRQlAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjAxZDY0ZC1jOWQ2LTRiMDktOWU2Ni04Y2IzNjA2MTVmZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnDVRlnmlfFx0IST40OSvYWqRMctPWKDkKXoGQMI79+zZd\n+F9z1ulXrxRPyqbi4XEc+CFpPfYe2ONJYYblJ9Gdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnKknfQZGr+i4rA9cIxTwFj3V\n7s0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaZ8s6pMMN1IgiHs+loaApBXQ2bGVISPN6aI0hWnmt6ICIQCjpaGZcvv3\nfjUjwi8kFKDhUfRwr1iHt5K5T+8SZufiLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAROaMsCnR4Z60fC2fZLR9RrlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGZhZjU5MTYtNGNmNi00Mjk3LWE1YmQtNzQzMzZiZjNmM2VhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWNmNTc2NDctNzk2YS00\nYTZlLWE5NDktYmM3ZTI1MWFlMjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nl/6HYS/NVi4qQHGzDBEcwTnpm0Gz8TeEyFOC72fNhKFfLXxNGChwRHW8bcthV5/1\nKZ8Dnm3VrGlFvCTOPvk6K6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOoPcYeKgBqLYQYT/\nGNIua1V9PdYwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIF8vLaY+THp/6GjVTzYHd2j2kNGoJ9ZjFCyAkzGfPryHAiEA21i6nzSb\nS6YVVepp397wSueUD/DoM//1cxXGEV0y9AA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8571", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8571` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISATFb28toPMWkRK2Ty42TRxDjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiMzU0NWE0LWFmZjAtNDIwYy04M2JmLTgzNTBmZjk5OGJmNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWNlMWFjNzMtODg2\nYy00YTZkLWFiOTUtNDU5ZTczOGEyZDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuXsc7Ldj/WTXrs1okKOR+eXLNddQwpg9feBlrpGDvHkDH/WbnqZjTTXvZGWK\nb6MzvcuqMprNTP1VTvbjl/X1MqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaDYXTOX9+ryy+3cY3NPcP/ose1wwHwYDVR0j\nBBgwFoAUapNPoBNA/VftQ9nqPVRtrLXeGnswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDMM9q5AZrNdJVe/XVILTV5Ja57qDZHjOO282ZKFWIxCQIgK3c7gqWW\nTifZWsU36cFBUulkcZl+8Tvc7VfKhUtJCM4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAezunGVC+n6/22uJBUkFfYNeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjM1NDVhNC1hZmYwLTQyMGMtODNiZi04MzUwZmY5OThiZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYd+59xFIm/y0RMoo/UWLoxk1rOAoYSMV0E/4e+HItMOVa\nfeTqo3ySXIZSNZFtvbO7Y3+2qt/1Hfo0WpZ1LdKpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUapNPoBNA/VftQ9nqPVRtrLXe\nGnswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNVxf+UkBHmNJurnQ5Kw1z9qr9jaDPv/mQ16mzJGnrIwCIQDAHy95EsdF\ne0CLL7vLGcv0O68LZCFeZIMRwOn6MR6LYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAT+BMyzd42uXZrcQlMjuye0UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWNlMWFjNzMtODg2Yy00YTZkLWFiOTUtNDU5ZTczOGEyZDQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjJjNTI2NGYtNWYyOC00\nNzg4LWIwYzQtZjZhOGQ2NGUxZmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKkmUuKXhdZp8ChcpGcutlYwq0g7pXU4TQnRPSPDrNg2l3GQKBlpBH8BupV7SPJg7\n/7UyryQfn4F6hA/L8+396aNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaDYXTOX9+ryy+3cY\n3NPcP/ose1wwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCXt7HoMsNk39woPkH8MU/gpXBlDlnFlI7oOusAPI0g+wIgSGzqSXYf\ncT5Pwe8gMdekWfwqP8/OCCxkcXDboZ+X3jk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8572", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8572` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISAfqBF+wbwtBRsv9hJGcIFPP9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NzdjMWNiLWI5MDktNGU2OC1hNjI5LWRmMDRjM2IzMGMyZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE5YzExZGMtOGFj\nZS00ODg1LTlkZWMtMzRiNDFjZjNmYmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPLTzm2zlOF182TruS47AJ3DaHa0tIJTHVbWoJ9NTnoF7DAONjF7L8KSumlCB\nXbQ/I4Lcy4jLXMGmqCToAX0nnaOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOT/DKMg9dxNaKZhxKVjzG/irLg4wHwYDVR0j\nBBgwFoAUsIb/Ieajb+mgRIKv9JV7ThKdMoAwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQDlCcmSj6YG5/NhXtyDMWSH0XfY6Q4Q/Ncc9EVmE8f32wIgSvdXWD/UufQJtD7S\nglW0PBNrHBSM3iJx5Y3N1VMGQ4k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWlpKOQ8v9rFyrKbehJDIztdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTc3YzFjYi1iOTA5LTRlNjgtYTYyOS1kZjA0YzNiMzBjMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6gU9zTf8lB9ldpGo1C0q/ZAoVuKMPFwUBvl7f+k8O7KIJ\nr2bWHpLPkIvZKLmdj649NHMkknZGEkrWkBC8UTOao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsIb/Ieajb+mgRIKv9JV7ThKd\nMoAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAcvmP3mwuLIe1Pvi6NKvzSNZz9wqZ3QOnkqiecSIH0ICIQDUAWIaT9X+\nsJCdv1kNQGaHNe3R1TApZbuvXUlyEpVjsg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISARXSczywFdf1KrcwhTqKKEoGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE5YzExZGMtOGFjZS00ODg1LTlkZWMtMzRiNDFjZjNmYmFiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTFiZTZiNTAtODBkYy00\nNDMyLWFkYjMtOTliNWY1ODY3MDViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBF80Hn86EBfJin89AfRR7N31v/yOdHYLIrK6sh23Fr8jsWbbuIe4oiLaeid5FpHz\nuoVWw2oZplG6rwdtwRi41qNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOT/DKMg9dxNaKZhx\nKVjzG/irLg4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDFneyH3RL3TdIwfYhOzNOP9raVGoqkTNdSORbZLN3hGQIgGm2yT2aj\n9WI9F0ISc0aIhsFQ8BadiOLVUBx+1iRcV68=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8573", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8573` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAQatqoiw3tXS+5sU1KoKsAPTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMGJhNjUzLWIzOTItNGQ3My04YTRlLTViMTgzNjY3Njg3MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNjMDc1YWEtODNh\nYi00MGJiLTk3NjktYjUyODA1MWQyYzQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVOcDu2EoKOyZQcdSkqflkVOzBLAmZTiFUyZ2nBXVM9Bl8tgWpn8KWBLtaMAN\np1aPYrzoqETPUPWq6SN+Gqk7DqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCYcN8T5TUDEoBaUf+vFuXxLWgRswHwYDVR0j\nBBgwFoAUoOfwINODM0SXtVCKb3Vm65dteo4wPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIHK+ghM7b49DJdliTcp37tG63z90nf7reszT8gbIy1MyAiEA\n5sbFcW3aAV8XNxsj4HPy/FPOJgMEGOj9dFG58UeH52s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc1eyV5BmsI86nWvnezp0WPJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDBiYTY1My1iMzkyLTRkNzMtOGE0ZS01YjE4MzY2NzY4NzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ34c3HKrmCcaNWzHxPpX8cskCj9igJh4cFWqO/puOUPc32\n3NIGV0xNq+VEZhUAuH0VHrV7Kyg7kp7hJ2CP6XXoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoOfwINODM0SXtVCKb3Vm65dt\neo4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbB/f1I/ml8b7wk4I6wxUFRhQi1bP9vnEKZBpQ0fkTcsCIQDvK8RR1+Ig\n4VnXvrJtMjsbUsKU2brYrXYyQLO8W+kYxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISASH5XvaXmpxJYE+bMQ0cJ3+MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNjMDc1YWEtODNhYi00MGJiLTk3NjktYjUyODA1MWQyYzQ4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjM2YjAzZDktOTdmYi00\nMmE2LThkNzYtYmYzYTIzYjU1YjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4YoJTOojiNQOBx4GFplNX8tih4Nw6yOibTOVC0Aqn6gseiWK1Zk3ecMVE8LXjL3e\nB06qk+ilJUZTTbrNZEEPwKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCYcN8T5TUDEoBaUf\n+vFuXxLWgRswGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDyn2mMB82G/n+DPA0v/zma+q3gh2ax2KRNfxwxa7hYBQIhAJnBNmrT\naGfUKLkmSaYgOzQZ0Rv32NWLTo6z4fhcj0Y+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8574", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8574` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAdUdj0MbhnF2Wzz/YjKKCj5DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlYzE2ZTk4LWQzMTktNDEwMi1hYjJkLWFhNzg1OWU3Yjg1ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZmNzk0YTEtZTJh\nZi00N2E3LWEyYzgtZTdhMDEzMDVkNjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoOuFbY/z2j5VCJ26sFrbwgfb/jqzl43lbAW3OsoX6oLmi3XYYJjYQNbLPJ/5\nwaJTa8Fl9i4LNC6a/og4AOCP3KOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcVYzYfPugQkWd7PeftyPrytvjmswHwYDVR0j\nBBgwFoAUhKtKYueZ9AgUsk+q3OSzzDut06owPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCIERSuw52W8+t0Svsvy0JwVW5DsskcL7az+VkarG/mxIrAiBu\n7JH1As45SvFArU2Mz+GOayd5MNgRYlqShcv6q8mK3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASX9BPDi6lNC3uj55eo1SBstMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWMxNmU5OC1kMzE5LTQxMDItYWIyZC1hYTc4NTllN2I4NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQkNzKEjR2GVGlbVKNriFY7Cp8WZzNyZ5pxEvu+igcv7y+E\nV/pOpJdL1moNrrKygYYZ4T2lwQ45fXn4JZqZFNrqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhKtKYueZ9AgUsk+q3OSzzDut\n06owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMoQRjYhDUwg5MG8x3NHO0HK13qtIEqQoevKEub+MjK4CIGe2PZmzkcBG\nF4+cvnmIJju1H8n12gxjp00DXBTPFbxv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAdpQhZiX+AfbhZvWKETrZSPRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZmNzk0YTEtZTJhZi00N2E3LWEyYzgtZTdhMDEzMDVkNjdhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTk4MDQzNmEtYjg0YS00\nMGE5LTg4OTktZTliNzU1MjA3YzU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nIBbFj7/N47j/sckIhVrgKSWYLEpfa7Rvok3HekzKWjF/h8OLq3jgrHy+4C0gHU4Y\ntb8A0hWXSQWH8ePS0f6ha6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcVYzYfPugQkWd7Pe\nftyPrytvjmswGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQC1ByT/oRBcdtkJenWPJ3lZiTMzw0K7jW2PT5taNyOeDAIhANsAimUe\ntQ2TfxmxWxEjidcNFh5kqf/50G9yM9REjtp+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8575", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8575` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAb46raaXrgdcDABsX5sngfNAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxZWQyM2I5LTFlMzItNDZkYi05NDhkLTZiODU5OTRmNDY5ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I2OGVhNTQtMDZj\nMi00YzExLWE2MjctYmYwYTM5OGVjMmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECZbgZMCIcyhRfVo4iF8x5vh3sClzABXGy279tTRj/GFN2NcNjJpfkXs+7IkX\nErXbUwHnk27NwChPjJDLKKtEdKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ebnOueAQN7JGqud1zTabrSOy8EwHwYDVR0j\nBBgwFoAUviPCnYxnp4n34eRMpVdN3ZlWmcYwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD6W6ofyqIL\nVeMSLoOhsIN3u7enbwfmmfoX/Rx6xLzKWgIgSxnFCtMF4UPx0NS3S9ov+eSu6yR0\n4n9+SGJY2rGyhI4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQjJtA/Gsf4VRG5gFlKMpPNAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWVkMjNiOS0xZTMyLTQ2ZGItOTQ4ZC02Yjg1OTk0ZjQ2OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASe6lqbiEypqXZlBaORQBpBOV85pl70Z4CTBXE0qvqccjse\nmy/FCEwvwUZMiBi/l9SmP2fJwCfEH7SfKdJORemOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUviPCnYxnp4n34eRMpVdN3ZlW\nmcYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIgSpOxBLS4YKB6I7YSF9htcbEsrGsEJMFmYu9jM9lfwAiBQ4/UKqknf\n2VZlNZ/V1DxRKabwvujq+7Qp7pcxs2+kIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAQvJnJ/hqDGHDlDs1CmdQnnmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I2OGVhNTQtMDZjMi00YzExLWE2MjctYmYwYTM5OGVjMmIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjdmZDhmNDMtZGNmZS00\nNDgyLTg5NTItNDZiNDAwNTUzMjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfq2ePbPvSs/nhw89crw5REy3/v+cUkhqSpMJGNc3C+XxTrgB24mYNnUF5tZihTdO\nSkJbHM89L//Q5yQ/wwYB+6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9ebnOueAQN7JGqud\n1zTabrSOy8EwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCICaHP50XexruPV9CrICzsnD/9QTOSroR5iwqebSl+V/7AiEAw+nsWQfK\nkqutWuGK5aLM6QEi/JwagReR3sSaki1u6QU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8576", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8576` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAbcsHYFaeGRdN3+V4kCdKKObMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2ZWRlOWIxLTE1NWItNDEwZS1hYjNmLWJjODIzODBlOWU2NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZkMGE0ZTEtOWEy\nZi00NWIyLWJiYzYtNWZjMjU5MjkyNGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3VCKpRycHUSrhN/kX5XetH+E+5N4pyf9g9K4I0Z0lBR/NCrxfWsRtGS35X87\nsFBaSFiJgdWn06ZYcLe/zNKFB6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhp1+J3as7T+U7xWpMEvwpg2xjlswHwYDVR0j\nBBgwFoAU6olbEN8mG59gIlYaEyW+L8hq3McwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgAPSAm+lg64o4oNowuSEQB3H8u4ysZCvQ+s+s/QXLCzoCIQCrWsul+Olk\njSKCArbnqYY49B0mAicb5MYiboMo0t0X2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU/VF6Y9Z6NcH0fNT2FyxAoMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNmVkZTliMS0xNTViLTQxMGUtYWIzZi1iYzgyMzgwZTllNjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxxSwGsmXXtvOBEWlFJCnkMbnK3Sv4rKANbs92PPLsEPYJ\nWOC50Z8KLFPyRWrHkvsIH/xI7q+6y6PJcPn1KOIho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6olbEN8mG59gIlYaEyW+L8hq\n3McwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDRzYOOXhuxXiMp5D8d76J2lfluuHecsrO4wRWBse2EYCIBH5reSFXBnn\niwiQlES2Q5TCEzS9ia23Ddfw7RPnoPNE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAZvIRDIKBaBGO3q8ASVibHxZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZkMGE0ZTEtOWEyZi00NWIyLWJiYzYtNWZjMjU5MjkyNGI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Y4YzMxZGItYTcwZS00\nZDlhLTg3MGUtODU5MzgwYjg2OTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nk+52Zq06fl+xXh4+3myRPOUlht6sixs5opRuuMXGBzoC43XeBWQcdYMlSF8WQyHp\nl7Wj1siKlUhzTQ6t3vsaAqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhp1+J3as7T+U7xWp\nMEvwpg2xjlswGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQDQtDaES/2dhvxByuDGgog8Ea/crGxG7yhZjKLeMIfnUQIhAKV5URMt\npCOXtW1sf3dwVI0NYM/xdt6q4NFR5d5KBlZH\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8577", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8577` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAeT85MuBkSwrShkegILMogbAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkODdiMmI0LTIzOWQtNDJlNS1iZWViLWRjNjQ5NjM1NDhiZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdhOGQ0M2MtYjBi\nMS00YTY0LWFkMjYtZjk1ODJiZDNmMzQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXhAHOTTfN2OtYKBjxEy72Bu+ZRQaIXVeeo0HfnVIzJQmJmvZ7JCOBkvojyQe\nYG0QzYdnutRG0U/dsgaDW9HSF6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfmPH9Kakk54sJbxXZkrIk9OD+2wwHwYDVR0j\nBBgwFoAUSiRXvyAEZZpXmmeu170XyaiG2xwwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhANd5RyGpYnxuKffO+da3pIdl/rTRLjjQxqP0aEG1Zb7dAiAE4VXGALzp\nm0WFppH/5/yppYOw2w4i/4onxFKR7XDxcQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU/jSYlbnRh+BISDbN2DuF0xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDg3YjJiNC0yMzlkLTQyZTUtYmVlYi1kYzY0OTYzNTQ4YmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASuf9bwxj3wh4TsnttlinLy3bg39G82vOBTm9JUktJqo+mw\nYcWU4jyC0YN/Y05G1U3lMZcAkUC2pIyNVCuUeONOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSiRXvyAEZZpXmmeu170XyaiG\n2xwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJVC7zBGiZgXjORF7PjuxPxBuz2icWF6xrt1fStGmUBkAiBKEL3exITQ\nyBwumgcrG9xZi9VATemh82pkWvjn4RQPuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISASHWqRd6shSKOyKRY+yKdG7TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdhOGQ0M2MtYjBiMS00YTY0LWFkMjYtZjk1ODJiZDNmMzQxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzgxYzU5MzUtNDE4Yi00\nMWJjLWE2YzQtYTIzZDU2ZmM4NTMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n60CgxMKaXxiSmGzqPTPRgAURHpya8liEVIfrNib0V58qjqW6tACHb6UrMdoHGgrD\njLNNgR2t1UJZUj3WI5CwL6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfmPH9Kakk54sJbxX\nZkrIk9OD+2wwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCQKZghQdUriRQlY0Iw5JRYvmtH3gzKM12784GIxcmNSgIgWFJ9VMHN\ntVxn2zF4wEP5ANXYQkJE7aVJPkJUSgkMV2E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8578", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8578` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARgSgw8bjrEH/JfNwvYEGrS/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllYzU1ZTlkLWFiZjEtNDQxMC1iNTU5LTQ0OTI3NmFhYWQxYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I5ZjczYmQtNzFi\nZS00YTVlLWFmMzgtNDM4OGZiZWRjMGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDUtEC/liSvBy6YI8WFf2KMzKQiA01r9/MLzjsGzGnls7qpZ1LvY2eD+t115T\n+JFmLGZidI5808NnIKdE2ezXT6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmmd8AovlcgcLbkpO1xOVmPlLRDYwHwYDVR0j\nBBgwFoAUGtDhH/Ggo5KAknfa57zDptb+/nowOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIAd5Wi+9jt4L6okSPfb83E+9fAOrRtxRCRJUSsQeZckDAiEA1qB0jhNt\nV+naqPrCmhB20W3STSm+8JwLkRh65jmxr5Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeXLgedFZnlAkrBkPYZI7yxMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWM1NWU5ZC1hYmYxLTQ0MTAtYjU1OS00NDkyNzZhYWFkMWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARcgwM/1dZ6JOad+2JjsuosocMjNtrT3YLroW154+66qbhZ\noZQZsfBXpSECBfdjwvUpUfmbHRBf8puDm8xsNzy7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGtDhH/Ggo5KAknfa57zDptb+\n/nowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMLbaSBMxQA1RoMAO7yQQlSFy4+Jk8QJ22Jk685md/i+AiEAyPE/uFfT\nNtVeD0Vlq+w9whETEyrXjt0jD1+2QEJkPH0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAflcaucttVcoo9hKhX9a8jQdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I5ZjczYmQtNzFiZS00YTVlLWFmMzgtNDM4OGZiZWRjMGJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDE2NTE4MjMtMjA3NC00\nNWFhLWIzY2MtODhkMjU3YWMxZWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8EkmDz5HC4C4d3MK5bkznGnjbEC6lzrKG1n6enBbcZfCdeuBbA8ZJQx5Mm7sERpm\nU46/SQ/m0aVRLOLfnfVGo6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmmd8AovlcgcLbkpO\n1xOVmPlLRDYwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCVZhWmXfl1w7tuQpcSamB3xyRycMTR0ppZpS9l9WP7fwIgPzpFdwnM\ne3HQ+eacEkzKxUcaApLomQSZfy0FcQZp9bo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8579", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8579` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISATc5ZTyabiEgo3etJZbg3FZpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0MmViMDJhLTIwZTgtNDdjMC1hNTZjLTkyNWFlMTgwMDdjYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjU1NzUyZTMtMjA4\nMi00OTVmLWIyN2QtMTg3YTFlYTNkMTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpzXOLbCwlUgjDbUyE+0aHwX21go5qHygzjFPtXhae0QNQiEqzGH/HpGWA/NW\nQ8jp7nQVB4+sQl10/EChe5e0Z6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw4lbyoucaTJf43nwnsy75Cc0u9QwHwYDVR0j\nBBgwFoAUXAYi/Fus9DXUXQnu1BdnQNcqcnwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIAIYI82Q7YL8FS4oIL5GTuF6kt2xccMiDMC7v/aa\niiPqAiEAi4kUFDkkbsAlt9W9t4aB+14oj1qyyKn0nhUlMUWxBQM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcBmPEHoykthHO1lGFLseAH/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDJlYjAyYS0yMGU4LTQ3YzAtYTU2Yy05MjVhZTE4MDA3Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPlQT2myOoCjP23cWG7KuYA6xnMcrLO7SHG/3H+iWM5iTv\nmB5i+toyVnTjvOM5QL3aps5LRu3TUHd8RCoRxFslo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXAYi/Fus9DXUXQnu1BdnQNcq\ncnwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL/sQuE3fu6rPyUPXXepRXOc4zenzClZsUiTgy0HtWjIAiAu9yvCk3HV\nzRbaONRLkZ41XoA+5Dal8hkVVAkHbiGGUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAcvfGt/+rziyNfZpF3sol04yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjU1NzUyZTMtMjA4Mi00OTVmLWIyN2QtMTg3YTFlYTNkMTJlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDZlMTgyYWEtN2I4YS00\nOWJlLTk3YmQtZjI1OWM0YWNkMTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTbjx0CQMRVncc+NlipDjJPjY5uvju9nF1hyapAQ3GV2Qh8opfZ9Qn0DL1wj6xrJA\nGdsCSV3Zsuzw604TJ2o3cqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUw4lbyoucaTJf43nw\nnsy75Cc0u9QwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIFp05y30JQZCr/6gnDPGsEOJW9sPg+MyMwZSExdq8iEyAiEAlUfOtGaX\nARmAHQZFwWHDuC8KVTvLw3pPQueM1SLQzEw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8580", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8580` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAXrsK96/i+Yn1s0qNW2c1ZGIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwMDkzYTY1LTRkODktNDAxYi05OWY4LWI1YjI5ZjYzZmRkYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg1N2EzMWUtYzU3\nNS00YTc5LTk2ZGEtMmU1Mzg5OTZkMjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQAmLYGAo3IkSZmrZm/oMdALhinyCmQO1v4DGM2fgQMM4k7x1JDdmHvMZk2vd\nkevuxi7wjWXm6EemWzsKfLHZZ6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCC7O7DtMIDLp6L1D+76HlXfOLl4wHwYDVR0j\nBBgwFoAUSBh6PuYz9PPzRyavKgM7x+0Bs5kwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICOdgIyqH2uS0lIFgAg5dnJ6ZecWFgGRfMVKNDRv\nA+jCAiBFBzw3RYayhBNxjqoMsLobU2WHDzLpL3eym6RWB1R7eA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVFM3Y7VRmhB6Kz48xTQZH6tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDA5M2E2NS00ZDg5LTQwMWItOTlmOC1iNWIyOWY2M2ZkZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXZIUmHgceQ4GjBj2FUl5FvQpCcfn3eQF9h8qYXtGWCm46\nhmfgwDryfHg23ntnp2rgWyCkmIwBGcHL80xX1Euyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSBh6PuYz9PPzRyavKgM7x+0B\ns5kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM602r7ARzzh+e8yfWrP8wFK/iwQ9xdwjG6nqmiIq455AiA9XQc8GB3J\nLUCdhN8W3LfFihMhjaafY3I+adEMvqCcPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAQIKn7Enansr4ddjAULSLA5rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg1N2EzMWUtYzU3NS00YTc5LTk2ZGEtMmU1Mzg5OTZkMjNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjRmYzRhZGItZmFjMS00\nMzM5LTgwOWQtNzM2NWE4OWRmYjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6th0NQ5LhINtT5STtO77xTj1OsI7LBdPrSB5HpW/mm1iA5Er8h4MCD9dk/RvGbTv\nwYXS3gYCtEjul4yXuyfxIqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCC7O7DtMIDLp6L1D\n+76HlXfOLl4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIARpfLFwPEePW7YWaVNCWrk+tCUPijR+xie5V2Ns5EwPAiA0tBVKuhBR\nr3JRez1bAT6IYtRspYxSQHYIJ2LqTwMxvg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8581", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8581` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAU8wxFI/o1wf5hE9SS0GGmwkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkOGE2OTg2LTk4MjktNGZmOC05MzY4LTY1ZDQ4ZTQyOTNhNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU0ZjdhZjgtMjg5\nNi00YjUzLTlhM2EtNDE4MzE5N2ViZmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg8Bu0CBfQcARMOCHG6et6Ti5qhI/rn9vkod3ZjN8LyA+uBVxLrqmFBYzCr24\nGQihAZyvMBE9GZ2rljRW2k0RR6OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnNYQVnIs/AC6KbbxWWT4M0p4jdAwHwYDVR0j\nBBgwFoAUzChBJpcdku/bKAVqu4e9nd74E5QwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCsAtkxDQ72mXNNkTje4J0BB4cD/NYJyg0EDOu3/p731QIh\nAOASV/bDnlmWK1G/6AAyI9UPlxwuDMcFLE0QpyDyqwpw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAakx04gamnTgm9kIh39EsrLlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDhhNjk4Ni05ODI5LTRmZjgtOTM2OC02NWQ0OGU0MjkzYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQC+9be8T1eXc1Dt8bRuFszFKOxuFkE+OymZ8NMhAX2Wll+\nDOp0wmx/tygubyeWTBEfInaicYq3eHYkVFbF3RVCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzChBJpcdku/bKAVqu4e9nd74\nE5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfeiiK6dX+cwmBUVkVPBeuPws7X6CV+dHt0m+01IcBj4CIAv9xVtsE/dC\nb1UuBRdG7P1b7WAxCKbq0TlxuacJkNUc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAeHVEDhEb3T2L59wRgRXp7JWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU0ZjdhZjgtMjg5Ni00YjUzLTlhM2EtNDE4MzE5N2ViZmZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjNlMDQxMzEtM2JiOS00\nNTFiLWFlMmYtYWZjZjI3Y2QwNjUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyXXwsjV6rw+OxnQQONhbjwthY/rptwuM0rw49OlMH2iOiNOzMy8+1B1W8F++ohlO\nTS7IsCAsOdrBgzBvV+FKoKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnNYQVnIs/AC6Kbbx\nWWT4M0p4jdAwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDzeVwO4o064RyZegRVl38ouCLZMtJb5/YW1y+3IZ+onAIgSvIBY6zN\nAm9dl9E8Vzwk1AyH6DvlqAnNskzIqeMQwzo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8582", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8582` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISASmx1UyT5UKTfnzU44hQFyKmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyODZkYWRmLTU3M2ItNGU5NC1iOGE1LTYyYzdjY2Q5ZGE5ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTA5MDMzNTAtOWQ5\nOS00NDE4LWFjMzctNjhlOGFiNDFjYTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDLtQYs/R8FbSUGznVAN9OuR3Z9Q1iCJinX+0PBd5vjjdrhGgCEpInPkxPfGq\n44yo2efusHim7GmAFaCxETximKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAmmL8/vB88+cpwxBpq992Yr50P4wHwYDVR0j\nBBgwFoAUWK3cnzXYuxGz5o7NjxK+0Y2ZtpEwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCFEO593xE8bZEk6WfZAdJgXEq44/14\nJMk216a474qjXQIhAM6nATNKUVOmyznqFTnUMixfLjrc5fFf+Y6fCPUquDWD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUeXlrDZsD1200Ly34+nf48sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMjg2ZGFkZi01NzNiLTRlOTQtYjhhNS02MmM3Y2NkOWRhOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZ5vN/aj0L+BuGEzFky2HgWwS1dQuF7Bj5LOx5yln1ghKP\nMQMMg/nNjNYBSDKUTIZilrXOqZbGzXl8dWCu3l/8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWK3cnzXYuxGz5o7NjxK+0Y2Z\ntpEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN5Oi8aeRY/iu4ALqwhIS234mCpXProfI3dqNNMjGRqfAiEA2xJrk9ZQ\nYs7cgVk1khTj2bbes9evVX5kwADzD+HGx5U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAdKpTyxEB489Zx3JKwh3nQgBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTA5MDMzNTAtOWQ5OS00NDE4LWFjMzctNjhlOGFiNDFjYTQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTMxMjIwNzUtYzFlYi00\nZmZiLWIxOTktOWFmZmU0MTBjMzA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4wXkAHP0wmbovENlGyQxq9+daQFt/sjLoG0iMssEeNtCFZF2yTD1naKc6jSOZYr2\nxJAu+EU0P7DuAqzbgblFUKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAmmL8/vB88+cpwxB\npq992Yr50P4wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQDgQXmzuBWTTqDpYCY/PL3QWX3MKKMHeB7LtjKMwDAqZwIgaPVyCRvR\nwBAyeAjSLFDo52ZQj2g9MzpyTLpAgdYDtrE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8583", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8583` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAUdDz8c+pQAqXeUkWJpHZzRnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5Y2VmMzU3LWY5MWQtNGNjOC1hMWM1LWQzYWJhNDA3NGQxNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGU0MzdkYWItZjY2\nNS00Y2JlLWEwZjAtZjNiZGM4MzkwY2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa4cuqN59w5JHhvyrRvU72Ah2i/dfJClwvSwAcetiW3p5MFel/8DL3wWZmAYb\n4u7l7b62a5emmYCFeCJvVxpp1qOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyZ0mKHz2rpgHiQBRnfx2zyKvPoMwHwYDVR0j\nBBgwFoAUuxmAv7A/RwwdNrJhowfNLSWKm8QwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDM+Jhrez68nijnT/kJMeEfKeo9kxho\nKcXpkULnJQyJwwIgJNVXTLJOBdwqMrNqquCc1nqsdIMZfJPQN/uLfjU1mFg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARuxfSjcamcT9/jk/wBbtrSfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWNlZjM1Ny1mOTFkLTRjYzgtYTFjNS1kM2FiYTQwNzRkMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASETCzHIvrLuDGwrxWai5DLYInG/B1KMf+FHEXwPEY/6Y4H\nP3IDGX/GfsQw8xaCWjlD5zslsb82vJlvkkXqdTbqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuxmAv7A/RwwdNrJhowfNLSWK\nm8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKMg6IlILI4GIqGjwX2gsIbobGM60uyoF6HKqmRe+Ua3AiEA1dmkUFE5\nUY1pJYidI8RE80O1V15AQg/D2/pN/2nNGzc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAXGCKJRNqlInHQmuDWzPfIPCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGU0MzdkYWItZjY2NS00Y2JlLWEwZjAtZjNiZGM4MzkwY2EyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTMwZjEzNDEtODQxZS00\nMGU1LTg2MjUtNjZmZDM4MDExOGQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPYr9+E+ieNVVhG7x3+XSHvIdURlu5MgWGVuNejv8maJ5vfy0F6AEPLWhjN6ctYYb\nygow+/CjcPUYA1uYEahxYaNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyZ0mKHz2rpgHiQBR\nnfx2zyKvPoMwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIFFkqu3FS0NJ+10A10lA88GG9O1RwlRlFBMrJY3h8qUvAiEAqAYtxcY1\nn33gPOlS04OHY1WFdxnRp0G/kwkcTc0EPxc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8584", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8584` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAaedTR1uTimUYbXIS0M3ze+kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjY2VjN2RhLWI3ZWYtNGYxMS04OTg0LWFlMjEyYTcyYzg3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODViZWE0NTktYzIx\nYi00YjhiLWI1ZGEtMDM3YzFhMGRmNjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuoZ/f20R6Lcc9H5UN8s9kWWbieeqTYg624UCRkSb/boBGmbY3gU3jtC9EGM6\nigOqJmS21KHndcKUdw5G1JI7xKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD1KfHrtEOn/b/qNKL1rfs2o1O+kwHwYDVR0j\nBBgwFoAU9mTpz2jFGrn84glM2pnObPfzsGkwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cAMEQCIAW+nza0EBT6\nVb5WewJmLSjfLKGrPCIp8EqcSQSy69MUAiBf3DU20p3S+YpefdyR2MjkXXckTHYe\nN9HrcYjgNTYzGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQSbZJXmCFaXysqcP4EG/a/RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nY2NlYzdkYS1iN2VmLTRmMTEtODk4NC1hZTIxMmE3MmM4NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvQ86ZVDjC73kENVaEq+czg/Y5hyjWee1a+wxPcEs+o5qv\nOeDzTY2mO4HO/whrkaC2fzCi0mztdooINjJPqLTmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9mTpz2jFGrn84glM2pnObPfz\nsGkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIOi4vLBj/zeM78QkHQE4EzW9BKUpEJFLxkv99Wc9s2oCIQCKrs2lhqPC\nACZRyP0tqDI5VgrA+ZzrLq5CYfbmHkQyIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAQ0sIeikYsQFuAMVhyn06NmsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODViZWE0NTktYzIxYi00YjhiLWI1ZGEtMDM3YzFhMGRmNjI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjMyYjBkMDUtN2Q1My00\nZWZhLTk5YjQtOWQ5NDRjZmJmNDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKUebBG2T5S4nPTE5U9K2iXLdJctjpBtaCO2TffbZmWO5e56OFJEUB/mIVr3dHgrV\nEoq3VNWRxlocURtN6n6EgKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUD1KfHrtEOn/b/qNK\nL1rfs2o1O+kwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIB+5EmA7sET7z9kIkebhvB024alf13EdPn/Q2CjCF+uWAiA2vJnXK0N5\nJ2iq9Ss1uo+MenL4uvmFHYLBp6v/bfY5hA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8585", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8585` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAdhTuHU5txfpxOI+guWAnuq+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0MDk1NDI4LTYwNmMtNDA1MS1hYmEzLTUwMzQ1OWEzYjQ4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE0ZDMyMzctMzMx\nYi00Y2IzLWIyY2MtZWJjMGRjZjVlMDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKsVBi6wydl0xsPVdzWHCuimPiXyD6Sv1u+TmV70kriFl64L0/k9p1yD2lgc4\nwOvewUlyzPe2pDRNdg1dqclHbKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3rP4PVauGJliGzz+fDBlRY5FtmkwHwYDVR0j\nBBgwFoAUicxmm4qmTW5V5jWKzDGQHHUY9lEwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgBJvOn0NyVSHtAUdIOiR5uLeODjAnA0aQCyCqCsLSPIICIQCZ5dj5dHZr\nHz9s3mfCa1dkrbujR1DgyWaADkhM6PnBzw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbwJqZAV7wg0GGeNgAPM8EobMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDA5NTQyOC02MDZjLTQwNTEtYWJhMy01MDM0NTlhM2I0ODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASW69HDMkAk/Cuvx4pCGgzgYV5uf7C7jdl1rOqOsWtFH6pW\nvKUbmHno20jbF70RCEgYJN4D5GUWRK6C5z0vkFVEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUicxmm4qmTW5V5jWKzDGQHHUY\n9lEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOnJJqr7Ss4TmPjYoKAeFagrPwJoh4WxZm4jQMOILKpnAiActdnzM1pZ\ntA7++o+C1/XtdHd7CL1AxSWQpMfGSZy6eQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAe1OSkx+tqTMuo0xhsTxvOi3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE0ZDMyMzctMzMxYi00Y2IzLWIyY2MtZWJjMGRjZjVlMDA1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDFlNjMyM2QtYzc2Ny00\nYTQ4LThiYTAtMWQ0YzkxZTMwZWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2CFfr9nJHycW8zxHvU/6d4z1uAAL0LchF3WxYTKjrUgui7hcApkXv1vxjMLWRQ+A\n9aLypqKjDghHn+6xljXO6qNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3rP4PVauGJliGzz+\nfDBlRY5FtmkwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQCmqiPoaid1qN9R4onoOCK68JyYwDQkXHoGo4ReCbilygIhAMgeZd77\n7mz5vo1KXpRKPXlsUR0Vkz0kOC5lR0iDC0xf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8586", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8586` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAWOFW3/jhZkzpFSLNivNXu46MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4MzU1ODA5LWVjMWEtNDEyNy1hOTUyLTk2ZmI0NmIxZWJjNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDkyMDkwOTYtZjJl\nYy00MmRjLWI3NmMtYjBjYmQwZDc2YTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbnMXExDtDtCg9JOe+cjYEW49P1tTkpRH99xr8H0rldVibewkVgqELy0bijWv\nOhN0XPI++OBMm/ksl5a68q4kpaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8T5ag065QG3oe1obtb6aunSIC64wHwYDVR0j\nBBgwFoAUx9i69l3JAFTWj6j9QxXf32O2Pn4wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIgV4JXj4PEqWvq//9sdPqFFoydMhkez3JhPEsYhBd9GTsCIQDgoJSzOMJ1\npdnJuOqHp43+XOPNlrfWQH5KpH1YAjI7rQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASGW3SZiLhRgevA2vM3ksEjBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODM1NTgwOS1lYzFhLTQxMjctYTk1Mi05NmZiNDZiMWViYzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJM9wvFzVmd6kWmDfE/C1qw0Vn8alnYaH6BrE4gPfad+kc\nEk2sCSUEEqYvPIc+4NVYFn88Su7dhOrrGMC14uIho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx9i69l3JAFTWj6j9QxXf32O2\nPn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHlOGVN6bvQWYWVYqr7BBP1GJyleaDuuot8lAvacuAVsCIQDi2wBndyni\n+7isdIuQ1yg9nTLcsbFrGfFB0A+tZVgMDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAb+XZTCb0K2fOgEpwcUIvKL3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDkyMDkwOTYtZjJlYy00MmRjLWI3NmMtYjBjYmQwZDc2YTE2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmViZTFkYjgtYzY1Zi00\nMzc1LThhNTYtZjk5YTZkZjMwOGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOBXyfps0RBUn7zFfuekQBpU0axcR5Hdahu8UKN/U3M31D6Ycuo69iBUcHbMotv3o\n0SoQqQ89M4t22HOBcQ0nfqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8T5ag065QG3oe1ob\ntb6aunSIC64wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIALmjCU2Um8G0IQF4T0dFw8fsxzytRHwZjenlMcJ6bU2AiEA2nrJwalo\nhOcvVuCxXwApNrwnwrGPwuRapKNshtx5HRg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8587", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8587` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISATLX33e6bE/SEGsw5vksj/utMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjNzc0MWJjLWJhODItNGMzMi1hZTVkLWEyZTk4NmQ5ZmU4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY4MmQ3OGQtMWU5\nNC00NTdmLThjZTEtOWY5MjI2MWEyNDM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/V5lsExnBu/Ufb/tGels6n9fp5Sis2N1udH1VmVVCNxDrPTZuOiS27WG3rel\nwFWjezfuBvKw/ApxtXu8WmF5KKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUrSUEfVvpIw7UCktUrvzC9uuubswHwYDVR0j\nBBgwFoAUZrebqlI2Lx6xgn3Fk9LJdhFYesMwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICZojHJ+etL5nsFgjK8qFBDXiy6lvMsxjTnYZ85lFc+FAiEA613+ssGC\ndL/UYnmxP07NvR0RU8su/zQpjCYzXzgB4AQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXCTaK5cw6de+b3OUX7lrbHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzc3NDFiYy1iYTgyLTRjMzItYWU1ZC1hMmU5ODZkOWZlODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQi4v53RmraQ2qmDx4yDmMKvgt9FvOeScnXZNLx23CZlcnn\nUokOMV/iWXkHbidmVQDh5KQDDtCkPOyWZISaXM8to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZrebqlI2Lx6xgn3Fk9LJdhFY\nesMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANOpClBuJ5yIVBPsl62cKvFSbOBtDX8ur9yhelSqbDOVAiAu5cFuuXVi\nihu5RACBn6Rtu0L3z9ie4+gijX7bQFHykA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAZgDyZL1oYoXiNsGyQ05WGw0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY4MmQ3OGQtMWU5NC00NTdmLThjZTEtOWY5MjI2MWEyNDM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGY2NmUxNDAtNmQ3MS00\nOGZkLWJhMzYtNzE5ZTFkNmNhNjlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlTR/NFWkYnn+ocRQAZhKBs9sp1SgKXPN3xVEFOSmOhJOmZw6MoeCfCl6EOdRuyzH\nR9oqG1zd0TymQQC4FlbqZqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUrSUEfVvpIw7UCkt\nUrvzC9uuubswGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIQCiCxm3An24UGFHIf9xknpdhQ+sbAQiXpxUtA7KA72s3gIgRGD/nkMg\nCxsftoVLF5DsFKOOdKS4k/OD0lN2VvFnjVo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8588", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8588` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAXCdC4+HDXhZQTafDtrJ09fiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNDFhNDgxLTgyMjMtNGM5NS05NWE0LTcwYTc0ZjgzYWYxNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRiZmIxYTMtNmE5\nYi00Zjc4LWE2YjItYjkzYmExZWZmODkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBjWPVdqd1XUkRvSJxlVqsHb+xroi1Jb63amCtRWaTDjRtog08MKwISUz1Pk4\nsdxK5GIqOMcQEqNGqSCPkC0sr6OBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUttGsMaqKlXBnXRdhxT8CeMcS2cwwHwYDVR0j\nBBgwFoAUlkdzgdC1fp+NKZXhwgtrrKRzMrcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQCvJGeoVrALybscfHmtmsyfQ4ySR/QC7hVBx6xb\nPEn0ygIgXA5PPWk+R2bKrlV7ZaAyQL3s5qQef9BM3my4O8uFWPk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAafKahNxJ+HH2NY9Ty8U3+FbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDQxYTQ4MS04MjIzLTRjOTUtOTVhNC03MGE3NGY4M2FmMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS48weq0NZX3rXcl/TVqfEAt5HxV//IMP+V/B6452RsQ2CJ\nS2uprXuooI9EYbHpdBcbYP8KJtArPBgct27RbNUKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlkdzgdC1fp+NKZXhwgtrrKRz\nMrcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDX2ljycRBj9Tfr8UuFmo/zfWr1vsCKWhkC/iNafGkEQCIQCfKf7OKlu5\nIoZj6JfHCTsGTOQlfsEFDlDn/V9Etpf24g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAckoyGKw0bceR62qYSaIj4B9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRiZmIxYTMtNmE5Yi00Zjc4LWE2YjItYjkzYmExZWZmODkzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjdlZjE3MTMtYzRjZC00\nZjlmLWIyMzctNTIxYzk1ZmQyZjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDZtURE+r04Ra3GnzzkUXJkyZ9Kw0MthR/33SRYuIw2JSrGzf91+ZReM91Zw9OZn/\nKTEiOFqzb76ruic/fcg8bqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUttGsMaqKlXBnXRdh\nxT8CeMcS2cwwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0kAMEYCIQC6x9QaXn1Kr/aZhxYPQMPmK7ir0gcGURJfg/vGuYkvngIhAP/7qT9j\n/Mc6X9Oi4wb6BeuBNxZzr3i8YCo8qkYEH2Z/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8589", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8589` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAWPUYnad9UwIVwyF7zDLIzfxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmOGZjMjAyLWVhMDktNGFlOC05MDAxLTBiMDhjZGI0YzY2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGVhMDIzNTItNThh\nYy00NDJlLWFkZjEtYTEyMjc1NDcxMmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF+lx2bNmHipFst/JuE9K19f/ne6VS1jmZcGJu83dRbVFf6Atp7GKf2q2QRxI\nbELdJ4NAnGPOyfJJi39Ox9tsNqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmfLxqGr5kHAjqD9XgWntFQLq/s8wHwYDVR0j\nBBgwFoAUfK2yRDoNSAsetgrUDtEAW5IXLaowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIFb+o9cuMBMD8eOkM+CsXVbwDZnBy4TjupdWc99w\nkAIVAiEAiopLw88DRw32+vd/fnFeKrQmQxZz8Qhj2lABOZyXhi8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR5EhIMrR/IsxANBgxbXJ0JDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjhmYzIwMi1lYTA5LTRhZTgtOTAwMS0wYjA4Y2RiNGM2NmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBOnNfYyscigQFi0INWT4YEsmawh0TRpoaGnFtEcEVIPAg\nmyIfpLYNEefh+fA8RNDMAshxqlU1+PpVCQ4YGJveo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfK2yRDoNSAsetgrUDtEAW5IX\nLaowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALbw2FgyUSfJt2pLcA7KN8kyJUftM+sC1hqaGgA7jCAcAiAhmT/8kmls\nJEpq77QO3vSIFzTMKIGNHr6iUny961NSeg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAU8oZS844JnibH59zkafWdXKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGVhMDIzNTItNThhYy00NDJlLWFkZjEtYTEyMjc1NDcxMmRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjgyNjJjMTEtODY3ZC00\nODVjLThjMjUtZjZhNDc3MDA0MWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncepaC1bmK2Tdt9oj6xqIJrf7KoSquMQdKtxd7I4VoifN4X6GXN/5Q+F2rn4grwz0\nXzi4P5FKEBzNVWq8XB/4sqNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmfLxqGr5kHAjqD9X\ngWntFQLq/s8wGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIDdj6u0Si9Btk6x+n2AyKj2lKlUctXrTITBwmE2U+P27AiEAoBTdTld/\nhmMjcS+anKNz4KTldM/R+tqCbWiLcTzvYZQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8590", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8590` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAa7bKOAjjhhkmsrO9gJSZFmUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5NTA2ZDIxLTg4MDctNDE3Zi04NDgwLTk0NTVlZjQ2NDQyMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjUyOTgwZDMtMGNh\nNC00YjM4LWFkOGYtNjE0OWNkNTcwMmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqOrgmNr7dOe0RgEqmOanXUfjXJ802hcpA7STTnh6Byt/mJUkMoiAU8zidItZ\na7YambfLZfOGymD+tzDT/5FGhKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdYkhMLIaHAd9lzK00xgibIEgd/EwHwYDVR0j\nBBgwFoAUTZOEfJcCxPEVGpue4PiFvQc23aAwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCIDrtgxlQIlQVVooExNBqlard1CL+XclCBC8jHpo2OoPSAiAa\ntxb0Ny7c2I6lvg9RnG2/d6azT+5wcDUFSvqA69e/5A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATf8QOP7SHtmAoOUrHCqCRlyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTUwNmQyMS04ODA3LTQxN2YtODQ4MC05NDU1ZWY0NjQ0MjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4RlpKYDYpFoTkN50ICZOvSlMfMtUx6Yf4+w29S6h9KIse\nT2JZNdD3z0BVJGbsOyO3+N5yxCmBuabxfQGBH17oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTZOEfJcCxPEVGpue4PiFvQc2\n3aAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO/qpa5Cu7spizyZYmph9dXBT2G40avsxC3Uq15raKIaAiEA/my5weWG\nisfbDA+TJm/GVxNUQkA7B9mmpsG1vSIhqek=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAfSnCzKPulLl+wAEb4D1yfawMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjUyOTgwZDMtMGNhNC00YjM4LWFkOGYtNjE0OWNkNTcwMmE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGFlM2Q5ZTUtYzkxMC00\nMmNjLTk1YTktOTM5MmFhZTg1NGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1srgSh/F/XDmwgzYYhR3V2H3f57xNrjlP/2vYgXEnVkBjchIVGjizTT2LYEGfvMP\n1cgXWcS/iaRtCK0wyVzRQKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUdYkhMLIaHAd9lzK0\n0xgibIEgd/EwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0gAMEUCIG+KNCx+65uSJtLKDR1l4j3gj+iqu7HhNBiNYS3EBrp4AiEAuxFtvnQZ\nzjl4i9fpZwqD8Vv5rF19kwnrVm6X2iAa3Zk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8591", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8591` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAXkrERPDKZ9uPM3OmOWza4vrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3MTdmN2M1LWQxY2MtNGVjMy1iZGZlLTMyZjc5MTRhOWE0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk2NjU2YTktZTIy\nOS00MmYwLWIzNjktMGQxNTA5NWJkYzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELlBf4ejyGgJ3dgrvmMcwtWt3TLQqoXJoMS/ww20qFnL/Q4rD26XQyd1fDnTk\nSRIVIvdK/7t3UjGjE1Jj4KY4taOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOkvHFKS3SlMfrisefD8SP7lpqIkwHwYDVR0j\nBBgwFoAU7oLIV0wsPUV3hfMVU/FUNzPbCj8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCgn4YjQhpUajMjROFEG5douApeBYpg\njZgxV/wiR+5y+wIga6BJiDoSQoOYy14wbyvpY27jgmxW/8QCspUGkB9uq0I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfgjLpsHXJD67IntjucShlUKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNzE3ZjdjNS1kMWNjLTRlYzMtYmRmZS0zMmY3OTE0YTlhNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCARSx+ixStxt/GQshjZurNTeCYXaK4HJ8HVfiZ/O9Vhqf\ndHjFOccZ0+8TPtelaR6rJMWHsx7jff9KPLn1fepao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7oLIV0wsPUV3hfMVU/FUNzPb\nCj8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKvVGiG8VtkjTgX8jPceld23Vt1+MmKMteECFuP0TM4kAiEA0Zb02uJ3\nZq29dtEfcYYKwRnH8iq4BZHKnTtY3mziyu4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAYRrCRGbiMHD2Gm9DSgQrOHpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk2NjU2YTktZTIyOS00MmYwLWIzNjktMGQxNTA5NWJkYzNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjdiNDBmYzAtNzNiYS00\nZTYzLWFkNTItZDc4ODUzMDM1MjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWcpQ5tfKoErrTMBEdlKcx7YDOVTtYntfrfHFlyaD2eEtKddB3r5psgFNzW979c9T\ngyNuiSZweD6mtPsvnfwKa6NyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOkvHFKS3SlMfrise\nfD8SP7lpqIkwGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIDbGJ/1n6wsTA8s44X/4lFdNbO3LCQzp/x0H3QKlfDUYAiAaO73ybHLU\nNi6fHSzoIPpk6bD97eplz8BJbYLVeF6RoA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8592", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8592` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAamWl4VlYoKU3PmPQevWXHQ/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2MDJlYzY5LTU0NWYtNGY1Ni1hOTQ4LTk5MzI3NWI3MjI5ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE2OTYyZjQtZDk3\nYi00MTFiLTlmYjgtZDIwNmZmYTExMzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVsl1W+cleQpLa/Wxb45VL8wNseZ/D17MY/XH/YrJbmyvm3SCaT1gHM3Z5cmr\nwbBzU1v5cxyGT7H4cnPGaKaRTKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkr9pzhR5oXnYqTEzw9KxGO7cHUswHwYDVR0j\nBBgwFoAUZoQYcM8gv8IReNlyFb6RWOeqvtcwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBzDO2fSldXjKpqEwflqA+bWqnXXPlrq\nXMNejPFkYInvAiEA+TjTCzZJB3P+7wmnNSYty9YZRzJ/Bp+SYQZIh6Za8gk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASoeuYOb+sIbPgeJTWILA3s7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjAyZWM2OS01NDVmLTRmNTYtYTk0OC05OTMyNzViNzIyOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbLJxThloSyitdxyV1cMhW9KpNMlEC3a8aCs5WnTxqp8gm\nz8w3XAFLn3FhI/BCRqAgCIET6NhWUR3c7Rb8XgXAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZoQYcM8gv8IReNlyFb6RWOeq\nvtcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKz1wuvJ1rMN1nc8+nXklAOGTYYQyqXZp+U/qvg+HcgwAiAd4Ow0nbSd\nT/TQKxPLhUrKnvxZSWalqpKeFUdpWfy5YA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAc4O16cXe8HZbSI8d0U7ZFQWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE2OTYyZjQtZDk3Yi00MTFiLTlmYjgtZDIwNmZmYTExMzFjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGM0ZGEwYjYtODI0Ny00\nZjZlLTk2OWQtNTRkNGY1YjIwNDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njqUpCdNOIP05JfeBpnW1Pq32Kvghxa85mKSzc0ohXtCivPCwVrr14R3ziUycFwJg\ntQNKYw/S9kfr43WoJjPByKNyMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkr9pzhR5oXnYqTEz\nw9KxGO7cHUswGgYDVR0RBBMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMC\nA0cAMEQCIAbWmekbxjY0lspRwNBOgVTiY5hM3PD2xffxiWaqAUBgAiAaK13ZfgAF\noRbgllxGjyzZ+jU0QiBGxUBgDoTTycA4sw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8593", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8593` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGTCCAcCgAwIBAgISAVCuhRumgkWcskXEATrHyFjIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5ZDJlMWFkLTk2OTYtNDVkNy1iODhlLWU2OWEyNDIyMjFhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ4OWMyNmUtNmFm\nNy00OTE3LWE3YjUtMGQwZGI5ZmQ2NjMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgNU5J9qxP0U0SwPsCPcI0AIGxMXVG+djiBhrESocl0ZxvIagHs67gZrkQ6MC\nJP4BztqwM/UTQIn0BjSyuyEqTKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFExoDJTO8EFjs95U89MziuogdviMMB8GA1UdIwQY\nMBaAFDVMXSbL4kSNxXPuArdYYsykBwX/MAoGCCqGSM49BAMCA0cAMEQCIHXTBtII\nPfpWSt7Vs4bFrMJGiCL5zdJwZYLASk2eBCGPAiAp5o57Lor10FgMtoVokZtAc6Ta\ndkVkqCkmOrlIMTCCqA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZGd4is080NKGRsGlXjQxXjbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWQyZTFhZC05Njk2LTQ1ZDctYjg4ZS1lNjlhMjQyMjIxYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCDbkZAogHxLxZ2d37ct3/6QZvyrrba4rDTwdB0H+3MoLA\nF5ZE3Y09qqSLEhOjztFRpEVp4fNFgOxxBBhAEgefo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNUxdJsviRI3Fc+4Ct1hizKQH\nBf8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALfvV6CWOcRr/sYLuKDf29ow4ZZWxyAvIvtbB7w6vzA4AiEA1r5OzRfX\nmb66GUd9IKDNoX14XAiq3vnNP04cmvCUDTU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAWDN3bXCX3ZX73OXXsXU0CaBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ4OWMyNmUtNmFmNy00OTE3LWE3YjUtMGQwZGI5ZmQ2NjMzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjljYjgzMmYtODg4ZC00\nZTQ5LWFkMzktNTllNzVjNzA1OWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJcf5Hi4l5sFkqSBO0nkBRCVc301krQ7xMCEQoJ3TwADxoBevVxu9AcRRwaAWJvZJ\nER5mIkfc9y3QXFcGWw4G4aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTGgMlM7wQWOz3lTz\n0zOK6iB2+IwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCozNpdqKfD7Y9Ei8YyJWCKPrNbt54adDmV/LHrwJksfQIh\nAJwFDtEbtboR1+1KAyh2sEWAlhMRF4cAPos4/GuVmY9z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8594", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8594` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAQ1FVwzjXMUnSgGGZFEvZZ4YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3YTBkOGUxLTI5OWMtNDI5OS04NzQxLTRmZmExMDAwMTEwMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQ3MjcxOTgtMWIw\nMC00YTQ1LTliNjctYmMxZWY5N2MxMGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB2/g4+a1fNZCKdXUqVCj69w8hBREuj5ooz/tVFMafkbjl/UhJSH+njvbFNEW\nKqGubMEsmKS2fMpC1pd8kKR/lKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFArRBHjslf1bvT1kgU/Indx96o6eMB8GA1UdIwQY\nMBaAFJCemhrw2dgtEjZ3ugOYXK15SgdXMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAjN7u2VCXyV2l1g2OpW0ZU3jq2mdhh0lf\nd4On3NPvMU4CIQCTyWiER61hs6ea6QRvL7hHlzBT/0QIJx9p4HeeWtsYsQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdczrhJYIrDJ4XgJW+coX8C+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2EwZDhlMS0yOTljLTQyOTktODc0MS00ZmZhMTAwMDExMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmV4c8h5kedoE6KBE64+HnUnHkBuq6CDVZVkvwDWw74hbU\ncHQyotwl5c4HG/Q5nmhfqYZvcDBPMoUkb6wQl8j8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkJ6aGvDZ2C0SNne6A5hcrXlK\nB1cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAnbUXUn+Q7mpzRvrR1hgiYKhNE12mzp6n6ee+QYTZq8CIQCIB3cza8r+\n42OCKtEE0isvPITOf3QbX0Q48igfoFoCVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAeMGkLAOsARm/3IrmNQpMGEEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQ3MjcxOTgtMWIwMC00YTQ1LTliNjctYmMxZWY5N2MxMGVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTc5MTAwOTItZGM4Yy00\nM2Q3LWE5YWMtNWQ0NzQ1MjhjZjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nEf4t8/xLxvGgkIUpqYAsdm8PlMxpV3UgRTK/PtjR1aNp8tJ1Mu1dctdBzOmd5hOj\nNsCKDzHQJj01xBJ28x8qZaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUCtEEeOyV/Vu9PWSB\nT8id3H3qjp4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQC1m0T+7Ep2GhaSytKqH1lksMR+tqsRmkOe8bBdKrqWpwIh\nAOOrCb5FB5EycO2cIYaTtnWqw9e5K0LAXi0Jd7P8/+qV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8595", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8595` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAQbbiE4ia9YS/cH4u2B4isiTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4YjkxNzc4LTc2OWEtNDdjYi04Yjk5LTZiZTAzZDc4ZGJlNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODY5NDcxZTAtZGE5\nOS00MWJkLTlhOGItZjA3OWI2ZGZmMjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgvLGc9e8B9UY+MkflSrFPC7Il9MUyc6OQ1H/UZasFMbQ7FazxUPF1TTE6Nc9\nGzH83sOWT/bujjm/irZXYTdhG6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFANnQvUfpYWK1a+kshJSxh9zkGZIMB8GA1UdIwQY\nMBaAFN1ixHY8CuR2xCNQooSoeK8943KwMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA6Ty/88OJ4eUNIVVcjgII4tjG6GVIPgp3\nCKPmYiJGBEACIQD8UBG/aIrCbWIYyClZUTYvN5/tuxIuMxIGehXyEr1Xdg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVk1Uyv/4zBzA7h7QM2s9PB4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGI5MTc3OC03NjlhLTQ3Y2ItOGI5OS02YmUwM2Q3OGRiZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4K6tUNuQVGK1FxqPybBOnKftENwq6PTlDkZd+mHjcg/+J\nu9gbG/qzKnK8s56TgDmM3ddLar0mGneeBV/ArTrMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3WLEdjwK5HbEI1CihKh4rz3j\ncrAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJBrMGawXDgmaUtT8gAMHqBONhI7IQjSP63L+ZnVBFeeAiEA8mPw4SGl\n2uS7gW9YLgFPz9F2B9cuwBm7NCLCecBxTuM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZpuug1NKnZbpfW2k+brglwnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODY5NDcxZTAtZGE5OS00MWJkLTlhOGItZjA3OWI2ZGZmMjVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmI4ZDA0ZDktNzY1Mi00\nODJjLWE3ZTktZDAyOWM0YmI3Y2FjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nL8C4BjF5MhNuqN+fRgQFtQ83czeKwXJ+AOfZ/seR/r3msSmd1zqein08+0OPIEhu\nilnyyBxCu6XG9aWHH9As06N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUA2dC9R+lhYrVr6Sy\nElLGH3OQZkgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDJilDubK7ePAptO2wmXDYqNy/RAu9glefAI/N59f84awIg\nBK0iwt604WQ7Ga/KZsUTjP39UbsE9VBD7SPkbjZJlxI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8596", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8596` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAWfoLs/OBKlqzsG9fEKvAbBcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjNjM3YjgxLTU5NDctNGRmOS05ZmNjLWM5Y2NjNmFjM2FiMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGJhNDY1MGUtMDBj\nZS00ODE0LWExYjEtNGIxNDA3ODJjMzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWisG/mT4KFvT14u+Fmg4yyT/8ojRLiqTGTM5MZhcbbbtpsmf9FWyf646TF2V\nvJO9skCilQXV2qVL+uQVm5MkvKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRpYZryEEtBBrFXiOzBfAV0uXckVzAfBgNVHSME\nGDAWgBTjdWEIVt+ZTyCxLDwhUGg+Y3Y6RzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGaBZ6BnlDbZolNPFt6jqWxQGDcMZ9N3\nEYTrvVioIAyNAiBwWdTEb0WrEe1tNGy4wLW9zCeUdg3UfTgACuDarvOrnw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWXePv5NFsz94JfcVobsgvg4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzYzN2I4MS01OTQ3LTRkZjktOWZjYy1jOWNjYzZhYzNhYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8NSjwazJuyBaZ7X64kImql3s44aG5VYNp8gBEmXV7B43U\ntLXsg8zFdHvMMZTTqXBS1QZiAMTheeNh21aYDzEQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU43VhCFbfmU8gsSw8IVBoPmN2\nOkcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPc7g5YRLdxarojX4JgZj6UP3y3Mw2LaNzRmal/52sI+AiEAjjBByWfr\njKfeYXdHAtoWNV/Cp2JhsKCsOAhgzxql1Io=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAZmm77PQqzvEHHM4IHr3Bo56MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGJhNDY1MGUtMDBjZS00ODE0LWExYjEtNGIxNDA3ODJjMzliMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjAwOTg3OWYtNjQ2Zi00\nYWJkLWI0YmMtMTNjNjQ3NmJkMjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBMrsVJ7ok3NDQu/FcJ2bagz+7rVULF2BgVmRn86UiDvNd/I2RK+2i4+2r150lL0L\nwBwlw6yKPCW5Ao62+JvC7qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUaWGa8hBLQQaxV4js\nwXwFdLl3JFcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCAeUz3On1RqJX7b2H6ocIqxpYt9CfGPwYFWzY32MyZqwIh\nAM3o6XRRdFD6yygSUbtwThXxWWpaZudAF8mMkmfjtHWF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8597", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8597` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAeG2l6rOWJElVQpO3tj5R5DfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlODg2NTRlLTBlMGQtNDk3OC1iNWUzLTJlNjdlNjA3YzM4OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RhNjAyNjYtNzIx\nNi00OTI3LWI0MGItMTlmMWEyNzBlZDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGr6PX+VOj2m9WoziCQgRe0367H0LuCRrYxM4T7Af87PGqlrclQdcBcFS/LDo\np3KAUwAlYuQmBbywEoyMwD/YTqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ3Q2qQwNKpi+cDIRZRjAraWdeY4wHwYDVR0j\nBBgwFoAUgjZoADpkjtPsqPJgP75eSHq8lLswJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEA17hopH9TET5H\n5jpnxcN7ramOo8hYp9I6WyjbWZcqvmgCIHVS1TpJiu/neSlkruyxUAYsHhcY8deX\nUBzDljrZVS+d\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZl8I+PuGsn/3zO7z2X3grrzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTg4NjU0ZS0wZTBkLTQ5NzgtYjVlMy0yZTY3ZTYwN2MzODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpYS2GiZPXNtRY4wEGEvSfq/dDm5yd0RetYtoZJ2kl94to\n0kSsS6j4C8hf1z+i7YW9bQFOPM3nvDUrEKvkVJLIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgjZoADpkjtPsqPJgP75eSHq8\nlLswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQv2MOdvv5j6CJdmrjAVM6CKpaAAZRWDDTtvlfxiYq5gCIQCEYYQQpB6p\npnl1ywOH9G6v6ZCg/FybewUWZLDEtgMyNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAU25PwrDETwm2Dyx7vZHCwCmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RhNjAyNjYtNzIxNi00OTI3LWI0MGItMTlmMWEyNzBlZDhiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWFmZWM4YTctMTc1YS00\nMjBmLWEzMTYtNjU4NmRjMGNkOTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nw3NIWGW3i8j3IAct37SntAuXFi6s9k5JlNr/Y8ZPxq94V/K1jktvUwYauU4EeWBT\ndGWvGrW5HumKR/2SPA8PraN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZ3Q2qQwNKpi+cDIR\nZRjAraWdeY4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDnv4hOpa2J8qIelMKf5a8aYmZ14YQ8saeX8WAIISTVUAIh\nAJ237ryyd974WEDhsI9gK/mMaDT2yN22LNsxYtFc3X12\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8598", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8598` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAXYmKynZAFJKosamRqDRkrDKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiZTQ1ZDE1LWU5ZDgtNDA3NC1iMjhiLTRlOTNmYzZkZTk2NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTRmMWZmMjQtZWM2\nYy00NWQzLWIwZWMtM2M2YmUzYzUyYTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbgYPs6OdqXe3diakpBsBhL6CjE2oynm5zAgYJ5z7TMiUEdzlRgcXST/SXq9h\n7Epy2t9g4XMzuSdA3e9Zem86qKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOw8vKIQHGG93bRUUQP4vXN1rlIUwHwYDVR0j\nBBgwFoAUGsJcrTtpGVQwuwd3S97kKqfc7rcwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiBHGP6aZ/vx9Qil\n97TbDzsj26i8UrwuGi7ubOSYxKtykAIhAI5cnHHP7wbsGbG4gJxTYDbc8j4UbiXZ\na9hCjs89VIuD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYGqspIEjlh6CTHbkGi2ZQw8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmU0NWQxNS1lOWQ4LTQwNzQtYjI4Yi00ZTkzZmM2ZGU5NjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQu1kTAf1YCreydW94+wpjkJgi0AgsnHpCfDNL/IAYclvG\nkyKRAzPo2zYk+UMrVbjrxJ6xEVi8G0R65A30mFNWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGsJcrTtpGVQwuwd3S97kKqfc\n7rcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZO3flQ6Jha3yc1W+4YUC11AKTIvF9gcH2FX1IihLJXoCIA1b5k3R8fnG\nNTiWTx9nBrrXeAg7ExTRoQ5J2cVivtYf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAYF51Q3JRujER17SDzsCK3u4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTRmMWZmMjQtZWM2Yy00NWQzLWIwZWMtM2M2YmUzYzUyYTY1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzM5YTc4ODYtYjdiMy00\nMDM1LWJmZDAtNDgxODc0NWQ2ZDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8zDNwIFiR0ga5xiCZw2ylW6J87/XThYe38ZV8Zows7kgjTAu2HN8ZZaUd2WB6WO7\n/TRJ3lq5sA/X9wkxo1j8laN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOw8vKIQHGG93bRUU\nQP4vXN1rlIUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIHMgj5rLzuayhzs+dtU0gV+qlnSzp3vi05GM7Y57g3JKAiEA\no2TVaTNJHvPCF5Df+ES0DWF6TQKkgXsgkncgYCsv1Io=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8599", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8599` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAeWgAwIBAgISAeiBWw+vCpv4OpxihVjFhjtMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlYjdhOWY2LWU0YzItNDZhMS05MmQyLWE3N2VhOWRhYThmNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzMzNmIzYjAtNTg0\nMi00ZTE0LWI3ZmYtNmI5MWI2Y2MzM2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFv4z4wlVWmykcVr3M68zL/AN9u/kwcEpIndGpugUnuPsJlIS46JQumQi47Fj\nveTMrqZAP8+KWxk9V9fkrqthFKOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4jGU0T/4dd3Iqb0jIPmYGCHLyiYwHwYDVR0j\nBBgwFoAUr1Bsih8w1Xo68AZ4EM8ovJ24zSAwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiEAwwApz0haiNaLgxZC2va2\n5bymy2v2dBUfbkXeT3XB6AMCIHoEbOuobBF3fbmR8mya21WFpwycWVI7uyRirNiq\ngctP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAej+AezsX4jyEib0jZNqcnHbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWI3YTlmNi1lNGMyLTQ2YTEtOTJkMi1hNzdlYTlkYWE4ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwWwIWitpRrNE+Km7dWBVULONBNqWAyxK9K4U7aDKICxvJ\ngMxfeRONv7FYfkoP0/KBSSX4x9ZXaHi7KaNEYVADo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr1Bsih8w1Xo68AZ4EM8ovJ24\nzSAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALTO2ZgwECFqqS3/0mOH1+W4aXZKULHjqzFnSLH5+kwsAiAvHRNTeuZl\n7zwlEQbYS8X+vZZclZhujWLu2nlsMIfuTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAfxCqA7F31si2+Vl6u2CKhUeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzMzNmIzYjAtNTg0Mi00ZTE0LWI3ZmYtNmI5MWI2Y2MzM2E1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmFkZjNhNmQtZDk2MS00\nZjAyLWI4ZWMtMGU3ZTUyMjcwMWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUXxgwQ0ckXUWqNenOFacUxJsjqt+8VmdLxpKop0LlkTqzLy1IkL4KT9WAyYw0xXD\nV6OEq8vd5k6nSprehfOegaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4jGU0T/4dd3Iqb0j\nIPmYGCHLyiYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIEtSm74AYb36EL3LtmOeDXZWZy6OPrFxYM3Ayn4cSBl/AiAP\n1ND53lfUvvqjTrB2THsdE+jFZxb69XAtY52YaX39Pw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8600", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8600` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAbBzUJn3xSHa20m6TH4tq1cYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0MmEzNWI3LWRmZTYtNGZhNS1hNzQ5LWVmOTk2YzMyMWFmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTg5NzU5MzgtYzE0\nOC00ZWMyLTg4NTYtYzRjZWU0ODQ0ZDQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhotLpb9ePblOSYWdizR8wTWuVLYanL4JK2S7y3pu1+I7DdxKTW5+sgf/vOeB\nnpstVEQfCacnGA/Qhay4RmZnraOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUravClfPhzNP2OnC0zgkAe4vLWrIwHwYDVR0j\nBBgwFoAU6wYs+uCHSg3jdId94gfTgBRE7bQwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiEAju6q\n3xAKOhFKOjwzPx7Dk7+6MR7JYoD9xAVlHadF4+MCIBCIfL4DCK7tRFbRo1T8ZkN5\njY80kXk5Vaegg95UicyT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARO/dG+Voa/lQpMO5e/pu/DJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDJhMzViNy1kZmU2LTRmYTUtYTc0OS1lZjk5NmMzMjFhZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+Og8WhBOycNrrkkbvqxJgkgz+Ebiw24zkteOaRMPPwNZy\nkWSz1T1G7agy5Gwfng7eWzYZ27e+pgsX4drcgQbCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6wYs+uCHSg3jdId94gfTgBRE\n7bQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJEB4JopzjHqtp989wXpp8mDxgAG3Nf91sf/DYoFo9G7AiEAhNJOw/2C\nPvMG3RZ2011uDAnwtRH7tMA+Jczj9vHyiio=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISARUtt0Q/Kqh6VIYp87GT01avMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTg5NzU5MzgtYzE0OC00ZWMyLTg4NTYtYzRjZWU0ODQ0ZDQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTY0MTdiYmYtOGEwYi00\nN2JhLTkzZjQtYWMxMDdhZTMyNzg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkJMKRTk+foos1OrefBF9bHLQRx4IlnfpbsSD5ftk3TPycOFD/HefnVuPXYXswgBh\nEwFIqxwXed9bX5Bj8Y1gRKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUravClfPhzNP2OnC0\nzgkAe4vLWrIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIApMR/3i/0Y5K9e3ipL7MNrIFLtg2HVUIr5+Rmp/D1HQAiEA\nnQ3pfED5vrBNYSIxArPMNVAuK3wY9UvQQyRwtncccqc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8601", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8601` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAXvhHdlT5XQCAvBc1xvODVA3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkMGE3NDk2LTM4MWQtNDM4MS1iODZiLWRkYzI1YTU4Njk5NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ1Yjk5ODEtOTRh\nMi00NjAxLWIyM2UtZTc5NzcwOTQxMGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElVS9ZqbBCT+aX9vv0ky+i416Ia53gKCkWsUeOMw165RTv+GrPBGj5YSBNJTO\nQQb0SGPsf2sqFI7dbSX9QaITSKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6h/fdSnmfJKWkBuV5KiIC9hVp6AwHwYDVR0j\nBBgwFoAUXw5Ai9E0keTUUQNxtMZf2eHj5aYwLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAwB8E\ntUsTazLpALTA40RWqCysSI9ESbc7PP1lVwCa+yoCIG8I6adFaGAne0Vtgf9IChiK\ncU7Hpl1Mze/JYV3vJU+C\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWJWZ9a9TNTBTvRswQWsyuVNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDBhNzQ5Ni0zODFkLTQzODEtYjg2Yi1kZGMyNWE1ODY5OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATK7or25N6gkpU3crzmaP63FleQzzbDIBgqXBEbt/wq5bCU\nM/aDpO8H2fpadtJDIsH5f/qnE36O3r0g9V7fdW1vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXw5Ai9E0keTUUQNxtMZf2eHj\n5aYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK7RjcdQ2L+EQLKDE60TSvk4IDVr+1eb12959RAE54HpAiEAxDnN45+H\nMmkIqLHlx1/4XOR2JURmdPQu5ouBC8/qcVk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQWh4iWreOMlbDm85ZfCxPpfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ1Yjk5ODEtOTRhMi00NjAxLWIyM2UtZTc5NzcwOTQxMGIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODEzYjk1NmMtMTMzNy00\nNWEzLWI0MDYtZGNmNjU0YjM4N2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkMN0XshUoQ5jDDZQqbmaSp2Uq2BTxzpd/SfIYkvI6YRhK7sll+OeDthlooYYJOiL\nSJzLMN2KoTgRUU337UJY/qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6h/fdSnmfJKWkBuV\n5KiIC9hVp6AwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCICnTSCSxJQUA+A98tWCGvEorrsw/ZUHlKoXgJhxDvgmyAiEA\n5MhVNi8kuOiMqqwsSoXMFqP3fVfG/ojufFB6PQ77bd4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8602", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8602` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAdecAuxHH2koc9+lPaI8XqXLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmODI5ZWIyLWRiMWUtNGUyMS1hY2RhLTc3YTdiNmZhNDIwMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzllYzZkMDItZTVk\nYy00NDRjLWE4NzgtZjhhNGIxZjA1NjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYf60CMBUf6Fq5SpXp1kYswzCJCYQxrumMp1XbOD+CgHXNnxb9REpryyWtwxK\npTtXTaAXdN3EbXptXe3gMIARhKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAdWklczPmVLFDvQVMePsJkgj31eMB8GA1UdIwQY\nMBaAFHgqZzRwnabgIApztIu5u5HM2jf+MBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAjkVVWklpavA+Qs7cCrBgbfu1AbC76dFK\nbzV8nvL57OkCIQC5bdHcl38j/3uQcZUaB4An1aJkRRquge15xkNcYKdTiQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcQfvVDQMeElzcw0ik8PV0irMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjgyOWViMi1kYjFlLTRlMjEtYWNkYS03N2E3YjZmYTQyMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1lP+GEpl9YNfnkFGhSqHNR+4QUs6TA+HblwkIih2h0hxp\nZypDyBa7Ef965pJZWqDjP7o0Mzuf6q3Pt1PD0Wodo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeCpnNHCdpuAgCnO0i7m7kcza\nN/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDrNPnlWRiUqN1Q8pL+thctxXVWuZVM+bKOM4xvSaMCUCIAnSbCgVErLj\nsQKFLxu9Mp+89gBzsatMumLpnN9Ysufn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVHzneTNgOkBm1GIKw2SJfkmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzllYzZkMDItZTVkYy00NDRjLWE4NzgtZjhhNGIxZjA1NjA4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjYyY2QwMTEtZGRmYS00\nZWM2LWE1MjAtZTAxN2YzOWRlMThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nwyGhYC5uW7NbmsWW9Fdx4k7jC09fDVd9oLIzfXLswmtz8SgH6ozNHjccA79+1Vu9\ni7HS1B6U0XPrLCiS0Y3JhKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUB1aSVzM+ZUsUO9BU\nx4+wmSCPfV4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIBe2n0BFnSUaIuebIPqtt6fkKl0uJWbpu+INJO6BMqQgAiEA\nlH+HQqUwFdQQkpF/6ADR9ggJsEgu3wdff9FS7uC97kM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8603", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8603` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAYt3znYF87u8/NR19jCLqWGpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ZWFiY2Q3LTRhNjctNDczMC04ZjNhLTA4M2YwYWIwZWUxZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA3YmU4ZGQtM2E3\nNS00N2EwLThlYmEtZWEyYzdlYzg5YTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEobWfRI0BiYFXIYGzSywok0hKL5OlDKalawTCKz+lpwvhptz4Xb7ORK7mpp15\nnneHzXPhDOno3pK4pQfmvinlfaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrGGD3yqqvDOhmBG+EedSsc9AB1gwHwYDVR0j\nBBgwFoAU4SO+k0R7uGbd0jQ46d3gjFfnh+QwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAO+pfFHhNgtd\nfczxN0keJhLnLr6dKcnmYTOVBZswhe4iAiAjRWRsJwZ2oSAkx+fSyKcpD0QqbBGM\nTJ9gagWqs8KC/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWzwH4yzrrvNHWKMVGOz2r3vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWVhYmNkNy00YTY3LTQ3MzAtOGYzYS0wODNmMGFiMGVlMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASirhu8HmQNZcF6VM3Xs5A9PQ6cZJ46Jzw4z6ofRLl3L3nf\n8dG9vhwjD+qEla32tFgq1D0j8/I+3A6WVqWXldyvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4SO+k0R7uGbd0jQ46d3gjFfn\nh+QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQpiECF5g0Psz1aqyTwjb26FoCr/CHfLcC5zGsl1pjQ8CIQCAnDJayniU\nku4mzrwbmUaB4trZ/3E5GPXm5K48ghyyBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUJetX5qOh0rx6i1KbUvoGiwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA3YmU4ZGQtM2E3NS00N2EwLThlYmEtZWEyYzdlYzg5YTI1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmNhZDg3ZTUtMjdmMS00\nNzhlLWE3ZGEtMzFhNzRlNmZhY2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKY6YQmS9B9vU5A5nrZ49nwqvh4ReIvbNUJCv0j2W0LB0SMcw8enQmRwGA0sU0R9T\nljLDl/A2g18jHimvVn2k1aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrGGD3yqqvDOhmBG+\nEedSsc9AB1gwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIEelXP1Qyy7Su74qoo6hOja32GeW2LSg70qL/EenBNZQAiEA\n+XkbELBA1btdgDulT2MoFL4XIptWaE0fdxJMDk4tGvg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8604", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8604` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAVoRzrae4Et+7QcZWlV0LRjWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZWNjODViLWQ3M2QtNDUyNi1hOTQxLWIxODRhOGEyOWUzNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjg5ZWIyNTUtMmJm\nZi00NWViLTg0NTgtNTQ1NjJlMWY3MjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI33MnIqW1kmF1P6M8iptUv9vZxi7IioGjdDX7bs+f1DLROyyraAdMBRfl5fv\nHV+LlOeyk4oczaiqjtPNPuomwaOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1uYu7oBvCFKUOXGa5oaVou0KfgIwHwYDVR0j\nBBgwFoAUA2TI1uNdEnSdSirji8xLLH9aWoEwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAMgTm7muUxEr\nRfzBKgQMCvODFY02AnYinWjegBLNCepBAiAgNHiZAW/kCq/mE7La0uE5ImPFZ3Bn\ncctlHrJS0wimCQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbC/vEIQhCbHl1Nu21z2L953MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWVjYzg1Yi1kNzNkLTQ1MjYtYTk0MS1iMTg0YThhMjllMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSW7s0VrVzIAnSvDLGlMjiiZ+VSJ6NnuOf/eKRk82lHbGu\nBJBVBVwPHO+CcDc/9FbD0knWpaFvtqnWvWLXmdJio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA2TI1uNdEnSdSirji8xLLH9a\nWoEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDl6VHX0S28k9hxfLTkBdFx7Hf9O1MCVzdnYbA9mJYXsCIQDXx/sD5anS\nr1BFet8aNihRxqmXoOgDiWkuVuqbhNAyww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAf9RcyeOj3M74eiG8CLtMCfIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjg5ZWIyNTUtMmJmZi00NWViLTg0NTgtNTQ1NjJlMWY3MjljMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjM1YzVhZTAtM2I1NC00\nMjUxLWI0Y2YtYzA2OWE2YmJmOGRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTM/CfRuO2fRoQ0RHYTrwKHmEgEtu1AlBP0u27H6ZWo2O3VuzycoQ43C6hmuQSEf3\nfYllbIXMhlvM8rIpoqvprKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1uYu7oBvCFKUOXGa\n5oaVou0KfgIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIGK4EO8626S3SWtEwRoQzv0oEHpDQQTV1k9D/0MHsgqvAiEA\nm1UF0I7UC7oOphEeUv0qGhAbySuoQnMPt43yC0oRow0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8605", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8605` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVVQLmnRgV1Zz29+2Hkc10OhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMGU1ZTRiLTMwMzQtNGZmZS1iNzE0LWYxMzIzMWZlZmE4MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODA0ODUwMmQtNDgz\nYi00MTU3LWIyYWYtZWI5YzA4YzY0MzVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPISx+f4pRHHpWDqn8nMiF7Yq1hOb2AQ9Umwgo6iQWEbWusKZnxusWDQ/ceLD\nrm6l8DXhS0E1h1opapTxmDMg6aOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqJ6wNXdOyIL6HfwVGxSjze9s7mwwHwYDVR0j\nBBgwFoAUgygMF0k+/JUjtwEUeXFb3PeQHnQwKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFmVfD4lnZIl\n2Wg7Sl8zzTcwD/rBwHfBeImXwOrNlB35AiEA9Ueqh7wvppCjk6pVOd7EXGvDJCqc\nrmTr6DIt1r6norA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf6bT+nK4rRzLE9JjfFFC00EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDBlNWU0Yi0zMDM0LTRmZmUtYjcxNC1mMTMyMzFmZWZhODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEB7DcCXs01tHAYOlbk1inRvyXSm0JSYTrUzeCBYI7YrdB\nz7D2OSg4wKMM015XWTwtAPs8m0FoLoxojDV0FBeko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgygMF0k+/JUjtwEUeXFb3PeQ\nHnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIkAvuTMCyg4CHiunpP0pi4Ojdv5NrEY/7W9uycZSsawAiBs1f7eCm9N\nO14bMzvR3B1/pNw7cunkeiJQ5vfr3Gp60Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWcvu4PHcTCk2dPU/rt1EPXiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODA0ODUwMmQtNDgzYi00MTU3LWIyYWYtZWI5YzA4YzY0MzVlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWE5YTA2ZjQtNjUwZS00\nODVkLTg2MTItMTExNjE2MTkzMGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nagSB8RIYElvBFtjGdePVH/MeiJ6i/CWc/KDRQH7FOb/i8odscaDrhtNOdSCZKMGT\nhflUGVAYFw4pWhFzVAbfG6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqJ6wNXdOyIL6HfwV\nGxSjze9s7mwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIBWYe+/R+qdgrLSBFdsGLfTUPw4BoJbePgtQNsf/jpe7AiEA\npgI/B72koMzJREwrTGZ1/R6aSPXdH380/jxB/m+Cnek=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8606", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8606` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAbr4htjL5SlWzFmSEkid8U8hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlZGQ4NTY4LTEzOGYtNDA0Mi05MzQwLWRkMzNjMjM3NmY0MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDRkNWE1NmYtYTEw\nZS00MDc3LThkY2MtOWYzOGFmZGI1ZTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVuQafb3sJl8JDk1Odn6/PtT5pgm7d945VjYK9aQOXUM8YYx9qjZAJHDHJPVc\nga1wOA8VaBTr6tuoNEB9XqKBGaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZOkjj1cF0neGy9Et0R7HZ6zy6lswHwYDVR0j\nBBgwFoAU1H1MwU5hdv4z2H5xOeKPODClj0cwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQDm/wyFukMZghZtamY++OuMDl6Y/eNbqS8vrbaFs08oIAIhAOzrK0iLdrL7\nhfUCNM9WYQhgiO17UJARORwILxUDQpTh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAULfbAWSnYtyh5Jn3hcW/gSaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWRkODU2OC0xMzhmLTQwNDItOTM0MC1kZDMzYzIzNzZmNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9kIttXi9Afc1Izjf+TMTZIQp5W9Wn2ZEaSiWTamUjZ9bl\nO4QfXXwoFVu0acCm7J1sHyst46xwYW2DG4i7/vzyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1H1MwU5hdv4z2H5xOeKPODCl\nj0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJbSEV/c0+OyKVIb5BI7G5c6ayBN3Wmuh+DDxIKwYm7JAiEAgZDyjNmM\npCjqArk+SgBfgOTs3wL2SQLskPoFlhzHtJs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUDVIadLY1itNljSVf6LZb9mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDRkNWE1NmYtYTEwZS00MDc3LThkY2MtOWYzOGFmZGI1ZTA3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTkyYWNiNDYtZWFhOC00\nMWJhLTk4MGQtZGNhY2VkNWFhMjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n40AKnJedK29kyhHJyOXnlpPVPdJBVQ7+xVu7uYL6vkVxAzWbMcm1KLHDO57hLneN\nk7tpJTP0hIkQXeD3+QRdF6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZOkjj1cF0neGy9Et\n0R7HZ6zy6lswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDus7ikn+8Vfpuzt2XEebBz3UCZqt1Dga9uUl5+asN/6gIg\nKNViuUoFMXCa1tHnrwr+EmY7dCAEwQVVqIbS6DXJDjk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8607", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8607` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaseL2dkeQwYoLP2/jsh3t4zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NmI4ZTViLWMzYzEtNGNjYy04YzNkLWZkNGQxZmQzNmU5MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNmMWRmMGMtYWZi\nOC00MzFiLTkwZTgtYjcxMDI5ODBlMTIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgLRgZoxRmpkgARM4RKGX5vR0T6aH4LUMe2ke0exx93JbAR+r7m8TOGrMJDf9\n6LnDUsvcK+g9tQqdzLKdoPkMjqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkoBIIkjWirgTSgdpL7SJDWrv6fcwHwYDVR0j\nBBgwFoAUhEpTNO9QrxZSk94Hr1EIvqEYNYQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCOJnSNOvt2dRt7GqSo+T707zYKeBh7/ewwW/4B2vtJ1QIgH4NcDEWjcsE7\n7nJDXCvfjDwCNA+1uD8idwtUsOmVnMc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc5V40MdB+Nt3IyuA7Ta5MpZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjZiOGU1Yi1jM2MxLTRjY2MtOGMzZC1mZDRkMWZkMzZlOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS35B9TnJpgw+Uc+0rj/VXPVQ/kpw+qjGQ5wNMP3PvIPbKW\nAgkYJVNtb4GKBJDZOs4yw1TJu6xKp6SFvfjk1XZdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhEpTNO9QrxZSk94Hr1EIvqEY\nNYQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ6OMQOVxojGUy3gU4Z0G5X6KSkYPlEdgI9zQXRTz03ICIQCowuUNzNUp\nzcQaszb9qeAjUnPxB52x0fuaK3FzeSUk7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZUIzLMeb91jKKrO41ruAxwkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNmMWRmMGMtYWZiOC00MzFiLTkwZTgtYjcxMDI5ODBlMTIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjFhMjZhMzAtYTlkZi00\nODZlLThiMzgtNTRmZDhhN2ZhYTIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\noGafoL9YttoQ7dfRPJIbQDznS54DU/6E668G1Yv91Vb6pqNLhUX4NzG/2dU11Hof\nEYre0hoqYMbXE4+EdY4tvaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUkoBIIkjWirgTSgdp\nL7SJDWrv6fcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDfdmTE5jTrvIsbuZ3fmaQejsnJISTbSOtbVJzXWRyeUAIg\nPazstiMPxRHCdvMx6sKmsu/6QsPJ2uiA/o2N254ppA4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8608", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8608` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISAecm8IUt0szvgBziOJ9b920IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxOGFkZGI4LTdhOWEtNDIwYy04YjAwLWYzMzU3MGE5NzBkNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjMzZDU0OWItM2I1\nZS00ZDk4LWI3MjEtMWE2MTdiN2JkNzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV55lHHFCVJlhQFl3IEFpuc920jVioJeI4QGn3v9RB6A+1Cogw+ZMEilX1Log\nGHHxc7Pzsws9kgfnlwpMn1W1LaOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIrLhuVpZDvJ5FKqnZWaPyNew9IgwHwYDVR0j\nBBgwFoAUQUxSkvDQBocPKtOr7Cnb7+FdprUwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBgB\nFY2tpXI6/O/aZ/l5ljBrlPX0ZxM8VAb2A2K3+JzxAiEA7TpFjTbmnm6FEyM2pr4E\nfMg6O7WtX7Ixpvy/aMQM0lE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXT34z6A945n9vzTQWO2hpg7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMThhZGRiOC03YTlhLTQyMGMtOGIwMC1mMzM1NzBhOTcwZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKXBiYxpSEqVRabf1VlZ26HlivcMJ/Q9p+NRBODXZJGBa3\nJrYWzrcKAXXbHLO22dqQv7ScfDmcycusyQe9QGqUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQUxSkvDQBocPKtOr7Cnb7+Fd\nprUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKc/VHv7ZkbD6qQmwn3YnkpUeCR5WzOQZwfDxfDcnLxmAiEAn4KeDjb7\ntBRj6laX11UWpeqaJ9jAPrLx704GJdpi4o4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAeiqJa9pjGjyQUYlq6+rqHLnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjMzZDU0OWItM2I1ZS00ZDk4LWI3MjEtMWE2MTdiN2JkNzI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzE0NDEyYWEtNjZkYy00\nZDQwLThiNTItOWI2NDQ0NWEzYjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZpcNZ5myxqhHExoB6r35jgf3Tb4OGn1j7mTUJ3arMS/30hKpzhvG6mCzHrQ3U4Tp\n4tgZkoGXZmAY7uNsMnyYWqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIrLhuVpZDvJ5FKqn\nZWaPyNew9IgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIEJ0FdpdM+kj3IUBGY4t50bh10jSVYTmtGAy13H/lbQkAiA4\n7jxfkaM24OkSVrhgfzwzn9NMJEzDeA7n410U4S5hNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8609", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8609` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAd+LADVstFjEoPAgfVJa3bDmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhZTk4OGFlLWRhYjItNGEyYi05MjM2LTQxODM3MTQ5NWRmZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVkNGJkZjItMjRj\nOS00NTNiLWJhZTctZjZiZTVmNWM1ZDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETOLy91QWvsIlc31Fm2yO0upofnXAUlaIl6/AVcoATa7dBbVlUux5zTt6mZnJ\nANopnCK24I4LjFpNMlH2Z4s1DaOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo5f7K3vki0eQgo7mpNXZbQOQ6aIwHwYDVR0j\nBBgwFoAUm9PHgPFteU4iGmlAP2WTqB3f/rMwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0gAMEUCID8lESfGJDzoMUMuYtDm5SGOETlOdk5yO/yVSgrx1amsAiEA6iC+\nHLFGmzvI5qFwZrMVFHVpSMc9Vp7al8aOoX3Aa90=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe1jhutC46GwEuO5a+fZ2BIKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWU5ODhhZS1kYWIyLTRhMmItOTIzNi00MTgzNzE0OTVkZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATO3tP2HmOaU24yUAXX7FeOUNQqppHq2PPeLd8DGvV5Le6O\nqa0pUPcN5liqhGiElM/hkPKk4nq8QBWnA5hAjytho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm9PHgPFteU4iGmlAP2WTqB3f\n/rMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgawbnNwS1TPQmtpfUWrAIJSoPGCOueYa4fcxQtO8wAOgCID1gztdPIruA\ntzDS0S1RyTq+Sv67cPRxzJi3vLzPMW20\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAZmAyabg+POUvprVaFn1WSvhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVkNGJkZjItMjRjOS00NTNiLWJhZTctZjZiZTVmNWM1ZDVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTMxODZjMmUtNTU2MC00\nMTQ4LTk5NjktYzQyMzZhYTRmNDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/gKnhIYbtW66eoBbW+pGpHbuI9AS5lEIeYugdAfgPeGXtekfJahMCTVQQ3NXCWt0\nbjqW/yROauDHVRGwMy3mXKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUo5f7K3vki0eQgo7m\npNXZbQOQ6aIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDfpnvwdFK+x3155yAN8xUPy1rq9vJ1qcQhoB+Em5wEtwIh\nAP70O/q7Q8fQBkXl3hFpf+F1Axp2BuGtFjq4kjBvVOaU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8610", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8610` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAVHCopHbDNAvYf3xW1oHPEowMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5MzE3Mjk0LWI5NTEtNGU2Mi1iZjYxLTI0ZDBiN2I1MGU3ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY1NzEyNDctMjJk\nMS00NzU2LWJlMmMtNDUyYmE0NDZkNTRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6nBxXY93I5EJEXbkdn11jokz4laR3BvhfqItQVJlcivhb3kuHB6irXG97ALv\nJyjJ30tgJuQHsUqbKNSRYyEZ76OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU24qndxKwG5hbdE4ak7YjhXZwrcUwHwYDVR0j\nBBgwFoAUezWmb9yl8RfejiSccmBQgocSrE4wOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDv3hUbWBcwG0kIhX2e6Tss5LjfVqLYCn47KGMKyHVfhgIgNfKE\nYAMyjos8YjZtrtLgjjwX6Yxdx16uN+NDzdsAoz8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARIgmjJF0+g2kZuov9jHrA6pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTMxNzI5NC1iOTUxLTRlNjItYmY2MS0yNGQwYjdiNTBlN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmiqEfIoe7k+6zH8YqFbWNjSI4Wmg7XtfUGmYdVGSpaPmZ\nthLMDGLm2NE2KLo6/l13/sWUBZyzAs+hT0cPcURZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUezWmb9yl8RfejiSccmBQgocS\nrE4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcO1mvCRNdARS6J9NHDPF4iN5p6JM2rC88nqwFdl8PGcCIQDWh+CjkY4E\nOyvGGk8u4+U5zASFvOxBJ0+4NQpLAb7r5A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXm8E1p8V44558lBbzC2wg9WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY1NzEyNDctMjJkMS00NzU2LWJlMmMtNDUyYmE0NDZkNTRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzQzMDFlODAtYzM5Ni00\nNWE3LTlkZTUtNmU4ZGFiODM3M2M2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nf5hJrNKgO7wSlFoXOgADAIP1zRVa8Z8wiPj2YE0aJjv90c6bdcKwV7gFFp5/1d8h\n9ToafSihaFjLEcJFZt5cVqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU24qndxKwG5hbdE4a\nk7YjhXZwrcUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIDA+l319cAGSIePqKzA+K38KaaFe7G0by/cI3IzGhgEbAiEA\nkTJFmUl6GfvKlzO9/PJrGZaZKVi3OqRqtqQnjbAsLAc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8611", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8611` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATpeZhCvKVWFASNEbEpoul0kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NDQ1MGRlLWQyN2YtNDI1Ni1iYjk2LWQwZmRjMzJmZjEyNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY0MzAzNzEtODhh\nNy00NWNkLWFkMjQtODI1NzM2MTY4ZjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnaUXBCq8VeqbMjJGdrSKOj06ccyqvciyjsYEmLKJT5+cAFiB0ETNgV64y98G\n8XKZHzbqy+lktQcrJExMzXpFLqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFN92AX+7sIioOMUk8RgU5sJLz8gXMB8GA1UdIwQY\nMBaAFJEUN1IGv9KVlZuOTtoN9wfefPQ/MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAhh2wQ2rsN70n7vy83WDPt1OiFOmxa2LX\n9fVrbHkR7uYCIExf6d8qJFFXERZ3lUKAGr3iGWsfId6h17leTOmrsrTl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcxTBAb6gy6nXlGUasTcCGAaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTQ0NTBkZS1kMjdmLTQyNTYtYmI5Ni1kMGZkYzMyZmYxMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzFuakVpdQzIR/n1h4NLBTvdNReFHUw1bBbe+kMmuSQ58z\n+IaAEyClc8jRQ0Nb2Yb0z1htHMUQa1Gwrze/8rqno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkRQ3Uga/0pWVm45O2g33B958\n9D8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANH49s1zJtrn9sC1qHIcsnvR9DWtTHsjVwyLwhwlgK6HAiA3pFBktoc6\niP2ng0f11PHfYk43CQYaJE1pIZGatxX8fQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAQCx9s0p7Tc09jEF8BDSIUvUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY0MzAzNzEtODhhNy00NWNkLWFkMjQtODI1NzM2MTY4ZjcyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjM0ZDUyOTUtMTVkNi00\nY2ViLTg4OTAtMDI3NjQ5MzNkOGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCG6s+8O0yOPOcD8e24sctGuN6I/0fdkg/WI7u7XFVNnEO8/6moP1b75qbn5u4xmS\nseM92rJBU6Rc8sy4B0BYC6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU33YBf7uwiKg4xSTx\nGBTmwkvPyBcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCICo2llTq4gMU1/Xj00fuAYKmTsb6Pi0UTz3lTphLcDy6AiAS\nNxPXqKRBRHJJkVaI0FZJLhfHuLYuMzITF2Qtt6hjVA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8612", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8612` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAZNUuaTnJ+4bbQo+5gbHNXBdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyNDYzZDc2LWNlMzktNDg4My1iM2Q1LTUxOTZiOTVjNDI4NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRiYmY2MGUtYTU4\nMi00NGM3LWEzZmYtYzg1ZDcwNjNiNTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt+HV5SDi6mnKMhqWBZGBp9AWvH9f6U5SlwhD/yTWuisJryVYyvNDAUxrBXsY\n2O1VV7zn7biwhtQ07rGwCCgz6KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGkL6tSxaLYU92bb3SlWCDxAVFq4wHwYDVR0j\nBBgwFoAUhpOLzYtPqqnkdhPWTZH/bhoPEEcwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgPKjo9XcQ/WFE\nIs/8wZGA/iiAflgi0jw1JG9upAUn5swCIQDXTaTkkoIoac+DusDb8qdlm604T8nL\nZA3N6iY331roUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYWmCBCSHMMX23X5MUiCGYvfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjQ2M2Q3Ni1jZTM5LTQ4ODMtYjNkNS01MTk2Yjk1YzQyODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQkcDlwH/q+R/5rl7R4l4AlXnjpCaPuZkN4qqr3wmijrL+\n3Sa0vcURxdVTuETH1PDdg+PjZWzvTq+geeiKTZJHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhpOLzYtPqqnkdhPWTZH/bhoP\nEEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANfq4z5KfW3QDrKD8MzdffXxqO/6lz3Mha3Ueiv0ET1AAiAM5TpvEDOL\nv8V0WR6AwLIVcDkxLV7+CqYzkXiphecnGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAXZsnneOAuYEDzHZsGJFzI3ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRiYmY2MGUtYTU4Mi00NGM3LWEzZmYtYzg1ZDcwNjNiNTM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDFjNjc3YTMtZmE2YS00\nZGYzLTlkY2ItYmUwZmNmYThhMzIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nttDp7r1gAkMZPSoR0jSxqK5xiS0Wm6qnbeeXftOYiiFoaxzcID+rxHVnnokbJvjs\nNLh8Iu4eRIx6XXdFZXLTd6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGkL6tSxaLYU92bb3\nSlWCDxAVFq4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCICIvHUa8Ma4CtfMIbr3wCW/Z05UIdQAjnL9F6PH5o5HpAiBn\nfx6Jhpm+sepH+erTDqO/OcGylO5+e9gl3N083aI3xA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8613", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8613` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAc+9ZbAAsNqDlEQ78yZgs6JlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0ZDc0YjFkLWNjNDItNDIwNi04ZDI2LWIyYzhkMzVhZmY2OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UxYmU3M2EtZjc3\nZC00ZjQ4LWFmYzctOWZkZjJhYzk5NzUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXdrf7+cJ8fQi/G57jzts0FigAO1gW13fisfbxO6x+iLGAt3X3UTP6+Hj//2n\nM8nS79vfw5ieuw5gf7OQyEHKhKOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4NWINiRHMEwg5mewQdXWAW8NHdEwHwYDVR0j\nBBgwFoAUUZa6LVB/nbcWbcrWpPlWjTt6msgwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhALBPt43ny8mo\ncftnD4sEKDCVdhrZHAGvsDVccR3UxQnNAiAx1W28EgkrBLOfvCEW94HyAv9cA5rc\nXOO7QBy3KEyWbA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZBUp1H1f8uEN/+7KbpKEzZKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGQ3NGIxZC1jYzQyLTQyMDYtOGQyNi1iMmM4ZDM1YWZmNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS44c98/kQIbaHAhyowkOPp+6H774vFeUxw6kefx5Q/EYzC\n395jCVY9XJuF81jTvuKOVM0YqEIt/bdxem8ppD3ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUZa6LVB/nbcWbcrWpPlWjTt6\nmsgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCnRD0LMvTOnZ1VqddtWK3xFK1D0CYgFbbPKi9BRL+qcCIQDWE2wXkayJ\npWyzkqMyQaMP0DJJjrPIcuDXMal87V6mww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAXPKXhW8UlaqGqOMVrM1EVUPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UxYmU3M2EtZjc3ZC00ZjQ4LWFmYzctOWZkZjJhYzk5NzUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzFhODJmMmUtMmZiNC00\nNGE2LTkzNzItZjZlZDhiNzlkMDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4x7kJ71nMIrflwIpYUgLcIwTMKvEWggIrS38XuZkyMxYB1+UkDNKaIL9nHikHABr\nmsiti5gEprdx/o/YFVd6YqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4NWINiRHMEwg5mew\nQdXWAW8NHdEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDlIgzoRA6fMDiV0Rz0+env54vTaLiHXlZzid6G71BQkQIh\nAJ3pB5hA69OlkpgfStdzn75QLY2igYk5YQ0T0eQLY+Li\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8614", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8614` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYdYgkoGSHFCXPCoyd+3Zuz2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhiN2EwZTMxLTM2NDgtNDc3MC1hMTNlLWFhNzQyYmM4Y2FlNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmIyYTA4MzEtM2Jj\nOC00ZDY2LTlmNTctODgyMzE2MWMyZjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoSR6iyRvAX2+Wzp9Dn2tbUB32UyV2Q941T/88bPP7A/E1yVJI2NKhz/h58g4\n4XsdEUtHSbGy+3m5nBWpZQRtv6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtl00hD6z4QxJrcgsFqzyDiihDuowHwYDVR0j\nBBgwFoAUyq6yboKnO4D8bksDIDKtJDOr73EwKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCHBp0dOUUk\nj0y2v9+OHKOQnZ7Oz0Or6871jWrQKcr+BAIhANXgDQe6/96WzMlp/K9pAPFoxCnJ\nW+90IX6W7ztmbtev\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS4DIy6FU6Q8S8dkdqSx8WlAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYjdhMGUzMS0zNjQ4LTQ3NzAtYTEzZS1hYTc0MmJjOGNhZTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJRJwvkVoYnhI3RB/ehWmjNT3B9/EsM1aWfUxJF/GIcMKi\n+4uOEWyUJM3wCjFgMj+HylxE192VqmgCz4w4MXj8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyq6yboKnO4D8bksDIDKtJDOr\n73EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIFv694EfaZChdFAF5mycMGSyUUtCsEEZ366VYqInGfjAiBTv2vHWnsd\nEgkx3d25ffyqXJqq/skqKQLiF4988bMsrw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAUG5pfBC7rq0UEx+Lx/TygkNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmIyYTA4MzEtM2JjOC00ZDY2LTlmNTctODgyMzE2MWMyZjZiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWQ3NjIwN2EtM2ZjYy00\nMzkyLWE2NzMtNTNhZTI3YWI1MDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3mKEQaLMaB0O7Ji24NOQN7OySAwq3cTUpUiOKnyVmnGSnyPYFLSk2PxXkrko1mqr\nAxmg8pRIYb3yDTCqyYttSaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtl00hD6z4QxJrcgs\nFqzyDiihDuowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIFYW0TF9EaNKfMKQEq5zSdWDDblptPPWoPOckTQ7DeUHAiBn\n+JFoLYf7LvLElMzxAj8BKdgXfJyX1VXzYSFrn8fypA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8615", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8615` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAdCpK8ciVCqt81yo5lIYHLiHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MDg5NDYyLWZlMGQtNGMwYi05Yjk0LTdmOGFhMjUzMGEyZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ3MGY0NTktNzk2\nOS00M2M2LWEwNmMtNzZiOTNjYWQ2YmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmuMiAjICWlWSZXCOezU0/Nr6zd0W1to6d4NpFoMuU9EriJUCp5NAJK4uQjLE\n8tXeOvUDPBYegEYF9TpYM1vf4KOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6wrO8go7lCC45ncRmb8VNofS+MwwHwYDVR0j\nBBgwFoAU1o04GnfPaGqFxZ/rLy98TfRWBjIwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCq1ka0Ajpf17/hEet/RVeTpEfcyBdtBAAcPDYJ1EnG4QIhAOfbXromhVfO\nafCyLlbLLEDQOFxFKmTlE2t55Ziq9r2Q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfY4JFtdAMdKbtMaGiWlrwVoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTA4OTQ2Mi1mZTBkLTRjMGItOWI5NC03ZjhhYTI1MzBhMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjOkP1umFOKikuL3vvYmvZkVOn2AEGcIf8276vOdYfUMUY\ntYGomxidW3Hi8I9/wk528p9O1FU5uyv203GgIc4lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1o04GnfPaGqFxZ/rLy98TfRW\nBjIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLoTyPLOIWmUJQgWPW8f2kTX7mCIT+2Zpz5aVL10P/TICIDi5vxfxrAYh\n+o866+hwG02d3Kv6c3Vipkhe2QWRhx2E\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAa66V5MrvXU8H5+UXFghVLClMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ3MGY0NTktNzk2OS00M2M2LWEwNmMtNzZiOTNjYWQ2YmRkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGM0N2M1OGEtYjJlNS00\nMDQ2LWJmNzYtZjg5NzZiNjBlYjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1bzN+AXxii4YEfKoXu3D5d5DSmycgjIw642WM6QAEf1S4ItafrFkujIcfeVpP4Hj\nk1IH4e4HidK9lqiVelgIuqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6wrO8go7lCC45ncR\nmb8VNofS+MwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQC8Rh17YC2S61YDny3EHO9N9A+VolM1EJKI5pXdS7BilwIg\nPCJ84MZE6ztd2OpCTe6pWS9L76SFVB+caDiohArocAU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8616", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8616` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAdGzp8neSAumjWEnbGz/8lW/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFkZTFjZDFkLWUxYzgtNDU4NC04Zjk2LTRhNzkwYzdiMTBmNjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ViZmUzMjctZmQy\nNi00NmQ3LWFmMzUtODI4ZDgyYmY1NTgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg0uI8BkGoCKcja1hOFY5eiMo++5cxYPX8R6/EkwxZJUjDlFwPAo9nJrM78cT\njFKL4EzhQXoPGfD0IWOM+ZoTCKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnIscmpeduaoBz441qArBLQVD/hUwHwYDVR0j\nBBgwFoAUMqXX77AKGiZ16uwGliGVjTzcNIswNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCa7FGreq+C68CQtlZTqXLg2+52pp2cjPeqiBOP+c92+AIgE4n8+6OpecYI\nb7VnKWSNwRResKODi/maAZasgxhAIRY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ5REu+n59JWglHPHmkPAOpcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZGUxY2QxZC1lMWM4LTQ1ODQtOGY5Ni00YTc5MGM3YjEwZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/KIWPe70FvdvSTjEjOs8b44m4INo0TnBYhdBf+SyNG+3H\n3z/Nja3c1uFPLE43ks9XScslLNiMHGambME29OZ6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMqXX77AKGiZ16uwGliGVjTzc\nNIswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCQxjwJQJCE2EBYhY/gBduRX2XxGvkQDU6LtIsaDFqB4CIQCqvXug+rhy\nmUm0dHyZBmI4Qt6weKBq752w9TtfZ4FOhw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAXymrbOCMrtkbGzlT9RQ939TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ViZmUzMjctZmQyNi00NmQ3LWFmMzUtODI4ZDgyYmY1NTgxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTE2ZjJkMjktZTkzZS00\nZTdlLTkwN2QtZWRhMmEyZDQ5YmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlSJAx+5xuI4rLmb2vlq5EDkvg4foEg7DwJNa9cEC+WY/2HPH7EjClurUOcxMvNBk\nPxXI1DI0rMLZPTYLeLPl66N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnIscmpeduaoBz441\nqArBLQVD/hUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQD+CgkiIxiDXqkynSKaXpD//FamUD8gQ5EaZkpJG9Fp/QIh\nAMhG1m7jI2oQNZkaB+daeNJh3/8k+VPN7dW1MfamEpmU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8617", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8617` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfOgAwIBAgISAdBjhGEilW2vulRav2/N4q0UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhZDcxYmFjLTMzYjQtNDA2ZC1iZWRlLTc4NjZjYjAwMGQ0OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjViNmY5OTQtZTVj\nYy00NzIxLTkxYzUtMTM3Y2U5ZTk3ZGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZPQ6uODDaAC//9TRRb8FZLW3MBMqq6auUAPvPyBu0zrtKlzrcm7Kk9U+NtOa\nrIZ/7MG7AasKVzXIkJjPkMrRhKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURImAjbWQ7S9HRR4vTy+nOpq6xGkwHwYDVR0j\nBBgwFoAULwYC7AzZd00rTF5gSrp8j9LHr+IwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCP\nfkNe7iqmQIlcVa0NjolGcu6NR8c0Slq2ukznhL6ciAIhANRrIEwPx7Y7kmgf61m+\nfvqJnUrd8PWOpMhUo+XloYV6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAap+yf7uhA25ZxLLqmntiGepMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWQ3MWJhYy0zM2I0LTQwNmQtYmVkZS03ODY2Y2IwMDBkNDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUwZe7jqo4aWz0+MgmAmv/IG3krCNR7VeqZ9zzSa0w1hwc\nekT+Lgr6daVabLUoDwgXkeYxB0+VcRLckTgjXJdMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULwYC7AzZd00rTF5gSrp8j9LH\nr+IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHCNUhxpKp7pJXrIhgh3bpdPGBPrh+jCH6IB2qfe1Md8CIGhmQg4IToie\npOp+GE2vD/bldtPytTg89Tr1qep7Cm2Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAUgi+MicAQ7GYrwdtq+MyzZsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjViNmY5OTQtZTVjYy00NzIxLTkxYzUtMTM3Y2U5ZTk3ZGJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDQwNTlhMTItOGZkNy00\nNDQ2LWEwNTEtOTJmODdhYTg2ZmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWQ5YQgyWaLhcrUKQBguI4DWF92k/iPN52Hzuud67qzRtRyxq6Xs6h9Osmk6JBgQr\nlpMOiuKhTdtDGS+5uxLXgqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURImAjbWQ7S9HRR4v\nTy+nOpq6xGkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCApQpC+d0GIPokVGqXiUSEO5nBf4H8rPI+4T9XBm09CgIh\nAJGHSxbIRNw3eGlaARXWd68ynghHvfkHKBrKke+9OFv+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8618", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8618` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAaIWJSp1vVrfZulHvE/h9ZySMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3OTk1MWEzLWI5NzctNDEyZC04MWRlLTAxODcxOWZhZTVmOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmU3ZWEyZjctNGJl\nNS00MTYyLThkZWItNjMxMzgyODBhZjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElDicnSGiqe+pa/3n4TewOJpUfdXn6eKQl74UO8Q5V7A0Iw9/QwrkvPi+dV9s\nzygsS6yfTICtnksgZtN1M+hl1qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyGSNPd6cb95efYpnNcIia0crJNIwHwYDVR0j\nBBgwFoAUdo3n5SimADbi1CmVrHG90OrNkVgwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDSd57EYVmARqenNdRZ1vguwa6hKP0/OBt6+DmOtF+wPQIhANWq\nTzd7C+P4FGC0231jsVH2RB7dopR7BsERjMEF5AC/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATz2CTWfMzYygh1x5yjOJG3HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzk5NTFhMy1iOTc3LTQxMmQtODFkZS0wMTg3MTlmYWU1ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdhF/W9im4uV4+889TI6WAq2pWJZXn1tItScBr8RTaMiCu\nomGBX0Kvmy7phMJXaeqXnXTEYiYiiG+nhhpYmGP5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdo3n5SimADbi1CmVrHG90OrN\nkVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALkei9sBF3Z3v+VvwX1SIEtk06T+NDC6tirmsYG57+LzAiEAnEAq/Ig7\nqw4eDnq/NNw5vshOYfLTtoDSbycDaqxFozg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAT+QooAlEVtW2qbnm554yatQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmU3ZWEyZjctNGJlNS00MTYyLThkZWItNjMxMzgyODBhZjRhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDc3OTc3OTUtNTEzMy00\nNjIwLWJkMjYtZTFkMzZkOTY0MGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHkyCP4UgbZKcUSATy9hESqzsmZrXU1dD2HdUsBwB7FrnxKRmUeASpdLuvOGbn9mF\nifzZZXNV0FiExQg0nS9cPKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyGSNPd6cb95efYpn\nNcIia0crJNIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIEqxUXTLzOUU0Lp0le8z6h4lPTwjJdEZw5TQ/bCS0jLFAiEA\nj8m2Zc6qvn+kfOjOVgHM/AMIs8k4XG0aEuypAconr1o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8619", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8619` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISARv6cH0XEa1IjPU0sgENTd4UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJkMmVjMzc0LTkyZjItNDQ3OC04YzEzLTc5MDJkNjA1MDgyODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBkNGRiYTAtODk5\nMy00YTgyLWFmZGMtNmRlMjJkZDA5MWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcJZVqeNnNVAkDfR0b31LaDL068puhJo/x1Ykx1Arqa2iL7Q6KueyP5hDcK6G\nZbCk0FCpsvJkjtMBccUQFr9O56OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn8BSKb+XElaOpFrCKLTrCMqSFqUwHwYDVR0j\nBBgwFoAUTm9UFy7wE47VkTxPtuLFLuBbINgwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQDb8phtzJVGpKglXuFygct/rTy7OH98zUF0kKbsoqUqMwIgV3rW\nq892PmJ00Gygb/2NDQmoAtPjA22ZOgkxoGq5nH8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATgJJjWDJy+A6UzNwxIsuON+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZDJlYzM3NC05MmYyLTQ0NzgtOGMxMy03OTAyZDYwNTA4MjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtOJBq+hFcvgvm7NVkPla1i966PibnU2Gb1Ro3cyN+jP+z\nRQUliukKZ9LSiR7lzXCHpxEe8HoFTmqN/fChJaIto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTm9UFy7wE47VkTxPtuLFLuBb\nINgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALGr4S3WHehQ5ZVaOWpRZk49Zg3pGNgvL+/QQmryjg50AiBJzFCci709\ncDqiA3jVKq81YkrcKBzt0ABiuVRjYkpVgg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAYqxfOv0ZZTTg8y/QTkkkbVJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBkNGRiYTAtODk5My00YTgyLWFmZGMtNmRlMjJkZDA5MWNmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGFiZjcyZWMtMmZkOS00\nNDFiLWI4OTEtYjQxZjMyNjIzZjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nz6ONje37wArLetDE0TxAJCrP05U0ZEag5d3Tagov5JdUxEMUyGQILHbuoZ+hovzQ\njmfQ2VZ9EOCIaCy8Un4neKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUn8BSKb+XElaOpFrC\nKLTrCMqSFqUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCihWhvFBJ+T51YBVyy2xDcdo6d0OsFVw0lTtx39XYGtQIg\ndVCLAbsZWo9kePhityjAMAzAmEV/yHBkjd6c91lOXMg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8620", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8620` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAeE7NJsbtDJdkoK5sRiL86phMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyMDYxZDg2LTc4YWEtNDM2MC1iOTlhLTUyNTJkMDUzYzMxMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjU5Nzc4NDUtYTlm\nZC00MGE2LWEzZGMtMjk2ZDJiNDc0ZDIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEjksVcdiVlN15bTFv5xhhsV7Xb4pXzVIARNBtjJTqORQYYEDipwDPjHikPsj\nyrLDFjUJVX80/uY6Hs9iF9n/hKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ981jFiky6BZer+kSsbGEBl5GLkTAfBgNVHSME\nGDAWgBRdO39H+thQ7VX17NngjvhioIWzuzAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIARjXVmUWuZbDYWo7wO/35hVhTrNiI5W\n+W0ECOwCskxkAiBFtDw+0MPnwSrHvaSbx6KCz3XpYhIN549IVtXAPrkHPg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcLvpC3+3xMzCHOXTXcPwr6PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjA2MWQ4Ni03OGFhLTQzNjAtYjk5YS01MjUyZDA1M2MzMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQI9zZP6DegZWq2v+35MupMAt/uNK+/tEdS1twGSL2PCtBg\n9/rtjNnLWvhe9r+ul1wwLnSl+kppYhmV8/QJpKMto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXTt/R/rYUO1V9ezZ4I74YqCF\ns7swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEkBktvJpgLIxbKgam/lOKRSr7wKxRC22wYuGmKYH8EoCIQCmUrnvVBum\nuS1OigQRMtfJ798zNKCHvb+2sq6FGJPqaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQMcXHj/KpmUvm6/cCykuIjQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjU5Nzc4NDUtYTlmZC00MGE2LWEzZGMtMjk2ZDJiNDc0ZDIyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2IyMmVlNTktNmE1ZC00\nNzAxLTgxZjctZWMzZTU4YWNiNGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOTK7V95tePgMyJ65KF8WR4QPmB8c2hcyyMHJcU1/vK7HaWONkR3ziA6cHcCaGz2w\nT38yY2T3ZlcmPeXpjWXtRKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPfNYxYpMugWXq/pE\nrGxhAZeRi5EwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIFyXEZhqGl2yAxFEyPcSSTSh2Kr+WdRTjzqfZfC8c1LzAiEA\nsiyu8lhUInq26PxaI7dMoPp9W7AVB4O6x0KynTsdOmY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8621", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8621` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAe2gAwIBAgISAaAWsn3BmiDnaiHgSB5gHcaHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkNTIwMWYwLWE3NWUtNDY2NC04ZjRhLWMwNzIwNjA3MTIzNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA5OWMyMmEtZjQ4\nOC00YTMzLTg4YWQtMDg2NTk5NGYxYzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHnN8qXGvvf70ZreR/zpqGWddxqAcHGGHnzZfK/ZnqsPs5SJV8bLQbsck/FwD\nZX0Iny32LTWdFbt0vX6TvzbAi6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBRE2Op2OASR0i8kY+XslVoBm2ecwHwYDVR0j\nBBgwFoAUa/G8dJwqK28wgRSz9AqDmk+hgyowKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIHQab/YVLkmb\nNqQHtcESOhusjn6THhUh7flKsLFP76KsAiAvoFA8dq4whKVLcx66rCNJ5Pxzi/U7\nkGC0J7imuhxapA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV3cQ0IPyc8l1tp4PIYzw7TGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDUyMDFmMC1hNzVlLTQ2NjQtOGY0YS1jMDcyMDYwNzEyMzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXBhRGrQ0bEsogogNsm8kOHl1z3xKHM8tBaxyFy1VTyQuH\nB9urGP35A8+dQP6r1yT8RXVYqHPBdLwAfITsY5ejo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa/G8dJwqK28wgRSz9AqDmk+h\ngyowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS/zzgj9EQN+Fqd+OV3ML3RoerX7oWO0msE0I1sKAmMYCIQCC8swZ1G6q\n4R+KAPcUTRkdN2g2fNZiM6GZs2SH5yTnrA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAR9W1wIIBgw9eeKd7YxXYIG8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA5OWMyMmEtZjQ4OC00YTMzLTg4YWQtMDg2NTk5NGYxYzZjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGQ5NDliZjEtMGFlOS00\nMDY1LTgxMTItNGY1NjQwYmI4OGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmjyh6ERrJnuD1My3YQY1jIvPfTiX8hedSp1MO/OT2pbaV1pOe5iHXWyUvRNBjFoB\n4EwsBo2AEIAatqTR8H90Q6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBRE2Op2OASR0i8kY\n+XslVoBm2ecwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDDkhWef9RI9IAMxloA2FvAbCN0gTsnbIcHuP+WIaa+BQIh\nAPcIeH48ztGznOHQoxWa7wQEzlu8a1IML2UVTU01ZO4n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8622", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8622` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAXyv0WLlbsE6DZw2q8rGrxtZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmYzliYzlkLTFmYjEtNDhjZS05OTczLWNjODEwYjViNjc2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjczMWQ0NGUtMWQz\nNC00ZDU5LWEyYjQtNTNjYmE1NGMxOGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQlV/ppHfAjPv/unQubI/gkjgoWetFI3LI2+wCKrSEE389wfVuAzI+N+12OBp\nQomARXy+3IGV2Rq+T3hWlPLqnaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+Y+Pj4mqBZ+sosgvOdXnuRtLo58wHwYDVR0j\nBBgwFoAUrqAHW6GY7DsaSY4Z5ruw8Q2DAeYwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCLrvhIM2or\nCE+LYUtsrPdr+QNkZCY19wZjIGAfjjYJugIgJhwfiNbPjfoJeLk3fOTMpndWA6PL\nUomwcUdECu/Kon0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUd5TMCMHUx792kHeW+Av9K9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmM5YmM5ZC0xZmIxLTQ4Y2UtOTk3My1jYzgxMGI1YjY3NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATijGcIK7aR28diZx2xBQp53slaoP63mw5eIjw7o6TY3TeW\nUYfA9HSgRr77d1CsaF2TsxVhYOEWQ0qWyUiZ8Gimo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrqAHW6GY7DsaSY4Z5ruw8Q2D\nAeYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGE3hxfHeDtXuwtYzooq2mq3Jn/7Ho8PwEdfhVh01P6YCIQC0dXiLmfnj\nju8wNbK7aRUzN9ed/Sy+SICqZRQcCrVQfQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAeqfo2pmVpsc1ean4kzaXOHhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjczMWQ0NGUtMWQzNC00ZDU5LWEyYjQtNTNjYmE1NGMxOGMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzM5OTBlYTEtYjRlYy00\nY2E4LTkyNDYtZGIyMDU2MGU4MWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njQpZSD+Rp3dxPQfR093gfW7PsOWzEPjTiebYMLC0i+JBxghoxuxGcAuSjKsH/g0s\nQ3GA9N+yxn7wggaQ85hrD6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+Y+Pj4mqBZ+sosgv\nOdXnuRtLo58wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDl3eurwczs8Na4TrG4v5CsxMFtbLWDxXGYWt68FLKLIQIg\nE+V4rivSBj4JZvCQsPyw3cr90N9ttgMtRMjRSDWcY4c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8623", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8623` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAbgtwGT3i/MW5do8idEJHtmtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5MjVmZmFiLTUyNTYtNDc1NS1iMjk3LThkZWIyMDgwNzhhZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWMwNzI3MjMtNmVk\nOC00MWM0LTg4YTgtNWM2NzhhOGM1OGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo5/H69qp8LMqNAuUBnKHNAtljx/1rntIHGs3BCLqF4LG6yfPQl1vt9MEnkLK\n5YLVGjsanlMJaETZchdHk/EEcqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPNY4oQ9jte1wL+GSkvYciFF1nrUwHwYDVR0j\nBBgwFoAU6wNM96l/GQ2/NretBpzNEd5dDB0wKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBNCayLgLmo\nQh/9Y7BBmNI0TSUuJrEBBvT0P5eX6MRENwIhAM9wGND6UHLTGu88RUOkI0sFLi56\n9HuBzFqKzffsBVBo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWY8Ggh53FZrRXFTnLGBkCHVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTI1ZmZhYi01MjU2LTQ3NTUtYjI5Ny04ZGViMjA4MDc4YWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8WJvyjC58/DYCgUtShU6ceNoR+fuzaFQ47jT5P9xRDjfo\nZJDl5NEGumdzbBXXhr3havWG6WkOsIrxwoeqwD/io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6wNM96l/GQ2/NretBpzNEd5d\nDB0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMJysCMMhAWdh8DlAoNKl/WmmcFr2GFx53nej9p/EVEwCIDbr2I8NoapG\nS/l4iuDEbcuo2ppdm8ISjCqyGs/zz2Vn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAUMNqlYcLmzwu9BV7VfSbHA4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWMwNzI3MjMtNmVkOC00MWM0LTg4YTgtNWM2NzhhOGM1OGMwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjYyN2M4YmQtMjI0Ni00\nYWEyLWE4YjMtYTRhMjJkZWE4NzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsgPMFwjaOCN2cQ3ORV/EbIoJUwJnGmxSs3j5JqhlbIdVs8dRS7YzdC0BHaLYXEJo\nJ0KK3Gkfsce879RdNoq4a6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPNY4oQ9jte1wL+GS\nkvYciFF1nrUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCgCo0LXZV0sXJ4fufupNE7I/SZ4zkIfYkqzF2KFIay8AIh\nAMkVmFxYGYZnzJVdz3wBV5KRDaQjzw9UlUiUhS4CkR7i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8624", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8624` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAe6xGwT3epLa+B2yihlBKRnaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5NzE3N2Y5LTJlZTktNGQyMy1iYTZlLTdhMWZmY2NiMGJjZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmMxNjdiMDYtZDZm\nOC00M2U5LWFiMWMtNjEzZTllNGM2MWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9ZCxsyQbVU64KFlaYj+glYBYoCejDZQxKi55YevIk6vsFlzj2rkMsLUAEB/p\npnAKQ0c1NdBe4/gCNnej0o6/kKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrA3BDGJIRhYlyxlCbwikySmFEHQwHwYDVR0j\nBBgwFoAUjAE1ChpAiL8qd7JPRmRd6R2IpR8wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiEAkGiRV3VPQYB5cNJhwFz7k/LR8ipOeKKQrn3dHTXCkfQCIAn1DeGkgp8R\nlttHLXhYQ4VLxkQ67KKb16oVpEoRf3Kf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU54mtGDs4wR7nVHGUzWv++NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTcxNzdmOS0yZWU5LTRkMjMtYmE2ZS03YTFmZmNjYjBiY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1+Vaw8XGs3++RWznFKF+TTgWkmfbT6bLvms6pBmIfwhYy\nywQ1WyonVAQaedZBBINo+iqJjutWX94s83rA4RWko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjAE1ChpAiL8qd7JPRmRd6R2I\npR8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKkJnVV5F4AT23fu+TRIiy4o/WJpMP+WrUCyBXKWM/QdAiEAhgvJyZXw\nIcRjeLQ3zMgvQkGjJVFTqqPuHVj0lltSHuw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAaKsOYxpJi/WEhk9WzTg3hBuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmMxNjdiMDYtZDZmOC00M2U5LWFiMWMtNjEzZTllNGM2MWE0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDQzMDEyNTgtNTg0YS00\nNzY2LWI3N2MtN2UwYzZlYWJlN2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrJSqM8AAQeQ02nHSVfL9nEnou4BKR0U8afXaAT1d1o3KKDD2FcVfz9uqmUlZKE6o\nU0Ff0D88Ksv/8c+/ykR2XaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrA3BDGJIRhYlyxlC\nbwikySmFEHQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCICQ88ZnGiDLpo7g+rqnW1vDH3vPaoXsPlYxn+VTXjMQAAiEA\nn83gBv5L5Yn6eHZ/rZFrP+hyWTzi7LBeo8y8gMNgfyU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8625", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8625` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISASUu8iPOgsTpk8caFSPJo4d7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZWM2NGE1LWNhNDktNGJmZS1hODllLTVmNmY1NmFiMzgyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNlMTczYzktNTBh\nMi00MWZjLWE3MDgtZjI5NDViNmMwM2UwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO559CC25SAJOytKLtfXYJz8/SHemTvgNOWbKSvcIKwB+iDcu45W9o7AGH6mf\nztpzcgh6Xi4z2yRGYPbWpbe8GqOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU32n4G+QBLhXZFRWPBU/P71luLZEwHwYDVR0j\nBBgwFoAURlG6wofnXUBCRtMwJtqq3Q3VlYgwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAxSd11QXdaWBYibRstpbdHeVbwdvgyvMEqPKpC9PWlnYCIQCQGnf9FAZT\nZ//gmcjTMOs8/45GgD00hQPwqncf4YgpaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUBYMumfbIMW4FwxEHmvKFivMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGVjNjRhNS1jYTQ5LTRiZmUtYTg5ZS01ZjZmNTZhYjM4MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiXry9MEl+mSAHsMhGY2aXj8kLf+rpoRHIfvkVWfCkA06l\n5YzCXEiYqVj2cK6tp9HVKy+VhJFTE9hiqVrVEoZGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURlG6wofnXUBCRtMwJtqq3Q3V\nlYgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAcL+omLhzzx2TZ6BmdJ36OHWl7UeEldNDGziEDyn9JgCIE5WAQRS6+du\n5xggj+eSyx7o80eZhhY9oF4iJG7mZ88b\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISASZSQbBgQCtuMz1786IJozZUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNlMTczYzktNTBhMi00MWZjLWE3MDgtZjI5NDViNmMwM2UwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjllODAzYzctYTY0Ni00\nZjRhLWJjMzQtZTY4ODE2YjZkMjhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nULob3PMYk8Ys2Cjl1kv6dITm3Q7zwwxEQbYhOLFg4wlzgOlppXV1e/6GyER08gbe\ne17sv+n0xaUReIDTCfVvRqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU32n4G+QBLhXZFRWP\nBU/P71luLZEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDffZWGXu+F4vtRh//rpNKFEZ6rw/Ido4Bgmg2o/v5MxgIh\nALM0rRg1nxJ+knD3BHL80yaZX2ycO+RSlRbLybLdXJB0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8626", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8626` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAWKSCCoossG3zinrQC47xH8hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxY2M1M2ExLTE0MTYtNGU5NS1iMTJlLWZiOGY2YzNmNmFmMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU5ZjBjYTEtMjUz\nMS00MThmLWExNTQtNzc2NjdjY2UyOTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeD+mq4T6MA2eGW+8Wvjyj/DuKYa3nhs2XiGBLLSZmq9dw3wIQZ1fxxKYIolc\nC3NF34F13OOH98nX6ivqdVvnC6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY0EGiJMuXLI47mwCEMG1p9Q/wv8wHwYDVR0j\nBBgwFoAUGFklrH52J1h+riV5lEgu1c1Lr3MwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiA2\nld2lvK+ihZSOdoquH3fA1FgjQ2A3KB0WMi1lKw70HAIhAOoj5ssQXLhX958bmm67\nzAOHMEpMiG84DgfTJhWNJmn5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVL/PwycPG2cJr8RSGV2t6/KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWNjNTNhMS0xNDE2LTRlOTUtYjEyZS1mYjhmNmMzZjZhZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQw/nR4F8xJcq9GcyJyLt2VJcq8hDx3A8+bnmotaDZJPPL0\nCfHxIgm3+cSOtH0iLbFf2V9rpKozVI5xPFb7Rqabo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGFklrH52J1h+riV5lEgu1c1L\nr3MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBthwbyzS1y9msQ2Mpa/qT0ICh1Ivz8kzoSFPEHFXPxQCIE80JkaIoCpW\n1TkR8XuUpRyrfWgEmKN0yY4eotUJ9cgz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZElRRbzTh8lC5vhcBY++TxAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU5ZjBjYTEtMjUzMS00MThmLWExNTQtNzc2NjdjY2UyOTNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzMzMWY4ZmUtOWY3YS00\nMDFlLWI0NzgtYTIyODhhMjI0MDdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nN+kp5I8r5aAOCI9wyNV8cf0VsUVSKD4hOLUaHt2W+gUT0GYhMVRFlmZ2Wovm7l5W\nZpz1wVkNy6WgY3kkHIjG56N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUY0EGiJMuXLI47mwC\nEMG1p9Q/wv8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDncTXVWfdHe9Z6r9blZs8H/XDeW03kGpOKSaFTU+PxwgIg\ndSh9cfxRdNhudI9OMu34p5uqGVMYXw0m/wHdYccurFc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8627", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8627` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAf9Y5Z/s3JX117VK9x01H1YrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiNmE2NzRjLTg3NjYtNDExNC04ZTM5LWNkZWQ4NDdlZjhiMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDNiNzNmYWYtYmE0\nMC00Y2IyLWE5MzYtYTk5YWE2YTI0N2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJH5vgrJOFwHUdZk5jauPrL5kxxdHaR+eRkgchm+6o14xNjGAQ3MnZx2hgGhf\nDIEYwr0f4NW1/MfOU48pHtIj5KOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWMMqqa/Nu//tfkG5I5Ls11VVc+gwHwYDVR0j\nBBgwFoAUjV6FiV4deC8wUH2zRWgZIJ8VtiQwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNIADBFAiEA8DZyjuPuERv9gOdWIBcMjXFlVSg4JW2cj3xRHhKcMMgCIDjV\nMzk5na5mmOTM6t0L7Aau6ZVNHFisddeS9J+v8tO2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQbFn3Zpg8QwBqWWIKoOk+XUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjZhNjc0Yy04NzY2LTQxMTQtOGUzOS1jZGVkODQ3ZWY4YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdzHtMm2geHN9TY6ZvJn/JkFAYCRlZmYdCpx7qYVJPKp6f\nkKoNlTpnbYfeT+MFaIAgX1K0LiXvwOqxa2dYqbcio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjV6FiV4deC8wUH2zRWgZIJ8V\ntiQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH5i4zfn0G8yuYNuZYaVYPdf1vY1Zt6dKv7Pd7jnZk50CIDxX9bwyRBYm\nT0qtAYc46txQ8YN37kabSkW4JLl5FKOz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAfEiRq2OmsdshmQr7RcEYXMYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDNiNzNmYWYtYmE0MC00Y2IyLWE5MzYtYTk5YWE2YTI0N2MxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWZkZDdiMGItY2Q5OC00\nZjQyLTg5N2UtZGE1MmQxZmFlYmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nO1UvaRCkT2fV6uC7PXei8N4xJTeocojQc8r+LiMK1YBCwaF7ZMHYkmyYP2J0dqB6\nGtfT955a1RRoQJrmBIVodqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWMMqqa/Nu//tfkG5\nI5Ls11VVc+gwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIDNV8HRX9Ben2yGMARhHylukew592E0EJz80zEtFkhDWAiAs\nVbTMj7Vf0s1HW0vVxtl26gJV7O3Mb/RdKdnChrwbNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8628", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8628` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZlOS0vmTMLo/fGBShIG9hkqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExNTRkZjU5LTNmZGQtNDM4MS04ZGNhLWU1YjkxNjQwMzJjYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA2ZmYyNDMtNWE3\nYS00MWIwLTk4NmItMTExNjQ2ODNlOGQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3G5AbMZENVLpHqSoRGyE4OhoCdvvpTPRvmC3P+Bzrc5ie8xUyM74HOf6yTwZ\nkYahvKWfzfF0vW2JmjFYMkMhaaOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp+2fhHVdcdbPotmrFZhAyRqrETswHwYDVR0j\nBBgwFoAUFXLf/cD5e2zmTl0DfnQOLzyIfDkwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBZFtE2FIqDN4QVW6Hug12eucxxhhdAJgLQnR5ZyGORNAIhAKoT\nYTp6ozMo8ik+Q3nu+3jLSh3+KUxh89UMJdkya0ay\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUEdwzER39lqmmDNh8Qc/sleMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTU0ZGY1OS0zZmRkLTQzODEtOGRjYS1lNWI5MTY0MDMyY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARAtrmIabP2fSzMYRuv6/QX9MnymuSc2lccW6ayPsmPHlCX\nyyRCTbkv7BIXxathYUE88gaGtP/Iil5vW9cr3fy/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFXLf/cD5e2zmTl0DfnQOLzyI\nfDkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgapx3ZXgGd0kIpshaxVZXnQUANUjC67UTGR5QRt4oq1MCIQDGJVekCAXV\nP9iVTDtpQU9Y+ig1iixJNkwE7byKguil/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAYM2OD90vMv2gG9jxB38gpwfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA2ZmYyNDMtNWE3YS00MWIwLTk4NmItMTExNjQ2ODNlOGQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGYyNDZlYjUtODg1Ny00\nMWIzLWIwOWEtODJmNTU4MjM1YmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGG7pDnw9RVHZMr8APGDhajDCN1QtEsNXIFO1XW6PXdgHeGx280WGwMhIwvZQcPJj\nVzgkwqFZ0G6F1s0Qjjr3rKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUp+2fhHVdcdbPotmr\nFZhAyRqrETswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCSkFgUN7CpQO8pMJ00XKHAocunP/jy4GnDooRBeJ78oAIh\nAOHQAU4AsuAf7MgFng23rpYofA+n94DFR4al3uwekt7k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8629", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8629` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAYqgof+qFBKeov/6TI01rO2UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjY2M2ZGYyLWY1M2UtNDk1MC1hOWY3LWQ5ZGI2ZGExMGY2NjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTdhYmMyMmEtOTc3\nMC00MGQ1LTg3ZDMtNjcxNzc2M2QyYTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErFtIWShU5jeVAOhi9nHWKda8W1TqhjuexSkTXNHt00maiorjYwduVCpBOniq\ndEgyuSM/GzTYQTN1oFhrdE9VxqOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZYzAURhkGqGlWKLDnQQjInDdIdUwHwYDVR0j\nBBgwFoAU1fwUpQYuOfJRK+jDljmlsZDLAzAwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiAmTIecNjmWC7Ji\niZk1pf/toueGtrB0cYtaVmtvN/UEhgIgV++QK0xj7l+1yxqg/OEdIpZdTZMSO7Ma\n2nAMqusTRy0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVA+anyEtOJFbKZRkGomI/CmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2NjNmRmMi1mNTNlLTQ5NTAtYTlmNy1kOWRiNmRhMTBmNjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIvAYgUQwHhTlo4CJce22Redbv/DiG+QrjBainSp0zR/l5\njUMfvNDoH5YH+tg7JEOrjSfg6Ao6N/Faq2n7tggqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1fwUpQYuOfJRK+jDljmlsZDL\nAzAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJm6MppcbdEBcVW4xY4c16GDLGYOHWVKeelAHDC/TV18CIA33JOo4Qf9G\nUo4g8DWCeWGSm2IGC+o9VZzdm6tDTD/E\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISARW9xnnxv4+dKZB6EbIp0K+RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTdhYmMyMmEtOTc3MC00MGQ1LTg3ZDMtNjcxNzc2M2QyYTAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGJhODg0ZGYtYTAwOC00\nYzdjLWI5ZDYtYWYzYjY0MzgwMDg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMne7eJhxro9ZENNTwt6X6QQZwPzCQInIyoyGOUTPHbwLo6fM3IBnT0ry17i3/tji\nPST7tp+NmKTtGTv2jaV7vKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUZYzAURhkGqGlWKLD\nnQQjInDdIdUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCiYn75WLCH3a+0i1dA3Z45GLPfrp0PNPI2xIVRbe+zpgIg\nBY0glbc51FKqNcjxG/HyO44NIZTUvAxQ4EvzCHyfBUY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8630", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8630` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAUSbwyU3LQlt2t75Qo5iDgz1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2MzNjZjZjLTg5MjYtNGRhNy1iNDJjLTYwYzA0ZTA1N2FiOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDY1YmFkZmItMjI3\nZS00M2QyLTgyZDctYzcxOWUwNmYxNTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8rDD9mTAklF+BdedSvAnCD68zBZ9jcwwUrK+F8QjcRqiKQfuE4MEEzjMyIcX\nfDcO8ZxV+Y1tWdtBxFk+bYmZJKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc7kZS5t5AWtc+fIAMVSQ4CN085swHwYDVR0j\nBBgwFoAUglENxtFsEi7XcgDxlLA1udr57EwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIB/2Pfyk38hR9w1jELZPuZmtg6FXjT3xUsUMfaYfpNjqAiEAgrsLn20SJPe/\nOVZ4C3Q3dTzh2aTjNxJMn5GUwBtylOA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATfdv7N/SSNdDWAccersXabAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjMzY2Y2Yy04OTI2LTRkYTctYjQyYy02MGMwNGUwNTdhYjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqAQSuZ0hsFHR6B9QreoFQb+HcrxGdko8XCHuDmBUdFeLs\na4Wl6EfMcLpKme81LiJtVkR59lmPk14SY0/pMS1ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUglENxtFsEi7XcgDxlLA1udr5\n7EwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLByyD8knVn+0afs31yFumU0H7+fQXKcmaRKqPzkQP9MCIQCF0JJpH/pO\nq+WKPnsIwyAEnjNzfmNZ7rHRtPY6qIAxqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAY7ZuPqGrgeJahVbQsqc8vTCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDY1YmFkZmItMjI3ZS00M2QyLTgyZDctYzcxOWUwNmYxNTAwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWNiYzY3ZTItZTU4MS00\nMDFkLWE0ZTUtY2U4MmU5NjUwNzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nx6Wo5SUxzAiTPAsE09zzkEtd/NIxquleVbFGQ3VKpSYouN8MRN2ZoscXO+znCVCz\nfKUCvZJVFQGv8Suz+p1kgqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUc7kZS5t5AWtc+fIA\nMVSQ4CN085swIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCbeA6GtiC4inNXrKVjX6AozaOkvSwcc12SQbW5QQVgewIh\nAJ1jEk63DK6O1dg1Xc1zrbBgCiy6AY5c4mlGc2cbKOJa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8631", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8631` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfmgAwIBAgISAaQkU9wV10nBx385hyj/i3e/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4YjVkZDYyLTEzY2ItNGZhOC1hZTBiLTQwZDRiMzMzZTM4MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM4OWE2NTEtNjVm\nMy00MTg2LWEwMmYtZDMwNjBiZmY5MGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExvJoI5WrJWJXfh1GBViAj+evppVy3r66h+202TWY+0tGNsDUYkV/anwCp1hX\nh/HUp/g5mSrOd/X2TZhhAk4CHqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpE+6Ai8Rqwb+03pg17jvYxrYvEUwHwYDVR0j\nBBgwFoAUGeN+/x8fNGsuvfqTKqqXtUoOHmswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kA\nMEYCIQCrq77IHJaQi1WTZ6ohQjLOsMCb2jJgLHsIOQ1la/ouugIhAJezKjJAiDh0\nH1cp+Vqw+wBJCojITPqWyylKt0ZfXmjT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAepDD061Fl/VLcPZLkbMm3llMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOGI1ZGQ2Mi0xM2NiLTRmYTgtYWUwYi00MGQ0YjMzM2UzODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdWlO3rbnkVNGICgkAezC14AOmhz3y6kwOfenwTRhZ0lnm\n3DcQYsEEIwZkom2U6VD/gdNk32Cy66jB1uITdfbmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGeN+/x8fNGsuvfqTKqqXtUoO\nHmswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANNOvQ6O9bF9Ga/1RC5kgKALLeSJVqX/Ev+L6CSePLdOAiEA+xMoW/xB\nLSvUCjaHzlTFwf9KPcFsO6JLPhCUdQhxKHI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAVaW14nGkRQgtj/zY7W+Ea7nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM4OWE2NTEtNjVmMy00MTg2LWEwMmYtZDMwNjBiZmY5MGU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTM5ZTE3MmEtNmQ3MS00\nZWMzLWI0NjktZjc1YTc1NjM1Y2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\njT468a2+Bl8Y8MI3R6P7XTpndS0UsavLVZZo2+YdHjijw3NxslhM8PRFmUQo1D/k\nYbg1VTSsmMJ9UYRhG+49cKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUpE+6Ai8Rqwb+03pg\n17jvYxrYvEUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCqROm16Dus2XFUsyciXCnsTZrgMWC77qE02xzkblmVAgIh\nANoexq/d0S5UBnlAmO97zwTjQ0y2/nWyyr6vW7mjZ8m4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8632", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8632` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAbT4jpTZAh40Itipsyirr9+PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiMWQ5MDQxLTc0NmQtNDNmZS05MTA0LWU4Y2ZmNjM4ZWMyMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM4MzgyMmEtZjY5\nNS00ZWViLThiZWEtNWJiYjU5NWE3MjBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGhV/4hOBRoue8YDzJY7ofxRwOwN92iXq8qtx+C0VnH2L9KBhcI2HrCFo4Ump\n+tecmP1Y6Ja+/bDyJxK2dbu0paOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYBpkJt6jFHBiJ2dRcJnuoPEgRAEwHwYDVR0j\nBBgwFoAUPbx7+AqOkKWav6AuOPltT2JxQ18wNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEAicsyVenC/7L+994aF72+hoZ9fbLDYzj8clYu/+44q+YCIQCfNu3Htj26\nsi8voAxD1seWAeBiRaZsbwYBm5ej+pXROQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXPHgY8DYUT34kgZC8HSluzFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjFkOTA0MS03NDZkLTQzZmUtOTEwNC1lOGNmZjYzOGVjMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0n/cuQUMALzwIU18RS1oIruOxjEjasOnm7334XcGHITar\n9BJvOeCfFtyyMnzj8k0tF8C5gKOZdJuqoLK6O2TYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPbx7+AqOkKWav6AuOPltT2Jx\nQ18wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCey6/trTucIlXUE0pgA8nA5/fYHwVtCt+Qj2neBHuB8CIF4w35yFVoTP\nUOp1qO3Zd3sWfjyrJW/9FXgNDwvyx4SH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAS2L5OOMtzraiG96lElcl+xTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM4MzgyMmEtZjY5NS00ZWViLThiZWEtNWJiYjU5NWE3MjBmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmJjNDU3ZWMtOGUyNy00\nYzA2LTg3YmYtNTU2YmEzZWI1ODM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nj4mJVPklA6WfwHAoL9hcrestqR7mhriqap9HfwendyJg3XBGKQZBvwq/pM5GdvY6\nohHN9WV3NBv5G3jmMUeMw6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYBpkJt6jFHBiJ2dR\ncJnuoPEgRAEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIDWfkgdE/lTKsV5zT3CAT+WDNEkt5shbCTVc8K1LGeFWAiBW\nlpqa+4SwXQxicDf6n5XSyqd5nnxfHnr1u8KH4TEwag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8633", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8633` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAS1bb6f1n/P75rGHzTUXdGQlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4ZTIyYTg3LTY0NWUtNGVjMS1iYzEzLWM5MWQ3YTA2NDIzZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQzNjcyOGMtNTVj\nNS00MDdlLTk0NTYtYTk3YzYwZmE4YmM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETU17LhxPXSOk52IsQovQOEpI+T2nUVk69IXdM0/4qsXBK/8wm9K6ibtLiDBH\nGJaq0Krtmv5GF818l8te/8ZozKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2RyvLW8xrVrm2T/8gzWfwBjX4YAwHwYDVR0j\nBBgwFoAUXLan60qrEi1grcy0XWqjJD2f5DkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA9UEx4r2XojuOmHYwm0lkAoGHhcbzGswNZBub3moA\nxJICIEReM2OoXR3uDJkb+04S4ZiDgRi38/6aF7qWOfahgeep\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdaDS8W3w2SrUjBcfhkqiVOMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGUyMmE4Ny02NDVlLTRlYzEtYmMxMy1jOTFkN2EwNjQyM2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqiNIetAauPUd4+eD/Lofi/Up++WdjRoAJ0NzmuE2RfysL\nHW85s48aUBiMMhEvvF/Uy3bKa008zjvjCJieLUWbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXLan60qrEi1grcy0XWqjJD2f\n5DkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKT0lUP+802hEUwZRPHrPrXWEN41CfybUnfqvIUyQMrCAiEA/Wpniirb\nmrlwCen7ZQMofFN1BiT8fcbzkFHz9t8Rg9I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAQc7gQqWEesdPCHfNMnZCiUAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQzNjcyOGMtNTVjNS00MDdlLTk0NTYtYTk3YzYwZmE4YmM4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTYzMjI1MGItOTdhMC00\nNjU2LWJiNDktOGFhY2M5YWJkNzVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nk0vLxxEVXB1HqphnqpLwTRnTRlKAT6TzqKANd9AY4AnhGcaOGZVB00LJ2KwlIWKp\nbGYisYeQY6B2HwlJvNu84KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU2RyvLW8xrVrm2T/8\ngzWfwBjX4YAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIFKel44BvVZCykRcNNVNMwhUU3aDTdxbt2FBLa26+Ri0AiBf\nphHvHaGWOMs4VFyT4b1by/Q495adreXtYzD5kPD/vw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8634", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8634` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAYgRxO/Dbo1dkg9Jv23aBlFGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjZWMwMmU3LWNkMjItNDI2Yy04NTRiLTMwZGI3MmFkYmRjZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQzNjNlYWQtMWU0\nYy00NjFhLWFkYmQtMTIxYTdlNGExNGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEO4zBALwc1ees7BLG8rYf3JV2VFknrayNOY8hg+IdhLcGXj5BZsJhCRnD/n5\nE0nRWQDcv3fuzDLmogowh/UFJqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfpIPQ2pOeBdWhj/qD0Jmt4QQ6q8wHwYDVR0j\nBBgwFoAUxptddmYAPL02Efo2birSdusp/jgwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiAPbwVKVA5SpeDohYnY/aI5vvq1n/8ayT27uCXXOwXB\nkgIhANC3Mn0CmlHES9PE61wxa1yn9M55/zidcZsWnR9UVBU7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZd7b4hXNPpOZqFVqJgjir6KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2VjMDJlNy1jZDIyLTQyNmMtODU0Yi0zMGRiNzJhZGJkY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpqADBx4hxqACvhlpxvjPUBSKhyY3TFaJgfgJ9ENp/Akyd\n0U1ECYwAQjosCUIZEATo5g/I1vyg/jJnoDLVka5zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxptddmYAPL02Efo2birSdusp\n/jgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKtylkmFGUQtz5piz3ORMVgyecCMZvStk82jHoC0GrMrAiEAm95YkOHR\nwrUobTEJ02V9SCMt7VLlXGhPXWvWxm0v79E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAW/PDteA4US1sdGpB1MQ+cUeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQzNjNlYWQtMWU0Yy00NjFhLWFkYmQtMTIxYTdlNGExNGFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjRjMjIyMDctODI2NC00\nNTQ0LWE3OTAtMmIxNTY2YjFkMjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOO0Eduel2a2C4tPEu3/dV1am/ZCYCSPk0Cg6ilTdaOspdExrB0fDqLdJtDcvPLQE\nF8qAWt6Z9OH7TrKjsILJZaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfpIPQ2pOeBdWhj/q\nD0Jmt4QQ6q8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCWveXLUofGCmLnknNt+rxBhJtqZYfk17ejDNZ8P/SK8QIg\nc7HYNZFHgparMO0JCUKT+D63JrbOrpHobUrQl5/IfAY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8635", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8635` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAQsypJAj4+UtXAlIt/dSABSlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzMWYzYzY4LWU5ZTgtNGRmMC04MDhmLTIyM2RlZTRiZjBkMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjZmOTgyOWUtNzE0\nYS00ODRmLTgzYTYtNjU1ZjRmMWE5ZWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhGxzA/ZeDsK4dWBufdL6kSA49iDFR4dwlz/fH1TuYS0bzJ/Q54FXqJbTwgyf\nE2kZfSr839qdSRfALQGWf9O0aqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlTvA5jJZwTTKYuzCo7ofxO2BhiAwHwYDVR0j\nBBgwFoAU2vapG5rdYA6tlV5gcWikr8rAWK0wPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiBNYYasoPcR2Q7lzS7zwQFGrD+7eWjpPS0JiQJPzwoQMgIhAJ4e\n9bMjGDLZW1gpXeD4omVAckY1z96t9nVDe+Sn0Dv0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXH71J+3s1vRZ37Dpmfrn5d5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzFmM2M2OC1lOWU4LTRkZjAtODA4Zi0yMjNkZWU0YmYwZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJYGrPZhqUFPlZ4KHUOrm6TvTc6okeyonGF9t0Y8kIXOFl\nifIVMkHJmg22p7c+e5sh0kVdGq6ddf6SC2q+wwwSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2vapG5rdYA6tlV5gcWikr8rA\nWK0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANz9riSXO+TquTX+zt7fch1enIxg3HfDwx+trnEoEj8IAiEAoK3ao43z\nyQzSsqzvSIu3Yuaizr8CQAS+1t8qR6BHWfs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAX9OnZGok8OXEsQI+Svn6xiLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjZmOTgyOWUtNzE0YS00ODRmLTgzYTYtNjU1ZjRmMWE5ZWQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzhmZjU5MjktZTZlNi00\nOTg5LTkwZTYtMzk4ZDdhY2U0YzdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTsX5SET28UloLYelfaebNTrlsbQfBW/rV5xV0hWilBnFJ8Gjm6r2c2OBhcAxYiyE\nrhC37wb0Zrt4whCoTZwB2qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlTvA5jJZwTTKYuzC\no7ofxO2BhiAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCID42bi5RHDH9+Jh+5/lG4l6Z2msI25j39wYXyj4tepSLAiAP\nuTjejRLNALf/GjyOGxYX6RIS0VKGIlEH3KvEMEL6bg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8636", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8636` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAVoDV6BH7GW8Uigyc/L/FmJQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmZWU0MDViLTJlYjktNDVkYy1hZDM3LTg0YzVlYzA0YmFkOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGIwYTk2NmQtMmNi\nMC00MDRkLWIwMDMtYTUxNTk2N2MzNWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoFP7uuvmRSiUAXOM8TZ5XN3h0mc2OMxq1rgHJQvoxIpeiCu9hr/y90rI5yOy\nuTCeOP3O1zj3XjX4B2bAsnnxzaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrPX50vyqOHagbThPFcOx6FRITsowHwYDVR0j\nBBgwFoAUijx0sgVEvUD3NbkRJXn5dLap8SAwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAjD+bImgK88LiR2ev4cBIxSKiz0hY5bA+\nVOZMkBGGocYCIQDqqWz4OwrXXucFT0bJpNUgLiWVF9D2wQfClplLa8ngAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYFKK3SvzYx8DQrtkhp4KsoUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZmVlNDA1Yi0yZWI5LTQ1ZGMtYWQzNy04NGM1ZWMwNGJhZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTHmzl2aqTAtQ+mvxZ/6/gOeplCloIPPW9hFoqccjUsOAm\n0dEbqnNrEwEtmdHj8PgMmGa2LAXUrzBx6K8rgRU3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUijx0sgVEvUD3NbkRJXn5dLap\n8SAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIpCln6TSRBhOBJc1Jo0P8Kg5LhA2ni3SRZ56lSqs99oAiBmoV1w/h+0\nLBU4SAlwXhMSzC4mHYZV0YjhUDCsbJ228A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAX8oyLIpA0rtQDVnFRjXkQOUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGIwYTk2NmQtMmNiMC00MDRkLWIwMDMtYTUxNTk2N2MzNWMxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjdjOGVlNGUtOWRkYS00\nNTg4LWExNmEtNWI5ZGM3ZjMyMzJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuUcaCdlvntlk7V1R43oFDb0Fakna8uDwf1cP63yzhQwgX6E1ahzP/aqx1Kh+UfCv\nywLf1i6mramqu2I8Ox/p8qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUrPX50vyqOHagbThP\nFcOx6FRITsowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDTKjr+SW1RC4cjb5egKBt1wKZ2zEDU3yF0lF8IOTi7QAIg\nZfA39XYuqteb53bH4e8eKz7DUwoi3B1ns5R5SXddlBE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8637", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8637` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISASS1OyXt3yfTjp9thdHhUSyBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhM2ZkZDkwLTIzYjAtNDJkYS04Y2QyLTlhYjUxODcwNjhhNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZmYmNiMjAtMGU2\nZC00YWYwLTg5NjktMDM2ZTVkY2RmMzVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6UBOgblUMQRbjuYTkTPIyFiLDJhDl5L2VyWfyi8BleWLJ/g1ifyLnVQclvAc\nA+wi9/BvgfJJWoIxfqe0bzJ4JKOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPvD1VsD49sw/xjLbEomQhIBjZKUwHwYDVR0j\nBBgwFoAUz+IRwyIQpUUMMZ+ajOEjA+u29qMwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAbW2bBY6WdmRY8aGucKvHGDCAapFVMBJXS\n5DXWSwM4owIhAM30w/alBnAGq+ElTc/WqhRR6QSEagC+TLAAmAte2Wpu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdj9om5ysouTwIrexCX+pvdxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTNmZGQ5MC0yM2IwLTQyZGEtOGNkMi05YWI1MTg3MDY4YTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8z6NgiwMLVjQVcWBSVI8bGK2+W5R9dKQuTgsuviP1hIap\nUzh9b8D+lmvgur7tzPem6KUTX8D7h3aTf8hXYZR/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz+IRwyIQpUUMMZ+ajOEjA+u2\n9qMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALpoCmQewGvHhgLFKP40y/SO/y5Yl8G9zfpcPd/GLngeAiBajr9IaTby\nicDecjZAXGAEz4ndLT3hwcm1PcbOmNOi9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAaZ+mJU8BMsmxTIyHFvQDd/lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZmYmNiMjAtMGU2ZC00YWYwLTg5NjktMDM2ZTVkY2RmMzVhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTE5YzEyMzUtNTQzZi00\nZTc0LTg1ZWItYWU1OTUwZjI5ZjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nfqmEQXSJLdlgWFMQSf0a1W8Mvi9vhoMquN9hyPsZA+U78zQ+PzX9wWwsUXOuDkXq\nLFRg6ywDPH4etnqY8lWzAKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPvD1VsD49sw/xjLb\nEomQhIBjZKUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCGUdaOT/L/javKqGT3mv9MKm22lnb5emhn3xJj55h3oAIg\ncimL8jW1HkycYo97ckvnbDkUmogggk5AYCtk9Uo02JI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8638", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8638` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAZaCKfQEZu1XZF7Umul5LS+kMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzNjI1MGFkLTI0MjQtNGU0Yy05OWY0LWFkNzE0YWIxYmQyNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJlN2Y5OGMtMTEz\nZi00OGVjLWEzMDctZGVlYmVjZjhlMWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1H/2zApuOrAoY1qNhBP4K//VJkLqODGOfGJFmZRgFsbQvgj2G9jMGFmYRJP3\n4A72jsU9bwG1IoDU0/2mQNulY6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/CN/GxJp0HG7WNmZd/3+KYEwlY0wHwYDVR0j\nBBgwFoAUVVAeNQZhSRXbMKg1rpDWuT9VATIwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNHADBEAiAsdjSijoiA4he9\nroMj8I2n7L3iBSfPc9sRoW88Ico07wIgNEJGYZg4kDzVBQh/BHXKSMbuzAbQujuj\nZBfEhRfUsFM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa4WMcJcZbkgV+XPNfA4iazOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzYyNTBhZC0yNDI0LTRlNGMtOTlmNC1hZDcxNGFiMWJkMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR9eXimYWRW568E/K0Cw5acSOId4agtAchXc4/b5QLFT2R6\nRWNE1mqPmrT4e4SAc2DhFVtBzL8dG6kn4RN4O8sso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVVAeNQZhSRXbMKg1rpDWuT9V\nATIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMY7g6dcRc7PnouvbFKmnDsw8RW01ojbJG5938qQAVYiAiEA30guNp+K\n+tMqJ5DFHa4LjAxgNjuSC5fdwR5hfh/9yyg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAT4UwmxpLiqAT0zXWvY6Ck9gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJlN2Y5OGMtMTEzZi00OGVjLWEzMDctZGVlYmVjZjhlMWVmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTI2ZTg5YTMtNjM2My00\nNTRmLWFlYjctMTNhZTJiNTQ0MmU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxFjJOAHdCrg51Smb95s98vkoPCBbauJlGp/yYHc4xqIWUtDgycyI4dw4kEBkDGb7\n2QGuv7ARbuSuTIOTJ03kR6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/CN/GxJp0HG7WNmZ\nd/3+KYEwlY0wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIFS7/4RlCjz1xHtAI3ezcOScIcer7VW3cmrE2NAHylEWAiEA\n7vxLofN8malgmkiBjfnBSkGTDFw3QqDz2s6Q81qQwYo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8639", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8639` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAaoDcYq/qyRDJoRG9b6a7GN1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3OTY0ZTQ1LTNiMDctNDhiMy04NDFiLWQ2NDQ4ZWZjMTcyYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjllMmU4NGQtNmFj\nOC00ZjVhLWExODAtMzdiZGY1ZmI3YzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnY+H4A/PL6VV3HrEm8oKX7B4wZIcP7Q0jckMAKOZ49JzQpglHCvE12DZ3ZdD\nck8/i914mk3lfKhG9HMuEd+VEKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsH1e3Y5rI9Ic9ENUTlr7iB+Lgl8wHwYDVR0j\nBBgwFoAURlGeQsu3Mi5IJnZ5ieGopbUqYV0wNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQC0xTFXnXGilKcGT04BUc9Kh7sRlZokX8OxPg4rsU3LMQIgciJt3X/Oc0EI\n59maKR6NBdlEBe6nM77vaBzS3GYBPhQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdWTZcDEHAtad013pf0xdJKhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzk2NGU0NS0zYjA3LTQ4YjMtODQxYi1kNjQ0OGVmYzE3MmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0A6MPzZ7LHn673EvAsSctV6J3NvH5OGodb283eQ+ZD2mZ\n21WGJZ8Ig67IgnCsm/MA/UX5bPz9B91eKWHvicm2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURlGeQsu3Mi5IJnZ5ieGopbUq\nYV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIfRPIn5m1Z0i3obwu4LIUpS5X+Ag+I2Nw9bGX+MSuS1AiAD5xgHtdre\nFkkAc1XCft+b0wWcmMpD7mLbuar51adjPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAUHO2dzr13cXnoZtCrzwXU7zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjllMmU4NGQtNmFjOC00ZjVhLWExODAtMzdiZGY1ZmI3YzI2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDVjZmY5M2MtMDI0NC00\nMzBjLTkwNzYtNWUxNGFmZWE1NGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n54xnhC1hKQHHVoe1JDNTZLXKiMCZCDv1LCtAjcz7R6RNMhsSP9IxbFyOn+F1jiKm\nKhTX6fj9DB5a9MvqDw0OxKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsH1e3Y5rI9Ic9ENU\nTlr7iB+Lgl8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIHNy5yKdQJxASAuYviqgEOfhllt2DBqEipKe0W3Zobf5AiBc\nSq+ES5x6z/UT9EtinJhx4tuDkm6AlOv95Km9gvxQYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8640", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8640` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISARRE4sc8GhTOE8FUGgeDegskMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlYzU3MjE4LTFiZjMtNGUzYi1hNTRlLTQ0YWU5Y2RiZDA3ZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVlZjQwODYtYjk1\nNy00MTRjLWFhNGQtNDg1NjJmMjdkOTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuF7mxuajV4+zpm+d4I59CGogIFuwovGwFMgEhL1SR1FKtRpZfY6nFWANjrt/\n20HPUoipeJR/jW013+5r3s+J8aOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUImy7NoG2XAj0NMwLVj/61rbYH4UwHwYDVR0j\nBBgwFoAUpU3YU+4QIPhZll/Ob1RK//lFGaswNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDpd75KMlIZ/Ad6k8c+ELbfi6mHtG8a3pqxQ4ea21c1BAIgZRZ3QIkYP5Lb\ntY6wV399I7jg/q0YW3PcLpuM/nZlzY0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARagGU8dVa35JrICf3szsDGGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWM1NzIxOC0xYmYzLTRlM2ItYTU0ZS00NGFlOWNkYmQwN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrXNnXECRc+7eqwyf1Ql0QKbrjK5I9x2ktp36iUYDH36G4\n9G5HccPe+xmbnNGqrymBlYUN+t4oiNDhNBBNrdv9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpU3YU+4QIPhZll/Ob1RK//lF\nGaswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKPk2fBi6Ywhq+OzSsU76hx4OJGGXVKRtV/5I3ZANcoQAiEAqHQOyaJk\njx69km2IsXUMFoBlm/oyzOIt32WsLO7bzlE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAcA0u85y0RFuoPivyXiLckbMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVlZjQwODYtYjk1Ny00MTRjLWFhNGQtNDg1NjJmMjdkOTNhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjNjYWI4NmMtODEwZS00\nOTY4LTljNjQtZmJiMzk5YmJhMjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nk9NQ9d+lFnn/E3M7Ww/9TyM/HBfKN/uERcgSpRlQ8HCKU9zl6ILYVy0QQVbgr6TZ\nzUssywOeVgBbPYTb5qjnEaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUImy7NoG2XAj0NMwL\nVj/61rbYH4UwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDgWGK+zE0/ZbjyayFILyBDsUwniVlRA7Jgt0Cw9sg83QIg\nY/SenOvNH3RdO1EwzLUf8DbX/jCOwgjYqFBry5DYB8Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8641", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8641` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAZxg2lu7pyCA2eZ2uZ5fcSUoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzYzI5MWU3LTQ4ZDctNDY3OC1iZTk1LWUzM2M5Y2MwOWI3MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTUzMjhkNGMtOTVj\nMC00ODQxLTk5ODItNTcwODcyYTA1OWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWY5zFD5PJr+v69Luy8ChcmE9+15+V1EKS33wXLh0vemPTM8k1UdMucC6MXKo\nZk8M4UhJNHDIqHCTpvYNFjhei6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnWii2uoxVpEugds1hkjxNEOm/5UwHwYDVR0j\nBBgwFoAUtG9gts0HLXjFvNIdBkTWb6/TF1QwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJ\nADBGAiEA+1XLpDNGICxgaw+f9JQdWEaPuckd8vtCePEkp2GFaJACIQDRjTK2ijtz\nwgc736qyWc6tOE05NuqcU5NwK+8RkmvbMQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcHDyOtHumDLj6NBqOEAh6FqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2MyOTFlNy00OGQ3LTQ2NzgtYmU5NS1lMzNjOWNjMDliNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6urI9j7to7aaK2JWwJuYTH5neFnxGXdZrCPlTGsJHpnc3\ny5Wyk6JuVeF7hYVTcE8CjQnGAEAFaEAM/aJjlFT1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtG9gts0HLXjFvNIdBkTWb6/T\nF1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALQmTLqkQ0h4pCDlMf7DdvErr1L68ZjMJjPOwe1KI6MUAiEAyyzVk6Wi\nwMWsBYVzFzgtEoCLRovmq0xhE3Em5MGOvhI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAfllT3b2zLWlGra1rI12t+ZQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTUzMjhkNGMtOTVjMC00ODQxLTk5ODItNTcwODcyYTA1OWZhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWI4MGRmMWEtOThhOS00\nOTJhLWFhMmItNjBjYzRjMjBiODM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQVCB9tCs2vcxjDaSnGKnudvKrn5VyBLoN6psgj4swecIoox934VhC6M1iW3zpYVT\ngqpJwqQjalN8caaMws/EQKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnWii2uoxVpEugds1\nhkjxNEOm/5UwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCYXHUUo48sGqyzZ2aptU+IzzPDpAKSFDMisDZE9KD1pwIh\nANtkCb9HiRfpr2YxFAXAODYmfx8DfhPJu2OOtYm2NKcj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8642", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8642` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXzCCAgagAwIBAgISAURZEw2x8y7AWzF0qISQRLYDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1OWRjMmZiLWMxZGUtNGE4Mi1hMDRkLWU4MDNiYjA0NTA0MzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdhMzlhMGYtNjZh\nZC00NjQxLThkODItYzY0MjViMjc3MzVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqGk9/W2EuDlctksWXe4NGttnCc/VNsj3OrAHxIpB/bRjvEYDnoR5AuCeGhce\nOB5k6v/weR0wVlxb+7JQBlcKoKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfCLh9CbG1GGNjcV6QFz53xrcD3EwHwYDVR0j\nBBgwFoAUXXypRJmR0F22dp0h/fMphi8v0K8wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNHADBEAiAwCGME6TSvqtnhCcycdryPlMD1SIfvKu7YRC9M77j2\noAIgQNbTEkDi3cMVOPnIY1jPaTHwpu7a2jgFijRHYYmIVa4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVpMHPgpqbntej3LS5NaFHkQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTlkYzJmYi1jMWRlLTRhODItYTA0ZC1lODAzYmIwNDUwNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiUcLyxF+CWVUQd4r8QkAQ58DP6h2ke9A2Fld7CamBep/N\nlM+/CwQEMfyVPWiX2ZVPHxx5BL+XSPSgObgGqsamo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXXypRJmR0F22dp0h/fMphi8v\n0K8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANsEz1PkB1MbRhDpPnGYZIzNbXaj96fQdkLYBP+24bypAiAfpO7ytpXl\ncstdhkG4mekfyKaeS/sjcMKcH5JTMUHvxw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAeG6TahOysctppE5JGTJtGIoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdhMzlhMGYtNjZhZC00NjQxLThkODItYzY0MjViMjc3MzVkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWVkMjczYmUtYmMzYi00\nNWIyLWJiOTMtYTNlODc2ZTU2MWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nq3wR13jBlOqnBf1ZhWPd0Qkq+Svr915QpBTjTJ1GVxBhfARdmFyI8nbMX4WsTzJ8\nB9d+tLLp/zzZb+vub7ZxC6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfCLh9CbG1GGNjcV6\nQFz53xrcD3EwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIAYHi4pAQy0CfYeQ59qUv+nGQ2i075axJauSOlsGzUVMAiEA\nrlCaNTWhGQn45R8LUIG/KH0O1QkJV96Op++mtB9vZJE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8643", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8643` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAcdBEAOiBlCx8RGlA4SP6dtkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzNTQ1ZDRkLWRjNjYtNDIwMy05MDMxLWY0NzcyMzYxMmIwMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTM4ZTQxYWEtODRm\nOS00YWZiLTk4NGYtZTEwMGNkYzY0NmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECcZCSLfQ2/smo7ut3qbxsqRtR94FADktULNFEZi6qzbxG2A/LE/PPJuBRZnE\nn6vPAUJX3eLf9FXi86xBhM3Bl6OBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU20MQZ0nVO6M05I6JRWb8a0OYragwHwYDVR0j\nBBgwFoAUXRSOtDPvrxcKposSRX/6rwKqe88wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEAry2eXnJFNikN8SXp2wuDyFc2rZ3UX3nCs1N77e8A\nsLACIQDJhN/wbqox7jLwLkHJ/04SchOCSNwT3wuoajSfJcwxVg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb09m0DjlvOgjpuLR5zA3dnAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzU0NWQ0ZC1kYzY2LTQyMDMtOTAzMS1mNDc3MjM2MTJiMDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzTmhMCQ04q0soBve8f1R60D11KdacXCcD+4vfG3qdhCzt\nKZnHqmPaiQ4v2sTFSENcta/OC39gqTlQXxHX53Wio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXRSOtDPvrxcKposSRX/6rwKq\ne88wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgO9uQu7o4b6wNwBIsLkDbkau4JmJp9jbkfdWqUCeSch0CIQC8L3JXqtEA\nQ/PnHQ0LBbXMYG1BwrP8qj0TVCGMHGqclw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATy6fFI2f730ECiEHDXui6iAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTM4ZTQxYWEtODRmOS00YWZiLTk4NGYtZTEwMGNkYzY0NmM2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZThlMDY2ZDYtNGExZS00\nZjE1LWFhMWUtZDg1MzNjNTNkMDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\na0etZJnb8A7Ynz4OSJZcB0mrFB43JIhtKb/m3HrsYpfotnhzH6b4L6KzxtPOapVr\n/AbreHTz1FutySGUdCkMoKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU20MQZ0nVO6M05I6J\nRWb8a0OYragwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIHCCo1CfpLZJ5k6PlOrkvS6CfSl5lrvC+qI46TQkRtGnAiEA\n58o9mew/SDDF7Kleqsf7iBWmVQ7Fxwa4Vj7C4sX+McM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8644", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8644` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZ5qMg1ID0PmlaNCYzH1bpyWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjN2Y3ZTlkLTFhMmEtNGMxYy04MjE2LWRiNmRiZjQzY2ZlMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmNkYjE4NGQtOTNl\nYi00MjE4LWFkMmEtMmY3MzdiNTk1ZjJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEplJTgCk23j3VtiJUZkJ8SxnZ1J1h4tdLgarw8/Q+e2msu+opAQdEUc+XxNd+\nPxNYNBuVgX5KzaJYDKJV/zwrPqOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzAWkK+auH1CTdgatUFa64z0ZHhUwHwYDVR0j\nBBgwFoAUEYkCxc/SAYK7UfEpYHgxy4kSwEowPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiA8oobHfZcTB4XAs1RBxuC+K5KLeB06LebZ7I1W4xD/lQIhAKGU\n2ZsMmzf3dVrlzJONNRaFUT2u9xRgetscnSVnUrgf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT9oKFduQwABnP/w8S9fhiwzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzdmN2U5ZC0xYTJhLTRjMWMtODIxNi1kYjZkYmY0M2NmZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/daQjKmywvuttoC+bza/eFfmx7L1j9ErqM24BSBhI7uYm\nz6Vg1h6QOiMOEuX4EUp8vT1qLgKswnVSnVD7AKCgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEYkCxc/SAYK7UfEpYHgxy4kS\nwEowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM7YJTwsgE9/5PGXKmfUC/lrQeGgt21qioLQev/xREg8CIEnAwVV2GTaf\ndWTjw6znDXECN20Aj+Y/G2RfyA3+OoMt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAfcvm9JsLo08s05MF3OFlII0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmNkYjE4NGQtOTNlYi00MjE4LWFkMmEtMmY3MzdiNTk1ZjJhMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGYwNjljZTgtY2M1Zi00\nMmZjLTk3YmMtNDA2M2E0YTFkYmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nazG4HA5K7AML62Mh/vDR0hqjdbMFqwb63Xp7qd7dSzIHMPtTt490RlY3EY9pGarO\nQf+pVMbnv3f0o3IzV25806N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzAWkK+auH1CTdgat\nUFa64z0ZHhUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDz3rQ5M1ooCEQVRhCpd7cFj63qTgy7VdW7KxKHJMLW3wIg\nalxBt5KhCl/CUZlGn2Xaovm+xqLf0Bxis7UnakeM4ts=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8645", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8645` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAbTz/0Wo/WLJZ9NYItMEbm1OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhYWZjZDkwLTZkMTgtNGFlZC1hYjlkLTQ2NWFhMDNjMzMwNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWU2MWRiZTItM2Nj\nOC00ZDY0LTgxZDMtNGNhOWUzYjdhMzdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYLsOzydg3pWYTHM06RuH0aSZOAWghJoq/nDGfI3jBnmjlq1OKRiay9QMJDLi\nOzsdbcOQxzVFBOEHTeiaqPjXDqOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMZrx1k8B1JwewynE0tv6p9zcOOQwHwYDVR0j\nBBgwFoAU2s4MXKCMLZi6zKhu588SGSEFgzcwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAUT2pOTU+GzL5wm7lmGba2f810QiooTnKU\nbY/+KgmWlwIhAM9hCaidgn05aAJxBX9MOYaWJcUqx9KDrTBfV+FzRcIP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY2nDP6Vc3Z8PQa5Y8XbaCeTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWFmY2Q5MC02ZDE4LTRhZWQtYWI5ZC00NjVhYTAzYzMzMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrlmCY/UYpoeT5RIsWMtboX3uQIoBxLGW9ugB6wlS+xlKD\nuk6UDYQRf7j0WHlNy9mkSglSpHvJ9rJ8DeoSuWrvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2s4MXKCMLZi6zKhu588SGSEF\ngzcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbzkPGZBRIwDLFH1+ve+/bfgqkDkHSVKwWlvEoEOPKGMCIQDIS7y6pFHJ\nf+gBSo/zPTOkuxBdgv80gLc5dXK3Ri1mDg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATsUO6wtSl9TtEErsHXA9h+2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWU2MWRiZTItM2NjOC00ZDY0LTgxZDMtNGNhOWUzYjdhMzdiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjlkYjJmNjgtYmE3Mi00\nNDAxLTk0MDgtYzY0M2FjYjRjOGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUeGAYNqiTYxao20JuJOV5LzSfZ6d9N7S1+699r2Ln47HABp5VhUSuc/sdBijugvb\nb8WUrun6mtkwwdOKOSAegKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMZrx1k8B1JwewynE\n0tv6p9zcOOQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCUyY2tgDdke5QspmgZvao9kfQNk5iGAWh2aeSvwtbtVgIg\ndaqk5aIasFNf1oZPAEL0xOs3FrOn72kFEid0sQDWBlU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8646", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8646` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAYzsxjHOkPV+oMjroDq7G0ftMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0YTMxZGIzLWQ1YzEtNGMxOC04YWY2LWJmOGUxYjMyZjMzOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU5YjllNTItMDcz\nNS00NThlLWIxODMtOGExMTc4NWQ2ZDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtZAZoL6sXHisMcIbVosWLVJNKM5hYREJMlgYZT92P9FyinHkx988rSj+Cz2/\nRKTpDz23dW42UEV9IZ/cSGObnaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMAXFQsdYzyy6cnpgVslUpMyUgEEwHwYDVR0j\nBBgwFoAUwO/8U5pt0C5v2Uji7L5VdbhDnFIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAyYfEKsujQepCxBqIjJY77Dxj8QQF9Ze7\nEPaOo6Co3lQCIQDLU6ZD0+d/h7yb1aDQEzNkdkuwt5EEiCJCovfFWOyqhA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASJ4YoejDxNFQQGMc++u8XPBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGEzMWRiMy1kNWMxLTRjMTgtOGFmNi1iZjhlMWIzMmYzMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/dcgPhlgSy2KJWBYAUde+mRqORfz1JNBmBgISELqossRl\nMEgrU6aLC6jJ1/5dje7oC4PUa/G/XClynJPSQjhyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwO/8U5pt0C5v2Uji7L5VdbhD\nnFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMbQVTUQb39NL/e3aKyvIqtm8oS98Nwd8UHL6tYtGO6iAiEA+N9T5/Y1\nZIohaPTa7GN0M0hxEXCjemhBT81B/HmChCM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAd5a3wIlOv398newKZMpFU5xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU5YjllNTItMDczNS00NThlLWIxODMtOGExMTc4NWQ2ZDlkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjM1YmE5MGItOThmNi00\nNmQ5LTgwZTktMWI0MzJkMGQ3Mjg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nId7Qid8iR2jFs8GjdnKrSQfvsTSa4UmbxrxOxDyrko2XnlmW9iDku66VsF1Fs+hn\nYvSCx9FqDS4aYbFWH3bLNaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUMAXFQsdYzyy6cnpg\nVslUpMyUgEEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIFyTDtEqf1lE9mEzBXhqKOO75h/KELlOLWuoE2MszR92AiEA\n2S9RPPnd65ss9l2CVSeGHvtfe2L/d3uRYOXYuZuzVE4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8647", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8647` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAZKV6iSP43I6Fi7iXzN0POhHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxNzA1NWNkLTBmOTEtNDJiMi05NzI3LWFmMmQzMzc5ZDIzYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjA0ZDVjZmUtOTI4\nMS00MmIwLWIyMzktMzBlOWM0YTY2OThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwJw30PAghOEoYm5PIURNIjunD5WDnXX5NsZu/JchJbzAh2vXe6aATFV1b8uk\nWH797c49j8UzwhD41kn3EDpsaKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjhG4Mtnw5eMKUyxb/0FW3H2GiLcwHwYDVR0j\nBBgwFoAUcmAapJyjWA/05LA5uquTHvqVTQEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAa53uSaTqJdkYSZ5Yqqk4xPmOvW\nFtBVFab76PypZQN4AiEA81XyhfoqIdMvBNoAje4ZBhPrjTcWKxfve0fmMPQ6O14=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdCicuc0S9uMoSjIrdlNDT4cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTcwNTVjZC0wZjkxLTQyYjItOTcyNy1hZjJkMzM3OWQyM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQhi/mvFzzX17tNwPA6uZVGCmvx3Zyls6vLD9wnp/PUlTy\nxRHliyHKi6o64JNJwBBEj3FHtJHb4UwN69yLMSCPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcmAapJyjWA/05LA5uquTHvqV\nTQEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTICfnCaHdy/Q6VU2YYHGK1S/hatQAb94FejNakXeUrUCIQDRdxXAPB25\n0eu9pL1msXIzAWRDc6D3OXJcTyPOgeN/+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAXNn1mkewuWlV3yoCjf24BqmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjA0ZDVjZmUtOTI4MS00MmIwLWIyMzktMzBlOWM0YTY2OThkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTZjYmIzNWQtZWJlNS00\nYWFjLTk4MGQtY2YzNzA4ZmI0ODUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nGKIBpa+k/6nEAGuaQwgI/Yq2e1XQDiw3H4jb4Mis/xeKqFwjDLhAx4uVP7ZdzKS1\nIjI6JP2L39deX0AvoU3hy6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjhG4Mtnw5eMKUyxb\n/0FW3H2GiLcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDYB943B+hU0FnZZMX3kHAalUP5SZv/m7KKAkiIGoy0ewIh\nALWRIkH/hsDPyMbCpYjd91bNFGV0voAvGiiWbRFWkY7p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8648", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8648` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISAViXtKSkYQRYV26SlWZ9v9F+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiZmY0ZTkyLTkyY2EtNDE0NS05NWQyLTE3OTJlYmM3ZWI5MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjIzYWFlODItYjNj\nMy00YWJhLWE3ZTAtNGFmN2QzY2I3OWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ03DhLtEYgDoBeeeBUKjWEr+i9rxB5G6otFgkaUn+3G4uiG3tHNVEbGZanuU\n1rD0DnHMU52MSe8Hx5xfcoz7waOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUY3+ZsmaiAPC7OFVWd3+TEx8qSYwHwYDVR0j\nBBgwFoAUj5vs0CS4L8D4bf39BrA8vuR2Ps0wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANkuI0yB\nkFDCy0I5wlIDq9tm0njlxYhrYhkuGmwhwJ1+AiAWKNLq8lSPjQSD1EeY7+Udp9DJ\nB2mloaOnlZ3jck8t8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAftGQXbSkHa8jS62FnZzrhuMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmZmNGU5Mi05MmNhLTQxNDUtOTVkMi0xNzkyZWJjN2ViOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAToTQhBKjUMwXKM1Dk8i4b6yL2Ue2ZoL3CxHWECIzdpHdMz\n6zZebM+MlaLJbXn9or1uTIxX/g6NoYrrlvQsbk9Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj5vs0CS4L8D4bf39BrA8vuR2\nPs0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANVSGZ4CmV0OBoZ2CnS9Vzd8PIYjpW5yC9nrZ0GzZq2yAiEAjk7aM0qr\n7U2eLXj5O5DwOuMLwU/VTfm8iT/8lGQEzsc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISASfdmrYghuesBJ/Z5kHFwJIxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjIzYWFlODItYjNjMy00YWJhLWE3ZTAtNGFmN2QzY2I3OWExMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWFiOGYwMWMtODgxZC00\nNmE3LWI0NDUtOTkxOGM3YTQxY2Q4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niJYWg+4ZXuJN/EJS3A9oE0pGWweCvSBUY9Oyn/S/R6SIg+joUToMk4gFs85WYYyR\nYAN9SsebZEVfwhOiEl8NyqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUY3+ZsmaiAPC7OFV\nWd3+TEx8qSYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIDfuc8ysGw3ikHwJsJ3ScmRoA7gDxnWLtaLTtg9xG5yGAiEA\n8PD7QFL0ZuyvCi+oG5dPs2pFOFB+cmHBr1CBSjMTXG0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8649", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8649` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe+gAwIBAgISAXv4O1vL9uPYRA5+pNkKQ/6MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiNDljYTgzLTllNjMtNDg4NS1hZTAyLWIzNjE5Yzk4YzM2YTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI3ZjBhNDgtN2Y0\nZS00ZGE2LWJiMmQtZWIxZGM2ZmU3ZjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq3vMdVCG9981op6Bc24jurDqJOR1X69Fw1Weete3QT99EN3ujxDrreS1SNKk\nb5A338BTiXQnmYYaBuI9EhHU36OBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOJYdkFtV6/cYB4jId25LqEPSGjowHwYDVR0j\nBBgwFoAUBc5lUvl97JpGSHLdrxtfaixxB+8wKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDRwAwRAIgaD+cezic\nLLddjPoj0CUVCKt4jMj84ZI4dD3QoCPerlUCIELjqGvYG+m8TEQG3UtqLL0Bf+m0\nTD/ZlxaHsgBwMMyw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWp1HsiNk2gf1SnyjscXKEF2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYjQ5Y2E4My05ZTYzLTQ4ODUtYWUwMi1iMzYxOWM5OGMzNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARn/I7W86ducjUqhaqo9dOd6AiMNkf5s3+LKQw+SqMccVYk\naQXQM5epNkA327EMWjN0FR8pLfibWXjKlvsdL6mZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBc5lUvl97JpGSHLdrxtfaixx\nB+8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIK/OGvh7MPdd2ENTCzN0R9/UobIb2nM4/Jo2tH5cokxAiBUaIh1IWQo\n+H12q9H2MqeuEkfIbQjudhQ7zyRa6ny2Ww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbi84byM+dNamitb0DnUTQ30MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI3ZjBhNDgtN2Y0ZS00ZGE2LWJiMmQtZWIxZGM2ZmU3ZjI5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjQ1ZDIxYzItNGRlMC00\nYjEzLWIxMjgtMjMwOTc5YzdkNjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYSrlzWYFJk8gFq1SMb3gN+OcXBBVZaBRxOBYyOs6HVEX+SY4UM+CwuEzW+JG03y3\noKGDOX4DG34llSV7tc7vp6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOJYdkFtV6/cYB4jI\nd25LqEPSGjowIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIFfXzX6auYy4a0gPTB2EsMcFYh6LAVquJeQRIjhJpsoNAiEA\nv9Z5nJdv3WBi+MdwOsxQyTsRg75VR/ZQPMmYeoAA7jU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8650", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8650` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAS/ifCg+QNiWGbquuZ2q+i3wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxNmFkNmMzLTI5OTMtNGNkYS04ZDI1LTQ2NDUwODI0ZGFlMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWM1NDExNDYtM2Fh\nYS00M2RlLWI0ODItZTk5YmYwMGU1NTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcuX/Dt7xZXQiRCBUVzQScHCOXxKaedtecYpDm5g1phcfSNXAGNj5eUyF3ooi\nBcW0s32XboxLjNQqdpXwAjgcraOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULc3OV33P6vYLXg98ogviXGR0I+IwHwYDVR0j\nBBgwFoAUu0EDICwK/2yljpp36ebYIKQMb9AwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAJ1t4Bk\n5ipx+Vj9W8bSTD9zDDi41UQzw4qGEyYA7ZDZAiB4Ja1CRAouzbLZDV6e3bXREZ3b\n1fkH3y5K9FdchXWDnw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe1Pe36j51U4mg/fXPLd7V2qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTZhZDZjMy0yOTkzLTRjZGEtOGQyNS00NjQ1MDgyNGRhZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhAKVcXKEAF0B/5kJmQ7+VGRXY1N8lYNhVukHOYxqWxOBw\nfoh6h4CtQwRP4V/zQiD4TkHW871xxaR6C/OwFHv7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu0EDICwK/2yljpp36ebYIKQM\nb9AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV4DyWFCNptcv8z7oHLMLr5jHG3IMkNZn30SYeW80TyYCIQCYxTbmz6OY\noL2OBaIdxBwhJ4i/c1VMx8rK/YtIYJgK+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAUHKp3KAz60kLed6yYtQmp+9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWM1NDExNDYtM2FhYS00M2RlLWI0ODItZTk5YmYwMGU1NTE3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzhjMjgyNmYtODZjMy00\nODA4LWEzYzItMDc0ZmY3MWFlYzg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6UNMqQ9q6JG5kXNLzf0x3gJSw5YS3B8FpH3B8zX+aG0g0qiBLyBJoK+1Fvh5en64\nFitcxigWTTgSu2OBs8uFPKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULc3OV33P6vYLXg98\nogviXGR0I+IwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCBK15bgDW7gyCGMHLQxXeN4atSchwm38AKLcc/+Qzd3wIg\nAVNvVOjVmAQ/wrVKWX6SN8t6gcqu2VPhJtG8VcApQvc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8651", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8651` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARTCZS8Y+bpbAQBS8bTYg4iLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMmMyMmIxLTEwODctNDNkMC1iMWM2LWExZGM4ZTQ2MmZmMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzYyN2NiMGMtM2Qy\nYy00MWEyLWEzMjgtZDYzZjFlNjc5YmZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBahhX2PsxEt3ihPGKw3rx5pcS85/bNSe4D1PNkaXoXOBdCouXbOkis93pcH5\nxpolSJgv4CIAGwFH/+Zpp2PFJaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURDcKjm0zyOu5CCkIReozKYGJV8YwHwYDVR0j\nBBgwFoAUMRVYsgrjQC/35OJJI7N9IytMlzgwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQDTbo4O5OdAXLEDgCgbJTWVqXdYedn5S3Tkkphil60PygIgHTUrPOYT\nQeiu0Ff0zg76jxn6iCwIcNWf9i1e82HQjjQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYgRLnJeqboQVcUPcdj1oECoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDJjMjJiMS0xMDg3LTQzZDAtYjFjNi1hMWRjOGU0NjJmZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASP3lYPOxF9m1EBC+OT0bK9hWHqPkqVCcfskDK+9X82mx4F\n2DLZ3WKrg6VOsKJ+M4uPZuwlYBwPFYKsy2P4Ag7so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMRVYsgrjQC/35OJJI7N9IytM\nlzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALOK1LraHsiH8UeGiHN8CS/DoFC/bMQmw4M6Ihfe62dwAiBmjO8MVL1x\nl7guVoJdS9sQObTvSFzrE9xxcTM9skNs3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAXO2JO/Ii6r+Z0vq8cy0VejoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzYyN2NiMGMtM2QyYy00MWEyLWEzMjgtZDYzZjFlNjc5YmZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzMxNDI3YWUtOTM2OS00\nNTBiLWExZjMtYjkxMTcwODcyZDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nqK/gXw2GFuY1blnonmpeW7DdJetuHCs293OVPEK9xJrx3RnxiVugoPMJr/+9a5Af\nsgiXLG3fcsaY88B/kO+3lqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURDcKjm0zyOu5CCkI\nReozKYGJV8YwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCBOnQxTK97lo/AfUPiFRKzH3ncSysIoeH1ddj3QtcdKQIh\nAIU/l5sT6euIf+KMDBL4sDVMm7WZftgnylEPtCkhJ/+f\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8652", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8652` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAV0vAT0AGtvABOh6Ce6kraaSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NTdjYWJhLTQ4ZTQtNDcwYS05NTg1LWUzNDZlZjUxMjdhZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI5ZDA4NWEtZTI0\nZC00N2M2LTkwZjMtMzczOWJkZWU5ZGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzvttLz5eZiTqkg9yFc7/blTDeTmmStRvlDaeHLaxYzU93q3yLvghkj+Ewtyr\nQj0pLgWJVPs9thUW72b+M/xlc6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN9EzvltD8jM3sIfNVi/1UMSE5sIwHwYDVR0j\nBBgwFoAUuD2IZTuv6DEsDCMzmShdBGqI7rIwOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0kAMEYCIQCg40HUmVSAA2PfKPk8aWhO4ZBB/2Jb4MioIvjd/WdaqQIhAIC1+2oW\nBQst9ru+x0KBacrrTSzXiUriXIwIY6M8DS3Q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfCD6AtH/SjVAEjKjTKqhecGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTU3Y2FiYS00OGU0LTQ3MGEtOTU4NS1lMzQ2ZWY1MTI3YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASATF9zZeHoM+QVaatjkMkWXkjh2mgSGUEUq+ZDUdHtVzZQ\nPTG+T6q4ysnu4rO6Y/TDAKUUGOKsR2vQV3fODp1+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuD2IZTuv6DEsDCMzmShdBGqI\n7rIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGOhHxALYhXAlsG6xw/V6yhAWIpMLbBoiJh/XBTJmmrQCIQCt1ldnYPKb\nNDp+KyYjYICXIfAqESIwxuMP6/BMIPZaYw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbcgCxDm0ttFnIdXBSxjmZF/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI5ZDA4NWEtZTI0ZC00N2M2LTkwZjMtMzczOWJkZWU5ZGU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTBhNGQ0MTgtYTUyNy00\nZjYwLTljOWEtOWY3MDNiZTg5MmRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8KABmx3LG42pcXl7bBYwRIgS4sZI7rDsPuJEjC6+DEBHXMCEYCkQTYGyY5ordnD6\n531L2fGnlbhOGEki9TMq8aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUN9EzvltD8jM3sIfN\nVi/1UMSE5sIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIAthUPZM3v4nm0FodmfkGuXN3TtmXURlsKHDKcuUOqdVAiEA\nqQwxS2DgNa29msC4SlXCIlMEV2MHPeSl+qR0CnE3SkY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8653", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8653` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISATrK44zrzJYramKEIWLDleSGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiZTM1NjUzLWMxMzYtNDkwYS04MTU4LTYzOWJjNGU4NDVlODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjcwYmRhZDEtZmQx\nYi00MjBiLTgyMDAtYTc0ZTY4NjA3MzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMoIkn8bpABLowhTZtZjFvDGBIZlJE9dX/GHr3UqYWIcN3alYbxqwtLrJEnDo\nXT2FkbqyfNjRlY58fG7N3usAqqOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1ZsPmW14K7toex5s6MgRdjWNL1UwHwYDVR0j\nBBgwFoAUi54yz9/rHIVPXlbXC8EmPT7CnG0wMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIAKT7CPx9XRrNJvMdORtgQLeUX0+uY4nKPLxBjf3bhT8AiEAtFMo1YUEfM+CYNIq\n0h6m10mRKlTf/oUrsoZ0L7U5n7M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcW5FupY55CEx42CcjJyhXhDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmUzNTY1My1jMTM2LTQ5MGEtODE1OC02MzliYzRlODQ1ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJ9/9/xFfREFkBT7GZwNOBopd+NFSVCxeX7N+lWp8yoAcX\nMnCM48osJVD2ToXex6Vu0jYuyI6kB3WWC7irVmcuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi54yz9/rHIVPXlbXC8EmPT7C\nnG0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXNBwWToC6LOl1noGYGtFFotf7Vyk7ajDDiLVa2Ed5/wCIAo++s1CPqOv\nuheYNJBo28mSEdP39uXVFRDc4A1AVBSB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAeJumPd7/llVei1utm6bbnjfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjcwYmRhZDEtZmQxYi00MjBiLTgyMDAtYTc0ZTY4NjA3MzU2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTM1NzQ0MzAtYzcwZC00\nNzJhLThmNzMtM2I4OTMyM2VmMzU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbq5p2EoHy7bVWH7HsjGSi0KJy2o1ddOxdJuiYoyeGlPKxCmitSdOTHPY2YCeEjBp\nGyylzm8ZnXGcwPY+SzshLKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1ZsPmW14K7toex5s\n6MgRdjWNL1UwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDDHMoK+L/agoQO8SCSeWwWQJkwmLaNbhGWjbTW94BeFQIh\nAMBZ8j7Ajol4cAhWVMdikD9eXE/qwNnK6hxLaOl9Yx0h\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8654", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8654` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAQd1tV7WGyGMILLyICHDHjA7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2ZDZmYmMzLTBkNTctNDFhOS04ODRmLTEyMzZmNTNiYjlhYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzUyNTJjYTItZGFk\nOS00NzkyLWE5YjktZGMyY2QzNTQ4M2MwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQtLcNpuvv/4IDi4+7zMIY+DDoAfJnqFKvtROkEGKRjAh824250C0M+CX0c2A\nvd7HQtFFtNuqBB5Jx+2ZFrVU8qOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWMKA0MKCnyJ11Q5jVNz4WwDLhOgwHwYDVR0j\nBBgwFoAUlUfkp06sR+Q3GrY9fAgAlLfYtpowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIEp48HSS9zQ5qjOyAKvGOr49pT44TICcjyvMdQ6rVFF1AiEA\n4XW8JnbT/Dd4u3bFANAJjm0CnyLr+V7JRvJFlA8+BUs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYLyJmWTi3n7+72KFxsGJJ01MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNmQ2ZmJjMy0wZDU3LTQxYTktODg0Zi0xMjM2ZjUzYmI5YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlQFIoW5yvfXdkhTUSK6dPfBnWMX3oZTZAUWtD1umFtGmK\nkH/T/mbEncHvM4nMX8xIrktW0Ovvsc0p5gzACeZ0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlUfkp06sR+Q3GrY9fAgAlLfY\ntpowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOba9GyFDj2C27R0hxN+qN3fid1HVWprtbUjoRDZ7FJEAiAvyDsdGl4Q\nLc8DPvnvjkQi1Pnm+C61fSRjEFyEBdfd3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAWmuT1pGVviz2yFbWbofqoIpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzUyNTJjYTItZGFkOS00NzkyLWE5YjktZGMyY2QzNTQ4M2MwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTk4MTg2M2MtNGI4NS00\nMjdiLWEyNjQtMGFhZjZjMTNjZTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n82PdhnRxsnjfvKKt0/lyEd2J++Ig81Byv6IWmkEGaYULWalp5A/PUTXJVjlFZa29\ncSsP35bNF5e3aAlIHhE1faN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWMKA0MKCnyJ11Q5j\nVNz4WwDLhOgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIB4HXxqxe6mg2htw+pL86ID/UN/PpiQHaPL7uiJf6yMeAiBT\nsI9wGWbSc24exuUl4VdvnFhmEvUH4Bie5ck7JKC5Pw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8655", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8655` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAftqDLZHHMpjNWoj3ZmVcIVpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3Zjc4MTVkLTU0ZmYtNGMzZi05ODNmLTA4ZjliYzcyNGJkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmM1OGM5ZWItZjYy\nOS00NWNlLWE4NTctZThiNjdkMjVkNTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjRNJH9y9YumE3haLQabn2xs567+3Ri8u/zsYeoMjlhFioN4JIoQ/blVe0BCG\nJIgKoxOhmMu2nGDcE4EtMmDe46OBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6UWW1DMGXoY7rrGMSkRGQT7rR/QwHwYDVR0j\nBBgwFoAUs7xMglOT4zfikARIY5ClHCCl/rIwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0cAMEQCICKU/u0PS6Aa4QczesSjH83MCsoth41TRfIpV0PNoPKbAiBU\nkMQ4ZjyI4yiuYSf49I83jZpkeX1Y/QTL2yEe3j7+DA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd6/UqU/+w1Ss6VS1n4+Lbw7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2Y3ODE1ZC01NGZmLTRjM2YtOTgzZi0wOGY5YmM3MjRiZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASd70bKvg4sMeyVtJAEXXmp7SdeXQLjmVTE4mWjh6ZXCFuW\nHtYPal6wCt2TxvMDVdf3lJi1h4NNKWGgc/mHp8Kvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs7xMglOT4zfikARIY5ClHCCl\n/rIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKcntrow8c47vu+NWxCE0AAMMwiUBjebH1ViaAVAy7J7AiEA0x5Q+82S\nUUkL0PBnY7nwX2UDcz9Ov9iGNRu5xapIz6E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAfBN11Y6RHeif0Qw71WrawLnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmM1OGM5ZWItZjYyOS00NWNlLWE4NTctZThiNjdkMjVkNTNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzAzZjliNTAtZmExNS00\nZmEzLWIyOWQtY2FmYzMwZmU2YzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKqf5PryS6g4uqFeTp9bANDWQJQLDrN/P+0/xisfktzmCoeQFiRBIhF31Sh6qT2Bg\nzm9g5MK89k2XaeRH/Q7R06N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU6UWW1DMGXoY7rrGM\nSkRGQT7rR/QwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIBvs0nHgQwX0TVUhLfMDXfMmhYD/lSuOIXcdb4WdoZLGAiAN\nlI9aqXDv6Sq54VF+TFgjVIGNqfxlEFWN2+nm7QIXgg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8656", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8656` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAYSiSLWfpftb3I4MXA5uz6FtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYThhNWZjLWI0NDQtNGY5YS04OTM1LWEyOTA3ODQ3NDdjZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E1NWVhMmQtOTFj\nYi00NGViLWEwYzQtNWJmNjljMzkwYTIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgn2nUERGnVaqJ8j5PGsyJGtrPMo6xa2zpjI3wIzxDQbQA1jnltNfnoPXblOh\nAletCuI9Wp7YZ096AA5ToUZPRaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmlYmXqhCpOfUnjp7gHnWES+Zf9YwHwYDVR0j\nBBgwFoAU4hv1I+BlCYskd9c+5KmnwSBHAiwwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCMoG9EoZQg\nLQyCykSA6rHOXop4b9rOcSqCFAJJ59cs8AIhAJ+KhkHG67FhXHCNM2CH7I10bB6w\n0vtPcKS1g0JZTSY5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZAz2deu56yIeXsbY/cKlwziMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWE4YTVmYy1iNDQ0LTRmOWEtODkzNS1hMjkwNzg0NzQ3Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoSvRhWLbkfqI/nIsHmUjOL0bCYPRe/2Zq6YYtu0+r/s+f\nJSsIAsIk17iZwzAuowBak20O1+T8AgbbLG0L2Y7Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4hv1I+BlCYskd9c+5KmnwSBH\nAiwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgH7V8npZnT5/nchOMJFId2Jyt8W7IOFSrG9HFfdWord0CIQDcVHlNxRCD\n9B/ZKTUDFPHESqWnu5ytIbhffoquvXSy5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAWtSO4dfaZZ8Nvwog9Rhsrb1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E1NWVhMmQtOTFjYi00NGViLWEwYzQtNWJmNjljMzkwYTIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjVmNjU3NDAtNGYwNy00\nNjAwLWIyYTUtNDE1ZDU1YzI1MjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0zg0uBum0yAh1gZ35EBL+CygjV6P21RAnkqHhkRJF8qKNuXEC+2uUkf+Ro0Z6WX1\nN5GorFzclkckteGG38n1rqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmlYmXqhCpOfUnjp7\ngHnWES+Zf9YwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDAfDCMBP+j+oBTizM36W6JijOP1hvRZH4lMICL0xbT1gIh\nANHzdJWTV8nV5Ixj84io2/qdIuo6LrA99EKVzttGX3Ru\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8657", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8657` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAZ+FbC7K052+TI1w0BXN3tMRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2MmU0YTZjLWQyODMtNDFkYy1hYmQxLTc1OWFiOTM0YzM5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdmMTJhMmEtMmJh\nZS00YWY4LWFjNzYtZmIxNjIwMjAxNWQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERczPD9gp+aLHIQiiv7CW15gGWb/S2ciIt6janXbhhfsq6lzfcntkowmYeAut\nynXm+WN8UqqAVavYMniUqtmwpaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO/nc7LJ4riHTKbIRnsIThBwOaHkwHwYDVR0j\nBBgwFoAUb4deZFpzxeheEhr+2gHwSzwXI9UwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAIYc45o7Ji4qJIscFq+3UTMlBoCWT7EHFd9UAkeYisHsAiEAjmJ339jc\npEfPDtgaP0KjPAhdGWTPmdxfF36ZWlxSXZI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAet82Zvd0F4LBDZS9rvP6oFCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjJlNGE2Yy1kMjgzLTQxZGMtYWJkMS03NTlhYjkzNGMzOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV9p+6BPlSrukG6zS9kePoxc4fJgTFeeRo6J6AnJkz0NH5\nIOBpuDO3AjBWV2c6DbWdAPdiKVLMyjQcaJjCdrUgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb4deZFpzxeheEhr+2gHwSzwX\nI9UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANqaTxbvZcjUKtXdbA+mkVctGnNnlxGQRtyjsOuZD3gaAiB2fc7YVqPB\n15Ga8sAhffjncQ5PeZ4iNSy0fixBwpQAZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAWsB47rk4HROw6Ugleq4SdpVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdmMTJhMmEtMmJhZS00YWY4LWFjNzYtZmIxNjIwMjAxNWQ1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2MwZDE0ZGMtZTE4ZS00\nM2ZkLTgzZTktODFhZmMxNGJmZjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVk9ddUx1SNr1C1/j+RaEBsBJEYvFMbFgOw0ABa015RQi84EsXpAjak/aG22Ls1w3\nRXShO2JxGOGSROFeOaG7TaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUO/nc7LJ4riHTKbIR\nnsIThBwOaHkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIFSO/XPxQ4X4tZA3g6R+zhCNdqa1P+aGn6ArWpzr4JidAiAk\n/ekbb1yXA8/K8oAyR3GAH7eqdeawmzj8T5IQ9fSOcg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8658", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8658` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISATimnxx7v5oOslndaBivEAmdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkODcxZTNlLTgxZGUtNDQxZS05ZThjLTJlN2YxOWRmMDYxOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTlkNzk1NjktMTdh\nYi00MTRjLWFiNmMtMjg1ZjQ3YmExZTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvGS5nMSuMD/foMYBqGQ/uzsk9gb29dMK1NeRCmw2SWPSp9wA3q/02j3gkXIQ\n9zfc6z3IzIuoYcEIh0Dbj1mzyqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTddOtIW+ZxUAWNhCwYt3TeK+CpYwHwYDVR0j\nBBgwFoAURW/3MiTOzxkIlMeekAbtcm0cYDAwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgOZoFD5PgrwGxQxQ6593itlMjKRVeAJTjBLsJQ/sSF0YCIExvEIH20zdN\nmwvreR4SBlQlGQ+9/OpomZm3NjJ7+mDL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcveVGwfTkqEqgXMyud46saqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDg3MWUzZS04MWRlLTQ0MWUtOWU4Yy0yZTdmMTlkZjA2MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoV4eIWIJtSCFVeJvrt1r4nli+jwtgZEdYeBnfHZZH5saR\ndPAlWJ1O2ZZCpT3PfWIdWXvBwqbKvaMxZtGv85FUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURW/3MiTOzxkIlMeekAbtcm0c\nYDAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRfeVEP9G407WT47rd7oXZMWvgbXmYONhzq62dtnr4vYCIDUgsRVq+Js+\nXki97CUkNRa+gwo/6CDRw9DMGU/0182j\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISASjGWXiwTKB8mKxyzUVxZt8kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTlkNzk1NjktMTdhYi00MTRjLWFiNmMtMjg1ZjQ3YmExZTcxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmJmYjM0MzgtYWFmMy00\nNzVkLTkzN2MtNzJhNzc3ZWY1NmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbqGOCrzjga7iBDR/WlPjYZ0NEMOcUUfxi/KlVf6pEbKMwv4NURYGrd8ymNH8BKqw\no7xN056q62UGPsKbod8i9qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTddOtIW+ZxUAWNhC\nwYt3TeK+CpYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIAox0hhA0gVH7zaWp0mwlOfNloTSe5xQ7JAZNpRTpjGxAiAy\nRlgqlmwvlwOHCxN6Dq8/27CEVNRoQL7hEXS9K4wjDg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8659", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8659` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAb1tdArNXlirMVsjowOr4szTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NDg2NTU1LTgwZDMtNDMxMS04NGQzLTU1ODNhOTc4YjU2ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjMwNzQ2YWItZmQ1\nYi00OWMwLTllYTctODVhZGIxMzJlNzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/AYtVTGu1kQdatAm8DnIgptANtLeOwzsQrIS6/R5CrjlivBNeHfXt+qs0thz\nLM6s8jGCm6Y0+5nHYJ9rww/IL6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv4nX/lEPk0VoKGi4se62MMmNLf4wHwYDVR0j\nBBgwFoAU4afk8hgblG4kUph0i4+igFzKrJ4wOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIFdhKOmCjkMqfHaC58FNjY122HYFnP6DyODOcwMC+ZtGAiEA/idqhVYs\nDAuiQwd+YOslF/qYY2hUDLgLfevNIzVZTuw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe9AZAEZ52nTV7vH3vYA+zpTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTQ4NjU1NS04MGQzLTQzMTEtODRkMy01NTgzYTk3OGI1NmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9t1XqPVvbaNL1z8VixoFiV3MQ0OQaX5AltHkpBMKuD5nU\nis5PC7xBMjj+xOECCeh8ub9FRZkgnSjxsRTJ2aibo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4afk8hgblG4kUph0i4+igFzK\nrJ4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALFDoFCsCZ58/sbvT0jOdYnODbndfrJVc3Qc7SlVo5miAiEA1Ht3ZpkX\nyrJE5x6S6LQMLiTlyM1EQRSUgAa/bVyLiNU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAc/VgwKq2GZ7y9Yk0n+s/36ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjMwNzQ2YWItZmQ1Yi00OWMwLTllYTctODVhZGIxMzJlNzI4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGQ5Y2YyNjAtOGQxNi00\nZmZmLWJlYWEtMTU0ODY0MzE4YTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nn0QjXNWsgAxLHxbFdXAzjSVstYf1uaR2GWo412YqgfVIadrWxc8yUHeBnYYlTu8E\nxhaWI5HR5Ez7NTNKXUiNdKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUv4nX/lEPk0VoKGi4\nse62MMmNLf4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDDviXKu9GUGokh7QBHBYzGnPnS0YnMpb3taP3NeT7lVQIg\nbgxlq3I1QpL1BEkusK70WZQNrPq5MXUiZIrxEmIURYI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8660", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8660` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAVZh7nKAquh1JOD26CMx3eHtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViNWE3MWI3LWQ4ZGQtNGE5OS05M2I1LThmMzM0ODIzZTYyZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzY0MGE1ZWItZDM0\nMS00ZWI4LTk0OGMtODA4MGFhMDFmZjE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIJNlUAk+KV4K6p2mLaIYm7i8ezahURdi2ES3HqPjOs0Psbd7Ce/SiGfI/P45\nbYH+sPMBwn3TVtL7x2HxvT/STqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmFdylDfhCDCeaHTpSavMIYO1vxYwHwYDVR0j\nBBgwFoAUm/LfzCrocPfl7FeKKgG59u2/8AMwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIA8khpyMFaxoDYCB31WA3TIo7vUgsfMAsCftFhgO\nfaWLAiBSE7dBYnkikKwNZxyGFb1jpGF2gwAFP00RPLHuC6rwWQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUceU34hK85G0tsrUgl+iNV5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjVhNzFiNy1kOGRkLTRhOTktOTNiNS04ZjMzNDgyM2U2MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOFoiudumOCOPMmLSlvCmiQ8CTx/tqIkKADC1lpKfavZcZ\nDwKiNfVs9b+RQM2ltKDtV1LZiXRwzL8X5fRoPksGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm/LfzCrocPfl7FeKKgG59u2/\n8AMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKNoDwAzt0d5fxXot1JTdW9Ti+ROfBMnXDgLNhJfPCkAAiEApAQ5Bhky\n1Mq431NJaYzf9bd1FGNGHbbvglmaFtvYLOs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAeH50PLKwqVzhmItGgWBVnO0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzY0MGE1ZWItZDM0MS00ZWI4LTk0OGMtODA4MGFhMDFmZjE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2U2ZGQ0MjUtMjI3Ni00\nYTYwLWIyYmQtNWIyOGQzNTczNTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsB45N7HFwCLjGto5ve/uKemCr4Wn1j28FXQWkT/4keM8x4ux6d9AfCUzJMYcvm4r\ns05n1dEQnBFDLnSGtRgUrqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmFdylDfhCDCeaHTp\nSavMIYO1vxYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDwfwg9VBMgt/mgzJA/r9lyq4dgA4LtgqAzYPOaaqU4hwIg\nSRA7vOLPtCGy+04K5JWWawfmmi8DHwm7+YDMEXa3YCE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8661", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8661` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAeZWaGLwU7YOlJv1YXcAYw7oMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlODc1NWI1LTE4YjUtNDE0MS1hYTk2LWUwODg1OTg3ZjRjOTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWFmNmNiOWQtY2My\nZC00N2Q4LWFiOTUtYTlhYjI3Y2Q0MmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExL41S/ADxBSbWgjOieC4EVbplgyjkgdkv2GGWCqihHljnz/rFTV5GVPhbgg7\ng0MfMxISGXCNmICp1oMEOvgPuKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9YU+PAn5J+YYpjZUBv3ZNNxG83kwHwYDVR0j\nBBgwFoAUjN/tOrNEkhcgHw5/5im4EGK2UX0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIFOH8z2pkZWRDegRZMASKBooUCrXqAgTv2JJP2+K\nHXSxAiEA10uKJ4VJ+gzWyE+K+S2aAdIC6q+QYJgWa3X8MnH7Nro=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAegAQAIv4/iYCGTs6QbikSzEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTg3NTViNS0xOGI1LTQxNDEtYWE5Ni1lMDg4NTk4N2Y0YzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEn0B7ZzbpzysnCi+kRxsIY3t0rCgL9vkNgVQiGnBSC/aM\nV+LhoRqK1+PZoTVKyav4xLkBqWXuPWViVGDlkaBEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjN/tOrNEkhcgHw5/5im4EGK2\nUX0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFN0qpTg6s0HOpXrquOD8GKmH0oi6dSo28rTBtE3WyhECIFlJaY1tUeIE\nOIb0nX4K+x+mdKTdNniGcOVp2nSoVSKr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAV4PsJ5HrjZ60Q9SQK5y/s1bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWFmNmNiOWQtY2MyZC00N2Q4LWFiOTUtYTlhYjI3Y2Q0MmNjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWJmMTI4ZDctNzg2MC00\nODU0LWI4ZmEtMDY2ZmFlMjA0MTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nBeaAb9lq7uCRyTAlvTgNPGambjNdDIj+UzFIhqDEk5MthWhy/pRW+BRG0b0ZXnTz\n0C0vxkY8FQY0OdytGuH/j6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9YU+PAn5J+YYpjZU\nBv3ZNNxG83kwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDZ6lsqDov47gTmT8zxuOjg6HPBy7nT5OKrz1uiugH3NQIg\nOlVkKQbv//6L9GBNUqD0OIXm1CbzVEA7mmhqFG2y2FI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8662", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8662` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAefHnJkPOJbo79yz37feuq/KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg2NDZiZjhkLThmNDQtNDQ5MC05ZWI0LTNlMWM0MjJhYjEwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQyNzM2NDctNGQz\nYi00ZTMzLTg1ZjgtMmMxODdhNDgwMDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt/AlxKImc7j/brlcvzJ3TgXJLLus+l/UPgnSEm6Ui4z7bQHv9fygkfMzTcXF\nf92jwyjTHvPpGFmeBM6OUNlwPqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFEEptR5S5IV2EN2tZQOaMECzDyswHwYDVR0j\nBBgwFoAUXY3jDyPHBkT/A0QdMnwtjVMHzz0wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIQD+L/+lMmJe8wY9wnj4i7qBDZTvxpSrle+w6/u38dkiCgIg\nF8xZSwF51/7uXfeT9ZHbu36Ht9GIcvI863JLwbj0/TM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYEeZ9hyFKQniY/6+VA4TEeVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNjQ2YmY4ZC04ZjQ0LTQ0OTAtOWViNC0zZTFjNDIyYWIxMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaqHu0Yttvpgs3wUfSZkKTJmUcQDB2EMasI12jUwORkf1/\nKWe0oIjzVlelKqrCWN4471fKDzwAJESgg72Q7zt4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXY3jDyPHBkT/A0QdMnwtjVMH\nzz0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNl71XJrQSsksAvTt5trcaXqUJ0MIEJIZOsHxk1YjHZsCIFpyRhkQl0cM\nDaLmtj31ZL9vpcJ/41CpXveAqYLoF4PG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAXeCORrhBKSzzVLX5F8tn2weMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQyNzM2NDctNGQzYi00ZTMzLTg1ZjgtMmMxODdhNDgwMDIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmRmYzU5MzQtMTdlOC00\nODI5LTkxZmYtMWIyNTIzMDVlODkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nrmlEohnQWZRj2Y3Tjj2RsyXvKEYhjvpvZjDd4pPH4CT8KtudG+Uk7KsN3ox8YkaQ\nlnKJtmVZHB8ty7PPEcnEBKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFEEptR5S5IV2EN2t\nZQOaMECzDyswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQD11Z1mxmu4eOqzHyD4WB5AqDTw9OvgOJK0Cih45GsRnAIg\nWb8PxHZ85f/wQG1liQkbaeSPNSIDaUiquAqjP33lkMQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8663", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8663` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAYANAoXEtrt3XfEUTbGFUPS0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzYjUxOWY5LWJkYmQtNDJhYi05MDYwLTAzOWJkNmViZjNhYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM5YjlmODEtMDRl\nYS00ZjUyLThhMGItMGNlNzFmNzM4YzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZX1bNpELkKXi0nSQv1dXm3LKc91yc3CiRXfQOpEeyuiIVvsHIi0h6emxg3aQ\nB1BYJagSATcrR9fnODnkr+IJKqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGRkNJJOVy5S4CDWaEplelh0n9a8wHwYDVR0j\nBBgwFoAUozfHXAtHRG1z2WkmuO++pbhZBxIwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIQCdUti5umzs3z4db4weLn0xwIw5Q8OB\nenQNDBHteGak3gIgG9MaSdkcSrXTAloR/to957LHT+hnCbjsbSnq51vhG2E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX7Ktp4HA+OI+llXPInloWyjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2I1MTlmOS1iZGJkLTQyYWItOTA2MC0wMzliZDZlYmYzYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeGbgbJsvDU0TUCrJ3sCG/AwKWhGfDXHxwcr86dH8qaX83\nOrRgcpQWdyu9B5gOEMoXivYyB2OPNauNwTJYgsdCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUozfHXAtHRG1z2WkmuO++pbhZ\nBxIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI07jbwM3G/t9zSFRwUyY970kA+joj2ISzQlVKev63s5AiEApCyS4Knd\nhYyyJwN+9d7v6CaQbOeupm9I6kbKsPjnl3E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAXvfJFa+VRHr3WMIz4md2Wh9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM5YjlmODEtMDRlYS00ZjUyLThhMGItMGNlNzFmNzM4YzdlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTRhNWQ2YTgtMGJjMS00\nZTc3LTkxZDctMzQ1ODE4NjNhNWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngry3mqSP7WnFhXFykTqhY9XBQ2s7kCtXdiTkJrFX39sKQ/R3hAHRgC3UTwVSuihv\n1cAyXXdHRCx4x6p1tjC5jqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGRkNJJOVy5S4CDWa\nEplelh0n9a8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCICOIFLWBBAscqSN6A02JJRcxIgHAnKlbYgrc+WBdqUq1AiBK\ny71CkI6vP2WmQN88mLvIQZN166CxXEprfcVLtfbOew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8664", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8664` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAbnI9VlA4ivmDg7fmKutDlu5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyOTQ4YTVhLWVkMGMtNGU2My04MjllLWM3MzM1MTZkYmM5ODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg0ZGJiMjQtZjhm\nMC00MGRiLTlkOTctNDY3NDdkOTc0MDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXKR6pQUk67pZjNvSyx/GwdV6gg5ySUDNwhYYhxRq6bOJVInIvx70lpymEG5h\nmWTSA3PWYjjs1Zpq5Th1767uzqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURndfd1ucdjTju2psoUFuvWtNuzkwHwYDVR0j\nBBgwFoAU7NQQIg69Kceb/oQoFDufSJeV2NswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDM7wwbLscGAlRSQFvUW8ScPP+slMNz\n2eIEN3dFTAX4rwIgVarEYQ1Ps19/IalhjWXEu/0ffbt3gF8DUmIpKDTEqOQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQpj1KHG7UabB02VaNxPitwUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjk0OGE1YS1lZDBjLTRlNjMtODI5ZS1jNzMzNTE2ZGJjOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbCJxnScAV0iCuBmcesW/HAi5+CjgCkPg0VExUHFpx4t7/\nrF4O4yjVFgoWFDTSAIPtSGIuOcXoFbuHF+QmwLi+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7NQQIg69Kceb/oQoFDufSJeV\n2NswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMD4xA9Z0RSJfxexJGjpcEjJtBWh9oxy4sW1XtrVNbHdAiEAss2QRUbs\nWVhjZ21wMzLWye0qdZr0Mp705nElQ3bkZL8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZJ7/yeY6F+tzzW1B9493ZmfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg0ZGJiMjQtZjhmMC00MGRiLTlkOTctNDY3NDdkOTc0MDg3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2QxOWY1MGYtMzNkNC00\nMGI5LTk0OGQtZTFhODc5NzQ1MzJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOS1rwuY8ayy5mZsZWHhUu4iLZ7GFJ6/iBMcSZel2RQB1SzV4hrEbszA58rIDXUPj\n2eskr91AzvwKF9DmJEL58qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURndfd1ucdjTju2ps\noUFuvWtNuzkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIGJYqWMl+MtHbtkIDAhcviOLZK1m9SoIHVT6f9bW1NlFAiEA\ng2ILBFLMq6w0d4Tp7eQpFhycTqEqZTFOSi4SLUwDR1E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8665", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8665` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVjijNRTzI3dgxx1YBu/CZI6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxMDE0ZmI4LWU5N2EtNDA1NS05OGIzLWEzZTMwZGQ4NDg3NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2EyNmJjZTQtM2I1\nMS00ZTg5LThkYjgtYjlhZDkyZDFhY2IyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcifJ51Sa4aBkDy/vDQhvxf4b5BOmzvqB+68vQFQIvfCBrqL2UK3qVmCvniAK\nbKOBKfsDt05pliQrUbb/S3rQI6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgrHPcW2xmiIv7Of73HBs9XN0OqMwHwYDVR0j\nBBgwFoAUN2yjJlUnLS8LMO8Tp8MBK48VvG0wKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQD75KWmYNPv\nWIqrYQBY6jmlBjBpIu6Kyf8P0colXx5m3wIgZ6UnQ6HhWeDQ66wQBVA2C26Wv4A7\nHqrJFoJ6uo41yIo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW/00gbGhmQl042qyklPsPzzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTAxNGZiOC1lOTdhLTQwNTUtOThiMy1hM2UzMGRkODQ4NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlKYNNAiI/MgEVTqB4tgtZNQamu0ESF2Kbs011deR7aRWQ\nS0TyWaps+JAPaXeNpMhfJfuP++uMeLLl+HMm2Aoeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN2yjJlUnLS8LMO8Tp8MBK48V\nvG0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLEbnRfm5e30LRyZMp3n5lc3JxxxYwNWB9jgl1cN5t5YCIElLCOY+OTTN\npGmme1z9TSdJsylMKBn/78OCnCmu3fWY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbO8xCjXf26G+7LM0o6TmpbVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2EyNmJjZTQtM2I1MS00ZTg5LThkYjgtYjlhZDkyZDFhY2IyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGYwOWUwN2QtZDNhYS00\nZjgyLThmNGMtY2M3YjA3NDk0ZDhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndHfMWDHQGlQRrnwlzwRPcIiFIUmDM8HkSbDajwGXoI/kzNG3ycedwxaD/LXeTky8\nQw9hINBTF3SACAB5dKFPbaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgrHPcW2xmiIv7Of7\n3HBs9XN0OqMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQDBiuSMZ9n87LfbM0Klv8YoLV6ORZEXQS5NYmkIrrB2RgIg\nBfmwIJ/ufv/0zY3xuzcG85rxPk6LKtjkFL6tGxcrtfQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8666", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8666` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAbiY+MxsBr6sFWVn3WSKU+iiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwZTE3NjU5LWVlYjItNDlhOS1hMmQ3LTJiMGNkMzlhOTlmYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzUwYzg0MmMtNDg4\nYS00NWRkLThmMTAtZjAzZTU4Y2IzYTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3jAmmWrSXKDkV1C5VrMXIMtUfEZ2dqAroHFbGGLhIVScUaHixa6TfLJIfsVF\nC4zWJBmw2fe9UhITRsNhav/XvaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURnHCKYcpdq1qtzbBky3NtiPeW6wwHwYDVR0j\nBBgwFoAU4LgKEHe2+6LpQ83wiXiQa9lRYnQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAP2EAOiaeI5/FTPKK6o5KDJb6uXiuyHHRH5Q0m9po0tEAiA+ddw9UOv3\nqrP/wU/CtvODjYqiNHufydfHEhDUb7Lxcw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZrIFEi1bl3pCZIantwzKUq6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMGUxNzY1OS1lZWIyLTQ5YTktYTJkNy0yYjBjZDM5YTk5ZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXNIKRr79dXw4QZ0si3zT7PHe9RrK//rDhfEbi22JQ/8rj\nzbL4lWxr0EPahruJF0q18IwSoLYgt2Vzdy9Adj2Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4LgKEHe2+6LpQ83wiXiQa9lR\nYnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPF21HkXW+UDca5YyXU4MI0mmV7CjxQUc9z0Zs/kf8eCAiAzSx0rzNrZ\nTSkKsQbAiS89Pu7FvJ37gukRtbldmnt6Dw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAa03oj+/8lM9Y/pamlHPzaErMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzUwYzg0MmMtNDg4YS00NWRkLThmMTAtZjAzZTU4Y2IzYTA0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDQ3NTQ5M2YtZmQ3MC00\nZjBmLWIzYjYtZTQ3MzlmYTU0NjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6iidUZks3sr9/rVESde8ekILrS99iGaBb/z+y2nTBrP7yXKgH+yWDfbJXPlDIq5c\nudQttcBp5TqnCi2C/492xaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAURnHCKYcpdq1qtzbB\nky3NtiPeW6wwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCYDv2mULdfu2wIEDKXwJeVVIvgwbJlwokIXwfikdlYdgIg\ndmdwch5uckvWQFSQf9az+WobfawBhfqAj4k+4zoflAQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8667", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8667` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAeKs83lkIoBNYfR2JndVXxxhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwNTJmNDYzLTU2NjUtNGE4ZC1hODBhLWU1MDg3ZDk2MTlkNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDJiNThjN2YtMGZk\nNi00MmM0LWJmYzItZGU0ZTA2ZDAyNzllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEz6wrUv15LVoTtILyACCmdcBaCiif7CjOJHl3GIb9/t4iDE20w/hJjTp3jUCp\nV5b11KpVzAwHxyOwcsF5eXepYKOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJlSgzkkOptK88KTXUudk6gtNk+MwHwYDVR0j\nBBgwFoAUskHufRfoyoZVD4htP7q/PGyjTvQwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAKHGAwe8YBoXE/ga6vv4xAM7Teb4ZCVIpUKkz1wDdNNzAiBbLJcHsElG\n2cSWUcOckanGIfxWSPcqZUoMEiU9BKR77w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARxUjCQKc3rl1NSfqn0nCIHfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMDUyZjQ2My01NjY1LTRhOGQtYTgwYS1lNTA4N2Q5NjE5ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmJD8DYaddIiaYJdm3qqdy3mMod+5/gV+0eBWBLebsQEam\nXgmntsdm25UtKOatDERHFw3SjXqKarMx492ShmoSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUskHufRfoyoZVD4htP7q/PGyj\nTvQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAK4ZmhaDy9Bu4r/LENddQad/+aOMGJ7GQpTp2z/O2fEHAiBbeBDu4rCT\nmbLHSzoZWT9MKBJO+Q7z8vkcdvLAunUtiw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAblunuYrNfn/0dPhpYF/5P6RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDJiNThjN2YtMGZkNi00MmM0LWJmYzItZGU0ZTA2ZDAyNzllMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTNjMjZlMjItN2FjNy00\nY2RhLWE3ZDYtY2U3MDk0N2RmNzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nuvE54Fqr1SpidYa4imVDgsZf7LGi1tKRkFlPTaxFy73ln5+/tA5qSSjLtVhSwr2A\nR2PDskbBilgU/RMdffjIWaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJlSgzkkOptK88KTX\nUudk6gtNk+MwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0cAMEQCIFS1hflBpgHqoWV6bB3RIaFYpw6oXPjyioRe3LNQsDioAiBQ\nOu7TRim2U+Q3C1+ej4Eay9QIwazzJlXUiAC/5zj+og==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8668", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8668` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVzCCAfygAwIBAgISAcEkFGLbzldFZSg63bf/mx14MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlNTQ3OTE0LWFkZTctNDAwZS1hZGJjLTFhOWY4OGQyODE1NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY2NDYyYjAtYzZh\nMS00N2VmLTg5YzYtNWMwZWQxNTY5ZjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsAtRHGCnmlqMMGJOx8DnCB+0TdWkYIPTowHkapwVXYsdpUVGBcNzCkrG0rvs\nBYnMG1oFCZwWjccseqS7K6LeO6OBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU24QwRK5+fjq+ufWymAvYC22cuggwHwYDVR0j\nBBgwFoAU9ztDxH5Ekv7SSyaSD6Yw6slVoFwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQC+OQ8Sn5lyFHQTmSuqIxDn2OzEIuTirfjnN1X6d26d8QIhAPU9Lw0y\nlPir9Y1KHNf71aoL1wk1uLzGJPzxmaw3BlSV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeVP15jo6Co8Oh7qB/Xxtf4OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTU0NzkxNC1hZGU3LTQwMGUtYWRiYy0xYTlmODhkMjgxNTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwCMVhVFlpsTIWu3ku6tmTY12HH/HpDErhQMG6khjoo2TG\n77laAG7dCeGc+WfwTG0SN9+eRG3Mg6STEBTqrFcao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ztDxH5Ekv7SSyaSD6Yw6slV\noFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZgW6fuM2llLzAjASrXi3Ljlf10wuLR1VqiLc+DdGWRQCIQC7W8Qv29z6\npQl/dhnuCAXcHqh7u+1N7LD3A3E4s4YfsQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAX6xJo/E3yWvcuU2MdZvZnjQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY2NDYyYjAtYzZhMS00N2VmLTg5YzYtNWMwZWQxNTY5ZjRiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjRmZjAxOTktOTQ0OC00\nN2RkLWIyYzEtMTY1NTYxYzM3M2IwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkRr5kCk78TpJ26AVHgnch5KapM6QlzDdbVBpNSfq5D/Ty5EtnPZKJrMe1xKYfTBL\nq6lIs1xdV8uvfTYTDwy2bKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU24QwRK5+fjq+ufWy\nmAvYC22cuggwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIE5zRoMuhXU/xc6sNqkZh7vZWrHGSm8p8wZLJHCK1S7eAiEA\n7Ur04HECFOCqvTVEseTPptVf6ZkXCyBG0LN0GsL2XKQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8669", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8669` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAaEoR5qV44D/sV0JHhW3lQ9iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4Y2NhMWEwLWUxMTUtNDZiNC04YWZiLWI3NWM4YjcyY2VkNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRiZGUyZWMtYWIx\nOS00NDU4LWEyMzEtNzk0OWI2ZTE2YWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdSdc+xWMbB3HNZeL1XyUoYXeIzZhR1CJirMCRyoDNtkeJXcIIwchDHUXRV82\noaWMPN8P6mpOSlYhqCtwJu3RFKOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq2Q4ncvV1Frs+MR84cNmwIIFfzAwHwYDVR0j\nBBgwFoAUW+cO9t7NCU/9TwofNUsiO/55DHwwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCIClTTA0zKnvusLB7ditVilFpkX6x0po1IjeLvXJ2\nHDDLAiBQHrPd/yrExR0f+528b0gq4BpEqcM69NnwSzOGoNmkvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVYYJJMjadCqAnPGPP6Mn/cFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGNjYTFhMC1lMTE1LTQ2YjQtOGFmYi1iNzVjOGI3MmNlZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASO1TMfSs6vgALWD2uouyM1b116lXCNqDz5sORYT8oGsoAq\nbGJGveOUkVtr5qlrZ12998CQ195hRdv3clctuyQVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW+cO9t7NCU/9TwofNUsiO/55\nDHwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIgTAHWjFzM5WRlwZgtft27PgvcKoGznCPMBf7u4gXtvAiEA2p9EUO83\n+oeaL0A5sf4CY7lNjcWPAcK3at+bs6a+vzY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAXKNsHVUqK//LayoNPFFbse7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRiZGUyZWMtYWIxOS00NDU4LWEyMzEtNzk0OWI2ZTE2YWY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDdhZWYzNmQtYjk4ZC00\nYzVmLThkMWYtY2E1NTVlMjJjMDVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ngDlimxSOeL9SgE/zkPWp/Zu5rTU5zzimfXb+9BkPwkJ2j9jSA0YLOm6/sNvdGOD5\n/NzcF9a27A+5q8BiLbvKTqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUq2Q4ncvV1Frs+MR8\n4cNmwIIFfzAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQCX7nRMJm2mwJ/2EE/ASp9B4+bcClZaYxX4luUk93oCTAIh\nANDsosks1cgub7YtUAxgT7NfcVYuMRT6VyBjIg/y3x2x\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8670", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8670` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAdnO3VKKVriXquZfkoKtZ+HhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3NTRhY2RkLTEyYzYtNDM2ZC05NGIyLTVlOTUzYTQyYjhhODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUwZTFjYzUtN2E3\nZC00OTRjLWJkMTEtZGJhNWVjMGQ5OWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhymDOIlyX4BvBAv0ioH9lsDKE6ytHsO+KvapN4h4yCkRd1+AtHI8XzhbqWcZ\nBrH/HHYkzsL8ccqkkY77Kd0rgqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/S0SDiiYKOoi/gBgl/AhB4pGe8EwHwYDVR0j\nBBgwFoAU3ZQMiglcoL+32gJ1bpDp0bp9OxcwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIAk4nBM9AokLXlVLwRCsW78PBxtxLMXLtMswXEG+\nDI9ZAiEA+ajKh/w4AGG5Hja6zxrQ4yFItPOksKJBgm6THSri+p4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY09kWTu9JFYjCdLaasCIT6vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzU0YWNkZC0xMmM2LTQzNmQtOTRiMi01ZTk1M2E0MmI4YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6cUQTccbDvGxlof3GQRY4TCaPT91zD85/osHC10fV6yb/\nR7WM6X7bIIhIu44ixQHxVTaQRVd7+PX0T6UvYuXoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ZQMiglcoL+32gJ1bpDp0bp9\nOxcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX+vbMuPUkZucQs0Ozu00q2Sza3dZknMjTg6dQqBlEOwCIQC13XapZSOl\n6+Evgz1TCTgAmdW2SFKWMCScm3AHJmKFxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAe26bg45RHjDK9EKgBGbX2uTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUwZTFjYzUtN2E3ZC00OTRjLWJkMTEtZGJhNWVjMGQ5OWFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDU1MWZkNDUtZmEyNi00\nM2Y5LTlhYmEtYjA4MDE5Nzc0ZjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nszBOWFQTSqQWKk3F3WhV2JRWJd/lbYQ1S9J+PiBkl2Rw+bDVAcuEN/anr3IpCpZG\nfrU3p8M8Gwa3AKGOVjk6b6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/S0SDiiYKOoi/gBg\nl/AhB4pGe8EwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDDElnc8rRQIkpubExEGVek1ZBrKGgx0qS9fAyfpV5lHAIh\nANh4isS8Z1MZdJWoQ2P11waOroTR6/3ljS3sirL1V/V3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8671", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8671` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgKgAwIBAgISAf7AaHxILv4w326LV1QuNfEiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcxMzY3YjNjLTA0ZTQtNGE1Yy1iMGIwLWE4ZTRlODI3NTA0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODkxMmRhYTktOWEz\nYS00NjdkLTgwOWUtNjdhNzI4Y2FjYzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhDrvIGEEkTagDNDa7c1CYM3TphfzK8UngmMwJ1V2s9Kbet3/G+jVsi4BAFTu\n+YELhqNehlXim9SpxUHMCE6aHKOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/cKvWa5OHNUksk+6w1aUkw3Jz3UwHwYDVR0j\nBBgwFoAUQptWESZNlIzSgJreRf7FFjWAFa8wPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0cAMEQCID+Yic0HuqDVTuVXYYmkys6XEP0TMnYs20GipNRgENcbAiBP\nDJgR3gUkp/moKzibgWcaFsNC7pLiVNDPd9tSfEpHZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbBJ6zMWpP+NHJz+dr7f+lekMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMTM2N2IzYy0wNGU0LTRhNWMtYjBiMC1hOGU0ZTgyNzUwNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJ+5rSwyEeXh8nMq7qufOOf0qxvFssJ5WbMyXgt5BQZryC\nmK8QLpetzLUblOKP5KI0mk+yY2nDVERP8UBakhWfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQptWESZNlIzSgJreRf7FFjWA\nFa8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCayAYyOEdRiP6oupvXZESZOx4G+Cy2m7vfA6TR8e3fwCIQDQLZqb8MSr\nqylohPq62U9ZuM94Xw4AWM75Yw/LtG/2jA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAcldzdKjhBRztBE0/CjiZvklMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODkxMmRhYTktOWEzYS00NjdkLTgwOWUtNjdhNzI4Y2FjYzczMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODRiMDhiMmQtZjBjMC00\nN2ZmLWI1NjgtYWZlNGMwMWJhYjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nbGYo5ItSzNuZQCy6WUCbCK9jt1N693o3klVK9rEWksW6EnOjZw6zj4H9Q1qKVOUO\nsVeZTIQJPmT7hkAFwPEYf6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/cKvWa5OHNUksk+6\nw1aUkw3Jz3UwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQC3SJIpIlqFZCp/NE+JFf22lUtt4Sz67i+15d/PMcc/JQIh\nALGHTwSgiFpXgFfC5qQH3umoqABsu55CdYI2pFxKLLU9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8672", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8672` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAU0XeSx8bBCPZNK3EdpbOg16MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjNjdlYTZkLTY1NzAtNDE5OC05ZTIxLTQ0ODY3MDA2MTFkZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIyMzExOWQtMDU2\nZi00ODIwLTgxNzQtNDgzNDQxYjc4MTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgNnvRk/0Oyhfg4+otjjJDXjEwSBT4bfV2j9dn0K7Sa5oBD60hPM/p9dYGotz\nNcHpVHL+XhKDa0tCRUhn0ZacQqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUm6rwDqhUoMyRTuzw0Iarrwcw0EwHwYDVR0j\nBBgwFoAUVePkwlhYf9RSeJWHCCNuRYMxlxswSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0gAMEUCIEaX5kKkeW7Rgh+n9M9s/yHSYDasH1Tf\nCpcEL/msRTXeAiEAtqla25fHCbxcXXWfvyydeNblTcqISXKVJT2skM79ofk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATXw2O1cG7R1pmapn7tjlFiWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYzY3ZWE2ZC02NTcwLTQxOTgtOWUyMS00NDg2NzAwNjExZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWaIjHyzt5qEWexWu1zgREpd3DWmF1abYpSn4JTvwJtxuC\nXJIvRbQT6GV/8tysKckpDZkoEnj2FmOKEsTqdHBdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVePkwlhYf9RSeJWHCCNuRYMx\nlxswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGMlORMo0TGapa+GapMvXvBQJ+6e2gJKinuYZuUDGPK8CIEoJMajyrZTn\ntRa5ExzK4hDrhtH0DWFcmUwtUc3th/gz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAZ7Nh45vztdfIgn2QFGyN+gTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIyMzExOWQtMDU2Zi00ODIwLTgxNzQtNDgzNDQxYjc4MTdiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTY2ZjQ2NGMtODk0NS00\nOTQyLTg1MGItM2Q2OTQ2YjljMjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\niHUmjHYFM163A4UthtKG1JXUpaM/qaoGHg2fraI8UnoksiLZfsoOy8Do/heObPxh\n5rfo1Mu+y5EEVaGZoIk7pKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUUm6rwDqhUoMyRTuz\nw0Iarrwcw0EwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0kAMEYCIQDCXcICxGS2xxMwOiiIIEvAZ/Lq6yp+m41qRQC9pSerbQIh\nAJA051uva8K2SNdkFHMtrXa12tMrzKf35PNXt8RKxgmZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8673", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8673` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATRMFi6rZlCaiaiq5CmuMcsRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViNzM4N2VmLTljOTUtNGVjNC04MzIzLWJkZTlhNTZmOTg0YjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdkZDczYjQtN2U0\nNy00MWE0LWE2YTctZGFhNmY5ODY3ZGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEe9Jm9bcPXpYVz1HRe3HAJVtZ0BKzLJAeTBd6EbfO3CAdXSjfE74l/QeznoUc\nQyCRFYxDXdwxg9THRMD17KHQRaOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvVuxrWbsLI/RepIyLNZ3lqy+5zwwHwYDVR0j\nBBgwFoAUGV8ngMY8FoYz07w2GJZw8wGw8e8wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIQDgts//Bh1i+yKzMYTUSI2SZUCwBzBo\nlj+13I4vXRmYygIgNvuMt9E/dCpoNOmBCARd7HEi09nhdz7srvf4gFB0cDE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARO8W7ENSu1Qu+7XZL4a7IalMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjczODdlZi05Yzk1LTRlYzQtODMyMy1iZGU5YTU2Zjk4NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhNkgaUK0yNTn10qRDmz+iCY29BI8W0CLqsL2FTTxD7O9l\ngSyrZ2n+Cn3Zv44bEG/7BuiUOpFT/Osa5yxKjVmvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGV8ngMY8FoYz07w2GJZw8wGw\n8e8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgT4VhvhoiEERo8ADiVgFlG53XIyiM3hyCkkkTaxoslCgCIQCe8M23asIT\nYuR7tNUi8RRjUqoa+PzKIjJBUNB3w+xyjA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAaH96fSToV9KeST86ObXroAjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdkZDczYjQtN2U0Ny00MWE0LWE2YTctZGFhNmY5ODY3ZGQ2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGYxZjgwMWEtY2YyYS00\nYzExLTg3YWYtYzAxZWQ4ZDkwZjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCnRjbFHC6PIn+w3SC/7HfqrFGK23n30ztyOEkGxCElySww9lBUxQTAWv2Ebj7cjv\nBY9fB8J7C5E8aL9ehV1gA6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvVuxrWbsLI/RepIy\nLNZ3lqy+5zwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwR/AAABMAoGCCqG\nSM49BAMCA0gAMEUCIQCzc4FCneOJI6kNMvZDLNRf1wDQLL5fLvBzZiEwMEt9FwIg\ncqXBKIVTjmPhRJE68YsHvPeivY3vPaPV7DzAZkJITKM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8674", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8674` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcCgAwIBAgISAUMWCbN+YiDMDQy3cNft/MrpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5NzY4MzVlLWQ4MjctNDM3My05MGMwLTJiYTVhYmE1NGU3NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzhmMTI5N2EtNjQ5\nNy00M2QwLWJlOGMtMDBiMWU1ODkxYjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH8rsgR/GmuInVWNLf9PYB0h4DFMg9IySv2OKbUMM+ts0R32JYhD6iIN/SBn+\nrLeWtzLmVpA3xUGN2vqZxqGWHaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMS6+j8t4HFVRUDyNqnihWJARS/CMB8GA1UdIwQY\nMBaAFPEK5Twn74euFXHPNgBX92JeaBghMAoGCCqGSM49BAMCA0kAMEYCIQCfqZQt\n3AKN9ciHw+Rz+0EIAffbjjNAOXSm1mQQGk8IRwIhAJNEa58yqnLWgHRTN6IhRNAo\npbQmNA79/gV21c3OH0gM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATVPYu0PWyISkOYKQSTgfqGRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOTc2ODM1ZS1kODI3LTQzNzMtOTBjMC0yYmE1YWJhNTRlNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATwEHqR3zfL53tZhHj8wiKrCTqOfePfCsxy0Ldv9tLC/Kmx\nxg21p4tGVclVd22vbNUvWWqdJ4Znqwh72VQ8caSJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8QrlPCfvh64Vcc82AFf3Yl5o\nGCEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ6O7hXf14piJ26AbjOBZ0je41ecK/JZOFmoSwYRZ/B7AiEAlszO4VYF\njqIIuOdoE8z5wxVURqiUFWC1jNJG4Ccvkas=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAddb3IFwM38XIoOMzZNst8IeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzhmMTI5N2EtNjQ5Ny00M2QwLWJlOGMtMDBiMWU1ODkxYjY2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGJmZDI4YTUtNzFiZC00\nMGY2LTg4MjctNjhkZTg4NDMxNzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkpk1FrsJa6MVQRGu0vsJ4PIQ3j8mA0E43n6fD+iNyCPiEuoxmUZ8eGyvY3TbYkSk\n/7OKp/AphfHXfm/GdEgXLKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUxLr6Py3gcVVFQPI2\nqeKFYkBFL8IwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCICZwIAcTODlUYOVJRK9zr7XbOTYejJcRI0pPO9YjablrAiBw\ni3jafZUBW5JE773eJE644oM26pIq1fyXiK21UB7TtQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8675", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8675` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAS7BXUhlWttdeCjO+5p6sQ3+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhMjViZDY2LTBmNWQtNGExNi04ODgzLTAzMzAzNTkyNTViODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM4YWJhYTktYmRi\nYy00MzFmLWE0OTItMGM3NjU1N2YxNmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg3UtLHY/+V65XvbifgtyTWOgzgmJ2DGyDItvJgM7j2whRMpTv8oqyjXIewdX\nXRjzGObHQlPJcfi7hvLNM7Ez3aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEwPG+IWGoKVUzT6hnNclPoeelzMMB8GA1UdIwQY\nMBaAFHbS3iPIyjKUCKFLYclUbZN598MiMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvhScz2VRVcl4jvef9YP4hDppLI6F7Xbo\nZJLXfBgqQCsCIQCORn4HwdkkOxcsR7ALkSEI4gzEx71Ohsk1gjYK1Ow8Xg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcgIcTUrvmjnjx4Sg4BL6KUOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTI1YmQ2Ni0wZjVkLTRhMTYtODg4My0wMzMwMzU5MjU1YjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQan4HdwR1vvSP3sS6Q7N4v7m/X/MqVCbvKGyzb0a16q+u8\naIDiv7kOBXLFbPgSYC3zY1Q5uj0zG8KyNOJCapo0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdtLeI8jKMpQIoUthyVRtk3n3\nwyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMnvv/HC4971GbM3fgHJHEU4M+Kd7tYWBFJIWiLmGuv8CIQDCkn/YwlIE\ngksDDsTDu7qa+rMV0ojjjfSRNpsJQo575w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAZVEdTHIonB7Xu5CqhucuQDBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM4YWJhYTktYmRiYy00MzFmLWE0OTItMGM3NjU1N2YxNmIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNTY2NGRhMGUtMjBkYS00\nM2IyLWI2NWItOTIyNzI2ZDIxZGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxIa4N6SbCJNU6/CeTyNZhEveILPF71hHC39a5GRaPWqNoKOXYv3jbN310OHWPtWO\nzfkNwfDlCDYzNfeU8vxeMqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTA8b4hYagpVTNPqG\nc1yU+h56XMwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCA46Tp4Jx52JMMFoqEtWTqB5rK4ab2QmoPUl211kq+ggIh\nANnD1RSmvCDE4cNnSgADVfWJv6MM6+QjiNQop/aPi2cf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8676", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8676` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAfm0zR+q88n2vJKQ74sr43vLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyMmM5N2Y4LTg3NmItNGE1Mi05NzkzLTM4NmYyY2U4YWRhZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU1M2ZhZmMtM2Ri\nNy00NzUxLTgxODMtYTBlZWE0MTE2YjVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvFObmnmAfgVdohsL/wz5do/sFo7PDImmy5Fp2NeiM99VVqgCc5wKZDpzun8I\ndy4ySgJtQ4KZ0vX/bDTvAUaamqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDjWIgae3DHpvqYDWunGJJ8pqDn/MB8GA1UdIwQY\nMBaAFCrubN6nmOGiCpXzkhojXxIRQUloMBoGA1UdHgEB/wQQMA6hDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAw8QRJIr9RgX7GmVZvB9MlH+eU0dICFmnV\nNccRmAlOzAIgVaxrI8XX5In0iC7QTILgUiFKcr3y3rnnIDcSnuRh4js=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbnuEo4OSAJR2bhbn+NPWFT2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMjJjOTdmOC04NzZiLTRhNTItOTc5My0zODZmMmNlOGFkYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARr0eZPbGk/TIe1YMKhRlVS0ezxagBniwpPE99GmCp46uIx\nZz2vLDPnnsuwEiBEjsoK/ixCBSt3s0mbnVzsVbWko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKu5s3qeY4aIKlfOSGiNfEhFB\nSWgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCKWiLbXqFiYIDOjdeXZrY0SOxGLmgLOL9D9QfdalNqYCIQDRhuL4w+s6\ny7LVkF3Li5ogvweiEWvmKHO+o3kpOK6+KQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAf5No9gWA0CT/XivEWAjdN/kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU1M2ZhZmMtM2RiNy00NzUxLTgxODMtYTBlZWE0MTE2YjVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjNmMjYyN2YtNDI1NC00\nM2VkLTlkOGEtYzVjMzQ0NjI3MmI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nKUFQLIkfIRl2qAK01Wqt3RO1fChevRZTohg65cyzXl7nX7DUpihPus18GAMrPsaT\nLbK4Jd21LNMc7yXbqwFwD6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUONYiBp7cMem+pgNa\n6cYknymoOf8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDecGfcX6HcrH2NP/KRtpoBljoKwtiEfUZccX5GandOcAIh\nAJA9QWxHeYlHpNdQRPf/UR1kKIwt/hHD5QJOPtu2AzDq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8677", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8677` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAamqZltKsUeihJ8wxzZpwEC0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyMjkyNmI4LWEzMDEtNGRlYS1iZTlkLTZiMzkzM2U4ZmMwODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ5NjM3OTQtOTU0\nNi00YjFkLWFiN2QtMGFkNzU1MGUzMTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERHPqw0TfCYfDFjxA1vDp4lsDoayZ1qRZTn8ogIM00R9WlNH6hl0+3+P08sa7\nUHtpH5u0nT6FuQ4qUa+G75x/YaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQn3GzL3dGp2VgT8Qk7OiuA21IOUzAfBgNVHSME\nGDAWgBR/rGMrZB8wv9Nww3xHzc4dpRbRozAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIF5qQzSx1S5zeFTIRZ0tSuqK0YlJwmlu\nmtzodtncpMNfAiEAi3Yp/IJf5cNjXlIpnFXf8Oh4rYkdy2Ejn9Ls65zkBTg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcTNt78YR4vOFcd7hSN4HdrOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjI5MjZiOC1hMzAxLTRkZWEtYmU5ZC02YjM5MzNlOGZjMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfg+hk857x0F/Xw+s2R8bdg4RssBMugMHfaGGCtGbg4gJG\nSYapiN+O9i1moasAIE0I9fdmWnNDjuDaFqCH22D0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf6xjK2QfML/TcMN8R83OHaUW\n0aMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO7mmAjU8YkRkF9b6xfK8y2as/s34abe5FFfTvSlKsk9AiEA9rM38GPa\n2RkoRSdQBmKdgY82T9b0T4VJF6xxylTjxh0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAVtAb6v3ZpR7qVACoPMBg84FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ5NjM3OTQtOTU0Ni00YjFkLWFiN2QtMGFkNzU1MGUzMTYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZmU3YWJkNTQtMTU4ZS00\nMmU3LThjYTktM2Q0NDM5YjBjZmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nES02BVHF0VBX+WNIdRHtdq6g+yHYacePRKUdXM4U4gWVXnlcz2r5xgjn8onLXet5\nrHsGYDUZAn3M5uJBPO+b0KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJ9xsy93RqdlYE/EJ\nOzorgNtSDlMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIAjMHB0wP7bmlm0q1iPRiWb87XvFldN0HKWuTnQp5j7aAiBl\ngsqe6DfANecyB1U8urJ5Kim71G3ayj2avGWsquBSyw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8678", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8678` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAeugAwIBAgISAW77WEz+2bC/4+jLI6qY/mdOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZWU1NmI0LWQzYTEtNGFkNS05OGM1LWZmMzI2MmVhMzYzNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTZhMjA2YmYtMzU4\nZC00ODYwLThlMDYtZmFiZjFhMTdmOTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI83ezEUdBdGlb2/QiDgQ8jreXUrcAU7pDljCVuOwrzYIiEY5aYf+jAC3qZqX\nbytaBBi9a2x6ea8XuVlMBUnX2aOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0+F2C4rz0juO+7nRwKeMZ3He/20wHwYDVR0j\nBBgwFoAUrr3XCED09pL54bsbjBMsD5Qfs44wJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiA44Be/YoT+cCAk\nZbpjtTZBLRjolvF5qlGa1Ipjw+ZbdAIgCoyM9ouxtUiQ3H5lke6UAMP5VRwiFGKT\nhNStWQSlns4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYynVlR+iLdrDbUqZcWASLFfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWVlNTZiNC1kM2ExLTRhZDUtOThjNS1mZjMyNjJlYTM2MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu99Yk3Qmd4PTMX09IUR1pAk2mqdRN05z4dtreRALdoVEk\nUYC60H17wKrFazWire6YCyOYCjBJTtkwOCRHTFP+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrr3XCED09pL54bsbjBMsD5Qf\ns44wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCy4dzJDLgVB0iqbnvSnxSeq055OiHAE+/e9prBjqOowCIGmyXOhtJD+V\nLUlMcOmF4R0hes8uMKiIV4MUXCdr0ANz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAX7asEqfSLWedeiWxjlOJBPUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTZhMjA2YmYtMzU4ZC00ODYwLThlMDYtZmFiZjFhMTdmOTE1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjdmM2MyNzQtMjQ3YS00\nZjRlLTllOTMtYmYwNjFhOGEwMTA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOWJFGpNN1jx1ZqrEs6kJzlpriY6iOefL1XfLTGaWykWwOULexjWeTJnyfsXuzO9l\nnW7N/23y0JRKwTRc14I41qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0+F2C4rz0juO+7nR\nwKeMZ3He/20wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCICN/lZpxd9v4r0adtES+SNicqfzH7tr3EmfmbdVzAooEAiBu\n0vSM53HPKzlh4hwX1RZa3O3/b/05Rn3TQ+2OF4ze8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8679", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8679` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAfYQG1vlFmp0CQ4E6K+7+JlzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlNGUwZTNkLTA4NjgtNGMyYy05NWRiLWJmMmFlNzk2ZTFiNDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYyYTFlNTYtZmEw\nMC00YmY0LTgzOTktNWEwNGUyODI3MzYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENw85cuzkp+QenKUrRCuLcPNhoZSfhSQLTnw6DXQ8oCILfodHOHxa7S+DfPgT\nV3ZHpobaLN1oFPC/SKGbgcPLxaOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0PfpPiiwET5nPxPmgLaRInQ0YJUwHwYDVR0j\nBBgwFoAUn9nWYOolfqRmeMr9KA6WqEVFB2AwJwYDVR0eAQH/BB0wG6EZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiB1rFb9+s0do8QF\nBti1YzCGbflluzrhjV/ZNRBeirP3IAIhAKJxay+lH6gfcl3OtTlgYHxX3ABc60+Y\nazdOyDnQEEog\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVd6NNA+memf7qR21BdXsSP9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTRlMGUzZC0wODY4LTRjMmMtOTVkYi1iZjJhZTc5NmUxYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXNWC5js7VW9nLIKD9dO1T5QpNGt2nu9nj7cbORhOPUhcm\n4xn96+HsR8MT0WQpD86mqIzSt5U3vsTu7++YZSqpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn9nWYOolfqRmeMr9KA6WqEVF\nB2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbBax5rAtBYQM+KSGPiJy/T+yfl6xba1U7YhsLoKC0MkCIQDfy2KxNd9h\ngy1hBZ09VKfbeRwxQeCQMZB0u1gzQ3aKog==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAazJgvSGkdykV9US0OjXRh4XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYyYTFlNTYtZmEwMC00YmY0LTgzOTktNWEwNGUyODI3MzYzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTczYjcwMGUtYmI4Yi00\nOTlkLWI4ZGYtZGIyOGMxODRlN2I1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4SKWQo8gNwwap09Npdd18WS0bPOw2vgyjvrIbQV1Y7w42xWhohRgnn+zYq45vN3i\nACoJFfZJznbZQDc2bNmqL6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0PfpPiiwET5nPxPm\ngLaRInQ0YJUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDgCyAJ78zTg8EbyWnidjGZsQgXxGvA9QuBsld+Qv6ovQIh\nALeslIrqxjUyP3/7dg2+QW5s4wk1/f0d7ZQEgnDnbb0q\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8680", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8680` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPjCCAeWgAwIBAgISAVw8tJQ/iUYSKnUGKRpTDUmSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiNzhjYWRmLTUxMWMtNDNjYy05MWNjLWU0ZGNkYjJlNTgyZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTUwNjY1NWQtM2Vj\nOS00YmRhLWE3NDQtZWVhOTRkYmM2NWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGt6dj78zbQud8VCzMEPcsctm/Ow+w9YQyeJBOsOYdE893SG8z0xgpX4Zzzwy\nMNn96ITc0iXHiTjJniFG4GKiwaOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7rgWjK9RyZxvc/mftcr9N+KlkGwwHwYDVR0j\nBBgwFoAUKL4R3aZfUwmvt0pROEltb3HyDIcwIQYDVR0eAQH/BBcwFaETMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBjx7qbCyaHePp8hbqb77Ne\ni5w+EbuI4o8TLgDMNM33BQIgFZvdVKOs8IBMkyJiF7HpC+LfXLls+hoTcQq738NI\n/98=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXSG0fESlTfETphgP8wND/M8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjc4Y2FkZi01MTFjLTQzY2MtOTFjYy1lNGRjZGIyZTU4MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROe6HAUIDB9GWStE2MLgYH5grBtE4PpNQt3adsv3+xoBO+\ndnVwFmJC0/x7jlWg5ujGBOJTRMjwHkDVz/k3dtQ/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKL4R3aZfUwmvt0pROEltb3Hy\nDIcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVCmA9+JzDOufd7jAsdC8pbfm9ZJU8frsuY8vtcrP9LsCIQCnDSmbN9h1\n9XbPzl5n2DBBWNNg8SNVwg2tSbDt1D2Wew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAf8D0/0efJ3dhuCjpGM3UKseMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTUwNjY1NWQtM2VjOS00YmRhLWE3NDQtZWVhOTRkYmM2NWMyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmIzYTE3ZGItNDg4Yy00\nMjViLWE4ZmYtOWJmNzU2MzFkZWE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyNm1ACohHvNAl+aDsCBGhrOIHdUmWrcLYmjgD4gQeuq61OklABl1TzqEKUBwqM8+\n/lJep3rFvScnXBvf+b7wI6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7rgWjK9RyZxvc/mf\ntcr9N+KlkGwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCOP+4QPiVP2+p1Hf20KdXVacrtouONeky3CjL0ZHcGbAIg\nHxFA5EZcEM6IKgfoqo5aSa/rVhFSpv5+AHB/114Ksgc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8681", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8681` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAfGgAwIBAgISAZ8Gph94E2dRJAJp7Zu/I1zaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0MjVhODI4LWYyYTItNDIwMC04ZGRjLWM2YTI0YWJlYTE0ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTY3M2IxYWYtYmE4\nYS00MWRkLWIwMDEtZWE3MDc0ODE5ZTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWaN7/gsMOWnUS1p35wzC5dfKDkfIbazMtrVCp1eqhuS4QBvozuNAbwty5lUH\nLeRJQar+Fh33I5ytJElfQR6TDaOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhK2XQuKqk/fw60NmtCKCOZJUbkEwHwYDVR0j\nBBgwFoAUrHNkVm7VlbaaUgqpDxs4yMtoaFswLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjOPQQDAgNHADBEAiBbp5GD\nwZG0UswfaiEouGFIypCLgESLm7Az6qn6WOEVogIgRZRi+gTNeOkkXB93PYzYixDH\nNUjm/OvVOAUeipt62EM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATWeEu5/FDO3Y+zkzhFYU6VVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDI1YTgyOC1mMmEyLTQyMDAtOGRkYy1jNmEyNGFiZWExNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsHMDcra86BJqtDwhFMXOifK/IMOPnt7Q/U4RCKJMqSTeD\nil6OndfGtvV7a2CetJzqQtgWHpmRjZaJbYO1yrMao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrHNkVm7VlbaaUgqpDxs4yMto\naFswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXsTgPGDEA1CvCE4RK5EkRPM9r06CNaB25FqduP2h9CcCIQCtm0fksRx9\nV3XHkbtRkzXeDWIiiMNhvUpcwA6fQPwBZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAWOaFF6OXvrLHtYAOS1LtpawMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTY3M2IxYWYtYmE4YS00MWRkLWIwMDEtZWE3MDc0ODE5ZTU1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWFkN2Q2N2QtOGJhNC00\nNjMwLThlMDEtNDc5MGY1ZTMwZWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+Ud3hKzDlJ2IgUiTy47Pzxo41fg9u0pp8pZnv0AIAEWz8xCoJUph3I5zcjH7bJf4\nVgib8XAwC657L9oz5RiPTqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUhK2XQuKqk/fw60Nm\ntCKCOZJUbkEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIFjGW5PgBlsInl/dMaIkr/OTm3UErOyhfxoM2oX+g8oHAiBF\na7JFdOYb4DSBs3ScPKe+n9HTm5vbMrMNJNIyI9Ew6A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8682", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8682` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSzCCAfGgAwIBAgISAaFLxqiybfztpw7eFazuRyyoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMzdmMTc2LWIzZmMtNGZiNy04ZjY3LTdlNDk1ZmJlNTBmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRjMzdjM2UtOTA1\nZS00OTRjLWFkYTctYjkzNDk2ZmQzZDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENH1S8g7xs5jLmzEsTl0gcbhroI+VIHl080cvKf3IwySpZxn6ymwnIDnbHrpn\n1iSv3X499WsyD+wnTb0TYYQENKOBkzCBkDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvgKDoBvrmInZfhI/3IPAh0sE+EswHwYDVR0j\nBBgwFoAU7u8Cxd11BFQtgwHLE5lWvFafAa4wLQYDVR0eAQH/BCMwIaEfMBGCD2Jh\nZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiAm6wbV\n8+ZVfKut4koaUoUbyQNMtjooQXaywTM+D7eGawIhALBNLTz4ai9tB2SYOETC53tx\nNl7fIrMYhNCeklG6NJYP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZWID80ntIS7vFGuu9V++F9KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzM3ZjE3Ni1iM2ZjLTRmYjctOGY2Ny03ZTQ5NWZiZTUwZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjharvQodCOdynRtzPYZ8kSU2/u9hhr/bK8X9e1agcrMtK\nuCZgGc2/I5+L2vcn7v9Fw7W42NQIAX27BIatOKCVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7u8Cxd11BFQtgwHLE5lWvFaf\nAa4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALKi465JXObZyA5tYvyXMc0k7aBMT1av9x5HX5ckZ8oBAiBzxFpZK6U0\nouQ/9HHcvjQLn/XkgtXwocRswUp4VqqofA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWkX7jYpE9iSXSK3TqwSIc9iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRjMzdjM2UtOTA1ZS00OTRjLWFkYTctYjkzNDk2ZmQzZDBkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMGRlNjVlZmQtNWFmZC00\nOWVkLWI1ZmYtZDVkOGYxNDA0OGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+Pi8uLfAx1UlMIh3QC+PP29t6lQNHQoegbwm8gpTyd9ZYtb31jhY6Mpm1sSogpo3\np8YfOtOulDbDZBFq6VnY4KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUvgKDoBvrmInZfhI/\n3IPAh0sE+EswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDA/lJzW1xGaTANCyZ6Z6GnZa47HPxX2BBBL85et7ZVRwIg\nbOylv7G6zd2HA/ni9CeW8X/3UijPwIVWs4xMK+17lac=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8683", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8683` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbPq5Lu3kGWq3dczECAt88fdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0M2U5ZWE3LWUxM2ItNDczYy05MTVmLWFiNWMxZmE3OTNmMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGViYjUzM2QtMTQ4\nMy00ZWJkLThkMmYtN2M2OTdiZDU3ODIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMDVgbWESUxZJo48RVdgI2LMUFoNxZ9Tm45VnhECqLb4iw4kDt7iMVfcTetk1\nkatG4iqauS0hmjqPu/pIlue2R6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIKW3yQj3q5I18fjseGUVMO6Kl4jMB8GA1UdIwQY\nMBaAFCH46934BqMcEG0u8pnQxouIgDMOMBoGA1UdHgEB/wQQMA6gDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBPk6g+eVVJ5tC59iIXue+CO9vYxeH9iTTX\nNyTH3efCZAIhAJJK4VW3BOTl4LzNQZmzVXjsT2dYUCKBApS3fpZ9tWcW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASWaets6NdUl4rxMOUgh4tKkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDNlOWVhNy1lMTNiLTQ3M2MtOTE1Zi1hYjVjMWZhNzkzZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS2A3Ix9PIc61niqvj43Q7y/9LS6T3vxnnFp+6WVG4+znVM\n1GyAeLurZvj3KADPz+HzBSVOUVL7y4LW6BJFxRF2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIfjr3fgGoxwQbS7ymdDGi4iA\nMw4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDbz5Yo/8lcMEBxX9rpvHez+xL8X7oEqKZaECB6iTwYUCIQDYMJaS7SXs\nQPekQmEkoq1RWlsy7p+CqRCYds4XwfDN4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZ0kjziX8AK42qlIo5C3fjIiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGViYjUzM2QtMTQ4My00ZWJkLThkMmYtN2M2OTdiZDU3ODIxMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzQ3ODQ3ODgtZjY1Ni00\nOTdlLWEwYjQtMjZkYmExOGRjMDJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyil6rhA/EpeGwE39JNqhC8ysvI30gnaK7M9JBapEinfvZzUyJ/koXa/0FPLvrn95\n5tvD3NmdLHObCnD5yxQQQaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgpbfJCPerkjXx+Ox\n4ZRUw7oqXiMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCVnKVPRzWAHiJ3B0WTaL2H7hryuKj+rykMC9v0S5fW1AIg\nSDzJegGAfT6IaQAoh6f7dybh18HaBzcL6Zd0H8RWV1g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8684", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8684` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAeygAwIBAgISAc0HjZkO486ru+scWBoUJVDGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmNmU4NmRmLTUwMGEtNGQ3ZC1hNzI1LTY4NDE4MTFjMDVlMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBlOWZhYzItZTFj\nNy00MmUyLTkwZmItN2QwZjk0MWEzODJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECbX82do7Mk/cpL2ocdvzXkSIVqSxC9VPEHI34KlGoGS/NLG9fUrNJrXNMksy\nE936cumGUVEDtHtMhHyFLJbj+KOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo8qUyE7nTRRoHJWoqgF42q1CGkgwHwYDVR0j\nBBgwFoAUpKMyGwhuM53Z3dcpvu8cm7b70jcwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhALSOEcYUhrpp\njCp6l+ln4VAhWOih9HDxHbMUyXoZDhaEAiEAmmRtCOdo0OU0tdmX3h7Ed/adt2cT\nyFaDV9T1Kd5F1Lk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUo11lW+MdylbHo/0yFtxHcbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjZlODZkZi01MDBhLTRkN2QtYTcyNS02ODQxODExYzA1ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9X5+Qzzo08lLRx+BzUBa5UJ/Ew7EebbqT1b1cfuAMXWPF\nB/lODHXYc0YJjwuPGsOdQw8SA6dZYw7jfLJeae9eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpKMyGwhuM53Z3dcpvu8cm7b7\n0jcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMbMbZFRMm4MtkXjmUpyXAvdr1TzbOpAwK7SW5mTGMz0AiAgyZwIaNHw\nINN/NjuNcUklkMOwgT4Jw3qxp/zKaSLoIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAYyXaEucYgw+BZcbYpoaPU/gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBlOWZhYzItZTFjNy00MmUyLTkwZmItN2QwZjk0MWEzODJkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDY3YmY4NTYtYjMzOS00\nNWNiLWI5M2UtM2U1Njg3NDNiNzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsfwg2p/wdmA9/pE81FT2qFi3Pn9SLWYfqoTQck4RZZWtZN1JuI89FtqiPXSFA4BS\ndZjPG9wiSvf/cr9iNrNWTaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUo8qUyE7nTRRoHJWo\nqgF42q1CGkgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIFGKqh4TgFTDPymV0R8tZVnrNLCs0vzedzAQOzqz19u5AiBX\nCQKSD6ifS5/skaZo4Vr9FKdg3BRcx9BLYr0nbqHb1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8685", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8685` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAbZ2lPSzBJapEtcsG4m+4KxJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4ZGUxNWFiLTY1MTktNDlmNS04Yzc1LWViMzg4N2I2M2EyZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTAwODI1ZjEtMjE3\nMy00ZDc4LWJhMzYtODgxZmM5MDEwNjg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWZUXWJdefHW+WmT9oPAdcWgtTVcGIaKahHmyKbl0PAIcZOG2ly6Q5ehuG10K\nrLAL+qRy8WxzqX5yzjuvYneaS6OBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKI9vrUL6BZB0PVmRe3mLgfDhu+cwHwYDVR0j\nBBgwFoAU+xoQxOsrqDGcFVoPeA5dxaGYGqgwKAYDVR0eAQH/BB4wHKAMMAqHCH8A\nAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIgdj6k0XhvFHWA\n/bnrOrKEshx4wDu+mGBvh3O7D2xTz+kCIQDu2bkXGLt/MMumHY7nC9bDd95kBr7L\n8QTwqp3Enmff+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdhtCeF6g8R9o+ecMslNW8IbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGRlMTVhYi02NTE5LTQ5ZjUtOGM3NS1lYjM4ODdiNjNhMmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9VTWF8B4f2ZJGGj7FaQQqpBFYfRx1N/gZEUR1oXAAovN+\nE757g0zZwarjERjb5jqNsDipHMQdH9g8ydU//JsMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+xoQxOsrqDGcFVoPeA5dxaGY\nGqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVwkGjIIK0f71ej02fd5tgfYrbf6pUk2VlOADokcORVcCIQDgUYjooqlP\nhNXBigL/m807XEKaCT3IOa/QkF8fYPLhJw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZQB3wpF9F5n4SEq8R3DQX/uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTAwODI1ZjEtMjE3My00ZDc4LWJhMzYtODgxZmM5MDEwNjg1MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzcwNDYwMDUtZjMwZS00\nZGY4LTk1ZWItODhhYjllNzE3YzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nh/quso4v0B7GIuu8Kym1N8yoCLCRFYRhBmHssZDjCaHnBQ7YtKNnyRraIjaaPGN8\nfxV5aLTRkXsfpylI8M2oxaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKI9vrUL6BZB0PVmR\ne3mLgfDhu+cwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCICfARHQYhu2vL5gBy05GMahRMe02XUO4WzyR/vUJ+gDHAiEA\nimB/x4K8KaWNZqWjAqsU1vGehvi6cREUl5g+kiUGwXU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8686", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8686` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAapCMGdfq9pkvL305+J1ezU7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0MmQzMGI2LTlhYzEtNDliNC05ZjVhLWZjYWUxZDcwNGRkZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDViN2ExNzctMmFi\nYi00MzQ3LTkzZWEtOGJiMjc3NzY4NWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEsCbRDC6XcC6kHs9NAXDK74NHRNq+WVQmPvU92m1Fph8bqjKtORj0Jr8sX9A\nXCghZhb/PL9DnLqLtoj5rQ4/RKOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUclzDnamtCUNVYX5dZI1r25ZhuXIwHwYDVR0j\nBBgwFoAUtvKKtbNBFtV00nds06NGR+J3CSswKQYDVR0eAQH/BB8wHaAMMAqHCH8A\nAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDZ+WURmT1d\nStgCOwq7Cgn/CiXhC5dX4PZtuhEcxkEp2gIgcj/sOpHfN1WEoxuYR4ChrDMZhdT1\ncuEikhfzRY9Og8U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdi+0Om1VvQ1QtobgP5OlrgbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDJkMzBiNi05YWMxLTQ5YjQtOWY1YS1mY2FlMWQ3MDRkZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBExxWnZP6k7FUtHmpKT5tqI855ChSDkkA/7INa7Jssavu\niQpiF3Lbjq2GQcXQ65OcMobVU9uJlKQMBMx/ZafFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtvKKtbNBFtV00nds06NGR+J3\nCSswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALvsRUg6bzRlUmEow7Riueb86+PMGWa0KYT6Ex1ssAy8AiAtTeVEzCXG\nAN46di6+kd41GUt3yayoey3eZhUmKTNGqQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAd7tN0EatgYjFAInSOOjHI5sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDViN2ExNzctMmFiYi00MzQ3LTkzZWEtOGJiMjc3NzY4NWFkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOWJhMWFlNGItMTY1Zi00\nYjBhLTk4NTQtMTg4YTdiOGU2NGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMn1chIC6OgekCK0t5XONCdFmNs6LCfs90xt6p+T5P4ll+5u+aiOVceAx+p1GLtH8\niErCaiqX4B9/KGQqrXmVsaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUclzDnamtCUNVYX5d\nZI1r25ZhuXIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIG/1JyOfpAzBv5otLst8C0wPU+tSJoAfpdPxx6K4iDPZAiBE\nGMAjASC4SqpjnuLbxdeXmM83WAkmFYhqmTkLtUNjvA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8687", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8687` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAWEeO8JaUimS1CYsa2g1AkLLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZWNiNzVhLWU0MDQtNDAzZi1hYTQyLWU4ZmU0NjRkNzk5MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk2ZjA4NDMtOGJk\nZS00MjZkLWEzNmMtYmI1ZDQ3Y2MzYjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHN3+mzR4egIkzXDPkmc4uHJ2sLnxTtXPdD+r0gcsgc5fBLSCDcF4f3BbB4Y1\nj5cKGOSyUW6Lxfg92F7YUZgqnaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwFAKxusmSwKNMEYEVDhk5YCOMXIwHwYDVR0j\nBBgwFoAUk3VcO3z2KTWF7vzFijv8pPIQHMQwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIBBspyw3mHgBJ9ZXSQBMmhmKyDJVwM8D1eK7cZrl9AfYAiB9ifxoZI86b9Ot\nRnTiCVDwL3haA32afcYYsLy8sikq4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbT3UrpdM+BOfM2INSEZeIm6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWVjYjc1YS1lNDA0LTQwM2YtYWE0Mi1lOGZlNDY0ZDc5OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATV/MlUZT4JC5UiCippSlJkesgYVf8A+VAHBXzrU9tMddyO\ni1dI1U3U2FZLpA5X1BMWFPfTyWI69ZQYvh7+IenTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk3VcO3z2KTWF7vzFijv8pPIQ\nHMQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZTy5EGVRGL8g9yRF1072Z8ZVBwbvswqrisYyLAC1C+4CIQDAc2PXjMhB\nC0bZzNYSL7gp2yLUr+EFcKozOpJ04RE38A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAbWp4xAwjf7mWH1/3+zXwHgnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk2ZjA4NDMtOGJkZS00MjZkLWEzNmMtYmI1ZDQ3Y2MzYjY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTQwZmY0NjMtZThiNS00\nYzU3LWJmZjEtYWM4ZDEwNjA5N2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJHVeKZ7BYYNZfPxuUYHiMxSXQP4PNXmEL4+g40vMaorhY3MWqA9SDs8Z07yphaW7\nIHagaaPJhBAEmgrB8ClNHaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwFAKxusmSwKNMEYE\nVDhk5YCOMXIwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQD/F4xFLFHoXjP9bxx9MR75d7zYHcOoWhd5Q5INic5MqwIh\nAPT1LEf8BusKnZtgvNxbW2P4YgYMsfFPdhBfPllIuzuA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8688", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8688` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAfijDKiZppx8PRRFnhRgu9meMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0YWQ4YzFhLWY5NTItNGM4YS1hOGZhLTRlNDU3YmM4MjU0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTliOWM0NWEtZDIz\nMS00ZTQyLWFiNDItNDNhMDdmNTNhMDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE72EcBgoj36JGRwvXaPrvDUS59PWirQhToNf8QZyuU8z6UQnR8jIio8v7AM3c\n5+9boj2Nw5wi4BkVttgiNVAUd6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBDwn5byTiCDC/9iykSw0GT3NmqUwHwYDVR0j\nBBgwFoAUh6q6Ss8UVbE9LdcmzEvKQaKhbrIwNQYDVR0eAQH/BCswKaAMMAqHCH8A\nAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQDCg7MVJ+0VFyFX/6HMhxeN9G4Sg9Lxp/Pq2FIdEBwTTAIgZyCUdxQI5I48\nz6yEEu18gQcWtfqQ5BXBW0h1oXQfC8s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVXYhu69kImO3FDIZuEo1wWyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNGFkOGMxYS1mOTUyLTRjOGEtYThmYS00ZTQ1N2JjODI1NDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6AK/AloSG/ZQEe5jXHdLNVrwT1l5npgek9RHw4j7dkmPK\nl21NGAXC6xwcy0wR+nTEpMTOj0HrNVky0CntB2+Zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh6q6Ss8UVbE9LdcmzEvKQaKh\nbrIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOtZVNr9HuRAis8wji0St67MgroSfTu6RpqqUoY1A08aAiATsj9eTVn7\n6rvWttiXn5BHBHEs0vjzfOsTpfNlZqcBoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAYRhifaiCBS9joJj41tGUHs/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTliOWM0NWEtZDIzMS00ZTQyLWFiNDItNDNhMDdmNTNhMDZlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGEyMmM4ZWUtYjkzYS00\nYjllLTlmNjItZjg2NDRiZjQyNGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nQAwyJyiEhRwwKxdcoBVlg3k94Xm8VyQDdRDgOR6LhfTyFk00EPlmkd3aEq/6F/Db\nLWIIN576sphwYXDG6NBJo6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBDwn5byTiCDC/9iy\nkSw0GT3NmqUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQC/g88CwE+pcaR+bcGryHQU8+nheri54MoUSdFYEWrf1QIg\nBW0Is86yqtqm5VTDJWgAaxrz8X3XARIa1KbU+d20ovI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8689", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8689` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfOgAwIBAgISAdEBnkgKviSITpri26MS84fBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYjY4NzM3LTJjZjYtNDdlNS04N2Y2LTI1ZWM1OTJjNTc1MDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVlMjVjNjUtNjI0\nNC00MjA2LTk0NGMtNmEzMmU2NzdiYzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENkAkMbWSH/zDAMaMNWR01tFmaTGOrCcAcuink0z4LUq/j+m5zEHf7RjToyCN\nX6CoNXiuMsNJnp7uz+QLKugxI6OBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBmTJ5fkyNPkUBN/Ai/MZtmCGkzYwHwYDVR0j\nBBgwFoAUP/I4Tf0XA42m3zwT1LMDR8qioeQwLwYDVR0eAQH/BCUwI6AMMAqHCH8A\nAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICGD\nAgp5lEMvW4Qnma/68+/DFS4zLZQ8H+Ygg/jmSCrRAiA/AEixgcB6SX8uT7LkbTeY\n1j/a1CYr4g4wNqwQ5Z3hMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf02dS59PQn/OLvz00hihDB1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2I2ODczNy0yY2Y2LTQ3ZTUtODdmNi0yNWVjNTkyYzU3NTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDEghCntHqhPvlSgEqdYx/PW1dCSywbtbrgQQTx0+3Bnh2\n8IL4KknGdhvchY1G4qOqPi6+O2poGJPBg4onPg2Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP/I4Tf0XA42m3zwT1LMDR8qi\noeQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIajD3dL9R0Tk6f0tJx+opDrQj4MFr4jWo3047el2EwdAiBOuIGRUC+f\nP135f6rJTyfJzDGtuL5dTSuVDPeqIMlAXA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATPLcSiTyuAhKV0a9YMm3PuDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVlMjVjNjUtNjI0NC00MjA2LTk0NGMtNmEzMmU2NzdiYzA5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzEyOGQ4OWQtMWVmYy00\nNjhlLWJkOWMtZjNlODI4M2NkZWU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\npuaQdDHEAlVKUqlldhw1QhDvhPmm0RrTKjoeY7fxTYvpINCO5JrHp/XrC+oaYD2P\nYEJnvJNTId84lDznKhYIiKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUBmTJ5fkyNPkUBN/A\ni/MZtmCGkzYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIAEE42jBGXVSDFqzvS7EZDuH06NIZjVeCzAqBVnZ3qmgAiEA\n59XyXgb1mrrkaZOmfIpIIVN93nMhWr1BokyI9oX7Ig4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8690", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8690` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAVlhrQdD1HeI92Sd20GtTMWtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1ZDdmMTEwLTJkMTEtNDVkNC1iNWYwLWViNzhhZTA3Y2YzMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjBmNTJmN2MtMThk\nNi00MzExLTgwYWItYTYxYTM5MTg4MmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFLNEdXMUPYci3IosaY22PiOp+BBvjLTMxbrfV+hFaEqRXX/LT2CPuM5uUGKG\nI+ZYXsJ4MVsI8g3KBnYj0pkpUqOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtDI2YPeBqquQoLUlnFZ4+HzIPiswHwYDVR0j\nBBgwFoAUquh0rOfdY9FEMsje27OMz5zeK+gwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQDt3L/6neynhGxAaaXPsiVCedM0exaPkHO4mwKEwfngPAIhAKit\nYWEQhauguTPagkRwBsBNEfJZoZNntZciyNNZmy/Z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXwGGPXbXlOFpsl4RLREeV6BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNWQ3ZjExMC0yZDExLTQ1ZDQtYjVmMC1lYjc4YWUwN2NmMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqJLWiSX0YcBKua9ou/lyFoOKQiy4D9AKRYXHTsfsDfL1Y\naWsYfTcZgPPfQmSNhbnYDF3hdEyWmOSHe2VbAs/xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUquh0rOfdY9FEMsje27OMz5ze\nK+gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLtYbTasQ9ESpTUPMG+XQ47RUYiXRXJcEBYMKUQGtJOcCIAptYzSAsmFJ\nsFwUgGLi5P8aS4z6lRJ9Vt2pDMYl0kP9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWwzn9EVe3Yj6luT22GgoM50MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjBmNTJmN2MtMThkNi00MzExLTgwYWItYTYxYTM5MTg4MmI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2EwYjBiMzYtMjRiYS00\nOTk3LThiZjktZTI1YjgzNTQxYWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ny55+1imVlapquuJgu3YCHf9Ian8JLpekNhJn5pMOXjEbIEtjULf19XSpG3KgpyZg\nghP8V/6tevdLhyPv5cWTK6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtDI2YPeBqquQoLUl\nnFZ4+HzIPiswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIE6hR3s0fLmcadiJrj0t4UOfkbFhzXrECXh3mnH2fZ3NAiEA\nwqwNAZiGbZtQufsgGbpGR9YBbsCcX2dnhazd4P7Q+T8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8691", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8691` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAT9QVEt6CLT0uY9T60Lx04V1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3MDk5ODY3LThjNjEtNDZhMi1hOWM3LTA0NzEwN2Q2YjZiNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE5NTFiMWItZWRj\nZS00Nzc3LWFkYjktNTIwZTNkZDY4NGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH/wEFFllglR1GrHOn/9L0UGUctdBV3DsXSkYDM/6L7rt3d8itRmyIQFtZVYA\nMJSAa+z075gFMFjS0pY7hkuI1qOBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPQq0ONDxNSQpTDrnpTFcf6PAob8wHwYDVR0j\nBBgwFoAU4iKgjc363TpVWP1XW0K6/9bvtLEwOwYDVR0eAQH/BDEwL6AMMAqHCH8A\nAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIQChWvW5ozlfMYIQW4SJgd3IH9504CH53tWxUCR5OZfVogIgfwX5\n8z4SEYoTbDo/Y6FLfGT81Vz3+++d2sjpyj9Ss4w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeu5VQdEA5YdY7TE5Jaq9FMcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzA5OTg2Ny04YzYxLTQ2YTItYTljNy0wNDcxMDdkNmI2YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyWHDtnPEDPzNotDf7HOhaOYj97kzEHLvu+e01hv4vAFvX\ncmU8evaX1f3B0xZTNaNJreF9EXGEOynvS2eQjJcDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4iKgjc363TpVWP1XW0K6/9bv\ntLEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOBLMsp6iteAkg5Xko6+PpJjQIWoFiR8ap6JNzLzIJ6lAiEA46VRbNI9\nCaPeUztklvKU6bBqUOKXX5kUDfBzFG2xQdU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISARC6RWNHTkJIZFncemOqSC9QMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE5NTFiMWItZWRjZS00Nzc3LWFkYjktNTIwZTNkZDY4NGM5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2EzN2Q2YzYtOGUwOC00\nNzA4LWJmZmItZjM1NGI5MGQ4ZjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nDN9rI7oOT4Nm66vP3WUO4H/L56oOOUT9unIyChC7+2KAwUI4kUYx1frU2rEm872Q\nZ6eKuPrbJevBVWLGnQC72qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUPQq0ONDxNSQpTDrn\npTFcf6PAob8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDBTOasK+h5oJaGkiiNRfLGTiVBOh4Lk49KxXgE8gCNNAIh\nAM465LTh6PfYza0xOF/ihqOj+jkPIT52dJOo/egtbaS6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8692", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8692` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAXkjYHBy0BT03AdWk4qknPzyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4MWM3ZDU4LWZiMzUtNDJmZi1hNTNlLWI2M2FiMWFhODI5NTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQwNzkwZGUtNTY1\nOS00M2Y3LTlmYjQtMGE1ZWJmMWMzYzcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj8UFcF2yQIPFOYYhb5sZfL+68iYqJtWkKaOMUiIaXAXB20DqVzDvYJ7tOS9T\n/sk6cwu+SJn7JtvFzvYPL+G3xKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOvPX/8+qXFV2UdYq7cqVN1LD/ezMB8GA1UdIwQY\nMBaAFHqG+QbCtAigpx7VDHBheNk+ZrODMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA8q+MavFwA5ScayP9kwH7aPPABQs8Gve/\nkrrVtNGjEzkCIQCwM9PbXsOw6XsTrwD33Q9FRa3s32wBmmGk6S0JvNYEUg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdenqENeK0+NJ+qiMkYLZL+FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODFjN2Q1OC1mYjM1LTQyZmYtYTUzZS1iNjNhYjFhYTgyOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPMVk4LcJyLuZaBvC3bP9/QmCAsEKKSs0DH0EvG3FbQNSe\n5JLXgFvPuYRzU4RocjIWjROpqW1//EYmkuCRpqJCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeob5BsK0CKCnHtUMcGF42T5m\ns4MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcIc5b3uzL4ZQirj0/BRetpx9f0KKKCvSIBdVZInbFScCIHiI0Oi1H0V3\nCjK/EXkdjhGzT+wdIao8yOKvostg6f2V\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAb1KMTg8lApS7Cx/Jww4w6l6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQwNzkwZGUtNTY1OS00M2Y3LTlmYjQtMGE1ZWJmMWMzYzcwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzUyZWExYjYtNDkxMC00\nMjg5LWE2ZDctZWEyNmZhZTc0NzI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLtgNTBEKiKwcIsNd4NaZvwYi/iopshGn1ogOqqiutt9Bv91weiWuuFUS/lyioB3W\nUbTwpCvkYaNVmaG7o5M1R6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU689f/z6pcVXZR1ir\ntypU3UsP97MwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCs1jnOXZxMU5HB5pjnSYlEfmfzf5xiNuxeKnYatOWFKwIh\nAM3owex3uxJj53BzpwVt7Ph77MFbBMUtufyGFvvDcf//\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8693", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8693` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAc/XqPsp+k6DQHyi6cX68b2IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxYWE0M2I4LWFjNGYtNGIzNi1iZTFjLTU0ZmE0NzNhMzU4NDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkzY2UwMTktMTc4\nNi00OTgyLWFjOGYtM2IwMzhlMzZkY2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQFqz2NMiUYhchBlImqxNcTd+ebXUk8wmAf8yG5xFKf0/Ga+QYFcVp2HxAdBb\n+aPco+i4nF7WqT1bsKNBlYw1cqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7FgqX7jfwkEX0eMwFYoBl1GWUgAwHwYDVR0j\nBBgwFoAUdApU2i7jVbrh5w9xy3aV0oDMYKQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhANyHiq3hmFJH\nMbIniV0zOLv3YoI1WUWr6BKjp/xTs1PaAiAd9e5RlfybxfzWjYZ1V+wA17ZjcZqM\n0kgMimAZyMbJKA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY9MruxnBKJvsm1vGLpe3j+CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWFhNDNiOC1hYzRmLTRiMzYtYmUxYy01NGZhNDczYTM1ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGPr6GeecwASrCwKMCnhjxl2ZTxox9yvhLR1EmcLi4/h3s\nwrkRyAAxbOPGBOGATLAubhMfGFA01tEhBP1YEYW2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdApU2i7jVbrh5w9xy3aV0oDM\nYKQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJsWRk8dB+cN0+zZ7+Lhu9WhlhorWwraK2nrBtcEN3tuAiEA939NtL1g\nQXJ9icerp7IOGpFqRFfOQF/2G1416dgg8F4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAUpVdp35xcAjszAp1R/rJ/nvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkzY2UwMTktMTc4Ni00OTgyLWFjOGYtM2IwMzhlMzZkY2I0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNThmYzJiYjMtZDBhYy00\nN2IyLTlhNzMtOWY5MGU2OTdhNDFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0FdaQep7Pd7bna4XwUPX2eeNlv5snmsUEnnq823Y7jNtS2EAivUDPPPjOxwz70Dr\nItxWmulPLOy4DXZ/gYI5e6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7FgqX7jfwkEX0eMw\nFYoBl1GWUgAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQC+4Q36E6PTmUxueKdOFgd7JYmLRvATCoXSzlUFdmEMQAIh\nAPGFtcDHYFHMk3X7ked+ijE7qpq/UAwrFIgcGLp+iAVC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8694", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8694` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRjCCAeygAwIBAgISAU5CQYJH1RYL0Pwx7hPSmWZ0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2YjU2Zjc1LTcwOWUtNGYwYi1iMzYzLTY0Y2NmN2RkMjRkNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYwMmUzYzEtZTY1\nZC00MTA5LWE4NzItOWUyMGIxMWEwZGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELK21BoxxlFxWKEbbT857R3bqgfXFIWa7X01kHTM46mW7P0y6U/TZOg9R6Xj5\nDFt6bWKg9ZzGPmHH2vV4jKmAzqOBjjCBizAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGSchJZq4aSeVHjOM568ZCrCUUsEwHwYDVR0j\nBBgwFoAUem6V6Mr4rqc0EQbWlhdV5xdybCQwKAYDVR0eAQH/BB4wHKAMMAqHCAEB\nAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAKtIuSPeEZpT\nm9X86Oj9mN9NUKJMYWAEXSIXMJF3h6uaAiA8ZjsHQtvINyGuPfvf1Y7BeAtx7fGB\npLMqyPKC4eEVog==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASHywORyIry49k8uWP0SrmTnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNmI1NmY3NS03MDllLTRmMGItYjM2My02NGNjZjdkZDI0ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyNOWKV9EfUwc/z0n5bWPihgF9YIbKztSxJJyUBmpt4ajj\nU99DpyJ5thGS8sE46vZpLTG1DYrGvU9NF8u8CFqTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUem6V6Mr4rqc0EQbWlhdV5xdy\nbCQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI3ycGykDXLrM08tOK52IWObSGdDnkxH5hXpSRUeA3/DAiEA7/vucTZm\n11ZC6GVWTmlXLme9Tzt3AhfoVzZiABkxJ5Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAfXtEMIIWWAaGMzWfbN5AhqSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYwMmUzYzEtZTY1ZC00MTA5LWE4NzItOWUyMGIxMWEwZGIzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmI3OGNkYzItNDI1Yy00\nYmQ5LWFiZDYtNjk3Yzk1NWY1OGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncXhoVRwpslKzoiGUr4U2rcb0EengRtewaxl8n08W7Wl19mp6G98tL7rYo/LXdoAq\nNW/yMy66IF3HNDE4nl/QIaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUGSchJZq4aSeVHjOM\n568ZCrCUUsEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDKdbMnFYDkROoXf8lmFf7qENBeZLBVLAGmG6NP11jSpQIh\nAIQEojuQUUgWXlCce5Akz5dJrX8yrE9+7K0Ljkn+4jlp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8695", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8695` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAVLC1DzlXpZEg/Ts/4R10JU2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5NDU4MzA1LTg0YzItNDcyMy04NDkxLTBhZTZjMTA3ODRjYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNhZDkzNzQtMTQw\nNC00YzA5LWJiNjQtNzM1MTk5NmNkZWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2LAmjjseoUoZAYYcoY+zu7jEiQV17JYVAf9oiCwP0+L5AaV65orI1OYl1u0h\nPQo4rbHUyqy8p870bfO0garTk6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUChNwSB4nl28xD7D14YfkUVV521kwHwYDVR0j\nBBgwFoAUhA41xckJ6SXTdQB6gpGOCQ66oKswKQYDVR0eAQH/BB8wHaAMMAqHCAEB\nAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD+CjLsu6S8\nfkWbu+PTf3QzUgz5T69xmqppz18v62AlBgIhAIbEvS/eVweDetkaFyk6deB+85hV\nkCTRCU0HHYaWyBpR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc9aE8iDqM8MtMrI6l3XhcynMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTQ1ODMwNS04NGMyLTQ3MjMtODQ5MS0wYWU2YzEwNzg0Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYi+SIWSgrTOuM9qTae8qFXeqBSMSY//tR/3TmQtOP9x9A\nHWh1XVJKRA/jVNJfkpUP+VOuKnWaDbPqOw7Nm4clo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhA41xckJ6SXTdQB6gpGOCQ66\noKswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJrvSNVXAoZ0/qDrq5MSmKCCsE2El3LvLS7CxsYIGnbwAiAIOsBwSggn\nDVy1DQKmz46KBtqaDCi0Hk7atoRsYjXsuA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAa4Flx0viX2eicWgpwOzGY78MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNhZDkzNzQtMTQwNC00YzA5LWJiNjQtNzM1MTk5NmNkZWFlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGIyYTVhNWUtOGJlZC00\nZjgxLWJkMDYtMDIzMTUzN2JiZTI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyFG4zWJ88qmYEpCDXuFPIwrH019eibJDWfF+OhCN4pvwl6ghHjHPJ1Uuz85Oq8/7\nLo4so8hRBfkZcjCu7SfoOqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUChNwSB4nl28xD7D1\n4YfkUVV521kwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCQNCHRbHlPQveRGr2q64ehHSM0aWf7eCH7GJGhkquPGwIg\nAO847ifn41/nc2E6wea1caeiPLS+48H5gRL+neexKTA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8696", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8696` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAcJwU5HzauARorLbgUZKroNEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMzNlNjQ2LTg3NjgtNGY3My1iYmVlLTg2N2QxOTk0ZjUzZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U1ZDllZjktNGVh\nNC00MzU3LWFlMDUtOTQyODg0ZjEzMDA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExN7XEQXBvSzFf9y8BXAzZ8wQANHpDm4oKGmnPe/Sc/033VoVkTji+LjgdBVj\nNnDinOHVD+pVLc6GcH+12/ddtaOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFaLBUtlSUD9r/aRtqdTMUIkQIBEwHwYDVR0j\nBBgwFoAUAQfYoBrhG9Lr7cJjrmnfiE71eMcwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIGgDrKI0SUNhbUxVaPLya6yvV6/H0D/9791AMqcIeEB+AiA8Nw8tnOxPqBmH\nefxD4+uEHf0xDJrA4omrgJo12RwpJg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfETEvedpibytbefwnssQsqSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjMzZTY0Ni04NzY4LTRmNzMtYmJlZS04NjdkMTk5NGY1M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpzlooaKMok9W6U/VThwNlYnOIe++MWrLnd6KejF2wN9oL\njKJ/cg9nAWjbFuGejX62j+MyLQIN+OrdZ3j18ia1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAQfYoBrhG9Lr7cJjrmnfiE71\neMcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO9VV2+Vz9W/ayM4yA6aZU4RHbdFsvlaB790iKIpBfwIAiB7pP5LXug5\nHoX3ttjPAED4Xw+mEO/0tjnpSIu0NJDzrQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWTx/wxIR2TfFdCWE2RvOX7lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U1ZDllZjktNGVhNC00MzU3LWFlMDUtOTQyODg0ZjEzMDA2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWY2YTU3MTEtODA3ZS00\nYzk4LWE5OTUtNWUwYjRhZDMwZTMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7lyGsHHgsz9q9azM5rOdPMGTLUdSK43Zv/2ahdnn7Y3TPNil2ZqVebmxWO+jqLG+\naQReOB8ZQOUGLIC7u/N7BKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUFaLBUtlSUD9r/aRt\nqdTMUIkQIBEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCICQR48VaKFbg4QF/FujqPcipiUKEFaz3u7JnSvnFfqq0AiEA\n8tWW3rncqA67uMJ9ZxNu2mTfha8tG6aALY6EZBhqs+o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8697", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8697` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISAVubTtX2vBijT7lHzXt9T+u0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyNTg2NmU4LWFiMjYtNGQwNy05YjI1LTljODUwODc0ZTEzYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc1YzJjZDYtMmE3\nOS00Y2FhLTkzNzItZTE1MTgxZGRmMGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3H47XuuwbzWfbp/ynqgmqO0Pl89vddcWIX+S6kguTFeWoX+QOk0NrYhRKO/O\ntStLmTSYGFCK6n8KXIMV8PHJh6OBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULED13FakTNRXKnos3WZTHx1h8fMwHwYDVR0j\nBBgwFoAUrHVVrIZepIy2O8RZ2qQSE1lvQRkwNQYDVR0eAQH/BCswKaAMMAqHCAEB\nAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0cA\nMEQCICVDWESQ5H2erjCJLLfAIfSYYTRglbpv8711xpjzz+QXAiAKkHb0lUNxBOH2\nHqC/3Zx3FbrKATomTxbz66Ik1LbiuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcbkJEDEggJ02TRRK65NM6qeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjU4NjZlOC1hYjI2LTRkMDctOWIyNS05Yzg1MDg3NGUxM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQL//L5tIMbkVPPx61odYhdKXbHeUhizdb1HyT1pdEywUlP\nkZXjecnFV7YAWot54CciTXfoFFFxK/FQsZl1dtFMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrHVVrIZepIy2O8RZ2qQSE1lv\nQRkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPvVkv652dp6LDhtIE4nsVYapJpuWLiultRIP50B/v2uAiBNifFPoto4\nvl49rOVUq1zShZltB4w94kZXY/Jg3tq9wA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAcdyM2mFtWQurVnhP+9VxLxGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc1YzJjZDYtMmE3OS00Y2FhLTkzNzItZTE1MTgxZGRmMGVjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTYxNmI3NTktMzczZS00\nZjA0LWJhMzYtMmM5MDUwYTYxYmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/EhGaPb+DZXbnL/O0PiSe2nUHV/0er2MmoKkC2VG8zxRFH9lOuS34NFckvVML9Da\nupz/ZnFkNy2jdbA0ag2ya6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAULED13FakTNRXKnos\n3WZTHx1h8fMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDidPnlY/C5A/xs0SN5QnLcbDx0S7pTXSWBwM6NKGIoewIg\nfctHdaVKClKsfAJ1mbcB2s/FQ2dwGENUEy3EmAi2ot4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8698", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8698` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTTCCAfOgAwIBAgISASquLzT81DsFyoSp8TeLUkagMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4NzZiODYyLWQxMTYtNGI1YS1hYTk0LWVkOTRlNDI3ODMxZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFmNDJhZDAtOGI0\nMC00MDQ3LThlZmYtNWRiYTgxOTdjNjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH0EA9XbTzi71LfT5JzOgTnFjI97BEj2Jhl2nsmsNcEVbZKVgVZ9pgf7dg6Rc\n49eaUHBGoIiE1AsNk86rAtEWUKOBlTCBkjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqGnqNpHhRFE7eJdQz6EAuf626+4wHwYDVR0j\nBBgwFoAUXw/SlCBjRPe1Ag3wIFoxcPPiqcAwLwYDVR0eAQH/BCUwI6AMMAqHCAEB\nAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEJx\ngGirfPB7zo55cBVly58H+Mv+MIh1uV/G53k8DCDRAiEA7VwEkUq4/YkLCpi3Oqk6\nQwz22P5eiQ4pFi7AtEN6eRg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUplNzdXmT7S/WZYd8hdfHhXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODc2Yjg2Mi1kMTE2LTRiNWEtYWE5NC1lZDk0ZTQyNzgzMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEFNKcuw0x98a3tFsdSAIvcvYjGimBpjLHizHAm5UFQoOT\nqKk44mtbzCfUz8xjaoCH5kFZJX0nVrlXrpN9KvXEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXw/SlCBjRPe1Ag3wIFoxcPPi\nqcAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANDzRyH9aFkoyJotZW6uiQDNFwwcm8m+FE+6fa4RCA+8AiEAr0Go4QqJ\nhlMRoBctgcjQx8iNwXGeA6hyFohvWrQchfI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAa1v+Lpk5ueYyWzSYZ7FIq1tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFmNDJhZDAtOGI0MC00MDQ3LThlZmYtNWRiYTgxOTdjNjE4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDRjMDZkZTUtYmI0My00\nYzVlLWI3ZTYtN2YzYmJjZTU4MjcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvla39dPFe3H0cNXp1tCkviI757Km/gKQ2neviLEagj/qFufss8wF0yhig2xRz6qJ\nj0GZCLAVeVf16sZ+6Wnb+6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUqGnqNpHhRFE7eJdQ\nz6EAuf626+4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDHeBEM9NJ1V8RmUHknIk4k6jXNw2QlU24ElMnKqrsCtwIg\nEp/I/OJXBpw5QP5wX8twnnlHz0oPYngiJmOsPTLG8k8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8699", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8699` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAf+gAwIBAgISAfNedpWpspHsPVyJ3Wzjc6GyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhYjNmY2E1LTNmOWQtNGNkMC05NTIwLTVmZmZkMWI2ZTU3ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2MzOTRkODMtOTFj\nMC00ZTA4LWEyYjUtNDFlYjE2NDEzYzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBM2b/YzfEEszyynPiSGka/z64TBjQ6vy+5j/EY9F0hZTJCLm3rpmd3Oh/5Pq\ncgX065RhCJojDHHt27gyu1BmQ6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4ArHEGZIRSVlIX8D1SSi6xNKwAMwHwYDVR0j\nBBgwFoAU1A4RErWuNTRu8L9GweV1TX9xvJAwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49\nBAMCA0kAMEYCIQCrlFiA+jCDNvPOb/bIxgOAdo5DZny6wu4H7a9QVumy9QIhAOpE\n/2qYnCWxQ5SmkSu+ZmlgJubrMWMvCkLRa3qH761D\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcCZuo0sObJLBgKwbDWcNUhAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWIzZmNhNS0zZjlkLTRjZDAtOTUyMC01ZmZmZDFiNmU1N2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARX8iHr4Z1mHDaqLkUHtyF5nmxrh0K9+5DlzQQacYbKJEc3\nCTnEVpPip1IHqAbCC8Z3nNJWHVGhlOSeh1yNfa1Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1A4RErWuNTRu8L9GweV1TX9x\nvJAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKNcB03YHumrT9zmBn7jv0UZIcam3wsI1VBtKetsdwYZAiAnvY0+BGG6\nhjOchSbgEaJQLc8LbKDnPrGUVdO+5BH7XQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATPf317wvVg0Jvet5B3fYka1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2MzOTRkODMtOTFjMC00ZTA4LWEyYjUtNDFlYjE2NDEzYzhiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzNmZDk2NjQtNzk4OS00\nMzAyLTlhZTQtY2IyYzYzZTFmOTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nXf4cOENWIgmtxhZxe1pnHZomPbwUt5FqunbWIAuCKC8iEnJK113GrONBWi2Be4T2\njpB4XUzVpBxZxaWM+ijEJKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4ArHEGZIRSVlIX8D\n1SSi6xNKwAMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIGwY5Zgr5RuwhEVSLXi7uwyca2ZoFflufSzsUQLC15/VAiEA\n7WRVR7x067Ee0FGlS8jiv/v9jtZ22O4Op2XmS5Fh1mQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8700", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8700` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAf+gAwIBAgISAYYGZrNrxZrVOxM3w7s6fE42MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkMGE2OWUyLTU1MDktNDlhOC04NTk2LTNlMmE0ZWM5ZDhlYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y5NWZiODctNTBi\nOS00OGI2LWJkMmEtZGZiYjlhMzVlNzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgQzjAzuSOPpTxya9KCsQZnqCoUotxDbWVbuLBQPg50450gBYXSSH6pugkxlM\nZUJIlGtJfroUYUsyQuXYwsjgf6OBoTCBnjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9WytenQK8+XzKxNU0TZ5d0I22DUwHwYDVR0j\nBBgwFoAU8U4TDTeQpEkZYsVW2+AmlMizSywwOwYDVR0eAQH/BDEwL6AMMAqHCAEB\nAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49\nBAMCA0gAMEUCIHKesAkqR7ERhLV/gEI+EHOMormItzXbWOVFO+pKByihAiEAi1wh\nRxAzREq8STDeK1exxSW+nY1DPmBA4N22G203qeE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASj7gKs6k8doGD3r4ts6bM7tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDBhNjllMi01NTA5LTQ5YTgtODU5Ni0zZTJhNGVjOWQ4ZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROckznUrOYr9AuE389IIM4bNCHDGPgdtQGzTTGHzJWHBRN\n14WO3zjR7SSF76O66URhpKG6UKAVvUefFbPpX+vgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8U4TDTeQpEkZYsVW2+AmlMiz\nSywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIUhRb3m8OoHD9b0wv+nthFVgx4zNg1/ZPN9uFsRimhQCICQCRVlhGO69\nix8JODfELU0nyvvc6Oi1QiT+nyrPWEQr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVlqmfDcLDCU5gmW8MAmA/NZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y5NWZiODctNTBiOS00OGI2LWJkMmEtZGZiYjlhMzVlNzY3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzNlNzE5N2ItNDk3NS00\nNzg2LWJmZjYtMGQ2Nzg3NjMzMzhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzzf61O5KCD00dexb/uFxy8LlS0H2YIjXO5fmtWLOdq805u9KuSSoQhk0eaWdVMHf\ny/jR98b7/ccZN1dAmYdNFaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU9WytenQK8+XzKxNU\n0TZ5d0I22DUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCdnBN6lFcYGFbBHoCJ5bOx3esSwvGMyppyjiPue8Y2gAIg\naN1UibYbEZWDXSyDpoYjM7NBz4jZMdEKCTiDA1dWi1I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8701", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8701` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISATBAra0mCtQR0HI7/KF0J7zSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2MjRjYmZlLTdhNTEtNGFiYi04N2FlLTFhZWI2MzQxM2YwNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU2ZmRjNWQtOTU2\nZS00YWUyLWEwMTQtYmU0MWI0YTA0YzQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb8Mkfi8l7gwFCM0fhkJOkf1bvXd/NhWUAtFww1SoLMTTqtcZEr6P1RuT0gtF\nqtAsBDN1h9A2m0CTJ+hHeuugTaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT6PgEeIiJxRXGtTwzC3pYs4xtYLzAfBgNVHSME\nGDAWgBS51UvglqpDmOcEBBTG1EW2G1H9njAbBgNVHR4BAf8EETAPoA0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGhKoev4TMO7XYt+sOgu9ogfSnMmC+XC\n6mr6ezRCUW5kAiBNUw2B4JAPuTRCFITnYWMencLtEOdZ7qJYM8WouWtwvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa0qI03KzS1s6Wo3vFnhaAM0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNjI0Y2JmZS03YTUxLTRhYmItODdhZS0xYWViNjM0MTNmMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT91mZmRRKKM3ASJ2Q1sLg+l/s1n+P6j8+RHc54B2WSFxFz\nl317p2N7VD9VeH6g3jzM7gRpoKVR35OpoYBfmlZgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUudVL4JaqQ5jnBAQUxtRFthtR\n/Z4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWM9B58SQRnmHKHB7bKCrGdfMGZnlOS1UIAUmUBIGWdcCIC3U1UDNIXYM\nxwQAR3x/S/qcPA/ul6P9FLbOY7mWiGpn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAW+YUwnmxJVJVDFb/1jCMr4nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU2ZmRjNWQtOTU2ZS00YWUyLWEwMTQtYmU0MWI0YTA0YzQ5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDUwZTEwNjQtYTcwMy00\nMDQwLTgzYWQtNWU1ZWMzMjdmOGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nzLSHaX876NNte0ZG6uPmhTqtJlNFm3Bn/HBKcUnL1hDJEZh9DuJhrwFCl5+WxJeY\nzkMl+N01Qc7nCMapH9BqSaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+j4BHiIicUVxrU8M\nwt6WLOMbWC8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCrxhwx1UYBMZXE4eRYvoSTvoCocwS/nOLWDgzQEZ6H/wIg\nINzXhbcVsZW2hPKy0GYgo2JcPnW81svg8tYteuRjUmQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8702", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8702` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATtosd/FLNOSMqWiZzoFMByRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxZDAwMDA3LTc2Y2ItNGQxMy04NWE4LWJlM2QzMzJjNTQ3YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjFhOGM3MzItODJk\nYS00OTY4LTg1YzgtMTBjOTU4OGYwMjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO8TRIo6adzuX752XOmujOY8sPRtpjJzk+ejxXasIkVgxPaxCyjiHCbCJV04c\nSPrLYPwMVB8snxDnHIOtN74HD6OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3sGtOZoZ8hHs+bsmsLeZEyqbBFYwHwYDVR0j\nBBgwFoAUH3xv23MdCKz2OzXWbvdTjmCqOacwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD6EB6YkIRq\ntBCbMxJbV+Ew5LTDajRdt+f0WcXDVVeHKwIhALabB+RL7K6UIwzdWUI8QoDxPkgw\n5Mwm7ZdmZcewNr6p\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAefS4MwTRDczlsHAL5QIYhhZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWQwMDAwNy03NmNiLTRkMTMtODVhOC1iZTNkMzMyYzU0N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbioEL6oFp40wCKAPWFbwOpErmk+iEwO6jrpYEpbq0KnD5\nQTMgLKyfoLpuJAAIuZ7kEwBTbBcgTdSRJQGS6rx5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH3xv23MdCKz2OzXWbvdTjmCq\nOacwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCKv3fSxMTNwQMDsOYz/kQPki9b57Wmzcpj9YfnruUVkCIF8exhlHmBl2\ndO/XJVEvTTXoFUNvf86z6//qHdYYAmMj\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWAvc9pYGxAwvgbvCfwMZOFCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjFhOGM3MzItODJkYS00OTY4LTg1YzgtMTBjOTU4OGYwMjUyMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjBhZWY1YjYtMGI5MC00\nMTJkLTljZTktOTcxNDczNmUzNjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nvGFTx4zSjlLgPlc3d0l+aUsR8n3wr4qVcjFBUlqI7ZzUIvQBPDlWAyysWNh4uUcl\nnEqokKpZS5IbfsEmsMRzE6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3sGtOZoZ8hHs+bsm\nsLeZEyqbBFYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCjvcb8eWdvH9hGHrAx/8mf126WbLSw7pqWLanJBwDYZwIg\nYclpdH29DjR6CsjzhhnLtuKCn3uIOoJaLJk6IJfNVz0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8703", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8703` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRzCCAe2gAwIBAgISAVM+Fj6at0XffCTxoiaev4tfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyZDE5ZDE0LTQxNTQtNDc3Ny1hYjhjLWE3ZDM3YTViNDA3YzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQ0NTZjMDUtZTc0\nNy00ODYwLWE1MDctZDg1ZjI4NjhlNGM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn33Js9TB4Rly5NacF0sd/Eso/wtgELImR2z0rz7hZJ0nvlv4LqNxcmnqGH4q\nZfTxadZ5miFphNJTeFmBAASn36OBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDOXq5fLISxDjRYDjfhamnRbkRPkwHwYDVR0j\nBBgwFoAU6U5l/LzFVXO+6RMlpqgvCK4IpuMwKQYDVR0eAQH/BB8wHaANMAuCCWxv\nY2FsaG9zdKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIAuiyZkNqddM\nQPNN+0abehhnmbRRiC1/LVJ7XRmjeRviAiEA35t9loJLSbdW4OOkAjUamFp2woV7\nQeWtE9A/Ye8P/Fs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVVJINMvd0kDVcAFuX6oUKP0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmQxOWQxNC00MTU0LTQ3NzctYWI4Yy1hN2QzN2E1YjQwN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATY/uoFPxyY6HMcLcNOYd+C+6iPZef6EWZlnhVECUMmo+tB\n2P2y1C1njiqJXJcAjeD2fGjojiSzdYEOXpsY4rp6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6U5l/LzFVXO+6RMlpqgvCK4I\npuMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaY9k1kDsWkTLu1KLl4bc6jr4QXhOx6kasOb6fFXfQAYCIQCstoY6pGII\nRk9hGyDY4mS4pGhX26NWfr47pEGzwDNbTw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAfuNOkzI2sb0giGpn05JyOnqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQ0NTZjMDUtZTc0Ny00ODYwLWE1MDctZDg1ZjI4NjhlNGM3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTFhMDBlM2QtZWE4Yi00\nN2UwLTkzNWYtYzY3ZTI5MzJkMTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nTiUacrD6LSQduz+qiLHiIRLJTDqBo9Xmc0iBWBCgD9p6qYYblQ3NMdxTFWXlnBkJ\n0gnq6hcmy2z1SwGeHvvkkKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUDOXq5fLISxDjRYDj\nfhamnRbkRPkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIEObbTYEeQfEIoQKO5xvtaSj3meuJXjmDz2XfJ0WWE62AiAh\nAaHrFkPZBxNPk9DPAbCAwvR49j+ECv+Pkdd2yg/Z5g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8704", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8704` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe6gAwIBAgISAWJRfZ1GrjaytPOnR6YZPEGxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhMTQ5MWIyLTAzZGUtNGQwNS1hMDkwLTg1YzRlM2I5NGRmYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWQyNjI2NWEtOWZh\nOC00NGQzLTg5NGMtNjBiOTRkOWFjODBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuljx5ibZevXr8exriGFvuzGWj1hKAVaMLfaYGuUWQ8XXf8qDrWGJDl0ufSAe\nd9rhZOcyyCQlrcqTYmgrOHwacqOBkDCBjTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUial+bPlcNQnYJHVuwU+LGGkSSqswHwYDVR0j\nBBgwFoAUm8TdvCvaHCfvp4Q9BhYZmQdygekwKgYDVR0eAQH/BCAwHqANMAuCCWxv\nY2FsaG9zdKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAlzHR9Xcg\noS89CAleBxfmE0f0Ok8iut5lVSSeL4sbHF8CIHIGu83AamZ9eUSlCGUMbLOrCo9r\nC8CoaHFSye4dv9H4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYeH9GyXEkJoFmMPmeCK19d8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTE0OTFiMi0wM2RlLTRkMDUtYTA5MC04NWM0ZTNiOTRkZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/uPnQR4KGC74tEgK0Uy8O79nys6XSOk/FIKTP2nG3khqr\nf3Yb5qAmr2Gqs0hV0YQ/cSBzBrBA2q9KZyW49dlYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm8TdvCvaHCfvp4Q9BhYZmQdy\ngekwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIHHMAX/DF/0xeIIUcWy1mXjs1GAyEc0kmLovUrk1v/LAiEAuv4hSOpt\nCto8XIYTp92qi3NA1Lmt3dP9S+Q+ZQJW8o4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAS5evPrp/daQ9a0lO1lhVjPuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWQyNjI2NWEtOWZhOC00NGQzLTg5NGMtNjBiOTRkOWFjODBiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYmFlNDI1NTEtNGUzOS00\nZDFlLWIyYTYtNWJhZWNhNWYzYmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n2Bq9DnIexkrymI7yVE7x/5D9pQpFRmZ91PnpYQD5QDFZuqPy/OK1s1JBNW0yzDSj\nZXeFPKzRbMUymhwZY9aWi6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUial+bPlcNQnYJHVu\nwU+LGGkSSqswIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIFSlA8oC236CJqtTixYlSY4Xr+aEm0xqqjdH2P1m6YG7AiBR\ny+4e2275FrNQwF3pP1uTqjMBdPU5gMw3mqIpzHYXkw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8705", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8705` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISASYiZ9rKny3URXEs6GWOc5bBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkNGFjNTUyLWM2ZTYtNGU1YS1iNGViLTExNTNkMGMyN2VkNzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRmNWE0NDAtNTNj\nZC00ZDg2LThiZjctOTY5OTBmMmUwMDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwfDpySQ4G7HMoqOok+rVSfsQ3KCbyCVls0m+UVdFmE01HTV336pw8jMnaXW/\nOCY8QWUg0bAj5Ikaf9F7hEbekaOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSh4h1r1wbTBhfPaA5uv6mDkfMAcwHwYDVR0j\nBBgwFoAU8/OK/UTzhkUozPzg2X2WavBRbXMwNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNI\nADBFAiABRUAzVJXafjsBp/CyIG5DwigO2hz5RXSzA8+2y45BNgIhAP0v6VUOORg7\nEBwxaUHNRycOrfXgGHU/dy5072fU2fTk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd2cRw8LhUekzfgf1ELb3EuBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDRhYzU1Mi1jNmU2LTRlNWEtYjRlYi0xMTUzZDBjMjdlZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQo2VjsaEI8ILm2C/1mrfz7QTp/a8Q9DCcmHE1gYN8F6nmV\n1+miYp4W3DgF1It+CuboR/lB8HHJTDb+JA2XmCwRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8/OK/UTzhkUozPzg2X2WavBR\nbXMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHODIH4Rkmes1pKoVPclHHjB24ZYfN6mdocppFm6iMUwCIQCXAQB/6i6Y\njw5oZ2LtbioAeUMR2EM5Rp84tAmkORGc1g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAbE/DlzOeU4jrRJFUTsyCH4KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRmNWE0NDAtNTNjZC00ZDg2LThiZjctOTY5OTBmMmUwMDk4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGUzZDQ2M2QtMTAyNS00\nM2U1LWIwOTItZWFiNjUzYjAzODMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZJGwdnc40DXn+eVaXddRWE0ZtREHPaXr92f+o/am78VYz3G5kZweF8DsSgujc5tK\nTGQTAW6K8XoIbOfVwzEeqKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSh4h1r1wbTBhfPaA\n5uv6mDkfMAcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIGKiMmjnQP3awQA2mGxwLtWU2n5m/qketxSZCAtjJEGjAiEA\nmDzISSGmsZ2oiwprG/7IbXDGkEHJpL/8r/5z8c7KT4g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8706", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8706` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfqgAwIBAgISAUJY9wxSXQITAjcc6jaNigd+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2YmQ3NzMyLTEyNzEtNDBlYS04MzgyLWM1N2I1NGJiZTAyYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI0M2I1NzQtYjBi\nNC00YjlhLTk5YmEtMDAwMjViMjgyY2ViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhawtlJKGbro8pZXMYcNQxK0NQFeqPg5MXBb6M4tfneJitB1M6ylDBNBMVsIw\n4yqPjd3VAyU6ba+l8fM4rUoRy6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSnbQiknAZmA5FGzTQqsCaCoESZEwHwYDVR0j\nBBgwFoAUnUXtOIJS3+/IYbqGO1tXE5K90K4wNgYDVR0eAQH/BCwwKqANMAuCCWxv\nY2FsaG9zdKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNJ\nADBGAiEAp4PIFnJGD1fkvVIkfzTXhvxVqXaDmMa78+Fxw0uDzaMCIQCWlGTDOSMC\nMxCWp+TXwdvQT91BQb3tN9zX1G1BEviDkQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbx3Z24bFupmwS89lJP4QyC7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNmJkNzczMi0xMjcxLTQwZWEtODM4Mi1jNTdiNTRiYmUwMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSsbGAZvQ/sXHi13ewoPNnwIKIFNCN+a7jnXSXWnLnO3mu\nfbt4nzWfrMNsxV7Qoqr4ab1WkxPwqxPvF02d96SCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnUXtOIJS3+/IYbqGO1tXE5K9\n0K4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJp6Lw69E0yfXnuQAM+WCwk6hsUZzMkKMBvnIdy4MRs4AiEA0w+uXbP8\nuGKocutWb7P4XBtu5d0ZaPrT3dDIioVu/+Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAQv0WS5iaTSarMxcJOQDeWrlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI0M2I1NzQtYjBiNC00YjlhLTk5YmEtMDAwMjViMjgyY2ViMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODRiOTgwMmEtNTNmMS00\nZjIwLWI0MDktOTYxZWQwNWYyZWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJuea8wfLU5neKPV3Xy3E+GK8k38wm7fU8u6T6wAjHrqm04hzsEH35ly0fkUvkLnw\nq5yDdnPpUhW22aW+ZLH1EKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSnbQiknAZmA5FGzT\nQqsCaCoESZEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCFiJjfY6nDkROs9ehReR1IJK1tWjuqh4UP2UQLwBfkxAIh\nAP204Wj+2gY3d3GOIijJkC6icq7QihzOoB13Wn2qz+BS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8707", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8707` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTjCCAfSgAwIBAgISAUB6YhudUKWR/+kdBIKBBpoiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNWY1MjAwLWU0NzAtNDY4NS1hMWQzLWNkNzFlYWZjOGFlZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQyNTg1MjAtNTY2\nNS00YWMwLWJhZDUtNjkxZmNjYzA1NTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzQVEjkRdutGBpoUg6LQTJs1CgTtpNN8afxli+i0U+benmhaJ3Zl2/8rpmcWd\nL/g6AsX2seHudueXHFQUZcaWR6OBljCBkzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0Ku9V9Aq5M925Ug4Ffbisp/TfVAwHwYDVR0j\nBBgwFoAUweJI8ysMCNeH4V8+sET6hvhArEcwMAYDVR0eAQH/BCYwJKANMAuCCWxv\nY2FsaG9zdKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjOPQQDAgNIADBFAiBU\nfDHiARNM4VzpC2X4eVMWtqKeQK34oBhL6YeBvyhl4gIhAKqzmcKmWCeXo/JgJksr\nPmTD5i6Cc96Svlde6j9XT1DH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaKQx0Z8EGFgYQmCrq9iCylVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjVmNTIwMC1lNDcwLTQ2ODUtYTFkMy1jZDcxZWFmYzhhZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwgaYpP6sJPE8gHDzhdjZlbKDyqF4G9xLEHhSK41zdkdgO\nSxmP/DJ1bceHVloy/6wvuNdtDu6FwKf1qhOkyzN8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUweJI8ysMCNeH4V8+sET6hvhA\nrEcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfA4JFC5H9Je8vm1ACtPPtzBVdYtXWGwBMVHUBYKc2JQCIQChbhEghVZx\nlTLzVpvvUoTYZIwIv88E04L2KBpi9rD8og==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAezftE5ULJmsCvkkZIv+nR1eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQyNTg1MjAtNTY2NS00YWMwLWJhZDUtNjkxZmNjYzA1NTNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNjI0YjVkYTItYTU5Zi00\nNTI5LTk4OTAtMWVlZmViMTg5MjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n+70fA2jGvN2jJzH6HY481TNMdyBrmqwPAySJZeMctXtYwg/sWTSl+DVqT6Xsusrv\n5Jlez2thJRdeeUu8xYRx2qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU0Ku9V9Aq5M925Ug4\nFfbisp/TfVAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCICaB+oSayUlVWzxZip/7iIjZGRTZr5aiEpQClocIO/15AiEA\np29DB1egO0eEkjTckKKzcTkOJJJOepRWfQCmkbsjbuw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8708", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8708` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWTCCAgCgAwIBAgISAXNLPyjtTCe5yOjPabKsFc4+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1YjM2YWNjLTZhZmYtNDMxNy04OTJjLTY4ZGI5NzFhYWU0MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJlODk1OTUtMWI0\nOS00YzI2LTliYTktNjMzOTNmYzJhZjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnYIe3di22JAdj1zXysijwag+RSS1ittgZSA5WOYLQqJB9L6+LgjQL6SXbdxi\nmxcYZ/kLCLgC4SHZuzwyxXf+ZKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfteVk2XPpmZSRXXCSmIgtrnXU9wwHwYDVR0j\nBBgwFoAUF2GR0gM+Eoo6ye5ipv0sBGKjf+cwPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA////ADAKBggqhkjO\nPQQDAgNHADBEAiBvDwvENS6JCsxNLGh6Evt+v3emrn5+TLi+aY8n91rb5wIgP0vU\nPv+zdXQB3ZW9dqFLW1Jy2pm3s16T0HZf0QFeI4Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR6vFSx9nd+iY+kN2CjIfAuQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNWIzNmFjYy02YWZmLTQzMTctODkyYy02OGRiOTcxYWFlNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARps1ZaWzhrNJao9CHl3UIRK6+Vxx+FFHrFFzGrQUok69uK\nNK1REGNAypAS8MZZgrK3fANU/TtClmAv9YyZLBMFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF2GR0gM+Eoo6ye5ipv0sBGKj\nf+cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL6E5AXpBVns7ALeWtXKP34iJZanzNyCMjabF6+/jcnbAiEAy8IMz7Ih\nYIquNynLzQCrinqRZDtlpMUUgLHsKWaly/o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAUsHB9+zGHp6niodBqNR8zKhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJlODk1OTUtMWI0OS00YzI2LTliYTktNjMzOTNmYzJhZjI0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODRmZTdiMGYtMzQxZS00\nNTFiLTljZTYtZDJjZDM0ODE5MzViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n3TNzTFTVLmdPBW1c4Y+vH4+nsSTBxba0rYps6nhj+2eoGNrpd3V0BaGSkfJHfsXI\nSTkFSIjj2w8/s3Eq/IsAkaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUfteVk2XPpmZSRXXC\nSmIgtrnXU9wwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCICJztgDxf0q5XkhI8PpRIJkj9AcLdvS/YnzHS+ZmtkCyAiBo\n061IQ1tyeGyV2lpvU25wTKRLsHtJTw5ZRxNVtKT17g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8709", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8709` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISAZgShT96LhMj9HJZTd+CyZn0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA0MDhmNzA0LTI4NTUtNGU2My1hZGZhLWEyNzJhMTYzZTIzYTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWQzMjZmYjgtNmQ4\nMS00MTcwLTkyN2MtMTcxMDI4MDNkMjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUIyQwwY2kD5qIBTu0H/uEIuABqZ1Tmpv5BoS3c/jcwu7CbQERFMu9uXTHbYF\nzaD/9qfZbBjblThvly69th19/aOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7l3u6YrwJUJC7qTGRpnnixtDAoAwHwYDVR0j\nBBgwFoAUKCmC3JFdSvy0/pR2Ld1RnsA9/dowPAYDVR0eAQH/BDIwMKANMAuCCWxv\nY2FsaG9zdKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA////ADAKBggqhkjO\nPQQDAgNIADBFAiBJRT6a28/dCVeKyBgHMOsvn1TEkybJDDz9rx3R9xRaKgIhAOkm\n4l+KDoLNo22jDtPb9hE5NjtP/AEefSmOcwoBjMk5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWd6xEgZNBGYcUvyPleCVDqKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNDA4ZjcwNC0yODU1LTRlNjMtYWRmYS1hMjcyYTE2M2UyM2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASh9y9Ha6G900e1cTSYN34L7SU6KN3wIOzXSi83z/20flxI\ndDNlMf3ThcjsjhIu4fupZ6EVz/l8sfCuat/7mRwao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKCmC3JFdSvy0/pR2Ld1RnsA9\n/dowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRT2zPOSbUJOGdk8OwA4RmyruCtG1vVIk4p0owuTkoW0CIQDez6T3vemr\nmCoAmDhBuWCc6vz0Z2ccYOXpD8LU6sKHEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWBLiEBiGNN+YwLfLMb8eC6HMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWQzMjZmYjgtNmQ4MS00MTcwLTkyN2MtMTcxMDI4MDNkMjg5MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYTYzOWUwZDQtODBjNi00\nMDhmLWJjMzktZjY2NjgwOTU5M2RiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nH7EQfTxEPzFYI+YWZAJFYCafO+BcR1Sp1W6f0pVNDvy7M1NqWs0CnU1riUYhw7LZ\nLyrccDPKk7HRGupvE/3WqaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7l3u6YrwJUJC7qTG\nRpnnixtDAoAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDLiBkyc/h6NRC6Zkk+4vfLp1KH5O2KgydmspwGB1qaOwIg\nRh9i1LTeijclD7RGpfAQDuxy3fD6zDmnqZRo2tNA/Gc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8710", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8710` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISARCto0XbP3OPyj/Dpc+UyTm7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NjA4NDJkLWM3NzgtNDMxYy04ZmRjLWE0MDRhMGM4OTE1ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Q0ZTU2NjktZGQy\nNi00ODg0LWI1YTQtNGI0NzE1ZmI1NjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp9UNL4QUAfAgOP7tOOjd5l2RMDr+OKRRvAfMcXY91zMuilRUmnG+cI31V3Hu\nG09NNp7OkwtFvO3S8mEQLgnfU6OBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnvuCYwwKt7jFui3ryqMhPYcfE0gwHwYDVR0j\nBBgwFoAUdOB2AnR7FCW7wqjI/GDUsZlLPtQwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////ADAKBggqhkjOPQQDAgNIADBFAiBK0gqD3CSL5YJt\nRqC3Pdg+IRdVLDwfhJQ0/kXlBUH89AIhAItm1b7juA2XrhAxG9TZwW5Vzotwus6B\nqAhsdA0h4PaA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfmuhkc6E6TMnt87CmO1FHSqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTYwODQyZC1jNzc4LTQzMWMtOGZkYy1hNDA0YTBjODkxNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTjvi3dGrBmI9HWldPMFBUPPUpzHshgSiRJ2L5hKMPISpL\nRncshIUIZXXxuzV3dkWYm39ec+SaVj7tcW/mndm3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdOB2AnR7FCW7wqjI/GDUsZlL\nPtQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOCxbibRo3jpFfCjeNpiL8JcPlV4M5l7XrkpFlml5k6oCIQCHo6dcco9w\nE0umJTTDp6nqs5v4s9/WMxTCHFGeI0PViA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAQm31okxSgMYmi5yPqOjEQURMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Q0ZTU2NjktZGQyNi00ODg0LWI1YTQtNGI0NzE1ZmI1NjAzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZWRjNzRjNTAtZGRkMS00\nNWQzLWFlMGYtMjAyZDk5YzI4MDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSap3MddnlB4fRIUChwmsjH3yuG/tphl+bOITaA89G8/HCO5qC2xCT7zowR1Qo7CM\nJBWPQ9G+gxVztgc5BIu2LKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnvuCYwwKt7jFui3r\nyqMhPYcfE0gwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIBaOioB0NFbzegnWMi8CFzJZIp2cEl1xYJOqZVpvtT/HAiBx\njj2jRVhYx8UkiAu8et8ARVSkXFntphFjanQRZzaiHg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8711", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8711` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUjCCAfmgAwIBAgISARZVA7MXb+KtUdWiApMgGE1wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhZTUwNjlmLTdmYTktNDhjZC05MjVjLTljODliMGIwNjQ5OTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI4MTVkMTItN2Zl\nOC00ZTJjLWJiNzQtM2IyNTIyYjE5N2M2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyRlt0H8YFmftUTdIqkoNmYUZ1Yxvulv0m47IgdSdD+mskvdOYjaMe1eYuTjY\niPC/JnKL+jmol+v0trSkEyrYAKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzHYrhwILsrjlCOwZ+jhE4LF8viAwHwYDVR0j\nBBgwFoAU9Gyyb+EyGVzpGFm3uBD0k4gPHFIwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0cA\nMEQCIDX2jt7SqSQEonqCne3KC/MZ8iIZyiuO416Cheh4LvEYAiAJK/25S5iVa5Qc\n5vbdQ0CA8H4NRGSptgeOg3062gUC8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXDldTLpVES0Gwoeok5d3anlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYWU1MDY5Zi03ZmE5LTQ4Y2QtOTI1Yy05Yzg5YjBiMDY0OTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJ02k5F8XMmEtoOGz5bn0fLVkJkhPeQ1430ZnnTl3AtZeX\nNhhDWBOT9N6f07cUEudxDlYEKPfcvwRJiArHbbOwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Gyyb+EyGVzpGFm3uBD0k4gP\nHFIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN6P5DxS9J761eMbzYEfu6egKeRJhIkxRIggp/vXKl9OAiEAq1eVQF/8\nVHKBZcPMwFhOs5XaOhBxAnhxtQCCdzxGjnc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISATpc66yl7lGPH3+3PQwLaLJbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI4MTVkMTItN2ZlOC00ZTJjLWJiNzQtM2IyNTIyYjE5N2M2MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjAzNmJjYzctMDI2Zi00\nN2M1LWEyMjgtZjEwOTEzYTI3OWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nYww/9HLya3MmtPvDrHSyEwUxJFEXWtq1e+q9tbiZS20ZPgAWTZKzQTx3jRetU1mw\nyySxdSpYRlh6seHleKd5qqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzHYrhwILsrjlCOwZ\n+jhE4LF8viAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDTmw0toqvnsLEHE4yowOQ93IHkkMCl/j6bUl1wToOJpwIh\nAMeWbA3GLjPqbXJJJvyg6EPuDJSLVqyuty+ga76+L22g\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8712", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8712` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAbpLUOS/D/xd+dooTwqXYRKKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NDZiOGFkLTgwMzAtNDBlZC04YjcwLTgyZDcxODllMDNmMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjRlODkwZDEtMzlm\nMi00YTQ5LTgyMmUtODhhYjQxZjljMzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhhPAW+cvMDR44K5WxLin2In9N0/gQ+90HK6BFXUeou6vT6GS23tARyqrb4P9\n8LHrCayHCZUSsEabEA4r7aBPiqOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyoPassuqqxpdG8MJWJzFbTupj4cwHwYDVR0j\nBBgwFoAUvC1YhDZkyR1fvQK9WUTU+0YKR9gwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIAMKJUjm4SquuK0Xhb83y60JYcDMa/62jCW54THBQdyoAiEAk4k+GyTYKo7J\nOfipRgXI/QJu8EEpTN/tsKhK/AYMCDM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe9VidLYuo2dNt/szR2AmgEnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzQ2YjhhZC04MDMwLTQwZWQtOGI3MC04MmQ3MTg5ZTAzZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5xoM3CE77X6fYg9GMmMLvRau3uyk5Vregc0gFBDLmtiO0\nBlHWE94ehiTT1hO8V8zsGitYjDc+mSXvyWdV1Cfwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvC1YhDZkyR1fvQK9WUTU+0YK\nR9gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPYXzb+GYnodzVsjCxi/M6Tf2S+Jwwpbul6zO8HisQT0CIGydxxk1ITGn\nuxNGlLuAG/JKS7C0wvOU1Mc/oGJfvj0Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAfajCgibPZcOfcfKteQxugvPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjRlODkwZDEtMzlmMi00YTQ5LTgyMmUtODhhYjQxZjljMzQzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTM2ZDA2ZDQtYTI1Ny00\nZDBmLWE4MWItYzJlNWI5NTc4ZDdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsAU3IZcGrW/TeAQCUwntlB/UPlFVSMxqKyHv8NFxMUPWQQejKGbRs+n7rHxos2wZ\nKNzblVTNPAFG+N62Z8xByqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUyoPassuqqxpdG8MJ\nWJzFbTupj4cwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIEvhx7oYZY0lpTwA5kCuLu8Y7oDJEcrPEqbbOut478+qAiBk\nPQn1UF/qJPSMlumgB7xDj4RGJtfBsJ7FfiS7cHuoEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8713", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8713` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAbDSAwelfXxZthQ0JSfF2mQaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjOGM4N2JmLWM4MjktNGY2NS1iZmI0LWZmMzExOTYzYWJjYzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFlYmY3MDMtMWE4\nYS00OThiLWJjNWUtZmZlNGYxNDk4NjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC4CKRdqNMIBc+26qaRXCb7tllMeDmZdYhc9iWXng+H2gqoLc1zazbpqhkIRl\n5JuWWLTkcMK9VydzuR52eeScSKOBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbZlrz2IpSNy3j8JYNVJHpcyDwSAwHwYDVR0j\nBBgwFoAUPEUpJGwkQns89PTMVNfpMMVLkQEwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiEA+w3C6RsGRhABHAQOIrdoh8WFxDLYMu6aGc1zhhpAUXICIFnykvgewOZn\nrkrW5kLyQ9cIawcsqUuN4KZgSKprjJw3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZFQsMUrg7ZAmkVxPWbrYX3uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzhjODdiZi1jODI5LTRmNjUtYmZiNC1mZjMxMTk2M2FiY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARSPqD9dRcF9iircqgYHVHnEFBKzWKR/x+KNUQmizU7Fx/p\nVc+qWEMMwG29M4tALJ2DKw91oqu/VolBcG4oVUOZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPEUpJGwkQns89PTMVNfpMMVL\nkQEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgY1Dr9zRVRjBAGEBEawCbj6jBcU/1ZawMoFffUeCj6DsCICISSf+GPaob\noPmLV9Qimza68wuEOQxR0PaZXxYErNcv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAcfU26/0nYpT2JFajWowcA5aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFlYmY3MDMtMWE4YS00OThiLWJjNWUtZmZlNGYxNDk4NjNlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2YyNjc2NzItZWEzNC00\nZGI4LTg1NjEtYTEwOGJkZjU4OTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ns0iIecCxlti1BQpcAIiBNPnEh0FoJDEnVrQFEjKgVunlUN2A2hJCsTuiw67vKzP7\n7SqDX91mSP429jc+hqf3ZaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUbZlrz2IpSNy3j8JY\nNVJHpcyDwSAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCnSGOq6TYhI3dkH6onq2GU4bbGZjgzXLcz6e1N1XC5JgIh\nALOdUJ6KgSl083a5M1F1MwT3zjQyZxhJd2DaAsRSP3Nx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8714", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8714` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAXFEHch5i5LuVkfjZDoSsP48MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5OWU4ZWVhLTU2OWUtNDMwYi1iYjZiLWYxNTZiZTQ3ZDQ0MjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzhhMjFhYmUtNDgy\nYy00MWQ3LWIzYzQtYmUwMDU4MjUzZmEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4qDLedO52ZVjOkEuyzQvEU9JgpbNJqCzq0K5R3JbqaOAiRm2lOnHEpn6ptwc\nj2AlmLrYIcbiBIB9sVHHw0HfpqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJqIl/PgOtyn2sTXV/vsOUsKUpXYwHwYDVR0j\nBBgwFoAULpzTvV7w19tVh2PU202Bt3UUabkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNIADBFAiEA//+yNklfqcS9+Gi5iL/qOnlGYqhyAAsofySyeqpx\nSZsCIGuiXcZaBTTiL6Xf2PFHOGvLm+fOIeJXry1J2wma6wJ8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcQINEsgviyhZlOvC/p7oyVNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTllOGVlYS01NjllLTQzMGItYmI2Yi1mMTU2YmU0N2Q0NDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCNHVIUv3uWQl47GalrMdLaZ9QbENrNVQoKvZAa6f9rTkg\nYycDlhfDnG5pxNTOw/7xc2r67uKGIaVI2ZAc38Puo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULpzTvV7w19tVh2PU202Bt3UU\nabkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJyGOtKQ0bZKTLUQ0WvuC/dwn23XomYzahAEQXgRXKRACIFVx3FgBIS+W\n6CWxQ/kvojYLlhsgrlEoI2Lj7gS8y9Pf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAXImxn6fZAX2KGpQT166Y336MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzhhMjFhYmUtNDgyYy00MWQ3LWIzYzQtYmUwMDU4MjUzZmEzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjU2ZDczNjItNjZlOS00\nYjZhLTlmZDAtOTNkM2Y3MmVjYjdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nxM9PrhA0Oh5vmMSohHCdDf1b+hyPXdD8XrMNW95Zn5iEBoq2fndFJf6iqixl/2hk\nZjhUa/rghHjQe9ScXRYMQaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUJqIl/PgOtyn2sTXV\n/vsOUsKUpXYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIEpTM7iNRyy9gSx99PT+sb5ehMg0juufvTJKFnDeqMCPAiA4\nGPcUHrny1fb9Q0DwcbJ/Aa6E+yJcxEWTyIGZoXk/MA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8715", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8715` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYDCCAgagAwIBAgISAb1iwm+N/EeAx8Zp8w5cSsBtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyNjNmODU1LWViMDgtNGE1OS05NDdmLTQ4ZmZmYzE1ZjEzYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RlOGY4ZWMtNDcy\nZi00NjNlLTk2YWEtMWZiYmNhYTU0NDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKGoJaInwnU/+4o7X4mylXsLRPxrvsBr7rIdbYhmjcisj4XXBF17A5HwCC4HI\n8/qA3B4wDKOrr3wVNpekCe3F0KOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmyk6Xs6R3c4RO9b3D/AG1UA4eCUwHwYDVR0j\nBBgwFoAUM2pSNQoZYu2r8y40TMrqHiH0ri0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNIADBFAiEAxjotCedHe3pTEMMb7AXHeshF97tMHSG0eGL7wlBI\nyo0CIBZnoHXS9ASv8OmU5uMSOmXGgg8IUi+keIQ3ZoDySUqt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXWtgBeI3aBDeN29QFQ6vgFpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjYzZjg1NS1lYjA4LTRhNTktOTQ3Zi00OGZmZmMxNWYxM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqJwZLiNBBSanb+k6P7P9fpLxwV9sdMrc55aPFze+CGZ3T\nTboV8qJ9Yj+aMuOcAu/jQpA68/idADBsa669ZuVho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM2pSNQoZYu2r8y40TMrqHiH0\nri0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIHs7pRVo5D1QZ/VCHrBGQAKN9aM4lVghkS2CWBQ3sKdAiEA4NNYYuAM\nXTqgEYJJY4oUAvtZ7ZWWSN3oHIoq2rb4AiY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAcp0To7Iv3DKhKohfPmKeEaxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RlOGY4ZWMtNDcyZi00NjNlLTk2YWEtMWZiYmNhYTU0NDhlMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjYyZmNjNjYtNTI5Yy00\nYTc4LThhMTgtM2Y0MzAyMGE1ZTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\naIAJeYmOZ1dpJQuIBsBr04gMbHFI2nRjLfdcqQ0zb2afJ8lK6dbd6GjIHYCgYhoR\nHeiJqHaCsIhFPTa2KunNaqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmyk6Xs6R3c4RO9b3\nD/AG1UA4eCUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCICL8/XYZrHKSBorj2+WDV0D3GhmzibPROFC5e39WxXagAiEA\n1bLPJOe4KYUCkiDMl+WyawF5mOXwe3gBVPDsjGZ5Pr0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8716", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8716` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWjCCAgCgAwIBAgISASMo8ooEEB0Rc2r1hwxM9hcoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5MzdmZGU2LWFhMzctNDUxMS04ZDJkLWFkZmY4YmE3NGNkMjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVmNDJiNTEtMzA4\nZS00Yzg4LWJlNGYtYWE3NWZkNjQwOGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWb0vmXO93DEofjISTeSFYjTmwX2oGqE/5+wi75loo86LfCUc6UcKHTKaSnwf\nG3D/Mvu9No7QAWi7U20INnEswKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+2lSq9ASBw6VylL2da7pc+BrBCcwHwYDVR0j\nBBgwFoAUiWgK5Grqqr4i5RA9zWO0DPG5LcYwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNIADBFAiEA8hWSF+7a9nnK8+mbp/dpn/5vkdgGWimMW488JGp18E0CIHC4\n6BlVtjROM1YsF5O1mxnc+ZTOjjLhh6xYazbPDm/A\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARQXwlO6nEJEQ/Z5gDGbIBLUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTM3ZmRlNi1hYTM3LTQ1MTEtOGQyZC1hZGZmOGJhNzRjZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOfYMebsnsp/B1y3FXAK16hCvXMriPlY3Z/WpO89L8vOLv\ngsEMo4hFV/KYZ0tRw2JmRsYz1LbsD8vzY04MiIzWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiWgK5Grqqr4i5RA9zWO0DPG5\nLcYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVf3WlUICTJFXEB0x/u5kiv7ogX0lAGCbfg26s/s7wc0CIEZfWH+QZjMK\nl6PTh8ZxuZUS3hmZtfXqmyjynzRuT5Is\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZJ05J0X2gc99CZX9CzNQH8zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVmNDJiNTEtMzA4ZS00Yzg4LWJlNGYtYWE3NWZkNjQwOGU3MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYjZhYTVmMmEtOTFjNi00\nMzg0LWE2YjQtMzYyMDY1OTZiOWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nlbpjyLvVGtqU/J8G1FzLo04aElgMorQk0e69vXtagClHhTloPWhLJLA5bHfTwsXN\nJOc/JikSxo/d6G4yN0ujFKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU+2lSq9ASBw6VylL2\nda7pc+BrBCcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCELeP0S9nWPInfZ7TY7euFgRzzzr0avabj1JxTQa4ifwIg\nNGzbh03jAGRDR3FdkO7ZveO0rgrowVMTIJgQ38b2muI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8717", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8717` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAeyrUCd3Pbjb9NU0FQ5Nx+98MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkMmZlNzEzLWI3YTQtNGJjYy1hZDgyLWJmODI1OTkxZmVmNTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDFmZGUxZTMtMmZm\nYi00OGFhLTkzODQtNWMyNDFkMDA1ZWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHdkb36kxS/eXhFIgdXXccGio5JZzmqCsQJHx6wVfBAonFCqX3pJ6r+Bk6s2o\nLL33CoLTk6jS3LdR+fgbbVnsaaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/0BKxae28wQh3o7DuxC1/SZ+bIgwHwYDVR0j\nBBgwFoAUrlhY24Uv/Dk4rHKaSL1y0BpivEIwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAMyjyWP8dIYSoH16+jXDU0Vh8H5kzdKAEv\nZTwqHLNIMQIhAKJ6fFx+hBACiqawaiYhb3oRtT6eIvhr6dz57AscCHPk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAShKPoLrDZn4qwZ4mn01JPcRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZDJmZTcxMy1iN2E0LTRiY2MtYWQ4Mi1iZjgyNTk5MWZlZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUp+sdNjyNhZ3tvkpRVaIsjr3zgVQPga3vJ0oDZNJQD+9E\nAwjXgMw8Iocn+b8AyHhBICU+QWyPB9iSjdUgseaEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrlhY24Uv/Dk4rHKaSL1y0Bpi\nvEIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANn/wK5R2VppuFF06tfZpTdYV4ZQlF4xIzRxcunirS5jAiBCEKgo06C5\nAq+CrOEpy+Xgsv07WloRZJ2liyDFNjeTQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAYndjBEhT4u04Cm1HpW9KpcoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDFmZGUxZTMtMmZmYi00OGFhLTkzODQtNWMyNDFkMDA1ZWM0MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTA1MGU4NGMtZmYyMS00\nNWRlLWJkMTMtM2I2ZTRlN2I1MTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWVRsRMkEyanGqPmODeiI4NqJu7B4U5llLSrOcgZLXvPpG+Rc5+ck7G65fLGDV2BH\npy91zeeCiHjgKTQ2k7ZiVqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU/0BKxae28wQh3o7D\nuxC1/SZ+bIgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCwjwcpvwt77JjUD4pS1srFjBSAp7rRAnQucjLBsk2XIQIh\nAJVBEdvHBivLUErlh7uKRyVNHTpgqtd+Mg2Dk6OG2T2S\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8718", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8718` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZjCCAgygAwIBAgISAfUe9pQex9BJpzCmTfFSG4SYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhODAwNGMyLTIwMjYtNGZiYS1iZGJkLTVkMDU0MmY2YmY0MTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ2YmI4M2ItY2Nj\nNy00YjMwLWE0OTUtYzJkMjdhMTFmNGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwCwjFEA5Lo6pubclKMjusD2yXmR+x2HJz2e6nAGfi5XP9c1voFaLokN7YE7K\nzCWWuXoAnHSFyZKFJ1LigJzkYaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNBNi2m4hGP2d+prNXhuQopu4hzMwHwYDVR0j\nBBgwFoAUNHbZazgBq2rsFYhpcdnLaQSgWRUwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwh/AAAA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBRyalRrmM6huVSSugeAoYIKWjSeDddW1Ne\n91hZnxC7iwIhALcjQyIP899kSmZGYw3tcEYlJbi8k+O7YOT6XvXSq16w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAareQswtFNmQvAYydOlmgo8VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTgwMDRjMi0yMDI2LTRmYmEtYmRiZC01ZDA1NDJmNmJmNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpnVfmddWh48bofdxzEO01dlwGSiKhY9sQZ+TZaSIQX58+\nU4Mh+cwuSJKbjYxBU4stwbWSKSlTTo6tX3a3u8v9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNHbZazgBq2rsFYhpcdnLaQSg\nWRUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM3SZInrofrczyrYCTLNdwBwLyGKZeLtTCt4luEKh29ICIFCGsBoY5lzd\niUMf6MbkwDnsu52mlnKlEu3MPboe0I5Q\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISASeGzqNaNqFmrrAzPNOxZFedMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ2YmI4M2ItY2NjNy00YjMwLWE0OTUtYzJkMjdhMTFmNGJjMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDIzMDU2ZjgtMjRmNi00\nZmM3LTkzMGQtOGYzM2NiZWYwMDQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n0WC53dyhccrwgaKwQ7gfd938XCm20BYYlLC5fgXcOM0PKpI8RXpAy31yB2PJFjSa\nLTjOYz3uxTT46eKavjzuiKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNBNi2m4hGP2d+prN\nXhuQopu4hzMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIHtzvf0+ZfKUneZiBMNBiDLwlygU38ZEnre6102OVZYUAiB8\nnkfh4AXm8W3tooW9YEBgY2wSgEyR5NwWruGTkSPKXg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8719", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8719` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRTCCAeugAwIBAgISAerm1EEFhmeuIsJOo6HeNzYoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0OTUwZmVlLTI0YzAtNGI4NC1hY2M0LTJiZTk2ZmU2NjEzODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgyN2NmZDctY2Zk\nYy00OGU5LWI4ZGUtY2Q0ZDVjM2E2ZGNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtxXOyfLr/t2cHy2VCcWHQ6mUMfA2lXvez6miuEvRr6e0Hem9AHt/ZerO22B2\n734dYsAbUJ5O7/ItTLqEnoJ0tKOBjTCBijAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuJYPspoupACNdEDobqVTZ82fLzQwHwYDVR0j\nBBgwFoAUqsoK+xvqCmm1SG/N4eN3RVu3ypUwJwYDVR0eAQH/BB0wG6AZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////ADAKBggqhkjOPQQDAgNIADBFAiEAg/WkWoFpsUa8\nvLJWVz9lFeFTyqJRGdHrhoGn8fCOV5ICIC/LikO2D9hd18oSXDUJzsPu2u6pgXi3\nsaEqXvW2J6wQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW1816h9ETo6nSGgHC0p7JwYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDk1MGZlZS0yNGMwLTRiODQtYWNjNC0yYmU5NmZlNjYxMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGyKTYvq2R0MeDpFjFLBuNOz1yC8emPW96kamiESNzJtZv\ni7SBa+tcIIkQShpGdTHv0FQTtTUvpQF2+S2c6rqvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqsoK+xvqCmm1SG/N4eN3RVu3\nypUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdgoR/Ygj90IZ/O7N39MGrGC46e3cRNgaBreiiDs82NcCIHGJbFk133gG\nWzcSh4skXmt3IYZFPyiCNtVOGDmHwYJy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISATSLdQqiFf0VRdn+OdCE+6n9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgyN2NmZDctY2ZkYy00OGU5LWI4ZGUtY2Q0ZDVjM2E2ZGNiMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjBmNWVmZTktMDAxOS00\nZThhLThhZTYtNWNiMWEwZDQyYWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nLpmeoLxKbNPVHfJy+WXzgIUqMbFrXe4jBvCaWJu7epsE/5MrLJX35YXT1FkbOQ7E\nROdXnGEqi9VRcSmkWURrxKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUuJYPspoupACNdEDo\nbqVTZ82fLzQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCAWuxD5eQ7qQM8ILz5aEBEjfp+hQR53mrhQ5UwCj6SMAIh\nAJsZcRvQmifPhhJRzmKd9jlGTvina/vbAOR9PK/pCFcU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8720", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8720` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISAQsIRMkeji9RvPYQUNT38A3QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2MmMxMzY4LTI4MDgtNGVhYi1hZmFlLThiMDU3NjM2ZmZkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmFiZDEzMzctZTVh\nMi00NzM5LThiNzYtMDNhY2FiN2YwODNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdk/cFIZyQstJCX8X8zK/Ad4/25nNrKJD/aYqJqCb2AG6m68hVDT5xc/sEZB1\n6cnPRM+oJE0ianNET9p/hYMSkKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIfdB1tqjiGz/CykCThTOj6vSKx4wHwYDVR0j\nBBgwFoAU+eS0dgkH4iC0QZCNqaaWWkt9UFEwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIQCll5DVKrc6cIdPb64ccv7zDZOHlbTCNgjLJJeolVsoVgIgX91jq4nls11I\nY8Sqqg27Ew1VEIRs8SXNrr019KbPXBU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ88NJUgtcUqCJj88+GemRPlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjJjMTM2OC0yODA4LTRlYWItYWZhZS04YjA1NzYzNmZmZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASS5rEsDkm3qNsTkPB8ZfcR6Xk2axapKXxvI+3SDhbNU0eg\nA/hIvRkJLrl+7a5yDnbtKypIdmTwQkFm4JbVw4Oko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+eS0dgkH4iC0QZCNqaaWWkt9\nUFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXjOLR2ymyHW/AdrqlbiwXG6cQM6Hpth29gdVcmCFt10CIEyYv9zhEx8q\nXEE1IlgUfOtR61kXDxsP34ji2CNG7+UP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAZqIAiQSeUts4RSHGhm/G5DaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmFiZDEzMzctZTVhMi00NzM5LThiNzYtMDNhY2FiN2YwODNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmRkMWMwMGMtNDcyNy00\nNWJiLWFkZjUtOTRmYmZiYjUwZjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ncysdIEMFSKnuhUS9mh3XSF59pHXE0NO8chhI1m+qC8cLtAZ7aFqAMm2FMxEJDTbw\nbM4SRh5EU1QVTC76ieKFN6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUIfdB1tqjiGz/CykC\nThTOj6vSKx4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIA4CW8O/Z+Z3ZaYlqNvnFi/mlTSiEae+169O2ISro1TNAiBB\nOGeQkBaJG6NMUsmT4Cp17RJUwROEYe6T2UG5+0t+xA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8721", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8721` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUzCCAfmgAwIBAgISATlewxxHuEaxQHSl0YBbVgj9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2NzY5OGQ3LTE1Y2EtNDc3My04Nzc2LTdkYWFlYTY2MWZkODAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQxYzU4NjAtMTBi\nYi00ZTBkLTliMmEtMzNlNjg2NDk2ZjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/f+fU7VExhbl09cCPynes3zvrZ+by9J0tY8FNy+7DwEzq8nH6vQBs4wSB4ci\nZNCFwg6sIg8WpjoB19k9Mgr5nKOBmzCBmDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5sBmg01zSSHRvEMigSsDzZiHkO8wHwYDVR0j\nBBgwFoAUVwqoC2UUuQDMlRfzOFrp+1QvwRwwNQYDVR0eAQH/BCswKaAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEMMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0gA\nMEUCIH5rj/zGM3mGW7RS/tX+d2gic4xorIDcEO0kPv4gciaKAiEA0+7pOjgkFsfs\n7S0uKqjhhuvAiOQz/XhauQG+ebwbvJM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUhdi5k5Cx/vsO5c3MutgVVWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNjc2OThkNy0xNWNhLTQ3NzMtODc3Ni03ZGFhZWE2NjFmZDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4Q9VwxENbYXMdqlwQ2RUw9TtU9yADfXaiB8lHUsuqU9ay\ngO3XjVEJYCZgrJMSNak7AMEBLI5HYGaHiUC17z5Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVwqoC2UUuQDMlRfzOFrp+1Qv\nwRwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYOSpWa2St1J0Xym/mnBumXLCyI7PsX1fi11eR4bMvpMCIHDlRgUbxfX+\noTmK3W8hmm8yWU9NJyIchNwVx2chJIQ0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAdlXVbn6yxAFZy2QRmhSYDAqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQxYzU4NjAtMTBiYi00ZTBkLTliMmEtMzNlNjg2NDk2ZjUzMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNmI2YTNjY2QtOWFkMi00\nNjMxLWI3MmUtYzYzMjIyNWVhYzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nsNEJ9/KkIgPTH0fFUqW9zT1Q6wgo2L60ugutnkt7WR9+n+Igw4Q72zAWDrDbTqiv\nxgJuYD/FtDcsMdIdOArwbKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5sBmg01zSSHRvEMi\ngSsDzZiHkO8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDfiIGVoVe0yAMzzua5KP9xpcHvPoydU8536kJIuYSGUwIg\nShfRDV1m6aUDVVlSL+JKpldhvPhaxsBbO2NlPIYQxy4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8722", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8722` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfqgAwIBAgISAamr9AnTdGo8h6jpEuaNuDkAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1M2ExMTdlLTllMzItNDAwNy1hOGY0LTQwM2I3MDc4NWFhYjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVkZWRjMTUtM2Zh\nYS00MzgyLWIxNWQtZjVkMzRmMDJmN2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN0GGNuKVP7lws3UpUzpzzEt97xRcjLfQruqXpkoqDkAIaS9Y65DqevBV1gh7\nWezXQnc3kixJBZrQQ5wVifi2X6OBnDCBmTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1uponFeR8Z/n+dAtGEBfhggXCTEwHwYDVR0j\nBBgwFoAUiE7buRszVK0nsrxfcOia4APpFBgwNgYDVR0eAQH/BCwwKqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKENMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNI\nADBFAiAsDO9oBOY785CdcG1pgF+YY3SMt7Tg/3qau3dCBhsO7QIhAMC4E/R9V/2p\n2IhAN8wuVPzC330NSiT4jHw6MzSvXwjn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYpzBlcBtOxhS/njwzshn9AuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTNhMTE3ZS05ZTMyLTQwMDctYThmNC00MDNiNzA3ODVhYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuecCc5HUxn3lRWB7EuPZYjJb+DHtBXn1Y5QakSPxRZ11Q\nG2QkcEfsDZy4COZ3ltyIAJ84ZqQRD2l52sGkUgc9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiE7buRszVK0nsrxfcOia4APp\nFBgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAK8jvCe4JDtkNO6S0wO3CYSEWeO7FVT64G+OerQeyx6yAiEAiliMXLQZ\nDAak68HZp8ylo2IwSDkZ+tWwz2cOzgwMW7I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQ4tFwzuvUvd2b5/aa54kAvSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVkZWRjMTUtM2ZhYS00MzgyLWIxNWQtZjVkMzRmMDJmN2EwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzAwNDVhMzMtZDAyNy00\nZDY4LWEyMjUtOTY2ZTNjYWM2NzgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nSXCkdijpVWJwURqxIbhE1RQod2vUichGEhYno8Nt8wgitzE2LUGNmqodp2F7ePfK\nYiiQcUhX6WlyGvS5UFeEDKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU1uponFeR8Z/n+dAt\nGEBfhggXCTEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQColE+GtcK+BMWPG+kM8o2xg6JiTOy86hTycvUZGc97/wIg\nd3+IdauUTIhj/+Kuo+6CA4PU7/ouXFpgUM0iGO6jxjo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8723", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8723` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAdsgYDqQiLMe8noYzzZse5EEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc5YmIxYzYwLTVhYWItNGM2Mi05MzNiLWI5NDVhOThkMjllMTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE0MjYwOTUtOTVi\nMi00Y2I1LTg1YjctOWRjZTIwOTgxNzIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYgh9hWcVASMQXYb51f9bSW2CV1Nc8AH4ZmbiRAuYIXwJZ26bMusHnocUZ7C6\nRlJKtr9oMJmdasqNRAoMmsLfgqOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8FtGe37kGBd5Voes8nrtZDPuyaEwHwYDVR0j\nBBgwFoAU/UaU+K3obRF/G458LeRZqqp51wkwQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwh/AAAA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA9ActgpJTeE5EBwuChqQB2J4i0gnamfG21iRPvIOW\ntyICIQD4cDey0PsMLbZs4ivOHav+KTm5bNLYlUtgV1Gr005q9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAULFFhe5vCOO8B3hv57tXEngMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOWJiMWM2MC01YWFiLTRjNjItOTMzYi1iOTQ1YTk4ZDI5ZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStwgjV8ha5MTfv2VJQm0eQ/hGsjbEGJWjOnEjN/8h7strl\nrQEyrIpgG3iKjrxhptWlSkZCk7+5uDvob6YVAcLUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/UaU+K3obRF/G458LeRZqqp5\n1wkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUnItAMAWXjRgDhKaimz62mzRIXG0GOzaGXg5XUOA+SQCIQCSzZnFodZ1\nCsNBH0/9Yl7PMPu4e6KQKoa/Rd1TCpvf0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISARtH0r6mgPNTf96dsQmP94EvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE0MjYwOTUtOTViMi00Y2I1LTg1YjctOWRjZTIwOTgxNzIwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWRmZDRmNDktMjhlOC00\nNWZmLWE0NDctMTJhMDE4MjA3MTQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nujEVV9CLwV9oI4El718UdR8QxmQ2oFckkkMuH383jXaak3u+k7e53CN0jWxq71Gz\nibZbCmG1DemFI9HAgWOTxKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8FtGe37kGBd5Voes\n8nrtZDPuyaEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIGO7muXzhZykRsgTjSA2Z+kaIprVtgv7zpp/Gt5ouz6cAiEA\nllpxczRybscplgZab0ql1Miz3dX4ZTofY+Vt2pNznA4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8724", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8724` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgagAwIBAgISAZ0KbdsfWhsVqvWaOk9vSzgmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0NTJhZTJhLWViMWEtNDUzMC05NDViLTEwY2MwN2ZjOGMxMDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjE0NDkyZDItYmRm\nMi00MTkyLTg2ODUtZjIwZDE5OTQyMTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5ADObCrtG5RML95SaanRmFCuedQLSEoMiBxTQv09l7j9AwFBJzQKpl1xFq1C\nPTUdmstLSAxeuUFmiJ6UfwzMaKOBqDCBpTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/sIGapoVn0jT8PK0wqMpcs58U8wHwYDVR0j\nBBgwFoAU45R9NdvvtGiHjeXxbmZHEAM7Kz0wQgYDVR0eAQH/BDgwNqAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEZMAuCCWxvY2FsaG9zdDAKhwgBAQEA////ADAK\nBggqhkjOPQQDAgNJADBGAiEA21IMf0DJB6zditJS3PbFG15XYmWUqyvkZzzgBaRd\nJCQCIQCIrc6gK+vmJzFufR7jEwjlleyf6AdnauF56pASrxa9hw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATrIot/Wz7GoQTQ74hxGoOZ0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDUyYWUyYS1lYjFhLTQ1MzAtOTQ1Yi0xMGNjMDdmYzhjMTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFm4yrfIGbGN7qBTnxBffZaCIFU1IRTFGY9x5w4Cfk/mxY\nLEVgueDRC3NUu38OTJUWts9AcWSnDnZyde/Z4Lslo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU45R9NdvvtGiHjeXxbmZHEAM7\nKz0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgS1PoPN330BfpHWnQg96Bu1Ru3BMGlbsmapIpkVKPj+ECIHF2Dk713O5F\nR41Jl+O45z3n/QHp9FfO4hiaqHT9BLUq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAaSwfXENhlqjGIfQ9iAszIbTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjE0NDkyZDItYmRmMi00MTkyLTg2ODUtZjIwZDE5OTQyMTRmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGViZDFlMjgtNDkyYS00\nZTlkLWE3ZmUtMDViMzc5NjMzNzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n1jPeHUcnfJgintDNhcc2T0sYgcsg+i5q5BVoHpG3U9h2bczenDdsd9Kjv+VUMnNd\n1y1A93IAo9ElYWs/y7oLOKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU5/sIGapoVn0jT8PK\n0wqMpcs58U8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCWkszhB9Zx58LQulTD6WfgnuPhmDfzEcR05sE162OTaAIh\nANQkZn01GQKZ8Lhv6G5xEAKs8Az4/M+aiaWO+bUkgjZR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8725", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8725` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICWzCCAgCgAwIBAgISARhi6bzkeqYTeXiTyiM4VIHrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkNDYwZGY2LTNmZDktNDRhNC1hZWJmLTA1ZDlmMmNlNGVjMzAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI5MTJlNTctNTI0\nMy00YzgyLTkzOTAtZGZiNTk1ODRlODZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEha4629+ToqvOieUSE9o8xfjwxIfJzHCOPVgJqCge1hZmz2EdcbLYLFEMpGot\n+qJ6U/xGc2R31Ie+QAqTlx2EkKOBojCBnzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYcrfZWvc5FGqtytehYXW7SBrwAQwHwYDVR0j\nBBgwFoAU/osx13RE75NZfP7KTAzfxuMFeFAwPAYDVR0eAQH/BDIwMKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKETMBGCD2JhZC5leGFtcGxlLmNvbTAKBggqhkjO\nPQQDAgNJADBGAiEAyf1GwNOaEFseKrzoRxuAG3F6sYPuhwB5wAl9RG2wMmICIQC1\n5cvolq7HZFByJHnVeT/Ldcqr0g7YT36Jec9zTpFgaQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATpQ+O9gYp0ooFFEJXE4GWfaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDQ2MGRmNi0zZmQ5LTQ0YTQtYWViZi0wNWQ5ZjJjZTRlYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAn87pPkRuOUpqFzXCG2FuBvfSYzB8okcYxfe3O9ppyG4y\nlAhPg8eCWVISDUsr97iTArt2yHD2vP+c9ASNdC0Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/osx13RE75NZfP7KTAzfxuMF\neFAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH+ZS9xqMX9nYY6lNgRA1tjhVEPkka034sDhohqo0A8oCIDBl+wTxQtni\nvfU3/h/FFqVTDfKaNFp7GZNSElH7dHcM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISATfpyrZE0uMcFyI7SSGuYpL9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI5MTJlNTctNTI0My00YzgyLTkzOTAtZGZiNTk1ODRlODZmMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGEyNjQzNDEtYTQ1Yy00\nYzQzLWE3YjctZDE1OWYzMmNmOTcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n8LDKEzn6I4R1+blz9oU0kQNgN+J7BB2h7IOGYAwFI4p0n9Xtzgai0Sa9zgm1stNL\nJ/L8FxPkLuMmRgKV/WWyBKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUYcrfZWvc5FGqtyte\nhYXW7SBrwAQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDrO5IpLC5oYxqyHfxFmbUdC1zPZTNpUI25Gott58jCZAIg\nPsJQpm9MX25tkA/l8hmCjEtvgw3ttrIQ+hFMxl1muVo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8726", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8726` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAgygAwIBAgISAb48U/z/I+Y/WFRy2nXVYpA5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1ZTgyNGZhLTA3ZTQtNDA1OS1iZDA0LWRmNDc0N2Q2MzI1ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmI1OWUxMGMtMTQw\nYy00ODkyLTg5M2YtNmY4NWRmMjU0NmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsLzlaGOvvn0zMrVDyKQbgmfjVO37y1zgO023hPmmG9Cc5Xju+FW6hgSA5V8C\nI07YQFZwACE4zfTxEKtcp2fUgaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcfmcFEUisn+ba70V0mATKD22+CkwHwYDVR0j\nBBgwFoAUB5yZAP3qTTZA/RAT7Id+0I8yfcQwSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAzkpayrN1kBkYR1kLDLyFjM3CVYGF85j7\nwkR+Bjq4OpECIQDVmJr1uNMI/3DQ1T9LfLZm07BVkXq+nICS5sFhhqlIVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASKwxWDUJn1rva6zy3cQL8vSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNWU4MjRmYS0wN2U0LTQwNTktYmQwNC1kZjQ3NDdkNjMyNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQR2axOiDR34jgYpnf2Sp1HiBu0iKwyk3bCABlvvcMPybDo\nTXQThxRK4rP97JDpjfaYiiK1lJq3BX+Fsz9xscsHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB5yZAP3qTTZA/RAT7Id+0I8y\nfcQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXeIE/QUcXrHrcUf7s+IiyXu1uWwxxZY93oRvWKqX2cMCIQDR/Scr7gl6\nvcBc8tuCL3fM+xx3MwsociVINAuoWaotqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZPq5PEru6cIMYW4lV9ww2rUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmI1OWUxMGMtMTQwYy00ODkyLTg5M2YtNmY4NWRmMjU0NmNkMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNDFiMDE5YjEtZGIwYi00\nMjA1LThhZjQtZGZkOTBmNDcyNGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nT7fWOmAEudd9rzmlsaOjyo+JwGdGGgqtkzsv4d2ywSZf1T/j4hluyNydcQEKzc9r\nsfdOBHx2Zxhtj2gNbQwmAKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUcfmcFEUisn+ba70V\n0mATKD22+CkwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQD45E8X+Mo15I0j+r3TgmQ01Z3UDEYHn6YnEIxFx5hGmwIg\nD/kfgen4QLPMQF5rKmZCr/79+9ac4aTV49lwJ1VBKK4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8727", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8727` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZTCCAgygAwIBAgISAUQ+UgoLiAk01TlmDmcrSFYcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc1ZTkxMjFiLWZmNDYtNDllZS1iMjcwLWVlYzEwYWE0YTc0ZDAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGY5NDc2OGItZWYx\nOS00MjAxLTg1YjktZjc2ZDk0NTU1NzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeG1sS6dOu7ykzlmZd//PPl7lhuxJMK4dAqgYb6yeBUyQQcsRN/+a3GD4VW68\nXmKGHi9S0rK1go4S+y75et+0QaOBrjCBqzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsO+/pLmLIM0kku9vXNDLqy2b9O8wHwYDVR0j\nBBgwFoAURGEJe5QfQUe0Nac/9hoFeiW8mi4wSAYDVR0eAQH/BD4wPKAZMAuCCWxv\nY2FsaG9zdDAKhwgBAQEA////AKEfMBGCD2JhZC5leGFtcGxlLmNvbTAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAxDq1EtWXTqI6FZdVxu7p4asdM3OyUpR56\nwfg4pf3BfAIgYyXKXbTq+3DsIthN4ud+xKqnsS7zu4NXaDS3+u9cXcE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARriNCEnx2WPUxfXjTAWFI27MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNWU5MTIxYi1mZjQ2LTQ5ZWUtYjI3MC1lZWMxMGFhNGE3NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfrHx0aT6oOX6lfq2Z/hihzrrl6p1zKP79jekb3W1DN1yJ\nA/6W0w6bfySUxeBfYkqCu9x0OGZb4LZNS0qp/9E8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURGEJe5QfQUe0Nac/9hoFeiW8\nmi4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM8aag3gkDYbJA1Fqfy3rzdQZ+vNvSmS3f6hyOR+lKadAiA5omWzxyOZ\nwx/yrs8YDo9hvYIlaki632fRF9+dncWocw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAaRVEOfCyqAtbC1IcW6+ciYEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGY5NDc2OGItZWYxOS00MjAxLTg1YjktZjc2ZDk0NTU1NzY4MB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGRhMDI2ODktNzlmNC00\nOTNlLWIxODYtYjFlMWNjZWFhZmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nHMKRz6l9aDiXtn4p6PaP+rZqU6LSB4qWpe0FI4J/Frypbrh4n2WlMTIuAARZ7C3O\nbi3k6PWWwSCQoy21fg1PW6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUsO+/pLmLIM0kku9v\nXNDLqy2b9O8wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIGizh8kL6Esd/a5yEc9nVUND//Jfbz/spKi0DpVO+SyrAiA4\notJSGu4fulqD5spaA8UyjjOZ+CbxWxR+QBUAvz8MIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8728", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8728` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAf0TemA3A2nB6etztOKNQLmbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmODcxYzhhLTlmZDktNDM5OS1iOGNkLTljNTRiODFmYzIyZjAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RhODkxNmMtYmY0\nZi00YWZiLThjMmYtMGRlNjZmNzYwZGQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPcq/ctQGl9S3c+vtwL9DV7VhBm2Gnoiy6wfrneYnsOqZKPkseAOlJAqjd99w\ny0UMIWXBLIawTySRn1e1QMHr8aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHb7LpcalgV8KwsyC3JstWI4iLSAwHwYDVR0j\nBBgwFoAUICdvLA0qR/Rl/c/93fIKd/pvPp8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHwSmCQ1Q83Ro4mNyvNjS07bUeBP\nyB/I/74P/jhvOkrHAiBsJL/WmQ5kSccOMmGJ/ixm24azjbVxAdnCR8dhZW3bng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVD8MF5ih7hD9yL80/7hKHtLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZjg3MWM4YS05ZmQ5LTQzOTktYjhjZC05YzU0YjgxZmMyMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0hOf7aTqF6VfRG0cS+1kn6hucrye8KhWA2TRsmDq5a6Tq\nWyzrHkUusOvmvLGk4w/X+hCLTK+TqupCyaBZk0Uzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUICdvLA0qR/Rl/c/93fIKd/pv\nPp8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI7icwGKUqG0hQkDlqz+vczAjULX7/nSWQapQTgcwoEyAiA7jOU2nd4b\nayuAG8RoNsSUZRDLheDOuT9NK7a5B/tsVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAauhE+IJrvBUUJY1GxogZTM7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RhODkxNmMtYmY0Zi00YWZiLThjMmYtMGRlNjZmNzYwZGQwMB4XDTI2\nMDExOTE3MjU1M1oXDTI3MDEyMTE3MjU1M1owWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMTgzNWFhMDEtZTA2My00\nYjc5LWI3YzgtNzVlNGUyZjRlOTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZ5PjTUqr9sFtQpRg3cVSwiTJZMl9YDiws1PDH7R5i2GeCcRtH5lg1Vmj9ME3GD2+\nJP4ToVNv5OtywzlAaVa5i6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHb7LpcalgV8KwsyC\n3JstWI4iLSAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDDMZvKoJydj/MB3/xhx3aFv3YAZeGBpOCFC06tjN7HHQIg\nSkXtjUdH4E3uGnNir3wdjVTUVh+3yDDF9zCiJQPLsuE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8729", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8729` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSjCCAe+gAwIBAgISAcSc0q0wwVReCyTgf0fLi42sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyNTFhNGJlLTgwNDYtNDZlMS04MmE3LWQ5YzgxODA5NDA2ZTAeFw0y\nNjAxMTkxNzI1NTNaFw0yNzAxMjExNzI1NTNaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTJkMGFhZDQtOTZm\nOS00MTZjLWIxY2MtY2U1MDBiOTNkNDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEn1hnMGdzN/xzAivyphn6zpGRMHyoZebrrpcVWuuznobmOBeE20/ofPhfi2Il\nF1oC87X0qfL7e8HKW62PMh5teKOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNa39Tz0Yaz28bpimkUryULkPyPAwHwYDVR0j\nBBgwFoAUGBfeIiQi9DB+6mlsL1BZnC/F8EkwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwIDSQAwRgIhAI/4IfTx\nELAJb0w96VvmWh6jDBOh5bP5lU4lPmgEJGAyAiEAmYEPU7G+4qWDE1Zkgy/DYPp3\nXa9LhQhgUC0EIzn73DQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUtAevnkjOEVt8KnrJ7Zkpf1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTUzWhcNMjcwMTIxMTcyNTUzWjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjUxYTRiZS04MDQ2LTQ2ZTEtODJhNy1kOWM4MTgwOTQwNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmghxjNxmJtyRR+hVapTTQqRpV59hSN+80j43iM14JkCOn\nu/kPHNCYysGfo2giRl/PahXxMbbXJLRqzh2BZJ9Fo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGBfeIiQi9DB+6mlsL1BZnC/F\n8EkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgP3pesILgLNL0nyuTarpxWXFWDrsg5ZXzTo1++mncQJQCIQDSc4ZfYzRT\n6qUO66ktPi10ZZsCd0Ey6Y8Qy2R20P9Q0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAT7dhEtQ9gSGYhgTTRoXbbHeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTJkMGFhZDQtOTZmOS00MTZjLWIxY2MtY2U1MDBiOTNkNDk0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNWFhMDhlZTYtMmQwMC00\nNmRmLTkzYjItODY2ZWMzNDcxZWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nWsL+c68sJMLRQq9j5H1T3gbUITwb2lg9rQ5HS0eLB4QRgANr2ZfFBEa12UpwhlNX\nJLDdzZddQpgpgKMTOnqw2qN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNa39Tz0Yaz28bpim\nkUryULkPyPAwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQDbySnLYyU4KTo+SkZtCZtTSwunTcj6M40FdSr32T8D4QIh\nAJYnclF2nBLIojWR8u5GdL9tZYSMK7RqzO0K+v6YYhuM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8730", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8730` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISASC2B+6o6QDJ1mF45M4AET+1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3NmEwZTQ4LTc0MGMtNDY5YS1iNTkzLWQ2YWU3OWRiNWE0ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JmZjA0OTgtMWFj\nMS00MmFiLTg1NzMtZTk2YTIyYjkxNjA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDnaIk31BnWMrxQtIHjgwCsjMss2SB5Uv2e+mths1LCjx8Lr3pB/ITsYAeNop\nWUuMEBZIkZ/dUzo/hJH8i+bSqaOBkTCBjjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4tWULPxF2SbZyCsR95KQTe7DZHcwHwYDVR0j\nBBgwFoAUdfkdl8mdH80Pd/qS8h6Zc//r0QUwKwYDVR0eAQH/BCEwH6APMA2CC2V4\nYW1wbGUuY29toQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwIDSAAwRQIhAN0ryLJJ\n+LDMYhyypWIuCDXTXPxysUINrds/uTd99QF6AiBqeonQzqBEW6vzXcAaD/NGKSg5\nl2war2OnqLdTasF8fA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASGIWuiNc35jxTJsOBPkv0dqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNzZhMGU0OC03NDBjLTQ2OWEtYjU5My1kNmFlNzlkYjVhNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRpL1OWNQ1Kir1I1iGbKKcSoE90dX29mTEZH+pu/LX3mdI\nHRiA0hW8JvBTKx8VAPpQEIeksiSXztnA1NsSO/b8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdfkdl8mdH80Pd/qS8h6Zc//r\n0QUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMOdfgwLNC9M8pIQoVHJZBEWHA/KnK0MF6/j+drgOWzyAiEAjoPXzJS+\nhDqsLZVhjbQiQK2OT/Mguvfx+xIn2+gQC1o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAYIepBzWY4oSLooFGK+Nkk4JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JmZjA0OTgtMWFjMS00MmFiLTg1NzMtZTk2YTIyYjkxNjA2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNzEyZDdmZWYtZTg0NC00\nNzBlLTk0MjktZTJkY2ExYjZjMzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nZeV//xEFuwdLWle9RWYSLo25qWcIifixwJPo+iFc/aCEpAh6VwowRtOuKW6iC5wR\n1Ky2OvyIO3NvzLZ9+VOAn6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU4tWULPxF2SbZyCsR\n95KQTe7DZHcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQClfliUqfTupBci5z3J36uBVbIT2q9xcEh5inWVB0OpLwIh\nAKRLNuWpNmrLNEVfntLHxSevN/d72JGVmbYrf8Bm31iT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8731", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8731` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSTCCAfCgAwIBAgISAdJwZ/99/9Wv/skTT600SQ0NMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1NDNhMzQwLTQwYTMtNGViOC1iY2FlLTA5YjE4YWE5MGVmZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFiOWNiNWItNGU0\nZC00MWMyLWI5NzQtNjE2Mjc2MTI5ZTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETiruoK4PO7STMI9lCJoRBf7/USxCMFDDw1Mus5aVrw2e6HQkm+Nd8WoYRToe\nVGrmAutcUXoCCXhH7m5InakhBqOBkjCBjzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAA9j6tNkzQYY+O1MkknscPYpMlUwHwYDVR0j\nBBgwFoAU3GUbEtxUjyG11nKZ0rxwRhppHDYwLAYDVR0eAQH/BCIwIKAPMA2CC2V4\nYW1wbGUuY29toQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIB4tMEQN\n56ViRCaJBIi8jpSJHVAhDJ1VMctX+w06IKkzAiAI5zOzvFX/MsdYlz6heI24rq/L\nbLtKt6B3EPbBLUy34w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaXu6gR2Mg9fGYaYBi3tMVOOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTQzYTM0MC00MGEzLTRlYjgtYmNhZS0wOWIxOGFhOTBlZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiWX3IbAUYQvPd6NG+IGQh/3yXg0sZt6tVYSdmEBVs7CJt\nZP3ylLDoN+VJ3iD8tOO/TfS7AQmb3MZhFsI3wNRFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3GUbEtxUjyG11nKZ0rxwRhpp\nHDYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGCJ0sqQzNSTVGPObZIM8lVoTKlt7np8rOEw7eR5S3kgCICzZeL4HQm1c\nuKNoms6+UbSK5LRmCdVK6XyjAsJRSZsc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAeEGOYViSkPO91yJDXzULVSpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFiOWNiNWItNGU0ZC00MWMyLWI5NzQtNjE2Mjc2MTI5ZTViMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZjM0ZTYzYzktMDRmNi00\nMjViLThhYjgtNTY5M2UyOWQ5ZTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\ndxtxtA04qDUswVYjStAW84FBlU4SvSthaolOkfYS70gv+q39QXwGJIUN746KVpdq\nTZMENjo1PdzhhTPkd4hLnaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUAA9j6tNkzQYY+O1M\nkknscPYpMlUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIGqE1pXxyOXSRRmaeHqj/dmdLDgoPGC91y4r5NIkOVIPAiEA\njWeYN/WRfr3nIb71dxtTsxCL3lC54Sq3P0pA269tFNE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8732", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8732` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAeIgQlza/wDrK8g1BDOZxXZtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlYTczOWRhLTVlZTUtNGY1Yy1hODA2LTFkYTg0ZmEwODg5NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYyYzI0MTItMjY5\nYS00ZDU4LWFlOTAtNWY1MGRiNTM1ZjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOYqs+bBPOHYvUqwtfuaQ5NoXPZhzym6udx3YHt397B6xfrWu9LeF+LnpwZiW\nISAZTT+b+kcaUaDacAwKdurcWKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEeNaVoptmtoApn4VeOBY9EHvYg4wHwYDVR0j\nBBgwFoAUqK4yZGGisGO2y3Ld9e0oWAZcWjswOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIFKoyLKONj1x4CEt2P7YE6IW+vf1bupi7W15+Bn0+aBNAiEAlGOIG7B9\nZhr9cYwe7aWuttWb22U3ki9RY2nlKfZLYoI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYXc8Xk4x1lTShMw8GjH8UUuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZWE3MzlkYS01ZWU1LTRmNWMtYTgwNi0xZGE4NGZhMDg4OTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARQDShh+eyelE1vczEXujpFgMjku40Xn/JtNu2Z078WOswA\n+xrYtdLJlmNBfvF9VsFVuOpB0PvWdyyCJ8jiSCN2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqK4yZGGisGO2y3Ld9e0oWAZc\nWjswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYkRGglZvrpbb4h7wcsa2w+StjqERidTGQTTuFqhcHKsCIQDU2pANtf+h\nBx8qlUVwnaFhbWyZNLPEk2S4DnNEf9ineg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAWLQVHg4bxuSjrVDPJakzYECMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYyYzI0MTItMjY5YS00ZDU4LWFlOTAtNWY1MGRiNTM1ZjY3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzhmMTJhNjQtOGRmNS00\nMjYyLTgwMGMtMzM3MTE3NzYxMzBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nE4EzDmC7QRETIEBoSjByAqfAcvkDIuZPl+KIE/HK6IOGHykh68psy27oQGVtGSeQ\nsTy5Q89v45a19oQYhgRpa6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEeNaVoptmtoApn4V\neOBY9EHvYg4wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIBM9yERzu+AGYvOXE5SKt9AcLs4t4n7cVbCb67mRKrRZAiEA\n25ubXBGNX8a5WhAE2jLtOOVKt2GYHVRey4AO/1PYysM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8733", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8733` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISARm48Mp3XRPF8BOvyfnUT+AqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5OTNiOTU1LTdjYmQtNDkxNy04MWVhLWI1Y2Y1NjExYjlmZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDYxNjcyYzEtZjAx\nMS00NzYzLWFlOWEtMjZkYWFhOThiYjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfJ7HEIXjZmFzyXbCFdEaHW1G4EjSNXr+7dAiPoLeWxyjpB9AItjM+OoN307r\nWrlcVm+iF+IyQxf1Rd2pfcqxhqOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUS7aFdqthcCHNiZz1t1q2TpaSPaYwHwYDVR0j\nBBgwFoAUIW1/jyNvxhINTSb4lToinEcOuW0wOAYDVR0eAQH/BC4wLKAPMA2CC2V4\nYW1wbGUuY29toRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8AMAoGCCqGSM49BAMC\nA0gAMEUCIQCmvy/NrrbyligeRVmiTxJu/jmjyow7W6TYdTYlTXpNcAIgb1lVLS2y\naArob8T4gqnf3vwGLXssMQSwFUm4y8FNVMs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAb+QYsC+AT8xyJ8jkiBFVNB2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTkzYjk1NS03Y2JkLTQ5MTctODFlYS1iNWNmNTYxMWI5ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLciO4mtNwC1tUNzPjGfa9jVY4MXdQVZyJXIoJ/faXEdHL\nt75EOmU3mrWHCiivJgA9dl+TN7hDsZJfohcaKrZoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIW1/jyNvxhINTSb4lToinEcO\nuW0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgG2zocyu+UTEX5QzkSW0iMGgXA7sqSLI/0Bv8hvZK0uYCIATqdZNct5Ln\nPtAP8FQ8wONvsBFGkzKb5GQyDSpIctUF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAU6osuvPUYdP+/h/nVx+s0XPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDYxNjcyYzEtZjAxMS00NzYzLWFlOWEtMjZkYWFhOThiYjk0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODI3NzJmMDYtZTBmMi00\nMGFkLTljMTgtZjNjMTIxOTQ3OTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n/ppY2Vff5Q3UPEirsc1S/3sh0lnJrhH+AhZcWEqSTIIn13C8Rs3/LgIeQMHC2GMG\nW8Oixqrzc2OdnSfo2b+vH6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUS7aFdqthcCHNiZz1\nt1q2TpaSPaYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIAoFNd875eopGNtRXETX2Mazo8ouLgMOR4jaDLGDWJc+AiEA\nqQX8zGOA/X1/XFqw7jJ3lXhy4mL/NpP6J9fWYG9+rl8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8734", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8734` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICUDCCAfagAwIBAgISASiy+g/1ysMgOz6fdtUrL3/FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwMTI5ZmRhLThhNzctNGRiYy05MGMzLWEzNDUyMTlkNDA0YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM5MmQ2NTQtMDA0\nZi00MWQxLTgyZTMtNTEyZTM3MTg1OGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbv+9l668BCSEg7/D17Tk7W1acoi+92bgI/DxBvUPLHTRpfbiW85XBeEkts4U\ndU3RlEEzvHnh0O2IBYNbX1jJtKOBmDCBlTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoRJUJd89X1BEFD1GOMaTBt8L4mEwHwYDVR0j\nBBgwFoAU/eqZLs9ZEneQ5yQvqG59lp5K93YwMgYDVR0eAQH/BCgwJqAPMA2CC2V4\nYW1wbGUuY29toRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUC\nIQCbbbq4d9kTTz+i+ox/UP/1a+PDx3tSa+C+EmeQzNipqAIgAr8HRGA0AE3pqNit\nV3HNCkAdrlX3kW6/7BFBQaq9tBg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAahPMfqKwBGS8Why/fPbf/toMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDEyOWZkYS04YTc3LTRkYmMtOTBjMy1hMzQ1MjE5ZDQwNGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuwk/Iztixr5T7/xiaFCN5bUkw6pA3SQ0FwpK+OttTde+R\nJ6sEVlJiEFxGoI+ziSxLWNe5Kh22dxqKpA9Q5MbMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/eqZLs9ZEneQ5yQvqG59lp5K\n93YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW24VFaAKmGnJBsKGVh1Acd7y2IkLLZ0PF58TwYxa37cCIGSBbPUfjFj+\nlz7xtKlYqoMbLju7mr2OPwEqFLI2CSo6\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISASeFJWAqrPix1Mt5AMxsJkFEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM5MmQ2NTQtMDA0Zi00MWQxLTgyZTMtNTEyZTM3MTg1OGViMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODJkODExOTEtZTQxNS00\nMTBlLTgyMjYtODQ5YWJiYzcwZjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nH95Uog3hY17Ov3aTDiISg3kQAzFel7M0GiKPOflhzQssQEoTa55w7sD3DlBUE8J7\n/BG1rvhOnD4KXYVLRzv0uaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUoRJUJd89X1BEFD1G\nOMaTBt8L4mEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDElny8yQVKif1C/0wTZtdy0Cx76y8JrXKwcH9ecBCLUgIg\nOZHj6mi60T/H4Enw8QiDxRxxkjMQey8sqHFtmPSP/7M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8735", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8735` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAT2OjNOkc0K98kRXvmVHJbMeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5ZjY2MGE3LTcwMGQtNGUzMC04NzE4LTY4ZDYyNTdkY2EzMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFlYjYzZjQtOWNj\nNi00M2E5LWIxYTAtNjYzMmY3NTczZjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoOd9R4GLN1DI76PHcKakx7fbB1jOBfGyybvMcnQplWvpiU2sH4P3g/SG9T7x\n/RGnxscn2GXi6X3Sui6RxVDNkqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUopxMYnve8m4u1AZMRpZ2LVQPQkYwHwYDVR0j\nBBgwFoAUiya5ZxU+ki7JioUCQ/C/PMF6KKAwPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqG\nSM49BAMCA0gAMEUCIQCT+6FArMHhs1E/gqMWW0+s+4jS5UjCNo8ygvm7OYYZ4QIg\nAMIeBaSbc2YD5tGdIrg+5kLi3R9U8bMNykyi1O4u0Vg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX00vTR04Q806xIQQp4phqq4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWY2NjBhNy03MDBkLTRlMzAtODcxOC02OGQ2MjU3ZGNhMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQR4abK186dgoCxQj2xOGH9wy3GurdC0vWtdgfqHmhk0y+J\nzFdupmeu90v0kmUfdOtIQU/hcVocfegt8yu997s1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiya5ZxU+ki7JioUCQ/C/PMF6\nKKAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOkJK3f6XYDe1/BDzsTppprdEvA92ou1+2U302r6J8keAiBvJU7BS3FL\nsRiZ7LVeh7PyEE+7WXEUGAGfEYx90w/63A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAYYIJLqY9OeeaJqWQ3hKdWCEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFlYjYzZjQtOWNjNi00M2E5LWIxYTAtNjYzMmY3NTczZjQyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMWNhMzliNTItYTkxNi00\nOWIyLTkyNDUtMTg3Y2I5MjNkZWI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nJNtKePI3QFzsRueXVEnOW+vCO6q98Bhxn80Z4yNDlspv4IAs+++YOrksFg3tuQyv\n+QjK8KifgbMeNV2154wLRKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUopxMYnve8m4u1AZM\nRpZ2LVQPQkYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDY2/+bvTZT2hZ5BC21QmKjIcBEQQDxK4tdOtjJvsbMnQIg\nPGXVtChTOEcsJwrt2S39t/9Xp3wkC+/+R8wfFH3A810=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8736", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8736` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAeF+7UM3uwHnuV6U6r2WoLhDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2MWFjYmFlLTA5NTMtNDFlNy1iMzAwLWYxNDc1MmMzZGQ0MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgzMGUxMzQtZDk0\nYy00YjJjLWI0MDItOGZjNDQ0ZTI2YjI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyS5Xx9p8d4WbHowsvEZpmEhHhGIHookB11O4SxPEMZVuns9ta9vhvR4N5+Va\nhgK1s+PQTUIkGAMZY57tUyKbRaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmVmHsUpzpbije/ldz6XW1yiche0wHwYDVR0j\nBBgwFoAUrr3hwr7A2hLpnkFFaV7YWVzWPlowPgYDVR0eAQH/BDQwMqAPMA2CC2V4\nYW1wbGUuY29toR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqG\nSM49BAMCA0kAMEYCIQCUETUi44v1JasKNzfM+sQFeQRkXkRZQP9fFSHbBagF6AIh\nAOtDRaadjQU/+eF2tj+ITiOhu5ope2aCxY/kSNSk6FkM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVLsOc3YKgq9OZxD+4rf1RYpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjFhY2JhZS0wOTUzLTQxZTctYjMwMC1mMTQ3NTJjM2RkNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1Uy4Az+tncVY5q6obrxrU24LhybJiqlHeJmG69cjGjG+B\n0LRvOsQQlgT85u2rqwmFAlsIEKEDGX60aG3kPHpVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrr3hwr7A2hLpnkFFaV7YWVzW\nPlowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALdW0JfMVZp2nFhH92aDwDNvNUGV4j76FBTsWbdTC8+jAiBJ+l/qTXTJ\nDdekl73OWrMA3jXKB3u+psbkVxBGW4JzRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVS4iD8TnZKlegD57eThvVBaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgzMGUxMzQtZDk0Yy00YjJjLWI0MDItOGZjNDQ0ZTI2YjI2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkODBiMTllZWMtZWVhYy00\nZWIyLTg0ZjItMzQ0OGY3N2YzYjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n4AsL+6Es/lEL1e/ZUMAz2mO4kROXtcQcffqrBNJOe9WYNb52XeLuQNK6YG4HQpjx\ntj4RTdALaq8G/7/CcpgKjaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUmVmHsUpzpbije/ld\nz6XW1yiche0wIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIB/8a8IUHstTfTJdOdryW61nuPTpJy2wRQsbANRpM5zGAiEA\n3tGkn3Rv2H1UUQSxo5SNha7cM5+gxeIKG8JkdaFNSXc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8737", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8737` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISATDRVLIzGFmL8BRIXHLuFTJFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzYmM5ZWM1LTYyNWUtNDk5ZC1hNWI5LTYxNzk4MTY0MzU4YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWYyMWQ0MmYtZTE3\nYy00OTNlLTk1MWMtYzMyNzBjMDE0ZGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkDWB02dLGZEB1jQlggjZdb/qi9CP98jD0u6PtwAbDfFthz8BDtok969DUH+F\nFA5r7JDn6gWvMPiQ/bZU95dHGaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUscMSEBR2x8aOwjvNe8N9sTZvTPYwHwYDVR0j\nBBgwFoAUFDU367qwSQiwrGq59QlJcXIPIxowKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCgACn/emYb\nSX3QB/R9z/7Se7Hhnog+ACR2GMkf2N/3TAIhALCIv/JcZ4WuftFH9YvhrD23dfnB\nLpfKu3nGRUhaGbfZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfxmIB89IoHSFZcpnr5WKFO1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nM2JjOWVjNS02MjVlLTQ5OWQtYTViOS02MTc5ODE2NDM1OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIodMTbBOeizCLhMZTUj+VbGEsT9QrEsjwXjq2dLEac3l9\nmXguVSh8YWTWW47Q0MphknqGjcMJmixWi6+YCzhSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFDU367qwSQiwrGq59QlJcXIP\nIxowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKxDA57bWhCkZSe8UFHA+bm3f4S4Ohj5PxXxAwKdMByMAiEA+nq0d6HB\nlc47QY50ud5WQ0V1u5kFhgoOSZIKUckzXfU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAQ0ELXRuFLyTaUGTgoyQ8hlaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWYyMWQ0MmYtZTE3Yy00OTNlLTk1MWMtYzMyNzBjMDE0ZGM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZGMyZWRiMjgtMWM5MS00\nOWFlLWEzOTgtNzBiYjMxZjIzZGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nMcZKbhK9H16xUWxLZ45ZE5gVBZLxIMpuEAJwXb7R52KORL9YmhHq8df6UvvsRsTj\nqT9rwQb/enCRG1V3m6Sz1KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUscMSEBR2x8aOwjvN\ne8N9sTZvTPYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIG6FnD8REmuxfz+Czh1l5War4NUSXkoZRdBuomGMgof/AiEA\nwoQl+Xd6ck/6KIDn2uAToEoH0+62cRyM58Ga6cZzebE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8738", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8738` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfugAwIBAgISAUYLxEiDoLyigkhZyIM5vamuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3MjcyMzk2LTVmNmYtNGQ5ZC1iNzZmLTAzMDZjZmMwNmQxMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNlMWY3Y2YtNDZm\nMy00MjIyLTg1MmQtNDhlNmNkMTBjYjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy2vlGY2ilouNwhFQ3Xt25pgsVf2K7bDWoS8AzadIsnZnqRuwzXcEDEQsXp5o\n1m3XkjXUa/bs5AcIDWX8v9DsBqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlewk8imHsBJ36ocNN1qhajQgLBcwHwYDVR0j\nBBgwFoAUWKitzyLSfwL6AFDIxZspxKNje0EwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSQAwRgIhAJsObHiMMZqQ2eWDZXMpv8HTXkR5CdQ7GYDIpCfVBOmaAiEAlRJBqg7A\nLvxXGjgF7SWZl4EWsm1y19CY9UmBjlL4jpk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARcPsLosrsZiJdEhEDnligd0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzI3MjM5Ni01ZjZmLTRkOWQtYjc2Zi0wMzA2Y2ZjMDZkMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqXU+FzouZCqWXDNcML2no32XTumrU6VeMizBxo5SA3N8H\nAEy5v5jfbdy2LmdTcf+ODdObAVMk8+NmA0MmcBsco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWKitzyLSfwL6AFDIxZspxKNj\ne0EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKG2E28I8x7DY4ZOQtyUkJ+Vp7rCRDLRjXrLNKRkdS1PAiEAxkiUL4SE\nb9mDdFHyfFqNAzVB73B5H/ADUq8XhZC5l8g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdKgAwIBAgISAWbGqpD0fYo6SXUj1KXdq8QWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNlMWY3Y2YtNDZmMy00MjIyLTg1MmQtNDhlNmNkMTBjYjY3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2Y5MzUwMWEtMWVhOC00\nYmQwLThjMzktNjk2YTVhNzMyNTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nPWTefaXgZAcHQKIR/cW+eiw0tB0OIIsOaaL8oOAfbJgl2Kp/MDkEK1oiFLBZ4A8E\nfES67HnFyBA1mSY84lgv+KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUlewk8imHsBJ36ocN\nN1qhajQgLBcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0kAMEYCIQCugWC/CcdpPC/ZFQ4dLb+WdWuz4d6ygoB2ggAkxqN6/gIh\nANfkSGUT74meekd58N1NqqFrF7sx+Ve4fL4yJzFfv3bR\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8739", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8739` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAWc/wIn0uOG+2gryLOg/Et46MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzNDQ3NjkwLThkZDctNGZhZS05NGMxLWQwYzc3YzdlYjI3MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU4MjBjYzktYWRk\nOS00ZjBlLWJkYTctM2Y2MmZhOTZiMmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWTULBPutROktFB0eps/g5boBaI4mSLhUOGr2cwsBOPNCa5lNLyZ9qeDEYlCE\n0Zvr8kFDChl2Xo7k2ZOo8YhEg6OBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKKBHarDJ7YyFwNSaq49pWiW092YwHwYDVR0j\nBBgwFoAU9mQEmWuCOyJfppxHJhfJaLgwOE0wNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgbRVN2U9i4PIqzIjDy0j+V4NuNvQdDefaG563FdkMjGICIBum8i8puXU9\nKqNbyrLfA1+3zmzu/0lon3Lg9vmt0fSA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVGl3akkFV1IKjVI5Dau0VdhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzQ0NzY5MC04ZGQ3LTRmYWUtOTRjMS1kMGM3N2M3ZWIyNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASo1SxWMpPHStG3EQ87fV/AqiKg7wsN/nz7kH2bU5TabYdn\n5B0OAVjnVAJVIBcvo/DNs7bqO3IEFP5vnzyAvu1Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9mQEmWuCOyJfppxHJhfJaLgw\nOE0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgS8/wfzKxYxkeHYOqC6ntx7ri1ZbSdFGZOVcO5MsoCUcCIE/bGa9bnmZ5\ngW9KVp6DLa4JVfMhLbKqZ3DbgWuL7Tyz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZdOZ1WQrUcu4pEG7xwUbIL7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU4MjBjYzktYWRkOS00ZjBlLWJkYTctM2Y2MmZhOTZiMmQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOGJlODY3ZmUtYzkzNS00\nYzFmLWJlNmEtYTVkNmY3Mzc2ZjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nOzyADSSY/jSTiKv/BnBnXpjh8OGC0z3/0mqgr8QQ6KST1uleylAB6+MRVtlT5LtT\n2mTe6fE6jEDMzPRdr4VPNaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUKKBHarDJ7YyFwNSa\nq49pWiW092YwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDv9yY/0tfUp+MSVXlJDhXEMQauM4z36SmOlCPXWljFZQIg\nXnZOZhrT5Kg9z2ducHcbYlUl2ohaCTW//PchMI/fFLM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8740", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8740` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVjCCAfygAwIBAgISAbsKhC244uY0IJtv2pFZBhLZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhNzA4MWViLTBlYjAtNGUwOS1hYjZhLWRkOTI5ODJiNWI0MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJmNTJiYTMtN2Nl\nMi00ZTBjLTg5Y2QtNjc2NWI0ZmZhMTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKEroVe5zOxWEtyWSUt/uxxoafFTGjcCNUOtbN/d7tc6Fbmnr1lN++nmDCvCa\nKNPnIAmYLnf4hzneQdbF7c5pNKOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE7s9+FXYbdoZC1tvWyi46pDf8twwHwYDVR0j\nBBgwFoAUx8xqyX8llagKXqU64eTIDbjzP1QwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIGnmlQCWfIfmIPU4kdMey+QyFOoIIPdtLtkQHQZG7dxSAiEAozSbkN1l\ne4R1ocMLLrVIo6uRALzGvYN5th5fPlay1dQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAewpVQMmI+mLcI1WeJZ0XaEaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTcwODFlYi0wZWIwLTRlMDktYWI2YS1kZDkyOTgyYjViNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQX2LJmWKDGl0unnbb3BhqktHb6BGKlt1QBGUleOdB/uCzY\n0pCUUlMIbtaEE/Rz2oBA0MUShBEpFaMPOMQvQH6eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUx8xqyX8llagKXqU64eTIDbjz\nP1QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMf4AYKsC21QDG+NZYDwJgBYhbt/8eT99buayN0cBqTqAiEAhRaZErD+\nd8CGG7kseG3lWp6lgtSjlAdtIK/L9mheFHM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAS2Gmqgb11qLS2k9dSwcov/eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJmNTJiYTMtN2NlMi00ZTBjLTg5Y2QtNjc2NWI0ZmZhMTk1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkN2MxZmUwMDQtNWQ4Zi00\nOGQwLThlNWYtYTM0M2MyMmQzZTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nkI+btkdKTFYTkU7qe9/79ijmLxbpzGGYOQbxuvCkF3dU/R8f1mGbhY6xIhGGYTri\nZ8lxofFnCy3qnsyXPPttXKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUE7s9+FXYbdoZC1tv\nWyi46pDf8twwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIFMOV6fju05oDREvO1L6VIjWcDoSPogo4mrfN4a069ekAiEA\n7qUx3pyYnseIiuKrjdnjkfw3EEC5ItIbjSfdlSCGNX8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8741", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8741` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAShlfkkYmjtiyD7DbMsb7X2uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwY2JlNTY0LTA5MGQtNDQ3OC1iNmRkLTMwZTExMmNmMmRiMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRiODVmNmItNzBh\nYS00YmM1LThmOTYtZWY1M2U0OWE0NjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnatm97PROPUJB+AFWEW6l88TPr9B52KaiRI9/tlOuIQTXhx23nuwr1gsPodD\nMRVdNQ7rfZ+UTaMTp7PlUuFsKqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHlqvNXqkIWM/Z8vWRsEq/azgbFgwHwYDVR0j\nBBgwFoAUfeAgiektfKT9MWGwDvH4e+saW2QwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQD0BgIj2wkBmdSxaMQRNTZeFcKlGsF+Zb1iKkBb\nflM3VgIhAIYzGbIYaC8pi2fP6AdkxR2C5RpEJOfX2X3XUq4hEMlk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARXBziagPRVY/kRXh+cRZMztMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGNiZTU2NC0wOTBkLTQ0NzgtYjZkZC0zMGUxMTJjZjJkYjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATs4qivb5Nux5en49kfiMpfN7eF7RUuLi+csChYjdMkQ4mz\nyPI+5MyOQmQ+sRxzaqfVt+dYwur1qBkJAe7JSK87o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfeAgiektfKT9MWGwDvH4e+sa\nW2QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALbsIe4/p0UU1BSZ8Y9FwOjgCuHojyw2z8NtyPkzkVBZAiEApqg6XC5D\n95kZRR3nfLpARfKOWIb9A9VD8mRhPc0+6EU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAb2McClZLzpzIVRE/FNI8a2bMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRiODVmNmItNzBhYS00YmM1LThmOTYtZWY1M2U0OWE0NjAzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjM3NGI5ZGQtZmQ1Zi00\nYjc4LTk1YWMtNjNmMGJhNzg2MmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nRjidpixzJut+X4keizEF9+zxTvxyk9ZSBzio5sSDMf11tqaKIe+5D3aY51S5hwX1\nPvP7cpt+TLkTfgp2xTAwz6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUHlqvNXqkIWM/Z8vW\nRsEq/azgbFgwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQDJmigf1T4DVwSZ4sxwdj5dJE6/gHTzhVH09rkqFj8HLAIg\nY9NYTbdrFEyaIM3gFV5vl/V8XzzuxXuvrJzj2dv0m0k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8742", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8742` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYjCCAgigAwIBAgISAVz5Gakf/cgzJUrefWTto/3ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyM2YwZWY0LWQ4NTktNDQ1ZC1iMWM0LWM1MmE0Y2M0ZmMyZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjg1MmE0NWUtYmZl\nYS00NzM2LWI5MmItYTZiNjFhN2FkNzliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV947/EC2uSqHx2NUvP+69cy6L9wf+AgBI/2GRMdX4rjYvk1L4Y2WozJ4rF3Q\ncUfAxjGAY7LyBJyiKxuLB4TeKqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO3fkspb2er1tlMnQolPRA7zMhoYwHwYDVR0j\nBBgwFoAULC4JokLrLtrhzOYdscz6Rir0hi0wRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0gAMEUCIQC79gPOcEFPpsW5H5BVE5WrJXk+VfxIB55eqpqM\n1FTOpgIgLxYx5Wae1yz4ULPl5U6oI8mvqG74kV5Jc5GxmovuuH4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfmBCCkQGwWXpD/yS4oerp9SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjNmMGVmNC1kODU5LTQ0NWQtYjFjNC1jNTJhNGNjNGZjMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3mdGRZ6Ms+aV6ekGioSzGv8vXs2DDidtUkOfHu075catQ\nB+OlpJcdMwKSMy3oi5cKGro0G+wXM5QrHQuqFtZSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULC4JokLrLtrhzOYdscz6Rir0\nhi0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAfNrmH2DQ9Ml5ngPi3SQTsd2dD3mEv18/GyNgVSz3koCIQC6qMcvo6Od\np/IWUrwkLXHEcraG3tyu89fm4Xlwqyg+kg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAYUi/gk2c0mSL8tHFiOFKbSZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjg1MmE0NWUtYmZlYS00NzM2LWI5MmItYTZiNjFhN2FkNzliMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkM2UzNjA4YmUtMTkzMC00\nOTM4LWE1NDYtOTUyZDk0ZDMyZTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nyIoaoMeOGA4n/pOb4+qOwROaYVu7umqUCmDCsxQUHG3IBRYfYfE3BRXEKjRA6s+i\nK0HH3qu34BIvDsUgEtC0F6N4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUO3fkspb2er1tlMnQ\nolPRA7zMhoYwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIHxCKJmLOLrspKkU+rsmS84+tb36gtmirYu4M5Wj1kAPAiEA\n8RWFEMoGHHX429/8KSUHRjZsOYeZ4s8K16F5EB+rTNw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8743", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8743` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXTCCAgKgAwIBAgISAVZYS0AvG8Tri/+51KDYP+lGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhMjFkOTEwLTQ5NGMtNDNiZi04ODFiLTAxZmUzNzIzNGYzOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRlMmQ0MDctODEy\nOC00ZTJlLWExMTgtNTZkZDM4Y2JjNDU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyUIQiRoz2OfaUAujZktbh5XV51FnN7fpjGmsjVgCzmJuufISflAeVhtdhPe+\nd5rwsE24dhVXeN9KzZGhNdcChaOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7SOalNzfnIRz30WaS0jt1amyidQwHwYDVR0j\nBBgwFoAUSK+MO0l6MOQIFrbY+Hgml4bF00wwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0kAMEYCIQCcZmXHefXFQqXCO1k1RuFH0L/BpUlX2/og03aMie06MQIh\nAKa2kg16MmqhHJJzXzMoODbYFIddBy6OV4iJt+5Rt7JH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQbYdBJM6JGRiKJvPIXdnQhNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTIxZDkxMC00OTRjLTQzYmYtODgxYi0wMWZlMzcyMzRmMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYg3Nkvy0GqetXNGCPWNs2hlv2ZP+26denlyaw+7wsx2iM\n72+yMGXQIcGaG82L6g790bK3T75iPXsirvW5gFauo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSK+MO0l6MOQIFrbY+Hgml4bF\n00wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJRrhqR8Qi/UfidyT2aU7ZYTF9oJyq2zmVegQq7tAIJjAiEAmFAq4m0j\nrHq1hxXUorBZhlXWf9Ual0DUqRUiyxc1ano=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAXBLY2+PdKb1sDM+UJ0e5s5RMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRlMmQ0MDctODEyOC00ZTJlLWExMTgtNTZkZDM4Y2JjNDU4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjViODQxNDEtNGJhMy00\nNjU2LThmY2YtMGRhMTJlYmQ5Yjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nksH0eVmQMiCz/UWe6CSXSFV7v0raqFL6JO+cEFaHyvYjBAo5/cr0FO67+FEHd+lb\nm7XqEAB6O0+2VRsI4nmEAqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU7SOalNzfnIRz30Wa\nS0jt1amyidQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIBhC2ogpxjRhVn9ifkSUD96jpzDy3wMCOsx5lKpC7CTCAiAz\nkymzoPYCAO6wmwbizF8JOix3pAorf64A+r8UF5Nv/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8744", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8744` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICZzCCAg6gAwIBAgISAQp4MG+V1GZcopAUIo4hlRGeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3YzFlYWIzLWExZDgtNGE4MS05MGI0LTY0YjBjNTBiMDI3YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTljYTZjMzEtOWRj\nYS00YWE2LThmMGQtYzExZGViNTUzYWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtn51jIRoLaX98FG3WYiWhe1i3mgxZFxGMiaUq5JQrTKqhnh44HEPKE+J5HYt\nqxMVYSeFd/YWQC53FBYtIS7i0aOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwdSAKFnM1znc6Zjtk9zdrAc6BHQwHwYDVR0j\nBBgwFoAUXrLKHI84MVGvv+vgxLQull7Df1kwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0cAMEQCIA4ZpkDLDAGSHbRl74XOTUcfmFpNbBCF\nVmlzLbdp1ZGZAiAI8FsdjbJ2R1xYs2uPTKs46mZwQNIby/JANoMqXPeRFA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASKqxhoBx3y33s3M9XMig5voMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2MxZWFiMy1hMWQ4LTRhODEtOTBiNC02NGIwYzUwYjAyN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQid1g6nr735qv3Sh3jzHpn6Taiwi5Lq4Lhz0z0r3vNWPod\n/U+pMXn5l9IKuc1QyoPuji250Jhdv5PwFVepbcOSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXrLKHI84MVGvv+vgxLQull7D\nf1kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIoyPwf3BaWc/VxittlxIJHyWOVQWUADBCZ1PDYij3IqAiAVpUap0gpZ\nKqGmrSg/Q7SJwerFK+7+76BngU3zIoUiDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAaq5fD+xLKbUElmbkKmcIXc7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTljYTZjMzEtOWRjYS00YWE2LThmMGQtYzExZGViNTUzYWIxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYWMzNDhiNzMtZWY4Yy00\nNDczLWFhNTctOTRkMzdiYjc3ZGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n6Heu9ASj4RODj90p7ZQePhLhZhEHTlu6wWTP5tlHFdD1yHimrGdJULU3SWH2mKOU\nI0FGC26h+nWqK84Ujs+EqqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUwdSAKFnM1znc6Zjt\nk9zdrAc6BHQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIHTmu1vj7w/SfVLO1LneKXvAheKpegey4oun9U2fFtmpAiBv\nzoQmwapVpJm67v5j6Yr8mVV87wkteijcTyCwhEAG7w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8745", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8745` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISATAQ2anBDdMg11vsTxtrr1eeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiZmFjZmZiLTY5YzQtNGNkNi1iNDU5LTQ4YzkwMTcxYmFjZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJkZjgxYzQtZmVm\nNS00ZDZlLTk0ZjYtODE2MDQzOTFlMTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERpeFyd/YuIZ3lN2i2LhVziau+u0ZpdLHEwRx9e8u8cJfwjOMn7SCNGbs2/tm\n7jgy52PnXmqfv9fZxe+80ZC0PKOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXFzSvQ8f5VaTvAo6pJZirpj2B+AwHwYDVR0j\nBBgwFoAUzlu+Jmq581T6D7m/r1j5bajnk04wSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCH8AAAD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIBp60r2cbaSSjAMQy7G1do2lhTxky1vc\n172/UWWcWsVpAiEA0oisA8iHBQqcPSpbtvJOuthxst4wZwuscM4qyvw6L3c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVeb1f/5AQDeMW1vW0YSeLZvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYmZhY2ZmYi02OWM0LTRjZDYtYjQ1OS00OGM5MDE3MWJhY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqk/gTB0JAR1d/lVHmWQPZyl+SL2viUqFyXfHPv3D19vZx\n/d6WJsj9Kmb//RP9tqrYk2X0SNSkmIwKXzYUd/gUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzlu+Jmq581T6D7m/r1j5bajn\nk04wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKrlA/KRcsN8nwcExL64IgbqV+eNPWunMJTMBnlWvpKwAiEA57/amtfW\nDeZSOLXWEVe+J1lsdx+6HJEawtavCvEVzS0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZOdfgz8Zbr/dsHWkLvNIHU4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJkZjgxYzQtZmVmNS00ZDZlLTk0ZjYtODE2MDQzOTFlMTI1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMjExNTVjYTEtOWVmOC00\nMzFiLTkxOWMtNjcwMDAxYmUyZWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUdtyOkyapWhjbziHJ3hFWPZ+AFCSmgTzpBzmeAGxh9UE3v6KHBF/w4ZR6IXn9yJX\nIAAV1c797o0RDV9lZvgfJKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUXFzSvQ8f5VaTvAo6\npJZirpj2B+AwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIQCZq7252jmVSCaNCKHj95znC/EDO7pthkhYlZ9+4nbP9AIg\nZgezIYLsMBmEUyotbkFacYJ7rsZAG9DEefi9Z7yrAw4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8746", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8746` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICSDCCAe2gAwIBAgISAWpHI+9WBqiOT32lxT0+ZpMHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwN2Y1NjJkLTBmYjQtNDI2NC05OTU5LTFmNTQ3ZGIyNzg0NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY2N2IxNWYtM2Rj\nYy00N2NmLTllMDctN2M5NTFlMGQ3ZWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELJAfVSKkLNZ6vGsEUiYsKY2vNNfUfgJornjzf0tzaOL+e1PRwpVHdwiL95c/\nQChTKQe764wpZ/4Y+omj5oW+OaOBjzCBjDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8KDqjifi6E0X9WK9sccvLbZXrKMwHwYDVR0j\nBBgwFoAUs6pGqzkATGU/idkKYtWhfSQmsBQwKQYDVR0eAQH/BB8wHaAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AMAoGCCqGSM49BAMCA0kAMEYCIQD8Y36lQqsF\nXAuuigyWEHTb4vASbQj7yIDgAl6TnXTZEQIhAPJAOEq0wHcDG7f/aiv1UzO3251k\nANT/lw6nqMlzxPve\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZqibibTq2XS5CP44UVmA+2HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDdmNTYyZC0wZmI0LTQyNjQtOTk1OS0xZjU0N2RiMjc4NDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZKGV+/qxtS8MTOIMlSqAzzyHo13FOvebNpj65vwN/G9Nw\ndcChm7OnrzY15lx9DMgyeVrRRu2bDdzHj7YPzMoeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs6pGqzkATGU/idkKYtWhfSQm\nsBQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL4fPeaZ9GfZCNtDc5YS1eLLGIJr0P9Sxjt4Mz7Ya9EcCIGhozehAbH8s\niVdP5vGmBdye5ao3ZDusXouJfTYDrIBO\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAczvp46lqDdu+H8LRS1eOh0TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY2N2IxNWYtM2RjYy00N2NmLTllMDctN2M5NTFlMGQ3ZWY3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDcyMmE5YzktNDlkMS00\nMTcyLThmODItYjYzMGY4MjAwNWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmL0arfd/vbFFkeb9++tQWKB04DHloWV9YlS2uDit3cml1lRx1aqZis0rYF9QYb7q\nL+acN3P53yIyp04TdnWUWaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU8KDqjifi6E0X9WK9\nsccvLbZXrKMwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCICXeDzDPPpRmJZdqaaAMzugfT2s687FEFdJDcG/+KIVlAiEA\n2Z+5SPj5HcrPnrO1owAxtyMARWfpGC9hf9PdXcNiq2M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8747", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8747` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfugAwIBAgISAf1MHjjhEYJhXf+HV+38Gy1MMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4NzkyMDkwLWJkYmItNDAxMS1hOTVhLWEwMWQ1NDFmMzgxYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVmN2QxMWUtNmI5\nNS00OWE5LWI5OTctZDk1OWU1NmE0Y2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEso1yPqge1UzAD5wTeQ77Ot4khLVJVTvTBJwOBqUwgLr96+XjGmT+oeLW7n5m\nqRMbcYhxm5tfrqXRaeIUQAHlpaOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgx2B/Jw7lHPGy6SI9RP27liDk9QwHwYDVR0j\nBBgwFoAUHcDU3VryLh0eNEmRrS2haL87/pUwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIfwAAAP///wAwCgYIKoZIzj0EAwID\nSAAwRQIhAMFqaIhqVbP19zgC8kBwjlK8rJ55C42owUAwTTcwxlVfAiAVV9BMU697\nwvav1vHq5UuYQB61k6pq3CV6V52eKHS6Ag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfflrfcWgklL4LgsRruspD+SMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nODc5MjA5MC1iZGJiLTQwMTEtYTk1YS1hMDFkNTQxZjM4MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATK0DjG3Jisb18qIfKZoZVWXsZFiD26j85Y+pPrF10lZeP/\nK4RDyTp6PBMxWgqwy1gWKZS7jrnGx3J/3RxTp+s1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHcDU3VryLh0eNEmRrS2haL87\n/pUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWEa0xRLVU7dZKCy7FjkFPOHMxctVGq/LW8c6XYN4mp0CIQCsOFd6oi8e\naVSP7bNOd8vMjAwiNAefNBjL9J7S3p9c6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAVRutdx5APtlOBaZCDWMmBoyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVmN2QxMWUtNmI5NS00OWE5LWI5OTctZDk1OWU1NmE0Y2I3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMmJmNGVlNGItYjNhZS00\nMjEyLWI0ZDQtNTIzOTk3N2M3NGUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nmqOYMDnyeMnYSmU3WTTqEa8Yk7j2yJTF07SVgy8ECbbgcEorhTi0nM0GY/XBwOVK\nffwQTJbVepWwjrkVkgnGiqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUgx2B/Jw7lHPGy6SI\n9RP27liDk9QwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIB9w3zBUcWXzctg76bFdHIfWkKOvuxzNh1YlIe5x5rvqAiEA\niTViUWP4AM5jX8JKYXPxxXLmtnRtbNY2fBqX7vkIWe8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8748", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8748` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVDCCAfugAwIBAgISAUZby+i5mywYIkpY4IKCoD2dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxOGY3MzAwLWVmZmYtNDQzMi1iYTkzLTM0NzFhNDJhNjdlYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmFkOGY0MTktZTU1\nMS00ODEwLWI2NDEtOWE5MGViNDMwNWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgkwYiDnBh9OIukB1YVkgQJFG24Sozec66SFa4bhfAhuSehOjVxzF12xY3Wrc\nE6Xpx7RS1cYrNDK4Ji6Y8LExNqOBnTCBmjAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNfajGxUpA16a14Y3Ks23L8hf19YwHwYDVR0j\nBBgwFoAUSn5tZletXZfvvMvXIGE2NEj605EwNwYDVR0eAQH/BC0wK6AbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQwwCocIAQEBAP///wAwCgYIKoZIzj0EAwID\nRwAwRAIgWqJ2B4eOyCCXZFekGaQdqC7BMT+F7SMbKTXSJK7NfaYCIEkkRrM8odBX\nQS+mNviQCKCQDw+sYnoE1ka7PNVpLQaQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASoVlnFMOgX8gBlUrpHj17GcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMThmNzMwMC1lZmZmLTQ0MzItYmE5My0zNDcxYTQyYTY3ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShzyAkLjxmyMMRYs7NYDGfN4R5R6sY96oc/ra3i5G6KwvP\nRub0Hz5XBIDRze8PvsKDa/clQtsN78THnxymvE4Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSn5tZletXZfvvMvXIGE2NEj6\n05EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIPETJTFFE/n7WSIndlIan+zaPXgO8Z/KH6xJEZTgfWLAiAJk4zjAFW9\na3/yJ4AgvmieMPsLZR0qo8j3F0iSEzQprg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAS8g5XGmWJONtpcwlqna7zT8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmFkOGY0MTktZTU1MS00ODEwLWI2NDEtOWE5MGViNDMwNWY4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZDFjZWQxNjQtYzAxMy00\nZjNhLWE0YzUtMmZmMGE5Y2ZmMDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nIZ6GpOM6QV1GV4N3Knf/QKAC54WuiyfnU6S1PqIA/yRF5Z3DTEiAylxKLFw6zoN1\nTpsNY/Tg6G9Cy/5JQD1XIqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUNfajGxUpA16a14Y3\nKs23L8hf19YwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIEiBuFP8fINXExtYJrm1iYf6Zt/aZNhVoziPzWqC2bH6AiAc\nRL+TOXwZVcggFN+MWlcYw/55/pLMZdyB+O2z8LqBvA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8749", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8749` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICVTCCAfygAwIBAgISAXIgOeGmR3B41DHhM8GzD861MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjMzBmYjUwLTcxMmQtNGJhOC1hMzk0LTI1MzM1ZDMwZjY2ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQzZWE2N2UtYjdi\nMi00ZDZkLWEzZjAtODVjYTBkNDQ5YWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBNW4yg2KNtxTgUMCddTiOP4+7FFltTTR6d3Nmowa9q2wHQFm8QTCbHic7MhY\nuKG5KLqrzDbpuzSLlkh5PEJmDaOBnjCBmzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL3/gRdebUrwlvk6XOaioDuBDq5swHwYDVR0j\nBBgwFoAUvxUJo1Mz1NZm9WT3Jk67mGOnnzwwOAYDVR0eAQH/BC4wLKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoQ0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIGv4uPHYjExZbw8h1M5Ae8V0qrylR/DhElJG2t3R90IIAiAoui6HBCTK\nTNy3LXLjhloSp1TZf9/7AFGoyWOjC5A9/A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfKqRQ6XbwGVlf9inqqgN6JGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzMwZmI1MC03MTJkLTRiYTgtYTM5NC0yNTMzNWQzMGY2NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfNAR3Y/nWmjmLP4sCRE3Li6QlMZTFRxo3qLBtAmxyi3t7\nDa51dFfotptOF3zMGurhCZX8df47HWPEfM3Q2jw+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvxUJo1Mz1NZm9WT3Jk67mGOn\nnzwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXNMKfNUnTYROF5NP3rZuYN60FsnDrv34NV/FdD+8/eoCIQDsjbSfW57q\njjCgw6OjOWH28v7dE//ZorxLJ5Ey7SkNtw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAbFtqw1DDmsOOhZRGvwQlmj0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQzZWE2N2UtYjdiMi00ZDZkLWEzZjAtODVjYTBkNDQ5YWZhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkZTIwNTY3MTktNDdiNy00\nZjZmLWJkYTktZGFmNWJmNzFlNzViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nutn7LFaqTUzQNpDExah8raI/nF6ONYnFta2bDluZ9DtQeTaFMfbI8u5Hkk/2FL0G\nGVbu7WtxgCE0vGKMnAXmqaN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUL3/gRdebUrwlvk6X\nOaioDuBDq5swIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIG3tHGWXWwkUyFrkXTZy8dBUljeCGWsOJVzFw6ZiugW9AiAU\n1vVwZM1hkncJdFhVQm5Ianq1M/gGAROkimSHdroLhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8750", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8750` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYTCCAgigAwIBAgISAY9zM8ErWY51/Fy0CfhAziPNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiMWVlZThhLWUxZjUtNDg4ZC1hYTFmLWJiNWVlMDE0NDQ4MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU3ZTY5YTEtNTgw\nNC00ZDU4LTk1MzctMDNhYzIzYzZmMDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECohdYjZsXGuoaYc9tniOyJuAzO1vFhSJ85jVzNjjTK+sRSOJ7NqLSJHrtPOr\nKKna0I1KrZh47aIfEGWfL5MQ5qOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjITgTPfb/qkrKcDuDCMq5cj7lUEwHwYDVR0j\nBBgwFoAUQUhEqRr36KeHgsv4ybU2ypLW6WkwRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCH8AAAD///8A\nMAoGCCqGSM49BAMCA0cAMEQCICWI+m2cP4vNPH5nOF7WrZ72ZgLLCdoAk+CaKPey\nZgYNAiAJwRsdzJxS1UgPWqfxBDYSCRORuJZxAeLihTZhFYaCaA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcZ8BTNj2cvkx4ilUuUcDsPmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjFlZWU4YS1lMWY1LTQ4OGQtYWExZi1iYjVlZTAxNDQ0ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATllKm/ZTE8zO86PHIhCG6aFreCRipnL6mhCbY8+Ti/bfyZ\n7eOv10MKMedn3aFNLwV2ZQBbCO/zoKwZDugi2Zwuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQUhEqRr36KeHgsv4ybU2ypLW\n6WkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWRKfwYeoRsI4mi64Nek1848KImcwEYKVYcc5V2zGJbYCIQDFydI5x8xH\nCbHASetzJmpXg4h/qUzf2eU7YIjauEmZhQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAfslsAviNOAzGkQGAgRaBSYoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU3ZTY5YTEtNTgwNC00ZDU4LTk1MzctMDNhYzIzYzZmMDBmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMzYwN2IxYmItMDI3MC00\nM2IyLWFjYjItZTdiZjRkNzI5YmUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\n7N2PLVyXwQw2cFON5PzdbUSNBnCXLgOs9GQU6uxoDlpc6azh9FAeiHm4e4JIzZj2\nJd09fH+WagDwqrA/ZPYD6KN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUjITgTPfb/qkrKcDu\nDCMq5cj7lUEwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIGyfuXA7D73v0IEvXRvfWAVQTiuAY/XysdlOrc9t/+KMAiA8\nU3Akp5h51fB7E98XA+R6bIA8CerKeV5wesNVyfHLKQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8751", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8751` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICYzCCAgigAwIBAgISAfKlwKDxLd20vxJvwON+NE4EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkZTYyMDVmLWQzNWItNDYxNy1hOWU2LWE4OWFiMzI3MzEyOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY4MTI3MjYtMTYz\nMS00ZjVmLWEzM2QtOGQ3NjQ3NDMyYmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENKBVOJqGZGcggXO2N1+/UIppmKvSDmRQiD7ubXHoZzRArQRM4k2sVeJnMdgd\neApGRt6773bauJSbapzWGTRybqOBqjCBpzAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTSBJwNIrK34zwKP527pXGhIIjPQwHwYDVR0j\nBBgwFoAUu+gi0XncnpQz+vkDguBvuun4SlowRAYDVR0eAQH/BDowOKAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRkwC4IJbG9jYWxob3N0MAqHCAEBAQD///8A\nMAoGCCqGSM49BAMCA0kAMEYCIQC4N4z1tPwO9+SFWxjULa0mZvNCsnzacsd0NW6H\ne7Q8FgIhAKXi9xvR2bMqiozgiky/uA71HaltnEudRga9KzdCIz6m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASZE/UfJs3jo1J/Au2+XkHwLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGU2MjA1Zi1kMzViLTQ2MTctYTllNi1hODlhYjMyNzMxMjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT++UIBv6EsrtjzRLOfT7ZLPPdb16xsqPfJjCki1Sa9P+SA\n3yi4/+k1NHCcDJKwIKobwrrMgLzJYHRcYPQeVNvao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu+gi0XncnpQz+vkDguBvuun4\nSlowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNUC+nIMSpgp5SsyH6BOC2i7AOFPSV08lc3jHa+Ak/zgCIQDQvoJzIE5u\n0SkU6W8n7BUiUUHgeA95T3MEbQaJFcpntA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAZBevNkb5Sj3pBYzes+Ng5GEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY4MTI3MjYtMTYzMS00ZjVmLWEzM2QtOGQ3NjQ3NDMyYmVkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkMDQ3NjFiN2EtYjk3Ny00\nMWUxLWE1NWQtMTJjZTk4MmVlOGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nUCFcg5FS2kau8ZQVFGoF25idwZXCoXcP3VrgfDP6ZTfgTnI6P1nwjONz/vtn+3Tr\nkqCD82KqF8w7HXi/e1gd8aN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTSBJwNIrK34zwKP5\n27pXGhIIjPQwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIEu7DugGd5OHVG61xxdW2fHpM5IVt5OTDh2gnzbnfk9nAiEA\njVG6+05Dqs5SlR4TQ62FLtYfARxAAu3VzvCSOOqmBt0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8752", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8752` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICXDCCAgKgAwIBAgISAT6voQybyBOOEGZwU8660ZhUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwNTY3YzAzLTkyZjUtNDJjNi1iNGY4LThiNjA2ZGU5OWQ4ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJlYzI5ZmMtN2Y2\nNC00MDBhLTg4NTctZDFkYTRmYzQ1M2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE97jXcvTC28B6BhKd8M/4hcKewFjKyKSFGTnBpOf4Q+obD3kfj5/xK/PJ8IHj\nj8gno5g7HCf7Hd3Dc8lFnyOaLqOBpDCBoTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3yrcrsBwYwWYElO8949VMOT++eUwHwYDVR0j\nBBgwFoAUI9y3HUQjPTEmZzh6l4J4bPH2krMwPgYDVR0eAQH/BDQwMqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoRMwEYIPYmFkLmV4YW1wbGUuY29tMAoGCCqG\nSM49BAMCA0gAMEUCIHPaRX6hH/gBp3nZ+uiRtDWGidwaKK7i0wrUZFzclIxtAiEA\n7dlE6JFzjL4A0D5RaUbXXy1YArHJn3PJUGoXJHNEafA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARg8l0x4F6yY7u1bFrbi6LV+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDU2N2MwMy05MmY1LTQyYzYtYjRmOC04YjYwNmRlOTlkOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8lGs3kj+4EN14lGgXJL1AKbV94hPhvZTR2v90L5tta+w2\naM7HX9ZjXg+pUNo/lCa/GIdCI+0YYrQqdB3R34mqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI9y3HUQjPTEmZzh6l4J4bPH2\nkrMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKqt1YoPAn3d6WHPY3uDpJQ44qDoV4+feOf+5KA73RjKAiBEMfvEEbqP\nUNoxbYMMod0+Jbsy2aGB6nqJOKKqo1KOkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdKgAwIBAgISAU6e3833D/0FBd/hsSJ8zWl4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJlYzI5ZmMtN2Y2NC00MDBhLTg4NTctZDFkYTRmYzQ1M2JkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkNGM3MzFiYTEtMjRiYy00\nZDI4LThkY2UtOGZjMmZjOWZhZWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nt3WpQrXLqTiOSlbu3526KkYTT5Ey4xtFQYFWvn6r9Zn75mA2TfUfUejXNQ09+qbg\nxm3/NtRwNw+nPDfo2+oUUqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAU3yrcrsBwYwWYElO8\n949VMOT++eUwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0cAMEQCIDfnvHQEb0xR1skMah+J4Kyhfy2rvevc0ZD68AMsIMYsAiAO\n98/09ErConssFPZr0MtQZJa7c+mu5lqMdiNxoGrhLg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8753", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8753` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaTCCAg6gAwIBAgISAWmRTqKY1U6MP9Tq4rdo0pZ6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzNDI3MjI1LWVhZTYtNDEwZC05ZWUzLTRmYzczZWZmOTkxZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjdmNDJhNGItMjcz\nZC00ODYyLWFhMzItYmM0Y2UzZTZmY2ZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf8ju7TOPDoSTVHSgBvZY5Da4cl7aw81sVHot8eKUbWlLEaD7NwXpP4FJpnrj\npD1P0eO+Dv0+tCFVry6Rg1yfPqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnvxoXMmK7KooV7pkB+p+O04ahRcwHwYDVR0j\nBBgwFoAUZXHdC3isy2j68cqTSxzRbtisK1gwSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCH8A\nAAD///8AMAoGCCqGSM49BAMCA0kAMEYCIQCmESpEmw+VFetNw0L+JIjK696cCO9B\naTpda6/H1TAtEgIhAPfYWsi+W10wtISZugUNU+H7TJZkUtA12Ju9o7jFw/ca\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZmJQRYKMylWtOVe7HT/xre4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzQyNzIyNS1lYWU2LTQxMGQtOWVlMy00ZmM3M2VmZjk5MWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCSJtsAsB9rQTqjR1qSJnmUsy/gXvKYXkWag3s/OVe5xAE\nKP8TLmrSq5IuGG7o7KnbLer25VsXS/n057BfyszLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZXHdC3isy2j68cqTSxzRbtis\nK1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMfHVVpBdjTQJnYlQ+I0CM08rxHxkfQT6C/pGkeDlHoLAiBKHhE9p1Za\nylfPaZPn3YLNZf+kakcL3kt9/DP8bF3vPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISAT/Azzhe35N6YW/EhuX+3k9XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjdmNDJhNGItMjczZC00ODYyLWFhMzItYmM0Y2UzZTZmY2ZjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkOTc4NjZhZmQtNjIzNS00\nMGNjLWJkM2EtZTEyYTQxNjcwNWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nCzf0ruDUEoJT8ZeMoDi33h/uDbkZ3Odby923TsCmVyyoy4MkPCFDbeS1zmDCwG45\nvKNWQvPdrUhNp+RGQqt8hqN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnvxoXMmK7KooV7pk\nB+p+O04ahRcwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIEreYfhP8QwpXNeTkfzuRicakMizfZadE80CE1bIWorFAiEA\nnoqMhzduPAg54scRW0eORzza9MO5byPGeu7QPl59sQs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8754", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8754` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICaDCCAg6gAwIBAgISAWvv/9S7cxEBjhqyCMdLDiuXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzNmQ2NTg5LTQxMTktNGEyYS1hMjMxLTQ2OTFiM2EzMWI2ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZkODU1OWUtNTFh\nMi00MjYxLWJlYTEtZWI4MTBjOWM0YWNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1+WRxj8TB0Or5bKb1vCLHHyNCkqzqh/3GV3A/wbyEMcact1BA+tgkxJ7JoSt\nxuN9dCRLh/dihv1sfvIBENUQiqOBsDCBrTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtIrDlirTygxIxv/fMaYxh2WelZwwHwYDVR0j\nBBgwFoAUvP0CNwORmrUVRaeFqeXT8edu52owSgYDVR0eAQH/BEAwPqAbMA2CC2V4\nYW1wbGUuY29tMAqHCAEBAQD///8AoR8wEYIPYmFkLmV4YW1wbGUuY29tMAqHCAEB\nAQD///8AMAoGCCqGSM49BAMCA0gAMEUCIEKkvn7eP9AJ+kVhF1CfyU30vOiPvlOt\nYRdV6v6iE7SYAiEA7IMEpN24PcqCGk+a6em98rBYhJxclhNwxEhB+9Em3mo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcCTB8FvkIwgm7IndrwozqFKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzZkNjU4OS00MTE5LTRhMmEtYTIzMS00NjkxYjNhMzFiNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQubE/5mjLGl2Gu4dODQDzgQxCA0yzCz93czXm4SN9xpVYT\nnU0hMw5IN9MFpGxBX39gfvvjtt7lyzQaieYWE4Bwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvP0CNwORmrUVRaeFqeXT8edu\n52owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLD5AHPkq3F/F917RJ/xWQgiwzc6u3iYTdhXMdbPkThkCIE+NHPv6UCj8\nmJjJMt5VTcmJfVxHBlIcU+bQW17gESx1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdKgAwIBAgISARVZHlrskA/BuUX7cKWZpK/MMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZkODU1OWUtNTFhMi00MjYxLWJlYTEtZWI4MTBjOWM0YWNlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowWTEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEQMA4GA1UEAxMHMS4xLjEuMTEtMCsGA1UEBRMkYzRiNTE1ZGItY2ZmNC00\nMmQwLTk0NmUtNWQ4ZTBkMDE3ZDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE\nVttF6Zu64MSI/wDuq79/9TbLubj9k9P0ZU4CXjc+Y9gmqhKRS5Ty/WrpV5sOQQja\nP3FWV9O05A37uWXviLlYYKN4MHYwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUtIrDlirTygxIxv/f\nMaYxh2WelZwwIAYDVR0RBBkwF4IPYmFkLmV4YW1wbGUuY29thwQBAQEBMAoGCCqG\nSM49BAMCA0gAMEUCIFWm1QhZ99PZIEvBy88goSM9b5c3B6NJhQFy55fnl9VLAiEA\n7gcpa4XT3SNA4DIG/wacnPev+HO82xrkJ1jDZE7mUeg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8755", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8755` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAcEYns1UDOWKxyt1ocQGcQmSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3NjVmMGE3LTAyNDYtNGYwOS1hYTM2LWFlNTU0NGVkZmE4NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2JiMjg2ZTUtZTFl\nNS00MWYwLThkYzMtMjVmMjI2MzBkN2RiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEulZnqM7C9cYzW5hphRBb76ad+D+hWVaLXQrQiJ2YQGCMBLRicz2UFaRoH+X\n77mwy1k3nvffCr3C6bNHsu1kUaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFWRYsCLTY4v3y3zg1yPeBrAuIGkwHwYDVR0j\nBBgwFoAUHk52/U33SDhJK2zgGTJIRWuZpKAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBBxXyuIJFqqIdG4xsBrP3s7MbE1\nr0cbPNwAOkGQdxIQAiALN4twjODDFYTh35wIoSDrtQGxInFrLW6Bhu5vMMcNDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaB27HIStSsPeNxp5invoZbxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNzY1ZjBhNy0wMjQ2LTRmMDktYWEzNi1hZTU1NDRlZGZhODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2fIHh3HJG3lKWW1JymcMywCoJhepab/Y97zwN8armvtJ6\nQV9+jo3A3z6uwRHc1dBz6tktJPSPVH+MvgAjUFrpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHk52/U33SDhJK2zgGTJIRWuZ\npKAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEHpxGLAMkKSRXHMflxeJlfsTZAzc37evm50nstf9wb0CIQCBBVl5VRvX\nxPxZ3VgARePyKCZ8ehs0vKu8Bpa7Z9r5AQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISARwpNDRO5EywGfXthCafwBBdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2JiMjg2ZTUtZTFlNS00MWYwLThkYzMtMjVmMjI2MzBkN2RiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGFkY2ZlOWUtODljNS00NjhjLTgxN2MtZGZiYjZmZTcy\nNjYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETnFHBJMlPo0IK0wTn/FpN3ai\n/r26wAv6T82JDTosLeIzJNhwnnaVlEnArdgJLHQtjSRvhVAEo7lCahD7kN4BC6OB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQVZFiwItNji/fLfODXI94GsC4gaTAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22ADnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQD8dNUmNZHS9wsa1SQfPX2Krc3vbExG4EsJHnaZSgg3ZAIhAIdL8ImE\niGWoHKILDglxSXjC9MgD5U3LZSKzXB4aucdK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8756", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8756` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAVgr51kYyYpwHM0UJHcqVrs2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4MGQzMTQyLWE5NmMtNDYyNi1iYjkyLTIwZWFjOGIxODhiZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTNjOTE0ZWEtMGM5\nNy00MzE0LTljZDItM2M0Mzc0MjcxNzM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElAirrAvVKMECaIWmHao1WCxsEJ2oGSH0sh3lz+AH3sPmG+5IqKMT6QusZoBU\nMTA669vQW7YFjvGJJU2gcbwyzKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSVEZDyTy3OlRg1M+yboUCXU7XzeTAfBgNVHSME\nGDAWgBQsb+ysQ5so5EP6NSVA0pbKNHGT4jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIF6dlrtNtJSFgMEdvHnt35M0NHYQK7VL\nr1zJs6OMgaWVAiBFNZSRd2zeGFXTkPigzekqvi5UNGju8cDSaYwCykFm9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdLooWtZtcIxhvuHoxi7EV8sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nODBkMzE0Mi1hOTZjLTQ2MjYtYmI5Mi0yMGVhYzhiMTg4YmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7i6jtUr1EAj02K0mWJ5EFM5RG6TX/wDsj8NOyFMs0GbQZ\nA7iubHbD13UoZrQa5ZYYhF/RA8vpkIjlgZ5T9E9zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULG/srEObKORD+jUlQNKWyjRx\nk+IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNqJQquEU1CwJw/gSdi5wqJ5iiGl39o7yKbhuWR968vMCIDHa1ytgQRiJ\ndw5T3IQs2tFwL+nYw20aDNxWn/8ctI62\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAc7odH5owXoAODg8qp5qFQCwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTNjOTE0ZWEtMGM5Ny00MzE0LTljZDItM2M0Mzc0MjcxNzM1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWZlMzVjOWUtNTZiYS00NjZiLTk3NWQtN2E1NDQ2YTll\nNWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG7c4hw9IwxREKsOYykPoPAn7\nqR7OcouOLinUOKtDHE7ThdvS3+Gcp/Wks4eLpp2DO8Ar7mMKOshfsyENr10fi6OB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSVEZDyTy3OlRg1M+yboUCXU7XzeTAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22ADnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIHrqyodynmfiVbk58tX1f3QaRjaHnr9rqHqyZKWr1FIIAiEAkOFZNeg3\nKVyib+gg18eBvwPT0zOA6d/ZAQPAy6ol2xI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8757", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8757` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAb159CykLCXxoPmehC+bHZGnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZmQzNzVkLTgzY2YtNGM3MS1iYTIwLTMyMDU3ZmU5MWVjNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI4NDY1MDktODRm\nYy00NWQwLTg5ODMtMmQ0ZGNjOGU5MjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMY9hlMPynUVggsPes7j96EiJanR25v+UkFaAvl2fwpT5jz2jwr1j4n+D1ghO\nebicIDdkTsHIfPonnEdU4XK8bKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzOnxIHSf1UclHK29bqmP0a/agvQwHwYDVR0j\nBBgwFoAU+/+efPznOd24z0Ar8BxMN5ddCt0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDUVcRLVi0q1/bXiffaYGSdHUORR\nvnpd5vcgm2ysa7u4AiBIeVh3xpOplel8+z7190su8mowuVczjUuR/LmFL1nDBw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAduuRtoQY0nuP31ng0YX26fWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGZkMzc1ZC04M2NmLTRjNzEtYmEyMC0zMjA1N2ZlOTFlYzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrOXaN1RUnm3g8Cz1KlHX7LlC2L3lM8Ynq47RqpmEBgfbN\nJNRcUVh8dlJEK95k8yfnflAXtJFxcqnEwQYEtXzdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+/+efPznOd24z0Ar8BxMN5dd\nCt0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANlPD9s0cpDAAyO1ZzPz1EJDsypvjcZpWVUfhCa9i7fyAiEA5OJYCyq2\n17kKHxjZNCTb+M8XqONhhGeG9MMTxngv5OY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARiIjhn+C5FaYJbF3/1y1KPBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI4NDY1MDktODRmYy00NWQwLTg5ODMtMmQ0ZGNjOGU5MjU3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzkyN2NmNTAtNGU0Zi00MzY3LTgwOTgtNzAwYWQyNzJh\nNjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExtokAG9ocJ12KELE6+PtLsCi\n3wcvyvFPKNfTNQHkSotJHHY+2XY6E1yuEYXzbif5Lq9oS5wyyGFGXTbfFv8bNKOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTM6fEgdJ/VRyUcrb1uqY/Rr9qC9DAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22AFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBFSIrr2QYqc/9B+yGXUCIw5rbWeUJ2yAOsuWdnIOHhpgIg\nKmI/+JmzNjTRoj2O0Tj35DP+Fq1BnvmXHloHWAh5m1A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8758", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8758` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAdVRGUUBqP1xbU/qO5xn4qwRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkYjljYTQzLTRhMjUtNDYwOC05NmM3LTNjMTE3YmM3OGIxMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzllYzhlMTEtNDg3\nZC00MGM0LWFmNjgtZDBlNWRiY2ZkZWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsARqG8OchnYF79rGILeYScqrpmYj9qu5UKB6gxCBukQfeV6zz7ujfXKysng7\nCvWl235X9qLdcnhO7twgMohnRaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTfRTnvtkKQS6SP/KlxAxVoJqdQLTAfBgNVHSME\nGDAWgBTtZ4qEFyC+R+5I8XCBZJxTUPrWKTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFdeuxJLz1D9R7bpwmdma13MiKNbx4ob\ni7jx2KNIrZIUAiAt0Hfgmgke5F9lR4OjmTtRVX/OHcTpAcPyFDCj45jlZg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf7XCY1i3fGzBtcBByBz+6hyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZGI5Y2E0My00YTI1LTQ2MDgtOTZjNy0zYzExN2JjNzhiMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+bd9bbaTjcMJesdUaWLoJbpLfeLLriG1X1iPOlg/CoI2l\n1Zz74hSXyYaR5cvnenONgsQYWfGHb6kDKOM1YtlXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7WeKhBcgvkfuSPFwgWScU1D6\n1ikwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANWBZLMnLrQ/UKVJnBTpHsxedpJZgqG8pSsWWuW28jZQAiEA8pFvPfGf\ntzNlDeaSO73VHqI+yrKykg6AYCuYHEk1fdA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISATU6X55oNuOKRxTDVUxYvIjKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzllYzhlMTEtNDg3ZC00MGM0LWFmNjgtZDBlNWRiY2ZkZWU5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTlkOGIyMmQtMDFmOC00ZmJmLTk5YzgtNDFlZGEwNGQw\nZWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaQIvpZm9DUaWQq0oSPFcYsqT\ndveh1edhMLKnQ7GJBZA6978sL0HBgoasIKOlyFK91rkyVDahiGgIfNdGAj+1O6OB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTfRTnvtkKQS6SP/KlxAxVoJqdQLTAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22AFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiB95+iH1SreGThInOCXYbMYkBFEyhT7oI/A8os/qBMEuwIh\nAPv4BUxXHkM+cmIqimGlnpO/bWVl5omYYrEq4UQFJPv+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8759", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8759` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAZLvyfECwu2znTpZZ4RN7BkzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzMTRhMjg4LWE4N2UtNGNhOS04YjlkLWI3MjY4NDFmOWUxOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzQ3OTIyNDYtMmMw\nYy00YmE5LTk0YWMtMDU0NDE5NmI5ZTY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0wW5/GLG9xpBmZ9+0tR0jlcPDYKKNRuHMOfr2OMvhXLgBw3Y2K8KYwI734Hb\ncPTf82bIL5tYnqOm4JZK3pGeEqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBEbvIlLOUJjBiePpZU7cbMBr10kwHwYDVR0j\nBBgwFoAUTC1q76sjcl8KLTPSgzhzk3l13ZcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC7JsSFoyItnok6XS9rOzcc14zv\nnFPDqcPP3j3QWfYZqgIhAKKyd88Y2RiOier3NVAMK0i5lEnKuEuj6DvMxW2qna3K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfaVAqingLfXAIOBSfy767ZFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzE0YTI4OC1hODdlLTRjYTktOGI5ZC1iNzI2ODQxZjllMTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/SIk1OT2bXs7YMPOlw4iOZI8naoHN5TlSopUsN6dLNdbM\n2RadXfvsZJI3xxO1Rqt2nnaGGNK8tEp0tEhMGCQZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTC1q76sjcl8KLTPSgzhzk3l1\n3ZcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPGAqxr/QURZxkiW5yHS+n7Kq7oSpgz2/gz0W/4ghq5gAiAOwckcHgYj\nqS99wKVIWiVtn/nvDWWIkPuZ96TFdqxcGA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISASycKQyR6seRKUULISUsG5epMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzQ3OTIyNDYtMmMwYy00YmE5LTk0YWMtMDU0NDE5NmI5ZTY3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2JiOGQzZTktZDVmYi00MzNkLTkwNzQtMzc4ZjcwZmU1\nZTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx+Mnn7HRveBCtFpcg3OJtReZ\nFyIpYJ19yPS816GcwCN+kIggEf9dBW2g+MfyNY7pkLl2DNnZufF1cn1H5ZfXSaOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQERu8iUs5QmMGJ4+llTtxswGvXSTAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22AFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhAMToQpG+0S02rIJAyJkCiFez1ZjY7qivJBhF7x+4Upyr\nAiBWHYQqC2zywtE6H9z1+ec/81ijnMSAQzW+HZlaBphtxQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8760", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8760` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAQSqpra8xeFL5RW9wU/w3nOUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhNjEzYjhhLTM5OTUtNDNjZi1hMjM4LTZmZmNkMDUxYjgwZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUwYTA5MmMtODMz\nMS00NmQ0LWJhYTgtN2IzMWVjYzdlN2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/aZnV5jZ1LobwYctyVzqUevOskjH+fKXHYuewSfeQEqE9YdKxcrNlp3HA4iy\nbUYRw9AUOaFOnmFL7FA8fWgA86OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRKQAMyDtpqljkwCh08KzuJx+Uv/jAfBgNVHSME\nGDAWgBT+Obb2SmWv7juGxi6qG8GWke6ehDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIA0OlCvNxJEX4uUj+UAzaNt6E/MJc+9s\nzX2gAIaNYuffAiBHEadv67h8ylXVQY3y/IqqHwMSaULNWQs0vb9AJfIu2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUGLjoGOSI2zGzdIg1DFhUoAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTYxM2I4YS0zOTk1LTQzY2YtYTIzOC02ZmZjZDA1MWI4MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQahTbhNQ0xi63gjcX9h4fSo0nUh95I9JViIE7s2erNWo5h\nvule3E8NF9LWor7ZvH+ryCniHmrfS1x850wbNTQ0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/jm29kplr+47hsYuqhvBlpHu\nnoQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYG7AnyoQiVXS78Fs9RKxeg75fnVDW6TcnOZoytYko04CIA+lhxhqIhE+\nIJYxxqRx31uLLX630lz1A1C0Amy18KN3\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAfUdqT9btOR1LaEHyN9WezyMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUwYTA5MmMtODMzMS00NmQ0LWJhYTgtN2IzMWVjYzdlN2ZhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjc5MDJhNjUtNDA0YS00NjZiLWIyMWYtODFlZWVkNDky\nOTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb1WrTyAdUDMTBnE9h9xtFYZE\nRmklc+M3/QLOdJJHzaoKETuMDwnK1Cy7IxMBvz8dakugYreebRJN/Q2D6v8zvKOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRKQAMyDtpqljkwCh08KzuJx+Uv/jAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22AFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSQAwRgIhAKn1CMBZeAHuYPQQiqgOq1ed7GAxsw+wsFAcxl7k9hns\nAiEA9rBlzRXlNEt1km+mNYavwmnXM5SNf3QfDKrzjB8Ze6M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8761", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8761` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYP/gYQzZf5ue2zcdCuTgRcDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5NjNhYjMwLTY1MzQtNDgyYS04OWFlLTI0YTZkZjNjYWMxNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQwNGRmMDYtODMz\nNi00MTAxLWJhMzItMjQ0MzRkZWYzZGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExpUTwN6tjuCy9nFLAHfnBBvLk+hoXaer8wSlpgQ2G0OsqlQ7IWf5UP4zzRY/\nl2C/vKpP7SfEKwsd1JPMG9ZVi6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxrXZzCMtZZpeM2HvMxQ3++vnR2UwHwYDVR0j\nBBgwFoAUmzCsWBybLy1ixkfd9Kpiwwhead0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCID/N0k0uDORftJvxMsHnndfftRZ8\ncvCC6kgubDeNYj9HAiEA70i0kA6kNEvulymBOvDAKA9LfFBceHPZz8dadDgT5aQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcIX81N0aSbAjhIILlfrNZD6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTYzYWIzMC02NTM0LTQ4MmEtODlhZS0yNGE2ZGYzY2FjMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATn9qk0bPKSzFj7lbWBKTOnLCraBSZ1mKzrhtbqd9hbqWGQ\nUebKHju/S49ygcCFSMOfkE3QTjTNSoyTYY1Tp69eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmzCsWBybLy1ixkfd9Kpiwwhe\nad0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRfkvsGAVfu903jhIWezcvje4c4qHzUwGEPZT472A18YCIEp3K+l4BdYk\nlV8Wi+YMTHSp+01rwnuXoC1X+LHFY6UE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISAbm+/DaFk7wvWJEIky2d0HOmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQwNGRmMDYtODMzNi00MTAxLWJhMzItMjQ0MzRkZWYzZGYzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjE0MGE2NjctNGU0OS00YzMwLWI1NTQtMzYxMmEzZWVk\nZDU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJKU4xqhHV8dNM8N3bkhz8qNb\nXdBDhCX9YWZGed1hb7r3xQg9V8VZj/9bSnp/HN6jaLBzMyenk6ChCINfSTCp8KOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTGtdnMIy1lml4zYe8zFDf76+dHZTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22AF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIFagJ6WjvLJm76mwkVvlFyu5QOUd10tPZNbCo4+C/VC1\nAiBL8tGNJBa5Dp/7ezLA4AgxHeqI4PETtXmYY4YPlN6/vA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8762", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8762` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAZdDuFv/LQmSime7I9zTQfz+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhZTkxYjljLTFkNjAtNDEwNC1iZmYxLWUxN2JjZWJiNDY3NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjllYzEyMTUtMWFi\nNi00ODU3LTlhZGUtNzVkOTgxYjE2NTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqmvMmh3pwsKLQ0NUswvf/C06+m7kCHZ/7K/ISpPjN+kk+X811kC5yHOmvCI5\nodvcfYt+LsDm7FFf5j3RS0S4xKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSNdNx+wIXM2uaowtL9GO1FS5oJ7TAfBgNVHSME\nGDAWgBS2QI93emk9zqlB9wzTzAzMPeLPjzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFvErbBpQhzjfbJbD5eMVgR9qIy7fzZp\nzcKkzYG0PyHHAiAk2oYn4iCBTi6dEqjZYNzKPfb1HWlm6RE0voAwFBAyWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUboqDUKT1V7/Fe0J9WisFrUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWU5MWI5Yy0xZDYwLTQxMDQtYmZmMS1lMTdiY2ViYjQ2NzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtaRqDfDiF0UxR70DASotdBIBqogRKQGCtKcIsWJMv8xuC\nE1IhF25WclqUkdZXRLRkF9bwlLndKXUBZaHD8nUTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtkCPd3ppPc6pQfcM08wMzD3i\nz48wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANgJuhTz23uMcHsjaqV5cVRnbQ3KRcnlPHaNc0Ez7dKNAiB+cRfuj0/E\nEkMK24TCGF9qmd4OWmuyG6BSDYVJAv3E5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAd6ii+b5sccvBjDVZiw8XXTlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjllYzEyMTUtMWFiNi00ODU3LTlhZGUtNzVkOTgxYjE2NTI5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjBmZDBhOTEtM2VhZC00MmNmLWJjNGQtYTQyNzIwOTU1\nNzI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoKkl40RLhH9pRNm5aivLfwHo\nusC8FHQvYzRA0s0TUiaIoqG4e06MHceP3lW4RXxa99WlLk6l/f8dpovQ+CTRTqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSNdNx+wIXM2uaowtL9GO1FS5oJ7TAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22AF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQDcF9vvvwi3KC7ja5xdEA/+JKEvWvRwqaWTAgix46SL\nWwIhAObUIU69w2NpWejQ3kpVWdjk1Cxua+w9Kqrr6aBJpt0r\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8763", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8763` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAY2BBUbhm3GxSMdlqF+wDHvWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4NWUxMmViLWRlZmYtNGZiNS1iMWQ3LTE0MmMzODE5MGUzZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODk3NTljODQtNTRl\nZC00ODQ1LTlhZjEtMDRhM2NlM2QyM2RlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpQLcHm8zB1wk8NECytzV4mLqPpCpgmQ6ABK/R1QRDCBSwkkIz4piuDFgCEga\neuA2kns9Ju2oEFSgk5sZ0WuLAKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULPzaUdwczD9sSI5dQt60g52/HIUwHwYDVR0j\nBBgwFoAUyaRlIaCfZPr45M3YO50b2WyDhZowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCd1vm0MqgPheWsIUoKcNyJlnrs\nQCRKgD5itJ1n3qkn+AIgbxY0nsCx4DRdVGquCbBsv3kaLsW8M2azrlRLlJR1Wgw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd0FlAb+tDDT/xAPHIfFDWLPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODVlMTJlYi1kZWZmLTRmYjUtYjFkNy0xNDJjMzgxOTBlM2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQMUbuEc4ePz+TCwZtrkLaoTdE8iF/gC9kU5+WJHcXkxL+U\nF6SreYM+MjD/hFjMsVLATozaFNgKao6GVfGtUOVoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyaRlIaCfZPr45M3YO50b2WyD\nhZowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgb1CX2cyWwATh+oAt3cKpOFKV75e55JlOlRRsHukH3zICIQC/T1B9hdmv\noxfMgHGEvUUX801bW9tdwH7KUpuJkuzgqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAQzmZP+q+r4fZCnYyAaux2ThMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODk3NTljODQtNTRlZC00ODQ1LTlhZjEtMDRhM2NlM2QyM2RlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmRlZWQ1YzItMWRmZi00MDVkLTgwMTAtZTk3ZTFmMjg4\nN2MzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEv1ID2KzkIKmbuMEPodjfUins\nRPpAW96fPNUegaqgZqtVGYKb4Mxlwviw7ujD2XdCfzpvVQwp63NcXJ3Hxo5PrqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQs/NpR3BzMP2xIjl1C3rSDnb8chTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22AF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIGyb0OQ4wUqLhucyycj68fDlCh84DtLsTvKdEO2sEnZG\nAiEA+eqLpQSV2Pyf9RXzKNnl8HCs59mzbx6FfN8beGDv6oU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8764", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8764` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAbYsA8i3fIPGmhIJ3VDMNOm+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3ODg4MjA0LTc0ZjUtNDNmNC1iOWJmLTg3ODc2YjBmZGU4ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzFhMWVlMmEtZGE5\nZC00ZTA4LWFhOWQtNjgwZmYzMjJhYWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ5y3t6fKaYqUIrGpymKWPuqKA5NecbZspalcIzVj58mzVrorCGJSBEvxM9pd\nZSoGPOkBw7CGgiWQxXuPD5DMkqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR/p5Gu3yjJttEgvySO54/WGny/ADAfBgNVHSME\nGDAWgBR7204qNHP4m/8ectdpcPY2yfUMvTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAQgGES6INmO+oJdDCGneKqz8eUg8t7L\neEIxEv0OXUTnAiB2douR1aqRU7tsDFt6x07LPt5dQN50aHdmi+W4dTVt2w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcrfHdimbbZHE4cx1b6cuHh5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzg4ODIwNC03NGY1LTQzZjQtYjliZi04Nzg3NmIwZmRlOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfZjes2V/9OfUPnxU/zYSGbs+67X0uuBfcpGDiDPHmAdnb\nLI6xHfZIUks8CSzsxFoz5EJS+mmBT91JTud62ENPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe9tOKjRz+Jv/HnLXaXD2Nsn1\nDL0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcCMvEYr4unwDwSM7nsszb7oy080fryH9KjyUh7aWaYUCIQCl+w+/92EV\nBtILQRXdOAiRJbRfIGdw+nzvYaclNxBlcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAccTJWYYRkOy46sYSEOBbXG9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzFhMWVlMmEtZGE5ZC00ZTA4LWFhOWQtNjgwZmYzMjJhYWYwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjM1ODAwM2ItOTc2OS00MjYyLWJjY2ItZjQ3NjRmMWIw\nMzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtC/ROQxTeqcIdC3SIwmpxXmm\ngWDyXlpwu6vH8aOKjxPAycbtuJ2nO+czXydjoAo8551cpIwK/iBukX4cIeF+aKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR/p5Gu3yjJttEgvySO54/WGny/ADAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22AF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIDdKnOHTLAAq3CL4uilil1mHTo0z8aaMOgFjgw9Y5KRi\nAiEAoGHGbw0owiVTrEjsC/rhIUny0ZxqCtiHdr3zpIz6mq8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8765", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8765` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAVd1yP8ngs9wgJ824Q9/UjK+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlMzUwZDc0LTkwOGYtNGYwNy1hNGQwLTA1OGE0NGQ0ZWJiYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWMxMmFjZDQtMTlj\nYy00Y2ZmLWE5OTYtMDMwMWM4N2FhMDA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjVNiBV48wIBHaTHIJ65VRSd0yk5jxhOJI+CZlibpw3I6JyBSbxG9eMp9hSTn\nWGkfoxm5u08M66Sagfgu0e/C96N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFH2+rZMcblTk2cWe+LJQnGOOL1DvMB8GA1UdIwQY\nMBaAFEWrRaLv43t9hX+2/QsOkHe0UcjgMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAimNoZrnTHQD0mEjsn+1pRr6M8h3lsLI+\nMAdRE6zoa/sCIQC8KyEnB+VPC33d+AFWhgDtgFVpDcR5Dlb4Xwn22WoJjw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVXZ3w1PW7U6ei5QHk2Mk5OyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZTM1MGQ3NC05MDhmLTRmMDctYTRkMC0wNThhNDRkNGViYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuo5X75qBsM/Cx5nvL4lBSQnt1HCeeDTx24MPXiHcHOUNB\nAKpDst2b9sa5gzRQxVxJ1w+e+nhnnVpmflZLLVeio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURatFou/je32Ff7b9Cw6Qd7RR\nyOAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ38auqK77URdugpPwe5RfoDmEWWnKAmVJW7ufdZy8WQAiB02LHlGELz\nBfzQFxtinQM9FZl51ekwCxvR2TJS4FZ2Ag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAfShxOJ15SzxLMIFy0Kv33teMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWMxMmFjZDQtMTljYy00Y2ZmLWE5OTYtMDMwMWM4N2FhMDA5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2E0ZTk2MjgtYjMxMC00MGYzLTgxMzktNDFkOWU5MWEw\nN2VlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEktbf1xYBvwqf69mksYGImluU\nB2e7q4GItr3Jn0gDiLekp3CUDs6BIYmDKZLb4pL/KbvVqXw18tbPe8sIIfQ3m6Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUfb6tkxxuVOTZxZ74slCcY44vUO8wFQYDVR0RBA4w\nDIcEAQEBAYAEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAhUHDPGG/H+yKPA+yNfAn\nHeg02Oj/q0vtOxDPq2u5NRQCIQCu02vZAkk275/hTpNQ7s6H6SjYOrkwiVya3bX3\n0OWacg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8766", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8766` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAQHbo04wD3LayRu5kd5Bmy88MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhN2M4Njk0LWVkNGQtNDVlYi1iMWY5LTk2MWJjMDU3OTE4MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NlOGRkNTktODI0\nZS00ZGY4LWI2ZTQtNzNmODlmOGQ0OWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFBBxBc+s875ioN4mK6VijPhrVNixGbDeBlT0urwWHw26SQs1pZWfG9T/4FAL\nQK4XegVpqUmWI0AIx+jNA1iyE6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGcahipwOqdj4O95UVJ8OiqhbLpSMB8GA1UdIwQY\nMBaAFLzabc8FB5AA/FdMp77vg1nQe5BBMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAyVs6hvZXyZdGC6x+H+SpfC4P0exrUjHnR\n3cfE34K/agIgGp2QDvKxQrsJNeJhn0vUps0/Uo7mQR9KtZO7OeiTRL0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdtzFeygxm/DbYQBtJYnt0gPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTdjODY5NC1lZDRkLTQ1ZWItYjFmOS05NjFiYzA1NzkxODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHcDzKjqvR32HzH7QGIT/QlIBdvK9oDTEzYAsNPSgtHNBC\nR0BkBeQx5iIrinHcDvIqdFugxbeZ4sJtbufmG5KFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvNptzwUHkAD8V0ynvu+DWdB7\nkEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALnnmIQefdGNmlX49F9Y2Ia4dmk2H/7ng42FJVBYhc7EAiBHfBDf6jBK\nXdQWQCtqdvmnF8mZzrpcRRDzehlvcXVYQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAQqeqyORH7wyVm09LVcnM8CpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NlOGRkNTktODI0ZS00ZGY4LWI2ZTQtNzNmODlmOGQ0OWZiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjBiMGY1NWQtMDJlMi00M2VkLTljNzctYTdlOWRhNDlj\nODhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUfA6/XSAL2oO+OxRirjy4Vqi\npnIOPjuByN+GjorUMlhWFvpSVfRsE1m9tmQY4C79gtFt14JmQxBz3YkUI3n9J6Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZxqGKnA6p2Pg73lRUnw6KqFsulIwFQYDVR0RBA4w\nDIcEAQEBAYAEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA45E68gBR8gRNPXZuDsP4\nkp8QbwBFPcDzXjyuTG31xekCIQDSt/7hydMLwxX2IRPC8X64NDDYEZy8Bf2JZMgr\nJnl1eA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8767", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8767` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQSOvmnvtrZwf1vfPxcyErtdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmNGZjNWM1LWNmYTUtNGZjMC05ODBmLWI3ZTYzNzQ4MWJiYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjU5YTkzMTYtMjZl\nMy00YTgxLTg4ODktODQzYmFhZDE2NDYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvY4pRVHoqnCymXjr22rwPGHAUJw4WvjckrgAADq4MfWQzXIIyJfIoABliY0W\n4RHCTenSL9Eq8gC9KBZzNJwZ0aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKCkf7zGhh9jrHaADKC8WRqNQ3OUMB8GA1UdIwQY\nMBaAFDHBXC7lrbeXs119Jhp/RI7/Mz3oMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3/ogPVxHxrk7VuSGLa29lIjRPNjejHLO\nJFZHbuNeSocCIFCvGpV5JaNwNl/PHBlADEuaiNFhmOGeoRAmcUZyoIiK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQBh6lEpbLxFSjQbpcwI35EDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZjRmYzVjNS1jZmE1LTRmYzAtOTgwZi1iN2U2Mzc0ODFiYmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJvgu8lxeRoBJGk3I+3121thrE4O0FqA8btTNen6ihY+Kd\nkn2OFbS6SVdTWBrop+2913Jda2nOVq+Ep4tlHmjlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMcFcLuWtt5ezXX0mGn9Ejv8z\nPegwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJq8Q+tsIvm0PMzrcGgauqpVXxAFWmq622i9TgEoQftlAiEAp0PqJ5O5\nOpilVel/k9c24xK1B0wKQLZ56U/bXZFjXIE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAWtdLNs83rPD9a5nl9J5b2uZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjU5YTkzMTYtMjZlMy00YTgxLTg4ODktODQzYmFhZDE2NDYxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDg0ZGE1MGUtNTU4ZS00NjU5LTk3Y2YtMmU3Y2Q4YTUz\nYTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEckLhDs4RUx3icN92ZoBDfySs\nAvcOPAUaFu9nhQUp35CvbWhs3//iOubkCRWOrqx3lZ9ZUqASrKDw6oBEh7n+xKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUoKR/vMaGH2OsdoAMoLxZGo1Dc5QwGgYDVR0RBBMw\nEYcEAQEBAYAJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCIFiakcNFGaGbWmEk\nF0UKfeYX5tOetKQFPZi/JxYPD/jHAiA8NkKBCMPETFucN89JdfDYk59v7Y1Rgj4b\nt+aaqzA5EA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8768", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8768` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASrKksvs81aV0h99WQnhzU/DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiN2I3ZDkzLTAxMTMtNGY0MS04N2U0LWZiZThmMWVlOWRkNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzljYmNiZmUtZTk1\nMS00MzBhLWI5OGEtZTM5NzBjYTZlNTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4llhwSzSt+oxUQCSxlp7RYP7J1GuIZrRF1XFqoYrT5a+WOG7zEkkPsAn0kd/\ndaEA/Nx+aflwpZqvyoRkmqJtF6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFKUnC9lH8GLRU3Q3PvjSZ/1W22cjMB8GA1UdIwQY\nMBaAFPy+gPu6oqplZnLpoFymhSCL06q5MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAkDF8dSUzkfydSPturfBFkYrQpyKR1dnp\nN9uPoCr+BWQCICxd+ZhiS8sBDwT9PWGy6OIqgY9/ap0Hb3GnU2jg95c4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWEU/e60l/X9bHHFqSt0nk5jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYjdiN2Q5My0wMTEzLTRmNDEtODdlNC1mYmU4ZjFlZTlkZDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtD4aqF/R/QzHjpJRRpn9GKph0IWJmxsfXFXUv0TzaBc1n\nsXDmsHh8HXfRYJm1elFCcuZTDvS8KzEVgds2yQZUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/L6A+7qiqmVmcumgXKaFIIvT\nqrkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgJfh1+chKJEmqlFm6wGDwRouX7slKRLvhT5u68/BwXLsCIGM60x/dMqUv\nuJvAS3BwlvJwA85F+ZKhTwXhNobP/Rah\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISARXYpnHFa7vZJbA6mg1E9DvmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzljYmNiZmUtZTk1MS00MzBhLWI5OGEtZTM5NzBjYTZlNTg5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDkwNDRmMGMtNWJhYS00MWJhLWFiNDQtZWZlYTYzNjE5\nODcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcUSR+rrGRMSXysE7cgzrEumQ\nidVgylx46xT2kwgQx4tQiGaQ4eUL6CgYPuKSeoi/l0/lXamYKYTOIUsNmaxeFqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUpScL2UfwYtFTdDc++NJn/VbbZyMwGgYDVR0RBBMw\nEYcEAQEBAYAJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIQC+2nZwxtqyTwkB\ngwBw8knNJNHEAvGk99KbBcPHcBiUEAIgenTiVytdQrNZoFPQ4IFl93NdRLtbfy87\nBx7qFSIr4I8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8769", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8769` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISARq/a1UwGWM2vGpoCz5paQgpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5Y2U1Y2YwLThmYmQtNGY3Ni04MmVlLTQxOThkMjdjNTllMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNlYzI4ODItNzZm\nOS00ZDRmLTk0NmYtMjFkN2YyODc3ODFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5DF7A3XE2J12S4Se91XinCX5eprFSmGLM18R8RG/QQbQR4o5n9PkKcS4mOIm\nFmptV8hEWyXeaFfGtha3+eNFZ6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSybCREThpsfsaRs27xwexOo0XIwwHwYDVR0j\nBBgwFoAUa7qcU/AruFUYSTJpFN3F88c1J8kwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCj4t74eUMrPrZ9OpICAe1YeEy0\nvdGin/2yCd/knyOVfgIgazfM/qfktZ7TDFLELeUFbYb8Ec94dPcPoNpcZ0rLWB8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbr8WptRcT+gARctleGtveX0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWNlNWNmMC04ZmJkLTRmNzYtODJlZS00MTk4ZDI3YzU5ZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROAdmz+F5CybdkrByDxTZgsRQw9lGXOoE6SeOkpdDPORH7\nf0ES7kktAA8jkb9cAdh0Snb6KyI4GwrLTO78PFoDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa7qcU/AruFUYSTJpFN3F88c1\nJ8kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKCq4j/tJ85XSxZT7lJDv/R0obiT5qVRhBGJRCI85BdPAiBwDEEVvgLe\nB7nNvGyahFoMF3Vt5/gJEkOOzj1vGAgn0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAT1Yahf+RIEbmzW95aKS6O7mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNlYzI4ODItNzZmOS00ZDRmLTk0NmYtMjFkN2YyODc3ODFmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjM4Y2IwOGEtN2RlZi00Mzg3LTk3ZDgtODEzYzhhYzE2\nODA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY9vBDcUSgdXlFkOTVONBBXsp\nk3FjYzkFAYsWDYD7hmAX1gfWDGVzpG3lJfLkT1toaNoRLBUBNFqqI7S6UfDdBKOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRLJsJEROGmx+xpGzbvHB7E6jRcjDAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22BDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCS3oTW6E+yKTHPw8Ej2uE4v8ktp2+xbJzL/LDLc9+/rAIgV8rEpyoK\nDIZ2h4kBz3HghDK1wZLcRwVTms2g/X7SV0Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8770", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8770` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAebx+5WCb6gkq24UWNJ1C6RrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxZTIwNDM5LWUwZWMtNGJiYS1hYTM4LTIzOTQ1MTQ5OTkzOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQxN2E5MjctNTgz\nNy00YmZkLTk5ZGMtNmVkYmY5OWU2ZjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDYnU2eJeuwXxZ8NyLr2TG1S6HvIOqNOLySRsV2T9MWAZOjPj+GKeyoDvs14I\nHBc8np5d3VqMoODfm7Mxhby0P6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT7dQhA58UOObWx0C2Gu2TWFNL8HDAfBgNVHSME\nGDAWgBQ14OvlTkzE3S7I2K+EusfZ5yUvtDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDixTGMXSV4fmlrKpA7PU96kQDJJNCB\nsYnyljwPaSHT4gIhAJ6POWmW4I7DRKQVCJR8v0XFxPs50bIOQ5oMGUd4xAq0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaSvM4mDKHk6awQOwptTaunrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMWUyMDQzOS1lMGVjLTRiYmEtYWEzOC0yMzk0NTE0OTk5MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTaTEthsnCmuzrIaY8u7yYng08OFhkGeAOU0YeyDC+CA8d\n+ys9OQWn+k8/Dx8GYkW8QXodmdDXK75apG1RtJH5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNeDr5U5MxN0uyNivhLrH2ecl\nL7QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSVzYitR2Ip5j+07QMiDtWgQ0BEWamz71Np9RHyJ09zACIQDEoUoo1gjs\nXURY1wvHLHqUtd73nR9p7L3d09Z4pMWo7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISARdTHz+UfSWEPZ8lOudF+7ApMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQxN2E5MjctNTgzNy00YmZkLTk5ZGMtNmVkYmY5OWU2ZjRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2ExNmIxNTctN2JjOC00ZDIxLTkyZDUtYTIxMTRjZmU1\nMmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQOi5/FQiprOlQej+2xZOGHtV\nZSq16EiyEj9DwSMNboQ2OVgg8+Y0B8xvuc3qsrZePHf6RbteAZcBNRM5zw3bSaOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT7dQhA58UOObWx0C2Gu2TWFNL8HDAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22BDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIAcWqp2utGlaQVp5CgIYYHnq5q7Q/HgOQHNm9HtFJ3kiAiBzauCxsV+W\nYMzVMXIlzW9VxF2ow2SqlTwL6wJSwfbw4w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8771", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8771` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAeGj4I2OtqY9Qa4i2qKlFEv3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxMTZjMDVjLTM1ZGQtNGFhOS1iMDg4LTIwZDU2ZDhkOWI4OTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRjMzUyZGMtNWU4\nMC00NzY5LThhZmUtN2ZiNjcyMzYzZmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtgYlbm1I+z/kQXVeP106a3/6JFy3rh7mOenb/dq51U8Gv/xfqe0urtNDaHg1\nXlqOEMNPL5Fg3pc9Bo8VjinpnKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNoO3Pih2FyD3cz0ro4yrxi11PaUwHwYDVR0j\nBBgwFoAU0W6zAmyiY2vw6pFg2I5sXa4BeMIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD9MYE4ADmBq4jSi1DDTK3QPl/V\nJhFeJvH/rr0UtLnWTgIhAPh/WEBHCsVscBTlIl9hFBBN7Xrd+jKWV5w1hoEFl6wL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV1Xpiq/WfBFSv85ZVeOM+ncMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTE2YzA1Yy0zNWRkLTRhYTktYjA4OC0yMGQ1NmQ4ZDliODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7iNqlvSiDZFNEap3EdIxGdBFhndOl93RIt2ibUS/6Zywy\nAkFL/0OKCNBBg3yhl3FHzTe5lKvMvYjRn78Fo22po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0W6zAmyiY2vw6pFg2I5sXa4B\neMIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMjAxtXuHIAdZhc687djkCCFIhmMwwfdf8FvfAZzJ4nRAiB77+NgtK4H\nUDYkOF0tFMqOHn+poZm3ZKOaGfixpzLEHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAdmK4VD1aJ9ngxByYjHd+J1WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRjMzUyZGMtNWU4MC00NzY5LThhZmUtN2ZiNjcyMzYzZmE2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTcwMzUxY2EtOGUxOS00N2FkLWIzZjctOWNiNjI3YTc5\nNWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5ggFgkjxJDr8hPU8G/1mc/kM\nbAzbMX+0tNui2IkHBq7N2K1tXbE0f+z0E2RFgDjVZI7VhO5x29jS/IQ1ltduQ6OB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ2g7c+KHYXIPdzPSujjKvGLXU9pTAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22BFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAkM9DCbi7yTrjaYlJP20+VHuwp0vQiN8Oxm08NqRDBTQIh\nAIJLGfLKtkSsPbXrfu+iaoXEEZB7bT29LW3lV4nKWGgO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8772", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8772` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAVXM+84TlWEFagBSUMxLyoUsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExNjc0NmNiLWIwMTgtNDhhNS05ODA1LWVlNTA3M2JiYTk4YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ExNWRmYzYtNTFk\nYi00YzRmLWIxNzItNmJhYzE0ODdmODEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9w7NidEQN8jmEB6D/Gpq/cAgc+7RurxFzV9CtM8I6PL7UDRQo0RAgqT9mnHa\nj/n2oC63Xcf1O7ddypJLqFc8u6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRFDeIMfrrMTe/ASoBtE20Ec0C39DAfBgNVHSME\nGDAWgBRbo4IoW3FYNTEmtpI9tUTekk0BqDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFqftW3veo14AYVojiVS4+DgbsqtWAvl\nNhjlckvL7jajAiBGVA/ldVr3K8iho/KHp2J/N8xlTxvtsKDWkpX0F/nlbg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfcy9ZFE2lY8QwtLnbU2GT0BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTY3NDZjYi1iMDE4LTQ4YTUtOTgwNS1lZTUwNzNiYmE5OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpT8z/86ErvufkK3GXxIlO0IaX9Lx8TRFgZhWbZV31nZzU\nf35J3CUfrcfN4FsTzL69cnFAHq/Alt/YNsToDfVlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW6OCKFtxWDUxJraSPbVE3pJN\nAagwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPXLJXVwUcFH9QUi5aCJv7vOnWCRcom4Xo4OcPnn2GtkAiEAiNQ8j2dS\nHPBRo+Q/vDkZvxnIUniTdYsVgu0QJuPbBFY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARgyXxCYnSUY+D6OGXSJNw41MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ExNWRmYzYtNTFkYi00YzRmLWIxNzItNmJhYzE0ODdmODEzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGU0OTlhMzMtM2JlOS00MGVmLWJmMmQtYjIzMWFlMTA2\nNjhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErdpCGRfWQ/0wamrtUWB5pG3/\na/g2M/mSQjQJSGOkNDcQDIIfQrmbqyUUzfXcI5tIAUOzoj8J9gTNhNwZBV5YbaOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRFDeIMfrrMTe/ASoBtE20Ec0C39DAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22BFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBtoEA3XM9TyJ2x/Cuiae9MfEisUDf9l3ID2ALQo0LrEwIg\nSmjIxJ9eQJO3HnEipr+nZMUkFVcZ3aDs5uMgJj5kicQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8773", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8773` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeZPEHRRnA4O6Wm+nMwbA6AjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxMDQ4ZGMwLTFlYTMtNGY2MS05ZjIxLTE2NWYyZDM3ODY4NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDc0NzIxNDQtMDFj\nNS00NDc1LTlmOTMtMzZmNzJkM2ZjMGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8j56z6ahzUPo+N+rEHHiGyqJTZd1Rub3jb0HwjucSMmEORQwVP/MVl908bRW\nUgljx+SiEUTGE5CtShnwekjgSKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBvG2P6GnQ6Rs8D/X9uyiNusGeVIwHwYDVR0j\nBBgwFoAUb2n6BQFxKu9kxQeAKioJLiPbdmkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG6zR/EaSos3FYUAgSx8LJ5Rq2MJ\nt98j5SZSamMrE3V2AiEA3VJZthE56KFaaIqJLtFqPPBEhbSEnVTVF2bjjoiOMy4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbKfajGTIhjHJp+ULkFJmMJNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTA0OGRjMC0xZWEzLTRmNjEtOWYyMS0xNjVmMmQzNzg2ODUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaaTmX/dGIKDdIJLW6yy78g5CxGJuU7yufT11r3+IU+raT\nJ9BgyuWz9tTtQDZoOgWHMBu0BDQlkCWRh0E/i5Jeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb2n6BQFxKu9kxQeAKioJLiPb\ndmkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBFQe4IqTE94XN+AVDq6cL3PJBsu4LFnTlfHeQzZyHE8CIDaNY7mAIKty\nMQO2yBBQvwUvpfWUw+RUy33i7RPYleFv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZFPszOd+gkMNsXAAmgVHiUtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDc0NzIxNDQtMDFjNS00NDc1LTlmOTMtMzZmNzJkM2ZjMGE0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDk3YTVjYzMtZGEwYi00NTBiLWJmYmMtMTEwMmU1NWJk\nYTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFuool15rneAawKAFe/gYXwlJ\na0z7NNqdYNYLjXsEghK2Aaj40x/sfjNJwssxFPnO+LNQ6/66W/DuX7ciBQrPH6OB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQG8bY/oadDpGzwP9f27KI26wZ5UjAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22BFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIgdsqBhQeb2GAZEXFNiwNe7UFIoSSxpjp4i9AbbL6u98YC\nIQCGPDr5WgjwOD/yNwC/B1TNxNGuIgIDvboaafrY7E6Zqg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8774", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8774` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYXwo2wjynwRB20YIxJ3h1zdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZGZiOTEzLTY2YzQtNDYwNC1iMDMzLTEyOTlhMWRkZDA4MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzRkNzAzNGUtMGE3\nZS00OWY4LTkwY2UtZDBiN2QzMWJkNGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETRSl6oUCvjLWqoEAhHh9keoiMlhNEQZlFmxLvcXjIfNF/jSGbbsZh28z4ppV\n0e8DhCItJyOLF0NdAJdmyQ0mnKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT+X1Yv4oJUZJqxojKIFVTBfPqF8jAfBgNVHSME\nGDAWgBSkv4YVYzn/84PLbCDopJvKa1je7TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAkhBm13hXpNeRcklFjDEDgMAjIpwSE2\nP/9+JQNgueqZAiB/as1eBYTHfIQaZzcGzfGkkk4VzrcU/J6XzQ8a+t9O/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb6ZJcnmtFVj78hDOiLt/fcRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmRmYjkxMy02NmM0LTQ2MDQtYjAzMy0xMjk5YTFkZGQwODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKyARrJCe/EzmK73++rfk7+630TU/Z5C4sfPtEG33FKg6n\nQRKkVJNeqGwcmVA/BK5ueO3TCAe3rJ/lcqdGEleJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpL+GFWM5//ODy2wg6KSbymtY\n3u0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL0UWSHoxh03UH5WOc3NQ5fEx1hGCzwETqqZbgPMd5EhAiEAq4UgNRWo\nSDvWKAkKtQvoJK0Lzn2Sewj+VLwU+rO4RTY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYmWrJU7EMVM10Yg/H1/KdTRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzRkNzAzNGUtMGE3ZS00OWY4LTkwY2UtZDBiN2QzMWJkNGFjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDZjNDY4NzMtMmE0NC00MjI1LWJkNDctZDI1ZjRlNmE5\nNjQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJQaxM8a3AatCdKwDo5tFf9mV\nzwuzdlHI6R1G2e+FEfkvgjD+AmCx+yEmfwvGT96rIfgDt8THl0i8TY8CDf33eKOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT+X1Yv4oJUZJqxojKIFVTBfPqF8jAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22BFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhAOQWrwOUGkpBf7FS5Qq+oMxI3qae4yIsq4nf03g6vjfM\nAiAtwv7qvvxyAGrL7tUyQFs1ni91Lqn3xKCMi9xlPqUTNw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8775", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8775` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeozXpwCkRxK9n1Cp2gX2z0rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhMGRhNDBjLTljZjAtNDFlNC05ZWNjLThmNjg5YjEyNmIyODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjlhNjI4ZWQtMjg2\nMy00MTgzLWIyNWQtYjliM2FiZmFlOWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAQF2j2+BXF+JSsiJh7gyaMVw4M3+CryGZprtcEo7QoDZZNOS+nQiT1QfuFBl\nlyfpna2iLpMGdLUIwCJdScpD4qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0wa3+ulhOdcDv4AZ5umDznBSwtQwHwYDVR0j\nBBgwFoAUzJTID3F7+SCpFPInnUdt4T/5Xp0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICNFTBLsDiAhKvGIf3Ykc1x/rpv1\netlbjgBAz/1TRP4dAiEAy3CY3cDXS7ce+UlTA9QMfc/0aUGsam8yHbz+CfeQnpc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaujuJcfUapgg7h4muD5w7YTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTBkYTQwYy05Y2YwLTQxZTQtOWVjYy04ZjY4OWIxMjZiMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASV79WKUgWSNWho7/wIvLtDAZ14kZd2DhGx9Kr3xNi/ZRoU\ncNEDU1I66UiJjzaGdH8EY3BTMMSs0CWkAdi96QRto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzJTID3F7+SCpFPInnUdt4T/5\nXp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNWacrdluhubILW9mq1dsmEfDLYS2WeYXidRD9FeNRs0CIQDAozB17EqY\n246SiiBHSGPkJFSC5HeG2HpnpFXCt/3g5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAbefox2CfkV+gRWeKc6AlLfqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjlhNjI4ZWQtMjg2My00MTgzLWIyNWQtYjliM2FiZmFlOWU2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2ZhMDY2MjQtMTUwNS00NzE2LWFlZjAtOTFjYjBjNTBk\nYzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEALV1/Wj2tCuNSIUNSVFXYBMD\nNBPY35k7/V4/DBpaB5/8mq2QxxeE0fzwaJrj+eUAk3ZWWFRpv+Q2dM2LNVnFHqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTTBrf66WE51wO/gBnm6YPOcFLC1DAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22BF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIBMv0vedj3iJUnCI9zFIpJanmOcXkiXRohVYXX5aiLb4\nAiEAygbp2gdmFHQDUdYHxnqkOgIJpRg+2nCUfXdSsH0P0wI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8776", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8776` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAe0Dwbd5oPumc2hHnMt+5Ly2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0ZWE5NmE4LTViOTEtNGUxMy04ZTZmLTA3YjM3YTBiYzE0NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2YyNzA3MjAtMzM4\nZS00MjYzLTk5ZmQtNWU0N2UzZDhkZDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8u80HxUBPRKVeJNPxch7Z7RGoqvRP8DKAVbBTWs6pjepmdg/syM01vxIDq2d\njfcWfSYQhm+hOmM9RHrIh6Sei6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTFeWNSeX3y0CnDW/xn4eGWwC987TAfBgNVHSME\nGDAWgBRYp3eH86w0WOW6EDX1wU0pe/X/tzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIECaTsKnrBEzk0v3cZOOlnbPLnTCIwMD\ny0daLQX98nijAiBuCHIR6+vF2tyiI53xlybBS+TheDtShOZFQWMRzv51cA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbWQvKK/35n4KgrDwBeh9Ue1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGVhOTZhOC01YjkxLTRlMTMtOGU2Zi0wN2IzN2EwYmMxNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+S1EhtZimTJ2sWtfzXu2ssEbD2Bk7e/k2kj2ZO+BUp+Hi\nOrhRTYv/sz29HGFfeaQNLtNjjPCgu2bPAbHZgyt2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWKd3h/OsNFjluhA19cFNKXv1\n/7cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJE8me+ObhOwb1aBKH56w8u/jpbJsnoctSQjySZ91H5qAiEA8R+D01vO\nyxawpaJxti7zy0d/xNPT3Rn8873WeCRto2Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAdSbp9l/NQcZ77ZWZ2/q7jA3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2YyNzA3MjAtMzM4ZS00MjYzLTk5ZmQtNWU0N2UzZDhkZDk4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTJlNTEyNmUtNGQ2My00ZDcyLThlYTMtMDYyZDhkYTQ0\nYzYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEotIY96p1yo2x3xHTUCzEcMHB\nbikLd1UpsRRxxi6zOzNsPCAGfJTSYuPwywxQDN+FyClCJo0RY8cWeX1x3b84q6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTFeWNSeX3y0CnDW/xn4eGWwC987TAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22BF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIBZEacF73wwQNnFyFIfn9IIqvAEVu1aCzRWvnRg3sVEG\nAiEA5nXq7Da6QSIfkyZ8bbEbeWvMzLCm0+xDOCEuBYUv5Cc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8777", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8777` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAUtDXRynmZ3Qos25A1dqvRxBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU2ODQwNTk3LTUzZTUtNGMxYy1iZjJmLTE4ODRjMjFlM2E1MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTAwNDExNDYtMWI2\nZi00OWUyLTkzMzUtM2RkYjYxYTliYTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsKvVkQQ1urrBM84jH6WpWjdcy+1ngvnKrALI7vfcMzxEJxRPzoSs3gBlOqlZ\niuuGt/pCIYfznfDxA1ciGZrppaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjB1U5uNHOdwztED/3xbmXNL6xMMwHwYDVR0j\nBBgwFoAUQHVhhwQfZszqaWvL59+2ZZcdrPYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFWsGfSL8+Lm91ZF5ReaSEXBFnyo\n1q1Fh3DTCLTWvxtTAiBy/2bgINLjNoCHXOAIChXACUdfQXPqSC/sgPsSLN87gA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdWFqpXbOs1ActLfenIFTZdaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNjg0MDU5Ny01M2U1LTRjMWMtYmYyZi0xODg0YzIxZTNhNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaWz6XZWp+OmxSPaDXxsO/ri+niSCXailUtvlVa7dvUdyD\nz1vwmxOxwik0/XKh1sa+/cf48+H76sh/5tvgG+7Jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQHVhhwQfZszqaWvL59+2ZZcd\nrPYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd8qydtDh+BdZhk9fEbRHF2dqHD3ZpR56yJySvhybYyACICrNW5zPQwAF\nPZf9Okbep1UVx+bVCoZYrkFEx8XSlivg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAUCAhm9W5BRaOkkgvdgnLW8hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTAwNDExNDYtMWI2Zi00OWUyLTkzMzUtM2RkYjYxYTliYTY1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjRhODZjYTgtNWZmZi00MWY3LWE5YjYtZjJjZDEzZDhh\nODY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE10vbsJ0MZvL5L89zuamExB74\nqCJXlzO/VNultxIqiJjY0lWhhmr+xk3bfu2cIK6hALmlf646AEmNznoneos2hKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSMHVTm40c53DO0QP/fFuZc0vrEwzAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22BF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIAmEkl7uGF/z/yNanAVAoRfr+yEEuKMQdU1oeytpgpEV\nAiEAhtcbB8zaSEbKDaaG6ThORsddKhYvBz4G4fu/dKOZow4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8778", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8778` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAYLUl/u3zoaDPOTiSvD/vFiTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlYzA3NDlkLWFmZWMtNDA3ZS1iM2QyLWZiZmI1ZjE0NzM5NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWFiZjM3YzUtOTNh\nYy00MTI3LWEyN2QtYTIzMTliMWU3NzNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9MGByUH9rs8KqLdk1h4S3idn+7xEXAVZRByBjRNuscPajRIhRSRP5JwbFRwd\nQr2NtJDKdhCOq5tBoSvrewD/JKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT6LGsbNd12GtLvvIZmrPU4iJ58uDAfBgNVHSME\nGDAWgBRii+oYZdIJXi5iF5sfIqfYBIadSzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDIRo6a7ieymmJY3HM12Bfrl8Nvl4xK\n8zGmKVREORfizwIhAIrzANhOXmOur6g98UH5qJDaIQZxsQPrf9+POYTFCiOD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUoYvjdMgQ+AZ55OizyqRKShMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZWMwNzQ5ZC1hZmVjLTQwN2UtYjNkMi1mYmZiNWYxNDczOTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASB1WLTmN6QkNcprR8H57kie21gBzAcRoNsjv4AU1aQOr7N\nsnh4wJp1NE9/6ag/4pIFq3KdVZi7Nz4ejW77jMF3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYovqGGXSCV4uYhebHyKn2ASG\nnUswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALKwmXzEauCje++eJcaB/EDcAslfRwenwJnAO9K3wU0yAiAPXkmpmUZZ\nz21sw4iLQycvSJ5Bu/yxD6aR3URfKOMoVA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAeTRukn5n8YcqnXPy91irsHYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWFiZjM3YzUtOTNhYy00MTI3LWEyN2QtYTIzMTliMWU3NzNhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQxMzE1NGYtN2JlNS00YTcxLWE5MjUtNmNkMWZhYmJl\nMDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUwi7Mo3HhTtIu2YJAAuKizWa\nq34f94Vgeaa7tT/bH9p8TqYhSwn4Z66cKmFR2C5oLc9W7LCU0mOcTgGBCAlsYqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT6LGsbNd12GtLvvIZmrPU4iJ58uDAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22BF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQD+iG0IzY3/ISoLOfdtFkDbk8Y6xvHn6LrZYLOXNvxd\njQIhAKJ9/ZLTDczTGvd+gGJUJybxKTslLHP4NAIFiDjFUWtl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8779", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8779` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISATigmeymnQD442CZ3eyadMfXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0MGQxZTQ5LTE2YzktNDJiMi1iZDFmLTAxYjJlMTI0NTRmYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJjYTIzMmUtYjNk\nNy00YzY2LWFkNDktMDg0ZjUxOGExYzljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvKCDhvc90ZFrL2KVdxUw0MtvPuKUqOoZTWxmNwQSy6w2kncVuPp75lqxR9GB\n0ruC+bWIDPAvdcrz4RcaTVTlPaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDq0cyO3I1G1PTOwWqIVySjn0e/xMB8GA1UdIwQY\nMBaAFAJLzuX0XwpupFmgpD+WzVd2GfTtMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiARhqnrWnwI/GnRK5jbT432o3547xz86QQV\nzoNtlGjV9QIgNRSlqAFffOuDO8IxpUqvoiyZSruKxTB05MYhICVMkXU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAROO5FiTabDESWlLcntccKRJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDBkMWU0OS0xNmM5LTQyYjItYmQxZi0wMWIyZTEyNDU0ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbQa++FeCGVp4R5y2+dzi64fJrhMSAugnUYDa1BfN5s9y/\nwy6PkGiAehXEY4m0pi8sDLNlizh0rQBNZTvOb1Xzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAkvO5fRfCm6kWaCkP5bNV3YZ\n9O0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPSMTsB8Gb7bgPIxr0+4s7ThHe/Nlmd5J6ldSGz/3Ph4CIQCHzX1ZvOqQ\nDWk2aL8wSiyqhOKd31KAer0A0OV/ryoa+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAV4A1OzHQh3bLon4HKrGRNH3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJjYTIzMmUtYjNkNy00YzY2LWFkNDktMDg0ZjUxOGExYzljMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTc1YzNiY2YtMWI5YS00NGY2LTkzOTEtOTA5NTFjM2M2\nOTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3OxhJYynXUSOmUPp5ygLBMUk\nkyXEM/dn0kg9dIC4BNjllCLPYb6MpZUl3VkW8W3EC1wgAx+rx9CSjeb2PUdgxKNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUOrRzI7cjUbU9M7BaohXJKOfR7/EwFQYDVR0RBA4w\nDIcEAQEBAYEEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAvTcTHCQs2Phun6/obtSV\nCq2KEG+4dyVCxF95aWyy0/oCIQCzXZftSQMTtnDa5C2bk6bdImAyqy8uY2iO06Jr\niTZy4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8780", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8780` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAQzXewtO6Yf207SL3wYEQjaMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3NTE4ODJjLTg5ZDUtNDY4OS05NjNjLWY3NDE4OGM5ODliOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM2MWNmNWItNGU3\nMS00OTBhLTgyOTMtNDVjOTA0MjFkMzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbrxqTjdlpd20OrK+Di4+MIO7DwCmOoT49NQy1rhFLj4Qp+TJ5B1zRXDBF6Th\nbHlWEYsfScimSSZgLhbhUPVV2aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDcEGk7a7tTz8ET013bdWUObEGR6MB8GA1UdIwQY\nMBaAFEjgH6IPqLoIWxE8pdcJGuiJGqRRMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAkjsABxqTCTEov0kLYxmHWFt3+ZQvzcWO\nxyvg614P39QCIQCOX0m1r1MJ+EDhQcW3fsLT/LWXN119ZIcBIDu3emNXcA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfSVZuapUKbp1orQtn7iH3CRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNzUxODgyYy04OWQ1LTQ2ODktOTYzYy1mNzQxODhjOTg5YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT086bQfdQbUenb7GjMmkODQo+EZD7KZSujJsEkg4VCxfX9\nAe7qfRDsO3kfkeWT8p1Fr02wlEuPO04UorFXzuK4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSOAfog+oughbETyl1wka6Ika\npFEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJzA6HQP75Fjs8VG4/buf/+jdhxZweBwn2JGeJVSYj85AiEAlwyU9IMk\na5xM1FD6XNlkvMnXfybGtsUjBjMCCFoTI4o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAdo0OLny9oOEMA+2jgiHAqn/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM2MWNmNWItNGU3MS00OTBhLTgyOTMtNDVjOTA0MjFkMzg4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjQyZWU3MGEtYTRkNC00ZDgxLTk4OGQtMzU1YmU4MDhm\nZDA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIw4VUMQtkZ7IBg9Hs2+oxhtU\nM6zPXlaSc5oOM09pGG1iFAhsTBeknm1nVq9/hxe12h9EhvErkildqQhsKffxC6Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNwQaTtru1PPwRPTXdt1ZQ5sQZHowFQYDVR0RBA4w\nDIcEAQEBAYEEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAzdCqHnO52kGpIf0Vn7FX\nVrm0X6sy5m/Qvj+JviNHEOQCIQDV2E6sLtTmI/ZOCb4PUvRVpT7yIiBoPYQYI8/n\nEN9OGw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8781", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8781` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAc6Kkkk5xurrLplln3LbSrh8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1YzBmNWZjLTNkZWUtNGMxZS05NWRlLTNlMGU0MGRjMjRkZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDUxMjMyNDgtZTgz\nZC00ODhiLTg5NWMtYjdmZTczNWJmMDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEttJBelp42Qaa31LSy7KLUbfAOzEH7yhytoGahR9YbDjXiU6wGEejEboUSUf1\nDzuumHIGI2/s8f+6a4eIXO0yZqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAA4vSmAL2nLUmlK1vkgoONboLLLMB8GA1UdIwQY\nMBaAFPI2UvvsXfwzHdeX2zXXskzCXCqMMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBQZXh3G+riPyyLlDkTP+2sxavC5d8S9kQl\n6DcfEr4iiQIgDBfqx1S0eGzBW5mD5Vhj6oCaAiCrt3HYkK8xcYb/lkE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXwM7rxZ8cKpRWLFhSaLBcxEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNWMwZjVmYy0zZGVlLTRjMWUtOTVkZS0zZTBlNDBkYzI0ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXxEJWoKZYixn36OIWneasqZSzd448VjJeVzBPXWX1EpRY\nf3I5L9S1Ah2DZaqESm++9KblzO8zQZ1w/IdY5Ralo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8jZS++xd/DMd15fbNdeyTMJc\nKowwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgM+0eN+kkigW6rUShOTPMVVkpqJfYzM/ADJvSC8DtZCQCIEd0T1KtmwUY\neoe+kyf4q0hP7Yg7Mh5cmQp5ydcFSq1s\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISATYZ60FZc3p8oS8LFjDwI/XdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDUxMjMyNDgtZTgzZC00ODhiLTg5NWMtYjdmZTczNWJmMDAxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjUxZDNkNWEtYzY0OS00YWVjLTllMTEtMjQwNDViMDA5\nNzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyohJwbVXzx8acX+RAOl+ySo7\nY+JH3QIUN+DxgDUU6Z/wWshN6dt77BboHQiO3+UpgzqgQ/CJzAFHKbTZXG1or6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUADi9KYAvactSaUrW+SCg41ugssswGgYDVR0RBBMw\nEYcEAQEBAYEJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCIDRed0RIa2Li6kw0\nbGMfv08c5tcdSnIqi5NlgeDfTXiPAiAeWZOLwQGAmV612YjZR44aNEC3Begv+Kup\n2wJRsVLzzg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8782", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8782` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAbVdb/eSRWa3reVUqPJd0WYoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwY2YwMTU1LWU4N2UtNDkyMi05NGJkLWMwODc0MDU3ODY2MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzE4NzRhMGQtODIw\nZi00ZDk1LWI2MmUtNjgxMDAyMzUzMTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnyNwAIWIBlsFNSKJvdtoGKMjIZuTTxn41hHn/kWih9w6KQdAVvhLLFP/BevA\nUy20tRuKFh8Mump6AKR6D5nAEqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGl9GGQNzpGrvScAP9mNJoimxI3UMB8GA1UdIwQY\nMBaAFJt0IFBGyFddcGNGM4TkXolt8sbcMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAtQ3Wq437fBHM+FbRe9emAetpkcIu1DHcH\nQyBcjqyfgwIgFsSutc1KGTxHCShH9IcjrxNSYhiHux+KpLoKS6kC01w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcn+DH3nBXpV6zS0gsgjYIYRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMGNmMDE1NS1lODdlLTQ5MjItOTRiZC1jMDg3NDA1Nzg2NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIpnR5x4PNOsNW5pDc3GCEFIyM64YvZjfbOpHu1saGk8vF\n+/nJlk3/b0ENjmoUubFSHpbwcFYLQ7DBW7oFKlY6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm3QgUEbIV11wY0YzhOReiW3y\nxtwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANprxd5uBY9wdarjXD8zyFgAlw9BlhXa3oBx+PHvFVKKAiEA0CBK3OT+\nfL7QQY9ledaURmsOyiR/sUebkB4A3TN6TEY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATfBOBI2mFTkYuMX6n4Jhb5iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzE4NzRhMGQtODIwZi00ZDk1LWI2MmUtNjgxMDAyMzUzMTMyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDk4YWMxNjgtNWViMS00NzJkLTkyM2MtODEyMGM2NmE4\nNjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENfvJ0Qp1MgOw13I3iodUoN1D\nzfGKB8DZDueKrNmnp5z97jleuckj2TQFZDlAcRg+EVkD+a+ubtPxJXb2YNZZ/qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUaX0YZA3Okau9JwA/2Y0miKbEjdQwGgYDVR0RBBMw\nEYcEAQEBAYEJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIFGjL/GTDc3B5rem\nFTHZxJfRftsF2NkXdYAvHF6Ex/QqAiEA9GZoj+75IWTMt1S5sYI9dgoL62ut7Fm5\nR1Yo1HRsIwU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8783", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8783` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISATSLhVIJgdPL1dPnEka/2bhZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMWQ3ZjQ2LWNhNWMtNGRmYy1hY2E4LWE1Y2ZlMjQ3NWFjODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE1MmRkYTktMDI5\nZi00ZjRlLThmODAtMjViM2VhNGM4ZGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBhvvdTyE8oSUDfYZM86WgzrkLhSw6mHSoAJd9BzvmqPlsnDgWgT4sn4717Pk\nQC3eCq34bSRWLn0iVoJPSfTwcqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCQhs22P+ibWDGshzf5fxTdoZBuswHwYDVR0j\nBBgwFoAUryb0joz+ulXAN+EMd4Rix4ZaqxgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD1u5O3XEHM6eCrnX45Ybed1ZTf\naFSzaPp8hNU5OxPvaAIhAIBmChSWgwJSALHGPlRSbmFtez7AJVqowvKHp+TSO4QG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbVveqDr58Aa6y1Pl4CvzCKTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjFkN2Y0Ni1jYTVjLTRkZmMtYWNhOC1hNWNmZTI0NzVhYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+wUOH1kvtheZ7Ra3qpV9/T+twYTgkePAixe7U//vWv03A\nuTVZcsqwTnym44C/qyHqMekFeP4jJaUJpsjwwl7uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUryb0joz+ulXAN+EMd4Rix4Za\nqxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOl70ly9QBnm68RgUMxSeaAXRk0KXn4up4YjoODR8tSkAiEAh4HbqBeK\nGW5bnd5RiJzXsnj05SPapego8bXH1kReReg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAdvBIYOMU99q9d+iRxXw9dFLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE1MmRkYTktMDI5Zi00ZjRlLThmODAtMjViM2VhNGM4ZGVkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjUxMTVlYjktZWVmNS00OGYwLWE4NjYtYTY4ZWE1MDEy\nZTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHotqEGnATAbmqHA599G8uAt3\nypL1iNw3ZUxe4cQIJZ05pPjzyXut0nbonP8KNn4PAxnb3Y9XhXfdCq5jp56feKOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQJCGzbY/6JtYMayHN/l/FN2hkG6zAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22CDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICizrdfhvQQjG3b+3dDSZsRd7bUUIsMjOR/DBrwuMLUkAiEAqS571TK0\nHuCumSDBsPJ/YZ0G5nphiLsu0B2y0cCgqhE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8784", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8784` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAQZtsSMkiruhHalXmR6yFuARMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1N2Y2NjM4LTljMjctNDU2MC04MjljLTNkZmY0MWNjZGE5NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2MyZjJkYjItOGNh\nNS00YmUzLThlMTktMjFkZDI5NTMyYmVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDgznPQAFYpaTLkaAa4GvrVXhOVugEDl/QzQaFvea84TMjbndaOgQ/nHtevwo\ndiP/a+xxGbn79mEdjlQCOV/Q56OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRcH7UmRb1eP3nXzOqVASoBVt8SVjAfBgNVHSME\nGDAWgBRgc9fSTGQRZ/sLOQMO7beaUdfC7TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC1qeqGwUZEitsrCYewBfM6GSD9Urwl\n5ND3Xyykvyw+hwIhAOL5yz0wssm75iOOvcxLVE9LyxSVCifDOULOBK+/rmX8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfLsUTCeAuXk9f8khzNhpIKeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNTdmNjYzOC05YzI3LTQ1NjAtODI5Yy0zZGZmNDFjY2RhOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgKqIVxn8KF3a3zkCtxmfoacLvkdK7iI/7DyvaTmFTbFUq\nS74YFGn49PBwYuSgUnpkgWhZo3YHcZ4IphP1ccvLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYHPX0kxkEWf7CzkDDu23mlHX\nwu0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMP2RP3fUYPw+xb2tYo/rBoZrG60llOMCgaj9isRkym5AiA83KSewPSw\niJ18Zw0SrfxhtgMRA4WmOKNQXvSm2VLpvA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAdMi+6wMyPwQFL1PTLpjqEHRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2MyZjJkYjItOGNhNS00YmUzLThlMTktMjFkZDI5NTMyYmVmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjk2NjQzZjktYjU0NS00OTU1LWI1YjAtYTcxNmE2NDhk\nZTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyD8sYbFA57Szr/sWqNA/TGbt\ngfALBzgltkgpTWyNKBsOVvCF5kROD6f0Ay9bM3qsiexCY4e8biryzbGI87cmoqOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRcH7UmRb1eP3nXzOqVASoBVt8SVjAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22CDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCF0AsMYdAZ2344Ez89yHtdKR7/w3bTd9b3uNJwaIL/3QIgC8CKSceS\n7AZpZOghGo+1dPWArvsZ7jCkStRW660SMFc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8785", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8785` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISARInt0zvusvcvSqjPIx1ZMNhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwNTg1MTk5LTkwOGEtNDljNi05YTMzLTZmZGE3N2E0NTlkMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZjYzg1NzYtM2I5\nMS00MzA0LTkzMTctZWY1ODJhNGU5MWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQjorVkLYTO2kVuYYJJy40AdE7p3884atIUhvIeyQOz5KWwFnjdIYsq9JoVCe\n96bCHlbtsTDiErqPugr7j7Zo/aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2tln81EWBaTHaImAvHVNeN24I44wHwYDVR0j\nBBgwFoAUr6bflE339sXMvTU/byYOsn/zBQswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBDiwzAu9rAoL/aluPZXy/a7cPM+\n6dPAeDKxkQ+9vRemAiEAr/vLngpJVjn75pZZiAFFYFuNAcCrDWMGWYp1lyaxP1k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWlLbRjivnvS8zl51wySaAdYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMDU4NTE5OS05MDhhLTQ5YzYtOWEzMy02ZmRhNzdhNDU5ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiTeOXSjHJiT7uBsO6x0uKPdazmcyI2QHz8T6Ix07e4k06\nZ4nUDm9GMA11gZfYug7E+YBkdFQCsgOv+x79yG8Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr6bflE339sXMvTU/byYOsn/z\nBQswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSPyDSZ7Cavc13dHZauaLb9dyy1Nw2YuXYB34xcS4Ef8CIQDfbIxHxC8I\nsATywXK6L8QgQVOkx4mqkCuUE8ug3GkaLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAYJ/LjMMd7UTscaMGxL3SJzxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZjYzg1NzYtM2I5MS00MzA0LTkzMTctZWY1ODJhNGU5MWFiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjZjZDg1NzMtNjFhNi00NDY0LWIyZGMtMmZhNWRkZmI1\nYWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx0CERKp1hrKNjC6rpHmxoBeK\nqgfgJ7rUoweE2XjHPxP+KHp5uFX9MssadlThuLuYkL+NPdiAg1/DSYa6aItbLqOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTa2WfzURYFpMdoiYC8dU143bgjjjAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22CFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAhMACgPvYTAkSJe5QN2v2CTqou5HYZRRhxfGylQGNsZgIh\nAM5XZ9+G9fRYrgy+1u9dZSzMv6hUUIrR2y2N0anvGutX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8786", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8786` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAdfcZEMaGUe7679u/uVcGp9tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlYTZlMGNiLTNmZTctNDA0Yy04NmEyLWMxODZmYWY3ZjdkMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZkMDEzNDQtZDVk\nYi00ZDkwLWJiZGItNDQyYTg5OGUxOTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMhNSpvUE+gPDIunzttW2kMjNtKDzsspVdOHWzsl53oF+/MVgP1zwufVUo32o\nSHnEPK/wcJxwykrLhnQBTi1LV6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQGS4THZPHO9Jn7uSgSLJ5qhi/UwDAfBgNVHSME\nGDAWgBSRQXoc6SGd6lCh7cZHZlGj3mgHSTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGuIqae3wdIOoOqNJCKpHvneAdzrfxov\nfrCq8eEU0cE3AiB/9z3PCpLHHNdn/lIaZa13+gBzC5k7OChadDNyGKyI5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVweiipcBvLTchzV8UGe3RysMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZWE2ZTBjYi0zZmU3LTQwNGMtODZhMi1jMTg2ZmFmN2Y3ZDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARvBtPg+5haN7ZCbIN5462fa7M8GANCm+ut0HNAru2GMx8T\nYSZyGHtKg1lhQLlZIzSh/Jh/xWSyLz6TEVuoH6KSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkUF6HOkhnepQoe3GR2ZRo95o\nB0kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT/MHej1Jk1bXkP4a8yi5GH76q5H/1WSyH7icmCEnpusCICY20FIgzJu1\nh5htKN4+Hf6E5AiWRQAOEja/Xl4+Ei40\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAapFHD6dgSCX/gTkMbf3VOmoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZkMDEzNDQtZDVkYi00ZDkwLWJiZGItNDQyYTg5OGUxOTVhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmJjYTE4NmYtZmIzOS00OGFkLWJmYjAtNDliMDA3NzFk\nOGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFBanFys7CKh9riPfl5B+Fg+w\nOf1TVEb6FQsoGbQI9yZtzXzU6v91bR8868fJX1p4NaYZYrlU9GrlsOnb1sdvHaOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQGS4THZPHO9Jn7uSgSLJ5qhi/UwDAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22CFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAxnX9OcB3FG84StHOQE/TFXB1CVWeAF2Z7mLhM8g1TL4C\nID776/6J2HGU5bZG8ozq3DSV5s5CVApQoBDyqOlYXrWv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8787", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8787` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASjecB9VBJ9xcSfdU2zGU47WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0Yjg2ZGZhLWNjODgtNDJkMS1iOTgxLTMzZmVhZGY3ZjdkMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWU3NDU1NzItMGZh\nMy00YWYzLThjZTUtM2ViMTIyZWQ4NDhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM9hml4tSuqDx1NiYmPCRYOlh666aY1ArOk7fo8t3dFV+jaL8LUt2yt44Q3ty\nDqzuxYe3AO/Nof0RZigh6rSSH6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5uCdg566NtvTvm5GlpnkF2CbcfswHwYDVR0j\nBBgwFoAUCBaKP0Sfge3RJ/qk6o7Ra5l6E3YwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCB3JnMlX1hOFmFDJYAxrzSX8Xz\n5zFoEcC2TmdxU7nZkwIgFFROclNSJ2l/EbYDwfOlHj/a3UVjy13EfM3wu9Kd/g4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATEXq2hGfs4ZIgEqiRafgFIMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGI4NmRmYS1jYzg4LTQyZDEtYjk4MS0zM2ZlYWRmN2Y3ZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASS8Qw7HRWLpX+xzVGj0oTxYcl5OH0LHjriqWl22/XASYu3\ny6lE1HbCGDdfzMzorTmAqCql2XzisrukV1Kg1DFPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCBaKP0Sfge3RJ/qk6o7Ra5l6\nE3YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbWLawSPGbDcRvJZ96W8UbLwYZQpkNAA2foeSvx4I7WkCIQDiRPblK5wa\nT6sab6O3LWKkCrp7RfrM6sejiEJB/TJ6NQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAR0Uy1VA4VPteoVxo9jNdPBjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWU3NDU1NzItMGZhMy00YWYzLThjZTUtM2ViMTIyZWQ4NDhkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmUxMjlhZDMtMzgxYi00N2QxLTgwNDEtNzg1OTQwNjdj\nYmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEW9EwIW3ucseHrSMdLFipOZu8\n7GFTqxfUlQb4OKbTN7R8PkIffkkaJAhSAq+dQLTTGlgKa1yg0p68syDDvaTDcqOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTm4J2Dnro229O+bkaWmeQXYJtx+zAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22CFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIgZAMMQUH1v0UbQRoj0u0kLEKKdVNeYyQGrSOYvJRb838C\nIQCWevu1QW54y5er8qrf5nOJOh+LDVzvI1Fs0b4UyE6WYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8788", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8788` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVj3MzhHYFlcXWboka6iQH1XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0MjQ4YmE4LWI1OGUtNDQyMy05ZGM4LTNkZWU3MmJmOWQ0ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFmNmEzNmItYzli\nOS00YTk0LWE0YWEtMzUxMTI5MzJkZTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqbqxsZuB3ybKX5qAfDPKCIYEK1i43XDuprTJII7gGQYrXfj6QZshD0Nn41aw\npe6vREzfHc0qO/Iw2xurxUnVRqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSM64AsvHadJ/4qBvYVvZni8Tx6XTAfBgNVHSME\nGDAWgBTP7+4SgjnTPKumRNarBjwMoexU5jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC2outqnnN+mpfnOaSZKpWUOHF6SKG4\nz8vIPCJYyDJfmAIgLpidpuQM/tvJs9slnmthcfJOXqeaDBY3vVBU7I1GiPc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbhyBuG4HE5AG8ZUCmeXIPPzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDI0OGJhOC1iNThlLTQ0MjMtOWRjOC0zZGVlNzJiZjlkNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQE6HMfbnFNn+Fh903VGMLbUk38fha2pm8LXYcV3aZMbXfJ\nu0owWFBhuy3DKMFwc3KdHfN6Gm1DUCkUGDIleeAKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz+/uEoI50zyrpkTWqwY8DKHs\nVOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEIoEluAHHtoEIaKFaGs1NKl7E9CjyaPhcr3Zl6BCHdgCIDYwUnCfujvm\nZiCpAXtTtG3moxuTca1u+7nwFb48iOHU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISATyuwpKblC4Q/U0donEjObDCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFmNmEzNmItYzliOS00YTk0LWE0YWEtMzUxMTI5MzJkZTkwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDY1YTE5NWYtZjJmMi00MGRkLWI3MTAtZjM2MTRmOWVj\nMGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ2PgT3XMNxGA7L4PLm7Vier0\nWJ+YZcgpF39lIHBoFtWk0veJc6IVExmVf/xDg9g/7V9o/yDaay3o1+hloegNKqOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSM64AsvHadJ/4qBvYVvZni8Tx6XTAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22CFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIgVueLZ3mQActibZLfk/HdvQMs1nFNUlVCvrjjO6X7+CYC\nIQCVJDA+yws7Sfj+ly1dwSIkjcEPQlNv5H66Umd7cHE3LA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8789", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8789` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAZQE8Q/ON+gFpch3YSwLU+4UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1NWIyMWYyLThjYzctNGIxMS05YzlkLTQxM2UzOWJkZThjMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTg5ZTUyZjktOWY2\nNi00NTYxLWFjMzUtOTc0ZTJiODk0ODY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElvxyU8AW/jEQ+xLz+N1vjGHLYteEANZLGG5NNQ3hUUnKilbMI9/yvQX3NLTU\nK/ikMybSY0Qr9sppcV/cc2Cb36OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ+yUcYizJ77AkeOiiRoGEKw4SrQwHwYDVR0j\nBBgwFoAUlSfJwv+GrxYc4liZafoTJRMpX3cwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGrre1PJ7ctrYiGqjkCkHkNHPBy1\ntc7v35mWEriXUdl0AiEAymp3qmNwda2+07Y6d2302ouJY+Ud51BGvpwQklWxIG4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd5Bnwx3qJfzDSC91lePKvsrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTViMjFmMi04Y2M3LTRiMTEtOWM5ZC00MTNlMzliZGU4YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARai4DFbGXp/BKudnj6HRUan4XH8zRgYJIA/rVc2uXm1BMr\nKnFwftRW1D0FUcSTmiLWixoiPe/9qAqeCblMNzUmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlSfJwv+GrxYc4liZafoTJRMp\nX3cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALz+mh/9UhPD+itRoYYZeWoDEEsG4F6FjzZ6GXiY8T8iAiAOMB0LVFMl\nhzczZfVjtRCzaPWQRL2myFHouVBSBVqU3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAd5vctN15Y6enBKm8U8NzJ7ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTg5ZTUyZjktOWY2Ni00NTYxLWFjMzUtOTc0ZTJiODk0ODY3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTVmODcyMjEtZTkxYy00Zjk0LThkYzMtZjg0NWUzZGIz\nMTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+Fg+zdMmie2sD8on9SNIy4P2\ntwJ0rSGcG4AfH+4UX7stpksNCEUq+Gyk29DsWWtnagEyPRFSdJijvZZukFr/WKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQn7JRxiLMnvsCR46KJGgYQrDhKtDAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22CF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQDEcMmB4829QOdV8lsM9Ljrsyoi+X49rnc10bBgdlrB\n0wIgSTsEzFmK3C7pFgx2gJ02UMyEIw3VZKMOc4FIm43SctM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8790", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8790` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAU8jem5gbID3qQJYgKArc8TPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkYWY1MTk2LTBhZTItNDRiZC1iNGY2LTUwZDdkYjYxNzRmMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ3MjY1MGItYzA4\nYi00OTI3LTk3MzYtOTc4NzVjNmM3NjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL+aNMWJ4q6Ht5eizNSW1TYgOEtzOcQdBik5OX1xZ7nlhDwXxEawZEJyqvelz\nJNDIlcscKKvfot9wuoxOaiHpraOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQgSbVgn94BLUTRALEfBzXAaIKLjTAfBgNVHSME\nGDAWgBS1eGfBDvZDkM+V2DefiPr+XbUV9DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIG0c0/w4wwpz3BK+Ln4ytuq+j/vmt1vL\nfsTDGVAROhH8AiB8/KUpdRwmQZ2bwFoTgEfCyNWRgTy1LSRWQxRiOY62Yw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASPp7buZm28PovpTW8z/noSeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGFmNTE5Ni0wYWUyLTQ0YmQtYjRmNi01MGQ3ZGI2MTc0ZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXmv4acY3LkdwdhgTEa7lZ+z52HlIU7CbsyfLhCUOEIjgC\nPj+TTQHxE++GZJReelA9HmtPEVeUHsgytSyTYSPmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtXhnwQ72Q5DPldg3n4j6/l21\nFfQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTL/qqNMQzGyauxIpg3zyNkaW9LpqT0CfwlMhXE9ba2UCIQDMRz2H06wi\nN7BDzuW8C06trGi558IMzwPnkWQDMW93nQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISASOls0gu+JQSS0J10m0fY93lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ3MjY1MGItYzA4Yi00OTI3LTk3MzYtOTc4NzVjNmM3NjlhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTJmMzA2MjgtY2NiMy00NWIyLWFiNTktMmEzNDFlYTYz\nNTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4FUDs5+tSlwZqeqC1Mlqr8lh\nt/U5iHZjz+xPRSkCImfoX5Dn9l4aSDSV+JgLWzlD1sGvseg4674T25w1dZU0KqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQgSbVgn94BLUTRALEfBzXAaIKLjTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22CF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCID9PKSLNvBFW0SE/m71Twsif+MpTTsMw3lqWa0iPpPRY\nAiEA396fdtfUATIPiadujiJt69GWp0tT6md5qXXpQtmaXuw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8791", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8791` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAW6reBkEeV7K6zl3BFAWtf5lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyNWQ4MDMyLWIyMTUtNGEyMi1iYTFlLWFmZDg1ZDBjMTJjMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTUzYjU1NzItYmQ3\nZC00Njc2LWE3MGEtNTY1NmZhMjRmMmFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE62Z/zkN+5Dk/ohVV+d1/PH2Si0+msSVrUht7I9lSXT0OFs1h6PW9P+oxrnsl\nuLceROQTfWE0bbx3i5Cs3Tmdc6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI6eclElGOrsg6B6km8KgEe1A8YgwHwYDVR0j\nBBgwFoAU+NT7ndTuNx69iaFj/KWAIW+wXcUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIA957XFF0KIFT9qvOt++xC3VhWL6\nuLPcfjDdMQcPAftjAiEAhVCgisDu8qInNp27HPYCiMUXpYY5WpEN9qdR33puivI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdDmLPI6b4c+am4uFSBABCQ+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjVkODAzMi1iMjE1LTRhMjItYmExZS1hZmQ4NWQwYzEyYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASeGTkXwsWpQDglAu/Mxh+yrgVXhDF11a7Matgkm62GiiVh\n7l9/RewPxqGmuIxpCCsp/r/yEowoudY/UQ5BLMVPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+NT7ndTuNx69iaFj/KWAIW+w\nXcUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNUL97Cl0T3xTFDQ+zjnDItJZFw9mmMRFoAE47C8VKRcCIQCAB7/Uhl3E\neARQRR8maBqGKZ+a0bv2qivoKYbJifqp/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISATRhtpCBWw36bIVlfWyN7KzMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTUzYjU1NzItYmQ3ZC00Njc2LWE3MGEtNTY1NmZhMjRmMmFhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODgyNjMyM2EtMTFjMy00NTVkLTg0ZjYtNjE4ODU3YjI0\nZjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExGL7Tli3uGVC8fHbYTZ6Rtzj\nUl5EWaz5IMe6WnR/qS5NoYqLO4AqFqEfgnTMKsSNRqydoQEct2sYbGzm0Nn+f6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQjp5yUSUY6uyDoHqSbwqAR7UDxiDAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22CF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIHYATrIzLYPLgmay+cNjZnaH7JMnAwKWiFpqJD2EF59b\nAiEAr7t2f6PZ8ncNyDFwEaGbfTjll1iBx3w0MM8B/9LvJ1E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8792", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8792` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAUGVx04fNYWS9hc6YfQf7piOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmZWFhYjRmLTQzNjMtNGEyYi05YzM4LTJiZTJkNjMxNjFlOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk5ZWQzNmMtZDQy\nYi00NWYwLWI4NzItMGFkZTI2OGY5N2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8N0DTZEmOQGTxwz0HOfXGGHAeVLYibVNQNZCoZC4PwtJvscx8me6q2aNlKTN\nDJWNjnPi1ZnYGS5RqaYDpnoZFaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQv70WJK8lmE+e2C+Os29wt78ipaTAfBgNVHSME\nGDAWgBRMHhdc6o/nulus97MNeOcLEaw2JDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC2UpYAUzrglv5neQ+jMetssjv4QnjN\n+4Nb7kX2bRYbpQIhAMJB3Kz4VLyn2rpa/gjuFX4JspOZTJ3TmVaj3CfhY+3S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXJITLHVH0teO0GQzI+youvQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmVhYWI0Zi00MzYzLTRhMmItOWMzOC0yYmUyZDYzMTYxZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2/2AUm8TiBFrZ1CDhVCHPu2hKF55T8dnhuL7CNt/Rh60C\nRaTnms0pLRyRXIcUgT2bYAkFiAixgs7R/zrBLj+mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTB4XXOqP57pbrPezDXjnCxGs\nNiQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO3OmbES5g8WEVi5N4fd64hK5e7tsdH3pGBsvcHa+36NAiBfLlltZpO3\nD12uAMBUKhFNHg5XZw31jykkO9WWIJIKzQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAYeM67OM8FKybtRI3ZiLmk1FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk5ZWQzNmMtZDQyYi00NWYwLWI4NzItMGFkZTI2OGY5N2Y5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDRkOTQ2ZmEtMTVlYy00MjE2LTliMzEtODRmZmE0MGEx\nNWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFR57sWBOK1p+lxWdAZJZ5O1H\nWQEHkTwGXO2bdR8msmvzm9wIegKhOOZg4yNUt5LHfMdSw0YzaVau6mkRQlbhJaOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQv70WJK8lmE+e2C+Os29wt78ipaTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22CF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQD92BEjgJ/aPQ+MGBECylrWt/yXPOZU4wZEF5fr8PcP\nagIhANjb7itd9KMmyUYWYlApR/nXfVXoH8Oi2Qn382PBOSfv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8793", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8793` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAfskzrNV7FhrTPPr4V84ZgipMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyOTMzMDk4LTlmODUtNGM1Yy1iNjljLTJhYzgyYzljYmU4MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E3MzZjODUtY2Yx\nZi00Y2MxLTg3MjYtZTAyZjI0MjU3YmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIoTxct72BxPmW71R/Ce20YXkTdaiwLmG6+J5CDRqfu/RHF18FL4ACeZKLZmF\nJ9m3RRFE0LAVcj4xvW8WCD5wuKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFI0dg/Egtg3ZRtDUOk74STTaboJ6MB8GA1UdIwQY\nMBaAFKHD/+asneoW863HT97oYIa+boGDMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBm/zaz+9tk9wP0rCy77xjxsmYjwWwCz/go\n7aPh+RfiewIgVZ8GLJR720PLL2rOlVR9n/MOw6avuQBkenPGgoSeP70=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUXPK9VCFo00n6ewVcbtr7CgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjkzMzA5OC05Zjg1LTRjNWMtYjY5Yy0yYWM4MmM5Y2JlODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgNShbXzoU5Xk/uZ3fWhpOhgN5FKXKvbwnlFWcZ1JAOznd\nFZROMMNeHSskv/3gd3zVrQdl6Nuky5FRikJDYOnCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUocP/5qyd6hbzrcdP3uhghr5u\ngYMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALKLAi8zb3q56//4q9k8nnB57laujEpRha22SsihKO+CAiEAxv9ib/5E\nI8EeEJOUTfPui54GZboNtz0bOF5O7XZ8z+w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAT7Ud6SVxm/vuGXiFrTqWn0jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E3MzZjODUtY2YxZi00Y2MxLTg3MjYtZTAyZjI0MjU3YmQ4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDdhMGFjYzItMmQ3OS00MzRiLWIyMzEtMTNkZWYzNWNh\nZmM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg+dUC9pKRnZLDHje7NQu67Sc\n+pJxnDuFFIOdpxVhplFSAUXw3vahLEVMieL+fShXlis0uQ1SeTTErb2aVfCehaNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUjR2D8SC2DdlG0NQ6TvhJNNpugnowFQYDVR0RBA4w\nDIcEAQEBAYIEfwAAATAKBggqhkjOPQQDAgNIADBFAiB8JwhJ98uaS6GxBfeR7oWi\n1Fm1K40mcb4wBDLQOo0UlQIhAN09Hg1wbjXzEzVaTOgFiWjNFnTE3aNo82+hOU2o\n3KgL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8794", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8794` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfyE9FY4Il2zLvXbIaarVfGLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiYjU5ZGVmLTc3ZDktNGU5Mi1hYzhjLWExZDRhOWRhNTI0MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RiYTJkMjctYTkx\nMS00YzJmLWE2NTctNGI4YzA1YjRjMjU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEynLgjwYkps1i7TXQwIchJ9DxtzdFma8CKTR9O1Ym1ORQpy9KjBsxHDwG7bXX\nZMAd7+VUKux7iv+sP+2G/hPZzqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMgY/sJO9n+3TQaiOy+kgMR2QcxeMB8GA1UdIwQY\nMBaAFHkJsd3txVt4looEVCjbL4IV3lxlMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAGsprlfjMdE3/pVDR63Ee8m5l+avEM4FUm\noWWCRkCQ/QIhAO2p5+SoGdQvrCRsurJmtdRn5korVjuh9JTpJ4MvnFgp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfC+lHpag5RvldPllKQrfdAxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmI1OWRlZi03N2Q5LTRlOTItYWM4Yy1hMWQ0YTlkYTUyNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHEvgu0djNpF/Pq2h++LGxhvNxqKGTdG4xpmwrR+wizhM6\nRQJLligq30/+zEQQC/5GetdmjNHFdLrl7AUcACMFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeQmx3e3FW3iWigRUKNsvghXe\nXGUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGYX+YXb+PRBg2Z7UzOs0lRWXH6Al7GpkZy3PtxX+s+oCIQCfrc4EJzgL\nyY1XECa27ygFAbwDc1I5yy2nTXKG/6ZNHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISATceh73qNQBd8M4TpsnjGvaGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RiYTJkMjctYTkxMS00YzJmLWE2NTctNGI4YzA1YjRjMjU1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2VkYjNiY2YtNzJjNC00ZjJmLTlmNmQtMWIxMjQwYzk5\nZjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb2/kTmfBmgr0VItiXmkwBK5C\n93266UnuIreKAvvYgbVa+2pavfJh9bvTEVPp9ymkAGdsuzOehUgK4IZdzjMVv6Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUyBj+wk72f7dNBqI7L6SAxHZBzF4wFQYDVR0RBA4w\nDIcEAQEBAYIEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAgETaP36JiV/IFLCzVDpo\n2zmsPXSsBxO9cpFB4LdaYskCIQCyPnUlXD/1CC6xBVEHqJHNslYIRBqyoz1a9Mqr\n5A4dqQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8795", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8795` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISARhNBMxeGUFHI1LPDz5QfNYOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYjZjNmVlLTc0NjItNGNlNy05YzkwLWUwYTU1ZDU0NGY3MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDhiZGM4ZjktODhm\nZi00Nzk0LTk2OTUtZDI5YTYwMTEyY2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErqYkWTJGXQbL/q3QSnvYk+vcttbW4I3xRuGOnRDj8jQb7jsWwVuc2/Fw2918\nFYCAHQDwvNLk7cIAWpwHhJTsKaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFH+S4/Rp91kaznAByND4kIlz4xAAMB8GA1UdIwQY\nMBaAFGdBu643RRbmaniU1+qlv5mBAflJMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBP1zU+QxybEW6GJiprJ67gkCNEZVLDSlfJ\ntpkotX7NfAIhAJt1vGzBFRXaJjnwApdKoZWZWdLeDJbHlG9pRU6Pw2iW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATRWCPeizT8BodfSzzz7npq1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmI2YzZlZS03NDYyLTRjZTctOWM5MC1lMGE1NWQ1NDRmNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASthu6RaeN+n9+B+0uI0Lw7355jRz+ul6ULLDafZCHRa0IE\n4AG76upMzkL/F2Pbt+QHLBrtHc+onRKFv5nfXLU3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ0G7rjdFFuZqeJTX6qW/mYEB\n+UkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCN7cXJn7JnMm5+XyoUEqG+fuSsrYwWnTiXr0xS9hczoCIFolQUWOHMEw\nJ9KYF8ct1x+jwVEH3YGFd7K4jLpkQv5g\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAX8JMSo3dwNANiwTixv2xJbHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDhiZGM4ZjktODhmZi00Nzk0LTk2OTUtZDI5YTYwMTEyY2E1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjFhOTQyYzctMmE2YS00NWY1LWEyN2UtMWNiY2YzYWVl\nZjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+U6fAJQIqF9Rf7cBfeM0POLD\nIPWIKw8kZxL8kdhCsE0CVMATtFnaD14vqJy4esVLLH/ogH2M/D/4ElwQZeSpy6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUf5Lj9Gn3WRrOcAHI0PiQiXPjEAAwGgYDVR0RBBMw\nEYcEAQEBAYIJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCIB1i+dDxjt1FouGG\n6U3O+vXayBgwngIOhcngDoTHOKnIAiBIHSIPw62DwIig1MAD2iMdgwCaDTi1Oxt0\nHvP9wnMkoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8796", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8796` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVhsx/6SFeo2OiL2zL4SIztRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxMGNjY2RkLTE2NGQtNGFkYi1hZDQxLTAzMzZlZWFjZTRhNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ4N2U3YjMtMjU3\nMy00NTc1LThiNzQtOWY2MTllYjlhNDQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELoqsWTXtjqnK1yrcb45izxJ2kPNwrnJxuSoKH9uxGUa8QWo1LHmFEtsnIbSX\nWmoF+aGZM0VHuSBCRTDRSIx5MaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHkin5m/PCQ21G4pPi5l6P5xdMx3MB8GA1UdIwQY\nMBaAFIxKxsJLDJVA+gkyc3qxr3hPi1bKMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAjQvCJUW6W2whPaNMHjlJg1TY1klEXaFnZ\n6DEWZSe3NAIgMShp/OWwp4MDgyhI8qHLb03AfgIyxxL4imuIj3NsFkU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATzPatkyjXN3inxlh2ucS4CdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTBjY2NkZC0xNjRkLTRhZGItYWQ0MS0wMzM2ZWVhY2U0YTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARK2N/uFyC0YA07cYKAGPAZ9ztrPbO4OSfdjgMA4HrfL1AG\nu4p97vBmSRUmHnQYOZ050v9lZH5UMul69bVH37Tro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjErGwksMlUD6CTJzerGveE+L\nVsowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPKB356wVClMqNEK3jFTNjVUDkq2d/yR96Ax6P4ufX+sCIBjhtyUPW5ub\n2qHck86/cJZR5lEtM8iYRnH1Ok4zDAEP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAdiYrH9kuUqMOJcl3nYwe5pXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ4N2U3YjMtMjU3My00NTc1LThiNzQtOWY2MTllYjlhNDQ5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWE1YWVkOTEtNjQ4MC00NWJlLWJlY2EtNTE2NmM4Y2E4\nYTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJWjjrZnKedzqgljzwAVolXHM\nGHIp3hI/i0MjFCG2yi2+ZfhOaoUvoK5T/W8yXsHwrKT9DEw+XYBpXEGPTyKBgKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUeSKfmb88JDbUbik+LmXo/nF0zHcwGgYDVR0RBBMw\nEYcEAQEBAYIJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIQDiUlJaN76jP6lU\nxS1y23Kne/v4Ur8S372mMiJfqpKtRAIgPM2WYATr2iv+bEvJgMEFWJAbnMOWVZvO\nVN+i/3S72b4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8797", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8797` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATLHKQbHuerp++9HmMvEDbkZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxMDYyNjY0LWI3OGItNGFjMC04Y2Q4LTI1YmYxNzk1OTM1MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmVhNTlkNzMtOWI2\nMy00MWUyLTliZDgtZjliNzNjNmE2MGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2Wy8g0qR5JQN3EAICB/q8xP2LcJDO0pUFyDM/kShC1t6CRC8uSHVBJcwZvtF\nk5cKMcTv3/nmoI7edjS+A7Pvx6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQt3BxyuspY2Lp0ivPEbg9Pd1ZNwwHwYDVR0j\nBBgwFoAUfh1gaq40/UO9jbBHMQoqwz379SMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBfM7tReEPK+ISG0nai++up7xP37\nY2XZL/rjYRpSGmgAAiEAow6+7Ha6i65jFGgMysKpUoqWSk/cqzPYSHUAjDU9Mn4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV4/UW7ZARyjVTqGhgjo/f9tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTA2MjY2NC1iNzhiLTRhYzAtOGNkOC0yNWJmMTc5NTkzNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlCNfzwG0sk+bRetOkqjE5KPqrgU+r48aFWORuzmSPzgKq\nUPATvUXyAdGFwlqbBBygiijZ7BERmj8Lh+26+UdDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfh1gaq40/UO9jbBHMQoqwz37\n9SMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgecTlYqTEh8uul9wkUtBbJZprvPI4ewWDKftwZPoh+MICIQCrMkV8/5Yq\nNnfGrvE1kM3AfmjU6fcMe1GLKjwMaLhTew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAQ+/iWt+07MPPRkTL3sB0hfiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmVhNTlkNzMtOWI2My00MWUyLTliZDgtZjliNzNjNmE2MGM4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmM3YjFjMGUtOTBlYS00NTQ2LTg0YzUtNWQzMDhlZGQy\nNWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+5FY+5P29E/4yCyaQzETkJfP\nlg8DlBsSsGFsSdV5YnXnNWLZxqkoPEPTedLO+Iq47kK79zJbVTdzvvzXksG+bKOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRC3cHHK6yljYunSK88RuD093Vk3DAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22DDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQD4eYnO92nX1AD2TASsBmju/YXdjdd41oVUxzoqZF7tcQIgCtbs+caq\nspz+NPCQMpy/Qn8E3lq4/TyOvvwfI4llH8Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8798", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8798` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQiXZ1+BxxK0255rMC+i1BOuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMjcyMTM1LTJmZmItNGQ3OS05ODVjLTQxZjk0NGQ4NjI2ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTJhNDlkNzktY2Jk\nZC00M2E3LWI0NTUtMTFjMWMxYWZjY2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEipUZlJEZwC5aOazvfHJD7ikgkA1KACBjjZVd8yu06u5MKbKyQVBGG/m85Ezq\nhGNOgDRRMMOhn0Y9L2eCoy4NlaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRIQ8Oo+OglfahRMY4YaJ2vU9x0zjAfBgNVHSME\nGDAWgBQ1Ba7TnLCq1nU7Z8IYqHZ6bi4y/TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICQoh3oFkOKRfOLCaSQFp9T9dXGGiNlI\nRJ5Biq98tojAAiEAkKnWrvBhumF1LGKzBfmjX9cv4DTIwcxQj/74TqI25J4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATLEiplupM5ARQA3Oqc+KsZXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDI3MjEzNS0yZmZiLTRkNzktOTg1Yy00MWY5NDRkODYyNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIVVZmwCRObseDyrgoUNXF1AT67LdLvSWcWZk2W1srPd5B\n29qe8vw1AUO5XqlhkhuItF6iTK26JC989BaaLPAKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNQWu05ywqtZ1O2fCGKh2em4u\nMv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOzUKu3ytuRsFZhNAcNhS2SA6uDLPDOzsiZqRv5l/RktAiEAtsgsL0p0\nB1+NswEjxeVZ3+mg7dLTaxvamVtBzPsoy1k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISARGDCdxWmmH59MPK7blRbx/iMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTJhNDlkNzktY2JkZC00M2E3LWI0NTUtMTFjMWMxYWZjY2JkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmEwNDZkYWYtMjlhYy00OTA1LWExMjEtN2VlNjQxMGU0\nNTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZsiUPSd15vi8DWz9dHq1Z30R\nuzwRLVwBcQK1x1kFgOgDqzlx0jysv7bnZaVuvow8dBOfB2jRD9/ztzrMNaRIFKOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRIQ8Oo+OglfahRMY4YaJ2vU9x0zjAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22DDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDcNU0FJA52JTVCCK24iFHdHw460XAj7uDvf5uVGtOZYgIgPIcbbX1g\nsJxUPxxpTVVN0GNYJWC7zq8FLqnPye+93gw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8799", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8799` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAbXFUianh17Z+dvGoRJpeGrXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEyYTQyZTBiLTlmYTMtNDJiYi1iNDVhLWYzZDAyZjAxZWI5ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzUxOTkwZDEtYjFm\nMy00Zjc1LWE4ZTUtZTYyYjk1ODZjNjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzFy/qVdYrkZUbQqTyaGlYz3KF3uZYfomNnwdhXVkZE5ZAM1mwRlH2oxUCqsj\n6ps7MVErr89ALm4uh2X51IvuxqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlVfQIed+5dTYkGgRQ6610GctavIwHwYDVR0j\nBBgwFoAUdMTrK8aA8b63oiyIHE+K3svHbgEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCzdRHWVtZEEeKNwKv6c5DDL37N\nijNYcPbWh0wBkv43ZAIhAJ5cktSG3BXCTfAY/qtwjK2vZUTOzjiQxEssEJ7SIFCk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAatL7aFzmJ5oyy7vFEODt267MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMmE0MmUwYi05ZmEzLTQyYmItYjQ1YS1mM2QwMmYwMWViOWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnj30NV5MF3y7WDYBEk8eMiVlQfRCIqtPMbzdAQ+KKA78b\n7jhQouqZHvm9UnsG8E584VAHPQkWL6j6o0sYYzoho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdMTrK8aA8b63oiyIHE+K3svH\nbgEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFmZEnN9dYwKRIrkHQ8LXfaOvcP5OBR4FJiGiMrXYVewCIFdQglLAxHMb\n7bV+1qK3mYXAOacHyO4QYJciqDujMegy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAe2WoeyBI9cS8gKmK/edHJurMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzUxOTkwZDEtYjFmMy00Zjc1LWE4ZTUtZTYyYjk1ODZjNjBlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzljMGIxMDMtZDkzOC00OWJlLWI4NGEtNTg3MWZhYzdk\nNGQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+DyrisLjt8pcqTlLNLFs70QD\naxAhSTXLPy1rJMS62FFujYlHMbWXrnoXf37wLccfJU8arU3C2QAFNmOhZw0pLKOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSVV9Ah537l1NiQaBFDrrXQZy1q8jAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22DFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAht/aOM/gl0NYytAAVbSP1sv8Tfa0NsXFcc5jz/unIgYC\nIQDSeXAUUkJL26xRBan67RP49ux3TN9NZyj+/+zYyzN5Xw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8800", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8800` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVhpajlLDL9+SdK2tX7vIDpZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhMDAwZTg1LTEyY2YtNDA1MS05ZjVmLTVhNTQxYmZkZmE4MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTY2OTE2MzQtODVk\nZC00YTkzLWEzOTMtOGU3NmNkY2FhNmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/ajc5b7SSMTdhDniPqcwpzKBB870L/FkXRPIfEfTBrtaPtVN0gjI5An8p+7D\nFjYgjmPgEq2sqyJa/ED2pDzG/6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRNM9N7UnelnejW/Qvvm3i09EtXGTAfBgNVHSME\nGDAWgBSOqPzHrxyLUHOfJDzSJOdUaF9IHzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCXgcXnToS51Kir0YlcEefnAke/zJ7w\nJ64psUQ/GpyGxgIgEdJjV6YzqgRfCQptqp13ZTa9TVqOlwhLKj//OYo2fFk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcW932WT5umU7eyopl3YN8XmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTAwMGU4NS0xMmNmLTQwNTEtOWY1Zi01YTU0MWJmZGZhODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARL9y/r1c+nbng2D0ssU51sU/WIqCGUSqD7UDe5jqPjiS3U\nNLTZuKT9sdhgM1Jh9z2KMqk7XIqVK6Iux6030sBgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjqj8x68ci1BznyQ80iTnVGhf\nSB8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJCqkHETkes+qRQfAoTDd1/k7ui8d0OEX4FLrCdZrLR9AiBY167ZzRyq\nhltoTHQOHDy82OS067sKUo9BYLJyJKcS0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXZGUHNEJXzXBbumoFCsZd3aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTY2OTE2MzQtODVkZC00YTkzLWEzOTMtOGU3NmNkY2FhNmM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWJhNmMzNDQtYTQzNy00YzI3LThmY2EtZGJmNjBhZDBk\nMWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGBPR6s+T03pN2YMDYwK33jA4\nx1xTau3zPGL1Dm1o6uv8XVaUFtm0fFHm97vwb3eYT1aWy55zAJ/QcKJviys1MKOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRNM9N7UnelnejW/Qvvm3i09EtXGTAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22DFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiB0GNEhxDnAS3DOVPutC4tlnF+Y4P0aY9XW9AMU8UHy1gIh\nAK0CSCI72df5HCtL1YkNdO9y9jnf/+IHOLhN16+/MroA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8801", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8801` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYBu/ONt3Z0vutNdjhp7WGV5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmMTViZTgzLTU4NmYtNGNlYS1iYzdkLTUzZmZjNTBhNTlmNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDkxNjBlYzYtMGM2\nOS00NjlkLWIyMWUtODY5NDdlZmNkMDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsnRdHrCmaLfdk3Zr9fC56uCVRisJJ5CvKWsfLYhcLjTVMqeYAVnzcPO0ZYpg\nuyhnPFJ2DPTSHZwxS0dEq9LjEqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9p5PvK0ycad8i8yijX6o871uwq4wHwYDVR0j\nBBgwFoAUF54q55KrYodBsWKZBEjmC5rICbAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAhOpvzRVf2FW1jMVpdNUQ5KxR3v\nwHHt7zlcSyUco6KyAiEAq3WGPbCwF0XlsKyLS8FdTOZQsJYUgdRqAznfTI7SRfY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQz1e3mIJrKWloPEJ5Ivjh6VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjE1YmU4My01ODZmLTRjZWEtYmM3ZC01M2ZmYzUwYTU5ZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+2yeS/CT9UnUsFprnY/+1BTLbkcA74hhUjr+6cmJglmdK\nOwtnd2lFifs9tWD/VlPfMFfnwTTUqH0lws4ebjmUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF54q55KrYodBsWKZBEjmC5rI\nCbAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgD06jBSD7YZ+UoDEYVEXUvZiDWGF4phhNKakXDm/kj/oCIHb0cmcC1vHA\nhF3PQuRj/DsSwVoezKq51qLrXZtWPzEm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAU6Rrrn6CBCNEaIBGiJvVs4NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDkxNjBlYzYtMGM2OS00NjlkLWIyMWUtODY5NDdlZmNkMDIwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTQ2ZDkxN2QtMzA3My00ZjA5LWI1YjYtYWRkODMyNWI1\nNjg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl5PiCbQBAoxcCg7XA2xQ6m+F\nVtgtryFrxSKTWNXRPMBI9iPgPFp92beTIIxA4I3B3zJ5SdC6wkXAT1YZOa4hxKOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT2nk+8rTJxp3yLzKKNfqjzvW7CrjAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22DFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIgFlI4ylpCOlc7aJ54z1GYMiFaBix7KtzdN3D4AHOee2kC\nIQCyjZRfysDM+WL+kmCp2BCT57OIOhmgg8gWT+orUB+Qvg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8802", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8802` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcghWw0ShE1Tx6JKgZyAvC76MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMDJmNGU3LTEwODEtNGQ1Yy1hM2M0LTBmMjcyZmM3OGNkMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDIxZmYyNGEtMzYz\nNy00YTAzLWFlYzYtNzI4Y2MyZDJjZGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEy0i7Mwqt8Fq1GlZvplGFMAmTzZrIV+8gFQvQWpvHxxKqGCdkxvqEOcs5KM0D\nQKFDykF/uVhG5HKgacRwl0ACUKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQdqoQFM9NBrTkYtIQ418QSkO2TwzAfBgNVHSME\nGDAWgBSJgOaxWR4uF08sX0BgiydFzj2zTDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGEeK/ULOzascixMYqmgTjO8g5dbXMmS\nd0WV+r9T7IbTAiEAl8wBIfCNsolcGKxhUqp1WuI7Uzd5slogTCYcB5Of5Z4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdxnDXp6PkiSYM322a5scGvGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjAyZjRlNy0xMDgxLTRkNWMtYTNjNC0wZjI3MmZjNzhjZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGp/isGcBv1san58d2NQQK0q15rqJ5PsVXUn9UlsN6grSA\nznSCOjr9r3EPf8fGHfjG/Q9uETl6y3GlD4MdzXOco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiYDmsVkeLhdPLF9AYIsnRc49\ns0wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANW6kWQTKmHP74NsXSbS9KTVMB8s4+/Nhan3V9AR+kVQAiBShmowjinM\nqYDuzEdDdKmckbVjnMahyAMOddOmRdw8fg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVr3AuPTRuE+DBh3hOa9pMVsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDIxZmYyNGEtMzYzNy00YTAzLWFlYzYtNzI4Y2MyZDJjZGM1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGZlMTMzNDctMTUyYy00MGVjLWEzZGEtMmIzYzY1NmRi\nYTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAZWl1yPqvuf6uVcYfvqncKqu\ngJcRRCx2cscdj3CHFLQ90p4C4R0HYqAF0AUVMxc/oukFUJHC80D/tx4X4p8kXKOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQdqoQFM9NBrTkYtIQ418QSkO2TwzAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22DFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhALt0pltq8slAzDURAfsO1gXBkz2czcZNuHTFb4GUxyMU\nAiAyn5ezv+QkpzzLrRdiSmaElXP1f6ksANF8hqgvccbG5A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8803", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8803` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAb0OFl6wuK8kj/6a3eLqs1DQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzYTYyZmI5LWQwNzYtNDY5NS05N2UwLTc4ZWQ4MDM5NzIzNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzYxNjdjOTktOTQ5\nYy00YTZkLTllMWEtZjMwM2Y1MTcxMDY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJTVnUCEfYAFjNgUx3M53PIHwqVKhmFEu2KqyU/vJ9qs+tDwtrRmi49bS4FZT\nnZEaUQmR2YdOm5OyiepomPsGLKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlxx7sLjqOkHZZ4Znk1+2eeLnC0owHwYDVR0j\nBBgwFoAUR8Dzoi455VAQV/GnbGlPjmYKaygwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCYMvjZ/mG5/JKLitLSKvCOPlqO\nTeBLJb1KCkB9pb0oPgIhAJlQejHqTTUTc4d36zbluIfFCIMiKxLhmxgCY/U1JkDA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWJyPbwbVTPU+N27cL4YgBZeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2E2MmZiOS1kMDc2LTQ2OTUtOTdlMC03OGVkODAzOTcyMzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLbwwkPx28FEhpI0lCx8yixrBo6gjJNv08GTq6gFbxPlui\nCXwdgjseAvXi7zEj3UOCHCZEOijziTaoNbDE6rMno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR8Dzoi455VAQV/GnbGlPjmYK\naygwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOsApjeDZH7q6r70zaFP5f8BnVrNRhe7V7cBkKoBbwSHAiEA05IKpo6f\nb5tkBrDUU+3BSgNGbtvhmhjwOz8jSLKCaj8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAV0nZUL97mU2smyrp3VLjN/IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzYxNjdjOTktOTQ5Yy00YTZkLTllMWEtZjMwM2Y1MTcxMDY3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2U3OWIzOGYtZmNiOC00NjU5LTk3NTUtZmM2MzgzMGI3\nY2EzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjCVzyUyf9koMXE3NhbXay+Es\n0uImo/yRT1X9Wnr9fa9aFol17af13EwscQ/1B9RwetPpz7af2A1CXYg6XAP776OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSXHHuwuOo6QdlnhmeTX7Z54ucLSjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22DF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIBann3vu7doEnZjZggwH1MnSih2IQXvJq6R4BIKjbp8/\nAiEA6DZ1wuMN0zXTg045u2yj+lO3cjf5zjD4SMlUz7Ks1G8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8804", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8804` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAacw4t41zEAzEUTZ5jLGt3thMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEwZWQ2NTljLWZhNmQtNDQ2Zi04MDI5LWFkYTQ2MWEyNTM2OTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM5MDJjNGQtZjhh\nMi00MmE4LWIyNjYtYjNhOTJmMzM0ZTVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsLvYSvfx3fCklydsM8VCfNEwx4EECWuewe//pXxgZ0Ew8rubMv9WgzoviKpN\nanNM3qDci6/xSTXC5duEDRjVm6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR/L1TKhtsOYTa13veTVpkvNSP5ZDAfBgNVHSME\nGDAWgBTbjguMtyzv43UsCJWoP1xC69xl9TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC8rCK3r4eNLViDaL5qBGA27wEhUPF1\n7vffUjV+VNSbtgIgCDUj4Rma8Jsxk7thWE1yBNgaoVwbwsv71+dPmnvV4d8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAViZc4k2ezKQHIGwVmM6Pd2kMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nMGVkNjU5Yy1mYTZkLTQ0NmYtODAyOS1hZGE0NjFhMjUzNjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcZ1DzO+iy12pTff9jouaKLM5cJt6WHLDML1HSmLrPzU/t\nubLorKxgoKLSQAsdOniqoQ2IRU+u7JlDN5dNYWeyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU244LjLcs7+N1LAiVqD9cQuvc\nZfUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVRUMNLjF9JGBDABxIonqyryKNpVgHRZ9XM1qnO9XTw4CIFlUHIr3YYBp\ndH3PvpLnvSl2CMpSyOwhz+JPJlR82JDz\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAUKO3DrWGpO24zIA0oFp4TxkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM5MDJjNGQtZjhhMi00MmE4LWIyNjYtYjNhOTJmMzM0ZTVlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjc5ODM5NGQtOWM1ZC00MDIxLTg3OWYtZDUzNzlhY2Zk\nMmUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE44COU4Ngu3SAX68zh1yllXrv\nvzjBW0pg5T5ifFf0VxB2yKLH1u2gz4O8cNJFtGY7h+v5Ra2p9FPqc7jESRPs1KOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR/L1TKhtsOYTa13veTVpkvNSP5ZDAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22DF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIFaKZ7a64KraNYQ36ArOqSX4hTiaNpiu70yuA10+Cyjj\nAiEAxcIzJkOj3zYqUYYEVdD3AxCd1at7GH7+bS+7hZOUfnU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8805", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8805` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAUUn5UaKb/FSjWLpFTsPWfq7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1OTU2ODkyLTc0ZjEtNDMyOC1hYzM5LTRkYzA3ZDI2YjA3NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjMzYWFkNjQtMzA5\nNi00MTk3LWJiNzMtYjYwMzk0YWQ0OGYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ+F1/YiGNtGhSVatR67NWJTMb50VawgBWxhVbaqkLiqIv4L08naDOHNPoiak\nJ1Vk3u42Tnef1wzOq1lIePKYF6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVkCMXPOyDZb7Y1C1uI6AG4Km48cwHwYDVR0j\nBBgwFoAUWZmzBRT9Ho0xG2mcF+NQFrgpMmYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDf0v1DqA9q/1oH7TmJJSIxqnvGy\n0kl1k4VoMYpYenfoAiBNx+X8zY08VYAoTIGHCbFBKctar3ChSzbm27/LTeLPEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX26B151HRulGnNlU1RWrFxWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTk1Njg5Mi03NGYxLTQzMjgtYWMzOS00ZGMwN2QyNmIwNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9Ui2Bpf+Dk623e+W6hHJ6ipBHhMxhxGNHzLWKHczHHv8L\neuHhyYivVDs+kRTtzOGEIFrNjGrw29z3sLG62K5Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWZmzBRT9Ho0xG2mcF+NQFrgp\nMmYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALcDBtUz6MbXCzvlkjLJjLAlPRWIg1Az5kANSafADmk9AiEA4TzM2bYZ\nQ6ik0zL5lfGme7yrdjYrjmCowC0IZWEpV1s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISASYyaVjSfV7VLeZmF7Y4FVPHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjMzYWFkNjQtMzA5Ni00MTk3LWJiNzMtYjYwMzk0YWQ0OGYwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWQwYzk4MWMtYzhiOS00OGUzLThmMDUtYjU1NmEwYTM5\nMDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXtqBcYrzIuj7kKG5yeBqA99G\nAiRq4ykcezl9W+gCPCR+HBQHazPjz+VkvOiK7Qauandq2MZ6Vvc7wftYusElmqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRWQIxc87INlvtjULW4joAbgqbjxzAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22DF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQCL6UrXyQy3k95YjhgOiungwvmCnKx3C4OeiKFOO3m2\nkQIgZzaBcOz0/p57vm7gaQsyxGVynX6luGX6iaHd7DreS2o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8806", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8806` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXG83MB3BG36EwPRzJgfAU/AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5MmZhOGMzLWQ5YzUtNDdjZC1hZDE2LTUyNGI3YWQyOGI2MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBkMGFmYzEtNGRk\nOS00ZjM2LTljN2MtNjZiMTk5Mjc2ZTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQuHXhIGm3ZKzExQjTAH08C989jrq/Za3jm4rEyEcuGa/8f54aT7UAsNdPIC6\nrGmGQ8U9HyeLvacIsnTKzfIQ+aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSBY+RQlqnJNK2PJcrzc6B63V2baTAfBgNVHSME\nGDAWgBQQYmWA1Z9V1RMsVLMtr5JpBXPMlTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA/8IpSVhJAoA9eNpjVMXw2J/aoNmLar\nNP5bDJgnNktJAiEA/RnJQiQJsI1rNmhDanidCaNz4inKZHLd0yAE/fFT/F4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUXCUmZOUczEGJisA9j6uIW6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTJmYThjMy1kOWM1LTQ3Y2QtYWQxNi01MjRiN2FkMjhiNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASP9wkLsh8Azy4NQ6EpfoBSU23jEkUJkcSqL28YLEz5sqdx\nGskIOGe5EaWRb6mh8c0NnrWh/PVaQhjn9cGuZ3a4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEGJlgNWfVdUTLFSzLa+SaQVz\nzJUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCvBeDpRh24pu4K8n3iE8HMZvWgdGaGr+eB0cyGcuYMMCIQCeS/WUda09\nTv3v+mqbltKPHPYLLRXdfUZ+A4qh65X3FQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISATBza4fEDvASDQ1zgKRKQR35MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBkMGFmYzEtNGRkOS00ZjM2LTljN2MtNjZiMTk5Mjc2ZTE3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTBkMzQ2YTctYzg3YS00YzMzLTg3MDAtZGFjN2NjOWM4\nMGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkfWT4mAVELgMsyFR+2NEAX1b\nbW6GrQmSXveS8UytTU5hN84TKlDpJiM8iUvcp8MF0V5UbeYAUBo9PAVgaPA0GKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSBY+RQlqnJNK2PJcrzc6B63V2baTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22DF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIHMNHi9waoUdjz+GZpC3xthuUnb+dHKcd8qJo+RNXMXq\nAiEA+4k0enfBPQ/KfNAV2wEpsZEKV74/dov7N0NN9621oP4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8807", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8807` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAYlqORGWBKg+rQWf2mm9iZ3AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjZGVmNDc0LTczNmEtNDc0NC1hMTMyLTMwNDc3MWUyNDE3YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjkzNzMxN2EtMjAw\nMS00NzA5LWIyNjQtZWQ4MzFlNDllZTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE07uLV+T8slqSrcvPou32o5Z59rQr2wLoAr+P5XFlaKUL8o1DqOZ44QrbSntm\nnTazGMU/NEmbg9EWSz3K91cMtKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGTzKCbWWdmvGdkec+GPrysBtcCpMB8GA1UdIwQY\nMBaAFOoxp7zNAm1uwRdZk0YAh5FRXaBcMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA9C/mJiKtTLPQTc0gh0ywLXO6rDC1UMT1\nO816o3Q7j6MCIQCDlw0A6DWEDi/AfODaMZzAUxTXmVkJj7GqdqTUC32RKA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeXg7QfNqo4Dn51hiLUO6cKDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2RlZjQ3NC03MzZhLTQ3NDQtYTEzMi0zMDQ3NzFlMjQxN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATscTpA3gYbB6Batr3P5EZkhUs469PwHrsfoMt1I5QQx4EO\nXP6RgPGJAaUKAePbf+zKBGOhyhuae/NmiaazU7LYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6jGnvM0CbW7BF1mTRgCHkVFd\noFwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPPKDR1ChG3Gn4+i3HcimfSvhKx3kxHIPwIPN9uxf1EpAiAMKs3Zq8Cp\nGHRke2vCE3JZnxQXl1jJQjHje3kzhM+FwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDjCCAbWgAwIBAgISAdr2s/xR95LTg0LkHBv1KgcNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjkzNzMxN2EtMjAwMS00NzA5LWIyNjQtZWQ4MzFlNDllZTczMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjc1YjE4NTctMzJjZC00NWY0LWIwOGUtNTk0MjNlMjk2\nNWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb8h//GSeVRVed/nG/hXZj6h8\nmrO3V0WMtQn/vzwKiRUYLGd4KD5Drd80z9WbSEcrsJeaWfpA7UItU7Ct9y7YaqNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZPMoJtZZ2a8Z2R5z4Y+vKwG1wKkwFQYDVR0RBA4w\nDIcEAQEBAYMEfwAAATAKBggqhkjOPQQDAgNHADBEAiArv4GPboPs+d7dtIeqitMV\n3AcFo2u1FAw0EdFwEVyjzwIgZdwk4GipuY/IEHvPK/HT5WqaT0TshAHYyQ1/geHZ\ncG8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8808", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8808` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAf/JdSDIR72HyEVPOfDhleWAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA5ZTJjNzVhLWFkYWYtNGVmYS05NjU4LTg2NGQ3MjNiMjg0ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTg3ZDhmM2MtMjE1\nNS00YjcwLWEwNmMtNTE2Mjc5OWE0MmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJpYcQGWvByrqulM5WxadleD2tpyNadQoT9qEL5wSFVE0uGWghjHIRN9HPJHS\n71+fjHc7RKt8LIKt4lZnHPf+2aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFB+N+VVon52gYURePk47OYiVzO+jMB8GA1UdIwQY\nMBaAFMmg9n+aTnWj234MpdLESzjlNgVHMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAIKTu4BRFm6cboKjT1m8bHQU6smftXzLaQ\n2x/mBfLwXgIgbxVALuEqEvdZDOxkHUMfSsnwjeKxUDZebv1JG0hXfMg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAViadiVt+xQ2BdhKbQKqYHOOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOWUyYzc1YS1hZGFmLTRlZmEtOTY1OC04NjRkNzIzYjI4NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDNh1FUVL9sv37UGYgNRVwjGXasCq0IdfiKf5OqN/tZPi0\nsHeU1JcdwPljwPe61Wt9W/6rJ0VZsrND6TqG/VG3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyaD2f5pOdaPbfgyl0sRLOOU2\nBUcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCP2NFkNDYP00aHlnDTMTDbNg7mV1tjRy4dMHefT2kAMCIAobIfNe+Rga\npezxgWrTtOfMlwiWidI3dX/tyskrXf85\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAfb8TnPHvoN+sqbmTJrN/OqbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTg3ZDhmM2MtMjE1NS00YjcwLWEwNmMtNTE2Mjc5OWE0MmE0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjA4MzQ0N2EtNzM5NC00MTc2LWJmOTAtMWYwMWU5NGNi\nZjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWyaLgPbPPQbsQw0mFBcx4/+9\nRMG6bjM9CXBbnS1hospcB7Borj0mXgP6ZacwHOmXajvXyDguDDquZPpvllbHKaNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUH435VWifnaBhRF4+Tjs5iJXM76MwFQYDVR0RBA4w\nDIcEAQEBAYMEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAsx3Xl7NrtjjfnQQReL/H\n2bX0MSDsaEAqbJG0VB+kHe0CIQDP8kE+wkvJtAkHyQmfDR/UEd3ZuYGqmaxsxDxS\nwQ6loQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8809", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8809` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAa2ngZjcFldTtdqAyUq9vmqyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3Yzc2ZWNlLTVlYmUtNDhlYy1hOWEyLTE2ODMyNzMzYjQ3YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ2OGVmMWItOGFj\nZS00MjNiLWE0OTUtNzgyYTFhMjJjNzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaROphXURqPC87mcuk7z0dwgoYbGWkzh3Uq+BqbPZrdSZdX4/nm4wjk+AgZ5x\n5gFBXdM2x0eIKgJMUjur0WFzH6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCk23XtZ7UJAUWnevclisRHgwdUOMB8GA1UdIwQY\nMBaAFGte1YQxJobR76w6U2QsHANsJIMDMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAswB7u0+OZOfmnaa5qBdNkqi1xjkFDEcvU\n+Ye2/5gJwgIgBJZ+nkx4MgbL7xA3zkdI7Z6pQf8x0M+O/3dutwchbb8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW6qny7r5cMePdi5jc3VogmcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2M3NmVjZS01ZWJlLTQ4ZWMtYTlhMi0xNjgzMjczM2I0N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaqAnWH1J39WR8I+o3FyqnDFA91aVyCpGZ9xWZ9DL2r95T\nlSsseCVr3svWLqJTN/4n38nomo6UoEi4y+3sWvBho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa17VhDEmhtHvrDpTZCwcA2wk\ngwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgITQeghYZbfq4DqEeknjUJ7nxvhLjVt1UAqT5tiYSU34CIQD6Shajn/aQ\nY956aoKLH61DMgO10T64ianvfELP2EFdlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAQ6XapQKqs+2UsXx9uo5p0RkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ2OGVmMWItOGFjZS00MjNiLWE0OTUtNzgyYTFhMjJjNzEzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzIzMWU0NmItOTIzZi00NzA4LWI2NjgtZDBlMzI5MzFm\nZThmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESXJIvw7sbwFFH+v1RG7kV3t8\nqz3z/8XL8Bu/DXlIMhgV89qfZfQ/MSrBxeptF9pZ81E90HbnbM0+pJk/OAUl9qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUKTbde1ntQkBRad69yWKxEeDB1Q4wGgYDVR0RBBMw\nEYcEAQEBAYMJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0kAMEYCIQDAwkM95Ut4mab2\nEdo3r/vUrZem6/wzVNCs6CGLfs3hvAIhAOZlKFB9hVRtv/33sqd05Lv24ofKH2Bw\nzzxm3idcGgqE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8810", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8810` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZfW5HROlrl3dH+xTMwsp7AkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY0NjQ2ZTJkLTUyM2YtNDNiMC05NGVhLTI2MWRhY2QxMTkxNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBjODExOGYtOGRl\nMy00YTM2LTlhMzgtMDI4YzFiODQ5YTU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXHS3kqsSmfcbjzMMDnLye8qbaw++W5QmVruDNkNeoDFASMoTS/S1+7k8iYCp\n32Y2AiCbaUZlRCT53LQ2znx5CqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAJhZuB0bt/8JRXXyF1bWN2J18YSMB8GA1UdIwQY\nMBaAFNc+ZESB2QcEZDNv0jRTadoHTO0mMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBjN2AJLNx4rp9JJpzwXohF6dFe5Rm96ERQ\n1kKmpW7HzQIgN9zkNL9pGNhVqFHBnOyScR6snq/NI0gFmMABJPvb9no=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeXHwOEmXFUSKTnj1BFMggAOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNDY0NmUyZC01MjNmLTQzYjAtOTRlYS0yNjFkYWNkMTE5MTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyNOhkG+v1f1acW4f4cug2TND6XSavovBgwJrcVrRS1ZJn\ngLrrPuwM/V4g+myPHtCuZfz6gjbcLsCkCbjkWYGko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1z5kRIHZBwRkM2/SNFNp2gdM\n7SYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOdOw+nFuqYQSpA67U7jgzJGwhPzr3sEQUxPEiBQI563AiEAyGyfmasr\nxA00TokSTBCU20eKxjdWk4o8podB+kEMK4k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAcnPSilzZrTAVwBi3pwh/SG4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBjODExOGYtOGRlMy00YTM2LTlhMzgtMDI4YzFiODQ5YTU4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjg4OTA1MTktMzA4Zi00ZDE2LWI2NjctYTc3M2RlM2Fj\nMDBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErAkgFeoQ0/RcaWtEx4jXLnlV\nQVXi0jC0xUBtUmxu3zGPv11yqShsbg/197w0uGLH7/2PttErdwfd44YN2j6iqKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUAmFm4HRu3/wlFdfIXVtY3YnXxhIwGgYDVR0RBBMw\nEYcEAQEBAYMJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIBRNwz9aR0nz0nJU\n8JmsqXi9xkxN7KdT1eTZ8B6qDGP+AiEAsiIvLy7xdO6lsFUj+ueEPw3enoiCnM4Q\n05W8K+SYQgY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8811", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8811` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAUzeB2OrRYzugKOhngNcruO2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZDYwZGM0LTBkY2MtNGY4Yy1iMjAxLWY2MDAyYjRlNWRmYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZiOTkwOGEtYjYz\nOS00YTM0LThiNTgtMWFlM2ZmMDhlM2M2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoO+HfHJbvN/0h3lN80baDzceOI9MkQu+/UphetM4eo+3ATzwsyYpwFfoXYKK\nzM0rlZ+UfUNrR0dSpMwqFVfvzqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCWJpIl/VyUEdx6FZnwYXvVC7BBAwHwYDVR0j\nBBgwFoAUXkaoneGqgNjVy5Q6mezQ+6eskVQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD4scd7u8t+8Baz48mdyOhZm9gW\nHk+bmA1Y3QMBLPOBaAIhAPBy1CtTAvl8cy7xL4QDCbI1dFsyEXq/NE2qjeEIbEY9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARaOr+HyG7tzXC4eThMHwJOdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmQ2MGRjNC0wZGNjLTRmOGMtYjIwMS1mNjAwMmI0ZTVkZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3XIv1lo43ZMAoq+uyEoDw3lkkOkHemBdogRJU/8S0QUI6\nSnR6rs8f6cOB+VfI1BkZwukd7mhOOzuhFArqHliho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXkaoneGqgNjVy5Q6mezQ+6es\nkVQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKNQTcYDn5iTDeDcSBUd/QAV79+MIx/d+Clw0yuH3v89AiEA4oMdKY5O\nK7WCHugCGKMeZ4zlPhGC5a7HyEJ6TZoKcTc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAUvT8IERoBYOd2oNomyOqIfRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZiOTkwOGEtYjYzOS00YTM0LThiNTgtMWFlM2ZmMDhlM2M2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGRiY2RlNWEtNzBkNC00ODhjLWFhNTUtNmMyMjg4NmM1\nODdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoD9jU1pRXfUdt7M4eQSwPKfk\nIgGVKk+eNXYLLCmyrmy3rVtkX4DJTtajRMXYfs4G6Utg4EL8qA0TgdmIxIvMg6OB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQJYmkiX9XJQR3HoVmfBhe9ULsEEDAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22EDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDtY8dUrV8DnsltecbDSIxSfaYybqgt8dGC2363LuT+aAIgBVnec2GC\nK8+M6GzugUnTw/7V/gmzIoHly05ah+TblHU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8812", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8812` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUZVWBEa3JQx4WmVRyhhjrphMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5YzMwY2NkLTUxZmUtNGFjMC1iZmE1LTY1YTg5MGE0MWU1OTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk0ZDc3OGEtNDZk\nYS00NDE3LTg1MDYtMjE4ZDE5MDQ0M2M4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5IyIb6j7m6cGfFwOR3Kzw2DgAbCXfft+yhex3G+XQD9QzbmDXG4WFYKiJSsU\n1XELX+D17NmuannjUXHSJc3ZsqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ/+skleqv4yhoGjfLPGCOGMuPBtjAfBgNVHSME\nGDAWgBSBKbUCQw2yZoHSQOxu01fMS7XGJzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD1PVH2CiGWDKWCEfE7jmzdBeJWWBwh\nQk1vviNNK0mjFQIgE95FjQ6Cf500fS3VSjZDtJYlyUiVgjT2yrURCmv0dMQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAezbGq4K4I1z685UWAcEv8R2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWMzMGNjZC01MWZlLTRhYzAtYmZhNS02NWE4OTBhNDFlNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6v6VI7Mtm4GOm8bh2LJe4HcVWygpi3t7GB/vzduoH+8JF\nsXZN3MZIjybKcbtspjITqbOuRSJazMxtc4NKDXg1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgSm1AkMNsmaB0kDsbtNXzEu1\nxicwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPKJsZrwY9276RnYoSzDwZVDOieIA3WFTFcFWnH+6rEgAiBcXBtS4h9s\n7273xQLU/BkCdTRDJsyZNZ3D9R69YlNKKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAaK66yBf2tsZgUH+Ilq56gLUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk0ZDc3OGEtNDZkYS00NDE3LTg1MDYtMjE4ZDE5MDQ0M2M4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmQwMTBhZTgtMzVhNi00YzRmLThjNDItZjBjZjdhYTE1\nMzA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIf0TLod3Fst4d0UjVZYbbpjJ\nzfdokIm7kxQz5rd7Ww0I7a7W0hhiraC2Vnc7qmLyk6mQ+qNtqwuf6OnMJJFBq6OB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ/+skleqv4yhoGjfLPGCOGMuPBtjAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22EDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIAi0RFoIfk6Zx3JJSu8rW384SgOkolzIR6ghTw8nxZTDAiBSNiTqQHFC\nCtybdu3TDlhMsWH+Zo0hdSm257u1fIDdUg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8813", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8813` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAblDYjOdnbHb/HBH24jdFESJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2NDNhMjRhLTYxNWQtNDZkMC1iMjQyLWJjM2QzNDNhMWRhMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY2Nzg1YmUtZTZm\nYi00YTFjLWJkYjYtNzdmMTQwZjI5M2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6p36hEnoI4DiDtmOsLqi4EEIqL7f6IMvoH5+xXpYBkb03WcAHC6Lt+uvx8h+\nnRRVoCN5nEPCDwNJe3Owrv+YIqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJtfJFCZdVawFXe3FL/P1+I62HvgwHwYDVR0j\nBBgwFoAUjTIqSsN9Atk6ivj0aavCekgJprswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDCCIYwBzv82q5jxl5hWNE6qfPX\nDLlMWq4qjvon4vdGlAIgJgXbE5ZfppUE/9y/bOhrrNgJxFtgINlanGNO6+4yRX0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXmetPLUSLZPmxF94f/5hxw8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjQzYTI0YS02MTVkLTQ2ZDAtYjI0Mi1iYzNkMzQzYTFkYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+UBdnpN5YhHoZ1XeOc20vJT5m8SaAwqBuFjSX4GHbQqjP\nCQu6h+VQViXeKUQHdUrogfdIO7JBGJdBptIzEWDwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjTIqSsN9Atk6ivj0aavCekgJ\nprswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRNh06MFe/+kJHcBiDKEzCYp92x0to76MsT5Bhap4nH8CIQDYaeux+qyE\nYLI0V+/DRUC8wJfMTA2Ss9rNpmCkiMVJiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAUJMD5C9twDKTTnu05p+NaU4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY2Nzg1YmUtZTZmYi00YTFjLWJkYjYtNzdmMTQwZjI5M2QyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTBkZjQ3MWYtOWQwYy00Y2UwLWJiOGQtMGI3NWE4Njdh\nOWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMeey/TtsUSj/m8HJ/KJFeR0+\nglHfDUGcUYjxeTQ06Uo9rnwgvAdunLqZPKnte2+Gu5XWmo6LZn/HAX0mvfCUoqOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQm18kUJl1VrAVd7cUv8/X4jrYe+DAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22EFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiA10aeN4sVKRLo/A844smzKogKTDfTT/evtd1f+BtxS0gIh\nAJ5FMgEQymlChLU7vKp6E0iNa4uOeWC+7soPjRSwBd9J\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8814", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8814` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAd3B+vZ2HP/M1LX9lvm7WfkOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFhN2ZjYzU2LWJjMjctNDA2ZC05YTc5LTZhZjljY2E4ZWU2YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE2NWNhYzMtNGU2\nYy00MTA2LWFmNjgtNjM4ZTE3OTEwOTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtluTSiHg7d9qRZT0eRpOGsFxNOL31WG9BLgtk/xneHtZUUsJwnu5Kg6s3LGS\nhCzAIvZX/r6u7BlxP/rHwN0M96OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQr96v54Mf6N/hFOftgzZRiFu1B6jAfBgNVHSME\nGDAWgBR6ofujiNQDdG6buor4rO2eilfxMTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHLISmLJCmcb26jFEjTRGlc9RVK190i9\nZGT/c2KTLT0oAiBdqaVaoxnKuTp5pb5Cxx+ziS/R9Y8syTqJeppiayG8bw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeeHndffPNmlZaiY5kaOZIWwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYTdmY2M1Ni1iYzI3LTQwNmQtOWE3OS02YWY5Y2NhOGVlNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEMNVntCQXh6Y45OM+gYsqcLHmKUKYx0MgsU3jM4DdgLVw\n/49DWAwmTb45nM/yADDeATZjnS1O50QvP/d0Ovujo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeqH7o4jUA3Rum7qK+KztnopX\n8TEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeZ6ydhIZe63j3w1iRuHu6Xgth+seH4oCaPfhQEEP/b4CIHPDACpZCHgO\nZyHFlzRFdRCIimwhVtRj05tKoBZxsiTy\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAao+bd+CNtcXJWdbr0KWe7cKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE2NWNhYzMtNGU2Yy00MTA2LWFmNjgtNjM4ZTE3OTEwOTNjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmEzYmYzYTgtMTkwOC00ZWZjLWEyMzItNTEzMGQ5ZmU5\nOWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWdUJpAU9MamMQ59lKwGRgY0X\nf/6ssjJvVrSE5HRAFfW7isA+7uvATjxzREqVLlxESEZ3jrD/74GkbuFdE0bTlaOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQr96v54Mf6N/hFOftgzZRiFu1B6jAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22EFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBAnE91qN+fwyeFsOdsukMon0E2t9HFDjlOkDlBG9isiwIh\nAOac9wTMnrGdjd6WG/myBbmVmPwz9YNmrh84APCCjbUJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8815", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8815` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAf1PVk5fMU0Kuf4j3cLBaSg9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0NTlmNmY1LWY3OGYtNDExOC04MGVjLTQ0NzlmZDdkYzA1ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE1MWRhOTItYTcw\nMy00NWU3LWEyNzQtYTkzNjk0MjY2NmEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEesmE7CIyaPZeiRhWnsD8wZ2KLxzCSmKMybFoYAqfIUE049+Vk5/ucZafSMbZ\n+U+g/L6W1082is1x2dwdf3vR1qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbwvWmZb3zI7kPw5ll/mXyeNwPCAwHwYDVR0j\nBBgwFoAUrXnCOh+jfrV5ue4wuxo90FzsUuAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGxajYHmtVSwsb73TjcJU5fLFI1p\nhFFpVeLT7LiqF5fNAiEAxI0+PRPSBGii7R03rTdKxxDNO9x9DVOwTCUbofjmJl4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASvsKaGb1dE0AF3thIwjR7+GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNDU5ZjZmNS1mNzhmLTQxMTgtODBlYy00NDc5ZmQ3ZGMwNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxb3f1UsVT7foe19LcQwNj4fZBWtvHPPcTuar+d2mEk4jT\np8Jg1Umpt1/muZMoJhXTNwg+aIV0x02e477eTUlQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrXnCOh+jfrV5ue4wuxo90Fzs\nUuAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFTeTraGHqR3g2xDHYga/zy+nCrNw8M+3giCF4CqTE0gCIAhhjTQFoCfe\nA2pRMVPmgIm0LUa49To5L1FAq4VlDcPe\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAYhDKxhspoXwBBAwkxMc/dJgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE1MWRhOTItYTcwMy00NWU3LWEyNzQtYTkzNjk0MjY2NmEyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTJiOTgxZmItNjY3NC00ZDhiLWI4YTMtYmE3Y2M2YTc1\nMWEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECoM/ghk/DvHGjAYYWvKXM8s0\n13r9IQA3so68pfd08KTBF68Y+oeYddgEnop70Fc1Iuq7s03plkcd1zgQOF3TCqOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRvC9aZlvfMjuQ/DmWX+ZfJ43A8IDAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22EFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSQAwRgIhAIMkPrAb53hYy67B057/zSlPwkttddKddToih7SdXuRd\nAiEA7aaL5Ac1PXHk88TDQgGLPbB7N+mRgLPzrvMjHRtB8k4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8816", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8816` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcvaVM1KHCQ4UB0URoB52i4pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxODY5MjQ3LTQyZWQtNGRjNC1iZDc1LWQ3ODc3OTU3NjJmOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJiM2Y4MTQtNjNl\nMi00MzVhLWJkNDAtZTAwOTI0MjI5YTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+R0rUUP/Zh0UbGF4jMCk/s/DV1G5gCfrrenVTG9XBj3qQxQ+s33NtByH+lTi\nsN+qnRgj8hspk6E4utwbN3p7M6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQmfElFAWxl6Jmw3s+1DOCcLyXAYDAfBgNVHSME\nGDAWgBRNg850REYYS/bw+ukrtP1OBOG7BjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHlFkkpRHFuBEZhmHzYr1JDZpmT8ZbEO\n4rcy95mP4pwfAiEAtgOlto16tDcsZYtPltcELqEBHF0PGsfFCLKQrovkYH0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAamfNmvqHH17VVQNS0WMjBZmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMTg2OTI0Ny00MmVkLTRkYzQtYmQ3NS1kNzg3Nzk1NzYyZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSh9Xwgew/AwdbV/4qTlbFAXzBbywrama53sBgfzDlV/Ey\nOWm6H0CQrzg79ANV44OuhIDhjhvffDEk4747o6fuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTYPOdERGGEv28PrpK7T9TgTh\nuwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbJ8McnYRmUKQJyymWrwC8pn+XBhx2+eitw+u0n+PfTcCIQD/WIVeJoMs\npNKoPqoe5XIE6ydliAjVWCIywHPPktxmKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISARp93ygVqvPjqKlZ9MKVdcM5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJiM2Y4MTQtNjNlMi00MzVhLWJkNDAtZTAwOTI0MjI5YTdiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQwMTUyMzktYTM5NC00OWUxLTljMjgtZmY0NGZhMjEy\nNTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE978z+Ph9xDoVOjVMpbhLUBXj\nmw2x6kdlrnLxlCxktfWCN4wzchI83cTGIRXFImy+DPnXcb5xmpDHxFpRCnSr8aOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQmfElFAWxl6Jmw3s+1DOCcLyXAYDAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22EFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSQAwRgIhAIsg9niSGVYg60L2+OyZkNtdCI/CksMGcgQPjCGPgtFJ\nAiEAp7z4BoN+MwW/pdt4gcFRPwjAYLiPM/0AuStGPkwkY0A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8817", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8817` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAbPIw3LW2xd8j2zREltMSZVUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1ZDU0OGYyLTMxM2QtNDJhZC1iNGYwLWY5OTM1ZmE2Nzk3YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjZlZjNkYzQtMDFl\nNC00NmZiLWJkMzgtNzM4MjYzNzUwMGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8MhiPq3FPJ9gnrgeB3EeQe9O+dzTyh2Rs2tLw7/WkT81u59lSx5RBpEozHCU\nOJAemcwczkbPeqH6wN5ZZqZvKqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdvceXg8wRCFdzUD24k7sB6eGbvowHwYDVR0j\nBBgwFoAU+iIAPOgo7X0bWueyuyFL4b1RSC4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHW8Ic/cmTQ9TOQhfNBgFlGpsUaT\nbXwkJj4QKT7JkMlpAiEA1s6pR4p+fNeoUT39USmZhJXit5+9LteISJV8Rul7ujg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaXSfKnnFhqSNaYSq79fbI9hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWQ1NDhmMi0zMTNkLTQyYWQtYjRmMC1mOTkzNWZhNjc5N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgDfr7mSOKT9xDOq0MXrtRntF7jg3mdyunFnSxm0mbHMSe\nCXRy9EVuCZo9NYClcey6L396EfRfNOxuO3VTAIPco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+iIAPOgo7X0bWueyuyFL4b1R\nSC4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJkYv70vNCAHPUDSCC7I2MY9M4JwEYIQyfNXzBi7sMVOAiAkPZulVSB8\nRsciyeWFeWEAeN4OwhhuF5B+B/XEgvjm+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAf3dBgrKbVSaGARJToJK1/fqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjZlZjNkYzQtMDFlNC00NmZiLWJkMzgtNzM4MjYzNzUwMGQyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjZmOTVlNTYtNDg1Mi00OGVhLWE3ODUtNTJmMjFiM2Y1\nNzgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+d63OSyA4aaylZziWk9hSguS\nN0sGEAvEfGcFtCDz1oqtaR2ZpJ7CE+D6S8Seu08MKxLxmBJQ0HOC2x3pbbdl/KOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR29x5eDzBEIV3NQPbiTuwHp4Zu+jAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22EF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQC7wYqp6jbK2jBzZEW0RTTsBLHBRPL8LzUuxFl14a5s\nkAIhAPlj2M4WAQumq7w/T/W+DlUMScatunJFwJMfIygTca2D\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8818", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8818` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISATPtvQOEKM3tonSPR0PHdAeMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3YjVjZmEwLThiN2EtNGE3ZS1hMmUwLTg2MzM4ZGNjYTg4YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzAyMzNhMmYtMTU0\nZC00N2EzLThmMzMtYzdkZjFlYjk1NDM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIPhR0Qcujk9wkuV+0hB2KAnki6nuQEjOXNcFSozwuIzLgCmvsq091MvjVr9M\nL8nPsINrJY2MLHKBFootFnCXraOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSIT6Ih8HgKCjB7+ovp8MMGRxxJkTAfBgNVHSME\nGDAWgBQ2vegUah/QMwQlW+TL6YSGFLt8TzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIG8yyd7fuFlChColJNrcAv3TW4qpiWzV\nTi2S4+AzC2jDAiBpMdMWcQ4SXUUcxL7EBkyfJspy6lQIDFPEi3csgYi7yg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYqnUjl3wTWkmtzaP4vsWQyHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nN2I1Y2ZhMC04YjdhLTRhN2UtYTJlMC04NjMzOGRjY2E4OGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATOGRad3cnQTpOFCEL087aCL6t9m33V2mJdXtEv5Kkm9vM8\nCY7rouQ9DqCxKoo/qMYjyBhNRdKtvqtLZmX7sNbQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNr3oFGof0DMEJVvky+mEhhS7\nfE8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANiJXjZ5qYc7G4wGnLD0arhZVWbdA06TDXT3I4pX0lphAiEA+WkoSrqR\nbQqwQV783vb6v8+IeHD814C/w3PvdNZAaig=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISAV2kyD3OX0FzZfDXgZXH/Ej2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzAyMzNhMmYtMTU0ZC00N2EzLThmMzMtYzdkZjFlYjk1NDM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQ4YjNkODctYWEzOC00YzkzLWJjMzAtZWNkNjExMThk\nZjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEPiBBeqw5Qrk4asx3EMwBJVE\nuFv2Rw10PBC73PGeMvLXmhQp0Fq5/d2b1BGkbY6XV5dwxnn0eIn3bW0WPLfU2qOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSIT6Ih8HgKCjB7+ovp8MMGRxxJkTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22EF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIAEDe4bGEXzjGCXUymZ9I90CPhAPi1fSH+ylavjJIFpG\nAiBMkZrImrzKTI2gTCQ/2i/8ZJv2GAb3ajfS3ZoG7AJWvg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8819", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8819` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASo0uiJUijBgl2e/vfbnYXCRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3YjA1MGE5LTFhMjEtNGE4Ny05YTcwLTIwNWNkNzVkYTU3YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMxMTVjZmUtMTBj\nMC00ZDQ3LWFhYmYtNWNhNDdhMjkzZDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEN3AgU5NPbM0D+Gqr0ohD0wd1tB5X6EpxwXqg70zGQy+C4EoDACFJi8VIbQzJ\nCkMw1sSl6i7CxS0vHiposiatNaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfn93s+ArgsDAlnPA6wpkt1WvpSYwHwYDVR0j\nBBgwFoAUyOgdOIQxMxlHqpVG/MeVhKkwzTYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBZ9iIy3U++60etSFOQkQhEO42Bf\n5GLyWmJ6OWE5zxlIAiEA90F3XM9xyicBeEa0hjheLrSBYHMuBk+KQVZkRffx+90=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUAayAntv5ObZR+hJn2h6YF9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2IwNTBhOS0xYTIxLTRhODctOWE3MC0yMDVjZDc1ZGE1N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPY7v9r6CDzTAEJvarupMd5AV9LY8ybVBfQvkvSBCsk/5u\neKPixOA5JcPZrZuxhtdMbP84fgfPacP7LYGXd+xio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyOgdOIQxMxlHqpVG/MeVhKkw\nzTYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX5JT3E2xUD3BSQ1BDg4A6MEDyfAocc6oVt8LTDn/7/MCIQCTf7UiFXJe\nmKb4+VVoD1q9GePVOftNAIcyG1DMVpIPLw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAX3AwCacavWV7T063KkwJij1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMxMTVjZmUtMTBjMC00ZDQ3LWFhYmYtNWNhNDdhMjkzZDAyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjVkMzhkOTEtZDRiYi00NmZhLWFkYjYtNGU2YjI2MTc1\nZTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXc/B8wlcXngIQWGCTPeM7FM0\ni43doJSExmsqH/7heF22lvrySSFnhzKMoAjhxAKU+sSdmj1DfCo04vmXVK6536OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR+f3ez4CuCwMCWc8DrCmS3Va+lJjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22EF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQCK3gixDzsgxTaRZVKSuy9IUu+mc0Pw5+CuqUc2fg2C\nHAIgOUHjY2mssJo+/akNC/kgfUzZI1eCF+aaKDXlBqIu+so=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8820", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8820` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUpJUIfVbwq38MUhzDrTIRhhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyN2QyYmUzLWM2MDQtNGFkNS1hODY4LTY1OWM2MjZkZWFiZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ3N2JhNDktZjdk\nNy00ZmFlLWE3MTctNWMxZDM0OWZlM2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA40tNEXHWpMjvXsEq0USMvsXliiXCO/tMnPL/Yq+6yR5QlQIP5flQnxXfP7u\nopUCIgfTe/5TssuL9HGrAiiamaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSbVjVU4rHrVMq2y9jSWeUMiPJNWjAfBgNVHSME\nGDAWgBQNtBFe0gfmj12b+Rl3E9YfH2/8ojAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGj4W74v0dXPdg+iJyRFXvlnbplmm0SB\ngc7Ezm8r5LsMAiEAtQnSk1cOpxZGe7jmqBmkVOzVINPim05Jddu7tqprk3w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATSJUzt9xl5iNxW4G4JVGjnxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjdkMmJlMy1jNjA0LTRhZDUtYTg2OC02NTljNjI2ZGVhYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWOspWZJ6NTT2o5irJsiavdW9Y2wigqr9/oY6I+1kJiYnv\n5Vo31Nmu3hwDZXBX06nYIE8h0H3xDevXE7eg9dAPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDbQRXtIH5o9dm/kZdxPWHx9v\n/KIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMoLd/2prR+RHJmiIgBt5Et9qcSSP8YMNN83UKj3T27fAiEA1cL3I0mV\nhejDaYzT3Dsinai1Z0frph3GncQkbN9+mi8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAefsyNWT8PQDnqWJTNJli+ZgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ3N2JhNDktZjdkNy00ZmFlLWE3MTctNWMxZDM0OWZlM2U4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjMwNWM1ZDgtMDIxMy00NjQ1LWFhYjgtMmU0ZGI5YTJm\nMmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6C8y898rceTF13ZQ2K7q+jVK\n1ia45GUzb+NLVS0yLVoAp0XzPopX/7PqJzq0ChlpWI8CLXPkKXZole7D01EiUaOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSbVjVU4rHrVMq2y9jSWeUMiPJNWjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22EF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQDeNKYia1e58OCiy5nDgcLRDydpw2f68L6yv6opcfp4\nwwIhANxdTDfEds/921JWC2PVD3yj8zVHRyDpUqwsBtLo7Dcq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8821", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8821` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAYqng9d073ZDFiAUiL+MuOsVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFiOWExZDAxLTc1OGItNGRkYS04MjA2LWI0ZjZiNWFkZTNhNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmI0NTA1M2ItOWQ3\nMy00YTM5LWFkOTUtZmZhZTIwZTFiNDQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcRC8Ndpo5vW9gAED7qbrHgqYcWtVdoFGeZYm1InYuETsuVrZE5hiOoJMOCwY\nlfnV3kMWlUrScee4JLB2nK6MfaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLWgjJ1aZZ+jIiG3mJjFaBBTdY5KMB8GA1UdIwQY\nMBaAFDS6XoRS3pzc72Al7YmCw4l7RjdFMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBRtAmnvi3JQjLErsqR5SZDjQwyPZsQYzew\nCXqILaO9PgIgcr6NegACi3GdsiP8GV0ronR6SU/OmyO0P/eWabhDuPI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXEQVDIqpgJfJv9kWLJPCOVrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYjlhMWQwMS03NThiLTRkZGEtODIwNi1iNGY2YjVhZGUzYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScXj0MGV0ci1gkoAAPZpYIT5sh92kK2vyAzjNK/DEm6Jz6\nQL655JCjn02C5DtkXMxCdtfmSRR2aUCj9vg5+/kbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNLpehFLenNzvYCXtiYLDiXtG\nN0UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMoZUsWMeV2N4xDkaYjNk/M+0L5gfm0Qfjijq54HuZP4CIHCxTojes27r\ngngtjRL38a2BGrL0OrFx1KmG2f2RxGLX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAZ/ZyVvGIw2asYEEMGAkIftWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmI0NTA1M2ItOWQ3My00YTM5LWFkOTUtZmZhZTIwZTFiNDQxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGVkM2I0OGYtNjFmOS00YjU1LTg2M2ItNmQzOGIzNjhh\nYjUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqrP6yS574wubD45r30tTlrZK\nKBpgAYdOht/EIAPakTdao8erfVCoAWApN8w/AhVSgqkskUAy2qj6a+gss5Zu46Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtaCMnVpln6MiIbeYmMVoEFN1jkowFQYDVR0RBA4w\nDIcEAQEBAYQEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAqeaJ0Ey7u897LIiPGrpa\nX/Y6vqUjZIirafb5kZBrD7QCIELVuIpDshBgxwuQfVkhGwk2zKpw+N+Csi3o9F3m\nRq4Y\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8822", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8822` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAR805ah3u3xivIcw7YNrMakCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxYWUzMTIwLWUxNWYtNDhhMC05MGE4LTU0OWM0ZjVlNjgyZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZmYmQ5ZmUtZTE0\nMC00M2E5LTg2YjAtNTRlOGFkMWJmZjg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsPXMq+Njz3T4gNYPjEAd9/pJeprKfoYTuCZoWOUnIKsMFxG0L0WnmyEGw3Fp\nj+GdixMspnFJThmSJrc5LtswSKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFD/GRbOFdk44oCf0xe7YKk5/TfXiMB8GA1UdIwQY\nMBaAFKaI8FBLnmtyoidr+2ISxUabtnGfMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBIdWTFzii4dEgDOBRShcBwIppfwEXKuWhR\nPf6SpIWG6AIhAJSRPsL5Fc3qA+2PD/luTGBZLLtMFdvpZI7Q21MXRMeT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYz6Vn4zY0nQ21/fT6rPhvlCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWFlMzEyMC1lMTVmLTQ4YTAtOTBhOC01NDljNGY1ZTY4MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUr+aobQ9UtNjnDg21pA81kKXbeCnFkD3a1owaIu0wEpdt\nCecBYfSQWM7siugN9u6Y36Ttq5Z6GZzzXCInOVBvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpojwUEuea3KiJ2v7YhLFRpu2\ncZ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOKBQB8tm5uCdaqW0f4mfoANLGTZLVfWPyVjjMtg2gz+AiEAqnylmKJ4\nGeR3CXnWycv1yb2RlSuKFctmtnYMnhiDR10=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAWI69hTiiZ1DxLS/vvmGbkilMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZmYmQ5ZmUtZTE0MC00M2E5LTg2YjAtNTRlOGFkMWJmZjg5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzFiNGQzY2UtNDI2OS00MDUwLTkwZTctNjIwYWVkMmMz\nN2EwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5kGVXo8ZjAV9Ng5kzh0obLc7\n/o4vVrKtSR9TvsxQvFRa31q4cY5e5usIPWHvychH3HCFEzrnryFNCUuCwBY4gqNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUP8ZFs4V2TjigJ/TF7tgqTn9N9eIwFQYDVR0RBA4w\nDIcEAQEBAYQEfwAAATAKBggqhkjOPQQDAgNIADBFAiAmMTeXx8vylyOstB6pfFhM\nA2zREroXJwSFB/vwcsJr5QIhAMdBiOojZiXDqVSNrVBop5gbjCpEWHCqjvXD6JH3\nWPrK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8823", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8823` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAeYgueCCpKkqAzUvvS67F2naMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NzFjYjgxLTgyZTEtNDIxOS04NGNlLWM1NmNmOTY4MDc2NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQxYmZkOTEtY2Y0\nOC00ZDY4LWEzNzAtMGJjMDQ4MzliN2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYfiQOdKVInF9vV7fumQRGcwC24EoyslKot6Fl3NyDi0PNdTd5ibN5B+LUkvB\nOroS27vk8SL1GpJwm45Jg/D1BaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMSgNg5zbqGltPboOaLt9J1AWgLuMB8GA1UdIwQY\nMBaAFI+2ZvbPHJGqlI0M69LHy91dfxezMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA7u4gj/011a/IW1k8vvT95w7gquljCs3f\nfyhr497kSGMCIBPCYc/MX3wNaVK4eFsNJ4RY89wTCv/8DMvrU2G/hpmv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARKAA0Lz2VQoKPGOAJsPhbmYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDcxY2I4MS04MmUxLTQyMTktODRjZS1jNTZjZjk2ODA3NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKyjruKYNAzFX14zgdhVxWWZCzAU4x8Xb3bnysr8NikY8b\nGsMWqIwNLVWIQCJuQzV0fDeXRE+AEb8qTWFLk7kzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj7Zm9s8ckaqUjQzr0sfL3V1/\nF7MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJIILzJFuy1l00hG1FHyvA/YQMhx7x169XblHVEUU0jJAiEAuGyGDoVt\nOGOyxyzx+0zYv4kd/9rqLXowgHR8O5E/PxA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISARfrNfuSeVfyE+YQkUFCHqZLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQxYmZkOTEtY2Y0OC00ZDY4LWEzNzAtMGJjMDQ4MzliN2NmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2IyMGU0NzItNzhmZi00OWFhLTg4MmMtNDc2MGIwNzIy\nNzVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0vjQJsFYu8TkslmuBJ/3REcS\n2zA9wTImZRXs6djDNrTNhNpagv4v3lgCL2JFHlTPyMJDqT+LI3xsWowXecI7AqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUxKA2DnNuoaW09ug5ou30nUBaAu4wGgYDVR0RBBMw\nEYcEAQEBAYQJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIQCUcYoxysQPp3Zc\n0vyTvKgD2mUf43tyORefzVXMiNaZFwIgEgDb37p1tYoBnjpAQRVevCLOR82QMXol\ncBECJzYCA64=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8824", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8824` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAdpdBzPv2Q7c6SzaIvmpJ8ZIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkNDIwNGQzLWExYTYtNGFiMi1hZjA2LTQ5N2JmNTJlNDc3YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWI1MTA1MTktNTEw\nNi00MzAyLWJlNzMtMzY4MDhhY2IxMzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7tdYuNPYxNRDRVBWDyyrOBSdTcthS04nnJz1jPOz752XD1b0edlaIWo8TDxM\nodZM4a+kacoUM0L0w3iZiAWPtaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGOKPaSUHSB5vQtlZ4VaCMHITzgNMB8GA1UdIwQY\nMBaAFIFfb0GjAGeP80fKl/fKp+h013bLMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvN0AP84W9uTLCBPpAOH8k0yUqzQMFBcC\n+ju2za0EjRMCIQC8j+mSDoL/ertOL5ZyFN8+Yape/vHR3JycAgP90WG6+w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS9W4YKjDlPE4kTTvr6SDeExMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDQyMDRkMy1hMWE2LTRhYjItYWYwNi00OTdiZjUyZTQ3N2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjpkcSxHqqxRlSl6gpu188mQZN3CwK8NFMYFnckpJ+mMP6\n2Ub1lpFDYSXGvu5H0LFjJhrmgLCcUQWPzcf5rWYPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgV9vQaMAZ4/zR8qX98qn6HTX\ndsswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIchf6+r8FGJJocQ3LY46LIQrOLVqMjULCZfxEZPhf9gCIAv1iyJH7fzS\n1QzRH4HxPKmQuDMuSEEjeeWSmZ8QFP1+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbqgAwIBAgISAca0GLLq8LpVM+amIDC1BBcKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWI1MTA1MTktNTEwNi00MzAyLWJlNzMtMzY4MDhhY2IxMzM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTFlYzU2NzAtODY3Ny00ZjI2LThjYmMtZmFkNjEwN2Ri\nMTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5+9NIqTWSSpOHWDcZ2ot0c9J\nQFpS44lu75jpTSrPj8mEw+9Hek9dM0L6JnysX78O5cs47B9V/3tlixiUWyLbMqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUY4o9pJQdIHm9C2VnhVoIwchPOA0wGgYDVR0RBBMw\nEYcEAQEBAYQJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0YAMEMCIFCAM4OPhN1kH0zi\nAxa2dGpBSkZ/lqk1ms3uHraDcIzMAh9hLxchh6J1+UlZQRaQ6GeMmflUdrSRwTpQ\nYX+YEp3e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8825", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8825` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAXrLEeKuvONs/qEObewgXT4WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyMDMxOTRkLWFlMmEtNGMyNy05YTgxLThlMmE4ZmVlNDcwZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JjMDg2MzgtNjk2\nMy00YTQ5LWE4MDgtZDNiMThlYmU1ZjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErdOeqRYIDQXFB8m+exRgielHtDvGbUFj8gDxX8y4FhksLLlHMaqlofBpElrJ\ntojyTEqerZhShgvDNnjJI8ekX6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+ucMsnJChPQ+5iCtjbpKJfE4v3IwHwYDVR0j\nBBgwFoAUsvZNJqwHfts45tibGvYUf95oxRQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCXziJjW1lpSR17X3QCWzjJ4rZl\nTGFlJwjuqYy3JQeqtQIgHZlFPiO74DNUB47QYHPnj7sX+Joah6TGOrx/a2Lr+UI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfGVs2vdybKHH+kLGkw/W5GsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjAzMTk0ZC1hZTJhLTRjMjctOWE4MS04ZTJhOGZlZTQ3MGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuJ/Tz0tYtz+iD3x6qbjyFTiGHLidTkGRmdeV4bNnDtOxD\nt9x5wmxKW3L2FjPVha7Qn+iwnalGWEE3O5EWMXtho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsvZNJqwHfts45tibGvYUf95o\nxRQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQ4W7OCU3yWfVJdGUn0qmVi+SBb/EaQkt8BJXkyeVol0CIFBhSQgpxeE4\nx5oYtG7cRnUSdZOHyDT6kgSGvmKEcZSP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAfhYmuMMgEKD8s06xtbgy+26MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JjMDg2MzgtNjk2My00YTQ5LWE4MDgtZDNiMThlYmU1ZjliMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjNhNTBmMDYtZDZkMS00NDAzLThjOTMtMzFjZGJlYmU4\nMmQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZc25SVoAi6P9lyU2TyaxwnUe\nDx3iVbJFnz51rIp53uXzLeu2RGkvD2VN5w6aBXaU650XkJv3yYmFMiYwoF+I+KOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT65wyyckKE9D7mIK2Nukol8Ti/cjAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22FDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIGHzsYSrODascXRQ17m3JqKEmi7D3TOq7K3RTmu08mj5AiASJUjcfii1\nO927SSRH06pLzU4A9gB4gyvZaGHA9kqktg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8826", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8826` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAeEkRC174ucTNl+4GO5vFUNDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzZGMxNzI0LWUxODItNDI4ZS1iZDJmLTAzMzJkZDg1YWI0MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzViNjU0MDAtMThk\nMS00ZjA2LWJhYjItODI4Yzk5MmIyYTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvY5SZRLtcO3kyg+O63NzhwK/bnaIE4IkrnBiVZnS/2L+947RkIfgq9NuYClj\nz1EnELG6HSXEMmi4CrTci+MbaKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQW+G9Uk5bNI8IP9XKI1a/6h1y7fTAfBgNVHSME\nGDAWgBTrKW0vKSQ9pMCxHoqqcmUbzW1YqzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDwb0jByBpVQ+XqXmrXRJAf/vRsmJFz\nmkhE8oo8ek4MQQIgXBKqRIv6x3AMwzgQ5evUwH4lKJ6jEm4JevrQLCnbUtU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa5HQl5ru+D1WMOZFubQaWv1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2RjMTcyNC1lMTgyLTQyOGUtYmQyZi0wMzMyZGQ4NWFiNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUSWhWyPpvSaPz5PazRwflmROu+w02N2FlkhYKHAD5UdH/\nA5mApnqo/OASlY5bPCT72euaIcDl92pB2dX6q66Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6yltLykkPaTAsR6KqnJlG81t\nWKswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANDhmNxrAnMQoExvIYfc19rAn8RKrIHEExDhHZo6STdEAiBNGb9oR1h+\n5GSkkY7f01x232eEineKmzPeebI3Im5JWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISATjjMgT6P7VoGFCbo2fEk0nKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzViNjU0MDAtMThkMS00ZjA2LWJhYjItODI4Yzk5MmIyYTUxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjg4ZWE1NDItZjRmZS00YWFiLTg4Y2ItYjQzNzIzNzI2\nZmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXpnMKhn1/GrVGLicewGAymKC\nj6BD1axXGrl1VtCopYH2gy3QE7em1y4+vMur7QgeQpcQ335bydqQq+ju+lNfAqOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQW+G9Uk5bNI8IP9XKI1a/6h1y7fTAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22FDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCc4/OawGsNZSc2PY6iD/XG6e9A9Ytrpac/RMSGOD1uEgIhAPfHwG0Z\nvW0OA/yU9daSAFCYa/SVZ4JW8hTZyu/uw/Ff\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8827", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8827` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAd1AnARpNaSweB5WnVZ7FLKhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkMWQyNjU4LWM0ZGUtNDRkYy05YjE4LTMyYTJmYmNlNWVjMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGVkNjI1ZmEtZGFl\nYy00NjUzLWE0MmItYTc2Y2Q3YWQzNzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV6NEod5FTDRApGTA+f7oOGBIT88If/2T0tNrc1VLQxGojlP0GB16YsvXvo5D\noKFG4PPqyQZhpJe7nyGlyjy6FaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmEG7GKms2V1SwlpFIGPzjXAznpcwHwYDVR0j\nBBgwFoAUiZwC4RdBnoL9fJKHi+UHRebkoPQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFpBuMF8IC3BD2Z98gHVm+1U8YMO\nX1J4lChIyXU4ipfIAiEAnUV3I2LfR/lq1Y4P/9KfzDo4+2UTUwf09T7zU2I0er8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaUNdPqg2uvwEdX8HEgp8p4NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDFkMjY1OC1jNGRlLTQ0ZGMtOWIxOC0zMmEyZmJjZTVlYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGGV0HWPUSJjtIOzvdhPfX44vvfMBzLqI8X234xO9hJd68\npoFxofieJmS/WLgNsODyWDl8eO0g+ZqjIVCYDMEAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiZwC4RdBnoL9fJKHi+UHRebk\noPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfkE6mH7xLOuRUkL6uyGwyAQcb7hdTPGfgWii8oKo/MECIAXiohHlDYgp\nY1UneY5kwa5bumlSoV453O2YTfJ0rLAV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAb4Lh1mGKbIxL7BhuhQp6hTYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGVkNjI1ZmEtZGFlYy00NjUzLWE0MmItYTc2Y2Q3YWQzNzA0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODgwNDQ4NTQtOTM0Yi00MDc3LTlhNmEtMzQyYWVkYTA2\nNGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2fUI9/JqITSRM8t9AZZUb/dv\nF5tnPNcKWmj8oVceEzx05dkHnzMTvEo41QoHBxZzFTeBFx6uM7hcviBoiQ1ojqOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSYQbsYqazZXVLCWkUgY/ONcDOelzAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22FFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAq1isi3KqOgX7Da4Fs/YngXHFUO3lAlUr5ewgm70s9aoC\nIQCZDyQ4nk3548STRgSoCFLBYp+GlYKn8xf+VvP2qLSNIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8828", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8828` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAfNRAtAIr5oVpWVq7gdPfTA9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNmMwNjRjLTA1Y2MtNGU0Yi1iMzg0LTk1MmFhNWQ1ZjJlZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmRlZTc2MTctYzkx\nZi00YjY1LWJlMmUtZDQyMzAyZDU0MzIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Qf2nD5gehPVkgdqtcyXtcxtZsalK1T0b/vgzxfjt3WsDGjxCR7xYz4Z8csE\nOMLe9jEY6A7KGCqLMgq2SX7A7KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRh6k4IRcAn6plkq/XHI0nnJ5bbdjAfBgNVHSME\nGDAWgBTvIJXqIp7hGIErZeCCVX8qaiInnzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDxPW+WZoguBz1VzlXweFsYLYgvZiN9\nmBudgGyGHNTZLwIhAI19nOFz6PEa76v/h3AhgVHz13b4go2LCLU5z/1HfYh8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR4amnk/VSF2AvQy1BkJ0heeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzZjMDY0Yy0wNWNjLTRlNGItYjM4NC05NTJhYTVkNWYyZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARIkEA4cXqyY7f9GxAlaHuoFAqGQjNW93xMF2rlBNGjq5a2\nQk12j7ZG4ZlnrzWn+c3oz7lr/KKdQ/7VfnG173/eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7yCV6iKe4RiBK2XgglV/Kmoi\nJ58wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQhqQNykE+lrAKJ0y6ewch1GlyGhpvOdeG9OjcQMG5ycCIBsgSIrB7yqA\nwlQYhxIIXwpNdhXnYxWUmTH9Gjx+VB6X\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARuILumhJmEbWaif6zFslzrtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmRlZTc2MTctYzkxZi00YjY1LWJlMmUtZDQyMzAyZDU0MzIyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGY1ZmQ4MjYtMmFkMi00MGZhLTkyOWMtOTQ5YmM5NzQ0\nOTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZgOPo4S+CkI8+CDvs8KceEqZ\nvjHqjVjpnWL8Wa0XdgAzk1kFAbPHLASzeV2zAw61Vmk0cB91IaXuEjitWJXe2qOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRh6k4IRcAn6plkq/XHI0nnJ5bbdjAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22FFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiA3F138wcC+2pwjzWt8fFhjCQL+Cwl1VYHJ1panEOeV+QIg\nF7n/fPKozXI9xY/wqIiZy+nbS3HON2fc6DXQj/zBnl4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8829", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8829` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASSsQG6lxNXkVsVwcufJG7I2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmYzNiYjIzLWU3N2QtNDQ0NS1iZjkyLTk5MDlkNzg3MTAzODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYzMzYzMjUtYjkx\nOC00ZmQ5LWE5MTktNGQ0MDZlMjFlOTRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuBfiiHShXcHRyFZ9WCaE9qgMdEGBwXXytfba5HUhC0ociJmZdsWpCBkVYLx5\nQaSeM9UhOJfWAAMaAchI2naOIaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDFZ8sijOUF4bUHpFfp4rB8xFU7YwHwYDVR0j\nBBgwFoAUT8kb3VSIr1pZNCBWpWJpnb1W0vQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQClEMIS697K3xhw8MsJPwlnjdHd\nIoC/pp05y0a+Ar2HfAIgJK8x+NcoEtGK59p95Mp3l8Z38lRDG+1HgQecLGKMHXU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVdXVYaKKzQGiv12LvoJ+rB8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZmMzYmIyMy1lNzdkLTQ0NDUtYmY5Mi05OTA5ZDc4NzEwMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQCl/Nn9LEo1BlwRhZeJP8+9PfDHkcYE7fHI/ck/WUn9SG\n3Mk/gtrrD1kvWp53ROIsH93GWaSdlIDOWCskbc5qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT8kb3VSIr1pZNCBWpWJpnb1W\n0vQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALUzD0VfPpZp0w2SANt2IY9nVFxQdunY7MO+CoeyTT9NAiA1yeER3/B9\n0GEWAsiJmhVJ6dZ1VOhd9+OY36wkuDVacw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISARQN0JyX1NIONvKzfkH2CjayMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYzMzYzMjUtYjkxOC00ZmQ5LWE5MTktNGQ0MDZlMjFlOTRhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDM0NjQ0YjQtOGJmYi00NWViLWJhOGUtM2QzYjU3ZWMw\nZTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoVet9OlCQq68S8yoMJ4z6saB\nkp0pXoRariO7ux/NcdsAixKNGdjB6+l5nhoL2gh0sbJcnAHhCCkJhsnRIYw7g6OB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQMVnyyKM5QXhtQekV+nisHzEVTtjAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22FFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSQAwRgIhAKOM3E9H+kY+40MPCZCnqibuYHBnZ0Z7dWuMsnnagf94\nAiEAh5fRr/rHbn8rls0nYZ2MoGW4x+fzzUTDKwYuGKQzgmE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8830", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8830` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAUm4dz+NPHOakKvr6YqWwnwhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0MjZhMzk3LTA3ZTctNGVhZS1iZmNjLTYzNWUyZDZiZTI5YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNkZTJmMDgtMjQz\nMy00Y2U5LWIzY2YtMjFkOWU2YzRlZTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZMPUTbIHmyVhgTdftlfjoLG3CpTkqYXZrNns8xCD+m9ouqKV0jwDlSSATIa/\nTwFVkvF088++T4UyGyjFUH5Qp6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRozL4QLJlnPcMqfV51uLbxceeJFzAfBgNVHSME\nGDAWgBRGdyQwo2+0/q7Dw6gtGxEVomCTdjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCRhiO7PcYVHKVEieUO0GpMTcMO9C9s\nBUQuMETX57IZgQIhAMnzaRjo2UHWufvhRuJ+BFiAg8hfYr0LE/Sy/ZBsZc38\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVGRolcNDF4MeCtCAPkYgLKZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDI2YTM5Ny0wN2U3LTRlYWUtYmZjYy02MzVlMmQ2YmUyOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR378Tkn+9nPTaghzhemTlTewayLKPlfxmoqwCEFrTg2b2n\n5GwKkLKf97CiM75qKoZ3JQsyBrgtQbFB2VgSMr7Po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURnckMKNvtP6uw8OoLRsRFaJg\nk3YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFApacu4Oc5L5sFCheITOP+KsnsFUWeTYNolSPuWIvegCIQDuAbHmH/7S\nKYYTV9Y1mzR2EmSQ4b/dqYzW3bRbb3hKvw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAeFZATqZvpsaVEL0J7/26HYiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNkZTJmMDgtMjQzMy00Y2U5LWIzY2YtMjFkOWU2YzRlZTE0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2UzZDgzYTYtN2QzMS00ZDJhLWE4MjktYWZhODdhYWUx\nZjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/mXdcD4/pBYfTrpy3rnuAyQ2\nN3LNDKeMtCF3DrEUNKrenJijIt8DIV2yooKN2BWvedeII2jG70HnNIw/BJN6YaOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRozL4QLJlnPcMqfV51uLbxceeJFzAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22FFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDRwAwRAIgbuwv4GsAQo+jjSHFPXPuomWsWrlU/ntuvEa0qDFu18sC\nIH9q3mzvKg52MuND5h85MzGkFFGbPFPlav3tb9TdNHp6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8831", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8831` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAfYcVwq0KEpgZbpEvGnSyomyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3NjQxNWUwLWI0MDEtNDIzNC1iMWExLWI2NTczNThhNzM3MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjE5ZGZjZjAtNzM5\nYS00NGFkLTk2MjQtNTM5ZjkwY2U4Yjc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtrIzfWDpIzoFukYOU/aaqknYEPgKPDWmxzMo5i6OIk+Nt9mQAjSXP9Mt4FfZ\nIHjO78qDbGh8jURyVlw9K+mwKKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUceVLIdU7zf+WJ7dJx2rcfoI51WkwHwYDVR0j\nBBgwFoAUhj+G1nbHHveNShQ/MDPno0quWx0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAcwSsxLnRLTCK7+wgVoymG/zpB2\nif/fETFrOIWIWsh6AiAHspVmFCD/t7CX7axbh9e2LgjGbCOj2bcrcGHBH3nA5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR2PL3lx0JS6cllIVQ4tdxx9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzY0MTVlMC1iNDAxLTQyMzQtYjFhMS1iNjU3MzU4YTczNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8KaePapDqiHWI8nmxnDLHmfei+kipjtM1xyNEFycx3bEn\noJD+lxkeM03qsv1NhpMsJJRFEzodRZ3bXbryilfto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhj+G1nbHHveNShQ/MDPno0qu\nWx0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgL9eRN/Mq8vbDdODpnJFHBKiOVdj6Cp9sFjKt+NtQPD8CIH2dbKr5jnXX\nqSYwKaaJVdGoP1CeYL9BN8SSZT6uNEtn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAT9tX55nPSMtVZf8SLOPHWtFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjE5ZGZjZjAtNzM5YS00NGFkLTk2MjQtNTM5ZjkwY2U4Yjc4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjZiMWZmNzQtOGEzMy00YWFjLTk5Y2UtMGQ4Yzg4ZTZi\nYWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH+Oovwvksbu9jrkeIV4isAlr\nq47rg7hIwhK0u1weH1zBgFjxNx6CD94S4QP9vLTUIuyYQwDj8uIzmjKaCb3CHqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRx5Ush1TvN/5Ynt0nHatx+gjnVaTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22FF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIDQfTA+4Uku3216viV6alhY74J4S9W+t2nuOcaAMHCN/\nAiEAsUfwrNL6jQHzFN4o+qH5XFoDGkJIvkDmF0o3kcqWVtA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8832", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8832` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISARg/uOAtExzjA0226f1lcJhxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzZmUyNDEzLTQ5NTYtNDAyYy1hNTQ4LWU4Zjg4YjQwNzhhZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWI5OTVhZTktMWM1\nYy00MDRhLTljODctZWVlNTI4YTIwZGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDYYeyoRo4t2lSfVtAjPcozR+VUbQDCnya+8Z5qoaMxEc43Oh03NWnYHvaNLX\n5HgJhbcf2gzmoQ7WtqiOwFrK7KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRW0suvB8l+0cY+eoEtAM7oHNA8/jAfBgNVHSME\nGDAWgBQmLhh6q3B+FNfK2D/3nsSUVBWktTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICUYen3YX6u/qvq/oaRpw7hnfYGo3xck\n6UzPON+FDwAvAiB3+4swL42AqS7KOlcVIMjhErPoGLJkhL5ZCeiWwB2TZg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQZf7BoO0BWoJ5DVQsks7eNhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2ZlMjQxMy00OTU2LTQwMmMtYTU0OC1lOGY4OGI0MDc4YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWaVYL/QB7+XQoD4fmfvqoig6Sb7Rlw/UaGQvr55q+y9uq\nGPtfBweHV1bG+Nx2FR9oyTG6qCFVcUZBRRPt4Mvzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJi4YeqtwfhTXytg/957ElFQV\npLUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMECyc7+sEL4GDAyddX+GvIMZ1m/6To8/JuN8QDcpujjAiB5fCuxFmc2\n9sKTbc+yRoW7UxDS4RMuNpTgZXDp++t/Cw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAS2dkrHrX6dt5rGuNVdx/ma0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWI5OTVhZTktMWM1Yy00MDRhLTljODctZWVlNTI4YTIwZGZiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjIxODdlMDktY2MxZC00MjQ5LThmZWQtYWU5NGQwMDFm\nOTQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHACyJTOVEZF7Wm3PE/7Qcnm8\nHCUJQCGUXIudpoptsnuQA/4S6qDDqRlxhJa+4qiw63Os/wgk9NMKJJfCWkCmyaOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRW0suvB8l+0cY+eoEtAM7oHNA8/jAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22FF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQCV3Dfg3CKiZE1rpNNhtAU4Vw3TzWOPhmsNfm64X/Wf\nigIhALsrDBPlk8pf3aZviT+ZTChiT2g7ivQ+MOr9j4gdKBHG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8833", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8833` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAagC0tvycZ1Gnsuiztd/WYg2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3Y2ZjNmQ5LTE1NDAtNDhiZC04NDcxLWM4Y2M3MDI5YzNiMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmE2ZWI0NGEtMmJh\nZC00MGZmLTk5MGQtZmVhYzBiY2MyZjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERyXU70epnrE8SPuCqM69l8PldWEEQVjlu9hHaXFRRLxJ0zbRum9/2Ei+wwhr\nqmS+KtLomHkEm3/CEsXuQRsFy6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo6IO4YeSrS7SLzqmpwV/aoCFKsgwHwYDVR0j\nBBgwFoAUquY02zWQ7eINab7twLNw0elf7yAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHbkipwBIK3RSI9T6JU4f6Bc8HaH\ncyBPCIUzujWrf70SAiEAse4PqhteEyFQrv6nZ9AvVOYYt0jaiqOo+jRFZZ+jaiI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdBvStIGq1Vpvpfc7bFt5yROMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2NmYzZkOS0xNTQwLTQ4YmQtODQ3MS1jOGNjNzAyOWMzYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRVyLq7x1jZuQN2UKvjy/ZuITWpNJLRt9xHvbj9Ys84Y57\nAsGcudThNqN+Vx9Ym85pR9hQ6u+2qsuaTOHTESrqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUquY02zWQ7eINab7twLNw0elf\n7yAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN4Hw6iCTaG7d9Jeh9JWaBOUAla6DGTEZa6CAy/WGA7pAiEAlueOaWXd\nmNj2xpE9FGkm3AYR9cmF+wZp77paiD+NLe0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAVQLfycae3pMlooImx1p3QQZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmE2ZWI0NGEtMmJhZC00MGZmLTk5MGQtZmVhYzBiY2MyZjBiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzczYzEwYWMtZWQ1MS00YmJlLTliNGYtYmVhMDQyMDQ2\nYTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3ZKUJT/eK06l0gTas+WXnZNn\nohonLLA29El31D3ulPsaV787sTvHloT2f0uFLzRYcwAarDMDLgPxTm7k+RFWR6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSjog7hh5KtLtIvOqanBX9qgIUqyDAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22FF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQCiLuaTewr7qRZ++iso7Qbns7qB74LwlTTG6OyMmvST\nGAIgdJ932mBOEHNJTMZCQM2+4ZFP2l9156f8kl6NkglYMSU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8834", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8834` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAd/RhMJ7yLUBM8ABJRxP4G/1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRmMmEyOTMyLTBmOTUtNGVhZS04YWY5LWRhNmJiMWI0YjhkZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU4MmJmMTAtZWZh\nMS00YWJhLWIxMjMtMDRlYzQ4OWJmMDY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdFHgbGU7kMk51hbWAQTg02eHXlrKhXG8KkFlJlia3nItASUZdIfphEp16rRr\nXTK4eRHDsRVPXwje9P4O//7Hl6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQtMe/uGZ5P+nPCnEbc+pJ790IiaDAfBgNVHSME\nGDAWgBQoNy6tWY+XUKIRhiYFx8Sp5RiSljAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFHJEJS2yM8oXzTs4xUvTl11m8UpHmLO\nMOKRaRE65H4uAiBNTSR886yd37ecLCU/JVwLeShI/TST4f1INu1tcSaUGg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbKsYgBh2L2di0dmBZGFPLmsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZjJhMjkzMi0wZjk1LTRlYWUtOGFmOS1kYTZiYjFiNGI4ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgVP/pcBapOvz439AO9AeQqwmZbulNxxREzE+MveWkb50M\nwydib8PcHRj6sF97GfaM35vYYu7UwKZK5YGckOCno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKDcurVmPl1CiEYYmBcfEqeUY\nkpYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKpOs/SExaBgVaxYSiR+rfQrrABK0gunweER/V79suIjAiAbSZLFVdCp\nYotcpzLioMl2ZGhcz5CwwIi43rBd2hFVjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAWumyfiQsF+z9bjnpYH1qdZKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU4MmJmMTAtZWZhMS00YWJhLWIxMjMtMDRlYzQ4OWJmMDY3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTcwMzI2MTAtNDZmMC00MzRmLTk3YmItNTBkZTVjZmJl\nMTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0JYMvexMRC+1p2U7JJMot0dq\nqvh4FBkFh0HO8RaK016lXCpASkc2+U9a1AWQMhM6TMLdOqYVindrwePcSyjnIqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQtMe/uGZ5P+nPCnEbc+pJ790IiaDAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22FF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQCjJ4oBC8/Tyr9pz79KUgB6S6SmrtcDmS201ixF/k3a\ntwIhAOh6mSlt7kCJCI19PRhlTijFdMd9lIPIZV2BvUzZ5x78\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8835", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8835` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUUu3BG9a1FUZlRTRVuxYZmTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllNmM0YzRkLTI3NGMtNGY0OC1iMWJkLTE0NGQ1ZGUwZTBmMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE5ODgwODEtYzU3\nZS00NTAzLTliZTgtYTU5YjljOTYzNDU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtjDAP1ge3FBLYQpuXpoCAEIRW4KzNYD3O/vov420AYJFAiNIaMyWDqo7x+qn\nuVADKsaSY5NrIFTqcxadXinmxqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJXtaYrH1MleOs8A+Fkj0W+DJVNbMB8GA1UdIwQY\nMBaAFLZryGJXQOtZbnUigsn1vJ0V+pMcMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAPQcKpNh5YEdej7rFQzgqJBz8NXq2PYK3e\n6htuZNQ/7QIhAPt+p9raCunsA856wgPONNk2Wo6Y1E9tLpf98/u8gYL3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATNVHyaUJkts9qtFViJ7LpU3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTZjNGM0ZC0yNzRjLTRmNDgtYjFiZC0xNDRkNWRlMGUwZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNfyPtL59Lt81grkQz+p8+yiPvklTijrOvKVnxB4JY22Yg\nf6ww28aia30wHtp1IzFLmkLtPpl93Eh3hGnBOP9Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtmvIYldA61ludSKCyfW8nRX6\nkxwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP0GqOPYZizDkkeE5zk5kGbhN478Ojz0h01e+2k6Ek19AiB47iXfYoTp\nz/WB+SCXYiCmXTiGS9r1LnkGGfFV2V3vHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDjCCAbWgAwIBAgISAWdsr04cEb52htG6u7cwuW3PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE5ODgwODEtYzU3ZS00NTAzLTliZTgtYTU5YjljOTYzNDU3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzAwYjYzZTEtMzYyMy00ZGRjLWFiNmItZjQ2ZjIyZTY0\nYTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/cmfmRWGr4nkDrLfOQxuRBXr\nZ/tCDBDoEfo4ZTCBA81h4yRXVOyhoe+byOEna1hwHb8p8tccdphp+GsBATMmQ6Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUle1pisfUyV46zwD4WSPRb4MlU1swFQYDVR0RBA4w\nDIcEAQEBAYUEfwAAATAKBggqhkjOPQQDAgNHADBEAiAPyo2Gc3smIk82ByJLI/+z\npb8J0+I5I5ysRykC4nRLCQIgGc2KKOFVNl8LLt6uLiqCERfykFeOrfDpmqXpUCG4\ny4k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8836", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8836` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfPJZ3QzN0TnG2MQUhZ1aLAPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc4YTExMDNmLTVlOWEtNDFlNS1iNjkyLWFjYjdmNjI4YWVjZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzE1Y2M3MjgtZTQ2\nMC00ZGY4LWFmN2EtNGI2OTE5ZjNhMWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWxCQT0Ma4hogbCeorCKs4Ai8asELR3AMiaxusF3HT+QVAIAqhI2eZWPmko+x\nVr0WoWtow5X1Ae82G4wPgau4fKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNk95TDb6HuuSLPDRiBOVURNzwBgMB8GA1UdIwQY\nMBaAFMv0IGgxWvgAEL8ff97fWAqomkhaMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBaPG4f7RHmhC8crjEMzugK9LXXNv0B1yVR\n0toiOBc/ywIhAJIlzxRzt3LBxSLlMCP/fystQuPhIKOBBYw1OVYUsDgt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd69Kvw6jgwRmJHhvd8XhrAbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nOGExMTAzZi01ZTlhLTQxZTUtYjY5Mi1hY2I3ZjYyOGFlY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9UJmxLco+HwurA8R/BT5h+NJCb0GFkfkCupXCzhJvGRLW\n5YB3wmPG6IKoLTIKqrOfKrIdgn3uXbbx/3HBoXVwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy/QgaDFa+AAQvx9/3t9YCqia\nSFowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM1Z9QPdEGilgeNhW2aoAmeRNk7FS3ddjHHmMkCACPNYAiB+xFvGwe61\nrcZ6sTxyugh0/73WaswJxWJC/eY1lHyoSg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAe7hVblpI48DByL5I/AfGEMBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzE1Y2M3MjgtZTQ2MC00ZGY4LWFmN2EtNGI2OTE5ZjNhMWZkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjMxMGNhMTMtOWNkZi00YTFmLTgzZTMtZGQyNTVlYjEz\nNTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQ1B0H39YeF/9/P7lVnkMNDHQ\nLCvdFFDiuVNv5FVxYcLRsroQw3ckhiqEbLXMI4EJasrjB5Yytpy+/UY31pUhMqNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2T3lMNvoe65Is8NGIE5VRE3PAGAwFQYDVR0RBA4w\nDIcEAQEBAYUEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAgt/9xzRJec7NwDCmG+co\nJ20z8VVC33lAZt3JPAzlsdECIECgK9PRa60IqWSp/2j0LpVzez66ckdn4/Dxf63m\n2ZLV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8837", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8837` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAaqOHuGczaQhb+wiEBHh+W+yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxMzhlYjA4LTYyNDktNDZmMS04MDIwLTYyODI1ODFhYTcwNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWUzMGE2NWMtNWE0\nYi00YWI4LThiOGEtNzQyZTI5MmI3ZDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKULFcTCYDQpcbG0YMhCmtKSvByqAKNpgXJ6YVdZEN3G1z2hJx3Fr7jTX5H0v\nQiZYPQDbsgXagjTjd7WG8LCxtaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNzPdRymzjmw9HTToxetDsax/EluMB8GA1UdIwQY\nMBaAFMsHTRcC2kOi/RJTwog3Bf7LUyVlMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAgVSfDU+xOcsEbSE+Sa5313SxNr7SQId4\ne31PvUYEqFACIQDa83OvebWet37U+loLkin2SMqbc12u+nJ2n/cvGgEs1Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXJfpBik+YU0/A32a7XQViOaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTM4ZWIwOC02MjQ5LTQ2ZjEtODAyMC02MjgyNTgxYWE3MDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR56qf7U+4D7HLHgE/4OGseGXq5zu6tB6O1zkfZSP8bCNjY\nsuMaK+iwb/uZaUJBq5CKu1GX0Nf91wRwATNP+NXBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUywdNFwLaQ6L9ElPCiDcF/stT\nJWUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgN7cW3lFKTwQCx1yruaOoQd8IH57zOajGolRyEQF6Nb8CIEb3YsN98mmC\nBVLrpYSTTJ7N/12kTYpHb5uYAbqhSAd+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAUIYKiDV4DlVH9802VKjuflaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWUzMGE2NWMtNWE0Yi00YWI4LThiOGEtNzQyZTI5MmI3ZDIwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjVkZjA5ZTktMmU3Ni00OGVkLWI1NmMtODZjM2MzYzQy\nMzA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7O7ydIhI1VnVm0smEPTOKMPQ\nEXqwkT8Vz2NaRigDXHqqgp9nT9oCKdih6OHHnxRJLGVIU1hC0oQGvaR7DhiCYaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU3M91HKbOObD0dNOjF60OxrH8SW4wGgYDVR0RBBMw\nEYcEAQEBAYUJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCIBivw52oUvR5gXwc\n3qCpAg1US9My5JetIlHhgepUdX8nAiAFahF+5FJ5Ax7RJjGDSqi4VB8QdSk6ILG6\nrR8cXgVAMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8838", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8838` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAb2fuOumYrAZKrJkDJ0PwlJoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MTkyNTQ1LWFmNzctNDg2Yi05NjBkLTE2NWJlMDE5NWE3NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNkOWU2YjktZDgw\nNy00MzRkLWJiZGMtNzQ4N2IxMTY5NWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUJUb1w++HUdsbU0uxE6WvPlFeoB61HKy9Bwztn0fcbInho3TU5mJVZoRRK2k\nUI9wCzZCTr/5uvco2/ur7wz8UKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGS1ArKN7tUHTtfXzS9pQmrC6T4+MB8GA1UdIwQY\nMBaAFGmrqVBMiLrgt/twv+w50mRYJgCXMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiA7Aa1SaXsDWL/IX8VnJaM6MHVF/NxewORQ\nO0X4nCJr3QIgTLrRrolUu2/Vq4TYWXovWunGbB1tTIxM3PKnoornhqc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAapuJ0LMFPNVZxZJoNFrI3/2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTE5MjU0NS1hZjc3LTQ4NmItOTYwZC0xNjViZTAxOTVhNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjhgC7PaBaPBtIEgC++b1k8SCDrBR9BrilAiGVUWmX4wKz\nT8z8VLtHxPRvcgDjVUDGQEVrg9W7pDOt2NXfQtnXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaaupUEyIuuC3+3C/7DnSZFgm\nAJcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOrjuFxIIkwpuekFVNROp919/g0iyhXqEiAzZhqk/bwWAiEA59bZO63H\ne8vCHsyDzGLKG2eUZvjA4lZwzBVbMTh6RlM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQTfirybyOA8ZZFivfC+wxRdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNkOWU2YjktZDgwNy00MzRkLWJiZGMtNzQ4N2IxMTY5NWMwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDEwMDYwYTEtZWEwZS00OTk1LWI2ZTEtYTcxOTQ2ZmI5\nMDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/0HwlUiuP3upux357U0XP4jS\n7oP4qJksazvPRsOqGJCXzElbLLc5/Dp3pmGrP3VsfXLSJPotfS2vDCZI2nTRjqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUZLUCso3u1QdO19fNL2lCasLpPj4wGgYDVR0RBBMw\nEYcEAQEBAYUJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIQC2AW+gOi5cbexe\n7C7iXPpLK26qx++UXBx1REn3YN+4rgIgWc2+Xdkp8QxS1huBgdWfFHP9RUn/yzm9\ndjps+aY+b28=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8839", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8839` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdNBUJIErL1yzsyBw1fwjROyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhMWFjZjQ5LTM5YjQtNDI2Mi05MmM3LTlkNmQxYzE1MDIyNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDlmMmQ0NzQtODU2\nYi00MjlkLTk1ODYtYmM3MTYwMmIxZmRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEafYgwKB+WNBDgbtiav6440Btfb4FzlcWM7q7b7o3geeqpArWRmQVlHo4M9zn\nMI8X210frVSuda0RH0c5YzKroqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTedxnoT2i2G+a139RaNa1o6U0EMwHwYDVR0j\nBBgwFoAUbqaXhu8b7sHSx0iODZqp//hfl/0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC614qDef/eUUMCGxbKAjdXWRFp\nHVigZS2FyQG8Rf3YWgIgVzhhxDgyQ9IhUlNkYfZ7aIr0D+LfS7dpzegvkDrdiqs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXKXO2Dz3bXf8HnESr8VKw01MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYTFhY2Y0OS0zOWI0LTQyNjItOTJjNy05ZDZkMWMxNTAyMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROzTQzt3Q9/IPebsAJAA68RV3I8pCXvFJ/bAp6AHN9CyKe\nvaHpLeBkXZzkKXhfgfQ1TNIZfKPVTuQMLJZGVUl/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbqaXhu8b7sHSx0iODZqp//hf\nl/0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgToQHSdEtWpBwxFVACZu92uUW46LQkG+zNh3t/AxBpy0CICpuzdtE7K8i\nECIRvL0eGguhqdZyuD2/XJRNTPyglOFK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAekcIaQjHYpxaaeAoLDWmxNuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDlmMmQ0NzQtODU2Yi00MjlkLTk1ODYtYmM3MTYwMmIxZmRiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODdkYWQ0YmMtYmU5Ni00ZjJmLWIwNjAtMDgyMGEyODNk\nMWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsIpNxdsrQ/en+TgtOLdlT1+e\nJDHwR+XAIx50u+8OVtfL77kyXgRy/mTElNW9S47UGg5277gTd9Q4OALYp7cl/aOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRN53GehPaLYb5rXf1Fo1rWjpTQQzAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22GDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCrGzlOgslMehzs3/2PBx/a8BIEfSApQKk9xDoPphm5WgIgB7ZBCfxY\nlsi5Je9WqWjvKfLJoDcMF4XBuSuEFYCI90s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8840", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8840` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZyhMP+wrSsEGbgEwMjtJ97qMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllZDk2OGFkLWY5MmItNGYwZC1iZWU2LWJiNDBkZDI5YzlkMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZkODA5OTItZmNm\nNS00MDQ0LTgxMjctYzUwMDYzNDljYjhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW3KjQubhVtV0IjYpMAK/MoBv+ohSazeyGdSQKME3Thk0PP2uqZ827ExIfjcn\nU5lB/fddQHSToK/ISS5O4iyzKKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT/uy3pSfQXfAH4Jed2nI/hVq3kezAfBgNVHSME\nGDAWgBQtKfCIC5IkkFNyDSQDXLO83ZH0ATAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDP3vKxJZDrhEGBeaB4M6X0s8K6U9qK\nKO3wd9vu6XAOagIgesgFo8x2phCwc2RuQdg/VoS0ckqGCgaruPstUR3wyeY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASGnGZtz4+F3z6/I4h4r1yb6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZWQ5NjhhZC1mOTJiLTRmMGQtYmVlNi1iYjQwZGQyOWM5ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5a2OlZBpcbth5bJCSEJ2ciDIc5rgM+E7jDvGAFzxe0n0y\niGkOrLt+N0sBIDg6WM3KQx99Yx6Lb5xfqIopan7Io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULSnwiAuSJJBTcg0kA1yzvN2R\n9AEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO6OW+I0ap12qP5L5GAeLHfNc/lHJHic7hfWSaw1YkjMAiEAhatSnz18\nl80SAhXoiNZwZ9goFCEjss8Z3JMICjlTOIk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAeRR7/LRpoY5OOi5C2WccybHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZkODA5OTItZmNmNS00MDQ0LTgxMjctYzUwMDYzNDljYjhkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZThiZjNhZWYtY2QyYS00MzcwLTg0ZWYtMjM5YzYyNGE5\nZTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2xi2wxKN8M5Orhjjz8T0dWTs\nxoW5T5AvlBzFYFJ5cIGOqhs92OJ2oMwuEYyYqxhkPtHZLBddRWzH3nt4jopi8aOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT/uy3pSfQXfAH4Jed2nI/hVq3kezAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22GDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIAX8yGk+HFXG/XNJux0+/fg43nKVhsULxFSOR/ukGutYAiAQw0TaLtUR\nxM4iyn4GHDW/tlwhAqZnfcekVYn5bGPmiw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8841", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8841` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWw1W5s3RbdIyfNwVBlSTicyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3NzJlNDdmLWY3NDgtNGMyZC1hMzZmLTA2ZmUyNzY1YWY5MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUwMGYxNjYtNTBl\nYS00MDUwLTk5OGItNDZiOTdmODkwOTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJGLefBpTxGNKu7KhwwI+mtQN6+kWh9Lf/m46eFUIPkWAWmMvF88uA58YVNJg\nMY6cBhTSNHCAlyZgb6mfYZaaFaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaHA8ZLkHgBPTulQubOTp0c1iiSYwHwYDVR0j\nBBgwFoAUGFkUVfYjmzImL/Tyhen6wZZhJWYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD5iCC7Y8pBCvwsY1JtqFNmByx6\ne66V4mfwNnAWECb4AQIgReEC3vC1K0/83uM/GT1FUr1wt+S0AUt+vipabb7F1zk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe3kPLtFad0cgXY7MEjz2/XIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNzcyZTQ3Zi1mNzQ4LTRjMmQtYTM2Zi0wNmZlMjc2NWFmOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCz2DyAW0qzTk7ra95hQbNx55QP1slV49vefnjpggAwm8I\n710mAEfmY1IRSSn389gigAbm7OEK5CkYfb0EGkiRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGFkUVfYjmzImL/Tyhen6wZZh\nJWYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXUSQeJSBw0oj/6dDb6fnKNukuABI0XKWDeSvrU5jLqQCIQCeSCas4P8U\n2OGB2GsvirbV3YG+WdhHIh4NVqqjHoXA/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAXmk1xKzbwCKe4O6+Yuoe9RNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUwMGYxNjYtNTBlYS00MDUwLTk5OGItNDZiOTdmODkwOTY2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDNmYjc2YzktMjQwZS00OTM1LWE0ZGMtNzlkOWQ4ZjM4\nNGQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvgjZFpIz1JJ7sH3L6MMO+uN8\nxUiU3zwu5mMk7pNsZ0lnYUAhcs5oxEgXPjcJOj5mJIew0heZClbdh0MNNVCffKOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRocDxkuQeAE9O6VC5s5OnRzWKJJjAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22GFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiB6URe4cSpEwHmRLlJjw19Zb7JLoJ1rV+R1pnPy1g8VIwIg\nA5f6bHiGzot8vZsZbqS9Z1/3im0YQmiyCMimZJ5qPA8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8842", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8842` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISASufFMWb7+LB9A3q9WXXVyieMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2N2I2OTIzLWMyMTktNDgwMC1iMWEzLTZjMzZjNjljMGZhOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDA0ZDUzNzYtNTQy\nZi00OGRmLTk1NzQtYWEwYzA5YmVlZWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERCuSmsHvuuTWWg3xXjKr9OCNH6p/uJBTFyR0GFhuskcYc0xoAKRPsYmFx1wC\nfFqcpb3LD87zPNwWd5zJPG0lPaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRjr3s0ObkTjHcR21KHY8PJnTbmazAfBgNVHSME\nGDAWgBSHICq4k9m8gYjJrkl8PiVfWMV3WjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCSezpmFfaM1m5LlaDd6JoWu+A50BFb\n5LCNvTY0LPhNAQIhAKFDDnThEt5vd3MEbmpGHfbq2V7WlJZOvMuHDvBgiAyJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUHZzozkTqU+gkuCs6IP2YocMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjdiNjkyMy1jMjE5LTQ4MDAtYjFhMy02YzM2YzY5YzBmYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS89kGWOUzTDaNKfYpnQMBiRLAWWHySX8/tHJwkg63Jj0W9\n0PFOcJ+bQb7Zk1/NzYiEUcxwJMgws545Tn5Cpp3Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhyAquJPZvIGIya5JfD4lX1jF\nd1owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPJTsQdVFWGs4IvuwUWCHyLfLlZbp7ERWNdbmLu9oFVGAiBrAL9OdAc4\nuiEYoJALOXoUdrbzknCD1szzCtgrL1KrUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAQMkvp0Khx8fmRwpu/E4J4qDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDA0ZDUzNzYtNTQyZi00OGRmLTk1NzQtYWEwYzA5YmVlZWM5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODg4ODNmZWUtNGI4Ny00NGU1LThlN2EtN2I0Y2U2NTA5\nMDk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELicrzRIAsdEuRLlIPpdwugU0\nDgRTkwLDt0xvk57IG7QuHBiGr9H3DDhUd4LyI5PGQ96Avq3+IB+IE7nm3lNwpqOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRjr3s0ObkTjHcR21KHY8PJnTbmazAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22GFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAiJcc6F+T/ECMw0Cnw7b69TnK5YXr0wbyVK8qe7/z7DIC\nIQCN5uNVsRKhY6tqDZ7UPO/pByBNJBkRVBlmkPJWAKRMmw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8843", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8843` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAWLTiK1T6BxvwpojSCwXccPjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkMTMzMGYzLWFkMWUtNGJkYi05ZTUzLTQ5ODVjODM2YmM2ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDhmNzE5YWYtMzlm\nNC00NTg2LThlMTItZjMwZjRkZmY4ZDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDItfbBGtkVUrpRC33Pz2yqhQsr2T30a/6MsLe5ACZh4bJayhdYiqlzWr7TEm\nZqHJ355Z3o2f1JytfcTGU2VbmaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw9yK8bYyX0aEIzkcJ2V3+fcI4JwwHwYDVR0j\nBBgwFoAU0U3aYBI22/o8LS0l8GfYoHIwjfowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEUd2xlLuwz1YAoMJTmRgFm3+rxC\ndvOOkbO+QoAlSc4HAiAlAD/L32E0gYLKMBV7iEhBNXIPmoGr5cs6qyB1BimQ0w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVgOWlB25NDScndm4mNUiKPaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDEzMzBmMy1hZDFlLTRiZGItOWU1My00OTg1YzgzNmJjNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/SZaFX/qF1f/JHcP1/SDvgcoBjpCe7DA0JsoyGcieKQR5\nEbfwzD+zpumC83AgH9YQeFDiLX8+IBWXad8whOnYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0U3aYBI22/o8LS0l8GfYoHIw\njfowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJSBVnsF6Xdy5DcCY7JALu0DqhYz9GvO76UB0s1xMwqDAiEAv2BC37rX\nZr/J7OV1mvw9+2Ict8kx+qb0VUBbWNqWCWw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAcUuvQcglTdRTbCie7rJeH1rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDhmNzE5YWYtMzlmNC00NTg2LThlMTItZjMwZjRkZmY4ZDBhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmM3OGMxMGEtZDgyMy00MjZhLWI1OTktNzU5MGZkZjI5\nMjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn9Kn1i0JdGvZXf3o7cNwqnJC\n/75O+ptVfDgo2ndH7cBOEuw1hmo7HUEGlBta6hfqrjkEcWboA8ahHxUBrjZYHqOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTD3IrxtjJfRoQjORwnZXf59wjgnDAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22GFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSQAwRgIhAN0jzssQgwPiHHbj1n52p2cuEQXpBJodMYvvUUmJay4q\nAiEAg90xVJc1ieOp38XoZxijWym7VPCeo24wXePxMMCVpWE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8844", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8844` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASTGp47d38SlMZog9D416mupMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5NGRlMmY2LTlkOWYtNDAyNy1hYWZjLTY1YWExYWJiMWE1YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA5MmUzZjUtYmU4\nYy00NjE4LTlhZDItMzllMjg5OGNlZjkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI78WBa7TUlLT428YUlXJbRWYh4rjXLPSuz/r9mVdAR8dWrtu4MuBe2a7Sedx\nJkzF6CGVj8Hfv9IpdtiR+IBNIaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRWlDMUap3noJ2kKwYkVwVfZO8rTjAfBgNVHSME\nGDAWgBRCdFYHvHi54wPbNlzS5Xq0knQS/TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDyVeHoQC0P/Ojd7VBhJXU9p0CHrzZFq\nL7dsK1tDCmmnAiEA9ebGwuiv1c/BfIhgCVrzkpKid3p210CRMrfiZ0/a3Ao=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASO2z9rj89a2YqbiG9by921qMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTRkZTJmNi05ZDlmLTQwMjctYWFmYy02NWFhMWFiYjFhNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8+eVk5/5Rq8dU95Tl9blCGNh233ljmSZnYVsB2Uvji3bX\n/eHhUOWvGOBzvVvXzYKkA8DPeGeirdSQOmx9cuN8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQnRWB7x4ueMD2zZc0uV6tJJ0\nEv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANl1DUElIPIRRDuXvhwZiD5VRAFnQ4HJH/34BSS2EL9MAiEAoYspKp5W\nsSQEls8RF+mUnhz6yd1wgkXarKEkgD96JGM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfbGuKJkjVNLI9d/aXqhBtbQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA5MmUzZjUtYmU4Yy00NjE4LTlhZDItMzllMjg5OGNlZjkwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzc4ZmJkYmItMWNkNC00YTU2LWJhNmMtOTE2YmI2NTZj\nODc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5z6TUPs0hr67i/F1JqBJlCKF\nMBV86k763llAq6SgHv2rSWJgSETUrlLDDn2c9KOCluIM/feDh/pE2FeCoqTG/aOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRWlDMUap3noJ2kKwYkVwVfZO8rTjAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22GFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhAP1Qm2NJF8Emjq7s8dhjuXxsysTINohPq4MN9IWBA9XV\nAiBsfFM95WYM8pgTkQ/LmIrx7eS8xLFryTcbdjrFwMxRPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8845", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8845` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAY3gqry31fJzESAbDhivPXWjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViNzk4ZTZiLTBmNDItNDgxZS1hYmRiLWVkOTYzMTNmNTcwYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVlNTAwMmYtNTVh\nMC00OTU1LTljZjctOTlhOGZiOGZlMDlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4uT+ihALQZRQK8TdQ5cahlhBNdM+sYvWtZ5Ac6JuST9jNliBTNMHZnQ3mSV1\nrJ84LafYu8Pg4p3WUTk4dNpVwKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZZPGfavBSPXBrWiDTxiEjcX7Cm4wHwYDVR0j\nBBgwFoAUqyvqz1uUPdQNcMxrVgA54662Gn4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBhxeJPLiXG4DqhjCveAZwY0YqAI\nxaB5cAeJ4dz/wNgTAiAfhiC2/7eVmaCv3hx2YRlqtdlTFIfo54Gtg7DlLzI0rA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY0rUBAfUQWiJG0hd3jnhZDjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYjc5OGU2Yi0wZjQyLTQ4MWUtYWJkYi1lZDk2MzEzZjU3MGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiKBjM+6Oi0ty/vqanmQdFVvb9oElHEMSrmNP79srh6QJ3\ntStsGdzeQ5EQd0le0P+Nvrg/6BAYhvi1ZngwztRco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqyvqz1uUPdQNcMxrVgA54662\nGn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSqHER/VcWNA0rgEpQ+tUsZbGpc1Rtw5uxE6Pc9NEsHoCIQDWmJtNUuIf\nE6OlviF8N8eySPoF4zQNlul0s1b9mufXmQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISASKdSTVmxU9Ezu4d/7KrTj4uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVlNTAwMmYtNTVhMC00OTU1LTljZjctOTlhOGZiOGZlMDlmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjk5ZmNkOWQtNjdiZi00ODAxLWJjOTEtODY2YTYzMzlh\nZDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvmebHg4hVA1uQr44L3gwm1gW\nClAKe7zcw/fTQL0mbjApcuyHVj+gaf0n97MKwYYkdrSPWh3ufjSyIO+kRfyrOqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRlk8Z9q8FI9cGtaINPGISNxfsKbjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22GF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIBi/ycEjDaPF+fUt7EmAnbMvQIIj+eUJFEf3hQgkeID0\nAiA/nicn+5x6X9xLK59u6KXc9hvRLFB0oakokcsKiMYvHQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8846", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8846` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAfcLsov4vxDiD8+D0QotK73yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNDEzYTY3LTJlNzAtNGIxOC05NTUwLWFkYjk3OTUzMmU5NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY5MWM1ODgtYmEz\nMy00MGY5LTk4MTMtNzg3MzExYjBkZmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2QRQJNw+II9Y3QkukxL5LV1EPlnVeVpov6GSSzXtGSeO43Ydmk1oyfZl3b+i\n31yxGYJLONqyuzkOebC/tQCHJ6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTbVHv35MmEfYVvCEDbmE5SKjuNDTAfBgNVHSME\nGDAWgBSWzcrf3y/UihGz1F9s6MkZ5Iy+izAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCcGNZRk9VVP/eJUwaAQjH2rDR9a3fo\nBQyhpTpy1VKDlgIgGylZRd7mZrE/m902dH4tyleA2ylq2uWIpVfCnX3De80=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcmJwomtpLHKpMYoiph6JbUlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjQxM2E2Ny0yZTcwLTRiMTgtOTU1MC1hZGI5Nzk1MzJlOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQLUvkrd4U2lVXe9/9UhUZ/VeGmNZZe6QmPIDru3Lg1gcw\nD2GzPz+TAQuvybg9Xr8jKuM0lWPJINV00PwafX0Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUls3K398v1IoRs9RfbOjJGeSM\nvoswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIMjIXgkIvWYtJuHF3O8YJCzLDrjQxHCH8sVo4IPTMXYAiAFMQgWAE/B\n+12KtwzxhWucHMBLvvneYPoNJgNMunh7vg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAarsWgPHn8Xa5wLoKGWzmV8BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY5MWM1ODgtYmEzMy00MGY5LTk4MTMtNzg3MzExYjBkZmQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGJmOWRlZGMtNjM1ZC00ZmY5LWI1MjktZDA3NWY5NjBm\nOGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnLRrsPuDUuKXUV/AyGOc987R\n/TnNwfDogpXMzW3fDGzEvtMMVSwmTGgXK+UT3eRnChkbI0k842H6qAfngTOiHaOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTbVHv35MmEfYVvCEDbmE5SKjuNDTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22GF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIB51MlEVYFXOl+SL/LwsIX1tg/Nw6z7Yxooz9QbU8Rbf\nAiEAigW5crQX+/X+ljk5/cv4xQ9bQ2nK9m9LXpPkgBi+ZdY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8847", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8847` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAW6Fe2spTlSdtxfV65vlenD4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyNDUwNWJhLWI4ZWQtNGJlZi05NzNmLWVkYWY1NDM3ZDRmMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjBhNzA5OTYtN2Mz\nZi00NjEyLWFlZDAtMDNhYWM2MmE3MmZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/TKRVI/gS8gjm/iBKAq/tyaaAamZQYCrhHelHidJA/+xp/zpkMqaetQZ4uJN\nIlCG5SeCZjWd9IlTdpP4UMiU2qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7BwlP+6i3+DaDsfGSLAAtyi6reAwHwYDVR0j\nBBgwFoAUlu+3I3lrjwb0kn6KgH6T0XbKFeEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCrfXEhUlppQQ2H1X1FDJJQnMJo\nj2kwDP1KYXYmMrKALgIhAL8xlE2pQxdIagq+ZjP4//7SMuVpijJYIPxaOkiuoiXL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQQrL8UpdBOMNCQDhMoP2YriMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjQ1MDViYS1iOGVkLTRiZWYtOTczZi1lZGFmNTQzN2Q0ZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS52Hj+Kwt716tlK0CTOPKxBoIXOxxNPvUlvxQa811VUB2A\nhtjnZeb0ujxgntBi8OxwpXg2lZCEHi/IMNroyex/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlu+3I3lrjwb0kn6KgH6T0XbK\nFeEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMkmNLmOTw8RknLiqV8462iTZJYst44oQ3cJcFNSaPU/AiEAtoEoBaP6\nxBSuiDDuYo0hfwNKIgKzM0xMDxWE73bFEyk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAYTKs/HvJq4OdQGmqNJcHuWLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjBhNzA5OTYtN2MzZi00NjEyLWFlZDAtMDNhYWM2MmE3MmZhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjZlZTVjZDMtYzk0MC00MjA0LWI5MWItZjYzY2QyMmM1\nZWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3BbyeZeaP9bsv6QVt+KmC2QU\nyA1Byoc4vBtqVL8PqF5osO2V3ApNyEYfcFMHDAGgqRf/6FJEBQPUUZy95CiPn6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTsHCU/7qLf4NoOx8ZIsAC3KLqt4DAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22GF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQD1hry6QcTUUPC8Up0m0lBGY34drM+8lFAGOSO5vNSH\nvQIhAPKUqBICuUcpbZpNvfFT9h5CmfHI/FmjKZWmFUDE7zYp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8848", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8848` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAf0Xj8fRl+9k591osoOMf27UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2ZTVhNzA4LWJmMzUtNDc2YS04MjllLTgyNzJlODJjNGE5ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg2N2UwODAtODRi\nMi00NDkxLTlhMjUtMTUwNWVkZjAxZjllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE09fkOrvUFOVszg+T7E5U1bGuRU4Amum7xAVqZV5y4RN29eD1WPkpRK7MQ4Au\nleSWEfLl0RyTGuNU5dOsv4O/o6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQkqX9stso6YDiPMVr++rqK5mqQPjAfBgNVHSME\nGDAWgBQA+n2HOumIXHgQUcYMCaMp33pdEzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDG3v1yiZi8R/2J7okJUTCr4DeJ1G9F\n0gvmxL6s4hEQcgIhAPGJimvAxvDvXbY42eSsQhBvIgTWyLgoozwaVf2IwKZt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUBWXxeQCUv+cN+n7e06ZqFUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmU1YTcwOC1iZjM1LTQ3NmEtODI5ZS04MjcyZTgyYzRhOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ51iUV3ePurklNxdI4z8WbS79/ODC17jB3ggNOs6/T/cPM\nluAL3FfwdLknKT1A8FGblbO8NTTWCLbbaLbzGWxFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAPp9hzrpiFx4EFHGDAmjKd96\nXRMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANB1q9yf0ti+8VGhZ5J1o7ZdmJLBbb1ZHvtpM0lQ7hNnAiBiShCB6R5/\nA7pXF6bUeuhAheopjKjtWQdL3IpfaERvug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAWpanui7rTGyw92YNfWomWxMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg2N2UwODAtODRiMi00NDkxLTlhMjUtMTUwNWVkZjAxZjllMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGFjNmE3ZjQtNjZmYy00ZDVkLTliMDctN2UxNGRhYjcy\nMzkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjJTvcCpfEfcBumanoOyVxJe3\n+TcTftggLmqp6zjrVvGeM3S0+iWtgj6x0n/dN3/J43ZLtsU3N9jY53BcxlrxxqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQkqX9stso6YDiPMVr++rqK5mqQPjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22GF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQCOPGwTCZ1D2UQ980rFONmduuzZshmng08Fl2OPEZJw\nDwIhAK9mhjqxmDy3xgUTNH42TAocP2XlfFVI85bGz8iumqr1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8849", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8849` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZN8yEvWzb51SuiMcnZ5jdfAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3YmQ5YzhjLWVhNjEtNGNlZS04NTA4LTQyY2JiYmFiMjViNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE0Njk3NGEtMDNk\nOC00NDQ5LThlZTgtOGZmNTA3MmM4YTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp2wz7G2L72o58T7sUuqtrwDjs3DFSfkW6CnwQyewZW7WhSPNjQPHiCsUi+2H\nwErYgD8hdkHDJkk+T0rd/5D+0aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJeDmfN5PzRn0Ed+I/0zgaecBCC6MB8GA1UdIwQY\nMBaAFGWsOrHej8gDe02bxKFntVtKCGg7MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA3GDhEYDhWupXRYCD0Znb1bMJ3q7RkMJS\nX9Z5m1NnCgQCIEmRjDcTXzQn5UR48M917byAn49cOLRHmso9EGW/m/Uq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQcm/7uO/MTAfl7A4KnCIdQCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2JkOWM4Yy1lYTYxLTRjZWUtODUwOC00MmNiYmJhYjI1YjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTfeQGOn+G7GzuQsBfOLOj/1ahtULyIkVODFbqI7+8QLvr\nFjngGVSZ9OFLRusYhCsjq2H3HBbTdqAOw770XeLqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZaw6sd6PyAN7TZvEoWe1W0oI\naDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPfQwqDdZZpdfDfb5i2wONZej8xkn2kBalQkff4oxxbYAiEA7iUOa2Bx\nwMuMtnG6zVs4Aa8KiE/NTCDq9MNch4bfuCc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISASk/fzUaWwwVw8E0Mzd9ge7mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE0Njk3NGEtMDNkOC00NDQ5LThlZTgtOGZmNTA3MmM4YTViMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDFkNTUyNDYtOWQzZC00ZWIwLWFiYmMtNTJjZTQ4NDEy\nYThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvQPJRqTCRqOxGD9kzp4CBca2\n76ZFqkM+GN9m87MBpgPzL+ejMbn0HUZfnsfWrIqprCkGdvsiWH7onGe1m1Jfz6Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUl4OZ83k/NGfQR34j/TOBp5wEILowFQYDVR0RBA4w\nDIcEAQEBAYYEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA1tGaIfX/ZnZAnXXyuXJF\nnh3ljNnJDI/Dw4At5Fvdab8CIQCCKqCFgtW3Lc4vHssqckROUmk4k51Bp35V83kg\nZGjz/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8850", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8850` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISASrvBxgtvuZDxjcaSAQZVl1YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0ZDdjMzVkLWJlMDktNGNjYS04ZmRjLTE1OTliZWRhOTZlYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmNkNjZjNmEtN2Uz\nMi00MDI2LWJlNDctNDc3NjUzYTE0NjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBX43mRXYnBlNJNUwHcpMr5xUeFhB4TvOcs7X7FncS98XEz0So62mdDNZ1wNC\nFzsEdowQLSm8HmgV9bmEcUneL6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFAX6p9z81Axye5HCyE7hG1pkaBlfMB8GA1UdIwQY\nMBaAFCv/YDqcvxOQr/o9n8Sv42qgftRGMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiACzKk17MITm0yZMgf/Wo7OqYTLwAUBzMJZ\nwqL52cIu7QIgFmLY8Oht/oNluLDvaKsTNw3gLJfnmLg0fqZlux2YOZc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfaP7ZWb7qEm8Lk5myK6fkuwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGQ3YzM1ZC1iZTA5LTRjY2EtOGZkYy0xNTk5YmVkYTk2ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQffmRNg4PVQ58QNPBlB+6JpwlR9rA2qdOUu09TC3JyO7U4\ngFMoKhJopUDLBPgbUEETPWaeczKpvYC10rFMZ52io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK/9gOpy/E5Cv+j2fxK/jaqB+\n1EYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMn/6REtr37ks4wovOUk3kcl2hAM94TFyOzJ/2iWxRDxAiBG4g0Krozy\nvYFGsSt4W3s3+2Pg8+LJKLX2lAr++3PhMA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAXl0D1BJ5wxIXdAJKcpVTMzoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmNkNjZjNmEtN2UzMi00MDI2LWJlNDctNDc3NjUzYTE0NjRiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjk4YTNjZjctODJlNi00MWFjLTk3N2UtYmU3YzY4OTlm\nOWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy9rtpyKyeNM61hGYsWr25RTD\nOCjNBmL3yTg7jOWoDrJldJdJjBhNS6LGFsidu7GQ+xt6faAASoPk2RjnyPevyqNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUBfqn3PzUDHJ7kcLITuEbWmRoGV8wFQYDVR0RBA4w\nDIcEAQEBAYYEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA32iYkiGEVyuW34xlMJvY\n55LjtwBeFYyFNFFZPP8W44MCIQCg+wiNJ4eXVBIQOdyfNba/yt6vHegYyxiVxZXi\ns8JD2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8851", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8851` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATzPdJ8zTQc4lyF02VkLjVbIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmM2EyZDRiLWMxYWItNDQ0NS1iNWUyLTIwOTIzYWI3NTk1YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM0ZThlZTMtY2U1\nNi00MjBmLTgyNTItMzBiOTEwNzBjZGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4X5yGWNiCie/7Ies9SSv1sUyggK2y6onW6e6s0G0aj4/vnb7ty1SgN0z5nYp\n8zGhyAKG2DQUxU+GnUoJxehch6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFF2tYWseHddgbI89xIkugy/W8CjcMB8GA1UdIwQY\nMBaAFIHtdJCjQgpn11y69PY8zK4sDjncMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBtboouEQulkmRjLsNxYdGrhNmVmNVqcXog\n3GOnIrNpZAIhAJiJjfyE+V3sb89bXK/eT71p1nVr4/PlAKBM1oEbz96J\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUGeG+38SXhyciQKsqSuf+5uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjNhMmQ0Yi1jMWFiLTQ0NDUtYjVlMi0yMDkyM2FiNzU5NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6E7RxWvb2LIYKtc1QNxJQMeRCtL7MYBKjB6pGjthDGmp5\n9N1Rlz0/gHJlYfzVSRZlMgF5FJn58cYWRZn6hnS8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUge10kKNCCmfXXLr09jzMriwO\nOdwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLnnPKvzScAATTOtjaDkc8pGjwa8YatwvVs3O8+qIKjcCIQDw7imU03oG\nkYS0c0ZIY+bCRvhsQd7zjqpBWkEONu1QdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAdy3VrIUCfri1joCs2kZvR8TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM0ZThlZTMtY2U1Ni00MjBmLTgyNTItMzBiOTEwNzBjZGFmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2I0OTc5YWUtYzE1MS00MmU0LTlkZDctYjE0NmZkOTgw\nNGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQpXu/kDxWZmMm4omxrgHk0uP\n+GOg1x72h+nwB4bKMRIGGeB+ij0CYz1WtuULZqgFRTu8OQmebFusm1z7EhA8taNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUXa1hax4d12Bsjz3EiS6DL9bwKNwwGgYDVR0RBBMw\nEYcEAQEBAYYJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCIBVvVzCq1N49N4bj\nkxGQTEg62ehkqOUc9/s9seaxLEBYAiBpYZYmVkeqeUeLYj6TA1rXzp51j2MaxzuJ\nOdb3iwcN5w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8852", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8852` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQkv1Xh70jLrHL8i74SUgs1WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA3YTllMDcyLTMyNmEtNDM2NC04ZDljLWVhMDBiNDM3YzRhYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzcwYWM0NmItYjRj\nZi00NThmLWI0Y2MtZGMxNDdhNDU2MzcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa6EnBZt/03+7A1wIYJDid+NiJHM5ugm/rKVdvC9Ezi5+LjzSbeXuAGLK/UOI\nA4VgkpYn0A16nzkO7a+j8oim+aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOMIg9fzENoj+Kwx6wactqUVmUszMB8GA1UdIwQY\nMBaAFGU4lPClfO0YoERGLH+fASa/+z0+MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAgjr+CNBosP2HA4PzSP71k2JwQVt/h/uy\nJIAjJ7HPITgCIAcZEKh2rWNdZB06INDrfqvS63+mxLNnRwuOlI6oJnTq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ/F9G0lxHR6sg5lCtZ2rWoaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nN2E5ZTA3Mi0zMjZhLTQzNjQtOGQ5Yy1lYTAwYjQzN2M0YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQv7fmg8B6PcJ7szxudcWfuw+ZrBbdQd3Bd2ydAejusVcHJ\n3RjNqmA4ID7k+riZ+x6J0ezqKINIgmd53Jwhf4tLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZTiU8KV87RigREYsf58BJr/7\nPT4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOIfl0WiUAL9vLZ9DbXEWT66Rl+JlGLuiqB5mUhH5Bn3AiEA2mGNN2lM\npucQ2O9hBaPwH7gW/SPs8i1Go6IlTv3JjVI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAW4RGyRhTU7IUyCukR12w/lEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzcwYWM0NmItYjRjZi00NThmLWI0Y2MtZGMxNDdhNDU2MzcyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMThjYWU2YmItM2Y4Yy00NzJiLTk3ZmEtNGE0Y2RlNTY5\nNTc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA7OijGjEKuFYWuJgh8y70Jl8\nTOmqhdkmR/TtRgZeeiG7I8YsZwWUID+6AG3eJB7AogVZrxOPqRFAFKUjJfYy4aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4wiD1/MQ2iP4rDHrBpy2pRWZSzMwGgYDVR0RBBMw\nEYcEAQEBAYYJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIHvLcCtx+L8JOa1z\n8NPNC9/ZKSjF9aLy4ZzI5AEq58IUAiEAqphjtYLA+Chs50FjBZaXqTsFdc34SD1y\nhdZOjOMxIUw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8853", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8853` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAYXWvCuSQAEIVOsMG2DNM5w4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhYjc1MGYxLTMxNGQtNDUwMy05N2MxLWVjMGQ0ZGIwNjQwMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZhMDg5MGMtNTgw\nNC00ODExLWIwZTctOTE1OWE2MjAyZDU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqnPKeWv9+zksHX++pXbM/n03/P2RdnMXkwdb4kbbgSsYtSrJ3HyPeGhtRh12\nG1iNnG1rlBGvzi873pIH66MQm6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdFTuzVG8EUF9jD1dIlDUkOKEhyQwHwYDVR0j\nBBgwFoAUCw4rpHX9CoEnsL5zYkTsBr0gDc8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBqlNhJ+LbD2HxmMaBOhXe3FDMiK\nPpmjOHvozwCoH80ZAiAmQ0SyEQY+K4AJ4djyfBbPfsRCMpTTBjBaR5u6Pzo7xQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQGL1izSt/B5gsMTGge/x5C3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWI3NTBmMS0zMTRkLTQ1MDMtOTdjMS1lYzBkNGRiMDY0MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9Prabt9zKGQHn3HBPf1ER8FURD0gtR5X34u6iZHCBVI5n\ns5G5+zcsKbZTrt5ZPuIYtIP420sqRkUlAycielHYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCw4rpHX9CoEnsL5zYkTsBr0g\nDc8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMK2cKaiEvJ8HlbB5468mBwfmLIQgYkwsBQZb8sK5P13AiEAhnLB8Bs3\nRPBkkUBRxBP4tHW2s3vBKSfI5ySpmThARFc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAXwsgWNrKgPcbwTS8QFSdrnJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZhMDg5MGMtNTgwNC00ODExLWIwZTctOTE1OWE2MjAyZDU2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmRmODQ0Y2QtNTgyOS00M2JkLWJlMmYtOTlmNDE4YWYx\nZjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzRO7r0TK6PcP0Rh/15Ns1FNe\nV5206RI+w7BbNTS08PNyJZO3Cm0WUjZpcY6drWksFTO76n/NRSvvmfxkWAGoRKOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR0VO7NUbwRQX2MPV0iUNSQ4oSHJDAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22HDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICskviu0CZkmAfWYlxCUm4PXMXD12TQsbGCjFYmIevrbAiEA550jqS1P\nxMZEq+4bcLvfkfX8k7hmB2icPXnAQGzmut0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8854", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8854` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASOp2WWaVsZt4xEXCINgNMLDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlM2RjNDhhLTc3MDItNDFiMS05ZTM3LWU3YmI2NWRjNzYzZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQxMmNhNzItMDM2\nNS00M2YxLWI0M2UtZWJiYTMyNTM5OWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdIe6JQAptIhiEL0qEny/LG3OCw7x6q56VbFhQfgNCku68pjJMG0QifDpc6ZA\n99lSFn83ZKRWr3tfVK/qUOf6DqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRx+XjLCD2fgUNSPlq2WXJjooEgSzAfBgNVHSME\nGDAWgBTla77qvBxJPTYDQhJvYKnpwIoAYjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDiJI7PvWXAlrLsxxbN+uw+fA3Fzwlg\nKkEupn09kiiFrAIgC+bfyXWo59LBTw5QfXdPeS98jt5SYhZwN/OxJScUYi0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARCVNoHXobrG1FYOB4oc4V5EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTNkYzQ4YS03NzAyLTQxYjEtOWUzNy1lN2JiNjVkYzc2M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARke/qSe7NExaxfjelVYjZUHxDRYXkh59qqC6OHhY3iYGBS\nv/MZrI1EkaKICZPMz1GHvE8ZkyWVT4xcF2KuhYdUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Wu+6rwcST02A0ISb2Cp6cCK\nAGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIMZPeuk9uLla0LlfPn6CgzAhqNyTA6yr18CaNPoQmjMAiEAw2ueR+Gz\noxxDPQ2/nthEEiDPa74BetjjTeRHf8+nGkk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAX38UI+EVJRM5RHhwar/wrMiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQxMmNhNzItMDM2NS00M2YxLWI0M2UtZWJiYTMyNTM5OWUzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTc1NDZhMTMtZjE5Yy00Yjk5LTg0YWQtM2E5OGViYzEy\nODcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfdW1sIdJAp02NtE/ZT2mKUJq\nBYKYE4Q5mnLqexvq7Kj/c369tMQXcjPfogkn6MHs8zBEiIds5CWOvr/skF1xWKOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRx+XjLCD2fgUNSPlq2WXJjooEgSzAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22HDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIAowa2z5X1SWoTS9TTN5VY2yGCHEu8OkBJklJieieDCjAiEA/rO68eNv\nDcGxPUEgIoEGeb/tBrffKAfWFokt4/RDOA8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8855", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8855` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQWllSp5KN8ABOcDgykK8CGYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlNTkxNDVmLTZhYzAtNDFmNC1hYzgwLTIyZmEwMDNkZTI3ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE2ZWRmNjAtYTVj\nOS00MzU2LWJjMjYtNjU5NmYyODU5MTk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESlBTD43hqlLp3TWGnzYvU1mH8AwqoOG2SlnzNWJvak7wrm1I6DEpzkK7q6+S\n11Pyf7/pmRCykDYOmib0fMY33qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnpXv2eOzea8HSuhujYbfOcrMq9YwHwYDVR0j\nBBgwFoAUyudr3MSjchL1KnE0PakHOlgYU9UwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICco/OodtCesAyWoQbvjWAep3D/1\nwquAd9hgBDtyQ6rLAiEAl7q0iU3j/kpfMmrGGtsDGA00bBxy6arkSsNUPgBQtnU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQh6t5SmsXUXavYvoD9qJFi5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTU5MTQ1Zi02YWMwLTQxZjQtYWM4MC0yMmZhMDAzZGUyN2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjfx0Uf7ydScsWoxE5Hsfc2+OolenZR0XkOlr3PCFpR4wM\nKnEx1vEJiWJZnA7GV3/nzUgVuEURY49q/YXewUnZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyudr3MSjchL1KnE0PakHOlgY\nU9UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIwRnQXBgQAPpseHiSXkqLTDpCDFsuyjWKzqkHB+BK+yAiB7R8vxCR0j\n3n9DG9b5rAG06tqB09VJl+9QvBm/fn6Pkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAcKrUwIRHUTYXu05puximifYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE2ZWRmNjAtYTVjOS00MzU2LWJjMjYtNjU5NmYyODU5MTk3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjg2NDQ3Y2EtOGRjZS00NDg5LWJmMmMtZmVhMGFlNjQ5\nNzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG8nCugT8fi+WTEsV+Q9aW/Ir\nMAKysyeH//ucR2ORz23pRLp+DaiTaMBe1Lx1Nile/ZyR7Gj8L3V2X8M44RFq3KOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSele/Z47N5rwdK6G6Nht85ysyr1jAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22HFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBhghF0txc29NK4KJwMCkxhySrzG4rifL6GcdsmrYMnsQIg\nUBxDLxpp9taDd8DeGXsHVNqBAALyr96cr5CKLmTTCmc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8856", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8856` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISATvWYxr5140l4RsonbGRSsKVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5Njc0MWYwLTdhNDgtNGNjYS05ZWJiLTA0ZjhmOTA1Y2Y2ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJjMWI0ZTctZThi\nZi00MjA0LTljYjItMWJjODU0ZjgyYTJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1lnBY3+X+ukGxSbJcM4/J0djbg/ODoKGjRQ/aYEsgUYqdSnxVDzPfqSfHqIK\n0OXT83Q2OGjwojyuH9UPvWjWF6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBToDr77HUiX8+FTSw2SFOVLRq79TjAfBgNVHSME\nGDAWgBR6IkBEw/c7MgfBFT2WQac+WaWYJjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIH90k3T7cKmIsl71OR4FAfdwWZp9bsB8\nmsQbTgGWB/e0AiBal2JaKLpNUQfVsZBKViZ4BkZb8eXasQIt8RVeEDwYJQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQOgN9Ki9xL3avu3eLvx2NBkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTY3NDFmMC03YTQ4LTRjY2EtOWViYi0wNGY4ZjkwNWNmNmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7a8gfj9+9GA3qP6QBo3t+YowoH36Y9FuvjOrupStB/2Oz\n+9J/ySUxET+2sZnBNZWYyBT7/cA3h1mvgtoJ/h4So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeiJARMP3OzIHwRU9lkGnPlml\nmCYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANpqZtcO1a1FPo2Z8YX6uigfg+3H+jTcQ2LSyll3k5IDAiEA3cuA+Nw4\n0G3Tej5bQ04Zv9iSNBnR33rj0dbRMNYVQiE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAWul4d9J3GGauVygTHdV1NK8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJjMWI0ZTctZThiZi00MjA0LTljYjItMWJjODU0ZjgyYTJjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDFiOWZhZGYtYmRjNi00YjYzLWFiMGYtZjY1NjYwMTQ1\nNmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM8HhRkiSSPCclHQdDlqhKJ/E\nYTPlw8oNP4SFNofmetNPDJQoF2NruCnlW2a2Biy5BTkixIRZGuZiHO1G0VCPwaOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBToDr77HUiX8+FTSw2SFOVLRq79TjAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22HFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBtobsD/NhZK0h8Gz2AcQwg2tf91tUr4YdCUgn3yhKjJgIh\nAJzstIMj1V6/C7dJZS4r/dhIHikJmIX8I2SEXin12EJW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8857", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8857` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAVK9U7LJWc7/djGcZX3JydweMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ2NjQ4YWQzLTAwY2QtNDMzOC1hYWRiLTcwYjkwMzk0MjU2MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzU0OTQ2MWMtNzA5\nMy00MmU0LTk4NTYtNWQzY2RkYWI4Y2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbw1umLxWuvwH1f5xACm6ht94RrC9MHPyty52DDLoKkcklC8lQzERcXe4i6e2\nIROuslWB2guRNmMms6EbspF+XqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvjKNWWd4yhSi21bGAdJewA4zQKowHwYDVR0j\nBBgwFoAUOvqLrmwYBHqsFKBCyRGiHE04bxIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDOoUjWClajoTxVauX204+3HK+D\n/G3h0IK9hQsjrbbkVgIhAJKBFjLLIynpQNHPsoByGffv96JevAOt7736U9mvplxk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfNHYP8UvwAYuFW+tYSc3aVLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNjY0OGFkMy0wMGNkLTQzMzgtYWFkYi03MGI5MDM5NDI1NjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhpgmTKjIo9XyPuyxjk/SdAKW7kGVjfsj1KVeMvWGpmMMd\nEaqTbSQanVVJzq/To9DuIIe7XmLPTgkc48uXrcfMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOvqLrmwYBHqsFKBCyRGiHE04\nbxIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIMdQQsXQ9VhgEdUyCD+TivwjB0iF36Hrd+Qt0mwGtMKAiAONz4CPdl1\nelLZ9K5BkEt26uMo5JuYUdCIFpknBaMnRA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAVLsWh4L1XE0YtDleIyg1pNpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzU0OTQ2MWMtNzA5My00MmU0LTk4NTYtNWQzY2RkYWI4Y2Q3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDIzYjRhNmYtYzdmNC00NDAxLWJlYjktZTZlZmU1Y2Vl\nZDliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfeQTXeY8G0AETXdvHEmebdYx\nsYFEoEQTyiTfWRGgCP1fZH518/tC4VJ4CKts6+bQFM+s3Nv0o1sOO/Xla+rNR6OB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS+Mo1ZZ3jKFKLbVsYB0l7ADjNAqjAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22HFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIgK8+UxKlYYgB6lfXcAPPvRbe114Cu2aXzW+TU9aKnGOEC\nIQCI6ja+zPeNOSIccv3kMt4MuK2Gdhld0EmdqnpiQiZymw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8858", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8858` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAe2ryrb2nAlXSGcVtkvjCqI8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiMzg5MWFjLWViNzUtNDI0Ni04MmE1LWM4YWExZjFlYWM0ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDBmYWNiZjctMDZi\nNS00ODU3LTk4NzEtYWQwOWEyNmE0MzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/06KehHDxEg2kXGcCfsrXIIQPA1m8ohIfi+pQQ3kqHqaSMTwIz19Hzdu4Ttx\nEmQXUI98DN/rAMXcAf/H9f5o5aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTxSd0PK6NEsOXgpxKkU7Detrj0dDAfBgNVHSME\nGDAWgBS1pVHzejalZkup6W2ZiBXkrah1GzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBvs9PrB+COncgNPP3PsOSBVGHAVeNai\ndKCW6Kebxwt+AiEAyZrEoLukHCJYUKp5QgvX761XBB47dl/Ajt5aZP/viuc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZRmGBXxFwYT8XM6WoIN8rwLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjM4OTFhYy1lYjc1LTQyNDYtODJhNS1jOGFhMWYxZWFjNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFYW8LO4HxYgNootTB2OlyAkpKY+eXCxYkfdCwLAWuyCEN\ne53BH309RQzghk1kdAMdP0qjiVQ+LhrWkskucMw3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtaVR83o2pWZLqeltmYgV5K2o\ndRswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOcBnH5LEtYGhgLHobTnB4SpfEsaCgbSvr1oFrNyNc+lAiB/AzIokwHS\n8k2UzwhebdP99oMESHrtFS0PzNfBXerXsQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAViW40FcEkLNwaGTukHZbr+0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDBmYWNiZjctMDZiNS00ODU3LTk4NzEtYWQwOWEyNmE0MzJmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWM2NThhNzktNzUwMC00NzIzLTgyZGQtNjk4ZjAyYjE0\nNzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXmDmzf8JIXozlrle7c8p19EI\n90gnuIOhCqOPm3AWhIWH0+nAoLVEqpFIOX+kTOLTPxwGPLy+xlMghy6ltthFa6OB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTxSd0PK6NEsOXgpxKkU7Detrj0dDAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22HFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDRwAwRAIgASeZgR4x2UD0ZWH+d16hToQxvGrSZVjYzH3N7pwWDtYC\nIHOHfc2OlNsjCw7m3nnQu0Nsg1EtZk54+vH6L6D45XJZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8859", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8859` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVxOfGr2g/gkmKqyedPyzBikMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlYWQ2ZjRhLTk3ZTktNDA3MS04YmRkLWE3YzEwYjRiYTcyMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGJjZWFlMzEtMTkx\nOC00ZDE2LWFhNjYtMDdmODZiZjk3YWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwADtNSOVsfQ26Ffi8v7ZhjdiiAfvuPuSA7fZJ1O7H7IsBazEPNV1rgi4v15e\nY5OphGFVZzET4YyDL1iq/TWPO6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIBoy1+h+TSX7iVL6fAGDUR+bkD4wHwYDVR0j\nBBgwFoAULQEwFzAio0aPn2Orcru7FYGbYP8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCYWlgmGOG5tRdjV5Pv8ifcEEvk\nG6cnlB1jHCdEVfDWOAIgd0QXymucIjrHmWcAZeXGHwlyApwcKAkEZcKcJDCZHJQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASZbuaBVVPxwI4fBvNxE6jNTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWFkNmY0YS05N2U5LTQwNzEtOGJkZC1hN2MxMGI0YmE3MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARTzPop9e0V/ftmPdJxDDqmsDjSRKsdxBYJuGzr9Wi6HAm7\nsnU/7qnvErMl5oTZ5uNR5F8tdfxG3A00QcgQqH6io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULQEwFzAio0aPn2Orcru7FYGb\nYP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXjGLBVAodS89Cut7vJIOudl5j9MtqvCSVxKvX9l7eLMCIQCQ2GwwDsYb\nXxkPBJb9rqGFQaBSb+hFPQAcSgwwhUrMEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISAUhUAhFWS8LB/hnswq2dGIv0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGJjZWFlMzEtMTkxOC00ZDE2LWFhNjYtMDdmODZiZjk3YWIxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzk4MTAxOWMtZmU1Mi00NjFjLWIzMmYtZDFlODcxOTdl\nOTUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8o3ka9X2RLdKi6jnoVkbRSUS\n/elsgcQ6FiGkz/r5CGo/RrRIyG422g9+Xsxa/33TfcKFADOo0/eQYDdxIu8xjKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQgGjLX6H5NJfuJUvp8AYNRH5uQPjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22HF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIBW0wPHwPygFq51OeZRIKmXFjZ7F3zxIH7aHG9QNSV3v\nAiBiO8YDWE28GpnxEAeaeTeEcAC+OKPhMN5yXFdRajug9Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8860", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8860` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAW48IOcMES01dwBgiGGPEVhdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwZWJmNzFjLWRhYjEtNDM5Ny04MDYzLWEyNDM5ZmQ2NzU0ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUwN2I1NTUtYjcy\nNS00YjJiLWI4OTItZDc4MmZjYjZhMDc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDv5OT4tKNNExvp7/i1rEH5+nyJwXuZq6J0OwA7UQoqr+Zk6IEhKKq24yhcdo\nj0tX17V/YDZPNu++DMFrmEr/MqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQN7IOE2SOtjL7aXzk/wzDsI7ih/zAfBgNVHSME\nGDAWgBTViG7KIl0cmLeUTxo8gESa+KKwvTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCNIEVP4qseYsj1VLUL1da9vpzdHlNO\ncw4kM/Yk9SKHEwIgcifrgfM5e9D51/Gi0KNOpiuTFcEWWlT4ACb3RacaSnQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfyFR1xQeDZUjDD+61aC+I+UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMGViZjcxYy1kYWIxLTQzOTctODA2My1hMjQzOWZkNjc1NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcIUuGVbt1yydZv63JIeASNFe3QpDkx+FC32Fraldi/tB0\ng+4tGwF22wftfHSqygqvaBnCjGrJTkkKZ6NC1ytho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1YhuyiJdHJi3lE8aPIBEmvii\nsL0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMTitcGuOjDE1oEPTFNBDMzJFw4AqTNFJy7r7j8n0+aAAiEAsRBOCxKf\nF0vC0+YbC0ENN14Y1AfhcZ/BIC/eZ29gIK8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISARJwqx15UTjLBcdy8wMIamCCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUwN2I1NTUtYjcyNS00YjJiLWI4OTItZDc4MmZjYjZhMDc5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2RjMmFkNmYtOTgwMS00MWZiLTg5ZGYtMGI4MDkxZjc5\nZjZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsIYIdTNbNggHxL5gCgwsQ/Oq\n/ltLwJRgo5Tps3e6bPQdUG4yO4O20+Z7rQwyHvGDyqnUwqsnovRImnI7ne16rKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQN7IOE2SOtjL7aXzk/wzDsI7ih/zAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22HF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIDMIndFZYkl++GsGnoxP5LDKGSBLsry2wrrulADX+YI4\nAiEAvPJUSoUEmuN3E0T5tKm2GASpgaokFnK67Zo1xDsfk04=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8861", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8861` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYxNkhJPc+l06QIBldROz6M4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZWJmOTRlLWIyN2YtNDIxMy1iNzc3LTk5YWY0YjkwMjZmMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZiNDYwY2MtZTcx\nOC00OTRmLTk2YmEtMGIwMmE0MmY4OTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfxoVCLEa5bgQxkQ2SJ7mrI/Vg3wmSutH1zv4QFHngGP49CRZl56QCdzypZNg\n4oMrUQpmdoGeaaIPZEKPWWHEsqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBsfSyXuGmQBiuQzTbhBRAwhJWzYwHwYDVR0j\nBBgwFoAUFEYPRI4walyIeCGjzQkFmKZK5EowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG+q4iKZkQzZQXjBtbu+qh4qvWNc\nSpb6Jo2bCpzeVu3jAiEA04TCsJ351hSa/Pl/fQyO6jxZwhS1g+dTFHuBGw3Ba+4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfnWwLEBw7qbEAfEmiR07oRTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGViZjk0ZS1iMjdmLTQyMTMtYjc3Ny05OWFmNGI5MDI2ZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvT+kthYeWYnKl8n+Kv3B+mNIKeI6jVobl4rYBVMyOj6CE\nWs9CSRzGZmZ2GmSLUVJg++dvosdsdp0euqbqiWnyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFEYPRI4walyIeCGjzQkFmKZK\n5EowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXopvW/LjvjEEve2rNWhP8fnDtftaN/w+ea7/T1wNUT8CIFu9IG9djumJ\nB5QikHUa4NmgPwRtTtq9FLcQo1KA+8d4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISAfNXd66A2+8hus8/5SwZZqaBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZiNDYwY2MtZTcxOC00OTRmLTk2YmEtMGIwMmE0MmY4OTZhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGRkOGM0NDEtZmY4MC00MWJiLWJjOTQtZjYzYTNmYTdl\nNWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvR53cqZ0aQwDpZb3zzqFoIv7\nPUmjpBz45sxrNAT/PQ50nocMblxxj90r4aYyHbsxIfuKJsIuj0ONyVCr/+L2s6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQGx9LJe4aZAGK5DNNuEFEDCElbNjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22HF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIFDDxf0NFfJ7VXdE3Se9oFynn8sw6lcQ8m3vtKDizZnY\nAiBLQl9XeElT/g09IBxoIkdb5aqEDDhN5jTZp+DgbzcEZw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8862", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8862` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAc4snnRhX437g9JS6cGlBwNZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxYzE1YmIxLTQzNGMtNGFmYS04N2UwLWQzOTkyMTEzZTZkMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWExNTQ2NzQtZWYz\nMi00OGI1LWI4YWItMTAzZWU2MmVhMGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESzFMydti6MI8B3Qg/ejX0KA4f29Pw07en5lWraLy4fpXQoC4BjbUQ9ZeRZYq\nDI2cC2m8myvJrMvV6jcxT0D+tKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQnwhs0o+UnCqkr6MhwUYvui4XysjAfBgNVHSME\nGDAWgBStzUzOmd6KjzOEGz8Xl5h9nQNW0TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAoObYV6vLHov2uq5HJ2tyCzdQdPsfEz\nqjtMiKBIHWAxAiAp0PKT4UN+dTZGHqdqN29OlKRJuU67XQKTZJ5EMzs14g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARlSRflMAxRm1oxC/FqEHlsPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWMxNWJiMS00MzRjLTRhZmEtODdlMC1kMzk5MjExM2U2ZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARaUXhVpbeRHd+XJhzHcxRK/qnPE/aU+j1LtsWQbnIx3Vzy\nG6Q4iAm120qsS5ID9CYjyjD7OMSxirn3ddYx9+zjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrc1Mzpneio8zhBs/F5eYfZ0D\nVtEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIFm0ppOVrPOW2EqH79eocep9oj8OT8z5gehfH8TGuViAiEA8JDAGXif\nDAQRiokAz0VUl88eHzf6q1xaokbivWZ9m7E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISARfh4j8oUyJ8KUYdOL0ThBUkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWExNTQ2NzQtZWYzMi00OGI1LWI4YWItMTAzZWU2MmVhMGJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODY2N2Y4ZDAtM2E0Zi00ZGM5LTg3OTktOTU5ZjA2ODBl\nNzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgCVfjeNMygfGrH+dqXBXa/yi\nNdeMv8FUnVDLudWnNONMq/P01yWXyzQ8Dwc7zpvFNokKnGTgY7JPf62sV/o7/qOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQnwhs0o+UnCqkr6MhwUYvui4XysjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22HF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIH/Fbk9HGL5b6j5Sd/BSF/+TIK4DgBSv8ZpW/RbYpWM/\nAiEAk7he8sq6vuLx3YQEKWDjm519J9UUyQU+2bZAdkIfRNs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8863", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8863` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXaok1soW3fcZhS1acsHNdwhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1NzU4MDlkLTVlYTMtNGJhNy1iMTc5LWI3MjRlMzk2OTljNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZlZWQ5NmMtZmZk\nNS00YjZkLTlhNWMtOTY5N2VkNzNhN2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4v+cpTULC2fGMOyeoTQtR36Fyto19ey/B0arvHDok4v6Fy0kVXJY9fyCmXYJ\nIyZieti22QEmonVaMma90wfwMaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFO8QrVzVawj3aF1ZBdkYRa+/EGXgMB8GA1UdIwQY\nMBaAFC9ohLTIAHeicN2G4UH2gZ/cv4x2MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAX+oKVfvIeAet+d1s2Wm5/3WdXK+p8Z1Vr\nZ2XAg/w5JQIhAJ4XU8yqS/eFYGna7ThlbC0eQdGIVYJsrrbj5Is9K3s/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASLEyqFhVoZy+22de9pBTsmCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTc1ODA5ZC01ZWEzLTRiYTctYjE3OS1iNzI0ZTM5Njk5YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4YdaeOO4JfNx5igJOTdZ5PrjKcseEdTiiP2M2Y6tgazXM\na8PZ9EKKoA7bAZwFrLqkSj52weR0mQvL5ViAMo+mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL2iEtMgAd6Jw3YbhQfaBn9y/\njHYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMJetlclsejeGTMSVmyJaSA9+nZV1I33lHuAGXI5HScXAiEAu6410PFL\nUWtDKtfZg4VGtHWQi6ElIu8qITTAkwm2Jpk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAcb6jOsKm3mCJeCjDb+Y0N4OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZlZWQ5NmMtZmZkNS00YjZkLTlhNWMtOTY5N2VkNzNhN2MyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDRlYzQ5MzEtNzg1Ni00NTI4LThkYjEtZGIzNDNiY2U1\nZWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErgpxMjCz9a6RKrX1yhb6VD5Y\njQ7xUNgVUkDkJlVqB0KpY0itJUQ3AUFluFZFtKruyr1oFDhuDmEQ+g3gc/qYG6Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU7xCtXNVrCPdoXVkF2RhFr78QZeAwFQYDVR0RBA4w\nDIcEAQEBAYcEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAwdM6er9h9R7XBHMIHp5u\n63tYZzMmN2lXpjYfc/Ha7GoCIBXxh3OTqx+SrtE9jR1giFGaYsqTyXqTO7GlDy4l\niWR3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8864", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8864` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISATuMSQ0ZBzXqcdYc9FBJ7e7LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhYTNmNGJhLWQ4YTktNDRkYy04NGYzLTBhMjI5MjgwYjM5ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRlZTZlOTEtNGM0\nMC00Njk1LTgxODktMzhlOGY2YWI4YjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfey3IChh3Zzd3+gtcwaJYk/spIJSv49Jk74hhaiV6OUPciFKeStna8U0R+kd\npD9s+67GGYW97wG9iWVrqlrM2aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEh9U3sG0rjWu8OrmaMmr7q/e4eqMB8GA1UdIwQY\nMBaAFCaNSHfZORfwJlCtoSR7iUnS3pS8MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAiaKB2strvL9r108LjLLjR5K3w4rkbEoR\nv5pNBFMsjTQCIQCiMVT8G+GvIZ/cZeGGduJW/BgNsPah+kc1eFymtS7uFQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAahXj/eAyJ235/x0SZ21Lka5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWEzZjRiYS1kOGE5LTQ0ZGMtODRmMy0wYTIyOTI4MGIzOWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9AW6/FEGfE3D8qZGgoUayBRa4B68UGQu8/d6zFTbqMDbF\ny4JtLon87zwGmcqa++qjR+7sXWNSZ8FrMvT+3qFPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJo1Id9k5F/AmUK2hJHuJSdLe\nlLwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTsKxSA9lguDqVz+Wo4Keqpkw9VODrpYnH9Pz1oL9TUoCIDTABah5yBfy\nKo55fXZ9uQZwnEFxTPQAysfFKNprCliq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISASNPworrYwVTlDPqxXTHYTo0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRlZTZlOTEtNGM0MC00Njk1LTgxODktMzhlOGY2YWI4YjQ0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWJlYzIzOGQtYzQ5NS00ODc2LWI4ZjMtMGE5M2JjNDNl\nNzgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtETS1//UpbWuyQUdqTIQhLL6\nHX3waLFatP7OkOZr5v0zrl3LU1Z09RZHDCkTWC0yN+zjE8/rLX05z8KTLd4IpqNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUSH1TewbSuNa7w6uZoyavur97h6owFQYDVR0RBA4w\nDIcEAQEBAYcEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA2fwkcMwG5IF3gdXwtKVw\noSkJohInleRqhafHBIgjc+QCIQCy+p/q3Ag1+s98357vBEIX/oSJYq57u07cEWHQ\nNY+Jxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8865", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8865` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAQPiHFBPQSTrjFuNhvf5kXMWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkMzZlM2RlLTQwMDItNDMzYS1hNDA5LWExZmMyZTZjODcxYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM3MWZkNjgtMjMy\nYy00ZDViLWEwZjMtMjQ3YjVmMGQ1YmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj4sRtVtdeq2l7dkWMmjHjTb5vrJWuF702lT2dAr0iom4WF4ZZ0omD0mAhabu\nDdI3rB/JrHpSA7ufYlqqikG4dqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFGET5d/9nWomBn3mPMSmyCuVnRPnMB8GA1UdIwQY\nMBaAFFnWyggTEi9n9JIqSvBnLNYQW8RVMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAyJuNcZdwgWjDmArLY3MaufdMud/RbY/C\nA2LZWzW61IUCIQCTeZ2MHMxc9CKG6FINXRQSKP5GKC1CUbN0lfTLy3aGmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR2qE5SN2YQABCDJd9N3Np/BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDM2ZTNkZS00MDAyLTQzM2EtYTQwOS1hMWZjMmU2Yzg3MWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARlhOVW6NZK9reuG7AjyZreXQqeRuNYRGHPF6V5pMyBOWYR\nyEuTprXAFuMx5xEpcU0G/wwe3EMBBq+uzyDnWqKgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWdbKCBMSL2f0kipK8Gcs1hBb\nxFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMoaQIHBG/xesoxlc7vNvtGYB7Jc0Hstmf7d5JYewWX1AiEAt+cH5b9r\neLwTQ/6hzcZOaXbaMfj/TyrV4VZ8aUBxBx0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZIhlBfsmBuD5xBjuIy7f4GDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM3MWZkNjgtMjMyYy00ZDViLWEwZjMtMjQ3YjVmMGQ1YmE4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWE1ZGVlZTEtZTYwOS00ODE5LWIyNzgtNjg0Mzk0NGYw\nODA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiTKX/2KzaMmoP41Kx2wgpIvp\nftjWf5adRMWDruJxQt9K0dOJ9WhT21RuPnjQpd7nBIXlHLSGdQkeuZA36p2l6aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUYRPl3/2daiYGfeY8xKbIK5WdE+cwGgYDVR0RBBMw\nEYcEAQEBAYcJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIQCGS90v8vMTmdpD\nkPLUk6CtceL/w1uIk42u/ySYehhG5wIgHDwXr+nLXIaqpPZpYet1vEw4lXlALwU1\nK9kwt+8u6UU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8866", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8866` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZNiTWUGlPGyjb5pz7xQ7f3DMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmNTU5MjUzLWI5M2EtNDlkMy04NGExLWE3NzcxMDEzNDQzNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzllMTdlNGQtZGJi\nYy00OWE2LThhMWItNzNiYTZkNmE2MzhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvLmkHJNBWNfLHa3iFW/BvtI0H5WSwBqUyv0UcOKrvR13AhQC4LgcZ1b3Djt6\ncX6kZCuq5mDnGHjJRlZckqpF2aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEVfVdx1TK9YQyI7a5/wcLZKHsaXMB8GA1UdIwQY\nMBaAFGyBoqwnwTchMYQ9ui33J2sC73mbMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEArya3Baa3CXtHTezmb4kHsFhWKp4Nr/cE\n5wxAKrteKlUCIQCQQ70yTbI9qVsgjRaEgypZvT4DLZ+rS3AHSbP46xcb3g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQjMxzQhkxkvZkj+hoHp1u+jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjU1OTI1My1iOTNhLTQ5ZDMtODRhMS1hNzc3MTAxMzQ0MzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcJ0MXd3z5u1Iv+ijihuZIKJrpSfvCPgFNbxmVE/CBsqq7\nX3JhEuj55Ov4onjpYvAYCIcK0+B0yLMLdIl6AbY8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbIGirCfBNyExhD26LfcnawLv\neZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU5ifBkQTBhjuHx3yLdv/12lky26fLIWtSh8dU5r9rjQCIF9sDa4pEtuj\nx9QupZYP3wVf9MYtCZ/pTnKPor+Sq4te\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAf1MTkuVXRAnhUwrA/554Q3TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzllMTdlNGQtZGJiYy00OWE2LThhMWItNzNiYTZkNmE2MzhiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWNlZmRkMzktMDY4NS00YjU3LWE4YzItNjc3ZjJmZWUz\nOGQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQ7PhY/Vt0hT58KxxhwpDbU2z\n4lYjvwI5Qxzw2JEVy3AEAR+CURSr16cU5LKicPUkMT+9bsFqBAHrIJO/2EWMnqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAURV9V3HVMr1hDIjtrn/BwtkoexpcwGgYDVR0RBBMw\nEYcEAQEBAYcJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0kAMEYCIQD6Har7uTvfgua2\n1bfXifYpm7/sQlaEIcw8hGmR4xHeWwIhAL0h5MIsfkXuL9qmojFxYKMb2suTmld5\nC9zkgwD9r7ev\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8867", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8867` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQIlikvWd1LUsceyVclbwBlsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkYzI1NTg5LWYyMjMtNDNiMy1hNmNhLWJkZDJiYzU3M2I0ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGY2ZGVlYWUtZWQ3\nZi00YTFiLWE0NTctYjk1YWIzNzllZjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEr4wYjTdtdsRU4sF0loD0AKGfXejyYZ7zi+Ci8VW3yfKzZIfoAOhoz+FlnZ3k\nKNhOilRxhqsEsJoc1VpONiNZPKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU884kYCSqg6LQtMH1cpsTVCIcZVIwHwYDVR0j\nBBgwFoAU2jxqSWalPlttbMAIM5ZJyh8PXlcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAVC0GhHUFXNdmXiTkUKjnYDzVcu\nPvaJvT8+f8UUk5cgAiEAxyus6fUPtpVk5D5xqx8n7iXacREQpAct50w5MR3PMKQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU8aITUjLjuWhAPRodezqDpVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGMyNTU4OS1mMjIzLTQzYjMtYTZjYS1iZGQyYmM1NzNiNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYrBjSUPd1cp/DPTSO6kEZYpjfIZCdrDXkmpwaSofnBIDT\n4Ge+QP0DgIf8b/+MYq9daPy8Ddrih7389HGm9qTko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2jxqSWalPlttbMAIM5ZJyh8P\nXlcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCT20Mj1SybWNzNE5RWGLG8MVMCXQNSUMhQAVAoLgomwCIQCULCuAt+xA\n4ECONdcs+x9pHUNOfwlv7HkdNncg5gIzag==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAUQ6BOUcy53bXduOv1LLRiW8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGY2ZGVlYWUtZWQ3Zi00YTFiLWE0NTctYjk1YWIzNzllZjFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjBiODI5ZDQtNzAxZC00ZmY1LWIxYTEtZGEzMzVjMzZh\nNDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETy53V+lBKBBYT0tnGzdQQslO\nUsfg4BY0m+hCrbwH2yeH92qpxAdSwU7iv/15czMajYVJIhQaAuvWTKDzYjN3A6OB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTzziRgJKqDotC0wfVymxNUIhxlUjAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22IDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIFXVTmMkS5Ql5Ylq3DYE3B6DEz3WO8h1VKji01hE5V3FAiEA7X2UODgR\nPbwWpvmxK39/za8n4MXFggonVh/HPB+zKbE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8868", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8868` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAfR+t1oSAjVP+cWMpus6FqjsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjMTA2ZDliLWM4YzMtNGVmZC05YWNlLTc5MTQ2NzY2MzQwODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQzNjZlOWEtOWM1\nZS00OWI0LTk5OWYtMDVmYTFjZGNhZDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQokKi2CC0fRIH5ShJyPQsmgS0uMkIQCJBntOXqs7isQuA6gO+mNzlrrHBa4m\n4/VeHjVMYznp/s952eQlRxjqpKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSBJ3RicpMndb+d3Yy1CqiQn6zQYzAfBgNVHSME\nGDAWgBRVqOzWL6sqM/V+waqbX4C0NrZqLjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFjY8q4SDZcTEy84YKIkInbyT7wI8dFs\npaW36T13PrdiAiEAqwXNgcDZCzeOiifz873yz7DKa6svJkMvR3a+xVngrs4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZcRI4YHpizWRuXHOeuvqrpdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYzEwNmQ5Yi1jOGMzLTRlZmQtOWFjZS03OTE0Njc2NjM0MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEWpZT3Xcs2qOgDAUSB69HB5UyyG32t/vU3N24HtCYlujW\nWqrld0H6RFdkBBuMu3aYCs6QfEjpw4pXKmw6keSGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVajs1i+rKjP1fsGqm1+AtDa2\nai4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMlbCKqe2gRr8MoBihSykWifrFsTWBW+/nl1GZuqYxqWAiEA1hOpUEUL\nvgk202Eb0p0SCVnUaT05tZU3be1RVSYnLl4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAbNYyDFWqCx9uI2n5tOAio5yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQzNjZlOWEtOWM1ZS00OWI0LTk5OWYtMDVmYTFjZGNhZDQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjdmYTAyOGItNmMwMy00ZTViLTg4NTYtNmNkNGQwYzJh\nYTcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBI8L/h4GAc3gOcJLm1x3DZLS\nGgJH4AeCihqtt9y7CYbubw6n8xt/VDx307wWTPg19xn5hk0i15DdKIuAKdiFD6OB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSBJ3RicpMndb+d3Yy1CqiQn6zQYzAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22IDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDO3NNmmHDudkmJsrkVp5LpMCYRrrG9p2Fgb8Z2uMroKAIgUjpXZ9pK\n+rdIGepzE6np/iVfErU6K8MqmIrKPfw68Fk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8869", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8869` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISARMziGPm+NQ/XJQDT+C55qEfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmODJlYjYzLTAyNjItNGYwZi1iN2Q5LTk1ZTUyMWU4Yzc2MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTYzYmIyMjctODg5\nNS00MjEzLWFlM2YtOTRiMzFlNjVhOTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHzyd2a35BoImyQTPq3cfsROdZKLTPLpP6+A+TWd3Y+Pq9FRdzky+/EZPcy3D\n8BJXD+aqV+xXHiPQ+vIRnXh+t6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzPgHmAZwmCkgyGVBNmVtMle3QmswHwYDVR0j\nBBgwFoAUgFY5zAmMMa84yroCdmNwQA6FTtQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIF1uHWkY0i2uOYxNZbgl4Jm7uUVA\nbu5oRtKCB4DA6T0jAiAQOy4DEx/Jjz7UXLxuCAo0wvYRq4vdC12sFkJIdTMyAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZSUdiW7YS8KqOoN+Rf++HgGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjgyZWI2My0wMjYyLTRmMGYtYjdkOS05NWU1MjFlOGM3NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARc3ngxDMKE8h1tOa1p0zb+RGnFhsZJI8hACrb5wCNx8K9y\nlhRpuMTVOs5+fd5NakWcs0qUJ+vlbwK5JaeltDM2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgFY5zAmMMa84yroCdmNwQA6F\nTtQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMQDNjycd7fwHE9WefBss5y8G0a0I/UQGxp+R0N4+SD+AiEA8YMPXdTp\n9CluBq/zvLjcf5Dt4tkpME/JLAGiw46MBDI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAeZqJOpwHJs02TWYrTzEqnZDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTYzYmIyMjctODg5NS00MjEzLWFlM2YtOTRiMzFlNjVhOTZlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODlhZDE3MDUtN2UwYy00NjAzLTljMWUtMzI5NTI1YTNh\nN2EyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqTSFNjgKLFKEWO0Zdf47ZbuI\nYmODuXjZLGIqAUdmB5/2bROxAvOYKXpiNqQQIgaQheI5WsXkI7ckqws05lHLFqOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTM+AeYBnCYKSDIZUE2ZW0yV7dCazAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22IFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAiTARja1VmPJqswVp+BZKde6cQdDeesykDPvWJJgDHVYC\nIH+NQi4JBSgO5gs+PgEi3c1hwc6GEOZPjVjkPhd8HrQf\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8870", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8870` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAf3aZ1/lEFSd/P9yQJK8kygKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzZjRkZThjLWM4NzItNGNkOC04YzdlLThhYTQ4Zjc4MDJlMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjk0YTM4Y2YtNDBm\nMi00YjNlLWI4ZTctYTgwMTAxNjcyYWJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6LN1J/uCzlxzTpZJ1Bpsr0adeyTnSMxIK71Wyv/bvF59KpPb7TtoZ+7CV1D6\nIx4Ba4q7S1Uzsx0DzPdAH1Jbe6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT0ZZ4E/DgR0KOaA99733XUPlAFLzAfBgNVHSME\nGDAWgBRsM0OOW+JOOiE7rDVH3dqt+ZWWxTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCDKaMgu1Jni/OKQf4ENtTfj7X3sPdr\nJlX3aBgWximuXwIgQMQj5SUSDpTFnG0mDpqQ0pHhGXtrGzELgqXmdXksNnc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASFBVlUBL6ySkV2DT0SIsOB0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nM2Y0ZGU4Yy1jODcyLTRjZDgtOGM3ZS04YWE0OGY3ODAyZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQM1AoTqHPad2aORBONo+6K16D6++RbX8D1Es0yb5bWwlkS\njCSpupEWAcARMg3ySu/YY3kZzbdaK/mEb+44LOq8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbDNDjlviTjohO6w1R93arfmV\nlsUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOITi2KSviE6/WC2VD+VnxftLrCdjXssxhzvqvHM+G4LAiBBdB9nXdpt\n2En//UMau9mTmWZJkLdr6gxbTtaqcQvpAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbV1dOtQGXNXnQykEXh1icsAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjk0YTM4Y2YtNDBmMi00YjNlLWI4ZTctYTgwMTAxNjcyYWJjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzM4YzRhZDYtNTlhZC00ZmY4LTk2NGYtYTZjYThiMWNk\nODJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9U6ehMdtwsaxL8c+F24LhZ40\nwCeCRulxahflA5/3b0cH5bEr10Z8FAZbH1FGV2nUva3DBq22nyuHDIWv4VXZYKOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT0ZZ4E/DgR0KOaA99733XUPlAFLzAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22IFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiBxHVwyJf2mGt3V7A0RRAQzcRZ98jrC7kY/neB39hG97AIh\nAK/PEe5lxNNn/i/xL60pvDL5Ew9uIr0Di2vRCNvGWhJK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8871", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8871` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAa8T/tfNr0P+vT9WArOK6C5eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlMTRmNzNhLWQ1NzQtNGRiZi1hNGU1LTRjYmUwNzAyOGFjMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTBjMTY2OTEtYzcx\nZi00YTUyLTgxYzEtYzZhY2E3OGMyZTdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBu2tjGCLTIxXP0DWr4qDU7S5q8d+9GBs0HGqeGsRNCzhPqXotTXoz4Sanc5E\nkpxq6ECk+rppoI1k/64slg1fpKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUasz1n7A+trJDnwCOzD3k8d3Qtd0wHwYDVR0j\nBBgwFoAUkE7Tz+um1MuLL3W8xJfjeBaiXt4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDg+4q1zqxJKzBfdrjSdJlKD4Q/\nOx1mnuApJo0SuqtyxwIgX/L1Zc2gyguhJXgMI2gcErZCoVn6r6US6of+NfaiINU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVmCMGu5bXod71EmjuDI0AEvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTE0ZjczYS1kNTc0LTRkYmYtYTRlNS00Y2JlMDcwMjhhYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKn+FmzA8KyWxAf+rsYfH2Q+COTvsWEy/ut+qBPFXDK0Ap\n2PCct4y7J4ZLA37f1bShNCrwvrX1ZuIXT2b5wZsNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkE7Tz+um1MuLL3W8xJfjeBai\nXt4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPdPTcZFHCP7f4GqOy20dzlFTWRar0taa2YOnaD4acCzAiBHuBjP97IP\nXd6ympy224UnJLdS3FADSkXf5l65vEjVaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAfGKIyF/KOpnjPjfbguE16EUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTBjMTY2OTEtYzcxZi00YTUyLTgxYzEtYzZhY2E3OGMyZTdkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTljY2NmYWMtOTFlZC00Y2YxLTg1NGMtOTAwYTJkNmY1\nMGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE91DVutpRzxaKl9y7yAehOEuZ\nVC7ChUAu1dVNqNSHAxUVyMHOaXC6hV5z8KsrDQAgWvtA9x9KWMzzUzpaTDeyEqOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRqzPWfsD62skOfAI7MPeTx3dC13TAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22IFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIgWp7Im73wg1laFXCUm6x1BY1SSN/7un4v9iwewU5lz/kC\nIQCEpxgV0OWPd+fwOYJdL9YL27iAI+rwou3KaSaidl5l2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8872", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8872` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAYu1n/E+OkjIWbPcoiXwnSFDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxMjE4NWVlLWZjZDMtNDg4My1hNjdjLTNkNjE1NjY4OTY1NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzEwM2FjYzktYTU0\nNy00YWZkLTg3YmUtNTUzNWM5MDkwZTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENnr4OpZf5PaT+Hm/KcISI0iS6u1JVKtbtWUNxvpisqBfIx6YG5JbrIG2I7QZ\njqOcQMOnoXaDfLudyXDUdUyCj6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS7mRTYW6QjdClSdVx+Aw99f5qOYTAfBgNVHSME\nGDAWgBTqRk2aRm9x9aWaY7BAUL4UxT8aGTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCQEMTCZ+bK7lssAaLPWgiOdvT5BPhw\nAw3/YmceX/5lTAIhAIUqWnyQL4dpDkLvgPCvZqdnkBxGIoKLC0sgMQOZ3MWZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWUUS6Q7tysMtuZW6TWfMTgiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTIxODVlZS1mY2QzLTQ4ODMtYTY3Yy0zZDYxNTY2ODk2NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPbQ1gtyHmRCx7IlY2sgLk7LXHSSCwpeP5jsV0cETGep26\nG4TxBOPjKXkoYag9R0bpEkL+3UYGwomRoc1jOw38o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6kZNmkZvcfWlmmOwQFC+FMU/\nGhkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOTZXSfnBJ0XCo8M0RpzxIgBFVJaNu5B8VXHeMmYZxj0AiAkbEtk3p7R\niwEX2vJ9kRYw+qL7aNNVuRFbRgk9Iye1FA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISATcSkgaPz1jZJq2kr1a3rYmxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzEwM2FjYzktYTU0Ny00YWZkLTg3YmUtNTUzNWM5MDkwZTQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDNkNWNiMDUtNmQwMy00NTc3LTllYzgtZTRlMzZmYzBi\nYzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5PNJnsDD60nrwUvHix0DRHpy\n6MyXhFt1pF6UrEBejyhzvpHXs1fnRfPRR5mEZAc2O89Nm+LQBSE9GfvDNQTGjaOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS7mRTYW6QjdClSdVx+Aw99f5qOYTAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22IFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDRwAwRAIgUGWiImAMBG+7UTrt7J5Yj+7WsM/fZ+PyGPMF8yeyURQC\nIHkERkw5qSbophUg1w0EqIfrGE73UBsUUoKcIKWLAaQs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8873", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8873` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVPqUQhCUINT6QU2VShIdYvbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3ZWY4ZTRhLTRkY2UtNDg5OC1hOWEzLTliYzc4NzExMTM4NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzE3YTIyNTYtYmU4\nMS00NmNmLTg4MDgtOWI5NzgxN2VmMDEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc7KL+CstMb3f1xy81074D/da+7mzpybhnN5lWWw9i/KluBpkpgGmHehOCq/K\nEvl+hpuUHXF1fB6iDNI8sXAB5KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYE3cVMsx3eFn0Qu64yOVG2Ol8EwwHwYDVR0j\nBBgwFoAUZK91fSDuH24b4veazQyhA8aTMQIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDktCglKkmpot/N35aTjhKhUHca\n0UjBaR2/d9Ydz358BQIgGWWvTvL1lN2ifsTfT+EonXkUUgi2zYBwtnd1xTWmRjM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYIFaI8LiDONfWe6Qu6JT1Z1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2VmOGU0YS00ZGNlLTQ4OTgtYTlhMy05YmM3ODcxMTEzODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASm+2XFKhHbKncqpJVv+RDb/T2tE6VoMGO5SxNSTnd5B3zc\nNE3QRBa/S/KHgvHt3uVGlIdAZpdrFxbP4RcXZiEIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZK91fSDuH24b4veazQyhA8aT\nMQIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALjdSBPeS+Ad+zWEuvLUXVACZSYV8MP5RDK2y0Z+VOzkAiEA7YXrH6lT\nlYq6XZD9miFyYz2YM4HI7GZGny61gDEUKfE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISATg+gxRwzZWDzT9aU4Y5e5gUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzE3YTIyNTYtYmU4MS00NmNmLTg4MDgtOWI5NzgxN2VmMDEyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTE2NzQyZDQtYjBjMC00YTA1LWIzZjctYjY0ODcyYzY5\nMjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELf8WdNz7qydGDPDduXhH3Fxe\n0QaSuwkpSGGHg3rNyco8derTF9E431Dsa9rtfcNVziRSnFOlvTKdEa0ts8d216OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRgTdxUyzHd4WfRC7rjI5UbY6XwTDAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22IF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQDPtqndRDNckZic08PLVnM8ziG/5h5+D6FR4FGfO4D0\nGQIgHNPWcw9VkxXhJWb73jAs6TGvfHbi1fwGiAVNmD2/tjQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8874", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8874` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQTCQtRmifI+s7ERk66elYZRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxM2E1MDFiLTA0ZWYtNDU1Mi05MzI5LTEwZWJhYzQ2ZmEwOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjIzNmM1OGYtNDYz\nYy00ZDIxLTllMjQtNmViNTE3OWU2OGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKw+ScnSvNHYSO57hpLfG4n93FJrEvsHrprjqMZFgq1TA7JoAyh+tgnsQvzUt\ndLSQp6uutYY83n5NQ9J2M4VJGKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQB0CDm6zFNglgODFpSxdNvCsNG0TAfBgNVHSME\nGDAWgBTB9a7njJVAz2BvB17JErSPpQjUCTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDwSD5l48ORQQZY2++AQPMPCOI/Lo/u\nofhy4a+lTHlSowIgWhn/cOixQs5HKwGXnvOsKF3zhUo3dLVE1tB3i14Prbc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT86ALUb4Djb7tE4fA4pHnsRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTNhNTAxYi0wNGVmLTQ1NTItOTMyOS0xMGViYWM0NmZhMDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpMjFGwGwy8ZPb5XxQogflLAbOw9tFEUUiCyram+FdH1ac\nnm+xk2ulyKTX2amvHZSPbe78TTbryyyBHhgvOWhqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwfWu54yVQM9gbwdeyRK0j6UI\n1AkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR/CiCsuYTUvz5Wcm5aVGg4bhPyUsgNKeMBGRC6UDczoCIGvx2EWyAbMf\naP/QXqjuSar8/fHHaE/I0xbbu+L4ADkX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAcE45USNqLuKqptG5uvBxMj1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjIzNmM1OGYtNDYzYy00ZDIxLTllMjQtNmViNTE3OWU2OGFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzc2ZWIxMzYtNWYwOC00OTEwLWE3NmEtOTYzMTA1MDNk\nNTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEGNwsKS2oBVqTbMBjS6zGwAs\nOBBgNMrTpUBEVjdpNdQWbr2j8EfJDq1GXfrmPo9dE9qUUKz3DgGMWkjS78HysKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQB0CDm6zFNglgODFpSxdNvCsNG0TAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22IF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQCfAB5HS2OaNdT1L9IUou7ijgYXWN12ZPk+zFzMJSLX\nwwIgMaxJ+ek5Qwp5wk+59yCyg8FBsF1HwFydZYXnhB4cY2Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8875", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8875` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAZHBXaBgVFCLZe1s4ApKNJ8eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzYjlmNDJiLThlNjQtNGI5Ny04MmQ4LTFlNDg4NWFkMmMwYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUxN2U3OTQtN2I1\nZS00YjM4LWEzMjMtZjI4ZTQ0MTMzMDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgFVyh3KdEUfSevrUwgnVEfE1YxeGs24pge0D4oijCr6fVyhuce2Azhul9nFO\nWiveruwbsxjTa/kzx8LpssDw/qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVDSN7O54flQuB+JmHm0fhs9t17gwHwYDVR0j\nBBgwFoAU2xBKFTniA+pUG0Z7Exf6KsAdAm8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCXEwM0sEJVYOuzM19JZssS47XO\n9JSc1fMXmT2x430N4gIgF7PvmMWHPo7hDDU0LJRg0jhSXaVulbEw6fhUhcYrO4k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQbNClM9/WRyeVWwJYNixLMEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nM2I5ZjQyYi04ZTY0LTRiOTctODJkOC0xZTQ4ODVhZDJjMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyOQ+1/UvNOsIGNGvIKM6TbTn8mwKHOGFqQvm/BvvtQXt7\n1sJoWa8IeJxfMJQPh39jSlXPNO2yM6Pn1LUvtd1do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2xBKFTniA+pUG0Z7Exf6KsAd\nAm8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdn7HIAtSWhxXR7tHtv50iXyR1WxXQ9NEY2X3x9GFQl4CIErusqjWIMO9\nHHgugr4yQSGS29KpWPSRXEnl1agBBZvv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISAWn1d3mO84FUOeHqdIrkkVN3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUxN2U3OTQtN2I1ZS00YjM4LWEzMjMtZjI4ZTQ0MTMzMDZlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjkxOGY0MDQtZDc1OC00NGE3LThkZDAtMGU5ODgxZTQx\nNzA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4kpjqta0iq9EPFX1ikJqoz03\n767SoBqM/RGyNog5cViwW0XUq6Bz/UkO973LpG/Xfk2GhyVqJD/sjEdVzq7Gb6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRUNI3s7nh+VC4H4mYebR+Gz23XuDAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22IF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIFWxo81PwK7SGNFVrO90uOHAO45sSAGfL0c2fFH5jZ8e\nAiAB1OS3OhaUHQ2Lo8iGeQjsJLCBk4ppTN7ypjsZ7dMFjQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8876", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8876` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbMpFdBUNJXO9s6dBLm2YGSIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhYzMyOTY0LTJjMDMtNDkzYy04OWFkLTM4YmQ1MDVlYjE2ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDlmMDdhZGEtNDM4\nYy00ZWExLTg4NjktYzVlMjBlOTRjMTk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE22eSY6HhLuv16WTq7vpIWf6NUNhHcRUWkaBYzkq3X7D1MnYyIPXMK2ebDh/w\nASFUFqug0mLkbSJCK58BbZti4KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQhLGzKhgMYkBlJMhUea4Scc7CrWDAfBgNVHSME\nGDAWgBR1PAqol5hKvrMtbjy5Jb7GAq5SaDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGZxhmHnqPuBXyK0/vCEnpeJ9wsCJCrd\nGsKYgHKwctqcAiEAoA/Lh8eKCz6XHqbZLN4DtDUAp2sa1sANaDRKtIm5fdo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbLzQSeCGVmu3UNpIExOz1ysMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWMzMjk2NC0yYzAzLTQ5M2MtODlhZC0zOGJkNTA1ZWIxNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5TxqUK3ZDYy2GNdNt/SJVzSYaVbcehXXBv+oLhnYK7UJK\nFliyCA3dJ18HwKvZpiUjCz8zNK0LUvdnE84PU72no2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdTwKqJeYSr6zLW48uSW+xgKu\nUmgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALhg+HOwB8/nagpLMOQUwYSortK92+pO7h95broDJVL7AiAfDkfGncFN\n/gfleJBsTh0cgqUZJv+0v+8tR3msOaHKbg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAYFHhmtiyuuUKVsw4O03C+RzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDlmMDdhZGEtNDM4Yy00ZWExLTg4NjktYzVlMjBlOTRjMTk2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzQ2ZjZmZGYtOWIwMy00YmZjLWI3NzgtMDdmYTU3OWFj\nY2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsnprRNd42Od2JNuGhD5xDQlV\nuJhohg8XQPi7kW2k9r4hECo7GWzTq3aL0qUDym9/CR1mJyZ5uZG8xIqQDLF42qOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQhLGzKhgMYkBlJMhUea4Scc7CrWDAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22IF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIBiykmZit4jjGKr2xQ+Q1lRwyrdSDtA8RDDXvUGkxoJu\nAiEA6JSnFoEDDVVUycRljCBS5YMwwgktXII7Go5+pNUn36I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8877", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8877` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYWBrdtSic+XCTfVlqUo9kypMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhY2RjNjdlLTU4M2QtNGU4ZC05MWRkLTdmNzg5MjY4Mjk1ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTFlZDJmODgtZWIw\nMy00NmM5LWJlNzYtZjFkYTFjNGMwYmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcsWj20qry5plyZ0MMIFGCOR6QVxf4Psoe0FnJyUPEoH68Ak/JOWA7/2pD7SX\nlW2JhrlJnrA6woHHYpdnyGCqu6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFE6SHLMSB2GCPoj28SHaYf7HytvlMB8GA1UdIwQY\nMBaAFJBv+PW7nG4+QKWAhQ+eoaeBpr5fMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA4Lm/wRuPGtfHFhp+Y2sZ2iFtCF///7ul\nMPSfxNJqFvQCICTlQ4y3vGoY0QwWSpft0YqRyK4X/ZAMIzLuDyOnoLv5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdvJ2q45UdkYnxsXF3psvwG8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWNkYzY3ZS01ODNkLTRlOGQtOTFkZC03Zjc4OTI2ODI5NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmrusXlfS5OZ2DHU7AOoWkziU7PAcCo2I19ui8qJK9kjmi\nJn1O8uKerqGoY26fCWzFoxo1v8ptMR3TQlw12Vzto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkG/49bucbj5ApYCFD56hp4Gm\nvl8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP8DRt1+aPE1OT89frcFb6PBHDK7M8FiFQ6jYNGXoZLUCIHHKLxqcaDUM\nRxnvbJIFllBPOPl6VJ3zbgf2L5JPBPoA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAdEo/ESo7HpJi4VnNppMTK35MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTFlZDJmODgtZWIwMy00NmM5LWJlNzYtZjFkYTFjNGMwYmI2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmRlZTkzMmMtNmVhNi00ZmU1LTgzOGEtYzRhZmZiMTJm\nMGJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiVzsGqExYICNxQifYUTDpztW\n+bs3/6tTq/RjW1q+P0c/7sB1uRA3c35DzJci5duOy97du2YjXXzx/1I7gwSPsqNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUTpIcsxIHYYI+iPbxIdph/sfK2+UwFQYDVR0RBA4w\nDIcEAQEBAYgEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA1+XqifhBS6kdEh/6EiyI\nqWy8k/BUZOevFZ5E7s1IUysCIQD+Ci0b/pC1yZCXbgBfIm6hwL1MNDZ++40aXa7g\nqrC3+g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8878", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8878` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfK0GjwRFW9Egv2vaAv2OKSeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3Y2NkZTFjLTUwYWYtNDFlZi04YjlkLWI1Yjg2MjdmY2Y4YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTdhYjllYzQtNjBi\nYS00ZGE3LWEyNDYtMTZjNmIzNDI1M2E3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjblLHzUuTS8irLeqoDnJy/RGhZbDFkyijJRPQc3swNmhM3AHY2PAxSREvRhC\nVXRU+60Au+FQvZKgoiLLymCqfqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFMzSGhKy9U27IEiP6C3SNhRRhJ1pMB8GA1UdIwQY\nMBaAFDwDmrez8Fq3+xsdBNEIQ7qSl0YUMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEArKtDq6FxTn5MQfFTe6j/l1P8K7uC4AcB\nz0T3WXkL+gUCIFTjO+U0uBubIRRkkOJS7bZFsioeb9l0pkXjf2KVp1sR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbB6cxH8FV+IE8oi95DeD7QDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nN2NjZGUxYy01MGFmLTQxZWYtOGI5ZC1iNWI4NjI3ZmNmOGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjkjm9mYG65TpZQ7BmbbGHbuXYqVKDJTTDF+vTORZtQseJ\nDCM67dSkaVFaDfjGjK2MIzS/jTHl3ERgjDri2HG0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPAOat7PwWrf7Gx0E0QhDupKX\nRhQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALNckGqjCKJbvD16QJ8LLKQ32tEi/XleV1oSrv50D5KkAiEA/AGqtEnc\nlTXE5BqeZC5wgX9xwNrQQZhb4w9NGGu1b8M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDjCCAbWgAwIBAgISATf+o2bb5bjTdTcwSAcjJ8iMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTdhYjllYzQtNjBiYS00ZGE3LWEyNDYtMTZjNmIzNDI1M2E3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMThjYzE2ZWQtYjljNC00MGFlLTg1NDUtNmEyYzI5YWFi\nMDIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE32qTnyig0abRgmhSYmxc2Js/\nJ40y9/WuNpYS9qDUOfQxsq52qYNKGwxlYYUE+CR+NlSHYOwEOA5WqQAincm8MKNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzNIaErL1TbsgSI/oLdI2FFGEnWkwFQYDVR0RBA4w\nDIcEAQEBAYgEfwAAATAKBggqhkjOPQQDAgNHADBEAiAwjaKMeK1yQgYc4qEcRlv5\nu5gKzRmA2SjfZc17zZfs4wIgE+3g6yUqYBJBr3/RbCy/BGQ1/Ch6CjeyDrhU/sIN\nJOk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8879", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8879` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUhwqcjenfluWBJ1crzWHSANMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlZjUzMWZjLWUwNTUtNGNlMS04YzI1LTg4NWQ5OTQ0NjFkZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWY3MDU1NTYtM2Ri\nYS00ODQ3LWI2ZWEtMTRmNDkzZDliOTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElZO+WCh4bJp4LCFCXLeCya49tWiDBz4IezPga22NT8mQLym7aPsXxUdTedqd\neyAMbiksQGRjqMbXEYKhNLwuEKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHbhJ0agoDUBz1KF0FLcEZ0K4kQtMB8GA1UdIwQY\nMBaAFAcFHNsVZrKNq2FBRkdJlMWb+r4WMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAvtgCHA67/xIhkIM/ISrplSRwY3cCKmSf\nNmoGZxbnZw4CICfMg24OS+29cKmxZyf4rT6X5GCoehVPPyxsE6patWe/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAURvFrseaIcOe5kA9uzBf8u2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZWY1MzFmYy1lMDU1LTRjZTEtOGMyNS04ODVkOTk0NDYxZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARux1xfS10gl8LOHSJgHnzUGEgNHJ7dBFJ4Y/sX/7wMrkTv\nIEB49sXAGwgcDPh6CKtcs79tu8iZFiTpE9kpf5ZMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBwUc2xVmso2rYUFGR0mUxZv6\nvhYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKf/GnlamloXt1hMAI7d4h0RH23LoHhswwn0+LDfXrySAiBEPbnxPybT\nJPhWXxHULEgMUDTSb9pM+imrae2AdSmfFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbyfyWY4/60qwCL7uSGZPt05MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWY3MDU1NTYtM2RiYS00ODQ3LWI2ZWEtMTRmNDkzZDliOTFiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTJmYTU3ZjMtOTBjNi00NzQ4LTk3MmMtYTQ5ZDEyMTNm\nN2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECUaXhUsPBF0DAgzWBwxuS8Wr\nj9YxcT/wBB4Uoy4t5Bl211o/H7+UsliYseNMcV0VWdJi1zyTWMgSpTob1l14kaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUduEnRqCgNQHPUoXQUtwRnQriRC0wGgYDVR0RBBMw\nEYcEAQEBAYgJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIQD+q1HN/OgOi/f3\nnigOdFkx00USOlGFhTfid8hIa5hOIQIgJVdl+cjN+D0rYwSckYUeIRDTB1+qqVaa\nlKMzMhgghBU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8880", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8880` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAUWUKgXqi4ZLgQg6BFb/xMgQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZjBjZmU4LWY1MjItNGQxZS05ODc4LTAwMzRjYzNjMWZlMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGY5NGQ4YjItMDIw\nMi00ODFhLTgyMDEtMTEyZDc1MjYyZjNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgcpXvNcfcC1O1lotGhmIxbp5FvfFQqSNwqr62WIDlmf09sTZPAfn3W+Fegq4\nfuGloh1PLTyTSkdjE3vqIw3RnqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOAZPzVZjGeoSIItEFK0QR/YzNiaMB8GA1UdIwQY\nMBaAFFa2ntrKehJRCpM1pUlo6TAawagoMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA2aBAmI2k+wMTEnCu2wMdZ0kKYlyggWgR\nlLvnacSUShICIQCo1XcfqL5iyNZLLXn6FUqLK2BASO9uV0XIBo0hdepY7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUBuyk+BsDhJ1qPpAVzfJzCAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmYwY2ZlOC1mNTIyLTRkMWUtOTg3OC0wMDM0Y2MzYzFmZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoP/laQJpB8vrxOqG6WYcE6Z6cnIabOzphvbmdy5sYDWhh\nnDfSh9Vo/yvejcywH6T5lBnV91UttMg5zBV3ptj/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVrae2sp6ElEKkzWlSWjpMBrB\nqCgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgadOH9MX3ebQkoBHmPRh4PYJpTdwD2h2aYKKfEw0tytICIFjgSUekshL3\n1NIZqS6ENyt/YYfl3/znlm8L5bhvJV7H\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAR7lxnPhx4m0BVXK6zmI6MY6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGY5NGQ4YjItMDIwMi00ODFhLTgyMDEtMTEyZDc1MjYyZjNlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjc3NmI0MDQtMzA0YS00YjhlLTkzYmMtZjRmYWVhNjli\nNTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0oBCX7vbnhFEGugm7GNNMh1d\nIcv+Q4WajVUVa1tmWtznWW5MRAqbjqeVhLS0INMOo5hFXaqaUgrzZsqglUAlDqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4Bk/NVmMZ6hIgi0QUrRBH9jM2JowGgYDVR0RBBMw\nEYcEAQEBAYgJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIFXNlCYmYdiTj00q\ndM2t/kQygEM1Z+w+8CgNfdFtABwbAiEAxRMuiaoWeyDOOyLdbCmH3IBIyLssFW+Q\nkEvmHn5fqiA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8881", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8881` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAT9JXwz/f9YEBbk89o3hPVGzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUwZTk5MzY1LTI5MzQtNGVkMC05MGY1LWM2ZjQ0OGRiMTk1NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg2NjY5YzktMGEx\nOC00NDk2LThjM2UtN2MyOTk3OGJlYWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2NcFzY/Amysz86Tik2oHTSM4eZkj3Irhdws0bdR+knAGR2UHCQ9bjrbAJgbz\nLySXigSxgraTaiv1b8d3S/n2zaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUORpkp57HRJUq5XoP7pyeW+TeonswHwYDVR0j\nBBgwFoAUFbTcbRvfFpTaYLQORcxcMaBXpNQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCa/BB+UgpVMeFPWvJnIefgWgS3\nQKQJchAY7u0bmn227AIgdzrI6Ciqw7Hf6dX3CK5xTRAbzI+4JHINAcrM65Z3WZI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAba/nppBTvSX7rsbkRDgBXRCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMGU5OTM2NS0yOTM0LTRlZDAtOTBmNS1jNmY0NDhkYjE5NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlnigxRtoojPvjJjdAAH7bzjfS40rnr6IfGtFZYUFmGCgv\n6yvRQv/5Kh0uVKBn3uJ9LeNbsJZGuMdA2rX/P0VRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFbTcbRvfFpTaYLQORcxcMaBX\npNQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO/CtrWturJNnYlCUdpLVjSyavp0en1OH7TU3SHkV6k1AiBsVx0ZyRYn\nRoTpVCadHRIDYJ3DunO+AkZr9KvFZOHN2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAXLCOsk4CcgPc+s23wLa9m96MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg2NjY5YzktMGExOC00NDk2LThjM2UtN2MyOTk3OGJlYWZmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzg1ODhlNGEtMjgwMS00NGUzLWE2ZTktNDQxNmVhZWRm\nMjA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBHySqIW/pxItf99sVXZaAAzD\n+DH0UgZrJPK6kSUt7aRhI5MPUhK/ktCiZAgBYRpwCeRDVX3kmxf+h+TbT+en46OB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ5GmSnnsdElSrleg/unJ5b5N6iezAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22JDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIDG0PL+nK635BfaDklNxb9wjrF1tRi7IRHTW/9n3q+OYAiAfy9PBAOEz\nHMfNvSli5QPGYzavp47hfr1uUOhwNJmoFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8882", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8882` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAb9aOGkFBNbqtJRmKnpXbdd2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZDQ0YmFiLWM3ZDQtNGUxNi05MWNhLTc4YmMxZDhhYWM0MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDFlOTJlMTAtMGE1\nNS00OGQ2LTg3NjgtNTI4MWM1MzlhYjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL+Fm0aSQIw+gJ61vFUeOFE30gG6YtNULqVdaANI1J0S7FtoImBrmKGumJkBL\nvtoVB+hRBiSQr1VJf+hO0OlV46OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTcs70pa3930HPLpCSsgDvTQrhGZzAfBgNVHSME\nGDAWgBRw3l7LLtriRUrQr6C31D2lsVcHVjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEVBDrdo7lNFSf4MVCjZzaeAbEbmwkRg\noFiUi5wYStTuAiA9DAOU2vIk/5OnC6aps0LsaNmbsFP9a71cTqSg6KhX8g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXoa/N4w0Uzh+cynpmXTS57AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGQ0NGJhYi1jN2Q0LTRlMTYtOTFjYS03OGJjMWQ4YWFjNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBV1hRq3qMQw3gIVblI/oyXkzLLjJS6PmXuG2+2nPBxZFl\nWWQX7H27yELu2rNkRrWdWc7bfa5fWbN1bmc1X8vGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcN5eyy7a4kVK0K+gt9Q9pbFX\nB1YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP1AnbBOmT8zelFmz2CalBOiNQRXlVq/2mZ+2UNaiLjWAiB1HioCn7sZ\ntotOIP8bkDpKsyTx7uvE/O/KQ9nvA7u1aQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAdTPR6d1/Nd5RrEpb3tP2gOHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDFlOTJlMTAtMGE1NS00OGQ2LTg3NjgtNTI4MWM1MzlhYjQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjI2MjljZDUtOTViNi00MWI0LWFlMWYtZTE5MjgyODhl\nYjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfBH4FoMo7n2s/vPiwhirXAyQ\nOIYHc3qMdQ/bdKjJLI98cixUAtru2yXMNM1J5wb67HwRRXVBVvwQ1DZ8Fc3YWKOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTcs70pa3930HPLpCSsgDvTQrhGZzAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22JDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICktWlADpD98s/Nwj4PLiDUGGR1IBrbJOIozqMgAgHmEAiEAqUMC1/TJ\nlH+/r+33c+TWw2DFIDLAsd9S0u5WLYjmpIs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8883", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8883` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAZ+gunYYddx8ITKXu4CM8f5FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmZmU3MTY1LTU5NzItNDcxMS04MzdjLTk3YzI3MjJhNjBmYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI3ZmE2MzItYjMz\nNS00OTk0LTkzYjUtNzQwMzIwOThmNGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET9Z8n9wc2bXiZ3+Az83+xjYHTHFfZcYPbPg/01KrvIdzfT/tzPuILn58We4M\nZC7vdAu9RGGPfe1OaHCkVTybs6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhJcbd14/gJ0DRh4zRb/u7zwVVPMwHwYDVR0j\nBBgwFoAUW23xi4JDZqrdska3sHKqg3X92eIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCID4TrlFZmrkXHQVBhgvLOu5gw97m\nVQgt9qkHQKo16ZNSAiEAvsPZMPVh1q2LjgOa4OgqgVzQYhmdhi67JZFsCieA3aI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe1pbcR00kI2auSnGuwzaWQVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmZlNzE2NS01OTcyLTQ3MTEtODM3Yy05N2MyNzIyYTYwZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT1dSiYNtUIXEybZBbYJl0nYCLJBo4iKa9KHFrJ52TozNRB\n4t5ieixUDhvJ9O9yDMWPRAztsa0gbqlOWN+iWNCKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW23xi4JDZqrdska3sHKqg3X9\n2eIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKNeJr9qHSDxDlJJf4jXTB4/NtVKZwXjew+FHEIGWgN9AiEAzEjhETrz\n9q0vQTlEPJCrC1uJjRPTNaS548eFrl6W6BE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAemFFmVzwUZQF+4zvdYZ+zgGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI3ZmE2MzItYjMzNS00OTk0LTkzYjUtNzQwMzIwOThmNGIyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODU5N2RjZDYtY2RmMS00NTE0LWE0NTgtMzU5MDFlOGJj\nMGRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzYHr7bThO+D+w++sOMRLHwS9\nqWLu0AqkL/c7XfAEnxRG0q20VBVXTBFpw7maUUqnqZBQVy7tEJmqQSTrSgqJJKOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSElxt3Xj+AnQNGHjNFv+7vPBVU8zAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22JFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAg7b4i83S37OYtnxq59QloWZgXxdZRjr4DmhEfswqJHgIh\nAOaoZlhpab6012seQsOZ9d3Hc0gZmtcYstWInGBMX/5M\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8884", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8884` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXIHI8qwhmUVpDGb9DWzAKcqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0ZmVmZTAxLTJjNDMtNDAyMi1hZjM0LTFjNTk3NjZhNDQwODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM0MWMwYTEtMTUy\nOS00NjUzLWE5OWMtMmM0ZjI0NDMwMDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZqusxZHPcyLP/wdPxUYN+OP3c9OHk0HifZMGnf9mieNGykRqhbaQTeDTxgrk\nm23J8GTisJ6gx+L3gKsYs1Nc2aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTkMkK2ix9YumsdJ75R24Sr7vF/1zAfBgNVHSME\nGDAWgBRii+iQ9GCA74UCPY9ksDYxmKzG8DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDcUpomR3zhFQonj5SfI3f6I6rv7/K5\n+0hTrj7Quk5u8AIgCGiPj+wLUAqMgZglIYkxkgyq1xQudnz2ELMyiTmtQ1k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcwbHyz+9/tKDA8mif2g6oFfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNGZlZmUwMS0yYzQzLTQwMjItYWYzNC0xYzU5NzY2YTQ0MDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASq/8Q41a6AiYoGwjNO8cvL9hx4bKVMf613AzVxXdugthrR\nv3OQ9qGD6K1+0E1gUg031AyFFZEnaQWkyr6vquqHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYovokPRggO+FAj2PZLA2MZis\nxvAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGDadV4UPe4OWxPeN568oHtYNyD7p9260i+eJpJbMKZICIBau/K/poUpJ\nMEN7RWcxHHS420/M9rfxu/8mAJaUdRzh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAfZIueBiEuQ5Sv4fUJJFTOgVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM0MWMwYTEtMTUyOS00NjUzLWE5OWMtMmM0ZjI0NDMwMDNlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzBkNGY0ZDctZWJmNC00ZTFmLWE0YWQtYmRjM2IyNWQz\nNGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6NKNGkJuGJwtPp1FalBfWb2/\nzmWO0RKwU6vk3pQb4kvEoSRVlwiUohJTdnN5f8I9y3TiWBoJyRsLOvnB4JCppaOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTkMkK2ix9YumsdJ75R24Sr7vF/1zAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22JFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAty5uZVvF4R10+15Fn8Ox04B/rLRuvZ4PR7lPDBsJwCAC\nIBRySSp7r1kGRJHxPJZGsQc5dPx1FqoTXASgxiJrDbH7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8885", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8885` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYabyvX/fpQgwyP9iHlwYm7IMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyNGRkNjNmLWNkNzUtNGFjYi1iMWQ3LTRlMmY4NTgxYzIyZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWYwMjI2YjItOTlh\nNS00ZTkyLWE4YTEtNzJlZDYzODgzZGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkaJzDFbS15ZNIiu6qcSFRUPfIYA/p1+fWccDP7cc3J8/lmCnxpGNkm5V6uc+\nFLvRkkPk2nPLJvIvYbdApLPZ7aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk16H0Qdc+2uIkO7iJjCpMKn7Eq8wHwYDVR0j\nBBgwFoAUg/vlW8PoiigscvNWYryQv2RVCVQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICpBj3YJ+gotd1EEUTwE962Fahkp\nQFNREnLnZNOXlzIYAiEAnViF9XbyO0z77HV6r//nvrtOQrmS139L0WqTS35EWqA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa57Gp4A9yR6gKbpLuL2BwcMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMjRkZDYzZi1jZDc1LTRhY2ItYjFkNy00ZTJmODU4MWMyMmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/9W69xS6nQgEx8pe1ZWDV5qDMqz7ZTDYP+N61H0RnZvGA\nMBX8eEaOw1XAE0QynJ1fy8kRKgmdB57G734lQVo8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg/vlW8PoiigscvNWYryQv2RV\nCVQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIqbRInJQFTY/xffOEFDRVgDnHl3zHTTGmxTOm07lJjxAiBQhLfwsf0f\nQsVBE26hDLpGQ2mvE1b2CdZejIetP2rFZg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAah3jh1BzC2WtV3yLyXT3H8/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWYwMjI2YjItOTlhNS00ZTkyLWE4YTEtNzJlZDYzODgzZGI4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTkyYzQ2MWItNjczYS00ZjNmLWIwNDUtMWNkYTA3ZjY3\nM2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENUsZi3ZOEpAXPAymO8QbXMBf\nWT8DzWrnyLeb0ZtyslaZi/TQqJ+AX5cMviqL+eZfm4gJ0x1vJ7VEiqvAd8JRXqOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSTXofRB1z7a4iQ7uImMKkwqfsSrzAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22JFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhANktDi8+z+a8AZLVyj4lWWpRNbx+LVnY2IN3HR6Pgif+\nAiB0/ZwdjmQxBl22Hz9WiWM1DmFfB/5pmj+6CFi6r4CEAQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8886", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8886` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbcd9sOeJh8919O0iyPJEiVFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFiZGI5NTMzLTdmMmUtNDVmYi05ZWE5LWQ4NTBkNzJmMjdjYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThkMzM2NjktMTM4\nOC00MjlhLWFmYzctMzQxN2FiYzFjZDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEelyABEXQxqUSmIiUGYOE9M47lxM6lFm+OhmJ06VpPxZzfTnAvwflbRQZ8d49\nhwDHgM1abeJhcJj/7sISFr8ba6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRavLJTprfdv2VcZYKo1Z8nZZc66jAfBgNVHSME\nGDAWgBRcRX/VbFp438QE2gIOXohhQEcGpjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFS+TZHKqbYUdrc3JZPX+QbAhoCvaDV+\nKXYlwu8ztLPEAiEAhg4bF02SlsZlM+V+Z4pxb//euAtXSBgqgKwvK6OPXvU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcdDxTxFJ6DYUwZ8FbBq4CXJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYmRiOTUzMy03ZjJlLTQ1ZmItOWVhOS1kODUwZDcyZjI3Y2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9XJ/4v3XJvlQ/14wyicq27V0j/HD0WbrQKENFzY+2JVAp\nguVCWPNNX0ebc/A1ULs2yjopvLutvU1qSrsNm1QKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXEV/1WxaeN/EBNoCDl6IYUBH\nBqYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM9gD8wSPSFx2EgBvBfV9htjJNzUi9hNVD0YvXNpikmRAiAPa4x9l54t\nlltGRxjZjA2LuENM8VAprPRkJZxTN2J/OQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAdNFLMmacEPORfHZmkaTyZd8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThkMzM2NjktMTM4OC00MjlhLWFmYzctMzQxN2FiYzFjZDBmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTljMmJiY2ItZTYxMi00YjE5LTkxMTItOWM1OWRkNjY2\nZjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExAm5/awyMEtTcmadppilQQfM\nuQyHQFLe2kWG3v6uC2ljpM3qpmSn2O3jfXfIcGz7ylNuOdnRs+XYydTdGWEmF6OB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRavLJTprfdv2VcZYKo1Z8nZZc66jAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22JFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhAPLNlQuqJW7f6CU6VzViXhhvEdaDYz1S+Atd2uoliTeC\nAiAEKY3aol4zq+2EzeySShEnxyeTZPV57ZJD5JZUnxmWGw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8887", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8887` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAXZewURHJRMvhrPn8Jn5CQREMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4M2JiYmEwLTY4OGEtNDc3Yy1iNWQxLTc0YmQ1Y2IyNmQxYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY0NjVmMWItZTkz\nOS00NzA3LTk4YzgtZGUyYjNmYzY1ODE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEO5n1VPaQ2ySd8N4ACLIsCO8TIKOCx0uM/4V3Ed22xmN4D694I8kJB0BAZrGr\ncDT1SunTgurW/n9XeIPLWjKJqKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuBTMOsjr91G5SEdDzRAqYbFT/qEwHwYDVR0j\nBBgwFoAU4gOHBSjXgoQj3bBeTba4OZgdFs8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCk5vaI75+vL1PrWyBeEtF7Sbv+\nqNlEQB/B780ZQ+1slQIhAJvp/FgTl1zdC8E62VfipdKNh76S3KCdlAupS11KySq2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeEwN1+7ew/xjA5P/tJhUDM5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODNiYmJhMC02ODhhLTQ3N2MtYjVkMS03NGJkNWNiMjZkMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmRe7Vkj4uaWL2AYO/9FydceyeyOvEkR61KTg8Mby5j/4+\nA+iASz7vU4kaANPdMV/bvRcXIP1CPCK7dWZ8xdaZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4gOHBSjXgoQj3bBeTba4OZgd\nFs8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOtuJzpQKoHIf5aaQ/am4jpusJ7JH0+QD8zUkjXdUj/jAiBnliKghQk8\nlAvg4vGbYdJ67CdzFKj5VTetdlNX9HGxGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAdud1fWh1pVLPft/hfhRgcPkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY0NjVmMWItZTkzOS00NzA3LTk4YzgtZGUyYjNmYzY1ODE5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTUyNDA0ZjMtMGJiYi00NWJhLWJlZjktYmMyOWRjZTQ1\nOTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXLbbTwizCxMiQaDlBsmraMup\nksNiZueVeS9NUh3oYQUsVTrHDyHfJL1Xv0onAfD6TGgSMnBvxCRT0R+UwHLZVaOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS4FMw6yOv3UblIR0PNECphsVP+oTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22JF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCICwDEyc+rnOsxL4PgS7Lssuo2zoehBtE9otsBtB1n+vU\nAiEA0fbngsisr7r+BD1hj4KsX0pZwT5EptQk+a6FQucGnDQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8888", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8888` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAS3iW4ORe7HYK+MlQyNXs9rhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0Yjc3ZWJjLTRmODctNDZmYS04NDA5LTM4M2RjODI0NTk2NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ3NjVjOTItMDdh\nZC00NDQ1LTg4OTgtMzRjMjk2ZGE0Y2E2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzXLzL1FdJQPcjiliDLZD+gluBJT/+9KWVfRIRlypQhpliAtJ2Ac0h6GabA6K\nD+4FjpNA4MEXc+vkWUr5l4c/qaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSrk2LPVz41USnV0gCQXnp+QIyWjTAfBgNVHSME\nGDAWgBR0Xwz4PLHmfFSjpaJdm5QUnqNCODAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD5qHlN91Az/DafAKoVPvCK4htu3BCS\n1LPK1cZqzRlflQIhAJcH+GZeBMAg67F3o+jRo5t4sXdzq8VjiklAt+IlcBEg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS4EDTla1zji+K8k8V09UG5dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGI3N2ViYy00Zjg3LTQ2ZmEtODQwOS0zODNkYzgyNDU5NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARhKwIdThtnwgPPIh7bHI1U1zyuaMepJ957BY/r5DU9ZpQA\ncbmCWr78GhMtjpreOFokaaCIn3q6tfnZ/lzpCe3Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdF8M+Dyx5nxUo6WiXZuUFJ6j\nQjgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXBN9Ga46nQVcl8sqWk2IlQy1NaOZi/QUuCZsQd9+GnwCIQD6jZdFSqNY\nqJJZmGFvbRMysc8ZjhXq5dodYYZFsigHqg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAbtEMG5qVOMfXPY9frZEbXuFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ3NjVjOTItMDdhZC00NDQ1LTg4OTgtMzRjMjk2ZGE0Y2E2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTUwN2RhNmUtNTAxMy00MzI0LWExNzctMjE4MGVkMTgw\nNDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE87fVKYXQOlAJMCcZ1TtXRI6S\ndBxH+h1gnkd+nvNKv9v7LUCMASzVqqx8ejkV24+zmg9rXnz9tIyuLEt3Fuc96aOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSrk2LPVz41USnV0gCQXnp+QIyWjTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22JF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIFxuPDZtHwj1jEfksLVZZqAsl/dYve1vtumy9U5HDedJ\nAiEA7/DZQxGrdU0GhLwlo+o8LdBtcNBQcLR3VrXv6daqm8w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8889", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8889` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQG+dCSV7I0l/aGXPXP5fokaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiMTY4ZGM3LWU3YjgtNDg5My04YmVkLTBmNTQxNjJiYmNmNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I4ZmRkZDAtYmZh\nYy00NjMxLTkxYTUtOGYwZmM1NTJhOTM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnsKWW8jEzfAA72RuRaXkDNfdMGwxJq2XWnE6uaYAwNFD25WOEv1XtsRmm1zH\nBx1d71iInKQJOmvJf8KCxK4pDaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsCznWR8d7bcm6TCqQ/xn8maRvYowHwYDVR0j\nBBgwFoAUJYgwgreAl34WRQ5O28W+9vxycDswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICe6Wwz6m0l9RmXIZ+3tEBV8t2nC\neX52iIPkyQXKZQckAiEAnhhwaSUbUQrwQm0P3Ja+E96kUDFplHK8QaIFJ0OBKVM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ8yViWfSgfVkLlbn8s0GI2WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjE2OGRjNy1lN2I4LTQ4OTMtOGJlZC0wZjU0MTYyYmJjZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARFADzUExbprQTfCKnlYhyZp8is/P7b6Vz2BDKO6F0S8bGd\naNVX7nAglvDpmdoAmu3Bv0KHKP3ZLRsDSyaPXGqgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJYgwgreAl34WRQ5O28W+9vxy\ncDswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCFetl9SduiRtKfevxrb6BHnqCQih3ESaSGdBE6G0vXcCIAH5VGi7BljF\nW5f3MbcsFw+H7IyRWVFhMQ/InBJl/BFG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISAe2F+s55sfl5IL+QOvZE82roMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I4ZmRkZDAtYmZhYy00NjMxLTkxYTUtOGYwZmM1NTJhOTM3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWRlYmQxM2QtZDJhNC00M2Q3LThiMzEtZjgwNTc1MTNl\nODJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElI4cm7QhV/hOdDw2DrNH09+/\nR2ilLkgi7CyU3ahBTkcg7ln/R6LL1MdpKm5FWHlbjzAPqtnRifiQN/BCsN9LZaOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSwLOdZHx3ttybpMKpD/GfyZpG9ijAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22JF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIHPx9UTugS7IIQzuh6f1gYjkhC1rmkiC/zd/sZShgQ1B\nAiBF5jbmty6PjSNPPDU6XeiqEfRgJpKV9KNPCGS30Shm9g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8890", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8890` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVMrjVCjjN7wu8E8xggQvf1XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY4YmZkNDY0LWI2ZDEtNGE3MC1hMjc0LWUwN2NkNzllNDU0MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVlOThmMmQtNzE2\nNy00MzI0LTgwZDgtYjdhYzYxMzA5Nzk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEarLj1GsBzbBW2OBpanr0u4HfPKS/ZoLJepwFgchOeF2JCX/lOt3ORqyzCThz\n3ophipxY9JXdOveoIMLfKoSW+6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ7pImtb7KYEHl4QFF0uWVjFKqc2zAfBgNVHSME\nGDAWgBSCzWf8mvgwlxmm3cCahmKR5VAm9zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCpGQgYoEzvbmQHRzaOgUoT5UJRAtIC\n3cu0kKq3+LL9wQIgGXKdB2HHjo3HWtohe5gmHiUzBi7sjwvbm/9c9yutulU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdn//h09h4qctJ2OtW4omjZLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOGJmZDQ2NC1iNmQxLTRhNzAtYTI3NC1lMDdjZDc5ZTQ1NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ51wjsFqDHIsadbXM3QpuaNAvhOwQW4grAX1wx6DCoQv4B\nJYt8O5glU8jPhlGKnH+pDLpk7eWlyZ7wtgKujZJuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgs1n/Jr4MJcZpt3AmoZikeVQ\nJvcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSNZEFDsHVwMxuLp56K8e3PoANowfDvUdSl4mVtKRHvoCIAm0x/hPu+1h\nm9rBTukdjn04i1+Ym96eSQRMKyRICPuC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAaSR9DILuPdEvrL1zDaAoxQ3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVlOThmMmQtNzE2Ny00MzI0LTgwZDgtYjdhYzYxMzA5Nzk1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjg3OGY2YzQtYmI1Zi00NTU2LTk5YjEtNzNiZDI5ZDA5\nMmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsXdoxHROG49x/DjfNG32a/OM\naaK82zJo0ZYW0xz9vF33G0elBygs+9AAP3uDQFOfvAvDLEBMrzOoiACv6Fk3IqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ7pImtb7KYEHl4QFF0uWVjFKqc2zAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22JF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIFgS34javeznvxc28x+csxTq810P2wTats3ZQ3v9UQmo\nAiEAvJ8PYjbEsAlMQDNJrWM4pFPT2BsesmeXHSvgS3nvJrM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8891", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8891` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAav9u5GhCf93sAvTXP/BcEsfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhYzRmNDIzLThkNWYtNGIzMy1hMjJhLTE0YTAyYTc5YWFiZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmYwNmFkOWItNzhi\nMC00YWVkLWEzODEtZTIzMDc4ZjY3ZmNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+rsT7OPbki2+6VnJcNBxxl8y20UXXzBTmRpkuVKmEexdbF//KunPWQxNJ6sY\nA7OjCxxILS0UYPqu5NIEsXHS7qN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJqeYsnTUnlu2kRiPNRhynHo55WlMB8GA1UdIwQY\nMBaAFMOZg81Ld8OQexLCMQkApzZJsaj0MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiEA+6vPJIxZ5ticwrueOHATPtH36d7++bzj\nZrywXYZwA48CIF3240WCJZGVCsmEGPF2EaubLARu4KU4Ln4qywgWfbwN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaWMuSAd0++dPgugDE1Dq3FXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYWM0ZjQyMy04ZDVmLTRiMzMtYTIyYS0xNGEwMmE3OWFhYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhIVpbGeP7yVfPxeuPd2zK9fHtDxY+YUUgS9o+XbbK2nuN\nd+mOgxx852kuF3aM9jnOmtcaN07QhZysxVf+KCAHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw5mDzUt3w5B7EsIxCQCnNkmx\nqPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANMHgYyAtjmPxPOdpbSA00HolDRd8QbyxVtX4b6JeK5rAiEAvKMcWgCF\n9LHMD1WgUfJd6S3ZIUJ5KGRaioc7fxiuHt0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAajDjT/qTsFIcYzowwFtGOnCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmYwNmFkOWItNzhiMC00YWVkLWEzODEtZTIzMDc4ZjY3ZmNlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzE3MGMwZWMtOGQ1Mi00ZTBmLTlmNmMtMzYzMjM2YzFj\nZDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB9v3TWAAzBDDt5bJgXlY+uy8\nvbEc7CT/BLJVcavDwzfHF6rLe6JPNvdLOoP2lqwouvFKL7pt5RxPXhngKAPMV6Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmp5iydNSeW7aRGI81GHKcejnlaUwFQYDVR0RBA4w\nDIcEAQEBAYkEfwAAATAKBggqhkjOPQQDAgNJADBGAiEAuBwOihNIJAOyeNojIxBO\nA+lKbdeTUAsEn0cZfQPbD1oCIQDsnNgPKR7zYQtG1+OHc2SnR3OLwWj9dGpRM/9D\noSzsuw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8892", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8892` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAY9jrMB5g0SO3IoctGoRGMi/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyOTgyNWVhLThjMmMtNDNmNy05NWQzLTAwYmJlN2Y4ZWFlOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ5ZTE2M2YtYjE3\nOC00MzIwLWJiMmEtNDEyMGUxNmY3Mjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEevViTcVDd959+dv+YQA26Xng4CgCGN83YH454BAJonSuL51gU103YpuVd44Y\nEsWwPoCge6R2sAdgTIoTcsRaTaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFEG8t5WivFJvsYyjGf62RgZl5zKwMB8GA1UdIwQY\nMBaAFDEDjO7xYxkD2xWkFQXtUVy5gGZEMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAsAHvOvm7OjconIoCpuv5RSaeES2Hq+acK\nYsnCo9tSrAIgKDyxJ1qpnjXYgPIZa6fLgih0WAKUoVNkubbz4iHASCs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcugAwIBAgISAUXy19guXfBVOdiyJ3kJ+1hRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjk4MjVlYS04YzJjLTQzZjctOTVkMy0wMGJiZTdmOGVhZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmA6uZtAUTmuxgI8ZIA91Uu7/lwJEOl8iOLhSUWebCkZBe\nVU2Cj6OnfVoJnz/7z+facZg0/1yJro6+p4hhROEgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMQOM7vFjGQPbFaQVBe1RXLmA\nZkQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRgAwQwIgYUuFBPkIKnT7hi1Js/CwTRdWse6SlZcx87XSn7xRO60CH21glk15rDWU\nutFZ50/nP2e1tKF/xLf/tLUmjPYUhc8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAWVNYXN7B/rKISi8PiJIulgNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ5ZTE2M2YtYjE3OC00MzIwLWJiMmEtNDEyMGUxNmY3Mjk4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGFkYmMzMWMtZGZmZi00OTAzLWIyZjQtYjBkODgwZjlk\nYTEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEd2Yu3cbCb7aWExj4klBT9Gd1\n+8yFWZJTX/ELwGksYfik9EjBloVFRIhg2E2mWP5Bqzib+PqUIQ00KB7GeAa7mqNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUQby3laK8Um+xjKMZ/rZGBmXnMrAwFQYDVR0RBA4w\nDIcEAQEBAYkEfwAAATAKBggqhkjOPQQDAgNJADBGAiEA6UNgIWbDhPvCpq4gGEqg\nOgWbF/fZC35Q+R14dUlNk4cCIQCctj1/826mlRXp4TpxdVMbl9o8ylwMZMDnqO2u\nayGOSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8893", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8893` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAexODDUZ7NExuikgNUkbb7p0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI0YWVlMzQ4LTJjNGMtNGQ5Ni1hZDM5LTQ4MjdiZGI1NjI2NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTkxN2JmOTAtOGQ2\nNy00M2JkLWJkZWQtOWIxODBiMjc1NGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6J99L/atigV0lkZmQ1/Fq+M6/xEC5Y7+TZb5LhBbJt+zJkrrC25wBdQGkyMG\nNqQdmJdaWyICHKUTfczG1DJA/aN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOrWdwfOeAgmXcgEhHuMGaHO9hd1MB8GA1UdIwQY\nMBaAFKfKLDZHAdNjxblbt9CCx+NGmgNMMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBgSS47yNKYwd1tHOfRKKoID2skaDQM8ji1\ndvsuh3F7/wIhALugBtERQgJgOLKySAEor5eH/H4uoNIisSz1oFbpv/vM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf+VSgFKuXd8T47yxRLtwk7XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNGFlZTM0OC0yYzRjLTRkOTYtYWQzOS00ODI3YmRiNTYyNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTAX8e/29E2A271lh5RwiOtIFlLdEkIGh65GlkGDzbORf6\nurYEqaKrgxcP6AZ9/t6ua6ckhdbbnkAJ6aj+P0dyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp8osNkcB02PFuVu30ILH40aa\nA0wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgH4F6ClFAAeSZfKj0OTUsiGvKgkRLDyrUbSLfZ4MhcxYCIAfDAOzdRyvQ\nRe2FdOHRn5mmCS7CDsDkNw075peKCxZi\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAZLq397+fwdmu7+S3XMeobgPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTkxN2JmOTAtOGQ2Ny00M2JkLWJkZWQtOWIxODBiMjc1NGRjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzhiYWIyMDYtZTIyNC00NGY3LWE2ZTQtMGVmZmZlNjFh\nZjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcROFdI7lk6+eC3DmZjhEcevk\n3vAXTGUVolH4+7PWYcI5a7hWqWnmXgUGf3NVn4hm51F1ESRYu0v2Ueuvz8N2EaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6tZ3B854CCZdyASEe4wZoc72F3UwGgYDVR0RBBMw\nEYcEAQEBAYkJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0kAMEYCIQCSSJRNq56qaYA8\nmsJsssFu8tc99Lu7SJJjt5cWD5l8qAIhAOlouz9+ZMarPyMCAkVVNdDcWHPq+nwl\nQmnUOsmMhwaQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8894", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8894` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAQzeEpC6WDJ7lvoDD+xkFrG6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4OWIyNGY3LWY1ZjQtNDhhMi05Y2IwLWE5ZGYyMWFjMzJjODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE5MGE1OWMtYWI3\nMS00N2FlLWFiNmItNzRiMDMyNjFhNmNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzQQIj4gSya19yksoF8VliWyuOC7dTymmsOsH/qml9Hf0jDIfS7MXiOM7AbMK\nzo/2ZuxxO3OcFPZEmRcyhDgDB6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFHNR8CZEskwN5Zq7dKmsl8MMlKSEMB8GA1UdIwQY\nMBaAFB683PaAsUuPpoGTI0RMUm7LCukCMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA9axwFRoD7JLUP6mPAQnTPN9UT3vpKCug\n9adFdU4e+lACIQD/lv9j74FsM1D9l0bsk+ewrTNkCcg12JOo21hgBsTrwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXxFaol/jQEU1+SNIcCLZosaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nODliMjRmNy1mNWY0LTQ4YTItOWNiMC1hOWRmMjFhYzMyYzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7Xshowpf2XKSzspAJgViro+CYFUsnJZo308qFQIYDWOxt\n5yx4tUw429v4XZB22dYuT1oy64RbHBtK/Wc1/wR9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHrzc9oCxS4+mgZMjRExSbssK\n6QIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXYI6SBXNrnL7K7mVCQluBwVtT7ugRizDzzuaizrwev0CIGyVMEYdqfcC\njcgoT6XrvupRJLRUolB7EeFxK8KlwxMB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAc5hLMJNfoJ7e+OmqY04YgzrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE5MGE1OWMtYWI3MS00N2FlLWFiNmItNzRiMDMyNjFhNmNiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzllNWJkODgtNmY1NS00OGMwLTgxMDktYzRlOTNlNzUx\nNDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8gVL+7+8uiYfUL1sp2h1xcAe\nLFOnU1cCNJp4t8vIDI+ns6pvUKaraB0IR1EdTVsd2RBlQ8gP8kxS6eYtOPT7JqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUc1HwJkSyTA3lmrt0qayXwwyUpIQwGgYDVR0RBBMw\nEYcEAQEBAYkJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCIHbVjMVd/Inqfsff\nepxc+d9TuSa8VVYnjZOCpM0ggUmoAiApWgE9dXNfOYL7ORnBURFjoOEXcV5gnqfy\nAxBcj5o26A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8895", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8895` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATTKsKAsRgR9wvAvrZu6RSKoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5YzFhNzBhLWE1NmQtNDNkYS1hZTM5LTFmYjI2ZGJlZjI1ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmE4OTYyMTctNjA5\nMi00NjM4LWFlOTgtZDcyYjU5OTY4NzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENxyIzoQW7yjPY8TH6/vdVpjH9Je/CzMCOCX3sQHMCJuRuCu3B1seEDp171rL\nmitzT2w4BUelPj82VybQdcyOsKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoBtJxUCZ6Du1lxGkeImL+EGwiAYwHwYDVR0j\nBBgwFoAUTqQJW3XJ3+IMYzWNIYOir3XeqyIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHDgPtNSkqfzBls85mD/BadXReCF\nJbXihzzfrI3FJl6uAiEA7oWS+mcMCLoXG9jQ1N385cjMDdLdlE7OXILzFmnJWYo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATEWCyrJS8kQKGBXwQK7ccLKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWMxYTcwYS1hNTZkLTQzZGEtYWUzOS0xZmIyNmRiZWYyNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR21zwXH/xBnPKHtH6YRBOsJhVwaiJ7+t29FkXL/tsvhnjv\nfVzfUXmaExEbLvaDO7haBh4QpqyJ2ipCVI75pLJYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTqQJW3XJ3+IMYzWNIYOir3Xe\nqyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgc/mErXeP+Ahz6AIPvILP7xSRo82NlL9Jy/dzUUrBvSwCIQCXaKlOSaiQ\nuXmWbbZD1LMAPDPvChEjoTDLsi2Zgi3LsA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAXEolH7Mup9WzP32p4uCbzNbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmE4OTYyMTctNjA5Mi00NjM4LWFlOTgtZDcyYjU5OTY4NzM5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2ExMmY2MzYtMmQzMC00Mjg0LWE0MDYtMGMzYjYwYjU0\nY2MzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESDR8CMqlFjZ+mksYkA8S8x+T\nhsw/+vI7+lxDNNny1x7cN2mbm6JhibrSMyTKtaao4WRSrSzKMm7ZrjAOJ0e8v6OB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSgG0nFQJnoO7WXEaR4iYv4QbCIBjAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22KDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDIJ7A++375hgsWYkR6sWuMVOpHhrUdUWDTnmdnTlMHQwIgc2/unpG2\nIo9vNoCOny+bg0S62KnMT2K14RidwmpLrGI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8896", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8896` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWkvUVjEnucdIqVI8EF0Wr2VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZmY0YjAwLTEwOTYtNGU2ZS05OTVhLTNjYTUyNmQ4YzkzNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjJmZTEyOTAtOTA1\nYi00ODc5LWE1ZmUtYzMyOWI1M2M4NGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd/PuUqPShSjUCcMrTNlH7P6U1JGVpqK3QTkMXY4vMrEB3blmsstxy8hlTIj6\nAK6sdo571PdnC3AfxXzjzd5MO6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR+nH8QchvxA3KRJsss64AzrBj/TTAfBgNVHSME\nGDAWgBSVtqPkWxBobf1kHdlgtC6Zqf8qUDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHa9ouOZomGBWDHRelOZPjUR65C6D5bB\neGb3CiBnmZL5AiEApkUZXDN0VGdtk7kpxylq67JPav2Db3P7f3i3o5eztxI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe3tlr9BLiKCW4InTfeelWikMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmZmNGIwMC0xMDk2LTRlNmUtOTk1YS0zY2E1MjZkOGM5MzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8L+2DT555G+dRPgvXod1YivhFvVqx3dPKnLoUtYW4mBrA\nKrvVmv0b7PWnwmoNvMtrfpjElWeK29EPOXjWty5to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlbaj5FsQaG39ZB3ZYLQuman/\nKlAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP7flLp9lF9ZbaHmdxqnteVwz2mQU4TjL/s+bBAqqNRuAiAG0A8VVn9N\ndmuxh50Z7rWAsxRN15U04N95a9CpdzvZTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISATqvewyfBX3K0qSlRxZ1pGIjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjJmZTEyOTAtOTA1Yi00ODc5LWE1ZmUtYzMyOWI1M2M4NGI0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDI5NjdjZDAtYjliOS00MDY2LTg3NjItNzdlYzU4ODQx\nMzg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELW3HBg39vWflzSJyIx90dJCB\npcRsUe7ETVBEs1gjILF2D42Y/TaEQzJ9jRhHwae2vqSIOmAzBgXM72NqFrNW6aOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR+nH8QchvxA3KRJsss64AzrBj/TTAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22KDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIBYGhU/NeI7OAGKzZfB3cMD75K50ptJlQHyJr5zOjZ7GAiEAxy2JyEol\nmEx1vYWk4AtXVeDyWu/WRe9f+8Zd/lqI2T4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8897", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8897` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAZyIOVCE3h5Nry8PNtDnpCqlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlN2Q4YmExLWEyNTEtNGQyZi04MjgzLWNmMzg4ZjU0ODhhZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjkxZjE1NTctNWU2\nNS00OGQ0LWIxNTItOWVjODAzMWZmZDhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERzScbYjzI7v179RI4F3RFVWmUH/HOSlgzWhJIuV1DqvoLyNMYN3+sj4SmPmp\nxbJheQMLMCm26yYpJa6I39CpVKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqdB1rd1C1/PCOt038eRIbVDSyVQwHwYDVR0j\nBBgwFoAUDi4jgXNs1Aq/PosUTDvG6YrsTSwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEjVMsKGDgacA4i7aLfF3Da67FTk\nLreNvxwhUhNWSkeGAiAO0EHK997PZNMylKjlafEXsR2bXkuW/RKztkJjoIaGjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUGJ5R7Vxk6f9ZlqbSiIcllfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTdkOGJhMS1hMjUxLTRkMmYtODI4My1jZjM4OGY1NDg4YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzZh6L1VbH7JGyf7Ij23UK22W/I5WdtF0eeXExI53GZzOd\ndjuwufmewtCjqHIjwdLE96GpX/At/FdW76TOqmizo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDi4jgXNs1Aq/PosUTDvG6Yrs\nTSwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOaftMe6ndhppVuCQrWh85EIGR8tY28ITH846s0Nte1HAiEAqfRJb+9S\nyJbNQEZVY/P+ELeJ1fSiFO413pZPWgnLgyA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAfT6973spnD1hufhlyXHUBu8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjkxZjE1NTctNWU2NS00OGQ0LWIxNTItOWVjODAzMWZmZDhjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWViOTUwN2YtODhlMS00NmYxLThhMDgtZjg0N2VjOThm\nMjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqN75zMeUeb/iy+BMCTlb4QCL\nxhFtz1w4uZszVQlpRCFKfQL2UWSi9Q6gfOTXr/WutYUII3pQS6y+MaKhnl0dtaOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSp0HWt3ULX88I63Tfx5EhtUNLJVDAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22KFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiAk57wmyOWbGeRW0T4g1pxJ9GHS2yHGTiHNNAwYDuyydAIg\nG/VQW7HtqOTODX6cdUHcYFd/aA8ji1civHpMYV5xlH8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8898", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8898` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdMbjFXEmAmX+i37RUT68p2rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5MDJjMTk5LTQ0YmMtNGJmOS05YWY3LTI5OGExYWExNmFmYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDgyOWU5ZmYtZmU1\nYi00MmIwLTk3OGMtYTk4YmFhNTA1NGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETnLAC3zlSCmFIcn5Bi9EgkfjZZxhYkpsDVALhXZJfijcSccvisjyQzYGcNiB\n9qD1NHEzaI8eNM/rq8TEPZ+cW6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSSqegxqD+IESk++LYWAadmLnbecDAfBgNVHSME\nGDAWgBQtVoejqM+JiiihdW679NppSef/yDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDYrlYSEgQ4qG+NP8iP34N2CgFtUaHQ\nr4heo132fMjHsAIgb8ZJWCetvgo2UsXkuJeolUagA3r2enYOISLqkM90kYU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYf1W+FzgaqaUpFvFXyEb6tNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOTAyYzE5OS00NGJjLTRiZjktOWFmNy0yOThhMWFhMTZhZmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpi1igPuB+s/Wzq44WMnPSaid31dpCbVtSoIKaw5PWhi7E\n1H7sIeev3Q0BFlChATs90S3VggKuZNki9JozMddNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULVaHo6jPiYoooXVuu/TaaUnn\n/8gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANEdZAnTVtiEVuyM+uWdDCiT9RGhhIk1ZHA3D1qe10D3AiA++ia8FFeD\nP+wvgvdARNsoVnnvz403UnxhgKcll0yuVw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISARjd6gDz5OyL+B9RGZcmWbIMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDgyOWU5ZmYtZmU1Yi00MmIwLTk3OGMtYTk4YmFhNTA1NGIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmQ4ODRhZTgtMGViMC00MWNlLThkNTUtYjNjZDRlOTU0\nMjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi54CMNumBk9xrrExA0nfadHJ\nmhhz4abeuXcMXUIZUYiov1t/t3ucQYgaocRgBySlrNYs1eKoJILfzdjZzW5TdKOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSSqegxqD+IESk++LYWAadmLnbecDAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22KFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAhfHyUj7IckTc4cE7D7c2siJDuNRX1MYW/gldclfqNccC\nIBwotmiaGxroHKVZblQP9G7DE4iWfi91SPzre7omp0uv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8899", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8899` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAYPrj7L5We3NMUeav5diW3y2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwNWZmNjAzLTNmYTktNDI2My1hMDNkLWYwMzYwNzFjYTIxYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjc1M2Y2MDMtYjc5\nMS00MGQ0LTkzYzctNWFmYmZhNGI1MGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkQVH+2aDcDlE6MPrtHFMMyMIGWdB4ImcsSTpqcaZW75AESr7iwx/S0mq2TSM\nDFhGGLDnXusmVfRZF5haxtUyW6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcyNO0k7fOPGGiz8hz3ZoAAkbcGcwHwYDVR0j\nBBgwFoAU/YO9ov/g98awhzxttdSVf7tAuJkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCSvEVG2gojNsA2jBLO/4ipTy0F\n7UsIrDc5a+LlXtEnwAIhAOs9HItN9gbTDFSM+gWHecVacMgaPGOcmselY6xAUAjR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAStdZnD7VNYT3YF74OEPi1PcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDVmZjYwMy0zZmE5LTQyNjMtYTAzZC1mMDM2MDcxY2EyMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASWHl9u6lYYQs4xHLBpMw1l1fZO8jamw/B+gU365xWfG3Hi\npIVFvtwPIqGr6AZL44M1HO5ElmrUl+kH06cPtaa3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/YO9ov/g98awhzxttdSVf7tA\nuJkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAORk0nsNpjLi2CGIpJdth7/5+aa2+8ckM4z94neQ5blkAiEAsNTK8wUK\n7CeNfJ00h4JHHNI5ypznqGv7InuKlJ7cAHc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAejaAkaEbnGSSXqnEnMW1B5KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjc1M2Y2MDMtYjc5MS00MGQ0LTkzYzctNWFmYmZhNGI1MGMxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODBmNGQwNzMtZGY0Ni00YmM3LWJhMGYtZjBhODNiOTky\nZjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMJEhkpwSfEYWMC+isLwKZ0+l\n3JAZdKLWr19EMYeqCbtMgPqdCGvQYe6Jc6/lN9/fj6Wmbi+yqsPFQsRXejHoHqOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRzI07STt848YaLPyHPdmgACRtwZzAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22KFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhAJ5yysC39DDV0SRMrYuIQ7XGgVl1v9MtsV/GhkW0hsOo\nAiBRFue7qp6gYcdN4jLBvSWZzLYfLgcigrQ7AXZTi9tFZA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8900", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8900` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAU5lTjfSqs58f0YCfvmvxQq1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiNGZlOWIxLTVmNjYtNDExOC1iY2MwLWRjMWU3ZjUwMzNmNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjk2MTRiOWQtY2I5\nZS00Y2FmLWE3NDgtNzcyZWZmNDYwZWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI9bvVjg1gKV3+5MZ3RUnfY7lAvhyFjFuP2ao+tD7Vj2rfFTfvH9JoVmHjIEu\naGGDLUo6lz0to4IBf5iOvvOyK6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSiunrc76JzPuRtbU+7dY8AoxttrzAfBgNVHSME\nGDAWgBSfVnC9yxKRY4nMMnMyHauohBTaODAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCEr8WHtkXu6svZ+iyC7AITfX0P9iNd\nIfg1Nmoz0a4sUgIgL54lBs+W/IrPDQSpYbdP12/fLYY+XpzDD2ZMBT2e7rg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZiBHgQXa9gQgAb02EbGlIO2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjRmZTliMS01ZjY2LTQxMTgtYmNjMC1kYzFlN2Y1MDMzZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzCJ/FHOGwbRZrXv07j58IN7NjTBZWdnHYI7N1bNwIvShe\nVb8l9jr0nhFwWrdi24xpXzFV/z/gj/tYkfC5tuOGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn1ZwvcsSkWOJzDJzMh2rqIQU\n2jgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP/tlpjJxa5IzH0kUuI2oFdOfyF1cfXywH3FyTRzHDwuAiEA8/am77lj\nVfimgCL1o+j9yJ7HRH51GyBxWYycn9U8fz4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZLAy/+s+ck6WZp2w/sbv3EVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjk2MTRiOWQtY2I5ZS00Y2FmLWE3NDgtNzcyZWZmNDYwZWM2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzJiZGNhMjYtYzMwNC00MzQ4LTliYjItMjYxN2Q0N2Uy\nMGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL3nY7XwxtV1zZBoGajFv2cS0\n2I2qumzuAM6DW7wEH5VuradAkEtDI5L566KAtRV48pCITFw54XNFh36dUGZqV6OB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSiunrc76JzPuRtbU+7dY8AoxttrzAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22KFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhAPPH4Ix0JT7VMEgackmzge3/O7GG2SS+TeeMOCQ7C7ky\nAiBX97gQ4AWq/fzLpgw31vlz9VQQ92lEy9okjlTXrXo70Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8901", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8901` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAUUQgz9zwcb7ik7cIySZCIR1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2MDhkYmU4LTczMzItNDdmMy05YjA0LTdhYWJlODEyZjZmZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ5MzNkYjMtZjll\nOC00YjI5LWFmZjQtZTdhZTA5NzJiMTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJ3Uc8PhUoOgK/1avzALRZTPkbHEAK0XtodgZogwuHP+oKUqiOY37+D6Quai8\nB89yU3nL6mzj4EjH2d0qPYq0h6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaLY76F5L3432uezvzgaUjAa9VYEwHwYDVR0j\nBBgwFoAUEhJp7qNK+KLJprFu8Fw+Dbc8H+YwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCxy3gSrIb39WMIUVkA5zD3fkOQ\nJw3ZCxF898m5wyK1KgIgDvYXBdvjpPSJvgR5viHv92wRsGtc9HmgJtgxPgYs0ME=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASPs2ipjsGFVlpIpliOBzFpdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNjA4ZGJlOC03MzMyLTQ3ZjMtOWIwNC03YWFiZTgxMmY2ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASiPSLjwMLyBbu/SUjEEATeTkR00c7LgPRRF2qhnjuGzsDw\nkONWE780/TGaHAtREnVOk/NLl+j7nh6Gvtrp2VCBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEhJp7qNK+KLJprFu8Fw+Dbc8\nH+YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOygQA2ptf9xIsWyIil8atjyaClBI5I3H9IDLAVa+/XQAiEA4cqwEgL+\nb3vvTrtuMOty+AQJRTtrVgvMPQ84G5oVAGA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAWRbBwcFpWUXLvwmTGhvO8gkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ5MzNkYjMtZjllOC00YjI5LWFmZjQtZTdhZTA5NzJiMTgwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDM4MDgzMzYtNDk1MS00MzY5LWJmNTItNDYxOGIwODk5\nZWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEd7FrDEKK/aZqldV4W72YtFBc\nvNf8ADUnlDNomDis0OZZWaS77qdNuqTKttFN1FtrnJv9c9WZe/5rVI5cL3aEXKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRotjvoXkvfjfa57O/OBpSMBr1VgTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22KF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIA0usHEUjS3P2HaFPSqCFaJ4Qtg69hVDPf+RhFkuzKHy\nAiEAhbcX3Y3jY5SQl4jBedNm4uZww52+RmHqf3XYBbnm1XM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8902", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8902` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYLo3G/Q3pPuLaO6yJpXh4HGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5YTcxNTY0LWI5YzktNGYyOC1hNTg1LTU5ZmNiYWM4ZmRkOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU2ZjNjYmItN2I4\nOS00MmRkLWJjN2MtMmQ0MGVmMmE1MjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYka68YOgCX1w4OPftQlhmNkJHwyl24JtIoQusObKvJBaOtGJLn2xUGkJjCdD\na54xjh2bS9DuEZCrbK6DRmIeDaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTQRRESF0Q9xb1gWphwHFVj9nhL5zAfBgNVHSME\nGDAWgBQyihS3S/r/pH84V+1ATLTNGDdvTzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC15PR7yfVA2USjtCpUE1VXcM+iTpUf\nWBjm2pPmY9Ag/wIgQGvWd0Fulus1d7Lv2aAn+r7ItiuSOdoQpWDIWSOpFD4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU9Xk9OF9pm1x2cYJFL0+mhaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWE3MTU2NC1iOWM5LTRmMjgtYTU4NS01OWZjYmFjOGZkZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgDE9qA1iP8sWcC/ix9heakGXrEfgdOC6AcvWeEbCjY9c3\nd/4sOOEN2qoUSt/jn9IRBV4fQ8wVeG0dihxW3QI9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMooUt0v6/6R/OFftQEy0zRg3\nb08wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPV+Qn0Omi9DtS1p1LS9rWj4BD6Qt9LCRvrT4ZpZkH/MCIEXVWRaJAGeH\ndX/GiF3b3tHR0KAdN+VT4FjGnU1gqAIS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAcZ3Pw4MH3elsmyJ8gdPZSh2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU2ZjNjYmItN2I4OS00MmRkLWJjN2MtMmQ0MGVmMmE1MjJmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzAxMzkxYmYtODJlNS00OGQ4LTllMDEtMWQ5NTE3Zjdm\nMjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2MUPmFVEnEDdJQgS1CyI9UIG\nFOzAWoNtRaes+kHtzLLF/6OfwGuDjRt8+JAbIZ+mNVlN2Bnj/YxL5aqdf+tPj6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTQRRESF0Q9xb1gWphwHFVj9nhL5zAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22KF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQC9p0t6oqWqXDriENFAHMvgBJ1o1EMQH+DsltLwsg+a\nwAIhAP3hIJ9luspnTvOI7ATFhUbaBDpzfcZhaSh5V+XJLxzz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8903", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8903` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAcY72WiEZpfQVGMvnRKZOTJ2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjYmUyMDkzLWUzZTgtNGE2NC04YzkwLTJiMTBhYjA3MjRjNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzM5NWE2NjEtNTAy\nMC00NmFlLTkxMTktZDQ4NzUwZGMxMDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHFtAuLoqW864xS+GMAlhoOBGyrEdkEW438u/aCJcKQCW/xtZp/ll3jm0LJqH\nRmhtqRwupEiqq5HJvjehul0LD6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFUVWdVEwZ78U9J/JDzhKFf2vNTIwHwYDVR0j\nBBgwFoAUkoW109j2C8leCHUBfuhSbZcdT48wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD6rkEC8goaccRxCmqCn49SLQ8P\nulM4+TI9huiT4VBDRAIgHZkJhzHBnxh2V1YriawyTPPjkWu85EZIhpsi8ijfH/4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXMAFOCDV9peEGNlWxnjGZPuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2JlMjA5My1lM2U4LTRhNjQtOGM5MC0yYjEwYWIwNzI0YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIdgA8jAvNpVNLpf7NND6Qi8ZjlByDwBqsuqZ6uzzzdOPz\nF9IuCbFrXkgXwYPyvb/6a0u5cbCDifEChtNepWmto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkoW109j2C8leCHUBfuhSbZcd\nT48wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWDCPDfuG2f7PPtACUooTKveb4AZLD8SBOQ4Vw0N0/BgCIQCy4c9a9dvV\n9wq5AgsjewMlWQw9OTTx5MsrXNWgXuIWuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISAQ7FpOd5nVsUboLEXMwQfI1PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzM5NWE2NjEtNTAyMC00NmFlLTkxMTktZDQ4NzUwZGMxMDExMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWE0ZjUyM2UtZTkzMC00N2FiLThhOTktY2NlZWVkYjAy\nNWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdFn2gzzA0Ts27wEZOfKcCMaV\nRcAPJBVm5HEpCLqBbIBShzZVocRs5JGvKwwxdzSq14UvxkUx6RilO+0cRL6OyqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQVRVZ1UTBnvxT0n8kPOEoV/a81MjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22KF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIDrqX733tbj24SlD1MhPD4vJBtDmKKjRgIgQdYV+b3j9\nAiAqWy3TLN9JvOX2USb+BtZ1LE1lfKRrQl+SD12Q7Cb2YA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8904", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8904` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAVS0DYlZekFIng/4Pv8TOcfPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxYzg4ZTA5LWEyYjItNDZhMi04OGQ5LTIzODJlMGU2NDFlNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWZlZjk2NjgtYjQz\nNi00MDJkLThkOGQtYWMzOTRlOTE4YjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJRyuTKBLwAMxMS62uwyYCDsu5G17Ue9Y6bcYHKz6PwI+U3CAwptKl1WlnE1U\nTYj6zzUKPlNvRiGtKMwIEbAAYKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQA5iIgGijh4GHvwZluSykWSSuakTAfBgNVHSME\nGDAWgBSLhZf/2roG0mkOOMeBQbV+O4WPRzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIC8gW+WzbqHcELTOyyeH9opcPjwALIhx\noektA1YZaeUQAiBvXQJ0XmvCZdnylswnx0F+gihRdWOB37VVL+1m3GRz+g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAemtcFKmr05OM0Nahh+RMfb2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWM4OGUwOS1hMmIyLTQ2YTItODhkOS0yMzgyZTBlNjQxZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+LXiNCSZqsqtNMgaX5iFoT3ItoerGw4O/S136zoWq9CEO\nFDA5osBv+xzLHWxrIQgLm/DqMTjMEv4v2FPD8egEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi4WX/9q6BtJpDjjHgUG1fjuF\nj0cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI3/Qa5e/ZtESzH5oLmcoDPEHh3Hg0JGK/cnOUee950JAiEA44ZfinFF\nv5YcuBouSoAqtRdif/TDpdvsf2LGQYszCL0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAR77rFtjXpgUQETZxWkWWlVbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWZlZjk2NjgtYjQzNi00MDJkLThkOGQtYWMzOTRlOTE4YjdhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDU4NWE5MmItOTQ1NC00YjJjLWIwNDktNTc2NjIxZmNj\nZGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8OIeyeiukrLlXzdgCuvRS0Fa\nEaHzn2ZgNZ3p8NaZgHknpYtaYScBZCaK1CE7cKJQ7nzz/gIdhP5Ubl1y1pLuaKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQA5iIgGijh4GHvwZluSykWSSuakTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22KF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQCxy6+2YVRsdKfsirFuzMBJPQ9deOO49PpIUgVY/nTt\nMgIgdTNnrALQ2Vi7H7m0c6aFY3Malto4xsqKDbnD79KCUgg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8905", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8905` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAUdoz6zgsuVYdP5t6dXij23OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5MzY2MTM5LTIwNmYtNDZiNS05NmU0LWUxM2Y5OTNlYzM2ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTVjMzY3YzktM2Y5\nZC00ZTBmLWFiYmUtNDk2NzRmNWU0Y2JmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/nl7jKyv7o4FeUjsq8uGSnHGUfZDmFKKE/ItpOg78MbuuR0I1tyDlC6bTr8B\nLR0zkA+NR6LABsepbXmOsaf146N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIhWYyquHujUmQqwULNk7JtDQXwEMB8GA1UdIwQY\nMBaAFNq9vaYZggjbbvrvCGs6MRdmuG3aMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAwvO2st38gAm8SL6DWx5cBKTpjp8CntGH\n4EDMO8GLKqQCIQCTX/XdbWcap/usIPPbUZ0xDgq/dnzESUtA5d40KzjCaA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQy0isBJRKX8I9VqhKDQr0SRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTM2NjEzOS0yMDZmLTQ2YjUtOTZlNC1lMTNmOTkzZWMzNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDCdW/n6V+tWNnDyX6z+hTk93EVYbQcj33zacOqCwOe8Fp\nwjIiSOZ7Dk+Ptw5dYU/C7/6e0didq78YbguTXxw/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2r29phmCCNtu+u8IazoxF2a4\nbdowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJFETyvNxSAdhCtl3z443GKly5Kb92B2ee49ByAR3TFjAiEAl+3E0kvY\najk/vzV6T1MzzmM/YG3JZyfjALfAFXjnMs4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAY7TxgXt+pj0KZds8PWdeiqPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTVjMzY3YzktM2Y5ZC00ZTBmLWFiYmUtNDk2NzRmNWU0Y2JmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjcwMzdmMDgtNjllNy00YWQ3LTkxYzQtMmJmNGIyYTBi\nZGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsacfO+24JxnYlaPXDxeOY/kz\nQtN7c7yfmEVrBvq4puF+xELSYwpg/zsDnBmDgf5RDY+9W2fbKeeyeV3M81MUZaNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiFZjKq4e6NSZCrBQs2Tsm0NBfAQwFQYDVR0RBA4w\nDIcEAQEBAYoEfwAAATAKBggqhkjOPQQDAgNIADBFAiEA0eIS1dHkRCpQ1KLfnAxk\n2ewo+T2o+hvZztPHtAh0pAoCIHqkOTL7ne1+Ff6dt7Ddxp7bxgnKcrEcY0bBxsx1\nBY08\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8906", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8906` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUo6xjoi4EbzqUekdUOjryMEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhYmJkMTQyLTMwY2UtNGRlMi05MjBhLTFhZmU4MTI5ZTQ4MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZmODU1MTYtOTgy\nMy00M2QyLTk2OGYtMzk4M2ViYTkxYzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ3xVgh/jqI5BYU2o8qwv+3obbZbvfqDjiwFdSRJrtc6oT2TIZxzZ6MMEDX/5\nDuEAaHdcDi1qFgjJFQbVqD1dCqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJmaiR42HQEr89UrqrHSohGffZloMB8GA1UdIwQY\nMBaAFIzZ9DoGaruCQHaSTio5FsgjG3exMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiANiFJQ93zwhNFQtsm3OpeKIBvtKoKsAGfN\nYV9QPFMUVgIhAKgPSrIzWJE7KL0gNDP83KqS9wDfd6qLWtmd1NQnQcyJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAarifi20KhTB6lWO3r2F9raFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWJiZDE0Mi0zMGNlLTRkZTItOTIwYS0xYWZlODEyOWU0ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ2rmosZseBnGtey2xo4+YpPu0OqXjpX41TPyi1dhn16ymf\ns9JkmbGT/wQuIgjuDJuFyJUPI1hjMU85oK8PinOqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjNn0OgZqu4JAdpJOKjkWyCMb\nd7EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALczOnKOVjlXeFTz96++kCDhb1FbhHaduWVywZvRr9+0AiBkEONmSx0Q\n1BviMTlduTgcwLa4J49zURp7yUgXZRYshg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISARKeAOFzvrksp4YDdZU/117IMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZmODU1MTYtOTgyMy00M2QyLTk2OGYtMzk4M2ViYTkxYzM5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGRkNDMxNTItYjY5Ni00ZDU2LWIwZmEtODIzYWZlOWY1\nOTQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQy2ku9GsULjgRlZzR3cuvVfk\nYmx4AR4NvWZRi+VaSDeyGzyx4zWx16Ifj8j6UQnvIV/1IQolsKukTQLEo0z0HaNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmZqJHjYdASvz1SuqsdKiEZ99mWgwFQYDVR0RBA4w\nDIcEAQEBAYoEfwAAATAKBggqhkjOPQQDAgNIADBFAiBAoQg1peAHE1hZvRFDbZOC\nEHrlwaPVCRg0OBkfqgyHqQIhANKnuhpWIumtuekA7PRhSxtJ6Dq3rmW4ldWT6V+O\nIR7X\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8907", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8907` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAR4SeRLCwyiOpdkj8jMCZ10KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4Y2NiN2UwLTlhODAtNDJkNC1hOGI1LThiODk2ZmUxZjM4NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDljNTdhYTYtZDRh\nZS00ODJjLWE1MWItNDAwYWNhZjE5YWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq4cRrddthWWKJ4sn/+k2csRQFye+Cz32OC6qkJCbwavQAn4FqAJqZfPNnJ4J\n/gYPLCZ4cScoy+VBanIs0sGk56N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOviZ0ZFH6hK4n91OyFzsVDdfTuLMB8GA1UdIwQY\nMBaAFIemphUlhH/hNSvCrMHl2WwjJ8qtMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA0QTYZyekp2kRVr+pTK5G7od9KwIesCCP\n+WdSCDuvSNcCIQCFcr/kHslQhQPSiDtX4iXAgylMHFAlE5nRzlD1nSBjAg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbEaed9BzebEa799ZhoV2IMnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOGNjYjdlMC05YTgwLTQyZDQtYThiNS04Yjg5NmZlMWYzODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATe4PwbczaVgbF9KeJtQ1uHKkfef8h2SPVT0WagnnAkP4lL\n2Js/w0QZgLJQ/+jrNOrrsdtKVhgR0muQHN89sOxCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh6amFSWEf+E1K8KsweXZbCMn\nyq0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYybsP4fxuXng+pJDemXI8perRLhSgyKjG7kOVtmoAmECIHfXpqLQDwLe\n1ISTIVaGCwZ5MA1GJYH01bUQJRS3V/Rm\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISARfjS/5XFrygYLyHooitPsJNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDljNTdhYTYtZDRhZS00ODJjLWE1MWItNDAwYWNhZjE5YWQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmU3NWY1NTAtOGYxYS00NzA2LTgxNDEtNDFiNjc5MTBm\nOGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjlGMmHN6uBXMGS4MOoRj2Zhs\nwgS2ic/SaiE8V80hQ5kLKUTYM0rhH2LXPGKpy3vuePVzbStKiSzr1a07GunQRaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6+JnRkUfqErif3U7IXOxUN19O4swGgYDVR0RBBMw\nEYcEAQEBAYoJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCHxclhDRRjsSuefgV\n+wJ1D0no2u1EWI1STk5sLCdJQfECIQCGRNySlmjC5hZb56aQqZ2QJhCq1AE0p/ot\nnRvt6qRXBA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8908", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8908` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAam0oeicZX+OsdhiEfGI54hlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4MjRkMjBkLTQyNDktNGY2NS1iZDQ4LWI4ZjYxZGM5YmJiMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc1YWMxNWUtZjhm\nMy00M2EzLWE1YWEtNmRiNDYwODdmNWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP3eImFN0VJ++H7ggGFcR3qnZ68i/h+T//n2hhh8fDnMaDH1dWrSjWohH4CEB\nOnKrzXQwOMjtVwtLh7TEWIlWwqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFODHws/d4+uJXdIS7kXr1/emo5j2MB8GA1UdIwQY\nMBaAFF0vwkZ8aFZ5UUq/DoyYVGc2FAaJMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAvxvlmUsCUfUnHEhPSHYlSd1B1C+H942d\nubEswviYJ7MCIQDTeGY6zsPJBXogHHIle6gHBWzyY5eOPxhhMEAzv/kP+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYJsUqlxM7orF3fJKCjlrr6cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODI0ZDIwZC00MjQ5LTRmNjUtYmQ0OC1iOGY2MWRjOWJiYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZzQosHU+JjljrN3JBCJB+WfFw/vaUMaweAP3KgtZQ5COf\nWWvJIavuLWFFCsJ09YmhgYWLKXn0rZoSD5oPs9NUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXS/CRnxoVnlRSr8OjJhUZzYU\nBokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMgrOJ/0NkKe2pWeZAQgjS3M8SamDrlZvtJFp3pM+mIaAiEAlQq/KAUg\nJb06GQaxNLTj4fYFh9L1z4/Ft5/6qzE70eU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAae0Ox/HbKyyb4528r6GMm/LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc1YWMxNWUtZjhmMy00M2EzLWE1YWEtNmRiNDYwODdmNWJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmY1YTExNzAtYTY4YS00NjAxLWFmMDUtYzRiMGUyZTI0\nNDIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEttKKbhfoh9+xI5jx4shsjpjR\npPd6z1LAV6KvZdfa/xtILAdyeMt3uKSdhJ0YpH9hgNYp8nS3v7gZ6/x8C2e+FaNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU4MfCz93j64ld0hLuRevX96ajmPYwGgYDVR0RBBMw\nEYcEAQEBAYoJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIGAPDXsKvjNBw++p\no/JcIRCD29wyaeN4x4bu1zx47oZcAiEA83N0Zvrps5hwRvwypCKw50cnRgqEZwsj\nd6ETde04/JM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8909", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8909` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAaSztIvpvM4YC5uCLi5fK0hpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyYmRmM2VmLTE5NjktNGMxMi05MTAzLTY2ZGUzMjBkYWM0NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDVhNjA3ODAtNDNi\nYy00MGY0LWI3MWYtMjY2NzNkYmRhYmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7aiR2adnfbGvojSm52ENzZUCxEzypxCIVoDdV9hQ2Zup3eLiICdgX5Yn83Bq\ntYJfPP8uiNuV41tQ63WvonbnXKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNQPrgY9DnS/eISMu2tvGVeCSSFEwHwYDVR0j\nBBgwFoAU0AUcLNFhSd/X7tx1X8G3fscbMv0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHtoV2HnZLzsieBa1cQvfZGQOT90\np2F9X94TZbDD+yVLAiATslammUDP+flOBVhw6RrZXTBAXbEx6XP8Imm+xyJEhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW9Hbapsi2z4v/hO5myrV7xuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMmJkZjNlZi0xOTY5LTRjMTItOTEwMy02NmRlMzIwZGFjNDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATg01KZy5vhcvcKn8icGUdjZ77rcj52odtWxcuuqg+5Q5A4\noJQ58crlGAS2TZ5DuvBTkvFqVFFeSrDpzmw8G3W0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0AUcLNFhSd/X7tx1X8G3fscb\nMv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdDtHEWwTBaZ1UqQQa13qBfJAovh/XyqKFDqUrin2R+cCICrNzOHhlbac\n1FeFkKdH8A/R+oP+mFe815+ZnMJjnPGH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAWBJn5lHW0jwlEcY3zSVyhjCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDVhNjA3ODAtNDNiYy00MGY0LWI3MWYtMjY2NzNkYmRhYmNjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGVkMjk5NzYtY2QzMi00ZDBkLTg5MTQtNjM0NWUzNTg3\nZDY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWU41e+iewWr2f1rIA70dmLSx\njNxEpLvPJoWFfkELpdR2IDrrtMdbhJWXaMM3zdp4pZt1KfHZioAtYFogLWJkIaOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ1A+uBj0OdL94hIy7a28ZV4JJIUTAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22LDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCICAjzEzB8jjddMjlwEdIyGnBXu1HdbD0NdGDFCp2qvjsAiEAsrm5xCx8\n1EDJQTYbhK5DI5py981F/DHvohzQinnvZOw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8910", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8910` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAQQ4vzKGTyEFDBZkc6i66eFeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MWMzMjYzLTUxNmQtNDk3NC1hYjgzLTI4MjIyNjZjN2U3YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJkYWE5ZmQtOWMy\nOS00OWY3LTk5NGItNTg0MDBhNjRjOGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0TxtybyBHx9f3M2xHzTXatZmIHUeLsYcNkxC4VEZM9Jlg+Vh3rDNKxJKZkdw\nbdlTUA0u5Hynx7g1gQcaE1fXAKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRjLeam7354UZ/659UvlTsgJObxszAfBgNVHSME\nGDAWgBS/My6j1edXaD3ppcQ8fYlsHGW9aTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDhThdoszZpbzrK/YjijkNtcEBf2BhR\ncx4gCGBTG9WXpwIhAIM6hzkdoYnxvXbSampqN3FWoQmDgddi4+jXd0MhUAo1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASgy5nIPrfHskl3xb6qyqGmmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODFjMzI2My01MTZkLTQ5NzQtYWI4My0yODIyMjY2YzdlN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/tzYOSUoO5jwrMANEpHlz2s1PX5KPsQwU3snecVILTGnb\nA4MjO+9yJWxH0neW6xNlRT4OrMIC5kvVuaF5AfkQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvzMuo9XnV2g96aXEPH2JbBxl\nvWkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOMEOtFUN94+HGz6bAPmqwMGce8os8p4tx8sxR4y+TrGAiEA1iYsA693\nfp7wBKjcnT0k6SlYHKua9dm6XgmEITczU3I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAfdFKD13zVgDndvhGrIckCl0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJkYWE5ZmQtOWMyOS00OWY3LTk5NGItNTg0MDBhNjRjOGMxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzc2YWI1OTctMjFhZS00YmIyLThiM2EtZTI5MDc4MzNj\nM2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEluoKdjsZvPaHscWthn4kd4xl\nKrOwyAS6lWp5rX49Nf1jpTZJR/FhztoQRwbAe9GIoXd9ao46Li6ET4VgwVE7wKOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRjLeam7354UZ/659UvlTsgJObxszAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22LDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCSY/28Q4SgO13BdNt8ZnDd2c4U3xdBgv9xzXoIkoKKUwIgSwjiMnZS\npe2q2nXvRfFcUrQ/EwQHUIyBmHRODoOPioo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8911", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8911` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAUqvQLyuQP/oQ1aAMXnbUnJiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiYWMzNGNjLTU5OWQtNDg4Yy1iNzY1LWEyNjQxZWUyNjVmYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNhMzk0OWUtMWFm\nYi00NGI2LTgzZTQtMmI0MDQ4YWFlYmFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9jcjLB9xNH4XHxesQxjnbDvkqn/pH7UBexl6iMfQ2rupV1pRQe31ze7lD3/J\n5tWCvSj7HVIZNS3ondRtc9Tz9aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUytTUwkAqUBO+jbPmrlRGbiyYHm0wHwYDVR0j\nBBgwFoAUaG66KembImUxzvODSM9IDBu6v7MwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHEVFbduj30tJ9bT0HXuX+pqDZEB\nmBJWemhfBOEZJ9hjAiAhJugWRdPE34CJFC6DGppn5qfrGywE8oLP5H1pHkEq/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXAyPRdEB3AqlFVGhn+X9/S8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYmFjMzRjYy01OTlkLTQ4OGMtYjc2NS1hMjY0MWVlMjY1ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzfd6cQ277bz31Xl1482DzdOJ9JI47JMJZYXMZINfeusry\nrFUcTSL7+IAD0gg4cRxbNZ9biqCzc50GlTGZAkPio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaG66KembImUxzvODSM9IDBu6\nv7MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXRBY+xuufUgiGPSfkx7UcGK9lqisEk75HB/if2hLREkCIQCwUv7HYwgk\nbSUZ26W4b4O7jaqqs2qE96ln3roqoDnPKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICKzCCAdOgAwIBAgISAftmj/2XwFv+Wzk9IIRWfCZiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNhMzk0OWUtMWFmYi00NGI2LTgzZTQtMmI0MDQ4YWFlYmFiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTk2NTZkMjMtNTliOC00OTQ2LThlNjUtMzc0NTY2MTg1\nMmFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC5jFXmS7VFSRpUbXYopHgFOu\ng3APkJm2wXWiTTghEpZlkaYfGdm2yN0EbbW0r9zbwCHDqKqUMi/RvniO8BaZKaOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTK1NTCQCpQE76Ns+auVEZuLJgebTAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22LFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNGADBDAiBeXiyFsapEaqwXmKL2+Jv4hdQ+7+NSTpt0jR4TdAFGKgIf\nSzYnzWDYbkWi/9W/PROFORxAJ0194TrbPM4NbDoz9g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8912", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8912` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZavAVx5s+0DKIZXS+2jBHyQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxMDY5YzY2LWZlZmEtNGI1ZC04NDEwLTE3MDhkYTY3OWU1OTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhhZjNlNTEtOTI2\nZi00M2QzLThhNWUtYWY4ZDIzMTVlZmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU6ctncdVQME9w/2F0RhEbqDUPa6ew3PJVuL0bZ+ZSivi6LjZNtdOyiKaXM+s\nDqzcGq+WTX/78uwmt91sUMPSCaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ/V/pO2f60uFFp0Qa5LBwSnTC1TDAfBgNVHSME\nGDAWgBQvPkcwzykIXIrOyNseaEL9nZ+HTzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCGECF8TBZJMbdpBxpEsF8/5eAG1Sc+\n8cl0Bc8o5KTOpQIgAp2LaTKwil/YljNG0oNI62vnwP8T8unB2c374ect1Xk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW9coRqiFq2mMxgA5u884DJDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTA2OWM2Ni1mZWZhLTRiNWQtODQxMC0xNzA4ZGE2NzllNTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5O818OtJlawpBOm9u51EQv5ahz8MHoJrh5/Y6Vq++v8Ns\nxg10fjswhZFd1arRaNEI724fiX3pQeYwshuqKH0xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULz5HMM8pCFyKzsjbHmhC/Z2f\nh08wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbPJQliiF4gudeY/DvwVbHLIA3vaKgO8RRLz5d8coiLgCIEBtCNJvdvor\nvhpquIYrqto7TbVwACyMsVoeBMJWo54u\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAcmTUtesAvuPb/ixSzl5JOI/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhhZjNlNTEtOTI2Zi00M2QzLThhNWUtYWY4ZDIzMTVlZmQ0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODM3NzkwYmYtMGZmYi00NDA5LTliZjEtMmZiNThkMzcw\nMDYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEREyQ/RCK90g3/hEPdd06qU5P\nHmOlBIzWdMAJoRPmgoNCs126SmzG/8zijH1wxQWaMOkk0BmqeYwe+FmL2xyaD6OB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ/V/pO2f60uFFp0Qa5LBwSnTC1TDAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22LFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBE6odP63/wypHJqoztpw2fZtTIP+1paAFYMbScSCN4OwIg\nQYrMDc8CzLTN1eq3JU27hOl2u9peD0aZqcNI39se/XM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8913", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8913` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeRIcolwoYf44sPhKZZ4ncWmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3ZjMwNGYwLWViYTEtNDRhNi1iNDA5LTlhNGU1ZGU1MGUxZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU0MGQ2MWItMDkx\nNy00YzZhLTliOWEtODJjYTEyNmE1YjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUPWuspql3odVWa6nl8/f1g6+AfFqM1Yvwf2pyq6wei6BTl8ubteuxYe+hWlM\nq4jtXSWHA64TTAiZ9VhU9z4z6aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSRo2P34ROJuhzaa4BUIMkFNsdNYwHwYDVR0j\nBBgwFoAU76urTdR67gDnKjx64Zc1vM80njAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAKn59blPNJ6nDens843z+u7kLss\nBVJZR/wtgBoEn5WVAiEAtFHtAU1mDmFthdp5bOF9KKLInNVqImj9y0Rlc2WWJVI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWlddgjp0e3euTQSwUg8fRgpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2YzMDRmMC1lYmExLTQ0YTYtYjQwOS05YTRlNWRlNTBlMWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkxVlvS22QTeazNiK9v7uFM2EzZqczOT/OVx1d9QxpdQWq\nFSy4RyP0lT38J/diu/8vLFZuwBHtyo1uV8vGaj4Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU76urTdR67gDnKjx64Zc1vM80\nnjAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIrQS1X2gsSY9E7qA50ROTQnCRiPIvbbgWG5VngufF72AiBawfKtIibX\nfQjUAmg2EzTEsxvpFkPIbMcSvtObkXes7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAZR6z5f27LWKbxy5zjqhf87TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU0MGQ2MWItMDkxNy00YzZhLTliOWEtODJjYTEyNmE1YjlkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjIzMzNmN2EtMDI1My00NzI1LWIyZjItMTQyZDRjOGYx\nZDkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1f0Fs8W0G0BVDlHj5Y+D75Ri\nH1Vvyg4zf5iiI6EJboS72sJQzO8yb9pmM0/Bb/dyhSyUpwSxjxwD8Cx7GlpxG6OB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRJGjY/fhE4m6HNprgFQgyQU2x01jAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22LFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhAIuey3jwaksmWQDvr8cbhfWWbJXdxUDxHd4s8SHUME2Q\nAiBybgsopcFy9K7UVMqaKyxSOtc/E9/QxtzfgS9Z/4LTyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8914", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8914` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAeIB0VpCUs34XOwlcj72cuHeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3YzRmMjljLWYzNDctNGQ0Ny1hYjhkLWQwNjUyYzJjZTM5ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU3ODU2NjctYmYy\nYS00NGFkLWE3YzYtOTRmYzlkMDQ4M2JkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEd62k1pnU1AbqRKBupT5NjfnF5wz/92lX6Jq9fvpnsJUTQkNVa2oMGC9Fdugr\niwc4p/g5cTAztlw+GtJghkjpUaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBREuqgEwKcqj3Bd2a36Qynnq0jMTDAfBgNVHSME\nGDAWgBQVhA8BvLDfbXEne6PiZxenNAthkTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCgLuCNUjwrd4fQIoQAdVtE1lHcxz9v\nXoS6mDUUK5mJkAIhAMWePaK9JE2rKfI1qeuTHfpCGqHldxHLH9q1ccol4Az+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbTIWxjoIgg1H2DJokMvM2bYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2M0ZjI5Yy1mMzQ3LTRkNDctYWI4ZC1kMDY1MmMyY2UzOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdXh+xThARI89D099Xk0Rdba5/M7G+/BH1lO5JNid6L9U3\nkQru4lNuwkMm0aF642emWr3tm/DbEuRNeNi1LzTjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFYQPAbyw321xJ3uj4mcXpzQL\nYZEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPMw+rrq/sn4fWzkrOaXMFh+vsitGkY4tokyxqYef1JkAiAgS7AVT3Wt\nmHMN26Gvehfi04FydW1A9xA/AdhRyDF/HQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAYa9k6NFGxkVC2PIOu2XZSybMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU3ODU2NjctYmYyYS00NGFkLWE3YzYtOTRmYzlkMDQ4M2JkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTdkMTIwZjctYjcyOC00ZmExLTlmODYtMzVlYjEyMWFk\nNDJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEu3t4+wIkzJV39M744oxZh62m\n538FGkEGhViM0jtaa6F5N+m9AxRfB5GYF3uqJ1v2gjnDG9IluR7uQQLW7DXP9KOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBREuqgEwKcqj3Bd2a36Qynnq0jMTDAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22LFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhAL7mMvWH/Teir+HWwIrVzz3weaKxSFsrofwYUQTtKT2y\nAiARLwFqMhV9vT6szZe0s0uYbPYxCoMy4hTyvErOT/LNPw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8915", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8915` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAbGrOrIPbu9xv3pyYmxJ45ECMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjNTIwMTU1LTA1Y2EtNDdiYS04ZWYxLTI5M2RmYjUwMjE2YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODliZGJmMTktN2Iw\nOS00YTM0LTg2NzYtZTFkYWI1NDg4NjAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcVvgGaTdbLtYJf2CSkrJvYlQYUqZW/p4EVanXK/eCO3Vp/KvHKIBF7rpA6Uw\nUic4Wjy0f5U6+MR2AN+yQcRKvaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjGMp8eyHKWdwzpVpB50IyL+cuf4wHwYDVR0j\nBBgwFoAUjkVp0FYbNM9+ns9KZUmLI6ByipQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBIyVtNjkpS5tPIv7ZHWj8VWr+H0\n8RNkn7oRl3SOlUMUAiA8EgKJDqnN6ZzxCgxmMuG++DIU4TUk6VoC0uAc3FW90g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeWOBHQgdtZ71owGKkk1v2vhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYzUyMDE1NS0wNWNhLTQ3YmEtOGVmMS0yOTNkZmI1MDIxNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARM2BZM6c3pkaJelfQ6omTGSxHXPVV4fBhbzG5G09ZOfU3K\nlVC8kaCUe6NX1E+itqbqqt89PdjRiur9Rn4KtP8wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjkVp0FYbNM9+ns9KZUmLI6By\nipQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMFiqpzruwvlEzFykT3eHtJ2UwGr7RwQDF+zijeeUpEIAiBVouElIbhP\nxSnoMj8siTESRMqap8WtJ94/EUCI7cy0Wg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAcWGEwZZ0ZSxZ6g6uPT0dJslMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODliZGJmMTktN2IwOS00YTM0LTg2NzYtZTFkYWI1NDg4NjAzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDE5NWI3ZTYtOWI1Ni00Y2MwLTliYzktMDNiOGJmNWIx\nMzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbu+NjlYVo1UOBnU2WVC/AHSR\nqnL9os5kXrFPOrmzL8GDMk3OKsmn+VwLxhqEpaHC2hYJtkLErGHv+fCqUYXM66OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSMYynx7IcpZ3DOlWkHnQjIv5y5/jAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22LF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQDLgw02ubBj3I/dtOYIoFIJHBRR+TCKzJM43S5f1XS3\n4QIhAOR5pa6RvfZBOnM0242GUGu67h7PtUM8+BwhBenH3QFK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8916", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8916` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAfn2SQTtaZkffafRAVe6Ny4eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdjYWQ3MTk3LTkyNmQtNDI3YS1hOTAyLTM2MWE3YzQ5NjkzZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGExYTRmZTQtOTQ2\nNy00NWU5LWJlZWItZmNhY2M3NGQxMmY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0xTF6KRFvlDpIxU7Jv9RH32VzOr4dfTmGtrKZ+XNT6vKDDIIbSdUNocipwDP\nF5TwjVsgIn2sOkZJzsI5SLQyh6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSMGmWlWqQ3q/b8AklZLncDVXMzVzAfBgNVHSME\nGDAWgBQZtKWvr2nXuthnjxQMgJfIQ78rTjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD0jPjao3+WXJAxvAl4EM3+R1wbVmcn\nOCWEiXPrUNOy2QIhAI7Qrih85iY0/HDcryFr5re6kdWe60szmehq0U50lYXJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAchyE5279Gm0akr3qep44+yUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nY2FkNzE5Ny05MjZkLTQyN2EtYTkwMi0zNjFhN2M0OTY5M2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpebgFkeofN2x305huCC7jmCCYU5WPpT8TiA40fADQ9Czz\naJsh3SLw/mZchP2Y0yxe8nsNaT2VDSMDl5Xb/nqAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGbSlr69p17rYZ48UDICXyEO/\nK04wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJv1lQKltN2x1Cje3xi4nUQ8rmIN5X8piZZ6oNdEqvYWAiEAr6NwTj3O\n4M8TDh2B0D/6khbuhYYAtNJsGx2Wk43l6G4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAVpJcfPJC5aFMHtOrLeiozExMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGExYTRmZTQtOTQ2Ny00NWU5LWJlZWItZmNhY2M3NGQxMmY4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjlhMDlhZmYtMjIyMC00NDMwLWJiZTEtMmJjNWJiOGVh\nOTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtVB/aBNKmjv9zDbnK2x1p5Dx\nTUGC+aVqfqaIwkse/t7laAPrRYHWQTHefyjEnAzETdJlSHxTOoDmRJmgAzt4p6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSMGmWlWqQ3q/b8AklZLncDVXMzVzAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22LF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIEW3OWxq94t5qbknSdBMY3uGImiq3wejX0K0snhXvYH4\nAiEAovaLqH/D/f4QR98pLvn1awehnhujsXHYOJx3V5yE3aM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8917", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8917` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAaJB87QIJBK1rMxonrkXlwf7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZGIzNjUwLTg4MjctNGU1Yi05NDk5LTQ5Njk1NTRlOGRlZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFlMTFiYzAtM2Zm\nOC00ODc3LWIwNGUtOGY5N2NiMTk5NzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7eQrt//XUaD+1IyRlxJwhwRD35eiM+sCcVb1AGSRyzLZYci+gGpYi3o79/O7\nft0kqOFRT6gplpVH7ykkrUMUWaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVZv/xIoZ5yK1CjQY7sLUKWiss2kwHwYDVR0j\nBBgwFoAU6N/6ExziJMicMq8/OehKVbzjmBYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC0rQbZRYRACa+3+zbzfU2LqK8q\n7pjrztL3YgiaI6nvewIhALhgEoH7jDCzrE/M29Z6pNIEEdEb1ig0+Ewub431Z9qh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAarH6yYSZEb/00elRzHmdwiBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGRiMzY1MC04ODI3LTRlNWItOTQ5OS00OTY5NTU0ZThkZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwo8Xp8iWe/7qaVvP2elC23Vkm42+IdKrblqoH6QceiVS7\nDKZ8p3jMX0gmycHR9tYtMS957FcMJ9t4C1vURfRZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6N/6ExziJMicMq8/OehKVbzj\nmBYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANn+FsQgyl/3hM4SdfHwMbbzEwM93obzt/8AEhmzeAQ2AiBbZNvF3Ssl\nHePlWPcu5x6/Xav/eJAWADRlQr9sn05fiw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAf/O7B314+u5GYwbixzoEQWcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFlMTFiYzAtM2ZmOC00ODc3LWIwNGUtOGY5N2NiMTk5NzNiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzM2Mzg1ZDEtMWE5OS00MDEwLTlkZjYtMGJhMGJhYjIy\nZjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+PgqwgeeJDVxYZ+w9tauk6/c\nd8N4kVw9GjVbUMS5CwVzxL2X6Lcvct9BH4D2ug2ywM9orYFZuWCsDrLk9vi7FqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRVm//EihnnIrUKNBjuwtQpaKyzaTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22LF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQDeh+BfsbBoo/CYzFS0/nFuA+pMS9Pt02O355olXqVp\nBQIhAMVqRCrFZugaQhmyWZN4wtDfwhQzohBLUoJiI3z6RZ5N\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8918", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8918` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYUOp9AkOpqmohdGZVTRNeFvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4YjQ5YWE4LTdmMDktNGU4Ny04MTA2LWY2YmVhODFiNTdiMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUzNWU0NGYtNWEx\nOC00MTUyLTg5ZTUtMzY3YzhmMjg4YWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0w+opHK1C+npTRhR2tgVB2p68v2Dh9E3/x77bc7jYxlO5ix6TqZcTxQvvKw2\nJwz7d9Oocu/LLgRDHrCTLgtVZKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSsWQPwdCUIek0mplkXp1m1ijgPBzAfBgNVHSME\nGDAWgBRIrhfDWFCe4bJq8MF/Sqd/AahpGDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIC3y8e2X9yw7WGnWRikU9PoLjy12sJeR\nyFWvEC1WtYLEAiAPqwFgsCLXndTemerrpDX2mo5VQ0dtxZT5MVjTDRztMg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbpTWky4iOtCNal3dfMi1Qo5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOGI0OWFhOC03ZjA5LTRlODctODEwNi1mNmJlYTgxYjU3YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9NUZIoZ2KanH/ufISFlPohO+yn0v8iRg3Rw1QiJpdWPf/\nHaaoFQTXhbL5jiNg/7SSjPL0mzmAePPNHjNmu/O5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSK4Xw1hQnuGyavDBf0qnfwGo\naRgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfL2lPz+RIkVljENtsWi+5JMh6sYpNVGzlj3YV2c/IPUCIA94KZDRezMk\nhR8hHTVNOUOo5gqPZ6ggC2nWRkltV+Ea\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAacLCJEipVenbI4H9J37A2YfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUzNWU0NGYtNWExOC00MTUyLTg5ZTUtMzY3YzhmMjg4YWQwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjcwMTUwOWYtMjI5Ni00ZDNjLTg0ZGQtOGI3MTE0NDZl\nOGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiw0oLKr+62rrEtO3Sq7W/eqn\ncph7N21LK4mF7UbrvJCz+/KUXIW84l16YYKVL7X/LGzkmRrcX9pumNF1SukcJKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSsWQPwdCUIek0mplkXp1m1ijgPBzAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22LF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIFX/utLgPYUzm3exnrhYACUNgb/WeUHkOzz8DmoWiwOO\nAiEAtOuLW0oakygZGicJcYcSvzI++NCJNaAFDRb6Ge9c0GY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8919", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8919` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAf2fNdqRJnicNIekWukhrrP5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1MDhjYjMzLTI4YTQtNDhjYS05OTEzLTY2NTMwMzE1YmI4YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzk2NzIxNTktZjlh\nYi00ODhlLWFmYmMtM2UyN2VlYzllMzJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElbNSnqqGlHV7Z+amGhvcVyiyNDSLq/wKZCPWON7PvtTq8iTxZR71a70ejZLg\nUNse3BYXaxy32EoAuLN+xOgMXKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCdVy5rFBQW+dNPsyVz3Y+gJl2EIMB8GA1UdIwQY\nMBaAFDbpVBHiLzEA48hVMRi4VVfBdUUsMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiBm8ok/6uB2gC7Pd/pTRrgy9QWIzBDOubN4\n/t1XyEkAMQIhAIQNw4IjJpoguC9I1n0wO9c9VSEh19bTOpujoW7gxlQ9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU1Ln14F2CRKXZD7MGQ9n0F4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTA4Y2IzMy0yOGE0LTQ4Y2EtOTkxMy02NjUzMDMxNWJiOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQmSqln+YO7tCVANicHPoxVJXWkB1GqG67r0SNV4SxpK/jF\ncgnD+1vSRlJg0/rplFQQ4jGqXu+CQugf3gWtxvJVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNulUEeIvMQDjyFUxGLhVV8F1\nRSwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKIdR78fnfZYhwPTj0NoszzcekV4N/mVF3OJVb17D5Q5AiEAmB6ShaIm\nUQHWJnxMEbUqsI13cYONOXd/5VesGSd5KMY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDjCCAbWgAwIBAgISAY+GVle2IGj/nP9VHEmEIq3sMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzk2NzIxNTktZjlhYi00ODhlLWFmYmMtM2UyN2VlYzllMzJkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWYzZjZlMzYtNGYxOC00NDBiLTk4YjUtYzcwNzIzNGQ0\nNjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdL/x9M2LrZLKCrfBwOK991le\nhGrllm69AYVhovAg3t+Y3hupzV9hnJFkOXjJjCKtdyC7HxffgNU+ee4uPHkKBKNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUJ1XLmsUFBb500+zJXPdj6AmXYQgwFQYDVR0RBA4w\nDIcEAQEBAYsEfwAAATAKBggqhkjOPQQDAgNHADBEAiByU2+PH0oHnTagu3ubEa/l\nFjrQhZfAsKPZJRw9lnSqCAIgPNpjp6o1NsODnyKa8y8Fm8sgPMlmPqgNap12Hy94\n9wM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8920", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8920` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAV8WcsY00CoX7n1JXiixjG4rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGViYTYwMTU2LWJkMDMtNDkwYS04YTA2LTNmNmQyZDFjZjIzMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI1ZDk0NzUtMTQ1\nMS00NjUzLWE4MTUtNWYwMDc2YjU3ODNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Y0L1wGyqZyZ41UnB3BM59fWEaSxWAAJtRrImKdfmcYwGKKFCgmUJy/MYMmf\nivB5ggqkK3pacPNaJNYlb3tHkqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNh1ChC5My19hv8y8wmzWktRFG5BMB8GA1UdIwQY\nMBaAFOtAJgBrQV7Q36X0OKY+rh8Ha92qMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBjose/H94mqGiMfDm3zgs0O85S2/nLc9B/\nYrjaGgHu3wIhANRk7teS7Art6K7NS4/jTqAK8nAMnc7t/M6T9DoG2gY5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATqp5fQzThSamhHFRWBlVgjkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYmE2MDE1Ni1iZDAzLTQ5MGEtOGEwNi0zZjZkMmQxY2YyMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnLu9Xzj7FfwFuM/9Ue5iCu8x/0z9BpfPYVk2GeNDvFFrM\nICj1WlOybmnQnezYAqno/3h9fVUvjpj+dRfdm2Syo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU60AmAGtBXtDfpfQ4pj6uHwdr\n3aowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJpRWkJw1LO+xuLAtrTX+XhYj6SjWXm2GfH3R3JnAdDHAiBzXqcxmblK\nULsIk+cTxT5rRd2LMjrGAyYw4XHXjbz6Zw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDjCCAbWgAwIBAgISAa2WpyHX5zn3NmGTO8Nvj1qDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI1ZDk0NzUtMTQ1MS00NjUzLWE4MTUtNWYwMDc2YjU3ODNiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGYwODEzOTUtOGU0OC00NzY2LTlkMDItZGM2YzdkOGRk\nNjE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPUoFHe2V8tKkVONexifgbASp\nCWvBBr1OML0wY1LBrwTTWY69h3pY378nOwGT22o9G8vkC/CXNuH1IP5NU3qBMaNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU2HUKELkzLX2G/zLzCbNaS1EUbkEwFQYDVR0RBA4w\nDIcEAQEBAYsEfwAAATAKBggqhkjOPQQDAgNHADBEAiAvzhIPbnWF6uXDu8BPiaJc\noJE9yqA0zaU4qShYaHP5vQIgE3Keg8HnPvLfnsZMy7pm1zmZFYcAAsb5yeA2MI0l\nZlo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8921", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8921` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVhXhjBlVBlIF90igsJH78ueMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxYzdhYjk3LWMyYWMtNGEwNy05MDc5LWU2Yzk4YTkzMzJiNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzk0ZDI3OGMtNDZk\nNy00MGI1LWE0MDYtOTQ5ZTNhZWQwOTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw5iPP9taBKMgKCKt8Mwcm0MgbHr7olUWCLI92cDzVEJjqdCzrrPMcKNOS0Ue\nz5KO5dd/fK59Uxk+VVqFBvCu8KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFJUzg3z4N84A72uMKyiXbuCvyweMB8GA1UdIwQY\nMBaAFG0knhw/kQjhWx9jS9dnqW7jZlyAMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAvuLMLqkMv6x1V49H3KpZ5anQKWpSXvIke\nj27DyM0jjQIgRiYQ4mUmOnPqtw9CIgHdMo7P1OEdkFUCidW0mVicXPE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQBMrrGO0+dwqn7ZLzANC6LLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWM3YWI5Ny1jMmFjLTRhMDctOTA3OS1lNmM5OGE5MzMyYjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATgzuSz4VTPah2D09YbNzliH20p5+fr8220F/rPXHrZSFq6\nSOGBpOjmfCSDlS1m02u/KvIjn8uW00p5AB17geTCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbSSeHD+RCOFbH2NL12epbuNm\nXIAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALoS2kFbDJ+UysP8vb1Kauz6nAyfFueNvP5mAh5GG6XUAiEA3xet1Kr9\ntu95J8Y3/Yj1JT9Qwzfv5wJJsay/oyNwupM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAXyFCiiKTOIcJ5WbqAa3IaJ6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzk0ZDI3OGMtNDZkNy00MGI1LWE0MDYtOTQ5ZTNhZWQwOTUyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTM0ZTU5MWYtNDk4Yi00ZTM5LWJlNTAtZGNhMDVjYmMy\nZjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnbUF28UqTUq+BdXRzTXdXqZX\nr2JiN3VdFtNQr3yryss3LxFjELbmgfT1tnFuRspD9Z4gi0AqQF6Er8SeR5oCs6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUUlTODfPg3zgDva4wrKJdu4K/LB4wGgYDVR0RBBMw\nEYcEAQEBAYsJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0kAMEYCIQDiBZbqtmSDTI/G\n6Sj8YUFghAaUceZrNsJYxmXgodZwhwIhALg+6xvx85cH++fDUuPhNafDbjG853ec\nYpyA+qdBAhF6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8922", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8922` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZh0UNMyGgIcWbKCm3pukCpUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhODBjOTEzLTlhNDQtNDgxNi1hOTY1LWI1NTE5ZWI2MmMwMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNkYTU4Y2ItMjBj\nOC00NDY3LTg3OWMtZWNiNTg1YTAzNDA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQyFsr1UrseYUO6TkTkzpboFdDPCdYapdC7YrUcynGd4oWL5A5bw7365gGrhA\nXeyrrg+PdgENSEzCMNAQsGCyDKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFM2ogJzBiMhFFXdFXlWypoumKqiCMB8GA1UdIwQY\nMBaAFPjiY0uRguuad/J5Xz3j+u0UTt+SMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAx8MuJR8K+eSoeqDelZXByATA9txOxdpV\nx0KS3MCjIG4CIQCw1yoXmgMAGENWnKo02U3oIhzSAw6AOEZUeSBi+O5k+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZBzLidD0RYyA6XcJk2kSdzfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYTgwYzkxMy05YTQ0LTQ4MTYtYTk2NS1iNTUxOWViNjJjMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfJowFBzFPpl03sEk9zzNNBd/8wS5dp5qRNVvRJ+2LT37m\nfqE4hm8FjVzT6OKyU2HraMSyHhGYAjST2BPYU3+Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+OJjS5GC65p38nlfPeP67RRO\n35IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWbC0V9gbutM3WP2BleQSwi6UjiRp/C9QyaG9KtYL67kCIQCv/4ABzv57\nbCmrThTYnjY8hyRD6maxT18HmegTAGmC7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAejdk4PuO1Eu2GPlPQ459zFDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNkYTU4Y2ItMjBjOC00NDY3LTg3OWMtZWNiNTg1YTAzNDA0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjJkNWMxNWEtY2E2NC00ZmNhLWIwNTYtNWEyNDU4NmY2\nMTZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkWJ3BjN8SOOKTdse68VHRNY3\nsUajTVzYzWIvHtix2B/J8FJApRnDy+7L3ZUO1xZPkO3Wds0MU+UOBfuAKYZ88KNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUzaiAnMGIyEUVd0VeVbKmi6YqqIIwGgYDVR0RBBMw\nEYcEAQEBAYsJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCIHPV/YiC3MVpEgkZ\nELPWbxo/FUgdrYXhzszDB0R2JHHCAiAtXT3SqNbqyOuRppzWByDNuB2K9JxGwtAI\nzF1/tjm5nw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8923", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8923` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWNdaUFZEc3sj95v6YdB1RvuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyMzRiZjMwLTg3OGQtNDdhZi1iZmQ3LWVhZWVjYThkOWY5NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmViY2M4ZDgtNzQx\nMy00ODc5LThhMDItYTVmNzQzZDVmNDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0RNl3VIqb9p164ZsD8A+lGGUxvaaF7L/YeRUbdTRVqOoJxfCJejbo0YfMtWJ\nqd7l3QTTHDb7YIbP+wATCunsUqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzizbCOegyUr/w0numoWg7NlY248wHwYDVR0j\nBBgwFoAUMi1Ijz2YLswSp46kmvGJH5KAlpQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDUooah3d2ptmjcirfENTYXqYsj\nHfmKbbAy+nE3GaIBygIgRNs5B9enNqvedKjv8KJsqksdGyY7xxjlk0XeVFoHy28=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW+BVAik93ET4kL9g9DPoZWOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjM0YmYzMC04NzhkLTQ3YWYtYmZkNy1lYWVlY2E4ZDlmOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKAlHuu1mAylvKZDIXIT5qFufyAIbzqBsfDYTuKIczzoca\naS+PAYNx3A3LFZ4MuwyX+nwYTlMblPeJwNrwYaDwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMi1Ijz2YLswSp46kmvGJH5KA\nlpQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTocdavXBFVoe/LzRCz4tGpfO19Pv9+lnXmZdsk/mw+ICIQDlqPxHhVd4\nIYHZEXfZcfgISLfyXLCwvs5k7SOluAwBHg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAcFTRjIsb8Cu517X+JfGI615MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmViY2M4ZDgtNzQxMy00ODc5LThhMDItYTVmNzQzZDVmNDE3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzMwYmJmZDYtN2M5Mi00MjMxLWE1OGEtZWQ1NGMwZjI5\nNzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaPLln9t5lFLWvEHwxlg67LRV\nM8ojVcczMYV68BhthSTpQ7bJoLbkxRaWSLQVqwB2TARXhStBeRdLKxBJ8MoNVqOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTOLNsI56DJSv/DSe6ahaDs2VjbjzAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22MDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQDo3sGO4uzx0dVIR4/rrgrwDtuFc+p5F3jIGzvTyAjZsgIhAMdpjUKV\nYoq9MLVITqPALgEscboJvkZOLIBMauBxNpFK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8924", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8924` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZ2Zr3EK/ny74PJWclPA7Vl1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ZTE2ZTVlLTIzNWItNDJlZC05OGJhLTU1ZmY4OWM0MWM0NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGQ4ZGEyNWMtYWUy\nNy00NzFhLTlkNjgtNDRmZjE0MWZkOTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPJlrhZOjZRzHgejX9u1vfBnMvqwcd8hII4uokdJ30DOqlTfUnMYeTIqr8I3X\nWbif3xQeq7aqQHAVAaYB66PCuaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTOS3dvAg1E3Hclv/v+xsgFxmyEnTAfBgNVHSME\nGDAWgBS2HQybaocZVhOan56RIuTCUdYQljAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAIUA/6q2gDkyZ+O9gNiNXxppe4QSdYV\nMfTsmQW6t3MCAiEA6vwfx0A6D3Bzda+8zbSeRMT9mjBs66BY3084Yh17A7g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdFMg6n8YBaEICDwVxiZXkmQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGUxNmU1ZS0yMzViLTQyZWQtOThiYS01NWZmODljNDFjNDYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtnAhQRRROrxItIuzbaNhB7jNupqEUttZ+421arpF1qU9N\nCQ097y2bFJUXyLw71fq7cMskfDxrjjmaNst1fdi6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUth0Mm2qHGVYTmp+ekSLkwlHW\nEJYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJAVhu1TgFVeYKhH8a3qn5jj/3EtU6xgdkam77RSqjwZAiEAstx7iCYt\nNjg09+sLjRnGleJl3f5Us+UnREsNnzoUBgg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAeJ4N+3wWV9FblN8E8Pr/VogMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGQ4ZGEyNWMtYWUyNy00NzFhLTlkNjgtNDRmZjE0MWZkOTBhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDFjOWFjNjMtN2IzZC00NDM2LWIzOGEtOTg4YzM5NWFm\nNzQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE88uU34i3++rxS6kYxyqDzbo0\nRCeAIEDOHDVBgeJnN/0A1wq2heSYGuCM89+DmETCCcIcjunDLd1GaFJ3Ta++q6OB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTOS3dvAg1E3Hclv/v+xsgFxmyEnTAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22MDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIFWXr2Ws8uJ/MhPqi4Z2W3Wu0Gw67KxIz/a2o93QuLUEAiEAjZMs20d4\nQ6LAVnX0KQiYVtAz617QykeOcb2yG1n7LJE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8925", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8925` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAcQ3xHeTwuXHgG5QktenpTPjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyOGE0Y2NjLTJlNTktNGU5NS1iYjIwLTRjYTk3MDA0MDQ1MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWZiOTExOTEtMjg5\nYi00ODY0LWI1NDktYjM0MzQ4YTE4YWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKD/8ef758Lrcgo1wmFUig1WuJThFGMjD2eYMckqn6Kh5RBHyfF8aMe95GhwA\nqzDNYoEFL7G+oNZDiNhphJ2jS6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC9Y7X3MGWtppNIcr+z2nC0LAvTowHwYDVR0j\nBBgwFoAUjDawhKc//no1O8RM8O1HKTEr0yYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDHy1DYonMvVBVqTw30voZgaPqt\ntW5c08blyqjYsi3VdwIhAKqmaJHHd9XP6gVd4K1VBLPHEJCFCVwXmOuMSR7OCpIz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVQNePyzpS+hvvgnPVHX4tUPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjhhNGNjYy0yZTU5LTRlOTUtYmIyMC00Y2E5NzAwNDA0NTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATnnuxZYjODLETutljng0Tk7isFEtvROPfQF/g/q1XXOIx7\n+K8tg4+qQT2kSfKchfTQ1ra/bq4NDwiEF8vPnbM/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjDawhKc//no1O8RM8O1HKTEr\n0yYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMcjxtB7ZfOm59hOrP4idh/UtWGTvWm4ffnIHEG7qqQwCIQDq7E8++iGv\n4n0TdbegAMeGBZQibqXQ09W8sYa9Nqtn7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISAUrgIQwdVwB7/00rEXwBclHjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWZiOTExOTEtMjg5Yi00ODY0LWI1NDktYjM0MzQ4YTE4YWM2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2IzODc1NTUtZjc0MC00ZmU4LWI3MGEtMWMzZmIyY2U1\nNmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE94IOU3ADOxuVC8MCUWW09imK\nvsUb847/JJLclv0RBlJjZOdGsPUjjTiE6Dg28hQx7X1V8HqtwMC5RWxlxjF56aOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQL1jtfcwZa2mk0hyv7PacLQsC9OjAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22MFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBWaYAZPoq5DR03jov8MsoTD+oPRcnNonToLKiIzqFpiwIg\nG7Kilt1diPzZRkOtJbqoVvYVJFHqFi+DnfXqkF0rH8Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8926", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8926` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAeU095VKzhfOVHAOQCf7vAxPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0MTNmOWUwLWZlNzgtNGMzNC04NjJlLWE0NjMwMWRjMDQyZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTcwNDVmYzMtM2Ez\nMC00ZWY1LTkzYjgtMGU4MzliYzczZjlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjYPYDOb/DKWZmZ2ArPXXNos2At2eVNHCNklcEu6pf3SX8vWJ8kfxcF7J16MC\nAvqX6eZKOP5DH1IDO1BuhnNLh6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRxkv1Y/94UI+Cp+U/FaDlRuwJjgjAfBgNVHSME\nGDAWgBR2ONaBP9wOsTIC3+viB6JZla/6qTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCFuKcs2l81v7hdGJwfVWpL7F0n0fDK\nbTmyrHFVEKgf7QIhAM12vcy7PthnWl9BdpfB8XO0uh/pt5OUElLh0r11K2F8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZqh5BH1lrM6HPwdr4tzFIB9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDEzZjllMC1mZTc4LTRjMzQtODYyZS1hNDYzMDFkYzA0MmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ57+gRwqIc9DmC4v2K7+zFFJi8dk8FwUT42mNVMsHbCWD0\nFJ34Ru0wF0QHZI9sm5Z1DIYzjxPM/IqotbPXOgPDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdjjWgT/cDrEyAt/r4geiWZWv\n+qkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgB/PpbPpmGd3EJu/8bCI9QGaw/O1sm1PYDyOb1ZxtJUsCIB0Fp9sJRcHc\n3m6iDuTUm6+SmGsSAR7ywmSOFZ/80+ph\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXXciftApQV6gfa96HOL1cTQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTcwNDVmYzMtM2EzMC00ZWY1LTkzYjgtMGU4MzliYzczZjlhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjMyZDdmMTYtMzRlNS00MTg3LWE3NjEtNDM1NGEwYjNh\nOTE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfqwwkNgpPOT8EH+IOnZD6TVN\nK/1bWbe3xJ2VcW7wh4jD1RbdXJaaMwLPaV+czOpRp4/WXHlorT60o86diVQOc6OB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRxkv1Y/94UI+Cp+U/FaDlRuwJjgjAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22MFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiA4S/75/ZY4PS0R87r7Snu6xoGtkg76fH5zSjnjO95wmQIh\nAOKLl2f3eEOlbmQTopJIgXlqnZUpwDLjzN2/RWS+AAe5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8927", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8927` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAR6Q4/uX/pOBnSKcYC8zyBXTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0MjkwY2RhLTZiZTktNDViMi04YzQxLWI0NWVkYWYzMDYwMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjdjMTk5NjctZWZh\nZS00YjhkLTlkYTgtNzg4Mjk3MzYxOGVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1kF4R/EihaYydx7DhRvAP1btAFRmlxtQo/PJZxdLOfyy2tCIq5zAgUcnN66n\nqUbmk2vGXx4mPxgqMgKXzSlkEqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU91vh4xX0XJjwMAV1OFujNCVgkUcwHwYDVR0j\nBBgwFoAUM6xlYJrEdoKSJ+FGAmJgTAQD7lswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCKZG2y4uvZZ9FcwRTIfO49MJHY\nlE40OLXI7IxsADmbewIgSdhJ4MAXJ0g4EVBF2zsl7u4EvQVpTIvT/wOrrc8RkTw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATLeuFisdrmft4vY45GnyyVMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDI5MGNkYS02YmU5LTQ1YjItOGM0MS1iNDVlZGFmMzA2MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiv38EQW8zu/lxtGWIxPzGhWlijG8iMksfPjki/SekuCNP\nE5X6hrajpJPYDh4e9W5dHGAWG9RG5+AUyyiFuQYEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM6xlYJrEdoKSJ+FGAmJgTAQD\n7lswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOZL9rFNgyhKOpX/gWLfgxXlfPVuQeCHaR04sGAoqjKlAiA+iFSrQm/u\nC1OvHwzpUSBzFgy33UDMT7WLvnW0/A0x8Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISARZD7YJf4ltHtFsmvQI6s/pLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjdjMTk5NjctZWZhZS00YjhkLTlkYTgtNzg4Mjk3MzYxOGVjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWU3NGRlOGEtZjZhYi00MmFjLThlZWUtNTViZmJlYWI2\nMjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2k8S/Qg78PH8mNmFIIZV+wAi\nw/SJD+vsXHVwOtFLaPkAQx3atRJZFAc/d3c7EnIpGHNi7DgsRsr184dqIVgI9aOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT3W+HjFfRcmPAwBXU4W6M0JWCRRzAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22MFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDRwAwRAIgRdJJw5ax7QQZmYY+wFfH+kHy69dk/zs4M6QXR4OHfrEC\nIB5VzFsSj3rWCWnX9czcAmu+LwCAzv9bvMTnbav5V6nL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8928", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8928` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAezG/t7aY351uW5C8gOEt/5HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhNGM0M2NiLWQ1MzgtNGEyOC04MzUzLWMwNDM4OWRhZTY1ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmZiNzJlNDgtMWRi\nMC00NDE1LWFhNWQtMjBhM2UzOTQyOWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElG22D5eFAXIpVUsNwidD7t1dKchKUx/LKmmOZ94ohX6rPhNnqAgKinBZu6K1\ng/50uCCQlJlEth2PdJN2SpIDLqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRX6ftdXLdsyzUWf+Nktdo7qgTkvDAfBgNVHSME\nGDAWgBTf3YK0r1+bX0dTu32MYjeGxmLP4TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDojRabHlGJkW+EqCl4t6iCB7gvLE6E\ntfOIdWzr9+unyQIgHdtUo3pX74VoUm1D8RGC57FO7aVHqppNbiFNLIIZ56A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZzzOvN1zdzHKd0dn177CMymMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTRjNDNjYi1kNTM4LTRhMjgtODM1My1jMDQzODlkYWU2NWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuoMJSHciQKKqA/wDZj50zaGX9QxxOx3S9sCgss84H5dyR\nnJNfHYQO3E28RXQluGfaOBNR8HlOxs1xO5CE1P5co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU392CtK9fm19HU7t9jGI3hsZi\nz+EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDtyEO76+/++I3SlJkViL8rdFCQ7LMblzyPX1e6jUQVYCIGLj4HWJn8V/\n6zJOo28QjbuABeuTJ/80cGEMgp5swzY2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAenDtWq5FUEkraqqi9WyaFrcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmZiNzJlNDgtMWRiMC00NDE1LWFhNWQtMjBhM2UzOTQyOWNiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTE4YWEyM2UtOWRkOC00MzQ1LTgxM2YtODE0YzlkM2Zm\nNDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDbk3WCn+xy7Gd2nqbOUcYD3e\nrSoeIa27ysForNy4h40/nDpuEKKuTrI6cHpJaxae4Sjykn0NiFDQsMBnfP7RFqOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRX6ftdXLdsyzUWf+Nktdo7qgTkvDAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22MFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSQAwRgIhAPnK1HAPm0/i65EvCqrok028Y9SMhaB50ezO9sFV4UUJ\nAiEA3BajL7J/4KzW/odcHiWgzKcqJ9KEUtjF3UEjIVAdcu0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8929", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8929` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISARLc68sxfkyGxVISrVOMumi7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwYTM0YWJlLWQxMTItNDgyMC05YWNhLWNhZTAwMzYzNDkxZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmViMDYxMTItMWE0\nMi00OGVhLWI3YzEtZjllNjNhYjJhODhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb6QQXEuwWcZ4t53cinejNmAVu4kvv6eq4RKZJH+LOgcZUnw9X50BIEZwb5Xr\n2tf2ZHWK7e0VD5Y+1pR+2fTjFqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaL01oAbhLOoHQpVUFkLFcxnSb9kwHwYDVR0j\nBBgwFoAUbggLf0gujirGgLCkAcCbKasCrV4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCTjelHk2e4C+Jt543hmQ862zuu\nFbQtDq+Uy7UxMaWaqgIhAIgaYeFHu7/DEG+25ikdsvHVo1mOdWddHY21fnwFlxoV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe8BkCOVRp+/tUI1qE9H3k9DMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGEzNGFiZS1kMTEyLTQ4MjAtOWFjYS1jYWUwMDM2MzQ5MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ67Grwffh+fw4CmZXofzx0TxPTlN57u9u4nCWWpxrU1dlV\n6SKW9TeOHQHJNnXdK+bfJX4cGJ1NppfYsLrTFVZAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbggLf0gujirGgLCkAcCbKasC\nrV4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXsgAhkxYmflpdZW1x/xrI0JZNAbpO13NQPEinRcfcNYCIQDA/dJLFiiQ\nDNy/SVlozDxEDiKjfH7sFHPtavNBaAMnKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISAQGAlraeYJAG2ktWt0N4DmnoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmViMDYxMTItMWE0Mi00OGVhLWI3YzEtZjllNjNhYjJhODhhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2UzZDE0ODYtZWFkNS00M2E2LTg5ZWYtOWZmOTk3MjA2\nMDc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErEtgor5gDV9CMvXtwEOffUMQ\nj9IavkfW1lIpUBVeCMOmtDDtVu+XdIIgv/SeZV6LMUb4R+G0YX2dgrPe3LKD9qOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRovTWgBuEs6gdClVQWQsVzGdJv2TAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22MF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIBm5ASmU2/MZzDdVUqmMdFRDYzy9XsYH+8GOLbTYv7br\nAiAtQyhonUlnFkOxB+CLMZYoYO+YjLk33Kj1UgIdA0x9LQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8930", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8930` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISASxfeO07Y9Yrw3Kjo0zZIoj0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmNDJjMWFkLTliMjctNDQ3MS05YTY2LTc1N2U5MDVmYWFhYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhiZGNlYWItMjZm\nMS00OTRlLWIzMTctMjNiYzM1MzcyN2M2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5ukGIStMj2j2OpqarIZzuTkohH9Gjghlgq0Kx5Ob+IfciHEl9X3CG6elBQbT\n8708Jrf8DJvzpEJ4dcmCyCTn16OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRfDK7KyyPvkueb/FfsGPpoXNbOlTAfBgNVHSME\nGDAWgBTSzzZJNRLUjsoLXlPX3ixcOC5k9TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCU45NS0QzadtGSDfwsM1WJFkBuoYuy\n7ocA38Wa0M+PFgIhAM8TLXFo2IUb+kk0idpWMGSVFmw7zLQIKBhc9AkZAg5Z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcZCeSQkMLWaQtmsDjFVb7boMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjQyYzFhZC05YjI3LTQ0NzEtOWE2Ni03NTdlOTA1ZmFhYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+x6Q2QHvSc+1Emihwc7XSHMNcm3OpbUZBPcniDgZQZc/M\nUxf/YVRWZS9dWUM6ivfE73W2tTX4eisgOicXMDgXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0s82STUS1I7KC15T194sXDgu\nZPUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN0EUfxKrqRF72kMJoMFayxYe5yeI5RdGiF1PoiENLJ8AiEAs2NEk/g3\ndklxxpL9NQoJtel0aK+Y+W3sEJRD0kiy7IY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAbZ7LsFlzEhaYBp5xIcvlPinMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhiZGNlYWItMjZmMS00OTRlLWIzMTctMjNiYzM1MzcyN2M2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDAxZGQ4MTktYjJkZi00NDNmLWIyNGEtMmQzNTUxZWVm\nOWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEM69mEdbbki1G9HAMq/l5B4Q1\n3cu09AfHZUfbI4+5rDuqGMMH4xjnzKsTMkOXz2Jhf15R0H1Jo3obczTLwZzWEqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRfDK7KyyPvkueb/FfsGPpoXNbOlTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22MF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQCB6LMbOrHEbpApuViveRS8cHR6udGYcY1gN1rqeUiX\noAIgTcstvt1UxRIh4Op3gGDikVa2E4fvYtp3RZDl2OoxpeY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8931", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8931` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAaTrvzairC89c+rjIe8DSBySMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlZjk1N2RjLTA3OGEtNDY3OC04NDQ4LTAyMTgwNGI3M2YyMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE4MTUxYjQtZmZm\nNS00Y2VmLWJlMDUtZTEzZWU2MzgyNWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcfnPiGbK+GJP4OgY5T5J8b7/O15dx5ureSr2pBGzC0S/sHVYrFyYxpOj/KAK\n4Jju/dezApd5k4IM9tvjlRQHEaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcd8AnxbiFbUk/mOyl2DiEP7FVQIwHwYDVR0j\nBBgwFoAUB11Ga5ahXDSm8WQckHM8PXo9SuEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHXA4D7fHUS1vjB/UCnKJDXq+zEm\nU9ezSzCkcvaYydU5AiBZjsgyr44wOmghlD/uE9FkGbawGEfI4mnvAArMyixz6w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfW+TaUngDCAQQWeNAWoMpBiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZWY5NTdkYy0wNzhhLTQ2NzgtODQ0OC0wMjE4MDRiNzNmMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQReYZe7Q80ABzxPD9sfTVYK16Kcl9CLjDGikryyUJOHx43\nYKg5SnRSyYwvSOx9ZuEdDLn/Hymv7ALUIKSuxaeHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB11Ga5ahXDSm8WQckHM8PXo9\nSuEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMP5QIZ89/d7R8dqyOq3qSvIBHN6qR5LFWU7rhhZgjlkAiEAkF+yZMgQ\nJ4muWYgxhmMtU7EptelwGXYMfm5fnzf2czg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISARR6tymhGLen1Pkq44/DF4gGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE4MTUxYjQtZmZmNS00Y2VmLWJlMDUtZTEzZWU2MzgyNWZlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmRmMDc3ZmEtNjA1Zi00NzJjLTk2MzYtNWM5ZGMxODBh\nZTJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpQcoaXTJU4Nmy8JWKa9wcA/G\nNoKIVYfnRnc8Z6EO7CfKaCH3eG4IMmUkbOqoD8dOblUMgKvA2I+urcopfpnc1qOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRx3wCfFuIVtST+Y7KXYOIQ/sVVAjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22MF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIBBoby1CFmHmv8WrAUh9RmtjwItU5qr2R9ETjCBfxn0U\nAiAX9EGgRpBn0Lx63P9U0SGNeSH9IB9wI2srR0gQLDiBIQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8932", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8932` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQG9/nfJC68Ak5MYlAf+TiIHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiZDdhN2VkLTdlZjktNGE5YS04Nzg5LTYzMGViYzM3NmZlZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmE0MjkwOGItZmM0\nNS00ZGYzLTg4MzktOTExY2MyMTU3YjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7ADyYq66sQTZnFTQ0XnWbfdjDm1udJlvJrygQXKmNkqVrJFO94l1g/f8jKTN\nRwnBJmtShn0tdYwVXYVSbgC5n6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRNE9PYPlrN4pyODmw9klBrHdIUMzAfBgNVHSME\nGDAWgBQZDfrknb3lJzXNqjr7VkuM0icGxjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCQx++kaEnc/LnWYO6qPub91Av5J0qm\nKanObfPtQQ3EugIgDYQMpT0NP0zLCHkQfnYtiZSRljvIr0drII9is4/EXRk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfC4FrRcQxjqCrXCswLhhba0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmQ3YTdlZC03ZWY5LTRhOWEtODc4OS02MzBlYmMzNzZmZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNYKcIe9AiwD7zEdhpAjovr7usq10ZptbeZkhPOl4zdzBi\nkQ0o0nUiZtpf6PVTm86uTNd9KYLUIfUXt06H3urQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGQ365J295Sc1zao6+1ZLjNIn\nBsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOBmJxl7V80oz8HBZI2V1lvBkNtC9uWw/WNxUmy++3MACIFQuD9rn1nW6\ntSvPR5ke+F3hTytVJHS79pWPUWBwVOjU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISAQ98eFzPb/lRk5xGM4KvfnE3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmE0MjkwOGItZmM0NS00ZGYzLTg4MzktOTExY2MyMTU3YjRjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjc2NjlhYmUtMTA3Yy00ZTgzLWE5Y2MtMmIwZGVhMjEy\nM2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9qF8NBA7G5aLX9YTQ9fqIK1A\nTGY9d7VZxNkr8R5mp/P1fynkBBBiZBG2OOE30maEr4iqp7LE8dWgRHn5DbSA66OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRNE9PYPlrN4pyODmw9klBrHdIUMzAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22MF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIG14bk/M8Ha8CzhPKXZ5yggqN76ZhnXcvbeVM9/3ETv9\nAiAVPhJe68xNASkkQ7uStmdtpYAkPCEhn58zq5lUwnyi0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8933", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8933` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAaRB7gLmpX2hp4qoFfwbGIq+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2ZTkzMzQyLTkyYTktNDZkYS1iZTlkLWFhZjY3MmU0NzRmYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA0MmY3ZGQtMDU3\nNC00Y2ZkLTg2YzktYjMyNzE5MzRkYjEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1L68sdMO7+kFdR4Vv9SF4iWmG23tppYVcvSJJK7oft3/VShLOtils8PVlPFT\nDOlxW+T6B4fyuykMl+OW47epf6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIEFU2BJnbtfXNZCCzm7Xp3X+m9nMB8GA1UdIwQY\nMBaAFNN0PMsYnhLpZJ7qg6kDA1ocPcGjMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBF5N9SD0Rs9DyZJ0BnPiEb7vU84ijddBKp\n59qGu4EqtAIgQrItDqua6qvyByv2T5TikCJ/N/IPvuiy9nUn5pSPJF0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAarQQwXgY9vQKBDNSkU5qATzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNmU5MzM0Mi05MmE5LTQ2ZGEtYmU5ZC1hYWY2NzJlNDc0ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPqqVU26YRUZ5TwQK9JkLO8S2q9Jkl5ffzJvf0hVjQLbYS\n+6g0dV4K1NLfbeSFPlqVMpS2UdHWQ14oobG7NpzJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU03Q8yxieEulknuqDqQMDWhw9\nwaMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPciv1zroTUoawfFBGzCNvgatmixr1E8SLBpJdviEHMtAiEA5SRbuPJP\n1m4jE5xkty5OxvRXbZ6L7sDykxstemJPwRc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAUAXNVE2G0h3Jxi9kvuG7o+vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA0MmY3ZGQtMDU3NC00Y2ZkLTg2YzktYjMyNzE5MzRkYjEyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQxNGZjZGYtM2M2ZC00YjFjLThlNTAtNzVlMzIyZTYy\nZGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEq+XH7sOuiRUGnC2G9RN2evG\nAO7g64B27D7o39Sod8ivJH3WqflOWqBXnYledVIBwHT8WCMLV4HVN7DePeyvwKNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUgQVTYEmdu19c1kILObtendf6b2cwFQYDVR0RBA4w\nDIcEAQEBAYwEfwAAATAKBggqhkjOPQQDAgNIADBFAiEAvgIWL/sF+kS8E0+4IULy\nXY7RwbSii7SAzO10/9B2OuQCIFNFcpU0vusDhpHSpDBaPQXJYXlc3X5DwZAFHKS8\nR8cZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8934", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8934` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAZDodmG+d8nrnNR2MOZpk3gqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzMmMyOTkxLTAxNTMtNDM5NC05MjQ1LTNhYjdmYjQwYjA1YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzVmNmIzNWEtNGU3\nNi00Y2U5LWE4ZDctYzk2OTg1YzU3YjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeQzO9Qa0DkJVxoWmq2rOEaMlMBxCVZl/evr6anrEQmbGYyCD3c6bLqT34eNT\nMury+2ZMQjZIYcUrBqLNwwKEfKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFPUi9+OouUm0EQp0t8Rp+hSiYHSBMB8GA1UdIwQY\nMBaAFM9T1WonP59JN5gXxtvtPGelzia/MBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBS5x3JNBS3q4Qnf1bZGMnCCtVOddJXR00C\nQfy/l1tmXgIgPb/iwkoEj7M0QjISRJ5r+gxzJj+Xr9o8WP1IojFz7tE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQM1TNNoxZobBAHJodAw29roMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMzJjMjk5MS0wMTUzLTQzOTQtOTI0NS0zYWI3ZmI0MGIwNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUSdJlgTk3UjCddWsy12b7n/7xSP9Vg417eNFZrUw8zr0B\nZ0SJHyPAVLAaLUxTidQhF1ZQuN884w8pFBXeWAX7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz1PVaic/n0k3mBfG2+08Z6XO\nJr8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALIoL3fiqxWf6n2zq1kZAQhyTmxZvH+Ls4m3HrGI7TqMAiEA010gOE2f\nf29Cn3yemJ73T4gPbbmAai66/uYwERpT0Vk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAc+CRnG1HcoRjPeD/jZZ+ym/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzVmNmIzNWEtNGU3Ni00Y2U5LWE4ZDctYzk2OTg1YzU3YjkxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGU5ZWI5YTQtM2VmOS00ZDA5LTg3YzgtMzMxYWUzYjcy\nZjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETYR0zVr2Mn+JOfBybX2JvyR6\n1cMssHu8vu+5T9WgfS8dSHrBBHqj6zWvM6tL03wDZV5H9gmwqxReU+qpfdZjB6Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU9SL346i5SbQRCnS3xGn6FKJgdIEwFQYDVR0RBA4w\nDIcEAQEBAYwEfwAAATAKBggqhkjOPQQDAgNIADBFAiADTa5dPjydMiENKKXSfASE\nh4StQWhxTIfrZoJO9yEtRwIhAMzKjG99TYYLiwtGJlqUhIMLbSAu1ei2JPo1fW4l\ns81p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8935", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8935` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAXg6Pp+3TGVPn8iSJdlRrTQOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzOTI2YjVmLTg2ZGYtNGU1Mi1hNDFjLTA0ZDRlNjY4ZTg2YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTU0NjE5MmYtM2Vk\nMi00ZjcxLWI2NjctYTE5ZjNhZDNlZmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOYDzfstFuMJBKIBCaY9lLiUM5LICTJCOtVRbY+84l+G9KGKsEF9zFCMl1e8J\n6m+ODMh255Vf/xy6J39ZX1sNjqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJkhD5yilcjv7bEKl0Hwld3xe6JnMB8GA1UdIwQY\nMBaAFGGsM65JectvTNNiXV6T2WZyt1jBMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA8zIew6qU3mrZipf/Atp0qXTcKNWWrJtk\naU/OFh8jmggCIQCZineQwqz3ZTuht1eJWK4U23udOYrZvX7xXxnf/WAYVg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYfCOae8k3+GWkl+7ov9WL/0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzkyNmI1Zi04NmRmLTRlNTItYTQxYy0wNGQ0ZTY2OGU4NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASP6wNpzD/Jqm49mqybU0YrKFrFzgiPNQSHZtlcDdzoZZcb\ndnw+Cxu4MZgfHvKDuIxpIGk3OxgajdcQE7EZf7URo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYawzrkl5y29M02JdXpPZZnK3\nWMEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOSKNQq842YGioJfIzDOfR3V+jVFhK1EhI1Q7wtWqP0PAiBEITXS5kWO\nbs8P8602XOFnNBDWHlbe9DMGTlvzQnMIUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAb0Oeb9NdIsB8WgMs7vxArX5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTU0NjE5MmYtM2VkMi00ZjcxLWI2NjctYTE5ZjNhZDNlZmI0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDQ2YmNiNzYtYjk2Ni00MjU5LThmZDYtODJlYmI2OGUw\nNmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEctZk6BBN9p4U7RlvMxmTpq9Q\nv9DBP1ZWmZiGfP0BmMw3U5iTsjiL+Egt7XbryyhpFMitqNGc8TOXTx8aPBDnI6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmSEPnKKVyO/tsQqXQfCV3fF7omcwGgYDVR0RBBMw\nEYcEAQEBAYwJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIE1rtbpGH75z6h8O\nMzToVNGQkRw92SfbLxRcJ/xnfg+qAiEA7VI/6Aaw6ilWMePNaoJc2kAJmilrMw6o\nCXoYfCc96iQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8936", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8936` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWOes1pmppPfhgkkW0ks5byqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MWZjM2JiLTRjMDEtNGU2Zi05ZTBhLTAxZGEyZTU4ZDA1ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDNiYzc5MzAtZDVl\nYy00YWY5LWJlY2QtZTFiYjYzYzA4NTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMhPPr/UTmgn7c5/NXGRW+7GG6vfT/ipLcWyPI0Vzu9FmAdh0SjsH12ktmasZ\n13ndQiE7MfPvlQ/o1zgOUgP/vaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFCBvMUMV/7w/SnbmqpIMEyyj8fpdMB8GA1UdIwQY\nMBaAFHDYqrqVTsQjWyen+jzHzjhhMcKfMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiEAuTuVK43l3osCDo4usr6fB5wnwoL8qSx/\nFkZ60CnaEEICIEqHCjpuUDzb2IdHnpvmZrIIowGejACpagPyW9uRDK5N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQCuiVt6lxBotlYRYe8oMwC7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODFmYzNiYi00YzAxLTRlNmYtOWUwYS0wMWRhMmU1OGQwNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATw+J/2kxEBZ9VcmyLUCe+BD4WhQeVo8VAGpaoWesAkBgy+\n1e2P/M2DV4FrWCKyAHqmKsDfIFJXw+EECyMIBizHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcNiqupVOxCNbJ6f6PMfOOGEx\nwp8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMv6aWZhkogKGYC9djHOZRlG4R/yO/HyKuhi+o7Cp0n0CIQCWNfm3O6oD\nkSaiY9Vr2BgXV2XDWUfQK6/PABzFgA4yGQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATVGYDp5o8Be6CEJ82nJjIU5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDNiYzc5MzAtZDVlYy00YWY5LWJlY2QtZTFiYjYzYzA4NTc3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzg3OGQ4MmUtODBjNC00Zjg0LTlmOWItZjFhZjNmYzhj\nNmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG/5xdrCPo5MxXxSTRMRZe/rc\nNRDN3mvcnoyRW+PM0r4UGJ/AeRzI7HHB5tue8UdyXtUK95daJxhjktukyff42qNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUIG8xQxX/vD9KduaqkgwTLKPx+l0wGgYDVR0RBBMw\nEYcEAQEBAYwJMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIQDFTmFK31D6na+7\n4y+swc9236TS+phCOODROGbLhU/e7gIgUC2UkrTfW0sUjIYZ5nzWVjrf06sOGeQ8\nhwV/gCLUI0U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8937", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8937` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASlKNzPG/LMg6x+yudAtcJjRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNjM3YWJkLTdmYzAtNGIyMC05YWJmLTQ0ZjQ5YzQ1MzFmYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZhNTJhYWYtNWMy\nYS00NGRmLWJkZjAtN2RhNjllZDhmYzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzfTpoCmINLy+IJ6xgjxDmMh2ZLP6/UNP6rkavlO4tJ6OoB32zdv5yIvUj0i9\ncS53HzQtV+aN6BgntdG3uOKD46OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUezM9fOp9x1Vk3nOyJZ5m7N66CJAwHwYDVR0j\nBBgwFoAUuwP/NFh7nNb5zmNLYm2t8mRHRpIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDai3Hf5oUtpnprfkSTBUVPJCW2\nM3vdGB9QHzjQHEDLLQIgHUs546g1Sm4kZXBtnRmiRROrruw24weJJR2jP/lpICQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWY8OhNu5tVCDZHbfN6oqFBrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzYzN2FiZC03ZmMwLTRiMjAtOWFiZi00NGY0OWM0NTMxZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATKXTjmhxXiIsholEd1Yt3Za7PQT3bDOe9S02F4LxzdNGFB\nS5HNu97e4YjIQ0BJM/tDPKhytrBDDwLCmtOGui9lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuwP/NFh7nNb5zmNLYm2t8mRH\nRpIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMMEEZOc6coiK/+xiFfU/1eEzJLqCSpJI+wRhWeNLtlfAiBhEBNIjXxh\nGsHnMlXVi5h3tZGe8/TxbL4Gkvzt/a5Egw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAca4q/Yp1B9hgcTRz0ppNDAFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZhNTJhYWYtNWMyYS00NGRmLWJkZjAtN2RhNjllZDhmYzMwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWJjYjY3ZjAtZmFlZi00NzczLWEwYzMtOGE1NWZlZDNk\nMmRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbdnZV3KBOlIb8vZB4He/laO1\nTb78GimC3/KbsVyya3gilmH0agN0rqaTx/0QgdQxQIHVxq/GJ1SDZm1EG2CRXaOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR7Mz186n3HVWTec7Ilnmbs3roIkDAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22NDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIGC8TrSgc20y9j9zufKxLuVSfWbeS3wCipSvYlShW3PMAiEAqVx+Tgni\nKjVtjd5m0T2Rff75vCBZY6nSPZQjaT8FrH0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8938", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8938` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAc6cAD6yGi11ri6a4QyAnOWkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU4NzQ4MzBhLTkxYjQtNGFhNS05NjYwLWNiNWI0MGM5YmYxODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWIwMGMzOGEtNjlm\nZC00Zjg2LTk4ZWMtOTFiN2VmOTI0YzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4pqzQfKH01pN/aCOPB1Zg3PIlNgh/f8q2Jo4ti2Sl2hPSnqc6PLRp1T+nG9S\noQP5akmOFEZVmyISDBLLZcLaf6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSKcl4M0qGnrhuoM2YSQ5XSrOaM9DAfBgNVHSME\nGDAWgBQLSI4RDUdwsNHc6wv4FgptI0avSDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIG/IzLUVFl4oyOtjDScmGMW+m3Q562Un\ndIO5APv5qMCkAiAtxusCp/UefhBNl/f6fUjDXpuRK6zutuzsPTn283V9qg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAezpzICmc0ZP25EGVSnpmg9EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nODc0ODMwYS05MWI0LTRhYTUtOTY2MC1jYjViNDBjOWJmMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7cTDlrwXKhLSCi1cdqQhHy3EpUJ6xfq8A2u/8XsLoO7e8\ny/+e/209n30mbA3m1ndco7H4Ey+maak9jyE+j1TJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC0iOEQ1HcLDR3OsL+BYKbSNG\nr0gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd8Utfwk5djWtEDjMUk/LsYootjtGze8OywRr3oVeP/UCIA7iXjmrSV01\ngou2eRLXTEnxMw3pJASj0EizwCbjsOX2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISARn463i+ovUtyOKyr2oAzmgVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWIwMGMzOGEtNjlmZC00Zjg2LTk4ZWMtOTFiN2VmOTI0YzM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjc4YTI4MjUtYjE4YS00ZWU5LWJhMzQtNmYyNmJkOTE3\nODMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMIdH1xH2WP8qR4SWjdyS2pLG\nE7qt+pNs4C8TM5wxyrZzYjQqgd7+7OsHC81qzMFE3yCcYuA907bKIvRDHh3IHaOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSKcl4M0qGnrhuoM2YSQ5XSrOaM9DAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22NDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIH1oRk6nOAfzVEE/lAm0Yug4tTsHIE/0bX8AK/R8MLeiAiBX1neewX8F\njmgti55+Xb34tVgqkiOSUIamFEBfHDOYyA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8939", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8939` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfLPmn4P/mawaeAvjnOLA0lVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxMTVlYjlhLTk4M2MtNDVkMi04ZmE0LTZlNWU3MGM4NGY5ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJjNzI0NmQtNzdh\nNy00OTJhLWIzYzgtZGFmNzRhNWQxMjkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnUTiVJelHKGesEIwa+Uun4Vqp3qi4q2fJ0hikoSaaB2e0q9pxdvMblIGgBkR\nOUPfS0YkkBqvblA6sZOQ2JWeT6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv8dPjVowlvgnhieSdGxmmFfcFf0wHwYDVR0j\nBBgwFoAU8K2pqLhg5OVcMt6W0oYXt308QsYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDyHkjj+8iqb3NweQW0tDnOl2tO\nKq4OluKtU7EPE+btewIgIHSRNTHhiPW/CKae7laB199QfshaLhHjPEGnLJ1vDOA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS/CCZolzQ4CFEFxL/qBp4nUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMTE1ZWI5YS05ODNjLTQ1ZDItOGZhNC02ZTVlNzBjODRmOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLifvo954i5v+VLJcaFeG5yrhi4D6jdwKJaR/mooJdYrYn\nnjm84jQ0fWWASkR9qPzqJ/wpI4SWBM9zfUzkUq0Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8K2pqLhg5OVcMt6W0oYXt308\nQsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD+mQQZfZR/Y6Q2+qgSItbAbZWJBTMAA1P6dckTlp2NwCIQC6ZWzvIw5V\np+RgAQyQpMtIHo4NDQEYWHA+WwoWLAbk+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAa5xXYB5h2Ae/EaKGBjqLy6AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJjNzI0NmQtNzdhNy00OTJhLWIzYzgtZGFmNzRhNWQxMjkzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmM0ODQ3ZTUtODRlNS00ZGUxLThlNWEtMzQ3NGM1NzFl\nNzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPzqxNixUVdqGR/YM09978C6P\nnqKxAMN79ls/hE9LH/GG4mUUeOWnt5QH5uoINVLEj5jbwzNa68HgPvtsbPftX6OB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS/x0+NWjCW+CeGJ5J0bGaYV9wV/TAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22NFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEAhQdjfPHcVJTPUWdgU7lDHwW6NlyfpFAYrErU8JSQ+TIC\nIAcphbKaEnFJT6k5N2neYXc3xx5pApslqzPAhaKjpaRz\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8940", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8940` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISATNzqVf8gVIA8EEjIP0SwJhFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzOTlmMmU3LWE5YTgtNDFiMC1hZjM5LTRjZWUzNWMxYTc1MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZmZjRiNzItNjkz\nYS00MGQxLThkZTAtMWMyOTQ0NTMxYTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECQaIw0JtC/vgN3DGTkN8XFJXVxG8zECNuCVyVwY0omdXNPaFvlREzarIOAK2\nPLWCkVGeFgIQpodbxoLIuo6dwaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRs56i5IrowZHDzWJJasfLXXw/4kDAfBgNVHSME\nGDAWgBTHE7424BUEccjoAGiGA7xOUPrn+DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDLg0tauK3/rhFiYAlGIDis01o6HzPnw\nMXchPU8L7xkGAiBPaDE/rIbmJnm3JdrUHxEl/aXiLI2q7hWvoNFUyVJKfA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQA6sxonMM7KwUf3+C6CaIz0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzk5ZjJlNy1hOWE4LTQxYjAtYWYzOS00Y2VlMzVjMWE3NTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARECdVwYVgRkz89NoIZ53zNgnxGtIsqs/n/NF4NC7aTHfRm\nb1bizJUTTSJx5sfP7B++0CfnHDFOUTXo9bqNAwhOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxxO+NuAVBHHI6ABohgO8TlD6\n5/gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMJwxKpdjV/6gJp0cX58Gfn9QeNnhwaxSTexnP9q74kzAiEAy7HxJYNj\ntuommZfMo//+QO5ztcI7hieTDsY7qaLc42s=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLDCCAdOgAwIBAgISARySLeNZttjZ1ojooh8Ksm5DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZmZjRiNzItNjkzYS00MGQxLThkZTAtMWMyOTQ0NTMxYTdjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWJlZjBmNzMtYjI4My00MzY5LTk2NGItYTQ4M2NlNmNm\nOTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3O/GsLRWIrVva7FWbK4KKykx\nP753IyR2bH3gISZtSfFyRmQ/lW/0CWGw02kOf6J8L3kjz+cK6/fS0phzNpVy9KOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRs56i5IrowZHDzWJJasfLXXw/4kDAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22NFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNHADBEAiBaL001ZArnIiywIqzO5cqGVL+qQmgtGxPsdPuH8xeL3QIg\nCZNfHN7E3lMB+4fIq+YEJsOGVy/kePFaEi+pW6dd5Rc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8941", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8941` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAcu12NYi+p06fSB3fMz1k7/2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzMzRmYjM0LTY3MWMtNDBmMi1iNzhlLWM0YzU1MGMxMDhmYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZhNWZkMDItODky\nYy00MTI2LTgzZWUtOTRhNWE2NTZkYTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQg+7ECMDoXnW+6ZQEErbLaNU7fWhMrSWhf693Vk85yxWZCesjv/4LSeBMqfL\nSIkwV8YaOwXQ6TYNmhK0O3h376OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYMs3Y1ghvDA/ahK+mjbovI6+TeMwHwYDVR0j\nBBgwFoAUYERnYK/slneyIx/YFD2CAViS3OcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCHcMSNp7ZRUkOstBis2ud7Z03B\nafSWZj/VrxPCJYSb/gIgD6gyYrYx7o+V0bK5JZxs0NSfzsJhbBFGPiiCz1Dpi/s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaDjUKkEc7O1tDpx4P5zyxnwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMzM0ZmIzNC02NzFjLTQwZjItYjc4ZS1jNGM1NTBjMTA4ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARStQqSq1UxZJRE0biiop+meE+n/Yo+j7VEpUBE+6Ois/k+\neI1uVro7xUD5cg60GYoSqeplhxOZxu5eAUDhmejBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYERnYK/slneyIx/YFD2CAViS\n3OcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgX9lgpoj1x1qrlAEjKedU2h01aAfNCvR9kWg8RJSIT/4CIQCW1T97crDP\naHsRx6SfwNeeVEHqg2FpLjXQUroWlbl1Tg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAQNiuCCqw2BgkIeA7FwQyGsXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZhNWZkMDItODkyYy00MTI2LTgzZWUtOTRhNWE2NTZkYTE5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTY3OGI4ZWUtYWI5My00YTM4LWFkZDYtN2Y0YTEwMzNl\nNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzJ+qcn/vWO0tPSSuHn2+rc/b\nLFspkyo+q/DOkC6LzQM88e8D5Gd1KQnIspxc2+G/gls0lrw5fru4JUbJLlNidqOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRgyzdjWCG8MD9qEr6aNui8jr5N4zAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22NFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDRwAwRAIgJAayFxJ0oMiRAfEm9n1OQzRoTyczjS85QzETburVCAsC\nIDX7Vl3h9qYses1YOaK4m4cN/ejntKbWsv2nu33P9k8v\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8942", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8942` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcHmH8MM4LOAvbkRbEJ7+udnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyMmE1OTA2LWU4ZTgtNGNmYi1iOGY4LWYzMTFmMDhlN2ZmMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE1YTc0Y2UtYzI3\nNC00NTQyLWIzYjEtNmUyN2U4MjBjYjM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl6bb+EHA3Tyd4SgoIPzjrkqPM6M3z1IESRZbTxobyoNR9rK36eLxDKX4DHub\noCY2RbO4cPz49+sTLBamoVlxSqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQd2C9mQJD98PgdtK6vaCMeDYaQAzAfBgNVHSME\nGDAWgBS/8VpMykcmvRaL70LAmM9ubQpvBjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCPT+dmoJ1StJl4DJtleqU52QD+9R3Z\n1n3xgJkPYUEN/AIgGfRRJxkpZiqK9wizAZPxxZwfsQf1wDEzB9dRikCcbyQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAa8wq+l1o/3oB3hM/ZJnpLxLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjJhNTkwNi1lOGU4LTRjZmItYjhmOC1mMzExZjA4ZTdmZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWbu89k/0GDPwUd7CoSiP+aIkV/OzVNJrCXQYAqQkLQcjW\nOQTyjIZzs7br3kW253nBIhBGACxryUpizBXXNatvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv/FaTMpHJr0Wi+9CwJjPbm0K\nbwYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgR3f8oAxnondVbWLywWlFKK/aBFBxyP3nxzZzWSiBWCUCICjWn9+7dbH9\nELUBJTkeWgDLuJqGSC/VLIiBV9dhCPyv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISATPkdeSQzRNUDvYtTIUSO/gHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE1YTc0Y2UtYzI3NC00NTQyLWIzYjEtNmUyN2U4MjBjYjM1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjFiNjA4MWMtYzhkYi00YTcwLTliZmQtZTRhNmQxNzAz\nZTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzpypQDUgY5XUJlJpqWPCaNIL\n353v9VRfwaa/hl1ufkEmNeLhEaSDpMDXLkU1Aq9Qy3Sk830UTqoCEvZLM/U4y6OB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQd2C9mQJD98PgdtK6vaCMeDYaQAzAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22NFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSQAwRgIhAKzxDm7AQqxuDcl2qXZvcHLT8/gTepNi4TRWghmeS5yf\nAiEA5tglA4gxwFGG4LIHwxVEeKCR2nerMxPOLykfWTlYO8I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8943", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8943` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAfWCAryObMX0Su5uidsV8rD5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MjA5OTYzLWEyNWEtNDIwZS1iZWViLThkZGVkYWNjZDZmOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTViMzg3ZmMtODg5\nOC00OThhLThjZGUtYTdhNTEyODIxY2IxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnHbevtFczsBqYj5tW/YdrIvbxSNUCTyfXOCz62O6ioUcM7fy6/+CRgMKg6sp\nwxECsGh6u5kZPLrceJuOJH/ItqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUob2U1vM5chIbvzM/JftjxmgYD70wHwYDVR0j\nBBgwFoAUmKyyRnqN6nIefHEoxDeBLqYEhiAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHhekqo6FbDPaHvQXzERvO0pATz/\nmDg12mG0QIXdJ/kJAiAFCtyL2894/S/g0uy94gCG+r8ParNoxBFpBm7XAu2N/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQgirK/kWTzqO4zmct6HMXnYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzIwOTk2My1hMjVhLTQyMGUtYmVlYi04ZGRlZGFjY2Q2ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIdoEKX/l758LygC9Mj5vRTdDA2Qey2DrV2BtKUR+Cto7Z\nxXo0tTZrDoVj64hs8l7vpRv0+arLiYLGfIKLjhlDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmKyyRnqN6nIefHEoxDeBLqYE\nhiAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIyyZvd512Zw4DqJCyp3aSdM/aqlRhNjsA6pShoXofj9AiAujKtswt/d\n/0JlvMVyUZ/PfvrJV6CzCcUgadGQatYbvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISARJ2H+XBsLBfShu8h09O++/KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTViMzg3ZmMtODg5OC00OThhLThjZGUtYTdhNTEyODIxY2IxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzU3MDQ4MjAtMTE2Mi00ZTQ1LTlkNWYtNDRiYzYxNzZk\nYzg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa5a7wX0VoN/o0TrCIBFwcczn\nAKAdvp8IPk7IUvNjiROWuRGZeJhokM3z+b9O8IrKJU2IvOg029XABwv9bvmo1KOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBShvZTW8zlyEhu/Mz8l+2PGaBgPvTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22NF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQDnxfVeJBw5kJeG3wiIGHzTiZYPVoXyPBrk+qRkr+s3\nBQIgRnuHAG/p8D+dSeNwWpwzqyHXoT5lKO4O7gbAU2bsUZc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8944", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8944` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAWc1y3r2q9vCO567b1L1XMcaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY4NjFjZjI1LWZiZjYtNDYwOS1hZWE1LWI0ZTYwODM4ZjQ5MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ3MjQ2NTktMWVl\nYS00MzRiLWFhNmUtYzhjMTg1MWU0MWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0zxsePRh+cxovfzqUygl2krWQlq8xIbyN0jeCBNV0obeBMV9LAlREXucf081\nj8EyQUz1owOvr5rSmVuYROMIBqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQuk/Iw2y+cn7FZ6jmzQunaFFSnGjAfBgNVHSME\nGDAWgBSAmr6KRfldpw2d1EgxnmamtPKdNDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDsCSAY+11Unk5L8BFB0xTBtnT8yySF\nD0j3+sXw+Zb+BwIhANdL4A2IDNbTmkJPn6CRkTe5BmFGVMGdepuoNjqu2exA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdRmDoIrBEYlrYhvAkZ65zEoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nODYxY2YyNS1mYmY2LTQ2MDktYWVhNS1iNGU2MDgzOGY0OTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIJT81brNLnTceO2OlZUiBLWATU6gPIR+c/BL5ZsveqW4t\ncHjcsyf6s36WPuC96wcxOWG3liObh810ydMMQ5WDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgJq+ikX5XacNndRIMZ5mprTy\nnTQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANU0LtCvODzxX3AvTfCmvs/CW32M/L8GLX+njB2Ne/B+AiByx3IRrXqm\nQ6vLtwiPti9xGHBV4wVmjnJjtg3v+jsmug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAd9Ts6EbpJuEYXvPZTARsD/eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ3MjQ2NTktMWVlYS00MzRiLWFhNmUtYzhjMTg1MWU0MWJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjcwNmYyZWYtY2YxMS00YTZlLTk3YmMtNzBkZThkNTIz\nODNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1Kzj3NWNZpGHA0jiuZgomJxm\n4gl4JvGDh6YUdoxBCa6err63qePUGsvBritbE/NJIRakzoDnIxz0zX/a34r3h6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQuk/Iw2y+cn7FZ6jmzQunaFFSnGjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22NF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQCibslov0l4wnxDzr3Ne/UULcFJj1p7Yif4h3RnY7ka\nHAIgZ87Jt+R8/mJzbGwkeZ96/obKpz3L/ezWtbDVwVi/mn4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8945", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8945` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfRnwcIe/4p/koXTFtwi1b2AMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxYmZiOGI5LTMwNDktNDI3Ny1hMGNkLTM3MmRhMDU2MzY5ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjEwYzlkNzAtNjI1\nZi00NDA3LThiNGMtN2YwMGRiODBmODIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU1v0PGU3odB0cuFH9kwQIKu1Q2Zahii5krzuYFLo0Dy6OrZAfl3VEXl+0Dm4\n4JMm/SIQBmA7PxufIPXSSbE2OqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHLe/Bwyf2cv1noj6IdZlnU2sKCswHwYDVR0j\nBBgwFoAUzMPpkDBtuso2R/AbqHrJyVWms14wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAJbe7Txx167feEM+PJLx0ZJR2uK\nAFOuvqS+q/KAPsdkAiEA3IbWNxXKCzK1qNLlO7rVSVDCourLl2rJWSYgRoUlmcc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdDw9S8sYWOqKA13NqODgTP5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWJmYjhiOS0zMDQ5LTQyNzctYTBjZC0zNzJkYTA1NjM2OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjOElPIP6ijWec4BARZSicpTlfy6m/f4AF0Ws4FShBNLE7\n5SuOjvqnUeDYzQNjHUaqb2Lqxw7DfUs/Mho70LCko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzMPpkDBtuso2R/AbqHrJyVWm\ns14wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANEDiQM7LCRkjUTVYf8Iwg4hBqbONROwfEU+5tQvSbWXAiEA3mZIfFwk\ng4Lsi/mJmHyLSPz3K2Vw3R6D4UYUzcmQiCE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdWgAwIBAgISAeBhIvk26tFf9l1A+CgxNe3GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjEwYzlkNzAtNjI1Zi00NDA3LThiNGMtN2YwMGRiODBmODIwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjQ5NWE2ZmItNTUwNS00NDk4LWIxNDYtZjFkNjA0NjU4\nMzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaEg89o7ex2C9BHLG4rWRKm+v\nvjzuHMStytGnF9Xweqp00uYIaP0XoFygoPiznga5QQP3tSUEMApI/HVxxwNFdqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQct78HDJ/Zy/WeiPoh1mWdTawoKzAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22NF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0cAMEQCIEh64AF4qda2vE/RNZb5DuvP5vmwDz5wIg+lccNgyd/y\nAiBueJ24TxOBBVyQV00p+aFC9PTTPdss+gguBlCqLaRpfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8946", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8946` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASrUOnajE9ZQlI34MqborFKdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4ZWY3MzczLWNhZjEtNDM0NS04YjMyLWI1OWY5ZTE4NmQ4MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVmYzQxOTYtZjVj\nZC00MzVjLTlhNzEtZGQwZWRhYTM2ZGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZSfk+QOPf4BGwoWh0uav7kl1Mfnrzo042u+O4M4A8BDf3/kyiyIBxcWxx/7t\nzUj4NWQdwDCtS8J+jl3MSKer2qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRecTcW3gHj/A+lwW6Ub0IWtRBonTAfBgNVHSME\nGDAWgBThvr/JTc2UqvFY6NVeiMRyZWTgYTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHSXRi54Qg2rrYVIGnmErmOf19Q9RiUm\nk1AUOQt4H53PAiEA86QX/8M86Kc06DdWZqmWJF/lIG7Y2Nif+H8poe8B1Vs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYHE2P3G5BwlL/NJcq/Ef91GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGVmNzM3My1jYWYxLTQzNDUtOGIzMi1iNTlmOWUxODZkODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEnBAwFwN5b3OIOrzyjFfCbbEofBO1kWxaNoxSLZHYoMpH\n5nbv2L1k5zASPf9CjihiTxQ+H4vqR6ZNSGvtrpi/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4b6/yU3NlKrxWOjVXojEcmVk\n4GEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ1pu7cMoASRy94GuenbvA7pA/YpyB64xiASI/F0v3gxAiBgXFkqHc9E\nlPcZLLnGMVf8iURAXKoLKVrwwXzjwCGJQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAV00W3AiGVzNdsVVoIs80NYSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVmYzQxOTYtZjVjZC00MzVjLTlhNzEtZGQwZWRhYTM2ZGFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTk5MWI3MzQtZDYwNC00MWMzLTllZjctOGMzNmJlZjYw\nZWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3ix2XaFCtNg8n+ZwQRsqw13s\niuvLeDJASwJ79IL0BZA6qhhmEFIWnxwZMA6bKPrmm7NuknaMNQqmov8b1tCegaOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRecTcW3gHj/A+lwW6Ub0IWtRBonTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22NF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIAENRKdv0lXM8zFHqgQ2mJP+3JmXyExFCbtiFY2/K5SH\nAiEA3AU3ZqwLhMzElREc4XGJOlw86+rLOAFl/wGiT2i2NIk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8947", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8947` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAaDGgbzfXpG97kaZ3lsubwl5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhOWViNDIxLTU3NjctNDQyZi05MDgzLTA5NjkxMjcyODNjZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJhYjllNzgtZjFk\nMS00N2M5LWJmZTItZGVhNjY4NGM4MmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX59Z5q8aJP+wtLBUHvPZUHoBT1RzBABJeWHF+Ip9vfx97ay6l9vSAJR7bdbR\nd+zq9d8RKKhjj5O404U/Z0eyTKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLWLY7PTC2k2115Mt2uKYySVmZBFMB8GA1UdIwQY\nMBaAFLqV7h9o0zLbPz5rg96TkVacLXYzMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEAxINrXJOibQ8ZmUYHNASL6pUJx5rSRZB+\nM4sJ3mFpaQMCIQCPLGTPuKRYl7qkOQU8kvLXUExLJVSvNHV7Hf4FUqETyg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdAeNgrNDlMF8IKiUiszebs8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTllYjQyMS01NzY3LTQ0MmYtOTA4My0wOTY5MTI3MjgzY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQCk1bgxfvKRMzYAat5yq9PsZ/UWJ4loOJ9AfEGiVDCcZhn\ns98QT++d2T6PaGT8pFZjSNGxxeRHYip5Uejs3bQho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUupXuH2jTMts/PmuD3pORVpwt\ndjMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcbVppW6sHfkN+wz64bAKQpDp/B/yw9BgzrWOWFhnkxUCIQDR+J5rXuB4\nb1/j1W61Zpxg48kVIFG4t1xJvdnp7tk/ZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDjCCAbWgAwIBAgISAXJZWghbuTzoHAcNN0wHGa2vMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJhYjllNzgtZjFkMS00N2M5LWJmZTItZGVhNjY4NGM4MmZiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTIyYjA5NTAtNWIzNi00ZDhlLTlmOWItODEwY2NiNTQ1\nNGU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2Kx6Deu2r+lfP79O05z7vUbv\n093BcAD+5A9SqSQ9a5JS3n+ZmruaSZkSMt8XaQksjUhlY6WMBV8zmLRLwiupTaNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtYtjs9MLaTbXXky3a4pjJJWZkEUwFQYDVR0RBA4w\nDIcEAQEBAY0EfwAAATAKBggqhkjOPQQDAgNHADBEAiA6pT0EVchQoVOhCbSwiPWB\nXWvtHBwgO+fARg1sDrzBBwIgKq5Dx6xa8bo3NQZrOrVEpnAo/F6UYLJxSmf2ZqPB\nnG4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8948", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8948` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcJ1Hrl1rebc1pKn+Xz3mzF/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0Y2U3MGQ5LTIyYTUtNDg1MC05NmY2LTAyNjgyZTI4NDAwODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRjNjRlYWItN2Zl\nNC00NGZmLTkxNjEtNjhkMjI5NjY4ZGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVsnfVH/Mun6MgaPqldz2A3w8V6OiXrpANCKwPRpdLoboFt4S6UwgWwEhtrfr\nGcI4VMnwOu87UPoT1BkfioPMu6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLY2SNdbNLKuwGYUzVutjyjoKAxvMB8GA1UdIwQY\nMBaAFIDIw6oqJjqSbMunr7UtDsl15HbNMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiAxa4HnQ5sLtUWXsON/30yKmpDOzXQAEFQK\nh8HvXnWVyQIhAOX9qGpGCDXGNzUtsRWCBfVmkC7SOqMluAm04GtwHRm9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYn2aujPUXyqFHLpuXToCAXjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGNlNzBkOS0yMmE1LTQ4NTAtOTZmNi0wMjY4MmUyODQwMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOke1t2FQVzjS+/PGKgSNmdnArQ7GWG6AHGIQgGo13ifeG\nb6FqAbYzxLuzW7rSezFQzML5rF+PW0dWoMyWfHlwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgMjDqiomOpJsy6evtS0OyXXk\nds0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPzkxEQx3uZqnqo9+OieA0YQEre46qOjPZncFn6ZRFvLAiEA4aeslarM\n8ihPcngCgc8ZGeeWX4Xsw3oGEBL23w2YR3E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDjCCAbWgAwIBAgISAU4paKcniW16bi7pBjoDfAoRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRjNjRlYWItN2ZlNC00NGZmLTkxNjEtNjhkMjI5NjY4ZGVmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODY5YmYwMjUtNzA5MS00NzE4LWJjMWItMjhmOTFhYjNk\nOWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOCit30YUB+LmHGFSVDX2L3tT\nN4J+jXjq8l05Tkx2KZR/UJvDqKMy4rTAfdu0yKKRI/oWUs0NX8sJa965LvnbqqNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtjZI11s0sq7AZhTNW62PKOgoDG8wFQYDVR0RBA4w\nDIcEAQEBAY0EfwAAATAKBggqhkjOPQQDAgNHADBEAiADLB7Qu0gE2ZCVgXZAcI8X\nrrYF75RoL8Mdn6W/U4LiWwIgffyp/b37d1OX+9V4C9xokNc31Jj4tP2cz9BilhDH\nXU4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8949", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8949` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAaXa4Yxea1GSkhl+f+QrT3iNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3NzJmMDA0LTNmOTgtNGIxYS04MjA4LTRkNDM4M2RmYWQwZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2ZmYmIwOTQtMGNk\nNy00N2ZlLTgxMzgtMTJiNDQzZjk4NWU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE86W6OOEMBknQKl8vj9E69qC2CF+G/UTXk/tMksl9dfFKtizeMTugckxS6185\nJBkfbx9JwpDe359XQCk4Pb/AfKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFNEuXEkadm9mRXM6CljXNV2vmbXVMB8GA1UdIwQY\nMBaAFJyhhpBts+GXCHz+yKgPYjTSExWFMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA/pg/NmcebpambINWrLFAbu2PnhV0ojLy\nMAwx1JKIRLwCIQCFehZ/7K1RrT2VHIDl4WGH0SJI2KH5yqw/tAU/3itAog==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfe6utZw2VEBWhhoXDtCXR8WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzcyZjAwNC0zZjk4LTRiMWEtODIwOC00ZDQzODNkZmFkMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMis+X8NmnQ2c2F0l4oHEtngQTGPrAWHNnG6h0OymFfXIJ\nGOAE7PnTvIIpD+rQRk33F142R5/7hYlyP7VGhVyvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnKGGkG2z4ZcIfP7IqA9iNNIT\nFYUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMkYffipsetpOIXcyzUsjqWhgppzzHKBSHVQgHp1DQ8gAiEAjnR54XeA\n5MUOhZh/t8J5vApuofb/ITZ545PtOcoH9oU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAdY9C1qbx7/XhpY7lGW4/80eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2ZmYmIwOTQtMGNkNy00N2ZlLTgxMzgtMTJiNDQzZjk4NWU1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmNiZDg5NjMtYTIyMC00NzZhLTk0MWItN2QyNzBiYWIz\nM2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGhrG10rxiFx5xZNE8wsKNV7N\n/fA0OVnTspVepf4AAF2+5wpB7kEyheUJiXbH9ABCyAwXppqBcon9QwkHlJA/yqNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU0S5cSRp2b2ZFczoKWNc1Xa+ZtdUwGgYDVR0RBBMw\nEYcEAQEBAY0JMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCIGmUGXL9OKESOwT9\nfrBi9oI/dKvPZ0gQl+8dNettb1QnAiAutGCmnSd/sjMd1HDda6u+H6jIJ57EeEl1\nCs8InOP5TA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8950", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8950` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAUp1aKds8k4aqCbVKOwkeyQYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0MzA2NWIzLTE2ZDktNDllMy04YTQ4LTRiNDE1NTgwOGZlMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzkyOTgzMzYtNTA5\nNy00MmI3LWI2MGQtYmI3Yjk4YjZiMmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAq5SCTd2DZGMuuLBJ87Kyi8sAK3sdADPfTyJoVyX5HxPsggr0DqFrBrUa8fz\nNUCZfA3q/WKFMa7S7S9rKgDtrKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLD+llSLno51FSyeBizuSWvh9R5EMB8GA1UdIwQY\nMBaAFPWco4ox9zI2xzaf60fRVYY5EK5kMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiBngJTrOee/BACD66x6LROvz8wQcWCJIYMZ\nl2io2+3sMQIgCf5KfLicRKT4oKvrM/5ih63Yxt9DscN2IAABlOr6zow=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWQ+bOEnlEvqLupCpyouFjm8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDMwNjViMy0xNmQ5LTQ5ZTMtOGE0OC00YjQxNTU4MDhmZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRhCKPsVZyA6njD+ZCQcU0ZEYWahrksZq/GVezXlBmYAKY\nd6ki0fuvyjVcAd0D8DTkz89BSkHmNN5GX9oabRQ1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ZyjijH3MjbHNp/rR9FVhjkQ\nrmQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMIYXEs9N6x8R4XtMU8fUytfy+4J1lqZ68Yo1gJ+7fRoAiBgloNZUGKw\nSVelsYLS3AVJKTok/ZjMqvIXzjSlie86Qw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAb4w5kBZZSbymZ0IK9L9e8xLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzkyOTgzMzYtNTA5Ny00MmI3LWI2MGQtYmI3Yjk4YjZiMmE2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmYwZjg1YjctM2UzOS00YWUwLThhNjAtZGY5Yzg5NTU1\nNDgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHhnLouh8qPe5bHbbuni26uyX\nTiveNBBP/uV7/Ydx3KcTAG458x6YPYgTWg+j8dR+ZNJE8UYtIGNEK8GPLCdvmKNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUsP6WVIuejnUVLJ4GLO5Ja+H1HkQwGgYDVR0RBBMw\nEYcEAQEBAY0JMTI3LjAuMC4xMAoGCCqGSM49BAMCA0gAMEUCIHfMAcnElfO5GKTu\nMfgG+J1+J/HQGD6ccY7XgN/94ldcAiEAsxdBW4iBjdOj9Ll80pzeAFfy4q6Oy9Vf\njPpMQoJiWZs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8951", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8951` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASLfLuYEjeabtn4c/sN30XYhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwZjE4ZGQzLWIxMGItNDMwZS05YTFjLWYwNWY1MWY1YjA2MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhhMDRjMWUtNWQx\nMy00ZjMyLWIxYzUtYjM0MDhhM2EwMzIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7GhuFroMZKjPU/Lrg+VyRQL3ZqnpsIQM87TO6MWwxXVbU1P4y+td8QgCg857\narC9xyXqFKnFaGoH9AhsiDcaU6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4H35BxTCvUcAa+q3h2KydqkRYVYwHwYDVR0j\nBBgwFoAUSnKc18AspdkHM27Uodktb7U3i6cwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDN38s7XyPeocbs1hfc4AQqaByN\n2S8uXejel8SB5Gh0owIgTzxabChX4tkI0xlxzOD/YpMgqCZmyDODg6haC5isljo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbs1jvr5a9Bp3buBHlw//DkYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGYxOGRkMy1iMTBiLTQzMGUtOWExYy1mMDVmNTFmNWIwNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQf5qYmaumPfN6vfZYgkogYFd0GMTvQp+GzR4KqjIvkKRcG\nY68f3P7urwKL5gVBYP23CLLG+LxGPIPyDk27wchAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSnKc18AspdkHM27Uodktb7U3\ni6cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANcAqL0Tlg9uQJ8S76cMQZDGriAVQN/Lj6KDk9n8msF6AiAK7XuCHVGs\nPcqw1CPMkSOmyNp6TqrAEOMfiL14RVjavQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAWwZwB8RfT1FaNf1nZgl9ruDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhhMDRjMWUtNWQxMy00ZjMyLWIxYzUtYjM0MDhhM2EwMzIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTNmNTNjZjktZDYzMC00NGIyLTk3YTEtMWVjMmY0OTg5\nMTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgvlanoFiHhrv7ztWAorWPGGi\neJbX+d6mZw02ha2nJGz7rKRWJ2AFU/syIqTvofQwOuSBN9oTVGXx2m+U1jB24KOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTgffkHFMK9RwBr6reHYrJ2qRFhVjAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22ODnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCW85LGUyC6nOHhTnS77LjVylDohwOdQEA3kc4xnHm0cQIgTz3LaznN\nKf2A0IQYNom2TUOquWHtN22iQrkwphBCwpY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8952", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8952` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbYzu3RsZSIoeaICMPu/OP+gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4NTg1YmMzLTFlOWUtNDA3MS1hMTkyLWFkYzQ0MDE4NjgyNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJlOGVmYTMtMGY1\nOC00YWFmLTlmZjEtOTcxOWIyN2IxOTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXPxO6fDb/McX4cKm5VdX6kN5KzBYhvyFVD5Dn9/DIcNqG69q2LQ3Vg0Z32nk\n1qPTto9j1kbheuYEqAx5jvQwraOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT9x/3DEGZqXJog24OI6i/+Tqc2/zAfBgNVHSME\nGDAWgBSzWfOCrONlASphWSsgFgjvhuKnJTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDFcJjoP0C3cG0bbkf2R86NrDXtxvP1\nbwH0nnUwaz176gIgR3ggdLFw+rhcY/5MjPuzT4JTYSU0PoTgXBW6bzBsjxs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeH8CwmKPSz4g5g2rBWfIcxLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nODU4NWJjMy0xZTllLTQwNzEtYTE5Mi1hZGM0NDAxODY4MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZzuy4ogjOOvNhEy1lCU8OzMWD9bp7gKQgF8tt+MEEJL5j\n76lFQq1sNjt8Rn08bb/vfAxPCNg1VaymmRCmmhKUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs1nzgqzjZQEqYVkrIBYI74bi\npyUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPpkJYgtZfYbQD0zNjw5m8OogSvp7Z5XLPxKzFT1oi5wCIA1bvUNP/0vJ\nTnv+hBqtkIbrJyg+58urPKabYCKp++uH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAcgUJUU4VHduROtEtR5yZ7YLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJlOGVmYTMtMGY1OC00YWFmLTlmZjEtOTcxOWIyN2IxOTFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjQxZGQ2MTktMWU1MC00Njg2LWJjNTAtZjUxMzg1YmI1\nNTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqrvpoekOrwjxJqn5nbe9+88I\n4spvfzyg3k4fLnsADWAlByDQ2oIASID2TGpZCF5S9SRIPgPZBvmP96WqTpwJZqOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT9x/3DEGZqXJog24OI6i/+Tqc2/zAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22ODnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDShrFCet4DKJsWw04ARN/sULU4GYxS2ubDgE5lEIhnogIgGQuon6HN\nXzOjHTVrD4kq8zDyfaThByH18O/eMZRjeb8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8953", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8953` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYpHqYembeHxrRiBDjvEf/ydMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzMDQ0YTM3LTA5NGEtNDM4ZS1hMmEwLTU0Y2RmOGZmYjE2ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDg2ZjZiMzItODNk\nZi00NWY1LTlkMWQtZDFlZjFmMDYzMDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3eFZ7F9LLwYGQTqD30QIe9DaPrvONkwC9YjbXtCyLwMe/NrMKoXanrQMVQmn\nlNWT5nvEEkG3j/dPZDC0+h8+kqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWMdmvdb3pRgZFWgsdBjm5rcp0sowHwYDVR0j\nBBgwFoAURA1dwfBlpYg8KN7vAYYoZuzZuQkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCZnBsCRzkirFvKcXlVUCt6xOFE\nZ9BQrKt3DjscHrYoHAIgKMhxeVDZ9oP3l8AqSPMPEhScRCOVMkrwGqQI+Sj4rNw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaQ+Lfc6lqcqJK9/lBxfWD72MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzA0NGEzNy0wOTRhLTQzOGUtYTJhMC01NGNkZjhmZmIxNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfD+1ieqmcRPKeBLxz7IPoHO0XrD/Zny5U+8uGQ20UgFJP\nb4HUtkY1j4FT1DYvT3AiYJ6QD46VWwo2GI+diEAUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURA1dwfBlpYg8KN7vAYYoZuzZ\nuQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgK9DkZY6o6rUvi7yKxRli0Bg816vONCcC705166UevR8CIBVHWYYNyVe+\nA05nx8vwtcruLeone5rT/W7qeAZnwDvW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdOgAwIBAgISAakkqCxma0NI57ntQMZROrGHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDg2ZjZiMzItODNkZi00NWY1LTlkMWQtZDFlZjFmMDYzMDg5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTM3ODEzZDEtYTEwZi00NzJiLWFjYjktMjNlYmNkZTNl\nZDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHa81g+eybPcvcgE79RWZx4vJ\nRXchEaa9VGhyXIKzwNAhrpYlaNENHT+If91Yuk1JAaaBRaEP/sR765U7d8xCFqOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRYx2a91velGBkVaCx0GObmtynSyjAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22OFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNJADBGAiEAmqluAhpDZllxhGpcd4umKJOqnQfM+ic9QmpiA2fAZT0C\nIQC48VPFSQCaxZjjFTwSj3oUXQwmEz0mHc6cB8km8c4Yvw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8954", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8954` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISATn/8JBoDlG5WUwKn8MG0WxAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNjUzNzEyLWUxMmYtNDc0Yi1hNTY5LTIzMTJkZWU1NjQ3NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDE1MDcxOWEtMTU3\nMy00MTM5LThlYTEtNzdiZGQzZGUwYmQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPaH6OZpO6DE/iPWA2TrEORXjheUobmXipkMhAZ/z7Xyf2/zPjAfRgl2vpGga\nsrfOx5U35kaJ8NpoBxXYXshFOKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQpGKhtpI5Un1FZxHVIreeen2wx/DAfBgNVHSME\nGDAWgBT6ptWeIH5z06RQplEcxIFIx1/uaDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC8/c0gAdA9qj3UJkmHhBCR7iujkLe6\nBzOjpJ3fmN4bEwIhAPRccacLp5t8aad/FkehnkF/MxcsGIh06qWkv2HrMyTM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASiG6FuxmeVREdCGRvQrAvlEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDY1MzcxMi1lMTJmLTQ3NGItYTU2OS0yMzEyZGVlNTY0NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzgbwMsbqwdgeHNIRJPA8b0QWos3t50aCgQP/B1D1EIa18\nf7KMHiJR1W1oAmSKsG7rvMnbr9iNqmXjo3IqcCpbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+qbVniB+c9OkUKZRHMSBSMdf\n7mgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPfcTZnLTDB1tclXPsC6TUUciD0M4EtFlJnKItg2l2g3AiEA3dICmQYS\nzDiLmolI9TpPwwyGuARJwnOKnwxeBQ64TPg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAXVH3hHlq39ekANQB2+3Qs+fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDE1MDcxOWEtMTU3My00MTM5LThlYTEtNzdiZGQzZGUwYmQ3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNThhNjNjOWUtODE3My00NzQwLWIwYTQtNTYxZjViN2Rm\nM2UyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECXq9p0jQWEizB89jGcn7Bo8e\ndm4/H3l/UoxOPiFX/HyJE6hIgYat86IkSXOFRlj8C0GLkiRqj7wdO4JpacfQXqOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQpGKhtpI5Un1FZxHVIreeen2wx/DAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22OFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiAkduR6oGRfmpop9p0Nyeo7dYgz5FnamPkUW28AnHnIBwIh\nAL3R1T8Gg6Kcf2tAQhm/7lXRG35vNnDc1qCfJ1yyscVq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8955", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8955` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQw9QeJL2BIlH7Sv6C5MIFe6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlMjBjNTM0LTY3NTctNDlmNi1hZGZiLWJmZGE0OTg3YTMxODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZhMDBlYTAtMmQ3\nMy00NDg5LWE2N2YtZTU3YzU4YmUyNDZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvBEJFM6to/Sb4R6+t/lNED51eCdbqMXLQmq346TE95Fv0KusiD81i6865E1W\n/lzr6yy0hMyUB9TMFWN/8/sarqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYs6HZjYneLH5BJz2Yvub9ioc+DIwHwYDVR0j\nBBgwFoAUsk3A4cwjQeDGr642S/aSIQspw00wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD8pHWw1X9I1mStXVUMEtqAEGMp\neHsJrgYFGVPFv2uvkgIgT0hTYJ9osiYsiH5LUH2Olq4Q+2XC82yhDM9Sgm8zp7E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT3zm0OwhVan7M4FriNzGs5WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZTIwYzUzNC02NzU3LTQ5ZjYtYWRmYi1iZmRhNDk4N2EzMTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJZNy6TjZukKjCIH5KIUBZviU2jnJNxHIe/ox+G92gTUq6\nLvGT+TD4GisXDzUkQdgiySSe78ylcH7eDzb9xXxzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsk3A4cwjQeDGr642S/aSIQsp\nw00wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANnxHwjr3RCq8hGs7h8GvhZTXae276riSLlgwPxxE16PAiEAgA4ChF8u\nhtCM5bfoPsSVOfNfLeYXL0ZFnuyQ4rP+mGo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdSgAwIBAgISAXKVtqPUkM9ASdAuMhBfyM6kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZhMDBlYTAtMmQ3My00NDg5LWE2N2YtZTU3YzU4YmUyNDZiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWMxYWJiNTItMTc1NC00OWIxLTgxZWMtMjk4NzU4MThh\nYzEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjSmzg3y8hd9thft73PR9mtkL\n8UIuDJV6cDjLXQ6nRWUhS1Xw8jfUezgDvlh5I8nmRP8i2nOI7CFtd/d0YrHz+qOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRizodmNid4sfkEnPZi+5v2Khz4MjAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22OFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDRwAwRAIgR6lHY8ZqefEVUvbayJ6qBTxqccaR7qOQb186naPiEEgC\nIEeba8YO8EKUtOF/P3QJdzf+vetj5qHH+EIQwBEeIHpF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8956", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8956` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVFyklV0DuYBDZ1xwBexYbtZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkYmM2MTZjLTlhY2MtNDYyZi04Y2E0LTJlNjg5N2IwZGQ4OTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2NjZDhlMDUtOTI5\nNC00YzJhLWI0YzgtNDBiYjQxMjE0YzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkq5uSQebBSKIL0KXJCnB8BE8uInLjdZBu78YXzlqXP/tx5QQMkq1qn0wMgZB\nwzqUVNfGGx8vIGnEFkLsVg7DdKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQzWdCkW/rl7p6J/Y3A/8w73yOe3TAfBgNVHSME\nGDAWgBQrWtBW/2O2jSl8GlLIEC2SEkzHWDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEGRv5OxbZpcyqjasrFINZz7C3oqKHAH\nUlvvHEHycUwUAiEAp2To0QXTHLBz2U98YgZM1mfJ+5d5pdp6Nm1mn90rizs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfnnvs5fmD1wBMWZH/GPT/WeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZGJjNjE2Yy05YWNjLTQ2MmYtOGNhNC0yZTY4OTdiMGRkODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7bCIYtpAtZ8k/utHyFoSKJ8QL+LG0z0fE/bYsC3mvYqd1\nMDLX5kk2kAGqjS63+FMIMkVqM6vhiKm7GzncMw4mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK1rQVv9jto0pfBpSyBAtkhJM\nx1gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANiBSN1mZoQz4H20XzT/cxM7Ze65EAwYk+ndEnhlF9eLAiEAmKU7R2kB\nYQfZon/3NgzYfdXFSBNTdhBZEugkSLLdFQU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAdRQbxeH64dyaEAq5xzNbLzbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2NjZDhlMDUtOTI5NC00YzJhLWI0YzgtNDBiYjQxMjE0YzlhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWUzMjM1ZTUtMTRhNS00YTdhLTgyMTYtZThhNGY5MzE1\nNzU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERaylWpMuub1gcUiGh4WGjrTx\nSWRizqGFxI3URbv0X73tmgZ+HO8/UZhJeYaBnb0/K62BzoMFXlWsy8D15dsbdqOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQzWdCkW/rl7p6J/Y3A/8w73yOe3TAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22OFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSQAwRgIhALCwnqI5a19qdeRH3j/dAyH8g0hJoOvNGCBdtz9uHNCy\nAiEAnV8lGDGVB4hoOggSgUlP2DucgFd3X8qUBvLFOD77uT4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8957", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8957` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfAZvb/xzaH6jhU71LlkZsdkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5MTVjNmQ2LTc0Y2MtNDY5Ni05NWI4LWJhNTQ1MDlhZjZjMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY2YTA1YWUtMmRj\nMi00MjUyLTljMTUtOTdiYjc2YmNkYThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWEKJlX2Nz/N1jPQgNYqNScJbKv1Sh9Pu/lksJy8rKFxYzLRcpnscAfR+CRPm\n6s8I2SkzaID5foItfT06LdZZ7KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUojG0qRa18ag/Cvwhs4422OSmfdkwHwYDVR0j\nBBgwFoAUmWImttd/Qwa1VhH45FBMvvkmkawwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBhaH2aoXAWH65iv/Ggkd08lzNDp\n7JuYhD0H23InyGqBAiEAnp9Dj80+99h0UKccNYpynbbGjEwTC47pLkOlJ7x/HiI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeO+8XBLT8hOJ1+tdyHcyydIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTE1YzZkNi03NGNjLTQ2OTYtOTViOC1iYTU0NTA5YWY2YzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpKMeR06Xmiw5LnOpqH0M8q8xkeUFuPDCUzTFcZyrJ2CR+\nK+psne7xli3OLzMgrefWyml/NP3sNDSwt6msWNyFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmWImttd/Qwa1VhH45FBMvvkm\nkawwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI/zUVPlzuBLTGDDk957PP0gWnT1Wjb9vLX1U7w/nG7IAiBVRvNDHIH9\nkIheXHbeZ/vu7y8gqFptv8a48GqzJJHyHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAcOFaqtJMCZ/wP2RMTbk/fZyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY2YTA1YWUtMmRjMi00MjUyLTljMTUtOTdiYjc2YmNkYThlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGI4YmE2MWMtYzU2OC00MGJkLWE1MmItNTMzNjlkMDFm\nNTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWaN79TgYmRUGm/MV89sCCx1t\nGGVlJ7jYX6YnLDmbmpwMWYyvw0LmhrFGbHm7d/ubbv3ASJq0AkVu3PylDInaLKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSiMbSpFrXxqD8K/CGzjjbY5KZ92TAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22OF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQDhCIpnSgSsxRGBW14llTpgcT2X4pCmywVFBw9JggMw\n7AIgROl4LT1OLVnWBDoV/KcgQs37/6cbVvyU42BqJeB9a+U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8958", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8958` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAX2mlGYQ4RJkClzAeaEze9APMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBlNDY3MDlhLWJkMzktNDU4OS05ZjJjLWE4NmM3MmU0YTJlMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY2MGIyYzQtMGIy\nNC00ZWEyLThlM2EtMGRjMzcxYzAxZGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGF8gQ40Rd9EbeB6aY18K9Vft93RnOG/+cc7LI5wcwX2GefYYF0jof3d9JgZI\np8nhn1UTl+SoefD/QBQq53Ld/qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQGWzVj+cU7pRVYlrD1a4Q1KrhnWDAfBgNVHSME\nGDAWgBR5Ghhwap9n478gwi+hTcvR5Ny/zjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICuujkX/QDegrW0cEzEsixMWlxrg+z32\nYjDyfhyVDASCAiAxhXJu+TPernTfIopAQiSquLrVfWHMGwUClwOkxVQJLw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaNS8tRUKR1bmsSlZGawjqYqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZTQ2NzA5YS1iZDM5LTQ1ODktOWYyYy1hODZjNzJlNGEyZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARUqbpts5usfdW9/f//MdJmF59HksJzlaPDv/C6Zn5FT1yk\nNZGKfysSUVrlUiLiQnllFfsrIJZx5W/7ubHnMmTco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeRoYcGqfZ+O/IMIvoU3L0eTc\nv84wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKbobROymlQxi2cGDBhNJRn2lJfghWxRbVdcr0J//LqGAiEA5KJodGkD\nV3BL+HxNtme8hWCMvEjxIwrDYLSekpcVLBE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISASxgNyFAFYVtdqmQTJ5yxHYZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY2MGIyYzQtMGIyNC00ZWEyLThlM2EtMGRjMzcxYzAxZGU0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWY4ZGJlZGUtZDc3MC00MThlLWE3NGItNzAzM2RkYmJm\nNzkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0bte6jKpri3/gd/JzoQEIsvy\nYAj4qExjHtNPGVsvALwZMkRlwTljrqVuKAa0JnMAKQTRLQcdcLg0/1Qv8rwae6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQGWzVj+cU7pRVYlrD1a4Q1KrhnWDAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22OF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQCOj6Q8XxTrgX6iYbT1Hntfsw8Wwwcg0Ih9/p9LeOOV\nEAIhAMvFk2+8MbKueZ95St6KXzJeZbWWxSFq8YGz48rN+zOt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8959", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8959` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdYJPtKIirCYbmfRftx9s3UsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyNmE1YjNkLTQ3YjItNGJiMS1hMDVlLTk2NjVjMDFjYmIzMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTc4OTY2NTctOTll\nZS00ZDk0LWIwNTgtMzljOThkNWY0NzM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElt792KI1JLd0QgJgfvvMOp3bF9xN6IOWeXhCWcsBPl3fy7RgdvVuMC1LOunT\nx+crMuU5I6Lbraf9NnIS/Dp436OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6GJM/EsF8fvHBDRXntYwF+NBBn0wHwYDVR0j\nBBgwFoAUUsKOOlH7GCGYI1RQHvs2izAxsNwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDnyUMNu8GHwcJfdnX1+kscNBUG\nifAtfd5sURH212qBaQIgKZLToLZwPDtAhE+hHExdZwz2yrQLaO+uWXYB+oXKZwA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXgdLJUp4dfL/tDY7+oexMrMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMjZhNWIzZC00N2IyLTRiYjEtYTA1ZS05NjY1YzAxY2JiMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATkED8ixFol0FTNgLkk/7PbPYzfAXjyYFe6IqY+BkI2HM4t\nRkJYvbUvs8LObWRLqRvPCkYJgiSYLOCyLoLT2QvRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUsKOOlH7GCGYI1RQHvs2izAx\nsNwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIganvXUlNIzXwp9U7wzGc+wHixpO5104m38gpybRb8oHwCIDqWiDPpFbI7\n5HPoibH8vyXHABCAATWjsjMW0f4ZAP/Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAVckmX9sh+xW1MjOSBIi0HqLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTc4OTY2NTctOTllZS00ZDk0LWIwNTgtMzljOThkNWY0NzM5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjVjMmE4OGMtMTQ5Zi00OTQ4LTg4NjMtZTE3MGQ3OGVk\nMzI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtij0ZAfe2kf4StEZCYqP4w8w\nBbLDHuDB9jwBjkoNy7XM9uJDTax3cNUGeYJaNqR+k+h1Q0/fI/8n9FfY5DIua6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBToYkz8SwXx+8cENFee1jAX40EGfTAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22OF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQDhffbbIQyVjb1wDtfvBKmfu8lLqq1ZRGmWEPmX0I2n\nxgIhAKozs4Es8rg76Zcq1AhcrzOOusUDOIG/rZsSXzsy/z7B\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8960", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8960` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbvBmiIfsTS7jOUmHjeJI+WnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NjgzMDU4LWM3MzAtNDMwYS1iNzIxLWVjZmYxNmMyZDRlOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2NlNWRlMjEtYzM1\nOC00ODFiLTk4Y2ItOTI0YmRkM2RhYzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzmEGuVLm5yrpcq6FETZpbYxYb7UC6XOvEwdaeTe7LWZgzbpwrGKPf9CMZ1NI\nc+NlugNSIJSUQ2XHARxLgzFSAqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRigWwq4cu+VxUKqGO1zioBb/Bs8zAfBgNVHSME\nGDAWgBQzTonONYFIooGS4Uf4+ClWHfd9LzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIE06EKCnkL7pfRcmUzzaO8bazP8zD5d9\nd5kkiG3aniF7AiEA3mxQx6KlR805IxMw75ZxVUDeNe9qe3D74WOyJICjW5g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASrgryNpgFFHEU5gyiydH4xvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDY4MzA1OC1jNzMwLTQzMGEtYjcyMS1lY2ZmMTZjMmQ0ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaD9GDZidSL5PcxeOTFhHCpWvIWP4sSYiEX59q/KyCcErw\nPOxiEZ+iTIYTDiEnkL+vmmVJQRbN5nE93Tlr6C8No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM06JzjWBSKKBkuFH+PgpVh33\nfS8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN1S/BDi9XuUOLEflUYToWfmr7FJC1qJeZ2HRu5Br7vyAiEAtY8ch779\nRSQ3skDlDQ6VsPd2bDJBaimWJu1wyP86RFE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICMDCCAdWgAwIBAgISAVLLxB8p4SyLUY254qoacPzlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2NlNWRlMjEtYzM1OC00ODFiLTk4Y2ItOTI0YmRkM2RhYzZjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzNmMzgyNGQtYzU5NC00MGQ2LTk5MGItMjViZTU2NjFm\nNmQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3a0kej/29/6bkehvL0/iT1nJ\nn+YgT1ToZpWE6OADDLvFgAW4AINSTbph2gDrTU9JPfuZZ+eaJ1inEk1Jkm1XRqOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRigWwq4cu+VxUKqGO1zioBb/Bs8zAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22OF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0kAMEYCIQCU3c9DKfjy86OM9hIBaQVs+yXBkQIGRAaBSmXTZ7oP\nvQIhAPs95j5+OmW78afkiOoIbBAdQKgbtppxLHgzo/Yl/hxl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8961", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8961` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWKDn2GK+CW+zDsLwE8xf3hZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxN2U1ZGY0LTIyNmUtNDk0YS1hNzRhLWU0YjQyMTliMzI0NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTMzNTA1YmYtZWFh\nOS00N2Y0LThiZjgtOWYxNjM1MTIwNTUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEXQkV5asso1+keLqi7VAEKwheX+4XMp5TYkJpJw1+KqPyCKIbgyS/3E2jI23\npT9GQKG+E+/+svj7Yr1PVzS7/KN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFC+7iTZLNIYssDYSBs7q76UFgzPOMB8GA1UdIwQY\nMBaAFH3FlDk2KhYrtUuJGmHj5SMyWDc8MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNIADBFAiAmIxKSNjIGU0IG/sSiepA4nr3AGMncuJ6b\nMke1TGsq0gIhAJ4epvkP6jK5jDnvd3Khr+eJbqrdh30SYhH9UAxgmtd2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXMfDTwYUup/aH9al16ZxPhaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMTdlNWRmNC0yMjZlLTQ5NGEtYTc0YS1lNGI0MjE5YjMyNDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmj9/orCCaP4cUFTbyLommoq2we8NQjHWozbXSFBzfe1up\niYF/zEai2sq0mPTs8LAU0OHoWwzvYfvTXD9ot619o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfcWUOTYqFiu1S4kaYePlIzJY\nNzwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRClpsf33eN3UPJSGoLN4L6tL695HLbHaHQa0RwHlO0cCIQD4VjYZp4Kx\nUIicHvA3exSry+R/FRKdczfRMxjt9s0+Aw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAZW1Z5ErRzyKhJXLt36HUjTKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTMzNTA1YmYtZWFhOS00N2Y0LThiZjgtOWYxNjM1MTIwNTUxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjAwMDhkZmUtMjk5YS00ODM3LWE4MjgtZmNmZWI0YWZj\nMmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/G96ohkoqbFulYkECOukjSDY\nfNPzcktz/FzJ/ay80jnWZrZe0ozLLyE1jONYu+gtaWUQqY8CIDfOCElhdGdNzaNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUL7uJNks0hiywNhIGzurvpQWDM84wFQYDVR0RBA4w\nDIcEAQEBAY4EfwAAATAKBggqhkjOPQQDAgNJADBGAiEAqG5x/dZmX5A5YfZ93zqA\nCJHuHiBLvE7gB+j6/0Z+z+sCIQCEE62YtzaIIw7dxxfgZ2AKyjkE7gGs9k4A+vfF\n7WTfUA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8962", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8962` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAS9xGtcPVO8mQ1IlXL40iHS+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1YTgyNGZiLWRiZmUtNGQ1NC1hNDVlLTUyZDRjMGZiZTkzODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzNlYzVkNzUtNDcz\nYi00NzBjLWJkNTAtNWMyNjFhZDA2ZDFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuyBkyIgJ3lXaJHXgPtqEJrc3mHdEE8OsvUN0HIVYzvRekWXnYVfw3979wZg+\nAtNTWiyY9jsHBNRxu8xMbPN9WqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLxaiWwSvVo5P0oS/BfoPop0vtlFMB8GA1UdIwQY\nMBaAFE4qYBvdRBpgSDXSF/0ZcR+mWvaoMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNJADBGAiEA5XRksiVWRg1/ngVL9lfqECWKMeY0V6S1\n1L8UK7cntLACIQCOgnsis/m/tQPzIX+GPJL7mfeuzAHVoGV8v+wqbfv6pQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZwy0wui3CoeghgzzFLhPtH6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWE4MjRmYi1kYmZlLTRkNTQtYTQ1ZS01MmQ0YzBmYmU5MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSdGoNlc2D9TI3xmAjo7EW9qealE4ZWxhW6wbEo0m9S4vC\n8amqKhkC0/XEaNPP2DYlp2SO/D3Zc3Ab8GlVLqcZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTipgG91EGmBINdIX/RlxH6Za\n9qgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQC1BlhQmEP2d95i8BpBd22DIDEAvLHUpsuMbu030GscCIQDIF+uKMHMj\nh4jfnxbpKu3VpsDC/+Oe+ka4eJLgzaj+Kw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDjCCAbWgAwIBAgISAbUr4IIIydUYyBDk3oYGr5MPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzNlYzVkNzUtNDczYi00NzBjLWJkNTAtNWMyNjFhZDA2ZDFjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzlkNDcxNjQtNjQxOC00MDdmLTk0NjctMjZiNzliM2Zi\nNDRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE76DO8Up/AgOzCth/siarCAEf\nOBEL5t73nXIv+yBIC547dx8yXbPMJY7a6ZCnKadWARIDmhfLRCH/Rn6cWB+wg6Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUvFqJbBK9Wjk/ShL8F+g+inS+2UUwFQYDVR0RBA4w\nDIcEAQEBAY4EfwAAATAKBggqhkjOPQQDAgNHADBEAiBmveFSRW3Xgqp41fMOOmU2\n+Z5lVoLQfvfQ32AienGJlQIgRWpeM5L8gFOHkqVKabS1OSewYSduS8HxQ6wOphZs\n9Fg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8963", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8963` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAWxwhuBC39VpJMJlTZgLVoaQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1MmVhMmY3LWZkMzktNDA5MS05YWJhLWFmMGMwOWEyODJmMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTk5MWRmZTMtNWQ1\nMS00NmRlLTkyOTctNDliNGE4MjM3YTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZhuA1Fzhv65X34J128tW+OSGQMwMmWAzZpWsG2dBpVrFqeznjhvLxxu5suOH\nhrN8nf2ris7OfgiJc1Nrxn9wEKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFDZ6q4tC3hR4Hf7C8xE1xv/XVivXMB8GA1UdIwQY\nMBaAFLy1PvYTYPnfKETXVApc1J0RTl/0MBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiBjWbq3fZS9s2d2WdjBsuh7KEHHMXPfyx1W\n1IHf5jZdVwIgHaswq5nWyFa6WvwfnReBpU7t72PnR/iG0EBNY+eT9To=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAREWah2oUXnMkBaJAkj88oboMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNTJlYTJmNy1mZDM5LTQwOTEtOWFiYS1hZjBjMDlhMjgyZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdmetq1DH1ZR3LVobcZ52bqn26MCfxznHHen71n5fF/EGz\n8flhD4tK3yS5MG3ELzuoXXQBiKlxz9b6EQlxObxdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvLU+9hNg+d8oRNdUClzUnRFO\nX/QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP3AR8Pem1SoWaIveCFPW/V4fN4f6qdTvSptKbXWbr0BAiAU0sdnZMgn\n/I6rAZnCDffAdWIPl+qTFIxOm/TsLmNViA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAeW5yWPWMpQpwS8Btvva3+fsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTk5MWRmZTMtNWQ1MS00NmRlLTkyOTctNDliNGE4MjM3YTRjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTRmMTRkODEtMjc5ZS00YTRkLTkxNjUtMmJlYzNjYjkw\nODgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbsoP/qFQLYd3Uzx55XTlRd1x\nVIYW8wnzl062SklP66SJuMmIi2STbXvpyksOKXcrj9poQtQNwc7XioaBlGCZ0aNy\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUNnqri0LeFHgd/sLzETXG/9dWK9cwGgYDVR0RBBMw\nEYcEAQEBAY4JMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCICwSRAFMgBBXvxN7\nXJBGJXZQFT0UhTgk/Ak2Maa7K8fJAiBIg2U24zgF+uQWmFU8yznLsyw0qE6pIXFD\nNXDsgInQbQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8964", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8964` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQSt8Dq2w3MrXy+XDnBMLGVGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NjZkMzRiLWI1NDAtNDk4NS1iODk5LTNkNjRjZGFhNjY4MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmIxZWYyMDItYWFi\nMC00OTlkLWEwOTYtY2E2NDhiNGNiYmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESccs48aQtgnYZG+miUn3CQJDCESoxgMLFxrKgQU9K3GpkwRlyIDji6nqpKYi\nTFYXk2XTL1B08QGZj2O9cuwnLaN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFLQkFUyJR7noRBxKU2SUnbUYACF3MB8GA1UdIwQY\nMBaAFNSKFApWkA4WykFsXFRHD2QxtkHwMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiBagjie0DkmWundDxgtUm9HmYp4hh0KLRHx\n7lSRYiJ4oQIhANgxnOc6E2g55BV8MqvjXW+6tJJuBrhbEkgu7wRdBw2R\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdSReCPb1RihlL35h2g5fBaAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTY2ZDM0Yi1iNTQwLTQ5ODUtYjg5OS0zZDY0Y2RhYTY2ODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT13pNWjE7Prg0i6dcNKGHmgWlNOT2Ye5z1VKroAoHYoM03\nJKRWEsPjKl6Q7V+V+yfA7eFGhgiUABiaZNNljuWLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1IoUClaQDhbKQWxcVEcPZDG2\nQfAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgM8w43o7QdRFy5jtto36aplQZQ8aHIUtq0GJoWuP08qYCIQD3H9AIDNt2\nHpepN45/iNspxsiAYLO+Y0jvEOtlyMJQUQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAfz0pLLIEsmL8FdfDwAfcxC5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmIxZWYyMDItYWFiMC00OTlkLWEwOTYtY2E2NDhiNGNiYmQwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmFjNmU1YmUtZGRhZS00ZWMyLTkwZDktZjU2OThiNTRl\nMjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEage4Y8TbLHI/5c0S4zpW1wmy\nw48Hd01+fpEe3qjsyjeEiWAP0Nkr6IuhCi+0549vH6pK9s5rnask//Ntartdn6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUtCQVTIlHuehEHEpTZJSdtRgAIXcwGgYDVR0RBBMw\nEYcEAQEBAY4JMTI3LjAuMC4xMAoGCCqGSM49BAMCA0kAMEYCIQCdJeiW+K+tMnCR\nN+Oa3S+t513if7LNLPe3QfyDyB1qPAIhAP+CfhgMMVzQG5jKDWr5h05CBpB8EGCC\njvbxn0syr/tn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8965", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8965` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAZWIjXfhl5gBJ5rPWkxf8GtuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5NjlkYzBhLTRmMDAtNGZjZi1hZTY3LTU3YTQzMjExMjYzOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2ZmMzY0MDktYjBl\nNi00NTgyLWI0MDctZGRkZGNiZDA2ZDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEU8fPrnhdNXxrP6+vFyh22Uxd7DA2tVTdx27xp2vj9lkTMXBGkVzyhnwy7T2l\nMdfQsJ7OZ0Kj8MHqJ3ntGf52XKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUesNaNRPQZRN9GDJv4Web+cQ38K0wHwYDVR0j\nBBgwFoAUR3kvlWW3YKEs4Y+TqjgLbmZUcRswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHv0DRUzvUG0Ou4ZOL3xR0fnmRiB\nJXjrMNoiri9XXXZvAiEAjQDvUCR0dhYIk2gmX2Fd/w33v6pzdRW5KJYKTfVxrGY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQj97jR4vJpzv7z3E+13hpO4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTY5ZGMwYS00ZjAwLTRmY2YtYWU2Ny01N2E0MzIxMTI2MzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARx4aMWzZnOIAeA6IP2AHmVvEmDZr+0kxEuSctv1TCXx9sM\n1FK772Pf8Op6pU9Miu6ac3AFe5ST1f8M+VxTUaJNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR3kvlWW3YKEs4Y+TqjgLbmZU\ncRswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJt+yYSpsTDRkalIgaXKgNm/tOV5gjUajYY4XwfuiBgZAiBB1u7wBYra\n9akMpCLDjSWoPoHijIeYMnOhYoVRHleCtA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAdRgyGUfI4oEBWr3vYi9S88TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2ZmMzY0MDktYjBlNi00NTgyLWI0MDctZGRkZGNiZDA2ZDcwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjdiMmUyNWYtY2ExMS00YjVhLTk2OGMtYjYwOGM0OTQ3\nNTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvXh7xlGjEiA7H/WXRvFurj26\nchSXvfSLp2LZTuN7DWAVzrqdQ0ilxrW0dABFlmj/Fzfug3AKM7BpFwp4f6DojaOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR6w1o1E9BlE30YMm/hZ5v5xDfwrTAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22PDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIG/eJL9tdb67XPvkKq1tdONxLYdqU7JsdiTVJWod1zdaAiEApHLhHp/g\njEbW0IKU4bf24O/5wUcre2lOrm5pWm6DE6E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8966", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8966` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcQhFoINK7LC+EIutA1+vUORMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMzgwN2E2LWE5MzQtNGEyZC1iMDUyLWEyOTgzODYxMGQ2MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ5MTQxMzItMmJh\nZi00OWVlLThkNjYtMDljYzUyY2RlNzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw4rVQyOQPMFR+gh6wCVYd2Jv5PCAzHvQRxzgkFKWgZGO4zS32fWGbDYVUuLs\nuGLxL5OpxE4bH8CuwRIzp5sNF6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT9JZY/x23SbsQGp4/L1BDohdll8DAfBgNVHSME\nGDAWgBSWIZDdKCu75mYgL4/+A1snuQa+qDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIF+KZUvKQXnEMF6GeRmEh0nuzN2lDuUY\nU6ooKpDoHXE0AiEA2IJOaliy+aQOJAXNoTYQNK27/AlUntv/NW4lIJGlUiA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZafIEPaf0B8IeZ56g/maLZQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjM4MDdhNi1hOTM0LTRhMmQtYjA1Mi1hMjk4Mzg2MTBkNjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQX5N/MQYYkB2shvLDb23pYEFwmzIm7Jvg82ogr0VLPbaSV\nO2Tn4GnjOhnpS9UyWECV81C9fGLU0f4h0KMw6ydho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUliGQ3Sgru+ZmIC+P/gNbJ7kG\nvqgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVX7Aohw4UTE+2QnDnnp6XPGbT4DTgdToqTzPXJfwmzsCIQC5cIFZ7Yks\nWvKzlnlXC3PRLmVrGIntSERHBG8WMFxcNA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAQpOB8DEou1Y2ANCPjrQWvQxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ5MTQxMzItMmJhZi00OWVlLThkNjYtMDljYzUyY2RlNzkwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzM5ODMzMjktMTczNy00N2FjLTllN2UtZThkOWU2ODMx\nOGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhhTfT84/JlBntKI9Z2wmROlc\nlolpGGsV8JF3JJrXhKu2ogS8umxW/uUIg6qhYk7377IE8o/4DGCHe8NHB7ch5KOB\ngzCBgDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT9JZY/x23SbsQGp4/L1BDohdll8DAqBgNVHREE\nIzAhgg9iYWQuZXhhbXBsZS5jb22PDnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCL7Gm4QNGFgEUVPVLn/5wbXlc+uVjM9oOxGZ9/VNwNOwIhAMjsX14u\nXdxWY30i9KZdH6L2+LGJ+NSULGJIsWzXgbmZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8967", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8967` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQvCdP3qAHCQ4ZDLsEbAj4GcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMzUwZjhmLTg3ZDYtNGE3My04YTllLTY4YzRhODNlMGIwODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFjMWU4N2UtNDE1\nYS00YTE3LWIwN2EtNjA2OTY0ZmU2NTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7fEv+oj1y5ehim7cUUXqkYwLZqQEWAA2/4vdoo61LDz8iqZ+z95X4HKxQ/Tf\nyRr1vOoWJD9Byc1WIAAin5zoPqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVoxlRxW4MbXja2kNdJok10g5BbcwHwYDVR0j\nBBgwFoAUg+sQVV9xEg5/y1BPOpAEpilBn4EwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEY3M/MiBSRQAZClsDSb3kGgNppZ\nOZiPwJeEb0dvdVuYAiEA1O9TZ1GN3ePcUe8P1kFCtHs6NseyoSUtNZxEmw0+qvI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVcOK+TNvph4veZMAEBcLT8MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzM1MGY4Zi04N2Q2LTRhNzMtOGE5ZS02OGM0YTgzZTBiMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARO5nK0LKpTHBYIlRRG26JrkeyfOAUWcCF1W0aEyO6GZHBm\nFmo6Qe3Ma9X2SRoKzcBohzBHRmWWlKMLrbHZKeg0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg+sQVV9xEg5/y1BPOpAEpilB\nn4EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeeDzXDJSrridFfOqgUn1vDL0bu9XQP2t3Gghp4NF5vsCIQCdBAK1fPsv\nVC6CrubI02NuUKwHCWsnI1OTtdE3Ldk39Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAbitm9wDCyYooqdrEt+X0knxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFjMWU4N2UtNDE1YS00YTE3LWIwN2EtNjA2OTY0ZmU2NTE0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTAzMTYwMzItNDRhNi00ZTkwLTliYmYtMDc4ZjkxY2Mx\nNGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtYEmPYmD64hwUBIeEg/h6w+H\nU6MzmegS/mQ1UrfaTYyUKPTZAhixZ1fRzTTZnP/m2+iC1Q5P+luq0mIPTowcQKOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRWjGVHFbgxteNraQ10miTXSDkFtzAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22PFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA8ktzcgkFUURtqvcE32g1PFW11aPy2p/dHYvwyv74haUC\nIHm9zFWg6dDpBv16dwHqHdQkF4wHJ8HrEV8paZHavpBX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8968", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8968` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYtHu3FOeRHtQsgUeKan3JemMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiOTBjN2VmLWQ0ZjAtNDI5ZC1iMzZlLTJlNzRjZGRjYzIzNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODMyMzExMmMtNDcy\nYy00NjY3LTkxZDUtNDJiMTJhNjk5YzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPg65fBGjYn/f4IjYRU+fSz57BCoVFev0vGRyeMNMXX5FiRN108UFrXpyJkIc\nI7rtp+bJ0CTPF0AAJAFb9bnr6qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQlxRnEPG5lMupA4I3LUXtQFWdjXjAfBgNVHSME\nGDAWgBQHLHcfjhUWoONpO4EwSaFt+UNiujAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFtaPeSG3LVuPKO4cJam/mgNAiwJZ/Is\n94i6+i3Wc5qdAiB7bgdoOaoZlBoJaf1z6XYxfjDFRSMsQD+9nqWUAG7/Zg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXm0JxSdq+q+SdJBrDaf9nMcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjkwYzdlZi1kNGYwLTQyOWQtYjM2ZS0yZTc0Y2RkY2MyMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCRxZ+4CGUTiBJHU2Q2HkGebEyqWRKi6erNWp2WvlkpBej\nNVfWFQOOW4b/zdEDN67zVZ/Tf6VLDfjFAutUKiFfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUByx3H44VFqDjaTuBMEmhbflD\nYrowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRUkDCX+cqqZo+1LtjklkSHGnlb+8O2RkR2R3UNVz/yYCIQClyLwNL4C2\n6LxbReVObpxX3501dJo45Yn+ZsQFsLZqyQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLTCCAdOgAwIBAgISAZbmOeUzgoJO9E6rK+Bez4rCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODMyMzExMmMtNDcyYy00NjY3LTkxZDUtNDJiMTJhNjk5YzM2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGMyM2RiYTQtY2UzYi00YTZmLWI0NTMtNWQ4OTU5MmUy\nNDdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8Oj5BEyBbiMrN1OMNlZxWX6A\nnIQ2AQoGKJTuP5VTP1amErW3zIijpbNZi5ImJSCH/aNhCVZ4LVVbt42aWQgLfqOB\nijCBhzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQlxRnEPG5lMupA4I3LUXtQFWdjXjAxBgNVHREE\nKjAogg9iYWQuZXhhbXBsZS5jb22PFWh0dHA6Ly90ZXN0LmxvY2FsaG9zdDAKBggq\nhkjOPQQDAgNIADBFAiEA8GqT8nOopn2lJTEKQm4qIu9imx/G50n/oeWJFrG8rLsC\nIEl3+YS3duOrOki0cOkrKWIm4/hhE71AExVwWx4OQDys\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8969", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8969` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAbxTK0z8n3IX5QaLo+RyP+OFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkMDdlMDViLWM0YmUtNGU3MS05N2JiLTg0YjRjYzE0MjU5MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA2MThlMjYtYTUx\nYy00MDNjLWEwMDAtNzg3ZjRhYjE5MjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4t3ZD7hoFTW6CtuN1pORE0CDR6WkoMtSbjI4N8Yug15vc79QAiQEswL8Ucee\nPOXE8e23qq42OQAcLMM3WWoL7aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2ZO0cPmEDbsoRLt15qsGGqBy4kswHwYDVR0j\nBBgwFoAUWW5gyaofgH1B+1gbODAsDIPiHo0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDX3/wyYP6F8PjRWqpvXbhxo1I0\nU3KVteX81uw91vNgfwIhAJP2g2PzgdskoMC8weKkEE8Lr7nrHR4kP6teCRO6ztwN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASyGMsRb5W/VCLqrVvMymaTyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZDA3ZTA1Yi1jNGJlLTRlNzEtOTdiYi04NGI0Y2MxNDI1OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaoF5F2T7V/0p/mCtus9AWI4vbLfGx6DP9pHCcuH75TCZZ\nSoYUkmbIBKOyiB5n+Tds9y4nCm71ILFKWP1W+bxgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWW5gyaofgH1B+1gbODAsDIPi\nHo0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBVgNwQJpS7EhKvcplVqvHhGxiJdthVLeUhQbGYlCYJICIQC9FTf9umW4\nxDszyXJUNHV872dlcWvdsVb3JoBhZ7xanA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAS3EFOF7NYs4cU0g9xrw952lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA2MThlMjYtYTUxYy00MDNjLWEwMDAtNzg3ZjRhYjE5MjRjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2MzMTIxMDMtYWVkMS00Mjc1LTkzNDUtMDEyMTVjODRm\nNDY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOvI5EuVmyCyZt8IDTeonzwmD\nNEZU7daZ+xX98GZ4tY2mG0HHZKe/RgrMcLoChoE2OtiHge8RaU/kq1RxUcBXZaOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTZk7Rw+YQNuyhEu3XmqwYaoHLiSzAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22PFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSAAwRQIhAIrkA20zGhEFMF5DErAVznnqgged5D+3Vepru5lt60Lx\nAiBaoNS4Xygs5rdXiWnlCphg8+czG6ia+CMuebaSG3fY8g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8970", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8970` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAY35Os/yhi9v9thOOPk0OPxhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhZjJjNzI4LThkMjgtNDQ2Yi04NmM4LTUwZjY0Nzk1YmIwYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjUzMDE5OTctMDVj\nOS00MzUxLTg0ZDYtODgzM2Q0MjMwMDUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVhtV8pkQ9VM5tmsrIO/v/8rgfNjbXOFH8onAaVsi55Ydg2VXdfb/9hJ6BAtj\nOsHTdrUXRzpWujS6wx/rGUBo3qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTq1+hpS0bc/yZwhl2x//DlxZTqDjAfBgNVHSME\nGDAWgBQOUpdzCLwAzNx4A3x7oend8QkjfTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIC5WVk0ip+oe3gp3U90nTWUaiFr/ynP7\nrtujYxZvtzU/AiEAp23LaJFoHU3dlWoZ5TmSCQgYRmnqg7qoIdomFQ+kn00=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATLO4sm9yHPgT1ewd8jFnMXMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYWYyYzcyOC04ZDI4LTQ0NmItODZjOC01MGY2NDc5NWJiMGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnOEcdgV2VCNPIUOqJroBuY9/Br7WevhYE6EH4mr+6LaBP\naO6iliChd6/Ou1h0LoHpX/gE0ti60PVCb99wAS/Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDlKXcwi8AMzceAN8e6Hp3fEJ\nI30wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIZL9IZ7yI9x/R/mvpFvJkAWPy719mixaNviQCEfbEwdAiEAjrzbwE8B\nlCARfEvaZR0iVSX1I7jh6eH8p0pDnARE1Bs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAehRpvoZmX7GyO79a165UPepMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjUzMDE5OTctMDVjOS00MzUxLTg0ZDYtODgzM2Q0MjMwMDUzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGM2Nzk0OGItMTlmZS00NmIwLWExMGQtNGY1NGYxZjcy\nNWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw3mD3bxFN+3yPJVuZuZKdQNE\nNKPgz8dwRgODpi1gpyGox9n17nrDGy8GrY0n/ATY3OV8py5Q8QYekWeJluoqpaOB\nizCBiDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTq1+hpS0bc/yZwhl2x//DlxZTqDjAyBgNVHREE\nKzApgg9iYWQuZXhhbXBsZS5jb22PFmh0dHBzOi8vdGVzdC5sb2NhbGhvc3QwCgYI\nKoZIzj0EAwIDSQAwRgIhAN9HNtSgNIBni9KyK4byUSKl1ecuIhmxknLvtpDjDhNO\nAiEA4TOwKELIk98px/xVcijZw0VB97jTJEQhsgX0Vsz/wnU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8971", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8971` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAS21dUpXXoxDVqu4AubPqoCfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY2NmVkM2E1LTBkMTEtNDJiNy1iOTRjLTUxYzExNGJkYTExMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQ5YjU0ZjItYzA4\nZC00ZWY4LTlmZjMtNTVjMWEwYzNiMzkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtsKYU+L3qFXxtjHMGsVwZ47VSpbbMoE2nJDyT4Di+v42SkHa8KRSFgVbdbSe\nM00F5egil7gLlarA+IMLSUT1OKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvVUakKGJjhfl/fZdaqapp1+zAWIwHwYDVR0j\nBBgwFoAUQHbjZ/8sngFTJSSYrp6vW6YeVxAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEDyCgtb1OOo1UKitSKvCdvhZXOV\nXQxyz1leTw1fSrv3AiAX/zNI6rf5w05U6QbAW9/RrI7gueRiBoRfGrE2YF5yEw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUZOOGOWagCsOH/jhd/+1+VQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNjZlZDNhNS0wZDExLTQyYjctYjk0Yy01MWMxMTRiZGExMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQGk2xyVOhqerBgb6Gk8OhGrguEigGrm1kiUPMJ+YsiSfx7\nVtQH/6WIXJsfUS7MsEBTGQE+6B8HBUMdDLjlGiZWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQHbjZ/8sngFTJSSYrp6vW6Ye\nVxAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgU36S+WLae0gBr63U8w1jjt62Xe75RqYTYbu0qqiOME4CIQDV62oxwEr4\nib8Y/dYUKpCXh3A+rgjLRMcALWYcv/6hbw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAW5KmLLFztm5XRNvvK+XLdeaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQ5YjU0ZjItYzA4ZC00ZWY4LTlmZjMtNTVjMWEwYzNiMzkxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmI4OGUyYjYtY2RkMC00YzRjLWJiYmYtMjAwYmUxMzcz\nZTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEabY7Oxa21phRDAJf84wdVDT8\nXti1UzhhtO8gNsBj15U38ks6kmhe26KS0tmmsZjpAKcsd47W3FuPan7HpuNx1aOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS9VRqQoYmOF+X99l1qpqmnX7MBYjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22PF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQD6/1AGQcVd3yoRXVAlzCSSP2JzNvu3SN6L8lrKoS+Q\nTgIgHn9KvW/08SQmKjiXHNv/AmTHxW9bAErYEE4Tzf8C1Ng=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8972", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8972` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAR1FDgpHINPSuxqK+ji8cWBiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2NmU5OTdkLTBlZDktNGJiNS04NzQzLTYxZWIyOTY5ZjgzMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTEwNzY4YWItZDM3\nMS00YjEwLWIyOGYtOWVkZGNlMjlkN2FkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOpPuCz7WO0n5dm6PsNrNxDuMseUWI5/NT39I6Xk3gkwivllifEtUJRymvxSx\nvA4XomK1jDF5uBmxe4eliBOtSqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTq+LIUeuyk7d9+nFcfkmx+p3S1FjAfBgNVHSME\nGDAWgBS3trLYLwBgsFqGQYPUjDGZkdAxHjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDbgG3s1kwqJS1dtpL3FF30xoV5Ts6n\n+KWskqkODnzjqgIhAJ5xKxwRAbggqjeBf2tNe4ZKUgBFIHnyhj9rK4TiKSG1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXEAwkrY1KnJCjOQ7VcEyVTiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjZlOTk3ZC0wZWQ5LTRiYjUtODc0My02MWViMjk2OWY4MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxvnEuwIz9HnzP6e41rDSBsR210anjmVzHZfrzt/ncdLvu\nA6C+n291MVAbPrBNEk4n2ZJTor0EfoAByNaFBGoAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt7ay2C8AYLBahkGD1IwxmZHQ\nMR4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPLhryy7DupQf8D+f9UMDiuU7vQyvasIydu0PJTaXSsOAiAXk4tBGSeF\nvNW+I80TwFW7GDNvcZE/Gl2Zx4mo/k9zWQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAfMg8jnsq2HFB0yim9sh2eQIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTEwNzY4YWItZDM3MS00YjEwLWIyOGYtOWVkZGNlMjlkN2FkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTJkMzUwZTQtN2Q1OC00ZjEwLWI3NjMtOTZjYzZiNTg4\nZTE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6HePF8qu6a/9NJnVCWYrvQd8\nF1vEajpC+yvDo+d4kOdtDjzWWQcmYjyOfLV8hf6td/ktlcEyqmvT+jdeAi1rEaOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTq+LIUeuyk7d9+nFcfkmx+p3S1FjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22PF3NwaWZmZTovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIAQnX3QooAKEqzqwFOk18xFAx2WkrLrdOvTXERituiZi\nAiEApz21ik+BYdcsx45hRz1L7X02oguUZgPtvscUhI8Wjjs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8973", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8973` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAUeQHCDJiZB4lhPD8CbXNFpcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiMzc0NTIwLWFjY2UtNGE4NC05MmIxLWI5NzIyNGNkNzQxOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzI5NjFlNWUtYmEw\nZi00YTJkLWFkMjktYzlhYTdmOWU0MzIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiHQpxjBUyivo874brz0yY/xYeNejS4ur6mDOmoUk4FkE+bfI3FENYRcA2T56\nL0FLu0QnbWy1sydOjAKV+e9LiaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN+hCd4Fly4EVAf1dftTEWOnxhOEwHwYDVR0j\nBBgwFoAUXRhStjhDlM0KHPSp8wvdPrphxp4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG9Ux5lS+MI2/n/uBB3kTz6DBgNd\nSjLzJ8cMu1ffiUmiAiEAxjEVBjQPCeyMxz/usGluZZxlRZga0TT2SsLWC9nNNB8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASNzZmFeZejrJwKvvukH7t3TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjM3NDUyMC1hY2NlLTRhODQtOTJiMS1iOTcyMjRjZDc0MTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8ggsRItWeGv4V+FcZWHZ4L3IdHmsiWPO+xzfpvAFazO+J\n25imX82MJOQrloUlvSn2N3zfSGtf9zRqfN0sbikmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXRhStjhDlM0KHPSp8wvdPrph\nxp4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPVTHnZwRYmrNisWFY/gS7ERZWpdGBbOEEUG5Yi98PCdAiAtCzeiUQxZ\nWJaLHa3WKwYPJXwaIBhlRtSVTRUsg9bLPA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAVW2ffXm0eoy+3xKYwUr3+Y1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzI5NjFlNWUtYmEwZi00YTJkLWFkMjktYzlhYTdmOWU0MzIwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODUxNDE4YWEtYTA1Zi00MjA1LWE0NGYtMzk2NTUxOWJk\nMGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3fxPN6dXPVVJS9atLOIZpcb2\nX9JKmeaerwOcPaTj4mQC6UAL4mmQa+wZ7bjjrCOjCW33mUbaqhj+pGG+ks9zP6OB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ36EJ3gWXLgRUB/V1+1MRY6fGE4TAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22PF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQDmd7DxwTgafeM/mSa7VUB6+xuEpKwIBMeC9y5i+Dbf\nfQIgFJJZzr12MojtYaKHc0fN/q+pU1kadD5flQUA7I+E/VU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8974", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8974` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAS/YXhDmczBj+5trsHcl1a4yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMGE4M2NjLTU5ZTEtNGZkOC04YjAxLTMzZWY0MjY0OThjODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjMxMDZjN2ItZGQ1\nYS00ZjBiLWI4YTYtYmU4MGY2MzUxOTVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhrRrr+NVS+Pl037fZyg34hcSjFBZc2+vD2JCYwkRIe36XQUzrjccxxmLocOr\njb3fcgJKZ3iWGeumvgkwc7zq/qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT496ZdOQiYceCJ5socSueWIexeQjAfBgNVHSME\nGDAWgBRZdrQ71U+pvsilr1sNfFPNaJwtgTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIB+vTFJ3stVP/TgufHGjOtoisVL3GiOd\nFzSj/cscYF6oAiEAq5b2KRtEydmpnCbGdMoquDyFUHHxmFHgmZreVqHDF2Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATHzjOVX0PAOi7+D6mxXxyh4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTBhODNjYy01OWUxLTRmZDgtOGIwMS0zM2VmNDI2NDk4YzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQsEk5TB5Z5SQUHYJhAMU5Scd4dkfoq5YarYgZ8d4iqsx4B\nxlXAdVm2e+qqeWSYe7NLmQ08CMxvgZ+Xy7HJ01fSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWXa0O9VPqb7Ipa9bDXxTzWic\nLYEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJdXGfeBbV38RQSKanKApeHl5cpsLOhCQ8LyEbmGbCUUCIQD3aP399E3d\ntW35V0b39iY4HFOkMSnXxW+wyZJNIjOgcw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICLzCCAdWgAwIBAgISAfx+imaQp+E6/fefqX/XlseZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjMxMDZjN2ItZGQ1YS00ZjBiLWI4YTYtYmU4MGY2MzUxOTVhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWE2YmEwNjAtYjZhNi00ZmU0LWIwMzktYTJiNTMyNDE2\nMTYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFaCoPR+IQs2a5RWJ4X17unye\nbMHXvXD15J2y0Wlyqe1L0SugD3LC2duVhgoyh8oh8scO/t+eg5AamjU+C9LbIKOB\njDCBiTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT496ZdOQiYceCJ5socSueWIexeQjAzBgNVHREE\nLDAqgg9iYWQuZXhhbXBsZS5jb22PF3Vuc3BlYzovL3Rlc3QubG9jYWxob3N0MAoG\nCCqGSM49BAMCA0gAMEUCIQDVcF2h4DNUJ+lDttsv7o75Eivk07+CXG2wnGebMVyD\nXwIgV4nxFkfHK0a9mD1jOGGRLWGuqcTRCvfBHftTzaheVwM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8975", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8975` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAT8PG4F/tFWgBuqSoP5NOO0OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2ZDM0ZTA2LTZhNTUtNDY2My1hZjU4LTU1YjU5YjhmZjBlNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYwZDRlNzctMGI2\nOC00Y2U3LTkzZGEtYjkzYzlmMTFjNDA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbqGIBNui8sbmeFnONhp6ZeNXtfEjIvU4ad722A+MDgGN4E8B2eBzFWZA82zf\n/i9QDpKQUrn9oMHU4TkJzLulNKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFJifXytJWa4XOeEtJN581wBA/l3iMB8GA1UdIwQY\nMBaAFJhO5iUgHo7ZUyv/ZreLZcMaEBHyMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiAZ1YNj/0FD9w5kV9lIP8wx7vcalIrx+ICI\nQ7asOYZlLgIgPXCuH6T/zddUFDklIaTjucPbfiYZ67VSN42ZdfWjo0M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfwRaE2ioHn67IoCM3I/nNcNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmQzNGUwNi02YTU1LTQ2NjMtYWY1OC01NWI1OWI4ZmYwZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRPLtxdTKJwrmRMZssA037Z7Sm2JJTQeLe94fjFiuzZbgk\nbZfk8AUyMFtek0Yd3qQrEWm1e0jnWoa+emLoN5oRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmE7mJSAejtlTK/9mt4tlwxoQ\nEfIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJd+YNfisGjHQucWrG1S+Basis1tC0HJStcPDufJGNRKAiEA3TbV6cex\nGUKNC8s38H29asRdOo5uPSbVoOWxNuWhZ3c=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAdgyPTmTyumzhKmx2X8ugFRKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYwZDRlNzctMGI2OC00Y2U3LTkzZGEtYjkzYzlmMTFjNDA1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWFkMTJkMjMtN2EwZS00NjllLWIxOGItMWQ4Y2RiYzVm\nODBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2qzjbS4zT1XJsyWXxjeKGN+r\n/6b8dsih1RfMxRz81t+m1ayAszEBExrtUG17nuztx65cLhk9yjCr2xjWbhTm36Nt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUmJ9fK0lZrhc54S0k3nzXAED+XeIwFQYDVR0RBA4w\nDIcEAQEBAY8EfwAAATAKBggqhkjOPQQDAgNJADBGAiEA/UXSQAiV4mkVjm2NHJN3\nzDXNXyLhQr1rNA1JeSBdV0QCIQCt+tJX9lP2OVh42WSCD7h+s0QIdFmEtYff3prM\nJvM6HA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8976", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8976` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAesChCndAbc4JJ+t2JBlxAb3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkYjIzNWIyLTZjNjktNDY2My1hNGNmLTZmMWNmYWQwNDBmNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmZhNTUwOWItYzgz\nMi00NDBlLWEzOTgtMTFkOTI1MDM5YWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeZ0aiIe7m7+V8NBZJxzJ5i+gGmF6S3qLehqdfEoCc9SMN2KJ5Rtv4DZSNKko\nnPJSKmsZGwpF0Fb3wWTp6zT6rKN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFOsqwT+r2i720fTMVFeuYqI0q7CuMB8GA1UdIwQY\nMBaAFO5IsAKEPky+L0dS/Hj+pUFNnBcUMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNIADBFAiA8fl+V196/49d35FWk6vuNVZYO+09+C0mI\nYRBnWlcWCwIhAMI6hcEOYI4ilXcHJVlDGKFgJJe8BOVQV7kFV1YTE8GG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcbrKrLP8hPgx/2sRa1Q0IliMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGIyMzViMi02YzY5LTQ2NjMtYTRjZi02ZjFjZmFkMDQwZjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7pHqG0DIlmzDlfUPEQpBO3tWmCCh/6EUP4QqgdjBuWT4C\ncQyrzV4w1upNQHHAvdP8YrHK/rbqR2ZbJsIEHsZzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7kiwAoQ+TL4vR1L8eP6lQU2c\nFxQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALuAHbRNjBAfwxyjoer5Qt/p0kL6gh5tQzMGIlNts7KGAiEA5JtTTpZY\nGpSfNItjxR4IXFJJHBmWCqlQkXZD6priwho=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAeMsbWOv8Pw8fZGzpeGP6LP6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmZhNTUwOWItYzgzMi00NDBlLWEzOTgtMTFkOTI1MDM5YWY5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjM5OWUyYmItZmYxZC00Y2VmLWI5NjktZWFhZWE1YTk0\nNzNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn6ADhfByWSdrKKvyMEwy4eC5\ndHvGS7mKFrixUkNJ0NU+fqFmmvgkpWKFkV9w9c3YieoLV+kabv+kkw+RmEKOcaNt\nMGswDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAU6yrBP6vaLvbR9MxUV65iojSrsK4wFQYDVR0RBA4w\nDIcEAQEBAY8EfwAAATAKBggqhkjOPQQDAgNIADBFAiAdp67FW0GbwZeRRnnryYTr\ng520zsyp2yw1DXr3ANXnqgIhALtsllmkiIdBjVzuki/D9aubaiM6vBj4oC1Z0WOf\nyKIl\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8977", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8977` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAQDCQcwns4WPEDN+UlzjYszKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1M2VkYmIzLTdkMTctNDMwNC04NjRlLWJkYjhkZmI4MDVhYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDkwZjUwMGYtODVm\nNy00OGU3LTk3OTgtODM3MzE3MjRlMzZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5AHdiJcc52fz7a1J0CmtJlOzcSRB5/Vthd1NrhGlRqt1uGAsnil7YaObnmjO\nFMkyrMDsjJ05xFcvNFstcU/0bqN/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFIhAL05cGFXgDfRuEOlhiX9y361TMB8GA1UdIwQY\nMBaAFC0fKlq0Dxv1pVI8qZ1RwkbminyFMBoGA1UdHgEB/wQQMA6gDDAKhwgBAQEA\n////ADAKBggqhkjOPQQDAgNHADBEAiA8gu+DGwPfSXBbBRdBXSfd/fUYqns5uwnd\nYlq3c3aPVAIgQ/NQwhTs8ruNjLQWirjntFykxif0MimZqbWWE7O6wWE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ2UmXAjZvD/bWFgEbxsZPo+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTNlZGJiMy03ZDE3LTQzMDQtODY0ZS1iZGI4ZGZiODA1YWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASfZS0MQmGybun8iks70karzioeHELdmjyR9cNA9WecKN0g\nyYuA+z3Vh7T1xU+pAww2v4AHv0Pz4ya5tiJ4YUGto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULR8qWrQPG/WlUjypnVHCRuaK\nfIUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMZ+EU+AjxVVB3mTq68v7YXlz/530huZRW/45ov3QgLyAiAu5woldlNf\nDSgZKCMlKDuGBRLlAM7LbR8N7EdAodb4fQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAZ2IhcVC+5FJwju6hFXbNSDvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDkwZjUwMGYtODVmNy00OGU3LTk3OTgtODM3MzE3MjRlMzZlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjIyZGQ5MzEtZjhlMS00ZWE3LTliZjctMTQzY2MxYTEz\nM2Y0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZhssNE/ay0gbFIGnvzQz/FHx\n1aF8g4tED6ILZjIDySNeU/cXQ6v5VxfC3qbPp+8fVntS2WprjeJVeOrU1PXVs6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUiEAvTlwYVeAN9G4Q6WGJf3LfrVMwGgYDVR0RBBMw\nEYcEAQEBAY8JMTI3LjAuMC4xMAoGCCqGSM49BAMCA0kAMEYCIQCuY3VVdods5mvU\nJ/l6bHfRoJAEHoZriFOKDO4UJW/ZmAIhAIEag0onoTMTwfuRwXW9+0Mh21cA6ra9\nvP3JH2nLqZrI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8978", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8978` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAXWwyAEBcfy4/nmLbH2P6rxPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NDZlNTA4LTU2NGEtNGU2ZS1hYTQzLTNhYzIxOTk0ZTkwYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYzNjgyYWUtZjky\nOS00MmUxLTkyZWQtYmJhYjEyNDFmYzYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpGfPkpGoV7aIUYJiG40VeJc7qdHiaAq6acG+oNEsuSnPLSNnDhWTJsz8zcF1\nA4O4vSntmMPcArGX7YNtBZXYc6N/MH0wDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB\n/wQFMAMBAf8wHQYDVR0OBBYEFFa0XnPLgjxEL3DfDbLReHRHMyKUMB8GA1UdIwQY\nMBaAFBLrI3F3fU+4y6BzjLnlRrKSMTMDMBoGA1UdHgEB/wQQMA6hDDAKhwh/AAAA\n////ADAKBggqhkjOPQQDAgNHADBEAiAuote00rzZA5dHB6lqTnRrbdELMyB5zqmd\nodgH2K4bnAIgAkMh8/a4PA6ujFJDmiuXtP7Xek+D5XOqaCOZbS4YsTI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXwFRGQxRw7bp+TWNbFeo0QHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTQ2ZTUwOC01NjRhLTRlNmUtYWE0My0zYWMyMTk5NGU5MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS5/RK4fvLPEGYJOROcI0szTycNT9uiQikjs/7OjRdbmxhS\nFAPpdeRLX4dEciAqwPPpBoRJclnBEPvVAgug53Heo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEusjcXd9T7jLoHOMueVGspIx\nMwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMpwvssbnnIuOK51vECT86xfkjBshbj5p8wf43b56JMNAiEA/j29XJyb\nCtDoSkWoNi0nqaErqmZaP1ZeHbFEDjo4W+w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAUPOI3ERndMaC7D71AVD+j06MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYzNjgyYWUtZjkyOS00MmUxLTkyZWQtYmJhYjEyNDFmYzYxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzdhMDA4YmEtM2NmNi00MTE2LTljZWYtNzhhMjgyOGI0\nZDM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEor+ooOHQLWD0DVlKMaFBVK7X\nCD7reOll0iKVMouKYvGAEFCIS5is+03udyFgZPITwCmOck3Ntj2fuKKa5j3Vt6Ny\nMHAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n/wQCMAAwHwYDVR0jBBgwFoAUVrRec8uCPEQvcN8NstF4dEczIpQwGgYDVR0RBBMw\nEYcEAQEBAY8JMTI3LjAuMC4xMAoGCCqGSM49BAMCA0cAMEQCIGbxnNJY21vvLBK+\nMsL6F7Zp4068PPC9OxvvalUCmkl/AiApdvxAptw95tkeA1TGvUo3MdUTtgYXWp+K\n+gFlSOphGw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "IP", + "value": "127.0.0.1" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8979", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8979` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATEdjqe6/3s3UCFdExVgVd1WMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdmMjNlYzQyLWRiNjgtNGM5OS1iNDIyLTY0NTg5OThhOGM5MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGVkOTlmYzktY2Zl\nMC00NjlkLWIwNmYtYzg0MjA0YjBlOGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESyeepvK7Z8QrYQRg1Wbe99JQoFTxA+snRF2ZGDKQsusdPyJCiwS7R3KG4ZJo\nMeFmv2UxVc0oEwjvKxbnDmRefqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrJCnYZsiksNNWRtHg8a8bmATHJIwHwYDVR0j\nBBgwFoAUm4JdASaHSDXM5+3PfE5pZionmKAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCR1UoI3ah1lijz4BNZ7WZL+oha\nRvsHTMSh3A17ungkFAIgJKZ5FOWCNoa6oB4SA0lRyA8YRol7rbQ9+E86OUNR0tk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdtOqoQ+upJKBZ6yti2e+ae+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZjIzZWM0Mi1kYjY4LTRjOTktYjQyMi02NDU4OTk4YThjOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8byUA2NCp1xca2b3K9E4JBoQwV06y2g5CwBiRe+rHjqRX\nkqdvnf6lVPnT0uHOdeLSxlImbS3ctU2uCA3prmCio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm4JdASaHSDXM5+3PfE5pZion\nmKAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ7I3krwW+shpMANdaAIgL/1PD8kHo/DpHNoSi7wvNCwAiEAt8iP5WXO\ne+KQm94V65yTQYIq5AMG14sJj1z0A148ig8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAd2gAwIBAgISAd6SYwF7tA5lN3vf2GUMbASaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGVkOTlmYzktY2ZlMC00NjlkLWIwNmYtYzg0MjA0YjBlOGZlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2ExMWQ3OWUtYzMxNC00ODU5LTgwNTUtZjhjZWU0MDY2\nYTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9tJneQe2I4zRiOnxjtQiCTkT\nvH3KuykX6wn0XVkCwe1oIfAS6Ffn5A7R05w63hTqXnv39rLAfON8IVtZWCWZe6OB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSskKdhmyKSw01ZG0eDxrxuYBMckjA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22AH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgGPKUyt7iAWgbNj2rJEAZrAwc5B3pjXrH\nPd9z0kotYeoCIGcktfaDc1Wcc6X2KpXk+qWo9ycZ4xpdT6d91pptpm7g\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8980", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8980` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZhybFJ96CYoy+kSPazOTeZRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmZTUzZTRjLTAzOWYtNDMxNS04NWEzLTZmMjMxY2RlZTUxNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzFhZWNlNjEtODJh\nZS00YmE4LThjM2YtOThkM2QyZTM2ZWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+QtAE+UZ8SLslEhDY5B8npqkiQ+uMc/X6n/QBaWn2DexIKejXCF5NpPTIjlK\ndpXTtv1z3IRTAmp/ECtEBLFg8qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ0VoW8KwCTSa2DIYRKD4wpQ32PxzAfBgNVHSME\nGDAWgBTAxxwQjfiutvANnEmWSqx0Q6TrVTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEeb+zWgPzWAzKjvEBi0/Yen9ZW/IbyU\nkWp1Hubn54vRAiEAhWkXrrI3MCxOzwT9MMYb9q27ZA+RnyxjB4mHtyy5qAk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV8nZCOFBB+6lSUvwEhOrefXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZmU1M2U0Yy0wMzlmLTQzMTUtODVhMy02ZjIzMWNkZWU1MTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThRuznyVlI3NKqHPyPR1gspw0sIbCouhXtmatQoyHvQKlK\n/pKSyN2KILxEOM4VWmh/ooBXJbDdMBgteZhBK2/Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwMccEI34rrbwDZxJlkqsdEOk\n61UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALCpjHdESmV1xMEJsy4IQESEKuSZEwkq0ddhAtFRbK7WAiBqLzg2Gtan\nGFg4j+6ZhNnf22CRaMzcvGvAeIn+Gty3ww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAdeDsrczFEN10ofTYwnFefO3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzFhZWNlNjEtODJhZS00YmE4LThjM2YtOThkM2QyZTM2ZWNmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTI1ODU2MDItMWQzOS00MjY2LWEwZTctNTJhZmFmMWYw\nYzNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhvLyouaAmNrEeVsZEEsosJUT\nvCpDoUo8ntrkhjbH+Xx7isETT81m2k+FcLtlrybPL7zeMwwfzHA0riYWoHl9K6OB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ0VoW8KwCTSa2DIYRKD4wpQ32PxzA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22AH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMTGfdYkHmW6rq4AxJDN0aEEVf7dWtOR\nV/5hnSi2xfWUAiBlUba7N3+2KrrzDYcN9vH+JgTPATyrUaHwxeG7T8D03Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8981", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8981` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVuQDV4OkZEZ32pnaXU+wSb1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMDE2NzI4LTQ4NDgtNDNkZS04ODBhLWM1ZWQzZjczY2ZjOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmI4MjliN2MtMmUw\nMC00YzhhLWI3MTgtNjJlMjQ1YTMxZjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEi/a6sFe3bf2WX1U2vSHFHKbWq1WJ+T5THYsXAPJ3T9HyNMzORXHm58ROJ52h\ndwRTW35sgQ9vNZRpyoHgDmY6B6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtbm05RqAgxBmMbCY6R/iVOuQXhowHwYDVR0j\nBBgwFoAUigdx5CI8PCyr91oPP2jbVVvqbG0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDkFarOSmaWXINk4qIqGWfSAvnB\n8GZ1S//tbnyQdgWtsgIgWTco1+pKpGedrOhj/FWSVHn2lShYHeV9pxo/g3/IAXo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATk/XIlakjbLdvycStruOoVVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzAxNjcyOC00ODQ4LTQzZGUtODgwYS1jNWVkM2Y3M2NmYzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgUv+Q8j4jbDhQrqeltuVGV8XfNnlazknstr9OAmqX7CiD\nxZUTf0fcQV5pE910gRk2ujqle4byJZdf0mbUWqhco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUigdx5CI8PCyr91oPP2jbVVvq\nbG0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJeAWI9OHKaH/MNUAYG2/dpxVtnBE9Wdvb4bFJ0evRnrAiBq4VisrN6Y\nqgz5syK+3Rlh2tcIIuPepmj/Q7QQjFsAeQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICODCCAd2gAwIBAgISAUO/2scXVHVP3VN5cMp5j1pBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmI4MjliN2MtMmUwMC00YzhhLWI3MTgtNjJlMjQ1YTMxZjA0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjM5NmNmYjMtMzM5Ny00OTQzLWFkODctODEyMDZlNjYx\nMWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEseTHF4lpdrta7Jb2kuzxrOig\nNT+R+uZzMfKRu6EcNgxhKTJYrqSXUERuFJuZJI4Ms1qin/3h8qLhuTMbauUvNKOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS1ubTlGoCDEGYxsJjpH+JU65BeGjA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22BH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIsLbn/h7Eb1+QXMvOunwSxMFJ2CcNuo\njMdF+gWsV3D1AiEAvMHBUKbUs5oa1jMxRx6oosVNYCPJxbQ95zfPVg5I0PA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8982", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8982` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAdipVQKjQi/zOoq45Ya79dcgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1MjQxNzZjLWViNzItNDNjNC05ZmE4LTk2YWI3OWM5NjRlODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U5YWFmOWItYzUy\nNy00YjkxLWJlMjctN2NiYmE1ODUzYTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgae99loKXZ+ogZ45OSse+wwpjBdSMLos85MkAuac84G9+G+TG0yYZefVArmB\nuaRDYV4ng/vpWnSwI8U5QC7TXKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT9orvwfKGXmF3CtR1XN7OXJfpZAjAfBgNVHSME\nGDAWgBTWlWREu6BOqMPyPYSIscK8ERwlCTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICaEsFUMtUqmENmZt1QSDe5wpqNjOdC1\nEOROC3N+uktBAiAJstMuKMK8uDnupKcJiSR3md3eFQ7qgyGiiInd6ioxsg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaco9UCzmATiZgfl0uZRh3tMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTI0MTc2Yy1lYjcyLTQzYzQtOWZhOC05NmFiNzljOTY0ZTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYVGPwu8E6OxPCQWWQ6XEykaIrD7u5SjbGi/0QP1lRSEL1\ncYXlHhiMGt9E6aaqBLi7kuqkdrLzo6qUbbroItnco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1pVkRLugTqjD8j2EiLHCvBEc\nJQkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNsxsmpAj/Qm4gQKfPWcmrjZgDjYDh3lEi+WfuOPz+KQCICrVld+TlXgi\nrP3jyz46wah0IBjyPBcH833x47CvFDag\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICODCCAd2gAwIBAgISAYT6XSchSJqsa1RqTzp7ltexMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U5YWFmOWItYzUyNy00YjkxLWJlMjctN2NiYmE1ODUzYTQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTg0ZTI0Y2MtYjA4ZS00MGU4LTkyMTEtNDY2NTdmMWI5\nNTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmfytMv0B1fYnFRzBm0LOjmc5\nXEzPfz/2KZvxgCWe/ef+mA6byNewvhAOhWuk3gSDzsscNaiMRfy3xIvG7kbdkqOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT9orvwfKGXmF3CtR1XN7OXJfpZAjA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22BH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKT80pIFRUeEP965Zdt3IyhAmP2rt/jb\n+/ZGEfNNORD4AiEApadtOvu9shL7L2LVFPwKc9La4ZQHY/8nskAnL14seow=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8983", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8983` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAf070zlfO4/0+BEx2UpgF4IdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2YzkzYmU0LTViY2UtNGJjMC1iMjgwLWZhZTRkMzJiYTI0YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTRmOTEyZGEtNjU0\nMC00NWU3LThkODItODE4ZDQ0MmEwZjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfT7b/hqTunEmkW2xNtQ8zI3rpcsPlrGvZw4IQMdfqhkbhYeoFTpG8iOoQZkb\np/aUrx+lmjlWAQplec72UttEB6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgTg8o4Rbx+UYMPHiMhZqQ1ap2KwwHwYDVR0j\nBBgwFoAUfVd15Vkts1FXONv2qLVLo0zYNsUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCwWt4gikENa9RYLA/lLKmVZZ1+\nBvdPwB+qKxJEDkyNOAIgLJ9I12In9FTb5gskJdbHD2o3NFQhHwrWDY6R3pjm+HQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAat41egBQhL906lNBurgErUIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNmM5M2JlNC01YmNlLTRiYzAtYjI4MC1mYWU0ZDMyYmEyNGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARWEODnNUlsLoHPpXAPUgkkddgWn7m7u7fAj/iub77kpIhN\nG+fu28lJmNqy2E8G7hnrRAn8fmi4vn+mTd3BDOTho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfVd15Vkts1FXONv2qLVLo0zY\nNsUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZ7Rb/ZPOyGHmvuzf4GD0nIBLp+QRvFohA9P1Wb3zmH0CIC8AjdIOhooJ\nJee1f19340n4N8u2hrRKzM2ED0rJV1hX\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICODCCAd2gAwIBAgISARoOH/Y+nPxIJK/adLvDKu6OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTRmOTEyZGEtNjU0MC00NWU3LThkODItODE4ZDQ0MmEwZjM4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTk0MmNmZDUtMzczMS00NjY4LTlkMDctMmNhYzFmMjgw\nODQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtX1zQqqsPIArZeLLaAoBlqG4\ntRLh1lpTryrMrEz+MfvOIwtdk30zitpi0DLwXgkuBu/tvtlSuK38teEBVKY9PqOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSBODyjhFvH5Rgw8eIyFmpDVqnYrDA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22CH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJzqo35dKqmExgF5n/yBCnnvXq9eQoec\nfb5A7+S9ZfmqAiEAyYpSmlykIykrhksDO0BVW1Q60hn4cRK2+y+Jbrxl9Ts=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8984", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8984` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAejfUmwj5UBEq1cW8YZY2DuzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVhMDQ5ZDI5LTQ2N2EtNDMzMy1hZDQwLWMzZTgxODNkMjAyNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzExNTUyMzgtNjAw\nYS00NzRhLWJiNjktODEzZWJlNjM4YjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6Ghixkzdw1V7j8hTrCpVid5q8sPvhMVGNm2THo42VaLRJyQVDyhmOqEDqlCy\nn3oXqidE1bzkLrIYImaM7SV3BqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQDfkeEtjUPuO2dS2yGTsEG4rHvGTAfBgNVHSME\nGDAWgBS8h3ey03vqOAcqIPduQjWd2gt3QDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCAuQKjOKoGSIMnAvTKE0tCQee1m2sp\nsBuVFWti65L8MwIgSL04A73dJ7BQTuQIMwQkDHgHkw7rBruhkHkyGI18GWk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfLIeyjdxN8uqcw869VcK9kmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nYTA0OWQyOS00NjdhLTQzMzMtYWQ0MC1jM2U4MTgzZDIwMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+bdvBKjbiMe97l4wN0C7qlIDAdf7xYoI9rUTT/8aE94mk\nqsDt8c9kxjx8hz7/KFmiwLUgm3/LcE6L9+MhLbQzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvId3stN76jgHKiD3bkI1ndoL\nd0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOY0WnoSTSuaMW+EPApK9OUrvNtDg9B8bhnFCN9z7AK7AiBtSsxu4u4H\nMrMFCZ/OcO2Im54Ueg8mOpWLpn0JE5jfRg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAdm67tFnddVbWBGsWJno9teRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzExNTUyMzgtNjAwYS00NzRhLWJiNjktODEzZWJlNjM4YjQ1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmNhMzYwZmMtYjY0Zi00ODQxLTlhYTQtOTIyNzhhMTJm\nMmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHuMUcLz/+t0i0rzRuCaSkS+y\niMJK/Eik7NgyL7BQuGc58MckxpidS5YPs2GfJmulzVjIMYjvB4hGUE1nfaysfqOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQDfkeEtjUPuO2dS2yGTsEG4rHvGTA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22CH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPnK43SSSK5cLyNBcNY8hLY2V42qwciK\n2YjaEjMXx4U7AiBCT96NY+Q9EeEl+kmmHUe5prf7UdtUgDtwd7bXou9W3g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8985", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8985` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAXwr++v+jPFlxFS5zp9YfVEXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1ZGMwMDliLTg2MDctNDZiNC1iNGM5LTEzMTdkZDIzZDM4NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDQ2ZjJkOGUtMjdk\nZC00YjYxLTkwYWEtM2FhMmUzZWFkMDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/PkqX+XcTUTeQQ8MXiXoLqspmO7zB0d3Y4NS5E+N4rGwYpBWarS7X9iquv7u\ngsEoEeVDNdpdwnEnMpdkWLnQeaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYoBGf1P2nRa+OZ9IFnylQg/sLeAwHwYDVR0j\nBBgwFoAUvs6fNNvh/LF3Mogb1cA+2I/qd+MwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCh0ueMOmy7H/qFmwMK//yvAKXX\nKfoA//PQZ9PfSpjwGAIhAOK6hksm54Nj9hUZBXecWH+NQ/tACxl/RMGcuQmzn6/o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfa54y/aQkKhDGwD9WuDhuaYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWRjMDA5Yi04NjA3LTQ2YjQtYjRjOS0xMzE3ZGQyM2QzODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLJY0HYYjdwuPmX97Y9mEBRufKhNNdGgNn9Rb9VANDFrxa\naiVLbzPqFuX7GUQaUejmsRy/VFFgwe060iOEgAWYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvs6fNNvh/LF3Mogb1cA+2I/q\nd+MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOlfgR+ap88zNnSLGsQh1tAMVkSwvLpJko2PjR+K0iPUAiEAp3+SKRoc\nYeQlkD8J/LkBrhd3lgaBngdsdoBgnmKlP+k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAQfHB0/lSHOOlRjMkXfFwtt8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDQ2ZjJkOGUtMjdkZC00YjYxLTkwYWEtM2FhMmUzZWFkMDQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWYwNzZhNzEtYmE5My00OGJmLThiODQtMDgyYmJkNWZl\nMjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOc7xBphcRXzBhTYlndCikoEf\n9e3HICcG0FAme8mytDTSZCQTBVHvVrCpc2MbLj4w3XhRnUtFv08Weheo0O9Z8KOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRigEZ/U/adFr45n0gWfKVCD+wt4DA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22DH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAI3SxYUTOYjRG3Oyc4VMDOHJPm/KzLxx\nachQVCqiGuOOAiAFD4X+brxJN/igwl79Hyvenpv8AZdKMPf/4TijGxr85w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8986", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8986` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAeB0qN6wm5J5i/diH9EvDRZ6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYxYmQ5ZmIwLWU4M2ItNGM1My04Nzk4LTRmMWFhNDQ3MGNhMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2U2Y2U3MTMtMjJl\nNy00YTczLWE2OGMtNDJlNTRmNjNhOWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9NDqNd7Gw2t8UcE/javGMuXq8I0+xmxENKzwbGn3W0VPhoE9xBSiR7Kja7tE\nVBU3xJBPCbbprfXaJ15qZ8GMEaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTZUWeFXAjEl5MGVsbUQitUwIVjPzAfBgNVHSME\nGDAWgBTEpxdWDZOWaZKrt7OVVG784ODVjzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCQMxqgXr+2vXJdH0qBU4MCzU8dBbuP\ntg93N+WH+INASAIhAOLnCV3KACrfa/6QoHSXyQKVgHyvPFN7l2Rlhn1LKCC5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbhZ+aQjUjXqrjm5SD3ByZYKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMWJkOWZiMC1lODNiLTRjNTMtODc5OC00ZjFhYTQ0NzBjYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQudehogXZghlmAcue5osRSehssD5Fo5RhXomZOsUaACwPl\nIJnMTvPRgAuMgboULquob3/XcFsJMY/NMEWop5z8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxKcXVg2TlmmSq7ezlVRu/ODg\n1Y8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGaqhT70ldhy1eySO7vCFny2kGn+9MVqe6iIcU0ULx+cCIEjRergNvo1e\ntln8lzww97HX4ERIyW1kgfo2sgEK5OzA\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAR+bSrA9vg7vCdTO5tg7bKMUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2U2Y2U3MTMtMjJlNy00YTczLWE2OGMtNDJlNTRmNjNhOWZlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTUwM2U2ZTgtNTIxYS00M2JhLTk5ZmQtZTFiNTdjM2Vk\nNmE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4aA8mmxTQfOaCCRs0ftmRPx2\nTAW57CqF2tGO+DYtmtNTb5Jx/bTcyohPDAauF9+T9SRTsgf4C+21NeR4kOz2SKOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTZUWeFXAjEl5MGVsbUQitUwIVjPzA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22DH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALc/aUxweFbWQQk3zow0XQRpeHht/44e\nAuHdHEnR8dXSAiB7uvCszwguHEEWFVn8CdIvf7Vw5laCK3zASSfpsk44Vg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8987", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8987` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAQi75BI0aJWjF5ia4jFmAYmwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzZDE3MTYzLTQ4NGYtNDUwYy04ZmEyLThhMGFlYmNlMmY3NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTI2ZTRmZDUtNGMy\nZi00NzdkLTkxYTAtZGU0N2IzYThhMTM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYSnWN/lq//T/H6upOvzIyRuAkqKTN5bImfO+uL9D8Pa0VJqq9/FqWerA0KmN\nVEvtXfLfl0sC3ZJ6DqbOPh3asKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSScEYQS9mdyfCY1EtTDpqQ8jwV0wHwYDVR0j\nBBgwFoAUBhqKDCwZu+cZ6FB3jA1dTDpaVeYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIB0H+tuwr7z8p8nT7eQA6ZdkKjkB\nRhnTiN+OUP7PxKokAiAPXbW5N5+g5NovuxE9qqJcRAT0ThngBaavtiRCKWhXeQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT1hDXO65kVs/sPieUthtgdzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2QxNzE2My00ODRmLTQ1MGMtOGZhMi04YTBhZWJjZTJmNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATO9d0E6xQWQkUj5ygV+EAskSdwkaGs5pmTX7iwV2GxJf0e\ny9vgMJGIqiMmJBUjy6AaITgs7ypbQAC0iAwVVak2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBhqKDCwZu+cZ6FB3jA1dTDpa\nVeYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKx36X2y4Tkf9StFMaF72LtIHUpn5V92EFFuQRLsJSJ4CIFp3d44Yvl3Z\n3AoXbLgiRHIwv8j+YThQLIwlQDiRIPID\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAeVZceg8wbbzLIBx4OCrmmhGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTI2ZTRmZDUtNGMyZi00NzdkLTkxYTAtZGU0N2IzYThhMTM5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2MwNDg5YWEtNzhjZC00ZDJkLTkyYzQtYTU0NWRmMjU2\nM2Q2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwtEciekGGCa3mu1XrxT9As74\nL62euapJjvaG318ZwKjcHavUswuFzP6EXVbhDdKB+GERsNATpmlcrjK6EiPOYKOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRJJwRhBL2Z3J8JjUS1MOmpDyPBXTA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22EH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKRKqs94LcZ+IF9X/mi5OONLG4JKLv9M\nm/tNrYHq8MJlAiAaYSqaRIANwqLfjy7nZiflXX9Xe8Ph1NLaMAuhiaejOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8988", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8988` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAYnsBTZsfvqptKPQ17P1/yoUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3YzA0MGMxLTcxYTEtNDllNS1hMjY2LWE5NzQwYWVjMDI4YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFjMzRjMWYtNTE0\nZi00N2Q3LWFmZmItZTM4M2I1ZTkyZGVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6ZQduOa5wopbP6/7OEWaAxffodXFV5F1eHaIe6y7jFWHskbTIuWyJmgYEz9a\nJBsgWylGd8GkZOGaLTYPqytjCaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTIHk9qefA8jO8tKKm46MxzvG140TAfBgNVHSME\nGDAWgBTEJDma6fTVBJM3RtyxS9VVQqtX/jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCttljZWNDCX6rKjKEVsWk+JmhSTNZ0\ncvbS/RgHOqmRjQIhAO8w7ffyrdHjsZ7VTiSNHKlB8Lwr4sdpU6r6qmSyVvYx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYm/bzPj0eji37uZ6EvOARUPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2MwNDBjMS03MWExLTQ5ZTUtYTI2Ni1hOTc0MGFlYzAyOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEELnmPv9plH/knpfMzojqDkBcT4nd6ofNvHxXOh7yFZiO\nKLVw5RMGcHXty2ar6z50U43+VXxK+WNYCIkxEewNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxCQ5mun01QSTN0bcsUvVVUKr\nV/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKvo6voI2MLCxJRZNEL5LCQIiRl82kqWsy/pYFlrDW59AiAkiRHnCh0q\n1IvO7Df91xnHmlyIY5OoKyaWBrZP9H8wrA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAd2gAwIBAgISATTKSaQzq8EVbPOXvAtJIgISMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFjMzRjMWYtNTE0Zi00N2Q3LWFmZmItZTM4M2I1ZTkyZGVmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2MxYjZlY2ItNjFmOS00YWIzLTkwY2ItM2E5MWVhZmIy\nY2NmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmQIMFPVkFE0s+QgFpZcs8PrO\nLt5GlGt7nUGMC8AkkjqbqJTaW2wORPoM9znLL9Cqqy2tKpCiYExC4EppfUGPy6OB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTIHk9qefA8jO8tKKm46MxzvG140TA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22EH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgC8Ux1hRn8n/VSZwihpWsa1c1KhctU0VF\n/2A1ECAHD8cCICxVtzy733WDwO1ZfZwVcfDx5es01nsVjXybuNR4Eyz2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8989", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8989` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAfdsEnX4DDm2PriO42sclw+HMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMjljNTA5LTlkZDEtNDdlZS04YzMyLWYxOWFmZTJjNWFiMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTNiMTQ0ZTktMjVl\nZi00NTIyLWIyZDUtOTFkOTc1MTlmMzVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu7V8/oElYLPYA2x8Ya2Fy6kLCnRFw+LgSpqr24G32PxZOm/Bfm5C9cqqIvoH\nIQ0g2Mg63mLnfcpl96CUXJPzeaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU99ZknO0b4oCgWN1izO4tEUpVV0QwHwYDVR0j\nBBgwFoAUjIU2gRrKfTzxDFTYTDf7HHsRXWkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDh/Z3zkF2DTHDqEG/yFW7bFev3\nt9gi1ilpm6PG+cViBAIhAI5NUcJuut7MLoTCLlxYHVU2hUKOsX9S2gURzyilGI76\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU9Z/cw0IOIo6eTeh7tZcOSIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDI5YzUwOS05ZGQxLTQ3ZWUtOGMzMi1mMTlhZmUyYzVhYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXXFEi8U3l1ESbb3M5yvudxpLdFi7Lssi8apynNO345FUy\nGSp/EGmFsoTV+JsFIO3a5cBs66KdpyPIqUHrmtqQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjIU2gRrKfTzxDFTYTDf7HHsR\nXWkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaA6xpSqXHwAEY/IY8Z5GErzsluKa7hjOVQ4PVqy+410CIFFjcmLzJo4n\nIA8Cpi3vg7ipzCi1sFEqMcGm9MFewCX9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAesGtR4dgwEA3Xd2xkyoFU/8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTNiMTQ0ZTktMjVlZi00NTIyLWIyZDUtOTFkOTc1MTlmMzVhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzk1YzhlYzgtMzY1NC00NGUzLWIyYjItOWQwNDc4N2Vk\nMDFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELsnWaHShbEAnPguzE/5ezSYc\n0PaZc2iIZsdmAUED1ng4w5qG+WmWA/o76BT4dpJSLkxtT6pjt8FHL+16Bc7Q86OB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT31mSc7RvigKBY3WLM7i0RSlVXRDA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22FH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgc3URa3Cx5qx4gTXn2L3xCVMwn2TeQBCS\nZ9GISxVusPECIQDwvF2zO6rxns86rWf9gMJ1sTOgDonOpXpvZX38Qtku2Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8990", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8990` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAeSWJIyGVB3ly1sO5xnwT82tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhMzhiNDgxLWExOGUtNGU0NS05M2ZmLTJhY2I2NDQ0ZTYwMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWUyMGU0ZjItOTI0\nMy00NTc2LTlhNjEtNjBkZDY1ODZiODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBV2UWMsrPz1CGZzdvWbBdKrulXXR4cDf7oe6CjB8qFLf0fyOGoS2JsJdoi6j\nvlnZa2IxdEqhu6BSozTjmvyZ36OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT0dBTz4l0jlIf3PGtE3dFkLKas4TAfBgNVHSME\nGDAWgBTWkYUvw5oiRd59r5nao6MNKv/cezAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCWQxq9NnihxO3wPv8BnyecIJ+EP04e\nuO4QyWJcfiSQswIgKdbGUiK1W4vgULRr8mE+R4+V0117MgfuZ2If2GG4EEE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXIE2ZcKqGNNOpwqqpoi2I6lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTM4YjQ4MS1hMThlLTRlNDUtOTNmZi0yYWNiNjQ0NGU2MDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxnsGHpTvroD25NKKf5ayT1lOuKNfzn0rtfYXFJM/L6mXb\nYzMAh/+7JT5XtF/HIwj4R1KlPlsd+7YGRDE8RCQ6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1pGFL8OaIkXefa+Z2qOjDSr/\n3HswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNVVTXUyxPaMFQthU/4UF21PobqjdCSrXFPS69ofBPtcCIEMSzxQ1DDWY\nN6ZpVVWiqhCwbhbXmb5M76d6TD+wxeHl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICODCCAd2gAwIBAgISAadA4Ze6mVDUNL/LwLlLb/vTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWUyMGU0ZjItOTI0My00NTc2LTlhNjEtNjBkZDY1ODZiODI3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWJiMzRlZmItOGVlOS00YjQ5LTlmMDQtYTgzZmQ2MDNm\nZDJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiGzQev1bQ/4ElvIWDxClmJsb\nh6YApuzfXF81KyuhkL06KfvhAiLqExxEd70wdjQEwaGd3i5GCLVwPr+giEyToqOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT0dBTz4l0jlIf3PGtE3dFkLKas4TA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22FH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMAjgOLR7IsHxMPx6RH1M2pTArIjnhFc\n+6Y1b64IAwvCAiEA6f9sTLMgE+fn1+M2rdMYnPo5X8y58+o+/dIHVib3dmo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8991", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8991` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATuXWIi5yB2RCy6CdAStp6FhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmM2Q1YzdlLTdhYTItNDkxNi1iYjA1LTAzOTU4OGVlMzBkMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZlNDcyOWItYmRm\nNC00NGVjLTg0NmEtMGQxZGE2ZGZjNmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPrbYocjRGTY5ThoaXgecM7QF92+sPSZqKrBVwgOMBxORSSzoVEdcHmCcoooC\n5MOpkgNm/Tni7MP79B+mX7G036OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+6a8CSiI9dws9m4IzFkCBESdj7YwHwYDVR0j\nBBgwFoAU9/RqmsAT5eaj9VDRU4zwo5Vog0owHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICd3v/SIdC8UxQGwvUFCH5L2Kh+/\nBFf5dmZ8eLTE9r3cAiEAtrcXqPly9dBHj96y/IgLxMNSKeqrzvNGaMOLZ3Lke+E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQWm71Bxwt4ZFeNzyJ/Ckn5FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjNkNWM3ZS03YWEyLTQ5MTYtYmIwNS0wMzk1ODhlZTMwZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ98W1GL1f3AD8kdq+h3JSY3t8kq+thS0pYtC1/OdPeh6Q2\nV14MvxclBSxEGukY3BTaQ9jrFPIA0Jy5Wm/eVSKLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9/RqmsAT5eaj9VDRU4zwo5Vo\ng0owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgWWqxOBTZe28O3ScGBrkTRixlIdxJ+pxhja4OwdT3s38CIQD8+fYDtp6K\nRNOyiqAumNnBxR6diV5wb/F4UQisQPJ1xQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISASNiKGZ4Bkz3aBrpT84doSUYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZlNDcyOWItYmRmNC00NGVjLTg0NmEtMGQxZGE2ZGZjNmU1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDliZGNkYzMtNDQ1MC00MzU5LTk4ZTctNjBmZTRmNTli\nZDc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE45fbK2pkDyRCm5429gB9A1E1\nrV3OisrKg8LXKTQvS/J5u8JXQXeGyvJgd/TJhjR/fHC1LXGwC0BjT0ekBS2YNaOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT7prwJKIj13Cz2bgjMWQIERJ2PtjA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22GH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANRknulLUzhWbdbMxKQwA1XDZ+GPKlY8\nfIb9I3yt2yRHAiAsUrnkWdGNWV2Fasj5MRkcWcuOi5YCQLE1+Npp6KL4Qw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8992", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8992` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAU9ue5BxYScU/k4xn35pClrUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2OWU4ODZjLTg4MmMtNDIzOC1iMzE5LTgwNmY2NGQ4Y2M3MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWZjYzJiMTMtMGE4\nNy00ZWM5LTkwNDctZGFjODA1OGY5MWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsUeWeXtW7s82hQ9iTekdeK8+Zi792+pmCKslmt+WvRmgZDPVIYuCLwnMNEAE\nVEwl1qBx+uwfDeaG7FIq099EbqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRM0ZG1h2S9TAv1UFxODfeQKCmYTTAfBgNVHSME\nGDAWgBSFHsIliSIfO3APqHPYFK4Ce0DRZzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCphCtzai1cjoWuIOdrild5KJncKnn+\nmMg2D4GKcW3g/AIgTGSC0wGr3XuAFxnSsOBN2zYzRW9T6d28CcFgr/zjKs0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATi8gDC93NyQ+qLqbGD05b+RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjllODg2Yy04ODJjLTQyMzgtYjMxOS04MDZmNjRkOGNjNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASz6nMH0JncvWxi5ZC2l0iqE8NG9gXjcxub08fjfbKX9787\nqTVB5op+bW789JfSroZhHI8pHDO4BbH2sEmLTfMUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhR7CJYkiHztwD6hz2BSuAntA\n0WcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJ/3dBNWDLWXdz33F9jtPTeKxBDEW51ICEm7KhLmEBi8CIQCA5vzaJci7\nsGl0uyTqTIdx3nvHKVH7RNirxvypEt7FAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICODCCAd2gAwIBAgISASb7imp9Lcsl4tS/WwDLB7kpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWZjYzJiMTMtMGE4Ny00ZWM5LTkwNDctZGFjODA1OGY5MWZjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzk5ZDYwZTgtMWU3NS00NjZmLThiMGYtODkzYWM3ZjQx\nNmRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEI4aToheIOyYu+BEykxxW5d0i\nNYdYxCD+MgUFhCq07ofKrZWp0Ye7+cUNcAASmtt/KTFK2zGrhVhxu+W9Jn9kU6OB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRM0ZG1h2S9TAv1UFxODfeQKCmYTTA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22GH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAN+fZ2c5TKthhbtYmdFaKmq3IhcZLkII\nibPzMTpwkkGOAiEA5+pXqbIylw2ztmohjOB/6LS4ZRfF/rW2AHAtlT7xj5w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8993", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8993` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAe+DqJ5/5Sy7d4Lq9brqQOKpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjMjU0YzRiLTA1ODMtNDE3ZC04N2FiLTVkZjYxMzVhZDUzMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGRmZGE0NDItMjBm\nYi00MDM2LWFiYjItZDAxYjRjZGRiZjE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE27YHRz/528RfuVDBXZYllpmTk3wHXnUcUwmJjJcV1W7HlZvvlj1cIKHUEmav\nChr/SFQNN1rLmypYD9d+Po50+qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyM7IZlWo/jsD+Qan1ccqSSf45KwwHwYDVR0j\nBBgwFoAU+sORZPuKVo5B4gDKfgKwLuBoTNMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD06MdraGKEKOU3bPNfxxRHk0cG\n19cQDsjCVxvZDA0P8QIhAJe4kKe8yJlnC5S2P46e554Hj7zVQS1JRpxkow9ojC3a\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASWNF5XbMAZbHLUsHTBjmaKqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYzI1NGM0Yi0wNTgzLTQxN2QtODdhYi01ZGY2MTM1YWQ1MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9I4V3bjKR06vFWGvQsUksUWCjJ8dttuAl6LyruGri++NV\nHu5I9OatU6fhzLGVi7xI5SnoAeecCJhDOSWnjSzzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+sORZPuKVo5B4gDKfgKwLuBo\nTNMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCzWEkaYDxhe46inL8OD7dTc62fdLiF/IENyyCYQvvDgCIQDoh+BHomIA\ni305ShvBDRkdsVTzOoP2GxW5mb1ui6l+Rg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAf1DyuTkkSYlutH1B42jfERuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGRmZGE0NDItMjBmYi00MDM2LWFiYjItZDAxYjRjZGRiZjE4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWU2N2UzYjYtYTY2My00MTMwLTg0NjktMjgwMGEyODg4\nZWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYwoNBks1Jb6vc3xutPgqXDva\nvyxRkzALjBBiBhiIz0UXMdN/D3Io24bT+BS6H0ajgK8kDxA3MHLUEq/rrB5GgKOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTIzshmVaj+OwP5BqfVxypJJ/jkrDA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22HH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgFS5XgZ4/Afm4KHXv3ERLcSKd0GMNW3LW\nAj8xSMpr11sCIQDp12hOhkndkAqD3Lf59luz0mNbq6SkrLQgeLTda+EzTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8994", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8994` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbNs0UXt4IwuXS66Y5ijyDZpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1YTBhNGQ3LWQ2ODctNDQzNS04YWEwLTM2Y2E4NWY3YWEzZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q3ZDAzNTgtYmJk\nMi00NDBkLTk0OGEtNTIxNmQ5YzhlNDJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx8jFXjmOSyPm4TOl7xnZib2Ychv8Ny3lRVKDuw/HERdqGATcbDqKtZpO7IAc\nOLod/wTX32Fq/gEojcQ27xfhM6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQW0QzwoYFmKLQmWPmr2y3Aox2sfzAfBgNVHSME\nGDAWgBQZkLnHsdallLggvZPpUgHshJrb1zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDVwm5rgZjyz20v57dGbLIBoB5OWhpE\nwd7kv55jsu4W7QIhANKRkygPUhZ5suVKFBV69UJGI04OhY5x8G8bQ6hD48Lf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWaIRBAfgZ3NWuYV/DU2VBjMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWEwYTRkNy1kNjg3LTQ0MzUtOGFhMC0zNmNhODVmN2FhM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARsHEIF/a6a5vYJ11u+LfWxllLDgX2J08aGgJYeLoVwJqxs\n4+KbJGZvcdkfz8SkZLgbCJ4H/R0vYUaiTlFK0aZ+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGZC5x7HWpZS4IL2T6VIB7ISa\n29cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgRE1CKaU4HIBgfp3dmTxY51XDWhIfe6xBcHPudaq86RkCIH+WDq7R1CeZ\nDKsL8hXQgW8UulpxB+Bqg0rq75ubsDpF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAXFoqQcdpQAORQ1Fp6jWvhWvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q3ZDAzNTgtYmJkMi00NDBkLTk0OGEtNTIxNmQ5YzhlNDJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzJjYjk5MWItNTI4MS00MzNiLWJiMGUtMjk0NjE0N2U5\nZTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjmvGuIUyHzuu9nJI3fJwtTcb\nQSwBYXTNRrB2w5qvNLhJf5g0XAWL/dS4PEU/dRiZaQ9G6wbiWh0KxE2Z5DuLfaOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQW0QzwoYFmKLQmWPmr2y3Aox2sfzA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22HH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKfK2oqeJSuzVY+px0ElFPbiiVNP998o\nHjNeqDNQ2EakAiBKE8s1nl+wuJFcA0gyCQipkC4H1slgKYgud4q/TrggxQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8995", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8995` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAceIXkzSb3j3N5X/r6mUXNyNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxNDhiMTQ3LTdkYzMtNDFjYy04NGE3LTk3Njg3NzVhMzI0MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjUyNmRkYTgtNGM5\nNS00ZGQwLTk5MTItODdlZjk2YThjMTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzprYKsasGrkYbooX1dv9U6nOzGrKKOyGKmw1YB7Gl7XS0qKSY64NhBhodr54\nebTtkdnkf+cyGOZeskEfWnun8qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyY6BsKEw4XX/2+NO2Rpt4STFF8wHwYDVR0j\nBBgwFoAUHlZUB131jFX5PekyJW57r2gn72MwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD5vEU4pWLkM/RLTFmZmKgAgnww\nGT3MmdIYBuqovrEMmQIgSiRNpIDAH6OxFOU6V4oo6YIyQg+AXKEf4zGdrIgfL5Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASaHJs2dhvesW5a8DWa3gDLfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMTQ4YjE0Ny03ZGMzLTQxY2MtODRhNy05NzY4Nzc1YTMyNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATavLklWC5giFRrA5hyW0qxOglK+NpznDJo1FOaOmH8WoQ4\n/yM/RT2QdaPYkMfhPSX5E8/kS5GqDun5zjc9jU16o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHlZUB131jFX5PekyJW57r2gn\n72MwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO4m5RDUmq8tRrAXqkfe3qMljg9v4cRHuhMAksyh1jzHAiEAr6FyJr2x\nvhtXGQhlPDlQz4dO0wHWgdACnGDAi8HtK9Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICODCCAd2gAwIBAgISAQByXuvB035NANazzmL6ZaRYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjUyNmRkYTgtNGM5NS00ZGQwLTk5MTItODdlZjk2YThjMTZhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWEzYTlkMmUtOWFjYS00MjZiLTgzOTEtOWI3MTdiNzAx\nYTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnwpTHQzwKQJbgv09iMWNMqfh\nkK97qXT9Vyln2gk5S92YoyE2jDd8TijpTV6bdSYFQKpyXk6lJKn7DhLMMn1ck6OB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRbJjoGwoTDhdf/b407ZGm3hJMUXzA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22IH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIn059edSVpze1uZ07Lyvlw2qWCgvhkl\nBRqzIrOIuMWRAiEAl1m5dZygZH98mo6opF5LdEVQ2xUalTC/Kd7Qrgq4RCg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8996", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8996` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISASGQuMaXfgkqXewpJ5FfEs1+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhNzg0ZTM4LTQ3ZTAtNGZmNy04ZDkyLTk2YmJlZDgwNGM4MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmY1Y2U3ZmQtMDc2\nYS00M2M3LWI5ZDgtNWZhZmQ1ZDdlNTZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE139TpwA23I6vt6IZlEFqzWI02eFRg7+0T6Yr7Po6tLaqIiraMpl0CxP+aVgH\nWHaLEsqff3mkfyAu0Mz5J5t8O6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQJr1UfA/fpHVutkwXSyIDduME6nzAfBgNVHSME\nGDAWgBT33HYNE9OwaqorwQRVjgVYSXyatDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCRr8FPv5uONLf4SUCgVd99xOkjZV5Y\nmcdYyecOd8unOAIhAKK2FURD3gqMGyd/fpEY5LnABdz+wew89JQz4L+YJHui\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZYuNpA4kbtWBGb0bZR02Wf7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTc4NGUzOC00N2UwLTRmZjctOGQ5Mi05NmJiZWQ4MDRjODIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdNJP35kkPSlj14Tk9MDFngYcO/hW9ERP8ttaiSztabjzP\nQpooIIPBy5VYqFdKZNOKiWmFRlA5MHEJOBOZoF/xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU99x2DRPTsGqqK8EEVY4FWEl8\nmrQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKiEJPnR7GdC0bPShCBTlG7Q13TquNYyZ8+0NohmFKpWAiAUT0g233Cm\n8Na8K0EjboMam4ldzwHYA2gqPkiBhhjtwg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICODCCAd2gAwIBAgISAY1YK/otYnjl3upwlEhF+lhmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmY1Y2U3ZmQtMDc2YS00M2M3LWI5ZDgtNWZhZmQ1ZDdlNTZmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDhlOWU5YzEtZGRiMC00ODc3LWJiNDAtYjE1NzI4YjIx\nMDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5x/jPJz+S4X2trV+ac5pWXMD\nAdmLLIv5tdp5BF4spIukbbdbExdvQicf+4ZDuTqx2dcZuRSbowXCFNDbegdTXqOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQJr1UfA/fpHVutkwXSyIDduME6nzA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22IH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALpe7oKaBYbBRGknyAtYsgMHUBCwJKDg\nTuyG2vXerg8cAiEAmMjRqe4Vr7K5QIY6g155b7Nxj+kTueOdNnJf0veCDeo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8997", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8997` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVzNQP7XMn9MAUSFQU7FNgzsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgwNmI1NjZhLWMwNDAtNGQ2Ny1hZmUxLWY5ZjRlOWVlOGM3NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU5N2MwYzctZmYz\nOC00YTM1LThiMDQtOWIxMzgwM2JmMzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsKK6dbHddnm0tbtMXcQA+n5wcmFSgz9rMnGLVaCW67anwlPYO4pn5C8TWTFI\nLfd/b15rGWltw+2tMrbb7Q7zO6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU31/YNz20Sv5LG90rPPpJ/pIdJuUwHwYDVR0j\nBBgwFoAUZe+hOfZOJy4HcPqRAbvG9TVVE58wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGDb0uzxAlHwoQurYpjZnCBnqqwV\nWOXTkFmovEILDGaZAiEA5lyri+IYJLthjclDKI2jsGWmxQEM5ORr5LetSQCqG+I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYeKppznDxg/Mv85O5WZE88WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMDZiNTY2YS1jMDQwLTRkNjctYWZlMS1mOWY0ZTllZThjNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASI0STi0RG1fFarAsb8B/fam5UTxP4FgZrGlLAC5rWorSWY\nU8L43QggkcUY+SR/jrIxx0Q79hlhgGt27re/1uBfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZe+hOfZOJy4HcPqRAbvG9TVV\nE58wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJwC7WnoOiGmS87K5miVLjEw+STMiFc3/lNqYxMsqbgtAiEA5aFXbYzU\nzSvCSpzVBzZn5Db8ESGtsfLzg4Ki+77cLvE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAVrKjauzC5Mt2XyUrzelatARMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU5N2MwYzctZmYzOC00YTM1LThiMDQtOWIxMzgwM2JmMzNjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmE4MTk2NzUtYzE2OS00ZTgwLWJkNjMtODI0NzZlZjI1\nYjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGqRo6qQwORhHgYkKaj+C+p3K\nSZa3gTYQfOndNtPFyoG6fgB49VXJyOrYmpPjj00+TfA/38W8yjzdFbYFFr9TtqOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTfX9g3PbRK/ksb3Ss8+kn+kh0m5TA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22JH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgBLYFHgl9q6R5/MNe0RmpTCLQPHbf0UL4\nBjePwoHHin0CIQC93EIDLFEnNrWJAaZNwzYLUXXRtiA8DlCZd7avO3+csg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8998", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8998` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbMrpd2cpJ8L465NbYSq/aFfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhYzY2YmE3LTk0ZTgtNDdhOS1iZGZlLThjOThhNTEwNDAxZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZlYjkzZTYtNjYy\nMi00YTIwLTg0OTgtZGFjM2Y0MjJjMTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaJD69p2zBnd9quQtWxSCzbiZDON3TbNI6RV6qGxehO98kXC+MHoaPVn6BGsO\n4qiqRoCmzDwv2u3wt6EJrwsrxqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS/QzRd8TEcKs1h/O6RBV3+68QNSDAfBgNVHSME\nGDAWgBRhAWa0rtdwY5Yu9vbUSRL8CrXiKzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCBl5lsoT54vHUmide6GmERspSf421/\nitOwap3k1bT+3AIgF9+L2R/GFL/GaestieRiqGhp+rM+JSXHnFX0JHzT+QU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbChrrafKpxZ8A21jEqUG/loMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYWM2NmJhNy05NGU4LTQ3YTktYmRmZS04Yzk4YTUxMDQwMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYbCOY9L0nFeRyKxJSMzTdG59lV+q1/ZXJG3Py9jFV+4F4\nxXxIle1Cj/J3eDfbsvz3sg3m/iu9o5AnaOIwqyrro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYQFmtK7XcGOWLvb21EkS/Aq1\n4iswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge7tD0Qd72RHT3uIEK/Q8XE6h35r1wfQpTNNyEL2bO6MCIEjdFraoFx+9\nBO/C26QlcLULYI36hgDFXAEOIxIjcizL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISATYYn8LaAhJT8nl6FUkb7N3VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZlYjkzZTYtNjYyMi00YTIwLTg0OTgtZGFjM2Y0MjJjMTkwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzM0ZmE5ZDQtNDA1NC00ZGJjLWI2MzItZGNmNDg2M2U3\nZThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEwgeltqttT+e6Fem0F+NsK5a\nypjxTOAzonQMaEPoYvaZdrbHtHHumm0tFduK/UUxlDE14xIXQ4Lxs7Q6YMXSPKOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS/QzRd8TEcKs1h/O6RBV3+68QNSDA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22JH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOakSgLNFKRbQSNrZ0Zr/jLDJr2s4/UO\nAf4rJHn9D34OAiAwPjBnh3qGSSQWebdV8re+pnroDsfdqJ3PpGUOKKk69g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc8999", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8999` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAScIl+VYBVCvnFC7g/qNkSpLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzOThkYWQ3LTRlYjAtNGEzNC05NTg1LWJkMTYzMWFlYWRmMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTRiYTU5MWUtNzY5\nNi00ZDZkLTkyMWEtMDcyNDI5NDQ3NTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl+WHd0W6pG6Dp41qs++VFqQe71qhjHfeJgTVvxNL7QlHfc8ASfPQA/nC0oYh\nOTAvXBmt0Hwm8g4UAEtAYd9lrqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxFas8JqRzadJ9ztYSdjxoRmeb/gwHwYDVR0j\nBBgwFoAUvLGFATiLBzCrME14xgHL/B89kC4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC2bWU71+fI8CBKIitiD8ylV+kk\n3NazkCXrgG1R889j6AIgPIUbp84Sh0tmDeY4MGWlE7xkx2Y8A9VuqO2ucJ4k51s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYrYIS7uLLTSeZBzWZEnqPg4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMzk4ZGFkNy00ZWIwLTRhMzQtOTU4NS1iZDE2MzFhZWFkZjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATFb6qIJt0b8elAthoHITEiXne63+DRUAoqlipEAQPHrkIm\nE/rdD+HpYDTXxMQ3x13VPXg5zBxkYlH0ZV5O0IJvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvLGFATiLBzCrME14xgHL/B89\nkC4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJYlQ/ie13sTlxt2lPyGE87qhb3+S27xmXBCo0AiYcGIAiA+5Csl97Ow\naHJ0fftSBxIlHBB5yQ3x6/YyXmstUowmRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAUoNFtWx+wfcqdEz94Xff4EMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTRiYTU5MWUtNzY5Ni00ZDZkLTkyMWEtMDcyNDI5NDQ3NTc5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQzZWI4ZWMtMDdlZS00MDJiLTg2ZjAtMWYwMmU3NWQ4\nYTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4PCQ/mmaLN7juV59do8nQdMi\nh2FCueh2xFt+w9Dl0PtAEIl6WeGZgYcvTs3IY4DH0AoWwjJX20RER4zFougUr6OB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTEVqzwmpHNp0n3O1hJ2PGhGZ5v+DA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22KH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANzGsripLzguC1apxH++7A2I5XsLzetc\n30dCyf1VQLyAAiAtII2CNDnoUR1AcCV0rzGkPR0pk6PonE3bhCxxYdubNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9000", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9000` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAT+I4nYKgjUa1lsgZp3QAMtlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkZTk4ZTU1LWE1YTQtNDdmYS04ZmY4LTJmMWMzMGUyZDg0NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY0OGRjNjQtMjhm\nZi00MjdmLTljMDgtZGY2ZDYxNzVmNjVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1XkW+ZoK74GyW9xid/+/70DqdzZPi83KSCFMWDpn5kXhCVXuR2nJo78r3Kqs\nYvgx7Qz5SqaAG/Vhtg1RvUbWm6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRyMl9B7cwLO8wy+x2zisH0khLpXDAfBgNVHSME\nGDAWgBQdR6EtH90UpWFE7UgCGZHEjitIvjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAKwppJM0xhoPXscYFwFCYoKr4v6XUir\nmtVVj7opJVOzAiBF8NUQypoBmPIS3I7H9YgMBx8yA2D/nb1VDrGQva+odw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdkSZqq04KM3RhRBpqp4Bb/pMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGU5OGU1NS1hNWE0LTQ3ZmEtOGZmOC0yZjFjMzBlMmQ4NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGGtEcONyUrY57bKjqko/KT0lrHALMOc/hZu0fIfqVDvQl\nUo2Op+xujWu5SoOgLvXzScXjktlO3dNJUqfoU4blo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHUehLR/dFKVhRO1IAhmRxI4r\nSL4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTx+uCts6bdrUd8HhSqpSvJZzdzBRVvYsDoUNcDdDXToCIQDKQ5AB9bp/\nbz1nzxilUtCaaMRBbQE1IDk/dCK/fjEPCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICODCCAd2gAwIBAgISAdKv94qmN8HnrIXs6Z2184vgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY0OGRjNjQtMjhmZi00MjdmLTljMDgtZGY2ZDYxNzVmNjVhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGY0MzE2YTMtN2QwYS00ZDkxLTk2YmQtNDFkOGJmZGRm\nYjQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr1nmmZ7dXCEnc8NVYA0/YiOw\np5f/tR8eSvlyRaXuLp5Mnz7Y5LAgXBQmkiRyCcBrw/iV37K8DFAXCi9S6KOWNKOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRyMl9B7cwLO8wy+x2zisH0khLpXDA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22KH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAN4yJv9/xUq2gpiP4I43+qcJ2nDBvGVz\nEx7TLxA05UmGAiEA0wgdXLegJ/0XR9CKE5DQkHz1uDh06wyjeFE2Ore8s5U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9001", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9001` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAa/8dm4DXHEN9zbXMItEkdBfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5YmU0ODI2LWU1NDEtNDcxMy1hMGM1LTkzYjg3MzUxMGVmOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2IyMTg5NGQtY2E1\nYS00OTkyLTlmYTItZmRlMTI2ZDUwYzQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6ng/AZJoOBxnNZ5dpCOkqmHmOz+lQpmaLLOI1gvITfXkzdOdRXsaV51I/+VJ\nkpd0xaHQE05xsOCw7j9v6eurJaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHZaupkPpWzXjunYPYWfqucVcEnYwHwYDVR0j\nBBgwFoAUPmjYyyWKDAG+bmbilIbZeOUmrrMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBRIsg3yFlYRxEdtDg2+nicCccN4\nEIvJgMSPSozKFrcoAiEAjgTea/RituSB3xfjZzngcDdLbJSQDlKfcP/kyqiDjRk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZBctsX/Q/ldL6O4slf2HeLMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWJlNDgyNi1lNTQxLTQ3MTMtYTBjNS05M2I4NzM1MTBlZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTMMzMHndJYkowq2cYftWK+gaffnK8dFWTPzBYNs+IjUfv\nlQKjDwwSiMJk5o8SRLx+1TTujzOPug2lQV3ZLFhuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPmjYyyWKDAG+bmbilIbZeOUm\nrrMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNWwehx2uFF8svYMMct5tf4Brtb1XcHSaj1JhdGlmlp4CIACYJohA2Sh0\ntdqSa0G/E577GdFxk52WoqIPCVmw24kL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAd2gAwIBAgISAcE/c7Nu3rd9bX5pHnrhcNURMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2IyMTg5NGQtY2E1YS00OTkyLTlmYTItZmRlMTI2ZDUwYzQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQ3NGUyNDItMDg1Ny00NjIwLThkN2ItMTc1MTFkN2Iw\nNTM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgKGJ/U8XMAR9lZMSm9bQ3SAT\nG3LWglZrHk42ees+HcrrEm2ri212PE6N+nL7X2jQQY4esnMb/xSDnF6UWOn8F6OB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQdlq6mQ+lbNeO6dg9hZ+q5xVwSdjA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22LH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgGHn4MGCKNmVl08gq0pEBF5zif3w/VbUI\ngP1o7T8FumACIFyOhNhsuoIbLhWbuCzkAHrlk3Dz1+c6+5rGfxu7ismI\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9002", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9002` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAV/mj2IC9eYBiwNXNuThi/3EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4N2U0MGY0LWY0ODUtNDA0NC1hYmE5LTYwNmQ2ZGQyMzBhMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQzMDFiYTEtMmZi\nYS00ZGUzLThkZTUtNjNlODYyNjZjOTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx1AkQoYayqk7l5yPPxZVCfqj+AT+c5o+FR7wfTIuAkabh9zD5io0TUSXLxLG\ntfVbHVADrd37JYnUzQKa7RS5/KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSkGUb/LdA4ag2auO2Owx4r3G95hDAfBgNVHSME\nGDAWgBRzvlcbpI2hn/DjNavXMc3D3MYBUjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCMqA/+FnstXryfDfuAgsukE/KMXImu\nXWYJ/QeMJvgfzQIhALOZisogYcT3zJwRhQpRtW8KKQKob++tv54epojQl2O2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXnaucxpZmgsxyyZOvc9ZvfYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nODdlNDBmNC1mNDg1LTQwNDQtYWJhOS02MDZkNmRkMjMwYTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeALM4q0h1Sjun2qShVnPTId3FfsKuGjgZn8KiPGZRCEdy\nw7yWlez7UjSNH6aPG9NJYXxQCDN7sYLD9Rtc5+JEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc75XG6SNoZ/w4zWr1zHNw9zG\nAVIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMEoPII1t3ljJ/as3TgtVpanFd2mL5hwS8xDhkdnMAnVAiEAio8sj2tr\nfV4urOlV47rPiX98V9vCCjjj+4IdZ3iU+/E=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAd2gAwIBAgISAbIxNjebyAU4hEgZ3hLGIFB4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQzMDFiYTEtMmZiYS00ZGUzLThkZTUtNjNlODYyNjZjOTY1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmM3OWMzZDctZTRmZS00NjJlLTgyMjYtMTQ2OWYxMWFh\nYzBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmhbqAjzw+EMYBYE5c7muP8jn\npKhV+ut57VULSXiH22vJI5shQ9eXueck3hDIBKcHQ+rl7bTWLDKMGJFJ5f0k5aOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSkGUb/LdA4ag2auO2Owx4r3G95hDA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22LH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgbGvI3Pb2lCsTZizf53Lk+P4uCAULC2Yd\nwVp23Q4P0vkCIArygT2b0T7esDSQqNMOagRnXv+vG+n60mC8nN7K4XNr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9003", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9003` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAb6b/WmVH3CyfzAvlHbzBKhcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NjMxOGQxLTk2NmItNGM1OS05ZmJiLTM4YWRkM2U0NzUzYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBiZTQ5MzAtMmE5\nOS00MjcyLTg3NmMtZDc1MWJhNWY5OWZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElP+IDCmjpDSwUCJeJE9RSTNejjfqXqgNei/06jBL55QiqxkBo6IAr2oKZNV9\nOc71VO691m53qD+G6gMU3WjtFKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMIEpbr5F+Jeou7QPqYZtfy1p6yEwHwYDVR0j\nBBgwFoAUa25cBwNlEJxOxdnSUBA0PxOR6GswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFsVOxablBXqv3TrKGm5853xCSjM\n6lbi7xdM5S+h91s/AiEArJzosrLPZ8Aa0VglonSjE1Xtie6cLuJO5Ho54GckJGE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATJuYf2qTr9C1ntmERjiBOoZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTYzMThkMS05NjZiLTRjNTktOWZiYi0zOGFkZDNlNDc1M2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCPmLHenAt+wpWtZFGJjwvRyn050SiyUQXDgNAo1MvdHuY\nXNfk2EpQH83Iup9ZCiK6SFjutzDusXbX0A/BEsgXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa25cBwNlEJxOxdnSUBA0PxOR\n6GswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALx9r6sW8GaU0RXH4cWJ9UHFyCNYguInjugLpiCChtCpAiBqW1unsDD9\nSsEpfFtql20A/W4FSCe2MZzKoXb/z1dHVQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAYe0LQko51ZLJIQLynsn9WiiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBiZTQ5MzAtMmE5OS00MjcyLTg3NmMtZDc1MWJhNWY5OWZkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNlNzNkY2QtYWM3Mi00M2EyLWE2MGQtOGQ3YWM0OWNj\nNDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEixc5Gu4WLh8W338h3wKmaL50\n6l6LNfhPRM7Ol2/u8LnI1ultGfKMYIevzPYPaGcExCacNGMDGmg3Sgt2Q5NdtqOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQwgSluvkX4l6i7tA+phm1/LWnrITA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22MH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgdx6SOxu+jZBNe90BkIqw5i8P/ASdtH1h\ntu44zV/pTfYCIQCQBbHmGzrMvBosdW2OIh1sef7ptFKAtO+zKvHyeF7+Qw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9004", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9004` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAd9dWWGFEN3+6Jp+9oE3NhUuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxYTNiNWZmLTJlYWYtNGZmMi1iOGUwLTVjMWM0ODI3YWIwNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTEwM2JkMzktMGI0\nYi00ZGUxLWIzYmUtZGJkNGQ3ZjBiN2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE933lbE+rbyQ91HUVfUINDSmVegoW3LcHNcw0kfmwiT4BiogY5s0cvGU1lttK\n+N0n79/ov4mSJXBIYWQ3EZfIR6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ83E49+o0qWUnTn3elwLiZaIN17DAfBgNVHSME\nGDAWgBQ3fpZqHq46w8Lb4vZZclapWHDHmTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHYrNolEIrtZt0OUv5UP9KKPOz5fYcgJ\nvwOdOKjqDHILAiEAlFMwblE568G1zq1A9ELIQW5e83z12K5SZjkrxWiivm0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeqBtPmb3BsWKP9ps7X1QcXnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMWEzYjVmZi0yZWFmLTRmZjItYjhlMC01YzFjNDgyN2FiMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStQ4ydR7Bjw2xMdkgZGL3fb16Pgm+Dd1vCQcVxGHSEYzTF\nz+/SnXj3wlWr6yxJ3y2D2YpV6RlAi5hLIJ6xk9avo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN36Wah6uOsPC2+L2WXJWqVhw\nx5kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgcR7G2NJ+l+NpkBO0JINbsOvufc+0ACUQo7sppF2U+jwCIHz4emo8oSXW\nx+n0YlFI7S4Yey6bi32idAnjT4FATxcG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAd2gAwIBAgISAQ5YSS35JpUofZV94dD3HNoUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTEwM2JkMzktMGI0Yi00ZGUxLWIzYmUtZGJkNGQ3ZjBiN2Y1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTQwMTgwZWMtZDUwNC00M2FiLTk0YzItODU1MmYzN2E3\nZDg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWK6PgOlTUfFg8iNIKTxhR4qT\nKL9HyxUvucJYvtLEAXJ4ddwHYPfMA5OpKuHUGeq1V/H36xrY7+6f8r+ge/ddgKOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ83E49+o0qWUnTn3elwLiZaIN17DA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22MH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgEvZp4TrXJcLkRMfkuZpqkydqXIde/xBu\nJIHNccTHE00CIBikozYexCwsIOMUtlcTbAi3qoiZEsk+Swy9l7Pn8xmD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9005", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9005` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISATTpT4BmZUOka4YoNkMsvkpvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjZTE2MTlhLTFhYTMtNDFjYi04NzI1LTM2NGIxZWI3YWJjZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjljM2Y0NzItNjA0\nNS00ZGVhLWI5YmQtMTgyNmM5MzJhZGExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZxxX2o2r5LeAFxlEa9Rk3q8sKNzbOC7ZhgmEgbKiUJMORmujS+LdeB8xaklJ\nIslxFLtEFCnHySmfApDJn//t0aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1OWTHC/Bo+EWyaNFiMNvcr7rynwwHwYDVR0j\nBBgwFoAU9waHjS5fajuXBQEX9NCbcP4GovQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC9P/Qcanuj13znMakKHX2pGIih\nTY97VRQevoFo9p9ufAIhAJB1kf6O/bw7y76WARRxxzy5PXvAuS6Ww1HbvltCWRJq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATCfS+PrILozs1lMtSPWKoZWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2UxNjE5YS0xYWEzLTQxY2ItODcyNS0zNjRiMWViN2FiY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATI+CNKMgh1lqA0CRLhpo44rDqk6khYcix2pALXrogTKbC3\nh8EYRcW/7TWfdG1ealb4zVYjqYJeC6iWzmX0PS6Bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9waHjS5fajuXBQEX9NCbcP4G\novQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALIjdygehVS47nj8l24D4TOhlEgLPMDsLRizBbFcrq/xAiBJVVCX4xem\nJZCi9Nw3kduvVfdBsz+pxjNy9Y34IBJ4QA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISASqIyvpmQrara0Ub9faijETGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjljM2Y0NzItNjA0NS00ZGVhLWI5YmQtMTgyNmM5MzJhZGExMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjNhYWE0NjgtNmU2NS00OTQzLWJjNTgtNmJhODcxNDUx\nNjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeGxa+H4yj0+G9PpFQrpB8+hO\nei2B0LLZ2pNCiVbWeQ7xNstaCCZtDq/boeE/SHaqu1Uw7Dn0Jz353Zds7nbXUKOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTU5ZMcL8Gj4RbJo0WIw29yvuvKfDA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22NH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOtbAur5We1RZaj12YTt4JgqqB0A6/po\ng1o1q8SSO5pMAiAP9tvoJH50mtkwv0wOHLAgouO11Tuvltx7W4T3QDsPrQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9006", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9006` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXRj2Iyk0twn/qi+ZHbx24ElMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwZGMyMDQ1LTlkN2MtNGQ2ZS1iOWQyLWEyMGQ3YmZlNTM0YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDFmNTBlMzItY2Fj\nOC00YThmLTgzNTEtOWQzMTQxNzYwOGJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENlkFBv2+Kip46EtZDTbO7UQdG7063Wfimq7Uit8CfpAA1L3ZfiLTuP6biSKZ\niwyfi29/dkDzGYB+/DUbA/zCkaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSZ8heOmvwgatYIY4jG2mL8B+4nxzAfBgNVHSME\nGDAWgBQcQhiwWKfJsGsbvyfJPQ8eCDuhNzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDSCqp9cgF2Z2brPqoaRiLO6UWDLkqD\nOES4fBhMaCvo7wIgfKj2DuecqTzY9oacPwGE0GyjmeeDG1Rm9KZVwKaySkg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe/oseYamf5YlUEDDaoGFiqJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGRjMjA0NS05ZDdjLTRkNmUtYjlkMi1hMjBkN2JmZTUzNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/lOkID2WiW9aSha5YN4IFxFpaHQWQ37Gcv7bKZjHX8vQE\nPE4Hib1IYvGqltXtQrbT+jN0Nzi3/Hxfmg1eHVOjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHEIYsFinybBrG78nyT0PHgg7\noTcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAqr2kIVP4YfDAP/OW6FwDcFA2WLOmKs3rbTGHWmD2/8CIDaznrenMKMk\nkSUeidE9tFYvtLsVPppJzzdWapPtJAbC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAd2gAwIBAgISAWRZwix9vvS2mhRstKdh/CDuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDFmNTBlMzItY2FjOC00YThmLTgzNTEtOWQzMTQxNzYwOGJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWFkNjU3OTYtMzUzNC00MzgyLWE3ZjEtNWIwNTE2NDY2\nNDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZmK9g2+wBih6VgxFOqyg4Q1O\nox1lgvbfb0sG+9Yh+EGEn8yo3V/u+Sk4SqWSfDoCTfDWe0h+jN3dkUsK2p7Y9KOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSZ8heOmvwgatYIY4jG2mL8B+4nxzA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22NH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgWttEuAveTvUKRTfGBxhiSDhvlBvpLTQ8\nwkX3F5ICwrkCIEXxWU6bWhPm7UrVcQ4As81m2Iw0DPeX/r2mAjJ7GI7i\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9007", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9007` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAebIKKnbzHCM5XHYHWRL0L5lMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiMTYxOTUwLTlkZTctNDcxNi1hZWVhLTZmYjc5NWU3ZGY5MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg1NWQyNmYtODZj\nOC00MjBjLTgzZDEtYzI1MTk2NTQ0Yjk5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExAc41JR0beGyoytcqe3IE1jBiQW/0fIkQC8HSt2n4Tkxgvu7cdaK5/P+5Y0N\nfxYGzKy1UajgDOnyOZ1stkLv1aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfuYx2VWZNQ0BSvaxAKwgBTj8TVAwHwYDVR0j\nBBgwFoAUNXFPWiNQmR5e/srI5d5WB50WDwkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICYwko1HM6PlT8EWbrjWthzpuSRx\njbtw+WPbGYS+M5M8AiEAj5H7nXtKlYyt2uAUOvz/KGwvit5AuKRA50rjLDtFDY4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAefoAOiD13eF0Z3bR8XX4eUkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjE2MTk1MC05ZGU3LTQ3MTYtYWVlYS02ZmI3OTVlN2RmOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrLfBcAU7SNMgo42vhUNhPLQ3vovyVePlwRUpUoRovrNQq\nHpUzKNe+mzQDeIHOzozzia+s9FKLGl3EGBaDS3J5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNXFPWiNQmR5e/srI5d5WB50W\nDwkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMTDFozyKYr5U1Y5l19pgo8qMvJk4aHmMTNG5+kA4XB7AiBfj7433qRJ\nSchGcyaeB49HOuIth1uvAQcZe3jjzJRSig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAWylc46+KWErUmdA+qZhvL11MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg1NWQyNmYtODZjOC00MjBjLTgzZDEtYzI1MTk2NTQ0Yjk5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzQ1ZTBlYjgtNzNlNi00ODAxLWEyYjgtZDYyMTBhMjFk\nYzk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5OkwjckNDzJEXCxzqf/etKfT\nBiPplaz0o9OUX85LfOtcpfYQnG/4c4r8sN6v+lxbWhhKtWz+FtNMuprdItkVKaOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR+5jHZVZk1DQFK9rEArCAFOPxNUDA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22OH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgTjfJzh3v44/ZSe/FgfhwMmSBS+NiWxDL\nDE9yGSjGevgCIQD12Zg75RCDxPuEQrcJpJqgyDD67wtLa79HyOEPM7e5xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9008", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9008` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAU6kDFSmVYr0EviXJmwg5r0wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxYzc1ODc2LWRlOTQtNGJmZC05MGVjLTk2YzUwNTNjYjRjNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmM5NjFjM2ItMTU5\nZi00MTBiLWI0YzAtMTczYmNlMTEwZTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkQIwC5WXMR9ywz9GH3Z2NWHHYkClGSb9v3qKQe0jJHLfnN98lhWH7fxXcYBS\nPzScxwdYXU5C53Yrtb2msKH1ZqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBST2L+Vop6BqNGLA4b+IP30mgsxGjAfBgNVHSME\nGDAWgBRnsH9bof5LZC20VFoG8pnIo+yJzjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCZT8TJR2SvM+VUSGTTG0wRNySILFCb\nro8Y4EWo8lJpNwIge0ehNlUXVGvKYxpAw9JO9YAv5pXv6W2eOZH2n+gpKA0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARn/vSsj7LqXxNFq8Kg7dX2fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMWM3NTg3Ni1kZTk0LTRiZmQtOTBlYy05NmM1MDUzY2I0YzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNH0XKOuQNa++TNTNchy4AuCER0D7J0v436yYEThseIICz\nXwh5mq6zaj7XHpgy9bzoL2YVEG1qA2JxSVPJJmSWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ7B/W6H+S2QttFRaBvKZyKPs\nic4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ7fT1Ff8l33WdP2e20crsV9sfvUiqZmrod85Ds24o1vAiEAzQBlDqO2\n5LT0/rAUXqoeUivOgyc9El0r+3Bby8vB0io=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICODCCAd2gAwIBAgISAUiYcJ7bbTvxXW09y8HcpbjVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmM5NjFjM2ItMTU5Zi00MTBiLWI0YzAtMTczYmNlMTEwZTMyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmZmZWRlYjUtZWYwMy00ZDgyLWIzMzktYjA5ZTE2NmI5\nYTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESyQ6llNSHD3GcdQthJv/4ZSk\nrEEmx/KsBk+hQ6f1hKGfJ7SwPCM019SVsqZO1MihuwpyzkpCznAgVuMYzmEEtaOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBST2L+Vop6BqNGLA4b+IP30mgsxGjA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22OH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIb1l+4B9bIZ3NmWCkjBEhKmJTM17HSO\nJN353K2HzNHDAiEAy5CuF2iFIdqbqKgIMQ/VyFATfpmTcH9rUvFH1wNOsvk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9009", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9009` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAURTP9kvnqGtTdlajFNs4CPfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA4ZWIyMTc0LTUxZWQtNDk1Ni05YTExLTY0NjkyNGQ4ZjlkYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBmNWRjNWItMjM3\nYS00NThhLTk1ZmYtODIwNzgwNTU1MTA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA9W0UwVu0mnKt7xVenXd75xKLZ2WO98QFSUhYKovMTlwk8353aIKm5+Vg0pX\n7HDpSMMuTUEtau4QIWFenwYrQKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAAHOQkVKPgDe2SmN7YDbi6FUBaAwHwYDVR0j\nBBgwFoAUzmYWkoS1NXottYhE+BsWTng7vOYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGBx+A6u8oy7ilPyC2u6YqPTAx2E\nn9yfPL1rqARWCv+1AiEA1le+C23e9O2syDhe+GmVAuTObukSYJG4Xo+8Xdl79/Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcgazu5lZHn/PfeAhWSDfOcbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nOGViMjE3NC01MWVkLTQ5NTYtOWExMS02NDY5MjRkOGY5ZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXZS6R9CApP3qlDFgKMyn5zWywqSdvxMFcKE96kxnPTjIo\nVB0Sr0UnTywlWI+K8D+zEJ8bpQ9CbQMSY7D9F4cNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzmYWkoS1NXottYhE+BsWTng7\nvOYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKO+sIa9DVn5k5dnQlHKJ//kYSlZxeh0HEKKQ9k+yAeoAiEAhqvwufqc\nYNNrkiJ4cpv9snYBV3+FtHKV3HeuVPvNRyM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAd2gAwIBAgISAWYSabvpazVmigc5V5sXBEDrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBmNWRjNWItMjM3YS00NThhLTk1ZmYtODIwNzgwNTU1MTA0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjhlZjUwZWMtMTE1Yy00MWQ2LWI5YzUtNWZlM2JhOGI0\nZWIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJC31X9GZaQyj2kOEKo6T12gD\nNQu2by1bO1pdMKPMRQCsfNnkedHEEnEgRzRrrB7M1TzqNaFDESspGnkQHADv3qOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQAAc5CRUo+AN7ZKY3tgNuLoVQFoDA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22PH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAO024A1UG1n0OJ/XZ0u1Uk4O0ThWaCll\nxLCaj9UMVOjzAiAv1OrGJA+1Y7x5IVFSnVUZCVd9BrGSI+wFEsDqbRaw6g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9010", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9010` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbS7aMEvuEuUCbY3dvhTUGJbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1OGNmMjM3LWQ1YmUtNDgyYy05NTBkLTEyYTVjNDRiZjNlNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2Y0OGYwYmYtOWM4\nNi00MGVkLWJkYWYtYjZhNTIyNmYwZjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWOeVkxqhLu/wdZdC4eGKpRMzhgqxAbRK/6AEuKTmdG04nJ/ANGauIW4p2I/k\njDn85au4yoJ3oJjW1dA0lieCb6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR0TeNMari/ax7IP+axR5ZV42+OzzAfBgNVHSME\nGDAWgBSgYg6gK5Uscyag/Me0JAN8kam8qTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHAqTZvDWDoLisaY6QSnc/hLQVydZrLE\nJrh7AubqgDUpAiEAut//JpoAR0XZ2+7n/qPMPjPO6pDguCHiyORsHgZXpe0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfy8fkf+PiKYha1h+CWUnGlwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNThjZjIzNy1kNWJlLTQ4MmMtOTUwZC0xMmE1YzQ0YmYzZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASRbVKp4YycAMtF4vjq6XyO6AQVNkCNFcgze5hzk6x7XQET\n+cX1xpYXywh9paFDrTUQxE6LlCZ0hLWNOvA0o8ZSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoGIOoCuVLHMmoPzHtCQDfJGp\nvKkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTjAwBPdT/UHob2cMc22XzwH/M8ieEdSDiFM+z901Jo8CIBFgDRpQzp7Y\nU2jXFq3d4hLAlEr+8y/1r+9SoPaDKXgv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAd2gAwIBAgISAbvDZM+k+31UZt6350Pn2poLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2Y0OGYwYmYtOWM4Ni00MGVkLWJkYWYtYjZhNTIyNmYwZjkyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjViYjZkYzItMWVhYS00YTYzLTk3OTUtNTllNGZmZGQ4\nZDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvDlGH3APHp9f9Q5dvb8Dyqrc\nmqTvkloI/CZRRYccwxNeDS2xrIfpq/9Cdr9l+G82M3Md3rG172Od6lqa7EkGgKOB\nlDCBkTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR0TeNMari/ax7IP+axR5ZV42+OzzA7BgNVHREE\nNDAygg9iYWQuZXhhbXBsZS5jb22PH2JhZC5leGFtcGxlLmNvbSwgdGVzdC5sb2Nh\nbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgPIHGUJO+IAzNl1TRLX6ScefAOm8qOCeY\nqU0fK6wS6uwCIH2yyDTYGuG6xIIx3yOogHVtverkQ2n32MU0F3UAe0bJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9011", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9011` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAQ4SjDk4Ewo4U35PNVvdujfpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmYmE0M2U3LWNiZGYtNDVkNi1iZWEzLTQ3ZTY3MWQ1YTU2NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2RiNjBhMTctZmQ4\nOS00NjdiLTk0YWUtNjAyYTllM2NhY2IyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYAKMw7h0CuMZ6Nrzk61FGssapxOYfk3jeVPnjM/4n6HhJIchvrJl2ZCbbE85\nY0ienosdXhH6UNJTzf8wkeO5oKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5+xqQflI9sd3v1wT4PfKvWL0F/YwHwYDVR0j\nBBgwFoAUPtZOLANn4LYSccNuDglYSmxEYvQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBQM2bByWb1Rh9As3i/6LT91PvbC\n81exCfpH+cGKbVOMAiAMDsmzeCJ0i5xexBgkH1MIdb+Zg+6le0s0VRKU0+4ckw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAR1TH1DmS+ugeQD59/YvoNfxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZmJhNDNlNy1jYmRmLTQ1ZDYtYmVhMy00N2U2NzFkNWE1NjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAUEKjdn45S5Cge/gdhljX1hzNHG1NkOv3ftYv5TxHsOP2\nrSY+EujpiQJ0LMshemEIm9ZFTjOeJ9XHdAUuPv0ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPtZOLANn4LYSccNuDglYSmxE\nYvQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANnWG2SuKc8uKXP56Im5nOk/RWeBWFbdcPB1HLteyg2ZAiEA863SW+s0\ntfD/HlH1B9weorAuo/viEaILM73E4tUlDaQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAWfT4skDkZi1bjT8CUdj7RgqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2RiNjBhMTctZmQ4OS00NjdiLTk0YWUtNjAyYTllM2NhY2IyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWFmZTY2NDctMDAxMC00ODIzLWI2NzUtNDU0ODY3Yjhj\nNGQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfDBnBfZ4o7b9IRt96NUi2BGj\nc7YoQUX6ZS0WbUQj9iAXJDwiKGfVIq0AKMwSqzJQ5Dp+txxVeqpvTiPVliXQ46OB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTn7GpB+Uj2x3e/XBPg98q9YvQX9jBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22AJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC9Ybr+E2PViEOsGxKq3FFA\nv71ly9NRRgVsz3+m/uoVFwIgdsRmdeLHzFov5uI6HPC5Rr/UNfYm23XQVjyD7F5A\nkFI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9012", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9012` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAaApNBafuqFUF5TwCnEcV7jwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMGJmZTU5LWM2MWItNDMwMC1hZDc0LWU5MTU2NDExMDgyYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGYyMjM5YjgtOGRm\nNC00MWY4LTljMjUtMDUxZGIyNWNlM2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElf6NibxpJtQa+A4u/r/56zCw1rUuViG0LyuQNcZC5Q1G5waPjEszYXPFmhaT\nAJdTBqDyjDhkX/u8/SOkjn4VT6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSs+nUhS+GAndgGJWz8BDwn89dsnjAfBgNVHSME\nGDAWgBTeKgRdWi5vRYSaUmAihXLdHD9KkDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDsf18vl6bof8blPy8NuT4tqTWlvF2h\nW5HS82nySPwZHwIgdanpIlkLKrvgxa68oiV5IuvL1YMENJBhes4T0U7Cr5s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbTKMcGFTY5QA3qWZo6/1oSPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjBiZmU1OS1jNjFiLTQzMDAtYWQ3NC1lOTE1NjQxMTA4MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSulYFfkAvnt8dZ6nW0khd6j5awHLb/owFQgkWRDDSm/10\nx53nN/9yu1049JGRfB6NSmUKWbApYNZVJYJDlbBuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3ioEXVoub0WEmlJgIoVy3Rw/\nSpAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANjirH8I/8x5I2DdRVq1lkl9zJSv8MM3tWhtbUr2mC40AiEA+S3Pb1Vn\nt9H0aciMIc0eIPRFCGnj14aVxMjJkZAypO4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISAVN95V0s9g59p90sfKtIT77PMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGYyMjM5YjgtOGRmNC00MWY4LTljMjUtMDUxZGIyNWNlM2QyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODY1MWI3MDYtZWM2NS00YmQxLTkxYzgtMzQxNWZhODRh\nOGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQlSrCbpzOq73+vdCBSqKSfnc\nfHXwv+LXMZVueytqwPwb/JLvQ2aHqlNAPlCCx+irTPOKHVTTL9VZoGRoxOVgZKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSs+nUhS+GAndgGJWz8BDwn89dsnjBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22AJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDiZ6esBCdwQyPapYtX+2j6\n/hfCcTMdZ05IO6v7ebk7HwIhAOuGRBqdAU6c6rO0lRDxfVOPamVHFAFYzQziD3aQ\neZYF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9013", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9013` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAQdf2Tv0rjUFd02iNSYUSB+uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlZGEyMThkLWUyNWEtNDdhMS1iZTg5LWQ5NDI4YWIxYzk5ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdlZTcyMjMtOThi\nNS00MDk3LWFhYTUtY2YyZDhkZGQ2MzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3pGx46fDBOke9LIU/nSwdb4pHpJeyCLUPWUlFkV63d0+gEw0XR3tD+tiKKkW\nqMN3G/h1P0UXz4/fXoKzUTr/2aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkB+TWKjfFmXPsRaIHbYyoL7QJNMwHwYDVR0j\nBBgwFoAUnF7jI6rNyHrEYZjabV6yGNvYgwUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAUpxJzPUv0cU9Qpd/ruUcICZGAC\nA0gnLeKdv8kaiFtzAiBZvw+dIod4KBT+xAFVtXeoJqbj+FBdSE7jKJIdeQ7akQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVr27zw+ZlqCf8ysv0gjJ4M+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZWRhMjE4ZC1lMjVhLTQ3YTEtYmU4OS1kOTQyOGFiMWM5OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdftNnAQB6yvMt6lvXtmkBs1s9Q9k+haBpDtRSbDo8DWNI\neKSbZ1SzRWiPYK4CvV3Otvri8rnJh+LYl0P1T8vKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnF7jI6rNyHrEYZjabV6yGNvY\ngwUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALjPr8u6tdW4bxxDUTyrVqr4aOWgD9kT5cKqBd4r5v6HAiAmJNG1itXe\nlvmKdVDzzJ9SXOiq4oIuyrPSn41yqtYv7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISARctjyI31uibRBJPVtBwk1FMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdlZTcyMjMtOThiNS00MDk3LWFhYTUtY2YyZDhkZGQ2MzBmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmM5OTNjYTUtZDdjNC00ZGI4LWJhMjctYjhmZWRlZTlm\nMTdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqRHqxJiW7G979Kt8mu9KynO7\nGsgI0UJWonxiFc1V3TqXG5/2taGprVCT6w9OCbUL7EMlmoyAeobJyr8QhQeqoaOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSQH5NYqN8WZc+xFogdtjKgvtAk0zBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22BJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCXmCrgmsku28dqIXAOHKoG\nXGnQa1I2QQtxDiuszwsODgIhAPf9oIocHb4FN6QnSOWB2KUOhnxZKswHUpIHEPkR\nYsvo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9014", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9014` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAd1CNWsTXjUHD1oUDqyHAi2BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlOGNjYWExLTk4ZDMtNGM5Ny1iYmIyLTI4Y2EzNDJlZWViYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWI1NDdmOWYtYWQx\nNC00MTlkLWE5NjQtMjVlYjkxYmIwOGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXHl61gmVuuux0CK0vFLx5gE9IdwtixEJuKV2vvQmFCAdwQBvXd5fiYIThfgB\n6uGali9RRISA6+hsE0Y6c0PLFaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQaCKyj3KTHaZBccEfd9BJr9i1HBjAfBgNVHSME\nGDAWgBQJxF6SsVjdCkNt1K4x5yHOZ0OSGDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQClnDL05ReB5IzRdAySLlNUmE934Vb8\nXj2EPOg0Kdv4zwIgHw+R6JhY18nHovZ7cRLLIHPJYNDt7ntuyRjNmXScpDk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYDWHDsQaejqoI900xkjJGGFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZThjY2FhMS05OGQzLTRjOTctYmJiMi0yOGNhMzQyZWVlYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR0AbKpZfqhK9YErnrpvPZPthebPPpiCjvrClDnsy0/En1\nt36CtfwDFUWNqnDewrv2CqNpn+RgzNkXHnNawI4+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCcRekrFY3QpDbdSuMechzmdD\nkhgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNBPkD8f1LNzfEam+IkZxkZROACQxYFcvIa2JZqmE4IkCIHuX2TS/o3P9\nI5sDkccsigQD6FZuft3eMtBVAGueChwf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISASHT3Tc5SITBfWqpPmTqKMuCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWI1NDdmOWYtYWQxNC00MTlkLWE5NjQtMjVlYjkxYmIwOGIxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTUyNmI0NzYtNDg4ZS00ZGZlLTk3ODMtMDRmMzkzN2Qy\nOTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZsME/7RI8Ayc8+cjlupwBmoM\nD23SPgo7kVKTqzRBGNrNTZ1CgJChblykJguXhVI2ymeDqOOFQ+via27FgeMfeKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQaCKyj3KTHaZBccEfd9BJr9i1HBjBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22BJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCXY8hMCoWhPUMlg9ZUu9HL\nsW/8Rn9blm9o9SM8B0Y/ugIhAO/d4sVI/O9PyXGZANPSnjt0amXijqNyXIyzimqr\nkvSU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9015", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9015` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAWf/mt41u+qC58yWa0JY0E48MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1M2IxZTdjLWZiMDQtNGY0My1iYjI5LWQ0MThmZGY1NmZkZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ3MDU2M2EtMWE0\nYy00ZmI1LWFkYzAtNjYwMzBhNjQwZjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQfhzVVQW9RGH9rx1iwKeZ5OLpzppCaMW8ITHswcW+bhI8PSONUs+h5Un5Ob/\nRXU2u6Ygh8T6B40OCVKcQG2VcaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNRZtXYe6UN1KTn4f5phQnbLwUOYwHwYDVR0j\nBBgwFoAU/ieRO9Bb/jj6oIwLbtIIMqjw/CcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEIEXxaGT6Iqh+KTFinNxrMbdVOG\nzy1udrNjr8GFHkxfAiBIbbXz9XcuWY+iidgffWvhAaFI+tmWegcrTJ2tr1sv4g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZHPE0KOc72KwB8ox8LSZD4xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTNiMWU3Yy1mYjA0LTRmNDMtYmIyOS1kNDE4ZmRmNTZmZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8sJdsnEjmSDmX7Uw/xqStPpgjV6F2v6c+qRHBqDVpIPGw\noBf7iqhH+3F74ozatBYQFYEeGqcqh1kaXIo5ErbXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/ieRO9Bb/jj6oIwLbtIIMqjw\n/CcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALGy0LDNKQTDUTFusQ6NlJdFhqmo7+zkkWHGVM9wYAaKAiEA6JVB37er\nqKgc9GHhUd18P4X/F/ozYd+XSM51KGVciFg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAfYTp85e0o94MOojqFM/oOX1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ3MDU2M2EtMWE0Yy00ZmI1LWFkYzAtNjYwMzBhNjQwZjRjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzRkMGFhODctMmI4MC00NWExLWJmZjQtZTE2MmExYzM1\nYTcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9ZLrZnGzf1BLRcxiWvw1xkIB\nUx1EWcPRXTwqzEvcxfonQ+TS/pJRp6mVb0c1LENizEjwQEiYKKn3wBu52JPiqaOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ1Fm1dh7pQ3UpOfh/mmFCdsvBQ5jBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22CJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAPmxJmslEeCu5zDreGd5+wI\nHtiz2rkPJQ28CzMawtENAiEA80uG0OLULyHZr6YkkxgbvqDf/wq4a7cJ+RMt9XWa\nOmA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9016", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9016` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQAaIV5xAG8hrTT4bL3sR1GJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzNTU4MTgwLTM2M2EtNDVhNC1iNjVhLTZlZDllZTRlYmE5OTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU4OWJmZGEtYjJl\nYi00MTkwLWFlOWEtY2RhNzQ3Y2U1MTQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAET93B+TvhfIgdKLWOBLYaMlWkbOZ08lO+m9twH5MYJtleujMbUJLqjFT+/Fte\n7deLUdffydlSS5sgSfGrLfvAf6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRQu1eD1WjJPTa7ZHXrqDyKw7/oJzAfBgNVHSME\nGDAWgBQvw2yjX1sx9qJgR72rHfobK/GA7zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCvecP0v7nqumF+1pRwkrSd8NGURTEZ\nu3ttz5bSq/R0SwIgJqy9UPZ1Q7UE2qdZMpsCbZUuKfBb4K46pIJKwUrVBDQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAU3ohiwO8ZiXVKf/uGMlN8hdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzU1ODE4MC0zNjNhLTQ1YTQtYjY1YS02ZWQ5ZWU0ZWJhOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQo5r1JWvTtRZdQzxVZ4hcEXOdw2dq3NQhHR+UQlyBHY3U3\nOKGxteVaRyQJ9nYQy9NoDIia5BA9aClhWDo3j8Cjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL8Nso19bMfaiYEe9qx36Gyvx\ngO8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ5gGE6CQ2JwZC2Gsv8mP0OO4jBMyO1ihlqii1MS1+/JAiEA81pq5fyK\nTMpR/JVSsNMeCnwl003YhqmgHOztUCgCDc4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAcAJnRTgrWSfiFL73q0K+PjIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU4OWJmZGEtYjJlYi00MTkwLWFlOWEtY2RhNzQ3Y2U1MTQyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMThjNDk4NzEtMDk2NC00OGM1LTkwOTMtNTJkODMyZjc3\nYTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn+4Ocgq5VFGm0IwSSEAwDLiJ\n+WTv6hGxs/NLfJE9mV5vgD+r/VfzM7u7EzsPPJ0mc9qHochUM8zFo6UcDCsXEqOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRQu1eD1WjJPTa7ZHXrqDyKw7/oJzBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22CJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDyTcVgIT9R+stIARoQ4vro\nrXrnE5MMQrnRK8M6C0i7ggIgIT07MLi2uPSL9/TEbNNnlCKzVdGi8bFsJwCfZ5vn\nCo8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9017", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9017` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAaUyk4Rv5FelPl1qhNdJsOPNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkZGIxNTBkLTFhY2EtNDczMC04NDNlLTI2N2UwNjRhZGY5YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGFhNmY2YjctNTA4\nNS00MWQxLWI4NDMtZDdiYTgwY2E1MTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp5krYPPYG2psYW0IL13aqHkLk9Pso7SKs5RHDGlV34/J4VFBFjayJMrVarw6\n/9rQsB/lCkVaFtoT0Elr8LcInaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjuSlerdv4R8ruWTiUgyGUhyOTvMwHwYDVR0j\nBBgwFoAU8UyaoAdQ69pqzZ6/QRs71gfuxrMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD9e4tQ2SxzkBKeinoUkT/TzQiv\nzTnNfkW3ZuUHam3HrQIgWm8YQkKT7PuBfMYAJrIKkPQsSbMHyF43LxTTSvYAg0g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdKAFk4pXywBGmKXtQU+QmSzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGRiMTUwZC0xYWNhLTQ3MzAtODQzZS0yNjdlMDY0YWRmOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPP0ZRrW4dMrRhXpzLp2dSvW74Wophd+ZiUuj+Fgd7CdwO\nBWbKJiREq8BL2lUnHooU4j6nO5UfyjwIiV9SLdqXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8UyaoAdQ69pqzZ6/QRs71gfu\nxrMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdrErHEd8ZemcMYRfrDkS//OlSNU1j9DQrCbAevIgsY8CIBtLSgmFfzAr\nuXdfWyl9hEPP5cddEzrQ03bun49vVe4z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISAewUCRFv1rZ+mDMUzigayzxZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGFhNmY2YjctNTA4NS00MWQxLWI4NDMtZDdiYTgwY2E1MTlhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk4ODA4MDQtZDMxNS00ZjFhLWI0MzYtMDVmYmQ0YzNh\nZThjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER9OUvoVH0dNJ/NUtnAkTizXY\nnI9NFWdjOK16CXxkvb6i5W9kq1PrbYr/AexChUKq1WvYmwtCTxa1V1w3eoQVjKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSO5KV6t2/hHyu5ZOJSDIZSHI5O8zBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22DJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDKKfK9L/mBHyXScJvjzsRc\nJzTYB7sle/6Pm7JTSzRYxgIhAI42bqwuQWDuGXIH6fMPBbYE0A7/+Q5tDzsDnLbl\nBE/g\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9018", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9018` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISARfkKRHrRukfN1lmMjicGEK0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0YmE0NjBlLTI5YzItNGE1MS1hN2Y3LTNmZWM4YmQzNTFmZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjQzYTk0YmMtYWIw\nYy00YWZhLWIwYTAtN2QwOTc5NWZkZTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHpGTQKEBlG+D4VOvDs+M+ypZLGsNj+qfMUKdOgBtSe0xBTGlyR1wz9jj0Nij\nAI/4FfZ7XSMhjEnfY1Vv99UhC6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSR5rghG1VRo3bIIopWwKaD4AhNbzAfBgNVHSME\nGDAWgBSVGe6FprvjiKYUkzCteseZq4d5/zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDsx77tuN8GYXjG74glqzBop2EqQ7Bjt\n4bOJ/RhJKOhCAiBQx5/AtLqlpeV8z+K+sbT+Xkiyk7W3ArGyfvDA3Zl+iQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeHBliakHfkk9BeDa+vR+SWYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGJhNDYwZS0yOWMyLTRhNTEtYTdmNy0zZmVjOGJkMzUxZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWHundxhzAYi96H7C4jhDHJhrk9vuSg6KX7cBJnl9t92AY\n3ctLd0YNvzOWzgnbFd4TEA7KJKpdIpJ+ptDE/c3ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlRnuhaa744imFJMwrXrHmauH\nef8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMRGSlWxdzBw8avZjXz82wk2HqF/OOfNOTILIWGWwt5ACIQDkX3ePpBNb\nSqOrHsLNNo2Tg/alE3cdwvq75OnBBOF9xg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAVuIUYix7jqrKmOUsc08G7uUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjQzYTk0YmMtYWIwYy00YWZhLWIwYTAtN2QwOTc5NWZkZTQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDI1ZTg0ZDUtOWJlZS00YzEyLWEyMTktYTc2NmUyZDgw\nZTY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMNwgwrkzDfrvAmc4eUR3yGiQ\nJ8JRDz3BMZySmWgDE6e3rxAQVncH4045Glj4pJrYfD5w7xYBIrPs2ykbLfCQdKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSR5rghG1VRo3bIIopWwKaD4AhNbzBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22DJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCQ9MgAMGoOdqL7AhwCB6VO\nN4w0mx/JZN5TvPFX0GODDQIgMIZghx3ppe+ch2lgh+J8JPGUZPfXQzz1Qy19cD94\n0KM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9019", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9019` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISASFyt6fe1gdzjXVewhN+BLfFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ZWYyNGYwLTE5NTQtNDYwMi04OTQ0LTY2NWIyNGRmOWQ0ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU5YzhmYTktM2Ix\nZC00ODZkLWI4MGEtZDZmNGZiODNiNzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdpjxVIEMMlz2mIV892ym82yoBkBM18UHLH3/c5qxHnuNVp0ZgQRxhyNuL6Iz\nMmrqR1Lj86dH7mj93tQID5wrYqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpnDUbtP/laUYHaR6L9hfxam6PpMwHwYDVR0j\nBBgwFoAUh8fEuQBPRGqSUraFIGA2X3MT+uIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCOlfQmSQQFb28txE390NwE36Fg\nqOLCnZ2gJKuR9lxbBQIhAO9HqiLP3fkAjTvQPgkDsCIizJID71gFvdDzWxvE/NEY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWgHkRUKtSe5T37N+seyZ8+nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGVmMjRmMC0xOTU0LTQ2MDItODk0NC02NjViMjRkZjlkNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZSGrvor3I6ps6l2HplSacMYQnl/04TCB+4znV+TDyuXvf\nrqDuLSil4j8x6Knp1snAJmoWleJ+OQhBV2CuVS3jo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh8fEuQBPRGqSUraFIGA2X3MT\n+uIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOokziFW3A1bUBdh6/OYlzd80izc9n/mV2W7NxDXgkJ/AiBSEwEr8RSC\naQJzt+oniS9q6nzGQiBJl/nswkfPARXhZQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAbR2XEqaAPPCCOnHchnEJZUcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU5YzhmYTktM2IxZC00ODZkLWI4MGEtZDZmNGZiODNiNzM3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjZiZTRjMTktNGYyNi00YTBlLTgwZjEtMDYzNDRhMjcx\nM2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERk8fniruUufPW56Iw0lrIP97\nftBKx1DHgvlMFOn4xYO/utg4FLFfcBXrcjkA/5ei//qsFLuH+MBEVuZhixfEoaOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSmcNRu0/+VpRgdpHov2F/Fqbo+kzBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22EJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCQw3hfo8TDpnHsPkumTgnJ\nVJq5ejiWmutF9007RoP/AgIgVD+9CR4j/JJVw7NCreslSJpCUQsSKg/VQRuW3bKK\nYYs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9020", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9020` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISATj/eE4iCPAzjfmAPt4RiD8YMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmNzFmYTQ4LTIxZDUtNGU4ZS04YTdkLWJkZmE4OTQ5YTg2YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGYxOGQ0YTMtMjcw\nOS00NDk3LThiZmEtZDA3MDcyZjI4ZGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYmd9w7We2DXX1ZQsNfufHTqJcfUpnuVDwDqFGrbSnFg7dx3GUH2jlVgx3lRr\nGRCJ+B4sAdxFrSdCO4C8OR7cuKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQeK6WheokSMqi4OmErKr6DJHx2jDAfBgNVHSME\nGDAWgBRofvda1+Un7XF4H/J5aOkYxvCSAzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDkwDGfHVqICT9rULnqErSOLPJbMoYf\npBpocOCw3QcwAAIhAKWO6+1y90TFs3k2gyvGKzjPGZJzgb5WyR/NBGgmcI2I\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVZa3B+6ucGdb5qott2sQmYIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjcxZmE0OC0yMWQ1LTRlOGUtOGE3ZC1iZGZhODk0OWE4NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATsLCa/dPPU5lGPzzr5zxwApe81u1E+158OaKZuFPCWeSL/\n0wOPNX+W616SKhPOSQFgFIyxj/Fsqlm/zrV15ZBOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaH73WtflJ+1xeB/yeWjpGMbw\nkgMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJBwsf4yVkZCRVou5peJJMIspzBuJd4kDfQbctvgDIdPAiAkZZZaSMnF\nNyr9v1ubNzlVuZFppB17CpKqsHIbPAghUw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAe2RSJtYl38LiiC1LteLuLmpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGYxOGQ0YTMtMjcwOS00NDk3LThiZmEtZDA3MDcyZjI4ZGM5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTk5ZDZmYTItNTQyNy00NWJiLThmNjQtN2YzYWFiNGJh\nMTM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcI5ZhbavMMlL2UdKD4xuoZKJ\nMqKl6i481gfuVwiWKrcQJ5ULKNdgRRxdd7yG281uRdVFVK89F4oXikiYecNuEqOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQeK6WheokSMqi4OmErKr6DJHx2jDBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22EJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCGypmVKNdfKMQ+LSpdvWmB\nYEuy3lkTkcY13ov2LAqlGwIgKpS3MSet6u2Hn/o80ZLxwEQZeogFP+sSkjKJq0NT\n49g=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9021", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9021` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAZ4e5rfIWuEVMj2wk5nrRdj0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkNTQzNTUzLTVjMzctNGU0Ni05ZDE2LTJkMTk4YWZlYjAyODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjg5NjQwOTgtYWYz\nOS00NmYzLTkzNDItMmVlYjkxZWM1Y2UwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8rZ4nADkv6wySf/2/Mcpy67bENEWqe+16Y1G8AFzj2uPeXutvVDATsQczcGN\ncoNHgR62kBN7UQqNb8UIlEsyCqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIR7my5djkjiKOop0PXhiLPo7nx8wHwYDVR0j\nBBgwFoAUdKLdp0ftAqrUkHem88tio/SrodUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHrUpOH7aPW31nythd5YRAcN9TMO\nQJoWuxHeokRWEqeIAiBeXWMoefPTgIHFqPsWQfbqSTc6J3BOz8aeRe/lZ1+oDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZMqYa7OcwhRSsoB3aChSneLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDU0MzU1My01YzM3LTRlNDYtOWQxNi0yZDE5OGFmZWIwMjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOPCXrZMpNjODoKVfAXN9fj/KRYXb63KeTxJcfygqPXVdu\njxLddHYdHD2XI+PAqkiK+L60HYLzW6Aq7ABW2I1Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdKLdp0ftAqrUkHem88tio/Sr\nodUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALXRzu0pZlgnQGS9ZjN5JtUP0JihQ7sd+QVPlz7aTqyQAiA5Xubgkq6Z\nqR9KygIl/GhXKiDYYFBIjboGObeHAy/HKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeSgAwIBAgISAU3h5KtVJEib5+BxSlxMnBSFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjg5NjQwOTgtYWYzOS00NmYzLTkzNDItMmVlYjkxZWM1Y2UwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTlkZmU3MzUtZTBiNy00ZDU2LThiNWQtMTZmMGM1MDAw\nNDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0WgErKa0VMTgAudzfaKU2LRW\nTt9Fy2DvAxXQs/SqBDhA4golTG5uyqxLY1ezavDdRlLJnnkgUm7v7UZCZQhJlaOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQhHubLl2OSOIo6inQ9eGIs+jufHzBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22FJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEJvNskQirHzbhfYvNIgA4kM\niNhk8axLh+WmUqleYWRaAiAJNsTuDdkCJ3dUnJcC4Jtv6qe09Upy+XsIiN3GiU/a\nNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9022", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9022` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAVs/H+MeVp7XjRLqG09oKEfkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyOGY4NjZmLWRmMjYtNGU0NS1hMTJhLTk2NjkwNWIwMzU3YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE5NGE4NWQtNzg5\nZC00ODQwLThmZTQtZDA4N2IyODczNzEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcvSjYYlSJPDSW0yvymbOgdU3RseoqX9KXxoAf6B+yBNOpA/TlSubl2l24nqc\nf5NfjTYE6fMxZ9HRXMb3uBfjUqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS6V2yr59gOL95AM8haXMBHEIgzEzAfBgNVHSME\nGDAWgBQvDtbjCocrpnHZM6D1Bn+5Q9WkvDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGk3cACHqqK2OxbYVbMnQ8mrk8AzcgbF\nj+vPPjbYtwDsAiB7qJtFSjGG9jHNWG6GlIIFE5UjftLnzLRy+jC3hmSz0g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaO6NhF94kAgJteH/TigC7IdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjhmODY2Zi1kZjI2LTRlNDUtYTEyYS05NjY5MDViMDM1N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmPtOppupCho4iEj6vHmNvlhLswuh+NoOaRo/bEj+NpTPw\nl+38Zs/c2e/1U4JNlhtAe0ft9yI4zai6tx3to64io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULw7W4wqHK6Zx2TOg9QZ/uUPV\npLwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIVfXBScWKEXV85nrFB6HqEBw0vwUQAHQRotZp/NKAWcCIC/GVXwWphzN\nmQXgX8312/s/NUqNqmljFG9ufF8Fg/EQ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAYmxWpOQRLW3EddXJL1C7f7YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE5NGE4NWQtNzg5ZC00ODQwLThmZTQtZDA4N2IyODczNzEzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGQ3NjI2ZTAtNmViNS00YjU1LWE4ODUtNjMxYzAyMjMw\nZDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE246VIr3uI9QvUoGAYuJQiTbJ\n/HHCssE+egjKhbpB+ekhwhFxgh2Zofu6KUvvDtIuWh4UMYhd6okjKkwyT987yKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS6V2yr59gOL95AM8haXMBHEIgzEzBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22FJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDdKUB0F5maZLk2YSOLmulU\nafcTqLGdISkjBvzs2wQxKgIgIoD8ykImZE6k9LuCEJv4DcPo6pWVk9WELNwjQmJk\nF4A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9023", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9023` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAc6vq+PabDur0mX0i4XUz3C8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFlOWQ4MjUxLTY0MjctNDIxNi05OTY4LTk2NzBiMDk5ZmIwZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDlmNjRiOWUtZGM2\nMi00ZmI5LTk0ZGYtMzA1YmNkZTdkNGMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZFPfbMfTXlE3sgdUtB1JtMJlBexWOom+o7d+aip2bE7smBvXxsreIXIm0ujj\n/kAy+mKd89EWG3aGoDkz7okG76OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFAR4+03biw+UQLNJfPN9p/wXIDIwHwYDVR0j\nBBgwFoAUXlps7NiAB6nSrBwhf7LuNraM8xAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCt5VBLl8zIXc3Nwg1SeCE2YR3E\np/g6YJo1zfSVxdzhXAIgFFNvITHj2PC4l23A3JagR7u3XOCS2AvAkKMGXdpinig=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbKynHEzeRJ0+MzTUNh3yY1uMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZTlkODI1MS02NDI3LTQyMTYtOTk2OC05NjcwYjA5OWZiMGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS0ap2jN5vOTmVFsuLH/9iy53dCQxQiBSSm5Ibu2FmB2rcy\nIsbH99w9x/4sErgdHwFNcMXxZyv/b6xK1oqTmuTxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXlps7NiAB6nSrBwhf7LuNraM\n8xAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIge2UEOC5PPEgsdqZNwadtQse04NRpSHau+4KiqORub08CIGvDtbhfQsGD\nB+bmgPuq65tRn8cEkXTyp6MvJ1/Il9aR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeSgAwIBAgISAZvmSWfx0GTaMzngp1AxeRVPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDlmNjRiOWUtZGM2Mi00ZmI5LTk0ZGYtMzA1YmNkZTdkNGMzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmU0MTM4NmQtMjFhYy00NGU0LTkxYTYtOTc1YWIxMmZh\nNDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDV27+CryFiAmhy4NGNw8tGxe\nEUhyjbRNucQnVDqoufMn08b5QYBTBLHmDcJ5VFvhK55ajjETlK9QSwvoseKesKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQUBHj7TduLD5RAs0l8832n/BcgMjBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22GJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAG3ZLe6ulY5ARtBSZfEqeqE\n7LcNJLl27UUrcUuTFgGQAiBhWWuK+Uq7F7UbVnH094gnuo2I5IocXU5+ZUk4rQZq\ndw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9024", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9024` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASurIWCkmFzBOqup6DLdcFYKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMTc3OTM4LWUwMzktNDQ5YS1iNjBiLWRkOTkyZDA2YzBkZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDVkZDllYWItZDY2\nMC00YTA3LWI3YmUtY2VmN2RiZDMwMDhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELyxq2EsBuYi3hb2K796MrfXlhBYb7LFW69EpD6w+fUll6vdio7h9GB1Blg3G\nXJIOpPawfrF7Yq6kYZ0+S+gzwqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQAok9UArwh6RtVPj+FajrirOLTtTAfBgNVHSME\nGDAWgBTxCue/naR7P4Kzt6kyRfeIDyWD5TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCncjHh+ytZN4FjUYCJuJ6mI8nWQ7yp\nukz+CeltiuNlDwIgTNgsA6u9C9tocBcRehxy8fXvLqmBrhck4kBEqhxRn+Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATgHEqOqxUnpNPpjKXvN1DksMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzE3NzkzOC1lMDM5LTQ0OWEtYjYwYi1kZDk5MmQwNmMwZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARPb8JCTd4SZX/qsBG9s7aEGiyaNYUFHLGQaKPmpDFQzNzI\n/6a+9Jnor1pAgLWT0dCaOkLNFKsa/wiRELpHd9m3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8Qrnv52kez+Cs7epMkX3iA8l\ng+UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ4VldgFKF6zSyaSi0MAbOdtxFbuRPo0VEMmEiH7isV/AiAVeZkxPHRj\nACbDTAirdTJ6PScowIlLWC9OSqOAvY2+2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISAawUl5yKFPOWJaRcNhj2pKd/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDVkZDllYWItZDY2MC00YTA3LWI3YmUtY2VmN2RiZDMwMDhkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTFkMTU1NmEtNmFjMC00OTY5LWExZTQtYTFmYjc2MTVj\nZjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjgXEKM+uFLzQ0dbK63wQ8lIs\nIV8H0T8gDIidyBnBMg0NZarPpo/MHV5piXukEYfFlwTzsOEwCzmf9c0mFzPQc6OB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQAok9UArwh6RtVPj+FajrirOLTtTBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22GJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDg180gVhjU9D7f5ML3B+kB\n+EPAhRfrSv5vZFbJ0JngOwIhAOnD7dssv6CkcuoOSuuXdA1iSD6tXrdqC9fIeQuG\nVgf7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9025", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9025` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAWovH260j0UikpPlkX8Yo7pWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5NzE0MTMyLTY4ZGEtNDNiMS05NDlhLWE4YTUwYzZhNzA1YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWY5NTA4Y2EtZDVj\nNC00YmRlLTg0NmMtODlkMzVlODk1Y2UyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8/8V2Bsoq/MqPsVJhbn/xyLD0Njhh0PnqYdP6f2PIyffXWhfc+gOywvesnFg\nvxcduBuTXwKeAuXTj43qLzywZaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULRyMptCXXiqvLe9AgoI6O1ucBI4wHwYDVR0j\nBBgwFoAUo2iTuHOnwrwF6cBSdSjBxB4Z/xYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC9Cl5r8PPSt1vqCfPALBEIiGch\ne4OTCxhIHPos9AbcGAIhALTmU98Qu7PiOFUWYdceNLg8PdcqFlOkthwqtYJvwviq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZKlbXhtTdPjJDv1KQlOl8xEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTcxNDEzMi02OGRhLTQzYjEtOTQ5YS1hOGE1MGM2YTcwNWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuPSrVMyNPd/ifsu5Bwy5x844IDxoZ6KLOpvK9UG8m7oK1\ndSat4A0ZPMvxqpUHffy08bS2AKuamVzS8sgoWdQ2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo2iTuHOnwrwF6cBSdSjBxB4Z\n/xYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANMH9s1MC5yI75bjgcsw2KXuYjYelvv6ttsZJFdnvYLLAiEA6kiZHmik\nRAQHAZbcHiAo/tkMoNnalxCAD1MejYFUtxE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeSgAwIBAgISAYvEOC2XYPCv5xddP0gNYwOGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWY5NTA4Y2EtZDVjNC00YmRlLTg0NmMtODlkMzVlODk1Y2UyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmFhNmYzNDAtYWQ0OS00NGJlLTljMTMtY2E4YzY1YWY1\nNmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEd6tuiFLSQaBECiQjnwqCUoeo\nQIT6IDDHm9PgNp0GVz7nifR+7HNHU2Yj269trgMJbnFqQA47fwbvwEV/ACt1naOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQtHIym0JdeKq8t70CCgjo7W5wEjjBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22HJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICClcGlARdeeTwLx+A9Dd8MI\nUsEzCLFraXvp6GUndG1rAiAg+BSyQG18E/c5UH8E84va/tI/2yqoGiekSJCe/gp+\ncQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9026", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9026` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISASy0P5fm/qwTiqBSvTazFITEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4ZTc0MjZjLTQ3ZTctNDkyNy1iNTk4LWFkOTFiNGVhZDBiMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGZkM2YzYTgtZTlh\nYi00MDgwLTk3ZDgtMmFiMWIzMmNmNzA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtdY44JqX0sStMQ2He7xenYpnmhiEFSqtGSv7CVDezuoFZkpX3TbWh53NirfC\nEYclBFVsxrKA/dPUw/HiZN3cs6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRbxI7WijlkSyVqH/XCeTZMfgc6aDAfBgNVHSME\nGDAWgBTwT/PFbbhar+73Vb5svqd10Jpn+TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCsHoB+PuwoM1MdxSxOc6s1Fn6pL8u7\nquFYSQL+vnSI8wIhAOXzdBkdAPvnGtzXyvgyTCetdDm08h2VEIwJRl/qlOJL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWDV77iHcmsWqc0aJc0CRwqBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGU3NDI2Yy00N2U3LTQ5MjctYjU5OC1hZDkxYjRlYWQwYjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxvRIv7hTdBh3Ub+y2c3Is1l5FLNaEQzisClkG7C+4E9PM\nJJcco479BObU5XvaK6B35k92NV7s19BlcDp7DfpGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8E/zxW24Wq/u91W+bL6nddCa\nZ/kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgK4WOX9NpfCy1FtTlmmBSeqToi9uyOu3iXEB+MC71TuICIQDP46BTsg0u\n6HeIlmxDPyopFMqZeHM702miomDR52rC3A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISARAM83GVnzWKzh5tPBGWh7jgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGZkM2YzYTgtZTlhYi00MDgwLTk3ZDgtMmFiMWIzMmNmNzA5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODc3ODRjY2EtNzJiMi00MjQ5LTlmYjgtOGUxYjE4MDVl\nMTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5WAP19xQbF9+McKOcZkBxRXV\nAiKkrDBVuntNSdlxLeZvvSk42E+3VzgycH8mvfu9iuKLIWYdW0x5vJ8BNgDUuKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRbxI7WijlkSyVqH/XCeTZMfgc6aDBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22HJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCDA8pzlTppd/UYkb9IBai5\nqMONnP7MnGIPRBrHYTxelwIhAOnnUBEf6uVp/uCxqqazQ5LXyyuhav727p7JpobC\nZUiW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9027", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9027` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAR2mRwq5UJiN0Im3mDJM8EUKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmN2U5OGRiLWNlNTMtNDI2MS05YWRhLTIyNGUwNjBjZTZkZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTViMGY1ZDUtYzMx\nMS00MzY0LThiMmMtZjIzMTgwOGI3YTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXVpzOVz6HLNG12lPj0WqjwzWpFr1FfQbpaLyChPy8MUNtL2+51DqWg3/E+zr\nssD3eeFLBLMxP7k2JBLZ4DemcqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqKP4gLt/MBc1OpRhTzt5eUfWJ0UwHwYDVR0j\nBBgwFoAUpxeUE+qWNgKKwIPVAa1NM9kZ1YwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCBqZ2QCbRZ61AKcSTVlbbVS18D\nHiX+45XN4nc0OqWwcgIgezgEO7S6ZvPskoVtcgZodGSVh05F4z53MyM2wF2AuX4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY6jzsqmZHdkf1rr8eMPXH4ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjdlOThkYi1jZTUzLTQyNjEtOWFkYS0yMjRlMDYwY2U2ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnaU8erqqacYnyNtrWuOwbTvSfT5QUSBPNuPNcA4TY6v5f\nJ6iq/77wuY1Jcf1+lpZD2FuYgDzXdM6N3+rRhrSYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpxeUE+qWNgKKwIPVAa1NM9kZ\n1YwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOswvxri2jjGV+v4iUJueVbRSnwfK8+zn6WcWbmdq5WwCIFVZGWCBnzLg\nsOpx18u6j2Clsnx6qYpUw1MvFbP+vujS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAaP8NXWGZciXgZz5EdfSpKaJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTViMGY1ZDUtYzMxMS00MzY0LThiMmMtZjIzMTgwOGI3YTk1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzVlMjIwYzQtYmYxZi00YTFlLWE5ZWQtNDU3YzZlMDRj\nZGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV5PxRMcLu+dBbzL22trE9WQI\nNn5TzUy4jjFkfPGQRgDkbm9cTqlPcVnLjE7NU6cpIrcyDzE7poSmoaIkTcZPuKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSoo/iAu38wFzU6lGFPO3l5R9YnRTBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22IJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD/qPhQmodoEkk+advEwjBo\njFmSx8K6dXLCb3zh7Q+sRAIgWLsb9c/JJapFgfFCW9er0kQFeNaIm/u/6mORDbVg\nvf0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9028", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9028` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAVqHMKJ5UXPiL9Vu4ecfdY4OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxY2IyZDkzLTFhYTItNDViOS04YWI2LWM4OTY1ZWIyZjY3ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk0MzdhNGQtMTY4\nMS00ZjhhLTlmMDEtZWZkMzdlMzljODAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2NchD3/jE39gtHqm+gLERYd0buriy/Q6ndd28dG+UJYu9g9Yt1YtUVv0HPs1\nitpuFmR1bJJcnRqwRAwz9O9+5qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTdFDwMtSDUnFlh6QLE99kzOehd/TAfBgNVHSME\nGDAWgBTxyi6ZkHgYR/HVINQLfq5GzoChZjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICdEqlZI8mMmn4DVkiKNMrtU+SxTSIN/\nslA/CWu+H6QWAiByuUSHPs/NnJUp7hsSIs0K1zadJRApS+obUa2/CaYlgg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAezaxMqf4QKEdQw/ZiTqtjESMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMWNiMmQ5My0xYWEyLTQ1YjktOGFiNi1jODk2NWViMmY2N2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARiu8ND3gAVfpL1aFtHPs1A7ch2w9qPTXZ3W/PsZl5Nduj/\nGsscG/FTydgciUFPlzHlngtTeRd1PEeD7vDaKieFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8coumZB4GEfx1SDUC36uRs6A\noWYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMb8uuRRwwgWkKaZ/JKoXIbtz/HUXsadUL9ZQcgJR4lcCIQCGwye0i+j6\njaoBdQ0bAfeaqP6iD2Qew/WqjlEPTJ0JVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISAT6MQSoFJpdeyrENbaVA6p81MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk0MzdhNGQtMTY4MS00ZjhhLTlmMDEtZWZkMzdlMzljODAzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTdlOWYyNjgtMDYyMy00Mzc1LWIyNjItOWQ1MDA4Yjky\nMDlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkjZjFj0Jq3rX9rRkfb+o5cTQ\nSK/Luq9t4Lkxi9ynaUxZnzZ3vFLyD2oysuInIE7Z+ZCdjV5JJwrrXF1eRLsHv6OB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTdFDwMtSDUnFlh6QLE99kzOehd/TBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22IJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDE9J1ZzfinPiH6wCc0VeKr\nM4cwnmOpmCL8NTvZcHnvowIhAJ2qholjNjVxXKXssp3xonI06YRXklrW2oEh18yS\n/51a\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9029", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9029` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAaDdsqM9Enp3NbSleRpm/+BHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhZmVhMTBjLWY2NzctNGFkNS04OGQ4LTg3MDUyMmYyYzFhMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRiMGNlM2EtYjNj\nNC00N2IyLWI2YzctZTRlMDVjNDg1OGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs9g+c99eUy1DgHMm7CeCxB7rzjpiiofbcV9pp/41o0AcRBhesMxNApcF/6dq\nRIrbDEqj442cndn00eeiXhBXFqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5Rwq1vHzbO+qAzDslGlvDWBhQccwHwYDVR0j\nBBgwFoAU+LsZ6BnIA7h3j1Oq6b2fHpz9qiwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD5bHmYoGCHj8WCD/CErz8fOxAj\n9eaZ5+PVgvUwGjKhUQIhAI8ncvJitjT+twO8bdjSP3hpuTHpY2t42QY/CbIJybve\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcxtCwfcmOPZtNmYo8LUvQ2+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYWZlYTEwYy1mNjc3LTRhZDUtODhkOC04NzA1MjJmMmMxYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARU4mJluYyuFLlr7WfJW5pipUAU5GKkvzOPQLUU9L6StCus\npAXr88B6Z/ll6wlKqaOb1Y8g4B9x+UItBllkwusTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+LsZ6BnIA7h3j1Oq6b2fHpz9\nqiwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL2ICZYdjQE7e6ADQLwECEtk8QeK+NzSWS5HU+V8TzoIAiAdk80sFItm\nTmZpvKpGA2l1q5vXFaloqMTND/rwhL7pFA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAZo+n91s55Q1ioXuwLD3OXmmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRiMGNlM2EtYjNjNC00N2IyLWI2YzctZTRlMDVjNDg1OGFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWI0YTIzZTctOTRiYy00MjBlLTk1ZjAtZGY5NTI4ZjY5\nNjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZUeO0ol/zSsvyYn7EGxEhPm3\nFOb+iFRUDPSk0gE/wql8G0edNqgDfnDy+bz0KqnvuVvEUlHOi+BBbDH5QWNsVKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTlHCrW8fNs76oDMOyUaW8NYGFBxzBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22JJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDCOu2KPtARyf23hkB2H6BGF\nzzf873kxnPKayyExkNWVAiEAmNzw5pYfrbXH1pjRnuBb5EoT2fjLO8viff+VkDIV\noGU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9030", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9030` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAThH0G45Sz8ILuw+Bdfpra4iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5ZTQzODVhLWZhYjItNGI5MS1iMTg1LWFmMzcyNGUzZTYyNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQ1MzU1ZTgtM2U2\nMC00MDljLWJhOTctYjk3N2YxYjJmOGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5UjioQsDeIX1sqEQ1jcjE+33PzAYy2cNvgDZZG/uMW+x9BA5OllcMxlrkPHm\nZ07yAV5IT1p/pB2Wh0zxyJE2wqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQQ49AtasXSQEv8DsOI1xsIj43lCjAfBgNVHSME\nGDAWgBQ5/mMfAG6i6hvxfbVUy4A4NkjpmDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBbTnECeD5ECqh69WKePuGuCQFuQL+iV\nzHaSXutw+8ilAiEAqO2BE2i1gf54jZbuGfRVjsBtjBCvNXAT+QfabnZ0MHI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU0DUBWjuJ+jnxkAMAG7yRhJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWU0Mzg1YS1mYWIyLTRiOTEtYjE4NS1hZjM3MjRlM2U2MjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATW75DaIeN+L/1qjupRSg1cxzm7SB3X4C7f5whNWLYViKAj\nq8+8mjgZURIPbMHQ/8yq3/MglYpTsatFfwzjCEKYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOf5jHwBuouob8X21VMuAODZI\n6ZgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNnd0W7bL7erHW76fXJ/i5KGO9FNTTmcmenlWKYduoR0CIDKg3r7HiZrO\nze9t4IvVhhi/HeW0Ceep6/rzXJtSbwyv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISASf7WZaiD3i3ThRRLGFtbS9SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQ1MzU1ZTgtM2U2MC00MDljLWJhOTctYjk3N2YxYjJmOGY0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDIyNGY2NjgtYWZlMy00Y2MwLTgwMzEtYzMwMzUzN2Vh\nN2MyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZHskgVplxInas4f9hWCXqs2u\nQbOkohVoLZ67A7vojsPywe6qasqqI1oVXw0kpFjhc2F1mrC56EIgLuIAodVYN6OB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQQ49AtasXSQEv8DsOI1xsIj43lCjBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22JJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHmEZffHN9hytF4AXpbd0Ssv\nwMdQhi6v3PaMIOKiIkhYAiEA2y2I7plCi+M/Hi1HRNL7TkSZa/SnyxRztBh7AjmF\nETE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9031", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9031` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAfAQrngmRNZJgSGR3u4oXw8tMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwZmExODdiLWJlMjYtNGQ4Yy1iNmIyLWZiNGRhZjIzNjVkNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE4MmJjNWItZjVk\nMC00MjE1LTgzYzItMjA3MzI4MThmM2M0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjIABX6uKYtacJR8PVbyx0qsVu5PcHu9HDHP8n8SLP6S0jrZOOBu0sS8vMuCW\nHhuqwiv0hcUAP2al4TF+F+yiUqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoL33FqfwKF5pb7L60Ybg6Tb1tzAwHwYDVR0j\nBBgwFoAU5VyfdV3dWOdlwBeYU/v9a7FZMSYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFheK/VY5QITbfmdRGQk++xPCoOr\nh0+L9w5QEpT18HIrAiADV1leUuy8VvcyyFtyhmgUUE+TVkXrjK68FSgNWltw+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASNbD3/lKE95x6ttZGHJq3W7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMGZhMTg3Yi1iZTI2LTRkOGMtYjZiMi1mYjRkYWYyMzY1ZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQOlbAwDN2I5E0NaNVhBgSYLxFHLNj5lpZx+PHVZ4138kMX\nWL27BCrRUgNvmzTV6AC4ukPlX1E3HLcYB4+wBqHSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5VyfdV3dWOdlwBeYU/v9a7FZ\nMSYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgf3uCqm+Fvj/Pmf12IOY4sxP0zJZF8WoNXpYN6vi9p7gCIQCH/7XUqYAI\najMsZf03NswTN2NOLj/oKeybEo/wcmyWKg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISAfLSN75PXSi2H74UT035S+6yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE4MmJjNWItZjVkMC00MjE1LTgzYzItMjA3MzI4MThmM2M0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzU4ODIwNGUtZGVkMi00OTI3LWE1OWUtNzk1NGU3OWVj\nOTA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkuEBFTWp7qI8uCxLkLjNBlCR\nzMHbjdurvp6dUmYRMS4AGmldxxhV5yrbjezUAPMcZK1Hoti+oJl1SWR1eKPfmqOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSgvfcWp/AoXmlvsvrRhuDpNvW3MDBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22KJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDc8PvHR6E56cJFQUuwh6lO\nGpcUIqzcq6U2I987LwHPIAIhANP9BJr7syKV6rYhJQX73HvDCtJwYMVdhJtuYjw6\nKIbx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9032", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9032` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAa04YpVQlrpr0DWNlqlP84H+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViYTMyZjQxLWRmZjktNGFjNS1hMmQ0LTE5NTM0MWVmNTI1MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGViZGYzM2MtMjlh\nYi00MjU3LTg3OTktYTE3NmE4MmM2NjliMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENINXNDId5SBRJ9umoNFsoorLLgKrPppRnq9CDwBdYIvym42cTGb15n6fta5U\nqm77DnbygBZ/Q1m0DsLp8dMELKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTQvIw3CJsynUicBjWGWREcjwvj3jAfBgNVHSME\nGDAWgBQ1aFNnWzY50K+RNydn14hSwNuX9TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIF3+vhda4gj75HluuQpC/TVAhQD0CrnZ\nblT3RZypNv9ZAiEA6zNw0s3Pria58HJq1BiPGeiYoff/wkkIuPH9cqVQDpk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVsuT5z2mam80Y/Z3VVS8XXHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYmEzMmY0MS1kZmY5LTRhYzUtYTJkNC0xOTUzNDFlZjUyNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSUp7R58YtrTjxtPlQoUsgrFMUv7Tg8NTyTxdqQKxBnxea\njbaC+ley4epluDyVvH5eic1hzlrg9iRkYvqMt+b1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNWhTZ1s2OdCvkTcnZ9eIUsDb\nl/UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANvuPHcfi4wbrrnz4ysxPoBAHVJDJSA/+n1RYhc/QoYpAiAfCcbuNNh1\njhpCHBx1h4thEVUrhEuzxGcmJchn64OyYg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISAaYuOEIQp/g+c4xhMmsOkDQ/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGViZGYzM2MtMjlhYi00MjU3LTg3OTktYTE3NmE4MmM2NjliMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzcwMDJiOTQtYjc5ZC00OWZlLWI1MmUtZWQ0ODI4ZTY3\nZjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5SIMhIxk2noBH/yC1JKM4Fv9\nspKsoHL57ia4vm/CM1OYABaozAHEm0Q5fsUqjTCPXHgILZZ2/Zf+8Lv9CEjU2aOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTQvIw3CJsynUicBjWGWREcjwvj3jBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22KJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCC9Q31UTxNH7JdCyC9WYmn\na3mso/QsVYFmjyG2DjaCtQIhAOphzhBrnFvz8NySCPoJpxyqjco9USBjVmqwgHdI\n9ps4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9033", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9033` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfApbqVtm6lNj3GZj+MTvc2fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyYTUzOTVlLTc2MDAtNGMyZi1iMWE2LWU2NWZmYmUwNGY1MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDY3OTEyMDItY2Jh\nOS00Y2Q1LWFhMGEtMjA0MTVmYTNhNjQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmvznhMCIx9FJ1PVp2bq0AtP49vmeDIM632ThkAIP66f4cphGMWIyZdX5CSjU\nSdn1sn1QSKK2eCRhwjDN7EWrrqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKBmf8vb2TP6jGCQMnsV2nq/49nEwHwYDVR0j\nBBgwFoAUL/iJ7pmHffuojq2RPE3sr4ZbpkswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC9XP8btdoOfn1yoe7lUW7pSfoZ\nvhpE/RjTjrWGQ5mL1wIgaEMEk7u6ld4Gl/kGdwdUC4DOECYJ3CUSLlT2OegywH4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAabyWuwYHEx5unJ+PF+OEcIzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmE1Mzk1ZS03NjAwLTRjMmYtYjFhNi1lNjVmZmJlMDRmNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQB59HJvQ2ElsLdmD7Bsb3l3lOizTOrKpiOtH15hxSb8pZS\ni8LUQsnuDVRUZs1GXGzmX0k8kTxG+8ByTeWk+XzWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL/iJ7pmHffuojq2RPE3sr4Zb\npkswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgELvTAx4naUn+PjqPCTAGBD+Qe75rH1RAPJRjijN4qb4CIQC0374ViT0y\nVYkXRYgM7/3+9su3tsTIgOmi1XhW1hRNXw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAa1pPmJVdcHIfJuPjLIsEagLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDY3OTEyMDItY2JhOS00Y2Q1LWFhMGEtMjA0MTVmYTNhNjQ4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTVkNjA1ZjgtOTk2Mi00YmYwLWI4N2EtYzBiOWJlMDFh\nNTZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETNIZpR4FWhVn0Qh/NtYOynjg\nfCLzQyC1NAsFuEcixV/cMTO5eHkn3j1pD2HcO18R24gQ4F7ly30vq9IjOnZD3qOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQoGZ/y9vZM/qMYJAyexXaer/j2cTBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22LJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIC3JFz3hBYiHHXJvYcssJQEY\nRhEN3EWUYuvf3H1sB3KLAiEAp1Qm71EWeCB/Ukxt8vMNjbFQTwiyaXNRPhg7Lpum\nnm4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9034", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9034` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdUTUNUpKqi8gcpp3m24TaBuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjZWYzYmQ1LWY0Y2YtNDA5MC04YjE0LTRiMWZjOGZjOTJhNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGIwYWY2ZjMtMWE1\nZC00ZjBiLWFkYzctZjExMWIzZWUwOTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEV8jeQpCUU2oEBEdOv0t0kgBYxN6SOPIbtk6KIHdJcFt5VZ+zDFqKz+Avk/f2\ne2NV7EqVo6nG9UpGnWE+Auwm1KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRpJMK2kpAGdPrpx0pLMrjoeau03zAfBgNVHSME\nGDAWgBSGyabdIvPh01xgwSZf1F81WsxmszAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFl53SLWy/mnjtfqKAmAgIcdGGLKqETE\neeFZpww5Uf+yAiEAoKBofJsUgPzqeC3SVe0ZRBvyS/7YEWwR/gE6Rvi8bMI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARuYIRsSx7r8jN1hBzOoUL+xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nY2VmM2JkNS1mNGNmLTQwOTAtOGIxNC00YjFmYzhmYzkyYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZd0B7uowv1ehESASFZZN36HVHjZzvmuWK1ZJ6NDU3vKDc\niIOxG+WBfj0UADTFdmvcn+ZhvQHH0BcAeHa1eeuno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhsmm3SLz4dNcYMEmX9RfNVrM\nZrMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVE7Z/2tTrULFhymaSd9wzfIZ1pptGy9/hIFO/SDJMwACIEZvS+rKdYIL\nRkE8rYPQ7uGnV+nOuFxMiGt6P/pKf/h9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISAY0FKlmA3lzJQ/yXNCq1RDjbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGIwYWY2ZjMtMWE1ZC00ZjBiLWFkYzctZjExMWIzZWUwOTlmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTdhNDMyYTItYzE2ZS00MDY3LWIxMTctMDkyMWJhYzQx\nMzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjyzeaW/7m2LhxM91AS5aPfAh\nQRq0Ru8koE2eeVY97kdpt72yIIeDDEzDYK23MI5719DJF9lBmcQy+gw9mP4vpKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRpJMK2kpAGdPrpx0pLMrjoeau03zBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22LJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCsWKoPky+Akg/cxgY76c7T\nlPY65Oxvam7Xhl4gGRn01QIhAOmYHkQkZPR8PNSu+s2eilm6G5Hhb8o+Ygu0qity\nS6VS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9035", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9035` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAbKAID1/hhrLLNs1IkifumkYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyZDZiM2ZjLTdjZjEtNDZlZi1iNWYxLTRmOGI2ZTA3NmE0ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODQ4ZDBjYzQtYWNh\nZC00NjcxLTliMDMtODEyYzFjMGMwOGMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEju8GM5DblQSecmXlYB+4GQ9btiFfmBnqGJqRUOoyZ+vzwHNE/u8e2kqt5ehC\nmvkNgTAuDpt7IexSklk7qR3mtqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdSgPEfIeODbayXiXxqQs4Gn+ggcwHwYDVR0j\nBBgwFoAU+PdHYf6REOIyFglhLsCDNSv1RdAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDovo9Ynziyk7D1JC03dJwtWwwA\nGTL38pUWPaz2xPA1ggIhAJd+OoP6/JB/NWN2hq7Ax/P4NCnlIRTJpQLhDv9RXMc8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWKKdeBde1w+4rGrlc6uVJJXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMmQ2YjNmYy03Y2YxLTQ2ZWYtYjVmMS00ZjhiNmUwNzZhNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATDVaVGH4ZZaZ9LMaxHdmdkwSKfbc7dEAR5kZNZyuG5+eSJ\nVoWYxDIzJbxPY4lZyUZaYk232IlNtTVTSDz6FvsBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+PdHYf6REOIyFglhLsCDNSv1\nRdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPc1W6MMx+EoL0PtLcE5tvQ3hqcCnvkHMjmhvxJnnUzdAiByiiHHM0KV\nbOGya0FR7JpH2+gUSl8JGOzMzVPfC2ztxg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISAX5lToHJ+3v7Dv0AQfLm0+bpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODQ4ZDBjYzQtYWNhZC00NjcxLTliMDMtODEyYzFjMGMwOGMxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDBjYTM4MjMtNjBiZC00YjllLWFjMzctMmY1YjU0NTI4\nOWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE11XPP97yW/rX1voxl9/kx1dW\nsntY/qIRfpFERsE7aQg5HCjTvzc3Co9OzkzLif2fCA8Vedx+3BESy8LMxkDrM6OB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR1KA8R8h44NtrJeJfGpCzgaf6CBzBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22MJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDYIs/b5QbwB/7kNuxKbGEy\nsFEc1TxJ/fn8YBaM1rsZ9QIhANY2StR2wipcw04KQoZYThSfu/KVo+THW8Li/F+Q\nxTG7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9036", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9036` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUvuq8zsAeEDeoPihzadjryvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3NmZhODkwLTUxNTgtNDMzNC1hZjc4LTczYmIxZWU3OTRjOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFmNjU3YjEtNDc3\nZi00MzA3LWFmMTItYThhOTQ4ZGFmNGU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyOsuZYE+/sRomaVwmAike+kStTkj7BTcErT7Cn2zWOzP4PiROkZ69G13BI31\nFz3ZAW+d/JL7IAYxuPXPsXb7EqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQBscRISrgBRH+lrNch2wLd4zofVjAfBgNVHSME\nGDAWgBSmKh76j4ghCM1xM1FaU9sg9HFLqTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDVwIauW/ljxEqxHw0GXRyfCzKaQ6c5\nYN8H8IjbwFzpmQIgICTFnTwd712usUuGZZfya8MnhAigFCNe70/Uu8swG+c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAamcP/aRUkzsKcxe00GV/bcMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNzZmYTg5MC01MTU4LTQzMzQtYWY3OC03M2JiMWVlNzk0YzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV3hSfg4FGS13Qpyyp5b2qaUWKCB+8M2chXOaUUcdVdBGx\n91D9T1AZbHo6flYbm/SiFK1fEMGrvaMjmp0OWfluo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpioe+o+IIQjNcTNRWlPbIPRx\nS6kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgW7i4wMfBSlmo3g8+2A9MQbAlX4TcqnXYR0ekpwQlybECIQD/kpYh+L2c\nimFvbFoFmXwdmNwAc05mgs+DX5+K2X5MTg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPzCCAeSgAwIBAgISAcjFSGRsRwLW1Gxwzmjb63dwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFmNjU3YjEtNDc3Zi00MzA3LWFmMTItYThhOTQ4ZGFmNGU0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjMwN2M2OTEtYjJmOS00NGZiLTkxOTEtOWE1NDJjOThl\nZmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENuSqC30jgycj6dSX0oyH6e0r\nXm1rSavi+B6FQWQe/bhKwaQsx9bV+Ebo8QuGbId9iXsu76b5pNRuxB7G9qfbgqOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQBscRISrgBRH+lrNch2wLd4zofVjBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22MJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDTLrF+7OCZXqx9Z3b86zd+\noYLChcsankVVuNwHy51uHwIhANPkbYDxo1+BuoQhIwGCPLZL35RN8cc6VB/+EoPw\nxC4R\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9037", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9037` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAYZfEFU9eEvDkX+DFYdL/7k+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZlMWM3ZjkxLTkxODItNGMyZi1hYTVkLTk4ZjFhODZkY2ZkYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDIwZjEzODUtZjBh\nYS00NmM3LWIxYjYtOWRiODhmNGUxYzIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfdJnjc6EtER4LcsyKkNQ7ME9V9tLXBrdZKqxeMmT63UM3AUTnt7W5C+TQ1IE\nxywZ+skfmr6mkX2zeqNpSEnke6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsa1x9Zoy5nt3kbJ1tChqbF+oXXswHwYDVR0j\nBBgwFoAURShg7Zz3ae/AtSlhjdQJQoPl+C8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFZ/stoshiIcTzB3OPM19cQ5FQ5n\nda6JEn1mPjjke9KlAiBSLr0afbJvrA9e0e37ZN1/Rd83IsTJpSxMLAQgQbOnLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf+6gVzonvxQj7jzCKM3vwm3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZTFjN2Y5MS05MTgyLTRjMmYtYWE1ZC05OGYxYTg2ZGNmZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR/Ii2eYPU608jOW4LG1J3nwfQ+QqixWASCsYive7AWLPyH\nQqYo24CKBQwHhaF3iQ2IQPIOGDtHnEj8tpmI95/Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURShg7Zz3ae/AtSlhjdQJQoPl\n+C8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANo70vm48x4A/QFg334RzoXImK4rFzhxsZTA/kcM+tAXAiEAtNQaober\nFpmTu4WZVh9Mw6D2seyaxZNDim0T5UTSytk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAV/shuFBg4s9NifZquZTI+9uMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDIwZjEzODUtZjBhYS00NmM3LWIxYjYtOWRiODhmNGUxYzIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk0Yzg0MDItYjAxMi00MjU3LWJkZmYtYmViZjNkOTQz\nMmI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+J2/xxLA2iX3AQGcT3qtRUy9\nG765zRCog/M4fOYAWjHnvgkrLtKFH7OZM1aVWTMXEke5fa1cjVjeMe1XNepyVaOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSxrXH1mjLme3eRsnW0KGpsX6hdezBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22NJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDLuQ6ASF4caJlUn9JoimTok\nYsF8kKP0kSU2sEt1kCqDAiEAgZk/0vrKp367t9AAjufCmRo9GriBfALH8bNiHorf\nhs0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9038", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9038` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAU5IorzAPCoopTnJ4az5QmWAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4MTk3YjBhLTA1ZWYtNDY3NS1iNTc0LWE1ZTVhNjkzMDViMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDEwZDg4Y2UtNmQw\nNS00MzNiLTg5MzgtMGU2MTI4MDI5NTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiYW0mhv1xAzzihjdC7fahXyYoxDQBdynObVIIpa7EM9B8l6kD+zoOnjdMEM/\ncdB3QD2EyrytfcmY47RfbloBMaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSDuhMfRetGe2rMUBVqmlH6AsK1kDAfBgNVHSME\nGDAWgBT6QRFs2aZruieN+2WUr5HzWmGL7zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCID5vfBYaVtCGaSFsILMtazKorr0tYF28\nUE1jKVD6R0hnAiEAs1hWMxo7KRRY/TyiOf+5VJcuC31kVKhAX/O/xUU3oNo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUjggaQbbBLqttuJ15YIVGSPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODE5N2IwYS0wNWVmLTQ2NzUtYjU3NC1hNWU1YTY5MzA1YjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqhjZKJaj8Ma2zPR8E86pcFdMcUuMWnu1LZwngTdFefiPK\n3dLwyevvuK0gbAmoNl/qStK7DTpfl3bNt8PDe/F7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+kERbNmma7onjftllK+R81ph\ni+8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMBBeefMlmr9RjbNjTz7JF7M8sS/vVbAeRKhNRDpkwDSAiEAzyv4zfZJ\nuaZBZTBypoboQqsydJVSVaujESAm77QsRao=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAYvAHgmzVeH6cTx1b9E5+bylMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDEwZDg4Y2UtNmQwNS00MzNiLTg5MzgtMGU2MTI4MDI5NTBmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTg3YTI0NTctMDUxOS00NDJjLWJlYmEtZWUzZDcwMDZm\nMTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHRnY5lRHuSN2Ws8R8tHfamNz\nqNcuQiTahdqlqEgvA7WqugchPvStIkY8+aVuyHqwgnYvwlN/3YJHQqUYMr6Q9aOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSDuhMfRetGe2rMUBVqmlH6AsK1kDBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22NJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCMaPaajTkURBfjzmSC9CzS\nau08+mQ7VqQpr/Mc/neR/gIgXyavnPLPP+yqCQknmXAsWwpQrOepiYQADkRzYVzD\n2sk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9039", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9039` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAcGm8uWAiYZ1+yebarwSQ299MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4NWFkMzFmLWMwNTYtNGEyMS05MDVkLWQ2YWQ3Mjk2YzRkNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVmZjEzNjctZDlj\nZC00YzY5LWEwYmEtOGFkYjYwNGVmYTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERHWaYHF/884LKlwmh+RmMl6rcEQC09N3nY3Iq1YIdHzhft/bbVMG6EM/o4OY\nfRzUHcue5jKua5d3eWCzvh/Ku6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUThJqMALF6CGQ/mJ7PoBdeHBgmg0wHwYDVR0j\nBBgwFoAUEXL7cHAw7I4d9rtaMQcXr+IE1fcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC9vviwIxUyDmM8b5yDfuMaWcWX\nHCdDkVrsqZuK5leuxAIgWAnETfvKoAXH1hxTvJGMun9ZDBYORHOmW018j/3In4A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbqlSowDnNuKqRGQUvGqcGt3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODVhZDMxZi1jMDU2LTRhMjEtOTA1ZC1kNmFkNzI5NmM0ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQHjaW567e28ezfDajJqeEpAT421Fev13Y98f5Dyk8X0yKd\nYenDIGJwvMRLPtuQAnBxKocMPNYW8PlVJ7iuG9hQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEXL7cHAw7I4d9rtaMQcXr+IE\n1fcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgI2dZ+9KcLNBYYdXhTbl0Vmz6dC/pucz4ePI8GZYn/WoCIQD8de1tZXFv\nND6RLMPTb3/wc9IIlfeCNCLofqKVad2QuQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeSgAwIBAgISAb+TorxGb3kIHyMdov7byeWuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVmZjEzNjctZDljZC00YzY5LWEwYmEtOGFkYjYwNGVmYTQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODVmYTc3MmUtODE3MS00YjZkLTlhMDAtODIwNDk1YWU0\nM2VlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECda29qMEzak5BaHM5ThxIUFj\nOYOJLRDAu9412ZlN8ZQ5ESYdR6B8bXp04SygLn2kZV1PzTQY5zElx1uj16KdNqOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBROEmowAsXoIZD+Yns+gF14cGCaDTBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22OJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBjm1/nOP+00IewuwDl1S6Dg\nQzOGfBL+jD70XxQ/ugbQAiBbVo0UsraTKE2zXVMat4gOFLoiWeRrhlmFo+jf2/mh\nPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9040", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9040` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAcfjJKanFxhNp3RG/42MkGlhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiNDNiNzQzLTQ2NjItNGY1NS04N2ZhLTgxOTdmZWJlZjg3MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTg4M2UwMjUtNmQz\nNy00Mzg5LWJiMmYtYmRiYmI1ZTBmZTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVoqlMQzLsYsZOuPw0FdPsh7EJ8tzN72Pj/vNxApGm37bBn4r8pJPUCDwSntC\nHwqxMf3E68mCadIJA0WzsKOD2KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQos4JKTFQfTYe+ATaddEnagc6HUjAfBgNVHSME\nGDAWgBTpmOY2cD5Gk6oCwchl//itqPMS9TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGlOkIkfkCF6NS+vihJ9w5+QZ5/qtuB8\nrNORMNAOtauCAiBgV8JlsQji9sdPHtOtny+kY4SFercljc1sbnc0iroMQg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASSIenAfbjz+nX4bVeuq2eg4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjQzYjc0My00NjYyLTRmNTUtODdmYS04MTk3ZmViZWY4NzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBklPIbXNJAFGtT7bu6482CD5PCqszJf2Wrdl4FAId6Lsq\nkyxrUR5+Ts621RJRqYfSLCONvgEET3FGRajyjG32o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ZjmNnA+RpOqAsHIZf/4rajz\nEvUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALfnqYX3ai5mCJ8n0MruMeJ0kzkDrOBqz3qrExhZzmyeAiEAlzUz0ao1\nhfv+ellOKl2zxPMmHHz9P15uc6Dg15RDPak=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeSgAwIBAgISATqSaO5eZeVj5F31cIVnP8zWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTg4M2UwMjUtNmQzNy00Mzg5LWJiMmYtYmRiYmI1ZTBmZTk4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDJkMGM1YzItMDc5Ny00Nzc5LTgyNDYtMGY1MTQ3NGVm\nMDg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7lYKEzjTLRjIhcv34o8YsB7s\nDSuFoGoej2egqpg8BewmmwXVnKHrU+zBjPQ33tTAb1G2fbWwpVPmMbKO6RaEn6OB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQos4JKTFQfTYe+ATaddEnagc6HUjBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22OJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICe3/z3x0FQ0c9qdDW80ZFLQ\n0ivPXudRQhEXFhKwTJPhAiBHkMT26g3q/qkLVZ3EjnU0oOptPIydXaNZRPu8VKak\nEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9041", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9041` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAaZW3EN+GaPrjQjwYOAIJUQ4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4MTllOGE5LWU5ZGEtNGRmNC05OTdhLTBlNjhlZjMzNTJhMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTc3ZWY2ZDctMzFi\nMC00NDNjLThlZGUtNjI2OGQxOTk3NDdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETmvbqlbYMtr/lY4+OiAQHy+0WhZOXaDoJ+b6stVoQxdkWvpocx6TV2bgCY33\nsTR0TbhCBKfscFkt7TXX1uqhXqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB1z+D5PyHigxHLJqZtb3brF2ITUwHwYDVR0j\nBBgwFoAUEc2dBKcg+fWPASfJVE0jFn11+GEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC/cgF89mCRvNoUFHXs2hUoSQUn\nMyl2e/Hc7IY7DiXFtwIhANgWLl/UiBiuyBCRn9r7zX3wFL90DE1vOtdsbvVzGPKl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcxcTdoEVnx5In2Tj+cdIJGbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODE5ZThhOS1lOWRhLTRkZjQtOTk3YS0wZTY4ZWYzMzUyYTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYg93DzvLi9vWDkOZHFTEN93jelpHpYnYWRUyZfr5vlt1H\nXPPUVU59rKDMPLBDH9qnB7O6ooz7ztEJXF4Mmwcao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEc2dBKcg+fWPASfJVE0jFn11\n+GEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMMTFMmK37AHB0tyI5rb0We1W7ypDjvfLQyiTQNPgZ8kCIQDp1jcXdFet\nuJVUs17RP/GE/Ixy5EtdPtaVMC0dFLMgJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISARL4tP4bLl9eJtTi0QzhT1PlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTc3ZWY2ZDctMzFiMC00NDNjLThlZGUtNjI2OGQxOTk3NDdmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmUwNDA1ZGQtZmE0NS00MDE0LWE5YzMtMGYyNzE2ZDk2\nYjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtc1OwjmS1YZkFKeBB35fQYfb\nQsPQm9Ti58HZzSxIO9x26ijGzepRrIPITajlFUOzCR54PfTp2+Caj2J6eQf7HKOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQHXP4Pk/IeKDEcsmpm1vdusXYhNTBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22PJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCoP9Y6vsXdmw59CiUFx4Ov\nQYHPHGbClt7IfFFKb30fqAIgD8jeYOXjSLmpT2ua+bdrP+7sqe4H/CY4FVQ+sEsw\nhHQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9042", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9042` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAdMbRqYYFgyr6TbU6hllrb2aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1MTc0NTA4LTI1YmMtNDBhMC04ZDUyLTU3YWRiNzU3OGEwMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2Y5NGM4NGItNTMx\nZi00MmIyLWJmYmEtOTE3ZGUwNzBhN2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDyZxh/eRwMWgl4INjqRV0VcZUd8MwWWKPU/FT/f0E2McDMSvIo9Ki5C0gNqX\nwFeBf4Ib42OQ65m7saEzXMJ9zaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRKuJ/l5KJNnFrf10i9pJJd3xJvpTAfBgNVHSME\nGDAWgBTW7ArccDcv40JOOGGo9RAO/xz1pDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDM0/6sdPLa/BHemSbjkHOqm5Pj1vTS\n2SMAoY3eUTQBCAIhAJdY2NzrFfGcrUB38KHACz9WxVkDTjbsn7srXgI11YuA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAexDxiIPpe3idm+zvUFh9XEgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTE3NDUwOC0yNWJjLTQwYTAtOGQ1Mi01N2FkYjc1NzhhMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASH2fvf9zeMqXFjD5VsDbGFFpIjaa5Qc6ll2fK+AstibpUN\nUpfKTJuS89iGyBCIUGngn7PhYlKKbbztK6B9cdYvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1uwK3HA3L+NCTjhhqPUQDv8c\n9aQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSJz0XZ9Ruzdi2pgTZFEXrRMNTFzhe0fZxfFFuPEjn9UCIHQuHt6D4oyX\nQDHkoeS/Y+GdXvZiU5GZJRj0ZqxUv38y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeSgAwIBAgISAdOT6MvRkfvLDQ3gW3zRZ2tqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2Y5NGM4NGItNTMxZi00MmIyLWJmYmEtOTE3ZGUwNzBhN2MxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWRjNGUwY2YtMWE0MC00NjgwLWEwMDEtNDlhMzAyMDMy\nZDhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETBUIMHUMS1dn5qhB9zyEYVTm\nCtwx7cK5VZJeSHYBHgi5DRY+NSiDIEU6lT8tBVSyUGqsXdvQdpA/1ZCkbjW2VqOB\nmzCBmDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRKuJ/l5KJNnFrf10i9pJJd3xJvpTBCBgNVHREE\nOzA5gg9iYWQuZXhhbXBsZS5jb22PJmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIHRl\nc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFOqJCvVNuVgCLQJjf0R4xFD\nArbaiu5pKK+aD460EB7sAiEAmeUALJcckKhz3IXD7FyPmiTtUCCdrzHlF+2tZjIm\nt7Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9043", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9043` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAavanZbKXFrzayYSOKQFLahyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2YTQ5Nzc1LTMyMzEtNGU2NC1iYWM2LTVlODQyYzNjY2E2YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjdmYTRiMjAtNzk3\nMi00ZjVhLThkM2UtZTIwMDhhZGE3ODM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESbhRh4TYeRbG/MW322Ij6TfbmHV5cHObExmdRZHldr5iYFhmob54Pu6EJ5XY\nrK/cEUbQcrfR9arSWRoay+AKHKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQRD2AbUVlMOBvTi+nuex0x/oM7cwHwYDVR0j\nBBgwFoAUAU8f8js0kDy/MZiYrlE5iFFcrNQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDAEu4WBw2JYC7lzoisoZ6OKHvy\nANBU3JJB0YUdlrF4CAIhAOOL0pMiyI8SXQps1nT8tsTC9cbPBkdqZwFLsL5sNQJ+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfYGCHbpBGKydz9F+6HU4nl8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNmE0OTc3NS0zMjMxLTRlNjQtYmFjNi01ZTg0MmMzY2NhNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATatkaumwv4WC2NIR9r7+ys/0jyh1cMkbOmpqxLdHayGt1i\nG6WKuZhLRKvGl/Rhov6z7MRkJn9AVG0xf+CyS6k4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAU8f8js0kDy/MZiYrlE5iFFc\nrNQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANMVp2bJmAw/7MMVr0RfiuxS/LFs8QGD0mzYeYjlRbDwAiBsRux6g2ns\ncn/PGgdTmQXTMSBhuCy+n8xU6VWrp1UccA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYMpYz4elIh9PUpBkLwaESzJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjdmYTRiMjAtNzk3Mi00ZjVhLThkM2UtZTIwMDhhZGE3ODM2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDc3MzJiZTAtODUxZC00ZGQxLThlMTMtMjQ4ZWNhNzNi\nMDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEW/jWY2pT/M6i7KZ7eeHBLsDl\nCO+Q2ELzNj5Z8bOFMPQIBUSusqHahvFlIrslIdOIwnMpuhbDX436YRjcGdRRV6OB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRBEPYBtRWUw4G9OL6e57HTH+gztzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22AI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEt9uhQgP3m/ofM5dzlidSLKN6pV\nFeJVuweWqBkGJw4eAiEA4daKZRqaUccBii7HK+h0YatPADme/Fw348DUd57ES7Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9044", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9044` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAY9HyX2d8moKufiH2JGN7yzlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI5YWNhYWQxLTQ3NjMtNGZhOS1hNmRhLTE1ZmVmNjUzYjNhODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU5MmUzNmItYzhm\nMC00YWNmLTlhMTktYmUyMzA2Y2VjMmJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmzymXuyXT7jYtbl8k7z6o9CPEm5A+yfis8M8RhOmUbL+i51Gs+gyXzVndB7l\nX+++2m3AcSJrFozV6jTKtRRg7aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQWeFNnGNaWWp7m/z5jDU6y14/BWDAfBgNVHSME\nGDAWgBSHo7M4qC4SnbDiosBtvzu0vMaI+TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIF850+JxZ94Lsm1C8KDWHcEra5hfJRtz\nk7QT9v/F+/+WAiA9JqMuNAL5hAZrOMegb1v9STkV/0peSWVyjn02UGhEBA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXWSzg4OiTyf6O17yPwnqWmiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOWFjYWFkMS00NzYzLTRmYTktYTZkYS0xNWZlZjY1M2IzYTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0M1+vT0bnCIRFV7nxZ9JabA85f7NpC5RrXsT07Q6py3To\n7pfEFG9cECcG9wFeC7DdRYbBQj9m/FVCD8v9dTqVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh6OzOKguEp2w4qLAbb87tLzG\niPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMZXT65CL3nWHPsXYhiFUbdy6MGSusaO4wgUa98mtrS4AiEA7hbqLYKk\nhUXPIFpS+rp4+pNcRe+GDczGpLLb8Zjey1Q=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAU9Sitt4h+OPUeGuVJ740J8lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU5MmUzNmItYzhmMC00YWNmLTlhMTktYmUyMzA2Y2VjMmJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDIyYjRlNmQtYjlmMC00ZGIzLTlhMTQtZjlkMDY1MDJm\nYmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE94T04HycNLA70rVmkApt9iXX\nSV+WTlSt3t3IwwNmrIKtFDLFEHRBKRThquhUa7loVgcwNL/S5/Xip12m3Ma49aOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQWeFNnGNaWWp7m/z5jDU6y14/BWDA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22AI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCCxKoqZZqlh8n5t6+zLBaIftVc\n1HMI30tcYRuumLHzwgIhAJarW1gM4s11REGdlr7gpzOVk2pjPVVR5hkBPao6CXpN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9045", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9045` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAbDdZkAcX949/FQnyk827/89MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxOWE4MWNjLTYxNjctNDViMC05YmZmLWFmMDIyOWY2MjFjYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTcwYWM2ZTMtOTAz\nNy00MTdmLWIzZTgtZjQzZDIzODMzYzI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhyimRzRepwBcIkNR7NUzxrZG0P3ZIWceG/3yZQWTOI7hE+gK1LZLAaNF/2TD\n4XuaCzyVFrTF1KGCIq3Z7zD+T6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeri6w9FHt7pGbMyx7uJndKsfUkwwHwYDVR0j\nBBgwFoAUWaPVnH0pWIT7+O4xTo8WdyR5vpkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCnLFRMpG4aZ0g9CdP44vX3dtmr\nLyzp1sWY2sN6DLo96gIgJ7caJVr0CNtm50xy/p3iBIr57cayZ8RscgpWe6rFovQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQKdBCQhzPiDxexlI2pVHDsCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMTlhODFjYy02MTY3LTQ1YjAtOWJmZi1hZjAyMjlmNjIxY2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASS4KirW/Chr4Y2h636X7j6YL+BS4xe+XZXkp4fgkhm1/vN\nnc4SPyS1dBnIJbtyUlpTzXCUQmKZImKDa2Ka+7dso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWaPVnH0pWIT7+O4xTo8WdyR5\nvpkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIyz8X3Fnxm8KCPPbjZLB4dyYOtoN/mcPtr70waY5PZ6AiEA4Qbp+xC7\nC30c4wgxG2RgPkEsq13XwPbZ0bzyyOaTt48=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAYaGfF002B96YaUk/O3u7HA6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTcwYWM2ZTMtOTAzNy00MTdmLWIzZTgtZjQzZDIzODMzYzI1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTFjYjlhZDQtY2E0ZS00OTY3LWEyMzktZDcwN2ZlMGQ1\nNmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtW0YJDD/2VOUV+cX4R10lVDc\nYrWBjRnKUlRt+8lJB+sIDWPgybGK8ffvI8bSTI0xz1GZkgk21LjvT+Kn54exqqOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR6uLrD0Ue3ukZszLHu4md0qx9STDA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22BI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIH86cqhGp4vcnU5wgJTOa2+ayQQe\nVL+RBnt0kIR6MXfkAiA7uY9woUBz6QUAggXWnnBofdyqsvrGe9WrpineAatvrw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9046", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9046` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZ+tH5qQLYBi2Wp+aJYaGU0EMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNzdkNjZlLTIxMWItNDRjOS05YTI2LWZmNGJkYTQ2Y2NlOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTI4YmJiZTktOGJl\nYi00MTg0LTg3YmItN2FhMzRkMzJhMmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbbdjWFVG00wYNYzM2AXEoXyqM9gZGAnbyLFUwCzT4JrnmEcpAm5rkfQD5s3w\nDaciiBO8asxDmn9TPgfhtXOoMqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTl2cl72Lf0yLBsnbDNEUDqttPCKzAfBgNVHSME\nGDAWgBTNovxPy20NMJC4N7d/T5m/YTiE0jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCq6SgxMJdG83rdgFBORrBPtKRINfo/\nlNgYYPj9lNKV+QIgaeGXOiFgNqiwf5zT1Inkh/f3NARi310LsTdpUd5O7Qk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeV7TYqNMefW0vdt8BMAk5V+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzc3ZDY2ZS0yMTFiLTQ0YzktOWEyNi1mZjRiZGE0NmNjZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrGur1HOAL8PKOUMzX4WxFiMryQ5DQ+yQJfjRlm+0cUWAU\nwGnbZfzSJVDrTLGxqhULhOfqsrxn4ypSQAubswCco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzaL8T8ttDTCQuDe3f0+Zv2E4\nhNIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYlWWT9Rzch2/YsAbQOTSwm3/ysltkhMF/OV4m7W5/ScCIGjWSUCzGQSQ\nH5Ptgq5pyAa/Seuf+YhPB0oRckiSXByZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAXJbOTIfdcnQxFdPt03Hr0g6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTI4YmJiZTktOGJlYi00MTg0LTg3YmItN2FhMzRkMzJhMmQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzk5OTk3YjItYmY4NC00YjQ1LTk1OWEtODQ1MWNjMTNk\nMmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn9iOGPx0ZdWsJ9Rm67drbdx1\nHJN8H+QppKAz5QHA77tr8SgSRohv6tkS1RWQhWxBhPgzvKFDOIuOrVsUnYKwaaOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTl2cl72Lf0yLBsnbDNEUDqttPCKzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22BI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC4HO4+cA5Cb5Stjolzr8jKbF1L\nsXcbsA6r4u25dlT3+gIgPm7ASZNvskXDmA5OZ+lMqX2KIJiaRRckxzsldNInBr0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9047", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9047` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQdVQ+qhFafHQGzcDc2phtcKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2NmU2NjI5LTUxYjEtNDNiYS1iMTZmLTA4ZWI2ZDM0NGIzMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGE3MzA0NGYtN2Vm\nOS00NGFiLThhNTItNjljZmJmMmYyYWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbSmXPTycUyfz7V4qclfE+t1uOIMBgatgFw9tDriHpC+XLHgtfiXYgk3Ts3r0\naAOAKKZyLc+BjGVpRihdCq2SqaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU52o8xtOoULm6GrU79vhBmy6Gvo4wHwYDVR0j\nBBgwFoAUxOFOEFlFQD0hPpiWrDc/XZFFtGowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDta8EEPvqbtuUvDAC6dOGejsWF\nlNVDiE0UCN8F2Kfb7QIgARwuF/lnohZIFopiDOk8842c1eTs9aSklraMibMKGvw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVs1ut6WFkSuyvl0BbwQg4h9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjZlNjYyOS01MWIxLTQzYmEtYjE2Zi0wOGViNmQzNDRiMzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATb/8FHoWV5zsrih8uJS89rb3dwyfldGdSoKLw5mx4vl3BS\n9RZgqQjAkFkKUVFNftL3Hw0YSzuImebV+t4UovHRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxOFOEFlFQD0hPpiWrDc/XZFF\ntGowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDdIvkPWzsL630CMRsUMGidAGttgW3V6gAHuou/p/utsCID8P7YOyAMYj\nnojQaWn1Tr8r2lgRxPnTZYlnbE/148Tb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAXGtdMbQONIju9mqsFO6TTysMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGE3MzA0NGYtN2VmOS00NGFiLThhNTItNjljZmJmMmYyYWIxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzBiYTdlMDUtMDQxNS00ZGZjLTk4MjEtN2ZjM2FjOTVl\nZGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIGbH1ZOB+/DB2f6deJLwB8tA\nGmRUlZP1HVCsBZJ8oux3y/jjxKeZYx9Tk3A7da+Z81mT6bLI8eF9uckmFLyU0KOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTnajzG06hQuboatTv2+EGbLoa+jjA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22CI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICom1+AT+vh8lfUyBzGCgNPpnlOH\neqpQdDk+NUcayIOlAiBmO4SmBlrN7HuczmNz7BPl1/3PeH9l7xhaG3wMbqzqng==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9048", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9048` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASQvh7vG6o3KIFsignh7RyIkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMmJmNTNkLWFiMTQtNGViZi1hMWE0LTQ0NWYzYTdiOWVlYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDU5YzE1NzMtMzk4\nNC00ZGI1LWE3MjQtMWVjMmEyZmZmODFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGy8akGtyRtVjYpQsC/LTfgguLBukAZqPmEhZM2vVW7yOLt5IOf64/GNJW9Te\nZ3pK3iO+AWB4RMb30c3Fyz9C76OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRUcH8nnzmwbVbvB6SQxYu6BBT5wjAfBgNVHSME\nGDAWgBQgCg7oyJwu4A8sVkwb1YccQiPJIDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCWr2RbeFtZfNatJkJbHfdVt+IBwFPa\nN6K49Z8B/GbIegIgBL6MSCS4rJ+1+Lj0NfOae844AO91J65AHsYUnG9Iv80=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXvVl+aTheVfpPs4vsafQqf9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzJiZjUzZC1hYjE0LTRlYmYtYTFhNC00NDVmM2E3YjllZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdCwxuCPVUGFmaSXEtzF0AChACSgrhdRou/RCGEnsA6/2+\nZa7BPwg16zEAoEitZVzaw+gKPSFoOOkPo3ZQH3DGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIAoO6MicLuAPLFZMG9WHHEIj\nySAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDHbQPbnaUQsySEBzcemEhl8s3ZadgCA7ljd6748weqECIQD273eGce6g\nk6GAyekKte5AeMSJAeDv8fJrAHXHBHYZIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAT9x5MAan0Vq0dWmh71C3QnsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDU5YzE1NzMtMzk4NC00ZGI1LWE3MjQtMWVjMmEyZmZmODFmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDJiNmJlYjAtOTM5Yi00MzRlLWJlMzItNTkwMWIwY2Zk\nOWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1UvV42lQZ0tyALZ9yyqPDA81\nU5a8N1jL+qWFPewKHJs0C9tiIrcautjlgHV/+BMTBHC4ev0pkSDaEdL2OIRxKaOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRUcH8nnzmwbVbvB6SQxYu6BBT5wjA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22CI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCDk7pOMaKKIXAyEiBB2DFUuprZ\nitx6jC+R7SbMWEfXeQIhAJAqzaxW6sySfoXlh34b70aeMQJOQLvvP2rYUvyJQo29\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9049", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9049` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAY9Xrv4bfWs36CCYd5fA3HjWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2NTZkYjc2LWE3NzAtNGNiNy1hNmEzLWRiOTdlODU1OTk0ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWI2NmYxZGUtNWE0\nZS00OTJlLWJlZWUtYTlkYzA0NDFhYzdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpFAYxcmgi27oIWW8Q6iqsuvv78PmIslslvZ79hp5p1lhaLvPQnIBArn7UFUJ\nXPi35LyNx9gIUsckeEGMuX66S6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeA7FUfAvigqhGlLQn6b0s0DVwOYwHwYDVR0j\nBBgwFoAUrtm2P/qr1lp7PUyKVSIrvdDKIiQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIASLaFCjSjEeScwcmjnUlGVokTrK\nwE4T6i6YHVFOFkwVAiEAnkbAqOYxDx0jZARbQixAX52AQp9zpDYjXcqaf5lpnTk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUFgo8XzKQGzD3CMsO/jZTCHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjU2ZGI3Ni1hNzcwLTRjYjctYTZhMy1kYjk3ZTg1NTk5NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIMlUxUyTSFaSxt0gDV3dEkjR/LzkJghaWRXLbJ/h4oVWp\n7/LNrxS5/Jv4Idv7qJpCn2+wA9RuhD0dg7vFmeyko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrtm2P/qr1lp7PUyKVSIrvdDK\nIiQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKltPkPZbS/EUphnG3zOH11JqmOeercsXsO0mplgwWP0CIQCArxbihQuZ\nLGWmuAdr23yaA5bqy+u3mvDKPAF38OSZWw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAc/H1GUDgPqvFJHhw0RBh3jeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWI2NmYxZGUtNWE0ZS00OTJlLWJlZWUtYTlkYzA0NDFhYzdmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDBjNGMxNzUtYmIzYi00YzNhLWI0MmItMmVmOTc0YjQx\nZGI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgnSRD88rXLympifcJrtt0qzj\n5HkpTrN3jtkZskuBI6sTKUIdgqhgTNZA5Toqw7/qv21/rFjPYAQzSZMEmJhV1aOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR4DsVR8C+KCqEaUtCfpvSzQNXA5jA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22DI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDAbwrkBcdyyJMlZ5chJ7ShSmXty\nYktCg53nb88TJvGjAiABsi1htgaymfFwtH+Is8JON+xOS7ptYdBBUiNZzreYYA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9050", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9050` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZS1LYMF0A2+UosGH1gO+HpQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhMzBiZmQyLWUwODItNDhlYS1iMDU2LTVhMmVlMTUzZWNiNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDk4NWM4MGQtMjBl\nYi00MGVjLWFlMmEtYzkyMDg0ZjJlNzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGwV02jRVOBBgzpaffNhgTl8UaQzNTMzYPjiatbarOZo5HeTpLrZ6McpzAxa0\ng/dYBg2KZ2LMhg7F4jFK9GAJHKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQSO6mmYe7iYnNqLsPo9EwNB/6PtTAfBgNVHSME\nGDAWgBSPaD1YmLV92OKAA11ASab2oo5EmTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEjKITDEOHldYaKDELdP1YQi35vO5kBz\nY/f4+J7UftCQAiEA6pmxdk1jNqsxtHVLdyZgviErvoFHxKQfwDFBC6cdcJQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY/UzeI3hiyP7UtxSMfVYVRUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTMwYmZkMi1lMDgyLTQ4ZWEtYjA1Ni01YTJlZTE1M2VjYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARgNMY65/m7C9UZhUBlVInG+dfmCiP35ysE5C5IaTCh98S8\no0ufmFCbxmUNNrfZ3cups2FhIoWrGEyBsAPNYMHco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj2g9WJi1fdjigANdQEmm9qKO\nRJkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaJRSK8UtlbY90DKSVB/leYZI4tjA4GzPyN7Vzm4jOhwCIF6gONTXx4pv\n7bLxotDYlge4mvHz4bAvuY6oS22GqmyC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAUsJIqax6eb0lfu9qOiyW1QiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDk4NWM4MGQtMjBlYi00MGVjLWFlMmEtYzkyMDg0ZjJlNzJmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTkwOTMyZTUtMmNkNi00NzA5LTg5MDUtMmYwNWZjNjk0\nMzA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETYdSzOE0ZayeerBg41ajMj2v\nGKSlluitUuJjMvDHGg+JSOeonIbYYMpnOJs2c6fSryNk2Xn47Hm12hptOhLhCKOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQSO6mmYe7iYnNqLsPo9EwNB/6PtTA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22DI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQChUtUOsDt/Gom9Ou+MgYicm4G1\nBP6jOsCu63eZebkN4gIhAKpcUS3agWciKxGJisHiKDQHBfsK26WlOsSDjuqzaO5n\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9051", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9051` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAXDYPLkA7LVJpbyIi01/Ux5PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0NzUzMGJiLTMxYjgtNDQ5OS1hN2UxLWFjMWE4NjRjYzA0MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmFmNDRhYjctYTk2\nZi00NWU4LWIwNmUtMzU4OGE4NDJiMjBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkqIfJ2tcmxxuvUUcJHvmt7N3ikyBQMkDkNg7T8/t9tsuJSnMLD5+nKut3muT\nPJbnSqaZ2GCirL0+stchUCwpYaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3Hma7wG3YMOK1bwR3NVpXAVQqxMwHwYDVR0j\nBBgwFoAUbZzODUJBpaQXk7LP/PLfvZ4bm0AwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBiOZW8YvVMXxgnib01aVP4G1Vsz\n1gy2O7zzz+XA7LltAiEAz5UZp/uuzdP9sI4MGbSmLO8xGlj7xC5c/1K2Sie7a28=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASg9T8Wb6QGhuH5r+HpFqdtuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNDc1MzBiYi0zMWI4LTQ0OTktYTdlMS1hYzFhODY0Y2MwNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJhPGjsuCh3lqBi0hZ5LRsV/K5WO+Yf32v6scyu6/uxhkO\n2f9Rdb2hfhGl7Ts6ogXPFklGaHjPdwermb/SXQiBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbZzODUJBpaQXk7LP/PLfvZ4b\nm0AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgOupyV/AXBuv/SVE0bQvW6f39SD+TM2J1lkJAxyN5WK0CIQDMgf2FuBAY\nE1/jTUOssZMTkRsKIzaRmOU+xTg8V60sDQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdew+9Evq2DkT1IswTVrIhSWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmFmNDRhYjctYTk2Zi00NWU4LWIwNmUtMzU4OGE4NDJiMjBiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODg1MzI5YjQtZTYwNi00NTFlLWE0MzAtMWMwMDA4NTI0\nZWI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZsjzUNMOCnX872DvmHFKXZBs\nZAuS88SQDW+ZrfPcYSqwKeqXoDQAIqqIsTlF6PclyRzuxxyc83NsodBcLNJ7p6OB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTceZrvAbdgw4rVvBHc1WlcBVCrEzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22EI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCwwLe9mkFOPasDqyNE1kClyTel\n2VVYaDA6j6QewaYclgIgZTKoHSbpaSXOMXNj/zq4cI7kLcruVFU2Hz04BRzIYVY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9052", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9052` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAaKjP5HmKjmBqbU+6jaF98cWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkZGMxYjgyLTRkMTMtNDM2ZS05NzliLTQ1MzI5MDAxNDUxODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE1Y2E0ZTEtMjdj\nYi00NjNkLWI3NDAtODhkMzRkZjFkNTU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPaoQD1ncsl3H3jFyCeaewVEnFV3r1X4+odqj7htxdWNfeUIhDusFR1KYgRiN\nVHnCCx0hCqJO/+0DbbGN3JFei6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ2eJD+Eib+23GuOE3WIbzu55LH8TAfBgNVHSME\nGDAWgBRBghI5Yq/ZW9I5LYWeo5AJmAGC8zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICkIDO/L8AM9vTh752OZxbSGPRHrT6ck\nLRxf6JQ6qZvPAiA+3L+6BerPcXmAZoKyR6OT844iRHQuo8OQOC4rx4dmOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXvjI4TI9NPwSU3x9qNztXq/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZGRjMWI4Mi00ZDEzLTQzNmUtOTc5Yi00NTMyOTAwMTQ1MTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxBEM2Z1/4Q94Fd/TQypbdZijVkfgYNx+S1L4wDoY5yiMp\naAjugqEjcdFn5ImBKv8BuaRulpdP/7rmB1YkiHw9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQYISOWKv2VvSOS2FnqOQCZgB\ngvMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhV0IoInPYFSrKorkCCFauwtncqE7DcL3Xb/AMCw/jPAiEA5slVz2XA\n/wEAzUAwNk6jfSCtlCuZLRDFrkN0xuIIyKk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAUgS/+GtwIr168T77d9f/ztLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE1Y2E0ZTEtMjdjYi00NjNkLWI3NDAtODhkMzRkZjFkNTU2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzIxYTUyM2ItNTA4ZS00NDc5LWFiNTUtODQ0YTExMTFh\nYzlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb5GgpVdOABRybS2ytXa6b5Sh\nHlle0GvJ0+dW39VX72bAidVsYFjq21Ws3ep4o4ldpCbcE8VU0IPY56ehqQsHw6OB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ2eJD+Eib+23GuOE3WIbzu55LH8TA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22EI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDIMnk1xBOFRWjANgLRHjgQRiznE\nyq4LfQ4fIrcKi2p3AiAjCBI5SUk78ATDHe7ssKemPW721KCtzbvl9mW+sTP6hw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9053", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9053` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdc7sc7nBN9QMQXxHOL30lw5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0YzAwMmVmLTUxMzktNGJmZi1iM2U2LWFhMmZjY2U3OTQ3NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I3M2ZiNmUtOWYw\nOS00MmVmLWE0MzEtMDE0YjE5NTRkNmY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELLN680qYBoveHJI8KEPe0eM75eQjz2V7rkCr2GzvihJ53ERuygJfKRyAsyTk\n63aNn8V5T+JidY2AKqa1apHTl6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjVIsKoBPldiCY90zMqKMmx7km50wHwYDVR0j\nBBgwFoAUmGbj/VoYNd2lbwVUQoovNHO1DmcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCDffyBjdbjN6aMvPZLwEZHtEJp\n/6mZCWFM/SH6yUOTQQIgBFtUwMEKe2pmFt1xAlU3sr2PuLXa7VZUhz52vrf2uxA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATm4Gbh3sbbrlSgzclL6zUJ7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNGMwMDJlZi01MTM5LTRiZmYtYjNlNi1hYTJmY2NlNzk0NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbKEq14gDuz+cdu1oGFFWPqSPAKJsrN3wt2paEliXIHQUx\nTnOMddSTCcN1th71udzkFTuAKcf0qlpUedw61BZjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmGbj/VoYNd2lbwVUQoovNHO1\nDmcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPbQVM27ucsagBbPfIrhwdmUDMoNxkapJF1b1Ja0wuzeAiA2VIPsZudS\nPsvGZMT3NIlWNR8hB3UuN5K9gSjgbURmiQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAaBz4nBA10cL2Y7ibyT/HkDVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I3M2ZiNmUtOWYwOS00MmVmLWE0MzEtMDE0YjE5NTRkNmY3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTViMmE0MjMtYmE4Mi00MzcwLWFjMTAtNDk0MDkyODI1\nYmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGmQoaeRbunGkPcHTlBEiDPIP\nO2zV1WeqzUNQV5byQlSCGwJWMlFH4bZO31P6DYSwMF8K/DE5MebbvU69RQDhH6OB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSNUiwqgE+V2IJj3TMyooybHuSbnTA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22FI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBch9r/FS1+NcYcJRzHaPIm35ZdB\n96ODDBZrkCoQDEyyAiEAkZCrIoQbUTvNxqyDDOsh+60nFC9ORzetKuNj4AbUf20=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9054", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9054` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYpxAGHtJKzJjFMuM1GjfaskMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3YmYzNjNjLWVhMmUtNGYzNS04ZWM4LTMyZTY4Mzk4MjAzYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzM2MGUxNDgtYTRm\nZi00ODM4LWEyOTMtYzllOTZjMmJlM2UzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkBG1HCvRzVJi6WMFgn/PzvtpBN81tW8ajkIfYDnAXNknyKoBq9jGZYaNUOyH\nV9WO3yedH75ouh/pMxYgPUms6aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBScW+xS4nkdJtkNdpEK4CxFcPsBjzAfBgNVHSME\nGDAWgBSRLYflGvdkBGOZYww9ZZvj+HKofzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIB9UKAnixcBLWYSbPKLhbcot4oJiVSa9\nnngqdBjb+S+9AiBFgc2ELVdEF4AdgSPXICEzqfwCqljkaXb+dFmCIVR5Gg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARsciNbF/eqkExlssZf/bWjFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nN2JmMzYzYy1lYTJlLTRmMzUtOGVjOC0zMmU2ODM5ODIwM2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATm/ElamJDEjhX1pLlqGqbJu9mCwFPy1whW0jkq1Dj2JPjQ\nYhi1+O6PPKr3/uwv6kqqZnjTTN2HWHpOuaLc3sfOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkS2H5Rr3ZARjmWMMPWWb4/hy\nqH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdf9fFb3UYzKOTk/xmP2KJWqTxnifvpgwhedXR+PVtqACIBYiqu5B83Jb\nQSaGSthMkDx+A400XkFsADECqX9ZEc19\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAS00edsg3LWINv9XFJRqXZaUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzM2MGUxNDgtYTRmZi00ODM4LWEyOTMtYzllOTZjMmJlM2UzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Y5YWE2ZTMtZDUyOS00MjVlLWExZmEtNjNiNzE5NDNj\nZTBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK+oeFv5x7yQiUWs3Hlb3ei8j\n0Fo5zNsg02FWM/Yuh1qXEepjtWgBI5v4w59Rq5CySEwVt1Alkq4YPt7TsPdr96OB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBScW+xS4nkdJtkNdpEK4CxFcPsBjzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22FI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDZYG/Ci2wxhdu5IYIsiVR0YQQj\n3jlTi0uEMM2DNYfjYgIgHlO1zb1/Vr1iHbdrzttHrRfs4oBGeNNg0/+RLa5fWQI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9055", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9055` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASoidUof/W9s/IzmFijpf+ZDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRhOTJmNjlkLTc1OWQtNDQ0Zi1iMjIwLTA1Njk2NjRjM2MxMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjA2MzJiNDUtNzlh\nNS00YTM5LWJhOTctMjViYmU3NGM2OWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzEigFg2hY0dKkSRvnTfPM8CXW1zCFGT0tzALG3jLEXIb6ck7UG3Ujp+HThvW\nFteFarDW5R0slVNQyZgXv8ylXaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3n2zwc2SeSnnClZabaQ3MyPCFAgwHwYDVR0j\nBBgwFoAURJW25p3xeq4s5f4ijj//aFBIDtgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCID+3Z2lryDY/NppBxCzitAm/dC3T\nEytUNC2D5pGkXc+4AiEAkjX2sI1ROLvKodDkCeRRM0VUa+YgxXpZ5AWJYbL/XaU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVjv6hhGvX2MAXd9pJTj8a4PMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYTkyZjY5ZC03NTlkLTQ0NGYtYjIyMC0wNTY5NjY0YzNjMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARX3iyvBoSaYNiIpR8Xkm+ldHS3rTwCfr8z/8moyyp1g2Zt\nSWVtaRYY40X9gVCrPkTuxJ9T1WNxOqeFWGiSPbc9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURJW25p3xeq4s5f4ijj//aFBI\nDtgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAvhKxiBrMIxd5v6GPqUctv09PmMzxIKEvgw09ZYmtmYCIQDB5ZlvGPNy\nsPTIVFwvHJO/Iz+fTvIRq5cdWdEHcFfSXQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASpNHMPgJpyhzbl59OwgHb5kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjA2MzJiNDUtNzlhNS00YTM5LWJhOTctMjViYmU3NGM2OWRiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzE0ZDhmY2YtZDVmOS00ZjMxLTg0ZDctOTFlMTM0M2Jk\nNjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzpeF83/DqyqXFP1YQWSgOdc+\nzn/Oewcoc79PNrfM9cwq6erlf65gXztcS/K59N8wbJEQ4NZgOkcleH9q7IwkeqOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTefbPBzZJ5KecKVlptpDczI8IUCDA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22GI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDXzE/4VPGoXGYmfc0Jjmk+F9qm\nA/HboFslcsnuHKx26gIgS7Lj4y2YpoV8A/DtA8NTSvTlK+GKuDujRqG14EoR9CM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9056", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9056` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAUfQ0HqaRUarj8ZWA45wwmuxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5NzczMWY1LTg3OWEtNDQzNi05MWRhLWJmMWE5ZmI1NDg0MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQ0YjlmMDQtNjVk\nZS00YjFkLTkzMzAtNzQ5YmIzNDBjYzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcBP0EK2BrU0jRRTWxHU1vCxD9EqXvzQt27KGRgK+YUafW3OWDxI77A+gR0+M\n5QAdC27DZwX+PWEJXbQZqp6JaKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT5/GFW0FwjaqqabzeT05AS93wlSzAfBgNVHSME\nGDAWgBR8chWdcjoTbeiunQkh1BGZJzrsCjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIExK+xMH2iGqZyASYqMmMEjqjwSCARIr\naw9KkGIDH6qTAiBBwqio/H1RUqLw6E5VFBv7BuNBnW+BRMKLN4WhD/RpoA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATDonZI3n65WHST/fU0MP1ejMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTc3MzFmNS04NzlhLTQ0MzYtOTFkYS1iZjFhOWZiNTQ4NDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQX6Sb/bEaBd9fd+j6t19MErFDtGc9zCJGQYUVQ4I8duOKJ\nOhEhlUyBVL0y+JfCy++3KfmWDLq6jVU3ejONVRf3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfHIVnXI6E23orp0JIdQRmSc6\n7AowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAICpmOI+1bwYGV8MYkFVRQ6zT6lcDsE8i8TuXGIUNSEjAiEAt9dYdipV\nmWRB9mm+yRlS47L5Tk2LZWqa3+Ay3njlDMw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQNTUogSRJH1iCh1gK9wtIqRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQ0YjlmMDQtNjVkZS00YjFkLTkzMzAtNzQ5YmIzNDBjYzk3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjNkMjk4NDYtOTVjZC00Nzg2LTlkZDEtOTM2NzEzZTFl\nM2E5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2XTxMEgq7aYmffcfwIKVa9Lh\nuYiW57eay7/5RfpBiD0xAU3qCjKgOdOhbJRS2/Mb5gCQH2LmJS3Pr4upzy+NHKOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT5/GFW0FwjaqqabzeT05AS93wlSzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22GI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDon8ugE9FJhfaJnBkL5zl39+R8\n5R61qGdLfKCyxZt3pQIhAJ3V4rkkv/Dv7PX11YA7xTxp/wgoe6D+FysYREVxOHPn\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9057", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9057` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAfZU55Ji61qoZrWeVDCsdcVgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2N2M1YjI3LTI5ZDktNDY1Yi1iNjcwLTZhZDcxZGQxNjcxMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDNlOTU1MTMtYjFh\nMy00NjU5LThhN2UtODg3MGNhMzJhNzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJeXAGaCJMjiUq+0mfjjeiMSa8AWJ7WB8y2eulSMOIFmA2Phr5dGmKklwxfKj\nCy9B5tKPatyM9jXjavNKfWTwBKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC5EaK3KOZTUcy9PKcb+tl0/b+fwwHwYDVR0j\nBBgwFoAUPb/W70AtaOCpS2QMlglJrseTjMcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDkLWJKlqz4CuYdy2vxZ41N+Ugd\nyaPlSFSNKwEfqUpNHgIhAOm/lGbRVX1UtI3hY0yijqY+hlyS+SrDxb65p+wKmQoI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATIqoWtbl1pazLk340fsoC3jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjdjNWIyNy0yOWQ5LTQ2NWItYjY3MC02YWQ3MWRkMTY3MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmd1dduGJZRFjNODUtX5Xo5sDnovP+Btg76LnOXdqW86bL\nJ5QK7I/AG3Z1Cz+Nl64ZiGq8tpd6qGMYpZngScxOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPb/W70AtaOCpS2QMlglJrseT\njMcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaRC6erFRepZFzIegDQa2Ih1TT26Li+J2078ORBfvxsQCIQDg1PxdmoWK\n5eqpNFZFBSoInJrjcMbxdk+G+ME2pEHj3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISARnPIGJtYNGnYMeFwVVSaesaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDNlOTU1MTMtYjFhMy00NjU5LThhN2UtODg3MGNhMzJhNzRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmZmNjhiZTktNjFjMC00MWJkLThmNjMtNDUzZWIxMzBh\nMjAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeQb9H1BvwWF3DVltlJQREhDh\nheRo253P4X/oCbd/DI6zZiOcKrzHS9zGxC5FmItQkHOVIoLNBh3tT6SJN8KxP6OB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQLkRorco5lNRzL08pxv62XT9v5/DA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22HI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDkVDEv30RrW7orMV+WPjsLSMx+\n0T21WDJd6AiiTvCKFQIgOD66vSODcKFGPxMtqVr+r35HqZ+lDcWbGvR7YrBnbSE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9058", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9058` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAS0Qw2Y57JfP4je61Yof3heKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdhOGVjMzc3LWNjMjAtNDBhZS04NTZiLTIwZGI3ZTI2YWQ3NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmJmM2RlOWMtNzE2\nYy00MjU5LTg5MTUtNDBkZDlhMzFjZDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXImCsW7qMIRAt14HVW9+rS6MR0tCHHkPCiihbqbWlkOSF/uqeMQfzzdZvj9f\nkBjrvFVATVHRCsuue1IXE6/fZKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRHihnrUqze5yh8P3A1KJFDAMoRtTAfBgNVHSME\nGDAWgBRgh/ldQYe2YeHQ13qV2RKOQS3+kTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAniOX+tPA1rsU5y6koJL+suwpLrdLgS\nCTdweNszIw6nAiBgdCcasiZEGl5LRXcaDYbVj39UFXWBJSPnVDnnLaV4Fw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfTkDI5x7B5tYIeazkPnLWWiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYThlYzM3Ny1jYzIwLTQwYWUtODU2Yi0yMGRiN2UyNmFkNzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARLOpVjDpsoMDonzBoQQiIzgaViCiuwKZc4BlHqI3HwgguO\nuBjqh+A+uiSiX0rasU48Gj9Fj1XBk52YggsoGGR+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYIf5XUGHtmHh0Nd6ldkSjkEt\n/pEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALi3ECV3E5dORh0NbEwgnQUQIvIn8Wh6B6cU8rIXz9P4AiA2IHhSLT64\nE+CxclfS2iZNL153qH0XXKRjqLIDglo0tA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWCQSIWXloP3hUcbRds5VDjWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmJmM2RlOWMtNzE2Yy00MjU5LTg5MTUtNDBkZDlhMzFjZDZkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTI2NzcyODQtYWY5MS00OWJkLWI3OWEtNjFmNzRhNTdi\nMGFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENZ9Pw7jhjbio3VGKH105w2Hb\niFUF8cLYTBa1U+udQ+Aks8LSlhyJCb0lycaZjwcEJiGU5/E1dAEEo2JJ/KsPhaOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRHihnrUqze5yh8P3A1KJFDAMoRtTA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22HI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD6nwJL9tPKpPG1VzdwH1UBqHOF\nmX+uek8gdUuoZXheFQIgJ6avhSl+SZtyoFIfF7NC1JSphm/vJCn3BKkBjuio/mc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9059", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9059` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAcpAuC8KFbQ2NIWkncFlG35wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU3OTc0NDU4LTU3ZDUtNDVmNy04NTJlLTk4MjM4ZDU1YjNmNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJmMjBlNDUtYzYz\nZC00NzZjLTg2ZWMtODRjYzczZDIwZWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa4pco7sNQvP0oCCMLM67YJpq0SzngRYP6vB56tz7RX0QoPJIoKCfjxIVmYvm\n13pEU8pNQmVVX3FPCORoDflF6aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUufZCt0waR1aQMLY6lOJf83SEjCAwHwYDVR0j\nBBgwFoAUmv0s9T58xeJw+CHkE6Q73+0wZKwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCs5bNIJ8ST90daDn0kK/W6B6Qx\nqfI0uYJTHjub6O0dxAIgUuTAVMxL+/jl8c2bJFqd9qB+/h75OW2vbqHEA+9anU8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZaLxNpUO/AK1xciL78MC999MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNzk3NDQ1OC01N2Q1LTQ1ZjctODUyZS05ODIzOGQ1NWIzZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATD13/KAQ3eFqy1c5btWN5gAh2WJiJUqLTPOCCJxqYLqv5a\ntGnveRi8bcqB+E4sH5Zz/mPfokILuhXuBwBIF8UBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmv0s9T58xeJw+CHkE6Q73+0w\nZKwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIbcTbGeszm6B0MitHzCDY5BLkAqH3XMYymMR8GGwucFAiEAqpUVWBdC\ny7gdWirV5O7Tn9FmMBw57rFIn0rWKcUfoWE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAdvJfttSl/CYTGnzqrYkQ8lZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJmMjBlNDUtYzYzZC00NzZjLTg2ZWMtODRjYzczZDIwZWFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmM5NmE1ZDgtMDgxOC00NmQyLWFhZTgtY2Q5MDM3N2Zi\nNTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEImhVCJkw7rw3Usy2i1gNpRQI\nZapn/9CaJ+HNsAowBt51zaerYames2pS+uOpy/wS9/2TZ5hbr5I2KLTmQeIWRaOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS59kK3TBpHVpAwtjqU4l/zdISMIDA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22II2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDeFe7bK4rblSbvNwu9YpC5YibY\nrDr8IoFjctNwKPPBKwIhANXc61N22JttmLSFKsMTvfOjL6n+g8U/Oyg8q0P/WOFY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9060", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9060` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZnC6izVENifP3doCDV4sq71MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmZDE1NTNkLWVmYmMtNDdmZi1iYzljLWM0ZGQzYzNjNjY0ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBhNGY2MGEtNTY2\nYy00MjkxLWI3M2ItY2YwNmRiOTFkNzNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3UXoRzVMHxTl5aTvEUX3pmgcgUu2K+Z5TOv69BIqtpw5+v1knOb31CvT9FS1\nkO+/Th4eBK5Wpl65/KfKY3QEmqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSv+xjA8ie/5AJhVOPCCO3IIVRBGzAfBgNVHSME\nGDAWgBTYfA/KUIXV0xopsnuze5PDYStNDzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAnJe8F8BbCofJaUy5lk/LvPaNpovQ6W\nrQruidZlt172AiEAtIwpKJqpS9pe8AwhM2E1Wv4UUflRJgYRsY2SRbr3Y8U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ5+6NHAEeTE7B+cHm93qTk4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZmQxNTUzZC1lZmJjLTQ3ZmYtYmM5Yy1jNGRkM2MzYzY2NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQreMUDIyD/cVf31zrTD3lzSfuvGDtkv3nJdZ7iSJEv041v\nTnxeyu7glRU8zpn95q1sMJor6u2FM7wft2oTFYnGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2HwPylCF1dMaKbJ7s3uTw2Er\nTQ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKadFM67ih8hOxtFM+F8oppQfg4DgDQjU9e/ns4IXHfsAiAGCrL7bwyD\n5hIfr3dT2KWPwQRdxwBZaigkslv/l2IBuw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQD6A4QRDHYX/HTlxkslOwjRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBhNGY2MGEtNTY2Yy00MjkxLWI3M2ItY2YwNmRiOTFkNzNjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzFhNDQ4MTEtZWVhYi00MDk0LWJkMDMtZDIxODgwNmRm\nY2EzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcxhIvESdrzvzNx1F9363A2GT\nJvvgvfGoP2YPNxdPSdoQUz0KBnWqkDwAfSfNUyFSA5L356hW4p5a2+ZK062hTKOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSv+xjA8ie/5AJhVOPCCO3IIVRBGzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22II2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDLl+KM/1tj+hRg3yjdXedUV0eX\nUtni4qZbACqau0wNPAIhAK5hsZ9nNjoxvFmewz/p7OzDwdjYU5rm4X4dSWsxeojB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9061", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9061` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASPsNGhhpy/eUrqC/M4mLM5ZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmZGViOGM1LWQ5NmItNDI5My05MTg0LWM1MWVlNDA5MDhkYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjQ5OWE1MmMtODYz\nOS00MmI0LTkzNjctMTFlYTA4NGY2Mjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/0isfm3FVrHF5A1V5RMHdanUCPcf6kCvwwYJvLUDHwYqGwbrT+40evRTbst1\nBTYUIF2eUH2nD5mt/giIEavQfaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1SjoSaAh2GKL6qv8v0wLGSZLC38wHwYDVR0j\nBBgwFoAUy2ZIgrmD9zONFtGnCFxzkHOn1jcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCfUXX25m9zmzkd1wchF7OYl+j2\ngkGsq6UpIpufnulwHAIgDGAX+wjOizaV9q1PqHPOLVCwGzil0YaHEWTc28rW3mg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAejd2ZsVg9A0JqsEnYUGng4MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZmRlYjhjNS1kOTZiLTQyOTMtOTE4NC1jNTFlZTQwOTA4ZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQaIOuyM1qkIyIUNV2lDMkwiym24xsnfdP4eaGB1nHd5RpI\ngNqdywLIKgkFErg+IrJbi4uoX7t5T6cra9UOSL9po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy2ZIgrmD9zONFtGnCFxzkHOn\n1jcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPWE02qjuxoAV4KHROTEFF+Cwib/sfsbXNu1prNxuJ44AiBbEv0q7ag/\n+83U8LL0jYbWu6qEBaqGtPxTJZtrTxlC3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAU9kdKtaL4oZBVb4wRJm9anbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjQ5OWE1MmMtODYzOS00MmI0LTkzNjctMTFlYTA4NGY2Mjk4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGZhNmFmYjYtN2JhYS00ZWM4LWI2ZjItOGQ2MWMxMWZk\nNzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE80xKD6TPl7iMVp6Ds7iVo3Vf\nlcU+ZeI43AuCXIYMeSI3kddlEoPfouDUy7Mzh93RVpovEHkriNmR1PK0pLzWWqOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTVKOhJoCHYYovqq/y/TAsZJksLfzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22JI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDTyygBtTv7VsmtLgsGn/EKnFcD9\nk0Lwd9iOVuoS2p3KAiEAxXc8wBrLah42/6P/cKrNmu/CxIVWsoPPQTmUXufYnpg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9062", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9062` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAapOYj+mq0nxnfESWT7wg4eGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzMjk2ODhiLWRhMmUtNGVmYy1iMjU2LWU0YzQ2MjU0MGI2NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzg1ODYzNTAtZDVm\nZi00MjMwLThiYjAtZDllMGQwMzk3Nzc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4QfxKG/j6hWJGMfK8EOGDrws/ARRmY6KwmsmJKqmqRitnKLQQ4tVHqKfAM/z\njP3JXqASDOc6GyzEQub2B4+J7qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQK4FXDTgjxOtLLv14wq81slaRp8TAfBgNVHSME\nGDAWgBS82PohDilyfmk+9e0vY4MuieqLlDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDp+j8moHEk1AQ9I/3a/qsajiTeDDzsB\n89+Sfl5UqXcfAiEAiQzV1+WbKXvAhHW6H51VHKAj4GplLwoQkZauAtKJXHM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcaXmfLWIbKGqwtJP68TPo21MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzI5Njg4Yi1kYTJlLTRlZmMtYjI1Ni1lNGM0NjI1NDBiNjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASra1YzhVhWorQjECaJgE+qgm5LyIbsOwYKN2kgkgwHhu9i\n5wWyfRPVdcTnaia91Rx2Ip7KV4lQ+8sVGyTmZB1po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvNj6IQ4pcn5pPvXtL2ODLonq\ni5QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM+GL99Vqg1xZDATr9ViK6V6qiWDWtCJISSiER/jbeQNAiAOCIq09t4V\nBAdUibshqHuQZeuvZFDrm2AZnjb2+UKudg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQNA4nVayY+mBEFuY5jK/N6CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzg1ODYzNTAtZDVmZi00MjMwLThiYjAtZDllMGQwMzk3Nzc5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTZkZTY2OTQtZWVjNy00NzU3LWJkMDktOWQyM2UxYjNm\nMGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE45Akxf3gnfmnmarJjEFgtC5c\nVixryuy0U05nrqpZB2e+tKKg1yyG3rFVZU46byiW4zLumXGZC5gvNAwBfMCD4qOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQK4FXDTgjxOtLLv14wq81slaRp8TA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22JI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHK98laLWwNdJIlY0GGa7WxWMX9b\n1FfPOdPZ0Up96bv+AiEAk/2fx7S9ITMevxPDumvv12+h4/4iXqg0B7LcnngTKsQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9063", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9063` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISARu14ko4KV4L3t3yw3ysE4DxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlNTYyMjY1LTQ4OTktNDQwMi1hMTBmLWI2NjU4MzdmZDI0MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFjODE2N2YtMDkx\nMy00YTAxLWE0NTEtZDlmMGI4Y2Y0MzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAgDgaZ8IKgxJfMJm/UtLMnVXPbhypEiW3UkEyZoDCL41LVO4LrmaQ/eMgrhT\nfiDgJKKPMYtRm0VAGeZNqKaXMaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOrNiXpK/Wd5kxmtZr549whExXJcwHwYDVR0j\nBBgwFoAUf1q1c0UdlijrYiTk+wkN1NLO1EEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIA6SagI8kBoSmMNnumccwO05HtbQ\nl8H4b7975tGLKsmlAiAEDrwPUcFhHiRzDQyrhhzrexPPNVLpLuFDWT2KtXQ8jw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeXnQhIDZLR2bTSf2W/MsNiAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTU2MjI2NS00ODk5LTQ0MDItYTEwZi1iNjY1ODM3ZmQyNDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARzYWBO87ZF9wzZjRvA/bsuHIHuVUhe5zkxXS8sucSvUZut\nLvagCOuK3+M8c3Rrn4BOpHZuDlccClebhKiNmlfUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf1q1c0UdlijrYiTk+wkN1NLO\n1EEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANqvGrC+lRl3veY2GY0GCzYVwfA/zgRcBJtdxpmk42beAiAE0nxcxuHJ\nMdw+k3+ANPalRNwdP9dnnotgHO3SqMr4pw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWvw8AS80ol5pKJWBgrR2E4CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFjODE2N2YtMDkxMy00YTAxLWE0NTEtZDlmMGI4Y2Y0MzBlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjllZjU2MjktZDk3My00MTc2LThiZjEtZTYzOWZiYzBl\nYTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuZ130WC/kPnWdGfaYYdMnMOo\nv3Vtey49IR4yTOsJkMQZ/AKLgptdqX+yRHMbI2pjii6gVKJ7+xP3wM949Hxx06OB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ6s2Jekr9Z3mTGa1mvnj3CETFclzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22KI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDPDx1ZXzWrA8y2JZ0pwMehJjfau\nu5EeFMF8qsdVnYMRAiEAmnzxUn9gql79Sgf1SIk9ER1N2JZQ/rUPLnElToi2xgQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9064", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9064` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAVD+ngks0eB9AwllFUAVGtLMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA2ODhkZTgyLWJiY2YtNGE2YS04ZGYzLWZhNzk5OGQyMjRlZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg5Zjc2MTQtMzc1\nZi00ZmMzLTkyOTctNTgxNmM3YjkyNzY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiO0Pc4j5/R+lQ9fgjQul1+fuZJb8Ejm7Nb6UwDenWVuouSn2hoH96zob1j4n\nt78qd3Dj0/RLfvXl/VT4xQM8k6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSkI+pEhvKMe8gAzNj87voqJ/ZuMzAfBgNVHSME\nGDAWgBSgLW7pOQj9MCzdXCL9dUj9S2+0RTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC9AB/2Jt+8f7UF9sBRoUJR0iAdC1cH\n3VypfJSxRCtWCAIhAMyKVm+9pCZpZ+gzHNVZ0vwZt/Lvn/OQ7nGQCchlwvjL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWoW3k0KEW1/rHJu9ckL42crMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNjg4ZGU4Mi1iYmNmLTRhNmEtOGRmMy1mYTc5OThkMjI0ZWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyOF16PIgyfXQ85YJWFLodjBdkqjUWsG9egv2wZvtpxpcm\nbMbgZlnxf5bC0ZJX3Jp40irQLSh+K25U1RnW+3X2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoC1u6TkI/TAs3Vwi/XVI/Utv\ntEUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWpKEYgQZBtUD52T10qFeS5l3k9pOdpFRYJXcnYuWNokCIATBIX5D7RRv\nBpvHPNGUvNSU56koIaEFb0XsQ2Ohqyym\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAf1HnpfWR/kQKbum3CJSEHEjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg5Zjc2MTQtMzc1Zi00ZmMzLTkyOTctNTgxNmM3YjkyNzY4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjg3MDk2MWMtODk0OS00N2ExLTk5MmQtMWI1MGU4YWNi\nMjVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE37+nKRMUM0aED3MvLbXq8VB\nKdkaEAqJuRpe2mp9sjaxJD+ag337h1jLIfiSyM8C2IG/zHjqKLF17ywtRiRVpKOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSkI+pEhvKMe8gAzNj87voqJ/ZuMzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22KI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDtwrqexuQCYw5dLsYeRcqpzvQAO\ntsFzeJzqYgKIDMfdAiEA6l+fZlarrIbULznkqBPo9hANcInZKe80WE5MP/Xl4+U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9065", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9065` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAbXGrs8Warp14OCHEe1mQfmLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5NWViM2EyLWViYTMtNGU2My1iOGEzLTFmZGIyZDU2NDMxNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODdkYzU3MGYtYjI5\nMC00ZWEzLWFkNzMtYmY3MWE5NmM0NjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnXrP7SaAm3XSLMH3832RgUa67/D56LckQrzQx/lRYvIOrxdFGHhKFvBE7n3C\nMphTzLlHs+jExEZG/NAA6B2slKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7CXLTBe/o3R5PQ9fmKSCdiCbr4AwHwYDVR0j\nBBgwFoAUlFpUY1OA13Ch6Fei376asaOzTwMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGJtBIe6mvt1DVGHxsh8C84Z1j8t\nMqDPSXc1Ttucr8TbAiAjQ6F0dt/Oh6XjdorFhJR9HPgtjZpgdm8ouwZv4TtJPg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYZPE/Y65L+3OHAHzfNUWsqdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTVlYjNhMi1lYmEzLTRlNjMtYjhhMy0xZmRiMmQ1NjQzMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAReflPWMyjZZeQrlbL7sfKjkcpnBgi5cVknY+MrFfXKI9B6\n0j6QBlG/JFfW/pLBiYu7My4trbBVs6EqzOxHgfIvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlFpUY1OA13Ch6Fei376asaOz\nTwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSS95gIqfKjHYQPPzzjOzt7VYL26aSsuOZRjGWhq4CTQCIAJtqBf6I4EA\nhrbrNOE5sHdZnvC8gSL4g2Um5TwHGm6k\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWgLMy283nx3BNJiH0p0ApodMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODdkYzU3MGYtYjI5MC00ZWEzLWFkNzMtYmY3MWE5NmM0NjBlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDJiMmVjM2UtYTI0Ni00OTExLTgwZDctYTdjZDhhNTQx\nYmZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9ir3+zXoi+gSISu5mf5NnToN\nsQccrGcEfDjhuXajdzavqee7xzKX1N8Es1NMQBFkeT/mpfuou5bOi14eqEeHG6OB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTsJctMF7+jdHk9D1+YpIJ2IJuvgDA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22LI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCZs1NzD/gAsh7IHnjSnNPIzxGs\nPTl8x1flV+UKa7wDqQIgazUuQuFhv7cHUe1zQKriIe8hXWF2hujLBFtEAvCVroE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9066", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9066` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATgxjo6lZwpDMbrsP6AO9kctMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiNDgzZmYyLTAwNzMtNGUzOC1hY2FmLWNjZWRiMGRkYTU5NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTYzMGIxOTMtZTU0\nOC00NjE1LWE1YmEtN2U4YmQzYzU2YTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWK6nC/AOC7iZldpfifBb0m4STFhTpgPXdcIRdA3/nRs9znA/L+VHL7vCLtus\nwTmvZWcKS0891jeVdv5h8GXI6KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSlKltPU0searqp9FoV65tEkXxD/TAfBgNVHSME\nGDAWgBSqnuywAUTsMZg05qCiYzyQJuWtADAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA3SPML/w0mg/D4zfzTX9G9RI11V6Jjv\nJbXklw6OvAONAiEAjU0r0QvisOZRGODB8qWfr2+PixEYoJE3ljItweCEk6s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX4FyWmfi3grtH8vp52qgM5CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjQ4M2ZmMi0wMDczLTRlMzgtYWNhZi1jY2VkYjBkZGE1OTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASAFTXkOZdEz+mG65S5dkKpcvST80cCvKI1GO+iq+juz4IA\nrGkpDSD+zXtHaIM0axkHazy/iKkUBqZM3GSs4Dr7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqp7ssAFE7DGYNOagomM8kCbl\nrQAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO4IiysPMgFN6oKl2prW4dNGGDlZ35/acVakvHS/yhETAiEA6ydNMBQI\nUn9/G3ELpJeKgG3X6hE0vITu8eQETHbNlGY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISATrnCsTchSDCN65QboOxs0FZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTYzMGIxOTMtZTU0OC00NjE1LWE1YmEtN2U4YmQzYzU2YTE3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjZjNDY4ODAtNGExZi00ZmJmLTllNmMtMGJiMzVlODNl\nMWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOnzci2wkAnw+s7Os1zPMzynI\n5fOgIkhktvwqCg0I86VpjL9L4CukPCwjM6u4ZKt4kZQVI7Ned8mY/TNnN+06EqOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSlKltPU0searqp9FoV65tEkXxD/TA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22LI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIC3XzjhFKlWck6tzFigHOzFWwVY8\nrNNSQyjU/MguU11bAiA2bpJdMhjpH7lz4heEGXUE7H76sXMszQq8DpIfvfEKug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9067", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9067` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISASZ/uAN6p4L66yDooCZTYOPqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5NzIzOWZlLTUyYjktNDNiYy1hN2FmLWE1MDlkYmFlZGZlMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdhNDhiOTUtZjNl\nNC00NmI4LWIzYjctOGFjNzdmOThlNWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEI5N2fyAgCGdwMdllvffM8GnNRHtfZ4UAkTNzTq9fHdLgKQbkjyrCCT2s1cj1\nW8J05Kt6q2sftz/31Z7XpjapvKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbZ4kVzaw9kWZKgeZD13H1ZMIBt0wHwYDVR0j\nBBgwFoAUjSyfVjyBynGexFKTWwuakx6N/H0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCRhMkAgnStcJ+Vf9bxwwZ0t0d8\np7dfbJsBY75z4VsPigIhAKU01jp0N5yKPGpvbDqAuC8q5PGm1c9tO0IgbOdwgHHz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVa8yXDXD4As+GVz5dboSP+nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOTcyMzlmZS01MmI5LTQzYmMtYTdhZi1hNTA5ZGJhZWRmZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZgN5obSoKSl+7KkrQaHRPuv1EbTnDbuR/4fKgQ9QCkkj2\naYJyBoYPuumyGE1LT81uHlOmV3yc3L7QTk904eFZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjSyfVjyBynGexFKTWwuakx6N\n/H0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVjLEXn6ZTrlvUAoOJ+roGXOfCRGmEebnRnGiRbnE428CIQDr8tRuH1gT\nDWniVI7xxEFpYJ3MC2hJxxc96DJ1RTrA2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfE/F1v0/9IoytvmskSy/lIUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdhNDhiOTUtZjNlNC00NmI4LWIzYjctOGFjNzdmOThlNWI2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2UzOWZmYzYtODAzNS00Y2ZiLTlmNmQtNjBhZTNmMjli\nZWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERbvjVH79fg1k4o+Z7BQlYBSo\n8yA46PL+Ic2gxRMXvq7zoLpqUR8xDBNY+K5Cm1Q0TIcLFO7Kmcw8kIda8K3nJqOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRtniRXNrD2RZkqB5kPXcfVkwgG3TA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22MI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD3nz2JtO/gSPIiamSPylmwTu+5\nI/wUMXqLZmzQjn17ugIgZyqo6Y5SZ4Hf9PKWw/jBr+lkQmJ8aVdQCzw+W/S+Fi0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9068", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9068` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdsm9MhzMAWbh+Bj6B4mdVlgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5Yjc2MDQ2LTFjODktNDk2MC04ODFlLTA3OWU0NjFjYTFhNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA2ZWIzMjMtNzAw\nZi00YzRlLTlhOTYtOTE1YmIzMGY0NGM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGSZCKtPzavXY6QsFEWv0XqxaUuAVpSEtG7puM1O7ENVc6113mtUXH4Rm7eHg\n977jyArOhacUWJV7CDZyXQ0clqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRKE72/L9nevg316u4eiDqavCC5GTAfBgNVHSME\nGDAWgBR51Tb47GIbqQfmILGOu1AqW0S6zzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICUPDUC/jYnVvTBi9hdIlWwcvsCpe6zW\ninZ8DOwkn0odAiEA8GcQyKvaVtXztuwSXgAOzGgz49OYdYLecq+MKRw4HcE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWToGPWtVM7Gfwn3LE05puZVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOWI3NjA0Ni0xYzg5LTQ5NjAtODgxZS0wNzllNDYxY2ExYTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATE83Wm0D8WLf37Ein9uZmqFbaDitx8nIUzpeki6xID09Np\nJXimGEZqIPQ71jLddrnwjFEUl2cqV/NcRExtHh9Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUedU2+OxiG6kH5iCxjrtQKltE\nus8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfbof5SLH2W62RUmbtI4bsJnm1qDPgHKUYTpQ99e/NkICIQC2lht3F5Lf\nnKOGOYEA0PKxYOZ7H5gF5th8vI0YzLXsLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISARAvhZg3GsaKWc3huQARpgsSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA2ZWIzMjMtNzAwZi00YzRlLTlhOTYtOTE1YmIzMGY0NGM1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDZiNWY2NzYtMTQzYi00NDZhLTkxODUtNDk0MjFjNDg0\nZjAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIKBsznjA0TuHAk79f5IP2MDy\n02rSFj41RXV+DR/lJyNnNhouvimc7hsMevWNpeQpRD//Ty0LGLdpxUqn43ZtlKOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRKE72/L9nevg316u4eiDqavCC5GTA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22MI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGBJ9KQMve13Coim6SvI4dsaDhm9\n+feGbLKBcB8JEbbgAiBEnFKfak/UIYeVL1HGW/1iHd1oaUMBJMyj3MwxTQ+PEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9069", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9069` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYSh41orqbUp9VIRDGO/ZaXdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5NGViNTFhLTg2ZGMtNDE4ZC05ZmVlLTZiNjlkNTY3ZGQ5YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2E2YTc5ZDctYWFl\nNy00NWVkLWFlODUtMWFlMmYyNjViYTVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqVio6Hkh9C+RYWlKRv1cfAHXL21Id1CfHAq8c0su1fkpnckOoYcHGXSWcHVw\nfaw93MYOTu64xHqcHVSfmIt3qqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl8nI0x0v4mVnNcWcNVnZcrfPzXowHwYDVR0j\nBBgwFoAUKj/Mtk+5yFbi38ZBszCoDy1qWeowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGQwSjJ+q5cpLooEuWm0OBmMd6uo\niwqXn90XcUMyWXA0AiEAuH7fVJqy5eaB8LKNpv9TE1FO4i3I/o0r/A/t2XC5sDw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcA3zsDETyX+JYtfJQCN+wdhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOTRlYjUxYS04NmRjLTQxOGQtOWZlZS02YjY5ZDU2N2RkOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARV+1mQpRc2puhyXjobqBqfrIffVO+SKfDPQFm8OQKRnd4d\n2iT5Mc5eOIEMRnh+ym9lQFAOcledRBwvxA6rGKOCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKj/Mtk+5yFbi38ZBszCoDy1q\nWeowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMeHYp4t7hDy9ld2OIkQzmEPguQFs5d1ZZV3FP4g1guZAiBXzJdgB/mQ\nSdiT/cM2UJSTJoLOpp0zxH1wlicl2jxedQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAR1/AMRlQUq0O2cfk4aM4s3yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2E2YTc5ZDctYWFlNy00NWVkLWFlODUtMWFlMmYyNjViYTVjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmI4OTY3ZDAtOWUxZi00Njc2LWJmOTgtOGM2Y2RkN2Ex\nNWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHS39SVhCY1W9J9igvPWlKw3j\nxXB4rLEZ2jF0EucCmOGG9IEpqbje8V7dOnclrFJrcO4fy5pmiTdFG3+g9SKG+KOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSXycjTHS/iZWc1xZw1Wdlyt8/NejA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22NI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDpaMGZpdmPG1yaBKHFKxmkY0np\nO6fU0+SPHeEtzDJeNwIgMiN2DuvATtI10dpJSQNecHQe7A30Zv5mkKuPIn0bHpg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9070", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9070` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAeImI10Czkiwz7gfLiBqz150MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzNDY2MzNjLWUwYzktNDAxOS1hM2Q4LWNmMmNjYWRhNmEyMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTUxMjA1YTQtMWE4\nZi00ZWJmLTk3YjUtN2E0ZmVjMTE4Mzk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEabvaW7Fg+Kpiwck9wzS3R5dtrP5yMAS+e1x7lnh7T+qndLa0f6wdhFw7XXC5\n/Mc8PuqtcIUMqrRgezCrfltf7qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR2/FIjyj79Q8/eZskuTlUbE9VvFzAfBgNVHSME\nGDAWgBSOKaSF7PcRBo2LZpolIkuE//7lETAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEGJCnC0dXSlSwq10XQfLiEVyl1JeUko\nLV4bYYkAefnsAiEAqKj6lPmw04L5H2I1AQlbhOC37Br/vlR/v1b/h6XVbW0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZFs2KTv5vTfUi/a3VOjttApMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzQ2NjMzYy1lMGM5LTQwMTktYTNkOC1jZjJjY2FkYTZhMjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQyVH+kOqEiajOH3pIxa/Z19B8ShJw3xguzkCF+xBBdgGVP\njjI2AHBpapyoAHJ+VhEds9UTVvLOuUMe+i+TUY0No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjimkhez3EQaNi2aaJSJLhP/+\n5REwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZoR4j4kQP5BKJSVw3esAUB+0MngjvygkxOPWBEZvDaoCIF2J6VXE04gT\nrpk2pTejk0+KrjKD0q55dvPr8gaDW+lT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAaYBvwqN0CD4LF/svMzyGsgAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTUxMjA1YTQtMWE4Zi00ZWJmLTk3YjUtN2E0ZmVjMTE4Mzk4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDlhMmM5ODMtMjAwMC00MmYzLTllN2YtY2JmYmI5YjFm\nZTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAGDLV40/DG4747meyY4iDQd8\nZDvNauUfwn43fQisdObuAbEsdfojQbQsQ5lVzNlmkSezq4b9B2G5R/6Cl4JxGqOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR2/FIjyj79Q8/eZskuTlUbE9VvFzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22NI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCGe/hYqwvf/P68WWl1LW8/4Igt\nXsLovPbzBkeE/F52lQIhAIymYxyf/UCzkS8qKEqcsKXKhtsIGdQktDcoFFXgYmvs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9071", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9071` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATRhZctVX4SXR3BKM8QcCniGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJjZWIwODY0LTY1YWUtNGNhMC05MGYwLTk5YjQxZWQ0ZTdhMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjZhYzIzZWQtYTky\nZS00OWRhLTlkZTgtYjYyZWI5NTk2ZTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgJpG2zFDq6CvcZ4zZt8CODf0YoHq7yVWoMh8d6G9YQO6C01rz8SBzs5TDLrM\ngpiwn1vMevP/UQIT/sVS2v6yg6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUgZllOlNYjSeo2DcZVYiWAXNh84wHwYDVR0j\nBBgwFoAUQOdJ6e7oo5mQ1Pkux9AiQtawHaEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCSFb5kCKHxKEivu8nre+o0ZPA1\nBoHOzUWmd1eU/zyfNwIgcr19S2fAJNt1SIgLM5gBdkUlIjT4bAbJGwC6XsEGYzY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeav65oEuQkV0RSBJOZpEnxlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nY2ViMDg2NC02NWFlLTRjYTAtOTBmMC05OWI0MWVkNGU3YTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAREgApGKFZwNSGw0T/a3vveh4aaB1Y4liMhK3dUxJNiA8H/\nsvl5dUXre7SCbd497StCrIqdZ7Pq7QlOJ+Sz8h4mo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQOdJ6e7oo5mQ1Pkux9AiQtaw\nHaEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOVuOQrHTM7lx3brLdR2lqxN3bQgEBR/lNA383mwqkV/AiEAjBSDcVQ4\nYGxl2lIicAgN/lMO8QqVkpe37Gh4N0Zm398=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAeJMXi3vo9xJr23yStK0/k7hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjZhYzIzZWQtYTkyZS00OWRhLTlkZTgtYjYyZWI5NTk2ZTNlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNlOWRkYjAtNzZkMy00YWQzLTgwNmYtZDgwY2Q4NWNh\nM2QzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl4aCURELBtSs/x/aiu9HgnkY\nRlNrF/zfx0CpUq2YC+WdnKiorHWFOLSDQGGs/AANhL5TPBV2tkRaPfh2VVsyDKOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRSBmWU6U1iNJ6jYNxlViJYBc2HzjA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22OI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCPzO9MAQ7p7fj+wix/QaFx7duR\njefi7Fs91YgcwJDXxAIhANFUsMvACtlgr9VY//JapVl+m4Vza4/SDHCvZ4Nv3aIF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9072", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9072` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAQTvf4EpIfQlE8BIezyCYnDmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4Zjc4OWM2LWQzZDQtNDBlMy04NWQ2LWFiYWUwNDNkZDNjNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmRlZTRkOTYtZDU0\nMy00M2YwLWE1ZjMtYzg4MWRjYTc3ZmJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8j8z71BVkQgzw5az2ElXg2GvHQHOoHBWIpm0HwA7DkayDSjxAT/VxunIChY0\nRsu5b9QHelsTcB294v1Rmd2ZhqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTp5hj3V/vq9Zsk7l1OBjomNlkZQzAfBgNVHSME\nGDAWgBRGXBnyrdALVoOacskrZ+bfD/rIrDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIH1LHiHxttWLCgTg+gGjXQmnl8m+K/G7\nLsD9yhDQOZUfAiAWkEV281MmgitexrGd0Txu6r5t1edlWBOa713q8JnHrg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARgHO+kw45OaqPGzryQ5Pg/xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGY3ODljNi1kM2Q0LTQwZTMtODVkNi1hYmFlMDQzZGQzYzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHHM82Z60fSWZe5Qkth2K84JD0Ap6HH+tmgO7Gl0xLqGZ6\nc7kfgreoH4M1qqmR1vQvt3KKF2fKyo/sQHbaBTAqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURlwZ8q3QC1aDmnLJK2fm3w/6\nyKwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgT4Qq2LkDqs6GZfKComF4cg5T3BM+J7diBaHjLpmRXOYCIH3uKd3JT2bd\nQX60yIn0jVNraRWSSUCUtB/djyTF7ZVW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAToxAV/E32A4uuUEnt0NFfi0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmRlZTRkOTYtZDU0My00M2YwLWE1ZjMtYzg4MWRjYTc3ZmJiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzc0MjNiM2MtYjU0Ni00NGY2LWIwY2UtOTI4NDYxNTBh\nZGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsUnl1jXmykUfTUAWt9l+jqTO\noskyhZXbq3vE6RsG6XEcs1DtM9e94A9wO+gdINPx+/bBOa6w9CJb/9YqwTIu16OB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTp5hj3V/vq9Zsk7l1OBjomNlkZQzA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22OI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHuCp/imFpcItmpWC2z317WRVXO2\nnEZzQbfqV13g10gtAiBuYXFAwwrdJ32KznWAPVTI5uPkJPazvdwsG9Dipj7suQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9073", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9073` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAelChn66uAoi9wNjdIZTdNXQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3NGZiOTU0LWJmYjgtNDM5Yy1hZGZhLWFjZjA2ZGRmNGIwNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTdjMjExMDItZWQz\nYy00NGNlLTgxZDAtN2IyMTczMzdjNGQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDihM28SDkdkF4F73i+d++hulKhN4AZ4KEnSUGKPUzKUC7pL6X+MfG4bn5S0U\nJUmi6QqQCithfWLITaQukmF5yaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYyB87t6BrWubGwQJSgs9k4chxxwwHwYDVR0j\nBBgwFoAUidELqmiMcCthZ5xnXm0ZMFhJlLkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIH/KwPl8i7BUWI/H+v6Y4CI8l0Hm\n/O1a0UPueAo/GC3qAiAbha5Os25tBKOvS540lp+JdhVKCvuo0uM24wZdx3LhCg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUTI4LGaa2E/7S15vnKI8ATeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzRmYjk1NC1iZmI4LTQzOWMtYWRmYS1hY2YwNmRkZjRiMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATcnisGcEIrBxv0fIwOtzlhC800EyOsOLyrIaC3lUbyfP/v\nvPXpScgCOcPN312Iu+eJzUyKOFbW4iZYNFzMgVW2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUidELqmiMcCthZ5xnXm0ZMFhJ\nlLkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSZSWDSOlb8q4KpTnmLSHQGPOZlDaTQ/Ktl4Etp7cYZQCIQCceR/QyYPW\nHpG9qQ0Bz3w/mdEG+jDWDA8j6EPAcoIjtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAR0gTmllDZNFv3cnJWbB/VWgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTdjMjExMDItZWQzYy00NGNlLTgxZDAtN2IyMTczMzdjNGQxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzRlNDBkNjctOTk2MS00YzJiLWEyNWItN2I1MTVlNDY2\nYWQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsk2wxyyMLwJXI/glbKeMCsWi\nIrhdKeJW8IYtt3oL9wysYDddh/WxdoMcTsG52bRj1tTxyaajVvGZ7A61GLOMMKOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRjIHzu3oGta5sbBAlKCz2ThyHHHDA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22PI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCOunnlemTch/5NQubvfHHQHXU7\n5BKOTu5e0YwQts7NFAIhAJMiLDMvh3DJqqn1BESkiZJZUwh87D8BA+QiT26DPbjK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9074", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9074` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISARNjv6o1TWO0MB8R/hzERLY8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1MTI0ODM1LWRhOTItNDBkNS1hNTVlLWYwZWQwY2EyOGYzODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU2OTc5NzgtYzRi\nZC00Y2E4LWFmM2UtYjM0MTRjMzkwZDQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE55WBZwctfts0xfHRD0K/c4rHtSWsLvYq8N21kkvqqqyRmuNU/gZznL7baIfP\nnqmUX/snb7iFbJVOb0+WicsRBaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQSDv93/15+zmNkEPSBPavaY/zp5zAfBgNVHSME\nGDAWgBR+xorysPohjIvClOKeFrJsjFDWrjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDjxeuLyyirYO3Kitkq5n4yKo+gLSiS\nxYB0apdBHvIyYAIhAJqYEaovLcFOsC5VES05wXPgnkULEBWY+EFzMaWRV0Fb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASttMNjzt5ewZ9pxiWR1YC8wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNTEyNDgzNS1kYTkyLTQwZDUtYTU1ZS1mMGVkMGNhMjhmMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/j0BgtQlGkMdujMVuaJhPH91cfVzc8mIHT79yXeuumW3j\nnI5P+gR2HfvucK584VWuZY3AHsOe/eunow84ftKao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfsaK8rD6IYyLwpTinhaybIxQ\n1q4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAME0kpQtbvo8J0QOmBB0bc7waTlv/LNyMhcsnSI45maQAiEA0vpqGuvZ\nREKMJD1wdJcHmRHE4T5OXF2oFXw8SdVCFKQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdSicKKo9cEXBbRAhM+OepxCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU2OTc5NzgtYzRiZC00Y2E4LWFmM2UtYjM0MTRjMzkwZDQwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWRiNDRkMzgtYTkwYy00NDM1LThhMGQtNGRmMWE1NTM5\nMDljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER8vxCfCm+Mjqga1HdBNdzb4t\nxryvdNglmNefpyGqa/Demqjm20DI3m2g16yTOu/HA7fEh0Jgxf26F0sSnj5PuKOB\nmDCBlTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQSDv93/15+zmNkEPSBPavaY/zp5zA/BgNVHREE\nODA2gg9iYWQuZXhhbXBsZS5jb22PI2JhZC5leGFtcGxlLmNvbSwgRE5TOnRlc3Qu\nbG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDypkCG89z3DXEz02Acbsy2U1e3\nBUGXzwIaJZW2rOIMnQIgYeeoqcGgkDG0+nGBTfenrxRp6EZHgVyNSrcWKjD5u2U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9075", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9075` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWMY8CrXTy239o5IX6JrODyeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiNzU4ZWJkLThkMDgtNDQxNi1iNWZhLTc4YzI4NTJkMDYyYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzUwOTE5N2MtN2Zl\nYS00NDI2LWIzM2YtMDU1ZDI0MDcxYzRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEugokTzSm7YFwCwRF/D0rcj6JlUJuYr2BUO57cXZNqfTkCrWZjT6pdrRyoFs8\nEP0AeI6LC0IRy04lI4+Y2CuJ26OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTc9vnJ6hVvLmpRsuQy3eaTbyfAkwHwYDVR0j\nBBgwFoAUu9WAe1TJdyQLsKtf8MaE4QMgAgMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICzb1bJ4+ebSqQk7SsYyIkJVUCe7\n8XnzaqfzckK30SXoAiEAoQetU8hDdOZNzc3jiQPRek7IRkB4PvyQAnY2EGJf2oo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdZgm+Aq8JrtKiB9vpnWNMUfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjc1OGViZC04ZDA4LTQ0MTYtYjVmYS03OGMyODUyZDA2MmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5B3/phkRcEPephP0sbp7kpor3S4QiR3inMrM9qsNYAkRR\nD1L98IpfivYYYWzPCqgUDRCJeAPu3/67ilDQvs0to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu9WAe1TJdyQLsKtf8MaE4QMg\nAgMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdTHRnd7MQYrtHox1sqMf03rsLTG63Eu5r7fYVLQkGgcCIQDT586lNc06\n4X3l1R0aotSOi8m/nWIfLSoWU4qYcyfXUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQzCCAeigAwIBAgISAUvi6KvbnDBo5kwqiBV/Ga9lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzUwOTE5N2MtN2ZlYS00NDI2LWIzM2YtMDU1ZDI0MDcxYzRlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTlmZWYxOGQtODM0Ny00Nzk1LThkYTctYzY4ZTE2YmM3\nZDRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/OEvabRKpUd8CRKohcTm8FCG\neu8YSmoPpAQI8se/qoGbLYn0q6qJiw9NtF7BRUKL9X6aHW6f/JeCfAfrkGwByKOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRNz2+cnqFW8ualGy5DLd5pNvJ8CTBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22AKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAjtLtvYnB8TIsQua9\nwpGPwKUz3XtoD4Cruu+LdpKslmoCIQD+r7mbaOawIH5QH8ojetrGdKt6hkmlfkAS\n92PvIHzewA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9076", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9076` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAT/0V/d6cO8QjgYbab5kK5LRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NzYxNzBjLWNjNWMtNGFlOC04Yzc3LTFjMjc4YzRiMWEyZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDlhNDQ5ZjAtYTQ1\nMi00MmQ3LWIzYTUtYzRkNTdlYmNhODQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERBKSMQ5VX6zFITCfg7KyrFmiLDgLi3XLdB+qw4qHE+Jx0MXdFtfhIIIM6PPS\nxm38sqs0gRhlefmXb9LiEl5WzqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRxrwu5TuQWui5F9mK8VxVXktS7hDAfBgNVHSME\nGDAWgBSkExZ3UcWItFobmxijNldjSkA/zjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDcP9mENmY5a3wCYfs/5BRL2gnJH+ha\n02yoUOzXXh7fTQIgUvblFtYdblGV0AmG0bF7e0IshMd54Mn/SAhqU4oVx8U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUJ6ZtQ2f5JUgWp1nbMqCN8cMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTc2MTcwYy1jYzVjLTRhZTgtOGM3Ny0xYzI3OGM0YjFhMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSz2XcBIIbbqVPX6+HjXzSTLBelafOzIgmMRmrDzFu8G5y\nmldZZAJgIEzC+WoloQ7m3OS1J4C8GaaptcrH4tcAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpBMWd1HFiLRaG5sYozZXY0pA\nP84wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFteOFsEOr9IvqQLWKrBB3iEBHsUUM7VJMAt37k30L50CIQCCs0p0Z3uT\n1GIzdHwxP3IqCjd12jLCNBY7PBkkHVc4fg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISATbCWw9xL+ZYZlqClH/G7GDdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDlhNDQ5ZjAtYTQ1Mi00MmQ3LWIzYTUtYzRkNTdlYmNhODQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2JmZmUwMGMtZmJjYi00MDczLTg1ZGEtZjQzYWQ3NzIy\nMDFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKKvJlmQ6dkGyinghkpTElYSb\nsGFGHANBOufKV43MB3mWnLtKhtEAGQe5G+ywu3zqcIjl0XPLLxTyzgjW8WHIi6OB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRxrwu5TuQWui5F9mK8VxVXktS7hDBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22AKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBTVNMtsLlk2iunuZfK\n0Ro76vOvkbtyJSrsEjq7UZuPawIhAOW2Te/Vie+jOuOfN+uAC3UQY9V+tHPa8xR7\ntOa+IPui\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9077", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9077` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAU2lE/Kz7u+GBwxrmqmFVBfQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0ZTAzNmI0LWQzZTMtNDQyOC1hZWI0LTE4OTYxM2ZlNDc5MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQzN2QxYmItYTYy\nNC00MDllLTk1NTItZDE2MTczN2ZjNmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC3r2ljmBT2LDfACy+q/4HJVLRxf+NfNi1AB1hYf7OV+VkMLdTF9z5kSbr1zB\nWGsGXEDrzXmQOmrssG7yOL8fqaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtAa7A0/nnNH0C/cYq5bfU8U0kVgwHwYDVR0j\nBBgwFoAUlmAwehHnZKl7brAGAOXrzI6rolEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIACUTtL2qwgCI3hto0qo/u/xgABV\nrlhTsEhiz4OAB+InAiAnCzJ49shOuBtI0OWSV1qQe8/p2TEVt91QU2luLUdcPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWJbBn1be4yyj38YTd/Bws6fMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGUwMzZiNC1kM2UzLTQ0MjgtYWViNC0xODk2MTNmZTQ3OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShPcA54SViYt+gWdIFDr9jtmjYZowdKAIU3l4PCTQQcbOx\nBSmoycbevcdqD5Vbhg5pJxeaKXZJqFpeUcy0xPBIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlmAwehHnZKl7brAGAOXrzI6r\nolEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZUhkEu6+TNKamue9LZQHjC4c75RA8l+Gj/Ml3cuv6B4CIQCqpsCpJ8cS\nVyL39luFaa3tB7R9LFZ8odRtSD296X1bPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeigAwIBAgISAVUlcZTIJcuJAttBMQCPuOkUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQzN2QxYmItYTYyNC00MDllLTk1NTItZDE2MTczN2ZjNmVlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzVjNzcxNmQtODFiYi00ZmMzLWE5NDctZWY4YjdlY2Yw\nYjhhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdQ0H1lApQq2A2Gu+Pr1V1PAj\nxgighUmDqnqj7zJhO5mqCG23T7BnqxhqJ174GpPwKiY0f86aYPh7Qnpr3ZgvMKOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS0BrsDT+ec0fQL9xirlt9TxTSRWDBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22BKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBlaf+Ln3HtlRXUPnYF\nwkwihsR6xg9qVBvTbgisR3kPhwIgG8cHzdzdCkpI8Lzkn9ygS7DnvG6aOY05Evn2\nCzV/DU8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9078", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9078` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAb71HxTQbiYi0vXQ/r4a5uarMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5ODc4NDgzLTdjMzAtNDQwZS04MDAxLWI1MzQ3MzI4ZDJkOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzNmZThmYjUtNmNi\nYy00M2ZlLTlhMGYtYTBiNTU5MTc2YTllMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbRSyOZQWAUIy776Ssua0PJ3t4GRc04qOsIxhcWJyrxeh4pM+tvePw4KDMrvE\ncPEBAgR5u82f98sWTirDo2PYt6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQJIO3X8C2ZEZ3GA8wdbe2ktbPKbzAfBgNVHSME\nGDAWgBSZtGnXDosxZJUgmmLDjJpLP6APiTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIH+DDZ/zGqclaNBFWBfaedVq9Y6YlkRh\nYwU0LyfkuXPLAiEAygT1w8e6JI8OwsDdJ6eqsK1UeLersPAkwnDgRrGPxKM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfdE95bRI31r+BpZ+YImVQW8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTg3ODQ4My03YzMwLTQ0MGUtODAwMS1iNTM0NzMyOGQyZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASGkOV4775ikN8onIGY/SVB+qkCDqiQ2L9TMsPVeJCL19JO\nevtHmSHNogYk+NcyfrU8N7YKcj3/ZhOXcBOpQfkMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmbRp1w6LMWSVIJpiw4yaSz+g\nD4kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAr6mlRGQynTgP0/PrpqQGVGtSk3XPbO5OGuXf3rCY+ECIED+IkGIHZqR\nO84nsjdmRQSjQZZ3JBccbaxU3XW2VmV9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeigAwIBAgISAVWaK3+Cr5qKfxyyBrJaVxlcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzNmZThmYjUtNmNiYy00M2ZlLTlhMGYtYTBiNTU5MTc2YTllMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmQyYjgzYzEtZjkxNS00MjQxLWE2YWUtNTJiNTYyNjZh\nZDFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9GvLEja9eRwnZ+JHwKIZJBR9\n1EQeYtXOMuTz94ZcLeTPXXUizw/r5VLjPRFSVPer5pT18f7PZoFDaMFCwbRXG6OB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQJIO3X8C2ZEZ3GA8wdbe2ktbPKbzBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22BKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBCNlpVRhvtO2CPE7rc\nPDtYaTKcbL2zOKq4Zt4iJIFRlAIgF6xWkYkLTXS5IDdVRc/3b8si2Vq4gr1gD1hn\n1zvH5CY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9079", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9079` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAVY7WQt5z4q+dJNIPsEfR14iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3ZDExYTY0LTMzMDktNDA5YS04ZjgwLTI2NzMxZWNkYTE4ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUxMTVhOGYtMzk2\nMS00MWQxLWJhNTgtZDVhYzhlYjVmNjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+XzaR2MBtP0QWUgDJENW9N0a56aZTfb/HAe/52+b/ddsPv6Bt05nPYIaX0c0\n2UFJS/4u0b7yPDGye+0tBoBuO6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6bUS29bqCyYiA9nU/Fx+DhEsHJowHwYDVR0j\nBBgwFoAUPbSuEJzm1HZ8M1/6UvL0azX7JcUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCbcNCaKRRLQK9xDT/npDTGNUdF\nEgVwKwG4/Du3jGwK1AIhAJHvQk9CINw89nnjQ9GQhFv/4lBfH97UrUvebV1sLItC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWPHTzTCcfgm02Uwjub7AxlGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2QxMWE2NC0zMzA5LTQwOWEtOGY4MC0yNjczMWVjZGExODgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgIEmtlNR21EzKZJ+nMLyG2WuE1w/wsqk6GeNvXy4k1t0M\nT2upmLR7MwR6duDz+WTSDxo4kMetXtLPyiECd2HNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPbSuEJzm1HZ8M1/6UvL0azX7\nJcUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANCtkXdLxGoHf5NoUU5dpphX4AotieIEKgkhTsoUNt/nAiEAxpIcGkF8\n9w9W8yA9wHqatES4ye5lRChCBczevX5Y+mY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQzCCAeigAwIBAgISAWB1gdZetJBF9jvv2E+kbrFzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUxMTVhOGYtMzk2MS00MWQxLWJhNTgtZDVhYzhlYjVmNjUzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjBjZWQzYjYtMjQyMC00OGJjLThmNGItMjBjY2U4ZmQ5\nYzBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXN+Q2Z8/A4qiNkc3JB2BwopX\n/fmzamLiksv8W1d+SieMxX0dXtqcrj5AV/A5EWDswud0bSU0w8JCBvI2eLBjlaOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTptRLb1uoLJiID2dT8XH4OESwcmjBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22CKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAhF0tX4a4Gs65BRa+\n++zfNS9LU2Ad337DSWvCBRazQ/gCIQD/1fRq8HuC/qgY7IdDbREm4EEerGkIADUr\nLJtrd86BKA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9080", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9080` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAfmpaYDCO1GWzDvzoTqnTA2gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5YTk0NzBmLTg3MmMtNDEyOC04NDJhLWYyZjNhNzExZjhhZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y1OTM0MTUtZmRm\nNi00ZTBjLTgzNzMtN2Q4NTc5M2E0NDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9FzDt2hBlpNz/et2Xm/1udmST/SdQy4DhyiPkIS798G9k2b1M2+JA2OYgH/I\nGDpPwC+W7iaT3KP1S3BUkSitjaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTqa84ro/KtU5hS+Yal42UNrCdRcDAfBgNVHSME\nGDAWgBR+rFz5NmqdoyPYgg8tpSMtvp/hWDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCWvc5yTSiLhPYNuH3wBIdEyEOeUWOS\nNzRhSA2PPttljwIhAPIEOScDxgq1I2tgS2PdjR13MPV1VAGqCaRGua3rlK7u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXawBV6LloMdgOeKSzq4DEyeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWE5NDcwZi04NzJjLTQxMjgtODQyYS1mMmYzYTcxMWY4YWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASOXk7WXrERHmVHENNoRMnlp3WgJyhjIL7iWdzpqK5dg5Ic\nYVqVrJtJfOXz09BxvIXCTowAPXaZjJKMjCqbdqh3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfqxc+TZqnaMj2IIPLaUjLb6f\n4VgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPsr0fpIUxvcz9od7cYz9q8kdU+b9s7jSbm7CnDIXsizAiEAzZ0IyCoY\ne0Q/SHAJhOFig4BmhFZTnICdm2zXLfrWjRs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeigAwIBAgISAXag2uWLu4XoSZrTKtqF2vNFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y1OTM0MTUtZmRmNi00ZTBjLTgzNzMtN2Q4NTc5M2E0NDY2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTc4M2YzOGEtZWEzZC00ZDE1LWIwNzUtNTEyMjc2OWRk\nZjBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEisDmfZukhLQYAI1CZIl5nWGE\nrYaXX+FTdutfpMolMGovrboOf7tfw2nK0Lw3m6mW5V+6CkVZSBP/cvw08ThlgaOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTqa84ro/KtU5hS+Yal42UNrCdRcDBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22CKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAyQTRSy0n6hlza/XSq\nWfZzv2XyLP2/fdvPtFraigYxLQIgJPLRmrNp4ZkMnTXi6FitRYkDjJyAWKBTDRyw\nbstliaw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9081", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9081` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAWY4jZaBbpz8vrBrNK75SX/sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxNjMyMmQ0LWJlYWYtNDVmMS1hNDYyLTVjNjg4MTE4OTcyMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDUwNjAwNzItNmE5\nNi00MzYzLWIwYWEtZWZjMTc3Y2NhOTYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Javi99mAgh3K2QsLMb9QUbrxwyjak6X9Hl97p0s/kseLIivYvFCbookpeuI\nne2hHe0NMm9qqaq74OM7MR8mnaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9QE6UKBx9tm8b4LMAtJRuNOwfY4wHwYDVR0j\nBBgwFoAUon1IJ7vhC055Q/QyPAqHfr0QPpAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIExS9cBGOr5AlYiw8nksCSJWatBy\nlh6NNC+KMs9zb498AiBcCcS7WnE8DHRua8TOe3cFG/50ON93/oYcXO+jquJ5Ow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV/TOoMIkLm08+gQjkHMm8mCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTYzMjJkNC1iZWFmLTQ1ZjEtYTQ2Mi01YzY4ODExODk3MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIYnivBXObjSVKvdBrkl8Qu+/HUjFM0Oym59CGFM1nNZ8O\nP6phImskp4NKuEHHrNDducJzwLxxGl59oc/PtfNho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUon1IJ7vhC055Q/QyPAqHfr0Q\nPpAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALubRDhJ4jpVyU9rgaWdnB3TxPgnc7QKqhzkZaENvUWqAiEAtmNtRGQW\nAg0avB8AT5kdCwmeht4BQR9KBhQJjC4PLfY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQzCCAeigAwIBAgISAQ8TFfDIPduKrOS3uHay13JsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDUwNjAwNzItNmE5Ni00MzYzLWIwYWEtZWZjMTc3Y2NhOTYxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGI3MzM4MjMtMDg2OS00YmMyLWE4NGEtMTNmZWJmYTNi\nYjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE57vfyJnTzsKigFUZeFKdWWlx\n14BPkXxPjBHE4s2qcTR0LmQP1PpEEDMrkf2IHDdFv+rX+frIsLhApgumbZA596OB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT1ATpQoHH22bxvgswC0lG407B9jjBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22DKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEA8xa5+Z1k68tMqo2i\nufhMLDzZNtSof1ZvKg/4Xw/lHIsCIQCu5MW+A2LDcCl/A9EPwSzQ6wNBGZH07rzZ\nVYg1saXjTQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9082", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9082` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISARk9OgKuuz9+N7Uroqq67lB9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5MTZiMjc3LTQzNGYtNDQ3Yy05NDhkLTAzNWU4NGNiNDIxYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTQ4YzJmZDUtMDhl\nOS00OWVhLWI3OWMtY2ZhZmYxZTkxZDBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEnGQqlelxLf0/pB/RVkCAOP5pca7nXJe6mbysnk+V4F3+4CcmBJZcr4Fjbkk3\nHb202mioHH3d5YwYhOJmVMhRNKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSJ1maWUXSgi3lX3B5D+RrozJWOHjAfBgNVHSME\nGDAWgBTCZYPJShFNiYG9a+BmqpKYlyhWVjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICUyk9sS5yNcMZ5KPjZmdhZZQaWxXwr4\nQdIhZbTp9YwJAiAnkDCJXiRn48+UUkuGil0h+IU7SzX6khnKxIju9jWqpw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARQ8A5Lm+HK7TjNtzaKNXB2NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOTE2YjI3Ny00MzRmLTQ0N2MtOTQ4ZC0wMzVlODRjYjQyMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATeWpugUZIVgf4AgrF9PhazC+ZmoRocfmHwwIYi3ergis3s\n1ETIKj7naVLwD7EyC771ZW3BPRpf6Q77LO6WeZfbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwmWDyUoRTYmBvWvgZqqSmJco\nVlYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSwTb9NSg6JVTeT1AHSxN7/wotcSe/VvI2XWRL84Po5QCIQCPfQ8PWvFC\nola7T4JtMKVL+Mr0y0k4eOVUOUdcJZe9KQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQzCCAeigAwIBAgISARTHnlBUDY/qXTyxHWi/YpQBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTQ4YzJmZDUtMDhlOS00OWVhLWI3OWMtY2ZhZmYxZTkxZDBiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGYzYjYyYTItNWUyZC00ZjVmLTk0YjktNzliMDMwZDQ5\nNjE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELtXbHau00fkRgTpYe8Gt0d83\nY9nENAdB38rEqWs6qcuVFSWYhqVFCeOHK0jwytCXaFS1DpL2DPOf42pQbqtmTqOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSJ1maWUXSgi3lX3B5D+RrozJWOHjBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22DKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAw0Gt+IwLbBejLZVY\nb2KOHQXKHk4rbUnkmDSWYO6j7SECIQDJ/luRCX5cOq7PpPauN4dMS42d6CKPNK5A\n+ysQfojc1Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9083", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9083` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAcyXP210Wb8SiNWwbrvGWVKUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyODUwZTk3LWI5ZmEtNGY0Yi05MTkzLTk5YjU0NzczODc3NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTAzY2IwOWItNzU2\nNS00NTdmLWEwNGYtN2M1ZDMxZGFlOTRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHhJzhhrRugG88K77jZpr4HW0S0xAgr+MBs8Azb5QTEsl0U9uF/SJNse2mENv\nQAOVAwtmHCEdoSZ+vqty4EA5WKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMkXDjUVUA9L7vfjmvY+T66kBuOAwHwYDVR0j\nBBgwFoAUMu3QPzs6lI2WHUCIUUyxWEsRKlEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQClgBaePE0MUl6gcCELEM0iE2GN\nf0gVIA/0uaUFdp3hYQIgbR1xbytL7i2bT0xe2jkCWKCmTRWOr9ffIQVzs9e3D9c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAe7RuHf9P1p45aYK/m8/kFqcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMjg1MGU5Ny1iOWZhLTRmNGItOTE5My05OWI1NDc3Mzg3NzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKOAhiXjSV992qPsfrWXjU2K3ige0oLzZUWDIqHAkHUazm\nvuT68WT4gDRjeV9iN5ctuOc8U+OQuYdz/bnVtboRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMu3QPzs6lI2WHUCIUUyxWEsR\nKlEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgPU1wOMuL7jM0A+f/aAazSzZl9uU9IO0Oa3jFo3omHoUCIFvfEv2fFE7p\nyDkIhW1kGlWa3oKCQTyYQSdfw4bEy0Gk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAUAyMkO708H72o8uunF86gM6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTAzY2IwOWItNzU2NS00NTdmLWEwNGYtN2M1ZDMxZGFlOTRjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTM1MTg1NDUtMjY4ZC00MjQ4LWJhODctMDM0ZWJkYWI3\nYjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcj2z2elZL7hP1Xhan/65szgT\n0nXDzXj+ShJhLV0cMsY5EcRS+o6PpJWtRvGA124cZdUHYhIiW0dYZz958lrrdKOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQyRcONRVQD0vu9+Oa9j5PrqQG44DBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22EKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA0Mfvyw7N0KuPBKFY\nK7k/2yFYodI6IovxhyuHxtl+yKUCIHPTsDbpx+01cjfbkp2vQj4OKhAlOPg/6SWR\nT+RU71sg\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9084", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9084` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAc4ikIPKoL6N+iCf3/p9XADSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwOTc0NzlhLTEwOWEtNDI0NS1iYzgzLTQ5NzEzZWIzYmMxMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTlmZWQ4MjctN2Vh\nNi00MTg4LWI0MzYtMWU5MzQ5NzExNWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKmYejLlzyJW507Q0wIUN4q5oR/0KhbRa2ZDxGxkq7pXdXKlOdlTMOkaQs7D8\nXLsNHfUN7NfsR7xa+Vfwekrxp6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQl+UiV52K1OEx9YeJsZC2LGo87bDAfBgNVHSME\nGDAWgBTl2g4Jngqdaic+aR2NZd3+Jm/wbDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD6rSMPCEJQva/g/FqSGVMYsJktjMiz\nOQs4k87E4l0qkQIhALJTd2+Ai9XgDoQVyFpU0vsBNGr4jcl8CoCHmWRdA2CO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXnFRZsjoAfiwhz0vIsOvx7JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDk3NDc5YS0xMDlhLTQyNDUtYmM4My00OTcxM2ViM2JjMTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASX2u0+NdAsgX79/Sytz5ArowsbJjfhnIoMoJ3UVegi1KMi\n35sIx2CvwN4GPSCW1I3SzsVhJXFzwa+KirGaMLuBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5doOCZ4KnWonPmkdjWXd/iZv\n8GwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDMeJXTuhFyi7qglawoqEXFbSxh6ZKsDzVFBztjVHaoACIAQDPPSYYKne\nt0M2k9UVLqZhztURiGWWmH5ZwgDGAS4Y\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeigAwIBAgISATpdUFAXtXjcVb6BbR0LM/vhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTlmZWQ4MjctN2VhNi00MTg4LWI0MzYtMWU5MzQ5NzExNWQ3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGRjMDIyMmUtNzkwNi00ZmEyLWJiYzItODliOTQzOWQz\nNDVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIgiDPQmvcIhUe056GG6+GSSR\n3mdhOuc/LvHmd7MhaL4MvBLD5vcuSkpNiH0lTa6848ShJ3rFiKnbo6pdl25cUqOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQl+UiV52K1OEx9YeJsZC2LGo87bDBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22EKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAnon5DkvvfRfcgx+C9\nuUngFjBlMjIWDVmymZe0+gJITwIgQwKheX/MjqBZu4LjXTk45P6dvd2PugrsG27V\nuVRKxsc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9085", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9085` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfr9LX6Z7A4ktjTxfcMiUV5rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4MDg5MGJiLWY1MGMtNDhjMy1iZGYyLTVhOTAyNjk3YzQzNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M2NGNiMGItMmQw\nYy00MTI5LTk1NjAtNTlkZGFmYjBkZGJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5z7uhuFJfr/J8Qqw7zmWh5hYu6/rRibH/AyjCzsc4KEKkiL+bHdcr2kubdIN\nMyBubppwKesRjy5c3RRZgfZKA6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu6Mbm0F4RVTVZ2YLAIWtnDmCAu8wHwYDVR0j\nBBgwFoAUDnyVux9oqpam2v6bSRD4btSoBGowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG2Xhqcwr/ebzahLAtqoBLE9edmk\nFFz/ierbEZwTVvzIAiEA+f+apL4w5fePlf5eCouoaFN/YAPeHSA10PBNPIa6veA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdxkZSyze1JLRRooXKQV8sQGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nODA4OTBiYi1mNTBjLTQ4YzMtYmRmMi01YTkwMjY5N2M0MzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0p4DpDmKpygTFkqZi9EAJj73e40lbW6jVvjwi9tDtERRc\nkD1YHjP5Z6jBFKiE46tA0uiko5ZtrlAewK25M9gho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDnyVux9oqpam2v6bSRD4btSo\nBGowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANVKzV/D5KOaJOPXORsnuSeus6flgI4VR+zpqGVUoNkwAiB6TN2gY0NE\noKYtGCDtjIRsYqysLWwrVUpkKo0Yjbj9Ww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAaM2tO54wSAKxuIHHcEez1QxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M2NGNiMGItMmQwYy00MTI5LTk1NjAtNTlkZGFmYjBkZGJjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQyNWMwMDQtNWUzYi00NDA1LWEzNzUtNjU3NjBhMmIw\nYTQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuwdzpmB+HAZjQSQpgf5bcf7A\nkXGJMUPY5KBZFaUtb8rYSphaKc3m8iuudm08XsfPsQmnYG9YKhVb57JxnB1GSaOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS7oxubQXhFVNVnZgsAha2cOYIC7zBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22FKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAh8r/sJnqqXbza52a\ni/MeVNXNjOFd31Hc71QVQQCA+uwCIDzuqsaUIRmLz8+rCi5G+kCFTnO09K7iDr5W\nwe8Wd4v6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9086", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9086` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAVr7Jc/EafCgrvCQC4GnIDnCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlYTdmZWU1LTVlMTgtNGI1ZC04NGNjLTdkMGE2NTQzZjI1MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTNiYTg3OWEtYzE0\nZS00YjFiLTgwMTEtMWE0NGU5MTU2OGY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETisraUwxH9tw/UoIWKnWjDjKyJS3FVSxa/BJzJDyTBt6iHAAs0s68Crl2jcn\nDySe793/LUtJ3CTxFgL+iu/ghaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRUeLDsFhnJ56b/8lBB2ntVftpQ0zAfBgNVHSME\nGDAWgBTSO/DGM1YIuwrvtC5xPYViTntlozAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICraE5UpNonCehp7PbKOtxGqgsMb+hTW\nlGKAvxH8RMghAiACwkWW3jBPL9abdLLfx1Sh8Bh22oyt7A28TLf+1+1V9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXX09nKshubWgH+8H+idtLvEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZWE3ZmVlNS01ZTE4LTRiNWQtODRjYy03ZDBhNjU0M2YyNTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQR5051wv4YSOZNCEQaeDjudwXcEDdeytdN95jv7fPDE+C1\nJLcNChAIwDlMFK7g3JihxWNRUxJQv9jjDNYOyRwFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0jvwxjNWCLsK77QucT2FYk57\nZaMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYSYXBn9cNeIbkQw+PtssV5URN+O0XGfBaYtn7XLJl04CIBrwjhW9xXmC\n86pjx2o5omkIMLL9DhQOKNoZPD7SA4CS\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISARMrkkZdT79rP5sOFq3bNqBXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTNiYTg3OWEtYzE0ZS00YjFiLTgwMTEtMWE0NGU5MTU2OGY0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzFiYzFkMjUtZGJmYi00YzIxLWE5OTMtN2QzZDY3ZWNh\nN2Q0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9r1mul8XHKhvQ6s1iQek8Miv\n8VktPqKzdpL4ZqAYNwMkYHwXkibjP1rbCb9StG0+/+TqWD7RJff8pHmHhHpu76OB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRUeLDsFhnJ56b/8lBB2ntVftpQ0zBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22FKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAnNEYv41VO0p1CejTb\nmzLdttx70Bb+aCnJdtPqRZ2wAwIhAJS1DHhtlRPgY3s9Y7NTzSnkE1y7PPtpRPZV\ndnnZV7D9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9087", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9087` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAVIKvtP6t70rLQ82VtP1lPHCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjZGIwMzY0LTViZGEtNGQyMC1iZTkxLTk0YzRkNzY0OGM3YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjdjZWI0M2UtNjA3\nOC00ZmI5LThkOWMtZDUxYjVlNTU5ZThiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESRSjUaymu2/lHw2HGejo3g25uKC1a6whyXVDge1JswLendf586bXqSK/9UAr\nx3ki+3SYXs5PFZNnkBi6t66ZfaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0p2Lg5GjJ2d86pg5QhwZ7Tqoxp4wHwYDVR0j\nBBgwFoAU61llCSxvetuwS2lwjuTXbwulltswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCV+l26jI193lK9qETemWYig6Jl\njSKozcu3Se0m5J5N4wIhAN76f9Lm5hKFeT5N4vIWwwBOmc87EwR4Rew6RuZhEmih\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQxEvJrJrVqfpVB284aLrP9FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2RiMDM2NC01YmRhLTRkMjAtYmU5MS05NGM0ZDc2NDhjN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVNyEzgupzSXc6UTq5D5JHGqQPWDnLwc5AKsreDL33u9f4\ne9Hn3V6OeEe2HovOgX0P66RniQxFx9Y2Yw2eC+2ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU61llCSxvetuwS2lwjuTXbwul\nltswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfOYPNrh+lgFf1HJsLQZF5ekFCOB6FAb7LMDULmWSMrcCIQCbSd31swt+\nrgVr4hLCFHMf+Ogx125G/iZiCFcpDt5clA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAaU2ARwRObgNyliHQ1gNGK7xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjdjZWI0M2UtNjA3OC00ZmI5LThkOWMtZDUxYjVlNTU5ZThiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQ0MDM5YjUtYWI4MC00ZThkLWJjODEtY2YxNjg1OTg5\nOGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1wOcvQ3dDrh25Pg5HFCtlpUT\n+tR/IV/3D+A+OgbCQMIcdxW9rqSAz5Jc++Pl5Zpt8ivCyZsO0ey25Y0M48HmRaOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTSnYuDkaMnZ3zqmDlCHBntOqjGnjBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22GKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA3rgVxZTiPukxpU2c\ntWxkZDeASPFHL/tFKqohfVJMFO0CIBKF7gE8k+bAx4v1N4Mo2ztAUToXeLWmDP5R\n2e/JgYsB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9088", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9088` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATE/qBXBaa+b3kaxXtWwjpyRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmM2Q1MGQ2LTcyZTEtNGEzZi04OTdmLWFjMThjYzQxNDQxYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ4YjIzNTktNzlm\nOC00ZGEwLWEzNzMtMjE3MWZiOTQ4MTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0o0EntZpiBsY0n6HCqMbjvNSNtQe1Dgetzw39FfeEsztDYVmJ/jURcN+ndf2\npsi8KNc8LR442vws5gbSDYrWpaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQke7yWTiu2G5JEXAVwFqq2i9ug4zAfBgNVHSME\nGDAWgBRU+qxZhOO73zznbLT59TqeMVzRqzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDNjgyEAUGGYOcfc4zdXvM8Jn7S5ANtk\nNqk4LBNtouKlAiEAsJ027GSLdhY7v7GSZAP3tEArittSBWhJk4ylHVnEroM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYZD4NL4E8uTkslZEOhu37F2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjNkNTBkNi03MmUxLTRhM2YtODk3Zi1hYzE4Y2M0MTQ0MWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUkiyOjf/Ctqg4mOyQfH7V5jz1vFMlJ4YS+TQ+pNhkWTgI\nuHGBZQnV1bi2sgaVnOJsrYqBNEWsHTSo/Rco5YRuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVPqsWYTju98852y0+fU6njFc\n0aswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeehaQ3lHfQC/+vxbiO+ibYMqLvqZmmKvIh58KDLoP8YCIQC1IGVeUnoh\nps8BkUQbY7f5oT/13fe7E1721pDmjIEmGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAVfI4REig3Z7ZOJVgyokrzqcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ4YjIzNTktNzlmOC00ZGEwLWEzNzMtMjE3MWZiOTQ4MTFjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjE1Yjk3YWUtYTQwYi00MTk5LWIxNDctNDIyMTNmZjRi\nMDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEivLhKI8IjY8NAhSSRDKlPeU6\nt2/jNb+rqcyzWNBI+znZXkXOXZaFMjF80y2ylGADtM8CVJ37e6A5x0ikL9EtYKOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQke7yWTiu2G5JEXAVwFqq2i9ug4zBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22GKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBgSoe8uQHrgXmgZVyZ\nEn20D7ynuJXdXwtXcZY9LSUlbQIhAJD2zuSTXHJ/Y3PCo//19Jf58Bv1PWSNOmsY\nJxnfpJHV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9089", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9089` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeGg8/wzvaBi8Wpq5yVrOEiIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkODJhMTc0LTI5ZTYtNDYyOC1hOTAyLWUxZjlmNzA2ODE1ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk5NDM3MjgtNjc2\nMy00ZTJmLWI2OTMtNjYxMzFlMTA3MzU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/mWFm6y71F0dn7g3AAvGi7uOEth2UKfAZe4vtXXKEh40nHgjUuN2091g1Y3m\n1s5jC1drLjkUyPnmhJTA+r6+H6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8nscA4JEEvrtiQg2ILXaQQv85L8wHwYDVR0j\nBBgwFoAUCcs8StfoVLLX6UMRmy/QCAD4x8gwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHypITqhzbfriioDee3f/mOVojbc\nhkT6lu57oJ7BPgKLAiEA7rcA0X+mXji0JdL+yeLeIfPoV6YJq1j5j2ay+jNB9Do=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATJJraoJ5r2xZcriNof4S29jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDgyYTE3NC0yOWU2LTQ2MjgtYTkwMi1lMWY5ZjcwNjgxNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVOHzGc6U5v4oPYz/6fiYAKh2FOiNdGLGm3QJjEwJwkrvo\n1fQIZOrYSdmDAtTT0T2MIWJ0OUZXN4dB0eBk1k5to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCcs8StfoVLLX6UMRmy/QCAD4\nx8gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJiqNZCzfvBH97Vsm/rHunlzhz+T6XbQrCwIJ7tLR1bZAiEAniyfLia4\ntGuib74u/fu4Y83N9tt2w6QfdXb73KZ/lCo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAXk2Q0+pXGYrqmU0tKP7UVbEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk5NDM3MjgtNjc2My00ZTJmLWI2OTMtNjYxMzFlMTA3MzU5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWQ3ZWQ2ZWEtZTM2My00ZjA4LTgyMjYtYTBhOTBlZGI3\nOGY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGTLi2aPEZ0Xdgsi6bhqXVXsQ\nMlYLkVWlvpWW619Cbqm7sfKLH1++K82OKctg8atbhNR0vXx/4ILrdZKPtojVLaOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTyexwDgkQS+u2JCDYgtdpBC/zkvzBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22HKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAxk1/lSFKsqIN+4Mr\nQ2lBELqzXcN+xRajyH9Y3gsqO/0CICq4Oy3k9KexEmmEpBWCpQVQbA1aJOl+ngQP\nt7+h9+ex\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9090", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9090` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASbuRl8T5gVuH6eQgPzk5zRwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM5NDdhZDU0LWUyNzctNDQzYi1iOWE5LWVmMGQ4ZGI5YmE4YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODE3MzUyZjgtOWYy\nYy00ZGYwLTlmYjktNGZkZGIxOGQyNmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpLcd4Kyk/xuJ4ZLgG75hbWrKRB1QMDdNJkrGx/8LYkWr9OMLYaYOTFNY7LkV\nSImz4vnrEcEgO80x5RfIrTOg9qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRfaruOeNNtU22iggAikb+eWKwrazAfBgNVHSME\nGDAWgBTjZ4l8q07FcJpDey4Z+X4Qf5jiWjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCQXjSbXnuPGCByhkwG08KSBnX/uwYs\n6ew8GTPLugOHbQIgFVdFLYhvl40gZqbdv25hTewqVGS1WQhzGFu+wlC5ZDk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVik2ZjFSHkfAcAtgh7epVhKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOTQ3YWQ1NC1lMjc3LTQ0M2ItYjlhOS1lZjBkOGRiOWJhOGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASN4p9tuyxibJWqfPFbCPtt3knVvDfeBecl3OdH8+Y5hlAs\ngfLgI3Du9gwg3dlsW9d+fj4Dqcn5yNUFd8/RDqqFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU42eJfKtOxXCaQ3suGfl+EH+Y\n4lowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIXOUhGtiyDVuQIhV/O2lbngV8E1UCuW8LDdjH0Xnh0OAiBbTyXnqj7O\n0Uv3Y+dO05JaTqn6z5TQ9H+6Rpr82HCxtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAZ8TXJ+2AGiLWdclVTJHRRTkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODE3MzUyZjgtOWYyYy00ZGYwLTlmYjktNGZkZGIxOGQyNmJkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTI2NTkxY2ItN2NiMC00ZTNjLWI4MDItNzg4OGY1ZWI2\nYTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsKcptFtQPbdwO4xknRiJXabp\n5nSsLXRL754eVhuVvTfqTox1SfsT12gNNuBshbyDZE+G0/+TRzeJxXIdLIcMmKOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRfaruOeNNtU22iggAikb+eWKwrazBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22HKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAtVvquAW29AHHBL5Y\nL20Awv66ZPcLatzqwEEB9If81RcCIACCwHS5+PlAcc3H8aN9tANYlLG87y15E0YK\n9Eo/D5lZ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9091", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9091` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAXcMiQl+a3hlfUP5dg3OElk5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhmN2Q5MTE1LWY3MjEtNDFkZC1hMDlmLTFlZTM4ZDhmNmNmYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWJhZDY5ZDQtZTI5\nZC00MGVjLWE4M2UtNjg5YWEyMmU2ZTc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1rfy84yi4wQqvzb7TYSGyWtZoIISaKbtYWqkY5EeCCd0uzyUZDUGaQLK18BV\n5zN4ZbvlxRq7+8HzckyUfaEH6aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnf2Qa7gcO63uePkgCNQlTNPd/30wHwYDVR0j\nBBgwFoAUGmhx/+29nzmJ9DDjtPTyiIe6NCwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAhi+c2pluzlPLQVCCmAhPQ8NWZQ\nsUAIiWAp0DDpF4+zAiAR1xcFAoxW6HpZGMybkSQazI3EMl704kqP++QsdiF8aQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbXme93rFD11mjCcroT/AZFFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZjdkOTExNS1mNzIxLTQxZGQtYTA5Zi0xZWUzOGQ4ZjZjZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQXghU4lSo/n5Fn3oe/nWGumRVE9AKdITXmMq17tj+W8O7U\ngaPiBBSY3cBOtiPh0ZKeSovoWzg4qfYagGO7VQf/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGmhx/+29nzmJ9DDjtPTyiIe6\nNCwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ7OAjpq6lh98YFZmiXBH451AVAAX/PXY4Qquq2KvWkAAiEApjEfMJp6\nNztFbrxepsdZviGYT+7M+cip4MTjo4AAk1g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeigAwIBAgISAfMZg+PFTLiZgCAXBDp4LuOVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWJhZDY5ZDQtZTI5ZC00MGVjLWE4M2UtNjg5YWEyMmU2ZTc3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDFkMmQxOGUtZDk4Ni00OTY4LWEzOTYtNWExMTY0MzU3\nNjY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKfDeDc47U0DIlqZ+px39mQ04\nyC0qarLfYsdmVpXh74AOpQW5Ak6rUzW5PWTGqgR2l0NGEX+QDbgcbQXSHHr28KOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSd/ZBruBw7re54+SAI1CVM093/fTBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22IKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAoSm1rCyUZJO5q2SPU\n5TqrZO7rzpBd/vfC+ff/YnNa6AIgMQCEXs2J1j1YtMi/BTXp6s2uzIxt6fsuzg+z\nAQmFYh0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9092", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9092` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWUpzxtkilCSoqvZEta7iNJwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzOWZiNTg0LTU4ZTAtNDRmNi1iYzQwLTg1NzZmYWI3NDFjZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I3YTFlZmMtOWUx\nOS00ODVmLTg5NmItMDhjZWMwYjA2ODE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJeDazv36b/8PKCO7JLNtk/WoLumHN5NpPI3rq64U/nCbnIBZbRzPfoL6Z+ti\nShLma4tTdzJ3pKEl+QMOoODvZKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRtISDE6/mYIFHcI/w2X9f0BfgaMzAfBgNVHSME\nGDAWgBQI6rp8uXaGxgdQbpyrLBzeR2SDBzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHuXJCZUTyLnQSN3nSa9QLqXFAZuLPrW\nczE3JVpLWu7dAiEAqg/WggYBQVckp3uR8mrZhonDxxm/Jx3bZjf7p5McGzY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASxz+R0PwTi9XDLZZfzsEy59MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzlmYjU4NC01OGUwLTQ0ZjYtYmM0MC04NTc2ZmFiNzQxY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5Angr8xmnT7++7O/h501SkF0xicphykyl1foP/scWwTjS\n+UH2vizZ+AnlisZbISuWyVgpTknalMArR/dn8kh3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCOq6fLl2hsYHUG6cqywc3kdk\ngwcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJF7lpdoejX7kSyhCZLOhbRA95/1FZnnD96zR8Y4QVezAiATzfgzVOJd\njMn6p94d5WC1hhcnD3b8pxigDZXtmLhMng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAVEJKjAnLG2XwGaSx0QrUjL/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I3YTFlZmMtOWUxOS00ODVmLTg5NmItMDhjZWMwYjA2ODE4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTM1MzQyZWYtNzZkOC00MTlhLThlYzItZGNlMjFmNTRl\nNmU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfUQKtu+6YTsYjchwgwvva3Rz\nem5dtfcdVIJ5+ga51jlHknInmNGoMPySxTCit/ZW2fB2OK9E7yqBILaTRTGIhKOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRtISDE6/mYIFHcI/w2X9f0BfgaMzBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22IKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBbA5S17eF+PXPHO7Q+\nQO8MDrCyomMCcNxckic6D7Wf0gIhAJ5AaAW2MUTg42aSl79JBQueRFAqIjf7GDGu\nyakFPN4j\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9093", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9093` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQ92LPploNqeZqrgd5/8Q8A/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5NzBmNmExLWM2NzgtNDBlNi1hN2QwLTY0ZTE5MTI4NTZmNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I0NjQ5MTUtODVm\nOC00MWRhLWE2ODgtYTNiYmY0YTc5YTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo9iJntfC6POYVd7Hikq0VAxFxSWGZWqdULE0AesmbdoOxL4EDM3wCpIrHox/\nJCmoioqDQNkX144NnTnxIh+dQqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkI0fIZzAcZEbqHpd7bZglXSccnEwHwYDVR0j\nBBgwFoAUNvyE7COy5tzEWNJ5jvcxdHZ1Op0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCHz9Pf7WhNiYupyjf/RLZc79Oa\ndHBi+LCXjPvZgN6lBgIhALKBtfR8QBuWNWngBZdX+L/wkXwYJIjhJPt/VGdtTf2b\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa5UtziW6xNr9s4DaEu/ocP8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTcwZjZhMS1jNjc4LTQwZTYtYTdkMC02NGUxOTEyODU2ZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS82x6YQnXcbILdS7wyzT0RKWDPyYR+4opFlsf4iQFrDcwR\na588mPcqe5pqa3UE4gOWHfK7+kigfmUmdLeWg1vao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNvyE7COy5tzEWNJ5jvcxdHZ1\nOp0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgQT1yKklvcRAudeU/z4NMXMSLf1pI7AHhlqdvhrriZCsCIQDGy5svIdwZ\nHXJ2O1+4IuIWqQZVbZaiTYVI0TwHVrai5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAbVMK4Qhcq3Dvbu7r4i/DLbLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I0NjQ5MTUtODVmOC00MWRhLWE2ODgtYTNiYmY0YTc5YTY2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTRkMTRiNTItYzcyMS00MWM3LTkzNWUtZTNhOTQ3N2Nl\nZmQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUaTh7JKjSwXX9QTbn24RzLsL\n9K1Uu4quWFWOdxNCcHPhnnm4RQ4m4awxwJtGM9TYTRxN0iHaqywWmI8APVCJR6OB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSQjR8hnMBxkRuoel3ttmCVdJxycTBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22JKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiB93dNALD3Gkq34kAIe\nHQ13+JIBfWwdG/9GDcEpi+QLpAIhAOcHschSllzfi4L/YegjPjjsz2sm+uBu175Y\nXrtzhy0A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9094", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9094` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAb4my0OPyqhqGnb81YW2MMprMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1NDBmMzM5LTI0OGMtNGUxZS04Y2QxLTkzMWIzNDIwZjE3MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzA1ZGU1YmMtYzk1\nZC00YjQ0LTg5OTItZDUxNzBiZWQzMzQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+gZNLgqHyCjRzsggX0wa053wCdNGMOrhqoaGxL3xEt3NHbxG8i2eOOyolZEM\n3VhAniaNnbzJM67z68PvAgHlH6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSqLoxjD2SqW65bXrqCn8WZwRpXuzAfBgNVHSME\nGDAWgBR59nSXBB9qo5gMG9/EVzU9D/Gk2DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAtp8fVqDodadr2wlT1N/PdKERL9RMiv\nH1Z8Io8z26sCAiEAxskoCJa+3sxHjQNQbbjSFCD4pSNr97wopaLgR5uMyio=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeht0STbBrieNnAMVgUlFC0UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTQwZjMzOS0yNDhjLTRlMWUtOGNkMS05MzFiMzQyMGYxNzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASB52m9g5VnctEFd1cXij64cosltFk2RsPIs90YmvvFckbg\nAnz5yTfZsnFSibmIN78YQldkMM9Nsv6QMNoryMKno2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUefZ0lwQfaqOYDBvfxFc1PQ/x\npNgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALtQmrW6iddH9Qp29EgYJ2ctSwG4+/81KRzhJxpiUxB1AiEAm0k7uCkH\nDSAyyv7x9NPEqWb+PhBFvO4+yx1HEGI91+U=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAT3XjQN7XaMy6/DWeOw1sGSJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzA1ZGU1YmMtYzk1ZC00YjQ0LTg5OTItZDUxNzBiZWQzMzQ5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQyM2E5NDAtZWE3ZC00ODNjLWExNGQtYjYyMzg3OGNk\nZTU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7y8Dd1bZq1HvelqwDi/UDHB4\nHYpJ93K3ogv4DA2O5b5BJAtHg5kkmSEWQJPYVtnM1JsiyHY+0dnvf5d+J+0Pe6OB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSqLoxjD2SqW65bXrqCn8WZwRpXuzBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22JKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAiQW66yWzu8EDAvpc\n6x9RvvHMYQiO5Is54oZkdTefP/0CIBAWb6SpanYrXfPBlSlx10aODEuOBGHlOOcn\nw98//coj\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9095", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9095` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWz/Np487bxCxJV71+gaC5zmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDliNWFkZGEwLTI0YjYtNDhjMi05YjM2LTEzNDQyY2YxM2RjZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGJkNzdlZDQtNTI1\nNS00Y2U1LWJhYjgtMzRhNTczM2JhODM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhzM64IvSlzj6idOvCZBDsdpd2PP2jlYe5CLGAde4SZRM4mC7ZSL6MZw25rV7\nsuaDLTUDfBb2wHA+j/2OdiX54aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJsQj+EbS+tg1sjDPDkjH4qLklOswHwYDVR0j\nBBgwFoAUYIKL7mthPOsc7Y1qsWcQ1CmByvkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHjuzuunN4uwDRVn/+Jq/r1rNvwe\nL2VKOiRS7TLEF+gUAiEAicxBAoO0RYNgUty+2PtkUzsqQw7y0qNDHjITkckxlC8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc26KbZvKPkdPqlANoK0/5kcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYjVhZGRhMC0yNGI2LTQ4YzItOWIzNi0xMzQ0MmNmMTNkY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATUKPjFBpCdV4PiFa7GAz/ll+YyLovVjDf6uiG+rRdkitvP\n+MEuPT/U4MoFQI3LCJwAwVidRi5qYw3y8nn4InDYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYIKL7mthPOsc7Y1qsWcQ1CmB\nyvkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVdrJD38j3tkeM6mrsdI+UBwxGrI0e9iAmodtce/p5jQCIQCWdwjyjNG7\nLqY0lgzjez0GxKH6Abb6W2c/P7Es4D2wtQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeigAwIBAgISAf6KCgKQUQ3m6Ttc5zhz9wGhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGJkNzdlZDQtNTI1NS00Y2U1LWJhYjgtMzRhNTczM2JhODM1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjkyNmI1OTUtY2JjZS00ZDEwLTgyZmQtMjZmMGExOTMx\nMWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwlfAhWOZcJ/ZDJXd98+sPFlQ\nVv+s1s3PnnxEP5IncC3bqH+/DUDGLLjjpnutuDxFWw8O5Q7rW0TjZjvMrBIJb6OB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQmxCP4RtL62DWyMM8OSMfiouSU6zBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22KKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiATuAq3r5b/6bVgIjRh\njTr4PJoGai3TeCisVZPWNu8IAAIgWLKe7VV10lxv5n7PzBeb1d9X2/6L1o7SVzA4\nMOtsW+c=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9096", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9096` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdLcwkSavviK5Cji6FlA6VVSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4NDE1ZWYwLTgwYTgtNDg1ZC1hNzJjLWM0YWI2NDBiZmUxNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGRkZWJjY2EtYjJl\nNC00OGM5LWJhZTMtZDJiZTdlN2M2MTNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErzD5exv2fPXr9nVmGKefDsk/A1hQCHD8Jc+BCCtNiEqcRaB2k1IUS2JYR8zN\na2o6k7gLMwXZKqqojzXU5vKQIaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTOY5SrhOzjHagBHj/lRdXrZwP/KjAfBgNVHSME\nGDAWgBQ4CLq0fLec1imF0OTq4/K5egmyDTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDE5ZvJwBbqIC53dRMaSJMTqmUlfnJp\nxyCVLCCaU1I0ygIgdjITopwcrSlxtn4gOoP2cuVJwWBLXtnJgAiEJH71Drc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbV808FCdbA0TQ/rZtbwEKhdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODQxNWVmMC04MGE4LTQ4NWQtYTcyYy1jNGFiNjQwYmZlMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUnYf/Ki9eOgaidUQMjSQff9TlC3GRgS9raFFcm3BMoTFq\nhxYoJsIQWCh6AJX0HvDrJepbRWEOr22VGbmIZDTDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOAi6tHy3nNYphdDk6uPyuXoJ\nsg0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAfaIl/BKGZ7PxSRXrg8fpfb5MfAR09EMA/rv4WeLNgQCIDMvN3lKkYI0\n0Jjt+MHgl+nvb2SXm3HevTWOLqNko72I\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAYm5eoHl6Nue7zUYzNlro4swMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGRkZWJjY2EtYjJlNC00OGM5LWJhZTMtZDJiZTdlN2M2MTNhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzhmN2FiNjctYzZjZi00OTc0LWIyN2QtZGM3N2ZiMDA5\nMWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmKNrOfAnrLSmklSoIoGZdWfH\n9lRjI9vBO92gsF4pXGGoJ8RdWLo+SAi6nfFbFbmurBBO6AkJjv7sPckcBKcNnqOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTOY5SrhOzjHagBHj/lRdXrZwP/KjBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22KKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA3lvYWjRVxKL5slSu\nCLjLtWDioN8ACOJL3D6PpokUj5gCIG9BbfcDRJuRaoPT9Y2Y0VBPjtPCBG1RaeN9\nCyRoYerr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9097", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9097` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAa38FBnR2HIXXqv3G6eH7R9gMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5YTQ0Mjg2LTQ1M2ItNGJkYS05MzhmLWMzNzFkNGZmOGYyNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI4YmMwN2MtMWMx\nMS00NmE1LWIyOTktMzc1ZWQ3YzQxMTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp71/2OibeLGjCg1YMlDz9r+gqintVqnuwzDQgDE6MkkHhjJZzeOeeCLnkZC0\nODUlxX7nCe7gZFn2VJJB4S6CQKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo+mnDHmL9GVOs/tIJ3xJLX6t7iYwHwYDVR0j\nBBgwFoAULhbRbgVBKfuxrrgWmsbrn6F2D7wwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCBpCayfm+PjCuXlyU0KC04dpkt\neNPNgIABQ4vnpLmnkgIhAKzljBTmwd/hSEl1b6xMawpqlHW6zR/OOcIsfABo4bGb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaX0sN5x8OYGkr7KfA4EbRphMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWE0NDI4Ni00NTNiLTRiZGEtOTM4Zi1jMzcxZDRmZjhmMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmpdyPAV5HoQLZhlVTYLP0X4mvvhsEto6vroHZ1+nk7Rd0\noqqgHWk9kzgk35h1FB3TyKHWdPna6lPKYuumSuodo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULhbRbgVBKfuxrrgWmsbrn6F2\nD7wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaG9P+Rf6Aa7kyS3Y1oGP59sb3GknyO8XpcEPFgdqtLECIQCONPKgcRkM\nkNtyNDaveT5CBN++ArQBtKpUBT8hAn8GBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAcyGo6Pr9nFySPsTIDGud9UpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI4YmMwN2MtMWMxMS00NmE1LWIyOTktMzc1ZWQ3YzQxMTk1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjJkNWQzN2EtYmE3NS00YTRiLTg0N2UtMjQzMDdkZTA5\nMWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3LPPZkeUDgOAZGthmMTWAzBh\n5ZulZH/xxvpNlYlJ1+qa64nlAXB7MTy2l0SqoYkvJ2q/RvyMZdP8ahKzqhPFrqOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSj6acMeYv0ZU6z+0gnfEktfq3uJjBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22LKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAqyyl+bncHxQCBJMV\nsP/w/B3axUmCvoYCEO7QbKcyEocCIDZH3PmRORpCLIJCKQHZLH/WlSE1pjvOdlDj\neIK1UQte\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9098", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9098` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAegqjK3chycJRSDNpsjCMUWBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2YmE2NTkwLWY0YWYtNDA1ZC1hMDBlLTJkOTIxYWU1NWNmNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODNjYjNmYTQtODIy\nZi00ZDU2LTk2MDEtNWE2NDMxODI1MGE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErafG8YPrF5NZLHpE7WOLmXOE26at2T1HuvEXamM3DozsJ2O+2f5OIgmFZCAX\nacWNrr0rwSbsiCo8Nb7mG8LGwqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQbRWsBPejvdhi6GLIPlPrwSFoOvzAfBgNVHSME\nGDAWgBRPqAMJ4K+PB63fCJliI7qp2sUqVzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGTHvn+rPTnSu9t3AafJTa5V0o3Ab6mq\nZ8WyxGpQHrm6AiArF5RsVFFgB7UAVXESK+uXV5V7OSmzkYmsjZKDGytycA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeMc/DlMr3QJOGVYCUVuAdudMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmJhNjU5MC1mNGFmLTQwNWQtYTAwZS0yZDkyMWFlNTVjZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATpdRBEjHR+hoP/ogOfRioCxHTZow1rrAy+cp4yjSstByBq\nHnliV3J+yMLV30OzxoXlP8GBq/f6lEws0f+QD/Wao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT6gDCeCvjwet3wiZYiO6qdrF\nKlcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDeaGat68pXkWP0Ip81mZ7Ny1bqC7jAHqrZBuYNjJK6gCIGCuJW9PbfO5\n35rzmWIkDs4l4NAwdS7TuV8KZgFubhHH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQzCCAeigAwIBAgISAfOqnFyvLkWvATFczPakyeoJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODNjYjNmYTQtODIyZi00ZDU2LTk2MDEtNWE2NDMxODI1MGE4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTU1MDE2MjctMjVlNi00ZDA1LTllMTItNjI5MTE3ODgy\nYTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQ20OidkPajOGS8PltyxeMhtt\nRj8EnpvYeKWJN/LELQc8p1vTJ1dCQ4u1P4UpXv5kpAlTiOlKuPtPSHewTe7WraOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQbRWsBPejvdhi6GLIPlPrwSFoOvzBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22LKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEArRMK9tU/IAs/06cV\nRWzC1+jUeETvaa4lx9K1HQFAgSwCIQDYZ5At3MlPORNVYjk9lpXVaikLmAFxvmlz\n9NUeeM8LTw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9099", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9099` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASj5Yz0BJ+XktZDTI7X6JSiPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkZDk2ZmY1LWJkMGQtNDAyZS1hMGZjLTJkODYzN2Y2YWQ2MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGJiZDQ3NjgtZDFl\nNi00Y2Y2LThiZDgtMGUwY2Q3MmZiZGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcR3X21Xl8boThpr7VLm8zzNnKvBC8cp98EsEFGEWW5qu63cZpEym87HimD5V\nFpuATWybgWJ2ROhQRMVYpU4Ju6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Bf7HUheL8svAWG/Y12A0Fn7evAwHwYDVR0j\nBBgwFoAUc7wuK1J6Py+C9JmlZa+5VDSGNlgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDiipacc+5P+nNKK9PJXZ4+YQKp\njUSA+2AA2lYOH7PBaQIgRwWxHba/T41vJW5PRaz/j+q+AEfUFyaSokUGTm/3wTI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbNtII8zasIC4TMeMW+WbNwTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZGQ5NmZmNS1iZDBkLTQwMmUtYTBmYy0yZDg2MzdmNmFkNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxoM6ebrCRtisYxqydGhuwc1nqCl8Tn6tEyiF6FujfmPM2\nGrtDoItx3wYsWViJPSZQqz5/3dnWw5SMasi7KfDyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc7wuK1J6Py+C9JmlZa+5VDSG\nNlgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBzB7vv/s39/DN/4YByghaAAG1q11nX15t2qxFYttRW8CIQDhnuM4HTsa\nB5FenSmxPpEejEE8Vlc7WUzCmfPyxThn0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAakxlk9xzOcDv+P1O4LjCL9nMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGJiZDQ3NjgtZDFlNi00Y2Y2LThiZDgtMGUwY2Q3MmZiZGIwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjdhZjUxOGYtZmE4Ni00ODA4LTlhZWUtMzA2NjI2MWYx\nOWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjXEzCnCsWwWD4e31jRhh0OhI\n5kQYOtn0JxbD9oypRtc+5yRbDALruzr2B7+1KxzzEz5hWhRSmoXfqSWLMW27naOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTgF/sdSF4vyy8BYb9jXYDQWft68DBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22MKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBBQNzbzPHquBmq1ECQ\nfXwZ0i5m3jtdtj1jCSk0cZXadwIhAMsOZLiH8pY1VfNaREiXwgPy2uJbkrkIm28p\nXlATty6Z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9100", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9100` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAdtfgXqAq6L5mLJYyUmdTTimMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0NmFmYzVhLTNiOTAtNDZmOC1iZmE3LTJkOTQzY2ZiYWNiNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDU4M2Y4YTEtMTVj\nOS00Y2U5LWFkZjYtMTE1ZGYzYmM4OGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEroneupyOiwWz1EnqtNS1v3wjBGjCfZ96ky3Ni7YjJVmQVe5bJC/cgwRutcb7\n+bt5pX7IQJOon5dTLWiN67y8baOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTAyTnsAr3kugYaPPjQVEZU8R1ANTAfBgNVHSME\nGDAWgBSbkBluON6z8ApccNFrI9VHhkYsKTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDxtCUDg2W235pCnCV8ATO/+sO8S9n+e\nQvcABtq9kCCkAiBx7wIxV+/YThSSSJjj20zOUFcxOIkORW8qgg0b3p6J3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYxciRLXUAe9eW1u79Kj5x5MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNDZhZmM1YS0zYjkwLTQ2ZjgtYmZhNy0yZDk0M2NmYmFjYjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARYeC/ksMnUHcT4lapTZdfb3Xwh+nQqJGj1aUomrGZH5G48\n1fTQx+CXxGkvrsG/dnZUSMa8Xurb9XdWgpDzCg0Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm5AZbjjes/AKXHDRayPVR4ZG\nLCkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALKwmNKQECX354hrpCEBLvKiAMyQslAqLzhfizJj+exfAiA0k2VjBGy0\nlmLgvWJab+XfVrshXgzQUp/T2mjbRNfndw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeigAwIBAgISAYYNPeVn24ILi+xhVvNFplMlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDU4M2Y4YTEtMTVjOS00Y2U5LWFkZjYtMTE1ZGYzYmM4OGFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmZmOTk4YTEtMTc4Yi00NTE2LWEzZmQtNjI4Zjk2OTI1\nNmYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJm+SUAoYrkhDSWWA4ubme7DM\nM+gR/yOt6pkUdOLGPihGrrsdJFCUrBMV74y+kuD8SUDLt6fJXHLuKzP5Kpp1aKOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTAyTnsAr3kugYaPPjQVEZU8R1ANTBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22MKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBltBCyFhyDcAykaGvj\n9eZDQ7b/BGGRW0tXvLbjjFWoXQIgZzF0feEaGDtoHR2osWd5UOe/qsBLm1QGt7CJ\nHMd5fyc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9101", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9101` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAUOE659MD4MQwF/hY2WUqum/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZiZjJhYmE4LTYzMjctNDg1NC1iNzQ3LTg1MWIwMWFhMDBhYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODZmNWQ4NTgtMjFm\nZi00Y2EzLTljMTQtYjEyYWNhY2E5YTNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENdrZZwIe9f3AtJJzxpCmWEjDD9bo12utjQlxchmlFg5rLhRyFEluLlCrMnys\noNPfTPQXG/xQe0q2Q7YPznXCr6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsiLLKbjQsQcjqx+tcZfR/hUTr5UwHwYDVR0j\nBBgwFoAUnUc8inTmjGv3y0+JEqzZlDazJx8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBpoqJGlYlYkuX+s8+X5FPxQUib9\nVpoTgh76XiCMmVneAiBXLQTGgFNg0awMKgLcA5nq64MFZ1z8lTDbnjPNRiM1sA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf8YO94yGIuksAfsd3zFU3VaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYmYyYWJhOC02MzI3LTQ4NTQtYjc0Ny04NTFiMDFhYTAwYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT6cgVM2DEnBpFm7XDd6KKo5LkaHrZmLMQtHfVKHvP1KMgr\nY/uR4j4l6YhoJZylTEiIl21iRbwl8WRwcFukTE6Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnUc8inTmjGv3y0+JEqzZlDaz\nJx8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDzLkdWEqJtFnM23VH+M+Y/ym2tQ+fNcHGydntIxAj80CIQDdggnW5S1z\naLSGLgT2fuQLY0CJF9D0bLaRhD9E9fUYgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISARbd9EjMajWxw8hSK/jFZPahMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODZmNWQ4NTgtMjFmZi00Y2EzLTljMTQtYjEyYWNhY2E5YTNkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2IzZjE3ZmEtMzQ3OS00YjdlLWIxZmYtOTRmMDBjMTA2\nZDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa8OpoqyEW8G9excr/CjBHd0c\noPEVdh0NeN0jxjTG9YAz6BSpWxGmiWgRqDT8dBKg9IPfQwykthUuQ0rJ2p3dgqOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSyIsspuNCxByOrH61xl9H+FROvlTBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22NKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAmooJ7LxmEY6oGWmV\naw4ljJ/X2yR2qxgnZ6MsPKXJIgsCID1cMd2URXpubbwn2IPWYSEdBh+XszE2BSLk\nQCjA1UAt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9102", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9102` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAc2UpsHqlfKE93P5iqrl+paVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlMTJkMzBjLTQxN2YtNDBkYi1iZGRhLWZmMDU2MDY1MzJiODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDJkZTFhMGMtZTk4\nNy00NWRkLTk2ZDgtNjViOThmMGFkMDY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6IU8blDTkY8dU616P+GRJHjcX4YIwQ7wyBcb0Emg9PGWTXHYDoV4vMS336nY\n+ySq63PtpPW8UL7ANnGfn9AIKKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRXjQeHU/mSTyisCOhgOnESKFltsDAfBgNVHSME\nGDAWgBRgzMA4Jiac0b8tyc6Tm48k4NfrUjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD0n3GusigI/6M1FaU/B4ecaHfZOCTN\n6m3eI7Fhu8g+FAIhANxytU1s2FwMqCAF2COFM8YOBzZJHYTmEKrkLQoeSsW2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe2UhoWv1amnqNmI50yqPesyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTEyZDMwYy00MTdmLTQwZGItYmRkYS1mZjA1NjA2NTMyYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqkRiE1k8Y08R72wtyWosnHIMywlsNow67O+6jk25wc1eJ\n3no4mPn8cdvUv3WnIUXIjldd7NepFBFKOV/mYA6io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYMzAOCYmnNG/LcnOk5uPJODX\n61IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMGNfLnUEXt1HtzodKRTky1ymUmnaxHAFzZxCZ+CMz+QAiEA2pC0XiPe\ndyySzfDUR2D7P0RSap8FZNekCG+LSeshbpw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAW6mM4ZVbijiu1cxeEaQJKv4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDJkZTFhMGMtZTk4Ny00NWRkLTk2ZDgtNjViOThmMGFkMDY1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWY0YzNiNDctMmMwYS00YzM0LThhYjctNDk5NjNkNDgy\nN2ViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsA1ZaICI7Hy6ibqWBXHLA5pf\nkgqP8uBcHTrm7v6nWjUmEy+ALe5qxfQ9FafuxycSWPVLNxClSeQouy2nMgK6V6OB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRXjQeHU/mSTyisCOhgOnESKFltsDBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22NKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiB8jakdR1pU/2Psd+z+\nZoPjVQLYofbd0q5Tz35RFIsdwgIhAPkde10Eb5egDpKUP5TeLLprKt1rsMY2Hh3c\nmC8kHxDX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9103", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9103` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAQPGBMnm5+tluETVgv21zFfZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYWQwNzNlLTViODctNGQ5NC05YmMwLTAxMGM5NGEyYzlmYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWMzOTY5ZjItZjQx\nMy00MDA2LTlmNmQtNWIyZDE2Nzk2YmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt49JVkbRObhZxey1lVsmS6afwLZrqh1Mc/GK9Di7k0248hwlW3X5nonZ6Pr6\nCifzauJTuFZspPk09HKL5YJnGKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCYi4KPRMatTpWrSEphPYcQ2isYQwHwYDVR0j\nBBgwFoAUWJAiUtxwwjYADpL0fuzZ/ocuBQgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEpbAtehv8ZXc/Pt6f34MSrlEfXw\na5IJelfK1I390rLOAiAcEM6mwqc+jScn0DZBYLhqPuV7beTsO/wZUmYvFSYreg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUr6K+yXZ+eC820DspAvF9yBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2FkMDczZS01Yjg3LTRkOTQtOWJjMC0wMTBjOTRhMmM5ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuBXb7MokMxMqxgmF229L5oxKWSdt52p9MK3Gu+0tjJan3\nTTEfUzrpEdzZfK2gkEN3bIpQzhOZXDSYCVYwVoNKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWJAiUtxwwjYADpL0fuzZ/ocu\nBQgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgf34cFV4N4V0NXwQs1euRdxR6d3Vq9Y8qY43t7Cn0Y1wCIQDN414Bp+XB\ndzsBPN6ESsTm9z7qWt2vVDKmYPWD3aJQPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAQaxo/Es8mXTdEgTagihjTuBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWMzOTY5ZjItZjQxMy00MDA2LTlmNmQtNWIyZDE2Nzk2YmU1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmJlY2Y3YTgtNjRmNC00MGRmLWEzYzMtZDdiYjAwMjFl\nZWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnwjOGe+e7a6zs2CPrlfpxdD8\nkpiHwtTHzy2xgNC9l0BEE6/d0TJmajn9FyukwCzXTpi4BsDfUW+AbcokBNcsQKOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQJiLgo9Exq1OlatISmE9hxDaKxhDBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22OKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAqlv6TdFv/hR/vqDR\n2aUisTbt8L8k6nUMR+aUDgo4clcCIH8RbLL/ict9LWRakVA+xa3CKbFGlovgufZg\n5jst8im9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9104", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9104` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQqZTLhfv5k7k1XaIXDC/hWDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4MDM2NDRjLWM5ZjUtNDIwNy04YWIxLWRlMzNiM2QwMmUwYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBiMGQwOWYtYjll\nYy00YjNiLWEzNGItZTM0YWU5YWZjNTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqUo5PVB8uulel7SR4QXUk73ayyO6OT41nosqc/tpsgBnlSBpxQ6wnoU3TOZX\nx0mBpUb7IgOL8OHaZ2cQxA9o0aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTZePsrQLah8wex6KPFAKkNKOs8HDAfBgNVHSME\nGDAWgBRfJ84BFzCxbt71W2XNCKIBx7ksfzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDy9/auNvK+x1gRnvswlArQvxjLkjyP\nbo5tE3Z7qKFT7AIgYhvENGTLyAUw0W7iE/098GF83ChDJ8gEq30HBSJ+ZZQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARK8OhDb7SDH7RrlbWalTCySMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODAzNjQ0Yy1jOWY1LTQyMDctOGFiMS1kZTMzYjNkMDJlMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ74CBDpyLtzsgF/mHC2ioJ2+66sHRsyUcBwwEXA/ExZII8\nEmezLKPgtuBlF6c6YX5GdyM/PUHyDuZoO7/Jm8s4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXyfOARcwsW7e9VtlzQiiAce5\nLH8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKy064VTOGSU43OGEXmyRJsq//2iwSP21Jih1aO8GmoECIQDzYn6oNlc6\nR2e4amzUSYvrwuUPzWa4Xv4O6I5z8XJUyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeigAwIBAgISAUsOmE/G2+0GoHzYH/+/4u72MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBiMGQwOWYtYjllYy00YjNiLWEzNGItZTM0YWU5YWZjNTI2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTA1ODcwZGYtNTlmNi00OTM5LWExOTQtYmQ1ZTdlMmM4\nMjdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN6toalXccSZij7gnm7bgQUpi\ntG3U84Agtj1oKZMv2C9UxMiSpfK9zy/821ZGp9T23PtSFcF06w/Cwl+3/o8BPqOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTZePsrQLah8wex6KPFAKkNKOs8HDBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22OKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAtnP0EH9vm0OupglHn\ndNx/EavApjxQDFxPKOk4jeiFoAIgGzAjAsm+fNksFfXIAgh7kb5y9LY9uqJEg5J1\nvqLEPfU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9105", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9105` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVZxdBoEMfPQh+bI9fHHBVKJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5Y2NlNTM5LWI1ZGQtNDNlYS1iOWM4LWI3NDJjZjBhZjgwMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODBmM2FmNTAtNTg4\nNi00MmM0LWJjMzktNDYwNGM5M2QyN2VjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAKermVDm9O7bLMNyOa0y3/s6HXIsVB9gnxFKG0nHpOvG8OvROjCsbyXKHXSI\nUoVhfpWgGdXJhPG6VMcURwXE6aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnEHjgyeChXZeqm83oMWKXrMjQuMwHwYDVR0j\nBBgwFoAUF01QeoiQhAhKBfJB/oRD6o1JBEgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCKjqsJvM3zLqO24PsZzS1NMU7H\n5QKosuWl4AWfqiGjkwIgZFoGV1/8IOb6KJWDaZOxGQXoMB5iDqeR2jApZbJTsws=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASswh7woKDRrRw06Usp0/pmHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOWNjZTUzOS1iNWRkLTQzZWEtYjljOC1iNzQyY2YwYWY4MDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAROSaK2T1buk4uRbDIkPsX7exUmEsFyxACWnn1Rf/xtjLqF\nyJK2CSEIyVqSW9XRoKf4q3/p+eiB4BU7ltT/epgVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF01QeoiQhAhKBfJB/oRD6o1J\nBEgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM390Vzgzfa/4TiVYQwLYI4iyu3eixTST8NVx9arzvzgAiBKonrn7bi3\n5CayCdRklwS4VnqepNrjqrtisge7fm+HQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQzCCAeigAwIBAgISATm0XD6nn0arvbuGa240LcnsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODBmM2FmNTAtNTg4Ni00MmM0LWJjMzktNDYwNGM5M2QyN2VjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDViNGIwMGItYzNmOS00MWZjLWI1OTctNWI5N2I1ZGRh\nOTk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP/P9PDye1wI1nlRQmbruUx9u\n7c1n8z1W5JHDEPUU7/LlXizsDCJvK7oIv/ZjuXmlOeZDgICudHwav1dENmQdsaOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBScQeODJ4KFdl6qbzegxYpesyNC4zBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22PKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAxWyR0BgsCNPmyoyj\nJGJIouRJx2lZmUAzYGBLWOR4NC8CIQCqwLaBUuh86s14bOSciSrVzv+OhDcXi/gO\nhDYPUY61gA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9106", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9106` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAQPD52eKzKi5G/vceW9ApZ+fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNjYmU3ZWVmLWM0NmItNDYyZi05NWVmLWU1MGU4MDQ1Nzg0ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk0ODNkMjUtYTBi\nMC00MTUxLTk5NmEtN2E3ZTM1MmNkYjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsHB14oo+u+Xi9nYaHo91AC8vF/ISeW/JfLsTawP/PA3JdOYoB1SupbbKtxio\n8T9UV0ca1xpORjzAlrS7RC0IqqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQbpgCHGT2O+Aqr/x448VHqanW/izAfBgNVHSME\nGDAWgBRJog4adTyo8MSEiiigpNFMGdq57TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD6Sluj6w+7z8A2xJ6jaSmsw6kPwm72\nQ7AlCwzz96cz0AIhAJUDevbkvlSa2Iim62VJlMSYTiia9lJX93atlsZlq0Ui\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASHL0skKpW9TjUd1ogKmcLs2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nY2JlN2VlZi1jNDZiLTQ2MmYtOTVlZi1lNTBlODA0NTc4NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5ZUdba7B/cywx04yIBhgoG1yrQrX5qHfpTmDKTYzE5hCT\nG2SBq68rL88WTTMNYSIqsSOcF2NMS0WVrFdYMqXHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSaIOGnU8qPDEhIoooKTRTBna\nue0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgUyfaUgf2sKvBQz4vutXSP+QHRPXf6/chmgH2u2VlAHkCIQDjKZg+bPCO\nYazNweBWQvpGgrJhOYLY24wvKmgy7ywK2A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeigAwIBAgISAaMcTGPCAUFRjAzd++ekUomMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk0ODNkMjUtYTBiMC00MTUxLTk5NmEtN2E3ZTM1MmNkYjIxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOThhYzBiYTMtZDFmNy00M2ExLTgyYTMtNTEyYTdlODU4\nODE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExp6yihjQjbjtqYnKOrfMcm9J\nI/NeaDqMUiTg0FHRtpGTlzdgp0mbgTA4mh76LMwVOQeNCB13N2HwxdaJcuv0wqOB\nnzCBnDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQbpgCHGT2O+Aqr/x448VHqanW/izBGBgNVHREE\nPzA9gg9iYWQuZXhhbXBsZS5jb22PKmh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sIERO\nUzp0ZXN0LmxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBcW857+fxchmTPkh8j\nrRIfQcZPF048JT+2N/s6/Q1lCwIhAK04370YONHoJ7M1VmXHcjIHez/u6Cn81yoA\n4AurZSgp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9107", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9107` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISARMbTFqNxfRs+msnzwlGw2BrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1NGRhZDVkLWQ0YzctNDI2ZC1hNTJhLWI2ODI0MDY4ZTc4MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDc5NGY0ZGItZTY5\nMC00NDUxLTgxMjktYWJjNmQ0YWFlMDBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPisGsRHi4bZghGi0z/W5tD5VxUDgh4zcXBZ+2ycdQIJrPNRyrqDcksSbQzlJ\nmodeFzmKlWK8F+j08lORSpe+JqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ka2sB14YUlDje8cPbsgKJBLtTcwHwYDVR0j\nBBgwFoAUvzStX/aTxqXkJteyAGrE06/8DAAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDKC4nyljKR3UyD2lXRrLMK0E/5\n/lKNCirYXB0imkQyYwIgJCVsF+GaWIoIzwEuU6AcGwJXMmiJr6RFaxFtdrZ3YEI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbT2nO55qCcXOvmrdHNYltEwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTRkYWQ1ZC1kNGM3LTQyNmQtYTUyYS1iNjgyNDA2OGU3ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpe0X6D3GxH0BmV/KylFaJtCEDd9zNM10fU4ealdDKX43V\n8+U5oCP83DmYTuU8ZxH3HiXWtHrdP4qS4vEzGsOPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvzStX/aTxqXkJteyAGrE06/8\nDAAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL4Ty2ffWgYfeHgFuDpqK//DNzgene+4/DmAasubMA1mAiEAksVqB6d8\naFqA3roTOPycL/Rs8wGCyMoLo1/ymzdUNn8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATgJTjGvon1gsJOdB0dIngoNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDc5NGY0ZGItZTY5MC00NDUxLTgxMjktYWJjNmQ0YWFlMDBiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmIyYWYwM2YtMzM1Yi00MTkzLTlkMTgtZTRiMTU0ZjQx\nODY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE59v8XHI3AWhG1QGW5sF9p+P0\nF/XyELEbh71tRqslRKYyY/LceEsNyXufnVP4BMVQlcia1sGGlxxuWLw4rizJMKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTqRrawHXhhSUON7xw9uyAokEu1NzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22AHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiB9PhDReRtXOBMtK00FeNQTiNW3IYLiVqfw\nDuWZ9bw3GQIhAOI1IDbph/Apa6cW1zmrXM18rOO+VZZOdInk0r2cNqc+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9108", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9108` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISASFYT97oHb9XnkQ30Gy6emmxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzOTk5MDU5LTk4M2EtNDMyYi1iZmU5LWM3ODZmNDNjYTQzMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGUzMTI3ODUtNTkx\nNi00ZDlhLTlkMTQtODcyYzg1YmEwYzI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELG6IBMRQ7Qb2jlsBFvX6DPqESR4buA/k8MHrv9uiQRLtvSGuXVee2Ddpy5YY\nyw2daW/x41g9aRZ3nIAwt8FnfaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQa8SYzL0eE1eja/zVmB7G3TN4LMzAfBgNVHSME\nGDAWgBTW2Dnpd8ITaAvNNysO7IAGd00UeDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDGlkMYEENDL1i1PLhi4oa2HBe6oeMR0\n6rLIJtwvHAYAAiAm7t0bWwjVIfFjEbMTHpp6pPp+5Ohequ3xG6BvzdTLgg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXIVmO1ggKmKscSRH2VsroFDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMzk5OTA1OS05ODNhLTQzMmItYmZlOS1jNzg2ZjQzY2E0MzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATF1tWXSkw5xJIKCWVMbAvwzbZ5IWWNYK9VT58thg7OVYzW\n1b481R35wOa8RR+Tke7nu6WKzfo75vcvCxVcm2XEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1tg56XfCE2gLzTcrDuyABndN\nFHgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALEaaS3aIg+KOrnt7SVdq4+vOe58Uzv09yrz1mebSoSVAiBNxoGc0Ph6\nhSmcfpgtDjobsqM+JTosAPZ1/vI+jhlY/A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVN5D1AgNvqogbj05tRPsrMBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGUzMTI3ODUtNTkxNi00ZDlhLTlkMTQtODcyYzg1YmEwYzI5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWZiNTkwNjMtNTRlZC00NDYyLTg5YTAtNGM2NTJkNTU2\nNmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7kCj/7BRazEOnjxmK8kye7lp\n5XUZyUN699ur7XmHb61nYdO6JAh4l/dHtuWkHcZkatbSShDR0L8CltYsohM8sqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQa8SYzL0eE1eja/zVmB7G3TN4LMzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22AHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiBWE3d3FcaPluP2MHAZ1tAe8T3kyKxpOxfq\nrebB5l+VkwIhAP+hif0JmEJ3lcexjvEBw1Lkca4kVaR95vUy+Jb/yDG+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9109", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9109` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAWwpzNAgkDjooV+9GV2/UQMuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY5Y2QzY2YwLTU3NjEtNDM2OC04ZGJjLWQ4YjhkNGRjOGM0MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGQwMGMwZWEtYjJj\nMi00YThmLTllYWMtYjZhOWJlMjdjOTkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExAY8F28iGfQoWjHPs03BXPDdGXWWqviUYuBOxETNY0DXita7QJsYPKlqZ0nQ\nhqdKsgREwbfeWkaKyfzEz9VeFaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTaJGbz4tIkk2nMqag3jTl+Yyq8swHwYDVR0j\nBBgwFoAUfMPLGV7o72fIL3p+V9GZGC03SN4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFFnyV1ni0wIJkHxXW7uUm0Hy+rB\n1jFKdIGm0wDHJigAAiBGVxBbXn+cfYmKd5VROgPQ09askWurHTVfwO3vu72sdQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaltZl6Ddx3TZW4dJkPyzDbfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nOWNkM2NmMC01NzYxLTQzNjgtOGRiYy1kOGI4ZDRkYzhjNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0JxafizovPP4CIAbxMnQUArrhCyoG90tErJd6kdsqdy2a\nikuL8K0xYAuEvfpa7Rbo5iwyFrVuu10TBUpnsfT+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfMPLGV7o72fIL3p+V9GZGC03\nSN4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPxfYLr3P/v+DFqPCXmiKWBBJM+Bndvb7qCBoSbRnFGpAiEAzVw76dIm\ngPzU9Smb76tIFv7w3AmaEHAkCgWPENLuxaU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdq4j/7j9L2xDXih/Sx7V3klMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGQwMGMwZWEtYjJjMi00YThmLTllYWMtYjZhOWJlMjdjOTkwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGI4ZmZjZjUtZTEwZS00MWI5LWEyY2YtNjk0YmM0Njc1\nZmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeOYnkN92hQDUzHE+fF+EvyXC\n2XSkTVcPJJhPLfRJCGsazN+A0zug8iXoyxWX06CTiMIbWkGyB55o2eOCmF/vfqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRNokZvPi0iSTacypqDeNOX5jKryzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22BHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAysOtfm0DLNfA46oXUIC05BkEbg84pO6Z\n2A1QCO1JeksCICpMjQC3lhG8h/cDQnAI/LxKNvaoMT9hhK0HRXDfU+Li\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9110", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9110` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYPEhC62SPVDy3GMRLP8rqH8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlNWQ1YjRkLTRmMzUtNDBkNS1iZWI5LTk3ZDkzZjBiOGFkNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ3MzZhYWEtZTJk\nNi00ZTYwLWI2M2MtNDBlMzkzMjBlNThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXQDCscLaJFG4LhPdKGBMxp/j89nZIjkQsFzodExulAvoRnmj8ggkwaHoHFeY\nwrGnZduSG+ndTMuFHwhy5Hvrm6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSzZ980lveWU9Mc1uWLZ1hLZON9XTAfBgNVHSME\nGDAWgBRmB28ohdVigeQjtBLjFDpkr8WzcTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDV0oBD41DPo84/1zLPmNX+cqElEXJ+\nPJFTb51n8KCIiwIgPW5nV1BHLPyW4oo3HP0xwmMUFbWqpvx/1glDwggPctw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV4x68xx7UgGMN9Y7spks1miMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTVkNWI0ZC00ZjM1LTQwZDUtYmViOS05N2Q5M2YwYjhhZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATLroMSK+XpuF3uJQvPy53Y6Ghnv/RL/SnJgWQFPbjoIhya\nhK5xrdqVNvPpvx+g0eRukiShfBM0JzCxbhl7YFgqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZgdvKIXVYoHkI7QS4xQ6ZK/F\ns3EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIUw/sjeCGblke7nS7zyP6N0xts+RN1XC7YvV3yccM04CIAkgWSN+jr8f\nsjtV/salo/LtIR10zuwfQOIZ4nXksX6X\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAf4zXFqf55tBlflt2BC8+pr5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ3MzZhYWEtZTJkNi00ZTYwLWI2M2MtNDBlMzkzMjBlNThkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjY2N2I0YTctYzAwZC00MGRmLTg5YmUtYjM3ODAxNzUy\nYWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcaR+3Q2dGZnQNxsQPtZAWRec\n6BTbittRzgvdEY37+fbMiGM7fvK2B9Pg7i5s12tKXEwFN27yGQDEiEGqQCSjdKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSzZ980lveWU9Mc1uWLZ1hLZON9XTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22BHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEA6FwRWgGFnfdnwhkY4OlFgVM3lmDW+mbt\ni3VdVg/xyxQCIFrm0d79G93LRf4eWjwfVHRZOzItViV5Y7vz0pIYbjmK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9111", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9111` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAfq6yUW7m0Yno/aym1WctxJaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlNDllNTY2LWU0NTgtNGNjNS1iZDJlLTg4ZWEyMDk4MmQ0NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWZiZGJjNzItNWZh\nZC00ZmE3LTlkZGYtZjMzZDQwYzE1MzA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ0xt3G2xl8FRLlwAxsiCm7UwKjXhLj2ZxvCb7Rf38UuEeVabBvlABHupKrnA\nBmNOesGbdghVxQ2viLHwxXxn/6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN2cJApzNc0LZuqjlUYkfvXGnqOMwHwYDVR0j\nBBgwFoAUIggeGFnCz1sj0+JxPSjxOvKTQFQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDjPpul0sZo7RBv+dmvaRavZDb2I\nxl7hGzrLqxuAfd/9AiBTP45njMEI+g9RoSBUAy65EKttQ0eaf7QcGfPB78CH/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAa2dHi5jKQ1K3QbhXKf1ha3JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZTQ5ZTU2Ni1lNDU4LTRjYzUtYmQyZS04OGVhMjA5ODJkNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQf5iViF7k0eDOlJ1S8opwWiqlL1qADIjlEVt1kILYT2Dje\nynzPM2FD1nLjzfaQk5cfSSQo31HS/2tSDf2ylDaNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIggeGFnCz1sj0+JxPSjxOvKT\nQFQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPjQ/HHr4VNmJ3qiJMdvrJJ3JN0WVTDb7Gtk2/Py28VmAiEAj194HoOO\nnXqU5TTWJh0f7ivBwZy3CdBL5D0qnI/cHg0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAc1fnD2f7H/2ndtjHatmowMsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWZiZGJjNzItNWZhZC00ZmE3LTlkZGYtZjMzZDQwYzE1MzA3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmJjOWE3MTgtMzA5NC00MzNkLThkYWMtNDVhM2Q3NDEz\nYTNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuSbEqx06dG0EvLmafuNimkMC\n0mkmkK9wCP+PuWoRkyi+Mqfl4jym5Nj4N0mTbFdr2B1vYa0BXKZ6ai8t0TglJKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ3ZwkCnM1zQtm6qOVRiR+9caeo4zA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22CHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEApd4IRhwHyCEACe2FpwT30dAsX7l/OEZD\nJ1Al0P8ji0YCIQDhDvdZt/rvePN3yy3bzQ+Hq6sqM4rEq7yh3zEF5PJjkQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9112", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9112` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbxBe/sGtODAkod4R0+eBN3jMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJmNjVkYWEzLWI2OTEtNDczOC1hNzBlLWQ4YzVkMTEyYzkxYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTUyYTkyOGUtZDQ2\nYy00NTJhLTlhYzgtYWY3ZGEwYTIzYjRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEppSj5/saWsV+BvxhHqYieWE/cHxM7gIOA02pfs0lfJB3Hmz9iIMSgyXr/hst\nBsxs+4BYmnf9wfx0SAX5IZQtVaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRI8UKS5bYQoE4WFWVBfiSe4/obpTAfBgNVHSME\nGDAWgBQiXY+ajLwMEUC5na9AcSya4XQLhDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCp9W7Apymi3Ll8nttn4JIjkogLwD89\nq423eOpODwsQQAIhANNQf9ryYBpHhND7XX+bTiR9nfzTuCNy+ZmO16nZSISn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZqQXKXj7Ts9jiwdSwjnesm+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZjY1ZGFhMy1iNjkxLTQ3MzgtYTcwZS1kOGM1ZDExMmM5MWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARNwCXrg2mDxp1l5ahQ1EmKIlhYBR+V9JgjghVRvxh9BFiG\nF30azVx5WQn4bHiAkqgf7P/4ZD9whOhpldIIJzMGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIl2Pmoy8DBFAuZ2vQHEsmuF0\nC4QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI80/vO0qxe/KIjVmsc32NkdSSsdrxQmnwzaCobU5lsiAiA5o5Vp5fcn\n/LBW9T/Ki7triLHluI5fesuVMeDRJbNfZA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISARey8+Ykjy3fvP+L6tOTZ7njMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTUyYTkyOGUtZDQ2Yy00NTJhLTlhYzgtYWY3ZGEwYTIzYjRlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDRiYjFiN2YtNWVjMi00NzUzLWIxMTgtZTIwZDQ2NGMw\nNzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkTmbKCRI+/l7Op+WA+vMQ6qE\n7rNp2gA054B0n9dDwX/JnYiGblWXQhTsxi/r/3pi3q69JsDVd/XY6AH3gufrIqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRI8UKS5bYQoE4WFWVBfiSe4/obpTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22CHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAlxneFFpyBJbPA91Yqm0j/v8CCuDyMi1x\nP6hluHBEaxMCIFAMW49BBhEU7WfOuED2TDaEy6bIb7sgKxOWG4lQmKZ8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9113", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9113` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISASh2lslr0M0obwnyDC/no00hMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwMDU3YTNhLWE3YzgtNDJkNy1iOGQwLTJiYmNhOTc4OWQwMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTU3YWZlYjAtMDc5\nOS00M2ViLWI4YjgtZmVkYTkyMDkzZjcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFP+MM/08OH7SOT4kg+xZCTx6GpPspqc5pwsIOVNMrcbXgOgpsgGZD7nOQsy4\nODWEaGLMAVSdSIIz5sbMJSEdIaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvM9Nft+QE+YkISwMvJbZAEUwPhowHwYDVR0j\nBBgwFoAUh7E0TfkD9wWeYiKeMXkL+3KFncIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHc3FQ7etgg5kbr7x8MDWgGxCV+s\n3pedcXZjUoeLjqERAiB6wSVLWxjWZLZX2a1iRB2NH2tVPP78ljQNckbhdsDngw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaXpdWi+mv/GZqIDVqxb6xCTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDA1N2EzYS1hN2M4LTQyZDctYjhkMC0yYmJjYTk3ODlkMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASE0MPHjcZHv4eOhJkhQ0XeoXSwQvWB6WTTWEE4OS2gFWrk\ngQ/TjgVndJotBuMRb6YXGaAieTOt2vqPchps84KQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh7E0TfkD9wWeYiKeMXkL+3KF\nncIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgIrkOfIXavJzgHrMqjqgaNLZnxVWScdMuAoUm5ShsboUCIQDk547rTlwh\noMrK4eaaVHudBgs2eFoDlWGSnDODniipCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWCBLJbBPW/MYmrHlCsUnGlxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTU3YWZlYjAtMDc5OS00M2ViLWI4YjgtZmVkYTkyMDkzZjcyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTE0MjFiZDUtNTRmYy00ODk3LWI3OGUtMzk2M2EwYWZh\nZWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi8fK7E2q6LG9qvEwqIBQM2kh\nmoAG03wgKQ8AncBZC2wFZFbk2gXuaGRdUW14SO2X8F6F5vsKYbBKXXp0/HRPtKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS8z01+35AT5iQhLAy8ltkARTA+GjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22DHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAluG4yzuxetbY/N4FKp+A8xFQ/2q+dXCCT\nJH7V/Njn9QIhAOlRiOaqiQlorYjKXbCKOhr7p8edUovBHRialFhbHfJS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9114", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9114` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQn2zZEsdPJY31FhORF7YM7LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwOWUxMDViLTlmY2YtNDNmOC05NzAyLWU0NDdhNDRkMTlmYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE5ZTI4YTAtOThk\nMS00NjNkLTllNGUtYzBjYzFlZjkwNDBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw2Rzm6hM8jmXX50VKa0l73QBm2gteoYlObRCiDGCv41KWNTgsXbxaTPbIVf6\nF5p99lz5MxhkyTzgleGA6TH786OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSqHFKdLMnZtIF8nyqLV/6OVS0pSjAfBgNVHSME\nGDAWgBTowJjyUq1RTvgGGmdw9LzFyhu7NDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA53200faXtRHPUwSSIzqnixI397aL03\nXDv+LFo4xKP+AiEAoT62TbxjosFAhDgGAypv9EQ0o3k1ezRji+4sRu9t95E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY4X5zkiOEyBBo0pG7gaLiVFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDllMTA1Yi05ZmNmLTQzZjgtOTcwMi1lNDQ3YTQ0ZDE5ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASdCCoF+xe9/sRDvlv4Mo0iYrP77Zx0dqC32h5CKOWUzrIa\nxIit5vB8ocmsmVJoFk+wbO/rZh+FRopp0AQoj6Tio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6MCY8lKtUU74BhpncPS8xcob\nuzQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ4ZOyvpi1+QfCZXBJxEqMrykOqFo8VKfsy8oTHsJQ3YCIQCvuTWJ6IUB\nDM1yMn6E6Kc8fxt+n3JLH0/N806J9CMIOQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISARSNbxTkzspPuXUswlADEmHyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE5ZTI4YTAtOThkMS00NjNkLTllNGUtYzBjYzFlZjkwNDBmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmZiYjUwYmUtYTQ2NC00NGNkLTgyZTAtODRmYjk0MWM5\nMjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQUCOArqyj4KlCeJonopKN3km\nugT9lFh0EhUT4DixYU8oHg+h3RLJ5gTsyP2QGB3dQlEIarN3OA+SfwESRL9ksqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSqHFKdLMnZtIF8nyqLV/6OVS0pSjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22DHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAx0NHwdRjBConOu4xTlArTkYUz8Nuk0cZ\nWaf3iMq19XECIQCLD8kg4TckuN9N3smt9kSNfAB3EznHK/B4YCFeGBiQ2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9115", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9115` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISASXBO+bP6IJnuVXtYdIpyxFWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0MmUzMjkyLTQ1OTUtNDVmOS1hYjg5LTQ1MjRhZjA3ZTg0NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmI1Yzc1ZTAtMTlk\nNy00YzFlLWE5Y2YtNTI4MGYzM2ExMTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+sGGitwMlj4y0klx3qEZOiC/Fr+4EQFcVSrC7pf8Pf75ocVRdYVQXxIsz1qK\noWpyO8j56/Oa7yXo7VxOrWQQCKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU20Vff1IoDSemXJGytrHwnholpCswHwYDVR0j\nBBgwFoAUxNHk0ldWy/rSMYdBxahhmITb9fYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCCPNLuffyDnmoOPCgQwA5x9Gio\nu3QDyxH/+JR/oApG2AIhAIQ7Bzts2Bdj6wFV+UR/zhaZoFYMjPCnQ80v5QrN98Bo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT0zA5pm+mGIxWwq1EwSe2FaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDJlMzI5Mi00NTk1LTQ1ZjktYWI4OS00NTI0YWYwN2U4NDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT08kzmFpmEypLeN2Sgji0uFgkp+gM1BOR2trFqpB5q5Qt7\nYMhv/MEC5YdM6zWc7hBO+wgNW0pziRdcviOwk0MPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxNHk0ldWy/rSMYdBxahhmITb\n9fYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALdZKuBWrbAoTcMHwCkM/GeaBpFcwCYP6x65EskKFRR4AiEA1qFUDSkR\n/FCYiKNSwcvbkVVJ7aTOBwDhgGmWwDA/ivI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAdBFywWIxYkKpc9SdZ8xvA43MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmI1Yzc1ZTAtMTlkNy00YzFlLWE5Y2YtNTI4MGYzM2ExMTJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQ1NmM0NGItYzlhMi00ZmNlLTk2YWYtNGQ3MjA4ODZi\nMjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+j5YKdN0bkgKKnvdhbIJeKa+\nU9utBMNb+txyeh3uwIqoZsSS2xJ+C1GMuKUss3QCh0LF3RA8aN731W5nsNzn/qOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTbRV9/UigNJ6ZckbK2sfCeGiWkKzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22EHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAmVvQfFvlSO1y5lrfwYA0HV1RV1KePIwj\nGnNqzNS9/hoCIQD3AXf4zZzlOb5xr970mJ+3ep/oxnmyMXgDBruFlOOrXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9116", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9116` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQM47TC14CNUGP/xDXdXM6RKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5YTAzZDcyLTkwYjktNDMxYS1hZjRlLTg1YWE0YjdlMWU0YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNmNWViNDEtNzdh\nMy00NDVkLWJkZjEtOTk1MmZmZTQ2MzExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXBXHp6k0EnGezBVMiMAIA8EtJ2bwaRqSquQvqOVlpDGRy01gH2qPbcwN3L7b\noNLld4zFwGdz98zFaMVnnbK3PKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTosNRoveiFyNIBOQiHCwR4smMDlTAfBgNVHSME\nGDAWgBQbE48E/OyFC9eGutHP6sFk0twDkDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGUwYY7rMe8PSfydPszcPYpc9VxOaGQF\n1kr9pkGUdPoRAiEA3OQBq43g4HdVaha0l29WHGrp5dkNNiA9w6eyk9Gcp30=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVfmjXAbgOxiFY1/07TIpGByMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOWEwM2Q3Mi05MGI5LTQzMWEtYWY0ZS04NWFhNGI3ZTFlNGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThWmtabbi8LKt8zrMP21AAMEmwmCPHIXYF9+pjudb/0IkU\nGLiAM7oWtPNRDafss3x3lB78yi9JizfSAp2Ifqjbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGxOPBPzshQvXhrrRz+rBZNLc\nA5AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG/TDjUUX13dBkFxSlhyqh/Um5e82JbKNpfY3QPFH7TgCIQCYO8sF0L5P\nfw4gwfECkYbegqIGwITbMx1IeFlojK1+mg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAaxVca9XHg9Jq+CTXFCWfJvmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNmNWViNDEtNzdhMy00NDVkLWJkZjEtOTk1MmZmZTQ2MzExMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTRlZjJmYTEtOTVlYi00ZjIyLWIwNWUtYzhjYzA5YjE2\nMDhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESY/kAP17fcYyXNjCDBbp5brg\nYxaZRd0LmGGfIG1f0PQNBxHYCkJp8H/FwTWf70tJctO6FwGLukEXoXOGh7JUVaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTosNRoveiFyNIBOQiHCwR4smMDlTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22EHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAmAPacpmfEkJyr3YQAA4lHBwhcpXUmQ0g\nPWFFNLOgcPcCIQDD2hutMv00B1LeTfFG0+U85crAVHaD8QAOGcT0xdLHsg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9117", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9117` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYDuo50kSTZPIg25ROPPsnaMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjNDkwNmRhLTMwOWUtNGQ2NC05NjJjLTAzOTE4YzU4OGZkMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTA1ZTg2NzItMTA1\nMi00YjA3LTk4OTgtNDE4NjNkODkyNGRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjZeTTkx6m9+N2660fmklwcPpejGAT1MLCDVa1y7Y61RlN06XtpYSe7HkL0lh\nfQCE4svTFYs9LaBR0FpjwXw99KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlMscHVQFtrrKaDKZWYx1XYFJdhcwHwYDVR0j\nBBgwFoAUiLjWPcvMJZLlu8Mzq+NRPEDfLXcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFrEwY2v1QOePIFIq4Xoi/ig88je\nmzDnPswdXOSHtPMDAiEA6XkrnnJPn7ICxi0PkOIVMTicKu+oZkDvfQYpcmoWZRk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc5+VRc3itBsr+AWZm/Jk3rsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzQ5MDZkYS0zMDllLTRkNjQtOTYyYy0wMzkxOGM1ODhmZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvylJY8WT3IdSsC51ACkGpNBhqLL5EK2jKKVGKcFp0H2rB\nUz5iwbD0Fz1lsnhXYzAKMA3TLMLkY7O/BMSqh+5Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiLjWPcvMJZLlu8Mzq+NRPEDf\nLXcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN49vjm/LzogfCYWMeHrZwD5SCcTYiMWs36/bqCMVgVpAiEAp2332LOy\nqT+glxiu6PSralGpJ8cnT7dYH6F84fJWmaM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZQLq06yjAl4MCE1O8F7S7piMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTA1ZTg2NzItMTA1Mi00YjA3LTk4OTgtNDE4NjNkODkyNGRkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzM4ODUxNTEtZGI1Ni00ZGExLTkxYjAtY2RhYTI3NWNl\nNWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENWjUm6IdnGeO698EZAdbp87Q\nVFPB6Dj/0lzwU6npviScse4dYVopZzB013YKizfbbfMVyxyaun5DKarNC9NvO6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSUyxwdVAW2uspoMplZjHVdgUl2FzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22FHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEA48oLT9H3XfSB/niEwJ1H7otwfqoH6DxH\n6EIHo8RWccgCIQDpQwB3TO5D+5rS6PkPW9QPT0IrPRjfC9LAtvSQO9CQug==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9118", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9118` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAS4stEj3mB72tjSfupXW7CxGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5MGJmZDY3LTllZGItNDEyOC1iYzE5LWY3NDNkYTk5ZDkyNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjgwYmJlMWEtYzAy\nMS00YTNiLThhMzUtMDcxYmRhNWVhYmY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHeYkca3mW4eij1z/aiFwJZHO/T/GAnGTfzrcNQtO2EAGnJ/+2JRp85iT1tG5\nEYKvEa+Fgl6stueEPvdRjNSYL6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRSsJFyD+jlg5NeGTRC6hszzZPRzDAfBgNVHSME\nGDAWgBSw+hKkGRNfQbZCiEH85ZXznb/ofzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIB50dcCRlL/X9E8KJbe1ZC5f7ZJqOW/D\nI/zAAodDvBfcAiBeMNY1rM1bGsxLSXuayrK+SITUoAFaSG1lpcKfLNWCfw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc9sIbSt/0AgNlTopoEqEAPAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTBiZmQ2Ny05ZWRiLTQxMjgtYmMxOS1mNzQzZGE5OWQ5MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJjhLi0YQ58AUDbekfXgjeq/Xcrj2EGUZ3RCKfYvr7Xdvt\njyUiCFda4RhDv6Ix7ucfwUSAGNrDiznU+38LsWd0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsPoSpBkTX0G2QohB/OWV852/\n6H8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgC+fMzmJyxLYeCO20mISlrWobywNMaRJslRPAbUTIBjsCIDUQsoq+SDtx\nM/DyaF/OAtZ2acuByujhgyvC6ql/iCP+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaAAMce10L/N7gq1gxTf10dOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjgwYmJlMWEtYzAyMS00YTNiLThhMzUtMDcxYmRhNWVhYmY0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjM2ODY3MWQtNTUyNC00ZDQ5LTkxYzYtMTBkZjRlNTVi\nMDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEO1RxGZy60b7OObO6jgcbuAhp\nggVSS9aHQvU11A43qmofAIjVLkD++ofngHA5gsg1deZhnnZzy08pD034DUspcqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRSsJFyD+jlg5NeGTRC6hszzZPRzDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22FHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiB7NbONw5egccYdlAoxi7APl5wsiXTKlfte\nxqBg5lmIywIhAPJ/Y946GuIDovR/TNlEMx7FIZuf521m6H4rI31EI1nG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9119", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9119` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAX9UKyvGNA+J0hwHV1CWkaQcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU5YjUyYjY5LThhNzUtNDdhOC1iMzNiLTAwODc2MDM4ZWQ1NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2EzNjNlZWMtZWJm\nYS00N2FmLWIyNTMtMWEwMjAxMjJmMGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqrbB1+JSByuo/R9WbIfUreODTUOzAHlisit5tDGnFiJkrlXAR8UhOp02Fv5b\nmczcbYHPKXqxvuHgFobMm8LluaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU70VWAX0JIgkTW7JaOCqxAOyYqZEwHwYDVR0j\nBBgwFoAUZiaJAa3gKGYN6Q9uNXnyqInw2JAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDTk/Y23loJUe6x23pSGV8TBbqw\nkxOIRU6gC6lsFP601gIgQ+9PqGFmva1xJAvbBFXvfg7fWUx/auSwWUrvAwGmQhA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVq55D3LPnuHDhJqeyY2BOc+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nOWI1MmI2OS04YTc1LTQ3YTgtYjMzYi0wMDg3NjAzOGVkNTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS+4/Cp3u9W0aPcLxoHLDZaxXAK9gYpmZu+J1B/UhfvEND\nVImjp0LtDRt9o02Jf6VkFypMsPEvuBJKUEoHEaWJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZiaJAa3gKGYN6Q9uNXnyqInw\n2JAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALB6I8hH9BrK5Sf5z9TzDTEVZIB9zhjRVeBoNLsubUrEAiEA0Nh0jp6H\ne82E9R8xmOvkl1Xg5kyOm/SAgb4KzUMEjTo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQrJiJptJewY6sYdu9f01r+wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2EzNjNlZWMtZWJmYS00N2FmLWIyNTMtMWEwMjAxMjJmMGM4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGMyMDU1OTYtNDAyNi00ODlhLWI5NDYtMGQyYWIzMzNh\nYTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuFiHqh9ValDcCeptmQVXC5Bk\nmCsosoKxRd3884VqkYXxltCqXTr9l2JsIJ5FxNKEwTDi11pWKAsR9pPRxitsVKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTvRVYBfQkiCRNbslo4KrEA7JipkTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22GHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiBRGN0tT4XfH+HgOCmGvELdC8bAaZfnO2Q0\n0BxTBRhjpAIhAPDd3+PjNovvaO4ZdQ8Bmy46/7qj+mHeSiW5LKVPR8vQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9120", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9120` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISARfsjbnY8XKoZOvqIb1eJbN5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYjhjNTJjLTEyNWQtNDVlOC1hNzBkLWVhYjRiOWJlOWRjZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzMyNGJmMTgtNDJk\nNC00ZjBmLWI3NjMtNTg2OTZlNjk1ZDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyfwLDlSJ0Qgp1PkCMBKYR0UmKADzV4I6QpPyFFAUeRr7RnUY4XqkdEQJO82p\nvDUjv1TIAwa2aiAHvML9b2FFzqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTRtjRa0th/VE91txq74XYkMlMIjjAfBgNVHSME\nGDAWgBThKamYQTXPcNfZD43yd83cUWAs7DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIF/FKbXJ7fBruPyhCGYOgRjOmOhQgIXQ\na6K9gxm+sWADAiEA9VP6T/VY6xOuIbOT4YTW4+pShfM12Y8oOe23lP3yFgE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARFAJbaEquln0fbZzyAEnInqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmI4YzUyYy0xMjVkLTQ1ZTgtYTcwZC1lYWI0YjliZTlkY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATlFwZ+J3CEcjyw87lsxYtPoZ2BeZA3nYqEA16jEAmAZqpv\nmNZwwqBO0pV+7Yf3xlt+iBX7ak145mpRf6pBVommo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4SmpmEE1z3DX2Q+N8nfN3FFg\nLOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHSAXhFJTib0v8FRqfOK2CJi/0nz13gEElVybgMyTH1gCIG8hz1YFJXFl\nXeQshwdo2kz1pk1D3jNPlCQ2paMBsH0Z\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAV7BTDnBDy+ONNqHVVgVnYcEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzMyNGJmMTgtNDJkNC00ZjBmLWI3NjMtNTg2OTZlNjk1ZDMzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTMzZmM4ZDktMjM4NS00MWJmLWIzYjgtYjcyMjliMzAw\nZDk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp2fRvpAj3F9+Ep2pPdS+NEFP\njKqTqAwIfO4+3unsIfHycC2lg3fEXp7ajjjuTSLfn7MoIOTt/rytsoAYWOf+BKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTRtjRa0th/VE91txq74XYkMlMIjjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22GHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEApMFZljBOXh446YzqtLI2ZBnXbemvGbUV\nmxZ6FN4xquACIQCE6ucUrZJWYbFNIOQlmNk2Mb5X4S/cWx4AQl8T7XJLRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9121", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9121` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAT8MTHAE1kIVEHlyMXO0QxmjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0ODA0YTdjLTdkMjctNGU3NC1iYTQ5LTFiNmE4ODk0MjA2MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBkZjE3YTktMWIw\nYS00ZjIyLTlkNTgtYWQ3MjlkNDNjNDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEup9ocOrlLEIkZfOKWxgPIkm8Ku7N3wIf2byRXQA0p2yp8U6ThMfb+Rm09ZC0\nq/QBFP0iY+zdSZ7M49FqyfX+pqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv9fNNKsjfxsvMrqcJqPQ+1COeT4wHwYDVR0j\nBBgwFoAUOKDvJSU1CFl40w70YVAEeVZThAkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEicGjD8g8MtW6KdkUUEhEZcU8vd\ns5/CmT7tJE7GNHH5AiEAk7UG9BFXmkvFNfKTHoVmGLTUuy8xvDMKhzhJ7S6td9Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf3xaxio6aUaLefvDVVFJgY5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNDgwNGE3Yy03ZDI3LTRlNzQtYmE0OS0xYjZhODg5NDIwNjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqxJAKe3+q61pHfUgRiTWIPr/1bCsQt0OVbU0LEs4vlBB5\npo/vFO/yUslmgaMIOZEbTrwCE96IjQusPk5/PkJSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOKDvJSU1CFl40w70YVAEeVZT\nhAkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMOqfZ8TtRO6jvdc103/jcSisA5VgqKI2VTm08eDe570CIQDNgCADXL1W\nzjR3ucskM1x5tmbaSh8vVrwLIhG2c580Eg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAUnEzWg4srZcyP+ETa/LJ2zrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBkZjE3YTktMWIwYS00ZjIyLTlkNTgtYWQ3MjlkNDNjNDAxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjhlZDQxZjgtNzlkZi00NjA0LWFmZWItNDg0NmIyYTll\nMGNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEujrEAisGUrrA98m1d47LZtj8\nc3PoDMhxYKrTy8m9SYeQYK3o9MuzkwzhJfu3YEEHnEQL3O1MtyxBkfS+704rMKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS/1800qyN/Gy8yupwmo9D7UI55PjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22HHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiAdHLlzlDpi8+XRhit6TX/+CpMtRqGLblL6\nt2APwKnoIQIgT+CX9s8wZC3ghSKyO9JgcQZ4+pmENHuVaHw0EQOWsCo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9122", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9122` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUBCS41KlAa1E/icCp2R4ug7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY1NjdjZDlkLTBmZDMtNDdhNy1hZTQ3LWY4MDhlYmQ3OTdhODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDVmMmU4YjYtNDYz\nZi00MjhjLWJmMzEtODNjZTdjNzY0Mzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3JWVRnnO/VF0ZhdAusLWsvlsvZZa3HauBZ+B8s4ytlZsnq8ivlRz/Nzq7Eh8\ndJpaThYPvXALf77PZRYjC4H7xaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQGMDAkCekTrpe5+TD1N1tynvkTcjAfBgNVHSME\nGDAWgBT84HNwpAyW983bLXfDZiGdBJYiuDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC6MuwzMAO2VtmGrS5AUcu5fv5JwY2R\n8wANwQKUQLLEuAIgQAXWtZ08HUiEgPFuZbxSRGZdwHMagAyBw1NjHPX0WS0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARfECFxGo/S8Tuhvi7fZpmSRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNTY3Y2Q5ZC0wZmQzLTQ3YTctYWU0Ny1mODA4ZWJkNzk3YTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ3yyoVxmlG4YofdGBLUbDjnA10P4vsjt/M5CN336+6KnjQ\nO1gOmkPNGbPdAwq98gGT9PkSXHQR+/rMpHqQh2ECo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/OBzcKQMlvfN2y13w2YhnQSW\nIrgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgHIDzYoiy/JAvhmj3PAKk9Pe1tgHcoEUQGDbRoXtqvPUCIF2NHQ9lxnMK\nrEAkqTjwiPixDm04Uw5LXYMbbPJut6Lp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYx1ErXGomK+sFE9BcJLJj50MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDVmMmU4YjYtNDYzZi00MjhjLWJmMzEtODNjZTdjNzY0Mzc2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWNlYmQ0NGEtN2Q5OS00MzQyLThiZDUtMmVmN2M5Y2Ey\nMGU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECX9tjf55jkCOd09X6pmsGky6\nGbEpxN98KJiZm3IniAH2m+DEtIxXoJZYKRxKbXSZtMFrd1xtH6mexrAOknIgSKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQGMDAkCekTrpe5+TD1N1tynvkTcjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22HHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiBADQ5wfif06XRQASQjZFgjRKgP7IFRwP8X\nMf4CcSlapAIhAOklSiYcYP4l6ZjJkUzN2rkje3H33deq9dNoHn6DZn9X\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9123", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9123` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAYI7VwKLg6yfDuQ80PsOOMyGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwMTcwYTM3LTNlZmYtNGJiZi04NzNhLTZhYmZiYzEzNGU4YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY1YjA3MzAtNGEz\nMi00NTI0LTllYTktMjUzZTE2YmFmZWQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZtWy2G5WdusTpifTmFKJNhcA3gi+I0SakqajoAYBqhMCfj+loiHkZ5lErQsW\npuprz0nBR/SiicwEbK7SnqolL6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBVZ/fHoxd1SYJapTmiYQMIgodYwwHwYDVR0j\nBBgwFoAUvfYfq3JSYxhjFmvUFUPnCQW5wRMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCWNtVJRqNAmrDIf+v8MZy4ajG+\nNbcq6KzHnW51an0hkgIhAPuyVVYiUtGqF8NzNar5h3ful6vrAyR0xNXjkBwz3wkn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfiH0HisxvS/bdkFLHTS95u1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMDE3MGEzNy0zZWZmLTRiYmYtODczYS02YWJmYmMxMzRlOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT4WPVfS2CNm/vqoPTDUOBWs+/05i1fB7ovkaKXQk7WUo8V\nG1rUl8/WzoT2d6kKTBnzWTbO13w2W0qTIIleIzPpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvfYfq3JSYxhjFmvUFUPnCQW5\nwRMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKIedGsgzQVWiLOSLsZXXTdhoL1PNY/VocYIUeW98gwCAiBlRROJRwV3\n2OH8jMXj+hz82ZopeN+G22zv8+Zrl+MeEQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbjPGwMbkAUj0xA4QULx/fjKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY1YjA3MzAtNGEzMi00NTI0LTllYTktMjUzZTE2YmFmZWQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2RmMjJiYjgtNGI3ZC00ZTE5LTk3N2ItZGU4NzIyODA2\nNTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExG33kA2sSTwRj6L8AQeM2gl7\nluTQ0BKbKIiYpINIUJad59xDWwpwXhA9WK02H/iVKUeg8wCjItYRxwIaEkP6y6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQFVn98ejF3VJglqlOaJhAwiCh1jDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22IHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAYhGCod2JJG+BoXJZS9qXq9WinY7ALl9SO\nC8knM2R4UgIhAOG4sES62EAki5yngs8qCxZ04HJyKUbgLa5z/24wGr52\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9124", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9124` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXS0pUnPa2y6RlqYlwTSuwWQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMzA3YWQyLWM4ZmEtNDRhZi1iODQ2LTNlMmNmYzk0YWRlOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVkNDc1YTMtYjIy\nZS00ZjQwLTkzOTEtZmEyOTcxMGU2NzVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUTmx6VRk+sbUr8siv4C8tYjRdqNH3yczKcqIG69ebYzTFKstVlb+VCIexw2H\nyJTkzvjtp0MdG6YEsNYdhMKh7KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQc1Og/PvpOj5iA7kORj3iP4LMcrzAfBgNVHSME\nGDAWgBTRbMN/LAkdnrmEKe95V+yasy/OiDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBUz12YF4exCMlfr3CBbyhbJWEMHEnLD\nXuDQYwTQRsEIAiEAkpdStaiMod/PqsClwgib9nuN8H/mWmgsGHJizEBYIc4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb84Eo+I6elyHplQ1aLEQjdeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzMwN2FkMi1jOGZhLTQ0YWYtYjg0Ni0zZTJjZmM5NGFkZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQRIiudJwk+dZBaKp4uBp0pwO/x23qV2XNHMX4VYeNzBZgK\nJI329BmojzBWZbh8YRCXS7L4qPpdTB2Y9UaCYwZAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0WzDfywJHZ65hCnveVfsmrMv\nzogwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDOc5VajB3Lg1HurTk9KZnVU2J7kCVkr319CaXJw3coMCIQDmtF2klxRP\n9X/0KfwAHG5GJHvjbAxXJ2R65pck0ENV8w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAaYk2vfF73xCUW06iuHQgu7UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVkNDc1YTMtYjIyZS00ZjQwLTkzOTEtZmEyOTcxMGU2NzVhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQzYmE0YmEtMTU1Ny00Njg4LTgxNTAtNzZiYWMyYmYx\nZWFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5zNv+EmBnftnLQHIQFSCX8nJ\nxNYrLQSt5DpxByLxoUI20axJryp/RXDWvGo5wKJCNQctV94FGNzRJdPOklaAzqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQc1Og/PvpOj5iA7kORj3iP4LMcrzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22IHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiBsO82zcmbhgv4E1/MIrM01D/bAbi8eKdB4\nQFfEwOEE1AIhAJN/polDt8eJKHThqvrxJbZzhPcnuOs3h8o1ia9ecpae\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9125", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9125` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYoODza1xIdUt0j42KreYXLvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2MTk2ZTA0LWVjMGUtNGEwYi1iYzA1LTUzMzYzMTU2YWYwMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjkwMGQyYjUtZjc3\nNS00ZTAyLWFkZTItZTk1YTRkYzNmOWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvKdmYMawNbbYuJq1lufkfNqbDjVxR/mXmbzXTZiUITcIf8RUc6PGQzkvJB/c\nCApiCKMInKMbDZaETw08rT/pA6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURjJwXs2BbCPK38xRiNLoAsSijMYwHwYDVR0j\nBBgwFoAUqXLJEyu3Xr1pToS4OJsjJgna/UgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBLvLVlid1jT3KOYpra7wk1Uu6Ox\nwy0UeAJLb35aRisSAiEA2Ja2TCR6uS23Ua1rKlCi1dqVGTmBpnsHLeW9MdyxFhc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQRUOTWg3Mw/zQ6mBJawP2KvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNjE5NmUwNC1lYzBlLTRhMGItYmMwNS01MzM2MzE1NmFmMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8sD89iolf/ejb4viJZ4JN2vANzmUCiGNjWysZV0WZvftS\njsbG2UOPPwMzmL8lox/1MYO0gX5TxzOD3PZ72eDKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqXLJEyu3Xr1pToS4OJsjJgna\n/UgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbZBDDKhhtczLv7gI+DZVlNo+9lKyw9+pJzbLJc70XAYCIQCIFOC2SXye\nDZPcpfleBPnLjLiL3NyRXq1J8Wh6APKQGw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAV8qiJB7yUVLVeTzybF5mOiSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjkwMGQyYjUtZjc3NS00ZTAyLWFkZTItZTk1YTRkYzNmOWFiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2FiNDMzNjUtNDE2NC00YjE0LWE5NDAtZGVmYmExODdi\nODA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6vEpNgfyaXI4Ga4Gfak57plY\n+c1QPmW3gfwebf9CI3673uvV6NyNOvlfZ2DdTwAJlbFtupJNn/JP7mYFuN59JKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRGMnBezYFsI8rfzFGI0ugCxKKMxjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22JHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiBKfiFXPFou4RerrxmPypFczvZDL6yL7xpM\nZBbOLjxu8AIhAO5peomQm+/vV9H8iNLI8azYQSH6nw92RYgWgV7pYd0c\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9126", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9126` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAWRkWCna/zAdbQgh3ZqFYJquMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjYTFmMzgzLTU2OGYtNDUyYy04MWQ4LThiODI2ZjZlZWY2YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjUyOWVlNDMtZDQz\nZi00YTliLWI1YzAtMTNkMjdmN2I2ZDFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpIZHVGQvyXveBuM0+V8sDpkuVWFpWAEyEJM8+sAI6jnwRrZFd2SxeKir6hID\nxRVO1IHNQnnv7kH1mkBar6ngBqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ0Wo5uOpOrRRR6q3Ed98tmbXqFqTAfBgNVHSME\nGDAWgBQ16ZryEr7Aw1vMSNrKgTlOlWsDAzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCtPgCNeboDmfTSLYGm/vI63z3OEKIk\n08DGVtt/rCGeagIhANhwlt3iIQMdNSsgs5RITlvzy0yeXTWCewLdV8Tr+tf9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARB4KwRphFaj3NymVjO+eGP0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2ExZjM4My01NjhmLTQ1MmMtODFkOC04YjgyNmY2ZWVmNmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATMjoEwlZg5zxMV/FP7wonF99leGg60SMAbTpTprlpJLGlS\nCQVhJ/uyRAmZBcxIEVJ1zYQkQa4sphWqKSajQhJHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNema8hK+wMNbzEjayoE5TpVr\nAwMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKYgpRc2ymUe+zVtVmBuROdw3vyqaw54//7o+Cn3DVuwCIQCxli1+icQ+\nIglZOy9urjVPpeSvg6cu86NAIsBlL/J2jw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISARDRhy3FUbKnTKGZAlYeDRoKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjUyOWVlNDMtZDQzZi00YTliLWI1YzAtMTNkMjdmN2I2ZDFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzE1MDI4YzctZWI4NS00NTQxLWIzYTItMzYwYzQ4OTQ0\nNWI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOuLXok2pF5oXOCked4VdmiSj\nSAhJ+Fxpme2sOLz1vxKFC0zWBiBBogvK9BJAuMjIO8VROPLNWqavnVkepn7LP6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ0Wo5uOpOrRRR6q3Ed98tmbXqFqTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22JHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAyU87K9MKV+ri+88dafk/N5xpjr7rWo3Q\noV474xw3Q0YCIDtEKqiUHiE1uVD8T1uYS6olCkwvkfP1i9pCBaBikb94\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9127", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9127` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAUiSu2jlHKGxtHltqVmanIeBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2YzZlOTAxLWRmZjUtNDIzMi05ODY5LThkZTkyYjcxNTQ3NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWEyZGFiNmMtNjAz\nMC00OGUzLWFjZjYtNmExYThmMTk1ZDY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfx8U8i4HBV5M3E9beusnoqoLUDDsMPqG0DCMbNOanFIrOXXppzfFwERNRoc4\nV79tWwoPEaQPnvnBShdZSvBCnqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE2u5E7/tahJAl/hxRdvch128+JgwHwYDVR0j\nBBgwFoAUPnAlX7vcTVuZu9jC53iY/arL8RAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHZOc/VYejOSORH6OFp7kvCf6E+4\n1qZv/juSXeluoPgGAiAGc5R6KzoIt/ByWYgYTkHznOJrqWXtZ9mWcQDDwqnzzg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARhyl35kiNohdhvRhvAxTNv4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmM2ZTkwMS1kZmY1LTQyMzItOTg2OS04ZGU5MmI3MTU0NzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmZU9UOSGDa4oIjtNcqMDJNiN5yNG2+XS2bxFLqOfgs/6l\nhFXt6/4fJA9IG4cBwxjyQT0t+aAoHrDwGll+4585o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPnAlX7vcTVuZu9jC53iY/arL\n8RAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZ+ydWwGBzmj6NU7alqRM39M82M3OthgbliLNhRilEUUCIQDkcBz1zfrH\nUHGAovuRaDrW1FwOJd6fdF/HNX2qWIzCcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZRYAuYlVXI6s3mqIHt3urMwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWEyZGFiNmMtNjAzMC00OGUzLWFjZjYtNmExYThmMTk1ZDY2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzFkNjI2ZTgtNmExMi00OGJmLWE5OTUtNWExYmI0YWJi\nYWM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9+gpS6SfpmttTdtrV5tubusQ\ne8iA7SBoVUk5hKjhwRJbWxzSaaq9Ja08WCmPCdHdkN6sHvnhCw6ri5pP550aC6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQTa7kTv+1qEkCX+HFF29yHXbz4mDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22KHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAkMXxSLIka7Pck4sVRXsQ3x17Dr4pc4Sg\n3G3lJFZ0BGoCIQCrNFSs1bwHDhAbWHBnAIm0Kzs3Tmq0qgtSuNDV4WokWg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9128", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9128` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAZMbrzYT0ZdfxjTsRnJQte0VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0ODhkNmZhLTIzMTQtNGFmNi1iNWQ5LWE3ODM1ZjZiN2MwYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODI1YzM5ODMtZGIy\nZi00NzRiLTgzMmUtZTc2OGQ0MzM3NWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh27LWfRgulYRTsqRC+MnqKxNMEK49DDzBd2g7KCNNNhpGeZ16JOexpuxVZJM\nuvvbcXOFF43exhT4d7So7nGAaqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTvYiHt5Mn05q/7f63m4/+lA+udaTAfBgNVHSME\nGDAWgBSrJmn6vkxHy+0xTysghGLench0WTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDPPx5Dh8Ks2TwiGX/Rp5PAhv7+MDkJ\nAk45ePHAUrc6IQIhAJF5Cj9K3cgBeOyUOACbm6ZPGAXqCULCg7VIYD1LXKl5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASJJwfpZCv9yVPiTqSZRBXGLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNDg4ZDZmYS0yMzE0LTRhZjYtYjVkOS1hNzgzNWY2YjdjMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJNOpoIPIhuxpRUuNs7V0R3IdJEhs/Nmjaks5cttKBemXF\nqAZ3XhDIGtyql6zK0+nsTzuqb9kjhL0kqHSXPHrao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqyZp+r5MR8vtMU8rIIRi3p3I\ndFkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgD/rFKzSQdGiWTUJhyv6w/fui1rqgDFgTcw2ENogiA8MCIQD7YutGXEYJ\nH7C0NT9txPs5SbIIUW5K1Pv7I8Dg/o7ycg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASSCIhebOsVqWZ0ss63wNkeiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODI1YzM5ODMtZGIyZi00NzRiLTgzMmUtZTc2OGQ0MzM3NWMxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmY4YWVlMmMtYTcyOC00YmIyLTk2NTktOGQwOGNhYTRh\nMWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8Y4GmyKlHvrBC9fmNbaUi/OM\nH71p1RBfzAJcE4o3pZQHEkP9B3m/PdBX5nTZDQeuP1XhAmx7jgsv9faxB2rbi6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTvYiHt5Mn05q/7f63m4/+lA+udaTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22KHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAs2wi780lkO4BsOy94xx/hfS2O7ZtUm4W\ntZksEclb//ICIDlbwrEd5jb+1cAWJhtWTtGVYVUgNsgj19XeZPFULw8U\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9129", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9129` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQQDQnMg0ctXKugKaKQiGz2bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3ZTVjNGMzLTk5ZTktNDIxNi1hNWNmLTM3N2U1MTE2YzQ1NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhiZmM5YzItYTBj\nMC00ODliLTgwMzQtZDkxMzcyNzM1N2NjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJyojyXF2iytIyLvoMdWYPvL0pH2Ak71mV1bJcSVZZWdKG22jdYR3DinbhvIh\nz+RJCqxUQKS4qGj2KNx/ocgI+6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK27ANkn0ifvlvJ5vyazTLVgjCWAwHwYDVR0j\nBBgwFoAUieYSsismZg31ditG7RZ40OJsxaQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCy+mFCNSStanhFuQcXlSI4vqGd\nUkPUumCK1bpihIlxjwIhANLZA5cFHYWD8ol+NGSlI5QPYQaHJCcB988UjrMpAxtw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARQEI3Uh/Fu+G33DI3wfUstUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2U1YzRjMy05OWU5LTQyMTYtYTVjZi0zNzdlNTExNmM0NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxwghKl835o43PC5yjxCavmPTyouNJOEBlYcnQbRlLSqO8\nG+YT8HPhwX9cQv+Yk6WGKkmPJNL4HZE1az+iEN/So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUieYSsismZg31ditG7RZ40OJs\nxaQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQGdEUeGGe0vTlyXRTN+LjNzJrytA4PT+5TWyfvqR5uACIG2jsuaKD/SD\nsSla12T/GGcVYzsGRiyWE/g1bjeRfMTV\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAaWcH+IFkw4yWqJtl4KhqO6LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhiZmM5YzItYTBjMC00ODliLTgwMzQtZDkxMzcyNzM1N2NjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjM1Y2I0YjEtZmUxNC00MjJmLTg1MGEtZTVjNTBkNDJm\nMzA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmPyhoUaKRKh/TISvh3puEwmi\nLaJRei31yzzsb0EjR7TwZdBv2k2tpC/2+7WcmDOuvMncm1nNMMzoqx6vUL2/QqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQrbsA2SfSJ++W8nm/JrNMtWCMJYDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22LHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiALpiT0ewAG4TAd204VSdgYPFC32vl98QDh\npNyyO3e3CQIgDhhUZXBmOOdOoh/hj6Rd+XoPO8DQwcVBOUH2y3o4Cdc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9130", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9130` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYcJZjrX1Sq3/mVoenbmn4TwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0NjI1ZmU3LTliOGMtNDAyNi1hNjZjLTFkZDBlN2E2ODAyNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjhhMmJmMjktMjQ3\nOS00NDg4LWEwODEtZGM2ZTRiMGZkNGY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyIdbI0FOtLXD/+HPuSxEwHT17xXXvxPj6bhFavv6HOjAeR0OEERBgFbhabEU\nuTAW0I2vCrgu5w5w/AkBAnDIB6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRo5EPzxbk0LJKE5iWCMtz/aGm6eDAfBgNVHSME\nGDAWgBSLUtFYJ4nBoRN6wYQ19vKBT+mBFDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGnSel/Sx2zg1leYiUD1mhEoT0qDG7uI\nVBYdJZZS1jT9AiAUmCi0X9nEkNptRXhXbu846vdoyS+Um9xOQATIkTftUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAcWxL2mZqLC+pGRWeytXEnivMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDYyNWZlNy05YjhjLTQwMjYtYTY2Yy0xZGQwZTdhNjgwMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATSUtXJIJ86VyHfJQwhs6bdtclEFwPJLBTup0e/C+hnSTsj\nR9evw6Hzb8F/Z+Ly0ceakyw07DK9b6c2cAhvj+/Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi1LRWCeJwaETesGENfbygU/p\ngRQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMLJk0f7D5M1HRJTpSYgWLTeHzyjnFnv7LOz7tEWWvMMCIFQGd1fK+8l3\nwGAwgV+wRz0V+VoIep3/bUc3zDZ4r1yn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAcJ9UwyDddcpzF0FKQJMlcDlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjhhMmJmMjktMjQ3OS00NDg4LWEwODEtZGM2ZTRiMGZkNGY4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGQyZmY5Y2MtMjQwOC00MGUzLWE2OWQtNjY4ZTE2YjIw\nYTI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExhFzlIoLBdx9gJiEKi/IjmMi\ncAMLQXENouABbziFKfaU7TIsN0WEiDGBv2c8qTOpVURhjU/vEScpyzwebYjbn6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRo5EPzxbk0LJKE5iWCMtz/aGm6eDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22LHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiBIMuK2LwmSA1h42FKwgybiY1JAOw/AhH4W\nQKv8g+NGsQIgVS9v5T+XRlrIdyUN8HOOr170zgRCEh5UYLGCnhNZe14=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9131", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9131` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATeQYxc5XqDs7HU75tY0wEHvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyNGRkMzA3LTRlNzQtNDZkMi04YzY4LWJlYmM2NjNkMmQzNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzYwN2NhYTctMzkw\nYy00MTRhLTgyZmItYTQ1YjU5NTdiOWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2D3cSiF9P987y2q73BX7vlxU06qnTMJBTDJf+umAv5wX6EznQy2Hjyv5W/GR\nLChbCja/IryrgcS3YYy7Wy0raaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe93QZ3nw81xSAWHMSuexBevE3I8wHwYDVR0j\nBBgwFoAUf4f9AMaeBGjUVXyKDL1oqswkQsQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC+DdEflHzyng7sK6enE/X51bhV\nMuCOY/andGDaZ5P9dgIgB8yth4imGzhMWxHuuYy4vvt2oT7qSu4b1hzMqvc/kpQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASq1SDiKpRBYSmoxDwPqIoF8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMjRkZDMwNy00ZTc0LTQ2ZDItOGM2OC1iZWJjNjYzZDJkMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATn4CWF4J+eJcH52cZVk/Qx5KI4t5xtxkHPC8jgw/1+O0WJ\nIZ90IsI+kTimN780Bhpr2g+vJuuzspkj3zlR9Nyyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf4f9AMaeBGjUVXyKDL1oqswk\nQsQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI1vaYURv3gZcmMhoPpDkEu1BTA+kVMPgvh9U9I5cZ2HAiEAjGhCJ9r4\n+lkHVM4VrHLWM0hB9ZltO6w/WX2Zz42/s3A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXxoajE514HuE/FdVEL+8GQdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzYwN2NhYTctMzkwYy00MTRhLTgyZmItYTQ1YjU5NTdiOWMzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjY0ODQ2MjItZjNjYi00MDQ0LWE1OWItOTZjYzA3ODIz\nNjA0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeGFahafRl+2cuq6hnz2F9WgQ\nm6MMLv6cZSdDqMVUsJzAOnslFCecjePRgxUa2w8NF8aZ5h8vAPe//s6P5QbbJKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR73dBnefDzXFIBYcxK57EF68TcjzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22MHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAhRvACbEOvEF0Do4fdnRrhnAjF74ZY1gD\nU7hK3LViQ1ECIEAOHffG7IiF0isMv+wAGYmGuzYtwUK9tUotvoRnFknm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9132", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9132` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbcVMCp+VrSnxzZyn9/h42myMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyMTJhMmY5LWFjNjEtNDYzMS04YmJhLTAyZWFlZmRkZmUwMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc3YzFjZjItMjBj\nNy00OTc0LWE2YmEtNWVmODMyNzQ3ZmYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBvs0d1t3Y7tanoT6TbT8fnuofUnRQGtGRNyzNC1uqSg/LFy+JRBbIOjI0cd/\nBwDUy+0pd4OIQukfk3TRjldo4aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSlE7AHOENBhZZDAhSakCj4LYcfVzAfBgNVHSME\nGDAWgBQvXWp04ZX8H65Dk0xeg5PwOk4gMDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIC+8glXod5YVhngEW4DLgqYhPheaEKu8\nCLgl5jTqwtbAAiEAjYjRLfAof642eZlgLanFFpJUZMd8FZQnkiv0yi7xDEI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASIyx9tNsuZq4/tbL45pRGp/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjEyYTJmOS1hYzYxLTQ2MzEtOGJiYS0wMmVhZWZkZGZlMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARZptWRuCzQ4PZPEzD1diNNGj0J3DvyXvJctT0Vy2JG6LVn\neWisEpjYDvtHBdDQxnJKeoWGyyPVuu/NgVOQq4/vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL11qdOGV/B+uQ5NMXoOT8DpO\nIDAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMtmONLl6F0HH6z6rSoqwtFypShEPxHBA+ehDJUYG5JxAiAgzR+3we4/\nYZcQ7ChciMtBxi35h2ZHE0SgQrmv8jipDw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVdaQIV3V/2mO9MYfdWHgQP4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc3YzFjZjItMjBjNy00OTc0LWE2YmEtNWVmODMyNzQ3ZmYxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDA1MGI2MTYtZjM0YS00MTE1LTk4ZDItZDJkMDUyMmVl\nMGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEs3eVJnnWT5I9iBcvTmOqRfO1\nmynq6t0iumwFWU0g7lPsdIip1GtYAEsuKvKx0wbocwAatCISPw12LogOmYNtw6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSlE7AHOENBhZZDAhSakCj4LYcfVzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22MHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiBJtir+51x7q3VrfqJrBhsspNzHwjoZTjX/\nMMHRoeoyKwIgI1U/x1yxoGpVuxUcQ/CUi3xz2N04nJnj1hHCiMIxC78=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9133", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9133` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAQK0ppr3LIsoF5cBy1nkEI4pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBmYjgxMTAyLWVmZTItNDhlNi04ZmQ0LWE4MWU5MjQ4Y2Q0ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGFkNDdhMzYtNDA4\nZC00ZWVmLWFiZmItZjgzN2M0NDc4OGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWTlWVKpHeydI5HVnDJinV/JVqbY7c6cm51E8W8Fzsgv83S+rv1djsGiEITKU\nLhaovq/RosEZQLPbVWXDp4EUw6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa6Wp00bPwZHducd0vacJChStkK4wHwYDVR0j\nBBgwFoAUn87xWjs3K6xiNrWTIoJv5M/W/xwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBR2Wyy8g6L08QH+L6Hne9WUGl0h\nD4gl+Q5OntDWKJjbAiB8q7faPpHQKbvvNUEmRIUc8Wg49WxPrubRTbjSD/mfLA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYwmxrug1Clbm6fvoeu0+qaCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZmI4MTEwMi1lZmUyLTQ4ZTYtOGZkNC1hODFlOTI0OGNkNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUpZQxI63KtGRjbp1moukc9x55YwFbAAcfkDFol20aZd9B\nZFxsi0HoZwWm5kYsZYJ9Qk8AlBQyAHGZn2bqZQcLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUn87xWjs3K6xiNrWTIoJv5M/W\n/xwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMiHIlddVoEurcBfoIkVhuLDN+3ycFltOI9DZBwu7ZmvAiEAtQJ2xSj7\nW/E9Iy6gTq2nmD+LV4rL6AJHGQBb3lPOlgE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAZ7oDmGBBi4QKBLB9YKbMyfZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGFkNDdhMzYtNDA4ZC00ZWVmLWFiZmItZjgzN2M0NDc4OGFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmE2NWFmOTItOTI3MS00NzQyLTg4ZDMtNDFjYmZjZTRj\nOTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6LW/sCPqYR0w7qWWpjqkxPet\nEcjdV3ZCMEljkV8MMr73ThsgC2wsELK2uOFMQpbyD+h/QvuuuS4PS41beVvtpqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRrpanTRs/Bkd25x3S9pwkKFK2QrjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22NHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAWUAJht2AWywxLYgHNQrL/mpdG+0XUaoAt\nagJnYt0figIhAMRj+Ua7+gg/vtkh3iU0PHA31zu8mzbN3eQIJH6oL7n9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9134", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9134` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUB2PJXY/6j9YZp2D/oHOFlfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlMTJlNDNmLTEwM2ItNDhjNC05MjA5LWU5NWU0ZjdlZmNkZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGM1NzMzNDEtZjk3\nZi00MDc1LThmYzUtMTUxM2RmNjNjOTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEeHB/13iu8bMt+mM+j1e90TmjekNsGPtVt6Vum0K0Rx9anWL5V4C39Nsoc9MA\nX9MXRf8b4leq6oN9JkS4L7LvuaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQBwQMz9JbHaXpvEfr+sJiN2iur2DAfBgNVHSME\nGDAWgBTj4TYl5WtGHJiw1Vrgk8kk6Bi/GDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEkZxgxOt1uNrXywQnjF2/c7VJ/vSgej\n+jIJq7RblN1mAiEA2KR/+9lIJgo13wx4hvPA317OZkHszStg5lB3f7Ze21c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASSjb/I4MM4D13T17WByEcpPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZTEyZTQzZi0xMDNiLTQ4YzQtOTIwOS1lOTVlNGY3ZWZjZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCFPekfBIaGs0L9VhR7A1fT4xVk04EakRyUc02lvWaxXlM\nsDvn06FKYxFJFTxu6CLGJJNSH1YgUz/o+JBZFi1ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4+E2JeVrRhyYsNVa4JPJJOgY\nvxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA1I9r2k5smJIBWpxoPyykvNlbXIx1JT8VPahwnJDCfQCIQC5WQA70yVg\nYxS2Fl2gmFMVWzmCxfNcFPXV+GNo/kKf2g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAZd/rZbaoVpfiie76Iik5mOrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGM1NzMzNDEtZjk3Zi00MDc1LThmYzUtMTUxM2RmNjNjOTM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzNiZWIwZWQtODE5MC00NDYzLTg1ZmQtZWRlN2VmMmM0\nMWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAES5VmlEOWym4xIX4g2kX3rTNf\n46ydVr4xo4tqcX0P6i9ndWtkVEmD3r1tLO4xdan9HXQ+xFizkfrzsJMwnmKZ6KOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQBwQMz9JbHaXpvEfr+sJiN2iur2DA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22NHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEA2woU+FHYTi3QEnLKdMkn3B1Yw8hcgvfE\nsW8ETRbDz1gCIQCv1xzCQkRKeP62zlFhhnOwiWmEC2kxpatK1cJrvTi1wA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9135", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9135` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAcoFWE0sWdM6JUH+ow9nwswQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxYjIwMTFlLWY5YzAtNGMyMC1hNDgzLTQyZTA1OGZkNTkyNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE2ZjMzOTctYzdh\nNS00OWJjLWE0NWMtZDE3MjM3NGE0MDcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDEzt6kucTwOt3H7XErXtlV9QK+g3Voov5RDA/qZpeFydMPIFYB2cAyAJD6v1\ndnXGRysbqgB+rPS1byBcRtvnhaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzKIbUSU4pp64B6rGKCUGvTJf2u0wHwYDVR0j\nBBgwFoAUlekv1hcPRxDwCfTPpJKUrk9Qz8QwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCniQ7E4RMFHDAATPsOCBEvPpri\nI2Y2SUOGDIxBwy9fAQIhAL0i9S8IlpGCaXjD8rP89Y816D3NrupdkwciDNe2OZ8u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeHzNbu5a62g/TCi4DaP0SYhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWIyMDExZS1mOWMwLTRjMjAtYTQ4My00MmUwNThmZDU5MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARm62n9f/tvC6D8j6m+u50E+fAleUja+OfxmIP0cHx1Jkpx\nRofhqGzpAynlAZE03N9Is7b1U8uudSvWgE0dfSx0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlekv1hcPRxDwCfTPpJKUrk9Q\nz8QwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbZqYAM1wXhaZZPCuu7ePr/vtbTGA24sTdyCuSOlBIIwCIGZAGAfObQrl\n8bZFkMGVvsdTbIHCDHUrImmHfX8Zd/jC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbeUDpBXhMSLagcqieSVd1fyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE2ZjMzOTctYzdhNS00OWJjLWE0NWMtZDE3MjM3NGE0MDcyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjUyMmMwNzktZDVkYS00ZWJlLWE0NGEtNjc5ZTk5MmQw\nNTI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE4WgofP08CZWdoErLnrKQLGJ\n2vMdPFFyoQYpiPEAlMo5L8tRxHbGvRZ7oKp4qx4xnSr+Yc372FUba3pF0ZyqqaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTMohtRJTimnrgHqsYoJQa9Ml/a7TA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22OHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAbV1H140v56pCKIm6r2vjaWlWOp0bnlW+6\n7K/BzARBEgIhAMCXRHGSdmVbiegD6Ayd1dmIJp4dTmhzp0BG1xefdY/A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9136", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9136` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAW56bxrKTOF2a93OrL2jjAILMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIxMGFiODNiLWI3YTAtNDFhMS05MjU2LWE1NTNlZDZhYzllYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODUyMTU4MzgtN2Zj\nYi00NzQ5LWJhM2EtNmEzN2E2NTRjYzZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsnNXiulhoFulv/lutMfYCcSAIK+azcXFZuAQiGOOwVIm45gY2iIISiJAoyiS\nhJHQy+kSCX0H7Z9IbTt5bCF8F6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSARjlrODUZY1BRQBYOvUT1lvFBcjAfBgNVHSME\nGDAWgBQk4MEQXOxWqyrjI0S4JVCfrGc67zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEqmLJ2OiJu0XMk4K8apMah/kn05K4oL\njczgSmZpygaiAiEAkc10xMQ/dDI/HQk1spGb4uiLGXqNC5U4137299r7Hus=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQT/HjeBOs8GQngD1lIzbV9KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMTBhYjgzYi1iN2EwLTQxYTEtOTI1Ni1hNTUzZWQ2YWM5ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATr8jqfhm3rLy9e/eev2O29sbNmPYVSdA1uJQOIJa1xTAJr\nEYr+MBfqitim72L3CM6TAoJjsmAKzwH3b7rDbji+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJODBEFzsVqsq4yNEuCVQn6xn\nOu8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPbOdwa2pYsWpKcBFiGC48xxYAKRWJWbdWUsPvR/QhgQAiEAvriPSs6T\nqmMacm59uaYhBTxjfiGO9w0N286CFbnCWXA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVuE+hAdWAn3ccRF2SlN8rgAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODUyMTU4MzgtN2ZjYi00NzQ5LWJhM2EtNmEzN2E2NTRjYzZjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmZmZmY3ZjctNzA1Mi00ZTcwLWJlMzktMDY2NjliZTZk\nZmE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEocpAZ2PHFjK5LPQBBjrEi3Q4\nxEAXw6u5EBMuUnRixW+vGYDJCGvUekoluZS5MNacltV4gXYzBKFT4FHr1PC1x6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSARjlrODUZY1BRQBYOvUT1lvFBcjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22OHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiAruf16VpI3iydyK66Jq4T7Y7kxr0hrzZyK\n5hiE64yQcwIgCW6KVzX5oJjClq0Iz8mtjqyGjfYN1WjjZAL6HcOZmL4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9137", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9137` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAbVhuYMcK2PuUcuJJCRSqMwoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZiNTYxMDExLWRlYTItNGVmMS1iY2M4LTFhZTc5OWVhYTg3MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQ2ZjJiYTAtMzVi\nOS00MjlhLTkyNzItZWZmYjllOGM0MmM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmaXd5vLNDSvVL51c9qU2T5x9lkNJOgFhveZoHQMFx8t/yPVoBpuHcjD1ScPY\n2ROuWFEaX4iy48XdnKLiPAMi0qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKs9pgAL8B4FCApvWOwQtAxbvc+cwHwYDVR0j\nBBgwFoAU5hhxi0wYvrWl7dw4F14CjunfRdMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC5WkH9CzuI7GfWI4p366OpwyJW\nGU0Q44AdbzQoy+fIeAIhANhXAt/JVKJgrGzmvyIOrHSo8SpesnK5qWmbmyniiQ3U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUJxS3qrmNK70IDX5rYVf/QhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYjU2MTAxMS1kZWEyLTRlZjEtYmNjOC0xYWU3OTllYWE4NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHBQLp3AmMNozRikProujJ++f//1g3coXxF9JveiXFKJKJ\n8ZooLOrTytUWXzYxE1m9lEqBFPb3w6b04kxPkIYoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5hhxi0wYvrWl7dw4F14Cjunf\nRdMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJYz4HJ+FLJotOUPcaoUTc+eGqwCBOcezQLKFmTKA2wxAiEAotly+kWb\nJjKaTOgPT3eul0E/u6rwIjE6ubRfQ2v8Fug=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVUSOEmGdNqrdM8gy8CfzDbeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQ2ZjJiYTAtMzViOS00MjlhLTkyNzItZWZmYjllOGM0MmM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDcyZDRmMWYtZjliMi00YjUyLThiZDUtMjJkYWIwNDM0\nZjljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOZY2Xg/hqqTKb1vTh6y/+ORJ\nsa4T49gM7zGhl1uiVkEHep0Rb9YOmggiQmOdCqUZh+IcrX/5l5o4z01/7cjKLaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQqz2mAAvwHgUICm9Y7BC0DFu9z5zA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22PHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAv8uaYoSvYzPEges/tYt4D1zyv6NZR9uK\n9VH4k7hyhHECIG3e3Ox+2B0QsdCDjSajJixkwdKYmSOqwP/WqnBm2iAB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9138", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9138` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcEN/P0NebJgKJV5G3zstOmsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDczMzMwMjAxLTY0NmItNDNiOC05ZDk1LWY4M2ZmZjRjODUwMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjlmOGM1YWEtNzY4\nYy00YTY3LWEyZWQtOTg5NDYyZWY3OWYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZygZoiq93TojSG5IMq+uSXk1SayKcW97/kQaiMRn2O8wkguJ+/d1mldErLER\nBlGUsk5sj5eeW7tU1oTa5rOisKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQgh9td71djdLRvllWNlQS1SQJvyjAfBgNVHSME\nGDAWgBRxRCWVEUgQ/do8o5S9lwM+q0QbFTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDNFBFRM8gMsdLV8mVjhWTAat7BfdeOX\nmh9npUW/IPCVAiEAt9LQurcof5JeWzAKNVXRKRZjI5oISjTa4M4UPi0Qn80=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbrBuyZHe/gOwGAuY6e6TqdtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMzMzMDIwMS02NDZiLTQzYjgtOWQ5NS1mODNmZmY0Yzg1MDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBgO/0gsSiTgp/ndb4N1bd8gH+p7ap7jBWeppcMq5Hn72a\n6oNFkgE3VT9xnnt4Z2UmQhMJ99Y58ti/kdFmAvgNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcUQllRFIEP3aPKOUvZcDPqtE\nGxUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgPhA6cYozUdgu2Mg3aTIplm2fvOO0sf11tpRE7Qns50MCIQDErTIVyE/o\nFUddqz+bN7a6PJget3ZDHxuVFTkHIZ27WA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYI9o94Bx04ut96KpcF0A51BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjlmOGM1YWEtNzY4Yy00YTY3LWEyZWQtOTg5NDYyZWY3OWYwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmE0M2Q3NmQtNWJhZi00NDg3LWJiYjUtODVmMWMwNGM1\nOGI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+PevMTRGh5y5UJtd4gFdACyF\nR0EMgQFy+NagkfOO2jQUjbVa/4cnNpX+dZWDSRXAOLlbmLPiRjdLq20tTLaHiaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQgh9td71djdLRvllWNlQS1SQJvyjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22PHmJhZC5leGFtcGxlLmNvbSx0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEA9ti1Rj47Ih7ophcZ27ZCAB79aJzN6OkF\n45xRLxSyj1ACIAo5PRBa2aMs0tuxAhEd5F4VEHdyQ5AQD/NNN6kvAkL8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9139", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9139` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAd0PaECXD8DRUI/6apsZgKBbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkMzU3YzE1LTgwZjAtNDEwMC1hMGJlLTI2ZDZmZTM3ZTcwMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBhZjBiODAtODBk\nYS00ZDRhLThmMTAtYzc0NzMyNDVlZWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6NzLQAyqwXwj9utB6q1+paFTQiBHTf3dtHl3fxOLrUKdyRmUDIDKvZvSYkjq\nclTgwoieuUbILeHNFZZLSmq10KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUv+Zdx562KUTiVzi64Hy9Wt/LNzswHwYDVR0j\nBBgwFoAUBQraSbQyzqZUOZpwp4OY25DlPsAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCUjoVsI1RVPWgzqY/hRL/jRx1O\nc9lhPCPa0Oee1+gknwIgOJo4NJQI2gcEQlCTXNnt86x48LVmUw5IFIo7JT82yeY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZnuJWC4E4MI8o6IszOMn+qRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDM1N2MxNS04MGYwLTQxMDAtYTBiZS0yNmQ2ZmUzN2U3MDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSfTRQghXqg3goAExXdU9HlmMm4GCGfRq5k35BF1KUSROa\nohHeTQ9IMajm7n7q8YoMjRv+1hJq2gwZfBmIx+tAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBQraSbQyzqZUOZpwp4OY25Dl\nPsAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZaO1B31nv3m3/GJuwHLyAYZ9EepDWJ6hStciwA0K1owCIQC8Q5uR11fW\naSBbtvnsPz6iU+Kp6GGzoTq8J7l8iWqIzA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAdowGcy51oB8j19eGizsgsPZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBhZjBiODAtODBkYS00ZDRhLThmMTAtYzc0NzMyNDVlZWFmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDViZjIyMzAtNGZiOS00MDkxLTg2YTctNTJjMDdhNjZh\nZDY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEljKSUaJVuAyZUctSBosoMHGn\nGOnMuUajvXSqfz2jrzZqq6FTZ5LiFuoP/JV0wnB/T5wgEs8CVBaJWXAaAdmWIaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS/5l3HnrYpROJXOLrgfL1a38s3OzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22AJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgQDu3H7CFKrhPmmybxQPWBs2F\nD3lDicx/EBW5jR9Y94QCIQCNpC4aP8R8ZrzjWD/KBW6OkmNqp/oTA0j9EDE6stlc\niQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9140", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9140` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWsq3pO8irL/AIoPFC3NhgTeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4OGM1ODUyLWJmMmQtNDZmMC04NGE1LWQ2NDI2N2YxOTc0ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M0Y2UxNjUtNDkw\nMi00ODNhLWI1ZjMtOTk0NzEwOTkxMzlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJZ3nQsKN98BE/3B1tOvmIBsbAhA0+fJ4nnDbztpuz2qvhTguhbPoWnKlq067\n0Tasv5f/vxsTLnKogbVvMVJnmKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSLtjTxNGOi+F0MFwsaEmb9S5D1MDAfBgNVHSME\nGDAWgBQ9LyJ8pzYShldhlYRNtsU4EmVAuTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICNpSDbG9rL5W7H5qYshE90/6YZu/zBD\nxuJEb+Sh+uljAiEA0/VBzfRfu8Z9EfGlQamcIZDB0KFqPelrx/8UnJmosLo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ5rDphH7LOv4zWH7XdttCNFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODhjNTg1Mi1iZjJkLTQ2ZjAtODRhNS1kNjQyNjdmMTk3NGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATO9B9px6y1iSqb9AUrhJDPfA5kqBSxsymsxrHKnEYHaFdj\nrokmkbHlH3FxYBbyP9RdI5hQnZgT0yB/iFC+Fc01o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPS8ifKc2EoZXYZWETbbFOBJl\nQLkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANOQ81+AdEuTARTfzKT2FfKWvFJ6ISNvy2eO6cVJs+TXAiAB2hqBBGYt\nBV7WRPOSGqf8FAtYHPmgjBRZVhtYWrPEKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAWy07RsXtUOnnIOYSycsA+AJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M0Y2UxNjUtNDkwMi00ODNhLWI1ZjMtOTk0NzEwOTkxMzlhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWY3MGJhNjgtOTZmYi00YjkxLTk4ZWUtODU1OTZiYWRi\nMjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8GkRS2YWqsU0B+pY294/eT+/\ngQVblU1Y4nMW0i2hzOJ7ovhkIHjiA0TOO8xFYzlQ+kUqFg0blxXeF8nV9VZy+KOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSLtjTxNGOi+F0MFwsaEmb9S5D1MDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22AJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMOs20lSNjst6NlzWoDfTVfP\nrcApATLFHe5WTEz2ZhUaAiEA8il/KcEo6wu9Edu4DtmjCtLhXtNaPriqTXv0UFXO\nguI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9141", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9141` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeZP96VZ/b3r7TqwIAEW+mebMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlN2MzMzg0LWZlOWQtNDEyMi1iZmM3LTVhMmIzZTA3YzAwYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTcxZThmMGEtZTlj\nMS00MjA1LWJhYTEtMzg0NTdkY2RjZmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9ZiKEq8zmmgbxFlNv/T/k4m5rXQMXVdR/a9gAhdOxgH8/KawPoqxHKPK2wR3\n9822Uf2h8dwe2S02K+ekouNOgqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq3ZXqBwDnrnS3HjMM9rxZJy39qYwHwYDVR0j\nBBgwFoAUGq6bcoIdqw1Am5Ixb9Cz3aDCHlQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDBtCqZb2GlmdS4GEgcvaudNAoE\nqvdh7krefGaBG69uvgIgPqbX9h1jthcSar+/cxrfXV4gv8ucI5WPA6Tw5fnrsYw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAduHjqVWP3LQ3DojqYHJ3pAsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTdjMzM4NC1mZTlkLTQxMjItYmZjNy01YTJiM2UwN2MwMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnguryOib+iVQRwYNh4KY6FkwOCietI2OI+/JAuyIGlA6G\nHe09vR84BtqYLIhgUHR4eKsSgypakGxz24dX8lQao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGq6bcoIdqw1Am5Ixb9Cz3aDC\nHlQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgROj5639r8BB+uSkTOmytOUwoA3U2/iI7BEyPM820xOgCIQCNQ2iDzV/u\nEexxvl2mJsWyKEqQ5DWevkyQ55jJNtmTYA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAYiRhEDYFGZTjxtfPeCvZ6XCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTcxZThmMGEtZTljMS00MjA1LWJhYTEtMzg0NTdkY2RjZmIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2ZkY2VmMWYtZDI0NS00N2EwLWJlYTUtNjExMDUwMjQw\nOTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwWzmIwNnx/w0lZHrDt5yc6z6\nN+CuSSWBrwmIROTJkdasMEe0Wb8uq0LIK03wK7uXfg9niG7lykgcJ+FnMxQ3z6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSrdleoHAOeudLceMwz2vFknLf2pjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22BJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgFcGEVjJ0cuQa/wtk15t638E8\nX0X+Ur9RzPfPmHbBUgUCIQDIB0i1ODfXvihBNgGPvXtVnndBqC8XkBngyJFeqeYM\nEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9142", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9142` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAS4w6ghxfz1mDBa+jGv1b3JEMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzNTgwM2ExLWY5N2QtNGI3Mi1iNWY2LTQ0OGI2ZjM4ZjE5NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JkMmY5ZTctN2Nk\nYi00NDI3LTljYjctNDQxNTA5Yzk2MzdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgfDDcIQgtKSrO37Wg6nPWf/epF+MRrm2Ky0MXu1Fl6S4KpRmtxLBkDcNq3Fw\nRrrunbUyrAqdbNtqaXvCqBGhRKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQG2yIOq/NKfkU4/Q22k0SkOfyBYDAfBgNVHSME\nGDAWgBQBUikuivqjT78YPp5BR9SKQKUFPzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDK6ufCMnrHVnV62w2RdmbadwFRBimy\nKglo82D7IrDmpQIgFvqOQIbKNRAyntNJ8JvJ9ESQbTSwioItFj71GWQbVxg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYo13FHroPkqaBBQISGKDAulMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzU4MDNhMS1mOTdkLTRiNzItYjVmNi00NDhiNmYzOGYxOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASp83H7aHVYZ6OJwFzXa0rCuP6KJZGR2lEW16lM+EPW+aSD\nejqzXHR7LI9TaYrrJX7EkZ6IJU5HVz05lV9aSLvho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAVIpLor6o0+/GD6eQUfUikCl\nBT8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgKPBhoEDvf+rsud+XyDP51zP3Q1ux8ivgB9t/FYUkGXECIEeQNtys4+ph\n3GHogg+xN4zGeWY9TbdmAkK6MP4I2VTx\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAQDoD8LS5ECnT6VytL21GPvEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JkMmY5ZTctN2NkYi00NDI3LTljYjctNDQxNTA5Yzk2MzdhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGY3MzcxZTQtNjEyOC00NzEyLTk4MzMtNGFmZThhNjdm\nNTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2F9273C9nwUSFwt7PPdhBkta\nVzvl1HQq9K6znqZquxZF36+flywgzERQTpLsIXKW4p7dpxETWxQPMUXumc2PIqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQG2yIOq/NKfkU4/Q22k0SkOfyBYDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22BJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgUTK6T1g4oLF2wSRIT7rq7iCt\n6SHDodQs07Tmkj6A/RQCIQC8SAC2dUZrN5LEJVXMETZXqwlDFswEP7yGv5NRV/lf\n0A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9143", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9143` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAY/Ha1UEkoWvvj/O5xCmMrGUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFlMmMzMzE2LTYxOWUtNDhjNC1hOGNiLTZlYTI2YzlhYmQ3ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjk5MTc4YzctODVk\nYS00MDMzLWI0YzktMjg5NWYzMzM4OTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtWreav1UG6Fq/A8rKRUMVEsdyhRHlTD8nXk0alNFv47J8B/WvdksfEw1ZnmN\nz4Rz+TCsq38rP3DP16i4K9JphqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+mSmdhHgZ/kVYWXkRHacWaOO2SIwHwYDVR0j\nBBgwFoAU2bqALd7JzE3GgmmsdRwXsniKpEUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDwWPBZkkgkl4gQDTDYv7clsXZA\njo0UsQSJE4rc5cSn5QIgcYI6AQvQ52CS4hcf33hbZtxTrFGe6F9fjKtz5IkHR20=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAT+oBX2aiM0RjBHp4jz02/iHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZTJjMzMxNi02MTllLTQ4YzQtYThjYi02ZWEyNmM5YWJkN2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS1R1/TktqBlFyl3VRZPKAnJf5zrWVZccd8qqZr2wBTB1cF\nVjriE8FeY/eV+O6CovFFCpWTYpWxmzPcDPC76S33o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2bqALd7JzE3GgmmsdRwXsniK\npEUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJw3qYsEQaAyb7zASLttCSRGiT29NuQWgivGYfRZ5SWUCIQCBTFa0LmUG\n3k3X8WZuieT0i7leJ+2BQblgg9cHCqPlJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAeVFrjtDq5ozIik7AHIzm5ttMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjk5MTc4YzctODVkYS00MDMzLWI0YzktMjg5NWYzMzM4OTQ3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDI2NzJjYTgtODhlMi00NTc1LWIwNWQtYTdlYTdmZTZm\nOWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkWXTLfwWKcHJ0MT/+cxO9RT9\n6aS4cj6+YB4wbo8nuQQBMjzeH5OwsnF1Y4semnnWF8JfRMeE7YaKfA3LmDhW3aOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT6ZKZ2EeBn+RVhZeREdpxZo47ZIjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22CJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANKds6J+vqvq/+ft+K1oowZ0\nmRxdRjz3zfHmaJFolGmzAiBDbfFsGpMLRsg7WbnYJo+fd1bFhs5SKmoML/oo0w6A\nkw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9144", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9144` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAeZ2KXEp8OeKXCJNNMzyQD1yMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkNzZlNDAxLWQ2NmMtNDhlZC1iYzc1LTQ5NTJiZjk4OTlkMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODkwNzMwM2QtMmU3\nYy00ZjFkLTk2ZWYtZjkzMDhmM2Q0OTQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdhBw6IXmShLsw1zB7AJLnXl9BCYmqZAHqmENE6mRIN/+RBKCWiQUMJXPhjxM\n5M2DFuIvQQrBBKZeYY+7a1xcoqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRNJ9oGFJWhwdczuoXrbunHk8aZezAfBgNVHSME\nGDAWgBTR62krQt8i601OPhhFtNm88V2d2zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCtdACBmOoBfhQzQ5R8RSyhXXl+ZodM\ngqfaXHuMf5m7tAIgMUX4LS+8ffsSpdUnfqvAEK5xEAu3m/1+KLqWB6uwvUw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe2Pe1oj3xkqLZD1BQqjfcifMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDc2ZTQwMS1kNjZjLTQ4ZWQtYmM3NS00OTUyYmY5ODk5ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBzobwwO5ihERonRva4yFtPtzTXvtNN8ly3hdR1gHLzQ44\n2Ou5TDYuEFZ7AmYLn+sKIs9p+9npanmYbH5zVtqgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0etpK0LfIutNTj4YRbTZvPFd\nndswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALs+6fAXCLbCfFIN/vuPEMXOX1j2QWI6Yea/Wtqn3ReBAiADHc3vhwS7\nCK9EYIKurGJ1APyvLhD6W9d5aDStBxHUng==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAbkc2XEktbL3k0hIsWCC/1JvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODkwNzMwM2QtMmU3Yy00ZjFkLTk2ZWYtZjkzMDhmM2Q0OTQxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDRiODVlNTItOWFmMS00MDllLWI1ZjYtOWRmOGU2Njll\nNDFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnOSzTN07loywLLqplb0RfH8H\n3LzcA1ljGIT5EkSibRHCOTiteBGKNsozAhjhCOsWaMdfMsKdbCfgNxQ8lWUze6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRNJ9oGFJWhwdczuoXrbunHk8aZezBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22CJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKAcVWIZS9n48FyL/4+Yy23s\n3jzy++P69mdM/9sgDVtBAiEA81BmeibgvOmdf5xBQcyLO/t5Sug+f+/v9JYuMgAQ\ndG4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9145", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9145` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAUNNCt/3QgMoXhol8/0KUmxmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZTAxYjJiLTM5NTktNDAzYy04NzNiLTFlM2ExZTEyYTY1YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDJhOTI2NjktMmFl\nOS00YzY0LTg3OGQtNTAyYjY1NjFkNWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErEcbL5O59F52VtXIuSMOxkV/GPjlR5o+n7145m7JOgzK4UMw6W1wodS5OEyY\nMrMh9//srmEH9BM6hG+1boxP76OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCUaXaYYTNBOV0T0KcmrkIoDkZAQwHwYDVR0j\nBBgwFoAUE/pd7eXCfDfx0eiYwUTPis14UdkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCT7SPl/kLAQboFitbXsq9+P9lH\nkUnPCSbplOJiLIbBhgIhALrYWf4sUAMny6AC+lLoRR+EHjPVuiAIUYoMxdB4lj+o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYBwr9cS6bIqmXuS1ugWeDUlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmUwMWIyYi0zOTU5LTQwM2MtODczYi0xZTNhMWUxMmE2NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARP2xH+o5lfJyNiM5dxDm/Uh6EUNSpzn2AF5XuD6zqN5kcH\nEJ7BeA/V2HUmRo2UgaEjKNTXrYrWMGt7JyHk49ypo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUE/pd7eXCfDfx0eiYwUTPis14\nUdkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLE0Q6FpGDv4uQefwWS5+MEA/jw30FfdQtwamW4fh/20CIBUgJkxLiV8c\nOs1JctLX3rzaRwD+apUUWzKKCzJyCosd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAU02+WwTDk8b82fuDQtCQFMmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDJhOTI2NjktMmFlOS00YzY0LTg3OGQtNTAyYjY1NjFkNWE2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2U5MGM2OGYtMjk0NS00Y2EzLWI0ZjgtY2M0NmNhMWQx\nNmJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4EX/fYnPJqTOYqjQL9sRrBue\nw39Kt38Aq0RDrd/j4b0KuRYWZICa0RV1BOXZXoN+vw0vtXTpsIGttkX5fzxFqKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQJRpdphhM0E5XRPQpyauQigORkBDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22DJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgTXvJ0V2pakV+ClYsBd4WXxK5\n2CvA7tTuasNHaReywYECIA3QfpX48KxrpmrVx1QUELtG42R8l+tM7Gv5RSVkbdni\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9146", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9146` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAWvBm0uGQZi+yzCctRLluQyRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiMjY4MTBmLWU0MTEtNDdkMy1iYjhjLTVjZDIyNjRlOWEzNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzgwNWMzZTMtMWRj\nOC00NjM5LTg4MDQtNDIyMTg0N2JlMTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5eX9QYaVi1ebbWsGze1eIfzoGvBlbW/QpEaRwNyMnHNFZzwxd/g9QuSvBc12\n0+u8Y9p95Ao/YncCYZP2A8WwGKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR7SuDwoLBSYaqgySX2DgpOkknsVjAfBgNVHSME\nGDAWgBTlH8GpIsv9BLa/8/hnuWjO4RNv1TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGn3H0s+XA7m7h/05CdLpwnU8SYSQ4mX\nqZp33b39hPubAiAW2bzSOwT7T8Ik6P0mGFhjScLCswpXAKJhvNkhcySwKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATV4v6cNIrd24crqrB02pEDWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjI2ODEwZi1lNDExLTQ3ZDMtYmI4Yy01Y2QyMjY0ZTlhMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASQ1zJZ4mbDyR9KuDFeHHwRmXUBLG7O4VCsKbVkzjH07dQk\nYzbl/ddNfv7WthJvUpsKHM7BjzdaDjr808zmzy0Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5R/BqSLL/QS2v/P4Z7lozuET\nb9UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANX3aIrlqeY5OR3/dnpJQapF3iAy3iMUaStHJxvxRarmAiEA2snN8mVm\n9TJjk4YvE66g3yI0KEgN9h8EVo9V4FOWJ7k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAcGf6aVl8hVgPaJfATyulrBNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzgwNWMzZTMtMWRjOC00NjM5LTg4MDQtNDIyMTg0N2JlMTBlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzg4NDdhZmEtOTkxMi00ZDlkLTkyYTgtNDRkNzMwZGQw\nYWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9aXOA4Jp7ZS5M7ie46nCGPMT\nx4/VKx49IP7CdWMBrpYu2BO3zN+28p3d7uUcEBtXolVIuT9JD14TH5XSbS38kqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR7SuDwoLBSYaqgySX2DgpOkknsVjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22DJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIo5+AqVj12vG4F106g8feuy\nBUk+78ADi1jiBr6tGb/xAiEA1odaDUQOU22RHquC/t9GmzeVu/asYmDGFfrmOjPY\nm1Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9147", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9147` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISARlKX0cy3yzOMMYhEPGsjN/zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0MzY0MDY4LTZlMDYtNGFkMi1hOWFmLWYwYjI2ZWU2ZDRjMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWU5NTA1ODEtODY4\nNS00OTgzLTlmNTItN2VhZjJiMTY5ZDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFrYIoMUaxwHbr3GqYyTvGhC/qjM1EtkWV6n/x3/+n4meU4RyQ6EI07oJ8wbE\n3MutH1ESpWCQd8XyFbkaTdz/56OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl+BxhuIRQrR/wHJggUMIe1GaC5owHwYDVR0j\nBBgwFoAUiciYs1jtu7M4lE0pAvy0FlwFYAIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCTyS59WcQJFBfqqfY8J3GJGz4C\n823llFYgluEUlBKK8wIgKykD5ENab9+1vHa1J8pEqnTBQKktQVvp0woXP2xatMg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXIz5TE67o5Fp7KET7a5ioeDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDM2NDA2OC02ZTA2LTRhZDItYTlhZi1mMGIyNmVlNmQ0YzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAShU4KsrCO6GdZCzU3Fa6YDrDRvLXgLRpcYI7sHriAD2Gi6\niyJYgOodmZRmIoPhrj6waSH29U/AnTQGeWNxRFFyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiciYs1jtu7M4lE0pAvy0FlwF\nYAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHI5C7GMNpB3xMuDRidO+Zygo9bX0o5NZ5Y5aAyrWEF4CIQCM/Ag+apiy\nIof6Fx8/MaMFYPFJY6dNC7d/WGnoJiwd9w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAd92xpRSJK/r+0vo87/dDn7EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWU5NTA1ODEtODY4NS00OTgzLTlmNTItN2VhZjJiMTY5ZDg2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzVlMDA0ZGUtNmQxMS00YTEwLTg3NDYtODBjN2Q1OTM5\nZmEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEomurKrCcDLYLApglC4gSCSKn\nSAh4DXMzMp+T482WyhQXURjM22gO8RY/szR8+gVzkfqMKgOxqZSUNLGHnzl4hqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSX4HGG4hFCtH/AcmCBQwh7UZoLmjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22EJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgUywiq0SC7T+w3WHuwwKWQEdz\nOOr5gzPxrC2vwiWP/04CIBsr1ee/ViirSBxYFg7B2Sj0s2K2qA/HEtJCGMBlRUWd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9148", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9148` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVjj6uDgYsD9CmbgrjRr4DomMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxYmJmOTkzLTI3MTUtNDdlNS05ZjUyLTlhZjkxZWM5NzU2MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDM5YWQ4NTItNWUw\nMS00NzgxLWI3NTgtMTIwNzA1NTk1YTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEW4GEpKxmIwUkRpMHedHOVyTZyxnMO/3O5h/v4z2bFlEPYJ7BSX1Sd3y4jF1Y\nsAQ34HITfNgEIhwcPrnbXbb+kaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBResHenO8cPxnJUOB5orZqMCCemhDAfBgNVHSME\nGDAWgBS9kdBbr4Yz/5Kc3uaUxSdUsLU5SjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEOCv7lve2GyC1Pm3jLo8LIcHYPS4+8Y\np1CFKaKYs8GBAiEApjFG7XIc0hhMbO8D0DrVVa4kOr8G3V+nAF603d+hcjQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdoSFOlo0jui96ZExfd1mCmtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWJiZjk5My0yNzE1LTQ3ZTUtOWY1Mi05YWY5MWVjOTc1NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARU95dv2cHvL/KA1dEiMfVcU0JcIJ3AHn6JlgN9fFOAVHkt\njxTa9N+gpjeLASjyaKoNf81xnlFjdTHDL5zZ3jxKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvZHQW6+GM/+SnN7mlMUnVLC1\nOUowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEkFKS7ewKFZbDB+sfcuRbSwF3Ak9qKnw6SFRAlVWytYCIQCInL3a+NEJ\nfLhBABhWB8XXf456nE5yNwfGGe36IelO7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAfwtDDLounJNPN2iD1wJHtwsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDM5YWQ4NTItNWUwMS00NzgxLWI3NTgtMTIwNzA1NTk1YTkzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDE3OThiMWItNmFmNS00Y2MzLWIzODMtOTAwNTk4YWM5\nN2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUdeQFPuR6Nl19EifMXT31hzc\nZ54+c6T/BEd2ghEHM7/1nUkdPrgzARABobnBtIA+98TeI6qAdlGnkKyGWWzzpKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBResHenO8cPxnJUOB5orZqMCCemhDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22EJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJolytQbiifh28KiVYCVX3XO\nEzZ+DPIJWmtQ3O74FZWUAiAbFzefKn7JZuEV6PKqT7XJGG3sEG9+QZzxH7Mj9KQI\ndg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9149", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9149` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAVQh2VgE+up349GshgKdaceKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMTY5MThjLTM1MDktNDRhZi1iMzg3LTFhYjgwNTU3MWRlNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q1MzFjMTctM2Zj\nZC00OGRhLTg0NDktMDI4NDhjNDI2YjJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEUhXRnOFeNxCbghf+C56gSi4UgOzAbTYxGzeoYa5q6NwkLYG905hlxnpZwOC\n021qDfnZ3YnJl0ItNfJY+war2aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtjGei1HcSng9X2szYQg4GTxPfPQwHwYDVR0j\nBBgwFoAUXJO7CCLjr6z/EUaYQePSzkmxQXcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDyh5OqfJRj7jW2DNgrvlQm24G5\nybyRFdXCKeGuV/r2ogIhAJ1ZLRvF5E6bQchT0jn3/ruxF4jYEkVikEMP2LglxQQG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASPUMPPQ5lsQ5JSangpVDrDBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzE2OTE4Yy0zNTA5LTQ0YWYtYjM4Ny0xYWI4MDU1NzFkZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQO+QbqCx87EnDB8C7TRrroG2enO+3/2q1YONhyF1OWZpwc\n0jxuoeYeaZl+uXRj+zZldpsWd1h48Ml3bXY7oNNIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXJO7CCLjr6z/EUaYQePSzkmx\nQXcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDoCbn1i4EK3WA4UY+Ku7me30bnOqtYTgsCDiUsZvg2gCIQC613vg2c57\nkW5H5gkCS7ulIjD0cawE5XyvAREG44UDFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAU3/iSCsl9DMbBJGPtdJSpetMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q1MzFjMTctM2ZjZC00OGRhLTg0NDktMDI4NDhjNDI2YjJmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2VhMTc4MDEtNTU0Yy00ZDMwLWJiM2UtNDE2Y2RjZDM3\nYjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEh0oiQzxKB8aJTrZcieRLFLjU\n7stjYnsahyHp1ArkxeYtiD5j73to684/+mDTLEv76OD/hyCKRdyvjK5xAzbW36OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS2MZ6LUdxKeD1fazNhCDgZPE989DBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22FJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOKmZ60eMZisER9b5zTkPpba\n/uM0iP216cxCBCmRiA3eAiA5u1cik63bSOmwdYKLWK7XiSK6FFzW63YysSxIbKwy\nBg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9150", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9150` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATO1HFHxgcFJB11rAvshdeEbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM0MTIyZGQzLTNjZWItNGVmOS1iNzI3LWU2NzBjN2Y4ZTdlMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmNmYjllNzItMGNl\nNS00NTQ0LWFjOTEtMjlmNDk0ZGMzMWMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUCGh1BySrzFiZx3dzMIUy9fi7AlN/CVdCYdsMcC/26XF3GTsRxMkSI8kQYs2\nVKiv3zIiY62kFdVgSGKcm6gWMqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR41/RpvmmGS8x0jqEQ4W9HearH/TAfBgNVHSME\nGDAWgBSbHHz2oFtTh2s9eTIpWcrb/cGYyjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC8cHd5IoliqKmKhpwhKqZAQJxCcQdP\nEUy1mlW4da6vnAIgJHN79qz7U/vRHB4eb6I7dizWW/a9Hehhscd+siKx5W0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASB8T28rr6piY0s/z7mIrXdPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNDEyMmRkMy0zY2ViLTRlZjktYjcyNy1lNjcwYzdmOGU3ZTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYvcrjPMNJCYX/312z4XgLdlPV55Bqo456dwnndtOK2MPE\nIH6fKH+kOm6e3yWgGZBnxHbCun/MLHwGcNDm97Pgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmxx89qBbU4drPXkyKVnK2/3B\nmMowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIIsyGDysi0XeXvMwzpi3kow4ox9ETwvFnptStGkVIZPAiAGrPp92R4f\nHb+IjNYyyt7xLBHcl2UQneH/4lvsG5CG1Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAUiynASYixuGwBSbxjtJMJuuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmNmYjllNzItMGNlNS00NTQ0LWFjOTEtMjlmNDk0ZGMzMWMwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTBiN2U2Y2QtMWE4Ni00Zjk2LWFlNWUtNzMxOTc2ZDNi\nOGZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYT+N0goRCDi62SiM2mUj3cJP\nxDD+3rOvbAtGp75eEISsxkjqoeSjEKXpIWeXGE4SA7EcA1+54aoYerYRPDP6XqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR41/RpvmmGS8x0jqEQ4W9HearH/TBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22FJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOzlfSppk1Saqdt4nORyawMl\nByIyYJasdiWHT6zfgl/NAiEAkIj+4YC0qBCLs1W5eyHCSheUoh5ZbQrAdWC54SSD\nLio=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9151", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9151` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAS/tfZZe5uZ5Dx7OyD2P3wmbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyYWY2ZTkxLTQ0MGUtNDAwMy1hMTQzLTJlZThiNTAyNDEwZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWE0ZWE0NWQtMGMy\nNy00MDMyLThmNjktMjkyMDU0ZDg1ZGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuu65uzfzTTK0JdH0s+2uePmDdOid6J3Fv+8OHvnNOiYO1zP0QP5AEXVoQ/b2\nu82MP5UbM+zqzBmvFQhKFTPQNqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSwce7wAwG3ddZEdqZWtOA6GYl8IwHwYDVR0j\nBBgwFoAUmYPy7BvC5x8+0arnXPbzmR4tDI4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDnqi/pSot5DyHSmYc6d7DfMM9n\ne6aw1iYupa8g0Bes3gIhAIU6JTvrNtexxWyo/HNsGX8yPz3VOMpY8di69GH2MFUg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZUGOE9IQD3f4Unue8sdPqqjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMmFmNmU5MS00NDBlLTQwMDMtYTE0My0yZWU4YjUwMjQxMGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4XDGG5iSRhRVd+JXTFVdRPo74WCAD86UxIyTgxDyiE22e\n08eCkUI7Jwu3W1o5cN3SS9A/bPUKxSDvaPCiv9YVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmYPy7BvC5x8+0arnXPbzmR4t\nDI4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTbDoSrH746wfRy65yTm+/kG4soRFWgPe+q8m8mydMA0CIQCd9xFvxAYj\n4ycWkin5mmUBdH09EUSg8c0Q07Hdtc+hCw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAWZDg4qZj6wdZATgguK9gLf4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWE0ZWE0NWQtMGMyNy00MDMyLThmNjktMjkyMDU0ZDg1ZGMwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmUzZjhiNGUtMzliNi00OWU4LTk3N2MtMGRjOGM2Yzlj\nNDFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGClOFimfFlR+OG3ItIUv2qBi\nAgzMh8V/a167R+SGzt1jN6J3bc0R72wW5XUqazqa07U4SN6GrkxxPABklNz8SaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRLBx7vADAbd11kR2pla04DoZiXwjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22GJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMji2Kug4l3dHZgZ9KLJphrd\nRvUT6srG1PHBkYbWAgPkAiEAwcbFOFA2Q80Y41Q3N9tWFcHjqTWgjA5FQ86SbhU1\nIbw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9152", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9152` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAfwNpSaNnkucS2FLdjlnfpHiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1ODkzOGIyLThkNmQtNDA4Ni05OTcwLTlmMjM5NWY4YmE4MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjNmZTk1OGYtNmJl\nNi00YzM0LTg5YWItZDYxMmFjMjkxYWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh4nBEVX/alYgdpJ8RPcoMXO1oGpbXwsJmg5hJwTgDAfK9sybH8Q5GSUKtpFn\nFYKDOpBJCsnbgzOYwBvYdHgFSKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQJXWIZJH03dcQENS9TppSX1dHbNzAfBgNVHSME\nGDAWgBTwZtXugNjU3nao6XOlGWa83zMtyjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC1UB98GFQAogloVtBgYKt8QOoE55Hb\nh4yse3k+MgVZhQIgRRyoNl32VpDX+IcMlSt2irDssjG5ywCnl2B8TRFwT68=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAViOFWtYVJdERfZ+XI3aTJNiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNTg5MzhiMi04ZDZkLTQwODYtOTk3MC05ZjIzOTVmOGJhODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuz5dHElWhO9J8OiDPl5DDek2wQgX8AJ4KMLZTbFUDQzBX\n8X6wzI8D7Y3iO/QuwARA5qrUsWTltlaxy9cOPkO1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8GbV7oDY1N52qOlzpRlmvN8z\nLcowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFFYtEzLjzZ8AGld8krpTPMRKoEtfT3S/bUke/6qxM2QCIFWt99KHCWB0\n8MKr7zllsLIE4PKZ6nDYK87j28oPq0RY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISATyAoFDDMpFlpB6Nyh0jQlQqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjNmZTk1OGYtNmJlNi00YzM0LTg5YWItZDYxMmFjMjkxYWZmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmVmOWMzNmMtNmY1Mi00M2ZhLTgyNTAtYzJkYmY1Y2Fm\nOTg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaWYE2lIft68t+2hiGukRf4Ag\nbN2U2Cd11c0xRrBt6Xp0BrqxZuqhElB/GDmDiN8GwywqyA5w5JFLXoJ8ABIu56OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQJXWIZJH03dcQENS9TppSX1dHbNzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22GJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgORHLdbm+rFgkdavVrB5b7LXo\nvoRyTsSCMIYx0OhmGvACICB3Yp+S7mOUwzclpY1CE8dgLmVoJvQW0jxX4vHhZx3A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9153", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9153` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAVcWHK7X/CtEfGQHTOL3mW8aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwZmE1MDM2LWRkZjMtNDRiNC05MTY5LTI4ZjE4ZWE4ZGRjMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDZjZDk1ZTMtOTcx\nZi00MDZkLWE2ZmQtYWNjNzFmOThjM2QwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7s7N/kTwMgih9lrxFodlDdo3g3aIMco7uJqjXPyKeG1EkPdJzTbIYCmJ8Ue9\nNXxCoC+BuDTzgDlphzw104nkAqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoavc0faKFS1IfyuryqHk9wpRV6wwHwYDVR0j\nBBgwFoAUjP4t/hU7vqPRC4ZA6tyEegnI3K0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEJLn76dFM38UdvHf2dkkx9GvPWt\n25c1uVAfTmF31AweAiAIoXd9MXzqf98KfMhrLCd32gaFTtkhz+sPsb0OT7H9ag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAd+3a8kyo6SddWReZMLkzIg9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMGZhNTAzNi1kZGYzLTQ0YjQtOTE2OS0yOGYxOGVhOGRkYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARXc9tKJ0a7iOY9Z60todv91p5+CICXTyc5XsL9uQh+CCDp\n68+9dMPrD4mHliuAD1vNuxu19XnxkRrdc/Byni8Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjP4t/hU7vqPRC4ZA6tyEegnI\n3K0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALHv+PB/Utd7HVLRoQHZ1q8FYxO9WCpYrs/mYVIu3s9WAiAK4+jrC33v\nSBjr4tkcvAqNJAVr2YXNgyI+D0gPcYhbSA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISASy2uKEI5Dc3c7EB6gbP+kO8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDZjZDk1ZTMtOTcxZi00MDZkLWE2ZmQtYWNjNzFmOThjM2QwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmYyM2VkZTgtZDI1My00ZmM0LWJlYTMtYTU0MWE4NGMw\nOTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPaBztN5DwuGmLFtlln98cf6K\nLaLIe3myotBHg3h8vRdVwBNFo2dag6gE0sb/PiVjjUUuzuD8csWG8tWeBlYg/aOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBShq9zR9ooVLUh/K6vKoeT3ClFXrDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22HJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgKNoJva6Abo4ReSdHx0eNnN1W\nugl4x84gcegNtwe5dP4CIHDlmlbamePbYe9rbu8CrW5BzGe7sWczuLb4qIJS+NRc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9154", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9154` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUFuxOukesDQx38s3v1Etzr7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4NzQ1MDMzLTMzMGItNDNkZC1iZTVhLTBjOTM1M2ZjYWI4MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTBkM2UzOGUtNDdl\nMi00ZjNkLTg0ZGEtNmQzMzNiNjFmMmJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESi4QGYtE147g1VBHnz80TI6ROyg5ZP3Lfu65qeXnLM5eTmjbAuWIsLqyJ51D\nbDSvrE4vcO8/U633w88pCkdODKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTvskIT8VoT9wM78qYITNK6mnrd4TAfBgNVHSME\nGDAWgBQvFPJJQgwkeN1AQjosuyzmYzoRXjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC29/TzljxBFSs0gwo/vGLI+zg3doYx\nrEZlNOOYt3jfaQIgXSrVDi7AHTncwiEzEEDXaBJEd54i4JAAN7zigOWDhEI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX3SJC/Aj3zTvZvHa41kqOEoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODc0NTAzMy0zMzBiLTQzZGQtYmU1YS0wYzkzNTNmY2FiODAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASomiWcpdC0oZ5P/0Ydu8rR/t9+hZ9hK4XXeGPY4I+DeQJm\nzMjN3QJ7YbWm/Xmcy0Ui87tLuXpTERsvCFp/yCJCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULxTySUIMJHjdQEI6LLss5mM6\nEV4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOXDZth3YqxrvGwJP2QdNnkbaM4HzuPgACMV1N9m7sl6AiEAkguA/wuQ\nYEGTnMTHnXU6nnk7y7c08VvkOA4LbnMK3RE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAdIfUREpP0//aUSf45yeYQpQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTBkM2UzOGUtNDdlMi00ZjNkLTg0ZGEtNmQzMzNiNjFmMmJhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDkzNmI4ODgtM2JjMS00MWZiLWEwNjctNzJkMzAxNjc4\nZDFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwSKeY7zP5yrtMxdpN1OpAq3d\nH9/fVARxU/MNI6doOjvN1nVxjB/zAHdBQwEyX1dCSB4UOFrGS4mIlL8swzd+TaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTvskIT8VoT9wM78qYITNK6mnrd4TBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22HJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgYaCA9GfmL4JGn4oa6vGpnIc2\n6IAQBj87OQUCYguJu5UCIBGa4zLEPyVsN4rIQ9nyjZvJYOxw0UnZoVw9f1VpueHv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9155", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9155` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISARrlhRGlwhG/L3Emm+Ywj6dxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1ODRjZmI3LWY4MzItNDhhNi1hMTdkLWQ2OGZmNWJkMDA0ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjE4NTRmZGYtMjBl\nNS00NzljLTgyMmMtZjc5MzU3NTQxNzcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVRMMLp5vAfXTllQ1biar2N169cNHb8t4gpgZ0BEWUbWam5AYuKRnw5rv6GZ0\nKP/U8fTIFBq7dwBmMIpL8j08tKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1b/L0xlrrSe+Q41QGZj9BsxmXMAwHwYDVR0j\nBBgwFoAUtJpquyFgXuVScVaXLmnkD2e1QA4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAtONwpjzWoV1LrcqIvVLr4L5bhY\nVKT/x6l2+u8s4q/mAiA9uu78iJTii4TamJt0MenRKMNv1MCyPm5zcKfCopItvg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZQf+db+Zwm5hBelFr80uwAAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTg0Y2ZiNy1mODMyLTQ4YTYtYTE3ZC1kNjhmZjViZDAwNGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJ2mGEK4NRBZZKBDIj5/cZ3C21LvGGY34T5Zo5kxVuq3UC\nwtcaAZ34eZvk+hj226xWvbt43IHiJP63sft5GFv8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtJpquyFgXuVScVaXLmnkD2e1\nQA4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIDfObP77p1Ko4CB0rhUqaSPppdBMhdfJ4CHsQobBZunAiEAkerXhVxb\n1uAWWnWbahnIPCQ4mw7C/LarYvwheBxPlv4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAWz658RobCwE4BK1VfiRg6kgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjE4NTRmZGYtMjBlNS00NzljLTgyMmMtZjc5MzU3NTQxNzcxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODg0M2JiMjQtM2IxOS00YzFjLWFjMmMtMmI0ZTEzY2Ux\nZDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn5Y65VR2Z8gW7Z30hg3nrG3F\njpX9FsZG/Mv7tdmssxEmMY6LTId4hn7oL1Wpxhy4xf3ombeyYXhmK1srR/fxNaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTVv8vTGWutJ75DjVAZmP0GzGZcwDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22IJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOuziAJI+dx7I3mFO9auE1KR\nNeeHEtdc6jq4Mmbv5MthAiB8yTghmjrA1LjCDv/t40upH3lHhfCB7xKX5vu42AQ7\nfg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9156", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9156` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAe2pflRzqjevyyRQaMszjgaQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZDU5Y2ZiLWUzZGUtNGI0NS04ZDJkLTZiOTM1OWRiMmFkZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M3OTczNWMtMzFk\nMy00YTJjLTkxNDYtMTdmMjllNjY0ZThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFshCsixHzg7+J97bzYDw9/Y+QmsFNeciJLGUlJRL63QwzvvyWiXmQWOmQqxz\n8uMatzkr1Z+KU76JRSiKbszBJaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTKN+nOyj5kOT+BtEoVZLBa0prGrjAfBgNVHSME\nGDAWgBR0ZhaCai+FfSbolUrWv2FqhejxdDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCpt+pM+zZWC6M4IWOTozmqKGYS7Jxh\niKOUnRzIYgSq1AIgMRd1joAi+XiSgur69qjO0AfuLV+KOCuw7CgDoZglOpg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWiULYhNQYTBXep9v4VAaTl0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGQ1OWNmYi1lM2RlLTRiNDUtOGQyZC02YjkzNTlkYjJhZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQN9e1mydrp4D5F2JBCTffTjbwSax3nu7LivbRDlBKzzI2R\nXf6nHNQ2BqIhB8bZqFYOg+AhLUohMGa43G6qHeE4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdGYWgmovhX0m6JVK1r9haoXo\n8XQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM6pClESYwzaHsjuHKC8f7vOORzphkjQcGRKMK8Bp/IQAiAGtjIJGbuo\n2cKaiGIDtsihfVXy2AFMyzcZJdJAzTdejA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAdENF2PzVubYfPqcFSWBut2mMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M3OTczNWMtMzFkMy00YTJjLTkxNDYtMTdmMjllNjY0ZThhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmQzOTQzMTQtZTkzYy00Y2YwLTlhMGQtNTFjZjg5OWY1\nNjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhG5NL35nt7/UNzeFVY1Ffu6J\ndSlxNCEAIaBCPSZEmQ0uVp5EWNQXeUaxHqbzJvgzruG2/RS/trxxYZFH2zafg6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTKN+nOyj5kOT+BtEoVZLBa0prGrjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22IJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPQ7QTSiylcnJ6Rbq0gKitiM\nijug9gO8k3lDz7SUtd0rAiATOXD0ukUid70kE3YeQkswKvNYPl6+JwnhJsQDpMPX\ngQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9157", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9157` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISARd/vx3ZPthBldaCXxVLMtVUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFjOWFhMTQ4LWNiOTctNDg0Ni05OWVkLWY2ZWUzZDAyNjIzMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWJhZDk2YzItNGUz\nYS00ODMxLWJmMTktN2RhZjZjOTg3Yjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaO0qi0tEowUKEyHNZMqv7p6mQ/aHgKnk7wyEhdr7CuTVRTUGzG/uWkNb70Gr\nrAy6JBKIqa+UMcp7wMK65QaQS6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSkus034f/nqjW81QHR2BYsS9FgswHwYDVR0j\nBBgwFoAUlD3vPkoAS+XhKLCEuVaZI9z0WqIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCwq/7Mhmouk9N77/4wrXB5NTlH\nIRfujvYADrErNigSzwIhAOApIBrP4AXT+9zeEyPZZs6xeQ/E4fY6oKsuFs4S/Jj2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV/T6PljSyIyg+K56rJLQH/7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nYzlhYTE0OC1jYjk3LTQ4NDYtOTllZC1mNmVlM2QwMjYyMzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVhynfNYKV/MXSUzKJKFDTarxH0DrRnmHBYK0cdj9FAxeU\nHYjJYjoFJTBcXg5uyh9FwAalx/RvzzBonyKxeRB8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlD3vPkoAS+XhKLCEuVaZI9z0\nWqIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALUowtVPeGjsN6H7N//NAMYK7S4g/PpirWrh0mQRCJeXAiBo384pP4+w\nRmi4jQnJMwHZVXrA9yNzKCKI6sqTcQrh+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAehd/1TOd8Yhgt2kSMCWirhBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWJhZDk2YzItNGUzYS00ODMxLWJmMTktN2RhZjZjOTg3Yjc3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmRiNjBkMWQtOGMwYy00NTY4LWIxNzctN2U0MWNhYzk0\nMmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPgQyPT45weynD0yd4GZhLVJ0\nC9/fpCi7ky8EwMFgHL7e8Br2Evu5OwRIDoe7NNN0APxy7sbAhAYxmGDON40qhqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRKS6zTfh/+eqNbzVAdHYFixL0WCzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22JJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgEfHlqWY4NwOTiQ4aWSGWYweo\nKewBbqUV704fIy6XkMYCIBKzaMCdtvt7XOVO4uQJikiG4ObuyKNf+1q5fdsCAXTA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9158", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9158` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAcTw0qYldy5gidDLcYqmCxBtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiYmU4ZTNjLTNiZGYtNGY5Ny04ZGJmLTg0MjkwMjk0ZTMzNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2VkODQxMzMtM2Jj\nMC00ZDBmLTkyNzYtOTQ1YmJiNjQ2MGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERNasaZh+zIKzXq8RIevG8rTHAmGiWOioksX3dRgmmHf36CxPOWuDW1SmWBs9\nK1fhSOWpQdr2kgZtKIyQURHH0KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTNlZepb1uwJQ5Pl2sXjOWexr3gdDAfBgNVHSME\nGDAWgBSVx0QhMtv+DO/rYdrXyaSA7Pj9RTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD4KHTzSfcdrRxeLhXdftpIjAlHvelt\nUGkKcOKrz86uKgIhANf+jMjQV7eoBIcvLI666zWaP04VGrPcuk7R1pQoR7o8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfq6jq4Pj8p0uOQMA/XRmu1VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmJlOGUzYy0zYmRmLTRmOTctOGRiZi04NDI5MDI5NGUzMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARtecZSSrrgGXf4tI4mvFqIn0gYrtxUuw4FXHWkVCKm0DxA\nqcQmmtZp/9dlR1JWD4ZrTJRUSY09/d5tunmFf1L6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlcdEITLb/gzv62Ha18mkgOz4\n/UUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTRhzW+w0ym4H2si1JQMoQXTFc22uS6trreN/GVhKs3gCIQC1n8LLTCMV\nKeCJ1BfQQgnKL9YnDxTajYeOEL7uzeoO/g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAfYwAn0cd35rUN1LSkc6W8zNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2VkODQxMzMtM2JjMC00ZDBmLTkyNzYtOTQ1YmJiNjQ2MGNhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjNkYTgyNGQtZTJlYi00Njg0LTk0YmYtMWMzMjJhOTVl\nZGE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl4OsroXurq15+NFPL3wu4Yy7\ns3p7XARcxf5N+gchZZiWYUcNbMY2Jqsc/0h7n/MtCsLFhpS8VvtIWhYzqhFWxKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTNlZepb1uwJQ5Pl2sXjOWexr3gdDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22JJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgRr8U50NVuLS664Cf3MnUOhvG\nBlrGrITUUatXo3GW5rECIF73HLR9AEhFJnDCZm4GAnY7t43VPdf0uwbVFRuZ1WSO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9159", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9159` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAW6Luik+vTLxnVztrlI3JTPzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1ZDRjOTE1LWIzYTEtNDRjYi04NzQ4LWUxODllNmI2ZTI3NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTIwNDE1YzYtYzRj\nYi00MzE0LWE3MzItZDU0NTcwZDA0NzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHYw/91w6wI7bLpYsW7hin7pARJffLEVNps9vpYxtUw1Ozn3Mz5R7UOKaiswZ\nwdU/lkWZpTXI0MPgJDvQ16v2KaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs/0Qs59fFTdVvfRngZmrJ5F3X8MwHwYDVR0j\nBBgwFoAUSunGAXJRYKFitmpxCUJ2SREkCeUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICSZSgMzMUC/jGKR0O0MZVSWdNJJ\nPdhNVkpMXVap2RRLAiBeOUQIlQPiwL5d3IbF9BG7V9DfmXac/iRfuJF9DFTRjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARcawRRHgEh3LyXkbtsNbd1KMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWQ0YzkxNS1iM2ExLTQ0Y2ItODc0OC1lMTg5ZTZiNmUyNzQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjBsWdyXOYoJqCbMXeNJTwa8sCRl6AKY6j84Q9wfXOwbiF\n6wxJJkPjRZBWjFntX/aiRVLj1p7pL5slxfmbexS3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSunGAXJRYKFitmpxCUJ2SREk\nCeUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaxbbo8d/ajwvAjdIe+JKeEqgbxAUoltllFlbJvHUfvoCIDqFNAJWf7+x\ntqVMDAuXPVB2jG+xVb904C3cdATOWMez\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISASbMxu0ropZbddFs7IEjfgNkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTIwNDE1YzYtYzRjYi00MzE0LWE3MzItZDU0NTcwZDA0NzAzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjFiZWIwOGEtODI0YS00YTIzLWIzZDEtMDdkMjRiMDkx\nNTg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk/oIfFD5/XCniyT8aXjItrIF\n2zeOz/32bjmwrtm20MiTeo++8dvqfP50BrIokc/QyItVxb15Qa+miGCatuY+CaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSz/RCzn18VN1W99GeBmasnkXdfwzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22KJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOgfJsD2hAI7KigtfdCPEdyh\n9z78a1M5EqiO7Rr0hofTAiBlzlMoQZCEfEIvuPzBoOoo7n5LPx9ytowSCLdC1/Yi\n/g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9160", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9160` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbaQkBwQo6MivIOQLnduytNXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiMzg3YTczLTc3YjQtNGQxOC04OWQxLTY2ODgzMzc3NjEyZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTJjMTM5NjUtMGQx\nZi00ODM2LTkzYzUtMzIzMjBlZDU5YzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyBpgB6G29zvSuMZ7YZAMWzn3xXNhAMpraVjKczBHvCogmZj/NArShHqnaZzT\n6bYx2w8zTmtgjycc34gPccG9F6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR/D2uHRsv9jItg2+6lP6IJNQzYfzAfBgNVHSME\nGDAWgBTbMsFZ9UeAuMdVTqq41iToZRM7dTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDxmG0yCkf/BFSMs5YQYbNPfDrNFO64\nxa7nnGtw1oxMaAIgIcfYJnddfhbL9/BqsC7+7jLZmlAS1qYrZQz0wIhgBeY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZjJb+2lxOuvTa0Q1hIcxLLyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjM4N2E3My03N2I0LTRkMTgtODlkMS02Njg4MzM3NzYxMmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXGybyE2AchhjH5U5/v7ZLV14qx9EycWyt9NTYuAuLiv6a\nDJG7kQUyBM0qQvrjOEOQejFWE0EoXKkbdUlDLJnUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2zLBWfVHgLjHVU6quNYk6GUT\nO3UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJrBX4izpAd1S+79VAEBBzwnvOugUb0GlmF8PtLqEeX+AiAt4h0gtpW2\nq31/y+RjfU2HORU0qpd+jTrMu33j3m70WA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAYDU1JvejB6PqSUz20Dfu6G3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTJjMTM5NjUtMGQxZi00ODM2LTkzYzUtMzIzMjBlZDU5YzJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTkwZDhhM2UtNTZiNS00ODBmLTkxNmYtMjJiMzc4ZjNl\nOGExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE97mA0J6Kz+LOExH8fD3OHEg0\nE5XWJMZa5pxrYHGwjEN7whvaCXHlQFuSfCTMuPC+DRXKqpalHkjSCSevGgwK1aOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR/D2uHRsv9jItg2+6lP6IJNQzYfzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22KJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAK7/aPyoKlU4UsX5/DKXhnu6\nsJgNyfsiYJVNFy76rE+JAiBJ4QQeb9cs6siZN00rFSU/ErtCZ+yw6H2H3+Xnlory\ndA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9161", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9161` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVKEJ3bzBanzOcE21yFe209pMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhMWZkMDQ2LThhYjYtNGRkMy05OTY0LTEwODQ0NTkzNGZiMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmU2YjE0ODAtNzRl\nNi00OWU2LTg1ZDQtNTIxNzc2OWQ5NmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVocVZAXSvStqgH7aXoRuVlqnjajK/hq9Jk8RYCFEC7Qo8oZukAz9epiyn1YV\n8OsFYnLKMMH1DCPDYgfrU1SY4qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwOKy1nOPtD4knlQa0hSfpispzBkwHwYDVR0j\nBBgwFoAUvvuBivp+iRWkD1aIZNapm+o4lUEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIB95HxZcgSqKlFTWFRskoezdcT0l\nxoVs5cFs9TOcnHPVAiEA2wCJnjEq4qCgMDy76sH0nQXk6emvsKYTKBND173SI3I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWKFXlpM2IM5KdMgijsbQennMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYTFmZDA0Ni04YWI2LTRkZDMtOTk2NC0xMDg0NDU5MzRmYjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATiU0i+Rv5WkguXUvpYwErD6xG+hPW6LcvVdUMkgK6zPRaL\nsfXd0sDcBdxEvUBOVl/e2ymSWpK26Uvdac0cIqawo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvvuBivp+iRWkD1aIZNapm+o4\nlUEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP5J4OUVr0ynBz3SIaEk2mJfU0u+x1jzEgwbF+wYKiynAiEA5ivWpSr8\ny/i2S43YkzK44Uxn9MfcRlD99BG8F79Xbdk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAcVZlRx3qcRsdBWMcqEsHKz9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmU2YjE0ODAtNzRlNi00OWU2LTg1ZDQtNTIxNzc2OWQ5NmFjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTU3OTUxMmMtNDU4Mi00Y2I3LTk0MjMtOTg5MmNkM2Ux\nODE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpE+C8C6c4tUxrx8nQJOKCgI3\nIqJUbmr1T93PtgHVX+ks6xvt0b4RNCl4UYY2mWxHRCKH6EmwPcxjF34Mppnpm6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTA4rLWc4+0PiSeVBrSFJ+mKynMGTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22LJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgFHa980u4NQsHVdnMyWcFG6sC\n2rSZiuOBE4rga6qmvFwCIQCBW6wrLDnbylMLs+ITVVRNEfYsoHxXFnDFmSnsu5yN\npg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9162", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9162` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbTZSnYfbTr4GvnUkYr9z/XDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVkMDVlZDRiLTVmYjAtNGFjZS05MTU5LTg4MGZkMWQ2MWU5YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTMxZjZmMTktM2I2\nZi00ZDdjLTg2MjYtNjhhNGVmMjRmZDAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVTfcPyDeXUAwJyt7i4QXvDxigtcPkOF2knbZH/ele5L6KsJNGVjzqzK9pQ7z\nn8ugIa8pkgMxVDivMKt7psDDIaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSQiFB8av+HU2qRk0CzryNULZU3ZDAfBgNVHSME\nGDAWgBTDUeZr3+nH5b2qYcu9JNhsF7cTXjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFAEwYN4BgI3pWvIkKKmWnwy9JeUGyit\nJ97QEFy4tkwIAiEAv2Yfe+3bTpGxWuDp7Ur1PGZmzijFO3FqBw0ME7GhD4k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR2qWm1Y6ud/+U54JFv79kyxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZDA1ZWQ0Yi01ZmIwLTRhY2UtOTE1OS04ODBmZDFkNjFlOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLB8yKNX7PyHaJYgp39j89jrPh8wpyZ5CZHc1ib+utWf40\nu51oNithQOc40nqHnRjCxbCfwvRb7cUM6w15WZupo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw1Hma9/px+W9qmHLvSTYbBe3\nE14wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaVoHR82d9zUETMXqhEFZyYCZ/RgPdpVYy8iK+sjMcFYCIQDq1dld3sZb\nFx6QuPmTDkgoHn2cYg6gyUB2abWklPI9vA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAS1HGMIz+kV6ozD/zhrUFoWRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTMxZjZmMTktM2I2Zi00ZDdjLTg2MjYtNjhhNGVmMjRmZDAwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWRmYTFmZWItNmQ2YS00MTNlLTkxODEtOGRiN2M5YzVm\nOGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvitGLBK+dpy0rRvUHgocfOo0\nxGbGJV5zcC57FxFalKv5PRqp4dbLg+Y2rg9sek/+SwiDSDdHs6oJ6/RKjaE3d6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSQiFB8av+HU2qRk0CzryNULZU3ZDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22LJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANnWMoa0crtlGFW8AGd7C4XT\nE7nrxn4cofleu/cMQSwhAiBu+FuooAZB9lSWcL25YEc2EHjYqZzSX+Q7dZtSZmKi\nJQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9163", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9163` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYUV3LKCl+qXDa0WFDNEWYoDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjN2RlOTExLWI5MTUtNDRiZC1hM2Y3LTkwNzFmNTYwN2E5NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWJlN2FkZWYtOGU0\nMy00YWNhLThiZmEtZWJkMzBiMzRkMmVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE86gv3Fg6KFQHUM/Tj4OdqWHV6U1/Rg5LUb940hH11yK3CduwO1u8FboMW8W3\n79Iq1/1kj5Cf0zewM4jkyLYtEKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUd77iI/eXLb0ZXhQhJETPQ7Nsp0EwHwYDVR0j\nBBgwFoAUhax8NMtfaDxO4bR+wFEw28dMcGMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDlKnYwfftx7w95IVprPqt4uOzd\niayShd1+Je9MSdMDjwIgYpbg/Z1w3DofTBAqNKhVZU+JEvyPCFyQr+meLhEwRwU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZoPwhzSim+nPC6rb9a25lpGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzdkZTkxMS1iOTE1LTQ0YmQtYTNmNy05MDcxZjU2MDdhOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpPXLhPmAA5zdeFn9NzURatDD9N2tLBrkHPl393hAamdXe\nGDH8diWzwNVEJ2Z3DUxiz/JV3BTWlpVY/+qKrNM1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhax8NMtfaDxO4bR+wFEw28dM\ncGMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOQQLeneYlslQI19c/c2weSWWev+P/2WCDzZwVoC3tvBAiA6DGCwlIUT\nIpa6DMkL/HriOxSEUGJUSyxCYi+ZwMwEcA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAVnyCE5JE0VklZqTQEfizhjiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWJlN2FkZWYtOGU0My00YWNhLThiZmEtZWJkMzBiMzRkMmVjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDYxZmY3OTctMmNhOC00Mzc1LTg0YzItOTkyNGFmNDMw\nY2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3k0dySpN3Gb3uRi/a4aqdR8E\neJjpwhaR3RKPUeeoVOzY6Ppf+SCxAUJkIcqFnBgsSinY8rQDB6x3ZhXluVehlaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR3vuIj95ctvRleFCEkRM9Ds2ynQTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22MJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgNPKrs28e0N8pYvGvYRZNGzkb\nQCOfMDV8ls7Zpvqa+HECIClsbTbQC8jUwlQ8Ocyk/qV20HhRBm/Eowu/Fwlb5PVC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9164", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9164` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAbtKy8m7p9V+mIjOkDlqyaAsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2ZGFmNzM0LWViMjktNDI4YS04MWI1LTgzYmY0YmUyMGMxMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2RiOTI3ZTYtN2U3\nNi00ZGE3LWFjNzgtOWI5N2U4OTVkYWVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHi7scXD81KYEXunW+U+yLLdepFrh9DgXZKTMh2NMSEBr2bWTu8mllS0tTVTX\nLsSiFWUbPNkMeCy6US0NiohnvqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRLHhibHC/bT4i5PVPHljiz+8bAbTAfBgNVHSME\nGDAWgBTBr3tV0IGrIAkQgcgcrMEbYcuxMDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHFKOnFFJjxC4j7U4l/fUbWcfus3dpGr\nxZVvvMUW887uAiAEYVu7fL2GR6KLo4C8WoT00BI1eCniGzWkvxPxDiBCHg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAToCqBNXvw4a3KXbS1zOgVeoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmRhZjczNC1lYjI5LTQyOGEtODFiNS04M2JmNGJlMjBjMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwJnsIfo60IhcR0bqGBRvUJYrm0uVQsiYL446z2Y08KaQy\nqKvPDBlnZZaWVz8d7HL6vZgh58Fj1/hQlIwqxiM0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwa97VdCBqyAJEIHIHKzBG2HL\nsTAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgF2JKJmLUKUmNoZ96BaXxDY3Flf5A/CuByYyqaRSn4DACIA4NxiekhDVh\nV/HBz04wHvQKfBzAhgZ3598ikeipUEN1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAa6Wwi6nIs3e9wqXlkcl6h4lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2RiOTI3ZTYtN2U3Ni00ZGE3LWFjNzgtOWI5N2U4OTVkYWVhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQxNmVlZGUtZGNmYi00YThhLWJkNzItOWFlODhkYzNl\nNGJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7uNVrGGFr28wQcj9vHLcq7mB\nzhQygTym7bDnl5oXXVt9x2xufSHxJ9HoKoVaJm86M9Omix0CcHnKx1OBPLRx0KOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRLHhibHC/bT4i5PVPHljiz+8bAbTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22MJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAL2mqfypIaSPrN6JzRKfKUN7\ndAmTJjX1lT78FQ/kggDuAiAZSByyhUqmZrAF8J1xhJBiTeYpPVkAFv3AMjKqWSzB\nxw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9165", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9165` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAV0EgteFtzLl96PEkbhNl+WvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZGUwZWJkLWE3MjUtNDM4Ni1iMzI3LTVlYjZlNzZhNDk2NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWYyOWNkOTktZjcy\nYS00MjQwLTk5ZWMtMzNmN2Y0NzA4YjRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDyTv4ingRdvFLMTL53g3CQja+btm/PfsJwF4DRsWfQCCh9TEMr7tq6XlCnYz\nxFZA/0NOXqruGWeGu62U5rhYe6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJmTmmLb5u9XIOvKLOlXIjhV8R5QwHwYDVR0j\nBBgwFoAU/JkJOzGKBlJr7BGBDvSjVbQur9kwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDXxVePFnufdT2YUTscBmbT9Qvr\nafo9xzgNeMu2Jh7b1QIgdD3x8u1z+uToLmSpTze3fVaneJ5EM10bF1rwtq8iSNw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARJ5rQBwvSm/T93x9VhgFussMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWRlMGViZC1hNzI1LTQzODYtYjMyNy01ZWI2ZTc2YTQ5NjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ/EzC6XxR4A9LmxOvK0eFxCScJXZNBS/wqojpT0UUWUZt6\neX1pDhWU0csq9co0G/2qyzLWiVxrncAR0U91OD8Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/JkJOzGKBlJr7BGBDvSjVbQu\nr9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDcnbanu3KCypwaV9IRFwKOBfZ+cUXREOSCm4uEG5cygCIQCpoYfE+6+E\nKTJCppm/opEEntGHgsbEiSWd9BmHm4XOKA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAXPaK+nvmxtH+tE1svKoewmIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWYyOWNkOTktZjcyYS00MjQwLTk5ZWMtMzNmN2Y0NzA4YjRjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzUzNGU2M2EtNDZkYy00NjgwLTgyNzQtODIwZGE1ODg0\nNWZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHCc2N9IVysXSmKfExG9Ic9b0\n7fC0urOJ4Dz6MWoCpjh4Mz6cPQarCfBXYs7IPKd9kKwaXzC19iixfLrNdCE0H6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQmZOaYtvm71cg68os6VciOFXxHlDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22NJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgSJhCzdN+TffPAS+Zrpik80Rb\nU6AiuH6Ny37wqRjSR1sCIH93KtoYUUy3Q483bfGDplzsyscuFpiIN2ybUyYAtPDC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9166", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9166` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAaJ06PloKjFRLv+OelAPMfFKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkxYzdkNGYxLTFkMjQtNDBkNi04YjgxLWRjNzM1OTgzMGY1ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzBiZTViNWItZTgz\nMS00OTVkLTk4NjYtZjlhM2VlNTE1YmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYiqZP2A46lQ4WTosVuKncGie23+1oEdlKjeLFXbB3mY8DtzVTdTUsSd+sAoQ\nxXQRvy2uDrXj+rNUiCXP/FHEgqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSFuHSeQzbW8tJNy/c3QxMvjxqiWjAfBgNVHSME\nGDAWgBQrwPuWCYNnOOEldGdMhfukv49eSDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD0sOFvM2WqifzjcVU8xLbpAZ9GGB7z\nAfc9c6fJDAgSRAIgENPI0bwemq8rnvR/k7Sutk83WVVmGyN0sPIexUoD7HA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ+bD6B+mjeo6wVafAs66KNhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMWM3ZDRmMS0xZDI0LTQwZDYtOGI4MS1kYzczNTk4MzBmNTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZ/lq21LX4NWyB99VowSnx8VFiU/ujhSPb/yzijCJ4psCd\nNXxHOWa+6i6YomEnnr1lmDGbnvGEXzYqXoixOwmYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK8D7lgmDZzjhJXRnTIX7pL+P\nXkgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMpoyOfeVacd46JjpGntGBl26VsqFxgfVNlTP1LFbYJkCIQD1s9sg+kdy\n7OEO9ftxGMY4V0XWxbndyXK3BLqX0/PIiw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAfIdVfShpxENVjbII8QORg1tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzBiZTViNWItZTgzMS00OTVkLTk4NjYtZjlhM2VlNTE1YmExMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWMzMTVhNjQtZDQyOC00ODZhLTk4NjAtYjBlZWZiZjU4\nYmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWcEwmRZ7G1l7K8MKuVWqwovb\neGKenTZQjNgdID8Nu2CVfF+Dxnq3fXeKRJrpiyS0Gn2l1ONCALPZZOyJcotvWqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSFuHSeQzbW8tJNy/c3QxMvjxqiWjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22NJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgYI0btWwlELRXcnwQqE77COP/\nC+2jwpYpYD8oBdjIFgICIQDERS2kD/YmPz+mEqgW5KPLkJ7o1QSFK9Wh9JibCVSb\nAQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9167", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9167` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAaphBVwdEQ2We7nIIhVOxztJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE0NWQxNGU3LTM4OTktNDkwZS1hZTcxLTE0ZGNiNWZmM2VmMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc2YTNjN2YtZWFl\nNC00YjYwLTk2M2YtNzJkOWUwNTU1NGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEioKM/pciqcIVNLqOnubylzZiN/tJiux8YHzayHO2Oa8u4PP/s82+B/mVVMxH\npOw8FvURtaPefmfINv+qp1FmjKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHB2QN9nhBJVBwjOkBnWp0H1tx1kwHwYDVR0j\nBBgwFoAUAL6UG4FOlOlWX5f6FyhNk74BbJ0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICJQ9qoU10tbNLAUBCCNl9V4GhHr\n3NUI7EVnc3eZ3yrAAiEA+HhWTPp+I6FILQrSfvTEZN2La8O3urs65wuotKNg6WA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWIrLQammPXVcJ8Nqc6JIrtdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNDVkMTRlNy0zODk5LTQ5MGUtYWU3MS0xNGRjYjVmZjNlZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjS5UpQro2Dxjcv3ixRojohDEOw7egi1S0uq4fbbsls4Db\ncOZHmYnhdK4XsDGKOhoAxB8jcIWWnPlGpBim0YjVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAL6UG4FOlOlWX5f6FyhNk74B\nbJ0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPbai07G0V4YoH7rPLuTmGvWo/PJEg9z32514XOffdMXAiEAuBmmvR4q\n12Y/eoKxnPTcrM60eE5fLidcbEfmg+6awGE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAa7qM0RjM6fREMHmY2prdpVQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc2YTNjN2YtZWFlNC00YjYwLTk2M2YtNzJkOWUwNTU1NGRlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGJjMGU1NzktYjdhOC00MWJlLWE3NjYtMjNhMzkxY2Q4\nYzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtyL7cv9Lxm09AOYb94+K2WKF\nTLgSPq8HUhNTqANBb0DUNmRvR1ZW/jETy/Xf/DIDH1UIk4M0HHz6FyZphKcAqKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQcHZA32eEElUHCM6QGdanQfW3HWTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22OJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANSCgz+WdV/9ZLVrItuDA8qY\nkWalXCxgSiYPjMZF6nLLAiEA/1mjVhEt58kTRGiyaFoEhx2Nt1Q1AyewSrMdz0lA\nkbI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9168", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9168` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbNG9HKMfym1YqA2WAd6RLTtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlYTA3ZTQ5LWUyMjAtNDhlOC1hYWVjLThiMDJmZjUwMzVhMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTAyZDY5ZWQtYmQ2\nZC00NDA1LTk3OWEtM2RkMDIzMDE4OWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtAOpcKy+Mizuj7NtGESxG6HCPsa8fh36b6faeJH2kyqc6x2OGVQOyLxI4K9o\ncscKJ5Hi6ZBpba7QWIhgi8sqTqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSL76JJkxf44MqAYEmOPP5lyuzf0DAfBgNVHSME\nGDAWgBRCCb49OPZiFtAdnkPPloh1FxuvoDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDAzdv9PzsMD9IMjWKTNby02evdFbOl\nnRQmnD6lqDV/7wIhAIPNI+ed7fFoCgeVAykLS/ukx3SC6NucFl+9FNTNP6Jw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbeB6Kf/NQ9nGqd+d3ERLbE9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWEwN2U0OS1lMjIwLTQ4ZTgtYWFlYy04YjAyZmY1MDM1YTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAThlGodoIEul1bHxWiCYF6YC5uSlVlp+uCQJu9ziVP8IDd2\nnHDlqdH1HdWjIWjVowJ/cppCKzxo9/HxegudhtBPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQgm+PTj2YhbQHZ5Dz5aIdRcb\nr6AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOCuHA10LUbhKlYxhHKW16Fv/7swO04IjHKjnuKSSAEBAiEAxIf6OvQu\nLx8aUcPigFdAE1U/sz7IUUVg2o0me+eq/Wo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAcAPr+g6VaLgMJ75Ryd3KZ2ZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTAyZDY5ZWQtYmQ2ZC00NDA1LTk3OWEtM2RkMDIzMDE4OWU5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjZkMmY3OTItNzJlZi00NDk4LThiOGEtOTEzNGJmMDUy\nYzdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuKXLelugwTqoGHY4GY/EsgLF\nf5p9utMW3JvwHG7vRlYXfrOIISVwjoWfd/C1gPXVaOri3IgIMygEdbkS6j09gaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSL76JJkxf44MqAYEmOPP5lyuzf0DBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22OJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMqYMwYxGR1PiIm9tDezZjXY\nzkTqLSsfz+kedv5fQyABAiA/r0/aaeiTAhCwK5cCgSmZ6Z2uXHiY3WXzAWX1jC/w\n2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9169", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9169` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAWdxMYEK/gCtwD/S2Sf18MWkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3OGNhYmRiLTI2YTgtNDg4MS05OGM2LWJiZTcxMTkwMjMwODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTE2YTVlZmUtZWM5\nMC00OGJkLTgzMTMtYWRiYWJmMmM2ZWQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFPsvunm74MNOfaJ4uVYCtYAzD/tLh1wOuUUKVZVYBVuBa6JITkwDc9wg57IO\ntYWmA+CGPm6RpoKNzxrZqoVCQ6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWXW/k9WYuOnWQ/SJDBYjGe5r8JUwHwYDVR0j\nBBgwFoAUpdfFo0PH04F0aqN+fH+rlT17+P8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFYHL1YNCDRAd0E4c5w+CXS/t5YT\nTYpfBnSY3ZZCBXokAiArsX808uDDBYcaXUzDfEn8IOaZ0hqiFfE0oqIV9HGUhw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX/+N5vP7zcQsdxZgZ2dvHxKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzhjYWJkYi0yNmE4LTQ4ODEtOThjNi1iYmU3MTE5MDIzMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQc49cAcj67opgtw7Y41BeRS0GD+fkX2vbpQuDUoqu2EceC\nGR4vypEMWZFHoBjyAz2ybVjZoWfU3Z6QRYQp7jbMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpdfFo0PH04F0aqN+fH+rlT17\n+P8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANvT/DA+kDg5qhdAyHGgH6IYhgytDP3vQ2TpsuRSlywcAiEA4w2uJCI2\nOYERm799N+Xi0wO+L6cL6LXgjT2fpDK4VrI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAVXIa+ccqPEkLrKJdIqFGy+fMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTE2YTVlZmUtZWM5MC00OGJkLTgzMTMtYWRiYWJmMmM2ZWQxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmFiZjYxMDQtY2I4ZS00NTQ2LTgyMmItZTEwMGMwNGM4\nODNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEATkXc2JjFUIqcw9I8ztYO8qk\nXUzb0bmtdFl8L2A08bGNa8vsaFzJ4azExDcy6rGD8dmDEo6LMBjalEt4n/J1KKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRZdb+T1Zi46dZD9IkMFiMZ7mvwlTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22PJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgeY/DXf2sa0FGX0+8W+dekZoF\n+YgSX7n17inTkeiglRwCIBP2vxf1geKVppzZIojbGHh1/oktw9Fy27vlPjQGeSd5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9170", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9170` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQ0pwtzwzrKKHAg/crIlmdm8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiMzMyNTg1LTJjNmUtNDA4OC1iZjhkLWI0ZTViMjAxM2RmNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM3OGU5ZGYtNmU4\nNy00M2RmLTg1ZTMtMmVhMTQ1MjIwMzUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEusaGs3ssEmwK9ogWhDxxsv+l0ZhdRRaZTabWyN2RFGnaUhLssySeH6DCix+h\nU1lbzvQeYPYdZfBwS6cWN6eLmKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSwTbt+wEclZSCvUiyqrvaZD2ON3TAfBgNVHSME\nGDAWgBQuWVB4JSFW8Uyqg42Is4/8jd3WDDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCtccUfIpxAo3fO6/3TdazRB32jFYT8\nFcSExItwwLxuwwIgf/BprAMAD9hfD2gZc28bRW3hJoyCAMTklIKdED2TSkA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATeONFbqRvqqXWOnoJ3GUlSgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjMzMjU4NS0yYzZlLTQwODgtYmY4ZC1iNGU1YjIwMTNkZjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjwxaGpOXktNWud5sGTZKlAwUIrb+x2dxNX0gTZ4r/Gx3e\nt0FWpHVR6FnGQsWlEEllKa9djb+9lD30GehjAll7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULllQeCUhVvFMqoONiLOP/I3d\n1gwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgJiubAydWuQq4MdX1mi6UC6SbAX/EZlRykK0OipJ/0jwCIQCzAmEIB3Yo\nAMwwFd0V3vcy3DpRSatSyKBmOWoZjEmZiw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAU7T2efgtDCpVoDCQMXukfESMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM3OGU5ZGYtNmU4Ny00M2RmLTg1ZTMtMmVhMTQ1MjIwMzUwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjI5YWJjZTEtYWI2OC00ZTRiLWE3M2UtZTQ5OTFmYmJj\nODkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEW2VSqJGr3w7FMviQuUmBtpW2\n82DsteqCHEgZ8H6CMmq/PP8gA0VGVpi02ZQJhIOJxQhBuOiPTXLGqxyhRCv+hKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSwTbt+wEclZSCvUiyqrvaZD2ON3TBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22PJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sdGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOFbCNhwKWeJygN1v0BsyXvO\n+OAXMbsHnjjwGW1dMb0sAiEA8bzwcY4Tt7P5BJBEjeTsSlkGh7xdB+iG824hJB+s\nros=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9171", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9171` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAW7QEIJDkdr2N5aXFsKO/GfBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmYWI2ZTc2LTU3N2EtNDgyMy1iNTE3LTZhZGU3ZmMxZDQ4MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODYzMmNkODYtYWRh\nMi00ODU5LTk5MGEtNjk4YTUxM2I2MTYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0VnjxWKnCqDSJIAae+I5ECCXfUUFAyOLz7eU3sVTG+m53jkE6TLbEBp7980n\nbISPmw2VaZhOV39wtm5PcV+3HqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb0y58ZxcuNidftG2HoGLSg3i9YEwHwYDVR0j\nBBgwFoAUyG45Avw2+b9PqVI7/sQZGXtE0TMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDIqvScd5plfivNXoezDF4TgDA7\nv1qVnzrAWMJB7RXaWQIgRJ+B7bO3mST7Wx5nx04PjE3ZAVpYldJVkpvfLLlastw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeVy5QD0Nk3/ZytOizbZtjl0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmFiNmU3Ni01NzdhLTQ4MjMtYjUxNy02YWRlN2ZjMWQ0ODMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASDB0UbqY0OYBVCZ15ZIAZOhcAxSWOFj0mAqn9iMKzJVigG\nnK+z0Q5jZuYvc9p0+8w+uh1tm9c9nI1426/1NtfVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyG45Avw2+b9PqVI7/sQZGXtE\n0TMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANsqNV4fJizHu/5dxSP3TMrPXCZe0F59b8YfhCVmxW5xAiEA0UzTDKQ9\ngGTJBiTLbsgS4hRl/SuRjPYkT+hKIo/hPwo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAbltVDWofToCwayDyJ0jixQtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODYzMmNkODYtYWRhMi00ODU5LTk5MGEtNjk4YTUxM2I2MTYwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDAyNTUyNmItNDk5OS00YmY2LWIwNDMtNTVlOTE5NzQz\nMDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMY7TGywVboIY3kHTcag4jZig\nNZpNQWtuw5N/bkanQRkqFptkOQL0rt37/6o/pBMxn4JWzp+3bNV3bpP1HHsxdqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRvTLnxnFy42J1+0bYegYtKDeL1gTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22AImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMbw/PxJwJIpOfMkMZu5P5PCLzW7\n+/JBN3bZfZD3GcmHAiBOuJlWyqofw+BAMlj6PC3xMGBkIZz8rKEEH4PxBzrmUg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9172", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9172` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATfVJQ6kqqea+5wUGmENZlcRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4MDI2ZDQ4LWMwZDctNGFjZi05YTE3LWY0YjhjYjkzZjQ5ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDZiMmUxMjUtODk5\nZi00OWEzLWFmYTgtOTM2MDA1OWJkYjQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2YiR+Qac1pRwA5MK9fFZSvNYu/9D6QjOiyf4Oer759VTM6X49Lj2ddULt2/1\nE2Q9yhmpXKbV63fcGgtUGjnkFaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTLNWO0wCsi7TcdPAxEPVfbBsoKRDAfBgNVHSME\nGDAWgBR7r1SfAYTnVZKvD1tn+mW+paS47DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGEqj+y3e6EP2cHC/7dBeeeuLaAqxVWy\n6cJjuDT2EVcwAiEAmoYvRS2THMMCr7PEd3F+VgE5FSzCRVCjtDdWJMllyi8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAejPdrNhpNhafPceQB3AH0i2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODAyNmQ0OC1jMGQ3LTRhY2YtOWExNy1mNGI4Y2I5M2Y0OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNEpY1ssW7GV5q6pJ37vuJJjiHfIYQ13XsmCkSfkmVrc9M\nNtmpbPdBbj94k7QqXAa++RHnbl7OuEqr+WZa9zs3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe69UnwGE51WSrw9bZ/plvqWk\nuOwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI1svfQ/+3Br46i58ucAMw3KuMc7vzTZoNtF5E4PHnzdAiBMNGjfSg26\nQwsUwxBeVp/fidn7s5EtT2tQ5H15Ray9Dw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAcd7gRGmxVwuao3vfMORPBbVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDZiMmUxMjUtODk5Zi00OWEzLWFmYTgtOTM2MDA1OWJkYjQwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDY3MjdjOWMtODE3Ni00ZjVhLWFlNjktNDg0NmNiY2Zm\nMDJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ6H26faMi5EZ1/i6vmESdZwM\ngsyNcDKEaRs45+RGGhjkYyRfHYZkXzQzl0eUZw5G49jkYiYYfhPxgEh+hX8/q6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTLNWO0wCsi7TcdPAxEPVfbBsoKRDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22AImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKK/AaZXk7LXOEsRiqE/0hMn82dz\nTVapYvCA/NMkOqRcAiEA1JT4HQED69NXv305/Nq58x5SyHt4zZLh0KcuV26yrWs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9173", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9173` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISASEfA1YSDiQOkauE8ZWUMA6wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNlZTg0ODViLTFjYzYtNDY2Ny1hZmMzLTA1NDU0ODI2M2JjZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDY4NmRlYTYtZGYy\nYi00Njk1LTk5NzQtZjU1ODU2YmZlZjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoORs3ZaZutxnJxSfXAohcDS59ZZATxNt1b/5BxdEHP4TPqRlF3PIhK6l9TOB\nn/OmyDwmR823DE471+psV166eaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaSw4jvBJQUk6iDHMdfdDEfxTExcwHwYDVR0j\nBBgwFoAUfXjCGTvKiJwKUpwss5ZS/CAuGFYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDoyrhmpBvvW7V04fDrRSPJMGb9\nj1Kx8xKcmlq1wVKycwIhAM28lBzET5fZfOPcniLAw1NqQRjaoQpVqeSwy8TRzQ8Z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQHfoi1z7WCm6xN8NQs9RaU1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZWU4NDg1Yi0xY2M2LTQ2NjctYWZjMy0wNTQ1NDgyNjNiY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfLNmVT0aEbdbd5dAz0pOFSOB7Jaez96tFiiq1GuXw5/hr\nkxWB7aFmsahRab8fyhAeBKteaGIbxMFrcgbOHjgdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfXjCGTvKiJwKUpwss5ZS/CAu\nGFYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbuu/2m+k9fZL0ve1bobNsly92FYUPxpmbE3ui2RmE64CIQCgnfZDxQPe\nMtVIPSURTL8kwStvJEasBJyY9W2diy1mtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAW7FNZrPX3ymHDFZhm00jhpJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDY4NmRlYTYtZGYyYi00Njk1LTk5NzQtZjU1ODU2YmZlZjUyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjdiM2JlMWItYjc0NC00M2U1LWFkZjktYWM2YTkwN2Yw\nODIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1LpRJu3LjUZmJxg3rXMXxlFO\negV8Ag+GBizHIuUMc+yZntBjQNs3AH+fznfe7nZPLGJoLaHU4eN/dVvvKhnftaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRpLDiO8ElBSTqIMcx190MR/FMTFzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22BImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPXc45sXW6TEvJuveELI4+lcRj76\nECywQqjDIJJKmw2wAiADRgow9oFvJsOuNCfzO6jNrcG7yfTWNy7z8draZoR5dA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9174", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9174` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbgWDWLiqHgvcDcr28zV8qWQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwMDgzYTU1LTdmNjctNGYxNC1iMWU1LTgwNzUyZjNkNTM4OTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBlMWVkNzEtNjIx\nMS00MjAzLTg4NzQtYjgyM2M0ZDg2OTIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEweH8k+DA8TM+YsGjS8GH5ANRC9Sw0sqRnhNv5M7j8Q26k25o5VvGw9+644o+\nQWNb3LNH6XXd+Ggb4JBcs6zDX6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRpYufqt6YokFU/1wLmi+/UWLVkaTAfBgNVHSME\nGDAWgBTOx5ZxBLiMqkBwxZlk4a0KZ4EFyTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCP5vyx8o8gboDby4QQxbu/yOumA8+o\nJ2KA2Qhx2GDdIgIhAMhbHk7MozgvwcZaiOKguNERFqlEQ/Vy4u1rJqZhzfWo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS8fLnoDbvulPK7grzvsh+xIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDA4M2E1NS03ZjY3LTRmMTQtYjFlNS04MDc1MmYzZDUzODkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEgTTa23mgbi+9lfR/0itZLk+im37AXe7owCR7Bz/41CAc\nulmw+aAaWl7ghTqYjf+zSTnitxw3+LQ4+R0Luktco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzseWcQS4jKpAcMWZZOGtCmeB\nBckwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSgydXffeKAupDzOzfMd1yT3V00ROK+/FDmTYLQ0cFpwCIQDNd2RZEtWt\npUd0M0KPMNvlB1QrPdgphT1938xuEyvUEA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAeuqI5GbEwZJ4tv+DURXAWufMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBlMWVkNzEtNjIxMS00MjAzLTg4NzQtYjgyM2M0ZDg2OTIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTZjYjI1MzUtODRiZC00Y2VlLWI0ZDQtMjZlN2UyMjky\nNzg1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAK3JgPjY4wEi/wJU2Z0+hdP9\nj8SsivvQqVfcFTPkDAC9vl1Dk4yzW/Ay8h3zzBWK61hKgoLthNEoNwG3LMsttKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRpYufqt6YokFU/1wLmi+/UWLVkaTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22BImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMljjtkC3z3Bw/LrGx4Psbv0uIKq\nh9JOE25gMoFepK78AiBQHfLghg4VmIxSPGTogcwhC4z5BnAgJXaqInzUK5ZumQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9175", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9175` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASmpvcNPOo+aos7hYYYe2T93MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRiYzA4Y2VhLWIwM2ItNGMxYi05NGNhLWNlZjY3MmY5M2ZlZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJkMWFhNzAtZGQ2\nNS00YzgwLWJjMGUtOTE5MmU0NjBiYjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjycV1OqPycCK8uO7BQRNpUzudF8wx3Gt8enJYBI30OwEf0rdZ6I/0VE7V8/B\nm//LHsD92WiPXqdVwb0m/USf7KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNIhBMEv2UdqFHqIcfmBHfiZY6GswHwYDVR0j\nBBgwFoAUR1DwcPDlpkqhqd1GVwO+WYVs200wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGcPq2d3Psb05U5X4GrM4fqtYkZm\nX88E72f9AlUAmOskAiEAg2aASOJanqOI6D623FqOpNI7dea7wH/wEdJUG6cRjC8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQDNLVtXpk3gEJZW5YQgkQfkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYmMwOGNlYS1iMDNiLTRjMWItOTRjYS1jZWY2NzJmOTNmZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQepcbmtBvTMsOEgANSRgCmxaY2SGCWn0QvIK0M89RHRTDA\nj2OMfJObMN+DkZ2b/QcFb+yJlhyZfl1rCdPl0uD3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR1DwcPDlpkqhqd1GVwO+WYVs\n200wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKf5C36Fmz3HxomtEroXTRk9cimGWvkeOPE04ESvYAGqAiEAgxH/oubP\n+XcZrTanORDYTJfvxgE+woX1cSHldqJHCUg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAVCEQtGdUKSMQDc1ff+qCrrcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJkMWFhNzAtZGQ2NS00YzgwLWJjMGUtOTE5MmU0NjBiYjhmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWFhYjhhZTgtMGQwZC00YWQ3LWFmMWYtMTI3ZGVjMzQ4\nMjFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELomuAcQES/zyW5HR3vv9Xkr4\ny5xWjVqEuIxF44xxoRWajWRqYwdcJyVOlEqOuae6tjpN5RDpihIjFzJinhVh66OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ0iEEwS/ZR2oUeohx+YEd+JljoazA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22CImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKnLwwG6dHiZBLT2VLgxBare2TIx\nmTPTIuymW5jK5fjvAiEAu+hoz1/DU2Bj/R9cXaLUX4vOg+vZDfP55vt1vFtWl/Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9176", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9176` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbTUePEJZ0/cf4XvpynNNTbQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc0YTNmNjljLWE4ZTQtNGY4MC04NGJiLWZhYWFhMmYyNTFmZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJlYmRhZjMtMTg0\nYi00ZjdiLWFiMWEtN2NhYjg5N2UyZWFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE913oW+oNgfqWCSbBOIAuwjVrJh9UtIsm2Tr7pI1gY0OlYnAbpPeSFeItT/yR\nGRcXKnQGmVIbgw1aMuVv0nHT+KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQUX/KJo0S0llsAgmLvhImwJaDwhjAfBgNVHSME\nGDAWgBSTOOw27igXJsWC7vYyma7HDyb07zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGDGms6cQEX2JXsJ9xWxRJh767xrkJZz\nVO3gZvdcKavsAiEAvbGoEhskpYPhGCQhUcZZv6VFV1LvYiQB2/RIxrBZmuo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfKi5j+96aYlXAe+s7iWSNosMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nNGEzZjY5Yy1hOGU0LTRmODAtODRiYi1mYWFhYTJmMjUxZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFC3a44lR8Kbazbb3qT+da1B13qh5Dt34RwzDhUOnDVFse\npMbuNcLzlpjCX1g2U1xwRMQdINCIQDlj5r4s/EAho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkzjsNu4oFybFgu72Mpmuxw8m\n9O8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSFRC+GJEoUrZBMuRi04NlR3ju9w3tWOnHCYthUPh+2YCIQC0Q5tJY9jW\ntsQdHIEM2Z7l2lRu5QYY1KqlmZwslzkd5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAZILwnTms8DrKd4CpWsNDNAVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJlYmRhZjMtMTg0Yi00ZjdiLWFiMWEtN2NhYjg5N2UyZWFhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjk0MDk2MDAtMWU2NC00YmMzLTk3OTItZjEwOGQxZjdm\nMDVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcObMcOiPds6MIdESPbPXRYuo\nc438fO5G62YagaNK6Q0RYAk3s4WPgkwjC0lLm6m1sC33kJgeWzOq7Bk2KnO9N6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQUX/KJo0S0llsAgmLvhImwJaDwhjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22CImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgZJG+mw1f9IpSR61STaPFQIvTTxp6\n5ZJIE4XlCNgr1NACIQDY7ITSrecEj58WCXMnOoj7jPgcsW7Y+kcZuH9FdyTssw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9177", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9177` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAebafGlaB0kAZyhRIeZIkLZXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlMDQxZmI5LTZkYmUtNDA5Ny1hZTM3LWVjYzUyNDJhZmQ4NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmY2OTdmMjctYzU3\nNS00NTg0LWJhOTItZThkMTM1ODQ3MzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMZ8h8t/s50Z+GYEFlP/QSf4D4pw7FnHM+r0GlEvOFoZYs5mz6beSzf1bOwo4\nu+THwXbuFdchh5H1WHeCdxcUiqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUs0+VffpwrMedFyVHCIHue/ZxhL8wHwYDVR0j\nBBgwFoAUWqS4u/JqWEbAdgdcpEHMoVrqcP8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC3bWQRcZt9JqEyVvmdU0FjSju9\nZq3uVlC/TJtPPu4EEAIhAKlzql8fgSdOwgS7mu4VMf50D0K2zETeiW6+2gykqBTJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUS0xDYImb5e/KrgJq0BcN2/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTA0MWZiOS02ZGJlLTQwOTctYWUzNy1lY2M1MjQyYWZkODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5BPGH0y2r5bMitn1/AtmkyjDllCaSVZnFfhfjpzgSZcIe\n6mZIb7ND+fcaX/TOViG9bnfUPBCW6TNRMLBe3YjHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWqS4u/JqWEbAdgdcpEHMoVrq\ncP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALBrOpMkgBIpXriXjkr+G5tjp9TPwvN8F668QNJa3be0AiBr9JIHjDkV\ny6OF1y6bz/MVDMBWI6NPE9OkasK5/jSvIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAewJ9nXBfKAJ5E/A+lgm9bOXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmY2OTdmMjctYzU3NS00NTg0LWJhOTItZThkMTM1ODQ3MzU0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDY5NjEzYmItZWNlMy00YmUzLWExYzMtZWY4YmVjOTc4\nYzI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0q0XxxdyRGdpBP+1IOTd0P56\n8qLccNRGNIS/XpGkat5uNGVlqbK3Qc28FWuiAn1+vyeNZidJwphlcUSh0lSWRKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSzT5V9+nCsx50XJUcIge579nGEvzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22DImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAN6MSmyMN9CzIkq8TBbLVguaxO65\naZOBrtM/1e5eXSpKAiBsakcHQYGBNyjv4AfYeKissThUpCyFK3eBcETWISSbzw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9178", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9178` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdC7EjnVCF/YCYodWlf1CHlXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVjZDljMWRhLWNiMmEtNGMxMy04NGY2LTY2ODI4ZTdlODI0MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQyYTFlOTQtYzJi\nYy00MGFjLTk5MTEtYWVhMzZmOGUzOWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE59xKX0c6+Kz+3u0Z+JuiFkg5SqESEqJFpbzGs+fo18xmwY2ms8KwitXR8+R5\n5hVjBgWhvXcVdYZVnapJYCpcjKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTCjEWwIVQIUdrMtcYoAH7mFn3IiTAfBgNVHSME\nGDAWgBTG4hzO3So+h2/DOI+rtuNVDh2lBzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCBwX4r+nXeP0r8SwzWWPeN5fK3Q9ky\nF1ODZMOn6DXzLwIgdIfg6SFgYdAcGJ4m0JUuvbXn+H1umwHStTmtorkLoYQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVAiWnn3ldyd/uVgisvWAnvNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nY2Q5YzFkYS1jYjJhLTRjMTMtODRmNi02NjgyOGU3ZTgyNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARKBORbxcAtOZ3a7KCOyLfq9tOp17vfcy21w1oN9YZRbkZI\nCSTW4mC/krTR66epd2Wv4XojhzupilmRUHlBGVigo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxuIczt0qPodvwziPq7bjVQ4d\npQcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO9HfwndoSA75mDHsydfUPEsbGqyIh0EGel/BEkH2apPAiEAn7L2ruVB\nWl6D+zLbPTtWzCiETuidnTiyIgJEnk7uZPc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAR3IFTOocFNCUg4aB9zpTerqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQyYTFlOTQtYzJiYy00MGFjLTk5MTEtYWVhMzZmOGUzOWYxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGRhOTY0YTEtZTY4MC00Zjg2LWExZTAtOGRjYjQyMGNk\nYmNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcajNjDaBwVv/nYg7PqhBCs2e\nkXiMXrADwkB4mHMRUL8yD8D2IK7LpUvz9gCup5NweLEEACQaXxDJ8Nopi+qKDKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTCjEWwIVQIUdrMtcYoAH7mFn3IiTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22DImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIge/cluZd2lltWsrA9hEn/6aotky6o\nzwHr8YhdOvNBODwCIQDlS5NDJnzGgB2wfW7pfsmnuNgDVqxLKUT39pvynN2JYw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9179", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9179` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAevWMx9JmaZf9JUD2RnyxyDOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxMWRlYjcwLTFlMmEtNDFlYy05MWYwLTllMTE5YTg2NzE3YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmUwNDQ1MzgtYzhj\nMi00ZjIzLTg0OGEtNjhhMzEzMDI5OGZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOwGA8WRr9WmjolWyaklcnoYAPUWcR9I11rw/DtlEcodqjm/7bN6jLqob6cnT\nq7mPyxuu6W9aG6cct0fPTWd/fKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIMV+lbLB2Mqeln8NM2ipcb8a3VUwHwYDVR0j\nBBgwFoAUQH94Nle5al7aur7BCAcQUeudgHEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGg5wZitKL0I/bVDypMLyADCVpLQ\n1aZb75heBwKogoS8AiEAoiYx9ouoq6YDh6Unv7nyfPiroWFhtrsVCZW5LRcEW2U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQDy7moJDjTSvZcL0L1/J2H5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTFkZWI3MC0xZTJhLTQxZWMtOTFmMC05ZTExOWE4NjcxN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASsjjU/OgoGA435lcdFuni/hqI/iDvmwfSSZQMNTA0JEFh0\n+jXOEGm/N8taJOQ3U3HVp6E0buWEjKgpiw9rO/JTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQH94Nle5al7aur7BCAcQUeud\ngHEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXSI+2aXVBiqOsdUfsbAy+yAvtGs/AlL4oHqCFB0DK70CIQDe2Txg/RkN\nz25/dMUFS1rpdf3PLWjt0yZ3g0mDOMDfPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISASo8bd6zSi+dX5yxtFUUTlcMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmUwNDQ1MzgtYzhjMi00ZjIzLTg0OGEtNjhhMzEzMDI5OGZkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGM5MjQyNmYtZDM2Ny00MGRkLTkyYTktOTZmOWE1MGY4\nMWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJQTYJg7sPChaPWv2wEKQvMOd\n3McsJhGfrizKelBApZ4VkD2HRrq+uGhoVGmtfnpjsN/3zsUn5BM9AfHWbG1xp6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQgxX6VssHYyp6Wfw0zaKlxvxrdVTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22EImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANaafVxyeMF4Ao0pArQX5vFWC6zq\nULn3ZRSyxRd17EErAiEA6JMZeZV7PLrsbjv0wDZgPbdCs880CzTz6dokNsmQhzI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9180", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9180` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdGW5uWHGOR4XJU8ydIjzua8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxODk4OTY4LTViZDktNDg4Ni05YWY1LWQ0YmVmMjRlYzVjMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjViNDRiZWUtNGZh\nZS00NDQyLThmNTEtNTc0MDNmMDEzOGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEb3SHpEPTYs9Ct3zvfcOD4SiNdqSJPiqrHT9UvNVoTeDHks2HlSdju3Tizz5M\nqKUypPIOVLBF/mM2kbW6rvYTw6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRBdtMSwUO79QHWqT3qosx25DpgkjAfBgNVHSME\nGDAWgBQqGqUOuQQwqSSpj22mih3TkvNThTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD/TEiQK7UVKYlDbeqJABOyH3Yn7q9t\nw/2/7wYmsudJvQIgeCMxanLT+WoZD0AefFwGEHjnYRWWU3qQdf+IsXMVY3M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVM2Fdq5lTMmGobWmOuptHnEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMTg5ODk2OC01YmQ5LTQ4ODYtOWFmNS1kNGJlZjI0ZWM1YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzNv3YEnwvL/sZJjAdFleOLqVDSuQFamu0VUKSedGf5u47\nP6aRQ6Fhd8znnxXl4FNjJdHajvkmlmESQzRRZeBCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKhqlDrkEMKkkqY9tpood05Lz\nU4UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAICj9hB63zJB+d8N+n5afdPuMcCD2gI19yG7TuLXzn96AiAUarluOeC3\nEZJhX0LlkkivCh+NzehYBJwl3dnQdU7rBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAcuoJazEFw6Kupn4HzshqESLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjViNDRiZWUtNGZhZS00NDQyLThmNTEtNTc0MDNmMDEzOGE2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzg5ZDc3Y2ItZGFlNC00MTQxLWFhNGQtNzI3MWY2MGRi\nZDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPY41cyjQxbySyu9jZCZZyfO3\ngpX0FYzGv5iGBxs6Qcy6g1JhLRduIlusmTBOhtBo24l7KBkm2AAZHyd6wtiwQ6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRBdtMSwUO79QHWqT3qosx25DpgkjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22EImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgKzXhjmgnQeb3nre24rlUFz6lgEl3\ngoQVPy60XuIccl8CIFhBew+3Sgxpn4uygVs7nOGluw6eOdkLw94EqCJ0pV2/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9181", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9181` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASqQqfeQdYv7PLzb1+Pkg8IQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFjOWMyMGNkLTkzNzEtNGUyNy1hMDU5LTI3Y2FlNTUxYjJhZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I2YmU3YWEtYTg4\nOS00MDlhLTkxZWMtNDBhNTMzMjNhZWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbofEbkZ2FMEHwmBIOtylLc5h96Wg3o99wMRR13H9v69Ss9LQ1Nq3Z0aUQuqE\nCRgk7EJwB0yIUs3KS1ig5KdKW6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU24AlHN5Gwd3acefUC6N1cP3WZf0wHwYDVR0j\nBBgwFoAUY3WiM0FeeAG4LAtWcTeOHHxfGD0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC5YgzOPQgUy43ADilXhEghn/PX\n3ObuwT2D0Bdse5lQ0wIgKELKy+J5kVsOwcaidOjU27R8kiOBYC6BqN9ulRIla3Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZP5iatjcXxnQzGtZuW+wipSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYzljMjBjZC05MzcxLTRlMjctYTA1OS0yN2NhZTU1MWIyYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS07FKvON9WgQiHJNOOVDXIc5cbzIHpOs43H2tRHYAP+iZu\nw+uqIdO5cMAtNPVJnHRbtq/w416zKhU6+IH4aHXOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUY3WiM0FeeAG4LAtWcTeOHHxf\nGD0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKiN9v6FIOw928LrSwJsX+n2OIMfPgbK6eNoJu7tdk1tAiEA5K9SPe5k\nH6AP39od1R/LwtjXamhuvkF12zwwu8RXmOQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAYl5Bx7rRDaQ8maHDs2oK9u4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I2YmU3YWEtYTg4OS00MDlhLTkxZWMtNDBhNTMzMjNhZWZhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmU4ZTAzYmUtMWY2NC00MDA1LThmN2ItNTAyYzU1NDQz\nZWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn3aAbCz5QYTw90styXLnZ+2a\nahjKq4dSwmKdOfRnVV9u3l1wYlIwoFEZOCV5k7YOmt08TH6e/WXHuYQb1aWrhaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTbgCUc3kbB3dpx59QLo3Vw/dZl/TA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22FImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgGHTsou+v4fhE+R1Nhsm3EFCDInWS\n0colxvpiUzFTaJMCIE8UfqBoDRC8Tcowsaf63zNCMHa5qZzdr8/CLvb1JZw1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9182", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9182` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAd/KZ1l7bscqPY6FyVlk0fZeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjNWY5ZDg1LTU5NzAtNGM2NS1iZDgyLTQ3MTlhNTRmN2IyNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2I5NWE3ZjctM2Nj\nMi00NjJhLWI0NzEtYWYxMzAyOTMwYWFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERJ+C3icvc6byU/lTB8iw5XxGBsY9GnFyRsKHyu2sdjZV/rQVIfhxG8RoD9uv\nuhLn3Mp/jB9IIVViby+Y8VRS8aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRCXUy/ka2jeBK41J0G1l5GUonYKzAfBgNVHSME\nGDAWgBQIZJ9jnAZ/StsOoclARwZV2NkX6zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCYpzbkEWvtZrX3YKpa6c/gIKspHCz8\nc0ALGC93fVzRTAIgGpIQhVjQKrMk478qg1rIshI++9GRdMLzd9YNtEa+OBs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbvS7+hHJn6n/FTC+/wBCEL5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYzVmOWQ4NS01OTcwLTRjNjUtYmQ4Mi00NzE5YTU0ZjdiMjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBbDdcOWEFMv/1vruaEi9RuNk7zJl08uqxSboRC/FBkpOH\nw6cBlx0m3pwFRVGbuVt2m11LZkLxb555amlJK/QIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCGSfY5wGf0rbDqHJQEcGVdjZ\nF+swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgG3V4r39DJnaJoENMxkKRPz94AJYAb0V0nh5yUYbdGTcCIQCReLLK7oui\nvQhbsmLlBMSrilb4ul66/gXo3zX5Ylws7Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAaXAriNNdPH610Xi81Fyh1eaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2I5NWE3ZjctM2NjMi00NjJhLWI0NzEtYWYxMzAyOTMwYWFmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2UxMzgzYzEtMmJhYi00YmI2LWJkZTYtNDBmZjhkZTYx\nNzA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6l0F+bmQn1uk20WMr2ZYTr/v\nS2Ui0Fb+fU3GPcEgRcOdMRD0OMSQRg6K1/lW5qxaqKBLRD6+o8XP6+dFauLm+qOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRCXUy/ka2jeBK41J0G1l5GUonYKzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22FImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgcbOq9cJzSnxfWcmJX0wmdHhadwjr\nAv7m7+M3DkEMT94CIGL1ojDZt2CBAWtYZHmOlNWuThjS+iV/7Wqa2R8mOb9G\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9183", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9183` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAWPArsRUv0R6E0estbxIJn1bMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVlZDg5ZTQ4LTgyNjItNDNiMC04ODlmLTQwYTVkYzhiYzU5ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzUwMWRmNDItY2Mx\nNS00YmZmLTg4MmYtMDIwYTFhMGVlMDc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOo+Sak7bMRPJNjMPkTY/KvhJrzHljDuZgR61T6oZZn52EeJNLr1kWzjk6Wbc\nm0HAsCtSWjbm09PCuLaUVK2YX6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUy4/X7AkdyNCckOMwWW68MGn+q+gwHwYDVR0j\nBBgwFoAUmtUzKznFtwJD7pFEKuXmXZoxZPwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCh5A2fK1pw0LkF0M2FQ/ZL89EY\necRM6HHZoWbdm3Q3pwIhAPxqOG5qlgIErjew6L9ShPrJpEbBFRdeFInZfabZ5d+7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYxGcttSWIeJhJmew/9JuEOmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZWQ4OWU0OC04MjYyLTQzYjAtODg5Zi00MGE1ZGM4YmM1OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASNgNf+a9WitHga5KBZTAKeXuiy+Z+70PgIjbklHCaM36NG\nn6NJsBVpkermR3Ldnk6eZiQl+HftiO9jfkB2o8J/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmtUzKznFtwJD7pFEKuXmXZox\nZPwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMjKOwtx6OYjoxWK3aiN5KCHn7mF6BOee5tK2iMjUL42AiAfWBB7+Eed\npFEGei7fr2qNt/k7YCzMLKBWAiCAwuH3Fg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAZSijH9VKw/8HZz3zFAjqYIoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzUwMWRmNDItY2MxNS00YmZmLTg4MmYtMDIwYTFhMGVlMDc4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODg2MDQ4NTYtMWJjOS00ZTBiLTg4ZDMtN2Q0OGY0ZTUw\nMWYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEF+EONY/dtL4va8X3nV+YxM33\ncMSd9dex5V+5opbD1GZMLJ9+mJsP1xRKPMnuhOrPYVrVyokfS5ole07Btk0f3KOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTLj9fsCR3I0JyQ4zBZbrwwaf6r6DA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22GImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgXsj7Ojvd6MRG1/56cmHMRT4tvwI5\ndNJANTmmg7zWHBkCIQDSzGlKsl/sLEVW/Bd66MJb6Zcf2EgqBQl7dhtSs4spgQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9184", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9184` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISARy17/G+khviWouBT3sM2TTsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzYTMwODU5LTcxOWUtNDVkYi1hYzgyLTg1MDA0OTM0NzE1ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2UyYWEyMzktMzVk\nYS00MGM1LWE2M2ItZWRkYTgzYzg1NzMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEIiQcRM7wej29nm7fB9aVJUGqycA+7t8fdhMk82sJp8T3dmUIpBnUuwFoXDo\naCSDXfFlNf4tjDBg03Aaceo6SKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTcJK5MIPQANlu3hA4UFhpiJyVEOjAfBgNVHSME\nGDAWgBSEHz84Gz4VHIb+DTC+n7AK5oAtjjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDcZZYjEJp/KD57vWIAdsYyDmSzG32L\n3JYrzryGBFKehQIhANsEz5a3J9zwtvmiRN9MxDYVG0iGdsnCDGoUyarZjouq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASNx0CWZnPOf1a7dKLfuXWmsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nM2EzMDg1OS03MTllLTQ1ZGItYWM4Mi04NTAwNDkzNDcxNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrrP0vi1XWQrbxGESaZrakwK4sbhDEGdW2wy888dstdyaT\nlsIk7vHnlORPPWJFiV5mDUID+2L7gag74N2F6k3io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhB8/OBs+FRyG/g0wvp+wCuaA\nLY4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALhrt6FIu2QpWznq9yhriyZ1iIKZJqGm70FZy3AK5ZMQAiBddKkuculC\nlLIZr662BIZxc8uo9a7N5IcVql+JGAnQzw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAc5+jadymB0XkH4ZpE1yxRoUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2UyYWEyMzktMzVkYS00MGM1LWE2M2ItZWRkYTgzYzg1NzMyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2NmMTliMGItNjM3Mi00Y2FiLTk4MTItZjdhOTQwMmQx\nNWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXGSviazqcMBk0bw31NZY7MbS\nVDhs/A31An8PuHWZj1CJ3V7cGsuA2+AmAubz+Khbr74K68HtkCrqIEUQt/CF/aOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTcJK5MIPQANlu3hA4UFhpiJyVEOjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22GImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgHTWuOpc5pOpo4ObMvCDHl8IbSo6/\n/e7aowJ9pTBThkACIQDOseYeyB7U2lzLinfgODxHT8vduhXZKZj2LOT91tC5Tg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9185", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9185` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAeyGFEv8XlQrUSy3vV7UA3N7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM2ZmE2NjcxLTU5YjItNDkxNy1hMmNlLTcwNGI0OTNjOTc2MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJiNTQyYmEtZjVi\nYy00YjJlLWFiZDUtZDI1NWNlMGNlMTIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfJO2J4IdDgaiNBdP0/XU1iIPuIfgQAzI7Ghs/wc1+LU9RxopVIB0cHVPlMfR\nSAYouTUsmFxVTtHXPCkiRwU9GaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/PzifOzzBQUjWtQnvajaUzCUcsgwHwYDVR0j\nBBgwFoAUTI9781YWYKnqb24XxbUTz4G9EHwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDE2/+b99Dni4piBzTqAxtrREPi\nmTUxg+kPMCEwrTns/AIhALnIhGYpinH3/kCOo1LPqelXHHCni6kzUx0avjjeMtjc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXH+BY46U7/IWHBAZY/riDxwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNmZhNjY3MS01OWIyLTQ5MTctYTJjZS03MDRiNDkzYzk3NjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrUSQwWyEjLreMuFxXuZM63/5zFLtwJxchbj9u1A9Sv9lY\nuD6Uj1Zd9UO+HfmMP6gkDxLVlT2bvOLbglmrgOFao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTI9781YWYKnqb24XxbUTz4G9\nEHwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFv5BTp5/3JcPhzU8qd2ZIfkh0Y474EEgO7l6Nh6giyACIQCjSMBNnRTo\nbUXIJKlDJA4BOxSDgd2jEgJ0iCwDQg7fvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAXPgnqfZ0ddFj2Zb8Merq2/CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJiNTQyYmEtZjViYy00YjJlLWFiZDUtZDI1NWNlMGNlMTIwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTAzMDk4MzQtNDY1Yy00ZjQyLWFjMmUtMGU2MThmNGMy\nOTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHZEewR2E2L9+TuKKzDnf0ReD\nPojHj5EunmXmyEX/UfSnwSqGvxVw7tfKoioq/hc0kq7dAJsFc8jEa2G837OhUqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT8/OJ87PMFBSNa1Ce9qNpTMJRyyDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22HImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgBrGJCNAnr11b6J607DbCkAMkyEZE\nzwFiE067AuiqAyUCIFv1ZvudF2JJCE04Y3cYmZQ+BHW/IXEixM+tL1Jiw/Fw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9186", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9186` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXb3D6rOJ2SbpWWGjFm/uWiFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1ZTQxOTc0LTkyMjgtNGEyNS04ZjhlLTEyODA2YjQzNDhmZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzgxZTczZDAtZmU0\nYy00ODdjLTkyZWYtMWQ4ZjkyNWMxZTJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWDsE4Q8SlxLyFr++Aeco7fDZjFXKcF4F6SsbBpAeYuMUWhROvNBIemVlpxlQ\nJcn8SbjTASFgfw9tWIsZ8HQZW6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ5yyk/YUVXi54FQxKq4sB5YWy6PjAfBgNVHSME\nGDAWgBSmhyikoRbks7QShPPZqYniq0GsPDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDobQUUcG/80nI3+iIjEgERlP6zBk8M\n6PoiS4r9g+vS2AIgL3cWqx9tPr79c+59zfd/wwoArIx5pXGQC9DkgS8jhgo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQm0ll0AhdMszDHRxZWnXhcBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNWU0MTk3NC05MjI4LTRhMjUtOGY4ZS0xMjgwNmI0MzQ4ZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARv7KiXpR3GS78JX8+0s1iOTHukfnX8732Vc4pa1TyPJvAX\nnCCUWXXbqXThztVZzby7p5PX64RDh6ZicgLIX3o4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpocopKEW5LO0EoTz2amJ4qtB\nrDwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMFN4aboaAJB0x+kdqT4+v7N1b0Nndkp+qDVsXB+6JswCIBe/wCCTW9I7\nhlrN2xAkaKr9h6vvszYtPQAuPWGUlD+0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISASsHAsZPtagR+xBVwOpJt2MKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzgxZTczZDAtZmU0Yy00ODdjLTkyZWYtMWQ4ZjkyNWMxZTJjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2UyNjViMmQtYTQ3ZS00Nzc2LWJmYWYtMjEwZmE2MjY4\nNTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmEEObgFODJQE+AUlufmkNq/n\nyqPJq8Jq8Q7U88HiBoleCVA4aywmK/6yGjwuVk46au0htktwjFuL1NhKlc3KmKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ5yyk/YUVXi54FQxKq4sB5YWy6PjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22HImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgDDNvkqGK0dGcpEEfda7q/uVR15Ea\n5VnXkqIQI9IxNhsCIA6w/aO+5HL2/TRQKMp9ukBMYHjuDl7n/pjNLw+KcdYN\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9187", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9187` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAYqPMtNFsyUnkb61FxKcbGfDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUyOWVjNzRmLWI0NmEtNDU2YS04ZGNlLWYzOGIwNDBmZGI1ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFiODdiNmQtMTc2\nOS00Yzk1LTk0MWQtMjM0Nzc3MzJmNTg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP/602fzj3wi87OzXcVEGR3rcYvv1mFxd1H18TyRsoRYv7GvNPwyQZym54e0g\nRRJqN9VOX+ccfX8pfl1XW4M+HaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9rSnW2+YfRP4ptJypIWzqhZg53YwHwYDVR0j\nBBgwFoAUVYgCvZKOQVFjHizwW9SV5vMHeWswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCaDDSxikivAoNC8rzSIn612TA9\n+BHoEKGj60uNkz8p1wIhAOx7HMw6+ziB/Fq0P8N+8BaKUEsUBVVxGZ6ghYN7hl11\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYPlaj0hHtpCmMsGllhwYehfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMjllYzc0Zi1iNDZhLTQ1NmEtOGRjZS1mMzhiMDQwZmRiNWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxzODU6ffgzsHfuJoNzBZWndVw5/BFUNdnE3uTfip4FSq4\nzpD0JkXwo7uyUUJXRVuo/oxBmhg6DaQS9fKOWBKPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVYgCvZKOQVFjHizwW9SV5vMH\neWswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALVNyaDfXhH7Gu02O/PPebzmMEN0S80Js5sYLDtkiBKnAiAIqnul2kuH\n1OsTlS/OHb8p141Z9+WNCxQ+IXeBqDt5/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAYpBMgciXAtLBhN//PuqLeL3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFiODdiNmQtMTc2OS00Yzk1LTk0MWQtMjM0Nzc3MzJmNTg4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTk4MzBmNGQtZDRkZi00M2I3LTg4MDUtZDdhNDA0ODVm\nOTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfNg4snyMrSYfUgfCRu4uXfQX\ncpghSOXR12FqSbflGi2s+OjNXytWCwAGxFHyp4Avcdz8LDS/oUUGtrRNgO/i/qOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT2tKdbb5h9E/im0nKkhbOqFmDndjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22IImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgLdPQj7fN2RYlYshtsb9Wion+MFVk\n9frNZYpxV3PMUjQCIQDptHUNyk7GzFxY2aKfxuaXlKK5nq1oJTSuGs/YrQKf1w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9188", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9188` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAdK1bn1Lgf6CEDBEuXbn/s+LMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU5NTg3NjEwLTRhYzMtNDNjZi04YzlmLTkwYWM3YzE4ZjVkZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJhOTNjNTUtMTU5\nMy00ODFmLWIyYWQtMGEwMzkzMDY1ZjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM/TnMyWGVl2/96DRt4W1+SBWNFctkoeO0HK9luHT0dogJLy/CJH6jrlIYClw\n3tmtnS8j4iOrfBX25vs95vKp+aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRkDcoeo/9BWFBAVsjZN3JbZ6z+2TAfBgNVHSME\nGDAWgBQRqpYWJuJ9kd1Cn8eOFxZg9/FqNTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCPjGGmws0d1Q0VnXwP1IFoGQ7eVvXm\nRKfXWF59gRJr2wIhALRj4iwgnGOGHhdPJAul2J4SnotO7+O2pT7tcIQ95ijF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ5oCRn2KZStdbym/OcY0PpxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOTU4NzYxMC00YWMzLTQzY2YtOGM5Zi05MGFjN2MxOGY1ZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARbDioDYu5ogWGkTC/Z17rcsWdkTQFI9xDm2jOmwiihC37J\nrN7/W736JhDGg2t6fR8D16gOd+gUgVcjdcRgL9rdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEaqWFibifZHdQp/HjhcWYPfx\najUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKJHOl6jheCKjHuFQ9+oxFlFFA0GMEeqImiL3ypD+yr6AiBxHF+XDsLE\nM0NLEodWlomU/GWN3bBwXy8HW9fuxBxuTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAWi8bFDw977wvA34/JXsSHR7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJhOTNjNTUtMTU5My00ODFmLWIyYWQtMGEwMzkzMDY1ZjRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDlkMmZhZTctZjI0MC00MzkzLThmMGUtODIxNzk1OWJm\nZDdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEole/2Sd88rlMxMm5/054KMwh\nwZPcd+MZFY+nRFZJpSzbJ/Qv+3gbjRx0xzHVafDRyTEds/af0GO0eyFneZljTaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRkDcoeo/9BWFBAVsjZN3JbZ6z+2TA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22IImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgf3csE2Sg2kxgMGq3ErDnrsP2AaKW\n2F221MaCWXH0s/8CIBqF2EykL7qp/oh9D4aefLvsBtNZRuuFI0Lbrk6xdrwq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9189", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9189` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATqo5tSN6mg8wlTSeYhdAJ5eMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMwYWIwMjIxLTk0MDItNGM4MC1iYzYwLWQ3ZGY1NGExMjVmODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVjNTc5Y2QtMTA5\nZi00Y2JjLTkzYjEtNGZkZjQ1MmJhNjg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENHKeM/iFgGh2W3RHWAYHwW8aHyvz1a4JKijR+QElzwWjM5i5TN2nQfHPGfB4\nAC7SwiNxVvBAaVfDWb9vlFsE1qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbOWAF9RWGTfY/v74a1wrQCcZLFUwHwYDVR0j\nBBgwFoAUdl/7Ma9F1vv1ZbhMn6Zf+B72QoIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDPk7eJnGQDaA67XFsX0iNR4sGe\nYz4J3MbkPW0K4jDxbgIgIq0yEGyuqVDUUPuXhn4v04KWDHth2mLgthUleIm778s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASjxPXDM9NYRkmNPH9dnD17gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMGFiMDIyMS05NDAyLTRjODAtYmM2MC1kN2RmNTRhMTI1ZjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARw6MNsu355G6qkCNQ44Rg+141nQxmMqehKpE3/Z5pLod5Y\neD4Gyfl9H1wm5QdcCumT/lrmxqmtxOeMKXkhe+a9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdl/7Ma9F1vv1ZbhMn6Zf+B72\nQoIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANpm0pJvg83em8mq7bCfal1ZwqulCAAuBnwnTkDvEz/AAiBSPNOWib8W\n4xdSTSebqYaDf3lOWqU41jRhtPfRSh5qSQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAUK/fjneXWU5ismc8CPgLWPmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVjNTc5Y2QtMTA5Zi00Y2JjLTkzYjEtNGZkZjQ1MmJhNjg3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzU5N2I1ODItYjE5My00NzgwLWI3ZTItYjAwOTFjMWRk\nMDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8fR5BoNxRTT8DjKy2nDK+0+z\noiJF/H5BIz1C7xDO7aO6EYowerNknQenfQ9MX6qBtT3aO/135B3bGGZ3GLC48qOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRs5YAX1FYZN9j+/vhrXCtAJxksVTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22JImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALtWQSWawhF89jQsYW515IkeU0Z0\nJFIkbcZr6uTwY+1IAiBIZscxKMnH8uYr201l0qwWnus8TjClW+YFmjnK7qeaSg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9190", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9190` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAe75wKtQ/SnKUgVAG/63VFR0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYTRmZTlhLTg4YjgtNDdmMS05N2UwLTcxNmRkZDBmNmQxNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2NhYjFkYmUtNWFi\nMy00ODgyLWI5ODctOWZjNzUzMGUzZTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENd7l/o2YXVoAaPHp+HVA8jkutIPnP+y/IcyjyFTGC1R1I3skEioXHle4501O\nhXcEWZ9Z+xPy8WW8G6SUKbYPA6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQyesy3/pnQHBAtVQ8FRzQpW4BECzAfBgNVHSME\nGDAWgBTwS1ni5AZ3+gENGtaTHC0dF15F6zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHG9hFx84qL/cTVMSUHBL5Vr3xn+vsfb\nvD1D06aP6NevAiBRFx6+9PFHceFxauf7qU74g4KERtvA9aXj2ho4YSX9eA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU3TYf9ZGAIgd0Yyxho5eiDEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2E0ZmU5YS04OGI4LTQ3ZjEtOTdlMC03MTZkZGQwZjZkMTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARA+uJTI8o22yp+bPgHYXAKPju+rHWF5iXVj99wJwGWpEfz\nyHPdrQI/56u3plxvI2VsoRNfkxWCDsFnwsasDv/io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8EtZ4uQGd/oBDRrWkxwtHRde\nReswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALohc/y9ZJoYts7hfmkcHydK8ZZchhZoouZILiVTRQaJAiBCQ3M0wGun\ntD7pV9ut8CGF42TR3wWa7CgCND/JZRnSCQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAQR6c+pQi3FCPCkzeQDWUBNQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2NhYjFkYmUtNWFiMy00ODgyLWI5ODctOWZjNzUzMGUzZTFiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDMzOGQ4MGQtMTYwYi00ZjY0LThkYjUtMDVkNjQ0MzBh\nMjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfkw+8Gg3dWG6D4x24MlXfatn\n9REtHDvWk0kQasm4BoMLeGi4F3dP6V0Nlbb9lswC5HuctZF3lgUKmQS4KVbZQqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQyesy3/pnQHBAtVQ8FRzQpW4BECzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22JImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgRjb5iHfWOn2ZsEG8tL5YzMvQEnCt\naQukEPu7y49laj0CIAsBw66u0IIh77AbVBxS3T0cSrL6CLCswhtLKIhYUuRA\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9191", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9191` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAawzjimt7lIvwkqaJX1YoXKnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI3Y2RhOTc2LTI1M2EtNGIzMS05MTM4LTY3ZDlhODg3YWM2MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTgzM2YyMGEtMzdj\nMC00YmQ0LWE5YmQtYTlhNmQwMjU0YTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsl5Ja91kCuoZX0X6YiR3r4NQBXwZofrW9KKprAkqgv+yi7BxllEwqu9BTxW+\nTBivIROvgA6Kooi/spni3/0ABqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiWK2U/k+/dwy3iStRBzMzFNWlTgwHwYDVR0j\nBBgwFoAUfzBTty6xBiIyFkxLEXRgMestOLcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICeNudGbBBA1mrDNuiaGmxI5KX0g\nXRwUDhhjOvaXdfM0AiEApnHCwsQcDLwSMLkSgkgSxO7blTtRMzMqfltyZ/frBec=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX/7COdZNuNiJj1oXi3d4ZYJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nN2NkYTk3Ni0yNTNhLTRiMzEtOTEzOC02N2Q5YTg4N2FjNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu3iqRdsvMuRfMVUv7/RwLBL8c7FRzn7IUoGBhiySWYYsZ\nVCII19V+8SA+gtomfyPGq1u+Gy72iYvXuLU7rCC5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfzBTty6xBiIyFkxLEXRgMest\nOLcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCi7fEkIH7pNt4Y7JQUTaudiGGo1f26lhPTLiLSMjbUwCIBAAUo64fYBW\nxOQQCbZVXSIBTniehjaiIMzx6epMKh6i\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAW8ptEjLrFWjt7hHePCFuLaEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTgzM2YyMGEtMzdjMC00YmQ0LWE5YmQtYTlhNmQwMjU0YTJkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzk0NzkyODUtOTA5NC00YTIxLTgzOGQtMjZhY2FkNTli\nMWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAET0WZzHzNfsia/V7DLLD1jBWt\nxAw971TfPjkzwNWQIv/5ygdyHtFgcDruY2kaoWtxD6LKzfknuBMK1NNiv9Zx4qOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSJYrZT+T793DLeJK1EHMzMU1aVODA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22KImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgIQ6crmGYB7Kf2Y3dTfqw7ld6hdTp\nTszxEe/ZMjec9GYCIQCrNr8Am0TZXDx2mJInlkDpOr4EfeGupVt9peHMPBYgeg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9192", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9192` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAb8d9O0C1KSCOfPOXoo4RrlzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJlN2ZlM2NjLThlYmUtNDI1ZS1iZTMyLTE4YWI2OTU0MDZlNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGU3NjMwZjEtY2Q5\nMS00ZDg4LWJkYWYtMWIyN2E0MDA0NWZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEY5P8vM7NNGIAU0GZxICq0idhbP3U0kpwDZENOEO0EdAorMyRUOUbDD1WjyhS\n+wqumgZRjUG0Egu2c3RH69con6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSNimiVy9f2Tyl0bw6FgjBHn3Gg9jAfBgNVHSME\nGDAWgBTvDdkFQBtrAFFgB5ePKGp/9jAHDTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCBNAu08AeefMQHQ0whldp2hApkc63Q\nw2xCsqNA3aRD9QIgXDyB6TH98FDsfKI1AwccXfxhmF49I1ux//hlSCS0tJ4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUpuWk5agMjgWft5bTf23m9XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nZTdmZTNjYy04ZWJlLTQyNWUtYmUzMi0xOGFiNjk1NDA2ZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7frBP2zmInOK11LwW36sj94LhMlEd2KHuEmWQsM99MsWG\nxHe92LGjIgNSQRIqXSNNCtZ5uzWnvSPxb+Wg37h3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7w3ZBUAbawBRYAeXjyhqf/Yw\nBw0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgetKAvT75sS6DjACV9oRwqP1c6HY6dQVRO93rsPms/KYCIQC60E0C2ejR\nKuZglgRs3/JSVIQXqnZl7s8W0AMD1tRcAQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAROA8VzaopK/NyLDVHQNsrFXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGU3NjMwZjEtY2Q5MS00ZDg4LWJkYWYtMWIyN2E0MDA0NWZjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjU5NzM4YTMtNmJmOC00ZWQxLThkNTQtOTljN2ZkMzlh\nMmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKA9CVN7DI7hCY7L7zTVhiwUD\nFZ4FOY0La9gNaYjhf31R7dIJQQ3xhtoX35XCtGs6qXeCSOu4+XtDlMw5GgOJbKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSNimiVy9f2Tyl0bw6FgjBHn3Gg9jA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22KImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgaHE7XKqHK6VkgI0nPX/5OvzDHz/3\n4jQB3mwH49W308sCIA6NKT9xrRrCd5KqWTIMQJ1ij4nus3Uyy76mmeGIHhbO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9193", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9193` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAW5dm4UsvdSKvQ1vqQvpdKE3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE4YzBlZmJhLTM2NjItNDdhYS1hNmI0LTQ2YmE0MjBjMzY1NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGNhNTUxMTEtNWJh\nZi00MjYyLWJjOTQtNDYzYmQ0MzZjZTFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYEY7KS5TkfA6+FS/CL4LOQ82WYS60G8NrhJXkTUR+s8wWogQEhyt9Dw+94u7\n1TUipVc9XpReqrimpeg2fCbUVqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfV5fdil423tE7mHU3hNpq6XfE70wHwYDVR0j\nBBgwFoAUBXeqT1YVlPF+xm9NbybeX/pb7S4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCHAtJbAYDDZk9MVwBjbEm1IwQE\nqZj/qWMrrw2IVyFb4AIhALXh/Y/MiEU6K4e5kQVVNUhorsOLxcPDFfcVpVb7Ocvt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAR1qVVpa1LNG7kAeZO4jw2IsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOGMwZWZiYS0zNjYyLTQ3YWEtYTZiNC00NmJhNDIwYzM2NTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStAK7S5bGVcDETrsUwRsVRJ0+PUo8TYOztQlefG4gZljlb\nL/g3A5E3Yf+CO62pjF/o26hZQFC8rxDJ+JaKPKK+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBXeqT1YVlPF+xm9NbybeX/pb\n7S4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMa0KUq5bTIvDgNd7SVWHmbiGxVtmoIJoMA6zUD1tsbdAiBGx0W5I29d\nLSe31Wmcff3HMm0ZWs1bcusNjRtOLyOeNg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAagfBNhf5tpqxxSi3CIok4niMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGNhNTUxMTEtNWJhZi00MjYyLWJjOTQtNDYzYmQ0MzZjZTFhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWE0ZmEyNDAtNjM4ZC00M2E2LThhMjktZDI4MTk1MTE3\nMzgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEln4feq+YBTcacTh+jtYcbR2Q\nwvsJhSVTKZpb4sb9L3mWg5inVNl8mE/mnxYtkB8NylehO+ogiW+KyBmRsHKlC6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR9Xl92KXjbe0TuYdTeE2mrpd8TvTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22LImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAME1lo+ZxsS07zp86U50zVMF5RxS\nQ/MpcjfW7zUYOGdeAiAUGnpu4RNn12bQJoyq7VJcha6pEwSnkPxfimdOZggwZQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9194", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9194` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQGuVLgAICvyHcVhvvbbRrKeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzYmY2NTkzLTJiM2YtNGJmZC1iNTUzLTZlZDdhMmMxZTFlMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzJmYWIzMTAtNzU2\nZC00MjM3LWEzNTMtM2QyMTE3ODYzNTQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqMXQhFW5VzlfFGSuECKz6KdEJfcM9MnQi19Eoy8emmT3MGHpSqItCYSKeRfp\nv6g+N9w89O05Sev2sW4QbPyr5aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQUJYbeqFKxBNFBuDnnlgUhpB/z0TAfBgNVHSME\nGDAWgBSwC/PCzfM2424r0nXxkn3zOWs8ZjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGuwKNNL5Ad8axnJiSAVfetl3enm0b3G\n2DN16UTegRaXAiEAgRcSarSX+9BhuQb4KiRd7KSFIS6s+/KQz78qT845Jzk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdS/4acwGZ5OrhNEkgbp00aFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nM2JmNjU5My0yYjNmLTRiZmQtYjU1My02ZWQ3YTJjMWUxZTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0fmOCn8pksNdViKoNWTB70tYlhuEnF0yaAJZHak2O795p\nnbzVbfpoiiFl2wKDkjp9S3ZmeF4NPG1g6xzOTrldo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsAvzws3zNuNuK9J18ZJ98zlr\nPGYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMq6P88s4vV+RpAFaxUCzrQ8PgdzrRgT7m8vPG4SwhJgCIADfgsBkDSdZ\n3IIQDaRpD7+irwJMjGaKnfwvjVTu6w0L\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAaZC+LDxgPNfBaG63B2eEyuyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzJmYWIzMTAtNzU2ZC00MjM3LWEzNTMtM2QyMTE3ODYzNTQwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTVmNjZkNzgtZjc3ZS00MmY0LThhMDQtOWY2M2IzMjJi\nZTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENKW9OtyfZjxqBjIP0C0mcGwA\nEzWOnBrvRHY/C1OcUCxWYiYaYHHEkUIMHR+AxNo/oByZp9oA78x6iYIeQ2/gaqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQUJYbeqFKxBNFBuDnnlgUhpB/z0TA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22LImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAL/yjFwxPH7tVz1QguLrJ7c+GJhC\nk+qKrJ7F7I3ePV8hAiEA5UZBT7G/1q4P/cPqrx6Yw15qfJlbuagG4hJe3b0WGmY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9195", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9195` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAcEWIkFsVl8p2o+FM2SdQY6OMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhlNjI4NjJhLTNkZjItNDUyNS1hYWNhLWZkNTlmYzUwNDAwMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWUyYTAzZjgtY2Y0\nZS00ZWZiLWFlNjMtNmRkZDRiNjA1N2ViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENdVk9Yj7eEaKDBdZBu4izUVjETfo+CY5gAZcqJ1oI++9pOm/FexH9W+k1ihV\nWlhgM0YO6nF66mGl+p4s2uzrC6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0gw54wtii5mNJ8E9SMJ5l+y5xbwwHwYDVR0j\nBBgwFoAUDaixOfIFak0P9qe9qAMQuBRndW0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDWh2KGZ3AuTfhiI2sj8K/lgzug\nE4BuQWnFcOSKVpj8ywIhAPNiZBOG3zCI4f5dtVs/eKJPGwuLLmKgaC3xXvzLiF2E\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWWR3l79ofSmd0Dk/dqe0PpTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZTYyODYyYS0zZGYyLTQ1MjUtYWFjYS1mZDU5ZmM1MDQwMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASUqTlcLXPstR5/uA440QIlW5G9A0OEj4XNc9qUSVCuulV4\nVW3ADm6A9OlsbIjpZIldPK7Hww99ArTJ7caHhojNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDaixOfIFak0P9qe9qAMQuBRn\ndW0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJzaC03/+2CS8m63LE6gT3n1iFNprg2uzQr80Q2pZwnaAiEAifRXVrnq\nREhdfTXRnFzzb9SD66KV7G0suCH+CPeQzMI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAZKASDDOYeQnCnhbaIvDw8MLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWUyYTAzZjgtY2Y0ZS00ZWZiLWFlNjMtNmRkZDRiNjA1N2ViMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTc5OTUzMDYtNzMxOC00NjgwLWJkNWMtYmU3ZWU3YmY4\nZmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFgkhIGZZ5hPOGASRxbqoQAOq\nnnA6whQJ1f5QbYaxv8XjxW9lOZgVDTSMMz6j+SET7eCxq4PiOGRxGqEP8Mu1qqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTSDDnjC2KLmY0nwT1IwnmX7LnFvDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22MImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgXoMADFCOIwN3IfAbexEPgeOUQfpC\n4qUzW1sDN7UVfVcCIQDFp5YZrWymvw/IzFjepWw0FcCAoYRaxbQ6npaxGMIhiw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9196", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9196` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISATKstRvWciU38gpxAYuuDhRfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0NmJkODQ5LThmMDQtNGYzZS04MDhmLWMxZjQ5MDRlNDIwZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWNjYzc2ZWMtN2E4\nNC00NTczLWI1NjQtNzJmMDQyNmYyNDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEUFWKxPhLeVf2J+r9JGp5LBJiscwfbFlwbAtLfZW7o2dnCikJ+c82rpiTdn3\nZqCT8PE9Xwtrg4CEOah9v/p75qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTXK3Ot4SDWuQ04nJVMTab4c7BjojAfBgNVHSME\nGDAWgBRCxnBYKpK+U97LxLfMZ+nURliQiTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAd21rUdV48HbbZH7+ipyni4MOH2w0Ha\nI4X+iCp9xgNVAiEA8K7guAtbrPDzD16RAppFWJggHyaohx3EuVzu8G1+29I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdB+C8HrZVEsSRTqd1DGb0g3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDZiZDg0OS04ZjA0LTRmM2UtODA4Zi1jMWY0OTA0ZTQyMGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ6Cr2VpP2QW2k6Pfb0PmM1Ba1xLHrQdd8vilmJVJ8ybCu4\nu8ApnNTh4rVxL1iXTPIvqyKlOzb3meaFxPIIzDfEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQsZwWCqSvlPey8S3zGfp1EZY\nkIkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCMwRT7GIGs5zU3LNSUz/RxWKE4sZEHFQN4IjdM4PdvgCIQCZMd9kfvMU\nJsfwJCNZ6ipoUF15cWGqNHiqkKq5P3it5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAWdOdAD48oAMbL7Jn/uqR9ilMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWNjYzc2ZWMtN2E4NC00NTczLWI1NjQtNzJmMDQyNmYyNDM1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTA5ZGRjZjgtMGI0YS00YWNjLThiMWUtYjdhNzMxOGVh\nNjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsrDCzx0SRo0HP53SI0O1GhuT\nmiBllrjrBbNM8jYyl+De8CEyEfVLeq506awGUxMuEVRb0Pg17b3t6MCq0QAfR6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTXK3Ot4SDWuQ04nJVMTab4c7BjojA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22MImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgaBHQPiV18esgd2o5QU+pYEBzfIHX\n2z8sXsig8jqcP1ICIQDEnkmZsGqfF74g3LQu3Jp1YWJmFTEE9sihJ9iOUqPA4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9197", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9197` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAT5YiIhoHgmjCYiDybcG2duJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkZTQ4Y2Q0LWMwZTktNGRjMy1iYzk0LWM5MzIxZDg2NmEzZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWY4OTdlNzMtN2U3\nMC00OTA1LTljZjQtNzFkNmQ1Y2RkOWY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYwrlpnJ2LVk1JOwjp6vrneg9XreAwcOFcAEL/nlTpoAFPFD5L7iOpgiX1AxM\nlnMMj+HZSr0gXmAOkSUZ3wR1p6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUT/2h70DLjv2tEqMzxTxM7EpwKpMwHwYDVR0j\nBBgwFoAUfaPSjSWhPyuc0AWXqNrWzxVI2M8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCNW8lSyfMwljaRlt52Y+g1nhrq\ntvSRUJ0B3VGt8GCn9QIhAOO3Kv+V9siaa+idT6tCf5zUNV168FZlomEzqMThK+ED\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVOQan/oTnNbTNZw68CV5oqoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGU0OGNkNC1jMGU5LTRkYzMtYmM5NC1jOTMyMWQ4NjZhM2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkcOuykntybTTOdCOGul4F/I73XsmFuaZRl8p9ZS97/O36\nhb4nIJCF1izZBRZWF83y/oOOHtvc8gNtGaGeUAtCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfaPSjSWhPyuc0AWXqNrWzxVI\n2M8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVZBPFQ2qPD1WW9jZnxhYg/BH89IMvcqTPZftAqfBrcoCIQD3PjTTSi1J\nyBJ3vcbReXHDvIsDgXqkAt/hD0jvK2lOLA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAVucVBkpvx5f2RVka2/03r8eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWY4OTdlNzMtN2U3MC00OTA1LTljZjQtNzFkNmQ1Y2RkOWY5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGIyNzc3ZGMtYjA5Yi00M2NjLTk1MDQtNjk5MGVmZWZk\nNTI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr7vjyDOHfnujZx9yfpVdZBCQ\nikoQRigF5gePYLFDtQJF44uRymoRNlfmoXjWtORTGOKdOevCiP9pPJvB99wwrqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRP/aHvQMuO/a0SozPFPEzsSnAqkzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22NImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPqdMj3uuyrpp2UrRKvznWhXfsmF\nMGJOKw3GrcXpOhFUAiEA76yr1zOtQ6ihQgqUdOUXpGo8Nol/jEd3gsIT1wl0lUI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9198", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9198` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQvpuc8UYWToQa4Z5YcKy4M4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYyY2Y1MGY5LTcwYzQtNDUyNi04MDU2LTVjYmI3MGY1OGY3MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzZmZjkyYWEtZWRh\nZC00N2Y4LWI3NDMtOWNlMWMzNTg2ZTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEPGM5m+BSW6Z5u6eyZlMp8o/J+7l5vltjWErnAE4BPh5/rfI+bYKBGp/7iU0\nFB9AdhjOqaBP7x/poLr2GuAmrqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSpJe0zC139W8ZnoIO/ak16/x4GTzAfBgNVHSME\nGDAWgBRtN3E7jhGQpc5gedRkjCBzdIVLqzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDoXQB1x5/fH473Lk6RMNVSO2M6Umx63\nB3xqofwgmVYxAiEA2e+OskkBWaf6mqW70/0P/wnw5UEYwN6E2VnvbxLxonc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASom/yqngL+gXYLsilfKDl/+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMmNmNTBmOS03MGM0LTQ1MjYtODA1Ni01Y2JiNzBmNThmNzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWoUBh6MoYMDwGUEHnLr7kF8zzFwcaoinCPeSIxmNa18yp\nvGE2hsqNHVHqsgjEJNIp0lkiOVd1xCR9zdvqELISo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbTdxO44RkKXOYHnUZIwgc3SF\nS6swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS+A970WeIZlUerT/sh5he89a70Z8gwsBNul5zKpuiZYCIQD4SOnmXnlw\n++p0XDgEHDsCI0WXZdu8yohJP3FQATc1uw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISATc7Evq9RvaX7GhZlfa0KQzPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzZmZjkyYWEtZWRhZC00N2Y4LWI3NDMtOWNlMWMzNTg2ZTJkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDk0ZjUyY2MtNmFiNy00ODg4LTg2NDItNmNkNTM0NmVk\nMmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEEKH61YCcifakT15oOe+Ucdu\nM5xnLEOAgwpWtt4fnubF9oIiv7aP/LKe90xHxaBRZSy+hMGSUiZB4hyJCRUE5qOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSpJe0zC139W8ZnoIO/ak16/x4GTzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22NImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAL6ZSvNN+LEmXR/ht/fW5ZzbSMhe\nFScIBOwc5jdqKIg9AiEA+CV1Ao3Icohnrqlj4wC5xfIMx09p7HmI5wmnpAM/gsQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9199", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9199` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdrVh8WmFw/TNEPZ+7S+1ANGMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ4NTg2MTdjLTY3NGItNDk1My1iZGE4LTdlZDA4MzhmN2Y5ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjcwZGI0NTktNjQz\nZC00Yjg5LTk4MTEtZGUxM2JkODViZWE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElwpjhABluySr6gRrviQ6YurIJcaIUaE6Li7ZHJhKutaceaUyGxdwP4f5HfHq\nfS1B8nzPsUcxLJWmgEMtGjxw16OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBLYBz+qMMpYcV+s+605ylUVGX7IwHwYDVR0j\nBBgwFoAUJPuWa3tyMNw0Qs04ts9dr/fB/+8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEI/OMe1z3+FugRCY/RRdg0RD479\nlrheLDs3670fHAonAiEAmjDUi+9WSQdJqDLqmykoCd1J0hvzoTSJSQyCaFO820w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUnjdyTlp2CDJh6IxiF1RYaGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nODU4NjE3Yy02NzRiLTQ5NTMtYmRhOC03ZWQwODM4ZjdmOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARxP3CeRlhMCvqDXNdYi95qVU42FkP+aH2KCfSvbyqNiK0P\nUe7N/ulKuBhUc7QCTEFrNpZ4a5qvnhHrsQ2+L+Rgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJPuWa3tyMNw0Qs04ts9dr/fB\n/+8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdQ1gi4+eI9Na7E7ITZ5cMEfiOtLUeAJk5elBJwrzWYICIQCIIouezmzp\nNhfhqcSklaekbqdt7eAATLWKT+677BH9yg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISATgCYHx2MEBSllrwA9WotPT4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjcwZGI0NTktNjQzZC00Yjg5LTk4MTEtZGUxM2JkODViZWE0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODk1MTY0ZmUtOTJiNC00OTJlLTgxYWMtZTg2MDgwNzk2\nMDhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAzBWGi6H5VkAO6QlTL1H7RKa\nvjiRyqTXeicjpa8vDrTGEvgnC/MHOwb3ZgBex17KfnJrV7ttCiFqjyJORmzdSqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQEtgHP6owylhxX6z7rTnKVRUZfsjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22OImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMRI3g20KlrdECgVHMQTp0QgGA9H\nTX9By/Bq26UdkW6QAiEA4QJdllJztexqe/mUCllagpiV54V93ntrBRQ35fCRU6k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9200", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9200` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYKLX1jjwdn+SLzXY4aLhA+sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmZTI5ZjIxLTE3ZGUtNDhjZS05OWU4LWVjYmY5ZjBlM2YxNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y2NzMyZGItMjFk\nNi00YzgxLWExYjAtOWQ2NmUwYjdhNzBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExECYa7gLTpAOpKguuLqUgp7if1qLaUj+0qUPQS+eXjprFdIuzo6lS7pieCbO\njLUETfKLXDgaHElcJ9E7tGgFCaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ7yXtLyhk1rvBz+FARKRe2D//+iDAfBgNVHSME\nGDAWgBRkPGTsNLB239Psn6eGCagaLOqIgDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEvjxgJvKBmJmGBgAUOziBot12JphjwP\nXo969FD3fX3wAiEAzipzFdDDI2Ou35xS0U9clOn9tHNLhY6XateiZORprWg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAVEgjCwrMPTQDhM8xr8CDxbOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZmUyOWYyMS0xN2RlLTQ4Y2UtOTllOC1lY2JmOWYwZTNmMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrQbjeZBiJIJ86cxie6+4BBwWaQh1PnJrQnARTsJ7ivv9p\nPiyzqv7FzXe+K4JjsjAsMHaupOT4PBsgDvqPitjco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZDxk7DSwdt/T7J+nhgmoGizq\niIAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJj+4dlhAU6ou8zyuhbdImZyXLT/q14dKAh9VnWvre6/AiEAsHs0YJmS\nBx6sT2Qe4f6ikeH7Z9QYWJj9nsCYMP9N/o0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAZdB7vdpvPKp9y0Fo9PFnF+CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y2NzMyZGItMjFkNi00YzgxLWExYjAtOWQ2NmUwYjdhNzBmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2Y0Njg3YzUtODAzMC00NTI0LTkxNDQtMjRhZDgwODc3\nNzFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5KXE8znV5m5/C51uOR3NclNH\nJVMO/Tb68JZUexqyCqhEiU6T0L21zm1mxOL3BptWWWw0iDuwZCQPB45V/HGMEqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ7yXtLyhk1rvBz+FARKRe2D//+iDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22OImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJipGiJgaDIACbwysRjY8SHyjSvJ\nGTuNw0GPOmzEweuSAiB2gvbCysYZ3S5uKGTv0d59Z3wVUCRTknIyVvQJGviRWw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9201", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9201` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWYM1ArLf1X3tPZSVbtmsrQmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ2YjYyM2Q1LWZjNjMtNDBiNi1iZDA1LTY4MWZlOTQ1YTE5YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY1ZTBiYWMtNGJm\nMy00M2Q3LWE5ZmQtYjY0NTM4MmIyYjA4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvgS6AFJZQe65GkqHwHWpKGzAfvTPwkDtz50Y9D74azGBRLZh+muvJd6Soonq\nlU2MLnWrhFCMea4N80rqCfvJTqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGjTj8CmX3v7ioc7B93jrMsddmgcwHwYDVR0j\nBBgwFoAUk/w6r+k6dzLKS6eLORotO4eX9LIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIF8tSDMTjt4Xkl9gTk43lCup+ksa\npeEXZKcMsqW8z8/4AiEA5pSLBGr1tAWnNsxU2YAY7Q4QX8jgB/ULyWSVBXffrCc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdjr+ky0oshLMn5pQ+/aLL9RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNmI2MjNkNS1mYzYzLTQwYjYtYmQwNS02ODFmZTk0NWExOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNDQoN1A65ZnZlD94eAOru54iQ6L82yOGbVGWh+6+U5l6j\nXR/zMEgk6AhXY71nmyxbQD7MJsYwRdMlcUIcgKg5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk/w6r+k6dzLKS6eLORotO4eX\n9LIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANh5uws9Y0ohYsoDWhLgwrc1Q6y/r5Hyn1lM0t/BBVqHAiA3LZa/0ms6\nkEOLEVTNQ5LHhoai2UGC8/GbaUsSmbVZhA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAcwkdGF5F0/xETzcsKk9h3FiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY1ZTBiYWMtNGJmMy00M2Q3LWE5ZmQtYjY0NTM4MmIyYjA4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWYxODJlZjYtYjk2ZC00ZDVkLWE1MmItYmEzY2Y5ZjYy\nNTY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuZesevlH4qw03hdFw/aMOB5C\nSD+hOjGsa03289AkKZcB7M+ZkxOgofxEQkwJP4u5JFs2P14kqoN/+CEgZblOd6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQaNOPwKZfe/uKhzsH3eOsyx12aBzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22PImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgDBHV1bIXqHS9V0995qsloxPk/fPe\nvZqt7fGvemW2BGYCIB7c4QIFLfGDdGyOWPm4ZzE7vdJHQV/yTO4/3puZ+54u\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9202", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9202` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISARyYE/G71oJLk+HwgAbOb8fHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmN2Q4N2ZiLTg1OTctNGUzNC1iZWZmLTEzMzA5YzNkZjA0MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRiNTRlNTEtZjFi\nYS00ODRlLTlhNTYtYmExNzU1YjdlNTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMiuB3imVmQPA75VFO+yJfqX0H6XgbZw9jVYK8hexuwgPDNPbA8ccQSbJAZ7X\nXMLMgpp5Nbt9TlGxAyXF5mRqbqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSI4GBE5Y4eV4Eim6DZe0AZNNiC6TAfBgNVHSME\nGDAWgBQIS5spYOZdGfP2Zwj9dPnt+IEiojAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBszXsORkw3lIhSSsNFd/siBCPGbPBeO\nQ4s3AWNKnoBzAiAmVLEL94a8mshiWnNYrK1HKFgM9B1dUbJp4+q2aS3Czw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV9Sfm3c8G6C/913Mh+8QrcvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjdkODdmYi04NTk3LTRlMzQtYmVmZi0xMzMwOWMzZGYwNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASG6N0Sf7wI6djON8DZxpV0xjP+6NBG0j9cInA3yEuH1M4j\nWL4QsfgnkiQsFgoVSpFO47ZEhJJPEP6hndpyMzuFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCEubKWDmXRnz9mcI/XT57fiB\nIqIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANtz4aCT34ptrSDSXCuFn9IY5fLPNpp3YhYDDdrurdwcAiEAoP8dF3tr\nK0CMHGcwqlC2Q7u9mGbOG/enmnqUeTcZyzI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAeKmm3HcAW6OXIxobfaHtqDXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRiNTRlNTEtZjFiYS00ODRlLTlhNTYtYmExNzU1YjdlNTU1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDEwZWUzNjMtODE2OC00NDU1LWFkNjItYjE4ODM0ZmE2\nMDhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERqh1agNz4T5JMsci/5cI6wBj\nt9/38b/yZfeR+DE+uQGWrvSotSK3OhOfjStDKZf8FBTlm1drSM80TBOyKwxyu6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSI4GBE5Y4eV4Eim6DZe0AZNNiC6TA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22PImJhZC5leGFtcGxlLmNvbSxETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgXEiBWvNGVQNE1AT+X4nuKkQGVsQ+\ntH/xUXjaB9OCB7MCIQC8BXGcUoMypcv1TVjtm0sJ8wrRx19xxMe4YQGKn7xPfg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9203", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9203` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQ4+mEtTILIbD97swyOKXs4aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgzODZmNGU2LTM5OWQtNDZjMy05NWYxLTAyN2Q2ZGMxMTBkMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2JhNTg2NDYtNjgw\nZi00NDFlLThhYzMtNDY3OTg4ODEwMTAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEx2a2nLWyw+JxNg95ggbmhUCvzmQXMWkOZNZUsJsYrUDEHisLi9ezSOU7t9N\nJ5LgIi+VquniCk1DzyJW/HUElKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEI7d8pNTE5jvNhxEm0zMCsSd7KowHwYDVR0j\nBBgwFoAU1QC/ytwDm7QD2+qzV/1yIQCtv7EwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD7a9mWCgt1efFuPLSaFpi01ZEZ\n4cE4Wi5tXDtql9qMVAIgbsg47B6UbSyPdas4l0MoOhHE6mItp+WegVk38HjX6nI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQZC7uUpx/J6fzYvZquyBTG1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMzg2ZjRlNi0zOTlkLTQ2YzMtOTVmMS0wMjdkNmRjMTEwZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwlE+GPn4BVbcCrmpGyTcNnYaZFEBJ739fFtZPeZ2m06IH\nY3yY9jhcX8Dc74iojjMo5Aybs89E2t740jNuCKsGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1QC/ytwDm7QD2+qzV/1yIQCt\nv7EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTB0Fi+yA7RqH95m5e80aqu2r8YEGR31PzuIHRLiN8jgCIQDsZa55acSj\nv8PcowLAwipMFuY6nwslH9FnFBJFrNNkAg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAcKcTaixKF3O/gMbaOUzOBZQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2JhNTg2NDYtNjgwZi00NDFlLThhYzMtNDY3OTg4ODEwMTAzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmY3NjhjNDctZjcyNi00YmIwLWIzZTgtYTVjODlkNjFm\nMDM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkT7dKV7/gpRwxfKd1GzO9PBb\nbblJlmS9vhC/GcVu3YMDLAX78k4iWMJD8TLS6Gm/j5s/OBR1cAiRgvPysz1mY6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQQjt3yk1MTmO82HESbTMwKxJ3sqjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22AKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDlMFDhOFCWruL6eOlq\nnlQr7QCboQRLGcM+rOyWQUaonAIhAIExeGZbFMvhN9fuE2LYcaHuRTFIAGm3EU+2\nAQXl97qk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9204", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9204` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYnThDot1jlYjbtwwxEn/EYKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI4MDZjODI5LTI1OWMtNGRkMi1hNmZmLTM4NDZkNjgwMGJlYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJiMmNmYWMtNTM1\nZC00ZDFjLThkYWMtNWMzMzIxNjkzZTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELaFIIZYoov6RdcqbsubqBqIFGTFswN8OD4W3tYCn4NJ1lhHTcgtNbCjRpVgo\n/QGT9vInsdPnfMOfAKfeEnT8aqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSr47I1g4UcKMtlho32mlnqm5XD9TAfBgNVHSME\nGDAWgBR4GaRz9+9nKfkwM0fDTPL3PWtTzzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDOVVAmZZrvWZrTs1EAUSrJO47nN8k2\nDLhjCrqsW7Hd6gIgaa6SuCTShNLpxAsBjJBqNICja4CEoZjX5wFgF9jfS+o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAep89DdB4VPUGzbQEbMhvnuZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nODA2YzgyOS0yNTljLTRkZDItYTZmZi0zODQ2ZDY4MDBiZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbREb4cCdcRIZI630y+6isDiKCQLX5h52S0G9hAp9HxFDG\nkaZuLZqHqzhMtF/0PcGMO8noReaqoCCtvGVifcxlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeBmkc/fvZyn5MDNHw0zy9z1r\nU88wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVh6alV3vXUqEyT08ftfu2ztWN749YM4LDKG0k1e1duYCIA9RF/jofBNZ\nO+SUhyOjibIe28Z3I/5zOS8WMcjAy+2m\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAdrmPJTKNJHYhO3WzxBh7VE4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJiMmNmYWMtNTM1ZC00ZDFjLThkYWMtNWMzMzIxNjkzZTE0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmJlYzU0YWEtMzAxMS00ZDIyLWFhOWQtZmRjYzhjYzQ3\nMDkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk6oOvTSFFtAvkqfu3RIIwBYP\ndi+xeNSznRHbdUWe1UDeYe1rBuC3z5pTZLJHVizsQt4dcciyk9JV6ksCeKMoYaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSr47I1g4UcKMtlho32mlnqm5XD9TBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22AKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBnqd6xKuHadHPW0JW/0\nKK+O3cP1xvbdfHhJILmJI7/5AiBIb4bwGIIYH/Chn/w3hBPLbrlC32kBxbh9Myea\nIXJ/VQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9205", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9205` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdPd096EwBnn9i+P+AZYw7t9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI1Y2I2Y2JkLTk0NGMtNGU0YS1iYzk0LTY4MTAxNDJmYmE5MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTVlN2E4ODQtM2Ew\nOC00OGQxLTkyMjAtZmVlMDc3ZmNmZjFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2i+N9UF8iCKwjDnS4muo53aQ4eAUEKcVgg3dKDHBAt7GCXu3CtYT6Z82DMjq\nTY6Nt25WmYnYoYkOBHdLxIoR2KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAk2vaHa2WwFoYWMYPqZujJbeXdcwHwYDVR0j\nBBgwFoAUVKYl+uXd4GWTHuloDKgVWe1nUvgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBrwtSCUXcVdbjQvNGSlXTOF2yNJ\nldVJdkQMXyBLvIgAAiEAtYYsWlGa0i5YN2gHM0tti4P0dZ9eZcX9hLVFW5QSBpo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc/DEqsNMPsXSBYSczn31/EEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNWNiNmNiZC05NDRjLTRlNGEtYmM5NC02ODEwMTQyZmJhOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwIy95WT3e2/0TkyYNkRk6PLcy0A1fm6TF9Kp/7nk7w9nr\n9pDCj/l+yAZfre6w0ukN0zrjqbdX5f/bA9LMAfdRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVKYl+uXd4GWTHuloDKgVWe1n\nUvgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEOeCzdhu4KEbK1vcld48EwKQSBMWox8IpUYhe7Uc4/4CIESO4XB3b+wr\ngErqJP6TpFiGbLr0WeMxZlGAprbDxBZN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAbn1KY5IoFvsNv9hx/WN9yXrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTVlN2E4ODQtM2EwOC00OGQxLTkyMjAtZmVlMDc3ZmNmZjFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjJjNmRjZGUtY2E2NC00MzQwLTkzMTAtMzJiYWI0ZGYz\nMjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsZkWsBZGGz/1gbQJs1kaZlNR\nNSIht6O5E72MY1GVdF2Rf4zaD6Tg40DHXIBR25tB5gtn2Vft0BWRboI3Y4gjSaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQCTa9odrZbAWhhYxg+pm6Mlt5d1zBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22BKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEeiGygor2GJGYh/sQ3i\nYXKzWYTWkkSupSkLpHgcHURdAiBJc9ptcOD4dfgqTG2bsed956v6F3+WhaLaGtfV\n/2Jd8Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9206", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9206` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdmyVwqf8xbbDidoMFcpWDtnMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViNzM5NTZlLWNiNjgtNDE1My04OTQwLWUxNjk0ZDc2MDk2MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk1OTExZmQtNDky\nNy00ZDFkLTg0MWUtYWUzNzJkNzJiZmJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEG55qLLvsyKEH5B5Bt6QfbOCzxzvbTUBsdgJN+iZRFwXErunQw0H27xLmNTJh\nmk877SO5+Ry3V3xbiSKU8bZhxaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRse9agwPBiCzBNsGOISXE9INLyeTAfBgNVHSME\nGDAWgBQaqHpjqJJ6d5SLg+wpW5rUrF1v5zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBEhgoD9gkFcTy2grYQRGugDmU+2YM0k\nEdPnevlA/bbgAiEAxOg1M+SgA2j1yTkz+oxtHZq64tr7F2l1ydMDl6pE33w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXj4tylEju3Pi6184hTYEko5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjczOTU2ZS1jYjY4LTQxNTMtODk0MC1lMTY5NGQ3NjA5NjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATaGVcFt9HBecUw/wwYw0RBOUAHVaxlWaVeqifIwcpjr+mM\n8hzUywQ6ge9q1tmLe9cy3cYVOItUDlMxzMogehvxo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGqh6Y6iSeneUi4PsKVua1Kxd\nb+cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKIeyL1bgl41SAyVQZajj0W2NR5U6h1Ch1o347xd7q70CIQDwcEi/X+08\nPDg5hy3Pts5Ttfo6/FXvZKyP44EJon/OWg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISActulb84ijcOsXoLzSTs1BuUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk1OTExZmQtNDkyNy00ZDFkLTg0MWUtYWUzNzJkNzJiZmJkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTZiMGNhOGItOTBjZi00YmY4LWFkN2MtNGMyYTdiZWY5\nYjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEonUmw+tTnYTPlhz1lRfo6RVJ\nprtTHWYCdmTnGrxxkjqBjnRem0Y7QYqVpktRx3hPx0JUVp8/QAGjG0+Pq9+fdaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRse9agwPBiCzBNsGOISXE9INLyeTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22BKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBLHTFOPeFtROX9Ix0NQ\nsM+8oJOh4wL+wX8DsR0e79N1AiBSS20TMKReF62we9NmQheZ9xQh5AKmDcG1QC6K\nys33Lg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9207", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9207` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAZU9cD6R8sVcsH8h4X5cz5HeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3ZWFmNDhlLTU3NGItNGI5OC1hNzkwLTAxNTlhZjlmYmJmNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTE3ZTk5OWEtNzQ3\nZi00ODY2LTgxMmItZjcxYzQ2NzIzZWY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExnedxyQeN0+9MtuuiTMdpucPUttKiN02eOVNJrM9Fbq7pF0gWVeYJSGC3wDg\nGZSvNysw7mGj39GEaEphfWqLpaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiWr+40u2RrEgrQzF6lypZMtTfFQwHwYDVR0j\nBBgwFoAUumaLXwgM/dEJRV9GN9xl3xKUjWMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCVUtsPnlX9RdLCkZlLuutcyVlY\nDA7sVh99R8qQm43gogIgWEQZDmPLISmJEHxSG/z/jFyTAbiTgqhjIqSO/DjfvFs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUpZtGJTENQmIY1uFmTbajbAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nN2VhZjQ4ZS01NzRiLTRiOTgtYTc5MC0wMTU5YWY5ZmJiZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ864SMsnyoONSWDTfUkcFac+SISS/mqKHc4h0VSoCrFZ2i\n+zlSVDSWfrA7MIAGgbCeKCeLOXAbfEUfX5hkf5q+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUumaLXwgM/dEJRV9GN9xl3xKU\njWMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM65muA63TgOBraO7hi3n+UIGfUDZGHFpII63hT3K0NAAiBvUDji22rK\nzysS1SLBjzUNWpPiBh5RyNcOcw1MRCdvIg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAUk2gL+sVgeaXYwXLJJkC4pBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTE3ZTk5OWEtNzQ3Zi00ODY2LTgxMmItZjcxYzQ2NzIzZWY0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjI2NDBmY2ItYTRhMy00NzhlLWIzOTEtMDQ4MmM4MjQ5\nZTczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXDKg90qWc4plEPyExpZuLAkw\nv6gPOIE7Pu6N5V7+UPsfdxIi06EA+iSYojS9J5Sam1t3yr8AwGxo+40qLh1czqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSJav7jS7ZGsSCtDMXqXKlky1N8VDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22CKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFKn1iJdmhowrjRez4z8\nsZfapEoisrLtH1kCiOhCCD3MAiEAzjkdrMfP5S7ZnHCOFSUfQgWd3sc4IRQq6i6g\nF76s+18=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9208", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9208` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcLJDehmdoq3CCXItg9dD3+aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVlNGZkMDk1LWYyZTMtNGUyZi04N2JjLTJjZGIyMmYyOTZlYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2U3OTg5MjItODA2\nMy00MDIwLTg1MTQtNmJjM2YzZmI5ZWVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmMWnMviNcJBYYGECOQ9g4ynduEVvAGakwqw0HmQ/iQsN1aH6USWanGvI6eJb\n+TGYJwe1GFj5euG4Cwlp+CneJqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSUCb9QsorunME2vKvdObQS+cFeTTAfBgNVHSME\nGDAWgBTaUH3G1Z69yyTyColQlrTNopfZNjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDDUtq//nEjlCpoZeDHdJZ1w1eC66Wc\nRekt1T2pL5TGpwIgDk24BvYgQndZWCRc2M7kjvq2hWDYhYoUxxmbUSK6aYc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfuF+ohNJuROPWIXtR9Y1w01MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZTRmZDA5NS1mMmUzLTRlMmYtODdiYy0yY2RiMjJmMjk2ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+NfremeeSUn03vEvGo6l3Q94aE5/LZdg92ZT/iIiuaRNx\n9J0ZtFQug5F4URobY5YE3hMrxhrik2bzu4O91ZSSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2lB9xtWevcsk8gqJUJa0zaKX\n2TYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaLqUyNFc+oHb9cPWWp6oHN2X8irlsr8iNibzynowR54CIGQvq6zVRta/\nbtBbaQCbUuBhfEo9AeBCS7142tj43RV7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISASQ+ppQj1GAooyoTXBAl7uJeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2U3OTg5MjItODA2My00MDIwLTg1MTQtNmJjM2YzZmI5ZWVmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTkyMzQ4MTYtZTBjMy00NzU5LWJhMWEtMGFlYTZjYTM2\nMzJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7HZRDXaMcBS+wBefxjBHXZCf\naXdSZJls/LcaEaA3G0qllGbvFJdpq9+dHL+uRi+j2+FEm6B9HWcfUNDcy3G9g6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSUCb9QsorunME2vKvdObQS+cFeTTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22CKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC59ZO+tDkBUxCmD7Sb\n1Ez8De8c42veqDvXZof28U2NYwIhAIGihIH5woIQNRBWOrlqbSFtM6Z1I+yO9dUq\nt77xcABG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9209", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9209` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAWVcrBl6VYZLGMaDozSiaJsyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmZjBlYzJhLTljNWUtNGQ1OS1iNjMxLTEwNjc2NWJjYWIwMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmYzMmMwMDgtZDZl\nNS00NGVmLWI1ZGEtYWYyMzFiMThhZmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX/8i7qT63gDWhL6hKt6z+HO9BQcZyvwKqkApzBAiulpDCxrJi0Zo/TsXxrOc\nw7AN5Pp5VjBT2AgkmZnT82E6dKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEjn8Hq8YGCg1bnk9VfaxjCELh4MwHwYDVR0j\nBBgwFoAUabd6gquE01x5TZNCqTnlble1lbowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIC/ZEM3p48fQBlY3gSlAuBjenV1/\nTomKegcVObDu08DIAiB9YPMw5blGbZNq7Qz/nuZRaTzaGpWHHzaqMGZX6stlag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAet15PHpmkPTk8npzS5mxpRcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZmYwZWMyYS05YzVlLTRkNTktYjYzMS0xMDY3NjViY2FiMDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATQ6b16qxdUC/vTSGQq6HXDKm/QgotCNvPfqQfFlDDMPo41\nS4oBqlSb2Dw+4LNBih8DxHFI5SVlPZnVzyVgxm+7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUabd6gquE01x5TZNCqTnlble1\nlbowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgArZZIZPfpEAEog9iojJyHeGrBqMnAiMuVGbMS8uWKzkCIQC1y1l4zdE0\nluIn0OIezuy9poXt8piFLTVM/TmbQjUdVw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISASO0T23fmlFOOGQkZEqv6/QKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmYzMmMwMDgtZDZlNS00NGVmLWI1ZGEtYWYyMzFiMThhZmY5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjM0MjViNDgtZWNhYy00MmY5LThmYmUtZDE5MDVmZjA0\nNjUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/Dml80NfoDVPu/6HFH7MeDxc\nja2VzX7dfTeBHjRq2ouFPQ2ZCJyIdtaqyQ0t8ag/JPvhiYHSBJoPuy1MPDvPt6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQSOfwerxgYKDVueT1V9rGMIQuHgzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22DKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIC0UN1mQUJnAMM9oP5+e\naqXpbPc+mtRjWLoaVABfjCqdAiEA/osPhAJ5pDwc9bDoS68f5errYjukKUaqgb4x\nYEOu1fg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9210", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9210` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYmIar9PHQj24hLbQgTQdOKyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJmYWQ1OTA5LWIyNjUtNDljYi1iYzc3LTViZjE3Y2M5MmI3NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmQyZTJhYjQtMDVh\nMy00MDI0LWJkYjMtY2UxMTk2OTc0OWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWdemekIa3qdc93kM613lue/bLaENH9pPbMLVVKurnUpjb3VzIsE8uX8SxjVs\n1SHpasfYu25QwvBraAwehK290aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQPx2lFgYnAUz+CEVGGQqgxLbLHNDAfBgNVHSME\nGDAWgBScwqyGiepCjoKMrtUMIlY2Pv7gXjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBdK5cwiBo+BJiMcry52dMQtgaJNROFA\niyCKVIPaprlmAiEAmEi/t24sFtdlECEtZ/Y/96vWecBnOav71uZ0Aw58T1s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAebz3TKRGVbni+JzsvLV6WinMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZmFkNTkwOS1iMjY1LTQ5Y2ItYmM3Ny01YmYxN2NjOTJiNzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvagk1SYyoVF7C5NE/+wemhJoJotex9Kz1ZcNecKlueCNS\ndwAbh2KcWgpgydJ5nq3/YRFZ5CRbs+gngJX6GS3Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnMKshonqQo6CjK7VDCJWNj7+\n4F4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB/m9Yqaw9e7SdPbM9AVrBtUNQF/ktCM8MLkXQLFPdMsCIQD5Yj93G7wQ\n4Hs23CqQ0WQ1Nezuu97x5TSWAjGml+quFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAaPsGhSkjGBoftyZ4G/hXKsIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmQyZTJhYjQtMDVhMy00MDI0LWJkYjMtY2UxMTk2OTc0OWRiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjEwYzI3OTMtNmM0MS00MWQ0LTlkZGYtYTlkYjQwMjFh\nNzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg2w6TOYdR6GWe2xG6rNd+UOd\nxktvp1WwDCWjSwar0JSlnaTNwB6b566Ajn2ETpBri+nboW7ldU8wEod0qXhZx6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQPx2lFgYnAUz+CEVGGQqgxLbLHNDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22DKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCvw3ztgYzw3dawjIgk\nJ6sGzESA7RIBlPld6JlvymcWmwIgf+lZo71XSNT32Vnkjbm1Qw7ipGWLnEIIzTH9\nSliQQC0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9211", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9211` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAW4vBlewgzL8kp5UK/n3Eh9BMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhNzkxMTY5LTRiZTMtNDQ1ZC1iNmQ4LWMxZjkzNTAxY2ZiNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjVmZThjYzItM2Zm\nOS00NjdkLWExN2EtODM0NGUwYmQyODkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsmdo6qJcQGCI6uhaz7vIDr1M04YPI4CB0J9VpY3aRBXxHH8IUMWlRD45bNfu\nywoRHD29B3Znt6OfKeuGuk85AqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwjh/mlaU3811kv9P7IdOOBIDJvIwHwYDVR0j\nBBgwFoAUTdiaxxzSbm3d0RkdBKIjfMsdNvYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCipenM/ACn2tGGAqNlXHTE+A/n\nC9sneaEuZxLry2TugwIgW+F3REPuLhpDFxWLG8xBSNPg3i8h7mrTN7Jczp/xNz4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWdYHBeglwF8vUFMwLCAsvsXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTc5MTE2OS00YmUzLTQ0NWQtYjZkOC1jMWY5MzUwMWNmYjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoa/f+++UXtkzjeX5itW+Lz12UgicVR9kvkf9Sxu9MzjYh\nwRstM3GkYti8VKTviCOfYXknrFGSuzCZwzl5RtSso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTdiaxxzSbm3d0RkdBKIjfMsd\nNvYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKAPJ0Hd7v/WDeo+YLBRoQJdGKIhIyOVD3SKkJTV1k3tAiEAmTwubzzj\n8S3t+ypozBVFVo1iQrGsMINxtp+02+Ulxok=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAVgoqj4ifH4OULxZUopwQc7yMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjVmZThjYzItM2ZmOS00NjdkLWExN2EtODM0NGUwYmQyODkyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDc1ZjFiM2MtODA5OC00ZTRhLThiMTgtMThjNjU0OGIx\nYmQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPGnSMMS2fTASWJ8q/gO0qduF\nEeNOUfR9XUWN/IaNCHvcAco296Jo3G4Sw4D3ToZQvJJCIL4S+Rezljsz6bDeCqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTCOH+aVpTfzXWS/0/sh044EgMm8jBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22EKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICJECm1SxN5myhiYbJJB\n9Lk5g8+7IZeQ97BIkQ9bFZxCAiEA+3Frc7plZM9nVuzItsU3oGzM1gHntVfPcKN1\njFGpgtI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9212", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9212` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAQInJ3UI6Z9UeFREoogFF81cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1NjgyMmUwLWJkZjMtNGZlZC1hMmJjLTJiZTc3MDdiOTdkOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTNhYTU5YjMtMjdj\nZi00MGIwLWI0ZGEtYzM3NGJhMDZmZjdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgU6gy1ZGswDxuhL1UsklGSGlaqo44PhFHCmWJ0sdwpa5yYCAsul+Gjoex7SR\nHsuVOJBiCFnjs/Jml4DDz7oSHaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRgz3v0WNgNfTCrvjLqiRN6L+cdEzAfBgNVHSME\nGDAWgBRRRFF3FUf1XzPQYgR2wau0g5JnrDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDmXomzwTkL5GKDZQRgDKVlz5rADd8f6\nAvnRqV5ZU5I1AiADeBat46PRPn0e384znhYG0Msqyo5hjwGTIyw6qzciyg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWifwthHtCa5mHyAydaSymaJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTY4MjJlMC1iZGYzLTRmZWQtYTJiYy0yYmU3NzA3Yjk3ZDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtC5TkDFmYzQt6yTkt/h03yOTIM2GFJk0forLtC5/CsCvF\nezUUNat7TdLjs0n7y1slhF3vfVpAUn2bRUlg8K06o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUURRdxVH9V8z0GIEdsGrtIOS\nZ6wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBFn72c/TmP/eLq6SP7xtfUnMU2ah38J7puKFrBNPjbECIGLE88U/gafX\nx49hF8p5reLOpkeCfhgwb0GJEA8oLFM/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAYh+GoQd+Ou8HjzBewZXc1qYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTNhYTU5YjMtMjdjZi00MGIwLWI0ZGEtYzM3NGJhMDZmZjdjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNkYzllYzgtYTBmYy00NDliLTkyODYtNWJmN2U3MzAw\nNDIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEz2/PbDwpb2DvAo+OJTrpxvqB\npbpB0XjyR2Y2RhEEwun/4uMuU9CBSLZGfqu2PO+UUFrAmMBia4DYQHyzmDWMfaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRgz3v0WNgNfTCrvjLqiRN6L+cdEzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22EKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDh+AebgjQ6vWQ55PCvs\niTPeD3FrkTd/qfaLJdZ2qXKNAiBPIdlXnuWKE7Cqtcr1e3lA2rMOH+Pwob6C9jtn\nAtpJGw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9213", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9213` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAVWQYAj1+3dOmaXK8rBcCfyOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkZThhNjM4LWMyNzItNGViNy1iZjc1LTg5NDUxYzY2NTQ0YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGFiMDExYzAtNWUw\nYS00Y2UwLTg3NjctZjZlZDI5ODI4NWRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAy0aYWPef1k0+Fp6T1y8wkedonGCUQzBXM0Om/bUyauOiBPG0rktD7oVvlcc\nRb51adUwffFs0MfE0MRwZ6XUFqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9KICcviDX1xe/nyuMTVseY8OtRUwHwYDVR0j\nBBgwFoAU/o5YQ1Gol3b8g4XZ2czJx/zZO2owHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAyqysFRkTOHFf3yAwiIR6QSphcI\ngmPdPyPjGy7MtWkrAiATbPXrgdiOfpr7sdkd9u+6o9muUrQaSMHLOkt+JrVkPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf9r3FgEl9xdcJ2PPFMmQ8AQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGU4YTYzOC1jMjcyLTRlYjctYmY3NS04OTQ1MWM2NjU0NGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtHHctdFDmUYhuVf9gps4UQXR7Wce4P7X917c7sahhmGdI\nvft4qs4UXiFcs6vaDNFdHKBtHc7We6evZmqxKsbFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/o5YQ1Gol3b8g4XZ2czJx/zZ\nO2owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJ6rJs5mhBtB+HI6mJGdbOU6Itvf3708s0y1k1BXQIuvAiAvETJegtkS\ni63E+e+ceuqmTipqyNvi6V/EuuJlQtyQ0g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAbiknMZRJUb0B5dggsYDq2e0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGFiMDExYzAtNWUwYS00Y2UwLTg3NjctZjZlZDI5ODI4NWRjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDRiYzNiODgtNjAwNS00NGU1LThmMTEtNTMxYjQ3NjU0\nNDg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa/d8ZnIXFEjXetLdTYkGX0OF\nI75KEKpRSHlFTsDFR9xbj1sx7N6W2Pel9uHRYsFGMP0dh7vnKxg+6LSMk/fMCKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT0ogJy+INfXF7+fK4xNWx5jw61FTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22FKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDhr3Nlqzb46SfIZDsB\nxBSVcz2ArnRY/+KPxlVb72FmNAIgIgKOE0Bb/2NndDhDgb6WQkagD8gM0/63dLJV\n6YbdUhE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9214", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9214` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUqRMs8K/RHG1l+HzW2IKdy5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzZDFkOTllLTAzN2QtNDYyZS05YTYxLWEzZTkzNGYyZGJiODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2FjNGJkNWItMmJi\nNi00ZDM1LTliNzQtM2MxZjgzZWVhYmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE78WqpulnnKxtyVFBYzaTJxCl2aBhaO6E3QgQ8ZCiYMK6mAOZ9f5jvhMAl4aY\nwa6KWw/QY9hF0hgoCu4m/6gNrqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSIsrsRwukbcLoylNbxjmLwU4xEJDAfBgNVHSME\nGDAWgBTBCl0FsZBMNkY2NKr58TCNLurmzjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBmOWHKfG/kFo5XuoOqlsSHuHjTKIRrj\nwWmoEiZGr7kXAiEA/D0NMaA9LhHwyM8uePTAqqDBZs0y7my7M6PtCbq5RKw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARIRB0cBCA70ZgC1MaWBAiDgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nM2QxZDk5ZS0wMzdkLTQ2MmUtOWE2MS1hM2U5MzRmMmRiYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATc0XHz/wgTf/STlBok2uWIRj7RnZ2lKtdj+z7xvDnZOEuG\na1ULpEzXWVC0StJJypHhJ5i7oKQ9aJMiGiGRmOsio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwQpdBbGQTDZGNjSq+fEwjS7q\n5s4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKQy/axY93xZ4EEq5SBlFUuV1oNZ5C88yaULG/FzuNskAiEAgaUSsnsQ\nGyAqZCk8ReX/pKbnWo6nL5pGTc3a2fEDL2M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAfvc5A7VAQy3oFEdn6kuMy5pMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2FjNGJkNWItMmJiNi00ZDM1LTliNzQtM2MxZjgzZWVhYmQ1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDIyMDZlOTYtMzllMS00NDE1LWJhOWQtMTM5MTkwNWUz\nY2MxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2P0t9W87PAEd/312gx/TpDRK\njZE9yubA65IBJ2zPUE/hGDT8D6RyHF0b7KqOHX3NuSlLHnXZVxEJXZE+YmvByqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSIsrsRwukbcLoylNbxjmLwU4xEJDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22FKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHMDwMTr6ywJPaKHW1ZG\nvg+7wYOq//Ekn3L9/e4vtJFDAiBRxJ2xUeJ8KqThtt0pVWQ+lj2errqniRiuMJTX\nYFmj3Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9215", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9215` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAZZKPlXq706NjYaxtRYbk/7nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2M2M4MWVjLThmMTktNDg2NS04MWI1LTdlMmQ3OTZmODY5MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzViODhmODQtYjRl\nNS00OGEyLThkMWItOWVjYWZkMGEwNDk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaef4b1Z2HVBnRFLykrBiZ7cPuOV+E4VRcEjp6n5lkanpIA0VYum5ucz0UBCx\nJ/k5d1ugI/y0N88/BrcotfxJP6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqc4O630qF8h2LYKlOHURZlof5ggwHwYDVR0j\nBBgwFoAUt3g4Ydeb9A6vItQ5/2ZdH9zXGMAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICpK4Fec1u2PGuSE0BTI25jQzUge\nvwh3SoS0FqgwiprMAiEA0BEQzCrX7bNNJWXGTEoj4Ob0JXL6C2YYrZjrSp0WV5w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcszwyHn6VghEuApJBweRoEMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjNjODFlYy04ZjE5LTQ4NjUtODFiNS03ZTJkNzk2Zjg2OTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxB2QLhR6yOyOELK5W3DzKP5Uid4SuQuq+kZExbwvtvr+L\ncIqd0XycAshP08E5krbRilrEvkUg4Rs7r8PfHc1Eo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt3g4Ydeb9A6vItQ5/2ZdH9zX\nGMAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALPf2VMniu12YuNc8DYtHPlq6hIX9LY1vKisfbLb6Qb5AiEAx3LcEk5/\n4pQcBVxq4PCPc45BLdn0ge5QaeOQzIQkid8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAZVBScg3M43MeUycy6c6QYi9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzViODhmODQtYjRlNS00OGEyLThkMWItOWVjYWZkMGEwNDk1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGM4MWZkYTQtNmIzOS00Y2IxLTllMjAtYjRlMGI1NjE5\nZWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElIWf6njUip3bXSnWbusU0U56\nXD5vs2n9O459dU72CoNFHWazD5XZhqFta2a4/wx/ki7hCFltt4yfEbBVYqsRj6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSpzg7rfSoXyHYtgqU4dRFmWh/mCDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22GKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCPfH1hAT7QRi8IL6vb\nnXEKp6y1k5mwZp095xOReiz1kQIgNttlQkOekxitOnftB9P7P4KY44mMOgD9iFdW\nKi5Oqj8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9216", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9216` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISARG9F9ve1/6G/sbeGFBVGTwYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3YmJkYTI1LThkODItNDhkNi1hZjYzLTU1NTNlMWZmYTVjZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2E4YWU5OWMtNzkx\nYy00YTg5LWJkYzEtYzBiZmQ3YmMwNDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXIpISV/KpbTrfIJM3ybCVRN9ugfbdjRSQeZF2bC3KckDZnQFJajUGoBsx2O1\n/Dy/cAJeIJrSipkDshU7jLX5vqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRK5+IU9UY52R6QM8HwCwSOg4gCjzAfBgNVHSME\nGDAWgBQqjUuevClkt29pgkmaSQ1CCP8lcjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDPBpvxh9HbqUEVWX95bjB41eqlmhxY\nLgrrqc49lkVK3gIhANuw8UbgQaA9wBMKZQyaddvxO9hDn9eG0vjL1mhnFt+p\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf/hIoilgAfjkohhje1gMswpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nN2JiZGEyNS04ZDgyLTQ4ZDYtYWY2My01NTUzZTFmZmE1Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrSl9Bwugj4YtFG8C3eHmkIeZOx0WJpdK6d62/jG8h2eGL\numPesZxUuSvOxe9+cuxE535AvMUt1RMG8A+aIQjlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKo1LnrwpZLdvaYJJmkkNQgj/\nJXIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE3ONFCF+/OoLqvtmKVSwKEt89XL4hkzRzPawdQDvX8ICIQCpS4zqrJV2\nvzn8evj4k1qufkgZjZNkOdHMQcoF1iBFrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISASanCU2hQVr+CgXe1Czb+s1XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2E4YWU5OWMtNzkxYy00YTg5LWJkYzEtYzBiZmQ3YmMwNDExMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2E2NTk3OTAtMDhmZC00MjA0LThlOWEtM2Y4MjcwY2Nh\nNWExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQ1wXSE9E5UZjgG8ZbP5zEz+i\nft95PLcDr3DsGHokxi4ZrjPqt+aNNUnQj27sV/BLpu1VGhFMhV4gsNvHiV3whaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRK5+IU9UY52R6QM8HwCwSOg4gCjzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22GKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBvQ4lxThhwIzHruL+qA\nMqtWcI6BsVEdS657ci5NKfZLAiAnz3jFT5StRWE1p55eXAtpreatw5ck9JSqbrt6\nN182Ew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9217", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9217` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVzD4GV6eJo7PWqI7WzXAzEsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQyOGJlZDhiLWUyZjUtNDY5NC04YjM3LTZkMjkxNmZiMjQ3YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzVkMTAzNTAtNzUy\nNS00Mjk4LWFhMGEtYWEwN2UyZTg0OTMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiO4Sue2F0vyobCpqGlDCa4lnSLRMNal2e+IJUfIgwSJ/2YEuISyT4/BucIUf\nnLtp4yK4dqgs5IXVGp0tBlmbNKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPcl/TdPlVitNX1xf5Iqn7UulYPIwHwYDVR0j\nBBgwFoAUZn4uOM+rQMKWK4WNeTee3bPDiYswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBmpu6bMEXdGZW5d+iy0d3F0aR7Z\nMPnptFgdhbqkk6FfAiEArj5aMCaGwhEfzS+tcCIegfdnTHzGdkN3xLXuFWeflZY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAX6CKtXOuroqOM1vb4yPydOUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMjhiZWQ4Yi1lMmY1LTQ2OTQtOGIzNy02ZDI5MTZmYjI0N2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASgTKoveQPHZUb1qBp3+oJ4xemGvqfLmDOlxecRzvL1Q1El\naEgpFzh2uGkI0/YEOcCGY+XOdFF2KHezkRfyPBs1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZn4uOM+rQMKWK4WNeTee3bPD\niYswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDqj4kYI0PmsgO7kJTKTsZPd4emMCpUyDf6vMcAlFMLkCIFV+QN71K1o5\ncsYznkV6xas7xOdO6N5mIQN9j0K3jalP\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAeEePx82ELiuSIFRCvPOo/XBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzVkMTAzNTAtNzUyNS00Mjk4LWFhMGEtYWEwN2UyZTg0OTMyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGU2YjJmZDUtOWQ4OS00ZTIxLTg2NTQtMjYyYzEzMzVi\nYjU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEriQMV9ojygOKOmQagulB0hJV\nILjra9xPHLjvUYR2KKAJj5xyDlhRVd/QI5B9GBYCJMmeymZGiKzwZgY6pPY8uaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ9yX9N0+VWK01fXF/kiqftS6Vg8jBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22HKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDWWqQF1ZXjcc2KaRj3\nxE/5ROsYIdbPnxy+Z/Q4NWCHNgIgCFt3fqWx6V95JEeGWEcO0fpUEK/knB1cvEdR\n5Hy7ziA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9218", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9218` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAVUWpAomo3ghnUqHhhcXPJNiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkMTRjMDlkLTgyNTQtNGU0Yy05MmFlLWRlZTQ1ZWE2ODAwYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2VhYWQxYjEtOTZl\nOS00MjVjLTg2MTgtMjZmMzI4OTU2OWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBjKcFCmVUgDfgG1Ynz2ZKaZAuJgip6kKtNY6BJuYamXPty/zjL5ZCnouUvdL\nbbtPNFVI6x55W6P2Kd9mH0f8xKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSHoEVjzAEb5oFAQmuR3aiHy0i8vDAfBgNVHSME\nGDAWgBTdsjIvfo474GWXJuSML7z132QwITAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCkOqVDIHIWWj3PAnEJqb29pqAp3nVB\n20AiB+m8lJVnKAIhAJX6vi4oh/wu8xYpAVYEd8XRgsb8/KGWBzhiFxYZ5SGc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY/bhXgfy98iH52ErYBisNUcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZDE0YzA5ZC04MjU0LTRlNGMtOTJhZS1kZWU0NWVhNjgwMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARY9ePeqitQF581WnqaW3G8RQ4arGovsoO4+rXS4dsWs4fm\n8grDlWhdPiOBSWYvdTQCjtYChTTRd3P3BOLzvMWro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3bIyL36OO+BllybkjC+89d9k\nMCEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOkdN+ZOJvbr7Pcuhl2lccU68l9GjyjAiJOYtE3TMzpyAiEAjbI3SEMf\nuNzC3UDGnZlH2eAUawfVfu6O4VQvN5a8xfs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAS6D9F6bJDWjxEQTFd4jqCHqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2VhYWQxYjEtOTZlOS00MjVjLTg2MTgtMjZmMzI4OTU2OWRhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjc4MWRhMWEtY2M2YS00Yjg3LTgxODItOTk2ZDBiZjUx\nOTAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHnI2LmJMg4SS2wZbKAsRO2Nc\ngxCbeGMYzvUWSQol8qbVcnkSUSULcgLBzB7jTscq6STR9ExY984Ic+uNih6SsKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSHoEVjzAEb5oFAQmuR3aiHy0i8vDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22HKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGhDtB6ZsSODOG/Oh/m/\nJM8ELXNN5k7nDvjRgE9/KLcBAiBjTLW8gqjJjINligS7H4b6I7T+OhxJXYzVCFWw\nHCmr8w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9219", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9219` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAWNABmg5o5XHPrC1sL9LFj4KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNGM0NzJhLTQ4YjEtNDg3Yi1iZTM0LTc4M2YyMDA5YjQ0ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM5OTI1MjktYTQz\nNy00ZDZmLThkZTYtNjg4YTA3NThhNWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7yaTChI0r7JCL9YkJBFfx6TOSUbYqYGyLffrym/9NjuoV3ecYBnPPH+bemQv\ntVDQzvLp+lmS64GcpU+3SH+FHKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFvkgqVPiL5bXgqgS8685zikavhkwHwYDVR0j\nBBgwFoAUZBCLdtSS3poyiNa4LrD/jU0p64EwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIB2tH0DK0BcNdypESmfFYpBP/KlJ\nMWSglwP51zf1ut48AiBpnAuM878EWTSl6pGKUrxwsmY2AODP38z/vebxTEhXyg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZEMXQ19Jb6/0Z/yXgj/jymxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTRjNDcyYS00OGIxLTQ4N2ItYmUzNC03ODNmMjAwOWI0NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBZcFldTxAeV2G1k4S756X3NPGBnBbaQEyGg5SuJUSngOU\ngQfYg0KGJZHC366r0bPv1QXiI8WwIl10zpvwPpwho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZBCLdtSS3poyiNa4LrD/jU0p\n64EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgKzpAmNnJBR2XP3zkxZDlBufWjC/DlIn5eDtYo6vqyhkCIQD5kBjXXCPj\n/EWPnpXGZStbG3BdNZQi565TaTrdhZaEww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAanCilUwkn4L0CqsYjOUCJOgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM5OTI1MjktYTQzNy00ZDZmLThkZTYtNjg4YTA3NThhNWI1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWIxOTQ0MjUtY2YzMi00NzIzLTgyYzgtMmUxYzQwZjMx\nODJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExA9lLs6tuYs6zH0Pp1j1pM5N\nh/4z0kYobqGVCSCItMsCdgv48x2JL+Vr3VeoHa89eo7scTNcQPEP9ucFDmm/P6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQW+SCpU+IvlteCqBLzrznOKRq+GTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22IKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD89y8KzOJZCtqPG7UJ\ngTa9MvpdjuyPSlxHCMUD8P4GgwIhALPii5R/IzGtYc9F4SQnWcalkQ3rVIrDniRd\nY2hhbFXG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9220", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9220` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAR3AtvGKGwMU+VidBioxuRMXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkZjljZTFiLTg4YzYtNDBkNy05YWRiLWE5MGY2Mzc5NDlhZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTY0MDA5ODEtZGU3\nNS00M2EwLWJkYTItMGZiYzJiNWIzNDk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9aJSW7QnHh0BwdGd0dYw/ExkTFQmjHUiqvaruqazoULWs/s3GNtmQCRGkFUD\nIrQkHKApkC1P/94ty5ER3nOAHaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTQvpi2RA8RZVwOnWn0Nord20qj4DAfBgNVHSME\nGDAWgBSld0rvHmJFyr97Y4ADEXBDQ6HojjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD6JDOSDVtVc+Rca57eYk20RmoIdpqC\nfYdOAPbrp+q/YwIgPFmhnZEqjiyxWD/fla699XuL5CUoxKgG2x++poR4G/c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY2y/11rBF9Zu4bmk3dWBct8MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZGY5Y2UxYi04OGM2LTQwZDctOWFkYi1hOTBmNjM3OTQ5YWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR5Y/qEe/roVswxUOFWx4gEKb95YLSlxKOM0l/djFO5cTVJ\nMSXgibp8Zqm8SZ7jz65lDAECNvQTaPL79i3ah02Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpXdK7x5iRcq/e2OAAxFwQ0Oh\n6I4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWyYF2gWdXRzc2oq4/unW8N+j6dd7rGJbQniVOjKcwdkCIGpuhwKUZyQ+\nHKTWXGzpxyOHE0zba0EGRZ92dl3u0laB\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAbTt3wxAb6SL/C//5tuOqrWUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTY0MDA5ODEtZGU3NS00M2EwLWJkYTItMGZiYzJiNWIzNDk1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGE0YzI5Y2MtZWQyMi00NmZkLTg5ZTMtOTIyOWM4Yzhl\nOTk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6sXYTQopDj7i+txYDgaiw+PN\n5yv9zUmwC55bEt5rmVFc3q5+2ZTwGB8d9XYRcCFmkqyHLNb+WonVOT+hixbLV6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTQvpi2RA8RZVwOnWn0Nord20qj4DBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22IKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCAIdo0+jjT+GSlpVpW\naIY3YA1PF5NtSrfTRFQPQaa4QgIhAMFqBzu/q3GQHFSZ9pusL8lkPVMKM329CMx6\nHi8PQEaP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9221", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9221` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeYqr+fPjH+BxSpMyClapWBOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxYmRmNjA2LTBmN2QtNDhmZS1iNjM0LTYyODllNDVmODk3YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTliZWY1ZWEtOTZl\nZi00NDc2LTk2NzItYTg0ZjFiMjJjMzU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbs2C74TulJSh9OX6/GmeIKKGc9sxy5N7JcZUJf0P4JWj8aIyohQGB6U8YJjv\ncfTYQmdpI4ShwS5SqsGL24Y0MaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp/vBKqaMgs57AzmWvzEYWtMI0SYwHwYDVR0j\nBBgwFoAUIB/Pyea3GNUkB9yRqt11FdOedAswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC+WOf7bBxIK8hHGKq/dFeZkElX\nk1AEGiWbGclj4HFnqAIgDSwBrshGD77S/7Skblqpy4/L1Iz/c+/FdBEt04kMTN4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARkwUXzTmoR88QRSPSki3xdUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWJkZjYwNi0wZjdkLTQ4ZmUtYjYzNC02Mjg5ZTQ1Zjg5N2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARmG/bRn7RGE644Kmrik9GL0ktIcxtm72ErlY1f+upXGlPf\nq6Cr55zGpebMmILcmJdcVoF5PIzJNYKmf0d21DPHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIB/Pyea3GNUkB9yRqt11FdOe\ndAswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKNmkxP3GkmZMbR2oFFvEM1cLaRcS6aVjJIQwerm6eFCAiAwfNfJx7L5\nPwXHFMncTjS+kETX8D9nZqFijV1B5HaHug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAUedFwuPe7BcMIJ5HbXCrqXnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTliZWY1ZWEtOTZlZi00NDc2LTk2NzItYTg0ZjFiMjJjMzU1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGM2MWFhNmMtZjliMC00MjczLTg4NWMtNGFlYmFkMjI5\nOWVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6SMdm068cB5GMN1kqffsVZX9\n7AVc1+wKjfIC4kFCrOAWQ7zjAAFodMBBHZCw2T8/GmNmAO4xrgN7AzKaI2T/d6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSn+8EqpoyCznsDOZa/MRha0wjRJjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22JKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDxSpnXs5ziXC6FHtHb\nBvWv9ovfdpzMpKj7uQfPWcm8EwIhAIKgyj9udftmSb01qFcJC4Sf5PBygk11jtcI\nnMOapJrm\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9222", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9222` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQAFAKUomyCtTip/pbYm+FlpMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQzNmI1NmI4LWJhNzYtNGJkMS1hNmM2LTY3MmI0YzA2ODhlZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGUxYWIyODQtYjVj\nMi00ZmFmLWEwN2YtNDk2MGM0YjBiYWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDXmhgVMOTRT+pZfyl5ng26HMw46Bb9lBi65ASBZZgbCc7DPYAE9KFFWhVRXO\nA7EYNuqToZvUjuIdhJ/Z+nwLo6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRy4XJs3ndETJ/nen8ko8plxGRWUDAfBgNVHSME\nGDAWgBTWauHUBprSXs9ul8LOlrIMEG3aSjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDrB//Li9TLtOyDTMmesfbLM9J7pX6u\noPPZeUTzqoms3AIgMlaVkqib5WnJ4OstUncdRfuga7zoop5ZGpzjtDFIP3c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbA+il2N49VNSLIuFcFXE+zaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMzZiNTZiOC1iYTc2LTRiZDEtYTZjNi02NzJiNGMwNjg4ZWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrS2fEo3X4JJVFcsVTlKo7OsXm9q1Ii/sNF6+8VDWBXlkj\ncxHnkyrlIVI92cy3jDOZEmGkGtaIMQbYRd/xGUHJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1mrh1Aaa0l7PbpfCzpayDBBt\n2kowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMUT/2rkw/ON0rhuRwlDX02jKq5TA8c2IyqEQEFnQNOwAiEAg2QXKDVw\n4GwVaW6X5nTsEjOaoMbmVDOineWsEvUvwyg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAW9DWWcngKjGjGjB4qN0hnXOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGUxYWIyODQtYjVjMi00ZmFmLWEwN2YtNDk2MGM0YjBiYWI0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzgxY2U1NWQtMTdmMi00OTQ1LTkyOTYtNGE3OTE0MGY1\nZDQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3jy9IADSd+1wkWENMw3rpsft\nYU2GRpnEedp6AFSSyN9LVioU36M+1AjlD39fEYxNnq4PqZGEhqYxWXyxXsdb1qOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRy4XJs3ndETJ/nen8ko8plxGRWUDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22JKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICRYYgkTzyuum2l/dgrh\nFjex0tG9vkKYAcERLkhUWijWAiB7h4EXyJdUQbOaI8TQt+8A1vJJLQwNUTmeLycm\nyO9IoQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9223", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9223` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAbVHbfZadgslu7YKuCWi0FihMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE4ODIzMDdkLTdhNGMtNDEwNC05M2U3LWQ2YTIyNTZjNzJmNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWYzMDU1NzMtMDc5\nZS00Y2E1LTljYTktMjZlYzM5YzY1MTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf3wtR5N1fojQWn/vlTFk80VjSaXnWikhQUbBtXLu+sR9eZSo/WwL+YC9En5p\nnebSmSrq8PP+9l2nDW/ty6dSXqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUMnhTq/Ld2uogp28E2gIDjLpMwUwHwYDVR0j\nBBgwFoAUqq6fpLcFsMpmDuU/mPJuaBFdnKEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC1Fb1e3JKK/scU2t2kqtxovvIh\ncCP+L1C/09wNnVsz8wIgBv7YNmCCdIAJR8IaXoUHM500IwkZekptV0sEb4FMcJ8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU+Iwow9lIo9d9l2pJtI3DKuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nODgyMzA3ZC03YTRjLTQxMDQtOTNlNy1kNmEyMjU2YzcyZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJyy4ZDEOR/fzlG0xNJFJEJqv2EvuXb8UPWT1HxsulCfIX\nyf1ayUtvwnyXdJjv85A8VqkYpdMj7s8miqRJOOioo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqq6fpLcFsMpmDuU/mPJuaBFd\nnKEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNEWfUSDW4MKJ8IwF8hyYmXBqHYdNC9AV7pg4rWS5sM0CIQDcu785AUId\ncEljFEt8fqWxfH12aUhwhZevaxNeysmvpQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAd8taQ983C82AUVyC40LQsDtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWYzMDU1NzMtMDc5ZS00Y2E1LTljYTktMjZlYzM5YzY1MTUwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmU5OTc0YTktNWY1OS00NmY1LWFmMmEtYjk1NjE2YjRi\nM2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWhW4EBh+cQdy+MWciKdmAHDA\nfQjaE5d0TgpWAIopthMVFGtEynSUkX95Xo+RqQhtmdZ0bcSEcyVTq/7AiQsp96OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRQyeFOr8t3a6iCnbwTaAgOMukzBTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22KKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIE8V7r4ma/LTEfk1mxF0\nQjgyUQnSnWXMKgLWXaatUBYQAiEAjxLI9gKz9ohtBFxwjKiVJOWl3E/B8nhGrdOy\nKtuIsFA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9224", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9224` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISARBLxTeKdb4v5p3UU2vxb1ZWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk3MTk2OGE3LTg3NTUtNDUyZC1hMTUwLTYzMmFjOGY1NjdkYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYThhZTFjMWYtODZi\nOC00ODRkLTg3OTEtZTE0Y2VlZTAxMWJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgK4/694tvAiY1glbuRJwFR+44EMTS7sFfL0jNqNY17TFlIAV5pmuCYwCA9Yd\nm4UrYxHoN5eVoEWTNNqsMr9kZ6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ2Y6aEUHcwT9/40eENR6UJhguT+jAfBgNVHSME\nGDAWgBTSux/lr/lCXqg8Z7uTdJXKmv0K6jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCK9M4CI3OwmqTO6uiCQBzP6SKsMNTF\nKxQRRF2VkVSLWQIgEcmvABckhMJFB9acaCezl6oy7x8ehuX8swAIrgZ+6EM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU6E1gXIurur+/qHvavnGou2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNzE5NjhhNy04NzU1LTQ1MmQtYTE1MC02MzJhYzhmNTY3ZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATufDxwpHcyc/C1YM/+kzcgBZE0VKNL90yoKCf1C+oxrfFi\n9eD6/yBV73Xd+446HW94nRD3DOv8xj2ijZdxuX47o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0rsf5a/5Ql6oPGe7k3SVypr9\nCuowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgbFQA3ykLXaOXQybp5WWx5K+QQyX+L+ZKAcTnYe6PhDkCIA8pTy7xTUPT\nc9ig9cjktQhhZ+w6R7/RZffTdaZfMiTU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAfzNryZwxE3DxaX5QgxDKnAaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYThhZTFjMWYtODZiOC00ODRkLTg3OTEtZTE0Y2VlZTAxMWJhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWE4MDk3OGItMTcxOC00NTEwLWI0NjgtZWNjNjBlYTM0\nZmI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsYFxxH3Zk25yP1tapBhTyPaD\nRm+3EqRaW7GITdAk14miX/5GV7/tHhdtAg4DfWVFoEKpPyiY6EwEWa9lJIBBpKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ2Y6aEUHcwT9/40eENR6UJhguT+jBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22KKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCTkvxai0EkPjSJUjAt\n1USrKzLHMslXM0SzlxjpZ6TcNgIgMdvEDFNrMtaLIr6mr7yxVcd6YMdXoqQTFaxo\n2QAkJhQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9225", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9225` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAaKCivBaRgvY5XD6ibnVTWg8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3MjJmNDljLWVmNWEtNGI2Zi1iNTAxLWI4MTZlNGY5ZmRmYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM5ZTY5NzEtZjI3\nNS00ZTI0LTlmOTctYjJlOGNmNzc5ODlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9soZB02dVY4t0EaVAAI1zCh3bTtiMLdq57AuUawlDY1YD3tzeNlGRe0rEio7\nFTb3KY2j1AU+I3xLoVWZZ6zFMaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6DqL1nHE0c5SxMlYPABKcfdl+TEwHwYDVR0j\nBBgwFoAUrfdEhQipzPJAuO2b87WrA4NOPkowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIE3mwnOyh0DogKFD2B7vcyWh5vgW\n7TpU86Qg9HUScLB3AiEArRabpis+I23QPsmkpSfwvewKM5+mRBhTSGDp0okCpsc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWNWCElp1odGdF/8jbCb2h6HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzIyZjQ5Yy1lZjVhLTRiNmYtYjUwMS1iODE2ZTRmOWZkZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARic34GWLDF/gKotY6UpQtAvNKIQL0F3iypFviQfYorLeOd\n8bKP4DKHRIHuWviLXv1XunBYSEY/N1HmHtby5AW3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrfdEhQipzPJAuO2b87WrA4NO\nPkowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYaEmBfOCPP0lNiJdOwsHL3agu46yaXRpIulGK82xU/kCIQCscNdLeLJh\nXJ3AHQv1GzysXSimW3CK1m37U82E8BME9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAVYEI7Opwlz9T9+L5SIUKk0KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM5ZTY5NzEtZjI3NS00ZTI0LTlmOTctYjJlOGNmNzc5ODlkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzliMmViY2EtZmExNi00MGE3LWI3NTYtYjcxOTE3OWFl\nOTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdB3mLvOsfENB183jWfzoEak0\nGu2iir5zWpfPeXNZ8xVc+HbKUIN4LzYfWEkiw30m09fxq+XTdOJGt8OIlO2skaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBToOovWccTRzlLEyVg8AEpx92X5MTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22LKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEWwf5G8bX4nksUtQu3w\nLD7sqHu3cK35T9KDssRuC5IVAiAGniCP9GeFweLpJuh3Phbr+04LvpqnrqvI/MmH\nRBB6nA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9226", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9226` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAYAN5eBVMkWgdxeYbiAxEk9aMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwOGI0ODljLWZjMzktNGYwZS05NDYzLWE1OTc0ZWJiOGU1MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTZiNzE4NGUtYTBk\nYi00YzYyLThmZGUtZGVkYzZkODE4NzY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEywK1vpxz4xsVBcxcDxVLfR5joLWVgQQWUDxcpfAO+iEbJgvznIR109I7yPb3\nPdyTJK24cHJySbd6kQStBuLBJaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTAeb1tP7wULkKWfMt6faVi12lg0jAfBgNVHSME\nGDAWgBSy/nM0pp7YSLyNTHx4RdQgKAhFnzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCx+thni6omM17Y3lxTFJFxfyh7w6yK\n5zxl8ggsM93GiQIhAIsEUE/G0w5zagj8CBLCaV3qgyjO+0I+gPP0QSEdn3tn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZqGIcCYpkao+s7jiEnST3MlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDhiNDg5Yy1mYzM5LTRmMGUtOTQ2My1hNTk3NGViYjhlNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5zly9Y/LZvExsDjd1FT6MvLakCoC/ErGxdQmAB4wzIQ3P\n9mX4nUquZhRi5U30TCCdZAuSnnySDs9yVLaEJlYwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsv5zNKae2Ei8jUx8eEXUICgI\nRZ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKXgOZmBeou4DFQnsj6jxSKP6/4xyk85DQCWspwab+aUAiEAy6m6IPPb\n8Q/9makVhKXInuwKPuF6l4gAfo/F/EBflTI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAVrsmJoZgb/XnHfEWjYnBmeWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTZiNzE4NGUtYTBkYi00YzYyLThmZGUtZGVkYzZkODE4NzY2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2RiMWU2OTAtZjRjNS00OTgyLWIxOGMtYzgzMzNkZjJi\nY2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEluy2Az2Umfu78Adive7JPaJO\nKS68W/zi72fA53tqmPHLpqouZNkvpEbabuDBzGpSFzedehZtFkci0c5v5wD7cKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTAeb1tP7wULkKWfMt6faVi12lg0jBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22LKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIF5cowCd6XDHARJwIR2D\nYPlOLYV9S6LZhhCg62wraVM1AiBlceKzPGzlxFPnSI4br/0Vjr7wZQRcRemW7x1G\nrQ0AFg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9227", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9227` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfrMqpwS37NzbCCIq3ONwAd0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMzYTc2YzE5LTkyZWItNGFhOC05ZjNhLTk5Y2E0ODgzNDc5NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBmNGJmYmUtYWZk\nMy00ZTQ0LWIwYzYtYjc3YjA2ZTQ2NWI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3zQKu+BD2dKqg3wlx55sXrh4S/bYqEoDcsw8HvcxYUAt3j+kDZqrDjLUowpf\nDc5wK9I0wTf5XXnllOYqnSEfnqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUETkH0wl1wCpXXqlis8Bdx0dMb6kwHwYDVR0j\nBBgwFoAU9Feg52hd7rcCw9KQts4vfVDrFxgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCfdNRQ+pzrzVD8sNvCviiQq0kT\nAOpF/UFZfP/kI3BPFgIgGrrzWUA/fusig5vLf8mFsyNl08H9CS9Rjqd8+RyN1PI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdZ3/XD8XzTAZc90ZSJSCJlcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nM2E3NmMxOS05MmViLTRhYTgtOWYzYS05OWNhNDg4MzQ3OTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYSKJIdh7oqc8GzeeOd8Vp3pr7mZMSuPUtmkmDXs+6u09f\nXehp3EgPEzdPFZFdh2HlenfFRbdCHKEdG924BD2bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Feg52hd7rcCw9KQts4vfVDr\nFxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQeXXn+0bO/ETGuo9ubkpeWZ6zwtr9lIPSiFBjdeNp/cCICUw4XSbRapC\nriwiCxYhBucdcbvLc58LNt6hmVTcOhzo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAU19QPqtVN9J+hAgb0MPczbuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBmNGJmYmUtYWZkMy00ZTQ0LWIwYzYtYjc3YjA2ZTQ2NWI1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmRlYmE1ODgtZGQ5ZS00Y2Y4LThhM2UtMTFjMzIyNjVk\nMGUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENiMP7n67lgFjLXGzxYEur01m\nUgy1mNv6ZYpnzWijbp3lTax7iUsdkMvQyVkt9FVBOMU4BMDbaPT5jQoF3CX3TaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQROQfTCXXAKldeqWKzwF3HR0xvqTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22MKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIB5gfh8MyfPhFlyplmtq\nry8whalGPoj/JrZn7u/yCW7CAiAwPq4Ex1wRgovut73qR2eORyflpvfsASNURf7v\nH3my2w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9228", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9228` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISARIha46Mi5Rn2TzpVagZIUfzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1YTM1MDczLWNlODItNGIyNi1iZWIwLTU4ZjJlZjJjZGM0NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTU4ZWEzYTEtZmUy\nOS00MjRmLTljOTMtYjdhN2RjNzFmZWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsRDxI+1AZGozqd1jIdUQbq6bTtlNZ8hRmS2gWr9v0gmztk7sV+tUm0x43wEB\nHr2HT+ZcHPJcsMC7LOev1uRla6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR5g2CI+fnNmgIYRP9bzu7CjmpfNDAfBgNVHSME\nGDAWgBS7QI6x50pMfArfwy9pBITSR9e1AzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHLl0DFyhW+0GWO7G8dvfJwCBNCel1ox\nQ949IaxxfbT7AiAGRUpJ8g2cmOzOLB3+mAmqpZhPwrLMHkB8rfYjNJ6n+A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATJqOlp6jSY9FLJAIp/0zjUDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNWEzNTA3My1jZTgyLTRiMjYtYmViMC01OGYyZWYyY2RjNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGK86qbKHipZVGKwaIPVwA69DfmVr4IW1L6bEClIVCeaD4\ni4BriYvuk6Zb/kYweWQoOwSdot8j8/Bgc0hffoM7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu0COsedKTHwK38MvaQSE0kfX\ntQMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBFh2NwXejiuiZmCDmxgtW95ZRDbVPCA+3Zg0+3Wivm0CIH9yXP5cBpx+\n2+SM5pn/yom2lmNlqBqN/WsjHPB0qSo7\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAcWTGZbCA5atCoV3DT48UxCKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTU4ZWEzYTEtZmUyOS00MjRmLTljOTMtYjdhN2RjNzFmZWNhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjU1YmE0NDctMDg3Zi00NWJiLTlmNTQtMzBjZDA2Y2Zm\nNDk2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7C1f+IwXx0CUHvZhYJlgOt5u\nlpfeL2ksH/4iIwerNyaCnyGj3QnXSolrdk63tgZPOmt4BE3suJRyYcF2nfgKY6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR5g2CI+fnNmgIYRP9bzu7CjmpfNDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22MKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCzcs3SI6H1PC8vE8Zk\nu34Gbw/kAcMKkZqAJfXuF2HYbAIgIiQ+X0AfxwPAbYzL/YszsJZerR4RMEeQwC8y\nCq/1ABQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9229", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9229` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeEj5p49bh3hJL83DjUmufE0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4OGI0ZDgzLTU5MGUtNDE5NS04YTYzLTk4MzNmMmVkYmVkZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDBhM2YyZmQtYWQw\nMC00ZDNlLTgxZDYtZmFiMTBmYjc2YWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiFD2iWKgkMCT6ZI49ADibFyRgNxNEXiSq2o0Qx3THD7jzNTDKbGh3rOHE6Z1\ntHLQOsmVRRKgPsYATHchMOnnTqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSDHZQ7YXzEBM7K/pvilQ6hK2bcQwHwYDVR0j\nBBgwFoAUQadD9qMmCqRP6JorngoCj0iuWzswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFMewcLtszCS6OmXCq2TGhrJwneh\nWjP8ysgwqbliSScMAiEAkkOW82lHwtQgg0S6yBc1b3lp/3Lrl3T4Cl4UUmz53Fc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWpjA7y9L1UVIeiPAalF2YoDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODhiNGQ4My01OTBlLTQxOTUtOGE2My05ODMzZjJlZGJlZGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpVYjrD/CLXDxiE8gAOwDXV2ihjGqHw/jK34E3grYj+2iV\n8ugszkA13rKyDUU30PBxgTlrgO2zfNfeXaNyyeN8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQadD9qMmCqRP6JorngoCj0iu\nWzswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP4sPs9m2gj4wFnyrocvKcDdqizFjTi7gyBCx9Wm8qDmAiEAjodA4KX+\nsaItC93k/GO2aVQqLy2m5fLi4GQG1E3gJok=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAVz+f+POCSs9jVIhJO+QionSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDBhM2YyZmQtYWQwMC00ZDNlLTgxZDYtZmFiMTBmYjc2YWMzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjZmYjZjNGUtYTU2MS00MzllLTg1OWMtMTNkNzZmODI2\nZmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzPPgtZpUiJTJaHAFUhoS4L3k\nIoYhZhiAm1BNkHmWSzqiyJGuOD+LEbny9E3sl6Mz4b8JgA6YN9EnujHSGcyfc6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRIMdlDthfMQEzsr+m+KVDqErZtxDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22NKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDq9yON1/dkHCnBYf+w\nW3h7nUWh8gCGXyQS6EemeF0uAwIhAOgHohVp0gCxCK9TclEiQipAJzucNtZGVVCZ\nSEi/kivP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9230", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9230` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcAEjLO+A521jPrLA4Slg1rBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3N2UzOTQxLThmNDItNGIyMS04Zjc0LTUxYjU1NTI4YjdmZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2UxMmM1OTYtY2Yy\nZC00NzAyLWJkNjktZjQyOTlmMjE0NDUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkZ5CE90YXqfUcYDaIgaZGl1f/3kmA9dFzxfKrOyk76f0IbEcyUJrF+GtsvEu\nJSv4Qb8BX2cdjJWqtdht7sJEKaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSZQDwTXLzklnEb0+LVdbyCJsiAEDAfBgNVHSME\nGDAWgBRXuMMUwv9umzVUD20h90sO0wB9/jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCQagY2xQ6qIIlgOPChL7d3TvLMpSiw\nXw4U0Gv+IOcSNAIgXYuBCqQzcswoNs32ol5jljya5AvCgs2in3sXVin7tes=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQpOY75lLjZMRPOb8+wtCIlxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzdlMzk0MS04ZjQyLTRiMjEtOGY3NC01MWI1NTUyOGI3ZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0gs4LQqtnTgF/CVJGJig0Jsy5t3SHAg1RwACHWNFikKZc\n1pvCwt/FD3wENd8+4ORy7hm8sMbnCGS3wBLSUY+Wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUV7jDFML/bps1VA9tIfdLDtMA\nff4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSE7BROwsYt/DClbDalDsL9mlCE5V4VFRIOtJDTfxmvECIBVc1tOnFIWN\nSQgJJInGg5YFq3DUL5QG/QwLqpoY5/Kq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAbhrFSyf2EuFQNmWyYwlVdA4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2UxMmM1OTYtY2YyZC00NzAyLWJkNjktZjQyOTlmMjE0NDUwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjBkNjkwNjItNTAwYi00ZmJhLWFjYmUtZTIyNGZhYTE2\nNTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOW2fbrmAXHpEQvS0svg0fC/x\nBYC+KPn6y9a8a+66Nd/sLobbAXE+G3qdHAJFaPx2edvpOC79OipwoSgUENqVvqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSZQDwTXLzklnEb0+LVdbyCJsiAEDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22NKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCHPePgxYCu8/D0pCdJ\ntip1wKiG9lfH397YpK6emznrGQIgHfnnn65VEVLuIBk65its88YoevaDDAwFF+ch\n8wHGH6E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9231", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9231` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAeO4iUP8onIRazGAGbYiCC7GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhOTBiZjEwLTZjMjQtNGQ3Yy1iNThhLTQ1NzBjMjYzNmU0MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDM1ZGVmNjEtNjZl\nNC00ZGZmLThkYjQtOWRhZTA0MmY0YzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWIUxfKloLE1qE75GiyrppcUhS94kBfceegnhGiCuVVIZW+JGxKIieDGD+mgJ\nCcWQf18lw5DZ05MwjiqOW80qy6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoubs0G4SDwsMiyFHonePwUKoAr4wHwYDVR0j\nBBgwFoAUiWuYPCaFpctKFpG8qB9nXmcDyHwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIF3G2eTqd3Yr+i/cLnN2ct6KlOlh\n/YKj72/f3p0RvyxHAiBFiliEv8enqgwEkeNuDMSIN0r2tbxgtUEIH6f4rLx43A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfknRtzVT0PIJkxIMqcpriv3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTkwYmYxMC02YzI0LTRkN2MtYjU4YS00NTcwYzI2MzZlNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbfaTJ+s9Ro6veygjPPMxuGe46QYUfIWxMgNeDbkjKNyyg\ndZK3SyqIRIA2rFBmaV8aUjHjYsQiTBVuetqaAAfJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiWuYPCaFpctKFpG8qB9nXmcD\nyHwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHlTy6XcenzkBn2/tc310a5tCrol5bxG+enImfXsb/PwCIQD3E/BrYv/9\n9u/P4W1+mDHHLxVaFgYvvEc/RLXrLWQBIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISASPjM3Wg/y4NKG/4GYjG9bmAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDM1ZGVmNjEtNjZlNC00ZGZmLThkYjQtOWRhZTA0MmY0YzFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDk3MGZhOGEtOTU0MS00Nzk3LWIzN2ItNGE1YTYxMDA0\nZmNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaVOzXfe/tpSf9qudDz5JUC7T\nl9LAePqKYzK6/7GCKYeRRgJTQUnCIsMh2q9zApeeDHjxCshV/xT2cFjiUcoSJqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSi5uzQbhIPCwyLIUeid4/BQqgCvjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22OKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHJk81xYNX7gtcry3QpN\nUnrEQXvJggf9EEEotgUeUUdvAiEAlVj0cGz6QVIOEiub2m9/TZLY99oFgGZjOWda\n0SWMC68=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9232", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9232` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWrps8+GxcB6ycSf3UKvghTbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzNGZjZmFmLTJhMWEtNGNkMi1hZjNmLTVjMzU3MjFhM2QyMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZThjMDFmMDEtMjkz\nOS00NGMxLThmZGItMjAwZjUwMzIyNjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEg+JzXo3CeY1NsxKdeN0aUuQs2KYJOsDNqVQ4OW/a9fjFWBEfdxb/ASdkMBdT\n5Xnq/5AQeYlu6ur9emDLtvtK0qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBThQ8fjeBwyPSl/MA8DZFCVmcwwvDAfBgNVHSME\nGDAWgBRRcQO1iizQvpEuLNSVd4eQnDQjzTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDtKBnibDYZPdu5YuX8Bc383PEkOiyF\nzlzLjbVhn7BwqgIgHNm2uQetaNJmf/Iicolb3Yrn+wACKVbPFSKAclxDbWM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYm3NdSs8iAsZEcsKep2793CMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzRmY2ZhZi0yYTFhLTRjZDItYWYzZi01YzM1NzIxYTNkMjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScyyCYfRojUe4pzNAHcBuwGvuSZQRrYja1jLsLacsIZR3m\nsm6fqbx65HAVGNNX32lyP1gQH7HHA39Ajd3AceNFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUXEDtYos0L6RLizUlXeHkJw0\nI80wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIZuuPo8v3ql3A2dVb217cIs/371KF3g6JTk1vyEu2knAiEAl+Jj1rzJ\nqu2jRXi1Dle5BeFLfcUJJMX3OdWEdQGDuug=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAVVSSWiLszmIgIuJoVdWdZxRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZThjMDFmMDEtMjkzOS00NGMxLThmZGItMjAwZjUwMzIyNjQ3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjE2NDNmMjgtOGZmYi00NmE1LWExMmItYWFmODk3NTJi\nNDgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBgLEzJRCXLqVtZg0qRDUK1Bf\nadNv+4HfcAybcQeeWWBSK5lKGE86PgdAuMtJwfB/artGgPAWUyFGnw87/XBNTaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBThQ8fjeBwyPSl/MA8DZFCVmcwwvDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22OKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDQ1txOjnu2yK8FWHP+l\nuGjcRSTPstLuSKC3KxZ6dRoKAiEAjpt0AnIJ/YlVG7qFk2qulfY16vGq3qtMr34z\nSV4eGfk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9233", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9233` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAXaf/m+JGOUSAmQCZC6zFF+fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmZjJlYWE3LWQ2MzYtNGQyNy1iZGZjLWFjZTc1NDliMjBmMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTNlNmUwZjktYmUy\nZC00ZDMxLWI1MDEtNjM0ZTBiYWYwMmQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiPnzMu2QkktxY3qowWZJHdgibgfgsant4vfO+/V+RkTHU6yVX8lSq5JVLH/m\nzG9PaCkURArPCOmseLDAIPbKBqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSitADjPkvenbhNVOrX+fuTbw26swHwYDVR0j\nBBgwFoAU/6+T4/YDnMRptJeG6i73DYJ/WQ8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAG8Jkg+14fRUX22WQ0L7r5W1awQ\nMSslVHi3eMBbnbWTAiEA0oKbOzlrnSlapkpjloPWAiVyPevZQm7BEcYb+RzxKtQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdEduk1izXf9NiQIvXUArlxwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZmYyZWFhNy1kNjM2LTRkMjctYmRmYy1hY2U3NTQ5YjIwZjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARus9iqETEEgTJb24cZaZ0cqM9A2rOW7PntVKdCWayglGB9\njbThM8OXkwdsVP21LCJDA3mW2rWemiHMqp5ytNcHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/6+T4/YDnMRptJeG6i73DYJ/\nWQ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWvNKhBllyNxqGIbdMTHkDcFjxcfZUb/pO5rZMP9lEgMCIAH0o3Fr6+yu\nOjOLgGI+AxQ7Zz6OdpEJSXrGfOlJB2e2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAWQtREi9WQhCJt4/10BUdYzdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTNlNmUwZjktYmUyZC00ZDMxLWI1MDEtNjM0ZTBiYWYwMmQ1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWVlYjEzYjQtMjFhZi00NGUzLWEzYzYtNmZmYjhmNjAy\nZjc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgWyAN6D759S7neZG0Ics9EO8\niFd2Gmi1xdf7h5I9IHvEwOGBsypAfT8O6E96B+3NrlMh/8qo+Yo+GnlAHKdu9qOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRKK0AOM+S96duE1U6tf5+5NvDbqzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22PKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCID3TRadOvJOhOR2xXVa7\ne8jf9anGZZkzPoYEtqUsGBtjAiAGgP/GmJYahdzY8gb5wEanHMmJDfO7gc20ttTV\nJ2pKQw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9234", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9234` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAc3Jgr9vgJYdEbSizPrZ9me5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmMGNiZGNiLTc3ZjItNGJlMC05YTA0LWU1MDc0YzIyN2VjMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzQ5MGI1MDUtMWYx\nOS00NDY4LWJiZWMtY2M0MTVlNDQyYWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEM0I+PLO4VhERSwAKnqCnghhCj+grynYgl6OfO+Qv8m1U6JS869qMz4iXVYC3\nWBt5a72zCUmj6EPVOB1ORDa14qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSY/P/dCK/nUyRDIif5ui0MAtRhLTAfBgNVHSME\nGDAWgBToQswMGvX97GflTtgdBE35NVooyzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDvjjlRaR+VE0EdMG4iWYJbC1tVIJ3/V\nUZ2lGZPzSWoKAiAzJLohgsVPecm4ybSyY1/Hcbugb5+IjXJvZPlNsqUa6Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc9V31JoGU5ZoitwDByW3APaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjBjYmRjYi03N2YyLTRiZTAtOWEwNC1lNTA3NGMyMjdlYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdkodMuIM8i91/JPulng4QT2FXcZs3Sidlv67k6QAbpgEn\nrnPCvvD3WWuRPJWf1SVIhFmE/4rfmhgVEDRMM7gbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6ELMDBr1/exn5U7YHQRN+TVa\nKMswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL7qE04GPa1rvYjEpDa0Ucnbq5qnWiS49OV/Df1oPFHKAiA6ri9kGvfE\njBOONhCqzlQ2k/OhZGE53OAuuJ3lEnVNQQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAT2K/HjRrPE053RFEIpkA/1UMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzQ5MGI1MDUtMWYxOS00NDY4LWJiZWMtY2M0MTVlNDQyYWM5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQ2OGY2Y2QtNjVmYi00ZDg2LThiMGQtNDA5ZjZhZTMx\nMzYwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUsBsiQQdv2t0khIKGm17y0dx\n4ymi+28ttlqeDARwGpT7Fw/uvH4lcSQmSRzQdyRjBmWFNRFbzJmXXVTrCOs5p6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSY/P/dCK/nUyRDIif5ui0MAtRhLTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22PKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb20sRE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCyN/zpQEWqvxc1i4JU\ntRKuljF9Sq8Fdhf3nj9WEfIqXQIhAPvWHDWo0VKV9VZrDzhuvMGXgDs0B31aol9s\nG7vndLmx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9235", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9235` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAVL242Jc7+5Rs2J6YmMTHBQqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI2MTBhMGEyLTk4NmUtNDllMS04NWM4LTcyYzMzMDJiODgyMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDBlYzRlMzYtOTc2\nMC00OTI3LWIzN2ItMjM4ZWY0NzdlOGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERgmfWY4mSq+0szsirU8OWlhsPax54zEuabKnbmBbjQiFjsF/yCEXNikWW0m6\nc8+XA+OJjq8+EjhORLJSM7JMDaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEPwZBg7IztwzQY0MSyA18GbCuWYwHwYDVR0j\nBBgwFoAUboH2n/9MR/yXJ6ggYmChXz9FIlowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEC4rbzI5zxzP4gE9LGZBhMhbg5l\nWNZyNx5nsq+h6uuSAiA61SKCTaLuTChVBbFU52aiyMWJSeCp8cLmP3ZhUiYmNw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdbOKz8OXOi2Sar6t1Zf/5/AMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNjEwYTBhMi05ODZlLTQ5ZTEtODVjOC03MmMzMzAyYjg4MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVvJl5NBFBbJpqrQfvJLg9No5xnq41u5eSUtk/xyz8miur\nVr+BuXtx3smlulWsey4pJrm33hq6MTVlz8L2VpQWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUboH2n/9MR/yXJ6ggYmChXz9F\nIlowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANzGu0GGez45uVRm7nXgaINJjH9HcH/rWNAHOnLSFnGGAiBBawXQEZxC\nmaiJTWiHACxHMpia4oHuf8rxr39KtJZWHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATmgDYmIwoS98uKDp6pIdDeSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDBlYzRlMzYtOTc2MC00OTI3LWIzN2ItMjM4ZWY0NzdlOGM5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjMzYjRhZGUtZmQwYy00YTZiLWExNTAtYTYyZTI4NDVm\nNzNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtvVYP/o6iiKjCX8ir123XCjL\nU/jpZKrByJM+Hja08gIhnNSXzE8L1bkGi9ETEEAKrZMIbxhOXcxEUamy/+cmYKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQQ/BkGDsjO3DNBjQxLIDXwZsK5ZjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22AHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiBLjQT24HcZSOyfcv0g12OPQWvZIm8RoUgW\nomFB188x5wIhALCC0fmgtro+LSxol32/pxksXd9dZX07xD7lg1FwrXgo\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9236", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9236` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAenB6sMi5B1+ZTeX3dyhrx71MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1ZDkxMmJlLTJjZTctNGNjZC04YzVmLTMzOTdlOTc5Zjg2ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZmYWMwYTQtMzAw\nOS00MDAzLWFhNTAtZTAwOTYwMjgwZGU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEoy399k/PY0OJHZV2icNQGvZXa62hNblfGFnJJjrJozocKYzMI4aEIjk7hJ4r\nmIP8+iF2LAMc55H9cKrg4WuogqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRo8fC0dYzszM37iBVvt3x6YXxVezAfBgNVHSME\nGDAWgBQWETpAoxQQJLHGPONjRgv3HTxJsTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCgUyr0oz976tN6AAfbR5Ot2QwJeYXD\ncTD9UKyv8klq0wIhANXtK/xBPo131PT3PY1QeBFKQ34vjMVLPbCTujYUwji/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARiw5vXC+5eKT83LIoHktar6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNWQ5MTJiZS0yY2U3LTRjY2QtOGM1Zi0zMzk3ZTk3OWY4NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTx+/l1/W1uG76vu5EqkYrrqjkWZtEpFYJhymvBcdETB0w\nYQwB0dWwDN6th3oW2Z1xNXKRTuYnf7i/wddaf/eAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFhE6QKMUECSxxjzjY0YL9x08\nSbEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgewcZ1BIwZd4D1xW5rTnvwSIgAm0EyTWlJi9VkhAZo84CIQDuv0suIvqx\nDexnda8Mr+caSPNwifa97FrMDsr4rt9EmA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAd7ZYK5AHwpDxV5+SxYEHutlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZmYWMwYTQtMzAwOS00MDAzLWFhNTAtZTAwOTYwMjgwZGU2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2RiMTdmNDAtMTRmZS00YmRjLWFmMzUtNzM3YWYxNTlm\nMDI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMsZ9LlTUyLMNM1erV49zi2IX\n+DBqM9NN65/nppafz0a1igLxP+bSd0O/F4uGq60VzYj5UJlDbkAe0lsNL2DQ0KOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRo8fC0dYzszM37iBVvt3x6YXxVezA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22AHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEA17zGbLYdqSJZ+cVZ4PMOxzXeJS0Tv55V\novQRVVWE+EMCIQDrIm3O3tQUG/1iMdX/wtvnRh4w9iYKnJVpCY1MCOkpXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9237", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9237` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQchR32mYj+IkDJUJZCppyduMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2OTdmZjExLWM2ODYtNDk3NS05OGI1LTRlNmQ4NjM4YjRiYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmZiMmU0MWUtMWY4\nOS00ODk5LWEzNTctNmQwMDYyZWM5ZTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEonWu8ap468RH9jOFMZGzudJzluPJ0vHpby6zkPvdVpNO983/0O0gu1H700FT\nWevV5aLcF5sL4cgLvXdjuLHGD6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKFL0IMBnzr0uUKrPZT+ADWVHoRwwHwYDVR0j\nBBgwFoAUsDh6rBg8zt9B96QMrej6NKu88PMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDnWD/LdMriQ7vyvOQSmPSF5XLU\nRsNj+FLM78Jbvvp5WAIhAOCSF+II/YLFrZukmrbpEbvIMwbo/Qz3Q9eik6z8Ojnu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAenCHm5Jk4TTOtSaBwvQl5IVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjk3ZmYxMS1jNjg2LTQ5NzUtOThiNS00ZTZkODYzOGI0YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcWW8B08vM3tFEUAFIZ9snZMJz3t4pfv+NTFtPJgUyr8ba\no8ZSFRCYycP/ssDlapGCbA3ZaN1mxcS/ZkGQiUWOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsDh6rBg8zt9B96QMrej6NKu8\n8PMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPpA4wVfgdehC+AvgZn5loTsR17ksJ2vZNt4JorZzTb9AiEAkBbhYsG5\nrtUFA/2J+PdL49IToW/+FKfG+QFo6ToKSBg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAbr1jDtETmNynIo1XgpissNoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmZiMmU0MWUtMWY4OS00ODk5LWEzNTctNmQwMDYyZWM5ZTVmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTJjZjI4NzktZjAxZS00Zjc2LWJjZjEtOWM0NjkyM2Rm\nOWQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEng91EXsyIHqe+dX3/tTQI8mB\nUtWvPHWZ13sQncYTKLYNFQL5Sl1y82/7Df/JSTY468VCMUm3t/VFjqVRTChx1KOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQoUvQgwGfOvS5Qqs9lP4ANZUehHDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22BHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEA8SpqQnH2fnWEITD2zQHxUQ6nnG7v/ONF\npIBJPQleJRoCIQCS6khaSSexsok4l0dZtS7FpUhlFHOlvU7JOgU38Qj19w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9238", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9238` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAfQf9j/g3W2/cJiw41qmZ3oTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0ZjY2ZTZmLTdkNmMtNDYzMS1hMjAwLWMyN2M0Yjc1MDg0NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI4ZmNiZjYtNWFh\nYy00MjNjLWIyZjctYmUwNGY4ZjI4YTFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElQPdFT+Tvnv7uZSEWUQwC6sXGeQ5hDI5PLkKJ/XsKANtVvIAW9E6oaZfmj6S\nAeByaRzTKNSUz3E3VbybGMiKN6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTTAp2dblC9vpaJliNwEJ+s4Zd9vDAfBgNVHSME\nGDAWgBSASFPePJSlemfJgVUZKMrd6ry6jDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDmwDbCSnRMh9p0/MUUpNmeBI8Lob7f\nRVsoEH1/mk7lZwIhALXSCUYtAQUPbDGq0FDgvNnxScdWxxW/+XTnhZda/8tj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASKxpzSJVtNmO/ea+ILn4xrIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNGY2NmU2Zi03ZDZjLTQ2MzEtYTIwMC1jMjdjNGI3NTA4NDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzrRz7151ZGnBYSwLnayXH7gdTjvKgnjKojTtURcvQwvsz\nIvC0NiLLgAfhQfy7IH5ekIwk4kfV5v2Ukuote3E7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgEhT3jyUpXpnyYFVGSjK3eq8\nuowwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdiOIWjS/XUaEnW2qeJpTxqU2RFpJdx/ooG8XmVx1+owCIB3Tpw8xnUGp\nJy4dJA9qATEzhKWn20kG4JqDhORu7OkR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAV/PyaJKvOCW9Uv/QLk0qnx8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI4ZmNiZjYtNWFhYy00MjNjLWIyZjctYmUwNGY4ZjI4YTFlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGUxZjBhMmMtZjZjMy00NTFmLThhMDMtMDI5ZjY4ODU1\nNDQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9yJup7VkcT8eg2SO0mda+7H+\nz1BhvzSKRNWEOOF82gefWqJCmVAX41QejA9NfOYfMfd4HuX1qZE58aywUePy3KOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTTAp2dblC9vpaJliNwEJ+s4Zd9vDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22BHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAq4iMusByeGpkQYw0nNte9GWcRZK6zeYN\nwYS9GvADAkACIQCmMrSbDWe3Tx1VVfAnlfl1rMxxf61eybIVodiF7SLoOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9239", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9239` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQyPaEmIha3cbQhdeqbzDsKkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxMzA1MTlmLWJkYzQtNDhjNS1iNTQ0LWJhZjU3NGMwNzY2MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzkxYmZjOGEtMjA2\nZC00M2UyLThlNDYtNzQ4YWZkOThhNTM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEaMDICtavHtyNOHCypd5g7zmU8TQrpwrGK6hMCfzExf3JRPlj6A5/WMmTaTpN\nS7vh1vUhYCe5WPuCAVe2BkNJ06OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfqoT3mAIv4C7++I7DqAyS1cJHV0wHwYDVR0j\nBBgwFoAUqnJ/is/CDl6J/GZoxPWp/Ip5/4YwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDjFCFjpN33RnZD7+OttaFTL/ef\nYohw8IhcQ09cHuHl4gIhAKOIuikOI0erFlH3VHBujpXqmyB2HVfobX8CoY/X5Z5t\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVktHqO0ZoOBVf5l6mBrUUw5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTMwNTE5Zi1iZGM0LTQ4YzUtYjU0NC1iYWY1NzRjMDc2NjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQZPlcxE0dVu4lJxR9rJp5Ruj1ITshF2NUCNbOO4VKHRSJc\njeypSEi5h6fkDTkmDy0bP2WTLLXWVxQf1l4Tz4Kpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqnJ/is/CDl6J/GZoxPWp/Ip5\n/4YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVrUYDei5lc1Gx/zpJQ2EBcTc1aa9XDqjM6WGhI2Wbh0CIQC62wFlr3Ac\n5dOOJSvOM734Acuu+lVmum5dWYYFy2pfAw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAb7ldlmBO1KfIfdyCt02lqN1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzkxYmZjOGEtMjA2ZC00M2UyLThlNDYtNzQ4YWZkOThhNTM4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzc4ODE3NDMtZDEzYy00ZWNlLWE5MTUtYTc0ZDBkOTUz\nNGZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7SUL4VwL4+/lSAk0pbHFe1CB\nB9DENVEUblh2UrR1lae5JGPzGu05usTCdSXya3x0qLKTS2Ak6+K7Z4Np9kYtu6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR+qhPeYAi/gLv74jsOoDJLVwkdXTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22CHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiAOwFJSfs/RmjUBHtNdsICrsqBLkMAMFP3y\n8LRckBKKYAIgOkYgKc6321GuTyQHFAm2YCFipkZa+rFBLbmTTiZQZoM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9240", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9240` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAR+xdNYlinXrGl0R2IuD/RjHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIwNWQwOWE3LWIxY2MtNDE2My05NDk3LTk5ZWNhNmY1NjM2ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzUyZGQwMjEtZmE4\nZC00NTgyLWIwMTItM2Y4NTUyNjYyMDQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUO0XEtqW1l3QRkysqkRe5+fADZJj1/hVi78c4hVYDsLWGgk88KDYZNhakS20\nJebVH/pD3WKlRbS+5cdYHti6d6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRgdcFIdO3BHe0bb/G3oCUUGkY82zAfBgNVHSME\nGDAWgBQudp+lRARuD+MZSxOaYaBMHQc6GDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHTH8EkrrlmwpejEgb/KYRARZ+Nqx9rt\nZBL7rYJnxiXOAiA0IIx1bb5Kz4QamvwrjDusjOVds83qx43sE+4Sg7yuoA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ+o8oON2QSihjcKaX/ACZvaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMDVkMDlhNy1iMWNjLTQxNjMtOTQ5Ny05OWVjYTZmNTYzNmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASoDZZG+b2V1wmir1GgfiHgmcvVF66OIn0uvsqE+MNMJHZS\nBHSV2IzO+i8curPm9Ev7t7GxOYRlCm/qOmXKxjxfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULnafpUQEbg/jGUsTmmGgTB0H\nOhgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga9UlNRxpseRsJQyAEphircqOdACaMV6659oTy2KO8XgCIAjRIM714Pps\nb/5RW40zCoKoZSubcSELfJzl/rQOeuTU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAddYRuMztw6wplZXk+oPLZ4AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzUyZGQwMjEtZmE4ZC00NTgyLWIwMTItM2Y4NTUyNjYyMDQyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjdiZDNhMGUtNjdlNi00MTg5LWJkMWYtYmEzOGVkMjUx\nNmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE90GK/MUtG/ZWfxi5gWgGwVu0\njD6xU8KRLK0of0RECe6vXh9pU9gT7Ob+dFX1uHOp03H0cGA3sPW9KIbWBJ/AM6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRgdcFIdO3BHe0bb/G3oCUUGkY82zA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22CHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAkCSDjSIakQi4S+CqdY+aJcyxn6U7jY3W\n4ElEVbCuHr4CID0Es1PR53epFdKy8bDjJO7PLLL8hdKWuYGqV9fzP7ev\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9241", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9241` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAdG8JD87CCFag5Lyj5S1nL67MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0ZTNhMjIzLWI2NTktNDg3My1iNWNhLWQ3OGI0NmU0NzZiNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjA1YzQ4MTAtZWMy\nZS00ODRmLWJmYmMtMzI1YjgzOTE4MTgzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpI73nDDyEpXGbLroyMeuEyhg5MxeI8Pvq73gR49Wk5ak+UaJlffM1yjTHdcW\n6ve24cH9yw23qs2si9I6+BtUqaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgChTsOCCa/g/DoTW5HhA9OeduYowHwYDVR0j\nBBgwFoAUcExSxEkWE1SBG7/9l1x/Ad+YoDgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCPTghFbGjrZ0NHOeRtdMruMwWH\nlQgO3Nwib4o1F4Ge9wIhAKyZXaKp6cMck9rKaJOnZa5TJTwV6Rlu8A3YCHGlNGXf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXaHL6DI1xsMJaG60cvIreVSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGUzYTIyMy1iNjU5LTQ4NzMtYjVjYS1kNzhiNDZlNDc2YjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJVfidPY74YBzTM6TQvWtcOwqXcj3np4ZEGf5LZ0nQtuG0\nBc6C+jiDw6R5H9rU1y67JoOw/68FrjG/0m91OVVYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcExSxEkWE1SBG7/9l1x/Ad+Y\noDgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMGSh3vf6WRQv6i/AOlqNlzt56MIMfOJn4PWaqI3/L/rAiEAy7KtRFRY\nGy0+vyDXWKHN6BRJdHDrHHRgudaSJInl38o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWIxToZ5xOZJ8yyHYF76QWgJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjA1YzQ4MTAtZWMyZS00ODRmLWJmYmMtMzI1YjgzOTE4MTgzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDJjOTdhOWItNDc2Ny00YzA1LWJiZTYtNWYwODVkODM1\nMDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJK9xGVWz91Ytxm+9nDHNpVX+\n9Dz8Zm14iwPZ3NehUdDgHlPdGnAXOpogWOSTkqA1QdQswgWd9xV6n/xDbnxcCqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSAKFOw4IJr+D8OhNbkeED05525ijA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22DHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiBDfwTAt78PFO26+iBu53xung4MQXahhPYv\nBCvcwr3BegIhAI4VNLErTJ5kSktwhtfZJOi4WWuesfYlH0hnUUeG7EZF\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9242", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9242` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXplrVRgzE2mo+xHhw+SvnacMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2N2Y5OTAwLTcwYWUtNDkwYS05YWU0LWE0OWNlNWQ5YWQzYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWYwYzA3MDEtM2I5\nYS00YjQwLWJhNjctNzBjMzRjNDU2Nzk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqZxoTrYA/oyHOZ2bkeo4EICzqiHkdyiWi38ZDTUy08M4EFitGH9vOULQPx5R\nTK012za8kunXMVaGjK7en7oNxqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS+/sZgunRJFNVVUmRMWfE5RuHuhjAfBgNVHSME\nGDAWgBQsJV3PttxtnI+/DzqnSZpz9HhJRjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCxSXYQvXsto4Yry9ARGpAoY0mCcvHS\n0yT0CO8YcZ3qZQIgAwZNeJDSDV5kcuRjZPBXkIiohgOKqDFr9zd5/XtpasM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZto6/guaQ+xUI4RCbiqATXSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNjdmOTkwMC03MGFlLTQ5MGEtOWFlNC1hNDljZTVkOWFkM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+LgUKHM8tBxVgAYJFbeYyezWAJy/JB9Kjfac7jzEsFgrt\n2bFWb60AGzMtzuaGGKHV2fvUdtrUP+agVWWJQ6PNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULCVdz7bcbZyPvw86p0mac/R4\nSUYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO6AIciEecD2lLgzJWO9t53Jg5mOc9GfLb+qvMuqi592AiEAsqwjnGGV\nxWFw8nfE9h8ddOY7k2GCqpRtdw70BYR6mqs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAff2QSLZvFuWh2GqhFMoM4tSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWYwYzA3MDEtM2I5YS00YjQwLWJhNjctNzBjMzRjNDU2Nzk3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjViN2E5ZDAtNGU3Mi00MjFjLTg2M2YtZjQzM2ZiYzM5\nOGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhQT2O1zas5S4SETr8yIcoy6c\nQfj8ZwHoxNUExH1uwXFnRlQiPKSBIwe3/NrPShU6McwqspRjzflTqMZWQBTPXqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS+/sZgunRJFNVVUmRMWfE5RuHuhjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22DHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAhvxrq8kdVD/jQRwwKAvxqF8DJ4qzECcrG\nC1slxXIhHgIhAP8SZ3nKYJiHuGfExggHw/kfrO0rYT6f4AaL0cURH0ea\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9243", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9243` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWxKGHDDMSWfV56EjM/DXcvNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwOTkzYTExLWFhMWMtNDRjMi1iMDMxLTM1ZDk3OGNlNTAzYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDk1ZGRhNmYtYjBj\nNS00NDc1LWJiZWMtNTU1ODdmNTk0MDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4ju/f8ueDuhwdL4dJATiyKtO7peVmfBv1e1KEM6MM+WEk0/4k89IWxrwF3Df\n3YqRN68c/sjuptQpaMyXGQBNgaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHJP6ylDLqO6mOND961j0pX2ZnhQwHwYDVR0j\nBBgwFoAUpaZzeFGEqd1OyHx42/8AZvQAxd4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCs6xvzu1Bx3IX3Ua0mhD54nZZz\nciJvng3cGi9ydZBG8wIgexKka8Glpq0t2lSeNyJgnx0dt41//KZsNoRqgQWdJmM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXnB0y+wEEuLUbGCgk7NxPuiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMDk5M2ExMS1hYTFjLTQ0YzItYjAzMS0zNWQ5NzhjZTUwM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATGJgKU3dKpUga7qYekbwsk3VA3A1uPQtWVOPUOyzNQhoFT\npUj9TNU9osu/gFi4oI0ptKPK/oHJ4KSeTqRyIbjWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpaZzeFGEqd1OyHx42/8AZvQA\nxd4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgAQ9y/KyGomeA0aALjM5kSXB/z7kWA+uVRHtFh8vjwdUCIQD7dcHPw76S\niJBNTQTrIqp04yknc/ANKud9MTXEm3bM0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAfaRC8JJvcFlZ2harG45x+pWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDk1ZGRhNmYtYjBjNS00NDc1LWJiZWMtNTU1ODdmNTk0MDg2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDEyZGZlZDktZTdiYi00MDJlLWJlYTQtM2RlZTI5MDdh\nMGIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/UTBqvpaxPoBxfXA1aiTWDt8\nWli8qHY5SxiIlwztWSNmRCdrb0uNVxvY1s0YqID06NdF9VBZykrSk0UFEQOt+qOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQck/rKUMuo7qY40P3rWPSlfZmeFDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22EHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiBt8C7euo1Bq/etLGRSqvPQitW9rYY9TN5o\ndFmXqGX9mwIhALTvxXwRd3lvyruyM4mfyr8EjkP5L0ioUNvtYYT9kZCC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9244", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9244` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAW69eZTm8yxokjjfSpZw53mzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmOTFiZWY0LWVjZjYtNDRmYy04OTdiLWZjNmRhNzgzZWQ4ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzhiMWJiNTgtZjFj\nOS00ODBmLWE4MWMtZjU4OGI0MTdlN2I3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFNStuifQM58M7BNLaTBGaWtmm13qqrk0M5ZME26DNloRDL5iV2uRZjMl1xhi\n+eteNsfBAyycEKQ1x9iuBKZrqKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSvWc3ZWMoE4Q+jOQ+OSr0n4XULTjAfBgNVHSME\nGDAWgBRh9LuriRhIjNSfsqgGVJCCXk2M2zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHSSIneec4G8vVLR78zx5TJ2xCOUEEhQ\npm9bCy/jQURPAiAfuQmNX+kmNutVKUusQLdybzPWFaUxGvsf08leY26s/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAajW5qzruksCyy53ZwaS8HqnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjkxYmVmNC1lY2Y2LTQ0ZmMtODk3Yi1mYzZkYTc4M2VkOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARuWqO4Ra65SS8RPJMwRks6dgGo1Zibc09Iq28UHFOPnXb9\nuUzLc2REHl6ozzxuy5ZHwvo5BeHzOFvfa7HjF32ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYfS7q4kYSIzUn7KoBlSQgl5N\njNswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKYUkWgOxz/qfPUS5rxVfZoZqAQeJOhWXQ/XNXLzRs01AiEA+48fuS9U\nf7M0cj1HMmIqg9dHSS5vtgQ75ubJFBpzK90=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAWstwO9N4i2K4AfW/zwsQ1ZGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzhiMWJiNTgtZjFjOS00ODBmLWE4MWMtZjU4OGI0MTdlN2I3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzA3OTdlMjktMjg3MC00MzA1LWI5MjAtNzRhZDdiZmQw\nMDRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgG3RQfKq945SZfmvifjuXU2L\nnrmXluz33SZ6Hewh+pq6j2sqcTz1Zr1GEnTd6LPmG3GLGxF2krc6hC8IvKEt7KOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSvWc3ZWMoE4Q+jOQ+OSr0n4XULTjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22EHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiB0m0JVk2BzGmyXEWcO7G8WWdqltrRYQYQh\ngUaqaJ8QVgIgKFNH1DO6ESmeU5/PRU5ng1NzSA7czXl0vTOq9t56VQQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9245", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9245` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAcUcnzfocHe+gcUVB8aayhNeMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJkYzJhMzI2LWQxN2UtNDJmZC1iODEyLWY2MmIwYzc5MzdjZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY0MmE0ZjUtYjI0\nMy00MjJkLWJlNTQtNGU0OTc2NGJiMWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsiG1UuqYZmf3eOeh+l5iu/Mt2Yf8L69DXY6i5MRO9B12nIVUJ0PmZgUifznV\nMgS22vTM8bHxSJCl3+6gGEjjDKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBzZBu6nIwcS8D93/s5VMI/SKJwgwHwYDVR0j\nBBgwFoAUgG/q0vqmYY4lHi07Yuc3E2pumw0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC7wXl3tzSymBBIzd8b8UTBmoT1\nBNgKIaPBnHS5QgWfXgIgbLxhuOp6E6UTzeSeyYVGlnSRhKtLWMrTA1/jdrF1Z0U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYUbt8GvrHY/hXUeoQmjWEtdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZGMyYTMyNi1kMTdlLTQyZmQtYjgxMi1mNjJiMGM3OTM3Y2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASHmVoFy898C869TOCcZdBnJADspGXNi4CzQjkBrIXN/wCQ\ng3Sd3HRDGZp3rPgO4Xvk4XG/6djgDdbmY6mXrn3io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgG/q0vqmYY4lHi07Yuc3E2pu\nmw0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgeAfNsVcyPnsYw3VtgqBawt67Z8ulG9lgBlXZ5rtkVS8CIQDsv4sfYhgI\neEcSCGf4aqkY/XQ1CYG1God5KaYom+5j+g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAT05uKcPxMf1+dlouorFcBPjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY0MmE0ZjUtYjI0My00MjJkLWJlNTQtNGU0OTc2NGJiMWRkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWY2NTFhMzQtZGRhZi00MjViLWE5OWUtODA5YTJiYjQy\nOTAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQTn60Ub+jQU/yOL/zooH+qLw\njUxf5Oo32JUpj4mUureRxDmoIpGZQuwxEsFQawUp+2gujjI2hY6HT5uHh7W/paOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQHNkG7qcjBxLwP3f+zlUwj9IonCDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22FHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiALlRN2sLGRpzzA4k8/8Mx8lvaWKQsDrE9S\nLQ266kyaTwIgdFMshvSTgaIcYJXTEoSrK1jiB988luqpQg0JyraDvJg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9246", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9246` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISARn+9DhqDtOf8RG61oXsRyKMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2N2Y0NWExLTIxNjEtNDI0OC05ZThiLWFkYmZmNWUyNDE3YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjhhZjQ2ZDUtYTk0\nMi00ZmNhLWE0NWQtNjM3YjBiOWZmMGU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbiyRiBJtFKfWAV2DjLZOkeB1Cqihv0oS0etNmqKcTtWRZNlIHUOJA/ACAVrT\nUCH521Ku4L+7wuneYdtXFdkU06OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSQUpyLs2JCG3R4Zj8SdA0LWt340DAfBgNVHSME\nGDAWgBTbtmu4d3Z4Z5T51LEwqRBd15d1ZjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDaYyxvqX+uOYH3U0vredhO8p7NTaEdb\ngRQ0LIgXsER9AiEA6WVnUDoxvPzh+Mob+XiPs+SwzSpzDfR1kXcrHfolKSc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYgJP0xkuEVOmT1pkeNRU8/3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjdmNDVhMS0yMTYxLTQyNDgtOWU4Yi1hZGJmZjVlMjQxN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQUwYJyAHWO+VVIfxf48lN2vEmJPL/lAZyXBvJ6MIV5LIvR\ntvukQhv36p81VoNI0whfOWB8oRLTvBCDDqtfSQ9Oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU27ZruHd2eGeU+dSxMKkQXdeX\ndWYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPr4SojNEX+Of/t7WFPDmmzArW/eytRXzM21en7hqYgYAiBUGYOIPh9Y\n+qkimwOv1xd4kzb/cjr0vnlYb9kX1AI7FA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUd+28P++rMjX+jd23sEpQCAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjhhZjQ2ZDUtYTk0Mi00ZmNhLWE0NWQtNjM3YjBiOWZmMGU3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWIyMGFhNWQtNzE5Ny00YjY1LTg4MGUtYThlMzc5ZWM1\nMGIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEk4U2fqrLsg4I6pP4TA2A9Kbd\nKTG2h8ZpQu9YOgy1pBDW6Irl5/g8pz43+ukSn51Un8/xglUbDqr2dJh4W/kzCaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSQUpyLs2JCG3R4Zj8SdA0LWt340DA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22FHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEA0N4GYe+N7VXJaD2mWTaiXMMjX7y3FTgM\no8HKmbj200ICIDdZULoEXvxvUdnB+Ex4n6IzQicqvh/FAgZmlOuPqVoi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9247", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9247` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAevgEMWCJxSQ3VzzoItogj0nMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhZGVlM2Y0LTBiYTItNDViZi1iNDJjLTk2OTY5YjY5OTI2ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmYzZmEyYTItZWMw\nZi00YWNjLTlmY2QtZGQ1OGUzOWIwZWQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBSrHOVnEjz7xZF2yy4z0acSgR6YJxKEACkLSQnVrcvn4IHVpOmbEE7UIMpyR\nAPa208IFeFVfIMTPeSK50NpKTqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqFIMtBp27QWjJ4NAFoNrBxI9JKIwHwYDVR0j\nBBgwFoAUJIzARt/fva12idx+3+dpQH09Id8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIF9t1BWyGpjNQMaawj9V009INwPT\nMmGGpYbjO0FlM8EyAiAWFElRzOmzRIdvsXlyJYkYmqLx3Nj4Pmh+fmOU0l53sg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeH7prC9LlVsLv3PBiHTOYKUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYWRlZTNmNC0wYmEyLTQ1YmYtYjQyYy05Njk2OWI2OTkyNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARidQcXbZR+85A0MDeezwdSoreUh0n+Nm+qydkZ9CEhkllC\nODQOfTAhj/IF6gMhZPe0An4CM1YY0kQd6dV00QP9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJIzARt/fva12idx+3+dpQH09\nId8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOIYi3dsU6u7LMIcxsuW9/7XtWfJ4Y9t5mHDTQmIH8h0AiEA3OZIE8JA\ncyLNLg44t7ZjlI5+VzlSA/Sc8+vmh9McEgo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQ0qryywTS/KZOHgwPOS05wZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmYzZmEyYTItZWMwZi00YWNjLTlmY2QtZGQ1OGUzOWIwZWQ4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzBiOWRmY2ItMmZmOS00ZjM5LTk5ZTUtMDU3MjgwZjQz\nOTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3dU+T/2cGDJV4P6S5OF0VjFV\n5bDW00HXrAqX4LWUGx9Oe3sbxZg5c7q0urN8ilAieGc7OsbpucbLmoNce4/YeqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSoUgy0GnbtBaMng0AWg2sHEj0kojA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22GHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEA4wT99weY7PK2j/tFDfcrlKFC+eNhxjUK\niOEe+xzq4NYCIDQtHH4T1sgfiJuq2bJAtQd8bxlmLIWPpIWXxXPvdpAL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9248", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9248` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVzTgx348ScfPpv1jE3TJsWIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBkMjBjN2VmLTg2ZjAtNDc3Mi04MDg0LTIwOGNmMjllOTNmZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjcxMDgzNDctZTEz\nMi00ODgzLWE4MDgtYjIyYzkyYmQxM2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA6y6DBk93a77dceA0rz2aY6I5oxBQr9DijWQ63V3E+ZWUBsJLYZoJlUqXhIy\ngVvVXHO2BXqB+gmVa0LIVwxkpKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTE3Cn+gO3c7wpcHEStPUizNiQQjTAfBgNVHSME\nGDAWgBRkuoDo7oFz5eam7EJSfEHwUL2djTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBANM0tQWQxjMFj2JISCOMXa1Mt4ggSL\nq0PWBVyMiejCAiEA4ex9JkdWx4bJriB4084MPDwCcRmXVunpSyNqBM2KZVY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQS9BSPC8ZNtqWTo0A/DbBttMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nZDIwYzdlZi04NmYwLTQ3NzItODA4NC0yMDhjZjI5ZTkzZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQH0hd1fkPr/i9diJaQB6i0JqNgTAEOi6l4qSYqSeaP5SjX\nSOzP9vZ4L3G4FciwwnkJfpMplIrj/tGrEPaSW94oo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZLqA6O6Bc+XmpuxCUnxB8FC9\nnY0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ7iiNN7ZCHnJ/J/TjzMRpo5UkmtgD0xUeco9f485xD+AiEAvaQ/IUBN\nTEg4CNEyBTIpKn8zsHSx2HHw0/0edbOMmw0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISARDCg09J6E97d+Ry91MJbUqdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjcxMDgzNDctZTEzMi00ODgzLWE4MDgtYjIyYzkyYmQxM2Q1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTlmNTFmZTMtZmIxNy00ZThkLThjZmMtMjFjM2QyZDY1\nNWE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtlGlcwTZwxdhwkxWk6TitJWT\nZH5qrdLRKYzcpXWcf3MZMkUa5A4EMA5r7PrvVzPE8WfsINGRCftph1pOsBrGYaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTE3Cn+gO3c7wpcHEStPUizNiQQjTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22GHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiA+gs7I6yJj1Y4fYAE0QxB4O5+AUzAFGmwx\nbhJltIu32AIgJ25BmYtEgbfzgk934wjrA5eyyk5hndjxnlGvqI5wMWM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9249", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9249` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAarGtA+xKiPsYkgBh+EF/NsRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNhNmQyNWQ3LWE4YTAtNDYzMy1hNzU4LTBhZDM2NDZkMzQzODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDM3YjNiMGItMWE4\nMi00YjEwLTllNWYtNDBkOGE0NmUzMmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAGSeL04JIBS8IpI51EGaIQTOaKoWzzFtzPft46sZxzoWdwYPaiZTIeBCZ3D5\njHlWF8A5vYNIUYOVHn1y+pMukaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2LNcx1mkZm7OOuwj+D8euxH32dswHwYDVR0j\nBBgwFoAUvyMYrTcZ2Xymg6RIcTdnNfQcDN4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCL4XwRJ7SW4loP1dut6n9KeEv4\ncAmCQl5DOYTxde/RUQIgB5K8oIJ7mAP9iW7WmKeYP4VmWhZR6LXCM/dpBtMlJ+w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATIMvou0QHVjSMd5WY5OIj1QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYTZkMjVkNy1hOGEwLTQ2MzMtYTc1OC0wYWQzNjQ2ZDM0MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQYRazj6jdEz9E3VCAdjO1WasuJyCISIc7CdUXQL1Okvc94\nivau4E5ByofQ8ucJgK3tdCpb2vefGZeJVpNC9e0Vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvyMYrTcZ2Xymg6RIcTdnNfQc\nDN4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgHSY59rgvO/s/LMfGNPCgksY9sb16uoTb+gwW+weS1sUCIQCXcnG12lh3\n8hUGu5fNXybXuFEDt4slbpNb3VZ9IhegIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAciGESmuns9Yszycv0WRE+q1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDM3YjNiMGItMWE4Mi00YjEwLTllNWYtNDBkOGE0NmUzMmIyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDYwNTY4MWYtZjQ0OC00YmE2LWJlMzktOWQwNzRlMDg1\nNGRjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7LSw2UjLJKlxjGhPVkhepkcP\nfZ1MyHGSLAznVUtp3FfmRY4BxobQoG/M5ZAVmaUsEaZxEjCDE1tEgKyDOabtrKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTYs1zHWaRmbs467CP4Px67EffZ2zA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22HHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAZR0DuhPa5gmUrIjn51RLy1/KKTU/kvzqJ\n0khB8U69ygIhAP3qItTHzdderDfe7zXnH9xCtJYdHgjrVZekfMgKmbJv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9250", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9250` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAfqP7Rayvq8Pzw8NHyWUXnGuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU2YzYwNjk3LTVhODItNDQxMy04NWJmLTljNmUxYmQ0NmYzNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlmMjZhZDYtMzJm\nMC00MDg0LWE4NDQtYTU0M2ZmOWEzYzVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKureZySQjObwSyAeESkrgyL5sOSSsmm+487BVdh01gQtx9Mqwho8o7wcYNUm\no+u+KKT20qyl+RNEBiIJtFFQh6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSTkNqcfZyeZTl22nMwf3TTVWlw+TAfBgNVHSME\nGDAWgBSB+YK5fx1FaDaCtSIyzKkAqLQ4CjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFMyo/pKQvxTo8EGiHn0u6FA+Lgc+Y2f\npHT4uYCtK7DbAiEA2/DL1hR5gprtc41bYVaBJnLatFOKcSowCgyQ3Lwd1wI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATAKOKLs5vn3d8Xk71dozbyxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNmM2MDY5Ny01YTgyLTQ0MTMtODViZi05YzZlMWJkNDZmMzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcHzCmgfTGBD5IabPaFl/Kt/SUWiEGBiBRxyBs0Kgv0Rl6\nzxaA9b+JKDYH4i9uESMEJKTAJXi4H3NU0YWP3PNPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgfmCuX8dRWg2grUiMsypAKi0\nOAowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALGlFrlVhdm+sR/kUUQi29mCw5eOHBNqNjvgaoF2QmlTAiEAv1Gfjwc6\nWV+MYQT+y/TbUNb5W4WW/7WLpS1n/hdjv/k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAeD3i6sNH7PGsZy1r3i6OLJWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlmMjZhZDYtMzJmMC00MDg0LWE4NDQtYTU0M2ZmOWEzYzVhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmQ5YWNiNGEtMjc0ZS00ZDJhLTk2NGUtZTk0YTcyZmRl\nZmUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvT/1jqEK/eQq3TCxQ3IWGpiP\nZnPFb6d1cxcgJxduBx9fuDHXIFl/mg1nDlJLwwbhF4t4MIXMtCg+l65vvVi6ZKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSTkNqcfZyeZTl22nMwf3TTVWlw+TA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22HHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAk4Wt3hljOZnK7HZmNxFaR2+JY2UyGQ1e\ntBtZCJsYkJ0CIQDwnNVoOlnxM/LFgcLh+JMCH+k2DQI9zskYrp55qbu09A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9251", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9251` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAWN64lm0RdDYU1TsL0P6YXdkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM4YWM1YWExLWU1N2EtNDYwYy04NjNmLTNhYjhjYjY3YjZjNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmY3Yjc5OWMtM2Vj\nNy00Yzg1LTg5MTYtOTQzNjJkMzM0NDRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKLqisXoMQ6TDSxlQ2cRVmWOzPZ/O/VvdXl1BMJ/a1U41LtUXh1DXeL7QNQoR\n8uTnYEBLaUzoo8AAkrVuyUO6U6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU26sIEZB5SXixxIjfUX93tLfOa6wwHwYDVR0j\nBBgwFoAUZCv91G8XcydcJEBuDxIwkEeBMN8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDYwcQlqnBkSeb6iOaiJ2gSQTZgw\nmiwDguZmfnzkxfRRAiBtjj5jyNkoNTWr6Ftsa1pERJGmg52UeS2ZIVdS3lEQ7g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATFHvuOZtBh29NSDp1M+N1CgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nOGFjNWFhMS1lNTdhLTQ2MGMtODYzZi0zYWI4Y2I2N2I2YzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5tvi9XRyqQoLAmxbqFBhQuH8UQM2Z98J5zbun+OgvaW/x\nLh7cOUbUxo+E2akMMMsALaONuedaQ8ueb9HwuQilo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZCv91G8XcydcJEBuDxIwkEeB\nMN8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMnRi8tSM4bcs3amwh7+s/huaarDn5L04glykqDdQEA0AiEA/GkWUltc\nt+nogaSdY5whEDG6FNnPoiVPvIeAbTN9K4M=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQJNf7aJIWXsUwmk+KO7w7PMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmY3Yjc5OWMtM2VjNy00Yzg1LTg5MTYtOTQzNjJkMzM0NDRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2ViNThmZjQtYzcwZC00NTIzLThmODctMmEwYzQ0MDVj\nMjBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElaOI/zedyhsyOQb10+4b7d+P\n6GiP60E8zANJTAuGP9NFPoJihJHlYbhsSxHa5pyMlG4pK6I52iOStwpaJyks36OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTbqwgRkHlJeLHEiN9Rf3e0t85rrDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22IHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAvhI0UXDqnmXJ9g0t87a/nK4XeonuEgs+\nAZiVKDVsuOACIASiDHCIiTkrcANHRXOY26djwl6OKI/biRIr+fYwXFLp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9252", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9252` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAY1QWXVxWaOXtcW1WZ008e3FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE3YmYzZjkyLTFjZWYtNGYyMi1iZmMxLTQ3NjU3MTA3NDZmNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjcwMjUyNDctZmZj\nNS00YWFjLTg0NDQtZjk2MTQ0YjU3YjczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDelO8QRYH6hDfsi+xIjHeomx22I+fu1yNvleRUTpeO3mg0G0bi8HvLKAEUKj\nX1qmyyjz92cCz/PbsPCDCW1V7aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR6/QLHW5+a5z6ckgLcafkLQjrPDjAfBgNVHSME\nGDAWgBTfcJ87U59l/efAovPnlU7CCJqUbDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC8CG3gQX6HXKVnVcUCY7x/5nGZRbws\na/IKxY7Bfz11rwIgWVIJAoj6ztGIW93XuUKeju4LQ6+dcOf9nS+DUsarXGo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcimaCR6Ci7ldu6z4aVOWHgNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nN2JmM2Y5Mi0xY2VmLTRmMjItYmZjMS00NzY1NzEwNzQ2ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASwCpY7b2vAXsrhDwqxPH8Hj6NUSkivKGGTIq8BcKFnxfH1\nw9IFYVqoxZ6XQf+6Xk/WUz7+R72sh/dTpqJDw5two2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU33CfO1OfZf3nwKLz55VOwgia\nlGwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALOnFQoE3Yo/dS8kZkw4irEa3MEsE3mlqtgaHSh4332eAiEAxypDLwEe\nzY9084YksrywJHs2gZjQ7BZBaK9LD+BNkss=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUq1s+W0O7GtAJrzhjVR4kayMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjcwMjUyNDctZmZjNS00YWFjLTg0NDQtZjk2MTQ0YjU3YjczMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmEwOTkxMGQtODQxMS00ZGYyLWJhZGYtYmU2NDZmNTY1\nY2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFoUSW+QmVc+rBIV8oj06bFzq\nMno16sC61OEQuUb9a+SXnIKOjL2PfQFPWwb7lGafO37F3rum+RFhUz7BpFXwzKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR6/QLHW5+a5z6ckgLcafkLQjrPDjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22IHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAgv3SbJvaf3BTCKegW0fkOkLLisPp0xbF\nReL1Z1RAL+QCIGyXdlnUMahr/mrjYzTkKJa+QkRJWX1vVlsgaucx0lML\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9253", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9253` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISARddUZ9yN6I6dizY7goDP8ZfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYyNDc1ZjZkLTkzN2QtNDhhYi04ZjljLTRhMDkxMWViZmUxNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzBlM2JkNDUtZmRm\nMy00ZTUyLThkZmItZDFhZDc3MWI3ZGEyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9a0hn4R6x7ifzo5LTSaUYUJTJu17jn72OQOv51cCKpyhfIssGrRMA0oLlB6K\nNjApqn21ylLrzK6iGPFkuBQiqKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJyXTFzl9e22Bl5wOrXNslcgMy2EwHwYDVR0j\nBBgwFoAUOFEau+WjkBg2vv6hnhbBOjm2z5UwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCNqsYugw+sLGzI78nEl/jFZOXG\nGasqWEi/NXWd9ebXAQIhAOJRxBivvmoV9rUncqTau13Qb5jZGFIF1MBBGw5yr9cP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe7ozUsAyxg6ZC5DyDeg7DcWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMjQ3NWY2ZC05MzdkLTQ4YWItOGY5Yy00YTA5MTFlYmZlMTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ8ZQuCk0fhYsIzrKjr9Yy8j8oWaWX3szmyV3M0M/zxpMKd\nu1WBt2UTHDP5eBUVKqupzQ9FJfkf/yaktanMwpbio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOFEau+WjkBg2vv6hnhbBOjm2\nz5UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKace5z8e7QSMusE59ELZQ74Au9qoN1S2WrtOzX9WNXrAiBs0t7YpfCg\nQqg4U+n3Mev6/fWdOQdlq3CM9QfLOmkNkw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVmM2iNYDre29w/u4cvWHMroMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzBlM2JkNDUtZmRmMy00ZTUyLThkZmItZDFhZDc3MWI3ZGEyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDhjZDUxYTAtMmRmZi00MGMxLWE1ZDItZDMzNTFhYjk5\nNDJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExyRLT+6xVW2Z11gtUbPJsCYK\nNcFtFrfAYbRDLPiLm1/UA/lnnLO3uaNbLBK3nIX5UeT3Hx16lK/6K5nDjdkqkKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQnJdMXOX17bYGXnA6tc2yVyAzLYTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22JHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiBuNS/HchPETLpQ7xqBiE3sk52RShsbCBDK\nusbDW+CFIgIgD6Julfpu115HDjVmNLrbDod5IJ7UlCC1AK/G4Ks5ISc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9254", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9254` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAXWjLyXR2WgwV+aLu9g7JwLMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI5MjI2ZjdlLTYxMmYtNGZlZS05YmI0LTk2NzcxZmE2OGU1NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGRjOWNmNTAtM2Yx\nNC00YTEzLWE0N2YtMzM3OGFlZTA4YjkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExhmUH2mdO7XTRyPqPLiu3BKYpH8zHhala6gm6xelzrCYxMsS2HlUGaPt42GO\nad1pVFGnFNZwykGViVUa8y5jAKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQRhQ4cqlhUg2iGl/CL8r3uEGZOfzAfBgNVHSME\nGDAWgBRhwi/x6Aj9fWbYSHp2rfdQQlipQzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIATTJ5K18Akl6MiU1FxbVN3Bszv8gYsq\nfiBqaT4Mf9/VAiASKR6aZchCGsBQ7SX2iG6gSQyYkgmq1h8Y2kEa0PinpA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARdxmnL7b0XwK1ZqLtaFBWYkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nOTIyNmY3ZS02MTJmLTRmZWUtOWJiNC05Njc3MWZhNjhlNTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT9SWHKy0UoeHxdsr9/lnaVHnRKS0l88ZwEX2Aq198vvUxh\nNgSb8XG0Nuz+icXqNilELZqC+/HwUJEsn0volafdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYcIv8egI/X1m2Eh6dq33UEJY\nqUMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKQDnMRDSm/PHohwxwbZ5CdzuU1pLn5/AupwOYJUvHfzAiEA2AdKGiaF\nVN+oZNNyr5EmmNfqmq387+JsLupQav/Heac=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAVifxxnTZCHySIDHBSHMqF0lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGRjOWNmNTAtM2YxNC00YTEzLWE0N2YtMzM3OGFlZTA4YjkyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjhmMjZjOWItNjE4MS00MGE4LWJlOWUtNjg1OGNkZDU2\nODdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWUgN2wUYE29EGssfks64CDaM\nwIgZSgbmwhHcgrdc0UBtQZHNXeOzVyqC3XaY5X7SRvfuPTguEQWKyXDm5pX9YaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQRhQ4cqlhUg2iGl/CL8r3uEGZOfzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22JHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAqXlVBokdeF2j5oH5vEu+qdFl6ebvckAj\nqzF58EX3fTsCIQCWmw8x1wUL74nEtCKTSfwQjVfbecqK4QGqTluFnmIr1g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9255", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9255` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISATOLSFfnqqmWckh337VzaHfMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNmNzE5OTdjLTc3YmMtNDk0OC1hYmRlLWJiNTJkNGNmYmY0ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjNjZTE1M2EtZmFh\nMy00NDBiLWEzOWEtZDc2ODJmYTI3OTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZKADsMBVNiGw9awWbBXSfZ0YK1/qC3SG+6LbuBJeiguri/EPvxyVMDX0MJBC\nrX6GnXbLBDd0ZZyehFF2OjVQAqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ6MZkzpHnHfEyZ8YQTbN50RiwwMwHwYDVR0j\nBBgwFoAU/228SwbQNwZ7t2fjPlG7Q4sDSY4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDvzijPZMYKePilSho0iWPuEiO+\ng/CgO+LX0hx9hFhkWQIhAM4iUrNm+SMDtd2ErtsvREAHsjSycO/XS8i7OZlCwP5x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXFwrVpLa9qqnKjpAjzq0xtrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZjcxOTk3Yy03N2JjLTQ5NDgtYWJkZS1iYjUyZDRjZmJmNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASYqUudK0r2dmRDx8pbPrI1ui9zKlIACPwgEQxSTn6YiaKr\nV7ylyaNgpDSyoajXxIWeBrvcvg50x2JlCY21OsMvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/228SwbQNwZ7t2fjPlG7Q4sD\nSY4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbHfzVf8m3OLc6cV53v8SGLDSluDYepT7QCgNRjdM2ScCIQDXoLAkntPc\nj5OvmWTwUSF3Rr+woJ4qTf9nIGNHzz40mw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAeiKnw7Av18pyKV3JDbBlW2wMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjNjZTE1M2EtZmFhMy00NDBiLWEzOWEtZDc2ODJmYTI3OTI1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjQ1ODc5NDMtYzlkNi00MTkwLTk1YTUtMjkyOTc5OTZk\nNzk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElBAkes3o0pZfWvapjedRjgpe\nV09eHCNR8WSN+eSMgOyhB2hXCEFlaXYD7J6297srM9Jtq0kXgcwFhCA3nDywgKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRnoxmTOkecd8TJnxhBNs3nRGLDAzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22KHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAOn/ZkBUTWB2zvwXaGIvelgAzf0/TTePLy\nPE8v82IOdAIhANUTtXIHYFS1KJU2ZdLHvDt3iGlfADZRcFfMqCNCupvk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9256", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9256` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQ4JixNFX3wTpQ8+hWxr5BL8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhYjhjMWNjLTg3ZTEtNDkyZC1iMGVmLTJhZDBkN2M0YTdlOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjQyZDU5MmQtYzgx\nMi00ZWUzLWI0MjYtODg4ODViODhmN2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECuJVXv4UgSy6pD0VkPqz93uk1tyw79tc8NnTMN4xsdniY8czSutIhi7gAzNn\nQGEuBj+l4zXLhFo1avdrsetK0KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQJEluTEpL9KIccfirZGOebiWWtwDAfBgNVHSME\nGDAWgBTymSC10w6mNyi352qkn3rRrvjggTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICqSwyhmFHN9APyeCOxJEz0tiTYmMqWT\nssAWi5YoFnMlAiEAgP+wa6hNtPFmfrT2cUszs/InIrdUFS8c58FTPre/OdY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUF4pEnpNtfwVh9dit2KvS1BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYWI4YzFjYy04N2UxLTQ5MmQtYjBlZi0yYWQwZDdjNGE3ZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQPzmh3S2YU8K0BW6RBJqHA8/ox3XIlNr+puDVtqb0QSn2p\niC/rYwDuFM6GSckuj9Xo6qM/Q4KatIjAbblvA+qyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8pkgtdMOpjcot+dqpJ960a74\n4IEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUEDD6UbuPvyxnxliJg++BqMsw0uDCw/mXL6ekxiUrN8CIF4896ipgBJM\nQHYaSoRRY43t9zRBfWSvAgCP6FbPTjin\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAYcP85a5Q1l+jNYfstG0JnrhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjQyZDU5MmQtYzgxMi00ZWUzLWI0MjYtODg4ODViODhmN2ZkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDYxZTVlMjItZmJjNS00ZWRjLWE3YTEtMGRhMTZmMGQ2\nOWE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKUd8nj/wBBPg7Jf8DUBljwKZ\nt1Xby/2ZKgVOErntNQixXcx731WeT8fXE75MEtfw6kD2GWo9YaQr85Yj0rc8/6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQJEluTEpL9KIccfirZGOebiWWtwDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22KHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiAjiR1QORhulZLHqGl/rOFD2BZPtU919uUu\n8ifprxAZUgIgV+zyv/Y662tp1YaiOQxGgaEPW5sBCxIgKdN5XBKe//Q=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9257", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9257` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAVtyMi8eY6gdc92MfW+TePJjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDllOTE1YTIwLTkxMzUtNDY3Ny1iYzZhLWFiMmU4NjI0YWNlYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmYyNWFlYmUtY2Y4\nZi00NTVmLWExNWYtMGYwM2E4YTNhMzFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8THABzqnDWi00Zti+CzfpSdZkBNdJGbcNSJQjDLIF1/xmm+qRRCNONC4OK1H\nGXCINPLyIaQfJHW/RC0jrHQOKqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcGrolkoJU3HQblyjl20ehn5Oq/8wHwYDVR0j\nBBgwFoAUlL/Clz/k9mXWTKltrfbI46TOb5UwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFoM5V8DCDUiNdZ7yyQdC47adrvh\ngz5lzWdnk/zqu6x4AiBGIfuJVhvUjVVP9S65omhAXChBQG5it8JwiYzNA5+Jhg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQmhmhpqbYRgQFjcDo7nVJdBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZTkxNWEyMC05MTM1LTQ2NzctYmM2YS1hYjJlODYyNGFjZWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASK7OyBdQ0k/DOpV7L82/7/9B2he8xT+2h4jFXYjTyFhTrG\n1GS6wvz53vFhd/xEyD24ID6yhZ61x1Pka/y37PTwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlL/Clz/k9mXWTKltrfbI46TO\nb5UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKw2ZFs+am/vD2AG3DmC1jqDdIrSYfMr5OukfN9PtjwOAiEA5NE4xQ5t\nyvAwi0ryb1+gwP+8efg9dGSKdXCrxY/MdhQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWTWYEFBE9BQnLNBORfhJiH1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmYyNWFlYmUtY2Y4Zi00NTVmLWExNWYtMGYwM2E4YTNhMzFjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzA1ZWM5ZTctNmEyMi00YTcxLWIxNTgtZjNjOWU2ZGNh\nNzZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVb3F0P08Sr1g6o5tTGwZnV43\nt5uZT+PK49gYhifS/0SJ/55xtKc/wZYVTePZxbSbZWI6o528eiSZycUD1n3EE6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRwauiWSglTcdBuXKOXbR6Gfk6r/zA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22LHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAsQGCNzUCyV000oprQgEpkS0Abf9YzPYg\nUlGy2rNWzRoCIFbr+mTms9mcDYwn2laV8juJy0V+1zFIzwzMzpTByEY2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9258", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9258` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISARNTXGHWu2BUptCCJFZ5suhIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwMzc2Yzg1LWVmZGUtNDdjNi1iOTNiLTVhOTRiMDBhNWU2YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2M2OGY4ZjEtY2Ji\nMy00ZWFkLWJlOTAtN2IzYzdmYWY1ODljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7bMo8FVVrziiPFT1jQ42Icgw+oL2Z7x7ADDpvMPOuTT+YjXSmZ23yJ4yvDgA\nMgMREOfhZyqPfpTpRjmw1gpdLqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSlYedl22ogq6Jk27Xi3acpE38qTzAfBgNVHSME\nGDAWgBS3ky4oUEyM3G8xTE7rjbYONgmAbzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCJ1bVhKRYIJavcRfFOvTl2FKzXTDht\nM9WaFkSM5QPBRgIhAMeKFzWIrYt/HYEeWTlLVp98SPHMCRlhW6YonNweCLLZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZFZe1taUn5k9//ehIEcFpvtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDM3NmM4NS1lZmRlLTQ3YzYtYjkzYi01YTk0YjAwYTVlNmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASG+ii3S4oYCQfFu8Gz6UjzDw2Is4xsW0PvUhKgV5BpqUMC\nPlc6+je9u5fXj72SCEK50RJRIzGhos8eJ6jc9zuAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt5MuKFBMjNxvMUxO6422DjYJ\ngG8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgB0tJmxcl14mP0gkSoHv3WxQC29O61jlQ4umFnLupYegCIQCiMQpFGYig\nD46lhhVtIxuAgYTO34xr7QNJ7hGWS/SBjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAfpspPjrCTTpEMKs86uqhBwrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2M2OGY4ZjEtY2JiMy00ZWFkLWJlOTAtN2IzYzdmYWY1ODljMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzkwMDQ1YjAtNTA1MC00MzJiLTlhNWUtN2JjZDBmZDNh\nNzkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENC6vb8dmZmEwmo32A+TNXCPV\ncihOp4mXOqjkhvJ+dQH0RM/bS81ow+Ajf6V53CfW0O9yS36zZUic7DqBVvcydqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSlYedl22ogq6Jk27Xi3acpE38qTzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22LHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAj8XXWjMBmEebFelIuVpU1zwOb4qAgMPc\n36BkXogF+NQCIQDZp4kaCS0rjrKFX82Xzx0IqR5TZwN8FbRdbWdFfA2YEw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9259", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9259` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISATlZ74oAX1DQaenXlQCnKFiIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkYmZmOGIzLTdmZTQtNDcwNi1hYzk5LTZkOGQxOGVlZTY3ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM1ZDBjOTQtMjg4\nNy00OTNlLTk5M2EtZWY5NWU0NmYyZjYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ91hgShIWp+XboeMKwoh4wzXoNdhumTIoYgp0vxXSwaYhItokZvR6fdBTcNg\nvy8WyGrk5NkjkMM2kpewX16+CqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1XOAZogppINLQPPM3io68tvWeRgwHwYDVR0j\nBBgwFoAUPirvu1jp0jiQQxZULxfvYsKAj4UwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDEnQdWYpqlkxkwWPR5CtQi4k0G\n0lhRznMOfd34DqCknQIhAMSTodRVw3ud1tn85/T6e7EuDS91TqqPEan4MV3WResU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYeSKn91qcQapbXMwKJXEBlwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGJmZjhiMy03ZmU0LTQ3MDYtYWM5OS02ZDhkMThlZWU2NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrKDa8yMCN7Wo10GPM0PN5RdVWHSi6ZkgsDN/oKqYDnF1y\nn2neYhacGBsmFZQWzZkQIfXy4kmtmLBIA4Hea64wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPirvu1jp0jiQQxZULxfvYsKA\nj4UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALf3Aovi/vhgwuqOphQEv/nu7NJITpMJNbT0MP4+DSlUAiAHhOzNngJt\n9rJTLmb5ukZyih/lYD0Z9BQM3gcr9NPfRQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAdQBzzgoZqRioX8rml536oAAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM1ZDBjOTQtMjg4Ny00OTNlLTk5M2EtZWY5NWU0NmYyZjYyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGRjYWExYzYtNWJmNS00OWNmLTlmNmItM2MxOWI0N2Q3\nMDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzSfjlej1pKIld1AJE+EkOJQY\neCqbZlnc+8b7BAFZhuorarAGTqecktz5j0G6rOjRd/8FyUJin0LHqVYw/1zLFqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTVc4BmiCmkg0tA88zeKjry29Z5GDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22MHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAgW9vZMRZZ91l9/y9oixNEqzuM0TmPZcq\ntYc8EQXeTfYCIGbugyCDnMmXtOkPUj1gcrP7zCBgYqTYPD/x/E4jOJ5p\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9260", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9260` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbZVS671PPS+NKQZcb5LzEvCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRhMGExZjIwLTAzNWUtNDk4MS1hMzgzLWNhNDkyOTZmODFhYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjZjMDZiNjAtYWE4\nZS00YjU5LTk2MzktNDVlMDU0Y2VjNjY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm+ng9r39YewRgLK8JkiupsuNSiuvMhY0TiGPDbtsHYNHBp2x+69/vL89OzVR\nIO2JKXzHe+SXm4k3IZLx4QkDmKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRd2VilDNUcIOEOZr6GcrN4jaTfUzAfBgNVHSME\nGDAWgBQb7rJzeK7ugvy235nnqrpBEW0bGTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFAOcpCWGhmhG2dRq7PaTx0vbgrIv1gD\nXNQbYl6KJeopAiEA8qxGzs7HNVV4dlH8pGJZZhyqGIRr03tYieiSTjbY72Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAedE6l9FqF+VfGmh8HZ5EsFkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nYTBhMWYyMC0wMzVlLTQ5ODEtYTM4My1jYTQ5Mjk2ZjgxYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATuaNpYdtNDfnrOF3PbdsbbcODxhzRCmgwUoeVxCEBYFC7X\npSlP+b0xuwYo91vleq54lmNTmWGFZsICrC5FEnQTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG+6yc3iu7oL8tt+Z56q6QRFt\nGxkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgW4SQ6Nj6gMOjqcaMjMgOkkC4iviS5lqBW3k2+Jdp6NgCIGNw5DJmE1o4\ni2+70PNSjKwqhawylBLVRZwsp0j3B9j5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAWB36fd0+8zyNlQTUBM4M12KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjZjMDZiNjAtYWE4ZS00YjU5LTk2MzktNDVlMDU0Y2VjNjY0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmQzYWNjMjEtNjIzZC00NzVjLTkxNzAtMjgzZWQ5MTk1\nMzNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2aXiVPQlQ/CvZBZt9g8RimIW\nhuaUcIusokCxl8MwtejWzhXKuF7bxbWDHoEgCVr/GRr8iP5YU7j/BBeLZhqo6qOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRd2VilDNUcIOEOZr6GcrN4jaTfUzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22MHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiA9t+yxpjmUDRtYriy3mtC+JXI/wXqjRbL8\n4LaQONXUAwIhANTEsnIqim4lwxEFTi+o11noSYVpRciLappYzPjO0xOB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9261", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9261` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQ8JRSby86/7BVJHYZA7+sY8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiYmU3YmZmLTE4ZWItNGNlYS1iMTMwLWMwNjA1YjZjMzQ0ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmU2YzJhYmItZmI4\nZC00NTdmLTljOWQtM2VkZmUwNzE5OWRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu5SGqFM0Vkgd76Q5VZDryTpa6Pbi17ODM3PCP/mOZAmJdk2xfL5T7HX6zQGM\n46wIeyxEvwYUu5Ffbr3T6iAASKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTvqClmbh9x0QHbFPa4k7EnJEXmYwHwYDVR0j\nBBgwFoAUeTMLYGIbPY0IRYspXOU7frbC4gMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCi6ZgMMviD2rgWdM/tEjo9i34c\nx2fS6HcHd3drzXu/3gIhAOo0LoCHGCxRvT7JE8dkpzWJ3vmFvuTooof/QvFcnhp8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYAFRwripB7IPt3ID7bq2Ou+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmJlN2JmZi0xOGViLTRjZWEtYjEzMC1jMDYwNWI2YzM0NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBA8rlaC25/Ctq/63pEMyn3ElOcmNzJ9zgD76PlCDFFEnN\nOcYaJD7cEaQph0h2anby38rKYM0B/Ioers3Jj4Jjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeTMLYGIbPY0IRYspXOU7frbC\n4gMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgY2C+z+tUR+AjBN7y0KIR28rTjCxKajt9SZmlUoG38joCIQDIZ3XBIZPq\nU6pv9dp8hKAfnqNLmGMtkZoICDiEY5iHqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASi80onAJc+fHJ5VyDmzwFeGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmU2YzJhYmItZmI4ZC00NTdmLTljOWQtM2VkZmUwNzE5OWRkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjY0OTZiMjEtN2M1OS00ZDliLWI3MzYtMDhiOGY0MjA3\nYjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEm11xA6c8JJDHA1ZwudoJFBgk\nVEaFhlDwajI9WG8Qx17Xg9noxD75gjx61UrN89YMs79ibEoG0bGUjFArK6hwz6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRO+oKWZuH3HRAdsU9riTsSckReZjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22NHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAsTJpVz6NxXK1y35qZq28DsWBV2A4oinM\n/9/Dy6251zgCICaCSn56KlIsZXMwRNOpvjhTBDDzXNypTcLkh8JzsLv5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9262", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9262` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAQ5MrFQQI19UgE/a+baCQDanMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5YzJjNjMyLTZiMDQtNDdiZS04ZWRlLTdlMzA3Zjc4ZTZkNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDdkNGVhZjctZGU0\nYi00OTJhLWJhZjItNzkyMDRkNDg2Yjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/nu1KrW+fYpNeGK+I334/SBTf+veGYD7V6IOX7U6Bkldpr6yMHadtUe0IPld\ngj+DHVUMxltBJZLr3gUdC+Q64KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRePjrjrRqBnc2wlaLvDSpy0d7s9jAfBgNVHSME\nGDAWgBS23FY4Sr63/d4gjCp40NHbIw/QlTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDnzbev/gUkNPMBarzwtqCa3ZNU0QpF\nhoZ3w5ReEGUAegIhALXIUaRW42rHxpUrujc2PznhbsVRX5BZlwLh4wBntfeq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVZFsd7uyeSS9AwibCR02ORnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOWMyYzYzMi02YjA0LTQ3YmUtOGVkZS03ZTMwN2Y3OGU2ZDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT45MzdPYeUUlM2MSlklBRuaGE0Sc921TopJsC5UNgIZkAv\n7L8YHbOgjn8BWQOj44ZrvvZJbVQeXU1D844D9+27o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUttxWOEq+t/3eIIwqeNDR2yMP\n0JUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXulgo1EBcsicL+90XWiOQBhnJIIhE+i6s13JQ2FBlC4CIDfmTEzH2hTZ\n3SnVoApky7T2d54awp/QHzggenT+ln2r\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISATaWUak7WEmcftRR2DnF4/YEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDdkNGVhZjctZGU0Yi00OTJhLWJhZjItNzkyMDRkNDg2Yjk4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjFkOTkzZWEtNWQxNC00NDkzLThhOWQtMTY2ODRjMjQ5\nYjQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPP0j1h6jHFIvXxiB8OcJ0FyX\ndzLn7XtUhmfZ/fhuNV9FARbKwlV3GlearK4YRA3e6USPutXjrK+zY6noMdMnUKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRePjrjrRqBnc2wlaLvDSpy0d7s9jA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22NHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAR6gu1wtWySXyOuu05jbbstbr/DRCu+EHc\nasUoZf9v3wIhAKSCeyfpDv/urZGnpEkRWV7dVKbH1Mr6LXgRnzfLb46e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9263", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9263` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQ/uN+MGq0nm5KGgl6U5RVMlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmMGY2MmQ2LWViYWYtNDdjMS1hNzMwLTJhZDlkMWY3ZWE3ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTcxOWIyNGMtOTU1\nNS00OTA5LTg5ZTYtODM1MzdkY2RlZjg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHYLeXq04up9tvszHynaZP5SOMa5H5dTeBV7+Q0+itl94RswVnLXYRxW2jyzL\nfK9uq7rdyqPc2U80sHOUOv1oQqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBDI/D2rcTYWITsLZAp/Se4aPZFUwHwYDVR0j\nBBgwFoAUPnJ6kUjtvgB81tvBhb5bcqsIJKUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIA7hWcz019Pf9/+7WHhEjBL0gKAg\n2C7RrGaZaj9mMCeBAiEAzK9S1YdAIcbIAp8E9YFRK+0v1Vk42cIIZbwF7nT995M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAe8VK4qlkfi3ho5udBMvMWRlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZjBmNjJkNi1lYmFmLTQ3YzEtYTczMC0yYWQ5ZDFmN2VhNzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkheI82hL9f3ikzqSP5Thgnl9cPnI7iHARsDTHvkwSbHM9\nJfEYsxMedODGh9kPm353Pxeloq5Raqvg8u8EkPrgo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPnJ6kUjtvgB81tvBhb5bcqsI\nJKUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOpxtCtjNAr1JYhP9YOY5iGt+KeTXel3H/WwnsZE+/luAiAlWsxuYLBC\nKntsG/hG47J/Y0QdBRlpI+kBctixWtyzDA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXJ+5OeKdg75D+o9A8XgaN4eMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTcxOWIyNGMtOTU1NS00OTA5LTg5ZTYtODM1MzdkY2RlZjg0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWRlNmU4YzYtM2FiZi00NWVjLTg1OTYtOTIzM2NhMmZh\nZDg2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjh11iSyUPTEyAg/eVSyay1OZ\nPeb3pevVTBNBNjIvcEChpI1mRnohuwir9Xg9Q5MZu0sDsRHiJiU/e5ligDL1jKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQEMj8PatxNhYhOwtkCn9J7ho9kVTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22OHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEA1a6d86zs71hCg38zdogF1krVqb3Yt36r\nOvWJauyIpDoCIEl3bUUBxBOhlVys+4NnQuM/TlzT6he8jthdApAiwTsC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9264", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9264` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISATQYQAbb4US4eFtMq/7G/Vi9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3NjNhNTczLWNiMzgtNGYzZC05MDFlLTkwZjM0OTlkZGJjNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQxNjUzMTItOWZm\nOS00NjU1LWI3YjItZjAxOTE2YWU0MTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs70oCn7a0CJNzrP/Mi2F/r3vYa3sBupOhhFweSNJJdhqwJIIFAznkcK3AZtd\nacldzCnYqehBn36yUGr199Tn4qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSAC7zyzbAFZcGiJZRu8Wwcg+hPmzAfBgNVHSME\nGDAWgBRyYVtjhWFEfd2grFTIcxPC1UYGGDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCHjLJAUzluX+IBQjWKBRIKhdHtLxY5\n6d8oW49sucHU7AIhALFrMCuyq+p7s+YtaKCbBLWl67Xk/7u5nlWE0M7+1zVI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAc1By7KcXCt0opA5x+tL/OK/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNzYzYTU3My1jYjM4LTRmM2QtOTAxZS05MGYzNDk5ZGRiYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR2ISiR6SxGQZmVragjlrNUw2BN4dx07HJ1MRaxKSiuRXDk\nS7sS824m5ucRa9YDORae4q4OlWQKJiWdH/8/9dxvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcmFbY4VhRH3doKxUyHMTwtVG\nBhgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI3EYPGcc0zX0e3SptFkIpVckavRzZjUV+pN2aTwEdh6AiEA4tZH80cn\nAO7iYMKonpnPGSRpSwdQVzpsU1QGQkDT0u0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASsVHmOz4rgPm9HA98P+xhvgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQxNjUzMTItOWZmOS00NjU1LWI3YjItZjAxOTE2YWU0MTU3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGExMjllZmEtMmQ5Yi00ZTE1LWI1NzMtMTUyYmY5ZGQ5\nYmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjanTs869A3fzAM1v8vzTh/+l\nbiZc4EnZVEUOlMItotZU/5WXbmHxskUCtNZj17l4xj1X26LsNjWuSA+h3LWnvqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSAC7zyzbAFZcGiJZRu8Wwcg+hPmzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22OHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAY2JvOwtI8Q1BJWtwlN9vxJlwmMY/w6ULw\n8MFeRvgFIwIhAI7yY+l4Mi2GFwq509EVw3ddGoeJAH+1earmIPpDfeF5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9265", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9265` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeOcYxaQ7dg9o8uDY1zPwIGXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwN2M2YTM2LWZkMjAtNDM0Ni05MmEwLTRmMjU1MTJlNTA5ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRhNzkzMTItYWNm\nOC00MGRkLTlkMzYtNDIyYjQwMTNkMDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1XH+z6Os6Ld5oKM1QMn21crTyk88BcyopysLDyrA1dqchyQBOSmlAko1jlDd\n+7fAyRbwIdDGe7ZKN71EBl3AXaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUohXWtXCriPtai3fVgDmZwrUoyX4wHwYDVR0j\nBBgwFoAUPmWKnopDxcfYhrjBSnf1nwmHteUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICm9PwKfz70dqMi4nr62VpnTZkTr\nAA5fEz01wvC+rNouAiEA91CcdWtEw/8P2raYsX5ByoH4gqa2BcqZxiCX2/o6pIw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbjiCOG0iOVrAEslcB1RbnYJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDdjNmEzNi1mZDIwLTQzNDYtOTJhMC00ZjI1NTEyZTUwOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBmNR9z2oN8EVX7LC5U/Q0Ka9kUB7/NJLMOOhXsr/fISor\n/p9wE1zGxKWLO0YQWPLMrVHTgkd48S/l1ir8rK3ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPmWKnopDxcfYhrjBSnf1nwmH\nteUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgckJuN/qlw95gnGGk4ONLg/kcaFLP0DOHx2xsYme2U8ACIQDNNGZQ8RR0\ncnyosWyzDmA0HH+AirMsqotB8eSAEwgwTQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISASx3Q05RTqsY4+CCmWoQ3Ci1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRhNzkzMTItYWNmOC00MGRkLTlkMzYtNDIyYjQwMTNkMDgxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2FlZmY1NWUtNjQyYi00NGQxLWI2MTctNTc3NDU2NWM4\nYjY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuF9q/r0oKllruyYJyJPSNEuD\nQDeSDI71PZ5//4i+Egnl3YXAv8ZZt7RTtMLcTGRzWnZyQ7dGhBKwMxdoNdLcQqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSiFda1cKuI+1qLd9WAOZnCtSjJfjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22PHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAjBlfuI8+7aJAesuMa3FmjUSe+/yP5UOb\nxAE2PxYo4/YCIQC1QBzd5Q/qveNQjkxcv6TAF0sDuXQ/RNEsyBU9gOzwBw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9266", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9266` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdM56ij1w6Oghl3ipho65AqmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMzNTRmYmVlLWVjZTEtNDAxYi1iZThkLTU1YTg2MGEzZmYzNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I5NTZkMzMtOGM5\nYS00NWQ0LTg1YmMtNGE4ODE1OWRlZDM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUBlGiDKd4hxlcQcAjf0bi6PgYkzE/FWP+yvuHJG9YBsbSOGGbWnrBu1EyQEb\ng2L+LAKLCkuuthUtNSwTsZ+xEaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRNK7gyNP6PHUwZN108/05VheRxGzAfBgNVHSME\nGDAWgBT5tmNJZd+Q/XNAyF7LTqJJmkBQsDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDG64lD7d4aPkm/27RXvwjXTBWdDahy\nbkvP0yI8CfCccQIgZFICzf9kBoH3bm8T3xg2I6XYTjOJiJELJ61sw1slgIE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU3keCy8iQonNIEELeegf6RYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMzU0ZmJlZS1lY2UxLTQwMWItYmU4ZC01NWE4NjBhM2ZmMzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATs6zS1vqL5xvTfStisUt88vgPYr9/yrp4Hs1YbEvbGqSmf\nFsQqBLsKSbnOex7ieVZUqX7aM3fEIH+AXzGFLjWPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+bZjSWXfkP1zQMhey06iSZpA\nULAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVphBNx7SaoCmByA2EeekE8h2aH2QmBdjBChXSClE7JwCIQDch4fSgkot\nLDgW6lNwDxOqR3RjiQqntyBOCc0JVYegBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAcTpVGySxDH8efkkdPFWYaZMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I5NTZkMzMtOGM5YS00NWQ0LTg1YmMtNGE4ODE1OWRlZDM1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzUwOTdlYTAtOTk5Yi00NjVmLWI3MTctNDliYmU1ZTlm\nOTNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKCJasvDBp37mdfP39mcbbgPu\nw3mFl3T5C8Y4yMLBzBb6pkJo+ehoehsmM7ltVain3YlavW81jWPYgyj+tbdCRqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRNK7gyNP6PHUwZN108/05VheRxGzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22PHmJhZC5leGFtcGxlLmNvbTt0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAVW9yRHbkM7oS6eq7FFCG5qLhCgqTXFdje\n7wJ9w1QNNgIhANG5gCjVUHK6ZYf+JKDEWZoeIhiY6ql+VZut9DKR8XA4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9267", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9267` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYvrCtaCa616kZMugP5Al6+TMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiODYzMjY4LWUzOGQtNDhmMy04NDMwLWQ2NWZkOTc1NzA5NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJjNDM5MTEtNzhm\nOC00Nzc5LWIzODUtNjVlYWY2MzhhYWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEp521X0Lcw12I0j4bc7TSf5PdhLdeuU4ez16C/BVfIxHKJPehoZnsY0U8kLL9\nf3ASlxy3limlssJWhAbXPawa36OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkngpFkAz0ZnOZB7lFioSyWMOUhMwHwYDVR0j\nBBgwFoAUu6QwVkA+g2jFuK7HCalj85kd688wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCWl8wyWcPFdZnAliZfYWyl3kI2\nogCpYzReCHaip9P9tgIgTltqPkcFBi2PKvffJI8aBeYkDIT6Nr+JOym5vfw8u7k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ3t2I63/6402LCsNutU+WXGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjg2MzI2OC1lMzhkLTQ4ZjMtODQzMC1kNjVmZDk3NTcwOTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVpG0hQ57onPiBdReCJ0lPMNAEBe3RbQpiOKqkiihdoT7R\n9hDUjDX1Ah74ia7Cqi7X6TiOO6KrfQIZOX5O1cqao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu6QwVkA+g2jFuK7HCalj85kd\n688wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV+9+pgtOOy2vLPmsxgWldFY1fE9kFC2bd5co7tVWZNACIQCnMvgPPjfT\nzDHX/Q3sTk765bCrjecyDvxO3ouwyd5CmA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAcHLZy6zOoSmWDJj7ybk3N4oMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJjNDM5MTEtNzhmOC00Nzc5LWIzODUtNjVlYWY2MzhhYWM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODEzNzdiMTgtOTIyNy00YWIzLTg5MTQtZGVhMmYwZmFk\nMTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0IMEh0y1wMEIRVOSr4+sN8UA\nCkwCoNS3fITaqcK5UayLTjCG6dFjM5K29KinI685y3lel0lu8z5aAAETicFl+6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSSeCkWQDPRmc5kHuUWKhLJYw5SEzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22AJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAPOxm7SjGhj+XccxAigOCMYP\n7XdK0Mga8Ucm31+x2dmKAiEA4ZdOeYhwzOF/tWxDBbyWGX+0FjjjGBKqj4p1xldM\nb8E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9268", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9268` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAXbcR001EzOj2WY5YPo8KpuwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE1NDRlZThjLTg1Y2MtNGZmYS1hMDY4LWY1NWIxN2Y0NWFiZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWM4OTYzMTktZjg3\nOS00NTgwLTllYmMtZTVjYjI3ZTA4ZjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7yYFfYnAmlyEv/uQKFBSi6TceToblktzGUYG6Ac1vgCQj51SJ3LXknrF28HJ\nov70t5yKWtzdWADPOddgWklKmaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTsLIgKP19S1ue/DBgLuZcgiNGxWzAfBgNVHSME\nGDAWgBRiVGBhxLwyOO12XXU+FvQSxtCkcjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHRd5U1hCu+DeWC92g71py4f25Lk3VNg\nMlZ+XMZaoAS4AiA1AsBtUQ1tkU2wE5LJ6/8V/83+XT/IfxKyVartX7HmvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeFF1n8QPtMU1W3ZgyR/7GzZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNTQ0ZWU4Yy04NWNjLTRmZmEtYTA2OC1mNTViMTdmNDVhYmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0L+rWBFoV2YbnUGPoy39oHaOTyxNY0k3waj8Bg+OakyhI\n7uFvzEltQG+L4uRdBQDlxkS/Qj9SS9yVL/XKiacKo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYlRgYcS8Mjjtdl11Phb0EsbQ\npHIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJwJPU8vtHcGrQYtg4+tV92bEVU2gqCjTuIIt+WAAVNtAiEAtJoxMsDP\neEjSRWZJYXQzveiK8+/zCxMYnXcDNxsSDAY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISARhA3U6IfsJCn4HIX6YCDZDKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWM4OTYzMTktZjg3OS00NTgwLTllYmMtZTVjYjI3ZTA4ZjU4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTJjYTM4OGYtZTdlOS00YzM5LThlYjItNzQ1OGMwNTBk\nNjU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8XL23a4wCCXbOS+h0UnHdwMD\n7Y+rqBZhuwHBpWU72pcrEP/Y7SuErhskT7muKJEvp287Eo77ptQPiYaUt5Ea4aOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTsLIgKP19S1ue/DBgLuZcgiNGxWzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22AJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgOIKQj+LSjvyvFwYiQ0ugyJf0\nApvohBVTXQcHznsBXVkCIQClHjE4PHfkFl+m6w+/8UdVDDITaC8bQFEgSLOOamCQ\niQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9269", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9269` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfvgFr9kLG0RmfhCCY7PglixMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhMDkxZTJkLTFiNGQtNDRlMy04MmNhLTY1MzFkNjZkMGE4YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZhOTNlZTItMjU4\nMi00MTRhLTk2OGUtMDM2Zjg5ZWFlNjU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEP8XGHEpg0amY3uop6hWmvLjPEYS1exlk87vdIq6Lbgn3oMaMcRv/Lnd/FNsF\nxTccTzOjt5MAfXalDAFZ79cCpqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeLGItygaQGRZU96FKUUBc2wYVOcwHwYDVR0j\nBBgwFoAUTFsgalJqEMfL+y6zO3rS3tRmzE8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCcmJtdrfSQtdIuGOwnobAamNXE\nFoHvNVz15b33h9T/8gIgf95EYcpamTijhvFmkFA0kfrRfRy1RwI28q0zPNBuUck=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfNx7kdgKhvkpEYgouf+FQNsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTA5MWUyZC0xYjRkLTQ0ZTMtODJjYS02NTMxZDY2ZDBhOGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNRGTylProG7UuuIkszrD5DEXqZ4aH38UbM3jXAr3f9r3Y\nHE8k19QhXcoIFE8VjHX2KQPR8DKXepcyfYagthpyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTFsgalJqEMfL+y6zO3rS3tRm\nzE8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEuCL/dU+FQHDNyfRLqzgfpy1kB8r9hRLoLxuItYYvnICIQCmdZS1H3yA\np2/0Q1RH8mFF0V0wGzD+vPt+sa4h6pW7Lg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAacXB7D172K0yQPREEWZqrsDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZhOTNlZTItMjU4Mi00MTRhLTk2OGUtMDM2Zjg5ZWFlNjU4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzc2MDk1MzgtNDQxZi00NWRhLWE2YzEtNGI1MTgxY2M2\nMWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPGPN1yVZuVT9LsP4xHrEhSMd\nsEHKQ31E/BRdqFfoUDzEpta57A0Aq38X6re24H/VePe7r7AGuo/8VxY97liv26OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR4sYi3KBpAZFlT3oUpRQFzbBhU5zBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22BJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJhCjuDdr0GEtHET9LdUpM1W\nYszytAiDioZ3I1lsW3OvAiEAh5fU3+CP1KIrQAZGcKwEXdQkOnrmhThrz2oA5rMM\nNIE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9270", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9270` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbXZJkfPb7ZaAS4TrXyQxzDfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdlYWE2NjFiLTg0YjgtNDViMi1hNGM5LTM5ODMzYjBiYmVlMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE3YjUyYmQtZmQ3\nOS00MDdkLWEzNDItYjA1NjM1N2VkNzMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEwMwdQmcU8STwrWEi6KqkDNbPkf8h09feB3Ez++YY3wLNmvfx29jyUigCueP+\n0i6hesgAn0buFdx4/3mOzij4NaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR3Ji6T00pLr4q/2hMsXWEEJoAxzTAfBgNVHSME\nGDAWgBRVfRee24Z00chROaLARuWtrpozoDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGvxm8anLArZCw5p8juHheOXpp1BLmmp\nX3qlj0H239FLAiEA8kFORRrZ8Pl+E14C6NCetHCvwGanfBdtFynLG/hHyRk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbAY1fd6Sn11m/54PTJvmZeuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZWFhNjYxYi04NGI4LTQ1YjItYTRjOS0zOTgzM2IwYmJlZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQdxSkL3gl5ylJrozD7bpwXF8Sir4mxDsT07/nPa9QakYn1\nZ5pZxeJXRLCEddCprNUieAEsOlm7WoHt0M6yGYDEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVX0XntuGdNHIUTmiwEblra6a\nM6AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPq5p4isKHHCtGopejzWuoddjuhO9MxU+AOvpW6MmvGWAiEAz2mQ9PLV\nuyY4cLut5IwlSGZ+rup/In//xpiGvSqOPh8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISASkY2qc/27ZQGXmghydz+NPKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE3YjUyYmQtZmQ3OS00MDdkLWEzNDItYjA1NjM1N2VkNzMyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTFlNDA2M2YtNWE5OS00YTM5LWE5MWEtMTUxNjA1NWNl\nOTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEe/SchLSX2zsrXAD2YXRBacXg\n/8KA0QaOIgGcQTK0Md3K7M5/54r/DvwI5EHiiHE8KCJiycXp+BHm1DWIBoIjOaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR3Ji6T00pLr4q/2hMsXWEEJoAxzTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22BJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAO5rIetYYgK6xdgewDJ2ay4O\n/ZgAbZA0HXgumAazOIOlAiEAmCrDj0d5QgNqPksAo48JvtcP8TsSLD5B5oOxXxNo\n0gc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9271", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9271` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAQ5CLOIacQwdZGMm+CWXzqW5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ZDBjYjcyLTEwYTctNDVhNy1hYzBmLTBlOTE5ZmI3MmNjMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWRlZWNmMGItNGNi\nYy00ZGEyLWE3OGUtN2I3N2M4YjliMTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXAtwK5vj6Al1sxYgGY6zroKCDQtAYNTRZoPpEXECAwbfQVapPQoFf4ArC6rF\nfyAuRweFPUB96AYl/oqBTuFLtaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzoBhBV3lV4k25VoRQ3CwANMrB2MwHwYDVR0j\nBBgwFoAUMGkkVBTrad8TeoXBVRjnJM4v8Z4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDBGPGZIp4lZXajv8u0NwuozRmR\n/PQM+I2dh34YbEsB/gIgUptXmfZjPNnqtrtaEGumC566fGX1l9svS/SHUAC4mNk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASyTHuSJvZSTUfwloGGrYK82MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWQwY2I3Mi0xMGE3LTQ1YTctYWMwZi0wZTkxOWZiNzJjYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR8ZuHmFtNYBmmo2EAaefLSuW0TMpYcECRr/v37whum9RT1\nqmRk/RMuMLUbCpPmnWsenGIRy6XmVd7ukKpvxbrho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMGkkVBTrad8TeoXBVRjnJM4v\n8Z4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANAzArkGrpJ4KmlUC60N0RmYV1DO3FkeuaTaYq7Xa/0jAiAiuDKoHXzC\nHw5EMOfBx0M7LsYKowvInzLuiISpOAtPJg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAR/GyD1nRARZAFjQKmIklTBdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWRlZWNmMGItNGNiYy00ZGEyLWE3OGUtN2I3N2M4YjliMTJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGY5ODQ5ODUtY2Y3Mi00MTZjLTlhMjktYTE0M2FkZGI3\nMjI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+OlEotU/pL3D0yzPaL2l4qx3\nmCPIjYLOuYhIolFNRXPi7Ryc15Y747at3sLpXIZCaBL4S8WEUY19aldGwi38uqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTOgGEFXeVXiTblWhFDcLAA0ysHYzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22CJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgT+GcvSyyshEAKQ7Kh3P4PK/4\nPj5qeMxPED74oaVtf34CIFx1WswjH0ts5sLjXRaNAzG0SarDlSUTdYWJUmDd6MYa\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9272", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9272` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAT9BXXLyw87wgfwxJOISbqw5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQxYTM0MTA5LTAxYTUtNDIxMy1iMzRjLWI1Njg2ZDZlNDkxMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmY3ODFkNWYtZGJj\nMi00YjY2LTllYTgtMjExZjI3MWRlMWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbujcNn5Z8iwwpuUBIbnbXN3ObcqdtIsYOhtEiqXjYyzikdJIea8BIHzDyz+K\nf2dPe+c3JdzyArqeTM4wMhLed6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQUZHKqqT4agYlcXrABb69WYU2RwzAfBgNVHSME\nGDAWgBQu6p+c9/FWl2dAH6bndqQ6WBtomDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDERYRG6JAS4Ul/LTgHH7qzd8vVmaQd\nOJRRnrig8UWo8QIhAPI8v2U66aaSfHzQ/eG8VUXAygFiwAKsRWcyMOkX+VsS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAde+hSEBPeffiz6BKVQnA93GMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMWEzNDEwOS0wMWE1LTQyMTMtYjM0Yy1iNTY4NmQ2ZTQ5MTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQEnfwHVjWeJ4KAxJuQ1qDZ03Ll56MoZNYlqsCpJih8P5an\nnz06I3HuSRWkzIlamCvCceteFzEZOaeJ4XMqHC7Ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULuqfnPfxVpdnQB+m53akOlgb\naJgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNhQ0pMX1PdltHxnJ9haLd0+Z+DaRGP8hn7w5N6rZ+oYCIQCsGpBbrw49\nscYhSX0UKw/qXyy5VIwdN7afTAJl4WT7Mg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAYa/s2vD6KBs5HIzTbu3qzEjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmY3ODFkNWYtZGJjMi00YjY2LTllYTgtMjExZjI3MWRlMWIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDI3YWVjMDEtMDY4Ni00YTJlLTk4ZWMtMDcyNDBiZjQ3\nNmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESfXgmDbtneMTkO6xJ7nZmxHy\nT5Q797ENq9JLtrEJgop8bOdm3hjxQUOcFgOGUhToUbXfU3bq27z7R7TBjCECCaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQUZHKqqT4agYlcXrABb69WYU2RwzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22CJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMK/GlRHltcGH3S7i6SyEXyt\n8ktDo9K0RYyXviPYSS/YAiAnTXKFHRUsP+Y1W2wobVTmewUfAeIli0ijldSUxvjs\nag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9273", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9273` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAYQtD6MBscasFxSzPrXIi6oqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhNTI4MWMyLTBiMGYtNGE5OC1hMjI1LWIzMjI1Y2QyOGNlNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTBmZmU3NDAtZDg5\nYi00YWExLWEzNTMtNDVjZWQzMWVhNjRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEJSbhuw6BKo4ITP58g5KuGwpfMEzdYSAVP1sPUe5sg5/Bv71bfQn/LZgVgzle\ndFWOJkjZ4JvLg7cBAEUqCi3KjaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUk6v6RFr1rTAY0LsIMNR65f/wrMswHwYDVR0j\nBBgwFoAUH7j26azeHtMIQU/ZXAczUlfgbywwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBHdWs4VI8XDGJpL0aZqnRLcE5Mu\n4AYKydnUK4IdqhgYAiBBYO+eovATaK+YcGA1hbBRkFCqUKbrFspW++m8PXFzzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbEcr0YQlkex8bBaDjdZez0LMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTUyODFjMi0wYjBmLTRhOTgtYTIyNS1iMzIyNWNkMjhjZTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLoNnq8/4BnTEtDKQXPO2+QjhkQ6kouiOIFeFRV1buYGvB\nChdaO2iQB+4MEoJMhAZoonnN8wnir/PmRfl7EQlio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUH7j26azeHtMIQU/ZXAczUlfg\nbywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIo4I0OewpKzmbJNGE6L1jJ8vYPD67D5c8F8cja190dZAiEA3hUfD/CG\nxNlqzZ7rEfOav05eLrBxtNE6Uahk0uSsJ9A=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAcIPmsNeUsl0Co8WAfjHV6XkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTBmZmU3NDAtZDg5Yi00YWExLWEzNTMtNDVjZWQzMWVhNjRkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2IxYjUzNDQtY2ZjYy00NjEwLWFkZjMtZjdjZjg5YmRm\nYTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn0U5v3ff5qpn3ozFr0tSsU53\nCyKroSOvhx2W3/76fRfmbH1guYiHs9IgiTmSW2ZL4L9IIHHv9/yKJxEtddJ7g6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSTq/pEWvWtMBjQuwgw1Hrl//CsyzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22DJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgPKOHaSXs+WPTt1B/BMA3aR4e\nrLqBGwxtLKRDQskTnbsCIQDYDA9zFRUIGhchkxg8KKpsbjGBzQJQnsk+m81gpo8l\nrA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9274", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9274` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAeRlXx73Mk8zzmXAAquSV73SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiODRkMzA1LWZjZTgtNGFiNi1iMTJmLTI3N2ViYWE2MzM3YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWIwNmRhOWUtOTg5\nYS00NjE3LWJiODAtNWUwODFjMzhlNDM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUB+YAsfhN0QE94Ku+jHNamVckYbqyfWjIXEqtHhRgB+PmaK8kHXN+tiAKkEz\nnreQR+ZjFfBH04zGntsWvk1CKKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR3IpEltMtXvRkABEoxx+5MX5uP2jAfBgNVHSME\nGDAWgBSngc0KwnwtSV6xvKgqrmV9a13WIjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIG7Xgvqiz92zsng19idfZSncLJGJ0uxt\n4lier/jnk3/hAiB9cJkiTpJZtkitIpKYHwJaLuAHs5vxQXn9IpdInMyWXw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAStMySIr55HnjiOvmwiB8x2HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjg0ZDMwNS1mY2U4LTRhYjYtYjEyZi0yNzdlYmFhNjMzN2MwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT+IHpSKJf1Gl+RsE6w+x7KmGXKNpAKQ0jgAfAdwmx+8d9R\n7ZCNUpmsVAn174khsSo49LUjzYgvjBKjLn5vixQlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp4HNCsJ8LUlesbyoKq5lfWtd\n1iIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANFTR1LtoLEVNHfRwq4UBAu+X5NMFO9kMKvweEcjMtpzAiEAgVyea0aR\nMUb3a1gCmHhfo1rMt1196UgPsy+2sqbpBuw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAVSSQfv4+NqfLYvz6QTkUq+NMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWIwNmRhOWUtOTg5YS00NjE3LWJiODAtNWUwODFjMzhlNDM2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjE2ZmU1YmUtY2I1MC00NzBlLTk1YjMtMzI5Zjk3Nzcx\nNmFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzhp4T8yMTX8GB/5sz/UpZXj+\n26x6YDozD+nv+tPH8ofGurilZW8u1cHx+hcyzrpYz8hh+qazEBMEttaOMYydi6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR3IpEltMtXvRkABEoxx+5MX5uP2jBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22DJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgCzF1IFa6ze6C6Xk/NDV6vmT0\nCNBsBLvf37o2uKcPXagCIQDZ7SsUkt2svNKevBdyUifZoOsPP1oNE6Q2APkpkKgw\nyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9275", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9275` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAUTlffgdXU5gBlt3RQdsFTUvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdkNjc1MzU1LWFhOTktNGRkMy1iYmRmLTJlNTQyNDNmNTFmOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I1YTRkNDAtOGIz\nMS00ZmQwLWFlMDYtZWFhNGEwZjc4MTkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKq4Ju32igUsTzusa74eZIdBFsuM5Vwl/OqW00fdIeUHs+joJr2g/UwYHcu0I\nJ2dVZKrDVvi7Z4yowVswZ95zW6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgpmh07HpycY0u0KFT4rV+a0teTgwHwYDVR0j\nBBgwFoAUArbDWz+lZ+kSm8OtJfH6/+pAeM0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCzh2gfT1jMDnQfDXGS/bJz5+iq\n0WEciwQWmHhPsxHSAgIgdSyrMDdJYCu1ju6P30lqxeJ9NYI/FXMtrVu05N0U38A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc/w6dKUxK2BfiiPd0DVj9FhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nZDY3NTM1NS1hYTk5LTRkZDMtYmJkZi0yZTU0MjQzZjUxZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATRTl41c+Px74fv5mogHVlpe6GIQfYKs5Hm0MDMIDc3f34D\nEjOXuQZK5Qq8cKcLfaGy9mmE9Kl/T4pgHN06wx+wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUArbDWz+lZ+kSm8OtJfH6/+pA\neM0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfU549ZUrFpGrj6MhXQE4d3Z0SJzz4XEb2k/wDwI9T0ECIQDGTaox1vc2\nBIJDfpgyjk9MYqYwW7cnTA/wuSvJpiTP4w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISASKW1Ia/Gv1OLi9PqhK7yDCjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I1YTRkNDAtOGIzMS00ZmQwLWFlMDYtZWFhNGEwZjc4MTkxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmNjYjJkNGQtNzEwMC00ZWJjLWJiOWUtZDU1M2EzYTA5\nNjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESLh/BoI3f2q7DFmE/OQ8yqjn\nqFWlqP/6aBeOH+u4ubwdnSicGIdCkTQjDiewQZXDv5Marvn+CepqcOtUGF37WKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSCmaHTsenJxjS7QoVPitX5rS15ODBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22EJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALegVKYH9jNHFLtS8LFUtpXt\noK1unhLDX+OkScSiVvPRAiEAwQmvQWT9lFDGlZa5pzU+JldZ5tOtZrHPVatByKYz\ns9o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9276", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9276` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcVr/Tn5NFnRPM8oeoqvc1g+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY0ZTM4OTJiLWI4NzctNGJhNy05ZDIzLTZhOTk0MzU0MDAwMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmJkOThkNDUtNDcy\nZS00ZDhjLTkxYmYtMDE5MmUzYjIyMzk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEegg8FBxZ+Fsl9GlbqjRlQW1p9k8ZtaCu9HlMQ+UNu+9hvVJ8FiN6oZM2GgZd\n7UqeZ9qSjoWO65xKRCuI+iBo9aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQORMyHP+d9oo5ip8ZXbjlWUQ8KDzAfBgNVHSME\nGDAWgBRrRoKueujUhiviU+7qcxAcN7C8HzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD+lP3Ihh5DsjKOFzFHMUTrMp62RfrA\n2oG2nMxssfItRQIgXaJiRmxHf22d1oo78t9F6nTNaW5lGXVTKxOrR565PSc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYkq0Ep6qmajRNCUZdO0Oy2VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNGUzODkyYi1iODc3LTRiYTctOWQyMy02YTk5NDM1NDAwMDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQIUT2VZ66cRmISi+4x7GmQm+bVj0I/ZpDoAZMb6+kuLDEg\nkx3XWQ7mvoSZ7fi37Cid27i9U3t96by6oUt7Ys+7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa0aCrnro1IYr4lPu6nMQHDew\nvB8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAN3g1LIZ4rZGhnKVQYd8B8DvHXZIrsaYmJq2ieMSu3IKAiEAgAFBLEN1\n/pRVBq6ROsfXSQWJafrEpGMHhVeP2fnNF5g=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAScR2JGMllMLTErkE93M2IxeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmJkOThkNDUtNDcyZS00ZDhjLTkxYmYtMDE5MmUzYjIyMzk0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWFiODA1NjYtMTRkNS00YzM2LTk3NTEtZWJkMTZkNWIw\nNzAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkkgiE22/II8ty58Z6Q+ZEnUr\nh5ln4cxa+7rPREwkPH3Tn24svb0N044HhtQlIxSA9YSmcp7bO6kui4xmaikDdKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQORMyHP+d9oo5ip8ZXbjlWUQ8KDzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22EJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALTVkH0CvbvozHFToHjZLpCH\nHaec0ezWK8AgFzdZPLqAAiEAsp4XXqR+oxALLy7jjPkKlJhZ4yTTdUVXSPWD6yUl\nwi4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9277", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9277` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAV3jr8qaekAgy4A2663zKmUaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZjU4YTA5LThkY2ItNGQwOS05ODg1LThiMTQ1ZDk1MjAzMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTM1NzgxYzktNTUz\nYy00YTY5LWI1OTktMTU3MTBkMjE2ODhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE58MRa+Irno9gB2al7AD2gRpxnSjmrLX4xO+niGDZxd7zRhvOOdEsPbAY4lPx\niQ7NB9AWVJxKIBdJmV/VcixAIqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiQWbIuOrHFQcnP/vBEnj2nRiMvIwHwYDVR0j\nBBgwFoAU8B2MGY0TaFiZrXON3/n8M2xOXyYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCiWPCUL5jNt2Y5CQ2hVRmqR2zU\n4RFFVignn09uFKHH3AIhALWisdBMQPFyO7B4RRGjoIoQU3fw6R9ZQ2bDDJMMuyAz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXUtbOtsq9Zu4au09chwoCwVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmY1OGEwOS04ZGNiLTRkMDktOTg4NS04YjE0NWQ5NTIwMzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR7P++52deoPJxXheFGEu3d/4LW8UPGRYHlYHh1TF2H0MN7\ncDrJGUzf+pMZ0aupVkYSml7LcLw8lX0dQBg46UiYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8B2MGY0TaFiZrXON3/n8M2xO\nXyYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPUhdhzKgNiSa5Q2cuj02IHiUmRu9YtC7dHIkHyI+VmdAiAYd4Sd/1jU\ngSJDLj9tUhUePQHZbW8XoLx4MpeaSUb88g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAXOlW/88FEcojKxHextfZiZNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTM1NzgxYzktNTUzYy00YTY5LWI1OTktMTU3MTBkMjE2ODhjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjhmMjNmNjQtMjZlYi00N2EyLThiZmEtNzEzNDZjYzJl\nYzc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXtx+V8DGNBztiXttfjOSnArD\n2SaVgx9qGgOjgK8pljWROdSvOAb3AxSXCDjRyF0BU7sDc6xyn2qOzl0S8AVMgaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSJBZsi46scVByc/+8ESePadGIy8jBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22FJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgd9eKNu6153zxgxvtIzj26tOM\n5XgPmLqXI+r2nlWLy88CIQDbiwEW8MNz7vZBwii4AN01gP3C9q/jewgCNrurim2J\nwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9278", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9278` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAS9qGvqO38wXGtsAYYbHQPS5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2MWVlODgyLTExZGQtNGViYi1iYjI0LTFiY2FkODlhMzViZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWMzNDRkYzAtODdh\nNC00YzQwLTkwMDItNDEyM2RlYmU5MGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELG77XTcB3/rY77LD0sJny1YGhdxeJ3OhitIBZy01oWnei/F3Bw3N+sKQ9JqH\nke0PF5WR+7cZ95BMNntmNgSsDKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTzFExK6EzTAx/ym2s4HmCGVCc4PTAfBgNVHSME\nGDAWgBTbIWq2Fsv7Le6nddqr63NBuJO5RzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAU0TmDb4Otzx/t7VdJ99mhzFByxiPNq\n2Vx8LVt51fgAAiEAlqwi4b3Ajn2M/GsA/NhZQhIbXFiVvqMCHTrBptSvwBU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdemr1XmcdtXPrGGXwPZBs+5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjFlZTg4Mi0xMWRkLTRlYmItYmIyNC0xYmNhZDg5YTM1YmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBgwNDBKm+ISCZyDOXaAGLTUAdEcf1UPjuvOX49GU9UQ1E\nTDJsvrYKHory9PGoX5bZm3xJcsFeV+5xeSplaV0Ro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2yFqthbL+y3up3Xaq+tzQbiT\nuUcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgecDHgLbjrr9Pa2S2hS2yABLCV06qnHnCqvO5WX/JsZECIFGvyXPaZnG1\n5DySJiaDAlVXZfYYXDwzks/gJ70akn0m\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAbFJBwW2eaPLMV5u1cC7bBmQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWMzNDRkYzAtODdhNC00YzQwLTkwMDItNDEyM2RlYmU5MGNhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDZlMDRlMjYtNDRjOC00MzFkLTk0OTktM2ZhNWQ4YmYz\nYmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELFf11KSidhNfHRGwIQ7OMUoW\n2pfeLbGE30VCmC4scqQs4wEabRskGRXYSFX+HXLkAiE4wV2409KP+SoBTQqmsaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTzFExK6EzTAx/ym2s4HmCGVCc4PTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22FJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgQkTh2EM6rYuKCfrMoYXz8VaS\nnZt7Rc5ycW4i4YeDcvYCIQDXq/th6d6gIx/jnLWrPfB13TNv16XXrwasCoVbebVE\n6w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9279", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9279` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAWI+REUYOF841yeJKyIgL3t1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwZTc1OTRkLTAxYWEtNDMwYS05NzA5LWE0ODAwNWVlZmVlOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE2ZTRjZTItOGY1\nYi00ZTczLWIzZmYtZTgzYzVmOWUwMjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqkv3NwYAZc2ae7/43cMC2q4fQd/JfVGJN0wVyQmXQIZJlCVL3l91viAQtNzX\npe12KwOE60RWuBGxHbCUbSc7PqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAHmIjtDPCsHKyjO4SqmMswayJl0wHwYDVR0j\nBBgwFoAUKKOlLFkzUq4QPCD4uVwaGipJx0wwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFbwRwLrZ5p15fXTZ0DwW9IrKi/Y\nihYdpEUihA8rxRh1AiBVMM81K8Fm0jOjj7MMeEFltLpQv05ibB9tdNaP8R0Uow==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAYqJMewBQyrj9HcMnyAQe+1OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGU3NTk0ZC0wMWFhLTQzMGEtOTcwOS1hNDgwMDVlZWZlZTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJaa07DIPlzpcq3N0uDEeF2D4BAg0Pgw8Iv/KyZYVAJsoX\n/M5m4H7JQ9ZoDyycVJgjpEHuFDqEgV0XslzrQk9do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKKOlLFkzUq4QPCD4uVwaGipJ\nx0wwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVQm8hnFJvpUDtsuV52OSprRxF6Oq4YoxjdykwKLUh4YCIFKk+VTMs7Jh\naBT5vULDsvMdSWyO2R7T5uxUlYaQXIgC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAbxqruOqsnSIZq96P23N83xfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE2ZTRjZTItOGY1Yi00ZTczLWIzZmYtZTgzYzVmOWUwMjRiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzUwMTNjZDEtNjJjYy00OTkwLWI3YzQtODg2YjM4MzJk\nMmI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvJ1STYLXgL2nJs1svr5aLM/f\nxkWFJoQn+S228AvMOl+z6YIMnTs+aOywH6gq0LdKwh9t8c2ozcm7wtWVpCfxE6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQAeYiO0M8KwcrKM7hKqYyzBrImXTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22GJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKUQ5ob3XLjkRyhqcA3vitv+\nWnNDRZyoRy9Ngwjl8a4rAiEA/AlG7qDOHeiDkVHpb/x+rI6prCl8NyhtwWfzThvR\n5+Y=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9280", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9280` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAf2p7eJkYnmhkv0dDkLf3EcrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyZDlmNDI4LWZlM2MtNGJhOS1hMWM5LTQ3NGQ3ZWY2NTgzMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGM0MTY2MjgtODc5\nNC00YWVhLTkzNWItNTRjMmQ2N2JjNmIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE45OvV5kkuGxzyOVDmCuEueFbcl81u83CV+kpADh7t408RkR8nInxjFmCN7ok\noihCRTeMg90Q0mq9WoFSNyoUJ6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQz6Hc5quguEsCiov6FM6ICQF0I4jAfBgNVHSME\nGDAWgBSDqIkMbb7617ydifxL8Dd86N+yTDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICMlpfjYgctO5H3KIMesDl0j/j6cyB1z\nsjmU3SQb1e5CAiAJbnWk9RSA0yI44vnppwGmd1QQkN1bM4Py1cBGUSDW/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdc8p1SkYsHR0KYwBYJIk+KfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmQ5ZjQyOC1mZTNjLTRiYTktYTFjOS00NzRkN2VmNjU4MzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ7sod8KlJ1k1PKDO9JitKb2IbSTuByYXFFf0zCZsTL1t2D\nbVVqOgZK/xFI0sV670pJ33iYhGp5t7s/OG5IUMUzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg6iJDG2++te8nYn8S/A3fOjf\nskwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIn3aHX9jxTfXOiB2QmJgZPlawZ85j0lkOs96Yl9vuASAiBOt7DXg/Wa\ncO8ScP/s7O/p7yKb36glIPegUlYyfFlusw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAWPOSLGuVY+WuYsZW1XggyeRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGM0MTY2MjgtODc5NC00YWVhLTkzNWItNTRjMmQ2N2JjNmIxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTU5OWY3YWItZjNmMy00ZDA3LTkxZTctMTk4NzViYzc3\nOTljMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXAzNE/2qsk4/Hvv//ml+7eO2\n8xTNQZEezTIiyZJ+TVksAqHgfMXahhxmxeesft1Va2+A+0+juI5O4IcGtgL9EaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQz6Hc5quguEsCiov6FM6ICQF0I4jBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22GJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAItnRj5OaaRGSGJNaKozQJMl\n5V6ZqjkG47GS1KaftMvoAiALPTwyFw/5YcuVgZpdUaB6t7j9XQhtWDwXWj0o/h0B\n4A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9281", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9281` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAbW4nFpH9JofVpvBw9eBX8WzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2OGJlMTU1LTVlMmEtNGQ1NC04ZDIzLTU0Y2EwOTU4ZWQyNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjJmMzQ5ZGYtMmVl\nZi00OTUxLTgzZDEtNWQ3MDVkNDNjZTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbPyBgjibuejFwoN0IQLNRGHWS9t90UDjsqaasTQvpABIAftY8qrumMn9WrIR\nO7wfVjKeGlKl7hOdsjd66y+QFKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDsHr0Ww4LBdlP0u0aFZoVFTkFOowHwYDVR0j\nBBgwFoAU6iPEOrzUhHGaOfRyQP5utECAVZUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDuY/E3A2mXAQYo50P7Nv9cn6f2\nLgceFLNPnkm71vdOvgIhAPN47g+FuesTDxieA8scqXSmtLnCoI7styxill5EZ4d/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAWogiEc3Cpp0qysBCk1pjHW3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjhiZTE1NS01ZTJhLTRkNTQtOGQyMy01NGNhMDk1OGVkMjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARCUwZfEsS4GQPoi0l94seyyMJ5cDzIzFt07E2Gl72F22jP\ngwkI45XxGvbEyKsRn8UlnC1WGK+42GN78Euw0KlIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6iPEOrzUhHGaOfRyQP5utECA\nVZUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEQfG5HImyqcW5yBCiht5tqn2zRkwu5SkCJs5dJvou2QCIQChNTuFeeh+\nYd0EF3KQpoYhsbef7ggVaDCATJckI6RXPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISASjvKXnrx0fxmuip7XivZpq6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjJmMzQ5ZGYtMmVlZi00OTUxLTgzZDEtNWQ3MDVkNDNjZTIyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDgwZjc3ZWItNTdlOS00NDE4LThkMWEtNzZhYmQ1NTJh\nNGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvx/923oBzfuRgGr6LE0CyZDX\nTFSIaaJ6yIvRxprGq2HnWJL5kS5p+MX7zDDfDkawld/ijg4pa0e56wlxynb2l6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQOwevRbDgsF2U/S7RoVmhUVOQU6jBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22HJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgBYWU04IclZpqJcqIlkgBWbED\nd3nTARSiHCE7mNZryTUCIBhlEcLvWWSTgFC2WnqSUpDNIkQ0EAtjqgdPjZpv3/FW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9282", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9282` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAScLFxXb+s6mvfwADatisztgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjYTI5ZTZjLWYxNjMtNDE2Mi04NmY5LTlmZWQ4NjgxNTUwYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2M3NmQwMjYtNzZh\nOC00ZDVlLTgwZDYtNmI4OGI2MjcxNzBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEq/fND1sFqfzLG8KPLnRsO1dpS3xMu/ahdNFi0V2G22O7J2vOzUb2OflX17zL\neIr+ZuJ5OnGaintsv1kv0nujHqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQitwHf/ZSlcjo57GqlSOEoWejoSzAfBgNVHSME\nGDAWgBRYaUjQWu3VfMEBbA01+aXfP9BmvjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCIDVWw+Zr3d1A+JBpN9JLks251wt4D\ny1HuJm/adiIUAQIhALzhodCx4nj+C2N+H1EHv2Dan68dsf9d7netAwesOk7+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAddZ6CXf5px6RXshENyhlrWVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nY2EyOWU2Yy1mMTYzLTQxNjItODZmOS05ZmVkODY4MTU1MGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQnjsuC62g6n62HR2eMk6mXFgODcC7akJUMOcP+PGQxrvfQ\nUOdm8/KGph86vlROwHejB8QBo70TTif02rUjtj2to2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWGlI0Frt1XzBAWwNNfml3z/Q\nZr4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF86hPnNnh/wv4XbmzKc4FNpokWTuMEqiuBK9tQtEpBICIQCOV5emE2EB\n6MK9wNP8FninmNWMYKaGMSTlgr5Uu6MuwA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAV56z+8A6tJQi5D/htJdsn43MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2M3NmQwMjYtNzZhOC00ZDVlLTgwZDYtNmI4OGI2MjcxNzBlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODAxZWE2MGMtYzcwMi00ZmU3LTgxZjEtMzQzMTljNDQ4\nOWM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwbbkJhwRsVcBj+4sLB+ndqD7\nyWGd68z4uaTai8Ss6Yqn/xtlhfm1Rd4bwQ3gSI0H20yB6uW55XJDw4mCBKKEvaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQitwHf/ZSlcjo57GqlSOEoWejoSzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22HJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgP3xzNKzAM9wSmJMw1zBUTjZD\nJzyhjIboz6L8iHFfewMCIQD1STVjN9WUtRH2pB1fTSmax7WkuZ24ktnsDDEx/HrQ\nKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9283", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9283` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAUIpvNURro4go/N1O9vnOUGAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlMmNjNjQwLTE5ODAtNDk3Ni1iZWU0LTI3ZjY3ZjRjYTI1ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmUxZWY3OTQtMTNi\nYS00NmU1LWJjMjktNDE5YzVjYzJmNTY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE23JtshVsY4UuiKRAY9DWOvykkX5E7pZvOpBLr5jP1GaR8ArzqILvdr1lPeQI\nG8ovqNfO0XOnyKJdZKMpocVLYKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUceG1Ke2+ea7gy80QxFExOOtPq24wHwYDVR0j\nBBgwFoAU5r6cT6d3B3zhXjfBMsh5zid1jV0wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCSAAbFx34AsvjmAg5Aa9lQH16l\ntcvOE0h5XFtScDlbLgIgcX5zUxMPyeKQrSK9QrbLqaZN0d2W627sJVfTtbcV7Wg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAb5DdsT5914xevICkv1PXSIVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZTJjYzY0MC0xOTgwLTQ5NzYtYmVlNC0yN2Y2N2Y0Y2EyNWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPDAheqzxt4uA2tBJUfgvKNVaF0aXDdhycZE/noulUqL7D\nXYsZF0FHHh/aIooJDomVxgQPHqoAkgs0Wi0kkGT+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5r6cT6d3B3zhXjfBMsh5zid1\njV0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKnZHaSYiUQtOwtayb2Fp7NP8MeIkOpPZzV7HZnW458lAiEA09DM6h6Z\nab0QfR/4V95vRAzwc4EiofC7Q+G3VrTssi0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAQK9FcMwdE1QKQhmD67UIGhnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmUxZWY3OTQtMTNiYS00NmU1LWJjMjktNDE5YzVjYzJmNTY0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDQ0ZjI5N2UtMTdiMC00ZTRjLWJkMTEtZjhmMGRhNmRh\nYWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBuDMKylevr82YfV1uTVQmWoL\nsb5U1KYCglTf28k4Vox1ePH+4N+/wxKmgkTgxZOPe6sm2zaDZhOG+PjclkVR8aOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRx4bUp7b55ruDLzRDEUTE460+rbjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22IJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALhVwwOOmeF0+MiQJiHVL8VU\nsVc4FywJM5JstDbGePSdAiEAoIZSfEKgCbCCgCgpheJ/iChIlqm+YzFtmFMx4ZXe\nSL0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9284", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9284` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAWEyl+huIerDB7IIUR+L8oslMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMTViN2RmLWU1N2UtNDQ1Ny1iMGUxLTdhNDQyNTQxOTYyZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQwZmE2ZDYtY2Zl\nYy00MzMzLWFjYTYtMjU0Y2MyZTZkZGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBmndAflR1py1MiFWAZMjYAxMrFbul3SH+EtzAV+KeytAWf+2+04Bt5ybpuxN\nwQfRK293VT7MAz1KMprYRlW8IqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQxTNTQgmm9A+Mi5nzCthPUU3bwQjAfBgNVHSME\nGDAWgBSLw4xbJvIxKrImWqIHsAKKTGAzYjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDcY3esCsp9ms5YCKpZdNF6FZRrMHdd\nIilbFmGNXeQsawIhALUjdUirn9qwcZ3TETQJGMjNtj9Hj+SLMhH5ADj54M62\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaCGEBENiKpiQyYWg78cQlEJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzE1YjdkZi1lNTdlLTQ0NTctYjBlMS03YTQ0MjU0MTk2MmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQfOc/Mb7AvEFik310CD1siqLb5Ws2fLvGH89QVnB2iHp+A\nhDn9yher0/2ILxieM94gvzrGjDVQCvHU67lE+ETRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi8OMWybyMSqyJlqiB7ACikxg\nM2IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPWmE06/ZdqtWIuILhBIEGGGu1EfyDjYL53WqZUwr451AiEApHsbFBgk\nUu2dEaXgoILQT7Ok+yRa2/lhah2DsugD3KY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISASJKz4FKKHYgszfRMIYGt+fGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQwZmE2ZDYtY2ZlYy00MzMzLWFjYTYtMjU0Y2MyZTZkZGUzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTkzOWRjYjMtNGUwMy00ZDVhLWFiMjctNzljNzFkOWRm\nODE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfceAm3ROJT97wcJVed9g4UEr\nqVub2XqBGdHg56nVZNrwkfo8oumKcwE9bf/KvFwb6PptjGdjoRDthb0m7GVsaqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQxTNTQgmm9A+Mi5nzCthPUU3bwQjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22IJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgXnNlA9pWvT74qMof+GyTOoV2\nshOhMrmIBW6QwO343YYCIBtG4Mfm0nUWnz42pPtwSlZq6gta4KPvueZGcwty1PsP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9285", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9285` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAfI8HyuxWV4RH9csZ9O68VCCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwMjMyMzljLWRiMTctNGY5ZS1hYjdkLTAxM2JhY2MwZWYzMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTI5ZWY3NmQtNDQ5\nYS00ZDcyLWEyNmItMzczOThhOGY4ZGMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEuMBHss/vg2QRA6L5gZ3Zd3Xn/Pn50nyrKGshrhjDxGeRr9LZbXYn3Pui85Mv\nDCa7ujIJQjwFe3miysPKIN3DIaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU65IBtHwEFt9uN1NBicV60k9mOsMwHwYDVR0j\nBBgwFoAURfZOhmEz4+7dIKKp6Es+9qKf3JcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD/fg5Fd106lmP7nkHnWJNilFFX\n8SBiRPzpUnI3iFE8ngIhANeJ5rogo98OOAho8PqXAN4WprZult+QVEEiegLQO5yv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdoOVuTuX4lu/1FtzI5x8PghMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDIzMjM5Yy1kYjE3LTRmOWUtYWI3ZC0wMTNiYWNjMGVmMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASVQ+NsjrSVweBl2cZxkIZEbmGRUqpWmxmX4DihSVl08ZWX\n9Wk6OoNEZjw7tbQjY34Xo6KiAzzDnCCGYldfKXCmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURfZOhmEz4+7dIKKp6Es+9qKf\n3JcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYUjuVN0Un2Y1pmifJtBxNMLWOj14n0nQbhx+ivOq0cUCIQCZrhGOkr+D\ncW/pEDk9raFx/i0Sy4jAeTph576+WvxSLg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAe1frVGeXMOyFJ91GG8+xg8tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTI5ZWY3NmQtNDQ5YS00ZDcyLWEyNmItMzczOThhOGY4ZGMwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWJhMjM1ZjAtOGNhYy00YmQyLThlNWEtYmYwMTQ3MDk2\nMDgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYnjQ1qP88XoqSHefrHemfnGj\n33fyT9OVDvrIO4QSFh/L85ZdyuoIbteMULnBQPDrkuEqItWu2m1oaT+dXVTSiKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTrkgG0fAQW3243U0GJxXrST2Y6wzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22JJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMDyQzk7dGjsMhWfkDjqpOHj\nnEWKNseQ1lFIdk0fob8eAiEA7kzkyqW886BtKwtmURtxygVBmVL4YbdOVF0oHapG\n4oQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9286", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9286` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYOX54PqK8jmACZPWfVzQay3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3NzYzYmE5LTY2NjAtNDViNC05ZmU1LWNlNGFhOTdlMzZmOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWRhZDM2YmEtNjk1\nMS00OTI3LTgyZDktN2Y0ODg2MTI4OWY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELQ4Atemjwg3kCtPtwuNqqcBm9S1lmpStRXhydupEjPbfAmctcn1uvgtdTwFd\nGdfXgvAVhuOWJYpl7M+2xr4OQqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRggKcal0l95ZmzavPrz6ppAyC1MjAfBgNVHSME\nGDAWgBQXjpeE9Noqf+o8Pm/aEI9HUt6QNDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEqaSJDSJ44820/LjeIGKbs/FqdYnNzA\nkBsZpTK+eR7qAiA+zTrW/EVaEB7aFbr/G58pktGCXGy3mWNepocszWyFkg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf/37fiJheWSFCulAQs+nZ+7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzc2M2JhOS02NjYwLTQ1YjQtOWZlNS1jZTRhYTk3ZTM2ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASEIpjS+nz/a0T5U7ozREThAiAAIKLAtgMTN4gf9njIgcH9\nP4yPN1eLTVjwJy1ObfYjM/Dw6sH38zCkyseEieeqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUF46XhPTaKn/qPD5v2hCPR1Le\nkDQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPK7RZbegehYsM2Qdy/mP5AvhT0jfrEXRsKAs71w/tlIAiA5bk2Egvdn\n9IO3aglQPqz2K2GziH1Kca1AcX+OwATRdA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAUhzUWkreHjed4/uS2Y6JU6GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWRhZDM2YmEtNjk1MS00OTI3LTgyZDktN2Y0ODg2MTI4OWY4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjk0MzdlNDQtZDk4Zi00MDgxLWJmMjAtZGFiZGFlNmQw\nMTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyq8p7PI/ZRH2ytaFrK0UJ2jb\nIXXpJY6VAjQD01LGTNY6ALAW3IW8DsB+fOHY9DqvHYFKY7UzGUFgDmlk0MQQjKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRggKcal0l95ZmzavPrz6ppAyC1MjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22JJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgJXJvUU2Cs/DGemxpYtcx33EJ\nLS8eQjg7Lp3RYd3Tnk4CIQDJg/YUQYgz0u6P2o9C7AZRulE3vJ05rCQZaBsktZjc\nFA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9287", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9287` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISASTWxjGIQAD5fEtQ4HtjYK+iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwYWIyODJkLWYxYzMtNGIwMi1hMmZiLTUxNWUzMDFjODc2NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGI0MDNmODYtMjE0\nNi00NzY0LTllMWItNWI2ZmIxNDg5ODcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6wsPTCEu3NWmj7bmhLLFXxRJXGGXcDOxdo5V83mZycy0UOcUWiGoJ67IszaZ\nlyco+QniUJ9tcmCTcdtLO9ynm6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHEWQsG/eG+4Suh1fnZ0HFmQbVSEwHwYDVR0j\nBBgwFoAUe2zicDgEn/x8f5WjCGYeA8wYLSQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDKGCIlWfQkoNi7X/g7XaGLJ+zDe\nZZRSgVjZ9dVG5IuXAiBSdpUhSHLaHSAUajTrPgioWYEHU12IFEapCIPfr0t9eg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARZiDJfQ0LaXuiYSOYfCAHnNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMGFiMjgyZC1mMWMzLTRiMDItYTJmYi01MTVlMzAxYzg3NjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQqUSEbdYAYRTSSrVtzBnqyBk8Wl9DcChaDS37vPmtanKd3\nwQZ8dGR1EBzzUzJuP6au7mx7A8++ZTm7IuvYl3kMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe2zicDgEn/x8f5WjCGYeA8wY\nLSQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCNPPWJuflbZKogu9c8ITK12l90pdet+BQgo1DmhM+AYCIQDHQ1YAzuU4\nlLO91nEksSTOcZWTzJS08kNUNe/1uVdxeA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAcOpp+0lCdrbOD7EDUgXknLjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGI0MDNmODYtMjE0Ni00NzY0LTllMWItNWI2ZmIxNDg5ODcyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWQyMjIxYjMtMzNhZi00ZTNlLWEwYjItNGYwZDVmMzZl\nNGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZtCEhjGfocW/1GfM3Q5+sRRL\nwQXSvLcxDlWcsN7C28LK+MCiKHwLwPDpiDPM97gxZsn3HT/+0NZCrAWdL2sGH6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQcRZCwb94b7hK6HV+dnQcWZBtVITBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22KJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKh5ag5BBXofhGI6Tu4T02tp\nkoo9Nl2SSY78ZSvnNFCHAiBffMMGk3TV8UxPMWkQPHJVN3i5HSei41d8Fd+3bQsN\nIA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9288", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9288` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQt3CrRYLFwS3XzaYYTgrEEHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRjOGI3ZTY2LWIwODctNDRmNC1hYzhlLWQxYWZkMWZkMjkzMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjI1NTMyMWMtYjA3\nZi00OWM4LTg5YmMtZTgzMzg0YmE3YWVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1TQxSHf7CJ5a4cpdpYeMdp24MngldB8Jq86/9g0T1a4rKgxmjAQW4Bg/7wgx\nt4L5owYiQDwmvjDUUY2oVgsVR6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTc7eC49rNZpavyxxykNohu8aVLKTAfBgNVHSME\nGDAWgBSE0c7P3P/4XfaWxIPQ5nDMT6PVXDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA8nUfrsbLn+cnbQHIIjVkNX5GD89SEt\nPPxTQ758lRW6AiEAsBYBce0E1R+g3s5FgXtzgo5NWpN1dhjTjgRgBppZ3m4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY5ed9+QYXaFceR7Z/fvGs6bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYzhiN2U2Ni1iMDg3LTQ0ZjQtYWM4ZS1kMWFmZDFmZDI5MzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3J1P2kWsKv706qxHuGmg2Azbda1WPP1GnKAHax3gqShx2\nTaCPubcu7LXA1lmhGv40m/sezgmUpPBHrFxg8k6io2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhNHOz9z/+F32lsSD0OZwzE+j\n1VwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCqHoHBV9wf9+aDbShp09/mcrvlpGQmj64vhJGHjgzhICIF9STgnXJzs4\nsSZKJsNvoy/5FJXKPtf98kyWMqc+uWKZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAdDdQqzMjlTobvJJLecf09kJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjI1NTMyMWMtYjA3Zi00OWM4LTg5YmMtZTgzMzg0YmE3YWVjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDM0Mzg4ZTMtODdlMC00MjBkLTgxZGQtYWY5Yjc4YWEz\nYjgxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUVNZ8+39yLdMv30LxJqLnWJa\n0SIeK6b/0FmbeBh4CVFLXWruQsqk09Q/slsoVXJL6tk4KK545M2JY4qaHIejo6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTc7eC49rNZpavyxxykNohu8aVLKTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22KJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIDW5cpypgLXFnuwF70kzkQ/\n4vKX55qVToIXheVruee8AiAQAdmeLpO8ZKlJeLgMkQJtfWw+WXOOZztmT5YElDvr\nDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9289", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9289` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAc66klr30I7QEI6Wj9Brbdi9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjZGFiMjA0LTE1OTItNDk2ZS1hZjMzLTFiOTNkZDk3OThmOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGFhODQ0NmUtNDRj\nNy00ZGVmLTlkNTgtOWM5ZmVkYmJiNWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3wl8cw0cprpKjhTwdnK3sa/8nQ9n7gd4rHDgCEnSCWAd/qqlUjCTK5xurb9M\n7yNJ1vEXJb2NVVSrCAyv+djzMaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/C9cNUpHFm1ukpOvsbfzEqz39pswHwYDVR0j\nBBgwFoAUtiN2At0HIVGy0jnnXpvll+J0u2AwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCrDQw4uuOiMC6i3ED7xxbcUGkv\nTQQVtKPYNbSlIjIKaQIga1gFpDF9YiFUenVlQme8Vj8/EY97uGFpda1u56LFE8g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT6+0np+/6F84xCYYccO2ovPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2RhYjIwNC0xNTkyLTQ5NmUtYWYzMy0xYjkzZGQ5Nzk4ZjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAScInSeEQee3Y8wdQX319/TUdIO7RD/nKYIwcVlZjiXJRvG\nH1ZwEEuL6oXAr2fkoGP0wrW5RIleNxvIBygZ/96Go2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtiN2At0HIVGy0jnnXpvll+J0\nu2AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFRlXr+jcLSq7lMLEZRkq8kAi4pkN7rf3ijNFTVGx/ZQCICUyS7BbtnX7\n9FOm41qRxvss73Z0U1c5V7HDuf8oJ9YE\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAdeRrYyLS7B7nuL/nkf/wyfkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGFhODQ0NmUtNDRjNy00ZGVmLTlkNTgtOWM5ZmVkYmJiNWUwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2U0MDYwMmMtYTA1Mi00M2UwLWEyN2YtOGJmYjg0ODlk\nNzIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsf6DGroCHsNQMonh8VXErgGk\n5xGcAE4ObFX86U4Q37/Tf0qaTcpwugOR7dk6XtFz/ppKFVNitpgU5ouJMWrhMKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT8L1w1SkcWbW6Sk6+xt/MSrPf2mzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22LJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANTUM+i21PMR+7d6Ku11LG5G\nHgXwBUnX8eCWKcCIS/joAiB7u1pO1wosMh/A9V7n85D5wC3MC1AZT5G2QUGRczXD\nlA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9290", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9290` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAasDbGN2NnBS1NBWJ3T59KszMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzNWEyODcxLWJhODktNDNkZS1iYTA3LWU3Y2Y3YmVkOWI4ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmZmNmQ2NmMtMjIx\nMC00ZDc4LWFmNWItNDlmZGM5ZjQxNTE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+/cFmboCnO3y5ToQ6W+3obX7EnTG1YwtKTAQ/vlKkmg3SqbxaptOUQKW9KXF\nYTVryJCiq6bBjFy13Y+/6e2IyqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQN0fBsxjg2CdtXfP7Sr3PL8ov05zAfBgNVHSME\nGDAWgBSq3dSfNZ1rUoW6EQZZkQBjwfth0DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICQtndoH/ILX09XxifdFU9iADjupb5rU\nRUWs/1mnEAhaAiAygAIjOsl9bXSI8EEzouKZjWOVn/zEiNTbQaHsPgk58A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAacB+QB6XnTDAH6HCz4Ni8vaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzVhMjg3MS1iYTg5LTQzZGUtYmEwNy1lN2NmN2JlZDliOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARq/JpH+0xn24FtwqdX1G4BW8yZevB9L+bMq9Mis2+7cJYR\nnHncHi9M/pz/2mFrevSLzPY0/pHuv2+Xpd8Kz8n4o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqt3UnzWda1KFuhEGWZEAY8H7\nYdAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFZO5GeMgJYk7SnAhGfHgb2q40nhSLdIHvsJMptu2RiICIQCQy+i3nAn+\n6qtaNYQYSoQG8P0L7SW0R9buuyxFT1GHfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISARA2GXk8K/i4fNYzyqoE/bE7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmZmNmQ2NmMtMjIxMC00ZDc4LWFmNWItNDlmZGM5ZjQxNTE3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmFmYjY2NzQtYzJhMC00ZjU1LTk4NDYtNmM3YWZiYTg2\nMWNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl11YBzM/FmLNzEeT8VNavgK+\nATg5E6k5PBuSiF4Dxp4Zl9qM+sV/x8fBCbqBcY9ZFHiYpVIurTKccJWJqeC9VaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQN0fBsxjg2CdtXfP7Sr3PL8ov05zBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22LJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgaWlOYvxNyxuiT5zkfixqpCzW\nEjBGCTkNb7SoPu32pfkCIHLutKf6Hg4YfBvdVIQd6VWGpgXBNUTgPohselB+b+SS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9291", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9291` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAaHdeWi4sVaphsmYCqj32uRmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVkZDkzYzdlLTQ1ZjItNDY3YS1hYTU2LThkNjY1OWVkZDkzNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDFmMjMzOTItMTcw\nNS00ODQ3LTk1ZGMtYWUzZDg1ZDEyYWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELz0enWDQPKF3r9zn7IvKZ9XwDitG7FVbuIU0j96WkBpohl5t3TodDgP6+SuD\nLGXGD4ElTNYGTnbupDTL/7cc5qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5/N9pEaUxTyfw2gbg7QO7rRVlGowHwYDVR0j\nBBgwFoAUpupOwnu+4etCIwS5PLnFxVjOfXswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDE8kzChls9mllROFbv3GiLeiYN\nKjdmajuPLDWSzrs4IgIgTm77lBdemcieSSA2mLzrG5arYFWixz6jM0tWsO8g1kU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUevZR5thzMSkOiify5uk2RzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZGQ5M2M3ZS00NWYyLTQ2N2EtYWE1Ni04ZDY2NTllZGQ5MzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATtGlZLTn1v1JgQy1kkY41RqguuEM9v+A+8xj9g22LQlmDQ\nA7XRa5CUbXy0knXIwruji6P4KuGxDN66JoQUFWrCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpupOwnu+4etCIwS5PLnFxVjO\nfXswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIga2J0/undLhkKLlVE0VyK91XLqJBtuIkgoPNNOukAZp8CICCO5Fk1z0sk\nrhIl0nTB9FhkPXcGxIEaBtWopgXQr37g\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAVBKEn/nvJ5pwsvxUmnD5VbxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDFmMjMzOTItMTcwNS00ODQ3LTk1ZGMtYWUzZDg1ZDEyYWI0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGQ1ZmJmNGUtYjIzMS00Y2ZjLWFhNDEtNjM2YWRmZTlk\nZTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgIZ+32IMpfFd5w+6engjbOq8\nGorcxqgGJQmvm5r5GMYsBUd4g/+RWSIR+bCHgGuMOLpkwNro2DciWWR7xNWlOKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTn832kRpTFPJ/DaBuDtA7utFWUajBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22MJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPhjSjRChTVtms8zbLG+PC+3\n+bXukQbeNm6FIjli1Mc+AiBZPMEOxkm5hELutzT0oIF9S23bEbycNglfLIoXkait\njQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9292", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9292` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAUG055rSvZLmb1OWCadJ5skZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkMjJjNTljLWY5MzQtNDQ3Ny05OGUwLWRhNTgyMTE1NmQ4ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzMxOTFkNDgtMThh\nNS00Mjg5LTlkYjYtY2RjMWYyZjMyZGY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFHMYf/g2/1ztQL8PL1c0IkYoCJYkpsRD48NXzx20+untZAIIYN2S3nbeWb/Y\nU2CRdejUHTcGIG6CyfePix5h/KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTzj+GuFMn71eZqpiufXqXWGitDUzAfBgNVHSME\nGDAWgBRZEUCWx4zv6RRTyjYotL7AIdVjuTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDQOlGw7GmvJj4FkboAVw3yn4GrIl2m\n7htQPtlObvFzogIhANmUbup3aqXomqSoBsuTS7rPTA4F5t1gOEZkD8MBYl9y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVIqVk13JgMCjv43TbvYhh+RMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDIyYzU5Yy1mOTM0LTQ0NzctOThlMC1kYTU4MjExNTZkOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSDRTMOXVPdNs1cCs0VIjIRW6i9b7oMog7pORZjuxHbDg4\nr2AZvGQmCNkz7/UNy08rGvClmtJwafPj+xgtRMw9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWRFAlseM7+kUU8o2KLS+wCHV\nY7kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEiDUvVN/+TN6ql5ww2Buzic3ld8klCuaXQ39JS93fpQCIGAQuJbuA1Ne\ntmzSJR1EIV69yx7ldtYWdwZ3ki6s3GSZ\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISATXJJ43egf0UTi13lE5LPzXvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzMxOTFkNDgtMThhNS00Mjg5LTlkYjYtY2RjMWYyZjMyZGY1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWNkOTlhYjktNjMzMy00MTc3LWEyOTItMDQ4MmI5YjE1\nYzNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsimmk5vWvue/IC6cRqLFTQae\n24bEki4f1VrA78MABGvYqbvo2PD9y4jcPQ27xGDTjGiT+7npnVVmC11OXPvSo6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTzj+GuFMn71eZqpiufXqXWGitDUzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22MJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgAbpMrDFCevFNcsp/E2nfDjpp\nFkyZ6DYzFAu+DupZVFYCICjpekkVtrB/6feRqtzJJhkPyk4Tl82HowNk7JwEEV+1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9293", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9293` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAfsG55z57s3+9vsv3WDabvVdMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMwOWY1YTU3LWE1ODYtNDM3Yy05OWNiLTU5ZmY5NjczYTk1YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQ2OGU4ODUtNTU2\nNS00MjY3LTk0MDEtYjM3MGUxNDk2YzUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7Xk6R13HGft1N/IMqXy6WXQ3GajFxu0gYJ+y9kWW2JzAA5Ypt7oB1EB1DVf/\nE9qVa6oRm8UaPfA878vzjFpSJaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9Fhf++msY+/mUTjt5NUj+3LjZxswHwYDVR0j\nBBgwFoAUcaAx8zmz3oJukBnJH65RFwZGmzEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCcNeiVepXFbjqTL+4cQfbYZytC\n/9kc++FUjr0ruIboKgIhALZp9HBOpfIcxU2B+rCkGGBqCeuFSV+PqPxm5x4avPBN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV9/2DLDRgdyz3nLO5IbpivkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMDlmNWE1Ny1hNTg2LTQzN2MtOTljYi01OWZmOTY3M2E5NWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPRdP0IBS6IaiUYiLY8PI71Ke5jfE26VB2royULdhQHJvv\nFyBla07WtVOqMZduC9UN/Ty0lXBhNxd51krPsm1Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcaAx8zmz3oJukBnJH65RFwZG\nmzEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgEClnpKBc3Dqv2oMU06JKAwvYQLUtJAdL7H//eSe1kXECIQDrmKDR5e3y\n5Dc4lST/NztKuVXDz+nlvybAdUaP+CbuyA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAbZY6vHQ/zUeKQvZQX5+imNHMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQ2OGU4ODUtNTU2NS00MjY3LTk0MDEtYjM3MGUxNDk2YzUyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2Q3ZmYzYTQtNmM2NC00YmZmLTliN2UtZmYzYjg4MjAz\nZTlmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEI1SdfnxHQOiO4tu9k4jnbw1l\npr8atCXflq83X1dw1sapbJRJ8lk6p3w4qKGgxVU8e9Kt1cZAFs32nyQG0DR4XqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT0WF/76axj7+ZROO3k1SP7cuNnGzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22NJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgY16tPeSWed0UQi17AUZ4H1wl\nVvEPOKLi0lDbbmYbuyECIEv08hqi+Ls4/7h6u3F26kz6YBaYZmEiFkb4DrFRsQrC\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9294", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9294` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAfu2cP+dxkiOgJTzalhLU6rzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM0NDFjYjI1LTVhMDEtNGVhZC04MGZlLWJlODFkMWQ3NTdkMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTQ3ZTVjNzktYWU3\nMS00Y2ZlLWFmMjktNGU0NjE4NTJhNDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFhKDbRJmQwAWEjKiSTC7yVwujsRyszbVSPoCebaZ6eI0OY+cB3XbWzresJzS\n6ottOgW2keskcaDZI31DB97Y1KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRum0QW/uSd7EOjnFyd2IzduMwk+DAfBgNVHSME\nGDAWgBQSAqWW460EYuf6NRdMvtBSMr+TmDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEdM5ZOw17PItpaQnyOdW4PqnnVIVFdQ\nKiw1mob5Y0yEAiEArcdOwtSj9lGNXvJhnnBcOMG1se9bkeoPiG4sYNnHqvk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXJYltyEiZAzgr7U2gdsRz88MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNDQxY2IyNS01YTAxLTRlYWQtODBmZS1iZTgxZDFkNzU3ZDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQw5Gz2QlFcaL1hZ+I1DZwL40MrE1kKZ0UnKi2o/lIwZnXV\nEGyoUUuyuXckSHODMKgzOvHQc1VtldnjePbi3stMo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEgKlluOtBGLn+jUXTL7QUjK/\nk5gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgERw88mOsg65g0aK1BfB+LAopbitex8BxWpLoQTsre0YCIHErYrHXvzX8\nRDjBzzTek7JexYHnUe+NV8UW76Gtfq1K\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISATuMmAQbjvtOrq8IhzOGikCXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTQ3ZTVjNzktYWU3MS00Y2ZlLWFmMjktNGU0NjE4NTJhNDY5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTc4ZmZiMWEtNjVjZi00ZTJkLWE5NWYtYzlhZGVlYWNi\nMzE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/fXNLGIHT2ys0mzs9UMlxzHb\ntyj1qzGIc4PhKoHwJtaOcZXI9L2K1ZOoe91cxvZCJOj2g/mlCOHAuhgqQQxNvKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRum0QW/uSd7EOjnFyd2IzduMwk+DBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22NJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALxFq2El5SYBzTHNw34z9XbB\njryM+wxYpIAUvVCCaGsCAiEA4z3qQ+wGaVS67OranjqkiKYLFEFm27Y/08nb1pk4\nEA4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9295", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9295` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAfIqKhVSps52Bb/K1ByR/1WHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiYzhjZGI1LWQ3ZGUtNDA1NC04NjdhLTQyNTc5OTJlYjg2MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWZjNzdhY2QtNGMy\nMC00YmEzLTgwN2MtNmM2Yzk2OTUwODIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFBIQXq0CnVA/ak1mcD1TFcImMolhklq0fulUrGSwZAP12O4b0ZaIksRqb0dG\nfG/Kwu0fLlN+sN8CducjnvETlKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrGCTEMzL7fz6SlAkZiGKs+hzNyIwHwYDVR0j\nBBgwFoAUtx3UK68+XNMRq08u04xbdr1ajfEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCID876pXnVcQiS815WTSL8QhqFVd8\n3qKgDwqSnjzMbbVgAiB63GXjVgE/AsXifW9K33RKsu6t7ZuuS8plEVkDLZPQQg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAb7ATjbbMXRDjBLitjtAyJy/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYmM4Y2RiNS1kN2RlLTQwNTQtODY3YS00MjU3OTkyZWI4NjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQewqw8JiQ8xi9FXtT0jr9svN2Jy8746v5EO5XtpmQqeR9k\n73s5OE4cM17RjwJMCr34IVo0UxXsEd5X180w2mTVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtx3UK68+XNMRq08u04xbdr1a\njfEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALie7f1otC27LiPO6Rnu01Eo5NF0Nn9pi2E19XJBQzW1AiAnuoA+ZU+B\nXVCPM6EeqBxtmpxiTIhu9+3DASRdm28+RA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAa0DgxO540Irfko345jNsf9OMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWZjNzdhY2QtNGMyMC00YmEzLTgwN2MtNmM2Yzk2OTUwODIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGNiMjlkMmItMzg5Ni00MjE2LTkxOTEtM2U0NWNjOGFm\nNTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERhq8LqMelZF8e19zdXVyTzZR\nqtzjAG8xJWLKsJMNaijHvEcS82y5ezOJ9KdsIiitjN1asBRaoDKVUPXBZWZFMqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSsYJMQzMvt/PpKUCRmIYqz6HM3IjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22OJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPGuQKGL+NWbJ2dw/iJtwzEP\nzpg1f4XWN+rmrlv6dbaBAiAIATO2MjDN9J0hNhY0ArJGZRCB4p6KfGMxp9Fz8evF\n4g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9296", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9296` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAT4WvEQRJ2WWwpIvrVA9KZDIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE2MDE4MTI3LTRhZWMtNDgxNS05ZWI2LWEzNmM5YWZlZmNhYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2VjODllNDUtZDM4\nNS00YTJkLTk3MTAtNjUyOTZkNDUyNDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFOuWKTOxXrS10vI8ZmHiIRQQhI5g6nNg43vvktuyawrTwmKf3w4G3pgwqBnA\n/a7713aNj+kyYHpzbaZEmC8DVKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTdoBQU618YBteQm0Kpt8bvFAOiDzAfBgNVHSME\nGDAWgBSJINdnpmCeiBH+iN1z0FLNh5phFzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCzksAD6mf1DwGphHQVwQ/5z3+TUy6/\n+lTYhL8Hqs5lUQIgfcSdmj6n+BrdQgXLcWp+8CvJnl2OM18y94DcJUn+6MA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAepMOQKaGGeSe9XBpdxkyshpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNjAxODEyNy00YWVjLTQ4MTUtOWViNi1hMzZjOWFmZWZjYWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2bgVy5Og7t9kjHpQ1SC6RwBhyBDroLL9IRfJxGyIbATcJ\nI3kD3qllBKNzeXowBCSE8ahgqcf7LawQE/cyBWWFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiSDXZ6ZgnogR/ojdc9BSzYea\nYRcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOV5HdzqpcXWxEEeKCMMmj2GsDtP3NvSbZtWXQHF40FdAiEA6qgsyrZf\nQJDElpxhbXtb9pZkNRWwZHjZ12SIPqjbuG8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAXk5+rgoYUlwhJxXT2K3ZMr6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2VjODllNDUtZDM4NS00YTJkLTk3MTAtNjUyOTZkNDUyNDkwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjAyNjA5NDktNjJkMy00YmM0LWI2NmMtNTE1ODYwZGZh\nNWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeIWfnGIbQWANgMXURgKqW0zD\nq9oz4g8vse2g+TteiUt05yBoJT/7ReCfdg+phFh29zJz2SGdv2SBL1IkYvQc2aOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTdoBQU618YBteQm0Kpt8bvFAOiDzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22OJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgSbzfMlW9wqKcYvWy3pskXrMC\n+8tr4MV7bGf+UiFULP0CIBWRlE4lWQf69JnNHtr/oiw0pl7PejiPOnjQpTq7T7Bh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9297", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9297` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeEYODPkiOPO1CXRKQ3F1QsIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM4MDM3M2YwLTFmM2YtNDdlMS05OTgyLWNjYzQxYWYxZDZjZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjhhNGNmMjUtMjEx\nYS00MjMzLTlkMzItZjZiYjZjNGRjOWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3ytGxDKvKfdnOukhgt2Vh8BjAlpOvUSz8ihszNcUi588FN6ZKdJHyI/WKWsh\nCcyGapqK+0C00GjOtxMRig30j6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6yWt0labBjVmmBQ+cz60OKTpgpkwHwYDVR0j\nBBgwFoAU/WXN0fTHYluBW9OnsriY5FCoc0kwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGn7v7pe58HyhmXrq8xr0imiHHJS\n9CXjvQdTxkhB/gVXAiEAuBKjXO7MKLxKwoGJI9grboSYd8nk41OAgNrq1+Ig7pM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATNwiareAUwnia2HM3lWsW/ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nODAzNzNmMC0xZjNmLTQ3ZTEtOTk4Mi1jY2M0MWFmMWQ2Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKc4qHGsl/j9I76nCnIfJ6LjbUqEwzGIJ5xHMMr9mviMJb\nd0ZmpjMrVDc+6dyE/JViqVcbvAhax1+xvz2CTqsUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/WXN0fTHYluBW9OnsriY5FCo\nc0kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ+6CPy6+EW+sxI+stee5xfPaaqiIAdRqA6GmagsQ52ZAiEApL8/gTP5\nWZfVbguJ8reH4+KAe+62y4iKhVsJX/YKV14=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAStwIksj/1P5iU+1MdF52btVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjhhNGNmMjUtMjExYS00MjMzLTlkMzItZjZiYjZjNGRjOWNhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjdjMTNiNjUtYzgxOS00NWRkLWI2NjMtNDE0NDlmZGZh\nY2Y3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoHV2iW5FyptUWYVgZIBxnWSh\nc5LGbnetPDg24BNzCvvL2n8I3veLpimiLVHExpF66cA+U4Yk/3e7Du27nKbcqqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTrJa3SVpsGNWaYFD5zPrQ4pOmCmTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22PJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgVLhFwSp3XN4faejJxUa1dzFq\nDBl4cGAzKa/tPzi5VYsCIGRn2gjTewU/HYcx7lArI+WDRIT8/9IhjZ9XbcZxVW/E\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9298", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9298` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISARiqJ1sG88Yx1LOjdY13b2C2MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkMDg4ZWMyLTNiMjItNDk4Ny04MWUxLTQ3ZTIxZjVmZGNkYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Q5MTRlZTctYzU3\nMi00N2Y3LTgyYWUtZTMwMWJiZGE4Y2ZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4rXA6WoicxJipQu1Nzgfjy7B2StpzBJg2Feb9XiCmD2uai272Ld3afzKHnvX\nLVCVtCJnW7uhpTE3HnyobecToaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ45uTQYp+gi6IMrXBJ0e1a7ZLUWDAfBgNVHSME\nGDAWgBTFRXb/QlYTTrIdwW3qWzz52CBMJzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDX513yFr0Tug1tLF0t1wpQnkNqRFjq\nKhgP1i3XZI9PmQIgOcMn09yGzcgmvtv0M1PPDJzGohHDf/ukzU9xvHaCAX0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAaLigF/Xrn3F1jGYIcToDzazMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZDA4OGVjMi0zYjIyLTQ5ODctODFlMS00N2UyMWY1ZmRjZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASv0vhzw7NJG4D6ZUFS7GtUVJnMLn+T4J+onROq2D9YSdCM\nqO/EaODwKQ9zO8pQ+XQTnjJC2dnAo0BDSXcjyvqZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxUV2/0JWE06yHcFt6ls8+dgg\nTCcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANAFzU5B/qnQO3djVGLBgP5V8NUYHN6KZy38LCzBGHMNAiEAwPXfFYgU\np6IgsRcC3s4Hl4H49NfaqRghHfGZeDqxqck=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAb4EoB7dLM4W9GtKw900a59+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Q5MTRlZTctYzU3Mi00N2Y3LTgyYWUtZTMwMWJiZGE4Y2ZkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2E2MjFhYmEtZTNhZS00YzIxLWI1NDEtZjE2MDZiNTA3\nN2I2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnpLvlsXhJGhknjkoS1W7rLHV\ndjv9RsnIRwZB7NN4YRTE9g/zDhk+M4mD4yFOLOwOuxOnzApwqy/zXyCNB1kCcqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ45uTQYp+gi6IMrXBJ0e1a7ZLUWDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22PJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgI21VSFGq9JxFh888Mo0vV8dm\nxqHeUUQ/6deWvBPewLwCIHNdcPlQ8peqUUfDGrhmk9vHScJbeV4do9/XQNqsIkrV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9299", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9299` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISASnzALmdXepWfyfHJjeCrcn3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIzNjQ0NTk5LWU4YzQtNDFmZi04OTQ1LWJiODdmZmRlY2QyMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ0ZWFhZDgtZjBj\nNi00NWQ1LTlkNTYtYWQwYzlmYTdmOTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMFAR0a5SY1Y4m0GYbo+AFMjP8dZEWAF0tZPlMG3O7LZkckzae70XX7a/FkO8\n9HQqTK2Bu1ZYk9nsvNbPgK/X3KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4z7B+Npaaiy47cSk07ZxcKQkJ3cwHwYDVR0j\nBBgwFoAUJjM1SsDOEq2vf3jDvKu3ndBGzP8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCbFcCS1ZmrFqyLzzPKJxQxjV+J\nhVqwthgaXKaEhna1/QIgOS1u71wNFul4gizNKaZOuN2nplTOMa04c64bMzFn598=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAURUyNlilJiljEmLvXrBxRgIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMzY0NDU5OS1lOGM0LTQxZmYtODk0NS1iYjg3ZmZkZWNkMjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvnsXXyI6Mp2WQY+kLqes6FEp5AXqcwjhRXhTm9p/lc85N\nr024GOKqmf3LJ/Aw7xqLrXKcwo7cPoBvJuxcGb6Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJjM1SsDOEq2vf3jDvKu3ndBG\nzP8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOeMU8cRsn/UiowRO7ZOKCL3ydKR10a8DevLJBhgejAkAiAJs54KC2SK\n7beT4iEWE0ZCNYILuozYdEAOdUDoaPYhBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAS75MN/nCu4jSlRCfIezCoPVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ0ZWFhZDgtZjBjNi00NWQ1LTlkNTYtYWQwYzlmYTdmOTE1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWRjNjZjMGItZWI0Ni00MzFhLWFhOWQtMzVlNmJkMTky\nN2RhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdMSD1CfS161S61G0/Jcq6ffI\niYfgN8w5WtD89HY4KGvaUZolpHU6eWgoHt9YG6y4M8u8IMo4oUdstNtDLLdwzaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTjPsH42lpqLLjtxKTTtnFwpCQndzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22AImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgYh3tCVmVcMYyIPVaJyAe4fpOI+Lz\nXewRedrYaeSgIp0CIFupOrIKQlOcPhi+zJMEIvXCWnyimrfx7v16GeadO3zc\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9300", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9300` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAZ2ZntcMnyyQbcRH3g2tKaktMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFmZTVkZDQ4LWVmYjgtNGNjOC04NzhmLTUwOThhOThjZDA0ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODcyMmM2MDMtZTUx\nNS00NzdhLTkzZTgtMGZiYTQ1NzYzZjI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8eWvJxff1SngEUmaQLYLErfVZkTqDZ3Dx3UG0Yrw+nBoFdTo0BZhMMpQ0flX\nKa83l3VEdWxZPX1dJkpxp0e9YqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSz1rPU97AnDGvqxi1tZ3i0gLMg1zAfBgNVHSME\nGDAWgBTWIfbxAt1Yu/xftJ0dtVLkc7mGQDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDgenHi3LHb6t40cEZjz4CDKRdZ3/aGQ\nC5fUF6bzJt15AiAfywCFyWVYbI3F/wKhRogZLUnmIFbh379+Ksc2pe19Zg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdRkX7G7wrGuan/L9qKoQlaOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZmU1ZGQ0OC1lZmI4LTRjYzgtODc4Zi01MDk4YTk4Y2QwNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARh3UQU6D3cmqCyiG1YWpe663FheJJ4q4CSNKinyGk65kG2\n8NALyHzJbrqrsHodEoQ0TlRnxgKRPhdBqi+Vb1Yco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1iH28QLdWLv8X7SdHbVS5HO5\nhkAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFLgh9RKBMUmoDU69OJW5bMbQyXzYVBq/fTI7mwbVh2wCIDU6NRYSFkTI\nWm9YmgsOT1a7hl53f72UM2AC+gKCgl1e\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAXLgABRYCCHixdND1+CJbtyEMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODcyMmM2MDMtZTUxNS00NzdhLTkzZTgtMGZiYTQ1NzYzZjI3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmVkOGI3ZTQtYWJmZC00OTYyLWFjNjQtOTQ0ZmJmZWVl\nMjFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhnQwcEiBzJ1R1MKDGMVZJRfc\npJuNAAswXLKk6VVuq9H+/JBsyRlul6/e+sr5v/cymrJULFltwqDLSZ34mSfw2KOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSz1rPU97AnDGvqxi1tZ3i0gLMg1zA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22AImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgVsNYZU678XteDPVjixe0ceedKDX7\nx5qjAT3W3DLXR3UCIQCe+NH9OjKmFNOe26WDgV2o+9DxXZqwfYRAmMx8ce3kaw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9301", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9301` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAbWE6b4pVHrLQVDAGFnRYeJHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwNWFjNTYxLTk2YTItNGQ1YS1hOWQ4LTY5ZGIwMWZiMzMxZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzRhYzkyZDgtY2U4\nNy00ZTg3LWFlZTQtNmI5ODg2Y2E5NDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEteqhB5C+Ankl21oLptoPT9EfP9mevKlgQIXEL8ixVSbkhRR57Z2ZhIZTf5oe\n9B+vckw4faZQOTjP5XDHy0bsEKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzYC0foRtw4zWNm5AtbWwP72u8PkwHwYDVR0j\nBBgwFoAUiGfMOr5goo0EZVkjami2RQi81CcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC1FwBklU9bH46aQnhk+ldiT27V\n6J1ogB4Vc7KY1ePrvgIhAPorj3exJB0sJdjkuCvlmArmO5ln56F21QFQ4hzEm0rf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAR9wAVexwJ5ZUSwKXToFMZ43MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMDVhYzU2MS05NmEyLTRkNWEtYTlkOC02OWRiMDFmYjMzMWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQr/wQ5z3e+FpEhJG9GbrLUAsjhH2KT56W6gZ2aV4/wHoRm\nhAv+V2i4XdwJynTDHOA60BpUI2qev6lyPQXbx5dio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiGfMOr5goo0EZVkjami2RQi8\n1CcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaZMB+63odM3nlPtJUyv2n6rdOCTeGoVwc10/DJP9hp0CIDNM0wTnvpc2\nIgqAFsrfOYG9GEW4/PUVK2U70BRnte6W\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAR2eoWeRqxrANXoa/A6qZ19lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzRhYzkyZDgtY2U4Ny00ZTg3LWFlZTQtNmI5ODg2Y2E5NDk3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTIxNGMwZjYtYjI2YS00MThiLTgzMmMtZjUzNTI5YTQ3\nNDVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETUMQvQRhLWu26CVBcEnARmql\n2R4hNwsYd2gU5yUXqOgtim+eXMswQQYHZ8OVHSxoOrT+wgk4DQCfTMjkoLbcL6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTNgLR+hG3DjNY2bkC1tbA/va7w+TA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22BImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgJG+ffqL/k2U2gwq+E5spTpTuknhk\ntp/FJbYqjVUst7ICIQCde9CAXbDQwTxoEbJAXesDlrpK5c5PCa8LIYSD8/8tPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9302", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9302` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAR+IY7NTQjR5WhOCEn+FM39GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzMDc5OGY5LWY2MDgtNDU0MC1hMWYyLThmY2IzZGZiZDBjZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjY1Nzk4MjEtNWRm\nZi00MmRmLTkwMzEtMTZjMTRlYTk2NjdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4E9SlI7XOoR/KJ9g/7sMtWGRVP8U+d1QRTjnAeI0Vef3fFof9HDPnvBfhgvZ\nxXdBxj8M1aU6fjIvRgAH3nQxVaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS372Onb4UXbCste8FLzbtNkyBUADAfBgNVHSME\nGDAWgBQSgtDYl1RjobrpqFb5jjXGyA5IoDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA63ChPawmX/09BfKGddiwdHJGRMvrFP\nMq6B2tSRBtQWAiEAiKIsfKTGB8MwCE6L49R/xyBQO08jTxk7I5glWBPKk0Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARsWLlmmVcZ2qzXme2InBzPzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzA3OThmOS1mNjA4LTQ1NDAtYTFmMi04ZmNiM2RmYmQwY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATk6N5PkubB8bMHoXAw9jExmThYGT4tJDew3Usd3iRdkHa1\n8mDWdKbYZV+jE4FLB2IERcSMtYqsxWbo5QGyH6WEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEoLQ2JdUY6G66ahW+Y41xsgO\nSKAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO6YXS3ffqHvrttF+de5IZ0d4XWSSNA40EA/oaAyo1rBAiEAhMSqWDMk\nwZWFTVrxB4xeQq8dlV8qJdBv73Nkp6TxuwU=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAQFT4XO2nHdEr8IHcdOyV3qtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjY1Nzk4MjEtNWRmZi00MmRmLTkwMzEtMTZjMTRlYTk2NjdhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNThiNGI0YjEtNzJiNC00NjE4LWI2YWMtYTQ0Yjk0N2Ew\nZWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEe0bE4Ge1iFeeaIn0Psak58xG\nk/rPvVp0gg7haHC5LI2x2CW3UjrBndUUU2fPE/PUPfxED/W76/74oR3fN1j3rqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS372Onb4UXbCste8FLzbtNkyBUADA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22BImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANSa8vtw/DU5w+kvyegzRDQBKiEm\nqjURvmb7sgxJ+DLvAiEAoOvygGLE6he3dpmQpXtx2i2kLE/Ced9xQWp3b+AnVC0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9303", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9303` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdUo8GsGmgnkR2LdaUCJY0VHMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmMGFlNjM3LTgyMDMtNDFlYy05NWUyLWVjNmE3YTlhMjcyMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGIyNWUzNGQtNzFk\nNy00NTMxLThhZmYtZWJmYTQ3OGUzZjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+H7aByxoWRR5cXEG97S675H8dUvEaEqP6cqyYpUSKZN1HEVANuJfyeQUqADZ\nXmT8+LnQDnwe3bob8ii4KmWSQaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiXnRQ00vNrSAiyMX/J3A6TGdAA4wHwYDVR0j\nBBgwFoAUFUp84P/RPj5u6IJnfFS0zdxCDokwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDRieErfvcEJnwHb1nw2lKMmFFa\nu2yyleTDOlrujBsNXgIga2GDfhjk4WOns5KSE4UTh3SY19EMapWzZbu4xZTQ5NE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAajSz1uBti2ft4/Dqo2GfpwUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZjBhZTYzNy04MjAzLTQxZWMtOTVlMi1lYzZhN2E5YTI3MjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQpSClclgHkwCdf+y5f8TJEYMuyv0E5H2uSAuK5Ys/HzWi\nUlaueXuhoPmcDkUKOv5bDSEeEWYzl0iCSQFzVjsNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFUp84P/RPj5u6IJnfFS0zdxC\nDokwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgQefV8XauvmSg/2ZPzFFvwvWMo0rUwvVaNd9JvaDdJUUCIFXaa7BTmwWp\nKzbCVIVrhSbA4gPkkToTfXS+0k5nF6rN\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISARJ2n949yl7slVN48OgHGWlYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGIyNWUzNGQtNzFkNy00NTMxLThhZmYtZWJmYTQ3OGUzZjA3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjM5OTE1YWItZmMwNi00ZTdhLTk4YzgtYjhjOWNkMmNk\nYzZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEiiSMaMw+QP8MMxOw8gk/8sep\njC/2Uei+xaSixid9EKNagC2SO8oRpRQi+BXXwj2whSZw8F1lAbWKwK09xNB8hKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSJedFDTS82tICLIxf8ncDpMZ0ADjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22CImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgTUcv3r33Quc2RdACqOsTUpI3e9Uo\nDZoh6dkgb+7db3UCIAYrlFAz8CIEKTUpwEVklPSLaRaaa/M2oBl3I13cdpGy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9304", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9304` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAYY2Brb+kimXpzRBmJF43xRfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiYTg1MTMyLWZlYmUtNGMxMC05YjQxLWU2NDY1Y2EyOGI0ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDI4MjVlNWMtNjE1\nZS00NzgzLThmNjQtZDEyZTc2NDU3YThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEt2OC4yd4NZLbn5+KyRhtW7UYKZXI40KeM042HqZxnwBa/PcuTevgI26BUWhh\nk8ICkN5tGTH0Q3uvMekpKH2YQ6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSIu8VGtDEafHqiZXEEO8u579CGkDAfBgNVHSME\nGDAWgBTVj7YjvzSENu1FnAk1GNp/F0Q+/TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDm7xUiA0KMyjoswYlqwazoqrQM2WBpN\nzebw6tBKIONCAiA404hyeSL8qVQP/Wd4ExuNil5KXXZU0e59MN2g2Dkncg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUTuq476IihZD9IVzVjVyBB0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmE4NTEzMi1mZWJlLTRjMTAtOWI0MS1lNjQ2NWNhMjhiNGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcb7zMqyHddfc9E9dtdUv8ofvPeZv49pDg5/KtIT18KIcw\n1ggrpbx+3BIk5GSbH5hrOp/UVkajkkubkvImLe4qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1Y+2I780hDbtRZwJNRjafxdE\nPv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgMkvRkERW+rlI1gA9e8mSb3mTao0r86Trr5q1grL6j6QCIAk8haFLljCM\n1sKfgSqMofkMwnxATn4jGW0aPIooyOTh\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAdD0SRy8Z8vkR/m88+nfq2GaMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDI4MjVlNWMtNjE1ZS00NzgzLThmNjQtZDEyZTc2NDU3YThkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzM4M2ZmZjMtZTlmNy00MTU3LTgyODEtNDQ0NWQwZDgz\nNzhkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHdjkn0z0Clf6/4GSptxDZtJM\nZBssUPqS7H91OyoMDF0MoaQ/Qgrp3Ve+ZBKYv+y9OEXxwTGJyHNvcpltUHAsjqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSIu8VGtDEafHqiZXEEO8u579CGkDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22CImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgXR/UoO/YRg7iyBPuXFwThaeRdXbV\nL42flNJUID6yd9ICIEl4MUcaHPPECm4r/67n9lTWO+Qb+debsLGN8ZujshjV\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9305", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9305` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAfJY0XfF4THY/bTkfnOi2n1VMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGFkYWNkYTZjLTU0YWItNDg0ZC1hMjVkLWEzNWMzMTg5NzNlNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDlmNTUxMzMtZTE5\nMy00NzMyLWIyN2ItZDM4M2M4YzZkMDJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEUi1KigJXgOxb7FD+XIceybebTapWbQh99sHz1XSHSO8/7HjDuv4ybRsl1VF6\nRoUZK58LR5mj92rZqA9tIAl3bKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6I2rHeQVNiKicfhpVvKsiTdOphkwHwYDVR0j\nBBgwFoAUe6mDih3ssVXFW+62q6j2tE3vJhAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD6xwWaBThdvmAFW9szPtpAW5f3\nkuzqBpB0wNdNNsCUdAIhAMxZx4uhA670S7flrEMrq717M3pMYomHssTTYw7OJciF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZG+qSnCwDS2DceY33vSmAgrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nZGFjZGE2Yy01NGFiLTQ4NGQtYTI1ZC1hMzVjMzE4OTczZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4eEvWfAEwCpIJVLyGPIaJnn/HFIA9PKd6R6BJQhf+UQy+\nl1RolVcx3CJiTtnukQVjW2XL+b1oB9z8ZuuzVrdoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe6mDih3ssVXFW+62q6j2tE3v\nJhAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUwB5mTUATWrCTQJiCjMFdLdq/o613AXnsbpiwgSf8IUCIAP4xmHnkPBp\noFuaBFY0kni6TZa0a7BfVDChDep5rHhg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAaMS7KXq7ireB/atsiAzMPCYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDlmNTUxMzMtZTE5My00NzMyLWIyN2ItZDM4M2M4YzZkMDJmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDMzMDRhODktMTVkZC00MWQ2LTgyODctZmY3ODFlNmFi\nNTViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElfvM22OJzf9X1XQOwNEgLShy\ntqQU9EfWw/VIsQ6/79CA7qgiybOkop8JxxMc/A4GsHxb7iVAbuzqLrWKGLx84qOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTojasd5BU2IqJx+GlW8qyJN06mGTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22DImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgKp2STCtnmR8Z/2hoclCHIcU77f9Q\nffeiu3KpJQzrVKQCIGtg7o5kUjy0lNETCE5ZeEb/TNe6c/zMAoWGEdv8WW6G\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9306", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9306` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAaDCJtDYdkgKSLVvc8ivGAX8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNlZjI1MDhkLTUxMDktNDY1OS04Mzg3LWVlNTVkMDAwMTQ0OTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzU1MmYxODMtZDc4\nMS00OWY3LThkMmUtMDIyNTlmNmY0ODQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7sQjWGO4XEaw9wsgNYlve9VPm0mGwRzu5fAEQJseJyjUXgqR0QuyIr8JqX2f\nYSpY4+tGu9dsxVpsAsE8D+py0KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSQXDXd4IWowYZ2JPIjCo5PKc0dwDAfBgNVHSME\nGDAWgBQNpdRfyZnEucB64i1Z0+DQ/uNQ8TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIF9IHi+Sc4cuW4j16I97CPPZEPdIRZf9\n7ncLYWs+P8mLAiEA5VBK7/XFlAstX1AqSv6ZPuKGdhjw5/Pj6YqKi/bBhxI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd3Z30Xtrsqit6Gze7C5H8UcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZWYyNTA4ZC01MTA5LTQ2NTktODM4Ny1lZTU1ZDAwMDE0NDkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS4l8qqp7eeOgGkSV6vAXKzA11uCfskrRmY1tJSbHlCYr5G\nP5hXhc7tVuFKPcOp/8VL7Fe+gnGSKWAig2JzFRG/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDaXUX8mZxLnAeuItWdPg0P7j\nUPEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOW3b05bbdbEK5V984dNkAj5uiVRVGd/PhYW7wENSLiDAiEA37aN8hzc\ncof1JbuGUxk/pyp5w4KaG0jXn4q/KL0niww=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAbfLAvTZ0W3spoY1WGB7FwlnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzU1MmYxODMtZDc4MS00OWY3LThkMmUtMDIyNTlmNmY0ODQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTdhNTYzOGUtYmUxNC00MjY5LWFhZjktZjljZGRiZTc1\nMzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzGjyULWtX48rSohakBTFKz0D\nRqzb7JajN0uaacQfTzU8dMjgWIJQ0hrdvJv70aSHaJ99uCTRaaaQVlXVdSNQ/6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSQXDXd4IWowYZ2JPIjCo5PKc0dwDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22DImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgBDJlvxeYL/qCBRQjooXN7mk+GUfU\n3P5/ZvC0eUJAjMMCIEQhDQfQgbzp3X2nbA//MSQFUQNDdfLbJxgx8ZXP5dMO\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9307", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9307` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQO5eeyAZJcUcyIIJrw/OjJzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNiNDdjOWI3LWIxNmEtNGIyMi04MjA3LWI1ZTJjZWNlZTdkNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjlhYzVkOTQtNjIw\nNi00YTNjLTg4NDAtMzdiYTFiMjMxOGVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH41Qt/dfzQb9ZgpSO0oVeWBhHgQzEWvvTufngBnKdpQ4yITRpG8WiErD+WEv\ne4PSj0bcSnCa5rKMqCGD9+2pKqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuH3ubZfzyeIfchx/oX1vE4f+cKYwHwYDVR0j\nBBgwFoAUoYMSAKoc7RIzbMYVqihpsQa9SaQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCAy3KR6HFmFzzgsd1d9g1xhPbB\nD162x19hOY9ZFpuzlwIhAIxRblLeAMto19/gsf1pkeJi+0CxcjFYxgMKs5FnjAHt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcgRdoSU7x0ERFdbTssZCb2gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nYjQ3YzliNy1iMTZhLTRiMjItODIwNy1iNWUyY2VjZWU3ZDcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASrKsJL6l+/AxrulN9yKvAu5EkNwVEQRKHMczAoB8m86EVy\nSXYvIwbv8TUP55MEkYbhCY0nxOptnP5p1r6AFAdZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoYMSAKoc7RIzbMYVqihpsQa9\nSaQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ/Ip+7OVZNysESwXVBWzlXTAsL0qqEe2gbjivr4pQ5VAiEA3o8ocQTV\n1C8vLFEhl4uhE+ODuz/2SpZHMqzqqGPcDFM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAZ3WdccsQQMVzy+s6syZdCVhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjlhYzVkOTQtNjIwNi00YTNjLTg4NDAtMzdiYTFiMjMxOGVkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTY3M2ZkOGMtZjNlNC00NDNiLWJiNzEtMDViYjQzNzA2\nY2I1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqnxb1++GZ0uNSCfXj71FQ0lv\npodOfbNVQuM1iA2t/RzqN9nvy3UW/deaTxzLqELa09NcKLmU7SX8podlJZwyeaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS4fe5tl/PJ4h9yHH+hfW8Th/5wpjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22EImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOnz11cSQnRtsDGev07oT700ymWO\n0yjawA08L2lP6SofAiEAptC1LsKtgzqkS/BTtaQWWg5WMIeYVss4Jv5TNxa8D5A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9308", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9308` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXHBDQBXK5ed8R1TlKpn9AkiMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViMmJkNzg1LTNhNmUtNGI2NC04YjVmLTJmN2YwM2VjZjljNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGEzNjg2ZDAtZDQ0\nMy00ZmRkLWFhNmQtNjdmZGFjOGQ0YjNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3oRnIljcQuuiW35OaYqFhVQBgDZmo03uGOqkrm1zlrt/ab1M6mZ3vBGvxrsy\npEu08OpIyEp5lLO1YofxCQ+loKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTBGEj6GgeEe3BMdm4+Ngk+dfBDijAfBgNVHSME\nGDAWgBRbSrJa8wP9zLmFzSR2O1sBdZcOkTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDltm+z2TvtN4ui7vJBS2rqO5Zm38tI\nyYclfCfv1IljogIgEBQpB2qx6D8X2Q2QXrxtDnoiR5M3J3RxMQD/CNDGcVk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf14ppCK44Ea8QDIV6GwIqtVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjJiZDc4NS0zYTZlLTRiNjQtOGI1Zi0yZjdmMDNlY2Y5YzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASB4ub2oWPdztokU2oxkquieiB5Z3bZAT8kOl7e81FGuB9T\noGvdUHxyfmTbeUl4NPayEqPuKoOhDQfXNMP5F0qPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW0qyWvMD/cy5hc0kdjtbAXWX\nDpEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOPOfVtZAGQelMslsrgWTT4BIsU/mQNQrtCTQs+kx2gMAiBOlK2si03t\nbHBKRk0uhys4dX6p503hiZE7E8nsR3ORlg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAYnTH+d9bf3QzYo7xqyHYUNkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGEzNjg2ZDAtZDQ0My00ZmRkLWFhNmQtNjdmZGFjOGQ0YjNkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2M0NDczMDgtZjRiMi00NTYzLTg1MjgtMzBiZTVlODU1\nMTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkn+3yq71eGtRMWBF8fzx8Les\nmvbK0BkGv38Ote9dkRCjYbRf/IBS9APU3VA4L2UcIK1jPWX41InkmrjySypMxaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTBGEj6GgeEe3BMdm4+Ngk+dfBDijA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22EImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANUnmSg8Ye4ZGFquG/03DMt9CF1L\nC4mTwxoY2/Vsh6TzAiB1AjgY8gptnF8oyvWZuMSzmYPT37ZvcoSlEBwKNCammw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9309", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9309` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWphMDtCEHsgxnDMf+xep/FuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjYjU4MzhlLTg2MWMtNDFhNC05ZTQ1LTk2YzBkOGRlOTI5ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDYxMWZjYWMtOTAz\nNC00OWQ2LTgwM2YtN2VlN2IwZmJkMDZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE95Ku6Lg4EMeU9u0XGlX1RUo9HLdDkU/TdGzBvqCNWS7Q37xKljxyJFBJKcAD\nfCZYlIp8+OJJ5WJqI5cAM6YyM6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUsidgfkDQsUk05O2CGLCzq2LXzkwHwYDVR0j\nBBgwFoAUMAqrfefNJNtr9N+EEGjVrbvQVaUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCyQqdZYVNOjL9kuMFyOFokxkP7\nuMidHV+Nzq1C6HQsMQIgM+IIscMrGHBFAcVeky12hSNcxBSM2ep+y8Ejmbpo448=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAS9frf5y5CdIic6EB5lkoKbeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2I1ODM4ZS04NjFjLTQxYTQtOWU0NS05NmMwZDhkZTkyOTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQk6eEmtrYG6tca7nwRCVCth7Xfzb/hgN2UK61IJNBPmYrk\n4YagbBKw44X/gWRU2lbc5uXnvc0udyzsWdAlcP2po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMAqrfefNJNtr9N+EEGjVrbvQ\nVaUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGggCi5coFWmP5VjRnpuGQzC7fB0MJ7PLkbkqUAOEGzsCICa9qnDmqjXr\n2XLIGDnmCr3OTKqRUNbiYHGPkO3cgRU0\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAdqaJgKH7g879TDGJ1/AJ32cMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDYxMWZjYWMtOTAzNC00OWQ2LTgwM2YtN2VlN2IwZmJkMDZlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmI2OGY4YmYtMWVlNy00NjY0LTg3MzAtZDJhZjJjZTAz\nOWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtlntA82R6e8kaGy0jVWRYNW/\nYT6nxrGT7L8dakZeKlnBylzN3VKwcQz3I6ZWr425zIaPIkD3qFjbX9nwPQEJEKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRSyJ2B+QNCxSTTk7YIYsLOrYtfOTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22FImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAO5wnboinkY3cDHaJWHfPIdPJIRJ\n8rvfJfzuYzCxD52MAiAu7smAzyR1rtiXzLwzAWWDANoSoEmn46Mjjg+d5vU7oQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9310", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9310` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISARPfMzVpj9vC6ZVVJKzECnbbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYzMTE1MTI2LTg2NTYtNGEzZC1iZDk3LWU0OWE4NmUxODM0MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2U0Y2FlYmEtN2Jj\nMS00MmRhLWFjYjktNzA4NzA2ZWZlMGE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYJvzuoK3i6azc1D1v0hn5RmRZJJU/nFNi8z+HJ9jKphKae+9ffHQtRpw1v58\naMWlQOYZsLJUMcu8r8QrmgRBIaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTU8gt0Vg3IhCBzYKzH0mMPMACHgDAfBgNVHSME\nGDAWgBTbXOPGyn0Wk7C7UlgP/2EubyMhZTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDRjQ2onpUsUHYmWuAoV+yVmMMWL/Ry\nYs7S8KsEKUlFBwIhAI643gJcHNuA4XkE56puVvvi4m9G0emMlw5wFD/nMzHo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVKuAMPFzWCL/wp58cgsqW6wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMzExNTEyNi04NjU2LTRhM2QtYmQ5Ny1lNDlhODZlMTgzNDAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATTKmkJo6ghhEcG7UZ3+qK3vXO/MIjg6YeG22FcW4iIs5yu\ns6TMeKlHL3kHS87HvcHohkHoq6wBJDwOISV45Qixo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU21zjxsp9FpOwu1JYD/9hLm8j\nIWUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGneGHhR1yuBEpjpFuCVePvugAmIV8fJegzVDbLlJrPYCIQCX/XL1Eg4L\nnOeaTwytxVsAam4+RyWikXXHV4A0ydJrww==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAUL6hzROvYv9zzccYbaec5tdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2U0Y2FlYmEtN2JjMS00MmRhLWFjYjktNzA4NzA2ZWZlMGE0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzYxM2IxNjQtMzYxNS00MzhiLWJjM2ItMmQ1NjVlMmY4\nYzZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0E/pkXZRJ+il70PK0b112x76\nBwuI0Zjtq+CAlQv1/euonI3EKv0tuqeeLn9Hfq3fajIaoOyrW/431eC1d4IT6qOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTU8gt0Vg3IhCBzYKzH0mMPMACHgDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22FImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhALS8mw6zM5RB/W7PMhv2h7s/Yt0x\nCfNxCxpapb088OaFAiEAsp5NI/ZQgex5EsXzIsIw8Jlk+0kbkIuHvOnVz8vHmKQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9311", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9311` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAdL0akJ9JlOJ01ABN3bogmw0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3ZDkxYzdmLWUzNGItNGYwNC05MTU2LTU1MjNjNDIwYjk0ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRmZmMyNTQtZmI4\nMS00MjkyLWJmM2QtYmYyM2Q5MDIxNDRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9AMYrZQ9oyVEwQkIYJ+oqcvcKrak4LTGqmpk/cw2NMU55NGktvJNyXC8zfkU\nSX+eStYlQchUxifEGTqHnm2XF6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxDiay/asN6aipXAnONiVO9kkOtcwHwYDVR0j\nBBgwFoAUNXrG9ReclteRJ4uROYCviye/TrEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICQLnNhI4w0+TF+ZaGOlUqGhNDa0\nS7eoLfnK59+cTpqsAiBUieUi8VOB2uC5u9FoBwQs0AzZNtjApFaOKtU/amMIlQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdQYg7Z4HBryWqUsTkVEbx3VMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2Q5MWM3Zi1lMzRiLTRmMDQtOTE1Ni01NTIzYzQyMGI5NGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKcIfiyJaaL8r197D/IZNF9IuhqjbGJqBDgksGYhAtSjE3\nNASk4/UkGk4FWTfBnXzuACw5bW3O2dt5vnwoDzzko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNXrG9ReclteRJ4uROYCviye/\nTrEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgR+fYBZPkNQYbI1Q42quEJojXpDauzUJ6l0xhm5UGjugCIQDrsR8PnS+9\nqzBzVk8ewSJG+00IwNc00hLp16w+Hi4ahQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAXwpOhrfV0FRQeBTcUSXOUlKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRmZmMyNTQtZmI4MS00MjkyLWJmM2QtYmYyM2Q5MDIxNDRlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjVhM2QwZWQtZDZkOC00OWYzLWE4OTQtNmNjNTY1ZTAz\nODIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyTpqwUpsg7d4nFZjnC0zaMf6\n+bPQgurIS/8HnV5wKpB141CRCSgG5uw/mmxAuV8WFTtBf9DtslKTadDqgE/0M6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTEOJrL9qw3pqKlcCc42JU72SQ61zA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22GImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgFnMsHW8oShW5yZMSiZUmSJ2jhmX/\n3rrk1FwKY7HITiYCIHwhMLSq+Jp8SdTUgUSXGY36l8rA5pRU9HOkqBA/NlXw\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9312", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9312` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASj5wkHcGbCG4C5f8uCwLxCkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1MTM5MmViLTdjM2QtNDg2OC1hOGMwLTIyNTNhMThhMDJhYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDVlODU5MTktNGI3\nMi00ZWRjLTljNjUtMTBhZGY1NDQyYWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElkjPiwV14HJ8TTcUhNsqaEeS52WtTG30Ww/Go/cH8cxUY5orGTz9rMkZxmxV\n7SgbRhLluGdOeKKKGewiqrjIa6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSaUOlY07MkTSAqDDNfOsc69t9KETAfBgNVHSME\nGDAWgBThRltK3nchmBfRGj2gL5xCEVTc8TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBlpnr0uaCEj/V+WpJIrCOPZESJcPm7x\neZXFpLy+1VgzAiEAzgmoEJRwzn3MWvSdzWZkBP6+OqyfIYKpN2QROpcqZcY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATzuSZNB1aEiyz8Xr/abp5IOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNTEzOTJlYi03YzNkLTQ4NjgtYThjMC0yMjUzYTE4YTAyYWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASu3AYcpTpcED/4ZFQXd4HKUm+aE4JaueDs3Y82YLaMnnaO\nQjbetS0hWl5dvy5ThgJ8wkqC63OFQBlH0TPYWIFZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4UZbSt53IZgX0Ro9oC+cQhFU\n3PEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIC8+yxzcCFi6yc3JzeqBGU6ki6AvLPxm8+rFKSeKQBNAiAf6tf/V7ZV\nG0x04EzlruFmfjSTJ5FyqzTjRVSwF1CTKQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAQLpkElBnI7DMAUzO8mo5XWsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDVlODU5MTktNGI3Mi00ZWRjLTljNjUtMTBhZGY1NDQyYWUwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzg5NWI1MjItZjIxNC00YWQ1LThkOWUtN2M1OTdhMWJj\nYzU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESWK1NYP/PQ+nJgqyY4BmOlW1\nwubGoIcRnhBB6pxNGSHYSkxPi9rh6am+irkVwqPBcMdDJkMNGdUMuZETlNQWmaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSaUOlY07MkTSAqDDNfOsc69t9KETA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22GImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgVh/eMFdabUGs08O7qz+tv0QA4Jey\nSOZeQ+IGlHuUay4CIDFOsG0NBI+YXRZM259x7aFwphsSpeyhGtTgLZmufyi5\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9313", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9313` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAdAdYy7ZKhubbZuyKvAQnxOQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzMjkzOGRkLWUwMWQtNDQ1Yi04Zjk3LTMyMzhmMjFjMTQyMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWExMDA3NDEtNjQy\nZC00ZjQzLWI2MmMtM2IzZTVlNjkyZDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6hzxHSUl0XbV2TdDVoGwJ6vuwqu5NZAaBh73roD69vtYRPNw2xpnvFW8Vzt/\nFjWdUBnNSTOkaU7bzb2wP5f0CqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgkWBL8BWG6YUI7M+lYCPNDPs5DUwHwYDVR0j\nBBgwFoAUZA0Qre6d6td3kEsWrrLYWvTj1LUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIA8wSQqAUAyZrxnHNlzQolLSwzkk\nYXSuFsdu4dB5A4ZuAiAlxWhL9uTxMDZi1Nfz64itW7XuNM1zFA4AooDHBANdgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAclWzwWNLWJ2sMzz/xaoax6hMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzI5MzhkZC1lMDFkLTQ0NWItOGY5Ny0zMjM4ZjIxYzE0MjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASbY0RCt+AlO/Ei84jt+H+bRIgtv9iJQ924QjtWxxxAsfbb\nBkDWp1j876bXHFqkPgv9ATsePjexfZ054k5tWtjso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZA0Qre6d6td3kEsWrrLYWvTj\n1LUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALhNLj0fE/aj9ezgz+WliOSIiasK8Qq2Xy83SafYdhTEAiEAqse1pRZL\nwBbvV9OtvkvhscQFkLM4E7jvHn0yCC0eBGo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISATGQC0zdD6/jPMknTbgP0tK/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWExMDA3NDEtNjQyZC00ZjQzLWI2MmMtM2IzZTVlNjkyZDAxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTM1OTQ5OWMtMTU3ZC00Nzc3LWI5NDUtNWY1MTI3ODFl\nNjZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEL3LJBaGgqek55lim4s5wOloc\nA+AvSYD1rE8iRh5XQ0f87vZkJ0TJzz8U1RsBnkCbiL2BC+/ITnAT9pic/Q2sOqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSCRYEvwFYbphQjsz6VgI80M+zkNTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22HImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAObjQ2dLsYrb/ln/tXe9RsecT95h\neVHCHmndClhyKVixAiEAiMloaA9LLKnN1lm7yjsAkhJZzvQgk0LLAXxmfjVDLsI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9314", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9314` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXq08lQnY/qZKvhoOWknvlo5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0YjIyNDNjLTEwZGQtNDBjNi05YjQ1LWJmYTYzNTk5Y2I1MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjFkYzY3ZTYtOWIy\nZS00ZWRkLTkzOGEtNmVhYzcwZDMwZmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbgPD0QiqoFMrwmV52o2oFp1WmxBy3P5Q9JRLlW8QJmOH0ILvJvSU1U0fxqs/\nHoeN9AXodE4iM+SRc/BnmTzB06OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQKTDCyeNXn6AHjzlhWIH8+/L06aTAfBgNVHSME\nGDAWgBTLPMag2K8yrM5uJVPuykka1sDtBjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGlsCk5M1/T0ufBQ6layDua9LDRXSEqL\nI+TayhNxopEUAiEAgcXlli+j86Y2MSRr/CsNNjtNXLmxBMweh7gT1w1D9Nc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAY7jPWvgh8CIIakd5hg+oHVrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGIyMjQzYy0xMGRkLTQwYzYtOWI0NS1iZmE2MzU5OWNiNTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARruqs/hUjeS9tsHn1rl8xBQlDCr/bo5Bjjlch/R7dIQefN\nYuDAmC2LpxnntIum8ch6AtmB2x1n51uZnB3bSVIko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyzzGoNivMqzObiVT7spJGtbA\n7QYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMe3yzJckP+NTbL8JuGJjA7tsP275LxYOhX9YhhgLTtlAiAMwOdYgK/k\nmAAqPoZX2JljXVLpTP1p8wHAdMMOQemjSw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAbLRlq6d2LpI95u2vUcKrKsYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjFkYzY3ZTYtOWIyZS00ZWRkLTkzOGEtNmVhYzcwZDMwZmU1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzA3YmZkNDQtYmFiNi00ZGQxLTk2YjctM2ZiMzBmYzRh\nOGFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+BAeGCIzj3M7YQDKMFjgj5TA\noHV2b57ULYC9m0+r8VPdh1WRgC8Q0jWAdotXv0grdZsNUn+EJI2Ef/aCBQaN76OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQKTDCyeNXn6AHjzlhWIH8+/L06aTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22HImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgKWigVmKgEBruoph3buctu1sh636m\nb1A3thD/S9/s6n4CIEM4WyQNS+i5e5UjDcGOmnoqPjT2OSIcKxd6UTCp+z1x\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9315", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9315` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeZU+NYz8ImK19miAH+IQZf7MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI1MDY1OWJmLWE2NDAtNDRhNC1hN2EwLWJiYWYwNWZlOGUxMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRjMTdiMjQtNGU1\nNC00ZTVmLTg1MTgtMjRjZDZkMWI2NGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/N4PSdK2/w4n90MTnsXNzLJBcAvt8c8vmenP2p22uhz0LO6chH8S4ckoYbx1\nsiXa7kN9BCsZiJrb0aeaOTrP6aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/W0BBbm6LKl6EHkaadHnNqtV098wHwYDVR0j\nBBgwFoAUu041kXwjN9XTSoY+9RcoQDlx66IwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIDOD7cCrS98e/wCSOs0Yq8brwQzT\nzyEYDklIaFmrLXnEAiEA4El1jVo5uKhmw3rLwLckLGfJxAc4DukrnvCANIAaiR8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATKimjkdVNFouwMo1PW6Ub2vMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nNTA2NTliZi1hNjQwLTQ0YTQtYTdhMC1iYmFmMDVmZThlMTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR88YahDSlbd3UMLH9OQ/xjZ9Fqw/3Ro4OHJKaIHZtFs7MX\nUeC0fOlQedJxU4jc+Zp0O8tERedeM0K1GTYCstLvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUu041kXwjN9XTSoY+9RcoQDlx\n66IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPbZe6i4vuMU5uw64l8SdmhHpEjxosl+vBuWtbh9WBCEAiAC6rkz2HBw\nZNTAXIVrvajUIrN82Q+XiGkR2ZYz93Q7zQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAfkL54S4Sm9EP4omvPHPTa1YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRjMTdiMjQtNGU1NC00ZTVmLTg1MTgtMjRjZDZkMWI2NGIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDc2YWU5OTYtOWM5Yi00ZGY5LThjMDMtZWY2ZmMyOWNj\nMDc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJSDylujP3KOkG6YGMs4cz4Da\nyGi55AYgftpmn0841RlRqNc4lQlVauB5xUlchju6v/L1SujeJ7mPq0074881UKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT9bQEFubosqXoQeRpp0ec2q1XT3zA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22IImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgFYsYP2hwnatvM2k931J95iGxUP4z\nkhJ+OF7vHovuevACIE+9nPLF7K/m79DHOmOrowqRYJ9qGd3g0p8zUP+rzu7k\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9316", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9316` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAUY72KZSFuYexuOJ2YhM3PtvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGNkOThkNGFmLWY2MTYtNDJmOC1hY2M5LTczMzYxYjlhOTFjZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWFmZjFlOGItM2Ex\nMi00NmY4LTkzZDUtYzI1NTE1MWNkZWU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgFCzWYMoy1ZhJgMbUddLPD1UDOLiL5BUXwVc7AeUXeoxtzwwqVEh3+iPpeDF\nDD5ymXEoTSeOHTNkz+bDLaTHf6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR4aa21F7jZXB1xAsI4SpdR3DpsOTAfBgNVHSME\nGDAWgBQ2S4uYZcuhZf4SFF3OesHF2njMPjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFMsLL41ERsisrpBx5f/kX4glFyUYAfh\nxHCoiEWRW14DAiB7Im+TDtnk/9fJowaZ3HkYQ6CEasfI/qxPIkHQcbqruQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeHC0QvnXY6XEFOrTaq9fz//MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nZDk4ZDRhZi1mNjE2LTQyZjgtYWNjOS03MzM2MWI5YTkxY2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNw6skDB7NXWKczynWgPZ6SaNWW9aAcJawOnjhlkx7mx4M\nNim7IdxDyLZI0P1dBGV2tX1Mxza9kxpQjWxMx99Do2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNkuLmGXLoWX+EhRdznrBxdp4\nzD4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFJkdT46mRwOD05oFZCGJ6hFVcRg5y2roljQQPsanHWsCIAr+/ZUPt+np\nIvjwYhonUG31JdmVgWEtizlngg2ihMfW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAZVTFbTB4jOZxwUmmCMZDUh2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWFmZjFlOGItM2ExMi00NmY4LTkzZDUtYzI1NTE1MWNkZWU2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDQ2MWIzZGQtMjRhYi00MDljLTk4YzgtZDllM2M1MDc2\nYjY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP4TorqWJQdk0A7jsFJwIxxeg\nxnpl+XePGcqOQU8y8aL0V2T48PWElFahf473sUrcaFH5nXTK4P5z+LqRX/3zF6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR4aa21F7jZXB1xAsI4SpdR3DpsOTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22IImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJObtHbNHCnyFtPjOqWlePfZCb5k\nuvSuPZKIkdfsGdJmAiASMVKvVORfHgn3jbi2kP5yqBA/Rrq/A+B9bAFvHPNbRQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9317", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9317` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfTLNTDg1ej/yXBJDCNmZN3GMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRlYmZmZjQwLTk4MmEtNGJmNy05YTViLTAyYWRlODBhNDBlMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTlmYjFjZGEtZWI1\nMC00M2U0LWExM2ItOGQzZjhmOGM3MjUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEAGkEWeesd/rZkn71Ti2RbQuk6MDFiofkPVHCeshNkAD/P+pvC36Q7b+A5+zX\nfXMsJq/tfpY6qlbNXQHeJWXN+qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6CAR9ioMvi3M3QJ8JXrFphJeOLEwHwYDVR0j\nBBgwFoAUt3TclMenKf4pQ8IgQURSOaCDG2gwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBQOgEPQZpQMjl4w4HTj3kF45UGY\nWKMOMf/hunxIx7eHAiEAlvFr6BJFFc5zJ8NKDb7xKq0QVHGrocgYQ77Nm5hxYdM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYQwt20v5rpBQp+FEIBEFKnMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZWJmZmY0MC05ODJhLTRiZjctOWE1Yi0wMmFkZTgwYTQwZTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARpBmQE7lkwzxprJ12k1IFgyqG7J7v2S0gRDojJzX63Wyf/\n0cfxsDsC9NtqyqtPU04TL40zjFOPF3g2u3Vzd/SAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUt3TclMenKf4pQ8IgQURSOaCD\nG2gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM3VNYNE3RqG2AixiQZuI8oHc/FhS//a/utPxFvxUCXFAiAVcMnOU0NI\n+opYCeURtOuc9hTCu8j/gE3tyuUmHY572A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAcxdtmmIfrxhs6uMWj8/8XQZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTlmYjFjZGEtZWI1MC00M2U0LWExM2ItOGQzZjhmOGM3MjUyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTI5NzA5MTctOGU2YS00ZjIwLTgzNmItNTQ4NzBhOWY2\nYTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0HYNzkbmk0ZY3Yy9coAuUjyO\nd79u7zuQn4YNmNacUGLGMiwfZh5v9SbNfTJeLgRYMH2kcX5IQipD+lR9j6qYtaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBToIBH2Kgy+LczdAnwlesWmEl44sTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22JImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgRmYx2o6Et04iNg8mz9ldcCsqgfBj\nba0o6fGAdIlRPlgCICup81sRn/r7DmQv7yJlWVkC3G250Ah/95fzOaXqCIXs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9318", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9318` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcRndSAmrBXL5TheJgGbstw9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyOWJlNGE4LThmNzQtNDI3Yy04NWYxLWUzMzUwOTU4YzgxZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYxODFiNTQtY2U0\nZi00ZjFlLThjMDUtN2MxMzI2OTAyOTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+o05GwkDqphoIUW1xyas137y/IqEGz7SlHHId0SqiXfQN3JZzR3EdVhxh/ls\n2OJh24zrHNOXQ20zvhz5LJiOvaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRyatr00kp8jtW3URwx6ARz9BOgBzAfBgNVHSME\nGDAWgBSd760m98ZRNaP/H/qbxxyEdYhijDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDIE4TE71rMBKwciqFD7/I0Go2WntGg\nALUwVEHDG43HUgIgAU2DeaHugrmkPA5gOSsdHF25ZUZ9XrDvALeQTJOG+zw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaf+psOgMiroRSPdl5PhXtVLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMjliZTRhOC04Zjc0LTQyN2MtODVmMS1lMzM1MDk1OGM4MWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS92k+FU+d+uWVfru4Q7Wf1C/OVw/9+H/Jti6WTfvPSMHy\nsePyAbcYeSdfautj4WR/r82kHmSmBbFbMaBiK/iho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUne+tJvfGUTWj/x/6m8cchHWI\nYowwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgLYPA/cOPVaWmp/ZMM47eVyWzv/Yp7H7nM/ZntAblbQYCIFJVAwrnPsGu\nax3guBeh2OYdE+LqbknqsFGaJC3KIMUo\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAWemx11Q5qCKxMspfsd0+9uOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYxODFiNTQtY2U0Zi00ZjFlLThjMDUtN2MxMzI2OTAyOTZjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWM0NjJkOWMtZWM2Mi00N2E2LTg5ZmQtNWNmNTcyMzli\nOTIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESo8X8flXP6dKc6vLAFCyCH3G\nIaCMOL/qnH+aRnGQ7hIGD2sCNzczGsNI9Wg2ZSCAVrDgd2Gmvo34WZBLuJepN6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRyatr00kp8jtW3URwx6ARz9BOgBzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22JImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALLPcShB2qlTPOsnrPGNfygWeRgC\nYWS7yvfLiCe7CIE9AiAJ/HggaihIQoAdUveUTJtneMzvA/XTrDuU4yxd/l17SA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9319", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9319` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQM5+6UnoOcaoJWbe2XjWDo+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYzNmNmZDdhLTg5OTYtNGEzYS1hZGUxLTk2MmJlYWFlNTU4MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjM4YThlZWUtMWJm\nYi00MzBkLWI4YzAtMmNhYTZiNzFiZDNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo0mNFIycgHAWs+fT17gdBTP26Ho2dNKhhKZkPRnBtfKAmDAs4Sm5VgEokimg\nmfNrFmdAmC7o+6Sdc0vggU63BaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvghqdErIuoO/jwFjlfzRouUxDWYwHwYDVR0j\nBBgwFoAUMXDLNNZ7YZ5pWwTfmM3F2pYlWegwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCOpqQGfQYay1N2F0vZzZ1RZKgE\n1XG8SRx5y5beAi2HAQIhAPLa/u2TSBlCxIQPLS7qYfXTV3cyo7p8FZlMrdhqdMlA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQ8I/NbJsCJnfOmvKpxyDwj6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMzZjZmQ3YS04OTk2LTRhM2EtYWRlMS05NjJiZWFhZTU1ODEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwZGv7HRSr9Bu0XbnOepxCxuQcwNhgScWtDR3uToZprK1Y\nfJ74nur97C5E13D3kJs0ul8Dy6ufRd9S7IyYK9FIo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMXDLNNZ7YZ5pWwTfmM3F2pYl\nWegwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEwo56VLJ5qTDQfwLU1ahLn2xClDhlEUTmFIqRDxIWbwCICJzqRLI9iYY\ne+w31v2KBQ6groyk3CF5HCX3jGFwPWVq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISASJ3DKXigcJNK5P1v/2LekhDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjM4YThlZWUtMWJmYi00MzBkLWI4YzAtMmNhYTZiNzFiZDNhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmQ1M2YwOGYtMjA1My00MTY2LWI0MjUtY2E2NDMzMGQ5\nMzg4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkIWtoZlCJuarZI/TAl5zG26+\nilJu0o2zrfygU9BQ24QG16Bbv0mb1eKTO2tdeM0NYekNYSLa6tprM/3QqkZBEKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS+CGp0Ssi6g7+PAWOV/NGi5TENZjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22KImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJBlLMB5r65nI6BON+01EJvyCA4X\nQAUOvukk9ObAYF1dAiBaQzyCgar710MOSPI2ZmHgoNreiwXVKdyi+ZHen4p0Ig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9320", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9320` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAfWEp/zmRdfNx/RdUL3FXM/cMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ZmU3YTdiLWY0NWQtNDE2Ni04ZGJkLWE5YjRlMTUzMDA0ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjljMTM1NjItMjE4\nYi00YmVjLTg5YjctNDk4MDEwZTZmMzg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVtvBopnH8UFsrvffq/9Mv0JMGwQ7zjc79a/l7+Fr1y0KRXuC0zUqO8Vkb+CK\njKBVUdj7h/Qj77WQjjjhjMWjvKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRCmEbaTcHeGEoUWS29xhbPMPAxcTAfBgNVHSME\nGDAWgBSqwMs85Qakr9kGwDbP9+Uzadm83jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDSf5h2vF+HPUyIS+b7ILiTGExJajcw\n+GM9hLft1BvqjAIhAPotMU0XVJEfnStwPoriTOi5p0xMT5liLOnwKH/huSSr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATrUckZnh1ofqq0kiKRAawdiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNGZlN2E3Yi1mNDVkLTQxNjYtOGRiZC1hOWI0ZTE1MzAwNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATA8iC7WH+jUflUrpVKXV5t39tK8ol7KI/wxnn4U01bFUoI\n8KjjM0mCSaX9EVahqHLuV2pCO+yEgMw9iSNNv3Kko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqsDLPOUGpK/ZBsA2z/flM2nZ\nvN4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKkYArWutMORRriMc/zo4TAbkNPtn9/uUWg+k/pEttyrAiBVMcZe5vxO\nMIoxtjnRiedYjrXkl6tmzAqumwQDAgyFPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICODCCAeCgAwIBAgISAYySpmfiTBSw0Ell7J6eu364MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjljMTM1NjItMjE4Yi00YmVjLTg5YjctNDk4MDEwZTZmMzg5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmJmMDFhMGEtNTU3Yy00NDk1LTk5M2UtMWI5ZjczYjMw\nYTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8ZRGW2ZVeJaTZGNg2BB7nvUZ\n1zp2mXeOpy/RAKgcsuJxDtAMLx7whrYpz2sW+zyl9D+uoNq9h2sA7nNEZ0C4xqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRCmEbaTcHeGEoUWS29xhbPMPAxcTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22KImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRgAwQwIfahdBKVY8pSTQmCwAVx/VEH+Xi3e5\n6rPhWHOfXwkXwwIgAIdtvjPspxC8TM8IZRYoIpjxbZB+mtZvGFYugyM7ATI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9321", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9321` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWDqN9ewWvaKANU9Ayk1wO+uMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZjY2I1YzFiLWUwYjYtNGYwZS04YTNlLWI3ODc5ZmNjMGQzOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTFhNGFkMDYtZTkx\nNC00YTFhLThjMGUtNjBhYzIzNDA2ZjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9pgfzPeMxsdwDmHmkPrgS5MVwE6v4Lk+2d0TP8RILCyXaxs/O7DHV++Xi7kJ\nXgHmI2Afh9bBQ8a2udmIv/eYDqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKc91voCjXs/iEFnr/vnraZzNimwwHwYDVR0j\nBBgwFoAUab4FhswCFc0vSCuCYB1vuNuuan8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIAYwX/cgSlne00ttPkjbAXk+G7kh\n9rnkgfBUca4hdoFDAiEA6b9Ns5fvZgbRnuPUu5UZnma/mVTcPIiaMJY2o3BS8UQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVNOgimrwJVP+dXms9cLj6HzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nY2NiNWMxYi1lMGI2LTRmMGUtOGEzZS1iNzg3OWZjYzBkMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpNsfWwTtXk4GSYsqjohVv45Ut+Hb1g8hOmKZcNjqHMRN/\nda8y4qzCFj1nck+fRNJlqQ4evYkMZJJSHkAEFCYyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUab4FhswCFc0vSCuCYB1vuNuu\nan8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgXoLkORi59iA5Vgym6sxnt+dgXhNGey1UFf4t7tsIHTECIBbOL6kCaurF\n9x2J8apHwloNWvNwli/FnxI6MCus+AGf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAQgrIdPG3gya6uf51xO12kLFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTFhNGFkMDYtZTkxNC00YTFhLThjMGUtNjBhYzIzNDA2ZjhiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODVjODZjZjctNjA1Ny00NGQyLTgxNGMtMjcxNDAxY2Iw\nZWM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEu5zjeE+afh9P5kVeqiWPnP4+\nK+mS+vL51hlC2l3jNN+pLzWAgsCSIV3mKOx/0sX6lhsighc6b255MyNhKZ+MTaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQpz3W+gKNez+IQWev++etpnM2KbDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22LImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALu+uMzhLuHHKd1Y3wiPLawsu70O\nTMm9RA0h7+MCe4qmAiAYfU+jkr5Cm440llaKRltHQai/7klEpkLBHE+BfHItUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9322", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9322` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdMNQ3aRtDNmpGoownywLIRsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ0ODc1YzQ5LThkYjAtNDVhZi1hZTZjLTExMmY3MDg3ZDVmZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjliZjg2MDAtNjhi\nMy00OTgzLTkzYTQtZDI2M2U2Y2ZkMzU4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVGaLcy+HucirqGh2961sS0+83iuTl25l1r1V+oIr4rFWtpQ58Cjmj/uJVacW\njl1//Ry4SkYp2iUBCuPPKinCKaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRflQv5oC4cqmqm9kY62S01x7PFIzAfBgNVHSME\nGDAWgBSUpZIjGbJQEG06o1wdOQLKo5l3uzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBOpavlGAIMHEcEUoU5acUWVkKBBjyxT\n5DP9kJeugxHgAiEA3PP2BSzQQGUVy1MevLrNoGjDJ9zk5ZAfgZOOxrguHaw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASyDL6lhHZk8AXjs3jo2VJBqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNDg3NWM0OS04ZGIwLTQ1YWYtYWU2Yy0xMTJmNzA4N2Q1ZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgtnzQKEaNadstnociIk5tYiwp9gZTH+q/lxQd5WPBbdiI\nCQWPZ/TI7cY72YM7bfKn2tWbaNvXpgDLeixkTFWAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlKWSIxmyUBBtOqNcHTkCyqOZ\nd7swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNe1weyUMIG8BZcSD8gDfoiD20EzyBrTQgpJHsnNdwWgCIQC4TxGMGPnr\nhXrf7MXuedEIq2tVPr6n9c89zJd9cKF+QQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAeCvmYajORVyZaHyizTCR9GfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjliZjg2MDAtNjhiMy00OTgzLTkzYTQtZDI2M2U2Y2ZkMzU4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjljNzg2MjgtNTg4NS00M2UxLThiNTAtZjBiMWU5ZGZh\nYWU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBwAlCBIzCO0oBRtriftYMO7S\nH7FTp9pVwNwVZfw3R+kbos38ZTRdmJQ8s+C1My78fyQpfJa2VmJagefBqchQbaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRflQv5oC4cqmqm9kY62S01x7PFIzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22LImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMtfxeHaaGM4Z5YtPvDpFez6YwS8\n/ZMU0nlv+ZmYh+//AiBFA6QNDYDXv/4rQzLl2vnd8ohz2elyZMW1dRzAtLIGXA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9323", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9323` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYcXE8U+WzsEZCD3PR0gn9IWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGI4ZmRiODEyLWY5M2MtNGYyYS04NDZhLTBkZDc5ODBlNzJkZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmIzYTQ1MTEtOWQw\nMC00NDQ3LTk3MjUtN2ZjYzdiYTRhZGIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETsf5/NrZcW4bR5pLZpVv/JNT6Y0wC7K+lXwXZ5a67m11wNZfSpZ6fv4V1spW\nJkdEFFFRql8beOgtwa7VRwPpVqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+DmOb8HE0r9Zwpp9e3BLr9lritQwHwYDVR0j\nBBgwFoAUttPai8psvicLuvGPh5CIWYe34m4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCOfxbNyS9ybSfIMAzbfO7L+2ar\no9YWffiFVLY6ONRN2gIgE/fbvm/8J+MCtylpmZtUgiorYrK2amTb+ev6sKSnSdk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUMCF/PpdC71JbKmY6luKYVSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nOGZkYjgxMi1mOTNjLTRmMmEtODQ2YS0wZGQ3OTgwZTcyZGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQu1apfDjI39OhBKoGobn6JeKonCZOXfleC3UqnQNybzrVy\nLQPZd96QkvnS1OGH4ScTiKKYymk+DaG7aeFzPpe/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUttPai8psvicLuvGPh5CIWYe3\n4m4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOGv954xht+ZVDFYIUDFRYOK4mOg1BDt/dBkz15xt0mVAiEAvdBcfs2F\nwwjSWnocXQJYHDGd0vQn7L6hgBY2Ldtx7sk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAbet2kMYl3ShA6EKiocHoau+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmIzYTQ1MTEtOWQwMC00NDQ3LTk3MjUtN2ZjYzdiYTRhZGIxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGM0OGViZDUtY2M0OC00MDc1LThjZDEtZjVmOWQ2OGZk\nZDVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkhUxhaxTEG+10jHTnoFIvpC/\n+k58mdTruDCbr2LSFwV+4NI26p5JC1cjabM1GlVq/LmPeqi5Sh5UO8F7+c9rUqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT4OY5vwcTSv1nCmn17cEuv2WuK1DA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22MImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJ6jbuNILe7ssTSfev0urnVzJoPF\nNsWmBwWvffSz6fkAAiA6fRqZY2esMFWUXN3580aieF5MnDQ4elWzlCPwx8mNCA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9324", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9324` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAejcIKUj4xQKWBXR8bW2nV8UMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhZTQzYzM0LTY4NmUtNGU2YS1hYTYwLWEwZDMyMGU3YzNhNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDgwOTA4NGMtOWJi\nOS00YjNhLTg2YjItMWJmOGI3YjVmYjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4Bc/jkliYdmhq2jh5NZ8+K56QFtl2Llo5JlUdePylrjYzZEZ+j98YsAThS/J\nS7qBy61n57F1P46DG2cqcLSuCaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRcLZV/QhPchwd0YUqUhgQhRJ1SXTAfBgNVHSME\nGDAWgBSSjRx7emglHVDvV6vTebWMsF9lZDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFLkC4xw1t/8+wTRR/Z02Q8Tg2wP/zuv\n98cXLplWxrGkAiBSjKNoMcfbvxY4O08xa5wCefub0HHCDR16eZocjyNmZw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQf5bLsFPxpWM1s7xAlCJGq2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWU0M2MzNC02ODZlLTRlNmEtYWE2MC1hMGQzMjBlN2MzYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqs8PpXuXpAovlO7jp2M0Xnp9vc6rzfHFoHYlEGoUNMM8T\nu8ZqgMeyroy3hSlO9jNaZUDexXSuNJgb7gw+yQsYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUko0ce3poJR1Q71er03m1jLBf\nZWQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgZKdITw44D/4yZL9aSJOyxdUvUeF8O69Rh2GA1PGU4UoCIA36cbqpWb9x\nQoYY+BwtxcYuaNBO8IXzlRUniGy14hyR\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISATHxt+qqrXLD370TRGvL49zWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDgwOTA4NGMtOWJiOS00YjNhLTg2YjItMWJmOGI3YjVmYjNjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWJjYmM3NWEtMzQ0Zi00ODlkLWE4OGMtNWI5NWJjZWE5\nMWNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEczHUse66P84h7ORYP8nJGuQR\no1FvPDvvcpBIlnxtd3h2ySKGwNqUspsX4ERdw6JlYfytsSsaocQbqWB7ikETC6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRcLZV/QhPchwd0YUqUhgQhRJ1SXTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22MImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgInvxkNsSJr4dbd8Cd3uxX8EOBtyf\nF36QERT2L6dJ7hoCIQCo4EAZVoaAS1kS9Xx8aCrw7BgjxdzArQqB98KfXZPyRg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9325", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9325` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAaq7C4Vs2nxAYTDzbFSuisEAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0ZTliNzYwLTUyYjItNGM2Yi04MmMzLWRkMDg1YTk0YTNmZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjljMmNlNjctMWU1\nZS00ODc5LTlkYzktZDM4OGQxNTEzYzFmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBVcLiYgrw5nXzVHFvGxTkvLEy/Umurki538KBrvgEkZok0SQFIQQavN7CsP9\nfeN45JSHCZXTt878n/uOwJNjgaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWHsA6rG5y686UlkN9uXcwnfSsHUwHwYDVR0j\nBBgwFoAUNDWENSGtAt6Hl8DZ6u/P6yDDyUowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIBAGRsbU2k9LY9r6FHgSZ5BKLs+2\neMw+QMvGlVsh2nwyAiADihwBrrMzXsnifKwNkR9OD1g7mTOORf1SWDN4WY6I1A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAawK9iDDLtWNLQRQoUqRb3gAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGU5Yjc2MC01MmIyLTRjNmItODJjMy1kZDA4NWE5NGEzZmQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASJi6MgatU5BYZZR0/d7wTfIaiNXkmDjRH1rLlVI1ft/g5d\ntjlOYmX2X89QRGOFZ/c9WCKix9bo8m3Qqf7Xs6bLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNDWENSGtAt6Hl8DZ6u/P6yDD\nyUowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJyc5QDX9lXGEfm4pfJ1R4dUbDTe92fA5nYcEB3zNm5oAiBfnbyUf7Kj\nFYhoafzkJsgAjI2w1Cz9J4s1/aoOdlyrGg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAd6pL6cw4ddtciC4N3LYbEz0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjljMmNlNjctMWU1ZS00ODc5LTlkYzktZDM4OGQxNTEzYzFmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzdmODJjZGMtZDUyYy00MTcxLWFmNDctYTZmZDU1OWQ3\nM2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuyBSwLmiB3gRfFyIUxpRC7AX\nKzDKKXmyKPzdVC+AjlCqy2AyDEfKE2/+z676Jy5oYuLG+tKOkO7RVzmfjIR12qOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRYewDqsbnLrzpSWQ325dzCd9KwdTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22NImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgS4WwBH2O9WIRiupEThtaEPJ7d/v+\nopRYiiBWc59gFIsCICIhBIPmg5Tufc35SmqKO0Y/A3JT6qiEUQ3aVNZcw2p3\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9326", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9326` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAf41D/51Z4qHumYmDUpfxqPaMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhYWQxYTNhLWFmN2QtNGQ0NS1iZDU1LTIxZWY5MTFjYmY5MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTYzYjViZTEtMDMy\nNC00NzdiLTg3NzQtYWRhZjAzMTZjNGM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEch/CO68Ly6FmhvqtFh+hsy321jl7ApIVHFHTKSrBjgDvWLE0oocHGSaZXBIk\nz1/u11uSMqD5/963d2yc/hNmlqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRrioHVUblqAkuTz0awaMKF4Jt40jAfBgNVHSME\nGDAWgBS2ZA1MboN6b5zHj0RKVHKjOY8pAzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICeo0wHAxNoBSmtuRSQ0rpleoXtSbLYt\ntrYTQOZ8ce4jAiEA6qxumAmrzJ0w3r5CZcjEDLXJUK/cccUYfZmjWE9RRbU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAbbkGPNA+4u1HQUgNpUIg++QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYWFkMWEzYS1hZjdkLTRkNDUtYmQ1NS0yMWVmOTExY2JmOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASxk+Vbjv8Ud8/laOcjBRLXEbWUopKqsKfM+0S5cwFrZdbw\n9lG1rfa1cgSRHymVtp8tgBCSwx0Ee52CiU0r7vWao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtmQNTG6Dem+cx49ESlRyozmP\nKQMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgOA9WKw663vbhuNK8yRsICL1j97yoEjXGWmgYquoBZlECIDtFciAL7WN0\n5bNemiI2R5uOUUDfw5J4DatqSShja0PH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAVcktpfs2wwyE+2XTCJEe7PIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTYzYjViZTEtMDMyNC00NzdiLTg3NzQtYWRhZjAzMTZjNGM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzNmMjE4N2EtODE0NS00YTA5LWE5NzUtZjEwZTBhZTRj\nYjQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC9LvW85yu6eAWKQWXfO+gD6S\nC73VM82MSUEadepUWOr+T3jhks53UM9FOWNKjVC2ZLJrwdribNLrrIsJ/SEN76OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRrioHVUblqAkuTz0awaMKF4Jt40jA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22NImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgCiU8/zKRC5mmbDHCgwfv5Cmnlevw\nr+MgFiWpCm+K9igCICJx4ZgZu9uYZPRR/Dv7xAbCxZTkv+rWruE7Gx6QRooS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9327", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9327` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISATQSrOEANd3FSITRPet+bZnNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZjMTRjY2JkLTBiODAtNGUyOC1hNDllLWM1NzFhNWZhNDM1NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGIxNWUwN2ItOWRl\nNi00NWFkLWI2MGMtZDJhZTU4ODYzZmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa4I5Hziz5CkGJ+llT9k2IjcFLzIVzl1CXu1NMO5/oG+gOjwMnlzPrFDkqlnL\nQHG3iLKzkjlCsqjqbew3vPTeVaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU93Go+2vCLxvwwOqMQZQ2FsFSm54wHwYDVR0j\nBBgwFoAUidZVPFxfrmFxkeVCCx18OhuD0McwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCVHBHNIWzl/z6YLLp98Ps/Ckhn\nTWqkj0ybhaXnTWIrrQIhAOAYBTHOpWMWK+IY84hQCgIbl7/df4PJOaxFe1it3/Ud\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbnyjOv8xEKjjOiNtefr2i8wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYzE0Y2NiZC0wYjgwLTRlMjgtYTQ5ZS1jNTcxYTVmYTQzNTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQBmMf+uxE1AFpfUN1+nwW3WUTMGw1g37vDYFRD8vRS/TUo\nLSYuLNOsTY+35jW5GeEOgBlWn/Mw8JcP1oKbivTWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUidZVPFxfrmFxkeVCCx18OhuD\n0McwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANeBLKiHjTjtjtQWJ+fKI9GqB5Zos8ucV6z3YN1WEInOAiBUhIjq3CZl\nRk14yVuRb2/ikxMfikMraf1nmJrcPeUQ3w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAdmR3GiN5JDfq2OiOxNsem2TMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGIxNWUwN2ItOWRlNi00NWFkLWI2MGMtZDJhZTU4ODYzZmE0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWEyMjZjMzEtMGNkMi00MDIyLTg5MzEtODQ5ODRmMjNl\nMDAyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhApUMi/s8VvvpGX2CCDFaS6D\ngk53NVSKb0+HFZm3JrMBSs7RsUxHYAqZ0J88DwIR5+fnWbI+9WyitDizrp540KOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT3caj7a8IvG/DA6oxBlDYWwVKbnjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22OImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgEmOCJxslVoel7l7Fxa9Bla1lMcju\nrf7OdAUM7YI0on8CIHrdyi/vwF00ki4jE5S01j1NXzLbM/HeaqzFUAUVImC6\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9328", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9328` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZfdxt3TyZ61VfZkE/G/XUCzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE5NmQ2OWIxLWJmNTEtNDlhMy1hMzQ2LTQ2MTM0OWFjMmJhZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNThmYTE1ZmQtMDBh\nOC00OTkyLTgxMmUtMjlhZTg4YTkyMGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE4EAQ/dySEJKK1Ho/3Ifr6SbRYM5HwzdNkeP5G6NYEtUDFsziXFbqVwx6lwSq\nxqVCs843wAawHh8ojpdNthYP+KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQd5cVeMu1xSkRBec3Hn88NvwhB2jAfBgNVHSME\nGDAWgBSjoZMlmbQOyHLnXW55kFKhK5kLDDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDiBTuZ/59p0wW/nbNvnrGEuMj94KU+\nJS2yYX/zGbNgKQIgJz8YOtJa0a0r1zsQaJTZ57la+ovut7sAEGaZJtnVebw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS5KBKIvSyCmVaWvovkm9QWDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nOTZkNjliMS1iZjUxLTQ5YTMtYTM0Ni00NjEzNDlhYzJiYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASLEPOY6SBzI/5txu8CZoSVHvRTRFkgLWIFM4GIOjrE5opu\nQWoct1iDSIL6LKKBmWf9NeSA8EYeReBiFtKKFtlwo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo6GTJZm0Dshy511ueZBSoSuZ\nCwwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgaqyBepHe5RlAUupuQF1ADvpKidxto+VjJbhC0tRUORkCIQCSV0E+lggT\n7X0dfAruU76+nExoaRVVyF0//g8cwBTQUA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAf2xyrv+9ZYryeTDjrE4cVeIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNThmYTE1ZmQtMDBhOC00OTkyLTgxMmUtMjlhZTg4YTkyMGU5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzMzYmUzN2ItMThlMi00NGMzLThlZDUtZDg4YTAxODMz\nZDcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9ZbnrfdyQyf8Mu7BKrDo5ukd\n38KNZXIUVXc8F8uIs7YGUVMc+HayqM/QjRp+OBAxeccWyWAg79/Lr+QQxDliEaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQd5cVeMu1xSkRBec3Hn88NvwhB2jA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22OImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgWVMsonRPG7VejRW4TobB57lSCk0E\nPAYYe/+nlk/ftmoCIEQ+ND4u/8kspdLA6UC77NQtmrFtZeguGt3yf8PdTVZs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9329", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9329` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWNAKi81g5iBwrdklgNe805fMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwYzA0Mjc1LWYxNTItNDFkMi1hOTdhLTg0YzRjNmI5NjBjNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTUzZDkxZGUtMmYz\nYS00NDE4LTk4YTktMzRiNWJlOTEzNjRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKZXqaWm5niXvqI5/JS6VRFfgI2PkW2c0rovtg3x1CoSmj7Ta9tkHwMGJr6zL\nCHUKPl+DCg5SHnj5LSqlPYbp66OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3W/CmuET7YOtmEnm5zxp/Z1EdgIwHwYDVR0j\nBBgwFoAUseo2l+5o017xpttDp6lQvRpMGVYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGRRmGIpbOAOEetlLB7dl9xmmuYJ\ncBXRBdpPt8G4GQkkAiEAm/HRCy14ZMyW5U2ESN0PdcXtglcg5+ntwT/SQJ7/OpE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAefI1uiHWb7VL6sx2RhD9iSDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGMwNDI3NS1mMTUyLTQxZDItYTk3YS04NGM0YzZiOTYwYzYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATm09l5FOEiHbuJlLA6UaZnPpOW7oKDB1OaotQUcZ8RGp37\n9vDsJoTyXIbQgTifwmqgoHwadXORqwb4iIDoFd/8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUseo2l+5o017xpttDp6lQvRpM\nGVYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfSR/dBc4SAC3wZiISWzRTkCzxbfBxLgPeIDsbcipHe8CIDWw2rftl2BT\n0ShhDUj9caay0dOdRCQRWDyRot+u5umH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAY5xaJIg6t7c9oTKprFj/syPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTUzZDkxZGUtMmYzYS00NDE4LTk4YTktMzRiNWJlOTEzNjRiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzllZGRmYmYtMjZlYS00NzI1LWJkYWItYmU4YzAyOWQ2\nNWFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB6l7FYemLrD4+arVQy5IUmOi\nCu9+2Z6pADohhGDLlBvTcajgeBDuSluhZeMxGfGmjKjSNbsBAG92hBcEcWvg6aOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTdb8Ka4RPtg62YSebnPGn9nUR2AjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22PImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgVr/VE46CYaRsbrGsAjmZ8DZVGse3\npXBLh4LfKzUGs0sCIAOEXKT80qYcE7h5gFGbm/tFPWFk5lUvti6M1hxU2PzJ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9330", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9330` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAZmDb3FoUom7sbFWRFW4WUtLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBhNDM1NmQ2LTFiNWUtNGI0MS04NmJhLTI4Yzc5M2FlN2IzOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmVhMWQ4ZjktMDUw\nMy00NzcwLWE5NWYtODkyYTI3MThjZTRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcJelS7RShbMbaZ2C2rAK5iVelyDlf5qRgmv5jM+J3n++7OMm6TV4jKvk6311\nYjn75FuCHM+Zr+oue7ck0yG9kqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTgjB8KJPEi4c6j+tUbdUWX//SO+zAfBgNVHSME\nGDAWgBSmYjngJmQaHZGhlzqv8hwyFxlYIjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHJzDtNzqqCBP04L9QVsfHdTELWWGMmD\nAs9jQD4984RYAiAfteDbvY13OwgG6/scXKmdfRjLTUoxb3fRQaT4vAmHzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAS1PlYYZz6r3fZrOCMAs7aN3MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYTQzNTZkNi0xYjVlLTRiNDEtODZiYS0yOGM3OTNhZTdiMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATAdgyrFvBxjn8Ex2ZW5Fo1jXLAlHnHS7iq93i9tYTo2drb\nAUabKa/iJL0PUbREiAuzMLj12FMKuxjrZK71FWTHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpmI54CZkGh2RoZc6r/IcMhcZ\nWCIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhANTOOv6iNZVMHjr25YtYPHTynOVWh3ehg4TeQ0Fw1OHMAiEA8hiUEojy\nbtZ/Z9TzE2mMGwne2MppyOqhPEq9alzqBRw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAfuS0zAAnR6Aa5wL70z8o0e1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmVhMWQ4ZjktMDUwMy00NzcwLWE5NWYtODkyYTI3MThjZTRiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWRjNTYwMzktMzczMC00ZTliLTk4YjItNTUxOWFiZTQ1\nNzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/TUXBGZN7CAjB28Ckr+swK/n\nNUc65zo8872Tpz7asIbwdy4pZUAUk/HBbhI8PnVXNXNjAkZlGFk2I8Cj1zo2j6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTgjB8KJPEi4c6j+tUbdUWX//SO+zA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22PImJhZC5leGFtcGxlLmNvbTtETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPYyM65u4y+7ULeRw5869HshQFi+\nrNqQz5LNfHfzadykAiAQXWs3lrzdkQPhV7t+/w+3A6CVP5EMKDYad4ohlreGIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9331", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9331` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAXWGuQezhwdzPdYHrB4K6CURMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJhMDczMTYxLTEzMjYtNDM5OC04MTkxLThhMTEzZjU2ZDFhNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2YzZmQ1ODMtYjc2\nNi00ODU5LWExMjAtMTNhMTdmZWFlYWEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEtB4KA64SWZpRy7bjxf22KDtkTaXyOq+qjLhLcxmgt8ylT+2RLqyLUnsyA3ZJ\nrWj3HHC7qOFhTC7U1zqn6Jk6hqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDazxPuKFtXjXm9X6s7x3hgsTul8wHwYDVR0j\nBBgwFoAUr+3lOIj57kj1Sry790u95Ew4Tl4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCUJ2s6pRBWbbVqGHxeoNGvXddj\nG6Ym0iVMBgjJwbjjCQIgPeTIt2v499DIOk4Lnm74gG2ecAbU7rr+xPZOxp8nKL8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASMUv+KQWzJ/C5Jacge5we0ZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYTA3MzE2MS0xMzI2LTQzOTgtODE5MS04YTExM2Y1NmQxYTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoj+H07FtcavBE4OGJcH2jJZDHWR+odWEkose9H98k66Il\nUyRlzbmbSskrQiG/N0jhS2oGb77AvojnNxRdXMz9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUr+3lOIj57kj1Sry790u95Ew4\nTl4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGodka5nkD4tJtvtvIwOnotJRlWu83SbwEEv1g+ts0e0CIDN7ak0DwVAg\nre8ntmkfTB8/IZlrGZqI6xeYJeFu7qDn\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAYBiAFAcuE2yey51eXjsgndwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2YzZmQ1ODMtYjc2Ni00ODU5LWExMjAtMTNhMTdmZWFlYWEzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWZiZjY4ODMtOGE2My00ZjE1LThhMmEtY2I3ZDJkYjNi\nMjBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUKZthHaVDILHQNh7daYecRR2\nyGuimvlPaJdkMXjxEttL5gchPcQqnGphGJx1mAnh1Y6VKjq5l8pZXeldLshTG6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQNrPE+4oW1eNeb1fqzvHeGCxO6XzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22AKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQD5ILc471jPvziAkwDt\nEM+CSHUMfht4SvYE8EGPmtOJLAIgEpR2TbVPnZecL2fTXsggkpCGAN6iPnlhconK\nhlXOBD0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9332", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9332` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAS3VY35Fbjqx/8Zae6FvUVJTMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhMTc4MmI4LTVlNGItNGJhMS04N2M1LTllMmQyZWI5NGEyNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzBhZjNmYTEtZjQy\nZS00OGY4LWI3ODctZTM1ZGU5Yzk0OTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELrySJNuu4PEDK6TY1DYjGDPrMQrIKGoRPIvJh80Fk3CJr1dAVbp1/EaWD3sL\n4E+U7WjdhD5tQT1qOuTApj05KKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTIMCoVdHcdFIOEIl02XXzGOiKunjAfBgNVHSME\nGDAWgBRV3KaCd/V/+i+OF7oAz5kBHjNvODAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCkjKrStvE7ZuAIUgLmRdIQn8W6QoFV\n1znTbV9YTxIRKAIgLPrGlS6wLPMoMPc8UIsuAc1bTgmJQiul5IP1fBLh9HA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUlynKKpEaWwWJ1M/f5eBB/jMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTE3ODJiOC01ZTRiLTRiYTEtODdjNS05ZTJkMmViOTRhMjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATfJOxRHIgasx7OjqH/zTEseQ9GblubK8pzpdzzxHefad3B\ncl7BCZbeiBYYg02vKc2QkJWuoCDJUbQTcPad7SmUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVdymgnf1f/ovjhe6AM+ZAR4z\nbzgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJVDTq7LSKyOR6IMdeaYtdih7lICgEhwH2WtP10sihQGAiBGWiCnvlus\nWiZflxW1y8CY+/KpffyttmnWMSO2e5swJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAT7e6RzWbrVAimEZSWNy3TCWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzBhZjNmYTEtZjQyZS00OGY4LWI3ODctZTM1ZGU5Yzk0OTBiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmNjOTZiNzctMzMzZC00ZjdiLWE3Y2YtZjc3NThlYzk1\nMThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK5YWKdCQRWh01Co4hpw06wvj\n7WLpAb2PmehndZNN+0Pi9rst65glDfdddvRQwu82IOBUU8M898hcrMk4cDL65KOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTIMCoVdHcdFIOEIl02XXzGOiKunjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22AKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICihm4H9UBpiP2zCGvxo\nj7n52LYpda041wse7qKhZ5z4AiEAwbtx8jumJX0KwJ28rSZY+ytXRHBTdtLGGEqx\n/cO2iw4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9333", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9333` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAaEkeDW++J83jiMPsZbc6naqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAyMjI3MmNmLWE1NGEtNDhkMi04YTNkLWMyNzNiODA0NmRkYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTI2NzU0MDQtMDU2\nNi00OTU0LWE4ZTYtM2E1ZGE4ZmRjZDAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERidHqBP+bmBMHCGCI1XeXgdgYc3QCCv4Ye+ePxU/X6Z7DYYKxE+Lp8vRoaI6\nBx7oghhvohPGnvffCLlHvwd4y6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlCzibwCjS3c9LhZZIiHKiKN/JX8wHwYDVR0j\nBBgwFoAUvH+F6kLT82yuj5YkzzTIQ1hQq5UwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDnOOsZmgLFm58Es+pBFongmc4M\nTmbwLfxx8omeO//vEQIhANRhJPLuqAf7xpikbxgss89TamkpmH75zkElt2exZWtn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAf/K+wvG6LCu+9GlnijSOLU4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMjIyNzJjZi1hNTRhLTQ4ZDItOGEzZC1jMjczYjgwNDZkZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEjUVQ4h7n6C8I/2ATlHTobtUoRIf5Dx8CJqdjDl6NpZuV\n+gxlZzPldGKptWSK7IPL0G2MyuwW3OQuqDk+AinXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvH+F6kLT82yuj5YkzzTIQ1hQ\nq5UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKg/s8LEN6pagzmV+7bOlGDMhsn/ogqmQNoLYT6XnjMlAiEAw3K4sm65\n1NzUp+52JhYMLyp2HgLVZxaAk/oxCnmhmZI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAfwOydNpO0MllbgtKhCot/qpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTI2NzU0MDQtMDU2Ni00OTU0LWE4ZTYtM2E1ZGE4ZmRjZDAxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjY2ZGJhNjYtMjBhNS00ODhkLTk2MmYtYjQ5Njg3OGI4\nODAzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZe46eOw0/iAAvkW0PDBOnC6a\nQHXklFZdqxJ2s12emlY+xZWePjeQtifrFf/11sZXnymzBCKEe+wwhrT4ADfHEqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSULOJvAKNLdz0uFlkiIcqIo38lfzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22BKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD82qgDlW6escrY83R9\nbnNUd6I5zntFIlRZQM4iIPoNKgIhAPRd0G3sJWWnXQGVprBuuJr1a7pFc91VoNOm\nmusM5p+0\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9334", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9334` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXXIwCsuE1nyCTOP3FwOAFVlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQyZDhiY2ZmLWE5MTYtNGNjMS1iNzY0LWQ2NzY2YTA0NWNjMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzM4ZjcwMjMtZGQ1\nZS00ZjA4LTljMzAtYTM0M2U5M2Y4ZDk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQHCFfD+StkSI6j9DQXiHKJRTEW4GeINA+Tn3Kk1qgtmF2gFgw0lR8lXDdH5v\nK0xqTPDN2vti1qjFzfHgRt/9OaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ0SHnXjfGzymi3CZes/w7DUjMV5zAfBgNVHSME\nGDAWgBQ7eHnYAVPNK9fqGL7DIUuvvGUCWzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIC+/VcBO+IOsvSJuXYdzj3l9KJ9WPKph\nZytTnM+NKcYtAiEAsn19Hbm78RjUzIcGrIkZXsIu3De+Sh5DSJpH7jyQpBE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWzaPnzcM+8oNOBovfqGiYEIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMmQ4YmNmZi1hOTE2LTRjYzEtYjc2NC1kNjc2NmEwNDVjYzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoSwqHvPo1tE9LByV6DiQs1UMW9Z/ktdEDgLvdEGITW47q\n77TQCkrhWN9MQoA0fSKj34g6yyUAJ4uS/3vVSsZuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO3h52AFTzSvX6hi+wyFLr7xl\nAlswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMTnlZo+2Yv7nYmdGXeun2RvtH6otwNkW7+0U09NRhmQAiEAtOreXQ9g\nab4b+TveeY2ThO+7ZrE1ywHoZlHOUvs9+u8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAb6U+hg5Mv0d2EPtOC2XwjOBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzM4ZjcwMjMtZGQ1ZS00ZjA4LTljMzAtYTM0M2U5M2Y4ZDk4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjk2ZWZiZWEtNzk2MC00ODBjLTkxOWYtNmY4OWU3NTI5\nNmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV+wMu5JigA8MlsK2viTyBkgX\naxuC8tgCdl0K9s9rI727LvVgYncUfCJDR1YV0vi2aPQXmbRPTxx60g2ErY932KOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ0SHnXjfGzymi3CZes/w7DUjMV5zBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22BKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCqQW/MYIZEqLs886it\nrGLhELnQYuOYYCwxKvFFoZJTYgIhANhnIzp0P25mgYbMOlt0zNNg0j4CNSQcAv6I\nLirFFQSd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9335", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9335` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAZTyjWvf6wFhdy7fIzxWydFUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MjU1MTk4LWMxY2ItNDliMC04NjFlLTU5ODFlZWIwYWVhZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzMxZGU0NTUtNTIy\nNS00OGQ3LTliYzQtNmRiZTFkOTM5ZjM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEF2du/XcpCSvSYK1O4vnK/D3r41frTCN4JXPLlVJBvv8jdkpKKCYRx/pbAMLa\n6vHh1yQO8lnbQOez3e5EqCbHC6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmrtRxQJ5eyDjizIpkL9vZb9jTOcwHwYDVR0j\nBBgwFoAUFSHo9szykjUsvQDJTx9IsUen5FwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIH/Qfs1lUwuj0/f/gbooSsqlMYDT\nDwZBgcwXeRgS5XrpAiAQ8dZauFaiNUu68wMVjWHI0BsxTFa2hx5WukQYaHeNTw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAQHhMEMSPEDbx7PlNrjqjdVMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDI1NTE5OC1jMWNiLTQ5YjAtODYxZS01OTgxZWViMGFlYWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATp+j/wwMngwTVgCGDbsHdenEX3Nafqe6G0v/owVraJmwwV\nnnd5XGWUcBmNF2K747rNDRiz50Q56F1aQP7cvQ6wo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFSHo9szykjUsvQDJTx9IsUen\n5FwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgaKZdEPCSXWU8yGesa3gYYJGsgbeO9TUqwB00NO/ASusCIBrAUtER+a4B\n9ZXTczxF3ameFBX1pbyVn6zKyTwDJK2d\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAWW+Sgk+1AJHlw+2cheeqASWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzMxZGU0NTUtNTIyNS00OGQ3LTliYzQtNmRiZTFkOTM5ZjM4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWFlZDY0NjItNDM3ZC00ODE0LWExYzktOTA2ZTQxOGJk\nMjk4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEenSG7jELXglBbkrVFADRnlw+\nKiI1XPh9ZuVijV2v0ADPJLGdh7YHNUaZxmdW9E0rFis4GYbLMZqlUOkSBTzOFKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSau1HFAnl7IOOLMimQv29lv2NM5zBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22CKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCFxBjNz048B4UMbkYa\ng+3SbXn4jNbM66vH46Ppqe1dHgIhAPbU3phky2Le+rxldDjINBhAnTiyel4DdLkB\njY3YUqTt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9336", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9336` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAT32EQuy0EFrfuwQ17aaxwuKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU0ZjA0MTE4LWUyYWEtNDA2Mi1iOGUxLWJiODAwNjlmZDJiYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTgzMDQ4ZWMtM2Nh\nMy00ZmJlLWJiNGMtODYyNjJiMzU3OWFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc13RRPMAzCtrIYRkAvsTKnsaRNYm27sBjizCJOFCn/48w2JVFtxRx4JG4igV\n4Q47qk7ANPTY50WRbBb5Rf0PKqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR//+FdZJn4kOHgd8UQFxiIuobaXzAfBgNVHSME\nGDAWgBQAhBjCD2MsHCFvmwz+XlkoKGy/8TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCVB0rMpaAcFk6MmPVsWqOJsJVvd0eD\nYQ3xk/5Y2m2azQIhALOTwVxHgBa8MPTM4BfWrkg2VfesRjo2Ld+Z5uC9UKoB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc4CFaHH9xkXi9acfbAYzPI/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNGYwNDExOC1lMmFhLTQwNjItYjhlMS1iYjgwMDY5ZmQyYmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdVbRDJDaww8apbMHtCR5GvMd8oFvHyVbT0R7/kZCbTmiY\n/6xt4g8nqMvw8OECNqLDlfF50Dlb4GxKJCuPSMj/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAIQYwg9jLBwhb5sM/l5ZKChs\nv/EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKKuoIu8cO0ktDgb+DUTb5wARteyjg88D3x3rZXbvr+5AiBRJx8clZmI\n1Eox7K3l1lTrOlAqB0IOjGFtDOkrQeTxlQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAQEMnv7GwOikims1KPr+SUDeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTgzMDQ4ZWMtM2NhMy00ZmJlLWJiNGMtODYyNjJiMzU3OWFiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTAwY2I0NzYtNWJkZC00NDNjLWFmN2MtOGQxODRiNmRi\nZjYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErJK6VhcnkgMl+UZ8a4CRgD3r\n49e7eOdMgrC4sp9JqSaSBczAmtb4nqicRQMrkMXU6fwBaLvwzpbitQfOADNK+KOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR//+FdZJn4kOHgd8UQFxiIuobaXzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22CKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEgxwTa2pPg/zLAIig/7\nTXCCkJgNKhc39Vtx3hJY1tHbAiBAdwkfCKoK+FaROdgUGPK1wSXrsgXOXBdLAXzF\nIissXw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9337", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9337` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAcJMKrUTm0+0qnUumEsipg/rMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljOTI4YTc5LWFiOTEtNDU5Ny1hODY5LWE0OGJiN2E2Yjk0NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDE4NzE1OGYtYTE3\nNi00OWIxLWJiYjItYWI4ODU4MjRjNWZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+clQvIhwj+tLTiCdwqA5brl0unYKNqOApd0TNMlEN+bye7DrmXHfwneEO8wU\ncVwg3vMSIb9iw39dziqxaZo6QKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAJu5J1lhrFeqxEi7XHzYntwKeGYwHwYDVR0j\nBBgwFoAUW3tjSfDPS/JelQYhLuCBitJAQnQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCvt9Ufj5I65uwwpaHuTb+st7Gm\nuDFfB+K2BMI+kVquhgIhANvWH52/MMvxMo7JBErAk/SlP/MEbE+58/5MQiR3DflH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU5o5EFqWJbcaUXoRqB0OtEfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzkyOGE3OS1hYjkxLTQ1OTctYTg2OS1hNDhiYjdhNmI5NDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATBxdJYtYkib50UzUs9GMGkLoJpjf9V5AdDLgXdK34kX+W8\nBWH1VuOXRm/VK6rB/Fcenlc1gfSMV9FRPtZz5uEVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW3tjSfDPS/JelQYhLuCBitJA\nQnQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdGR5iOOUMKDwQkisiTF8pn4bskMhPJHnoGu+VXp7aawCIFx+lGlK/+Lv\nZUTQjb9xmFflyY0qmrbodimGUJ/etDuG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAeN9NPAdqw0kqb3kXtmT6dkAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDE4NzE1OGYtYTE3Ni00OWIxLWJiYjItYWI4ODU4MjRjNWZhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDJiNWYxYjMtOTA2Ny00ZThmLWIwNjAtN2E5NzIxNTlk\nNTBlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFb0x/LZN3PJdqwDdVfkBwtrn\nyjaXFOXKknqQCAolEBc8EpLYcGQb6EANNLhZtRj2LtoTOXGOm1mEVsHEATs5P6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQAm7knWWGsV6rESLtcfNie3Ap4ZjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22DKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIB20LEurJNDH2c33Qjz/\n5eMaOikXcG+Bt1V5VAMrlcZzAiEA5kBOqMcMhqoW3KygLBecGs7Ii4rKoxtYJRsb\nuyS863I=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9338", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9338` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAf9f6yqDX6v4d82TfD2unsqPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUzMDVhMjYwLTVkZDItNGU5OS05YzRlLWIwOWQyOGFkNjc5ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODVmMTFlNzMtYjlj\nNS00ZWY5LWI0YTUtNzE2NTUwYzFkOGYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEs/Atm2PxfmSei6if2YT2LOdCPwtUlZm4UesS6fy/hTCBRvU8ap59uW2Ny33f\nDyJkWbdCiu6Cxp3k/AWKbgBITaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSYGl+U2rDWmcA+VMgtQgvYNHA53zAfBgNVHSME\nGDAWgBTGWsLdC7Q3mCBhmmRjLhELNUPe/zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAOUAZO4gAl54pwd2gw7g8E0yGX0odrP\nLJdNHYSzoonpAiEAhAgd6cBzYJqnJ2NZLqCwWhiBo7mZ9kQhE7dfNsZ43l0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZuQrv58CYHL8L/ovewmj1cUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMzA1YTI2MC01ZGQyLTRlOTktOWM0ZS1iMDlkMjhhZDY3OWYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARBnbCIkdU7+qqvxg3/sLWfu2zkKjjR2MStZAXb42ufFTzA\n41jI4tNGSiqXBCjSn02+qB3pOxh/rQ1pP511b+4vo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxlrC3Qu0N5ggYZpkYy4RCzVD\n3v8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgdxL8r4KHOblpxEajC7bfBbWwH0DMFRwW8Lrm3Z+YGmsCIQD8jKK/HD1W\nySMsShk7VoulzEp58bjyvwnVJmvn0YW2Cw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAUbIeJ7MFiRENTYP/AiYaOMkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODVmMTFlNzMtYjljNS00ZWY5LWI0YTUtNzE2NTUwYzFkOGYzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWQxYjIyMDEtNWMxYS00YzhlLTk4NDAtMzA1N2Y3MDM4\nM2Y2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi8ckI5eUCJ4k9r+Ww5tqpZlT\nOFxUYyin+RVuwb5pKhFLcJqapAlsPCGJGn5a9ihAYIbPgqr6uxyyq7qKhkrcAaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSYGl+U2rDWmcA+VMgtQgvYNHA53zBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22DKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAzHZXIejxC1U+3aMLjG\nIa7X4P5d3E6NKtEaQQjPB/sjAiBgF5J3DHD5lMBCsUhg2AN3WyPGmzNkJRia0wWU\n8qRmTw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9339", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9339` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAReysF8l7n+3c455PlkAmcASMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1YzcwMmZlLTA2ZmItNDM5ZS04MGQxLTQwMmQ4NDA4NmM4ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2I1ZjcwOTctYWNk\nZi00MWY0LTk4ZjEtZjk5MjY2ZWFmNDE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECZ/QHC1XkE+oKRWWH8/y7OWZ2UfZpyIGzPG/4WfJJJu5qSawDfwiQivNdKr/\nju0nfYfI4sbjobZ/LrXlceQ8J6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYrzlTKKPK9HqXr89AQGcRtO9BngwHwYDVR0j\nBBgwFoAUqtzgR7dLFZeuMnFqdTQ/9bReJuowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHbqvrKf/MkHjyqte9Z7y4h+vyhS\n4ALH80E4E34SrfJzAiEAtsJi9a4r9anJRzKDKmXbMNHshCxoF+0xHZH+2301apI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUAQww7GL6MtPkNBvGuq0kGEMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWM3MDJmZS0wNmZiLTQzOWUtODBkMS00MDJkODQwODZjOGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ4tZw3NpSpd4A3AiYFimg1bZXrm+ZVfFC7A4Y3LyKW0N1J\nDKW4LaUJSM3fJtJX8NqyJEsfP5ITI0HVqz0+xZLvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqtzgR7dLFZeuMnFqdTQ/9bRe\nJuowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYuwTtvT0Ykpi22ZZ8UryxZQVSA8VGztKcpCiom4YOyICIQDm/ktQVMc2\nB7O3rHqJ6cv9Kb4LeO5tW2cja/XN0F7NqA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAWxY5O4RtwuE0/zo2d/rLq5DMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2I1ZjcwOTctYWNkZi00MWY0LTk4ZjEtZjk5MjY2ZWFmNDE4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTNjNDEyYjUtNzBkOS00ZmM3LTgyOGQtNGEyYzVmODM0\nNDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE76Gy6erPNe81/0YgmuMsNlQU\nNqwbXkx+VRoLi8cOQAVgdAV/6km0aHqHvmczEcAJLWfGmtZlWXOGGfCFRoD03qOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRivOVMoo8r0epevz0BAZxG070GeDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22EKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDbbfHsxin5bZtwHV/G\nrHh7AGXeOPCFwmpn8+Dbsi8wigIhAOArKBkHuX1nTxqLgJUtilbqdFqXH/JdwfgJ\nMdh/KNyX\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9340", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9340` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAXmUesbEI4zl47fx6YEoQvZCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkyZjg4ZDBjLTlkNjctNGQ2YS1hYzI0LWM2M2EwOGI5YjJhOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjkxZWM1NDQtNzY3\nZC00NzE4LWJiYmMtMmE2MjMxMjBmODIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgwhN+q38PPL32M+C89QnYHLQmEtNnEsNuCOQ2IcHrG9RxXDNDiQQxg1WsziW\nV7snjcJ4jEKQ017yWqfiaz8YkqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTDWC9AJ/7nrFMxoybw6JdzDk4rmTAfBgNVHSME\nGDAWgBSIM1r16G+cFnp9wQbE1a+qM/YAxjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIC+baa8YtRTq3/ET9T+V96CvP9qunl33\n8aspqGARbquiAiBksjN252GO/8uND1CoeQDkVA2lAnEiwLdYJAvoOaitSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT2LwhZTy6IkwpEijt0N3oWaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMmY4OGQwYy05ZDY3LTRkNmEtYWMyNC1jNjNhMDhiOWIyYTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATmnWMTp0EH7gtW8bEQNepHR1O3EL1J+WRE5xQ3L/rVKsqM\nW01Z0kdUIB1omi6z8XUMsFnlasqhM00ImrnzaNYRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiDNa9ehvnBZ6fcEGxNWvqjP2\nAMYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgP6K/WlgIVbZAsCBLE9dM8Rual6ucgRVRW6CunG72pO8CIAzokpPcHbXg\nR22zLN0qzPbD44PLCKLI2VOGCR2kaymL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAbimGa7WuytUhmwaWpwC27jmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjkxZWM1NDQtNzY3ZC00NzE4LWJiYmMtMmE2MjMxMjBmODIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjdhMGMyYzUtNDE4OS00NWEyLTg5NDAtZjk5YmE3YjE2\nMmY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEadAAbctOBbWVORGnEG4H6WIt\njX0estsSbrm3XZeHqPVad5LF8EDIPq2HFm10/tOQDAqwA8ULVZyuo4yv9EXXeKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTDWC9AJ/7nrFMxoybw6JdzDk4rmTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22EKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIF6c8g2t74vhPMDyERKG\n9oZgVDgjUzqTii0qMl94nlluAiAwYBFutL9/2jWihJeQKMhAujHVBsgmfX4D0Zz7\nNeFJew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9341", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9341` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAburTwhSn9BjCIpEvzeVIM8sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiMDY3ZTNkLTEwNzEtNGRiMy1hN2NhLWNlZGQ1MjZhZTE0ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDdkYWEzYWUtY2I2\nMy00ZWI0LWI4NzUtMWZkNzY1NjQ0YmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEu/lCnR7qQ3lLCrD0KQ6J1HJBq+xpZMduswDVWaBMzvNNpZ6L35+Az90kw7Pu\nhZLhHNba0d07eP8ZYn7UeyVwvqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcTL8RR6xorBz+48RmFBcwAZ96eIwHwYDVR0j\nBBgwFoAUzVlwkeeKPHn/F4n669Rgj0aYB6EwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCvIfUXdXA25HvBF6cmcoXeVJYT\nH7eqLyF+ou0CmIQb2wIgMdAYgl5Cd5KkasLMd6cC8JLW7n58PixqhgQoDMIguzQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATS7g+BlZ406BIfqabL5uCtbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjA2N2UzZC0xMDcxLTRkYjMtYTdjYS1jZWRkNTI2YWUxNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASCSCgUtedvXDAXG86iAQBpoQiwuBUClPZHE5lwgeMhjwoe\ntVvctsMek7TDZJ2dZiFJ7YkE9D+yxtYEE/WiPyl/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzVlwkeeKPHn/F4n669Rgj0aY\nB6EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOr7uHCGu6ejxl45p99tMQbIUWwc0kJIAJ8xhiynMyTFAiEAliF0mJnB\nXWkhRB56wX/8+jlPCEj+nMHP4n5DmALFNuI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAVdKiB8TgiMt1F5mKkoV1uSnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDdkYWEzYWUtY2I2My00ZWI0LWI4NzUtMWZkNzY1NjQ0YmIyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzAwY2Y2YzEtY2Q5ZC00ZjQ3LWFiNTAtNGU3Mjg2MzZi\nZjdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqlPHLN3FqGDIPKvvBdGMTswH\nAX745NixTuoQUPKulmsEQ9Azr13Ynzkf9vZ7QcN1pn6LBf1IirKueDlUwCCi5qOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRxMvxFHrGisHP7jxGYUFzABn3p4jBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22FKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIG9fTc0sM9K4bUZCk3gZ\nutZ7+6vWdXdcglgJR92lNj7rAiAq1k8+BKwDgTYYyxgJfQ5pB51o9u2E8iFrVUIt\nFqz3AQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9342", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9342` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAXX2CEwipUY/79XRiHNiSYr9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU1ZjMzYzM3LWM0ODAtNGUxZi04NWM5LTg4NGY3Yzk3NzA5MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjgwN2YzMjctMmU5\nYS00ZGM1LWEzNDctNGMwZTNkZGJlZjE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEo4NddzPPtMy1EBItCblwz6QWEhvGd1AbQcKkH4cz+NnjYYbrM0vJ+hxrBC/Q\nraHiBavu5++UN6zyFVY+6MONs6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQhJpaXgmjus7/saTa6FOw9dct0KjAfBgNVHSME\nGDAWgBR0k8WO/ldS8rwEpo53bJn9cFRfxTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICL4HHafhb/aAN0vt2LED3l2aYz5Zkk4\nRSpKTZZu8IiuAiEAorPlN3h0Ze1AqJOM94jMCp2GMgUA8ADlILQ5bfJrc1s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfrh4wWvTMy8+hNOj2c2QccGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNWYzM2MzNy1jNDgwLTRlMWYtODVjOS04ODRmN2M5NzcwOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQSQjnQLqQMoD0Wx1hd/sZ60AcEVPiApruVgGSjjWxZrI1a\nK0TvxnjEAZNDyFwmGb2ZtGrSu9ue+UezWgaBz01To2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdJPFjv5XUvK8BKaOd2yZ/XBU\nX8UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUUbOPxvs0uFR9cjZEOKxcTQA87S+BgS/rnTrfPUfx3ICIC8RW9JUF1vN\nC+DcOBUtULR6Fwg0FaacCjuFIarYzfwb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAaaiyPJ3ngFqSchcbiwCkdUmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjgwN2YzMjctMmU5YS00ZGM1LWEzNDctNGMwZTNkZGJlZjE5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWMxNDc5ZmYtYTU3Ni00NDYzLThjNzEtYjY3YTQ3NWZk\nMjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE81f45GnlKGeb63U8Jq77IPcR\nzIcfKr0Cv9Vh7kxYEMhRhHyLw9o2oR/jzWSjhvPflvdb8BqK/Yq/v6BVds1WtaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQhJpaXgmjus7/saTa6FOw9dct0KjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22FKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICC5rAUiKbeCPHcH72vz\n3f5abGPcFW4Hkdd7ZzyV5hyAAiEA+UMmDf7MlVPeOSb5Ze0RuEpSPla8yoTjryT/\nhHJU0kg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9343", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9343` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAQtwzFnXsayuO2qBK0Ac8WInMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwZWI4OGJjLWMxNWMtNDA0Zi05ZjIxLWJhYjcxOGQ0NDYxNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGU1ZTdkZTMtNTdj\nMy00MzAyLWJhMDItMjBmYmRlN2MyMzQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvAGjNGuad1mNh8Ah+mBNV3bv0r7EeIFKe83abGnpRrFnpUrGgdxiBUNiHfUg\nUaUnnWEYFDE8ETTCTq1OOqf/pKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSRc/2rmEmuE+HMpGQosESbAAyJswHwYDVR0j\nBBgwFoAUqVc5cA1hL+stEd/QGwwRaPnbhxgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCICwcrFofJTozty0ddlV6KGlah53m\njUhciGcAATIRphEsAiAY7aTVbAf+djQRj5vEhsfmol1OJSFmmolXmg9KB4GYcw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAcO5B7PyaFtPbhAZNEbhjt8IMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMGViODhiYy1jMTVjLTQwNGYtOWYyMS1iYWI3MThkNDQ2MTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAART9ziX9eJnbKb70oW/v1uM8qo82ZR+Oaostx2G5sDE7t8J\nVn+gnJNAakDNyKaGM1arTyvRwgElJ09bw4q7KHMAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqVc5cA1hL+stEd/QGwwRaPnb\nhxgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJKNk5xpLIbv841iZiRFWOLD2KOkOkkW881X3SnGHZjfAiEA8ELtIyjf\nqHQrzb4mrl45MV1qDSgSdK2ee19lqAKnuzk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAZm47UqtRb0EdxQj30m/lRcGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGU1ZTdkZTMtNTdjMy00MzAyLWJhMDItMjBmYmRlN2MyMzQ0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjJmN2U0MWUtZTE1NC00MTRjLWI0NjEtYzIxZmJiOTA3\nMTFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbOfU6XXAOvZXzqVzW9cLFp4Z\nLmROVaxVzJn8H8hHaYA+8floTyNQpOAEbZN88BqCS+MQPb+aChXivj48bknMlaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRJFz/auYSa4T4cykZCiwRJsADImzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22GKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDjbnJvRlGeXRtcDml6\ng1xOQJlypejVYBaVAR6ChFE4EQIgeA8/DaQbFCFUhHFEKApLJjDbO2HjXxNTeSau\n/zuhYSY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9344", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9344` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAeZaigsA62ibMRjXK3kPgoXNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyYzRlZWM3LWIyMjItNDY2Ny04MDY5LTlkZDAzYTVmODkzODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE2YTlhY2YtZWM1\nNS00YzIzLTkxZTYtMDg3OTk3N2Y5MmU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh+qOKxzuOLDr0FdGIYB7J40vT7h/3glCY1+9W5Is57VCeAGfQmn7Scj6d/s9\nF/+lhSNAevEH5UTg6xIOlcctiqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTrx8Yy4s3jC0EQ4vjuhOf/TwdM2zAfBgNVHSME\nGDAWgBQcvOA94jz2gNx3rE44THpbQhOpJzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDIT+XWBzQiEVgrEAQxAoAMsUmGNfCG\nNLBdxCf43VfdmgIhAMfwNVMiyopB4sxNwir6molhXsSlvNFN/SY4lKw6UWv2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAY9W9SFf9Cfjzne16ppB2YN+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMmM0ZWVjNy1iMjIyLTQ2NjctODA2OS05ZGQwM2E1Zjg5MzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQLvHySYQZtgPh6Z1PiRfn0gH2AtnpmneFpPM6j5Gr+N/25\nfVbQV3xPVbznL3HASUv4zxDA8+PG/FOdBsaamACmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHLzgPeI89oDcd6xOOEx6W0IT\nqScwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgGljos4bP/vANhbEIVPiFcAobglnZZjHeGOj/4XX89gICIGfWS8ZTfIJ5\nzY8Ye/y4h+wUTC2IzrAXr/GWoGPj3Fkt\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAcPm/uyA9EqmhmZLPexUbpWgMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE2YTlhY2YtZWM1NS00YzIzLTkxZTYtMDg3OTk3N2Y5MmU5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2RhODlhZGQtYmU5Zi00Y2JkLWFhYzctNWU0NDYxN2Y5\nNjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEh4UzlrWY5lKEAhaxB0B2yG30\nARm2DGo7433muQH0kP4PC0laTFElPGSK6Kgt0ixejJvaSPLbSVRjwhHu13mAJ6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTrx8Yy4s3jC0EQ4vjuhOf/TwdM2zBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22GKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICMZFfqsFhTGcsMeqB+/\nPoRU58mhJkiRUXhZJdjPvv/qAiEA2QlM6zWjuDlpNgAUleQQrWZzKIGRRwDzh9B8\nMZfpk2k=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9345", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9345` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYg0VxL8Lkxr2DltHK+NB6j5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVmZWFjNGMxLTc2NzUtNDQ2OC1iZDViLTIzMzg2MjE3MDA0MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDA3M2YyZTUtYTQ3\nMi00MmNhLWFiN2EtYmYwNmVmZGFlOWE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ3pBWciYwaMxYs6GCJ1wdGIyc1KbsFNrmV8/DOgF7YBBzJXlN5nnj+TRr+b5\n137Al4QTqdz3asiDoxC1PDFwUKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP4dJJmCWDR8QJpX07C90SptUnrEwHwYDVR0j\nBBgwFoAUzuPsZro+zhcPbw618fde9oJG3ScwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQD3yIJSv8uMBXghY8vmKu2vxiRm\nKjt/R3uFc3D7eI/n8gIgd5IZm6xyST/V0E9tQrblfktHb0pe11FuDrqpLcDKE0k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAek9Xm2V4jXeWKni5nzmoK22MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nZmVhYzRjMS03Njc1LTQ0NjgtYmQ1Yi0yMzM4NjIxNzAwNDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARESgkvP0hBDFjZd1NjLvH34qeA8NO5Z0vdGHpqFuVEmbaM\nSGZ+JO1bLwxJJ02x7h6Xc3TeSp0au62jZkXk3GsBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzuPsZro+zhcPbw618fde9oJG\n3ScwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgBdeLbD60MF93yXfDGHCmlZVrByr3kdMcHXyUEQdSA44CIFRSEkNFDTTa\n7mv+neQdMV7pF8nkCAP7Eolg8AmZFAjv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAcoTXszZy1AoUtLVvWgRMDY3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDA3M2YyZTUtYTQ3Mi00MmNhLWFiN2EtYmYwNmVmZGFlOWE4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWVlMWMxMGEtNTVkNi00Y2QyLTgzOTAtNmYyNzA3ZTZj\nZmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuIYWeeowlIDGrPcdIYmWJNor\n/VN8b+EtoXXHNtqcHbSyEU3EK4jitxtAGx305yw4FmTI3oTMUcax/bI+QfXRkKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ/h0kmYJYNHxAmlfTsL3RKm1SesTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22HKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHTeePVM6F5Fv83+ptrH\nJciI26FHMrwD8er0DxEtKiVxAiEAx6nhHZUFOTa0miT61Y5yw1JJhympNFS5W9Yf\nod9QnpI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9346", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9346` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISARTAWkrX10ZhF2DFIbABd5rrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM5MjFkOWRmLTkwYzUtNDA3YS05MmYwLThmMzFlNjU2YjVlYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE1ZWM2NDAtOTc2\nNS00ZTVjLTkyYjMtYjk0MTVlYzVlNTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjyM9NCjL76mUyEqtkV6ZZTc5OmooJdtQtyw6ybTAWrRMlYX3m3M2JACHX541\nwPl+vjTbf8smce72nUFemHVXqKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQnah4rpoXJaiTw9EXREc0kdQPRsDAfBgNVHSME\nGDAWgBTwqttAmGx+wh7yegqugInF+n49zzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIETlx/16C9A04kr9hE34Mvz5hd9F/TiH\n07hvPJFMtQIpAiEAqefsVaL7VSSUUOuKUQf4xiN44533Y1rp2KC1URNFjsw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAT3iwOwxedhoC/8kzA0iWKGmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nOTIxZDlkZi05MGM1LTQwN2EtOTJmMC04ZjMxZTY1NmI1ZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATbmn8WzTCw7iFJhw5hfXJvqhLsz3a1+OALEG58uWJAOxIh\nipSN5U+xkKGaqt8bmn9vsHLU3NF3pPT/iz1RtnfRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8KrbQJhsfsIe8noKroCJxfp+\nPc8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWXQwkRMwHanfUg2QmFT4zWxiUIwkK9xoW6c8eqaWIAQCICt+frOOhio7\nTrYRxHcp6WXOiGGaiHrW3z3W4gh6CKhr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAYimxCxpZJ3LboqGy+uRUfjeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE1ZWM2NDAtOTc2NS00ZTVjLTkyYjMtYjk0MTVlYzVlNTJmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmFiZDJlYzktNzViYS00OTFmLTg3YjctZTBjMjZmY2Yy\nYjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEu2do7JVMSLc4SpinxO5CiQVK\ntfxqv1DNB7tl4oI9n/GYG4ZwDNH7EXhL1yw2xLNCPtX4mdOwHO0vZ7soQL7oWKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQnah4rpoXJaiTw9EXREc0kdQPRsDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22HKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGj8wgsb2F87LiqHMULT\nXqLsVMD51IHmAh7ZDlIiZpWDAiAHfI9LffsX7Cul75j4X/oikcyikCNQXjrftZBf\nEyz1xg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9347", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9347` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAaY/BcARXqzOBQr0WvQedlT6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiZTA4YTMyLTA2NTUtNGQ5MS1iZDQyLTc1ZDdlMGQ1ZDhhNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjg0MTViODktNTI3\nYi00YTM1LTk0ZGYtOGFhMGIyODljYjNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE08HWTGC6SnH6BsP7naWoEGb46VrD4sQVVkashFzeFwi8urnHkiGYzs1FftcS\nU23c8QXg9Ix8XHRrfGgMo2xKo6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSh3ZHrgdW/BYE/yP+cZQp+28otcwHwYDVR0j\nBBgwFoAU0K4scVsMiIKXdwVF00waSKwNfEAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFmPwGATUMPQ78GCmp6LHR/lx2Rg\nwQ5sfUHGazX/hJYlAiEA0ccbXI/BDgKgRbINDvvlvPQefxsiAJKH0hsLs35IcWQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXH/7ec/baAhWu5aF2CBfWVQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYmUwOGEzMi0wNjU1LTRkOTEtYmQ0Mi03NWQ3ZTBkNWQ4YTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxvMb/lxidjkAi2kfCCFOysJC47bgT0b2PwmhcG/+gnhV2\nl7g0WSOHxO+GjzaZgoccHV+10latd/na2Qr2X14ao2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0K4scVsMiIKXdwVF00waSKwN\nfEAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgA9fqxvVlZ/2MV7sTpakEZ9olZpBebqThi7TT5RQPxZ4CIQCduJ6SOELQ\n6eP5gftzwPgmqZydo9ys2Rkpa9gRa2QRig==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAW2vWF2qPYLaOCMVnluxY7+JMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjg0MTViODktNTI3Yi00YTM1LTk0ZGYtOGFhMGIyODljYjNjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjdjMjMxYjgtYjg0Zi00NjNlLThkZmMtNzZmODY5NzY0\nY2IxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8ZDe2Q10llSuEl3FDsDPYSM4\n5adQif+Rr5eA1obs2gnHfXmA0BsguwfkGtxGt8jspquKpnN/ow78wr4p1CF2AaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRKHdkeuB1b8FgT/I/5xlCn7byi1zBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22IKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDocRDJP1+8ipN4PUQz\nSxzfk9t+wuoPwwDpL+2zYuaoEQIgQHDjRLqq5Plw7i3r3b/Ye93p/BVVNYCGLE/p\nR9ZyOjo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9348", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9348` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUxLHgwWhYmeRZGX54OcqykrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjYTgyNTRlLTk3YmYtNGEyMC05MjMzLWYwNTE3Njk0MjIwNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY0ZmE2YjYtNjY4\nYS00YzQzLWFhNDAtOGQwZTJhN2ZhNjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjMv7WITYOBrm5tW1JlqLe0shGQqbPY3Ydv3wQQ9SqUPFipU6+zZrEZipzIdn\n85I8Mqc22QFhfRyft5JXRarfCKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTSmmyYUYoDLF8JCESf7bRbZnEg/jAfBgNVHSME\nGDAWgBTitI5ag6FcLoiILcfrkfCvPDuFFjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIC1MKPB08llFKVySGXaWtWwz6Wi9/Y3Y\n3IM27ceqvha/AiEA69tHEqR4Z3kY9nCGCi3ji49aRwFF/9wREc+OVvxXXf0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfQPF46tZ95hmQhoxvg7X7l+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2E4MjU0ZS05N2JmLTRhMjAtOTIzMy1mMDUxNzY5NDIyMDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQJfR4uPEA2ti1R3/3bebThQkd533WZFLPkTbfvYoIrzNTF\nCANx3Nj8o/ZcBojnTkSX3oeqWGP12HqOfosHxlzOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4rSOWoOhXC6IiC3H65Hwrzw7\nhRYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAP3QeYTOLABJkxDS5i7SObhrYje65+UCDBt4ia96P3l3AiEAlj6ldGw/\nXrbLGDXHpcLI/vsIVsYlCNMl93ib+el7KE0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAZ+3s9yGSvQl9t2O+u2VRs29MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY0ZmE2YjYtNjY4YS00YzQzLWFhNDAtOGQwZTJhN2ZhNjhmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDljYWNjNzUtMzIzMS00ZWQzLWEwMmUtZjY0YjYzOTk1\nMDJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtULwgaTHoY6QWFPcdGIEXBJP\n1meAP0VsowigcmxJ1w5RvdBPdjDz4d7xrB5zoszpYHlVPrGPShDO+u0oeGwaxaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTSmmyYUYoDLF8JCESf7bRbZnEg/jBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22IKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDrSX3X6QeWEZKYRuTH\nEiL6YaN7Qvdry1akx8qsD+5x3wIhAMkf0/dOELWdvXnSF2OIoh3+34oe+6fKryNy\nI3Y80Mt7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9349", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9349` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAbHcl90F2kML2bSi3OVoz58iMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZkNzk5ZmIzLTdkMTItNDYxZC05YWNmLTk1Y2NkN2JiMDczZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjY4MDcxNjctMWVi\nNy00MmVmLThjMDktODQ0NTRiNzQwNzJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEf0CV7ErRz3KkScCYwnjkrIzMpuqkIT9wzDtVuGS6GsC4slviJb8q9QnB/qW+\nfTwOLEOo8Vsy05Ip07eF7N8Kt6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwnAu30JcAedsDAuUUXmiEFpm+OAwHwYDVR0j\nBBgwFoAUOaTMtd/dEkrf9tK/sACOcy8aS7IwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHxD/M3x2nZeYd0jIZjnifYNqcsS\nc9VoNn5V9ueEpnGVAiEA4P1ZhgGVmKdX7uZZUsxb/6gdbiM1dzCkDle0ZvSliyw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdXY32PcZz6tBAyOUxE5JOOjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZDc5OWZiMy03ZDEyLTQ2MWQtOWFjZi05NWNjZDdiYjA3M2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASG0AYHR/A4l1G2I7KRMaO2zXg/WPXCciN56WzABhsN4ciD\nZpJ9zblL4ZCmeuM8ktiJT7/MdAAhgPMADwK1cXbQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOaTMtd/dEkrf9tK/sACOcy8a\nS7IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANUACMGiSBZyam2Mz63mS4fe/cdQWasRGrISLzLFLhuQAiB4HGMG/udF\ngZTP8i0UV6Z+SfE6ygzLVa0NFsGSxcEOSA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAUMT4nVkietMHLrMWHBrpETkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjY4MDcxNjctMWViNy00MmVmLThjMDktODQ0NTRiNzQwNzJiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2U0ZjI3MDItNWNmOS00NzIzLTkxMjEtMjZkOGMxYjg0\nMmQxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELr+AJZew5pVbnJ/T20RotSPE\nnF6C/yKEfMUZVdBoX+1qFvQKlhx7gxumTZhQ2bjoHrqBq54Ow1c/qh3cwMt6T6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTCcC7fQlwB52wMC5RReaIQWmb44DBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22JKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHj0IlNj/KFthT8iCV4E\nCN/LSDGrZV/9WyA2I20HW5rCAiAZtEhAuD6B7EZDYEyf16Q+s2VfmHG/zy3wHEzt\nJQB5XA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9350", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9350` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYl3S8gTiF+OUagl9vnkRGiDMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5ZTQ4OWJkLTY5MzgtNDlhNC1iNzYyLTk4ODRmOTM3NjZlNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQyNzEzMmUtYWE2\nMy00OWQ4LTg4MzAtMzQ3ODVkYWM4ZjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESbPPyzcSPnAOcw1JASOKmKCfXxHWVYermiYEERXhto+DPyh5tloVFekNo2yb\nt9CTrBg6G7a/qkH/qCuZ1ECKx6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRYJOpTaUCFonPDbcjmlhDdN/CPFDAfBgNVHSME\nGDAWgBT9rXhAMUHenA+unTBxmKExH1vkhzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIB8OmDYOU8hP81d13u4MeKI+DpDWj+Ud\nlzSpgZR5d04tAiEAkEbvf+dqIpiYRQjW6kQdfmhoyMf9NX9xiPDF/nI4jRk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdmgcBZwhRownQRstAf3ywPWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOWU0ODliZC02OTM4LTQ5YTQtYjc2Mi05ODg0ZjkzNzY2ZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAStpD/C/fyaZHxcnxBc0abE7Va+NV8VgJJaW4Z0rqQU35Dr\nR1IDl/zElMCDliIPwTcZeFtsTklocWz2wiXsjDjPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/a14QDFB3pwPrp0wcZihMR9b\n5IcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIOWWjj/4r4klsoPAUxsM68QkfLr1aAq0YH0qXiSV5T2AiEAvb7mlVF6\nXashEW1hXJlUnfX63Ps0baZ9klteLijDqjY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISATavqpUhDZb2VddBR/cgzYCmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQyNzEzMmUtYWE2My00OWQ4LTg4MzAtMzQ3ODVkYWM4ZjkxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODVmOTUyODItZDkwYy00YTNmLWI4ZmMtNjgxMzJiNDBl\nNzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOCPkAsBISd+n7eHcP/+vklnJ\nFMxTHMC5qUS6/XVFTJwHxXj38JpszbzMosjjOYTrc7V2BSnXkLGcLFy5n/bUuaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRYJOpTaUCFonPDbcjmlhDdN/CPFDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22JKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHNIC3RB3Imhve24w9Ds\nrynIGU4ED8gzhH7Cg5/21iwdAiAsIZ4EXZvOXYvhoS1hvKkPIz+Ng0AM2Wp0wH2A\nNiYEFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9351", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9351` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAYIZZR3dd05bDxKG1lqt2CQ/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFhNjU1ZjYzLWIwMDQtNGQzOC1hZTIyLTEwMzRmYTQ1ZDBkNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTM4OTQyOGQtZTg4\nNi00ZjAxLWIxZjEtODBlNzBlNTU4MDc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVlp2BruPlT/GLvOquBvfpvIZHT0+rCKX27vmSOmr61Fvip+dmMhvjJe2p+YT\n0C/eufan7Tf1KxDCDVLM2wp+O6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5m+e9Rx1aNPaQ2xuf5GDjfVegCUwHwYDVR0j\nBBgwFoAURLvy6v7nproSmg65Vs7we6l8HskwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAv17NwSxSqV+gR4wjgED8MYJ8Wq\nw9NUySm0y51erJ0UAiBReBeXYrAC8NofZi01FUCLjs45n9JgH2UBz7mZK5ab8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa0RBBGyQNaZD5gw0PGicOcxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nYTY1NWY2My1iMDA0LTRkMzgtYWUyMi0xMDM0ZmE0NWQwZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASjffcSQKhjvsnBxffmaD+ohX6haYpC8R5c/HOK67WYVjHB\nba/Jj2nAuC5gFp2JpoK0p0VBlE9yRJ7R1CU8Vx/5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQURLvy6v7nproSmg65Vs7we6l8\nHskwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgMPI+5vV4ZxLT8B0mipD7utxTcZNS0194syZjXyUszq8CIQCL4xHBYT0K\n0Y1Sj0jq5Qk4EGNY+rRB+boWZaEhYCftew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISARD4Ds6g4UxIqMMF5CRk8q++MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTM4OTQyOGQtZTg4Ni00ZjAxLWIxZjEtODBlNzBlNTU4MDc1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzgyOTVlM2QtNzgzYy00MTQ2LTlhNzktZTRlYTQ0YTA5\nY2IzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6EEhvTeWl2C6hBYUOBTmhZo8\niQtKJgqcPnzMg2/KIcXb/n1g0dezX+0b3ec/AU5buFqeSoOnUVZeNEvGfkritKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTmb571HHVo09pDbG5/kYON9V6AJTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22KKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCqIaDtigNzEdem7G4r\n+B9U+cnseIGoXHL679hj/rDZggIhAM9LBGhhiLXcgAkaO971xUFqI5eGRbhAjGPu\nqEnN7k6O\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9352", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9352` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAb+GHEFjggXpCQhQk7ne08czMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4YWZlZDY1LTQxNWQtNDkxNi1iMjdmLWI2N2FlZDVjZjM0NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDRlNjMwNjEtZDg2\nNi00OTlhLWFmOWEtYzJkNTZhNjQ5YzdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEba9Bad0kiyd47IgWOPx8m7vpLflePL0+MdoRuanzK+wVZHqRlv0+81ao5WGS\ni1+qPSP+sKDuDbWNMzFf8+TnlaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTrhjmqoWxv+vxW/BBpZeuxv63L9TAfBgNVHSME\nGDAWgBQ7qPBDQSIIRWYkF6FM2kj4pdbNsTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIHu7A2nQFIvwlGOCe/+7KT6fT4c0wTaO\nHePUeDKYJm7gAiEAwJiCaSm7/QqSCnCpBDQevMt6Ee/deOPwSG+fDlY6r7s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAReeUFeMgsfw8UEiZ9B4jql5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOGFmZWQ2NS00MTVkLTQ5MTYtYjI3Zi1iNjdhZWQ1Y2YzNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT5Td2STFH8iZg+YU3g9QDQSwt5WHf5nfQWUaTov1RLXQgz\nWiad9UrtYYMDzPEla/xs1TbfqWtYn61A3c29hksNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO6jwQ0EiCEVmJBehTNpI+KXW\nzbEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU2UOPj3s2rfrUUnIT6wGZml5WSxDZCWhqyv10hIzJFQCIEFq4PBZ+cQG\ntOPeTAqMG0pF9Q6658HzFlKjWurVmSqk\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAfmWcHElA4QI20zs8c0nYYPpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDRlNjMwNjEtZDg2Ni00OTlhLWFmOWEtYzJkNTZhNjQ5YzdmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGU2NmNkYjMtNjkwZC00YTgwLThjYzEtN2ViMDEzMDU5\nY2U3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELZi2SM0wJqG11ndivgQXdhHO\nBhpULzKE3X9vd068pCAYMPH3bnZ2lefttqqire4sLYcz3Unw2yeWTCi2waqfI6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTrhjmqoWxv+vxW/BBpZeuxv63L9TBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22KKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBTVY9J59vmSA1ozkT6G\n/V88bPemrYw/p3tcphQudR7EAiALiWghqDjOzu+tbbvZHAs95Y7vKXSifgjs5Qxh\nxjSaOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9353", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9353` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAUorOMm/3eOBFdqa/q6CF2glMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDdiMWNlOWUzLTI1MDEtNGJiMC1hYjdjLTViZDg3MDczZDFiYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTZkY2E5M2UtMGU2\nMi00NDI2LTlmNWMtODUyODg3MmViMDY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmwqskMxKFoAAF73xPWIeFew8UC/y/maOgP66HCJMz0jxfZf1t/mT9E0M33VW\nlMgIWwzE3G/PUZeR7GTIJrbEQqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4SIeRbVm4+a5+VY94gIyNgzfbVkwHwYDVR0j\nBBgwFoAU4X1H1OsxtLift3Lnmgdmt2N6wdYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEVdDvyn06M/tORhBjXBHPYK6pSv\nVyd0FXvuiuYHQorZAiBKK+qEki450hIJdVxafOCUq1Veug6KHWcXFZAosRLWvw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAVe+LDnVTjC6vlpgXyEuRPXTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nYjFjZTllMy0yNTAxLTRiYjAtYWI3Yy01YmQ4NzA3M2QxYmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARjyIoXJH468U4ral6owSK2Hgpe5r4LnOLRk2NfdKs+EybQ\nJqxRdtIOP37vTSEmhU+B+bONU1GoBuJoicqjFWFSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4X1H1OsxtLift3Lnmgdmt2N6\nwdYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgDY/yaXnyJahogXEgPJicCK77+R92/QmiTNnw1GWJ8gcCIEFAEEBQbxKz\niWqZYqKddJB/yGPMhBMlSHQhojO6GDyL\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAZBZePhKYGihn4twG7r1lsEIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTZkY2E5M2UtMGU2Mi00NDI2LTlmNWMtODUyODg3MmViMDY4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmQ4Mzg0OWEtZmNmMy00YmRkLWEwYjItZDZjM2FkOTU1\nNjExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOUyJ9NMyrv4FmIEbsE7cnYQL\nOhevOnRKs0c2y2e3l8mzz5S5HBXi7Mlk9LFaGbcvZZBnJ8piyS5IvfYLn+fp5qOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBThIh5FtWbj5rn5Vj3iAjI2DN9tWTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22LKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIB11NKbnqWM4NIAghuQZ\n1Sb0SleLN/Q2gftBw2/JCXuEAiEAvul9iuCn0JVVwSb9q6wykdzJvvhEK0Ivf1rq\ndk/u3AA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9354", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9354` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAcZBRh5Rmm/5u19x2qtpLKHmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJjYmVmYjcyLWNlMzctNDgwNC05YTQzLWQxYjlhNzllNjBkYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGNiNDRiOGMtYmE3\nYy00NmFmLWFlNWQtOTcxZjEzYmVlZTBiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZ7PTBPrV+uB5gK8Iy446aGMxhHiynncowhj2igbMD7HUn4BwXxbXLT20CBTi\nZET9kqJzTvOBj1sGd6DCGH0wzqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQWaGiYW0em3fZNT7aQFMDVsp6MZzAfBgNVHSME\nGDAWgBQQkqkvzGAxFJeJ7Dq9Jxe1speSIjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBNa9R8LLUNEAu/vMdD5je0XQntv4kFn\nsw69VunyAOYNAiBMyZCpSxZ213Fo8n9CQHC9QSmolkG7mWrKqriNk2llOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATO9HHPfB3V7Y0dngJxENo6mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nY2JlZmI3Mi1jZTM3LTQ4MDQtOWE0My1kMWI5YTc5ZTYwZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARkOKZB7m55ootOIRIQQnaWrmkltuKLwO/YffoECGmmS/ED\nQWU3A2moTtFuyWAEPdTKFMHUbHq7igIYbpkRiftzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEJKpL8xgMRSXiew6vScXtbKX\nkiIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAODMSJfmvce2LPmzoUfPufJoCMBbG2vQd4l32SD0BIhCAiBJ/cS0wZWP\nKQ5ZJV3WXiGtSEeYmdnKgQJI3IUlo71tBg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAS6Aa2AuglsyXJOVJ4ugp9CjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGNiNDRiOGMtYmE3Yy00NmFmLWFlNWQtOTcxZjEzYmVlZTBiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjNlMmYzNGYtNmU5MC00ZmQyLTgxZWMtZGNlMzhjMGRj\nNTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE15hr5uwbj/HS/S3PazFVX1jM\nB8k8Myjb+BPhYkupkHkAhTS+/W1YI64USY640bivjl0SLanJJ9ayVa84V7grPaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQWaGiYW0em3fZNT7aQFMDVsp6MZzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22LKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDe2fCnvLSSg3rZ6Me8w\nAZxhghmGa0yyCLAdRiYgq43CAiEAp04CZRQ597Q52Jedl2OeNGF251xG1/splzDx\nSEKaItU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9355", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9355` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAS/Sgdt6moYXhuCzN/J+XIjrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBjYzA5YzQ1LTNkY2QtNGQzOC1hMDYxLTg3Mjc3YTc4ZmNhZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODEyODk0NWUtYjZl\nNC00ZjNmLWEyZDQtYmVjZDQxN2QyZjMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh5n64WnvvAnY4Nhe/vZbibengnJuSsyuwS9uSQp6OFxSWKnILR748CP88DmY\n8k72rvlrJAJZVYvMxWMrnDMNT6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfxw421dr4keCUgBXz1a3ErLg/r0wHwYDVR0j\nBBgwFoAULdxBKXhUMCeqDZo9zfrdgC96SxQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIBCK+0ZV9k5yXA+NCgcFnTpRtFVQ\n3WRQWG9M43tXFAs4AiEA1Ao2KXWGIF2sQFpWphtBYXRB2mWHZNDb2Ln29LFP0zY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAY+owphv5lu7vjsIlGQ+neAMMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nY2MwOWM0NS0zZGNkLTRkMzgtYTA2MS04NzI3N2E3OGZjYWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQANB8DqqQ3Q5c3rim1AbKMwOcCwcWBAKb+ZP6VAwU63wwq\nVq0VaaiKzaOkvIn1uaCGbCJF8BkNwxMAFzIv6oXOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULdxBKXhUMCeqDZo9zfrdgC96\nSxQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIEmEkzghwH8CCxjhqKFmlUuZdkj6JFZtFGCcKnwqTM6AiEA/SBxaNRg\nM9QboJzU0Y4pvBy+ACiarc6FnBFHtZxgiOk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISASWuOyM/4pUr/CG5NX2ZoZnlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODEyODk0NWUtYjZlNC00ZjNmLWEyZDQtYmVjZDQxN2QyZjMwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTdhMTFhZjYtZjRkZS00NGYwLWIxMjUtMTM1OGMzYjAy\nYzNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERe8XBEdAnhSeBX7zc4I1A2Cm\nuR3JoBngXVJgJrinKUEELht0C/uHyRmX3Fqohy5XNYTc4KD68mgLXYm762b8n6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR/HDjbV2viR4JSAFfPVrcSsuD+vTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22MKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDW72gu39FCfg7vJaTJ\nU/WIxDXl7HdgZpvDTbjHHiIEAQIgCv7ieBY/xicRCjkfOrfJ/pD14qpmcFFb73Ae\nvVFVSJg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9356", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9356` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAavTXlbpMela1/xKcQzYmKx6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzODZmMjU4LWIwMjQtNDZlYy1hODUxLTlhYTRhYjk3MmYxMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY3ODA5OTYtNDQw\nNi00YWI2LWFmNzgtNWE1NTM3YmY2MzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0NiXRYD8m5C5YXUbQRXL8toV1RgPWwYRQZG241bPjB2yNBSdp1RIoNcaV/y9\no7BqEsDoR6i7ZIzon5RDnC3WoqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSXvtso5dN9+Q9J0COmbkIfMWpHKzAfBgNVHSME\nGDAWgBSxoupfCWjsb8Y7qg0PQabV10bhjzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDKrwIAFL3BDyp1klHEUaVQva3Fqz7ar\ne8Ee5232gm1SAiEAi1aopMCrPFwHsiI6bFnt/YFHC1yqynce1vDpEnBbNx0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUwKoA/R1bxVPBDGDgzdv9AeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzg2ZjI1OC1iMDI0LTQ2ZWMtYTg1MS05YWE0YWI5NzJmMTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARJdyRa3LXqcZOedvsEvt9ZGbcJTQdd4SuDPSgx3fwbK79o\nLFlo5MY7XBAh+TuzntA4yDqB3/dNwm2/EXw242i3o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsaLqXwlo7G/GO6oND0Gm1ddG\n4Y8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgYIDmqrepGJRPiZ69AQEXuVvBi8HLjJAj53GWHcD4AIcCIBhIVjVFwqSS\ne6WItxz37JB0TFn5bs5SRHmD6NxKtYq1\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAe/DEbzKVjCxs/NZt0nKnvGJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY3ODA5OTYtNDQwNi00YWI2LWFmNzgtNWE1NTM3YmY2MzhmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGE1YTVkMzItYmYzZi00MDM1LTlhZjktNzZlNmM2YTZi\nNDI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEG/B1ByXrb+fCVGVTAAZnAng2\nmIAp0RYdXccSHvxhgs65A0hXNkEUbc6Pl6HRzNPx1b2ur6zCkcPfSplKNcTGt6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSXvtso5dN9+Q9J0COmbkIfMWpHKzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22MKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCoD1uZIFrSP3NCM89w\nRzHHuiN5gMn5YHho9ZWk2CLR5wIhAN01twXv5mdLZeB8uoLwqTyTJgMcYTsU31Cj\nMPgCpJcP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9357", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9357` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeTUKqXJMRGquYU+/dLHUgjXMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGYwZTY5NTI5LTg3Y2MtNDc2OC1iOTIzLTE0MzNlMjI1ZTRmZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTFmYWI3NzItNmY0\nOC00YzgwLWIxYjQtMTg1MjY2OGM3ODIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEA4S64DaNgKPqEAItsL0grM54WcxHSVQUaQYof8vJko7MKJeHLH0KtDeQFcYk\n2mfpYNJkb9EfFdmGmiI0eZTpCqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9vn5pCgMh4a3HT5xfd+V9mxOxzcwHwYDVR0j\nBBgwFoAUhM5IC1+Tcomexls2ulY1v2ItiIIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIC9OwGwmUnnwiB+PtdISDAcNOB0P\nsVbfexSE71m4Lv55AiEAlMYpt59jgq7622JaVIy8HkXIycEWQ/52G7sfvieaboM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASCalmbPgGUR/mg4Au+Z1D+xMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nMGU2OTUyOS04N2NjLTQ3NjgtYjkyMy0xNDMzZTIyNWU0ZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS65bRf3tbq+FgtKYSKMJ2Q0adI7ekJ6SPII26bfs/z2VEi\nhI4BslVeClKWCjndqdV0aLw724UraLtAIFULbXMko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhM5IC1+Tcomexls2ulY1v2It\niIIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSzQPiAkbnsaJKVNTKDH3WgywvI7Sf86JqYU6jJhfQXoCIG5wjgPWCZkP\nWAlkv0KzUiXGUPR4UqCUAQKrNE2t/MH4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISARpyy8b9V3U0ejEWMQV/h4OnMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTFmYWI3NzItNmY0OC00YzgwLWIxYjQtMTg1MjY2OGM3ODIyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWMwNWU5N2QtZWVlYi00YjljLWE2NjItYmMyZDc1ODkw\nMzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH/1XONFzAo3xxrgosQdRUa+C\n0kZ8UaBRRNg6iWeSIGb+E5RhCVKTfSyJgZMlRGYrGiu3pZK+4g0IumaIVWcvNKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT2+fmkKAyHhrcdPnF935X2bE7HNzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22NKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIA6jT08VqBE8n6UzabCO\nD366aAlFX9WH0QHz2fqjzaPLAiEAm8ZpoHW9b6g8azurmXSMTm3F7UHjrU6bkDnb\nm1B8NgI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9358", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9358` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAR65Ed/+ibb11mvynZboCwOfMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmMzY0YWM4LTI2ZTItNDQ1ZC05YzU4LWZjNzQ1MTFiMWJlZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzc1MzllYTMtNDlm\nMS00ZGM4LTlhZDctZjg2YWYxZTVmYjMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEl2Wfz927imAZbJmgRHeiBu0PJxGIeP/DCVqnwgB1izc1oAfGnoglkPfqRbk1\nNqNQwE1Agf9kVsfULPsqKLf4JqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSdFaOuOCBbvCBjuR8CTCqA78XKZzAfBgNVHSME\nGDAWgBRNahpL/3fd42eThDv/iOfv4Z2lBzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDOrhPKkjg1mzCLDHv9y4dSj0ht3HDS\nsLNE+HvpDdbR/QIgFxTMTqHgEz3s/kVE/5t2PyBs361H6IYzc8owOM2QlnU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbJ7g9VQF1Y/llDd1NQlNsUBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZjM2NGFjOC0yNmUyLTQ0NWQtOWM1OC1mYzc0NTExYjFiZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyZiVOoMCIAJgxnmkhr23hap78G+AKXBY9I9l34gX/2TaI\nqdyzCvLZ7MPAWT5yFjn4AK1qbsiFgCXU+7+NgiKvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTWoaS/933eNnk4Q7/4jn7+Gd\npQcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL2jmbHlhpSN92L0BKaFFUFXIUkkXA+R3m1RQzsUoe1aAiEA9L2tknn6\ne69vnM8Act1ZTnJm31MGFUuSgMc/GwSDUT0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAfhRHgrCvgiXFPP4EQlQkrbwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzc1MzllYTMtNDlmMS00ZGM4LTlhZDctZjg2YWYxZTVmYjMyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGIwNjVmNjYtZTNmNy00ZDg3LTkxMjQtMDhjMjQ0ZWQ4\nYWMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo6GnOFU0bkpa1igR7R2zLc8W\nnoNOFSaG/XLGcIAAvK4ZLfAg1LAneV7AIsffGizHOqf6UG3L/tF4SaqBUIPTt6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSdFaOuOCBbvCBjuR8CTCqA78XKZzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22NKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGisG3Oy3vdfHKR8mFZb\ni6Cvkx6MphvyAQsMNFfMWzYNAiEA1R1X9Tkz2TFvTBwB7grnZog580y2TYobK9dO\n1yScMV0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9359", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9359` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISARRe2hsXRxr25qmt6aGXiPTyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY1Yjg2YjFhLWI3ZGEtNDQwZS1hNjZlLWIzNWMzNGY3OWJhNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjQ2YmNkMTctYTIw\nMS00Njc1LTliZmMtNzFmNTA2MmQxODg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENfsK9keUu7T77t0/TIP0elAWKsMUfskUy0nkImVTJ+eJRf4KXeu3sSi7ErMJ\nGD274I80g/+COgYd2lb3bOtcMKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxY8UWxsE1pj/EZ4mFOX/AflefH8wHwYDVR0j\nBBgwFoAUWUulvKtHjMfAxPGloQPucSfDyHIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEuF9hZkT13f6kpU7AxACbuIXpJ3\nrRW5OSOHDsHIEkajAiBzY31Z+F4teesNcxQfpvkqfoBq7ZXNSTECWQX0lydpCg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeL/FjeE4Hs9wVJUtOvWieITMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNWI4NmIxYS1iN2RhLTQ0MGUtYTY2ZS1iMzVjMzRmNzliYTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATvfTcT8uVNCkB3gjWAtLcVc0SM6flvmJgdiNq7iYuMEE6d\naLm+arIUwx2URfJ//ocEVhnEiYCZPmqk6yy/Jt44o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWUulvKtHjMfAxPGloQPucSfD\nyHIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKWOxe8LuYuZylZ0nxChA20XYzvKeFBzD+jXDCzHizibAiEA37js2iNw\nrTaZGR08qpq/q1G/qq98cnqaJjz4mqBBg60=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAdT8KifuZBuQLkit65ZfJcGlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjQ2YmNkMTctYTIwMS00Njc1LTliZmMtNzFmNTA2MmQxODg0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzZiMGNhN2EtYjBkNS00NmIzLTgyMjctOTIyZjVmMmNi\nYmMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1ugBWUtegVvr9/VBY7yA+vfP\nfPjEZPEq5ARDLkOB1tC09/JPeCECsPwnEHBqX3AGa9Ti2nqI08DrHRfTB6nHk6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTFjxRbGwTWmP8RniYU5f8B+V58fzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22OKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCAKSX/cP53hVwkOuA8\nGvFPGUaCHeZ5U8B89w/3dOyLQQIgKiy/zUTaehOvcQtSm1C16pTx8CWXOUrwhFoA\nDjGrbRg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9360", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9360` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAcMIWoPxtThw9aTW0p/aOnHFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIxMWNmNWJiLTJmYmEtNDRjZC1iMDY4LTYyYjA0NjgxMTEwMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzA2NTEzNTUtNzVk\nMS00NWRhLTljMzMtYWNlNGIxMGJmODc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyAYyxYuQYQ8GBL6Sooi3D9EUG6BwvVAWwg2P8ZOqwqkAuVSD09ReOOewHrs8\nx1BxVrqmFpzXP6qzCoG6igY2haOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSKSmZj6YvOViSRKkeKqQ3pGfAdFjAfBgNVHSME\nGDAWgBQCXfv7zrgzkkojOAGhr2QBR/XX/jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFmPAuW1ug2KHzjO5WNqehSvwgmygJmV\nuCHLhT89g1GCAiBLULt+XH/hligP4LcI93RbTYYb0DHRxWGkXqsc5X+D1g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAatGJmW2GzlWc6SzubAnhKPTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMTFjZjViYi0yZmJhLTQ0Y2QtYjA2OC02MmIwNDY4MTExMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARX+RrxeSqwadWTDeaoV1G2HYTLKCSbrhMtTMyOingiFj9Q\n/SCSjmMkXTAHmBsa4UJJ2B+3x3o+qHmiCbIxvl43o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAl37+864M5JKIzgBoa9kAUf1\n1/4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPxeL44zKP56MD8Ue0eBabKstcIKXEIhUFgGyhHK3KV0AiAnJFHMMmWq\n6QMLXDk9O9zmqkwe/EnCLP9NuYWeYUIqdQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAVHA3VlCHZc7ZCZmMWCqVb7CMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzA2NTEzNTUtNzVkMS00NWRhLTljMzMtYWNlNGIxMGJmODc0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTgxMGNkMmQtMDViZS00ZWZiLTgzYWUtNzQ5NGJjMWYw\nNDY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYkuIFNdIKyKBvf78dcuAMKE4\nirqBKiq3z9OPjY5INpsO1926xIew9VAc6Q8L3Dkan99jgLjQPDDvemegrrDw/KOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSKSmZj6YvOViSRKkeKqQ3pGfAdFjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22OKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAHbBvAc11eUBTFoN7dM\nhToeK5QItMte/kx+RZxHGTGsAiEAywY1rdmtAcbe2Wd7ac6fDuigxt/ykt9zKtZZ\neZWZT8M=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9361", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9361` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAXfuFD5V2fuPaC54XWnOYjGKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDJiM2M1ZWMyLTcwZGEtNGM1Ny04NTk4LWVkMGNjMzM1MDZmMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDEzNjFlYjctNDhk\nNC00YzI0LWE1MTYtN2VkYmYwM2M3YzQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEcSdYKGkZ+8meVNpVxxnEPj/cpCsktTCCS4bjKXZDLu+5Ibj+dd2XOTubbC8V\nsaHYOjUeBiNnUoyVsXsGpH7hy6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+lkI/eZ4PuIeZHdCQpLayWIRnSEwHwYDVR0j\nBBgwFoAUi/27cFemzzvYSM34TMAenvQu8uQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDImTGO8gO0aPFeitoTfjMeojaoh\n59qxYn+TlpxyGRR2AiB1eJtiL9UMv3Ttx9gtsfc3sCYKq2fvU6DjTFeL8P0EJw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWQ4QFl4GQr4nuz17d5VTjTbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nYjNjNWVjMi03MGRhLTRjNTctODU5OC1lZDBjYzMzNTA2ZjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASC2qZUk1EN7j5Q+jLof2h2RIHXG2emYwJ2ZU9jqfBWAVT2\nyTeElNZXE/wE+6/UdBga2P5f/URWZA5h/oDc1Halo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUi/27cFemzzvYSM34TMAenvQu\n8uQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAL36TKqEvRLjsr+kB+FnnCVrCgHO74/2pG3whIQEUaXlAiEA1KsYdube\nclFwqDyal3J9lRxNN9zZwDwYoLIlYEeI8VA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAe+wPrOm4o1U3XAkWQu82f7KMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDEzNjFlYjctNDhkNC00YzI0LWE1MTYtN2VkYmYwM2M3YzQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTRjZmVhYmUtZmMwMi00ZWNjLTkxN2YtYmJiMTQwNDQ0\nYmExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdSSx2cN7OBiip6JECMuMZyEP\ne6UERCSK6JblVo5MO5Hoy6EK68zO5Ve9OrC7eRZvN9DrmMUX8dViG4CvoFmNxKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT6WQj95ng+4h5kd0JCktrJYhGdITBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22PKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHZfvqVFU88sQw+KcbY/\nbUkvfssjbzdqCiy/rJQxjOmDAiB9vlblmUYI9J0nME5jqiTJd2xoJFhvYFW/7rg2\nJsGS/w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9362", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9362` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQYiU/VvItlLqIo2Ey/MRbA0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUyYTIwYWE1LTUwZTUtNDNkYi05YTU5LTgyMDY3MjhhMzRmNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTYxMzIyYjEtYTNh\nMS00YTYxLWFlZmYtZDk2YWQ3Mzk0ZjA3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdDm+snLFbYmO0a2/6brOycboxIF0YlBSyZz/oLHEjIEybrVWVMTmEGezL9Iq\nlnDU4NjoVkF/GpdLTPLxBNrNuaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSaqYMy4GL+C6GZ6LQJPpkgz3q9fjAfBgNVHSME\nGDAWgBRNvtv6SfMrIa1mleWHlikNNOJF7TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBKB+DZTGGMerldBh/XxWilMStDA6Ikw\npnnZ900gT6NYAiEAuLl6YbeIdxNS8n62GTb/4gub+8HzyWvHMG6XOXSxK8Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISATYePf1Im1P1wgofc8f+UaYwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMmEyMGFhNS01MGU1LTQzZGItOWE1OS04MjA2NzI4YTM0ZjcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmOq5lzMSvf5+ujfUs1h00sftnCOk6UJnA3l3z7L4Fvoyp\n0TfCcH093mtn/+deSE+4zAPw5pwTJ8+bJmriavZio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTb7b+knzKyGtZpXlh5YpDTTi\nRe0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP48+I/OplIPQbukSCGVGwO6aqEejjIv/siMEpajjTUIAiBqn3Ljfng4\nffm8eHYYNs1uTwvLHTHSNxoghwjJonjT5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAZqItMXWvU5p5qFeOs+Zvp/GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTYxMzIyYjEtYTNhMS00YTYxLWFlZmYtZDk2YWQ3Mzk0ZjA3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWZiOTEyNTUtNDdmOC00NGMyLWIyNzUtZDI1MjExOTBm\nNTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2gPh7tKJZR7FkFSPbF6r3hrd\nMR3jORw5h43U7nAS8uJ8NLLsVy/A0J9vjq4IdQ44aGoTY0c1mF7LH9m12177laOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSaqYMy4GL+C6GZ6LQJPpkgz3q9fjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22PKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb207RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBnnD+PdbZwq5AVvIQM7\nBwA3UudILIsyhv/uEG8M6mvtAiEAkIrvsy0Z3aRkWVgBurF4MYt//8D441fSzMVG\nsHQc1lg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9363", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9363` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAY1KzJLiDbN1WoloQi5eiaQjMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0ZmU4ZGEzLTFiNTYtNDQ2Zi05YWYwLWJjYmE1NDUyMWFjMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjk4YTE5NGItZmY1\nMC00ODdkLTgyYWItNDVjMTRmZGY1YTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENFZZ92tZ70csakDJEtbPoto6bZcESo0RFbyuJlvl/jqWy22qqCi6INamVheK\n0aBv2mEqDrsK9WqlPkLEX2Mx7KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXP76Qr3Ij5pvnIvspO7EOTgAiDIwHwYDVR0j\nBBgwFoAUuG05CY1zUOwInbJvF3ZbDX8RQdQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCK9HK9ayJ606s7GgA6Qal1i57n\ncabyJ/byNzJ3jJBxbQIhAMV+usrmIRSeasdicC/dksnJt5xlzftPLtEJA0gtZi4l\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd0T48Ef6tKLQjlPRzcq77iLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNGZlOGRhMy0xYjU2LTQ0NmYtOWFmMC1iY2JhNTQ1MjFhYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQpv8oKevOXsPVY01JQaejSIqllgWgWwI1xYLNZQzZb1yZz\nKPi/9eA61fmLLQ5+xQYld1mRezSxI8ZimgCA/WLto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuG05CY1zUOwInbJvF3ZbDX8R\nQdQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPWGOZ+uaCfrZWCiWkyCqhV72uw082g67++CWPm09vwgAiEAqW8W7Tz6\nhhCLrhZDrVDrvfA93WlIFPRqDyzwy3hAmrk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISASYhBPaoq8UkExjj/647DwTmMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjk4YTE5NGItZmY1MC00ODdkLTgyYWItNDVjMTRmZGY1YTA2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWY5MDdkY2YtMzExNi00ODAwLWI2YjUtY2ExYjY4Mzgw\nYjRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKD023vNs3dmlXRQapilZ3ACV\nqF6IgMxpzrZ3LYDyq+BIFqQwsHzqncDdNHNZuvfuSxsWyK9uksj2sdeMcaRH8qOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRc/vpCvciPmm+ci+yk7sQ5OACIMjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22AHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAoRdn3te8ZOO6y0aYRuXax2Nq5qrDWC19\nG/uz6cDiT2kCIQDzzOwx3ISY2Zq7cHrvbVob7kIC99/J9AxF6nHdJd7UfA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9364", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9364` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAUhu+h5XX69vSOSlGzvoZigLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ0ZmY4ZWZmLTA4ZWEtNGQ1My04ZGYzLTY0ZWU3MGU1N2E1MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDlhNTA0YzEtNzFi\nMS00MjNiLWIwMWQtM2YyZWI1NmQzZWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEw/cKSrD+bVyQIJdim9iHGzc/BgO+wApYqGdh2P4/hVYhv/wPjv7u/GUs3OkL\nA2VLWsuq34O9sSV2Nn47Y18LP6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTKTHEt+bPdxCVu5LXfYH28fDyh5jAfBgNVHSME\nGDAWgBThdiNmuJJZMiqvrCov0As60gOa/TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDD26FlrfQivU0xuFcz7YjLQ87+bVrc\nTb3j7naPcyQVUwIhAIwu3Hb/MUVB30mrsVhrVTPn7KT9aLQ5moBG4lJpMAu/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAXseON6j9OIh/bFvsI9On0fsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNGZmOGVmZi0wOGVhLTRkNTMtOGRmMy02NGVlNzBlNTdhNTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT3ejA1y5MSPmdfh0TCj6cjv2KFJcVynTWlBcys/SWoUns+\n/lMgQyyLb5vQ+lJ3LYsGzCbHBSDCv0MJp8o4bcuVo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4XYjZriSWTIqr6wqL9ALOtID\nmv0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPJl67ofAGSYOu26vI165/1BGm3rEgYcOZiNkfGil02AAiEAl43uBCsm\n4/mVo/+qLZ3fjx00+4Tz06TxBuALYJRuwsE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAa5KLkhyFoHUcdohVp2zcZXJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDlhNTA0YzEtNzFiMS00MjNiLWIwMWQtM2YyZWI1NmQzZWY3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2IwNmMzZWMtMGQzNy00OTg5LWFkZWUtM2Y1YzdhZTQy\nZjdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEp2SupveqpZ0R+OYU2/b3xUYH\n2PiDICghHOVnJUCdgZT735Jw//vJx4nAqN8O1193ZHHvJxK3jWVDxXco2S2kmaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTKTHEt+bPdxCVu5LXfYH28fDyh5jA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22AHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiA/QuUOjDrsNOdNpahVkuDPF3TREWMXzPQS\ne83Kcs2nqQIhALn1e0qwwXsInsNfT/DUweY5/DGZHiqzVEsnYulGYuSy\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9365", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9365` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYpEVd0vbvY8O7KBEnDVi8yVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDc3ZmIyMTIyLTc2MmUtNDg0Ny1hMWM4LWUwNDBmMWNlOWFjMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjAyYmEyOTUtN2Mw\nZC00YTg5LWJhZTktZWFlMjRkZWU5MGZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7+6OzBqIIXNUh5qB6pJFAcpp55jo1uFC+6EIsNqxEqWxdIdUYoHHHFIpp2Qx\nL7oRAQgAVTxeZi6TQrLgXu6r96OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+N9GTXYYAuaez/nYpHy0CEpxlGgwHwYDVR0j\nBBgwFoAUdzuysbWoM+LzEdKGUj7xPVYK9QQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCICFtdSzDtk3byDIpgHJ3elM/ICBc\nkdAkgs55b9tfGDttAiEAnYyOqv30DXzpuBcGxhvOZVzEKkTfvYSR/l48m2jhfmc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaE0zoVZILEIxGEQ/IzEvxijMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nN2ZiMjEyMi03NjJlLTQ4NDctYTFjOC1lMDQwZjFjZTlhYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARB5alLdOxiNyzGbH7YeKxK9niU/cj75oNtAxwYtiqXeNlD\nXwg77qeyX4UI88iOL+8O1htSKQ0L+H5pIkDnc0yLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdzuysbWoM+LzEdKGUj7xPVYK\n9QQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANmGYFo8LRUapzwSsvgAVw81zpq4jdHBidnDqRZz4QitAiBt9EQ+f3eb\nGuK78lKZkaRIBwlLlmEycktzoPTrltxbdw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbn8ju2OOziiLyNhxDG24r6YMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjAyYmEyOTUtN2MwZC00YTg5LWJhZTktZWFlMjRkZWU5MGZiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWI1OTIyMGQtMDY2Ni00OTI1LWE5MmMtNDNkOWViYTQ5\nYzQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExPcH45JRgCydr+NgcqaIqy15\n5TtQ5b3LxuORC+5CCCr20MmmYjXoNTvm/Mda9BpF1OGkPQHucEig32FuMX7RxKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT430ZNdhgC5p7P+dikfLQISnGUaDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22BHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAy1Kh0VM5V6v2Wo+NfDwSWcAyPuwx8LqX+\n6mQOwjhhDwIhAP8BJXdEiyMMeiqDypqImxvxoqqMm9e+HMEhe2mzPpmv\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9366", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9366` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAUAWsuTEkIBU5ox+xIQg8FMgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU1Zjg4NThjLTg0ZjYtNDY0MC04OThlLTUwZmMyZjk0N2I5MjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzZhNjJlMDgtMGNm\nZi00OWRhLTg2YzYtZmFhOTFhZjUzMThhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEZLAc+nAJDNY1WUDLC8YE0ezx1ssjVHugSlFe21IIwv2OflufDgmVRawj4kVq\nZWTF5+BdJHbi+3aCUql7QjbhaKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQR/uqR/XiN3xC6gwJgUkO2SPaNizAfBgNVHSME\nGDAWgBRtg0XFB3nUEvwjKLCR8xfj0B4QSDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIB3MAVucT7Tzm5L5qNHhyCx3USs4jU9W\n8izB9RaA4I8xAiEAquvWkFXxTIV8WgIyRhlqTaTA8BEcEqR/fhuIe1zPYiw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAf5oUzoZlkPzMMj9wzGA7ewvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNWY4ODU4Yy04NGY2LTQ2NDAtODk4ZS01MGZjMmY5NDdiOTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASftjp5j/xH2KDQLHWCXBX9dbg4T/LflOPXYwEXSmz4e3bT\ni1LiseBCi0RMphsMZmwQGUGomxChssrG89hRIiIRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbYNFxQd51BL8IyiwkfMX49Ae\nEEgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSJdE1FREOuWMZpPtmGJTPg15Nx8VlyYJxqXN+DB92+0CIQDjlAGaPnDH\nYtWgOZzD4qoekErjf7DeL/SWmWLUyax/5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAfX7pHhRTjkXXIWJ7EW3C9RKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzZhNjJlMDgtMGNmZi00OWRhLTg2YzYtZmFhOTFhZjUzMThhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODBlZTNkZGUtZTc1Ni00NWRjLWE4MzAtZjIyZDY3ZDlj\nYWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdQXy/JLX8QJMIGc21L+EQkv7\n3MOrL6WGgDNzXrL3N3v7KSu6M+9XGC/Ex7Ip9Mk2R/JXCghPim4pEbG0T3qmgaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQR/uqR/XiN3xC6gwJgUkO2SPaNizA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22BHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAvZ+J6fvQGPwpMuHd4GKrPfJPPNFLaGv8\n5cc5EBCeYsECIQDaZbqS7ouVSDYrlhF57vv10my/vIjKU2EO0mGCXcgJjw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9367", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9367` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAWTTnqfIACKg7m3L7OX3e9+3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyMDM5ZGQyLTQyYjQtNDI4YS1iZDE4LTU5NmM5ZmY0NTZiYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkY2RmNzVhYzEtMzE0\nMS00ZGI0LWJmY2EtMzQ2Mzg3NDE0NDUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEx7m3vaHDsxXh20vlYwok07mKYSYYf+bp2GziR0sTVtjHbKsKKO2xpi3Ls3GX\nvRys56eA77oYB5VMT3o+m6zye6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUevcF4cf3A+MCeHKvjXDgSWIm56YwHwYDVR0j\nBBgwFoAU6MGi7taxmWkz7ItafnIaX3MSncgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIC2le1HRdMDlaBdBbPCBaK0uGf27\ne1YwDEIVQiWLxlaPAiEAlI15WJPjE+f7WPZhAIX5MGYSKFXaHQlUj/kCPvOnBrM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAZq/nP6/fssAR8Fd3FFtKrkuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMjAzOWRkMi00MmI0LTQyOGEtYmQxOC01OTZjOWZmNDU2YmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQhsSRER4uukINuRw2EUq3ctUyOpn3Lp4FxNouoblRvpzCn\nCkt5rfBPfEuAsbp5tiqZNTHS1Dkao+Rdi9VcXRmto2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6MGi7taxmWkz7ItafnIaX3MS\nncgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMTDDbj4qP5FnixIvVVQ1K00rWPHRd0n0stM2Ga0DQT9AiEA8pZi7zs8\nr3BqlT3j8Cs1EupI9j1Y/QrwqxEZiMEcoC4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVpzKxognSE3Ldr61e4bwueVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkY2RmNzVhYzEtMzE0MS00ZGI0LWJmY2EtMzQ2Mzg3NDE0NDUxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjdkM2Q5ZmYtNmU1OC00NTkyLWJlNGItNWJmMTMwYmY4\nYzY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6bV1ifhfEpxxQU5fpdpskmeq\nnwC7MlnDfXwAVXXv8gt1dG9ICyh9p5XN/ct75Tdp7QelNiN9l5z2ImhXOxR9eaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR69wXhx/cD4wJ4cq+NcOBJYibnpjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22CHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiBRBBxauhOHJU8UsSw+ZzW+Z699wwTFEvlo\n+tvY5skg8QIgJ0Ijeb8k+KLzimowh33OjDzLWUlXm1XKjEaSzLrksxs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9368", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9368` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAc/jptfmDBaicsrzVhQtsPCsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkwN2QwYWJiLWQwZmMtNDM1ZS04ZGJhLTM5NDI1ZDU2ZDBlNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWViYmNjMzItMDQx\nMS00MzA1LTkyOGMtZDQ0N2FmMmJmYWRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAECx5FHD6pP5/MNHy8dOFaaZrwixGwLCG2X8PWc2m9rfnBSdVgqNlnrCDHxk/x\nWtb53HQ32eVtzWptiffTHJYyuaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTqKvcGzQINs2dFoaGg7B3apFWZUTAfBgNVHSME\nGDAWgBRLL7G+8YcYwQjpVZppc8Z+x+dr0DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEHbE1vgnLhQm+6Mwjcqwo8UTtlrt0ue\n72QA63Q/st8kAiEA5ahqojvraNBdcHTor4m1d9u5eLlNRe+QrtgyY+fV/BQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATc/iZCGEgrn1W/N1jh1HeBQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMDdkMGFiYi1kMGZjLTQzNWUtOGRiYS0zOTQyNWQ1NmQwZTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATzmLE7DuUSM1pvzZ5dFuiDaZzny9vZt+PrMZE/mX7OOS0S\nst1pCffdPTlFRv/MvXK1SfZ53jvaf9QIJm/tv1Xio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSy+xvvGHGMEI6VWaaXPGfsfn\na9AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI5MPKSukBVk4In9t332tSwTEttT7zfQoYdDFdldWS3iAiEAk43J3ciH\nyNBu+2VcOe1OJ0oSvTqExRriZOpD9vDcBrI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAaCHuD/a1EXeg6id0A3paQWcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWViYmNjMzItMDQxMS00MzA1LTkyOGMtZDQ0N2FmMmJmYWRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWZjMTUzYmQtNDRiNC00NjM5LWE0NzktNDFjMzUyMGU0\nYzVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEl3hmLS4foNFg7x9Wcb8ZR4BT\nSkOZ5vwwwFQAxyMGbebXJLJJjgpak+S43+HQ6ayT+rP8rNWNRePbqr4f3M2KqKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTqKvcGzQINs2dFoaGg7B3apFWZUTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22CHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiA2B0mFNPk4F2IcpiOme5juAEMeh654Z/oN\nDFMzZKF/jQIgI5Ck3Hp/rdotoE80Bd6sqAEEjX5DSM6JPfSfgxDdKDM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9369", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9369` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdUdCa3FjdkhEUpcFuVdWe7QMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxMjRkOWYyLWE4M2QtNDhmZi04NDIyLTUyY2Q4ODU1ZDBiODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc4YjVmZWMtYjUz\nOS00MDZlLWE3YWItYzA3YzNjMDAyZWUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/UO6xRN+XBiZjaPepOVVA5iKkJZYwZ3U9ob3TpVN9aKbTu9/AIJNlJhx/T9Y\n4CrDWnT/t52ddqOThhjl09zbmKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUC60BvGoyEoItdVpVVrxlxecWeLcwHwYDVR0j\nBBgwFoAUe3YTUvEOXNEOOJH+NY4FY/PsL3owHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCWbbp3YLCGpknyLMVFu5Si4hPD\nNQ58bSRZos35YMnR/gIgedEL8HvxoWTpmSvCJKeqx8afjKaLw5hfgeztmEk+P7I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWSWqMsplIx153q/CMiQ+TOYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMTI0ZDlmMi1hODNkLTQ4ZmYtODQyMi01MmNkODg1NWQwYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQoXtUNQjWtJT8Dcc/SRoUSrbddUNPyCOrTthb1jUliTyQ6\nQkP0bKrPGHUX+wHn88yJ+jwJ1GjWb5ZBYgGTOByWo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe3YTUvEOXNEOOJH+NY4FY/Ps\nL3owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgEGxRM6bAx3gWNzbB491HGsgETkkwjwKiH9fZHycIESECIG9w5uCmdtj/\nV2woOpxwSYYwgskHnNqkss3l0mBTH6hp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISARs4twoKj+ga1DrEY9zoqUMlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc4YjVmZWMtYjUzOS00MDZlLWE3YWItYzA3YzNjMDAyZWUwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjNiMWNiMWUtYzg2Zi00YzQxLTkwOTItZGM4M2I1MzBm\nZGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzft16ZPMDs7PGO3wBwVRzE/w\nmPfujEvOeV6ADD2mNqge7antBS+DzwjfSrkmfDsh2e9SnNbdrUwUfT0Ec54U5qOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQLrQG8ajISgi11WlVWvGXF5xZ4tzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22DHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiBWGLvqXoUMVSVL6Tq3toAwdQxaZ9DsjisH\nsKy/CDKfzwIgD0QnDdKJer2lovu+lUIXi8TFsztkk9UQilFgxaKnKn8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9370", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9370` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAdSAS1SyDmKHpzGHJU5LqFPIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmYTJkMWE1LTdhMGItNDFkZi05ZjUzLTE4ZGNhNTAwOTNlYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjcxNzNlNjAtMjE3\nZi00MjY2LTg1YWYtNjRiOWExZGFlNTEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEecyQQh9u2PVOeCP5apDXvJ6T1tbGj/T84x46U9BNf0+FdeUrRCyUuTxXffcj\nkIl0VXyGJ0+I8KJHh8tBcvgFSqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTmvfcUq2IAGKQRCWygkD14b23RHjAfBgNVHSME\nGDAWgBTahEevCCnqZQ3mYTHp/svdU31+NjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFxpq4nthgkTrzkxOcWQJ0IAfJQfHw08\nUh7Q9okzq7UAAiAtchPEp4eZhTex7HtG4yEdiBPx7Hqqq4/XNAI3MEh4PA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV9NSGGzw2fsVoMCnkbf/Oi1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmEyZDFhNS03YTBiLTQxZGYtOWY1My0xOGRjYTUwMDkzZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARnTaKse5VkyAXbAR15mj20vVZ7RruNfIcbu8PQM4mnys7y\nqcDy0S1vShwMbb7JxjGaGHyJdsfdkNOqOl63kI7No2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2oRHrwgp6mUN5mEx6f7L3VN9\nfjYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAP8V5I9LRfsU5guIpTSq8HB7lYnIRJUM386BHMdw/F4kAiBPQVFhHDUv\ng3zUEaGdIdet/k95wZMTVop9dSzQwvu8kw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISASE8KRwUClwSHv7xpKD0hYncMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjcxNzNlNjAtMjE3Zi00MjY2LTg1YWYtNjRiOWExZGFlNTEzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjA4NWIzNzMtMjk0Yy00OTZkLTk1ZWYtMDg4ZGRiZWY4\nNTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvy+ytwVcai8vb6VGJedIX02W\nJwZH/olCVCYjTWJVPuB4xJ/u9SHBhINw2txJtH03DFg+gy7V83TswQX6CE4w/6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTmvfcUq2IAGKQRCWygkD14b23RHjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22DHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAlv2Q2tQczuOCxvZpchisMyCkHF/BQrsi\nJK/m8k/wtIkCIQC+zwFN5TKOMUSNXnlji8iZUC80p8dNL5tRBQtb1cLeFw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9371", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9371` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATe8mWS3GA1PyZNMKf+jIPnIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5ZmIzZDBlLTg4MjctNDEyYS1iZmFjLWU0OGFhZmYzOGU5YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkxODQ2MGMtNzJk\nMC00N2EzLWEzNzAtZWYzMjE2ZWVmNjRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh5DK2PcwPqeZ2qrZ8thXffmOKMiQj8IbSf85xrwD+Ss7WVr9vlMeF+m6qp01\ngnQH7Ww0ox+/eJRhaQ0Tzmo6KaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhcr4bzEqvfyAi8ezgUzohR+UDJowHwYDVR0j\nBBgwFoAUR7LlqW8C7StNMtL+oKmi8LvxHYUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCaAQMONY+TmeLzSXy26ffFDJig\nLlkMGSgpKnfeVq3THQIgN64FMKJQwInEx8JXoB2mExpaXSby0NpCE8048jHvQw0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQ6rdQXKvM5/ZZnMaL6hCmtTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOWZiM2QwZS04ODI3LTQxMmEtYmZhYy1lNDhhYWZmMzhlOWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ1DXT82DpsHvJ6tyDiaq/rxOrMRNM51ijA0RSJHTJEges9\npiW1pA6u1+uRx0xoromicqFkAsXxIbk4Dgthf/wuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR7LlqW8C7StNMtL+oKmi8Lvx\nHYUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMPqi88tAU95cKo/TrA4CuulzGrhajyakGK43AgWDuI6AiA2eJuogxV7\nD8hH0TyWaT4dJPR0W3blRjAEc5A72LQEuQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAUPQ4crdqodFzLEtCL7syy+aMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkxODQ2MGMtNzJkMC00N2EzLWEzNzAtZWYzMjE2ZWVmNjRhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzk1YjUwNDUtZWE2Yi00NzkwLTkwOTEtNGQzOGU5ZTE0\nYTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2R6PSypIN32+k5DqIqiQtQ0l\nUhvUW1hDWG8PiGfPCapl+DU63YzQ+NMfNLo76TnbjzbWHYm83M3pdvZJLmvMGaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSFyvhvMSq9/ICLx7OBTOiFH5QMmjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22EHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEA/fn5XYTj8OjsY7fwF5jnkZGj9IB2uRzj\ngLNz23Oh4EgCIB3r5DJUJ4H3sGYAFMkuhPcnuDEenTHVY9G42ovO5MB2\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9372", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9372` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWD5dmIbWX/xSG+SeAMFl4+6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY3YmYxNThmLTQ2OWItNDI4MC05ZTAyLTBiYWMzZTAzOTVmYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzYwN2RlODYtYmNi\nOC00OWFmLTkxZjMtY2RmNzliMTU2ZjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEceDj60nsnFvgKwFREfVFGsYLtaNK23VcymVoNUgJmMChllsXjxatDMk/isgr\nevcWbwDzLSqzJzUhSJFnGoznF6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRZURu1UWiHHDBrQAy+LdtQQMSVCDAfBgNVHSME\nGDAWgBT+Yyi0ehOZFVo6L8jci3YkBmM5vDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAyUV9lQtQlAe/dluz/uJqfZqLDw82RZ\nuPlro8SHW6WoAiEAzJzuSKJgZqW0iwMwb4X+6dgJ4IQhyPClCWYd8/v7o/s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU9IR6Q3Hxm6XwGHW3MSaDUBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nN2JmMTU4Zi00NjliLTQyODAtOWUwMi0wYmFjM2UwMzk1ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXktFrPvelrO04wbE3+6Naqcw471FLGEBpiMVnFoDoKr8d\nIw23Ho1OBVedX1MieE7cjWFJBI4JzD1Kli5fDbPso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/mMotHoTmRVaOi/I3It2JAZj\nObwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFaogeRE7YWMiXrNslkO916bWQebzXhmfs7hM7toj24cCIQCKbOq0t7gH\nDtbZFWVGaKNKXTtfhYKsTOeevw3sPVpziQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAThiIIPS24vwoRLeM88DOlrDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzYwN2RlODYtYmNiOC00OWFmLTkxZjMtY2RmNzliMTU2ZjhlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzcwNDY2OTctY2ZlZS00M2M2LThiYjEtZTE3ZmQxNTFh\nZTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIEX/NMKzOdkR+ZWv/721Sfkd\nT2F/pUnUqjcCZdNLldVzrTV1aieDXXk6+E1kJ8fR9oY30LQgRjuX6d00QgpaCaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRZURu1UWiHHDBrQAy+LdtQQMSVCDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22EHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAgRtgaORo4IWuOTXBhfNkZJjm6ciIZwd3\nXL5s3oNwIdoCIBjbVMFYuL4fer++bfQbTd7SR7Gm5zdx7jByESPusTJk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9373", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9373` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAa4ayLBa8h562QDtzeUhTr9XMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1MzM0MDYyLWJiM2UtNGUyNy1iNTA2LWJhM2E0ZjBlZDY1NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTc2ODgzZGQtM2E1\nYi00ZDcwLTkzOGYtN2MxYWJlODFkMzc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE5skL0F7yHQZjAaVUCe8j6kNcScDq762O6RAHBfekHQMPlHPBLn4ob0m66eDJ\nc0pAyKXhyFsuujidw/VEKUOf3qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcr8khzGZu67Rnn7DrDExstVXPZIwHwYDVR0j\nBBgwFoAUL1Tb/FseYtf1oCOIce7oCjUYnDMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIFpmxr60LGhuJAz5je5iPFAXsBjH\n9XnLxU5R2Lbwmf+eAiAmwLMkNkJfVP2NGht6nROQC1SsoINCNDNb88QQhey37Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQYzMOo92QTHjkb45VvPe9q0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTMzNDA2Mi1iYjNlLTRlMjctYjUwNi1iYTNhNGYwZWQ2NTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQNVDMq5OEpgn4yZbyCecAiKwcbxiPk4ZnCbb5/rF083Sq9\n8OcovWkwiRwzkbrqWyOhxHsNxXeWewb0kXzl6mj2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUL1Tb/FseYtf1oCOIce7oCjUY\nnDMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPNFLGWu8ucXXMCCUGE/hwozZ/ntDN7odgSYFzqihhc0AiEAw7LeIVFN\nEzQhgggjfyFw3T988A/sJm3HuRbvfc0rBtk=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAVTyUJLjBtLhVWZRbboW3qXBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTc2ODgzZGQtM2E1Yi00ZDcwLTkzOGYtN2MxYWJlODFkMzc0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkM2E4MzY2ZWQtMjMxMS00ZTkxLWIyODEtZjU5ODQwMDVm\nNDE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfYj0YsF27L8I/PISgiDLIKmg\n3WfSryyiHY6jwhtIXAnxRp8aVUGKX+ECh8VvUWL4r3I39+nXcShUD9F/zDTbO6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRyvySHMZm7rtGefsOsMTGy1Vc9kjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22FHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiAsRclQvgeLqnoXqGVWPcZXDDyjxcdjRwOM\n3khk8wcOnQIgGpBXNL9GKcJFUYg4MPSaBPFdl+eFufmeVColGomMF08=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9374", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9374` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAccnesbs4RkKrOoK9O/XgcuzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDViM2E0OWMxLTgzNGQtNDA1MS1iM2M1LTZkZTNlNjRiODIyYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTQ4OGYxZjMtYjli\nZC00NTE5LWI1YzctZWI1MGQzNDYzNmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERuGWC/xg67NnMj0FyKeikFgIPeptKNseVqh30qf9bTXTuZeNxn97ULPkDFkk\nynaWVpiXbW5hMfk3D/VkNj86lqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTRs3cDCAjqg8aoRA+lH3fPyaScNjAfBgNVHSME\nGDAWgBRyxczl1xgRW0dqMdqQ9AORnNWXADAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIG9TJKX/lMzOtIk86rums+0T+Qi+cWyW\nX2yE9Kf3XpNWAiEA2UPRSDKjDy12jvCK0GkdJdV9vCqHQSj0i0lveOue94U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASty200EiRg/bKRMW3YrJ91nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYjNhNDljMS04MzRkLTQwNTEtYjNjNS02ZGUzZTY0YjgyMmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiEC2qkLCCNgR4/90h4k6pnHY2fu8x/BffDfFePWMfabSA\nlyk99BVY0QpwJiIyVPoPwoBewCbKSn7F+JhxIs0co2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcsXM5dcYEVtHajHakPQDkZzV\nlwAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbeSOORTe+JaQKIQzRRaxgFb1fs4ctazuUOL7J6tCXV4CIQCKMpNIkZJK\nTr8K4D19CuQi4PLFxTvvJ0L7AhBymqcCaw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbu9YG/4EWVM/n5oGiZwSCHtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTQ4OGYxZjMtYjliZC00NTE5LWI1YzctZWI1MGQzNDYzNmYzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDhiNGYzNzMtODA2Mi00MzVkLTlmNzUtNDZmMDU2MDFi\nZTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMKojP4MQkAeI9YgtigNG+Zt2\nn26F15V2GW6IBFTXOKJI0UO35dUP7AXIlg8nz5aObimgmBY4z4h0YIhdzm0OIqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTRs3cDCAjqg8aoRA+lH3fPyaScNjA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22FHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEA4IGjV3qblOTtGXT2JwWSHUAv/SyaYPqW\nfMrdITDef48CIHIDv3gP/8jtyTS/Gb47bxap063Y7moxXr26cEUR4TQ4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9375", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9375` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAUmdAkFL61lpdPP12Q1VjpDxMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZhMzI1YjA5LTgwNWYtNDg3OC1hMDc5LTRmZmQ3NzExYzc0ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M5NjEyZmEtZDJi\nMS00MjI5LTg2ZWMtYTE3NmZlYzdhYWZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESMHbmD9VOPjBmadyfWwin+LhwsyBvXvx1/LOXDqQO9RSaQ/7qAYyStVzXgI9\nmjn1i1xrXayrf1vK8f/Do48Eu6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGCAH6rKvk7qVKo7Cbul8+zzX7VkwHwYDVR0j\nBBgwFoAUNzlLlA+KK7jGWtRwR4QDyeYxEwQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDnjDxpZ4NaKZJ3rDXJedVB57Bb\ntroWYAsllxKi8714cQIhAMUiJtaesEj+cNpMU/2ZYFzOLK7qL0VQs0ktlWIJy/Q+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAXCtkf8UONENOo+4k72MBAv/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nYTMyNWIwOS04MDVmLTQ4NzgtYTA3OS00ZmZkNzcxMWM3NGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATR1Riy8YbV1BRE4UQoTXdi7tyj5ALUE1l+cJ0cNMLhMHj5\nE7E96f98tFamAT7LxqfKxap/XCOLf6sG9JlcKgAZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNzlLlA+KK7jGWtRwR4QDyeYx\nEwQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgASCVM4r6lRlf3GijrpBm1fUEbmuyzjpF1fsc9ZogV0MCIBp8iVx2c5gk\nJGMVCrv4v6uW0zwmJcyaDZbaNUhtkLBT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAb2rl92MU6tE5KIhwTGQmwZPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M5NjEyZmEtZDJiMS00MjI5LTg2ZWMtYTE3NmZlYzdhYWZmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTAyY2EyZjgtYjMyOC00YzU0LWFjNzEtZDIwY2ZmMmIy\nZjhiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEg03eKbVuqQk6ekOR3anBH6J4\nwsWpI2V+FA7gSH7gtXP+Ae/OLG+g1QH8Ujayzu7EVNXckmYtLBySSRQ5LJlP0KOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQYIAfqsq+TupUqjsJu6Xz7PNftWTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22GHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiBjlyQlZkRAS06UFM6f8xMxudNk9ddYUKVB\n8Nc8EqARZwIhALz2pdtdpRbDgDqPz9Vsn3EL1I5OmB95s2930S8tyLv/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9376", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9376` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcqLFB5ol7M01EGjq46rgtYkMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4ZmM4ZTA4LTY2NTctNGNhZC1hMDlkLTc3MjllZTFkZTI4NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmJmNzg0NzgtMmJh\nNC00ODJiLTgyMjItMzVkNTllZDFmOTkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgwVTH+pnIyRy8wOKvpQaNp8HcW8HGdaCWZx+AdOueg1TnYxmguHkOrVCii24\n9de0mRjyrsEy8SvsJk7LOwP15KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTk0BwLvI4Q63YH2uxz3CDMAyMEBDAfBgNVHSME\nGDAWgBRKlYkr/6k9ZfMEwpK7WK+Gn/5YdDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCxdZ+NPLjuzh+XfdDBhO+Vs2S3r0Fz\nFyhM3FSkOngDyQIgb40tfoYdjKXmKp6QiqaQ4Bvb5NzWnWSUCvRMo81M0DI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVzyPGy5thtFhlrK6kCHhegyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGZjOGUwOC02NjU3LTRjYWQtYTA5ZC03NzI5ZWUxZGUyODYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQzVkxw8PAqfDHcS8xCQwGAR54TEzxogozpuKHh6R/SFPqi\nQoo6sJri3J7Y45qBu+21itiuKmL3rbOdgM7SV2mvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSpWJK/+pPWXzBMKSu1ivhp/+\nWHQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAND9337FCk+GJZnq8GxiSHuIffXufKTYH5oWWKLseOURAiAOMN7ZB0g1\nuzRVuoa6Z2+lqYDeLZhYhvhcGJpm9BRNxQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAcx5OMsL7ORcYWVfEgOUZnXJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmJmNzg0NzgtMmJhNC00ODJiLTgyMjItMzVkNTllZDFmOTkyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjZmMzg5MTMtYTQ4NS00ODkwLWFiYWMtOTFmNTEyNWM2\nMTZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaZbDjXazmgroZhYd8umFxv1B\nIadobioQob6nk7blIhBG+Ajs2KR6+7sEzdRQjROnnSfRwSZKq20ZgJ142GlCjKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTk0BwLvI4Q63YH2uxz3CDMAyMEBDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22GHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEA9jH0a7eyPnSo/q5dr4KFZTPeuhGnnFmI\ndYGVkensFLECIQDS4xpzDDtbCIKp7rq+Xqt3KO5MZPZbW1O2AIjb2nfhkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9377", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9377` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISASmaeDiJIE+Jp7aE5rAqewJRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUxOGVlMjdmLWJhNDItNDM0OC05MzVhLTY4MWE3NzQyNmVjMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmM1NTM2MGYtOGYw\nNy00NGIwLWE0ZTAtN2MwNzViODVhNjVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7xdD+lFYvl0T9198GlbF69GRMdS5hKiO6jnOhsoBvLqb10Urm9EOz9C9kvoV\nsogEIX19ZS4YeNyTmwd/YP0Sn6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUN5HrLO4WidiUPTiuVjEUieVcQbwwHwYDVR0j\nBBgwFoAUSRr8b5OS6WtvfbUVo7+M5NZRb/swHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDkSkWtBLyh54KStqdkG2T9FPPW\n7FgT3EhsXg2DZRiAOAIhAKBRYI+f6Hxk2+0IQF6qunNZwFOC5/i/Rh25DGIG3M7w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUOmNp73gJtlCH9wnGFzs4jKMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nMThlZTI3Zi1iYTQyLTQzNDgtOTM1YS02ODFhNzc0MjZlYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASSYBub1E94V6nWINRKxMcn2TVyDgobpzTZUTMl3fI8gCkd\nabFrR7ajkEqrktPypiEkZGfzvdi0zySSVdPZ2Lbyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSRr8b5OS6WtvfbUVo7+M5NZR\nb/swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVTf7HRpsN6ytNu1CNeDHVCfuuII4EubbDXCWPLVeulsCICCackP5kHUt\na+/WrvtccAPW9LQSLYPH5kI/xYixJi1o\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAf+2c+JJbc0xarhEnR04ksa4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmM1NTM2MGYtOGYwNy00NGIwLWE0ZTAtN2MwNzViODVhNjVmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGYzNGZkYzYtMjgyZS00OTExLWFhMTUtYTg1YTJlYjlk\nYjFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2E2hVGdj/gD1sGxkhw4+/NdB\nyUFa1gGxm0oH4xR7Y4CxdiIX0dKffOS7yVAbBbI6cAnf8JGGATeyt2igFn+3nqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ3kess7haJ2JQ9OK5WMRSJ5VxBvDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22HHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiA6nHvHqLaCLmLusFjYMUbmDYlXEEoz/UGw\n3XLzbmKSRwIgC4C9tvgSqR8jhrPra9vRRy2PBNIMHHvFLn8+2C6QrKo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9378", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9378` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAdrqycm3OPPZkyd1RfSBwwQPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk4Y2I2NTBlLTYyMjYtNGIyYy04MTViLWQ5NjUzNTc4YmFkMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzc2ZjZhYjctNTY3\nMC00ZjRkLWI1MGQtZjczMzk0ZDZlYjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEOkprdPy3qI7Iu6Sc88t0FgKGO1ue6YpwqVezlPXa0XZQpDfH//0rEvAvooxa\nX/eAwhVbwAaA/VXp4KfLjpZgRqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRtNeEXJniziwopv8wchiKB/Oaa/DAfBgNVHSME\nGDAWgBRx3PTLAMpSoAoJ8cU1iVsOLdE89DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDHk3JP4M9DQiTuyFnli/H0bWOIXmLl\nEPk6PT4sE2kTfwIgbR09vNsb/pHIQ6T5YEhUbriVrGPEIwktcOxrzbpoCC0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISATq5cl7Ns5ApARhDpuIGck6mMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOGNiNjUwZS02MjI2LTRiMmMtODE1Yi1kOTY1MzU3OGJhZDIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT2qGy/ofHjfWDFzdnw8/qZZJbctTwL0nmwAQOVO3oqt/ie\nyvGh7e72D3QJU9gyhJGJhqlO5ZFyXdol4zsgTTs8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcdz0ywDKUqAKCfHFNYlbDi3R\nPPQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIAE2BGypHglVj1Aar/WCqatMHNLXF9QnY0tENqpk+F/AiEAuWUFQs3U\nHl9e9d4BFmRLx8iBNFaWa03bz+w/Cz6Cw+o=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAbtzRP78r6t2Izg5rjX8xi4gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzc2ZjZhYjctNTY3MC00ZjRkLWI1MGQtZjczMzk0ZDZlYjEzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjI2MmM5ZmUtYTU1ZS00ODhiLTkwNTQtOWYzNWFkNjAz\nMDZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEW4ZsrX/chv5SL3n9itN9Y/za\nz/SNjDskFiTYpS/3AECaSDmDxLCKJJDR7QGnjcOKuTfH8op8KSbgnCMO8U7NGaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRtNeEXJniziwopv8wchiKB/Oaa/DA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22HHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEA9US2oVgm+HjN0/oCaqbViT/gP978jBql\nO6jOKrMAEU0CICW/nDHuSlLNddDdNBt0JnoLtbVyHiFAnkwBiw4l1vdp\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9379", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9379` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAe8R3PsMX2E4WLxnP0pheGoNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkOTBhNTA2LWFhZmYtNDI2NS05NzE5LWIyMjE4NzNkZDEzMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWFkMTA4MWQtZjI4\nMi00N2U2LWE0MjMtYjk4MjYyYTE3ZmY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE3ottjCXwtdBd+Fi+YAyueXcMz4n6TmlcVKzcQMpEiGH0FIAuYv89020EBKZs\nVNJuABaGWmahBKMrtkOJAXNRXqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJygpH4oocqfFylIxC39/hSEOwaIwHwYDVR0j\nBBgwFoAUQrKM+vN8jtp138MdaE5HHgHmgCEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCbCALc036mu1uSdLsU/U8E6l21\nXjRdJEYMT30p7z9aPgIgf7renMSbtaMc33nfmeX50aZhbCIOuI3MzYEQGVLusGs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZqYFvoGkov9fSkka0DmsWpHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDkwYTUwNi1hYWZmLTQyNjUtOTcxOS1iMjIxODczZGQxMzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASS8Co3q7rkDRuH7xzDkEPmTDbgEILlRx8VLiZkUw+urI5n\nItEWnuHKRNIjDb0ere3k6IZZg/8YGFYv7oDupaZfo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQrKM+vN8jtp138MdaE5HHgHm\ngCEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMq6SZ0tjC2d571frFTkma3TDJzeYcmFOJ0m9gxt87H7AiA2pDqdV+5b\n2/BsgaemJWwmelvlJXgGOwE6cRMi66k0Qg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAYEbjokyUpPydpC+153fsYf5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWFkMTA4MWQtZjI4Mi00N2U2LWE0MjMtYjk4MjYyYTE3ZmY1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzU1OTViZGQtMzZjMC00NTgxLWFhZmYtMmJkMGQ0NTgy\nMmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOX6mFfnr+6eF8essWeTw0tJ9\nrmgfLUdOWr4O2mPR1bAZEYHMWK24fsHeSKWocxiACUXklRprmsKhk3sZ9TgYNqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQnKCkfiihyp8XKUjELf3+FIQ7BojA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22IHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAi65vyR6f/c7rrX4IVmiszuSqvGMoBbnh\nNH8Y6phczdwCIHyy9QPT9u2aSIbYU7DYpvFn38ZKKsPPVqRMhwUdKjub\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9380", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9380` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAaAyBGUlvVcfDmh1WRqm4k2sMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDkzMzE5ZjE3LWY3MDAtNDkzOS1hNWEzLWM1MzAyNTI2MGEwNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjcyYTQ1NDMtZjkx\nZC00MTA4LTgyM2QtNzM0MjY4N2FlOWJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmMoI6VeAcojvOl/tc2/nPYiSDvhuOBjhqqkwhyqYYxckDGQ+4BgqiqL93DMp\nMQVmN35d10LELRNOWncKZC1b36OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQa1XPk0iVKXpBeovmQsr2a9B+pcDAfBgNVHSME\nGDAWgBSYq2NfDezER7oCKCMeE6/YwrMbaTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAVIA9e4tsAlsCc+nDBHff1o89GgwRHV\nkOs0XCEI8b05AiB27fyOewhfb8I0Zv90iC6Pr5UYE8VBOSSLxaL0Ua24Ag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAS/NlhJgY3G6/ecGeHocn8ZjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nMzMxOWYxNy1mNzAwLTQ5MzktYTVhMy1jNTMwMjUyNjBhMDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGOHsQJD/6523hkvgP2nK+x7V/I+pc1/vNg117mlTDh+7r\nqOKAyeQj7dkE8RdFLSJzW0ZNvIoW3J5950TrdR2ho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmKtjXw3sxEe6AigjHhOv2MKz\nG2kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgV0NeRM24u8yS1Ej4t/HU8Xs1mPkHcInWnP0WhI3Mmg0CIQClOIhYT98y\nfEo1/AsJSk8AqTRZzT/DsYdaQag1Y46BaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAV9D8opegKNYS2bitGTo1jqeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjcyYTQ1NDMtZjkxZC00MTA4LTgyM2QtNzM0MjY4N2FlOWJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjkzYWIzYjktN2U2Mi00YjlkLThjNGEtNTZmOTI2MzEy\nZjkxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXLSwj0T+iU8K+4ZoyMPhr0xz\ndMzSjkvSvJjYDbb6Cr6JY1WpCbdfDQJmH5ZQlwDthn6w/MpPe29PA01kdVkcFKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQa1XPk0iVKXpBeovmQsr2a9B+pcDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22IHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAl9e2h9XPbqphtitdxyUYQ5uIEjSpG8Y7\ngs6sQOTePqICIFyVrbch/cSQ9Z3oxX5XxnloewM7OzMtWQB3Q7i0cnIi\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9381", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9381` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAS+9U4/11z0o/ot8jA1DDIi4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNWUzZTA3LTBiNDctNDU4NS1iZTE0LWU2MDRkODM3NGIzOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjgzMzQyOGQtMjIw\nZi00YTYzLThjYjMtNDMzODgxZGY3Y2Q1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXVKpUOpgMyVnhyizt9tTo0wEBu4q5A74DEFTk8qxyxbqnWwnspnPmYl7ltUj\na997U224MeHZZneco71MThAgAqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+rjg8WHgxrj8UQhduWjMoSKUcQUwHwYDVR0j\nBBgwFoAUDuJDmBTjb9ZfZ28tHHPFF7zo//8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIHDXG3Lq7fV4bSca2ZVBY0GVlyV1\nLg0Y0b4istVtyGRfAiEA0+ldeuGp/he3irY4yJwKyYzFKGVy2iDOJLtbA2wV7tY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAW7PQjRrA0VYJI4oRxyYD6COMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzVlM2UwNy0wYjQ3LTQ1ODUtYmUxNC1lNjA0ZDgzNzRiMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcC1DGtLE1qmxlv0yLcUQOL5YhfNBB79/G3syDTsAO1WYp\nlE0TET5efyUkusNXHSwFPvadrxabYF8uowUdLmT7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDuJDmBTjb9ZfZ28tHHPFF7zo\n//8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAIB5NZ8U9Bg59juwdK1jjPOfig5FHeiqRmYljlyGteJiAiBCx6OJSyc9\nKDSD+ntOl8ygBasisEXXugaWrUn7LRiL9Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISASfnQYXTDA3ICGk48Pw0SKUjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjgzMzQyOGQtMjIwZi00YTYzLThjYjMtNDMzODgxZGY3Y2Q1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGJhZjg5MWUtNTZiZi00YTY2LWI2ZWYtMDgyZmM2MzQ5\nOTc5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJIVaL9flzzoo0zIb42Vj6GjR\nVCB20h0m2EXcUzzQbggKXd9Tt082Iz+FBv34b++WV8y1LCYkviJJDTb9uFIgwKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT6uODxYeDGuPxRCF25aMyhIpRxBTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22JHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAtyQ73ZCnkexkQlqfSDz/0cloMwOJjkdp\nRbe0LODWHdYCIQCIo82Qi8ZD1FhNnhfYfi6lyljWI0Ckkm9NYCcpPoiLQQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9382", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9382` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAe9empuwOpLOgyprIwTCnSEyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQzM2E5ZWU0LTQ1MmUtNDg5MS1iYTdhLTAzNTMxYzMyMGNkNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDQxNTQ0NzEtZDE2\nYi00ZGQyLTllZjYtZTQyYzRhMmZmMTVmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEGdy9uWb+UiI+wgiIcRbp/YsmHt7b+dxefNRWcfoBtIxNhOYqlviwG3FChItS\nrMWDCYzc7ujvk5guxiVfYmuO/aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRszN0jW4QqUVhshvVuUwxWjhsm/DAfBgNVHSME\nGDAWgBT9UOqBvlmRbs4UURIx2Hn4Mk1c1zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFuAezWtyAegRcrLrSzSm81duGoIbuVX\nukDpZ5TOtMxdAiBrhLM6KTS8SJcbis9bJuWd0/aZD06Kw7Jk15Cfj9/4yg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASXVYoQHoN4Bvti7OD9MDlvLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nMzNhOWVlNC00NTJlLTQ4OTEtYmE3YS0wMzUzMWMzMjBjZDQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT7otO5RW3jy9WnUoy9yB3UsoP6c8+mYIURNkrib2hM9GCW\nIwOlK/7wCvRxegs/CkK4pMBES/UlD/6mVob2syjOo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/VDqgb5ZkW7OFFESMdh5+DJN\nXNcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOM3WVkt8QdvnwEJvj7VOEV9cobYtmkkM2Ujr8IDOTo0AiEA069YmsN6\nSYCRoBuxiaVjJLm1BFB/g/G4Pbh8+LnTiCA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAYAGiJecuU45zBCZ+3hjfHB+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDQxNTQ0NzEtZDE2Yi00ZGQyLTllZjYtZTQyYzRhMmZmMTVmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjI3YjNjOWEtZDZhYS00MmI0LThlYWItNjJhMDJhODQ5\nNThkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECfZiU3Y9V2S2E0rf3Zkb87l5\noEOyjYMgy/vTWsXoUiBfEC3DXxMBW7j3XB10Qw/LzpRRPsu8+V8kJfuaAU4jhqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRszN0jW4QqUVhshvVuUwxWjhsm/DA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22JHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEApLySFOgflzTWLLGmOygbO+DmspM1L9et\nRhnJ7SS9PxACIQDLJ6JVIf6UEuXRVtLW1/JUJnCuZD1BgC8GR1zWn0Wsfg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9383", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9383` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQXAy7Sy1LGamadpGoMX/LtcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE1NzE2YWM2LWZiOWItNDNhMC05ZWZkLTM2NWQ5OGQxZDVkMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTRlMTFiNTctN2Zl\nZC00OTdmLThhY2ItZjQ4ZTFjMzkzODdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERl6D8eXGSy195A9fqBIolJwQ+48IrSZlSzNIUbxVC2WiUMvq/blvpxdFvmi5\nwxCd7B4KVwBWpYCVTlCub7rBEaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7R7eOm0uKCgcdejej0pj8pbU0ugwHwYDVR0j\nBBgwFoAUdiZxUJDjvYtOn9gvJw+D7mn9HxQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQC01eEm+7YboUqY7Ml6i9pMRI4j\neF6AEcHAgDjHbY+hKAIhAOqoE6nolv7SeOyh5Te6OkTFzmls4eXlxARshtd9p+LC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZHOCMGbzSG+2575U3TsqT3wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNTcxNmFjNi1mYjliLTQzYTAtOWVmZC0zNjVkOThkMWQ1ZDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARqa3OBvQbllmGBnqcpYRjTIyTYe0TiNITMFFdOEPTbQny9\nm2JnDebTTpm3R5+DKZ9fhqT3rH7BIrd6Q0QWiIKQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdiZxUJDjvYtOn9gvJw+D7mn9\nHxQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXQbYpBYcsLAMMNk7u0Yx90Mt9e4u/1/6dHUU6ZW2xJUCIQDT/XReXs2c\n3YEDH3T3HwuUqnskdwwQymbKO5jfsfHaTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAUWkmTKNYPoAziAW9OPIMbugMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTRlMTFiNTctN2ZlZC00OTdmLThhY2ItZjQ4ZTFjMzkzODdjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjE1MThiYTQtMTU1YS00Y2RjLTk0NTEtNThiNjczMGI4\nY2U5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE49awSrm0La9jt04n3f/fj7CL\nqQ1AqOb6XCxq7ZLbYSOukU7gmnkTmi0jqPX7SNm+2HmFO8Q7rgiZK1bCzaYfaqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTtHt46bS4oKBx16N6PSmPyltTS6DA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22KHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiA5nq1BoT4QdEM0dNIiGkrmSsT7FL9ER7Ky\ntxbb6tuDFQIgFNKpHPM5DXQQ4v/cJxnmXpwAawyoQa4yvaj39GvvAPo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9384", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9384` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAcDv9OzA99wBbqmaMnKNB6ixMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiMjllMzRmLWY3ZmEtNGQ1YS1iOWUyLTJiMTlkNzVhZDNkZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTViMzM0MWYtYTY1\nMS00ZTQ4LWI2YTAtMzQ1ZjUxOWE1NzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAExnT8bUnShhzg0fP5q6A6ZFomTTBz5+ERqjE2UPH/tKtTafAhVAadqE9bIfZN\nk9mdqG1IzFps6fEcEUk2El3UcqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTBgyyDSwZEEsRX3bZ3YlcSb2/6YzAfBgNVHSME\nGDAWgBQWyOZz7LfAF7Go9IkPo1mYg2NEkjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCleUYYVgq1ubtxDgeM0fnqDmaCsT+M\n8OZIppJJurmA4wIhAOsY8FG5371FBlTORdfZqfjmojaYP6L7yJkLFZ8Bjkg0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdZXAd5o6uWmDAgD2/UPXnm7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjI5ZTM0Zi1mN2ZhLTRkNWEtYjllMi0yYjE5ZDc1YWQzZGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASqxSKE7yinrMr4qFVWpxWnxCeSOYAq2H806TgWBSvcS4HC\nUGdfcfVAJRPYYtWFvbgvfVn7NHKCdBf6OnPU6oijo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFsjmc+y3wBexqPSJD6NZmINj\nRJIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALShpuKp8CcCzhRdvDbPhQ8T2sBavA6ZMZzF4dLbRvumAiEAsXKUw1Gt\nB/vuFJKv1hz2zA4dqJqc6esqkoFFMu5vfvg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAVIn+kWmRpFqWQThIUI7o0xcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTViMzM0MWYtYTY1MS00ZTQ4LWI2YTAtMzQ1ZjUxOWE1NzM3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjkwZmE3ZDktNGFlOC00MjllLTgzMTUtMzQ4ZWMyOGZl\nNTI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEd6FMaiHmNGS5Urw1eS4pi9bU\nDl4687Dn36IyjWb/4xAHhZpxYRd6tKEdzs+sQEVKbfNjvxqWhKEo/yK7NLOS+aOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTBgyyDSwZEEsRX3bZ3YlcSb2/6YzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22KHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAjTY5WL9fYoCy0iJHRlBe/NFsMtyLmQMYV\nfKNy/Th5CgIhAPhPAU90fvl7suoLmhzB5MGpGi93ChxqX16AieV+/Z+f\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9385", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9385` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAQkSWzmAXXZGRWBfm71ZC8HuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZlYmE5NTU3LWJlYjMtNGFlNi1hNGI1LWU3ZDc3OWZkYWQ2MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTFlMTMxMGUtZTYx\nMS00M2QxLWI1NjEtYWRjMjFjNmZmZDg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdvJLd+DWN8OrCuUCOflQRx/9uvxEn0S+mvJgVTLN3YB4R7GiuTfnj9khh4Mz\nZ8KP3dA4/QwSZotEgmN8dvwc76OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwvnBQB/TTBvKUHwC+3IMn22hdnQwHwYDVR0j\nBBgwFoAUPsbhptPCTWmWFYxV1d6/2wvUlDUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGvHvlc9brcDKEeAZehvW4as0I8k\nTySFrGynYA74NwzbAiARQ3ldTYTMuDFtpDtF+zIgJkhNFeSHxiVR5BeG22HK7g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUKq+VFjC3YBUlLRTQ/1ykxzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZWJhOTU1Ny1iZWIzLTRhZTYtYTRiNS1lN2Q3NzlmZGFkNjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATXjUO/IA/pP5tN5MHciL6GjCY1cBGRV01C69pRYckjmKyR\n10ZmsGyNKxSGvc0G8QI4zBOTUjmZuR8tB1MOLv04o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPsbhptPCTWmWFYxV1d6/2wvU\nlDUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgc7W/yZEZ0ukqX1XIjYAKbK7KYAEqgik9Q0xJJ/AWuK8CICwYBfnWe0Sj\nUFNs8rOD9E7rVLMWrKCAchsPIg/2kypb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAaBlyRONUZiDH/kP+Qidh2DlMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTFlMTMxMGUtZTYxMS00M2QxLWI1NjEtYWRjMjFjNmZmZDg0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmZkMDgxZDUtYjcwYi00MjJhLWJmM2UtNmM1Y2NhNGVm\nMzFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnCFmOb3f+m/Ad3qQGeOVd9EX\n79Ry/gCjaII4P2O9M7prd1ovOj8H+uFY+2nxu4E3vwmaa6dHTpq1UFMck7GHEaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTC+cFAH9NMG8pQfAL7cgyfbaF2dDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22LHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiBJ40ZZxYQVi3J/vxK8xdP1ObY9cnrRO1vw\n5pFYH0KsCgIgNRaM+VvNBYteI0bh872Z77hv7gfPl6F77MXUvPOj86A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9386", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9386` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAa3LOPbANy7AnWRHRwPwVL1FMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMxZjg1OWZjLWMwMzItNGFkNC05ZTg1LTNhMGU1Y2ZiYzNkYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmRlMGFiYTgtODA4\nNS00MzgyLTg3ZDAtMWFjMDE1Mjc4NWZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEit0dWrym4+NhyWYchNxFQYXg/5G0iaEWuPLLfKj70p7GkPOXCyk+3kwUh5JA\nCQyyBshkOmw2KlqVjH3SCfpViKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQaWHMIOQO8z+LiuLD2oWRmrYx7uzAfBgNVHSME\nGDAWgBQ/r0iawxNoexynwL/dCPnotIu6czAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICTjEgobKhze0z+8gehkAXaAw9Y5epJ4\nIUQGk88NFGNYAiEAoiRuCGWFpmAtYVC0cMiNZlG8x1BpSCnGwgvyusShrpI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbyazvu7F3zu2Q51ubghubCzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMWY4NTlmYy1jMDMyLTRhZDQtOWU4NS0zYTBlNWNmYmMzZGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARwZGqT9n8sODSuRCvDIrwuyc9XxJ4YS0zBZ3jYmw+37kt9\nPc70G36+KCnzhLm9Pt8tZkcs8cX34wR/l7XT5JyTo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUP69ImsMTaHscp8C/3Qj56LSL\nunMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO5qOdYidHQkGPlUzPcnvO+Nq3KFZt7J+4d7g464iHUrAiBSFZp8MKUW\n4wlCzwnMFp2rKcsJ1iCAkfF6vrayd7Pspw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISASL1oDvMQcT/3EnAmxtJmWrJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmRlMGFiYTgtODA4NS00MzgyLTg3ZDAtMWFjMDE1Mjc4NWZlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmNmODY1YWEtZTczYi00Mzc1LWIwNWItNGMyOWMwNDcw\nODU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMVlxzGe+7eXOMCz8abCr068B\n/hxi5ljw0/6IHBArp3fFo1fNXRlLGUYO6gVHnj4eCI0K/Tql/xI7PuadeJhpt6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQaWHMIOQO8z+LiuLD2oWRmrYx7uzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22LHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEA1pJ7e6nFaZMjn/mcOzTIOXZrdTzLO5Fm\nvLqnxIbfwvICIALuoWHk4owbRGDrd2XRN6VAkvkytIq2Ks9eBxHY/8bW\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9387", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9387` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAd2TRr5xtOgNDVNXGD+iZrfMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxM2ZlZGI1LWFiYzAtNDIzOS1iYjk2LWFjMjRiZDc5NjZjMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDhjZmIwYTUtZjdh\nMy00NjMxLTlkY2MtMDkxNjc2YjU4ODNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE//OZen1P8lMnWm6feF3hiOBViWh9cwROQhjtqcKgr5Q34ChXnNxQS1+or41u\nHZnkGGRL74nV79Gcl5KkZ1WNv6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeuhGrJ/y/dPZJCxRW2a8ot94kg8wHwYDVR0j\nBBgwFoAU4HqQqNWN9ruVfpV6MPYjwAOsRWkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFuVtWsHB9P5XvY9nBTBXBy7USza\n3vHWRWkeCyh+x8UcAiEA29EE4PVdiZ3dMkofqC1zb0ne7M7fAKyAjsNNWM2mVek=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQJYMfmbMPPLxaOTFsz97T0EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTNmZWRiNS1hYmMwLTQyMzktYmI5Ni1hYzI0YmQ3OTY2YzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8kT35XEy6Bpi7s5CDUipYRmWJQOr5PwBAMut4vU3etXPt\nh730pKwDXkQLKFrtqIhobUhNpDGc/onnAOhlVPDoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4HqQqNWN9ruVfpV6MPYjwAOs\nRWkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALXbIiOStMUMLbGhGtSQj54RJaZZ7++am6t4Y1ZYkZ5QAiA5D0LmAglP\nmQIWpz+L9ruMXnc5FVtsL3pOz2Yd19EN0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAXv3jQukL6gRObJuFbK/rcRAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDhjZmIwYTUtZjdhMy00NjMxLTlkY2MtMDkxNjc2YjU4ODNlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTYwY2RlOTEtNmFlOC00NmVkLThkOWYtNzVmNzNhNTFk\nMjJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbLvF1SpsKfRhdZXjQEaWt5RH\nk8hgCRmdb42q/uMi7lhQnxfzErrRGXlM3mmatQeb34bGO4s2LwzkFLSFNbZbIqOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR66Easn/L909kkLFFbZryi33iSDzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22MHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiAX1T1zC8Zkaqsp55LQq7khDKuv0dUcVLpm\nJUz/EbgYUQIhALAJkQRzbiQBCoRGgobEhgpnFsQs8OxX+pmYFVgHuQBx\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9388", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9388` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISASH6T1VRJm9Dt3cYpJ19o+vCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE3Y2I5Mzc2LWQwMjQtNDkxYS05ZTVhLTM4ODE4ZGE2NzQwZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjVmOGY2ZTItYmY4\nYy00ZDhjLThhY2YtNjRhNWYyOTdiNDBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9Y9uSMst0x3lzNaGBSLp/HmykANfLH633qeNBoT3lmG8qG32c6zU9yf5Ai9t\nMfZe/mgknnfXJjLNVnbUAMHXcqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT+jITicXc0k6QDXKoSdHyDqmI2nTAfBgNVHSME\nGDAWgBSJYuq9EUuaZnODnCD+hxJX+66yOzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICNVVNtyT8JB50nEFlRxsGVUBw6CYYD2\nZhVpvAB+aGbGAiATK2KRmhVvR3jU7srCnkRbHsDZN100aP7i3RvLlQZCbw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAX8+2o7CH0uGhSXe+14t2eiIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nN2NiOTM3Ni1kMDI0LTQ5MWEtOWU1YS0zODgxOGRhNjc0MGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjPiz9/hlNmWGaXsV4pFcFzND3n4lYhjeg7znce+WhYV35\nbyjJSMiFw7o0VeZaJG1YTcROlQIBuc2DoWVC9lS+o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiWLqvRFLmmZzg5wg/ocSV/uu\nsjswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO41KoBnsQCfZDzyZ8ekgh/6itI6jOfQlNKyi/QTimmZAiEAxmB4S08N\nMTRsTH4sWYffgrhIZfA9GDesvpPE5a3By9w=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAYUyUt4whpWb672FdZLU34pBMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjVmOGY2ZTItYmY4Yy00ZDhjLThhY2YtNjRhNWYyOTdiNDBhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGI0Y2Y2MjctOTZhZC00Y2EwLWEzZjYtMjMwMDNjNjJm\nZjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0ZU8LRtENEbfzHb46DLYdFZ9\n2K7cJDNHbsgsoFsa2kD3S2lYRGG+lK0LU2lJgQ9tYdDxtZWYV1VrzaP3c+y3tKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT+jITicXc0k6QDXKoSdHyDqmI2nTA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22MHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiBNw/kkp1kMj0PfNrA56h2GNilsqVGiDw0X\ns8c2fM14hgIgEQailrqpNlaK0WYUvh99GztkVw7gc0XqbImhmbjmTWA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9389", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9389` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAXyuwNvZOwPziJE+1v3SH7TvMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2MjM4ZmZkLWI3ZWMtNDA0Zi05MGQyLTc5MDNjYTZlN2M1ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzNmOGQzNTYtOTFm\nNi00NmMwLWIzODUtZjQyOGU0NTk4ZjY4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE8PUd0neJmqv4dTKFq5N0+1NsS3dlnnEmfKTKG/ZJyuEyx/yjOAsy1b4/7dBW\nz4yMLjqAiem02WRM17XcVPsVqKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHNwkQ6gbENTjoZmWMice6+A1RNswHwYDVR0j\nBBgwFoAUzR+pGjuyzVca2kbWMyrBYodhAoEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIH4gMrrZOjTaJxvdl8J2V1yTQCyP\n25Iu8goF1HIMC0GPAiBOyyY9CKzyc18MHM6NQD6LNZOdDl/CuD4n5QVWpVV2vQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAefyY8M2ya3xLxrdhP4/FXSCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjIzOGZmZC1iN2VjLTQwNGYtOTBkMi03OTAzY2E2ZTdjNWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+dz3I4HETqO8p1ybB2l7+rk3Nszmkl9CM6qD6SfvYcP35\nUbB30sjH4ijCihhZowZG5DxSvacYUyaHFkcURLTjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzR+pGjuyzVca2kbWMyrBYodh\nAoEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAN3nWrKHEKbBEbkw+48LYOEbtesoYpFkcpAjwVAJzZswAiBCivJIYz3V\n6ZRxEEkBuoBHOC/SERIQmu/eEVYNLlHGOA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAQZogcCzB96SKybpOCIoqNtMMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzNmOGQzNTYtOTFmNi00NmMwLWIzODUtZjQyOGU0NTk4ZjY4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzBmZmIzMTUtMjk1Ni00ZDU4LWEwNmItZjZmYzQ5N2Ni\nZDVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAES4GaOkLCebZXmSWyGinc8hwT\nFC2fDOj6zpUqD1rPRTqpnwkdOtx9lYm1BNdyS7QJtXWt4/ukKqH6qhHVMNGpvaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQc3CRDqBsQ1OOhmZYyJx7r4DVE2zA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22NHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAggjffyBfTdLPjauZu+Ktw5dt0fenv/48\nmynj6JPFVwUCIAmZyPM0YSkXeKJV80KwbgVVp3UCnMQXO/DzLp9kx17z\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9390", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9390` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYGpaCkduZZT/fFhOT7YEGs9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDUzYTEwNzdhLTE5MTQtNDY1ZS05OTE3LTM1NTUxZDUzNzJhNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzY2NjQ3MWUtOGE4\nYS00Mjk4LWFjODktM2M1MzQzZTcwNWNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESArm9jYHjcCxqLHGNcBdPsJ6+75T7E9fFNeC/GtOX7TdTUxcE0qX/hV2W8E3\nUnG9gY3WitcuECDDR6RMVnOYIaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTDNaGUlDONizr0dp6ei2Djpx/7vzAfBgNVHSME\nGDAWgBS4q3zyLF6uzLoTLu2pjUxcVkdYuTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFHw8DOMfKUeq/PV8OtkJcadOS2W25KC\ndXXrgzaED+jKAiEAzXaX6JkWX65NyzyOme2zDbcDiaHJz60fMvFjOHmbWI8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdG6ul0l+2YSJQ8gxv3lDQsOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nM2ExMDc3YS0xOTE0LTQ2NWUtOTkxNy0zNTU1MWQ1MzcyYTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQwC/B5vOfiQShWOUmQr/h1nCtALLbnOlvHHtI3ViGWJdm3\nd2j6aRIcvQpJcul/jPzTmDnunyLpv+SF/YIxV4C9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuKt88ixersy6Ey7tqY1MXFZH\nWLkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVMrlMf6S4gELKVhqKr1eAAy3UUkakx6TTyFwEMvYaMwCIQDIV3axwdZn\nrVY1tbfbJISuVJRrMw2rKCpS60udSfq7eA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAWsSoADRDuiOE9d91uIpYVOoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzY2NjQ3MWUtOGE4YS00Mjk4LWFjODktM2M1MzQzZTcwNWNhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTY5MTZmYzItMGU3Yi00Y2Y4LTk2ZjMtZDhiYmRkZmY2\nN2ZhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0PQTlDHXpwrlAJK0gYsk590d\nZVa56ubAhtP3uQ0nTv0qWCENcR9/o9T8BxZ89+Fngg9vNSqgINgi7SykB/HIiKOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTDNaGUlDONizr0dp6ei2Djpx/7vzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22NHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEAxYE5HPP7Bwqhy/Ee2yXS5AbJ9FBeIPwN\nKuBVmq+WG48CIQCpJknA01SiWM9V5O2NN87m11k///b/ecGrUQ4zeSRX7w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9391", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9391` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVsXNjLk8Yp+YWILmTBo+QySMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjZTUwN2NmLTIxZGQtNDY5Zi1hNTJmLTYxNWUzMzg5NDYyNDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWE0YzVhNzItMTk1\nOC00ZWVlLWFjNzctMzM2NjI3OWIyZThlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE08122u5svq1BejB6eFBSoaq5fB3rsl+eIYey8Z6E1T3eT5KJzCFMNrhNsp80\nAu1sqMcvjEouWoxGj2ItXPVjLKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxbu0WDqzRzgoZ055b+ilYB2BmUMwHwYDVR0j\nBBgwFoAUYra1mGWI16AcaW0DzBtLdVje3zcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCcbpMOZzxuPCgyZC3RyQHSe9dH\nrl8k0fKHSuJVIKWRZAIgSlxzFHCSBsvrFKZUDGtW336iMRIrNlL0gnlR96emDng=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcX9fOSTe5ZEblBFIsMBSMYLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nY2U1MDdjZi0yMWRkLTQ2OWYtYTUyZi02MTVlMzM4OTQ2MjQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATyRqyxr5D33t1PSWqoBKGLDf9R08AhtCwDIVEc4O0fwxAX\ntIqhQJnLYT1mLhZ4kSQ1/ZDUXujNxe0AOLntHsUpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYra1mGWI16AcaW0DzBtLdVje\n3zcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgZJhMJntXSXsy9AG76JtJGeafWInMDyh+U+Da0nnFh3ACIQCk1Z5GPP00\ndBj2a3g6e934qi5+EkhNBm1mPxz6YfMevA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAeYlPM03go12OR4r1OILyuxuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWE0YzVhNzItMTk1OC00ZWVlLWFjNzctMzM2NjI3OWIyZThlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzE2OTgwYzctZDI5NS00OTlhLWFjNjctODU2MjU2Yjdl\nNGQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5gesHBLvZuw+EUVCHXMEN3z7\ndQPgc/krndTC2F8+lNuwX3T0jOmw/iaT23i0S7iGW5vaEAX4S8UBWnYlOKzaOaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTFu7RYOrNHOChnTnlv6KVgHYGZQzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22OHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAtBV6PW27cbQGYTaw3fZrvyAlR5oJUioO\ngmive6Si04UCIEKOaSnPoieoscksd2/ycksq8FRe2fWaoiohhaiaIXti\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9392", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9392` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAV0PhUL/8DxTE9KKhqWZ2mVbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYwMzI4M2Q2LTFlN2ItNDQ5ZC1hMzIxLWZkMTM1MzgxOGQ2MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDQ2NzU4NDAtYWQz\nNy00NmUzLWEyMGYtOTdmZjYyNGY0ZTBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEB8sIZQ9thvIpCI3edLlJRFNfX7C0ufWnzQ/5MSEREU1q/jAZUfzwAIiY4vjl\n9bsXfSRYb2lKiAy+geFU6IAyraOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRYxfSZX4kocdb5et6UOWyi6fTTLzAfBgNVHSME\nGDAWgBSjEN1h9H11AG7krMa0LouVNmqf0TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC517Ta1ts/NiS/REUvH7MMXudoLQQ5\nKN1Z6fYLybeQrAIhAJp6EaK7SffiIuAoafhibWlr2qriaTPfnQ67SbkGzfD8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQPzD9UFj3YXyoVOsOXF/OLvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMDMyODNkNi0xZTdiLTQ0OWQtYTMyMS1mZDEzNTM4MThkNjAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR7Fd2REclQQMoOYksq8bp4TF6E2M21N00fDs8KW8Vhn/P\nQ8tohTR6awmAQG3OqOLNcbIeypeimhGYhZV+/Mjio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoxDdYfR9dQBu5KzGtC6LlTZq\nn9EwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAO+8004ns1r2HqdEZicIHAF/DlVCOXjkJyM0PbxvzDDlAiA6TkVlc7MN\nlkWZ3R6vzZp391nJBC3TfEE8rATK4aD8yw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNTCCAdygAwIBAgISAbJsRqZZlD8j41ANV8LkhmMSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDQ2NzU4NDAtYWQzNy00NmUzLWEyMGYtOTdmZjYyNGY0ZTBhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTdlNjViYzAtMWViYS00ZGNhLWE0ZTctMzY3NTgzZTcx\nNDY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKoilT/uBPhfMj5VQnBjlGKaR\nSgXzCIhn2raosJOPn8PewEtT4a7qbPI9bpy+vToE02jvOMsFYqmD9nby2FZddaOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRYxfSZX4kocdb5et6UOWyi6fTTLzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22OHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNHADBEAiBffYe9UIBgh/IdQsBeXhKURqwV/XynnCI4\nDS47aIg7SAIgIsVuf3NFdSQfkZH3aYWWj9BmN7SSqN8pM2R324+3jXI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9393", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9393` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATbDdxVsiw4OVaB4LTIM6azCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3ZWZkNDBmLWFjYTQtNDVjNi1hOTQ0LWJiMDRlYTkyZjBiNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2FmY2M2MjktZDQz\nMS00NGY2LWI2ODItNjUyM2EzODdhNjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbkwoeYAdYuHYxVo6txj3QPgo2ohzczle+pt3K4uj3SaVz9mHacOBZdAQlmo1\nocqCt+5qkuZ+n5NgZigMP6cA16OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDpz10HFS2YkfzVqjqZdbk3UYybwwHwYDVR0j\nBBgwFoAUkL2+ongChJyNmHd+HymHHtUG6rowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFBuLfxz+/Gzn71N0K16Q8Jm9HNB\nT7ocH3xf9SnBx90LAiEAlExUIjQEDC/1F0ij4DkK39cZ8IQvSPMaiCNpU3JmGxQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZ8sbnXNeEVROjNRg+pcm5b0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2VmZDQwZi1hY2E0LTQ1YzYtYTk0NC1iYjA0ZWE5MmYwYjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASIVFBNapFJaT34+1J9++PFM10gz+iAJpeWpgPn5KH6zkiy\nPs8fFYm3jlyBIbmHuH6JcmjA2g6QqS4Hp8MLnarpo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkL2+ongChJyNmHd+HymHHtUG\n6rowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfBty5te6ID9tPD5EFjIeN7OLKlCb48EdU8adt1jrvcQCIDf2izscXEc+\nlBvlZC1yONJqsTS3PSj08Neqf5N7gpgH\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNzCCAdygAwIBAgISAXnzXC3yQ8rDoUl94VLEtfqCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2FmY2M2MjktZDQzMS00NGY2LWI2ODItNjUyM2EzODdhNjk3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTg1ZDQ0NmEtNGNlNS00MDgxLWE3YWQtYWZiNTYyYmRm\nZTAwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIK1UZaxEujjbstvLKO/aH5N7\nU9P0hv42/hwvVr6sOaTkI40GBOb0x0WL1r5kZm7J3NRhw9G6hH7maxGgjTesM6OB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQOnPXQcVLZiR/NWqOpl1uTdRjJvDA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22PHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNJADBGAiEA8kYR+lUk7ySww0dIKo6MIpX8SBRf8VVd\n3sSKvaIvjg4CIQDJwuJJdmYwyo7Z87o7/HarOniBK8k8xi2e6LGkkfOF+w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9394", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9394` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAc4ooq19moDfKmhDqM1ggDjlMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDYxZDRhZTFlLTJjY2QtNDdhMS04NjczLTAyMWQyYzM5ODc1ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWJmMmZlZWQtOWZi\nMC00NjEzLTlmYTAtMWM4NjFiNThhNTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEzSOEqNgN+xbRGCvYfBrZIodFSr97J1tR/ycR3Q7Ks+tN0WKymbSPulopjKk\nuza/d0pCZ4arBdtJy/Fvoy1/kaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRohjhVujJuP0N7VlwFlr5LNkBcPzAfBgNVHSME\nGDAWgBSN07tP8Bu+A9WeIVHox2PP3zgWtzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEHB6GvKG6L3dg0/t16+HXPwNR522wDA\nFQOLvfwZQvvWAiB5YL9wiL8Gp+vwAEYxgGVZok/LEXosHeMX/E2ftVxsTg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYfpjUgVrh3Kw8sRXpqFN8KOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nMWQ0YWUxZS0yY2NkLTQ3YTEtODY3My0wMjFkMmMzOTg3NWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASKHikv29V7lB7oNQCRCZJQJ6Amm3LEtC0H5pXHD9wNaZrz\nSY0XoJ1KoH/V2qw1z0ix0FzZvClI/7PDhf0U+1iPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjdO7T/AbvgPVniFR6Mdjz984\nFrcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANlP0DoKkKY5yj6s3C8z+pNNUVLR2sRpOHJlcd11ayPxAiBFveC/NOfu\n9MpA1+k/Xi6jOqOeya1Wd6rWnjaRfUag5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICNjCCAdygAwIBAgISAchDWIMvdsq72QMhiYPZxzWbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWJmMmZlZWQtOWZiMC00NjEzLTlmYTAtMWM4NjFiNThhNTUwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTkwMjI2ZmYtZWNkYS00OTFhLWJlYmItNDc1ZWI2ZTlm\nZTM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBa1fWFJNgsfsGidkvzi/NDy9\n0eLvsNtCJ0RA9WPnQEGnnPKkDzM5Qcyek15GW8dD5XRLJlHrVOPGqeFIQLV0waOB\nkzCBkDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRohjhVujJuP0N7VlwFlr5LNkBcPzA6BgNVHREE\nMzAxgg9iYWQuZXhhbXBsZS5jb22PHmJhZC5leGFtcGxlLmNvbTp0ZXN0LmxvY2Fs\naG9zdDAKBggqhkjOPQQDAgNIADBFAiEAztu1DfUpA6d64MOJJ1yTeDXcTuixAXpG\nACQ/F8fSJuoCIGQvumMAvLx0LkDOce5QulZZVEny9ox7LYW+YfWUM1vs\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9395", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9395` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAb7FbEqeKlJznk78/j2b3MFWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGU0YWRjMTlmLWRjMDYtNDAyNy1iNDkwLWU3MGQ1ZWM3ZDNmNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2I2OWEzMzItNWEx\nNy00MDc1LWEzZjMtNGQ4OGNkOWIwZTJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEj749wXVwTrEY9E3fqUubJ/uapY8K1QtuMMSixQpu/YQn3s0L5BQEzizTmaFv\nX4/m1bo9F/J+tIy3DhI1kwRJP6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyGEBU+uwnKgZ+MhRyOt+JQ8I3mQwHwYDVR0j\nBBgwFoAUBfRMTG0aBti62HuAMjhVrVqAHB8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEAhC/m6Pv7uTFN3w9fvoZR8sfUn\n0XL3inWx17EDVhVLAiBGNyPWSFqgk4cbUfVGOR0fseutpVb8ubAcOM7VhoIuCg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAfTW4UCyH2z/5i7BtA5vT1tDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nNGFkYzE5Zi1kYzA2LTQwMjctYjQ5MC1lNzBkNWVjN2QzZjYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS+ihWQXHruB/rGw6tOY1chFr/pTGQBjXjgYkKza8jcr1MN\nd/1baSkSbsU+gyD1lVzpA0Jgi/7SmA2t/DZr6/j6o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBfRMTG0aBti62HuAMjhVrVqA\nHB8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgSDPeL6yyqroz/CGwFhYV9S0NwLU2FvlDjaj/oCBxEkwCIQCdL1Gl2hEz\nMq6TffMcIAznG6qBfuFnWi+YhDC/LGjyXg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAUJRTraZ7B2DIjGE8IRiIiY8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2I2OWEzMzItNWExNy00MDc1LWEzZjMtNGQ4OGNkOWIwZTJlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjM1YjgzNWYtYjVkNy00NDRkLTk4N2QtY2I4NWJjN2Mz\nYzYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQngqav0p1FeUP3cWRC3160sv\nBaFQ/D5WVAguGvLJNLSSsC9w8MglcveUO2ww2dCGWSS2eBZ9kl1hInyYZGQ4AKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTIYQFT67CcqBn4yFHI634lDwjeZDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22AJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAP+ZNcFN0JiorSHEhZ8f4a5U\nfYcRDxlYz33cfitcoJx4AiB1K5+8OFbH2kVfyhqGNyu27vnBVIwq0RIrdE+GPVO7\n0Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9396", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9396` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAa7j8urHqIX4K3aC4vNZPT1KMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGZmZWFiZjZhLWJlZjUtNDlhYi05NzE0LTY2MGNhOThiMzc5ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDYwZTU1NWMtOGMy\nOS00YjI0LTkxYjEtZGQ1Yjk5OGZlNjk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvRTqzfrzH6HFiMfj3qzUyL3K73+vupVIkg7h3IbTuXfnvGeMjElMkpGfV4hH\npCRg2cmbMwczG/iPwV2U98dVKqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS6uh8Z0mvl2qaGGmFYMGGV9wo6wjAfBgNVHSME\nGDAWgBRS8Rp1l/BQv92PBz7bWkMa+lF6yzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIGOJHQ8hSbK+se/nXwyCadCVBJURBV7g\nTkbawT1hTr2AAiEA49Mi5i3ncFv0+VT/VYtvj7qFBveWYSYAyEYsjmc3Jro=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbs34KfRR5hZ0Lxe1tS31Wk4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nZmVhYmY2YS1iZWY1LTQ5YWItOTcxNC02NjBjYTk4YjM3OTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ0q0rVkFCKf30/3mYxGBzg6Y5eZHWm6K4/Pzzj+gWQT9ot\nedTxXFdiwTGRXNqCh5PamdpiK5GMD4Li1ck29OMZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUvEadZfwUL/djwc+21pDGvpR\nesswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgGCLmX1HmXtEs+mfTpWf8YYsuGrrXmTEsiwH5H8ouLdwCIQDMqWGCMHll\n6b/yrkX6mypnTVrVUWM+LnIawTEQ/2/+0A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISASpEWPq2/OKOtrNCUcr06iuYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDYwZTU1NWMtOGMyOS00YjI0LTkxYjEtZGQ1Yjk5OGZlNjk0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjk5YTk1ODctMjUwNy00ZTM2LWJiNjMtY2UxOGFkMTcy\nNjcwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESi0bOAfSvDsRBlGseTGe2ZRE\nFlabVY2JQ8Se2fTymyX/Xj/x//gRLxA4X5arO3QgyP7CFAr6xmrR6NCENGjbcaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS6uh8Z0mvl2qaGGmFYMGGV9wo6wjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22AJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOKVi8aWplZPlot/a4NYVtUF\nXajFnvn9scHQ41alprtPAiEAhR+mB9UEBvn/Y7H6n0SLdl/QVjFS4C4Bxuxbeeo7\nVnQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9397", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9397` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISARd4mF1+xG1iJyl2K+sqTgO3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMyNDgwYThiLTcxMDUtNGFjOS04MTE0LWRiZDA2MmQ0ZjdiMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmMyNDE1YzUtY2Ri\nYS00YmEwLTk4MTQtNDI1ZWZiYzRiZmQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpanjObePRYnqPGt/mZBFM6uRmWT++VQJ1nQoJsKkighHH/o5So8uib/kjuHd\ngXA1zyholIQzd10xvM9jEV1H/6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIKdNY6eHmYJ6rOyLvNfoKvjGNVEwHwYDVR0j\nBBgwFoAUsG5OY7sGJ910jinpLjGwtruEiJkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIF9kwAuHM+ra/8uKe2/1bx4HaEDZ\nE3bglHE+9C3knlIaAiEA+WCfCxZEHzWdcTyHZfXYhVqlcFJtUWqCI3Az4dCsNCk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAQ5OOgKOKIqw9YFfiSd/cvFeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMjQ4MGE4Yi03MTA1LTRhYzktODExNC1kYmQwNjJkNGY3YjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARyZIJU43wgBSWGlK7bNZgjyYSXsQeDXS8r4lZAjlPovk9Q\nyx0GxlUK6iepY7X+a/p6cn9oQZUXH3mlZp0zfu05o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsG5OY7sGJ910jinpLjGwtruE\niJkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOvKFKDZKfQSdqCUKjbrp1saFgXSt9yponl+P6ctecxrAiEAoGkwJE6P\n2ogiokm2N/3MkObv1rYlxh/E+gG/+imYwdg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAaTlhzrT6/rkxZo0pKS33zqLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmMyNDE1YzUtY2RiYS00YmEwLTk4MTQtNDI1ZWZiYzRiZmQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTJiNTUwMGYtZGRhOS00YmFjLTkzMDItYjMyZjg4MDM0\nY2VhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3o9Km4ttnIxFVrQlNcNeAjR4\nZN2eNBnb/t88dOl24TVZh5S30jvQ47AIXPRwidGEwww2aPMqONPR28bHfIE+7aOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQgp01jp4eZgnqs7Iu81+gq+MY1UTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22BJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgHBngoZKzaemjNBu3IgB1kU9X\n5airkCbx6HEMWOCEfBgCIQCVgVN6uGVVGn4lY4JXAowhAR1VJI8h6/ZY2Qhf3drs\nxg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9398", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9398` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcN3rz+4S2IZ1TkrFZt0blqRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ1MzYzMTk0LTEwMTUtNDcyYS04ZGFlLTJkNmI0MmJlYTVmYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmEwMTM4YzAtZjll\nNi00Mzc2LWI4YjUtY2JkMmMzMDI3MTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkzM9a9EAUd2+dxT2rbcQMZd5s4ebWabGWR0UV82S8EU2ra3TwTCXuhGTvsZQ\nNvWPCgxiW/6hvMXPv8Qz5uB3w6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQn3ZP3LtbkRecGuCIf6WdzCOnk5jAfBgNVHSME\nGDAWgBT7yiAHAVvy4gMBmAImwBGup2CL2TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDsO37qaOfU93bRVkEuvtzeXOdmAFKm\nw88Hfe+qcmXqVwIgZqA9RRaztpS9PKp69fYrScZdGuMhZZEsJ6YIeCJTwTw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZhaMr25U0JPl2rXYfOfCxDBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNTM2MzE5NC0xMDE1LTQ3MmEtOGRhZS0yZDZiNDJiZWE1ZmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQO+7ErOLY0eBCbXDdiIZSGMGRz7b3QcNqw7qlgGqSM193f\nGf3A/iyUfIrdQeeRezRX0n+7ZqxRbncixQpIgKnio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU+8ogBwFb8uIDAZgCJsARrqdg\ni9kwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgXL3JB1c6r1mdKB0fpxjru7gDMR9bhvNYetEOE3ZLIksCIQDubhEPKOgg\na3mUtGY4TnbyBPlTaS2vqcf4q4GqQstWEg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAfxs5gsRp9UEwjhTFWODgeTWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmEwMTM4YzAtZjllNi00Mzc2LWI4YjUtY2JkMmMzMDI3MTQ4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDljYTIwMmYtMDMzMi00YzQzLWExMTQtMTkzZDFiNmI0\nZTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEz+km//HcoDRiatjC57sRcFn/\nceonEaZ8JxllcgR9eTkkDyheqdkX6MXIEzF38g9C3bf4Al/FUTmWnI40iVS4zqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQn3ZP3LtbkRecGuCIf6WdzCOnk5jBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22BJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAInXS1oDQBcZo+clhKwuFcYQ\nk5ifsB9ZsOSIEAEqTuWgAiBbZW4WtTWj17ad8VEAHe+gildzVN6soLqryBI2s+gD\nxg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9399", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9399` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeVP2B8CDic+3odorG8/qOkRMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAzYzgxYTYwLWY1MWQtNGNkYy05NWU4LTUxOTUyYWY2MDRhNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGE0MzMxNWUtNTdi\nMS00NzllLWFlZmItYzhiMjhkYWNkZjU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEevk+K7Ov8lrgtSlxlWQIQkPq1vNSBVzndzPzvuBZ3djgFc8LB31wC0LuiqGo\n7pVSPnqymf0GaIlz6Tpl+n59DKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg5a4ciVLqi+w3jRGb5ubH0T7no0wHwYDVR0j\nBBgwFoAUcTCAaeU41qE7We9cVFi1sA4blUEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDu06KDiyJQeeBemUmkJaHGrdkL\nxikTOsq1vYl17Eka+wIgffc9WEYNWptk1Thbo50FY0jeq+BbtwM7IhYN4v5Zgr8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATwzZnKHtT6VitVNUSD59N81MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nM2M4MWE2MC1mNTFkLTRjZGMtOTVlOC01MTk1MmFmNjA0YTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARHEiqmQe4a1u1ZKgltBYxGqkuJ22FTyPAjeyI8W4B5pJRS\nZ1nYs0lqaveroGPZZVsjSU2uImgHSfB1KcVErLEJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcTCAaeU41qE7We9cVFi1sA4b\nlUEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTMYyDFBdwVskwEcRkbFdpqI/VtRMeoX5v0RJKPKQ9tsCIFLIkPHEEu66\nD41DBFaJp7pvykAwlML9TzVtuaHuQbn2\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAXNI10r3yW9gdf3nUDTA066gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGE0MzMxNWUtNTdiMS00NzllLWFlZmItYzhiMjhkYWNkZjU0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMmM4ZGRmNDItYzA2OS00N2MzLWExMmUtM2UxODAyMTYx\nMTI2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETJaX4uDd6JHoes7330aFzjbG\nH9VhIsDyN88YvIq4MeoGPn/0fRKiQ5otGKJpX5dCnmq3PgCAOM2kv6clRVem+KOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSDlrhyJUuqL7DeNEZvm5sfRPuejTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22CJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgXgokF8K7pDb6UdNq1cQDQEms\ngXn9vrJIX5eWyGhq5AUCIQDl03zwBfqpTNEccrVvIR5I490oEkvg6DNZEKE8z/bL\nWg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9400", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9400` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAYDtNXBHJfmbHT/6lZsBiz+4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRlYTJhYTA3LTM4MzktNDU5Ny1hNmFjLTMwODQyNmMzOWY1YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjRlODBjNDktOGM5\nNy00MGIyLThlODAtNDA0ZGYyM2VkODI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESsmbXzbw4wYMVf7xq+o4+GNLK/2nhBCOqtxh1EV6jS9JUVUnj49UZZe7txia\nBnfZNiU5Sa5Jk9/6weRSWVph/qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSITIb74sKb3m8I9QC1IJmwnY+SdzAfBgNVHSME\nGDAWgBQJsGPFa5mwJJj44rTNcBNsOW3F3DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCbvb6n++ikwpoUncyzo1mOEzgOS0w/\nDjtb8951oAdSfAIhAMBuYP+SVYlhFl1q9DZmLQKFHC6MSd03Xn83ELWzjxDA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQuGdqN3E/ksjP9K2rdGLfJ5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZWEyYWEwNy0zODM5LTQ1OTctYTZhYy0zMDg0MjZjMzlmNWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQ5Kjyv7qb/ekyoKqUufdWX9hzrZzdKRbfy/STs7BxOS3D+\nagAgmHT/0j0PCetal/r7FnMYYJNC2ggYCqUyipYJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCbBjxWuZsCSY+OK0zXATbDlt\nxdwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALHxDpdWIzW1D1yzVRQTclN4ZDZgOoS8Y5cYcHr3yZu9AiBvT94YtfW+\nmXM2UfEPvnjZlNacLqpiHXH7AzqbHhSYUg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISASJitZTnPNkUvvPblCgrplw0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjRlODBjNDktOGM5Ny00MGIyLThlODAtNDA0ZGYyM2VkODI5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjNlMDgxMzYtNjFhMS00NGUwLTgzMGUtZGY4YjNhY2Jj\nOGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9tCvCdAAlEypui4pLQ3T++NK\n9Olg6HA0PT3fbIq+P+qHDwv/g6fNtcsF6dJJCoKmtCUODR0k2HyUz8aUz3npkaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSITIb74sKb3m8I9QC1IJmwnY+SdzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22CJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgJwKWbwZyx4Xoi1ZURpMYbRgL\nsH2C1TReEU/YZAp9NykCIQCsRRxKlCo/4HSFCiuUHRgcWobYSK+iuclvQ1a+RXn4\nsQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9401", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9401` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAT/7AThlzcREPu0oAvGm6s4/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk5YzRiZTQ4LTUzNWEtNDI0NS04NTUwLTk0MGIzZTI5MWJmZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjM5MWI3MzUtY2Jk\nMy00OTFiLTk3MTEtYTQwNjMzMTQzOGVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEC2ydm72wJ6C7T8WRJYRFcMvjD/2qO4Uib9q0en2d9sjsSvQpWSOEhjShneTZ\nsT+XlfaQw45st/ypVxe42/0EaqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUo890N462nYkkGx14U0ytdnqNVAkwHwYDVR0j\nBBgwFoAUkkKPWWABd9cdyEeK1V2e3oVQGgYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFYDn23ypcRM3M6rIjUnoO7AJ5ja\n1oKhpouQ9PunXp06AiEAmvfm7uEJRvBACs0jMo3N4sgdwKL2oEpkHWDv7s+Gla4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbMnLPnaOcrY20vya5QRvQGtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nOWM0YmU0OC01MzVhLTQyNDUtODU1MC05NDBiM2UyOTFiZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQVJd0F8xGGbGPwFC2Ini6palTfHJbBoH2HKI9ovn1gP/lT\nd6k78dtVVzm+15xuvRkrxZz1Wwcv3rX7Rd9XyQswo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkkKPWWABd9cdyEeK1V2e3oVQ\nGgYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMGblit/uo7W3g5xOzMPS6nZOKVP4kWOEjQ4MQ1ihYcJAiEAjD+BrUYE\nxCVn1jScnzfj9bAzOwRlfiuzr2O9rHF6oIM=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAYBByqTbbhwG/gczY1Ml/jLiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjM5MWI3MzUtY2JkMy00OTFiLTk3MTEtYTQwNjMzMTQzOGVhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWU5YTA1ZDgtY2FkMS00ZWVhLThkYmYtMjg1YmUyNGY1\nZGE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEYvrfwjmPufbdHRjRvLQ27G8\nQkKZemV8tUqbsvhYFdlOQAZzBHO6qBDb9BQ5DiFWL+sGtQa4S+WyWTVvCPbOL6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSjz3Q3jradiSQbHXhTTK12eo1UCTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22DJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgbngBu1dJQXcPYFr3DF9krJE2\niK9sK6NiZuOc2xYKjsoCIApJF/LsLCoBcPQN5v2itl8lxktowrbvt9nCErzgsCQB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9402", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9402` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAQF5op0OKWYVkmQWCM31ZrewMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI0MWE3MmY3LTI0MDItNGU3My05NDJmLTQxOGE0ZWE4YTNhYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTg2ZDUzNWMtNjhh\nZS00YmIzLTg2MmItYmY0YjE5N2Y0MGQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE+2bXHMnRSA15wdUPDGVYWoP/h8sK99lL6ec72DwkvHUMUUFso8NAX/9Ceghr\nY7sMpXM9/Y4KG+nw+dgOMWWAIKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSscbzyEV0PeCWGxXW7NbOZpcND0zAfBgNVHSME\nGDAWgBQmON0xT7larK9kCzaRTNV6BsBLKTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEIWVw4vyHSt7mQsf4S2f6dLMFv0aegQ\nRJ++Ss34XZ7FAiAkMXJ+sc4HX3/pBIO/fci/PSYCsn5jxf7r7ZVcxptfug==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAfo3OAd6AhRlJLaCJ+MC5wSyMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNDFhNzJmNy0yNDAyLTRlNzMtOTQyZi00MThhNGVhOGEzYWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASXHEfe6Qdo8N19SUjfiey2O7P+PBOsc6bAuXIxIZrx+U7O\nriM7eL3at/ML0PE47V6JmgJx4PzjrgXgOQuNgryho2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJjjdMU+5WqyvZAs2kUzVegbA\nSykwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCQA626XuRd7ISh/TYEuhZeWRpXH/ejEn8VrukG+YuF0CIFnD6EDkEupB\n+INALKuBVU/1gaJTEeBlNlm78iH9uDjM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAaB4wyRzuT+/T6FHMOKYKaxsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTg2ZDUzNWMtNjhhZS00YmIzLTg2MmItYmY0YjE5N2Y0MGQ3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjkzMzNjN2EtYWQwMS00ZTdmLWE0YWEtMDI0MTczZWE1\nYmQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZ8RwrWmKX3KRdVMO9RkSROO0\nM9FRZpKidZJwe9DNX4PENEs25+4G3QEYr0po+BDwt2EZ8F4K169vASdqFb2HX6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSscbzyEV0PeCWGxXW7NbOZpcND0zBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22DJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgNT01u9Kr19Y66Gt/RVeZdQqS\nR80Xicw+YlFAH8KZa44CIQC3d5O30p79Doh90I4EHtDc0+M5ulPJlZ5CNSwiauUT\nJg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9403", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9403` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISARkixGPHrWfnYCzRFr3MHSTsMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDM1ODc4NDgxLWQwYzQtNGE3Ni05ZTBjLTBlNjAwOGNhNTU1NjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWE4MWYyZjQtMDE3\nMS00ZDQyLTgyZjQtNjllNzQxMjA5NDYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHW/qcNmS9hZIAB3d5z6+4AxYzxtkoRTyh2OdlC4lDVPwrRaoB5ORp5Jan6q2\nvwr1Z5RuYuC/7mNaOtOOfQVFiKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyVgCV+/eS0dM+wpj4lrDW9qC6hgwHwYDVR0j\nBBgwFoAUM/ivlfHZevxUSvDhPCmq4wN6yTswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCIz+DPyeSjixqJLPrFlzm3ZsuM\nvsA+1Q0Tz2i6EFERHAIhAPV6pSABLLSxlPM0B7XiuTDiKuIxYkwlWMq92tsfujOI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdO5pAvM6/S9VAbK6sq2IYDdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nNTg3ODQ4MS1kMGM0LTRhNzYtOWUwYy0wZTYwMDhjYTU1NTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARR48RVSt4UmaNwTw2jW+pvOxeQVoNnQBxUG14uafwan70c\n32pvE1axo1JYeV7L/Q80zS35HSc6SIpB7ljNAwM7o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUM/ivlfHZevxUSvDhPCmq4wN6\nyTswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFo3d1IB0FdY4cbMvD3I+nq+gpKFHJ56UK6hvDds2u4ACIQD3FF+vsWmo\ndhahxb8nXWecdcZf2/xnR4jJjHPYz1nP2w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAQPdAsOn68Xwnp9KZDWPppYfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWE4MWYyZjQtMDE3MS00ZDQyLTgyZjQtNjllNzQxMjA5NDYzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjE1ZmEzMjctMzY2ZC00NWVlLTk2NjQtZjRiZGE4M2Mw\nZGY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmumKrQPVInrbSQNZBsBzm639\nnitJBMFVQRKy01F+wN32nvr3J5oK09Zn7cWzan4XFVHefdLstlIuHd319y7qVaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTJWAJX795LR0z7CmPiWsNb2oLqGDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22EJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgdPcF3fRHUX7bXUZEgJTKPBRv\nRsfT9pxq/lgarNPuwb0CIEPVnzMvRZHp/DmJVymJfvaqnJVb16PhBJyKjmE5d7b8\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9404", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9404` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAaUgeuhF5vdRjEQ6wHiOmVXSMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlmNzdlYTU0LTcxZTMtNGEwZi04ZjY5LTVmMjk0NDNmNjkyYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWM2NjM3NGMtOThl\nOC00YzFhLThjMTAtZDEyMTljN2M4ZmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9dbuxGgaYpc46Y4JuGiFbgkbHTXAmGlaO5ZzVPG7kV20MKDA0WAh4GGg34HB\nHJbFjCNWbDEYzEmg3domv37btaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ34yA1GLOzVEfxNgwO9kC58eWB+DAfBgNVHSME\nGDAWgBRqYeT859xzqZ5zQEHoYg4O64P4YTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDbzy7Uk+I7VdnQGki8PozW9eRrMW5t\nlcUsALBcAoRRkwIgBtNK5XLVK+Ysclq1u1Kxd/p8aNHgdIQTP75+okJT41Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaDq06YfI761O1rKRi7dkfK6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZjc3ZWE1NC03MWUzLTRhMGYtOGY2OS01ZjI5NDQzZjY5MmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQvcU3AJBcCWBYBFtIvbN01GHUrzuMUTkOu+jNuDSJIGndG\n6B7bxZC5GCN/K3bs8FAxP+QZALznXFh5B5iNDXPEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUamHk/Ofcc6mec0BB6GIODuuD\n+GEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIQPIRymwQcs9flKjaoUrKDzKq+E+JVaxmBVjIoNOpmcCIEDiGIUZt2KJ\n1l+jHejC7tzHbOiUWtABPUs5/HMgj1Ec\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAZuNhuzGTbROe+dyGUrsFKdRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWM2NjM3NGMtOThlOC00YzFhLThjMTAtZDEyMTljN2M4ZmQwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzhjYWY2YTAtNWExMS00ZWYxLWFmNjItNWJkMGUwNzRl\nNjA5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBb8M16zx0Q6h7Hy4FP2bfyh1\nbmUVWjs8xhDavfAKUXfOADU7QaRnPI2TDHLcZBxlRgle8DbCrx9zgKCliRnrvaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ34yA1GLOzVEfxNgwO9kC58eWB+DBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22EJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMFrh8WZLc2EvijTtE4WTwBo\nDAz71+v0JYSbu/InjpEcAiEAr6Pec68gc/0xStnA/NmuSQZtzPYdmlFOhmnwbzEs\nwRE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9405", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9405` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQIYtycEh5ygkWNeZhL7xEepMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2ZGVmMjRhLTRkYjktNGM1My04MWQ3LWRlYzEwMDcyMGFiMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTE1YzkxZjYtOWY1\nYi00ZDJmLTkzOTgtYTkyZGUzMmQzN2Y4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELypw5ggYM5pSCerCSbievHkQ8Z3UeiNIlT1MquffBVTUezmM8wSWdRH1jlzP\nh6vuYygekBpiundEQ6pOzOuDkaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUW+PNhZGsVB0hGIcyynroF7Q3W8UwHwYDVR0j\nBBgwFoAUSQsXdGOHdMuczinp36mELxH5hKEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQD/VvXo5nv9THQcNF0cIkpZQAlf\nq2l/nQJjeTSF/jEjKAIhAKTLKkoj/ebw/wug3rwfoYzAI7MtOZsm0gJVRuSN6NRi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISASQENXmT6LfKWYE4RcKV3I+7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmRlZjI0YS00ZGI5LTRjNTMtODFkNy1kZWMxMDA3MjBhYjEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATApVgBjhEurnj2RM14bRiI/eGMaEetMW2yHQDeusutin1X\nZpeZcyRrwX7+7Y0olMwg9uSorcRSNqftYG8aD/EBo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSQsXdGOHdMuczinp36mELxH5\nhKEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUDfMdZrZ92st9zTNvCD2t+dePMGhzktpwsQu934UmMECIDft2TnMTiAf\nMFk/kBj4pMhSc0MyitiyVPT1tAiax2tY\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAY1fkQ0/EKBwp08cQLdARVuJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTE1YzkxZjYtOWY1Yi00ZDJmLTkzOTgtYTkyZGUzMmQzN2Y4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzkyOGM0ODQtOWE4Mi00NmExLWFkNzItMGQzNjM2MzVi\nYTNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+yR4IyB+2a+CP5fd2PLJSOoa\ncHGvAS0otoZDk47dIbFmdsH8J3Jy0InxT1GdmiwoBAELLN3VvJwixyhXU5wuhKOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRb482FkaxUHSEYhzLKeugXtDdbxTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22FJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgFFWYVypsi3IZRG5Q5l9ooR7D\ntbmJHWN61z+TFKPpw30CIQCfyEx/FnsOZ1Zt9JFFfquDIHUYAws7cbVSDF5c0B5J\nPQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9406", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9406` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAaHCbrFilmOlUo74htqj+i47MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRkMTRkYmY3LTE3MjgtNGRhZi04ZGUzLWIyN2UyZmFiNzE5NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjY5NWM5MjAtZGFm\nNi00ZTkwLWIwMjUtMzA1NTA4ZGJiNDY0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEH87mleu3CJ+dHmzWjLd7ISwbJhW//Eq4bqJZkpft/zwc83osMBbQpobKooqT\nbh+BmFTE1xztcGYNGkczSHY7VaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTOXlZBsDWnIQDL+NMEy5ajfyz8lTAfBgNVHSME\nGDAWgBTT+60FuBRSN2gi5YwYfqpGvkdy2jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIER53/83uaRHSzrEEETbfBdZmkNM6M2V\nzj18GRy4egcRAiA7kfXGfs2/Vlgrv1/I4EMJwhGkQlwgyCGinhvSCoQAiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVULzJQHfgOcmldd8Y+eJ31wMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZDE0ZGJmNy0xNzI4LTRkYWYtOGRlMy1iMjdlMmZhYjcxOTUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARrlIMlr88skkqUPosA1ntBnEW54kx0Mgs5VGBoPFmxO27e\ng9817I+cTuf4vOLFQ9uAaSlevB/KvMyB4no/EykLo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0/utBbgUUjdoIuWMGH6qRr5H\nctowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgCEKOmOHXkGkbzlLlrYVVi5c2Xn4HaesQxu1Bjo7U9TMCIQCbX6GSEbmA\nIMsyHdoC7HQx+5zfg7+zuOa6YQu8hWrQvQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISATsHi/GEGLiQ9/y6iUpkNLYNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjY5NWM5MjAtZGFmNi00ZTkwLWIwMjUtMzA1NTA4ZGJiNDY0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWRjOTQ2YzAtOGZkNS00YzBlLTg2NzYtYWE3Mzk3ZTdi\nNTg5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENtqv4dnh7/UsagCCDEXSSKDM\nO+u4aOJv3odRIY37+PbWlEMk1AwsPC7F3rSXVV68kdfVM0GDaDRvEClqmyKMuqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTOXlZBsDWnIQDL+NMEy5ajfyz8lTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22FJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgDdePeZYauFE+OSh7sxsE1SZJ\nGhxnY+EZ9YHMte9SMcUCIFEXr4GPhy+a2fvB3ci39bPLnltpv3bFvSuRzdXCc450\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9407", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9407` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAZSitU9ims8zMtkVtzhTwOzcMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlYTJlNjQ2LTU3YjItNGQ0YS05OTgyLWRmOTIzNzdmZDE3YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzJkODI2NjUtZDlh\nNC00NDc5LTkwNGEtODY3ODJjNGY4MTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEh10+WLfWcPc/qicHincaiUdegaYQ7ovjBPYE07IStf2OwrQes2kYsVf2fm14\nawnkNnhaGrpD7ZtQa8a7gk0U/aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQURawk+FqhSbpRF7ACF7kz/KPbyrEwHwYDVR0j\nBBgwFoAU4Z9jSQj/J+QXf5Jwjolg9zAZfYkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDNiyiVVH3tWhuj+vwAs7XbcNaN\nd48vo4QzWPRjQZv2mgIhAOPnJ9fcBQcaMI6pNGLnPLOaYEScm5WIFvHRX4TYcm3S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdlUwdtWKig4me6ztPWiSIc9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZWEyZTY0Ni01N2IyLTRkNGEtOTk4Mi1kZjkyMzc3ZmQxN2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATT7nXbfiShOwVzodSvNHNaZTFQg7ZtrvCckZB8NH5tvBoF\nMPYMx/HsqxauB4zz43tFCObWjqd4PV6FJ4Of4s7/o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Z9jSQj/J+QXf5Jwjolg9zAZ\nfYkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJYlrxeDCSeIVjnFSsyLIgQ3zaETOFTniwALHntE3DS+AiEAvL5dgz1m\nPkcoBMbE/hYLug4o+bZ5ZXHVPTknY6ZeCr0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAXk0H8A8crDJbEeUlX0KoJp+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzJkODI2NjUtZDlhNC00NDc5LTkwNGEtODY3ODJjNGY4MTJkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGIxMTUxMjAtNGU1ZC00YzMyLTk5NmItZTk1YTdhMWQy\nNjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5StTOo9QsMzc2m5xoc1TsHDA\nIOHmdQgd/opGB3gt3CDxibmBbRF20q4J1VBxetzcWJdUK1/OTyV9dS/PInKJtqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRFrCT4WqFJulEXsAIXuTP8o9vKsTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22GJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgJik6qQ2l0SbwRtejTNbupO1a\neYfU+a1ICuMPgnX34+cCIB9UCGId0TFNUNZ91UUkrbbmu4HWQ635oDI0e18gtW5A\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9408", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9408` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAaoLV1UMvM7Y8MZHqi6vuNdwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ1MWQ0ZjI5LWRhZGMtNDhkMi1iY2JmLTExNjZiZmNlNTc5ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGI2YjNmOWEtNjhl\nMi00YmNhLWI4OTctZGNhMTFjNjllODViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAENU3O0XZHmlmeqabhnyCXO6N53GMtQGP/UHCDkrpNNxX37Llvs8+Bv7H9TasQ\nzAyOkUaPKGk9/RLCbVmwZ3oKT6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTWCLik9KDEDURz2U2QZQ/9uDgbyjAfBgNVHSME\nGDAWgBRDVO0WXZkBbvGclAaBCJxnF6KG6DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQD9s/FyvIiElHPWswRN1N8wp2tBvZ7j\n0UoPGWn2UeQZ/wIhALvwadhJUSWEpkRrFFrIKv4NGPlIfWJzgRMLprgb9aqK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISARwGpq/oEAMR+uYAQhuV7vuRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nNTFkNGYyOS1kYWRjLTQ4ZDItYmNiZi0xMTY2YmZjZTU3OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASZx7dQjJwTPHVPTY5BUO/sd8aGQeiq1BZkWQO7g1XIDW4N\nEZvMOmBjMvQ0+ytWtVKDaeyz7HwVD89XANuGhHZAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ1TtFl2ZAW7xnJQGgQicZxei\nhugwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgFmg0CFEAfAsXp3rvJOsFIL3V2mr/3PY6IcKNUxEtV2cCIGHH1QOWoJ2G\ncmD2bV8ZsBUGuifH/XAs7srXs1Fd5+5V\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISAQCsrBOoUliwigXlkbRkj6eNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGI2YjNmOWEtNjhlMi00YmNhLWI4OTctZGNhMTFjNjllODViMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjIyOGU0NGMtYzkzMy00OWE4LThkZmUtMjdkMzY5NGZl\nYTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZP51PfUgUtJIbth+P3a7bpK6\n98tkaornHy+EOgVhEAlOFRzHq4WPSMdK7FJvEuu85B2qgiDso/8f8ycBqObH/KOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTWCLik9KDEDURz2U2QZQ/9uDgbyjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22GJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANRkEswApEr/YoZSdhekMb6R\nzmlBxxKShz+pGWf5CIF1AiEA+VrGEyLNdtoVshwVi9hZbQgjzaJiP595iKWy4IZs\nE6w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9409", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9409` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISATJuiSzif4M5tycwYn2zAVpUMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NDhhYWYxLTQyMDItNDYyMC1hMWIwLWIyNmFmMDFhNWM0MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjllNmIwNjYtZTgz\nYS00YmQ0LTk0YmYtMDg1NmRkNzZkMjEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESAJMA+fQgoPl4s0eujXSIMjRemA/oweB4CfnWU3MmVgQl9sbuZ+u4cUdtsiQ\n0yaPO55kAIYqiWdvcNMC+j2arKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTQ7Ldc/N3s1EqHB4GVcmCMlu6nAwHwYDVR0j\nBBgwFoAUNZTLtkOfACvSJ7hJrzEhIHLmjhgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIALL5gi0pisgsG7pZic4D/WatJUl\nklR41b4ou+9yllxLAiAcF6Rlv88EHWBuJhuoj+myunwevZX79fMqDCXkNQxnoQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAU9ZWLI6HsLLbQO8tby9b2XiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjQ4YWFmMS00MjAyLTQ2MjAtYTFiMC1iMjZhZjAxYTVjNDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQKg1UlYhfW5Rrao+FR662kq3492ODQkYpRU0OY1unaO3dc\nXghynzt3OYVuLRvhtyBbgDQC3E1exXGlYXjLNeXSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNZTLtkOfACvSJ7hJrzEhIHLm\njhgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgF9lHbNeZz7O4UkVEd3m3yB0Y9FCbzt8hE0EG2YBl3+wCIQCWp8oSGQpJ\nEAnfsLI9mv5dRF0zBJbuHsqdj7TDgbaFBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAVOwh5syjfhJ7DKFMj6gSGSuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjllNmIwNjYtZTgzYS00YmQ0LTk0YmYtMDg1NmRkNzZkMjEzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTJmZmNiOTktNjJmMC00ZDYwLWI5OTMtZWQ1ODZlY2Jk\nMzg3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYIPIx4246206MSggxsSmZdwh\nJcZP0Xg1yWM73WsQkC5eOBHJi+i0ISR9QZjLJa7nVKRYpS9r62HzZWuOT7TotqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRNDst1z83ezUSocHgZVyYIyW7qcDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22HJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIEHYNqRDiTHh+jMUVYIO4PC\ntv56cPodXutqISOFy6PFAiBL9FYBfii1fmF54hFrLYVK7tK37Z8ZmInP/toOOSoW\nbQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9410", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9410` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAfkhyIp5VdeElFY2blz8wXLMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk1YzU3MGJiLTA3NGEtNGIwMi04OWQwLTYwMzVjZjdmMjA2ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZTc3NmQwYjMtMWE3\nZC00YTRlLWJlZDYtYTFjZTVjZGFkZWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEbYVoEA4fiD6/+irYyiocIH/PXZS/i3HFGeAwyVa0YdtBr/wbH5b4lNmRwdrd\n9ORLeoyCLvKEZLPlKZjy17uwbaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQcYI+KNX7M1c9DpFJ/4OmdxoNajjAfBgNVHSME\nGDAWgBQd/3Ry/HuBU0fpzi9+C57uIamrTjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQChskiRtoWnD6s0d0Bl333j1AjcdW2I\nIFOHHwNeqksGUgIgcvfJ6R1b+t4h2q4JIYSTLXKSM/ncQFs1dVoF3ELFt6g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARzHpPq+K/IJA9ieLXxfOaVeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNWM1NzBiYi0wNzRhLTRiMDItODlkMC02MDM1Y2Y3ZjIwNmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQl8cxT/EImy0wIl1FFb+RC1lRBv1GNGyfvPG5MhytxNwlo\nbEDjUO8VCDToDwEhdbdTn1UKjKdxSt6O7ozCn59yo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHf90cvx7gVNH6c4vfgue7iGp\nq04wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALERdlEwRYtSqMvTOyAnS+jnQrntIo8yswUxViZ5pPRfAiEAhHdUpfec\nZVPtE3fvnoY2KCg52Wr6KsOJU29uhMkdGqI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAQWp+LP8c5NpMTyXISvWND8XMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZTc3NmQwYjMtMWE3ZC00YTRlLWJlZDYtYTFjZTVjZGFkZWNkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmY3M2EwNmYtNGY1ZS00ZGE5LTkzMDUtMzU5OGRjZGEy\nNTc4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEd91K/4YE5TXY3s7FHyLNfviR\nFrJePq01D5Ihe0XTqoWGCUEmuHp/MvpDmJMG1l0ViVDS66OoE/3FyN3z0NE14qOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQcYI+KNX7M1c9DpFJ/4OmdxoNajjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22HJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALRSOCS2/b6THnSofshq4lnT\nS3LdxacPaC+A+jCDmpN/AiBRCoLVKdFcvlS/wpK5dP0A39o6Xm83svtudPMfcHkp\nYg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9411", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9411` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISATtv6MKmeSrFvMVR7psR3pANMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiMjNkMDcxLTk4M2MtNGE3Ni1iZWQxLTUwODQ0ZWEyNTg0ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTkyMmM1M2EtNmI0\nMi00Y2Y0LTgwZDQtMGE5ZGViZWU3ODViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0CF0CTS6aV82C2C6nETsQBYS0t9RpVSkSyoB5VcNSXUgBGAXCXcehWGoC5Sl\nZPkZpwIM5yztT8wuVgM6CQkww6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUg4aj2VIGNKa1KbmOokR2YLcXBIcwHwYDVR0j\nBBgwFoAUlfhOa5nIFtf9xAltLlFGhLTF1qQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIEq1VzBiX14KftA5FDb2iapX/MDI\nwRkKm0tjMw8X2OeAAiEAg/5Dwms4+j4BrJGCDJ8kyq4OxwG+thdQGBr51ZHjoSE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAazrLRn33m64F6H97VDDlr9QMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYjIzZDA3MS05ODNjLTRhNzYtYmVkMS01MDg0NGVhMjU4NDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARdatdHfEzRTH9XkTI/Qdz75xjQbcpHrn4RaR+8V8rsM5eK\nTK7gmd50y725GbPGv33qtdF/O+jVjTMTkGtDSIdGo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlfhOa5nIFtf9xAltLlFGhLTF\n1qQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgbYHHd1y1m0H/xUvofHtrAEudsXGKmlnvsptoBfTHrQICIQDqWSPeyQmS\nIb8rWudwvJgzxC5z578f2JdVOrouQMAC5Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAfdRKxTHQ2rGtiMHZxzI/xEXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTkyMmM1M2EtNmI0Mi00Y2Y0LTgwZDQtMGE5ZGViZWU3ODViMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTVhNWNkY2UtMzc1Yi00YjZkLWFiNzQtOWVmNTk5YTc0\nMWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExcFer0MTUIQJtIOVNOw2xGZh\nSFoUjlQEZGYylBPisURKwXgvppUC/1OT1zptG4hmlXL153AJh3Om6/9yUDCmS6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSDhqPZUgY0prUpuY6iRHZgtxcEhzBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22IJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIL+odRqSlIJX+JXxc9kzpzN\nHlTvhhuNZOQk7dHLWw6iAiAUlFWChlpXQd+REYPurLV8cCUGPO6+Pajrvyb2O+ee\nwQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9412", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9412` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAfmuzrPlxT1nQ9ruX0jLyfDYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZkNmEzOTU4LTU0ZDQtNDk0Ni04MmUzLTllMDNiMTVlNmY4ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDkwYmQ3ZjUtNzgz\nMC00MzRlLWE1ZDgtOTVhMDNhOTUyYjBkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEpeIduuh8uBiWhg7a2VMnggKIP3oN71pCK6h8nXntu9aSQcDT6weqM6ala8O5\nQmSiRM2L03jeKeuZciwOyyAtT6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSFjLg2TzQcXGnNXGswKBCNwNpatDAfBgNVHSME\nGDAWgBRzhS7oncas/LhvXCAySOqV245TVjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC/eDDtybgKCMP+i4toyBcJMPbtU2GM\n9yTAgPBIDLsAtgIgKIsGEGLoUMSS4v15bdD/qjF+mFUi8n63u8qZuWGLdvk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAeofiw9D53jWkmQJQxoAKLI6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZDZhMzk1OC01NGQ0LTQ5NDYtODJlMy05ZTAzYjE1ZTZmOGQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATIvtWLUH1g4JyYBbzjfVuIq7WVrZJO8YuoxZGcwIGtSN/j\n8ALLcQnTQsYzxuEui2to4qZDz/45OCZSGcGXR84Uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc4Uu6J3GrPy4b1wgMkjqlduO\nU1YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPrEDgWUGystZnQApRAkgA3v2Xw71CBmgT40IF+ynVgDAiEA8ai9I3bQ\nvLu1GFVzx190mwu/JWcB+NFvnDupUG/2yCo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISASRcDOOPB+GAqKp5Pt7SgA2zMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDkwYmQ3ZjUtNzgzMC00MzRlLWE1ZDgtOTVhMDNhOTUyYjBkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTEwZmI3N2MtMWEzYy00YTE4LTk0YzEtOTM4NDRkNWVi\nNjhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1IA0EmEVP4bc/XP54YpkKfAA\nJGjkb8hk2OJ5NOvhAxTfxR4xrbFZ3haDtZiCimQNUvDE0H4yunH6jj4oLeYGzqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSFjLg2TzQcXGnNXGswKBCNwNpatDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22IJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKniwzvH1GXx/GNgOljFvF2h\nmpAaIGlfvbiBbmYaaUzXAiAw7VoLUwpQH0eCDEQm6Q+UY7OIujhxDBXG+AN6v0Cw\nZA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9413", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9413` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAbMoV1WBux0EXjS49I6zjp1CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRmMTdlZTdmLWE2OWYtNGZmNi05NWY2LTlmODlhZWQxNzBlYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDI2MGE4YTgtNTY1\nYi00N2E1LTk0MWItMGY4YmZiYWYyY2Y5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfJ0uCkRm4+EyWfX4S0TW4nOpH/Nxt1KHVxsGlem5P6ms0nj6HzgEEejKpv5z\nP+jo1yo6JeZisQkTpVR4T16m9qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUooOcz6h2gKPLkRiEYCo7bs8vT34wHwYDVR0j\nBBgwFoAUh/r4MjSRZefh4NHuF5auh1H2ZFQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCo0uYPxU5XeEPKMlBaYfzG4CQn\nO5wwB+3RPp+4rTc38wIgaToSTNhgF6wKRmDdNz5KgDOV6qVgYJl7N2OKy01zFK0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAc8z8n9YAvrotaVf22cq6aU9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nZjE3ZWU3Zi1hNjlmLTRmZjYtOTVmNi05Zjg5YWVkMTcwZWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0MKO63AkYhrY9jz5TJkbk9gYA1s9SPiQDzC8uR5Qw1aex\nuo54LGq/kOyNhy0rEpRa+FRi3n1NlCUMz/4OZTa0o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUh/r4MjSRZefh4NHuF5auh1H2\nZFQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgECstAZ/+nQ+19CTvw+EGIGnMI5A2PadyyaNNq6R4dwoCIQDpO8eLXWHB\nMtl7odgGEs4P9zmi7wiQkZl+8dhuFR62MA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAaCh/s6TWEC7jUqvuNqODPXKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDI2MGE4YTgtNTY1Yi00N2E1LTk0MWItMGY4YmZiYWYyY2Y5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTlhYzczODgtMzk4Ny00YmE4LTlkYzctMmY2ZTZkYTQy\nZWM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEMk5KRQgrQtWy7Wgz5k0XO+zU\ndHxEYRFXLrwuE46HZbbYiSwtN99iUe21XQLyQDHHRIZbcuGeCQ1t5W28bLvdG6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSig5zPqHaAo8uRGIRgKjtuzy9PfjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22JJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAPAdMDiYtfKQG+TBqndjuaJJ\nb0XicYHPp0hKj7MfH8OuAiA6OhbbyTewoDKfPgeua+/z6m2izOPO9B56RBEfrU80\nRw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9414", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9414` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAZlRRrZtGwFXUgTaY7GA1lvKMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY5MjcxMTljLWJhYjMtNDVlYy05YmEzLTI0NmMzMTM0OTM4NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjRkYzViOTItNDI3\nMi00MzVmLWE5M2ItOWZiNDFlMjg1MGM4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAETPsc588Q9hIzmXU/QhvdsgDNkoHBByLbEVLbEQLNuhF0tbZ9BVm8aia0cgOi\nDWMcMwpV1/iElgTybU1LrnacoKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRCZFS+v9SS084fx7D0IK6Pac658zAfBgNVHSME\nGDAWgBTGjoOVv9NZKl3Nd2B+VN2azJUfzjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIEo633N/pwEyKpxPKN8ceJDcA1nQ+8pk\n4LBs/6kVnoptAiBmOX+EkirgeXf+Ya/3AlvGkqMlpamkwTOmiME4SczwxQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATrw+JYo6WbrEkVHGYyw2thIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nOTI3MTE5Yy1iYWIzLTQ1ZWMtOWJhMy0yNDZjMzEzNDkzODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR0l3scDjIgBbjYD4vMuCdCnvoqf1jM0lP/ioQc17agRRFg\nEmI0CivH9ovARmwGTkofjY17AY72OQaVTLrfyTTro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxo6Dlb/TWSpdzXdgflTdmsyV\nH84wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgNm4Ku3mSoqWiDUcPDq8gsQefOROVWahczi3czfiwoq0CIHlZFuzPqH0s\n4PLPu64IsqlJ1ciw0KEHPGtCw11MxsGF\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAYFGNfW96j8NQ9c2xUiODpigMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjRkYzViOTItNDI3Mi00MzVmLWE5M2ItOWZiNDFlMjg1MGM4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDAwNjRkNmQtNzAxOC00ODU5LWIwYzItMGM2ZTc4NzVj\nMzBhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1+no2tBfN6RgH71upSgv9/uB\nZpmQLLCCwPPMr07/2rckT85v/nz1Qy0SzbRIbw57PghoLc7Qt6qbHXz9xtR7eaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRCZFS+v9SS084fx7D0IK6Pac658zBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22JJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgbl/ZLh1Yg4oBJcarxt1DwEDF\nlid40CBelGFF5J2NSogCIAMEbI31E/2bEOkwsShDzErUKr0y526fReeuqXr9XWD+\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9415", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9415` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAcMwHn4zrt/tay9DOp+SoVjqMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDBiN2IwZDAwLTE4ODQtNDgwNy1iYzAzLWU0YmNlNmUxNDBmYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNWQxMDFjZTktOTRh\nYi00NGVhLThkNjgtMTM5ZDY5ZTIzZTY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9fIpj4OMf4pcPFfNcpPGps4sIJqwT2eBSa+ejq1ufGas3tzeKt+KeZsWaYs6\nn9+9pXX/5DKvihC09vmx2/aQx6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoLBiL1LrdH7MMesDL1fu77YgfPowHwYDVR0j\nBBgwFoAU4J/8uwRIRe63gzhoXlC6JfH2jNswHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCtF0zrDFpmRRxEwWCWKWzHTaL9\nAc/xMjVRrzVSDM1fSgIhAODvjA6RlMrq0YDY4cWwuxQfiYzKfrDFgfXmGHjEEQx0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAdyPqDeUnUJbxianw40RQ3nFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nYjdiMGQwMC0xODg0LTQ4MDctYmMwMy1lNGJjZTZlMTQwZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARh9o7pAJ0NH4OYyUInyhHrv5WUroIZxSjlcUiEqNVJbIfW\nha3j9pBF1YjhycmE9yfJHRU6CfiTUo2Kgc7mBsbco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4J/8uwRIRe63gzhoXlC6JfH2\njNswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgS13+JEGzkDd0kAG0iZYIB82mzc/KpQsOkdXnIAgw9ukCIAUET1eM81gS\n0oLQpuVO96i1mgVnH4KF3sOikJq1qwp5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAWphOw8yQpC8dwJnrZYctTEDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNWQxMDFjZTktOTRhYi00NGVhLThkNjgtMTM5ZDY5ZTIzZTY2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGQyNzY2YmEtZTEzNi00NTg0LTg1ZDAtY2FjOTNjZjgz\nNmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn15hpq9FeRouFuAhOA5ls98y\nnG00PTFZZ37m+eOJL+phbcYNe7470c8INcF7bfCA32sE1AYJz3P88ZwuGU9oNqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSgsGIvUut0fswx6wMvV+7vtiB8+jBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22KJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKdi2GpYkGNysyYDJxyTR5Ie\nKmTYwweiXBNzgalApLI9AiA/l06X2X99btGvltwyq1JofOJO2eS/LNjNjwxWVUZV\nhw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9416", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9416` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAQ9DYqxkKKugoLgVf0hZrvX/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM3YjQwYWY5LTgwZDYtNGQwNy1iYTcwLWU0NDhmNGUwYTc5ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODU3ZjRmNTItYmFk\nNS00ZjQ3LTlkNzQtOTZlNmM0ZWRjYjdlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE6r0ZI8HKz8ImgXGOpjcHcu/0llxcVR6lplCVEqF8NVyLzuLyUZx1DqRTBg0d\nj6mYQEwdkq1rVQwWOV9IZHlybKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT8Kn8o0OwPo1o+iO4nCxYvGJWsRjAfBgNVHSME\nGDAWgBT0mxtDx0xaJNCWFOO1/I5n0Q7Q4DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDzQhM57Aaykm1MolZo8LmKk6akza4l6\nA6Au/a1dCr0VAiA4Gd9Po/MrInaYMxcE/FWVWWkBMY8eagZN7uPflsiwZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAQTT8VKyZeuoTvmq+dkFyI6nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nN2I0MGFmOS04MGQ2LTRkMDctYmE3MC1lNDQ4ZjRlMGE3OWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQgoVjdIutLyi9qXk2Wmm2dmrGAOBCsyriPZtCOHl5kSI0I\nBSTv5wGM609cXd6VuNAimY/9wn6GPgikJ2RbK/Zio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9JsbQ8dMWiTQlhTjtfyOZ9EO\n0OAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANDzpUoLpEyrObDnvxrwRn5BP0SLaDvEQUFQM373K98XAiAbjEcIVsAS\nrCACp62lJMl4c7126XLrviyLWlTEZMKiHw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAS5hAEOwbnXAEvXuTEkX+1mGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODU3ZjRmNTItYmFkNS00ZjQ3LTlkNzQtOTZlNmM0ZWRjYjdlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmFkOWZiYWItNjU1Ni00NGY5LTgwN2MtZTdiZmNiNzc2\nNTc0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIRpXDIWXNoC5kxkPbOblVw2q\n9HqHsjnwWNOwWjYr5gauajE9CNOqmPewW6q//m/EE2uLSfGfgDFb6VwjVuFG46OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT8Kn8o0OwPo1o+iO4nCxYvGJWsRjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22KJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANExGqMyA7a+CUS0T5tVbC8z\n92RT+N4c6LyPO0uEf6+yAiA+ZHiAviEkQtPaLQfxoqi4V/EEpGcM06BL2XYqZOVm\n7Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9417", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9417` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAaY8HaYLatEcpekq04OvQgw6MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDFmMThhZmM0LWI1OWEtNDUyNS05NDk2LWYwNDQ0MDE5ZTQ0MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWE4NGFmNmMtYWQ2\nNC00YzliLTk5OTItMGEyY2VkNTQwYzVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhONnhYfMkwR07tb1TjAnC1Mr0T/YdjtGQWa2JYSMoTDdxtnNpWonXlRsKdmz\n67NQeqgeAbOPr62WJd/QU2pAJKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq8ZokfIvwcpNq97iSiI1antYQ2EwHwYDVR0j\nBBgwFoAU6QGEq0mX01gk9fNeDRFncYNgDFUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFLtcGYLEpCPuqWvX4wnD3jp9RaJ\neeIICZrXq0Kzo4mTAiEA9dQf/aVbKKPaUOuJTE2XrR8UdaM1D0oP2DNcx34jaJY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAf0K1Cc7P+iHMxuysTo/X1fhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nZjE4YWZjNC1iNTlhLTQ1MjUtOTQ5Ni1mMDQ0NDAxOWU0NDMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARoEGVR3UFDi0ls3Iijysna/10FgV2PM4hFYSE8yHa1pS3K\nB+u+opB3Z2WLRVpDGq7vMWNsyrWDGRcCfkX0cLRco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6QGEq0mX01gk9fNeDRFncYNg\nDFUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgd/aBulS5j76vdDaArzXoMW4x60QZHKQdbo1K4KOBFUMCIB8V0spZ0AL2\nEAXyDuwWj2G8gOku+lYYEaes0vvA3GOW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAfUhPL3ZqetJJ+hVbv2bTxvcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWE4NGFmNmMtYWQ2NC00YzliLTk5OTItMGEyY2VkNTQwYzVlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2NiZGQ5NTAtZjk1Ni00YTQzLWFlNDEtMWQyMTQ2ZDI1\nZWMyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDZh+EDw46vvb0XBc//u6MsJe\nK96advDEpPRcY2SUa8uI9FXe+mUhqy9IukU+qJVg+WwZecoLTtTFRRL/7b2DOqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSrxmiR8i/Byk2r3uJKIjVqe1hDYTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22LJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAN0HKOksRxrO6XjpKjR9zdXM\nxJ96zpOfyxU2Jg5dSV7vAiBU3/JSFVJubsx9TN1qkzl9j1BUfauScc5uB+mYLDAp\naQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9418", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9418` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAX+KC87pkfAjNob13ZBSfmmbMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIyZjJlNGMxLWI5MDctNDY4MC1iMGM1LWI1MmUzZGI4NzJjMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGI5MjUwZjktOTQ0\nZi00OTcwLWE4MDgtYTllYTM0NzllODVhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEExE0Rrhm/KHoYB6ldCD/v+P5Jbr4qS7elJC76ocBzGceF0rk6J/qqGgtkAq/\nKv3vvtzABJl1mU2ZnUDgLvlc9qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTmZxT7flT6dfOWNwlUixHsIXt6MTAfBgNVHSME\nGDAWgBRar8VOqcf1de/MVzhoLLUAhhHMIDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAxNgAPAip1znXrgB1D9X0vabPB60QGh\nQf17xjodXefwAiEAuXg710kcHmgeipXeiirVRfE2JH+m5Qu2nPhRNF4/kDw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAV/+cQNf4GbtFpMyn5Vp/gWRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMmYyZTRjMS1iOTA3LTQ2ODAtYjBjNS1iNTJlM2RiODcyYzIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQlfBVFXSWsyQCLjj6Su7tVOH7CcouR//bwgVzlQ+SSrmnM\npT9BLdfVAHmBLI9qfTAyQhp64ukQLkwuuMK4A/l5o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWq/FTqnH9XXvzFc4aCy1AIYR\nzCAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhALXPfyqjNhT4zqV/2lxlXUa//5JaJCrJo11w/A5JtM9QAiA7lx7y+ENA\n33gWoZUOO8yd4kPvwYuRjOtX3MzpVYhH+w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeOgAwIBAgISAef+cvh++17NQ/RM0mUdOL35MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGI5MjUwZjktOTQ0Zi00OTcwLWE4MDgtYTllYTM0NzllODVhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOGIxNGRmZjItYzZmMS00OGIyLTg4ZTUtMTA1NDc4YTAx\nMmFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEt7gJdhTUL5TX/dKVTaHtBdf7\nILzSp3iZE0+8BXV6N9qZXbHJXVrrApUYCN3JeAJSJTkQJX+uhfpCjriBAq/gv6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTmZxT7flT6dfOWNwlUixHsIXt6MTBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22LJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRgAwQwIgQmM1zv9jT+lcDhYqBXHNVHx+\n0dhVL3T0ZzwavteqbsMCHxaZPKjPRbzJkrr0L9FbVkPqJP54zZCI3wTsYTK1Zck=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9419", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9419` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAU2HYASVuW7ckkz3xP3vmE7dMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGEzYWRkMDc5LTM3OTQtNGU3Yy1hNTEwLTM5NzVjYjJjZjEzODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWQ1MmZkMTMtNDEw\nOS00YWE4LTkyYjYtN2RjNTFjN2Q5YTEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE2QA8sFaZnEthid9HEmR2G0BGrzSHpEvVgXiC1uywCQNVD7MVMPD7aOZW62gt\nRCMfcUgytJ1NoiFdz7rJ+uxtFqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIDTtVBpz1S+ohGRUi4A3xK2QurYwHwYDVR0j\nBBgwFoAUJWmgJJuAabfZ0wp5u4/tud1d+9AwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEQWzCuk0FigE4GG/ZlQ+fMNHvSO\njuMG2CYQwDKX86r5AiAV7bjExWl33eVbG7702PENIHv4WcGlJ6+7pDuWQWx78A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASV3IJY21Vct0KJjae1AoAMIMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nM2FkZDA3OS0zNzk0LTRlN2MtYTUxMC0zOTc1Y2IyY2YxMzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATdXDL+8L/Xmbn9jGU7MRK9cObU0HFQ3R0iLYqHKyP8hqT1\n8GKqm13WpS+B36zoRVmEEbIu0Ds7t9HYYgpSaVCqo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJWmgJJuAabfZ0wp5u4/tud1d\n+9AwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDEvsJoAGT6iBUNxnk7RpguDSvGeiTrig5lfV7uOa35oCIQCiTzEo+UfF\n3CNBnfgFOxqh58BK3tw4N95WJXnYc0Szbg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAabR7XT8C85bG0BhOaEAXuKLMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWQ1MmZkMTMtNDEwOS00YWE4LTkyYjYtN2RjNTFjN2Q5YTEwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2I0MzBlNWItY2EyOS00MzgxLTgzOWUtMjZhOGZhYjM3\nNmE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE1pYab5dXwIKhf8JrOR4DBnj\nrimFpnAah3PCLyZt2J6GpTuLbOyzszF1+cXr5S9n0jimWmx/5mN8m0OXrreYmaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQgNO1UGnPVL6iEZFSLgDfErZC6tjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22MJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgfmXRFWE5lwsMDDpTtaBTQtK1\nUPyVMwCmFnfihGhfaR8CIQCnaQ06+YYwiBBW+tX3FSY3cPx5Ax7Jub+XgSjtgVS8\nzQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9420", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9420` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbPUXr6mkzCxPtvDZHWpU+a/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGMxZDgyZjkxLTEzNDAtNGRiNC05ZDlmLWYwMmRiNWU4YjNjMDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU4MDIxNGYtY2Y3\nOC00MzdlLWI2ZDUtMTQ3MzhlZmI4MGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfZBRd49yB4c0Y9QxsKZ3MQM75ux/jpy9cEelc9jF3KMcD0vuuumhhRzkaXjw\n6UOs0DX+x2T8/zzqYCgoy8H/WKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQxgXREDyoobcKVa/BM2fdgx3hBBjAfBgNVHSME\nGDAWgBSXkepKCM+DIGN/66joirUVPuMJfDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIFtTQyOdzFqJU9DeZCODVabIqaXWd8Ye\n2Hnuj7IUBCpnAiEA/G/j9Scrzfq9+W9fmVsFdohWBLaZWLl7R1DfCT6Rjxk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASVTIXKVzPcPLX3RY8E1xujtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nMWQ4MmY5MS0xMzQwLTRkYjQtOWQ5Zi1mMDJkYjVlOGIzYzAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnRlIp5GAeunXz87RE3iL1LHwuNnxqhyjGTQGk78y6Ruwo\nLVo95WqNtwRw62c9tXf7D+4uqtJgk3ZPXIjdxz3Ko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl5HqSgjPgyBjf+uo6Iq1FT7j\nCXwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAL2mFi2CxRR8K/CpsOzOs3k28NW9rj4ePM6yKK+ruOpLAiBASuooSnXL\nt19BMRTpvACMLALwtruMhF22LbyN6c/WPg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAWcs9z8XqlIsy4vAmWnQfe89MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU4MDIxNGYtY2Y3OC00MzdlLWI2ZDUtMTQ3MzhlZmI4MGFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWVhMjFlMmEtM2VhOC00YzFmLWE3N2EtNDJkMTAyY2Mw\nOTc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAd4MWPJkmORpnR8RQBplt1E7\nMxaD4Ul+nMfg/8wVBpWvalxect3ZZauewExFYasFYfQkS/nU+O1UJIjdyB1yBqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQxgXREDyoobcKVa/BM2fdgx3hBBjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22MJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKCYVgv6JEIaew7anpaB00ZD\npuOCuNFZCwcjPLUNscAYAiBH9WJz0mPlgCLVlP5oeKDEgFuF/hpJt7wrtxa6/wQU\niA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9421", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9421` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAcO6hzg3k3twYlKXneUUW/3CMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUwNWU2MjM4LWMwZjEtNDBhYi05MGI5LTBmZWYyOGM4YjA2ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmU5YmNhNGMtNGI2\nYi00MGFmLTk3MDktMjIwNTYwZjgxYTUyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEfCQhzl8LnnqHal6HP7fRBpzdqxYcHxSsk+TIR5UY20eYznp8c5Pg6hfuepiQ\ngPlD/khdudZImb67OooP+RPNsaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIfXEtZXpRY1MLdae/ukXvQ8w9IgwHwYDVR0j\nBBgwFoAUmjunc+/PwGKHeJhd77/DT7b8hJ8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCtyv4cNITFCbzX+o+uCYdsVtG7\nQZKq0mSVEsIxbXca8gIgadYuBnnGi/FZK25sSJc4AU30QcndPWA4Ye/Yj+g3Z0M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASIbIxsssDkQOODIHGGJRVj6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMDVlNjIzOC1jMGYxLTQwYWItOTBiOS0wZmVmMjhjOGIwNjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATodIq4hPHq2m7reZUC1akae3ByKjyxAWVERS1UpVQGSZvb\nJqKcfLFWgjNN4ywxb/mu3iPaqQI/cy1FfGtwzwSUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmjunc+/PwGKHeJhd77/DT7b8\nhJ8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgC2eDksVUCR7/RWf6fu53a2kRzXGIH1CYA1ep1Y19Xd0CIQDJuCfWCufs\npB3wU7XhgksruZ3kABkkI/GWq3HxjkQrow==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPDCCAeOgAwIBAgISAe90rwSb+CaeRorCt880ilw9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmU5YmNhNGMtNGI2Yi00MGFmLTk3MDktMjIwNTYwZjgxYTUyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzJjYTUxMzEtYWFiMS00ODA3LTgwOTYtZjg5NTZhODQy\nN2U1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkLJ2VVBbpPhFhGTIe2xa8I5u\nNn1mlmU1WK99BdOjl7E0qxNrpXUtDLjI6exOpRmVMCS+QqAdPsDH/z+03N2yRaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQh9cS1lelFjUwt1p7+6Re9DzD0iDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22NJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgeKL3t8Zp5d58x+rqNmHG8Weu\nK1y/sl6t9jRqfDZ9+2oCIHUThdriH2xpd2wZdFFFgT866GoR1pacIKalo60mK8qh\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9422", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9422` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAacn+FZto26qpI4O9Pf0ewVFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5ZWU2ZDY5LWNiMTEtNDQ0NS1hODQzLTFkM2RlZTE2NmZjZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDM4MzU2ZWMtMjA5\nNi00NjAwLThiYTQtMzkzNjI1NGE5NzkyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEX8rvfbzvj1ElOBCAFmq+YiUbJacJwktzfrYQU+HqfWK97eRTSjVA/GE4/eEO\nIryEo89iHUcoiQs5ah847Lp+v6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT1dR9Wd6zCxDPIHq6FV/wJIHTivjAfBgNVHSME\nGDAWgBRbE3eA8awgF0KWAptoIwWB6yd/zzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDNa9C67ioeBjJLY89sgkDx55PTDhyi\ns1/H/84dg+haCwIhAKHy9ZEyLtQo3n2gjQ3OKBYSGbK1Q35ie0BARBwg0PB9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAX3ilZab94uOuYoBOoAIqS8oMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOWVlNmQ2OS1jYjExLTQ0NDUtYTg0My0xZDNkZWUxNjZmY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR1R+zPaqUiVfurcrN/NYoFapb4k1imD/tS4+8geuVGnt46\nnhcS5Za5001pKO7AWzwmMfDbk18AFMZJD5IVLf4zo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWxN3gPGsIBdClgKbaCMFgesn\nf88wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgcSPt47u2rh18Cd0wq0JLjUhQTM/UFP4MzXlsEx4YnxcCIQD/tFvU/eXK\ndHl1T4d2OoUcKzcJFwfv7wczHHzhdDauFQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISASOR6VZh+L9/b4nLbFJ+AeCoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDM4MzU2ZWMtMjA5Ni00NjAwLThiYTQtMzkzNjI1NGE5NzkyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2JiOTU4NmUtM2RmNC00OGMzLTk2NTctNDgwNTAwNDRi\nOTVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4joI39gZjrmj6WrR3KAWsoe0\n7KYS+KQNMymE8d2f4RlULVyT1wQTnx2R5DTnImA3cTGYxAlq7t7FyQvHcoPNQqOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT1dR9Wd6zCxDPIHq6FV/wJIHTivjBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22NJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJoxfnU5ZVgkpIVawcSxwqO/\n7FByUkYtGyX6PRlrZru9AiB83M/IdD9wswy77hTPYvqyWob0ukS65A2R31IhkzA5\nWg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9423", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9423` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAbB/Cl8AMkFxfbs1zlKKiC6SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxZmRkMWViLTg4NzItNDg0NC05ZTA3LWM1YjVlMzJlOTJkYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODJkYjEzYjQtZDA2\nNy00Yzc2LWJmYTYtYTYyMGE1ZDMyMmQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEmDT791gx1u2tjLF544eWXAORxi3RDRcmgwzizPB0lP0zgrmS1a/OYySfp6A/\nt9Nw7/gdHFlcFT6f/9MbS1BH8qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkFDxd33vVShu6xNoLbR2YaWgK6QwHwYDVR0j\nBBgwFoAUnGu8/ggZ903AeJbkeQ27huDyvmMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIAr4g1MvwHqmDorjA3zP7qaFPM8V\nu7kCCDW7UjR/z/llAiB4Du5BgBdi9yPLrh8Qfx2iT1QKtuClfu04I9mAQ+HiqA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAWHXaQLELkSXM3d3pKxtOJbxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMWZkZDFlYi04ODcyLTQ4NDQtOWUwNy1jNWI1ZTMyZTkyZGIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASh3kyOC7P85QbXXq1TNxw8/7qF0vQDzK+Q+JUVyeYzJ92n\n1ZzAYHQSl5rnfjLKGecy5grUnDVsHBhr9Zx/i68Xo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnGu8/ggZ903AeJbkeQ27huDy\nvmMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgdrSE83NuIxCe6hxwE2j6LjluPZ2ROTyhTU5glLxNKCwCIFQdIu4W5Fpz\nElLqqnTNAtEahC+pN7ldeYNafI0RfJ/4\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPjCCAeOgAwIBAgISASTEx+sUUcRwbpmhbN0ihm7WMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODJkYjEzYjQtZDA2Ny00Yzc2LWJmYTYtYTYyMGE1ZDMyMmQ5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDNjMzM4ODctNjA2MS00Yzc4LWIyMTQtN2RkMzA1Zjdi\nNzIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7LUc6cF+Z5BTFn6F5Yb4Xx9R\n2HhEvOklrQ3IPKhmx1pWJ1GrK8XpR+LEw+ALI5hegN1uu33DrzPhYAkzPIFDV6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSQUPF3fe9VKG7rE2gttHZhpaArpDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22OJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZCbanGUffDjAHAsLHOcdnI\nDb6dA2QECSsrDzxVzoDAAiEAjjTmTsg1TLJREbybYVJfPfwqjs4F/qJbiC+ktmGH\ntC4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9424", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9424` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAUn43qph5E4PavSj+rUmurmLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1N2QzMTZlLTQ4YTMtNDk2NS1hZGVjLTA4ZDU3NGU5MGM0ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGUwNzNiZjAtMzlj\nMS00NTA4LWIzOTUtNjFkMTVhMzI5ZDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhvLsmE7HunC6I7ytfUeEK/lfgyarFezR5flu0j/vCbNJLU4TKHGMgUSwCF0x\ncc/O6f4GlD9iPrmWbTSxvTcVQqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTapyGk04JjrhoXKdhDOvj5gl1l1DAfBgNVHSME\nGDAWgBQuZragI2A+GZuBhVN8TdsCBi7S8jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGfJPi2ieMONoolXtu5pp5FOfcJ1XG3Q\nQCLMXljK/sQoAiA2ixGpX4PGrlKgyinWDGLV0UUnqJVCpzsYO4zSOtcikQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAe9R/lVK1qnf8gri5+wpTGqHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTdkMzE2ZS00OGEzLTQ5NjUtYWRlYy0wOGQ1NzRlOTBjNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATo0QLGLgxbXDAqDYx1Ixai4uvEz7gdJTZt9pCDiT2FKI3h\nWvJ10niwBPXkNE3mcgTmvTshNhX2YfdYyx0qlOOjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQULma2oCNgPhmbgYVTfE3bAgYu\n0vIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOxmeMFrTPPTPH61ybYkKuJWi7AmhAJ+/0dQTwIxyOzYAiEAhA695sDu\nmRpYJV1cXOHzEbKK/OT7WzkkL0wqvORftQg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAVsQRgIKg+ut/X0ezk+U+XUhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGUwNzNiZjAtMzljMS00NTA4LWIzOTUtNjFkMTVhMzI5ZDE2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDk2NDAyZTYtNGVlMS00YjYyLWJkNWEtMjNiZWI1NzZj\nNjE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXWHZzxsl1Q0syWbG9h+kBbXB\niBHxb3b4wYMJPhj3OjiYjw+qweXWLGm6jDVFV/KQAGCydE8WNdJc6L0EGrQoR6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTapyGk04JjrhoXKdhDOvj5gl1l1DBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22OJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgP3dCh1iA/o8dKuSEK4QoYa48\ntg8EdQ36gedLSclx+AoCIQCwZmsqNx6rYjq/F4ahBT2clRfND0za14hHqPElaQWd\nPA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9425", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9425` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAbInVCsXZclNd6UhFi+nQGy3MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRjYjNiOTVmLTBjYjQtNDU0YS1iMTc0LTAwMmM3ZDhiZjUxMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTk0MmVlZTgtOTdh\nNS00OGU5LTg2ZWYtMTg1NmNhNWYxMjFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEqCYqbzEMLu1n6s355uOHyud1MrGVN5xJ0upmMJ3WoiTTi2tcVYmVuybHpO5s\nZSKtN0yvuSKoO9DzyW5Z65PSe6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUtU6HSBx5ARx9WgHTnR9nQ/P1iswwHwYDVR0j\nBBgwFoAUTRQWWbjOD+bvjDlu/v7bBK50It8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCJnEf/IVQ9ewUzzTKeP4zsUADj\n7Dn96hDSlPiBgR4O7wIgLdok/nKFsl4iTY7ePf9eQlrB2fbrM8NbdYD3VWifCVA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAbhNZWERzXk6zFjeXamTo4vmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nY2IzYjk1Zi0wY2I0LTQ1NGEtYjE3NC0wMDJjN2Q4YmY1MTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR6JjcwMl0oa8Hoykuyq5uuA/2VXHMWBztI22156iKxzKtg\nqRmti9DsPJ0R2GVD9QerOL9GFiNIrF37qPQoCKqJo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTRQWWbjOD+bvjDlu/v7bBK50\nIt8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALdF4AFX8GdBAmTFAtQJs3tyt/lpgDxAIaEQtosSsbuQAiEAmZxBElwU\nWsR2TbA7emTPjp505KZLM0uryvHMBhnmNl4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISARcsT+Z2koQ2fykramUC79KTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTk0MmVlZTgtOTdhNS00OGU5LTg2ZWYtMTg1NmNhNWYxMjFjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTJlYTg5NGMtYTFhOS00MGM4LTljZGUtMTNjNzhiM2Zh\nNmNiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP071P7TOI7g+OySoqKX3CTQF\nsM7rBOB5cggrkrSv9Ev841RY7xzyzFzSHAeXBG4VCgBk5ghytC4vS1XcE1ZnB6OB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS1TodIHHkBHH1aAdOdH2dD8/WKzDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22PJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJLGpfNIo9KJFvfUB+BzpLNG\nAk6YuaFRXkOrjf/YpcIqAiApK5FPR3mQ6ggGiGnCasq6Pkrgm8NQIW/xBXxALum8\nag==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9426", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9426` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNjCCAd6gAwIBAgISAQy30Mj6iukXmkNIbdm4kQknMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAwZjViNmVkLTNiZDYtNDcwMy05YmQzLTMwMjM2ZDVmNDIwYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMDU4NzlhODUtZWQ4\nMC00NjE1LWIyYzAtODBjMjlhOTVjMGE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEvgDr9R5popvYJ89QhWQtjqNkK7fu4B3ZVk/wllLlDO7ZSPTVjur+3PyFka1w\nPLz9Z2BqpZWawEqSVyOONOIrnKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQxv2yCFjhf2/ApTZSdimN2al9lfDAfBgNVHSME\nGDAWgBQBqyFF6MXAJ0hoOZ62eoY9bZ4ssjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0YAMEMCIF+H4bXBL2RXKmHxWfyWVegxdzV0jbo6\nrtSq+bLa7KSbAh9n3obb40rKj1V1X0MtRRnjl8gX8VTEbJCIBvPIGAWm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISATp5sdLCwJGg9PYiHKZenLGXMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMGY1YjZlZC0zYmQ2LTQ3MDMtOWJkMy0zMDIzNmQ1ZjQyMGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATVy96FmjSDb4NleLF7RtKCkdsscJQmzyDKKrpokDwRwFg3\nGrTmDQvSJhmzBDNC3HmDEE2F/FJLpdZuyaGhqDhRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAashRejFwCdIaDmetnqGPW2e\nLLIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCG+97bT9B8mGLgFTY/LKhxRdNeuBZDGv2OWxizRi1bcCIF8UF9O6/Ma+\na4wNqsdxSGGG3ec5acaR17mUzXVCf2rq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICPTCCAeOgAwIBAgISAWAJCBSE/pwcmS9DqEqUm1olMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMDU4NzlhODUtZWQ4MC00NjE1LWIyYzAtODBjMjlhOTVjMGE5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTIyM2RlZTAtNmMwOS00NmYyLTgxMDEtNzAzNmFjOTVl\nN2U4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExV7GLa/FoRCcCYoc8UwMfaU4\nxvxgrc7Ol6C/ahVFwk4MplVDxmWvAkza9acDXiJE/Cjc9URW/nea8Gs4MrVOhaOB\nmjCBlzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQxv2yCFjhf2/ApTZSdimN2al9lfDBBBgNVHREE\nOjA4gg9iYWQuZXhhbXBsZS5jb22PJWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206dGVz\ndC5sb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgFU+N32ZrAbDTxvBnJhtiV8TR\nz0HizQZYb0szJb+/NXQCIQDkArHpRxuIp5XIIBoDjxTwAjG+YMDKHdTLy26+msDg\nHA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9427", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9427` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAe03Dx5X5Y04CAcp0HVkjODBMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDlkYTA2ZWUzLWY0NjgtNDQ2ZC04NGFjLTEzYWFiOTA1OWY5ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNGM4ZDMzM2YtMzg0\nZS00MGM0LTgyMGYtYjE1YTY0ZDhjNWRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQvLmw3jgOrGTfa7C7yCGATSyFMfAH9thAtrI+2e8gdnhaXU8LKztMGDRihxS\nC9IDXWG58/ktBXYRKmgs7ox3Z6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmnKUT7Jbwva6/6gEbphGLxxJStwwHwYDVR0j\nBBgwFoAUMSHRriY7GJOv8KtGDn7OLm4WxmMwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCaLjYD87KUCh0ZQASCrLW8izVf\nb7A01vztqBlvU+oKqAIgAJ+sQCB9xe2kaf9+0dqyfNYJXDd2tdETFwV0o3OZbYk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeJrjs6Zd1TenNJMg5wwgGxaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nZGEwNmVlMy1mNDY4LTQ0NmQtODRhYy0xM2FhYjkwNTlmOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQb5QABBXZXbfjXuBHyfiWPD8LmwDnrn7ALdmgBooEGk5Ib\nZRHzoofMLblWw5+hCkn0gMRcvr4179B2KlasWteDo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMSHRriY7GJOv8KtGDn7OLm4W\nxmMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgTKt6lJeye8WqDs7jRckQm185EW7OKvl14aj0cInYZuwCIQCpodw1LysA\nNGJsFivczks01zpizoHaQbO7BJ7s2wQVmg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAdJjJozyE14r4qfJNex2VyYzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNGM4ZDMzM2YtMzg0ZS00MGM0LTgyMGYtYjE1YTY0ZDhjNWRlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzI1YzQ5NjEtOThmMC00OWQ4LThhMzAtZDRkMjIwNmFm\nNmRkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpHr9P2KQKGoZ7OzesVxriXMW\nLBHyAS6te21MIveCW7T8Z9LoOSgS+4aCnDR8YKwfCmMFleu2D2m7pBhq22XY/KOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSacpRPslvC9rr/qARumEYvHElK3DA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22AImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgaX3TDE3NhEoRzlF0xcctfFUOBQbJ\n6565rdjIUVQcIn4CIQCOUFKsc+OT8UlQWZWXIgYCuzi219wLJhY8y/JGgdnEmg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9428", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9428` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYuQZE6xf7uleMsuxW3ZXZJoMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmYzMwMzNhLTgxNWItNGFkOC04ZGViLWViMDQ3ODk0NDY1YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODY0YzU2OGItZDRm\nZC00MzdiLTk3ZDktZmM2MDhmM2Y2NWIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEgegbch/FSwj8xnS7ABVw26mBy8DTIs4dmOv5ydnL6pJN4oFVRL6jbbCN8HEI\n37pcIXWnd5W+C9twLwAIHl9FA6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQbiwINtn/wyi3upCQIw7xi3wiodTAfBgNVHSME\nGDAWgBQggjMVpqlXzu8on8vRlwQa98BkVzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDdETMHnMIyzEc8WAaTbDuApwF1EAxr\nuKegGNCZReCITQIgHCN2vCkkulq/GMDKTtoBKqN5CPgqD1mm5jRHkpi69o0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZcK3z6N+8uYn+ihfenrONmQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmMzMDMzYS04MTViLTRhZDgtOGRlYi1lYjA0Nzg5NDQ2NWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQjdNyu4vN0mvjnp+Gy5k3IcKHCZHSPpsBbk/FB2uLH9VOY\n/1gAv519Ir4eA2yFTs/v34sZKs/nqUEUb5sbbLPSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUIIIzFaapV87vKJ/L0ZcEGvfA\nZFcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJyeE3Qihl29WXvaehuD+B8WVfjJD/LsxGDhGViLuOndAiBjPBDkTz/8\nMKYkFfjJtJ+WTQogmhBi9VHcCA4UOYeCcQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAe36odxk67EKEPt6jymTR+MNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODY0YzU2OGItZDRmZC00MzdiLTk3ZDktZmM2MDhmM2Y2NWIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTJhMDU0NDktMmI5MS00NGM5LTk1NjYtNTEzMmQ2MDFh\nNDcxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4BHRF0L8XspUqqIDiAFB8CvY\nXB19gjfJC0FOiUZ5MhM/hhrETpQDqxd0RmZM+BxsuVyJeK3by4P5uacSbtQCOqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQbiwINtn/wyi3upCQIw7xi3wiodTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22AImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgeMaV/euqelHTM7ZecbFVwiXIn8Pr\n0ImCcl11FUugSAkCIDZF0YB9a2mZBaRhWSSBArk4zGWbVSW+sWyCnXWcIiUY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9429", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9429` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAYadV6i6+xSWqbEDwEvHuvkNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDVhNjA1OGI2LTU2NDYtNDUwMC05YTM1LTVmZjA0MmM1MGUzYjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGQ4ZTZiYmYtNjgw\nOS00YjA1LWE5N2QtMzUwNzRiNTcwM2VjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE1nE3st1XXScgnsEeZZXLg2+c/n471IZ3usbRovon3RMcSM+wCakNcPOCK4Md\niBWZLV7Qn/e2jLVNkrolEUO6M6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6iEL9AokvDkcBsGsd1gJpTiQnTYwHwYDVR0j\nBBgwFoAUvMfgklEPbSk8YfkESKNbQbeNI0IwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHoxI4fJL4sPpTbyvDSF6GFWa4AS\ntj8oLJ/+0A3BgHhIAiAUCDRUtXsnCNOYsdj/7bsrjnoG3W8qlaU+Yx2VutItng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAUODJpvDU8mBCQMBNsNbqQKFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nYTYwNThiNi01NjQ2LTQ1MDAtOWEzNS01ZmYwNDJjNTBlM2IwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQFm9kS/PBpAiUMfLV8GxkbjUauqfSqEb5YrzO1ef79zI1d\nXIiop1z9nfwdmFak2t2hy82ch4Xnx8fO6kmNijUYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvMfgklEPbSk8YfkESKNbQbeN\nI0IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPx8QaPcaAi1F8fdaJa1IauXTAgxgoCmBPNMgg5hFDjbAiAV9b/rkrX2\nc08TlqER+JhvjBTZz9UcMWJyoyNErgERRw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAYkTkNwAqXnQuW9odmaFCHS8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGQ4ZTZiYmYtNjgwOS00YjA1LWE5N2QtMzUwNzRiNTcwM2VjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYmJlMTgyYzYtYzc5MC00YWZiLTg4NTQtOGNhYzZkMzMz\nMzM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEh8KDabdVWFXkLCz1An6/H+a1\nga4tsRATlustPkTSZYHpoRH0ijbUBfVOjgMYJZ+UvVsUlabPlyee9g9Pm9JEaaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTqIQv0CiS8ORwGwax3WAmlOJCdNjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22BImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhANWbc67xgsmka2A9uZUefpRBGuDA\nYlnI0Ti8HixAXrlQAiANFNvXENbkSM1FD0d2SQtiW9gZByPXM1bIPL1NpOIprQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9430", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9430` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAdOCIEbM4B59nE0lss/pTJjZMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2NzMxMjcyLTRhMjItNDcwYS1iMWI1LWZlNDQ1OGJlMGJjMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjUyZDkyNzgtMTQ3\nYi00OTBhLThlOTgtZjJhYTAzMjE1MjQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIBt59J935dTc92d9UEKskmWpghn1FxefKSf7RuZVCUPEoE1D1LhZcEDO+lVC\nBhdvT4Bbv1SZE9Zq5RZWkq3+96OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQJ2oeuzwvdbb0MS6V+qPajNogLRjAfBgNVHSME\nGDAWgBSiTT5AMu6IsXW/T2BTXwo7172QYjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBteTPHJYSw1nzhG4S2RKEEt+Iko02tu\nFAxgwXUMYkM/AiBl58r0+8Mr5s/RzHDfyo/Njzk/sUuDKF0ztY3Bnyvk5g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAdXzDjalY0G7aIbM9Rqy0HdcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNjczMTI3Mi00YTIyLTQ3MGEtYjFiNS1mZTQ0NThiZTBiYzEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQblILWNChKM31D9jRHoYJGGvshhL4OJsf7t49tDUDU+mmR\nL5pqVQkoCJ3LJ2qmB+Fa2oZKVHDyCwSRy4L3f0NSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUok0+QDLuiLF1v09gU18KO9e9\nkGIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhALdY7KKKv/RokQN3BforCWSJa6KV6ksk9zVDmcd6HD1eAiEAv0sjs8bc\nF0HCz4Zn2UL3kqTCUToS1dDPCR/MnplsfJw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAUQpJ38tov0YIzyzIDk+E/JvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjUyZDkyNzgtMTQ3Yi00OTBhLThlOTgtZjJhYTAzMjE1MjQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkY2JjY2MyNjEtYWI1ZC00MWFlLTgzNzgtZmJlMjJmZTM2\nYzMwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErkJm9dZ68k8QHq09WS04isC+\nCZxssqlVrG0m6mrpgTXaDTFE6OpItphQMV8dOYV6Kp95mp82oGcYzlewK/Fp0KOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQJ2oeuzwvdbb0MS6V+qPajNogLRjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22BImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgFDtf0Vd8HosIiw9AxZ0L4Nqf4KEY\nUcuEq7V+wWKD2cMCIQCeyl+al/pMXFCyqteXo4C1/Deqlm4ZpG56VxJHeAHVKg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9431", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9431` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAVaIvegZFL1pmN3M3/Lnb8NIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ3YzkzMWVmLWZhZjctNDFmOC05YjEzLTAyNTBhOTZkYjYzYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzM0ZjI0ZGItOWQz\nZS00MDY0LWI4MTEtNDIzOGM1MmE1YWNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWFhQf0RkcTVWxYAsg+fFfHLX22B+1HIFcjcTli8c2bM06eHqWYGPLI02GvvT\nhtzbjeLK3xGB4x1sc0tP8z8+WaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9ThT1ZuJsvB9SfA26p6xJYJoDZkwHwYDVR0j\nBBgwFoAUMo3Mg1kdBMbQZj5HnV8vLJb2i6UwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGjCNjJ/C5nm3AIypyWnM5i7mMot\nuTCBxDFLBE8BfgpBAiB7bsLwJh05S7vSeFFqNZQojdoWyzVxHobY8VEXhbUOeg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbkWRByEbloVrdlZBfu5TRikMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nN2M5MzFlZi1mYWY3LTQxZjgtOWIxMy0wMjUwYTk2ZGI2M2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASpgeaXeUhatuA5TYpQA05cpY4EXeTpjvfehR7UT6qqScQH\nsF47Th8FBK46pvlLaKm5FXATJS8eKUl9Eg4yHBQdo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMo3Mg1kdBMbQZj5HnV8vLJb2\ni6UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMvnC6SdzMEdzcN/w0bz+OyszEsyW8hFeuesqQa7YZDOAiA9kKsHphuL\nXk1RiXMyl41LkI5ANnDWIANC+rweOXNRxA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAU/4pVSdg0OzIQ4iSy1+RMJAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzM0ZjI0ZGItOWQzZS00MDY0LWI4MTEtNDIzOGM1MmE1YWNjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGI1YjQ1ZDQtZDIwYi00MTAxLWIwZjktYjI5NzYzYmQy\nODY5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+We4TpOtWKg22VoY5DIPwcw9\noLaPstheMLSvWfgRyqxRQceIo7nhmUKwZJId72eySzIdDvr3e4+/9dGESgOU96OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT1OFPVm4my8H1J8DbqnrElgmgNmTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22CImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAObRECwW3Ixf12gjSGPhKbkbYrAS\nWbsZ94q9ZP+5mJCoAiEA7amKGBSHnmrov4czzgLHnYSQKkq886irsDvtGG1HqRg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9432", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9432` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcdP2FoDFUEamb3FbkNEw0qrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJlMjMzYWI2LTkzMzctNDZmMC1iNDZhLTRiMTdlODU0ZDViOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjI2NjA0MjMtNjk5\nMC00NjBlLWE1YjMtZjgzNjBmMDNmMmI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEm6fe5HVgi/hWbjyPH+XHRDOi5R1nZ7ERf3XnWkHYqjG6kBG2n0SRZz86a0RY\ngEwnwX9YAgmy/ZDvq91KvYplMaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSa2Y4kT/p7hklQD21nuvYlDx6NMDAfBgNVHSME\nGDAWgBQ7mVMWGB/JXaV7xGnpS4Lk6742TDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIEJdXus0luLR7EUz4dAegyL9NLa/F8yU\ne97oHQKiOC1VAiEAl/CQAkAr2DGfac83PtViD6wJDbB7cybREX/YB0uZFIE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAesZFduvu3wNAFzUxN3L1wdgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nZTIzM2FiNi05MzM3LTQ2ZjAtYjQ2YS00YjE3ZTg1NGQ1YjkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQbvV0AI2qRX0ytNYFJzaqlbTF5+bjS7d35BS/2nPZ2FJ4u\nCLENIdBfxZPyKH+dXzPvdDEXJGbEOfECjwLhA7lYo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUO5lTFhgfyV2le8Rp6UuC5Ou+\nNkwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgBJs5cPzITkDckWZpSDA8WeqVdZw0HIYQKqj3AeZ0Qy0CIQD23PIJDIk7\nzdOLN6E3tAnp24/r2sMPvBmQ2a3G+1Mx0w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAWDtHtFxl77mCcQXQzYmH078MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjI2NjA0MjMtNjk5MC00NjBlLWE1YjMtZjgzNjBmMDNmMmI5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYjM4YmRiZjMtYTcwMS00YThhLTkwZGMtYWM0MjA0NTAx\nYzNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHuUQmni97mFzJuHJorACIaZS\nJQrd2zlW+RB0Jff4iwa/4vlhges3ffOe7Fl+qIG+jv3ThmgBECbWyQSGcVcMcqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSa2Y4kT/p7hklQD21nuvYlDx6NMDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22CImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgGyBAF1eAi7ll+7xCYvtL5k22bs7n\nhCOh+G/x7IlwF08CIQD5Se7sM352JAR1Swc4opLohtnUkQFUeS1pGogolatQ2g==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9433", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9433` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAfSYFmR0hNkQXuiAh3oCtTPCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDMyNzQyY2E2LTM4NjMtNGNjOS04NzNmLTIxOGRlNGZkY2Q5MDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTUzYzBmMjUtMGE3\nZS00ZDAyLTk4MWEtYTI1ZjYwZTZkMGI4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjWrTeifcP4QRrwB7JwsdLKknbhx0E/vcEbVjSaEqGW7Dzr/IOklsm+m2cqEN\nKmjJHDCfCHsleSvkuXBI+qdhxaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGjwQRVrAo55F5TaA38E9DdURQfYwHwYDVR0j\nBBgwFoAUJN9CiZdwqoAoKZ9c9IhcGnltM3swHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCa1uHElOuEQncSD7yR9ywotuSo\nJRUszbP8R64+ClxodQIhAIVSdkK85+jgHJkT+Cp1hhi3/E7IIL55mtNt6zt9Q146\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWlJoBVEZg/JawzkITtrcEbdMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nMjc0MmNhNi0zODYzLTRjYzktODczZi0yMThkZTRmZGNkOTAwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATHRAzdkDj9/Z1lLDK52x72QO7cyUtZSCNJAG7K1EsxVEf8\nacpuNO6Ue4RrlXIdcKmTBdV6agrUZWXcjdzghmqro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJN9CiZdwqoAoKZ9c9IhcGnlt\nM3swHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJgAh4f9Ij1NQRnRffMgM8VxE+rX1Wa+WksJM1OqCI7NAiEA+9Cx4zZB\nL6GsnDwevV2GoIovfyHThSmunLaY5AwI9s0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAXh8D+um7a9L2ULirsFaBd09MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTUzYzBmMjUtMGE3ZS00ZDAyLTk4MWEtYTI1ZjYwZTZkMGI4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDVhODczZjctZDdjMS00NjVkLWI0MTUtMjBiMDM0N2E3\nYzE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGmFsDbO3gXujAzr0iCC7BOk+\n8Stlf7/Bo6juCqO9f3WNxo2MsLGDE0/UvdPZ+eyeqKYYiRpVfynvy9FBkyZAoaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQaPBBFWsCjnkXlNoDfwT0N1RFB9jA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22DImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgXd266y07+Paf5u82vqBitXeuQNAN\nyoXAmBcCR9VwtjACIFl8Kb3h8XUDbOd85YwZv8oEY7Rg39U4x3ty3+czOEMd\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9434", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9434` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAbBFDWoCbpjP3ohtF4ncIUu0MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1N2M5M2U4LTIzNmUtNDcxYS1iMDU3LWM3NTk4NDg3OGY0ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2FlMTg3ZmYtMTdl\nNC00ZmJlLTljOGQtNmE0ZGNiY2I5ZWQyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE0NFix74BYrwLqhjT+SzaDpvxacFOm4LSchSkMDvZi6t1Bjh38n04r63cjUDL\nOIyqd46lQkQifGsnfF9ULjSsE6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQsAba9z6wwBZ+VOB6i0qASbgB/ozAfBgNVHSME\nGDAWgBRntKXz0YrO04Vv6q46/7cpJtMcFzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCBVnpprkPmwmtEel13z1WcGmOQsq46\neJbO67Peax5fSQIhAKtogqBmCTuBpEUijJxam/XEcu0eiwMjQSjDgi8lSeZg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdPnHr/q5f5NfEP2TCG2SStAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNTdjOTNlOC0yMzZlLTQ3MWEtYjA1Ny1jNzU5ODQ4NzhmNGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6Py/zNNE5Rwk4ng6Ju/JBQAIZM4ImM+D/2OhO2Bk3wnbG\npo/dPtvyLmj10siNWcKxHiIHaP7FKa6ukrJFYLV1o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUZ7Sl89GKztOFb+quOv+3KSbT\nHBcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYI/u1SInOQOq66aKGNyy5bkgdkGf1ReLw2AXoBkdZIoCIQDP973CqD0v\n+RovoFyLYZytIvSpbFH+6VXWo6FlSc1VPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAceR1xkG5k1NCe4iBDaeIaB+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2FlMTg3ZmYtMTdlNC00ZmJlLTljOGQtNmE0ZGNiY2I5ZWQyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZWFjMmY4NmMtYjM0YS00YjMzLWEwZDMtMTliZjYwY2Ri\nYTU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYTQ0V80dV8236DcUJc3B+8Re\n1PQ6cp342FKyDrwYvAYNMywycDsymf1a+pimC7fe34GHGoxNHIwgREzSVysqOKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQsAba9z6wwBZ+VOB6i0qASbgB/ozA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22DImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgXyh2DkVgVDrgfxiXpmh1X6LH/u/x\nGQjJeogV2Q8DaB8CIQCV93VAYyp0EH/NvNg27kUBz3+gDBRfryuhCelDYNr6fw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9435", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9435` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeqozJmuWnW5VLOlgp062BToMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGY2ZTkyNWFiLTY0ZmEtNDg0My04ZjM0LWFiMDE2ODNlNDFmZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmRkMmQ4YWUtYzU2\nMS00M2RjLTkxNWItZmIzMWFjMDNkN2Q3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEEoweSh7XmSNLlr8GlLjiGLppTFBnX7/+ozrkPeIhN8o8MMFGuHPox029k9/M\nY7xHH0wrG2rwQaI0bSMR8bV9c6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2Kug0gPQ1Mje3gKcuzT7kkh33DYwHwYDVR0j\nBBgwFoAU8JWeK2pO0C9sSPUz7yhtkUoZ7sIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIGp+eTVu+8xtTCfxLV/1MnLp7mmj\ntluutrlQbABva6aaAiEA8xOY+sjAPnmqZBRaAROZNOwpQiJsuRxVuYwNEQiHu8g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAV20bmtsI5eyhtg+3528kPSOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRm\nNmU5MjVhYi02NGZhLTQ4NDMtOGYzNC1hYjAxNjgzZTQxZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWIrGtX9/44SGFh09xLcWL5em34HqQt9Q1ZSsLenvGD5rf\nJFLm8rLZ7dHbGUNF/GqftpFhyjAnhPGXftmoO8oSo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8JWeK2pO0C9sSPUz7yhtkUoZ\n7sIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAOK73T5XtQwdTu8EhkDLqcs3bfXMnX1vOcaiVkY8oqEWAiEAsmc9O7RS\n/t7+6ouM/l/xsMHEE5yTpHMFCYyfTnXy0p8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISATBAgJgGseR4ahUUL6KZAEH2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmRkMmQ4YWUtYzU2MS00M2RjLTkxNWItZmIzMWFjMDNkN2Q3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzI2NGY4OTgtM2JlYi00ZThjLWEzNWItZTJkN2I5NDc5\nYzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXoqWMxWQi9fMZgRXnFnlHiqu\nvH4DXVniZG4jBnS8fNjfOQeIJ5a8B36VtQYfwm4mddumepYAcMHPYoeeTaE1CaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTYq6DSA9DUyN7eApy7NPuSSHfcNjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22EImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgSiIQN6KNvxa7HM/mOq/VrM5BZOJr\nvyWBF1ad5rDaEWYCIQD0S1EY0ZUv8FSD90ehCEGe1vyS/grGFN97ApV5MYW5Bg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9436", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9436` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAawqGqEomyAUwxLcYo3ZZAxLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk2ZmEzMDRkLWEyMGYtNDMyYy1hZjFkLWZhOGU4ZGVlZjYyNTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTJkYzYxOTAtNjA0\nNi00MGE3LTg1MDAtMWNiYzVjZjQyOTZlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQNt2+ChKSJsJ+F/FlNzap5u5tvDv4QM/wSh7EtaQtaYPdKN5xUZSpVZ7Za0i\nWLZUpHbmLiBQn1cquPQqCB6UcqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSfFsvuai53KuFbhroGACmFg8FfGDAfBgNVHSME\nGDAWgBSawAHgGMXgPyjG2w/+OD7Crb4rLDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCa2S8VHCHdvN74ZVT7xCulHYLXxUAS\n/L2XhBBQPz1XRAIhAMfLu2RKRonrCFk24sS2AO93qcloIZltfrvmn/rdopQW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa4MEQ2DduoWozDDhjCyMVkFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNmZhMzA0ZC1hMjBmLTQzMmMtYWYxZC1mYThlOGRlZWY2MjUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS9RrBoEmVV+DGwVr1VN9gORwm8XxLWFjNectY5k+MkyFzp\nvyCLfaYsjtHyirmxvgGnZrR0JqHRtBa87J5mXOhPo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmsAB4BjF4D8oxtsP/jg+wq2+\nKywwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgYY8bUj8j5EqhUWKZMRlv/veALmuJ2EXCQ6dDpimntRICIQCO8k1EYqnu\nvaWuK/0bzyPKJvUYmQgaInArsOq8P9AV4g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAVj3HLvR1aLBfFDRPjnNSg3hMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTJkYzYxOTAtNjA0Ni00MGE3LTg1MDAtMWNiYzVjZjQyOTZlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMGFiMWJmNGUtOWZiMC00MTA5LTk5ODktYWFjYjc4MmJi\nZTJiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx+H4yNFr7K8HYbxSF/2m6fD0\nHq1tuP4uDqPku78KdBJKrPGZVooG6JFzZMYXmz1jbFmscVXDNSFfz8k8EoeO7aOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSfFsvuai53KuFbhroGACmFg8FfGDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22EImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgVfxxXMbZv50xIZ+XS7TgcQPE8Zm+\nC3ew++FI3VK6iJQCIQDiBagJXsRy2GE+SsX7q9o3wK8gp6aLI0YjxbB0quT1eQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9437", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9437` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAdjAM6gCTzFAP70GUroadsj+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhhYWQzZmFhLWY1NzgtNDAxYi1hY2U4LTA4OTg1MWE0NzkxMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOGNiMGJmYjItNjZi\nZC00YzcyLWExYmQtZDk4NzUyMmE1ODI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9cqwjaFCWaq/MtxjYxULH/0vBLlLWDYonH0RC5e6VnVk7dW962cfKjsjeuIg\nbIj4WAzF53A6PtvX1oBSsWZC86OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYIEVoe61k3aZGd/UDLSyBBVvcWIwHwYDVR0j\nBBgwFoAUp8sMmf5dYlRiockhwQo9frOUqKUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIA0q4KFJ6190U3b1MpPB2ayMB5wr\nwAOiIr5PvuhJ+fQJAiB2Z3y4RkUzu4cW56pA8cxotRi2KM7lyjtKCzbEOIgM0A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT6mT8pfRb69fj2Y4I1XAIDVMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYWFkM2ZhYS1mNTc4LTQwMWItYWNlOC0wODk4NTFhNDc5MTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQAZLWHWyaL323e1g8NWPHn+AF8xJZQ8WHWJIVbuEWX6mWe\n5xo1TVMGjSVP4u71cFV/tN+6+/Bpu1pQPdnk3vPbo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp8sMmf5dYlRiockhwQo9frOU\nqKUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMVVz/vi4x4/9D6wb9XxejQwJ7gIq0On7gmOErgLuN/XAiEAxtBOHuXG\nDD+XpVj9vfTxPeVcvh8QO3PMFJaOIDSeWuo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAaBLEU8/Zybv2e5FIAoetHfUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOGNiMGJmYjItNjZiZC00YzcyLWExYmQtZDk4NzUyMmE1ODI1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMzkxMjQyYWMtYWNjZC00OTYzLTkyZjUtNGFjYzliZDJk\nNmZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfbJKeAbmJUsbYE91pUgrjCcV\nuAifYab+ILUzQ6dBQh3hKGcUp770EfovU8WNCBCIzp35dIBbs833JLIHA2g2pqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRggRWh7rWTdpkZ39QMtLIEFW9xYjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22FImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJverx7jHer1479v2MVwVPCKNRfx\nMegztx4uPJb0EMinAiEAp68YQWxesJz3QpGyElPCs8KZQdofocktpE5EU8bZLPA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9438", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9438` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAV0n30KbT3Yf6Xf2XzKlhIwLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcyZWM2ZjBmLTBjZDMtNDk1OS05MTBiLTY4MmQ4YTY2NWE5YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjA2NTk5OGEtMDhj\nOS00MjFhLTk2ZTQtMWUzMzhmZDM4MWIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE7xkiDA/NjvRFc067cjLU3lDD369qBT/rX412YHs0pdLxPigp1Z8+m175b9NM\n1NMM2kO0fgLi7pjMfi9W3vtCiaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQuEtvGwgF5w8XWFtDzJek6gbU90jAfBgNVHSME\nGDAWgBRcrknOu9UfkJrszNl94y+erQaYNzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHZvjbpprBd9gQ9drOmEqmawQHyaiTLO\nU+cBnSaUxH38AiBozs54nc4zLzQ5yQd7hP7M7Kek3bwqJOS8gpIf2IHi/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZiS41v6CTl9OBScTD1LVBv/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMmVjNmYwZi0wY2QzLTQ5NTktOTEwYi02ODJkOGE2NjVhOWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQonFPQstXfoqDmU2PQz6HdOlhrCDuy1H9nI+2Gx6gyQhgF\n0FKQwAHTVCgabIzvcih92jjihU6F0tiEO6qvI+qeo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXK5JzrvVH5Ca7MzZfeMvnq0G\nmDcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANrsG5OvCS/hRs/fuvARjHXINLLBCOFm9OZLn8i1ULEWAiBkAi4sEo6J\n4duFK1yE7p9U4kZ7jq4QAQwsw9r6Q9kkfw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAa7pgOvSHoqM/pq26HE1MyFKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjA2NTk5OGEtMDhjOS00MjFhLTk2ZTQtMWUzMzhmZDM4MWIxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDg4YTU2ZmQtZmU5MS00MDFjLWFkZmEtYTQwODUzZTRm\nMjJjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqiUngAzt6jfvFSreUgD7BqV0\nci07Gpco9xy4kMU6Jnej2Eef3TXIrJ+4NKuoJFFaiQA3LF7xCWd7D4UCJ5O/IaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQuEtvGwgF5w8XWFtDzJek6gbU90jA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22FImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgeHqJsDaHWoGq3q8SHAosi+gPKsz9\nC8xqRGF0FDuhdlICIAQEX3w7oRY8GSUTr/s30567tuv9GeBU413W8Cv5uH1L\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9439", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9439` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISASjuIQpS173DFDCV61LkC5kOMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQxMzIxOWEyLWZhODctNDM4ZS05ZTIxLTJjMTJhNWIyOWIxNzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTA0ZDU2NWQtNGE0\nMy00ZTIyLWJjYWEtNGE1ZDMzNWVjNmQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEWMSDbn2pcqYBgY+niFTct7av+slkQYu1KPenNd6wyY3QIJ1PaVHz7t7Bqkl5\nJZz/pgaIcmE0JPpVNQYRSHD0B6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNqdL4l5bUPOfQfGEJgTwgAks8aMwHwYDVR0j\nBBgwFoAUAuC5FwXlGbRRy361hRpasRw7LvQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCH+JhOSsgw2YYlK5jqro09uqZ8\nXQI6QPUD6qPe6Dby1gIhAPr0OZqr91eN54y62LfyQAK5IcuLvNJ991w3NPjC7As9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAT069uBymVWvcCAQdyXi+xuaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nMTMyMTlhMi1mYTg3LTQzOGUtOWUyMS0yYzEyYTViMjliMTcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARySSkwRVJ91/SzZwZn3pU/B4FOlhypt8/WwIu7roVpseCU\nBy3APNPH9q90Iti9b51bOhMhY+aDyirbu0To6AFro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAuC5FwXlGbRRy361hRpasRw7\nLvQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKZbNha/H4o5Wz5vf+knMFEoeULHVeWNhKOSm+1URDlJAiEAs4XIo/p2\nL4009Hfk85A9LFw2ZrbduCcjOQQIexfdGXY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAUkrz3wzyFrZmrP9tFt8OkBTMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTA0ZDU2NWQtNGE0My00ZTIyLWJjYWEtNGE1ZDMzNWVjNmQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYWE2ZDgxYzktODA5NC00MDA3LWI4YTQtNTU5MzQwM2My\nZjQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcpLftEkOyKEgttKgsj8oZt8G\nTVZy3ov1YtqWY3hP2yt9IPyLZLmV73q/8U4ODJ8u2rsst0p3y16t3bf1ZqbNdqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ2p0viXltQ859B8YQmBPCACSzxozA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22GImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgeliq8SXpZ2f2/pq1eRjB5Itn4KJN\nMKciaP29yUcsLegCIGg+u0aADP/paUdAKir8DeE9b64HisPd1wDiKk6n2o5W\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9440", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9440` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAbdtijSf5YJcV9CJ6vsW1zI4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM1ZDFiMjk5LTAwZTItNGQxNi04MWMwLTIyNjE1MjdiNzE0NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2M0YWY2YWYtM2Jk\nYi00YWVjLTk0OTUtZWQ5Mjg3NGQxNGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEFH0RRs0udGb6YlFpXf8ugTNofS78it111gTepmLvAcq7JJlkBHD4xqXDI/Pz\nUkJtDoO1OU+9L27jQ4FPNuKPfaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBT1CcMzlgyhRzVO5A4ZxNo9/y3SOjAfBgNVHSME\nGDAWgBSAxkQmrcWVRrqd5e+CdU/N9+C33TAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICas4Mka9prjF1iDSnLlH/TSBJnFnDbu\ntk/rNCd57PNLAiEAkeOhlmQlqBwK3CLYzFp1VKtwuTEnu8xH8O/cKb08Ubw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaGbPhHOguNaPK/NnM3LTZCjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNWQxYjI5OS0wMGUyLTRkMTYtODFjMC0yMjYxNTI3YjcxNDUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQY0CTGBWE+FDW+K06meEa7ME02/g+6Z2bWHU6E9aUQWzQu\nChZVqCyEQfn+wkAf7T4Zbksgu0ySgPLT5PdszgvRo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgMZEJq3FlUa6neXvgnVPzffg\nt90wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgeUauRk1iUTnX2TMGGftNVoZtSdkK9HbcP9x6CwWlbrMCIF0z1QsDsHZm\n0Falqtcz4zI2JtIxXmX2BsYbbfW97S7U\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISARJ/XDN8KxOeytyTHCijBzeGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2M0YWY2YWYtM2JkYi00YWVjLTk0OTUtZWQ5Mjg3NGQxNGE3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjY2ZTI3N2YtYzAxMS00NTJmLThkZTItZTRjOTllMjgy\nNGI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFcMs6edwcm2ut1R4m/0/MOYs\n9pCoBnVcVUwk7F5EMmqDs8ivh4xLb8zfFtf4aGiEo4ipX6IH9e/zAkG+krNTfKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBT1CcMzlgyhRzVO5A4ZxNo9/y3SOjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22GImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgDGfRw81aLJOdDjj5Z6t0qbGzHMLZ\n5LPrbau1dSBmJPMCIBxFdH+lylhex1GyqGlAR4QflErgU6/gKw4uhJ2drfvr\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9441", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9441` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAdMGwgYRyC9Khw4wXO+4HHo1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDcwZmIyMzQ1LTY0MDgtNGJhMi1iOGI2LTQ3YzYwZmYxMDQ5YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkN2Y2YmFlOWEtMTky\nYy00OWM1LTkyOWItOWYzZDMzNDRmNjI5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEc78nWCI/wetqqcxXx0mb0RArJMpSwKg3Y2wdvuUWkAQEo+uJeRLR7sIaY00I\nQ0MK5jvxlX2WJMHWM/ax5Ke4nKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrixwAGsKp17kPqiuH+bIAFLDXUQwHwYDVR0j\nBBgwFoAU/FA2weJhwij1ewwJAhV35UOzRcQwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIA6bTrXqiCVRBhBfekmmN3F6Ciqg\n5lgHNRQ+Wmr24EU7AiBIL+htHEB5QvuZYBsvhgXehMSXbhLJPGhlhd3U8LvIHA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAftamZJ57UQdJy4AJeYN0NiuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ3\nMGZiMjM0NS02NDA4LTRiYTItYjhiNi00N2M2MGZmMTA0OWIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQuChVz/KmwmaDv7GLgWOBxOoc3TpXq3FECSgQIcaslhMRB\nxc/VIenP61bC5o/v+tDdHOXjEi68yxd2AELKGIu8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/FA2weJhwij1ewwJAhV35UOz\nRcQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgVPeQodx9uRRSnTRTd2TGHO1m6le/rvf1kLnXvtnX2MMCIEqhW1Jq3y4x\nJtbxOhCGsp8ZEdGGVoL9RENO+XApua4R\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAXgkHkl4LSL6O242L0CqkrcYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkN2Y2YmFlOWEtMTkyYy00OWM1LTkyOWItOWYzZDMzNDRmNjI5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNjYyYzE4NzItMjI3Zi00OWMwLTg4ZGItZmFiMmEyZDk2\nMjBjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEK4rvxMFsfUtmFzf9z/e5Hgrl\nRrNoJANwEnZ+978gyTOEiLdiVWEoYHhOxwnd4Kl4yqrQDc6gcXu1tkvI8JhcgKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSuLHAAawqnXuQ+qK4f5sgAUsNdRDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22HImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAK7v9j3OR8lbbe5r8w5YFMEA7Uul\nTuNCEXh4QMvTK771AiEA3EQeSpPp9AApxF9cIlQxPcl38hYx15+V/SBBXKUeLIU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9442", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9442` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAairEghgITsOt2dvQ+0WQElYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg1MzA3Y2FjLWZhMDItNDBlYi05NTczLWNhMzc3NDQ1NDA5OTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmE1OWY1M2YtMDE4\nNy00NDdhLWJmZGMtZTIxZTQ5Nzg0ZGFjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/qj6YKtZxWsyFqXJSeO5qcrTpKquDab7wRjNO/ScGONjtoFQDV6sAE90JXWL\nvcsULNzbrCSWAM6a4Eo/J2t/WaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSFbhdKcUHlBhFlIYQ9b77yAKc1xjAfBgNVHSME\nGDAWgBRr+lEQd0vnBdUxP6FIKTRXnM9cLjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC3uUe84cVSqQLEeVaHEBiXOo8ef6Fp\n4NfpOAgVYSa2UAIhAKRI5T2KmgbyyTZ/Sjk19JNn8li9gnmz9aE2Eea3xZwE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWrkxrffZe7L0qXFPkAk6eo0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNTMwN2NhYy1mYTAyLTQwZWItOTU3My1jYTM3NzQ0NTQwOTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQTlDwt54hO0d5LXERy7uWPK3Ng8No2cDnhUGQAUJf4ndb/\n2WfKGX4dBGJbbyA9LeejIdwQ9oUDsqyuWHjKklMio2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUa/pREHdL5wXVMT+hSCk0V5zP\nXC4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ+PO7vtkylNbGvz0QG1yWK9801SvWZCCVQ0jZ8eFKG/AiEA08MiIA6V\npqfvZWiN0wMrBbX1tdDkaZ/n44SRr0Jh2wc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISASIZOadr7q2ZyasKY91ztUOOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmE1OWY1M2YtMDE4Ny00NDdhLWJmZGMtZTIxZTQ5Nzg0ZGFjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYTFlMzE1MzQtOTQyNi00ZDE0LWE0NzAtNjc3YzlhM2Uz\nNmIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERQmPBVnreyutju4z1EAuQ+OH\nxnMI7bUDIFnQx8AZ+FXdGLK6vhIU6FlMon/RksrOtonu31GO9MoH41oUS0yWoKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSFbhdKcUHlBhFlIYQ9b77yAKc1xjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22HImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJP6O+xTyoryXlBqu6h7jV6SnfXv\nCmO9Jda0GC+RvJYbAiEA5NEc99fuTVy4qQ/PRQCm0D1CFRJJNsYVI9v/pGelQQc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9443", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9443` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISARV1mHEB4X0bJ39cAbUk71CrMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIyZmM4MmZjLTA1ZWUtNDg5MS1hNDYxLTgzNjAxZDRkZGJlMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNzQzZjIxMjAtODM1\nMy00ZjllLTllNjEtZGY1MjZkM2EyOWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAErmFM5QW9K4zX0PV/H69WhQvckQuGc7plpG9dT/TRnvIH+Bx84erzaMWrvoVi\nU7NrH2/Ptj1MbBZMi3WVrK17t6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7Gcgvcb+PUmI1m5E4P+8bkYtA7swHwYDVR0j\nBBgwFoAUlaXWPLxy5j2FfAmWKKLxKzjycPkwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIDfMw88mpy97q8pI+Ne92XiFA8UC\nTFQbIP2rdTZKN7P5AiAVTHR5DuP5xIDMTwaNtK5Fi24h//FmgdQlLowyhNvgsw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVug6Q+vCl/AYwxzK3dWUp7FMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nMmZjODJmYy0wNWVlLTQ4OTEtYTQ2MS04MzYwMWQ0ZGRiZTIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT/L5n6KcMBLiNezpfHTzGzWtoMLlymTjvLp7nA6M8PlRT0\nj/dAUgVgOn5inaiHnvzL0r8a8GH/XqJUk5e8Ucdvo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUlaXWPLxy5j2FfAmWKKLxKzjy\ncPkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAM9ozRisA00eu3tdoIL7VvRvfFHJ5e7kmFKlL4cOiy6KAiAugYt5AiEj\nTEmf+UnvWYgjmC5MuFlHvWC1dZo3HfOFTA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAQ84yJprkqmCa29/1FUkkE2tMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNzQzZjIxMjAtODM1My00ZjllLTllNjEtZGY1MjZkM2EyOWYxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmFjYjc4MDUtNjNlYi00MjY2LThjMmEtYWFkNmE5ZTA3\nYjIyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAUnGhbONukFZOti3xwzz++eo\nHm18N5Z99QG0MikiIpobpQ1DiuDT4q6qtIo8Xe7Y0PxHl9vG9XFo0YDTGgkAzqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTsZyC9xv49SYjWbkTg/7xuRi0DuzA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22IImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgWdUIXl8f2AaU/+/3YQEuPwPzjV6i\nFULYW9vWjahjywQCIQCNJK5ytN+AIRTPqTiPAvX/w2ayDR8F4VtkJqBGc0s8bQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9444", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9444` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAaik25kAnTdblf5gJZo6I1w4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkOTFhMzAxLTUxZDYtNDc4ZS1hYTk4LTFkNmNlNmRhZTM5MTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmIwYmIxNTUtZTZj\nNC00ZDJkLTgzYTQtZmUwM2U1YTJmM2M1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAERrtF65GtTKX8Gxqv6zYoYevV0EO4F2syjjChGxunbV4q9B+kq810KX37NmUZ\nuvmBSKJjMr/zbHJA1R8UiHHc1qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQvlGh4r70hre48cmfonc58rsUm3TAfBgNVHSME\nGDAWgBScZp1Z4oWN8hLuUzw7IihsKkcKfDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFWs969/V/wNTAkJB+gzNVs6jSf1wj95\nf0VezKjMZwThAiAwXp55wti0GiKk38tm0NjKPdhjBVDKX0cw3DyEeVc0Ng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbWcnHsHa5awZYigrWctZ6/YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZDkxYTMwMS01MWQ2LTQ3OGUtYWE5OC0xZDZjZTZkYWUzOTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS8XHq9QFaA6aME/BgbR31dRL9xjVpE41Q4qZbAlIrUSvTG\nhHoMGEypffgMtDjG3Qneswc1pCGp44mxJ4OtnXZoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnGadWeKFjfIS7lM8OyIobCpH\nCnwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAOiM7NZxgIbJzg6hr0YMlOpqKVbVsRT4DVrCXR6rQf9oAiAU/P7PwAfL\nIHM5k0V23KJ316I1w/+JRUWmLVOk7Lhcew==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISATXOH1+dL2C1+cy6JoG/J/GJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmIwYmIxNTUtZTZjNC00ZDJkLTgzYTQtZmUwM2U1YTJmM2M1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTc3MDg2YjktYjA0Mi00MjJhLTg4MjYtNGM5MDZkNzBl\nZGNhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOu+suPfxGsvuP0ZZpXElwbjK\nftNAaICXWgrfmdHhF30zjQnXVybSAlY+jgtV+6MfP45xC7hbnbhD9ADf3oSvRqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQvlGh4r70hre48cmfonc58rsUm3TA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22IImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAICbldZJhoFyiLQS/+CrVlf0OdOx\nsESNaRc2NPejq63lAiEAkQtgWCGoYwSNQ+ZK09AiknMjXWMl3yCOUkfGQEIZQ1E=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9445", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9445` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdPo2eL7dnSsp9N0F5Id4HiLMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGUxYWRmZWUyLTdhN2EtNDA5YS04ZTY4LTQ5N2U2MzJkZTVjZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmVjMmEzYTctNGEz\nMS00M2EwLWIyZWItZjcyYmIwZDBiNTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHc2nI/OIksGInM7mfzjWzEQM8DALdci2pmZkI694zNydKqQfVtfIV4SRSZAO\nX3dgGNkN220oysLzvKW94eQn1aOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaGmY3SJLv5y9Leecr1SGb87dcQUwHwYDVR0j\nBBgwFoAUTvue5DpRdwEq7xLTKRtLYYXTnsYwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDPh0GivaOJiFz93cii4LowuqvT\nGJLKy3ON5usQXzYMvwIgPutx3a3HcMzGEfD9MEFuleXXFYMhcGFelGn9Cj1+Fa0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeIKHU/y9kCcKEuUzsgwogxcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nMWFkZmVlMi03YTdhLTQwOWEtOGU2OC00OTdlNjMyZGU1Y2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASnqdcC2jh+q/3OauLhfwMwnLf/sbj32yI3h4Ks9MDS/dbr\nD7dvIFdsWbRiOuS8eXXgWc/Lh7tVj+rSrDdHLgEko2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTvue5DpRdwEq7xLTKRtLYYXT\nnsYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJvgsH+cmP13iYijkWfZH3a19Gde433OVGwSV0JUJ0QqAiB0quvSCSLL\n1nO7E+2Md8Ww7l83TOzFwzqlez8+1Am4ug==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAanSYlKKUw3npovZ2VGuJHlyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmVjMmEzYTctNGEzMS00M2EwLWIyZWItZjcyYmIwZDBiNTlkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTIxZmEyOTYtMDI5OC00ZGU5LTk2YTItZjk0ZjU4NGIz\nMTkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEn/85eLvOVyU4I0+W51hY+zc1\nAhzuFcAzpyg+yQezFsb8BYv53kvj7YMrLebx4cwGZ8onmTN2fteeG7eCP9JLY6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRoaZjdIku/nL0t55yvVIZvzt1xBTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22JImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgZMukrSkZTJUAXduZB2jsjZYvm/ZX\nJwG9yq79zVhy094CIAgd49UROA7HPlDfSqMBrDMh5bvrX73ghnleUkO1yryt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9446", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9446` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAcyOumxKjzcl+aQ76oEP/n7PMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhkMzQ0YzgxLWNkYzAtNDA4OC1iY2EyLTIwODhlZmM3NjAxYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjgzZTQ2MzMtMmZh\nYy00ZjI1LTg5NmEtNGQzNTE3ZmE2Mjk1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEavVNUCvqVB8L9UswXLdnmC0vP3QQLwnSYuZOC21YDC8L4u/qB2qFgxVrS/Pn\ns24cXTFdVQvkipYcuUYR2gwW7KOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRnaNvXC8Py0axW5EIsiBl2atLG/zAfBgNVHSME\nGDAWgBS8uBqgAzz2G+5jZsO8kpszOR0JvzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCDSaAh4hkmc1QrnvLZFGxQMdHcl6S0\nLxrGtPR8uj3HnwIgRcQi+UsuBoPdJXz4PUHQR10DXSp+7Hzgm3Y3o/4e+MQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARGjnS1+uFHCIpHWKMXLja1TMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nZDM0NGM4MS1jZGMwLTQwODgtYmNhMi0yMDg4ZWZjNzYwMWEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASkJLcGwIvy0BqcdUV4yV6oLUuda4oCFUx+0+Ue5PTUeSqx\nOUmyf8QhoJZNuQEkw2S5CcAjtmElWYX+shvBtGajo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvLgaoAM89hvuY2bDvJKbMzkd\nCb8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgFDgM8H7cmBlh8oL2sm2d36H4PkBDXcPeeGOY6PWtjIkCIQCp/UiAidyc\nzZBI3ItesE4GjAR6UGph3c9UICAD6BWR+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAY0bXiqrXDUEXzaIFWA6a3+7MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjgzZTQ2MzMtMmZhYy00ZjI1LTg5NmEtNGQzNTE3ZmE2Mjk1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTczYjBjOGItNTAyMi00NGViLWEwYjYtYzMyMjQ0ODZh\nZDNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+gTdkW04zyHII7Cf2tSsKKE4\nP2fJttDb6wuGx+fov4HfsR/Ht8iCYWU4hIWqqnSFBMSHGmIdwocEt50z1HTU3KOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRnaNvXC8Py0axW5EIsiBl2atLG/zA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22JImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKjwAZXnQl3tx39OEatfsilAgaMr\npBftAH4rpfHmsBQcAiEA1RFG1IsCpAXPmlDF+y7g9QgNLNYrYmBSxD5ZQl+NkuA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9447", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9447` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISARtldqDTQECNiqc+cw2ZXJByMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNkZmFhNDc1LWI1YjQtNDg5YS1iNmM1LTJhMjQzMGU1ZDU3NzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWM0OTQwOWItYjE5\nYS00YTFiLTg2MTMtNTA2OTYxYjAxMTFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHTGKat7zp0Edv9pfWLY0i01iDnalQf2Kkofe3Ozh0cPahKIBGPAO+hmscHRR\nX3cpKPK/i2/pJWYN/r7gLcfftqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU887vgskdlZZCDB1Z0U5DrFMNeKUwHwYDVR0j\nBBgwFoAUTHwMBha5K6mnQxbKoiQsJmUIDlcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCsI+MA3CEo/EhgW1FOzEkhR+ah\nhcC5LSg27M/Xo65MngIhAOfBY+VReCjPM7taziQhvYLJ2qEAYLWCVUObKvwPiKpE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAV2tyr/k5aw8UEXahYOwWmyZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nZGZhYTQ3NS1iNWI0LTQ4OWEtYjZjNS0yYTI0MzBlNWQ1NzcwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT8u/WjdEEIIYtE+HhtIQKYXFS7O1H5VggjW5hgscMjQmk2\n2y+6NpqgVMppIWyruKUlRIGcNsjN/nhMDTfc4g3po2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTHwMBha5K6mnQxbKoiQsJmUI\nDlcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgTLNFeJ5tBUCgLrwdXxygG9vk5/ewibb2sKgC/NLgXuwCIASSjHlGCFVs\nGmUfj8yVsms4e5ol7zpyNZ6gP9nMrLFD\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAa1ZtSZ5LMgx4+PYhNzIHaZQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWM0OTQwOWItYjE5YS00YTFiLTg2MTMtNTA2OTYxYjAxMTFiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWViZmI0YzUtMTZkOS00YTBhLTgzMTAtZTcxOWExMzk4\nYjIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERnxz153hiALiEFrkxO+fnCrW\ntQBZ96HIdCy14/UoWGfZ1J1ZR7J7nk11BQER0BS0wibcHK75xvSQmdHGw5c78aOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTzzu+CyR2VlkIMHVnRTkOsUw14pTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22KImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgI5/Zfk3H/jPz89lvkJiLt5XLzReB\nbkBtPhScGZt8eLICIQCTLlqj/IvI5UWW0CuwCgcdpuuvGOZl3afeK+y0JeGcOQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9448", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9448` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAR4mJjSzaHnb/d6MimlRHvRmMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjNDBkYjIyLTk3YzktNDEwYS1hNjBmLTI3ODBlN2Y5MmFhMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYmFhZTI5ZjYtNjA0\nOS00NzY3LWFkZjItZmJjY2U1NWI4OTJhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdEwx7zXA9Uig4cZBN/QxlWh3xHZCCLAfUk7SvA8CWHtv7tmAPe0UuV7b/qMf\noo8Rus1h5uS2kfSkGrBLG+1inKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ1K1ZyxrFTDyHRh2jtRUjvwjHI0TAfBgNVHSME\nGDAWgBQAAd7K/veQJU3e32BJ5fumOMk58DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIHNrtOSNVlVhoxHM0C/Ee+XsHbNEEQOQ\nCGQq41JXRNOJAiALgpGtPVWXxC6xbvqasVg6DvhDvjAoR+AD+irPM0EvYg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdZkPPaqMUE/dhp6fBfZafCOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzQwZGIyMi05N2M5LTQxMGEtYTYwZi0yNzgwZTdmOTJhYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQQRfgJ/ud5h5pTJSI0H37NqInbxnOHvOzpMJzfwHLUWrlF\nuEf4VmySkM5tdMy/XVSlXwxiBKYDFS0agWEmeyyro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAAHeyv73kCVN3t9gSeX7pjjJ\nOfAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANQrtaS/PDTMXxLUZ10rYQ2vj6N4KM6cYPyxKuJW6ujfAiBxkm9m4bYy\n+79sjhF/BCokRQ056qr2QYN6xAbvWlo/+Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAat+qGlPf9toFMdc32Qnqpd5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYmFhZTI5ZjYtNjA0OS00NzY3LWFkZjItZmJjY2U1NWI4OTJhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZThiNDNmOWYtMTVjNC00ZGMyLWIyMTgtODdmYTZlOWYy\nZmE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8LtP0AHUsvXnsg6ahnky6Aye\nrC/x5WyX0+L18HNNlTl+JUh/nIv8YKg1/kRt4G5+a8LH/Ck0e2cwvKtCkPeDK6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ1K1ZyxrFTDyHRh2jtRUjvwjHI0TA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22KImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgeUQW0RtAAJNdWSfOQ1uWX60VxE1P\n5xrJ+G90Bafrs1QCIDfsRDMxWmfohT+ODL3bm0HxbXIvr+gQoWPoxnw6k4SP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9449", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9449` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAQ6v6/IJUI0bN1M1SVo1aP2zMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEwZDNjOGM3LWQ4ODItNDIyNS05ZTJjLWQ0OTg1MWMyNGQ5YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDNmYmRhMmEtOThi\nOC00YjYwLWI2N2YtZGZjZDcxODM1MGIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXtwoRA2uC8HIa3t54t51omACsXvpAYUHRBKu0QSunJTDotg4aZE4PTA13vHk\nJs2DCEpC24xXas7dFdnfmIyCfqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKZPQCpz3gVXUwATTEiZHYtCbSmkwHwYDVR0j\nBBgwFoAUiaVqUJCBN1PjLfwdWE6XPeFh8RowHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIC/APriJy5kR/OlZdD0QUtL/oIXa\nVzGI1jHIgW5dZSQMAiAgNZjS54b367wzpG7n2qlZD0e4/8KoMh7JZPoBnXMKMw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASsByNrgxMjAu9CQPyK3ocLBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMGQzYzhjNy1kODgyLTQyMjUtOWUyYy1kNDk4NTFjMjRkOWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATrk0kxvSVdat/VGSzrX4KCHn3FU/Wz4SC5fiDDca2PY8VO\n4tCbK1M21eX86bvQfUVG/Yj8/erMCtcZ2Re+Wnnzo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiaVqUJCBN1PjLfwdWE6XPeFh\n8RowHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANTkKTCkXr4mQfvBrtK5ED/3vxkjnQjtHcyLsaCEjO+8AiAgbbc5Ruzk\nxD/RosJZiYvp4w3BhpMxjVMfiTCi5/2wIw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISATmlQiZmaQijoVoI6gLxXUQ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDNmYmRhMmEtOThiOC00YjYwLWI2N2YtZGZjZDcxODM1MGIzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjBjZjc3NzktNzA2ZC00Y2Y2LWEzZjUtOWQ3ODU0YjM2\nODEzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+G8lutYNxp8LyGyw0xctQtfo\n4YAFSr4qnnbq5Gq20opmCxGia5SnSNc8TiTy+TGOLzCqv2N0lGXcp7D6MtOrSKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQpk9AKnPeBVdTABNMSJkdi0JtKaTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22LImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOOsDTMCyQi1h+XLw9aHZyzN3j6K\nzOm7IAn0MmDmH3ZFAiEAmWn8ce/ndyS26FodAcWCQXYo1YAEoY7ameTl+oLJR5w=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9450", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9450` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAQRXxIghySrBkXnlONV9BZ54MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU3NjRmMzEyLTA1M2QtNDVhYy1hM2NlLTE3ZTI2NDI2ZjVjYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWRkYzUxZmMtZTFj\nZS00NTdlLWE0ODgtMTY4Y2UwMWQ2YTUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEhqpeQfBhaNtTW/xl5IpgnZ9UyHWKXRfPMhy2i+FF056GgppzgiiamwWJ2DBu\nsdAYZMwYf0AMrVSacgiFe3uh7qOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBR1+HGkz2sDEwlUlC/nxeyVSKexOjAfBgNVHSME\nGDAWgBT0uUqohU/UE1K4HSqQz1F83viXMjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIApn7mNzldtsAeSogIl/AG0be7EiFdJK\n9h2gn7QPnojqAiEA/Sj0CGqkDTwYdbxQx+u60QK1VBlXUgy++biwXfrHNv8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAclbdrqceh0ZNhqgLZGDZze9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nNzY0ZjMxMi0wNTNkLTQ1YWMtYTNjZS0xN2UyNjQyNmY1Y2EwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQiu1WGblKAweJEM0VvqrBuJ9lywwJAJdHtdOmTswucXlX1\nNYtkg+p27JcB2xmV9tmtM+HbKQyEhI78/FGi5468o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9LlKqIVP1BNSuB0qkM9RfN74\nlzIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAKfsmoNco5ON/s8cAODYYOxk8fA1tWKwYY+O981ZvCZ6AiEAuwE+AhuM\nnHYjhWT1WY2ozw7c517bh4qjWoiukd6ox34=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOTCCAeCgAwIBAgISAZJ6RyjXTZ1xIpNDS/vHtMhQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWRkYzUxZmMtZTFjZS00NTdlLWE0ODgtMTY4Y2UwMWQ2YTUwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjJkZjU3OGMtMjI4Ni00Y2E5LThjMzYtNzYxMzQ0NjMx\nYzJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGs171G3qRlsmkevTXwJxzdIF\nOrDlrk26ceCStY/7kuQJL0SmEncnSIDzge+wx/gyT6IZFu0IwZtSlGmWaoKXqqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR1+HGkz2sDEwlUlC/nxeyVSKexOjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22LImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgC7FnX6ah9lzMZNQ9sKmnexWN71Yb\nM96fxSazh5XAKb0CIF/hB74flR0sTg0XyGxFM+3IijhCxZzPHWmg/Vzn8akM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9451", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9451` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAV0wKkDvh5WSVL6g6FVIxvPMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiYTUyZTJlLTliMGItNGVlMi1iNGQ1LTY3MDE2NDYxYTdhOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTYyYmE2NjAtODEx\nMi00MDBlLTlkYTItNWM4YjFlNzRiNmVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEL1XduD69x6IBaybzwEtoralTsdWqPPo+ZE7LQfjbasG8kg7YHchP4T9Nlf1F\nw3ZR75lbpbUjlppNT6xyJnmC26OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0kU9d8BErPBA6ujWutxh3hL3OCYwHwYDVR0j\nBBgwFoAUBlIjEPTiArTArgMa/S0vU3OnJMAwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQDMl1Gc79wQY2NjTyFVoIFdiPwF\njv3geOBq5Jf+orwyYgIgVtFkz+8hrxKXKOSBioxlSmmo5fuBj+F/vLRqbZKzsuY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYYmD6gg93WkdOAtvpOvxYtOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYmE1MmUyZS05YjBiLTRlZTItYjRkNS02NzAxNjQ2MWE3YTkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATq3ts78vjxm1JoEwF8MoHbUzDE4K47h/2e+MVFdFQyjyGe\nSMg18PJe3fjSU3uymGY5q1f9yfpRyQGqylJKmzcmo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBlIjEPTiArTArgMa/S0vU3On\nJMAwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgNzNn49HQ7GmP5OkIHDYl1hfVpUt0W54dDufYK5yRFTkCIQD2yh3ZLVr/\nHjMz75TY2EmEPmwIMy5nxhK9oyQQFDRhLQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAYR1r4+x58jeQerB2/J+M2DDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTYyYmE2NjAtODExMi00MDBlLTlkYTItNWM4YjFlNzRiNmVkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzhhZTlkMjktZjhjNi00YjkxLTk4MTYtYTczODUzYzdj\nN2RkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzefzPrDSu6+TgLU9gER2FGED\nBHE+P6H2IbOfiNK56kTuQH2JardvhOKEsweRX6hHIJQxsgAwhUbJLxJviqzzrKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTSRT13wESs8EDq6Na63GHeEvc4JjA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22MImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKTLgf4IDtpj8ZcdL/Vav8fkfBwN\nU8uxgJCAO5zx7xCeAiEAtqGfoexohz5XWm8hzm2wHlTx5VToHiQi+8q1kwOOwf4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9452", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9452` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAS5/BKAFIaG3NIG9cV6KxPpCMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDhjNGVhMzM5LTRiOWEtNGMyMC04NzRhLWM0NTA1NGVjMmQ3MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNjc1NGY3MDMtZjJi\nOS00NTA3LTg4YmEtN2ZhZmU0MDZiOTlhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEygH18aQ8KV/ryOwPg77wscp9yUJcSE76jZqu6vIMtHH014+jbleVvbEdONA+\nL9Pi8jhnzY/4ComAY4GzvDTxZ6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQmiCEPfCCDRlCoOcXf0KO9Wx5xGDAfBgNVHSME\nGDAWgBQ0iP+NIqtgzRZLyuCSf3NtvPosjTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDKviXoJzfRrsb3bsFj88Lsb/ZKMxYu\nR8GGBy9iFb6HEQIgSLQaLEdFajXCePBNjvIvPJvOHSwsxq8PAZYiu+cYq04=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdJdOVtjg0NQH1B+XIJFkbqNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nYzRlYTMzOS00YjlhLTRjMjAtODc0YS1jNDUwNTRlYzJkNzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS7ZQ/yXjQLsefU3xbq9j7mMo7YckkENM2iekqawxlR2LgW\n2b4MUqTo9tcdtU1D2QUh2MujS2AgqBJw2y4aEAjro2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUNIj/jSKrYM0WS8rgkn9zbbz6\nLI0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgS0ikmUT5JRitgsZT8FCEYhfETRmtByZgy20WhJnXB58CIQC/DUtvGSLr\nhfQFVvNCTRtJq6HzvJ+pEUBJTKLKvEr2rw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISAc8MN5hz16V1R+gJ8ZUwOKs9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNjc1NGY3MDMtZjJiOS00NTA3LTg4YmEtN2ZhZmU0MDZiOTlhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMTM3NDg0MjAtZTVkYi00NTEzLTljNGYtNjIwOGE4OTEw\nM2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHLW0LSWgT+PgTvcDSgSu5o/P\nCkQWubCQkPryylyChP3giRqI/38I0Ckgx8GPdkAGj7J0bYTioeR6gc6rD4zrx6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQmiCEPfCCDRlCoOcXf0KO9Wx5xGDA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22MImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMU5KbZfzQw/PEfFZVexMg/cfqpi\nRiDKd8LHdxSHWNU4AiEAqV1MKEQeWETTSXR/ufdQUxyCXiEmrxp2Oj0mDOixoDk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9453", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9453` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAUahHyndCWB4BM1NpidC5H1wMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEzOGY3M2NlLTAwYjQtNGEzZC04NzBkLTE3NTAwMDg0ZjY2YjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWVlYTcxNDEtZDMz\nYi00MTZhLWE0ZjUtMDkyYWE5NjE3MmIwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEQ+NCyIVE3dJE7WJGhusNOuV/lBhBwDGdqMrqYqn0GXIZJwdTV3KsqBmNVerC\nicGTjErdDE2fXadGcFrRQ5nQnqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEN2Gu/NnWhjrDN3EiXf+PMv1wbkwHwYDVR0j\nBBgwFoAUybH7+hIPOjNOrMmQ160mb/Fb3LwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC2TVsGLitiubnNeWWqKQ+kQM/y\nrXB0MZUob0pg+oDVvQIgF9kpAcKGQr7u3v1TRjzPRNEj4wDHsXQWBoqcNG3z210=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUurAmdo3jvjc6OG5iRPqdiSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMzhmNzNjZS0wMGI0LTRhM2QtODcwZC0xNzUwMDA4NGY2NmIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQn8gdnaFtcvQApTFECOtjPGIJ9+zK/NmuK0a/qhonXw7jb\nALmDgxqaDKH+2cSL9OUk/7L3n0A9wZL70gLHStGHo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUybH7+hIPOjNOrMmQ160mb/Fb\n3LwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIuDPdVToeIuVDn3+q1QfLdDVuBW+jsGowbhtdigjArcAiEApiE8LPnY\nPB+vDoY81aYdCMZO7DL02tNENu2JNxzJKFQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOzCCAeCgAwIBAgISARB71y9s0KOYUDmAxCpPiIESMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWVlYTcxNDEtZDMzYi00MTZhLWE0ZjUtMDkyYWE5NjE3MmIwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkODI4M2YzOTAtMmE5OS00ZDJmLTg5YTUtNjgxNTUwNzJh\nYjMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyAEHaVqkWu/Bh2WdwZZgQo97\nMr9XKU1rDIbg8/QlZcoUzKK+6rFU5HJC/zd3a04F2x1qk0nXKWWjzrnTIGC5zqOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQQ3Ya782daGOsM3cSJd/48y/XBuTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22NImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMKsdw8dy7/pDHYgpYZ3K/qlTBp0\ncYzCDo/DkSVES6o2AiEAoKrxUyCvnna4xw2+Lt9LFL0adaWp2JiLMDYJkqVFr+8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9454", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9454` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAb1Hfmccksmro9TacFslC9HNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI3YTYzYWQ4LTRjNmEtNGE3MC05MGRlLTUxNDFjYTUxMGQ5ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYWY5NDNmZDEtMTRm\nOS00ZDBkLTg1NGUtMzQxOThhMTZlNjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAElHSvaJKBl5CC5k4vpCl9MX/etpijm/MWeRacxmYMaJzMGlUMAKqfTXz9PGRP\nQqg3fFjjEYX7aKRxs8LpcohQ2aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSQWGGGdoxMml7sSXhLj+xrv5/4HTAfBgNVHSME\nGDAWgBQKd5qiHxw68/hf0RGXpeTPV17ntTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDRpt8fJs364gLxRO4+hFJliEqEPmck\nDt8dlbuTyeVdYQIhAO0jvrui5zLWvDLf1widskNKoV5n7NMLTEeeLNMbwu02\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASk+XHlvYU6kTZNKw/ZHPa4NMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nN2E2M2FkOC00YzZhLTRhNzAtOTBkZS01MTQxY2E1MTBkOWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASelJsv2z6eFekbuqjW/7jB/A2lrYuLR6lReOCsSE0qQ66b\ntYo1iAD7dDbYAEohCTArjNVc5nJMBLQ1wgHSPvSoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCneaoh8cOvP4X9ERl6Xkz1de\n57UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAMzOJkYzaVbN9aUtncU3GRQn6lARAl5YvrjmIZuVD3IgAiEAmQ4iQyFD\n4nj7SLwrm6rDgjt3QLccHy98rK0jgMnTwzI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISASe3jLg5T8BdBgZAzvFZuk5BMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYWY5NDNmZDEtMTRmOS00ZDBkLTg1NGUtMzQxOThhMTZlNjk3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTc1ZDk1MmItZjJiMS00MmFiLTk5MDMtOGNmMDlkZWNk\nM2RiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE11c9BUMu+pXWznFNQhGuwCMb\n41Wu+iEPK3XzQGzFXHvo6aFh+NazSJbV5PwN5mQZ2/KMlHhfJTB8WM3F5QGXnKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSQWGGGdoxMml7sSXhLj+xrv5/4HTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22NImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgNqWn0mXd1i0jo24Hy9tN9zjriiy3\nACEGrNXnVSD9He0CIQD/FYmtzqNmrLIwVNlihJLDh6bOrCYGqmLdh8ztumhyew==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9455", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9455` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAYXvbiTbfv28inC4LXPFE/DYMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE5YTliNzgyLTdmMzktNGJlZC04MTQzLTEzYjRjM2Y0Nzc4YTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDNkYzc1YmYtYTc3\nNi00Nzk2LThkOTEtY2VhMGI3ZTE0ZTdjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHa6ql5BilyWBY/XB427cIfxxLPMEK295MCYsPC1tvpv1x7qzzdfY5PriE7et\ndG03V8jejF1r+nmvS8ghW37dpqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJIGp5KGCyRxkvu6OcX9tpn1Kf9UwHwYDVR0j\nBBgwFoAUigNQUdMfW8b5az6W8FH+VTrluZcwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCuf/FTUVSluzTkBFvV8AR05LMp\nNRdEICHetGwDyA/3MgIhAK0I1aJ9ZeCg4+dk80UTcbJH69zuzCrosXSdkOstXaUl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAU8ymM0Pr6Doh3+eMC1fujJsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nOWE5Yjc4Mi03ZjM5LTRiZWQtODE0My0xM2I0YzNmNDc3OGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATP0sOMTWnG2HWZf7ZAg/mH0vV5t42c0nE1tbR410EdxTim\n/YclrhldLhEyS44lLmca6zQ67uyorS9KoiUU19Rso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUigNQUdMfW8b5az6W8FH+VTrl\nuZcwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgICSPsYjrNGvOaLpqEumKwD4ADHnJswdRXaxNYdaeLtUCIFo8WX3nDpDO\nOMAwgEJKxAGYFQPsOxuioOAwb93XyZJf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAXUa0KwInKwTmC4SR//4EQWyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDNkYzc1YmYtYTc3Ni00Nzk2LThkOTEtY2VhMGI3ZTE0ZTdjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTEwNmE1OWEtMTQ1ZC00ZTE5LWEzYzUtZDEwNmIyZTdh\nOTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYBm4xk3HqK2CDl8vxLbGXOEl\nuXVJK0yrdQ1ljUflXIrBGl7PJec+A8tOzXOqnaucA8J3TftEPSRPx9b2rDHws6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQkgankoYLJHGS+7o5xf22mfUp/1TA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22OImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOK9jqZi8C/gUw+vpE3bjq2Exxhb\nQAjn9WXkUeL6P8cdAiAeTvGsh/FluOSNfzJllv1lN+lVHEj9ORy+UrUHkhHEIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9456", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9456` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISATxzExvXxBqj8CwO8HsgWEShMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNhZjIzMTUwLTViMDUtNGI2MS1iYmEzLWNhMDNmMmZhZmMwMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTMwYjM5ZjctZDk0\nYy00MTA0LWI4MjAtNjk4NDUyYjRhODdhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDfKr4pvgbTsf9m9ZK7cadHO9t6N8rjHDhcpeaqu2rGoDL+XBVaL9c6LJQ1F1\nyoMfrNWCc9YjyusJ/AUz9bmiZKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTsFx1shjmsWl64LAk+/GXDxapqLTAfBgNVHSME\nGDAWgBR4ky6m7sMy07RPdoAm5rnNUoOniDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCCcr4Q/2th565jU/TiePxi0fRphBIf\nTsn8jQi7TN9FKgIhAOe4GawFQ3cP8GsqwHkyWN8M8LeAWJVwE9kwPu6flnib\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISASlSJP4NAXtScqYVlb8zxGODMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYWYyMzE1MC01YjA1LTRiNjEtYmJhMy1jYTAzZjJmYWZjMDEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATZZa7CQsDGeWg32A3cn6TqLmm6l2wsbrd/izW2dPLfHGBZ\nArtkQbZl6wYBo6bjwyD0IHoskhGCuVJongk590Ppo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeJMupu7DMtO0T3aAJua5zVKD\np4gwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgRPN3Ptj9WbMzBQVSeAkiAEj0TZr6Oa28S6guLRT2xXYCIQDkWFqZGNsT\n8x/bMdBAwiRApD3YRAsu8GZr+peEcOz/uA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAZSjPFZYSch8uUCHBumWUgi3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTMwYjM5ZjctZDk0Yy00MTA0LWI4MjAtNjk4NDUyYjRhODdhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDM5YTA2N2QtMWU0OS00Y2M0LWFhYTYtYTJiOGNlNjcy\nMTE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENjnfPcW/CRO9w2Eq6uME8qJV\nCET9dpsGJ7hzqz3vOF0qmMXfBj54KYUoE8qArCKvdkKXjc6qZE1jYi+pjl/aN6OB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTsFx1shjmsWl64LAk+/GXDxapqLTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22OImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKGrPus9KbPmYi5RP/SYL3hJhL8P\nYA24z8/WfVNjADRDAiANlSY4Q2Rb135Rr3ozLQIrWEj/z9vkgBuVrBfBJMonpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9457", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9457` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAb2qaqFp4PxczknxvzgwAO6SMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDIwNjM1MjBmLTc3NmEtNDVmZC1iZWFkLTM0MTAzYzg0OWEwYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkM2E3YWY4OGMtNDVj\nYi00OWZlLWI5MmEtOWI5Y2YyMTZjOWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEiy2CKRshww6g/tLzR6McEQnOnT/DcG2KRWUVQIWNlFqKGGnCfIMuHdmqz9ob\nml/oq2Ba/mh8nVoEOxFnHRy29qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUnmuvlZdzaMiFJVVnw1Uywlu6GmkwHwYDVR0j\nBBgwFoAUQ0Bm9p4rSTfnYjYnC9aVmvNd4DwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEIdFozBFn6BhdlSiCwHEoqhalgU\nTeLUWo7zEKUZO7I0AiAciblFfgZ8UgJPHfFXpYjKMs/u4/1lX125VXVHeqtcqg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAaBG9Epi1Ly5uM6//dtujApNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nMDYzNTIwZi03NzZhLTQ1ZmQtYmVhZC0zNDEwM2M4NDlhMGMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARfuxQugkP91HCrZEegZxJ4tPemjUy3urFTG/hx3gKH/I7v\nW+DRrxTnVoIJXhRSTseJSK9chl8XaHgKG/L3VK9so2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ0Bm9p4rSTfnYjYnC9aVmvNd\n4DwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAJfZ47lDyj3IkKt3tmO0avnPmeMOuPH6oWj7sessr3YsAiAXSTQY21pi\nhnsqoY8Od3rmIv+8YM0Ss4+VbDSoHPwNqw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAYmNem38C+YbASWhN4AWXSxoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkM2E3YWY4OGMtNDVjYi00OWZlLWI5MmEtOWI5Y2YyMTZjOWJmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDM0ZDM4MjktNDdkYi00NDFhLTg3NTYtYTVjZWI5OWQ0\nMDdkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkrHGkI7h28Qmifj7JPcI3GHL\nFLE1ltAqqVKrxLh+tYsP4llAbd9SaYyALIBy7kE7+VRui8x+B7+adH1ggUSOWaOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSea6+Vl3NoyIUlVWfDVTLCW7oaaTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22PImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALQg1daEvklloznCnp+jMiTrSXC4\nNsYUY+8XCoOgAtw/AiAEnotO4L1WpaUzfrhjSKnUL8FiBLp/wirKKSw/XBOySQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9458", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9458` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAS++GCnBBVBc7s1u+yS+z+BJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4YTg4OTYyLTA5ZmEtNGY2MS04ZjhlLTgyNDY1MjQ1YmIyMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjBkMjg5MjgtZmU5\nZi00ODA4LWFmYWEtMjc4Mjk4ZjU1MDk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkQyzzI1TrXqq8e5PLG+rIRHQ9ITGOyfmVE4RRZ3+ja9Yf08be3qTDyhCgHmm\nMy1lhQ7SOayxZwr5/OOv/g7VSqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQu0YsuiaBCKs0UE+i5c3eYloVjWTAfBgNVHSME\nGDAWgBQHz40YV2eKOxKDy8V+793a1ph5dTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC4FUkuJ5UdC+Mbz7R5AzjjZzEjz+Q5\nSbpS2NHJRbFI9QIgPY8oWHUAkTst3CvadRVYY/yyNAgwuxYOrq43ptJkyvc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAXHYzUF+Zzchtowxu+lvMzUhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOGE4ODk2Mi0wOWZhLTRmNjEtOGY4ZS04MjQ2NTI0NWJiMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASutjo9Bg/MqtD+SVV1STdcKgSAmfMtHQDN0h3xwAMwm4AG\nQ5tccj8owAJuZlAcS6manUOr1kg+UGYhMkH1t/Xco2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB8+NGFdnijsSg8vFfu/d2taY\neXUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgE5G5kK6zprshvh69GvOvuLTCWmju2G++Lng6Xi1/6uICIQCRxNwvpY7+\noUnki8hoAtRrDFl+9mC9Kjo5tqCT+/KJHQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICOjCCAeCgAwIBAgISAfZ125w+ln4hKZ8Nol/tFff0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjBkMjg5MjgtZmU5Zi00ODA4LWFmYWEtMjc4Mjk4ZjU1MDk3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDA2YWQzMzEtMTY3OS00ODIyLTk1MDQtMzVlZGE3NGZk\nMjc3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECrZq/Dbzt5eTK+J/YRApOAVJ\nlWUtp9SgBvTfkxUue9wibr9O584FLPbdoDfHR1OM9vsEFCt2QNx78eZlVoWdIKOB\nlzCBlDAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQu0YsuiaBCKs0UE+i5c3eYloVjWTA+BgNVHREE\nNzA1gg9iYWQuZXhhbXBsZS5jb22PImJhZC5leGFtcGxlLmNvbTpETlM6dGVzdC5s\nb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOqRbhZwg4Lrn7jsCi5jcP5MMLNG\nY2t3yE07hga0QdWxAiBjh94zo4Y9evuhTeV0kq7/Bc2dz+s59r1o39BD4JCBDA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9459", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9459` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAbromkqDjdPVm1SPJl7BHmn8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDU4ZGVhZTliLWFlNmYtNDc4Mi04ZTdjLTNmODBlMTVhOGIyMjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMGQ5OTczZjMtMDEw\nYi00NjA0LThlMjgtNTc2NDFhNTg2MGYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE61GNYGlY95guANr8mbTm5pNcO2LDa/F12uGEkjr97ugZNRqiLOKd5xqgmcfZ\ngxkkw2lmeB+OHZQBbVglf4eTXqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2kiJ1X/dG3mMu87Pp5/GdzdZ6agwHwYDVR0j\nBBgwFoAUHiLOW2/Kb6FZ2OrvMYcaS3PLGyIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIEUshVl2xaV6F4KtBqyomVc1Kuc9\nV34cirA0aLrELhh5AiBZE2z1f0k9TPfNcGHNs4la+uFCB/WVYlvWCjoPnm6GIw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAfL21wGCbG4lSBdpVeuayp+yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ1\nOGRlYWU5Yi1hZTZmLTQ3ODItOGU3Yy0zZjgwZTE1YThiMjIwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASyqkUj/Z/ZO9jMTi/RF71wSb4qQLxRKG6CpoHvRdFK1RZ+\n5AfPs5/yigqMQ8x1n33wuHJpmRHw7Zv2de/2lwMZo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUHiLOW2/Kb6FZ2OrvMYcaS3PL\nGyIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPT5oLAjYW8FcwYXPgpln+tDZNmtdLdVPLkFy+w6PHqiAiEAsRvretdu\n6libYMBKefmlOleQZEhcpuSoelCQUdybWL8=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAXp0z9CB04hawtI/UL4y1GBuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMGQ5OTczZjMtMDEwYi00NjA0LThlMjgtNTc2NDFhNTg2MGYyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNzU1YzM4ODItOTU2Zi00ZDkxLTlkYzAtMjM3ZDI1OGNk\nMDZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjf21sQHa91VWBkcBfmDTL1ak\n6pGbN7mdoPi8CNKZgHn58AAawsMq2CrDyw4Zc5sBVoYNzq4pX5qT47yPrt69qKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTaSInVf90beYy7zs+nn8Z3N1npqDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22AKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCMTwMDRQMRu5mbmEgD\ndKWkfmvQhmA822fvFf2CQ/2M5wIgCwjVF5bcOTqoqBanbtO1OSvxWNzShY4XZLPL\n0OVbO9A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9460", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9460` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISASjkH+CCYPcsUEnSGZBfioxIMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDk0NGE5NTA2LTBlMGMtNGJmMy04YmI4LTk2NjRjNTBjNWZhMTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjY5ZDc4YWQtZjU3\nYS00Mzg0LTg1YWItMjU0NmQzNmU3YjFlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMv3plm+kXK7Mghyij2RYV4Hd/upRBQQ1wdmLXCEleTzmriFEFuxg0syIdmug\n0s6dr36qLXT0qaE+9ivgDpVjoaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ662IzS8ezNHY1jfC1rhQLEoYnizAfBgNVHSME\nGDAWgBRcLOK3NxSuQDfkVaxwm6j/93+cZTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQC2IdBPmdXxxnaqsjgpDbOUeJ3y52u+\ndFrMB46iMUu/jAIhAKc/+RFLEagtENfmjywkirn6lecNpqN7bmHn24MMeBE1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAajP3V5e+DJE9lIWlaDSOW0tMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nNDRhOTUwNi0wZTBjLTRiZjMtOGJiOC05NjY0YzUwYzVmYTEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATC1tSlcgy8FV01CZGS5t02Ga07yuiDT6Qg/to/5OYL2rPp\nK2ueA2+9queRQiIakdq/oOPOdGpY2B9wVRctb6T8o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXCzitzcUrkA35FWscJuo//d/\nnGUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKFMqiDreafgNaAHoFPY7HKzH5Rsf2vaASd+a8XYZMkXAiAYophk2tH0\n1uS/PF+lUHJMOYiMREs2AUUZHTBevm1OYQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAU4BA616DbVzQAOAJkdRd0Z/MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjY5ZDc4YWQtZjU3YS00Mzg0LTg1YWItMjU0NmQzNmU3YjFlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZTQ5MzE3MWMtNjcyMS00OTUyLWFhNDctOTBmNDJlZTg4\nNmYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4NSBR8BCAQxtGy+ru1ZqyQPB\nuiiaCgSEo2s6ecrUfR2k42OHvnjVzEmDmiPLgq5nR926JsfTP87HcbFyZBhp/aOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ662IzS8ezNHY1jfC1rhQLEoYnizBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22AKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCA34OxX0t1KUIujTr3\nEDV5qdyAkgwDk0PPiHEsQ2S+hAIgPIuGBsqqdya5YKCthNMCWqg0dRDnenfNEH7Z\nrPEBmaY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9461", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9461` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQJ0+ZOr2ez5GLr1LTIxy3GFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDAxMmQzMTk1LTEwOTItNDU1Mi1iYzc4LTI4OTdjYTNmODNiODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWNlMTI3MjItODU2\nMy00ZjU3LWJlZWMtYjU0Y2Q4OGIxOTQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9houCSa+DorH0j41I9sg/KL1nJbqo8MFFeAlf4UZ7g2rhJQT2E9LLoamHbSB\nEm/y6X7HMJe22ne49bKt6+hmxaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvXfAlftczYNt8Lh9kJAp/F7gZSkwHwYDVR0j\nBBgwFoAUqY1BWw2UPyABWaGSC6eKjzett7YwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDCOm5Ihh0eoyFNwuNiETmybqvc\nfQFwVT7Tqtkik2I4sAIhAIQxkV8aJ9zvTKQq/ZMOS9H93+zJPELv79vOoaCYvb2f\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYKAeCobzOUER36l3dWu+kHJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nMTJkMzE5NS0xMDkyLTQ1NTItYmM3OC0yODk3Y2EzZjgzYjgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS6yXTIIeRX59gIfTjeSUPE1/G8N1tnYn5K5Mzh3z+U1zAR\nqUOdqI4DJrW/w5x4GJV6mBudJlRvGoSBwtl/3Y7Qo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqY1BWw2UPyABWaGSC6eKjzet\nt7YwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI7A8RRmMxkkTrdrYu/u9lj880CdkIlRtTa01q6YcZyPAiB6mo+t3E9v\nwa0r4M5/PJf5b8ZkLjqEI/vj4N3UPrQyjQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAROE68rRa6gqyekxMZWeiFVjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWNlMTI3MjItODU2My00ZjU3LWJlZWMtYjU0Y2Q4OGIxOTQ4MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDk1NTA5MTMtYmM2ZS00NGQ2LWI2ZmItNWZiMDRjYzRk\nZDMzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5upOteDEiwbl0g0k0IIF0mOA\nCXNmnqTJSfs2O9wVlO+J/sMD5OZzTd4Rh2RGQcft9ZoSgIxsB+0yWhUbIF4i1qOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS9d8CV+1zNg23wuH2QkCn8XuBlKTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22BKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIB96TL/34v4MuiZ3yVIg\nUICmjN9bl4ru3l4xBbmKK/PhAiEA1ONHBmRdED2QNCGmRs2pBJuicOVuwqaKxtDw\nz2bnR80=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9462", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9462` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISASj/ps89n/zNP1GUlRx1bIioMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGRkZGQxZWRiLWI0NjUtNGZiNy1iMGIwLWYxZjgzMDE0NmFmZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE0ODk3OWItODA1\nOC00OWI2LTk3MWUtYWZlNzExOTM0MmM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEyO9wSNZj7dp7jNsa/V7je1TpepuWqK7FXr+pjkpdtOvRJmi50nK0ERhy9Rf6\na+WV6lMyZUejFucuywL4YdD7c6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRi/jPBsqF7CYDRcTY4HzWZF7ICOjAfBgNVHSME\nGDAWgBReqSqw9Kna4gVOC2Ch2PJ3GMxTUjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICmdQuK4soL72XKvaEjcKP9AGVaEAsjI\n4mTUDnvB07V8AiEA9RnjQI72lPWG0rJ2opE1dG6lIlbaZpfBHE+6+VtUhY4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAdHKFuHoXh3nPdBOdbR5BSFtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nZGRkMWVkYi1iNDY1LTRmYjctYjBiMC1mMWY4MzAxNDZhZmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/yPKys6Hgt+D6jr/BwIblsA9m3luFvWqGxhzELZZ/GLdo\niAz8sJh0eUoxGtR6bZ3Q0lNKhwde7u8ssZ2XSc3uo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXqkqsPSp2uIFTgtgodjydxjM\nU1IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgANl2NAbEtq13uK9isuz5Jv/JIz8H0WZRbc4PWWKzXNcCIQDKX2jfRCda\nEiyGC1eaL1hca0Zk3rqFANtU7OH+K4RCaA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAcvPpNO2TBnBuxvLV85IHivGMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE0ODk3OWItODA1OC00OWI2LTk3MWUtYWZlNzExOTM0MmM2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTU5YTg3NTMtMGQ4NC00YzdkLThlNmQtYmIyNjc2Mzhi\nZGFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyiZ1qKh+JcFLLv7AhYqTpVqi\nJ639Z7O1fB/jfOAU2IIEzqeYdv87ycWliUZdsADwfeXrniSWieWq9GnWGKID96OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRi/jPBsqF7CYDRcTY4HzWZF7ICOjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22BKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAWE63ASW+Ou+GLlHyUf\ntbIMw18jkJlTGVnokYr6SpTtAiBHdEkPF3ZXHQ26aB9w4jZjMLB/0iPFRVdRM5Mq\nHGhiNg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9463", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9463` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAQlAOv5IS6xGacHL8Al5n5P/MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDgyYzQ5NThmLWI0M2QtNDU1My04YjlkLTZiMzFkYWZlMTQ5ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjMwOTkxMDgtYzI1\nYi00ZTAxLWE1MDAtMzM5ODA2ZTM3MzY1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE9fsgzYoRxQY1lX+nBbUo7EqnKmfXTAS4f7YCZ2GITIpgIEP6Fq4J/EJdIfnb\ndPL5ExpIhIfOd/rHwAiWA3mRvqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUdW74U/PDu4Gc06Q8uf/SGS4ZOQkwHwYDVR0j\nBBgwFoAUalz4sMenUTaFoAF5aiDg93BLfAIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQDttVld8UhNjOgqgSb7B4qMcqdv\naHEajCujB78Zxu10igIhAOW0Pt7ddlH2SaISdx7eOQJtdICJKJ9TySW5hO607Gn7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAffTzTI5AsUMOOCv4MlXheTcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nMmM0OTU4Zi1iNDNkLTQ1NTMtOGI5ZC02YjMxZGFmZTE0OWUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASmWqFYZDXlXnj9yVEDc/Q7TNS5qJovdvBeFkyP4GePrsoa\nUieJtdc9HZWP2gQHZgP9SxFF3AAc3hyu4G8O47uEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUalz4sMenUTaFoAF5aiDg93BL\nfAIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAI1OEsP9w84vInUldN92FiSXMiSTOU7uInHMLZm8YzV5AiB5bwwiAPPN\naRB1vfX3HPp0DRxYw8z9ewjCKRhyQ53wgA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAcR7QaZSwVWZ6e8FAZJnCMLxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjMwOTkxMDgtYzI1Yi00ZTAxLWE1MDAtMzM5ODA2ZTM3MzY1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjBmMGI2NDAtNTkzZi00ZDczLWJhMzEtNTMwMDAyZjY4\nODBmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEo9ZZZZNW/3jk4F86VOR8CdXX\nE8xUEJzZRx273Z9QXMzuaGbB0jLu+Sma0+GV0KcZekH4mwFUc+l2ZiujdgBxzKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBR1bvhT88O7gZzTpDy5/9IZLhk5CTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22CKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDhdVjMjS5Wtm4/d7BQ\n2NnRfSZ3IfAtsbefSIjgR5IN9gIgHe7WrGMJ/PVqtuv/2dAtBiRVAPvQoJWM7u1Z\nLpfJxWo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9464", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9464` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAczTAHiMCg6cDDYLek4bYBw+MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZmOGFkMmJiLWRkNzctNGNlYS1hMjQxLTAyZjY1NWE2MzcwZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYxOWYwOGEtNjAy\nMC00NzhmLWFmNTEtYjc0ODQ2MzA2YTQ3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEa6/qNcoQmhJnG8WiZV0BWuea+BcpQ2X8yjeAOmES0kyswXqDnu0zDIM4ccDA\nGMMhIGkhyodmCHxWMjKB4iEF1aOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQF79G+WEj/lEtV0+INTkSpq4ayjzAfBgNVHSME\nGDAWgBSJf01DACc1m32pVNs8NGh1LaexWDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIBp8PXenanuDoVe0g+DpSwRmJ0ABE9OA\noeMsxnBPw/MYAiEA836rtEWBzkrflbaFb69QTOq9muQcqrqE12XR92UQHm0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAa+3ev19nVdInyI8rQ7bqJAJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nZjhhZDJiYi1kZDc3LTRjZWEtYTI0MS0wMmY2NTVhNjM3MGYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATNSI5z6slZ8GlxvxNpD2gw+BHWfP/jpaqspwqmM6KH9Yo3\nrJkUsPHuUF/DIOSDMtKKNyuzeITFTMh0tEzf9LSso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUiX9NQwAnNZt9qVTbPDRodS2n\nsVgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAKKOQHl5f4DNf/vTbxuGnl576osusklFHNoJtcwtrvq5AiB2Lun5ux2m\nzgOxLn6L4tPDxHmm1Wq044jtP0FHGGImBA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAdUtMtvACfOTMAosSDErb/pOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYxOWYwOGEtNjAyMC00NzhmLWFmNTEtYjc0ODQ2MzA2YTQ3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDc4MWIwYTMtMjBiYi00OTU1LWI4M2QtNWUzOTMzOTgx\nMzhmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnqz+GO5qSZ17zYRIpFMgud8W\nqIEfGx3zxmlSfc10A1kaDTrfiXBW6hLKf8hvJcJrFA9CWv+QfC7uhePpxRBg1qOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQF79G+WEj/lEtV0+INTkSpq4ayjzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22CKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBc4QA30Vz6Pqe+vrmaf\nL8tGNVT0GiqzVH9LxjvjlNkLAiBG6TF7bBlPONyGNA+nfERqi26x1fa65LSjtft1\nBxKDkA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9465", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9465` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAdL9TZHvn9cMQvbiktTs55AzMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ4OWYyNjk4LTNhMGUtNDM1NC1hNTU1LWFkOWY5ZmNiMGY0ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTA2OTJkYWEtMTQw\nZi00ZTYyLTliMGUtMjg5YmQxN2E3ZTA1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEkfBPWNBx2dyRxJjLVSiOVwwp0zkOmsRKc8WN4QOQoDyDA/8tpS9VRzz0mNQK\n0aLLlneThrp+IrcjH1YgP9sx76OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc689DEh/qsIBDZJDSdZmmGeIvi0wHwYDVR0j\nBBgwFoAUWPsbQ8vaZ7LJENID3hd51R4FgmwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQCzqw3fpp2dppEOlU3MMr0ckNaT\nrx05laKj04oCWm7seQIgCmlzLOxJ7o1ofMfL/R5PAe84S2yGWxYTqX8IIRE4fro=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISASxtOCruUD+EktkKv1+HPbczMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nODlmMjY5OC0zYTBlLTQzNTQtYTU1NS1hZDlmOWZjYjBmNDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATEpUv38frXweOtxyHypJMar8XgcyQxubb0DWtN1vnnJRwC\nNwKwook95wEA/HWAEcI0QxSvdptUz7lSMD26moA2o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWPsbQ8vaZ7LJENID3hd51R4F\ngmwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAO5VWzgV6CVqWutjoJPe6eUtNWY1E3W7Xyy2xlb/IK3GAiEA05R01Qcn\nN3kzUbfM5pcURAq+dMTZ3lYFBZZFyzDAhS4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAf71t2mjDQza08EUWnj9P9cVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTA2OTJkYWEtMTQwZi00ZTYyLTliMGUtMjg5YmQxN2E3ZTA1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZmQxODNiYTAtYjY1Zi00Njc4LWFiNzUtZjQyMDZmOTQ4\nMDE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzmOr3wvEcGmuoOKAC2Xn1qpd\n3ywbezggsPLg8K9/ksT0gBaA1xfJBA40MAOMCurm2A6HnsWyL3BFNQM6HuSbOaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRzrz0MSH+qwgENkkNJ1maYZ4i+LTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22DKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDgIQeYqMY4qteJ1+hpz\neV3zxCGWmQrWdx/KQK6Of7LAAiAhSGVpaCmudp1O2bLWJ1pF12ZcFvZOaf9uRdAQ\na052XQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9466", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9466` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAURrX1r7qgtoNLa5aDly3xkwMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDRiYWRiYTFiLWU3YjctNDc1MC05Y2M3LTE5NThmZWUwYjc2YzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMmIwNzA3OTgtNDE5\nYi00MTlkLWEzMmItZTVlNjRkYTZlNjE0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEIxhGslrMYX4t06hCJwbTq4u+HwHAq4g/Fy33/hxcyBqVfhqR//jWhYX5Gms+\n+Y2RZC3Bbfy6iKBiW2RcN1+TlKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS7Mjg2kSpZpGabELBq9UZC4Yh43zAfBgNVHSME\nGDAWgBQH60lwbbl1miQmy8S0jCTh2a051DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFmkuUOI9wnknRuWFnEIJ/I+BmsK7Fnt\njWst0pOOPz6cAiBx3sqAubaBazG5tb5oB944Cb/gx0HAUct5rKhTw8sLdA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAazBjuMJurmZO8eH4+3iPWrOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nYmFkYmExYi1lN2I3LTQ3NTAtOWNjNy0xOTU4ZmVlMGI3NmMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATJ5ASvFvAOMYyXK1H90CyKqN9VTbRZlVMxIaox9YLXl1Ot\nfFxiZVdiGVeHukwWbWcUiDI+LgoWg15/xQUtl9Eoo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB+tJcG25dZokJsvEtIwk4dmt\nOdQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSd5tB3zYxqIhDVrYs9xJPyozTHtOZF+WcoQrY7OvMbUCICt9nMAJNnp2\nivZANsKMHFHYtSiIPLOsL8DVvQD4LP4g\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAadbNBShAgo4xm3B9yG9T684MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMmIwNzA3OTgtNDE5Yi00MTlkLWEzMmItZTVlNjRkYTZlNjE0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWM0ZTBjZTctZjY4Yy00MjY3LWFmNWEtMDczNTRjZDg4\nNDc1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6sjwPlTmlG5t9C5BEOTYAz9Q\nJaLsqm5+KcDxIvUrDjZ5XtRRBTpe5YQybUs+oQ9YvdiG4AwuQ5sy6l/iVQ2B/KOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS7Mjg2kSpZpGabELBq9UZC4Yh43zBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22DKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAILZa2foIo87RN566gU\nSQlDoB6p7P/NCPzLfWeTsqo+AiBJKQrFtV4ihW+gX6e+RzlK7dm22I7NWmDTlKHP\nazKcIg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9467", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9467` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAVnhn45ws6mBujAg95LKpN22MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGVmZWYyN2Q4LTliMmItNDk4Ni04ZDJjLWE0M2U0MGRlNzY3ODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZGMyZmFmMjgtOGM1\nMy00YzgwLThjYWQtMzkzZTU2YWIwYTJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYLH1q0og7+1QdTAGLSuqKLq9gFZXKzLomRdaY0yXHHpxxY4IASW67XTOOCQE\nvA9AM3gD3IcLS9wYkaDIbpIX6KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMPNRQS2ONlKLXA1v5WO1zRGBrNcwHwYDVR0j\nBBgwFoAUj7T4nhLlIcxIEpcmlFTDDHigscUwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC+ka0Z7jgcJ/fKEefBKT+gLru5\nmMaaxvKJ6z/2QttkUQIgE29EsghSBJAjLsmwPzx5CV6WCYJoBUyx39QPDT8TG5c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISARKcFiYbJreCv1P6tzVpTaeqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRl\nZmVmMjdkOC05YjJiLTQ5ODYtOGQyYy1hNDNlNDBkZTc2NzgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARi54vhYVBxADWEEDhcXEji5sICi7QzhNiaLIAXFwu3J3OL\n+XUz3pqVVJY4fgr/P4Scb7aLHgTtELd9VXyOld85o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUj7T4nhLlIcxIEpcmlFTDDHig\nscUwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLqbAm0tVccv1ddu3RH3yME0PeuMlSsYeQO1ieP1Sih8CIQDyOyBdYhMM\nO/BHcFOEHdNvwBE3u5m9+wW7pPIJ21CN6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAQljgVmm8zHttsuSf18Jke92MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZGMyZmFmMjgtOGM1My00YzgwLThjYWQtMzkzZTU2YWIwYTJkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZjdjMDU5ZDAtYjE2Zi00OTIzLWFiNjgtNmZlMDZhOTQ3\nYjYzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnawy3fvQ8KC14EzOuULra+SD\ngPEEMCZsCDGcv0Y0bX/P27mOsLokQqXuuFkLFQ2NeVFxx0RoCvv56gMEiIZnNKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQw81FBLY42UotcDW/lY7XNEYGs1zBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22EKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCxOVsqUuvNRcYbRwDN\nFU8zSCqI6lKqlXneimZhEXMrugIhAO7jPeJamwyKPCu/IDeYskSvC3zQe9LmxixM\nyONWqUiY\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9468", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9468` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAS3npm9bYB6vP2BXHQVFD5F8MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiNTc1MTJmLTk3Y2EtNDAzNy1iZjdhLTgwOTQ5OGM2YzQwZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTdjMmViNTMtYzI0\nYS00YzJmLTgwMzMtNmVjNDQzOTFhZDExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEjn6/yJIpt/ZtU42fjFlIqqN12zxEquMcsOk85uXgCxIxC4l5cSKio5BrfF/o\nukQhvZ/qOHMdqs33fetcvpO4UaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTXSmDGFcjWIqOuPiFYw0/WteI6TDAfBgNVHSME\nGDAWgBS6lLjUww5vjoNRwwjsh7QY7hIhUTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDXFG7Whs9QXrrsc1uW9yosxvvbEFiS\nXPfhNEMd1Hke9gIhAO4dA1DNT5ptJ4kIPRIXUgj6azleadd7yIOqgkPgCEuz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUm6m9HAZ5C851Ze9N5jrozLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYjU3NTEyZi05N2NhLTQwMzctYmY3YS04MDk0OThjNmM0MGUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAT0/j70kvQLvCT9je8lYsAc+avcmq9oElg4ZGaIbboehnBn\ngY4++RnX+zDardtGdxZg1ttvHB5EmHM3KpwoQdgEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUupS41MMOb46DUcMI7Ie0GO4S\nIVEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgIUST2eGpOVOuLnyj9tL8099/09jEy2I1AL37slqzXqsCIATwKB3g2cNn\nkKguz12itgRHaNfo1SM19P6/290XuuVp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAQWHeYjyxPOHgw8CZcJwrNw3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTdjMmViNTMtYzI0YS00YzJmLTgwMzMtNmVjNDQzOTFhZDExMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMWRhMDdjOTktMGU5MC00ZWE4LWE1ZWMtYTA3MDUxOTEy\nZDRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE49LQMvoFwclOUAoHYxDcI/Mb\nMNpdhG4gTyQ2gw81HXlxcS9JD7BvY/ke+/VSUzb1NEO8rPYHDZ8HgcUp6rAH5aOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTXSmDGFcjWIqOuPiFYw0/WteI6TDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22EKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBFIk8DAdJ1PBc3xaRmu\nMYfmCUsKjHDUH/OtAWNRFCw1AiBAU/mffvAcSjNDXxxTJiGOXAdiKDsThwe7Dxww\nAZ91vw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9469", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9469` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAeOMupMDit4ZbffUhA2CAoi1MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGE2NjZjNzE0LTMzM2ItNDk4Yi1iMTVhLTcwOGRhOWE4Y2QzOTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkODgzZWNiMDYtZDgz\nMC00MTljLTg2ZDMtM2UwNzM0NjBjMzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEKEgasBiG7D0zgUv1+pL5Grlb7oYlLdet7FP7pHCwlrpQfhqI/a/kWKbdi1i7\nTGkAxLJWpnCRbTjiT9AxvRt9taOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUD8ThTRjpWR3stRm15BAs/8JOOBEwHwYDVR0j\nBBgwFoAUORitwXw8J9Lnsd0P4MErCUaG1R8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCID6TPcxDqNb/ZL+t1Uy8PzHERVrV\nlUJIoNluuCXKqAp/AiEAynN2jk8LdNRV5gdxuORhJPoWFqtKmuZPwDCYu5uiT2o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAZ+LyeY0mrvskGhVS3aLr0jLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRh\nNjY2YzcxNC0zMzNiLTQ5OGItYjE1YS03MDhkYTlhOGNkMzkwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASs4becZItwX0co8GLoFg/ATj5d0sm/RlODegB7eC5eX1w7\n7TxGXJ9z3IUmYrjL6NX8ukiJzkbQwh8lMU6fobxlo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUORitwXw8J9Lnsd0P4MErCUaG\n1R8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLykcxNUuSBIZC9c6H3YU/3QAuRe3v+bgihNLmARkZXoCIQDbmIISbhYB\nD55fNXKabHq4YutmkY7lxQFQ3OH0PaXJ9g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAYQabaEJyCcT7twJaeALBJKyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkODgzZWNiMDYtZDgzMC00MTljLTg2ZDMtM2UwNzM0NjBjMzM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNTY5NjYzMWYtYTk3NC00NDgwLTkyOTUtMjMxNjQ0YTUx\nNTQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAECrsavTy0DaURjYVy0tg4B12d\nhGvL04HGVdhwsNaC4WhoWc+rHDBEkNr+wAsueSx96oZnT8zkgCWxpmt6HJLkj6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQPxOFNGOlZHey1GbXkECz/wk44ETBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22FKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIElxtn60sv+Rk7p3kzcZ\nSOXj67TnUFScXM1xi5+qQRnbAiATErylrQO3Ep5q2H0vD79K8PqPqs5i4TRbCfEZ\nReMzVA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9470", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9470` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAYYvqa3WMT+Xn7KvQsmV1Fn9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDA1NGQwNjlhLTQ4OTEtNGI4MC1iMDgwLWJhYTlmOGI3NjlhMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTU2NDI2ZGYtOTQ1\nNi00MjI4LThlYTctNDU0NjcyNjk3ZDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBUREs8PAAEaWUXQX8rNBwUEJ+pA0De1/NwgQ2WsU7YvtAkEXX1vL5fA418ig\nxd4MA8zay0BJdxpnPCgwSwzGiKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSEy17iYDhe0jeaYANRAJK0EdGEajAfBgNVHSME\nGDAWgBSbwLHjwkrnTqEXww6VLRw5mnahdDAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCutcG2O+SGIM+6OnMWxDfjXWU/giLG\nKaPqUvS5Q5MHCgIgHEj2wKE5wZ/h4D50J2gL642bh3KHwmmrBTWAqNnC7AU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWNSW3BINkFPVjAyQO9rm0PRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQw\nNTRkMDY5YS00ODkxLTRiODAtYjA4MC1iYWE5ZjhiNzY5YTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQm+jj4J5sMUlmPbYfM4sxVR/vqjyOs4aGwKMX0+Db/8Wj5\nPPOsmZkI21fD+H9AGMBLWAU0Bl2VMDGHYe524VvAo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm8Cx48JK506hF8MOlS0cOZp2\noXQwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAPU/XBcMNtCUnyXtymk85SHpVgnrFEVrDdNi1GGR/KddAiEAhMiJYUD1\nMLANzhN9fvSgF2OQFW/9Yzdur1H5TEUQm0k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAUxcsdPhSwKvywgZqmo2KGGeMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTU2NDI2ZGYtOTQ1Ni00MjI4LThlYTctNDU0NjcyNjk3ZDk0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWU5ZGE1NzctNWU1ZC00OWE2LThmZGYtZmJkMTA3N2I3\nYmY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHgXr0bhW/JXReLnQfR55ibyW\nfqQNxDb1CYEHHOdeTuHwrRRiQAArSk00JpiLDGb/2/rt3gDtWu6wWIWgqsI4V6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSEy17iYDhe0jeaYANRAJK0EdGEajBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22FKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCLV+9Enp9vK+aHBtvF\n/RClzyguZInoA2neW7WxvF4ErgIgGq+536oczbMXqHSn9lc0LL7HYV+HYWuF/qjk\nQ6SvL/0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9471", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9471` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAYq/rDKo1/XA9a9MeHoVA8YVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDljMDY1ZmVmLTFhZjYtNDFmNi05MDhlLWNlZmY0Mzc3MTU3MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWE1MjY0ZGItOWVj\nZC00ODM2LTliNDItY2VkMWQ5ZDUxMjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHN8Omluc21g2RT1yS0X9GzuoHwPDjIbEBjujekOW+9+uLWsbYGTjJlvnOALs\nx63qXGfhIm1ga2Q7l2u2OaoJR6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPshEPtEdlF5Vj2h5Nfn27LGpv5gwHwYDVR0j\nBBgwFoAUFM14WLCsgVvn1avBepG1OAxjOn4wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIG0T58RhW1RdPUzwfyo8K58oirnb\nmsq2fZL+vEmQBvfoAiEAvpBV3NvfvkKpHGj1kfkC1CokcyA5xCQRhVhOLFctdS8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAc3vBWTb1lH0zW7EcO0O3QahMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ5\nYzA2NWZlZi0xYWY2LTQxZjYtOTA4ZS1jZWZmNDM3NzE1NzMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARRuJNfN5faOpFDtTyV0M2x3CYLaPNCXm6QGd4mP08/zQ+8\nNkZh5zTcp1MPj7586WIw2o5DnRami8MDULhu9PCEo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFM14WLCsgVvn1avBepG1OAxj\nOn4wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgSfnYec2xOh0eHuyukbtszLVSVqqel3x/tFce4TpbVEkCIAfsvyblJYeL\nq0YIGn3py7GbuZ6boCEt0sfnvYYXK0Kw\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAZW/JEddhp2EYihPcOVhLP2SMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWE1MjY0ZGItOWVjZC00ODM2LTliNDItY2VkMWQ5ZDUxMjhlMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWFkYjgwNTctZWYzYy00ODI2LTg2ODgtNzA5Yjk0MjU2\nYjdiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEd29QwvILvOnmV5yZ8LIeaHSD\nsV2VyfHnQVicZr7Y7YvHE7nsxKyqtyVHr27gvqExRZXgufQxaZHBiperiNI29qOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ+yEQ+0R2UXlWPaHk1+fbssam/mDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22GKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDUdXgv07kWGYKYdoNS\nxALJi7bLtYWyGRcLrfmXYgpX7wIhAPOitFRxzl8b3ZvNnEcAMXvxTdHoZrrtFMC0\n+AAlvYCU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9472", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9472` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVk7l5RO5uFPmlnyhnOuD/Z5MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNjMjNiNDNiLTA4OTktNGE5OC04ZGM0LWVhNzk3OTgwOGRlNjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNTQyOWJlNTgtY2Qw\nMy00YzBlLTg3MDctMjAwOGZlZTNlOWRiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/Us9PhPat29gf0jL8LJ/oNip5uV1YZtxD/ZEqWZ9eIkVt2WG0ehrSwC+GLBG\nN4YsNNxUZ5EGWqDalQnijFZoiqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQ9P6Fr+H5IXqAYC+hWF+b+vGlYcDAfBgNVHSME\nGDAWgBTZiQBUozyyrjLOiBJx4s5WDHIPDTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCrwYBGfI/YYNvp/vC0ldE41npshCcR\n9tOjYc3KuTsFMAIgWEeLu7Py1dcWuGnfDhogjSU8M54eYB/92g/traHEzlY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAbGNQ1NJsyqua9PE20rA9b0MMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYzIzYjQzYi0wODk5LTRhOTgtOGRjNC1lYTc5Nzk4MDhkZTYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQtFolwrz/8466yh7W7dWuVc2vimhwP7iVB463lSV2+HAo8\nuBJBu9Y6jbybWwDY7kibg/1CYZEmFN4fhypJi9PQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2YkAVKM8sq4yzogSceLOVgxy\nDw0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgLrA4M3KuQzBQBVKOqhh37z1Ds0zASygT4UTWkL3yArICIQDnwsKyuY/2\nKGKrwd+rpXUTJ1bvGtTJFC2ncDq63Wv7hw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAeBeLzixuECQOkEzALWRigNDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNTQyOWJlNTgtY2QwMy00YzBlLTg3MDctMjAwOGZlZTNlOWRiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGRiZmJiMTQtYzVkNS00NmEzLWFiN2YtYTQ2YzU4MGFk\nNWI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYCj72qq62ZPBwKzSKcCnl0m1\nhemyHNMSpDNgop6BpnnjkpVPNBqROlJLhSns06AdYixomvR3Xu0xxtgfKT/J+6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQ9P6Fr+H5IXqAYC+hWF+b+vGlYcDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22GKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCTWOu/EKI/lWRMb2ws\nAcOFtG6Jr9rvd8oEy+nzCnFjRAIhANqzIs18IE0VK5PCuFQAVcuwqfRhqtPBXwnX\nfPEJAAfM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9473", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9473` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAWzfmsVfJi7bIwbOpqOpmbsgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg5NDBjMmFmLTc1M2UtNDY4YS05YWIzLWJjMTY3NjUzYmVkYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzc2ZjgzOWEtNDQ3\nMC00Mzg0LTlkYWUtOWQzYjVmMDVkYzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAE/6buWaM10LWywBauRS5ACTwiZBSkka2ps3SdPUyNbuzDZmy96ftfV/pUjESU\nivNDi8bXewwi03/MDqufs8Thh6OBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5MA5ZxIdVxhU2P8JFlpMVwcUpb0wHwYDVR0j\nBBgwFoAUAl4Cm8ZSgbLm//+BPyZpWQl0F/cwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCRwu+YT04NwKtMkGGOCag5/ds1\nlp2xCycKlayKEqLtbgIhAJhBMaIQAsdv2QVEq2DeuvamTtW1KNxcXsIIqZ53g7+H\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAVMVBEExbz4FPDsLMFbpbHdPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nOTQwYzJhZi03NTNlLTQ2OGEtOWFiMy1iYzE2NzY1M2JlZGEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASykKUaFB5iBA7lbstITZ0jR5lUCem5x+ny+LwZimPaTwGH\nREd5IgVpLwcHuu9qL66YjZutQdhPZFqoYme1Mz18o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAl4Cm8ZSgbLm//+BPyZpWQl0\nF/cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPPB0zSvKzRUUur5ITe0BUOKMau2VgksW0p5dEZhRXJXAiAjv91QEGSx\nzVumHgqq8zrpKCkeaa2qW/+rWjHzqogGnw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAUaqgE2O12krCv0LRaT9V2gUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzc2ZjgzOWEtNDQ3MC00Mzg0LTlkYWUtOWQzYjVmMDVkYzM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2UxYTM5YzgtY2FmNy00NzZmLWE3MGItZjZjYzBiM2Ez\nNWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfwOX5PGueTzFj9aVCdSGg6cS\njpPEEAOhJAjYLiQGjWu8rXJZtaRjlrWR7RzGCtIbhU6KmgAel5EixKK9dY1Wr6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTkwDlnEh1XGFTY/wkWWkxXBxSlvTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22HKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIFAiRyMrp9QTz9Ffcsat\nydCGuQHpNnk1xN8Eq1dIyHQMAiA+ROIa38RsjP7gOchINVJxrD0Lu+a7VqlE7ECl\nuP99Vg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9474", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9474` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAeJdldobFP116vwPM6cPyaGWMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg3OTQzZjMxLTJiZTQtNDE4ZS1hY2Y1LWY2MDg3MTczNzFjZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWVmZTRmYjgtZTM5\nNy00ZTkwLWIxYjYtNzljZDA1MzY2NmU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEPLJ2ZHUHCU486Q7zqYxoj4H5OOTHNz7W3YIQhyAz3/jVOzRakY88MacM9Km7\n9/HQdpeKPBNQIPhz0XEt1f7wMqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBScRAI8RsXKXNjkNdjTJ3V7AWuMSDAfBgNVHSME\nGDAWgBR/1TVLkm4rmyD7UKy5VoFxlJnXqjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCZ5NKDWJFOfACzGOcf34f4X7gnMxB4\naxdv9MyItTmmZgIgIeZ6+AcIWAF8J5ySjG3gd6JA1HYTl645nZcTfSiZ6h4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAW9uKxONVGI2IEiFkLsPYsIDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nNzk0M2YzMS0yYmU0LTQxOGUtYWNmNS1mNjA4NzE3MzcxY2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAR+nWpogjflUnLnfiGv3JsFbtLmsW7YcS0/kZmJCQtrwYS1\n0KTeDwX6AVnhrhBl9MAs1MCbKss4npQnhgbfzfCUo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUf9U1S5JuK5sg+1CsuVaBcZSZ\n16owHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgU2YWCsVkRGHtTDYfyYIUrso0uanEpCJ+rgULubAmxnECIDS/wVWue5YO\nqXabC8gLgWhujuMgqoM2Q8OvBflwERlC\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISARcJYsYQm4zVwATGH8r4FkoZMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWVmZTRmYjgtZTM5Ny00ZTkwLWIxYjYtNzljZDA1MzY2NmU1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNDFiM2E3NzAtYWIxMi00NDA4LTkzMDgtNGYxMjA1MTk4\nMjk3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr0UEl5QfvL3MM1YzYh9xEuU4\nLI7JaecGRaDbpSbZJQOJq3lOV2qqa22gzPqWeB1AO1WFdG3vtHexrwwq9+4BhaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBScRAI8RsXKXNjkNdjTJ3V7AWuMSDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22HKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGvNgZnpR4sP1b3kRoPx\nbQaNIsNEh1IxooLXQ1IVdt73AiAi6uIT4bLm7B7CXlK+M9sziDBbgafuOYPzZRjX\nl5QbKA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9475", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9475` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAXfhLEXLOyMKUEyauDnlIwdgMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDg4NjUxOTI0LTUwOGEtNDlkZi1hYjhjLTQ4M2Q5ZDIwODY3ZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMTBhMDMzOTctYjA1\nNS00MTI2LTlkNmQtYTBkZTk0YWEzOTA2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYc5zUSpmYlkdTsk/vzDPuhNwgPHQ6beTjx5arTwTPJMrZAIQB8PWQNv7qFWF\ndUQnh+Fd8UJvK55U9jWBuhKy4qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbOrTQtL415TDF1DYn390BWist+8wHwYDVR0j\nBBgwFoAUVQuMUZ64c4GbOR8Ay/OfuLQPi2cwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIHy1tVJUPzA87DnAwfh0lZr/wJ/X\nWC767gwYRFBzlhDtAiA+o/T1zZAOYIRXQB84NOkA9yGvsBY1jdikA6Cgrqq/oA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAeBS+OCzl2WrC3ZgBiSJMi0HMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ4\nODY1MTkyNC01MDhhLTQ5ZGYtYWI4Yy00ODNkOWQyMDg2N2QwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQcH+GDPZoG5n+/43MVwJ44EIyZ4hrmAZb3zeahuxam8ddZ\ne9ruZVVOVLzAb3JQYhfRa2JlIwHCWZ3D/CrVZepFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVQuMUZ64c4GbOR8Ay/OfuLQP\ni2cwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgfbrvh/y6Q8itPFQ2xRykp+smoRN1dGrFZsszGji6b5YCICVHdx7hd3hS\nW8jTUjV3SwZAiIWVqwZitVWf+W7W9BwG\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISActVE8RmwzKV4S8wzJ80FrF6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMTBhMDMzOTctYjA1NS00MTI2LTlkNmQtYTBkZTk0YWEzOTA2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2I5NmE0MjEtNjE3Mi00M2FlLWFlNjktYjU5MzE5M2Jh\nMmU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEE0hsOtRcINKVvQJ6YqdFbhif\neu4nVIZ1SCFGFcFzsXSLcYJre8eMfuTzONWZrz3jVAQKWu7rdF+NCUBXT1okKaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRs6tNC0vjXlMMXUNiff3QFaKy37zBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22IKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCha0xfUHnfepzPnlwi\nQcmh+xhi9/moBD6tqDXSCP4irQIhAOaHVk7OsBgyjj3XyZ3bvOZWmu8nVBA+PNNQ\nJYOiuw4a\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9476", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9476` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAamevfgr1oIPEU0lsMROYbJMMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDE0NWMwNmRmLTA1N2UtNDhhNC1hYjljLWRkM2FmZTllNDBlZDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTE0OWFmNzMtMzQ4\nYy00M2U4LThjOGYtNDhjMGQ4ZTc0NDVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEdYHIBXL6jat4Zu9udc0j+Demuwpfr8KY3vYYuyw8vuirjO+iOUHOLWgzPBwz\nEMrmicQIgWF4Hk27R3PHQf6tbKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBROQA/BOavSag+QsVokkCtJX1MEFTAfBgNVHSME\nGDAWgBS+3xBgAvudPsWI2VPcmhGkvtmfgjAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBQVUZXwNvD2kPU+Q7d4xWIfocVxa6iy\n0nvdmnHCInbrAiBfOz2H+AJmFvoZD+BopB5NPW7TDI6bXuL0ZqNCEKDBhA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAUdDgiXj0o+zXPzGt2SfwueNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nNDVjMDZkZi0wNTdlLTQ4YTQtYWI5Yy1kZDNhZmU5ZTQwZWQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARS7AJffN3Su2rXhqG8xjw3xT87qMU/2jZvUXuQzVr03y3B\nyuZ55mBWYqkNEIRvUzwJO7rRtSHWOpzgpPt13i7So2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUvt8QYAL7nT7FiNlT3JoRpL7Z\nn4IwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgCm+WaZ01e+rtUYRTJUGUreSr04NG6TjwNojP3zTG96cCIAEyECv7VhuJ\n0xo00mMXB6Pt8EX9UBUILaFLmlhJzp9U\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAf9UoS0qnvj2qQ3Fz1fAm2uqMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTE0OWFmNzMtMzQ4Yy00M2U4LThjOGYtNDhjMGQ4ZTc0NDVjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTIxOGQ2MGItNjdhMi00ZGFmLThhODQtNjE1M2EwOTAw\nMGRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUpDWBftvlui50gicNdK+UirU\nekYxU/IfoMGSuzTgahPnRN1v8CMqWWAdD5RvKNIsjwPGZgeUNR41IZIQjgSl9qOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBROQA/BOavSag+QsVokkCtJX1MEFTBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22IKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCNPQRKGHgCB5m4Eq/y\n3+6Op+Sxcqnj20skAcrfPdNIJgIhAJVILLqSz9OTptcz0VQrvI2r958J4UTlx5on\n5zTTpmNE\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9477", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9477` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISATbiAOpg3YLeufGg8TOK4KFAMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDY3MGMyYWE0LWJlZmEtNGE2NS04YjI4LTM2ODRiNjg2N2VmMzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZmQ5NDZmYTYtNjVi\nMi00ZmEyLTk5NzQtZWM0NGJiY2JkNzE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEMpchiIe54sE4HQd0MKMD9N2OrHO5wBlWzxdBWYKTHv9ZdJODv3ayGgTseB6M\n79/kUxLwrzFaU+N/KJ0dNeWstKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUihhPIAn+rg821d5yBjj5c+qBnrwwHwYDVR0j\nBBgwFoAUWZ6/V0UxpGWx8Upn5XwqegiZ3sgwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGPmm1yE1oqOc3Kz4A5qeAtEAgur\n7XrGI5G/gqOO4J/WAiAJ8cKDaeuMhoMWCEGoys4slwB09YBAuvaOWt3xwezZZw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAWgq8+tghs4LKhMfF0ee4mIZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nNzBjMmFhNC1iZWZhLTRhNjUtOGIyOC0zNjg0YjY4NjdlZjMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARGU780Aw2Ci/brADHctXvuKtL3uwD+ztf1dsO6i5nU5Lf+\nBf9kZfxqhLTaJE7mGM4GJ272OD8/1jHYJpC/JwZjo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWZ6/V0UxpGWx8Upn5XwqegiZ\n3sgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJ/GrlhKizexReaH2ALBr+XhY+RWXw+msFnKdsYzedNHAiEArG1/pSbw\nEP9lD03BgkUgre+fh7TrYXvjZ8Ppsq7Fvrg=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAVmZ3vQPUgh0SMDRaz1l8By2MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZmQ5NDZmYTYtNjViMi00ZmEyLTk5NzQtZWM0NGJiY2JkNzE5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMjdlMDZlNzctOGY1Ni00YWExLTk4NWYtMTRmODRmNmQ1\nZTU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/j+gKwMs06+9EB+vIY4TOOxp\ndCYaPgOIJNQuoP+Q3qWstB8kq5Ta7SOOVdjP8N9+t5cvUHZGnIQw20zkeQg+JqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSKGE8gCf6uDzbV3nIGOPlz6oGevDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22JKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIDXyndod+v0Rx2pwzxOp\nI32NirNHqjpqso9zd2smEgLbAiApXM/ZmQ/Gvl+hY/OGkh4lu1CcDoX6b5lgpX9F\np4gsIw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9478", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9478` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd6gAwIBAgISAWwYvmEQe+CGNS4F7sl7eHprMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDI2OTJlYWRkLTUyNTktNGNkNS1hOTEzLWVmMDQ2YzEzMDQ3ZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYzMzODhiOTMtNmE4\nZC00NThlLTlkNWEtM2U4M2NlNDJhZDVkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXzpTspRcf0i/Njk3m0xViqtbBJbXTix8yuz7HWp1YhQ67Gfw6uYASKbW4Icd\nZMXAK2YcmhPGxByL4HA9Ib2lTqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTbOHB1AEoCRTKQio4wBDvzAT4o+DAfBgNVHSME\nGDAWgBTDqNNQX4PSu7oYaAuU8RJ35kQ1+DAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCNH4Yfc55+I9x1uzUGn7I0hVYCoWqs\nBOPR4jBxWaZYdgIhAJ8YiBWNllAcyylIyLkwM3vMpvz1JeXBagx85m/ewsOi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYh2YUARGS1PL6O6JhWz8O5YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQy\nNjkyZWFkZC01MjU5LTRjZDUtYTkxMy1lZjA0NmMxMzA0N2UwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAASPMCsgPwJLtFhRBuWEDLsMjD8E8wH5hgN970iM1FoRqFnG\nzNkNJhm5fviTP/c+NrLnXswoXWbmT+/uUT64vTxCo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUw6jTUF+D0ru6GGgLlPESd+ZE\nNfgwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgDRKW7fRx24QakSJwrFeemR3Za398K4LkpMFC2HexknECIQCKloLKBIRm\n2Ck+RrrvK/pzmGfij8J6lJOQRN+gTl+l6Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAajg4nKTcFo3ft9qh5IXKq1+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYzMzODhiOTMtNmE4ZC00NThlLTlkNWEtM2U4M2NlNDJhZDVkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWY0YzZkNzAtMDUyMi00MzZiLWFjNTEtODU5NDRhZTFj\nZmE4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcpHjczVewrzrZOmY7KrkLsnc\nii4gdsx0LoHSKnvLjU4mX7ZJvvUwDJvbc7SD5DLLslOyb/aEvzJBa4ToIZKVAKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTbOHB1AEoCRTKQio4wBDvzAT4o+DBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22JKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIBOTVIh0PDEt1uRK9Ob+\n1g45WvM+DStQUB7JgR91KzKpAiB3UTnHUoaw5zdRAjw91qquWaweGp4F0YyGHKb3\nsOMggg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9479", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9479` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISASErvnk+44OAuW+fCxqLE7jhMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNTEyZDZlLTU2ZGEtNDA0NS05ZGRhLTUxNTQ1OTE1MmQ5NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNmQ2MGZlZjUtMDM5\nOS00ZmU1LThmNDEtOTQ3ZTgxNjM5MzM3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEDDwee+YbMZQQbQb62Nk3GI3RTytYRwZVzMtAFZ0znQDjK4KwisbAMuL7nqZD\negxM9OsGG/umYX4TZgpqhbx2gKOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmoXDFtHzlFq3lAPknPUSm7wsio8wHwYDVR0j\nBBgwFoAUodJ87SwagPXQ6Z727f4+nO/uCXEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIATjZTmR0eWj1DU7mW7alTA0xO/k\nMWsZQelrRIJlUn7TAiABsHj/xdJHw/Wyem1/K10MzTInYXWIQbQy3rOMmQBWlg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAd80TwHFX7WHYIyCfEXib1FTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjUxMmQ2ZS01NmRhLTQwNDUtOWRkYS01MTU0NTkxNTJkOTQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQxlyLlcMDB26VoIkPoQL0KOaf/ZLNJzdHI0F82OPuyxmWv\nV17OHrEDh2aDY1INtAcujJ3/fEXPXsFwoegC0MJuo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUodJ87SwagPXQ6Z727f4+nO/u\nCXEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI5aRzJxr393RuxfZR205quj41Ml17YKmQHCOndX8xM+AiEAt0fGtMEJ\n1LQe2YRZwwFcF84AoucbYzehpv2skW2bMYo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAcWrTGgy8ZS14eRGsU0GQ9V+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNmQ2MGZlZjUtMDM5OS00ZmU1LThmNDEtOTQ3ZTgxNjM5MzM3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMThhZmRkMjEtZjY4MS00N2U1LTkwZDUtYzQxZjJjN2Zl\nM2QyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPgXaMRrCzAOXmZb+WufRsXtF\n2dMCple1soGfQrzL06VKXb/OerqRhbh78eyFZTfgXkI7ZB3XEQZOQM/LEHHkzKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSahcMW0fOUWreUA+Sc9RKbvCyKjzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22KKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQC5Z7hCpUYxRFJGbsqL\n+mJm73i4x1yb7++5IlKXUEqZFgIgb7XJZe10ZxoStmMH+/hteNH7Jj2C/doNKsXC\nUZvEvKc=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9480", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9480` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAe64o0ehcL2gOsi22fpLZPFtMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ3Njc2ZDAyLTI1NWQtNDc4Mi1iYTU2LTEwMDY5NDkzYjgxODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMzExNTRiZjgtODUx\nMC00NzY4LTkxOWQtMWM2ZTZmYjJiMWU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEzI6S5jis5VN2+KsqbMK4xAZzpudRuCbDcAVIuWs25pYO6AJzPLkgdkAZB0/x\nLKihxqHvEpWXHO7YL6HY3QsIP6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQFhK/SH45zYAXXkmwWGBDHUPeqGDAfBgNVHSME\nGDAWgBTGJZi6hXUg/usyxTpcDk0/6kjR4zAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGzjFetbgnsKILQsQvD2bQ7OJdowNScj\nUjoOTCpNLgt2AiAB3kR3wfBUo5G7zYmsyGqzC4FVncMR82oIGY3s9p969g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISARAWWGkljupIZLfeQff6uey5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nNzY3NmQwMi0yNTVkLTQ3ODItYmE1Ni0xMDA2OTQ5M2I4MTgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATCLko1Ra4VuAtC7aXjzL3eWgnFBG3FLi4syJYj5kqHaaPP\neyZ0EkEkrwWTkk4stpvxYPn/GeTi4yB0dwUa1c6Lo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxiWYuoV1IP7rMsU6XA5NP+pI\n0eMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAIz6kdwg4LAUwzV0EfoGc73JtVtlbO2n75PxOZqSMXi/AiEAipEWSRJP\n4Qr1PFu7ujABJ7QIaGtCsIyCITDVw12/8SE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAWGD/U8MGY71MGwcAqhJafm1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMzExNTRiZjgtODUxMC00NzY4LTkxOWQtMWM2ZTZmYjJiMWU3MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWFkOGQxZmQtMDMyZi00OGExLTkyMjUtYTk0MDhiM2E0\nZjZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHCQebh1HRZItcgHmVhP8Li1t\n89lifHUqJg58f0Cn+154z8kdPMOUni6aQ1AmpYgFGidfoo9sP4F7GXt7bI4tYqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQFhK/SH45zYAXXkmwWGBDHUPeqGDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22KKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDitnLCjRvfb6leRMwV\nydz2lcGJsP5LUCwQESfLxgP9UgIhAOW/MDaZ2gBHG2yKb4pAIQh9rpZeCvZzkEPE\nLNnM48PB\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9481", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9481` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAY5Vv78xtaUKRVl1klYudZKVMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJhOWUwMGRkLTllY2UtNGJjZC04MWQzLTQ4NzJjYWY2ZmMwODAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZDI1MGU3MGQtYjVj\nYi00ZTE2LWJmMWUtMWFhZTM2ODhjMjM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEBQ2ljXX1w6I2ETCEVFvR2y/Ed89wT58F0whmwgjZhLfsBYS13giVQPmAfSpF\nxbXwaBPBJ4ATL1bmaQvqf/Nt5qOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUG4nQ435E1i6TpbI86PjfeVuIqY4wHwYDVR0j\nBBgwFoAUR+RmQJeDInB5hu5MNS6rZYV0dx8wHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIQC2WAzknco4mCyie8m1MkohTCEB\nbsgzx5I90hnIQpkheQIgR7ZmVVakOZJxGbhyyR8FPusFRYXibT4sEEpyROmPMT0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAeCfdfjpLuodGdMeswzNh9bgMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYTllMDBkZC05ZWNlLTRiY2QtODFkMy00ODcyY2FmNmZjMDgwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/DRGuNxoHdZuSwsa3I+o9dJKD78yIvuNhQaBuYnwqj7tt\nv2KvBfzZr0Tvc76b9zTdRKISOpm48wpovUOAGp0bo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR+RmQJeDInB5hu5MNS6rZYV0\ndx8wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAMJWlwdgTFEbHRozlQJLPn+yOaFs3A6wtH9WfU7L95TkAiBKigTNmGbx\ncRGWcPgM4x8O1tPEsqtu8aJch07bY3ifKw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISASUYCXeivWF9y3gdklUGkDnyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZDI1MGU3MGQtYjVjYi00ZTE2LWJmMWUtMWFhZTM2ODhjMjM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOTQ4YzQzYWEtZTQ1My00MzZjLTljZjEtYzFjYzc0MGM5\nY2Y1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBw0aR916VCXHCUYwBRhr1T4M\ncgW0GAklRG/8T11jgG0Wzkv64PcqoaPIiO1Z5ZmLZuNvywGBE/Jiatagrqr7+aOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQbidDjfkTWLpOlsjzo+N95W4ipjjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22LKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQCC+H5/WmX0x7ZCKOPP\nZVVqonfHQ3aX0YLtVsheVLDHVgIhAIagJzyirxZffSde10k/HwnbTOjzYCXOXGP6\nToyKRwt4\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9482", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9482` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNzCCAd6gAwIBAgISAeE4I6OeBeLwXtnhLcmOdnYQMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGJiZWZkZjg5LWM1YWEtNDA1Mi1hOTE3LWVmZmZkNjFhMjllYzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMjYyZWY0ODYtY2Jk\nNy00ZTljLTljMmQtODU1MmQ0ZDNlNGYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAESTa3Oa5SBr2V+qGBg5SCnOP2HRENN/F947ZSc5/Q/i4mP1F0KF1CeVLGbqkS\nEixtqwpkxxOuXNxnNScvwxi/c6OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTw5FGwGM0aEOWIFFafKdiBHYyLtDAfBgNVHSME\nGDAWgBQM5cL7mL8+HnvXKojTho2VVD1SAzAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIGe9rAmfcF8vMbfGGoJIz4HOYLx3zBw3\nXb47AKNjlFLBAiBfwBSUORtGLd7k733a6rfIcFvJK2M4aBaWw59ohNFm+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcZ8/pdbQUX0jIevwEbSHYoSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nYmVmZGY4OS1jNWFhLTQwNTItYTkxNy1lZmZmZDYxYTI5ZWMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATWVP1sDsFg/hynmLGKV+KAAxe9NCnaokMPCedDK/wt0Aw5\nycLzh37PVOGbdtpctlh97m5YPJ/6jFxRJ1ZZh7JFo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDOXC+5i/Ph571yqI04aNlVQ9\nUgMwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhANjETlVMYvBi6NIMZU4vIMPyRodI8g2fPVMAbvUxp4DtAiBQvxCPnTb5\n3HJNbPY5tuOS5ISq7xpCN7T6ofYyd/C18Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAZ1nJpf+3wIUaP9A+Ue/bvYKMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMjYyZWY0ODYtY2JkNy00ZTljLTljMmQtODU1MmQ0ZDNlNGYxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNWIzNjNjNDQtNTM3Zi00M2M4LTkwMjEtY2U0NmY3MDI5\nNzFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEcIKl1Wdt2VKOTNN2ejeSzRA7\nqPxPFtXY28cZtCQyneSCU7foMb3I47ioCLF4xhFHMW+N/gkgbi2lLKd05wqSO6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTw5FGwGM0aEOWIFFafKdiBHYyLtDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22LKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDJcTfkIVxaMeallYAR\nQjTcMKWlKAk7oW1jeqI1610BtgIhAKmk6/mk/euHkPKGBC9p3fOtg1WnG4elcTFi\nC6DxR+T9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9483", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9483` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAeLICvqll7EjwyGP2Rm2Y6oyMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDEyNGE3MDkwLWU5ZGYtNGQ3OC04MGMyLWZmOTI1ZjViZjg2ZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYjE2Nzk3MjQtZGVi\nNi00YTNmLTg5ODYtOGZlMmZlYTY4ZGE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEByO378Fhe4pmfY7ubou1MQw4IR5Mg6iFFdR0appEzucuWOS/aIqsOjPgj0lQ\noSx0nxR8P11oPelvfPmYde+7WaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKhgJYsNeQH/4rOfYCaunYWFUkBowHwYDVR0j\nBBgwFoAUCq0fW5E9heZDEZa+p1tiaclBKPIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGSjhb/a/DFqc+o9CIEEEuD0qHHS\nMWGov5AhiTsPeh88AiB38FuQx2WxYyMFFkac9doU8H7wS5fH1tG7WDi0V4SYlw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAUMYYIg15HbCGrR4c8UEhIihMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMjRhNzA5MC1lOWRmLTRkNzgtODBjMi1mZjkyNWY1YmY4NmYwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARF5t05xUp95VyIL4Se7NXgxR99K1C311LTpXWIA/+HCrb9\nWjYzJAup3WHmuPKt3smV3WpGaOZP/DAR1eIl4sHNo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCq0fW5E9heZDEZa+p1tiaclB\nKPIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAJQXVQDsbPQ0YHDZbyqrzfO4EwofWz0QoXXti2evAbMtAiEA4/0uNrjy\nQptOXJEicTnxD0FlOfbmJZ8HobK4AenqN5I=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAeG1WercM/9EzKS40jJVH2aDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYjE2Nzk3MjQtZGViNi00YTNmLTg5ODYtOGZlMmZlYTY4ZGE2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkN2ZkZWQ3MWItMDNmYi00ZGQ4LThlZGItNDdhMTVjMGIy\nMTgwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ4LHn4Mx7iabV+H/uaEYi1fX\nH9iCAwgooK2fBg9qwMrnbuMCKtz0QSuHPUQv98sM8w4IGqxyq6Br/YccIuQRfaOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQqGAliw15Af/is59gJq6dhYVSQGjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22MKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCICI3Vw7wC4ukXidadtyp\nh8Gvi0J/VYRrj9llY4HmUirzAiAwk5YRqJYJiDjjMVrmrEral9Z0Pqr9+sLOanTx\n1uBqVQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9484", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9484` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAR2/XNAZuGFzYzPZIJyFMyBFMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGIzZDBmNjIzLWNlNTQtNGVkZi1hMTI5LTc1NmMzYWMxMGRjZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOWU2YzI1ZGMtMTlm\nMS00YzNlLWJlOTctYzkwMWUyMWY0M2M5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEHjqSpvkSDRIQjUZE/ruwhiyQbZIT0NJcz70h8ZIkMXbXdBCdLp+Ce+5m8TD6\nOcYt0lHO05Jc8p3g6N/xkUBgOqOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSVN9VluVub1z3rFQGg6E5mygUTcDAfBgNVHSME\nGDAWgBTXathfOGh3SsKTKLgSiD/0xdajVTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCJFe3HqnU3auDnX7qSTSBsEyJQZmEg\n8rZW+T7/4cVkGQIgMoqfzWauHED1YayQe9xoYEaFhzqEVwi9wkRPi+JHv+c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJjCCAcugAwIBAgISAYqJluDNCqadcq3qKOOVfvweMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRi\nM2QwZjYyMy1jZTU0LTRlZGYtYTEyOS03NTZjM2FjMTBkY2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATxnjRjepG+CVZ0rM5w4se1URD7b7qGbcGtZdhWdVoXWTBG\noutDZVK0OmAm4MjBX6/R+/eAcX87BV9ZZ5swz4gQo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU12rYXzhod0rCkyi4Eog/9MXW\no1UwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSQAwRgIhAI9l2R1VwW9tvK8oDh7wg84bqGQ8xrVS91+oOxgCOW5MAiEA7TvpzyVK\n7Nzul6CslBoTxxXqZDs4S7eZf+cPotYPxlE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISARgcHsDKW9svmMDquR3oZblAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOWU2YzI1ZGMtMTlmMS00YzNlLWJlOTctYzkwMWUyMWY0M2M5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNGNiODBiNGQtNWY3Ni00ODRmLWE0ZDAtODg1MTEzZjEz\nYWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzalUFWgg2nUt7sfZM61cBQdq\nm2YGTChlauSoeATuN2WUBWhyhAbZAYhisewSI5IljVSioiP216Xy18zwpcaKM6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSVN9VluVub1z3rFQGg6E5mygUTcDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22MKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAyrjL+D4fC1tefqOdk1\nIz8A9c8NFP7BfePhVfLWn3G7AiEAoHEa3sAmExwRKOkb+dbLlDJPYZlsPyU1lH9N\n8BWmP/U=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9485", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9485` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOjCCAeGgAwIBAgISAYFxIXDQCatHMV0ycRJZkzqNMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDNiOTFiYWFmLTY0YmYtNDAyMy1iNDI3LTEwOGQ3MWU2NmNmZTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZjJlMzYzOWQtMjI2\nNC00OGFiLTk2ZTEtOWVjNTU4ZWI5MDQ2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYKe1j6qnw2atg3wwmEi895jq+FBRvw6a0cGFy/XB4cO/d0tY+zzwqzuuFpA1\nUD0qb8uXmVMq9Iv3T+LP65fTSaOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqNeDcsYXsUW6G6uFMyUGazo0xUQwHwYDVR0j\nBBgwFoAUcteRlJUqMcdQJUDib+E2kIY/lJwwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCIGba1cRrF+nXV0v/YhaW/a20Sk3d\nC31bpXTHgJBqmsXMAiBV7lEDqdcorY1PI7iSoecf8PDfuggOp4nNB+yVMfZSNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAcR4UKvuQ5otuqQfomlHQm4+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQz\nYjkxYmFhZi02NGJmLTQwMjMtYjQyNy0xMDhkNzFlNjZjZmUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAS/QXUnrscG+zi84GOtvOi5szKfrKeruQuu+gwpNAhvTCee\nFZrE8d40WAqC0yUxt0gXZn7YcX5sodhkW+R2/RiXo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcteRlJUqMcdQJUDib+E2kIY/\nlJwwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgfzaYqqcR6lZCMfPOV96+vsdgAKSa5idF2WpEvxU69cICIQCqQJ9NOhZX\ndi+d/kRDBWCA4QITMLemYR+TkgwtlScojg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAZwTlnKcJGP+Kyay0/0NFSl1MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZjJlMzYzOWQtMjI2NC00OGFiLTk2ZTEtOWVjNTU4ZWI5MDQ2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkNmJmM2U5ZjEtMTMwOS00YmFjLWJjYjAtZTNiZTE1NDVj\nNjhlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERPpDZnfLmmCzk+BUVSvqGu+l\ncnbhrw+4ffyhbBlpFoeSaJa9BemMzZvb6bFl2bLedV/0va/Mi5DK5rt0RzbFv6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBSo14NyxhexRbobq4UzJQZrOjTFRDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22NKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDsNkpFXBdQJFDtR7Nd\nF5T7TDNfG5lZD4BXLgObbh1TmQIgS6XwGaoDMXv44zY3MzLBv4OHK1tTeAvLJEn4\njk3uPa8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9486", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9486` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAVi/RhiU1U6YK8jFXHxee9k9MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGQ5NGQ3ZWI5LWYxYjAtNDdmNS1hMzYyLTRhZGIwYTdkMjlmYTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkMWUzYjAyMjAtODA2\nZi00OTNmLTg3MDEtY2ZjZDQxOGYxODAxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEVJzX+y3PsUKYPT9RQwgbm7JB0YYf188zd21MPPHJNaATLgyy2zezxQtIrthT\nuLTCSvRTpJJ84DsjRLWJbWbi76OBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBTUwT2bA2c5AJmafLNakm6fjN51RzAfBgNVHSME\nGDAWgBTzHwF0QElObl0cN04XlXGR7qB59jAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCICeQmPlLGqiCs9UERFeoTRNexS0cBGPr\n22mW0ZWQ3Dh9AiEAnLJACzIlWUV0UzfXXBUJDD/53ksih+E2x9sPAQEPM5w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAejTI8zD2PhxfzP0Zyzz+DipMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRk\nOTRkN2ViOS1mMWIwLTQ3ZjUtYTM2Mi00YWRiMGE3ZDI5ZmEwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQWvqEWQFBLSUU390RCClLoyswjwZLUqqq3/Rq0cgobEDDb\nd4UTGn37/9IqWmq4E3mUUiEL5Jq8WtecawFmhrilo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8x8BdEBJTm5dHDdOF5Vxke6g\nefYwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgAgDXs8utNMfeIsnlFBAyg4+7Nc/kBJa3stZPtJL694gCIHYGzIWSsfbm\nF/0/YTJYzoDJrUH6Ly2kyzKIsqBdHDtd\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAblFrVjvbmjN89ZREwrkuFiQMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkMWUzYjAyMjAtODA2Zi00OTNmLTg3MDEtY2ZjZDQxOGYxODAxMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZDQ2ODJlOWEtYWM0ZS00Zjk0LWE5NWMtNGY4NGJlOTZi\nMjVjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAErV42UvFI3A6HFOJrWfuzIzA/\noIql9B0dW2+MN1FVhuDr0V7yMx7vWKoDQ0G0k/ETYk5ULbya7Q9ZhnGpsHZ3HqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTUwT2bA2c5AJmafLNakm6fjN51RzBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22NKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIDx1+Fnn5n3z0T0+oopK\nHKBQYxLyuX7J2+QqWFZ82+KqAiEAgu7ny85KGpHWevJd9bSWwOZBkhsP5Y25+CDB\nLbQ8pvA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9487", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9487` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPDCCAeGgAwIBAgISAftIcPq2B6L3azhABOs51zpuMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDQ5OTdkZDY0LWEyZGMtNGE0Mi04ZWM2LWQ4MTZjYjliOTE3NTAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkYTM3ZWY2OTMtOWI2\nYS00MzE3LTg2MDUtODFlOGEzYzA1YTdmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEXaMQh5neJVs0R+OEroOp4rDawbJEcJcQSsTb6bjvGqNVt1oEL+xD9yu1jvYs\n/EWKZRUXCb7A7ImfF5/6mTumoqOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVtuAlMzJ0mecWXapRKu2BC34nDYwHwYDVR0j\nBBgwFoAUbQF10UtYnlWHADQpWGfoumjaPvIwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0kAMEYCIQCWxcVSzcvCOFcY4qD23EBW2iYq\noLDRSYf37pj8f1z0UwIhAMAU6Y/o9wTkrNBETpueoG1p0ZFaSZpZsnuOoVeoQsjd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAaqtvXkJDx8WVgdab7IjJqUcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ0\nOTk3ZGQ2NC1hMmRjLTRhNDItOGVjNi1kODE2Y2I5YjkxNzUwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAARMbvXFGakhckvIz2w4HtuqQFJYKIdBzNvqZ8TGsuznqhdg\ntKqoq8LJGV0IA6BhNCFp1gDmmmzuVEas4h+4d8q9o2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbQF10UtYnlWHADQpWGfoumja\nPvIwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgWJixLvAKvRUGp3fhW8ATSjhzEzEU+Z/TRaVyMIHSjO0CIH1UKqKrqzge\nSobS4eFYbgl+hgoQpymHeTyqgXepXd/R\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISASbMDf+nojZvCprdeTbORH48MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkYTM3ZWY2OTMtOWI2YS00MzE3LTg2MDUtODFlOGEzYzA1YTdmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkOWMyOWIzOWUtNGFiYy00YmI4LWEwMmEtMjRhYWI4YzQ3\nMGViMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEKW6VRcBAVxWDsnT1Em3D0/G/\nBMMwNx/ykZks1DdmAAo+sU/ZXGGB7qvexoB3B7LXHcf9UIB7N4SX2I2rzobxDqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRW24CUzMnSZ5xZdqlEq7YELficNjBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22OKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0cAMEQCIAyiOjCckW1tydLloOfj\ndig11aEQXF4Riq+RAqSWnfRAAiBm+vkmvnjMf/xlXTU47Ug/HB4LMsNY631QDmJ+\n/G5vEg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9488", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9488` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAZ7ulnDMsChWRIq/grrKmbt4MAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJGM2ZGRkYzI1LTljZjctNDIwMi1iZWE1LTNjMmM5MjI2NzU4NDAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkOTlmYmJiNzMtNzg0\nZC00YWM4LWIyYTctNWMxNzk0Y2FjZTJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEsYwWGQYOj8AHMWkfGaG2NMyTEMXVMqlYkYfmwGedooJ8kUFLwIC5wGd1KU8H\nfnz3i5Ep680Wijw2GLFu8qlXfaOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBS64SId8x1GDBwQg2DKDrJPxDNWczAfBgNVHSME\nGDAWgBSRyKJzlK2DczWn5ykA3O/qre4QQTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAGbEIFtIDVbhL115iyjrw9HSoiPMc+1\n3SHiS+3ijYP7AiEAiLm5MeJLllqWKAv7FjHmfpoEV4FQaLW6DJZMPBsVT1M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAag4IQd2kAskAuItryliXI4dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyRj\nNmRkZGMyNS05Y2Y3LTQyMDItYmVhNS0zYzJjOTIyNjc1ODQwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATN9k168o6ho50xCDDSEPTtsfDHA2t3LSc437uRy4bM6mBa\neRuyfLD0B3QfcL1zQDdz0NOP0len4SP54ATEDgnyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkciic5Stg3M1p+cpANzv6q3u\nEEEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIgVPWFyT1G4Lo/NTfEr8Vty4pteAakUSmmFj7UZ9JoB2UCIQCFcLDCsXek\nocyhVXi1XW+zLRRecRa3pl68DmZEg5CjVw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQjCCAeegAwIBAgISAQV8Gu6HUC78uI4I0ByQtd/LMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkOTlmYmJiNzMtNzg0ZC00YWM4LWIyYTctNWMxNzk0Y2FjZTJmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkMDU1MTU5OTMtMzQzNC00OTM2LWJiZWEtYTk0YzU1MTU4\nNWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEi31N3Qr+6sdOOPUs9rqJdOgM\nL1We5DehlVvalLgtL/g/EAIbtjBRTDtBAclb0UWYBxviRDsWWZLrKTaDg+4vt6OB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBS64SId8x1GDBwQg2DKDrJPxDNWczBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22OKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0kAMEYCIQDz6f1vKr9JpglSKiuI\nktfk3xjst06f1V6YFP/cwu3B6QIhAKyRWb4QKyBRpeNuF4Kv13SPhfoopszOfRly\ngVJtgnDL\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9489", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9489` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICOzCCAeGgAwIBAgISAfaF/Vzv+2dbukHpwq2gV/cPMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDZhMjEwOWIyLTk0NDYtNDdiMi05Y2RjLTg2Y2Y4MDRhZjVjZjAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkZWU5OTJiNTQtYjU3\nMS00N2EyLWExNTEtZjI2ZjEyODNkZmZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAELu0cPINlMko9VtLZ8zEwzYWYKdMsmcXDMiK/Q8NZh+fVLOh23sAZ51SV43Z5\nF7/i4Wwj3IWYlbAhqB/NqL6B8KOBgzCBgDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUzqvaskc5uRc4/7dvcFiNE77nDnQwHwYDVR0j\nBBgwFoAUXsaBhBQRf8wN76I3dJxg8PXMZbEwHQYDVR0eAQH/BBMwEaAPMA2CC2V4\nYW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFdpdydc8zcfLZN38OKZBbj01iMa\ngb4gLwajfFH40tl3AiEArU5pqYBPDnoB7H7E95Yp9txZnZyJPjoFlzebsbjqhgA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcugAwIBAgISAZyhMHjEADUxz91FWe6DjAeCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQ2\nYTIxMDliMi05NDQ2LTQ3YjItOWNkYy04NmNmODA0YWY1Y2YwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAATqObTv6AZREN+aDp3Wa/YhT7kYOnLob9Eozo6ELRbh7m5m\nCp8OC5MvFhPf47yw9w4PcXwD71nZ8dZr4B5YoAqso2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUXsaBhBQRf8wN76I3dJxg8PXM\nZbEwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nRwAwRAIgUAUNdIC6pKewM1X5A/PVVGvRxvRfzlJO9huVQvix5EkCIDMOokrCWGXO\n1I1MA548b9r5M53hYRViP2s/N9wCZmzT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISATxGRAiuOAlsGKRXCUfpL9LyMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkZWU5OTJiNTQtYjU3MS00N2EyLWExNTEtZjI2ZjEyODNkZmZmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkZGQyZTczMjktMGQ2NC00ODA1LTlmNzMtNmE0MzVhNjY1\nZTZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYJmfthEg6C0r+KBKi+MsYDMP\nDjABJsT0lr9b6/oneNapy5RlTdVfg64btuTcIbq5QOmhaz2rm9eSN929Ve/ttKOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBTOq9qyRzm5Fzj/t29wWI0TvucOdDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22PKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQDHb7JlE1HuYnRN01lF\nPbN1GqXgWC9ojREmlFNyUHimhQIgSLpFB+ORH58G7Pak6YKWByf3yj0XDI4+cnK0\nPkmMZ1o=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::nameconstraints::tc9490", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9490` from the BetterTLS `nameconstraints` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICODCCAd6gAwIBAgISAWBvZHxRAci0mNZyqiHUHwhJMAoGCCqGSM49BAMCMFwx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEzARBgNVBAMMCmxvY2FsX3Jvb3QxLTAr\nBgNVBAUTJDExMmJiZDUzLTNhMzMtNGRlNC1iOGJiLWY5NDNlMTQ4ZjU5MzAeFw0y\nNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRs\ncy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsGA1UEBRMkNDUzMjdiZDMtMjg4\nMi00MmY0LTg5YTQtMGJmZWVkYTI1NjE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD\nQgAEYoss1gnQTQ1fR45R1hIGzamos3LvYyRWfSDmOCWjTp+IwseeMz7uohpCDS0J\nj/CdjPIQoPlasuCXdBCfOOiXBKOBgDB+MA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBQB6tCRftFf0vkJSK7G4iwjPvKLfDAfBgNVHSME\nGDAWgBTsz1+gjiD/eQVGAepgSiK0nRwgrTAbBgNVHR4BAf8EETAPoQ0wC4IJbG9j\nYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIAYd755zn6suJBeHA0QyJwoPpJ1oKCt9\noAyvojR2dN7PAiEA/dj5bBnCQ8HzDk6bEEcsts98mNGntnEkQOEEOIRAFmY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcugAwIBAgISAYxO8PzvNzMQNoqX/aq37mSuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBcMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRMwEQYDVQQDDApsb2NhbF9yb290MS0wKwYDVQQFEyQx\nMTJiYmQ1My0zYTMzLTRkZTQtYjhiYi1mOTQzZTE0OGY1OTMwWTATBgcqhkjOPQIB\nBggqhkjOPQMBBwNCAAQv+BKQMpzrZ0tTnwBBzTIjFluvrDJn4l2s0vyA7Po86yMh\n0Fs/mMs8VTqHpaAd9wQjyW77whWtpGX7hAWlxWRyo2MwYTAOBgNVHQ8BAf8EBAMC\nAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU7M9foI4g/3kFRgHqYEoitJ0c\nIK0wHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwID\nSAAwRQIhAPI4ikXGIW/C2dto5iejtGtzxxAWRhww3HJrF7NQylUlAiAYq6D1HU+n\nN098QsYSDdPmqB/i27ksaX51Zdb548VCBQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISARGARMQxb5Tw+UzyOgzZWteDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMMCWxvY2FsX2ljYTEtMCsG\nA1UEBRMkNDUzMjdiZDMtMjg4Mi00MmY0LTg5YTQtMGJmZWVkYTI1NjE5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowRzEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEtMCsGA1UEBRMkYzcyNzgyZGEtZDNjZi00MTA0LTk5NjgtMmJlNTE2MTU3\nY2I0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEu3lr/tDkKVkbsyy437rpZwJZ\n3uZOTGxx3sXXvCDfRNKrqj7h/5deYi7a0SdXSXPEOUaQrK4ET6/+s/GLPpxCbqOB\nnjCBmzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBQB6tCRftFf0vkJSK7G4iwjPvKLfDBFBgNVHREE\nPjA8gg9iYWQuZXhhbXBsZS5jb22PKWh0dHA6Ly9iYWQuZXhhbXBsZS5jb206RE5T\nOnRlc3QubG9jYWxob3N0MAoGCCqGSM49BAMCA0gAMEUCIQCc0RNgG/oT2+qUnseA\neXZGM8nIxLeDWoNBzLi5tkWmfgIgLmoXBbag1wGdx3AgR0wSmry2E05zDTVNV9PJ\nQn+B9HU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "test.localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc0", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `0` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAf/YQHu2JveI7AjHI3J8Dh/UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDNhZGFiMWJm\nLTAxYzgtNGQwYi1hMGJmLTcyMmRiNjE2ZWU4YTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPqHf6nH6tMatlAfUYiVTFOrEm0SejoaalXNgLsQv0trCL8l0mCiBH6c\nrbZz8qKia4cB8aaXT7DtmrMQmj/s6oejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTjsU37OJBH4UiPFfhrgnZG8ISGhTAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiEA\njS8QE3m2EQIuEI6zrRNdynrMqIy1INZkTXZ7hmr+gxgCIGAGpXsNw0vRAPEqeG9o\n04Ti3yhvxU6oqU2pMbn7d8Sg\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISAeuNzl0sb2hNvzywv3psCsWPMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nM2FkYWIxYmYtMDFjOC00ZDBiLWEwYmYtNzIyZGI2MTZlZThhMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDkxODE1MzYwLWUzMzgtNGY0ZS1hZTcwLWIw\nMTk1MzM0YjBjNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDkG++xrEy7bUPnu\n0gcBzkRqmq1vYGCtyKf+PGq3fKAWYloIvaX37zvapwvIhzvBiP3/a0SDzrtrC51C\ndMa9AjajbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOOxTfs4kEfhSI8V+GuCdkbwhIaFMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAlgWGm1vW7pUB\nBH8dpCJKWphXyvobukPdltAlrFYysz8CIQDSBI2IYLoV/JwRSIg3IlDgUfDED54F\n9rV5jwwJRqMhUA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc1", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `1` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcSgAwIBAgISAZUURa0L1SnLXy3nHSpsHIAjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGE3YzkwOGJm\nLTA2YmYtNDc4YS1iN2NhLTIxZWMyOTk2YjlkNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAgL366FZ6j7j1x/m2J4yJu4gbaCiBIPfUBbywEUGoPSdBd0yq3HLZpk\nnOBzAwgaFy/3uPsVzgwsYDXjB0vG4uCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRYbj6MeH473UkiMLRwGWjW/ToagzAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNHADBEAiAM\nlc7+mP+MLRqIFstVY5QnxoELd9SgJgZSQMLfyVbgGwIgOriUzUbBtIFSngwI6kqB\nK41b/7KlHlTKAdD/ex108Ts=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAU3Z2kP3cesSJp/ZgZcekJUUMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyQwYTY3NGZhYS1hNmNmLTQzOTAtYWNjYS03Njc2MDAwMDM5MjAwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGE3YzkwOGJmLTA2YmYtNDc4YS1iN2Nh\nLTIxZWMyOTk2YjlkNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAgL366FZ6j7\nj1x/m2J4yJu4gbaCiBIPfUBbywEUGoPSdBd0yq3HLZpknOBzAwgaFy/3uPsVzgws\nYDXjB0vG4uCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBRYbj6MeH473UkiMLRwGWjW/ToagzAfBgNVHSMEGDAWgBRMbrnYFpqd\nZ4Qc5kY+HWqKaUo+BTAKBggqhkjOPQQDAgNJADBGAiEAyMVrDb4IIkpQZTy+LoYH\nK/pDH0bWz8lvcSVb1GcssZ4CIQCyMdwHDVHV0FGq0zlj0IxFnlqqUi+OjHuN9Rbt\n7sn4tw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAX9HQv9+Lh5fCn5/vABtokUHMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nYTdjOTA4YmYtMDZiZi00NzhhLWI3Y2EtMjFlYzI5OTZiOWQ1MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDA0YjcwYjUwLTI5NDgtNDU3My1hMDRiLTQ2\nODBhNmVjNzc1NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG/28VDKO6MupgY+\nPZYOh6fGmX+lUxJlf25PFDrgyEgD7z8McuzuUUYhFp/VgUn9o4iKRBg7iEk16Bzw\n3Va4ieqjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFhuPox4fjvdSSIwtHAZaNb9OhqDMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiEAoqhNRijOMIYp\nqGdRB57q3r0hSvib4Zgt60rtkzey/m4CH2rDR0ANny9yuRU6jmu3seOBrchfesg1\nf4d+D/Eg8jE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc2", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `2` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbWgAwIBAgISATDP8G7wd+1MbTerTZiv1stmMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyRjZDU1ZjRkYi1iNGZlLTQyZDEtYTBlNC1mY2FmOGFjMGI2YWEwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDhkOWUzZTBkLTFjYzctNDg0My1hOWY0\nLTUyZDZmNjdhMTAyNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKFo9yiboMkA\nYdihEW8atEj7UnicjC8bioHmSdbIxNrpMFWYbsxSrEuUTDLGCuG4UzGF0EU7QR+z\nf5FRx3ah6gWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBTQiul1E7ZL5S2YfHKvVlED875NLTAfBgNVHSMEGDAWgBQgDvf7JGkd\ncm6HV58b2KwLnQQa3zAKBggqhkjOPQQDAgNHADBEAiBMRg7eLXiVY6LtpBYU38yR\ndeI75H4hD64M55v+snzVNQIgDc+237FgFynFZ43ogMVRG9dT1VzDOxNph2tpDvZG\nqYY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcSgAwIBAgISAdoNH0aNLHrdyAUL6qHsfgKaMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDhkOWUzZTBk\nLTFjYzctNDg0My1hOWY0LTUyZDZmNjdhMTAyNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKFo9yiboMkAYdihEW8atEj7UnicjC8bioHmSdbIxNrpMFWYbsxSrEuU\nTDLGCuG4UzGF0EU7QR+zf5FRx3ah6gWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTQiul1E7ZL5S2YfHKvVlED875NLTAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNHADBEAiBL\n4FMTTVDl3tanE/Y3/fHCM0Fi3mfklsVNnUboFM8oRgIgCt3gFLR2CX4pWnNLpmY/\nnTtXYuJXGKNlpehT2Qjwcww=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAWUanpxg75c59cyPy+R+/gVwMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nOGQ5ZTNlMGQtMWNjNy00ODQzLWE5ZjQtNTJkNmY2N2ExMDI0MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDMzMGE2NzQ5LWY4MWQtNGI3Ni1iNGJmLWRj\nNDVkZDdiOTM0NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKgzYjY7TwJNEz2T\nBKuqWGlzfwAhn1ryYSboEWNIKjgA6IBHJNI6Ypj1sEbOEKekkdIMhtniDLi4pFH6\na39aa56jbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFNCK6XUTtkvlLZh8cq9WUQPzvk0tMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiB9Fyh5yIlDwI1w\ntLF0S6y7l0mTqD40/edTfzEWNN/UpQIgSWkgQs84RKvc/i1b6qPZTPDZKArm6Uli\njKd7mfWN1Xg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc3", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `3` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcSgAwIBAgISAUd2dgp3mvrFshHcXJfR0tDfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjYwMTIwMTYyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDBhNDczNDIx\nLTkxN2EtNGY4Mi1iZWFkLWMyYzBmMzE4MDBmYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD5Hgurd6uQDjRZqy9LQxr9KafeCzMVFjuxJgAJgnvksgupwVObQM8nj\nyE0x4fGeQlJJbJgVmCa/YkpwPKr2776jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSy+GgJShsZTnH9FzFn2vzPOaIQAzAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNHADBEAiAg\n69aMqedrNZmyuWipLp8wCtW6NaGOmKF1gGLC5WttzgIgRgZ731+X/EsLUigrKGg2\nCFYFsQhMbAJUf4sbqFpvq7k=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISAckSYXNPV/Nqy4gc6GlrzDhXMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMGE0NzM0MjEtOTE3YS00ZjgyLWJlYWQtYzJjMGYzMTgwMGZiMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGY0NzZlY2M0LTQ0OWUtNDZkMy1iYThiLWQ2\nMmFkNmU1NWI2OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIMrBSPZalQfIY6n\nicfyos2qxlodZNrhsDm9P0aICte9FVmXTXPmXFZlDC4w2PV2VuSRLtLowu1R8elI\nCwLK6FqjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLL4aAlKGxlOcf0XMWfa/M85ohADMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAj5KC4kTdKldD\nwaRzsn82qZ/nfJIj1kMF52itA8Z4GccCIQD9Y1OKyMJgd2F8cy0jpjizk9NTrcSG\nOXeqhPiIOwMwOA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2027-01-21T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc4", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `4` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQzCCAemgAwIBAgISAfi56KJTC7XLw/MKnmrtuMpzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDIxODcyMjRm\nLWMyZjctNDY2Ni1hMmFkLWY3OWU0Mjk5Y2FlNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABGNNh3rYCMF+e95PGzxMbNjHK5eZlPdysMNtMhG7XYZ494TeOkrhEO+a\n6ewg34k5/XadOuNjdDntwGdqfcbYAimjgYcwgYQwDgYDVR0PAQH/BAQDAgIEMA8G\nA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFE4d00ezMEUrvNnAUqKQw8+tkFHpMB8G\nA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MCEGA1UdHgEB/wQXMBWgEzAR\ngg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhALYlPN3DSZr0VB/g\naciFx8Rr/8vN4pS4dLr2Si9WQY3JAiAFOQprXk0tYLsjttsTt7x4UZz9uPK9/r0U\naEISsjrd7A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISARKfDM4Jtm0IYfdl+tJC7IxCMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMjE4NzIyNGYtYzJmNy00NjY2LWEyYWQtZjc5ZTQyOTljYWU1MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDM3NzkyZmM1LThmMjMtNGVmZC04ZjExLTA1\nYjg2YmE2Yjk3MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOYKb065sorqx/6k\nhO/GGmNlvGTnf6qM40mZX7jCWI5sNGVJ9S6+J3YG0EnXIqg3E3p6JopzXg4zchOf\nkVlZKlyjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE4d00ezMEUrvNnAUqKQw8+tkFHpMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAzBXq+OEd/0TIF\n1P+PYHn2cJkrKgQW5VISxJSb5a8TmAIhALQiPXM+S5VMWonoELb2bbspCThuGJth\nbWgIQ4ZVSkkq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc5", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `5` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAYrYj9in99LCunDYqqLv0OYfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGU3ZmE3MGM1\nLWI2MGYtNGU3OC04MGRkLTcyNjM2YTlkNzhkODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAuLQUMFmg0qCDRNHEwidyCqH/lvWrcEXae6Y9Rhi0znBvL7xE8wgxVR\nTHwf7WaxHTCRg1otuEp+ljVnxPLDlUajeDB2MA4GA1UdDwEB/wQEAwICBDATBgNV\nHSUEDDAKBggrBgEFBQcDBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSrsMVN\nsKTeGwZkxTPbPoxRGD7BuTAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAKBggqhkjOPQQDAgNIADBFAiB9oYCtD79aDoy+4V4qS3O8gW9R0Rrf9xRbuREA\nmHTUlwIhAJdrhazCQr18gmt1HP4CH2E57/aUNpYPDGvhrpLEvCls\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISAZNWVr0JY7aKK7ZWsa4JgeJGMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nZTdmYTcwYzUtYjYwZi00ZTc4LTgwZGQtNzI2MzZhOWQ3OGQ4MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGFlZDlkZGMwLTY1MTgtNDI5OS1hZmNkLWYz\nZjVjMzA2NDkxODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABF2J7gPDEwOo4oSA\nl47ZaNUlne+guIa0/czHkcJSjdPoomVh0YAMhNZDsVzpjfFyx6lj6NekBBdrj7Uy\nBVv9/3+jbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKuwxU2wpN4bBmTFM9s+jFEYPsG5MBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAlbX02SkJC6qI\nOLrHQ0QepfyxnufK4gwTEwPGYOslevYCIQCqFRyA0lKNXO0T4YEg6ry2bglUp81W\nbYuNl9tAKqrJeA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc6", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `6` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbOgAwIBAgISAWc+77x6IIQ8gHetCsEmjS+gMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGU4MTJhNmUy\nLTliZTItNDliZC1iNGU3LTNmZTg3YTJmMjE5ZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABKmW1AHpteCri4jNptISNJGD+TmkcX9PTqQXfj10oEqyX8p+pTkEL0HO\npORq9sM1wP8rvajANQahrfGbmh+DfG+jUjBQMA4GA1UdDwEB/wQEAwICBDAdBgNV\nHQ4EFgQUZwozjamRtfiS1s5UREGs5Iq2qqowHwYDVR0jBBgwFoAUSmacmwv0HQuF\nABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgWo7vJ+nNg7nzfTzrJVe88Yur\njTEZgiGPSD+v1fmrTGoCIColGAjaLZCkj/IVY9QLYhFE/RhFZmofBX4wlXCQt1f5\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAb43gLA2VcffLiuoImGRp24RMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nZTgxMmE2ZTItOWJlMi00OWJkLWI0ZTctM2ZlODdhMmYyMTlkMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGFkNWNjNjU3LWVkMDctNDViMS04MmQ3LWRh\nYWI5YmJjYjc3MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNwSbA44VIGsboGN\n5RKiphPqIH0g3nuTtAZzCykP8oydfmu9rRke0zujjk1uvllFIOrIysNkkxPEBPy4\ntGG9aSijbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGcKM42pkbX4ktbOVERBrOSKtqqqMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiArSCZw22zJt8Ob\n7cSKzxpfvBnm86FEUVewTq0FrwqbGQIgSQQ6AKgxs2MJOwbclnn199W/+C40BpRC\nJmJ99oXZqpg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc7", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `7` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/DCCAaKgAwIBAgISAYjQ6erNidAy3WLQdOBpwUJWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDFlMGZmNDlh\nLWI3MzAtNGY2MC1iM2I5LWQ5YjcxZmE5MTc0YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBjBSaMFQI/GSgOi6LIVWpOrq1hWV2MTPK4IcshA+osNOjEL7lOy6j18\nO7Cobz9onPKC2L0KDCmZDSlLThbOsyijQTA/MA4GA1UdDwEB/wQEAwICBDAMBgNV\nHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MAoGCCqG\nSM49BAMCA0gAMEUCIQCoeG++NatKcbRscpwbyaDPvRxgJlUaQ8iRIKEd9lNNegIg\nGD63EthsaH3lElC7HjwTrN8+BWyg7KWSXdULsa8uAOs=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAQyOshUE7TIkgumxnXVPIiBdMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMWUwZmY0OWEtYjczMC00ZjYwLWIzYjktZDliNzFmYTkxNzRjMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDk4NzdmM2YyLWRlOTktNDJlOC1hMDU2LTdm\nN2FmYTc5MjM2NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMORynyOPV6iq0/c\npoumkvUmnjcZ1bRX6AyoXfB/NC61xj6kk0E2P0albhjXCxtwETGMJ+seISDJDMCm\nu9aDxaijbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPJFPH+kvhmiv0Zc5n+2J4YyqyXmMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBjjIf4B2vu/9uW\nh7wcm62pzrj0T+EiRz6ZdrpJ3FH0BAIgO60fLS6cCibNegTNrlBnelIKOT7Fbrfl\n2KaT6842abY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc8", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `8` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISATQjyRs9rLxDV+vJGedV7uLAMAkGByqGSM49BAEwZjEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0\nX3Jvb3QxLTArBgNVBAUTJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUx\nZDhjYzAeFw0yNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFUxFjAUBgNVBAoT\nDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMkNTAxMGE3MWMt\nYThmYy00NGJjLWFkYzgtNTczZmY2M2NhNWFkMFkwEwYHKoZIzj0CAQYIKoZIzj0D\nAQcDQgAEs4FGlGjK4ayhwDfCYpN1VtTgD9Qx62EjnTE2DLPY1No4vO5vRU43TwT4\nkJTwihOsK5YdInFsf7htNtKPD3hNAaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1Ud\nEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFqZJ3iGlHKY+xytEPEnvSgMgUjtMB8GA1Ud\nIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MAkGByqGSM49BAEDSAAwRQIhALvz\nq7IS/uYKyIX48zmgLD4qmC5aL9e2fzMGUuiqohoMAiACbkAVt84yZi1CJlQZol+h\nlicQFepjKCwoWAIvZ+Zg7g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAY8VCaOWARGAw2S33tVrmM6GMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nNTAxMGE3MWMtYThmYy00NGJjLWFkYzgtNTczZmY2M2NhNWFkMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDdiMWEzOGFkLTcwZjktNGUxYi05YTg5LTU0\nOTI3OTZlODczYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJMsHWLHxBR9o0XX\nbLMrM0mCGgmJpiqaSldV8ChgfjT+Brv+FzzTOKKACDtLJ9Y3Vzqr4p/9wTCmT0o8\nCLbqv4qjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFFqZJ3iGlHKY+xytEPEnvSgMgUjtMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAo2KdjBtcVkDV\nL2nlgoTFPpI7y9GD054kV3RcfrPl5gwCIGDdii/zB7tTLvmRFT22nFHGLI7OMHQ0\n/n3wH7+KwmDe\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc9", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `9` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAbaeBgrw1pxRi/3GXmsg7MOAMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGEyOGU3YzY2\nLWZhYjItNDlhYi05ODczLTIwYjkyNTgzYjM5MTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABABKZma4hMXZGIrCURfA5cAsLZwi6QGiyv6WmlpMa4HDoeotEXWXPQ1J\neOt59gE4QlNxsEiC3KbC5Eq25hot4vKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQLYcUFx2OToWKYDsFaDOBsmBNlTTAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiBI\nYauehgR1oG6HaYtTJdbtHEVpeKHXbG2nEKLoeQo6qQIhAKQB0TbbB1+N6U0M9am8\nQI8xs/wydmVwDVCw1tEKuHMc\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAZe+wyFHRSAbvxh5ofW8Tk3VMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nYTI4ZTdjNjYtZmFiMi00OWFiLTk4NzMtMjBiOTI1ODNiMzkxMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGZkMmExZmJiLTAyZjMtNDgzMC1iNTA4LWUw\nM2ZiYWY1NmE4MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCS8+Rl2/MmzerYk\nGgAEuc1xYKzCjNaoY5Hz49al0DtG5SkTQ/NQZBajYBzuoJBXv0+093HhIbUp/2Nf\nH8z/mWSjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAthxQXHY5OhYpgOwVoM4GyYE2VNMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA4Z7Z3HF20CgZ\n9AA7jxs7R3q9vQlUkI7472cWrass0NICIGiC3LCGdStb9wxiI+MPOJuPJ1ZKUdCB\npAgg8cBY7sp/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc10", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `10` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHzCCAcSgAwIBAgISAeondM8tMzvAhS1HyjtM4DwrMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjYwMTIwMTYyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDQ0OWNmYzM3\nLWYxNDItNDE1Zi1iZWZhLTM2Y2I0ZTBiNmVmNDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJVzZPLOJLTEN+Rlx/26FadmhN65ldssG6vkHUvNFsxHBAEW6ku+Qq7b\ncvIjv/147DmQcBnfTQu0qovIO0Lg3kSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQHTv1tq86C4q9zYacDFsEX+z6rqTAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNJADBGAiEA\n5qCN53KP7s1QKjtCGNqofqQV51VRHY3iPyns4cS0qQ8CIQCbsbkBMIHfMvZXqXoO\nTCUpbG4WcSeq3hNgdirq1TPQtg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAYKSyyy4L8TjAbShofadqhVcMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nNDQ5Y2ZjMzctZjE0Mi00MTVmLWJlZmEtMzZjYjRlMGI2ZWY0MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGNlODdiZmRhLTE2MWItNDA4OS05MTBmLTUx\nMDMwYzA1MjhmNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLvkRG70ZUT9Dqds\niC4jY1zczx4xMLKb+kqh2nsIuyuFa27RPl+gUYstHTCNApHLk81W8bbGbA2WIMDi\nHdXkP5qjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAdO/W2rzoLir3NhpwMWwRf7PqupMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEA49+PmrU7Ctij\nAjNw+nkfiK44BCKz6UHpYQe9VbF/ntICIA+o+Pf7fwGAWrGJ1+XLdYGaqk18Xg96\n8do574Z4YUbQ\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2027-01-21T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc11", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `11` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICQzCCAemgAwIBAgISAT9g9Bd7VlqkvwIUfujxeu7OMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDJkM2IzYmUy\nLTcyNzItNDBkNy05ZTM1LWE4NGI1ZjQ0MWQ3NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEMq10YaZIoMPMmpj8Wgj9bewE7qgaF67HWz6+WaxjDlAIlJlQR0/XMt\nVkLehCNhsVIkdecL9VMExiykEa6m69GjgYcwgYQwDgYDVR0PAQH/BAQDAgIEMA8G\nA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFBYRKmY5fKOpEEhOFuoGLU6UYq3qMB8G\nA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MCEGA1UdHgEB/wQXMBWgEzAR\ngg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAKlbcdd1gWsDaiuZ\nNNhLpuuP/QjY8Xs9JD5Ww1+df8SyAiAAnNXDF1YnVywYuoK2n/uOPOCxnau8tsYr\nDJiDaDgSHA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISASGPfLCBumjaoFdqZhFxSOJZMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMmQzYjNiZTItNzI3Mi00MGQ3LTllMzUtYTg0YjVmNDQxZDc3MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDcxMjQ2OGI3LTQwYTYtNDgzNS04YTlmLWZh\nY2JhYTYzZDQxMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABENDTm0ZRWL3OuLa\ntc6nyTaBOcCt2N5gQxPcPZFJrkUGni5Hv33OZF4Hu4pN+3xWPuu946GVxf6tqkLd\nodMr/CmjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBYRKmY5fKOpEEhOFuoGLU6UYq3qMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBZUhKHWJ3x9QR1\nO73unaZNT3NVZQ9SyialQdlrkmBH0wIgM2wvCesZWd1HmLkm/Yn08uPXIvDjD1yA\nTghqp08D9dM=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc12", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `12` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICMzCCAdmgAwIBAgISAeobc8Xw4LCZxY1ZNQmE3SwnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDg4MWUwMzRh\nLWNmZTYtNDBjOS1iMjBiLTg1MzVjZjI2N2Y1ZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABM4XIo308pngECh1jsCamsQhZutmMDchqyiFxwrqKzpZoz1YJiZjPVPG\nxPbJvq7twKlRVOQIm5hD5WBX2/JLOu+jeDB2MA4GA1UdDwEB/wQEAwICBDATBgNV\nHSUEDDAKBggrBgEFBQcDBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQQVE+W\n3bBHqfzHrhx12m8BqC+LtzAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAKBggqhkjOPQQDAgNIADBFAiEAtUn2CRqyFGWPuBOs8UC4rAAa0EtFpSQ3R2dP\ncXw73nECICSEd6dt1m8BTIctqFkfLLMvjnEHAVMNVUoLVTfnzLL9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISAQMePfBxwEQauN8BPmE1AR/NMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nODgxZTAzNGEtY2ZlNi00MGM5LWIyMGItODUzNWNmMjY3ZjVmMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGIzZWU0N2Q2LThlZjktNDQzZi1hNzk1LTJm\nYjExMzJmZmRiNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM/u7SSKT32q515p\nbFf/wQPudksd4o42oOq97NikHRB5HDklRxSMPyIEdlaE/uZn1TKaI3KQuDS9z2Fm\nOvp+wO2jbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBBUT5bdsEep/MeuHHXabwGoL4u3MBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAiQAPNdYdpnB0\n6pDK0BjDo+V8yfP6mW2kcNWmNfOddyECIQDHvS5byxEgP0Fg0L3CKz8E90ymH1Ep\nM7XCsizXC8FGhg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc13", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `13` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbOgAwIBAgISAXcZlUnK1Uu6o6Vq9GP4SKXeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDRmM2I5ZDg0\nLTFkZDQtNDY5Mi04NWIxLTdjYWQyOGMyZDgxZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBbtObqpzU29DD7paPR15TESsaWIXThRO22wStZvimCBJ6ndwAcjoTNk\na6C7zsLE72hz/ydPOaHjA9CBMNFNZt2jUjBQMA4GA1UdDwEB/wQEAwICBDAdBgNV\nHQ4EFgQU/wI/dYyopOChn9z/HTTlBLPmjkUwHwYDVR0jBBgwFoAUSmacmwv0HQuF\nABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAMEOfgHfXR5yaTCQiJG0qBjD\nymsAozOEAH7nSYGTo6pbAiEA7BpG6yYjGKwqYbFX7y6axoSXV6kKQKVdtN1UcBmh\nfdA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAepmw1/9efrMQsqkjqkgVxsXMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nNGYzYjlkODQtMWRkNC00NjkyLTg1YjEtN2NhZDI4YzJkODFkMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDk2OGFlOTQyLWNkNDctNGM2ZS05ZGRkLWIw\nOTg5NDIxMjRmYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM5NhsYjgnTNYmFm\nfkrROFG5ZDytGAeCZL7LSYMmgKMUt+n3pRoclGDD/s+P4XwK4qLT0ruEtbqVGM4V\nsZUAuP2jbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP8CP3WMqKTgoZ/c/x005QSz5o5FMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAtAlUl2KeazOY\nVlKfG0YBvIadFfnYmiTOLOyiTR3EUOcCICl/+RgeNbxxeR/BWktnOL+w7flytlGr\nf34Zcu83MUY7\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc14", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `14` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB+zCCAaKgAwIBAgISAdBRvdVpjs216I1Mt7ZR7iomMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGVlOGU4YmM1\nLTcwMjctNDI0Ni1hODkzLTc1YzRiZjFmZTI1YjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEoVpx1J/z3/qT2w7Fa8IAzP2wArIn1W7tktE72fP+mos6SgAOtobf8d\nu+A9NiWWxwcnUFdyth8MlSStczt8KsejQTA/MA4GA1UdDwEB/wQEAwICBDAMBgNV\nHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MAoGCCqG\nSM49BAMCA0cAMEQCIADipPlc7DtVtDTWXSWHCLuk+iRg3e1vd1WIH/KnPDvwAiBM\nWaVYLY9OGBSErUlEyawTZ/ghGG20xeyxA2OaXWstPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISASc5nMdPo7J1YgAcupGNcWI6MAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nZWU4ZThiYzUtNzAyNy00MjQ2LWE4OTMtNzVjNGJmMWZlMjViMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDkzMmFhM2VmLTNkMDMtNGI4ZS05Zjc4LWI4\nNTcxZjk2YTYzZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDVOtVIJU+0h2SeL\nq/Y5j2kK7eDDAqky4u+kqsq8S2T3QCbh7kbmFgUJa0Vzpvjvu7N4Ivr8xR9jTRBW\n7hH5b7qjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI/ITeC4mtfNwm8NwhRWHdE9Sa+pMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBUV/sO1NyMMjh2\nQ8f6q9id5zrvjcIcpsjAthynyo2KtQIhAI5kLfofh/yAGg1VwNOfR5uDqMMf3KSE\n6Hnuh7X7uobP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc15", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `15` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcOgAwIBAgISAYDaUg+XiNkxlnfrtGjv9Z8GMAkGByqGSM49BAEwZjEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0\nX3Jvb3QxLTArBgNVBAUTJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUx\nZDhjYzAeFw0yNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFUxFjAUBgNVBAoT\nDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMkYzE5ODcwNTEt\nZWM1Yi00YjRmLTg5N2ItYzViNjFkOTU5MmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0D\nAQcDQgAE0JKtVA6LJa9D63UsYfy3fp//suIllai8BktHlYP/oORa5WmysSPqti8G\ng6a44zs/B5b5COStIx45T7DFEqMC+6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1Ud\nEwEB/wQFMAMBAf8wHQYDVR0OBBYEFDp+3jW76dVcdt2d4U6Rbn7QU0c9MB8GA1Ud\nIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MAkGByqGSM49BAEDSQAwRgIhAKVp\nv7nV/XqV+gq/9+51cWGn/bg44+dk/hOSWgFYo/+WAiEAqYFK0kiPjL+Nap4UkX8H\nbcyjSlWfNRUniLETVrD8UZc=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAbshn8Ad5dIOjBMfhzcGzX28MAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nYzE5ODcwNTEtZWM1Yi00YjRmLTg5N2ItYzViNjFkOTU5MmVlMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGE5MDQ0YWEwLTg4MDUtNGQ3MC05MTA4LWI4\nNWFkNDQ2Y2FmNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCcsFUK27QMEwU02\nXkEecSV17v4pPr6d52eRkcmFEe4ebrRhYgBS1+sAJqpk0m/Pwyl67uuuAAiU1W6g\n7J/IukqjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDp+3jW76dVcdt2d4U6Rbn7QU0c9MBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBuZdWVSpTctLtD\nrcGhZKCYVXywvrWOy5zWkp4AmlQUwgIgXvKzPSyylvDiG3cWJ21UVkAp57rc2Ubf\nEQLOaoYacig=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc16", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `16` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICJzCCAc2gAwIBAgISAXD2297SeUmxw1rZxRFcA0xWMAoGCCqGSM49BAMCMF4x\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xFTATBgNVBAMTDFRydXN0IEFuY2hvcjEt\nMCsGA1UEBRMkZjUyOWVhOGEtODJjNS00MmNlLWJhZmItZDQ3NTVmYzYxMDQ2MB4X\nDTI2MDExOTE3MjU1NFoXDTI2MDEyMDE2MjU1NFowZjEWMBQGA1UEChMNYmV0dGVy\ndGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUT\nJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbty\ntVSwktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQE\nAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhr\ngjvY9TAfBgNVHSMEGDAWgBRgM3++R1TXpW+9XYO1Y/xzB/f6JTAKBggqhkjOPQQD\nAgNIADBFAiEA1paep07sRGY93KNVoxB1cPkQxy8NPu9ldS2yyUojJFUCIFJro7hA\nUxllkRDOeezEPyjWOOTToCPKmkP4s6k7JSbT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJzCCAcygAwIBAgISAbpKNEqwHozPy/6g6TEryFPzMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBUMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQswCQYDVQQDEwJFRTEtMCsGA1UEBRMkZWQ0NTgzOTIt\nZGVmNy00YmQzLWIwMzYtZjVjMGZjZGMyZmMxMFkwEwYHKoZIzj0CAQYIKoZIzj0D\nAQcDQgAEnmWkWzi25elb0fAqCDa1sPhyOpxT8erGSJt9FIEfWzBOVvU+FdmMG+LG\nuB9CfBAWRw4UyMhKnFa2GOE9FCRcoqNsMGowDgYDVR0PAQH/BAQDAgeAMBMGA1Ud\nJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSmacmwv0\nHQuFABoc7YS4a4I72PUwFAYDVR0RBA0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0kAMEYCIQCdzcuAX6kVf6j5TmXEzS1MB4kRpRwlT09kMBmQ79cRXAIhAJ+9jvPu\nqdWXVnskQ2r+cwwVqT0mKvtZy4XFEpSwz5JG\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc17", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `17` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICTDCCAfKgAwIBAgISAbyTTvuCNH7SQiV8sV5lbDb/MAoGCCqGSM49BAMCMF4x\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xFTATBgNVBAMTDFRydXN0IEFuY2hvcjEt\nMCsGA1UEBRMkMWJmNmFiZTUtMjNhZS00OGUyLWE0NTMtNWEyMmUwM2I4MDU2MB4X\nDTI2MDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVy\ndGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUT\nJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbty\ntVSwktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajgYcwgYQwDgYDVR0PAQH/\nBAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0LhQAaHO2E\nuGuCO9j1MB8GA1UdIwQYMBaAFHNfZoLQRvwjqni5zacBJwnGf2c8MCEGA1UdHgEB\n/wQXMBWgEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAJqR\nS3La2NILlhTspBU4J1TBG4NIptSbpvBwzgK2rwW7AiB3LVZgN3zcMZurWlu7jltu\nzV7LUEp7MNA7nMvNT0fckw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAYTyDWSY5fEYzNcP4TI/ZSIuMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBUMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQswCQYDVQQDEwJFRTEtMCsGA1UEBRMkOTEwY2M4NjYt\nMTA4Yy00YzYwLWExZTgtNDkzZmNlZGFjNmMyMFkwEwYHKoZIzj0CAQYIKoZIzj0D\nAQcDQgAEkR7caZfrCzZjxrnzDjRKKuqU6qcg4fvgRp/rsTNzbvphH+7I3RDW3jY/\nXrqLC1QcBh06ysVjp8SOjWHTxS46/KNsMGowDgYDVR0PAQH/BAQDAgeAMBMGA1Ud\nJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSmacmwv0\nHQuFABoc7YS4a4I72PUwFAYDVR0RBA0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCC/foRVKr4FErYGKZfd0XOPoRtEK6vvS1riV2RDl/85QIgbZWM0S0Y\n6tQPkOI3liY2Z6FtThT249Vy+Kqn68po7do=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc18", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `18` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICPTCCAeKgAwIBAgISAbhIyiBmvdSU/QtMlqPcVMeLMAoGCCqGSM49BAMCMF4x\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xFTATBgNVBAMTDFRydXN0IEFuY2hvcjEt\nMCsGA1UEBRMkNTI2MDA4NTgtNGQ2MS00OTAzLWEyNjItNjdiZDg2YTA2NDIyMB4X\nDTI2MDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVy\ndGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUT\nJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbty\ntVSwktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajeDB2MA4GA1UdDwEB/wQE\nAwICBDATBgNVHSUEDDAKBggrBgEFBQcDBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY9TAfBgNVHSMEGDAWgBTIJahtXSVQXURg\nGAHYe3uzcQHm8DAKBggqhkjOPQQDAgNJADBGAiEAh2WKozEdn2CfYT8gKgUJMMw6\nKFOewVAP//4S3MfofJgCIQDKuXXVOpeLHabYbW67Avz1i8+JYIYagiGe6Ke0r0Ua\n5g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISAYRN9N/MUL8JhUDWohOoDsyLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBUMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQswCQYDVQQDEwJFRTEtMCsGA1UEBRMkZTA0NjA0OTIt\nMzRmYS00ODlkLWI2ZDctODUwOGMxYTI1OWUzMFkwEwYHKoZIzj0CAQYIKoZIzj0D\nAQcDQgAEHG6dpW7SXkYxooqIcmGLCWqfgtIwvSRIkXo9VEXSVzTOvr8MihPMbfZs\nurdykwhcpI50hDtm2BeGdSBAO3k2I6NsMGowDgYDVR0PAQH/BAQDAgeAMBMGA1Ud\nJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSmacmwv0\nHQuFABoc7YS4a4I72PUwFAYDVR0RBA0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCID68f0hDOgXKB9uxXoSNLxDgzSqkaN7eyg7MZG6zhs94AiAcTrlI7xlz\nyYxYY07DAvheXGpqnnqkiEJJARkFVaKriA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc19", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `19` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbygAwIBAgISAa++iuKoix4C2CKcft831RBZMAoGCCqGSM49BAMCMF4x\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xFTATBgNVBAMTDFRydXN0IEFuY2hvcjEt\nMCsGA1UEBRMkOTk4ZWU2YmQtNDM2Mi00M2U4LTlkOGMtZjE2ODA0YzNiOWNmMB4X\nDTI2MDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVy\ndGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUT\nJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbty\ntVSwktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajUjBQMA4GA1UdDwEB/wQE\nAwICBDAdBgNVHQ4EFgQUSmacmwv0HQuFABoc7YS4a4I72PUwHwYDVR0jBBgwFoAU\nJO9YtfNHiJJZenn+IWCs72NEBHIwCgYIKoZIzj0EAwIDRwAwRAIgQEic3EY2hFeJ\noosGshw3sQh+ua5YR5goVqgnS+WJa1wCIBIEZZTBuiVqKraEIxVSa3fag/J79Ncu\nHWRJYJtoD2up\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAaFfKPZKYIPIaJLr4wPtzBXCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBUMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQswCQYDVQQDEwJFRTEtMCsGA1UEBRMkNjFhYWY0MWQt\nZTk1Mi00OWQ5LWJlOWQtZWMwMzQwZGQxZmNiMFkwEwYHKoZIzj0CAQYIKoZIzj0D\nAQcDQgAEec/+iw1GAxQOXSpMMcC/PnhBf+BZTiro/ukJb7+t2lnOUst0knT6IgPt\nVom4PCQk6GfAS0eJeMa3dLUdSqQE+6NsMGowDgYDVR0PAQH/BAQDAgeAMBMGA1Ud\nJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSmacmwv0\nHQuFABoc7YS4a4I72PUwFAYDVR0RBA0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQDDaKk2mUW3upaB4iEOeJnN0NNr8qwhRfnhChL7oWNv7AIgUEp+0nnZ\n+afWxN5+oE6GZaqe3wJSf//MJzcuQMRaSE0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc20", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `20` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICBDCCAaugAwIBAgISAWzFJvXPLHo6Ot8bQFJ5B2c2MAoGCCqGSM49BAMCMF4x\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xFTATBgNVBAMTDFRydXN0IEFuY2hvcjEt\nMCsGA1UEBRMkMTUzOWUyZjktZTE2OC00MGJlLWE3MTAtYTk0ZmZiZDczZmZmMB4X\nDTI2MDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVy\ndGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUT\nJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49\nAgEGCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbty\ntVSwktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajQTA/MA4GA1UdDwEB/wQE\nAwICBDAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPUX9jENtzmCpGvBHb18apX8\ng4VPMAoGCCqGSM49BAMCA0cAMEQCIH5JddS8TKJgkSpCmP8dG0q4s12Kl1PfEKyz\nbrwwONMdAiAFva5S7xgG7FCij5CEag0F+yCdEAAKWmMzVdjlWTLP3Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJjCCAcygAwIBAgISAZ518L0PoSG0SAmCUhhqNU9sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBUMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQswCQYDVQQDEwJFRTEtMCsGA1UEBRMkMWE0NTA3ZTYt\nNjhlYS00ZjM2LWIxOTctMDA1MGVkN2M1MzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0D\nAQcDQgAElr50LZtpLTTpMbBPVTx1xjD7VPjDAEvRdHjoQSvvxw599uuLNp6+oION\nQkLi5X4EVfjnfdJncSM1J3J8nQknc6NsMGowDgYDVR0PAQH/BAQDAgeAMBMGA1Ud\nJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSmacmwv0\nHQuFABoc7YS4a4I72PUwFAYDVR0RBA0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0gAMEUCIQCQ0OPxQNBrIHFYFUsI77wPznGZjuCeShXCBJzYk8202gIgY10eTEIc\nfM5Xepy/kn8OOGVSSwhTinc2sC0d8vg5BRQ=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc21", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `21` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcygAwIBAgISAZeCZWKv8s+Y+BLb/l9UsazHMAkGByqGSM49BAEwXjEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEVMBMGA1UEAxMMVHJ1c3QgQW5jaG9yMS0w\nKwYDVQQFEyQzZGE0YzdkMi1lNTAwLTQ1MWMtYjUyMC05MTNkZTBiZWZmYWQwHhcN\nMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBmMRYwFAYDVQQKEw1iZXR0ZXJ0\nbHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEtMCsGA1UEBRMk\nNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkwEwYHKoZIzj0C\nAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jdEQsvM2yVu3K1\nVLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNjMGEwDgYDVR0PAQH/BAQD\nAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0LhQAaHO2EuGuC\nO9j1MB8GA1UdIwQYMBaAFFbSatfP77Jy424wFTOq06uGOfPyMAkGByqGSM49BAED\nRwAwRAIgA97rO9bf92Eoa4rvdn9TsusiVpuZzIceJuiiAyi1LrICIHZG7p3qBklH\nhSJjoHwDK3AnWz3cPrkCRBulQqRkG0Cv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICJTCCAcygAwIBAgISASSSTppsMrMLgvEjLNUcoiHUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBUMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQswCQYDVQQDEwJFRTEtMCsGA1UEBRMkYzRiYjM0MTkt\nNzE1Ny00YzkxLWI1ZmYtN2ZlODY5NWMyMTE2MFkwEwYHKoZIzj0CAQYIKoZIzj0D\nAQcDQgAE/t6eSD3bDefDFdqyHHaB8JR6bYDQqSJD3YY3DFR2wl3I+4AzbcaKCpxJ\n2Hu01AP0+HFfXLebC+Q6wDaBDeE8U6NsMGowDgYDVR0PAQH/BAQDAgeAMBMGA1Ud\nJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUSmacmwv0\nHQuFABoc7YS4a4I72PUwFAYDVR0RBA0wC4IJbG9jYWxob3N0MAoGCCqGSM49BAMC\nA0cAMEQCIHxsBGx2vI5SjCbY3dz41Pn0ANoRv6biLkNolGE2N8UBAiA2eHAgxFIg\n8A0Z/TioU2vVqNOEA8fo3x08RcuqAn0YhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc22", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `22` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHzCCAcSgAwIBAgISAdLmGFyWwdz87mCRVcMt241/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGZjNDM5OWMy\nLTkyNTUtNDI3Yy05YmQ3LWNiMThiZGQ4N2IxNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABOdeFlz1aGNYc0c2AkfgE14cDz/zdLIQn1Ia9x8iSvB91kVFjvAUE6vb\nk4az2CDvUENGutU4aX6VygewsIAIeQWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQQfV6t03isF/0cupFz9Bro+wVGpjAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNJADBGAiEA\no/NIu55T+AA2BQh2Y8fQ+T+F4CzOzLPrG6oqY/fQ0loCIQClQ9flcYSETAqBQLVo\n6080hNHnR4C0f4CNYMd59b64ag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISASERVDEz39QLdVxFye24yBZRMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyQ1ZjY1ZjQyOC1lOWMyLTRhZDItYTdjYS01Mjc3MTdlMTQxZTIwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGZjNDM5OWMyLTkyNTUtNDI3Yy05YmQ3\nLWNiMThiZGQ4N2IxNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOdeFlz1aGNY\nc0c2AkfgE14cDz/zdLIQn1Ia9x8iSvB91kVFjvAUE6vbk4az2CDvUENGutU4aX6V\nygewsIAIeQWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBQQfV6t03isF/0cupFz9Bro+wVGpjAfBgNVHSMEGDAWgBQx7uzYqc1G\nwuvwaH++T8vX+dBeyTAKBggqhkjOPQQDAgNJADBGAiEAxcsz+h4wfRSi8bw3kNIJ\nby+TVgzPV/IgVY49V6z63qICIQDp9VA9QoBt1BihgCnYIBIu3IvkQR/TXYAlAj3Q\nlIInZw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISARod0fqLhhvyBlgRdX5B5AKJMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nZmM0Mzk5YzItOTI1NS00MjdjLTliZDctY2IxOGJkZDg3YjE1MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDI0ZDllMzY5LWYzZDYtNDExNy1iY2E2LWZh\nZDM5MjAwNmU3NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIoHpaod4wPkNxDs\nHGUe8UF21WrNNo+ifWwRupnWvdqHid6GPBHzJAwjLJ/sVST1YD4qUIZ6zeoobTzk\nWIDsfw2jbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBB9Xq3TeKwX/Ry6kXP0Guj7BUamMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAmf1QyAP7OIbq\nGMh5e2E+3sflaydqSgzigY/MIT4K38MCIQDLAqPYXG4UGn1hkDRQJ+ttNFYftfdf\n49ZiR4tLepPVpg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc23", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `23` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISATczQxE8QJzxqSeEVd9llBYzMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyRjODM5NGY0MC0yMzMwLTRjYmEtODI2OC0xMjg5NmI3MzViZDYwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGVkYmE3YTNlLWNlMTYtNDIzYS1iMDA5\nLTIzNzRlNWFmZDQ0MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFSXHb2sWXrY\ndmQHy8iGJy07EcRSRM/YXCt3k+7q0oh99Sj/RBpeh8pPpWT3pAhWw2W3sUkoS6HA\nbsbpwXYg9TejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBSRE+aq7Pn5y7NRhqZiUjYk2QH2gTAfBgNVHSMEGDAWgBQMkEZD82UE\n24+W71/rOkSr7cTxnjAKBggqhkjOPQQDAgNJADBGAiEAvPabkSZUZ11L3ZcxZJ13\n+QlNpXe2jA2LDXs8M1XgoUUCIQCxR+vJYaj5t1NW50NitKKEsNHhtBqA6ER8cHtE\noMh4eA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHzCCAcSgAwIBAgISAZJjkj9pPXh3D0eXnY3roHwtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGVkYmE3YTNl\nLWNlMTYtNDIzYS1iMDA5LTIzNzRlNWFmZDQ0MzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFSXHb2sWXrYdmQHy8iGJy07EcRSRM/YXCt3k+7q0oh99Sj/RBpeh8pP\npWT3pAhWw2W3sUkoS6HAbsbpwXYg9TejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSRE+aq7Pn5y7NRhqZiUjYk2QH2gTAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNJADBGAiEA\nruEeJ53mf9104iVuov7na4k07EzGVeJlWJUuDuovj0sCIQDwGCenXjP2qf9t0XXk\nNGtK73obfRlJV4hxJO0yxoLH9A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAT9a5nA1vcl6Be4D1l9IQDnqMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nZWRiYTdhM2UtY2UxNi00MjNhLWIwMDktMjM3NGU1YWZkNDQzMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDJiZDhjZDVmLTlmNWYtNDY3ZC05MjlhLWEy\nNTlhYzBiZDhhZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEwH4dqObuErzZb4\nnZFedutTntzCbBuGrbQRDq5lyCfTUE22xkAcZnorz/r+fKndkxQmJhIdn9x680PA\nQL8s4X+jbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJET5qrs+fnLs1GGpmJSNiTZAfaBMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEAmuzrJl68o0H8\nxepMF0PZJlzO0OKySmeHT8GRroWPWnYCIH48h8cVwsQnoiCi9npViSxB5l3DQtWm\n9/vxbDr/mWvS\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc24", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `24` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAdeihs8UJD/OlDoDbwc6dmDPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDZlYjI5M2Fj\nLTU2NTItNDc5NC1hNjVhLTdhN2UzZTUwMGQ4MDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNVsW9leSEgwc6AYtE+qyX6M1pcYjaWyC3jfXrBGxYN6h60r8m21GSs+\nzjKmS3e/ssQYyu+uoCG1riMLQNNlSiOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRPal/86j+EJO/pxe9SxBdu2ELJ6DAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiEA\n7uE5KJfiwQ6IswZR0fWFgHK/aR6L877r2OO/nuRbrjMCICp58TGFK2VwFN7smHPo\nxldYWHxU3TEXr2sobKR+k8dv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAUZ1SuaV8RA0jFCl2NDLblxeMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyRjNGE3YWNmNi1jYjZjLTQyOGEtYTE4ZS1kM2VlYjcwMDE5NTIwHhcNMjYwMTE5\nMTcyNTU0WhcNMjYwMTIwMTYyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDZlYjI5M2FjLTU2NTItNDc5NC1hNjVh\nLTdhN2UzZTUwMGQ4MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNVsW9leSEgw\nc6AYtE+qyX6M1pcYjaWyC3jfXrBGxYN6h60r8m21GSs+zjKmS3e/ssQYyu+uoCG1\nriMLQNNlSiOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBRPal/86j+EJO/pxe9SxBdu2ELJ6DAfBgNVHSMEGDAWgBRstn2SoIOB\nW8FaRk5kMAjNK38WCTAKBggqhkjOPQQDAgNIADBFAiBL9Rl+akBDRCWmPMJbCgsI\ncgg/Uath9aYLUmWlHa+AVQIhAI8qNlF4rwV/7Lk30my84z+hDBNFlviNfcv8+w3G\nU63v\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAWgAQE3QbKN1YUyC5AWb1TfVMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nNmViMjkzYWMtNTY1Mi00Nzk0LWE2NWEtN2E3ZTNlNTAwZDgwMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDg2Y2Y3ZDRlLTQwYzYtNDdhOS1iZGQ1LTI5\nM2Y5OWRmYjFkODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJOq+/e1gufeqlEs\npjm4tbEJ1g4RTs3ZVTluJlD4dmtXJbknPBBIs+1nS52lUVZ7OuntBsD/Nu4OV0UU\nYTAYh3ejbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFE9qX/zqP4Qk7+nF71LEF27YQsnoMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiA4uUwhOqtPFzTP\ntsVKTZsmU/xmkn9HBYix0OdIDIC2AAIhAPi5TrFHdk9VM8hxARxx/immmCqVTeeQ\nS6QTzrEVDYr/\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc25", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `25` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHzCCAcSgAwIBAgISAdw3ZKhVkkW8tbq30eHICrFcMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDUxNWQyZWM1\nLTU3YzYtNDY5NS04YjI2LTY2NjMzNDQ4MjNjZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ4YAmc9X3ooJrGurUlQUtG5TEelJFe4scdi5FHYJV2jzoGXwAwOmowj\nFzdxKdDz1bHXabFHlbTFv/8Oggg7DG+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSsLG8Tc8d27E8/GKb9jiQFh/JhoDAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNJADBGAiEA\ntENVCVb79t6OG4FUSKG0XcGfYYuZZrzP3Lvu7kU5gBcCIQDXPw/Rtv6tM6LwH0j/\nlB3dcuU+VqB7Q4EHctdjfAI6iA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISARwO9vVNIeyRZFjXI1I3vYAxMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyQxODliOGRlNS02MTExLTQxOTgtOWIxMi04Y2I0MDdjYTMyOWQwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDUxNWQyZWM1LTU3YzYtNDY5NS04YjI2\nLTY2NjMzNDQ4MjNjZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJ4YAmc9X3oo\nJrGurUlQUtG5TEelJFe4scdi5FHYJV2jzoGXwAwOmowjFzdxKdDz1bHXabFHlbTF\nv/8Oggg7DG+jgYcwgYQwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8w\nHQYDVR0OBBYEFKwsbxNzx3bsTz8Ypv2OJAWH8mGgMB8GA1UdIwQYMBaAFDaaW7L8\nU1+IKMcifGa3PEmkA42SMCEGA1UdHgEB/wQXMBWgEzARgg9iYWQuZXhhbXBsZS5j\nb20wCgYIKoZIzj0EAwIDSAAwRQIgLMc07VpouhihNOQNf5D3yY7KEWsLoUu2fdHL\nPrmV03ICIQDnbmdG5+PTL+hYO3NKGbqXOG33ncAYmLB7mu2ZeQPdlw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAaPOZoJW9wnVa+vuIOLiwGZbMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nNTE1ZDJlYzUtNTdjNi00Njk1LThiMjYtNjY2MzM0NDgyM2NmMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGU0ZDIwN2NkLTIyY2QtNGNiYy1hZGE3LWYw\nMmNkZGVlYzZkYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABET6IqP/wOW1YaTo\nnALKkM5uN8bcY8vb6gNRtTViBxTNzF38sUXrJTiF7gWUdbFWdgd14ho+u2Ot+tFE\ncU+mClOjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKwsbxNzx3bsTz8Ypv2OJAWH8mGgMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAdOec2qi+1d8No\naoRwK3YT0hWXFoxEsmLTnQ+NfQH7aAIhAPUqIAhsuId0t77Dkxtjcqez7bE5tGxz\nxUyOW8UyGYnt\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc26", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `26` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcSgAwIBAgISAXJoIZMx4H0ClQ1FyZUCjh95MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDE4ZThmNDM3\nLTM3M2MtNDc2ZS04Mzc2LTBkNDU3NjA0YWM2NTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAUhJPX9hC07u3EmgYR7Pn3nD+XbgSoXJygQsoMibrU8tt3tSSSV72jp\n8SykiE4ktpkudPPSSc5Uqj7Db+aRD0ijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSNTfaKcWbjlKowXg3kQKsOvhuzZzAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNHADBEAiAR\nKgWdeAGMFKqNE5O77JtrSCyulcE9M2C0VwFpo0yh3gIgPVaHpG+9b7jMc27NUQwR\nNFZOfUgAcgYvYD7Atq9TAWc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcqgAwIBAgISAeCZHenoJlTCPS+rep23w6jqMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyQzY2FmMTM0MS1mMzBmLTQ3ODItOWExMi02MzAwZTc4YWE0YTMwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDE4ZThmNDM3LTM3M2MtNDc2ZS04Mzc2\nLTBkNDU3NjA0YWM2NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAUhJPX9hC07\nu3EmgYR7Pn3nD+XbgSoXJygQsoMibrU8tt3tSSSV72jp8SykiE4ktpkudPPSSc5U\nqj7Db+aRD0ijeDB2MA4GA1UdDwEB/wQEAwICBDATBgNVHSUEDDAKBggrBgEFBQcD\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSNTfaKcWbjlKowXg3kQKsOvhuz\nZzAfBgNVHSMEGDAWgBQCPl96s8BsBh7vGHJrmWkJsCki0DAKBggqhkjOPQQDAgNJ\nADBGAiEAoQLD9Tm4NXQkIkLj5q+Q6OVAeBzB7tr/xENwn08mVkkCIQC1LlPL8mxi\ndDJkgJLdPQecnkKwPwBEXmR7rFLC9RGGrg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISAex2m2wXxvWUDXATNpNTWjDEMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMThlOGY0MzctMzczYy00NzZlLTgzNzYtMGQ0NTc2MDRhYzY1MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGI5OTI1ZWJmLTdmOWQtNGRjMC05NWMyLWQ2\nMjEyYjMwM2IxYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJRW3vSgRbvZseHS\nM+mWlcI6VntbwHKYl1gDqZ18Cy9+wRkUsIf1e2e52Z8n9iQBCSjizsWTCsS8hyE2\nhTyEY2ejbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFI1N9opxZuOUqjBeDeRAqw6+G7NnMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAln4tEjfCoc2j\nPFZKDnOfI5NT3bm6iooqirjyCAA0juwCIQD9Bn3B5UcM61iwo2NaDY67aywT0FVg\n+74/9Q4FmtRxUw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc27", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `27` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAeZAYfOec+5LNbUUSaFMfEojMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGQyZmIyMmY4\nLWViNzAtNDA5ZC05N2YwLWFiYWJkMWRjOWE3YzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABD/VRZXSBsD8YeWq+nEWITWt+ov/bYiT+OD+eyT4yUl6PWgRri4nxwhh\n79U2vERr190SiIbK/gA7pThh0tVltNejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQUBMwVjnrsNFxC+5BMi9k5hCrYEDAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiAn\ny0mZrb4mVa5H1nVVx5ovIjgJDC9NNkc3Hc1B1Sj6JwIhAPRbXUNPdgU+fE1QBgZM\nJEZF8Nn5aIxEPhAzkI8bXFod\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB/jCCAaSgAwIBAgISAZU+R7/RNcCLp41G7fRYkupaMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyRkNWFlNjU1Yy1hZmU4LTQ0NDctOTAwZC04NDcxNzRlOGQ5MDMwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGQyZmIyMmY4LWViNzAtNDA5ZC05N2Yw\nLWFiYWJkMWRjOWE3YzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD/VRZXSBsD8\nYeWq+nEWITWt+ov/bYiT+OD+eyT4yUl6PWgRri4nxwhh79U2vERr190SiIbK/gA7\npThh0tVltNejUjBQMA4GA1UdDwEB/wQEAwICBDAdBgNVHQ4EFgQUFATMFY567DRc\nQvuQTIvZOYQq2BAwHwYDVR0jBBgwFoAUf6y+MW4gyNFele2sPOz9vuxinIswCgYI\nKoZIzj0EAwIDSAAwRQIhAN37N4nvQUin8wiPXlpfKG2AUA+8/epHSS0yqZvWUR55\nAiBhFKtaD9pOyKZ+0WG07XAMaZB3jboWq/Bf0d33G7bEPQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAXvew6OoPLro7tjgGyikuB/RMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nZDJmYjIyZjgtZWI3MC00MDlkLTk3ZjAtYWJhYmQxZGM5YTdjMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDMwMGIyMTU0LTVhOGUtNDg1NC1hODU1LTk4\nODU5NTJmOWE4NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABElFilV91lmECb72\n6dAWDMOmTcwBnvSMYY0i6ZZa8SzTDMAekHToAamawu5xOX7ZxHvDvHwVZxUoYGDj\n873kMuGjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBQEzBWOeuw0XEL7kEyL2TmEKtgQMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBumhR0bOgUR95+\nAdatlYlckAzwf1MWO98a1hXFGHToIAIgMxuFXfmBJMAjPA11qyqjVZja8AQiknBw\n0GVr6E30OQA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc28", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `28` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHzCCAcSgAwIBAgISARAhKax91XhVtKYGb5biyyHtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGVlZDcwOTll\nLWQ0OWYtNDllNy1hZDk1LTBjOTIyZWI0MTMwYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABFCAjEA9Eu4QEnpYmSmID2qGHNi/cq5wuVEW30OiCXtya+H4177nJHdh\n8sRabBwy4RDHjvSM1Fg58RTCyhXvC0yjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQMdnEDPjdBY2xNr6LTer7GYb295DAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNJADBGAiEA\n31S5yk1yk+x0ckmAfzUTrlKYDs1Qwo246eM8Wb/J7uwCIQDRHIoVh8TUOGzmIBDZ\nvPjjRGDvRt2rZbnxVoHk+1cspg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB7TCCAZOgAwIBAgISAVRv9VhDUdnwBGMEXqc+qrWbMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyQ4YTVjMDc1ZS0zMzk1LTRkODgtOWZhNy04ZWNlNzg1NTA2MjEwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGVlZDcwOTllLWQ0OWYtNDllNy1hZDk1\nLTBjOTIyZWI0MTMwYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFCAjEA9Eu4Q\nEnpYmSmID2qGHNi/cq5wuVEW30OiCXtya+H4177nJHdh8sRabBwy4RDHjvSM1Fg5\n8RTCyhXvC0yjQTA/MA4GA1UdDwEB/wQEAwICBDAMBgNVHRMBAf8EAjAAMB8GA1Ud\nIwQYMBaAFLwebIB5RKkP+5V3D5Yddnjo59/aMAoGCCqGSM49BAMCA0gAMEUCIQD4\npaABxCOVQd3v9hEHeBsoqklmJTWhn2jQdCbwPu5DSwIgL+keBLQe39SXzg+1gRCT\nB8reTSoOhKCN5XfCSP/wfgw=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISAe7EsfYuNkpIPOlZD6Q2MMB1MAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nZWVkNzA5OWUtZDQ5Zi00OWU3LWFkOTUtMGM5MjJlYjQxMzBiMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGRiNjBhMGYzLTQzNmYtNDVlMi04NDQ0LTZj\nMzA4ZDQ3ZmNkNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKYazbIzc00jUfjh\nQqPkh6WzsaZQiBiDt5hTHE2O3GyqF0u2gpjDB9ZShZHc6MxLVvLkoWMbHRuA01d8\nAzUQdtKjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFAx2cQM+N0FjbE2votN6vsZhvb3kMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAm9KAGovKb4rU\nQJ3nz2D9Kx2onZWoXfErU3Hoo4bejwUCIQDsgKxslqqXURK8zOSA6XqmdZavOgAb\nC5PMkextlg0YKw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc29", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `29` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAamB4imrRAMrvN2ZRwOOpTLnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDgzNWM0YTFj\nLTZiM2QtNGJhNS1hNjg2LTRlZTkyMTZkZGVjMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABI8kCpcrZfctb7n+HT/IkU7ggTY7Msp5pduJLIYubtUXgH+UGH2YxjvM\nrmsSk8sst8xCwH9YeqpkxRWfYrVVTFSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRyMR5+tsHwan1d9Kqnouopq5EhbTAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiA/\nJQV4mlpuxDmgO/tEM2P6mSRG6Cy2SPjYqxBm5Z/WOgIhAJStlzTIn74PbFqb07NC\nEY+m/YnkiQ+zG8qR8FJ/6aiC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbSgAwIBAgISAUlmPdvgYwWlNQ567mUwnEjnMAkGByqGSM49BAEwVzEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEOMAwGA1UEAxMFUm9vdDIxLTArBgNVBAUT\nJGIzZGRmZDFhLWUzMmItNGM2NS1hYmE2LTA4ZmRmMmQ5Y2M5MjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFUxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMkODM1YzRhMWMtNmIzZC00YmE1LWE2ODYt\nNGVlOTIxNmRkZWMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEjyQKlytl9y1v\nuf4dP8iRTuCBNjsyynml24kshi5u1ReAf5QYfZjGO8yuaxKTyyy3zELAf1h6qmTF\nFZ9itVVMVKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYD\nVR0OBBYEFHIxHn62wfBqfV30qqei6imrkSFtMB8GA1UdIwQYMBaAFEYPD3lDVwXO\nokn884dDR9Yir+/6MAkGByqGSM49BAEDSAAwRQIhAOMwcIIpIkT+tepGyG0XZTod\ni51yB2hcK88GWoWXbPEuAiAK94Uxq7Ba9NuH1wCLPKHgdSSiBZTe7ogVJAsvYnAZ\nbg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAV/InNJ4XSfGJ7VSoCJsgWqMMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nODM1YzRhMWMtNmIzZC00YmE1LWE2ODYtNGVlOTIxNmRkZWMxMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDlmMmE3MDZiLTU0NzEtNDMyMy05NTBlLTY5\nNTU1MjdhNDk5MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABF67DoSk/+d+JvtM\ni1JWbNn+lxoXk8l9SUaHzTBlNy6RassC6KucH1HmND03xGCQg9CjoDGsTXEEv/Yr\nautfP1OjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFHIxHn62wfBqfV30qqei6imrkSFtMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAtkJu/kKZd4z/2\nRmAArlFT07gi0TwYjVntd9VjVgmnaQIgc3MPlAbKD2q5AyNfYDCbCXjrVBQREl2f\n3QjBajDKeYo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc30", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `30` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISARcg/as4V6UzpF1l1izUtXISMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyRmZTBhOGRlNy1lYmMwLTRkZDAtOGM4MS0xYjI5ODc1M2U5NzQwHhcNMjYwMTE5\nMTcyNTU0WhcNMjYwMTIwMTYyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDI2NGY1ZGRhLWMzYTMtNGNhNC05MDBm\nLTYyM2M3ZDM4YzllYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABC0kribhwLe5\nxdGTyNyeV4JaQk4jIeXtoQ7wb1a4FbYGl4gaO9wtZQ6uMDfZxkErFAiUeHhIKLk4\n81TS2Fnw3byjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBSwkE959ZirP6CYqqm2TNA2rG8ELzAfBgNVHSMEGDAWgBQKxILZyVv0\nMF1kxFShe/8F4+UFVzAKBggqhkjOPQQDAgNIADBFAiEAhwCskyiStj9DM6G9AD5g\nQyhZU8nBupfjbmTaUETGcH8CIEC5+E5smvntCNZRa7AKD4Pfsx0uOBJvECEz6tPp\nrJcq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAc4NEn7MKRvv+DoPA9yCytXiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDI2NGY1ZGRh\nLWMzYTMtNGNhNC05MDBmLTYyM2M3ZDM4YzllYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABC0kribhwLe5xdGTyNyeV4JaQk4jIeXtoQ7wb1a4FbYGl4gaO9wtZQ6u\nMDfZxkErFAiUeHhIKLk481TS2Fnw3byjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSwkE959ZirP6CYqqm2TNA2rG8ELzAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiEA\njJE3ZTR5YZ/qZgbv7BgqlqX0Y1ro3nYJ/yZN8tXGjwMCIH1LOkLF8wViXWLGJnUD\nmPs0MTOv7vt1n83mGxGqQC2E\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAXOktLl1oTSbY+Cw5i6+SMRqMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMjY0ZjVkZGEtYzNhMy00Y2E0LTkwMGYtNjIzYzdkMzhjOWViMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDBmMjI4MzI0LTcxZjktNDFiNy05NGNjLTc2\nNGU0MjMzOTVhMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLIvJtRrvJWjZUb9\nZvCjB/5YPnmMH+eotr4pprT9DsrtYZ9Eeq6W+halK4nU10tKpMZJcgQiarSONCN/\n3/TFbqujbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFLCQT3n1mKs/oJiqqbZM0DasbwQvMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiArPmbHnXX87uB3\noa+0lIHkqepDay+Gh2Ll1lWkFsG1BwIhALqKwYPWf0zq7nlZ7p8F+yJrPmUYTlXP\n9dJL3RCm0AGK\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc31", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `31` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICNDCCAdqgAwIBAgISAQhYXaIsG3gF6WMthgSnlTr5MAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyQ4Y2MzMWQ1Ni0yYWQ0LTQ5ZmItYWRkMy00Y2VkYzcwMDA1NDAwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDQ4MDZkYTZjLTI5NjItNDA0NS1iZDYx\nLTNkOGEwZjMyMjgzODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK6i80HUq/+5\nF8+hOxoCaFcAdeoyBlVzQlC6Tnjj0sIL/V1VWTskT1JBFWj7ASA0FlSEz3XvTnKM\nIw2M0LPY7wGjgYcwgYQwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8w\nHQYDVR0OBBYEFMlddrX99w4wbNOTgk8e9X8E2tCUMB8GA1UdIwQYMBaAFL3agbwH\nhI3QJWsBBWXCmv4ICBfsMCEGA1UdHgEB/wQXMBWgEzARgg9iYWQuZXhhbXBsZS5j\nb20wCgYIKoZIzj0EAwIDSAAwRQIhAIspeTuONYLiO7QhgbK5OIRwEpAxWuLlU8Z8\nBXpKwtkcAiAody2i9kUexdod8JRZKLpu/ZGPcB4G0Yn93keKhwuUGw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHzCCAcSgAwIBAgISAfdr1FAAKVrUBM117o5983OlMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDQ4MDZkYTZj\nLTI5NjItNDA0NS1iZDYxLTNkOGEwZjMyMjgzODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABK6i80HUq/+5F8+hOxoCaFcAdeoyBlVzQlC6Tnjj0sIL/V1VWTskT1JB\nFWj7ASA0FlSEz3XvTnKMIw2M0LPY7wGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTJXXa1/fcOMGzTk4JPHvV/BNrQlDAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNJADBGAiEA\nyqcrSx5FXYFfbn1RJjsK1oE4u2u4u+/CoMBWE+8ZfNcCIQDtnivkjKPitJPdZBMo\nb0fVu1N9naylqPjgKfo+YArPQA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAdNn1OOruBzysD6+1QYRrKAEMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nNDgwNmRhNmMtMjk2Mi00MDQ1LWJkNjEtM2Q4YTBmMzIyODM4MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGFhMDhhZGUyLWY0MDQtNDdkYS04YjIyLWVi\nOGRmODQ2NDUxYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFCKyo7sN+KmbvS6\nlFwQIu66Bt1aJ5ZOgOtxlABETa0P9maE/EO2kzJ4yuMdl3rQSabw5svSVsFisIHM\nDgOJj9qjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFMlddrX99w4wbNOTgk8e9X8E2tCUMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBO69JhA5z41XtZ\nCJfqlFRyQHUrCrQOd+1CIuBm4g6CNAIhALWB4R73v55j445i+jWayYTr2KsJEegz\nC5DwJdmilwhD\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc32", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `32` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAadKiIORVrA3b4DQTLBhGsvuMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyRiZDYyMTNmZi01ZDliLTRjNDQtYjgyYi1iMTk3ODQwNWVjMDgwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDUwYjA3ZWY4LWQ4ZWItNDc1Yi1iNzkw\nLTNkZjgwNDg1OTQxNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNRetGkOkmz+\nKHVOnMGl4CzHzEDuoVrG7LtqFX1jxdXaarejGowWKPK/1e8Z1MuQ1zd7JgA73m0o\nm/CNIRsQtryjeDB2MA4GA1UdDwEB/wQEAwICBDATBgNVHSUEDDAKBggrBgEFBQcD\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTeWrUD+UBNfy7zSMyBacA/Hwbh\nMDAfBgNVHSMEGDAWgBSwU544yRlX2ReHBqQYOB4/YrJxSzAKBggqhkjOPQQDAgNI\nADBFAiAcULDCFXZECX327z0THp9IETuFgEwqaoqUdhuNWg/hRQIhAMhYuyvyrCHq\nFZukh/XuqLXdnbxLSGT26nRixXTA0d1v\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHzCCAcSgAwIBAgISAR195KQx25kTAaO120C7fElWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDUwYjA3ZWY4\nLWQ4ZWItNDc1Yi1iNzkwLTNkZjgwNDg1OTQxNjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABNRetGkOkmz+KHVOnMGl4CzHzEDuoVrG7LtqFX1jxdXaarejGowWKPK/\n1e8Z1MuQ1zd7JgA73m0om/CNIRsQtryjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTeWrUD+UBNfy7zSMyBacA/HwbhMDAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNJADBGAiEA\nnMn/srsaRl3KftrZpmsIwBMYtTr0UdSHqBHX5fwR1ugCIQDCh5e7OoUDVGXJWl5h\nSuGI5ptUbxjvU/oOwWpO2sMAPw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAX+KYQr3ulIIj3mxZjxfNe0LMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nNTBiMDdlZjgtZDhlYi00NzViLWI3OTAtM2RmODA0ODU5NDE2MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGE1NmUzOWQzLTE5MmQtNDQxZC1hMDllLTY2\nMDM4Y2VhM2VlODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGe+mcWyZ9eGXs3/\nW/X43lfYryhvbXPW+iRYtwkwtwUCc1F3pdZQ5jd+dRI3IFmLnMH84xlnPZSm2wb2\npAy8zYSjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFN5atQP5QE1/LvNIzIFpwD8fBuEwMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBwkqCtUCWrwoO+\nQOHhyBjYshA84Q7hXSb7Dma2mYI5hQIgEil873lVkX4glKH6hhgXnhWjiF3q30A8\nNBGlY8gzJX0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc33", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `33` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaSgAwIBAgISASRLY9feOCcIUXVFU94CE+IuMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyRmZTRlYmNmOS1mYmFiLTRhOGEtOTMzYy1jYTZmYzhjODRhMzQwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDJmZGRiMjFmLTE5MTMtNDExNy1iYTE1\nLWU2YzgzMzQ0OTkyYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAzoag9hqoH5\nUnWN51p2n7Tt+15T/TlCfqGugx69dKyryRZkOGwHPQS9nfHZGLmqDbX+Rj1Cnp9Y\npGd6O+ukogajUjBQMA4GA1UdDwEB/wQEAwICBDAdBgNVHQ4EFgQUFbp9ZS5bSi/4\nT7pIhOwPsU98ALswHwYDVR0jBBgwFoAU2z4jODdY5GQA75DenNacJlEMmxEwCgYI\nKoZIzj0EAwIDRwAwRAIgfvflirYrlqDuwzc6CcALjSby/LRUOrtMpFXmgPB0L9IC\nID9PLHwRgdmrXDgRuzDmt0aviGBkdKIexB+iE42LAl0m\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAUiPxj+t03wVhXRzK+eOl5qPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDJmZGRiMjFm\nLTE5MTMtNDExNy1iYTE1LWU2YzgzMzQ0OTkyYjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAzoag9hqoH5UnWN51p2n7Tt+15T/TlCfqGugx69dKyryRZkOGwHPQS9\nnfHZGLmqDbX+Rj1Cnp9YpGd6O+ukogajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQVun1lLltKL/hPukiE7A+xT3wAuzAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiEA\n9qOhMZwAd2SXGpPaX28L7KUx9lRhmLdZ3MsLLxHSx0UCICCg3RERuBF1qeDK3g86\nfRdrwiQynaxKx0iUFyyb+yBr\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAQBfYZTSxZmukMqal6BUmp3WMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMmZkZGIyMWYtMTkxMy00MTE3LWJhMTUtZTZjODMzNDQ5OTJiMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDQyM2JhNjZiLTI1OWQtNGQ1Ny1hNDZmLWZl\nMzZmMjE3YTFjNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABARalT35fef5+iXf\n4b4phWywICO03lddZ72azzEEezvhZ13ebiCKZDg1NxraQkQFbW098mPrLI9dc8eJ\nxzGGUzejbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBW6fWUuW0ov+E+6SITsD7FPfAC7MBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiA8TCrcBVivO/IO\ntutjLsAcYdHcI/7F/q9JwCrZKMUAawIhAP9fH/1qiFgwqs/Th9JXQMlwsArp3hOe\n4hMRHWzIgBQk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc34", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `34` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB7TCCAZOgAwIBAgISAaJn1z8fTfOTwYBkQQTZQrCaMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyQzNDkyN2U1NS1mYzdmLTRmMTMtODE1Yy1lMDJhNjNmMWY2MjEwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGIxMzViOWQxLTAxMWQtNDRhYy05OTZm\nLTcwOTU1NjcxMjA2NzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJ441VGXkEw7\nUxFlflxDrbf4MiWLcxS3b15VsVjGMiZKyR6+L+Zwk2tfHngaEmmsRvgH7hFHXpKq\nYKe/an2iqt6jQTA/MA4GA1UdDwEB/wQEAwICBDAMBgNVHRMBAf8EAjAAMB8GA1Ud\nIwQYMBaAFCR6uvcyTCYMwPlHxTKVvHGJTCM/MAoGCCqGSM49BAMCA0gAMEUCIQCf\nvBGiPPt8S3DoJzmIwumg3Pm5N3Wy0pEJ2HC6EK6ybQIgchDex6eY0RUpWtHwSyeH\nf/GxjRRCkDAqYIucm4bZRNU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAcA+LtAlvu8TmT7yoaKPVY2YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGIxMzViOWQx\nLTAxMWQtNDRhYy05OTZmLTcwOTU1NjcxMjA2NzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJ441VGXkEw7UxFlflxDrbf4MiWLcxS3b15VsVjGMiZKyR6+L+Zwk2tf\nHngaEmmsRvgH7hFHXpKqYKe/an2iqt6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTrzkeW+uxVAIDfIM9tu/+lunaW4TAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiEA\nvUXBBzwAJpXeWS6BXfmT4ssBJoeRMeEBswVzlS1N4J8CICm7Yfsif9gaGCkL6tsk\nunm9kq6OxKB7+FnowM5nqy33\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAVhTrVVmYxej3j+SFJg1tcnaMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nYjEzNWI5ZDEtMDExZC00NGFjLTk5NmYtNzA5NTU2NzEyMDY3MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDFhMWQ1NzI2LThlMjAtNDJjNS1hZDhhLWVh\nZDgyMjZhYWVmOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABA8i2K8xS+T0Pgkx\njPVY/f0ClmgfT0Zq3SkFHj2/1aFYt2jz7wCRuAhg12tArHte68EtYcE84kC4tVxp\ne+NXbxijbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFOvOR5b67FUAgN8gz227/6W6dpbhMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAsfg4GeljnhLdL\nEBbJrmxaCnSzIwvTqivoNkNsnKZf8gIhAP29uMxSHii4caCQr6GTCuaz+qnDqCbv\nraA1+MNu5eO1\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc35", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `35` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbSgAwIBAgISAa7YN12bndlth22xl/tVmp6jMAkGByqGSM49BAEwVzEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEOMAwGA1UEAxMFUm9vdDExLTArBgNVBAUT\nJGQ1MzQyYzA4LTc3OTAtNGVmMy1hNjc0LTM1M2ZkMmZjNDMyYTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFUxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMkZTcxZTQzZTEtODEyYi00ZTI0LTliYTgt\nZTc2MjJiZjM2OWYxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN3IPYF6e0rC9\nGAyHoieTWmn0qiUApuwgVp1vbcMxfizn4pN8tK1Fm4eQuGv/5yzp5vQpBEz8M42u\nvGML7cR4uKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYD\nVR0OBBYEFPwMgDNX9Xbzjr03NeVx8cbt1xPSMB8GA1UdIwQYMBaAFEkc3VYWuLbl\nmpMVZGUpmmDKUsjsMAkGByqGSM49BAEDRwAwRAIgJyHThy/MT1EMqOXjVWBkr8r8\nRj4tR2WdNnhnoaFZKM4CICQsx4wUKzRQLiCraF/jBkowp5WcC7BYXnQvLmU/KDt6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAe/TuzdlPlzh0IixI09sUzCeMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGU3MWU0M2Ux\nLTgxMmItNGUyNC05YmE4LWU3NjIyYmYzNjlmMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABDdyD2BentKwvRgMh6Ink1pp9KolAKbsIFadb23DMX4s5+KTfLStRZuH\nkLhr/+cs6eb0KQRM/DONrrxjC+3EeLijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBT8DIAzV/V28469NzXlcfHG7dcT0jAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiAn\nRwFhK0ykZ4CxsRCrbbW88s/GOxGzqzsJD0JWi67wiQIhAMfE44aDExtrVb8+WpCF\nGKiPVZSLv7hohKmRPB5QuI8I\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAfRLbGPJdWHpnyZWmkx56MwtMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nZTcxZTQzZTEtODEyYi00ZTI0LTliYTgtZTc2MjJiZjM2OWYxMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDgyZTRiZDUyLTcyYzMtNGE2MS04YzIyLWYy\nOGY3YWEyNzNiZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD7o45DMYyDmMPX+\n07v++kwv6t+iGvR1JBsAOfmOKQoGTjciTZCJkUgkaK38OKa7tOiTUOEIJNzmRmiM\nnHk4wzijbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPwMgDNX9Xbzjr03NeVx8cbt1xPSMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiBk0DfHSUomqZQ7\nsAW+KjocMrvftxI/x9tT1ctxa1ZuQAIgZtG6oAMoi5G3KmcK2vr+YM46yn/PCYQG\nzNpQ2zU8glY=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc36", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `36` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAYQNBYFDB3YCtfFUcB8ckuD4MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjYwMTIwMTYyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDMwYzdjNDdl\nLTFhYjItNGE2Zi1hZDY4LTUxZTZkMTg1NDEzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCVUlwa/QeS8Ki7n6pkOoI0FG6t68Ezh7GX8IjHw6CKC2zB/CaT5rqer\nBnylXGQIV0Umbriq3sn8e/qNbgdZO1KjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRnTPTgQVmKXezfkINAIdGZXCYurTAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiAu\nV5wXaGptEmGAEA9YUQtNV3yKTA0ATdOdVRhS5gG60AIhAJ3VgBsN191rQnxG+IlS\nhlAm5TQpu7ikx+9+CFrin3Zz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbWgAwIBAgISARWmR2+cwp7mbUUwRny7zzI7MAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyRkYThhNGFhMi02MDA1LTQxMWUtOGIyYS0yNDZiNzg0ODVkYzYwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDMwYzdjNDdlLTFhYjItNGE2Zi1hZDY4\nLTUxZTZkMTg1NDEzZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCVUlwa/QeS8\nKi7n6pkOoI0FG6t68Ezh7GX8IjHw6CKC2zB/CaT5rqerBnylXGQIV0Umbriq3sn8\ne/qNbgdZO1KjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBRnTPTgQVmKXezfkINAIdGZXCYurTAfBgNVHSMEGDAWgBRPhh23UwXZ\nj2/fVGey1HRONslUOjAKBggqhkjOPQQDAgNHADBEAiBsA8VbporZSFFy6STpL3gw\nck49cHFHwmEscvKWD2oDhwIgXZIUKmaS2FJv8aocCY479nKELFEnLI2gVzJMEnXM\n+Ls=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAW3iXW8A8AqmNtnB+Xs1QcuKMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMzBjN2M0N2UtMWFiMi00YTZmLWFkNjgtNTFlNmQxODU0MTNkMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDRhNTYxZTRlLTVlZmMtNDY4ZS1hMTZmLTZk\nMmIwNTU2ZmU2ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOveMBtUdB9o3Vko\n1RhZ4gk68AFCF0bGcWxc1DYUJJYlisOTkR9m/HSRjEGSdgkfjHyS5jP7mfk8U/Zj\nYmoZ4uCjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGdM9OBBWYpd7N+Qg0Ah0ZlcJi6tMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAvKwVwkCOUQyKJ\nBzAycLz98ZZophv1wFT0U2AqKbdq/wIgLKJ7yqBoZzYW7bEXoFb9ct8Tyl6c5kvD\nwsTVDNYsj6s=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2027-01-21T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc37", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `37` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICRDCCAemgAwIBAgISAaYAjH5Kq7Au81cHMJxdNM40MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDM5MzA1ZTU1\nLWE5NzEtNDc0Ni04MDg3LWM4ZDhhYjMzNmI2ODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABBh2fgbMW315F93A0FAbHiGoVExCbbMoXF2DHHHCQD3CV3zTtLZ/voL+\nlAkk34tPtLDIysn1AeMIgjWfzUt3PUmjgYcwgYQwDgYDVR0PAQH/BAQDAgIEMA8G\nA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFPhkvNwBDElMfo8dF8qoztaCJblnMB8G\nA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MCEGA1UdHgEB/wQXMBWgEzAR\ngg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSQAwRgIhAL7bxVCStWbcLtgf\nYFmOEwQCNG+Rt5Yo++x3vFsa6tFTAiEArgoGszeQtV/IUhBtDoSe1BV29UVT4z9g\n3DK4s42+lNM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAS9Y5f6jW7lkNCOjnUh+uJB5MAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyRlZWE4NDdhZi05YmIwLTQxZTktOTY5ZC1mNDEzNzNlY2VlMTcwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDM5MzA1ZTU1LWE5NzEtNDc0Ni04MDg3\nLWM4ZDhhYjMzNmI2ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBh2fgbMW315\nF93A0FAbHiGoVExCbbMoXF2DHHHCQD3CV3zTtLZ/voL+lAkk34tPtLDIysn1AeMI\ngjWfzUt3PUmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBT4ZLzcAQxJTH6PHRfKqM7WgiW5ZzAfBgNVHSMEGDAWgBQLMvTG32lz\nrCgU1CptJJFRmb0LdTAKBggqhkjOPQQDAgNIADBFAiEAjXN5DTguATCPcJaQoTCr\nQB0CBZMLOvmTn3pvsJu/ZiACIHBngTBXxUlssohiMligzywVunn1q6kX9eiyx0sJ\nZp+T\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISAVnlltPnRdH6fbjrpTA95OKWMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMzkzMDVlNTUtYTk3MS00NzQ2LTgwODctYzhkOGFiMzM2YjY4MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGFlMjVmMTYxLTc3ZjQtNDA3Mi1iMDA2LTU0\nZjdmNmRhNmEwNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJ8lac+qb/OAE9ZQ\ncre7XRR/x4oKd0em6mHHmnh+XAW8Z5sCP4VSZX1klYdg3r6RE/UEPRYjrzSuuoRS\nQnX4RYajbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPhkvNwBDElMfo8dF8qoztaCJblnMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAjCb9YlPRLiPS\nfbYLXaJshF4CP4y1fSpNSQQuWbEaiDICIQCUkYRvyx2ph8aLvYleBWlB3ZBFocUW\nUBV0opvEc1U00A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc38", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `38` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAa4LF9Gi6Y8bz9mVVWXv3vDhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDMzNGM2ZTFk\nLTU1NzgtNGVkNi04MjdjLWIyMmE1ODg3NGM5ZTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMHFKQnEP2pp6IolU8ZMnIAIrgqCUYY92l4rzfv6/5ZCpj04gL5xrzSU\nBrDljjlq4KtzMSo0+AOaoOCyUtUcT1+jeDB2MA4GA1UdDwEB/wQEAwICBDATBgNV\nHSUEDDAKBggrBgEFBQcDBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKUJzw\n2a1b8vLa4QMaRDH5bbyPezAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAKBggqhkjOPQQDAgNHADBEAiAnwwro5qlv54fHDC1OMdlxqnzlWaADvvmMEMVg\nDX3GLwIgPx2w58TEnKD5F8bn0fOpNekUnYUCRVP02hDBVysg0+I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAXPz1Pq8DSQxeJrVRMbVTchPMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyQxYTIxMTBiZS04YjNjLTQzYTktYTg0ZC00ZjVjNzVhY2E3MmMwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDMzNGM2ZTFkLTU1NzgtNGVkNi04Mjdj\nLWIyMmE1ODg3NGM5ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMHFKQnEP2pp\n6IolU8ZMnIAIrgqCUYY92l4rzfv6/5ZCpj04gL5xrzSUBrDljjlq4KtzMSo0+AOa\noOCyUtUcT1+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBRKUJzw2a1b8vLa4QMaRDH5bbyPezAfBgNVHSMEGDAWgBRO/O0hm19X\nNvfLl+yiuevdfTM9TDAKBggqhkjOPQQDAgNJADBGAiEA3PlvRKfz16aMnsNoDTuv\nZxAgIzreBPv11CaRYv+VOgICIQCq4FSW+aAQ76D0IF6pFicCYu0gcYCrBc9tlXvU\ndBJs1A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAbmTLHTatk08v+CSLfdaQAACMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMzM0YzZlMWQtNTU3OC00ZWQ2LTgyN2MtYjIyYTU4ODc0YzllMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDJkM2MxM2E2LTA0OTktNDFhZS05MzMzLTcz\nY2Y4YTkxMGRmMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAsIh6nOArUKLMfx\nYicQg97mH9XTRKizYa/+O10mZIeofjJHC0uW3Ni8BUcjKllMLFkdp3jDWyV6AJJD\n+rEV6SGjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEpQnPDZrVvy8trhAxpEMfltvI97MBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBrhhaNAyHdRhNY\ndwhtOvUePssEJqtS37VoynuzJw5QOAIhALDmORJgRmbTllQ+OCj8OwtHt0vSjlSj\nyc+HA3GjO9uk\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc39", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `39` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbOgAwIBAgISAfoid3QmBZHaGWJLORO/QRzDMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDA0YWUwNjVk\nLWQ4MzUtNDRmMi1hODE3LTcxYjgzYmNiYjMxNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABMeS82bFA5e30am4KTs2IYF/U/tHdaJAjFgd8jfEFuiXGLHCMLLhkmQv\nccCkjiYA1aB+9bBg62tTdAmynjqJKOmjUjBQMA4GA1UdDwEB/wQEAwICBDAdBgNV\nHQ4EFgQUZYmbCaDewmfkHe94+ODKJsD1dz4wHwYDVR0jBBgwFoAUSmacmwv0HQuF\nABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAI06hkGZU6IpOqZrLWRrXaci\nFQlw/5/Bq/wGHk1yWf3MAiAlVmYsQipHlqKBdch1W/L5ysvUa/m2BYz1cZoGOnoI\nbw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAdaGf873iMhVXhZYnTnGcN7MMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyRiODBiNGUwYi0zZDI5LTQ3NDgtYWYyOS1lYzgyMTE5YjQ1MTUwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDA0YWUwNjVkLWQ4MzUtNDRmMi1hODE3\nLTcxYjgzYmNiYjMxNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMeS82bFA5e3\n0am4KTs2IYF/U/tHdaJAjFgd8jfEFuiXGLHCMLLhkmQvccCkjiYA1aB+9bBg62tT\ndAmynjqJKOmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBRliZsJoN7CZ+Qd73j44MomwPV3PjAfBgNVHSMEGDAWgBT2JiP9XJOV\nzVfdeXVCYac4Vn/viTAKBggqhkjOPQQDAgNIADBFAiAuvt4dpzPuzgl5uD+E11j3\nrsGQQ/AWDkEhK/b3NVMaowIhAPKg1PQyf1mNoJtHGNQcMdRUHzWdjHAt9uMV0s0n\np7RM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISAfVkppMphPu8SXyKEQJ6rZUyMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMDRhZTA2NWQtZDgzNS00NGYyLWE4MTctNzFiODNiY2JiMzE1MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGNkZDdjZGEyLTQwNDktNDZjNS1hNDJjLTA2\nMjMwZDU0ZGI2MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPDvM5LCmlkTH/wi\n0k7k9Sy5F6wvWUILZKQRX++NNNgIRImb6oNHZcFKXvT28gKMV7H01wJmaXTN9In6\n2f5tQGWjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFGWJmwmg3sJn5B3vePjgyibA9Xc+MBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAzucQ2b8sB55+\np4amULR2aF3UqivK5AVFQuniCobJ3AgCIQDgoN4jFHKMLYyt13lnqbz37JSwjpB/\nu4km640KrORpig==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc40", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `40` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaKgAwIBAgISAeE71wUHiryRj5fd/JeQoxUGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDdiZDk3ODNi\nLWNiMzgtNGNjNy1iNTU5LTM4MmYxYWNjYjcyZjBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABPpIvis3UYfgb9eHl1HYGEmaUrOtlmHwCK/d+dQFPAeAj8XMLWhW5N0l\nV22Up0ZmwLQNCd5KiaCycCo8cHmtCuGjQTA/MA4GA1UdDwEB/wQEAwICBDAMBgNV\nHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MAoGCCqG\nSM49BAMCA0kAMEYCIQC/jTfskYJRdstObsExn+O0hH9enSyucZG/uyfb+bQrYQIh\nAMWFpkEHqcXeCs105fW61WOAIxYpERdrsKvZ/C5pRhvU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISATJUnzxMkbEJ6Ejg4QJSFazHMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyRiN2ZhNDg4OS05ZWNiLTQ4MGMtODY2My01NWUwMDEwYTA5NDYwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDdiZDk3ODNiLWNiMzgtNGNjNy1iNTU5\nLTM4MmYxYWNjYjcyZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPpIvis3UYfg\nb9eHl1HYGEmaUrOtlmHwCK/d+dQFPAeAj8XMLWhW5N0lV22Up0ZmwLQNCd5KiaCy\ncCo8cHmtCuGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBQct0pNg6h5+9BbkTNk2a+W7G3xCTAfBgNVHSMEGDAWgBTH/jqWlu8p\nDDw5XSA0bhNi+c10UjAKBggqhkjOPQQDAgNIADBFAiEAtfK/vNgfdMB7mrMWOjUU\nwUBc25FmJ+UtjAM9lG1mR30CIHeFkacep3Xl08bgwNxrXzkRJK8YdUt6UMJX9BYb\n6nVf\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISASIP1CoglIDAM/ZUc2/jzSXfMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nN2JkOTc4M2ItY2IzOC00Y2M3LWI1NTktMzgyZjFhY2NiNzJmMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGIxZmM1ZDM1LTBhYmUtNDE3MS1hNTUyLTdj\nZTI0N2FlNGMzODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGehtv6+gFoRdOP8\ns5/gAyWQUSiqBW1p0wGKwCPBGqVeGQXvYlReEUPwjm2n+H1sRjrwM0LcEPu0Axph\n3rX3ohCjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFBy3Sk2DqHn70FuRM2TZr5bsbfEJMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAIOfTAJMxWiNZL\naiwKW0Hf7HtTEmUz66OKnHy5N8fBpgIhALbUkbZuxaSo39f+eQRHxHMw3uCDp/4p\nXMQOf0Z3aaka\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc41", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `41` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAZABT2qEo368csSlQnPIG1jAMAkGByqGSM49BAEwZjEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0\nX3Jvb3QxLTArBgNVBAUTJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUx\nZDhjYzAeFw0yNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFUxFjAUBgNVBAoT\nDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMkYjk4OWRiNTIt\nOGYyYS00YzM3LWE1YjItNTE4NTZjNzBjN2E1MFkwEwYHKoZIzj0CAQYIKoZIzj0D\nAQcDQgAEslk6yofUGK6ywJrWml9Zo+6pgm1vZOc+i69P3XXyRvgq9HubJ5rVumrU\nlmDkai0KaDIB2f2hQHZk0bKQN4wag6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1Ud\nEwEB/wQFMAMBAf8wHQYDVR0OBBYEFCLrNwQZaqzJ4dOHcfSOAOi06FA1MB8GA1Ud\nIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MAkGByqGSM49BAEDSAAwRQIhAMy1\n31LTBaC8TwrOPRdBTe5QBU8Jl1xPmzekpC6PTTnpAiAa/MfpC2ETfVXEnfVGLbQ+\nsB/Dlkf0JHHVNG2Bqzt1nQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAZyK7wThHej1SAhsdAFmkSxCMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QyMS0wKwYDVQQF\nEyQ2M2VmOWI4NC03ZTE3LTRlMjAtOTE0OS00YTMwZDQ0NDUxNTkwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGI5ODlkYjUyLThmMmEtNGMzNy1hNWIy\nLTUxODU2YzcwYzdhNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLJZOsqH1Biu\nssCa1ppfWaPuqYJtb2TnPouvT9118kb4KvR7myea1bpq1JZg5GotCmgyAdn9oUB2\nZNGykDeMGoOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBQi6zcEGWqsyeHTh3H0jgDotOhQNTAfBgNVHSMEGDAWgBS0zB0iSfXv\nFFYRUbGEs3VgwmmS+DAKBggqhkjOPQQDAgNIADBFAiEAxh57OcrqtsXIeX+dyxVq\n3CdgNN8luL5nIC+CfzIYL18CIDPKQ7cMhP6If4qsMPQ8Om/v+NC8tkkqhqko37qX\no0Ub\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISARRmIUXwLlab09JZLTMJr4S5MAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nYjk4OWRiNTItOGYyYS00YzM3LWE1YjItNTE4NTZjNzBjN2E1MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGNiNTdjZTg2LWM2ZjAtNDg5Zi04Y2VkLTM1\nZTcyMzgyY2FkMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDaOm5XshTxLadkL\nlK4HxNlNSpygde4iGw/oavmxFku0rhqJBvDGkTGrWUP9vGWP7YI7VuArsF62QEqa\nylHYN8+jbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFCLrNwQZaqzJ4dOHcfSOAOi06FA1MBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiAV+X0dq9fMLLiI\ny/9NlUhlpHG+YvGB+iSlEcx9VT72vgIhAJdrw9jK5uyJFokJgnMprUVn7MB8vr2f\n+hfkFGfhE/0e\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc42", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `42` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAVZL5RFYBke/6otTs2yrYg91MAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyRhMzY5NmY5MC03ZDI3LTQzYzgtOGRmOS1mNGFkNDNmNjc2ZDUwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGI0N2RkODMzLThhMzAtNDkwMS04MTU3\nLWViNjBmYjcxOTNiMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABORmaeJMKs6L\nBWVIU2bMCAICNkH+I15ksi4Uor8Yv7LGKuVTorHgTB4NZxVpzYRqyOrZEheGyFX1\nmdJo6GMWGAyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBSpZRkNFGVLYS3w7WRxrE6BLGefljAfBgNVHSMEGDAWgBSUTiM10Sv2\nfY8nqVUaxpYZu8JLwjAKBggqhkjOPQQDAgNIADBFAiEAtATIeQye93Ih+QLQ9TuI\nf7h/MzrsSlgu0MT6JrxcwOYCIFD4bwCnu+YtvFngDEBaCQVSjV1VibMYVgf6ZAQ/\nXMU/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcSgAwIBAgISASZspsEwSsKEtmUhqLRYmvULMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjYwMTIwMTYyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGI0N2RkODMz\nLThhMzAtNDkwMS04MTU3LWViNjBmYjcxOTNiMTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABORmaeJMKs6LBWVIU2bMCAICNkH+I15ksi4Uor8Yv7LGKuVTorHgTB4N\nZxVpzYRqyOrZEheGyFX1mdJo6GMWGAyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSpZRkNFGVLYS3w7WRxrE6BLGefljAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNHADBEAiAu\nLolfs0k87Kapk+qMlEG9BUcX+83N9Arv8CBe0H7o6wIgB6mT57uZfGHHPR6AXELF\nHhmZSmoQ37E8bedUiyz/fMY=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAZ7ePwW/dTNHtbSeDDK2+3AuMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nYjQ3ZGQ4MzMtOGEzMC00OTAxLTgxNTctZWI2MGZiNzE5M2IxMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDk2ZjE5NTE2LWM0MTUtNGY0NC1hNTVlLTg4\nMTVhN2IxMGI3NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBrn+tIaGoTWfIfc\ntUL+EZieY31pF6bKX0BveZp3eYvpGO9M6+Id2zVr419G7pfBqHREC9KnUUd39rmC\nNXIANjCjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFKllGQ0UZUthLfDtZHGsToEsZ5+WMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiEArPktludpqo6r\nalIEJkFncmpZu/d83CjXIGbUKOcakwcCIBSMRLLPZ2V5iggxthOZQwi7Y2bVVfyB\npiQ1Kl7F08OT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2027-01-21T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc43", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `43` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAYMGMosdms3FJ0oOGfsqIeCOMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyQzYTVjNDE5Yy04ZjYwLTQ5YTAtOGYwYS0wNzljN2U3ODA5NDYwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDQxOWNkYWJiLTNiYmYtNGJiNC1iZmM1\nLWU2Y2ZmZWQzOGYyNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAme3ec2ftGs\n6ukh0X/PrCXdsIQ/+Zia74t3oUwTTxwZkUEcrLGcBKgtmrzGGo7tjT10bfZqsCyr\nIdkRPin+F9GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBRdECk8qUpSVqpthjhocsaNG6MrWDAfBgNVHSMEGDAWgBQ28T9SCvYh\nKZqXJIBREPwbv8XGyTAKBggqhkjOPQQDAgNIADBFAiEA+tz68Se6AMB/9T+ix4ZD\nSY0o9MFgkN2oyF1YiTV7P+ECIAbhlTUldai9R8B6MnAjdZDm22qtOA1bG0Z/VMUy\nKEas\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICQzCCAemgAwIBAgISAfKethxFV8/QCwFVlid8ezBjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDQxOWNkYWJi\nLTNiYmYtNGJiNC1iZmM1LWU2Y2ZmZWQzOGYyNTBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAme3ec2ftGs6ukh0X/PrCXdsIQ/+Zia74t3oUwTTxwZkUEcrLGcBKgt\nmrzGGo7tjT10bfZqsCyrIdkRPin+F9GjgYcwgYQwDgYDVR0PAQH/BAQDAgIEMA8G\nA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFF0QKTypSlJWqm2GOGhyxo0boytYMB8G\nA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MCEGA1UdHgEB/wQXMBWgEzAR\ngg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIhAJ9i2XvqlWaQkTdy\nU+bO5wAc3pqbp5YBgWelsjfUMTgqAiAOCiowfG4Pfkqh4mDo2hEQtoP3NI9MCm1p\nNXbw/ZDW0Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISAbIN5QXO0MnRVi+1IWz3Bm6DMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nNDE5Y2RhYmItM2JiZi00YmI0LWJmYzUtZTZjZmZlZDM4ZjI1MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGFkZjY1MTA5LTIzMTYtNGU4OS1hNzY1LTYw\nNjMyMDIzMDM2NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCRaTo3rcnDrT5+a\n4yIu9DmLqT2FSmzoJm8iKeHqlfoiMaE5g4Uw5CX9nBj/O5n4ikc6r7gRUz0DVQNU\ndxZoVeWjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFF0QKTypSlJWqm2GOGhyxo0boytYMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAzTQoPpS6WcvT\ndwByg6/IcUHVxsu3X0OGpulicUIcCf4CIQDl3FYplUKeiekF5xiYAl5m9cc+1heS\nAnTL8RTdsjNcfQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc44", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `44` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICEDCCAbWgAwIBAgISAcP3WtqeNXqLZ8WxJsnPx0RDMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyRhYzdiMmQxMC03MjM4LTRmYjktYmRlMC0xMDc3N2Y1NDljYWUwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDBiNGM2YWQ1LTUzNTItNDFkOS1iNGRk\nLTMyNTllZGM5ZmQwODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEdFYNr8F5Vk\nbaPp69gnvAvnf5p5JXB6Y+hf4Xj6bwddeewyHkAe5hkfQnP1lP/X0yN/7x+Gh2a8\n1CRqxHzR2ASjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBSVwBeJWDIokgtWA5he+Py/hUcxQjAfBgNVHSMEGDAWgBQwsqoqhE5+\nIr4yW4Z3bdeKzvSBtzAKBggqhkjOPQQDAgNJADBGAiEArYdF4gk4w3yH3zQhND4Q\nVOcd6n9HlVtp7ILsD3ErnXQCIQDlBsbrDjDDhNqwaDf+VeVLJjsPZyVao1Rad4oB\nug0Fzg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICMjCCAdmgAwIBAgISAbbumReQ/fU2trtjDYnnTGJxMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDBiNGM2YWQ1\nLTUzNTItNDFkOS1iNGRkLTMyNTllZGM5ZmQwODBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABEdFYNr8F5VkbaPp69gnvAvnf5p5JXB6Y+hf4Xj6bwddeewyHkAe5hkf\nQnP1lP/X0yN/7x+Gh2a81CRqxHzR2ASjeDB2MA4GA1UdDwEB/wQEAwICBDATBgNV\nHSUEDDAKBggrBgEFBQcDBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSVwBeJ\nWDIokgtWA5he+Py/hUcxQjAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAKBggqhkjOPQQDAgNHADBEAiAQezho/jQDQ64QA4CJ9//vprzQaOlfY3jlbM9R\n2B/TjgIgQfEuynxB2AGeL8zEChyN8vriNXkLphEtUq+6tdLNxXo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAVbqAfd1lHUXui28RVfaCVwbMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nMGI0YzZhZDUtNTM1Mi00MWQ5LWI0ZGQtMzI1OWVkYzlmZDA4MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDQwNmViNDc3LTI4YjktNDkxMy05OTJiLWUx\nYjBjMDU1YzFlZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKrCw8XpwBlvUOUM\n/Jk4bSPyPyb/AKE7P439vLQxiMKz6suRqqIdRE29nSfNKCKPGf1AVrXdzgrpXEHE\nnJsIkeyjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJXAF4lYMiiSC1YDmF74/L+FRzFCMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiB9pPmavr70WwT6\nEwpzKtmi7mroAz+a0hdw7T5DVrwGMAIgEvj03Vrk0/0EB8i+uQqSbAyzd7Oxge5W\nPs4fwah+tOU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc45", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `45` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAf6HRbPWl4zqfwCJz+Ob0pu3MAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyRlMDVmZThiNS00NjUwLTQ2NjgtYTNkNi0wMjFhNTMwNmQwMzQwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDdlNGRlMzk4LWUxZWYtNDM5My1iZTcy\nLTg0YTBmNjgwZDkyNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJbTJ6d6NVfF\nTzfjbsdnkvLXnoUno6KCJKY0sOZkuBSYMbrOBpL2CyL/vT9LljmQjiJ/yXZcy9Ij\n169wVX4IDJ2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBT/xZXnySQyULwtcETRyCjNIEqSezAfBgNVHSMEGDAWgBRjXByZS/Jr\nh6X9wbnke6bj8iT1HDAKBggqhkjOPQQDAgNIADBFAiEA9JokfgtF5vQbE5V8xwcr\nAbZyENj5FI3kECt6jZ6kcl8CIGDAslO1QkGNyc+3hGFzmfOk+iSOk8XhcY02/D0b\nn+Wc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbOgAwIBAgISAVJOZZ0j1RhzZcW6OQ3ef0PfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDdlNGRlMzk4\nLWUxZWYtNDM5My1iZTcyLTg0YTBmNjgwZDkyNzBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABJbTJ6d6NVfFTzfjbsdnkvLXnoUno6KCJKY0sOZkuBSYMbrOBpL2CyL/\nvT9LljmQjiJ/yXZcy9Ij169wVX4IDJ2jUjBQMA4GA1UdDwEB/wQEAwICBDAdBgNV\nHQ4EFgQU/8WV58kkMlC8LXBE0cgozSBKknswHwYDVR0jBBgwFoAUSmacmwv0HQuF\nABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgXpEIdolIoOKa/MaCVBykbHVQ\n0Nr893JHzMRKpqVZtJMCIQCA5R0pUQZy5MgKc4d3xf+TmyLt9ZKCbYCCSfwKaWhS\n2Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbugAwIBAgISAT+8KPoEGLVbZn1G6Q14ZfsEMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nN2U0ZGUzOTgtZTFlZi00MzkzLWJlNzItODRhMGY2ODBkOTI3MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDI2MTIzZDIxLTRjZGQtNGIzMy1iMTA5LWU0\nMDkzNmQ5MTE4NzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJwJqTjfZHQGJLl0\n333Fawd+1SJTxiuH9Anpp2xMus3rxjZTCVXj73Rk+mWDnfHe/FQJpJKctBJovLdH\nlq55nEmjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFP/FlefJJDJQvC1wRNHIKM0gSpJ7MBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiA/5YSY0Rkbox6p\nA4GkTcMpPcy53BueZpxzNSmxBtwTMwIgQEdXuKCmUvIgrEPBq/2FwljmGP4BXLN3\nUbpkN2kZkHo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc46", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `46` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAQcNsHU6m+tnSOz2dIFKkhuEMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyRkNjIzYmE4ZS04NDg3LTRjM2YtYjBiMi1mNjQ5NDc4M2JkNTcwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGVkYjUxMTFmLWY5NDQtNDM5NC1hMTQw\nLWU0ZmU1NDUyNWYzZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAyoTglehmog\n8o1qB6yUes/0PRxR9Nxl3DnuFKZCV+vQr56niEhHQkGlt/DOpSUOz9h1imgozX+V\nc4dK+HcRd66jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBSZtrKrVaUyrpXBhMOPXTh1tqEwVjAfBgNVHSMEGDAWgBTKyioqxiqm\ntAU/GU6vIOjg4NZu6TAKBggqhkjOPQQDAgNIADBFAiEAlrobDNUHm7XIb8xElBLP\nyCCVlV1g/pNEM7UlPVnsMdQCIAXsq61lPRn7lysXUwGmKxXrPMlcw+pLrEUEXwrY\nVl8v\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB/TCCAaKgAwIBAgISARPXp3q+yy5p9qOs2VmdWAAtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJGVkYjUxMTFm\nLWY5NDQtNDM5NC1hMTQwLWU0ZmU1NDUyNWYzZDBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABAyoTglehmog8o1qB6yUes/0PRxR9Nxl3DnuFKZCV+vQr56niEhHQkGl\nt/DOpSUOz9h1imgozX+Vc4dK+HcRd66jQTA/MA4GA1UdDwEB/wQEAwICBDAMBgNV\nHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MAoGCCqG\nSM49BAMCA0kAMEYCIQDoC8Nr3Tf6nBH0icttPNy0dFuWOwaeFzP2KGHfue8UGQIh\nAInv3fjD3mAaJ/9fV1eHtl12xrV8GmN7/hwqBMDju8vp\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFTCCAbugAwIBAgISAfu4+xmzNLft6LZT/+UO4Ws2MAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nZWRiNTExMWYtZjk0NC00Mzk0LWExNDAtZTRmZTU0NTI1ZjNkMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJGE5ZWM3MzNlLWYwZGEtNGVhNC1hM2YyLTQ5\nMzkwZTlhMjFlNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIakXClRHQAzSzrU\na106dx4RSsEOt9QYNRiZ0UJAeI4WuoW9jkTpygg8R/uS1A7f5UMjJfrwYTcRlUJE\nQXrSdkGjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFJm2sqtVpTKulcGEw49dOHW2oTBWMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNIADBFAiBZWdIBolJfeBfc\nkrksThpF9qsR6sqiHMRZhTv2r4nPOgIhAM8aBiGU18T5pOGxbHMeNwaUMimKSSXh\nXYtUHhjX/m4j\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc47", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `47` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICDzCCAbWgAwIBAgISAa1IC7ULNCfjxeW/KmaaDQtYMAoGCCqGSM49BAMCMFcx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDjAMBgNVBAMTBVJvb3QxMS0wKwYDVQQF\nEyQ2YTI0OGZjMS0wZDM3LTQwMGYtOGQ3Mi03YTU0ZTBkYTUwYWIwHhcNMjYwMTE5\nMTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBVMRYwFAYDVQQKEw1iZXR0ZXJ0bHMuY29t\nMQwwCgYDVQQDEwNJQ0ExLTArBgNVBAUTJDY4YzY4MjVjLTk1MmQtNDVkMi1hNzNm\nLTBmY2EyNGRlNGJlYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLp2BrC9LlC/\ncVS1U/FhdbBDUKg9BEM14l/qV6FYE603658ZBy62Dxv0N8jGsmzqdOEY/y1DCQDZ\n9KLNXyFd83qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBQchSlAg3hGY8FhbBOomGVeqyVr7TAfBgNVHSMEGDAWgBTZWywoUDXD\nKLyJW3ghG0bCN4VNVDAKBggqhkjOPQQDAgNIADBFAiBR/E0BwqBgDxqbtXPSKJqf\n1yOJWHMb3UD47v9TuHpwjQIhAIkIZwxyHoLpTnj1Nu5AKQywSvejye7oNbO5WvUd\ncU4h\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcOgAwIBAgISAYPcS8+qrM+8AHOeQ7ua7V1PMAkGByqGSM49BAEwZjEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0\nX3Jvb3QxLTArBgNVBAUTJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUx\nZDhjYzAeFw0yNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFUxFjAUBgNVBAoT\nDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMkNjhjNjgyNWMt\nOTUyZC00NWQyLWE3M2YtMGZjYTI0ZGU0YmVhMFkwEwYHKoZIzj0CAQYIKoZIzj0D\nAQcDQgAEunYGsL0uUL9xVLVT8WF1sENQqD0EQzXiX+pXoVgTrTfrnxkHLrYPG/Q3\nyMaybOp04Rj/LUMJANn0os1fIV3zeqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1Ud\nEwEB/wQFMAMBAf8wHQYDVR0OBBYEFByFKUCDeEZjwWFsE6iYZV6rJWvtMB8GA1Ud\nIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MAkGByqGSM49BAEDSAAwRQIhANMt\nCWYcyE4eKosaAlTev8Rd41nhCq5uYif/snG9dELTAiB6I+gUGlmcVoZ+iKQR9/Jx\njO/2YpMtN82P8HzHGfEy5w==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFjCCAbugAwIBAgISAY+o1VlJZWR2IFGhew0N/PrhMAoGCCqGSM49BAMCMFUx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDDAKBgNVBAMTA0lDQTEtMCsGA1UEBRMk\nNjhjNjgyNWMtOTUyZC00NWQyLWE3M2YtMGZjYTI0ZGU0YmVhMB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowVDEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEL\nMAkGA1UEAxMCRUUxLTArBgNVBAUTJDc5ODc2ZmU4LTFiMDEtNGVhNy1hNmFiLTYy\nNzlhZDhhNzM0MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFtedESMfbIVxp0f\nvaX2g6lXhUKaqJYxi0zlioVn0Y61reBhQHpdiWA0px7GXlFSXznRRguh2EVbBLkr\nfVugkbOjbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAM\nBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFByFKUCDeEZjwWFsE6iYZV6rJWvtMBQG\nA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNJADBGAiEAtPyEfQ0b0dDS\nGBE9sYLfrU0oe7oUgH8nZkEWt0EuIxoCIQD/dZan5OVqsdUoXQhc/cjGMFydXy03\nOA0persMLC+75A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc48", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `48` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeq4Hsi1ETKCJkPvrTkRppPmMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGUw\nOGNiMjgyLTRhMmItNDU2MS1hM2Y2LTgxNDFiYzI3MjU4NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGNmYWEzNzRkLWU0ZTctNDkwNS04OWQ1LTIzNzBk\nMzkyM2VkNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBX0gVpN4Fe4zVL72eeL\n0ESVy8wjaLchyl5lTRYcCHLsgaQe0mwrOFMQuvUv9D+nMyFUPO5f0yIVv+rw6up+\nlMqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR5jQzZA3sp/B3VEVH21CNFQfZXTTAfBgNVHSMEGDAWgBQlr38xfJ/CKhdiMe77\n3IP32xf/OjAKBggqhkjOPQQDAgNIADBFAiEAp2KwekjCI+1OGT5o+fIAVsfN9FFZ\n4/A4P/WeQ6MgqiICICXTJfJmP+oU2LBvFURCCpTkoy4q36o8r+uEw/jYcW7V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAU7bjcV2Y4hRzCul1/TW/UkZMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDEx\nOWZiNzE1LWI1ZDMtNGViZS1hNGZhLTgzOTMyYmJmY2Y4MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGNmYWEzNzRkLWU0ZTctNDkwNS04OWQ1LTIzNzBk\nMzkyM2VkNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBX0gVpN4Fe4zVL72eeL\n0ESVy8wjaLchyl5lTRYcCHLsgaQe0mwrOFMQuvUv9D+nMyFUPO5f0yIVv+rw6up+\nlMqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR5jQzZA3sp/B3VEVH21CNFQfZXTTAfBgNVHSMEGDAWgBT9gqsHAihLPKUNKP27\nxe/2J3N+HjAKBggqhkjOPQQDAgNIADBFAiAHAfcjNBKEAIsv03KeGbRq6EXMFY2j\nJAuBSh1TCrnw5QIhANkArRpQNGbafrdTJ8Upb6AkSjCWjDaY3/lx8eV805jA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQMGoDia4rGlnIxX5vikYG3uMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGUw\nOGNiMjgyLTRhMmItNDU2MS1hM2Y2LTgxNDFiYzI3MjU4NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDExOWZiNzE1LWI1ZDMtNGViZS1hNGZhLTgzOTMy\nYmJmY2Y4MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJrIcEl9JzvBNYgT/+xS\n3JxuYAi8EeyXSRdE8mTFVt1v76hUycV9gRojBsD1Jk0YNIG8lr6pIIVm2JyTwo/+\nsjOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT9gqsHAihLPKUNKP27xe/2J3N+HjAfBgNVHSMEGDAWgBQlr38xfJ/CKhdiMe77\n3IP32xf/OjAKBggqhkjOPQQDAgNJADBGAiEA/0v9muYvYbDCxhdLDjtNaV03nZy3\nWzDhW6nRLjxY1B8CIQCy92b69vWeokzfCxt79ihVLkIgvAI224sxJQfgiy5TeQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAemgU8ZLpPB5w/aqw1ObwR/oMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDEx\nOWZiNzE1LWI1ZDMtNGViZS1hNGZhLTgzOTMyYmJmY2Y4MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJGUwOGNiMjgyLTRhMmItNDU2MS1hM2Y2LTgxNDFi\nYzI3MjU4NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDlRUa4HPR2EU4a7PO8V\nHGLEuV6UklkOTJazdBSMDBLzHALZ4U5vzUxc0nGG9TGTurgbX3Xo9Mh8VQMs0a/0\nFl2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQlr38xfJ/CKhdiMe773IP32xf/OjAfBgNVHSMEGDAWgBT9gqsHAihLPKUNKP27\nxe/2J3N+HjAKBggqhkjOPQQDAgNJADBGAiEA3K1lIcsV2YN53Hw4TI/eOIZENHdd\nxwkqyHv+L/Eac/ACIQCHQCrM27p3dsgvR7iqI0M9AOqKIaR/HGVFMakPLLOMXg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAUEcZ1Ud1dqCeQlAdLk8VHKnMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyRlMDhjYjI4Mi00\nYTJiLTQ1NjEtYTNmNi04MTQxYmMyNzI1ODQwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQ5UVGuBz0dhFOGuzzvFRxixLlelJJZDkyWs3QUjAwS8xwC2eFOb81MXNJx\nhvUxk7q4G1916PTIfFUDLNGv9BZdo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJa9/MXyfwioXYjHu+9yD99sX/zowHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAK7R\nlyQR31pf7zDXV5F34zXCz80rVWkGnQZOFLyA4NuzAiEAociQFo/ltjBgXh6QznzM\nHHwLLyNwumWHiSrWPOBarSs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAQHdkXskI9uW8AnaWTvoYJfTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyQxMTlmYjcxNS1i\nNWQzLTRlYmUtYTRmYS04MzkzMmJiZmNmODIwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAASayHBJfSc7wTWIE//sUtycbmAIvBHsl0kXRPJkxVbdb++oVMnFfYEaIwbA\n9SZNGDSBvJa+qSCFZtick8KP/rIzo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/YKrBwIoSzylDSj9u8Xv9idzfh4wHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgLraS\norRMlGhujwPgmi1vC4SAEg+EKD0zWmSLGt52GogCIQD2dLfc09I/yH7HFG4fZMTF\n6Rk6T2Iyu3+xxgFXVwXHoA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAd71Alu85N/J3R6bW5dAsIHfMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGNm\nYWEzNzRkLWU0ZTctNDkwNS04OWQ1LTIzNzBkMzkyM2VkNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRkZGU0OTA5OC0zODY5LTQxZjYtOTgxMC00YTJm\nODM2YzA1ODkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARXMW/6CGJ7FlUyYvis\n48Q/DeD+BSKGToSP0RNZhVnSM6NnIyVUC/gyBHGqxyfuBvfUH5Fc1j5O0BbJH6bR\nJvzao2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5jQzZA3sp/B3VEVH21CNFQfZXTTAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAN4WpNiaHo94InvV\nsmEhQkuSqqTXliBZiXqCZlgn/IC4AiEA9Z9ydsFPIspO/49p0KH4sjzfc/l+oguZ\ntHwUF6Z8fKI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc49", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `49` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARc6RgAfKl36K9VgNj2cCSy7MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDYx\nZmU1YTBjLTEzYjQtNGZlZS1hMjQ4LTA3ZTY2ZGEzZmFlMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDZjZjM0ZDcyLTFkZDMtNDIzOS05ZjAyLWRhNzEw\nMjg4ZmFlNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCLYc7yw+4g1DPAC4bWk\ntOAIQQC8qrxON+tNI9gfmwCYAj7BaJwn1Dx4uMWqlIyvGf/CeLbc0OG0SytJK3sw\nQ4WjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSpu1vWqtoaKoDXVj5oCbPxJzTnqDAfBgNVHSMEGDAWgBQmtkd9Q7HX9X9NCPmG\nM/RZfd6JnTAKBggqhkjOPQQDAgNJADBGAiEA0WwqxPex+bMshhAmnAwjbrK0YiN5\nCdmoMmndDck8jMkCIQDkVX0pNBCTJuVsugdwo2kUUIKBAdOH2FvK/iSsXgwD8g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAW31RgoKljPrs+bAWxmzK1lDMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDIz\nZTYzMjhlLTBiMTEtNDU4Zi04NzY0LTY2NzQ1MjE3YTI1MzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNjAxMjAxNjI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDZjZjM0ZDcyLTFkZDMtNDIzOS05ZjAyLWRhNzEw\nMjg4ZmFlNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCLYc7yw+4g1DPAC4bWk\ntOAIQQC8qrxON+tNI9gfmwCYAj7BaJwn1Dx4uMWqlIyvGf/CeLbc0OG0SytJK3sw\nQ4WjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSpu1vWqtoaKoDXVj5oCbPxJzTnqDAfBgNVHSMEGDAWgBTntm3dhg3CS/bfXCb+\nudBAj2IQnTAKBggqhkjOPQQDAgNIADBFAiEApIIn2PFZG4SjW4RdNiji39mt1T86\npyLIs1Kfa18LVAMCIB47V2iWUXedLGZEvC+EJV9wq/e23DiuZ0z9z6qEnXzC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfVzkQKxcmskXcaAzH2BCP1gMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDYx\nZmU1YTBjLTEzYjQtNGZlZS1hMjQ4LTA3ZTY2ZGEzZmFlMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDIzZTYzMjhlLTBiMTEtNDU4Zi04NzY0LTY2NzQ1\nMjE3YTI1MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJlk9E794XUHgFs0TgI8\nKmdYJ630M0V3efrFXt1MIOvOi7jMs7g/5Ya/3ETkzduc4oT0PNgiBPW8LADnONeb\nFxWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTntm3dhg3CS/bfXCb+udBAj2IQnTAfBgNVHSMEGDAWgBQmtkd9Q7HX9X9NCPmG\nM/RZfd6JnTAKBggqhkjOPQQDAgNIADBFAiBhBOL8ZDaVSojU2llyeIYFrKjYN3Gu\no4z5ch+3McngTQIhAJgj3KZsyxFPeRyOIMCUZ9fzKdGKO7zXF3vOLYe0E9/k\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAc2HoHz4SaMWWKb4f5VdP66yMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDIz\nZTYzMjhlLTBiMTEtNDU4Zi04NzY0LTY2NzQ1MjE3YTI1MzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDYxZmU1YTBjLTEzYjQtNGZlZS1hMjQ4LTA3ZTY2\nZGEzZmFlMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGjCkdmOLU+Y8ft2somG\ncZnJN66wLlgyBKrWMatyv2sqK7GCI+q494pHIK4o6B0yLCVkxEsZmBEV7QDw4BZa\nFI2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQmtkd9Q7HX9X9NCPmGM/RZfd6JnTAfBgNVHSMEGDAWgBTntm3dhg3CS/bfXCb+\nudBAj2IQnTAKBggqhkjOPQQDAgNIADBFAiBB+5z5siP6FXRjz6lrFVhngjP2Es84\nTmT4/97ZnSWKtAIhAPADn35pr/IZ+DTiqAIYFWcVzPqpm1S7XkQBSS2+EPh+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAVVyvrVkr5O2Nf4eF6TR+ZXfMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjYwMTIwMTYyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyQ2MWZlNWEwYy0x\nM2I0LTRmZWUtYTI0OC0wN2U2NmRhM2ZhZTEwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARowpHZji1PmPH7drKJhnGZyTeusC5YMgSq1jGrcr9rKiuxgiPquPeKRyCu\nKOgdMiwlZMRLGZgRFe0A8OAWWhSNo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJrZHfUOx1/V/TQj5hjP0WX3eiZ0wHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhANzM\nrXGBMyOmcTQ7vGM2HimsoSr3aBYbPtqAp8O3EuCyAiEAz/3Y5jPM80A+PAtuFHvz\nbuuEqFhc8L6yIgOSclvYTUY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAdbcl4mpNyqOpnYWiVtECZWHMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyQyM2U2MzI4ZS0w\nYjExLTQ1OGYtODc2NC02Njc0NTIxN2EyNTMwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAASZZPRO/eF1B4BbNE4CPCpnWCet9DNFd3n6xV7dTCDrzou4zLO4P+WGv9xE\n5M3bnOKE9DzYIgT1vCwA5zjXmxcVo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU57Zt3YYNwkv231wm/rnQQI9iEJ0wHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAKIT\nNtfLZxP3pImnpNiN01N2gGt5gqRZHjlHbGOiPRAjAiEAy60t1CWCnO8F5OuIYh37\nTwHawJzUmPRRPvXWhHY26vA=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAd2BvCzuc1zFyacN0OB7ivX5MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDZj\nZjM0ZDcyLTFkZDMtNDIzOS05ZjAyLWRhNzEwMjg4ZmFlNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQyOWE4YjhlYS01OGI0LTRiMjAtYWJmNy04OTJj\nYjliMGE0N2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAStuXACgTcmYLyJMFTU\nWQ8pcAiEa3kMq7NNEsxxYCezNRLkFSYy9jbek2eIY3n+uolhVE69inzfrmUyZAGv\nUPNto2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSpu1vWqtoaKoDXVj5oCbPxJzTnqDAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAKP3n6lbZo7/7kTA\n9hCUa4jKPBxwXN2EPEXLHlqTK4fdAiAnV7GBwKR40aD6DxUbMJT7/yKDmd9yxAe6\nmTDhHGRYCQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc50", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `50` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYrM8Ai4RKpBDmkNBgXo47emMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDEy\nMDBlMjc0LTY4NmQtNDIxZS05OGQwLWE2MjY2NDdjOTRmMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDU2NTc0ODgxLTk0NWItNGE3MC1iOTk2LWM3OWJh\nOGY5MmIzMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG4krVmnf/e5NwnoUOBi\n1AwDaFQ6VHfxWREtpUchy9nYUf3ZTYXlcw21Dzt3jpWrpK76xBlCszoeKz+OQbmk\nMKGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSOmutV6owVXsMWO7TWDzut92apoDAfBgNVHSMEGDAWgBSRG6iHhpN1LSubP6zY\nB9eZ1zHqUjAKBggqhkjOPQQDAgNJADBGAiEA0DCzhQbqBKO9ex0fab4fx6DeYhQy\nTE8qoIW8QXtlZXgCIQDq1pt9rtBvYn5s5tJ/Icx1qeUHfsMD/0jzoiPIk+F1ig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICLjCCAdSgAwIBAgISAcvkiSd+3VJYBaEee/kWEirSMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDk0\nNmRlZTAzLWUxMzAtNDAyNC1hZDI2LTc0MGM5YjZjNzI1ZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDU2NTc0ODgxLTk0NWItNGE3MC1iOTk2LWM3OWJh\nOGY5MmIzMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG4krVmnf/e5NwnoUOBi\n1AwDaFQ6VHfxWREtpUchy9nYUf3ZTYXlcw21Dzt3jpWrpK76xBlCszoeKz+OQbmk\nMKGjgYcwgYQwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O\nBBYEFI6a61XqjBVewxY7tNYPO633ZqmgMB8GA1UdIwQYMBaAFAcQgmjqJy3JGzUQ\nDXibR3iT0DnjMCEGA1UdHgEB/wQXMBWgEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSAAwRQIgLreySkAeWtmpI6RR2N+DjIEvfXH+ZitDPEoXvla0FOEC\nIQCY35bw79R4NSkb/7zr4GaebcHeXLuNmfkN+jrPs4AG7Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdKtM5Q4NelBG6Mpo3Kh1I+jMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDEy\nMDBlMjc0LTY4NmQtNDIxZS05OGQwLWE2MjY2NDdjOTRmMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDk0NmRlZTAzLWUxMzAtNDAyNC1hZDI2LTc0MGM5\nYjZjNzI1ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBEE03KkQ+OqYbayAksw\nMQX9UXtT98jUD+Rhl8XYyrKz9G3sPQS/3GtNxZc+HoIDX+0sYuxjnURhgfuSsIby\njWmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQHEIJo6ictyRs1EA14m0d4k9A54zAfBgNVHSMEGDAWgBSRG6iHhpN1LSubP6zY\nB9eZ1zHqUjAKBggqhkjOPQQDAgNIADBFAiEAiNHA4X085rwWxgRsWQLaGOqcqHT2\nDAbTQ5qoK4d4a2ACIG3RV3VrEfjO6uUr9H0hhtTIvuSxPDVzYxc/SErN/wbK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAckMRzrUDiv9IYpugVwF0ER3MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDk0\nNmRlZTAzLWUxMzAtNDAyNC1hZDI2LTc0MGM5YjZjNzI1ZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDEyMDBlMjc0LTY4NmQtNDIxZS05OGQwLWE2MjY2\nNDdjOTRmMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGtaOOQl09qyu+TkFaoi\nWUZ6Ct5cfuTDiAgxniBe720WIk6cNowwOTQxPCg7CJUvgpjgGsZ8zrgOBISZoOiQ\nAIOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSRG6iHhpN1LSubP6zYB9eZ1zHqUjAfBgNVHSMEGDAWgBQHEIJo6ictyRs1EA14\nm0d4k9A54zAKBggqhkjOPQQDAgNIADBFAiEAoImekikPBwe9oRXBYeUvLMHdf8Xt\ndRMTnjmMmC6TVNECIAykNmW88hKaUhOvmyudlDfCOdMF1kQ3XTb4z4hpCQVW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICQDCCAeegAwIBAgISAQXxvt7ItJSnxAV2CooV9Y7BMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyQxMjAwZTI3NC02\nODZkLTQyMWUtOThkMC1hNjI2NjQ3Yzk0ZjIwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARrWjjkJdPasrvk5BWqIllGegreXH7kw4gIMZ4gXu9tFiJOnDaMMDk0MTwo\nOwiVL4KY4BrGfM64DgSEmaDokACDo4GHMIGEMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSRG6iHhpN1LSubP6zYB9eZ1zHqUjAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAhBgNVHR4BAf8EFzAVoBMwEYIP\nYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0cAMEQCID+1MYon/7BKtsH2yjV7\nlautl7ezIVh/LU5tgwLM2lDTAiByibqc7DhPRX2u/2tufo24LDosCYc+0FeKJe4B\noLWLWA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISARu4whZlJPS+FfOYo+PDqhDhMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyQ5NDZkZWUwMy1l\nMTMwLTQwMjQtYWQyNi03NDBjOWI2YzcyNWQwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQRBNNypEPjqmG2sgJLMDEF/VF7U/fI1A/kYZfF2Mqys/Rt7D0Ev9xrTcWX\nPh6CA1/tLGLsY51EYYH7krCG8o1po2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUBxCCaOonLckbNRANeJtHeJPQOeMwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAP4L\nx8TZFwwXTqisjI0YJckxoNcollK/4ssAe7UJomPqAiB6mJlc3/+H42vUUpFvFQSI\neiRhm+KLbzToYefLDbSZVg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbwnH9Jaoj3jG510Tg0li/WyMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDU2\nNTc0ODgxLTk0NWItNGE3MC1iOTk2LWM3OWJhOGY5MmIzMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQzZTMxZmZjMy04ZDhjLTRiMTgtODEyZi05MTlm\nY2I5NzVlMjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASFKQrIJHpOoDrKcimM\nlPKQsTKA8Jc+89lNfLWBXdf+n9zWb3FQJMMM4j4vG+MRfEbfpYdxiGtJggv867yY\nurv/o2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSOmutV6owVXsMWO7TWDzut92apoDAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAJOMhkvTp/AWl6Nb\n3mWroucMmCMd+1zcOV5j5xZE/QkWAiB3NWCmMGOdB0vnytPGoztA6/ffHGsVeI68\nP8n8+Tg1/Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc51", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `51` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAflOGQ+QxhnOHfL4HrJ4RNouMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGEz\nZTg5MDBkLTgzZTEtNGNjZi04ZTBmLTExMTgzZGI2ODUxZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDZlODNlNjM1LTk1ZGUtNDdmOC1hMzI3LWI1NzRm\nZjk4M2MzYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAHmi2OV5/BdCees6HeW\nhOqzazw3Z+k0KuPIi8R+Qhs2DtY8zKizrkfuJjPF+PQlUMHuu762UTqwZWeOpg4V\nyuyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRmhFAvMkQE32GdusCMjMI2OeRtAzAfBgNVHSMEGDAWgBT09heM3XjbAJZvGuTD\n7EWtSsMRmzAKBggqhkjOPQQDAgNHADBEAiAlU8QCE89HIY7zdt7llVfs5QryK61Q\n9OlmlRfZ3FY/fQIgPvn89wC8zhQvwwzHFvv7JUiYiDjGX0Ys0XQ+JD5NOX0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcSgAwIBAgISAVTwC3UAmCz+/AbKFYZrUaNyMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGRl\nYTNlNjNmLTM3YzYtNGFkMC1hOTdlLTM1ODA5YTZmMGU4YjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDZlODNlNjM1LTk1ZGUtNDdmOC1hMzI3LWI1NzRm\nZjk4M2MzYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAHmi2OV5/BdCees6HeW\nhOqzazw3Z+k0KuPIi8R+Qhs2DtY8zKizrkfuJjPF+PQlUMHuu762UTqwZWeOpg4V\nyuyjeDB2MA4GA1UdDwEB/wQEAwICBDATBgNVHSUEDDAKBggrBgEFBQcDBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRmhFAvMkQE32GdusCMjMI2OeRtAzAfBgNV\nHSMEGDAWgBSS6ImxkzwWaNnseCkKf+edp0Vo4jAKBggqhkjOPQQDAgNHADBEAiBv\n77dLMQi1wYka++MUww7Oe+qsr3XJQ0OEgtUpIRcIVwIgFEmoeu0MaaI+1Zx/qomI\nyvUE9tu4QGpVXqjVlsFCfFA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUAV9ym4NtF50VY70AugjZ0bMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGEz\nZTg5MDBkLTgzZTEtNGNjZi04ZTBmLTExMTgzZGI2ODUxZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGRlYTNlNjNmLTM3YzYtNGFkMC1hOTdlLTM1ODA5\nYTZmMGU4YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHDwgHdXicTOs1IdPWYv\nliL0WO10WK+qIHGFPMtpDcRUSS8n/SQRlgyRJvqLk+vCLS1noUkWSyrNunz/2tO7\nA3ijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSS6ImxkzwWaNnseCkKf+edp0Vo4jAfBgNVHSMEGDAWgBT09heM3XjbAJZvGuTD\n7EWtSsMRmzAKBggqhkjOPQQDAgNIADBFAiEAjZbix+Z7ofTAAcjOVWFO4l4z1y4o\npdb/S6ntu7s/9rICIHGkCEXvRP4nEqxXOe6fWUvXKr2/2C1+aXyciu845m88\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVuAKyHhKkvVEvQvgkBSYMC4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGRl\nYTNlNjNmLTM3YzYtNGFkMC1hOTdlLTM1ODA5YTZmMGU4YjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJGEzZTg5MDBkLTgzZTEtNGNjZi04ZTBmLTExMTgz\nZGI2ODUxZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDyL/0OSGwPs+dvHU54L\nHxwvKiE4p1w30UnGGqnOyeRgyB4TEvsWY763mkUdpYjLqvNsOKkgSyQHDzUxQ4gs\n21CjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT09heM3XjbAJZvGuTD7EWtSsMRmzAfBgNVHSMEGDAWgBSS6ImxkzwWaNnseCkK\nf+edp0Vo4jAKBggqhkjOPQQDAgNIADBFAiAwMecxVliDnyUw3hZhoJYxMr78wG+Z\nB1rA1CaO9LuwcQIhAIBce/bcfQdjHiiRjvYgnoLuq78C9VsWMWa1G6QGuPTl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICMjCCAdegAwIBAgISAepfYQvMBWUYag3N88wwUtE2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyRhM2U4OTAwZC04\nM2UxLTRjY2YtOGUwZi0xMTE4M2RiNjg1MWYwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQ8i/9DkhsD7Pnbx1OeCx8cLyohOKdcN9FJxhqpzsnkYMgeExL7FmO+t5pF\nHaWIy6rzbDipIEskBw81MUOILNtQo3gwdjAOBgNVHQ8BAf8EBAMCAgQwEwYDVR0l\nBAwwCgYIKwYBBQUHAwQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9PYXjN14\n2wCWbxrkw+xFrUrDEZswHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUw\nCgYIKoZIzj0EAwIDSQAwRgIhAJfY2YjJ8yR0K1yEWHlB3K0jpr9FwhGWG62HoF12\ns4c4AiEApIgmS/O3hiEEbV2KrLHyeAd45EQwynpXj5Ju5r+dYcA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAf/lhhOWaqyMsCLXYS7svh7bMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyRkZWEzZTYzZi0z\nN2M2LTRhZDAtYTk3ZS0zNTgwOWE2ZjBlOGIwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARw8IB3V4nEzrNSHT1mL5Yi9FjtdFivqiBxhTzLaQ3EVEkvJ/0kEZYMkSb6\ni5Prwi0tZ6FJFksqzbp8/9rTuwN4o2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkuiJsZM8FmjZ7HgpCn/nnadFaOIwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAMsP\nY5UFbOaQwiahSAA8WvD9Cvr13snnieEbrTjyo/h2AiBODz5urKXAW0gzYq0k1Pfa\n5P/AvTU28xARUUIvEfVbQg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAZgoWD+HB74EVIbEVe62dgcJMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDZl\nODNlNjM1LTk1ZGUtNDdmOC1hMzI3LWI1NzRmZjk4M2MzYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ0ZjMxYmQzZS0xYTgwLTRjZWItOTEyZi0yMjg5\nY2U3ZGE3MmUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQMrbds+PCbRaI0j6vt\njn6GoLVzjXQECSwEqCeJVK5oXvCfLVvzRQtutBwk37vHl837Ybf+wH1KcVN5LWSI\nCj4Lo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmhFAvMkQE32GdusCMjMI2OeRtAzAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgdqFmAhJkrNwAQzag\noEaq+Rxt1yWf8MykBexZiSgaWi8CIGn84Abmi2GdahkQDxoRoG0N6N44Kv7qPTvp\n1ggOAeBP\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc52", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `52` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfoyspfoxXFji4MgAoCz2XCTMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGQw\nNGQzMjcxLTE1NTktNGU1Ny1iN2M2LWY3NTJiNjgxMWQzNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGQ1OGMzOWY2LWFjOTItNGRkMy1iYmNkLWM1NmM2\nMmEwNWE2YTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEMKHP711rHIYJ1lbMZL\nosYfU+hWcnMoR5nRR8XIirHq8IvPxRUGbUZ9GMLGZH1djfBh37na+0iEg875Tpv9\n2yujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRxis8i3QbR+VnxqaIjGmwpP+wGhTAfBgNVHSMEGDAWgBR04nAYkyNMDaAtS7CK\nyapA9hH0ojAKBggqhkjOPQQDAgNJADBGAiEArVd7rY7i13PWhPFPN6XrPk4zfCy+\nsO8wU7XcphJM370CIQCRxLfTKWVkd4Jg3LLtqYhKijmUEr/Xmk4OKme0q6xcEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISAWoaV0d7bHe9LAV3i1HiDnudMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDdm\nMmNiN2YxLTY1OTktNGE0MC05Zjc0LTI4OTk2ODJhZDdhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGQ1OGMzOWY2LWFjOTItNGRkMy1iYmNkLWM1NmM2\nMmEwNWE2YTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEMKHP711rHIYJ1lbMZL\nosYfU+hWcnMoR5nRR8XIirHq8IvPxRUGbUZ9GMLGZH1djfBh37na+0iEg875Tpv9\n2yujUjBQMA4GA1UdDwEB/wQEAwICBDAdBgNVHQ4EFgQUcYrPIt0G0flZ8amiIxps\nKT/sBoUwHwYDVR0jBBgwFoAU9hrnTp7ZK3f6a/gbohY2qzh5kLgwCgYIKoZIzj0E\nAwIDSAAwRQIhANt50I6mRr3vb78GXiehi/6BIAIyiQ+Oqufg+GP2EisQAiBaX/aA\n3euW+KhfpreFD+m926o8osFnhaCa7a5IPLgBNQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQHWDAsM9C3INBS27CCb8OB5MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGQw\nNGQzMjcxLTE1NTktNGU1Ny1iN2M2LWY3NTJiNjgxMWQzNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDdmMmNiN2YxLTY1OTktNGE0MC05Zjc0LTI4OTk2\nODJhZDdhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFGw7E1KknBMjryXeg4h\naSphW4YKk9Kd2z248C0qeTUztjD5DwXy2m0Zz+DuhDW/5FsJO+POD2WmaU0QIsbc\nVzOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT2GudOntkrd/pr+BuiFjarOHmQuDAfBgNVHSMEGDAWgBR04nAYkyNMDaAtS7CK\nyapA9hH0ojAKBggqhkjOPQQDAgNIADBFAiEAjds7M8yAgKWQCRX8d71Tvt8inFNW\nscft4lotV81LUP4CIAqW0/ltqmJs/zH8C9q/rBqyi2rlbv1U+PRheWd8RYug\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYXNZLvK8XvDimUwWPNr2NLgMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDdm\nMmNiN2YxLTY1OTktNGE0MC05Zjc0LTI4OTk2ODJhZDdhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJGQwNGQzMjcxLTE1NTktNGU1Ny1iN2M2LWY3NTJi\nNjgxMWQzNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM6JvExaV/h8RHtiog+s\nH4elD6t86gHrO+SfcGRqpSnNP/ycTcg6h/cmtEmNaiN0VoCLA2edTNPTzeG/6cFW\n2iajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR04nAYkyNMDaAtS7CKyapA9hH0ojAfBgNVHSMEGDAWgBT2GudOntkrd/pr+Bui\nFjarOHmQuDAKBggqhkjOPQQDAgNIADBFAiEA8rxP5SWUJx0CXRiLt+5t9RHrL6e/\n0nkBNyifh85RVuMCIH47JSHhggpK2Wvr+JwOe9Nxz2hZGt+uswVWj2/0mIBW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbGgAwIBAgISAdvqNIrzhdoYLLyuh6YdUEnkMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyRkMDRkMzI3MS0x\nNTU5LTRlNTctYjdjNi1mNzUyYjY4MTFkMzQwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATOibxMWlf4fER7YqIPrB+HpQ+rfOoB6zvkn3BkaqUpzT/8nE3IOof3JrRJ\njWojdFaAiwNnnUzT083hv+nBVtomo1IwUDAOBgNVHQ8BAf8EBAMCAgQwHQYDVR0O\nBBYEFHTicBiTI0wNoC1LsIrJqkD2EfSiMB8GA1UdIwQYMBaAFEpmnJsL9B0LhQAa\nHO2EuGuCO9j1MAoGCCqGSM49BAMCA0kAMEYCIQDCQOHbfgoBKbBjh/wuqXaMPFj2\nr42DXWposYin9Zx3YwIhAJL7xsPRzbHClwrO5O6DZdR1FXSSISpxb7uRPYZAn2bM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAbqq4cdboTZ+yNTkmpbctFLQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyQ3ZjJjYjdmMS02\nNTk5LTRhNDAtOWY3NC0yODk5NjgyYWQ3YTcwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARRsOxNSpJwTI68l3oOIWkqYVuGCpPSnds9uPAtKnk1M7Yw+Q8F8tptGc/g\n7oQ1v+RbCTvjzg9lpmlNECLG3Fczo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU9hrnTp7ZK3f6a/gbohY2qzh5kLgwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgGhgu\nO8pSZMEUMx7L1PzDFzQCCF7YLCxus9ixqd1vOkUCIQD17VxP/iHnFZjUkLhUN9w6\nqYIk5kHnTXPoOcVcDNuwFg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAUYJ0mIZNp14jVkO8vXIj9L0MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGQ1\nOGMzOWY2LWFjOTItNGRkMy1iYmNkLWM1NmM2MmEwNWE2YTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQxNTdjN2MzOS01MzIyLTQwYTAtOWYxNi1jNDFm\nYmVlZjYxYWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQzjn0ecHfux58eeoDC\nOEWB18nF7bBJKpRchhwKGG9jIhs/dsq0lER0DX4KSV7EZg6BuvtpUfXB1Y7jXR3n\n2kOYo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRxis8i3QbR+VnxqaIjGmwpP+wGhTAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgHfhes+I1mqDfMaLd\nnFuJFgeozJ6P6rfMXzZDCW4VR6wCIQCKQjO5nqPadXdWOR0NpiIUBRDPz5zXv886\np0bSjqkOMg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc53", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `53` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbe8k7wjIeoU+ahpU0DJ4+oEMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDA5\nMDBhMzYyLTJjZjgtNGZhOS1hMWUyLTdiZDEyZGEzMjhhNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDkzZTQ2NjU0LTQ4N2UtNGMzMy05MTBiLWU2N2Ew\nYmFjOTZiMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHAJh73bkhewYmVNjxQV\nIGUVnlcCioa68oyPgV15pUBAFGKFM/ckWwx6PVdvAquQXlxRhO94xrxtxqGoUAce\nYR2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ1Tcv1gjO2344Sro8+VWasgJiMbzAfBgNVHSMEGDAWgBSWASSi+e67mZW7uzqh\nib+HIxCnfDAKBggqhkjOPQQDAgNHADBEAiAxqENhtiOb3wjXZ/+AUnY3wqsIg2q3\nscTdOUbhd/ojGwIgLUwgK2vRF6kWf4z6BIOd2raNvKVOUSHpRWgjcBf8t6s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB5zCCAY2gAwIBAgISAQ39TdqEHX4Ck25cjoR/WYALMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDAy\nMDVhOTQ0LTc1MTYtNDVlZS04OWFhLTM1ZDBmY2IzZjYxMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDkzZTQ2NjU0LTQ4N2UtNGMzMy05MTBiLWU2N2Ew\nYmFjOTZiMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHAJh73bkhewYmVNjxQV\nIGUVnlcCioa68oyPgV15pUBAFGKFM/ckWwx6PVdvAquQXlxRhO94xrxtxqGoUAce\nYR2jQTA/MA4GA1UdDwEB/wQEAwICBDAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaA\nFHtKd8EPFm3YvxJaVlD53c5Ln41mMAoGCCqGSM49BAMCA0gAMEUCIQDS+HHzVVox\nO1URZucM1BCoQdHYlLJulCjyVdBw3Lc9wAIgBKkZyP8Y3H5ZI/4f7HNfZ62bAxQs\nwxTRqDsvg95sM6M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQC6WV6piweqEcGFyz1+H5wiMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDA5\nMDBhMzYyLTJjZjgtNGZhOS1hMWUyLTdiZDEyZGEzMjhhNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDAyMDVhOTQ0LTc1MTYtNDVlZS04OWFhLTM1ZDBm\nY2IzZjYxMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBKwZZhUS8B0PR08Lr3+\noFAuDpiuVMcBif7XJZ6ruwrNROpmFBxRRzUEy1IXsMtaVvcTBhWv/VGCBmgCaCZ/\nDsejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR7SnfBDxZt2L8SWlZQ+d3OS5+NZjAfBgNVHSMEGDAWgBSWASSi+e67mZW7uzqh\nib+HIxCnfDAKBggqhkjOPQQDAgNJADBGAiEA3DLZaU1RpsjrXBFdpMPc42jRFf7x\nEKEhaBbymIvNcPUCIQDRMb+NvQUKXs/KBOKfQaKraWaRMxCTCjYrZZ01XUTgIg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATLQeLDyvMgBeScTHLo3zCBUMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDAy\nMDVhOTQ0LTc1MTYtNDVlZS04OWFhLTM1ZDBmY2IzZjYxMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDA5MDBhMzYyLTJjZjgtNGZhOS1hMWUyLTdiZDEy\nZGEzMjhhNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDT+TPGmgTeRxpJDf66a\nxbEkwGWIJTDzj4CIYhPWGDlSHyRLsF482/73DFPWn6h6fVbWN6lWmDHL4/54afab\nQVGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSWASSi+e67mZW7uzqhib+HIxCnfDAfBgNVHSMEGDAWgBR7SnfBDxZt2L8SWlZQ\n+d3OS5+NZjAKBggqhkjOPQQDAgNIADBFAiEA/VDhb1ilhycq4QQrXmIQPTXcsjtF\nkqS/Hi9+e2WVb/QCIGnkuH/5bMiA0rXZdIumzZPMw654ctNsv8nGaTcN79ga\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB+jCCAaCgAwIBAgISAfX3mrCcVboEeKTCbVPewS0sMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyQwOTAwYTM2Mi0y\nY2Y4LTRmYTktYTFlMi03YmQxMmRhMzI4YTQwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQ0/kzxpoE3kcaSQ3+umsWxJMBliCUw84+AiGIT1hg5Uh8kS7BePNv+9wxT\n1p+oen1W1jepVpgxy+P+eGn2m0FRo0EwPzAOBgNVHQ8BAf8EBAMCAgQwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjO\nPQQDAgNIADBFAiAigLX2MrUmQzyg7L7CSOw3GEUpB6CmFLPdF+Zrc9TZ5QIhAOic\nD+dv+57hyRTJyUDqn3xle9kSTodrwCd5YTEbCmqV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAeMxyxZc+JtuWDZvvwJ6lxVoMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyQwMjA1YTk0NC03\nNTE2LTQ1ZWUtODlhYS0zNWQwZmNiM2Y2MTMwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQSsGWYVEvAdD0dPC69/qBQLg6YrlTHAYn+1yWeq7sKzUTqZhQcUUc1BMtS\nF7DLWlb3EwYVr/1RggZoAmgmfw7Ho2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUe0p3wQ8Wbdi/ElpWUPndzkufjWYwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAMAq\nUkgZbdA3GSkOz1smRc8ydg8PNhMCq7x6msP0O7LKAiBZbLL264rKgCypPb3QG2my\np5lWt1z6RKUhlByLkYi7Hg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAZGm6qsS8IaZeeP9GZAiFDr6MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDkz\nZTQ2NjU0LTQ4N2UtNGMzMy05MTBiLWU2N2EwYmFjOTZiMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ4ODk3OWU5MC1lYWJhLTQ2MDItOTkyMy1kNzdh\nMjk5MGJkYTkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAT6p7AWPVbWvM2BBAOB\nCSzKQ0A2K9SjJwqUVTN0vwxIaQ4v08o1mw6udEX3MNZOg2RaVc4iMQoMK3dYNWOv\nlA/Po2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ1Tcv1gjO2344Sro8+VWasgJiMbzAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgQ3pWXMgGYmu8sStx\nlOroiRO0uJLKLpyaaZ1Lq0JzUVwCIQDVTq4YvJ5F2hu4Y3PawyNxGw19MumlNYcb\nCDrNYoe1fw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc54", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `54` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYTkyb6AfaXEkK1dwo/qRgeqMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDQw\nNmRlNWUyLTRmZDItNDVhOC1iODdmLThhZjE0YjIzNzlkMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDRiNDFlZDgyLTY0YWYtNGYyMi04NGRjLTQwNWRl\nYTdjODkzZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKVM1XLhBJNd0p+ivbg3\n4YBo0vkgEYjK2usvvu0GH69WDqD9MP+GMwA6Vgx3lK5BxXYNASarMe09sd8r5hYd\nVtujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQSu+SdCWQY3KgTiwOJcANW/w0NqTAfBgNVHSMEGDAWgBSOHsva5l4Sggo34Fyf\nnC1TT53KWjAKBggqhkjOPQQDAgNIADBFAiEA1/8TXlCOU6mcnbXYk5Or6KgG0Ixv\nTLml+nac3BsklMsCIH3fr8x7vNL/OGr4VWQBUOHDZFD9v3z0k2zFGhTelslR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICBzCCAa6gAwIBAgISAYkzYDP5PfsySjR0D5tI6pymMAkGByqGSM49BAEwUzEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEKMAgGA1UEAxMBQTEtMCsGA1UEBRMkZWU3\nYzBlMWMtNmFmNC00MWNlLTkzOWUtODM0OTA1MWE0NGU5MB4XDTI2MDExOTE3MjU1\nNFoXDTI3MDEyMTE3MjU1NFowUzEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEKMAgG\nA1UEAxMBQjEtMCsGA1UEBRMkNGI0MWVkODItNjRhZi00ZjIyLTg0ZGMtNDA1ZGVh\nN2M4OTNmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpUzVcuEEk13Sn6K9uDfh\ngGjS+SARiMra6y++7QYfr1YOoP0w/4YzADpWDHeUrkHFdg0BJqsx7T2x3yvmFh1W\n26NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\nFBK75J0JZBjcqBOLA4lwA1b/DQ2pMB8GA1UdIwQYMBaAFP1ZZ22pNqIUKvkXuYEz\n22ff93gcMAkGByqGSM49BAEDSAAwRQIgVUDnxVRO8skk8Rl48kQaMvfoJ7hT3DdA\nDGtl72pPzAECIQCm+/jFvKoQEJM8vaqpMZAWIwH0HlSjYUCTwspJX05IJA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfJcxyURtfIXzfRTHsZpNscQMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDQw\nNmRlNWUyLTRmZDItNDVhOC1iODdmLThhZjE0YjIzNzlkMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGVlN2MwZTFjLTZhZjQtNDFjZS05MzllLTgzNDkw\nNTFhNDRlOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO4DfgEr/E4vChVK2uja\nK5QfbnHEYnoMLefzlyKakfvcCi+rkZz9gyDezl0VzppqyRppeZO1LsP+eGHsCv22\nZM6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT9WWdtqTaiFCr5F7mBM9tn3/d4HDAfBgNVHSMEGDAWgBSOHsva5l4Sggo34Fyf\nnC1TT53KWjAKBggqhkjOPQQDAgNHADBEAiBvCNoAkBu93XR49hZJWA/Xstiy3SSd\nAkPImtq7ChrpKwIgPxgUYsmU3hhZnq8q559senODj2rJjaCTdjJvNsnEiWU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbhTUtHZwb1CLIgEHDXID07aMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGVl\nN2MwZTFjLTZhZjQtNDFjZS05MzllLTgzNDkwNTFhNDRlOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDQwNmRlNWUyLTRmZDItNDVhOC1iODdmLThhZjE0\nYjIzNzlkMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBJPpjP6I6z+pi7VNClc\nsv/PO3HX4xuCfFadXZ8Z+bLLUrEwlKbdUKeyqU3B0FDXD5CrNy9tdrmF1QzBU3Rj\nbkejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSOHsva5l4Sggo34FyfnC1TT53KWjAfBgNVHSMEGDAWgBT9WWdtqTaiFCr5F7mB\nM9tn3/d4HDAKBggqhkjOPQQDAgNJADBGAiEAyZXUlufDy3NeJXLa09uRh8G/lfeo\nqsn2MlzDoC3BCiQCIQCJdTy3cOByTenJt3+XUOXwRPg6nWFcMveTj2J4o78r7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcGgAwIBAgISAZFcA6GsGGGibHwEvQ+9JOXHMAkGByqGSM49BAEwZjEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0\nX3Jvb3QxLTArBgNVBAUTJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUx\nZDhjYzAeFw0yNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoT\nDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDQwNmRlNWUyLTRm\nZDItNDVhOC1iODdmLThhZjE0YjIzNzlkMzBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABBJPpjP6I6z+pi7VNClcsv/PO3HX4xuCfFadXZ8Z+bLLUrEwlKbdUKeyqU3B\n0FDXD5CrNy9tdrmF1QzBU3RjbkejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSOHsva5l4Sggo34FyfnC1TT53KWjAfBgNVHSME\nGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAJBgcqhkjOPQQBA0kAMEYCIQDqDk7x\n6vqlsxzU/0iKHuJU8d/bmyfpcdYl/9j2jI0kFgIhAMzcMiMCLC3rmj1+AhMRpRQM\nwGe6OUcUzKuKNdNhOdeD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAaFFqYYLe9PFti81J0gF6JYiMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyRlZTdjMGUxYy02\nYWY0LTQxY2UtOTM5ZS04MzQ5MDUxYTQ0ZTkwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATuA34BK/xOLwoVStro2iuUH25xxGJ6DC3n85cimpH73Aovq5Gc/YMg3s5d\nFc6aaskaaXmTtS7D/nhh7Ar9tmTOo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Vlnbak2ohQq+Re5gTPbZ9/3eBwwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAKM4\n932HGbxdofK6xd65QNMzEZCIV14ITxQS5aLgOCxOAiEAmSfWKP/y1084pnFaLaN4\nj3bYsShqHMImQSzbHsSppXE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAWjfXZ3g0VRVqS9pe1QFF+qjMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDRi\nNDFlZDgyLTY0YWYtNGYyMi04NGRjLTQwNWRlYTdjODkzZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQwOGFmY2FlZS0yOTUyLTRlMmYtOGI1Yi04NmY2\nNmE1OTE5NDcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATIN4goCDkVaTdMu0mD\nKEJnWc0ySm4kRlvqkwklESdOz7O4SYlZzgFIieZV0AU+2oBQoi1498ik0WF6pnEG\nWCtko2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQSu+SdCWQY3KgTiwOJcANW/w0NqTAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAMk9lOOYQfGUS4Sv\nj41Yp03/9+y5BBWEE2tVF1meK8OXAiBMzjVaEKAzwawnZbkEiJiSaTFo+rHCGdYh\n3QvhQE+18Q==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc55", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `55` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASk5CqfL5urvE4BqLJARfHP/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDQ4\nNTAyYmU4LWE4ZDUtNDNkMi1hOGQ5LWZlY2E0NzM1ZDA0YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNjAxMjAxNjI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDk2NDU2ODg1LTkyYjYtNDI5YS1iYjk1LWE5Zjk3\nM2ZjOTBmZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMxZHn7Bd3WpNCAVQl1f\nBMfbtbjh0OJ307Jth7BLBHwqozKUhj0ucblIDN9sKT3k8g/2szDHJ1bc2rsKu5zj\nQeKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTJ30YkDATGyTyvdBhMi1zwPXUVkTAfBgNVHSMEGDAWgBRH78U4CDMt6ylXE5TI\nn6XI3Y+AFTAKBggqhkjOPQQDAgNIADBFAiB33wJHR+AelA8teTkGi78e8nCqgFIF\nUCjUxiqmjm2DPgIhAN+g6Ma8vVIRTinCf8Zp+3rR5VDLHwbqyiyKkOATPJZC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAW4+mKgWXBYmA+RnD9LTenbiMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDJj\nNjlkMzNhLWE1M2YtNGNkZi04OWM1LTc4NjdmMjRkZjU2YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDk2NDU2ODg1LTkyYjYtNDI5YS1iYjk1LWE5Zjk3\nM2ZjOTBmZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMxZHn7Bd3WpNCAVQl1f\nBMfbtbjh0OJ307Jth7BLBHwqozKUhj0ucblIDN9sKT3k8g/2szDHJ1bc2rsKu5zj\nQeKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTJ30YkDATGyTyvdBhMi1zwPXUVkTAfBgNVHSMEGDAWgBQrY+CAdj7lD5ArW2LW\nXuplRVJC8DAKBggqhkjOPQQDAgNJADBGAiEA8RQBH/ozt5wxA55kK+INszhT+8nu\n80c//qjN2mHsiwUCIQCU3gClChvvoRvjzqp3odIFYwBkpUoa8h+Fw6m7IQYVkQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdwvwYZkW4VmlT2RezG1DUXXMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDQ4\nNTAyYmU4LWE4ZDUtNDNkMi1hOGQ5LWZlY2E0NzM1ZDA0YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDJjNjlkMzNhLWE1M2YtNGNkZi04OWM1LTc4Njdm\nMjRkZjU2YzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNfEoufCH1XsibqHX0kF\njpwrzwFDEqEeIbkkcscZQxsDgguYGR66TrF3W+NUT5stK+S8Rjk+B6S1BBW0L0kA\nnCmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQrY+CAdj7lD5ArW2LWXuplRVJC8DAfBgNVHSMEGDAWgBRH78U4CDMt6ylXE5TI\nn6XI3Y+AFTAKBggqhkjOPQQDAgNIADBFAiEA2z66rW/CUxtUMpPvfPsWKu2kf0E/\nLcMYw0WPk7h70E0CIEy+p8KsMRTdMkiROlP4MKLoSgaDzazLielFMLNEnjpo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAT05zAajM8n7z26pi82UwjFNMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDJj\nNjlkMzNhLWE1M2YtNGNkZi04OWM1LTc4NjdmMjRkZjU2YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDQ4NTAyYmU4LWE4ZDUtNDNkMi1hOGQ5LWZlY2E0\nNzM1ZDA0YzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBIQ0TkmG2tpzeH2dVIX\nPpd03KG5ICSubQZxM9ckvPP3vmFMQXpCmmCBlyuQ/V/5/XVCJ/UdAgtrS/IytDHs\n5FGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRH78U4CDMt6ylXE5TIn6XI3Y+AFTAfBgNVHSMEGDAWgBQrY+CAdj7lD5ArW2LW\nXuplRVJC8DAKBggqhkjOPQQDAgNIADBFAiEAm1rSLFmoQngGh0RsusgvOg0Iq56y\nQ7Nx6MNv+Slz6VgCIGqnsZ9GyHT6U+8VgAg/NP1OI674M6qZagUi49N3cL15\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISAaRvmsX4R3ImY8l6zi9X1HiFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyQ0ODUwMmJlOC1h\nOGQ1LTQzZDItYThkOS1mZWNhNDczNWQwNGMwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQSENE5Jhtrac3h9nVSFz6XdNyhuSAkrm0GcTPXJLzz975hTEF6QppggZcr\nkP1f+f11Qif1HQILa0vyMrQx7ORRo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUR+/FOAgzLespVxOUyJ+lyN2PgBUwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgHkMD\n6chMGWhtQj/xIAIXtlqEfZiz1y1n27Qxr3Ba/v8CIHmZYdEWKNH1aJcTIFN6n+69\nsZZbOuoKi2+wptkIV8Mg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAehbloNL2tx9/9/uF1MGs340MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjYwMTIwMTYyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyQyYzY5ZDMzYS1h\nNTNmLTRjZGYtODljNS03ODY3ZjI0ZGY1NmMwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATXxKLnwh9V7Im6h19JBY6cK88BQxKhHiG5JHLHGUMbA4ILmBkeuk6xd1vj\nVE+bLSvkvEY5PgektQQVtC9JAJwpo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK2PggHY+5Q+QK1ti1l7qZUVSQvAwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgDzhq\nkD6DUeRSsOp/XUvvEywC/gJAhaGpxXA2kL91PCICIQCcQUpxyBMO+iD+tQdjwPkj\n0YlwDm6kqMBZjr7SqLpx/Q==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAW1xFUlLFefmbERP2anvjbHJMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDk2\nNDU2ODg1LTkyYjYtNDI5YS1iYjk1LWE5Zjk3M2ZjOTBmZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRjZGNiNmNjNy00YTAxLTQzMDItYTRhNS1kMTg1\nNjY3YmEzM2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS/DxD3H7HA+ahmbfL2\nixxTF2qqIIlDDLg1maDF6HQY8guBXz0SrVswmPgsC3wkT85gdFKKBZyCkLyNXLMJ\nKhW7o2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTJ30YkDATGyTyvdBhMi1zwPXUVkTAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAOucHxKfdJ9PNNT2\nuejM+rDjg9MBNqn5x7yjBLgUZkGnAiAiqcT/83CkvrlfM9FqCbfdtEGp8+HcI6yi\nzZK4qAR0DA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc56", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `56` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICLzCCAdSgAwIBAgISAYpjRA5fACVEtvTA+mOlBJeFMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGZk\nMmZmZTUyLWNkMGUtNGUwNC1hZTQ2LTNlMjFkN2U0ODZjYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDI3ZTBjYmVjLTU1MTgtNDAwNi1iYzAyLTYyNzY1\nYThkMTc2ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIlbTdqdBixboi59qjNK\nQjlYaFTomjzspUdbqpRy7NbbDlrIEdN6frifU+WVIE9HynCKBQqpFZBriRmp6Lku\nA2GjgYcwgYQwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O\nBBYEFMSMwAvud/PL4+57KYhX3KHtTfawMB8GA1UdIwQYMBaAFAdVKPiafrdT30Tc\nx5lup6pcvUn4MCEGA1UdHgEB/wQXMBWgEzARgg9iYWQuZXhhbXBsZS5jb20wCgYI\nKoZIzj0EAwIDSQAwRgIhAO1WWBc6R2LNJX3VSB1FlyAyJ007SNaPySMdDyOlX+gA\nAiEAqew4iSVpEVyp5/5dDTTwgAXuqsmlvyyNqUNap90Vta4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWL3g4CwHTFGk/bTO7apjKYxMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGQy\nMzJkZDMwLTE5MmMtNDQxMi1hOGYyLTkxOWIwMjcxMzk1MDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDI3ZTBjYmVjLTU1MTgtNDAwNi1iYzAyLTYyNzY1\nYThkMTc2ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIlbTdqdBixboi59qjNK\nQjlYaFTomjzspUdbqpRy7NbbDlrIEdN6frifU+WVIE9HynCKBQqpFZBriRmp6Lku\nA2GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTEjMAL7nfzy+PueymIV9yh7U32sDAfBgNVHSMEGDAWgBSaIicOm8wziBByWTbs\n2fotR+SwlTAKBggqhkjOPQQDAgNHADBEAiBiIpe1S5CosClPLlRYRpaS1SUb7TwE\nVSm429NgP3nPggIgSq8czX0ypUXBlXUODaaJXfriEy7tdUjChX2xrLGrJH0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARI5YTSY1aGqIMzaQ39UchWOMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGZk\nMmZmZTUyLWNkMGUtNGUwNC1hZTQ2LTNlMjFkN2U0ODZjYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGQyMzJkZDMwLTE5MmMtNDQxMi1hOGYyLTkxOWIw\nMjcxMzk1MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGNXwcQFKpUECeQ3C1bF\nd4m/hteFXmhV1uU383Q3WoQW1z1EpKIHDNRRuv1yh4rPUpenmMuM0N8rN481X21O\nhbOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSaIicOm8wziBByWTbs2fotR+SwlTAfBgNVHSMEGDAWgBQHVSj4mn63U99E3MeZ\nbqeqXL1J+DAKBggqhkjOPQQDAgNIADBFAiEA8KnNrVJJ+etOsvMu6oy4thNe+itB\nydImYzx34bwaFKICIFdpCN80r16yT0Gj+bzN3WVBCwlFLCEmfqaDWiE9mmaF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATpb/InxWCVsnq6CoxK3xK5/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGQy\nMzJkZDMwLTE5MmMtNDQxMi1hOGYyLTkxOWIwMjcxMzk1MDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJGZkMmZmZTUyLWNkMGUtNGUwNC1hZTQ2LTNlMjFk\nN2U0ODZjYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGYjvV53sVeWv9tj3F7d\nRwVqoXyCO/N9/8GWw8aDim6uO8YABZS6mP3ra8vnLBMuYuLD5LRb9K+PKEZxoTGh\nk4OjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQHVSj4mn63U99E3MeZbqeqXL1J+DAfBgNVHSMEGDAWgBSaIicOm8wziBByWTbs\n2fotR+SwlTAKBggqhkjOPQQDAgNIADBFAiBYnuTAzS3KnFuX6s44Lqj2Y5SnNFCG\nn+D/6UGNpVJ0VAIhAMzbP+VvGzwHZR61dZLNRkbRbjgq3HjexYSfi3nEd9Yc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAZ1cjLXV1sZlq7Fp5Zc+mNItMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyRmZDJmZmU1Mi1j\nZDBlLTRlMDQtYWU0Ni0zZTIxZDdlNDg2Y2EwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARmI71ed7FXlr/bY9xe3UcFaqF8gjvzff/BlsPGg4purjvGAAWUupj962vL\n5ywTLmLiw+S0W/SvjyhGcaExoZODo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB1Uo+Jp+t1PfRNzHmW6nqly9SfgwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAMAW\nEnGMcbgpzN8CFlqU4qTEXzc8flc5U4dcR8otoGYaAiEAiU7BIlfAE4RhhRc13xbb\nvaop6ookkbpLi0MWJFa0e20=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICQTCCAeegAwIBAgISAb3qKDN38aREbI5wXKk+HBWFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyRkMjMyZGQzMC0x\nOTJjLTQ0MTItYThmMi05MTliMDI3MTM5NTAwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARjV8HEBSqVBAnkNwtWxXeJv4bXhV5oVdblN/N0N1qEFtc9RKSiBwzUUbr9\ncoeKz1KXp5jLjNDfKzePNV9tToWzo4GHMIGEMA4GA1UdDwEB/wQEAwICBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSaIicOm8wziBByWTbs2fotR+SwlTAfBgNV\nHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAhBgNVHR4BAf8EFzAVoBMwEYIP\nYmFkLmV4YW1wbGUuY29tMAoGCCqGSM49BAMCA0gAMEUCIFzx94krZc18B4MAuMVP\nS2Y3cqhIHzQqaTa3CgPc2Q1kAiEAoXbuFlzoh2PSlB2SKrhRJKXqhiTroR91Mr9Z\nHIG5sn0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAaKmZxqY8LjCEEzKpJri7PulMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDI3\nZTBjYmVjLTU1MTgtNDAwNi1iYzAyLTYyNzY1YThkMTc2ZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRhMjMzODdkMC1kMDA3LTQ0N2UtODQ3YS0yNGQ0\nNGIxZjE3YzAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASmNFC1ghswCG9iFmye\n84PSMkVFwr/8518Ivum3rx/KkxoxY4vC5yVD8k7aOq4scNGC62/axzBP7VBjEFzb\nQfYlo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTEjMAL7nfzy+PueymIV9yh7U32sDAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIB7jXOA+7hJAXXs\nhdlQM9hd0ssnUg1HfPPJcQG6z2LJAiAqPN0iPLwC0XPlXk4LJDKPdRXMsZc1QthS\nEJK5jvVuyQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc57", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `57` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICHjCCAcSgAwIBAgISAcMsvTVcs8UCE6rSDBpPYrF4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDc3\nZjIxYjVhLTg2ZGQtNDRiMC04MDYwLTUwN2I2OWY5MzU5OTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGFlZDY2MTQ3LTQzMmEtNDJlNy05ZWE4LTE5MzAz\nZTg0MWNiODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKJHdoXc+SHvOH0wdU+m\n3y6lCkVvhye4aadKmxTzHRXK/mIJpEcE6nmwE5mNQoMHbpswnP3I4yYZYkFlM9wf\nkz+jeDB2MA4GA1UdDwEB/wQEAwICBDATBgNVHSUEDDAKBggrBgEFBQcDBDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQr0esnjau/indTyUMi46zA3Z9lXjAfBgNV\nHSMEGDAWgBTq1OYv+nEPaip3doWGoobgwnSQNTAKBggqhkjOPQQDAgNIADBFAiAG\nQeZvAppdSRUmqPIx/YZmENw+qzCiE3M+YwG5x0PrPQIhAKWrVfQKtasiIVy5c9wz\ncpQyx87b/gbx0Gztgg+eWt2E\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcxFscQLV7X0UFLFNri/rzcwMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGY0\nOTQyNDg5LTg0ZjAtNDgwYy1hYzcyLTY3MDUwZTliMzViNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGFlZDY2MTQ3LTQzMmEtNDJlNy05ZWE4LTE5MzAz\nZTg0MWNiODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKJHdoXc+SHvOH0wdU+m\n3y6lCkVvhye4aadKmxTzHRXK/mIJpEcE6nmwE5mNQoMHbpswnP3I4yYZYkFlM9wf\nkz+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQr0esnjau/indTyUMi46zA3Z9lXjAfBgNVHSMEGDAWgBQBq4Vwqq3MDZcVNrsi\nTCK2xDHomTAKBggqhkjOPQQDAgNIADBFAiAj1qUa0Evlv79AFNa1karc0fbZUcOd\na08PSOQ3vhFwDwIhANgTZVheolaoc5nFs9hBaCH65giVq58m5Wire3HS8xMa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZ0AWxvhzvqoIJYZsJIdO8YVMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDc3\nZjIxYjVhLTg2ZGQtNDRiMC04MDYwLTUwN2I2OWY5MzU5OTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGY0OTQyNDg5LTg0ZjAtNDgwYy1hYzcyLTY3MDUw\nZTliMzViNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJfZVCiNkmQRpiLqfnMZ\nm18HLdLu+98dceVCVJOBRs9Wl/v7E7A5SXH2X97Aq1YFZPGMEIMqnd1XZ1uArj3w\nikyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQBq4Vwqq3MDZcVNrsiTCK2xDHomTAfBgNVHSMEGDAWgBTq1OYv+nEPaip3doWG\noobgwnSQNTAKBggqhkjOPQQDAgNIADBFAiEAuZkIMdK5IL5zTOfqZnqRni0PvCN0\ndoPQxGJtDmZLU1UCICqLN+Ix9lbJ1Qq6YHfhgFdaMrb4XXvPC8yxMYTZi2Fo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASlLxOk1MvwZ/qN6+UR8OMJQMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGY0\nOTQyNDg5LTg0ZjAtNDgwYy1hYzcyLTY3MDUwZTliMzViNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDc3ZjIxYjVhLTg2ZGQtNDRiMC04MDYwLTUwN2I2\nOWY5MzU5OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHK9vbaGOWmbq4QQJ8Gv\nNSsL3WZORVdUs2WRVneN45aR25tgkTfgKQMEzD7pf6y8xANAscqVaEvBa2p3STdf\nhNSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTq1OYv+nEPaip3doWGoobgwnSQNTAfBgNVHSMEGDAWgBQBq4Vwqq3MDZcVNrsi\nTCK2xDHomTAKBggqhkjOPQQDAgNIADBFAiBITnKhLtqsjyNjfHOFNb2CR4F9kNKJ\nS3kh9px6I2rwkQIhALFx2BA2+kWCrKTCZxgl8OhrtuurhAaO4GMxG6gC9I7a\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISATCfqkfjUDF7d83KG7Puy9lTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyQ3N2YyMWI1YS04\nNmRkLTQ0YjAtODA2MC01MDdiNjlmOTM1OTkwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARyvb22hjlpm6uEECfBrzUrC91mTkVXVLNlkVZ3jeOWkdubYJE34CkDBMw+\n6X+svMQDQLHKlWhLwWtqd0k3X4TUo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU6tTmL/pxD2oqd3aFhqKG4MJ0kDUwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAIdd\naSS2/taWanZ+Uht+/fFfEDFfV+7Iww2M9fTMt9vDAiEAvB804+eDuPkuZto6vZQV\nJSjPpWgMMgHQEMq343036KQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICMTCCAdegAwIBAgISAZ3i4RHKjDgTqLeuo3cDyUz0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyRmNDk0MjQ4OS04\nNGYwLTQ4MGMtYWM3Mi02NzA1MGU5YjM1YjUwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAASX2VQojZJkEaYi6n5zGZtfBy3S7vvfHXHlQlSTgUbPVpf7+xOwOUlx9l/e\nwKtWBWTxjBCDKp3dV2dbgK498IpMo3gwdjAOBgNVHQ8BAf8EBAMCAgQwEwYDVR0l\nBAwwCgYIKwYBBQUHAwQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUAauFcKqt\nzA2XFTa7IkwitsQx6JkwHwYDVR0jBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUw\nCgYIKoZIzj0EAwIDSAAwRQIhAPeVfXd1Y9UPHcsxXdLtnOO7IbvZkghw/sVkv/Ij\n7ZjvAiBfRdEJ+5uFOUBuChydERtln0+3OTPago/6qIt3T1sr3g==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAVV2QVH4LVQQfKJSafcb7hd0MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGFl\nZDY2MTQ3LTQzMmEtNDJlNy05ZWE4LTE5MzAzZTg0MWNiODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRhMGM5MTE1NC04ZmYxLTQ3YjQtOGM2MS02MjJm\nNDQ5ZWViNjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASOCRwGFhjKQVfkU0ll\ntZa2hI2oWxlyhEKwSOm20hC8TdaExTB/SiIyssVFeDi3DWSybO5wsoFRC/T3cBqY\n2ggDo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQr0esnjau/indTyUMi46zA3Z9lXjAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAO0xA6XYGWD0UMtr\ntR/aae77f57LcC4a8hkPIiVMKd3+AiEA18zOetOHr6NH9X3z3kfFz9ueRubyr/XE\nvRnwd64AeGk=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc58", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `58` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB+DCCAZ6gAwIBAgISATh2ANJwc3VhLMisyAIPNySUMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDBk\nYTdjNWZjLTg4MzItNDNkOC05Yzg5LWQ2MTYzMjJjYzQ1NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDkzYjUzMDRmLTYyNDAtNGJkNi1hNmY1LTA5ODQ2\nYzBhZjNlMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE9MeRAR9alnXq00fq9m\n7o5BgXA19jC2C95sSdii+EjCeKaanZQlg5+yd8+VPxdzmOcNayRDqrc1fWvPnON1\niP+jUjBQMA4GA1UdDwEB/wQEAwICBDAdBgNVHQ4EFgQU44Qa7YGf80mcrx95IPnl\nYvps7pkwHwYDVR0jBBgwFoAUeFoHO04aDV4mZKqQlivtwPAS23YwCgYIKoZIzj0E\nAwIDSAAwRQIgIS70plwc5dEGacJ83N348U/YENZzpEzACdCDcBRx9ngCIQDtbFFC\nWGR3uHoeYs8Jdgsul+grXqlIVt1O5QzRkdxN+g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXgP4rbLSjcjmFlV0t6l+4t5MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDI5\nYjYwMjY0LTJhNTYtNDNiNi04NDhmLWI3MGVhNGJmNjY2MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDkzYjUzMDRmLTYyNDAtNGJkNi1hNmY1LTA5ODQ2\nYzBhZjNlMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE9MeRAR9alnXq00fq9m\n7o5BgXA19jC2C95sSdii+EjCeKaanZQlg5+yd8+VPxdzmOcNayRDqrc1fWvPnON1\niP+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTjhBrtgZ/zSZyvH3kg+eVi+mzumTAfBgNVHSMEGDAWgBSyCHSIKV4nmWt8qBqM\n3uNVdkwBLTAKBggqhkjOPQQDAgNJADBGAiEAyZ0F0H9gpB8q8232/P3yltENHX+k\n87M2Yi9Cj1bgRB8CIQDCsZn7cSRBclZFrcvzrfgUjoam+P63LrUGYeSCh6pbWQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXRFSU1WT2wnuvd2xMhMl7GKMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDBk\nYTdjNWZjLTg4MzItNDNkOC05Yzg5LWQ2MTYzMjJjYzQ1NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDI5YjYwMjY0LTJhNTYtNDNiNi04NDhmLWI3MGVh\nNGJmNjY2MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABF6AJ2TcpzN2AAUEUyw1\naaziFeJd/28812vXDx/uzSFAElOdKj6qO32fAPJuDni3d6m984mE0Q5quuWP5pcV\nYUujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSyCHSIKV4nmWt8qBqM3uNVdkwBLTAfBgNVHSMEGDAWgBR4Wgc7ThoNXiZkqpCW\nK+3A8BLbdjAKBggqhkjOPQQDAgNIADBFAiBKrmWGHZnmNpUsVsCNeO8jYiCxiOYQ\n+ddyuGSsWKZe/QIhAPWyE/6vdb8L0BUBjNSf2BysbAEASB+XRWDwke64/euw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUyGqnKzMcbInpKerjHLy8BzMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDI5\nYjYwMjY0LTJhNTYtNDNiNi04NDhmLWI3MGVhNGJmNjY2MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDBkYTdjNWZjLTg4MzItNDNkOC05Yzg5LWQ2MTYz\nMjJjYzQ1NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPbMFZS/hCNoUv8yFZQ1\nMLR3cl7TdT/6xBMJOa6b+7cfFo7z1H0xb8Wc+xF6HOHeNOng/YlkJrkQ1nGE6mh8\nXtGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR4Wgc7ThoNXiZkqpCWK+3A8BLbdjAfBgNVHSMEGDAWgBSyCHSIKV4nmWt8qBqM\n3uNVdkwBLTAKBggqhkjOPQQDAgNIADBFAiBoyItzCqRYCD6DcIxWi85cnKjTGNtE\ndYTT8jP13IGAAAIhAJUNtnMRGB71VFPJdTwm6rswzZm8i/IOcU+H8HpkiH6i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISASkA14rTsFX1AQf2bA7HciFFMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyQwZGE3YzVmYy04\nODMyLTQzZDgtOWM4OS1kNjE2MzIyY2M0NTQwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAT2zBWUv4QjaFL/MhWUNTC0d3Je03U/+sQTCTmum/u3HxaO89R9MW/FnPsR\nehzh3jTp4P2JZCa5ENZxhOpofF7Ro2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUeFoHO04aDV4mZKqQlivtwPAS23YwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhALTh\nmQdXUDvBZanJ5kjJ71MACyO9qpWnC+sfwbk1NXFDAiBr0lAgBD2cmRZ45mIcaOJj\nv8g/xUAAPMuYBz3lNPRBZA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbGgAwIBAgISAZrlRXabqHRalrXyauTxjzA7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyQyOWI2MDI2NC0y\nYTU2LTQzYjYtODQ4Zi1iNzBlYTRiZjY2NjIwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARegCdk3KczdgAFBFMsNWms4hXiXf9vPNdr1w8f7s0hQBJTnSo+qjt9nwDy\nbg54t3epvfOJhNEOarrlj+aXFWFLo1IwUDAOBgNVHQ8BAf8EBAMCAgQwHQYDVR0O\nBBYEFLIIdIgpXieZa3yoGoze41V2TAEtMB8GA1UdIwQYMBaAFEpmnJsL9B0LhQAa\nHO2EuGuCO9j1MAoGCCqGSM49BAMCA0kAMEYCIQDw9Giyjv6uGdPyHwVOC0kXvSW2\nontpOZpInBpXWm1kEwIhAK26FWb1m27ukCwms3r4aUJzmj+m4ATalL1tCnU4PQI9\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAcEqqC25PrZcGJSrtG4H/6kQMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDkz\nYjUzMDRmLTYyNDAtNGJkNi1hNmY1LTA5ODQ2YzBhZjNlMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ5ZDg4YmRlNC03ZjIxLTRmMGQtYTdiMy1mZWI0\nYjZiYWMyNGIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQquyCfVLP+v/2QoBeU\nfZIuDPhn4e4YegLpB0Sosye9HcI0MqpSAcW9s9SJ88DSFQiIc3HmZQdouXMYfosV\nG4VEo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTjhBrtgZ/zSZyvH3kg+eVi+mzumTAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMT4YifXfEEmEMIE\n4LoFOuepNuzkt4xRbEXtPBQ2/nZ0AiEA4J1DBMRZUWhDJTVHy7UxlymQL0r73CuF\nJQ7Zsif4Ahg=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc59", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `59` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIB5zCCAY2gAwIBAgISAXcb1uuVhcx/qQK6weFHCroNMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDVi\nMjA0YjAxLTA0ZGMtNDc3Ny05N2U3LWY2ZWVjZTJkNDA4MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDJkMmRlNmRlLTE4ZjEtNDUxZi05ZmM2LWE4MTMy\nNTAxMWNmZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE/05fjQhQcUE3jTHrHF\nshFwCXY91K0lgOCo1WBT9uyaMl4YWVxl9Unf1Lso2LlSC2MyMiRuGO3Khb9C8XBG\nXVGjQTA/MA4GA1UdDwEB/wQEAwICBDAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaA\nFFMVF/4gzLrXpRryBtDsrHA/M7cNMAoGCCqGSM49BAMCA0gAMEUCIAw0ipTkqmt5\n3pbHYSYES+8aRPotBWm2Um+7O1ptBjJeAiEAsG65bekGSzGHpFdO/ktz0jQFFwj8\nVRuLZozk0mcBDOQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVGsGwBrnPlXykd8jy1mx3+PMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGJm\nMGVhNTFiLTQ0ZDAtNDNkZC04YjEzLWRhYTllMGQ4ZTM4MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDJkMmRlNmRlLTE4ZjEtNDUxZi05ZmM2LWE4MTMy\nNTAxMWNmZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE/05fjQhQcUE3jTHrHF\nshFwCXY91K0lgOCo1WBT9uyaMl4YWVxl9Unf1Lso2LlSC2MyMiRuGO3Khb9C8XBG\nXVGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSumwLkCJ540igkuEffdXMcP++Q4zAfBgNVHSMEGDAWgBS4IUyVAUGHrjeE5FoD\nlyMozLfBUDAKBggqhkjOPQQDAgNIADBFAiAtgr3IT12qMucw9Z/otNCs5Jd+vx5D\niHYiYLHGNfNfEQIhAP37Dugu8mLK8g5TLrz1fuLrEN9CLfwuOOXZr+J2j4Qy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcyHW6ht8zUMie2AlXJ/7SpkMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDVi\nMjA0YjAxLTA0ZGMtNDc3Ny05N2U3LWY2ZWVjZTJkNDA4MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGJmMGVhNTFiLTQ0ZDAtNDNkZC04YjEzLWRhYTll\nMGQ4ZTM4MTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAeV/j7AAN8Hpunh+JRL\n3f08qqqGO6yOqO+W0+ySiMkzCc8z9CC8WK7MHR6nhA4Q978O3jcNSSkozgtQPwCD\ngXKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS4IUyVAUGHrjeE5FoDlyMozLfBUDAfBgNVHSMEGDAWgBRTFRf+IMy616Ua8gbQ\n7KxwPzO3DTAKBggqhkjOPQQDAgNHADBEAiBTFVaAN3Fw4KrA3o+6ju8xcVIWC1Nd\n8et2v/z3YtmsUAIgaBoeWl0xMdW6ndg2IbRP59qB1tUkRTB9gC/pAyBIAgk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVKlw4+lZeJQhXPFkAwtFa1uMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGJm\nMGVhNTFiLTQ0ZDAtNDNkZC04YjEzLWRhYTllMGQ4ZTM4MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDViMjA0YjAxLTA0ZGMtNDc3Ny05N2U3LWY2ZWVj\nZTJkNDA4MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAqCT8Aoc6eoA2TjxYFE\nXsKbMOCfa3kSkOsqlJxWCvpm3LShPu7Cmg4hDbIoV6qPEdIlvZhZpiouBhZuua//\nIymjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRTFRf+IMy616Ua8gbQ7KxwPzO3DTAfBgNVHSMEGDAWgBS4IUyVAUGHrjeE5FoD\nlyMozLfBUDAKBggqhkjOPQQDAgNHADBEAiB5La71ryU2+4C4yZvMKgDlg65iiVKk\nTW3Gsa+Ik5rn2QIgaf9o7O3Yc2Hu6CXmaBo6413jQ6qZsb1qjROEIGEd6mo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAX4QIZPXlJjeoUZ2GrbrsYtPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyQ1YjIwNGIwMS0w\nNGRjLTQ3NzctOTdlNy1mNmVlY2UyZDQwODIwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQKgk/AKHOnqANk48WBRF7CmzDgn2t5EpDrKpScVgr6Zty0oT7uwpoOIQ2y\nKFeqjxHSJb2YWaYqLgYWbrmv/yMpo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUxUX/iDMutelGvIG0OyscD8ztw0wHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhALg/\nq6gGnoc69uPlfWzfF+vlVdbFDzlOiqe5CT2sl+NdAiAAr6NSG5RfSZom0mIYnDdu\ngKhj/GuDxjMTJYalWKZyDA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB+TCCAaCgAwIBAgISAUh3jdk2Dy0LZTZGWiTnhimmMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFBMS0wKwYDVQQFEyRiZjBlYTUxYi00\nNGQwLTQzZGQtOGIxMy1kYWE5ZTBkOGUzODEwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQHlf4+wADfB6bp4fiUS939PKqqhjusjqjvltPskojJMwnPM/QgvFiuzB0e\np4QOEPe/Dt43DUkpKM4LUD8Ag4Fyo0EwPzAOBgNVHQ8BAf8EBAMCAgQwDAYDVR0T\nAQH/BAIwADAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjO\nPQQDAgNHADBEAiASCou7nVhItintEchqn5VYqJ6R9gEyDK7iv+58hbx16gIgJVsC\nYdo7RlWok6kR/2TpsmUfL2eLK/RqGC8jCUIf1sQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAVJizyVflnR9UlH36T492gN1MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDJk\nMmRlNmRlLTE4ZjEtNDUxZi05ZmM2LWE4MTMyNTAxMWNmZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRmNDY5MTVjNi0xZmI4LTRjNDYtYWU0Zi1kYTk0\nNjU5YWIxZmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQ8prcbR89rLc8BUpa/\nVDGHC6AE59yUlCJWnItyBsAjsjQldYOyYLTJyKt95L0rJ6sJtlVJRitYi/h3avo6\nvf0qo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSumwLkCJ540igkuEffdXMcP++Q4zAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgIUauhJXrSTgv+oUn\neTItA9GJ2FN+tk1OV4Bpd7NG9r8CID+OiHMZV9eC+kNOaBP1zVjNv6LO8dwGsu0o\nIFQUqHlU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc60", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `60` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa6gAwIBAgISAUMgRkotuhHBlajRsOP04hIwMAkGByqGSM49BAEwUzEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEKMAgGA1UEAxMBQzEtMCsGA1UEBRMkMGIz\nYzRiNjktNGU3Ny00OGI5LWJmZjQtYTcyNWRlMDkzOTllMB4XDTI2MDExOTE3MjU1\nNFoXDTI3MDEyMTE3MjU1NFowUzEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTEKMAgG\nA1UEAxMBQjEtMCsGA1UEBRMkYjFhN2JkMjctOTMwZi00YzVkLTlmNmUtOWE3ZjYz\nNTAzMWNkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEP2P+CXAIIKVFyzTUGrm8\nZsG1PWRYVvz5gxC+eIGCUa0fNvWnH8dLzk9H34GNerx23QE6FZG5qhKjyTsaSEO8\nMKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\nFPqD2ZzTUvAmUncFjgId93mxmaLaMB8GA1UdIwQYMBaAFKznIbNx8i+2nisN8IDD\nXB1YnksqMAkGByqGSM49BAEDSQAwRgIhAKVGRZhTVxtigqP7TXt/xtx4QaVJGC+D\nQWkOCujYRLzxAiEA8+yxhqEojNjni/ePTQpdNm4L9SqeRtvQdykF1XWPkzA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVj8wnavdcD1/HNKTHji3QrpMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDBh\nYTY0MTcyLWM1YmYtNDBmYy1hYmNiLTAwMGZmMTYzYjRhYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGIxYTdiZDI3LTkzMGYtNGM1ZC05ZjZlLTlhN2Y2\nMzUwMzFjZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD9j/glwCCClRcs01Bq5\nvGbBtT1kWFb8+YMQvniBglGtHzb1px/HS85PR9+BjXq8dt0BOhWRuaoSo8k7GkhD\nvDCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT6g9mc01LwJlJ3BY4CHfd5sZmi2jAfBgNVHSMEGDAWgBRnoeYZBcOBcS5pu8xA\nuBm2/iZVhDAKBggqhkjOPQQDAgNIADBFAiEAuTZTksl3pYiO8M0yGNnLOTME1z4s\nzCfWkHJba5I4pK4CIF1+hSlYGHy4b4hdcRFhohY5YGIJ4oS8z02nfzEDbqxa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfJzdDLIz1OxfJ4vh9N5O0XjMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDBi\nM2M0YjY5LTRlNzctNDhiOS1iZmY0LWE3MjVkZTA5Mzk5ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDBhYTY0MTcyLWM1YmYtNDBmYy1hYmNiLTAwMGZm\nMTYzYjRhYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBeqkqOX+oyBHWuJPgbs\n7GUu2kMuuibrV92zxq6OqwWg/Owgh34LhTKOAlJ4G8OG8xFfKrouCOvhGqUgBEFM\n4jejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRnoeYZBcOBcS5pu8xAuBm2/iZVhDAfBgNVHSMEGDAWgBSs5yGzcfIvtp4rDfCA\nw1wdWJ5LKjAKBggqhkjOPQQDAgNHADBEAiB4NMQNzSX7PbLUCP37f2pInoWIX/UU\nIOpDb8Otbu5VywIgdhbdLHv3ItDGfNaCcqoyF3Z594XWcAIMftveWfOCOWE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXO/C9bRNE01vYr0z3gIoXXhMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDBh\nYTY0MTcyLWM1YmYtNDBmYy1hYmNiLTAwMGZmMTYzYjRhYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDBiM2M0YjY5LTRlNzctNDhiOS1iZmY0LWE3MjVk\nZTA5Mzk5ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMM5YYy/zDJDnbN4uHz8\nW+I/M8Wh4iSwG7zECv3yMgnOs5JSr59G4Tn5uSmOiiacW8wlvRop3cKokZIh+Em+\noTGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSs5yGzcfIvtp4rDfCAw1wdWJ5LKjAfBgNVHSMEGDAWgBRnoeYZBcOBcS5pu8xA\nuBm2/iZVhDAKBggqhkjOPQQDAgNJADBGAiEAm9kHmpTxa5PFWmM8c7/1Pf1Cx/47\nIZxcy/+7NBkmJvcCIQCQsXlAuDN7SKVXVCAPNW6BFz5beA50KB2io8iv3p7JZw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAeMxl5hnxsyddsjsNOWVYO2yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFDMS0wKwYDVQQFEyQwYjNjNGI2OS00\nZTc3LTQ4YjktYmZmNC1hNzI1ZGUwOTM5OWUwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATDOWGMv8wyQ52zeLh8/FviPzPFoeIksBu8xAr98jIJzrOSUq+fRuE5+bkp\njoomnFvMJb0aKd3CqJGSIfhJvqExo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUrOchs3HyL7aeKw3wgMNcHVieSyowHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAIs0\nm5kzUMXraMXUCpiaB7VM/5HPmy/dGhbXrGfaDqW1AiAxDcoJ9vcRzyQzK7rsj70+\nPIpYmju/y1ShrzULnKbcLA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGjCCAcGgAwIBAgISAXfy/C3C5ZhrqteRR8rnC75NMAkGByqGSM49BAEwZjEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0\nX3Jvb3QxLTArBgNVBAUTJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUx\nZDhjYzAeFw0yNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoT\nDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDBhYTY0MTcyLWM1\nYmYtNDBmYy1hYmNiLTAwMGZmMTYzYjRhYjBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABBeqkqOX+oyBHWuJPgbs7GUu2kMuuibrV92zxq6OqwWg/Owgh34LhTKOAlJ4\nG8OG8xFfKrouCOvhGqUgBEFM4jejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBRnoeYZBcOBcS5pu8xAuBm2/iZVhDAfBgNVHSME\nGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAJBgcqhkjOPQQBA0gAMEUCIQDlPoP8\nzy5SJBMY/qIBHry45TtaXSMzwdwxoov8ArO/bAIgS0lrdFxrem61yTGRLfP7JFWq\nfR178gD/HdQXoqBAvos=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAeZ2K6GCd4rJ2krVOlmYX9ceMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGIx\nYTdiZDI3LTkzMGYtNGM1ZC05ZjZlLTlhN2Y2MzUwMzFjZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ4NzhhMTIyMS1kMjdmLTQxNmEtYTY2MC1lZmQy\nNzNkODk5ZGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQa3K8IlofuhmgZQgdC\n8QmJK4tTIoCTY9b8xc1wX4U3eYw5NeziWYEaSlTuLl+Hib09PX67FEcH3XoFQjs9\nc67Fo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBT6g9mc01LwJlJ3BY4CHfd5sZmi2jAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhAIP8h/soT4F58EvB\n43gr45LfXjqI+Tfnm1e3zNNJBIP0AiBCSqG9UIQnRBQmJiY5GJiVQ+dhwBsyYECi\n/IBEr8FqgA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc61", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `61` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAU/zbfzaDJHXyqn4USTVU0LLMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDM3\nNGNmMWZlLWE4MDEtNDI4NS05MTI0LTI5MDFjMmIyOWQyMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDcxYTZjOTgwLTQwODQtNDkxNi1hZDA2LThmZTA5\nYTVhYTY2YTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOFL83n3Tux1JnfrMVqQ\npOclsULXSOw2MaPuvnx41ScK61AM/cZI7lGJQfWro9qCtC/JT9ANm6ZFIqcEt38y\nrKqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQrpStyBbc237Xm1DD2DR/Ldi1f4jAfBgNVHSMEGDAWgBTrjdMS/ag5wZwfd86K\nmOuR3Zv/kjAKBggqhkjOPQQDAgNJADBGAiEA13IsoGh1QEyahmPZsePSyqv3jOzy\noL4fOctmOoQu1bwCIQCJvoFsAwvsc++VWrZamF1J736CRsvnH+OjDT+82j4dgg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZ6tJjXRgbRSbQZQLuHVROu+MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDM3\nNGNmMWZlLWE4MDEtNDI4NS05MTI0LTI5MDFjMmIyOWQyMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDg0ODI0YjA0LWVkMGItNDUyMy04YzhlLTk1YzYx\nYzUxNmI2YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGdkPhQKAecMXqihdHCx\niUFxp1ExQrS3SVNWF/Gz6SSgKPz5AEtMdMnrFSWQiVva5mp6eld5azjQBjNfCzhD\nEYSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQT/ERQz33jBQE4/euCNlob6GzRZTAfBgNVHSMEGDAWgBTrjdMS/ag5wZwfd86K\nmOuR3Zv/kjAKBggqhkjOPQQDAgNIADBFAiEAkkC5AOdez0WbgBf9IYVJHsfLl3cR\nNJkcdu6esxtliJ4CICbngmAdyDmM38cS1GutgVe5cBGnW4OFNIUZ9DEYvu2v\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbgzbleI71YtOP9ZC1geTOIBMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDg0\nODI0YjA0LWVkMGItNDUyMy04YzhlLTk1YzYxYzUxNmI2YjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDM3NGNmMWZlLWE4MDEtNDI4NS05MTI0LTI5MDFj\nMmIyOWQyMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCn2Po5RPH/t5Pi4n6+t\nWWfIjQf46SCDzvby87FSgCqzbG8TayJ0mugB6N+LpmDXYyOlwseaVliKvmSjZqQh\nK16jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTrjdMS/ag5wZwfd86KmOuR3Zv/kjAfBgNVHSMEGDAWgBQT/ERQz33jBQE4/euC\nNlob6GzRZTAKBggqhkjOPQQDAgNIADBFAiBbDE341TEvAtuO5w+mECVGiGWNYcag\nfBv6Yf7RmthT4gIhALxiPiGgH9Ha4arI2tPcvb/UPG4aZd0rGdE14THt1TU2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAREoDD5+Crtmi0J8PF4Hbfl7MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDcx\nYTZjOTgwLTQwODQtNDkxNi1hZDA2LThmZTA5YTVhYTY2YTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDQ5NzgxZThkLTViZjItNDE5Ni04ZGRmLWFkNmY2\nZGM3Zjg0NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKMjjl+1LKxJ8aQjpt+4\nJ8oW341rLRqw5MSHuv3emFeWlAKpRWgN9gc5uMRGdX3AQTk+El/z2zWjAK0KQewa\nESujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQoUPiaJ09Jw4cyf+O3m3pKmIJlMjAfBgNVHSMEGDAWgBQrpStyBbc237Xm1DD2\nDR/Ldi1f4jAKBggqhkjOPQQDAgNIADBFAiEA2M6YNQs3g3T14UK1PiXsakJMPhxo\nwxpn4s79SY9aTbgCIEk+WKwHICt/Lhqx4bLPlcJXpxxSbKkrxNNhb7RFV7zv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaDI/i+v2Nr73GJLIrGXG3FyMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDQ5\nNzgxZThkLTViZjItNDE5Ni04ZGRmLWFkNmY2ZGM3Zjg0NjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDcxYTZjOTgwLTQwODQtNDkxNi1hZDA2LThmZTA5\nYTVhYTY2YTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOFL83n3Tux1JnfrMVqQ\npOclsULXSOw2MaPuvnx41ScK61AM/cZI7lGJQfWro9qCtC/JT9ANm6ZFIqcEt38y\nrKqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQrpStyBbc237Xm1DD2DR/Ldi1f4jAfBgNVHSMEGDAWgBQoUPiaJ09Jw4cyf+O3\nm3pKmIJlMjAKBggqhkjOPQQDAgNIADBFAiAEmogEQMhirpjQvEiWDSavXpW6v65i\nN9VVhfxG8ngwOwIhAMuYomiiXnSyQ0qQJ1OcQjjKjSA5OXYZTeuMuNXgC3GX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeEnlQLKmRw3b5h7ah0sxdV8MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDg0\nODI0YjA0LWVkMGItNDUyMy04YzhlLTk1YzYxYzUxNmI2YjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDQ5NzgxZThkLTViZjItNDE5Ni04ZGRmLWFkNmY2\nZGM3Zjg0NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKMjjl+1LKxJ8aQjpt+4\nJ8oW341rLRqw5MSHuv3emFeWlAKpRWgN9gc5uMRGdX3AQTk+El/z2zWjAK0KQewa\nESujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQoUPiaJ09Jw4cyf+O3m3pKmIJlMjAfBgNVHSMEGDAWgBQT/ERQz33jBQE4/euC\nNlob6GzRZTAKBggqhkjOPQQDAgNIADBFAiBjJDe+64ZeZiG4ROJe0gTaBJpb61rS\nRpHAnQHmPHf5ZAIhAO2aqfPtF3lVwrYHypXCB3XZjoXzsnDaLps0IL2dMVZI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAZKNl6WWisahstXs4MYo9oDmMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDk1ZTA3NWEwLWIxNzYtNDI2Ni04MDg2LWJmYjk5ZmEwZTViZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDM3NGNmMWZlLWE4MDEtNDI4NS05MTI0LTI5\nMDFjMmIyOWQyMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCn2Po5RPH/t5Pi4\nn6+tWWfIjQf46SCDzvby87FSgCqzbG8TayJ0mugB6N+LpmDXYyOlwseaVliKvmSj\nZqQhK16jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTrjdMS/ag5wZwfd86KmOuR3Zv/kjAfBgNVHSMEGDAWgBQjdRLJdtrkpVXQ\nuEF2jI/B0o7sKzAKBggqhkjOPQQDAgNHADBEAiBiHbLURGCsum7JhXL3e6phHyW4\nZ8XcSpDj++8ch1Ti8AIgVliypFFBIQunaXR7+9AJkkrKmY1A6x/tglPpgpFHK+o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAal5GylRbj93a2tSUkCwHNDCMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDk1ZTA3NWEwLWIxNzYtNDI2Ni04MDg2LWJmYjk5ZmEwZTViZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDg0ODI0YjA0LWVkMGItNDUyMy04YzhlLTk1\nYzYxYzUxNmI2YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGdkPhQKAecMXqih\ndHCxiUFxp1ExQrS3SVNWF/Gz6SSgKPz5AEtMdMnrFSWQiVva5mp6eld5azjQBjNf\nCzhDEYSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQT/ERQz33jBQE4/euCNlob6GzRZTAfBgNVHSMEGDAWgBQjdRLJdtrkpVXQ\nuEF2jI/B0o7sKzAKBggqhkjOPQQDAgNJADBGAiEAwxKF7MBcajTNlHpF0lqAtPTe\nDlzcYJnDOZPVt38Fz3YCIQCrhYeWk7E/sffONXRzC14GBpzIvRotvSsLRqPI63nn\nPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYGl3iJc4Cyomx3AVKYyT9DOMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDEz\nYTdhZGVkLTYwZDUtNGZlMi1iN2E0LWY0MDAxNDA1YjNlNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJGNiODY0NzY1LTZjYTQtNDZjOC05ZDFhLTdiMDZl\nNmE2NGJiMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLGZwAalqE3RFINbRYQc\nGWmqcR95nwxs804EiU9vf7BfFoLRTiHOxcK48Mnr6Pjx1hUW2Z5faQaxbJVljKSy\nEHCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQgh5Tun0r1oloqmzl6VGT2LZeNBzAfBgNVHSMEGDAWgBRT2IM5xF13nNZi7bIP\nI6ulj1aD6DAKBggqhkjOPQQDAgNIADBFAiEAhqfW5k9JAkOmBypk9nW5hR1A3XwP\nCb/IFVsIsgID4IMCIHw+jCuvu9zy7UlBG63yz7ERIBVRhVTwjB40qLI80Gbi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAbCgAwIBAgISAcxGA76DjwHKuj1HC0pznYXjMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDZl\nM2Q1ZDQxLThmNmUtNGMyMy1hMDA2LWE0ZDI5MjRkNzFiMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRmMDEzYmRlNi1kYjZkLTRhNTQtYTA3MS1mZjY4\nOGI2YWYxOTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATTKhTCwNFBnAJlm6qQ\nCxMvf0Vjjr8NKV0CbTl2M0cwn5KIVkmle3ZJzmE7egI+247pwIQ1xePref7tnJi4\nHMdvo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E\nFgQU3R6t/NhxwhTjZfv/w0jToTZ6lvYwHwYDVR0jBBgwFoAUW6yAPT6uBP0n9L5e\nUqrucSqzls0wCgYIKoZIzj0EAwIDSAAwRQIgOFPjSSVvRegZ8EK9G72EPWR8gETZ\nXBL/HRJpp5Iu2JMCIQDEh0jlRqQHhzRBiqItQjoA/CdUyxKNzQHT6A1/K2HqIg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATw7/pwH9kk4XyfTRR/DYVNPMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDJl\nODllODcyLWZhOTMtNGY2Yy04NWJkLTQ3M2IwMDZmZTU4ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDZlM2Q1ZDQxLThmNmUtNGMyMy1hMDA2LWE0ZDI5\nMjRkNzFiMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAILqOUATpgth4PO6pgh\nFc96veGXOgwjN5QV2LWNXgoBERkPhdPHPk/pId1kv+s6lOAoAfgPjl90mDJ5FV/Y\nWB6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRbrIA9Pq4E/Sf0vl5Squ5xKrOWzTAfBgNVHSMEGDAWgBQ2wpnjPEO5xAr11cMv\n3XZHwB+q3jAKBggqhkjOPQQDAgNIADBFAiEAvHmylQz0migBPghzQK/TGeFmDI+7\n0fh/zAdtwqt5c9QCIA17phmvTHRemzvmF8XA+2U5x1r7FJkLy8JivSfu3k5J\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARJb1uqiAY0h4n4rMQzlCm6eMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDJl\nODllODcyLWZhOTMtNGY2Yy04NWJkLTQ3M2IwMDZmZTU4ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJGQ1YzRhNjFhLWM3MWItNGRjNC1hMmY3LTVlZmNh\nNDE1NWRhYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLx0kpSRTuXwoq4D3am5\n7OCbIMrCYjMZryS5fdpcaYv9/0hsTabCH9XCcIyMa6BXWn4IiE/RNmjUYCCNb0wL\nTl2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTsnmvNQRt0bB3xPGYFLBB+L+L38DAfBgNVHSMEGDAWgBQ2wpnjPEO5xAr11cMv\n3XZHwB+q3jAKBggqhkjOPQQDAgNIADBFAiEAzsMqxwTn/mqAcI4dylYJP0T7qyJu\nueb9FrmnFemNKVACICjPAYzoySoR32GEismXhGYVHqfNEuXO+t6zcWl5902L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISASnWawugQsTnkzdTVQw85MoGMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDBhNzFkYzU0LWY2N2ItNDFhNS05YmIzLTMwNDYwYTA0NzMyNDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDEzYTdhZGVkLTYwZDUtNGZlMi1iN2E0LWY0\nMDAxNDA1YjNlNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDLH40vihIJtJqvb\nVFx7Af8a3+XjjUAg534ZhmejFv1xAEKJhqCLfegxC6Vnc6qX7P5HWky92f6UqBIc\nAMSlwjGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRT2IM5xF13nNZi7bIPI6ulj1aD6DAfBgNVHSMEGDAWgBRU3Lh6GcWdgqFA\nCgfBhmSOFWj4mzAKBggqhkjOPQQDAgNIADBFAiAFkUXO4CzHmt+QsEqkuFdSGsze\nAe3WkF8nzY5lXuKw/QIhAPS3/O4htUVXPl9N7SOtVq1Wjy35ZqL8CEMVZTnr6ZqV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAXdOpKUi6tInwfoYVNjEtFytMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDBhNzFkYzU0LWY2N2ItNDFhNS05YmIzLTMwNDYwYTA0NzMyNDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDJlODllODcyLWZhOTMtNGY2Yy04NWJkLTQ3\nM2IwMDZmZTU4ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBP7Jj/xA/G3dD6L\nm2grJKef9B20uIdmOjR1KQjGk8Qm5vmjiP6f+E/CDb/AbI9OGwyI6Pw13qMc1LS+\nc27th2ajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQ2wpnjPEO5xAr11cMv3XZHwB+q3jAfBgNVHSMEGDAWgBRU3Lh6GcWdgqFA\nCgfBhmSOFWj4mzAKBggqhkjOPQQDAgNHADBEAiAr2Hr9uw4KBppsmsXmSle4BjEs\n/5LqVvsym2B70EhorAIgTBM0GHcaDKe+qjZn01RefdWZ+Ppdl03YUiXnPmxQ9F8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfbJGQykuqEVyYj+KKZg9GTiMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGQ0\nZDNmNzQ1LTdjOGMtNGVhOS05MDI4LTgyNDIxNjhhYjczMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGQ1N2Q1Zjg0LWNlMTYtNGJlZC1iYWM2LTQ5YzRm\nNjg1MWNhYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOc/KiSTez9Wt9sxQI+A\n2qe+YrwJXqle9c7S9YuvdeCQNuS6pOZ9piPwxTuLuN0HuFVvRQyY6BqYkUg+m5mT\nIsajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQgnKBudHE/POaQSuch4fISm6Z4WzAfBgNVHSMEGDAWgBT7DmEeMdV8dRfjKm4m\nOnJojAlPrzAKBggqhkjOPQQDAgNIADBFAiEA17hKBUpc8KIz4mRUcH9jluu8Q6I8\nAHlgBhMm4JWrQWUCIF5hRTqAAIgzlMXrg6Whr7gWIK2oadvCiC6VBKRceexJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQBF1Lj4brATxZAAVlyBD9ahMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGNl\nODgzZjhmLTEyZWMtNGYxYy05MDZkLWI5YjFkYjRhOTk4OTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGQ0ZDNmNzQ1LTdjOGMtNGVhOS05MDI4LTgyNDIx\nNjhhYjczMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE3F1jSh/SKsYOW/Vkyt\narMa/0n8eH6vK4bu+tGkGAJQjJY1m6LpfJwvjk3Sg2Ap+LvIdh31/Z0iGNgK5FPN\nlNWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT7DmEeMdV8dRfjKm4mOnJojAlPrzAfBgNVHSMEGDAWgBS7g3QZP+uJSfwylRjZ\nYH9C8Z0JBTAKBggqhkjOPQQDAgNJADBGAiEA77M2cows80NTMPvYqJxUq8EZ6aay\nU6ND0+xh5EaKubUCIQDy4A68Fdo8T+f0n4FL5GL92vK4fYloTMcY3L3Kqofuig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeBlHLT409yK3bFIXazNR7vYMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDJk\nYmZhZGYxLTRlMTYtNGUxOC04OWFiLTkyMmEyNTQ2NWJkODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGQ0ZDNmNzQ1LTdjOGMtNGVhOS05MDI4LTgyNDIx\nNjhhYjczMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE3F1jSh/SKsYOW/Vkyt\narMa/0n8eH6vK4bu+tGkGAJQjJY1m6LpfJwvjk3Sg2Ap+LvIdh31/Z0iGNgK5FPN\nlNWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT7DmEeMdV8dRfjKm4mOnJojAlPrzAfBgNVHSMEGDAWgBSJdyIsXnu35M5tZH48\n9zSEQ2rTSTAKBggqhkjOPQQDAgNJADBGAiEA6PYgvQkkDZE69Rjv2Vqmm64EARmV\noKqpk26BKoeQjq0CIQDRMfF7R0tUN79hOm8FDwc3L7crkT2dA067CSgmt/XjhA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVrMAdr65brXfMQ9hvuBfZLqMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGNl\nODgzZjhmLTEyZWMtNGYxYy05MDZkLWI5YjFkYjRhOTk4OTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDJkYmZhZGYxLTRlMTYtNGUxOC04OWFiLTkyMmEy\nNTQ2NWJkODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGuIMmLf/9aIDH/ioxo8\npBnQ3SCNgjxX1eSbP2jTGKgV6k+UMXcJk+h1Wh5c8eu6CHdYYrYgApuo3Ba7py8I\nYYqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSJdyIsXnu35M5tZH489zSEQ2rTSTAfBgNVHSMEGDAWgBS7g3QZP+uJSfwylRjZ\nYH9C8Z0JBTAKBggqhkjOPQQDAgNJADBGAiEA/NQR0WH5xIZQArR+ogaU9dm9Da4s\nUe4o+QRf6RZn9OMCIQCqfuuBY9fIJ1So61Zz/A+Kzq3LobUDcO5NoTvy04IhWw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISActYYmXpWHj0pxqel5GF0607MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDJk\nYmZhZGYxLTRlMTYtNGUxOC04OWFiLTkyMmEyNTQ2NWJkODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGNlODgzZjhmLTEyZWMtNGYxYy05MDZkLWI5YjFk\nYjRhOTk4OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJT1vUYcjU878OTagqkB\nGgRE/7Ru8EqssEJz9wMqKqEh6N4bctYOSasDXaWIKwpkOj4/Rk+3f4WgaQGBURqI\nom6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS7g3QZP+uJSfwylRjZYH9C8Z0JBTAfBgNVHSMEGDAWgBSJdyIsXnu35M5tZH48\n9zSEQ2rTSTAKBggqhkjOPQQDAgNJADBGAiEA5REq29qcqKfx8Ug0Jsp0qIOXx2SZ\nEzT2fv60kNp5KUoCIQDwNeSSQ5+5PdllTvIUQIG7rbr6/dkfpLnnsr7Maum6Kw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAeEbAKlq7cnGayZU6sOlHRD7MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDZkYjVkZjljLTZlMjYtNDljMS05N2I2LTE5Y2I1OGVlZWZhOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJGNlODgzZjhmLTEyZWMtNGYxYy05MDZkLWI5\nYjFkYjRhOTk4OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJT1vUYcjU878OTa\ngqkBGgRE/7Ru8EqssEJz9wMqKqEh6N4bctYOSasDXaWIKwpkOj4/Rk+3f4WgaQGB\nURqIom6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS7g3QZP+uJSfwylRjZYH9C8Z0JBTAfBgNVHSMEGDAWgBSA8FZtk6tgZAaY\nfQQjieagrJXCSTAKBggqhkjOPQQDAgNIADBFAiAMzowYiFY/iS+G1IVLkEi7gyz0\nPqTBPhegz7qT3NW2QwIhAO1g0y6nIXuaceTME9EdyyQYTA00MvPhdNedInYUNvKI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAWwjj6ov2ab3+8CMinAbcEZ3MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDZkYjVkZjljLTZlMjYtNDljMS05N2I2LTE5Y2I1OGVlZWZhOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDJkYmZhZGYxLTRlMTYtNGUxOC04OWFiLTky\nMmEyNTQ2NWJkODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGuIMmLf/9aIDH/i\noxo8pBnQ3SCNgjxX1eSbP2jTGKgV6k+UMXcJk+h1Wh5c8eu6CHdYYrYgApuo3Ba7\npy8IYYqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSJdyIsXnu35M5tZH489zSEQ2rTSTAfBgNVHSMEGDAWgBSA8FZtk6tgZAaY\nfQQjieagrJXCSTAKBggqhkjOPQQDAgNHADBEAiAK8WUjPpHUi3SHZT+cp3V8yfld\nNeyR+WKI6+j4B6jzXwIgGkvCBw10uOEdq7ae47BC4XXM4F/8bc+1eEnKBZDhFjQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAeSASVI75y/NFoKxsi3klcBAMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJDQ2\nMTg1ZGI2LTA5NjUtNGJkZS05MmFhLTcxODViNjY0NDdhYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGI5NGM4ZDA3LWQxMGYtNGY0OS04Y2NlLTI3YjVi\nODM5OTcwMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCMmUnKE1ln6PqMzQUIx\nVWTg561bvlXgKbWOnOO9pXIyK8g2X5/4TEVFIspd99avima/X9V4nhgfpHq8ZlF8\nTnGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSPVLNqdpTF72qS29cYG9X8DI5oNDAfBgNVHSMEGDAWgBRXhcTvBd2t9FiSluc9\nYTg4jVx8UTAKBggqhkjOPQQDAgNHADBEAiAfYqeCY/tlE6Zy5IwzbYbIaBu7fPUQ\ngJLj0sfc6md5MAIge9WbzsgHvqtB0K5c5i+xaw9zRudNzT1QBfeO2hYVVrE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfgwH/OPwrVMIwA4/wQEguhEMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDg3\nZTQ3ZmM4LWI4NDgtNDQ2Yi1iNjM0LTlmN2U5MzQ1YjQ3YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJDQ2MTg1ZGI2LTA5NjUtNGJkZS05MmFhLTcxODVi\nNjY0NDdhYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIGk3KwOHLwMAzctNpC+\nPINgxbFmmTlDB2Wi8UJxG31YYDZvFcOsiRV+z43doJeyfVy06s96YEoamiUDI5rI\n3uajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRXhcTvBd2t9FiSluc9YTg4jVx8UTAfBgNVHSMEGDAWgBR8Rh0X3BFviMWlStLV\nokOn/iNV+jAKBggqhkjOPQQDAgNIADBFAiALsaJDFEFho+3kAabj9XE+FSAOukyH\nJOR1fElZfB3jAwIhAMuaveUIoRF36JaLUzYDz5tdXpvRDUv1B/ZMnWenLksw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATBGNgVDxnPonqsarmEcW69AMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDg3\nZTQ3ZmM4LWI4NDgtNDQ2Yi1iNjM0LTlmN2U5MzQ1YjQ3YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDRlNmViMDRiLWMwMTEtNDZkMC04ZGU3LWI4NDE0\nOGQ1YTc0YTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAFFIKBmm/eArPYQsyza\nVoDI7KPKeniUF3H6wycieBh8NlMP5cNU8H4TI0Z4fJm+fDNpu6DJuvfLyowayZLR\nkESjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRjowAMCFW0WlWYUtSPP9YQJQjLwjAfBgNVHSMEGDAWgBR8Rh0X3BFviMWlStLV\nokOn/iNV+jAKBggqhkjOPQQDAgNIADBFAiEA+ANesyjiv3rVMw0gDo6Vm9z0/CKW\nFIPSPAE1U1y9C+8CIGiE0dPx9VF+DFjKXKL8QwvFvSu4RXbubhcAsuNDjeTX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQPht0bXr18Nka8tW/qa/WfHMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJDE5\nYTcxYjEzLWRmOTQtNDNiZS05MDQzLTExMDQyNmM1MDdkMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGI5NGM4ZDA3LWQxMGYtNGY0OS04Y2NlLTI3YjVi\nODM5OTcwMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCMmUnKE1ln6PqMzQUIx\nVWTg561bvlXgKbWOnOO9pXIyK8g2X5/4TEVFIspd99avima/X9V4nhgfpHq8ZlF8\nTnGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSPVLNqdpTF72qS29cYG9X8DI5oNDAfBgNVHSMEGDAWgBQbBETUAEZeTeoPK1i2\nS+PfkW3HyzAKBggqhkjOPQQDAgNJADBGAiEAr2k3iE6elT4d8thL6xtzAJ2VmkP8\n6BU4+2kP56Yv0/4CIQCI5Ouxxh+w6dDx6iekdPAqAPA5oixD1hPMd7Pwh7WU5Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAWfIo6kM2W/KfnyNSxfgUXsPMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQ4N2U0N2ZjOC1i\nODQ4LTQ0NmItYjYzNC05ZjdlOTM0NWI0N2MwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARaLx3V0NSg6JURkt9ceCGk5oJjekz7F8UchlHfBnpm+lEe3EKusAzdOpAl\nCrUqoGTTBLNrD5Nwdns+xSD7pWrCo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEYdF9wRb4jFpUrS1aJDp/4jVfowHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhANfT\nVJeihz9E40n/K6eWeDcvF6W1thLKopWf5ZZ84dQ+AiAXmaSdgKP/+5qVoh/MNMYm\nIVrMTYUQSRkjXeZlr1n5fA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAaOmYaD6lI5Lyn40wxLlb1CpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyQxOWE3MWIxMy1k\nZjk0LTQzYmUtOTA0My0xMTA0MjZjNTA3ZDEwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATEjQ3BHjheWCh6xI0m+Yox4WfQgbJXoldrfOq4nk09BbCHkUtfT80mVkhL\nQh9yJHEilWEfwagwZuEPjxjpjjrlo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGwRE1ABGXk3qDytYtkvj35Ftx8swHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAMQt\n817KXKN0PlM2U/7158wUdxJSJhlmx3V19GEMKQ6wAiBwYGvF/A5D09N5r77zaG1s\nN0U5j1h4o6G5YZEptiyB8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISARZwQ7Q+7qeBsYqGS3TgIdWCMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDk1ZTA3NWEwLWIxNzYtNDI2Ni04MDg2LWJmYjk5ZmEwZTViZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMzQyNjk2MjMtNjk5Ny00NjVl\nLTk2MTgtZWNiZjllZmMyMzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGphb\nHFggLYDo+EaxQPjtLtoMepPp3KmkoQw60mi3uPkyyR+y/4OJWfpxhILfwp2lLvXf\nRzMFVG0QrygaiooxuqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFNWnYc6csrunBGB5rYCwFL5Zw8viMB8GA1UdIwQYMBaAFCN1\nEsl22uSlVdC4QXaMj8HSjuwrMAoGCCqGSM49BAMCA0cAMEQCIB5yA6pT+X8xi1ru\niUHzNhzMq9eLOiJX+ZHQ0G66doy6AiA0qaAXXrSq1gjYXptYBJUnDSLEs9xvnS0U\nxkqWZg3vkQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAW6ejB1UZd5/40ZJLqk2aERrMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzQyNjk2MjMtNjk5Ny00NjVlLTk2MTgtZWNiZjllZmMyMzM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkOTVlMDc1YTAtYjE3Ni00MjY2\nLTgwODYtYmZiOTlmYTBlNWJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHqdQ\ndue8rRpe1GcL3s71YNC7eW2LAle68EJlluIbeEcDG8tcOGBqEp5U8o5KH5rlkJSb\nNEW1IeCjyuNyHwTLoaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFCN1Esl22uSlVdC4QXaMj8HSjuwrMB8GA1UdIwQYMBaAFNWn\nYc6csrunBGB5rYCwFL5Zw8viMAoGCCqGSM49BAMCA0kAMEYCIQCPgX6JpbJ7GqL3\n9yAfpcXbXCyGP80fuFLrs4/166KHJQIhAI/tiLNWXYSIyc8Ndu3vmLAWQ7bJk3Tv\nSG6h6L5jqii7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAb1G6dZ7HOlT0Xb8nJyvUxv1MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDBhNzFkYzU0LWY2N2ItNDFhNS05YmIzLTMwNDYwYTA0NzMyNDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMzQyNjk2MjMtNjk5Ny00NjVl\nLTk2MTgtZWNiZjllZmMyMzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGphb\nHFggLYDo+EaxQPjtLtoMepPp3KmkoQw60mi3uPkyyR+y/4OJWfpxhILfwp2lLvXf\nRzMFVG0QrygaiooxuqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFNWnYc6csrunBGB5rYCwFL5Zw8viMB8GA1UdIwQYMBaAFFTc\nuHoZxZ2CoUAKB8GGZI4VaPibMAoGCCqGSM49BAMCA0gAMEUCID8PbY+VIhkbaiqe\nHyRG8my2MqYLoviemmm8/9t43TwuAiEAldPWmYVwdzwWjX9YUw84GWFwpFPhmt5c\nJJGAWEiWDEY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAdSOwF/22B4nEAocnHRBBzDoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzQyNjk2MjMtNjk5Ny00NjVlLTk2MTgtZWNiZjllZmMyMzM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkMGE3MWRjNTQtZjY3Yi00MWE1\nLTliYjMtMzA0NjBhMDQ3MzI0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDI+g\nC86MAjnXDUhPYYPV60MLHlZgCfwfGBB5tDIQ226LxJYCb1sPAhq9sv5QTbdTx+BB\nwrb94nKLLZ/lCsCYUqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFFTcuHoZxZ2CoUAKB8GGZI4VaPibMB8GA1UdIwQYMBaAFNWn\nYc6csrunBGB5rYCwFL5Zw8viMAoGCCqGSM49BAMCA0kAMEYCIQDvx/DxUypFzB+k\n0NB1enrUDGDlBj0+TFwzhfHwIkf4FwIhAP+2Au7vDlbLiMfDE+BnZ8hMQp6jsTp4\nvc1KldD1s874\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISATbepVD9+1OKHPy03kpQJKqzMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDZkYjVkZjljLTZlMjYtNDljMS05N2I2LTE5Y2I1OGVlZWZhOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMzQyNjk2MjMtNjk5Ny00NjVl\nLTk2MTgtZWNiZjllZmMyMzM0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGphb\nHFggLYDo+EaxQPjtLtoMepPp3KmkoQw60mi3uPkyyR+y/4OJWfpxhILfwp2lLvXf\nRzMFVG0QrygaiooxuqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFNWnYc6csrunBGB5rYCwFL5Zw8viMB8GA1UdIwQYMBaAFIDw\nVm2Tq2BkBph9BCOJ5qCslcJJMAoGCCqGSM49BAMCA0kAMEYCIQC3kJGgnUoP0jN1\nf6gSucjpTTzpp3+zXPNePn/MI2VMeAIhAIV2ePTRFBEd2i6IOChKagnryk/j4YlL\nFjwzG4bojTbm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASveOEiXbSDb6nWacyQjKts6MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzQyNjk2MjMtNjk5Ny00NjVlLTk2MTgtZWNiZjllZmMyMzM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkNmRiNWRmOWMtNmUyNi00OWMx\nLTk3YjYtMTljYjU4ZWVlZmE5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAER0Da\nBuP8usAHL0mIclAuxyQFXxSgtvhLLzZJp5VxNW+rTR0d6DMfYANSavnxKSE1gUqq\n8zv50LPA+TukhQQszKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFIDwVm2Tq2BkBph9BCOJ5qCslcJJMB8GA1UdIwQYMBaAFNWn\nYc6csrunBGB5rYCwFL5Zw8viMAoGCCqGSM49BAMCA0gAMEUCIHCyQT5byrM+IFNg\nAb7uqCpDh9VbLXcZQMGUMqOFQABEAiEAwpBU0gkySO1pfs2/ZefaadfhtohfZhe5\nM5C2K1tRx8s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAd7v45FXTnjpFDGA3/OV7zpqMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDM0\nMjY5NjIzLTY5OTctNDY1ZS05NjE4LWVjYmY5ZWZjMjMzNDBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABBqYWxxYIC2A6PhGsUD47S7aDHqT6dyppKEMOtJot7j5Mskf\nsv+DiVn6cYSC38KdpS7130czBVRtEK8oGoqKMbqjYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTVp2HOnLK7pwRgea2AsBS+WcPL\n4jAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNI\nADBFAiEAjaDnCpC3wN1EsSSK/gjVQw5IJZRxvqjB+HlNIlDpQHkCICQ0PU2SuYgs\n/OFhHGgAHpFFbifob/c4OIGlKlwPpTFq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAeTEhtBiPV2xmdq5MO4MJVz0MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzQyNjk2MjMtNjk5Ny00NjVlLTk2MTgtZWNiZjllZmMyMzM0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBTVp2HOnLK7pwRgea2AsBS+WcPL4jAKBggqhkjOPQQDAgNI\nADBFAiB6N9KBNjiI4Li7D+yE/pF7r6ZAS5vIn90Sy3esTGANRwIhAN2+LygLGjxO\nEq5G+fsm0ynZvrLaOjC2jooHF0cKHOOl\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICETCCAbigAwIBAgISAQv871IKVvmM2NZL0O8RWerWMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGQ0\nZDNmNzQ1LTdjOGMtNGVhOS05MDI4LTgyNDIxNjhhYjczMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDdiY2I4MzZkLWMxZTAtNDIzZS1hNzJjLThiNTc2\nZDhmNTNlMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNLXwV7pAL5H2zuBiltr\nuBbdBsuJzkdg5TXc9Vn8dUO5zLqvdgvegIJmDw7rQ8m6/FLxw/bkQ3ySjRzbyxZG\nmvijbDBqMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAMBgNV\nHRMBAf8EAjAAMB8GA1UdIwQYMBaAFPsOYR4x1Xx1F+MqbiY6cmiMCU+vMBQGA1Ud\nEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQDAgNHADBEAiAEX9i6OaiXZG62aWpc\ntCQNM4fjhCsVV3MGSgnJ/8WsVAIgfJ4DyPbOKbUUF5GnSxzXk0U+Q2L/l5UEkc6Y\nGOpVwIs=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc62", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `62` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZAhO/DBCS46pIzjigLP+ntMMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJGM2\nY2Q4YmI0LTcwMTMtNDIwMS04OTkwLTQ1ZjZiZDFiMzcwZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDBkOTQ1YmFiLWExM2MtNDA0YS04OTAzLWMxM2Iy\nZDcxMjUzYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABC1xgOpLBAMZyy5ssgZr\nH40t1jNyvbkWkk0BDnL3ie/hQFen0RsZ6sBAW0qD6rrk5EhDVbbu6ssi7ClbZQKM\n6RmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS2XEP3Xojb07hgiL1FUMCZUfj4lDAfBgNVHSMEGDAWgBQoehhMt9TdLzIAV7pe\nMNgAzFGTsTAKBggqhkjOPQQDAgNIADBFAiEAqL46PZOpGzxAjHu+dqUek53cy2nM\nmLSbO2C8CUzzHXECIDCRR/XbZ4omcrlWNzPStcfn7TfplBnfxUgfi0LDwIwY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATMzvZcZe8tz8lM71UdMA+zmMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJGM2\nY2Q4YmI0LTcwMTMtNDIwMS04OTkwLTQ1ZjZiZDFiMzcwZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDMwY2QxNGY5LTgxM2MtNDg3YS05ZThhLTNkMDJi\nZDJjNDZhZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBsVfytzHuDI0ihGEaPy\nLt0AGebreEHcJFbYJlvQjepeYgoq81DDL0WSkGhNfIB5Ya1JsHTuVaV2DqJpNArk\n1s+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ45aqGQopE6eGu8POuvcdvWS8s5zAfBgNVHSMEGDAWgBQoehhMt9TdLzIAV7pe\nMNgAzFGTsTAKBggqhkjOPQQDAgNIADBFAiATAn/MkSjQDXfJo4k3/yDswjKSZpCo\nDF/n2E9z7/XnzgIhAMz/qrlDK49Wf2N879BUT7d7ASgrHXACGK3BOOx+sbnS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXG22qWVg/LD/LftBzG5mc/TMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDMw\nY2QxNGY5LTgxM2MtNDg3YS05ZThhLTNkMDJiZDJjNDZhZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJGM2Y2Q4YmI0LTcwMTMtNDIwMS04OTkwLTQ1ZjZi\nZDFiMzcwZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEDVQfiSzHihRX+do3jR\nsqwwOP17qpFXcu6b3Rt1y3bBtgF4MIqhJ0JA9//lJ4gRMrIo4j8Hdc/Av7eFUNgQ\nxrejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQoehhMt9TdLzIAV7peMNgAzFGTsTAfBgNVHSMEGDAWgBQ45aqGQopE6eGu8POu\nvcdvWS8s5zAKBggqhkjOPQQDAgNJADBGAiEA9UJFXZA4d6kzW3IQppLoUI2vlyUJ\nYIOoauG6i8gweH0CIQCrbZ9qzruJX/EV/0joTZiF6R8wyqcKZPDNOxfmcbQqdw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbaSQLet3ShF9VaEtHwtIYlnMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDBk\nOTQ1YmFiLWExM2MtNDA0YS04OTAzLWMxM2IyZDcxMjUzYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDI4ZjExZjkzLWJlMDktNGQwOC05ODllLWMzZTE1\nYjI4NWUzNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAqxoVcUQ9U3gX0dv4jb\nt4rpDL4uH/II73G7uKhX/foeJbvEISf4je+Hf9AGuMHtMXkJpvO/rPrsw9ihqXMm\nxeCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRvb5e3/g98LvANrSVyPQIUZEumUjAfBgNVHSMEGDAWgBS2XEP3Xojb07hgiL1F\nUMCZUfj4lDAKBggqhkjOPQQDAgNJADBGAiEAwYj+8lXU6T/RyTq7dqXXAhcXL1u2\n9p2OR+Etd4ZSTxICIQDSFY+rYMoEU707isot5Uas6BuhZ6S54iuOtHusvcqvEQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfb6WjcDoUyeYrtQ0+/tP5WyMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDI4\nZjExZjkzLWJlMDktNGQwOC05ODllLWMzZTE1YjI4NWUzNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDBkOTQ1YmFiLWExM2MtNDA0YS04OTAzLWMxM2Iy\nZDcxMjUzYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABC1xgOpLBAMZyy5ssgZr\nH40t1jNyvbkWkk0BDnL3ie/hQFen0RsZ6sBAW0qD6rrk5EhDVbbu6ssi7ClbZQKM\n6RmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS2XEP3Xojb07hgiL1FUMCZUfj4lDAfBgNVHSMEGDAWgBRvb5e3/g98LvANrSVy\nPQIUZEumUjAKBggqhkjOPQQDAgNJADBGAiEAu8vA7jF2F6tlxemP3qaV9F5UNt3f\noxBE73TIn/qvaJYCIQC7VfwWAtJODYtpPlug5jQZWNfwiIWlMdUocxCeCArOgg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASwwLkYwRy/nAuduXh7LUkfqMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDMw\nY2QxNGY5LTgxM2MtNDg3YS05ZThhLTNkMDJiZDJjNDZhZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDI4ZjExZjkzLWJlMDktNGQwOC05ODllLWMzZTE1\nYjI4NWUzNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAqxoVcUQ9U3gX0dv4jb\nt4rpDL4uH/II73G7uKhX/foeJbvEISf4je+Hf9AGuMHtMXkJpvO/rPrsw9ihqXMm\nxeCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRvb5e3/g98LvANrSVyPQIUZEumUjAfBgNVHSMEGDAWgBQ45aqGQopE6eGu8POu\nvcdvWS8s5zAKBggqhkjOPQQDAgNIADBFAiEA9eQ5VfyRShS+zezlpA3bDyh0okvU\nOf0MzokM2fMVJcYCIG0n35aH75Ag/EUGl/7+LtsYTGaUkaU5cIOcIUCD9Sxy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAR4xHzxFM65ubjDpYd6zSY4pMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGE1Yjc4ZGI5LWY3ZTMtNGFkMS05ZjliLTg4N2RlMzViOWUyNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJGM2Y2Q4YmI0LTcwMTMtNDIwMS04OTkwLTQ1\nZjZiZDFiMzcwZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEDVQfiSzHihRX+d\no3jRsqwwOP17qpFXcu6b3Rt1y3bBtgF4MIqhJ0JA9//lJ4gRMrIo4j8Hdc/Av7eF\nUNgQxrejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQoehhMt9TdLzIAV7peMNgAzFGTsTAfBgNVHSMEGDAWgBQxILhNNBUPksCN\nApsWenEyBi59AzAKBggqhkjOPQQDAgNHADBEAiAIcMyo307HonqDEayRL/njZJfa\nBjPnC7rXr5lE3FhsvQIgV+R6HL5hPLFfNXvbkupU5hkMVPSMXcGnNmGaW7wMruk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAXRy9/i3hvwTdIHPcPoJVbpJMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGE1Yjc4ZGI5LWY3ZTMtNGFkMS05ZjliLTg4N2RlMzViOWUyNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDMwY2QxNGY5LTgxM2MtNDg3YS05ZThhLTNk\nMDJiZDJjNDZhZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBsVfytzHuDI0ihG\nEaPyLt0AGebreEHcJFbYJlvQjepeYgoq81DDL0WSkGhNfIB5Ya1JsHTuVaV2DqJp\nNArk1s+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQ45aqGQopE6eGu8POuvcdvWS8s5zAfBgNVHSMEGDAWgBQxILhNNBUPksCN\nApsWenEyBi59AzAKBggqhkjOPQQDAgNIADBFAiEAia+AhpHg2fsTzj2cvm92ssSO\nloQHg4MQQJ8gE0p0wMQCICU37xNJDFg0YwKgWDeHDMYMre5xh0QOVukYDapnnM8J\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfryhWvI2gxfTM08M4FzpqGpMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJGY2\nMzFlNTZhLTE0MWYtNDRlMC04NzU1LWVhMzRkNDE5ZWMxNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDIwNDcwODE3LWRkZmQtNGIzOC1iOGMzLWIyMzFi\nNDk0NTY4MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGy+Lz6ugtC4HS+vYz3h\nydlPXmSUx3b1W5vejSzNq3e4bVJ9yaeTPdrX80PBnW6reoeAZt95kMWaZ5lH5+f9\nP8mjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTY4XRBmDK65V4Yt6stPSNxFUQP/zAfBgNVHSMEGDAWgBSuYJsA+Q1PsIZgrZpR\nc6gBKSPXjjAKBggqhkjOPQQDAgNJADBGAiEA2VtXHMC/+e10GfR1wUYEwEz3J/mO\njfg4EsspQVP0zuECIQCgEhn5I7l1eopjyyKLDNMPiMYopC/w6ER4Ivu6VQ6k6A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeGx1+6Ieq0nGafbo13X9e+/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDk5\nNzlhNjNjLThmYzktNGFhMC04NzU1LWUzZjM2ZDQ1MDk2OTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJGRiYzI2MTZkLTU4MjgtNDRmYi04ZWNlLWU0NzFl\nZGU0ZDJkNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM3nIwWIKk6IgYD4KYEy\nK4EK7BtGULJsCZz4embQ5XW3ScHZorti8s6RME49yM0BPah6Vvc/QZl9FfkjKEmA\nOSGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTw/XCgt1I023hyruoXbCIZ5nAWHzAfBgNVHSMEGDAWgBQg2yzxByRHJbV2zT1r\nQO4ktOp8YDAKBggqhkjOPQQDAgNIADBFAiBi72Toa0lEMl9ZwUJuTGpvHOHBjPL0\ndPEC+1VCST/jRQIhALda/1OL0vwyN5N8iJMu2C80hhpS9C41zMKNp/tArs+z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfS1a3sEWg2Js/YkftoghSthMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDk5\nNzlhNjNjLThmYzktNGFhMC04NzU1LWUzZjM2ZDQ1MDk2OTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJDk0MzQxOGI5LTI5Y2ItNDZkZi1iMTZhLTliYTdm\nYjQwYzM2NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNoHRYo29IQOwLHxvv+X\nMKKb9zZ+/nI2z661UNR2o8lCrKqQFK5Lb0CQjz/tsBMyR7OLGrK0z6er3B6E7YnI\nddajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQGm2RSFjz74psyP5SEuNrwH6de/TAfBgNVHSMEGDAWgBQg2yzxByRHJbV2zT1r\nQO4ktOp8YDAKBggqhkjOPQQDAgNHADBEAiATFlpcpemjAENyprikkI9PGYXNuSZU\n7Af6ypE12J1QUAIgPCVdwP97KusTmwuplKO9wLmw8WHAANpHR86H9F3ZASw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAZ0DmFWaaUnZWmr88YFodD+1MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDZiMmM4N2Y5LTNjYTctNDI5Ni05YzAzLWY2YTY2ZjIwNmZlNjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJGY2MzFlNTZhLTE0MWYtNDRlMC04NzU1LWVh\nMzRkNDE5ZWMxNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEnTPUF4OrXSzOP+\nmvI73Mx9M4WT3GQP/6NV3bVcGsMZtii16Yuo8L9n8z0AHpqxNgwKxAfYM9rPWsOz\neQgA1yGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSuYJsA+Q1PsIZgrZpRc6gBKSPXjjAfBgNVHSMEGDAWgBRSMIVOMFICfRlM\nsyjd8+Qjh3SOPzAKBggqhkjOPQQDAgNJADBGAiEAiGuI9VXL3ALmx3oK7eEa+FqB\nX5hkRq8CMYd6IiCBUJ4CIQDcSaoGms+Cavt5T7287h/tHMH9nsVYqNr5fuq02r7V\niw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAfaYpIpvOkYPrq7YJlh/9slSMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDZiMmM4N2Y5LTNjYTctNDI5Ni05YzAzLWY2YTY2ZjIwNmZlNjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDk5NzlhNjNjLThmYzktNGFhMC04NzU1LWUz\nZjM2ZDQ1MDk2OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOMg/jIje+l73lbl\nCOwBpgpaz1ZmEvHY5K0UquFYjcnxcOhYUHa1hDIVqfhm1L/n4TSKDLJAivw42MIu\nLZweAbCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQg2yzxByRHJbV2zT1rQO4ktOp8YDAfBgNVHSMEGDAWgBRSMIVOMFICfRlM\nsyjd8+Qjh3SOPzAKBggqhkjOPQQDAgNJADBGAiEA6+hT2Q/U+5iXe9CCdiV3jR8B\nhgTuE/x8HiKdxsifukoCIQCHeS9Uqrq1C3T0qC/V8HA2C+50ysbOKAoWJUM9ct6+\n4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAd6H6WUn2z20AxWVfMaWPsZuMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGYx\nODI0ZjFlLWY1YzItNDdiMy05YWU3LTM3ZTAxMzVjMzJiMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJDAyNmRhNzhkLTRiNmMtNDYzNS1hMjY5LTU4YzI0\nNWUwMzU0YzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPw8TYAgzNvbrfFyPizf\nJSxoIqKPtwrsHWZ39G9DJCYV0ISF1VsnPOAQ49Rdgv+lMWg9A/ngYFMazcNusxcG\nGJejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQO+NVAa8OBanM8mX09pVa+hedC+TAfBgNVHSMEGDAWgBRpXSUe8tzk4a9mmI6t\naAl1UmokhDAKBggqhkjOPQQDAgNJADBGAiEAtGN4IzbX7HUrLACrvEHIaBIgjcGU\n6CKXOhjoGS4NBlcCIQD+ERaoDArPqtCNjHV1k+v9D/8jg16jxGYJn3vhynAkOA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbddM6S3VEQUtuqGxKhzEfH8MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGYx\nODI0ZjFlLWY1YzItNDdiMy05YWU3LTM3ZTAxMzVjMzJiMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDJiYzMzOWYzLWFjYzYtNGU1NC05NjUzLThlOTk5\nYjkxMjViNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIcccM2Ggd7rWJGAm2EK\nJOYnChv2GvtsSdnqY/LAk8EECn+WI0CPd1mtGYK8fYYEkRH6inWWvTDlQz7STUod\n4bCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTqth1SC6216j42rKPfIzzJp5XFfDAfBgNVHSMEGDAWgBRpXSUe8tzk4a9mmI6t\naAl1UmokhDAKBggqhkjOPQQDAgNIADBFAiArA/5DI+9DFQPzyLK1uh0ZZDPSeCuo\n0ST+ydEamFCguQIhAMcknHT7XIq2/wH+iYzxbvRto3eecU74FFM6idkGCOuy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWsBk0XBrgFncLfD9/eM3CtqMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGRi\nZTZlMWUxLThiNjItNDM5Yy04NDUyLWQ5MjA3ZGQyMTZhMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGYxODI0ZjFlLWY1YzItNDdiMy05YWU3LTM3ZTAx\nMzVjMzJiMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCWQ1i4q4trqejmogmId\nVtcEYFIxCUzCct5zIO0gKfHX8HCRMEGCh/VxOYpGbdna0P0aX47lDGUgsgH8uCtZ\n+iujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRpXSUe8tzk4a9mmI6taAl1UmokhDAfBgNVHSMEGDAWgBTTdu2IC5HJL5f5q9Dz\nL1PVW8BXBjAKBggqhkjOPQQDAgNJADBGAiEA+iVdFXNpYFRbWFhprY2PfKJwtSSI\n2DPFih7JkF2D5jICIQCt9Jr4DRSjzeDXhhiajfeXsW3VT2Aiz5qyIqD2aXWWPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISASvTi5zPmciXMvP6xAtt758UMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDYw\nODRkMWU1LTI3Y2QtNDNlYy05ZWRjLTUyMDg2MDg5YmYwODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGYxODI0ZjFlLWY1YzItNDdiMy05YWU3LTM3ZTAx\nMzVjMzJiMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCWQ1i4q4trqejmogmId\nVtcEYFIxCUzCct5zIO0gKfHX8HCRMEGCh/VxOYpGbdna0P0aX47lDGUgsgH8uCtZ\n+iujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRpXSUe8tzk4a9mmI6taAl1UmokhDAfBgNVHSMEGDAWgBT91mGTaopDdqzv2+8u\nOZl1I8DbPTAKBggqhkjOPQQDAgNJADBGAiEAqi7QEusSVpmHOrO9EaIhIVBHCKVO\nNsq3ukf0ylDZbfsCIQDKaE/uzJTAqikRm4YOfRK+WFnyqCaxp/Y6WXq3Rhnx8w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWjNH5qAJ70mbfsCr6kAT0yvMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGRi\nZTZlMWUxLThiNjItNDM5Yy04NDUyLWQ5MjA3ZGQyMTZhMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDYwODRkMWU1LTI3Y2QtNDNlYy05ZWRjLTUyMDg2\nMDg5YmYwODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK+VBgQSDrWHIQgGkTO4\nyqaeeH9wCz5n7BTOCBfYaetHnAxBTXYD3N4skJehkRbjBYFqKYImnzEvTag/80MZ\n6xWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT91mGTaopDdqzv2+8uOZl1I8DbPTAfBgNVHSMEGDAWgBTTdu2IC5HJL5f5q9Dz\nL1PVW8BXBjAKBggqhkjOPQQDAgNIADBFAiEA2jCcP9aS893wYzSnl0ZELZV+30pW\nmdOzvP2zBvWeAuYCIAzm+42GE7ygDfVWnODh//P+N2c5QVBfSRxrBEbKXlkl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcA+HMizQl3/a9aSB8h4hcyJMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDYw\nODRkMWU1LTI3Y2QtNDNlYy05ZWRjLTUyMDg2MDg5YmYwODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGRiZTZlMWUxLThiNjItNDM5Yy04NDUyLWQ5MjA3\nZGQyMTZhMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDjmApxpZYj9678ES50U\nWfgtzoBn96I2Ul+b2F1oiyNhut3sKDsgIwlzo3uh0BGII9Fe68kjywTxzEG7msyk\nFsejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTTdu2IC5HJL5f5q9DzL1PVW8BXBjAfBgNVHSMEGDAWgBT91mGTaopDdqzv2+8u\nOZl1I8DbPTAKBggqhkjOPQQDAgNHADBEAiAdqPYuhTO4LfvGJHM6m0QGPH8BYVyD\n5OczEdQWfcjWsQIgSN2TRrSIDJq3doFKoJHopUY4KZQHDHrkpDhWVVQUjAo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAaFc5ZpFatG7CEf2BlodYLf0MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDBmNzA1ZTAxLTAwOTQtNGVjNC05YWFkLTA0NGE5ZTgwZTFmNjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJGRiZTZlMWUxLThiNjItNDM5Yy04NDUyLWQ5\nMjA3ZGQyMTZhMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDjmApxpZYj9678E\nS50UWfgtzoBn96I2Ul+b2F1oiyNhut3sKDsgIwlzo3uh0BGII9Fe68kjywTxzEG7\nmsykFsejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTTdu2IC5HJL5f5q9DzL1PVW8BXBjAfBgNVHSMEGDAWgBTcldafFfy6aZyi\nRSgobUE4dg2/NDAKBggqhkjOPQQDAgNIADBFAiBYXGnTLyJ7TMuvmWvtypS041t5\n4HnyZTCiUktcOLCJ7QIhAIgImC7G15/MJOsd15kHlkeztobnyPwh3/B2BX8BXc9t\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAW+6REU1ekUvR4+cgQCMdIQnMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDBmNzA1ZTAxLTAwOTQtNGVjNC05YWFkLTA0NGE5ZTgwZTFmNjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDYwODRkMWU1LTI3Y2QtNDNlYy05ZWRjLTUy\nMDg2MDg5YmYwODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK+VBgQSDrWHIQgG\nkTO4yqaeeH9wCz5n7BTOCBfYaetHnAxBTXYD3N4skJehkRbjBYFqKYImnzEvTag/\n80MZ6xWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBT91mGTaopDdqzv2+8uOZl1I8DbPTAfBgNVHSMEGDAWgBTcldafFfy6aZyi\nRSgobUE4dg2/NDAKBggqhkjOPQQDAgNIADBFAiBoNQmCFx1zJxO+sVS4h2kxgC5q\nWiaQvqPoqARcDoLwYAIhAKVWxH4MCZsmhrAbburj6M7xsbiGKiVJqH/ic3HH90sh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZCoCnw8bfk/G1azhesugamnMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJDJh\nZDQ5ZWI2LThmZDQtNDhiZC04YTRjLWIwZWIxNDQ2ZWY1NzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDA4ZWNmYjgyLWRhNGMtNDhiMC1iMjM0LTU1YzJl\nMDhkNjRiOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDb6onT2TNiFTrEKiX9s\nzTBs1gkDwAWi9gSP9BADuYTz+Rbso8Y9XaPE8tDKcAPqrmBZQGjq2D2+KubpC8RU\n2sujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR+1zH/z2sT48iSnuImGl6ObKS9ojAfBgNVHSMEGDAWgBSUqiGNWfm6Uo/KYkAI\n3yol/USGMTAKBggqhkjOPQQDAgNJADBGAiEA1Jj/NpzNCLRvNpSZ2E0qCnuZXdaz\nnf4snRN1lSSShDICIQCAyuiNpXk8RqLBD1cyOJAQmomy1WmZLTOsc+iaAR5XVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASkbp5he3FEpvk+nO88eWpUEMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGIx\nNTNjZDNjLTZkODgtNDU3My05YTZlLTI5OTQ3YzUwOTQ2NjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJDJhZDQ5ZWI2LThmZDQtNDhiZC04YTRjLWIwZWIx\nNDQ2ZWY1NzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIq4kKZEQF/lkXak3lfG\nqVh1fwtXSY1KeRWAd4wo8MfdSJ5P3Ul8/fvUKxD5miAHpXYyOZvY06XlfSWAJZFd\nfoajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSUqiGNWfm6Uo/KYkAI3yol/USGMTAfBgNVHSMEGDAWgBSr3enPUkB1i1itmAnF\n3GVedjUdiDAKBggqhkjOPQQDAgNHADBEAiBEq28Bq3xiZS+KM2AjbShKswUWc4yD\nxVAJvn1rDfSqiwIgHPr5KPSIldEKfZSwzuPXvlf9avWBpZP2xjTbFh0xZ9U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASw/lMqReOHPZP1VNMQCanDbMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGIx\nNTNjZDNjLTZkODgtNDU3My05YTZlLTI5OTQ3YzUwOTQ2NjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJGNmOTc3ODk0LWFjYWItNGVkYS04NDMzLWYxODNm\nM2Q4ZTc3MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABH9Hr6JPm92lS5KZp8jc\nWfomMeUPLJ2Y7NXGxQylEv7smtMH7XlLkqqbvGOo7pFj7+Y6t7ABKH7ZHV3dbtdE\nLXmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRXUsGjee8nQvMb+cTib4DkwVXP2DAfBgNVHSMEGDAWgBSr3enPUkB1i1itmAnF\n3GVedjUdiDAKBggqhkjOPQQDAgNIADBFAiARNYjutJdP2gOFNPrGKUg77GsyD5T3\n5HOExME3AaA9RQIhAMVRNbzEqiVHA9o2wwOG53g1rgyVMCn7wpovzv4u3hYT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAd9ycqXREVyjtYfKNwXsVoS3MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGEx\nY2E0NTkzLTU5NTktNGU2MC1hNTFlLTk4ZDRlZGU3N2E5MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDA4ZWNmYjgyLWRhNGMtNDhiMC1iMjM0LTU1YzJl\nMDhkNjRiOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDb6onT2TNiFTrEKiX9s\nzTBs1gkDwAWi9gSP9BADuYTz+Rbso8Y9XaPE8tDKcAPqrmBZQGjq2D2+KubpC8RU\n2sujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR+1zH/z2sT48iSnuImGl6ObKS9ojAfBgNVHSMEGDAWgBSZhIvvNDnt2siVU28k\nr+aCL17+gDAKBggqhkjOPQQDAgNIADBFAiAh67x1jwZJ0XM8Hpfp6CS8cJIIedON\nhNK2INaxAkHpaQIhAKLGi/DMSbOot9QTPtV8fMEm9gn5RftAlacasvWp7aTg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISAV0NFlleHEgnd4jVBekED4plMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyRiMTUzY2QzYy02\nZDg4LTQ1NzMtOWE2ZS0yOTk0N2M1MDk0NjYwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARiHxN0R8INgP3WU/0NfqBcp9UF1zhptJK/8T+ln//FIYVxGrC625AeGyhR\nM5B3TJLs1eAK+KhB4twE9wmXzB+ho2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUq93pz1JAdYtYrZgJxdxlXnY1HYgwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgCqsj\nETT+Wtu1ExD+rD/85MyaRpD9jd+5ozDKPbi0XMICIGUPKFToAMgGGBObcyotkOw8\nBITvyM7GP3V73sAaCKHf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISAT8OnuC6Lcsa00hMLJHrW44WMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRhMWNhNDU5My01\nOTU5LTRlNjAtYTUxZS05OGQ0ZWRlNzdhOTIwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATwsTR6Lb9b11AwJ+T9GLZ3c1D9llfXOZmPbvl/fdGSyeJ8+UL8h4kPaQoo\nWA/1UHkhayxGof/fmi/uDluax3syo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmYSL7zQ57drIlVNvJK/mgi9e/oAwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgdQMA\ngModmiK2cuylyFUTDiJs0jDFfLsa1QtcVNsiAEcCID65Jb/9H+1Th/7pkmNHUZiX\nEOIC94kTRBFJuETv4dRg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAbU0OXBamGWSBNFTimNHJ5JIMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGE1Yjc4ZGI5LWY3ZTMtNGFkMS05ZjliLTg4N2RlMzViOWUyNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkYWY0YmQ3NmEtYzBjNC00NzZh\nLWI2YmYtMjUyM2MzYWE4MWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAubW\nZD77NIh34VXPWaKNRscLGVYMd04oOKc7Df34KRI/geew5U/dfoSWNA3s9ZCbx4ks\n6+grDfNrp9if0aorCaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFE/sYB2Ln9psq9nsaKiCifphhuSzMB8GA1UdIwQYMBaAFDEg\nuE00FQ+SwI0CmxZ6cTIGLn0DMAoGCCqGSM49BAMCA0cAMEQCIAJfr96OdcNJUQ/B\nU8eBSBmwvBnpxvsA432GJzFF/2JVAiBO6QdPvKvE1zsPcTQVTMnxbPeS3Rr5QRpr\nvNgXzvkaLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAUybDtbN4j+2VZGdgjfvNGMbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkYWY0YmQ3NmEtYzBjNC00NzZhLWI2YmYtMjUyM2MzYWE4MWRhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkYTViNzhkYjktZjdlMy00YWQx\nLTlmOWItODg3ZGUzNWI5ZTI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEA6s7\nOcEQoPKdEuvSb54WMTDRaObOTwTOUQi92btt+U3VcioJ0+w6ii2Umv1oibMO3XD2\nSQiAPZ4JPvT3z8JWr6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFDEguE00FQ+SwI0CmxZ6cTIGLn0DMB8GA1UdIwQYMBaAFE/s\nYB2Ln9psq9nsaKiCifphhuSzMAoGCCqGSM49BAMCA0kAMEYCIQDfHUm4f5A4zt92\n+vB3jrhU3Us/xAl4lKxe5OcaPi5WjgIhAOIqpuekOsumJbxoPkp5yjSXOxfYGrwF\n7DLAH5FN+PMz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAcFLgkETDRfUdFPWh9aRSxCWMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDZiMmM4N2Y5LTNjYTctNDI5Ni05YzAzLWY2YTY2ZjIwNmZlNjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkYWY0YmQ3NmEtYzBjNC00NzZh\nLWI2YmYtMjUyM2MzYWE4MWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAubW\nZD77NIh34VXPWaKNRscLGVYMd04oOKc7Df34KRI/geew5U/dfoSWNA3s9ZCbx4ks\n6+grDfNrp9if0aorCaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFE/sYB2Ln9psq9nsaKiCifphhuSzMB8GA1UdIwQYMBaAFFIw\nhU4wUgJ9GUyzKN3z5COHdI4/MAoGCCqGSM49BAMCA0cAMEQCIGhXIUyxBVM8Vmpj\nlhlcSc5Oygs6R9nCskRvMUWajYIIAiBn3jyPsSgKv7JJBgU2jjCnh7Q98jFiKbHf\nKDM4TrAhnA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQkVD8r+fjtvl14Yxe6qozxUMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkYWY0YmQ3NmEtYzBjNC00NzZhLWI2YmYtMjUyM2MzYWE4MWRhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkNmIyYzg3ZjktM2NhNy00Mjk2\nLTljMDMtZjZhNjZmMjA2ZmU2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaxaV\n/TDCoryF/wuwll4pLUSckXa9WICAnPSBNjpQbHseHCZaA63aXDF8/WGDeVRQnrJy\nMU7RBDnJo7cRhUydaKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFFIwhU4wUgJ9GUyzKN3z5COHdI4/MB8GA1UdIwQYMBaAFE/s\nYB2Ln9psq9nsaKiCifphhuSzMAoGCCqGSM49BAMCA0gAMEUCIQD4aX8p/dvLbziv\nhkbuk6CMiqKWNPhKCaF76Bi+xw3vcwIgS1dySySf42VXNJS93B1yDoV8iz5W8uhh\neq06UVry7xw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISATjX4DVOYDyayO3fNdRpAYLxMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDBmNzA1ZTAxLTAwOTQtNGVjNC05YWFkLTA0NGE5ZTgwZTFmNjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkYWY0YmQ3NmEtYzBjNC00NzZh\nLWI2YmYtMjUyM2MzYWE4MWRhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAubW\nZD77NIh34VXPWaKNRscLGVYMd04oOKc7Df34KRI/geew5U/dfoSWNA3s9ZCbx4ks\n6+grDfNrp9if0aorCaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFE/sYB2Ln9psq9nsaKiCifphhuSzMB8GA1UdIwQYMBaAFNyV\n1p8V/LppnKJFKChtQTh2Db80MAoGCCqGSM49BAMCA0kAMEYCIQCel6XDAMG4uJsf\n1ytsRkQw4jB7okZGSnXblb/LfBUKMAIhAMEgO7a/A5q0S2ELFtsQ+qJo5wE2NrfY\n8g+aXK+dgm4K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAXfoJKaCpSYmnUqKxA/r7b2xMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkYWY0YmQ3NmEtYzBjNC00NzZhLWI2YmYtMjUyM2MzYWE4MWRhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkMGY3MDVlMDEtMDA5NC00ZWM0\nLTlhYWQtMDQ0YTllODBlMWY2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN0KT\nQPwAYXa3OVhTuraljVOT0YIS1W0F3WEq2wEPrPHhEI7uOD6JbhhiCUoaaPsKRL6F\nN16JMtrztRj4NKj0wKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFNyV1p8V/LppnKJFKChtQTh2Db80MB8GA1UdIwQYMBaAFE/s\nYB2Ln9psq9nsaKiCifphhuSzMAoGCCqGSM49BAMCA0cAMEQCIAhhQANhO1aR32x8\nt1b8D1hb1u4DV96wZSOlvMQ3ZoEXAiBpS3x6QlQNPxy/4Ue8qNw/O1Fo6XLPd6MZ\nNJn8bbhIvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcqgAwIBAgISAdT0moRxRItrqfC23vG0zcoUMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJGFm\nNGJkNzZhLWMwYzQtNDc2YS1iNmJmLTI1MjNjM2FhODFkYTBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABALm1mQ++zSId+FVz1mijUbHCxlWDHdOKDinOw39+CkSP4Hn\nsOVP3X6EljQN7PWQm8eJLOvoKw3za6fYn9GqKwmjYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRP7GAdi5/abKvZ7Giogon6YYbk\nszAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNH\nADBEAiBV0S6GXQk22E93blxGkUCWbtC+cFmjIKG7u4PYUudSmgIgP3sDDYiDdNZK\nVz4Ejo7g12C3GvQsbrwIrX3o+5hVzz0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcqgAwIBAgISAS5S8h4NBlam0VLiJYNDvjLcMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkYWY0YmQ3NmEtYzBjNC00NzZhLWI2YmYtMjUyM2MzYWE4MWRhMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBRP7GAdi5/abKvZ7Giogon6YYbkszAKBggqhkjOPQQDAgNJ\nADBGAiEAuX49EHwq7UJnZU35RYtg7k9ScLOSJrQWUTs1Ad8+LGICIQCY4Ow9OnqZ\noNBPZF2ngXvPXaH9SfJmzByaMZlpuse21A==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAfx7rK3CJJbCp0pqkpJlscXaMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJGRi\nYzI2MTZkLTU4MjgtNDRmYi04ZWNlLWU0NzFlZGU0ZDJkNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ0ZWQyMWQ2OS0wMjI5LTRhMzAtYjRhNC03MGNl\nODlkYjNjY2QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARLVbZ9W6ZHj1ShWNX7\nCpafzAQXiLdlo7+HvE3Hnnf3RVC9pHvE7RNObhLCa2g9ry+6svUesO0uiV2fGqlO\n4ullo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTw/XCgt1I023hyruoXbCIZ5nAWHzAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgd0bpnoN+2FLEVy6Y\nFNbaDLXUM5oagCLhbVbf6Z/GAkkCIAuoDjAkRaprD7uDgVI9DI4loSuG1SoY1mON\nuiHC//6D\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc63", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `63` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdP7/79EBL2BgA/6zfmz4dPWMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJGIz\nNTUzNmRmLWMzMjYtNGRhOS1iNjUxLTkyZTQ4MmMyZjE2ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDk5NmFmMTVkLWZmZGQtNDU4Mi1iODAxLTE3MWRi\nMDIzZDEzNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE12XFosdtqFA7KO2+Pn\nef2zy9FJ0H4IcnRq90vGXuukBy/5IxJwM3l8KJmxO4DJCTZ0FMf8LGoKai9k/U4w\nCISjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRsnYLG7o6nSpvfS9fZh4uLVj/mdTAfBgNVHSMEGDAWgBT4m4kHP2orNjyMj1R+\n1Bx+nAwYkjAKBggqhkjOPQQDAgNHADBEAiB/w31nFv2nmFwr/xdmpPGyITl3itPj\nynU6oNL1iY3D/gIgM6I7noEIRacqoRGdFuz2NeFeycFM2HlxFScWAG90flI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAb3QYhkDNstRfU7vKjywT7sCMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJGIz\nNTUzNmRmLWMzMjYtNGRhOS1iNjUxLTkyZTQ4MmMyZjE2ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDAxYmUyYTZmLWYxYzMtNDM0Yi04ZGY4LTJjMjgw\nOGY2NmFlNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPvuPY+SKKxomfZConxV\n6QwjKrpYAgwDfOTAdnNaSoMAnU1cVuSv7pCXo7Hl8IeahrdIHyh2u4yExlWEUASp\niP6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQFa6qahRxXnO7vRiVbDaAtrcTuGTAfBgNVHSMEGDAWgBT4m4kHP2orNjyMj1R+\n1Bx+nAwYkjAKBggqhkjOPQQDAgNIADBFAiEA6CxKzqTHDd78twCOiPdptaRtYilR\nFYjyXWwqnurzTi0CIA/zXcm1aj1Sl4Qd3TDaut9uEAqxe6LBwSA72AY3esj+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbzhsnA62zm0gFZck0urJAl1MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDAx\nYmUyYTZmLWYxYzMtNDM0Yi04ZGY4LTJjMjgwOGY2NmFlNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJGIzNTUzNmRmLWMzMjYtNGRhOS1iNjUxLTkyZTQ4\nMmMyZjE2ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEuKCbwKhcJJ9Ykcp5nc\nzALJPvRzpx652vw4i3onfE656D+gS01FCX92J2iQkr29eQGpPgud0bD3g1m9FFhP\nlC2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT4m4kHP2orNjyMj1R+1Bx+nAwYkjAfBgNVHSMEGDAWgBQFa6qahRxXnO7vRiVb\nDaAtrcTuGTAKBggqhkjOPQQDAgNIADBFAiEAynjzRJ3bcBnMhfD4HTqaOeB3jLMO\nEfVoTX+umhr7RugCICc4sQ57/evbvi3doiMjaYcSD2ESz/hdmLcx9e2SL4D7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAflaYKB8w9Px/QqC09q+ipj1MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDk5\nNmFmMTVkLWZmZGQtNDU4Mi1iODAxLTE3MWRiMDIzZDEzNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDk4ODM3OTdkLTczNWMtNDIzZS1hYzkzLWQxOTEy\nNjlhMTIyNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEIpihGIOJtjJq2e66Ej\n1HP9dfq73RDoqTXrNjd9SSir4ViRccNFMRylfE7+I72MjL8PqcQ57qSVuOLcF6xa\nVAWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTOk2fxVgV02igeVS2LKd4jledwnDAfBgNVHSMEGDAWgBRsnYLG7o6nSpvfS9fZ\nh4uLVj/mdTAKBggqhkjOPQQDAgNIADBFAiBibHVGNGL2XBVlLU2AA3MOFtpHhTh9\nDVJYNjCCQnLUxQIhANRg+V9PJbCWL6kIUaObjykq5ouipdWfbIx5UnrulmfL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXS/OOXnZsYs4MfZ0wzoB7XcMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDk4\nODM3OTdkLTczNWMtNDIzZS1hYzkzLWQxOTEyNjlhMTIyNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDk5NmFmMTVkLWZmZGQtNDU4Mi1iODAxLTE3MWRi\nMDIzZDEzNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE12XFosdtqFA7KO2+Pn\nef2zy9FJ0H4IcnRq90vGXuukBy/5IxJwM3l8KJmxO4DJCTZ0FMf8LGoKai9k/U4w\nCISjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRsnYLG7o6nSpvfS9fZh4uLVj/mdTAfBgNVHSMEGDAWgBTOk2fxVgV02igeVS2L\nKd4jledwnDAKBggqhkjOPQQDAgNIADBFAiAOKl6/SWRx8I7RMvjrQ6vIh3PuH/Og\nHUCCZPGpM/vmcAIhAJIsz7E1Sb1EoJlocVngEVQZpp6asIQYZSMTv4sMxAFk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQu1msMGvvflZiva0IpjGWleMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDAx\nYmUyYTZmLWYxYzMtNDM0Yi04ZGY4LTJjMjgwOGY2NmFlNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDk4ODM3OTdkLTczNWMtNDIzZS1hYzkzLWQxOTEy\nNjlhMTIyNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEIpihGIOJtjJq2e66Ej\n1HP9dfq73RDoqTXrNjd9SSir4ViRccNFMRylfE7+I72MjL8PqcQ57qSVuOLcF6xa\nVAWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTOk2fxVgV02igeVS2LKd4jledwnDAfBgNVHSMEGDAWgBQFa6qahRxXnO7vRiVb\nDaAtrcTuGTAKBggqhkjOPQQDAgNHADBEAiA6IUi2EO2WAaCREKKJk6cBa99JzREq\nWLiDTFrvKLYzvAIgTjPsY52q6sRwDaonh4efvp7fngNhW4EOztxhEc3yI8s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfsryim9IaZCxaU6ZvBP0UqYMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDk4MDQzYmRkLTY5YzUtNDE0Ny05ZjRlLTUwZGE0YjFlYzg3NjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJGIzNTUzNmRmLWMzMjYtNGRhOS1iNjUxLTky\nZTQ4MmMyZjE2ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEuKCbwKhcJJ9Ykc\np5nczALJPvRzpx652vw4i3onfE656D+gS01FCX92J2iQkr29eQGpPgud0bD3g1m9\nFFhPlC2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBT4m4kHP2orNjyMj1R+1Bx+nAwYkjAfBgNVHSMEGDAWgBTWNBeP8tmRnd6D\nkd6OHUM/c1AcWDAKBggqhkjOPQQDAgNIADBFAiAWi87Req5tmlInIbXKpseTQQBt\nAluHrawCoU1UT7YVFwIhAOmkVKXhI0fO+ZpjlJpqNdG3sh7rCkVKQlAtrHOPkTqN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAfB45x6z00op1+Nqj0jYwP6EMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDk4MDQzYmRkLTY5YzUtNDE0Ny05ZjRlLTUwZGE0YjFlYzg3NjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDAxYmUyYTZmLWYxYzMtNDM0Yi04ZGY4LTJj\nMjgwOGY2NmFlNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPvuPY+SKKxomfZC\nonxV6QwjKrpYAgwDfOTAdnNaSoMAnU1cVuSv7pCXo7Hl8IeahrdIHyh2u4yExlWE\nUASpiP6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQFa6qahRxXnO7vRiVbDaAtrcTuGTAfBgNVHSMEGDAWgBTWNBeP8tmRnd6D\nkd6OHUM/c1AcWDAKBggqhkjOPQQDAgNHADBEAiAyi7DAgFPEjG3VWA4svhrr7eFX\ncdHTuJVpr8WKAwPi9wIgKZPvtafxAIH/0RmdmHyLk/La5WUgaltDmAT/swmc6Eg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbKMtG38rN+PDSrraiy0+SDGMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDQw\nMTEyOGExLTUzOWEtNGRmNy1hMGU0LTJlNjM1NGNkZGY5MDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJGM3NjQzODE0LWFkZTItNDljOS04NDdjLWIyYTgz\nMjMxNGFiNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOYvnG/+Xg9R+yB0ywlz\nOASV3fwrWKSc+rlIHVnDF5tu6hYV61BC+Y17RzD2sKh99AV3IWsuSOabcPdZVX27\nouqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ28oSbSSxfUKiXiHOAhyc8fviyLTAfBgNVHSMEGDAWgBRdc9y0Dh1G86B35ZLL\nAngEuzv9OjAKBggqhkjOPQQDAgNHADBEAiAWokkyKl0e6kabH5Z0rfgPxet2+2Sw\neYcJLwyq7BfFSgIgH40VO95exo9diQ0kvwNvkyh69YfBOT+GYqJuZJ4sDHU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZYQmuNjJ8VhvF6nTh79hftLMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDli\nNGY1OTcyLWU1NGYtNGFiNi05ZmJkLTUxOTYxMWVlMTQ5NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDM4ZjMxYjA1LTVjZWMtNDliZC1hYTdiLTg2ZGE3\nZDBmMDM1NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJzinzJo2mP21qaeoiN8\n912CwJmfGZUhEMhSiamFVmAJoIj68ExL7XQ24mQKQJSof9XPcOC9PzX2m57uk5X6\nMpyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTevYywoJvOrrv7KgIxFD9ayuk7sDAfBgNVHSMEGDAWgBQ/tRKlGTX7IrjtxzpE\nWQhPSqucjjAKBggqhkjOPQQDAgNIADBFAiEAg+UwNHNEC53obclEoQrbHLHlfKnf\njWAwjiKbkB1/J7cCIBAmkCjdXupOLiE1SS1x3vX6n6cqC/xqUxVm32dpumHr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZLTyLKBeEvEt/8Ow0UgSOI9MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDli\nNGY1OTcyLWU1NGYtNGFiNi05ZmJkLTUxOTYxMWVlMTQ5NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJDg4ZmViZWU3LWM5ZjgtNDhiZC04Yjk2LWEwN2Qy\nYThjMWQ3ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAg+P4NNTbwPwPogXlQw\nIKcKcNFTrfD4Mlqi0FcU15t/+m2fROkorr2mcyE6yzDnJuvKh2YxsDkDOxqb/4a9\nwZSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRy37ZSG3Xuc5ZZ3V8mJEHOQ0dNBjAfBgNVHSMEGDAWgBQ/tRKlGTX7IrjtxzpE\nWQhPSqucjjAKBggqhkjOPQQDAgNHADBEAiAZ2upG6Y/+S+g+1Z41ejYXRhaoHojB\nADPELH3fFfVqnQIgee6ze/wSOzpt7djHUIYwnjeLkxRoGeSOzEs6tgzZEwM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAUska1mNDoE5+Ci9xULbXT0UMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGQ5NmRmMzBhLTdlMjUtNDIwNC1iM2E1LTc2YWU5Yzg1MWNhMzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDQwMTEyOGExLTUzOWEtNGRmNy1hMGU0LTJl\nNjM1NGNkZGY5MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMn6W3LmCfF/zsdh\ns5zPDOeoziao4OyHmrYur/HyuvxbvzvmpHOIAk6ZnU1V4posGjSzOMcDWnbORw9z\ntUKNwUGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRdc9y0Dh1G86B35ZLLAngEuzv9OjAfBgNVHSMEGDAWgBRPp258DFDsouVt\nRgEpt7uWRB5MUDAKBggqhkjOPQQDAgNJADBGAiEArLqPCq6j/cwApr6+57rbqLwb\nav/ej0oxJNCKxNkDOq4CIQCY/SqYFKfnnJfhIPJFKAY5W84pt+yrqRbCvw590LHX\n8Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAcpD478ZAlJqxfpSJG92Yd+vMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGQ5NmRmMzBhLTdlMjUtNDIwNC1iM2E1LTc2YWU5Yzg1MWNhMzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDliNGY1OTcyLWU1NGYtNGFiNi05ZmJkLTUx\nOTYxMWVlMTQ5NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBnROEvtC2lF9gR8\n5o8HtIHqSD4lYupcszFXdHSKDQ+mNdLxaYBVRl6kd3ABRk+2xTN3wxx4om3YVQ6n\ncpyurCejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQ/tRKlGTX7IrjtxzpEWQhPSqucjjAfBgNVHSMEGDAWgBRPp258DFDsouVt\nRgEpt7uWRB5MUDAKBggqhkjOPQQDAgNHADBEAiBuHrYRJHWT4omW+ci0rczEAMq8\nNd6uZfgT5xF1ylbclQIgKTQN6TUZSvoWQZefMaSsCSxEPWFlPIGgQH81n9qUHSA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVlyWsnT6nJnxhQSSPW3jaM/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDFi\nNTc5ZDM4LTI4YzAtNDgzYS04NzY0LWFlZDI4YzAxZjI4NTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJDFiYzVjZDkxLTk4NWYtNGI3ZC1iMzE1LTdlOGI1\nYWIwOTY0ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKrMsWmK3+L8Mx5cg1cM\n9y9hvHVV/Iz9us51vXK9/M/5GEuHWPc6Z/5PhosJdmeOlqTgCrug9rsHxYUvMQ0R\nzemjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTxSfl2NkYraviOwlDzBLOqJ5gOezAfBgNVHSMEGDAWgBQVPHWjqCLzlbuDYogb\nrTc/9qM98zAKBggqhkjOPQQDAgNIADBFAiAFB+98X5fKkxZgVrqqBvs6/lBKVQqn\nykZ0veJHQdQ5xwIhAIYgG3XU1P5REtdOqlGCrt7AoLGwQ98EJ4dt92lwIhcL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATsqkmUytGImNF7mcvO08FeZMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDFi\nNTc5ZDM4LTI4YzAtNDgzYS04NzY0LWFlZDI4YzAxZjI4NTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDRhZmEwMzg1LTQ4ZWItNGI4ZS05MGNmLWI0NGVh\nZGFjZWM4MTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLvlBVoMHzOwxplQ3flD\n0o+1r3MhOFUnbh2CCGriiuiBye3RPQCQ/vjKeiYdflVFxuirtKMTyLoYd2BZS3jW\nKO+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSAMWmIk9JWTKWDECT+rL3H+HyQgjAfBgNVHSMEGDAWgBQVPHWjqCLzlbuDYogb\nrTc/9qM98zAKBggqhkjOPQQDAgNHADBEAiAuEfHUTCvf4ogCK4RzA1AOCpgip3MY\niSawzOvahC3UsQIgWjREq/sY36+Bn2kzgfwALrhKhF9oSWRK64oxTEDvmP0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAY3N3OC2YcHhNYa37gBPf41fMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDU4\nNTFlYjU0LTc3MDUtNDNlZC1iMjZiLTc2M2M1NGU0NDQ1MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDFiNTc5ZDM4LTI4YzAtNDgzYS04NzY0LWFlZDI4\nYzAxZjI4NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHadD14/0XVvXCLKzo+J\nFZumGu5lijTOwQIaDxhTwixJt5k/3SbL1zM+LBfCAEcUzM4kBkS54mXhgMNNJL0K\nR/SjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQVPHWjqCLzlbuDYogbrTc/9qM98zAfBgNVHSMEGDAWgBQLUY+piNygDNPMmPqE\np5b/LKGFXjAKBggqhkjOPQQDAgNIADBFAiEAq32yAetkRfJ+dcMZ3gDxuC6vassx\nHpSuYFbtde1TTCcCIGNcOsqQzo0xgDJo/Cu8Rskq4pK6NzDWj5qB8Pgun6pS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQLrFyF2xYiLd5eb7g3GZQMRMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDI5\nZDZjYzM0LWE3YzYtNDIxZC1iYmZiLWZiODZmZDdjODVhNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDFiNTc5ZDM4LTI4YzAtNDgzYS04NzY0LWFlZDI4\nYzAxZjI4NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHadD14/0XVvXCLKzo+J\nFZumGu5lijTOwQIaDxhTwixJt5k/3SbL1zM+LBfCAEcUzM4kBkS54mXhgMNNJL0K\nR/SjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQVPHWjqCLzlbuDYogbrTc/9qM98zAfBgNVHSMEGDAWgBQ+FDTirlE/r6/zvoaU\naQO3m8FMmzAKBggqhkjOPQQDAgNIADBFAiEAoI8FtOoMDh5S72WfU9y+Ujfrpjqv\n3MFd+HH92VeLvNcCIAPlIN++L+etc9cxwPkpooHGgAuci+xep8tJkiS4mKWx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAU7pd1SD3GqTKY7NtvDfCchpMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDU4\nNTFlYjU0LTc3MDUtNDNlZC1iMjZiLTc2M2M1NGU0NDQ1MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDI5ZDZjYzM0LWE3YzYtNDIxZC1iYmZiLWZiODZm\nZDdjODVhNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN3lluyj74wXaV9QJG85\nAWvylhGEJuGHTuCtcymmvu0wrUyGEzeGA2eun/Wd+ccyrG9IZ4o1+07LcEDnwf6Z\nODujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ+FDTirlE/r6/zvoaUaQO3m8FMmzAfBgNVHSMEGDAWgBQLUY+piNygDNPMmPqE\np5b/LKGFXjAKBggqhkjOPQQDAgNIADBFAiB4SX3sHm2/9IdiLe/vFAF2o3taLuC8\nOS9Bz1LwdGXU/AIhALW12Un2rR+e9CBfxglaSHupv5Ys90cplLydc4ksDpvP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARB6n54ax02mlC0EuG9YQPdpMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDI5\nZDZjYzM0LWE3YzYtNDIxZC1iYmZiLWZiODZmZDdjODVhNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDU4NTFlYjU0LTc3MDUtNDNlZC1iMjZiLTc2M2M1\nNGU0NDQ1MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGKascroDkTpzoQSgbYk\n4Qr053Pdzue1bV6PTsuNARX+XUNOVhovHFhyt86YeacNGUxxXxOxGIGDu1lrBhZl\nam+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQLUY+piNygDNPMmPqEp5b/LKGFXjAfBgNVHSMEGDAWgBQ+FDTirlE/r6/zvoaU\naQO3m8FMmzAKBggqhkjOPQQDAgNIADBFAiEA3rldVgwCGnvxNS3bikr+3W1VLor4\nHqSBL1cxr9US73QCICERxzs2t/37FMslHfGcTqcvjvR1RqFmBtnnj/J5IA8Y\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAXJv1M2iWKu1jSx5i8E+9zoXMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGQ1NTg3NWIzLTU3MjQtNDQ1Mi05MTg4LWE5ZmM3ODkzMmU1NTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDU4NTFlYjU0LTc3MDUtNDNlZC1iMjZiLTc2\nM2M1NGU0NDQ1MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGKascroDkTpzoQS\ngbYk4Qr053Pdzue1bV6PTsuNARX+XUNOVhovHFhyt86YeacNGUxxXxOxGIGDu1lr\nBhZlam+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQLUY+piNygDNPMmPqEp5b/LKGFXjAfBgNVHSMEGDAWgBSnuRmLkCDoV0Lq\nBHXGW+NudggeGzAKBggqhkjOPQQDAgNJADBGAiEA8IxlKvCgXdSXh06x9z6mH8Cv\nIZ3ACFJKEKI0Q2Zd8BACIQCg4XejWtUasjmhyM5herILhPuuwEz+FC4xZTNKTJby\nNA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfLQfoc8/zqBoB9nADF0hYZBMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGQ1NTg3NWIzLTU3MjQtNDQ1Mi05MTg4LWE5ZmM3ODkzMmU1NTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDI5ZDZjYzM0LWE3YzYtNDIxZC1iYmZiLWZi\nODZmZDdjODVhNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN3lluyj74wXaV9Q\nJG85AWvylhGEJuGHTuCtcymmvu0wrUyGEzeGA2eun/Wd+ccyrG9IZ4o1+07LcEDn\nwf6ZODujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQ+FDTirlE/r6/zvoaUaQO3m8FMmzAfBgNVHSMEGDAWgBSnuRmLkCDoV0Lq\nBHXGW+NudggeGzAKBggqhkjOPQQDAgNIADBFAiAZQhLG8TouOJGAHafT+UPdsOVi\nFQIpC0rdKaXh9MyfuwIhAKcpN/UjrtHFcXnMcfOiX/85cVKFOlVGhnskh1cc+J+N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAagbEDj5l1zJcH+UOc94k6UxMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJGFj\nMTk3MDU5LTlkNjMtNDZlMi04ZTJlLTk2MmExMDc1Njc5YjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDc5OTUyNzhkLTk4MjEtNGQ0Yi1iYTU1LTg2YTk2\nYzg1MTU5ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEJKTwa/42RY7kTM+t2W\nDpxMsuRcaaUStelIJRLZKi8YTGyrsH/FscqJ4AiIvju0q0yjLHCM6Iuu1pCFXcXF\nziGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSxeb5Bdmkcexo2eJNme7mibTbOjTAfBgNVHSMEGDAWgBSbeibfV/JyHoTtkbHD\ntWcbk9An7DAKBggqhkjOPQQDAgNIADBFAiBzJSdPZLkiRticS2fCEL96u3PLvlqf\nIppZUmNsDdYb+wIhAKi8qupmPQ2d7he5j0j8bkSO4/kKwrTyYrn7VOZWfueD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARVUOxMBu2H3SGDQySo1lbMxMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGVj\nZmQwZjVhLTYyNzAtNDQ1ZS05ZThjLTMyZjBjMmQxZjA3MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJGFjMTk3MDU5LTlkNjMtNDZlMi04ZTJlLTk2MmEx\nMDc1Njc5YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIb19uoVdi4mNSt/XpA8\nPNUUXfnmk5v3FLjiLnQwzr1VlTMmu83crsrS2C8u3omEDiHR0aRFdabKA4NihIkb\ngAmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSbeibfV/JyHoTtkbHDtWcbk9An7DAfBgNVHSMEGDAWgBTysgcdV9fjhVeAU+QF\nStNBH2DDwjAKBggqhkjOPQQDAgNIADBFAiAYwckHzZGBknt9qjEhjBMiUk8ojSWF\nbhOPNGxQ+u4urQIhAOtYmFeKwCqbpUrA9JMQRacMceqbz9zbbOpSf+Is+XTC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISActsL76D8EZ8SzsSYE7ZJBjbMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGVj\nZmQwZjVhLTYyNzAtNDQ1ZS05ZThjLTMyZjBjMmQxZjA3MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDI3YjY4NjgxLTI3YjktNDg3NC05NWQzLTUwZDE5\nODIyNzYxNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNXz1muxQZxwH5je41Bz\n1BjjrqEcCMA5tgEOqSnfpH6iOze3Hbmu8V89q35mmkEKbRj55fEKM2jSvw2bOyhI\n7gOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQfsrx79aTUvCbWQBoMOBoi1+4RnjAfBgNVHSMEGDAWgBTysgcdV9fjhVeAU+QF\nStNBH2DDwjAKBggqhkjOPQQDAgNIADBFAiByhwhWzqpKm+u3g7rxnjCFRtuHmJxh\nkd4rX4ocDy/AKQIhANu4HOx2COpu9eXO0pCHUXi7ZHZAVW5n2gS4Wtl3fQSH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXzt9v0o2Pm2xneeqwHAi1a7MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJDNi\nOTAzODNlLTEzYzgtNDM5OC04MTkyLWNiZGQxM2ZkYzAxNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDc5OTUyNzhkLTk4MjEtNGQ0Yi1iYTU1LTg2YTk2\nYzg1MTU5ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEJKTwa/42RY7kTM+t2W\nDpxMsuRcaaUStelIJRLZKi8YTGyrsH/FscqJ4AiIvju0q0yjLHCM6Iuu1pCFXcXF\nziGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSxeb5Bdmkcexo2eJNme7mibTbOjTAfBgNVHSMEGDAWgBQ4LM+tC9yO4Qjwofjr\nwIGxpv+4DDAKBggqhkjOPQQDAgNHADBEAiBXTAcWe34/S1/A1tS7+2J+09q9WYnh\no7mtSe0HgPuLjAIgYM8xpJNiSkBMxesjVxJPOAai9k8eX17Qy2o6RgaWCgc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAQ70ae5FkAQZXbeYO9mKXjMCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyRlY2ZkMGY1YS02\nMjcwLTQ0NWUtOWU4Yy0zMmYwYzJkMWYwNzIwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARG+K9uQkgl3JKVIfULOEd/Za80m8oq9bDGPS6xSSTF7Oy4qD2cnd1dTqKZ\n+vD3xWMPY5Oua6+9wiWfEKrzdNL/o2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8rIHHVfX44VXgFPkBUrTQR9gw8IwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgVSp8\n/lVCqKTqqrjMi7H6BpW7zYPzo+DG9/ojqcR6IYgCIQD6cRhwkPZ1szzmaEmNQFwY\n42e4WanBmC0A0SRtQiSKfQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAU2N8rhb+RImLXonbWve6kt5MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyQzYjkwMzgzZS0x\nM2M4LTQzOTgtODE5Mi1jYmRkMTNmZGMwMTUwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQIJWa4PvIwUdlg93v0UQHOz0Uu1+VghwD9L91UN8l2/QpsrMXyAaG2eOPO\nmtJKcOiBm+41Gq50QahCxDh7fbnpo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUOCzPrQvcjuEI8KH468CBsab/uAwwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAKJt\n7cRq+KkUPutoG/Ckrsrm64NDIOd0OfLpeV9CnHNSAiEAk2PhsuaNBdXD5e+Ynis8\nErAsFn69yXwEhp8/8d1QW18=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAfIssRaetDee6xmE7WrAUkQZMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDk4MDQzYmRkLTY5YzUtNDE0Ny05ZjRlLTUwZGE0YjFlYzg3NjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMTUxNmJlODUtZjk0Ny00Njlk\nLWE0ODUtZDJiMmVhZjhkMWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN+b1\nln0Ge2njFqdDSr/lQ14L8oTlOeVkwXPq67yfYg3nQzZLeDEiDKIM9y+wcFo8DB8m\nmghvjaaQ6cYlqED2LaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFKQ3Cu5/zQzqo6b12WXvzDb1I7ZDMB8GA1UdIwQYMBaAFNY0\nF4/y2ZGd3oOR3o4dQz9zUBxYMAoGCCqGSM49BAMCA0cAMEQCICa3UQ8Viz9Xr0VH\nW5FIr9PlaAAoFFr3+Ppkth7VK2XQAiA7d38QCXa2nGVKTvxmfmtoc6p8VxXdjZBi\n6Gvj9E1Wlw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXAXsSci2sylO6jW2EKwak6kMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMTUxNmJlODUtZjk0Ny00NjlkLWE0ODUtZDJiMmVhZjhkMWQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkOTgwNDNiZGQtNjljNS00MTQ3\nLTlmNGUtNTBkYTRiMWVjODc2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFtRQ\nzoiAT9lGJVcwD6NEiCl6kI5jORS1x5+fyh738v6rf73mPeUO74Fdjdgyt1zjyzVu\nqjebOni3pgUUGRDDRaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFNY0F4/y2ZGd3oOR3o4dQz9zUBxYMB8GA1UdIwQYMBaAFKQ3\nCu5/zQzqo6b12WXvzDb1I7ZDMAoGCCqGSM49BAMCA0gAMEUCIQCOea8x+Yw3YAhk\niVLMjy/WsYCQG1OVActvnSGyrxFmGQIgM9wthoajgrjgXZiOGGwbDk2ZM1KpjjIS\nXZSq/FJUbfg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVc9fbtbumBb1LvWH06gT5rIMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGQ5NmRmMzBhLTdlMjUtNDIwNC1iM2E1LTc2YWU5Yzg1MWNhMzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNjAxMjAxNjI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMTUxNmJlODUtZjk0Ny00Njlk\nLWE0ODUtZDJiMmVhZjhkMWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN+b1\nln0Ge2njFqdDSr/lQ14L8oTlOeVkwXPq67yfYg3nQzZLeDEiDKIM9y+wcFo8DB8m\nmghvjaaQ6cYlqED2LaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFKQ3Cu5/zQzqo6b12WXvzDb1I7ZDMB8GA1UdIwQYMBaAFE+n\nbnwMUOyi5W1GASm3u5ZEHkxQMAoGCCqGSM49BAMCA0gAMEUCIQCtKgA9BYKV7Y74\nBl7hCB6He3qAVPSMrZfhCo1+dlXDeQIgULmNzCrRCB1vjtMAcW2koDskbiNNyyV1\nP2WLn5CpwJ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAZRaysJeV5s7iFjdxdYaQ47VMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMTUxNmJlODUtZjk0Ny00NjlkLWE0ODUtZDJiMmVhZjhkMWQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkZDk2ZGYzMGEtN2UyNS00MjA0\nLWIzYTUtNzZhZTljODUxY2EzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGx5I\nT3ejPkGY+i3affvFVlmCemQvMpy8asXhguDAQ5dZRqA1RuYdpiDywKznCRY3a0qH\nP8lSRoD8FOv26fxx0qNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFE+nbnwMUOyi5W1GASm3u5ZEHkxQMB8GA1UdIwQYMBaAFKQ3\nCu5/zQzqo6b12WXvzDb1I7ZDMAoGCCqGSM49BAMCA0kAMEYCIQDoZ4a1aJm11zHv\nbIUpkjcLRSVOc1jQ1TcSZ/B2yGnnlwIhAOn7GozZcxGoP575VdGvNTeswsKfoWPt\n8sDm25XjRkOW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISARz1moNYy5jIdaYEZOVMCgIqMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGQ1NTg3NWIzLTU3MjQtNDQ1Mi05MTg4LWE5ZmM3ODkzMmU1NTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMTUxNmJlODUtZjk0Ny00Njlk\nLWE0ODUtZDJiMmVhZjhkMWQzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEN+b1\nln0Ge2njFqdDSr/lQ14L8oTlOeVkwXPq67yfYg3nQzZLeDEiDKIM9y+wcFo8DB8m\nmghvjaaQ6cYlqED2LaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFKQ3Cu5/zQzqo6b12WXvzDb1I7ZDMB8GA1UdIwQYMBaAFKe5\nGYuQIOhXQuoEdcZb4252CB4bMAoGCCqGSM49BAMCA0kAMEYCIQD+nFUjq16Pbrmz\nadY25JyCnWeP91UAvuas6wl6sNNN+gIhAOuWuelrbu71FkmiY3OyIarT+BotqL44\nFPnjmyKYfPWl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAdMPMIBdcexAUAB2fWXlJroCMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMTUxNmJlODUtZjk0Ny00NjlkLWE0ODUtZDJiMmVhZjhkMWQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkZDU1ODc1YjMtNTcyNC00NDUy\nLTkxODgtYTlmYzc4OTMyZTU1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJSCc\nJ/xwcFaAelfR7Ulql4d6IRRwNCYxTm0PIkXNgj4OPQ6MA1CGV5UGLElQnP/Q3xIX\n+oPBXUdpszGINeNJCaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFKe5GYuQIOhXQuoEdcZb4252CB4bMB8GA1UdIwQYMBaAFKQ3\nCu5/zQzqo6b12WXvzDb1I7ZDMAoGCCqGSM49BAMCA0gAMEUCIQDwk760Gh3EnJJu\nTU8rht4x3ZsV/koXjxOFx85dpI0yiwIgbxpuzr1ukMmER9SzSH4DoYTZtOEpIgEy\nvxztXgIgirE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcqgAwIBAgISARi/A3oRlaxIYcjtAr3ul+aOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDE1\nMTZiZTg1LWY5NDctNDY5ZC1hNDg1LWQyYjJlYWY4ZDFkMzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABDfm9ZZ9Bntp4xanQ0q/5UNeC/KE5TnlZMFz6uu8n2IN50M2\nS3gxIgyiDPcvsHBaPAwfJpoIb42mkOnGJahA9i2jYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSkNwruf80M6qOm9dll78w29SO2\nQzAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNH\nADBEAiBYzfustVxw2KcqdVPNKxLlB5V1aeUv1Y/hgO8nONuk9wIgPz90m7O8qRxq\nOxtrUIqSTH2sizjLDVzYXY+REw5cFHQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcqgAwIBAgISAWhtAfAtrm8r1U/mhFC+0BI3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMTUxNmJlODUtZjk0Ny00NjlkLWE0ODUtZDJiMmVhZjhkMWQzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBSkNwruf80M6qOm9dll78w29SO2QzAKBggqhkjOPQQDAgNH\nADBEAiAVEjRZRcUXymaYpmDG2oLKLA1UCo30N2CYJI1OkZx8vAIgaD7C44hZXofR\n8Q0vwMrpxkkOrTPBcgIaSL6q7y/3T0Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAd55fqFF/JyxBQaKpm+Y7gOGMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDM4\nZjMxYjA1LTVjZWMtNDliZC1hYTdiLTg2ZGE3ZDBmMDM1NTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ2MjczYzI2Yi00NDRmLTQ0MjYtODUwOC0wMjZl\nZTQ4MjlkMjEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATjDmd4SNS3xndHZnSb\n5Vj6tgGEOuDKUZp8ISiz69XQbhgpBuUcUXV+Tv3s616P/Q7jypN2iYIXdmgXAlV0\n/ZYKo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTevYywoJvOrrv7KgIxFD9ayuk7sDAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgHynow7SL1y+nHySQ\nsbeisbhtfGh+HXbM4CYuBNoIxLoCIQCjRbfffksi7KiS4fidPvtkBkyADKlarBxx\nsDRvTnHDhA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc64", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `64` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWr0OWLiJvB5hpBDFICw/OO3MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDYw\nODJjMDEwLTZkMGYtNDc2Yi04NTUxLTA2NTM5NTFmNDQxYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDYzM2MyZTNhLTY1ZGQtNDhlOC1iNDE5LWJjOTI4\nOGYyY2RiZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNlBpMaFtTEE/nunuaG4\n0lgRy2HJci5J2ef5sFSyZHqftPpeqmSIeXUeH+OAYVg2IwO7YqcG411v4MVpNHWX\nHSGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRoKbxZPiVVuQOAII0EYEb1fBhr+DAfBgNVHSMEGDAWgBRRfnhjbSZP2Aow3Aiv\ntU/2JRJSnTAKBggqhkjOPQQDAgNIADBFAiByq/AiTcR+KzXHHQq4XX0k7P8J8EYP\nFIbE7DElU1RpjgIhAKeftEb9NXY2BQpf0SJhq5hvkaA3Vg5KgqUMsdtU9YdZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbNP/ngjRT/Ns98CP+T7CcHbMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDYw\nODJjMDEwLTZkMGYtNDc2Yi04NTUxLTA2NTM5NTFmNDQxYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDU3ODE3NWEzLWQzZjMtNDBkYS04NWYzLTRmZTVl\nOGJmMGQ4MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGCFnldak+bFd/aLnhv5\nVs1B4KQcO/zux5Bj2617prYF4u7NhTpWpLmEFVRDoUnK+M1PT6BtoMP4Q9QgnfZz\noyijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSSCoy5kEx7dqC5IJnQETR5OfALGzAfBgNVHSMEGDAWgBRRfnhjbSZP2Aow3Aiv\ntU/2JRJSnTAKBggqhkjOPQQDAgNHADBEAiBSvHya5z66BgCp6pwDPq/TXPbu3t7Q\n0HND3eskNYN5+AIgFI4epefu5LltwryOd8eiQ6H8bhGJNz38G5UtcvNWSnM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAW37hOGteqgB4qPrcyF0/Xi6MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDU3\nODE3NWEzLWQzZjMtNDBkYS04NWYzLTRmZTVlOGJmMGQ4MDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDYwODJjMDEwLTZkMGYtNDc2Yi04NTUxLTA2NTM5\nNTFmNDQxYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMGV/5iNp06pq7l1Wc7o\nwh8vPfejzNIwHJfqViupwH680tlVx/hrHW9EtJJD1NdGoQaMZFEjhsws/9K76Sn8\ngamjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRRfnhjbSZP2Aow3AivtU/2JRJSnTAfBgNVHSMEGDAWgBSSCoy5kEx7dqC5IJnQ\nETR5OfALGzAKBggqhkjOPQQDAgNIADBFAiEA6ANx8VNHKx6/0yRnVw0upjpNZlNY\n+HPawLjq3+lcXPoCIAV1O5UVhYDyaMm97n10fKBiQr31+hNKGoNCrRaRhcBD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVHAccA1bn2NzGVkDE4YvKNoMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDYz\nM2MyZTNhLTY1ZGQtNDhlOC1iNDE5LWJjOTI4OGYyY2RiZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJGQ1ZmZmOWIxLWRiOTQtNGE4Zi1hMzYzLTU3NDk3\nNGQwNjRlYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAzVtpXum+wRo5FspRxd\n+o7Ka7dSG5Avc8+ZhzeMjyN0FFirk08+g8oLTm1F6ynsLU5CVgCg5vqSu6lCsf+v\nPmejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSQHTqj+TYcyA3apAh3SLe63TXdDDAfBgNVHSMEGDAWgBRoKbxZPiVVuQOAII0E\nYEb1fBhr+DAKBggqhkjOPQQDAgNHADBEAiBsj4HdKt9oGHuiu65y3wGg/H2eY/Q2\nEMPZa543zbxnyAIgCVD9UnPrEDnDytQYh1VsYmYf18hz1DJvX8SUFONfp4s=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfu7WT9eyi/sRq4s+r6hoeTjMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJGQ1\nZmZmOWIxLWRiOTQtNGE4Zi1hMzYzLTU3NDk3NGQwNjRlYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDYzM2MyZTNhLTY1ZGQtNDhlOC1iNDE5LWJjOTI4\nOGYyY2RiZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNlBpMaFtTEE/nunuaG4\n0lgRy2HJci5J2ef5sFSyZHqftPpeqmSIeXUeH+OAYVg2IwO7YqcG411v4MVpNHWX\nHSGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRoKbxZPiVVuQOAII0EYEb1fBhr+DAfBgNVHSMEGDAWgBSQHTqj+TYcyA3apAh3\nSLe63TXdDDAKBggqhkjOPQQDAgNJADBGAiEAvkNyhaE+///2To2wMB1rBPIwisGk\nacF4JleaeXykbCICIQCRYzqYMqVersqknflxhNOy1vEMdXn36c+AYGpL8qC++A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISATAolazkG9myZL6oavk4B6snMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDU3\nODE3NWEzLWQzZjMtNDBkYS04NWYzLTRmZTVlOGJmMGQ4MDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJGQ1ZmZmOWIxLWRiOTQtNGE4Zi1hMzYzLTU3NDk3\nNGQwNjRlYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAzVtpXum+wRo5FspRxd\n+o7Ka7dSG5Avc8+ZhzeMjyN0FFirk08+g8oLTm1F6ynsLU5CVgCg5vqSu6lCsf+v\nPmejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSQHTqj+TYcyA3apAh3SLe63TXdDDAfBgNVHSMEGDAWgBSSCoy5kEx7dqC5IJnQ\nETR5OfALGzAKBggqhkjOPQQDAgNJADBGAiEAlw2OkHdGAyG0zDeU3x7tzDeY/XOe\nPLHMsSJ6uhYEjLsCIQDQlk4nLLDtBkSBsB7ToVT1uX0gHFJqact9TnBuvVr2Gw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAY6kW1DHDIsiGZUBTDSAwMABMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDM0YTVmMmY1LWUwNWYtNGY2Zi04OWFjLTUzNGE1ZjAzNWYyMTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDYwODJjMDEwLTZkMGYtNDc2Yi04NTUxLTA2\nNTM5NTFmNDQxYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMGV/5iNp06pq7l1\nWc7owh8vPfejzNIwHJfqViupwH680tlVx/hrHW9EtJJD1NdGoQaMZFEjhsws/9K7\n6Sn8gamjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRRfnhjbSZP2Aow3AivtU/2JRJSnTAfBgNVHSMEGDAWgBSivqPTcR4lHZim\nx402iQojKuzrmDAKBggqhkjOPQQDAgNJADBGAiEA4yc33Df+OXAESo5orns74yg0\n5nJ2UrnskLtSCdgz+4ACIQDUhZpkJWnGo77YratHSkQBWmQcCiSybdGp3YTM8eHx\nYQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAawHYow3zhl5Lk9wJlXzXOFFMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDM0YTVmMmY1LWUwNWYtNGY2Zi04OWFjLTUzNGE1ZjAzNWYyMTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDU3ODE3NWEzLWQzZjMtNDBkYS04NWYzLTRm\nZTVlOGJmMGQ4MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGCFnldak+bFd/aL\nnhv5Vs1B4KQcO/zux5Bj2617prYF4u7NhTpWpLmEFVRDoUnK+M1PT6BtoMP4Q9Qg\nnfZzoyijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSSCoy5kEx7dqC5IJnQETR5OfALGzAfBgNVHSMEGDAWgBSivqPTcR4lHZim\nx402iQojKuzrmDAKBggqhkjOPQQDAgNIADBFAiBkPEFXaBk2SGo81Ed/gtvvWYzd\n9t9LBn6Ht187kHYmgwIhAMdQRybYFk4uU8B+NAwZjXiNdJw6SnIMJGGeCrgTZQY0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYfRt5QCg6iE7Eexle43j4DtMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDc3\nZWY5ZGRiLWU5YTAtNDVkNS05YjBjLTk2YmNhYjJmZTRjOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJGQ4MzU0NmFmLWFkOTUtNDk2ZS04OTA5LWZmZTg2\nZTAxZjU3MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPGSckms1yAXdjNPpnrR\ny+wc22P9o87HcPrTHUyGKOf0Qi9YsJQXiNV0X343Ut2eILJvn51PHxWHCZn5LjlG\nTyyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR2nHMSj7MIYTIK8yJS9Ty3mrfaAjAfBgNVHSMEGDAWgBSeGf+XxKVyNAazM6Z+\nFlRmLN9EDjAKBggqhkjOPQQDAgNJADBGAiEA8kAf4QIWExz1FkF+WaIjq00gBEFS\n4Ss8pQnG6E1WMgwCIQD9JKQggzahJx6qh4h3L1Se9iNmh0TbEhuv7l6+o76hHg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAaxk6Ve+/hc/lEZqH1+04LwXMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDgw\nZGNjODYxLTUxNDEtNGIyOS1hYjZlLTk1ZGE1MTY5OWQyODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDhhZmM4YjIyLWZiZWEtNDFiZS05ZTA2LTc3OWQw\nMDAyNmY3ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPKwPjRhswHb0kjKM4DZ\ne+JE2S+AzLq3ly1Qy/z4JVOdSOizI1RrtTiXoGvPiVhoHOitmH5ge2XSZzWjlrqO\n6bijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTRiLDVlu/GQuuCK/E0A+is9iAb7zAfBgNVHSMEGDAWgBSBWucTlG1xkOdEizS6\nfiVk9aaWBTAKBggqhkjOPQQDAgNJADBGAiEAp9jTzhskA0xAkX7sTrKAL0XIzb+Q\nwpzyse2tLpbYCzcCIQD1FPQDMyZBxCettpxcoIILijyzdm9BfKxlFoPzIfBIZQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUE1CCrXU184JYM3h5svlP1CMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDgw\nZGNjODYxLTUxNDEtNGIyOS1hYjZlLTk1ZGE1MTY5OWQyODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJGQzNjQ2YTljLTk5MTYtNDUzZS1hZWI1LTZjN2Yw\nZDFkYjM2NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIinO0MTQ+uyx/M6RiTB\nhScv9NgV6pzpNb9KUFRaHfFom8xbAxMrhEQaNsrZa+bnSiemf9atFzNuADLBOjd6\nymyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSsiuIs9uesWSyZ/AoGkFLGnymizjAfBgNVHSMEGDAWgBSBWucTlG1xkOdEizS6\nfiVk9aaWBTAKBggqhkjOPQQDAgNJADBGAiEAy8aVXrpWWTJJX8CT/V1amN0PhPld\n6ydEx6pJlvG1aikCIQChHvQlS2ULWGPhOj3ZeGzmftV39zdV6XPlkdyg+TDccg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISASxNlOomowv0vOjvfINRbjV1MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGRhZjU4OGNjLWQ0ZGEtNDAyOC05Y2Y4LTA0NGY5MWE2MTc5ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDc3ZWY5ZGRiLWU5YTAtNDVkNS05YjBjLTk2\nYmNhYjJmZTRjOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIT6NzbcKd5dvWJn\nCP+fweSRVdXyD40poI4TSJgXhH1KVLW3Lx2crCckpXyYGzd8RpEfGivuvpQRfgmy\nRbMPveqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSeGf+XxKVyNAazM6Z+FlRmLN9EDjAfBgNVHSMEGDAWgBQ1Q/ceWX2sROjO\nCrsJwodaN/R0UDAKBggqhkjOPQQDAgNJADBGAiEAsGPlGZQQpf0kNCR70ty+pyn5\nJPogffkzGhP2zgvZLjsCIQDdWqnD08NnyuQ99wGw3J6K8Eho+26Pf/3FutlN93Tz\n/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZwlKIUYvZiPMOp8l0S905eqMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGRhZjU4OGNjLWQ0ZGEtNDAyOC05Y2Y4LTA0NGY5MWE2MTc5ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDgwZGNjODYxLTUxNDEtNGIyOS1hYjZlLTk1\nZGE1MTY5OWQyODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABC8xB9Mqfce4wK51\nxlYdbsgIPLihwRDMAggzhoqLvvQwWX+SZRXI1kXi4CO66grbbqvAdGCGvKRJGsjo\nqr7IxlKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSBWucTlG1xkOdEizS6fiVk9aaWBTAfBgNVHSMEGDAWgBQ1Q/ceWX2sROjO\nCrsJwodaN/R0UDAKBggqhkjOPQQDAgNIADBFAiBoNmHTzMVBrqqCr8GgzDdFNbUw\nq6mBLVO7WmxlFdubpQIhAPps9YjOONl2snUQbwsphWS9YFMZ/bm/gFwzFr4NAIQO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAf7DQ/NE1EReVqdMw7t5DWz1MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDBj\nZjVmNWNkLWM2ZjQtNDM4NS05OWFkLWIzOGZhMjBkMTVlMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGMxYTA0NDBjLWRiZDctNGYxMC04M2Q1LWYzMjUy\nMjdkNWVlOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAY4Cf4kTmpPQmtISRNd\n0iI5yjoctTtIKPelzesH6s2+DVpABVNoZiGpmfuQrJ7RzXzldBTyGglqMD35REim\noWujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTzHGAhZeLU7oejL+pntSfvCXwrBjAfBgNVHSMEGDAWgBS7Vw4fcA4gyNRTHbhT\neR78eQNgejAKBggqhkjOPQQDAgNJADBGAiEAwV6DecYXnMG+QdaawJLdcsBGTaBP\naFYix6utze/IzIgCIQCX+3uwtuP23IkyGthxhjUrAnv0hoiubSwzmBsllfhM5w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZMoBo9JZl+vMdQGX3roWFy3MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDBj\nZjVmNWNkLWM2ZjQtNDM4NS05OWFkLWIzOGZhMjBkMTVlMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJGQ1NTk4NGMyLWNkMGYtNDU0NS1iNmI5LWNlY2Iw\nNTBkZWQ2OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLQFmtS32bh8OuNhWFFK\nIVKFgdSmAHorU/mt46+r4tsm2xWIsktJfR69vPzsTLyHbmQIq9sL9KN6HvJcI36d\n82ajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS0PBP37k1juUbXwvm2TvUVtcGs/TAfBgNVHSMEGDAWgBS7Vw4fcA4gyNRTHbhT\neR78eQNgejAKBggqhkjOPQQDAgNJADBGAiEAiU+YdGAIjlsAqpQsXafxrD2voF9I\nXPqa+DjjLjyQ800CIQDUsRBfKsu7nwdh1D5ThRFg1UtNpgQnkrM4M3JbKc0U3g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcFWkjZ52rQtdjLCDD8DnMdfMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGE0\nNGNkZGNmLWU1NzAtNGU2ZC1iNDNjLTdjMDI4YTVmYTVkMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDBjZjVmNWNkLWM2ZjQtNDM4NS05OWFkLWIzOGZh\nMjBkMTVlMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKR7c0V+GxF3GjHdfu87\nNmNKAYhT6PnMOm8+3i9SVWMKuPdi1L2j2yfsa9J9vqVF5HESgDwu9VEJ+m2dERWQ\nHWCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS7Vw4fcA4gyNRTHbhTeR78eQNgejAfBgNVHSMEGDAWgBS4b4pEjW5dI+YRsfg8\nHg4DUB2kbDAKBggqhkjOPQQDAgNHADBEAiAK8+iM38p0WS+6DEPZ3GrAZQSBOhyl\nudgG/vjhKdUJTwIgT6kzMz5p/OPymPWxjGoibkJpgyiIld4DAHnlBTmKksk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQR2ibgv8+MqM7lIN3AyXrQHMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGM3\nYTNmYjhlLWQxM2YtNDVhMS04ZjYyLTBiYzI3Y2JjMzk5ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDBjZjVmNWNkLWM2ZjQtNDM4NS05OWFkLWIzOGZh\nMjBkMTVlMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKR7c0V+GxF3GjHdfu87\nNmNKAYhT6PnMOm8+3i9SVWMKuPdi1L2j2yfsa9J9vqVF5HESgDwu9VEJ+m2dERWQ\nHWCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS7Vw4fcA4gyNRTHbhTeR78eQNgejAfBgNVHSMEGDAWgBRUzK8n8RC4NTlSkup3\nHIDX6/NMaTAKBggqhkjOPQQDAgNHADBEAiB6+4I1mu1jYUy+iRa2Ca1vOhVM6mZF\n0GrxgLggXJRZ9wIgKardR3791+7EsGwVQLI59G/D8iVqRdhjW/S2OxrKL/w=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcON11zhMvU8r9mdzDwKyPD1MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGE0\nNGNkZGNmLWU1NzAtNGU2ZC1iNDNjLTdjMDI4YTVmYTVkMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJGM3YTNmYjhlLWQxM2YtNDVhMS04ZjYyLTBiYzI3\nY2JjMzk5ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOL88qkg8CWkyZvrPULs\nF5L01HBV1qgPfkH4hCUv1ZIj7GTikj9mEBkfQvtQDghV6TX/aUrrJHWlf4nHnKtD\n3o6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRUzK8n8RC4NTlSkup3HIDX6/NMaTAfBgNVHSMEGDAWgBS4b4pEjW5dI+YRsfg8\nHg4DUB2kbDAKBggqhkjOPQQDAgNHADBEAiAe274Kj8oNtozLhiRssFXSMJUCQR24\nih74hVNXzsn/EAIgfaj9D+KE9L0i9Oh+3StCgRpLG1zvfTL3RgA7lCHUchg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAamu9F1t/CAY1iqzzTwcGn52MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGM3\nYTNmYjhlLWQxM2YtNDVhMS04ZjYyLTBiYzI3Y2JjMzk5ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGE0NGNkZGNmLWU1NzAtNGU2ZC1iNDNjLTdjMDI4\nYTVmYTVkMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFro6Km5dwslnmWiACvX\nV7yFIT4zfsd93pylxmXcwUCQIU/4K9SjyP4xi4Rvbr4UlZUtzLIaaRyV6jV4LeC0\nMqmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS4b4pEjW5dI+YRsfg8Hg4DUB2kbDAfBgNVHSMEGDAWgBRUzK8n8RC4NTlSkup3\nHIDX6/NMaTAKBggqhkjOPQQDAgNIADBFAiEAkeNRfqkwUXkjtyVlviUxD17IInsh\nzs7Be0KNpt4m+ZkCIEvWpF4DfqnuOxjyPRzmS4zb/sH+iLpTEqr6GkEIV3S+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAbnl1vXzi+1jchh9tP4UnNgDMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGVlMzYyZTY4LWViNDAtNDI1Zi1hNTNmLTkwZDNhMTcxM2QzZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJGE0NGNkZGNmLWU1NzAtNGU2ZC1iNDNjLTdj\nMDI4YTVmYTVkMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFro6Km5dwslnmWi\nACvXV7yFIT4zfsd93pylxmXcwUCQIU/4K9SjyP4xi4Rvbr4UlZUtzLIaaRyV6jV4\nLeC0MqmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS4b4pEjW5dI+YRsfg8Hg4DUB2kbDAfBgNVHSMEGDAWgBRckAdlXlC9XeED\ns6ECZue17IiFfTAKBggqhkjOPQQDAgNIADBFAiEA+E9j24/G25kcVQ/5Oqgh15R0\n7SGwVDlvrznH4/v3xS0CIEvCJBp2RVZ0vECSJS8KPSdk4u8hXo906JL4LlF3tky7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZn8rTnJsQztdDF/2fjTVVtxMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGVlMzYyZTY4LWViNDAtNDI1Zi1hNTNmLTkwZDNhMTcxM2QzZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJGM3YTNmYjhlLWQxM2YtNDVhMS04ZjYyLTBi\nYzI3Y2JjMzk5ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOL88qkg8CWkyZvr\nPULsF5L01HBV1qgPfkH4hCUv1ZIj7GTikj9mEBkfQvtQDghV6TX/aUrrJHWlf4nH\nnKtD3o6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRUzK8n8RC4NTlSkup3HIDX6/NMaTAfBgNVHSMEGDAWgBRckAdlXlC9XeED\ns6ECZue17IiFfTAKBggqhkjOPQQDAgNIADBFAiAz5bvDUdCeLsYnu7KOPEAeAO6M\nPGZ9geFu6cof2BVh+QIhAIpczQqR3WxpGk52L95+8r5RYbmSygiF+N4rLL2xygIH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQgo7ClD9XKmH9KJTwQ55nGaMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJDdl\nYzRjZTYxLTlmNjUtNGUzMS1hOTIyLWUwYmEyZGNhN2Q2ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDcxMzIyNDhiLWUyNWMtNDU3OC05NDA4LTg3ODNl\nODlhMGE3YTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO8htG5jv7gKn+bcIyLH\nwsasNcooHefUIpYsYBNY71Pe5XWP3Jm9Ih9nVfbf2Qb8pZpxbCrQgH8RzdJWjnqc\nRsijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTC9JUqxaa4xX7kK47nAxp5oTCv9zAfBgNVHSMEGDAWgBTw7BwtOzLM2/UNYw6E\nf89dXxgyHjAKBggqhkjOPQQDAgNIADBFAiB8OT6MraW2d5iudkLsDaA8EbLDGm2o\nupu4yQxM+HuQUQIhAMGnt0EBkIRBS1psw5Nq24CQ/KEDan0R5eUlMEiVePgY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZl8c7gI0YDiKLt3qBP8BiuoMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDJi\nNWNiZDg2LWVlZmQtNDZmNi04NWZlLTQ5YjljNmZiOTA3MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJDdlYzRjZTYxLTlmNjUtNGUzMS1hOTIyLWUwYmEy\nZGNhN2Q2ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHnJXNKggXtzJPAQtS2r\n5G7YIEjJ3sP+374FKiEJF4Nq5TSZqBvn/NZ9DLveshf+lmRaCXXMnv60gNgRPHhg\nZVGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTw7BwtOzLM2/UNYw6Ef89dXxgyHjAfBgNVHSMEGDAWgBT9d+H/Df9DzXfmmb/D\nWF++NQfdrTAKBggqhkjOPQQDAgNHADBEAiBtQMq4KiQ5UeybPNDHS3sV0oXxIa/G\njoj2zZQRrhxFHQIgdNt6e4WQmi1Mpgv92aR2eK77zNyoffhntLd66qifZtI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAY3TUlBhMt8TzKtL8mz18QoBMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDJi\nNWNiZDg2LWVlZmQtNDZmNi04NWZlLTQ5YjljNmZiOTA3MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDI1NTZiYzRhLTU1YjItNGI0NC05MTcwLWQ5NWFh\nYThkM2I5MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGefmT9UJ58OQrD0ms09\niK+cjHxH1Q/nAgT0aljcZEeaT7hN2ZNNRUKhJaSIFXNFgqlUXjc+cNfZ5cPr2lyz\nFrmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRWUSwqYzb/62gHnbLEmpFo/LrJpDAfBgNVHSMEGDAWgBT9d+H/Df9DzXfmmb/D\nWF++NQfdrTAKBggqhkjOPQQDAgNIADBFAiAh7i1L+fz9B/LsEpkZp+A3weJfe15z\nsXbpFZxzY82bfgIhAL4tn5G9GRzaf8/GyZ9uybS0ajJDZ8/yNIR3gjCZhp36\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAY+l3dY9chj9YuGj7ZMIxnmFMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGI4\nYjcyN2FkLTI4MzgtNDM3NC1hNjRkLWQwZjk5MjllMzIwYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDcxMzIyNDhiLWUyNWMtNDU3OC05NDA4LTg3ODNl\nODlhMGE3YTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO8htG5jv7gKn+bcIyLH\nwsasNcooHefUIpYsYBNY71Pe5XWP3Jm9Ih9nVfbf2Qb8pZpxbCrQgH8RzdJWjnqc\nRsijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTC9JUqxaa4xX7kK47nAxp5oTCv9zAfBgNVHSMEGDAWgBTQA4x11jjGgalpNDsD\nD/H16GTWGTAKBggqhkjOPQQDAgNIADBFAiEArctHNgUnZmTLlwr4e6g3I/R8y23P\nDHU+yxmtyYfUleoCIHKHqteXKX1JLLXVM21IOvYIOBhNImEdR3Jxqyz64CEV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISARPYE/cRZrtEjLb/LmT45Q/yMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQyYjVjYmQ4Ni1l\nZWZkLTQ2ZjYtODVmZS00OWI5YzZmYjkwNzIwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAReX05i/kolxb7hXopLuT6tDvTFBzRQ8zuCJrg5fZc+8/y7dbClEz9n/5Tq\nIw2CGVAsIQf2Cq4k5lGrj3eZq+jGo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU/Xfh/w3/Q8135pm/w1hfvjUH3a0wHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgL5Zz\nj5p4DUt0j1UkDV3WluCqutRe35csuW27oCajjAsCIQCNUrsOgV/Ux1v/Rzx6YhsV\nSLSOq0MXW3MHmnz2aFCtug==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAR9Kn0Ir/39eh6EJ7CnzgzRbMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRiOGI3MjdhZC0y\nODM4LTQzNzQtYTY0ZC1kMGY5OTI5ZTMyMGIwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAASXqEaaMBjz5T1oxQRwADU8tiwvjtGnNf1Dkf77jpGo48Sdz+FrCJKknzvZ\njPef+FGr1zzMTwVTbXI8SbaeCsK4o2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0AOMddY4xoGpaTQ7Aw/x9ehk1hkwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAKfL\nPkN0HH3CSphh49mg2lSTkedG6IAUPuK8BOLJ6jx4AiEAwetd7jtQqby2L/Z5RkDV\ncymPPO+KDiZl0KoLRz0CvJI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYpf23RKLZDZcqhTDpy4OZacMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDM0YTVmMmY1LWUwNWYtNGY2Zi04OWFjLTUzNGE1ZjAzNWYyMTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMTc3MDI2ZTgtMjNiNy00ZWVh\nLWI3ZTgtMDc4MmY2ODA0NjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+LXf\ndJCqfJE6VrqIr+tPJRG7n0L7xE8n4JEA0GLMRgzTQF/twy527gjMWXBuhPXVWekZ\nqCIIUpReQPTnD0X5p6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFEAb7lq4cShX/hzkai0wpsIK8M2RMB8GA1UdIwQYMBaAFKK+\no9NxHiUdmKbHjTaJCiMq7OuYMAoGCCqGSM49BAMCA0cAMEQCIH4ThSWV9Iz5tne3\n5mGBQQhXRPQuebpI/f41+qHyZsZXAiA0AiqxLBy4rRy6Yi/ZmQlrAK2ctsnJilOO\nMwIcygzDdg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISASNmBdKxUuMwHd87dwsY0cf3MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMTc3MDI2ZTgtMjNiNy00ZWVhLWI3ZTgtMDc4MmY2ODA0NjhjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkMzRhNWYyZjUtZTA1Zi00ZjZm\nLTg5YWMtNTM0YTVmMDM1ZjIxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPtaS\nqF8kvG9ODj7qrcnT4xWbq1At5/UxUO9NvGtaTjwg5ctnmJc3F3+m6j6HiJzJj90D\nHwoX6akrBCrqxBw/raNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFKK+o9NxHiUdmKbHjTaJCiMq7OuYMB8GA1UdIwQYMBaAFEAb\n7lq4cShX/hzkai0wpsIK8M2RMAoGCCqGSM49BAMCA0gAMEUCICsXCbyPLhL0ave2\nt9tMPaMktcRY2m7ARCjoG831EJ7NAiEAih7W0kmj6KSXmVriFCygokj5uOK4SX1f\nz6d8MWgF4ro=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICOjCCAd+gAwIBAgISAVK01meEIMhLVdBN1FKWg3IuMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGRhZjU4OGNjLWQ0ZGEtNDAyOC05Y2Y4LTA0NGY5MWE2MTc5ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMTc3MDI2ZTgtMjNiNy00ZWVh\nLWI3ZTgtMDc4MmY2ODA0NjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+LXf\ndJCqfJE6VrqIr+tPJRG7n0L7xE8n4JEA0GLMRgzTQF/twy527gjMWXBuhPXVWekZ\nqCIIUpReQPTnD0X5p6OBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0TAQH/BAUw\nAwEB/zAdBgNVHQ4EFgQUQBvuWrhxKFf+HORqLTCmwgrwzZEwHwYDVR0jBBgwFoAU\nNUP3Hll9rETozgq7CcKHWjf0dFAwIQYDVR0eAQH/BBcwFaATMBGCD2JhZC5leGFt\ncGxlLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA7pECCZMnj+U/zJ4Dq+bRBVvUPThE\nw9zwIRFD5wO/w+oCIQCnUZ7ITMLjy51zJZtpntbbNN5v5wvS+l5eBVr9F0cBGA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXnpOG1K8kL8iYcxl7H1EHwAMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMTc3MDI2ZTgtMjNiNy00ZWVhLWI3ZTgtMDc4MmY2ODA0NjhjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkZGFmNTg4Y2MtZDRkYS00MDI4\nLTljZjgtMDQ0ZjkxYTYxNzlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJ7Nh\nBAtTOHj9gtiNWVst5b3u8XkRt6paTa35qn8iLwWBppbKNZ83252wnFAsGigtAYe/\nnKv4djARI4A9mmrAhqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFDVD9x5ZfaxE6M4KuwnCh1o39HRQMB8GA1UdIwQYMBaAFEAb\n7lq4cShX/hzkai0wpsIK8M2RMAoGCCqGSM49BAMCA0gAMEUCIQCQdU+vfyvhaina\nD5zMB8R9vUVk2zces34x3qSdsN993QIgM5O9szs97hnjZgChTHQLTHY3g7O4nssj\nMpTyr6ZTaKo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAeQF93V/0L4tngmLz5DYP00xMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGVlMzYyZTY4LWViNDAtNDI1Zi1hNTNmLTkwZDNhMTcxM2QzZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMTc3MDI2ZTgtMjNiNy00ZWVh\nLWI3ZTgtMDc4MmY2ODA0NjhjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+LXf\ndJCqfJE6VrqIr+tPJRG7n0L7xE8n4JEA0GLMRgzTQF/twy527gjMWXBuhPXVWekZ\nqCIIUpReQPTnD0X5p6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFEAb7lq4cShX/hzkai0wpsIK8M2RMB8GA1UdIwQYMBaAFFyQ\nB2VeUL1d4QOzoQJm57XsiIV9MAoGCCqGSM49BAMCA0gAMEUCIQDSypCmM0RpSKwR\nkakmJMnHmQ5w9APXxi7Z2zCW5RXYAwIgM/Now9HHC7bxFLmUuBJNNKz29q8+DwBk\nlgZB67DQFVE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAXG0TjMv+PHLmgipO0nMS7LdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMTc3MDI2ZTgtMjNiNy00ZWVhLWI3ZTgtMDc4MmY2ODA0NjhjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkZWUzNjJlNjgtZWI0MC00MjVm\nLWE1M2YtOTBkM2ExNzEzZDNlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdQUZ\n4O5nyDO/EwnK+LHtReJiolnqp2ce718fbpkH0XECmUm45gx/S8dtec9A2AhhXonT\nnfgiK0A9vzS1BYCM9KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFFyQB2VeUL1d4QOzoQJm57XsiIV9MB8GA1UdIwQYMBaAFEAb\n7lq4cShX/hzkai0wpsIK8M2RMAoGCCqGSM49BAMCA0kAMEYCIQCj8SuiNy2mL3jL\nW45XGYkdczrkpR3rPMJtkorzZRXYdQIhANXr9XOfXynxDAnHJItXF2B9IGN5VpUA\noiYt/FvZ5/co\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISATDDGzFANbS7o/YS3uci9OE2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDE3\nNzAyNmU4LTIzYjctNGVlYS1iN2U4LTA3ODJmNjgwNDY4YzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABPi133SQqnyROla6iK/rTyURu59C+8RPJ+CRANBizEYM00Bf\n7cMudu4IzFlwboT11VnpGagiCFKUXkD05w9F+aejYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRAG+5auHEoV/4c5GotMKbCCvDN\nkTAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNI\nADBFAiEAo7ckbUKnKKt3d2JspebyQrBZVLmiObTIF1B6rQLqvgsCIC533cqVgwFc\nlt3u3QiTYMDOMlVVNFk1iDSGxRYxONJG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcqgAwIBAgISAfwtXoZrMGvUpCOHaNIkgRsOMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMTc3MDI2ZTgtMjNiNy00ZWVhLWI3ZTgtMDc4MmY2ODA0NjhjMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBRAG+5auHEoV/4c5GotMKbCCvDNkTAKBggqhkjOPQQDAgNJ\nADBGAiEAukKt2rChni25XaqJei6t+DV8UoQVQsYNZQds2/PhKu4CIQDvBmeD8YYs\n+/W0ZU1d8I+I+yePbdjtOuhlNMYLBRM7lQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAfkMiepmDwrzQe9X6TH6JzPKMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDhh\nZmM4YjIyLWZiZWEtNDFiZS05ZTA2LTc3OWQwMDAyNmY3ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRiZmE2NTE4My1mOTU2LTQ2OGYtYTY2NC1iMjg5\nOGUwZDc2MmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARCUMiHZwu2KxQLq7Nk\npWb6dKaeTOGV47cxd0Np3M01mCXqUYNvHqJGNO268CN7FfvxetBMof76r0w2eZbO\nDj7qo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTRiLDVlu/GQuuCK/E0A+is9iAb7zAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgemrsnLYoNW1Eyv9V\nDed2G2qPRImgJMJ6GqRnX4tjJjMCIGpA4LQCI5wiyxVzXbQeZsOrTWGHXd+DI31l\nBFlSgu4I\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc65", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `65` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQ5RNJ4wBsRv+Jj1WucGsg30MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDMz\nYmYxZjU0LWI1OGQtNDJjZS05ZmZkLTM5Y2ZkOTE0MzA0YjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGI0OWZiNDMzLTFhZWYtNDhkNi05ZjliLWQzYmNj\nNTI2YTFhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGX7+KYgoTJm4+x1XMlX\nwO8ekkbrc83JZAhFyb5Lp8YkIDJSr4BdLtNrQpmIm9JYsvWKWXnaETd0+tHQoL1h\nNT6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQNlpsLE3bGY4mk79SCBqPd/la82DAfBgNVHSMEGDAWgBR0mh2zvyYyzsNXCnz1\nh2BrrXi65TAKBggqhkjOPQQDAgNHADBEAiB+g+N/GIUAtTywrV4iXaY9XMv5tSqj\nxCRmz6fiIh6EJQIgL5m3FNRg/0k5Gf/rTTwMh663irpkOYOjWkPom78Iz4M=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARdw0Q9+MUCGboaltSzyZRr/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDMz\nYmYxZjU0LWI1OGQtNDJjZS05ZmZkLTM5Y2ZkOTE0MzA0YjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDM5ZmI0ZjQyLWRkNzUtNDMzYi04ZjZhLTQ0NGE4\nOTU0ZDc0ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLut/KVXCoYUf19Uf+ur\n3zIQgRUUd2KONLhXy3+cmIoTgnwv1uId4ucAc5Im5I17emHO1kHH7E8RPCAXROXB\nlX+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTUNhQOsBjMTtLNyJ9k8ak4nO0KpjAfBgNVHSMEGDAWgBR0mh2zvyYyzsNXCnz1\nh2BrrXi65TAKBggqhkjOPQQDAgNHADBEAiBw+H9MpNPrwq3mK3hbY56/6NriJ15t\n87V5dYw0tJidmQIgZ6ZI95Jf0Sz9qJ1dxV02p0uZttsXowM7OR9RSDp8Fpw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAR6U9zXxXu2HqNl0VUN/Cmc+MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDM5\nZmI0ZjQyLWRkNzUtNDMzYi04ZjZhLTQ0NGE4OTU0ZDc0ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDMzYmYxZjU0LWI1OGQtNDJjZS05ZmZkLTM5Y2Zk\nOTE0MzA0YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCAcFHVkg8Cq2EaKqlDd\n7LujqFW+2P7D3PWKpKAqqVUB++Ffw9ckvHYKJFRJBGsRZI/7RTNzPcWwS1xrjIqd\nHFujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR0mh2zvyYyzsNXCnz1h2BrrXi65TAfBgNVHSMEGDAWgBTUNhQOsBjMTtLNyJ9k\n8ak4nO0KpjAKBggqhkjOPQQDAgNIADBFAiA3ZJeNFtE03FSZVPVCEXwmftOi2RVt\ntZ7iwDsRWmTjIwIhAKbdIqHEov8qUo+/Id2rNSHguuCLRXhhMX0CgRvtzj1u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdv1s/SlsAI167ipjgPjEpS/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJGI0\nOWZiNDMzLTFhZWYtNDhkNi05ZjliLWQzYmNjNTI2YTFhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDllYjUzNzQyLTQ2NTUtNDY3NS05YzQ3LTQwMmZm\nODZmNzdiZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKo5tQVh504o44oq+XIm\nu3OYAlkk/X7TIAmKaA9vWWjkVldPykVjrQptNJJntECtLmLlp+mFK6sdj5zlEehV\nRaijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRJwsTx7A4ezhyQFLw/BUtZouDeKzAfBgNVHSMEGDAWgBQNlpsLE3bGY4mk79SC\nBqPd/la82DAKBggqhkjOPQQDAgNJADBGAiEApViW752pxjn4ZFbda1nfD3FdF1WP\nbBwsQyBaD37l9foCIQDelNIZ7+Im0N+x2Z3MbbhMZfz2VBdJXeLYiu+wOTITxw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcfetbIPLGR50SOfCNdhsOfeMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDll\nYjUzNzQyLTQ2NTUtNDY3NS05YzQ3LTQwMmZmODZmNzdiZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGI0OWZiNDMzLTFhZWYtNDhkNi05ZjliLWQzYmNj\nNTI2YTFhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGX7+KYgoTJm4+x1XMlX\nwO8ekkbrc83JZAhFyb5Lp8YkIDJSr4BdLtNrQpmIm9JYsvWKWXnaETd0+tHQoL1h\nNT6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQNlpsLE3bGY4mk79SCBqPd/la82DAfBgNVHSMEGDAWgBRJwsTx7A4ezhyQFLw/\nBUtZouDeKzAKBggqhkjOPQQDAgNJADBGAiEArjSblpu54m24uliVF5JDIGknX/6z\n21a6S/CJZBWZCtMCIQDlcp+gdRKhqLeDZx06V7jO+i9gIO3g8ZkY8eBTXEnNbw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAaVvd1f/PjayGT7pz4flTM76MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDM5\nZmI0ZjQyLWRkNzUtNDMzYi04ZjZhLTQ0NGE4OTU0ZDc0ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDllYjUzNzQyLTQ2NTUtNDY3NS05YzQ3LTQwMmZm\nODZmNzdiZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKo5tQVh504o44oq+XIm\nu3OYAlkk/X7TIAmKaA9vWWjkVldPykVjrQptNJJntECtLmLlp+mFK6sdj5zlEehV\nRaijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRJwsTx7A4ezhyQFLw/BUtZouDeKzAfBgNVHSMEGDAWgBTUNhQOsBjMTtLNyJ9k\n8ak4nO0KpjAKBggqhkjOPQQDAgNHADBEAiBcuXww5WTflnK4J8wi+HUSiR9r/Dgl\nCYFOkNdptrBqHAIgGxO39XGxhmZZcxOz5/fIazIgE28ypU1e+thMbQ/f+nc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAeMClrVtLDWqIbwbT37QQFiWMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGQwMjEyYWYwLTZiZDctNDMwZC04NmU3LWI2MDZhZTlhYWRhYTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDMzYmYxZjU0LWI1OGQtNDJjZS05ZmZkLTM5\nY2ZkOTE0MzA0YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCAcFHVkg8Cq2EaK\nqlDd7LujqFW+2P7D3PWKpKAqqVUB++Ffw9ckvHYKJFRJBGsRZI/7RTNzPcWwS1xr\njIqdHFujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBR0mh2zvyYyzsNXCnz1h2BrrXi65TAfBgNVHSMEGDAWgBRn5BIlalEOWom+\nkNm9nBsYf16imDAKBggqhkjOPQQDAgNIADBFAiEAnQdEUrFpyV6IjsMoiF/jfzy/\nD/4/3Sn7mrNAtipu0bYCIFmufjATiGSoM0MtdaeQcAQHuYz3nPU6LIP0JdkWiym3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAWpqDewNm4Dv8CrOsknDfeFdMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGQwMjEyYWYwLTZiZDctNDMwZC04NmU3LWI2MDZhZTlhYWRhYTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDM5ZmI0ZjQyLWRkNzUtNDMzYi04ZjZhLTQ0\nNGE4OTU0ZDc0ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLut/KVXCoYUf19U\nf+ur3zIQgRUUd2KONLhXy3+cmIoTgnwv1uId4ucAc5Im5I17emHO1kHH7E8RPCAX\nROXBlX+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTUNhQOsBjMTtLNyJ9k8ak4nO0KpjAfBgNVHSMEGDAWgBRn5BIlalEOWom+\nkNm9nBsYf16imDAKBggqhkjOPQQDAgNIADBFAiAfQQVQJLgYa+BZfLGhrbAmlUpg\nv2CTduvPGS2X9DmI4wIhAL2fXxu/k9bq6WG1+VvDUaLNqutm47+d0yZ61bGMVTfX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXgV4EaleofSg7SIPCy1PvugMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDA0\nMzkyZjQzLTMzZDUtNDY4Mi1iMTBiLTQ5ZWM5OTlmYmZkZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDM0N2RiMWI2LTFlM2YtNDdlMy1iYTA5LTc3MmZh\nMGNiODBjYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFENv6aGHNNnEU3x1N/s\n7vuLgo89YNYlwXoGYFUYIx5HeVmDU2wRXW+4g6UYJIxbX56q78B5tHCnx0+k4UDY\nrGijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTGHajHaRF5uI8ovHaCnvIFLyEGZjAfBgNVHSMEGDAWgBQVkMjfzk+Gj9B8HoBb\nLDVGL1rTOzAKBggqhkjOPQQDAgNJADBGAiEA3rVXfK4lKQKXHuU02mmpjMzfvt4t\niYGbC4vdvPOy8s8CIQDYZlxSPyEb5Spc///xufs1PswxMHysKUZPGL/5DCDzkw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAaJWJD/AFOOcvJ+vhh95rRMLMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDli\nZGI0MzdlLTk3OWItNDlhMy1hMGRlLTQwZWY4NmE4ZWNiODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJGVkY2IzNDhlLWExMzAtNGM4ZS1hMmNjLTA1ODBh\nMjczZGIzNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM25a/TQJZQ4Ov4R5BMQ\neZRo8WhWzOnkgY7FYxm3MhgNgn3RHbFun1kBaf8L/2EwpU4qcZ+PhnppHe8zY1PN\nfV6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTzE4BuOiapvSGH6kVPoZKja4XC2jAfBgNVHSMEGDAWgBSl+GkV3ohf3SJUb8o1\nvNPhIPPbajAKBggqhkjOPQQDAgNJADBGAiEA9CWZt4e2McbZLLzm9X3vcV+YJn1c\nm5utZaEuFSoqzwQCIQC0CB4WtMUQxDlHYxLhVsYUerhe7TGsGRmv25VtuEjW4A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcIr2XdjRCGi2Wvmig/C7m7bMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDli\nZGI0MzdlLTk3OWItNDlhMy1hMGRlLTQwZWY4NmE4ZWNiODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJDEzNWQxMDAwLWM4ZDUtNDIxNy1iZDQ1LTUxNjQz\nMmZlZTY2ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPDnBWO8O8fmmD5lk8R3\nlYi/vMLKThcOJFjCIZHkR7vl3IPRcDk+tZSdAJWeGLkz8o9K1tpzc7JfgJj3FKU9\nhzijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTmPvv4oF55UH85hvarG3JpCg3VPzAfBgNVHSMEGDAWgBSl+GkV3ohf3SJUb8o1\nvNPhIPPbajAKBggqhkjOPQQDAgNHADBEAiAPifMGgYK4m2zpge8Rgfw2aXYEF0HW\nX0VDVjc+MwHRNwIgZ9eQG8OyRlCcoQOKfh8nw71wkcPQFKAwJiY7X5hS4jg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAS9XY+SPtxkAdA3QaBfaN2QcMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDExNzM0ZTcyLTkzZTItNDgyYS1hMDI4LWQ2ZGZmZGM5OWZjNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDA0MzkyZjQzLTMzZDUtNDY4Mi1iMTBiLTQ5\nZWM5OTlmYmZkZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFa0GJ7JmRZ8YXd8\nwSmyjCTihG9CegFD3yfz//TEGLPlz/EwN7FD1uwjCQov1cUxkUpIXaX5/9DUMdZS\nghZ5VQijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQVkMjfzk+Gj9B8HoBbLDVGL1rTOzAfBgNVHSMEGDAWgBRy3yMj19Q429Je\nVxsXfWU3qc9D4DAKBggqhkjOPQQDAgNHADBEAiA1STt7Q1mFnQR6i9rl2sdSJd8v\nsnQWyoMa0lDvOQdHpAIgfpsgpL1CPSnObd0NHvG/Z0R91ybA1ioUDGAU4cSG9T0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAYN/ZweZ1sQp5V3li6guGT23MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDExNzM0ZTcyLTkzZTItNDgyYS1hMDI4LWQ2ZGZmZGM5OWZjNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDliZGI0MzdlLTk3OWItNDlhMy1hMGRlLTQw\nZWY4NmE4ZWNiODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHn3tAGSgQQBX37S\noIA4x937uJHzsKA7MNvLpOy1zwIJbMdkNChZVdO0BpCu4vxd6zDMkiufs8piBacJ\nwGf8qImjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSl+GkV3ohf3SJUb8o1vNPhIPPbajAfBgNVHSMEGDAWgBRy3yMj19Q429Je\nVxsXfWU3qc9D4DAKBggqhkjOPQQDAgNHADBEAiBExE8nZh3iYm4TeAGJcIfK1LGP\ni6p6g7LSzZOUrO643QIgaMs2uBbEHenUItkmFg1R1hQQKyMKzJz0z+PFdzCgaNs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXpeWXJLsLpSgmlbOVYQTQHlMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDI1\nNWUwN2JiLTUwNDEtNGQzMi05MzVmLWI5MGZiMTFhZjliMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGFiZmFmZTlmLWVmNDAtNDk0Zi1iODU3LWFjMzdi\nMDExY2Y2ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEF5ia4P2w3ltK9Mjfbi\nAX+ncMbXTFCeKGl48o3MBHhZaF0yLbd67an+YbYuerpTRvp8TZ6QYoTOsYQitFIC\njv6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRjDHIMwTemippCmVDGE+/WJWIHnzAfBgNVHSMEGDAWgBTOTxTRZMSQfT1Rykhz\n1zN1ND5nnjAKBggqhkjOPQQDAgNIADBFAiBzztTyBvOkptdaRV9Wcxw+RQpRY9r/\nTgZYbpP096/bWwIhAITbbFKfIjK20nfoobfFiIuwoJwRjGllqQCx7OKq2JB3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaiLDoLuHuA9S6/DsZOEJW1EMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDI1\nNWUwN2JiLTUwNDEtNGQzMi05MzVmLWI5MGZiMTFhZjliMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJGZhODVlN2UzLTE3ZjUtNGQyOS05ODVkLWEyNWMx\nNDA2OTljYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO0y1Bpz55PzmB07zgsq\nXohBUPqfDKAitjCwXda3ukU1xW3N/SmJfahwHP2Jr1a/PdPcBdhk9AIbrBz4zrgH\n+LCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ4vASVJZTIx1XZ3sB/qdwdpalwzDAfBgNVHSMEGDAWgBTOTxTRZMSQfT1Rykhz\n1zN1ND5nnjAKBggqhkjOPQQDAgNIADBFAiBTVjh5RpVYFyT+o0yX93gQ9kq+tMRE\n7NhT9t3vtk/5uAIhAPOAKOaeiOA+K9ZAwQqwgRecqSmfviKXU2nbUiYTLVPK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVtmfOV3loBu4z1HNYrYN1dhMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDdk\nMTljYzIxLWEwM2UtNGMwOC1iZWJiLTg4MjhkOWUwNTFmYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDI1NWUwN2JiLTUwNDEtNGQzMi05MzVmLWI5MGZi\nMTFhZjliMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKnnjiATXisn+NlAVz+p\nFDc2jdQI7MaPavQFd+2Yo24QpYkz0rzsAfqPeC8kZ7dG5BhfrvkNidIt4mu3Kl2D\n0FujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTOTxTRZMSQfT1Rykhz1zN1ND5nnjAfBgNVHSMEGDAWgBS1ogP39WgbY2otqxBA\nncfy7AY6BDAKBggqhkjOPQQDAgNJADBGAiEAqzP75FgN19/SmNJSyF5+Y5uHcid+\nTIrYHd44OeUY2AUCIQCTuEw2skXre6hfy9jEE5XJvCjyJwW3LNbneJvikj7+7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZhfCyHXTXGMtx3VThkeDKoXMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGMy\nNjhiZmYxLWVlYjAtNDM4OC1iOWMyLWQ2NjVlNGEwMTVhZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDI1NWUwN2JiLTUwNDEtNGQzMi05MzVmLWI5MGZi\nMTFhZjliMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKnnjiATXisn+NlAVz+p\nFDc2jdQI7MaPavQFd+2Yo24QpYkz0rzsAfqPeC8kZ7dG5BhfrvkNidIt4mu3Kl2D\n0FujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTOTxTRZMSQfT1Rykhz1zN1ND5nnjAfBgNVHSMEGDAWgBS3OmVMxOpYzBxbc5NT\nW3lFc5LssjAKBggqhkjOPQQDAgNIADBFAiEAslUYuKFI3Xng/W4QqAkv+hRLbpGG\ncZymY8E1c/uEcQ0CIGerkFmmpnNgAjSCOo+1Bxk8thy9gcgbHA082un/KytL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAe99l4vsed9/FIQ4W7hKG0O2MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDdk\nMTljYzIxLWEwM2UtNGMwOC1iZWJiLTg4MjhkOWUwNTFmYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJGMyNjhiZmYxLWVlYjAtNDM4OC1iOWMyLWQ2NjVl\nNGEwMTVhZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEyNianaa4xyS0GEEi1n\ncf05hR1kgjY//QI80witwJ4xJg/sjGOU0EA+DeRYfZ4GgvpQM1xzczffkoo2qTST\nGbqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS3OmVMxOpYzBxbc5NTW3lFc5LssjAfBgNVHSMEGDAWgBS1ogP39WgbY2otqxBA\nncfy7AY6BDAKBggqhkjOPQQDAgNHADBEAiA04NgSE67A5uPv/GngWlgnCQrT9MNN\nCAp2K8hYAV1uYAIgdn78G/K27ylZUoWxYokME8fcaex2wG+h7uvqGpe1qkQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZhCACxHhIMUU6vragqDXgr7MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGMy\nNjhiZmYxLWVlYjAtNDM4OC1iOWMyLWQ2NjVlNGEwMTVhZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDdkMTljYzIxLWEwM2UtNGMwOC1iZWJiLTg4Mjhk\nOWUwNTFmYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIgck5Fh7K/sGvgN3O8S\nzqPPttfQxzrhZueF96p2cDtYERYftJbcYaGUSIbZQNP2WisvEeUsLkIWFgp8G40k\nCI6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS1ogP39WgbY2otqxBAncfy7AY6BDAfBgNVHSMEGDAWgBS3OmVMxOpYzBxbc5NT\nW3lFc5LssjAKBggqhkjOPQQDAgNJADBGAiEAk4oWnj0u9LFlzjUy0Ky+ZS5qalYC\nnOcEwspJfECyxksCIQCeiRaPDnT2wydjO3zNm8AOvYvUXfCTEHzzdRhOJxhq/w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfDZ9+kYCQtH8EMXm18FnJhfMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDk5ZTAxMWEzLTlkZTEtNGI0MS1hYzIyLWQ4NWEyNWE2YzBmYzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDdkMTljYzIxLWEwM2UtNGMwOC1iZWJiLTg4\nMjhkOWUwNTFmYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIgck5Fh7K/sGvgN\n3O8SzqPPttfQxzrhZueF96p2cDtYERYftJbcYaGUSIbZQNP2WisvEeUsLkIWFgp8\nG40kCI6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS1ogP39WgbY2otqxBAncfy7AY6BDAfBgNVHSMEGDAWgBSe7RAiAmRKgOXS\nWPkcnfDAHhCEUzAKBggqhkjOPQQDAgNIADBFAiEA/1hfVx5/HXMyrslSqhzNQ+2O\nVFPfzeWxIXQONjWQp+ACIC1Nu9Xe/qML+xEgLGqWMPD74iNL/YNfglD9oNft+ti8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAUlyDwa7OJ7gVjmKKoT2z3KfMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDk5ZTAxMWEzLTlkZTEtNGI0MS1hYzIyLWQ4NWEyNWE2YzBmYzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJGMyNjhiZmYxLWVlYjAtNDM4OC1iOWMyLWQ2\nNjVlNGEwMTVhZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEyNianaa4xyS0GE\nEi1ncf05hR1kgjY//QI80witwJ4xJg/sjGOU0EA+DeRYfZ4GgvpQM1xzczffkoo2\nqTSTGbqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS3OmVMxOpYzBxbc5NTW3lFc5LssjAfBgNVHSMEGDAWgBSe7RAiAmRKgOXS\nWPkcnfDAHhCEUzAKBggqhkjOPQQDAgNIADBFAiEAl/92moqidcVZJt6AZuk5Tzoj\nL2boYLmiEnc0ZB98ZAQCIHv4+8Y7woGervQ6Fzxxud31D7SD95n+BTp4pxC2N8tw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAV+UfpeS/Rjal9NTEeG0hzd4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJGJj\nMzNmOGY3LWNkZmItNDA2Zi1hMWZiLTlhYzYwZjY3ZjY4ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDcwMTYzYTAwLTI1M2YtNGM2Zi05OTExLWUzMDZi\nZmMxY2JlMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM/APz2bGFGF1cEzVYmG\nZvAYpbOsJBfBBjnB437EN7etWV3sXRbDLfjnVNa2Bkya5fv6EyGbqNOvZ3XDSsoY\nevqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQXOws8cDzgbhvHAdKGGM/zK0n+hDAfBgNVHSMEGDAWgBTWqEmGwtEz1uKwPJdn\npqfDWuzPATAKBggqhkjOPQQDAgNIADBFAiEA2JC2auMDBX3i6l31xflOIJJU4dcX\nLvxstx+x7Gj41OMCIAO9wKx+GEUjNvDjfnPqDPDrXVQVCPEAl712BxssRubx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa80+tsOLfm0u7o82G15+TlQMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDk4\nMDg1OTQxLTlkOTgtNGM0MS1iOTdmLWIwMTZkNmMxMWJjMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJGJjMzNmOGY3LWNkZmItNDA2Zi1hMWZiLTlhYzYw\nZjY3ZjY4ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEftmb384Odwyq3Y4ErE\nxCwbqBD3z7E2bC2muz9aRXKydffyjx0uLu+GIM/GToUJ8ZnorZibC7vRqZOd5R3y\n2gqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTWqEmGwtEz1uKwPJdnpqfDWuzPATAfBgNVHSMEGDAWgBRQK1wXRi8lJMlFYvCa\n14fU+hZP2TAKBggqhkjOPQQDAgNIADBFAiEAogY87nJQxxSZZ7lf+fVW3zo02vAw\nqbxO/UfHFh04e6cCIBdrb77e9ejbECkQ/eM8XsURkwYTyXiZ+Cs2YNpF4fzG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQ6Mxj0GGKqApKL9HuUcCxSJMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDk4\nMDg1OTQxLTlkOTgtNGM0MS1iOTdmLWIwMTZkNmMxMWJjMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJGVhNDRmODIzLTQyNTQtNDAwOS04MWRkLTU0OWJi\nNjE2MjlmMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABI/c7Q9xUtP5kIZ3fRa7\nFVfHMG0MGkRdAjFzrfngNk2B0D2pxdi4voTrLDexyjozovJs3LrmY2q+zbvBZR/P\ngz+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSFZ7htqoWFxqn6EZkuZw3jwsMSbDAfBgNVHSMEGDAWgBRQK1wXRi8lJMlFYvCa\n14fU+hZP2TAKBggqhkjOPQQDAgNIADBFAiBHPiyErh5b0WQ7HOr1oLm/jmLUnCca\n7nxY9uBLpEVsMQIhAKYMfzdlRCJKl5NL3i+AuGTUUBGkBseGnQRCyJ1lfQHF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATVOmpW9dgsWyLAzqvFKvDqnMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGUz\nYTExNjk1LTRkNDktNDY5Ny1iMDg1LTM1NmRmMTFjZDhjZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDcwMTYzYTAwLTI1M2YtNGM2Zi05OTExLWUzMDZi\nZmMxY2JlMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM/APz2bGFGF1cEzVYmG\nZvAYpbOsJBfBBjnB437EN7etWV3sXRbDLfjnVNa2Bkya5fv6EyGbqNOvZ3XDSsoY\nevqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQXOws8cDzgbhvHAdKGGM/zK0n+hDAfBgNVHSMEGDAWgBQRv8JGA/sLVsnzmUXx\nE5Ad6irA5zAKBggqhkjOPQQDAgNIADBFAiEA3dnciPf0b0LbUutoQQcB+YwDi1Sp\nd4iQ8D5TcHbJAFgCIAEe/SGLPP6HdxxGKRwzrFU8ZHyuJL1+C5Q/JNlnWS7j\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISAdLly5cw5dzWyw3f22HNgP2lMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQ5ODA4NTk0MS05\nZDk4LTRjNDEtYjk3Zi1iMDE2ZDZjMTFiYzAwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAT8Ufvmawr8+0CVtsRo1NbQZWyStMvl1aS0Vqjl85Le6EDPz1eCg5dAGxtr\nLKkcz+kQS70cj1zUdBlI5cvncACpo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUCtcF0YvJSTJRWLwmteH1PoWT9kwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgLz69\nfxnrn+Tx10jVC4zhnNfMXf3VO9nHWAIIwJS1LxkCICt3DNQcxzI9sEId9iB8g8ai\nY1NpD0P/rQnZojZhd/g1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAeOVv5OYf/YuSVIiJIuHOLZ0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRlM2ExMTY5NS00\nZDQ5LTQ2OTctYjA4NS0zNTZkZjExY2Q4Y2YwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATspqwR83QkRXTv+pNNFr2ntXn7E9QTW6CL0gGjtpnjlH9+vur4KW+ca5af\nkUIcUZYqy3X1X2J/rbmSSmAg21o8o2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEb/CRgP7C1bJ85lF8ROQHeoqwOcwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAK64\nr6abMUnDdG1IADC9u/lvO3feQVfrlwCZswaIiX7dAiBOnTBvFCzpa4s7l2QqwsML\nQSmPjcgw0AhmA2Hy1cqWDQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAcQbMIriTFIfI0iOPNOQna6oMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGQwMjEyYWYwLTZiZDctNDMwZC04NmU3LWI2MDZhZTlhYWRhYTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNGFhOWFiNzMtNmQ5Yy00ZDEx\nLWFmNDItNjU0ZjQxZTY0NDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEcBS\nt2HxJQT7dNssu3qB7hzt3PAkPOCaQXy71rqZ6ABIDpuy/pIElmOzXKOYqUywIFPO\nr9dyVmCogxBLEKhKs6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFG+zv2kafXl+6RtXQNBU+J7lQMmnMB8GA1UdIwQYMBaAFGfk\nEiVqUQ5aib6Q2b2cGxh/XqKYMAoGCCqGSM49BAMCA0kAMEYCIQDLR8zz24R6Q6F6\nZVtIY4JnrL3PJndB+XmgV00a8jp7TAIhAOv5YZw2NyR3JIqxtdhkHve/1REjSRGo\nqCZbqhEbpzYF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAWEGMaUAnguFkxkPCROYY/OvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNGFhOWFiNzMtNmQ5Yy00ZDExLWFmNDItNjU0ZjQxZTY0NDE2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkZDAyMTJhZjAtNmJkNy00MzBk\nLTg2ZTctYjYwNmFlOWFhZGFhMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEndtJ\n1lrR7FozhNlrGYc3d+BRZgdShA8/pWP1p4RQgJyQlXw9nqyiJAb/H+q9iADrrkAC\nEDXPb87zZaIRRLxxI6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFGfkEiVqUQ5aib6Q2b2cGxh/XqKYMB8GA1UdIwQYMBaAFG+z\nv2kafXl+6RtXQNBU+J7lQMmnMAoGCCqGSM49BAMCA0cAMEQCIDPr9rDqe3p63I85\nQga/VaoDATaY7tBphmVWE6SqdvJiAiBFScHNT0uslJklkfQFv1Bs9DRps2g801SL\ndHv0tps+AQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICKTCCAc+gAwIBAgISAR+2fw5lNcUOfwwYp1j0dENKMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDExNzM0ZTcyLTkzZTItNDgyYS1hMDI4LWQ2ZGZmZGM5OWZjNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNGFhOWFiNzMtNmQ5Yy00ZDEx\nLWFmNDItNjU0ZjQxZTY0NDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEcBS\nt2HxJQT7dNssu3qB7hzt3PAkPOCaQXy71rqZ6ABIDpuy/pIElmOzXKOYqUywIFPO\nr9dyVmCogxBLEKhKs6N4MHYwDgYDVR0PAQH/BAQDAgIEMBMGA1UdJQQMMAoGCCsG\nAQUFBwMEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFG+zv2kafXl+6RtXQNBU\n+J7lQMmnMB8GA1UdIwQYMBaAFHLfIyPX1Djb0l5XGxd9ZTepz0PgMAoGCCqGSM49\nBAMCA0gAMEUCICmrPAZfV5jbHx126oUANsI+qnSft9jKMr+iU1q0GxbFAiEA3e/M\nHN9lTFwcU+3nzxspVsW9HTESI1QMMIR/39Ft/C8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAb0BrKA4BqejP8eeqXgXBI8rMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNGFhOWFiNzMtNmQ5Yy00ZDExLWFmNDItNjU0ZjQxZTY0NDE2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkMTE3MzRlNzItOTNlMi00ODJh\nLWEwMjgtZDZkZmZkYzk5ZmM1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5jS9\n7hf7HeCtP1bYhLQINpd51IjCxEK6enPlCt7QiEtdJ4sclaYDavZOHvQl8r7NIHpJ\nu99TngAYe+B6PW6M4KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFHLfIyPX1Djb0l5XGxd9ZTepz0PgMB8GA1UdIwQYMBaAFG+z\nv2kafXl+6RtXQNBU+J7lQMmnMAoGCCqGSM49BAMCA0cAMEQCIDFuU6xlRJ18wiJF\ni7vIKmAaGr7Y6zbP6N7vuPHUgxZSAiAjn6s7AOWEvpd7XfdhQcftmFZvDlrkkGBm\nGlQttdcJPA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXskUT8gTAiaxdPpAEdtjAtQMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDk5ZTAxMWEzLTlkZTEtNGI0MS1hYzIyLWQ4NWEyNWE2YzBmYzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNGFhOWFiNzMtNmQ5Yy00ZDEx\nLWFmNDItNjU0ZjQxZTY0NDE2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEcBS\nt2HxJQT7dNssu3qB7hzt3PAkPOCaQXy71rqZ6ABIDpuy/pIElmOzXKOYqUywIFPO\nr9dyVmCogxBLEKhKs6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFG+zv2kafXl+6RtXQNBU+J7lQMmnMB8GA1UdIwQYMBaAFJ7t\nECICZEqA5dJY+Ryd8MAeEIRTMAoGCCqGSM49BAMCA0gAMEUCIQD3WeGZwh+o8SU5\n4sY3/g7J79QHCXTsbnoq3ee/49MZcwIgJqrg9Ypbge7HdUGG1n7S8SoDDA2zlLfq\nAwz2gaK8BbA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAexXMtkLu8S+gX6M6KBNVIZVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNGFhOWFiNzMtNmQ5Yy00ZDExLWFmNDItNjU0ZjQxZTY0NDE2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkOTllMDExYTMtOWRlMS00YjQx\nLWFjMjItZDg1YTI1YTZjMGZjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEyR8Y\n4vEBg1E0aDxbE/7vKQS9rO0KtJlARWCkI7CeDNDrEtNW4Bisk5fy1ii22ErWcMy0\nZKKrtYevJ6sML7ZV+6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFJ7tECICZEqA5dJY+Ryd8MAeEIRTMB8GA1UdIwQYMBaAFG+z\nv2kafXl+6RtXQNBU+J7lQMmnMAoGCCqGSM49BAMCA0kAMEYCIQCZgnM3byjvYrzR\nA0boIFoVlI6sZJd395Z22ONvHnGzBQIhANEo8I7Y3Wwn6dQJs+vhaNgVNKArrQeV\n6QEDcdL9BQSo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAZ1GxW1TfkcICXgGRrSIWxHYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDRh\nYTlhYjczLTZkOWMtNGQxMS1hZjQyLTY1NGY0MWU2NDQxNjBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABBHAUrdh8SUE+3TbLLt6ge4c7dzwJDzgmkF8u9a6megASA6b\nsv6SBJZjs1yjmKlMsCBTzq/XclZgqIMQSxCoSrOjYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRvs79pGn15fukbV0DQVPie5UDJ\npzAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNI\nADBFAiEA8jsY4ARV1dS0e/zI0vhclW0PZoWLV2WHaiW4MpCn/7ECIEVdzQUwkl/5\nHpYNkaA7lQfN4qly7dwhBDBW1z8XvgWy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcqgAwIBAgISAUP6FDfAeb8wc+z0YuRAGU+lMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNGFhOWFiNzMtNmQ5Yy00ZDExLWFmNDItNjU0ZjQxZTY0NDE2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBRvs79pGn15fukbV0DQVPie5UDJpzAKBggqhkjOPQQDAgNJ\nADBGAiEAmI0ukmJc/MzdYGxveETZtcUt4QCXGk85/Sam2hI4rdACIQCD8qfcl1Kt\n9uaETzbcHDvEtqE7lMPWHCUblCBlL5hMJA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAaa534VGmznBxP8nqeTKAd/YMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJGVk\nY2IzNDhlLWExMzAtNGM4ZS1hMmNjLTA1ODBhMjczZGIzNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRmZDRmMTU3Yy02OWRiLTRkYTUtOTc3Zi1mY2Vk\nMmQxZjM0YWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATRRLUGfvqRheI3pmY6\n+pXnRayG+jMzcYLydMFPzWHUz1pkPqYULLCcSYi8EkCPHO6wQgHDamhi5X3VZyuH\n4HNlo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTzE4BuOiapvSGH6kVPoZKja4XC2jAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAMMrVNF47NmqYc7k\nzuF5v5XYDx7ljj+5F49T6DtPDgzvAiEAvrELFa/Kr6hbTTgY7+fNTuQuY4ucw2l1\nMpxTofCGVh0=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc66", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `66` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWyg0GXwOEVWq2cV39xcedktMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDZh\nOWMxOWMyLTRhNDctNDY2ZS1iYmNhLTdlYmYxNTEwYzdkNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGU5MTljMjMxLTc3MzctNDdjNy1iZDRiLTU3NzYx\nMTEwZTI4NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG0wi9IW2ZQOG+7AwRh3\nj2vM6htRO/0JC4RV9UuX59LT8ZcGaubYeRe8vKr6L/6wdN+3/88Jv5Kb07umMXpz\nwMijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSwaTzNTcREFzHJEm2PcW67Ki6k5DAfBgNVHSMEGDAWgBR+o/hJVxReGAnbKSfL\nelKWksjC0jAKBggqhkjOPQQDAgNIADBFAiAecTdxd96yYURX3GGISJqyDkf84N1y\nKnNO8LMBwttXxAIhAJPgqSVdKmqLodazEDnHOXL4VPv5+sYyb/WSrLTGKnF+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAT/bCLSxvwPlQndHipOIhBWsMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDZh\nOWMxOWMyLTRhNDctNDY2ZS1iYmNhLTdlYmYxNTEwYzdkNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDMyN2Q0ZmU5LTliMDAtNDgyOC1iMDYwLTNlZGJj\nNmNhYTdjMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHKSou2WzXJ1wKlXn1a6\ngdrbMXw7UzFfiou89da8FPK5XKxIoczerfH7Eeyz1Mxo6QumFqhMcw4ZAxilOPEC\nNAujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTgs14VAv3eSd8mk63MMML13CB92TAfBgNVHSMEGDAWgBR+o/hJVxReGAnbKSfL\nelKWksjC0jAKBggqhkjOPQQDAgNJADBGAiEAwLVb1i5OS3qN0/0Coqb8pXh6k/8z\nnYwiWJmNRfPEuRYCIQC9Q0diwiXwsTdCuyXdFvBrE1Dbrw0T8z7frw+NPlytsw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa/a1h0j5Dln3ey4B3W8FhZtMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDMy\nN2Q0ZmU5LTliMDAtNDgyOC1iMDYwLTNlZGJjNmNhYTdjMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDZhOWMxOWMyLTRhNDctNDY2ZS1iYmNhLTdlYmYx\nNTEwYzdkNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM+D9nm4k1Ec7Jm2n3t3\n2JGvgxIQtyDKBFnw0Wwx6sVMwAsw06BIzBG8F3EPBKHkUp/mM6jrIkTy/Aj/iovB\nQUajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR+o/hJVxReGAnbKSfLelKWksjC0jAfBgNVHSMEGDAWgBTgs14VAv3eSd8mk63M\nMML13CB92TAKBggqhkjOPQQDAgNIADBFAiBOM+U41u+ijSGaSjVRa2oyFBm7Xb09\ne7ikXA3XvCiJrAIhAOXNKU+yumoJZnvDqYDOzusnhNPxEvaWRQ+6jzABvSBp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARfEeaFdxvHYadGV3R1KMockMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJGU5\nMTljMjMxLTc3MzctNDdjNy1iZDRiLTU3NzYxMTEwZTI4NjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDdkNWYxNDczLTA3MzctNDY2Yy1hZTJlLThmNDNi\nZTIzNGFjZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLNu5MeQvl/Mg4w1u3l0\n0V+vg2XDNOQt/0e51sRF+l78Zh46B7ZVx5e5JKtemKV+FsHFZyaKR9ArLQa2bZQ+\n42qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR4O7L9AoeKih/a+04GvcB5gLVBIjAfBgNVHSMEGDAWgBSwaTzNTcREFzHJEm2P\ncW67Ki6k5DAKBggqhkjOPQQDAgNIADBFAiEAwwb4q41ycyqpbDve89nGtM3M3hye\nLcr1E9Z2ZoorGKcCIHvRsR2UBhmXDYVIsoDpLTFDgo3vdjRUrCTwRcardCiU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcEWIL+VfGNaQOWO3SdGB1fzMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDdk\nNWYxNDczLTA3MzctNDY2Yy1hZTJlLThmNDNiZTIzNGFjZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGU5MTljMjMxLTc3MzctNDdjNy1iZDRiLTU3NzYx\nMTEwZTI4NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG0wi9IW2ZQOG+7AwRh3\nj2vM6htRO/0JC4RV9UuX59LT8ZcGaubYeRe8vKr6L/6wdN+3/88Jv5Kb07umMXpz\nwMijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSwaTzNTcREFzHJEm2PcW67Ki6k5DAfBgNVHSMEGDAWgBR4O7L9AoeKih/a+04G\nvcB5gLVBIjAKBggqhkjOPQQDAgNJADBGAiEAlgq2eUjVxwpY+7HzBGM3q5f3CsWq\nA1ExKekbgewqxm8CIQCKBoV9zVH56E41wyEQ3//LYSNhdobP6icDn7v4vgWi1A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWcuCnzy74QzUkozhFXcyx2uMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDMy\nN2Q0ZmU5LTliMDAtNDgyOC1iMDYwLTNlZGJjNmNhYTdjMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDdkNWYxNDczLTA3MzctNDY2Yy1hZTJlLThmNDNi\nZTIzNGFjZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLNu5MeQvl/Mg4w1u3l0\n0V+vg2XDNOQt/0e51sRF+l78Zh46B7ZVx5e5JKtemKV+FsHFZyaKR9ArLQa2bZQ+\n42qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR4O7L9AoeKih/a+04GvcB5gLVBIjAfBgNVHSMEGDAWgBTgs14VAv3eSd8mk63M\nMML13CB92TAKBggqhkjOPQQDAgNIADBFAiEAwbWHvKHpbljWT5QRXEtJX0fAMonK\nsYkwAAMKB8yUi9gCIDMJh/cHxHyHGwbzdF3pu0Wx49BwBWmdObYDRZVtZHNy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAT/IPh2oRHFV17PxD04Ni0vjMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDlkYmVmMjc1LTFjZDUtNDcxZC1hNzBlLWU0N2I1NTk3NzU2MjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDZhOWMxOWMyLTRhNDctNDY2ZS1iYmNhLTdl\nYmYxNTEwYzdkNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM+D9nm4k1Ec7Jm2\nn3t32JGvgxIQtyDKBFnw0Wwx6sVMwAsw06BIzBG8F3EPBKHkUp/mM6jrIkTy/Aj/\niovBQUajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBR+o/hJVxReGAnbKSfLelKWksjC0jAfBgNVHSMEGDAWgBRPv+T1vHRszy1m\nX7KYtAukCOGIEDAKBggqhkjOPQQDAgNJADBGAiEA+4y0hVgARz+nx4mbWOfn3/r8\nhJxfmIOrRTTFd+w/bdcCIQDEWsqrQQpk3MeQPn//KFcY2tMcQccw69kIfNVtiPCw\noQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISATGnROlUhOC8z8OtccoQ2WLlMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDlkYmVmMjc1LTFjZDUtNDcxZC1hNzBlLWU0N2I1NTk3NzU2MjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDMyN2Q0ZmU5LTliMDAtNDgyOC1iMDYwLTNl\nZGJjNmNhYTdjMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHKSou2WzXJ1wKlX\nn1a6gdrbMXw7UzFfiou89da8FPK5XKxIoczerfH7Eeyz1Mxo6QumFqhMcw4ZAxil\nOPECNAujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTgs14VAv3eSd8mk63MMML13CB92TAfBgNVHSMEGDAWgBRPv+T1vHRszy1m\nX7KYtAukCOGIEDAKBggqhkjOPQQDAgNJADBGAiEA6TxzCYjjlSHAd4sbSLGmGkhH\nvuwfvzYlED/Gf/Xhl58CIQCJsunJeYKI++/FLYam44YmoIc6HNDGu87YJqoHH9aM\nxg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeFhjXXY1pyz7+wGQyXx2gZLMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJGZi\nNWExNjI3LTM5ZjYtNDhhOS05YzEzLTk4MmEwMjg3YjJlNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJGViMDZlMzAwLTY4NGItNDE3MC1hMDIxLTBiMjMz\nMmRlMDI2NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPJPm0120pBTNo7WzN+z\nLO3UlkXo/pObuRSNbtghvfPNCZ/g43fGc/6XNYcexFXTpujRWPoVrMpmWanI4DPe\nO76jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQl5p4aq4KWBiSnBB/Dqr8pMD85YzAfBgNVHSMEGDAWgBRK0NwgDs0xlLZUuZdi\nrMTxhu0vtDAKBggqhkjOPQQDAgNIADBFAiEA6Qf32YYIDJfxYqTeXO9BsikJSIaJ\nEmbSnMRH8FxCwr4CIC8d8fIF6d2sjy0PClRJ53vTFS0fHeT6kkq3sfRFD/77\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbU6nlWav86u3f5LzdwQwlTGMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGNl\nYzQ0ZTg0LTg1YmYtNDliMi04ZjczLTJkYTAyNmQ4NDNmZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDE2MDE4YTk1LTcxYjQtNDZmNC05MDBkLTRlYzUx\nNzQ2ZThmNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHC2utPRx4nZhbZ0CNd1\ndyI4M+RjQIpgAw/lJ6i/gG6pb2lc6UqYzjhjTI3UAxuce/CQq4w4B+7KZ0gs21xJ\nTF6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTs3cav/16oyjo/qDYzvt/v2k4gojAfBgNVHSMEGDAWgBQGJ9VE18cXQFLcVo7t\nWN3hbHKdqjAKBggqhkjOPQQDAgNIADBFAiEApLQdnTxwwZUUG7y/Z8cs0+BUfDd5\nkCEpci+Ps49NMCoCIHgut9CqWZ/XPSXrqbho44WKUMe1dDnCgeNfm3XNYy9u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcDu1bnUC2T+X4pf5QeOtnsUMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGNl\nYzQ0ZTg0LTg1YmYtNDliMi04ZjczLTJkYTAyNmQ4NDNmZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJDZhODljYTUzLTYxNDgtNGNjNS04MDEwLTk5MjZl\nYTAxODk2MTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABI+OfXsOX8XyOjBrbxqZ\ngNO6tQndrXCnIf07j88uh/mqWkBQzZfLIwikHInEU4GLkZjyMLji2ai80cWxSos1\nvZSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTfotPNlhSP+q+qp/fN1v9cTwqY+zAfBgNVHSMEGDAWgBQGJ9VE18cXQFLcVo7t\nWN3hbHKdqjAKBggqhkjOPQQDAgNIADBFAiEAqyoT0cU+CQ0Fbztv7bsD18i6wxSa\nx6Kiz1QHoKxmeW8CICDcYCvDJboJ6BIj0DF8L6g7ggGGPRiM7Tu7hT3UjctT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAdy67KMUp3KGh7N9w4iT65VaMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGI2MzU0NGM0LTRiYWMtNDVlNi1iMjY3LWM0MjRmNWFlODc1MTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJGZiNWExNjI3LTM5ZjYtNDhhOS05YzEzLTk4\nMmEwMjg3YjJlNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJVRJ2yrZb2sPf5r\nCy4yDGTarF23jmO+1muuv7mUuy8hiDvcd64SP/+H8GRMrDnL68aj4YDDMHP51Opk\nzb+IvHijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRK0NwgDs0xlLZUuZdirMTxhu0vtDAfBgNVHSMEGDAWgBQRzbGZ7gdyqeWC\nBC6ppThIi0JdtDAKBggqhkjOPQQDAgNHADBEAiAESea/39wynP0yWR9KIelGk1DR\nyghIURX+DCY8Vcj8WAIge35b0Cn5CM693bwZj9adkK7ZfxVV2w6V1WGW3hwgvPQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISARw6/AFMJ1YlAgNWIwYUEQrvMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGI2MzU0NGM0LTRiYWMtNDVlNi1iMjY3LWM0MjRmNWFlODc1MTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJGNlYzQ0ZTg0LTg1YmYtNDliMi04ZjczLTJk\nYTAyNmQ4NDNmZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBOwE8jbXETXkkaj\n/xUe/CaD9R2oVwIfRdqtdikktH5sSxMw9FlFP0QmUmSlvpRHucSDqAZ7r7BpGNOm\nvSg0iNajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQGJ9VE18cXQFLcVo7tWN3hbHKdqjAfBgNVHSMEGDAWgBQRzbGZ7gdyqeWC\nBC6ppThIi0JdtDAKBggqhkjOPQQDAgNHADBEAiALJlZsF/dH4KFldGL6l3CVOtZk\nMaiscuPqiiHZJs03/wIgT7osWhpTMY2ZX47694LYKyLVXjgmm0xhS+diB2AeGqw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWPOPeAQoLKhRJSSM3LfKuZWMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGNi\nMThlYzVlLWVkZDktNGRkOS1iOTkyLTVmY2Q5ODJmNDY3ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGJlYjA3OGIwLTlkMzYtNGFkNS1iYjliLTZmMzk4\nZjk3YzEyNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCn9NFSKSk3wjQHvMY0G\n4rr6ir6U5knAobfHBDQINAklHaJ8Kg30/ySSNe/qV1usPLC0ejtKvCWZyl2Iyied\nci2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRNQ+hH7eWU89O8/X9fIbG/M92SxzAfBgNVHSMEGDAWgBSlw4lS/2Mfvm0AACEV\n6Fdt6OLTKjAKBggqhkjOPQQDAgNJADBGAiEA5vSwL61Jo+AfOND3+k3epXHxP59B\n2Mu2yH+16ESZEWwCIQDaCE1Ssm4K/nLhavenRvWBCqYi1QqpU+Ex5q52Bq6FAw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWrxXKzeSBLK7igQqWR+kk+vMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGNi\nMThlYzVlLWVkZDktNGRkOS1iOTkyLTVmY2Q5ODJmNDY3ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDg3NDllODExLWI2NjEtNDMyZC1iMzJlLTA1NWE0\nNmQ2ZGQzYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLHCV44cnpI/+Oh5d4qy\nnTMA6ilyleSKYXswF060roSyp6a+XCABPn1Fy8w3aqE25YScegjMBTPvl0dYWrzm\nwq2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTOUDFa3l7WWfys6QNwxdX+oKl5MDAfBgNVHSMEGDAWgBSlw4lS/2Mfvm0AACEV\n6Fdt6OLTKjAKBggqhkjOPQQDAgNHADBEAiBvEgY/YYd0nzh/LTti7QZJSMzPjpLw\ntgHCirGRDmQBlQIgL3Pye+6c2m2i8Vp1L5Wc2ALyvD4SDUqnaLoTEzXXyIk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQh1LXQ4PQFcTOq0sSVjTlU5MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDAx\nNWNmNTZiLWNjMWEtNGIxNy1iYzU1LTRjNDk2NDBlYmRhYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGNiMThlYzVlLWVkZDktNGRkOS1iOTkyLTVmY2Q5\nODJmNDY3ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLaeH2MbjBg1+v1suu4/\nzzNso0wPQA3tXGcD8eG1k2kfoRdNc7C79QBW6ps4fKrJ8EUKHIkWEsQeKLgqqHtQ\nGYijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSlw4lS/2Mfvm0AACEV6Fdt6OLTKjAfBgNVHSMEGDAWgBS/VwRIdA9GO99qyoDt\nbIKGGFAkgTAKBggqhkjOPQQDAgNIADBFAiBIbz2MeyKUxMFrJeDRa9XDV/QKXRNr\n+SW3ebKgFBPnhwIhAOpC13zBCXqqMoY4gsi8VtsRZpHB+RpabQR6EKoRceCK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdWU9i7mKvk7OuCpJbhpLRkvMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDYw\nMDI1YmE4LWExNDYtNGVhMC1iZmUzLTc4YWZmNmZjMzIxMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGNiMThlYzVlLWVkZDktNGRkOS1iOTkyLTVmY2Q5\nODJmNDY3ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLaeH2MbjBg1+v1suu4/\nzzNso0wPQA3tXGcD8eG1k2kfoRdNc7C79QBW6ps4fKrJ8EUKHIkWEsQeKLgqqHtQ\nGYijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSlw4lS/2Mfvm0AACEV6Fdt6OLTKjAfBgNVHSMEGDAWgBSFm4P+9t+mzGqS9xmr\noQyjNBIQMTAKBggqhkjOPQQDAgNIADBFAiBzvRfIY6gO3ng0XEy7KnoYmUmae1JG\n7gQKaO9ejabdXgIhAIaFXA54KMHsTTsjiLCvE0c/6cK05zJek8JJydUi0+Gf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeO2uLwnudCsEXGBFfsMr4xMMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDAx\nNWNmNTZiLWNjMWEtNGIxNy1iYzU1LTRjNDk2NDBlYmRhYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDYwMDI1YmE4LWExNDYtNGVhMC1iZmUzLTc4YWZm\nNmZjMzIxMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDlcVczmTc2wgHX2g1Zl\n3MtqNZ2ZiN9Zh3ovf+7lGYpfVBF/p0j7WGt7PV1hkGZRrzaFBdyW5USu8DpW4hn6\nbv2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSFm4P+9t+mzGqS9xmroQyjNBIQMTAfBgNVHSMEGDAWgBS/VwRIdA9GO99qyoDt\nbIKGGFAkgTAKBggqhkjOPQQDAgNIADBFAiArthDBu2eGLWN2HcWI62QesJAJ9CM0\nQ4RGwgsqgihgUQIhAK+5lACwSQmlJWGRBV9i+VkqZ2uLiVmj0cgUz1MZaICb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAak6KFrIVzgg2is4BM2N8C6kMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDYw\nMDI1YmE4LWExNDYtNGVhMC1iZmUzLTc4YWZmNmZjMzIxMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDAxNWNmNTZiLWNjMWEtNGIxNy1iYzU1LTRjNDk2\nNDBlYmRhYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNZQg9S+ksxe2Zww0dqL\n7EgoFlY5ojE+C8Cf4yWK/Jszhn9hwwWuTqW5eJ0hrSCMV2XmWwPgkY0mVSx4E9PR\n6iKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS/VwRIdA9GO99qyoDtbIKGGFAkgTAfBgNVHSMEGDAWgBSFm4P+9t+mzGqS9xmr\noQyjNBIQMTAKBggqhkjOPQQDAgNHADBEAiBuQEKzSxdkkH0wPByAvKd4f5dD/x1z\n2wESGNywXad/QAIgH61tgEo/Y/phcdnj17sOnry99JYaZpCo8qybD22R6Lw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAec8KyGGiE46KN6874xT4M7xMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDBhZjIyNWNlLWIwYzUtNDlmZC05ODM2LTYyYmY5M2VkNzlhMDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDAxNWNmNTZiLWNjMWEtNGIxNy1iYzU1LTRj\nNDk2NDBlYmRhYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNZQg9S+ksxe2Zww\n0dqL7EgoFlY5ojE+C8Cf4yWK/Jszhn9hwwWuTqW5eJ0hrSCMV2XmWwPgkY0mVSx4\nE9PR6iKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS/VwRIdA9GO99qyoDtbIKGGFAkgTAfBgNVHSMEGDAWgBQ26iRdme/IHFrY\nTJeSr1wMdgAMWzAKBggqhkjOPQQDAgNIADBFAiA0W3ULytkd1Rg8zvTLJeYMVlqx\nFCqZZ9CCZWPKPv2URAIhAMIdUzuQZgwaeN2bP0GOKU37YIlSdeVqy4oJfKrmTsY5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAavMgjUX5I7EFh0e5pqEUiCIMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDBhZjIyNWNlLWIwYzUtNDlmZC05ODM2LTYyYmY5M2VkNzlhMDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDYwMDI1YmE4LWExNDYtNGVhMC1iZmUzLTc4\nYWZmNmZjMzIxMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDlcVczmTc2wgHX2\ng1Zl3MtqNZ2ZiN9Zh3ovf+7lGYpfVBF/p0j7WGt7PV1hkGZRrzaFBdyW5USu8DpW\n4hn6bv2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSFm4P+9t+mzGqS9xmroQyjNBIQMTAfBgNVHSMEGDAWgBQ26iRdme/IHFrY\nTJeSr1wMdgAMWzAKBggqhkjOPQQDAgNHADBEAiAoEwGMtFzDG+CKjgGGhxQLcHng\nxVPIiZiPeoSU0ABrIgIgCxo9/PbLEDOUKBv30UNrgTz0RuthuPkYPkjk6qf/k/I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARS5NBu/xsoDIWUlKWf2gQp4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJGFl\nNTM5OWFjLTI0OGQtNGRjNC05NTMyLWNlOWU2ZTU2MjA1MzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDVkOThjOWIzLTMyMDEtNDlmMS04ZGVmLTg3ZTJj\nM2NkMTNjYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK2Od+fRVfG6jUyXC12R\nzSBowVyR0WGfLlaE/oQDjNQERaeTIKjw6ZtyIjbFP2VW2Uqhm3mGpafo1klIy8zO\nBLSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRIkwwWjf5kqgLQnmdTwDQwXSy47zAfBgNVHSMEGDAWgBRKLbADXvnohKWyNbW6\nqbM5Ni3t3DAKBggqhkjOPQQDAgNJADBGAiEApcy2PeFA53+1K7bD6xhyo6A7pclv\nrhqQpX/LqVGUKQICIQDDaFWrf9jU0EKruG2N5VXwePk7dcCjk7l6l3DbY+OhEg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQianQHObiU+2jj64+MquGa8MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDQz\nMGVlNjk1LWFlNGMtNDA2Ni1iNWU1LTUxZDQ5MGEyZjQ5MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJGFlNTM5OWFjLTI0OGQtNGRjNC05NTMyLWNlOWU2\nZTU2MjA1MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBlrIuizxGKg+OSRSLPh\nBc6eCg1UU61j5J1M9o6YGyxKPdZv+75r6WOU+Ah+2hVxrgTR0O4W/q0FNhUH/PS6\nnFGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRKLbADXvnohKWyNbW6qbM5Ni3t3DAfBgNVHSMEGDAWgBRx985rr5f/4cwGlokK\n1rhLNunPFTAKBggqhkjOPQQDAgNJADBGAiEA6sPtNh9RiGFMHPP4rADOrGrktRLi\niXDe0Tue7u+F1RACIQDkehWSdlFgFKkP9Qs6LFsBeB1WKwlP+U5lIjkn1N+X1w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAe+8+ArwWiWEtKrJBbgnczgGMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDQz\nMGVlNjk1LWFlNGMtNDA2Ni1iNWU1LTUxZDQ5MGEyZjQ5MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDdiMjE0MTAxLTA3YTgtNDMyOC1iZjM0LTdlMTZi\nN2RjMzVjMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOZucaP/oq3R0w6EshOP\n+xKA+LiWjKBfD70N6qDSWYX7VVJYpqQP2nn3mUx/Qx4p7OvbhKLQVtIr8AO+X4p9\nK+2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRM57NiDJ6mxmpBPWXNro5zFsvDhjAfBgNVHSMEGDAWgBRx985rr5f/4cwGlokK\n1rhLNunPFTAKBggqhkjOPQQDAgNHADBEAiA4s0pA28zZrRxfZZ3cu7vXKkVLY0e2\n5eqxg25GknpdzQIgcD5GLZ5Ht0yGDzRasKKuxCSDoc7NOCp2K8q0LzXk9NI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZ84VELQd983hdxXBVJDKbEEMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJDY4\nOGU2MTlkLTA2NmMtNDFlNS05ZDhhLWE4NjZjOGJiMmY0NzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDVkOThjOWIzLTMyMDEtNDlmMS04ZGVmLTg3ZTJj\nM2NkMTNjYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK2Od+fRVfG6jUyXC12R\nzSBowVyR0WGfLlaE/oQDjNQERaeTIKjw6ZtyIjbFP2VW2Uqhm3mGpafo1klIy8zO\nBLSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRIkwwWjf5kqgLQnmdTwDQwXSy47zAfBgNVHSMEGDAWgBTQM5CtRylQW7oVkBSv\nUgzOMsZXFjAKBggqhkjOPQQDAgNIADBFAiEAwOsxpDbs4KpI5SyAEdh1v1A8cc+T\nHEAirIE/TZ2boMgCIBavKh4FJpZDC9wBZMovXxli0MfiwneW3IIL1iTvMrSY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAWIVt/jGI/E721rqovpZC9NRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQ0MzBlZTY5NS1h\nZTRjLTQwNjYtYjVlNS01MWQ0OTBhMmY0OTEwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAT8405m71ocz32/pK/FMsKFjOhy1mvYpslWB+26umiB+Tu7+h7VzmwgBchh\nhmKH6NBHVbJj2Vso2msQ47jqKFnao2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcffOa6+X/+HMBpaJCta4SzbpzxUwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgOBj/\nJaGnfjb1U8xCSx93/BoK9N/0KNIU0GTT694GjW8CIQCdv8M80YqhwG6DwWHk7B+E\nG8XjdP6pDJHiOeRTexAjLQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAXMRPFLD7NQAacXY4VqHHPRZMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyQ2ODhlNjE5ZC0w\nNjZjLTQxZTUtOWQ4YS1hODY2YzhiYjJmNDcwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAASFVCCpu5BhWk3wlYtxslOhhPWalJn5rIul9R4X3VOzv2VWflD7wmJAiSwP\nL7DYTqu0hBKE0sFf3k1u1R1/6L5vo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU0DOQrUcpUFu6FZAUr1IMzjLGVxYwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAPZx\nLC/zRhEi0cccAoGMNnRYOlJ4hEbJ1MkL5vb6zyH4AiEA4kwxWgRySjTfIRys//Tl\ncivLskLKMc0lO6MajaODWMw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAeM2q2vkkI3onNmPbd9tnjryMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDlkYmVmMjc1LTFjZDUtNDcxZC1hNzBlLWU0N2I1NTk3NzU2MjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkOGU1MWUzYzMtNWVlYy00MjAw\nLTg4ZDctMDU1NGEzODM5NzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpUnz\n6kjmOBu02Goo4Y6mIKMQY5akTRailKNQ7RKDYGPfQUsJ7ijHBPeWvTRjb/nkwMsp\nONZsNt3yKdHJpIa6/6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFA/0jIkyT1tke+P5WV93nAJsyE2RMB8GA1UdIwQYMBaAFE+/\n5PW8dGzPLWZfspi0C6QI4YgQMAoGCCqGSM49BAMCA0kAMEYCIQDeq9xeQjtIGZXb\nGHpBcC87PrmSG77vFjMczpoNh/i5CAIhAKeZZOfUoTTrdgtVUMf/hJAeSvCHTvE6\nKVQZ3ZqpWcbI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAdbYGMXuxRIPjToWbY28pwBhMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkOGU1MWUzYzMtNWVlYy00MjAwLTg4ZDctMDU1NGEzODM5NzQ1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkOWRiZWYyNzUtMWNkNS00NzFk\nLWE3MGUtZTQ3YjU1OTc3NTYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBMMO\nKHxCld4KegdwNdV8W1a/HawgWxXC8WF2RvYRj2tF543Aa4TuEpREy03WqJMGy3LA\nWLaB6ljJYwEfTvRxuqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFE+/5PW8dGzPLWZfspi0C6QI4YgQMB8GA1UdIwQYMBaAFA/0\njIkyT1tke+P5WV93nAJsyE2RMAoGCCqGSM49BAMCA0kAMEYCIQC2g6EVd0KQHs+F\noCsDdubbXQe8AUCJZvvB9dOSBkzEKwIhALGuv2AmI6qrqSC6GLDLQvypOsluTtVg\nCNiariZXgO/x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICAzCCAamgAwIBAgISAT9Pw/O3ZDqe+YWXBqoDTqnLMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGI2MzU0NGM0LTRiYWMtNDVlNi1iMjY3LWM0MjRmNWFlODc1MTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkOGU1MWUzYzMtNWVlYy00MjAw\nLTg4ZDctMDU1NGEzODM5NzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpUnz\n6kjmOBu02Goo4Y6mIKMQY5akTRailKNQ7RKDYGPfQUsJ7ijHBPeWvTRjb/nkwMsp\nONZsNt3yKdHJpIa6/6NSMFAwDgYDVR0PAQH/BAQDAgIEMB0GA1UdDgQWBBQP9IyJ\nMk9bZHvj+Vlfd5wCbMhNkTAfBgNVHSMEGDAWgBQRzbGZ7gdyqeWCBC6ppThIi0Jd\ntDAKBggqhkjOPQQDAgNIADBFAiEApGhyqzZbWIlIqzHbOCbBOug0/LM9a4Ae7WdP\n1kdV/YoCIE5t8dvXGEpsqbguDvv1Rs3xXydKRY2zvz89vn3x0gVR\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISARs6GX9Kbxrve5ufWJqPKFQ+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkOGU1MWUzYzMtNWVlYy00MjAwLTg4ZDctMDU1NGEzODM5NzQ1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkYjYzNTQ0YzQtNGJhYy00NWU2\nLWIyNjctYzQyNGY1YWU4NzUxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEy4mB\nhCM2gsExUkokv6ei8EgqZ25/V6l5bBL8CGEv8NPMs/XGclIk1lW4Qjg2nZa8NOpO\nhuBvPTeEA0OA9CYOS6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBHNsZnuB3Kp5YIELqmlOEiLQl20MB8GA1UdIwQYMBaAFA/0\njIkyT1tke+P5WV93nAJsyE2RMAoGCCqGSM49BAMCA0gAMEUCIAlMcztJxvfA+YSz\n7R3SzZIUrmuH4+0HlfB/frbJtS13AiEA0L/5O4wPdwx2tqDVmqqIZS/oYH0M+i70\n4JzNXuCYTM4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAX1kIr9Xvro5wNm1LjpwoCjhMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDBhZjIyNWNlLWIwYzUtNDlmZC05ODM2LTYyYmY5M2VkNzlhMDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkOGU1MWUzYzMtNWVlYy00MjAw\nLTg4ZDctMDU1NGEzODM5NzQ1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpUnz\n6kjmOBu02Goo4Y6mIKMQY5akTRailKNQ7RKDYGPfQUsJ7ijHBPeWvTRjb/nkwMsp\nONZsNt3yKdHJpIa6/6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFA/0jIkyT1tke+P5WV93nAJsyE2RMB8GA1UdIwQYMBaAFDbq\nJF2Z78gcWthMl5KvXAx2AAxbMAoGCCqGSM49BAMCA0kAMEYCIQCugOY2WGYWYxo2\nnAdgum7Gq2XsI8GQsbMqtiCD+YlGewIhAMaj8KokBIXmlTMISw0jFdTqBViGEflS\nK2Gx+ttCL4KQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISARszITIcJQwUn33l5XgXclsYMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkOGU1MWUzYzMtNWVlYy00MjAwLTg4ZDctMDU1NGEzODM5NzQ1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkMGFmMjI1Y2UtYjBjNS00OWZk\nLTk4MzYtNjJiZjkzZWQ3OWEwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUsyF\nc2Sr85hh8BgcSmHn+ij6HLJQmabT6vfXG0HO3Clb606Os2kYn13kzKfSpK0rvEtp\nVdUW+RgF8P3AOhuNaaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFDbqJF2Z78gcWthMl5KvXAx2AAxbMB8GA1UdIwQYMBaAFA/0\njIkyT1tke+P5WV93nAJsyE2RMAoGCCqGSM49BAMCA0gAMEUCIQDCBF2NHdsvG3Oq\ncJkieQ2PqjsHuV3sptNSK8T24e5TWgIgJS16AHH+DAZGyqDrCK1HXMMfOTRHbYlz\n5T5f84Qr61k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcqgAwIBAgISAdq8ue/ANhi094CuaL0b6YVLMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDhl\nNTFlM2MzLTVlZWMtNDIwMC04OGQ3LTA1NTRhMzgzOTc0NTBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABKVJ8+pI5jgbtNhqKOGOpiCjEGOWpE0WopSjUO0Sg2Bj30FL\nCe4oxwT3lr00Y2/55MDLKTjWbDbd8inRyaSGuv+jYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQP9IyJMk9bZHvj+Vlfd5wCbMhN\nkTAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNJ\nADBGAiEAxNJZHWHWN9/AG9Oo9ag2SCrRfDEUzn74jOyKT1q4J/ICIQD8C83A4rOp\n5ivjqfPMKmuwdcU7vv4HD6mcuoe4AbGJkg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAWtjOZ6yR3kV3sTluOICE0tuMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkOGU1MWUzYzMtNWVlYy00MjAwLTg4ZDctMDU1NGEzODM5NzQ1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBQP9IyJMk9bZHvj+Vlfd5wCbMhNkTAKBggqhkjOPQQDAgNI\nADBFAiEA7ck9IYae0/bhbXsRqtK9DvmQIK4GkQdVC/hKJ/YVsQgCIBK0IV6Oiugm\nyXMq5I17xy3Kh8Xfwhrb15Uzr9izFID/\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAedMn6+GeKMM4fxLoRUPkJ+BMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDE2\nMDE4YTk1LTcxYjQtNDZmNC05MDBkLTRlYzUxNzQ2ZThmNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ0YzBlYWM4Zi1mMmIyLTRkYTItOGQ1MS0zNzFm\nOWIyMzBjMjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATrp65KE2YThVknP0dF\nMlRUOSJ5orKMhfGpVZbLfg4FuTMCEesylAsnp9MZ980Oyg8hR0OM13nrvRKv6SnR\nX/3Qo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTs3cav/16oyjo/qDYzvt/v2k4gojAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgOeoLZOeW4rMgamI5\nqHqN70lHtTVdDzYfuUyV2Q0XM6ICIQDudVt76M7ZbY6n6y6PuLqIKmEkClacwB1D\nXsPgqS/XqQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc67", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `67` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAebMRFTnwl1FZmQ44IliUxU7MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDgw\nZWE0YzRkLWQ3ZDMtNDgyYy1hMzc5LTgyZTQyYjk5ZmZhMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGVkMWU4MGU4LTdlYjMtNDY1NS05ZGI3LTIzZWIz\nNTU4ODIyYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIPBLD2WBFL1JMNAOTLR\n9tdx20HuNbRHZQdQ13/HskY85z/F2BRI2bHDaO2JDEEIum9pHETYKwSErdP9Vy/p\n4YSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSRgK8/RFJRwdb1uSUeuPddSuxUJzAfBgNVHSMEGDAWgBRDgvNbdTySQnuCI9nP\nhiCcUiPsajAKBggqhkjOPQQDAgNHADBEAiBWMOD7vUTVwA3Laz6vYYvprT5bqPSw\nG62wxuxAL4SlFQIgU0BiH7Tq+8VmsqJt2h6po7sz+6ow5QA3Xm2gZto72ZE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISATVetP1uyuWwgAl/YwiNflutMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDgw\nZWE0YzRkLWQ3ZDMtNDgyYy1hMzc5LTgyZTQyYjk5ZmZhMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJGE2OWFiYzY2LTliNzgtNDRlZi05NDdlLTQxM2Rj\nY2JmMTNhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHgAeyteusjWpWvUWHQQ\nQV+AkXdRnB+QMqFq2ujWaIy8K+t2Q8KvKEkAx8I9NIREJz/AsHDoeH1wUXEKgI2h\nlbmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTBiJ/kQrgJe9U99sZl1IAYKZalijAfBgNVHSMEGDAWgBRDgvNbdTySQnuCI9nP\nhiCcUiPsajAKBggqhkjOPQQDAgNJADBGAiEAvu12RvP+4VkUqjkSrdaw3el8LI5F\nn8muL1y63fPaQ8MCIQCOawzVoDMoAfo5jizsLPOZbsqT815D9ruFkSL/YZ62Lg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAf5Zzjkw4OhSJ/jMQb+iujkFMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGE2\nOWFiYzY2LTliNzgtNDRlZi05NDdlLTQxM2RjY2JmMTNhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDgwZWE0YzRkLWQ3ZDMtNDgyYy1hMzc5LTgyZTQy\nYjk5ZmZhMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABECgkp2YEscHj1VjJnHa\nLvIh0cxg3UHelMKVPaX7RslJUPUL+r8oJj2fF1rohkT8ja6Oa9sFVbXI7fvQ9z/8\nBIyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRDgvNbdTySQnuCI9nPhiCcUiPsajAfBgNVHSMEGDAWgBTBiJ/kQrgJe9U99sZl\n1IAYKZalijAKBggqhkjOPQQDAgNJADBGAiEA6lR5JAibexPx+nCXYgSJTTKpxlLH\n97dfRAClstilG1MCIQDl+ye+Xv+4iKriON9sX+8JT5I7J4UKahOXyPPWRiFB6g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARf3xrRYBs+RuTwSbtg4slT6MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJGVk\nMWU4MGU4LTdlYjMtNDY1NS05ZGI3LTIzZWIzNTU4ODIyYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJGI2ODQ3NDA1LTg5NGMtNDNmZC04NDdkLTg2NDBm\nNTMyOTEyYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBvVsY6jqC7NMizoWs9Q\nYgxtcs0xpFyTyXJvaotLtFmIYSHzgsYhCTOOGtW+iC2NI9pp0TWTSTY4kluC9q/m\n4A2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQrWTv7qP9QtLoM1wK+L11rL1r5BjAfBgNVHSMEGDAWgBSRgK8/RFJRwdb1uSUe\nuPddSuxUJzAKBggqhkjOPQQDAgNJADBGAiEAr3PNKMEaDWWMEaPRJbWiLqz0R+aA\nOPvqwYxtG0UC2rkCIQDc1iTuGTgkTH1UwBBmantX5+fFkJeB+NbT7ZpcKa3tTw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAe+2OJipHkVPPjSxecH2hAj4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJGI2\nODQ3NDA1LTg5NGMtNDNmZC04NDdkLTg2NDBmNTMyOTEyYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGVkMWU4MGU4LTdlYjMtNDY1NS05ZGI3LTIzZWIz\nNTU4ODIyYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIPBLD2WBFL1JMNAOTLR\n9tdx20HuNbRHZQdQ13/HskY85z/F2BRI2bHDaO2JDEEIum9pHETYKwSErdP9Vy/p\n4YSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSRgK8/RFJRwdb1uSUeuPddSuxUJzAfBgNVHSMEGDAWgBQrWTv7qP9QtLoM1wK+\nL11rL1r5BjAKBggqhkjOPQQDAgNJADBGAiEA2wk78EDSfjh4jSZMOohdOtRiUlpi\nUzv6WeiFwClx0jcCIQCvCarhxWFuvM4eavlV/sGlh+Rg+WiABbTxt8Wn50mlrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQzvFZ4dgLOqfrJbYRatT5j3MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGE2\nOWFiYzY2LTliNzgtNDRlZi05NDdlLTQxM2RjY2JmMTNhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJGI2ODQ3NDA1LTg5NGMtNDNmZC04NDdkLTg2NDBm\nNTMyOTEyYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBvVsY6jqC7NMizoWs9Q\nYgxtcs0xpFyTyXJvaotLtFmIYSHzgsYhCTOOGtW+iC2NI9pp0TWTSTY4kluC9q/m\n4A2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQrWTv7qP9QtLoM1wK+L11rL1r5BjAfBgNVHSMEGDAWgBTBiJ/kQrgJe9U99sZl\n1IAYKZalijAKBggqhkjOPQQDAgNHADBEAiBg3dN8iD3psUnws4f10iWgOljehttC\nxNV0uTybury1yAIgfeOBtoo6Bf5WnrvmKkp+VtuGr1jjTyJ8rVDDAMLvV3c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISATjUT1tiapZ4G6Wh0sJinXNQMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDRiYThhZGUyLWU3MDYtNDIwZS04NmM4LTAyMzhkMTk2MmYyZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDgwZWE0YzRkLWQ3ZDMtNDgyYy1hMzc5LTgy\nZTQyYjk5ZmZhMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABECgkp2YEscHj1Vj\nJnHaLvIh0cxg3UHelMKVPaX7RslJUPUL+r8oJj2fF1rohkT8ja6Oa9sFVbXI7fvQ\n9z/8BIyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRDgvNbdTySQnuCI9nPhiCcUiPsajAfBgNVHSMEGDAWgBRStonw8uT6JATM\nYLPx8MVJq0cGrTAKBggqhkjOPQQDAgNHADBEAiAlpk3CKiaH4l7PoAJeZhCa7/ra\negYBDUkPh+yonoZGAgIgMTD/p+BijQQGTn6TeUqM8XLZpyUUbS0U0dBkaVlfUss=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAZyWN09QWwItdvcGKg9OJjQSMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDRiYThhZGUyLWU3MDYtNDIwZS04NmM4LTAyMzhkMTk2MmYyZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJGE2OWFiYzY2LTliNzgtNDRlZi05NDdlLTQx\nM2RjY2JmMTNhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHgAeyteusjWpWvU\nWHQQQV+AkXdRnB+QMqFq2ujWaIy8K+t2Q8KvKEkAx8I9NIREJz/AsHDoeH1wUXEK\ngI2hlbmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTBiJ/kQrgJe9U99sZl1IAYKZalijAfBgNVHSMEGDAWgBRStonw8uT6JATM\nYLPx8MVJq0cGrTAKBggqhkjOPQQDAgNHADBEAiB5GS6galVWNvOZQzb61gojDXss\n56OMZnbjB3yZDmKv0QIgNA6PI+6wMFrE6bPiDRvAAJ2HetRJ185WS+TxcYuJeow=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAV6E53KMpwY2fIGeewrjeKrPMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJGE2\nMWUyZGRkLTk1Y2QtNGE2Zi05ODM4LTlkNjM4Njk0YTU5MzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDljNDZjMTIyLWJjZjYtNDMxZS1iMTJmLWEwZTA0\nZWFkODJiNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABA308PpLCwcGysHSG+je\nJpC5b0ILBE5kOKVo1OWXSKHeN/pUvNKcyBIxkao23EbvehWeUfxeYNRFP8JowsVB\nqzCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSCKQ2k+EBzxr1YLgs75yLpBLOUPTAfBgNVHSMEGDAWgBSGISMXOmqdOLQlPgIt\nfaAwr3K8TzAKBggqhkjOPQQDAgNJADBGAiEA4dYXTZUfdY8C8ZYclbJ2VhUfsoMF\nzbEkvjZXnRV7OTkCIQCGjAYixZXudvW9J0swRl0GX3tmckuG5EIcZv1Y1DTLPQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXf8KR0h67OtMY4CkiJ6WhVpMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDZk\nOTk1ZTZhLTcyMDMtNGQ0ZS04ZTEzLTM2ZTE4ODg2NWYwOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDQ0MTYzZTdjLTNlZmUtNDA4Zi1hM2IxLTU3N2I0\nZjA3ZTk5YzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKhQhdX3RQJtMOTYRCep\n+pNf9Jnhm4rBUMTY1ZgjK0IAYJ7sXospSrZF4uixiJgbJ+zU+Ytys/fq/zSRN/TW\ngoWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTJvVgUdRt2lAEiJgs4bO+oUF3ASzAfBgNVHSMEGDAWgBQuLw1hQqchqCkgZ9I/\n48DLCod1zDAKBggqhkjOPQQDAgNIADBFAiAexFSJO3OyRbIkvy6DeaVpetpMlof1\nAB8U0kiwuF92FgIhAL8egQUtOuLh5xix3OViBvpffB1+3OLIfWMh9mby50cl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISATbdJt7gaTr87Q7PTX+zgKUBMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDZk\nOTk1ZTZhLTcyMDMtNGQ0ZS04ZTEzLTM2ZTE4ODg2NWYwOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJDUwZmVjZTllLWQ1MmQtNGJlYS1hMTgyLTliZWRj\nOWRhMTEwZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABP5UqVdnrQLhXzOalja1\na5j0GGai3Vc6H6rfFP2UTwaDBitdAFmCVerx6aQ6aoMrEF94Z26nAJm/8MXkbZe0\nx+OjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTMTmLH0FpqG8lmsMj/Ip31dXcc0TAfBgNVHSMEGDAWgBQuLw1hQqchqCkgZ9I/\n48DLCod1zDAKBggqhkjOPQQDAgNJADBGAiEAlQLvLiSTIHMA44bhnoKk7L16W4SV\nIxzkGDEOucwbFn0CIQD0XBSqDDPjCGQDAY7BSpd6m9x/2rnsOVePtCVXPOAsOQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZGjgdb2py8XnLHsZoCUR3ORMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGY4OTAxZjhlLTJkYzAtNDM5ZC1iNGZhLWExMDY2MDU0NDJkODAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJGE2MWUyZGRkLTk1Y2QtNGE2Zi05ODM4LTlk\nNjM4Njk0YTU5MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLiKFkmD5NeAC9iA\nahhTRzO9sYomZShcl63ws85VswJ0jL1C3C7lN7PK2CV7HGATdnI8xvtMyeCJPTGS\nhPU9qf+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSGISMXOmqdOLQlPgItfaAwr3K8TzAfBgNVHSMEGDAWgBSz62gN6V7y9HYU\nBjrvKqFWd9++8zAKBggqhkjOPQQDAgNIADBFAiEA4fVZKGktTPw2BA9VQSYEUeUL\nKkrpegdvSD1W/mUeswMCIB1zFSm70uKTa3UdEBLBvCdHzlWd2kwBUiPyyoK0v2G6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAUIkNua+oi/CvsuYk4egu+G6MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGY4OTAxZjhlLTJkYzAtNDM5ZC1iNGZhLWExMDY2MDU0NDJkODAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDZkOTk1ZTZhLTcyMDMtNGQ0ZS04ZTEzLTM2\nZTE4ODg2NWYwOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBGn2CggTPWkIEwG\n9GMcqQsL+UZwe16IiJoD+qk00eP0yDrKW5PLA+LbHjRWqLL07jy6zvFbctRH16bK\nKtYyyL+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQuLw1hQqchqCkgZ9I/48DLCod1zDAfBgNVHSMEGDAWgBSz62gN6V7y9HYU\nBjrvKqFWd9++8zAKBggqhkjOPQQDAgNHADBEAiA5nbmZCERoSm13bOnl8nZE1Sz/\nk/Tw8WlV3YN0PFVlKQIgA9GbR5fHbwQPfp1bJj3ncro75HV8IdKTH7wfppp45Gs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXnIgydjlLSuzlW5YgUlicq7MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDJi\nMDAxOWM5LTQ1MjUtNGFiNy05NjU2LTYzZTc2Y2Y0ODcxYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJDRkYWJjMjkwLTc0ZmEtNGZiNi04Yjc4LWYxMTk5\nZTNkNDMyNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAkZExuUJ4MnOSnlRU5Q\nBOwm8Ec9H/E6lT8FmGgfjL5c1mR+88yGL3ykTPmAZJv4ojHanM9WlTPwrn9qFEGC\n5vajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ0g17KZMudS/UukIv+mxvn/SvCPjAfBgNVHSMEGDAWgBRTPHCIL61KXwwulACv\nMjwvucDFozAKBggqhkjOPQQDAgNIADBFAiBikoz6P9hNlfWmjtaO/cVoxXpBBJ2Y\nJBGyULnEtolMWgIhAJfF4fXzLGxeTMn2ocqqI0c+bkfgtD6Xlez25xIoIeiv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASetQzbwNg/PXbLsJagdQz8oMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDJi\nMDAxOWM5LTQ1MjUtNGFiNy05NjU2LTYzZTc2Y2Y0ODcxYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJGViMTg0MzdmLWY3N2QtNDFhOC05YzFkLWJjYzBk\nNjc4NmYwNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKHLPtxVIA1YEFWf/aJl\nzy7paseadwNh44K7BDCJpRd6MRp3HLHpZtegzejl2vB19LQBGfDyqHYaVBrAIU2Z\n5g2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR8K9rRn1yti2xDLk2RYhqHU8dTljAfBgNVHSMEGDAWgBRTPHCIL61KXwwulACv\nMjwvucDFozAKBggqhkjOPQQDAgNIADBFAiEAvw2CQZmVuyZgvS3uwnxI5/20q55+\nM3uIHOWbtMW+2/YCIHAv+3xoxv+uijhu/8BcWP+Zyxk4zqE6Csc0s5nwTDt9\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWwt3LFwp0tTxz3ffqYwFJ9/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDEw\nZGRiYjc1LWZkZGEtNGQzMi1iY2I0LTc5NWQyNGEwOTI0YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDJiMDAxOWM5LTQ1MjUtNGFiNy05NjU2LTYzZTc2\nY2Y0ODcxYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIlJX9/Qukq3TBgaOfvC\nlSuQLiqrRJNnjq6U3QWxYZt55eNfP2QAEt3ur0Bw/wrlHHCey00DgyQwAdDm8G3h\nSM+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRTPHCIL61KXwwulACvMjwvucDFozAfBgNVHSMEGDAWgBRUqtDavsEf03r7gQ97\nKllDAYQ0jjAKBggqhkjOPQQDAgNIADBFAiEA1vROOcP17SgSoSO6GpkziOtSc+9Z\njjL3tSR6kzbKDVoCIGUtj7nKn5V3nKNpt4AhaVGwe4NPH3HMIajmPWDXHHlC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQO4tylfb8TDPPNUT5WGBhOLMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDIz\nMTE0MDNjLWUxN2YtNGE5NS05NWNkLWEzYTBiNmEwODA4NTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDJiMDAxOWM5LTQ1MjUtNGFiNy05NjU2LTYzZTc2\nY2Y0ODcxYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIlJX9/Qukq3TBgaOfvC\nlSuQLiqrRJNnjq6U3QWxYZt55eNfP2QAEt3ur0Bw/wrlHHCey00DgyQwAdDm8G3h\nSM+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRTPHCIL61KXwwulACvMjwvucDFozAfBgNVHSMEGDAWgBQrh3Di9s3bcfvgeBc6\nqJJfe2lhDDAKBggqhkjOPQQDAgNHADBEAiAU0y9cdWKjR4NIxsrrvK1ZED6v4VkR\n6CtvjlnhdLJk5gIgNK8ziKmMRGdP2vwcxx4CTC98xyhrlV3ATnMCnddPKwM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAf4+LvsgVN0ioaQb0ObgO9ixMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDEw\nZGRiYjc1LWZkZGEtNGQzMi1iY2I0LTc5NWQyNGEwOTI0YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDIzMTE0MDNjLWUxN2YtNGE5NS05NWNkLWEzYTBi\nNmEwODA4NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEdYEBXgAvzhe/KLBfYw\njoZI+Krz+CztROug8DDDsnkYX2azUOueuurB16b5r3BffyAFrr12U3q6ru8zngaA\nVXWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQrh3Di9s3bcfvgeBc6qJJfe2lhDDAfBgNVHSMEGDAWgBRUqtDavsEf03r7gQ97\nKllDAYQ0jjAKBggqhkjOPQQDAgNJADBGAiEAw2NSCzEjMtzkU6UI9Y85eVdnV7xA\nQCOzQjlEjI3fgOQCIQCHBzEV4OXg9Q+zjfS7Hq1maAlLKY87wCrFo5+zOJThKA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfq3cSxbL7R2734Fui2XWPEPMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDIz\nMTE0MDNjLWUxN2YtNGE5NS05NWNkLWEzYTBiNmEwODA4NTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDEwZGRiYjc1LWZkZGEtNGQzMi1iY2I0LTc5NWQy\nNGEwOTI0YzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDtRqTYBs2il/Dg5AaYd\nOvoVr+syIJQszfCmd9fxHet/F/6a4VeTibAptOiVQXRwMfu6f+MAmSvjM4VAlqjf\nqLKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRUqtDavsEf03r7gQ97KllDAYQ0jjAfBgNVHSMEGDAWgBQrh3Di9s3bcfvgeBc6\nqJJfe2lhDDAKBggqhkjOPQQDAgNIADBFAiEA/QMEIhwtgL9mTSSxMUIxK7UfcWYB\nmEhT8/2yd9pRNiYCIHqM02OaOHyQz2zRQoRnrXC7RetUDVEGh3NQqt9VXYK4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAV1Bs00St5k2ou3jApG6OK+fMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGRiNTYyMWY4LWU0MzItNDhjMi1hZGNjLWYxNzlkYzg0NjQxNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDEwZGRiYjc1LWZkZGEtNGQzMi1iY2I0LTc5\nNWQyNGEwOTI0YzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDtRqTYBs2il/Dg5\nAaYdOvoVr+syIJQszfCmd9fxHet/F/6a4VeTibAptOiVQXRwMfu6f+MAmSvjM4VA\nlqjfqLKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRUqtDavsEf03r7gQ97KllDAYQ0jjAfBgNVHSMEGDAWgBTDyAPBXvpBJJRd\noxKEsXI/xqVY9zAKBggqhkjOPQQDAgNHADBEAiASCdCIwUYnrm8mPmS+TjCEgKE3\n0BNkvd3MVjuVfuaYOgIgcetXxV9llTN2N9nL0GHSNuiI1PX3Fk8zrTdgGzSfPfo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAazxfI8LlJ6apTiw7iV/gMb5MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGRiNTYyMWY4LWU0MzItNDhjMi1hZGNjLWYxNzlkYzg0NjQxNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDIzMTE0MDNjLWUxN2YtNGE5NS05NWNkLWEz\nYTBiNmEwODA4NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEdYEBXgAvzhe/KL\nBfYwjoZI+Krz+CztROug8DDDsnkYX2azUOueuurB16b5r3BffyAFrr12U3q6ru8z\nngaAVXWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQrh3Di9s3bcfvgeBc6qJJfe2lhDDAfBgNVHSMEGDAWgBTDyAPBXvpBJJRd\noxKEsXI/xqVY9zAKBggqhkjOPQQDAgNIADBFAiEAkDkjvaxyUJ2LU0zSweek5xG2\n0OfJa/k/NYyck3hMCrkCICqvPMr9tSjaGAlkPQxzhZHWEggVkeuuydXvegPxQmDj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAb8VqooAleAT4zPclbaVfNRTMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJGQx\nYTA5YWZjLWRmMjItNGE0Yi05NzRhLWQxMzEyOGJiNjRlNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGIzNTZjYjUxLWZiZmMtNGY0Yy05YTAwLTkxMWI1\nNGVlYjIyMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPYmSdbGY1rfi98caLtL\ntvnZPI0vsG4/8TgYe02JM6pT5g3/75DX0p8uQsS251L9XPvWxq58T58i1t81AlV9\nFySjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQB6jb1fqA7zHVZKDJ8pbxoPCbKHDAfBgNVHSMEGDAWgBT5/mkqwdXKHqEEpybl\nVlbVf+45+zAKBggqhkjOPQQDAgNIADBFAiEAq/FjBuTXF5MrfJ6Vxscd5lIkZfvU\nI54wM/EOGBn8HGcCIFHDtZOqK4utYEPmDANZZM14U5IPGVZd+ztstHEPMmct\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAX+HWmX1Pr2qKacupIiXopi3MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDFl\nZTM1M2UxLTg3YWUtNDgzZi1iMDM4LTcyOGE3MWJjZjAyOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJGQxYTA5YWZjLWRmMjItNGE0Yi05NzRhLWQxMzEy\nOGJiNjRlNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNlUahO9yENP+kJpEnoz\nh6zwwL6ThPdcXIoaYTpz653kwPHYSHx2W5S9dqin2KmuqWWR65n3aBYVgoO5c0c9\nrImjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT5/mkqwdXKHqEEpyblVlbVf+45+zAfBgNVHSMEGDAWgBRvWC4Z13KKEsDMru7H\nKfWas5TKGzAKBggqhkjOPQQDAgNIADBFAiB2e5Qyh0CaU9DtxakT8QFLTGneeRjx\nI5JrBqGfIp92yQIhAOzygBH6SvIpL2CaVTRW8MlDD95H1rilA+0rpKDoW27s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWb0ymeyy9feQwanZBTqASshMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDFl\nZTM1M2UxLTg3YWUtNDgzZi1iMDM4LTcyOGE3MWJjZjAyOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJGVhNDgxMWI1LTFjYWMtNDkyNy1hY2Y2LTc5NDcz\nYmU1MWZjOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABANR8oiiQEp9tWUmPfPm\ngn2AxNuWVqtjbVqJEMA/97rsvf3clGBdq8PEQdKAGslwlhL0yhPRWr6aXINo1noZ\n6qmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRfDMrw26B9MY2Q1Jq/241I8/FtTTAfBgNVHSMEGDAWgBRvWC4Z13KKEsDMru7H\nKfWas5TKGzAKBggqhkjOPQQDAgNJADBGAiEAhUixiVE2gAdsSMVrrSeE04zDVQ7C\nLsg0iowR0nAX4NkCIQCmKlGc2Uyo/JAyFCpVFqZzdt8XJl5LvsKkWuKvWG381g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUg5WtO/Z1fcyijI3irANN/tMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGQ1\nMjA2ZDRkLTNmOTAtNGRiMC04MzdiLWM1OGY5NzUyYjU1ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGIzNTZjYjUxLWZiZmMtNGY0Yy05YTAwLTkxMWI1\nNGVlYjIyMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPYmSdbGY1rfi98caLtL\ntvnZPI0vsG4/8TgYe02JM6pT5g3/75DX0p8uQsS251L9XPvWxq58T58i1t81AlV9\nFySjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQB6jb1fqA7zHVZKDJ8pbxoPCbKHDAfBgNVHSMEGDAWgBRgMCKlD3D2Tjtlk990\ncJSlJWjVdjAKBggqhkjOPQQDAgNIADBFAiEA45i17YZywZHmHYk+n6UMeRY1jcwk\nTPFrtkeO/6yiLQoCIDVIhCem6+hnte/6BDsXb4LtZzDl4xbTjkRZg06uKq+n\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAfp7XLNXyfHBkX+jL9W36NrwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQxZWUzNTNlMS04\nN2FlLTQ4M2YtYjAzOC03MjhhNzFiY2YwMjkwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATOZ9L/0C25A3aqj9T7D/WkqiZIO0mdZ6I/ikG7bCrcWW/KCtRP9MZ62hCo\n9SQnKiLpQnsyemPaL5ST/Z/P4M73o2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUb1guGddyihLAzK7uxyn1mrOUyhswHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAMgl\n69+t+Wzdv9PzZ4AqNJS++zJvgX8c5g9KTR9Z/HY3AiA/1YnFZzYksr88Oge7kAJF\nKoxjn74C/1hLlxvmuEvkuw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAWUpRXedsuq1wR6VGCwqGec6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRkNTIwNmQ0ZC0z\nZjkwLTRkYjAtODM3Yi1jNThmOTc1MmI1NWYwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARqZrLjq8g0yK87SOG5XWY/qXoPg43bAEpoMTFFTrJvPslVOIGOxlyCBs0t\nX+JuKXNoN22MlrhqTth7P0y33Xlqo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYDAipQ9w9k47ZZPfdHCUpSVo1XYwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAMl1\nXI1mR6BszS/0q52HF/D84V1+ezcAqtRl7jXjowQiAiB7gG7enR4imJ2VBLD3RN4A\ninmLlIolF19X6vGrCWM3uQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAV9chgkVQMn2GFYHbhmXbUBlMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDRiYThhZGUyLWU3MDYtNDIwZS04NmM4LTAyMzhkMTk2MmYyZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZWRkYWNiODYtYWJlNi00OWIz\nLTgzZDAtMzIxOTg2ODVlZTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGFay\ncD6qp5vOBpmjtvjQg0w5awCW8SbYLJdhdv5YroOrftsp0lvW9nnezi0O3pB2J2og\nmleev+ma/MCem8hjr6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFOCDaXbZIstEAU2LQrAWVA6Gewp+MB8GA1UdIwQYMBaAFFK2\nifDy5PokBMxgs/HwxUmrRwatMAoGCCqGSM49BAMCA0kAMEYCIQDytDxL9DW6sF64\nDLO9zwYR7BeiNtfSXrRARzpHqEtRHwIhAORd+Ic2zfbeonb3pWMRO6ycuBws8kOo\ncx26xbd9lqs5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAcTqMZhLo05m/AmfZ2IHTMPkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZWRkYWNiODYtYWJlNi00OWIzLTgzZDAtMzIxOTg2ODVlZTE1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkNGJhOGFkZTItZTcwNi00MjBl\nLTg2YzgtMDIzOGQxOTYyZjJlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7Gjw\nCWVJ4FYw/ch/nhC8rQCl4XuPCR3YJutx4pcBI2P57sV2zoAc8DdoFtGGL0r+Te5T\nl/iSrXesT/YwpJbKWaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFFK2ifDy5PokBMxgs/HwxUmrRwatMB8GA1UdIwQYMBaAFOCD\naXbZIstEAU2LQrAWVA6Gewp+MAoGCCqGSM49BAMCA0gAMEUCIQCR02xNSZRmtoPV\nGRopK8LmSPSz0Bc/gsp56czq/tzohwIgCmwvohsZXPAmfVLq22EoRA/jfOrGtCEU\nI6i/dLbDe0A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB8TCCAZigAwIBAgISAR1vNxJWSC7LG7qE2O1Gkq1PMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGY4OTAxZjhlLTJkYzAtNDM5ZC1iNGZhLWExMDY2MDU0NDJkODAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZWRkYWNiODYtYWJlNi00OWIz\nLTgzZDAtMzIxOTg2ODVlZTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGFay\ncD6qp5vOBpmjtvjQg0w5awCW8SbYLJdhdv5YroOrftsp0lvW9nnezi0O3pB2J2og\nmleev+ma/MCem8hjr6NBMD8wDgYDVR0PAQH/BAQDAgIEMAwGA1UdEwEB/wQCMAAw\nHwYDVR0jBBgwFoAUs+toDele8vR2FAY67yqhVnffvvMwCgYIKoZIzj0EAwIDRwAw\nRAIgUBtFwRnpHF/omLPusSQPfmEB2hx7CnDl1mBzXD9dfpoCIHz9skPPTs8TgXVF\ncEwVmIjeL2PLAQ70HAtkJtestbtN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXjn0v9RRj8OGggtsId+cfPXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZWRkYWNiODYtYWJlNi00OWIzLTgzZDAtMzIxOTg2ODVlZTE1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkZjg5MDFmOGUtMmRjMC00Mzlk\nLWI0ZmEtYTEwNjYwNTQ0MmQ4MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuzAr\n3qQw/tZ+JLVBwX489PuGVjqDPN5FPHv8GS4gkMCEnFS7Npfa6wCB7K+c2nmDKwRa\nvtQAaSxUUTfFrPDztKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFLPraA3pXvL0dhQGOu8qoVZ3377zMB8GA1UdIwQYMBaAFOCD\naXbZIstEAU2LQrAWVA6Gewp+MAoGCCqGSM49BAMCA0gAMEUCIQDxkXNQ+jnxD3Mg\no5ee51k+uCbCKY6pytbQicqXLfAtbgIgC2gMs3QB6V7TNLo2Dy4GuBgrip/Jejau\nSEs9wdClhKk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAeXNpr4c0ZUmr3zdrhaBr3w0MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGRiNTYyMWY4LWU0MzItNDhjMi1hZGNjLWYxNzlkYzg0NjQxNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZWRkYWNiODYtYWJlNi00OWIz\nLTgzZDAtMzIxOTg2ODVlZTE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGFay\ncD6qp5vOBpmjtvjQg0w5awCW8SbYLJdhdv5YroOrftsp0lvW9nnezi0O3pB2J2og\nmleev+ma/MCem8hjr6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFOCDaXbZIstEAU2LQrAWVA6Gewp+MB8GA1UdIwQYMBaAFMPI\nA8Fe+kEklF2jEoSxcj/GpVj3MAoGCCqGSM49BAMCA0gAMEUCIDqiI5Ros5+vG5Ud\nqL3gFsP2b/IdhsTTbegBAzRoVeLlAiEA392Vc655An66dNAmau3f5xiFqScjpmNg\niF4PCczjV04=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAZ7xQIVNsooS0YDorVN4+pqIMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZWRkYWNiODYtYWJlNi00OWIzLTgzZDAtMzIxOTg2ODVlZTE1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkZGI1NjIxZjgtZTQzMi00OGMy\nLWFkY2MtZjE3OWRjODQ2NDE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEGOZo\nB7CpuSbYzmAWgUNQ0SZ6sbRZAU6NkR4fya2HFyK8rPqX4sjHR7kmX8/FP+mzDA9t\ne8AHaKCa4B+r2E8uyaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFMPIA8Fe+kEklF2jEoSxcj/GpVj3MB8GA1UdIwQYMBaAFOCD\naXbZIstEAU2LQrAWVA6Gewp+MAoGCCqGSM49BAMCA0gAMEUCIQDJsLb5R7/fVeoZ\neZP/Oet+h8j9ebvyy733U3lpzH17iAIgeTtXwba9d5G2HCGRiE1+K93RjLGRiBAB\niAdfoA/qVnw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcqgAwIBAgISAQ6CjGJs8sC1LLSvEyxQa28XMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJGVk\nZGFjYjg2LWFiZTYtNDliMy04M2QwLTMyMTk4Njg1ZWUxNTBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABBhWsnA+qqebzgaZo7b40INMOWsAlvEm2CyXYXb+WK6Dq37b\nKdJb1vZ53s4tDt6QdidqIJpXnr/pmvzAnpvIY6+jYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTgg2l22SLLRAFNi0KwFlQOhnsK\nfjAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNJ\nADBGAiEA3SdI+jB42CFz5cc5+JE80E34kQIFesjwii4YDo7uOLgCIQCqwsN29jxB\nn4+alYwPk5O6Ti0MIs96rAm1/Y4IJtDsJA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAeg+t9eaKKAOo4Dv7mSc5XgvMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZWRkYWNiODYtYWJlNi00OWIzLTgzZDAtMzIxOTg2ODVlZTE1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBTgg2l22SLLRAFNi0KwFlQOhnsKfjAKBggqhkjOPQQDAgNI\nADBFAiEAlZIZ/hwBdW5gU3BvQLXSyuXr2XdkYa5aF6wZr4UBYc8CICuA2G0V2NEo\nUd1fwHnFBNv+1Cal/1evukeqkAiOzYiM\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAYIaW0F3h4dm1LdLZoex987BMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDQ0\nMTYzZTdjLTNlZmUtNDA4Zi1hM2IxLTU3N2I0ZjA3ZTk5YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ4Y2I3YWNiYy04NGM5LTQzNWEtOTc5Yi1hODMw\nYzJjYzJhZTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAT9pLEoEYlaKWSvs17b\ngyLKWQGwnqxiZm/wtfhswlJtO/b6fQMnVrCORP/0opy2JSBWLeibHlydkkS3ElPt\n3wKzo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTJvVgUdRt2lAEiJgs4bO+oUF3ASzAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAJ5ZGPIRMmZg8L/G\ni2eZEjilsTrfv3DnC/2xGIez7V9WAiEAyTuUHRn/vZFd+7xpEpkDc1EOfQeYLOlp\nADu34w2neQo=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc68", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `68` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQbK+jNAOR/RxmzHrgZS8tQ0MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDk0\nNDQ5MWY0LTdlZmUtNGJkMC1hOTZlLWQwOGNhOTJmMDVkNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDcyMDZmMjNjLTQ5MzAtNDJkNi04ZGNiLTNmM2E4\nZDYxZWQzYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmz+sedcmQAj8KDD0e8\nYQv4LqR3BPgsyvbO5dU8PK0mVpwZMBAeHSz4lXyrG+kROJtdBKVXQ0z8eGCwqt+8\n8XSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTLWXhUUBr5IId2NX4heuBZppOOVjAfBgNVHSMEGDAWgBREyPB8dLmq2t/iSqI/\nhICs+hQsuzAKBggqhkjOPQQDAgNHADBEAiAqTnqv1bbAgJLH131NWN2YJUiK5jRK\n6U4sU0lMq1N9jQIgNZnh+XXREDm00yb3pAlbU/wDtOUXsuv6pZ7q9/FaEIg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATbwCD60MGf2jgiJXOPNGM0zMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDk0\nNDQ5MWY0LTdlZmUtNGJkMC1hOTZlLWQwOGNhOTJmMDVkNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDllZDAzY2Q2LWY1ZjUtNDc4My1hN2Q4LWY5MDQx\nNjk4OGExNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDk2Kij36c7s8NM6yvRn\nzyeqnXAzAZ5qtBoWl08SVJ3/Sw4vh3sGk0jW0LesXP/7vZiw5640mkVptmfrVNSf\nV1qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSZWlqcjtAdnysvexPHsuuOrvmGUzAfBgNVHSMEGDAWgBREyPB8dLmq2t/iSqI/\nhICs+hQsuzAKBggqhkjOPQQDAgNHADBEAiAeuXv7YD7RVm5SMtDZLr/aKyeqRL+8\n/N6b2XMSbCrC+gIgfFmL57KwZnwMtylUZub9UybxfynBwC30RIJARngd2tg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAW1ym+rmbf2OF4Vxd84a6AAXMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDll\nZDAzY2Q2LWY1ZjUtNDc4My1hN2Q4LWY5MDQxNjk4OGExNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDk0NDQ5MWY0LTdlZmUtNGJkMC1hOTZlLWQwOGNh\nOTJmMDVkNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABF2Zrta7dtStvO89oExf\nNkcW8oJfQYxmlxg/rVUnORV7z8cpoFMxCUXAty4YjlgslbudvQ72NiPisWcOpZMq\nh+OjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBREyPB8dLmq2t/iSqI/hICs+hQsuzAfBgNVHSMEGDAWgBSZWlqcjtAdnysvexPH\nsuuOrvmGUzAKBggqhkjOPQQDAgNIADBFAiEA4zWRaT7tHCpEf9KrDJLSYOIaF2nL\n8c1Qh5mc2Br8gFICIHLapEEPyACe9x3Un0GI7nADjBo3vJS3q0zY4f5N4ayI\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQZtje/dyaesPxFOv10WYJT7MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDcy\nMDZmMjNjLTQ5MzAtNDJkNi04ZGNiLTNmM2E4ZDYxZWQzYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDk1YTQ3OTE1LTVhMzItNDhiNi1hMjY3LTZlZjc5\nMTVhODg4YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJM/oJIiPXGtrBrA+pSj\n4gjqN0lYRdnEvP8h2QjoAUISS95oYEGSZQ7q2MibaJqmPFTMWfXE8DCYWX47VSFO\nwtijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQDLBKLXapTC0vdkDYKMN4TuheyBjAfBgNVHSMEGDAWgBTLWXhUUBr5IId2NX4h\neuBZppOOVjAKBggqhkjOPQQDAgNJADBGAiEA92hCyFjEUnP2Y1c8SZyiFA1u+LSs\nSgia6TPsSJHWx+wCIQDNFKDydxEBoVG1U55PVAsbBMbHYYEntkxTMeMiyBr3OA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfxCb/2xAXWzqK05tTbg+4kQMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDk1\nYTQ3OTE1LTVhMzItNDhiNi1hMjY3LTZlZjc5MTVhODg4YjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDcyMDZmMjNjLTQ5MzAtNDJkNi04ZGNiLTNmM2E4\nZDYxZWQzYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmz+sedcmQAj8KDD0e8\nYQv4LqR3BPgsyvbO5dU8PK0mVpwZMBAeHSz4lXyrG+kROJtdBKVXQ0z8eGCwqt+8\n8XSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTLWXhUUBr5IId2NX4heuBZppOOVjAfBgNVHSMEGDAWgBQDLBKLXapTC0vdkDYK\nMN4TuheyBjAKBggqhkjOPQQDAgNIADBFAiBxgeEJPsueNpwhKh06PHUlxMcAfyqV\nCFGW3t75U0qGIAIhAKGweoAi7JIr6fLyCh4L54pmnnNEKIxFP1lep1waEKeK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaD6JCW0c/PUhrmVkZirw/GFMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDll\nZDAzY2Q2LWY1ZjUtNDc4My1hN2Q4LWY5MDQxNjk4OGExNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDk1YTQ3OTE1LTVhMzItNDhiNi1hMjY3LTZlZjc5\nMTVhODg4YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJM/oJIiPXGtrBrA+pSj\n4gjqN0lYRdnEvP8h2QjoAUISS95oYEGSZQ7q2MibaJqmPFTMWfXE8DCYWX47VSFO\nwtijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQDLBKLXapTC0vdkDYKMN4TuheyBjAfBgNVHSMEGDAWgBSZWlqcjtAdnysvexPH\nsuuOrvmGUzAKBggqhkjOPQQDAgNIADBFAiEAxTrdLYlAPX8WXUWMjiljzl3ozCd3\n9+NQJYnDXPmRKBMCIGNJUvXF662c8FEvrlwPL29oASYRyVK+HozxBir6OJOa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAaYEdFHVTelDRwN0ptOx/DJVMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDc0ZmEzYWNiLWMyZDEtNDc0YS1hMGExLWVkOTVhNzdlMjA1MDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDk0NDQ5MWY0LTdlZmUtNGJkMC1hOTZlLWQw\nOGNhOTJmMDVkNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABF2Zrta7dtStvO89\noExfNkcW8oJfQYxmlxg/rVUnORV7z8cpoFMxCUXAty4YjlgslbudvQ72NiPisWcO\npZMqh+OjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBREyPB8dLmq2t/iSqI/hICs+hQsuzAfBgNVHSMEGDAWgBStiRaXvXIikxF0\nsmONY2b+rJMGljAKBggqhkjOPQQDAgNIADBFAiBZan2f6rEcFIKjuA0H+sxdRYj7\nYFluGMtw84p3JKD21gIhAJjvYcePjY4yFvuyK65pXHyOj8eUWXfPD1rS84AUU0Bj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAYulIPA07piCcgAN8lC20+SdMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDc0ZmEzYWNiLWMyZDEtNDc0YS1hMGExLWVkOTVhNzdlMjA1MDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDllZDAzY2Q2LWY1ZjUtNDc4My1hN2Q4LWY5\nMDQxNjk4OGExNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDk2Kij36c7s8NM6\nyvRnzyeqnXAzAZ5qtBoWl08SVJ3/Sw4vh3sGk0jW0LesXP/7vZiw5640mkVptmfr\nVNSfV1qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSZWlqcjtAdnysvexPHsuuOrvmGUzAfBgNVHSMEGDAWgBStiRaXvXIikxF0\nsmONY2b+rJMGljAKBggqhkjOPQQDAgNIADBFAiEA1vSXcqza7uEBb0Zo8zDX4r6P\nJBNJpB5zv+dURDTgaswCID+OWQgMF7Hhyt3ivTwARzjQnMqlqn3KuboA7lYkKOx/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARiVXtGVYLNfjBGKimZnn4u0MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDBi\nMzQ5NzcwLTBjMGYtNDRmOC05ODdkLWU1Yjc1ZDc3ZDhlNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDhhM2Y4MTFiLTRhNjEtNGY1ZC1hYTc4LWE1YWE2\nZTdiNmUyYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBqvkEDShG+6N3Mn+fQF\nG+9iK24UaHANdrQWtY1Gohf6HMpjVZvIqki7Qhk0xeENG8J1zG3xHE19xBTBWC98\nxDSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTst6FL36jldrqsM76nKRLta/L7iTAfBgNVHSMEGDAWgBQF99uo37rbWTU2IG69\nLZPnwT2N7TAKBggqhkjOPQQDAgNIADBFAiBnMZPfLy3mTC/+5ZE/rFRnK55AEOG8\nq/+hNCw43rtAAwIhAMOlSVqa6w6+QpidtfyX7tHgDj7PwnefKVtRmYrrg6tO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAabZjITqiUiXC1Q+mUYrCSdaMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDk1\nM2MxZTIyLTQzNmYtNGUxYS1hODE4LWVmMGM5N2U1NzdlMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJGQzODM2NDkwLTMzMTAtNGNkYS04YWUyLTM4Mjg4\nOTE2NDI1ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMtV9TJoY6V4CHPplHVu\nGXmFF/0g2mJ76Eu5IsNccp1TB7B8E9i7apMj49UQ6+bDvVdJ6vEkb7OFs+FvauYn\n2TajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQKaclLh1eBSNOIV0ySl46gOz2E5TAfBgNVHSMEGDAWgBRCkEX8/dk0gFrKNdZD\n/cZWxoH6MzAKBggqhkjOPQQDAgNHADBEAiA56JKgoIZEWwC5WRFqtZkW78/gK6lp\nrRSzgzpFoWfzvQIgIuorDWKxkjLMbS8mTHL1eOQVohMDFc5ar/Qsq/yg9SI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVB6+Z7416UuKi14Rpxmyq67MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDk1\nM2MxZTIyLTQzNmYtNGUxYS1hODE4LWVmMGM5N2U1NzdlMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJDJjZTFkY2QyLTZiZjctNDBkNC1hY2QyLTcwMWQy\nNjcwNTIxMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABA8/qe2M1ahIZqWDl6u+\nxtBJGJTa2V7xmRKMvHetngjIkzhqgOtBZ0rzhKXuB0ThnP1DyX1hBT4I2FJ/JcQM\nUgejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTeLDnmHRJG1bCPz1DYFh+TUndgezAfBgNVHSMEGDAWgBRCkEX8/dk0gFrKNdZD\n/cZWxoH6MzAKBggqhkjOPQQDAgNIADBFAiAuX9mUovFXAc82xN0xQyaqA6CUoPwd\nm37NVN9OgwuiFgIhAIfjiMvmRdpJmgA4PBDNIIL0gWwLNdwqA7qtaoliWrX0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZifAERlg/gRNR6OC22Na9BsMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDEzNGFhODMwLTY4YjctNDI5Yy04ZDVkLTQ5NDgyZjQyYjdiNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDBiMzQ5NzcwLTBjMGYtNDRmOC05ODdkLWU1\nYjc1ZDc3ZDhlNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEFefs6t7dQb+WG/\n8AweqXeASe9+7h7AtVarxDtB7ba3OXYSideHnwAhjBWySw02OtC8YGghrdXzhXN1\nyKOvrUujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQF99uo37rbWTU2IG69LZPnwT2N7TAfBgNVHSMEGDAWgBRNcjpD0rTnLC7h\n7BpYw9T3ZPXbqjAKBggqhkjOPQQDAgNIADBFAiEA8Qr4gKuMOrk/1+/JyOw6YmN+\n2HOTKJ1d76s1TmmbCh4CIHIlKf0veLOO9qg5O22vX7PDO7fx4hxl1C/7GeXh/Vpf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAWUTpNT7Ce1dqSD37ZtMy01kMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDEzNGFhODMwLTY4YjctNDI5Yy04ZDVkLTQ5NDgyZjQyYjdiNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDk1M2MxZTIyLTQzNmYtNGUxYS1hODE4LWVm\nMGM5N2U1NzdlMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCm1zvJccRxTGMf2\ni+7SbRxYh26hcOOgnRLJ3eGCo116W1dVudOk0FkAM6RlTHdHpIE4W/6wKvkQML2q\n42ZR/dCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRCkEX8/dk0gFrKNdZD/cZWxoH6MzAfBgNVHSMEGDAWgBRNcjpD0rTnLC7h\n7BpYw9T3ZPXbqjAKBggqhkjOPQQDAgNIADBFAiAlJAb4HEI2nLebhpgW83WKA3LM\nsJiphD5s86KbNLz16AIhAIruQ70W/zxYYa9seGUQKCIh3SqUUtUPGUnOiLiAtO18\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAV1YAXiZzFvM8D43NqCSYX3OMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDUw\nYTA3N2U3LTlkMTItNDUzYS04MjI0LTIyNjUyNjEwYzdjYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGI5YzE0ZWUwLWYxMTQtNDA1YS04YTdmLWVjOWM5\nYWFkYTc2YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPfGlD0YTy+JuVHdMTbX\nLY+LN5MVlYs1B9FWU1izKDequeHrxz8TEMIrnrMfV0DsQ/0DH0P11RereQlpIG22\nU4yjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS24nidBD03hpVbwtAVX1tGnYAjczAfBgNVHSMEGDAWgBSecxbAVAl12A6GYkjj\nedH8StVK8TAKBggqhkjOPQQDAgNHADBEAiB5eUBxcsyZ11+rLYNNSUIKo4LIkmlA\njKUIjvllGjWVLQIgNbSZ0mXAer9fjIKtV/+rzP8soU6jaDI2xjc+cl8DYl4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUgErTWkWpo5KOTt/d58bPp9MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDUw\nYTA3N2U3LTlkMTItNDUzYS04MjI0LTIyNjUyNjEwYzdjYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDA1OGNmZjA0LWNiNGItNGI4Mi04M2Y5LTkxMGEz\nY2Q3Yjg1ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEf3jKgyyl813JAOWRmd\nZFjvb7J2RIjeUposXsDJpUiBxHCIqfWrP0EIrL66LEZYujjWiH3jXjwDIXYQyiH+\nac+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSisBLqrlrR0drMrUMj1Ah+UgLzwjAfBgNVHSMEGDAWgBSecxbAVAl12A6GYkjj\nedH8StVK8TAKBggqhkjOPQQDAgNIADBFAiA4RcD9TBBa13GbjNvPSE+rzc8CyWAW\nOhIycpL4wQpH1gIhANpVd91Zo7ht54MFyQTovaEXNgX+H7tEye/dI0mFm8UE\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXjUknjd9rYfGfSCgtiku4RqMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDZk\nNzc1NmIyLTJjMDYtNDFlMy1iOGM3LTgxY2MwZmEzZjFkNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDUwYTA3N2U3LTlkMTItNDUzYS04MjI0LTIyNjUy\nNjEwYzdjYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDVKy+fvfBFrcrA8ZZVw\njbAyo0HUMrvnN6F5UDHYlALxZoKWDIUzVHguHwBcNG2apM3a4C0DNaEt24PnHjK1\ne8KjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSecxbAVAl12A6GYkjjedH8StVK8TAfBgNVHSMEGDAWgBQguAjeQadBxrGSoyNY\nW1xeAuO3vzAKBggqhkjOPQQDAgNIADBFAiBFlxmoQNvy1aGnvNjtfnJkh98fJwWY\npnNKBgxBHB7wCAIhAJUMYGSIrUv2sCDkNer7p+/QfRyQABcTUzw1gZCpnSy2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYixnndxTxGm77qeAAgtq0HpMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDRi\nNjgxYzA1LTljNDAtNDJiZC1iMDYwLTQ4OWY1ZThiMGEyYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDUwYTA3N2U3LTlkMTItNDUzYS04MjI0LTIyNjUy\nNjEwYzdjYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDVKy+fvfBFrcrA8ZZVw\njbAyo0HUMrvnN6F5UDHYlALxZoKWDIUzVHguHwBcNG2apM3a4C0DNaEt24PnHjK1\ne8KjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSecxbAVAl12A6GYkjjedH8StVK8TAfBgNVHSMEGDAWgBQoBOakwL8W+7f+nnYo\nTYXOfgJYVzAKBggqhkjOPQQDAgNIADBFAiAmPue3PzM/sGomNsnpnmfl0rfZN5k4\nboSbYLAulzg5/QIhAP2N40LJFoNuPWayDQAGdQOo7XRG4xPGpasZwM7nLAW+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdG6anuRxJYXFyH/osCcUMbcMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDZk\nNzc1NmIyLTJjMDYtNDFlMy1iOGM3LTgxY2MwZmEzZjFkNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDRiNjgxYzA1LTljNDAtNDJiZC1iMDYwLTQ4OWY1\nZThiMGEyYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOnPbWCRFcMPN8xVY1LH\nkmcZ7k+rrgBInP08zd5iM/WfLwZLHLxP5eWKllgj0S0l7yXUbvUmNe2gUcGuOk8Z\n8z2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQoBOakwL8W+7f+nnYoTYXOfgJYVzAfBgNVHSMEGDAWgBQguAjeQadBxrGSoyNY\nW1xeAuO3vzAKBggqhkjOPQQDAgNHADBEAiA3PBsDbOPrbQpQa+wh0d3KaFlI9Qxf\nAUSVGA2dS63p7AIgXvYG7A+0xhimH4uALl+jYakWInXNkCFEc4sh5kCY0zg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASy09LCNqyuj6yjiQfkze56HMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDRi\nNjgxYzA1LTljNDAtNDJiZC1iMDYwLTQ4OWY1ZThiMGEyYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDZkNzc1NmIyLTJjMDYtNDFlMy1iOGM3LTgxY2Mw\nZmEzZjFkNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK5Xqrln1QnLojpbTaBN\nbOlt1dj7wXBYaFSokKu0xQxWHlLyzQTfoUvEXYcXS6xjRugLthL+tzRheDK3fm/l\ndkejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQguAjeQadBxrGSoyNYW1xeAuO3vzAfBgNVHSMEGDAWgBQoBOakwL8W+7f+nnYo\nTYXOfgJYVzAKBggqhkjOPQQDAgNIADBFAiEAmus5dtAvdZ1lBSCiMwPNVyOZTHkm\nPowbzg3rZup1Ub0CIC6HwikqR/9epwkaU2YBRAV4Nx7wH2dIGVwaI76I+RPa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAX8yvCdn6V1jZ71MH4MYMzj9MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGY3MjllMGRlLTdiYzktNGNmNy1hMTVmLWI2NTFiMWY5NDNmMDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDZkNzc1NmIyLTJjMDYtNDFlMy1iOGM3LTgx\nY2MwZmEzZjFkNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK5Xqrln1QnLojpb\nTaBNbOlt1dj7wXBYaFSokKu0xQxWHlLyzQTfoUvEXYcXS6xjRugLthL+tzRheDK3\nfm/ldkejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQguAjeQadBxrGSoyNYW1xeAuO3vzAfBgNVHSMEGDAWgBT6vEj0ciLX1TkN\n2Jm3peSpC/o0/DAKBggqhkjOPQQDAgNIADBFAiBQoQZ53WrjD8YuG4y2AjLIduPm\nH/yFOepYZNde+02QqwIhAPF4YNKa+zqqQOxTnjntrckGSkUf3gQJIw0klQaTfdp4\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAQhbYI4bFhhMwdTBmYzOzbXEMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGY3MjllMGRlLTdiYzktNGNmNy1hMTVmLWI2NTFiMWY5NDNmMDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDRiNjgxYzA1LTljNDAtNDJiZC1iMDYwLTQ4\nOWY1ZThiMGEyYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOnPbWCRFcMPN8xV\nY1LHkmcZ7k+rrgBInP08zd5iM/WfLwZLHLxP5eWKllgj0S0l7yXUbvUmNe2gUcGu\nOk8Z8z2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQoBOakwL8W+7f+nnYoTYXOfgJYVzAfBgNVHSMEGDAWgBT6vEj0ciLX1TkN\n2Jm3peSpC/o0/DAKBggqhkjOPQQDAgNJADBGAiEAgnXHxaiuOUa0aRufaoLmKfZ3\n6lmKZ1uHPXjyuXj3of8CIQDwQN84UkZkIExk/R9U2W2VBXr0T8e2UCSf79RPrIol\nRA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWljR+hZlfL2gHn501STiuISMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJDJi\nNjQ5ZmYzLWY1NzAtNDNiZS05NjgzLWZmZTM4YmVmMzI5YjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDk5ODg2ZDk2LWUxMDgtNDhiZi04ZThmLWNlZWVm\nMzZmNjE1MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJBo1x0fNev+qci0xCJL\nhYVw3gGkrXFEIVHCnK1t2aECrdSeHhgoOT6JBlH+31yGDcaBXdm/CPz0+YkiTQTd\nyPKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTXQ/urXPiR1VR1RfhVt7WpBtM7HDAfBgNVHSMEGDAWgBQS/Kvz9GaMebxdfVOE\nrxBAaUYVHjAKBggqhkjOPQQDAgNJADBGAiEAh73F0Q3vk9pZlc7WPqP9Jmkh3irx\nE75lL/SIJNsaZZsCIQDFJVdLBode0E5+u8Ou6OGXAGjYzOZjaxj1+bUQY/Tj1g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVjQfBrHm906uTZyVhEKrwzsMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGE3\nYTE1YTQxLWNkOGYtNDA2OS05NjdiLWVkMDUyODhmYTNjMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJDJiNjQ5ZmYzLWY1NzAtNDNiZS05NjgzLWZmZTM4\nYmVmMzI5YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBAxdsYpuJdSVHiynCCY\nA+RL8xtaC42+l/qC+PcJy3GUfsXYXmftsrstpVU+AMyQ4Qc7bal8FqMOz6nDOhv0\ntJejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQS/Kvz9GaMebxdfVOErxBAaUYVHjAfBgNVHSMEGDAWgBTk47vhOFpDKNHOGB4h\nk1iccC3WYDAKBggqhkjOPQQDAgNIADBFAiA4Zvbj7oXsouHG5iH7dkQgK8Yf7gcY\nzuwb5Fgco3KdLgIhAI0bA4iPzXsz66y4hio39IBoDIxXwK2rcGku1NTbcRPx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbDfxm9rYKBZfHkZCk8Byu+zMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGE3\nYTE1YTQxLWNkOGYtNDA2OS05NjdiLWVkMDUyODhmYTNjMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDE1ZjBjYzVjLTE3ZGQtNDZiYS04YjhlLTA3NmJi\nMzc0MzQ3MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMr64MFLJOwo/4oY5M/F\nA6XPZS9XpdJEZVofJ8vQ8soXYFx+k3qIg6+Iswfy52DkGgU2bQUrahcRxyMw9kry\nN3yjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTrOsglJTtTCdV7bFbYba4rYjBjgTAfBgNVHSMEGDAWgBTk47vhOFpDKNHOGB4h\nk1iccC3WYDAKBggqhkjOPQQDAgNIADBFAiAdwdYHkF8dhTRArnxaCP+lMON8dHDl\nJR8k+7t8h5DuTgIhAOyPf01nNzLIRjYst8g+g5TnZjddBPb7XgW58wDhiypa\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZ1hNTMDpnGi6P7bNQNjwrjwMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJDNk\nNTdhY2RjLTZjNjUtNDQ5Ny04OTY0LWE2OTRiMDc4MDZhNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDk5ODg2ZDk2LWUxMDgtNDhiZi04ZThmLWNlZWVm\nMzZmNjE1MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJBo1x0fNev+qci0xCJL\nhYVw3gGkrXFEIVHCnK1t2aECrdSeHhgoOT6JBlH+31yGDcaBXdm/CPz0+YkiTQTd\nyPKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTXQ/urXPiR1VR1RfhVt7WpBtM7HDAfBgNVHSMEGDAWgBQwgGN3A0GOBDECNjaC\n7qc7CgBnMjAKBggqhkjOPQQDAgNIADBFAiEA7qWx8/4p8Y50teWVnN9OAc2uP2TJ\nWtTsu7EnsbyYtcgCIFtKQU4e1Z+6Mwcdmhj5+G6lwO+LKGbCBW1TUSEDkbyt\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAZDJ4Al0O0BjzPHtURXXYHphMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyRhN2ExNWE0MS1j\nZDhmLTQwNjktOTY3Yi1lZDA1Mjg4ZmEzYzMwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQ8IGrmS4g2xdo5AUCRUeVr+GYsMnP4oEP80hN5PEk2azKVqOoci8WfYnmO\ndVguTNBLFyUlVnPhfh6sK4HmTuofo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5OO74ThaQyjRzhgeIZNYnHAt1mAwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhANM8\nV7a/kuzEmsIZ9sw+DGRgJWSPjxpliavfAYyO0Tr8AiEAjDDPHeJ/JNK5gZkG2W3Y\nZNj+sirJCXv3wObS66bZhqo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAU65xAtnnGyKU3zFWJNGYRZtMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyQzZDU3YWNkYy02\nYzY1LTQ0OTctODk2NC1hNjk0YjA3ODA2YTQwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQVju/9H3seA2XCJkPTvWjBz7cTc6Q176F4ERZHJJzp98kM6EiIKg7AVDBJ\nJPVPMVWIvJVm6UK0ZKZrHtw96KqAo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUMIBjdwNBjgQxAjY2gu6nOwoAZzIwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhANxT\nQ4CrYb4aC2LNVqDKaA+la5SRD0BTQOMzYqmCVO0/AiEA0qHWNOZOuYZXrDHH9XTc\nCo51Adnz19E03piOssq8Us0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAQ1QAUdEhHvGnK+jpZVxFUEWMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDc0ZmEzYWNiLWMyZDEtNDc0YS1hMGExLWVkOTVhNzdlMjA1MDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMzFiMmM2YTAtMjQ5Yi00Yzcy\nLTk2ZDQtYTllOTMxNWQ5NmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVESa\n8rj2OJww5RG+UX0ncXGvtbk8UrxFFSFk5bUw/Es5C70Hq4SCJBVlH7RVfPsal613\nrEdTXAXlgyBvKeM4qaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFIk0LG/9kGRsCRsSvXK5lowWhuiMMB8GA1UdIwQYMBaAFK2J\nFpe9ciKTEXSyY41jZv6skwaWMAoGCCqGSM49BAMCA0kAMEYCIQD+IGg0BHgEJyPq\nNw4nuJ+EF/Sz2YNrGn/FLRu6Ku9p+AIhAOT/JW4hAhMV62QVR0m1GgXUM7ZzcgTX\nD4cKXTOWlsd+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAbjGZcAqwj6OROuEUtKdGDXdMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzFiMmM2YTAtMjQ5Yi00YzcyLTk2ZDQtYTllOTMxNWQ5NmQwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkNzRmYTNhY2ItYzJkMS00NzRh\nLWEwYTEtZWQ5NWE3N2UyMDUwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzqzu\ngV56RU/r7mUn0sbTMG1pkwZ3Flh3jfA0+YJNxGJF1usMBbSVJCLDSMTXK3N2ePvm\n6KKJlD406beRFCy116NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFK2JFpe9ciKTEXSyY41jZv6skwaWMB8GA1UdIwQYMBaAFIk0\nLG/9kGRsCRsSvXK5lowWhuiMMAoGCCqGSM49BAMCA0kAMEYCIQD14VHlv3mAZk9r\nPf2u14MT5c3lej9H8XRBkbWWsuBleAIhANPVKkbw02mqpqjRItYK5pv7QJIFtrQr\nUtR9fIpbWvq/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAZmKp+9SZcXssj7GHAhIMWKnMAkGByqGSM49BAEwVjEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMk\nMTM0YWE4MzAtNjhiNy00MjljLThkNWQtNDk0ODJmNDJiN2I1MB4XDTI2MDExOTE3\nMjU1NFoXDTI3MDEyMTE3MjU1NFowWzEWMBQGA1UEChMNYmV0dGVydGxzLmNvbTES\nMBAGA1UEAxMJQnJpZGdlIENBMS0wKwYDVQQFEyQzMWIyYzZhMC0yNDliLTRjNzIt\nOTZkNC1hOWU5MzE1ZDk2ZDAwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARURJry\nuPY4nDDlEb5RfSdxca+1uTxSvEUVIWTltTD8SzkLvQerhIIkFWUftFV8+xqXrXes\nR1NcBeWDIG8p4zipo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0TAQH/BAUwAwEB\n/zAdBgNVHQ4EFgQUiTQsb/2QZGwJGxK9crmWjBaG6IwwHwYDVR0jBBgwFoAUTXI6\nQ9K05ywu4ewaWMPU92T126owCQYHKoZIzj0EAQNIADBFAiBxJX65b/s1ASnPbafb\n0vUggVFtPn/gpcCVZ1lBmeGeMAIhAMjebo/3l2utMptBcy8+IIrw/rNlmfkvpSXU\nwd0yfzAU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAQtPAExK+Il6xaku808/izycMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzFiMmM2YTAtMjQ5Yi00YzcyLTk2ZDQtYTllOTMxNWQ5NmQwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkMTM0YWE4MzAtNjhiNy00Mjlj\nLThkNWQtNDk0ODJmNDJiN2I1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAES/VM\nTfbHwZVh0UE9a0N+Ea2sJfKEmUJZ5W4uM6+Pk+Vd2VLrzpjwvMbCICmdfRx1OGoA\noxJbpzXfwCixSfedA6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFE1yOkPStOcsLuHsGljD1Pdk9duqMB8GA1UdIwQYMBaAFIk0\nLG/9kGRsCRsSvXK5lowWhuiMMAoGCCqGSM49BAMCA0gAMEUCIQD3Ex53QTHcq+5N\nglhSaBggW2U9EFlBBqNs6ASmzmTvXgIgRSUMVQJLtZ9+1Q13z3anS4N/LY/bMLo0\nt13LwTLoThY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAT8cUYtPit1ydsKM/t0g0KEcMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGY3MjllMGRlLTdiYzktNGNmNy1hMTVmLWI2NTFiMWY5NDNmMDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMzFiMmM2YTAtMjQ5Yi00Yzcy\nLTk2ZDQtYTllOTMxNWQ5NmQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVESa\n8rj2OJww5RG+UX0ncXGvtbk8UrxFFSFk5bUw/Es5C70Hq4SCJBVlH7RVfPsal613\nrEdTXAXlgyBvKeM4qaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFIk0LG/9kGRsCRsSvXK5lowWhuiMMB8GA1UdIwQYMBaAFPq8\nSPRyItfVOQ3Ymbel5KkL+jT8MAoGCCqGSM49BAMCA0kAMEYCIQDCzXyDdNCqRSPM\n80Emz2JX095SepxRXylQXXzFpWOAewIhAMBFFKQR46Q0mJWSdiW0B1rTRmbtc8XF\nhLylaPBmHzb3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAS78j2hjF6fNSMyAm1uefTTsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzFiMmM2YTAtMjQ5Yi00YzcyLTk2ZDQtYTllOTMxNWQ5NmQwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkZjcyOWUwZGUtN2JjOS00Y2Y3\nLWExNWYtYjY1MWIxZjk0M2YwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdmia\neoCe8k9iDZ9GO8SmaIMZvqwAmQZMo05lcLh5DxbOV4AxO4XghyrvVEzFC8aLS2eQ\nbnDHtssDzDS7oPspiaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFPq8SPRyItfVOQ3Ymbel5KkL+jT8MB8GA1UdIwQYMBaAFIk0\nLG/9kGRsCRsSvXK5lowWhuiMMAoGCCqGSM49BAMCA0kAMEYCIQCp1bmEstbf/PhQ\n9kOdB1PGwBI2rTor+orgiYZwCXoxRQIhAMnIWMXChoyfwNe2OE+1luKRNWJHMjvk\nzMxjEsKyjFW0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAUNT04e0DJyNdeM7NbjOAyJSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDMx\nYjJjNmEwLTI0OWItNGM3Mi05NmQ0LWE5ZTkzMTVkOTZkMDBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABFREmvK49jicMOURvlF9J3Fxr7W5PFK8RRUhZOW1MPxLOQu9\nB6uEgiQVZR+0VXz7Gpetd6xHU1wF5YMgbynjOKmjYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSJNCxv/ZBkbAkbEr1yuZaMFobo\njDAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNI\nADBFAiEA1rruZ9wlbUu9TOeGMkc10pK6bBCR8Zs0uQL56+UjDMcCIFx8keggdZj2\nEwo9QPG4Uo+HVx8VzSV04+zdobsVqzDG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcqgAwIBAgISAdXJdSFn/mFN9Yjj/TtbaV1GMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzFiMmM2YTAtMjQ5Yi00YzcyLTk2ZDQtYTllOTMxNWQ5NmQwMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBSJNCxv/ZBkbAkbEr1yuZaMFobojDAKBggqhkjOPQQDAgNH\nADBEAiAqVTJ9+ju8Ay/D8M8iFYaUO0rJHMLhW9Ji1EfVAuNZmQIgPSi7h7PaJ2np\neeZINftE9afFWtWSruaGRvX9/Na6Dw4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAULRGH8NgquGF0kY3VWWKoyAMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJGQz\nODM2NDkwLTMzMTAtNGNkYS04YWUyLTM4Mjg4OTE2NDI1ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRlMWNlZjcxMi1hY2Y4LTRmMzQtOTg0MC0zZjc3\nMWVlNjM5NjcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARUrMygc4AVP25RRn8M\nG9wzhQcin45cbeYgzokdHjijmlr9T+eHnTSXLsIH+qJt1QUfcy+FV1QAKzT1zivg\nvteCo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQKaclLh1eBSNOIV0ySl46gOz2E5TAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgWpgD2r9MUkXttFRW\ndM8xhpZarmIxF9WaaftwHa1F8YYCIGM33jwygjhM04kIwn/X/zTk5EatQIcckPFG\nIiur9W90\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc69", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `69` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISATtGYnCFYB7qWyzFVI3y2ksqMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDc0\nM2EzZmU2LTcxM2QtNGE2Ni1hY2FiLTczN2QyY2EzZmE3NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDNkZmUyOTdhLTQyMGMtNDk2ZC1iMzhiLTY4N2Q1\nOGFkMGQ0ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLLkaGyZJWGhqDNSmXk6\nYwHtwSK/EXp1RgjHNHtwFXBHdEUsiA3uEbG2AHozC0YyYx5ll/MRQR1daHVC988g\n1dijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQyQ3HdLTAkztghLwsblPFRvF1SjTAfBgNVHSMEGDAWgBT6So08evWMAIUGW4NK\njunnk+U5HjAKBggqhkjOPQQDAgNJADBGAiEA321Q+FqfDFfhS0nO270Q50DaTwRJ\nJAaVGzGeN9RR2AUCIQCkY312zkQnQz4D5T15/25DavZpNXn8/Mka+bOiGUc+dQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAR848UoP6HW6yZEtn0QMJyOgMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDc0\nM2EzZmU2LTcxM2QtNGE2Ni1hY2FiLTczN2QyY2EzZmE3NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJGMwYWVjZmZiLWFjZTktNDBhNi04ZDVhLWM0OWIz\nYWVlNzZiNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLGlH7E0b0pNWYE3QQlb\nzeXfqgSC/VdgK6jXvpkBWNqVw9dZhyCQ/dF7KfBMGHNjUcQLkKbekZNQoJ5NYh8n\nsZajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRkuc7Y6ltTnxp0inocQNgt586M8jAfBgNVHSMEGDAWgBT6So08evWMAIUGW4NK\njunnk+U5HjAKBggqhkjOPQQDAgNIADBFAiBkeioAeWturY1akmHbaSB18fGS1byD\nN513F7aResfZPAIhAKjEnG19BxfzpSs8gwt5Pa1P5UmWku9e3Y/mmxx5jY0q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbQPwWTTG5ZQnJPYwW0CP6eFMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGMw\nYWVjZmZiLWFjZTktNDBhNi04ZDVhLWM0OWIzYWVlNzZiNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDc0M2EzZmU2LTcxM2QtNGE2Ni1hY2FiLTczN2Qy\nY2EzZmE3NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMTIv1lzWVNeeNcy872W\ni6TjbWMhpNInOkcjExNK2ROmH0TlieqsS6BvcrRfNkxSCu+JLZuiGP0JX1MSEcgb\ncbCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT6So08evWMAIUGW4NKjunnk+U5HjAfBgNVHSMEGDAWgBRkuc7Y6ltTnxp0inoc\nQNgt586M8jAKBggqhkjOPQQDAgNIADBFAiBh7j/vj96KuCBu7Bk64zR2zkNBQ87F\nZjMBpjp4ShmPEAIhAOqFRKQr00kWM6vqzrSpBcRWiwdkS0sNhZa5VfpC2L9j\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYA2g7wiOrDZyR84HNMy6og6MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDNk\nZmUyOTdhLTQyMGMtNDk2ZC1iMzhiLTY4N2Q1OGFkMGQ0ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDg4OTI5MzQyLTI3NTgtNDVkYi1hNDFkLTE5YjEx\nYTkwOTExZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGj1IexNXrLqCyuaymsH\nevoHmf2qPGE4zYL8BKSPKMGBTXoMX9SE/yynLvnBeDQFEKEuxbAeg/ppyTR5BZyZ\ni4ujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSHcdFDsHKuzjQvJIi/F4uKeq0tSDAfBgNVHSMEGDAWgBQyQ3HdLTAkztghLwsb\nlPFRvF1SjTAKBggqhkjOPQQDAgNJADBGAiEA+HYT/7LrkLlBa7QZAt1j/xs+DWVS\nNwzbjSwchxcCg2MCIQCT7ZGq7CM/v9QqMw6GsQlOOE3pQGqKmx0ZhJ9jTws1eg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcu2KvG6TXOcjhdI06NZXnT4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDg4\nOTI5MzQyLTI3NTgtNDVkYi1hNDFkLTE5YjExYTkwOTExZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDNkZmUyOTdhLTQyMGMtNDk2ZC1iMzhiLTY4N2Q1\nOGFkMGQ0ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLLkaGyZJWGhqDNSmXk6\nYwHtwSK/EXp1RgjHNHtwFXBHdEUsiA3uEbG2AHozC0YyYx5ll/MRQR1daHVC988g\n1dijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQyQ3HdLTAkztghLwsblPFRvF1SjTAfBgNVHSMEGDAWgBSHcdFDsHKuzjQvJIi/\nF4uKeq0tSDAKBggqhkjOPQQDAgNIADBFAiBwtJ/H4K9REd2R8N3MsxIe8OCWLx1u\nDRp5JE4vdpCH9gIhALNA8a7sTXUxemEWso+CKIBmxS3/nPEit8BUpadzmK5w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXirOAyqe16kvZI8BHT28kTsMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGMw\nYWVjZmZiLWFjZTktNDBhNi04ZDVhLWM0OWIzYWVlNzZiNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDg4OTI5MzQyLTI3NTgtNDVkYi1hNDFkLTE5YjEx\nYTkwOTExZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGj1IexNXrLqCyuaymsH\nevoHmf2qPGE4zYL8BKSPKMGBTXoMX9SE/yynLvnBeDQFEKEuxbAeg/ppyTR5BZyZ\ni4ujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSHcdFDsHKuzjQvJIi/F4uKeq0tSDAfBgNVHSMEGDAWgBRkuc7Y6ltTnxp0inoc\nQNgt586M8jAKBggqhkjOPQQDAgNIADBFAiAuwSKakVXW/FJ4QIysHErPkV0DG1wo\nLKmuCM9Ys2x9ogIhAISKoYJVq6nmw/cAxKWgA3G3wi41SY4Ogbuon1ErWTKr\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAbGCKTBFfkN6R5355U3CJeS5MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDhlNTExMmVmLWNlNTUtNGY4OC04ZGI2LTg0MzFmMGU5MTNhYjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDc0M2EzZmU2LTcxM2QtNGE2Ni1hY2FiLTcz\nN2QyY2EzZmE3NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMTIv1lzWVNeeNcy\n872Wi6TjbWMhpNInOkcjExNK2ROmH0TlieqsS6BvcrRfNkxSCu+JLZuiGP0JX1MS\nEcgbcbCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBT6So08evWMAIUGW4NKjunnk+U5HjAfBgNVHSMEGDAWgBQcY5XhpOMLCihS\nZx9o17TyQx/pNTAKBggqhkjOPQQDAgNJADBGAiEAqyj7BpEIPCOPjt1y3TtRCXUa\ngBOKNHs8zHhOb9OX3pkCIQCh2b94/WQT72+7C9nG4Or6LXJXlZ3y92hS5BokzVC5\neA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISARsBVtYHYD5edIRS7VSVny0ZMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDhlNTExMmVmLWNlNTUtNGY4OC04ZGI2LTg0MzFmMGU5MTNhYjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJGMwYWVjZmZiLWFjZTktNDBhNi04ZDVhLWM0\nOWIzYWVlNzZiNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLGlH7E0b0pNWYE3\nQQlbzeXfqgSC/VdgK6jXvpkBWNqVw9dZhyCQ/dF7KfBMGHNjUcQLkKbekZNQoJ5N\nYh8nsZajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRkuc7Y6ltTnxp0inocQNgt586M8jAfBgNVHSMEGDAWgBQcY5XhpOMLCihS\nZx9o17TyQx/pNTAKBggqhkjOPQQDAgNHADBEAiBymA9mXvZQSoeR09e9Y8HK2YQ3\nvHhC12qKNu71sj2VRgIgZwTNre9VVMWvpHWUEL/6b5FnELbTkzqT3pgNdWy0c0k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAageA6LcXmET8jHh17H5xTigMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJGU4\nMWUyNjNjLTNlZGUtNGZjYi1iZjBhLTQ3MjhhNDdhNzRlMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDYxNGJjODZkLTZiY2UtNDJkYy1hY2JmLTUxNDc0\nNmE1NDBhZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABL8CjKvAAaTQmwM6sLiY\n7NNyQaFn3MZGMxsDCiENuh8zPSn+1gKOjxzmk3CuzACJzonh1vBBLNTSjRlSn4U5\nZIWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRICT0d8uplMGAQ/EBA+5uEfo+QwjAfBgNVHSMEGDAWgBTZqdhW/wnkYXKKv/IP\n2dYYmzDRRTAKBggqhkjOPQQDAgNJADBGAiEAsFOa7vRwnJ3G1HSX9zJU/O00v7Xf\nBSu96BhzGQeHHRQCIQDMKWlJ8aaYLvmwOM3dBYZOrFA3MNYy+mYAAEbQ3ps1vQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQj1uKo+dpp5yDAQLuB8jxiTMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDcx\nNjM0MDVkLTNmNWMtNDA2Zi04ZWI1LWYzMDk1NjFhNzNjODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJGIxMzBkOWY5LTI0ODgtNGVlMS1iYWZjLTdhYzkw\nZGQwNzNhODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABA13mmCcbOy4hqY7v3Ks\n0DyyCmv/DPIscQb+vPja9vhOVGooKQeob6Zl1C4G5nXvFwIm0cRXUXLFznPIoIeG\neqGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRf7t0V9NLcLCK5JJ2vc2x3LpcXSjAfBgNVHSMEGDAWgBTTooFG5hUJ6R60fuLY\nBL58VqxgSzAKBggqhkjOPQQDAgNJADBGAiEA2uOmSTx+hGFB2s1Kv0dXyhdM8VKB\n1wlcCv/B5seiTXsCIQC2u7HjR/QMUrj/rQjbYVXfwYm3Zo2Wp71d9YwCeiiHOg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZzcUSQEUjSDcvMFbNqbITsIMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDcx\nNjM0MDVkLTNmNWMtNDA2Zi04ZWI1LWYzMDk1NjFhNzNjODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJGJiNDM3OTQwLWYxZWQtNDkzZC05MWRjLTQ2MmM2\nZTE5YzdlNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOcFCTjvW2Eh5ZDRCWwJ\nSn0WGjvXGtycIPvZifNWzWAVBYoubKGXVX9wPZwxQ6VVenOrZiTx24LowSVdnlZz\naLujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQD4FsD3kwLUx4R91pgOG5E/7+TmzAfBgNVHSMEGDAWgBTTooFG5hUJ6R60fuLY\nBL58VqxgSzAKBggqhkjOPQQDAgNJADBGAiEAkAwnqPkUl5Ra6TTZQn6ysVY+Vqhb\nPWee3mbSk620wtQCIQCJQJCbvbS+6mGt0e4fzgYIv+d0AfF8igCSzHQlT0sDkw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAWbnMSlh76rYTJOjGA3Md55UMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDczMTM3ZDYyLTQ4ODYtNDdkYS04ZmY5LWQ4MWQ3NjUyYTNkOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJGU4MWUyNjNjLTNlZGUtNGZjYi1iZjBhLTQ3\nMjhhNDdhNzRlMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABP8CtYr0wL0iY9iH\nWGZ1ybty/4aTOYrIla4GhbrHLMQkYIvKFsYFql7ubECC5JJJf62cXqv2nChC7uaM\nPXXQvBWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTZqdhW/wnkYXKKv/IP2dYYmzDRRTAfBgNVHSMEGDAWgBQzNUpLf1y/AhEO\nNUJPNACvQNbJ/DAKBggqhkjOPQQDAgNIADBFAiEApCX5nAMfvIcdq30XeiMmX26Y\nCJjZKLq0xPK8jM8bBNsCIBKAJkKhlj2pP4HKS7Ef1BfyBjfnADbS35FskV/xCceX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAdcdQm4Tvoz64SjEwVKw43c0MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDczMTM3ZDYyLTQ4ODYtNDdkYS04ZmY5LWQ4MWQ3NjUyYTNkOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDcxNjM0MDVkLTNmNWMtNDA2Zi04ZWI1LWYz\nMDk1NjFhNzNjODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNY92f9BJJnkSM6u\nSDIBQldMzid9svB1M5oEalqpDoNgKmcq5jP2xYwmLfF/iut+QqbDX5gq7Sii2cHX\nN1M5f6SjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTTooFG5hUJ6R60fuLYBL58VqxgSzAfBgNVHSMEGDAWgBQzNUpLf1y/AhEO\nNUJPNACvQNbJ/DAKBggqhkjOPQQDAgNHADBEAiBc5hG46R08ZgaDHZ6yX5Tw2bqs\nAhIVZToMO27GzzSQDAIgYDxzSg6OefvOpkNE6ylx9HuiYte+KHO7RjQxxo2/sOI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAToMIxVt13yU8f7Pt6EyFVE4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGQ0\nODIxMzE2LTY5ZTItNGVjOS1iYzdkLTYwYWI4NWRhMzJmNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGFmZDhiYjIzLTE4ODktNDBiMC1iNzcwLWQzNGI5\nOGMyMjY3ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD7Jx9FpJ3Iph1vw3jF1\nlGK8MWwavQOG/6WT7yQAUv6L75bfdU/odg5xo0YMG8HcYf899yPkPmSvQ9mafRgs\nQ0+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR/Fp4bpafXtNgMTDfz/conj/yXSDAfBgNVHSMEGDAWgBR8Xr6A3BSsdeisb9f5\nt9LS/tvd/jAKBggqhkjOPQQDAgNIADBFAiAVMtYwjhtmi3bzoXs7LempQqNZWuYN\nFpBw4A18ibSqcgIhAKLGd5KRrUu6STokqIgvSkYoxN3WWHWPA/vLda6urrOX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASF54NeoDtA2rm/biPcTw404MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGQ0\nODIxMzE2LTY5ZTItNGVjOS1iYzdkLTYwYWI4NWRhMzJmNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDhiMTYwNTc1LTNhN2EtNGQzOC05NTQ2LTc0NzYz\nOGMxZTBmNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBkYkJ561VdRdX07Ho/T\nNbQUeY14VBpdf6eGh66eC5l/CzCL51+ALcd/dcM8Zq0fE9tC6Cz8akpJHgUtahta\nbhWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRIp4GhU3hDCk9oSUBy2ZUXoduHaDAfBgNVHSMEGDAWgBR8Xr6A3BSsdeisb9f5\nt9LS/tvd/jAKBggqhkjOPQQDAgNHADBEAiAguvOKWzsBbN8mYm6iyQ6tUIiG6bbi\nP4PA3MxuBLviBwIgVEJeXodar/I7+DVUCugA1THazcRNZLQFqyMR6ZxBaxI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAf0kosHPSpnseo5+gk0Wv93XMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDMx\nOGNmMzE3LTllNzQtNGJhYi04MzljLTIyN2FhMzM5ZDVkODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGQ0ODIxMzE2LTY5ZTItNGVjOS1iYzdkLTYwYWI4\nNWRhMzJmNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD+YH5HrqG+N7dFmOQIA\nOaw1k9iZ3Eak3dJ0XnwCTq4K46FG4cdmUC7q5+0m3xSqUbyg5Vnj8EDWZJ5/wUl6\nkNCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR8Xr6A3BSsdeisb9f5t9LS/tvd/jAfBgNVHSMEGDAWgBQvhg4s1TDXdLHwqkJq\nKYVk8HJhrzAKBggqhkjOPQQDAgNJADBGAiEAp/qfdrW4EYKxYwutoQ/Bnp3yVRFF\nGVHAZZkTQM1IevICIQDt7pqj6TJ9nOjyWnl/yqh+rIl/58gQA3idUGIGs7DZeQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQ/zfXClAUhMLWABAX+rVx+iMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGZl\nODc3NWZmLWFlNTgtNDhmZS04Yjc1LTY3NzAyNzQ2MDIyMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGQ0ODIxMzE2LTY5ZTItNGVjOS1iYzdkLTYwYWI4\nNWRhMzJmNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD+YH5HrqG+N7dFmOQIA\nOaw1k9iZ3Eak3dJ0XnwCTq4K46FG4cdmUC7q5+0m3xSqUbyg5Vnj8EDWZJ5/wUl6\nkNCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR8Xr6A3BSsdeisb9f5t9LS/tvd/jAfBgNVHSMEGDAWgBRTTYGN4bZPKvFNoWn+\nigyDgCIY2DAKBggqhkjOPQQDAgNIADBFAiBLVB2scYhMEbMfkK4EkOzTDGqgcBO4\nbSRA01GaAGXG/QIhANSfFmyrVLdeww8j2/9T5nyO+8S1cS/31HeRyEE7R3Nj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAb64NbJ14WicGHX+5A/uqzY/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDMx\nOGNmMzE3LTllNzQtNGJhYi04MzljLTIyN2FhMzM5ZDVkODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJGZlODc3NWZmLWFlNTgtNDhmZS04Yjc1LTY3NzAy\nNzQ2MDIyMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJaNJQkXuSA6A2Sq+WQg\n66+JKXFdQ0IbmHOOOCd0Me51aNffld+xuy3pMUsJ5aN8D9GsZhVJqpQXBHHF4x0N\nWu6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRTTYGN4bZPKvFNoWn+igyDgCIY2DAfBgNVHSMEGDAWgBQvhg4s1TDXdLHwqkJq\nKYVk8HJhrzAKBggqhkjOPQQDAgNJADBGAiEA+0PHVf7EqsssbpzpyHrp7m9kahxs\nwPdtAuZMg3CsyPICIQCgmTtAgOoD7SXtvxhiIuf6cMpNbSX7cof2csyGPbJE9g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAb7FgxrC94CXNOdSlZE6cyXFMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGZl\nODc3NWZmLWFlNTgtNDhmZS04Yjc1LTY3NzAyNzQ2MDIyMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDMxOGNmMzE3LTllNzQtNGJhYi04MzljLTIyN2Fh\nMzM5ZDVkODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE7QE3gBW7LRUDAylvoG\nMLcGVXA7a/eS2HEBj10oducqMIVNREh6d4EwQDoje4HQ1/0fy4di6xNEiGz0cunu\n9YSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQvhg4s1TDXdLHwqkJqKYVk8HJhrzAfBgNVHSMEGDAWgBRTTYGN4bZPKvFNoWn+\nigyDgCIY2DAKBggqhkjOPQQDAgNIADBFAiEAjQSnHuBKXGbDG0KOOkemrM8YY9Oh\n3Mu18B+qTzVrClwCIADHRvR2LKJh2VlK+Gvf/Rr7gcZ/LQ206BsXigcUate7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAYs/gNWTqxktgkCx/Y8RC+1lMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDM0NzQ2M2YzLTI4YWQtNDk4NS05YTE1LWVmMTI4OGM4OTJjOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDMxOGNmMzE3LTllNzQtNGJhYi04MzljLTIy\nN2FhMzM5ZDVkODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE7QE3gBW7LRUDAy\nlvoGMLcGVXA7a/eS2HEBj10oducqMIVNREh6d4EwQDoje4HQ1/0fy4di6xNEiGz0\ncunu9YSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQvhg4s1TDXdLHwqkJqKYVk8HJhrzAfBgNVHSMEGDAWgBRxC9UEn5s97CMZ\nTuVc3sQsRRrOcTAKBggqhkjOPQQDAgNIADBFAiBCT7zqhsJ0PSywHzaATqogy7G7\nDshA04L629Lu5bYgTwIhANnw3p/rS+QXtXVXfOlbVpQDh3gKvIrlfg8RtgKo7EV8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAbwJUxgGPp03v7dsduxlV7BLMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDM0NzQ2M2YzLTI4YWQtNDk4NS05YTE1LWVmMTI4OGM4OTJjOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJGZlODc3NWZmLWFlNTgtNDhmZS04Yjc1LTY3\nNzAyNzQ2MDIyMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJaNJQkXuSA6A2Sq\n+WQg66+JKXFdQ0IbmHOOOCd0Me51aNffld+xuy3pMUsJ5aN8D9GsZhVJqpQXBHHF\n4x0NWu6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRTTYGN4bZPKvFNoWn+igyDgCIY2DAfBgNVHSMEGDAWgBRxC9UEn5s97CMZ\nTuVc3sQsRRrOcTAKBggqhkjOPQQDAgNHADBEAiB+eNLEyi8Xv8VY6kGF47oLZZus\nkwdeZJd3omTSL8RlfgIgNxYy1tllpxEKah5DZFserkeDS7nDsoUBQW0MuM9loLk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAS0tYSQjEUwvN5k5JNn6D35EMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJDY0\nMzE4ZDg2LTFkYTQtNDk0Yi1hMjc5LWRmMmNlZmVmMzM3MDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDQxYjg5OTQ2LWVlMDgtNDI3Ni1hOTU3LWE0MTg3\nNTYxOWU3MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO8FOeId54Vlhi1gLSVH\ncXtb++o2/SPyWAwvrwMG+5JFFn3m4t5mwEMM+LZM7jmMFGgCClN+91RmDU2XttYm\nGSWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQrYmK4y2eU7k8gv6+f5pAeWvoJgTAfBgNVHSMEGDAWgBRyjEMO+HzOkhYdpDhG\nO5hHEr3CnzAKBggqhkjOPQQDAgNIADBFAiAbNu9dqXuqECL+QBdxyiCFk5w98/8y\nL9k96gD0KebyPAIhAJHH+Cls4K8RgIH7xzYaQQXqknxXFZyGwmou8h+7QWBD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdR7blc6metwy5z2NUndaOyUMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDNl\nODYwNmMyLTZmZjQtNDlhZC05MzE1LTFlNWZlNDU5NjBkYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJDY0MzE4ZDg2LTFkYTQtNDk0Yi1hMjc5LWRmMmNl\nZmVmMzM3MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEqrYtvVPjDLws65BO2s\nEnlzbQWqftYC4hLSgIbgIao6kwSeTG0DJ9Bk+OPbJ2NFNtbZwMSO31vnd3XNdore\nCqGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRyjEMO+HzOkhYdpDhGO5hHEr3CnzAfBgNVHSMEGDAWgBRDfW53FEA4WtEncZMt\nrs57Ce9FhzAKBggqhkjOPQQDAgNIADBFAiEAyJ4LiNQmKYVRkUZL9TLg/ZU857rM\nTSfpp0DFy+P/iUwCIB+b32ytVFJbMQ9WAzVpW4xIv3DkymtjyGCOatVqAwwo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbXPTdad40pD7MmVrDv79x+BMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDNl\nODYwNmMyLTZmZjQtNDlhZC05MzE1LTFlNWZlNDU5NjBkYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDg4ZWE5NDEyLTE5NmYtNDQzZS05NDNlLTlmMmNi\nNWRhZjA1ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKgbq5F3D9fTwnR+V4vc\n2XK2B6dzsvC96C5o8JDGPM6uaNpRK9I4SnVayaL5Xmw+PHXF3hfGgpBdBVkoVCpg\nJ0ujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTxQ1oK7GayrF2dkizt0y+2DrRbfTAfBgNVHSMEGDAWgBRDfW53FEA4WtEncZMt\nrs57Ce9FhzAKBggqhkjOPQQDAgNIADBFAiAuHd8ROZrAKIQv9Hk2OelbXoz9Cl4I\nP+k2aR/uS1TSrwIhAJjhkpncaSZg/kU4/CsT/kwW8xu6Tq7+Ecoi09ONiDuw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAej0oYQ/43rqbPakrCYBREXZMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGFk\nZTg2ZmZmLTQ1Y2MtNDIwYy04ZTAyLTViZWIwN2UwZDc3ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDQxYjg5OTQ2LWVlMDgtNDI3Ni1hOTU3LWE0MTg3\nNTYxOWU3MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO8FOeId54Vlhi1gLSVH\ncXtb++o2/SPyWAwvrwMG+5JFFn3m4t5mwEMM+LZM7jmMFGgCClN+91RmDU2XttYm\nGSWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQrYmK4y2eU7k8gv6+f5pAeWvoJgTAfBgNVHSMEGDAWgBRy5EeY5chA1aNn0AdN\nvHEESz5zgzAKBggqhkjOPQQDAgNIADBFAiBUZ6ElqwZGiwTEWjIg8rmaVS3TFUtd\nRBIUJCvTuYRUhAIhAMEI8zUaV/ohXWpeshKaN774YszmTRUk2FmZLOQ0Kl4T\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISAe+zBaZh7VXWdkI9u39MVTwRMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQzZTg2MDZjMi02\nZmY0LTQ5YWQtOTMxNS0xZTVmZTQ1OTYwZGEwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATips5VZI4J2vLD7K51yTSslVnRHX4b2rmsPaYpJ1Cj3UzCmQ3DHfS4UC2C\nc5cN3Y6/zi1Vp40bYfMMWjzk+bGSo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUQ31udxRAOFrRJ3GTLa7OewnvRYcwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgQE/h\nXnxMJB0OiW3xCPZL0D5RlH7s73nodW+RQywbF0kCICGjfwNkQuSe7d6rPXK6g8zp\nR9NjuGztp043fLuJuZqH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISAd46g6JNFYOKF0xVEpaH8jABMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRhZGU4NmZmZi00\nNWNjLTQyMGMtOGUwMi01YmViMDdlMGQ3NzgwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQZqTtumnLGq5BXz4nOqaBa5CYbvVZsuJaJhImFxwHS45LwDrH1WLZjGreb\njIvyCikwQl0RXlwKvPBVMGB7ziQLo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUcuRHmOXIQNWjZ9AHTbxxBEs+c4MwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgNF89\nu1SCaYp/EyML2iZvkp4Ab8j/oW0d7GDKpjSCJdICIFJe5bC13xDj/0GDWhlqieAw\n5tJARDQb2ZgBTUSEyCmV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAVYzws1M0OhoM06r25OARsJaMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDhlNTExMmVmLWNlNTUtNGY4OC04ZGI2LTg0MzFmMGU5MTNhYjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMDVhZWRkMzUtMmM1ZS00ZDJi\nLTlhNjYtZjI2Njk4NmNjZTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWWEc\nvcyYM7y0bKb+6GloOu5CjdkmpXQ41QEw04JjApT1bqZe+rGRgdr+KePDDLRkapBO\nd+egl1Ki/CNnxxGE9aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFM8+WSNteZTtekG/MZ8m2lEyA46qMB8GA1UdIwQYMBaAFBxj\nleGk4wsKKFJnH2jXtPJDH+k1MAoGCCqGSM49BAMCA0cAMEQCIGKhm/aZVtAF35c7\nXwkk0TZFpduvo0+cB8ZC2+LyWitKAiB4NIiMQJqYdFsf46XZJE9f9qvS4UlM/+S6\nfxLpGP679g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAYgIhiz5oJjc6oQaLZuRwWeJMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMDVhZWRkMzUtMmM1ZS00ZDJiLTlhNjYtZjI2Njk4NmNjZTgyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkOGU1MTEyZWYtY2U1NS00Zjg4\nLThkYjYtODQzMWYwZTkxM2FiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEALrC\nLZYB1dm9VVMvP2LDDXWAgMqLyaFLYKFoKfaLNq5qvPyq+mLSDCv3fyPP4AkQLxZw\n7+wUPoJa8i/fvFBTzKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBxjleGk4wsKKFJnH2jXtPJDH+k1MB8GA1UdIwQYMBaAFM8+\nWSNteZTtekG/MZ8m2lEyA46qMAoGCCqGSM49BAMCA0gAMEUCIG3S0RjsQu7W4RHh\njvZ3e8NH6zJPuHedaSjBYf60atJ4AiEAzxnoGNYzV9DwlyvAud0Fz3NFrZ8V6kpH\ndRYmANJHveI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAapWVO6iOrs4dUFdEAe9PE/tMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDczMTM3ZDYyLTQ4ODYtNDdkYS04ZmY5LWQ4MWQ3NjUyYTNkOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMDVhZWRkMzUtMmM1ZS00ZDJi\nLTlhNjYtZjI2Njk4NmNjZTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWWEc\nvcyYM7y0bKb+6GloOu5CjdkmpXQ41QEw04JjApT1bqZe+rGRgdr+KePDDLRkapBO\nd+egl1Ki/CNnxxGE9aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFM8+WSNteZTtekG/MZ8m2lEyA46qMB8GA1UdIwQYMBaAFDM1\nSkt/XL8CEQ41Qk80AK9A1sn8MAoGCCqGSM49BAMCA0cAMEQCIBgCLHcqqWkZpdIp\nBhaG6mu7reRggjhjQ8oglVRbX6Y/AiAVzT5tGrKasR2VAqrRanQNZwbd6vkzh5Jj\ndgd8e7ngzQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAbqvnbUYx8ojQGiu06ud6xTjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMDVhZWRkMzUtMmM1ZS00ZDJiLTlhNjYtZjI2Njk4NmNjZTgyMB4XDTI2\nMDExOTE3MjU1NFoXDTI2MDEyMDE2MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkNzMxMzdkNjItNDg4Ni00N2Rh\nLThmZjktZDgxZDc2NTJhM2Q5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkir+\nbCgRvc7lROhF4cRcJOtybtouBB7Ald32XblXRt/udIb/te0oUBZRmtt/EfYSwK0p\nuvk1C+2hRzhN9OygWqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFDM1Skt/XL8CEQ41Qk80AK9A1sn8MB8GA1UdIwQYMBaAFM8+\nWSNteZTtekG/MZ8m2lEyA46qMAoGCCqGSM49BAMCA0kAMEYCIQD5Ig76J2eIq6ux\nr7AHX/IsshkboUy35Z0lZJCPTKNcNgIhAKlW1zNadl4lPkmpdwUzzLwor66tExyy\nXZmu7e3KmYMB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAUxMfnxlYNH6FuE1NViDGfa+MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDM0NzQ2M2YzLTI4YWQtNDk4NS05YTE1LWVmMTI4OGM4OTJjOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMDVhZWRkMzUtMmM1ZS00ZDJi\nLTlhNjYtZjI2Njk4NmNjZTgyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWWEc\nvcyYM7y0bKb+6GloOu5CjdkmpXQ41QEw04JjApT1bqZe+rGRgdr+KePDDLRkapBO\nd+egl1Ki/CNnxxGE9aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFM8+WSNteZTtekG/MZ8m2lEyA46qMB8GA1UdIwQYMBaAFHEL\n1QSfmz3sIxlO5VzexCxFGs5xMAoGCCqGSM49BAMCA0kAMEYCIQDa5TCQ5Hy0ckG9\nlr4NAbe4L2Udv1Om5yRl2NX4p+AJRAIhAIhCRozb5WwHfAKsrQegjYrTxFaKAkOq\nGMbSSlkQ8HsK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbcSrknOV2bAUTnpWHO+MgzoMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMDVhZWRkMzUtMmM1ZS00ZDJiLTlhNjYtZjI2Njk4NmNjZTgyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkMzQ3NDYzZjMtMjhhZC00OTg1\nLTlhMTUtZWYxMjg4Yzg5MmM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFIc4\njGm/zt5yivLhezGFhoPDDFCV7mmBiiWgKNMJg85uQKiyIE93Bg7TbR2gnOyNgXdg\nYLVRefz/1Hzb0omKHKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFHEL1QSfmz3sIxlO5VzexCxFGs5xMB8GA1UdIwQYMBaAFM8+\nWSNteZTtekG/MZ8m2lEyA46qMAoGCCqGSM49BAMCA0gAMEUCIQCirccc0tJwNp03\nPoSbDiR/Y/0IU5IcO6m3yo2sLfjVqwIga97H1+TQs7s/75uF7ogKtBmyPvOtr+0M\n3oku7BRO06c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAfHt0aRNvhcS/dv469xv9Z5UMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDA1\nYWVkZDM1LTJjNWUtNGQyYi05YTY2LWYyNjY5ODZjY2U4MjBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABFlhHL3MmDO8tGym/uhpaDruQo3ZJqV0ONUBMNOCYwKU9W6m\nXvqxkYHa/injwwy0ZGqQTnfnoJdSovwjZ8cRhPWjYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTPPlkjbXmU7XpBvzGfJtpRMgOO\nqjAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNI\nADBFAiAc22yvZdvP4eM20tr2PVd7vqwr9DctUii1nF4ZXlMMFAIhAOWOg6HW3xNP\nhtv+7piUt3R8Xb/EHGvcrKGrLeyz1Hdd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcqgAwIBAgISARblNu12ZlaseLH4dRDAfw+4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMDVhZWRkMzUtMmM1ZS00ZDJiLTlhNjYtZjI2Njk4NmNjZTgyMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBTPPlkjbXmU7XpBvzGfJtpRMgOOqjAKBggqhkjOPQQDAgNH\nADBEAiASR9L1ASSjjTeBE0kjWMukjURJzYc/slE5/Y6spiyyAQIgBw4lUCCcFXzQ\niMKilW2NHxInoeCcF1vZ4miJxOLO/L0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISASFOvVfVPppR8XWkNfz46GdfMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJGIx\nMzBkOWY5LTI0ODgtNGVlMS1iYWZjLTdhYzkwZGQwNzNhODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRhMmJkYzNiZS0wN2JmLTQ0Y2QtOGNiYS01MWQ3\nMTMxZGRkZDIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASA0oFCnT4yflc0zZoB\nLM5g7HJ7st22VnF6NYqWa/bvXkOQhPwJxWZyxkALmjyh+4CHEvbFZ/vtgbFAFgYd\neAvIo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRf7t0V9NLcLCK5JJ2vc2x3LpcXSjAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALZYilIsRf9IR7Qx\npHQ9DAkBB9UxClOYfpAcjaFVhLeTAiAMonrSP8MKH7XyT8oPE95AumpJ5165Yusu\nQzxNLe8hjg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2027-01-21T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc70", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `70` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWOmCEyMCPztKjlBKKNQ4YHtMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDdj\nNTY3MTE3LWFhMWEtNDY2MC04OTc0LTlkMTkxMDRlNzdlMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDg0ZDMxY2M4LTA2NzktNDQzYi1hZjBiLWNlOGM4\nNWVlMTkzYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLSwWhlugloCkUc10nVI\nvEurtK1pN4FdQYc886T6lcLhntkZv+fEmozh0m8Xg1XsQLYtcXIQpLkcfUi16ejl\n+jqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQy0rwdSc7E48+eUXpxNG10Z0saNTAfBgNVHSMEGDAWgBRcTw1WaE2VnZ+5l3Ak\nWJMrf+lzVTAKBggqhkjOPQQDAgNHADBEAiAyj8e5rpg2w7TYll6b/7V187aMqo98\n7n+kWiuz7EcZrQIgZu6PRM9T7SEpLqc9XBtuQ8OsFmzfdumQduEaHcdyZdU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXi1raR3rkS+0gl8JrGisfg/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDdj\nNTY3MTE3LWFhMWEtNDY2MC04OTc0LTlkMTkxMDRlNzdlMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJGJhZDVhOTljLTA1MDEtNDM1ZC1iYzNhLTkyMmJj\nNWExMWNkZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKsb6TiBgzOOu7wNNMHK\np9JbmbCpI5NPkYORpINwGV1QysijPgHOoJFpARZ92zVvG9usjm/ysCF15t+2f6eS\nmPWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBREgLqUdzNBZYwLtLOWula3ODLRQDAfBgNVHSMEGDAWgBRcTw1WaE2VnZ+5l3Ak\nWJMrf+lzVTAKBggqhkjOPQQDAgNIADBFAiEAzp3zcHrhDuPMxELVmlr8meqLt4Ra\nKju2xyMbxfeyYCwCIEq2ecxt+8HF10smRpKaWMZFL05PFeoxydaLBAav27QZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfkvGOgbEdHwVd13+AkYOen+MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGJh\nZDVhOTljLTA1MDEtNDM1ZC1iYzNhLTkyMmJjNWExMWNkZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDdjNTY3MTE3LWFhMWEtNDY2MC04OTc0LTlkMTkx\nMDRlNzdlMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDyhsveLHiMyrL1e0xFb\n1MULfOkOdkZgLsX6I/FuBgHULBANA96qKzppUOeU2qUx7tSt9sNzGwujXTbsIb5e\nBtOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRcTw1WaE2VnZ+5l3AkWJMrf+lzVTAfBgNVHSMEGDAWgBREgLqUdzNBZYwLtLOW\nula3ODLRQDAKBggqhkjOPQQDAgNJADBGAiEAuftb3khtZwScDwl+jH+BZG8Hv2GQ\noSBL3rHCVCkr5z8CIQD/vBFfIhx7lzRSY5U4/yVzVtTRa7RyrCmGQE9EagaJlQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARqbbcXXQZkbtb7D/hvMgtfSMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDg0\nZDMxY2M4LTA2NzktNDQzYi1hZjBiLWNlOGM4NWVlMTkzYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJGNjN2UwNzAxLTE2ZTAtNDgxZC05MjliLWJjNjQ4\nYjU5MGY3ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABA+EGl9PSBg3BG8jYB7a\nKcn7oYEC2Q1zboCiIQjxlAPwArPs/yC1JpFITJ3irlLRurxnkP9mmTGY+hYPPhwG\n56ajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTdkPsbVvWcESvBgB8bvIoL0oOejDAfBgNVHSMEGDAWgBQy0rwdSc7E48+eUXpx\nNG10Z0saNTAKBggqhkjOPQQDAgNJADBGAiEAmSxvtIAtILk/y9UEmyQ5yX8uLc8W\nazqvsUIZi752ALwCIQCE02EDRHps92rEJJO6RVM5mXtJ09UNdVT49BRSCmjWpw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVDPDV693330beysZM/fwikPMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJGNj\nN2UwNzAxLTE2ZTAtNDgxZC05MjliLWJjNjQ4YjU5MGY3ZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDg0ZDMxY2M4LTA2NzktNDQzYi1hZjBiLWNlOGM4\nNWVlMTkzYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLSwWhlugloCkUc10nVI\nvEurtK1pN4FdQYc886T6lcLhntkZv+fEmozh0m8Xg1XsQLYtcXIQpLkcfUi16ejl\n+jqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQy0rwdSc7E48+eUXpxNG10Z0saNTAfBgNVHSMEGDAWgBTdkPsbVvWcESvBgB8b\nvIoL0oOejDAKBggqhkjOPQQDAgNJADBGAiEA6aL2jE59nfw6RJFXvW/TpnOmlUTb\niJ6HKn0+DYrfQewCIQCljA0DMmd4cUboZrOHCkwiesla+wSCxjWahH72UoRHwQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYuPLFE0PZ9F7+THaIrf2oD1MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGJh\nZDVhOTljLTA1MDEtNDM1ZC1iYzNhLTkyMmJjNWExMWNkZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJGNjN2UwNzAxLTE2ZTAtNDgxZC05MjliLWJjNjQ4\nYjU5MGY3ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABA+EGl9PSBg3BG8jYB7a\nKcn7oYEC2Q1zboCiIQjxlAPwArPs/yC1JpFITJ3irlLRurxnkP9mmTGY+hYPPhwG\n56ajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTdkPsbVvWcESvBgB8bvIoL0oOejDAfBgNVHSMEGDAWgBREgLqUdzNBZYwLtLOW\nula3ODLRQDAKBggqhkjOPQQDAgNJADBGAiEAt88wsTbmTeT1NIZCEos4jva9I9+D\nK0gLzsl7doECadoCIQCTR1GAUCFmvtwnUmft5aQbSwQGCk3I+cg+LV+VhaPIPw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAWVHQFoMagLRgc1K8g3G5je4MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGY0ODA5Y2FhLTFmM2QtNGI0NC04MTlkLWY0ZGNhYzFmOTVkOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDdjNTY3MTE3LWFhMWEtNDY2MC04OTc0LTlk\nMTkxMDRlNzdlMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDyhsveLHiMyrL1e\n0xFb1MULfOkOdkZgLsX6I/FuBgHULBANA96qKzppUOeU2qUx7tSt9sNzGwujXTbs\nIb5eBtOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRcTw1WaE2VnZ+5l3AkWJMrf+lzVTAfBgNVHSMEGDAWgBTPbJPL9LtRkJYL\nWsg0nxNEdCBAGzAKBggqhkjOPQQDAgNJADBGAiEA6uhUM4+/H6WeepSifJDkIuPZ\nsCGSAdpqiY482t8yUTACIQDWS38YqRkeFf2A9WsAIY8zv6wfKBUXWMG3Xl9b1D9f\nxQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAadxbHuEZHRa1sGAGYzVA5orMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGY0ODA5Y2FhLTFmM2QtNGI0NC04MTlkLWY0ZGNhYzFmOTVkOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJGJhZDVhOTljLTA1MDEtNDM1ZC1iYzNhLTky\nMmJjNWExMWNkZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKsb6TiBgzOOu7wN\nNMHKp9JbmbCpI5NPkYORpINwGV1QysijPgHOoJFpARZ92zVvG9usjm/ysCF15t+2\nf6eSmPWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBREgLqUdzNBZYwLtLOWula3ODLRQDAfBgNVHSMEGDAWgBTPbJPL9LtRkJYL\nWsg0nxNEdCBAGzAKBggqhkjOPQQDAgNIADBFAiBpbqUOYbumNQurFjK4yp8ujVoH\nKa+pd+DiYDQxFEobAgIhANKyh4rI+Dmkp5voKjL22qfV9uAQ1h61ApXSnqMAni7q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATDg2l1tC5aWhCw5MXy09bUsMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDcw\nMzU0ZWRiLTRjNzgtNDM2OS05YzQxLTMzOTYwZDczMWE5NTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDRjNjZhN2UwLWQzYzctNGEwNC1hZTY5LWFkMGMx\nN2Y2MjhhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIwbMlJQJq942n5djWca\n53i92HvWOleNH/kNQcDkun8iURBnNWt3wdhesWUiV5iHZnLvsTom5Jiz7jOGITKE\nWGmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ//I55Nq6Xn10sY4NLPHOPHw0JgTAfBgNVHSMEGDAWgBTzxASFeKCmz2HPsE3C\n/iSywl4DZDAKBggqhkjOPQQDAgNIADBFAiEAsD/euDmv/fF+sQgIO+SpSSh3t3sI\nqAJVmMEf54/9E9cCIAKb2Z2NPwdYy/j8/0XrWxMzE0h6uyIZvXRTLKImya8Z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISASNBYKuk0jGVZRAp/M40HVTXMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGMw\nMTE2NzZiLTI2YmItNDBmYS1iZDgzLWMwMjgxYTAwNzQ2NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJGRjODkyODZjLTFjMmQtNGYxMC1hZWYwLTQ0ZjMz\nZTc2MWVkMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABF+hP88cRE4dYU8lZ/oj\nnMkxBQd16tlKZPz6hION0ilW9emD+t9TkpNy7WMGc65YLxZbRX5OIbQAmslZUH+C\nms2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSLtd/NPWn8IaiBb3BgBN5VkUdDajAfBgNVHSMEGDAWgBSWqkXdm4W/4C8apfXb\nkbaF5Vlr5zAKBggqhkjOPQQDAgNJADBGAiEAmKyUwYSTbu5un0MlVq1+bcSYP4GM\n5Uqw2AlMf4xVtbcCIQDmPqQRyd+Qw1hSJzfH+pHRa8oM0TM6NWFFKuWDtVXbbw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARhegfpmU/YZ96IhJdhX2v8aMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGMw\nMTE2NzZiLTI2YmItNDBmYS1iZDgzLWMwMjgxYTAwNzQ2NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJGIyMjNkNGI4LWE4ZWUtNGMwYi1hNjI3LWYxOTk3\nYTRmYWIwZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGAj++uuS26SUfwmpAX9\nPDr4clQwwrjhJw34ZIXdDCsJGrEY6Tt2AKVtiIIYdsOj7tIKC/2929jNueW5sioC\ni82jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSAnX8q1ZjBDJ6SgCDh+FIJcKKKMDAfBgNVHSMEGDAWgBSWqkXdm4W/4C8apfXb\nkbaF5Vlr5zAKBggqhkjOPQQDAgNJADBGAiEA7OkC2bxUu1RMqUyrOdzM3a/JHfII\nrxUIDuPM7KF3XEwCIQCzJ3EEVun3ngdCa1EOU+ZQD84HSD3q87WQwXrZ1s47GA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAcT2xJFsMq13V1w+Kwj4ZGdBMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDVkNmNiOWU0LWM4ZmEtNDE3ZC05YmQ5LWI1N2E4NTAyNzJlNzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDcwMzU0ZWRiLTRjNzgtNDM2OS05YzQxLTMz\nOTYwZDczMWE5NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBa3xrxnEcZmJ4Cg\nzFjLLdZi9AJ3agEMs34UmI4w6Mdg7EYYRJjCVMfcT+TUeNX5ho+OYzCOcdic6efb\nCJV5T8ujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTzxASFeKCmz2HPsE3C/iSywl4DZDAfBgNVHSMEGDAWgBQ3dD/TmaTTAOpV\n9kgAQAe1IEfSzTAKBggqhkjOPQQDAgNIADBFAiEAnd9sAuTI2sdBpU8XJrl2munk\nH5iFLT2B/nrS4wud0qUCIBmSVH7AMh83unK/c2r4mcYg7e2kKyk2ABemgo+3pHiS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAcV55Lx4DFHQgMSofRnhXmqaMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDVkNmNiOWU0LWM4ZmEtNDE3ZC05YmQ5LWI1N2E4NTAyNzJlNzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJGMwMTE2NzZiLTI2YmItNDBmYS1iZDgzLWMw\nMjgxYTAwNzQ2NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO6jkDv8DYX7HKod\nxmuSOa8PM7ZITDEVeun5656QWm/UBj4FuOc6NMa884edFb9MQWl9W+vy6apzlWpW\nO2snOe2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSWqkXdm4W/4C8apfXbkbaF5Vlr5zAfBgNVHSMEGDAWgBQ3dD/TmaTTAOpV\n9kgAQAe1IEfSzTAKBggqhkjOPQQDAgNIADBFAiA6qSOUH0hfqjSOpYrXOjJa5fkg\nlS/QMWGhUfmyjVlDjgIhAMOwEz3ZGariewX2eG7cXjApcwD8YcpRbRd7V1/D1H5u\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVwiM3eHfVqrJ3i6nA3JA7uiMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDZj\nM2M1ZTVhLTQ0MGYtNDUzYi04MTJkLWE4MzBlZDc0ZTc3MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGI4ZjU4N2U1LWE1MjQtNDQ5MC1hNjFkLThlZTNi\nY2VkM2M1ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABL2s0xe1PmA+VnKQdzfU\nmtoY777OnE6ilAggK29CbJcV5TtufHtFCndJljCmC7wv8oyBkLPLTk+HoYbPZUfv\nEw2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR8wBwF0Yi97eXYNADjJ5m2yUHXDDAfBgNVHSMEGDAWgBRgqoi2C2OhtOmoboaP\ndq1uWQGnujAKBggqhkjOPQQDAgNHADBEAiA0Ou3L6jiKwOiTxZJftiH6ciXwl6zT\ncsDilzQlrnqqWwIgSQgfC8whQ4yzKp3PdcQ47t6M3xnvFhXjwfr5xhgsHVo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAT4Ysy/hHMOmFxD9GYzREmuwMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDZj\nM2M1ZTVhLTQ0MGYtNDUzYi04MTJkLWE4MzBlZDc0ZTc3MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJGNjMzc4ZWE2LTFhZjQtNGYyOS04OGQ5LTcwM2Vh\nMDc3MGQ5MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBy96OXakv4y3qAjTnXM\nxWpvSRROxVxH7howMv8lyWl6thDMt1ksnNFowwTWLbwKXktTWM8Cu0jUBVGHE6P4\nGSqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT7AcTDB3dFgltiECxAmdNEWcB14jAfBgNVHSMEGDAWgBRgqoi2C2OhtOmoboaP\ndq1uWQGnujAKBggqhkjOPQQDAgNIADBFAiEA+vGn6P30hyy5BvABPsl/3/5cfpd/\nhnQq59owph3n/kACIBXAnXv9/l6u8c5l7aFuJUMgBT0T4JGfLuAcT5Muh1S5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASvrgE8sjw0tj8cFRY8YZHFzMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDM0\nODI1ZGRjLWQyYjItNDdmMS1hMjg1LTBkYzlkNzVhNzcwMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDZjM2M1ZTVhLTQ0MGYtNDUzYi04MTJkLWE4MzBl\nZDc0ZTc3MTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMIKPjqixQmBRgIdV9Hd\nws5xIO3RdJfWOXH4QpL0/BbGZipvgsJV4UoMBLdwrEvKQHS4nnolr+SyHHdxNZ7y\n6HyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRgqoi2C2OhtOmoboaPdq1uWQGnujAfBgNVHSMEGDAWgBRAl3EDr0mODo2g8Y0i\ne/5C1hUYWDAKBggqhkjOPQQDAgNHADBEAiAaEWyssbiCTQ9uQIDpbwWCNewfexGG\nLZLFlGEVCOgSPAIgAuZGiRfLu52xALfwGpkbMPgtD36/NGi0Jiu4S/0x2MU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdI7BAia+t/MWCcCgOYz+1qwMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDAz\nODNiNWIyLWYzZGMtNDM2Ni04YzcwLWExYzhiODFmZjA1NjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDZjM2M1ZTVhLTQ0MGYtNDUzYi04MTJkLWE4MzBl\nZDc0ZTc3MTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMIKPjqixQmBRgIdV9Hd\nws5xIO3RdJfWOXH4QpL0/BbGZipvgsJV4UoMBLdwrEvKQHS4nnolr+SyHHdxNZ7y\n6HyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRgqoi2C2OhtOmoboaPdq1uWQGnujAfBgNVHSMEGDAWgBTawkVxkw2GsOliYXQn\nJpwEuDqkhTAKBggqhkjOPQQDAgNJADBGAiEAuMjWwdyTEpagE9J72d+Y2MPRPDts\nVIO8fOjFq3I4ZcQCIQCli32wiQTRhAwFNFnOv7MzTuLkTGNtko2f6syTWnsukg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAS7/7iZVUUaf+afmKMLvW3nIMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDM0\nODI1ZGRjLWQyYjItNDdmMS1hMjg1LTBkYzlkNzVhNzcwMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDAzODNiNWIyLWYzZGMtNDM2Ni04YzcwLWExYzhi\nODFmZjA1NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNuZneWzJ34IDhlN3FNT\nqVFwG4DsIYv5KFywOcrRLNjzbmhuEYjAOVZ2T9e42wALOTewbU0wgY541z3wWYWJ\nVWejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTawkVxkw2GsOliYXQnJpwEuDqkhTAfBgNVHSMEGDAWgBRAl3EDr0mODo2g8Y0i\ne/5C1hUYWDAKBggqhkjOPQQDAgNIADBFAiB57XnZeI6vvkabspig+QnWI5El8qUD\n4Na3oB0N8VAS/QIhANbSN/tjW3TixGA4Uk9Fp7RcivBkphcoYRaN0plexlwU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARt+dI4lR8qThknfqMoTOLYnMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDAz\nODNiNWIyLWYzZGMtNDM2Ni04YzcwLWExYzhiODFmZjA1NjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDM0ODI1ZGRjLWQyYjItNDdmMS1hMjg1LTBkYzlk\nNzVhNzcwMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABP3xL7nfftp0YGCkqsd/\nFw2I5SZvO9/K3vzb1L3XzsUS8Tgc614hl6RGXOC6vCWhZcSzbXgdy3Q9YE+SzuTc\nbH2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRAl3EDr0mODo2g8Y0ie/5C1hUYWDAfBgNVHSMEGDAWgBTawkVxkw2GsOliYXQn\nJpwEuDqkhTAKBggqhkjOPQQDAgNHADBEAiACobskYIyFLE5W/Vpgq6rt1EBdQVPZ\n5sd9L/mf7s6E9AIgS7Wvl4J//YFUgRH84R9QBDpb3+QC7SlOY2jjrY+4/YI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfPBzH5/CLZUYs4K+jo7uKUqMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGE4ZjViMGFmLWJjYTAtNDc3ZS1iN2IzLTcyMWMzMzI5YmVlNDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDM0ODI1ZGRjLWQyYjItNDdmMS1hMjg1LTBk\nYzlkNzVhNzcwMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABP3xL7nfftp0YGCk\nqsd/Fw2I5SZvO9/K3vzb1L3XzsUS8Tgc614hl6RGXOC6vCWhZcSzbXgdy3Q9YE+S\nzuTcbH2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRAl3EDr0mODo2g8Y0ie/5C1hUYWDAfBgNVHSMEGDAWgBQWF+caFF2kV2kn\nB7PP1V9ehlo5WTAKBggqhkjOPQQDAgNIADBFAiAlPikVj2N0HWf55q8noWuN+Ca0\ny5f6pUYx2RZKi2KQ5gIhAMSQWqgSBzwyXG/TZnyIxB+0A7ALjewRguhkWfWvuRFc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAeddZCK2sdh5u0GfQIErCVYoMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGE4ZjViMGFmLWJjYTAtNDc3ZS1iN2IzLTcyMWMzMzI5YmVlNDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDAzODNiNWIyLWYzZGMtNDM2Ni04YzcwLWEx\nYzhiODFmZjA1NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNuZneWzJ34IDhlN\n3FNTqVFwG4DsIYv5KFywOcrRLNjzbmhuEYjAOVZ2T9e42wALOTewbU0wgY541z3w\nWYWJVWejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTawkVxkw2GsOliYXQnJpwEuDqkhTAfBgNVHSMEGDAWgBQWF+caFF2kV2kn\nB7PP1V9ehlo5WTAKBggqhkjOPQQDAgNIADBFAiBxfTW0VhjmoiMiLPRKa2V8W9NG\n2NMihrgqY7zJ4bdYpQIhAOBvHLA18sOERyLhUuy8WjmYiWZX/cmvQljYrzNP2Wtf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASyfhz8dBCiFPNJTzR7lAqfeMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJGVh\nMzNjNThkLTA4YmYtNDVjOS1iMTI0LTQ3NTgxNzA4MjE2MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGQwOTRhYzQ5LTk1NTYtNGU4Yi1hYjgwLWMyNzk0\nNzI3Yzk2NzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLqosTkQPFAcjkqgm7Jp\nr1QHVv/9RWntWQ3rzNjsu5k8RKMAZqmw8mA7MqCov1L5x1hm5WbJLoYu1ialFpBv\n0nejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSjugLKYfWEHIMag+AKPewv1hS6jzAfBgNVHSMEGDAWgBRehOvnMzARzgRFIbqN\nxdF4Hl7g5TAKBggqhkjOPQQDAgNIADBFAiAcAYrohVoSGS/s1cSuzuWkO50p5df2\ngROn23HuZapk7gIhAJGd9ICZny5YKme0EZcph6ybKIIum9IBpn3CT7VouSuL\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAenwwlYFcsNqHaHdjF0+NzBYMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGM2\nMTk2OGM5LWZlNjAtNDFiZS04YTgyLWM5MWQ5NTEyYWMxNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJGVhMzNjNThkLTA4YmYtNDVjOS1iMTI0LTQ3NTgx\nNzA4MjE2MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIU7FwKnzHCN9kbbqBNh\nS+MTvGiG3yoljVZM2WdGPRjesTa/yoDazaahxOD8o7mmxpyh2iQ9HoNpBvsItP2H\nCHCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRehOvnMzARzgRFIbqNxdF4Hl7g5TAfBgNVHSMEGDAWgBQKDAguTgMsi94nZAQR\neCKY21zFwzAKBggqhkjOPQQDAgNHADBEAiBO6dCysDPfrCr6uBlAaM7pF9HERW2v\nPQxJkAqLM5GK5gIgNmPDyMjVVaqSMhFdXyCdMacx6hw90XpJnL9iVTL8lUc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYZb7hiGR7+AkKQfuFyveH9KMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGM2\nMTk2OGM5LWZlNjAtNDFiZS04YTgyLWM5MWQ5NTEyYWMxNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJGY0ZTk0ZDQ3LWM2N2QtNDkwMS04ZTg0LTljNDFm\nODZlZWY5MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKhnaRnbPwwPVOTW86BA\ny896iHr06ZDCoJf5l79Kzpx5lDqSdhl4mWm18suinn2YfjY3A7/J37P5jg8WV0Ub\ncVyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTW9oPDwCoEM7O/vz4+JAE2wrq4yTAfBgNVHSMEGDAWgBQKDAguTgMsi94nZAQR\neCKY21zFwzAKBggqhkjOPQQDAgNIADBFAiEAl1//xtbdEH7JTUngFoJO6cCBoYUm\nJwGhCsYTX0JADc0CIAgC4u7hyt5+ls5+XqpFGW+nk6mowXO+8T2Eg6PxeLu3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAe/mSyMrkvb/24hCpWAHiGsXMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJDgy\nZmUwN2MwLTAzM2YtNGY1OC04ZDE3LTUwOWU5MTgzYWViNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGQwOTRhYzQ5LTk1NTYtNGU4Yi1hYjgwLWMyNzk0\nNzI3Yzk2NzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLqosTkQPFAcjkqgm7Jp\nr1QHVv/9RWntWQ3rzNjsu5k8RKMAZqmw8mA7MqCov1L5x1hm5WbJLoYu1ialFpBv\n0nejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSjugLKYfWEHIMag+AKPewv1hS6jzAfBgNVHSMEGDAWgBTgdsWol9WQSY5AZBNh\n2aPBFqXkCDAKBggqhkjOPQQDAgNIADBFAiEA0N+KOV6NHEVtu7e64L6TvGf4gmd2\nZGOYNMLwINI6YmwCIAVkznk1vN06ig7agOxguwgHOYcH4uAIKFIJYHvOJqjf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISARbGk5y3W4ScD8kLGu2fuUcGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyRjNjE5NjhjOS1m\nZTYwLTQxYmUtOGE4Mi1jOTFkOTUxMmFjMTUwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAASgR7Jb0nrSRrHJk/+y8+pmrgEdudEwujpx1GPYK/mKNuJtpV160xeFIqfS\nX1prvPWYR6Mn8wREJ3LOHabcRSrxo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCgwILk4DLIveJ2QEEXgimNtcxcMwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgGscn\nzRopj4+F8jKpGqeoi4jmCVIK546e5BvdN+jTeUUCIBA5UoDU4DJNlm034WzJm9To\nymwhJTg5c/mbRrTcF/dY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISAbJuTGGngZq0KrV26O52UXbQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyQ4MmZlMDdjMC0w\nMzNmLTRmNTgtOGQxNy01MDllOTE4M2FlYjQwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQSfZphN5IGtJwJ38ud0WN8pdSGfIhURyUhep4Q0+fie8kQtng8A7GdO3nm\npJv+bBjGphON18c8teb4KGnJYXWHo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4HbFqJfVkEmOQGQTYdmjwRal5AgwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgUGxo\naS4eDW2iu5UbSQM7YtNJO+cDO+ag5m7gEiLH1T8CIDKXMfFACj5I85LhY80pcLxb\nIdDtg/6/wCGe86ssYxRe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAac649kzmYrRby94Tl9G3Z28MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGY0ODA5Y2FhLTFmM2QtNGI0NC04MTlkLWY0ZGNhYzFmOTVkOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNGFjOGM5ODItNDQ0NS00YmJj\nLTg3YjgtMTk1ODU4NmExMGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzPyT\nXpBmGEUej0u47lc9TQdYvqYFTMDXCNFLQZJdWT9rgjjKB+VztsQysLAdcu0ApW3s\nPi6+zH3Rs5r3LbyTkaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBB5dNwD8ofZJjbf2ImSYgr4GhLQMB8GA1UdIwQYMBaAFM9s\nk8v0u1GQlgtayDSfE0R0IEAbMAoGCCqGSM49BAMCA0kAMEYCIQDbNcJoMvKoEiog\nK6QjR0xkRETFuExNTEqhYBrZUKPTVAIhAJgOABmo8jJ2fen+VI4Pe8cPquCy3Ddw\nBWfnPY96NyNf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAU9TUmvDGLovvY4rsmCIMrCVMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNGFjOGM5ODItNDQ0NS00YmJjLTg3YjgtMTk1ODU4NmExMGU5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkZjQ4MDljYWEtMWYzZC00YjQ0\nLTgxOWQtZjRkY2FjMWY5NWQ5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpWzv\nhKlKnkRF6Aqm7VyjCoZKafYBTRPpIsSocnLC0y85Q7ngwUT7/nAe7Rtxa6H9YXgz\n64TfG4Qq9ywxXBiLRKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFM9sk8v0u1GQlgtayDSfE0R0IEAbMB8GA1UdIwQYMBaAFBB5\ndNwD8ofZJjbf2ImSYgr4GhLQMAoGCCqGSM49BAMCA0cAMEQCIENmIumd4B2EixG6\n8JYZK2zU2xDzYQgB9NFzQdNFWI7FAiAU0zbUS+YuTSSJTXNkZRzxlarbOT9Tfbgo\nlQqFmx6voQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbxnBXwMb+0C4rqMSfZ2pnJBMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDVkNmNiOWU0LWM4ZmEtNDE3ZC05YmQ5LWI1N2E4NTAyNzJlNzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNGFjOGM5ODItNDQ0NS00YmJj\nLTg3YjgtMTk1ODU4NmExMGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzPyT\nXpBmGEUej0u47lc9TQdYvqYFTMDXCNFLQZJdWT9rgjjKB+VztsQysLAdcu0ApW3s\nPi6+zH3Rs5r3LbyTkaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBB5dNwD8ofZJjbf2ImSYgr4GhLQMB8GA1UdIwQYMBaAFDd0\nP9OZpNMA6lX2SABAB7UgR9LNMAoGCCqGSM49BAMCA0gAMEUCIElcSz3dkxFplVp0\nTgVGZQSbOyZx13mnD7Fddzc2qF4lAiEArk2HymWrfuXjEtibNvLmo0tIlTntsBEw\nKO5U1QhD+bA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICODCCAd+gAwIBAgISAZuqEA+5hvrVJ6fLWRGDsOTRMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNGFjOGM5ODItNDQ0NS00YmJjLTg3YjgtMTk1ODU4NmExMGU5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkNWQ2Y2I5ZTQtYzhmYS00MTdk\nLTliZDktYjU3YTg1MDI3MmU3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFL+J\nRwWp9tvxGhG9829684+R2UFSPp/pHRpS3C+41/AA0TGd199mREvZcjt0GbexM4kZ\nwqFyTgG3nhPIXJtu+KOBhzCBhDAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0TAQH/BAUw\nAwEB/zAdBgNVHQ4EFgQUN3Q/05mk0wDqVfZIAEAHtSBH0s0wHwYDVR0jBBgwFoAU\nEHl03APyh9kmNt/YiZJiCvgaEtAwIQYDVR0eAQH/BBcwFaATMBGCD2JhZC5leGFt\ncGxlLmNvbTAKBggqhkjOPQQDAgNHADBEAiBU6+HeXbozlmFuCcj6CjPLECGIf82g\nKjW4LO+vskqvEQIgNxxsnthq10LCdOAQ0HMZXV7zZc4L+6hegzXhdbAKMcU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAaZbY+UrU1LjeVcbsKhjDhU2MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGE4ZjViMGFmLWJjYTAtNDc3ZS1iN2IzLTcyMWMzMzI5YmVlNDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNGFjOGM5ODItNDQ0NS00YmJj\nLTg3YjgtMTk1ODU4NmExMGU5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEzPyT\nXpBmGEUej0u47lc9TQdYvqYFTMDXCNFLQZJdWT9rgjjKB+VztsQysLAdcu0ApW3s\nPi6+zH3Rs5r3LbyTkaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBB5dNwD8ofZJjbf2ImSYgr4GhLQMB8GA1UdIwQYMBaAFBYX\n5xoUXaRXaScHs8/VX16GWjlZMAoGCCqGSM49BAMCA0gAMEUCICYyl27hA/RqYhi+\nXTtmts7IAxnoZ835XZpKmrEqdDlUAiEA6xq42HEsStCnA2qy0DMU+wlH2KmJyOwT\nTozrmKnBYM8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISATgdcAGpTEMLZAHo2EvGOWCNMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNGFjOGM5ODItNDQ0NS00YmJjLTg3YjgtMTk1ODU4NmExMGU5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkYThmNWIwYWYtYmNhMC00Nzdl\nLWI3YjMtNzIxYzMzMjliZWU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIVZK\nyY0z6BGowgYKf0tppFW9m6oh/7yJtXjjBKoni5tYqv9AAmHjx3+xtbPMNHhUr+k3\nrck6UkIdw2WXCm4SzKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBYX5xoUXaRXaScHs8/VX16GWjlZMB8GA1UdIwQYMBaAFBB5\ndNwD8ofZJjbf2ImSYgr4GhLQMAoGCCqGSM49BAMCA0kAMEYCIQCpWCdYipFvaGw/\n0lgHFMo9no6uVCzjurqwSVse/uFeJAIhAJA4zyLiwqvqmMZJ7B9nlV+ZAIhXt0ya\nUgYk+yl8Vkc3\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcqgAwIBAgISAYAKhlieH79MPGHte6Tks5OOMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDRh\nYzhjOTgyLTQ0NDUtNGJiYy04N2I4LTE5NTg1ODZhMTBlOTBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMz8k16QZhhFHo9LuO5XPU0HWL6mBUzA1wjRS0GSXVk/a4I4\nygflc7bEMrCwHXLtAKVt7D4uvsx90bOa9y28k5GjYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQQeXTcA/KH2SY239iJkmIK+BoS\n0DAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNJ\nADBGAiEA343YIdQNmBhanMFbN+6Go6yQabNyX2vrWQXOWO8POLACIQDPY+dLx7Su\ndISqKAmxsrlv1p6ZkA1bjCctygYRx5t8ng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcqgAwIBAgISAbORcsu2oZQ5JxG3P6j7W27FMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNGFjOGM5ODItNDQ0NS00YmJjLTg3YjgtMTk1ODU4NmExMGU5MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBQQeXTcA/KH2SY239iJkmIK+BoS0DAKBggqhkjOPQQDAgNH\nADBEAiACikSZbK4iISV7GfkrRyGn8DRfBIuIcNvhWEbxnzsTKgIgV3WNXhrCCJvF\nVZ2rxxow/hd1KGSuFZuIysIWtL9uTwE=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAYDPkTAaGjH9sdCLF3l9nj1cMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJGRj\nODkyODZjLTFjMmQtNGYxMC1hZWYwLTQ0ZjMzZTc2MWVkMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRkMjNjYTI3YS0yZTkzLTQwMDctYjQzMy1mNGY1\nNGE4ZWY3ODQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARnPtX/2P40YBS40wgf\n4PTl9VbNI6UCLwzMncfj4ohh6YLXAtE2TJaolU+2aJUCbC/NXLce9tKz25ELgnzH\n3JnLo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSLtd/NPWn8IaiBb3BgBN5VkUdDajAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhANFLp1D4qjf7f8bS\n7uZQx44PdzGGYuq8d2gT47gi/sPVAiEA9rTEvP1RF/711ouPJw/xcO799RgqFkqB\nf3RI/gWP8w4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc71", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `71` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVBpS6Sa0kSilqeJ9JO/HWzvMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDU4\nZDVmYzRhLTQzYTItNDRhYS04OTQ3LWY1ZThlM2M0YzE3MzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDFhYzk2NWFkLTk5ZjEtNDcyZC04MDU1LWI2NTEw\nOGNlZjUxMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEJ1wtcYb5Zqw1xkkvnX\nztL2igTvWCealC+JJks0BUgArOUb2MW8ra2GflB9oU79JfoqFpNeCLM7DJuYIUqa\nL7ejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSKPsx4uZBJ+j4upn10KJqUc64IczAfBgNVHSMEGDAWgBQaYOb9N4Hx+oUUOQT8\nQdVEwkmiejAKBggqhkjOPQQDAgNHADBEAiAOH1m0UVMj9TJlODfHsgTexdS33wm6\npOqPZjfEkkf21QIgPQ6ZHDAVKMKJNzPqgvvYVfrdssRKjnbCzcK44FSpc5c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAf7iYkywSJB5jk0dGG57oskyMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDU4\nZDVmYzRhLTQzYTItNDRhYS04OTQ3LWY1ZThlM2M0YzE3MzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDRiODgzYzdjLTk0ZWEtNGM5ZS05YzEyLWQ4NmRj\nMjM0NzI0MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE4gRywFpRsY1zbiAR94\nw9J+4uxAvMMfuGVlVFtS7s4s8OcoxyO5gRZMmXs4LL2ZTjxGJsL0ejhspQ1x82F2\nQ22jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ11rTeZsmX30DSKeTi6KQFbCOy9TAfBgNVHSMEGDAWgBQaYOb9N4Hx+oUUOQT8\nQdVEwkmiejAKBggqhkjOPQQDAgNIADBFAiBqCh8SpH1YGqwFNmNbefgdpW0YVbEY\nG+ubDV5Fiz6HQQIhAM+KPZ5iXhszjg7TPjj5hH78+nC/FHLK8+baG9iML9DX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZnFcLW+xxWcV8IPaAQ+8b4PMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDRi\nODgzYzdjLTk0ZWEtNGM5ZS05YzEyLWQ4NmRjMjM0NzI0MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDU4ZDVmYzRhLTQzYTItNDRhYS04OTQ3LWY1ZThl\nM2M0YzE3MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABANdte/UpGZ/LYarW9dl\n1Z5eBRKDgySMaOXQ5qDXQ78mw6jrLtcdfKLegUu0AKdcXpwfK2lU70I/I0w69KjR\npqajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQaYOb9N4Hx+oUUOQT8QdVEwkmiejAfBgNVHSMEGDAWgBQ11rTeZsmX30DSKeTi\n6KQFbCOy9TAKBggqhkjOPQQDAgNJADBGAiEAq9+uhA/RW0+zDAJm82I/GZhXNGcx\n+yNZbryQa5jB6ZsCIQCfws8dUFZXWG5085OBDg/Ytyz9Hy8ZaKfOqwFk0eL7TQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZpXkqXzpJ6B7WjRHDl7HvQhMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDFh\nYzk2NWFkLTk5ZjEtNDcyZC04MDU1LWI2NTEwOGNlZjUxMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDIyNTE1Yzk1LTM5YTQtNGUwMi04YTVmLWI2YzQ3\nZmQ4YTJlNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPfgNCC9vSlIfJKaB0Bl\ncOuXRhtpZFpG+be4mSwG4l9JRu3mUexT5iB0VLoJ187PNtoupfHxzoSTf2Xf+GDM\n2VCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQeu3gFhtYo4ME1/vj0mj7z9ZQIojAfBgNVHSMEGDAWgBSKPsx4uZBJ+j4upn10\nKJqUc64IczAKBggqhkjOPQQDAgNJADBGAiEAlJIpqxrtAlXlQgmaj/K+PK1hCE+w\n0AqydQLc1nReQK0CIQD4BKhvWm3TdDyflvQNvW/skGwDv3E9L8gNP0YbeL9wcw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXY61xCwAzlacW7JRSCGcOJZMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDIy\nNTE1Yzk1LTM5YTQtNGUwMi04YTVmLWI2YzQ3ZmQ4YTJlNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDFhYzk2NWFkLTk5ZjEtNDcyZC04MDU1LWI2NTEw\nOGNlZjUxMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEJ1wtcYb5Zqw1xkkvnX\nztL2igTvWCealC+JJks0BUgArOUb2MW8ra2GflB9oU79JfoqFpNeCLM7DJuYIUqa\nL7ejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSKPsx4uZBJ+j4upn10KJqUc64IczAfBgNVHSMEGDAWgBQeu3gFhtYo4ME1/vj0\nmj7z9ZQIojAKBggqhkjOPQQDAgNIADBFAiEA0+ZTa70b8PjFlX8sZEPQpTuv6/0N\n4QNt9n7saJe7msYCIAWaRlNJ9rQcx5Rqm6jlXoDgxHMG0le8/ko4dvtm5+Uv\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAS4SKXFvMUIj7h2EwJwujLQUMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDRi\nODgzYzdjLTk0ZWEtNGM5ZS05YzEyLWQ4NmRjMjM0NzI0MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDIyNTE1Yzk1LTM5YTQtNGUwMi04YTVmLWI2YzQ3\nZmQ4YTJlNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPfgNCC9vSlIfJKaB0Bl\ncOuXRhtpZFpG+be4mSwG4l9JRu3mUexT5iB0VLoJ187PNtoupfHxzoSTf2Xf+GDM\n2VCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQeu3gFhtYo4ME1/vj0mj7z9ZQIojAfBgNVHSMEGDAWgBQ11rTeZsmX30DSKeTi\n6KQFbCOy9TAKBggqhkjOPQQDAgNJADBGAiEA01H/2wwWZyRX4Fjn0DIfJUdKAX9Y\ns0mrS5AfyrItY6ACIQDKt5CSobnM+6hvJIA3tTl7UDgzL4XfZhf4j/775IqxtA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAaxOtcF9nU4cwBjUC2YSVB0VMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDJlMmJmZTQ2LThlZDQtNDVjZi1iMDJkLTFmMDg1NWJlOGNkZjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDU4ZDVmYzRhLTQzYTItNDRhYS04OTQ3LWY1\nZThlM2M0YzE3MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABANdte/UpGZ/LYar\nW9dl1Z5eBRKDgySMaOXQ5qDXQ78mw6jrLtcdfKLegUu0AKdcXpwfK2lU70I/I0w6\n9KjRpqajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQaYOb9N4Hx+oUUOQT8QdVEwkmiejAfBgNVHSMEGDAWgBSO8Uc0nSeiJprY\nBJpVB87+won/DzAKBggqhkjOPQQDAgNIADBFAiBQ9pOq+bI5BmNnJtIYDrv5lqez\nPySdpX6Ja4QZDjjpMAIhAPIV3iO2xzndSpVBUqFIhqwDWUezYowaCdshQVGm+983\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAX3PbiEyyyvejY9WJBricO7HMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDJlMmJmZTQ2LThlZDQtNDVjZi1iMDJkLTFmMDg1NWJlOGNkZjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDRiODgzYzdjLTk0ZWEtNGM5ZS05YzEyLWQ4\nNmRjMjM0NzI0MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE4gRywFpRsY1zbi\nAR94w9J+4uxAvMMfuGVlVFtS7s4s8OcoxyO5gRZMmXs4LL2ZTjxGJsL0ejhspQ1x\n82F2Q22jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQ11rTeZsmX30DSKeTi6KQFbCOy9TAfBgNVHSMEGDAWgBSO8Uc0nSeiJprY\nBJpVB87+won/DzAKBggqhkjOPQQDAgNIADBFAiBOSxUvOXwWQ3VAqVzEUyis9Rgh\nsDOG9iFrlxjqI6P1hgIhAMGKSxWMADY0dM2uZxxwLJ2JJqI3Lmx/PMuBhqWk98jD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAe0MasP7kg6u5OUAxvX9XdhoMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJGM1\nOTkzM2ZiLTViOGItNDQ2YS04NTE2LTUwZjg4YjcyZGNlZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDU4MGMyZjBjLWRlNTQtNGQ3Mi04ZmQxLTRmYjEz\nZmFhMTQxOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPcb8ZQcEPLzkf1EsvN9\n1D65wiArw7EcfaExmYKb7KXsEo0gW4B50Uhh8lQmkhT+fq/NZz5zfJWogxvFi6jA\nN/SjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSgyjVYupJjNbwYPbscD0zN+js7kTAfBgNVHSMEGDAWgBT1GeiO2GPm9T+3UXNc\nCQV65nNq6zAKBggqhkjOPQQDAgNIADBFAiEAnN+1zIhGQqYLesR8E7bWkTIzwXSs\nwp3jeiditou9ey8CIBLjJL8cyVO6j45sEnv+7e7jy+qT58hWrBHAoUew03p+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVI3vpDCxDcZr/7QTKQ4IiDgMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGEw\nY2EzZmM0LTYzMDktNGM2NS04ZjMxLTRhMjEwZDIxODUwZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDMyMTVjMmM2LWIxZGYtNGM3Ni04YmZhLTQ2MTJl\nNmFmZTE2NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE9bBBcAYIw8SP595M1t\ngojTVJi6mqOqoPHD8I2Bxl+WKXI9Wp7gKp+CZs74lO2Aua9YmVFpXlJfGynVjGPZ\n/OKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR5vJottDZD4lUZ7K7SW3CVPcPfrTAfBgNVHSMEGDAWgBRJO6XGZgO1kz3Rh0bk\nbwQxD/YMoDAKBggqhkjOPQQDAgNIADBFAiAMiX1lHepleRQ11/lfGYOCh9utv5lq\nxinn/LdC1jKTrwIhANtRGBRJtseizw/e+IYKlQn2siQhyVjFzNddqng2WG7V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbyw7bIG5Xelb0nujvTMhfJSMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGEw\nY2EzZmM0LTYzMDktNGM2NS04ZjMxLTRhMjEwZDIxODUwZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJGUzYTA2ZTZkLWQxNDktNDc4Yi04ZjY2LThiZjk2\nYmY5NzIwODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMATZdr73sWBP3bUTMVH\nH+6MyLvVmDlWUq44JRoV6v/vMw/Xx2YtXQ+AtYNuZdJhtaKb0H8S5xj8+paHOO/T\nGUGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR6WVKwW7S0SCqCeniK7JLrX/w0WTAfBgNVHSMEGDAWgBRJO6XGZgO1kz3Rh0bk\nbwQxD/YMoDAKBggqhkjOPQQDAgNIADBFAiAGcingIiKFZcgeXeGMH7d+c2WfHQOI\nNmvQCYN9LkurlwIhAL4Dz4ctrkpKhMKagTPU5Xx+tAubK7YX28S0pZ0udAMF\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAaozQwnOvIBxb4eXHvSdbZXTMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGUyNzhlODU5LTI0ODEtNGQ1NS1hZjhlLTlkNjYyNDQ0ODc3MzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJGM1OTkzM2ZiLTViOGItNDQ2YS04NTE2LTUw\nZjg4YjcyZGNlZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABH4zNzleS1oYWFDb\nB7vhHACur289DN4jCt3wGxV2ucsv1exzvGFuE5lXoy2lHL+xMyOAnCQCBCxaWDIE\naMtT/J+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBT1GeiO2GPm9T+3UXNcCQV65nNq6zAfBgNVHSMEGDAWgBQk/mh+hFruYFps\nkVfwUEIN89aYiDAKBggqhkjOPQQDAgNHADBEAiApYs4LD1iDpwOmX9YBmmEc8GyJ\nq6r6W8kI166PjdEVlQIgM3xQpRLeSm8ktJlIHM6CD2mFfY5zxnRK0RKDqEV7f6E=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAVjujlkOn8oiT+bVNBxG1qYMMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGUyNzhlODU5LTI0ODEtNGQ1NS1hZjhlLTlkNjYyNDQ0ODc3MzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJGEwY2EzZmM0LTYzMDktNGM2NS04ZjMxLTRh\nMjEwZDIxODUwZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDHYsyG4BF/gATfz\nDz70UeKlcxDiAAesxn/hQ6rX2b4aAx7WINE52EMGZLqGNtLEakkswBTd9lFQhvC0\nuaCGD/+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRJO6XGZgO1kz3Rh0bkbwQxD/YMoDAfBgNVHSMEGDAWgBQk/mh+hFruYFps\nkVfwUEIN89aYiDAKBggqhkjOPQQDAgNHADBEAiBCDm4M/zjvMxBrjdxMbBj7f4CL\nNWCOnB6c6SvbXiRCoQIgUlpVB/u9Jfnf3tnuMPEfcEA2UFtSSY+tR7GfagIL3s8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATcrs/JEnPiARS9rG4gRpCvIMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGRm\nODI1NmE1LTE3Y2MtNGQ3MS1iMjc3LTFmNTM2MzkwYjNjMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGVhMDI4Mjc0LTNjNzctNDBjMC1hNzVkLWRlNDJh\nZWMwNjc4OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOcCdA0WGkblvhCCPugG\n3dtieKRy+aLM5fMGv1CLg9ljIRPqoe9dAl+KASajrMV0+4LAeP9TDjQmpFcurVaP\nWc6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRWlvcMgLsthm3DAj1zDG9SP5NUKDAfBgNVHSMEGDAWgBQwgVGl3D43e6KgSg5F\nbJTS/qWXVjAKBggqhkjOPQQDAgNHADBEAiAUyXUywH03WHdKxlUVdRTH/9QqApu5\n+ULC+xhGAU+4jgIgdYZ1j7g13DwUJ1TrfAZt/8qfThdlK+LuJgChs/bEu38=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaTtBSykLrx1Py4PgJ797qxWMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGRm\nODI1NmE1LTE3Y2MtNGQ3MS1iMjc3LTFmNTM2MzkwYjNjMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDhlMzUzOWQ5LWFhNWMtNGI4Ni1iZDZjLWRjZDNh\nZjc3NmVmYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK2/JG7e79L5eoHhDULq\n37ACQVgsHKhZ9WR2VDKkr51unvOy4E+mMCYOPss4Gb+a8xlbDmo2qDdkv25+/Qjj\nwn6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSQZ1YAwyXc5ToWyUxiNJkSPfi/hDAfBgNVHSMEGDAWgBQwgVGl3D43e6KgSg5F\nbJTS/qWXVjAKBggqhkjOPQQDAgNIADBFAiAEP7+wCxZK15wMmipUf67gB7ydgjNn\niHNl61qnwSgu1AIhAOG7DV1MXk0qCsTn9mMJgAcStoO2hXFIh6LA6Xb3hAiy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAb4/ydB5V5zygJe8MUgDi9EGMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDlh\nNjEwYmE0LWMyOTgtNDgzYy1hNDRkLTllMTM0ZmE2OTRiNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGRmODI1NmE1LTE3Y2MtNGQ3MS1iMjc3LTFmNTM2\nMzkwYjNjMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKe0TIefh/CdwxYKHYnn\nekmXvGJHwUAVwevqmptD2dS6SSgn4SubD+cs/TObIsF9Na/EiCy2ThHT/DJ08ezZ\nV9ijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQwgVGl3D43e6KgSg5FbJTS/qWXVjAfBgNVHSMEGDAWgBQe5Qh5UaqIgIfrxfV9\ni4T+r+En8zAKBggqhkjOPQQDAgNIADBFAiEA3lp4jn2nRGEL+Ydb9QG1Q5qChjYt\nHdfRqV0ReFMSq3cCIFRnogoTaPA5XoAp4GskXwPqpc4m0tHSYlWjeRVSHYPP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAafzaZD8bxd7KRK3OA95KL3gMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDk5\nZWZiN2NhLTU5YTUtNGRmZS1iYWU0LTM3ZDQ1NjQxNWZmMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGRmODI1NmE1LTE3Y2MtNGQ3MS1iMjc3LTFmNTM2\nMzkwYjNjMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKe0TIefh/CdwxYKHYnn\nekmXvGJHwUAVwevqmptD2dS6SSgn4SubD+cs/TObIsF9Na/EiCy2ThHT/DJ08ezZ\nV9ijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQwgVGl3D43e6KgSg5FbJTS/qWXVjAfBgNVHSMEGDAWgBTY0HTn4REsH8Pw2fUc\nl4eCPeo1jDAKBggqhkjOPQQDAgNHADBEAiAodxEoQE6n7d5+jPeK8TcuY6FDN+tz\naVa0YgYKbzRkTAIgIhPSzh0W1SpVIso0l6cyIdtGzcVgeKNUxSltMG0EaMU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAc5uUyarGR+d4EOv2IVayPopMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDlh\nNjEwYmE0LWMyOTgtNDgzYy1hNDRkLTllMTM0ZmE2OTRiNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDk5ZWZiN2NhLTU5YTUtNGRmZS1iYWU0LTM3ZDQ1\nNjQxNWZmMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM6zSwcP56DLWBcKs1vw\nzwZZ/YSw8SJWOnnESQilmgkw5FodOogDKYc+Ez8xwTrP54g7bBfDnPTAYUDSNAOW\nyXCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTY0HTn4REsH8Pw2fUcl4eCPeo1jDAfBgNVHSMEGDAWgBQe5Qh5UaqIgIfrxfV9\ni4T+r+En8zAKBggqhkjOPQQDAgNIADBFAiBQKnmETvLwhpRQs9RQY/NBwxsMYoAW\neomFo7BETxkWNgIhAN65Sri5TEQA66/jP2V8pUyUcaiTAV+JeJfa2fWpF27+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXS05TUJCpnZ9KD0erJiKrreMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDk5\nZWZiN2NhLTU5YTUtNGRmZS1iYWU0LTM3ZDQ1NjQxNWZmMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDlhNjEwYmE0LWMyOTgtNDgzYy1hNDRkLTllMTM0\nZmE2OTRiNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBLev+GG5zv+BGoaw2JL\nxMmTH+rLsSYOevIHfmafpoWqpx1RDYSBHPZ8YI3FDbg7zU6NOQeqTryNwd3x+dye\nm+GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQe5Qh5UaqIgIfrxfV9i4T+r+En8zAfBgNVHSMEGDAWgBTY0HTn4REsH8Pw2fUc\nl4eCPeo1jDAKBggqhkjOPQQDAgNHADBEAiAtbbr5a4Lf8m0kmmnTycN1m6+gD19n\nYgH+m78Ju0Td2gIgBfDCx3iZ8anHJXIAc4jAK91owZG6KBAoLRAikF6tFik=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISASS5dsTYWqIwG8MMGHSEiOu1MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDdhMzBmNjZkLTg1MjUtNDE0YS05YjhmLTgxOWQ1MzA2YmNlMjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDlhNjEwYmE0LWMyOTgtNDgzYy1hNDRkLTll\nMTM0ZmE2OTRiNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBLev+GG5zv+BGoa\nw2JLxMmTH+rLsSYOevIHfmafpoWqpx1RDYSBHPZ8YI3FDbg7zU6NOQeqTryNwd3x\n+dyem+GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQe5Qh5UaqIgIfrxfV9i4T+r+En8zAfBgNVHSMEGDAWgBQWTxXnrQGCy1Es\nmVJUtEqeN490DDAKBggqhkjOPQQDAgNHADBEAiBrvdHaoLv6ILLnLiYAD8WpYagX\nz2p2EdadGca0labUqgIgXgXrbTZFRjnpz0D/F4RLKokLlyczarT10RgWmVD2whw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAaMc0rYgbncIcnlf3hy9zd8zMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDdhMzBmNjZkLTg1MjUtNDE0YS05YjhmLTgxOWQ1MzA2YmNlMjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDk5ZWZiN2NhLTU5YTUtNGRmZS1iYWU0LTM3\nZDQ1NjQxNWZmMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM6zSwcP56DLWBcK\ns1vwzwZZ/YSw8SJWOnnESQilmgkw5FodOogDKYc+Ez8xwTrP54g7bBfDnPTAYUDS\nNAOWyXCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTY0HTn4REsH8Pw2fUcl4eCPeo1jDAfBgNVHSMEGDAWgBQWTxXnrQGCy1Es\nmVJUtEqeN490DDAKBggqhkjOPQQDAgNHADBEAiBCOAGgki9WZjBTtwKqjcFR60Sp\nKiwyxAMX/fH2PczxvgIgBfs4TkMBgUuBgu+jHNWg1M+8jjHLRKShKX2F927GUUQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXhiHqZb+/UGmCmLmIN17gmmMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJGI5\nNDBmN2RkLTQ3YTAtNGQ2My1hNWEzLWZjZTcwNGRhNWQyYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGFjNzA1MWI5LTY5NjMtNGQ4ZC04MWY5LTI1YzZj\nNTI0NDAyNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEosmp2ukQZp0y9hxjFm\nhFuSlyggEmf6FLpk8OHCWtrBVa9lLYkBpTWMv75AjTt3j5Vv1yIPaBBEtAgeXGuH\ntVejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT+NmdJL22VhcNhyhLmX2+i+MHbiTAfBgNVHSMEGDAWgBTRv/2SaRPMhc+5BBP1\nSeura5E6lTAKBggqhkjOPQQDAgNJADBGAiEAggIIbZrwDx3pqln21vpMJTqnlzfw\nHy6y//rmNA0Y9zsCIQDkwxyYw7FqiIMCPidWqXh+/pfT8n2A6Y6TmMehvpeXYA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQ5w//sAkL8UNR+Gh3nkpAVYMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDcy\nZWFhNDEyLTMzNTAtNDJjZi1hOTA4LTA1NTE4ZDdkOTQzZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJGI5NDBmN2RkLTQ3YTAtNGQ2My1hNWEzLWZjZTcw\nNGRhNWQyYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIXjKbqevSz8kHayphnZ\nPbsE+rQETKj6PF/ILxDOGhrARXOpxdKg/hLCGpm7HQaLbN4WD8OmEhawqOQ9u64Z\n4+mjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTRv/2SaRPMhc+5BBP1Seura5E6lTAfBgNVHSMEGDAWgBQHT4Cmq8e7RX8HYX4k\nzEYCZne/njAKBggqhkjOPQQDAgNHADBEAiBOCf4Q7U91Urf9ylGABzo3F7hc3lYP\npQaygfdp51RPjwIgZjlTz7wwyjBvDGyUigTnwFTC8ytY35E18DrwQLKSVqI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa3pN11CtuadfouhFBZ5AJuzMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDcy\nZWFhNDEyLTMzNTAtNDJjZi1hOTA4LTA1NTE4ZDdkOTQzZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDNjYWMxYmQ0LWQ3NGUtNDFhOS04MGI0LTMxMTQ4\nNzlmMDE0ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABL5o6CNpAvbQ/1ixaF2h\ntxgaNyXZxathzFp2JTZy81y8Kf7izg0VcEupeKWFK2FG2Q3GgeA6Kzjof3+jVV+6\n1wCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRhn7PyQZpsCg8jjYOs5q5sWPX1tzAfBgNVHSMEGDAWgBQHT4Cmq8e7RX8HYX4k\nzEYCZne/njAKBggqhkjOPQQDAgNIADBFAiEA0DpVIiv53N3tHXnZ2IuLf9nAQ7sR\nBty82vVVziv72a0CIFfLFJasBGZJ2KXTXHOztkS/b8A5MJqUcwvH1X+jBN7P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARLIOF+bTs/Oi6ZHJKpfERk6MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGJh\nZjE5ZjIwLWRiODItNDY0Ni1iMzk4LTY3Njc1ZDNiYzM4ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGFjNzA1MWI5LTY5NjMtNGQ4ZC04MWY5LTI1YzZj\nNTI0NDAyNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEosmp2ukQZp0y9hxjFm\nhFuSlyggEmf6FLpk8OHCWtrBVa9lLYkBpTWMv75AjTt3j5Vv1yIPaBBEtAgeXGuH\ntVejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT+NmdJL22VhcNhyhLmX2+i+MHbiTAfBgNVHSMEGDAWgBTgGb7YV2s3cn8VSPnv\njJFGTVgH/DAKBggqhkjOPQQDAgNIADBFAiEA/3cfXyHJWCwKgfnlOPna9ZQKL+GF\nc5ZVo95IxD8HsEYCIHwWfY8UQ7DmViWXxP+FYj1UE+pXNlKyWzeOH0Zbf1G5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAfWVMqGTA7nBnuHAx1MGKoZ0MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQ3MmVhYTQxMi0z\nMzUwLTQyY2YtYTkwOC0wNTUxOGQ3ZDk0M2QwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATKDpynjNvbAavAcdD9HTOg9YHf6IqFasTEpFZbwyfrV/2GJlKQRss0XJ3i\nf6BuoxnjFjymOoc8ZPXtkySIQKd3o2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUB0+ApqvHu0V/B2F+JMxGAmZ3v54wHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAKRj\n7AzfnnDBRWx6SnhxPlbNJ7Wpmf5vb6LIbHffrQ8NAiAmluxv6mujx7N/dzzFn3e3\ne3ZsAChOXefdpUmgarajIw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAXfNzBIWLZWlSBv6x6kEE47nMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRiYWYxOWYyMC1k\nYjgyLTQ2NDYtYjM5OC02NzY3NWQzYmMzODgwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATMtxFbN0KtZLNcgWigdpVsRyOcH/7Wm1/tscDF0Ab4S+8hjsNa5azNjnz9\np0k89sn7N78EMutNq4TdEuHnQ+qro2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4Bm+2FdrN3J/FUj574yRRk1YB/wwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhANoc\n/ldLCEHvS4pRLHHBNnXXwl+/90H3ueVzasvDpCvlAiEAv+EAAhao8twv2y+OCBbq\nJWWQ4XDgoqNQP1nXbHZ+UTQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAc3muRmVoWtaiwaY6lRaPGmFMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDJlMmJmZTQ2LThlZDQtNDVjZi1iMDJkLTFmMDg1NWJlOGNkZjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMDM3ZmQ1MzItMGQ0Yy00Y2I2\nLThhYzgtODdiMmYwZTIwMjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZm5\ndTm87KnAbK4ssyG/N9pL2s4jHd1giRtR6daUJb1z0r5htVSrEkoIH/LzOVjaRL7/\nIkCnJWXflT2Ev3Es+KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFKILHntog28Eu35AdEgXsr9xNf/WMB8GA1UdIwQYMBaAFI7x\nRzSdJ6ImmtgEmlUHzv7Cif8PMAoGCCqGSM49BAMCA0gAMEUCIQCpENZGXC0qd7nX\nstAdZ2miu9GJRz3EPlnBXIg3ctva/wIgb9VQ4buo3kxaWD2+gn2PCfEg/edu3WiI\nalzLbOd3Hp0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAesiE+GTQZW+EF02BWUtU+GfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMDM3ZmQ1MzItMGQ0Yy00Y2I2LThhYzgtODdiMmYwZTIwMjQ0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkMmUyYmZlNDYtOGVkNC00NWNm\nLWIwMmQtMWYwODU1YmU4Y2RmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEauvv\nJ8Fg/Mfv4iNP08CVvQ8Gij3Isb6HzTxnXBEmwcmayN/Z6JaHt/w+LPmfWzJ/TdlS\nglc/F5mj2GQnp50FZ6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFI7xRzSdJ6ImmtgEmlUHzv7Cif8PMB8GA1UdIwQYMBaAFKIL\nHntog28Eu35AdEgXsr9xNf/WMAoGCCqGSM49BAMCA0kAMEYCIQCVR7TRlHnpvPx/\njSj5Vq5vU9W3+BjsC/mEfhRomWmXRAIhAJTCS6j9PvI5DM3R1cRBeSr8ajZMRlNb\nADX0YUcNktqz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISASAon9JMAAEjnQYx+HAQWnLTMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGUyNzhlODU5LTI0ODEtNGQ1NS1hZjhlLTlkNjYyNDQ0ODc3MzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMDM3ZmQ1MzItMGQ0Yy00Y2I2\nLThhYzgtODdiMmYwZTIwMjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZm5\ndTm87KnAbK4ssyG/N9pL2s4jHd1giRtR6daUJb1z0r5htVSrEkoIH/LzOVjaRL7/\nIkCnJWXflT2Ev3Es+KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFKILHntog28Eu35AdEgXsr9xNf/WMB8GA1UdIwQYMBaAFCT+\naH6EWu5gWmyRV/BQQg3z1piIMAoGCCqGSM49BAMCA0cAMEQCIExFPxFKLKrSVJMD\nabvyJQy2EIxoQRmYmnql+WHnV4soAiAYwJ5CZGxJJdFE0p0H4JNUvdxm0KxG0JYY\nh3yk2JePCw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICKDCCAc+gAwIBAgISASOuA0imc3yBToy6a3r7A202MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMDM3ZmQ1MzItMGQ0Yy00Y2I2LThhYzgtODdiMmYwZTIwMjQ0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkZTI3OGU4NTktMjQ4MS00ZDU1\nLWFmOGUtOWQ2NjI0NDQ4NzczMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1zSk\n+H6XIpyQ5KwPJzoZavKoTDf+yNPEvHHyGI1mwZhUIozRHVXwv0MMoPVCQvBOk45U\nMEnxo4vv/Kdxq+k2uKN4MHYwDgYDVR0PAQH/BAQDAgIEMBMGA1UdJQQMMAoGCCsG\nAQUFBwMEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFCT+aH6EWu5gWmyRV/BQ\nQg3z1piIMB8GA1UdIwQYMBaAFKILHntog28Eu35AdEgXsr9xNf/WMAoGCCqGSM49\nBAMCA0cAMEQCIClTO8ANBF5Q6cBjytw/0+xXv7To//RVTsczv0HT3qq9AiBY3xNx\nn3AdS5OTCw06Qas/xbFiZ/bKiAaXFKH432tDxw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAd0bbjmyX3Vc73D4euMhNBb2MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDdhMzBmNjZkLTg1MjUtNDE0YS05YjhmLTgxOWQ1MzA2YmNlMjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMDM3ZmQ1MzItMGQ0Yy00Y2I2\nLThhYzgtODdiMmYwZTIwMjQ0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZm5\ndTm87KnAbK4ssyG/N9pL2s4jHd1giRtR6daUJb1z0r5htVSrEkoIH/LzOVjaRL7/\nIkCnJWXflT2Ev3Es+KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFKILHntog28Eu35AdEgXsr9xNf/WMB8GA1UdIwQYMBaAFBZP\nFeetAYLLUSyZUlS0Sp43j3QMMAoGCCqGSM49BAMCA0gAMEUCIBzw7ZbXQgsGiq7c\n042a5cC2lCK4VLRf/nObvoL1/fh1AiEAiffxRsp0kkSH5AGWiftOKZIlblxGorRC\nFfe3hGWpIcM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVGeRaleZ08jGkdlE3Yvlc08MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMDM3ZmQ1MzItMGQ0Yy00Y2I2LThhYzgtODdiMmYwZTIwMjQ0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkN2EzMGY2NmQtODUyNS00MTRh\nLTliOGYtODE5ZDUzMDZiY2UyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEntl2\ntHy5hW80Xt2XmaOFTElxVaZ1JHhETl1KzZKPDEBaioZ6NH3McRMWdZIJjYRHM64Z\n0ZAVevdOFrnH0a5iiqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBZPFeetAYLLUSyZUlS0Sp43j3QMMB8GA1UdIwQYMBaAFKIL\nHntog28Eu35AdEgXsr9xNf/WMAoGCCqGSM49BAMCA0gAMEUCICP8u5rAakM/vZnv\nHy6MSmvfDr2PskgSsu1aBRNcYtfvAiEAvMW0MoOZDAwfhSa6Fd4JHb+1VrTsxH7e\n62RPJsS0oaI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAaALMkXlW5TcsERNHwgSE/+dMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDAz\nN2ZkNTMyLTBkNGMtNGNiNi04YWM4LTg3YjJmMGUyMDI0NDBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWZuXU5vOypwGyuLLMhvzfaS9rOIx3dYIkbUenWlCW9c9K+\nYbVUqxJKCB/y8zlY2kS+/yJApyVl35U9hL9xLPijYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSiCx57aINvBLt+QHRIF7K/cTX/\n1jAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNI\nADBFAiEAwwiTgxjM51Tg90W7cgH6uDzbzXxUSj8lJghLZCWQzyQCIECh06qTHC47\nasVPgyZqIoQJkLg+2dAJi1xCarPseyaJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAVz4KyJUxq1RaNM0EBqOiqy5MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMDM3ZmQ1MzItMGQ0Yy00Y2I2LThhYzgtODdiMmYwZTIwMjQ0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBSiCx57aINvBLt+QHRIF7K/cTX/1jAKBggqhkjOPQQDAgNI\nADBFAiA9zZymTlICl+va7/T729yXh4/AWuKaARBhcGY/gPmfUAIhALz4JJvvi+4t\na/EwDmmWe13LzMXQGR/eKe2cVVPvoWvq\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAbjSkgL5iLQ/eN36kdUgGTzRMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDMy\nMTVjMmM2LWIxZGYtNGM3Ni04YmZhLTQ2MTJlNmFmZTE2NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRmNjM0NjMwYy02MzEwLTRlNGMtODc2OS0wYTE0\nOWRiZGFiZGEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASrYXrLjnhW21NmXr5A\nNCOSK6WEdfmFw4Hoeo4m8bSZAu58yn6UJY+NHK6gpcy0hj8XPwILN21s2YHBYLOC\n6M7So2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBR5vJottDZD4lUZ7K7SW3CVPcPfrTAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIhALLMTOBZYq1t11NF\nvy2oXomAHU65nW8V+tbq1Jw62fqyAiBImSWlnQKdtgzIZX7mDkVCCoQJxBEAnECZ\nhdXgeEsNVQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc72", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `72` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAe/h7yNafIJnJilqCxaUeFymMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJGVm\nYzkxZWRiLTAzMDAtNDY1NC1hZTcxLWVhYTY0MmRlNzhjYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDczY2NhODVhLTAxMjEtNGZkNS05M2ViLTZiZDZm\nNjgxOTA0YzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJSbkrTbFeMgZrcg8Jgh\njJWEOy27ln5lbOMZKuEYnOJ19+htlukH595LCYFWPAVCCahrcI2s3MszHmg2jfCt\n31WjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRZcXrvEkI9hR4Daqlq7ryx2DPVmDAfBgNVHSMEGDAWgBR9QUe4b5kIlVgcGvmX\nJHfo7D2m/DAKBggqhkjOPQQDAgNJADBGAiEAw28L5T3e/MvKgUVHw8aHjdM3glx6\nyho7jU8XToEPBdACIQCucVmiFiZ5A4dN0LE6Hgeg/iuKYeSsO+3HoMY1MobA7w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWh92ftJ1TUigiCg0KVfA0mBMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJGVm\nYzkxZWRiLTAzMDAtNDY1NC1hZTcxLWVhYTY0MmRlNzhjYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDdiYTc1NDFhLTZhNzYtNDFiOS04ZGQ1LTg5NGJj\nZWMzNDNhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDC4/rPkHqD5PMbrLPXE\nJDu+EFJm/NHZkm+EXT2LeoUrumQtNsewO75JtgOYjMojJzN9LHMH52iq3Ls4A5Fw\nSZCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQvZoWY5u8sG3r/KG6IeHauJMyQMTAfBgNVHSMEGDAWgBR9QUe4b5kIlVgcGvmX\nJHfo7D2m/DAKBggqhkjOPQQDAgNJADBGAiEAjm96J/IdgXHCeUEfmYzREOZL5/F/\n12TQdjoB/dhrzP8CIQDL3nwRPW19go+SzJgh0Sy8r/PnRFaJoT1gi/b7fwNEmA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeIVH6xlXIFanX3+JH4Udu/tMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDdi\nYTc1NDFhLTZhNzYtNDFiOS04ZGQ1LTg5NGJjZWMzNDNhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJGVmYzkxZWRiLTAzMDAtNDY1NC1hZTcxLWVhYTY0\nMmRlNzhjYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN8iTP99ceq+joZLn8kO\nhZppnSfoAj4CnPCvp6pOu+eGPIico5f6irguoBxSbkxkNsZy9KtSUL4t/wHEax9n\niGKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR9QUe4b5kIlVgcGvmXJHfo7D2m/DAfBgNVHSMEGDAWgBQvZoWY5u8sG3r/KG6I\neHauJMyQMTAKBggqhkjOPQQDAgNIADBFAiBK6j07iFUVxwoRRb1rtAhe1c9m3Dv6\nZ8AWlIS8KJ/rnQIhAP92+/SRAHORq9TnMIJQmnNnuD59E4MnbSiLLVOwmtlA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWzRiVtskF7iC+nqxMfOsbGgMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDcz\nY2NhODVhLTAxMjEtNGZkNS05M2ViLTZiZDZmNjgxOTA0YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDQ0NDkxMzEyLTg0MjYtNDkxMC04NTM0LTAzMjY5\nOGZkNTA4ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJclbah3cowQlhQVUlMK\niLJFaT7QCOK3oI39vaazSa6g44AmkjM8UNNYusdkHFGNCaIEp7fL5KTnolQntm5m\nq0CjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRF9muTjsUQfsSFactgaIOmjXNboDAfBgNVHSMEGDAWgBRZcXrvEkI9hR4Daqlq\n7ryx2DPVmDAKBggqhkjOPQQDAgNJADBGAiEApjbqjB1UVXcjjqKUK05zM3gd539n\nDet+EzS1JE5ETE4CIQD49UbXO+NmyN3aISbrpgR7lUx2CRi5tYU9yG86ZKpXDQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYOZD3XVQ1sHNs0yMo2NaFLsMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDQ0\nNDkxMzEyLTg0MjYtNDkxMC04NTM0LTAzMjY5OGZkNTA4ZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDczY2NhODVhLTAxMjEtNGZkNS05M2ViLTZiZDZm\nNjgxOTA0YzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJSbkrTbFeMgZrcg8Jgh\njJWEOy27ln5lbOMZKuEYnOJ19+htlukH595LCYFWPAVCCahrcI2s3MszHmg2jfCt\n31WjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRZcXrvEkI9hR4Daqlq7ryx2DPVmDAfBgNVHSMEGDAWgBRF9muTjsUQfsSFactg\naIOmjXNboDAKBggqhkjOPQQDAgNJADBGAiEA8OkCzIeG1nmxE4H3sP+ews1Gpvf4\nTceJw9pvAmt1WiwCIQD6OE8SwhXb2JLV9EiPqa7OBbqo+OKrXeczFMBheveRmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZ06vYGK8LrKlS2veav83QMiMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDdi\nYTc1NDFhLTZhNzYtNDFiOS04ZGQ1LTg5NGJjZWMzNDNhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDQ0NDkxMzEyLTg0MjYtNDkxMC04NTM0LTAzMjY5\nOGZkNTA4ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJclbah3cowQlhQVUlMK\niLJFaT7QCOK3oI39vaazSa6g44AmkjM8UNNYusdkHFGNCaIEp7fL5KTnolQntm5m\nq0CjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRF9muTjsUQfsSFactgaIOmjXNboDAfBgNVHSMEGDAWgBQvZoWY5u8sG3r/KG6I\neHauJMyQMTAKBggqhkjOPQQDAgNIADBFAiEA72TSNKiIcC4awuNhPUqsljYsNjUa\nUS89VLv/FunDxAYCIH5Am/h1UbObQeFjpr46cukOmRpL/j6MQLknwvV2ors6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAS/I0+/HBw6bWl0Ba8Fob+XiMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDUxZTliZmIxLWJhZjktNDkyZS1hMmQxLTllMmM1MDAzNTJmMjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJGVmYzkxZWRiLTAzMDAtNDY1NC1hZTcxLWVh\nYTY0MmRlNzhjYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN8iTP99ceq+joZL\nn8kOhZppnSfoAj4CnPCvp6pOu+eGPIico5f6irguoBxSbkxkNsZy9KtSUL4t/wHE\nax9niGKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBR9QUe4b5kIlVgcGvmXJHfo7D2m/DAfBgNVHSMEGDAWgBT+ItGHfH3ENCHv\ndFIKQS5yxPLFizAKBggqhkjOPQQDAgNIADBFAiBhKIENTG0dmAPnDEy40YODGjiP\nL5h2uBT3pggF5jK2twIhALnfoHmjfnv6PQ2XRUcoyzra+MUP35QFCjeXCE72juFi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAU/vSfN3IeawaWwVDr4TaEB2MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDUxZTliZmIxLWJhZjktNDkyZS1hMmQxLTllMmM1MDAzNTJmMjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDdiYTc1NDFhLTZhNzYtNDFiOS04ZGQ1LTg5\nNGJjZWMzNDNhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDC4/rPkHqD5PMbr\nLPXEJDu+EFJm/NHZkm+EXT2LeoUrumQtNsewO75JtgOYjMojJzN9LHMH52iq3Ls4\nA5FwSZCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQvZoWY5u8sG3r/KG6IeHauJMyQMTAfBgNVHSMEGDAWgBT+ItGHfH3ENCHv\ndFIKQS5yxPLFizAKBggqhkjOPQQDAgNHADBEAiAiZX0FqeS9/wh11ryLXpkaTGc3\nuI3hiTplCBlErBTvbQIgIfpvkvDwiKlLPVfeL0aDYY/ouN2X9VU4s+uHrDc8szM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXrX3+IdtevlKgomlqG5FjN4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJGJm\nYzUyYzAyLTU3Y2MtNGE1My05YmEwLTQwY2FhYWEyYWJmODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJGYwNjdhZjg2LWI1MDgtNGE1Ny04NmIyLWNmNWYy\nZDhkMzJjYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABC++up/CuQ3ZQc5qEGtu\n1BwQTNJrshj6RmRILMT3ZhaP/uvcgFR4vSnF3ymtQojk2ZTxTjKoCCQ7BX9cpTEj\nxe+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSGW9Tuv0LJAOq9hdFY+zrKKwv5ADAfBgNVHSMEGDAWgBQerA2uAfEscmeIAYst\nSpAs8ZL5FjAKBggqhkjOPQQDAgNIADBFAiBN+0PBx8xw6mljpN4uBB1DiMXp3QE9\nvJP7jQCgYi7qngIhAOwl9wtzEMqhGUMp6wbEO/cqzwOofFP/2Y2sM/90Llwc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQWD5tOmJ1H0eRyE4Ct1Zal6MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGU2\nMTgzNGI3LTBlOWItNDAzMC05NDYwLTliZmU5YWM3MzI5NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDYxZTYxY2UyLTdiNDItNGQ5Zi1hMzA3LTUyMzhl\nZTBiMGYyMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBondJyA968dW8DPiQG1\niyQRldzKWyh4mK3y8OgIFtPWFoWulVSet8BMUBbWkQTFSFPhFJjTUykAAiNAHd2k\nRK6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSf2QOCqKWIJk6BIfjETfiGZnA5KTAfBgNVHSMEGDAWgBSOuaXmFj/XJU7grxuB\nTi1uOt4ajDAKBggqhkjOPQQDAgNIADBFAiEAwOD66EUl0KDjZ2AEK0AopzAspGl3\nEit0+BgmSLjaXRkCICAAyL0yJwZ5XX2go5i2AVhiq3863KHPxVk4e4BA2B5Q\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdHE7ChdfzOZloz30/2D/nRlMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGU2\nMTgzNGI3LTBlOWItNDAzMC05NDYwLTliZmU5YWM3MzI5NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJDIwNGM4YWU0LTNiMTMtNDcxMS04ZGJmLTY4NjVm\nNjc1NGIwZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLoiSpzvTBDQ6/2Aoyuc\n6O5TF70X8JT9PRNJn40B4ja4U4khU/z4gV8ihJ6QqQK4PC6Sg2z6S2mwQC8dFGNN\nDpKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSpjiFu3R90/nxelaWfL8450oKKIDAfBgNVHSMEGDAWgBSOuaXmFj/XJU7grxuB\nTi1uOt4ajDAKBggqhkjOPQQDAgNIADBFAiArxLZHIqbOptN0HR5DDHX9xkn6Y1ZQ\nP+LzOcrS1G8XWAIhAPlRTA00TwFaFdQXVY7NJZlBZRcexQgZQgNq7g87pNrx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAdFbr2BgN5tFokZN2V1jWIIlMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGY5OWZiZGQ0LTNiY2UtNDJiZS1hMmY4LWE5ZWUyZTI1ZjI5ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJGJmYzUyYzAyLTU3Y2MtNGE1My05YmEwLTQw\nY2FhYWEyYWJmODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFFfqM+MmOs33go6\nqule30KHACoK921MFqj6Hp0jQj+jDVnl1TJkQM+icBcLzkd3lsmCYYV8gdiD4mCJ\nuW7rh4SjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQerA2uAfEscmeIAYstSpAs8ZL5FjAfBgNVHSMEGDAWgBSJZ1Dxsj5rR5rq\n4RMxMa1Cz5SD4zAKBggqhkjOPQQDAgNIADBFAiAtV5+axj1uvVuClEdMgL5Qhaxg\nTggAOPYjCwWEuAKxjgIhAIi9gPyMjB4sMuLutcKlcoyZrim2O7dna2F12e/0oUYd\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISATQ/xX24ITQJA8zK17G5QIRcMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGY5OWZiZGQ0LTNiY2UtNDJiZS1hMmY4LWE5ZWUyZTI1ZjI5ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJGU2MTgzNGI3LTBlOWItNDAzMC05NDYwLTli\nZmU5YWM3MzI5NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJKdnE+K4EuhZymI\nFsS7y+VAOWr/jG+kGf5RFjXodUnvAeDQcYjJy4QrVd2obaOtDQiGPDVWF1yfF4Bj\nc/gswtejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSOuaXmFj/XJU7grxuBTi1uOt4ajDAfBgNVHSMEGDAWgBSJZ1Dxsj5rR5rq\n4RMxMa1Cz5SD4zAKBggqhkjOPQQDAgNIADBFAiEA1Bh+rHjBBi43MAU2P1Vrl9ME\n+LkY5uhOBGsgN3T9CnECIA5tgNd07sUSfIUnlK+2JheVSV/ABqZYtoUCIBzpRO9d\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAW6l0edLh5/tIyb/PSQmiX0lMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGZi\nOTA2YTQyLTczNWYtNGU2Ny1hZGYxLWQyY2VmNTA2NDAwOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGUyODlhNGExLTc5NmQtNDRmOC05MWZiLTU0NjEy\nMzY1MGVjMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDpaFzKsgQeX8jG2/lmQ\nNXCv9DyCps4a05rj281wbnj8KAk/nJf3DIWH1zO21t9ZFn9oy4oe0x4QzKw9igrh\nGpqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQAAg87fz+cPaTblC5HnZAjEKCmFTAfBgNVHSMEGDAWgBRcFz2fTLnBkZ7dET4F\nqh5LozBLpjAKBggqhkjOPQQDAgNHADBEAiA+WnevTWwy0Uvu1tbY8Bk9yDms30Kq\nZPAh19buTeExkAIgeQ9vGkVIAoqfnmq1dRvr+JO1qbw5mslPC0STvJWrPQU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdlVatQWB8+G4jE1ILJQfcjPMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGZi\nOTA2YTQyLTczNWYtNGU2Ny1hZGYxLWQyY2VmNTA2NDAwOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJGJkMzZhNTBjLTY5ODEtNDE1Zi05ODE1LTBhNWU0\nOGZiYzExNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNNRClFGP/2PuSNxcLHu\nf3ShUngN4whuAvBKiWAJv0bmL+85pu2iLPBfU4UA6e2bu2i1SULGSWxRwu8gHNF9\np6SjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTY+Rimmk6wXv8bFMMpUagPeGZXlDAfBgNVHSMEGDAWgBRcFz2fTLnBkZ7dET4F\nqh5LozBLpjAKBggqhkjOPQQDAgNHADBEAiBgpzo0avXdpmiEtRjmURQL/dJifYrQ\nVMwsg3vlLSqnawIgeOUzkEXA7vMOauz6gJ6wa7+O+S61of/dGxCqnLAKD5A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAU9Ccgg0nqxOO47PVJdbNG7qMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDY0\nYjA0MTJkLWUxYmQtNDlmZi1hMGYxLWJhNjRmYjVkNWQwNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGZiOTA2YTQyLTczNWYtNGU2Ny1hZGYxLWQyY2Vm\nNTA2NDAwOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIbyECPUzrh1afIeGlzv\nJJBVfddNFcabtRYkCpojKJITqFR0MmocFH0FBIdcfY8QLLE3u3yzm6J99Snk2rWR\nQ8ajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRcFz2fTLnBkZ7dET4Fqh5LozBLpjAfBgNVHSMEGDAWgBQzPAeKG66GlexTi9EB\nQXEjW6CgujAKBggqhkjOPQQDAgNIADBFAiBT1bvZmLtX/IPq0tD1b3ShQrMMF2Wh\n/bLB0WgEeKeUbQIhAMDMSjigREN7GYVZDj7Dn9acWnXUY7jHQPJz7lqR++Pk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATsA1Ncg7P+e6LYaa6VqC+Y1MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDg4\nNGVmZWU2LTUwYzgtNDkwZi05ZDM2LWMyZDZkNjI4OTkxNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGZiOTA2YTQyLTczNWYtNGU2Ny1hZGYxLWQyY2Vm\nNTA2NDAwOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIbyECPUzrh1afIeGlzv\nJJBVfddNFcabtRYkCpojKJITqFR0MmocFH0FBIdcfY8QLLE3u3yzm6J99Snk2rWR\nQ8ajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRcFz2fTLnBkZ7dET4Fqh5LozBLpjAfBgNVHSMEGDAWgBSt6p5QaZkv5W5gBqxk\n1bWk+piPxjAKBggqhkjOPQQDAgNHADBEAiAlo+GehRZZ0fxRiuHY0J0dZpPVkArb\nDt1k+U/7sCutigIgEahnx7cTkqIEyIN3pQ4wo42HIE2KDtbZ9Ks41XzH6Xk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAWYcOQ1efstuyi+LiSIzz8BAMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDY0\nYjA0MTJkLWUxYmQtNDlmZi1hMGYxLWJhNjRmYjVkNWQwNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDg4NGVmZWU2LTUwYzgtNDkwZi05ZDM2LWMyZDZk\nNjI4OTkxNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAYwy972QYM8PlBPYk8T\n2mYjsIyFLB6SOGlgPlwv9/gcoqrlsIqi6g5h9bYL8sv58dK/dXDw0YoCKF0pJ48U\nBG2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSt6p5QaZkv5W5gBqxk1bWk+piPxjAfBgNVHSMEGDAWgBQzPAeKG66GlexTi9EB\nQXEjW6CgujAKBggqhkjOPQQDAgNHADBEAiBaG6UqiPEljYR7fbNTl+tiwqXFqkt6\nFuouxX9CvPXiAQIgUeayfBfzQdx8XNurQHBv2BmECRUgHbqa54sLHURsgJM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAViL1kOM46uBt8W8iE7kxuscMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDg4\nNGVmZWU2LTUwYzgtNDkwZi05ZDM2LWMyZDZkNjI4OTkxNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDY0YjA0MTJkLWUxYmQtNDlmZi1hMGYxLWJhNjRm\nYjVkNWQwNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJ8xfHk9bpbEb2MjFMW9\njywFR/2y33UMuetQ/jL6S0bbcg835UIZInXJt8dcqdJ2+M1r5cRSHf3tRHX2MpRW\nSRyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQzPAeKG66GlexTi9EBQXEjW6CgujAfBgNVHSMEGDAWgBSt6p5QaZkv5W5gBqxk\n1bWk+piPxjAKBggqhkjOPQQDAgNIADBFAiEA0nCvQ6+TXKwktzyRLpmBbhAn+U73\n9Mfgb6WeefiYJA4CIEwhui5wJZkI7usday/MNtjAICD/wBBLWlIcekvj0hfW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAVoa+MFwiAEci8bZcdRXqPFLMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGMxZjk3NzFjLTBiMzktNDdiZS05OWY4LWYxZGRhYTQ4Y2FkMDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDY0YjA0MTJkLWUxYmQtNDlmZi1hMGYxLWJh\nNjRmYjVkNWQwNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJ8xfHk9bpbEb2Mj\nFMW9jywFR/2y33UMuetQ/jL6S0bbcg835UIZInXJt8dcqdJ2+M1r5cRSHf3tRHX2\nMpRWSRyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQzPAeKG66GlexTi9EBQXEjW6CgujAfBgNVHSMEGDAWgBRzRf0Cu4mdHxSs\npGTB6E8TrW1nyzAKBggqhkjOPQQDAgNHADBEAiAniRyOnV6N0JdMAdRH3HG9V/Xd\nsYjXcUyN8DNsqex4CwIgXIQZG3KzTThyydcvbIeRkgkXa0snGpkBf5zWHP60Cw0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAehs45LZKtKyxTCKviojz8icMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGMxZjk3NzFjLTBiMzktNDdiZS05OWY4LWYxZGRhYTQ4Y2FkMDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDg4NGVmZWU2LTUwYzgtNDkwZi05ZDM2LWMy\nZDZkNjI4OTkxNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAYwy972QYM8PlBP\nYk8T2mYjsIyFLB6SOGlgPlwv9/gcoqrlsIqi6g5h9bYL8sv58dK/dXDw0YoCKF0p\nJ48UBG2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSt6p5QaZkv5W5gBqxk1bWk+piPxjAfBgNVHSMEGDAWgBRzRf0Cu4mdHxSs\npGTB6E8TrW1nyzAKBggqhkjOPQQDAgNIADBFAiEA2NPGl8ABbVl0iq3tOiyYWFxL\nUIZTGtIiV2eoTDjeJlYCIGqSpQLLrBJignNc6xQXSw6zjcUa8niYHrzzLagJbN/f\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa2V/BoI7prkF8QED4uQ5lROMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJDYy\nNGYzYTM1LTQ0YzAtNDM3Yi1hNzg5LTc5ZmMwOWNjMDJhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDEzZDM4NjI1LWJlNmEtNDAxYi05MTk5LTExM2Q5\nNGMwMzQ4MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABL2GRnyoyjOJKbEEca8l\nw489Qlu5lVVjp0+jhvn2pE8w3j5eQcoxsrXWfNOCPUYqc17CUxDWg84p1USysXA0\n8HKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRNWXf1EmTp69h9o4ie171CUhDyRDAfBgNVHSMEGDAWgBTNC6BiO3hb5rRxIJIy\nWlwLNCS/IjAKBggqhkjOPQQDAgNIADBFAiAdzkXgpTiGGeqZAIncx7Mb6fbxL1PA\nOFgxDbXK5A+1YQIhAPJalR72YOkAQuKEN/HsvflYG1jmpxSPuc5crXkM+uVy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeVJjVtxmq0bBOQKOTnqF9GMMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDhm\nY2U1ZjczLTM3NGQtNDI3Mi1hMjc1LTcxMjU1M2JhZTM1MDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJDYyNGYzYTM1LTQ0YzAtNDM3Yi1hNzg5LTc5ZmMw\nOWNjMDJhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABACgGZjGjDdN/LFb/Qv/\nlTk2evYOPZSJiw0b7QrXoGKM+9l+RElBgKnIJWbJ/kldi6bRWbN8+3B2XbzyjSLT\nB+mjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTNC6BiO3hb5rRxIJIyWlwLNCS/IjAfBgNVHSMEGDAWgBRIgwbDjiVPOpuqA4pU\n6QF+qpylUzAKBggqhkjOPQQDAgNIADBFAiEAg9iT7R99HpXQlY1zx+fEFVYpoqJb\nkMBibTaWqKMUMmQCIBgly8THX3hyEVoH8dSADJzpW7DtsfOzThUmDmfGLOZD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeWiFzHCnWCU4h5NTiSVljU9MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDhm\nY2U1ZjczLTM3NGQtNDI3Mi1hMjc1LTcxMjU1M2JhZTM1MDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDE4NDZkZmNjLTBjNDEtNDA3ZS04YWI2LTE4Njlj\nMzVkMmRmYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCvrnvQVKhCVOk6HxDkb\nW/cf09/N1h4E4lxcUc8MM2wK+AXUBUe39tTglFFgeS4CuY1UNHAnWktC9lRqVKmG\nVnajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSJVW5iRZb/6Niq3I564mpddnMaHDAfBgNVHSMEGDAWgBRIgwbDjiVPOpuqA4pU\n6QF+qpylUzAKBggqhkjOPQQDAgNJADBGAiEAx7atX5KtZSBYpdfwXOaKHGzuK2TI\nrPKbaEEtq98qSEkCIQDytFvua72qu1+P4PKLwNHKs8C4xiYagPZvxoV+v6wQCA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARS1eKcL0Bsdu25ZH/qg+Ld2MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGUy\nNWI2MmI5LWE1ZGQtNDU4OS05ZDQ2LWI2ODg2MWRhMTc0ZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDEzZDM4NjI1LWJlNmEtNDAxYi05MTk5LTExM2Q5\nNGMwMzQ4MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABL2GRnyoyjOJKbEEca8l\nw489Qlu5lVVjp0+jhvn2pE8w3j5eQcoxsrXWfNOCPUYqc17CUxDWg84p1USysXA0\n8HKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRNWXf1EmTp69h9o4ie171CUhDyRDAfBgNVHSMEGDAWgBTm/l6AA5O3e3i+yd4b\nle7ntsLk5DAKBggqhkjOPQQDAgNHADBEAiAl2LX1SyR9Nn9rpv6MB3sHrX7sHqbx\nHUtXzTzJ1RnL/wIgISxpwKRziScEbSmMv9EE7OCm+IkGr/fHmOW2NcQOOzQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAcgu1lPx/oqtwkDGOn88z4IjMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQ4ZmNlNWY3My0z\nNzRkLTQyNzItYTI3NS03MTI1NTNiYWUzNTAwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQaKdoPEBViu+UARn0otGZs4CWL1Tl2GbP6pQsFwHTbZ1nwaXUYk2KWI1V6\nyJy6sbQMuM+77LO88PI8NSjA4G99o2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIMGw44lTzqbqgOKVOkBfqqcpVMwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgDjSG\n2TeQdGbNPZV9Sl7ydBh213lUXSqo6qH7c6sCzpMCIQDqibcNS72gummc/6NFaBjR\n7TLnyyluhAtfQNf85wJKRg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISASfds48mrPrVcBcvH4c45kA7MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRlMjViNjJiOS1h\nNWRkLTQ1ODktOWQ0Ni1iNjg4NjFkYTE3NGQwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAT5aG6EckkKO/bm+2zkScufRLLzdbXpMAkMMeoLfkNYAOqFW+FBuvQw9kXB\nQlssyKVabFdsqNavKah7jQgK9CoTo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU5v5egAOTt3t4vsneG5Xu57bC5OQwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAI5b\n/W1p3zFrYL4pqzsRxxCocZK1iR6wfP/9BaheGb05AiBN7c7y148h/zgTqZcJXOFQ\nKjD00B4Cv/ATV6rplsjEVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAbindeH1BpsOgg197XgYXk3LMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDUxZTliZmIxLWJhZjktNDkyZS1hMmQxLTllMmM1MDAzNTJmMjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZjRlOTg4YjAtMDVmMi00ZTFl\nLWJjZjQtMzVhMzMwNzU1MjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXoVT\nVL42ll1TcQimAtAqjlY7xDyIAcyT0dTkmq4z1BlDk0qsM6w38SXCn0/ZslFARlEY\nVndEhrAUdlBUpvzSBqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFNiS9Yips4YKF/gTmFTsJFrZzZL9MB8GA1UdIwQYMBaAFP4i\n0Yd8fcQ0Ie90UgpBLnLE8sWLMAoGCCqGSM49BAMCA0cAMEQCIBLRnEj2n9ll3oF6\numPDpdRPS/2Invhhe5u8Z269naXuAiAJuAxuS/E9aeAZoQi4INBECQMXyoIeiw+L\nt1oxB4N7Pg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAZD5xFcPvE0pa+jnYEjQ6AntMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZjRlOTg4YjAtMDVmMi00ZTFlLWJjZjQtMzVhMzMwNzU1MjI1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkNTFlOWJmYjEtYmFmOS00OTJl\nLWEyZDEtOWUyYzUwMDM1MmYyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8Ayt\n+wbAV76T7LB7uaCCw8JDkbLeGPR+1eBtIslwXHFC4W3B05AZfkU+hFhEGnhJiFK0\n6Nd6TCOhc2DV2yK8wqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFP4i0Yd8fcQ0Ie90UgpBLnLE8sWLMB8GA1UdIwQYMBaAFNiS\n9Yips4YKF/gTmFTsJFrZzZL9MAoGCCqGSM49BAMCA0kAMEYCIQCjhSpMiG4kdjzy\nwghHabvp1KyrNODoTfLOvOk5Hu+ZcgIhANIokwvmibBs0eDuRmoTkgih7RuGLQ75\nPM9xcPtxQbuW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAT1Sqql61b1lvS7uWFFE5O8eMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGY5OWZiZGQ0LTNiY2UtNDJiZS1hMmY4LWE5ZWUyZTI1ZjI5ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZjRlOTg4YjAtMDVmMi00ZTFl\nLWJjZjQtMzVhMzMwNzU1MjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXoVT\nVL42ll1TcQimAtAqjlY7xDyIAcyT0dTkmq4z1BlDk0qsM6w38SXCn0/ZslFARlEY\nVndEhrAUdlBUpvzSBqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFNiS9Yips4YKF/gTmFTsJFrZzZL9MB8GA1UdIwQYMBaAFIln\nUPGyPmtHmurhEzExrULPlIPjMAoGCCqGSM49BAMCA0cAMEQCIDN2NG2BmOj1TVI0\nQP7v5cUzYt3vIroOqmzMa8tYLUJgAiB5j1BD/RqmILsWIagrI1K8qxRcciJWkAWf\n6GIw0xIqFg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICBDCCAamgAwIBAgISAYfWkzJZBjkMObs0jDeiBO58MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZjRlOTg4YjAtMDVmMi00ZTFlLWJjZjQtMzVhMzMwNzU1MjI1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkZjk5ZmJkZDQtM2JjZS00MmJl\nLWEyZjgtYTllZTJlMjVmMjlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5uiR\ne5j8Ok1g67Nz67pxgkuDoJeHfXiv96WD5+NkC76gfuI7jdPy6sEToyyDRISKml8J\nr/XWe5xSiy/Qphvnj6NSMFAwDgYDVR0PAQH/BAQDAgIEMB0GA1UdDgQWBBSJZ1Dx\nsj5rR5rq4RMxMa1Cz5SD4zAfBgNVHSMEGDAWgBTYkvWIqbOGChf4E5hU7CRa2c2S\n/TAKBggqhkjOPQQDAgNJADBGAiEA01SZ+Ps3GTvtHsDU2JQv7h6P4ArBNTcI1qxN\n6pQLJg4CIQCOKQy+X0YI44Wy/bXg4OqUJo6CZUGY+sXahDwNZpbnUA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAYLQ7VWvNL9UBeXS/1sHukfCMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGMxZjk3NzFjLTBiMzktNDdiZS05OWY4LWYxZGRhYTQ4Y2FkMDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZjRlOTg4YjAtMDVmMi00ZTFl\nLWJjZjQtMzVhMzMwNzU1MjI1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXoVT\nVL42ll1TcQimAtAqjlY7xDyIAcyT0dTkmq4z1BlDk0qsM6w38SXCn0/ZslFARlEY\nVndEhrAUdlBUpvzSBqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFNiS9Yips4YKF/gTmFTsJFrZzZL9MB8GA1UdIwQYMBaAFHNF\n/QK7iZ0fFKykZMHoTxOtbWfLMAoGCCqGSM49BAMCA0cAMEQCIHIFusnlcvnWHYYz\ncyBOI2wx5bvViKxSPMK6kWMZf4saAiAiqBcbcKNHKSt0A+MgPEkZph6p0geV4+MZ\n4ayVEZ41aA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAUKY/xOwhBK4WvB7TfjJqX6jMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZjRlOTg4YjAtMDVmMi00ZTFlLWJjZjQtMzVhMzMwNzU1MjI1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkYzFmOTc3MWMtMGIzOS00N2Jl\nLTk5ZjgtZjFkZGFhNDhjYWQwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEu0I5\nnHnEZ9YO19iPgGc3UxiWGHX3Y1OZuH8a92LpkRqMSDGQ9xOFvyJFOQ7LuXRszz1f\nED7uB/JP910+fAocZ6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFHNF/QK7iZ0fFKykZMHoTxOtbWfLMB8GA1UdIwQYMBaAFNiS\n9Yips4YKF/gTmFTsJFrZzZL9MAoGCCqGSM49BAMCA0cAMEQCIAuSOn9hEYRrKdJy\n2upGLpCChXjoe8ossQD1/q+Rf49/AiA0oliCeW7MompaZQ4kG84nbc3ltGijygLD\nUPvSdxXeFg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAbdfhIoi0hGSHzvAjM5DaBkSMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJGY0\nZTk4OGIwLTA1ZjItNGUxZS1iY2Y0LTM1YTMzMDc1NTIyNTBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABF6FU1S+NpZdU3EIpgLQKo5WO8Q8iAHMk9HU5JquM9QZQ5NK\nrDOsN/Elwp9P2bJRQEZRGFZ3RIawFHZQVKb80gajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTYkvWIqbOGChf4E5hU7CRa2c2S\n/TAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNI\nADBFAiEAwfqSGaNgqAljvMaG5izQwr432145GoL7x9r1sP1rguMCIDlscc9Z3vf5\nQF0Dnrfh0FOeMNpWCwSF0OoUZVp6MnIA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISATLNqKUs30auYiN10TF/4k20MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZjRlOTg4YjAtMDVmMi00ZTFlLWJjZjQtMzVhMzMwNzU1MjI1MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBTYkvWIqbOGChf4E5hU7CRa2c2S/TAKBggqhkjOPQQDAgNI\nADBFAiBBRc6rVm52Q5U6p8Nb6efK8zvQ77HT/eFtmS7wufWd+wIhAKpFW1Ss4hYE\nzrrMXlmnx0vLaytz4JQB+1NkR0DQcKGv\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISATHGrkNbKdQrKTzoN+hU+/UgMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDYx\nZTYxY2UyLTdiNDItNGQ5Zi1hMzA3LTUyMzhlZTBiMGYyMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ1OTdlNjI4Yy1mNjU4LTQ1NDctOTYxNy02NTBm\nNjYzMmI0MGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASsAa+tBM4ahtITc3cu\nkrzDBQvODKHlW4WV8ayMezc+C42iQhm0jCrCPd7WbeIsdETA2j67s3DLVoXCHHow\nCuu6o2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSf2QOCqKWIJk6BIfjETfiGZnA5KTAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgIVWy8CZe6WzAi6xm\nH5Sx74+tLQm6xqfLCEgYRxDzB/QCIQDWP515GSHO8MbCstFSgLtIssdmkb7LGaF4\nj91PtrRLAA==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc73", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `73` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYjkIByiWiut6dXEgDHlDarQMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDE2\nNjBlMzY3LTg1MjEtNDEzMC1hMTc4LTc5NzcyZWJhMjFjZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDI1YjkwMWU3LWE3MzctNDU3ZC04YWJlLWI3Y2U4\nMDJmYmVhOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIbGK4o2t4fld7PsdZwL\nvLQ90mx1WABqC2naUAPL3OzE48zBBbF1O10ZKgQHaLXElj4Pdfem3Nlm1RFCz8Ss\nGrejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQRVBC/erYMXqCcIDKcW5yFmQKMszAfBgNVHSMEGDAWgBQ2SDhpUDOvOtMWOsQl\nQiVizkIW9zAKBggqhkjOPQQDAgNIADBFAiEAnwfjVUMHlAzAacz7H/1j5sKlz/cA\nU2JNz30M4Z+qbJUCICe9nkrhdvzA8byMl9/Kyh15yxI1So9mCr2mDZjcmiei\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfIYWyashInuRmg7BfLzva8IMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDE2\nNjBlMzY3LTg1MjEtNDEzMC1hMTc4LTc5NzcyZWJhMjFjZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDJjNjEzM2QyLWIwZjUtNDYxNi1hYTdiLWQwODVi\nNzM1NzU1NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAhJG8K3OAqK07IMAeaQ\nHQuD85ilHhAMej+buCyRUqShA138GQM8DV6X6J6BK+WIRy3iY6AGm/g1/ojTitkF\nntCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBShaOqaF9EVCwCajDH/8Bcs2t6VHjAfBgNVHSMEGDAWgBQ2SDhpUDOvOtMWOsQl\nQiVizkIW9zAKBggqhkjOPQQDAgNIADBFAiB3D58MwXHkPEEnEgjX8ISyBB0D+J4m\nl2coki8Eq18LsgIhAIn4Yqhzb/lRtJhrjSoYQHUbJzykGZ92Qbc6jcVoGd8I\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAY8snHcbKNmU1izlmjH4QuqSMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDJj\nNjEzM2QyLWIwZjUtNDYxNi1hYTdiLWQwODViNzM1NzU1NjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDE2NjBlMzY3LTg1MjEtNDEzMC1hMTc4LTc5Nzcy\nZWJhMjFjZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCL4zuiK8axB8IM9w+uI\nshFzTDFHesQJXUtCOmZwu+3v3kFfK35Sij8FOVKCZMVQXbwUWQAdKWvaUY/2H5tC\nsrijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ2SDhpUDOvOtMWOsQlQiVizkIW9zAfBgNVHSMEGDAWgBShaOqaF9EVCwCajDH/\n8Bcs2t6VHjAKBggqhkjOPQQDAgNJADBGAiEAyY57P0nHMn5Oq48GxjFf8QGbvsW/\n4qj3ts5Ze7YYI4cCIQCWGlWOYEH9SrNOqIGLs8wsaI9tIxcOCUUr5WPF/prFxA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcuA4kv4dVSATFLw7W50pAvKMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDI1\nYjkwMWU3LWE3MzctNDU3ZC04YWJlLWI3Y2U4MDJmYmVhOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDI2ODM0NWUyLTllYzgtNGFlMy05NDc3LTNkNWZh\nNzRkMTVmNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCN3hDNKPa2pEi0bA6fj\nkNj+2r7UNlGx2EcRk+9QMe9su5TBE15W5IWbb5/fp3vK/6qZh8XCfmLC8vaWxMy2\n9kyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTAu9tm/tF5U7jfNajmnfDhC6v05TAfBgNVHSMEGDAWgBQRVBC/erYMXqCcIDKc\nW5yFmQKMszAKBggqhkjOPQQDAgNJADBGAiEApRZ+7U7RKRpVyLGIqwhn3g0UtBmZ\nUICjmzOqWjrzgTkCIQClM1aov7WT5tPrKRirCB0/pDCT9KyjW2RKZee5h+H5Wg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATuZdnjyID7FsKxMIfaNPL2YMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDI2\nODM0NWUyLTllYzgtNGFlMy05NDc3LTNkNWZhNzRkMTVmNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDI1YjkwMWU3LWE3MzctNDU3ZC04YWJlLWI3Y2U4\nMDJmYmVhOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIbGK4o2t4fld7PsdZwL\nvLQ90mx1WABqC2naUAPL3OzE48zBBbF1O10ZKgQHaLXElj4Pdfem3Nlm1RFCz8Ss\nGrejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQRVBC/erYMXqCcIDKcW5yFmQKMszAfBgNVHSMEGDAWgBTAu9tm/tF5U7jfNajm\nnfDhC6v05TAKBggqhkjOPQQDAgNIADBFAiANR7wsOb3TxIOlL6IrPBICP/V9aYCX\nr8hiY4bVWC3VWwIhAPCFQKHbg2/O2y8Byc30a93/paXHXNGwy8AifjctJcf2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVax/n6L+QeTXhH2H0UJInC/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDJj\nNjEzM2QyLWIwZjUtNDYxNi1hYTdiLWQwODViNzM1NzU1NjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDI2ODM0NWUyLTllYzgtNGFlMy05NDc3LTNkNWZh\nNzRkMTVmNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCN3hDNKPa2pEi0bA6fj\nkNj+2r7UNlGx2EcRk+9QMe9su5TBE15W5IWbb5/fp3vK/6qZh8XCfmLC8vaWxMy2\n9kyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTAu9tm/tF5U7jfNajmnfDhC6v05TAfBgNVHSMEGDAWgBShaOqaF9EVCwCajDH/\n8Bcs2t6VHjAKBggqhkjOPQQDAgNJADBGAiEAmxrOgq1G1+ZqJU1UpLPo9++wLxxK\noo3+RVXtCC8uBQkCIQCc6EW5wj2zFIsb6j7AEQZVCHbReg3ovBcWOK9ygp4g6g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfv0/J97vFUMvSkQqtIyUy4FMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDI4NzM3MTA5LWU5ZmUtNDAzOS1hZGQxLWQzYTNmYmM4MDFmNzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDE2NjBlMzY3LTg1MjEtNDEzMC1hMTc4LTc5\nNzcyZWJhMjFjZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCL4zuiK8axB8IM9\nw+uIshFzTDFHesQJXUtCOmZwu+3v3kFfK35Sij8FOVKCZMVQXbwUWQAdKWvaUY/2\nH5tCsrijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQ2SDhpUDOvOtMWOsQlQiVizkIW9zAfBgNVHSMEGDAWgBR8gWP2CIeihv11\nqM9rk7TXNG0KuDAKBggqhkjOPQQDAgNIADBFAiB+GNE0FxtVw4+YEosV+x4j7EvZ\nodarq3LR9KEfZeFtAwIhAP2W9B5xKgsDbhYCSCRaoCvOgCLLMvaZ15fsX/0ZpAkj\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAQR41MEnCaxMUQV7h5V4yA1zMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDI4NzM3MTA5LWU5ZmUtNDAzOS1hZGQxLWQzYTNmYmM4MDFmNzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDJjNjEzM2QyLWIwZjUtNDYxNi1hYTdiLWQw\nODViNzM1NzU1NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAhJG8K3OAqK07IM\nAeaQHQuD85ilHhAMej+buCyRUqShA138GQM8DV6X6J6BK+WIRy3iY6AGm/g1/ojT\nitkFntCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBShaOqaF9EVCwCajDH/8Bcs2t6VHjAfBgNVHSMEGDAWgBR8gWP2CIeihv11\nqM9rk7TXNG0KuDAKBggqhkjOPQQDAgNJADBGAiEA6dCknbxP0eWtkGEKhFNl9++u\nZq8noVc6/nf7cMfM+RQCIQDI7c6/FhxT1Sol5eEsPkTqISI5ySEwp4J9X62sxaFd\nvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATcz8lWes5lbmjN3BwJh0KajMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJGRj\nMTRmNDU1LWI5N2MtNDVhYi05ZjQ4LWNjN2RlMDRmYjQyNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDA2OWQ2OGFiLWNmMTAtNGRlZS1iNGUyLWE5MDE5\nNGEwYjFkMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMJM8mJYbRu6Rv2ihVgw\nXwVbTUHWZZ4LuN1jVhIwVLbUfe3PBlHmE0X2xoKvfA2cpxkeNNAFJDSC+tfwfKA8\namOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQJskvmb0yJQLb3zOJGvfsP8z37+jAfBgNVHSMEGDAWgBSBcwm8AYzXsXO47l5A\nulNHTEYxVDAKBggqhkjOPQQDAgNHADBEAiAgZJEM09vMNJMmc81rG2bLKvvqdZia\nyRRYiOsLdBhO0AIgUfmbuOO14OBL8wYbbldLKXJXlZhla9zfNAS+P6QtT1g=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAf4PcCtOgbW7c+Q4OV4xPPdhMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGMz\nNzhkZmNkLTdkMTYtNGM5Ny1iY2UwLTVmNWM0Yjk3MmZiYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJGNmNjFkZTI1LTg5YzUtNDI5Yy1hOGQyLWU1ZGNh\nYjgyY2I0ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBCEjswTuTPdwMn1DkP8\noyXQeWCD4tAwaf7e58nXVcDmaKdH19VMSYMJxEIhDq27zmpIFAo/FGBxPHpU9yq/\ny62jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ84KK4Q0UWjoJeA3kstWryqjfNCzAfBgNVHSMEGDAWgBS9V1Qxwk2iZY1PVFez\ne8vfnFgmXDAKBggqhkjOPQQDAgNJADBGAiEAgDa61bt3m5tscKjWlDCpUK4+yXQf\nERhZAfnIEed/9QQCIQDuAFbvj38DYfv6wdCC0G+uuAr/6HBoDEGZtVVOjzBBog==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdUEmFuEPIDvqk4DMrdL4yZGMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGMz\nNzhkZmNkLTdkMTYtNGM5Ny1iY2UwLTVmNWM0Yjk3MmZiYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJGZmN2NmNjUyLThkNDEtNGQxMy1hOTM1LWFkZTNj\nMDczYTJiZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABH2uzPRI1nJgxu6jzu4t\nmRFpciqoh6KHARepOflFF/t9ZaWFbe3hnys1i5T9AehrtEZZ1GzMX26DGz8wws+R\n3y2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQNqL0fYlS8cPpBZvYTxDlfd/uT/zAfBgNVHSMEGDAWgBS9V1Qxwk2iZY1PVFez\ne8vfnFgmXDAKBggqhkjOPQQDAgNJADBGAiEAr94PkayN1YUXAcC7MmfVcg0t2djn\nfH+ZtfekSC949QwCIQCo1AlKL7tB3mesMmiljycULACkUCzM8YprPjB1bwFDyA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAQDfLuvC/eiMP4x3aCljeerqMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGJkMjgwMmU3LTczYzUtNDM0Zi04ZTUzLTA0ZjExYTE4MzFiZjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJGRjMTRmNDU1LWI5N2MtNDVhYi05ZjQ4LWNj\nN2RlMDRmYjQyNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHNdJyil24XY/FBQ\nJtC8ozKhEpjccN4IpGATOjJNURH8Hu+8o3QicTjSY1fmsQPMLUj82pHeg1XErlAB\nvi0sjwWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSBcwm8AYzXsXO47l5AulNHTEYxVDAfBgNVHSMEGDAWgBSshJM9Y9a2CL/M\n1tXJyNtwarCMozAKBggqhkjOPQQDAgNJADBGAiEA3hN8dVMSfqYq0YKWZD9aysPp\nZnYNys0xP6ojXnhH2OQCIQD2Xos2FwxGeX4j0L9YvXX89nmODixULO8P3aHHD0PS\noQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAZkiBGanVhUwAK+Grh9jYRpIMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGJkMjgwMmU3LTczYzUtNDM0Zi04ZTUzLTA0ZjExYTE4MzFiZjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJGMzNzhkZmNkLTdkMTYtNGM5Ny1iY2UwLTVm\nNWM0Yjk3MmZiYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD/9E6zkIQJYYBUK\nAnkfjeMqzB7F4c8Af1BKmMoN0PG6OSAdFuNffD9rgOpKQ23mlB6QjgqIvNrjQEjL\nzSIEeEejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS9V1Qxwk2iZY1PVFeze8vfnFgmXDAfBgNVHSMEGDAWgBSshJM9Y9a2CL/M\n1tXJyNtwarCMozAKBggqhkjOPQQDAgNJADBGAiEA0P5MJs7hGF7fM276E4mrIHMR\noz77bacnTJurgZjvwQcCIQDJG8BawYSvT7LsOfQCC6iVqqWhK0dFta9DUanvlnU3\nZA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVZ+RXAVqTULuFCPzrnU1ZxWMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGNm\nN2YyY2MxLTk3OWMtNDc3Ni04YTI0LTE5Yzc3MzkwZmQ2MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJDc2NWUzODIyLTc4YTAtNGFlMy04YzMxLWYzNzc2\nZWY4MDgwMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPgYUkONHSgQSQMpYKFl\nz9v9IJ18k8w4t31X3snfwzfdIpg39dYeqRI+cj9DZwg5ei/k+fWRQjt+U5wwuKr7\n6kajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTlEi2lGZnpstyOJpDhPVoZEc6wZzAfBgNVHSMEGDAWgBSZlpy9Rrj8+kAnDbY1\nwDnKMXW2cTAKBggqhkjOPQQDAgNIADBFAiEAgE7l/Z1GkWGtggyJO3t3rML9Orj8\nj+WP5KIE4RNeesYCIGL/AWb6wU1k+rU/aHsC5VOeGubVjhvMh744rAxo7l9D\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATQn0tTv5vfmNz7hZVeacPAMMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGNm\nN2YyY2MxLTk3OWMtNDc3Ni04YTI0LTE5Yzc3MzkwZmQ2MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJGI0MTMzMTk2LTc3MzYtNDMzZi1hYTViLTU5NDI4\nZjc4YWIxNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGAUZ1KQfl4w0q80CIwZ\nLcYCVfHV+XvBoKN7njoYCHjwWukEKQwIRFXEzYEXxM4gJIUg0RjbKtUVMtiPswC9\nKhCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSH0Uol8Z5kP6SsnpUDL1jTfsj+uTAfBgNVHSMEGDAWgBSZlpy9Rrj8+kAnDbY1\nwDnKMXW2cTAKBggqhkjOPQQDAgNIADBFAiEAliVCQI2Jk0A2SLRN9HONmBFDFfpX\nSIpS6hVQ0RFDSCECIGgZAnKEXriO7GjcNFYTP7R5mp385PdyXoE24G/pbqOe\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISASbbZAXDbfjx40v3EQieZi4KMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGMy\nM2U2ZTE2LTZmNDEtNGU1Yy04ZTlkLTQ0YTM2YmJmMzU3NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGNmN2YyY2MxLTk3OWMtNDc3Ni04YTI0LTE5Yzc3\nMzkwZmQ2MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABH2Iohg9zApbKO+sYKki\nrvvdpZHGFOr1MJ9Xr5BABTmM2D5XtzaukE1pzprqMvIaMFkNdj2bvyPnfR9wlBM7\niIijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSZlpy9Rrj8+kAnDbY1wDnKMXW2cTAfBgNVHSMEGDAWgBQTEI45LsnFlm6QR1G1\nowDLW43G1TAKBggqhkjOPQQDAgNJADBGAiEAm8ClYQ1V8NqmI13D142VtlRnV7Sp\nMLrkgJMYUkIwiRUCIQCBtV9gN++xXUMtnnNQmHXvCXrsHqMVIH2CUJDsbkjtQA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZBchdsITIxpCrUIhZa+aMAqMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGI4\nNDM4MjJmLWMyOTgtNGYzNC1hYjY3LTI3NTFjYjIyMGY1ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGNmN2YyY2MxLTk3OWMtNDc3Ni04YTI0LTE5Yzc3\nMzkwZmQ2MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABH2Iohg9zApbKO+sYKki\nrvvdpZHGFOr1MJ9Xr5BABTmM2D5XtzaukE1pzprqMvIaMFkNdj2bvyPnfR9wlBM7\niIijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSZlpy9Rrj8+kAnDbY1wDnKMXW2cTAfBgNVHSMEGDAWgBRTfm8+w9rMxifxZi+H\n28SUZFJ1kzAKBggqhkjOPQQDAgNJADBGAiEAx7suop2uSxG2ctjBVkuArsrQilYb\ngBr+e+QZgGKRNtgCIQDW9k3ICPLGXLwP8sryENfmSG0kh4SRfeRtzge0FpcMBA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAa5uqtAQWuWFG4u7Xvc2qLNIMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGMy\nM2U2ZTE2LTZmNDEtNGU1Yy04ZTlkLTQ0YTM2YmJmMzU3NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJGI4NDM4MjJmLWMyOTgtNGYzNC1hYjY3LTI3NTFj\nYjIyMGY1ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAbVe43iJOGGGYU/JR81\n8/6XW8YADaToJM3R2/v307jfWyTA6gBxAsIuwegh0TKpBvKszu5h5nu5wIsPhddh\nu42jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRTfm8+w9rMxifxZi+H28SUZFJ1kzAfBgNVHSMEGDAWgBQTEI45LsnFlm6QR1G1\nowDLW43G1TAKBggqhkjOPQQDAgNJADBGAiEApJRofhBMQ4clWZurvQAZjTQurNpR\ntoJ+amj/wOWBjM8CIQDFZKUEyCZRq3P17TKOFAwicEzcL2FS7A+qOKodzR7erA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXu3UwCuUTVdKeMmn4KhpIYQMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGI4\nNDM4MjJmLWMyOTgtNGYzNC1hYjY3LTI3NTFjYjIyMGY1ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGMyM2U2ZTE2LTZmNDEtNGU1Yy04ZTlkLTQ0YTM2\nYmJmMzU3NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHY4tatQR64WPoKUXUZx\no/cWtNOEgtEb7iey+3ySeT/nmmm0eWUuqiHg4Vv8FxjTfAW4YwJE4UQPW27oJuEh\nDs+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQTEI45LsnFlm6QR1G1owDLW43G1TAfBgNVHSMEGDAWgBRTfm8+w9rMxifxZi+H\n28SUZFJ1kzAKBggqhkjOPQQDAgNHADBEAiBal+wv96rWyRv9RUGV9t+DXclf2Uy+\n0kFGg/7sdggMNgIgDH7aRYp8vPQyThc5bfJsZCLko2FoY1v07zWWvCe6cTc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAVUidKLOICAWzgv39z06R4bFMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDNkZDAyMWQ5LTIxMGMtNDY5Zi1iODQ3LWI2MjI0MmI5ZDdlZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJGMyM2U2ZTE2LTZmNDEtNGU1Yy04ZTlkLTQ0\nYTM2YmJmMzU3NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHY4tatQR64WPoKU\nXUZxo/cWtNOEgtEb7iey+3ySeT/nmmm0eWUuqiHg4Vv8FxjTfAW4YwJE4UQPW27o\nJuEhDs+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQTEI45LsnFlm6QR1G1owDLW43G1TAfBgNVHSMEGDAWgBRZQrNOE2q4+NPd\nXz5Uo5jCGl78JTAKBggqhkjOPQQDAgNJADBGAiEAgHCRgGPFgc5it4qgo5zT3EQd\nq7zuXJp1OQU3cKtBnqsCIQDyFO8/zXtoFO5PYycfj0nspFxclEZiBccUnjOl+c6s\nfw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZLqNbvESw3233uHVBhNSl3HMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDNkZDAyMWQ5LTIxMGMtNDY5Zi1iODQ3LWI2MjI0MmI5ZDdlZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJGI4NDM4MjJmLWMyOTgtNGYzNC1hYjY3LTI3\nNTFjYjIyMGY1ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAbVe43iJOGGGYU/\nJR818/6XW8YADaToJM3R2/v307jfWyTA6gBxAsIuwegh0TKpBvKszu5h5nu5wIsP\nhddhu42jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRTfm8+w9rMxifxZi+H28SUZFJ1kzAfBgNVHSMEGDAWgBRZQrNOE2q4+NPd\nXz5Uo5jCGl78JTAKBggqhkjOPQQDAgNIADBFAiEAtSFriGombvP0s4njqYn4NGFj\ngsh6Oguoysqyo+IiUmsCIH7whnlwggF0ZCnIR35tOrxMPlSjU8KT0cR04TWub+f8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAY40sAtkCUyjkbjyiONiF80ZMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJGEy\nZmYyODQwLWQxNGItNDI5Mi1iZDcwLTZlZmJiZmI4YWJiMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDMyZTYwMGZlLWJmNmYtNDAyYS05YWIyLWM5ZjZj\nOGMzM2ZhNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMqjzYm5sum8Bt0T7INu\njCHylVu/3IKQskzw9pRKDMyVAj7CmI38ZN0BJ7CbvDAnwpi6BOukrHw8CR89He6R\nA7ijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRGY2+IrHFT2mzDMDRRtEPCjttFXDAfBgNVHSMEGDAWgBQY/vtcL+6c0INi9d5/\nB36OSM8n/TAKBggqhkjOPQQDAgNIADBFAiA+Ge2ct/b5nsJ0uhMhGR1nG1RuIvI7\nd4Fgx6j1jWfKlgIhAP/UQL0Oa2CRpWmY+3I+Hvb6jPIyevb/qhkcfjgxDX++\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISARrkoOfhBS5nDJuUz7PkB5B+MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGMx\nZDc3YjM5LTJhZDItNDY2NS1hZDc2LTk3MTU4ZGFjNmJjZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJGEyZmYyODQwLWQxNGItNDI5Mi1iZDcwLTZlZmJi\nZmI4YWJiMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO9MyF2RSiVkoqReSrml\nquckIcWxqHu5KEIJ4xl3M/l/e75djhylL9/EXW5vDTBeZOmx2wcQUi8bClDCa4Ry\nW8ejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQY/vtcL+6c0INi9d5/B36OSM8n/TAfBgNVHSMEGDAWgBQjRY+FJ4+fHjvz4eEY\nTWcr7aFCBTAKBggqhkjOPQQDAgNIADBFAiAwXkTKp1Xv+SajlJYWyvXEWutFQN0G\nY+qFxD8iinuPdwIhAI0XXmi30dwV1iEaz1xcgdIVfmQCRA1hRCimdf4dwlzT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQ7JBFk4qrh+DOeO8jyuEBHSMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGMx\nZDc3YjM5LTJhZDItNDY2NS1hZDc2LTk3MTU4ZGFjNmJjZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDJmYzAxMWMyLWMzN2EtNGY3MS05NDhkLWFjZDRm\nNzYyMDVjYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDDt96aDecJktkY9c1xL\nHGRkqThBwihiUJ12HVMvDH+u2Z2qDruf8CLGhmNN3pRQfslV9VVqICGZSgmeJqTi\nLUijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRLMmIuPVuue8BU5SsKlQn2eBgQFjAfBgNVHSMEGDAWgBQjRY+FJ4+fHjvz4eEY\nTWcr7aFCBTAKBggqhkjOPQQDAgNHADBEAiAo2Loz19/PooRwBEfvBtbNW2NEWU9V\n+AkpD1b82WnQ+AIgWZbF2OiNEe5LvwiBPyFyNSmb4NM9tR418aq9GPz+oPA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbT+1UcZdf4AXHYI1ViiPslhMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJDVj\nMTc0ZmU2LWIzNzUtNDcyNy1iOWQzLWQxOWNkZjE4ZThmODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDMyZTYwMGZlLWJmNmYtNDAyYS05YWIyLWM5ZjZj\nOGMzM2ZhNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMqjzYm5sum8Bt0T7INu\njCHylVu/3IKQskzw9pRKDMyVAj7CmI38ZN0BJ7CbvDAnwpi6BOukrHw8CR89He6R\nA7ijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRGY2+IrHFT2mzDMDRRtEPCjttFXDAfBgNVHSMEGDAWgBQsfIIiBarQ7B4vFlg4\nLK3uLfaM+zAKBggqhkjOPQQDAgNHADBEAiAwHg/Q2aAQymMUjzisWCfWuDZiBBAp\n5EBBSpX3U9jvqAIgGsflfkalSbpo8ehiGZP/yWckpMv7KfchnVbpAguu9Jg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISATzf4gybg7V04KAoVERtEmk1MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyRjMWQ3N2IzOS0y\nYWQyLTQ2NjUtYWQ3Ni05NzE1OGRhYzZiY2QwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQkcaOLjb0coEPeulIiiN3bJZQHGZzQQMraXhJxDE4mhXtviBt+Op6FccKU\n3B4f+oyrFJv+7QqvqPi1/P00KHeao2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUI0WPhSePnx478+HhGE1nK+2hQgUwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhALES\nMI5DUn7iV/68kfpVxq+t3PEzhr1KF0ztJ1947BisAiEAkJ5UYlejpuPpwOc3yn2K\nwDbd4qFyzSZgJJqBwGcR3JM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAaW2bumSUkJwHvxUFTeXYfS2MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyQ1YzE3NGZlNi1i\nMzc1LTQ3MjctYjlkMy1kMTljZGYxOGU4ZjgwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARUQnphDn9afGo6NKUSeAVqycTi/L6BJ93O1kTAW3+Ic/F3+w1WGCsUOocb\nSjEL495Rk1Y+ZO4eeTCv3qG9ECgpo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQULHyCIgWq0OweLxZYOCyt7i32jPswHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAOCg\nIYL54LCPXzYFd0F81+G0nOlxUaBNGilHZuwNziMXAiAuQYZ1v4OuXfRAIpEjs20c\nYdMhtQW/hqslq0sx6xJoEw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAUJUShK+CTgy/4KA+XsgZSOCMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDI4NzM3MTA5LWU5ZmUtNDAzOS1hZGQxLWQzYTNmYmM4MDFmNzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNDE5NTA4YmYtZDY4Mi00ZjMw\nLTg5YzMtMjAxMGQ0MTA5MzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBKBm\n57MB5YZtPkCK9G/GV2xHRPSQ+xSDijWM/xpDxdyLYYxxhlsf1yzbfmF7pYJiHz/5\ncY/fNAxIt7UhkwPUoqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBgrILIld2Qy0Ru/D8MRfBHcg/kkMB8GA1UdIwQYMBaAFHyB\nY/YIh6KG/XWoz2uTtNc0bQq4MAoGCCqGSM49BAMCA0cAMEQCIHcwRkhPlkwcvfsj\nYOKi5HXwJMq94NWl/YFbunYEd4KlAiAPiuNYxjABOgGDVSo1iIZMUx5hu3jIETij\nTG095IyHPg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbHY1I9ehA5xrBp/angJXZFsMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNDE5NTA4YmYtZDY4Mi00ZjMwLTg5YzMtMjAxMGQ0MTA5MzRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkMjg3MzcxMDktZTlmZS00MDM5\nLWFkZDEtZDNhM2ZiYzgwMWY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2jlj\n386nrC3jyaN6c/id45tURPtCDn8rocCtg7VfjpyJc67KJH+hu9RHVyrtlzGGR/cC\nhvWonzpClkHsy5j7AqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFHyBY/YIh6KG/XWoz2uTtNc0bQq4MB8GA1UdIwQYMBaAFBgr\nILIld2Qy0Ru/D8MRfBHcg/kkMAoGCCqGSM49BAMCA0gAMEUCIQDUmn6oiUtJCfu9\n91RXBpW1gmRq8IZBHrmzEefHinso1QIgZoZz+W6ZcTkVE6JOi6DaibWkBpEHZTUK\nxC1ZlzJHIXM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAVb4y8EbZB7Q99zxT2g9tzDMMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGJkMjgwMmU3LTczYzUtNDM0Zi04ZTUzLTA0ZjExYTE4MzFiZjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNDE5NTA4YmYtZDY4Mi00ZjMw\nLTg5YzMtMjAxMGQ0MTA5MzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBKBm\n57MB5YZtPkCK9G/GV2xHRPSQ+xSDijWM/xpDxdyLYYxxhlsf1yzbfmF7pYJiHz/5\ncY/fNAxIt7UhkwPUoqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBgrILIld2Qy0Ru/D8MRfBHcg/kkMB8GA1UdIwQYMBaAFKyE\nkz1j1rYIv8zW1cnI23BqsIyjMAoGCCqGSM49BAMCA0cAMEQCIHub8SZ/s/4G7mF9\ngdATy0zEYDzKa7qdpOY5NNssIKFoAiAL2IxBGfq5uJHXdad8IIKINaB3fhyy2f8M\nEyEbS5D/3w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB8TCCAZigAwIBAgISAbcFeWbHS1b+NErJkIIr9l2gMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNDE5NTA4YmYtZDY4Mi00ZjMwLTg5YzMtMjAxMGQ0MTA5MzRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkYmQyODAyZTctNzNjNS00MzRm\nLThlNTMtMDRmMTFhMTgzMWJmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVdbi\n3q0aR4d9swBFxxAuiOKZxtsFVqc5+c67iq30MlaeQ5XV8nPwiHcyytjJsPQKT2kq\nWCgd0/a5u4hrqoX296NBMD8wDgYDVR0PAQH/BAQDAgIEMAwGA1UdEwEB/wQCMAAw\nHwYDVR0jBBgwFoAUGCsgsiV3ZDLRG78PwxF8EdyD+SQwCgYIKoZIzj0EAwIDRwAw\nRAIgG9ITmH7Yf9rJVEHgArJYSs3VqfiNi/p4FlSzXIE4VgoCIEUIXgAollPBEpM6\nSrrqOoc+AvOLM/VOgTb2R+00VHXh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAcqspUAEaYmzlYEg9EtmgOwvMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDNkZDAyMWQ5LTIxMGMtNDY5Zi1iODQ3LWI2MjI0MmI5ZDdlZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNDE5NTA4YmYtZDY4Mi00ZjMw\nLTg5YzMtMjAxMGQ0MTA5MzRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEBKBm\n57MB5YZtPkCK9G/GV2xHRPSQ+xSDijWM/xpDxdyLYYxxhlsf1yzbfmF7pYJiHz/5\ncY/fNAxIt7UhkwPUoqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBgrILIld2Qy0Ru/D8MRfBHcg/kkMB8GA1UdIwQYMBaAFFlC\ns04Tarj4091fPlSjmMIaXvwlMAoGCCqGSM49BAMCA0gAMEUCIERI+uaiWp3/g2hn\nm5E48w548v+wZPS6/R99ijW8ugHGAiEA+rl41OS9BtDdMVRgJUoIozJHnNwvl89+\nn3hqJzQq7qw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISATPwbwD1jUTCeEeYTo15/pbDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNDE5NTA4YmYtZDY4Mi00ZjMwLTg5YzMtMjAxMGQ0MTA5MzRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkM2RkMDIxZDktMjEwYy00Njlm\nLWI4NDctYjYyMjQyYjlkN2VkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6mhZ\nHPXOeDcjTVj+kBhuzOYwusOuY4kFcuWdtnelNlo9TZstYnwFraNdYBCGIPARhuKQ\nAaIr/8JlIO5On+knIKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFFlCs04Tarj4091fPlSjmMIaXvwlMB8GA1UdIwQYMBaAFBgr\nILIld2Qy0Ru/D8MRfBHcg/kkMAoGCCqGSM49BAMCA0kAMEYCIQCANaT6UhS3ldTi\nyfCBZnvyM15MSyDlLErGKrcDeKy9MAIhAMb60Yonfj8OZO9TuYmDL9VD1khYT8WT\nTS/JXbOVlewg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAZiXhKk2vCq2g5wza6Z1d1K9MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDQx\nOTUwOGJmLWQ2ODItNGYzMC04OWMzLTIwMTBkNDEwOTM0ZjBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABASgZuezAeWGbT5AivRvxldsR0T0kPsUg4o1jP8aQ8Xci2GM\ncYZbH9cs235he6WCYh8/+XGP3zQMSLe1IZMD1KKjYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQYKyCyJXdkMtEbvw/DEXwR3IP5\nJDAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNI\nADBFAiEA8b52URQu8sIfcTkilZ64pFtcDrplRaVv1p0z1YDf2zACICXVfGGRNlis\n9IiqVPi1eoeMHObvDUhJFED0L41hGrkC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcqgAwIBAgISAftT+LcK1/fFvYBv/3zu76a9MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNDE5NTA4YmYtZDY4Mi00ZjMwLTg5YzMtMjAxMGQ0MTA5MzRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBQYKyCyJXdkMtEbvw/DEXwR3IP5JDAKBggqhkjOPQQDAgNJ\nADBGAiEAu/cyVRogLdWcSeSbZjkvQaKjOGzzl31MJT4Ct9KWkqACIQCCjftWprSD\n6J7EbxhomrcoEqnAPlPIza3IBIco1VEJjw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAW+f4gZ9ICr+XOPgw5sKPJ+sMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJGNm\nNjFkZTI1LTg5YzUtNDI5Yy1hOGQyLWU1ZGNhYjgyY2I0ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ2MjEzYmJlNi02Mjg5LTQ4M2UtYWFlMy0yOTM5\nOGM3OTUzMjMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASeW5MpqudTjBoK5dF+\n7+FqpYOcJxKqNEjVy/z6u/hePxylk0v8NJ7HpjOCLGDVuIqzTQJ8xoP5PEpLwVrS\n2YtJo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQ84KK4Q0UWjoJeA3kstWryqjfNCzAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgZ0KoJHiZgXz0ImBn\nIlhc3Vy0yH1iWf7Sx5Av71sP464CIFYQmRVmdgfETMfQ5O6ae4PDJVFRRw0DBjzV\nuwZB31lq\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc74", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `74` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISASZ10OuIKDGmySRn8logLjiNMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDY5\nYTI1MDRkLWY3NmQtNDEwZC04MTY4LWMyNWU0M2NmNjRmYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDY2YzQ2MTM5LTc5ZTItNDZhNS1iZjQ0LWI4OTA0\nZjllNzdiNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHlKqNtnzs9PsV6IMSa9\n4IrdiHvr9dT8NkfKSkLWudDHDD07nqixvZvBpsm47o1kaH7qkGvwMJXZC9Ei8jkn\ndWSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTyn2mXKZHuWjo7ROs9QJw/1g8RTjAfBgNVHSMEGDAWgBSE8XutCEIbB56jfiAw\nB/Ae80N7LDAKBggqhkjOPQQDAgNJADBGAiEA/omqQWQfc/MD8Znca8uFz1H8++TX\n8CEyxDeLKZwJOPYCIQDi7MVJyU1thJQcslBY6uR3WMtpxXodmRiljhOI4koqQQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQMgt+TArpnzLrL1D5iJ3zP6MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDY5\nYTI1MDRkLWY3NmQtNDEwZC04MTY4LWMyNWU0M2NmNjRmYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJGI5YjcxOWZhLTMyZTMtNDdkMC04OTNjLWZkYzYx\nNmYxNGE3ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPVmj3s564xFbkCw0H4T\np686WAGoWYEABDS1UbyDJd61a/Lr6nKnVpsUD/x58gt1C0BSPXTaRvwmrxOuK0XV\n0TSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBScFMxo1F6q9xU9WZC+JMysWgF7KTAfBgNVHSMEGDAWgBSE8XutCEIbB56jfiAw\nB/Ae80N7LDAKBggqhkjOPQQDAgNIADBFAiBgftonfLyf/94gwvwaQN7zoQvzo4ri\npiuomdEiPkucIQIhALH9DPHw+jbsABOB9jCeIWgOfGWy8yLMZNCSVD2B212T\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUbxWJZz5O9UF1Hg0Z+UNbW4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGI5\nYjcxOWZhLTMyZTMtNDdkMC04OTNjLWZkYzYxNmYxNGE3ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDY5YTI1MDRkLWY3NmQtNDEwZC04MTY4LWMyNWU0\nM2NmNjRmYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABL00qpXJ7ekgpguq7fJ6\nTjHzaMpFrTxATYjJV4CYL5XcLygKOUdQIPLpAPQgDQPEoXAKsyFk7cAePv9Vvsm7\nriijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSE8XutCEIbB56jfiAwB/Ae80N7LDAfBgNVHSMEGDAWgBScFMxo1F6q9xU9WZC+\nJMysWgF7KTAKBggqhkjOPQQDAgNIADBFAiAZZoXBkAqiHxi3ZTUd+UXg42YBGIJZ\nKBUG7jn2Q1FLNAIhANHh+KiugfXnRJE1x8bBg4CJtm0fNuX540u6zXvoe/ak\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAU4WbXUaUrDvAlv/Gj0udROLMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDY2\nYzQ2MTM5LTc5ZTItNDZhNS1iZjQ0LWI4OTA0ZjllNzdiNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDk4M2NlNmE1LTUzOTktNGY5NC1hNDljLWE3ZWZj\nNDYyZDYwNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCqhqaoZeCXRQVv3vF/t\nNGuwoXuWszmSh/bf5M7yMtEqDNoz/jSxAia6ATrfWPenu/dELcXf9GyoiztzKvO5\nDr+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRcicdyW09C4ne+x5j50FAOp9gh5TAfBgNVHSMEGDAWgBTyn2mXKZHuWjo7ROs9\nQJw/1g8RTjAKBggqhkjOPQQDAgNJADBGAiEAmQgFTJdOH+enfC8fmf/s/RIn4sxh\nEEcHM2mdllVSDTMCIQDemEmIoMS504l8bDc1ZH72LGx01ln+8xqlI59E7q7ahg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAU0fNdPWYlOcloDaiRYe7JaeMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDk4\nM2NlNmE1LTUzOTktNGY5NC1hNDljLWE3ZWZjNDYyZDYwNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDY2YzQ2MTM5LTc5ZTItNDZhNS1iZjQ0LWI4OTA0\nZjllNzdiNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHlKqNtnzs9PsV6IMSa9\n4IrdiHvr9dT8NkfKSkLWudDHDD07nqixvZvBpsm47o1kaH7qkGvwMJXZC9Ei8jkn\ndWSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTyn2mXKZHuWjo7ROs9QJw/1g8RTjAfBgNVHSMEGDAWgBRcicdyW09C4ne+x5j5\n0FAOp9gh5TAKBggqhkjOPQQDAgNIADBFAiEA9SnkzdcVVPayDZkV8RN2C9TqUjSL\nyE9EI4z9+jNudc4CIGX2obj32zw5V6FtpLksuWs2qzvnL4caAYcz7hCxOE0i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfsXAe5jCtSXAT5IKYROft89MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGI5\nYjcxOWZhLTMyZTMtNDdkMC04OTNjLWZkYzYxNmYxNGE3ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDk4M2NlNmE1LTUzOTktNGY5NC1hNDljLWE3ZWZj\nNDYyZDYwNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCqhqaoZeCXRQVv3vF/t\nNGuwoXuWszmSh/bf5M7yMtEqDNoz/jSxAia6ATrfWPenu/dELcXf9GyoiztzKvO5\nDr+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRcicdyW09C4ne+x5j50FAOp9gh5TAfBgNVHSMEGDAWgBScFMxo1F6q9xU9WZC+\nJMysWgF7KTAKBggqhkjOPQQDAgNIADBFAiEA+smigOOK+kmDjKUPElr8MxpLhQkW\n5EFVUlSt2v3LYg8CIBdJ4HlNfxzbUyrgMjdxwGsxfJo5uKgpouPmf8Z7QfEo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAeQKwXcAZVvRj8DVETnlxtduMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDJiYmJhZWZlLWY0ODEtNGI1NS1hYjJhLTQ4Y2ZkYTRhNTJjYzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDY5YTI1MDRkLWY3NmQtNDEwZC04MTY4LWMy\nNWU0M2NmNjRmYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABL00qpXJ7ekgpguq\n7fJ6TjHzaMpFrTxATYjJV4CYL5XcLygKOUdQIPLpAPQgDQPEoXAKsyFk7cAePv9V\nvsm7riijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSE8XutCEIbB56jfiAwB/Ae80N7LDAfBgNVHSMEGDAWgBQDYqrlXE/tTLX7\nhPTFhkr8+orF3DAKBggqhkjOPQQDAgNJADBGAiEA2AuFi8W2H8JY61LyMZKjhm87\npbBis4dLZL7/J3BryDkCIQCQiHQ5S23i/UQRYBH/1kFe0ltrP0579D0/1c+zV1QT\n9Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAa/5FJ690NlahWBYiN8akIhSMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDJiYmJhZWZlLWY0ODEtNGI1NS1hYjJhLTQ4Y2ZkYTRhNTJjYzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJGI5YjcxOWZhLTMyZTMtNDdkMC04OTNjLWZk\nYzYxNmYxNGE3ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPVmj3s564xFbkCw\n0H4Tp686WAGoWYEABDS1UbyDJd61a/Lr6nKnVpsUD/x58gt1C0BSPXTaRvwmrxOu\nK0XV0TSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBScFMxo1F6q9xU9WZC+JMysWgF7KTAfBgNVHSMEGDAWgBQDYqrlXE/tTLX7\nhPTFhkr8+orF3DAKBggqhkjOPQQDAgNJADBGAiEAv5ceZMXCYsq4ZQ6dmuKZrd91\nQYJHU4Dj8rywMSeL+o0CIQClrdhCNKriYj9kF/2Wtjz6al1ianh6kY/AvI76phqz\nBA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaTMGpw5uQJSQhrAMVmLF4YnMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDA4\nMmY0Mjg1LTM1ZGEtNDg3ZS1iYmJlLTgyZWIzMzE1ZWI1MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDM5MmVkMTYyLTAwMGMtNGRjOS1iZGQwLTdlYjc5\nZjM4OWUyYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJZQ7bMv3kIY2kOsYtSx\nI4T2tOdjO/FhYXDp50anuR7UkI2hkIUop4JM8SeGltFQZTY8WdAY3WoLBJQDiKBF\nJMmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTs+Gd5R9cCuyudn3jFZQbjP7MtrDAfBgNVHSMEGDAWgBQSftl+b8S0FsnLmr+o\n1OlhdnXIfDAKBggqhkjOPQQDAgNIADBFAiEAlEoE3XQZB/iCTVfKHqI0wwaOHTIR\nsSZXwowmyP8JDeMCIEruennTZqwlBJTenQvoDVKbe1nPHo4KFJT9RTvUWrAA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYmZ/tEd3ebPbz7CUf2RRrkaMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGQ3\nNDNmZTA2LWFkYTctNDAzNC1hM2VjLTkzOTUwYzVmYWFiYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDg4Y2I3MjRlLWM1YWItNDRjNy05ZGQyLTc2MjY1\nMjE3ZDY3NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNAj1kttXefA42kRRdf+\n/pvhrs2/O0SYeZlVDDAyfGvCn4lnWAoAtaefOKIVZC8k0qhMINnR5uLLjIXs8QPs\nr9mjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSa6f2qO8JmUxy4c1Q0oXUHVGPULDAfBgNVHSMEGDAWgBSuGqfwiehNnJi34S0Z\niAatTaE2ozAKBggqhkjOPQQDAgNIADBFAiBlaxmdIxebXOEt0wFYiSy3OP3YZgGz\njzl3sb2D/Pl9TQIhAIdP0iOWURUH1a2NgH8NWiVn5m2sX8jJN9McPgRnKWeV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAT75hdbK4PkZQDPgDomHOV6iMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJGQ3\nNDNmZTA2LWFkYTctNDAzNC1hM2VjLTkzOTUwYzVmYWFiYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJDI3NWU3MDA1LTg0MTMtNGMwOC1iMGQ1LTM1NGY2\nMjRhMzk2ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLZtrzdSNOxeM6nf8LY9\nZvBxygL+BcvbXdDfQD9QYg9dDxChOT3tpR9wYizlIx7YUhxpTo7+0YPZnKf24sCg\nUq2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS4NiJ95udS1oopotO0JsBI6JN+XTAfBgNVHSMEGDAWgBSuGqfwiehNnJi34S0Z\niAatTaE2ozAKBggqhkjOPQQDAgNIADBFAiBBRPkxzr6xhTM1P0Vd75r1f7gMuKXe\nUDwelpQBQl7LBQIhAL4nCLnLYm3cejUyU6wM10YdrleimD8wPyhNgk7nMHG8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAdgBiF25NmonfmMsQreK5vq8MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDY1ZGY4ZmQxLTA5MmYtNDQ5MS05YzI3LTRlNGY2OGY4MjQ3YzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDA4MmY0Mjg1LTM1ZGEtNDg3ZS1iYmJlLTgy\nZWIzMzE1ZWI1MTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDi2NK8FrOacnsEh\nxFp2hi7JI7EB5ez37fD2v604f1sf+OUndHKIOjREo3FVS6q69oxdaU4y+OunBUCv\nRk7654ujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQSftl+b8S0FsnLmr+o1OlhdnXIfDAfBgNVHSMEGDAWgBRMrodk3pQ398ZA\nbw/4l/NebuRIEzAKBggqhkjOPQQDAgNIADBFAiEA0IZKpdazZSDidyQy5jM6YnoN\nmrOHpl6eKlPCOo4lu+MCIF13Wn6+sG75BKy18tF76isTVxK3h8guMaRmKM5zpIcN\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAYy/xvza8oDRydGFPan4Hl9fMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDY1ZGY4ZmQxLTA5MmYtNDQ5MS05YzI3LTRlNGY2OGY4MjQ3YzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJGQ3NDNmZTA2LWFkYTctNDAzNC1hM2VjLTkz\nOTUwYzVmYWFiYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDVnmKOOMRKi9dLR\no4WNpsoT5GhG5F8sVstgfSXPwcWF64Fk5d0jM2NXX0jslvMw5af0xbyn78uQWsUT\n6ggPlb2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSuGqfwiehNnJi34S0ZiAatTaE2ozAfBgNVHSMEGDAWgBRMrodk3pQ398ZA\nbw/4l/NebuRIEzAKBggqhkjOPQQDAgNHADBEAiBAwv78/oia8/I/t06cSmbtv/Rw\nCvVaTUMsFBt24LiNrwIgRNTa+FxdDdhj0DBKVkXOu9o7k4cmABABj8JetOPycNg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWbBAafdVXAS3jkYyFYZGHH7MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDUy\nNzNmNzE0LTAyZGEtNDIzMS05NDI4LTNjNWYxODUzNmM1NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGQ1ZjliZjM0LWFhMjMtNDA5Ny1iZjZhLTk5NjQ5\nNjdmMzI4MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIdQ6cjrex29VbufDfED\nLUk3zSj4nfBGSPbCwlxjhMxdrBVuSgrHLXSouyyDeCd45ba0ccIv6c3NmY1GfAl9\nruCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRMPrRdaB+Z3DSwiC32KUVFC1dSljAfBgNVHSMEGDAWgBQEp1azBPU8jVtS9zNu\n10QrpzCyyjAKBggqhkjOPQQDAgNIADBFAiBxjPgqgkx2RkEYWmVYXOVwZTbOecSc\nceVqZuL+ji8OfwIhALp2/8Fq2wNhfS0ofqrGHIVYidAPGOSn/JNBPqYwfx4s\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQNdVP5RGwwtceLm6Im8YdH8MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDUy\nNzNmNzE0LTAyZGEtNDIzMS05NDI4LTNjNWYxODUzNmM1NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDE1ZWE1MzhhLTk1ZGQtNDg4Ni1iZGE0LTg3Yzhi\nNjRiZjU5YzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNb7RYsCHJxttygXEye9\nID1jOY+C1BlzuEL4aMgPMsrVvYF7gdRpIAsb38ipGlch2+PZ1mEG8h1ONxaf8c5B\nMdWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS8eVMhihQNg1ilgvvbcz/Dib15xDAfBgNVHSMEGDAWgBQEp1azBPU8jVtS9zNu\n10QrpzCyyjAKBggqhkjOPQQDAgNHADBEAiAvfGu6zMkSd1FV+zHnwPo3HBNcz6SV\n+Tuu7w9qK0NEkwIgHJzVH1SQRWp/bTHAYIQ9/KrM0aC8mtZGrmPrkme7VmI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVEXqoJuPRqhs4i0tytJfd4DMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDI4\nMWYyNDU1LTRjMjUtNDEwMC05ODk5LWEwZmExZmE4ODljYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDUyNzNmNzE0LTAyZGEtNDIzMS05NDI4LTNjNWYx\nODUzNmM1NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDqqUOAN9HhuUJ0K0sx5\n97veySnWgQFgf0oZZHsM7bRhQX5TRlyH+5H9U8dg2Cjg1sQ9Je5KaRO5TMmXCu2O\nBwyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQEp1azBPU8jVtS9zNu10QrpzCyyjAfBgNVHSMEGDAWgBRLNV/oCe/I69it9CB3\nt7P89yS7wTAKBggqhkjOPQQDAgNIADBFAiBydtX05fXe+Dy4ExZVY6/8uCPRXpAx\nsrB64FuK6Q2H4gIhAMW83w3Sqz4i+a6thdmjGiyZzrVICPW3Vard/JdnCAjh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcvMnUZJm+lIgmOc3LaSeRVOMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDlj\nZjJjOWI5LTczZjQtNDRhNi05NDFhLTAxODgxOGUyMDg4ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDUyNzNmNzE0LTAyZGEtNDIzMS05NDI4LTNjNWYx\nODUzNmM1NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDqqUOAN9HhuUJ0K0sx5\n97veySnWgQFgf0oZZHsM7bRhQX5TRlyH+5H9U8dg2Cjg1sQ9Je5KaRO5TMmXCu2O\nBwyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQEp1azBPU8jVtS9zNu10QrpzCyyjAfBgNVHSMEGDAWgBT3LaeG45G7lfKGHYc+\nrluMzivxvTAKBggqhkjOPQQDAgNIADBFAiBJOtc9RaErq04my7PwSjxOvR23nYBj\n0VWMo4ugorhuMAIhAOOQQd51zFgwsa2sKF1X4bpQwlfm0AorLkgyvGo+D22W\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAdmZSkLv+RFKoSUvJwcyFPIdMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDI4\nMWYyNDU1LTRjMjUtNDEwMC05ODk5LWEwZmExZmE4ODljYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDljZjJjOWI5LTczZjQtNDRhNi05NDFhLTAxODgx\nOGUyMDg4ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNjf3yJHUXElwyz9V+ji\nOduhjef8k/nuVKtt//eQkEW1jxxW8jSGZ2xYbswnEXqnrBAM/GmJUqZ+xB9L8ADh\nf1GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT3LaeG45G7lfKGHYc+rluMzivxvTAfBgNVHSMEGDAWgBRLNV/oCe/I69it9CB3\nt7P89yS7wTAKBggqhkjOPQQDAgNJADBGAiEAtlEUk4Uu+VCsMvJ3+QO9uXIBBX8+\nBGg6EU4ZOXRe0/ICIQDAV3MKgTiNunMxzdgbanD1MZKu4GMA1wWHRrv3ZHW7xw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXFVbGC3Ifwo/dGUQ2caslmRMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDlj\nZjJjOWI5LTczZjQtNDRhNi05NDFhLTAxODgxOGUyMDg4ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDI4MWYyNDU1LTRjMjUtNDEwMC05ODk5LWEwZmEx\nZmE4ODljYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG6he7wEpxw7pCG9eh6D\nKxyQuovNv2ZcdvUhaaWkpo3WbBH5jzypmczrcEkLn1dinrvidhtpgr1cbifagv7P\nuB6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRLNV/oCe/I69it9CB3t7P89yS7wTAfBgNVHSMEGDAWgBT3LaeG45G7lfKGHYc+\nrluMzivxvTAKBggqhkjOPQQDAgNIADBFAiBTQUevQr+CW77y3OCEXiaPQEg/0Msa\niWNWoXQhfGppxgIhAM50eBJkK9KkaE6tu3atvnDWorp+/zvQLCu792LejN3L\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAbRcOQSwXfs/aK8EZlrQj1wSMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGVjNmU2OGY2LTBhZjgtNDMwYy04Mjk3LTY2OTkwMGY1MmRjOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDI4MWYyNDU1LTRjMjUtNDEwMC05ODk5LWEw\nZmExZmE4ODljYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG6he7wEpxw7pCG9\neh6DKxyQuovNv2ZcdvUhaaWkpo3WbBH5jzypmczrcEkLn1dinrvidhtpgr1cbifa\ngv7PuB6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRLNV/oCe/I69it9CB3t7P89yS7wTAfBgNVHSMEGDAWgBR60B+3bVs3cnMz\nAZdL/oWABRBoCDAKBggqhkjOPQQDAgNIADBFAiEAn7/mf0p4pXuUNkB00ndMF6rR\n3G2/RWv+EqKRf1KsK48CIEA1RrQyJI9MLTFY2v6qh92vkvehxZ+CDLyJ+VJTXTYX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAZEZrKqjJ+SUG4bF0toDBgqZMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGVjNmU2OGY2LTBhZjgtNDMwYy04Mjk3LTY2OTkwMGY1MmRjOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDljZjJjOWI5LTczZjQtNDRhNi05NDFhLTAx\nODgxOGUyMDg4ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNjf3yJHUXElwyz9\nV+jiOduhjef8k/nuVKtt//eQkEW1jxxW8jSGZ2xYbswnEXqnrBAM/GmJUqZ+xB9L\n8ADhf1GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBT3LaeG45G7lfKGHYc+rluMzivxvTAfBgNVHSMEGDAWgBR60B+3bVs3cnMz\nAZdL/oWABRBoCDAKBggqhkjOPQQDAgNHADBEAiBrzmtTiFEdtHD5EfO7CcQejoiK\n6Rhw39ExTR0BMeCPGwIgHchCAwCJRQIxXvdu/AWHr78t3mi+OXoKZFo2eQAqCVs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbv7Svlzg+KFO+QDWFRe+OV/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJGJl\nZGNlZTNjLWM5MWMtNGVkMi1iOGNjLTE0NzllNTBhM2FhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDhjYjgxYjI5LTQwOTMtNGE3ZC1hMzNlLTIwYmJk\nNGI5ZmU2ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK867zsZRt3Rmp7MSZzM\nUnHPlpduC8LbBjGC8FK03230NfiCa47ZKWDDzuOONuuidf0skMVw04EoMKQmYfgr\nnxSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTovWLwpGoTEFPLTWV+szzcW7yjczAfBgNVHSMEGDAWgBQhOCLaWsKHHA3XZayW\npG0QAAV9NDAKBggqhkjOPQQDAgNIADBFAiBPguTa+avkxfTOhwAeXhVjJvf8w2k+\n96b3dY6XghsTnQIhAOnZwpIF8ADZyZ7S/2Lrd8gYu4fkFN/wYyidBQpLcxqK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAV3GElDO3w3MovxNMdgU+ZClMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDA0\nMzYxZWE1LWQ3ZGYtNGMxOC04NDI1LWY5ODU4MzQ4YTAyNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJGJlZGNlZTNjLWM5MWMtNGVkMi1iOGNjLTE0Nzll\nNTBhM2FhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPlK8y96Rh3MuQ+uM0u6\nKfPmZiKw4K3SHRwp4Jc2PMjgMX5Dqs/laRdhWOeNSH5+OVDg4pD3nvdjyZQILPI+\nTB2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQhOCLaWsKHHA3XZayWpG0QAAV9NDAfBgNVHSMEGDAWgBTrocSYRmOtNf/nnWx5\nrgySfYNy+jAKBggqhkjOPQQDAgNIADBFAiEAxNRh4giexT1Czb0IBGP6n/ceQuz9\nC875TWYhZK6mcKgCIDYnu/xE6g3cFzSMooyfliKAjwD3Yu4RfE+5qJCSvVKM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAa7GoNIDDmbKJcScxUPBnPoWMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDA0\nMzYxZWE1LWQ3ZGYtNGMxOC04NDI1LWY5ODU4MzQ4YTAyNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJGJhZTc1NDY3LWQzMzctNGYzYy1hNTQwLTNmODE1\nYTM3YTU0ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJ52Y35H5ZNzKMHwVDXz\n4DxwIgw5L/zqYPeg7h5vpxCBRIwulI7OsXzRUG++RHl5fCPRLCQehQrSfQrvTCpZ\nXzajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRD0Vv9DeTg5klsJffio3yZ/hXAyDAfBgNVHSMEGDAWgBTrocSYRmOtNf/nnWx5\nrgySfYNy+jAKBggqhkjOPQQDAgNHADBEAh8IRqZKoaHX1cLs2NxwvUjDsOb3RfSj\n838WSor5TuetAiEAh7GMIIpvS6RtCCJqrgrV243fwiR0VeN7YB3esQ2J0yQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdexsourVZDbO05CCroXc+wNMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGI2\nOWJmYzBkLWZkYWYtNDc3YS05MmRkLTJlMDA5YWQwODA2MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDhjYjgxYjI5LTQwOTMtNGE3ZC1hMzNlLTIwYmJk\nNGI5ZmU2ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABK867zsZRt3Rmp7MSZzM\nUnHPlpduC8LbBjGC8FK03230NfiCa47ZKWDDzuOONuuidf0skMVw04EoMKQmYfgr\nnxSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTovWLwpGoTEFPLTWV+szzcW7yjczAfBgNVHSMEGDAWgBSie4XyMynx4eWzoI8F\nLuLXza9icTAKBggqhkjOPQQDAgNIADBFAiEAlPEe9YkO57ZalGrWl0KxUkgCulzD\n05hRj+k/cN1RJU8CICQWPrlFRiDfKAwkYiy4ZqTl+F2XNEkzb5pXGjqb9zNX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISARcON6dseypzTkc8jFeTkWcJMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQwNDM2MWVhNS1k\nN2RmLTRjMTgtODQyNS1mOTg1ODM0OGEwMjcwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARgmYm92e/0gGsRVTBT+NgrGAd+FsibQuXga7AzYjMWk2ZJ1oYUwk6AOipy\ngbVmPIpVnATb0QEYcZ8dcNkB9GGwo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU66HEmEZjrTX/551sea4Mkn2DcvowHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgAQET\nzQXqnsVjapTbezLE4A7C+3lQEebyoh9Cg6nSvYoCIQDSuuEJG7o1sESHK+KDjXqX\n8hhVS/YOpL86YWVwXwtGlg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISAczALMj+xPNZaS894qkmq36iMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRiNjliZmMwZC1m\nZGFmLTQ3N2EtOTJkZC0yZTAwOWFkMDgwNjEwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAASSWNLo3vNnqwea6WC0+ai+QDkAIycGO+PgCvyVW00o7BMixm+Wo3x2pkw0\ng5S2WlC+syDLkjEoDJlV3vHOW4DSo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUonuF8jMp8eHls6CPBS7i182vYnEwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgd64M\nSv/ATgHE415wZ9AktBKr+LPZgvY4YWAsltv0RrYCIAgovdk10shtI7I8e85S7OJK\n4bS2viJ2426ThPk6NoIu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAXw09cgqO6hPoksQ6aCRXyHHMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDJiYmJhZWZlLWY0ODEtNGI1NS1hYjJhLTQ4Y2ZkYTRhNTJjYzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNWI5M2FkZGMtOTdlMS00MDkx\nLTg2NjktMzliODYwNGM2YjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPLjJ\n/jaoHYbNxBMSsj9abmqoTd8wDntHGIYRQsUQYC/mKtj0i9GVK1E3G9S96hPvkq3R\nQxu1x7GOfZb1ZLeUk6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBGV448nYSbDWpCCRvFp0asSSYicMB8GA1UdIwQYMBaAFANi\nquVcT+1MtfuE9MWGSvz6isXcMAoGCCqGSM49BAMCA0cAMEQCICUObjb1PS9uIO11\nP89fHintPHquUO9Q33sDLJMkcy+rAiAW9uHC3CLntDsg1xK0cCm02xy5CiiPjAJi\nZO3xijcfpA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISARW0Ima19tjdrc8nxD47HPfpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNWI5M2FkZGMtOTdlMS00MDkxLTg2NjktMzliODYwNGM2YjM2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkMmJiYmFlZmUtZjQ4MS00YjU1\nLWFiMmEtNDhjZmRhNGE1MmNjMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1pTz\ngswitcacKQDI5rjZpPLY8niuj7ZZY99cBvm6DkK7uoTS7SDXIBT70FMPWoolbVHm\n+bdNYVW6iFRciA2UFqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFANiquVcT+1MtfuE9MWGSvz6isXcMB8GA1UdIwQYMBaAFBGV\n448nYSbDWpCCRvFp0asSSYicMAoGCCqGSM49BAMCA0gAMEUCIBzgTYk7r96+G67J\nSNsfXIlYabenynj+Sdl8e7kpWC2zAiEAw3DNe0zwigcz+G4PX1U2xfj9aYxFMnjF\nIXz39ZHVjac=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAbbVan0t91ysUAIAiMYL/025MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDY1ZGY4ZmQxLTA5MmYtNDQ5MS05YzI3LTRlNGY2OGY4MjQ3YzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNWI5M2FkZGMtOTdlMS00MDkx\nLTg2NjktMzliODYwNGM2YjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPLjJ\n/jaoHYbNxBMSsj9abmqoTd8wDntHGIYRQsUQYC/mKtj0i9GVK1E3G9S96hPvkq3R\nQxu1x7GOfZb1ZLeUk6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBGV448nYSbDWpCCRvFp0asSSYicMB8GA1UdIwQYMBaAFEyu\nh2TelDf3xkBvD/iX815u5EgTMAoGCCqGSM49BAMCA0cAMEQCIAfsvkarJ9cEwjmZ\nqthfwzEAPMhX7goFNO8x6ROVavlaAiBgLAtCdC2LETmQq6bJ0Wv0sau6Q0OB6OHh\n072SVLu3aA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAaU4FyKojNYIIB7+SxT4XIuQMAkGByqGSM49BAEwWzEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTESMBAGA1UEAxMJQnJpZGdlIENBMS0wKwYD\nVQQFEyQ1YjkzYWRkYy05N2UxLTQwOTEtODY2OS0zOWI4NjA0YzZiMzYwHhcNMjYw\nMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBWMRYwFAYDVQQKEw1iZXR0ZXJ0bHMu\nY29tMQ0wCwYDVQQDEwRUQSBYMS0wKwYDVQQFEyQ2NWRmOGZkMS0wOTJmLTQ0OTEt\nOWMyNy00ZTRmNjhmODI0N2MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATtvs6X\nY+O9xypsA0kEdgH2jTpZY6noyWzmigiL7qsuc3QcwZbYkIsO8d4fblevDY0zp4gW\nemB8MdPtDnuSV1kRo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0TAQH/BAUwAwEB\n/zAdBgNVHQ4EFgQUTK6HZN6UN/fGQG8P+JfzXm7kSBMwHwYDVR0jBBgwFoAUEZXj\njydhJsNakIJG8WnRqxJJiJwwCQYHKoZIzj0EAQNIADBFAiEAjus5VdAdpBr0Juw9\nHidPuUlBndqj7UfX9TW9oIMvED0CIDuRbUpIe+3nUFilhfRQZIt3a6lJdEnAd2bC\nvtCO6qIG\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAUfxcntSBxC+kWtSSmfC2UjIMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGVjNmU2OGY2LTBhZjgtNDMwYy04Mjk3LTY2OTkwMGY1MmRjOTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNWI5M2FkZGMtOTdlMS00MDkx\nLTg2NjktMzliODYwNGM2YjM2MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEPLjJ\n/jaoHYbNxBMSsj9abmqoTd8wDntHGIYRQsUQYC/mKtj0i9GVK1E3G9S96hPvkq3R\nQxu1x7GOfZb1ZLeUk6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFBGV448nYSbDWpCCRvFp0asSSYicMB8GA1UdIwQYMBaAFHrQ\nH7dtWzdyczMBl0v+hYAFEGgIMAoGCCqGSM49BAMCA0cAMEQCIF8tA11hlYlPOxAb\nxDHQCkZGVfJin0THADKSd21oqxSLAiBMnBOKK6/uDvl6y+H+hS54BDX1LNdJYQhG\nuLKMKuhO/Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAX7sc2KrsS07VR/mZ9lNQL/EMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNWI5M2FkZGMtOTdlMS00MDkxLTg2NjktMzliODYwNGM2YjM2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkZWM2ZTY4ZjYtMGFmOC00MzBj\nLTgyOTctNjY5OTAwZjUyZGM5MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2Ifh\nb1p3nY3v4WnJQt82A9kyxf4hW/iAj09F0TcWK0OD5UjXgC6yfwJJKdGiWw8apYq5\nld9nfOHvZeT/Ii5kVqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFHrQH7dtWzdyczMBl0v+hYAFEGgIMB8GA1UdIwQYMBaAFBGV\n448nYSbDWpCCRvFp0asSSYicMAoGCCqGSM49BAMCA0gAMEUCIG+NeubMXNWn6+Da\nicSjMejvEFGkKlEgGdL4qOXQw/h0AiEAyP7/0LAiCrb1cOBKa9E1gB+w2ky+u3W+\n4rz9VmwZOLU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISARMYjMAfsnoFk7sqnTfgujCWMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDVi\nOTNhZGRjLTk3ZTEtNDA5MS04NjY5LTM5Yjg2MDRjNmIzNjBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABDy4yf42qB2GzcQTErI/Wm5qqE3fMA57RxiGEULFEGAv5irY\n9IvRlStRNxvUveoT75Kt0UMbtcexjn2W9WS3lJOjYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQRleOPJ2Emw1qQgkbxadGrEkmI\nnDAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNI\nADBFAiEA1JkixbG2lQf/UTgUtHD6nbX59RnTTdMRtZ7Owj0PE14CIFwmIiknB96P\nLHB9sfd545mPdcaM5WM9efJHgZIRicYB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAbqagSQ6JEW+ZgWGG3kfdLv8MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNWI5M2FkZGMtOTdlMS00MDkxLTg2NjktMzliODYwNGM2YjM2MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBQRleOPJ2Emw1qQgkbxadGrEkmInDAKBggqhkjOPQQDAgNI\nADBFAiEAifHYyEbbN/FxCe5dBnM8lqOFurDNA38TZBV6KqQlOJECIHk7ug9p3kKp\nRgwRvPl12oj9MdOHXzJJnx3614iNygw+\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAcbE2GqqhLc4Ew5+BtAc17m4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDg4\nY2I3MjRlLWM1YWItNDRjNy05ZGQyLTc2MjY1MjE3ZDY3NTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ3NGVhYzAxYi03MThhLTRiN2EtYjQ2OC1mNmI4\nMmU2NmQwM2YwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS8blUOcV5RWwYUd1xB\nNnQAJrVOIWpUhCxrPuLFNzNup/0CAf8DOW7M0AzcyA8srCX3q37N6J0iu+7VM2NH\nESjRo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBSa6f2qO8JmUxy4c1Q0oXUHVGPULDAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgNENniHb3ch43Vbky\nv3GyZMIZCTlmxKApswVilJy3ikoCIALehCRWBhg5z0SUv2hX/WteVAq4WkzbZcQG\nInkvTUVU\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc75", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `75` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATxSuVU9/mVGTpoFDoN0TPEdMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDkx\nOGIxOGM5LTQxMTAtNDMyYy1iZjY4LTk2ZTBiNmFiYzMwNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGYwMjA0NDUxLWQyNjAtNDliYy1hOTI2LWZiOWI2\nMWI2MGNkYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHGhBvj9Pmi94FfQb4Vm\n25G+fMzpYfCs79wh9QAgNPbrUA3X6GasH0xva8M6PfKBNs58TG2XzQKfTw+wfMKZ\ny9GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTnGg6Eau3+R3C9vyHPHI/1t9IhJTAfBgNVHSMEGDAWgBSmLKEkXCxBMUelZnGY\n0YV3EnbmPDAKBggqhkjOPQQDAgNIADBFAiBN2b/O+SQRjg64tm70zkV4qammmqjq\n3INeXfS1MbsDtAIhALLYx7D6MSl/0vwaKUDWAFjwEp3hW1fkfzByZjRBfo+N\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUpk9dBCuolxZA7XDx63SAjxMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDkx\nOGIxOGM5LTQxMTAtNDMyYy1iZjY4LTk2ZTBiNmFiYzMwNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJGU5MDk2MzU4LWJmY2MtNGI3ZC05YjkzLTQ1Nzdi\nMjE0Yzc2NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEwo7J7/NEHVcvQhmxRk\nVp19dsXL7wGJKO+pqXume9rumqgkDAiSwMRpInbS6xGWsdPWJmcHmWqb7mbS6Mc4\ntsKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSn/9P7mHPyUP0EAkIyhlAqFMtCwTAfBgNVHSMEGDAWgBSmLKEkXCxBMUelZnGY\n0YV3EnbmPDAKBggqhkjOPQQDAgNJADBGAiEA4s5SKUJ/DpH9UKlgnMTtgaB9g2pe\nj1ViNVs9bkFNA4gCIQDReEXdz0O7gikYhIatkGKTCGna7G4rndYtGISdPuPDjQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAeYPNuwSEdU7/RRPKZiefwdQMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGU5\nMDk2MzU4LWJmY2MtNGI3ZC05YjkzLTQ1NzdiMjE0Yzc2NTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDkxOGIxOGM5LTQxMTAtNDMyYy1iZjY4LTk2ZTBi\nNmFiYzMwNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPuqJ86UIhUUM7iU6v1S\nwNBlbNGCE9uN5oLCu9hJlMmyMlhuiQTtTcudjUdkPmxvs/PB3bEkJcAYrMuDnXuE\nZ5ajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSmLKEkXCxBMUelZnGY0YV3EnbmPDAfBgNVHSMEGDAWgBSn/9P7mHPyUP0EAkIy\nhlAqFMtCwTAKBggqhkjOPQQDAgNIADBFAiEA3xL4PU/mXPyzRBL9C5x/dM4ca1f8\nBpFMwt0JFQQWIo8CIG/+o0c9frqpGdGuWkkw5NMZbGihuPhsXQufZbJNQVUD\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfUTXdDvAyigQ88lJTtTS2QjMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJGYw\nMjA0NDUxLWQyNjAtNDliYy1hOTI2LWZiOWI2MWI2MGNkYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJGExMzczY2E3LWNmNjctNDdhNC1iOTRjLWYwZDUz\nNjAzN2ZhZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKD/GhNqS6tLFSNghxMf\nraZU/GbyViwCkxx40o41K/PnMvggvW0gNg/NRHZ+MQ5x3rpjOFcqF2OMRKlMpN3n\nA5ejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSjzL3I4eGDRQm62lcqpcBG18v4bDAfBgNVHSMEGDAWgBTnGg6Eau3+R3C9vyHP\nHI/1t9IhJTAKBggqhkjOPQQDAgNJADBGAiEAlvbiwe4sgUN0H+qbUuwA1AdQlJcg\nKd2wcdtzb5419mkCIQDhtvPGY5HBkLxMCNK0y3KZK640gLX2D8LMWsClqEh5gw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAX0YXhCHgbRbXCsX8jpEI/luMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJGEx\nMzczY2E3LWNmNjctNDdhNC1iOTRjLWYwZDUzNjAzN2ZhZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGYwMjA0NDUxLWQyNjAtNDliYy1hOTI2LWZiOWI2\nMWI2MGNkYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHGhBvj9Pmi94FfQb4Vm\n25G+fMzpYfCs79wh9QAgNPbrUA3X6GasH0xva8M6PfKBNs58TG2XzQKfTw+wfMKZ\ny9GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTnGg6Eau3+R3C9vyHPHI/1t9IhJTAfBgNVHSMEGDAWgBSjzL3I4eGDRQm62lcq\npcBG18v4bDAKBggqhkjOPQQDAgNIADBFAiBG3fv3jKP5dxjLe9JE64cZBB858z0g\nat9xZ65+/JA0YgIhAOwI8lCLUk381I+/gZx0vldECB8JMo4/LmH0qqGPN4Ll\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAeeBEx1Q9yGTe/qaA7DqKQ+vMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGU5\nMDk2MzU4LWJmY2MtNGI3ZC05YjkzLTQ1NzdiMjE0Yzc2NTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJGExMzczY2E3LWNmNjctNDdhNC1iOTRjLWYwZDUz\nNjAzN2ZhZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKD/GhNqS6tLFSNghxMf\nraZU/GbyViwCkxx40o41K/PnMvggvW0gNg/NRHZ+MQ5x3rpjOFcqF2OMRKlMpN3n\nA5ejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSjzL3I4eGDRQm62lcqpcBG18v4bDAfBgNVHSMEGDAWgBSn/9P7mHPyUP0EAkIy\nhlAqFMtCwTAKBggqhkjOPQQDAgNJADBGAiEAoer1TQN6eD7HYpFGqYylMaQqUpoJ\nLiR6qdPnO3qSZM4CIQD5zXTXHsKYtSaO2AUDJTsryWXNr/MF9GEHmDLicEL+og==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAR6FAi1s7JvyQteTqMMtv1yiMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDg0M2I3NmQ1LTdkMTAtNDA5Ny1iNGU0LTAwZjNhNmU1MGNmZjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDkxOGIxOGM5LTQxMTAtNDMyYy1iZjY4LTk2\nZTBiNmFiYzMwNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPuqJ86UIhUUM7iU\n6v1SwNBlbNGCE9uN5oLCu9hJlMmyMlhuiQTtTcudjUdkPmxvs/PB3bEkJcAYrMuD\nnXuEZ5ajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSmLKEkXCxBMUelZnGY0YV3EnbmPDAfBgNVHSMEGDAWgBRW6m+M/AZXbqEX\ne5rkgCj6JxmykDAKBggqhkjOPQQDAgNJADBGAiEAnNRw2lwEa5hHmqKz4QxFs1vP\nYcYeWJvoPl49cqa1tjgCIQC7piDdiFOXUUZWfaxTUn6XzvN1Qv9hBOd8mchDLvO6\nVA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAUVVK/b8wSiZGnQWDbi+mO4IMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDg0M2I3NmQ1LTdkMTAtNDA5Ny1iNGU0LTAwZjNhNmU1MGNmZjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJGU5MDk2MzU4LWJmY2MtNGI3ZC05YjkzLTQ1\nNzdiMjE0Yzc2NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEwo7J7/NEHVcvQh\nmxRkVp19dsXL7wGJKO+pqXume9rumqgkDAiSwMRpInbS6xGWsdPWJmcHmWqb7mbS\n6Mc4tsKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSn/9P7mHPyUP0EAkIyhlAqFMtCwTAfBgNVHSMEGDAWgBRW6m+M/AZXbqEX\ne5rkgCj6JxmykDAKBggqhkjOPQQDAgNIADBFAiEA/zngWoBdFDWTMfEsdgURN3bL\nlFHZy4a/GaJLA86U4dICIFqPtAM/YEI0suZaRIBLsX2vAFkNBV8qwXgiKCoxpFf+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISARjtE5RsZhYFudoRp8+SaLgvMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJGY0\nODRhMmNiLWRjNzAtNDQyNi05OGNiLTE2MDE2NzBmMjNhODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJGM2YjZkYTFmLWI2OTMtNDIzZC04NDA5LTg4YThm\nNmM1MmM2MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIayvbtdKRsV2/eUtMYC\nvZjXZNiyeLaECPOROq1pqoUHe9w6ru0rHD9e5RfQnGOPvAATjBjw5WS6gRY9NwDP\nDl+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRuOqWd2QXD38skGAkhIrZfFRGHjTAfBgNVHSMEGDAWgBS/D6Sy5r1auRmh4t0N\n3CL8iz+4ojAKBggqhkjOPQQDAgNJADBGAiEA2mhrgCal25YOUiraM6R6TQ+GKiIx\nXOs0w2Koo658ZQUCIQDI4sCSuIeeWYBprsKDWMUiluVY9uvxEPlZaMMfsO1ijA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZx34wSQhHcjOfv5gsCiFenWMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDcx\nMDczYTk3LTRhYzQtNGMxZC05MjNiLTU4YTQ2YzNmMDVhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDFmYjdiMzAxLWY3ZDYtNDYxZC1iY2YzLTE2YmFi\nZmQwNjUzOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOlV2LdeG9rPwLu4WNuY\nnyNm4jodoNZOrIb4fIH4HC0CnuVwX7JPR82y2Ayc760yvQSnWzC3qqKaCkVLHPOF\n+yqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRl20IEefJNKypqhCaFBzDeN0lodjAfBgNVHSMEGDAWgBQ7/g5rcggv0LdLb2jX\nS6B6iTLwsTAKBggqhkjOPQQDAgNIADBFAiB6L/XYqDXvFIway++unLmVF7YtMMf/\nNKAGVJmv01+xcAIhAPxvpwNCWJvAfaol0pjas7X2NiNH2IQDzqqbdRVE0Pzi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISATdgFpr5Vd6mBCWYt+Cp5ObrMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDcx\nMDczYTk3LTRhYzQtNGMxZC05MjNiLTU4YTQ2YzNmMDVhNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJGJlNTBiMmZmLTBiNGItNGFmNy1iNDBlLWE1YWY1\nN2Q1MGU5ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABC47Kr3N19ljHGbF+6w/\nHBM8tiqO8DAajMsj355Z2pRCiVumLI1WbPNcA4yyN3OQmVIi+TSGVWBtKL+zq9AM\n/B2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSdHn1Dkpbuz5e4dRDAwmE5Xxc5FDAfBgNVHSMEGDAWgBQ7/g5rcggv0LdLb2jX\nS6B6iTLwsTAKBggqhkjOPQQDAgNIADBFAiEA2prF+mRo2mMMEjSstpK0GLZDdhFz\n7X4N6xiQE+bWMGICIDDdjsrNOl5cJizfjvdSZmU5GN/A9sgDuxfwL0WA6NCx\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAZYSqoQ10PbMIugL88EjWFG1MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDg0NDJiYjA5LWM1YzAtNDNlZi1hMmI0LTU1ODhhMTJhMjczMTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJGY0ODRhMmNiLWRjNzAtNDQyNi05OGNiLTE2\nMDE2NzBmMjNhODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIV4vukpi3aJrYRF\nX3M/XMeI46GN9g6bo9XbTvlNuPIpNxNL+3He1TM6ZwOlPc5lFDRLMq04tK0wg2lb\nHx+naZCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS/D6Sy5r1auRmh4t0N3CL8iz+4ojAfBgNVHSMEGDAWgBS/8oTKdpF3iewK\n5nvxXJTVGFa/pzAKBggqhkjOPQQDAgNJADBGAiEAsIgztczEkzEHqP+lqvs5dYcB\n6l98WrdQP5FAsTDkuNgCIQDDjXzBeIB2NRPPveADb3oLRKXvKWS+sUmdK0G+AZtF\nWg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAWNna2xgbm7wWmou39bKgQioMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDg0NDJiYjA5LWM1YzAtNDNlZi1hMmI0LTU1ODhhMTJhMjczMTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDcxMDczYTk3LTRhYzQtNGMxZC05MjNiLTU4\nYTQ2YzNmMDVhNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABATHBU2V6DPf/G/F\nPBfn4va3Q1OR3rQ8TCjSviAj2yxOkQxT2EMGP7a00q/0QFeJlbR3aPkYOB66+ek2\nXAr1CHKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQ7/g5rcggv0LdLb2jXS6B6iTLwsTAfBgNVHSMEGDAWgBS/8oTKdpF3iewK\n5nvxXJTVGFa/pzAKBggqhkjOPQQDAgNIADBFAiAgAilY6p/6bSHN64aO0ZDnFko9\nT2ThJ1DAlhSXfyz6swIhALRgJLcbbOnbEaGrdOCKkxBuHSdV52ac6F9lWm38ZPXK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfF18c0lKOV4LRxF/fu5rbuqMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGNl\nYWJhNDVjLTQ4Y2QtNGJlNi1hN2VjLTUxNjM4MjM0NDQ2OTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJDhmMzU4ZjJjLWJiMTYtNDkxOC04YTQ3LTQ0MmUx\nZmI1N2IyYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD6fTJdDIrLj6uVhp2KE\n0kIjO4pmwz32P2p1rUo4FlMiLK2eCj0xLkpuI3h1R3WrsIN6if4AoqKOFu+Zr7jd\ncwWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS+/YAWxfGdWWU3BHjde9g0quGrozAfBgNVHSMEGDAWgBSLXgiJsqitXdfRBWqy\nLws68pgkXTAKBggqhkjOPQQDAgNJADBGAiEAvQ7eDM61TAOtIjPuSawwA3pUcv6H\njFIHwqzyEjftOUgCIQCPoAuqM10nVzXpl/8TTR8C/e0jCkIo3BI2CQ2Rl+uEQA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXSZF6eCmeXEh9yxsM+aEb8vMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGNl\nYWJhNDVjLTQ4Y2QtNGJlNi1hN2VjLTUxNjM4MjM0NDQ2OTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDkzMzIwOGE4LWQzZmYtNDg2Yi05ZGE4LTI5M2Y0\nNmUzNjE0YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD1PiuT14QuhSdpTGCn3\ntnCibI1roVtHSPPiMeNS/cevEHTSxSQpOSrPbBSSM1Ouvevd4EXcIOQ/vhPxBgC8\nsK6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSJ1JZF7fL0lFLv57u2F7lbtIt/PzAfBgNVHSMEGDAWgBSLXgiJsqitXdfRBWqy\nLws68pgkXTAKBggqhkjOPQQDAgNIADBFAiBHUmA6NuXPoTZOgnCHDW8jqUA2HGoq\n5MghdvmRjV5dwQIhAJ+8L+fmCStEBFfHjIpnTLBfVIWSrGWoMBuC3BLCGkuQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUTKwC+LzNAiik1PpMzujno4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDFm\nM2E5ZmI0LTEwMjYtNGRiYy05OTkzLTM5ODk1YWQ2ODcxYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGNlYWJhNDVjLTQ4Y2QtNGJlNi1hN2VjLTUxNjM4\nMjM0NDQ2OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLZKJ34wVjUFfoSHXZTP\nyfvIVCxBN/TChHqmW77oD75sQMSEG/rc5QxU0XUqYgryOgrGX9pzXxKLyklRAKcz\nDPSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSLXgiJsqitXdfRBWqyLws68pgkXTAfBgNVHSMEGDAWgBQpGULaaS1iEC4lUmGS\nyqUoRB1JFzAKBggqhkjOPQQDAgNIADBFAiAY6/b7AQmxkk562JCNNVzx31Vynr0p\nrmQUp10mkLNsDQIhAOx7DqN4WsDduQz5KkZxS7EQmfCPuo9QWGXlJr0zjdbz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQ6eKvj4jfBMnZYGyLewAFW9MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDQw\nMDUyMGEwLTIyOWMtNGVmZi04MDhmLTU3ZWQ3M2NlZTc4ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGNlYWJhNDVjLTQ4Y2QtNGJlNi1hN2VjLTUxNjM4\nMjM0NDQ2OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLZKJ34wVjUFfoSHXZTP\nyfvIVCxBN/TChHqmW77oD75sQMSEG/rc5QxU0XUqYgryOgrGX9pzXxKLyklRAKcz\nDPSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSLXgiJsqitXdfRBWqyLws68pgkXTAfBgNVHSMEGDAWgBTy8BeFPWySuUwPPbbx\n+mEGhrr+djAKBggqhkjOPQQDAgNJADBGAiEAj6aAYiAYzoGX6O/5CwHS4/h6px+R\n9FT7fr39rNNoJF0CIQDWRC7eb8seL8ByEflKvkway3aHF6NhuJ8c9XYOaNd6Kg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARTbDWGV6a8ERpYpEae5n8FYMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDFm\nM2E5ZmI0LTEwMjYtNGRiYy05OTkzLTM5ODk1YWQ2ODcxYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDQwMDUyMGEwLTIyOWMtNGVmZi04MDhmLTU3ZWQ3\nM2NlZTc4ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIfiUEgoSkVqFeSk/4+9\nKCzcT8uze5uBZJOrnDoO5uCIyKkfgNa6uTQzgZ3r4ELsBvFkVKjAwnYlBx5AXTez\n5QajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTy8BeFPWySuUwPPbbx+mEGhrr+djAfBgNVHSMEGDAWgBQpGULaaS1iEC4lUmGS\nyqUoRB1JFzAKBggqhkjOPQQDAgNHADBEAiBXHZGW2Er/pqcntShTth+lYyQj+wdI\nwMnnSuZMoytX3wIgPn6Iet6jEBOkCdsHcBUJTRGsncUtl6lV3ACDnfgSfMU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWJ3pNhMWeluadd5kVn509LpMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDQw\nMDUyMGEwLTIyOWMtNGVmZi04MDhmLTU3ZWQ3M2NlZTc4ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDFmM2E5ZmI0LTEwMjYtNGRiYy05OTkzLTM5ODk1\nYWQ2ODcxYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAnQj+G4i6wWmLlp0IUR\n6BWyeglio5SUMMWvgYXGvybfGfUM7G0mvZuaLc2CAv/H1qVJNAobFJrrVPE2sL4B\n9eqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQpGULaaS1iEC4lUmGSyqUoRB1JFzAfBgNVHSMEGDAWgBTy8BeFPWySuUwPPbbx\n+mEGhrr+djAKBggqhkjOPQQDAgNIADBFAiEAt49OK1J20sE4ySTahIz4yxGt/jbP\nFeUmPaMCxlR4H9ICIBaauNOOGUl4Wx374P/to5Jcu5YPuS9CE+Xbt1I+nS8G\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISASc/ujFksiEhKmFRxwh5urjOMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGE0MjA1NGE4LWNmY2YtNDkwNC04N2M2LTg4NzdhNDUyMTMxYjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDFmM2E5ZmI0LTEwMjYtNGRiYy05OTkzLTM5\nODk1YWQ2ODcxYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAnQj+G4i6wWmLlp\n0IUR6BWyeglio5SUMMWvgYXGvybfGfUM7G0mvZuaLc2CAv/H1qVJNAobFJrrVPE2\nsL4B9eqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQpGULaaS1iEC4lUmGSyqUoRB1JFzAfBgNVHSMEGDAWgBSgUxPR7i+g8r3f\neGnvYF25QsHDXzAKBggqhkjOPQQDAgNIADBFAiEAiL53HN9+IWgZjK/Zd5SElAO0\n3OgbQouEhbisJ0/RYrQCIFpoPlFtz4apmNGlsmfzZMyhOIzDGgqNfbqaoTVU4Ws0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISATtlsIwM1ZSidVB4mZhmUI13MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGE0MjA1NGE4LWNmY2YtNDkwNC04N2M2LTg4NzdhNDUyMTMxYjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDQwMDUyMGEwLTIyOWMtNGVmZi04MDhmLTU3\nZWQ3M2NlZTc4ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIfiUEgoSkVqFeSk\n/4+9KCzcT8uze5uBZJOrnDoO5uCIyKkfgNa6uTQzgZ3r4ELsBvFkVKjAwnYlBx5A\nXTez5QajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTy8BeFPWySuUwPPbbx+mEGhrr+djAfBgNVHSMEGDAWgBSgUxPR7i+g8r3f\neGnvYF25QsHDXzAKBggqhkjOPQQDAgNIADBFAiBheNWRWN0vVSA/ykS2JisJBaX+\nbH4EiY9+a+Q2bhmXwwIhAIypqNNUv9YDQzQam7Apl/Q3iIvjpSRTk/SmaFpqmf5j\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAdFRL8qKV9w4jOEaOxM00lInMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJGFk\nODFjOWRkLWI3YmYtNDAyMi04ODY5LTE2Y2U0ZWQ2OTkyYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDhiZTM1NWFhLWRhYWQtNDMzMS05YWU2LWU4MzEx\nMDliZmU1NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMJLzH8WElLyy28ZSaJY\nXupy/WecELplJqMUi0TaUxTdBVJFJbSqLErUVoiGW8VRIq3YYZC2X0hcNX9BVAU/\nu76jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQhumysqwZafUf2sEHK1v1BRT0HWzAfBgNVHSMEGDAWgBQuxaJllhFOpgePLxK6\nd+E+nKr+jTAKBggqhkjOPQQDAgNIADBFAiAx7NNWp7qDCPlwEfjcf0be1dHZJLdn\nbDad4ChidUKIvgIhAJQ6UQXX63/jl2R4jffI4ndG7Xi1kF0NFfL1qH8Ojee6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWUUu+UYZZZY5TuJvyTTbK0FMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGFh\nNmNmYjgyLTM2YTgtNDEzNS05Nzg0LWVlNWM1N2MyY2YxYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJGFkODFjOWRkLWI3YmYtNDAyMi04ODY5LTE2Y2U0\nZWQ2OTkyYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKHbHAov5wa712oxDDl1\niiWjInxBN6YH/5lQFeqts1zqydTmEfpCghy1AvQx/ww72KcURqOqIiR77L1B9lJ5\nz8qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQuxaJllhFOpgePLxK6d+E+nKr+jTAfBgNVHSMEGDAWgBTAjKEPDoEsMP/yloWJ\nhCQMO+v7wTAKBggqhkjOPQQDAgNIADBFAiEAhPjEH4ClMXkURZXtBb9gRa9V/+0t\nNPLaV9TjCFxo1v4CIG+iN8KM6XImuRT8HujNnCh6pmZGD8SAZqm2bjJgPlL6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcY8njaqTJESImkpA57Oh0oiMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJGFh\nNmNmYjgyLTM2YTgtNDEzNS05Nzg0LWVlNWM1N2MyY2YxYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJGUyMzVkOWY0LTFmOGEtNDY4NC04ZDM2LWMzMjk0\nYWFiNmY1MDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLU7QKC0eUICYfuuGAyZ\n4NPY2xAbIkC/izKhS8rMszUPkEw5yD9PW0W6SjsalgAPdGdbmVjgjSLQqU+YgJHb\n0hyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTec/M07oSxtonQWOGLAh8rGM2JcDAfBgNVHSMEGDAWgBTAjKEPDoEsMP/yloWJ\nhCQMO+v7wTAKBggqhkjOPQQDAgNIADBFAiEA0g4l5f3vrxIv/JPr7pupfKGxlYrS\nKW3IkTjaa3zdfHsCIDqjXyX2FXrTucBZk+BG7j5SjSth5bx/kBjUZ0FhUSLp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAQq6cKOlKnhtZFgGuPZ5mCzBMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJDZh\nZTFjMzA0LTliNTMtNGI4MS04ZTMyLTZmMDEyMDlkMTE5MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDhiZTM1NWFhLWRhYWQtNDMzMS05YWU2LWU4MzEx\nMDliZmU1NTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMJLzH8WElLyy28ZSaJY\nXupy/WecELplJqMUi0TaUxTdBVJFJbSqLErUVoiGW8VRIq3YYZC2X0hcNX9BVAU/\nu76jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQhumysqwZafUf2sEHK1v1BRT0HWzAfBgNVHSMEGDAWgBRhMl6cqcsOFvcaWFxS\ntTIsRX/S8zAKBggqhkjOPQQDAgNHADBEAiA5kxpl8MTEdXxg18/eteCxuJTYxavk\nW8c+TLX6UgsG6gIgNPR3ODN2z4fxLSUpL+uC5+89bzPGF9Jso9OdEHSxurQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAa6HRacJ2P0assKLzsd8PRQsMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyRhYTZjZmI4Mi0z\nNmE4LTQxMzUtOTc4NC1lZTVjNTdjMmNmMWMwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQ7uBZOM8XF+k/ZdlcZuWxGqR2+F09a8WDQATM22JB7MxxDytTiggNlqNTl\ng9zthDqvhbQ1YP09/MRdQ3EsyiDBo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUwIyhDw6BLDD/8paFiYQkDDvr+8EwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgEpnJ\nfSqmcipvIoazFacEnlIodFWwvtRLwBjv89qxGtgCIQDHMuG2UYeBEK/I5r7R90ca\nLMO7zVxzApCwQQE6YYVBbQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAbnrThtwgIGbOluru5TgNzgGMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyQ2YWUxYzMwNC05\nYjUzLTRiODEtOGUzMi02ZjAxMjA5ZDExOTEwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARWzXapq38CWO37Kc+ZY1YafbQj4vw69oKofHWoe3En0J6J9UeSAZEXUySd\ndPNam9BUTLIf/a2jOws0O/n24+6go2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUYTJenKnLDhb3GlhcUrUyLEV/0vMwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhANij\nJT7wPJrus2iAUcMqQOAH+hBTXWmZzIctFlYvkQaSAiEAhhqBIgrwKTUANYkQeJAs\n3G/soQ4YL+eW3hUJQviIIJU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXfZMYhF9CMClfigqNHXlgfoMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDg0M2I3NmQ1LTdkMTAtNDA5Ny1iNGU0LTAwZjNhNmU1MGNmZjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNDEwZGM0MjAtNmFlZC00Mzhi\nLWExZTItZWFkN2VhODJkMTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDRPW\n1TmXyRVipxyzqcpYiI7yPZ+i0FiNDQj602ER9tg0ddDMpQs4FEl/UIFfb1OHzwtv\nE8SpsCuX7N17E86C6aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFJWAimCIe5OV3inTQGF0103MrC5AMB8GA1UdIwQYMBaAFFbq\nb4z8BlduoRd7muSAKPonGbKQMAoGCCqGSM49BAMCA0gAMEUCIQD6f3KJbvxj8PXG\nmaxPAQC4byx5SXiLR26R6fgOHrho+wIgdYw71zAyOMUYFasAClUQDnO6IIw7vS2u\nGsQFEjulDOo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAfEr6rXDiIdkcSm8EEujkMrFMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNDEwZGM0MjAtNmFlZC00MzhiLWExZTItZWFkN2VhODJkMTRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkODQzYjc2ZDUtN2QxMC00MDk3\nLWI0ZTQtMDBmM2E2ZTUwY2ZmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9nFn\nZbpPiFlXAkTrmuUQSO8T1VgZVPcQSFvPsYDnyKPRnMNEbJtqJNtExGF1HJw0WGmP\nYapeVQldtTRdkNy/aqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFFbqb4z8BlduoRd7muSAKPonGbKQMB8GA1UdIwQYMBaAFJWA\nimCIe5OV3inTQGF0103MrC5AMAoGCCqGSM49BAMCA0gAMEUCIQCm728PXk1WdD9r\n6ysCJK6G+qE7Hr04GIDWY90Xr1vELwIgY4WED6McYpBOBQrMIJmUXxSgZJNdpKWc\nm3eZ5UwEbLY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAc/36eDq5fUsSPPVTfXqNo/sMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDg0NDJiYjA5LWM1YzAtNDNlZi1hMmI0LTU1ODhhMTJhMjczMTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNDEwZGM0MjAtNmFlZC00Mzhi\nLWExZTItZWFkN2VhODJkMTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDRPW\n1TmXyRVipxyzqcpYiI7yPZ+i0FiNDQj602ER9tg0ddDMpQs4FEl/UIFfb1OHzwtv\nE8SpsCuX7N17E86C6aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFJWAimCIe5OV3inTQGF0103MrC5AMB8GA1UdIwQYMBaAFL/y\nhMp2kXeJ7Arme/FclNUYVr+nMAoGCCqGSM49BAMCA0gAMEUCIEk5SFhdEyqBOVVZ\nV5cm/HIq/Vmp+wOJdidJX2L+I7cLAiEApYs1ffxFo5MTNnYbYOkCNAJUaofNIL10\n2jxDJ++37c4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAUXwYp/NFW2SH3xwmlnZ7ALPMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNDEwZGM0MjAtNmFlZC00MzhiLWExZTItZWFkN2VhODJkMTRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkODQ0MmJiMDktYzVjMC00M2Vm\nLWEyYjQtNTU4OGExMmEyNzMxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENTZf\nslHf+Sc1xWC80VU9QrwzRipmNBhSB4aFgy6eSbRtqK3ReMBV6zLioom/XcxdXsqy\n43QmSd0WujSLep4KoaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFL/yhMp2kXeJ7Arme/FclNUYVr+nMB8GA1UdIwQYMBaAFJWA\nimCIe5OV3inTQGF0103MrC5AMAoGCCqGSM49BAMCA0gAMEUCIQDLSscVAKL8UrtX\n8l/1gUX0OjHgKfIG3uaN8t8De1BN/gIgYlsd89goteVigSuEf0qm3UfvgNHii/pF\nTiVR+tWw+xY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAbj1AlsP9kYoyzoYVB4GKvEGMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGE0MjA1NGE4LWNmY2YtNDkwNC04N2M2LTg4NzdhNDUyMTMxYjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNDEwZGM0MjAtNmFlZC00Mzhi\nLWExZTItZWFkN2VhODJkMTRmMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDRPW\n1TmXyRVipxyzqcpYiI7yPZ+i0FiNDQj602ER9tg0ddDMpQs4FEl/UIFfb1OHzwtv\nE8SpsCuX7N17E86C6aNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFJWAimCIe5OV3inTQGF0103MrC5AMB8GA1UdIwQYMBaAFKBT\nE9HuL6Dyvd94ae9gXblCwcNfMAoGCCqGSM49BAMCA0kAMEYCIQD5Rx+5BT9uXTRp\nGWryRnmqfqFkHpAKFekKl5Ff8MDxSgIhANV8NobcvVRgXaSrSMQ2TT/NCoGjk287\nxAKbfGDQnwZM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAa5gYISiitvHSklGr6kKuwKtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNDEwZGM0MjAtNmFlZC00MzhiLWExZTItZWFkN2VhODJkMTRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkYTQyMDU0YTgtY2ZjZi00OTA0\nLTg3YzYtODg3N2E0NTIxMzFiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8ihB\no75TXAMftzN3mMUKs5nCYKuEQrJzNPnE1XqwGIXuHz6UWW1/jVGNhc7SEhYjGFOZ\neO4FB1ABTq+b3weHRqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFKBTE9HuL6Dyvd94ae9gXblCwcNfMB8GA1UdIwQYMBaAFJWA\nimCIe5OV3inTQGF0103MrC5AMAoGCCqGSM49BAMCA0gAMEUCIEV/pLCc3X49fVsL\nEJ/YWR5V8vV/dQasvEgjwz39VWJHAiEAkcAwQ5YDfTkVGtPA1dm9U5Zfov1yYVdK\nBS+Mf2GJl0k=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcqgAwIBAgISAf3h16XH637N0xBAi0l/khhNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjYwMTIwMTYyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDQx\nMGRjNDIwLTZhZWQtNDM4Yi1hMWUyLWVhZDdlYTgyZDE0ZjBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABA0T1tU5l8kVYqccs6nKWIiO8j2fotBYjQ0I+tNhEfbYNHXQ\nzKULOBRJf1CBX29Th88LbxPEqbArl+zdexPOgumjYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSVgIpgiHuTld4p00BhdNdNzKwu\nQDAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzthLhrgjvY9TAKBggqhkjOPQQDAgNH\nADBEAiBaFQpWbuu3eNx6or6kBL+fT+DzK8jV+T2wWahv7tEtvwIgf011c9YhtQjR\nuEU23j33z91bSUJlx16q3mMRBM/IbjI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcqgAwIBAgISAf3xPXVbb5Fgz2MsK+JsdgTfMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNDEwZGM0MjAtNmFlZC00MzhiLWExZTItZWFkN2VhODJkMTRmMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBSVgIpgiHuTld4p00BhdNdNzKwuQDAKBggqhkjOPQQDAgNJ\nADBGAiEAoTuIvoi11p/sZ94E7FUAMQxoNWxH4AAAV4sKss3yc6wCIQD2nqiG2zj1\n1LQIzQObHmtxBPehU68cMmAQnG7LAV+nQw==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAYXLlC7CfA11W6oI0Cq3znxfMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDFm\nYjdiMzAxLWY3ZDYtNDYxZC1iY2YzLTE2YmFiZmQwNjUzOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQyMWYxMjEzNC0wOWIwLTQxNmUtYmViNC0wNTMz\nMzQ2YWE5MDYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAT7tN54CzoNWWaBxqfT\n9+M3AibSIftR/2SIRYbFWqI7xhQ3kmwm+7amDEFY4SI/hxymxlGV1C8ufax7+sHB\n9UhUo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRl20IEefJNKypqhCaFBzDeN0lodjAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgBjzceoFAZoo9cOTA\nDOM0/HPde9Gps0o01nl4UVStvNYCIQCVpjzwVpDIK/LEXoEUj0BLqMlA5YpDyhWM\ndD1D8k0c6A==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2027-01-21T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc76", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `76` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAat1iy+UKz66u9X1nT0G20j4MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDBl\nNGI5NmIyLWRmYzgtNGViMi04Njc2LWUzZWNhMGM1MTQ3MzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDU2OTU1YWIxLTQ5NTgtNDI0Yi05YTA4LTBlNzUx\nOGJlOTc2NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGq0nkuP3DPA9D2kdKbE\nFBEAx+RBnMTwWacYR94IP7ldT/zZ+lLbtCWaAeV0CJ1ajLoNIQnbiJMt4eeWRx+z\nVKWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSCxUxrZo4ADtu5EqemTvpreY/dVTAfBgNVHSMEGDAWgBRtvd8bNXQ9tdUZRY/y\ni+/nUA6TVDAKBggqhkjOPQQDAgNIADBFAiEA5RtoXkdDjQY3kVMaICRGocU7mwQg\nhTHyJtbc2KxlKoICIFYmRcaRo7JafYc7xIP9xMeigHLS19iDwr+9yHLVhS6K\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaeNWPMvXDhgjmryi1WVZanAMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDBl\nNGI5NmIyLWRmYzgtNGViMi04Njc2LWUzZWNhMGM1MTQ3MzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDRkMjI3MjJhLTJmMTctNDRhNS04ZmYzLWFhYjM1\nZGQ1YjEzNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBKH8GlZJR2Ag2HITVDO\nS9GY1tjzUvJfxKEWyl8ZqSYz8PPC4iPzfDBmJm7KZndZesU86zdqtMbFAYsVLTuL\n5GajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQYiE4S6PQNrvQFxkRCTRCkUFFAfDAfBgNVHSMEGDAWgBRtvd8bNXQ9tdUZRY/y\ni+/nUA6TVDAKBggqhkjOPQQDAgNIADBFAiEA2rbCM+GCWEeoI5irq86Guh1dGiVT\nvJXGnNjeU/f2w3wCIGH/PGzZhSsp03A0sgmkU8SW3OhoVXi0fRhhV5nUKSFo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAff2RhmjrNqvi4CynQH3RIFHMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDRk\nMjI3MjJhLTJmMTctNDRhNS04ZmYzLWFhYjM1ZGQ1YjEzNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDBlNGI5NmIyLWRmYzgtNGViMi04Njc2LWUzZWNh\nMGM1MTQ3MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD2qlbi5XCO6nSCGebrF\nxkgoyHp3uxTTeS3HJEbVuv89G0/newsckrquJcWqhcShZ+TnuhFL4BbG6PL7NZmb\n/YOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRtvd8bNXQ9tdUZRY/yi+/nUA6TVDAfBgNVHSMEGDAWgBQYiE4S6PQNrvQFxkRC\nTRCkUFFAfDAKBggqhkjOPQQDAgNIADBFAiEAywQFFt+TL85cZzURnRTXScCcWnON\no4sXxrXJC9mS8C8CIAFWtELCAXpeFASLpdsANmAKv0i/2DxiDqtKJLma+eSf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWRLtIJ6AG+dHR3XqmrOKiGVMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDU2\nOTU1YWIxLTQ5NTgtNDI0Yi05YTA4LTBlNzUxOGJlOTc2NjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJGI2NjMyNjIzLTY2ODktNGFhOC04M2ZlLWVhZDZm\nNDVhN2EwZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCqdZ0WI8Y+wzLJcfIOx\nKVsZ/02mAUlWDI0B71Uc+WNb0Kom8YwV6kWSUKYKddaa5hVHRI1dfa93DgrxiOQL\nMRCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRl+ujv9SfN5LUoZ3j7YjWW147LejAfBgNVHSMEGDAWgBSCxUxrZo4ADtu5Eqem\nTvpreY/dVTAKBggqhkjOPQQDAgNIADBFAiBGLR6+JX7Sj9x8r+qpCOQWRoQDNcrs\nzzphn4KrtqYmNwIhAPJv0c2lw3Ro17V12ACUGkxclhzeDXHYGPyogulWw2+w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAXgl3qob04yVOhxSlmUDyACjMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJGI2\nNjMyNjIzLTY2ODktNGFhOC04M2ZlLWVhZDZmNDVhN2EwZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDU2OTU1YWIxLTQ5NTgtNDI0Yi05YTA4LTBlNzUx\nOGJlOTc2NjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGq0nkuP3DPA9D2kdKbE\nFBEAx+RBnMTwWacYR94IP7ldT/zZ+lLbtCWaAeV0CJ1ajLoNIQnbiJMt4eeWRx+z\nVKWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSCxUxrZo4ADtu5EqemTvpreY/dVTAfBgNVHSMEGDAWgBRl+ujv9SfN5LUoZ3j7\nYjWW147LejAKBggqhkjOPQQDAgNJADBGAiEA+8lhq9DeoWsubtNfry+JNCUw/zP1\n7JAeiU4AlQ40UkcCIQCHN3s71ARk3Cobsdt+5O0JUIRwPuenUShDpWj1yl1/ag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAbOyxvsXHHV00w4DZIihY6vKMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDRk\nMjI3MjJhLTJmMTctNDRhNS04ZmYzLWFhYjM1ZGQ1YjEzNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJGI2NjMyNjIzLTY2ODktNGFhOC04M2ZlLWVhZDZm\nNDVhN2EwZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCqdZ0WI8Y+wzLJcfIOx\nKVsZ/02mAUlWDI0B71Uc+WNb0Kom8YwV6kWSUKYKddaa5hVHRI1dfa93DgrxiOQL\nMRCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRl+ujv9SfN5LUoZ3j7YjWW147LejAfBgNVHSMEGDAWgBQYiE4S6PQNrvQFxkRC\nTRCkUFFAfDAKBggqhkjOPQQDAgNIADBFAiEAsm/68OVnurCu9xUtYKyb3y1aIA2N\ndmjueX7CYs9rsU8CIBk9ujIXnOLsRjyYFVgISaaupOvW+geYsNcBzZP8DXod\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISATXBfM9AKc3AYrYGI2sGnpgEMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDUwZDg1ZWI1LTZkYzMtNDU0OS1iYTlmLTRlZDk4NDZjMDdhNDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDBlNGI5NmIyLWRmYzgtNGViMi04Njc2LWUz\nZWNhMGM1MTQ3MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD2qlbi5XCO6nSCG\nebrFxkgoyHp3uxTTeS3HJEbVuv89G0/newsckrquJcWqhcShZ+TnuhFL4BbG6PL7\nNZmb/YOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRtvd8bNXQ9tdUZRY/yi+/nUA6TVDAfBgNVHSMEGDAWgBRMyMtXY2P0WgFe\nAjqB32ICV5ZQVjAKBggqhkjOPQQDAgNJADBGAiEAgy07NtGH89G9O9fp2Q3grRcy\nqCLYP5gP+WDzYd9U/zgCIQDaV4d9pioXf9RWz/42/UuQedKNY8nCYL1DV6iYHhrv\nkA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAWPbE8svTgSmiCG1xyKz3podMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDUwZDg1ZWI1LTZkYzMtNDU0OS1iYTlmLTRlZDk4NDZjMDdhNDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDRkMjI3MjJhLTJmMTctNDRhNS04ZmYzLWFh\nYjM1ZGQ1YjEzNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBKH8GlZJR2Ag2HI\nTVDOS9GY1tjzUvJfxKEWyl8ZqSYz8PPC4iPzfDBmJm7KZndZesU86zdqtMbFAYsV\nLTuL5GajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQYiE4S6PQNrvQFxkRCTRCkUFFAfDAfBgNVHSMEGDAWgBRMyMtXY2P0WgFe\nAjqB32ICV5ZQVjAKBggqhkjOPQQDAgNJADBGAiEArMxXNk7vLrcnN4NyzjlMZCqc\nChOg2sXDN+T3JUG+xsICIQCietS8d3vEpZ6iGZgOSR9auY3psSD16i0ZaXZ3hoM8\ntw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYnlApq8KXtOh9Kj9O3FPgcCMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDMx\nOGRiYjllLTIxNzgtNDJmMS05MWJlLTc0NmZmNmU4NGMyOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDJmNzBlMjZhLTUxMWEtNDczNS05ZWY4LTc3M2I2\nNWY0ZTJmYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCTlJRHExSNlbDIn3BtH\nKG8Y0R9qgzUTWDhNC8m4KawjzuNv7z3G709KmrJpEi+zuo34xkqBQ38WJYv86HUj\nK8KjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTV0cb8pQny2g65CsUxWPC+6gcTTzAfBgNVHSMEGDAWgBSSpSAR7ZWl1pd1OSKk\nDUUabjwZdDAKBggqhkjOPQQDAgNIADBFAiBaiNaYbgRoHlNClmoR4m75VE5m5+Tw\nWK425JnKviRl6wIhAPchXnoMeDwuBj5PIdtmXME4uiXXcIDRx7VWyJ+xVVSz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISATDBSHcrfYn77+PkKT9aWvKyMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDRk\nNjFiMjZhLTk2YzgtNDhlNy1iZTdlLWIzYmQxN2Y5MDA0MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDE2YWM5MDMxLTk0ZWQtNDYxMC04MGU5LWQzOWY0\nNWFiMmRkMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLRB83rq+OsU8d+OZ7l8\nXOkYC363AYPWbpQ6dVva0kUeMEHNQFxzfWzKloqjls0TXUMERrSpELgbf0i/w9ol\nA76jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQHPqo07a5wv69Vr+H9e4f+aEIDVzAfBgNVHSMEGDAWgBRZdCDcOLQ56nEi+CVb\n/fas/zPnITAKBggqhkjOPQQDAgNHADBEAiAv29AJvhPb+r5ztciYSdtRJr1JuPNO\nYCcfw9e116tmRAIgYX859ZTMUSI4qpxLeRWhYRBCk3WfKjQaunJ54gPEPGU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcgD7tZpAgo9SeQOOLQatNK9MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDRk\nNjFiMjZhLTk2YzgtNDhlNy1iZTdlLWIzYmQxN2Y5MDA0MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJGNkZTQ3NzVjLTY2ZTItNGM5ZS1iMDI1LWNmMjBm\nMjI2MDFmODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLB4g9jY98mL8kWg/xms\nl6U6lgQGi0Cd/H3PTV7tIpOsMDsLkjQHc1IjODMTp4+/tZOdDJpXVtd1SMxaUj/e\n5a6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSWywfBbp47yic7sO1Bw2ka37czJDAfBgNVHSMEGDAWgBRZdCDcOLQ56nEi+CVb\n/fas/zPnITAKBggqhkjOPQQDAgNJADBGAiEA6DWWsSk66FhDWv28l63O3ogdxLFT\nX2S5A8+4qOXj8EcCIQDjDi9I7jXJPKERQRC4wcZnyJGLX6i1EsjpJEyDKWFavg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAQA8YJxlfVLrVws3iQAaqiMqMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDkzYjk5NTQzLTA1ZTktNDE3Yi04OTY0LTljMjFhMzQxYzE0ZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDMxOGRiYjllLTIxNzgtNDJmMS05MWJlLTc0\nNmZmNmU4NGMyOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMmL/pxkz+OARDCe\nU4U2+ko1V0GD+yZmUhMTsEI/88lLb6waneunzkWG6sLlpDbo/lmJuB+4+b06dEfc\nf+gXOYKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSSpSAR7ZWl1pd1OSKkDUUabjwZdDAfBgNVHSMEGDAWgBTglaiw9Em26bn5\nOxIolkcAYxFlDTAKBggqhkjOPQQDAgNIADBFAiEAwY4C+amOkkac6aSVw+KEYhce\nLIdf69UhN4tx9Tp/PqMCIGP+XaWGtAsUQAF4Ku9pt5XjvHlzWamuKu3VofXiHp8V\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAW0dXAovcwoPBEgRhyudE5xaMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDkzYjk5NTQzLTA1ZTktNDE3Yi04OTY0LTljMjFhMzQxYzE0ZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDRkNjFiMjZhLTk2YzgtNDhlNy1iZTdlLWIz\nYmQxN2Y5MDA0MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABC1XNxI7ldtx85KC\nzs4XV32Tje/sNNlyO6RkI/gknvjj/pR6Oc9bzpnsernPKQQp4GHwJ1cu/NOsfv+f\nBDawkUSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRZdCDcOLQ56nEi+CVb/fas/zPnITAfBgNVHSMEGDAWgBTglaiw9Em26bn5\nOxIolkcAYxFlDTAKBggqhkjOPQQDAgNIADBFAiEAgDnXsolHq2UmQqOQjdyPQCjD\niqET6emcJ0O7WPTK4mMCIG9XpLjzdS6CfMzWXHNfttEhHOZlFkpsC4srNzt+cEZm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQmCirMYjRGkHcgkb+K9x8QaMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDFm\nYWVjZjBjLWYwODYtNGYzMy04NDZjLWYzZDNiOGVlNDg0NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJDE0Mzc4ZDU0LWE4MmMtNGNhZC1iMmVjLTMyMzFl\nNWVjYzFhZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPlaGT9HpmNluo/qEurG\ndi78pP04cag1LH1v7sT60WeG9XioXxy7b4c8A92YRs6iKH30CsIxQ9YdPlTS5ZlF\nVmGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSY8y6vcgi0i6zus0TUbJVWBqitoDAfBgNVHSMEGDAWgBSED6i+y/EdaM/p2Jz3\n5fd0W+YWjjAKBggqhkjOPQQDAgNIADBFAiACRZiqbBpl1n8/O9Pgw2g4A76lwrfK\nhQw7eUB0UO+LbgIhANJQsYoI1mhYdTjhEc3V+zM5RdjHTRk9MbjelE+/O+qp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAdQaF8RUxnUHsLg1A53FxzBGMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDFm\nYWVjZjBjLWYwODYtNGYzMy04NDZjLWYzZDNiOGVlNDg0NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDY2YmZkMWU4LWZjZjEtNDZjYy1hMzRjLTY0NTI0\nZjQ1ZGYwNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFsDhzNUvkSk8shUTLsh\nGT5zjpWSLt7s9KfVnYk+M/TukjAvd7ubNEa3hhxdIsLSnQwfGTHjAAMvydkD/lZ9\n+VOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTAjmVUGAtiqevOx6w2eFTWGeXhmzAfBgNVHSMEGDAWgBSED6i+y/EdaM/p2Jz3\n5fd0W+YWjjAKBggqhkjOPQQDAgNHADBEAiB17eKRid+bDalhAvDLZ5cCca8yUezC\njVO77ulAsG1ZFAIgLojpiSKXPjTSWEOf1dQVWEWJOBUIhlsVODXhb6690RQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAe/wG17VB4bmv5kuO5VRr5ICMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDRj\nMmVkMzJjLTBkNzQtNGYwOC1hZGQ4LTNlNGM3YmU0M2ZkMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDFmYWVjZjBjLWYwODYtNGYzMy04NDZjLWYzZDNi\nOGVlNDg0NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGwUh8TegIlJnIzc22ZK\nvy6ni1e+DNIuOB8fmddDMGczFhHDRC4uY+ffshltU2Mg2idankE/VwUwvI1M2U1h\n+XujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSED6i+y/EdaM/p2Jz35fd0W+YWjjAfBgNVHSMEGDAWgBRO0cYXgLZ2uHSICrEd\nvSzs68b6SDAKBggqhkjOPQQDAgNIADBFAiEAxIwFSBBUQead1QqEGE9+oSHelXxl\nRRgvLjcceCAvefcCIEXyiXHfF563ax/EGCxSwHcme0/ID+x8gXaUDXlAuEKH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQQE5JPVR8s3nPtf3FpzDPA1MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDBj\nODljNGRhLWQxYmUtNGQ0MC1iZWZhLTIyMThhZmJhNmQ3ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDFmYWVjZjBjLWYwODYtNGYzMy04NDZjLWYzZDNi\nOGVlNDg0NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGwUh8TegIlJnIzc22ZK\nvy6ni1e+DNIuOB8fmddDMGczFhHDRC4uY+ffshltU2Mg2idankE/VwUwvI1M2U1h\n+XujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSED6i+y/EdaM/p2Jz35fd0W+YWjjAfBgNVHSMEGDAWgBTP4qkHayq3lr8cY3I5\nzZ8E+CPXXzAKBggqhkjOPQQDAgNIADBFAiEAy5cBNzWi4hnGKm+jQv+cBkrKLvio\nCVt+xUWGoHI18cYCIDnnkeLJJsw0Me+BcYVzStSMe+RLfqY/oSWBQ45NbZOu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVjSw4E34QwBhuDMJw61+fRBMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDRj\nMmVkMzJjLTBkNzQtNGYwOC1hZGQ4LTNlNGM3YmU0M2ZkMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDBjODljNGRhLWQxYmUtNGQ0MC1iZWZhLTIyMThh\nZmJhNmQ3ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIipzv5t9IRslbeO0r6t\n2G36XVIYsZHEvAYfLNwtM08SI5GZXCnDwDsO3QpQjcNSi2raOtv6GyylQpeeCEWO\nFJ+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTP4qkHayq3lr8cY3I5zZ8E+CPXXzAfBgNVHSMEGDAWgBRO0cYXgLZ2uHSICrEd\nvSzs68b6SDAKBggqhkjOPQQDAgNJADBGAiEAzXqfyP5StoGFIfOb1fAHOaLJZ4tj\n3OUmzZODKGcytLwCIQDIoD1qJtJb5nn5AyujRzk8AAmtnuow597DyTW0JPXt1w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAcdfVg4mnQUjUQJrybim2eGTMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDBj\nODljNGRhLWQxYmUtNGQ0MC1iZWZhLTIyMThhZmJhNmQ3ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDRjMmVkMzJjLTBkNzQtNGYwOC1hZGQ4LTNlNGM3\nYmU0M2ZkMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJQJQyznzk+rbVaY2Sdr\nBqxnd+8O9zAKdQFmY2SAmmE/Rol1639IKOVxGkQLnsH985XlGxhGuW+osBETruEX\nHvWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRO0cYXgLZ2uHSICrEdvSzs68b6SDAfBgNVHSMEGDAWgBTP4qkHayq3lr8cY3I5\nzZ8E+CPXXzAKBggqhkjOPQQDAgNJADBGAiEAgc3cQm5DNDhLNaLZs34CXoB1bLK1\n1fcswSZ7RuOcfRYCIQC7nmV0LxnurFraq7lCvg7E3Gxhtl+Hv1nkwF7aRjwlhA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAZ+F5lPQ6fSRYknKHQjmXj9JMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGM1MWFiMDY3LTI1ZDctNDMwMi04YzZiLTkyZDc0MGQzZjJlZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDRjMmVkMzJjLTBkNzQtNGYwOC1hZGQ4LTNl\nNGM3YmU0M2ZkMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJQJQyznzk+rbVaY\n2SdrBqxnd+8O9zAKdQFmY2SAmmE/Rol1639IKOVxGkQLnsH985XlGxhGuW+osBET\nruEXHvWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRO0cYXgLZ2uHSICrEdvSzs68b6SDAfBgNVHSMEGDAWgBQhPXKDtOEImGFO\nhBlesNy3q0IUxDAKBggqhkjOPQQDAgNJADBGAiEA/1DDtdOEUuYABsYFXNq8JxEk\nYE5isWE6gDmVBxGFk7sCIQD+Fs3HZ2tUafn6D+ohZwECIcP9in+5OM3lvbQhU0NU\nwg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISARumhaDlYusvw35fU1AdSfo3MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGM1MWFiMDY3LTI1ZDctNDMwMi04YzZiLTkyZDc0MGQzZjJlZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDBjODljNGRhLWQxYmUtNGQ0MC1iZWZhLTIy\nMThhZmJhNmQ3ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIipzv5t9IRslbeO\n0r6t2G36XVIYsZHEvAYfLNwtM08SI5GZXCnDwDsO3QpQjcNSi2raOtv6GyylQpee\nCEWOFJ+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTP4qkHayq3lr8cY3I5zZ8E+CPXXzAfBgNVHSMEGDAWgBQhPXKDtOEImGFO\nhBlesNy3q0IUxDAKBggqhkjOPQQDAgNIADBFAiEApr13NUQIW6NpL677uxZ2z7go\nY6ATM1Jg/+UV99w3aQcCIG8tMp818Tm/GU82N1Ji39iCM0u4ChBC5+2oFxg6Qdgk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXsyi+mgYIrQoU+3cDaLVh1iMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJDUw\nMTgyNDk5LTUyY2UtNGU2Ni1iODExLTFmMDQ0YWFkOTgxZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDRmY2ExOGM3LTc1ZWMtNDhhYi1iOTRmLTY4YWU4\nZDI3NDQwNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFuaLeJ+OM82sU0HF0uG\nnDwM0yb0Ac83duGcetxeQl3xc7Pq1e+etf7hsfaOTw3JzDaIzCYlCDToi6bYy2Eg\nHI+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ/epgOwUxC0pefNOMJ0dkZHPJmmzAfBgNVHSMEGDAWgBRoVJRLQVNXrlR3fc1V\nVnF7uFQFWTAKBggqhkjOPQQDAgNIADBFAiAaHj/PGTlxUudo8zmL2KKfhayRoZsB\nbhicwqkNF89v+QIhAJXFotjcecsmfJlVPrQs8Bd1EkRQmT2TpQ78CwXtCW/a\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAfxVy4bZdgogVV0XS6uhaes9MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDI0\nYTJkODRlLTkyYTUtNGQxYi1iNGNkLTJkNjQxOTI3YWQ1YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJDUwMTgyNDk5LTUyY2UtNGU2Ni1iODExLTFmMDQ0\nYWFkOTgxZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCyfoqhy2WdHT7c7DIje\nURiFiypCuWOmvj1R4rMk7++62PLjNl9kuixeUG0XAULJbKTFqQhnGokFv4OfLFxt\nIQ2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRoVJRLQVNXrlR3fc1VVnF7uFQFWTAfBgNVHSMEGDAWgBTYa+UzVgXOjZTb6Hfd\n76AezyOeFTAKBggqhkjOPQQDAgNJADBGAiEArlp7fuhDE3mvUdwvPAWWGVoumP5B\nQxXDFNIVCiP5hoUCIQDpzRFD7WotH7E7+RY/CZHdRvsSMvqbe/HXBABEzQJrsw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAXEoBNo98twISonZidIlODSuMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDI0\nYTJkODRlLTkyYTUtNGQxYi1iNGNkLTJkNjQxOTI3YWQ1YzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDI4NzI1MzAyLWE0ZTgtNGIyNy05NzQ1LWIyNzBj\nNzUxZTA1MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFleulSclyQ3cXSMAYuT\nk/wkLuTwr8VdKR3+QLMuiRy6XVrwx0AdYyg2B0eYmakvAQj/Zf6/6IWDoLDSSaco\nOCyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSF/CU0l5EccHpRazjyWityptGsSTAfBgNVHSMEGDAWgBTYa+UzVgXOjZTb6Hfd\n76AezyOeFTAKBggqhkjOPQQDAgNIADBFAiEA6/8fddwGn5BS/BKMtnkSnr74mkzP\nMlwncv51mg2kew4CIE+iFYyCv5zt3s4vr16APp98GnJ0JOzW5muoU+X2MMBm\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAV+Vs86sMHaKpAGGDDrkin2CMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGE0\nNjQ0MWIwLThkMTEtNDk0YS04N2E5LTlkZWQ4N2QwZWY0MDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJDRmY2ExOGM3LTc1ZWMtNDhhYi1iOTRmLTY4YWU4\nZDI3NDQwNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFuaLeJ+OM82sU0HF0uG\nnDwM0yb0Ac83duGcetxeQl3xc7Pq1e+etf7hsfaOTw3JzDaIzCYlCDToi6bYy2Eg\nHI+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQ/epgOwUxC0pefNOMJ0dkZHPJmmzAfBgNVHSMEGDAWgBQq9lgSja9PgRQd3/9K\na+LhlK+oITAKBggqhkjOPQQDAgNIADBFAiAdwiPpkt88Os8sH6Dopk3cpjVmjDaO\nc1sikB7o63+qbwIhAKtX2Hl50e7QcjriStuX5MROzS4wzj2UO/nVj7PSZBg1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAePZgLQ5UpIpy2XxBOEB1FwwMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQyNGEyZDg0ZS05\nMmE1LTRkMWItYjRjZC0yZDY0MTkyN2FkNWMwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQ018TgRUvSa4841i/7FymLMfk8dcGM7t+LeiIECpTAfEKPLVdhQUoC4flw\nH784l/gbon0YxjxPDI5LBa7D+JXbo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2GvlM1YFzo2U2+h33e+gHs8jnhUwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAKQX\n3cCk8EvlZZf5N9pE21tte4PKQZGaGcBk7cfZkzSdAiEAwXpdisi/ANYWo8Y+eKzj\n48eV+UcVRRDBhZn6Gz151J0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISAb++pr1gwo47BDJw9+e+lz9/MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRhNDY0NDFiMC04\nZDExLTQ5NGEtODdhOS05ZGVkODdkMGVmNDAwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAASA4noaH/3jRZtZxrCrMbnmzyn/pHKzn0r3AO5ceMXnkOH/DjB1H1py71HP\nPPlKbG7Gzoi5r9hL1bnWT771cQpEo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKvZYEo2vT4EUHd//Smvi4ZSvqCEwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgYt0E\nFsInWsmPFx45pc529mRq2cF8/J8Ce+nogESg/eICIAjdWWFq35gd+fZ6kxdE55Sg\nCmkYeCY8yqep+9sRlJJS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAd6Pl/81HtPR1BRBuyV8aDygMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDUwZDg1ZWI1LTZkYzMtNDU0OS1iYTlmLTRlZDk4NDZjMDdhNDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZGJjYTgxNTctODg5Ny00YzM5\nLTk4NjEtNTUzOTZmMDBiMTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElsC2\n4GlQ93YZaeQjtzz2kOYHg6eMNY3DCTH2ToUTazusC5Cuhxja7su8kY+zmztlnwGa\n0DS+fSZChuabGcE+cKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFLMN5wW12mM2L2Qu+TnCDAIMBrM/MB8GA1UdIwQYMBaAFEzI\ny1djY/RaAV4COoHfYgJXllBWMAoGCCqGSM49BAMCA0gAMEUCICERgiwauwVw5ElO\n3PZl+gQezWBAdN48wGHtG/bpT0dtAiEAx3T+vuKfB/aHOHvtbrOmlqcoEL3JtNOp\n+s09b7Un2Fc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAU4JoV+Smf8F7+/ql7Z7AIxtMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZGJjYTgxNTctODg5Ny00YzM5LTk4NjEtNTUzOTZmMDBiMTFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkNTBkODVlYjUtNmRjMy00NTQ5\nLWJhOWYtNGVkOTg0NmMwN2E0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEasYI\n5+rfN2X8i0STeXPY8lt0SZkzhARzj4nCqEwGnsckOjaxTW6KAKEFwJpJXcpta0Pr\nCDjH4nRsKeYvWRxxh6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFEzIy1djY/RaAV4COoHfYgJXllBWMB8GA1UdIwQYMBaAFLMN\n5wW12mM2L2Qu+TnCDAIMBrM/MAoGCCqGSM49BAMCA0gAMEUCIFxzTg1N4fEnsrNs\nw7CeYdLzGyi9DSBQGZW3d3D+wQksAiEAmo8QogWFu9F11cRUSypeA2flBNcEAl8x\nxFVcjoD+EQE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAe4ksJ3tlJ0bB01AucOls9q5MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDkzYjk5NTQzLTA1ZTktNDE3Yi04OTY0LTljMjFhMzQxYzE0ZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZGJjYTgxNTctODg5Ny00YzM5\nLTk4NjEtNTUzOTZmMDBiMTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElsC2\n4GlQ93YZaeQjtzz2kOYHg6eMNY3DCTH2ToUTazusC5Cuhxja7su8kY+zmztlnwGa\n0DS+fSZChuabGcE+cKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFLMN5wW12mM2L2Qu+TnCDAIMBrM/MB8GA1UdIwQYMBaAFOCV\nqLD0Sbbpufk7EiiWRwBjEWUNMAoGCCqGSM49BAMCA0kAMEYCIQCAtYH14awLqakt\nPJmjQurv/9LbgCmrO7nMqsnAR/dD5gIhAIz7bHVUt/rVTcVGEbHk+oiU60H5ISBy\n00STwqL4lgbl\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAcRnxe6MxyIpfx0FNto0mxeWMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZGJjYTgxNTctODg5Ny00YzM5LTk4NjEtNTUzOTZmMDBiMTFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkOTNiOTk1NDMtMDVlOS00MTdi\nLTg5NjQtOWMyMWEzNDFjMTRlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/Ydf\nHpmqYLh8vj4ySvNdh7muAu3xbVa5HxqMrQDO6Apy+n4mmwA4h1X9z6+NOxxZY2y9\nf94yBnWb4+bmKIBJS6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFOCVqLD0Sbbpufk7EiiWRwBjEWUNMB8GA1UdIwQYMBaAFLMN\n5wW12mM2L2Qu+TnCDAIMBrM/MAoGCCqGSM49BAMCA0gAMEUCIEfPpFCKhwLfLvtC\nGYGxRcDtKo/6w8T2dqoJlMTkSpHFAiEArT5s6Io3MEJQQas+ToaC8VFv58Q0aTge\n8AvD7BBw3cQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAdOrWiW5XqXR9LIbN4N8UeNYMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGM1MWFiMDY3LTI1ZDctNDMwMi04YzZiLTkyZDc0MGQzZjJlZTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZGJjYTgxNTctODg5Ny00YzM5\nLTk4NjEtNTUzOTZmMDBiMTFkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElsC2\n4GlQ93YZaeQjtzz2kOYHg6eMNY3DCTH2ToUTazusC5Cuhxja7su8kY+zmztlnwGa\n0DS+fSZChuabGcE+cKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFLMN5wW12mM2L2Qu+TnCDAIMBrM/MB8GA1UdIwQYMBaAFCE9\ncoO04QiYYU6EGV6w3LerQhTEMAoGCCqGSM49BAMCA0gAMEUCIDAtlAVXraAR3NEv\nrvdt+seXseHXkTpqkb+evexwh5x1AiEAmjFsVC2Yeb7BzawudSmb/TojwbOiscC1\nI0JDz2kxjs8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAVYT8RJPM2X1CpnM3mI3F3SpMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZGJjYTgxNTctODg5Ny00YzM5LTk4NjEtNTUzOTZmMDBiMTFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkYzUxYWIwNjctMjVkNy00MzAy\nLThjNmItOTJkNzQwZDNmMmVlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8OTB\nTmfSCSAsGLxPFrOMr+eJgjUHcTbpCAh+Z37McZPX5qDWy0hXsNIO+PsdFsKVha8b\nJ84cvn+d1UwJTEVuxKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFCE9coO04QiYYU6EGV6w3LerQhTEMB8GA1UdIwQYMBaAFLMN\n5wW12mM2L2Qu+TnCDAIMBrM/MAoGCCqGSM49BAMCA0cAMEQCIAvDdefMTvJRarzH\nGKEdX4ciLuhoEK2WG/J09vYose/PAiBxjpFNO++4++n86F1zAAF+oRE3SAWdW4Kl\nacAk+yhh6w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICSTCCAe+gAwIBAgISASHavCp9TYXdmhh6FExwXaFpMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJGRi\nY2E4MTU3LTg4OTctNGMzOS05ODYxLTU1Mzk2ZjAwYjExZDBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABJbAtuBpUPd2GWnkI7c89pDmB4OnjDWNwwkx9k6FE2s7rAuQ\nrocY2u7LvJGPs5s7ZZ8BmtA0vn0mQobmmxnBPnCjgYcwgYQwDgYDVR0PAQH/BAQD\nAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFLMN5wW12mM2L2Qu+TnCDAIM\nBrM/MB8GA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MCEGA1UdHgEB/wQX\nMBWgEzARgg9iYWQuZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDSAAwRQIgbkLhn1H/\nLUEtoDhcrQXsgxHaQBgmnIzNV0ySjkZCz6cCIQCIHveJxp/z770c3h6nv/jf/wMC\ndJmuFNQKMc0DvTxSQQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISARaygBC3dH5BgMSvsPLJgr9dMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZGJjYTgxNTctODg5Ny00YzM5LTk4NjEtNTUzOTZmMDBiMTFkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBSzDecFtdpjNi9kLvk5wgwCDAazPzAKBggqhkjOPQQDAgNI\nADBFAiBCidT1cuqEmqtjVO2C5AcFmo0uXyjH17JFeAUDNqiI7gIhAKxdtpyOy1+F\naT4NVPOeXS1+zkuckNvROUv4GLjpt1dT\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAZ58f5M7xG0StQp4JGyqCGNTMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDE2\nYWM5MDMxLTk0ZWQtNDYxMC04MGU5LWQzOWY0NWFiMmRkMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQzZDU0YjNmOC0yNzE5LTRlZDMtOGExZi01MGRi\nYTExYmQxOTcwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASSY/CloXhmhzKBJxvx\ntpGeMDyZJ8ttR1bIwkxresHS4uN6XRd7VEPhsxvpPXqBKiFjSOXQbulu0bWqT5ZR\neWYlo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQHPqo07a5wv69Vr+H9e4f+aEIDVzAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAK5TBEDiMKGumPZ0\n7hWzK7glTvfI86zOJ+BeSFxJSCVvAiEAmiZePOFEDv3qhioW/i8WSJk2HwiUm5EO\nd3MJHmDaya4=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc77", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `77` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZOEkNg5Y8RBHlcK5dgrHX25MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDU5\nZWQxYjc2LTQwNTAtNDFhZS1iZTE0LTg1YzBhOTc1ZTg3ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDFjZjAzNWNiLWI2NjctNDNhNS04Yjc0LTdkOWJm\nNTMwMmVlMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLuoOkHGgNCqAxes2s1Q\nFO/wOdE2/Gu7/TlCTelxBNJr6cRghyKQbNshfmwFDjWp5GRBJ/9J+GGlAGGhD1MF\nJrqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQIn6tdeZn6fsnRiC5v7DyCmLsuzzAfBgNVHSMEGDAWgBSaVBhkyinb2DcVirRe\nkMPD/cbUpTAKBggqhkjOPQQDAgNHADBEAiARCRXev52+Te+CdDFEqT6OgymuHMvI\nELljKa5o8P8MfAIgIQHEbFd6dtnne8r3yjN9ilXhCkH85h2FOdYq70A4bBs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAW5GJ83fr01rd466GpnzTs8tMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDU5\nZWQxYjc2LTQwNTAtNDFhZS1iZTE0LTg1YzBhOTc1ZTg3ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDhjZGI3MjNmLTg4MDEtNGI5MS05NmM1LWRjYWVl\nMTM1MzViNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPBY2OBNep6yTxRTPKi2\nC/uemOojYLa+Yo6va85qHV/8ky/oMfeKIcMxWxdcW391E337viFBJ+SbfqfgOh+l\n0EyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSBXphtycVBbFThJMFrCByswlZcwDAfBgNVHSMEGDAWgBSaVBhkyinb2DcVirRe\nkMPD/cbUpTAKBggqhkjOPQQDAgNHADBEAiB/8XILrvaN35h0D4Uk1zJU8b8IINYn\nvt3Tse+ptK8ONAIgdjm6GrMPo/QcA2zz/s1xXx5MVYuFcvuIajrEGYCbOP8=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAYPHpkviuA1wIvK1/a5+5ZIXMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDhj\nZGI3MjNmLTg4MDEtNGI5MS05NmM1LWRjYWVlMTM1MzViNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDU5ZWQxYjc2LTQwNTAtNDFhZS1iZTE0LTg1YzBh\nOTc1ZTg3ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHGO6rHXaWHZcuFpF0+5\nACHjapRuty6H9nSn3chRaDZK5NBufM+BDGHmnHy6qsBBqCdlndMQvuNeReB4A2r7\nECWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSaVBhkyinb2DcVirRekMPD/cbUpTAfBgNVHSMEGDAWgBSBXphtycVBbFThJMFr\nCByswlZcwDAKBggqhkjOPQQDAgNIADBFAiBeIMKLZQ5Rh8aaTKtBbcqKfUhjzgA5\nmZZ5YuCZ1T1r2gIhANeLin9R2nsPxCHNy1O8qXXEAUjIUnU3syz5H5HkIucA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVfNrnehft26M77q/aysJwYOMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDFj\nZjAzNWNiLWI2NjctNDNhNS04Yjc0LTdkOWJmNTMwMmVlMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDQ1ZWRlMzY0LTBiOWMtNDNkOS04ZmNjLWQxYzM0\nYTZmNGFkNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGwkOUzFFupkxYWy1qHO\ndM20TotX6MOmiXCNuFh8oKSZmMfy2HP4XHVG8iced+SZEtd3SnMKw9k0vNj627C1\n7NmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTFoIS3/TsMPSYr9+ab2re0Mz2roDAfBgNVHSMEGDAWgBQIn6tdeZn6fsnRiC5v\n7DyCmLsuzzAKBggqhkjOPQQDAgNIADBFAiEA24k2ak+gOEd0Cq9QMlWpQ3JiBGVT\nVeBAdULkbCCYLdcCIHMyMDKdTY20js1xUpPHJP1PnmLfE4RBCfWI7MCfZagU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQP+DhuvbXSnecvouvmHNy/zMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDQ1\nZWRlMzY0LTBiOWMtNDNkOS04ZmNjLWQxYzM0YTZmNGFkNzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDFjZjAzNWNiLWI2NjctNDNhNS04Yjc0LTdkOWJm\nNTMwMmVlMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLuoOkHGgNCqAxes2s1Q\nFO/wOdE2/Gu7/TlCTelxBNJr6cRghyKQbNshfmwFDjWp5GRBJ/9J+GGlAGGhD1MF\nJrqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQIn6tdeZn6fsnRiC5v7DyCmLsuzzAfBgNVHSMEGDAWgBTFoIS3/TsMPSYr9+ab\n2re0Mz2roDAKBggqhkjOPQQDAgNIADBFAiA9p7tRdpdeLY3+zRdPGoAVgU/XUvlm\n3ssDKR3R4DUKhQIhAKRV8E0/Zk33NkTo2r+5q2b2AM8blcBCYRsdkRUJqAHh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZHrNwyq8wTCrbGYy+l5OlnRMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDhj\nZGI3MjNmLTg4MDEtNGI5MS05NmM1LWRjYWVlMTM1MzViNjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDQ1ZWRlMzY0LTBiOWMtNDNkOS04ZmNjLWQxYzM0\nYTZmNGFkNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGwkOUzFFupkxYWy1qHO\ndM20TotX6MOmiXCNuFh8oKSZmMfy2HP4XHVG8iced+SZEtd3SnMKw9k0vNj627C1\n7NmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTFoIS3/TsMPSYr9+ab2re0Mz2roDAfBgNVHSMEGDAWgBSBXphtycVBbFThJMFr\nCByswlZcwDAKBggqhkjOPQQDAgNJADBGAiEAnlM0FIGvpjUdsky/+ta4IsIUJsxE\nKdXEufqQxL4y/x8CIQCKNcSkZQ1SDjDIp1eNMH8RodhxMRyp0Z/VyQ9l/ovD2A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAUC04MrIZV/CKIjRmdSneve2MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDQ0YzEwODAwLWEzMDMtNDU1ZC05NmI0LTMzOTdlYTk5NzAyZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDU5ZWQxYjc2LTQwNTAtNDFhZS1iZTE0LTg1\nYzBhOTc1ZTg3ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHGO6rHXaWHZcuFp\nF0+5ACHjapRuty6H9nSn3chRaDZK5NBufM+BDGHmnHy6qsBBqCdlndMQvuNeReB4\nA2r7ECWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSaVBhkyinb2DcVirRekMPD/cbUpTAfBgNVHSMEGDAWgBTwUASbnCdKHaN9\n8/SMnwWFluZIuzAKBggqhkjOPQQDAgNHADBEAiB2tE2bOPPrvzTVdcZ8zZsbb0Y1\nBQNKTbu9/+VEydMsyAIgON0fVqzDB8LaBVXURHWYImCDG8f0n77FzlsmZCb37mk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISASbDpKKeLUrY9rGdf+2PYZpfMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDQ0YzEwODAwLWEzMDMtNDU1ZC05NmI0LTMzOTdlYTk5NzAyZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDhjZGI3MjNmLTg4MDEtNGI5MS05NmM1LWRj\nYWVlMTM1MzViNjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPBY2OBNep6yTxRT\nPKi2C/uemOojYLa+Yo6va85qHV/8ky/oMfeKIcMxWxdcW391E337viFBJ+Sbfqfg\nOh+l0EyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSBXphtycVBbFThJMFrCByswlZcwDAfBgNVHSMEGDAWgBTwUASbnCdKHaN9\n8/SMnwWFluZIuzAKBggqhkjOPQQDAgNHADBEAiBdwUQCSDZEhFVrzSbxyQl4EmDK\n1iogjNq9FCAogXpEgAIgEtaJFSCCLr5YJ7XOWB8N1TlVyFaORdhp2Z5++G+uCDA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAfZKjfo2MBXKYZUdI9A/HVg+MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJGUw\nZTk4ODM2LTE0ZTYtNGVhZC04NGY2LWY3NmZlYzgwZmQyMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDc4MzIyMTYyLWEzZDYtNDE2ZS1iMDU5LThhNDY3\nMzBmYzA5ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDQ5bxOu5njG8ZSJ87V+\nJdqFm8RBcCbUAw1cbcE2DZBWZVEgy0i5ymewSM4ubX3xR4gxn8s1K6/mFxJ5wzLD\nrrqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQFdL/JElsbVLwQ1YVexkhzBh7eiTAfBgNVHSMEGDAWgBTLHqDsYBWX2TaLaC7A\nzBp/PS6FWjAKBggqhkjOPQQDAgNHADBEAiAkp+4DL/PiTXiw7/1QtgBJfnsFH8Rn\n4SsYOU2Xl2n+ZAIgILUVoqihHHAxrizXfI9a0aDXFvhuK3xut20YZDwbj8U=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVvVqrTX6J0xclWmmjS1cYqhMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDY0\nOGE0MjViLTdlZDEtNDkyOS1iYmU2LTBkMjYwOTc5MDIzYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJGQ1YjU5M2RlLTgzYTUtNDBlYi1hN2RiLTdkMTI1\nYTk5YThhMDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHl/E4zu89MF+NaTIaCZ\nZ2c7gFg+zygjXoHVJpbxlFSI6eJdhtmbRKLmgek61t6xy13GD3CGjOdMIuIEwUp6\n+/KjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTscgSwMqfLEI7ICM63tAk6hh8CqjAfBgNVHSMEGDAWgBT0WhZ1VyBHX5lI8/bJ\nqGzdFAhYQTAKBggqhkjOPQQDAgNIADBFAiA3ROp7MtrsWOdFX4ia/MFdmlTBFcTG\nDZbI7RJoADGBHwIhAL0yIQAObjR/MTeOVnz3n0z/GicHs9M/qE/V7yOX1t02\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAUihnJa/faUxZhQCQbNeeEwKMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDY0\nOGE0MjViLTdlZDEtNDkyOS1iYmU2LTBkMjYwOTc5MDIzYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJGI4OGZhYzlmLWJiMzctNDIxMi1hMjFlLTUxNWU5\nNWM3YmJkZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPFuR1DOugLy9QH9pa6u\nSjrdT3jDMyJJG5KIIuWgcRX7G7Zjl1AWGarMInqnG5z1rsYR06bVO8S4p7tBxCyl\n4Y6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTKJLfjnE/ecGWlco6+UgvA/lqPSzAfBgNVHSMEGDAWgBT0WhZ1VyBHX5lI8/bJ\nqGzdFAhYQTAKBggqhkjOPQQDAgNJADBGAiEA07z6rmjF0exPJdVGSrxM83VqFfGO\nYIoLg6mNoOkEFA4CIQCkuwL7ZXwE9B8q4AhrXPOlvBQvKwAB/qc0J1BOdWvNkw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAYiHj0c6XLKT/vK3jCfkh3ZhMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGYwYjZlZTJiLThiMTctNDQ0My05Mjg1LWIyYjAwN2FiOWY2ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJGUwZTk4ODM2LTE0ZTYtNGVhZC04NGY2LWY3\nNmZlYzgwZmQyMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEv/p4X01or42/At\nvX/g6S2cBwVXhC0tZqh7pI0+zqNpgqqMrl4vyTdEVRlne0+959ymkr0N4Nx57Hhw\nW09kNb6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTLHqDsYBWX2TaLaC7AzBp/PS6FWjAfBgNVHSMEGDAWgBQNpxCanqkkFtFd\n/Q4AueTokCtwrjAKBggqhkjOPQQDAgNIADBFAiBwh/9/n81jzsRq6HQPBCdOt1R5\n3yu3akmGcWCcnDaIbgIhANU538OCH3n3HgudRUMbrzxg8j1I8HO6P9LL104hZq9Z\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAQLkZU8uMwfpqpZPf/cP1rIMMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGYwYjZlZTJiLThiMTctNDQ0My05Mjg1LWIyYjAwN2FiOWY2ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDY0OGE0MjViLTdlZDEtNDkyOS1iYmU2LTBk\nMjYwOTc5MDIzYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPd1HEM/0NLm8Hrf\nfy8GOaZl3N5l4/zU59JO2C2JfybQO/smGZQ8ZmUDo/h/rvoSeQsaXG30gCVZkSPV\nu0u7x/ajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBT0WhZ1VyBHX5lI8/bJqGzdFAhYQTAfBgNVHSMEGDAWgBQNpxCanqkkFtFd\n/Q4AueTokCtwrjAKBggqhkjOPQQDAgNIADBFAiEA6N4XQof1pXIE57ce7rKSmmXd\noLpugWa5cRCPKysS6SECIAK1pnIDglIX/5R23AuVB2SZQN0U1NVDHIOaUsq1lCTw\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASZj13ichQu17q8SbVNbrRjFMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGQy\nZmRlMmQ1LTcyMDQtNDI4MC1hOTgxLTVlYTZhMjYwZTVlYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGJhOWRiNTE3LWFkNTQtNGFiYS1hMWRiLWZmZmRi\nNDg2NzIzZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO+arkm7RX9JX2jPoHHh\n111Yj9hnF3+F8MCgIqBTMaTj7nRJAUG1vXZt41cMtGDNpOkzxctTiwMeavkTN3BW\ntRqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQDUEtnuN+kIDpDdaEiqKfPK2+UNTAfBgNVHSMEGDAWgBTGOPcPUAUYjHft1tQo\nluuRik3YLTAKBggqhkjOPQQDAgNHADBEAiAgzqzpfXmpiq9OKRmm5xLPsf2cBTod\nXJGQkda6Rmb32AIgSmcVV3PqfIr7P5txZbEjG6q0R4Cl9GNGySd07nmxMlg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASzm8bXilBv2msnLpREm7dc8MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJGQy\nZmRlMmQ1LTcyMDQtNDI4MC1hOTgxLTVlYTZhMjYwZTVlYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDNmZDQ0NmIwLWEzOTMtNDdmZS04ZjUxLTg0OGIz\nMWMzZjI1YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABP78DDkGOPE5AwU4zYlr\nNvuz8vFbF8LjW9FkfmDCq4fFcKV+M9eH6xc89/ZmFhEy22uhPPz7TNFQTXju9vFN\ng6mjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRBvm4orpPyDgdoFcC+PLOVJ4esYzAfBgNVHSMEGDAWgBTGOPcPUAUYjHft1tQo\nluuRik3YLTAKBggqhkjOPQQDAgNIADBFAiA1i83y3KCQ9YE6LbsjRR9ILOMAzXTp\nb1S+XWFayT+1TwIhALtX1j1YURLZ8g1JEmNQxqWLcFSL+GoX4dH2LqkRZQo1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaMitOLnflNZ0HLntfdUOessMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGRh\nNzM4Mjk1LTY0YjYtNDVjNS04YjUxLTM0OTY2YzJlYmY4ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGQyZmRlMmQ1LTcyMDQtNDI4MC1hOTgxLTVlYTZh\nMjYwZTVlYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO8NPVtFD7wgfBRtBBXn\nQ4sH0HF5O6A2YwucHDLReqFivyr4yFO7U/cnIWB9GUAgECIsWs0Yko0BRHdQ/EU1\nXGKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTGOPcPUAUYjHft1tQoluuRik3YLTAfBgNVHSMEGDAWgBQjVbrj0nL8JR1h4E9x\nu51TiDniNTAKBggqhkjOPQQDAgNIADBFAiEA+cAls7cRh100/8zGTOsS/BlP0qVN\nszRMR2nSGWeWQokCIFXOdPFlH9N2qwPDEf50qtlEcHEHAb9iOFMt5n4DLq2w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbW4923GvfvtM1EjOmSTPm9mMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDAy\nM2VlYzAzLTAyMGItNDBjNi05N2E5LWQ0NWNiNDdkZjUwNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJGQyZmRlMmQ1LTcyMDQtNDI4MC1hOTgxLTVlYTZh\nMjYwZTVlYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO8NPVtFD7wgfBRtBBXn\nQ4sH0HF5O6A2YwucHDLReqFivyr4yFO7U/cnIWB9GUAgECIsWs0Yko0BRHdQ/EU1\nXGKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTGOPcPUAUYjHft1tQoluuRik3YLTAfBgNVHSMEGDAWgBS4mcmO/LuZcRTk2ZZ+\ns6CjfufDhDAKBggqhkjOPQQDAgNJADBGAiEA8mm01ACkyGw24eEsDCpuefFLTSXW\nx4P96L0Xh/yJ+q0CIQDwvgAIIoZiiuPObojvWgB1wsFyKP6BdSHA91pjX2d50Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWgD+ECSdro2yAF4uXM69TPGMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGRh\nNzM4Mjk1LTY0YjYtNDVjNS04YjUxLTM0OTY2YzJlYmY4ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDAyM2VlYzAzLTAyMGItNDBjNi05N2E5LWQ0NWNi\nNDdkZjUwNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABB4xQx5cIfuAtSrOc92j\ntB23r9XuZhpEJ9nPoZLXLFP9czhL2hBgIczw9C8d7veIa8nMM00wIxceILf56fPf\nznKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS4mcmO/LuZcRTk2ZZ+s6CjfufDhDAfBgNVHSMEGDAWgBQjVbrj0nL8JR1h4E9x\nu51TiDniNTAKBggqhkjOPQQDAgNIADBFAiEAwDc3F0Ups2IezZfkSXfdAc3Aj2oX\nl5Z+1+07bSpqzXECIChN9bQGtSLVnCacUDkDIR7tmKvrNocEOVALI8Y6P0nQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaSGUSgNNTmpmrAhltvgBR7yMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDAy\nM2VlYzAzLTAyMGItNDBjNi05N2E5LWQ0NWNiNDdkZjUwNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGRhNzM4Mjk1LTY0YjYtNDVjNS04YjUxLTM0OTY2\nYzJlYmY4ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAs563CuHubDaaBhXcfZ\njdBZ0HOhlsGQxUsHmVG21ICVdDHQUeSbXKyYGD39/TX3xfCRzp7rvIj6TV8vsq9o\nexejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQjVbrj0nL8JR1h4E9xu51TiDniNTAfBgNVHSMEGDAWgBS4mcmO/LuZcRTk2ZZ+\ns6CjfufDhDAKBggqhkjOPQQDAgNIADBFAiEAsiLzjjMzPTJFWAke2dBhJtBs+LN9\n7MaHiH3chlOvhMYCIEkoQgl9sE7uUiC3sn1qWtDqYUIOUtzjJSfP40HMyTH2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAd+yuPp5ToFFWEbxyhnn1ErCMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGZhZDM0ZmMwLTdjMmMtNDA5Zi1hOWYyLTI4OTVhNDBjZTA5MzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJGRhNzM4Mjk1LTY0YjYtNDVjNS04YjUxLTM0\nOTY2YzJlYmY4ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAs563CuHubDaaBh\nXcfZjdBZ0HOhlsGQxUsHmVG21ICVdDHQUeSbXKyYGD39/TX3xfCRzp7rvIj6TV8v\nsq9oexejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQjVbrj0nL8JR1h4E9xu51TiDniNTAfBgNVHSMEGDAWgBTGDEfdQCv60NcX\nNvUTQwkLRFhfVDAKBggqhkjOPQQDAgNIADBFAiEAvzSSU5iYe2VfZcinIdiba19i\nfvm+qiqFXZiIxoOCdZECIFdKxsUSjUaDOscG62+H7IzSgNbe+Pd7QX+Hk0LtKl7S\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISARF06Aha6oNYBWAIh5Dqh9cJMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGZhZDM0ZmMwLTdjMmMtNDA5Zi1hOWYyLTI4OTVhNDBjZTA5MzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDAyM2VlYzAzLTAyMGItNDBjNi05N2E5LWQ0\nNWNiNDdkZjUwNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABB4xQx5cIfuAtSrO\nc92jtB23r9XuZhpEJ9nPoZLXLFP9czhL2hBgIczw9C8d7veIa8nMM00wIxceILf5\n6fPfznKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS4mcmO/LuZcRTk2ZZ+s6CjfufDhDAfBgNVHSMEGDAWgBTGDEfdQCv60NcX\nNvUTQwkLRFhfVDAKBggqhkjOPQQDAgNIADBFAiEAzRw/3rKabtfTd3ni/Q6Pnw5p\nkJ4iHtfu3aTr7oeaQxoCIFZiqMjnd3XsHOvnkp8lpH3C1PdvmruEaha1OI7i4HlO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQlr6RVQdwrl0TOMJQvLEA0NMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJGFj\nNzA1MjcwLWUxN2MtNDk5ZC04N2EwLWFiOTE2NGJjMjQwZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGQwZDUwNzY4LWRiY2UtNDBkZC1hNTBmLWMyZWMz\nN2UyZTVjNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMJ92ze3PuCu4K2oEmVo\nbLUXziU0iS436MvlxOAADfGLEFDowsh12pUnPAnoe/p+msbvjSzc6AsqMzeTZMG6\nLdCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRyeu4TK5lMwaXnXcHkJcBoVJeeQjAfBgNVHSMEGDAWgBS8muGtPpKPfz3SJtga\nEkI/HYGTnzAKBggqhkjOPQQDAgNIADBFAiAolj6HVefh0MfQhPkniYHE76JL0JT0\nNmLG36ZnuLpTvgIhALF9zbXmPT0MV+l2x7tJnS2g+TbEcbUrV5yZEKxpgN1/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcz9aNxq0lrxO6wXrTY/Fs9uMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDFm\nMGZmYWNmLWQ3MmUtNDA3NS05ZGFkLTMyZGMxY2I4ZGQwNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJGFjNzA1MjcwLWUxN2MtNDk5ZC04N2EwLWFiOTE2\nNGJjMjQwZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFDM+zFf7OSMv1GUrgtm\n5CY8F5KEpExgFFG72Z7qEE4Zo7Y4y4qvMuG9W5FjvammPtkjigMBXoYKCFHfcY2P\nQJmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS8muGtPpKPfz3SJtgaEkI/HYGTnzAfBgNVHSMEGDAWgBRNtMO4o9kWFoVXqxeR\nP/T3/0BuvDAKBggqhkjOPQQDAgNIADBFAiBG50d246LzdG4wQ75w9YNfOH7SmNGr\nVgfVeXDInraPSwIhAMB5GNBVZB8ZCde5OlppxtbtW/y0+NXNYNqC28QIup0U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAa+PlO3SmYFwDUnNqUUR77okMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDFm\nMGZmYWNmLWQ3MmUtNDA3NS05ZGFkLTMyZGMxY2I4ZGQwNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDk0OTIwZWY4LWFkMDYtNDUxYy04ZTZmLTE1ZWVl\nYzdhZTIyNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFuF5d8cDpBxHZoGyqfj\ncdN8CQKX1KFIhEORwqMlLpXeXxQyDwYTq1h8NoipWwQL6+valQwgkNa/kR8N19tV\naS+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSXrp4qmARVorzD/WqNGH6qwP6h4TAfBgNVHSMEGDAWgBRNtMO4o9kWFoVXqxeR\nP/T3/0BuvDAKBggqhkjOPQQDAgNIADBFAiEAuJ51ZkVQYD5lSzioYf6vbx8Atlq2\n12ipPgdL7GAUaDkCIELqOJHuzczsNUD4FEkcHvqz535xdv/Ds121WyR0owdZ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUhVqtd3egK8vfFhlbV+fImBMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJDIx\nOWFjYjZhLWQ3NjQtNDJjMi04NmJmLTQyYzVmZTA0NWI3OTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGQwZDUwNzY4LWRiY2UtNDBkZC1hNTBmLWMyZWMz\nN2UyZTVjNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMJ92ze3PuCu4K2oEmVo\nbLUXziU0iS436MvlxOAADfGLEFDowsh12pUnPAnoe/p+msbvjSzc6AsqMzeTZMG6\nLdCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRyeu4TK5lMwaXnXcHkJcBoVJeeQjAfBgNVHSMEGDAWgBSk6kn/rDljwLrLGE7z\nYkC2sPIirjAKBggqhkjOPQQDAgNIADBFAiAGcTuah+22o5RbWecp6WbZG7YISs2s\nQJXezAeXDsihLwIhAKvDHyffYaoUu95a/C9fguXPzFYvdW6ISoJtpHMnsYbn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAeVjqVMySTChHfqxivQ2SpwTMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQxZjBmZmFjZi1k\nNzJlLTQwNzUtOWRhZC0zMmRjMWNiOGRkMDUwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQIJeDEOwTVFWOnHlwVN47b7/n+KRPmBxTC1tS/6A7Qd85ymnYXTURDf/KD\nEcGItsu7BYhSTRH3uz/yE3702/oPo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUTbTDuKPZFhaFV6sXkT/09/9AbrwwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgbhwD\nsN9RwSiCWbro5+cGR8gWqwT83dU1oUHfaRayX10CIQCSxbozH0ISqJQJuqNK89Ki\nW9tjdVzbOT8qKfNGCPvy0Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAcmr3jSUYKq6hJVuurk3i1w+MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyQyMTlhY2I2YS1k\nNzY0LTQyYzItODZiZi00MmM1ZmUwNDViNzkwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAARVwg4Qx3YWr4WLPyL0QQENGpRfRNBq+gudlHNHUiU8QXDbHZcNP8r2Zwj4\njFTv6rMCurweOAt8BaN0CQ7eH7UZo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUpOpJ/6w5Y8C6yxhO82JAtrDyIq4wHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgFo3u\n7Daqxjq3tpVEnO3ZevAiY1D8szmyFDg/NucerWYCIQCTLwCaYGn1eLtZE4HfKjpO\naDAnGvlXxqPu4x/u6shzaw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAY9mqnM6Q1OqyBe3FdtKPZFXMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDQ0YzEwODAwLWEzMDMtNDU1ZC05NmI0LTMzOTdlYTk5NzAyZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZTEwMzdkYjctMzlmMy00MTY3\nLTlmZGItMTI2OGExNTA1Y2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE61Gv\ng8i9tUQDILxk26UtbAo4EvtxvsxACSFcLdOpJ62qJt5ahD/rUDIe4HOn7mvRRQhM\nr9WpPc+eCLSHheQwiaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFMEGRRtRpUEzC5duP+L6SxbkbcStMB8GA1UdIwQYMBaAFPBQ\nBJucJ0odo33z9IyfBYWW5ki7MAoGCCqGSM49BAMCA0gAMEUCIQC5oytoc8gps9eh\npq2EQKkHsCqZnKOSh8MNSw073CjqMAIgNXFm2Z4Fn9oVqk2QCAY74qWBTIq3/aUN\n+KcsfL8OeZ0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAfDvzL1Lh5phkbriKdlF7xzbMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZTEwMzdkYjctMzlmMy00MTY3LTlmZGItMTI2OGExNTA1Y2ZiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkNDRjMTA4MDAtYTMwMy00NTVk\nLTk2YjQtMzM5N2VhOTk3MDJkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElSB1\nIA8n5jQ+2YrPVXruv5zNzAmcy2SHefX5ak2aR5BnHnTbIw8rmdfXuTWzBA7mbdxd\n15bx9Sd4CRsW/f86zaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFPBQBJucJ0odo33z9IyfBYWW5ki7MB8GA1UdIwQYMBaAFMEG\nRRtRpUEzC5duP+L6SxbkbcStMAoGCCqGSM49BAMCA0cAMEQCIGGx9mIpqfYLOP9v\n+ykpQsRUhnoYjbmOJqd3uYlGnmOQAiACMZTYnnpI+uZN4pDsfImxK7Ub0Ju3QWmL\nCgAt8OKi7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAXROrGMGN10v7S2Y1empCFZHMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJGYwYjZlZTJiLThiMTctNDQ0My05Mjg1LWIyYjAwN2FiOWY2ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZTEwMzdkYjctMzlmMy00MTY3\nLTlmZGItMTI2OGExNTA1Y2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE61Gv\ng8i9tUQDILxk26UtbAo4EvtxvsxACSFcLdOpJ62qJt5ahD/rUDIe4HOn7mvRRQhM\nr9WpPc+eCLSHheQwiaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFMEGRRtRpUEzC5duP+L6SxbkbcStMB8GA1UdIwQYMBaAFA2n\nEJqeqSQW0V39DgC55OiQK3CuMAoGCCqGSM49BAMCA0cAMEQCIBcXRogZqin2UW0h\n5bN5Kg9DTmEuhB3MBqqAYWlujWb8AiAE8wvQ6S30jD2S2LmEjgbILQTWNvkd0A32\nWnANYHb0fA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAesjKt/UPwiPNP5THS7XSl+qMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZTEwMzdkYjctMzlmMy00MTY3LTlmZGItMTI2OGExNTA1Y2ZiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkZjBiNmVlMmItOGIxNy00NDQz\nLTkyODUtYjJiMDA3YWI5ZjZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtZh+\ngToqDL8FQp5l7VcMBsY5npHSSpC+2F30pIq8Hoja/XW8l+hY4bU8ZfMbucLG5eVR\nC1sjVqLE5ZaSutIVN6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFA2nEJqeqSQW0V39DgC55OiQK3CuMB8GA1UdIwQYMBaAFMEG\nRRtRpUEzC5duP+L6SxbkbcStMAoGCCqGSM49BAMCA0cAMEQCIH2J+2qjnnpQhH0S\nTn4v38qu0W28FGBq6nuZbvXCwW2RAiBtUsF6S5x8C3XoUtiVbxVJeYFcLnb+WKDI\nq6oIfsKQTg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAcTetaGkbP4MpTZpjVcpCaMSMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGZhZDM0ZmMwLTdjMmMtNDA5Zi1hOWYyLTI4OTVhNDBjZTA5MzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZTEwMzdkYjctMzlmMy00MTY3\nLTlmZGItMTI2OGExNTA1Y2ZiMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE61Gv\ng8i9tUQDILxk26UtbAo4EvtxvsxACSFcLdOpJ62qJt5ahD/rUDIe4HOn7mvRRQhM\nr9WpPc+eCLSHheQwiaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFMEGRRtRpUEzC5duP+L6SxbkbcStMB8GA1UdIwQYMBaAFMYM\nR91AK/rQ1xc29RNDCQtEWF9UMAoGCCqGSM49BAMCA0cAMEQCIHy99UsZ/ifJfGiX\noG2hoeSnp2Qn0D2aA23Z37UtyqI3AiAhABj4gBC6Zzb+ItWQWfyDS53yKHZaT73t\nVp3S+mqWiw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAeVhoRV2St67LpAfkK0mKIl4MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZTEwMzdkYjctMzlmMy00MTY3LTlmZGItMTI2OGExNTA1Y2ZiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkZmFkMzRmYzAtN2MyYy00MDlm\nLWE5ZjItMjg5NWE0MGNlMDkzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC3Nd\ng0YUwe8qAz4wBdjd7BG6AlUMba4H15Pf//ZYGwezr7/57TYvkOlP4Uv9O1GpnABh\nDFWbmWg0Ii7FE+pzcaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFMYMR91AK/rQ1xc29RNDCQtEWF9UMB8GA1UdIwQYMBaAFMEG\nRRtRpUEzC5duP+L6SxbkbcStMAoGCCqGSM49BAMCA0cAMEQCIBCTY/M7RQRxrqTX\nrEtugnHOjsW/YFEZabip8iE3cMAZAiBQ+/Z1soLuNhF2g6YuRTn1db1SPEf5AHq7\n/pl2XqHzrA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICOTCCAd+gAwIBAgISARVimoxiiuKQL6uwE5SS5+p6MAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJGUx\nMDM3ZGI3LTM5ZjMtNDE2Ny05ZmRiLTEyNjhhMTUwNWNmYjBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABOtRr4PIvbVEAyC8ZNulLWwKOBL7cb7MQAkhXC3TqSetqibe\nWoQ/61AyHuBzp+5r0UUITK/VqT3Pngi0h4XkMImjeDB2MA4GA1UdDwEB/wQEAwIC\nBDATBgNVHSUEDDAKBggrBgEFBQcDBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTBBkUbUaVBMwuXbj/i+ksW5G3ErTAfBgNVHSMEGDAWgBRKZpybC/QdC4UAGhzt\nhLhrgjvY9TAKBggqhkjOPQQDAgNIADBFAiEAy4qDYhZ71qCpy0fGnlaXL97RX1vo\nWDi1ZgYWb4MuUqwCIAWeUVCovDjWVcVkYKoOjvJb3hZyjVDvUEqoy/CBXguy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIzCCAcqgAwIBAgISAUO7wSDSR+CuAHozeK0LbvGzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZTEwMzdkYjctMzlmMy00MTY3LTlmZGItMTI2OGExNTA1Y2ZiMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBTBBkUbUaVBMwuXbj/i+ksW5G3ErTAKBggqhkjOPQQDAgNH\nADBEAiAdyiA06K46e0LErOyJDUEQeJg+eqOISqdeZvtGCp5NuQIgQV3ezGmlTa60\nUheuI3hKjzSr0uAesUmR4Rz3n0ALRGI=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAS7OihP8CKOaU2dz5Myzw2XeMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJGQ1\nYjU5M2RlLTgzYTUtNDBlYi1hN2RiLTdkMTI1YTk5YThhMDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ3YzE1YzRiYS1jYTNmLTQ2NTItYjQzMi0xZmU2\nZTg4NDRmZjYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATMOdXttDF2V05qR0s8\ngNqJHOlYIJTPMwQxWdWRVTrLUQdnvtHzGkDSrvZOmO9zlHg2+728Atxt7Bn7+Urj\nf/PLo2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTscgSwMqfLEI7ICM63tAk6hh8CqjAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAKofbqFCo9G8zRgb\n7CpgNV0dcJiPKgj6U2d/sulis0GBAiEAjaCmcoc2/+iEOzzKME7BFA/WDHx4LwEA\ndZFZpSW+xuU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc78", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `78` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAW2MoIWsJ0bhBoOUQhv/7rmyMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDFh\nMDQzMzhlLTUzMDgtNDM0NC05OWM3LTU3ODM5YjEyNjk2ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDQ5NGY0OWY1LThlMzMtNDcwYi1iZmNhLWM2OTBm\nNDYxNDk3OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIKcNQh6+rqvSajaQgg4\nSOvkglXHMu09XOIdmJZ+/mYDxxDsb+IX9Wz+nGoxZEVInr06vyTAl8p6P3PlStr6\nji6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS4Ix6D50lB07aPuyPHWu2Q2+s36zAfBgNVHSMEGDAWgBQO+Xz5XQH+3Wb7AR5m\nZzuBfaW/YjAKBggqhkjOPQQDAgNIADBFAiAaUMx93Ew6z3hw8c4pK0tLVnLn4+cw\nuT1smWfUU9lwuwIhAIADNFHRX1KU2joq/onfJhgul7Wsp+BbtTEXvyvSBUod\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAWLMDZ/7YvevnsmG/bQqYED5MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDFh\nMDQzMzhlLTUzMDgtNDM0NC05OWM3LTU3ODM5YjEyNjk2ODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJGY0NTYzODNjLTZiNzctNDAwYi05NGE5LTZjOTVh\nMDZkNmEzNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKVWitNh0YOHjIIWKdtP\nFC3+4RB/wN2LWW7eszFDnj7BGCMGDrWblpQOWyW0o5Mfv34llCAsFGVQvLud2Jog\nAcajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS9RyOhnkrtnTYCgM8loPdXYsCRAzAfBgNVHSMEGDAWgBQO+Xz5XQH+3Wb7AR5m\nZzuBfaW/YjAKBggqhkjOPQQDAgNJADBGAiEA8neFx+fCNDfCXCMZ+QB6BBua28E8\naTJta7dpDyLIC4oCIQDGf+bVIMDovm73DT5v1sinGAnKLEs+iawUArcf04pzmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVArMKJGCxa6gOtG0rqnlfFIMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGY0\nNTYzODNjLTZiNzctNDAwYi05NGE5LTZjOTVhMDZkNmEzNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDFhMDQzMzhlLTUzMDgtNDM0NC05OWM3LTU3ODM5\nYjEyNjk2ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGrXidcBVMxIqczasRgJ\nhN+0JwC02Jp+dVGuGkfM9aXEE4bOI/1AvbrAZoxXsV0iUFTzBIaHgI4rMt3YHSYw\nZmWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQO+Xz5XQH+3Wb7AR5mZzuBfaW/YjAfBgNVHSMEGDAWgBS9RyOhnkrtnTYCgM8l\noPdXYsCRAzAKBggqhkjOPQQDAgNHADBEAiBfSoSt4kfLRG+FZmilWOLpynyvOJFQ\n68/mGR+EWsxUuwIgU9uTvPQJFI+ps5khyDHoKwrLyWPh+8wmwd1miyFvqxU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISATVH55MPCWWon6CaN08Udjz/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJDQ5\nNGY0OWY1LThlMzMtNDcwYi1iZmNhLWM2OTBmNDYxNDk3OTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDE5MTBiMTcwLWFiMTgtNDBkYi1hYzc2LTQwMGM0\nODE4MzA0NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHkGOKtN5ZMD4rk9bnNu\nOfY1y54M/Z2kIbtelu/WiOiIL/3O177ifox1Yy5+B5FwhpEFfJ8LJeR3jy5aN005\nfYmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR5SUuNcOPV1YMLwTPzVEYJ6/IwDjAfBgNVHSMEGDAWgBS4Ix6D50lB07aPuyPH\nWu2Q2+s36zAKBggqhkjOPQQDAgNJADBGAiEAj3EM2fU4UCkUtu6T/nIXi7BilWT+\nox/rhHxRJcMWQbkCIQCNcV7gUAooiwmJHOfWq+L4w6TK2cz+/YdVRIWYz+GKSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWT3zuO6XTDcPm7I/S8nRI0WMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDE5\nMTBiMTcwLWFiMTgtNDBkYi1hYzc2LTQwMGM0ODE4MzA0NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJDQ5NGY0OWY1LThlMzMtNDcwYi1iZmNhLWM2OTBm\nNDYxNDk3OTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIKcNQh6+rqvSajaQgg4\nSOvkglXHMu09XOIdmJZ+/mYDxxDsb+IX9Wz+nGoxZEVInr06vyTAl8p6P3PlStr6\nji6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS4Ix6D50lB07aPuyPHWu2Q2+s36zAfBgNVHSMEGDAWgBR5SUuNcOPV1YMLwTPz\nVEYJ6/IwDjAKBggqhkjOPQQDAgNIADBFAiBiC2MSE/X+ZSAZwzTq6tHKnx3NZdIc\npkTjjiHa8d/N4AIhANLdVsXBd33psB6C/IEIr8Quh0WwJXnAIMOwo9N550b8\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAaN1bLNwid6F5/2wCqj6JNAvMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJGY0\nNTYzODNjLTZiNzctNDAwYi05NGE5LTZjOTVhMDZkNmEzNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDE5MTBiMTcwLWFiMTgtNDBkYi1hYzc2LTQwMGM0\nODE4MzA0NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHkGOKtN5ZMD4rk9bnNu\nOfY1y54M/Z2kIbtelu/WiOiIL/3O177ifox1Yy5+B5FwhpEFfJ8LJeR3jy5aN005\nfYmjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR5SUuNcOPV1YMLwTPzVEYJ6/IwDjAfBgNVHSMEGDAWgBS9RyOhnkrtnTYCgM8l\noPdXYsCRAzAKBggqhkjOPQQDAgNHADBEAiA3+r8Zdpc9Gzs6U4zFEIGlILV4X27d\nBEtOIgbmOCzZrAIgPeSaPlGnZZXjmDUCMCv8DAm8M5BhmdUYZGBGIStB/Qc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAZCxEb8l54WESaO3IbFnfS+AMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGM4MTQ5Njc3LWM3MzItNDdiZS1iNGExLTFmMzMxMDFiNmNlMTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDFhMDQzMzhlLTUzMDgtNDM0NC05OWM3LTU3\nODM5YjEyNjk2ODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGrXidcBVMxIqcza\nsRgJhN+0JwC02Jp+dVGuGkfM9aXEE4bOI/1AvbrAZoxXsV0iUFTzBIaHgI4rMt3Y\nHSYwZmWjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQO+Xz5XQH+3Wb7AR5mZzuBfaW/YjAfBgNVHSMEGDAWgBT37+hmRIzP6fFI\nUQDFds+veGjtWDAKBggqhkjOPQQDAgNIADBFAiB8nkUL5nLjaOLHq5j5ijeHIX5m\nPDLY45Cz6iKq8fDwtQIhAJzzE67I+iEpKhTbGSEvoF6q0HtmdC1X4mc1qBxmPqN7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAY1IKQc8MSaxgiiSJ1p91sv3MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGM4MTQ5Njc3LWM3MzItNDdiZS1iNGExLTFmMzMxMDFiNmNlMTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJGY0NTYzODNjLTZiNzctNDAwYi05NGE5LTZj\nOTVhMDZkNmEzNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKVWitNh0YOHjIIW\nKdtPFC3+4RB/wN2LWW7eszFDnj7BGCMGDrWblpQOWyW0o5Mfv34llCAsFGVQvLud\n2JogAcajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS9RyOhnkrtnTYCgM8loPdXYsCRAzAfBgNVHSMEGDAWgBT37+hmRIzP6fFI\nUQDFds+veGjtWDAKBggqhkjOPQQDAgNHADBEAiBHFI7/VZu5GDVraDb0LADaL867\nl/eUDbHDo1+/GEFb/AIgIem/g+G65aXipLC20TPUhJWAy/bekWNbCffDGIjofbw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVHyx4eW6bI1z5jTONE/X80qMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDJl\nNjExZDE3LTU2ZTAtNGQ2My04NTY4LWFiNzliZmU0YWYyMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDhmMzJlODc3LWE3ZDYtNDlmYS05NzRkLTVlYmI2\nYjY4Mjc3MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKr667vxyUAEh+Oty5zX\nNPlf+RrKw7iJw3PGgnLyACSnLhJ75+uu1NQucc0a16Qe1UtY/FWNtw0/G1Jb8emb\nM46jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQPgZAQRTXDLevzSBjFAz5UkYZuHzAfBgNVHSMEGDAWgBTi8Az12voa3Yee00mG\nNcYhB4JT3TAKBggqhkjOPQQDAgNIADBFAiAaTMh4gfWmxM9nsEPo78wlHGpFj46x\nh8keTUW5xcyYcwIhAMttw/mXrUP9Kw0wB2Dnm5MpKSQASov/19mhViXpMnoB\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASX8dASrKWdh4JzxQkn0dtNpMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDQ2\nODE4Mjc3LWE3YjktNGQ3NS1hNjBlLTA1Y2U1MzBkNDkxYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDZmZGUxZWEwLTljZTctNDUzMS04OTRlLWQzMjIy\nZmE3ZmFmMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPJLqzdod8JBGTEp4VDd\nqFnxQoBUt1TAYLa599nQkvQY9LIDob1GN/Slpu+eVr6g5MgM5xfRvMklZI/eWtKe\n3jijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRdABurn4XUPlEoRCdJh8f5/5PI2DAfBgNVHSMEGDAWgBS2GOGjwTenxG6+/i6H\ntTvYdEkwLjAKBggqhkjOPQQDAgNHADBEAiBBbmCV9vaEdftpgVjadMNQ/xCCAFOY\nrVZqDobTQfYRpQIgW5qZJ7Zf79yiTbHFQoKe5ucyacJ8s3YL8SBmnITmi9Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWS8BDRR8ux0bVxoRpzPXcPYMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDQ2\nODE4Mjc3LWE3YjktNGQ3NS1hNjBlLTA1Y2U1MzBkNDkxYjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJDA4MDVhYmJkLWM5NmItNDExMS1iOGQ2LTUxYmYy\nZjJmZmY3ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBkobsqoLlzg7/R5Cx9a\n/oxK3kBfYQMj/QvSsZopZ5JiY1D7WZNeqPqhyRPlXEnyusJHEGpHNeYMu/uPASOu\nW6qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRZsfEWvigmHwNUcdPB5FGj03VDnDAfBgNVHSMEGDAWgBS2GOGjwTenxG6+/i6H\ntTvYdEkwLjAKBggqhkjOPQQDAgNIADBFAiEAuNffJaFeuAbcepT+/bVjEQiW1wAZ\nNHtI2FHpNoQJYe8CIH1totcNolyd5HDvVBuM0xffsrIHV7CVy6bvGIIltUYV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISARtINPVajcMZs7XTCz7lMskUMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDg4ZjIxNmU4LTFkNzgtNDAxZi05ZWVlLTg2MDkxMDk3ZjhhNzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDJlNjExZDE3LTU2ZTAtNGQ2My04NTY4LWFi\nNzliZmU0YWYyMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABM/s81euxbNGHkB2\n0UM6aGGOFISlbRLv3XeB4uVcja4sHj4D89nbznilmp7r1f4QGJOyqSAnL2DZIcgF\nnExZX5OjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTi8Az12voa3Yee00mGNcYhB4JT3TAfBgNVHSMEGDAWgBSIz6KrKk6Y5Fir\nwRptj6f4VKVlGTAKBggqhkjOPQQDAgNIADBFAiB3Jq3cKH/hkUVibYo9TwDf6r+/\nzHIG3YxZAkdj0VX7AQIhAIwnzXEfNZ7Uer8VRmnN+/28KMrlVcO1FwqkcyU4fWgp\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAbGFKItz6NOJp0Lnf0CkkK1vMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDg4ZjIxNmU4LTFkNzgtNDAxZi05ZWVlLTg2MDkxMDk3ZjhhNzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDQ2ODE4Mjc3LWE3YjktNGQ3NS1hNjBlLTA1\nY2U1MzBkNDkxYjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIB/Gbxk5BTW6Smh\noebaopqFzRNv1HY4NEZ+ZL1jWkh/9b2xo5pMBZ2UBLnqRoKVNfnPdcDFBEcg7hqq\nTrFb+hKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS2GOGjwTenxG6+/i6HtTvYdEkwLjAfBgNVHSMEGDAWgBSIz6KrKk6Y5Fir\nwRptj6f4VKVlGTAKBggqhkjOPQQDAgNJADBGAiEAzDBfIWQEvq0gjOakiT0AHiiE\n5HU14JALDB+odlSjsugCIQCM/5Qn7aWLmmGducac/XmQEK1cWbyDUx3QIvqCIkoT\n7Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAaP9Mn4Gim1T0YUFfQnuQv2yMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDI3\nNGRkMTA1LWNhNDMtNDA2Ny04MDZiLWUwMTc0MGY3MTIxMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJGNlYzcyNThhLWYxMWItNDQzNi05NmUwLTIwY2Ji\nODU4N2UxZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMWSTn8r0tXFneZzzwrB\nvRcMrRDl0pJyAIWEKUkKc3AEOkTfo2WjZwg1PQuTDSucOOEgqB2Bf2gEMJHEDRmY\nwaqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBS262BZalUrBleI4N+5eUskLZyNJzAfBgNVHSMEGDAWgBR2CKTu21HrWKmRtIIL\nKTOUIUpz0DAKBggqhkjOPQQDAgNIADBFAiEA1UTVInXITzVMiUjPJyCFPLN6onMR\n3PFvPXDZw7lP2HACIFu2pAFYG73cyNNcCuow8KIqSe0+ti2ykJFBl0GYouQh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZ5olRl3c4ey23SypLfuYbjsMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDI3\nNGRkMTA1LWNhNDMtNDA2Ny04MDZiLWUwMTc0MGY3MTIxMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJGE5NDkyY2NiLTQ3ZjItNGY5ZS1hM2RjLTJmM2Vl\nYThlMGE3YjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJW6++FRAdVeFtOZy6ix\nNYtbz3fFBKwnfF0Gc2QnxuS4xoSFtqpvoGXLmsnBW/fiFqeDmrgFXZtn4p003T6O\n/FCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTcpA1OaMEngSqXY9y5IxmubSNr1jAfBgNVHSMEGDAWgBR2CKTu21HrWKmRtIIL\nKTOUIUpz0DAKBggqhkjOPQQDAgNJADBGAiEAnpB6WCQ+KryssxxJ4+UNQCQ00XIv\nbmB3VKS0//DpEx0CIQDp45cc65Jh/8Ut0Ja78CgOpns7UTOWLM5kDFDXwTHOHA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZwYOsxLz3+cPEIOfiWQDFO9MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDJm\nMzRlMWY2LThjNTgtNGJhYi1iZDBmLTJhYTQyZjU4MGVhYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDI3NGRkMTA1LWNhNDMtNDA2Ny04MDZiLWUwMTc0\nMGY3MTIxMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOLr85R/wdFLmRN17Aia\nokB6VWR48R2MetJ9B0zRQXcPMDXzW7IY1BXWqbgB6ZRRZoGtqQQewH6e9h5n4A8p\n3XOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR2CKTu21HrWKmRtIILKTOUIUpz0DAfBgNVHSMEGDAWgBQWh0JWu0P48WQJ2Ic2\n5Hqr0wNQ7zAKBggqhkjOPQQDAgNIADBFAiB9oyIY0LQy+kiv81fnY66hgp58uZ+X\np9eNHuDTe+7z8gIhANz6ej18z/yoTlvkpnVxxlu3y5OIsnMVNp2UMZXOHXcO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXhulNO8wSCa8jgiXcHQy8WVMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDIx\nODFhYWY2LTYxOTItNGFlNC1iY2UzLTViM2VlMzZkNDdlMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDI3NGRkMTA1LWNhNDMtNDA2Ny04MDZiLWUwMTc0\nMGY3MTIxMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOLr85R/wdFLmRN17Aia\nokB6VWR48R2MetJ9B0zRQXcPMDXzW7IY1BXWqbgB6ZRRZoGtqQQewH6e9h5n4A8p\n3XOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR2CKTu21HrWKmRtIILKTOUIUpz0DAfBgNVHSMEGDAWgBRypuSprP/iiS9Dsr2Z\neKfik9SM2jAKBggqhkjOPQQDAgNHADBEAiAKp8gVHIlkzRMnYJfzafiqCptb8RCn\nHOmMmA8K0Ud/owIgWmJIA70wjm/Hqu+uMN7BBfGTSSkNiN1ZhaybZrFkcrw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUHll34flJf292Sg6ugi9+t+MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDJm\nMzRlMWY2LThjNTgtNGJhYi1iZDBmLTJhYTQyZjU4MGVhYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDIxODFhYWY2LTYxOTItNGFlNC1iY2UzLTViM2Vl\nMzZkNDdlMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEGfy2X9TwheCrPVmQM3\n4h/0gRC7xDzKom9khDl1NNvfk5xCgF2vidEeHUDL7jDMPl7Yejl73dca97HAgQSM\n6lOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRypuSprP/iiS9Dsr2ZeKfik9SM2jAfBgNVHSMEGDAWgBQWh0JWu0P48WQJ2Ic2\n5Hqr0wNQ7zAKBggqhkjOPQQDAgNIADBFAiEAyG6v0o3jadbC2MdBUcn7hBHXATe7\nWQp7k+Tm9/yNH2ACIEyKTWjBwk/DTZ4uD/rSbK/IkoD16okEbN3sqauUdyoX\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAX8ZqT6te0LClhrpCwIGsO1VMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDIx\nODFhYWY2LTYxOTItNGFlNC1iY2UzLTViM2VlMzZkNDdlMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDJmMzRlMWY2LThjNTgtNGJhYi1iZDBmLTJhYTQy\nZjU4MGVhYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOsCMcJLr2S2yA6GTspe\nCYWPk7IOB5hcFd7C6482szft6YNO3zMdTpsfr92KFl5k/ttcxb6ah4NuqqJVg6XX\nvlSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQWh0JWu0P48WQJ2Ic25Hqr0wNQ7zAfBgNVHSMEGDAWgBRypuSprP/iiS9Dsr2Z\neKfik9SM2jAKBggqhkjOPQQDAgNHADBEAiBIjFKb4rmBv9LRRfNQtVod++k8JB00\nW2fxedhn575ymgIgM9S9ylPBMVJlN/U7hsPGRUNmlkJp4/63vT6g/rI23RA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAXDpvRAS+208YCJk/HHlBVl6MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGFhNmE1MmRhLWY4NDktNDcwYi1hMjMwLWE4OGU0MzFlOTg3MjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDJmMzRlMWY2LThjNTgtNGJhYi1iZDBmLTJh\nYTQyZjU4MGVhYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOsCMcJLr2S2yA6G\nTspeCYWPk7IOB5hcFd7C6482szft6YNO3zMdTpsfr92KFl5k/ttcxb6ah4NuqqJV\ng6XXvlSjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQWh0JWu0P48WQJ2Ic25Hqr0wNQ7zAfBgNVHSMEGDAWgBTnQOZv0VGBH8Ls\nlXxx+FwBdy8DGjAKBggqhkjOPQQDAgNJADBGAiEA3cXrxZDA+/bdMW0L9zWJgKrv\n6ZTuuuk5FPXoDFzHSokCIQC7FpNdXhnG5JSE+e7JCqBD1/MmHMagIdR4K9W58EkJ\nBA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAaYH8UW1JqaZC5JQfSNNKkBtMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGFhNmE1MmRhLWY4NDktNDcwYi1hMjMwLWE4OGU0MzFlOTg3MjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDIxODFhYWY2LTYxOTItNGFlNC1iY2UzLTVi\nM2VlMzZkNDdlMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEGfy2X9TwheCrPV\nmQM34h/0gRC7xDzKom9khDl1NNvfk5xCgF2vidEeHUDL7jDMPl7Yejl73dca97HA\ngQSM6lOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRypuSprP/iiS9Dsr2ZeKfik9SM2jAfBgNVHSMEGDAWgBTnQOZv0VGBH8Ls\nlXxx+FwBdy8DGjAKBggqhkjOPQQDAgNIADBFAiEA8lz38L2L2vwac5/D9/9WfaLW\nMrDW8oQJsgAS+gYAYbsCIEXw8m7yQ6NCkbH/j+yC5FMQfk/a4uZ5vED8bHXdtMQ/\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAYF8uGoeuNy/UYAMTTqHk0KeMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJDNj\nM2ZjYmZhLWY4MzItNDg1NC1iZTdhLTcxZmVkZDFiNTZlYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGQwNTg0MTBiLWZjM2QtNDgxNi1hYmZmLTExZmI2\nYjI1NWUzZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE8dpvPVufGGyzfzk4Yb\n+/2r6p/aD4mrvhKjGzV6IDhiEATZq754U2il2XP1o2NtSef52aQGTQfPZzzUocRC\nxQGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTNZ/perPqy6y7T5ZV9ZwjlirdpPTAfBgNVHSMEGDAWgBSuKKpkW4shA/5Uwytb\nb0q/qW3cCTAKBggqhkjOPQQDAgNJADBGAiEAuwYZ8TupTJ+ko5M4IQcgLI4OhwXa\nYaqjOf7iqXLtQ3MCIQCUCnVh/HvWFVBKxW/UcTZwWA80b92DNxmV23b35tyDgA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAU6Zj1nHGTVs9YFxaWlriQw2MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDc3\nMzU0YjEyLTY3NzctNGExYS1iNmExLTQxZDAxZmEzZWQyNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJDNjM2ZjYmZhLWY4MzItNDg1NC1iZTdhLTcxZmVk\nZDFiNTZlYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD8EEV1/ou7MfmhC+pKH\ni6llwwUyVS6kvFo2abPAXt8R9E950lorUwZjoTP2UpLxAEuNrFEnANhRZeditTdv\nSp2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSuKKpkW4shA/5Uwytbb0q/qW3cCTAfBgNVHSMEGDAWgBRtuZUcC5lA5xkq3Det\nTDeZ+THqJTAKBggqhkjOPQQDAgNIADBFAiEAwsLXJTnt+acj2dsSH9mYOHax4KX1\nQBTpu31kL/6HEYACIE6vRSviRG0d+otZ/e4SccMeb0jQ7Ra6Kuh8nyAm1zBn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAd63ge3fRRJt9Gs1XMRocTTPMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDc3\nMzU0YjEyLTY3NzctNGExYS1iNmExLTQxZDAxZmEzZWQyNDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDY4NmI5NGJjLWQyYTItNDE1Ny1iZjc1LTQ2OTAz\nM2NiOWQ4NzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHLKBfo1Xwzr2CGqbyyv\nihkfgr3KX5Bb5uocWEnKwaHouwqiF0zsGCYeuoLaMZNO4LmIxZ+WHRutlzRSC95w\nHaijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQkV9KkCIuVfC9fuqC4Iauep9zMGDAfBgNVHSMEGDAWgBRtuZUcC5lA5xkq3Det\nTDeZ+THqJTAKBggqhkjOPQQDAgNJADBGAiEAmtD85Rd4I2Vut/Y3Yn4Ou5+QE2VI\nkOqYrSirXs+x17sCIQCcCYyiNe4uZ/tjlbk2yaB7CFgTwXxz1I/+ECbk5H27aA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAZYaAjoihn7d5kd0TNw8H5G1MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGM5\nYjUyYjU3LWYwZjgtNDEyMy04OTY0LTQ0YjdmMjg2YWEyODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGQwNTg0MTBiLWZjM2QtNDgxNi1hYmZmLTExZmI2\nYjI1NWUzZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE8dpvPVufGGyzfzk4Yb\n+/2r6p/aD4mrvhKjGzV6IDhiEATZq754U2il2XP1o2NtSef52aQGTQfPZzzUocRC\nxQGjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTNZ/perPqy6y7T5ZV9ZwjlirdpPTAfBgNVHSMEGDAWgBQUXCQ9bqkpcACLpE1t\nUhPP/aT3dDAKBggqhkjOPQQDAgNJADBGAiEAraQORPH3TU1xtHbJkJH2t13QM/fH\ng9mipGvWkV8ZB4UCIQCiI08Lxa09goQ8axF6GxxoFRZSufsv4IcWvTOjdaNlfA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISAUQbo9B1TQOVHO9WIuPyufGCMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQ3NzM1NGIxMi02\nNzc3LTRhMWEtYjZhMS00MWQwMWZhM2VkMjQwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATprGEb+xwbwAJMdd+gef7GFkmwVbcuDJr5bNM4a6wEZbXatSzSkEzyyRA/\nhgXlgSxBw3kpPCGQjJmwXYJQQJ6ko2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUbbmVHAuZQOcZKtw3rUw3mfkx6iUwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAL8A\n0Hu/NdrBxNNYIX/cOs4aeNhsjmDVMcJS2+xxKHw6AiBCl/xMHDZzgYh61w2jSne/\nrO/G/X7LAKiSlr28hG5PjA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAUBaOdM7iOVH9sIvBJwZlgKBMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRjOWI1MmI1Ny1m\nMGY4LTQxMjMtODk2NC00NGI3ZjI4NmFhMjgwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAR2GPVsvdUn4Q6qqXosPkYw2Rm9DbLM46hxVJjjt8hZItNH/I9mkYcgxkE5\nnZGMVNmknBsM75aGGtFroM4CmRuNo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFFwkPW6pKXAAi6RNbVITz/2k93QwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhAJmg\n9cbGcN7RpWNMw40UAEt5692/Tb2KO6ap72efsvAJAiEA0R/TdzoZBM83Qu5/13YN\niEes/wNuMtomcVHG1BXH+I4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAS2axA/1JXbe4UpNNiTAy7x8MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGM4MTQ5Njc3LWM3MzItNDdiZS1iNGExLTFmMzMxMDFiNmNlMTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNTUzZGJhNDUtMzI1Ny00ZDI4\nLWJhOTAtZjYxNDlhODYxZDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE790L\niTVks51D9Tq/wgK4kShXrB9JhLB8VbPhvhp6C3USb0YyO7TtEgU/qwkI+kiAsepj\nM36QPCrGyCOWsaKsPqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFAv2oiNSnKTimQl8tk1S//85Q9iJMB8GA1UdIwQYMBaAFPfv\n6GZEjM/p8UhRAMV2z694aO1YMAoGCCqGSM49BAMCA0cAMEQCIHunbbo6zbnLxXaF\nXW7sXEqPyIv0vo94Hqjl1VxiLnLlAiB0BaKGNqUF6oz2myU+hVsmnTazNKSC6WS7\n9vjbd3aMvQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAcqiR87PDzj5SDSR3KvyPC90MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNTUzZGJhNDUtMzI1Ny00ZDI4LWJhOTAtZjYxNDlhODYxZDk0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkYzgxNDk2NzctYzczMi00N2Jl\nLWI0YTEtMWYzMzEwMWI2Y2UxMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXwS6\nzcsDblTmMnYhrKp7Emmb0MFGHo7q9Ch5pDFqCtb8kWlB69pR6EetDrcd8uaQFTcH\nwp/3VjojMGyJHHitAaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFPfv6GZEjM/p8UhRAMV2z694aO1YMB8GA1UdIwQYMBaAFAv2\noiNSnKTimQl8tk1S//85Q9iJMAoGCCqGSM49BAMCA0cAMEQCIHV2AldNhLGyYZkd\naQnKAdy2oznJL2ckBputzJ7s3sWpAiBFkqw7qO5p6U05osTJ8rfnjdVMbe6RgV2K\nwKFvkA+3ig==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVIYVCFInAAo0v3yjGQpz2RMMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDg4ZjIxNmU4LTFkNzgtNDAxZi05ZWVlLTg2MDkxMDk3ZjhhNzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNTUzZGJhNDUtMzI1Ny00ZDI4\nLWJhOTAtZjYxNDlhODYxZDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE790L\niTVks51D9Tq/wgK4kShXrB9JhLB8VbPhvhp6C3USb0YyO7TtEgU/qwkI+kiAsepj\nM36QPCrGyCOWsaKsPqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFAv2oiNSnKTimQl8tk1S//85Q9iJMB8GA1UdIwQYMBaAFIjP\noqsqTpjkWKvBGm2Pp/hUpWUZMAoGCCqGSM49BAMCA0gAMEUCIEi7tePLfEpfiqV7\naS/di6JKYLZMPJpiR9b1gYqmABToAiEAp1kbMSDIHzRSCWgpxK1534kLJ55FCvVA\nDfVtMmIp9B0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAZizxELCxdJvKtyQt7HxsskkMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNTUzZGJhNDUtMzI1Ny00ZDI4LWJhOTAtZjYxNDlhODYxZDk0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkODhmMjE2ZTgtMWQ3OC00MDFm\nLTllZWUtODYwOTEwOTdmOGE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvvnY\n65RjrxQhUwkTRWosDI3bDI5DapbgGusW97DQZvcfE2MuOYcaQev6sYBLlNh/9xdF\nRcG5gBmTuBbveKqoo6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFIjPoqsqTpjkWKvBGm2Pp/hUpWUZMB8GA1UdIwQYMBaAFAv2\noiNSnKTimQl8tk1S//85Q9iJMAoGCCqGSM49BAMCA0kAMEYCIQCUwyMnq4AbKbDL\nuVR9/XNTC6gDZiCv8DSlg4/KsyHl3AIhANUsX0BbVxAYR4dHYNw1DESG1VgqWykf\nw5m+1SWUKRoA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISASvFfDL9w1MgsLrhZQ+2b858MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJGFhNmE1MmRhLWY4NDktNDcwYi1hMjMwLWE4OGU0MzFlOTg3MjAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkNTUzZGJhNDUtMzI1Ny00ZDI4\nLWJhOTAtZjYxNDlhODYxZDk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE790L\niTVks51D9Tq/wgK4kShXrB9JhLB8VbPhvhp6C3USb0YyO7TtEgU/qwkI+kiAsepj\nM36QPCrGyCOWsaKsPqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFAv2oiNSnKTimQl8tk1S//85Q9iJMB8GA1UdIwQYMBaAFOdA\n5m/RUYEfwuyVfHH4XAF3LwMaMAoGCCqGSM49BAMCA0kAMEYCIQCP9/mLTTe1ObFF\nS+f5Wp9DW5i071Y2OfvE1aSRtD+4bwIhANNQVddywBgxNLmnuKnLOkm9WMaABc8N\n7/aJmBAIVYdQ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAe2Ixr7Ye13IOjPvbaQTcUbDMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNTUzZGJhNDUtMzI1Ny00ZDI4LWJhOTAtZjYxNDlhODYxZDk0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkYWE2YTUyZGEtZjg0OS00NzBi\nLWEyMzAtYTg4ZTQzMWU5ODcyMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXhPY\n4O7b7vOuwMMsUFVggHbDSMw23N31E8PdkahHxfkfed3DRvHk1xKoZQKPGm4QfQMv\nMG2MtLNECqHuFyEZsqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFOdA5m/RUYEfwuyVfHH4XAF3LwMaMB8GA1UdIwQYMBaAFAv2\noiNSnKTimQl8tk1S//85Q9iJMAoGCCqGSM49BAMCA0kAMEYCIQCON5udXKTorchZ\ntgCUT2+gc6bYWHgx4HhyjEZVAQVlbgIhAMCzgueU6nAsMV6RBvp4veO4Lt3QJJlS\nTL387j+/xX1x\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAUmPRsrd7ENVfxWxR+O79o6YMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDU1\nM2RiYTQ1LTMyNTctNGQyOC1iYTkwLWY2MTQ5YTg2MWQ5NDBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABO/dC4k1ZLOdQ/U6v8ICuJEoV6wfSYSwfFWz4b4aegt1Em9G\nMju07RIFP6sJCPpIgLHqYzN+kDwqxsgjlrGirD6jUjBQMA4GA1UdDwEB/wQEAwIC\nBDAdBgNVHQ4EFgQUC/aiI1KcpOKZCXy2TVL//zlD2IkwHwYDVR0jBBgwFoAUSmac\nmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIgB8+X4Dx1qb7FJX0E\ne+pgrMSWqJ5PLpdVXx8GSZFXs8UCIQCgT1eF5Ze288vDF268TYYagyZTedhofURh\nT3sqplL1lA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAWs0OfazLydGBIhTpI6/eqmzMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkNTUzZGJhNDUtMzI1Ny00ZDI4LWJhOTAtZjYxNDlhODYxZDk0MB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBQL9qIjUpyk4pkJfLZNUv//OUPYiTAKBggqhkjOPQQDAgNI\nADBFAiB97+FT9MSKMQJ2TWpEM2ISCLy4MlyHvs4vEwUdkogo3QIhAOhEeeWeNvYK\nBiWF7J0vBD1xgIZYV45TBMfEHHcRRcfb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEzCCAbmgAwIBAgISAWEN9B+fpC95jL3OLsqDW3WPMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDZm\nZGUxZWEwLTljZTctNDUzMS04OTRlLWQzMjIyZmE3ZmFmMzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRiZDIwYWExNi01ZWU2LTQxNTQtODJmMi04YjY3\nN2VjNGM1ZDEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATuUAA1BDBOVIDJsTfr\n5ixUlBrNsfyuJ5byibYCift5d+JbTwTTWjy2fbeyLRvArNzMWLQfcs3Hczx3iznK\nGT+7o2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRdABurn4XUPlEoRCdJh8f5/5PI2DAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSAAwRQIgDTLfY5zORwQYnF9b\neED/zlj0PrWE+JFMrYz46V1J5xQCIQDxTPhlmT4ba4i5tnIbzswR8XdFIn3RUceF\n4eviLIvq6w==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc79", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `79` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQeNv0VVAwRnk52OG7eLV5tfMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJGU3\nNDMxYTYwLWQxODAtNDllOS1iNWRhLTRjMDM0YjljZGNkOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGE5YTBkZWM0LTBkYzAtNDk1Ni1hNGJhLWZlN2Q1\nMjY3OWQzZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN6U4OdpyAeBX3ANBkfW\nxXJbeOgVlJrrI9fEy83QwiKxwZCLmJoy+a1tTlnUEPSfoVirIg9eJsbOFNU7ogzC\n9lCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTYHnE7C1JD3FS52Ug6+ovqtVGYgjAfBgNVHSMEGDAWgBR/JMcubEhGyeU6n2E+\n0fTUx21JZjAKBggqhkjOPQQDAgNIADBFAiA3laN1GzF1mWeRPf+J0oPA8u2DPivx\nPRVAxGa2VMybwgIhAMQI+hObC627jzYE+Yko0LC4ciQHP1kzQQkjuRWHT/Ru\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISARDPOxWdKV0SfpMgqP14phlWMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJGU3\nNDMxYTYwLWQxODAtNDllOS1iNWRhLTRjMDM0YjljZGNkOTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDg1Yzk1YmUzLTRjNjgtNGZmZC05OWEzLWY2OTY5\nMjYyNzkwZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG79cPT6jVYKL5lN8fzU\nFXF+ZdXOaUd7DBh6E5UUHWf/E2BIGjQnnXqLDTDgo8Z8STRSLfcnSAxEdEFqIYdg\n0u6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT7mgEHKzE03VjHyd3OCZ0g+dpBETAfBgNVHSMEGDAWgBR/JMcubEhGyeU6n2E+\n0fTUx21JZjAKBggqhkjOPQQDAgNHADBEAiAZLlX1snqAUuTnZwfkAptuVzU9Q5bf\n+V4jlzCYN/+s4gIgJFzXjdKY3bf8JXDb9fJbZGoREeq+HKRUuRxU+XhefrA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVAMpOBSw2a8LvLBfO4IVaYyMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDg1\nYzk1YmUzLTRjNjgtNGZmZC05OWEzLWY2OTY5MjYyNzkwZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJGU3NDMxYTYwLWQxODAtNDllOS1iNWRhLTRjMDM0\nYjljZGNkOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHl7wZE9w/7Sv7XCM87s\nZqlChJ6ZP0K1zoswU6Qjg1b+YJj4UWtIAbVVWo1xDYXRIQDeOgyeXxW5hLi6get3\nX6qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR/JMcubEhGyeU6n2E+0fTUx21JZjAfBgNVHSMEGDAWgBT7mgEHKzE03VjHyd3O\nCZ0g+dpBETAKBggqhkjOPQQDAgNIADBFAiB5tubdCZd0EcVJBUxxwdg2XVC9Ycgs\nrFeXl7wc40EsDQIhAMFJGxIZT30HuRoBOFQuXXUTsdhCbnjjtsrg3+niQN6o\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQf3OqleZueHOgkSxvtvD+qnMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJGE5\nYTBkZWM0LTBkYzAtNDk1Ni1hNGJhLWZlN2Q1MjY3OWQzZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDUzYjg0MGI1LTAxYTAtNDUyMC1hYmE1LTA0MTU5\nMTY0MWYwZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLB/VPmq5L1AvjSEYDs6\nhj9/C5aQ2SAoIQOtEouRw3PG5NShSpcBRo6lGSRNmYEEN7dPwHRVM10o1vA7lCyg\na3GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSDXQRlwkVRl99Tb3vRxYnoASU1EjAfBgNVHSMEGDAWgBTYHnE7C1JD3FS52Ug6\n+ovqtVGYgjAKBggqhkjOPQQDAgNJADBGAiEAxmI+7irMqth/cb4u9MMWW1PHK+h0\ny0PkX0iMvb8oc2UCIQC4Vv8Ct3LZ5VRkQB/HNoZJ8n0PpN4m4r843rYJrkBDLg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAd1z2cEUhYx39uuOr5RlXoUcMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDUz\nYjg0MGI1LTAxYTAtNDUyMC1hYmE1LTA0MTU5MTY0MWYwZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGE5YTBkZWM0LTBkYzAtNDk1Ni1hNGJhLWZlN2Q1\nMjY3OWQzZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN6U4OdpyAeBX3ANBkfW\nxXJbeOgVlJrrI9fEy83QwiKxwZCLmJoy+a1tTlnUEPSfoVirIg9eJsbOFNU7ogzC\n9lCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTYHnE7C1JD3FS52Ug6+ovqtVGYgjAfBgNVHSMEGDAWgBSDXQRlwkVRl99Tb3vR\nxYnoASU1EjAKBggqhkjOPQQDAgNIADBFAiEAynERPasGQzRAjmodlqjMnZTsAbgb\nKhPiu8P/m8yU4oACIEwbyK28UnqrsTE2iKh6kcC8TN2FxMUYg+w/DkhfFVXK\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAXLJFaXECr69w+wzhcngHXIGMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDg1\nYzk1YmUzLTRjNjgtNGZmZC05OWEzLWY2OTY5MjYyNzkwZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDUzYjg0MGI1LTAxYTAtNDUyMC1hYmE1LTA0MTU5\nMTY0MWYwZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLB/VPmq5L1AvjSEYDs6\nhj9/C5aQ2SAoIQOtEouRw3PG5NShSpcBRo6lGSRNmYEEN7dPwHRVM10o1vA7lCyg\na3GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSDXQRlwkVRl99Tb3vRxYnoASU1EjAfBgNVHSMEGDAWgBT7mgEHKzE03VjHyd3O\nCZ0g+dpBETAKBggqhkjOPQQDAgNHADBEAh88cO0/fNk6AwOi3pIhj1mklRlA6jRx\nRwWpUeNpSH7gAiEA8RtsyMfsgoDUju1ez4XKT/jvqv1hIQzRUdrgG5XYKqY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAeoqfIuUaXd427NGgCmH1mQ7MAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDZiYjc1ZmFmLTI5NTEtNDkzNS1hZjJkLWNmYzNiY2IzODg1NDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJGU3NDMxYTYwLWQxODAtNDllOS1iNWRhLTRj\nMDM0YjljZGNkOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHl7wZE9w/7Sv7XC\nM87sZqlChJ6ZP0K1zoswU6Qjg1b+YJj4UWtIAbVVWo1xDYXRIQDeOgyeXxW5hLi6\nget3X6qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBR/JMcubEhGyeU6n2E+0fTUx21JZjAfBgNVHSMEGDAWgBTVgq+4y8U5R0Ly\n57YuMxyOFDrK3zAKBggqhkjOPQQDAgNJADBGAiEAlXWTqniSGD9b0ZeeXhKMiDx6\nnJXH2cqBtQyQmzczpY8CIQDgtxmUcCBqaG+Z8l+00ReZm9Y8pwG9QzO0vuYQMIg3\nSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISATJs/NT/57rOSH59WJYg3l5hMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDZiYjc1ZmFmLTI5NTEtNDkzNS1hZjJkLWNmYzNiY2IzODg1NDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDg1Yzk1YmUzLTRjNjgtNGZmZC05OWEzLWY2\nOTY5MjYyNzkwZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG79cPT6jVYKL5lN\n8fzUFXF+ZdXOaUd7DBh6E5UUHWf/E2BIGjQnnXqLDTDgo8Z8STRSLfcnSAxEdEFq\nIYdg0u6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBT7mgEHKzE03VjHyd3OCZ0g+dpBETAfBgNVHSMEGDAWgBTVgq+4y8U5R0Ly\n57YuMxyOFDrK3zAKBggqhkjOPQQDAgNIADBFAiA7wigoSqN5ZlZlhTDga5SfBIiw\ncXEho1t850PBi315EgIhAM0n+jIzmBE9xwDhh0CmIdGEhdpoL2SLaSSiX0VKNWUP\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcR8xB0QN85bZIVqpTj8kwKLMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDI0\nMmZiNDIyLTI4MmItNDJjMC05NDIyLWRjZjViYzBjNTBkZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJDk2MWQ5ZThlLWEwZTQtNGViMC05NzJmLTg5OTdj\nMzE5NjNiZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIktlrzSkOaP++KYZspo\nL8F5tjmzx5X60aaLjYSOpHWMIMY8SWl/jOp/FIfboolHyV51A2+4/Trm9gPdyepi\nOWejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRxRiKevJm4O2U1BejR7qNytoJ5pDAfBgNVHSMEGDAWgBQPrBsxX92Wn+GK1dJg\nK+h4pm9O7jAKBggqhkjOPQQDAgNIADBFAiAIsHPLQpJIM3toIxZHQG5r4xy5rxs+\ny9zXDF4U5xjsFwIhAIc7g7fXS/H5kMIXy4bKG8EqafL6CPS363iIi5iSu/lf\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcGAvsDGlbCwJjslZyzU31CMMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDM1\nMDM0YWU2LWMwOGMtNGQwZi1iZGY2LTZlMzZiYzQ2N2Y3ZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJGM3MzVlMzI3LTQxOTYtNDY1OS1iMWQ2LTY1N2Yw\nOTFlODYzMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN+GUrUs19CObSqFendO\naaJpIyPZL++Afn/+FYlZpN19b66xDFjGi9cBzJxzAVXxnVTv7jdhFvzWmDkSy1F9\nrkCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQmWlZWqKq/BMEnvZ5I/NuSNL2lIDAfBgNVHSMEGDAWgBQVAajHoEbDPAjK/7b4\nPpQseeKy4jAKBggqhkjOPQQDAgNIADBFAiBvTUBW8CFkM140AfX0aBxo17nRwxX0\n/gahb+GQpWNuYgIhANbULNF766y9D/R79CAlXkJF4dsKHNVicH9GjrN2J3KV\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZDFUQZtJbKzk99s+TGka0uiMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDM1\nMDM0YWU2LWMwOGMtNGQwZi1iZGY2LTZlMzZiYzQ2N2Y3ZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJDAzZjdkOWM4LTRiMDEtNDg4My1iMDY1LTdmYjVh\nNmNhY2I5ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO7a6xnNStO2P6VNUYNY\ncaTte3W1vVOKYddEvWL+o395GayvSTukK7mIC2esTL8MPR1pdNwQ3vnY3PTDhuw6\nAzOjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQagoFC9oQ1TpCEea/Zhw0N0UaaPDAfBgNVHSMEGDAWgBQVAajHoEbDPAjK/7b4\nPpQseeKy4jAKBggqhkjOPQQDAgNIADBFAiBnwfBbL9TasFeuTXR1QsH/Q2bJBhB5\n2SC+4cRKYw+NRAIhAPLQVCqQWKMHese3Fw6nWAYIYRFVJYmanzaUJQiQ7/7M\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAUIRGnn9DqT8Y6h2dLZ99oIgMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDgxZDU4OGM4LWE5ZGQtNGRkZi1iNWZmLTNlMjJiNTFkOWQ5MDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDI0MmZiNDIyLTI4MmItNDJjMC05NDIyLWRj\nZjViYzBjNTBkZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNTIvveVgp5uszKD\nbQ1d9eSFNc1KjN8nCXGRzIObnPFNdifRhaC29xGycV5kJ/Q/tKN4W+omr9PxGdPt\nRB2LnYujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQPrBsxX92Wn+GK1dJgK+h4pm9O7jAfBgNVHSMEGDAWgBSaESWFaRHDW5SU\naF7mK0LpiijxZjAKBggqhkjOPQQDAgNIADBFAiEAw6t4OI3z78kcmAaDW5t37Cyn\nb3G4BimCv500VXW2qNQCIAU9W81gmAeg0UAegWp5l4AcA3iQypKPt70jtIAxmTqg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAbYZmSIxAPWaNg5hNgfKYxtVMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDgxZDU4OGM4LWE5ZGQtNGRkZi1iNWZmLTNlMjJiNTFkOWQ5MDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDM1MDM0YWU2LWMwOGMtNGQwZi1iZGY2LTZl\nMzZiYzQ2N2Y3ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO/cu4RpR0RbEV5p\nudH6t2L9pho55cEEyBbEHHRdLqXOE+XqioW7TSY+BGvW6mpP81URBWbeKPZwyLVK\ne5tUUxejYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQVAajHoEbDPAjK/7b4PpQseeKy4jAfBgNVHSMEGDAWgBSaESWFaRHDW5SU\naF7mK0LpiijxZjAKBggqhkjOPQQDAgNHADBEAiB2uyq9eycGJL/UJy5AGFU+lJEC\nPSj6Yivuc2d56h4WUAIgI4jH2V+nNFf8QA9htwQplH7HSpAjesGV1XNZODD898Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAcFHCW7eZTCI3AIBVtJ3R69RMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDkz\nZjE4ZjcwLWM1ZWYtNGVlYi1hNTMxLTUyNWUxMmFiNzkzMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJDE2NjQ0ZTFlLTQyNjktNDcwYy04MWYzLWRlNmY0\nYWU4Yjg2MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGmlgwTZZs9zyZZYHqX0\nR4Ft0OTRXUWjKnep71kIIX7xs+YerUtVRL7R8eNwE5UKsWyhEdacNnwqnnY/wteR\nDuujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRKIdpF/5VG0kcyc8r3x9naKJhXETAfBgNVHSMEGDAWgBR4qKYbCzfJpBMPPP6q\n4xRbDT6HRDAKBggqhkjOPQQDAgNIADBFAiEAojeMNOHes/u9gqTa1SXG9zM7NAWv\npg4/yTw/HwUbeI8CIDu+WLWz9ea158gvXgKF34N8fGfRtUbk/2Y91Q3hhmiA\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVL4iZli3OrLzSFApEVTLh8pMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDkz\nZjE4ZjcwLWM1ZWYtNGVlYi1hNTMxLTUyNWUxMmFiNzkzMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDVkOTk1YTRkLTE3NDItNDQ3ZC05ODU4LTNmNDQ2\nZTk3ZmZlMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDpZZxsBeWVJTqMqzjjS\nkqa1PUXYVYVEf/pC9BBn+3Xer+lMpzlws0LtLx89R643aYFJXc4Rn4cr3YPScWoi\ndZyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTf6xQQdaXfxATXn8/bjwoXcS14lTAfBgNVHSMEGDAWgBR4qKYbCzfJpBMPPP6q\n4xRbDT6HRDAKBggqhkjOPQQDAgNHADBEAiBf7g19kZTAO2b5RQJao/ZX7qXYq//c\nPCduRTMJ32VWrgIgLCyPXV4H+M0bUYXetgmamlbenBcwO+dw7hfaiumxlvY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAbb/fOt9JHrS4NF499fSuN9tMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDRi\nYjhlMGEyLTQwZGYtNDUxNC04OTM4LTFiZTE2YTVkYWJkMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDkzZjE4ZjcwLWM1ZWYtNGVlYi1hNTMxLTUyNWUx\nMmFiNzkzMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPxmRHp3jHkZtjLXnpiS\n6cS5WOL51rrlRhYKf+FnLr9CCj1EWajbD/lfAT9Iqu1Z9gjckhD8bdp3wUOWnO/g\nCM+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR4qKYbCzfJpBMPPP6q4xRbDT6HRDAfBgNVHSMEGDAWgBRbgON7mYw0yInB5MDU\nuGQ9XjbERTAKBggqhkjOPQQDAgNHADBEAiA8SCHpaDDU3tbt4pMCjCxtHQ8s/LjO\nXi9REbrB6UZB3wIgC/0au/5ObC6mZAOHPXB7RN7IDSwkMOvGMwy4rwrmN48=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAVbS022X1/ZqdiEWEPBNxX4DMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDdl\nMGVhZTAyLTdiOWItNGM5ZS04MzAwLWQyMjYxMDRiZTIzMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDkzZjE4ZjcwLWM1ZWYtNGVlYi1hNTMxLTUyNWUx\nMmFiNzkzMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPxmRHp3jHkZtjLXnpiS\n6cS5WOL51rrlRhYKf+FnLr9CCj1EWajbD/lfAT9Iqu1Z9gjckhD8bdp3wUOWnO/g\nCM+jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR4qKYbCzfJpBMPPP6q4xRbDT6HRDAfBgNVHSMEGDAWgBSoJ8w+NYVP9O/ess9e\njbot5NArnTAKBggqhkjOPQQDAgNJADBGAiEA1V8asSeaj92JD55bkgBbTqxtrEME\nEgkmTkVDLCGjYBQCIQDVNXej/Ygxo01W7JOYCeur97s3qUNa0f0XRUEJMGKMEw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAW6MxQsGmPD2i35RFfXH3t9CMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJDRi\nYjhlMGEyLTQwZGYtNDUxNC04OTM4LTFiZTE2YTVkYWJkMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJDdlMGVhZTAyLTdiOWItNGM5ZS04MzAwLWQyMjYx\nMDRiZTIzMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE5RBHiZznKPqMIlf+ob\nwqQyJHuLsmSWyTtQE+zpUhSwfvJCrVyJWOIFiPvRbq3eFn+2L5HlvEdAPVIigNns\nNDyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSoJ8w+NYVP9O/ess9ejbot5NArnTAfBgNVHSMEGDAWgBRbgON7mYw0yInB5MDU\nuGQ9XjbERTAKBggqhkjOPQQDAgNIADBFAiEApTyefqbe3BXwVMkbrKq7oyoQtVO/\niUW47NVZu0zp7vkCICMh6qL3PxNBrOIRi1h7KpGjRHXWe0eU3ddrtdEWrG4w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAZ3ZlglGpXfF7bObh0F7DuguMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJDdl\nMGVhZTAyLTdiOWItNGM5ZS04MzAwLWQyMjYxMDRiZTIzMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJDRiYjhlMGEyLTQwZGYtNDUxNC04OTM4LTFiZTE2\nYTVkYWJkMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN/SGep56qPHbC44VwJ+\niEQXnzvyx+lc1Uw6AimunbGEKoW8vSr51Fj7N7tUE5Qjjz9jVhFFkRnLSPfLqWp6\nlm2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRbgON7mYw0yInB5MDUuGQ9XjbERTAfBgNVHSMEGDAWgBSoJ8w+NYVP9O/ess9e\njbot5NArnTAKBggqhkjOPQQDAgNIADBFAiEA6V3vn+IHEapcj36dQemOT1js0Iqn\nkYHuXB/bUn+QHg0CIHqk96dzA5BaH3iyIvCtIoEcuEo4Q2nAbPxVZ1bwlLqJ\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAQEt28P0WnWxeLN1j2mRKCvMMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDJhM2Q3MmY0LWU0M2EtNDcwZi05NDhjLTgyYzc0YTNmYzMxNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJDRiYjhlMGEyLTQwZGYtNDUxNC04OTM4LTFi\nZTE2YTVkYWJkMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN/SGep56qPHbC44\nVwJ+iEQXnzvyx+lc1Uw6AimunbGEKoW8vSr51Fj7N7tUE5Qjjz9jVhFFkRnLSPfL\nqWp6lm2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRbgON7mYw0yInB5MDUuGQ9XjbERTAfBgNVHSMEGDAWgBQzisk/uPxmwnwb\nNkDrp1nQDUbPoTAKBggqhkjOPQQDAgNHADBEAiAJD3iBHAIIdPEQpmLwMc5RefEw\nA5S0WCc0hFInkJ1gFAIgUvDHtpqQ0QKSANM7VFMmkAa/+E86rbi1i37y8WiNjdM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAaY+z5BckMRaOc5u1SsKaFEcMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDJhM2Q3MmY0LWU0M2EtNDcwZi05NDhjLTgyYzc0YTNmYzMxNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJDdlMGVhZTAyLTdiOWItNGM5ZS04MzAwLWQy\nMjYxMDRiZTIzMjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE5RBHiZznKPqMIl\nf+obwqQyJHuLsmSWyTtQE+zpUhSwfvJCrVyJWOIFiPvRbq3eFn+2L5HlvEdAPVIi\ngNnsNDyjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSoJ8w+NYVP9O/ess9ejbot5NArnTAfBgNVHSMEGDAWgBQzisk/uPxmwnwb\nNkDrp1nQDUbPoTAKBggqhkjOPQQDAgNIADBFAiB5wtRwRnW3uuaOh/xGBuLLQ+ou\naUkOpeh4jRPNmVH0tAIhAKrjoAJbDoLsyvaXbcTCpA59/C44y48GVN/thG4/9xL+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAetKumu7bD04O7x4Jnd/Et5hMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJDkw\nMDI0NDMyLTczNzMtNGE5Zi04MDMzLTg5ZjBmZGI0M2FlNTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGI3ZjBiNzNhLWNiNjMtNDdkNS05MGNhLTM3ZTc5\nMjMzYjE4NzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKMwNFI4l8K5bJZeb5kV\nqg+ocqA8R0HPchfpqg38rlna7ba4DpshGSFlb4Qs2LVyHPZXulDOeQASU6jMfNEb\nqXijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQiK3mTRkWJ3oQh6VnDMI6XFa0nYDAfBgNVHSMEGDAWgBR5o0jxcfaPmwiY4WeN\n1aDtge52VjAKBggqhkjOPQQDAgNIADBFAiAp5MnRWHF1f1TEr4oI+uEQDqtzAo0h\ncWsuLEKQ36igHAIhAO9InljOFnlLGQDx/7+JRSDI86FLe4esmcX8OLpUKFXS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAR0uEYL1+T7VzKYQ4RDxOAFiMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDVh\nNTlhZWM1LTU5NTYtNGE1NC05NWYyLTk3ZTc1ZTliYWI0MzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJDkwMDI0NDMyLTczNzMtNGE5Zi04MDMzLTg5ZjBm\nZGI0M2FlNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFkqlcY2YmAJa4Rz9E7x\nURZ8Kt1Lh8KXloX7Qh+1y3fudYjnToChNgxbLUKnmuBwxjqKyBYfbxOp3FF6Imt7\nJc6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBR5o0jxcfaPmwiY4WeN1aDtge52VjAfBgNVHSMEGDAWgBSGanomNJO6GsBKHGyY\n8chiflORjTAKBggqhkjOPQQDAgNJADBGAiEAioD1CFQjwnQfgt7lSy46d8bXfg/e\n0JUQc3IUgWbxGd4CIQCqu3ROhTDQUFLWDJSjosZ5p7PnJYsvdFAFD4wzuYTn+Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAaGiVEZNJxxs0KRmgG/zH4hVMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDVh\nNTlhZWM1LTU5NTYtNGE1NC05NWYyLTk3ZTc1ZTliYWI0MzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDlhZDc3NWZiLWYyMWYtNGQ5Ny1iMzAyLTVhZWM2\nN2YxYjI5NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBLM/U198cfBQNR28dT3\nOLy8tYxDgy2bVozGdhboiKEG/eThjcLn5+Z3Fz+ZNgnh42yY5+MyHioN5ftqgiIL\nLMajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRa7IltGnFUroHIubYJwPM9uKPkzzAfBgNVHSMEGDAWgBSGanomNJO6GsBKHGyY\n8chiflORjTAKBggqhkjOPQQDAgNJADBGAiEAyB+uVy3h/woT4RqF0uzTMtGs7x7y\ndUDiFLxa/PfJ9QcCIQDQFlxdBEmraEqOCvDzQRrzoYRml4kD1AKZqeCmmpE36w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAVSUbhOYHybXO4pUbhTrWHQJMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJDAx\nYzlhMThiLWNmNGMtNDQxOS04ODQxLWMzOGI0NWI5ZmI5NzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGI3ZjBiNzNhLWNiNjMtNDdkNS05MGNhLTM3ZTc5\nMjMzYjE4NzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKMwNFI4l8K5bJZeb5kV\nqg+ocqA8R0HPchfpqg38rlna7ba4DpshGSFlb4Qs2LVyHPZXulDOeQASU6jMfNEb\nqXijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQiK3mTRkWJ3oQh6VnDMI6XFa0nYDAfBgNVHSMEGDAWgBQq/8ICyk0S0ZSATNEF\nti1s4dQJiDAKBggqhkjOPQQDAgNIADBFAiBCDyYYmtrzbsJFyy1pHxUnhqi5o9q4\ntkoHDl9BrWhUggIhAO2Tyl51KMQKTK8NbF/tjLxtVflsNDdWn9WAOoTK0zXT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHTCCAcKgAwIBAgISAXx24FyZb2a7HitiABcnNq+EMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQ1YTU5YWVjNS01\nOTU2LTRhNTQtOTVmMi05N2U3NWU5YmFiNDMwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAATd/1wtM0RDWmgvcaaK5lgjYHyfnTOwvQpcl4vhjI1YxAx7Wfb5HkhLUnuK\nz5UlYZNVTiDJbMghlDpWayPJtEbGo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUhmp6JjSTuhrAShxsmPHIYn5TkY0wHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSQAwRgIhALaS\nIjwLzBawzkAaVQWJOh7IQ4qJ+g/8xLJawsAWCDNGAiEAqM0Q6DDvxCLYuxZ6mH+X\njYlQE90WHNWACOdMVR7x/FE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICGzCCAcKgAwIBAgISAd85f8X4VCa6atD7omTgu8TNMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyQwMWM5YTE4Yi1j\nZjRjLTQ0MTktODg0MS1jMzhiNDViOWZiOTcwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQTXtb4CQ+HAc9ZqEhej7rWmGal10qHxmUQahkP1yloa8RnuZ5pYysX92n6\ndeQ9xkik9WnJ7+JUSpPEyB+5RLuzo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUKv/CAspNEtGUgEzRBbYtbOHUCYgwHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDRwAwRAIgP6vY\nAsFN4Gy7VpaLj55G2F4ygP1HjOTbSNZv7fyYEMsCIH+xLM1vcGVhIUZBShIwsrMV\ndr3Z0ow2t06KDyPMHemo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAVp65kGYttfiEO+gkrWR0qPyMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJDZiYjc1ZmFmLTI5NTEtNDkzNS1hZjJkLWNmYzNiY2IzODg1NDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMzllNmQ5Y2UtM2I4NS00NzFj\nLWJkM2MtMWFhODkwNTlkMGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE89Gg\nVeYK6Sxox7pExXfAuGtwFfyR/WDNHQONUL1h8BWiNpDByMTKsysbResndpZwnFDV\n16SmmMbiRGpj69S/YKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFE/HlAWPietMgjPjTjwVyM3eBdYaMB8GA1UdIwQYMBaAFNWC\nr7jLxTlHQvLnti4zHI4UOsrfMAoGCCqGSM49BAMCA0gAMEUCIQDQqdKXCRIYTNaw\nvI/5RAWma0zsvS4fHwdnAgfP6njKUAIgTl9iBUeiGwpHpmno4hd1PfLBItaOL81N\nimJOERKQFWM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAY/Er4Sy5RMoe6zj5EDnLmG+MAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzllNmQ5Y2UtM2I4NS00NzFjLWJkM2MtMWFhODkwNTlkMGUzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkNmJiNzVmYWYtMjk1MS00OTM1\nLWFmMmQtY2ZjM2JjYjM4ODU0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAh5i\nXBXWXhVd9nEeTmvbGiIuhq/GcIR/Db+tsbQoYuZv7xmm8FF16IzegatTfqDORH3K\ns6m2tf19LbXtdI2h7qNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFNWCr7jLxTlHQvLnti4zHI4UOsrfMB8GA1UdIwQYMBaAFE/H\nlAWPietMgjPjTjwVyM3eBdYaMAoGCCqGSM49BAMCA0gAMEUCID2nBHswLRmEZbsD\nyXl0m3Z35af+bgThueYtn8msYkRuAiEAyETpU8cn1enUINlUz0K7JJyuqRqaX/XB\nq6RvIfHjYmA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAXI+wH419K5CMuqHRu1WohrOMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDgxZDU4OGM4LWE5ZGQtNGRkZi1iNWZmLTNlMjJiNTFkOWQ5MDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMzllNmQ5Y2UtM2I4NS00NzFj\nLWJkM2MtMWFhODkwNTlkMGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE89Gg\nVeYK6Sxox7pExXfAuGtwFfyR/WDNHQONUL1h8BWiNpDByMTKsysbResndpZwnFDV\n16SmmMbiRGpj69S/YKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFE/HlAWPietMgjPjTjwVyM3eBdYaMB8GA1UdIwQYMBaAFJoR\nJYVpEcNblJRoXuYrQumKKPFmMAoGCCqGSM49BAMCA0gAMEUCIQCSTZYY/PsTUjZU\npTk19kee7YrB6d9iUY2tNhhAj6gNmwIgVq8QFtEMkANOtURDeqYJpm8gaffzbuDQ\nvGXJrHuexMc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAWulON0Hjyz/SaSrFce+AVzjMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzllNmQ5Y2UtM2I4NS00NzFjLWJkM2MtMWFhODkwNTlkMGUzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkODFkNTg4YzgtYTlkZC00ZGRm\nLWI1ZmYtM2UyMmI1MWQ5ZDkwMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwXEg\n2cw2Wx8VkSB4fDWTQx3zlyZ+RIXFiJBnnfr4qrkNh07hLCBghyPBwJHOuiZfxtTN\nekr2gtTaCbKDkVex/KNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFJoRJYVpEcNblJRoXuYrQumKKPFmMB8GA1UdIwQYMBaAFE/H\nlAWPietMgjPjTjwVyM3eBdYaMAoGCCqGSM49BAMCA0gAMEUCIQCMeNSVwemYa8RS\nIWrlkbgr7wJwoE6zJ5PdgkRpTNl+/QIgN1CnwhzhB5v0DiRcETrtvOT0mE+pebWU\nEFhHB4V0vfc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAX0AZ5HSEzGwRq4sALYSLkzKMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDJhM2Q3MmY0LWU0M2EtNDcwZi05NDhjLTgyYzc0YTNmYzMxNTAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkMzllNmQ5Y2UtM2I4NS00NzFj\nLWJkM2MtMWFhODkwNTlkMGUzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE89Gg\nVeYK6Sxox7pExXfAuGtwFfyR/WDNHQONUL1h8BWiNpDByMTKsysbResndpZwnFDV\n16SmmMbiRGpj69S/YKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFE/HlAWPietMgjPjTjwVyM3eBdYaMB8GA1UdIwQYMBaAFDOK\nyT+4/GbCfBs2QOunWdANRs+hMAoGCCqGSM49BAMCA0cAMEQCIDXG2QUML7pSe3ey\nJeaaLNRfyfZZj//kOOyeapmpJpIMAiBGtUypvsPq3PKEKjnRFFarNK5oYg8lfmna\nnC+1Tn0EDg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAVjugNCT5MYnCbxdg9TWmiEiMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzllNmQ5Y2UtM2I4NS00NzFjLWJkM2MtMWFhODkwNTlkMGUzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkMmEzZDcyZjQtZTQzYS00NzBm\nLTk0OGMtODJjNzRhM2ZjMzE1MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuDLF\n5ACgiYVsRxuFw2mJRNLA1fHl9G26+iF8ZA+Bpip7qys159Ne3F+smgWdQZmhr+37\nLJWHtbfNBhjKw3jChKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFDOKyT+4/GbCfBs2QOunWdANRs+hMB8GA1UdIwQYMBaAFE/H\nlAWPietMgjPjTjwVyM3eBdYaMAoGCCqGSM49BAMCA0kAMEYCIQDw1kyFic19K7q4\nfwW3baJdnoQvzIB2n3WpjAi0klWvzgIhAKluWIH6PA7fpez9T4EamO7+NXKzBnIN\nLFzzI329TSsM\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICAjCCAaigAwIBAgISAYlYJAWfbcLUEk+ajiaSxm3JMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBbMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMRIwEAYDVQQDEwlCcmlkZ2UgQ0ExLTArBgNVBAUTJDM5\nZTZkOWNlLTNiODUtNDcxYy1iZDNjLTFhYTg5MDU5ZDBlMzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABPPRoFXmCuksaMe6RMV3wLhrcBX8kf1gzR0DjVC9YfAVojaQ\nwcjEyrMrG0XrJ3aWcJxQ1dekppjG4kRqY+vUv2CjQTA/MA4GA1UdDwEB/wQEAwIC\nBDAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1\nMAoGCCqGSM49BAMCA0gAMEUCIC9cZG4NltzCWZkXpxzXwNw4GcRMGaCnWHJQeQ+w\nOLaIAiEAuVb1ZhX6rcGL8Ba3OJT3WNiLLEumgj96x+N9BYRymeQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJDCCAcqgAwIBAgISAdOW6Jn5E1ScSVZVxxjcbCaxMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkMzllNmQ5Y2UtM2I4NS00NzFjLWJkM2MtMWFhODkwNTlkMGUzMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBRPx5QFj4nrTIIz4048FcjN3gXWGjAKBggqhkjOPQQDAgNI\nADBFAiEApPJKv4vzcMSCPdSIgwT0UUdETMMKDxPrB1E8co/FMEcCIHwFpKX4QcN4\nNUqkIb+yf9cxmrcv3+U/9qsWwYj+QrVb\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICEjCCAbmgAwIBAgISAZ2mefpr3Fvk6Y+OxN99pWQlMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJGM3\nMzVlMzI3LTQxOTYtNDY1OS1iMWQ2LTY1N2YwOTFlODYzMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyRhNTlhOWZkNC01OWQyLTRkOTAtYjA2Zi01OWJm\nY2RjMWE2MTYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARK/03LUyKLfdQedzq8\njT4SChG7x7dvM+nDsIRFWXeMfEYDyqc5LmB6hXiz0Sbx/12uTd13udO/XYqalNhn\nLnS1o2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQmWlZWqKq/BMEnvZ5I/NuSNL2lIDAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDRwAwRAIgNSaMAQhyRmCbozg2\nwFbXulbbDemrQ2RIkRz/BFgSexYCICCXj8MdxeaQ8RkhRlNTAm/+/kmQb5NLM+E9\nLipdSDOT\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "bettertls::pathbuilding::tc80", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "Testcase `80` from the BetterTLS `pathbuilding` suite.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICDjCCAbSgAwIBAgISASGkPPTG8uU4NeuPffhNGktYMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTQ5WhcNMjcwMTIxMTcyNTQ5WjBmMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMR0wGwYDVQQDDBRiZXR0ZXJ0bHNfdHJ1c3Rfcm9vdDEt\nMCsGA1UEBRMkNmM1OTZjMGQtNWQ4YS00OWQ1LThhYzktNDFlMDRkZTFkOGNjMFkw\nEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExZzAzk1587nOG0tYccfUS1+ksJ28D+jd\nEQsvM2yVu3K1VLCS1Wb9Hu3DwPaRNCFvpIUFVQP8KeewDhb3ltMBlqNCMEAwDgYD\nVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEpmnJsL9B0L\nhQAaHO2EuGuCO9j1MAoGCCqGSM49BAMCA0gAMEUCIQCJ3V2OThmM8SkWSHT3q5ul\nXWqRkC4UWJLadD3OR+t6KwIgJE98gnds/RYWrJUVZQ7h6ptS/5H0OQLalU3xKeHR\nfMA=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISASowTBOiJ9rpxTOjz7KcN8ZSMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDQ1\nN2NjYzcyLWUwMTItNDM1NS1iOTA2LTU4Y2QwNjY5Y2Q5ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGM0YmIxMjVhLTlhN2UtNGI1YS05MGUxLTA5MDc5\nYTA2NGYxYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAx0Z3MwPAVKSeebvTII\nP9SL1dx/Lwrwkku+/qnPvfczhnLQVcSkoAxygMnjE75ahTdFJSRSRj3hVPZ4QxH7\nI7GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSFQK9AcaNUwP0QytEfsiNn8fbvFDAfBgNVHSMEGDAWgBTUcIf65aXCQTLztt71\nY2qBtC3/ezAKBggqhkjOPQQDAgNIADBFAiEA+LYpiSmgeEX8P5+INeaaB9CuBNue\ndnVoh0/NwvEVMXcCIHHPeqC9d1r/qsQRbIZSrjwjxtEGDwGC+xFpx+dOTCvy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWSATID9bNbJS5imuGj03c3fMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUYxLTArBgNVBAUTJDQ1\nN2NjYzcyLWUwMTItNDM1NS1iOTA2LTU4Y2QwNjY5Y2Q5ZTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUcxLTArBgNVBAUTJDQ1MGQ3YWNhLWJiYmYtNGMxMS1iMDFjLTRmOGVh\nNzMyMjA4NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAc8jU7+XFcfzE1qcWJ6\nEUlCpe+QMqVbFsgnNvXmzQilxA6EyzEHJ2GnYDKjo+vOb/JYF4FsmSZEXMj+ChqR\n3K6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBT3EQrfnIxTmlM9Z86TDhIwQ5APIDAfBgNVHSMEGDAWgBTUcIf65aXCQTLztt71\nY2qBtC3/ezAKBggqhkjOPQQDAgNIADBFAiEAlb6MI8CRamDu7aGCibTNQZZLMTb3\n40JxruG+JsV9pPoCIGaHqvobDpbgdeJKG+uJVEGQrlbkqDGrN9Vp3TlUuZL+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAfdVLRhXDebKfTnl9g2PprHlMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDQ1\nMGQ3YWNhLWJiYmYtNGMxMS1iMDFjLTRmOGVhNzMyMjA4NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUYxLTArBgNVBAUTJDQ1N2NjYzcyLWUwMTItNDM1NS1iOTA2LTU4Y2Qw\nNjY5Y2Q5ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIwtXJWqEUXII0/QyQoD\nateV6hUe+znxWyblTIFhO0TBD08NBVaeTMR8ZqS1FlCZV7x7QU/3oLUZQnc8LxXA\nXPKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTUcIf65aXCQTLztt71Y2qBtC3/ezAfBgNVHSMEGDAWgBT3EQrfnIxTmlM9Z86T\nDhIwQ5APIDAKBggqhkjOPQQDAgNIADBFAiEAgmHUbsfJHoTgjVidT/ldIpikcLhh\nvJHsqJY64XUNdgcCIBiUkwGgk0jMtAfQouMhaCk1ZSotLnQ2iP9TenvFkPCk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQoQ6/8Fnfd4eYVWBkXHoB7jMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUgxLTArBgNVBAUTJGM0\nYmIxMjVhLTlhN2UtNGI1YS05MGUxLTA5MDc5YTA2NGYxYTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDc5ZTU2OTE3LWVmZjctNDVjNi04MWI4LTE4NDIz\nZTgwMTI2ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPhn5fgalX6La1jwgmnn\nVw+kE6AGL7/yYt3iav8L9s0SxsgMDx7b6i+PCSA4MNbgjMVoHFJ3HtaHDNb+UPjf\n3GKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSvWpgc6tx9+w6LioDMlZNWkYNDJjAfBgNVHSMEGDAWgBSFQK9AcaNUwP0QytEf\nsiNn8fbvFDAKBggqhkjOPQQDAgNJADBGAiEA++iXdhJUohjaSIc1ilaOx68MbAho\nK3WXKR8p7SWe49QCIQDq/+cplBPMd49jxfUL1LsDSl800e4MT0qD7Ony259AYw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAbgXmwQUiO4/PzKZhs9m/HkLMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUkxLTArBgNVBAUTJDc5\nZTU2OTE3LWVmZjctNDVjNi04MWI4LTE4NDIzZTgwMTI2ZjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUgxLTArBgNVBAUTJGM0YmIxMjVhLTlhN2UtNGI1YS05MGUxLTA5MDc5\nYTA2NGYxYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAx0Z3MwPAVKSeebvTII\nP9SL1dx/Lwrwkku+/qnPvfczhnLQVcSkoAxygMnjE75ahTdFJSRSRj3hVPZ4QxH7\nI7GjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSFQK9AcaNUwP0QytEfsiNn8fbvFDAfBgNVHSMEGDAWgBSvWpgc6tx9+w6LioDM\nlZNWkYNDJjAKBggqhkjOPQQDAgNJADBGAiEA6Lq6ixRiiGCG8Xvh0Y0eGod3RDGA\n6P575GflpLHL19ICIQD7E8C/QSEYVT17lemssilB+dXm/krsnpupI7QtnS0jwA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUCQWMKS/4KNVzxJZlW/wbMqMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUcxLTArBgNVBAUTJDQ1\nMGQ3YWNhLWJiYmYtNGMxMS1iMDFjLTRmOGVhNzMyMjA4NDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUkxLTArBgNVBAUTJDc5ZTU2OTE3LWVmZjctNDVjNi04MWI4LTE4NDIz\nZTgwMTI2ZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPhn5fgalX6La1jwgmnn\nVw+kE6AGL7/yYt3iav8L9s0SxsgMDx7b6i+PCSA4MNbgjMVoHFJ3HtaHDNb+UPjf\n3GKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSvWpgc6tx9+w6LioDMlZNWkYNDJjAfBgNVHSMEGDAWgBT3EQrfnIxTmlM9Z86T\nDhIwQ5APIDAKBggqhkjOPQQDAgNIADBFAiEAvL9+S3nDq9K7cQSvjFaNAI56DV5d\nR7b+xPzN4350PEACIHAgqZ7Y0VqDfgphXWRo5FjByrUf4Ss0ldTwKQzUVxsO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAfR71WZxDP7a/4x2O28ixCftMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGVmNjkyNGNkLTA2OWQtNDJhMC1hZDNkLWIyNjRiZTNkMDZiMzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUYxLTArBgNVBAUTJDQ1N2NjYzcyLWUwMTItNDM1NS1iOTA2LTU4\nY2QwNjY5Y2Q5ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIwtXJWqEUXII0/Q\nyQoDateV6hUe+znxWyblTIFhO0TBD08NBVaeTMR8ZqS1FlCZV7x7QU/3oLUZQnc8\nLxXAXPKjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTUcIf65aXCQTLztt71Y2qBtC3/ezAfBgNVHSMEGDAWgBQ+6qQQpStN5tK9\nK3/1XajYIfdcyzAKBggqhkjOPQQDAgNIADBFAiBnkcABJ4dOM2nJgjdQeCfIj0mr\nRV7hLsjSceny5wY9bAIhAKwIePPZo+/fPhdn4w8CaSG6ZTHmgDZEVwRAzNNXeDNg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISATBgz52ErO/TmYR2iIrzCkfBMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGVmNjkyNGNkLTA2OWQtNDJhMC1hZDNkLWIyNjRiZTNkMDZiMzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUcxLTArBgNVBAUTJDQ1MGQ3YWNhLWJiYmYtNGMxMS1iMDFjLTRm\nOGVhNzMyMjA4NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAc8jU7+XFcfzE1q\ncWJ6EUlCpe+QMqVbFsgnNvXmzQilxA6EyzEHJ2GnYDKjo+vOb/JYF4FsmSZEXMj+\nChqR3K6jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBT3EQrfnIxTmlM9Z86TDhIwQ5APIDAfBgNVHSMEGDAWgBQ+6qQQpStN5tK9\nK3/1XajYIfdcyzAKBggqhkjOPQQDAgNIADBFAiEA+4EHP/s4UfPIYFGQD7FQzTty\nuhxoXglusJWwrr+9CLgCIGMDi/bizGoC0muvtcMc0bDIl/5ks2HcUsX7QABM6B0i\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAf3Ct+LNUQUoTI/KPb1GjxzhMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUoxLTArBgNVBAUTJDA0\nZjEwNGNkLTJlNTktNDEwZi1iZmE4LTc3Y2EzZmRkMmNkZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUsxLTArBgNVBAUTJGM1MTg1ZjdlLWJkMmMtNGZjYi04ZGFlLTY3ZmYz\nZmU1MTAzYTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEv5ZJX3Ewpx7qNYAsLl\nClQu19SqECNVT+oA5kRyGgAadYUVWagTnm+ULvFzy9LHlaUZGh9ES6pPNlQodXLi\nQESjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRs0WcnqPmtBsbFrg0a3tB57evKGDAfBgNVHSMEGDAWgBRNxoktnJHz1GV7Ifgg\nEsPpheVRrjAKBggqhkjOPQQDAgNHADBEAiAoznuL3KDmd+S5CXA8qqEXSYt3/hS5\n0TAmXDfNQ+T0WgIgNS2w9tHSHCpytBmiLNlXft7iWjDMYL//fHy2zXcHVzc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAVolBOUiWRkZgsKlksXk34cHMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDJk\nOWVkMGM4LTg2MDQtNDhkZC1iZDY4LTExMzRlY2ZkMTM2ZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU4xLTArBgNVBAUTJDAzN2FiODAyLWIwMDUtNDFlMi05Y2U2LTdlZGFh\nZGM5NGZmYzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABL2wPbHeOSH8EsNqfgCj\nrfVjtnkB80M/9y+m6lCAfZTpm/3/t82Wnd/Dtap8KLD1Yd1PPnWu9/uyqx5l9F/W\n9cijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTIAZqD1zOnJ6I48MsoDcZQvtSS/zAfBgNVHSMEGDAWgBTc7m5fM58rtBtKU9th\nSEvBwp8rzDAKBggqhkjOPQQDAgNHADBEAiAEelVkImpdTk+vZ/NYLlnEYqlNRDgS\nzBq21pk1tkVpGAIgVJ6rI4Fo51yUA9G584tnRusJNlvqN8DxYx63GelLkWU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAcO34n0h9ei1A04BuYx0BmkiMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUwxLTArBgNVBAUTJDJk\nOWVkMGM4LTg2MDQtNDhkZC1iZDY4LTExMzRlY2ZkMTM2ZDAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAU0xLTArBgNVBAUTJGM0NGQ0OTI3LWM5ZDMtNDBhNi05ZDg4LTZjOWQ2\nZjNmZWFlNTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHbD/NFVT1UW6cwHibvG\n4bML8EVZZDB1wf2F2abhT6c+vUWqfOhn6aCWnwlxB2hs/WWesePJ7FgWf4qOkFwn\nAZijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRRoMYV7w73wgQuPlty15VAWG/18jAfBgNVHSMEGDAWgBTc7m5fM58rtBtKU9th\nSEvBwp8rzDAKBggqhkjOPQQDAgNHADBEAiBWSmhNnX869Pg+Rju33if/snTNA22h\nzTxe6Ymexs+9tQIgASxPhX+A8WBELVLiakxub3EpvyJoH2c8ZBTDFzk0vPQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDTCCAbKgAwIBAgISAcStGeIQrSxL5p/nUl1NBrbTMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDJhMTkxZDNhLWZmMDgtNGQ1YS1iMzFhLTkxNjkyOTQzYWQ2ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUoxLTArBgNVBAUTJDA0ZjEwNGNkLTJlNTktNDEwZi1iZmE4LTc3\nY2EzZmRkMmNkZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG59J7Mavzx+uQ+F\nubMKFHY7vV+eHdvmBvXsn3HHjFEflqRB7b6fKKSFfY6ORdo/yZryCK48U8eay6Ul\n6lzmHNijYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRNxoktnJHz1GV7IfggEsPpheVRrjAfBgNVHSMEGDAWgBTwc7hGLFkzAKm3\nE400jLRe0tRfeDAKBggqhkjOPQQDAgNJADBGAiEAjcSvmysEBJfLuMG8hrtw8+kM\nSRTw5zpFq1hPQ2pqMosCIQC8FFVNuxDHApRT3cuUN2ceTojEWuaxvAQl0gqxxwW+\nKg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAQJ/oPjD4qeoCrc/1d7TFw3CMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDJhMTkxZDNhLWZmMDgtNGQ1YS1iMzFhLTkxNjkyOTQzYWQ2ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUwxLTArBgNVBAUTJDJkOWVkMGM4LTg2MDQtNDhkZC1iZDY4LTEx\nMzRlY2ZkMTM2ZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKqMErmaZB2Ebtxu\nEiDipyxEiR95MfSmgeuVxfD8EhXMVOkTtQHIYr2fhOE/YSzETd90KXxmHR0RdH79\nvRfm8CujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTc7m5fM58rtBtKU9thSEvBwp8rzDAfBgNVHSMEGDAWgBTwc7hGLFkzAKm3\nE400jLRe0tRfeDAKBggqhkjOPQQDAgNHADBEAiAwJQNCXjdP+af8+AJzwJdQMA/t\no3021MiRMvE8iqlERgIgJq7a9O4kIveX+BNDPBO72WTmusV1Y+Z4ZlPsC/+edXQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAYbZbWq0W/AXeoEH06D3DfeMMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDA2\nYzcxZDEwLTNmNDctNDVjMC1hNGIxLThkZTk3ZGE5Y2I2MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUUxLTArBgNVBAUTJDM4YTcwNDM0LTdjYTktNGEwZS05ODVkLTQ4N2Iz\nZGE5MDVkOTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAGM+uOVpMsZY+5fsHRY\nP5Yyo/pxLNBdg85CeXdSDODy6PRkDU8s7EFkoova6a6ZH5cTERwvsPtVHWZyUi7i\nYs2jYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTQJWWwF+wGiGS1Dwn3qRFv10h5AzAfBgNVHSMEGDAWgBQIV6k2MUkuQ+IPtG4X\n9JbBuHjebjAKBggqhkjOPQQDAgNHADBEAiAYQbFHckERRBaQ2f304zmQKpKDk+8Q\nMbQJWiXVsNe5UQIgOI0J+YwBqZ2lnZKwIkRq/fUC+Im+3Vc40V6MOOc+93Y=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAQRICsGEiWCgcBlIOAi4f3FRMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUIxLTArBgNVBAUTJDA2\nYzcxZDEwLTNmNDctNDVjMC1hNGIxLThkZTk3ZGE5Y2I2MTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUQxLTArBgNVBAUTJDJmNzU2Mjk4LTJlNjMtNGU0OS1iNWE2LWMyYjJl\nNTVkYmNmODBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOGv0imSTlAGBbAINkEQ\nN+OJ0HXacglG9Rqon62bvQga80H8pZWoXH0G6KXa6xjyTudEEyI+ATE9JzvKiRMN\nv7ujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTUu+qt6HNKdL7sPExzLtfMP+rogTAfBgNVHSMEGDAWgBQIV6k2MUkuQ+IPtG4X\n9JbBuHjebjAKBggqhkjOPQQDAgNIADBFAiBViXSj2ZmGlsPv83eKQtGetduUcaZY\n8Rl8H2Q6RKS/AQIhAN8NoXrvTZbZFdOK/ehpdnAqaPxzCh87fC6mUlWoi8Nu\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISASp14g09qp6FzC86jSB47ViSMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGYz\nN2M4MDU2LTRhZTItNGIyNy1hNDMxLTM3NDU0NmM5ZGFlMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDA2YzcxZDEwLTNmNDctNDVjMC1hNGIxLThkZTk3\nZGE5Y2I2MTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEPgVUw/fKMlDuvvAUJ7\nKDuaB/QneiAzC3/3LUY8X9dLQTdCMaM0XxUxfgxrRnUyOBMnmCX05rmra/ZtnZpQ\nuKujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQIV6k2MUkuQ+IPtG4X9JbBuHjebjAfBgNVHSMEGDAWgBRZwlx4uOmOqH2vfDzd\ndMHTDAUf5zAKBggqhkjOPQQDAgNHADBEAiBaTzkDSg5U1xkfKiQBLzDhi6PIMBV9\nUxBvSWX43JmYlwIgcnkzNeWaBzCkuQIqurLKjQzzggnfg4lKBd8hCzEouI4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAUgTTK7tf8O29TLNULg58k5VMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGJi\nMWJiZDhkLWZiOGItNDBjYS05ZTA4LTg2MjQzODM5ZWU5YTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUIxLTArBgNVBAUTJDA2YzcxZDEwLTNmNDctNDVjMC1hNGIxLThkZTk3\nZGE5Y2I2MTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEPgVUw/fKMlDuvvAUJ7\nKDuaB/QneiAzC3/3LUY8X9dLQTdCMaM0XxUxfgxrRnUyOBMnmCX05rmra/ZtnZpQ\nuKujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBQIV6k2MUkuQ+IPtG4X9JbBuHjebjAfBgNVHSMEGDAWgBTL3GuaiLzVW3KZlIDB\nRTJopHv36DAKBggqhkjOPQQDAgNIADBFAiEAnkYq7qpddcq9hhNLT5cMIeOlpkak\nvPkZmULbovXqVE8CIHYGWhaOm76RCOdEicgx1kLDQt+pe9UWPlxQBvP1IAMc\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAQR2YLeAe0Z4hOBoI2mwfBPUMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUExLTArBgNVBAUTJGYz\nN2M4MDU2LTRhZTItNGIyNy1hNDMxLTM3NDU0NmM5ZGFlMTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUMxLTArBgNVBAUTJGJiMWJiZDhkLWZiOGItNDBjYS05ZTA4LTg2MjQz\nODM5ZWU5YTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCVcaZLCxpykBzyg6hTh\nvyFe3yljbK7+2w48rrSfUF9jp7WqzguT0TY4LKWQ4/CqneX6MgOfF/NJhOKOK0TG\npcCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTL3GuaiLzVW3KZlIDBRTJopHv36DAfBgNVHSMEGDAWgBRZwlx4uOmOqH2vfDzd\ndMHTDAUf5zAKBggqhkjOPQQDAgNJADBGAiEA5hIzKpi/gV43y2RkbrxmmcPNHQWp\nt6lbdia3q6cCTZ8CIQCCtNI3Wn4ycwCkjGRdcdsIDB/jhwwi+VX0MKb27Bxcdg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAV9K3xpK0QTQ+FR3Cutr7qEpMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAUMxLTArBgNVBAUTJGJi\nMWJiZDhkLWZiOGItNDBjYS05ZTA4LTg2MjQzODM5ZWU5YTAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAUExLTArBgNVBAUTJGYzN2M4MDU2LTRhZTItNGIyNy1hNDMxLTM3NDU0\nNmM5ZGFlMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAXivWj/ouNRSi0BfXU7\nUmWYp9pY+25dI8gTeKYeYA5US453RLns8xZUjXtQaG6FJngPiuijY4++44urTyPu\nr8qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBRZwlx4uOmOqH2vfDzddMHTDAUf5zAfBgNVHSMEGDAWgBTL3GuaiLzVW3KZlIDB\nRTJopHv36DAKBggqhkjOPQQDAgNJADBGAiEAph6d0u5iUWEtmO16XbaEX4rwjgSZ\nX4yexnQ4OPmP8h8CIQCY+/YGvRRiVNrIWssTq3gLr/tR/uvYwGLK3SAmAn64tg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICDDCCAbKgAwIBAgISAe5ehVHi8/U4vKS3KtxX5sHmMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDM5MzU1YTEzLWVlZGMtNGUyNy04ZDAxLWZlNjNhODA5YzE4NDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUExLTArBgNVBAUTJGYzN2M4MDU2LTRhZTItNGIyNy1hNDMxLTM3\nNDU0NmM5ZGFlMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAXivWj/ouNRSi0B\nfXU7UmWYp9pY+25dI8gTeKYeYA5US453RLns8xZUjXtQaG6FJngPiuijY4++44ur\nTyPur8qjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRZwlx4uOmOqH2vfDzddMHTDAUf5zAfBgNVHSMEGDAWgBSFOHAx4mSBlJJS\n+VcTnwIXtjAq4jAKBggqhkjOPQQDAgNIADBFAiAemTIu5GmRStgn7NSyy/FdREyW\nYc9S6dHKfJMu07aPqwIhANeTpDTDkKhgFD5af17Sat9ollsePMmS0FjZGg1OHr+5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCzCCAbKgAwIBAgISAe34JVe6GyTLaxq/EXPiLtLxMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDM5MzU1YTEzLWVlZGMtNGUyNy04ZDAxLWZlNjNhODA5YzE4NDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nCjAIBgNVBAMTAUMxLTArBgNVBAUTJGJiMWJiZDhkLWZiOGItNDBjYS05ZTA4LTg2\nMjQzODM5ZWU5YTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCVcaZLCxpykBzyg\n6hThvyFe3yljbK7+2w48rrSfUF9jp7WqzguT0TY4LKWQ4/CqneX6MgOfF/NJhOKO\nK0TGpcCjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBTL3GuaiLzVW3KZlIDBRTJopHv36DAfBgNVHSMEGDAWgBSFOHAx4mSBlJJS\n+VcTnwIXtjAq4jAKBggqhkjOPQQDAgNHADBEAiAiyJqLOg/D1h9usddarSJbJUIY\nSvhoxrC5EnZ6RPPchAIgRxbGM3zumdY4dIPLhBUC9mg2QpEcG85CFeXeELpYV60=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCjCCAa+gAwIBAgISAX0k1SKJoklhFACSSBaaur1sMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVIxLTArBgNVBAUTJDll\nNTNhYzlhLWEzZjgtNDQ4MC1iZmUwLWViMDg5MjI0MWE5MjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGU5Y2UxOTE4LTQ1ZDYtNGZiNy05NThmLTU3MTFl\nN2YxMTYyZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBeLP2r9fA0zmdF744wa\njOFYHwX24SewzkG7E/JbGwkipMk90XV3RNKVG5lfeKF4la19qjrS5JhFq0Ch2TDU\nNQujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSZRTsMyaAoEqKvDJjpkXHUPjgBGDAfBgNVHSMEGDAWgBSU3v282FMmtADOL1aH\nOWtEJWntdTAKBggqhkjOPQQDAgNJADBGAiEAmVvedTra5wEv3wkY8vRl4Wm0gx/y\ny/jtPOteN4TXPSECIQD/ZY239opf0HJxlr+wZ3OeQFdw24cBkFmuNH9fteLdAQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAS3nOHhUQ5v0exGGz6sS7Ei/MAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDgy\nYjgzODJjLWJlNDEtNDk2My1iYmZmLTUyZTc2YTNhODhiODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVIxLTArBgNVBAUTJDllNTNhYzlhLWEzZjgtNDQ4MC1iZmUwLWViMDg5\nMjI0MWE5MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNdPPRpi8BH8xJeyWcaB\nQvihOy3DEgR9z/VUOzhKP+rJktmxVYs3SQEZLhcdWREOylzQTijCFwzJzsTAzxPg\npqqjYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSU3v282FMmtADOL1aHOWtEJWntdTAfBgNVHSMEGDAWgBRQXpRFOuYd9VtokB48\nvFELh997uzAKBggqhkjOPQQDAgNHADBEAiAcHHkvs8/6FCPwdmnSFY8cZme6Tsx3\nn/d1NrItQLN8NgIgIGp+3F8fXAvBPpHVBF65C36OEr3+9vKhwf6ioy2tenU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCDCCAa+gAwIBAgISAZFAER1QdR8yOJikFV7rpf3fMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU8xLTArBgNVBAUTJDgy\nYjgzODJjLWJlNDEtNDk2My1iYmZmLTUyZTc2YTNhODhiODAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVExLTArBgNVBAUTJDFiNjViNzFiLWRmNDgtNGJhMy05MzM1LTQyNTgy\nZWQ2YmQ3MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLPUTh/b2PTvasukxqvw\nzJC/QL86B/Lq6Y2W44piV5XX+CrTP2vXNeVZ34ZA8bl0J1l9QhrvNCoTIax5Nved\n09ajYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBTOfiSapodJS7I9YTZIGKIVtzoOvTAfBgNVHSMEGDAWgBRQXpRFOuYd9VtokB48\nvFELh997uzAKBggqhkjOPQQDAgNHADBEAiB8WUQjdpipgGOW9vdFgQJCuEqGv3Ot\nE5x56RjrOcciTQIgXWE1teB5nzyZB7yg9Z/x/qLGkSLi0M2XKOPcq0ZJ3Cg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICCTCCAa+gAwIBAgISAWDguz8JnvdZQZD2ybHOJxGjMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAVAxLTArBgNVBAUTJGZk\nNmQxODQ5LTFlNTItNGQ1Yy1iY2IxLWJkOTUwNjgyMTdiMjAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFMxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAI\nBgNVBAMTAVMxLTArBgNVBAUTJGU5Y2UxOTE4LTQ1ZDYtNGZiNy05NThmLTU3MTFl\nN2YxMTYyZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABBeLP2r9fA0zmdF744wa\njOFYHwX24SewzkG7E/JbGwkipMk90XV3RNKVG5lfeKF4la19qjrS5JhFq0Ch2TDU\nNQujYzBhMA4GA1UdDwEB/wQEAwICBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSZRTsMyaAoEqKvDJjpkXHUPjgBGDAfBgNVHSMEGDAWgBRQKqD4tmz5C/CftqMf\n+FwU9OsATzAKBggqhkjOPQQDAgNIADBFAiA+ac3fi1EzLrMZffKAlXatQ1Ie9eQ9\n21CcHQqkvYgIswIhANC6n7C27HgJSeIoKhh8bavnIP5DxN1WUZcx5yn/YITk\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISASbmJmjI8W1+lhjQFFQVO4FQMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFPMS0wKwYDVQQFEyQ4MmI4MzgyYy1i\nZTQxLTQ5NjMtYmJmZi01MmU3NmEzYTg4YjgwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAAQR958WbKz81EsKNsWk2YCKaWWIOMECaD6uYofThKEjeeSBYfUL7MQ5u3P9\nbKlZJGbrPiqdFwwM8CyBL0oq4o9uo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUF6URTrmHfVbaJAePLxRC4ffe7swHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAK8n\nNiLdXwHkx0iGdAGuSLIDJHy9ebWQKNY00aE4gs5mAiBeS5wBPWlJsYLAEOGtoQog\nD3bN5ihktDezilefnhMuxw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICHDCCAcKgAwIBAgISARiXZhYbCQrvmGg3+64mvBbvMAoGCCqGSM49BAMCMGYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xHTAbBgNVBAMMFGJldHRlcnRsc190cnVz\ndF9yb290MS0wKwYDVQQFEyQ2YzU5NmMwZC01ZDhhLTQ5ZDUtOGFjOS00MWUwNGRl\nMWQ4Y2MwHhcNMjYwMTE5MTcyNTU0WhcNMjcwMTIxMTcyNTU0WjBTMRYwFAYDVQQK\nEw1iZXR0ZXJ0bHMuY29tMQowCAYDVQQDEwFQMS0wKwYDVQQFEyRmZDZkMTg0OS0x\nZTUyLTRkNWMtYmNiMS1iZDk1MDY4MjE3YjIwWTATBgcqhkjOPQIBBggqhkjOPQMB\nBwNCAASQA9s3mXGqlp4ssc7zF9SWANQVc7c6TyuLOT7OJce/1roF4jwTARTcO7QI\nrGjYwVFB1fE3GzfzTDbPu3tg9W+jo2MwYTAOBgNVHQ8BAf8EBAMCAgQwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUCqg+LZs+Qvwn7ajH/hcFPTrAE8wHwYDVR0j\nBBgwFoAUSmacmwv0HQuFABoc7YS4a4I72PUwCgYIKoZIzj0EAwIDSAAwRQIhAOgK\nbyvtsULEpdJni8HUeMFZQ+ME/PckwaauZU4W8mHbAiBs5vC35U2Qj6+L58rBsoPJ\n7CeYkVWiXHRbr1WMOfC3hQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAZhzB2knZzAVhxw/4NomYtvEMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFcxLTArBgNVBAUT\nJGVmNjkyNGNkLTA2OWQtNDJhMC1hZDNkLWIyNjRiZTNkMDZiMzAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZjhkZjJlZWYtYWQwYy00NzZk\nLTk0MGQtNTI2NmNjYTczYTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj6zQ\n9X2bNZjzjzqf77AVSD4ZS+AL1YNnDavbNAXD9WPGADzjy5+9mUkbvrGs05qSFact\nsJ3JTExYYDQZvQm9HKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFIWpGUyXAw/gb0DIUYPSr7qdVj+7MB8GA1UdIwQYMBaAFD7q\npBClK03m0r0rf/VdqNgh91zLMAoGCCqGSM49BAMCA0kAMEYCIQDOREf+RnDpdSYE\nK+gakS3vskIiLz3Ud1LHNDstOWaZAAIhAJzjOyjTVuJXPKj5FRGQL6X5NN187IpT\nzC5OFfAteX6U\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICEzCCAbqgAwIBAgISAQ+OUIpnnhifeYbFLJfNrOKSMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZjhkZjJlZWYtYWQwYy00NzZkLTk0MGQtNTI2NmNjYTczYTlkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgVzEtMCsGA1UEBRMkZWY2OTI0Y2QtMDY5ZC00MmEw\nLWFkM2QtYjI2NGJlM2QwNmIzMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEygO2\ncAXXwiYVxOMZYT5899X4J2f81xV8Ki46qxdf3y1dprLbAi1Z9GBInMe3ckQ/5EiD\nX3+52UaCWtsmm86qzqNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFD7qpBClK03m0r0rf/VdqNgh91zLMB8GA1UdIwQYMBaAFIWp\nGUyXAw/gb0DIUYPSr7qdVj+7MAoGCCqGSM49BAMCA0cAMEQCIEkBQWQzzdFDS3FY\noh+5WOkys7DYLKISf6OUchv+sJu4AiBTsIR1gD9tW+49u6WgSHajybcMjvD2nxaL\ng3xaV8FvcA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISATQla0U8nWjrjd/ImPgxgXzfMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFgxLTArBgNVBAUT\nJDJhMTkxZDNhLWZmMDgtNGQ1YS1iMzFhLTkxNjkyOTQzYWQ2ZDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZjhkZjJlZWYtYWQwYy00NzZk\nLTk0MGQtNTI2NmNjYTczYTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj6zQ\n9X2bNZjzjzqf77AVSD4ZS+AL1YNnDavbNAXD9WPGADzjy5+9mUkbvrGs05qSFact\nsJ3JTExYYDQZvQm9HKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFIWpGUyXAw/gb0DIUYPSr7qdVj+7MB8GA1UdIwQYMBaAFPBz\nuEYsWTMAqbcTjTSMtF7S1F94MAoGCCqGSM49BAMCA0gAMEUCIEZePq4T46Yh9M9H\n9EHuGpsfr9tXzAL3+TqNIvjKWXD4AiEA83rDJf2Tc3ILHo2vuGy8yvMiCL+orA0T\nFYFKkUNjAdU=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFTCCAbqgAwIBAgISAUGHZZmcA4l0m3AzPnET8jKwMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZjhkZjJlZWYtYWQwYy00NzZkLTk0MGQtNTI2NmNjYTczYTlkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWDEtMCsGA1UEBRMkMmExOTFkM2EtZmYwOC00ZDVh\nLWIzMWEtOTE2OTI5NDNhZDZkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAEWT\n/sR3ePP8DRRBMfGFRIGnGS8FKkiy4TyHRpkEUGZNZVxmxDDX8MR4DWuxv9QSsuGY\nMwo1ZRijb9xUNqOAn6NjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFPBzuEYsWTMAqbcTjTSMtF7S1F94MB8GA1UdIwQYMBaAFIWp\nGUyXAw/gb0DIUYPSr7qdVj+7MAoGCCqGSM49BAMCA0kAMEYCIQCPQisNFCUpxNM3\n5Hyt4Ku/JrDX6GCby2g71/SNepucngIhAJ5oNb4adNdOvfzCyu00po5qNQEms1Sv\nIbXo2J4ZuaS+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAbz0dKxfgP2BFVTb0A1CorvJMAoGCCqGSM49BAMCMFYx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xDTALBgNVBAMTBFRBIFkxLTArBgNVBAUT\nJDM5MzU1YTEzLWVlZGMtNGUyNy04ZDAxLWZlNjNhODA5YzE4NDAeFw0yNjAxMTkx\nNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoTDWJldHRlcnRscy5jb20x\nEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZjhkZjJlZWYtYWQwYy00NzZk\nLTk0MGQtNTI2NmNjYTczYTlkMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj6zQ\n9X2bNZjzjzqf77AVSD4ZS+AL1YNnDavbNAXD9WPGADzjy5+9mUkbvrGs05qSFact\nsJ3JTExYYDQZvQm9HKNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFIWpGUyXAw/gb0DIUYPSr7qdVj+7MB8GA1UdIwQYMBaAFIU4\ncDHiZIGUklL5VxOfAhe2MCriMAoGCCqGSM49BAMCA0gAMEUCIQD4Dawc4oUPt41i\nPftlv+0oh+mepnaEGU8AvzT3/7J+rQIgIdfPQGL5YBLi+WqE5q0DTbDsmIh18VRt\nLEEJz5Tgq7I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICFDCCAbqgAwIBAgISAafZWodkCgpjCugHDeoBihQXMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZjhkZjJlZWYtYWQwYy00NzZkLTk0MGQtNTI2NmNjYTczYTlkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowVjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTENMAsGA1UEAxMEVEEgWTEtMCsGA1UEBRMkMzkzNTVhMTMtZWVkYy00ZTI3\nLThkMDEtZmU2M2E4MDljMTg0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0O7u\npEf5ZH+Z4+K4Ag3vi4QfGX1V2z8oNhiaB937klW2ePnKa51uMZ3hfL1K2Ny+8Rft\nZMinKfFaDZiaDh9jFaNjMGEwDgYDVR0PAQH/BAQDAgIEMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFIU4cDHiZIGUklL5VxOfAhe2MCriMB8GA1UdIwQYMBaAFIWp\nGUyXAw/gb0DIUYPSr7qdVj+7MAoGCCqGSM49BAMCA0gAMEUCIQD4f/i5MqSoFCkE\nyP3hy9/CQiUuqYLv0C79dfL7yBCxPwIgAOtcVWohLCe1vGVM84uwweOGv1NWDZ+m\nxudKqX/iJ7A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICIjCCAcmgAwIBAgISAVidoHpiTnVMgkSGoDgwGP9BMAkGByqGSM49BAEwZjEW\nMBQGA1UEChMNYmV0dGVydGxzLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0\nX3Jvb3QxLTArBgNVBAUTJDZjNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUx\nZDhjYzAeFw0yNjAxMTkxNzI1NTRaFw0yNzAxMjExNzI1NTRaMFsxFjAUBgNVBAoT\nDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsGA1UEBRMkZjhk\nZjJlZWYtYWQwYy00NzZkLTk0MGQtNTI2NmNjYTczYTlkMFkwEwYHKoZIzj0CAQYI\nKoZIzj0DAQcDQgAEj6zQ9X2bNZjzjzqf77AVSD4ZS+AL1YNnDavbNAXD9WPGADzj\ny5+9mUkbvrGs05qSFactsJ3JTExYYDQZvQm9HKNjMGEwDgYDVR0PAQH/BAQDAgIE\nMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFIWpGUyXAw/gb0DIUYPSr7qdVj+7\nMB8GA1UdIwQYMBaAFEpmnJsL9B0LhQAaHO2EuGuCO9j1MAkGByqGSM49BAEDSAAw\nRQIhAO92Tb28UqaoUBFUtvfGslvIBmvOXKCiNZLWPCnhVTYZAiAdji7/eocoga6t\nvRrbv21fR5XtLDbeJxqvCY6QPrRa2A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICJTCCAcqgAwIBAgISAZYcuUksOIzWMmZU5eGHmA6AMAoGCCqGSM49BAMCMFsx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xEjAQBgNVBAMTCUJyaWRnZSBDQTEtMCsG\nA1UEBRMkZjhkZjJlZWYtYWQwYy00NzZkLTk0MGQtNTI2NmNjYTczYTlkMB4XDTI2\nMDExOTE3MjU1NFoXDTI3MDEyMTE3MjU1NFowZjEWMBQGA1UEChMNYmV0dGVydGxz\nLmNvbTEdMBsGA1UEAwwUYmV0dGVydGxzX3RydXN0X3Jvb3QxLTArBgNVBAUTJDZj\nNTk2YzBkLTVkOGEtNDlkNS04YWM5LTQxZTA0ZGUxZDhjYzBZMBMGByqGSM49AgEG\nCCqGSM49AwEHA0IABMWcwM5NefO5zhtLWHHH1EtfpLCdvA/o3RELLzNslbtytVSw\nktVm/R7tw8D2kTQhb6SFBVUD/CnnsA4W95bTAZajYzBhMA4GA1UdDwEB/wQEAwIC\nBDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRKZpybC/QdC4UAGhzthLhrgjvY\n9TAfBgNVHSMEGDAWgBSFqRlMlwMP4G9AyFGD0q+6nVY/uzAKBggqhkjOPQQDAgNJ\nADBGAiEApe4BZGUMsHvn2bPdRJwgXJhWOIX3Z6yohRZfcn+Yu+MCIQCzIKC5pg0T\nYaZFWmbC/0Vgrlg03balcGsanYRGS89AIQ==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIICFDCCAbmgAwIBAgISAfH6Cnpb/oncnKHhiijj1FbNMAoGCCqGSM49BAMCMFMx\nFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCjAIBgNVBAMTAU4xLTArBgNVBAUTJDAz\nN2FiODAyLWIwMDUtNDFlMi05Y2U2LTdlZGFhZGM5NGZmYzAeFw0yNjAxMTkxNzI1\nNTRaFw0yNzAxMjExNzI1NTRaMFQxFjAUBgNVBAoTDWJldHRlcnRscy5jb20xCzAJ\nBgNVBAMTAkVFMS0wKwYDVQQFEyQ5M2NhYmZmNy1iY2YwLTRhYjItYTk5OS02ZWU2\nYjE5NzIyMmQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATjSromwftKTWS9PkPQ\n9R609CSIB4KN3u8clc3fYkoGEdr/Ezg4lwgpdd+t8SYuWIhrdIbQeYBVbPADp2na\nqXq6o2wwajAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYD\nVR0TAQH/BAIwADAfBgNVHSMEGDAWgBTIAZqD1zOnJ6I48MsoDcZQvtSS/zAUBgNV\nHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAOa6TEPBPwyOHIUI\ncyjYQs99IeVEYUfO9u6gNxiTaFF6AiEAroJolSRrmj75uABj7i8uatsH/dkAwVFU\ngqoZQxb+4Z8=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-19T17:25:55+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "FAILURE", + "expected_peer_name": { + "kind": "DNS", + "value": "localhost" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::akamai.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `akamai.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw\nCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu\nZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe\nFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw\nEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x\nIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF\nK4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG\nfp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO\nZ9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd\nBgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx\nAK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/\noAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8\nsycX\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIDeTCCAv+gAwIBAgIQCwDpLU1tcx/KMFnHyx4YhjAKBggqhkjOPQQDAzBhMQsw\nCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu\nZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe\nFw0yMTA0MTQwMDAwMDBaFw0zMTA0MTMyMzU5NTlaMFkxCzAJBgNVBAYTAlVTMRUw\nEwYDVQQKEwxEaWdpQ2VydCBJbmMxMzAxBgNVBAMTKkRpZ2lDZXJ0IEdsb2JhbCBH\nMyBUTFMgRUNDIFNIQTM4NCAyMDIwIENBMTB2MBAGByqGSM49AgEGBSuBBAAiA2IA\nBHipnHWuiF1jpK1dhtgQSdavklljQyOF9EhlMM1KNJWmDj7ZfAjXVwUoSJ4Lq+vC\n05ae7UXSi4rOAUsXQ+Fzz21zSDTcAEYJtVZUyV96xxMH0GwYF2zK28cLJlYujQf1\nZ6OCAYIwggF+MBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFIoj655r1/k3\nXfltITl2mqFn3hCoMB8GA1UdIwQYMBaAFLPbSKT5ocXYrjZBzBFjaWIpvEvGMA4G\nA1UdDwEB/wQEAwIBhjAdBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwdgYI\nKwYBBQUHAQEEajBoMCQGCCsGAQUFBzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5j\nb20wQAYIKwYBBQUHMAKGNGh0dHA6Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdp\nQ2VydEdsb2JhbFJvb3RHMy5jcnQwQgYDVR0fBDswOTA3oDWgM4YxaHR0cDovL2Ny\nbDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0R2xvYmFsUm9vdEczLmNybDA9BgNVHSAE\nNjA0MAsGCWCGSAGG/WwCATAHBgVngQwBATAIBgZngQwBAgEwCAYGZ4EMAQICMAgG\nBmeBDAECAzAKBggqhkjOPQQDAwNoADBlAjB+Jlhu7ojsDN0VQe56uJmZcNFiZU+g\nIJ5HsVvBsmcxHcxyeq8ickBCbmWE/odLDxkCMQDmv9auNIdbP2fHHahv1RJ4teaH\nMUSpXca4eMzP79QyWBH/OoUGPB2Eb9P1+dozHKQ=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIFvDCCBUKgAwIBAgIQBJYYSzPWwZnwLyEw7ZklSzAKBggqhkjOPQQDAzBZMQsw\nCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMTMwMQYDVQQDEypEaWdp\nQ2VydCBHbG9iYWwgRzMgVExTIEVDQyBTSEEzODQgMjAyMCBDQTEwHhcNMjYwNTE4\nMDAwMDAwWhcNMjYxMjAyMjM1OTU5WjB2MQswCQYDVQQGEwJVUzEWMBQGA1UECBMN\nTWFzc2FjaHVzZXR0czESMBAGA1UEBxMJQ2FtYnJpZGdlMSIwIAYDVQQKExlBa2Ft\nYWkgVGVjaG5vbG9naWVzLCBJbmMuMRcwFQYDVQQDEw53d3cuYWthbWFpLmNvbTBZ\nMBMGByqGSM49AgEGCCqGSM49AwEHA0IABA4clizPhsoYdAFUzwSIhJ6VvTT/DUXl\nRHCqYv8MiwoIY1kf+lZNtq5PEo+nqLbjZqX9MtM3x9QqSqmN5QiFdVijggPNMIID\nyTAfBgNVHSMEGDAWgBSKI+uea9f5N135bSE5dpqhZ94QqDAdBgNVHQ4EFgQU6oy/\nIzFpShQimDBH8+ECueLVoqYwaAYDVR0RBGEwX4IOd3d3LmFrYW1haS5jb22CCmFr\nYW1haS5jb22CFGRldmVsb3Blci5ha2FtYWkuY29tghVkZXZlbG9wZXJzLmFrYW1h\naS5jb22CFGRvY3NlYXJjaC5ha2FtYWkuY29tMD4GA1UdIAQ3MDUwMwYGZ4EMAQIC\nMCkwJwYIKwYBBQUHAgEWG2h0dHA6Ly93d3cuZGlnaWNlcnQuY29tL0NQUzAOBgNV\nHQ8BAf8EBAMCA4gwEwYDVR0lBAwwCgYIKwYBBQUHAwEwgZ8GA1UdHwSBlzCBlDBI\noEagRIZCaHR0cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0R2xvYmFsRzNU\nTFNFQ0NTSEEzODQyMDIwQ0ExLTIuY3JsMEigRqBEhkJodHRwOi8vY3JsNC5kaWdp\nY2VydC5jb20vRGlnaUNlcnRHbG9iYWxHM1RMU0VDQ1NIQTM4NDIwMjBDQTEtMi5j\ncmwwgYcGCCsGAQUFBwEBBHsweTAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGln\naWNlcnQuY29tMFEGCCsGAQUFBzAChkVodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5j\nb20vRGlnaUNlcnRHbG9iYWxHM1RMU0VDQ1NIQTM4NDIwMjBDQTEtMi5jcnQwDAYD\nVR0TAQH/BAIwADCCAXwGCisGAQQB1nkCBAIEggFsBIIBaAFmAHUAwjF+V0UZo0Xu\nfzjespBB68fCIVoiv3/Vta12mtkOUs0AAAGeO9kSnwAABAMARjBEAiBayPOLnoS7\nR6cvasCaX1/JwSjeQcWt9pd/41Ji3uYGMAIgZumuMt+nIYJjNrcrD3iRPHB0d60X\ngBClVxMYB2gI04QAdgDXbX0Q0af1d8LH6V/XAL/5gskzWmXh0LMBcxfAyMVpdwAA\nAZ472RJ3AAAEAwBHMEUCIQD2/8hX+BbtlfYat4hDiforPqtaE+okkPJ3Boa9wAqx\nfQIgfaqAZ47wcg5kf+tOFDdBGUNgDzSGXKpyS80ssXzAzKQAdQCUTkOH+uzB74Hz\nGSQmqBhlAcfTXzgCAT9yZ31VNy4Z2AAAAZ472RKtAAAEAwBGMEQCIGeiHRM1K1lz\nNZym1xUpdahIbN3YbXJW2OWK3wRilFITAiAsCUYaM8E6oNtImlzQoa0k/d1ni9Ug\nMPrvWmL1bcdVtDAKBggqhkjOPQQDAwNoADBlAjBowSS55/WqNJ7bYKLBhFmBY1NX\ngswfezmNB5Ic1kz9MaJ47cRYipgek5ltRRWlow4CMQCPrLPpe6bIyPK9Q/mDqrxE\nkf85+ldctRSMbJyiPvQz/cAkS5FijOuAFraFl+dXHPA=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-05-18T00:00:01+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "akamai.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::bing.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `bing.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\nd3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH\nMjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT\nMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j\nb20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG\n9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI\n2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx\n1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ\nq2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz\ntCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ\nvIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP\nBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV\n5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY\n1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4\nNeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG\nFdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91\n8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe\npLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl\nMrY=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----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\nNJ7DzNfImza7xSXi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIFiTCCBHGgAwIBAgIQCwxrLEZpF7BHc8ZH1K/AyDANBgkqhkiG9w0BAQwFADBh\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\nd3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH\nMjAeFw0yNTA1MjEwMDAwMDBaFw0yOTA2MTkyMzU5NTlaMFExCzAJBgNVBAYTAlVT\nMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xIjAgBgNVBAMTGU1pY3Jv\nc29mdCBUTFMgUlNBIFJvb3QgRzIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK\nAoICAQDf6oufR+EoEHGvQdYZ25JX3mur5i7erTpgg7cTmKxbuTILe+ufcidrXUCr\nvhgGk7IN0hLtuHT1fy/qqBeU9jMWV4reIHwh3bfarN5OZLBazUt18+8CZE3tUtqj\njwTokfjX+z8Z/U5FOV7oKcPW8mevswCUwY3h8EoYmDn6wAmEM0EFAwWr9HXhU6Uh\nklxETOZgV6SQApfH1diTBDJK7YVR7dbFuqA/Noovb0w5qARpIoQ7dRT32T60qdAH\nQTiBfkZIHegZ5nC4oKoY3XK/fn21bE4ZcBGEBBOB1GL9nGvxHN3/7Kfg5seNMUu/\n8mszzNGMtv6xG6NKqF8OfzF2OD8HR2wBqKylFNqCsF8fbLyJGsASKst7lx8oLjEW\nilNMdWb5fQHWwmCqZY8xnnLLzJst5UQZk1erbo7C2S5lsHIt56HDoX5JHVln1gnU\nGBJtwJVFeMnxYGrk9u4GJDtzSloRwj6XYcB47u8TpzDiSjgt7lgXEyC3NirfCzK0\nwjixkd0SsEW2fMCxHWKhnd1xEhWWAZ0KCfWx3bPZ4DhCNPZptsOvFnP+1EP4Q+RY\n+U+z8+zWPZQ6QDgVqwyG0GTOGmPohJRVCVq2BLbRPpoVx2QRgNAbgg5N/0WesmUH\nJR/bmsjG7NZbhVAEnxzLXSCCZ5554t/o8uhvxCByMIblnXUnNQIDAQABo4IBSzCC\nAUcwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3pGGSLehMVkx8UtfB6nciHna\nqHYwHwYDVR0jBBgwFoAUTiJUIBiV5uNu5g/6+rkS7QYXjzkwDgYDVR0PAQH/BAQD\nAgGGMBMGA1UdJQQMMAoGCCsGAQUFBwMBMHYGCCsGAQUFBwEBBGowaDAkBggrBgEF\nBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEAGCCsGAQUFBzAChjRodHRw\nOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRHbG9iYWxSb290RzIuY3J0\nMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdp\nQ2VydEdsb2JhbFJvb3RHMi5jcmwwEwYDVR0gBAwwCjAIBgZngQwBAgIwDQYJKoZI\nhvcNAQEMBQADggEBAAu8tCs3dMVLpzYCNsav4RPMipqXG/zjRIzuVADl5EEaRvAL\ndjT/mVViNaqtipwMWmLMQ8DL6kodvWsdr7EZJWac93luWyWAJIGFx3ktNV9CCXjt\nn+Jl1cQgUIIQj2o67RiOSImrpgn44YD8BnUWJyVaj7g6cGwYR/Bj9FMO2RU1IPOR\nPRMBoOL6JAhFVnfRZ6kxQtBX/xomvsVD2FepY/+v8zrY9ntLEKKXoc9mvmdnCfm1\nTOerGSu/Ij193sb372M4LN1WxPkJUtrf44hv1W1r9whBL44+hjGf8XxK9dZhpEZG\nKO9XurBvktjSdyXte6YpzjtyeRHU4KdUbTUrpHo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\n3bCB4CB8wYI0S2/nFX2KOeLktHwwuX8jHYf1v8PZOw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-09-01T17:05:47+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "bing.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::fastly.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `fastly.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx\nEDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT\nHFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs\nZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw\nMFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6\nb25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj\naG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp\nY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\nggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg\nnLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1\nHOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N\nHwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN\ndloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0\nHZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO\nBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G\nCSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU\nsHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3\n4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg\n8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K\npL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1\nmMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIEoDCCA4igAwIBAgIIEYMc3ky1c+UwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNV\nBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUw\nIwYDVQQKExxTdGFyZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylT\ndGFyZmllbGQgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjAeFw0yMjA2\nMjIwMDAwMDBaFw0zMjA2MjEyMzU5NTlaMEUxCzAJBgNVBAYTAlVTMRIwEAYDVQQK\nEwlDZXJ0YWlubHkxIjAgBgNVBAMTGUNlcnRhaW5seSBJbnRlcm1lZGlhdGUgUjEw\nggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCW0khmsa1kAMrw6Q6kPsiZ\n6LfWXQcpcDnu1+Ql7+FYYyBKT3zFSsjx+ZTI2yRG2sFOwbBMchtQf5MGUoQfNznR\nANlqUNXdWlMrkso93JburzqBEoNGy8utK0TNnepMbb1yc4YuXk/nMRZaBPA2Lh8u\ntwUG3vMvNQHsliV48CQ+4CJutM34rvI9AfJeI2CkcxBUlCyYatGcA12nvCr7dGdy\nEKeG5G4XyBak48571FtQqNqkSkCQlqmv93LVoOHqzEQKcJWw8zPxZc0dnORZVmgL\nl3Ws/QltCsIf6OTyQOfGHi81ehr6P4j1KQ56MfgWcqBqdeIANxVcb0ZVVb3SiEhT\nAgMBAAGjggFHMIIBQzASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIB\nhjAdBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwHQYDVR0OBBYEFL2Xnd+h\n2BslmeMMBAaJZBLXZSTHMB8GA1UdIwQYMBaAFHwMMh+n2TB/xH1oo2Kooc6rB1sn\nMF4GCCsGAQUFBwEBBFIwUDBOBggrBgEFBQcwAoZCaHR0cDovL2NlcnRpZmljYXRl\ncy5zdGFyZmllbGR0ZWNoLmNvbS9yZXBvc2l0b3J5L3Nmcm9vdC1nMi5jcnQuY2Vy\nMDsGA1UdHwQ0MDIwMKAuoCyGKmh0dHA6Ly9jcmwuc3RhcmZpZWxkdGVjaC5jb20v\nc2Zyb290LWcyLmNybDAhBgNVHSAEGjAYMAgGBmeBDAECATAMBgorBgEEAYOGGQEB\nMA0GCSqGSIb3DQEBCwUAA4IBAQBosoh/lcTPBVC36SxIqjmdnuKwHs4SUDa/o5+y\nAJ22DaZDIFMJS+LLhslCVPAO9lQ5LR0AviC8atueKWOxPUw5aNDodEpIe988xSNa\nLSuPXsAB93FJ5v2BxdCiDHlIZbJPAOVQAo+rP2WgaTcDFX6g6LvK1b/RS9kL+rCB\nOebvFIbOmhfErkXjR7F6p759ftTQ23tT1qoTgegkySRgugEp0mtveWq87UIsGgdI\ne3UVWONiA9l3hTmxRyHkaYLlBzDdVPt4MIUkFrxZAz/8ebh+x2KNfAO6Mxi/vdS0\n9NEqn0ekjRmQK5UvHXoBNHVvZ1VrbMv6hlIMCt++bfb6UBoK\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIFOjCCBCKgAwIBAgISeF8RRZlWraa8wNkjaEZ7aGMVMA0GCSqGSIb3DQEBCwUA\nMEUxCzAJBgNVBAYTAlVTMRIwEAYDVQQKEwlDZXJ0YWlubHkxIjAgBgNVBAMTGUNl\ncnRhaW5seSBJbnRlcm1lZGlhdGUgUjEwHhcNMjYwODI1MTkzMjAwWhcNMjYwOTI0\nMTkzMTU5WjAZMRcwFQYDVQQDEw53d3cuZmFzdGx5LmNvbTCCASIwDQYJKoZIhvcN\nAQEBBQADggEPADCCAQoCggEBAKslzgZFw3cg+GsIXTnj9F8JV9ATYoazD3PD76B4\ndhhGOwPQeI3VhGLj/3PICcN6RKEp4PBcCtFpyfjN78qh8FBXscl7YCo+WeGQzWEA\nomAyaGekrXrIeMzUt9f4bVGmwCO81l72LXnA5AqTDjArz2s5mZbo+gIR2mA92Nv6\nckhzTWKcluRZ8a47N8/SSWxBGZkZTgn0gKeGqotXDPx4PWJzYVg1kWrkEeyILKmT\nnKlihBdMu8Zodd6m9AWaMTibEmP5NGWE4/jUzj/eCuFKandXK2+IZUTdVOrJY5hF\nPy4HfNFyo02FzztmpZXZJmY40PDBz+BVLhLG5LRcWpHiLD0CAwEAAaOCAk4wggJK\nMA4GA1UdDwEB/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8E\nAjAAMB0GA1UdDgQWBBQZMw3sc6I5VagFYF5dPmsZzMtZTTAfBgNVHSMEGDAWgBS9\nl53fodgbJZnjDAQGiWQS12UkxzA3BggrBgEFBQcBAQQrMCkwJwYIKwYBBQUHMAKG\nG2h0dHA6Ly9pbnQtcjEuY2VydGFpbmx5LmNvbTA7BgNVHREENDAyghRkZXZlbG9w\nZXIuZmFzdGx5LmNvbYIKZmFzdGx5LmNvbYIOd3d3LmZhc3RseS5jb20wEwYDVR0g\nBAwwCjAIBgZngQwBAgEwQgYDVR0fBDswOTA3oDWgM4YxaHR0cDovL2NybHMuY2Vy\ndGFpbmx5LmNvbS8xNzE4MjI2MjQ1MzAwMjUxNC84LmNybDCCAQQGCisGAQQB1nkC\nBAIEgfUEgfIA8AB3ANdtfRDRp/V3wsfpX9cAv/mCyTNaZeHQswFzF8DIxWl3AAAB\noDqeCO0AAAQDAEgwRgIhAK1SDgJp+MaAq4ZYeLvKmEMxDkIY7MaQ/p9AoklJs8ko\nAiEAye7lBpJub7RSUWySlw1Y8zGr+LZn6kE8ghScRHCVaFoAdQCvZ4g7V7BO3Y+m\n2X72LqjrgQrHcWDwJF5V1gwv54WHOgAAAaA6ngmsAAAEAwBGMEQCIHVNFxF/2ZtV\nslVTde6oR8DRGpLFBrCPWjoz1c5TyHb/AiBsG/OtPo3fqV3o9wcpUxuP117QcOQ8\nZuwWZhyW7WsjYTANBgkqhkiG9w0BAQsFAAOCAQEAWIc64xie+mPE8J+Ultfj6uUy\niozcEJN47Tog66FNBs26ZxC2Mp+I22al6SNdrMroNa41YASW01c85rmR515qB+yO\naINbCN6vyjX7ott9gq9/a6dn19YY4fZJF1NBLWTgl4X5dG21inxiCP9afQmP+KG+\nGtVOLij9ovEmYaTiD/PSFtGxkd29+4ogPy7yk2dRwHrNBRuLqWmT2Haez406nYSj\nyf12vrf+a1YoG371nNKSymHJnL3AwRjR2XAXz6J21f5xB2ZrJ27RrBFXXfrn1NPT\nFPKLXwRy85IK4KGCcmSUwurkfHj97Zh7o1FJ85h/mq23SXBHsNbyRwQrnlqOdw==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-08-25T19:32:01+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "fastly.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::s3.amazonaws.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `s3.amazonaws.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF\nADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6\nb24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL\nMAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv\nb3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj\nca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM\n9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw\nIFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6\nVOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L\n93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm\njgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC\nAYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA\nA4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI\nU5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs\nN+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv\no/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU\n5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy\nrqXRfboQnoZsG4q5WTP468SQvvG5\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIEXjCCA0agAwIBAgITB3MSTyqVLj7Rili9uF0bwM5fJzANBgkqhkiG9w0BAQsF\nADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6\nb24gUm9vdCBDQSAxMB4XDTIyMDgyMzIyMjYzNVoXDTMwMDgyMzIyMjYzNVowPDEL\nMAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEcMBoGA1UEAxMTQW1hem9uIFJT\nQSAyMDQ4IE0wNDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM3pVR6A\nlQOp4xe776FdePXyejgA38mYx1ou9/jrpV6Sfn+/oqBKgwhY6ePsQHHQayWBJdBn\nv4Wz363qRI4XUh9swBFJ11TnZ3LqOMvHmWq2+loA0QPtOfXdJ2fHBLrBrngtJ/GB\n0p5olAVYrSZgvQGP16Rf8ddtNyxEEhYm3HuhmNi+vSeAq1tLYJPAvRCXonTpWdSD\nxY6hvdmxlqTYi82AtBXSfpGQ58HHM0hw0C6aQakghrwWi5fGslLOqzpimNMIsT7c\nqa0GJx6JfKqJqmQQNplO2h8n9ZsFJgBowof01ppdoLAWg6caMOM0om/VILKaa30F\n9W/r8Qjah7ltGVkCAwEAAaOCAVowggFWMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYD\nVR0PAQH/BAQDAgGGMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAdBgNV\nHQ4EFgQUH1KSYVaCVH+BZtgdPQqqMlyH3QgwHwYDVR0jBBgwFoAUhBjMhTTsvAyU\nlC4IWZzHshBOCggwewYIKwYBBQUHAQEEbzBtMC8GCCsGAQUFBzABhiNodHRwOi8v\nb2NzcC5yb290Y2ExLmFtYXpvbnRydXN0LmNvbTA6BggrBgEFBQcwAoYuaHR0cDov\nL2NydC5yb290Y2ExLmFtYXpvbnRydXN0LmNvbS9yb290Y2ExLmNlcjA/BgNVHR8E\nODA2MDSgMqAwhi5odHRwOi8vY3JsLnJvb3RjYTEuYW1hem9udHJ1c3QuY29tL3Jv\nb3RjYTEuY3JsMBMGA1UdIAQMMAowCAYGZ4EMAQIBMA0GCSqGSIb3DQEBCwUAA4IB\nAQA+1O5UsAaNuW3lHzJtpNGwBnZd9QEYFtxpiAnIaV4qApnGS9OCw5ZPwie7YSlD\nZF5yyFPsFhUC2Q9uJHY/CRV1b5hIiGH0+6+w5PgKiY1MWuWT8VAaJjFxvuhM7a/e\nfN2TIw1Wd6WCl6YRisunjQOrSP+unqC8A540JNyZ1JOE3jVqat3OZBGgMvihdj2w\nY23EpwesrKiQzkHzmvSH67PVW4ycbPy08HVZnBxZ5NrlGG9bwXR3fNTaz+c+Ej6c\n5AnwI3qkOFgSkg3Y75cdFz6pO/olK+e3AqygAcv0WjzmkDPuBjssuZjCHMC56oH3\nGJkV29Di2j5prHJbwZjG1inU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\njQgSFhAkjWQtSETRnOUYdHwtCrMpPr8zdfWprbfstvwoDxmu+s4irg==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2025-11-18T00:00:01+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "s3.amazonaws.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::aws.amazon.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `aws.amazon.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF\nADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6\nb24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL\nMAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv\nb3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj\nca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM\n9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw\nIFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6\nVOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L\n93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm\njgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC\nAYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA\nA4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI\nU5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs\nN+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv\no/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU\n5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy\nrqXRfboQnoZsG4q5WTP468SQvvG5\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIEXjCCA0agAwIBAgITB3MSTyqVLj7Rili9uF0bwM5fJzANBgkqhkiG9w0BAQsF\nADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6\nb24gUm9vdCBDQSAxMB4XDTIyMDgyMzIyMjYzNVoXDTMwMDgyMzIyMjYzNVowPDEL\nMAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEcMBoGA1UEAxMTQW1hem9uIFJT\nQSAyMDQ4IE0wNDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM3pVR6A\nlQOp4xe776FdePXyejgA38mYx1ou9/jrpV6Sfn+/oqBKgwhY6ePsQHHQayWBJdBn\nv4Wz363qRI4XUh9swBFJ11TnZ3LqOMvHmWq2+loA0QPtOfXdJ2fHBLrBrngtJ/GB\n0p5olAVYrSZgvQGP16Rf8ddtNyxEEhYm3HuhmNi+vSeAq1tLYJPAvRCXonTpWdSD\nxY6hvdmxlqTYi82AtBXSfpGQ58HHM0hw0C6aQakghrwWi5fGslLOqzpimNMIsT7c\nqa0GJx6JfKqJqmQQNplO2h8n9ZsFJgBowof01ppdoLAWg6caMOM0om/VILKaa30F\n9W/r8Qjah7ltGVkCAwEAAaOCAVowggFWMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYD\nVR0PAQH/BAQDAgGGMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAdBgNV\nHQ4EFgQUH1KSYVaCVH+BZtgdPQqqMlyH3QgwHwYDVR0jBBgwFoAUhBjMhTTsvAyU\nlC4IWZzHshBOCggwewYIKwYBBQUHAQEEbzBtMC8GCCsGAQUFBzABhiNodHRwOi8v\nb2NzcC5yb290Y2ExLmFtYXpvbnRydXN0LmNvbTA6BggrBgEFBQcwAoYuaHR0cDov\nL2NydC5yb290Y2ExLmFtYXpvbnRydXN0LmNvbS9yb290Y2ExLmNlcjA/BgNVHR8E\nODA2MDSgMqAwhi5odHRwOi8vY3JsLnJvb3RjYTEuYW1hem9udHJ1c3QuY29tL3Jv\nb3RjYTEuY3JsMBMGA1UdIAQMMAowCAYGZ4EMAQIBMA0GCSqGSIb3DQEBCwUAA4IB\nAQA+1O5UsAaNuW3lHzJtpNGwBnZd9QEYFtxpiAnIaV4qApnGS9OCw5ZPwie7YSlD\nZF5yyFPsFhUC2Q9uJHY/CRV1b5hIiGH0+6+w5PgKiY1MWuWT8VAaJjFxvuhM7a/e\nfN2TIw1Wd6WCl6YRisunjQOrSP+unqC8A540JNyZ1JOE3jVqat3OZBGgMvihdj2w\nY23EpwesrKiQzkHzmvSH67PVW4ycbPy08HVZnBxZ5NrlGG9bwXR3fNTaz+c+Ej6c\n5AnwI3qkOFgSkg3Y75cdFz6pO/olK+e3AqygAcv0WjzmkDPuBjssuZjCHMC56oH3\nGJkV29Di2j5prHJbwZjG1inU\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\nr71o4ToMZRi5D0I0hrSqJz4ZkXWAXGZH7JhwmsU22/R3b6R9\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2025-11-06T00:00:01+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "aws.amazon.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::docs.python.org", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `docs.python.org`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G\nA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp\nZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4\nMTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG\nA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI\nhvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8\nRgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT\ngHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm\nKPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd\nQQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ\nXriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw\nDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o\nLkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU\nRUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp\njjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK\n6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX\nmcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs\nMx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH\nWD9f\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIEkDCCA3igAwIBAgIRAIPahqsOMbGdjwOl7dW9vWYwDQYJKoZIhvcNAQELBQAw\nTDEgMB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkds\nb2JhbFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMjUwNzE2MDMwNjM1WhcN\nMjcwNzE2MDAwMDAwWjBYMQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2ln\nbiBudi1zYTEuMCwGA1UEAxMlR2xvYmFsU2lnbiBBdGxhcyBSMyBEViBUTFMgQ0Eg\nMjAyNSBRNDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMxqPHokJx19\nu/UzIIDj3xVbvZUVaaYagOIlNGQ9bI6v6ftebJuQmHEIhz0p2gqxVfWSjRsJ3AJR\nxZc/3Ay08xjL0fYTFWdiF86X6yXwmkpv3MkhhqfQKrbWfv+2Tf6Hf9lrtR6//Cuj\nOBNvRe/qcryl/HfN+u+n+YGTkT397id+feK5qQg5YoJbkBnjeKHt2HOxtJYxfggT\nYSE/zS0CKzfEL0ttYO0cBRycopII5bSgfOEpicA/JqLNimyVQFfL+T10arNK6LW4\nuiPfWhHsxGtlb7Hml9yNd+8Os3jBTrz+Do8EDwcYbKG4efC9PL4ZR8Pop0uDGaaU\nkI5buvF6tjMCAwEAAaOCAV8wggFbMA4GA1UdDwEB/wQEAwIBhjAdBgNVHSUEFjAU\nBggrBgEFBQcDAQYIKwYBBQUHAwIwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4E\nFgQUsEOeMHD23v1UHhI6HeD3Ycv7IMcwHwYDVR0jBBgwFoAUj/BLf6guRSSuTVD6\nY5qL3uLdG7wwewYIKwYBBQUHAQEEbzBtMC4GCCsGAQUFBzABhiJodHRwOi8vb2Nz\ncDIuZ2xvYmFsc2lnbi5jb20vcm9vdHIzMDsGCCsGAQUFBzAChi9odHRwOi8vc2Vj\ndXJlLmdsb2JhbHNpZ24uY29tL2NhY2VydC9yb290LXIzLmNydDA2BgNVHR8ELzAt\nMCugKaAnhiVodHRwOi8vY3JsLmdsb2JhbHNpZ24uY29tL3Jvb3QtcjMuY3JsMCEG\nA1UdIAQaMBgwCAYGZ4EMAQIBMAwGCisGAQQBoDIKAQMwDQYJKoZIhvcNAQELBQAD\nggEBALJnnt6rIjXwl6+6W0XrYYuSF91baTVFiFLKG7I8YBEhiLBsYL4juDZcyWtB\nPvw1zHZHYWRC//ruG6diKB/hxeIfOU563a3dP0ct8GGakGL7Q/nKleSoEWjnabNO\nPeH4brw+ZgbRz7VBPXv+6y+P+1qqwUrvLmgawPRW4HYMQ65TXnKh7O7lN/SacDbZ\n53J0YTNPy4JLQoK/gqGFmPiHOLbLre/F4gblRnsRmDY6Ow10Cv+6+a/ktWzmSioK\noeU4gGL5XuXhBJFv8kkJkgLNSotWuE/r/izVYXzcaI6e2hgwnA6AB2e2vCJmS1ow\nZqY63DngXSg4Vs9JR97+KjaDGu0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\ns06+jSRkCDni0ky01ug43M6Z73FOvRw0qnJUljRdzRka17tVLkw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-01-13T13:03:47+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "docs.python.org" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::amazon.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `amazon.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\nd3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH\nMjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT\nMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j\nb20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG\n9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI\n2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx\n1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ\nq2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz\ntCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ\nvIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP\nBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV\n5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY\n1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4\nNeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG\nFdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91\n8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe\npLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl\nMrY=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIEjTCCA3WgAwIBAgIQDQd4KhM/xvmlcpbhMf/ReTANBgkqhkiG9w0BAQsFADBh\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\nd3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH\nMjAeFw0xNzExMDIxMjIzMzdaFw0yNzExMDIxMjIzMzdaMGAxCzAJBgNVBAYTAlVT\nMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j\nb20xHzAdBgNVBAMTFkdlb1RydXN0IFRMUyBSU0EgQ0EgRzEwggEiMA0GCSqGSIb3\nDQEBAQUAA4IBDwAwggEKAoIBAQC+F+jsvikKy/65LWEx/TMkCDIuWegh1Ngwvm4Q\nyISgP7oU5d79eoySG3vOhC3w/3jEMuipoH1fBtp7m0tTpsYbAhch4XA7rfuD6whU\ngajeErLVxoiWMPkC/DnUvbgi74BJmdBiuGHQSd7LwsuXpTEGG9fYXcbTVN5SATYq\nDfbexbYxTMwVJWoVb6lrBEgM3gBBqiiAiy800xu1Nq07JdCIQkBsNpFtZbIZhsDS\nfzlGWP4wEmBQ3O67c+ZXkFr2DcrXBEtHam80Gp2SNhou2U5U7UesDL/xgLK6/0d7\n6TnEVMSUVJkZ8VeZr+IUIlvoLrtjLbqugb0T3OYXW+CQU0kBAgMBAAGjggFAMIIB\nPDAdBgNVHQ4EFgQUlE/UXYvkpOKmgP792PkA76O+AlcwHwYDVR0jBBgwFoAUTiJU\nIBiV5uNu5g/6+rkS7QYXjzkwDgYDVR0PAQH/BAQDAgGGMB0GA1UdJQQWMBQGCCsG\nAQUFBwMBBggrBgEFBQcDAjASBgNVHRMBAf8ECDAGAQH/AgEAMDQGCCsGAQUFBwEB\nBCgwJjAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEIGA1Ud\nHwQ7MDkwN6A1oDOGMWh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEds\nb2JhbFJvb3RHMi5jcmwwPQYDVR0gBDYwNDAyBgRVHSAAMCowKAYIKwYBBQUHAgEW\nHGh0dHBzOi8vd3d3LmRpZ2ljZXJ0LmNvbS9DUFMwDQYJKoZIhvcNAQELBQADggEB\nAIIcBDqC6cWpyGUSXAjjAcYwsK4iiGF7KweG97i1RJz1kwZhRoo6orU1JtBYnjzB\nc4+/sXmnHJk3mlPyL1xuIAt9sMeC7+vreRIF5wFBC0MCN5sbHwhNN1JzKbifNeP5\nozpZdQFmkCo+neBiKR6HqIA+LMTMCMMuv2khGGuPHmtDze4GmEGZtYLyF8EQpa5Y\njPuV6k2Cr/N3XxFpT3hRpt/3usU/Zb9wfKPtWpoznZ4/44c1p9rzFcZYrWkj3A+7\nTNBJE0GmP2fhXhP1D/XVfIW/h0yCJGEiV9Glm/uGOa3DXHlmbAcxSyCRraG+ZBkA\n7h4SeM6Y8l/7MBRpPCz6l8Y=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\nO2xJ2i5fPPykWWLmGJ+8LwzzdYOhoEw=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-05-05T00:00:01+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "amazon.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::facebook.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `facebook.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\nd3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH\nMjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT\nMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j\nb20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG\n9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI\n2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx\n1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ\nq2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz\ntCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ\nvIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP\nBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV\n5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY\n1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4\nNeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG\nFdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91\n8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe\npLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl\nMrY=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIEyDCCA7CgAwIBAgIQDPW9BitWAvR6uFAsI8zwZjANBgkqhkiG9w0BAQsFADBh\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\nd3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH\nMjAeFw0yMTAzMzAwMDAwMDBaFw0zMTAzMjkyMzU5NTlaMFkxCzAJBgNVBAYTAlVT\nMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxMzAxBgNVBAMTKkRpZ2lDZXJ0IEdsb2Jh\nbCBHMiBUTFMgUlNBIFNIQTI1NiAyMDIwIENBMTCCASIwDQYJKoZIhvcNAQEBBQAD\nggEPADCCAQoCggEBAMz3EGJPprtjb+2QUlbFbSd7ehJWivH0+dbn4Y+9lavyYEEV\ncNsSAPonCrVXOFt9slGTcZUOakGUWzUb+nv6u8W+JDD+Vu/E832X4xT1FE3LpxDy\nFuqrIvAxIhFhaZAmunjZlx/jfWardUSVc8is/+9dCopZQ+GssjoP80j812s3wWPc\n3kbW20X+fSP9kOhRBx5Ro1/tSUZUfyyIxfQTnJcVPAPooTncaQwywa8WV0yUR0J8\nosicfebUTVSvQpmowQTCd5zWSOTOEeAqgJnwQ3DPP3Zr0UxJqyRewg2C/Uaoq2yT\nzGJSQnWS+Jr6Xl6ysGHlHx+5fwmY6D36g39HaaECAwEAAaOCAYIwggF+MBIGA1Ud\nEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFHSFgMBmx9833s+9KTeqAx2+7c0XMB8G\nA1UdIwQYMBaAFE4iVCAYlebjbuYP+vq5Eu0GF485MA4GA1UdDwEB/wQEAwIBhjAd\nBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwdgYIKwYBBQUHAQEEajBoMCQG\nCCsGAQUFBzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wQAYIKwYBBQUHMAKG\nNGh0dHA6Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEdsb2JhbFJvb3RH\nMi5jcnQwQgYDVR0fBDswOTA3oDWgM4YxaHR0cDovL2NybDMuZGlnaWNlcnQuY29t\nL0RpZ2lDZXJ0R2xvYmFsUm9vdEcyLmNybDA9BgNVHSAENjA0MAsGCWCGSAGG/WwC\nATAHBgVngQwBATAIBgZngQwBAgEwCAYGZ4EMAQICMAgGBmeBDAECAzANBgkqhkiG\n9w0BAQsFAAOCAQEAkPFwyyiXaZd8dP3A+iZ7U6utzWX9upwGnIrXWkOH7U1MVl+t\nwcW1BSAuWdH/SvWgKtiwla3JLko716f2b4gp/DA/JIS7w7d7kwcsr4drdjPtAFVS\nslme5LnQ89/nD/7d+MS5EHKBCQRfz5eeLjJ1js+aWNJXMX43AYGyZm0pGrFmCW3R\nbpD0ufovARTFXFZkAdl9h6g4U5+LXUZtXMYnhIHUfoyMo5tS58aI7Dd8KvvwVVo4\nchDYABPPTHPbqjc1qCmBaZx2vN4Ye5DUys/vZwP9BFohFrH/6j/f3IL16/RZkiMN\nJCqVJUzKoZHm1Lesh3Sz8W2jmdv51b2EQJ8HmA==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIGpjCCBY6gAwIBAgIQAum0tI5pKZRMcqZRz6bmFjANBgkqhkiG9w0BAQsFADBZ\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMTMwMQYDVQQDEypE\naWdpQ2VydCBHbG9iYWwgRzIgVExTIFJTQSBTSEEyNTYgMjAyMCBDQTEwHhcNMjYw\nNjE4MDAwMDAwWhcNMjYwOTE2MjM1OTU5WjBvMQswCQYDVQQGEwJVUzETMBEGA1UE\nCBMKQ2FsaWZvcm5pYTETMBEGA1UEBxMKTWVubG8gUGFyazEdMBsGA1UEChMUTWV0\nYSBQbGF0Zm9ybXMsIEluYy4xFzAVBgNVBAMMDiouZmFjZWJvb2suY29tMFkwEwYH\nKoZIzj0CAQYIKoZIzj0DAQcDQgAEuevMd9Qf0Zdnxrvdvn3bT2Pw6xGQbq+3BdRn\nauTUQabpVFMBDdOwRKDhAwrGDyYL+KCE8Tfvwet0a36DhhLZc6OCBB0wggQZMB8G\nA1UdIwQYMBaAFHSFgMBmx9833s+9KTeqAx2+7c0XMB0GA1UdDgQWBBRCnovQXtuo\nsHGgo79X49gZ0h8jDDCBtQYDVR0RBIGtMIGqgg4qLmZhY2Vib29rLmNvbYIOKi5m\nYWNlYm9vay5uZXSCCyouZmJjZG4ubmV0ggsqLmZic2J4LmNvbYIQKi5tLmZhY2Vi\nb29rLmNvbYIPKi5tZXNzZW5nZXIuY29tgg4qLnh4LmZiY2RuLm5ldIIOKi54eS5m\nYmNkbi5uZXSCDioueHouZmJjZG4ubmV0ggxmYWNlYm9vay5jb22CDW1lc3Nlbmdl\nci5jb20wPgYDVR0gBDcwNTAzBgZngQwBAgIwKTAnBggrBgEFBQcCARYbaHR0cDov\nL3d3dy5kaWdpY2VydC5jb20vQ1BTMA4GA1UdDwEB/wQEAwIDiDATBgNVHSUEDDAK\nBggrBgEFBQcDATCBnwYDVR0fBIGXMIGUMEigRqBEhkJodHRwOi8vY3JsMy5kaWdp\nY2VydC5jb20vRGlnaUNlcnRHbG9iYWxHMlRMU1JTQVNIQTI1NjIwMjBDQTEtMS5j\ncmwwSKBGoESGQmh0dHA6Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEdsb2Jh\nbEcyVExTUlNBU0hBMjU2MjAyMENBMS0xLmNybDCBhwYIKwYBBQUHAQEEezB5MCQG\nCCsGAQUFBzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wUQYIKwYBBQUHMAKG\nRWh0dHA6Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEdsb2JhbEcyVExT\nUlNBU0hBMjU2MjAyMENBMS0xLmNydDAMBgNVHRMBAf8EAjAAMIIBfgYKKwYBBAHW\neQIEAgSCAW4EggFqAWgAdgDCMX5XRRmjRe5/ON6ykEHrx8IhWiK/f9W1rXaa2Q5S\nzQAAAZ7YLYPSAAAEAwBHMEUCIHkhdN9oMBY5eFf+647nwdrR0UU7RQB4Fmn0tM0g\npJ3hAiEAmsOOf1h/eRYoO5rmHfjhzP4LdmoWv8527BcuaU+39zUAdQDXbX0Q0af1\nd8LH6V/XAL/5gskzWmXh0LMBcxfAyMVpdwAAAZ7YLYOwAAAEAwBGMEQCIDVV7X/1\n7towBgOqFzdU+Qatp6AC2/uDJSA0wEuoGSshAiA9ol3kpA0a3mTYS5hxjDJJT523\nLJ2bKn6gBr+3L4VZgAB3AJROQ4f67MHvgfMZJCaoGGUBx9NfOAIBP3JnfVU3LhnY\nAAABntgtg+EAAAQDAEgwRgIhAOZBXGgZPrea3XbWAGPLuzDN0tE0ioHR7Y5gK30f\n8jIgAiEAuaDRME7UY97IH6lCkUzMQkRH5SrBR689rmSH9L7uPZQwDQYJKoZIhvcN\nAQELBQADggEBACBtd+Ux6Kr9+cD3eL1PVbDxA/Zl78N66OGGV5A4aDvQ47o0TbmK\ncGZbHmADEwKO4sC3QYfjRpD9DyXSQKZTUDx+bwPmImUfWotx9KcKrF0PNrM1w51V\nsTtRsmt92G2JcdUXS+SLBKAUlSUW4OFPSJlrYIV5H1J0r1em4nfLVu8vrK0QyIBA\na+VAjEAUM/JHBqJJkLN05laP5ZObL1ZxcomVNKVcV7RxGyJernqi7goqRMNr/ao7\nc4RIZP/se7Msu2OQsRAEUU5YkbKFZuDSg3k7ANlhLFi4bBXW/c0koNUtbebKiHoq\ny/T/XRNs+z0KHWXr62zY2NRQKN0BjiXPcsU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-06-18T00:00:01+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "facebook.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::google.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `google.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIFVzCCAz+gAwIBAgINAgPlk28xsBNJiGuiFzANBgkqhkiG9w0BAQwFADBHMQsw\nCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU\nMBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw\nMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp\nY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwggIiMA0GCSqGSIb3DQEBAQUA\nA4ICDwAwggIKAoICAQC2EQKLHuOhd5s73L+UPreVp0A8of2C+X0yBoJx9vaMf/vo\n27xqLpeXo4xL+Sv2sfnOhB2x+cWX3u+58qPpvBKJXqeqUqv4IyfLpLGcY9vXmX7w\nCl7raKb0xlpHDU0QM+NOsROjyBhsS+z8CZDfnWQpJSMHobTSPS5g4M/SCYe7zUjw\nTcLCeoiKu7rPWRnWr4+wB7CeMfGCwcDfLqZtbBkOtdh+JhpFAz2weaSUKK0Pfybl\nqAj+lug8aJRT7oM6iCsVlgmy4HqMLnXWnOunVmSPlk9orj2XwoSPwLxAwAtcvfaH\nszVsrBhQf4TgTM2S0yDpM7xSma8ytSmzJSq0SPly4cpk9+aCEI3oncKKiPo4Zor8\nY/kB+Xj9e1x3+naH+uzfsQ55lVe0vSbv1gHR6xYKu44LtcXFilWr06zqkUspzBmk\nMiVOKvFlRNACzqrOSbTqn3yDsEB750Orp2yjj32JgfpMpf/VjsPOS+C12LOORc92\nwO1AK/1TD7Cn1TsNsYqiA94xrcx36m97PtbfkSIS5r762DL8EGMUUXLeXdYWk70p\naDPvOmbsB4om3xPXV2V4J95eSRQAogB/mqghtqmxlbCluQ0WEdrHbEg8QOB+DVrN\nVjzRlwW5y0vtOUucxD/SVRNuJLDWcfr0wbrM7Rv1/oFB2ACYPTrIrnqYNxgFlQID\nAQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E\nFgQU5K8rJnEaK0gnhS9SZizv8IkTcT4wDQYJKoZIhvcNAQEMBQADggIBAJ+qQibb\nC5u+/x6Wki4+omVKapi6Ist9wTrYggoGxval3sBOh2Z5ofmmWJyq+bXmYOfg6LEe\nQkEzCzc9zolwFcq1JKjPa7XSQCGYzyI0zzvFIoTgxQ6KfF2I5DUkzps+GlQebtuy\nh6f88/qBVRRiClmpIgUxPoLW7ttXNLwzldMXG+gnoot7TiYaelpkttGsN/H9oPM4\n7HLwEXWdyzRSjeZ2axfG34arJ45JK3VmgRAhpuo+9K4l/3wV3s6MJT/KYnAK9y8J\nZgfIPxz88NtFMN9iiMG1D53Dn0reWVlHxYciNuaCp+0KueIHoI17eko8cdLiA6Ef\nMgfdG+RCzgwARWGAtQsgWSl4vflVy2PFPEz0tv/bal8xa5meLMFrUKTX5hgUvYU/\nZ6tGn6D/Qqc6f1zLXbBwHSs09dR2CQzreExZBfMzQsNhFRAbd03OIozUhfJFfbdT\n6u9AWpQKXCBfTkBdYiJ23//OYb2MI3jSNwLgjt7RETeJ9r/tSQdirpLsQBqvFAnZ\n0E6yove+7u7Y/9waLd64NnHi/Hm3lCXRSHNboTXns5lndcEZOitHTtNCjv0xyBZm\n2tIMPNuzjsmhDYAPexZ3FL//2wmUspO8IFgV6dtxQ/PeEMMA3KgqlbbC1j+Qa3bb\nbP6MvPJwNQzcmRk13NfIRmPVNnGuV/u3gm3c\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIFCzCCAvOgAwIBAgIQf/AFoHxM3tEArZ1mpRB7mDANBgkqhkiG9w0BAQsFADBH\nMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM\nQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMjMxMjEzMDkwMDAwWhcNMjkwMjIw\nMTQwMDAwWjA7MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVR29vZ2xlIFRydXN0IFNl\ncnZpY2VzMQwwCgYDVQQDEwNXUjIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\nAoIBAQCp/5x/RR5wqFOfytnlDd5GV1d9vI+aWqxG8YSau5HbyfsvAfuSCQAWXqAc\n+MGr+XgvSszYhaLYWTwO0xj7sfUkDSbutltkdnwUxy96zqhMt/TZCPzfhyM1IKji\naeKMTj+xWfpgoh6zySBTGYLKNlNtYE3pAJH8do1cCA8Kwtzxc2vFE24KT3rC8gIc\nLrRjg9ox9i11MLL7q8Ju26nADrn5Z9TDJVd06wW06Y613ijNzHoU5HEDy01hLmFX\nxRmpC5iEGuh5KdmyjS//V2pm4M6rlagplmNwEmceOuHbsCFx13ye/aoXbv4r+zgX\nFNFmp6+atXDMyGOBOozAKql2N87jAgMBAAGjgf4wgfswDgYDVR0PAQH/BAQDAgGG\nMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjASBgNVHRMBAf8ECDAGAQH/\nAgEAMB0GA1UdDgQWBBTeGx7teRXUPjckwyG77DQ5bUKyMDAfBgNVHSMEGDAWgBTk\nrysmcRorSCeFL1JmLO/wiRNxPjA0BggrBgEFBQcBAQQoMCYwJAYIKwYBBQUHMAKG\nGGh0dHA6Ly9pLnBraS5nb29nL3IxLmNydDArBgNVHR8EJDAiMCCgHqAchhpodHRw\nOi8vYy5wa2kuZ29vZy9yL3IxLmNybDATBgNVHSAEDDAKMAgGBmeBDAECATANBgkq\nhkiG9w0BAQsFAAOCAgEARXWL5R87RBOWGqtY8TXJbz3S0DNKhjO6V1FP7sQ02hYS\nTL8Tnw3UVOlIecAwPJQl8hr0ujKUtjNyC4XuCRElNJThb0Lbgpt7fyqaqf9/qdLe\nSiDLs/sDA7j4BwXaWZIvGEaYzq9yviQmsR4ATb0IrZNBRAq7x9UBhb+TV+PfdBJT\nDhEl05vc3ssnbrPCuTNiOcLgNeFbpwkuGcuRKnZc8d/KI4RApW//mkHgte8y0YWu\nryUJ8GLFbsLIbjL9uNrizkqRSvOFVU6xddZIMy9vhNkSXJ/UcZhjJY1pXAprffJB\nvei7j+Qi151lRehMCofa6WBmiA4fx+FOVsV2/7R6V2nyAiIJJkEd2nSi5SnzxJrl\nXdaqev3htytmOPvoKWa676ATL/hzfvDaQBEcXd2Ppvy+275W+DKcH0FBbX62xevG\niza3F4ydzxl6NJ8hk8R+dDXSqv1MbRT1ybB5W0k8878XSOjvmiYTDIfyc9acxVJr\nY/cykHipa+te1pOhv7wYPYtZ9orGBV5SGOJm4NrB3K1aJar0RfzxC3ikr7Dyc6Qw\nqDTBU39CluVIQeuQRgwG3MuSxl7zRERDRilGoKb8uY45JzmxWuKxrfwT/478JuHU\n/oTxUFqOl2stKnn7QGTq8z29W+GgBLCXSBxC9epaHM0myFH/FJlniXJfHeytWt0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\ntkFYsu4dielszjCk1DF9LgMc15/cEEE=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-08-10T08:37:36+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "google.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::storage.googleapis.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `storage.googleapis.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIFVzCCAz+gAwIBAgINAgPlk28xsBNJiGuiFzANBgkqhkiG9w0BAQwFADBHMQsw\nCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU\nMBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw\nMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp\nY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwggIiMA0GCSqGSIb3DQEBAQUA\nA4ICDwAwggIKAoICAQC2EQKLHuOhd5s73L+UPreVp0A8of2C+X0yBoJx9vaMf/vo\n27xqLpeXo4xL+Sv2sfnOhB2x+cWX3u+58qPpvBKJXqeqUqv4IyfLpLGcY9vXmX7w\nCl7raKb0xlpHDU0QM+NOsROjyBhsS+z8CZDfnWQpJSMHobTSPS5g4M/SCYe7zUjw\nTcLCeoiKu7rPWRnWr4+wB7CeMfGCwcDfLqZtbBkOtdh+JhpFAz2weaSUKK0Pfybl\nqAj+lug8aJRT7oM6iCsVlgmy4HqMLnXWnOunVmSPlk9orj2XwoSPwLxAwAtcvfaH\nszVsrBhQf4TgTM2S0yDpM7xSma8ytSmzJSq0SPly4cpk9+aCEI3oncKKiPo4Zor8\nY/kB+Xj9e1x3+naH+uzfsQ55lVe0vSbv1gHR6xYKu44LtcXFilWr06zqkUspzBmk\nMiVOKvFlRNACzqrOSbTqn3yDsEB750Orp2yjj32JgfpMpf/VjsPOS+C12LOORc92\nwO1AK/1TD7Cn1TsNsYqiA94xrcx36m97PtbfkSIS5r762DL8EGMUUXLeXdYWk70p\naDPvOmbsB4om3xPXV2V4J95eSRQAogB/mqghtqmxlbCluQ0WEdrHbEg8QOB+DVrN\nVjzRlwW5y0vtOUucxD/SVRNuJLDWcfr0wbrM7Rv1/oFB2ACYPTrIrnqYNxgFlQID\nAQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E\nFgQU5K8rJnEaK0gnhS9SZizv8IkTcT4wDQYJKoZIhvcNAQEMBQADggIBAJ+qQibb\nC5u+/x6Wki4+omVKapi6Ist9wTrYggoGxval3sBOh2Z5ofmmWJyq+bXmYOfg6LEe\nQkEzCzc9zolwFcq1JKjPa7XSQCGYzyI0zzvFIoTgxQ6KfF2I5DUkzps+GlQebtuy\nh6f88/qBVRRiClmpIgUxPoLW7ttXNLwzldMXG+gnoot7TiYaelpkttGsN/H9oPM4\n7HLwEXWdyzRSjeZ2axfG34arJ45JK3VmgRAhpuo+9K4l/3wV3s6MJT/KYnAK9y8J\nZgfIPxz88NtFMN9iiMG1D53Dn0reWVlHxYciNuaCp+0KueIHoI17eko8cdLiA6Ef\nMgfdG+RCzgwARWGAtQsgWSl4vflVy2PFPEz0tv/bal8xa5meLMFrUKTX5hgUvYU/\nZ6tGn6D/Qqc6f1zLXbBwHSs09dR2CQzreExZBfMzQsNhFRAbd03OIozUhfJFfbdT\n6u9AWpQKXCBfTkBdYiJ23//OYb2MI3jSNwLgjt7RETeJ9r/tSQdirpLsQBqvFAnZ\n0E6yove+7u7Y/9waLd64NnHi/Hm3lCXRSHNboTXns5lndcEZOitHTtNCjv0xyBZm\n2tIMPNuzjsmhDYAPexZ3FL//2wmUspO8IFgV6dtxQ/PeEMMA3KgqlbbC1j+Qa3bb\nbP6MvPJwNQzcmRk13NfIRmPVNnGuV/u3gm3c\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIFCzCCAvOgAwIBAgIQf/AFoHxM3tEArZ1mpRB7mDANBgkqhkiG9w0BAQsFADBH\nMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM\nQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMjMxMjEzMDkwMDAwWhcNMjkwMjIw\nMTQwMDAwWjA7MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVR29vZ2xlIFRydXN0IFNl\ncnZpY2VzMQwwCgYDVQQDEwNXUjIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\nAoIBAQCp/5x/RR5wqFOfytnlDd5GV1d9vI+aWqxG8YSau5HbyfsvAfuSCQAWXqAc\n+MGr+XgvSszYhaLYWTwO0xj7sfUkDSbutltkdnwUxy96zqhMt/TZCPzfhyM1IKji\naeKMTj+xWfpgoh6zySBTGYLKNlNtYE3pAJH8do1cCA8Kwtzxc2vFE24KT3rC8gIc\nLrRjg9ox9i11MLL7q8Ju26nADrn5Z9TDJVd06wW06Y613ijNzHoU5HEDy01hLmFX\nxRmpC5iEGuh5KdmyjS//V2pm4M6rlagplmNwEmceOuHbsCFx13ye/aoXbv4r+zgX\nFNFmp6+atXDMyGOBOozAKql2N87jAgMBAAGjgf4wgfswDgYDVR0PAQH/BAQDAgGG\nMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjASBgNVHRMBAf8ECDAGAQH/\nAgEAMB0GA1UdDgQWBBTeGx7teRXUPjckwyG77DQ5bUKyMDAfBgNVHSMEGDAWgBTk\nrysmcRorSCeFL1JmLO/wiRNxPjA0BggrBgEFBQcBAQQoMCYwJAYIKwYBBQUHMAKG\nGGh0dHA6Ly9pLnBraS5nb29nL3IxLmNydDArBgNVHR8EJDAiMCCgHqAchhpodHRw\nOi8vYy5wa2kuZ29vZy9yL3IxLmNybDATBgNVHSAEDDAKMAgGBmeBDAECATANBgkq\nhkiG9w0BAQsFAAOCAgEARXWL5R87RBOWGqtY8TXJbz3S0DNKhjO6V1FP7sQ02hYS\nTL8Tnw3UVOlIecAwPJQl8hr0ujKUtjNyC4XuCRElNJThb0Lbgpt7fyqaqf9/qdLe\nSiDLs/sDA7j4BwXaWZIvGEaYzq9yviQmsR4ATb0IrZNBRAq7x9UBhb+TV+PfdBJT\nDhEl05vc3ssnbrPCuTNiOcLgNeFbpwkuGcuRKnZc8d/KI4RApW//mkHgte8y0YWu\nryUJ8GLFbsLIbjL9uNrizkqRSvOFVU6xddZIMy9vhNkSXJ/UcZhjJY1pXAprffJB\nvei7j+Qi151lRehMCofa6WBmiA4fx+FOVsV2/7R6V2nyAiIJJkEd2nSi5SnzxJrl\nXdaqev3htytmOPvoKWa676ATL/hzfvDaQBEcXd2Ppvy+275W+DKcH0FBbX62xevG\niza3F4ydzxl6NJ8hk8R+dDXSqv1MbRT1ybB5W0k8878XSOjvmiYTDIfyc9acxVJr\nY/cykHipa+te1pOhv7wYPYtZ9orGBV5SGOJm4NrB3K1aJar0RfzxC3ikr7Dyc6Qw\nqDTBU39CluVIQeuQRgwG3MuSxl7zRERDRilGoKb8uY45JzmxWuKxrfwT/478JuHU\n/oTxUFqOl2stKnn7QGTq8z29W+GgBLCXSBxC9epaHM0myFH/FJlniXJfHeytWt0=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIEQzCCAyugAwIBAgIQGQfdneEgJaAS5/l+nAZY+DANBgkqhkiG9w0BAQsFADA7\nMQswCQYDVQQGEwJVUzEeMBwGA1UEChMVR29vZ2xlIFRydXN0IFNlcnZpY2VzMQww\nCgYDVQQDEwNXUjIwHhcNMjYwODEwMDg0MTUzWhcNMjYxMTAyMDg0MTUyWjAhMR8w\nHQYDVQQDExZzdG9yYWdlLmdvb2dsZWFwaXMuY29tMFkwEwYHKoZIzj0CAQYIKoZI\nzj0DAQcDQgAEohX5NfJRU4+A+C6O1ksDImmIe+PcNivHyqtdVCD/UvU5u8ndl61X\nCxMyVemxrupCyH6wifSqzGPG/MxWhgQgG6OCAiYwggIiMA4GA1UdDwEB/wQEAwIH\ngDATBgNVHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMB0GA1UdDgQWBBRZ\nXvjV9dK9ep8vJZxQnenMYpCDYDAfBgNVHSMEGDAWgBTeGx7teRXUPjckwyG77DQ5\nbUKyMDA1BggrBgEFBQcBAQQpMCcwJQYIKwYBBQUHMAKGGWh0dHA6Ly9pLnBraS5n\nb29nL3dyMi5jcnQwIQYDVR0RBBowGIIWc3RvcmFnZS5nb29nbGVhcGlzLmNvbTAT\nBgNVHSAEDDAKMAgGBmeBDAECATA2BgNVHR8ELzAtMCugKaAnhiVodHRwOi8vYy5w\na2kuZ29vZy93cjIvb0JGWVlhaHpnVkkuY3JsMIIBBAYKKwYBBAHWeQIEAgSB9QSB\n8gDwAHYA1219ENGn9XfCx+lf1wC/+YLJM1pl4dCzAXMXwMjFaXcAAAGf6wzTigAA\nBAMARzBFAiEAjXzJizB9bFnFM8/t3vBK2wPLwpmV/VgNGLrXSgycIwoCIDetAaQz\nGmzBBw3SljID3mT5lRFS04SxKnN6YSLNZyseAHYAwjF+V0UZo0XufzjespBB68fC\nIVoiv3/Vta12mtkOUs0AAAGf6wzTogAABAMARzBFAiEArtiafIWpqvJS7EwGTHG6\n8wFqFznVwYsZk+qHPzvzZoICICwpQ72ncFRpBVS5QxGIh30/yphyw66irZVb2dUs\nvnlcMA0GCSqGSIb3DQEBCwUAA4IBAQB4fAF0QFDJkIHdFHcEbVXB8/NeJnxvFcs5\nb5N4pahcFTiGDVuVVf9jYkml0KMXE+MnwpGxgT5jZzIKa60JxSu5Jv7kWdhT5nL7\nd76D7cjQYFw5FwLe77qCE/FVAxxgCsKsGlJLPvYPA8oFDOKm6BuCYcnInj5SLsme\nSz1WS2HztEGAHBBbu1dOGppNtCRvmCWoN8MpP/2He+Cl714YNgIV8W4e3W1Qc4dv\ncmzH4tMBLylWk+1+sksbRUTMOeRSf4nJmPa1jtuZLxKixM+X4EY1oVxzcCPp5Kbe\n9KuuMgubY9uC1DivKlIJBFxLE4AMkLQEtGRePG+RTpcAjIl/slHM\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-08-10T08:41:54+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "storage.googleapis.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::apple.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `apple.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw\nCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu\nZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe\nFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw\nEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x\nIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF\nK4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG\nfp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO\nZ9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd\nBgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx\nAK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/\noAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8\nsycX\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIIDsjCCAzigAwIBAgIQDKuq0c7E6XzCZliB0CE49zAKBggqhkjOPQQDAzBhMQsw\nCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu\nZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe\nFw0yMDA0MjkxMjM0NTJaFw0zMDA0MTAyMzU5NTlaMFExCzAJBgNVBAYTAlVTMRMw\nEQYDVQQKEwpBcHBsZSBJbmMuMS0wKwYDVQQDEyRBcHBsZSBQdWJsaWMgRVYgU2Vy\ndmVyIEVDQyBDQSAxIC0gRzEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQp+OFa\nuYdEBJj/FpCG+eDhQmVfhv0DGPzGz40TW8BeWxipYTOa4FLieAYoU+3t2tg9FZKt\nA4BDTO43YprLZm6zo4IB4DCCAdwwHQYDVR0OBBYEFOCFSH0TptMQGZ9cy2t4JJL4\nrhuuMB8GA1UdIwQYMBaAFLPbSKT5ocXYrjZBzBFjaWIpvEvGMA4GA1UdDwEB/wQE\nAwIBhjAdBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwEgYDVR0TAQH/BAgw\nBgEB/wIBADA0BggrBgEFBQcBAQQoMCYwJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3Nw\nLmRpZ2ljZXJ0LmNvbTBCBgNVHR8EOzA5MDegNaAzhjFodHRwOi8vY3JsMy5kaWdp\nY2VydC5jb20vRGlnaUNlcnRHbG9iYWxSb290RzMuY3JsMIHcBgNVHSAEgdQwgdEw\ngcUGCWCGSAGG/WwCATCBtzAoBggrBgEFBQcCARYcaHR0cHM6Ly93d3cuZGlnaWNl\ncnQuY29tL0NQUzCBigYIKwYBBQUHAgIwfgx8QW55IHVzZSBvZiB0aGlzIENlcnRp\nZmljYXRlIGNvbnN0aXR1dGVzIGFjY2VwdGFuY2Ugb2YgdGhlIFJlbHlpbmcgUGFy\ndHkgQWdyZWVtZW50IGxvY2F0ZWQgYXQgaHR0cHM6Ly93d3cuZGlnaWNlcnQuY29t\nL3JwYS11YTAHBgVngQwBATAKBggqhkjOPQQDAwNoADBlAjEAyHLAT/4iBuxi4/NH\nhZde4PZO8CnG2/A3oGO0Nsjpoe2SV94Hr+JpYHrBzT8hyeKSAjBnRXyRac9sM8KN\nFdg3+7LWIiW9sUjtJC6kGmRyGm6vV4oAhEDd9jdk4q+7b5zlid4=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIFwTCCBWegAwIBAgIQVJ0RG7gkqlrPMawBmF2UhDAKBggqhkjOPQQDAjBRMQsw\nCQYDVQQGEwJVUzETMBEGA1UEChMKQXBwbGUgSW5jLjEtMCsGA1UEAxMkQXBwbGUg\nUHVibGljIEVWIFNlcnZlciBFQ0MgQ0EgMSAtIEcxMB4XDTI2MDgxMzE2MjAwMVoX\nDTI2MTEwNTIwNTUxM1owgcMxHTAbBgNVBA8MFFByaXZhdGUgT3JnYW5pemF0aW9u\nMRMwEQYLKwYBBAGCNzwCAQMTAlVTMRswGQYLKwYBBAGCNzwCAQIMCkNhbGlmb3Ju\naWExETAPBgNVBAUTCEMwODA2NTkyMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2Fs\naWZvcm5pYTESMBAGA1UEBwwJQ3VwZXJ0aW5vMRMwEQYDVQQKDApBcHBsZSBJbmMu\nMRIwEAYDVQQDDAlhcHBsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATt\np3z7XbXLnDV6se8R4I3ljNQoP+EOwqLlvR+H76bkrcRLkg/RNY37z8aLwknnNhuZ\n/dTyJIgRb2PdP0ib91clo4IDrDCCA6gwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAW\ngBTghUh9E6bTEBmfXMtreCSS+K4brjB6BggrBgEFBQcBAQRuMGwwMgYIKwYBBQUH\nMAKGJmh0dHA6Ly9jZXJ0cy5hcHBsZS5jb20vYXBldnNlY2MxZzEuZGVyMDYGCCsG\nAQUFBzABhipodHRwOi8vb2NzcC5hcHBsZS5jb20vb2NzcDAzLWFwZXZzZWNjMWcx\nMDEwFAYDVR0RBA0wC4IJYXBwbGUuY29tMGAGA1UdIARZMFcwSAYFZ4EMAQEwPzA9\nBggrBgEFBQcCARYxaHR0cHM6Ly93d3cuYXBwbGUuY29tL2NlcnRpZmljYXRlYXV0\naG9yaXR5L3B1YmxpYzALBglghkgBhv1sAgEwEwYDVR0lBAwwCgYIKwYBBQUHAwEw\nNQYDVR0fBC4wLDAqoCigJoYkaHR0cDovL2NybC5hcHBsZS5jb20vYXBldnNlY2Mx\nZzEuY3JsMB0GA1UdDgQWBBRb9CgKiaX0Cf264US5z7MuZ6h3STAOBgNVHQ8BAf8E\nBAMCB4AwDwYJKoZIhvdjZAZWBAIFADCCAfUGCisGAQQB1nkCBAIEggHlBIIB4QHf\nAHYAlE5Dh/rswe+B8xkkJqgYZQHH0184AgE/cmd9VTcuGdgAAAGf+/WQvgAABAMA\nRzBFAiEAwdy7GCBEHWIm0+0JU+Ns0Jc8WFSkozEa9RGMH1ej4gQCIDoWHh/QDAGU\nSWsOVkVCDTzTKC7ldiX2gnE0fIe8GBEsAHUA1219ENGn9XfCx+lf1wC/+YLJM1pl\n4dCzAXMXwMjFaXcAAAGf+/WQsQAABAMARjBEAiAjt5CLvS1WIETEBmadMLEePPX+\nPZnMGsiDjj0NedsHfwIgFW3ZUnzToqhcGN1C4E0cWjwb8AuYGLwGNe5eNJtQCB8A\ndwDLOPcViXyEoURfW8Hd+8lu8ppZzUcKaQWFsMsUwxRY5wAAAZ/79ZC2AAAEAwBI\nMEYCIQDtVCou0Lfyrrx9gW1YbXmviTDAfwiFg2ZwBWw6TCsaZgIhAPj1/noXJ08A\nn+iuZ5lYKsd0jCjbPSHge+2hYY7lrRTBAHUAwjF+V0UZo0XufzjespBB68fCIVoi\nv3/Vta12mtkOUs0AAAGf+/WQrQAABAMARjBEAiACelNUUEpMQP+U/KiqblTSmpaJ\nbwfBNY7LF0KyOdbDPQIgcDwY8tbomd9y3i9ySw6G8F2W8j3xbvt8edz6LJE9zMgw\nCgYIKoZIzj0EAwIDSAAwRQIgWv+bASy+Tr8EsUhafqrVPv94UtDMJqDnOOCV31uM\nmtUCIQCrnFCbMrAkxc99ViFUSwIo/+adOS4yOAZzmR40T0LeEQ==\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-08-13T16:20:02+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "apple.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::cloudflare.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `cloudflare.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICCTCCAY6gAwIBAgINAgPlwGjvYxqccpBQUjAKBggqhkjOPQQDAzBHMQswCQYD\nVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEUMBIG\nA1UEAxMLR1RTIFJvb3QgUjQwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAwMDAw\nWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2Vz\nIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjQwdjAQBgcqhkjOPQIBBgUrgQQAIgNi\nAATzdHOnaItgrkO4NcWBMHtLSZ37wWHO5t5GvWvVYRg1rkDdc/eJkTBa6zzuhXyi\nQHY7qca4R9gq55KRanPpsXI5nymfopjTX15YhmUPoYRlBtHci8nHc8iMai/lxKvR\nHYqjQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW\nBBSATNbrdP9JNqPV2Py1PsVq8JQdjDAKBggqhkjOPQQDAwNpADBmAjEA6ED/g94D\n9J+uHXqnLrmvT/aDHQ4thQEd0dlq7A/Cr8deVl5c1RxYIigL9zC2L7F8AjEA8GE8\np/SgguMh1YQdc4acLa/KNJvxn7kjNuK8YAOdgLOaVsjh4rsUecrNIdSUtUlD\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICnzCCAiWgAwIBAgIQf/MZd5csIkp2FV0TttaF4zAKBggqhkjOPQQDAzBHMQsw\nCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU\nMBIGA1UEAxMLR1RTIFJvb3QgUjQwHhcNMjMxMjEzMDkwMDAwWhcNMjkwMjIwMTQw\nMDAwWjA7MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVR29vZ2xlIFRydXN0IFNlcnZp\nY2VzMQwwCgYDVQQDEwNXRTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARvzTr+\nZ1dHTCEDhUDCR127WEcPQMFcF4XGGTfn1XzthkubgdnXGhOlCgP4mMTG6J7/EFmP\nLCaY9eYmJbsPAvpWo4H+MIH7MA4GA1UdDwEB/wQEAwIBhjAdBgNVHSUEFjAUBggr\nBgEFBQcDAQYIKwYBBQUHAwIwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQU\nkHeSNWfE/6jMqeZ72YB5e8yT+TgwHwYDVR0jBBgwFoAUgEzW63T/STaj1dj8tT7F\navCUHYwwNAYIKwYBBQUHAQEEKDAmMCQGCCsGAQUFBzAChhhodHRwOi8vaS5wa2ku\nZ29vZy9yNC5jcnQwKwYDVR0fBCQwIjAgoB6gHIYaaHR0cDovL2MucGtpLmdvb2cv\nci9yNC5jcmwwEwYDVR0gBAwwCjAIBgZngQwBAgEwCgYIKoZIzj0EAwMDaAAwZQIx\nAOcCq1HW90OVznX+0RGU1cxAQXomvtgM8zItPZCuFQ8jSBJSjz5keROv9aYsAm5V\nsQIwJonMaAFi54mrfhfoFNZEfuNMSQ6/bIBiNLiyoX46FohQvKeIoJ99cx7sUkFN\n7uJW\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIID0zCCA3igAwIBAgIRANUJklyNsQ4ZE6Ohyxx7BaswCgYIKoZIzj0EAwIwOzEL\nMAkGA1UEBhMCVVMxHjAcBgNVBAoTFUdvb2dsZSBUcnVzdCBTZXJ2aWNlczEMMAoG\nA1UEAxMDV0UxMB4XDTI2MDkwNTIyMjkzOVoXDTI2MTIwNDIzMjkzM1owGTEXMBUG\nA1UEAxMOY2xvdWRmbGFyZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAR+\nzmFk2tUQkjjV68FkY5y3/ekkm/cMcgjpYsUGjYRvzpWC1YBNhkge5+86iffd6F2G\nHBciNS4t1CGn20FoEucOo4ICfTCCAnkwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQM\nMAoGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHQYDVR0OBBYEFNNSG3S1RQpCoCtj\nbB6fFUGKIvmHMB8GA1UdIwQYMBaAFJB3kjVnxP+ozKnme9mAeXvMk/k4MDUGCCsG\nAQUFBwEBBCkwJzAlBggrBgEFBQcwAoYZaHR0cDovL2kucGtpLmdvb2cvd2UxLmNy\ndDB3BgNVHREEcDBugg5jbG91ZGZsYXJlLmNvbYIRbnMuY2xvdWRmbGFyZS5jb22C\nEyoubnMuY2xvdWRmbGFyZS5jb22CGiouc2Vjb25kYXJ5LmNsb3VkZmxhcmUuY29t\nghhzZWNvbmRhcnkuY2xvdWRmbGFyZS5jb20wEwYDVR0gBAwwCjAIBgZngQwBAgEw\nNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2MucGtpLmdvb2cvd2UxL2dBb29BZnp4\nOXV3LmNybDCCAQUGCisGAQQB1nkCBAIEgfYEgfMA8QB2AMIxfldFGaNF7n843rKQ\nQevHwiFaIr9/1bWtdprZDlLNAAABoHPoBMoAAAQDAEcwRQIgTY2icRQ9zdZ1IDYM\nC16AcunlNQO08Ne3KvUJzQPo2pcCIQDpsVu06QMCPVGvMqbsyuErSWGfUSNV4NZN\n5MA6VT1hgAB3ANdtfRDRp/V3wsfpX9cAv/mCyTNaZeHQswFzF8DIxWl3AAABoHPo\nBLcAAAQDAEgwRgIhAJ9FxiJ8f+NHMEPwlAhntMe5kFwQaFQiP4oeGozz5ePcAiEA\n+lvQPBAjQDswZHOWmzHIZkrY6hy3N0eH056gdgAdO7kwCgYIKoZIzj0EAwIDSQAw\nRgIhAJwzW+J0yoGca/N+Dy3kekDofJHSzhdub2w/j2YqchfeAiEAku056/zi664u\nr1tIjbzAooVw0aBhBKgnT1AiT+lZaWI=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-09-05T22:29:40+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "cloudflare.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::microsoft.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `microsoft.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\nd3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH\nMjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT\nMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j\nb20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG\n9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI\n2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx\n1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ\nq2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz\ntCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ\nvIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP\nBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV\n5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY\n1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4\nNeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG\nFdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91\n8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe\npLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl\nMrY=\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----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\nNJ7DzNfImza7xSXi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIFiTCCBHGgAwIBAgIQCwxrLEZpF7BHc8ZH1K/AyDANBgkqhkiG9w0BAQwFADBh\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\nd3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH\nMjAeFw0yNTA1MjEwMDAwMDBaFw0yOTA2MTkyMzU5NTlaMFExCzAJBgNVBAYTAlVT\nMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xIjAgBgNVBAMTGU1pY3Jv\nc29mdCBUTFMgUlNBIFJvb3QgRzIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK\nAoICAQDf6oufR+EoEHGvQdYZ25JX3mur5i7erTpgg7cTmKxbuTILe+ufcidrXUCr\nvhgGk7IN0hLtuHT1fy/qqBeU9jMWV4reIHwh3bfarN5OZLBazUt18+8CZE3tUtqj\njwTokfjX+z8Z/U5FOV7oKcPW8mevswCUwY3h8EoYmDn6wAmEM0EFAwWr9HXhU6Uh\nklxETOZgV6SQApfH1diTBDJK7YVR7dbFuqA/Noovb0w5qARpIoQ7dRT32T60qdAH\nQTiBfkZIHegZ5nC4oKoY3XK/fn21bE4ZcBGEBBOB1GL9nGvxHN3/7Kfg5seNMUu/\n8mszzNGMtv6xG6NKqF8OfzF2OD8HR2wBqKylFNqCsF8fbLyJGsASKst7lx8oLjEW\nilNMdWb5fQHWwmCqZY8xnnLLzJst5UQZk1erbo7C2S5lsHIt56HDoX5JHVln1gnU\nGBJtwJVFeMnxYGrk9u4GJDtzSloRwj6XYcB47u8TpzDiSjgt7lgXEyC3NirfCzK0\nwjixkd0SsEW2fMCxHWKhnd1xEhWWAZ0KCfWx3bPZ4DhCNPZptsOvFnP+1EP4Q+RY\n+U+z8+zWPZQ6QDgVqwyG0GTOGmPohJRVCVq2BLbRPpoVx2QRgNAbgg5N/0WesmUH\nJR/bmsjG7NZbhVAEnxzLXSCCZ5554t/o8uhvxCByMIblnXUnNQIDAQABo4IBSzCC\nAUcwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU3pGGSLehMVkx8UtfB6nciHna\nqHYwHwYDVR0jBBgwFoAUTiJUIBiV5uNu5g/6+rkS7QYXjzkwDgYDVR0PAQH/BAQD\nAgGGMBMGA1UdJQQMMAoGCCsGAQUFBwMBMHYGCCsGAQUFBwEBBGowaDAkBggrBgEF\nBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEAGCCsGAQUFBzAChjRodHRw\nOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRHbG9iYWxSb290RzIuY3J0\nMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdp\nQ2VydEdsb2JhbFJvb3RHMi5jcmwwEwYDVR0gBAwwCjAIBgZngQwBAgIwDQYJKoZI\nhvcNAQEMBQADggEBAAu8tCs3dMVLpzYCNsav4RPMipqXG/zjRIzuVADl5EEaRvAL\ndjT/mVViNaqtipwMWmLMQ8DL6kodvWsdr7EZJWac93luWyWAJIGFx3ktNV9CCXjt\nn+Jl1cQgUIIQj2o67RiOSImrpgn44YD8BnUWJyVaj7g6cGwYR/Bj9FMO2RU1IPOR\nPRMBoOL6JAhFVnfRZ6kxQtBX/xomvsVD2FepY/+v8zrY9ntLEKKXoc9mvmdnCfm1\nTOerGSu/Ij193sb372M4LN1WxPkJUtrf44hv1W1r9whBL44+hjGf8XxK9dZhpEZG\nKO9XurBvktjSdyXte6YpzjtyeRHU4KdUbTUrpHo=\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----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\nKP7WFm/mz8wjVIlEJZr1STNy8WU=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-06-23T09:04:18+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "microsoft.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + }, + { + "id": "online::stackoverflow.com", + "conflicts_with": [], + "features": [], + "importance": "undetermined", + "description": "A valid chain for `stackoverflow.com`.", + "validation_kind": "SERVER", + "trusted_certs": [ + "-----BEGIN CERTIFICATE-----\nMIICGzCCAaGgAwIBAgIQQdKd0XLq7qeAwSxs6S+HUjAKBggqhkjOPQQDAzBPMQsw\nCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFyY2gg\nR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBYMjAeFw0yMDA5MDQwMDAwMDBaFw00\nMDA5MTcxNjAwMDBaME8xCzAJBgNVBAYTAlVTMSkwJwYDVQQKEyBJbnRlcm5ldCBT\nZWN1cml0eSBSZXNlYXJjaCBHcm91cDEVMBMGA1UEAxMMSVNSRyBSb290IFgyMHYw\nEAYHKoZIzj0CAQYFK4EEACIDYgAEzZvVn4CDCuwJSvMWSj5cz3es3mcFDR0HttwW\n+1qLFNvicWDEukWVEYmO6gbf9yoWHKS5xcUy4APgHoIYOIvXRdgKam7mAHf7AlF9\nItgKbppbd9/w+kHsOdx1ymgHDB/qo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEKWrt5LSDv6kviejM9ti6lyN5UwCgYIKoZI\nzj0EAwMDaAAwZQIwe3lORlCEwkSHRhtFcP9Ymd70/aTSVaYgLXTWNLxBo1BfASdW\ntL4ndQavEi51mI38AjEAi/V3bNTIZargCyzuFJ0nN6T5U6VR5CmD1/iQMVtCnwr1\n/q4AaOeMSQ+2b1tbFfLn\n-----END CERTIFICATE-----\n" + ], + "untrusted_intermediates": [ + "-----BEGIN CERTIFICATE-----\nMIICizCCAhGgAwIBAgIQXd1w3TH4AchcGGp6BLgK/jAKBggqhkjOPQQDAzAuMQsw\nCQYDVQQGEwJVUzENMAsGA1UEChMESVNSRzEQMA4GA1UEAxMHUm9vdCBZRTAeFw0y\nNTA5MDMwMDAwMDBaFw0yODA5MDIyMzU5NTlaMDMxCzAJBgNVBAYTAlVTMRYwFAYD\nVQQKEw1MZXQncyBFbmNyeXB0MQwwCgYDVQQDEwNZRTEwdjAQBgcqhkjOPQIBBgUr\ngQQAIgNiAAQHZVB1/mimla2hfSurylScjPMZaOJXLz/NnAc2sylm8WDyhU9Ccp+z\nASQi5vSwGGJjSGklkD9fdPR8GpyDIOIjCEfrnbt/v+ZSEPLLEGbaM6EccDbN7p9x\nteIm2Avf+ryjge4wgeswDgYDVR0PAQH/BAQDAgGGMBMGA1UdJQQMMAoGCCsGAQUF\nBwMBMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFLsgykcL/tflnPmPCSqj\njDdFsbzYMB8GA1UdIwQYMBaAFKPIJlqOoUzQNWP8myPIOq5W809WMDIGCCsGAQUF\nBwEBBCYwJDAiBggrBgEFBQcwAoYWaHR0cDovL3llLmkubGVuY3Iub3JnLzATBgNV\nHSAEDDAKMAgGBmeBDAECATAnBgNVHR8EIDAeMBygGqAYhhZodHRwOi8veWUuYy5s\nZW5jci5vcmcvMAoGCCqGSM49BAMDA2gAMGUCMQDgjUEahFT/h3DRakqiPZpLvPgf\nZwkt6K2EOMmh1nvEzl83eMLYcod4GCl3b0J1Nn0CMBNYmEQJb4CEG5WoOe7aRn/L\nVKu6saHmHEynI7ysIPd8zQsK1HdmhlHKlw9Z5GpGvA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICpjCCAiugAwIBAgIRAIchZfw0tuX7qK3Vs3BftTowCgYIKoZIzj0EAwMwTzEL\nMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2VhcmNo\nIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDIwHhcNMjYwNTEzMDAwMDAwWhcN\nMzIwOTAyMjM1OTU5WjAuMQswCQYDVQQGEwJVUzENMAsGA1UEChMESVNSRzEQMA4G\nA1UEAxMHUm9vdCBZRTB2MBAGByqGSM49AgEGBSuBBAAiA2IABDwS/6vhrcVqcbBo\n+wgdI3fwn9x7DNJJOY/lTOti0vkwuRN87RhEhTH17E7XyFjWsPYhIPt/wzOqxTd2\nb+4ZJNy9ID04YywF9U5zasDVyGSNErVNtz8uSGh5izW87j77GaOB6zCB6DAOBgNV\nHQ8BAf8EBAMCAQYwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDwYDVR0TAQH/BAUwAwEB\n/zAdBgNVHQ4EFgQUo8gmWo6hTNA1Y/ybI8g6rlbzT1YwHwYDVR0jBBgwFoAUfEKW\nrt5LSDv6kviejM9ti6lyN5UwMgYIKwYBBQUHAQEEJjAkMCIGCCsGAQUFBzAChhZo\ndHRwOi8veDIuaS5sZW5jci5vcmcvMBMGA1UdIAQMMAowCAYGZ4EMAQIBMCcGA1Ud\nHwQgMB4wHKAaoBiGFmh0dHA6Ly94Mi5jLmxlbmNyLm9yZy8wCgYIKoZIzj0EAwMD\naQAwZgIxAMU19WCtmxVND8UHBZRoma49Z7jPs64Dma0eTu1OChVbB/2J7GV3nvYK\nAx54uk1G9QIxAO0miLVJu8PLNiXXXkiE/gsK3CTRTF/aeo4bMX42Zw40csRU6AC2\n6hSW1/IWaas6dg==\n-----END CERTIFICATE-----\n" + ], + "peer_certificate": "-----BEGIN CERTIFICATE-----\nMIIDpjCCAyygAwIBAgISBmByEe6tiXQrWiIs97c0nYIdMAoGCCqGSM49BAMDMDMx\nCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQwwCgYDVQQDEwNZ\nRTEwHhcNMjYwODE1MTIzOTA2WhcNMjYxMTEzMTIzOTA1WjAcMRowGAYDVQQDExFz\ndGFja292ZXJmbG93LmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABP5ZP5Vu\n7MJhztzvHduwjgx+U5gpYcTWTpg0cry/ehfh8sOjK459EWAXBs3egH8L8DFGqKnc\nlmF2sOqOwFjCKq2jggI1MIICMTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYI\nKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUYpHXLcynIUCmUXOlw8of\nooMjcowwHwYDVR0jBBgwFoAUuyDKRwv+1+Wc+Y8JKqOMN0WxvNgwMwYIKwYBBQUH\nAQEEJzAlMCMGCCsGAQUFBzAChhdodHRwOi8veWUxLmkubGVuY3Iub3JnLzAxBgNV\nHREEKjAoghMqLnN0YWNrb3ZlcmZsb3cuY29tghFzdGFja292ZXJmbG93LmNvbTAT\nBgNVHSAEDDAKMAgGBmeBDAECATAuBgNVHR8EJzAlMCOgIaAfhh1odHRwOi8veWUx\nLmMubGVuY3Iub3JnLzMwLmNybDCCAQ0GCisGAQQB1nkCBAIEgf4EgfsA+QB2AMs4\n9xWJfIShRF9bwd37yW7ymlnNRwppBYWwyxTDFFjnAAABoAWkbPsAAAQDAEcwRQIh\nAMx+PqXUI8FqEYaUJMJIYzb179sxxbwmcHQ4b+fOhBFwAiB7eNG7me0nvBflJkcO\nXs3b0M6Kf7qWDiWBUhoFfzpp8AB/AEavhj07PuWfpXfeqCRdNrDZ7SKiI/Rhd0Ei\nlFLulVBfAAABoAWkbYEACAAABQAT+yKjBAMASDBGAiEAgRSUr+OH1O1d+TEkxntX\ndxIg6EadIjhRc0mkvM2fXqsCIQC4X4kznvMZa4Qkz3TmI3lnVtBYo5nAnY5hlXze\nV3i7zDAKBggqhkjOPQQDAwNoADBlAjEA1liKDqsZgpDskZxKgeaWZYL5zpYThSor\nzwVFpdi4WEeFxLhRp2E/H8pGWV6JhLw/AjBVpW1jMJk5UNr94owy4m/gfTP45Iqt\neKfWBwUMpDQdbSatfrWK8/GNYgXjAmRhd2A=\n-----END CERTIFICATE-----\n", + "peer_certificate_key": null, + "validation_time": "2026-08-15T12:39:07+00:00", + "signature_algorithms": [], + "key_usage": [], + "extended_key_usage": [], + "expected_result": "SUCCESS", + "expected_peer_name": { + "kind": "DNS", + "value": "stackoverflow.com" + }, + "expected_peer_names": [], + "max_chain_depth": null, + "crls": [] + } + ] +} diff --git a/crates/clazel-x509/tests/generated/x509_limbo.rs b/crates/clazel-x509/tests/generated/x509_limbo.rs new file mode 100644 index 0000000..af601a1 --- /dev/null +++ b/crates/clazel-x509/tests/generated/x509_limbo.rs @@ -0,0 +1,40193 @@ +// @generated by `cargo xtask testdata` from tests/data/x509-limbo/. +// Do not edit: `cargo xtask verify` fails if this differs from what the +// converter (xtask/src/testdata/x509_limbo.rs) produces. +// Source, commit and license: tests/data/x509-limbo/SOURCE.md. +// Certificates are in tests/generated/x509_limbo_certs.bin. +/// Number of testcases in `limbo.json`. +const TESTCASE_COUNT: usize = 9802; +/// (offset, length) of each distinct certificate in the binary file. +const CERT_SPANS: &[(u32, u32)] = &[ + (0, 436), + (436, 403), + (839, 430), + (1269, 391), + (1660, 390), + (2050, 436), + (2486, 403), + (2889, 436), + (3325, 404), + (3729, 436), + (4165, 403), + (4568, 435), + (5003, 404), + (5407, 436), + (5843, 403), + (6246, 437), + (6683, 403), + (7086, 436), + (7522, 403), + (7925, 453), + (8378, 403), + (8781, 473), + (9254, 402), + (9656, 436), + (10092, 403), + (10495, 430), + (10925, 390), + (11315, 391), + (11706, 475), + (12181, 402), + (12583, 483), + (13066, 404), + (13470, 476), + (13946, 390), + (14336, 479), + (14815, 404), + (15219, 432), + (15651, 394), + (16045, 404), + (16449, 394), + (16843, 394), + (17237, 403), + (17640, 395), + (18035, 393), + (18428, 403), + (18831, 395), + (19226, 395), + (19621, 517), + (20138, 402), + (20540, 546), + (21086, 518), + (21604, 404), + (22008, 530), + (22538, 451), + (22989, 403), + (23392, 443), + (23835, 513), + (24348, 403), + (24751, 516), + (25267, 514), + (25781, 402), + (26183, 517), + (26700, 513), + (27213, 402), + (27615, 516), + (28131, 594), + (28725, 402), + (29127, 517), + (29644, 512), + (30156, 402), + (30558, 517), + (31075, 594), + (31669, 512), + (32181, 402), + (32583, 516), + (33099, 592), + (33691, 514), + (34205, 402), + (34607, 515), + (35122, 592), + (35714, 591), + (36305, 513), + (36818, 403), + (37221, 515), + (37736, 591), + (38327, 592), + (38919, 436), + (39355, 404), + (39759, 516), + (40275, 403), + (40678, 516), + (41194, 515), + (41709, 403), + (42112, 516), + (42628, 516), + (43144, 403), + (43547, 517), + (44064, 595), + (44659, 517), + (45176, 403), + (45579, 517), + (46096, 596), + (46692, 437), + (47129, 402), + (47531, 407), + (47938, 439), + (48377, 451), + (48828, 404), + (49232, 444), + (49676, 444), + (50120, 451), + (50571, 404), + (50975, 445), + (51420, 444), + (51864, 455), + (52319, 403), + (52722, 438), + (53160, 438), + (53598, 78085), + (131683, 55568), + (187251, 23881), + (211132, 55566), + (266698, 54596), + (321294, 55567), + (376861, 441), + (377302, 403), + (377705, 354), + (378059, 355), + (378414, 354), + (378768, 354), + (379122, 354), + (379476, 354), + (379830, 354), + (380184, 355), + (380539, 353), + (380892, 354), + (381246, 355), + (381601, 356), + (381957, 355), + (382312, 357), + (382669, 356), + (383025, 356), + (383381, 357), + (383738, 357), + (384095, 355), + (384450, 357), + (384807, 357), + (385164, 357), + (385521, 357), + (385878, 357), + (386235, 356), + (386591, 356), + (386947, 357), + (387304, 356), + (387660, 356), + (388016, 356), + (388372, 356), + (388728, 357), + (389085, 357), + (389442, 355), + (389797, 356), + (390153, 356), + (390509, 356), + (390865, 356), + (391221, 356), + (391577, 355), + (391932, 357), + (392289, 356), + (392645, 357), + (393002, 357), + (393359, 356), + (393715, 356), + (394071, 356), + (394427, 355), + (394782, 357), + (395139, 356), + (395495, 355), + (395850, 356), + (396206, 356), + (396562, 356), + (396918, 355), + (397273, 355), + (397628, 357), + (397985, 356), + (398341, 355), + (398696, 357), + (399053, 355), + (399408, 357), + (399765, 356), + (400121, 357), + (400478, 355), + (400833, 356), + (401189, 357), + (401546, 356), + (401902, 356), + (402258, 357), + (402615, 356), + (402971, 357), + (403328, 357), + (403685, 356), + (404041, 356), + (404397, 357), + (404754, 357), + (405111, 356), + (405467, 357), + (405824, 355), + (406179, 355), + (406534, 357), + (406891, 356), + (407247, 356), + (407603, 357), + (407960, 356), + (408316, 357), + (408673, 356), + (409029, 356), + (409385, 356), + (409741, 357), + (410098, 357), + (410455, 357), + (410812, 356), + (411168, 356), + (411524, 357), + (411881, 356), + (412237, 355), + (412592, 357), + (412949, 356), + (413305, 435), + (413740, 403), + (414143, 346), + (414489, 347), + (414836, 348), + (415184, 348), + (415532, 347), + (415879, 347), + (416226, 348), + (416574, 347), + (416921, 347), + (417268, 347), + (417615, 347), + (417962, 348), + (418310, 346), + (418656, 347), + (419003, 347), + (419350, 347), + (419697, 346), + (420043, 346), + (420389, 348), + (420737, 347), + (421084, 348), + (421432, 348), + (421780, 347), + (422127, 347), + (422474, 347), + (422821, 347), + (423168, 348), + (423516, 346), + (423862, 347), + (424209, 348), + (424557, 347), + (424904, 346), + (425250, 347), + (425597, 347), + (425944, 348), + (426292, 348), + (426640, 347), + (426987, 347), + (427334, 347), + (427681, 347), + (428028, 346), + (428374, 347), + (428721, 348), + (429069, 347), + (429416, 347), + (429763, 348), + (430111, 346), + (430457, 347), + (430804, 348), + (431152, 347), + (431499, 346), + (431845, 347), + (432192, 346), + (432538, 347), + (432885, 346), + (433231, 348), + (433579, 346), + (433925, 346), + (434271, 347), + (434618, 347), + (434965, 347), + (435312, 347), + (435659, 347), + (436006, 346), + (436352, 347), + (436699, 347), + (437046, 347), + (437393, 347), + (437740, 348), + (438088, 348), + (438436, 347), + (438783, 348), + (439131, 347), + (439478, 347), + (439825, 347), + (440172, 347), + (440519, 346), + (440865, 347), + (441212, 347), + (441559, 348), + (441907, 346), + (442253, 346), + (442599, 346), + (442945, 347), + (443292, 347), + (443639, 347), + (443986, 347), + (444333, 347), + (444680, 346), + (445026, 348), + (445374, 347), + (445721, 347), + (446068, 346), + (446414, 348), + (446762, 346), + (447108, 347), + (447455, 348), + (447803, 346), + (448149, 347), + (448496, 348), + (448844, 440), + (449284, 403), + (449687, 354), + (450041, 355), + (450396, 354), + (450750, 354), + (451104, 354), + (451458, 353), + (451811, 355), + (452166, 354), + (452520, 353), + (452873, 353), + (453226, 354), + (453580, 356), + (453936, 356), + (454292, 355), + (454647, 357), + (455004, 356), + (455360, 355), + (455715, 356), + (456071, 357), + (456428, 356), + (456784, 356), + (457140, 355), + (457495, 356), + (457851, 356), + (458207, 355), + (458562, 357), + (458919, 355), + (459274, 356), + (459630, 356), + (459986, 355), + (460341, 356), + (460697, 355), + (461052, 357), + (461409, 356), + (461765, 356), + (462121, 355), + (462476, 357), + (462833, 357), + (463190, 355), + (463545, 355), + (463900, 356), + (464256, 357), + (464613, 357), + (464970, 356), + (465326, 356), + (465682, 357), + (466039, 357), + (466396, 355), + (466751, 357), + (467108, 357), + (467465, 357), + (467822, 355), + (468177, 355), + (468532, 357), + (468889, 356), + (469245, 355), + (469600, 357), + (469957, 355), + (470312, 356), + (470668, 357), + (471025, 356), + (471381, 356), + (471737, 357), + (472094, 355), + (472449, 356), + (472805, 357), + (473162, 355), + (473517, 356), + (473873, 356), + (474229, 357), + (474586, 355), + (474941, 355), + (475296, 357), + (475653, 355), + (476008, 355), + (476363, 356), + (476719, 356), + (477075, 356), + (477431, 356), + (477787, 356), + (478143, 356), + (478499, 356), + (478855, 356), + (479211, 356), + (479567, 357), + (479924, 357), + (480281, 356), + (480637, 355), + (480992, 355), + (481347, 356), + (481703, 355), + (482058, 355), + (482413, 355), + (482768, 356), + (483124, 356), + (483480, 355), + (483835, 355), + (484190, 355), + (484545, 355), + (484900, 357), + (485257, 436), + (485693, 402), + (486095, 346), + (486441, 347), + (486788, 346), + (487134, 346), + (487480, 346), + (487826, 346), + (488172, 347), + (488519, 346), + (488865, 347), + (489212, 346), + (489558, 347), + (489905, 347), + (490252, 347), + (490599, 346), + (490945, 348), + (491293, 347), + (491640, 346), + (491986, 347), + (492333, 346), + (492679, 347), + (493026, 348), + (493374, 347), + (493721, 347), + (494068, 347), + (494415, 348), + (494763, 347), + (495110, 346), + (495456, 346), + (495802, 347), + (496149, 347), + (496496, 347), + (496843, 346), + (497189, 346), + (497535, 347), + (497882, 347), + (498229, 347), + (498576, 347), + (498923, 347), + (499270, 347), + (499617, 348), + (499965, 348), + (500313, 347), + (500660, 348), + (501008, 346), + (501354, 347), + (501701, 348), + (502049, 347), + (502396, 347), + (502743, 347), + (503090, 346), + (503436, 347), + (503783, 346), + (504129, 347), + (504476, 347), + (504823, 347), + (505170, 346), + (505516, 346), + (505862, 347), + (506209, 347), + (506556, 347), + (506903, 347), + (507250, 348), + (507598, 347), + (507945, 348), + (508293, 348), + (508641, 347), + (508988, 347), + (509335, 347), + (509682, 347), + (510029, 346), + (510375, 347), + (510722, 347), + (511069, 348), + (511417, 347), + (511764, 347), + (512111, 345), + (512456, 348), + (512804, 347), + (513151, 347), + (513498, 346), + (513844, 347), + (514191, 348), + (514539, 347), + (514886, 347), + (515233, 346), + (515579, 348), + (515927, 346), + (516273, 348), + (516621, 348), + (516969, 347), + (517316, 347), + (517663, 346), + (518009, 347), + (518356, 346), + (518702, 346), + (519048, 348), + (519396, 347), + (519743, 347), + (520090, 346), + (520436, 346), + (520782, 436), + (521218, 439), + (521657, 403), + (522060, 403), + (522463, 513), + (522976, 403), + (523379, 483), + (523862, 437), + (524299, 403), + (524702, 513), + (525215, 483), + (525698, 436), + (526134, 404), + (526538, 415), + (526953, 403), + (527356, 426), + (527782, 404), + (528186, 442), + (528628, 434), + (529062, 516), + (529578, 404), + (529982, 548), + (530530, 435), + (530965, 434), + (531399, 436), + (531835, 432), + (532267, 446), + (532713, 434), + (533147, 463), + (533610, 449), + (534059, 430), + (534489, 432), + (534921, 429), + (535350, 431), + (535781, 442), + (536223, 458), + (536681, 428), + (537109, 430), + (537539, 442), + (537981, 458), + (538439, 444), + (538883, 439), + (539322, 433), + (539755, 438), + (540193, 434), + (540627, 415), + (541042, 438), + (541480, 438), + (541918, 438), + (542356, 439), + (542795, 436), + (543231, 437), + (543668, 441), + (544109, 445), + (544554, 434), + (544988, 441), + (545429, 436), + (545865, 452), + (546317, 516), + (546833, 403), + (547236, 552), + (547788, 516), + (548304, 402), + (548706, 567), + (549273, 514), + (549787, 403), + (550190, 549), + (550739, 435), + (551174, 430), + (551604, 436), + (552040, 431), + (552471, 441), + (552912, 435), + (553347, 442), + (553789, 436), + (554225, 429), + (554654, 426), + (555080, 443), + (555523, 439), + (555962, 446), + (556408, 452), + (556860, 466), + (557326, 404), + (557730, 470), + (558200, 403), + (558603, 528), + (559131, 403), + (559534, 584), + (560118, 608), + (560726, 528), + (561254, 472), + (561726, 517), + (562243, 608), + (562851, 521), + (563372, 402), + (563774, 573), + (564347, 634), + (564981, 521), + (565502, 402), + (565904, 552), + (566456, 652), + (567108, 536), + (567644, 404), + (568048, 548), + (568596, 518), + (569114, 402), + (569516, 546), + (570062, 574), + (570636, 402), + (571038, 550), + (571588, 458), + (572046, 380), + (572426, 562), + (572988, 448), + (573436, 493), + (573929, 466), + (574395, 379), + (574774, 380), + (575154, 535), + (575689, 529), + (576218, 455), + (576673, 521), + (577194, 402), + (577596, 530), + (578126, 520), + (578646, 403), + (579049, 522), + (579571, 539), + (580110, 403), + (580513, 521), + (581034, 536), + (581570, 402), + (581972, 524), + (582496, 518), + (583014, 403), + (583417, 525), + (583942, 523), + (584465, 404), + (584869, 527), + (585396, 530), + (585926, 404), + (586330, 527), + (586857, 519), + (587376, 403), + (587779, 528), + (588307, 519), + (588826, 403), + (589229, 529), + (589758, 525), + (590283, 403), + (590686, 531), + (591217, 583), + (591800, 402), + (592202, 524), + (592726, 551), + (593277, 404), + (593681, 524), + (594205, 537), + (594742, 402), + (595144, 547), + (595691, 516), + (596207, 403), + (596610, 547), + (597157, 519), + (597676, 402), + (598078, 547), + (598625, 515), + (599140, 403), + (599543, 533), + (600076, 433), + (600509, 402), + (600911, 413), + (601324, 403), + (601727, 446), + (602173, 404), + (602577, 431), + (603008, 403), + (603411, 438), + (603849, 402), + (604251, 418), + (604669, 403), + (605072, 1072), + (606144, 435), + (606579, 406), + (606985, 435), + (607420, 371), + (607791, 517), + (608308, 403), + (608711, 485), + (609196, 511), + (609707, 402), + (610109, 512), + (610621, 514), + (611135, 402), + (611537, 512), + (612049, 512), + (612561, 400), + (612961, 511), + (613472, 513), + (613985, 400), + (614385, 514), + (614899, 512), + (615411, 401), + (615812, 512), + (616324, 514), + (616838, 400), + (617238, 514), + (617752, 514), + (618266, 400), + (618666, 513), + (619179, 513), + (619692, 401), + (620093, 515), + (620608, 514), + (621122, 400), + (621522, 514), + (622036, 514), + (622550, 401), + (622951, 514), + (623465, 514), + (623979, 402), + (624381, 513), + (624894, 411), + (625305, 403), + (625708, 409), + (626117, 376), + (626493, 458), + (626951, 404), + (627355, 436), + (627791, 424), + (628215, 435), + (628650, 403), + (629053, 422), + (629475, 513), + (629988, 403), + (630391, 515), + (630906, 544), + (631450, 514), + (631964, 402), + (632366, 539), + (632905, 514), + (633419, 422), + (633841, 403), + (634244, 515), + (634759, 515), + (635274, 403), + (635677, 512), + (636189, 515), + (636704, 402), + (637106, 436), + (637542, 385), + (637927, 437), + (638364, 400), + (638764, 437), + (639201, 402), + (639603, 513), + (640116, 403), + (640519, 451), + (640970, 404), + (641374, 479), + (641853, 403), + (642256, 482), + (642738, 404), + (643142, 461), + (643603, 404), + (644007, 422), + (644429, 404), + (644833, 435), + (645268, 403), + (645671, 1320), + (646991, 1391), + (648382, 1306), + (649688, 518), + (650206, 404), + (650610, 519), + (651129, 403), + (651532, 515), + (652047, 514), + (652561, 403), + (652964, 4032), + (656996, 3999), + (660995, 5561), + (666556, 5528), + (672084, 7519), + (679603, 7486), + (687089, 4032), + (691121, 3998), + (695119, 4032), + (699151, 3999), + (703150, 4032), + (707182, 3999), + (711181, 437), + (711618, 413), + (712031, 437), + (712468, 460), + (712928, 436), + (713364, 440), + (713804, 435), + (714239, 463), + (714702, 435), + (715137, 436), + (715573, 428), + (716001, 403), + (716404, 434), + (716838, 402), + (717240, 454), + (717694, 404), + (718098, 471), + (718569, 403), + (718972, 452), + (719424, 403), + (719827, 442), + (720269, 404), + (720673, 452), + (721125, 402), + (721527, 473), + (722000, 404), + (722404, 437), + (722841, 402), + (723243, 444), + (723687, 404), + (724091, 438), + (724529, 402), + (724931, 414), + (725345, 402), + (725747, 435), + (726182, 423), + (726605, 435), + (727040, 430), + (727470, 516), + (727986, 403), + (728389, 532), + (728921, 515), + (729436, 404), + (729840, 537), + (730377, 517), + (730894, 404), + (731298, 521), + (731819, 436), + (732255, 402), + (732657, 429), + (733086, 404), + (733490, 436), + (733926, 403), + (734329, 441), + (734770, 404), + (735174, 436), + (735610, 403), + (736013, 441), + (736454, 404), + (736858, 431), + (737289, 404), + (737693, 432), + (738125, 403), + (738528, 446), + (738974, 402), + (739376, 437), + (739813, 403), + (740216, 442), + (740658, 403), + (741061, 444), + (741505, 403), + (741908, 438), + (742346, 402), + (742748, 452), + (743200, 403), + (743603, 441), + (744044, 403), + (744447, 412), + (744859, 402), + (745261, 442), + (745703, 402), + (746105, 426), + (746531, 403), + (746934, 426), + (747360, 404), + (747764, 719), + (748483, 648), + (749131, 1320), + (750451, 462), + (750913, 402), + (751315, 420), + (751735, 372), + (752107, 420), + (752527, 404), + (752931, 437), + (753368, 1541), + (754909, 1574), + (756483, 403), + (756886, 500), + (757386, 538), + (757924, 506), + (758430, 404), + (758834, 630), + (759464, 800), + (760264, 639), + (760903, 404), + (761307, 304), + (761611, 402), + (762013, 455), + (762468, 402), + (762870, 520), + (763390, 403), + (763793, 560), + (764353, 530), + (764883, 542), + (765425, 554), + (765979, 561), + (766540, 572), + (767112, 553), + (767665, 535), + (768200, 541), + (768741, 554), + (769295, 536), + (769831, 542), + (770373, 552), + (770925, 525), + (771450, 542), + (771992, 552), + (772544, 525), + (773069, 541), + (773610, 553), + (774163, 574), + (774737, 571), + (775308, 553), + (775861, 507), + (776368, 542), + (776910, 553), + (777463, 508), + (777971, 570), + (778541, 554), + (779095, 509), + (779604, 570), + (780174, 552), + (780726, 508), + (781234, 572), + (781806, 553), + (782359, 508), + (782867, 586), + (783453, 554), + (784007, 508), + (784515, 585), + (785100, 553), + (785653, 509), + (786162, 579), + (786741, 553), + (787294, 507), + (787801, 591), + (788392, 552), + (788944, 508), + (789452, 590), + (790042, 552), + (790594, 507), + (791101, 571), + (791672, 553), + (792225, 507), + (792732, 586), + (793318, 554), + (793872, 508), + (794380, 586), + (794966, 552), + (795518, 509), + (796027, 587), + (796614, 553), + (797167, 508), + (797675, 599), + (798274, 553), + (798827, 509), + (799336, 599), + (799935, 554), + (800489, 508), + (800997, 593), + (801590, 553), + (802143, 508), + (802651, 604), + (803255, 554), + (803809, 508), + (804317, 605), + (804922, 553), + (805475, 508), + (805983, 571), + (806554, 552), + (807106, 508), + (807614, 586), + (808200, 553), + (808753, 508), + (809261, 585), + (809846, 553), + (810399, 509), + (810908, 587), + (811495, 553), + (812048, 508), + (812556, 599), + (813155, 553), + (813708, 508), + (814216, 599), + (814815, 554), + (815369, 507), + (815876, 592), + (816468, 552), + (817020, 508), + (817528, 605), + (818133, 553), + (818686, 507), + (819193, 606), + (819799, 553), + (820352, 507), + (820859, 573), + (821432, 553), + (821985, 509), + (822494, 588), + (823082, 553), + (823635, 508), + (824143, 588), + (824731, 553), + (825284, 507), + (825791, 589), + (826380, 552), + (826932, 507), + (827439, 601), + (828040, 553), + (828593, 509), + (829102, 600), + (829702, 552), + (830254, 507), + (830761, 594), + (831355, 552), + (831907, 508), + (832415, 607), + (833022, 554), + (833576, 508), + (834084, 605), + (834689, 554), + (835243, 507), + (835750, 585), + (836335, 554), + (836889, 507), + (837396, 599), + (837995, 553), + (838548, 509), + (839057, 599), + (839656, 552), + (840208, 508), + (840716, 601), + (841317, 554), + (841871, 508), + (842379, 611), + (842990, 553), + (843543, 507), + (844050, 613), + (844663, 553), + (845216, 509), + (845725, 607), + (846332, 553), + (846885, 509), + (847394, 619), + (848013, 553), + (848566, 507), + (849073, 618), + (849691, 552), + (850243, 509), + (850752, 585), + (851337, 553), + (851890, 507), + (852397, 598), + (852995, 553), + (853548, 507), + (854055, 599), + (854654, 553), + (855207, 507), + (855714, 599), + (856313, 554), + (856867, 508), + (857375, 611), + (857986, 554), + (858540, 508), + (859048, 611), + (859659, 553), + (860212, 507), + (860719, 606), + (861325, 552), + (861877, 508), + (862385, 617), + (863002, 554), + (863556, 509), + (864065, 619), + (864684, 553), + (865237, 508), + (865745, 576), + (866321, 553), + (866874, 509), + (867383, 588), + (867971, 554), + (868525, 508), + (869033, 589), + (869622, 552), + (870174, 508), + (870682, 591), + (871273, 554), + (871827, 507), + (872334, 602), + (872936, 554), + (873490, 508), + (873998, 602), + (874600, 553), + (875153, 509), + (875662, 595), + (876257, 554), + (876811, 508), + (877319, 607), + (877926, 553), + (878479, 508), + (878987, 608), + (879595, 553), + (880148, 509), + (880657, 586), + (881243, 552), + (881795, 507), + (882302, 601), + (882903, 553), + (883456, 508), + (883964, 602), + (884566, 552), + (885118, 509), + (885627, 602), + (886229, 552), + (886781, 507), + (887288, 615), + (887903, 553), + (888456, 508), + (888964, 614), + (889578, 553), + (890131, 509), + (890640, 609), + (891249, 552), + (891801, 509), + (892310, 620), + (892930, 554), + (893484, 509), + (893993, 619), + (894612, 553), + (895165, 507), + (895672, 587), + (896259, 553), + (896812, 508), + (897320, 602), + (897922, 552), + (898474, 507), + (898981, 602), + (899583, 553), + (900136, 508), + (900644, 603), + (901247, 553), + (901800, 508), + (902308, 613), + (902921, 554), + (903475, 507), + (903982, 615), + (904597, 553), + (905150, 508), + (905658, 608), + (906266, 553), + (906819, 508), + (907327, 621), + (907948, 553), + (908501, 508), + (909009, 620), + (909629, 552), + (910181, 525), + (910706, 542), + (911248, 553), + (911801, 525), + (912326, 569), + (912895, 552), + (913447, 525), + (913972, 569), + (914541, 552), + (915093, 525), + (915618, 571), + (916189, 552), + (916741, 524), + (917265, 586), + (917851, 553), + (918404, 526), + (918930, 585), + (919515, 553), + (920068, 526), + (920594, 579), + (921173, 552), + (921725, 525), + (922250, 590), + (922840, 553), + (923393, 524), + (923917, 591), + (924508, 553), + (925061, 526), + (925587, 571), + (926158, 553), + (926711, 524), + (927235, 587), + (927822, 553), + (928375, 526), + (928901, 587), + (929488, 552), + (930040, 525), + (930565, 587), + (931152, 554), + (931706, 525), + (932231, 598), + (932829, 554), + (933383, 525), + (933908, 600), + (934508, 554), + (935062, 526), + (935588, 593), + (936181, 552), + (936733, 524), + (937257, 606), + (937863, 553), + (938416, 524), + (938940, 605), + (939545, 553), + (940098, 525), + (940623, 571), + (941194, 553), + (941747, 525), + (942272, 585), + (942857, 553), + (943410, 526), + (943936, 586), + (944522, 554), + (945076, 525), + (945601, 586), + (946187, 552), + (946739, 526), + (947265, 598), + (947863, 553), + (948416, 525), + (948941, 600), + (949541, 553), + (950094, 525), + (950619, 593), + (951212, 553), + (951765, 526), + (952291, 605), + (952896, 554), + (953450, 524), + (953974, 604), + (954578, 552), + (955130, 525), + (955655, 571), + (956226, 554), + (956780, 525), + (957305, 588), + (957893, 554), + (958447, 526), + (958973, 587), + (959560, 552), + (960112, 526), + (960638, 587), + (961225, 554), + (961779, 524), + (962303, 600), + (962903, 553), + (963456, 525), + (963981, 599), + (964580, 552), + (965132, 525), + (965657, 594), + (966251, 553), + (966804, 524), + (967328, 606), + (967934, 553), + (968487, 525), + (969012, 606), + (969618, 553), + (970171, 524), + (970695, 585), + (971280, 553), + (971833, 524), + (972357, 598), + (972955, 553), + (973508, 525), + (974033, 598), + (974631, 553), + (975184, 526), + (975710, 600), + (976310, 552), + (976862, 524), + (977386, 612), + (977998, 553), + (978551, 525), + (979076, 611), + (979687, 553), + (980240, 526), + (980766, 607), + (981373, 554), + (981927, 525), + (982452, 619), + (983071, 553), + (983624, 525), + (984149, 619), + (984768, 552), + (985320, 524), + (985844, 585), + (986429, 553), + (986982, 524), + (987506, 598), + (988104, 553), + (988657, 526), + (989183, 600), + (989783, 552), + (990335, 525), + (990860, 600), + (991460, 553), + (992013, 525), + (992538, 612), + (993150, 552), + (993702, 525), + (994227, 612), + (994839, 552), + (995391, 525), + (995916, 606), + (996522, 552), + (997074, 524), + (997598, 618), + (998216, 553), + (998769, 526), + (999295, 618), + (999913, 553), + (1000466, 525), + (1000991, 574), + (1001565, 553), + (1002118, 524), + (1002642, 589), + (1003231, 553), + (1003784, 525), + (1004309, 589), + (1004898, 554), + (1005452, 526), + (1005978, 589), + (1006567, 553), + (1007120, 525), + (1007645, 601), + (1008246, 554), + (1008800, 525), + (1009325, 602), + (1009927, 552), + (1010479, 525), + (1011004, 596), + (1011600, 553), + (1012153, 526), + (1012679, 607), + (1013286, 553), + (1013839, 525), + (1014364, 608), + (1014972, 552), + (1015524, 525), + (1016049, 586), + (1016635, 554), + (1017189, 525), + (1017714, 601), + (1018315, 553), + (1018868, 524), + (1019392, 600), + (1019992, 553), + (1020545, 526), + (1021071, 602), + (1021673, 552), + (1022225, 524), + (1022749, 614), + (1023363, 554), + (1023917, 525), + (1024442, 615), + (1025057, 553), + (1025610, 526), + (1026136, 609), + (1026745, 552), + (1027297, 526), + (1027823, 620), + (1028443, 552), + (1028995, 526), + (1029521, 621), + (1030142, 553), + (1030695, 525), + (1031220, 588), + (1031808, 554), + (1032362, 525), + (1032887, 602), + (1033489, 553), + (1034042, 524), + (1034566, 601), + (1035167, 553), + (1035720, 525), + (1036245, 603), + (1036848, 553), + (1037401, 524), + (1037925, 613), + (1038538, 554), + (1039092, 526), + (1039618, 615), + (1040233, 554), + (1040787, 525), + (1041312, 607), + (1041919, 553), + (1042472, 524), + (1042996, 620), + (1043616, 553), + (1044169, 526), + (1044695, 621), + (1045316, 553), + (1045869, 524), + (1046393, 542), + (1046935, 553), + (1047488, 525), + (1048013, 571), + (1048584, 553), + (1049137, 525), + (1049662, 571), + (1050233, 554), + (1050787, 525), + (1051312, 571), + (1051883, 553), + (1052436, 524), + (1052960, 586), + (1053546, 554), + (1054100, 526), + (1054626, 585), + (1055211, 553), + (1055764, 524), + (1056288, 580), + (1056868, 553), + (1057421, 526), + (1057947, 591), + (1058538, 554), + (1059092, 526), + (1059618, 590), + (1060208, 553), + (1060761, 526), + (1061287, 569), + (1061856, 553), + (1062409, 526), + (1062935, 585), + (1063520, 554), + (1064074, 525), + (1064599, 586), + (1065185, 553), + (1065738, 525), + (1066263, 587), + (1066850, 553), + (1067403, 526), + (1067929, 600), + (1068529, 554), + (1069083, 525), + (1069608, 600), + (1070208, 554), + (1070762, 525), + (1071287, 593), + (1071880, 553), + (1072433, 525), + (1072958, 606), + (1073564, 554), + (1074118, 524), + (1074642, 605), + (1075247, 554), + (1075801, 525), + (1076326, 569), + (1076895, 553), + (1077448, 526), + (1077974, 586), + (1078560, 552), + (1079112, 525), + (1079637, 587), + (1080224, 554), + (1080778, 524), + (1081302, 588), + (1081890, 554), + (1082444, 524), + (1082968, 598), + (1083566, 554), + (1084120, 526), + (1084646, 599), + (1085245, 553), + (1085798, 524), + (1086322, 592), + (1086914, 554), + (1087468, 526), + (1087994, 606), + (1088600, 553), + (1089153, 526), + (1089679, 606), + (1090285, 553), + (1090838, 526), + (1091364, 573), + (1091937, 554), + (1092491, 526), + (1093017, 587), + (1093604, 553), + (1094157, 524), + (1094681, 588), + (1095269, 553), + (1095822, 524), + (1096346, 588), + (1096934, 552), + (1097486, 524), + (1098010, 600), + (1098610, 552), + (1099162, 526), + (1099688, 599), + (1100287, 552), + (1100839, 524), + (1101363, 594), + (1101957, 553), + (1102510, 524), + (1103034, 605), + (1103639, 553), + (1104192, 524), + (1104716, 606), + (1105322, 553), + (1105875, 525), + (1106400, 585), + (1106985, 552), + (1107537, 525), + (1108062, 598), + (1108660, 554), + (1109214, 524), + (1109738, 599), + (1110337, 553), + (1110890, 526), + (1111416, 600), + (1112016, 553), + (1112569, 525), + (1113094, 611), + (1113705, 553), + (1114258, 526), + (1114784, 612), + (1115396, 552), + (1115948, 526), + (1116474, 607), + (1117081, 552), + (1117633, 524), + (1118157, 618), + (1118775, 553), + (1119328, 525), + (1119853, 618), + (1120471, 552), + (1121023, 525), + (1121548, 584), + (1122132, 553), + (1122685, 526), + (1123211, 599), + (1123810, 554), + (1124364, 526), + (1124890, 600), + (1125490, 552), + (1126042, 525), + (1126567, 601), + (1127168, 553), + (1127721, 524), + (1128245, 612), + (1128857, 553), + (1129410, 525), + (1129935, 613), + (1130548, 552), + (1131100, 525), + (1131625, 606), + (1132231, 553), + (1132784, 526), + (1133310, 617), + (1133927, 553), + (1134480, 525), + (1135005, 617), + (1135622, 553), + (1136175, 524), + (1136699, 575), + (1137274, 553), + (1137827, 525), + (1138352, 588), + (1138940, 552), + (1139492, 526), + (1140018, 589), + (1140607, 553), + (1141160, 525), + (1141685, 591), + (1142276, 554), + (1142830, 525), + (1143355, 601), + (1143956, 553), + (1144509, 525), + (1145034, 601), + (1145635, 553), + (1146188, 525), + (1146713, 595), + (1147308, 553), + (1147861, 524), + (1148385, 607), + (1148992, 554), + (1149546, 524), + (1150070, 608), + (1150678, 552), + (1151230, 525), + (1151755, 587), + (1152342, 553), + (1152895, 525), + (1153420, 602), + (1154022, 553), + (1154575, 525), + (1155100, 601), + (1155701, 554), + (1156255, 524), + (1156779, 601), + (1157380, 552), + (1157932, 526), + (1158458, 615), + (1159073, 553), + (1159626, 524), + (1160150, 613), + (1160763, 552), + (1161315, 525), + (1161840, 609), + (1162449, 553), + (1163002, 524), + (1163526, 620), + (1164146, 554), + (1164700, 524), + (1165224, 620), + (1165844, 553), + (1166397, 525), + (1166922, 586), + (1167508, 553), + (1168061, 525), + (1168586, 602), + (1169188, 554), + (1169742, 526), + (1170268, 600), + (1170868, 552), + (1171420, 525), + (1171945, 602), + (1172547, 552), + (1173099, 526), + (1173625, 614), + (1174239, 553), + (1174792, 525), + (1175317, 614), + (1175931, 553), + (1176484, 525), + (1177009, 607), + (1177616, 553), + (1178169, 524), + (1178693, 620), + (1179313, 552), + (1179865, 524), + (1180389, 621), + (1181010, 553), + (1181563, 534), + (1182097, 542), + (1182639, 553), + (1183192, 535), + (1183727, 570), + (1184297, 554), + (1184851, 535), + (1185386, 570), + (1185956, 553), + (1186509, 535), + (1187044, 571), + (1187615, 554), + (1188169, 536), + (1188705, 584), + (1189289, 552), + (1189841, 536), + (1190377, 585), + (1190962, 554), + (1191516, 536), + (1192052, 578), + (1192630, 554), + (1193184, 534), + (1193718, 592), + (1194310, 553), + (1194863, 536), + (1195399, 591), + (1195990, 552), + (1196542, 536), + (1197078, 570), + (1197648, 553), + (1198201, 535), + (1198736, 586), + (1199322, 554), + (1199876, 535), + (1200411, 586), + (1200997, 553), + (1201550, 534), + (1202084, 588), + (1202672, 554), + (1203226, 536), + (1203762, 598), + (1204360, 554), + (1204914, 535), + (1205449, 600), + (1206049, 553), + (1206602, 535), + (1207137, 593), + (1207730, 554), + (1208284, 534), + (1208818, 605), + (1209423, 552), + (1209975, 536), + (1210511, 605), + (1211116, 551), + (1211667, 536), + (1212203, 570), + (1212773, 552), + (1213325, 534), + (1213859, 585), + (1214444, 553), + (1214997, 535), + (1215532, 587), + (1216119, 554), + (1216673, 536), + (1217209, 586), + (1217795, 552), + (1218347, 536), + (1218883, 599), + (1219482, 552), + (1220034, 534), + (1220568, 599), + (1221167, 553), + (1221720, 535), + (1222255, 594), + (1222849, 553), + (1223402, 536), + (1223938, 605), + (1224543, 554), + (1225097, 535), + (1225632, 605), + (1226237, 554), + (1226791, 535), + (1227326, 571), + (1227897, 552), + (1228449, 536), + (1228985, 588), + (1229573, 552), + (1230125, 535), + (1230660, 587), + (1231247, 553), + (1231800, 535), + (1232335, 588), + (1232923, 553), + (1233476, 535), + (1234011, 600), + (1234611, 553), + (1235164, 535), + (1235699, 600), + (1236299, 554), + (1236853, 535), + (1237388, 595), + (1237983, 554), + (1238537, 535), + (1239072, 606), + (1239678, 554), + (1240232, 534), + (1240766, 607), + (1241373, 554), + (1241927, 534), + (1242461, 586), + (1243047, 552), + (1243599, 536), + (1244135, 600), + (1244735, 552), + (1245287, 535), + (1245822, 600), + (1246422, 552), + (1246974, 534), + (1247508, 599), + (1248107, 554), + (1248661, 535), + (1249196, 612), + (1249808, 553), + (1250361, 535), + (1250896, 612), + (1251508, 553), + (1252061, 536), + (1252597, 606), + (1253203, 552), + (1253755, 535), + (1254290, 618), + (1254908, 552), + (1255460, 535), + (1255995, 618), + (1256613, 553), + (1257166, 535), + (1257701, 585), + (1258286, 553), + (1258839, 535), + (1259374, 600), + (1259974, 553), + (1260527, 536), + (1261063, 599), + (1261662, 554), + (1262216, 535), + (1262751, 600), + (1263351, 553), + (1263904, 536), + (1264440, 612), + (1265052, 552), + (1265604, 534), + (1266138, 612), + (1266750, 554), + (1267304, 536), + (1267840, 606), + (1268446, 554), + (1269000, 535), + (1269535, 618), + (1270153, 554), + (1270707, 536), + (1271243, 618), + (1271861, 553), + (1272414, 534), + (1272948, 575), + (1273523, 553), + (1274076, 536), + (1274612, 589), + (1275201, 554), + (1275755, 535), + (1276290, 589), + (1276879, 552), + (1277431, 535), + (1277966, 591), + (1278557, 553), + (1279110, 534), + (1279644, 601), + (1280245, 553), + (1280798, 535), + (1281333, 601), + (1281934, 553), + (1282487, 536), + (1283023, 596), + (1283619, 553), + (1284172, 534), + (1284706, 609), + (1285315, 554), + (1285869, 536), + (1286405, 609), + (1287014, 553), + (1287567, 535), + (1288102, 587), + (1288689, 552), + (1289241, 536), + (1289777, 602), + (1290379, 553), + (1290932, 534), + (1291466, 600), + (1292066, 553), + (1292619, 534), + (1293153, 603), + (1293756, 552), + (1294308, 535), + (1294843, 614), + (1295457, 553), + (1296010, 535), + (1296545, 614), + (1297159, 553), + (1297712, 535), + (1298247, 607), + (1298854, 553), + (1299407, 535), + (1299942, 621), + (1300563, 553), + (1301116, 536), + (1301652, 619), + (1302271, 552), + (1302823, 536), + (1303359, 587), + (1303946, 552), + (1304498, 535), + (1305033, 600), + (1305633, 553), + (1306186, 536), + (1306722, 601), + (1307323, 553), + (1307876, 534), + (1308410, 602), + (1309012, 553), + (1309565, 535), + (1310100, 614), + (1310714, 552), + (1311266, 535), + (1311801, 614), + (1312415, 553), + (1312968, 535), + (1313503, 607), + (1314110, 553), + (1314663, 535), + (1315198, 619), + (1315817, 553), + (1316370, 536), + (1316906, 620), + (1317526, 553), + (1318079, 541), + (1318620, 542), + (1319162, 553), + (1319715, 541), + (1320256, 569), + (1320825, 554), + (1321379, 541), + (1321920, 569), + (1322489, 553), + (1323042, 540), + (1323582, 571), + (1324153, 553), + (1324706, 540), + (1325246, 584), + (1325830, 552), + (1326382, 541), + (1326923, 586), + (1327509, 553), + (1328062, 542), + (1328604, 579), + (1329183, 553), + (1329736, 541), + (1330277, 590), + (1330867, 553), + (1331420, 541), + (1331961, 590), + (1332551, 554), + (1333105, 541), + (1333646, 569), + (1334215, 553), + (1334768, 542), + (1335310, 586), + (1335896, 552), + (1336448, 541), + (1336989, 585), + (1337574, 552), + (1338126, 541), + (1338667, 587), + (1339254, 552), + (1339806, 541), + (1340347, 598), + (1340945, 553), + (1341498, 541), + (1342039, 599), + (1342638, 552), + (1343190, 540), + (1343730, 593), + (1344323, 554), + (1344877, 541), + (1345418, 605), + (1346023, 554), + (1346577, 541), + (1347118, 606), + (1347724, 554), + (1348278, 540), + (1348818, 571), + (1349389, 553), + (1349942, 540), + (1350482, 585), + (1351067, 553), + (1351620, 541), + (1352161, 586), + (1352747, 553), + (1353300, 542), + (1353842, 588), + (1354430, 552), + (1354982, 540), + (1355522, 598), + (1356120, 552), + (1356672, 542), + (1357214, 600), + (1357814, 553), + (1358367, 541), + (1358908, 593), + (1359501, 553), + (1360054, 542), + (1360596, 606), + (1361202, 553), + (1361755, 540), + (1362295, 606), + (1362901, 553), + (1363454, 540), + (1363994, 573), + (1364567, 552), + (1365119, 542), + (1365661, 587), + (1366248, 553), + (1366801, 542), + (1367343, 587), + (1367930, 554), + (1368484, 541), + (1369025, 588), + (1369613, 553), + (1370166, 540), + (1370706, 600), + (1371306, 553), + (1371859, 541), + (1372400, 599), + (1372999, 553), + (1373552, 541), + (1374093, 594), + (1374687, 553), + (1375240, 541), + (1375781, 606), + (1376387, 554), + (1376941, 542), + (1377483, 606), + (1378089, 552), + (1378641, 542), + (1379183, 585), + (1379768, 552), + (1380320, 540), + (1380860, 599), + (1381459, 552), + (1382011, 541), + (1382552, 599), + (1383151, 553), + (1383704, 541), + (1384245, 600), + (1384845, 552), + (1385397, 540), + (1385937, 613), + (1386550, 553), + (1387103, 540), + (1387643, 612), + (1388255, 554), + (1388809, 540), + (1389349, 606), + (1389955, 552), + (1390507, 542), + (1391049, 617), + (1391666, 552), + (1392218, 540), + (1392758, 618), + (1393376, 553), + (1393929, 540), + (1394469, 584), + (1395053, 552), + (1395605, 541), + (1396146, 600), + (1396746, 552), + (1397298, 541), + (1397839, 599), + (1398438, 553), + (1398991, 542), + (1399533, 600), + (1400133, 553), + (1400686, 540), + (1401226, 612), + (1401838, 553), + (1402391, 540), + (1402931, 611), + (1403542, 554), + (1404096, 541), + (1404637, 606), + (1405243, 553), + (1405796, 542), + (1406338, 617), + (1406955, 553), + (1407508, 542), + (1408050, 618), + (1408668, 553), + (1409221, 541), + (1409762, 575), + (1410337, 553), + (1410890, 541), + (1411431, 590), + (1412021, 553), + (1412574, 541), + (1413115, 589), + (1413704, 554), + (1414258, 542), + (1414800, 591), + (1415391, 552), + (1415943, 542), + (1416485, 602), + (1417087, 553), + (1417640, 541), + (1418181, 602), + (1418783, 553), + (1419336, 542), + (1419878, 595), + (1420473, 552), + (1421025, 540), + (1421565, 609), + (1422174, 553), + (1422727, 542), + (1423269, 608), + (1423877, 552), + (1424429, 541), + (1424970, 587), + (1425557, 554), + (1426111, 542), + (1426653, 601), + (1427254, 554), + (1427808, 542), + (1428350, 601), + (1428951, 554), + (1429505, 542), + (1430047, 602), + (1430649, 553), + (1431202, 542), + (1431744, 615), + (1432359, 552), + (1432911, 541), + (1433452, 614), + (1434066, 553), + (1434619, 541), + (1435160, 609), + (1435769, 552), + (1436321, 541), + (1436862, 620), + (1437482, 553), + (1438035, 540), + (1438575, 620), + (1439195, 552), + (1439747, 541), + (1440288, 587), + (1440875, 553), + (1441428, 542), + (1441970, 601), + (1442571, 553), + (1443124, 541), + (1443665, 601), + (1444266, 553), + (1444819, 542), + (1445361, 603), + (1445964, 552), + (1446516, 542), + (1447058, 614), + (1447672, 553), + (1448225, 540), + (1448765, 613), + (1449378, 553), + (1449931, 540), + (1450471, 608), + (1451079, 553), + (1451632, 541), + (1452173, 620), + (1452793, 553), + (1453346, 542), + (1453888, 621), + (1454509, 554), + (1455063, 542), + (1455605, 543), + (1456148, 552), + (1456700, 540), + (1457240, 569), + (1457809, 553), + (1458362, 541), + (1458903, 570), + (1459473, 554), + (1460027, 542), + (1460569, 571), + (1461140, 553), + (1461693, 540), + (1462233, 584), + (1462817, 551), + (1463368, 541), + (1463909, 585), + (1464494, 553), + (1465047, 541), + (1465588, 579), + (1466167, 553), + (1466720, 541), + (1467261, 591), + (1467852, 553), + (1468405, 541), + (1468946, 591), + (1469537, 554), + (1470091, 540), + (1470631, 569), + (1471200, 552), + (1471752, 541), + (1472293, 585), + (1472878, 552), + (1473430, 540), + (1473970, 586), + (1474556, 553), + (1475109, 541), + (1475650, 586), + (1476236, 553), + (1476789, 541), + (1477330, 598), + (1477928, 553), + (1478481, 540), + (1479021, 599), + (1479620, 553), + (1480173, 541), + (1480714, 592), + (1481306, 552), + (1481858, 541), + (1482399, 606), + (1483005, 553), + (1483558, 541), + (1484099, 604), + (1484703, 554), + (1485257, 540), + (1485797, 570), + (1486367, 553), + (1486920, 542), + (1487462, 585), + (1488047, 552), + (1488599, 540), + (1489139, 586), + (1489725, 554), + (1490279, 542), + (1490821, 587), + (1491408, 552), + (1491960, 541), + (1492501, 598), + (1493099, 552), + (1493651, 542), + (1494193, 599), + (1494792, 554), + (1495346, 541), + (1495887, 593), + (1496480, 554), + (1497034, 540), + (1497574, 605), + (1498179, 553), + (1498732, 542), + (1499274, 605), + (1499879, 554), + (1500433, 542), + (1500975, 571), + (1501546, 554), + (1502100, 541), + (1502641, 586), + (1503227, 554), + (1503781, 541), + (1504322, 588), + (1504910, 553), + (1505463, 541), + (1506004, 588), + (1506592, 553), + (1507145, 540), + (1507685, 601), + (1508286, 553), + (1508839, 542), + (1509381, 600), + (1509981, 553), + (1510534, 541), + (1511075, 593), + (1511668, 553), + (1512221, 541), + (1512762, 606), + (1513368, 552), + (1513920, 542), + (1514462, 606), + (1515068, 553), + (1515621, 542), + (1516163, 584), + (1516747, 553), + (1517300, 540), + (1517840, 599), + (1518439, 554), + (1518993, 540), + (1519533, 599), + (1520132, 554), + (1520686, 542), + (1521228, 600), + (1521828, 553), + (1522381, 541), + (1522922, 611), + (1523533, 553), + (1524086, 540), + (1524626, 612), + (1525238, 554), + (1525792, 541), + (1526333, 606), + (1526939, 553), + (1527492, 541), + (1528033, 618), + (1528651, 552), + (1529203, 541), + (1529744, 617), + (1530361, 552), + (1530913, 542), + (1531455, 586), + (1532041, 554), + (1532595, 542), + (1533137, 599), + (1533736, 554), + (1534290, 540), + (1534830, 600), + (1535430, 552), + (1535982, 542), + (1536524, 601), + (1537125, 552), + (1537677, 540), + (1538217, 612), + (1538829, 553), + (1539382, 540), + (1539922, 612), + (1540534, 553), + (1541087, 540), + (1541627, 607), + (1542234, 553), + (1542787, 540), + (1543327, 618), + (1543945, 553), + (1544498, 542), + (1545040, 617), + (1545657, 553), + (1546210, 541), + (1546751, 575), + (1547326, 553), + (1547879, 540), + (1548419, 589), + (1549008, 553), + (1549561, 542), + (1550103, 590), + (1550693, 552), + (1551245, 541), + (1551786, 589), + (1552375, 553), + (1552928, 540), + (1553468, 603), + (1554071, 552), + (1554623, 540), + (1555163, 602), + (1555765, 554), + (1556319, 540), + (1556859, 596), + (1557455, 553), + (1558008, 541), + (1558549, 607), + (1559156, 553), + (1559709, 541), + (1560250, 609), + (1560859, 553), + (1561412, 541), + (1561953, 587), + (1562540, 553), + (1563093, 541), + (1563634, 602), + (1564236, 552), + (1564788, 540), + (1565328, 601), + (1565929, 553), + (1566482, 541), + (1567023, 602), + (1567625, 553), + (1568178, 542), + (1568720, 613), + (1569333, 554), + (1569887, 540), + (1570427, 613), + (1571040, 552), + (1571592, 541), + (1572133, 608), + (1572741, 554), + (1573295, 542), + (1573837, 620), + (1574457, 553), + (1575010, 541), + (1575551, 619), + (1576170, 553), + (1576723, 540), + (1577263, 586), + (1577849, 554), + (1578403, 541), + (1578944, 602), + (1579546, 553), + (1580099, 541), + (1580640, 601), + (1581241, 554), + (1581795, 542), + (1582337, 603), + (1582940, 553), + (1583493, 540), + (1584033, 615), + (1584648, 552), + (1585200, 542), + (1585742, 615), + (1586357, 554), + (1586911, 541), + (1587452, 607), + (1588059, 554), + (1588613, 541), + (1589154, 621), + (1589775, 552), + (1590327, 542), + (1590869, 621), + (1591490, 553), + (1592043, 536), + (1592579, 542), + (1593121, 553), + (1593674, 536), + (1594210, 570), + (1594780, 552), + (1595332, 536), + (1595868, 570), + (1596438, 554), + (1596992, 535), + (1597527, 572), + (1598099, 553), + (1598652, 537), + (1599189, 585), + (1599774, 553), + (1600327, 537), + (1600864, 586), + (1601450, 553), + (1602003, 536), + (1602539, 580), + (1603119, 553), + (1603672, 535), + (1604207, 591), + (1604798, 553), + (1605351, 535), + (1605886, 591), + (1606477, 553), + (1607030, 536), + (1607566, 571), + (1608137, 552), + (1608689, 536), + (1609225, 585), + (1609810, 552), + (1610362, 536), + (1610898, 586), + (1611484, 553), + (1612037, 536), + (1612573, 587), + (1613160, 553), + (1613713, 536), + (1614249, 599), + (1614848, 553), + (1615401, 537), + (1615938, 599), + (1616537, 553), + (1617090, 537), + (1617627, 594), + (1618221, 553), + (1618774, 536), + (1619310, 606), + (1619916, 553), + (1620469, 536), + (1621005, 606), + (1621611, 554), + (1622165, 535), + (1622700, 570), + (1623270, 553), + (1623823, 537), + (1624360, 587), + (1624947, 553), + (1625500, 536), + (1626036, 587), + (1626623, 553), + (1627176, 536), + (1627712, 586), + (1628298, 552), + (1628850, 537), + (1629387, 598), + (1629985, 553), + (1630538, 536), + (1631074, 598), + (1631672, 554), + (1632226, 536), + (1632762, 592), + (1633354, 553), + (1633907, 537), + (1634444, 605), + (1635049, 553), + (1635602, 536), + (1636138, 606), + (1636744, 554), + (1637298, 537), + (1637835, 572), + (1638407, 554), + (1638961, 536), + (1639497, 587), + (1640084, 553), + (1640637, 537), + (1641174, 587), + (1641761, 553), + (1642314, 536), + (1642850, 588), + (1643438, 554), + (1643992, 535), + (1644527, 600), + (1645127, 552), + (1645679, 536), + (1646215, 599), + (1646814, 552), + (1647366, 536), + (1647902, 594), + (1648496, 552), + (1649048, 536), + (1649584, 606), + (1650190, 553), + (1650743, 536), + (1651279, 605), + (1651884, 553), + (1652437, 537), + (1652974, 584), + (1653558, 552), + (1654110, 537), + (1654647, 599), + (1655246, 552), + (1655798, 536), + (1656334, 599), + (1656933, 552), + (1657485, 536), + (1658021, 601), + (1658622, 554), + (1659176, 535), + (1659711, 612), + (1660323, 553), + (1660876, 535), + (1661411, 612), + (1662023, 552), + (1662575, 536), + (1663111, 605), + (1663716, 553), + (1664269, 536), + (1664805, 618), + (1665423, 552), + (1665975, 536), + (1666511, 618), + (1667129, 553), + (1667682, 537), + (1668219, 586), + (1668805, 554), + (1669359, 535), + (1669894, 600), + (1670494, 552), + (1671046, 535), + (1671581, 599), + (1672180, 554), + (1672734, 537), + (1673271, 599), + (1673870, 553), + (1674423, 535), + (1674958, 613), + (1675571, 554), + (1676125, 536), + (1676661, 613), + (1677274, 553), + (1677827, 536), + (1678363, 607), + (1678970, 553), + (1679523, 535), + (1680058, 618), + (1680676, 552), + (1681228, 536), + (1681764, 618), + (1682382, 553), + (1682935, 536), + (1683471, 575), + (1684046, 553), + (1684599, 537), + (1685136, 590), + (1685726, 554), + (1686280, 536), + (1686816, 590), + (1687406, 552), + (1687958, 536), + (1688494, 589), + (1689083, 552), + (1689635, 534), + (1690169, 602), + (1690771, 553), + (1691324, 537), + (1691861, 602), + (1692463, 552), + (1693015, 536), + (1693551, 597), + (1694148, 553), + (1694701, 536), + (1695237, 608), + (1695845, 553), + (1696398, 537), + (1696935, 607), + (1697542, 553), + (1698095, 536), + (1698631, 588), + (1699219, 553), + (1699772, 536), + (1700308, 602), + (1700910, 552), + (1701462, 536), + (1701998, 601), + (1702599, 554), + (1703153, 537), + (1703690, 602), + (1704292, 553), + (1704845, 536), + (1705381, 613), + (1705994, 554), + (1706548, 535), + (1707083, 614), + (1707697, 554), + (1708251, 535), + (1708786, 608), + (1709394, 553), + (1709947, 536), + (1710483, 620), + (1711103, 553), + (1711656, 536), + (1712192, 620), + (1712812, 554), + (1713366, 535), + (1713901, 587), + (1714488, 552), + (1715040, 536), + (1715576, 602), + (1716178, 554), + (1716732, 535), + (1717267, 601), + (1717868, 552), + (1718420, 535), + (1718955, 603), + (1719558, 553), + (1720111, 536), + (1720647, 614), + (1721261, 552), + (1721813, 536), + (1722349, 614), + (1722963, 552), + (1723515, 535), + (1724050, 608), + (1724658, 554), + (1725212, 535), + (1725747, 619), + (1726366, 552), + (1726918, 535), + (1727453, 620), + (1728073, 553), + (1728626, 542), + (1729168, 542), + (1729710, 554), + (1730264, 542), + (1730806, 569), + (1731375, 553), + (1731928, 541), + (1732469, 569), + (1733038, 554), + (1733592, 541), + (1734133, 573), + (1734706, 554), + (1735260, 541), + (1735801, 586), + (1736387, 553), + (1736940, 542), + (1737482, 585), + (1738067, 552), + (1738619, 542), + (1739161, 579), + (1739740, 554), + (1740294, 543), + (1740837, 591), + (1741428, 553), + (1741981, 542), + (1742523, 590), + (1743113, 553), + (1743666, 542), + (1744208, 570), + (1744778, 552), + (1745330, 543), + (1745873, 586), + (1746459, 554), + (1747013, 541), + (1747554, 586), + (1748140, 554), + (1748694, 542), + (1749236, 588), + (1749824, 552), + (1750376, 542), + (1750918, 599), + (1751517, 553), + (1752070, 541), + (1752611, 599), + (1753210, 553), + (1753763, 542), + (1754305, 593), + (1754898, 553), + (1755451, 542), + (1755993, 604), + (1756597, 553), + (1757150, 542), + (1757692, 606), + (1758298, 553), + (1758851, 541), + (1759392, 571), + (1759963, 552), + (1760515, 541), + (1761056, 586), + (1761642, 554), + (1762196, 541), + (1762737, 587), + (1763324, 553), + (1763877, 543), + (1764420, 588), + (1765008, 552), + (1765560, 542), + (1766102, 598), + (1766700, 553), + (1767253, 542), + (1767795, 600), + (1768395, 553), + (1768948, 542), + (1769490, 593), + (1770083, 553), + (1770636, 541), + (1771177, 604), + (1771781, 554), + (1772335, 541), + (1772876, 606), + (1773482, 554), + (1774036, 542), + (1774578, 572), + (1775150, 552), + (1775702, 542), + (1776244, 587), + (1776831, 554), + (1777385, 543), + (1777928, 586), + (1778514, 553), + (1779067, 542), + (1779609, 588), + (1780197, 552), + (1780749, 543), + (1781292, 600), + (1781892, 554), + (1782446, 543), + (1782989, 601), + (1783590, 553), + (1784143, 542), + (1784685, 593), + (1785278, 554), + (1785832, 542), + (1786374, 606), + (1786980, 553), + (1787533, 541), + (1788074, 606), + (1788680, 554), + (1789234, 542), + (1789776, 585), + (1790361, 553), + (1790914, 541), + (1791455, 599), + (1792054, 554), + (1792608, 542), + (1793150, 598), + (1793748, 552), + (1794300, 543), + (1794843, 600), + (1795443, 553), + (1795996, 541), + (1796537, 611), + (1797148, 553), + (1797701, 542), + (1798243, 613), + (1798856, 552), + (1799408, 543), + (1799951, 605), + (1800556, 554), + (1801110, 541), + (1801651, 617), + (1802268, 553), + (1802821, 543), + (1803364, 617), + (1803981, 553), + (1804534, 542), + (1805076, 584), + (1805660, 553), + (1806213, 541), + (1806754, 599), + (1807353, 553), + (1807906, 542), + (1808448, 598), + (1809046, 554), + (1809600, 542), + (1810142, 601), + (1810743, 553), + (1811296, 542), + (1811838, 612), + (1812450, 553), + (1813003, 543), + (1813546, 612), + (1814158, 552), + (1814710, 542), + (1815252, 606), + (1815858, 552), + (1816410, 542), + (1816952, 618), + (1817570, 553), + (1818123, 542), + (1818665, 618), + (1819283, 552), + (1819835, 543), + (1820378, 575), + (1820953, 554), + (1821507, 543), + (1822050, 590), + (1822640, 554), + (1823194, 542), + (1823736, 589), + (1824325, 553), + (1824878, 541), + (1825419, 591), + (1826010, 554), + (1826564, 542), + (1827106, 602), + (1827708, 554), + (1828262, 543), + (1828805, 602), + (1829407, 553), + (1829960, 543), + (1830503, 596), + (1831099, 553), + (1831652, 542), + (1832194, 608), + (1832802, 553), + (1833355, 542), + (1833897, 607), + (1834504, 554), + (1835058, 542), + (1835600, 587), + (1836187, 554), + (1836741, 542), + (1837283, 600), + (1837883, 552), + (1838435, 541), + (1838976, 602), + (1839578, 552), + (1840130, 542), + (1840672, 603), + (1841275, 554), + (1841829, 541), + (1842370, 615), + (1842985, 554), + (1843539, 542), + (1844081, 614), + (1844695, 552), + (1845247, 541), + (1845788, 608), + (1846396, 554), + (1846950, 541), + (1847491, 619), + (1848110, 553), + (1848663, 542), + (1849205, 620), + (1849825, 554), + (1850379, 542), + (1850921, 588), + (1851509, 554), + (1852063, 543), + (1852606, 601), + (1853207, 553), + (1853760, 543), + (1854303, 601), + (1854904, 553), + (1855457, 542), + (1855999, 602), + (1856601, 553), + (1857154, 542), + (1857696, 614), + (1858310, 552), + (1858862, 542), + (1859404, 614), + (1860018, 553), + (1860571, 541), + (1861112, 608), + (1861720, 553), + (1862273, 541), + (1862814, 621), + (1863435, 553), + (1863988, 542), + (1864530, 619), + (1865149, 554), + (1865703, 541), + (1866244, 541), + (1866785, 553), + (1867338, 543), + (1867881, 571), + (1868452, 553), + (1869005, 542), + (1869547, 570), + (1870117, 552), + (1870669, 542), + (1871211, 571), + (1871782, 554), + (1872336, 542), + (1872878, 584), + (1873462, 553), + (1874015, 542), + (1874557, 584), + (1875141, 553), + (1875694, 542), + (1876236, 579), + (1876815, 552), + (1877367, 541), + (1877908, 590), + (1878498, 554), + (1879052, 542), + (1879594, 591), + (1880185, 554), + (1880739, 542), + (1881281, 569), + (1881850, 554), + (1882404, 541), + (1882945, 585), + (1883530, 552), + (1884082, 542), + (1884624, 585), + (1885209, 552), + (1885761, 543), + (1886304, 587), + (1886891, 553), + (1887444, 542), + (1887986, 599), + (1888585, 553), + (1889138, 543), + (1889681, 599), + (1890280, 553), + (1890833, 542), + (1891375, 593), + (1891968, 553), + (1892521, 542), + (1893063, 605), + (1893668, 553), + (1894221, 543), + (1894764, 604), + (1895368, 553), + (1895921, 542), + (1896463, 570), + (1897033, 552), + (1897585, 542), + (1898127, 586), + (1898713, 553), + (1899266, 541), + (1899807, 586), + (1900393, 553), + (1900946, 542), + (1901488, 586), + (1902074, 552), + (1902626, 542), + (1903168, 599), + (1903767, 554), + (1904321, 541), + (1904862, 599), + (1905461, 554), + (1906015, 541), + (1906556, 592), + (1907148, 553), + (1907701, 541), + (1908242, 605), + (1908847, 552), + (1909399, 542), + (1909941, 606), + (1910547, 553), + (1911100, 541), + (1911641, 573), + (1912214, 552), + (1912766, 543), + (1913309, 587), + (1913896, 553), + (1914449, 543), + (1914992, 588), + (1915580, 553), + (1916133, 542), + (1916675, 587), + (1917262, 554), + (1917816, 543), + (1918359, 599), + (1918958, 553), + (1919511, 543), + (1920054, 599), + (1920653, 554), + (1921207, 542), + (1921749, 594), + (1922343, 553), + (1922896, 541), + (1923437, 606), + (1924043, 554), + (1924597, 541), + (1925138, 605), + (1925743, 554), + (1926297, 542), + (1926839, 585), + (1927424, 552), + (1927976, 543), + (1928519, 599), + (1929118, 554), + (1929672, 542), + (1930214, 600), + (1930814, 553), + (1931367, 542), + (1931909, 599), + (1932508, 552), + (1933060, 542), + (1933602, 612), + (1934214, 552), + (1934766, 542), + (1935308, 613), + (1935921, 553), + (1936474, 542), + (1937016, 606), + (1937622, 554), + (1938176, 542), + (1938718, 618), + (1939336, 552), + (1939888, 542), + (1940430, 619), + (1941049, 554), + (1941603, 542), + (1942145, 585), + (1942730, 553), + (1943283, 542), + (1943825, 598), + (1944423, 553), + (1944976, 542), + (1945518, 599), + (1946117, 553), + (1946670, 541), + (1947211, 601), + (1947812, 554), + (1948366, 543), + (1948909, 611), + (1949520, 552), + (1950072, 542), + (1950614, 613), + (1951227, 552), + (1951779, 543), + (1952322, 606), + (1952928, 553), + (1953481, 543), + (1954024, 617), + (1954641, 554), + (1955195, 543), + (1955738, 618), + (1956356, 552), + (1956908, 542), + (1957450, 576), + (1958026, 552), + (1958578, 541), + (1959119, 589), + (1959708, 553), + (1960261, 541), + (1960802, 588), + (1961390, 554), + (1961944, 542), + (1962486, 590), + (1963076, 553), + (1963629, 542), + (1964171, 602), + (1964773, 553), + (1965326, 541), + (1965867, 602), + (1966469, 552), + (1967021, 541), + (1967562, 595), + (1968157, 552), + (1968709, 542), + (1969251, 607), + (1969858, 553), + (1970411, 543), + (1970954, 607), + (1971561, 553), + (1972114, 541), + (1972655, 587), + (1973242, 554), + (1973796, 542), + (1974338, 600), + (1974938, 552), + (1975490, 541), + (1976031, 601), + (1976632, 554), + (1977186, 542), + (1977728, 601), + (1978329, 554), + (1978883, 543), + (1979426, 613), + (1980039, 553), + (1980592, 542), + (1981134, 614), + (1981748, 553), + (1982301, 543), + (1982844, 608), + (1983452, 554), + (1984006, 542), + (1984548, 621), + (1985169, 554), + (1985723, 542), + (1986265, 619), + (1986884, 552), + (1987436, 543), + (1987979, 587), + (1988566, 554), + (1989120, 542), + (1989662, 601), + (1990263, 553), + (1990816, 543), + (1991359, 601), + (1991960, 554), + (1992514, 543), + (1993057, 603), + (1993660, 552), + (1994212, 541), + (1994753, 613), + (1995366, 552), + (1995918, 542), + (1996460, 613), + (1997073, 553), + (1997626, 541), + (1998167, 608), + (1998775, 554), + (1999329, 541), + (1999870, 620), + (2000490, 553), + (2001043, 543), + (2001586, 621), + (2002207, 554), + (2002761, 533), + (2003294, 542), + (2003836, 552), + (2004388, 533), + (2004921, 570), + (2005491, 553), + (2006044, 534), + (2006578, 569), + (2007147, 553), + (2007700, 534), + (2008234, 572), + (2008806, 553), + (2009359, 533), + (2009892, 585), + (2010477, 553), + (2011030, 532), + (2011562, 585), + (2012147, 554), + (2012701, 533), + (2013234, 578), + (2013812, 552), + (2014364, 533), + (2014897, 591), + (2015488, 552), + (2016040, 533), + (2016573, 591), + (2017164, 553), + (2017717, 534), + (2018251, 569), + (2018820, 554), + (2019374, 533), + (2019907, 586), + (2020493, 553), + (2021046, 534), + (2021580, 587), + (2022167, 554), + (2022721, 534), + (2023255, 588), + (2023843, 552), + (2024395, 532), + (2024927, 600), + (2025527, 553), + (2026080, 533), + (2026613, 599), + (2027212, 553), + (2027765, 532), + (2028297, 593), + (2028890, 553), + (2029443, 533), + (2029976, 605), + (2030581, 553), + (2031134, 533), + (2031667, 604), + (2032271, 553), + (2032824, 534), + (2033358, 571), + (2033929, 553), + (2034482, 533), + (2035015, 586), + (2035601, 553), + (2036154, 532), + (2036686, 587), + (2037273, 553), + (2037826, 534), + (2038360, 588), + (2038948, 553), + (2039501, 533), + (2040034, 600), + (2040634, 553), + (2041187, 531), + (2041718, 599), + (2042317, 553), + (2042870, 533), + (2043403, 594), + (2043997, 552), + (2044549, 532), + (2045081, 605), + (2045686, 553), + (2046239, 533), + (2046772, 605), + (2047377, 552), + (2047929, 534), + (2048463, 572), + (2049035, 553), + (2049588, 533), + (2050121, 588), + (2050709, 552), + (2051261, 533), + (2051794, 587), + (2052381, 553), + (2052934, 532), + (2053466, 587), + (2054053, 553), + (2054606, 533), + (2055139, 600), + (2055739, 553), + (2056292, 532), + (2056824, 601), + (2057425, 553), + (2057978, 532), + (2058510, 594), + (2059104, 553), + (2059657, 533), + (2060190, 607), + (2060797, 553), + (2061350, 533), + (2061883, 605), + (2062488, 552), + (2063040, 533), + (2063573, 586), + (2064159, 552), + (2064711, 532), + (2065243, 598), + (2065841, 553), + (2066394, 533), + (2066927, 599), + (2067526, 552), + (2068078, 534), + (2068612, 600), + (2069212, 554), + (2069766, 532), + (2070298, 613), + (2070911, 553), + (2071464, 533), + (2071997, 612), + (2072609, 553), + (2073162, 534), + (2073696, 606), + (2074302, 554), + (2074856, 532), + (2075388, 617), + (2076005, 554), + (2076559, 534), + (2077093, 618), + (2077711, 553), + (2078264, 532), + (2078796, 585), + (2079381, 553), + (2079934, 533), + (2080467, 599), + (2081066, 554), + (2081620, 533), + (2082153, 598), + (2082751, 553), + (2083304, 534), + (2083838, 600), + (2084438, 554), + (2084992, 533), + (2085525, 612), + (2086137, 552), + (2086689, 533), + (2087222, 611), + (2087833, 553), + (2088386, 534), + (2088920, 607), + (2089527, 554), + (2090081, 534), + (2090615, 619), + (2091234, 553), + (2091787, 534), + (2092321, 618), + (2092939, 553), + (2093492, 533), + (2094025, 576), + (2094601, 553), + (2095154, 533), + (2095687, 589), + (2096276, 553), + (2096829, 533), + (2097362, 590), + (2097952, 553), + (2098505, 532), + (2099037, 590), + (2099627, 552), + (2100179, 533), + (2100712, 603), + (2101315, 552), + (2101867, 534), + (2102401, 601), + (2103002, 554), + (2103556, 532), + (2104088, 596), + (2104684, 552), + (2105236, 534), + (2105770, 607), + (2106377, 554), + (2106931, 533), + (2107464, 607), + (2108071, 553), + (2108624, 533), + (2109157, 587), + (2109744, 552), + (2110296, 533), + (2110829, 601), + (2111430, 553), + (2111983, 534), + (2112517, 601), + (2113118, 552), + (2113670, 533), + (2114203, 603), + (2114806, 553), + (2115359, 532), + (2115891, 614), + (2116505, 553), + (2117058, 532), + (2117590, 614), + (2118204, 554), + (2118758, 532), + (2119290, 608), + (2119898, 552), + (2120450, 533), + (2120983, 620), + (2121603, 554), + (2122157, 532), + (2122689, 620), + (2123309, 554), + (2123863, 533), + (2124396, 587), + (2124983, 553), + (2125536, 533), + (2126069, 601), + (2126670, 554), + (2127224, 534), + (2127758, 601), + (2128359, 553), + (2128912, 533), + (2129445, 603), + (2130048, 553), + (2130601, 534), + (2131135, 614), + (2131749, 554), + (2132303, 533), + (2132836, 615), + (2133451, 554), + (2134005, 533), + (2134538, 609), + (2135147, 553), + (2135700, 533), + (2136233, 620), + (2136853, 553), + (2137406, 532), + (2137938, 621), + (2138559, 553), + (2139112, 550), + (2139662, 541), + (2140203, 553), + (2140756, 551), + (2141307, 570), + (2141877, 552), + (2142429, 549), + (2142978, 570), + (2143548, 553), + (2144101, 550), + (2144651, 572), + (2145223, 553), + (2145776, 550), + (2146326, 584), + (2146910, 554), + (2147464, 550), + (2148014, 586), + (2148600, 554), + (2149154, 550), + (2149704, 579), + (2150283, 552), + (2150835, 550), + (2151385, 591), + (2151976, 553), + (2152529, 550), + (2153079, 591), + (2153670, 554), + (2154224, 550), + (2154774, 570), + (2155344, 553), + (2155897, 550), + (2156447, 585), + (2157032, 553), + (2157585, 550), + (2158135, 587), + (2158722, 554), + (2159276, 550), + (2159826, 587), + (2160413, 553), + (2160966, 550), + (2161516, 599), + (2162115, 554), + (2162669, 550), + (2163219, 599), + (2163818, 554), + (2164372, 550), + (2164922, 593), + (2165515, 553), + (2166068, 550), + (2166618, 605), + (2167223, 553), + (2167776, 551), + (2168327, 605), + (2168932, 553), + (2169485, 550), + (2170035, 570), + (2170605, 554), + (2171159, 551), + (2171710, 586), + (2172296, 554), + (2172850, 551), + (2173401, 587), + (2173988, 552), + (2174540, 551), + (2175091, 587), + (2175678, 553), + (2176231, 550), + (2176781, 599), + (2177380, 552), + (2177932, 550), + (2178482, 598), + (2179080, 554), + (2179634, 550), + (2180184, 593), + (2180777, 553), + (2181330, 551), + (2181881, 605), + (2182486, 553), + (2183039, 550), + (2183589, 604), + (2184193, 553), + (2184746, 551), + (2185297, 571), + (2185868, 553), + (2186421, 551), + (2186972, 586), + (2187558, 553), + (2188111, 550), + (2188661, 588), + (2189249, 553), + (2189802, 550), + (2190352, 588), + (2190940, 553), + (2191493, 550), + (2192043, 601), + (2192644, 552), + (2193196, 549), + (2193745, 599), + (2194344, 552), + (2194896, 550), + (2195446, 594), + (2196040, 553), + (2196593, 551), + (2197144, 606), + (2197750, 552), + (2198302, 549), + (2198851, 607), + (2199458, 553), + (2200011, 550), + (2200561, 584), + (2201145, 553), + (2201698, 550), + (2202248, 599), + (2202847, 553), + (2203400, 549), + (2203949, 600), + (2204549, 553), + (2205102, 550), + (2205652, 599), + (2206251, 554), + (2206805, 551), + (2207356, 612), + (2207968, 553), + (2208521, 551), + (2209072, 611), + (2209683, 553), + (2210236, 550), + (2210786, 605), + (2211391, 553), + (2211944, 551), + (2212495, 619), + (2213114, 553), + (2213667, 549), + (2214216, 618), + (2214834, 553), + (2215387, 550), + (2215937, 585), + (2216522, 552), + (2217074, 550), + (2217624, 599), + (2218223, 552), + (2218775, 550), + (2219325, 598), + (2219923, 553), + (2220476, 549), + (2221025, 600), + (2221625, 552), + (2222177, 549), + (2222726, 612), + (2223338, 553), + (2223891, 551), + (2224442, 613), + (2225055, 553), + (2225608, 550), + (2226158, 607), + (2226765, 553), + (2227318, 550), + (2227868, 618), + (2228486, 553), + (2229039, 549), + (2229588, 617), + (2230205, 554), + (2230759, 550), + (2231309, 575), + (2231884, 553), + (2232437, 551), + (2232988, 588), + (2233576, 553), + (2234129, 549), + (2234678, 589), + (2235267, 552), + (2235819, 551), + (2236370, 591), + (2236961, 554), + (2237515, 549), + (2238064, 602), + (2238666, 553), + (2239219, 550), + (2239769, 602), + (2240371, 554), + (2240925, 550), + (2241475, 596), + (2242071, 553), + (2242624, 551), + (2243175, 608), + (2243783, 552), + (2244335, 550), + (2244885, 608), + (2245493, 554), + (2246047, 550), + (2246597, 587), + (2247184, 553), + (2247737, 550), + (2248287, 601), + (2248888, 553), + (2249441, 549), + (2249990, 602), + (2250592, 553), + (2251145, 550), + (2251695, 602), + (2252297, 553), + (2252850, 550), + (2253400, 615), + (2254015, 553), + (2254568, 551), + (2255119, 614), + (2255733, 553), + (2256286, 549), + (2256835, 609), + (2257444, 553), + (2257997, 550), + (2258547, 621), + (2259168, 553), + (2259721, 549), + (2260270, 619), + (2260889, 553), + (2261442, 550), + (2261992, 588), + (2262580, 553), + (2263133, 549), + (2263682, 600), + (2264282, 552), + (2264834, 550), + (2265384, 601), + (2265985, 552), + (2266537, 550), + (2267087, 601), + (2267688, 552), + (2268240, 550), + (2268790, 613), + (2269403, 554), + (2269957, 549), + (2270506, 614), + (2271120, 554), + (2271674, 550), + (2272224, 607), + (2272831, 552), + (2273383, 550), + (2273933, 621), + (2274554, 554), + (2275108, 549), + (2275657, 620), + (2276277, 554), + (2276831, 551), + (2277382, 543), + (2277925, 553), + (2278478, 550), + (2279028, 569), + (2279597, 554), + (2280151, 549), + (2280700, 569), + (2281269, 553), + (2281822, 550), + (2282372, 571), + (2282943, 554), + (2283497, 551), + (2284048, 585), + (2284633, 553), + (2285186, 549), + (2285735, 586), + (2286321, 553), + (2286874, 550), + (2287424, 580), + (2288004, 554), + (2288558, 551), + (2289109, 590), + (2289699, 552), + (2290251, 550), + (2290801, 590), + (2291391, 552), + (2291943, 551), + (2292494, 571), + (2293065, 554), + (2293619, 550), + (2294169, 585), + (2294754, 553), + (2295307, 550), + (2295857, 585), + (2296442, 553), + (2296995, 549), + (2297544, 588), + (2298132, 553), + (2298685, 550), + (2299235, 598), + (2299833, 554), + (2300387, 551), + (2300938, 599), + (2301537, 554), + (2302091, 550), + (2302641, 594), + (2303235, 554), + (2303789, 550), + (2304339, 604), + (2304943, 554), + (2305497, 551), + (2306048, 606), + (2306654, 553), + (2307207, 551), + (2307758, 571), + (2308329, 553), + (2308882, 549), + (2309431, 587), + (2310018, 553), + (2310571, 550), + (2311121, 586), + (2311707, 553), + (2312260, 550), + (2312810, 588), + (2313398, 553), + (2313951, 549), + (2314500, 600), + (2315100, 554), + (2315654, 550), + (2316204, 599), + (2316803, 554), + (2317357, 550), + (2317907, 593), + (2318500, 552), + (2319052, 550), + (2319602, 604), + (2320206, 554), + (2320760, 550), + (2321310, 604), + (2321914, 554), + (2322468, 549), + (2323017, 573), + (2323590, 554), + (2324144, 550), + (2324694, 588), + (2325282, 552), + (2325834, 550), + (2326384, 588), + (2326972, 553), + (2327525, 551), + (2328076, 588), + (2328664, 553), + (2329217, 550), + (2329767, 601), + (2330368, 553), + (2330921, 549), + (2331470, 601), + (2332071, 553), + (2332624, 551), + (2333175, 595), + (2333770, 552), + (2334322, 551), + (2334873, 605), + (2335478, 553), + (2336031, 550), + (2336581, 605), + (2337186, 552), + (2337738, 551), + (2338289, 585), + (2338874, 553), + (2339427, 551), + (2339978, 599), + (2340577, 552), + (2341129, 551), + (2341680, 599), + (2342279, 553), + (2342832, 550), + (2343382, 601), + (2343983, 553), + (2344536, 549), + (2345085, 613), + (2345698, 554), + (2346252, 551), + (2346803, 612), + (2347415, 553), + (2347968, 549), + (2348517, 606), + (2349123, 553), + (2349676, 551), + (2350227, 617), + (2350844, 554), + (2351398, 549), + (2351947, 617), + (2352564, 553), + (2353117, 550), + (2353667, 586), + (2354253, 553), + (2354806, 550), + (2355356, 600), + (2355956, 553), + (2356509, 549), + (2357058, 599), + (2357657, 554), + (2358211, 551), + (2358762, 600), + (2359362, 554), + (2359916, 551), + (2360467, 612), + (2361079, 553), + (2361632, 550), + (2362182, 612), + (2362794, 553), + (2363347, 550), + (2363897, 606), + (2364503, 553), + (2365056, 549), + (2365605, 617), + (2366222, 553), + (2366775, 549), + (2367324, 619), + (2367943, 553), + (2368496, 550), + (2369046, 575), + (2369621, 554), + (2370175, 551), + (2370726, 589), + (2371315, 553), + (2371868, 551), + (2372419, 590), + (2373009, 553), + (2373562, 551), + (2374113, 591), + (2374704, 553), + (2375257, 549), + (2375806, 602), + (2376408, 554), + (2376962, 551), + (2377513, 602), + (2378115, 553), + (2378668, 549), + (2379217, 597), + (2379814, 552), + (2380366, 551), + (2380917, 607), + (2381524, 553), + (2382077, 550), + (2382627, 609), + (2383236, 554), + (2383790, 550), + (2384340, 588), + (2384928, 553), + (2385481, 549), + (2386030, 602), + (2386632, 553), + (2387185, 550), + (2387735, 601), + (2388336, 553), + (2388889, 549), + (2389438, 603), + (2390041, 553), + (2390594, 549), + (2391143, 615), + (2391758, 553), + (2392311, 549), + (2392860, 612), + (2393472, 553), + (2394025, 549), + (2394574, 607), + (2395181, 553), + (2395734, 551), + (2396285, 619), + (2396904, 554), + (2397458, 549), + (2398007, 620), + (2398627, 553), + (2399180, 550), + (2399730, 588), + (2400318, 554), + (2400872, 551), + (2401423, 600), + (2402023, 553), + (2402576, 550), + (2403126, 601), + (2403727, 553), + (2404280, 549), + (2404829, 602), + (2405431, 552), + (2405983, 551), + (2406534, 613), + (2407147, 554), + (2407701, 550), + (2408251, 615), + (2408866, 554), + (2409420, 549), + (2409969, 607), + (2410576, 553), + (2411129, 550), + (2411679, 619), + (2412298, 553), + (2412851, 549), + (2413400, 620), + (2414020, 552), + (2414572, 559), + (2415131, 543), + (2415674, 552), + (2416226, 560), + (2416786, 569), + (2417355, 553), + (2417908, 559), + (2418467, 570), + (2419037, 553), + (2419590, 560), + (2420150, 573), + (2420723, 554), + (2421277, 559), + (2421836, 585), + (2422421, 553), + (2422974, 560), + (2423534, 586), + (2424120, 553), + (2424673, 561), + (2425234, 579), + (2425813, 552), + (2426365, 560), + (2426925, 591), + (2427516, 553), + (2428069, 561), + (2428630, 591), + (2429221, 552), + (2429773, 560), + (2430333, 570), + (2430903, 553), + (2431456, 561), + (2432017, 585), + (2432602, 553), + (2433155, 561), + (2433716, 586), + (2434302, 553), + (2434855, 559), + (2435414, 587), + (2436001, 552), + (2436553, 559), + (2437112, 599), + (2437711, 553), + (2438264, 560), + (2438824, 599), + (2439423, 554), + (2439977, 560), + (2440537, 593), + (2441130, 553), + (2441683, 560), + (2442243, 605), + (2442848, 552), + (2443400, 560), + (2443960, 603), + (2444563, 554), + (2445117, 559), + (2445676, 570), + (2446246, 554), + (2446800, 560), + (2447360, 585), + (2447945, 552), + (2448497, 561), + (2449058, 586), + (2449644, 553), + (2450197, 559), + (2450756, 586), + (2451342, 553), + (2451895, 559), + (2452454, 599), + (2453053, 553), + (2453606, 561), + (2454167, 599), + (2454766, 553), + (2455319, 560), + (2455879, 593), + (2456472, 553), + (2457025, 560), + (2457585, 604), + (2458189, 552), + (2458741, 560), + (2459301, 605), + (2459906, 553), + (2460459, 560), + (2461019, 573), + (2461592, 553), + (2462145, 560), + (2462705, 586), + (2463291, 552), + (2463843, 560), + (2464403, 587), + (2464990, 553), + (2465543, 559), + (2466102, 588), + (2466690, 553), + (2467243, 559), + (2467802, 600), + (2468402, 554), + (2468956, 559), + (2469515, 601), + (2470116, 554), + (2470670, 561), + (2471231, 593), + (2471824, 553), + (2472377, 561), + (2472938, 605), + (2473543, 552), + (2474095, 560), + (2474655, 606), + (2475261, 554), + (2475815, 559), + (2476374, 585), + (2476959, 553), + (2477512, 561), + (2478073, 598), + (2478671, 553), + (2479224, 559), + (2479783, 599), + (2480382, 554), + (2480936, 559), + (2481495, 600), + (2482095, 554), + (2482649, 561), + (2483210, 611), + (2483821, 553), + (2484374, 559), + (2484933, 612), + (2485545, 554), + (2486099, 561), + (2486660, 607), + (2487267, 553), + (2487820, 559), + (2488379, 618), + (2488997, 552), + (2489549, 561), + (2490110, 619), + (2490729, 554), + (2491283, 559), + (2491842, 585), + (2492427, 553), + (2492980, 559), + (2493539, 600), + (2494139, 553), + (2494692, 560), + (2495252, 600), + (2495852, 554), + (2496406, 561), + (2496967, 599), + (2497566, 554), + (2498120, 559), + (2498679, 613), + (2499292, 553), + (2499845, 561), + (2500406, 612), + (2501018, 554), + (2501572, 559), + (2502131, 606), + (2502737, 553), + (2503290, 559), + (2503849, 619), + (2504468, 552), + (2505020, 560), + (2505580, 617), + (2506197, 553), + (2506750, 560), + (2507310, 575), + (2507885, 552), + (2508437, 560), + (2508997, 588), + (2509585, 552), + (2510137, 560), + (2510697, 588), + (2511285, 552), + (2511837, 559), + (2512396, 590), + (2512986, 552), + (2513538, 559), + (2514097, 602), + (2514699, 552), + (2515251, 560), + (2515811, 602), + (2516413, 553), + (2516966, 559), + (2517525, 595), + (2518120, 553), + (2518673, 561), + (2519234, 608), + (2519842, 552), + (2520394, 561), + (2520955, 608), + (2521563, 554), + (2522117, 560), + (2522677, 587), + (2523264, 553), + (2523817, 560), + (2524377, 601), + (2524978, 554), + (2525532, 561), + (2526093, 601), + (2526694, 553), + (2527247, 561), + (2527808, 602), + (2528410, 554), + (2528964, 561), + (2529525, 613), + (2530138, 553), + (2530691, 561), + (2531252, 614), + (2531866, 553), + (2532419, 559), + (2532978, 608), + (2533586, 553), + (2534139, 560), + (2534699, 620), + (2535319, 553), + (2535872, 560), + (2536432, 621), + (2537053, 554), + (2537607, 559), + (2538166, 586), + (2538752, 553), + (2539305, 559), + (2539864, 602), + (2540466, 552), + (2541018, 559), + (2541577, 601), + (2542178, 554), + (2542732, 561), + (2543293, 602), + (2543895, 552), + (2544447, 560), + (2545007, 614), + (2545621, 553), + (2546174, 561), + (2546735, 613), + (2547348, 553), + (2547901, 560), + (2548461, 609), + (2549070, 554), + (2549624, 560), + (2550184, 620), + (2550804, 553), + (2551357, 561), + (2551918, 620), + (2552538, 554), + (2553092, 565), + (2553657, 542), + (2554199, 554), + (2554753, 565), + (2555318, 570), + (2555888, 552), + (2556440, 566), + (2557006, 570), + (2557576, 553), + (2558129, 567), + (2558696, 573), + (2559269, 553), + (2559822, 566), + (2560388, 584), + (2560972, 554), + (2561526, 567), + (2562093, 585), + (2562678, 554), + (2563232, 565), + (2563797, 579), + (2564376, 553), + (2564929, 567), + (2565496, 591), + (2566087, 552), + (2566639, 566), + (2567205, 591), + (2567796, 554), + (2568350, 566), + (2568916, 570), + (2569486, 552), + (2570038, 565), + (2570603, 585), + (2571188, 553), + (2571741, 566), + (2572307, 586), + (2572893, 552), + (2573445, 566), + (2574011, 588), + (2574599, 552), + (2575151, 565), + (2575716, 600), + (2576316, 554), + (2576870, 565), + (2577435, 600), + (2578035, 552), + (2578587, 565), + (2579152, 592), + (2579744, 553), + (2580297, 565), + (2580862, 605), + (2581467, 553), + (2582020, 566), + (2582586, 605), + (2583191, 552), + (2583743, 566), + (2584309, 571), + (2584880, 554), + (2585434, 567), + (2586001, 587), + (2586588, 553), + (2587141, 567), + (2587708, 587), + (2588295, 554), + (2588849, 565), + (2589414, 586), + (2590000, 552), + (2590552, 567), + (2591119, 599), + (2591718, 552), + (2592270, 567), + (2592837, 598), + (2593435, 553), + (2593988, 566), + (2594554, 594), + (2595148, 553), + (2595701, 566), + (2596267, 605), + (2596872, 553), + (2597425, 565), + (2597990, 605), + (2598595, 553), + (2599148, 567), + (2599715, 572), + (2600287, 553), + (2600840, 565), + (2601405, 587), + (2601992, 553), + (2602545, 566), + (2603111, 587), + (2603698, 553), + (2604251, 566), + (2604817, 589), + (2605406, 553), + (2605959, 566), + (2606525, 599), + (2607124, 553), + (2607677, 566), + (2608243, 600), + (2608843, 553), + (2609396, 565), + (2609961, 594), + (2610555, 554), + (2611109, 565), + (2611674, 606), + (2612280, 554), + (2612834, 565), + (2613399, 607), + (2614006, 553), + (2614559, 566), + (2615125, 584), + (2615709, 554), + (2616263, 565), + (2616828, 599), + (2617427, 554), + (2617981, 566), + (2618547, 600), + (2619147, 553), + (2619700, 566), + (2620266, 600), + (2620866, 553), + (2621419, 566), + (2621985, 612), + (2622597, 553), + (2623150, 566), + (2623716, 612), + (2624328, 552), + (2624880, 565), + (2625445, 605), + (2626050, 554), + (2626604, 567), + (2627171, 618), + (2627789, 554), + (2628343, 566), + (2628909, 619), + (2629528, 554), + (2630082, 567), + (2630649, 585), + (2631234, 554), + (2631788, 567), + (2632355, 598), + (2632953, 553), + (2633506, 566), + (2634072, 598), + (2634670, 553), + (2635223, 566), + (2635789, 600), + (2636389, 554), + (2636943, 566), + (2637509, 613), + (2638122, 554), + (2638676, 566), + (2639242, 612), + (2639854, 552), + (2640406, 566), + (2640972, 606), + (2641578, 554), + (2642132, 566), + (2642698, 617), + (2643315, 553), + (2643868, 566), + (2644434, 619), + (2645053, 552), + (2645605, 566), + (2646171, 575), + (2646746, 552), + (2647298, 567), + (2647865, 588), + (2648453, 554), + (2649007, 567), + (2649574, 589), + (2650163, 553), + (2650716, 566), + (2651282, 589), + (2651871, 552), + (2652423, 566), + (2652989, 603), + (2653592, 553), + (2654145, 565), + (2654710, 603), + (2655313, 552), + (2655865, 566), + (2656431, 597), + (2657028, 553), + (2657581, 566), + (2658147, 609), + (2658756, 553), + (2659309, 565), + (2659874, 608), + (2660482, 554), + (2661036, 566), + (2661602, 588), + (2662190, 552), + (2662742, 566), + (2663308, 602), + (2663910, 553), + (2664463, 566), + (2665029, 600), + (2665629, 553), + (2666182, 566), + (2666748, 602), + (2667350, 554), + (2667904, 565), + (2668469, 614), + (2669083, 553), + (2669636, 565), + (2670201, 614), + (2670815, 554), + (2671369, 566), + (2671935, 608), + (2672543, 554), + (2673097, 565), + (2673662, 621), + (2674283, 553), + (2674836, 566), + (2675402, 620), + (2676022, 552), + (2676574, 565), + (2677139, 588), + (2677727, 554), + (2678281, 565), + (2678846, 601), + (2679447, 553), + (2680000, 566), + (2680566, 601), + (2681167, 553), + (2681720, 565), + (2682285, 601), + (2682886, 553), + (2683439, 566), + (2684005, 614), + (2684619, 554), + (2685173, 567), + (2685740, 613), + (2686353, 552), + (2686905, 567), + (2687472, 608), + (2688080, 552), + (2688632, 566), + (2689198, 619), + (2689817, 552), + (2690369, 566), + (2690935, 620), + (2691555, 553), + (2692108, 567), + (2692675, 541), + (2693216, 554), + (2693770, 566), + (2694336, 569), + (2694905, 553), + (2695458, 567), + (2696025, 571), + (2696596, 554), + (2697150, 566), + (2697716, 571), + (2698287, 553), + (2698840, 565), + (2699405, 584), + (2699989, 552), + (2700541, 566), + (2701107, 586), + (2701693, 553), + (2702246, 565), + (2702811, 579), + (2703390, 554), + (2703944, 566), + (2704510, 591), + (2705101, 554), + (2705655, 566), + (2706221, 591), + (2706812, 553), + (2707365, 566), + (2707931, 569), + (2708500, 554), + (2709054, 566), + (2709620, 585), + (2710205, 552), + (2710757, 566), + (2711323, 585), + (2711908, 554), + (2712462, 566), + (2713028, 587), + (2713615, 553), + (2714168, 566), + (2714734, 598), + (2715332, 553), + (2715885, 566), + (2716451, 599), + (2717050, 552), + (2717602, 567), + (2718169, 593), + (2718762, 553), + (2719315, 567), + (2719882, 605), + (2720487, 552), + (2721039, 567), + (2721606, 604), + (2722210, 552), + (2722762, 566), + (2723328, 570), + (2723898, 552), + (2724450, 565), + (2725015, 586), + (2725601, 553), + (2726154, 566), + (2726720, 585), + (2727305, 554), + (2727859, 565), + (2728424, 588), + (2729012, 553), + (2729565, 565), + (2730130, 598), + (2730728, 552), + (2731280, 565), + (2731845, 600), + (2732445, 553), + (2732998, 567), + (2733565, 593), + (2734158, 553), + (2734711, 565), + (2735276, 605), + (2735881, 552), + (2736433, 565), + (2736998, 604), + (2737602, 552), + (2738154, 566), + (2738720, 571), + (2739291, 553), + (2739844, 566), + (2740410, 586), + (2740996, 554), + (2741550, 566), + (2742116, 588), + (2742704, 553), + (2743257, 567), + (2743824, 588), + (2744412, 554), + (2744966, 567), + (2745533, 601), + (2746134, 552), + (2746686, 565), + (2747251, 601), + (2747852, 552), + (2748404, 567), + (2748971, 594), + (2749565, 553), + (2750118, 567), + (2750685, 605), + (2751290, 554), + (2751844, 566), + (2752410, 605), + (2753015, 552), + (2753567, 567), + (2754134, 585), + (2754719, 553), + (2755272, 567), + (2755839, 598), + (2756437, 554), + (2756991, 566), + (2757557, 598), + (2758155, 554), + (2758709, 565), + (2759274, 600), + (2759874, 552), + (2760426, 566), + (2760992, 613), + (2761605, 554), + (2762159, 566), + (2762725, 612), + (2763337, 554), + (2763891, 567), + (2764458, 607), + (2765065, 553), + (2765618, 565), + (2766183, 618), + (2766801, 554), + (2767355, 567), + (2767922, 618), + (2768540, 553), + (2769093, 565), + (2769658, 586), + (2770244, 553), + (2770797, 565), + (2771362, 599), + (2771961, 552), + (2772513, 566), + (2773079, 598), + (2773677, 553), + (2774230, 567), + (2774797, 599), + (2775396, 553), + (2775949, 567), + (2776516, 613), + (2777129, 553), + (2777682, 566), + (2778248, 612), + (2778860, 552), + (2779412, 566), + (2779978, 607), + (2780585, 552), + (2781137, 565), + (2781702, 617), + (2782319, 552), + (2782871, 567), + (2783438, 618), + (2784056, 553), + (2784609, 565), + (2785174, 575), + (2785749, 553), + (2786302, 567), + (2786869, 590), + (2787459, 552), + (2788011, 565), + (2788576, 588), + (2789164, 553), + (2789717, 566), + (2790283, 590), + (2790873, 553), + (2791426, 566), + (2791992, 603), + (2792595, 554), + (2793149, 565), + (2793714, 603), + (2794317, 553), + (2794870, 567), + (2795437, 596), + (2796033, 553), + (2796586, 566), + (2797152, 608), + (2797760, 552), + (2798312, 566), + (2798878, 607), + (2799485, 554), + (2800039, 566), + (2800605, 588), + (2801193, 554), + (2801747, 567), + (2802314, 601), + (2802915, 553), + (2803468, 566), + (2804034, 600), + (2804634, 553), + (2805187, 565), + (2805752, 602), + (2806354, 553), + (2806907, 566), + (2807473, 614), + (2808087, 553), + (2808640, 567), + (2809207, 614), + (2809821, 554), + (2810375, 565), + (2810940, 609), + (2811549, 552), + (2812101, 567), + (2812668, 621), + (2813289, 552), + (2813841, 565), + (2814406, 619), + (2815025, 552), + (2815577, 566), + (2816143, 587), + (2816730, 553), + (2817283, 567), + (2817850, 601), + (2818451, 554), + (2819005, 565), + (2819570, 602), + (2820172, 553), + (2820725, 567), + (2821292, 601), + (2821893, 553), + (2822446, 565), + (2823011, 614), + (2823625, 554), + (2824179, 566), + (2824745, 614), + (2825359, 554), + (2825913, 567), + (2826480, 608), + (2827088, 554), + (2827642, 567), + (2828209, 620), + (2828829, 553), + (2829382, 566), + (2829948, 621), + (2830569, 554), + (2831123, 560), + (2831683, 541), + (2832224, 553), + (2832777, 561), + (2833338, 569), + (2833907, 554), + (2834461, 561), + (2835022, 571), + (2835593, 553), + (2836146, 562), + (2836708, 572), + (2837280, 553), + (2837833, 562), + (2838395, 585), + (2838980, 553), + (2839533, 561), + (2840094, 585), + (2840679, 552), + (2841231, 561), + (2841792, 579), + (2842371, 553), + (2842924, 561), + (2843485, 590), + (2844075, 554), + (2844629, 561), + (2845190, 591), + (2845781, 552), + (2846333, 560), + (2846893, 570), + (2847463, 553), + (2848016, 560), + (2848576, 585), + (2849161, 552), + (2849713, 561), + (2850274, 586), + (2850860, 554), + (2851414, 562), + (2851976, 587), + (2852563, 554), + (2853117, 562), + (2853679, 599), + (2854278, 552), + (2854830, 560), + (2855390, 600), + (2855990, 553), + (2856543, 560), + (2857103, 593), + (2857696, 554), + (2858250, 561), + (2858811, 605), + (2859416, 552), + (2859968, 562), + (2860530, 605), + (2861135, 554), + (2861689, 562), + (2862251, 569), + (2862820, 554), + (2863374, 560), + (2863934, 586), + (2864520, 553), + (2865073, 561), + (2865634, 586), + (2866220, 553), + (2866773, 561), + (2867334, 586), + (2867920, 553), + (2868473, 560), + (2869033, 599), + (2869632, 554), + (2870186, 560), + (2870746, 600), + (2871346, 554), + (2871900, 561), + (2872461, 593), + (2873054, 553), + (2873607, 561), + (2874168, 604), + (2874772, 553), + (2875325, 561), + (2875886, 604), + (2876490, 553), + (2877043, 561), + (2877604, 573), + (2878177, 553), + (2878730, 562), + (2879292, 587), + (2879879, 553), + (2880432, 561), + (2880993, 587), + (2881580, 552), + (2882132, 561), + (2882693, 587), + (2883280, 553), + (2883833, 560), + (2884393, 600), + (2884993, 553), + (2885546, 561), + (2886107, 600), + (2886707, 552), + (2887259, 561), + (2887820, 594), + (2888414, 553), + (2888967, 562), + (2889529, 607), + (2890136, 554), + (2890690, 560), + (2891250, 605), + (2891855, 553), + (2892408, 560), + (2892968, 584), + (2893552, 554), + (2894106, 561), + (2894667, 599), + (2895266, 553), + (2895819, 560), + (2896379, 600), + (2896979, 553), + (2897532, 561), + (2898093, 599), + (2898692, 553), + (2899245, 560), + (2899805, 611), + (2900416, 552), + (2900968, 561), + (2901529, 612), + (2902141, 553), + (2902694, 561), + (2903255, 606), + (2903861, 552), + (2904413, 562), + (2904975, 619), + (2905594, 553), + (2906147, 561), + (2906708, 618), + (2907326, 554), + (2907880, 560), + (2908440, 584), + (2909024, 553), + (2909577, 562), + (2910139, 600), + (2910739, 553), + (2911292, 561), + (2911853, 599), + (2912452, 554), + (2913006, 560), + (2913566, 599), + (2914165, 553), + (2914718, 560), + (2915278, 613), + (2915891, 554), + (2916445, 560), + (2917005, 612), + (2917617, 552), + (2918169, 562), + (2918731, 606), + (2919337, 552), + (2919889, 561), + (2920450, 618), + (2921068, 552), + (2921620, 561), + (2922181, 617), + (2922798, 553), + (2923351, 560), + (2923911, 574), + (2924485, 552), + (2925037, 560), + (2925597, 590), + (2926187, 552), + (2926739, 561), + (2927300, 590), + (2927890, 553), + (2928443, 561), + (2929004, 591), + (2929595, 552), + (2930147, 561), + (2930708, 601), + (2931309, 553), + (2931862, 561), + (2932423, 603), + (2933026, 553), + (2933579, 562), + (2934141, 597), + (2934738, 552), + (2935290, 561), + (2935851, 608), + (2936459, 552), + (2937011, 561), + (2937572, 609), + (2938181, 554), + (2938735, 561), + (2939296, 587), + (2939883, 552), + (2940435, 562), + (2940997, 601), + (2941598, 553), + (2942151, 562), + (2942713, 601), + (2943314, 552), + (2943866, 560), + (2944426, 603), + (2945029, 554), + (2945583, 560), + (2946143, 613), + (2946756, 553), + (2947309, 560), + (2947869, 614), + (2948483, 553), + (2949036, 561), + (2949597, 609), + (2950206, 553), + (2950759, 560), + (2951319, 619), + (2951938, 554), + (2952492, 561), + (2953053, 620), + (2953673, 554), + (2954227, 560), + (2954787, 587), + (2955374, 553), + (2955927, 561), + (2956488, 602), + (2957090, 554), + (2957644, 561), + (2958205, 601), + (2958806, 554), + (2959360, 560), + (2959920, 601), + (2960521, 553), + (2961074, 561), + (2961635, 614), + (2962249, 554), + (2962803, 561), + (2963364, 614), + (2963978, 553), + (2964531, 561), + (2965092, 609), + (2965701, 553), + (2966254, 561), + (2966815, 621), + (2967436, 554), + (2967990, 561), + (2968551, 620), + (2969171, 553), + (2969724, 568), + (2970292, 542), + (2970834, 553), + (2971387, 568), + (2971955, 570), + (2972525, 552), + (2973077, 566), + (2973643, 569), + (2974212, 552), + (2974764, 567), + (2975331, 572), + (2975903, 554), + (2976457, 566), + (2977023, 585), + (2977608, 553), + (2978161, 566), + (2978727, 584), + (2979311, 553), + (2979864, 567), + (2980431, 579), + (2981010, 553), + (2981563, 567), + (2982130, 591), + (2982721, 553), + (2983274, 567), + (2983841, 591), + (2984432, 553), + (2984985, 567), + (2985552, 569), + (2986121, 553), + (2986674, 567), + (2987241, 586), + (2987827, 552), + (2988379, 567), + (2988946, 586), + (2989532, 552), + (2990084, 567), + (2990651, 588), + (2991239, 553), + (2991792, 567), + (2992359, 599), + (2992958, 553), + (2993511, 566), + (2994077, 599), + (2994676, 554), + (2995230, 566), + (2995796, 593), + (2996389, 553), + (2996942, 567), + (2997509, 606), + (2998115, 553), + (2998668, 568), + (2999236, 604), + (2999840, 552), + (3000392, 566), + (3000958, 569), + (3001527, 552), + (3002079, 568), + (3002647, 586), + (3003233, 554), + (3003787, 567), + (3004354, 586), + (3004940, 554), + (3005494, 567), + (3006061, 586), + (3006647, 553), + (3007200, 567), + (3007767, 600), + (3008367, 554), + (3008921, 566), + (3009487, 599), + (3010086, 554), + (3010640, 568), + (3011208, 593), + (3011801, 554), + (3012355, 568), + (3012923, 605), + (3013528, 553), + (3014081, 568), + (3014649, 605), + (3015254, 554), + (3015808, 566), + (3016374, 571), + (3016945, 553), + (3017498, 567), + (3018065, 588), + (3018653, 552), + (3019205, 568), + (3019773, 588), + (3020361, 554), + (3020915, 567), + (3021482, 587), + (3022069, 553), + (3022622, 566), + (3023188, 601), + (3023789, 553), + (3024342, 568), + (3024910, 600), + (3025510, 554), + (3026064, 567), + (3026631, 595), + (3027226, 553), + (3027779, 567), + (3028346, 605), + (3028951, 554), + (3029505, 567), + (3030072, 605), + (3030677, 553), + (3031230, 566), + (3031796, 586), + (3032382, 554), + (3032936, 566), + (3033502, 600), + (3034102, 553), + (3034655, 568), + (3035223, 598), + (3035821, 552), + (3036373, 567), + (3036940, 601), + (3037541, 553), + (3038094, 567), + (3038661, 613), + (3039274, 553), + (3039827, 566), + (3040393, 612), + (3041005, 553), + (3041558, 566), + (3042124, 606), + (3042730, 552), + (3043282, 568), + (3043850, 617), + (3044467, 552), + (3045019, 566), + (3045585, 617), + (3046202, 553), + (3046755, 566), + (3047321, 584), + (3047905, 553), + (3048458, 567), + (3049025, 599), + (3049624, 553), + (3050177, 568), + (3050745, 599), + (3051344, 552), + (3051896, 567), + (3052463, 601), + (3053064, 553), + (3053617, 567), + (3054184, 612), + (3054796, 553), + (3055349, 566), + (3055915, 611), + (3056526, 552), + (3057078, 567), + (3057645, 606), + (3058251, 553), + (3058804, 568), + (3059372, 618), + (3059990, 552), + (3060542, 568), + (3061110, 619), + (3061729, 553), + (3062282, 566), + (3062848, 575), + (3063423, 553), + (3063976, 566), + (3064542, 589), + (3065131, 553), + (3065684, 568), + (3066252, 588), + (3066840, 553), + (3067393, 567), + (3067960, 589), + (3068549, 552), + (3069101, 566), + (3069667, 602), + (3070269, 553), + (3070822, 568), + (3071390, 602), + (3071992, 554), + (3072546, 566), + (3073112, 596), + (3073708, 553), + (3074261, 568), + (3074829, 607), + (3075436, 553), + (3075989, 567), + (3076556, 608), + (3077164, 553), + (3077717, 567), + (3078284, 587), + (3078871, 553), + (3079424, 568), + (3079992, 601), + (3080593, 552), + (3081145, 568), + (3081713, 601), + (3082314, 553), + (3082867, 568), + (3083435, 602), + (3084037, 553), + (3084590, 568), + (3085158, 614), + (3085772, 553), + (3086325, 566), + (3086891, 614), + (3087505, 553), + (3088058, 566), + (3088624, 607), + (3089231, 553), + (3089784, 566), + (3090350, 620), + (3090970, 554), + (3091524, 567), + (3092091, 620), + (3092711, 552), + (3093263, 567), + (3093830, 587), + (3094417, 552), + (3094969, 566), + (3095535, 602), + (3096137, 553), + (3096690, 566), + (3097256, 601), + (3097857, 553), + (3098410, 567), + (3098977, 603), + (3099580, 554), + (3100134, 566), + (3100700, 613), + (3101313, 554), + (3101867, 567), + (3102434, 615), + (3103049, 554), + (3103603, 567), + (3104170, 607), + (3104777, 553), + (3105330, 567), + (3105897, 619), + (3106516, 554), + (3107070, 566), + (3107636, 620), + (3108256, 552), + (3108808, 566), + (3109374, 543), + (3109917, 553), + (3110470, 568), + (3111038, 570), + (3111608, 552), + (3112160, 566), + (3112726, 570), + (3113296, 554), + (3113850, 567), + (3114417, 572), + (3114989, 553), + (3115542, 567), + (3116109, 586), + (3116695, 553), + (3117248, 566), + (3117814, 584), + (3118398, 553), + (3118951, 568), + (3119519, 579), + (3120098, 553), + (3120651, 568), + (3121219, 592), + (3121811, 552), + (3122363, 567), + (3122930, 591), + (3123521, 553), + (3124074, 567), + (3124641, 569), + (3125210, 554), + (3125764, 568), + (3126332, 585), + (3126917, 552), + (3127469, 567), + (3128036, 587), + (3128623, 552), + (3129175, 567), + (3129742, 586), + (3130328, 553), + (3130881, 567), + (3131448, 599), + (3132047, 554), + (3132601, 568), + (3133169, 600), + (3133769, 553), + (3134322, 567), + (3134889, 594), + (3135483, 553), + (3136036, 568), + (3136604, 606), + (3137210, 554), + (3137764, 567), + (3138331, 606), + (3138937, 553), + (3139490, 566), + (3140056, 569), + (3140625, 553), + (3141178, 566), + (3141744, 585), + (3142329, 553), + (3142882, 566), + (3143448, 586), + (3144034, 554), + (3144588, 568), + (3145156, 588), + (3145744, 554), + (3146298, 566), + (3146864, 600), + (3147464, 553), + (3148017, 568), + (3148585, 600), + (3149185, 553), + (3149738, 567), + (3150305, 593), + (3150898, 554), + (3151452, 567), + (3152019, 605), + (3152624, 553), + (3153177, 567), + (3153744, 605), + (3154349, 552), + (3154901, 566), + (3155467, 572), + (3156039, 553), + (3156592, 567), + (3157159, 587), + (3157746, 553), + (3158299, 567), + (3158866, 586), + (3159452, 552), + (3160004, 567), + (3160571, 588), + (3161159, 553), + (3161712, 568), + (3162280, 600), + (3162880, 553), + (3163433, 567), + (3164000, 599), + (3164599, 553), + (3165152, 567), + (3165719, 594), + (3166313, 553), + (3166866, 566), + (3167432, 605), + (3168037, 552), + (3168589, 568), + (3169157, 606), + (3169763, 553), + (3170316, 568), + (3170884, 585), + (3171469, 554), + (3172023, 567), + (3172590, 599), + (3173189, 552), + (3173741, 568), + (3174309, 599), + (3174908, 553), + (3175461, 568), + (3176029, 601), + (3176630, 553), + (3177183, 567), + (3177750, 612), + (3178362, 552), + (3178914, 566), + (3179480, 612), + (3180092, 553), + (3180645, 568), + (3181213, 606), + (3181819, 553), + (3182372, 567), + (3182939, 617), + (3183556, 553), + (3184109, 567), + (3184676, 618), + (3185294, 553), + (3185847, 566), + (3186413, 585), + (3186998, 553), + (3187551, 567), + (3188118, 600), + (3188718, 552), + (3189270, 568), + (3189838, 600), + (3190438, 554), + (3190992, 567), + (3191559, 600), + (3192159, 552), + (3192711, 566), + (3193277, 613), + (3193890, 552), + (3194442, 566), + (3195008, 613), + (3195621, 552), + (3196173, 568), + (3196741, 605), + (3197346, 552), + (3197898, 567), + (3198465, 617), + (3199082, 553), + (3199635, 567), + (3200202, 619), + (3200821, 554), + (3201375, 567), + (3201942, 576), + (3202518, 552), + (3203070, 567), + (3203637, 589), + (3204226, 553), + (3204779, 567), + (3205346, 590), + (3205936, 553), + (3206489, 566), + (3207055, 590), + (3207645, 552), + (3208197, 567), + (3208764, 603), + (3209367, 554), + (3209921, 568), + (3210489, 603), + (3211092, 553), + (3211645, 566), + (3212211, 596), + (3212807, 553), + (3213360, 566), + (3213926, 607), + (3214533, 553), + (3215086, 567), + (3215653, 607), + (3216260, 553), + (3216813, 566), + (3217379, 587), + (3217966, 553), + (3218519, 568), + (3219087, 600), + (3219687, 554), + (3220241, 567), + (3220808, 600), + (3221408, 553), + (3221961, 567), + (3222528, 603), + (3223131, 553), + (3223684, 566), + (3224250, 614), + (3224864, 554), + (3225418, 568), + (3225986, 615), + (3226601, 553), + (3227154, 567), + (3227721, 608), + (3228329, 553), + (3228882, 568), + (3229450, 621), + (3230071, 554), + (3230625, 568), + (3231193, 620), + (3231813, 552), + (3232365, 566), + (3232931, 588), + (3233519, 554), + (3234073, 567), + (3234640, 600), + (3235240, 553), + (3235793, 566), + (3236359, 601), + (3236960, 553), + (3237513, 567), + (3238080, 601), + (3238681, 552), + (3239233, 567), + (3239800, 614), + (3240414, 553), + (3240967, 567), + (3241534, 613), + (3242147, 552), + (3242699, 567), + (3243266, 609), + (3243875, 553), + (3244428, 568), + (3244996, 619), + (3245615, 554), + (3246169, 567), + (3246736, 621), + (3247357, 554), + (3247911, 534), + (3248445, 542), + (3248987, 552), + (3249539, 534), + (3250073, 570), + (3250643, 553), + (3251196, 534), + (3251730, 571), + (3252301, 553), + (3252854, 533), + (3253387, 572), + (3253959, 554), + (3254513, 533), + (3255046, 584), + (3255630, 553), + (3256183, 534), + (3256717, 585), + (3257302, 553), + (3257855, 533), + (3258388, 578), + (3258966, 553), + (3259519, 534), + (3260053, 590), + (3260643, 552), + (3261195, 535), + (3261730, 591), + (3262321, 552), + (3262873, 534), + (3263407, 570), + (3263977, 552), + (3264529, 535), + (3265064, 586), + (3265650, 553), + (3266203, 533), + (3266736, 586), + (3267322, 553), + (3267875, 535), + (3268410, 588), + (3268998, 552), + (3269550, 535), + (3270085, 599), + (3270684, 553), + (3271237, 534), + (3271771, 600), + (3272371, 553), + (3272924, 535), + (3273459, 593), + (3274052, 553), + (3274605, 533), + (3275138, 606), + (3275744, 553), + (3276297, 534), + (3276831, 605), + (3277436, 552), + (3277988, 534), + (3278522, 570), + (3279092, 554), + (3279646, 534), + (3280180, 586), + (3280766, 553), + (3281319, 534), + (3281853, 586), + (3282439, 553), + (3282992, 534), + (3283526, 588), + (3284114, 553), + (3284667, 534), + (3285201, 599), + (3285800, 552), + (3286352, 534), + (3286886, 600), + (3287486, 553), + (3288039, 534), + (3288573, 593), + (3289166, 552), + (3289718, 534), + (3290252, 606), + (3290858, 552), + (3291410, 534), + (3291944, 605), + (3292549, 553), + (3293102, 533), + (3293635, 572), + (3294207, 554), + (3294761, 534), + (3295295, 588), + (3295883, 553), + (3296436, 533), + (3296969, 587), + (3297556, 552), + (3298108, 535), + (3298643, 588), + (3299231, 553), + (3299784, 534), + (3300318, 599), + (3300917, 554), + (3301471, 535), + (3302006, 600), + (3302606, 552), + (3303158, 535), + (3303693, 593), + (3304286, 552), + (3304838, 534), + (3305372, 607), + (3305979, 552), + (3306531, 533), + (3307064, 607), + (3307671, 553), + (3308224, 535), + (3308759, 584), + (3309343, 553), + (3309896, 535), + (3310431, 598), + (3311029, 552), + (3311581, 534), + (3312115, 600), + (3312715, 554), + (3313269, 534), + (3313803, 600), + (3314403, 553), + (3314956, 534), + (3315490, 612), + (3316102, 554), + (3316656, 534), + (3317190, 613), + (3317803, 554), + (3318357, 533), + (3318890, 606), + (3319496, 553), + (3320049, 533), + (3320582, 617), + (3321199, 553), + (3321752, 535), + (3322287, 617), + (3322904, 553), + (3323457, 533), + (3323990, 585), + (3324575, 553), + (3325128, 534), + (3325662, 598), + (3326260, 553), + (3326813, 535), + (3327348, 599), + (3327947, 552), + (3328499, 535), + (3329034, 601), + (3329635, 553), + (3330188, 533), + (3330721, 611), + (3331332, 552), + (3331884, 533), + (3332417, 613), + (3333030, 553), + (3333583, 533), + (3334116, 606), + (3334722, 554), + (3335276, 533), + (3335809, 619), + (3336428, 554), + (3336982, 533), + (3337515, 617), + (3338132, 554), + (3338686, 535), + (3339221, 574), + (3339795, 553), + (3340348, 533), + (3340881, 589), + (3341470, 553), + (3342023, 533), + (3342556, 588), + (3343144, 554), + (3343698, 534), + (3344232, 589), + (3344821, 553), + (3345374, 535), + (3345909, 602), + (3346511, 552), + (3347063, 535), + (3347598, 603), + (3348201, 553), + (3348754, 534), + (3349288, 596), + (3349884, 553), + (3350437, 535), + (3350972, 608), + (3351580, 553), + (3352133, 534), + (3352667, 607), + (3353274, 554), + (3353828, 534), + (3354362, 588), + (3354950, 553), + (3355503, 533), + (3356036, 602), + (3356638, 553), + (3357191, 533), + (3357724, 600), + (3358324, 552), + (3358876, 534), + (3359410, 602), + (3360012, 554), + (3360566, 533), + (3361099, 615), + (3361714, 554), + (3362268, 534), + (3362802, 614), + (3363416, 553), + (3363969, 534), + (3364503, 608), + (3365111, 554), + (3365665, 534), + (3366199, 619), + (3366818, 553), + (3367371, 534), + (3367905, 620), + (3368525, 552), + (3369077, 535), + (3369612, 587), + (3370199, 552), + (3370751, 533), + (3371284, 601), + (3371885, 552), + (3372437, 533), + (3372970, 601), + (3373571, 552), + (3374123, 533), + (3374656, 601), + (3375257, 554), + (3375811, 535), + (3376346, 613), + (3376959, 553), + (3377512, 534), + (3378046, 614), + (3378660, 553), + (3379213, 533), + (3379746, 608), + (3380354, 553), + (3380907, 534), + (3381441, 620), + (3382061, 553), + (3382614, 534), + (3383148, 619), + (3383767, 554), + (3384321, 551), + (3384872, 542), + (3385414, 553), + (3385967, 552), + (3386519, 569), + (3387088, 552), + (3387640, 550), + (3388190, 570), + (3388760, 554), + (3389314, 551), + (3389865, 572), + (3390437, 554), + (3390991, 551), + (3391542, 586), + (3392128, 552), + (3392680, 551), + (3393231, 585), + (3393816, 553), + (3394369, 552), + (3394921, 579), + (3395500, 553), + (3396053, 552), + (3396605, 591), + (3397196, 553), + (3397749, 551), + (3398300, 591), + (3398891, 554), + (3399445, 551), + (3399996, 570), + (3400566, 552), + (3401118, 550), + (3401668, 587), + (3402255, 553), + (3402808, 551), + (3403359, 586), + (3403945, 553), + (3404498, 550), + (3405048, 588), + (3405636, 552), + (3406188, 551), + (3406739, 598), + (3407337, 552), + (3407889, 551), + (3408440, 598), + (3409038, 553), + (3409591, 550), + (3410141, 593), + (3410734, 553), + (3411287, 552), + (3411839, 605), + (3412444, 552), + (3412996, 550), + (3413546, 604), + (3414150, 554), + (3414704, 551), + (3415255, 570), + (3415825, 552), + (3416377, 551), + (3416928, 587), + (3417515, 553), + (3418068, 551), + (3418619, 586), + (3419205, 554), + (3419759, 551), + (3420310, 587), + (3420897, 553), + (3421450, 550), + (3422000, 599), + (3422599, 553), + (3423152, 551), + (3423703, 598), + (3424301, 553), + (3424854, 551), + (3425405, 593), + (3425998, 554), + (3426552, 551), + (3427103, 606), + (3427709, 553), + (3428262, 551), + (3428813, 605), + (3429418, 553), + (3429971, 550), + (3430521, 573), + (3431094, 553), + (3431647, 551), + (3432198, 588), + (3432786, 553), + (3433339, 550), + (3433889, 588), + (3434477, 553), + (3435030, 550), + (3435580, 587), + (3436167, 553), + (3436720, 551), + (3437271, 601), + (3437872, 553), + (3438425, 551), + (3438976, 600), + (3439576, 553), + (3440129, 552), + (3440681, 594), + (3441275, 552), + (3441827, 551), + (3442378, 607), + (3442985, 553), + (3443538, 552), + (3444090, 605), + (3444695, 554), + (3445249, 551), + (3445800, 586), + (3446386, 552), + (3446938, 551), + (3447489, 599), + (3448088, 552), + (3448640, 551), + (3449191, 599), + (3449790, 552), + (3450342, 550), + (3450892, 600), + (3451492, 554), + (3452046, 552), + (3452598, 613), + (3453211, 554), + (3453765, 550), + (3454315, 612), + (3454927, 553), + (3455480, 550), + (3456030, 606), + (3456636, 553), + (3457189, 551), + (3457740, 618), + (3458358, 552), + (3458910, 551), + (3459461, 618), + (3460079, 554), + (3460633, 551), + (3461184, 585), + (3461769, 553), + (3462322, 552), + (3462874, 600), + (3463474, 553), + (3464027, 552), + (3464579, 600), + (3465179, 553), + (3465732, 552), + (3466284, 600), + (3466884, 552), + (3467436, 550), + (3467986, 612), + (3468598, 552), + (3469150, 551), + (3469701, 613), + (3470314, 553), + (3470867, 551), + (3471418, 607), + (3472025, 553), + (3472578, 551), + (3473129, 618), + (3473747, 553), + (3474300, 549), + (3474849, 618), + (3475467, 552), + (3476019, 551), + (3476570, 574), + (3477144, 552), + (3477696, 550), + (3478246, 588), + (3478834, 553), + (3479387, 550), + (3479937, 588), + (3480525, 554), + (3481079, 552), + (3481631, 590), + (3482221, 553), + (3482774, 551), + (3483325, 603), + (3483928, 553), + (3484481, 550), + (3485031, 601), + (3485632, 554), + (3486186, 550), + (3486736, 595), + (3487331, 553), + (3487884, 552), + (3488436, 608), + (3489044, 552), + (3489596, 551), + (3490147, 608), + (3490755, 553), + (3491308, 550), + (3491858, 587), + (3492445, 553), + (3492998, 551), + (3493549, 600), + (3494149, 552), + (3494701, 552), + (3495253, 600), + (3495853, 552), + (3496405, 551), + (3496956, 603), + (3497559, 553), + (3498112, 551), + (3498663, 614), + (3499277, 553), + (3499830, 552), + (3500382, 613), + (3500995, 552), + (3501547, 550), + (3502097, 607), + (3502704, 554), + (3503258, 550), + (3503808, 620), + (3504428, 553), + (3504981, 550), + (3505531, 620), + (3506151, 554), + (3506705, 552), + (3507257, 588), + (3507845, 554), + (3508399, 550), + (3508949, 600), + (3509549, 553), + (3510102, 551), + (3510653, 602), + (3511255, 554), + (3511809, 550), + (3512359, 602), + (3512961, 552), + (3513513, 550), + (3514063, 615), + (3514678, 552), + (3515230, 550), + (3515780, 615), + (3516395, 553), + (3516948, 551), + (3517499, 608), + (3518107, 553), + (3518660, 551), + (3519211, 621), + (3519832, 553), + (3520385, 549), + (3520934, 620), + (3521554, 553), + (3522107, 551), + (3522658, 542), + (3523200, 553), + (3523753, 551), + (3524304, 571), + (3524875, 553), + (3525428, 551), + (3525979, 571), + (3526550, 552), + (3527102, 550), + (3527652, 572), + (3528224, 553), + (3528777, 552), + (3529329, 585), + (3529914, 553), + (3530467, 550), + (3531017, 585), + (3531602, 553), + (3532155, 551), + (3532706, 578), + (3533284, 552), + (3533836, 551), + (3534387, 591), + (3534978, 553), + (3535531, 550), + (3536081, 591), + (3536672, 554), + (3537226, 551), + (3537777, 570), + (3538347, 554), + (3538901, 551), + (3539452, 586), + (3540038, 554), + (3540592, 551), + (3541143, 585), + (3541728, 554), + (3542282, 551), + (3542833, 587), + (3543420, 553), + (3543973, 550), + (3544523, 599), + (3545122, 553), + (3545675, 552), + (3546227, 599), + (3546826, 553), + (3547379, 552), + (3547931, 593), + (3548524, 554), + (3549078, 551), + (3549629, 606), + (3550235, 553), + (3550788, 552), + (3551340, 606), + (3551946, 553), + (3552499, 552), + (3553051, 570), + (3553621, 552), + (3554173, 551), + (3554724, 586), + (3555310, 553), + (3555863, 551), + (3556414, 585), + (3556999, 553), + (3557552, 550), + (3558102, 587), + (3558689, 553), + (3559242, 551), + (3559793, 600), + (3560393, 553), + (3560946, 551), + (3561497, 599), + (3562096, 554), + (3562650, 551), + (3563201, 594), + (3563795, 554), + (3564349, 551), + (3564900, 605), + (3565505, 554), + (3566059, 551), + (3566610, 604), + (3567214, 553), + (3567767, 551), + (3568318, 573), + (3568891, 552), + (3569443, 551), + (3569994, 587), + (3570581, 554), + (3571135, 550), + (3571685, 587), + (3572272, 552), + (3572824, 550), + (3573374, 588), + (3573962, 553), + (3574515, 550), + (3575065, 601), + (3575666, 552), + (3576218, 551), + (3576769, 601), + (3577370, 554), + (3577924, 551), + (3578475, 594), + (3579069, 553), + (3579622, 551), + (3580173, 605), + (3580778, 554), + (3581332, 551), + (3581883, 606), + (3582489, 553), + (3583042, 552), + (3583594, 585), + (3584179, 552), + (3584731, 551), + (3585282, 599), + (3585881, 553), + (3586434, 551), + (3586985, 599), + (3587584, 552), + (3588136, 552), + (3588688, 600), + (3589288, 553), + (3589841, 551), + (3590392, 613), + (3591005, 553), + (3591558, 551), + (3592109, 611), + (3592720, 554), + (3593274, 550), + (3593824, 606), + (3594430, 554), + (3594984, 550), + (3595534, 619), + (3596153, 553), + (3596706, 552), + (3597258, 617), + (3597875, 553), + (3598428, 550), + (3598978, 586), + (3599564, 552), + (3600116, 550), + (3600666, 599), + (3601265, 553), + (3601818, 552), + (3602370, 599), + (3602969, 553), + (3603522, 551), + (3604073, 600), + (3604673, 553), + (3605226, 551), + (3605777, 612), + (3606389, 552), + (3606941, 552), + (3607493, 613), + (3608106, 554), + (3608660, 551), + (3609211, 606), + (3609817, 554), + (3610371, 551), + (3610922, 617), + (3611539, 553), + (3612092, 551), + (3612643, 618), + (3613261, 553), + (3613814, 551), + (3614365, 574), + (3614939, 553), + (3615492, 551), + (3616043, 589), + (3616632, 554), + (3617186, 552), + (3617738, 589), + (3618327, 553), + (3618880, 551), + (3619431, 590), + (3620021, 553), + (3620574, 551), + (3621125, 602), + (3621727, 554), + (3622281, 550), + (3622831, 602), + (3623433, 552), + (3623985, 552), + (3624537, 595), + (3625132, 553), + (3625685, 552), + (3626237, 608), + (3626845, 553), + (3627398, 550), + (3627948, 608), + (3628556, 553), + (3629109, 550), + (3629659, 587), + (3630246, 553), + (3630799, 552), + (3631351, 602), + (3631953, 553), + (3632506, 551), + (3633057, 601), + (3633658, 553), + (3634211, 550), + (3634761, 601), + (3635362, 554), + (3635916, 550), + (3636466, 614), + (3637080, 552), + (3637632, 551), + (3638183, 613), + (3638796, 554), + (3639350, 551), + (3639901, 608), + (3640509, 553), + (3641062, 552), + (3641614, 620), + (3642234, 553), + (3642787, 551), + (3643338, 620), + (3643958, 554), + (3644512, 552), + (3645064, 586), + (3645650, 554), + (3646204, 550), + (3646754, 601), + (3647355, 553), + (3647908, 550), + (3648458, 601), + (3649059, 553), + (3649612, 552), + (3650164, 602), + (3650766, 553), + (3651319, 551), + (3651870, 613), + (3652483, 552), + (3653035, 552), + (3653587, 613), + (3654200, 554), + (3654754, 552), + (3655306, 607), + (3655913, 552), + (3656465, 550), + (3657015, 620), + (3657635, 554), + (3658189, 552), + (3658741, 619), + (3659360, 553), + (3659913, 561), + (3660474, 542), + (3661016, 552), + (3661568, 561), + (3662129, 569), + (3662698, 553), + (3663251, 562), + (3663813, 570), + (3664383, 553), + (3664936, 561), + (3665497, 572), + (3666069, 553), + (3666622, 562), + (3667184, 585), + (3667769, 553), + (3668322, 560), + (3668882, 586), + (3669468, 553), + (3670021, 561), + (3670582, 579), + (3671161, 553), + (3671714, 561), + (3672275, 591), + (3672866, 552), + (3673418, 562), + (3673980, 590), + (3674570, 553), + (3675123, 562), + (3675685, 570), + (3676255, 554), + (3676809, 561), + (3677370, 586), + (3677956, 554), + (3678510, 561), + (3679071, 585), + (3679656, 552), + (3680208, 561), + (3680769, 587), + (3681356, 553), + (3681909, 562), + (3682471, 600), + (3683071, 554), + (3683625, 561), + (3684186, 600), + (3684786, 553), + (3685339, 561), + (3685900, 593), + (3686493, 553), + (3687046, 562), + (3687608, 605), + (3688213, 553), + (3688766, 561), + (3689327, 605), + (3689932, 553), + (3690485, 560), + (3691045, 569), + (3691614, 553), + (3692167, 561), + (3692728, 586), + (3693314, 553), + (3693867, 562), + (3694429, 587), + (3695016, 553), + (3695569, 561), + (3696130, 586), + (3696716, 554), + (3697270, 560), + (3697830, 600), + (3698430, 553), + (3698983, 560), + (3699543, 598), + (3700141, 553), + (3700694, 560), + (3701254, 594), + (3701848, 553), + (3702401, 562), + (3702963, 606), + (3703569, 552), + (3704121, 560), + (3704681, 605), + (3705286, 554), + (3705840, 561), + (3706401, 573), + (3706974, 553), + (3707527, 561), + (3708088, 587), + (3708675, 554), + (3709229, 562), + (3709791, 586), + (3710377, 553), + (3710930, 561), + (3711491, 587), + (3712078, 552), + (3712630, 561), + (3713191, 601), + (3713792, 553), + (3714345, 561), + (3714906, 600), + (3715506, 554), + (3716060, 561), + (3716621, 594), + (3717215, 552), + (3717767, 562), + (3718329, 606), + (3718935, 553), + (3719488, 562), + (3720050, 606), + (3720656, 554), + (3721210, 561), + (3721771, 585), + (3722356, 553), + (3722909, 561), + (3723470, 598), + (3724068, 554), + (3724622, 562), + (3725184, 599), + (3725783, 553), + (3726336, 560), + (3726896, 600), + (3727496, 554), + (3728050, 562), + (3728612, 611), + (3729223, 553), + (3729776, 560), + (3730336, 613), + (3730949, 553), + (3731502, 560), + (3732062, 607), + (3732669, 553), + (3733222, 561), + (3733783, 619), + (3734402, 552), + (3734954, 560), + (3735514, 617), + (3736131, 552), + (3736683, 562), + (3737245, 584), + (3737829, 553), + (3738382, 561), + (3738943, 598), + (3739541, 552), + (3740093, 562), + (3740655, 599), + (3741254, 552), + (3741806, 562), + (3742368, 601), + (3742969, 553), + (3743522, 561), + (3744083, 612), + (3744695, 553), + (3745248, 560), + (3745808, 613), + (3746421, 551), + (3746972, 560), + (3747532, 607), + (3748139, 551), + (3748690, 561), + (3749251, 618), + (3749869, 552), + (3750421, 561), + (3750982, 617), + (3751599, 553), + (3752152, 560), + (3752712, 575), + (3753287, 552), + (3753839, 561), + (3754400, 589), + (3754989, 554), + (3755543, 561), + (3756104, 589), + (3756693, 553), + (3757246, 561), + (3757807, 589), + (3758396, 553), + (3758949, 561), + (3759510, 602), + (3760112, 552), + (3760664, 561), + (3761225, 602), + (3761827, 553), + (3762380, 561), + (3762941, 595), + (3763536, 552), + (3764088, 562), + (3764650, 608), + (3765258, 553), + (3765811, 561), + (3766372, 608), + (3766980, 552), + (3767532, 561), + (3768093, 588), + (3768681, 553), + (3769234, 561), + (3769795, 602), + (3770397, 554), + (3770951, 560), + (3771511, 602), + (3772113, 554), + (3772667, 560), + (3773227, 602), + (3773829, 552), + (3774381, 562), + (3774943, 614), + (3775557, 553), + (3776110, 562), + (3776672, 614), + (3777286, 554), + (3777840, 561), + (3778401, 608), + (3779009, 553), + (3779562, 560), + (3780122, 619), + (3780741, 553), + (3781294, 561), + (3781855, 621), + (3782476, 554), + (3783030, 561), + (3783591, 588), + (3784179, 552), + (3784731, 561), + (3785292, 601), + (3785893, 554), + (3786447, 561), + (3787008, 601), + (3787609, 553), + (3788162, 560), + (3788722, 601), + (3789323, 553), + (3789876, 561), + (3790437, 614), + (3791051, 553), + (3791604, 561), + (3792165, 614), + (3792779, 553), + (3793332, 561), + (3793893, 608), + (3794501, 552), + (3795053, 560), + (3795613, 621), + (3796234, 553), + (3796787, 561), + (3797348, 619), + (3797967, 552), + (3798519, 568), + (3799087, 542), + (3799629, 553), + (3800182, 567), + (3800749, 569), + (3801318, 553), + (3801871, 566), + (3802437, 570), + (3803007, 553), + (3803560, 567), + (3804127, 572), + (3804699, 552), + (3805251, 566), + (3805817, 585), + (3806402, 552), + (3806954, 567), + (3807521, 585), + (3808106, 554), + (3808660, 567), + (3809227, 579), + (3809806, 553), + (3810359, 567), + (3810926, 590), + (3811516, 552), + (3812068, 567), + (3812635, 591), + (3813226, 553), + (3813779, 567), + (3814346, 571), + (3814917, 553), + (3815470, 567), + (3816037, 586), + (3816623, 553), + (3817176, 567), + (3817743, 586), + (3818329, 553), + (3818882, 567), + (3819449, 586), + (3820035, 554), + (3820589, 567), + (3821156, 600), + (3821756, 553), + (3822309, 567), + (3822876, 598), + (3823474, 554), + (3824028, 567), + (3824595, 592), + (3825187, 553), + (3825740, 567), + (3826307, 604), + (3826911, 552), + (3827463, 566), + (3828029, 605), + (3828634, 552), + (3829186, 568), + (3829754, 571), + (3830325, 553), + (3830878, 566), + (3831444, 586), + (3832030, 554), + (3832584, 568), + (3833152, 586), + (3833738, 553), + (3834291, 566), + (3834857, 587), + (3835444, 553), + (3835997, 568), + (3836565, 598), + (3837163, 553), + (3837716, 566), + (3838282, 600), + (3838882, 553), + (3839435, 566), + (3840001, 592), + (3840593, 554), + (3841147, 566), + (3841713, 606), + (3842319, 552), + (3842871, 566), + (3843437, 605), + (3844042, 552), + (3844594, 566), + (3845160, 572), + (3845732, 554), + (3846286, 566), + (3846852, 588), + (3847440, 554), + (3847994, 567), + (3848561, 587), + (3849148, 553), + (3849701, 568), + (3850269, 588), + (3850857, 552), + (3851409, 568), + (3851977, 599), + (3852576, 553), + (3853129, 567), + (3853696, 599), + (3854295, 554), + (3854849, 568), + (3855417, 594), + (3856011, 553), + (3856564, 568), + (3857132, 605), + (3857737, 552), + (3858289, 566), + (3858855, 606), + (3859461, 554), + (3860015, 566), + (3860581, 585), + (3861166, 552), + (3861718, 568), + (3862286, 599), + (3862885, 554), + (3863439, 566), + (3864005, 599), + (3864604, 553), + (3865157, 567), + (3865724, 599), + (3866323, 553), + (3866876, 568), + (3867444, 612), + (3868056, 553), + (3868609, 568), + (3869177, 612), + (3869789, 554), + (3870343, 567), + (3870910, 606), + (3871516, 552), + (3872068, 567), + (3872635, 618), + (3873253, 553), + (3873806, 567), + (3874373, 617), + (3874990, 553), + (3875543, 568), + (3876111, 584), + (3876695, 553), + (3877248, 568), + (3877816, 600), + (3878416, 552), + (3878968, 567), + (3879535, 599), + (3880134, 552), + (3880686, 567), + (3881253, 599), + (3881852, 553), + (3882405, 566), + (3882971, 612), + (3883583, 552), + (3884135, 567), + (3884702, 612), + (3885314, 553), + (3885867, 567), + (3886434, 606), + (3887040, 553), + (3887593, 567), + (3888160, 618), + (3888778, 554), + (3889332, 568), + (3889900, 618), + (3890518, 553), + (3891071, 566), + (3891637, 575), + (3892212, 554), + (3892766, 566), + (3893332, 590), + (3893922, 553), + (3894475, 567), + (3895042, 589), + (3895631, 554), + (3896185, 566), + (3896751, 590), + (3897341, 554), + (3897895, 567), + (3898462, 602), + (3899064, 553), + (3899617, 566), + (3900183, 601), + (3900784, 553), + (3901337, 567), + (3901904, 596), + (3902500, 554), + (3903054, 568), + (3903622, 607), + (3904229, 554), + (3904783, 567), + (3905350, 608), + (3905958, 552), + (3906510, 567), + (3907077, 587), + (3907664, 553), + (3908217, 566), + (3908783, 600), + (3909383, 553), + (3909936, 567), + (3910503, 601), + (3911104, 553), + (3911657, 567), + (3912224, 602), + (3912826, 553), + (3913379, 566), + (3913945, 615), + (3914560, 553), + (3915113, 567), + (3915680, 615), + (3916295, 552), + (3916847, 568), + (3917415, 608), + (3918023, 554), + (3918577, 568), + (3919145, 619), + (3919764, 553), + (3920317, 566), + (3920883, 621), + (3921504, 553), + (3922057, 567), + (3922624, 588), + (3923212, 553), + (3923765, 566), + (3924331, 601), + (3924932, 553), + (3925485, 567), + (3926052, 601), + (3926653, 553), + (3927206, 568), + (3927774, 602), + (3928376, 554), + (3928930, 566), + (3929496, 614), + (3930110, 554), + (3930664, 565), + (3931229, 615), + (3931844, 553), + (3932397, 567), + (3932964, 609), + (3933573, 553), + (3934126, 566), + (3934692, 619), + (3935311, 553), + (3935864, 568), + (3936432, 619), + (3937051, 554), + (3937605, 566), + (3938171, 541), + (3938712, 554), + (3939266, 568), + (3939834, 571), + (3940405, 552), + (3940957, 567), + (3941524, 570), + (3942094, 554), + (3942648, 568), + (3943216, 572), + (3943788, 553), + (3944341, 567), + (3944908, 585), + (3945493, 553), + (3946046, 567), + (3946613, 586), + (3947199, 554), + (3947753, 567), + (3948320, 579), + (3948899, 553), + (3949452, 568), + (3950020, 592), + (3950612, 554), + (3951166, 567), + (3951733, 590), + (3952323, 553), + (3952876, 566), + (3953442, 570), + (3954012, 553), + (3954565, 567), + (3955132, 585), + (3955717, 554), + (3956271, 568), + (3956839, 587), + (3957426, 553), + (3957979, 566), + (3958545, 587), + (3959132, 553), + (3959685, 567), + (3960252, 599), + (3960851, 553), + (3961404, 567), + (3961971, 599), + (3962570, 552), + (3963122, 568), + (3963690, 592), + (3964282, 553), + (3964835, 566), + (3965401, 604), + (3966005, 554), + (3966559, 566), + (3967125, 604), + (3967729, 553), + (3968282, 568), + (3968850, 571), + (3969421, 553), + (3969974, 568), + (3970542, 586), + (3971128, 552), + (3971680, 567), + (3972247, 587), + (3972834, 552), + (3973386, 568), + (3973954, 588), + (3974542, 552), + (3975094, 567), + (3975661, 599), + (3976260, 553), + (3976813, 567), + (3977380, 598), + (3977978, 553), + (3978531, 568), + (3979099, 594), + (3979693, 554), + (3980247, 567), + (3980814, 605), + (3981419, 552), + (3981971, 568), + (3982539, 604), + (3983143, 552), + (3983695, 568), + (3984263, 572), + (3984835, 553), + (3985388, 566), + (3985954, 586), + (3986540, 553), + (3987093, 567), + (3987660, 588), + (3988248, 553), + (3988801, 567), + (3989368, 588), + (3989956, 554), + (3990510, 566), + (3991076, 600), + (3991676, 552), + (3992228, 567), + (3992795, 599), + (3993394, 554), + (3993948, 567), + (3994515, 594), + (3995109, 553), + (3995662, 567), + (3996229, 605), + (3996834, 554), + (3997388, 566), + (3997954, 607), + (3998561, 553), + (3999114, 566), + (3999680, 585), + (4000265, 552), + (4000817, 567), + (4001384, 599), + (4001983, 554), + (4002537, 567), + (4003104, 599), + (4003703, 553), + (4004256, 567), + (4004823, 601), + (4005424, 553), + (4005977, 566), + (4006543, 612), + (4007155, 553), + (4007708, 568), + (4008276, 611), + (4008887, 552), + (4009439, 566), + (4010005, 605), + (4010610, 554), + (4011164, 567), + (4011731, 618), + (4012349, 553), + (4012902, 567), + (4013469, 617), + (4014086, 554), + (4014640, 567), + (4015207, 586), + (4015793, 554), + (4016347, 567), + (4016914, 599), + (4017513, 553), + (4018066, 567), + (4018633, 599), + (4019232, 553), + (4019785, 567), + (4020352, 600), + (4020952, 553), + (4021505, 567), + (4022072, 611), + (4022683, 554), + (4023237, 568), + (4023805, 612), + (4024417, 554), + (4024971, 567), + (4025538, 607), + (4026145, 553), + (4026698, 568), + (4027266, 617), + (4027883, 553), + (4028436, 568), + (4029004, 618), + (4029622, 552), + (4030174, 567), + (4030741, 575), + (4031316, 554), + (4031870, 568), + (4032438, 588), + (4033026, 553), + (4033579, 565), + (4034144, 588), + (4034732, 553), + (4035285, 566), + (4035851, 589), + (4036440, 553), + (4036993, 567), + (4037560, 601), + (4038161, 554), + (4038715, 567), + (4039282, 602), + (4039884, 554), + (4040438, 567), + (4041005, 597), + (4041602, 553), + (4042155, 568), + (4042723, 607), + (4043330, 554), + (4043884, 566), + (4044450, 609), + (4045059, 552), + (4045611, 566), + (4046177, 587), + (4046764, 553), + (4047317, 567), + (4047884, 602), + (4048486, 552), + (4049038, 567), + (4049605, 601), + (4050206, 553), + (4050759, 566), + (4051325, 603), + (4051928, 553), + (4052481, 567), + (4053048, 614), + (4053662, 552), + (4054214, 568), + (4054782, 615), + (4055397, 553), + (4055950, 568), + (4056518, 608), + (4057126, 553), + (4057679, 567), + (4058246, 620), + (4058866, 553), + (4059419, 568), + (4059987, 620), + (4060607, 553), + (4061160, 567), + (4061727, 588), + (4062315, 554), + (4062869, 566), + (4063435, 601), + (4064036, 554), + (4064590, 567), + (4065157, 602), + (4065759, 553), + (4066312, 566), + (4066878, 603), + (4067481, 554), + (4068035, 566), + (4068601, 614), + (4069215, 554), + (4069769, 567), + (4070336, 615), + (4070951, 553), + (4071504, 567), + (4072071, 609), + (4072680, 554), + (4073234, 566), + (4073800, 621), + (4074421, 554), + (4074975, 568), + (4075543, 620), + (4076163, 553), + (4076716, 562), + (4077278, 543), + (4077821, 553), + (4078374, 561), + (4078935, 571), + (4079506, 553), + (4080059, 561), + (4080620, 570), + (4081190, 553), + (4081743, 562), + (4082305, 571), + (4082876, 552), + (4083428, 560), + (4083988, 585), + (4084573, 553), + (4085126, 562), + (4085688, 586), + (4086274, 553), + (4086827, 562), + (4087389, 579), + (4087968, 553), + (4088521, 563), + (4089084, 591), + (4089675, 553), + (4090228, 563), + (4090791, 591), + (4091382, 553), + (4091935, 562), + (4092497, 571), + (4093068, 552), + (4093620, 561), + (4094181, 586), + (4094767, 553), + (4095320, 562), + (4095882, 586), + (4096468, 553), + (4097021, 562), + (4097583, 587), + (4098170, 553), + (4098723, 563), + (4099286, 599), + (4099885, 553), + (4100438, 563), + (4101001, 600), + (4101601, 553), + (4102154, 563), + (4102717, 593), + (4103310, 554), + (4103864, 562), + (4104426, 605), + (4105031, 553), + (4105584, 562), + (4106146, 606), + (4106752, 554), + (4107306, 563), + (4107869, 570), + (4108439, 552), + (4108991, 563), + (4109554, 586), + (4110140, 554), + (4110694, 563), + (4111257, 585), + (4111842, 553), + (4112395, 561), + (4112956, 588), + (4113544, 553), + (4114097, 562), + (4114659, 599), + (4115258, 553), + (4115811, 563), + (4116374, 599), + (4116973, 554), + (4117527, 562), + (4118089, 593), + (4118682, 554), + (4119236, 562), + (4119798, 606), + (4120404, 553), + (4120957, 561), + (4121518, 605), + (4122123, 552), + (4122675, 561), + (4123236, 572), + (4123808, 553), + (4124361, 562), + (4124923, 587), + (4125510, 554), + (4126064, 562), + (4126626, 586), + (4127212, 552), + (4127764, 562), + (4128326, 588), + (4128914, 554), + (4129468, 562), + (4130030, 600), + (4130630, 554), + (4131184, 561), + (4131745, 600), + (4132345, 554), + (4132899, 563), + (4133462, 594), + (4134056, 553), + (4134609, 563), + (4135172, 607), + (4135779, 553), + (4136332, 562), + (4136894, 606), + (4137500, 553), + (4138053, 563), + (4138616, 584), + (4139200, 554), + (4139754, 563), + (4140317, 599), + (4140916, 552), + (4141468, 562), + (4142030, 598), + (4142628, 553), + (4143181, 563), + (4143744, 600), + (4144344, 553), + (4144897, 562), + (4145459, 612), + (4146071, 552), + (4146623, 562), + (4147185, 612), + (4147797, 553), + (4148350, 562), + (4148912, 607), + (4149519, 552), + (4150071, 562), + (4150633, 619), + (4151252, 554), + (4151806, 562), + (4152368, 617), + (4152985, 554), + (4153539, 563), + (4154102, 584), + (4154686, 553), + (4155239, 563), + (4155802, 599), + (4156401, 553), + (4156954, 562), + (4157516, 600), + (4158116, 553), + (4158669, 561), + (4159230, 599), + (4159829, 553), + (4160382, 563), + (4160945, 613), + (4161558, 554), + (4162112, 562), + (4162674, 613), + (4163287, 552), + (4163839, 561), + (4164400, 607), + (4165007, 554), + (4165561, 561), + (4166122, 619), + (4166741, 552), + (4167293, 561), + (4167854, 617), + (4168471, 552), + (4169023, 562), + (4169585, 576), + (4170161, 553), + (4170714, 563), + (4171277, 590), + (4171867, 553), + (4172420, 562), + (4172982, 589), + (4173571, 553), + (4174124, 562), + (4174686, 591), + (4175277, 552), + (4175829, 562), + (4176391, 603), + (4176994, 553), + (4177547, 562), + (4178109, 603), + (4178712, 552), + (4179264, 562), + (4179826, 596), + (4180422, 554), + (4180976, 562), + (4181538, 608), + (4182146, 554), + (4182700, 562), + (4183262, 608), + (4183870, 554), + (4184424, 562), + (4184986, 587), + (4185573, 552), + (4186125, 562), + (4186687, 602), + (4187289, 553), + (4187842, 561), + (4188403, 600), + (4189003, 553), + (4189556, 561), + (4190117, 601), + (4190718, 552), + (4191270, 561), + (4191831, 615), + (4192446, 553), + (4192999, 561), + (4193560, 614), + (4194174, 552), + (4194726, 561), + (4195287, 607), + (4195894, 554), + (4196448, 561), + (4197009, 620), + (4197629, 553), + (4198182, 562), + (4198744, 620), + (4199364, 553), + (4199917, 563), + (4200480, 588), + (4201068, 553), + (4201621, 563), + (4202184, 602), + (4202786, 553), + (4203339, 562), + (4203901, 600), + (4204501, 553), + (4205054, 562), + (4205616, 603), + (4206219, 553), + (4206772, 561), + (4207333, 615), + (4207948, 554), + (4208502, 562), + (4209064, 613), + (4209677, 553), + (4210230, 562), + (4210792, 609), + (4211401, 552), + (4211953, 563), + (4212516, 621), + (4213137, 552), + (4213689, 561), + (4214250, 620), + (4214870, 553), + (4215423, 569), + (4215992, 541), + (4216533, 554), + (4217087, 569), + (4217656, 571), + (4218227, 553), + (4218780, 569), + (4219349, 570), + (4219919, 553), + (4220472, 568), + (4221040, 573), + (4221613, 553), + (4222166, 568), + (4222734, 585), + (4223319, 552), + (4223871, 568), + (4224439, 586), + (4225025, 552), + (4225577, 567), + (4226144, 579), + (4226723, 553), + (4227276, 568), + (4227844, 592), + (4228436, 553), + (4228989, 567), + (4229556, 591), + (4230147, 552), + (4230699, 569), + (4231268, 571), + (4231839, 553), + (4232392, 567), + (4232959, 585), + (4233544, 553), + (4234097, 569), + (4234666, 586), + (4235252, 553), + (4235805, 568), + (4236373, 587), + (4236960, 552), + (4237512, 567), + (4238079, 598), + (4238677, 554), + (4239231, 568), + (4239799, 598), + (4240397, 553), + (4240950, 568), + (4241518, 593), + (4242111, 554), + (4242665, 568), + (4243233, 606), + (4243839, 552), + (4244391, 567), + (4244958, 604), + (4245562, 552), + (4246114, 569), + (4246683, 570), + (4247253, 553), + (4247806, 568), + (4248374, 586), + (4248960, 553), + (4249513, 568), + (4250081, 586), + (4250667, 553), + (4251220, 569), + (4251789, 587), + (4252376, 553), + (4252929, 568), + (4253497, 599), + (4254096, 552), + (4254648, 569), + (4255217, 598), + (4255815, 553), + (4256368, 568), + (4256936, 594), + (4257530, 553), + (4258083, 568), + (4258651, 605), + (4259256, 554), + (4259810, 569), + (4260379, 605), + (4260984, 554), + (4261538, 568), + (4262106, 571), + (4262677, 553), + (4263230, 568), + (4263798, 588), + (4264386, 552), + (4264938, 569), + (4265507, 587), + (4266094, 552), + (4266646, 567), + (4267213, 589), + (4267802, 553), + (4268355, 568), + (4268923, 600), + (4269523, 552), + (4270075, 568), + (4270643, 599), + (4271242, 554), + (4271796, 568), + (4272364, 594), + (4272958, 552), + (4273510, 569), + (4274079, 605), + (4274684, 554), + (4275238, 567), + (4275805, 605), + (4276410, 553), + (4276963, 567), + (4277530, 584), + (4278114, 553), + (4278667, 567), + (4279234, 598), + (4279832, 554), + (4280386, 568), + (4280954, 599), + (4281553, 553), + (4282106, 568), + (4282674, 601), + (4283275, 554), + (4283829, 567), + (4284396, 612), + (4285008, 554), + (4285562, 567), + (4286129, 612), + (4286741, 552), + (4287293, 568), + (4287861, 606), + (4288467, 553), + (4289020, 567), + (4289587, 618), + (4290205, 552), + (4290757, 569), + (4291326, 619), + (4291945, 553), + (4292498, 568), + (4293066, 585), + (4293651, 553), + (4294204, 569), + (4294773, 599), + (4295372, 554), + (4295926, 568), + (4296494, 600), + (4297094, 553), + (4297647, 567), + (4298214, 598), + (4298812, 554), + (4299366, 569), + (4299935, 612), + (4300547, 553), + (4301100, 568), + (4301668, 612), + (4302280, 554), + (4302834, 569), + (4303403, 605), + (4304008, 552), + (4304560, 568), + (4305128, 619), + (4305747, 554), + (4306301, 568), + (4306869, 618), + (4307487, 554), + (4308041, 568), + (4308609, 575), + (4309184, 553), + (4309737, 568), + (4310305, 590), + (4310895, 553), + (4311448, 568), + (4312016, 589), + (4312605, 553), + (4313158, 568), + (4313726, 589), + (4314315, 552), + (4314867, 567), + (4315434, 603), + (4316037, 552), + (4316589, 569), + (4317158, 601), + (4317759, 553), + (4318312, 569), + (4318881, 596), + (4319477, 553), + (4320030, 568), + (4320598, 609), + (4321207, 552), + (4321759, 567), + (4322326, 609), + (4322935, 553), + (4323488, 567), + (4324055, 586), + (4324641, 554), + (4325195, 568), + (4325763, 601), + (4326364, 553), + (4326917, 568), + (4327485, 600), + (4328085, 552), + (4328637, 568), + (4329205, 602), + (4329807, 554), + (4330361, 568), + (4330929, 615), + (4331544, 553), + (4332097, 567), + (4332664, 614), + (4333278, 553), + (4333831, 568), + (4334399, 607), + (4335006, 554), + (4335560, 568), + (4336128, 620), + (4336748, 552), + (4337300, 568), + (4337868, 620), + (4338488, 552), + (4339040, 568), + (4339608, 586), + (4340194, 552), + (4340746, 567), + (4341313, 601), + (4341914, 552), + (4342466, 567), + (4343033, 602), + (4343635, 553), + (4344188, 568), + (4344756, 602), + (4345358, 553), + (4345911, 568), + (4346479, 613), + (4347092, 554), + (4347646, 568), + (4348214, 615), + (4348829, 553), + (4349382, 568), + (4349950, 608), + (4350558, 553), + (4351111, 568), + (4351679, 620), + (4352299, 553), + (4352852, 568), + (4353420, 619), + (4354039, 554), + (4354593, 569), + (4355162, 542), + (4355704, 553), + (4356257, 568), + (4356825, 569), + (4357394, 552), + (4357946, 568), + (4358514, 569), + (4359083, 554), + (4359637, 568), + (4360205, 573), + (4360778, 553), + (4361331, 568), + (4361899, 585), + (4362484, 552), + (4363036, 567), + (4363603, 584), + (4364187, 554), + (4364741, 568), + (4365309, 580), + (4365889, 553), + (4366442, 568), + (4367010, 591), + (4367601, 553), + (4368154, 567), + (4368721, 591), + (4369312, 553), + (4369865, 568), + (4370433, 570), + (4371003, 553), + (4371556, 568), + (4372124, 586), + (4372710, 554), + (4373264, 567), + (4373831, 586), + (4374417, 552), + (4374969, 568), + (4375537, 587), + (4376124, 554), + (4376678, 568), + (4377246, 600), + (4377846, 554), + (4378400, 567), + (4378967, 600), + (4379567, 552), + (4380119, 567), + (4380686, 592), + (4381278, 552), + (4381830, 568), + (4382398, 606), + (4383004, 553), + (4383557, 568), + (4384125, 605), + (4384730, 552), + (4385282, 568), + (4385850, 570), + (4386420, 552), + (4386972, 568), + (4387540, 586), + (4388126, 552), + (4388678, 567), + (4389245, 587), + (4389832, 554), + (4390386, 569), + (4390955, 587), + (4391542, 553), + (4392095, 568), + (4392663, 599), + (4393262, 553), + (4393815, 567), + (4394382, 599), + (4394981, 554), + (4395535, 569), + (4396104, 593), + (4396697, 554), + (4397251, 569), + (4397820, 606), + (4398426, 554), + (4398980, 569), + (4399549, 604), + (4400153, 553), + (4400706, 569), + (4401275, 573), + (4401848, 553), + (4402401, 568), + (4402969, 587), + (4403556, 554), + (4404110, 567), + (4404677, 587), + (4405264, 554), + (4405818, 569), + (4406387, 588), + (4406975, 553), + (4407528, 569), + (4408097, 600), + (4408697, 552), + (4409249, 568), + (4409817, 599), + (4410416, 553), + (4410969, 568), + (4411537, 594), + (4412131, 553), + (4412684, 568), + (4413252, 606), + (4413858, 553), + (4414411, 568), + (4414979, 606), + (4415585, 553), + (4416138, 569), + (4416707, 584), + (4417291, 553), + (4417844, 568), + (4418412, 599), + (4419011, 553), + (4419564, 568), + (4420132, 599), + (4420731, 553), + (4421284, 567), + (4421851, 600), + (4422451, 554), + (4423005, 568), + (4423573, 611), + (4424184, 554), + (4424738, 568), + (4425306, 612), + (4425918, 554), + (4426472, 568), + (4427040, 605), + (4427645, 553), + (4428198, 569), + (4428767, 619), + (4429386, 553), + (4429939, 568), + (4430507, 618), + (4431125, 552), + (4431677, 569), + (4432246, 586), + (4432832, 553), + (4433385, 567), + (4433952, 599), + (4434551, 553), + (4435104, 567), + (4435671, 598), + (4436269, 553), + (4436822, 569), + (4437391, 601), + (4437992, 552), + (4438544, 569), + (4439113, 612), + (4439725, 553), + (4440278, 568), + (4440846, 612), + (4441458, 554), + (4442012, 569), + (4442581, 605), + (4443186, 554), + (4443740, 568), + (4444308, 618), + (4444926, 554), + (4445480, 569), + (4446049, 619), + (4446668, 553), + (4447221, 568), + (4447789, 576), + (4448365, 554), + (4448919, 568), + (4449487, 589), + (4450076, 552), + (4450628, 568), + (4451196, 589), + (4451785, 553), + (4452338, 568), + (4452906, 591), + (4453497, 553), + (4454050, 567), + (4454617, 602), + (4455219, 552), + (4455771, 568), + (4456339, 603), + (4456942, 553), + (4457495, 567), + (4458062, 597), + (4458659, 553), + (4459212, 569), + (4459781, 608), + (4460389, 553), + (4460942, 567), + (4461509, 607), + (4462116, 552), + (4462668, 569), + (4463237, 586), + (4463823, 554), + (4464377, 569), + (4464946, 601), + (4465547, 552), + (4466099, 569), + (4466668, 600), + (4467268, 553), + (4467821, 568), + (4468389, 602), + (4468991, 554), + (4469545, 567), + (4470112, 614), + (4470726, 552), + (4471278, 569), + (4471847, 613), + (4472460, 553), + (4473013, 567), + (4473580, 607), + (4474187, 553), + (4474740, 569), + (4475309, 620), + (4475929, 552), + (4476481, 568), + (4477049, 619), + (4477668, 552), + (4478220, 567), + (4478787, 587), + (4479374, 554), + (4479928, 569), + (4480497, 602), + (4481099, 554), + (4481653, 568), + (4482221, 601), + (4482822, 554), + (4483376, 568), + (4483944, 602), + (4484546, 553), + (4485099, 567), + (4485666, 614), + (4486280, 552), + (4486832, 567), + (4487399, 613), + (4488012, 553), + (4488565, 569), + (4489134, 608), + (4489742, 554), + (4490296, 569), + (4490865, 620), + (4491485, 552), + (4492037, 568), + (4492605, 620), + (4493225, 554), + (4493779, 507), + (4494286, 542), + (4494828, 554), + (4495382, 509), + (4495891, 570), + (4496461, 553), + (4497014, 509), + (4497523, 570), + (4498093, 553), + (4498646, 506), + (4499152, 572), + (4499724, 553), + (4500277, 508), + (4500785, 585), + (4501370, 554), + (4501924, 508), + (4502432, 585), + (4503017, 553), + (4503570, 508), + (4504078, 578), + (4504656, 553), + (4505209, 507), + (4505716, 592), + (4506308, 554), + (4506862, 509), + (4507371, 591), + (4507962, 553), + (4508515, 507), + (4509022, 570), + (4509592, 554), + (4510146, 507), + (4510653, 585), + (4511238, 554), + (4511792, 507), + (4512299, 586), + (4512885, 553), + (4513438, 508), + (4513946, 586), + (4514532, 552), + (4515084, 507), + (4515591, 599), + (4516190, 554), + (4516744, 509), + (4517253, 599), + (4517852, 553), + (4518405, 509), + (4518914, 593), + (4519507, 553), + (4520060, 509), + (4520569, 605), + (4521174, 552), + (4521726, 508), + (4522234, 605), + (4522839, 554), + (4523393, 508), + (4523901, 570), + (4524471, 553), + (4525024, 509), + (4525533, 585), + (4526118, 552), + (4526670, 507), + (4527177, 586), + (4527763, 554), + (4528317, 507), + (4528824, 587), + (4529411, 553), + (4529964, 508), + (4530472, 600), + (4531072, 553), + (4531625, 509), + (4532134, 600), + (4532734, 553), + (4533287, 508), + (4533795, 593), + (4534388, 552), + (4534940, 508), + (4535448, 605), + (4536053, 553), + (4536606, 507), + (4537113, 606), + (4537719, 553), + (4538272, 507), + (4538779, 573), + (4539352, 554), + (4539906, 509), + (4540415, 586), + (4541001, 552), + (4541553, 508), + (4542061, 588), + (4542649, 553), + (4543202, 509), + (4543711, 587), + (4544298, 553), + (4544851, 509), + (4545360, 600), + (4545960, 552), + (4546512, 509), + (4547021, 600), + (4547621, 552), + (4548173, 507), + (4548680, 595), + (4549275, 553), + (4549828, 508), + (4550336, 605), + (4550941, 553), + (4551494, 508), + (4552002, 607), + (4552609, 553), + (4553162, 508), + (4553670, 585), + (4554255, 552), + (4554807, 509), + (4555316, 598), + (4555914, 554), + (4556468, 508), + (4556976, 598), + (4557574, 554), + (4558128, 507), + (4558635, 600), + (4559235, 553), + (4559788, 507), + (4560295, 612), + (4560907, 554), + (4561461, 507), + (4561968, 612), + (4562580, 553), + (4563133, 508), + (4563641, 607), + (4564248, 554), + (4564802, 508), + (4565310, 618), + (4565928, 553), + (4566481, 509), + (4566990, 617), + (4567607, 552), + (4568159, 508), + (4568667, 584), + (4569251, 553), + (4569804, 508), + (4570312, 598), + (4570910, 553), + (4571463, 508), + (4571971, 598), + (4572569, 554), + (4573123, 509), + (4573632, 601), + (4574233, 554), + (4574787, 508), + (4575295, 613), + (4575908, 553), + (4576461, 508), + (4576969, 612), + (4577581, 553), + (4578134, 507), + (4578641, 607), + (4579248, 552), + (4579800, 509), + (4580309, 619), + (4580928, 552), + (4581480, 508), + (4581988, 618), + (4582606, 553), + (4583159, 508), + (4583667, 574), + (4584241, 554), + (4584795, 507), + (4585302, 588), + (4585890, 552), + (4586442, 508), + (4586950, 590), + (4587540, 553), + (4588093, 508), + (4588601, 591), + (4589192, 553), + (4589745, 509), + (4590254, 601), + (4590855, 554), + (4591409, 509), + (4591918, 602), + (4592520, 554), + (4593074, 508), + (4593582, 597), + (4594179, 553), + (4594732, 509), + (4595241, 607), + (4595848, 553), + (4596401, 507), + (4596908, 608), + (4597516, 554), + (4598070, 508), + (4598578, 587), + (4599165, 553), + (4599718, 508), + (4600226, 601), + (4600827, 553), + (4601380, 509), + (4601889, 602), + (4602491, 553), + (4603044, 508), + (4603552, 602), + (4604154, 553), + (4604707, 508), + (4605215, 615), + (4605830, 552), + (4606382, 509), + (4606891, 615), + (4607506, 553), + (4608059, 507), + (4608566, 609), + (4609175, 553), + (4609728, 508), + (4610236, 621), + (4610857, 553), + (4611410, 507), + (4611917, 620), + (4612537, 552), + (4613089, 507), + (4613596, 588), + (4614184, 554), + (4614738, 508), + (4615246, 601), + (4615847, 553), + (4616400, 509), + (4616909, 600), + (4617509, 553), + (4618062, 507), + (4618569, 603), + (4619172, 553), + (4619725, 508), + (4620233, 614), + (4620847, 553), + (4621400, 508), + (4621908, 614), + (4622522, 552), + (4623074, 509), + (4623583, 609), + (4624192, 554), + (4624746, 508), + (4625254, 619), + (4625873, 554), + (4626427, 507), + (4626934, 619), + (4627553, 553), + (4628106, 526), + (4628632, 543), + (4629175, 553), + (4629728, 525), + (4630253, 570), + (4630823, 552), + (4631375, 525), + (4631900, 570), + (4632470, 554), + (4633024, 524), + (4633548, 572), + (4634120, 553), + (4634673, 526), + (4635199, 585), + (4635784, 552), + (4636336, 525), + (4636861, 585), + (4637446, 554), + (4638000, 524), + (4638524, 579), + (4639103, 552), + (4639655, 525), + (4640180, 591), + (4640771, 554), + (4641325, 525), + (4641850, 590), + (4642440, 553), + (4642993, 526), + (4643519, 570), + (4644089, 553), + (4644642, 525), + (4645167, 585), + (4645752, 552), + (4646304, 524), + (4646828, 586), + (4647414, 552), + (4647966, 526), + (4648492, 588), + (4649080, 552), + (4649632, 525), + (4650157, 599), + (4650756, 552), + (4651308, 525), + (4651833, 599), + (4652432, 553), + (4652985, 525), + (4653510, 592), + (4654102, 554), + (4654656, 524), + (4655180, 604), + (4655784, 552), + (4656336, 526), + (4656862, 605), + (4657467, 553), + (4658020, 526), + (4658546, 571), + (4659117, 553), + (4659670, 524), + (4660194, 586), + (4660780, 553), + (4661333, 525), + (4661858, 585), + (4662443, 552), + (4662995, 524), + (4663519, 587), + (4664106, 552), + (4664658, 526), + (4665184, 600), + (4665784, 553), + (4666337, 526), + (4666863, 600), + (4667463, 554), + (4668017, 525), + (4668542, 593), + (4669135, 554), + (4669689, 524), + (4670213, 604), + (4670817, 553), + (4671370, 525), + (4671895, 605), + (4672500, 553), + (4673053, 525), + (4673578, 571), + (4674149, 552), + (4674701, 526), + (4675227, 587), + (4675814, 553), + (4676367, 524), + (4676891, 587), + (4677478, 554), + (4678032, 525), + (4678557, 589), + (4679146, 554), + (4679700, 525), + (4680225, 600), + (4680825, 552), + (4681377, 524), + (4681901, 600), + (4682501, 553), + (4683054, 526), + (4683580, 594), + (4684174, 554), + (4684728, 525), + (4685253, 607), + (4685860, 554), + (4686414, 526), + (4686940, 606), + (4687546, 554), + (4688100, 524), + (4688624, 585), + (4689209, 553), + (4689762, 525), + (4690287, 600), + (4690887, 554), + (4691441, 525), + (4691966, 599), + (4692565, 553), + (4693118, 524), + (4693642, 600), + (4694242, 554), + (4694796, 525), + (4695321, 612), + (4695933, 553), + (4696486, 526), + (4697012, 611), + (4697623, 553), + (4698176, 525), + (4698701, 606), + (4699307, 553), + (4699860, 525), + (4700385, 618), + (4701003, 552), + (4701555, 525), + (4702080, 618), + (4702698, 553), + (4703251, 526), + (4703777, 585), + (4704362, 553), + (4704915, 525), + (4705440, 600), + (4706040, 552), + (4706592, 525), + (4707117, 599), + (4707716, 554), + (4708270, 525), + (4708795, 600), + (4709395, 554), + (4709949, 525), + (4710474, 611), + (4711085, 553), + (4711638, 525), + (4712163, 612), + (4712775, 553), + (4713328, 525), + (4713853, 607), + (4714460, 553), + (4715013, 525), + (4715538, 618), + (4716156, 553), + (4716709, 525), + (4717234, 617), + (4717851, 553), + (4718404, 525), + (4718929, 576), + (4719505, 553), + (4720058, 525), + (4720583, 589), + (4721172, 553), + (4721725, 526), + (4722251, 590), + (4722841, 553), + (4723394, 526), + (4723920, 590), + (4724510, 552), + (4725062, 525), + (4725587, 602), + (4726189, 554), + (4726743, 525), + (4727268, 602), + (4727870, 553), + (4728423, 525), + (4728948, 596), + (4729544, 552), + (4730096, 525), + (4730621, 608), + (4731229, 552), + (4731781, 525), + (4732306, 609), + (4732915, 553), + (4733468, 526), + (4733994, 587), + (4734581, 554), + (4735135, 525), + (4735660, 601), + (4736261, 553), + (4736814, 525), + (4737339, 601), + (4737940, 554), + (4738494, 526), + (4739020, 603), + (4739623, 553), + (4740176, 524), + (4740700, 615), + (4741315, 552), + (4741867, 524), + (4742391, 615), + (4743006, 552), + (4743558, 524), + (4744082, 608), + (4744690, 553), + (4745243, 526), + (4745769, 621), + (4746390, 553), + (4746943, 525), + (4747468, 619), + (4748087, 554), + (4748641, 525), + (4749166, 587), + (4749753, 553), + (4750306, 526), + (4750832, 601), + (4751433, 554), + (4751987, 524), + (4752511, 601), + (4753112, 553), + (4753665, 525), + (4754190, 601), + (4754791, 554), + (4755345, 525), + (4755870, 615), + (4756485, 552), + (4757037, 526), + (4757563, 613), + (4758176, 552), + (4758728, 525), + (4759253, 609), + (4759862, 553), + (4760415, 526), + (4760941, 620), + (4761561, 554), + (4762115, 526), + (4762641, 619), + (4763260, 554), + (4763814, 525), + (4764339, 541), + (4764880, 552), + (4765432, 526), + (4765958, 570), + (4766528, 553), + (4767081, 525), + (4767606, 570), + (4768176, 553), + (4768729, 526), + (4769255, 571), + (4769826, 553), + (4770379, 525), + (4770904, 585), + (4771489, 552), + (4772041, 524), + (4772565, 585), + (4773150, 552), + (4773702, 525), + (4774227, 579), + (4774806, 552), + (4775358, 526), + (4775884, 591), + (4776475, 553), + (4777028, 526), + (4777554, 591), + (4778145, 553), + (4778698, 525), + (4779223, 570), + (4779793, 554), + (4780347, 524), + (4780871, 587), + (4781458, 552), + (4782010, 524), + (4782534, 587), + (4783121, 553), + (4783674, 525), + (4784199, 586), + (4784785, 553), + (4785338, 526), + (4785864, 599), + (4786463, 554), + (4787017, 525), + (4787542, 600), + (4788142, 552), + (4788694, 525), + (4789219, 593), + (4789812, 553), + (4790365, 524), + (4790889, 605), + (4791494, 553), + (4792047, 526), + (4792573, 604), + (4793177, 553), + (4793730, 526), + (4794256, 571), + (4794827, 552), + (4795379, 526), + (4795905, 586), + (4796491, 553), + (4797044, 525), + (4797569, 586), + (4798155, 553), + (4798708, 525), + (4799233, 586), + (4799819, 553), + (4800372, 525), + (4800897, 598), + (4801495, 553), + (4802048, 524), + (4802572, 598), + (4803170, 554), + (4803724, 524), + (4804248, 593), + (4804841, 553), + (4805394, 525), + (4805919, 605), + (4806524, 552), + (4807076, 525), + (4807601, 606), + (4808207, 552), + (4808759, 525), + (4809284, 572), + (4809856, 553), + (4810409, 524), + (4810933, 588), + (4811521, 552), + (4812073, 525), + (4812598, 587), + (4813185, 553), + (4813738, 523), + (4814261, 588), + (4814849, 553), + (4815402, 525), + (4815927, 600), + (4816527, 553), + (4817080, 524), + (4817604, 600), + (4818204, 552), + (4818756, 525), + (4819281, 593), + (4819874, 553), + (4820427, 525), + (4820952, 606), + (4821558, 554), + (4822112, 526), + (4822638, 606), + (4823244, 554), + (4823798, 525), + (4824323, 585), + (4824908, 553), + (4825461, 525), + (4825986, 598), + (4826584, 553), + (4827137, 526), + (4827663, 599), + (4828262, 552), + (4828814, 525), + (4829339, 599), + (4829938, 552), + (4830490, 524), + (4831014, 612), + (4831626, 553), + (4832179, 525), + (4832704, 611), + (4833315, 552), + (4833867, 526), + (4834393, 606), + (4834999, 552), + (4835551, 526), + (4836077, 618), + (4836695, 554), + (4837249, 525), + (4837774, 619), + (4838393, 553), + (4838946, 525), + (4839471, 584), + (4840055, 553), + (4840608, 525), + (4841133, 600), + (4841733, 554), + (4842287, 524), + (4842811, 599), + (4843410, 553), + (4843963, 525), + (4844488, 600), + (4845088, 554), + (4845642, 524), + (4846166, 613), + (4846779, 552), + (4847331, 525), + (4847856, 613), + (4848469, 552), + (4849021, 525), + (4849546, 605), + (4850151, 553), + (4850704, 524), + (4851228, 619), + (4851847, 553), + (4852400, 524), + (4852924, 618), + (4853542, 553), + (4854095, 525), + (4854620, 575), + (4855195, 553), + (4855748, 524), + (4856272, 588), + (4856860, 552), + (4857412, 525), + (4857937, 590), + (4858527, 554), + (4859081, 525), + (4859606, 589), + (4860195, 553), + (4860748, 525), + (4861273, 601), + (4861874, 552), + (4862426, 524), + (4862950, 602), + (4863552, 553), + (4864105, 525), + (4864630, 596), + (4865226, 552), + (4865778, 524), + (4866302, 607), + (4866909, 553), + (4867462, 525), + (4867987, 608), + (4868595, 552), + (4869147, 526), + (4869673, 587), + (4870260, 552), + (4870812, 526), + (4871338, 601), + (4871939, 553), + (4872492, 525), + (4873017, 601), + (4873618, 553), + (4874171, 525), + (4874696, 603), + (4875299, 552), + (4875851, 525), + (4876376, 614), + (4876990, 554), + (4877544, 525), + (4878069, 613), + (4878682, 553), + (4879235, 525), + (4879760, 607), + (4880367, 553), + (4880920, 525), + (4881445, 621), + (4882066, 553), + (4882619, 524), + (4883143, 621), + (4883764, 553), + (4884317, 526), + (4884843, 587), + (4885430, 554), + (4885984, 526), + (4886510, 601), + (4887111, 554), + (4887665, 525), + (4888190, 602), + (4888792, 552), + (4889344, 525), + (4889869, 601), + (4890470, 552), + (4891022, 525), + (4891547, 615), + (4892162, 553), + (4892715, 525), + (4893240, 613), + (4893853, 553), + (4894406, 524), + (4894930, 608), + (4895538, 554), + (4896092, 525), + (4896617, 620), + (4897237, 554), + (4897791, 525), + (4898316, 620), + (4898936, 554), + (4899490, 536), + (4900026, 542), + (4900568, 553), + (4901121, 535), + (4901656, 570), + (4902226, 552), + (4902778, 535), + (4903313, 569), + (4903882, 553), + (4904435, 535), + (4904970, 573), + (4905543, 552), + (4906095, 534), + (4906629, 585), + (4907214, 553), + (4907767, 535), + (4908302, 584), + (4908886, 552), + (4909438, 535), + (4909973, 579), + (4910552, 554), + (4911106, 536), + (4911642, 591), + (4912233, 554), + (4912787, 536), + (4913323, 590), + (4913913, 552), + (4914465, 535), + (4915000, 570), + (4915570, 553), + (4916123, 534), + (4916657, 587), + (4917244, 552), + (4917796, 535), + (4918331, 586), + (4918917, 553), + (4919470, 535), + (4920005, 588), + (4920593, 554), + (4921147, 535), + (4921682, 600), + (4922282, 553), + (4922835, 535), + (4923370, 599), + (4923969, 552), + (4924521, 534), + (4925055, 592), + (4925647, 553), + (4926200, 536), + (4926736, 604), + (4927340, 553), + (4927893, 535), + (4928428, 605), + (4929033, 554), + (4929587, 535), + (4930122, 570), + (4930692, 554), + (4931246, 536), + (4931782, 585), + (4932367, 554), + (4932921, 534), + (4933455, 586), + (4934041, 554), + (4934595, 534), + (4935129, 586), + (4935715, 554), + (4936269, 535), + (4936804, 599), + (4937403, 553), + (4937956, 535), + (4938491, 599), + (4939090, 553), + (4939643, 535), + (4940178, 593), + (4940771, 554), + (4941325, 535), + (4941860, 604), + (4942464, 553), + (4943017, 534), + (4943551, 605), + (4944156, 553), + (4944709, 534), + (4945243, 572), + (4945815, 552), + (4946367, 534), + (4946901, 588), + (4947489, 554), + (4948043, 534), + (4948577, 587), + (4949164, 554), + (4949718, 535), + (4950253, 587), + (4950840, 552), + (4951392, 534), + (4951926, 600), + (4952526, 552), + (4953078, 535), + (4953613, 600), + (4954213, 553), + (4954766, 535), + (4955301, 594), + (4955895, 553), + (4956448, 535), + (4956983, 606), + (4957589, 552), + (4958141, 535), + (4958676, 606), + (4959282, 552), + (4959834, 535), + (4960369, 584), + (4960953, 553), + (4961506, 534), + (4962040, 599), + (4962639, 554), + (4963193, 535), + (4963728, 600), + (4964328, 553), + (4964881, 534), + (4965415, 600), + (4966015, 552), + (4966567, 535), + (4967102, 611), + (4967713, 554), + (4968267, 536), + (4968803, 612), + (4969415, 553), + (4969968, 534), + (4970502, 606), + (4971108, 552), + (4971660, 536), + (4972196, 618), + (4972814, 554), + (4973368, 535), + (4973903, 617), + (4974520, 553), + (4975073, 535), + (4975608, 586), + (4976194, 552), + (4976746, 536), + (4977282, 599), + (4977881, 553), + (4978434, 536), + (4978970, 598), + (4979568, 554), + (4980122, 535), + (4980657, 600), + (4981257, 553), + (4981810, 535), + (4982345, 613), + (4982958, 554), + (4983512, 534), + (4984046, 613), + (4984659, 554), + (4985213, 535), + (4985748, 606), + (4986354, 553), + (4986907, 535), + (4987442, 618), + (4988060, 552), + (4988612, 536), + (4989148, 617), + (4989765, 552), + (4990317, 536), + (4990853, 576), + (4991429, 554), + (4991983, 535), + (4992518, 589), + (4993107, 552), + (4993659, 536), + (4994195, 590), + (4994785, 553), + (4995338, 535), + (4995873, 591), + (4996464, 553), + (4997017, 536), + (4997553, 603), + (4998156, 554), + (4998710, 534), + (4999244, 601), + (4999845, 552), + (5000397, 536), + (5000933, 595), + (5001528, 552), + (5002080, 535), + (5002615, 608), + (5003223, 553), + (5003776, 535), + (5004311, 608), + (5004919, 553), + (5005472, 534), + (5006006, 586), + (5006592, 552), + (5007144, 535), + (5007679, 602), + (5008281, 553), + (5008834, 536), + (5009370, 601), + (5009971, 553), + (5010524, 535), + (5011059, 601), + (5011660, 553), + (5012213, 535), + (5012748, 613), + (5013361, 554), + (5013915, 534), + (5014449, 615), + (5015064, 553), + (5015617, 536), + (5016153, 608), + (5016761, 553), + (5017314, 535), + (5017849, 621), + (5018470, 553), + (5019023, 535), + (5019558, 620), + (5020178, 552), + (5020730, 535), + (5021265, 587), + (5021852, 552), + (5022404, 534), + (5022938, 602), + (5023540, 554), + (5024094, 534), + (5024628, 601), + (5025229, 554), + (5025783, 535), + (5026318, 603), + (5026921, 553), + (5027474, 534), + (5028008, 613), + (5028621, 553), + (5029174, 535), + (5029709, 614), + (5030323, 553), + (5030876, 535), + (5031411, 608), + (5032019, 553), + (5032572, 534), + (5033106, 620), + (5033726, 554), + (5034280, 535), + (5034815, 621), + (5035436, 553), + (5035989, 541), + (5036530, 542), + (5037072, 553), + (5037625, 541), + (5038166, 570), + (5038736, 553), + (5039289, 542), + (5039831, 569), + (5040400, 553), + (5040953, 542), + (5041495, 571), + (5042066, 552), + (5042618, 540), + (5043158, 584), + (5043742, 554), + (5044296, 542), + (5044838, 584), + (5045422, 554), + (5045976, 541), + (5046517, 578), + (5047095, 552), + (5047647, 541), + (5048188, 591), + (5048779, 552), + (5049331, 541), + (5049872, 591), + (5050463, 554), + (5051017, 541), + (5051558, 570), + (5052128, 554), + (5052682, 541), + (5053223, 587), + (5053810, 553), + (5054363, 540), + (5054903, 585), + (5055488, 553), + (5056041, 541), + (5056582, 587), + (5057169, 552), + (5057721, 541), + (5058262, 599), + (5058861, 552), + (5059413, 542), + (5059955, 599), + (5060554, 553), + (5061107, 540), + (5061647, 593), + (5062240, 553), + (5062793, 541), + (5063334, 606), + (5063940, 552), + (5064492, 542), + (5065034, 605), + (5065639, 553), + (5066192, 540), + (5066732, 570), + (5067302, 553), + (5067855, 540), + (5068395, 587), + (5068982, 553), + (5069535, 542), + (5070077, 587), + (5070664, 554), + (5071218, 542), + (5071760, 586), + (5072346, 553), + (5072899, 542), + (5073441, 599), + (5074040, 553), + (5074593, 542), + (5075135, 598), + (5075733, 553), + (5076286, 540), + (5076826, 592), + (5077418, 554), + (5077972, 541), + (5078513, 605), + (5079118, 553), + (5079671, 541), + (5080212, 604), + (5080816, 553), + (5081369, 541), + (5081910, 572), + (5082482, 553), + (5083035, 540), + (5083575, 586), + (5084161, 552), + (5084713, 542), + (5085255, 588), + (5085843, 552), + (5086395, 542), + (5086937, 587), + (5087524, 552), + (5088076, 541), + (5088617, 601), + (5089218, 553), + (5089771, 541), + (5090312, 600), + (5090912, 553), + (5091465, 541), + (5092006, 594), + (5092600, 552), + (5093152, 540), + (5093692, 605), + (5094297, 552), + (5094849, 542), + (5095391, 605), + (5095996, 553), + (5096549, 541), + (5097090, 586), + (5097676, 552), + (5098228, 541), + (5098769, 599), + (5099368, 554), + (5099922, 541), + (5100463, 600), + (5101063, 554), + (5101617, 542), + (5102159, 600), + (5102759, 553), + (5103312, 540), + (5103852, 611), + (5104463, 554), + (5105017, 542), + (5105559, 612), + (5106171, 554), + (5106725, 541), + (5107266, 605), + (5107871, 553), + (5108424, 542), + (5108966, 619), + (5109585, 553), + (5110138, 541), + (5110679, 618), + (5111297, 553), + (5111850, 542), + (5112392, 584), + (5112976, 552), + (5113528, 541), + (5114069, 599), + (5114668, 553), + (5115221, 540), + (5115761, 600), + (5116361, 553), + (5116914, 541), + (5117455, 600), + (5118055, 552), + (5118607, 540), + (5119147, 611), + (5119758, 552), + (5120310, 540), + (5120850, 612), + (5121462, 554), + (5122016, 541), + (5122557, 606), + (5123163, 552), + (5123715, 540), + (5124255, 617), + (5124872, 552), + (5125424, 540), + (5125964, 617), + (5126581, 552), + (5127133, 541), + (5127674, 576), + (5128250, 552), + (5128802, 540), + (5129342, 589), + (5129931, 553), + (5130484, 541), + (5131025, 589), + (5131614, 552), + (5132166, 542), + (5132708, 590), + (5133298, 554), + (5133852, 542), + (5134394, 602), + (5134996, 553), + (5135549, 541), + (5136090, 601), + (5136691, 553), + (5137244, 541), + (5137785, 595), + (5138380, 553), + (5138933, 541), + (5139474, 609), + (5140083, 553), + (5140636, 541), + (5141177, 608), + (5141785, 553), + (5142338, 540), + (5142878, 586), + (5143464, 553), + (5144017, 541), + (5144558, 600), + (5145158, 553), + (5145711, 542), + (5146253, 600), + (5146853, 552), + (5147405, 541), + (5147946, 602), + (5148548, 553), + (5149101, 540), + (5149641, 614), + (5150255, 553), + (5150808, 541), + (5151349, 615), + (5151964, 553), + (5152517, 540), + (5153057, 608), + (5153665, 553), + (5154218, 541), + (5154759, 620), + (5155379, 553), + (5155932, 541), + (5156473, 620), + (5157093, 553), + (5157646, 542), + (5158188, 587), + (5158775, 553), + (5159328, 541), + (5159869, 601), + (5160470, 553), + (5161023, 542), + (5161565, 602), + (5162167, 553), + (5162720, 541), + (5163261, 602), + (5163863, 554), + (5164417, 540), + (5164957, 613), + (5165570, 553), + (5166123, 542), + (5166665, 613), + (5167278, 552), + (5167830, 542), + (5168372, 609), + (5168981, 554), + (5169535, 542), + (5170077, 620), + (5170697, 553), + (5171250, 541), + (5171791, 621), + (5172412, 553), + (5172965, 541), + (5173506, 543), + (5174049, 552), + (5174601, 541), + (5175142, 570), + (5175712, 554), + (5176266, 540), + (5176806, 570), + (5177376, 553), + (5177929, 541), + (5178470, 572), + (5179042, 553), + (5179595, 541), + (5180136, 585), + (5180721, 552), + (5181273, 542), + (5181815, 585), + (5182400, 552), + (5182952, 540), + (5183492, 579), + (5184071, 553), + (5184624, 540), + (5185164, 592), + (5185756, 553), + (5186309, 540), + (5186849, 592), + (5187441, 551), + (5187992, 541), + (5188533, 570), + (5189103, 553), + (5189656, 541), + (5190197, 586), + (5190783, 552), + (5191335, 542), + (5191877, 587), + (5192464, 552), + (5193016, 541), + (5193557, 588), + (5194145, 554), + (5194699, 541), + (5195240, 600), + (5195840, 553), + (5196393, 540), + (5196933, 600), + (5197533, 554), + (5198087, 540), + (5198627, 594), + (5199221, 552), + (5199773, 541), + (5200314, 605), + (5200919, 553), + (5201472, 542), + (5202014, 605), + (5202619, 554), + (5203173, 541), + (5203714, 569), + (5204283, 552), + (5204835, 540), + (5205375, 587), + (5205962, 553), + (5206515, 542), + (5207057, 586), + (5207643, 552), + (5208195, 541), + (5208736, 586), + (5209322, 554), + (5209876, 542), + (5210418, 598), + (5211016, 553), + (5211569, 540), + (5212109, 600), + (5212709, 554), + (5213263, 541), + (5213804, 593), + (5214397, 553), + (5214950, 540), + (5215490, 605), + (5216095, 554), + (5216649, 541), + (5217190, 605), + (5217795, 553), + (5218348, 541), + (5218889, 573), + (5219462, 553), + (5220015, 541), + (5220556, 587), + (5221143, 554), + (5221697, 540), + (5222237, 587), + (5222824, 552), + (5223376, 542), + (5223918, 588), + (5224506, 553), + (5225059, 541), + (5225600, 600), + (5226200, 554), + (5226754, 542), + (5227296, 600), + (5227896, 553), + (5228449, 541), + (5228990, 595), + (5229585, 552), + (5230137, 541), + (5230678, 606), + (5231284, 553), + (5231837, 541), + (5232378, 606), + (5232984, 553), + (5233537, 540), + (5234077, 584), + (5234661, 552), + (5235213, 540), + (5235753, 599), + (5236352, 552), + (5236904, 541), + (5237445, 600), + (5238045, 553), + (5238598, 542), + (5239140, 599), + (5239739, 553), + (5240292, 541), + (5240833, 612), + (5241445, 553), + (5241998, 542), + (5242540, 611), + (5243151, 553), + (5243704, 540), + (5244244, 606), + (5244850, 552), + (5245402, 541), + (5245943, 618), + (5246561, 554), + (5247115, 541), + (5247656, 617), + (5248273, 553), + (5248826, 542), + (5249368, 586), + (5249954, 552), + (5250506, 541), + (5251047, 599), + (5251646, 553), + (5252199, 541), + (5252740, 599), + (5253339, 554), + (5253893, 541), + (5254434, 601), + (5255035, 553), + (5255588, 540), + (5256128, 612), + (5256740, 553), + (5257293, 541), + (5257834, 611), + (5258445, 553), + (5258998, 541), + (5259539, 606), + (5260145, 553), + (5260698, 540), + (5261238, 619), + (5261857, 553), + (5262410, 542), + (5262952, 618), + (5263570, 552), + (5264122, 541), + (5264663, 576), + (5265239, 553), + (5265792, 542), + (5266334, 589), + (5266923, 554), + (5267477, 541), + (5268018, 589), + (5268607, 553), + (5269160, 541), + (5269701, 591), + (5270292, 552), + (5270844, 540), + (5271384, 602), + (5271986, 554), + (5272540, 541), + (5273081, 602), + (5273683, 553), + (5274236, 540), + (5274776, 596), + (5275372, 554), + (5275926, 540), + (5276466, 609), + (5277075, 552), + (5277627, 540), + (5278167, 608), + (5278775, 554), + (5279329, 541), + (5279870, 587), + (5280457, 553), + (5281010, 541), + (5281551, 601), + (5282152, 553), + (5282705, 542), + (5283247, 602), + (5283849, 553), + (5284402, 540), + (5284942, 603), + (5285545, 553), + (5286098, 541), + (5286639, 614), + (5287253, 553), + (5287806, 542), + (5288348, 614), + (5288962, 554), + (5289516, 540), + (5290056, 608), + (5290664, 553), + (5291217, 542), + (5291759, 620), + (5292379, 553), + (5292932, 541), + (5293473, 619), + (5294092, 554), + (5294646, 541), + (5295187, 587), + (5295774, 552), + (5296326, 540), + (5296866, 600), + (5297466, 554), + (5298020, 540), + (5298560, 600), + (5299160, 553), + (5299713, 541), + (5300254, 602), + (5300856, 553), + (5301409, 541), + (5301950, 614), + (5302564, 552), + (5303116, 541), + (5303657, 614), + (5304271, 553), + (5304824, 542), + (5305366, 609), + (5305975, 554), + (5306529, 541), + (5307070, 621), + (5307691, 552), + (5308243, 541), + (5308784, 621), + (5309405, 553), + (5309958, 537), + (5310495, 542), + (5311037, 553), + (5311590, 535), + (5312125, 571), + (5312696, 553), + (5313249, 536), + (5313785, 570), + (5314355, 554), + (5314909, 537), + (5315446, 572), + (5316018, 552), + (5316570, 537), + (5317107, 585), + (5317692, 554), + (5318246, 537), + (5318783, 584), + (5319367, 553), + (5319920, 535), + (5320455, 579), + (5321034, 552), + (5321586, 537), + (5322123, 591), + (5322714, 554), + (5323268, 536), + (5323804, 591), + (5324395, 552), + (5324947, 535), + (5325482, 571), + (5326053, 554), + (5326607, 537), + (5327144, 585), + (5327729, 553), + (5328282, 535), + (5328817, 586), + (5329403, 552), + (5329955, 537), + (5330492, 588), + (5331080, 553), + (5331633, 537), + (5332170, 599), + (5332769, 552), + (5333321, 536), + (5333857, 598), + (5334455, 552), + (5335007, 536), + (5335543, 593), + (5336136, 552), + (5336688, 537), + (5337225, 606), + (5337831, 554), + (5338385, 537), + (5338922, 606), + (5339528, 553), + (5340081, 537), + (5340618, 570), + (5341188, 552), + (5341740, 536), + (5342276, 585), + (5342861, 552), + (5343413, 537), + (5343950, 586), + (5344536, 554), + (5345090, 535), + (5345625, 587), + (5346212, 552), + (5346764, 536), + (5347300, 599), + (5347899, 554), + (5348453, 537), + (5348990, 599), + (5349589, 553), + (5350142, 535), + (5350677, 592), + (5351269, 554), + (5351823, 537), + (5352360, 606), + (5352966, 554), + (5353520, 536), + (5354056, 604), + (5354660, 553), + (5355213, 536), + (5355749, 572), + (5356321, 554), + (5356875, 536), + (5357411, 588), + (5357999, 553), + (5358552, 536), + (5359088, 588), + (5359676, 552), + (5360228, 535), + (5360763, 588), + (5361351, 554), + (5361905, 536), + (5362441, 601), + (5363042, 553), + (5363595, 535), + (5364130, 599), + (5364729, 554), + (5365283, 537), + (5365820, 595), + (5366415, 552), + (5366967, 536), + (5367503, 606), + (5368109, 553), + (5368662, 536), + (5369198, 605), + (5369803, 553), + (5370356, 536), + (5370892, 584), + (5371476, 554), + (5372030, 536), + (5372566, 600), + (5373166, 553), + (5373719, 535), + (5374254, 599), + (5374853, 553), + (5375406, 536), + (5375942, 601), + (5376543, 554), + (5377097, 536), + (5377633, 612), + (5378245, 553), + (5378798, 536), + (5379334, 612), + (5379946, 552), + (5380498, 537), + (5381035, 607), + (5381642, 553), + (5382195, 536), + (5382731, 617), + (5383348, 553), + (5383901, 537), + (5384438, 618), + (5385056, 553), + (5385609, 536), + (5386145, 584), + (5386729, 552), + (5387281, 537), + (5387818, 599), + (5388417, 552), + (5388969, 535), + (5389504, 599), + (5390103, 553), + (5390656, 537), + (5391193, 601), + (5391794, 553), + (5392347, 535), + (5392882, 611), + (5393493, 553), + (5394046, 535), + (5394581, 612), + (5395193, 554), + (5395747, 536), + (5396283, 607), + (5396890, 554), + (5397444, 536), + (5397980, 618), + (5398598, 554), + (5399152, 535), + (5399687, 618), + (5400305, 553), + (5400858, 536), + (5401394, 575), + (5401969, 554), + (5402523, 536), + (5403059, 589), + (5403648, 554), + (5404202, 537), + (5404739, 590), + (5405329, 553), + (5405882, 537), + (5406419, 590), + (5407009, 552), + (5407561, 535), + (5408096, 603), + (5408699, 553), + (5409252, 537), + (5409789, 602), + (5410391, 553), + (5410944, 537), + (5411481, 596), + (5412077, 552), + (5412629, 535), + (5413164, 607), + (5413771, 553), + (5414324, 537), + (5414861, 608), + (5415469, 553), + (5416022, 536), + (5416558, 587), + (5417145, 553), + (5417698, 536), + (5418234, 600), + (5418834, 552), + (5419386, 537), + (5419923, 601), + (5420524, 554), + (5421078, 537), + (5421615, 602), + (5422217, 552), + (5422769, 536), + (5423305, 615), + (5423920, 552), + (5424472, 536), + (5425008, 614), + (5425622, 553), + (5426175, 536), + (5426711, 607), + (5427318, 554), + (5427872, 535), + (5428407, 621), + (5429028, 553), + (5429581, 536), + (5430117, 620), + (5430737, 553), + (5431290, 535), + (5431825, 588), + (5432413, 553), + (5432966, 535), + (5433501, 601), + (5434102, 554), + (5434656, 537), + (5435193, 601), + (5435794, 553), + (5436347, 537), + (5436884, 603), + (5437487, 552), + (5438039, 536), + (5438575, 615), + (5439190, 552), + (5439742, 535), + (5440277, 614), + (5440891, 553), + (5441444, 536), + (5441980, 608), + (5442588, 554), + (5443142, 535), + (5443677, 621), + (5444298, 552), + (5444850, 537), + (5445387, 619), + (5446006, 554), + (5446560, 542), + (5447102, 542), + (5447644, 554), + (5448198, 541), + (5448739, 571), + (5449310, 552), + (5449862, 542), + (5450404, 569), + (5450973, 554), + (5451527, 541), + (5452068, 573), + (5452641, 553), + (5453194, 543), + (5453737, 585), + (5454322, 553), + (5454875, 542), + (5455417, 585), + (5456002, 552), + (5456554, 542), + (5457096, 579), + (5457675, 552), + (5458227, 541), + (5458768, 591), + (5459359, 554), + (5459913, 541), + (5460454, 590), + (5461044, 552), + (5461596, 541), + (5462137, 570), + (5462707, 554), + (5463261, 542), + (5463803, 586), + (5464389, 552), + (5464941, 541), + (5465482, 586), + (5466068, 552), + (5466620, 541), + (5467161, 588), + (5467749, 552), + (5468301, 543), + (5468844, 599), + (5469443, 553), + (5469996, 542), + (5470538, 600), + (5471138, 553), + (5471691, 542), + (5472233, 593), + (5472826, 553), + (5473379, 542), + (5473921, 605), + (5474526, 553), + (5475079, 541), + (5475620, 604), + (5476224, 554), + (5476778, 541), + (5477319, 570), + (5477889, 554), + (5478443, 542), + (5478985, 587), + (5479572, 552), + (5480124, 542), + (5480666, 586), + (5481252, 552), + (5481804, 542), + (5482346, 588), + (5482934, 554), + (5483488, 542), + (5484030, 600), + (5484630, 554), + (5485184, 542), + (5485726, 598), + (5486324, 554), + (5486878, 542), + (5487420, 593), + (5488013, 554), + (5488567, 542), + (5489109, 605), + (5489714, 552), + (5490266, 543), + (5490809, 605), + (5491414, 553), + (5491967, 543), + (5492510, 572), + (5493082, 553), + (5493635, 543), + (5494178, 587), + (5494765, 553), + (5495318, 541), + (5495859, 587), + (5496446, 553), + (5496999, 542), + (5497541, 587), + (5498128, 552), + (5498680, 541), + (5499221, 600), + (5499821, 552), + (5500373, 543), + (5500916, 600), + (5501516, 553), + (5502069, 541), + (5502610, 594), + (5503204, 554), + (5503758, 541), + (5504299, 605), + (5504904, 553), + (5505457, 542), + (5505999, 607), + (5506606, 552), + (5507158, 543), + (5507701, 586), + (5508287, 553), + (5508840, 542), + (5509382, 599), + (5509981, 553), + (5510534, 543), + (5511077, 598), + (5511675, 554), + (5512229, 541), + (5512770, 600), + (5513370, 554), + (5513924, 542), + (5514466, 612), + (5515078, 552), + (5515630, 543), + (5516173, 611), + (5516784, 553), + (5517337, 542), + (5517879, 605), + (5518484, 553), + (5519037, 541), + (5519578, 618), + (5520196, 554), + (5520750, 541), + (5521291, 617), + (5521908, 553), + (5522461, 542), + (5523003, 585), + (5523588, 552), + (5524140, 542), + (5524682, 598), + (5525280, 553), + (5525833, 541), + (5526374, 598), + (5526972, 553), + (5527525, 543), + (5528068, 600), + (5528668, 554), + (5529222, 542), + (5529764, 613), + (5530377, 552), + (5530929, 541), + (5531470, 612), + (5532082, 553), + (5532635, 543), + (5533178, 607), + (5533785, 552), + (5534337, 543), + (5534880, 618), + (5535498, 553), + (5536051, 542), + (5536593, 619), + (5537212, 553), + (5537765, 542), + (5538307, 574), + (5538881, 553), + (5539434, 542), + (5539976, 589), + (5540565, 553), + (5541118, 543), + (5541661, 589), + (5542250, 552), + (5542802, 541), + (5543343, 590), + (5543933, 553), + (5544486, 542), + (5545028, 602), + (5545630, 552), + (5546182, 542), + (5546724, 602), + (5547326, 554), + (5547880, 542), + (5548422, 596), + (5549018, 554), + (5549572, 541), + (5550113, 608), + (5550721, 554), + (5551275, 542), + (5551817, 608), + (5552425, 554), + (5552979, 542), + (5553521, 587), + (5554108, 552), + (5554660, 541), + (5555201, 600), + (5555801, 554), + (5556355, 543), + (5556898, 600), + (5557498, 554), + (5558052, 542), + (5558594, 601), + (5559195, 552), + (5559747, 542), + (5560289, 614), + (5560903, 554), + (5561457, 541), + (5561998, 615), + (5562613, 553), + (5563166, 542), + (5563708, 607), + (5564315, 554), + (5564869, 543), + (5565412, 619), + (5566031, 552), + (5566583, 543), + (5567126, 620), + (5567746, 553), + (5568299, 542), + (5568841, 586), + (5569427, 552), + (5569979, 542), + (5570521, 602), + (5571123, 553), + (5571676, 542), + (5572218, 601), + (5572819, 553), + (5573372, 541), + (5573913, 601), + (5574514, 552), + (5575066, 543), + (5575609, 613), + (5576222, 553), + (5576775, 541), + (5577316, 614), + (5577930, 554), + (5578484, 541), + (5579025, 608), + (5579633, 552), + (5580185, 542), + (5580727, 621), + (5581348, 554), + (5581902, 541), + (5582443, 620), + (5583063, 554), + (5583617, 541), + (5584158, 543), + (5584701, 554), + (5585255, 541), + (5585796, 570), + (5586366, 553), + (5586919, 543), + (5587462, 570), + (5588032, 553), + (5588585, 541), + (5589126, 572), + (5589698, 554), + (5590252, 542), + (5590794, 584), + (5591378, 553), + (5591931, 541), + (5592472, 586), + (5593058, 554), + (5593612, 542), + (5594154, 579), + (5594733, 554), + (5595287, 542), + (5595829, 590), + (5596419, 552), + (5596971, 542), + (5597513, 591), + (5598104, 554), + (5598658, 542), + (5599200, 570), + (5599770, 554), + (5600324, 543), + (5600867, 586), + (5601453, 552), + (5602005, 542), + (5602547, 584), + (5603131, 553), + (5603684, 541), + (5604225, 587), + (5604812, 552), + (5605364, 541), + (5605905, 600), + (5606505, 552), + (5607057, 542), + (5607599, 600), + (5608199, 554), + (5608753, 542), + (5609295, 593), + (5609888, 552), + (5610440, 542), + (5610982, 605), + (5611587, 553), + (5612140, 543), + (5612683, 605), + (5613288, 554), + (5613842, 541), + (5614383, 570), + (5614953, 553), + (5615506, 543), + (5616049, 586), + (5616635, 552), + (5617187, 542), + (5617729, 585), + (5618314, 553), + (5618867, 542), + (5619409, 587), + (5619996, 553), + (5620549, 543), + (5621092, 599), + (5621691, 553), + (5622244, 543), + (5622787, 599), + (5623386, 552), + (5623938, 542), + (5624480, 593), + (5625073, 553), + (5625626, 542), + (5626168, 605), + (5626773, 553), + (5627326, 542), + (5627868, 605), + (5628473, 553), + (5629026, 542), + (5629568, 572), + (5630140, 554), + (5630694, 542), + (5631236, 588), + (5631824, 553), + (5632377, 543), + (5632920, 586), + (5633506, 553), + (5634059, 542), + (5634601, 588), + (5635189, 554), + (5635743, 542), + (5636285, 601), + (5636886, 554), + (5637440, 541), + (5637981, 600), + (5638581, 554), + (5639135, 542), + (5639677, 595), + (5640272, 553), + (5640825, 542), + (5641367, 606), + (5641973, 553), + (5642526, 542), + (5643068, 605), + (5643673, 553), + (5644226, 541), + (5644767, 585), + (5645352, 552), + (5645904, 541), + (5646445, 600), + (5647045, 552), + (5647597, 542), + (5648139, 600), + (5648739, 553), + (5649292, 541), + (5649833, 599), + (5650432, 553), + (5650985, 542), + (5651527, 613), + (5652140, 553), + (5652693, 541), + (5653234, 611), + (5653845, 552), + (5654397, 542), + (5654939, 607), + (5655546, 552), + (5656098, 542), + (5656640, 617), + (5657257, 552), + (5657809, 542), + (5658351, 618), + (5658969, 553), + (5659522, 542), + (5660064, 585), + (5660649, 553), + (5661202, 542), + (5661744, 599), + (5662343, 553), + (5662896, 543), + (5663439, 598), + (5664037, 554), + (5664591, 543), + (5665134, 600), + (5665734, 553), + (5666287, 542), + (5666829, 612), + (5667441, 554), + (5667995, 542), + (5668537, 611), + (5669148, 554), + (5669702, 541), + (5670243, 605), + (5670848, 554), + (5671402, 542), + (5671944, 617), + (5672561, 553), + (5673114, 542), + (5673656, 618), + (5674274, 552), + (5674826, 542), + (5675368, 576), + (5675944, 553), + (5676497, 543), + (5677040, 588), + (5677628, 553), + (5678181, 542), + (5678723, 589), + (5679312, 554), + (5679866, 542), + (5680408, 590), + (5680998, 553), + (5681551, 542), + (5682093, 603), + (5682696, 553), + (5683249, 541), + (5683790, 603), + (5684393, 553), + (5684946, 543), + (5685489, 596), + (5686085, 552), + (5686637, 542), + (5687179, 607), + (5687786, 553), + (5688339, 541), + (5688880, 608), + (5689488, 553), + (5690041, 542), + (5690583, 587), + (5691170, 554), + (5691724, 542), + (5692266, 600), + (5692866, 554), + (5693420, 543), + (5693963, 600), + (5694563, 554), + (5695117, 542), + (5695659, 602), + (5696261, 552), + (5696813, 542), + (5697355, 614), + (5697969, 552), + (5698521, 543), + (5699064, 615), + (5699679, 553), + (5700232, 542), + (5700774, 608), + (5701382, 553), + (5701935, 542), + (5702477, 620), + (5703097, 554), + (5703651, 542), + (5704193, 621), + (5704814, 554), + (5705368, 542), + (5705910, 586), + (5706496, 552), + (5707048, 543), + (5707591, 601), + (5708192, 554), + (5708746, 541), + (5709287, 601), + (5709888, 553), + (5710441, 541), + (5710982, 603), + (5711585, 554), + (5712139, 542), + (5712681, 614), + (5713295, 552), + (5713847, 543), + (5714390, 614), + (5715004, 553), + (5715557, 542), + (5716099, 609), + (5716708, 553), + (5717261, 542), + (5717803, 621), + (5718424, 552), + (5718976, 542), + (5719518, 620), + (5720138, 553), + (5720691, 528), + (5721219, 542), + (5721761, 553), + (5722314, 529), + (5722843, 570), + (5723413, 554), + (5723967, 528), + (5724495, 569), + (5725064, 554), + (5725618, 528), + (5726146, 572), + (5726718, 553), + (5727271, 527), + (5727798, 586), + (5728384, 553), + (5728937, 529), + (5729466, 585), + (5730051, 553), + (5730604, 529), + (5731133, 579), + (5731712, 552), + (5732264, 528), + (5732792, 591), + (5733383, 553), + (5733936, 528), + (5734464, 590), + (5735054, 553), + (5735607, 528), + (5736135, 570), + (5736705, 553), + (5737258, 528), + (5737786, 586), + (5738372, 552), + (5738924, 528), + (5739452, 587), + (5740039, 552), + (5740591, 529), + (5741120, 587), + (5741707, 553), + (5742260, 529), + (5742789, 599), + (5743388, 554), + (5743942, 528), + (5744470, 600), + (5745070, 553), + (5745623, 528), + (5746151, 593), + (5746744, 553), + (5747297, 528), + (5747825, 606), + (5748431, 553), + (5748984, 527), + (5749511, 605), + (5750116, 553), + (5750669, 528), + (5751197, 570), + (5751767, 553), + (5752320, 527), + (5752847, 585), + (5753432, 552), + (5753984, 529), + (5754513, 586), + (5755099, 554), + (5755653, 528), + (5756181, 587), + (5756768, 553), + (5757321, 529), + (5757850, 599), + (5758449, 552), + (5759001, 528), + (5759529, 599), + (5760128, 552), + (5760680, 527), + (5761207, 592), + (5761799, 554), + (5762353, 529), + (5762882, 605), + (5763487, 554), + (5764041, 529), + (5764570, 604), + (5765174, 553), + (5765727, 527), + (5766254, 572), + (5766826, 552), + (5767378, 528), + (5767906, 587), + (5768493, 553), + (5769046, 528), + (5769574, 586), + (5770160, 553), + (5770713, 528), + (5771241, 588), + (5771829, 554), + (5772383, 528), + (5772911, 600), + (5773511, 554), + (5774065, 529), + (5774594, 600), + (5775194, 553), + (5775747, 528), + (5776275, 594), + (5776869, 552), + (5777421, 529), + (5777950, 606), + (5778556, 554), + (5779110, 527), + (5779637, 606), + (5780243, 552), + (5780795, 527), + (5781322, 585), + (5781907, 552), + (5782459, 529), + (5782988, 600), + (5783588, 553), + (5784141, 528), + (5784669, 599), + (5785268, 553), + (5785821, 527), + (5786348, 600), + (5786948, 554), + (5787502, 528), + (5788030, 611), + (5788641, 553), + (5789194, 528), + (5789722, 613), + (5790335, 553), + (5790888, 528), + (5791416, 606), + (5792022, 554), + (5792576, 527), + (5793103, 618), + (5793721, 553), + (5794274, 529), + (5794803, 619), + (5795422, 553), + (5795975, 528), + (5796503, 585), + (5797088, 552), + (5797640, 528), + (5798168, 600), + (5798768, 552), + (5799320, 528), + (5799848, 598), + (5800446, 553), + (5800999, 528), + (5801527, 601), + (5802128, 552), + (5802680, 529), + (5803209, 612), + (5803821, 552), + (5804373, 528), + (5804901, 611), + (5805512, 553), + (5806065, 528), + (5806593, 607), + (5807200, 553), + (5807753, 528), + (5808281, 617), + (5808898, 553), + (5809451, 527), + (5809978, 618), + (5810596, 553), + (5811149, 528), + (5811677, 574), + (5812251, 553), + (5812804, 527), + (5813331, 589), + (5813920, 554), + (5814474, 529), + (5815003, 588), + (5815591, 554), + (5816145, 528), + (5816673, 590), + (5817263, 553), + (5817816, 527), + (5818343, 603), + (5818946, 554), + (5819500, 528), + (5820028, 602), + (5820630, 553), + (5821183, 528), + (5821711, 596), + (5822307, 553), + (5822860, 528), + (5823388, 608), + (5823996, 552), + (5824548, 529), + (5825077, 608), + (5825685, 553), + (5826238, 528), + (5826766, 586), + (5827352, 554), + (5827906, 529), + (5828435, 602), + (5829037, 554), + (5829591, 529), + (5830120, 602), + (5830722, 554), + (5831276, 528), + (5831804, 601), + (5832405, 553), + (5832958, 527), + (5833485, 614), + (5834099, 552), + (5834651, 528), + (5835179, 613), + (5835792, 553), + (5836345, 528), + (5836873, 607), + (5837480, 553), + (5838033, 528), + (5838561, 620), + (5839181, 553), + (5839734, 528), + (5840262, 621), + (5840883, 554), + (5841437, 529), + (5841966, 588), + (5842554, 552), + (5843106, 528), + (5843634, 600), + (5844234, 553), + (5844787, 528), + (5845315, 600), + (5845915, 552), + (5846467, 529), + (5846996, 601), + (5847597, 553), + (5848150, 529), + (5848679, 614), + (5849293, 552), + (5849845, 528), + (5850373, 614), + (5850987, 554), + (5851541, 528), + (5852069, 606), + (5852675, 553), + (5853228, 528), + (5853756, 620), + (5854376, 553), + (5854929, 528), + (5855457, 620), + (5856077, 553), + (5856630, 544), + (5857174, 541), + (5857715, 554), + (5858269, 545), + (5858814, 570), + (5859384, 553), + (5859937, 546), + (5860483, 570), + (5861053, 552), + (5861605, 544), + (5862149, 572), + (5862721, 552), + (5863273, 544), + (5863817, 585), + (5864402, 553), + (5864955, 544), + (5865499, 584), + (5866083, 554), + (5866637, 544), + (5867181, 579), + (5867760, 553), + (5868313, 544), + (5868857, 592), + (5869449, 553), + (5870002, 546), + (5870548, 591), + (5871139, 552), + (5871691, 545), + (5872236, 571), + (5872807, 552), + (5873359, 545), + (5873904, 585), + (5874489, 552), + (5875041, 545), + (5875586, 585), + (5876171, 553), + (5876724, 545), + (5877269, 587), + (5877856, 553), + (5878409, 546), + (5878955, 600), + (5879555, 553), + (5880108, 545), + (5880653, 598), + (5881251, 553), + (5881804, 545), + (5882349, 592), + (5882941, 554), + (5883495, 544), + (5884039, 605), + (5884644, 553), + (5885197, 545), + (5885742, 605), + (5886347, 554), + (5886901, 546), + (5887447, 569), + (5888016, 552), + (5888568, 545), + (5889113, 586), + (5889699, 554), + (5890253, 545), + (5890798, 585), + (5891383, 552), + (5891935, 545), + (5892480, 588), + (5893068, 552), + (5893620, 545), + (5894165, 599), + (5894764, 554), + (5895318, 544), + (5895862, 599), + (5896461, 552), + (5897013, 546), + (5897559, 593), + (5898152, 554), + (5898706, 546), + (5899252, 605), + (5899857, 553), + (5900410, 545), + (5900955, 605), + (5901560, 554), + (5902114, 543), + (5902657, 571), + (5903228, 552), + (5903780, 544), + (5904324, 587), + (5904911, 554), + (5905465, 544), + (5906009, 587), + (5906596, 553), + (5907149, 545), + (5907694, 587), + (5908281, 554), + (5908835, 546), + (5909381, 601), + (5909982, 553), + (5910535, 544), + (5911079, 600), + (5911679, 552), + (5912231, 546), + (5912777, 594), + (5913371, 552), + (5913923, 544), + (5914467, 607), + (5915074, 553), + (5915627, 544), + (5916171, 606), + (5916777, 554), + (5917331, 545), + (5917876, 584), + (5918460, 554), + (5919014, 545), + (5919559, 600), + (5920159, 553), + (5920712, 546), + (5921258, 599), + (5921857, 553), + (5922410, 544), + (5922954, 599), + (5923553, 552), + (5924105, 546), + (5924651, 612), + (5925263, 552), + (5925815, 544), + (5926359, 612), + (5926971, 554), + (5927525, 545), + (5928070, 606), + (5928676, 554), + (5929230, 545), + (5929775, 618), + (5930393, 552), + (5930945, 546), + (5931491, 618), + (5932109, 552), + (5932661, 545), + (5933206, 585), + (5933791, 552), + (5934343, 545), + (5934888, 599), + (5935487, 553), + (5936040, 545), + (5936585, 599), + (5937184, 553), + (5937737, 544), + (5938281, 600), + (5938881, 554), + (5939435, 544), + (5939979, 613), + (5940592, 553), + (5941145, 545), + (5941690, 613), + (5942303, 553), + (5942856, 546), + (5943402, 606), + (5944008, 553), + (5944561, 546), + (5945107, 618), + (5945725, 552), + (5946277, 544), + (5946821, 618), + (5947439, 554), + (5947993, 545), + (5948538, 575), + (5949113, 552), + (5949665, 545), + (5950210, 589), + (5950799, 552), + (5951351, 545), + (5951896, 589), + (5952485, 553), + (5953038, 545), + (5953583, 589), + (5954172, 552), + (5954724, 545), + (5955269, 602), + (5955871, 552), + (5956423, 544), + (5956967, 601), + (5957568, 553), + (5958121, 546), + (5958667, 597), + (5959264, 553), + (5959817, 545), + (5960362, 607), + (5960969, 554), + (5961523, 546), + (5962069, 608), + (5962677, 554), + (5963231, 545), + (5963776, 587), + (5964363, 553), + (5964916, 545), + (5965461, 601), + (5966062, 553), + (5966615, 545), + (5967160, 601), + (5967761, 554), + (5968315, 546), + (5968861, 602), + (5969463, 554), + (5970017, 544), + (5970561, 613), + (5971174, 553), + (5971727, 546), + (5972273, 613), + (5972886, 553), + (5973439, 546), + (5973985, 609), + (5974594, 553), + (5975147, 545), + (5975692, 621), + (5976313, 554), + (5976867, 545), + (5977412, 619), + (5978031, 553), + (5978584, 545), + (5979129, 586), + (5979715, 553), + (5980268, 545), + (5980813, 600), + (5981413, 553), + (5981966, 546), + (5982512, 600), + (5983112, 554), + (5983666, 545), + (5984211, 602), + (5984813, 554), + (5985367, 546), + (5985913, 615), + (5986528, 553), + (5987081, 546), + (5987627, 614), + (5988241, 554), + (5988795, 546), + (5989341, 607), + (5989948, 552), + (5990500, 544), + (5991044, 619), + (5991663, 553), + (5992216, 546), + (5992762, 619), + (5993381, 553), + (5993934, 545), + (5994479, 543), + (5995022, 553), + (5995575, 546), + (5996121, 570), + (5996691, 553), + (5997244, 545), + (5997789, 570), + (5998359, 553), + (5998912, 546), + (5999458, 571), + (6000029, 553), + (6000582, 546), + (6001128, 585), + (6001713, 553), + (6002266, 546), + (6002812, 585), + (6003397, 553), + (6003950, 546), + (6004496, 579), + (6005075, 554), + (6005629, 545), + (6006174, 592), + (6006766, 552), + (6007318, 545), + (6007863, 591), + (6008454, 553), + (6009007, 544), + (6009551, 569), + (6010120, 554), + (6010674, 546), + (6011220, 586), + (6011806, 552), + (6012358, 545), + (6012903, 586), + (6013489, 553), + (6014042, 545), + (6014587, 586), + (6015173, 553), + (6015726, 546), + (6016272, 600), + (6016872, 552), + (6017424, 544), + (6017968, 599), + (6018567, 553), + (6019120, 545), + (6019665, 593), + (6020258, 554), + (6020812, 545), + (6021357, 605), + (6021962, 553), + (6022515, 545), + (6023060, 606), + (6023666, 553), + (6024219, 545), + (6024764, 569), + (6025333, 553), + (6025886, 546), + (6026432, 585), + (6027017, 552), + (6027569, 545), + (6028114, 587), + (6028701, 553), + (6029254, 545), + (6029799, 587), + (6030386, 554), + (6030940, 545), + (6031485, 599), + (6032084, 554), + (6032638, 544), + (6033182, 599), + (6033781, 554), + (6034335, 545), + (6034880, 593), + (6035473, 554), + (6036027, 545), + (6036572, 606), + (6037178, 552), + (6037730, 546), + (6038276, 605), + (6038881, 552), + (6039433, 544), + (6039977, 572), + (6040549, 554), + (6041103, 545), + (6041648, 587), + (6042235, 553), + (6042788, 546), + (6043334, 588), + (6043922, 553), + (6044475, 545), + (6045020, 589), + (6045609, 553), + (6046162, 545), + (6046707, 601), + (6047308, 553), + (6047861, 545), + (6048406, 600), + (6049006, 553), + (6049559, 544), + (6050103, 593), + (6050696, 553), + (6051249, 545), + (6051794, 607), + (6052401, 553), + (6052954, 545), + (6053499, 606), + (6054105, 552), + (6054657, 545), + (6055202, 585), + (6055787, 552), + (6056339, 545), + (6056884, 599), + (6057483, 554), + (6058037, 546), + (6058583, 599), + (6059182, 552), + (6059734, 546), + (6060280, 599), + (6060879, 553), + (6061432, 545), + (6061977, 611), + (6062588, 554), + (6063142, 545), + (6063687, 612), + (6064299, 553), + (6064852, 546), + (6065398, 606), + (6066004, 554), + (6066558, 544), + (6067102, 619), + (6067721, 552), + (6068273, 545), + (6068818, 617), + (6069435, 552), + (6069987, 544), + (6070531, 585), + (6071116, 552), + (6071668, 544), + (6072212, 598), + (6072810, 553), + (6073363, 545), + (6073908, 599), + (6074507, 552), + (6075059, 545), + (6075604, 599), + (6076203, 553), + (6076756, 545), + (6077301, 612), + (6077913, 553), + (6078466, 545), + (6079011, 612), + (6079623, 552), + (6080175, 546), + (6080721, 606), + (6081327, 553), + (6081880, 545), + (6082425, 617), + (6083042, 553), + (6083595, 544), + (6084139, 617), + (6084756, 554), + (6085310, 545), + (6085855, 575), + (6086430, 553), + (6086983, 545), + (6087528, 590), + (6088118, 553), + (6088671, 545), + (6089216, 590), + (6089806, 553), + (6090359, 545), + (6090904, 589), + (6091493, 553), + (6092046, 545), + (6092591, 602), + (6093193, 553), + (6093746, 545), + (6094291, 601), + (6094892, 552), + (6095444, 545), + (6095989, 596), + (6096585, 553), + (6097138, 546), + (6097684, 608), + (6098292, 554), + (6098846, 546), + (6099392, 608), + (6100000, 552), + (6100552, 545), + (6101097, 588), + (6101685, 553), + (6102238, 544), + (6102782, 602), + (6103384, 553), + (6103937, 546), + (6104483, 601), + (6105084, 553), + (6105637, 545), + (6106182, 602), + (6106784, 553), + (6107337, 544), + (6107881, 614), + (6108495, 553), + (6109048, 545), + (6109593, 614), + (6110207, 553), + (6110760, 544), + (6111304, 607), + (6111911, 553), + (6112464, 545), + (6113009, 620), + (6113629, 553), + (6114182, 545), + (6114727, 620), + (6115347, 553), + (6115900, 545), + (6116445, 587), + (6117032, 554), + (6117586, 544), + (6118130, 602), + (6118732, 552), + (6119284, 545), + (6119829, 600), + (6120429, 553), + (6120982, 544), + (6121526, 602), + (6122128, 552), + (6122680, 545), + (6123225, 615), + (6123840, 553), + (6124393, 546), + (6124939, 614), + (6125553, 553), + (6126106, 546), + (6126652, 609), + (6127261, 553), + (6127814, 544), + (6128358, 620), + (6128978, 554), + (6129532, 544), + (6130076, 621), + (6130697, 553), + (6131250, 555), + (6131805, 542), + (6132347, 552), + (6132899, 555), + (6133454, 570), + (6134024, 553), + (6134577, 555), + (6135132, 570), + (6135702, 553), + (6136255, 555), + (6136810, 572), + (6137382, 553), + (6137935, 554), + (6138489, 585), + (6139074, 553), + (6139627, 555), + (6140182, 586), + (6140768, 553), + (6141321, 556), + (6141877, 579), + (6142456, 552), + (6143008, 555), + (6143563, 590), + (6144153, 553), + (6144706, 555), + (6145261, 591), + (6145852, 552), + (6146404, 555), + (6146959, 570), + (6147529, 552), + (6148081, 555), + (6148636, 587), + (6149223, 553), + (6149776, 555), + (6150331, 585), + (6150916, 553), + (6151469, 554), + (6152023, 588), + (6152611, 552), + (6153163, 554), + (6153717, 600), + (6154317, 554), + (6154871, 555), + (6155426, 600), + (6156026, 552), + (6156578, 555), + (6157133, 593), + (6157726, 553), + (6158279, 555), + (6158834, 605), + (6159439, 552), + (6159991, 554), + (6160545, 605), + (6161150, 553), + (6161703, 555), + (6162258, 571), + (6162829, 554), + (6163383, 555), + (6163938, 586), + (6164524, 553), + (6165077, 554), + (6165631, 585), + (6166216, 553), + (6166769, 554), + (6167323, 587), + (6167910, 553), + (6168463, 555), + (6169018, 599), + (6169617, 554), + (6170171, 554), + (6170725, 599), + (6171324, 553), + (6171877, 554), + (6172431, 593), + (6173024, 554), + (6173578, 556), + (6174134, 606), + (6174740, 553), + (6175293, 555), + (6175848, 606), + (6176454, 554), + (6177008, 556), + (6177564, 572), + (6178136, 553), + (6178689, 554), + (6179243, 587), + (6179830, 552), + (6180382, 556), + (6180938, 586), + (6181524, 552), + (6182076, 555), + (6182631, 587), + (6183218, 553), + (6183771, 555), + (6184326, 599), + (6184925, 552), + (6185477, 555), + (6186032, 601), + (6186633, 553), + (6187186, 556), + (6187742, 594), + (6188336, 554), + (6188890, 555), + (6189445, 605), + (6190050, 553), + (6190603, 554), + (6191157, 606), + (6191763, 552), + (6192315, 555), + (6192870, 585), + (6193455, 552), + (6194007, 554), + (6194561, 600), + (6195161, 552), + (6195713, 554), + (6196267, 599), + (6196866, 553), + (6197419, 555), + (6197974, 600), + (6198574, 553), + (6199127, 554), + (6199681, 611), + (6200292, 552), + (6200844, 556), + (6201400, 612), + (6202012, 552), + (6202564, 556), + (6203120, 607), + (6203727, 554), + (6204281, 555), + (6204836, 619), + (6205455, 553), + (6206008, 555), + (6206563, 618), + (6207181, 553), + (6207734, 556), + (6208290, 584), + (6208874, 553), + (6209427, 554), + (6209981, 599), + (6210580, 553), + (6211133, 555), + (6211688, 599), + (6212287, 554), + (6212841, 554), + (6213395, 599), + (6213994, 554), + (6214548, 554), + (6215102, 611), + (6215713, 552), + (6216265, 554), + (6216819, 612), + (6217431, 552), + (6217983, 555), + (6218538, 605), + (6219143, 553), + (6219696, 556), + (6220252, 619), + (6220871, 553), + (6221424, 556), + (6221980, 618), + (6222598, 552), + (6223150, 555), + (6223705, 575), + (6224280, 552), + (6224832, 554), + (6225386, 588), + (6225974, 553), + (6226527, 556), + (6227083, 590), + (6227673, 553), + (6228226, 555), + (6228781, 589), + (6229370, 554), + (6229924, 556), + (6230480, 603), + (6231083, 553), + (6231636, 555), + (6232191, 603), + (6232794, 553), + (6233347, 556), + (6233903, 597), + (6234500, 553), + (6235053, 554), + (6235607, 608), + (6236215, 554), + (6236769, 555), + (6237324, 607), + (6237931, 553), + (6238484, 555), + (6239039, 587), + (6239626, 553), + (6240179, 555), + (6240734, 602), + (6241336, 553), + (6241889, 554), + (6242443, 602), + (6243045, 552), + (6243597, 556), + (6244153, 601), + (6244754, 554), + (6245308, 555), + (6245863, 613), + (6246476, 552), + (6247028, 555), + (6247583, 613), + (6248196, 552), + (6248748, 555), + (6249303, 609), + (6249912, 552), + (6250464, 555), + (6251019, 619), + (6251638, 553), + (6252191, 555), + (6252746, 620), + (6253366, 554), + (6253920, 555), + (6254475, 587), + (6255062, 554), + (6255616, 554), + (6256170, 600), + (6256770, 554), + (6257324, 554), + (6257878, 602), + (6258480, 553), + (6259033, 556), + (6259589, 601), + (6260190, 553), + (6260743, 555), + (6261298, 613), + (6261911, 552), + (6262463, 555), + (6263018, 614), + (6263632, 553), + (6264185, 555), + (6264740, 608), + (6265348, 554), + (6265902, 555), + (6266457, 619), + (6267076, 553), + (6267629, 555), + (6268184, 621), + (6268805, 553), + (6269358, 560), + (6269918, 542), + (6270460, 553), + (6271013, 562), + (6271575, 570), + (6272145, 553), + (6272698, 561), + (6273259, 569), + (6273828, 554), + (6274382, 562), + (6274944, 573), + (6275517, 554), + (6276071, 561), + (6276632, 584), + (6277216, 553), + (6277769, 561), + (6278330, 585), + (6278915, 553), + (6279468, 561), + (6280029, 580), + (6280609, 553), + (6281162, 561), + (6281723, 591), + (6282314, 552), + (6282866, 561), + (6283427, 592), + (6284019, 554), + (6284573, 560), + (6285133, 569), + (6285702, 553), + (6286255, 561), + (6286816, 586), + (6287402, 552), + (6287954, 561), + (6288515, 587), + (6289102, 553), + (6289655, 561), + (6290216, 587), + (6290803, 554), + (6291357, 561), + (6291918, 599), + (6292517, 553), + (6293070, 560), + (6293630, 600), + (6294230, 554), + (6294784, 562), + (6295346, 592), + (6295938, 553), + (6296491, 561), + (6297052, 605), + (6297657, 553), + (6298210, 561), + (6298771, 604), + (6299375, 553), + (6299928, 561), + (6300489, 570), + (6301059, 554), + (6301613, 562), + (6302175, 585), + (6302760, 553), + (6303313, 561), + (6303874, 586), + (6304460, 554), + (6305014, 561), + (6305575, 586), + (6306161, 554), + (6306715, 561), + (6307276, 600), + (6307876, 554), + (6308430, 561), + (6308991, 598), + (6309589, 553), + (6310142, 561), + (6310703, 593), + (6311296, 552), + (6311848, 561), + (6312409, 606), + (6313015, 554), + (6313569, 562), + (6314131, 604), + (6314735, 552), + (6315287, 562), + (6315849, 572), + (6316421, 554), + (6316975, 562), + (6317537, 588), + (6318125, 552), + (6318677, 561), + (6319238, 587), + (6319825, 553), + (6320378, 562), + (6320940, 589), + (6321529, 554), + (6322083, 562), + (6322645, 600), + (6323245, 553), + (6323798, 560), + (6324358, 600), + (6324958, 553), + (6325511, 561), + (6326072, 593), + (6326665, 553), + (6327218, 561), + (6327779, 606), + (6328385, 553), + (6328938, 560), + (6329498, 606), + (6330104, 553), + (6330657, 561), + (6331218, 586), + (6331804, 553), + (6332357, 561), + (6332918, 599), + (6333517, 552), + (6334069, 561), + (6334630, 599), + (6335229, 553), + (6335782, 560), + (6336342, 599), + (6336941, 552), + (6337493, 561), + (6338054, 611), + (6338665, 554), + (6339219, 561), + (6339780, 612), + (6340392, 552), + (6340944, 561), + (6341505, 606), + (6342111, 554), + (6342665, 560), + (6343225, 618), + (6343843, 553), + (6344396, 560), + (6344956, 617), + (6345573, 552), + (6346125, 560), + (6346685, 585), + (6347270, 554), + (6347824, 560), + (6348384, 598), + (6348982, 553), + (6349535, 561), + (6350096, 600), + (6350696, 554), + (6351250, 562), + (6351812, 600), + (6352412, 553), + (6352965, 560), + (6353525, 612), + (6354137, 554), + (6354691, 560), + (6355251, 613), + (6355864, 553), + (6356417, 560), + (6356977, 606), + (6357583, 553), + (6358136, 561), + (6358697, 618), + (6359315, 552), + (6359867, 561), + (6360428, 618), + (6361046, 552), + (6361598, 561), + (6362159, 576), + (6362735, 552), + (6363287, 560), + (6363847, 589), + (6364436, 552), + (6364988, 561), + (6365549, 588), + (6366137, 554), + (6366691, 561), + (6367252, 589), + (6367841, 552), + (6368393, 560), + (6368953, 603), + (6369556, 554), + (6370110, 562), + (6370672, 603), + (6371275, 553), + (6371828, 560), + (6372388, 596), + (6372984, 553), + (6373537, 562), + (6374099, 609), + (6374708, 552), + (6375260, 560), + (6375820, 607), + (6376427, 552), + (6376979, 562), + (6377541, 586), + (6378127, 553), + (6378680, 560), + (6379240, 601), + (6379841, 553), + (6380394, 560), + (6380954, 601), + (6381555, 554), + (6382109, 562), + (6382671, 602), + (6383273, 553), + (6383826, 561), + (6384387, 615), + (6385002, 553), + (6385555, 561), + (6386116, 613), + (6386729, 553), + (6387282, 561), + (6387843, 608), + (6388451, 553), + (6389004, 561), + (6389565, 620), + (6390185, 554), + (6390739, 561), + (6391300, 621), + (6391921, 554), + (6392475, 561), + (6393036, 587), + (6393623, 554), + (6394177, 561), + (6394738, 600), + (6395338, 553), + (6395891, 561), + (6396452, 602), + (6397054, 552), + (6397606, 561), + (6398167, 602), + (6398769, 554), + (6399323, 560), + (6399883, 614), + (6400497, 553), + (6401050, 561), + (6401611, 615), + (6402226, 552), + (6402778, 561), + (6403339, 609), + (6403948, 552), + (6404500, 562), + (6405062, 620), + (6405682, 552), + (6406234, 561), + (6406795, 619), + (6407414, 552), + (6407966, 560), + (6408526, 543), + (6409069, 554), + (6409623, 561), + (6410184, 570), + (6410754, 553), + (6411307, 561), + (6411868, 570), + (6412438, 553), + (6412991, 561), + (6413552, 573), + (6414125, 552), + (6414677, 561), + (6415238, 586), + (6415824, 554), + (6416378, 561), + (6416939, 586), + (6417525, 554), + (6418079, 562), + (6418641, 579), + (6419220, 552), + (6419772, 560), + (6420332, 591), + (6420923, 553), + (6421476, 561), + (6422037, 591), + (6422628, 553), + (6423181, 561), + (6423742, 570), + (6424312, 552), + (6424864, 561), + (6425425, 586), + (6426011, 552), + (6426563, 561), + (6427124, 585), + (6427709, 553), + (6428262, 562), + (6428824, 586), + (6429410, 554), + (6429964, 561), + (6430525, 599), + (6431124, 553), + (6431677, 560), + (6432237, 599), + (6432836, 553), + (6433389, 562), + (6433951, 593), + (6434544, 554), + (6435098, 561), + (6435659, 605), + (6436264, 552), + (6436816, 562), + (6437378, 604), + (6437982, 554), + (6438536, 560), + (6439096, 569), + (6439665, 552), + (6440217, 561), + (6440778, 586), + (6441364, 553), + (6441917, 561), + (6442478, 587), + (6443065, 554), + (6443619, 562), + (6444181, 588), + (6444769, 553), + (6445322, 562), + (6445884, 599), + (6446483, 552), + (6447035, 560), + (6447595, 599), + (6448194, 552), + (6448746, 562), + (6449308, 592), + (6449900, 554), + (6450454, 561), + (6451015, 605), + (6451620, 553), + (6452173, 561), + (6452734, 605), + (6453339, 553), + (6453892, 562), + (6454454, 573), + (6455027, 552), + (6455579, 561), + (6456140, 586), + (6456726, 553), + (6457279, 561), + (6457840, 587), + (6458427, 553), + (6458980, 561), + (6459541, 588), + (6460129, 553), + (6460682, 562), + (6461244, 599), + (6461843, 552), + (6462395, 561), + (6462956, 600), + (6463556, 553), + (6464109, 561), + (6464670, 594), + (6465264, 554), + (6465818, 562), + (6466380, 607), + (6466987, 552), + (6467539, 561), + (6468100, 606), + (6468706, 553), + (6469259, 561), + (6469820, 586), + (6470406, 553), + (6470959, 561), + (6471520, 600), + (6472120, 554), + (6472674, 561), + (6473235, 599), + (6473834, 552), + (6474386, 561), + (6474947, 599), + (6475546, 552), + (6476098, 561), + (6476659, 612), + (6477271, 553), + (6477824, 561), + (6478385, 611), + (6478996, 552), + (6479548, 561), + (6480109, 606), + (6480715, 553), + (6481268, 562), + (6481830, 619), + (6482449, 553), + (6483002, 561), + (6483563, 618), + (6484181, 552), + (6484733, 562), + (6485295, 586), + (6485881, 553), + (6486434, 562), + (6486996, 598), + (6487594, 554), + (6488148, 561), + (6488709, 599), + (6489308, 553), + (6489861, 561), + (6490422, 600), + (6491022, 554), + (6491576, 562), + (6492138, 612), + (6492750, 553), + (6493303, 562), + (6493865, 612), + (6494477, 552), + (6495029, 562), + (6495591, 607), + (6496198, 553), + (6496751, 562), + (6497313, 618), + (6497931, 552), + (6498483, 561), + (6499044, 618), + (6499662, 553), + (6500215, 560), + (6500775, 575), + (6501350, 554), + (6501904, 561), + (6502465, 588), + (6503053, 554), + (6503607, 560), + (6504167, 590), + (6504757, 554), + (6505311, 561), + (6505872, 591), + (6506463, 552), + (6507015, 560), + (6507575, 601), + (6508176, 554), + (6508730, 562), + (6509292, 602), + (6509894, 553), + (6510447, 561), + (6511008, 596), + (6511604, 553), + (6512157, 560), + (6512717, 607), + (6513324, 553), + (6513877, 560), + (6514437, 608), + (6515045, 553), + (6515598, 561), + (6516159, 587), + (6516746, 554), + (6517300, 561), + (6517861, 600), + (6518461, 554), + (6519015, 561), + (6519576, 601), + (6520177, 553), + (6520730, 560), + (6521290, 602), + (6521892, 552), + (6522444, 562), + (6523006, 614), + (6523620, 554), + (6524174, 561), + (6524735, 613), + (6525348, 553), + (6525901, 561), + (6526462, 609), + (6527071, 552), + (6527623, 561), + (6528184, 621), + (6528805, 554), + (6529359, 560), + (6529919, 620), + (6530539, 553), + (6531092, 561), + (6531653, 586), + (6532239, 553), + (6532792, 560), + (6533352, 602), + (6533954, 553), + (6534507, 560), + (6535067, 601), + (6535668, 553), + (6536221, 562), + (6536783, 602), + (6537385, 553), + (6537938, 562), + (6538500, 615), + (6539115, 554), + (6539669, 561), + (6540230, 615), + (6540845, 553), + (6541398, 561), + (6541959, 609), + (6542568, 553), + (6543121, 561), + (6543682, 619), + (6544301, 554), + (6544855, 562), + (6545417, 619), + (6546036, 553), + (6546589, 555), + (6547144, 541), + (6547685, 553), + (6548238, 555), + (6548793, 571), + (6549364, 553), + (6549917, 556), + (6550473, 570), + (6551043, 554), + (6551597, 555), + (6552152, 571), + (6552723, 552), + (6553275, 555), + (6553830, 585), + (6554415, 552), + (6554967, 556), + (6555523, 585), + (6556108, 552), + (6556660, 556), + (6557216, 580), + (6557796, 553), + (6558349, 556), + (6558905, 591), + (6559496, 552), + (6560048, 556), + (6560604, 592), + (6561196, 553), + (6561749, 555), + (6562304, 570), + (6562874, 552), + (6563426, 555), + (6563981, 586), + (6564567, 552), + (6565119, 556), + (6565675, 586), + (6566261, 554), + (6566815, 556), + (6567371, 588), + (6567959, 553), + (6568512, 556), + (6569068, 599), + (6569667, 553), + (6570220, 557), + (6570777, 599), + (6571376, 553), + (6571929, 557), + (6572486, 593), + (6573079, 554), + (6573633, 556), + (6574189, 604), + (6574793, 554), + (6575347, 557), + (6575904, 605), + (6576509, 553), + (6577062, 555), + (6577617, 570), + (6578187, 553), + (6578740, 555), + (6579295, 585), + (6579880, 553), + (6580433, 556), + (6580989, 587), + (6581576, 553), + (6582129, 555), + (6582684, 588), + (6583272, 553), + (6583825, 556), + (6584381, 599), + (6584980, 552), + (6585532, 555), + (6586087, 599), + (6586686, 552), + (6587238, 556), + (6587794, 593), + (6588387, 552), + (6588939, 556), + (6589495, 605), + (6590100, 552), + (6590652, 556), + (6591208, 604), + (6591812, 553), + (6592365, 556), + (6592921, 573), + (6593494, 554), + (6594048, 557), + (6594605, 587), + (6595192, 554), + (6595746, 556), + (6596302, 586), + (6596888, 553), + (6597441, 556), + (6597997, 589), + (6598586, 554), + (6599140, 555), + (6599695, 601), + (6600296, 554), + (6600850, 556), + (6601406, 600), + (6602006, 553), + (6602559, 555), + (6603114, 594), + (6603708, 552), + (6604260, 557), + (6604817, 605), + (6605422, 552), + (6605974, 555), + (6606529, 606), + (6607135, 552), + (6607687, 556), + (6608243, 585), + (6608828, 553), + (6609381, 556), + (6609937, 600), + (6610537, 552), + (6611089, 556), + (6611645, 598), + (6612243, 554), + (6612797, 556), + (6613353, 600), + (6613953, 553), + (6614506, 556), + (6615062, 612), + (6615674, 553), + (6616227, 556), + (6616783, 611), + (6617394, 552), + (6617946, 557), + (6618503, 606), + (6619109, 552), + (6619661, 556), + (6620217, 617), + (6620834, 553), + (6621387, 555), + (6621942, 618), + (6622560, 553), + (6623113, 556), + (6623669, 584), + (6624253, 553), + (6624806, 556), + (6625362, 599), + (6625961, 553), + (6626514, 557), + (6627071, 599), + (6627670, 554), + (6628224, 557), + (6628781, 599), + (6629380, 554), + (6629934, 556), + (6630490, 611), + (6631101, 554), + (6631655, 556), + (6632211, 612), + (6632823, 554), + (6633377, 556), + (6633933, 606), + (6634539, 554), + (6635093, 556), + (6635649, 619), + (6636268, 552), + (6636820, 556), + (6637376, 618), + (6637994, 553), + (6638547, 556), + (6639103, 575), + (6639678, 552), + (6640230, 556), + (6640786, 590), + (6641376, 553), + (6641929, 555), + (6642484, 590), + (6643074, 554), + (6643628, 556), + (6644184, 590), + (6644774, 553), + (6645327, 555), + (6645882, 602), + (6646484, 553), + (6647037, 556), + (6647593, 602), + (6648195, 553), + (6648748, 556), + (6649304, 596), + (6649900, 552), + (6650452, 556), + (6651008, 608), + (6651616, 553), + (6652169, 556), + (6652725, 608), + (6653333, 553), + (6653886, 555), + (6654441, 587), + (6655028, 553), + (6655581, 556), + (6656137, 601), + (6656738, 554), + (6657292, 556), + (6657848, 600), + (6658448, 554), + (6659002, 557), + (6659559, 602), + (6660161, 554), + (6660715, 556), + (6661271, 614), + (6661885, 553), + (6662438, 556), + (6662994, 615), + (6663609, 553), + (6664162, 557), + (6664719, 608), + (6665327, 553), + (6665880, 557), + (6666437, 619), + (6667056, 554), + (6667610, 555), + (6668165, 619), + (6668784, 554), + (6669338, 556), + (6669894, 587), + (6670481, 552), + (6671033, 557), + (6671590, 601), + (6672191, 554), + (6672745, 555), + (6673300, 601), + (6673901, 552), + (6674453, 557), + (6675010, 602), + (6675612, 552), + (6676164, 556), + (6676720, 614), + (6677334, 552), + (6677886, 557), + (6678443, 615), + (6679058, 552), + (6679610, 557), + (6680167, 607), + (6680774, 553), + (6681327, 555), + (6681882, 619), + (6682501, 554), + (6683055, 556), + (6683611, 621), + (6684232, 552), + (6684784, 562), + (6685346, 541), + (6685887, 552), + (6686439, 562), + (6687001, 570), + (6687571, 552), + (6688123, 562), + (6688685, 569), + (6689254, 553), + (6689807, 562), + (6690369, 572), + (6690941, 553), + (6691494, 563), + (6692057, 584), + (6692641, 552), + (6693193, 563), + (6693756, 585), + (6694341, 553), + (6694894, 562), + (6695456, 579), + (6696035, 554), + (6696589, 563), + (6697152, 591), + (6697743, 552), + (6698295, 562), + (6698857, 592), + (6699449, 553), + (6700002, 562), + (6700564, 571), + (6701135, 553), + (6701688, 561), + (6702249, 587), + (6702836, 553), + (6703389, 561), + (6703950, 585), + (6704535, 552), + (6705087, 563), + (6705650, 588), + (6706238, 554), + (6706792, 562), + (6707354, 600), + (6707954, 552), + (6708506, 562), + (6709068, 599), + (6709667, 553), + (6710220, 562), + (6710782, 593), + (6711375, 552), + (6711927, 562), + (6712489, 605), + (6713094, 553), + (6713647, 561), + (6714208, 606), + (6714814, 553), + (6715367, 561), + (6715928, 570), + (6716498, 553), + (6717051, 562), + (6717613, 587), + (6718200, 553), + (6718753, 562), + (6719315, 586), + (6719901, 553), + (6720454, 563), + (6721017, 587), + (6721604, 554), + (6722158, 562), + (6722720, 598), + (6723318, 554), + (6723872, 561), + (6724433, 599), + (6725032, 553), + (6725585, 562), + (6726147, 594), + (6726741, 554), + (6727295, 561), + (6727856, 606), + (6728462, 553), + (6729015, 562), + (6729577, 604), + (6730181, 553), + (6730734, 563), + (6731297, 572), + (6731869, 554), + (6732423, 563), + (6732986, 586), + (6733572, 552), + (6734124, 562), + (6734686, 586), + (6735272, 553), + (6735825, 562), + (6736387, 589), + (6736976, 553), + (6737529, 562), + (6738091, 599), + (6738690, 553), + (6739243, 563), + (6739806, 600), + (6740406, 554), + (6740960, 562), + (6741522, 594), + (6742116, 553), + (6742669, 563), + (6743232, 607), + (6743839, 554), + (6744393, 563), + (6744956, 606), + (6745562, 552), + (6746114, 561), + (6746675, 584), + (6747259, 552), + (6747811, 562), + (6748373, 598), + (6748971, 552), + (6749523, 561), + (6750084, 600), + (6750684, 553), + (6751237, 563), + (6751800, 600), + (6752400, 552), + (6752952, 562), + (6753514, 612), + (6754126, 552), + (6754678, 563), + (6755241, 612), + (6755853, 552), + (6756405, 562), + (6756967, 605), + (6757572, 552), + (6758124, 561), + (6758685, 617), + (6759302, 552), + (6759854, 561), + (6760415, 619), + (6761034, 553), + (6761587, 563), + (6762150, 585), + (6762735, 554), + (6763289, 563), + (6763852, 600), + (6764452, 552), + (6765004, 562), + (6765566, 599), + (6766165, 554), + (6766719, 563), + (6767282, 600), + (6767882, 553), + (6768435, 563), + (6768998, 611), + (6769609, 553), + (6770162, 562), + (6770724, 612), + (6771336, 553), + (6771889, 562), + (6772451, 607), + (6773058, 553), + (6773611, 561), + (6774172, 618), + (6774790, 553), + (6775343, 561), + (6775904, 618), + (6776522, 553), + (6777075, 562), + (6777637, 575), + (6778212, 553), + (6778765, 562), + (6779327, 589), + (6779916, 553), + (6780469, 562), + (6781031, 589), + (6781620, 553), + (6782173, 562), + (6782735, 590), + (6783325, 553), + (6783878, 562), + (6784440, 602), + (6785042, 553), + (6785595, 563), + (6786158, 603), + (6786761, 553), + (6787314, 561), + (6787875, 596), + (6788471, 553), + (6789024, 562), + (6789586, 608), + (6790194, 553), + (6790747, 562), + (6791309, 608), + (6791917, 554), + (6792471, 561), + (6793032, 588), + (6793620, 553), + (6794173, 563), + (6794736, 601), + (6795337, 553), + (6795890, 562), + (6796452, 601), + (6797053, 553), + (6797606, 562), + (6798168, 602), + (6798770, 554), + (6799324, 561), + (6799885, 615), + (6800500, 554), + (6801054, 563), + (6801617, 613), + (6802230, 553), + (6802783, 561), + (6803344, 609), + (6803953, 552), + (6804505, 562), + (6805067, 619), + (6805686, 554), + (6806240, 563), + (6806803, 619), + (6807422, 552), + (6807974, 562), + (6808536, 586), + (6809122, 553), + (6809675, 562), + (6810237, 601), + (6810838, 554), + (6811392, 562), + (6811954, 602), + (6812556, 553), + (6813109, 562), + (6813671, 602), + (6814273, 553), + (6814826, 563), + (6815389, 613), + (6816002, 552), + (6816554, 561), + (6817115, 614), + (6817729, 554), + (6818283, 562), + (6818845, 608), + (6819453, 552), + (6820005, 562), + (6820567, 620), + (6821187, 553), + (6821740, 561), + (6822301, 620), + (6822921, 554), + (6823475, 562), + (6824037, 541), + (6824578, 553), + (6825131, 562), + (6825693, 570), + (6826263, 553), + (6826816, 562), + (6827378, 570), + (6827948, 553), + (6828501, 562), + (6829063, 572), + (6829635, 553), + (6830188, 561), + (6830749, 585), + (6831334, 553), + (6831887, 561), + (6832448, 586), + (6833034, 552), + (6833586, 561), + (6834147, 578), + (6834725, 552), + (6835277, 563), + (6835840, 591), + (6836431, 553), + (6836984, 561), + (6837545, 591), + (6838136, 554), + (6838690, 561), + (6839251, 571), + (6839822, 552), + (6840374, 563), + (6840937, 586), + (6841523, 552), + (6842075, 563), + (6842638, 587), + (6843225, 554), + (6843779, 563), + (6844342, 587), + (6844929, 554), + (6845483, 562), + (6846045, 598), + (6846643, 553), + (6847196, 562), + (6847758, 600), + (6848358, 553), + (6848911, 562), + (6849473, 594), + (6850067, 553), + (6850620, 563), + (6851183, 605), + (6851788, 553), + (6852341, 563), + (6852904, 606), + (6853510, 554), + (6854064, 562), + (6854626, 571), + (6855197, 553), + (6855750, 563), + (6856313, 585), + (6856898, 554), + (6857452, 560), + (6858012, 585), + (6858597, 554), + (6859151, 562), + (6859713, 587), + (6860300, 554), + (6860854, 561), + (6861415, 598), + (6862013, 553), + (6862566, 562), + (6863128, 600), + (6863728, 554), + (6864282, 563), + (6864845, 593), + (6865438, 552), + (6865990, 563), + (6866553, 605), + (6867158, 552), + (6867710, 562), + (6868272, 606), + (6868878, 553), + (6869431, 561), + (6869992, 573), + (6870565, 554), + (6871119, 561), + (6871680, 588), + (6872268, 554), + (6872822, 563), + (6873385, 588), + (6873973, 554), + (6874527, 562), + (6875089, 588), + (6875677, 553), + (6876230, 562), + (6876792, 599), + (6877391, 554), + (6877945, 563), + (6878508, 600), + (6879108, 552), + (6879660, 563), + (6880223, 594), + (6880817, 553), + (6881370, 562), + (6881932, 605), + (6882537, 552), + (6883089, 563), + (6883652, 606), + (6884258, 553), + (6884811, 561), + (6885372, 586), + (6885958, 553), + (6886511, 563), + (6887074, 600), + (6887674, 552), + (6888226, 563), + (6888789, 599), + (6889388, 554), + (6889942, 562), + (6890504, 600), + (6891104, 554), + (6891658, 562), + (6892220, 613), + (6892833, 553), + (6893386, 562), + (6893948, 613), + (6894561, 553), + (6895114, 562), + (6895676, 606), + (6896282, 554), + (6896836, 561), + (6897397, 618), + (6898015, 553), + (6898568, 562), + (6899130, 618), + (6899748, 553), + (6900301, 563), + (6900864, 585), + (6901449, 553), + (6902002, 563), + (6902565, 599), + (6903164, 552), + (6903716, 561), + (6904277, 599), + (6904876, 554), + (6905430, 563), + (6905993, 599), + (6906592, 551), + (6907143, 562), + (6907705, 611), + (6908316, 554), + (6908870, 562), + (6909432, 613), + (6910045, 554), + (6910599, 562), + (6911161, 606), + (6911767, 552), + (6912319, 562), + (6912881, 619), + (6913500, 553), + (6914053, 561), + (6914614, 618), + (6915232, 553), + (6915785, 562), + (6916347, 574), + (6916921, 553), + (6917474, 562), + (6918036, 589), + (6918625, 553), + (6919178, 562), + (6919740, 588), + (6920328, 553), + (6920881, 562), + (6921443, 591), + (6922034, 554), + (6922588, 562), + (6923150, 603), + (6923753, 552), + (6924305, 562), + (6924867, 601), + (6925468, 552), + (6926020, 562), + (6926582, 596), + (6927178, 553), + (6927731, 562), + (6928293, 607), + (6928900, 553), + (6929453, 561), + (6930014, 607), + (6930621, 553), + (6931174, 563), + (6931737, 586), + (6932323, 553), + (6932876, 561), + (6933437, 600), + (6934037, 553), + (6934590, 562), + (6935152, 600), + (6935752, 554), + (6936306, 562), + (6936868, 603), + (6937471, 552), + (6938023, 562), + (6938585, 613), + (6939198, 553), + (6939751, 562), + (6940313, 613), + (6940926, 553), + (6941479, 562), + (6942041, 608), + (6942649, 553), + (6943202, 561), + (6943763, 621), + (6944384, 553), + (6944937, 562), + (6945499, 620), + (6946119, 553), + (6946672, 562), + (6947234, 588), + (6947822, 553), + (6948375, 562), + (6948937, 600), + (6949537, 553), + (6950090, 562), + (6950652, 601), + (6951253, 552), + (6951805, 561), + (6952366, 602), + (6952968, 554), + (6953522, 561), + (6954083, 615), + (6954698, 552), + (6955250, 562), + (6955812, 613), + (6956425, 553), + (6956978, 563), + (6957541, 608), + (6958149, 553), + (6958702, 562), + (6959264, 621), + (6959885, 554), + (6960439, 562), + (6961001, 620), + (6961621, 553), + (6962174, 527), + (6962701, 543), + (6963244, 554), + (6963798, 525), + (6964323, 570), + (6964893, 552), + (6965445, 526), + (6965971, 570), + (6966541, 554), + (6967095, 525), + (6967620, 572), + (6968192, 553), + (6968745, 526), + (6969271, 586), + (6969857, 554), + (6970411, 526), + (6970937, 585), + (6971522, 552), + (6972074, 525), + (6972599, 579), + (6973178, 552), + (6973730, 526), + (6974256, 590), + (6974846, 552), + (6975398, 525), + (6975923, 591), + (6976514, 552), + (6977066, 526), + (6977592, 570), + (6978162, 553), + (6978715, 526), + (6979241, 586), + (6979827, 554), + (6980381, 526), + (6980907, 587), + (6981494, 552), + (6982046, 526), + (6982572, 586), + (6983158, 554), + (6983712, 527), + (6984239, 598), + (6984837, 553), + (6985390, 527), + (6985917, 599), + (6986516, 553), + (6987069, 525), + (6987594, 592), + (6988186, 553), + (6988739, 525), + (6989264, 605), + (6989869, 552), + (6990421, 527), + (6990948, 606), + (6991554, 553), + (6992107, 527), + (6992634, 570), + (6993204, 552), + (6993756, 526), + (6994282, 587), + (6994869, 553), + (6995422, 526), + (6995948, 585), + (6996533, 553), + (6997086, 526), + (6997612, 586), + (6998198, 553), + (6998751, 525), + (6999276, 600), + (6999876, 553), + (7000429, 526), + (7000955, 600), + (7001555, 552), + (7002107, 526), + (7002633, 592), + (7003225, 552), + (7003777, 526), + (7004303, 605), + (7004908, 554), + (7005462, 526), + (7005988, 605), + (7006593, 553), + (7007146, 527), + (7007673, 571), + (7008244, 552), + (7008796, 526), + (7009322, 587), + (7009909, 553), + (7010462, 526), + (7010988, 587), + (7011575, 552), + (7012127, 527), + (7012654, 587), + (7013241, 553), + (7013794, 525), + (7014319, 601), + (7014920, 552), + (7015472, 526), + (7015998, 599), + (7016597, 553), + (7017150, 526), + (7017676, 593), + (7018269, 552), + (7018821, 526), + (7019347, 606), + (7019953, 553), + (7020506, 526), + (7021032, 606), + (7021638, 553), + (7022191, 526), + (7022717, 586), + (7023303, 552), + (7023855, 527), + (7024382, 598), + (7024980, 553), + (7025533, 527), + (7026060, 600), + (7026660, 553), + (7027213, 526), + (7027739, 600), + (7028339, 554), + (7028893, 526), + (7029419, 611), + (7030030, 554), + (7030584, 526), + (7031110, 612), + (7031722, 553), + (7032275, 527), + (7032802, 606), + (7033408, 554), + (7033962, 526), + (7034488, 619), + (7035107, 553), + (7035660, 526), + (7036186, 618), + (7036804, 553), + (7037357, 527), + (7037884, 586), + (7038470, 553), + (7039023, 526), + (7039549, 598), + (7040147, 553), + (7040700, 526), + (7041226, 599), + (7041825, 553), + (7042378, 526), + (7042904, 601), + (7043505, 552), + (7044057, 526), + (7044583, 612), + (7045195, 553), + (7045748, 527), + (7046275, 611), + (7046886, 554), + (7047440, 526), + (7047966, 606), + (7048572, 553), + (7049125, 526), + (7049651, 618), + (7050269, 554), + (7050823, 526), + (7051349, 618), + (7051967, 553), + (7052520, 527), + (7053047, 576), + (7053623, 554), + (7054177, 526), + (7054703, 589), + (7055292, 553), + (7055845, 527), + (7056372, 590), + (7056962, 553), + (7057515, 526), + (7058041, 591), + (7058632, 553), + (7059185, 526), + (7059711, 602), + (7060313, 553), + (7060866, 526), + (7061392, 603), + (7061995, 552), + (7062547, 525), + (7063072, 595), + (7063667, 553), + (7064220, 527), + (7064747, 608), + (7065355, 553), + (7065908, 526), + (7066434, 609), + (7067043, 553), + (7067596, 525), + (7068121, 587), + (7068708, 553), + (7069261, 526), + (7069787, 600), + (7070387, 551), + (7070938, 526), + (7071464, 600), + (7072064, 554), + (7072618, 525), + (7073143, 603), + (7073746, 553), + (7074299, 526), + (7074825, 614), + (7075439, 553), + (7075992, 526), + (7076518, 613), + (7077131, 554), + (7077685, 526), + (7078211, 607), + (7078818, 554), + (7079372, 527), + (7079899, 619), + (7080518, 553), + (7081071, 527), + (7081598, 620), + (7082218, 552), + (7082770, 525), + (7083295, 587), + (7083882, 553), + (7084435, 527), + (7084962, 602), + (7085564, 553), + (7086117, 527), + (7086644, 600), + (7087244, 553), + (7087797, 527), + (7088324, 603), + (7088927, 552), + (7089479, 526), + (7090005, 615), + (7090620, 553), + (7091173, 525), + (7091698, 613), + (7092311, 554), + (7092865, 526), + (7093391, 609), + (7094000, 554), + (7094554, 526), + (7095080, 620), + (7095700, 553), + (7096253, 527), + (7096780, 619), + (7097399, 553), + (7097952, 542), + (7098494, 543), + (7099037, 553), + (7099590, 543), + (7100133, 569), + (7100702, 553), + (7101255, 542), + (7101797, 570), + (7102367, 553), + (7102920, 542), + (7103462, 571), + (7104033, 553), + (7104586, 542), + (7105128, 586), + (7105714, 553), + (7106267, 543), + (7106810, 584), + (7107394, 553), + (7107947, 543), + (7108490, 578), + (7109068, 553), + (7109621, 543), + (7110164, 591), + (7110755, 553), + (7111308, 543), + (7111851, 591), + (7112442, 553), + (7112995, 542), + (7113537, 569), + (7114106, 553), + (7114659, 544), + (7115203, 587), + (7115790, 553), + (7116343, 544), + (7116887, 586), + (7117473, 553), + (7118026, 543), + (7118569, 587), + (7119156, 554), + (7119710, 542), + (7120252, 600), + (7120852, 553), + (7121405, 543), + (7121948, 599), + (7122547, 552), + (7123099, 542), + (7123641, 593), + (7124234, 552), + (7124786, 543), + (7125329, 605), + (7125934, 553), + (7126487, 543), + (7127030, 604), + (7127634, 554), + (7128188, 543), + (7128731, 571), + (7129302, 552), + (7129854, 544), + (7130398, 585), + (7130983, 553), + (7131536, 542), + (7132078, 586), + (7132664, 553), + (7133217, 542), + (7133759, 587), + (7134346, 554), + (7134900, 544), + (7135444, 599), + (7136043, 553), + (7136596, 543), + (7137139, 598), + (7137737, 553), + (7138290, 542), + (7138832, 594), + (7139426, 552), + (7139978, 544), + (7140522, 604), + (7141126, 552), + (7141678, 542), + (7142220, 605), + (7142825, 552), + (7143377, 542), + (7143919, 571), + (7144490, 553), + (7145043, 544), + (7145587, 587), + (7146174, 554), + (7146728, 543), + (7147271, 587), + (7147858, 552), + (7148410, 544), + (7148954, 588), + (7149542, 552), + (7150094, 543), + (7150637, 599), + (7151236, 554), + (7151790, 543), + (7152333, 599), + (7152932, 553), + (7153485, 543), + (7154028, 595), + (7154623, 554), + (7155177, 543), + (7155720, 606), + (7156326, 553), + (7156879, 544), + (7157423, 606), + (7158029, 554), + (7158583, 544), + (7159127, 586), + (7159713, 554), + (7160267, 543), + (7160810, 599), + (7161409, 553), + (7161962, 543), + (7162505, 599), + (7163104, 552), + (7163656, 542), + (7164198, 601), + (7164799, 553), + (7165352, 543), + (7165895, 611), + (7166506, 552), + (7167058, 542), + (7167600, 611), + (7168211, 553), + (7168764, 544), + (7169308, 605), + (7169913, 552), + (7170465, 543), + (7171008, 618), + (7171626, 553), + (7172179, 542), + (7172721, 618), + (7173339, 554), + (7173893, 544), + (7174437, 586), + (7175023, 553), + (7175576, 544), + (7176120, 599), + (7176719, 552), + (7177271, 542), + (7177813, 598), + (7178411, 554), + (7178965, 544), + (7179509, 600), + (7180109, 553), + (7180662, 544), + (7181206, 611), + (7181817, 553), + (7182370, 542), + (7182912, 612), + (7183524, 553), + (7184077, 543), + (7184620, 606), + (7185226, 552), + (7185778, 542), + (7186320, 618), + (7186938, 553), + (7187491, 543), + (7188034, 617), + (7188651, 554), + (7189205, 543), + (7189748, 576), + (7190324, 553), + (7190877, 543), + (7191420, 589), + (7192009, 553), + (7192562, 542), + (7193104, 590), + (7193694, 553), + (7194247, 542), + (7194789, 589), + (7195378, 553), + (7195931, 542), + (7196473, 601), + (7197074, 553), + (7197627, 543), + (7198170, 602), + (7198772, 553), + (7199325, 544), + (7199869, 596), + (7200465, 553), + (7201018, 543), + (7201561, 608), + (7202169, 553), + (7202722, 542), + (7203264, 609), + (7203873, 552), + (7204425, 543), + (7204968, 587), + (7205555, 553), + (7206108, 543), + (7206651, 602), + (7207253, 553), + (7207806, 544), + (7208350, 601), + (7208951, 553), + (7209504, 543), + (7210047, 603), + (7210650, 554), + (7211204, 544), + (7211748, 613), + (7212361, 553), + (7212914, 544), + (7213458, 614), + (7214072, 553), + (7214625, 543), + (7215168, 607), + (7215775, 552), + (7216327, 543), + (7216870, 620), + (7217490, 553), + (7218043, 542), + (7218585, 621), + (7219206, 554), + (7219760, 543), + (7220303, 586), + (7220889, 554), + (7221443, 544), + (7221987, 600), + (7222587, 552), + (7223139, 543), + (7223682, 602), + (7224284, 554), + (7224838, 544), + (7225382, 602), + (7225984, 552), + (7226536, 543), + (7227079, 615), + (7227694, 553), + (7228247, 542), + (7228789, 613), + (7229402, 552), + (7229954, 542), + (7230496, 608), + (7231104, 553), + (7231657, 542), + (7232199, 620), + (7232819, 553), + (7233372, 544), + (7233916, 620), + (7234536, 552), + (7235088, 542), + (7235630, 542), + (7236172, 552), + (7236724, 542), + (7237266, 570), + (7237836, 552), + (7238388, 542), + (7238930, 571), + (7239501, 553), + (7240054, 543), + (7240597, 571), + (7241168, 553), + (7241721, 543), + (7242264, 584), + (7242848, 554), + (7243402, 542), + (7243944, 586), + (7244530, 553), + (7245083, 543), + (7245626, 579), + (7246205, 553), + (7246758, 544), + (7247302, 592), + (7247894, 554), + (7248448, 544), + (7248992, 591), + (7249583, 552), + (7250135, 543), + (7250678, 570), + (7251248, 554), + (7251802, 542), + (7252344, 585), + (7252929, 553), + (7253482, 543), + (7254025, 586), + (7254611, 552), + (7255163, 543), + (7255706, 587), + (7256293, 553), + (7256846, 544), + (7257390, 599), + (7257989, 553), + (7258542, 542), + (7259084, 599), + (7259683, 553), + (7260236, 543), + (7260779, 592), + (7261371, 553), + (7261924, 543), + (7262467, 604), + (7263071, 553), + (7263624, 543), + (7264167, 606), + (7264773, 553), + (7265326, 544), + (7265870, 569), + (7266439, 553), + (7266992, 543), + (7267535, 586), + (7268121, 552), + (7268673, 543), + (7269216, 587), + (7269803, 554), + (7270357, 543), + (7270900, 587), + (7271487, 554), + (7272041, 543), + (7272584, 598), + (7273182, 554), + (7273736, 543), + (7274279, 600), + (7274879, 553), + (7275432, 544), + (7275976, 594), + (7276570, 553), + (7277123, 542), + (7277665, 604), + (7278269, 553), + (7278822, 542), + (7279364, 605), + (7279969, 552), + (7280521, 542), + (7281063, 572), + (7281635, 553), + (7282188, 543), + (7282731, 586), + (7283317, 553), + (7283870, 543), + (7284413, 587), + (7285000, 554), + (7285554, 543), + (7286097, 588), + (7286685, 553), + (7287238, 544), + (7287782, 601), + (7288383, 552), + (7288935, 543), + (7289478, 601), + (7290079, 554), + (7290633, 543), + (7291176, 593), + (7291769, 553), + (7292322, 544), + (7292866, 606), + (7293472, 553), + (7294025, 544), + (7294569, 605), + (7295174, 553), + (7295727, 543), + (7296270, 585), + (7296855, 554), + (7297409, 544), + (7297953, 599), + (7298552, 552), + (7299104, 544), + (7299648, 599), + (7300247, 553), + (7300800, 542), + (7301342, 600), + (7301942, 554), + (7302496, 543), + (7303039, 612), + (7303651, 554), + (7304205, 543), + (7304748, 611), + (7305359, 553), + (7305912, 544), + (7306456, 607), + (7307063, 553), + (7307616, 542), + (7308158, 618), + (7308776, 553), + (7309329, 543), + (7309872, 619), + (7310491, 554), + (7311045, 543), + (7311588, 585), + (7312173, 552), + (7312725, 542), + (7313267, 599), + (7313866, 553), + (7314419, 544), + (7314963, 599), + (7315562, 552), + (7316114, 544), + (7316658, 599), + (7317257, 552), + (7317809, 543), + (7318352, 612), + (7318964, 553), + (7319517, 543), + (7320060, 611), + (7320671, 553), + (7321224, 543), + (7321767, 606), + (7322373, 552), + (7322925, 544), + (7323469, 617), + (7324086, 553), + (7324639, 543), + (7325182, 618), + (7325800, 554), + (7326354, 543), + (7326897, 576), + (7327473, 554), + (7328027, 542), + (7328569, 589), + (7329158, 553), + (7329711, 543), + (7330254, 590), + (7330844, 553), + (7331397, 542), + (7331939, 589), + (7332528, 553), + (7333081, 542), + (7333623, 603), + (7334226, 553), + (7334779, 543), + (7335322, 601), + (7335923, 553), + (7336476, 543), + (7337019, 597), + (7337616, 554), + (7338170, 543), + (7338713, 607), + (7339320, 552), + (7339872, 542), + (7340414, 608), + (7341022, 553), + (7341575, 543), + (7342118, 588), + (7342706, 552), + (7343258, 542), + (7343800, 602), + (7344402, 553), + (7344955, 544), + (7345499, 601), + (7346100, 553), + (7346653, 543), + (7347196, 603), + (7347799, 552), + (7348351, 543), + (7348894, 614), + (7349508, 553), + (7350061, 543), + (7350604, 615), + (7351219, 553), + (7351772, 543), + (7352315, 608), + (7352923, 554), + (7353477, 543), + (7354020, 620), + (7354640, 554), + (7355194, 544), + (7355738, 620), + (7356358, 553), + (7356911, 543), + (7357454, 586), + (7358040, 553), + (7358593, 543), + (7359136, 601), + (7359737, 552), + (7360289, 542), + (7360831, 601), + (7361432, 554), + (7361986, 543), + (7362529, 601), + (7363130, 552), + (7363682, 544), + (7364226, 614), + (7364840, 553), + (7365393, 542), + (7365935, 615), + (7366550, 552), + (7367102, 543), + (7367645, 608), + (7368253, 553), + (7368806, 543), + (7369349, 619), + (7369968, 553), + (7370521, 542), + (7371063, 620), + (7371683, 553), + (7372236, 552), + (7372788, 541), + (7373329, 553), + (7373882, 554), + (7374436, 571), + (7375007, 552), + (7375559, 553), + (7376112, 570), + (7376682, 553), + (7377235, 553), + (7377788, 572), + (7378360, 552), + (7378912, 553), + (7379465, 585), + (7380050, 552), + (7380602, 552), + (7381154, 585), + (7381739, 553), + (7382292, 552), + (7382844, 580), + (7383424, 553), + (7383977, 553), + (7384530, 590), + (7385120, 552), + (7385672, 552), + (7386224, 591), + (7386815, 553), + (7387368, 554), + (7387922, 569), + (7388491, 552), + (7389043, 553), + (7389596, 587), + (7390183, 552), + (7390735, 552), + (7391287, 585), + (7391872, 554), + (7392426, 554), + (7392980, 587), + (7393567, 553), + (7394120, 553), + (7394673, 598), + (7395271, 554), + (7395825, 553), + (7396378, 599), + (7396977, 553), + (7397530, 553), + (7398083, 593), + (7398676, 553), + (7399229, 554), + (7399783, 604), + (7400387, 553), + (7400940, 553), + (7401493, 606), + (7402099, 553), + (7402652, 553), + (7403205, 569), + (7403774, 553), + (7404327, 554), + (7404881, 585), + (7405466, 553), + (7406019, 553), + (7406572, 587), + (7407159, 553), + (7407712, 554), + (7408266, 588), + (7408854, 552), + (7409406, 554), + (7409960, 599), + (7410559, 554), + (7411113, 554), + (7411667, 599), + (7412266, 553), + (7412819, 553), + (7413372, 593), + (7413965, 553), + (7414518, 553), + (7415071, 604), + (7415675, 554), + (7416229, 552), + (7416781, 605), + (7417386, 554), + (7417940, 552), + (7418492, 572), + (7419064, 553), + (7419617, 553), + (7420170, 587), + (7420757, 552), + (7421309, 553), + (7421862, 588), + (7422450, 554), + (7423004, 554), + (7423558, 587), + (7424145, 553), + (7424698, 554), + (7425252, 601), + (7425853, 554), + (7426407, 553), + (7426960, 600), + (7427560, 553), + (7428113, 554), + (7428667, 593), + (7429260, 552), + (7429812, 554), + (7430366, 606), + (7430972, 554), + (7431526, 553), + (7432079, 606), + (7432685, 553), + (7433238, 553), + (7433791, 584), + (7434375, 553), + (7434928, 552), + (7435480, 600), + (7436080, 554), + (7436634, 552), + (7437186, 598), + (7437784, 552), + (7438336, 554), + (7438890, 600), + (7439490, 552), + (7440042, 552), + (7440594, 612), + (7441206, 552), + (7441758, 552), + (7442310, 611), + (7442921, 552), + (7443473, 553), + (7444026, 605), + (7444631, 552), + (7445183, 554), + (7445737, 618), + (7446355, 554), + (7446909, 552), + (7447461, 618), + (7448079, 552), + (7448631, 554), + (7449185, 584), + (7449769, 554), + (7450323, 553), + (7450876, 599), + (7451475, 554), + (7452029, 554), + (7452583, 599), + (7453182, 554), + (7453736, 554), + (7454290, 600), + (7454890, 553), + (7455443, 553), + (7455996, 612), + (7456608, 554), + (7457162, 553), + (7457715, 612), + (7458327, 553), + (7458880, 554), + (7459434, 605), + (7460039, 553), + (7460592, 554), + (7461146, 618), + (7461764, 553), + (7462317, 553), + (7462870, 617), + (7463487, 552), + (7464039, 552), + (7464591, 574), + (7465165, 552), + (7465717, 554), + (7466271, 590), + (7466861, 554), + (7467415, 554), + (7467969, 589), + (7468558, 553), + (7469111, 554), + (7469665, 590), + (7470255, 554), + (7470809, 554), + (7471363, 603), + (7471966, 553), + (7472519, 554), + (7473073, 602), + (7473675, 554), + (7474229, 553), + (7474782, 595), + (7475377, 554), + (7475931, 553), + (7476484, 608), + (7477092, 553), + (7477645, 553), + (7478198, 608), + (7478806, 553), + (7479359, 554), + (7479913, 587), + (7480500, 552), + (7481052, 552), + (7481604, 600), + (7482204, 553), + (7482757, 553), + (7483310, 600), + (7483910, 553), + (7484463, 552), + (7485015, 603), + (7485618, 553), + (7486171, 552), + (7486723, 614), + (7487337, 552), + (7487889, 554), + (7488443, 615), + (7489058, 552), + (7489610, 554), + (7490164, 608), + (7490772, 553), + (7491325, 554), + (7491879, 619), + (7492498, 552), + (7493050, 554), + (7493604, 620), + (7494224, 553), + (7494777, 553), + (7495330, 587), + (7495917, 553), + (7496470, 554), + (7497024, 601), + (7497625, 552), + (7498177, 552), + (7498729, 602), + (7499331, 552), + (7499883, 553), + (7500436, 601), + (7501037, 554), + (7501591, 554), + (7502145, 615), + (7502760, 554), + (7503314, 554), + (7503868, 615), + (7504483, 553), + (7505036, 552), + (7505588, 607), + (7506195, 552), + (7506747, 554), + (7507301, 620), + (7507921, 553), + (7508474, 553), + (7509027, 620), + (7509647, 552), + (7510199, 559), + (7510758, 542), + (7511300, 553), + (7511853, 558), + (7512411, 570), + (7512981, 552), + (7513533, 559), + (7514092, 570), + (7514662, 554), + (7515216, 558), + (7515774, 571), + (7516345, 553), + (7516898, 559), + (7517457, 585), + (7518042, 553), + (7518595, 558), + (7519153, 586), + (7519739, 552), + (7520291, 559), + (7520850, 578), + (7521428, 553), + (7521981, 559), + (7522540, 592), + (7523132, 553), + (7523685, 559), + (7524244, 590), + (7524834, 552), + (7525386, 560), + (7525946, 571), + (7526517, 554), + (7527071, 560), + (7527631, 586), + (7528217, 553), + (7528770, 560), + (7529330, 586), + (7529916, 554), + (7530470, 560), + (7531030, 586), + (7531616, 553), + (7532169, 559), + (7532728, 599), + (7533327, 553), + (7533880, 559), + (7534439, 600), + (7535039, 553), + (7535592, 558), + (7536150, 592), + (7536742, 553), + (7537295, 559), + (7537854, 606), + (7538460, 554), + (7539014, 559), + (7539573, 605), + (7540178, 553), + (7540731, 560), + (7541291, 570), + (7541861, 553), + (7542414, 559), + (7542973, 585), + (7543558, 553), + (7544111, 559), + (7544670, 587), + (7545257, 553), + (7545810, 559), + (7546369, 587), + (7546956, 553), + (7547509, 560), + (7548069, 599), + (7548668, 554), + (7549222, 560), + (7549782, 599), + (7550381, 554), + (7550935, 560), + (7551495, 592), + (7552087, 553), + (7552640, 560), + (7553200, 605), + (7553805, 554), + (7554359, 560), + (7554919, 605), + (7555524, 553), + (7556077, 558), + (7556635, 571), + (7557206, 552), + (7557758, 559), + (7558317, 587), + (7558904, 553), + (7559457, 559), + (7560016, 587), + (7560603, 553), + (7561156, 558), + (7561714, 588), + (7562302, 553), + (7562855, 560), + (7563415, 600), + (7564015, 553), + (7564568, 559), + (7565127, 600), + (7565727, 553), + (7566280, 560), + (7566840, 593), + (7567433, 553), + (7567986, 559), + (7568545, 607), + (7569152, 552), + (7569704, 560), + (7570264, 605), + (7570869, 554), + (7571423, 559), + (7571982, 585), + (7572567, 553), + (7573120, 559), + (7573679, 599), + (7574278, 553), + (7574831, 558), + (7575389, 598), + (7575987, 553), + (7576540, 559), + (7577099, 599), + (7577698, 552), + (7578250, 559), + (7578809, 612), + (7579421, 553), + (7579974, 558), + (7580532, 611), + (7581143, 552), + (7581695, 560), + (7582255, 606), + (7582861, 554), + (7583415, 559), + (7583974, 618), + (7584592, 552), + (7585144, 559), + (7585703, 619), + (7586322, 552), + (7586874, 559), + (7587433, 585), + (7588018, 554), + (7588572, 559), + (7589131, 599), + (7589730, 553), + (7590283, 559), + (7590842, 599), + (7591441, 554), + (7591995, 559), + (7592554, 600), + (7593154, 553), + (7593707, 560), + (7594267, 612), + (7594879, 553), + (7595432, 559), + (7595991, 612), + (7596603, 552), + (7597155, 558), + (7597713, 605), + (7598318, 553), + (7598871, 558), + (7599429, 618), + (7600047, 553), + (7600600, 560), + (7601160, 618), + (7601778, 554), + (7602332, 559), + (7602891, 575), + (7603466, 552), + (7604018, 559), + (7604577, 589), + (7605166, 553), + (7605719, 559), + (7606278, 588), + (7606866, 552), + (7607418, 560), + (7607978, 590), + (7608568, 554), + (7609122, 560), + (7609682, 602), + (7610284, 552), + (7610836, 560), + (7611396, 603), + (7611999, 553), + (7612552, 559), + (7613111, 596), + (7613707, 553), + (7614260, 558), + (7614818, 607), + (7615425, 552), + (7615977, 560), + (7616537, 608), + (7617145, 552), + (7617697, 559), + (7618256, 587), + (7618843, 552), + (7619395, 559), + (7619954, 602), + (7620556, 553), + (7621109, 559), + (7621668, 601), + (7622269, 554), + (7622823, 559), + (7623382, 602), + (7623984, 553), + (7624537, 559), + (7625096, 614), + (7625710, 553), + (7626263, 559), + (7626822, 614), + (7627436, 553), + (7627989, 558), + (7628547, 608), + (7629155, 553), + (7629708, 558), + (7630266, 620), + (7630886, 554), + (7631440, 559), + (7631999, 620), + (7632619, 553), + (7633172, 558), + (7633730, 588), + (7634318, 553), + (7634871, 559), + (7635430, 601), + (7636031, 553), + (7636584, 559), + (7637143, 602), + (7637745, 552), + (7638297, 559), + (7638856, 602), + (7639458, 553), + (7640011, 558), + (7640569, 613), + (7641182, 553), + (7641735, 559), + (7642294, 615), + (7642909, 553), + (7643462, 559), + (7644021, 607), + (7644628, 552), + (7645180, 559), + (7645739, 621), + (7646360, 553), + (7646913, 559), + (7647472, 621), + (7648093, 552), + (7648645, 559), + (7649204, 543), + (7649747, 553), + (7650300, 560), + (7650860, 569), + (7651429, 553), + (7651982, 559), + (7652541, 570), + (7653111, 553), + (7653664, 560), + (7654224, 572), + (7654796, 552), + (7655348, 560), + (7655908, 585), + (7656493, 553), + (7657046, 558), + (7657604, 586), + (7658190, 553), + (7658743, 558), + (7659301, 580), + (7659881, 553), + (7660434, 560), + (7660994, 591), + (7661585, 553), + (7662138, 559), + (7662697, 592), + (7663289, 554), + (7663843, 559), + (7664402, 570), + (7664972, 553), + (7665525, 559), + (7666084, 586), + (7666670, 553), + (7667223, 559), + (7667782, 586), + (7668368, 554), + (7668922, 560), + (7669482, 587), + (7670069, 554), + (7670623, 559), + (7671182, 598), + (7671780, 554), + (7672334, 559), + (7672893, 599), + (7673492, 553), + (7674045, 558), + (7674603, 594), + (7675197, 553), + (7675750, 558), + (7676308, 604), + (7676912, 554), + (7677466, 558), + (7678024, 606), + (7678630, 552), + (7679182, 558), + (7679740, 569), + (7680309, 552), + (7680861, 560), + (7681421, 585), + (7682006, 553), + (7682559, 558), + (7683117, 586), + (7683703, 553), + (7684256, 560), + (7684816, 587), + (7685403, 553), + (7685956, 560), + (7686516, 599), + (7687115, 553), + (7687668, 560), + (7688228, 599), + (7688827, 552), + (7689379, 560), + (7689939, 594), + (7690533, 554), + (7691087, 560), + (7691647, 605), + (7692252, 553), + (7692805, 558), + (7693363, 606), + (7693969, 553), + (7694522, 559), + (7695081, 571), + (7695652, 553), + (7696205, 558), + (7696763, 586), + (7697349, 554), + (7697903, 558), + (7698461, 587), + (7699048, 554), + (7699602, 558), + (7700160, 587), + (7700747, 553), + (7701300, 559), + (7701859, 600), + (7702459, 553), + (7703012, 560), + (7703572, 600), + (7704172, 553), + (7704725, 558), + (7705283, 595), + (7705878, 553), + (7706431, 558), + (7706989, 606), + (7707595, 552), + (7708147, 560), + (7708707, 605), + (7709312, 553), + (7709865, 559), + (7710424, 585), + (7711009, 552), + (7711561, 559), + (7712120, 598), + (7712718, 553), + (7713271, 558), + (7713829, 598), + (7714427, 553), + (7714980, 559), + (7715539, 599), + (7716138, 554), + (7716692, 559), + (7717251, 612), + (7717863, 552), + (7718415, 559), + (7718974, 612), + (7719586, 554), + (7720140, 560), + (7720700, 606), + (7721306, 554), + (7721860, 560), + (7722420, 618), + (7723038, 553), + (7723591, 559), + (7724150, 617), + (7724767, 553), + (7725320, 559), + (7725879, 586), + (7726465, 552), + (7727017, 559), + (7727576, 599), + (7728175, 553), + (7728728, 559), + (7729287, 600), + (7729887, 554), + (7730441, 558), + (7730999, 600), + (7731599, 554), + (7732153, 560), + (7732713, 611), + (7733324, 553), + (7733877, 559), + (7734436, 613), + (7735049, 553), + (7735602, 560), + (7736162, 606), + (7736768, 553), + (7737321, 559), + (7737880, 618), + (7738498, 554), + (7739052, 560), + (7739612, 617), + (7740229, 554), + (7740783, 559), + (7741342, 574), + (7741916, 553), + (7742469, 558), + (7743027, 590), + (7743617, 554), + (7744171, 560), + (7744731, 589), + (7745320, 553), + (7745873, 559), + (7746432, 589), + (7747021, 553), + (7747574, 558), + (7748132, 602), + (7748734, 552), + (7749286, 560), + (7749846, 602), + (7750448, 552), + (7751000, 559), + (7751559, 595), + (7752154, 552), + (7752706, 559), + (7753265, 609), + (7753874, 552), + (7754426, 559), + (7754985, 608), + (7755593, 553), + (7756146, 559), + (7756705, 588), + (7757293, 553), + (7757846, 559), + (7758405, 601), + (7759006, 553), + (7759559, 559), + (7760118, 600), + (7760718, 552), + (7761270, 560), + (7761830, 601), + (7762431, 553), + (7762984, 559), + (7763543, 613), + (7764156, 553), + (7764709, 559), + (7765268, 614), + (7765882, 552), + (7766434, 558), + (7766992, 608), + (7767600, 553), + (7768153, 559), + (7768712, 620), + (7769332, 553), + (7769885, 558), + (7770443, 619), + (7771062, 554), + (7771616, 560), + (7772176, 587), + (7772763, 552), + (7773315, 559), + (7773874, 601), + (7774475, 554), + (7775029, 560), + (7775589, 600), + (7776189, 553), + (7776742, 559), + (7777301, 601), + (7777902, 553), + (7778455, 559), + (7779014, 614), + (7779628, 553), + (7780181, 559), + (7780740, 614), + (7781354, 554), + (7781908, 560), + (7782468, 608), + (7783076, 553), + (7783629, 558), + (7784187, 620), + (7784807, 553), + (7785360, 560), + (7785920, 620), + (7786540, 554), + (7787094, 555), + (7787649, 542), + (7788191, 553), + (7788744, 555), + (7789299, 570), + (7789869, 553), + (7790422, 554), + (7790976, 570), + (7791546, 552), + (7792098, 555), + (7792653, 572), + (7793225, 553), + (7793778, 554), + (7794332, 585), + (7794917, 553), + (7795470, 553), + (7796023, 586), + (7796609, 552), + (7797161, 554), + (7797715, 578), + (7798293, 553), + (7798846, 555), + (7799401, 592), + (7799993, 553), + (7800546, 554), + (7801100, 592), + (7801692, 553), + (7802245, 554), + (7802799, 570), + (7803369, 553), + (7803922, 554), + (7804476, 586), + (7805062, 554), + (7805616, 554), + (7806170, 586), + (7806756, 553), + (7807309, 554), + (7807863, 587), + (7808450, 553), + (7809003, 555), + (7809558, 599), + (7810157, 554), + (7810711, 555), + (7811266, 599), + (7811865, 552), + (7812417, 555), + (7812972, 594), + (7813566, 554), + (7814120, 555), + (7814675, 604), + (7815279, 553), + (7815832, 553), + (7816385, 604), + (7816989, 553), + (7817542, 553), + (7818095, 571), + (7818666, 552), + (7819218, 554), + (7819772, 586), + (7820358, 554), + (7820912, 553), + (7821465, 587), + (7822052, 554), + (7822606, 553), + (7823159, 588), + (7823747, 553), + (7824300, 553), + (7824853, 600), + (7825453, 553), + (7826006, 555), + (7826561, 598), + (7827159, 553), + (7827712, 555), + (7828267, 593), + (7828860, 553), + (7829413, 555), + (7829968, 606), + (7830574, 553), + (7831127, 554), + (7831681, 604), + (7832285, 552), + (7832837, 554), + (7833391, 572), + (7833963, 554), + (7834517, 554), + (7835071, 586), + (7835657, 552), + (7836209, 554), + (7836763, 587), + (7837350, 553), + (7837903, 554), + (7838457, 589), + (7839046, 552), + (7839598, 555), + (7840153, 600), + (7840753, 552), + (7841305, 555), + (7841860, 599), + (7842459, 552), + (7843011, 554), + (7843565, 594), + (7844159, 554), + (7844713, 555), + (7845268, 606), + (7845874, 554), + (7846428, 554), + (7846982, 606), + (7847588, 553), + (7848141, 554), + (7848695, 586), + (7849281, 552), + (7849833, 554), + (7850387, 598), + (7850985, 553), + (7851538, 555), + (7852093, 598), + (7852691, 553), + (7853244, 554), + (7853798, 601), + (7854399, 554), + (7854953, 553), + (7855506, 612), + (7856118, 553), + (7856671, 553), + (7857224, 611), + (7857835, 553), + (7858388, 555), + (7858943, 606), + (7859549, 553), + (7860102, 554), + (7860656, 619), + (7861275, 552), + (7861827, 553), + (7862380, 618), + (7862998, 552), + (7863550, 555), + (7864105, 585), + (7864690, 552), + (7865242, 554), + (7865796, 598), + (7866394, 553), + (7866947, 554), + (7867501, 600), + (7868101, 553), + (7868654, 553), + (7869207, 601), + (7869808, 553), + (7870361, 553), + (7870914, 611), + (7871525, 553), + (7872078, 553), + (7872631, 612), + (7873243, 553), + (7873796, 553), + (7874349, 606), + (7874955, 553), + (7875508, 554), + (7876062, 618), + (7876680, 554), + (7877234, 554), + (7877788, 618), + (7878406, 552), + (7878958, 553), + (7879511, 574), + (7880085, 552), + (7880637, 554), + (7881191, 590), + (7881781, 552), + (7882333, 554), + (7882887, 588), + (7883475, 552), + (7884027, 553), + (7884580, 590), + (7885170, 553), + (7885723, 553), + (7886276, 601), + (7886877, 553), + (7887430, 554), + (7887984, 601), + (7888585, 553), + (7889138, 555), + (7889693, 595), + (7890288, 553), + (7890841, 553), + (7891394, 608), + (7892002, 552), + (7892554, 554), + (7893108, 607), + (7893715, 553), + (7894268, 554), + (7894822, 586), + (7895408, 552), + (7895960, 554), + (7896514, 601), + (7897115, 554), + (7897669, 554), + (7898223, 601), + (7898824, 553), + (7899377, 555), + (7899932, 602), + (7900534, 552), + (7901086, 553), + (7901639, 614), + (7902253, 553), + (7902806, 554), + (7903360, 615), + (7903975, 554), + (7904529, 555), + (7905084, 608), + (7905692, 552), + (7906244, 553), + (7906797, 619), + (7907416, 554), + (7907970, 555), + (7908525, 621), + (7909146, 554), + (7909700, 555), + (7910255, 588), + (7910843, 553), + (7911396, 553), + (7911949, 601), + (7912550, 554), + (7913104, 554), + (7913658, 602), + (7914260, 553), + (7914813, 555), + (7915368, 602), + (7915970, 553), + (7916523, 554), + (7917077, 613), + (7917690, 554), + (7918244, 553), + (7918797, 614), + (7919411, 552), + (7919963, 555), + (7920518, 607), + (7921125, 554), + (7921679, 554), + (7922233, 620), + (7922853, 554), + (7923407, 554), + (7923961, 620), + (7924581, 553), + (7925134, 560), + (7925694, 542), + (7926236, 553), + (7926789, 559), + (7927348, 570), + (7927918, 553), + (7928471, 561), + (7929032, 571), + (7929603, 552), + (7930155, 559), + (7930714, 572), + (7931286, 553), + (7931839, 561), + (7932400, 586), + (7932986, 553), + (7933539, 560), + (7934099, 586), + (7934685, 553), + (7935238, 561), + (7935799, 579), + (7936378, 554), + (7936932, 559), + (7937491, 590), + (7938081, 554), + (7938635, 561), + (7939196, 590), + (7939786, 552), + (7940338, 561), + (7940899, 571), + (7941470, 553), + (7942023, 560), + (7942583, 586), + (7943169, 552), + (7943721, 559), + (7944280, 586), + (7944866, 553), + (7945419, 561), + (7945980, 587), + (7946567, 552), + (7947119, 560), + (7947679, 598), + (7948277, 553), + (7948830, 559), + (7949389, 599), + (7949988, 552), + (7950540, 559), + (7951099, 592), + (7951691, 554), + (7952245, 560), + (7952805, 604), + (7953409, 552), + (7953961, 559), + (7954520, 604), + (7955124, 554), + (7955678, 561), + (7956239, 570), + (7956809, 553), + (7957362, 561), + (7957923, 585), + (7958508, 554), + (7959062, 559), + (7959621, 585), + (7960206, 553), + (7960759, 561), + (7961320, 587), + (7961907, 553), + (7962460, 561), + (7963021, 599), + (7963620, 553), + (7964173, 561), + (7964734, 598), + (7965332, 553), + (7965885, 560), + (7966445, 593), + (7967038, 553), + (7967591, 561), + (7968152, 605), + (7968757, 553), + (7969310, 561), + (7969871, 605), + (7970476, 553), + (7971029, 560), + (7971589, 573), + (7972162, 553), + (7972715, 560), + (7973275, 586), + (7973861, 553), + (7974414, 561), + (7974975, 587), + (7975562, 554), + (7976116, 560), + (7976676, 588), + (7977264, 553), + (7977817, 560), + (7978377, 601), + (7978978, 552), + (7979530, 560), + (7980090, 601), + (7980691, 553), + (7981244, 560), + (7981804, 593), + (7982397, 552), + (7982949, 559), + (7983508, 607), + (7984115, 553), + (7984668, 559), + (7985227, 606), + (7985833, 553), + (7986386, 559), + (7986945, 585), + (7987530, 553), + (7988083, 561), + (7988644, 598), + (7989242, 552), + (7989794, 560), + (7990354, 599), + (7990953, 553), + (7991506, 560), + (7992066, 601), + (7992667, 552), + (7993219, 561), + (7993780, 612), + (7994392, 553), + (7994945, 559), + (7995504, 613), + (7996117, 554), + (7996671, 560), + (7997231, 605), + (7997836, 553), + (7998389, 561), + (7998950, 619), + (7999569, 552), + (8000121, 560), + (8000681, 619), + (8001300, 554), + (8001854, 559), + (8002413, 585), + (8002998, 552), + (8003550, 559), + (8004109, 599), + (8004708, 553), + (8005261, 560), + (8005821, 598), + (8006419, 553), + (8006972, 560), + (8007532, 600), + (8008132, 553), + (8008685, 560), + (8009245, 612), + (8009857, 552), + (8010409, 561), + (8010970, 613), + (8011583, 553), + (8012136, 559), + (8012695, 605), + (8013300, 553), + (8013853, 561), + (8014414, 618), + (8015032, 553), + (8015585, 559), + (8016144, 619), + (8016763, 553), + (8017316, 560), + (8017876, 575), + (8018451, 552), + (8019003, 559), + (8019562, 588), + (8020150, 553), + (8020703, 560), + (8021263, 590), + (8021853, 554), + (8022407, 560), + (8022967, 589), + (8023556, 552), + (8024108, 559), + (8024667, 603), + (8025270, 553), + (8025823, 560), + (8026383, 602), + (8026985, 553), + (8027538, 560), + (8028098, 596), + (8028694, 553), + (8029247, 560), + (8029807, 609), + (8030416, 553), + (8030969, 560), + (8031529, 608), + (8032137, 554), + (8032691, 560), + (8033251, 586), + (8033837, 553), + (8034390, 561), + (8034951, 602), + (8035553, 552), + (8036105, 560), + (8036665, 601), + (8037266, 553), + (8037819, 561), + (8038380, 603), + (8038983, 553), + (8039536, 561), + (8040097, 614), + (8040711, 554), + (8041265, 561), + (8041826, 614), + (8042440, 552), + (8042992, 561), + (8043553, 606), + (8044159, 554), + (8044713, 561), + (8045274, 619), + (8045893, 553), + (8046446, 559), + (8047005, 621), + (8047626, 552), + (8048178, 561), + (8048739, 586), + (8049325, 553), + (8049878, 561), + (8050439, 601), + (8051040, 553), + (8051593, 561), + (8052154, 600), + (8052754, 553), + (8053307, 559), + (8053866, 603), + (8054469, 554), + (8055023, 560), + (8055583, 613), + (8056196, 554), + (8056750, 560), + (8057310, 614), + (8057924, 552), + (8058476, 560), + (8059036, 607), + (8059643, 554), + (8060197, 559), + (8060756, 620), + (8061376, 553), + (8061929, 560), + (8062489, 621), + (8063110, 552), + (8063662, 560), + (8064222, 543), + (8064765, 553), + (8065318, 560), + (8065878, 570), + (8066448, 553), + (8067001, 559), + (8067560, 570), + (8068130, 553), + (8068683, 560), + (8069243, 572), + (8069815, 553), + (8070368, 560), + (8070928, 586), + (8071514, 553), + (8072067, 560), + (8072627, 584), + (8073211, 552), + (8073763, 560), + (8074323, 580), + (8074903, 553), + (8075456, 560), + (8076016, 590), + (8076606, 554), + (8077160, 559), + (8077719, 592), + (8078311, 552), + (8078863, 560), + (8079423, 571), + (8079994, 554), + (8080548, 560), + (8081108, 586), + (8081694, 553), + (8082247, 560), + (8082807, 585), + (8083392, 553), + (8083945, 560), + (8084505, 586), + (8085091, 553), + (8085644, 561), + (8086205, 600), + (8086805, 553), + (8087358, 561), + (8087919, 600), + (8088519, 553), + (8089072, 559), + (8089631, 592), + (8090223, 553), + (8090776, 560), + (8091336, 606), + (8091942, 552), + (8092494, 561), + (8093055, 605), + (8093660, 554), + (8094214, 561), + (8094775, 570), + (8095345, 554), + (8095899, 559), + (8096458, 585), + (8097043, 553), + (8097596, 560), + (8098156, 586), + (8098742, 552), + (8099294, 560), + (8099854, 587), + (8100441, 552), + (8100993, 560), + (8101553, 600), + (8102153, 553), + (8102706, 560), + (8103266, 599), + (8103865, 553), + (8104418, 559), + (8104977, 593), + (8105570, 554), + (8106124, 560), + (8106684, 605), + (8107289, 552), + (8107841, 561), + (8108402, 606), + (8109008, 553), + (8109561, 561), + (8110122, 573), + (8110695, 553), + (8111248, 560), + (8111808, 588), + (8112396, 552), + (8112948, 560), + (8113508, 587), + (8114095, 553), + (8114648, 560), + (8115208, 589), + (8115797, 553), + (8116350, 559), + (8116909, 599), + (8117508, 553), + (8118061, 561), + (8118622, 600), + (8119222, 552), + (8119774, 560), + (8120334, 594), + (8120928, 554), + (8121482, 560), + (8122042, 607), + (8122649, 554), + (8123203, 559), + (8123762, 605), + (8124367, 553), + (8124920, 559), + (8125479, 585), + (8126064, 553), + (8126617, 559), + (8127176, 600), + (8127776, 553), + (8128329, 560), + (8128889, 598), + (8129487, 552), + (8130039, 560), + (8130599, 600), + (8131199, 553), + (8131752, 559), + (8132311, 613), + (8132924, 552), + (8133476, 561), + (8134037, 612), + (8134649, 552), + (8135201, 560), + (8135761, 605), + (8136366, 553), + (8136919, 560), + (8137479, 618), + (8138097, 552), + (8138649, 560), + (8139209, 618), + (8139827, 552), + (8140379, 560), + (8140939, 585), + (8141524, 553), + (8142077, 560), + (8142637, 600), + (8143237, 552), + (8143789, 560), + (8144349, 598), + (8144947, 553), + (8145500, 561), + (8146061, 600), + (8146661, 552), + (8147213, 561), + (8147774, 612), + (8148386, 553), + (8148939, 560), + (8149499, 613), + (8150112, 554), + (8150666, 560), + (8151226, 606), + (8151832, 553), + (8152385, 560), + (8152945, 619), + (8153564, 553), + (8154117, 560), + (8154677, 617), + (8155294, 554), + (8155848, 560), + (8156408, 575), + (8156983, 553), + (8157536, 561), + (8158097, 588), + (8158685, 553), + (8159238, 560), + (8159798, 589), + (8160387, 553), + (8160940, 560), + (8161500, 590), + (8162090, 553), + (8162643, 561), + (8163204, 602), + (8163806, 554), + (8164360, 559), + (8164919, 603), + (8165522, 552), + (8166074, 559), + (8166633, 595), + (8167228, 552), + (8167780, 560), + (8168340, 608), + (8168948, 552), + (8169500, 560), + (8170060, 608), + (8170668, 553), + (8171221, 560), + (8171781, 588), + (8172369, 552), + (8172921, 561), + (8173482, 602), + (8174084, 552), + (8174636, 560), + (8175196, 602), + (8175798, 553), + (8176351, 559), + (8176910, 603), + (8177513, 553), + (8178066, 560), + (8178626, 615), + (8179241, 554), + (8179795, 559), + (8180354, 614), + (8180968, 553), + (8181521, 560), + (8182081, 607), + (8182688, 552), + (8183240, 559), + (8183799, 619), + (8184418, 553), + (8184971, 561), + (8185532, 621), + (8186153, 553), + (8186706, 560), + (8187266, 587), + (8187853, 554), + (8188407, 560), + (8188967, 600), + (8189567, 553), + (8190120, 560), + (8190680, 600), + (8191280, 553), + (8191833, 560), + (8192393, 602), + (8192995, 553), + (8193548, 561), + (8194109, 613), + (8194722, 553), + (8195275, 560), + (8195835, 613), + (8196448, 553), + (8197001, 559), + (8197560, 608), + (8198168, 552), + (8198720, 559), + (8199279, 621), + (8199900, 554), + (8200454, 560), + (8201014, 620), + (8201634, 552), + (8202186, 507), + (8202693, 542), + (8203235, 552), + (8203787, 509), + (8204296, 570), + (8204866, 553), + (8205419, 508), + (8205927, 570), + (8206497, 553), + (8207050, 508), + (8207558, 573), + (8208131, 554), + (8208685, 509), + (8209194, 586), + (8209780, 553), + (8210333, 509), + (8210842, 586), + (8211428, 554), + (8211982, 508), + (8212490, 579), + (8213069, 552), + (8213621, 508), + (8214129, 591), + (8214720, 553), + (8215273, 507), + (8215780, 591), + (8216371, 554), + (8216925, 508), + (8217433, 570), + (8218003, 553), + (8218556, 508), + (8219064, 586), + (8219650, 553), + (8220203, 508), + (8220711, 586), + (8221297, 553), + (8221850, 509), + (8222359, 586), + (8222945, 554), + (8223499, 508), + (8224007, 598), + (8224605, 553), + (8225158, 509), + (8225667, 599), + (8226266, 552), + (8226818, 508), + (8227326, 593), + (8227919, 552), + (8228471, 509), + (8228980, 604), + (8229584, 554), + (8230138, 508), + (8230646, 606), + (8231252, 552), + (8231804, 509), + (8232313, 570), + (8232883, 554), + (8233437, 508), + (8233945, 586), + (8234531, 554), + (8235085, 508), + (8235593, 586), + (8236179, 552), + (8236731, 508), + (8237239, 588), + (8237827, 553), + (8238380, 507), + (8238887, 599), + (8239486, 552), + (8240038, 507), + (8240545, 599), + (8241144, 554), + (8241698, 509), + (8242207, 592), + (8242799, 553), + (8243352, 507), + (8243859, 606), + (8244465, 553), + (8245018, 508), + (8245526, 604), + (8246130, 552), + (8246682, 508), + (8247190, 572), + (8247762, 554), + (8248316, 508), + (8248824, 587), + (8249411, 554), + (8249965, 509), + (8250474, 587), + (8251061, 554), + (8251615, 509), + (8252124, 588), + (8252712, 554), + (8253266, 508), + (8253774, 599), + (8254373, 553), + (8254926, 508), + (8255434, 600), + (8256034, 552), + (8256586, 508), + (8257094, 593), + (8257687, 554), + (8258241, 508), + (8258749, 607), + (8259356, 552), + (8259908, 509), + (8260417, 605), + (8261022, 553), + (8261575, 508), + (8262083, 586), + (8262669, 552), + (8263221, 507), + (8263728, 600), + (8264328, 554), + (8264882, 508), + (8265390, 600), + (8265990, 553), + (8266543, 509), + (8267052, 601), + (8267653, 554), + (8268207, 508), + (8268715, 611), + (8269326, 553), + (8269879, 508), + (8270387, 611), + (8270998, 553), + (8271551, 509), + (8272060, 605), + (8272665, 553), + (8273218, 507), + (8273725, 617), + (8274342, 552), + (8274894, 508), + (8275402, 619), + (8276021, 553), + (8276574, 507), + (8277081, 584), + (8277665, 553), + (8278218, 507), + (8278725, 599), + (8279324, 552), + (8279876, 508), + (8280384, 599), + (8280983, 552), + (8281535, 508), + (8282043, 601), + (8282644, 552), + (8283196, 509), + (8283705, 612), + (8284317, 552), + (8284869, 507), + (8285376, 611), + (8285987, 552), + (8286539, 508), + (8287047, 605), + (8287652, 552), + (8288204, 508), + (8288712, 617), + (8289329, 553), + (8289882, 509), + (8290391, 618), + (8291009, 552), + (8291561, 508), + (8292069, 574), + (8292643, 554), + (8293197, 508), + (8293705, 589), + (8294294, 553), + (8294847, 508), + (8295355, 589), + (8295944, 552), + (8296496, 507), + (8297003, 590), + (8297593, 553), + (8298146, 507), + (8298653, 603), + (8299256, 553), + (8299809, 508), + (8300317, 601), + (8300918, 552), + (8301470, 509), + (8301979, 597), + (8302576, 553), + (8303129, 508), + (8303637, 608), + (8304245, 553), + (8304798, 507), + (8305305, 607), + (8305912, 553), + (8306465, 508), + (8306973, 586), + (8307559, 552), + (8308111, 508), + (8308619, 600), + (8309219, 552), + (8309771, 508), + (8310279, 601), + (8310880, 552), + (8311432, 507), + (8311939, 602), + (8312541, 553), + (8313094, 509), + (8313603, 613), + (8314216, 553), + (8314769, 508), + (8315277, 613), + (8315890, 554), + (8316444, 508), + (8316952, 608), + (8317560, 553), + (8318113, 507), + (8318620, 619), + (8319239, 554), + (8319793, 507), + (8320300, 619), + (8320919, 552), + (8321471, 508), + (8321979, 587), + (8322566, 552), + (8323118, 507), + (8323625, 601), + (8324226, 554), + (8324780, 507), + (8325287, 601), + (8325888, 552), + (8326440, 508), + (8326948, 603), + (8327551, 554), + (8328105, 508), + (8328613, 613), + (8329226, 552), + (8329778, 507), + (8330285, 613), + (8330898, 553), + (8331451, 508), + (8331959, 609), + (8332568, 553), + (8333121, 508), + (8333629, 620), + (8334249, 552), + (8334801, 507), + (8335308, 619), + (8335927, 554), + (8336481, 526), + (8337007, 542), + (8337549, 553), + (8338102, 526), + (8338628, 570), + (8339198, 552), + (8339750, 524), + (8340274, 569), + (8340843, 553), + (8341396, 524), + (8341920, 572), + (8342492, 554), + (8343046, 526), + (8343572, 585), + (8344157, 554), + (8344711, 525), + (8345236, 584), + (8345820, 554), + (8346374, 524), + (8346898, 580), + (8347478, 554), + (8348032, 525), + (8348557, 591), + (8349148, 554), + (8349702, 525), + (8350227, 590), + (8350817, 554), + (8351371, 525), + (8351896, 571), + (8352467, 554), + (8353021, 525), + (8353546, 585), + (8354131, 552), + (8354683, 526), + (8355209, 587), + (8355796, 554), + (8356350, 525), + (8356875, 585), + (8357460, 553), + (8358013, 525), + (8358538, 598), + (8359136, 552), + (8359688, 524), + (8360212, 598), + (8360810, 552), + (8361362, 525), + (8361887, 593), + (8362480, 552), + (8363032, 525), + (8363557, 604), + (8364161, 553), + (8364714, 525), + (8365239, 606), + (8365845, 553), + (8366398, 526), + (8366924, 571), + (8367495, 553), + (8368048, 526), + (8368574, 586), + (8369160, 552), + (8369712, 526), + (8370238, 586), + (8370824, 553), + (8371377, 524), + (8371901, 588), + (8372489, 553), + (8373042, 526), + (8373568, 599), + (8374167, 551), + (8374718, 525), + (8375243, 598), + (8375841, 552), + (8376393, 524), + (8376917, 593), + (8377510, 553), + (8378063, 524), + (8378587, 604), + (8379191, 553), + (8379744, 525), + (8380269, 604), + (8380873, 552), + (8381425, 525), + (8381950, 571), + (8382521, 553), + (8383074, 525), + (8383599, 587), + (8384186, 553), + (8384739, 524), + (8385263, 586), + (8385849, 552), + (8386401, 526), + (8386927, 589), + (8387516, 553), + (8388069, 526), + (8388595, 600), + (8389195, 552), + (8389747, 524), + (8390271, 601), + (8390872, 552), + (8391424, 525), + (8391949, 595), + (8392544, 553), + (8393097, 525), + (8393622, 606), + (8394228, 553), + (8394781, 524), + (8395305, 605), + (8395910, 553), + (8396463, 526), + (8396989, 585), + (8397574, 552), + (8398126, 525), + (8398651, 598), + (8399249, 553), + (8399802, 525), + (8400327, 598), + (8400925, 553), + (8401478, 525), + (8402003, 599), + (8402602, 552), + (8403154, 524), + (8403678, 612), + (8404290, 552), + (8404842, 524), + (8405366, 613), + (8405979, 552), + (8406531, 526), + (8407057, 606), + (8407663, 553), + (8408216, 526), + (8408742, 619), + (8409361, 554), + (8409915, 524), + (8410439, 619), + (8411058, 554), + (8411612, 525), + (8412137, 585), + (8412722, 553), + (8413275, 526), + (8413801, 599), + (8414400, 553), + (8414953, 524), + (8415477, 600), + (8416077, 554), + (8416631, 524), + (8417155, 600), + (8417755, 552), + (8418307, 526), + (8418833, 611), + (8419444, 553), + (8419997, 526), + (8420523, 612), + (8421135, 553), + (8421688, 524), + (8422212, 606), + (8422818, 552), + (8423370, 526), + (8423896, 617), + (8424513, 552), + (8425065, 524), + (8425589, 619), + (8426208, 554), + (8426762, 526), + (8427288, 575), + (8427863, 553), + (8428416, 525), + (8428941, 588), + (8429529, 553), + (8430082, 526), + (8430608, 589), + (8431197, 554), + (8431751, 524), + (8432275, 591), + (8432866, 554), + (8433420, 525), + (8433945, 603), + (8434548, 553), + (8435101, 524), + (8435625, 601), + (8436226, 553), + (8436779, 525), + (8437304, 595), + (8437899, 553), + (8438452, 524), + (8438976, 607), + (8439583, 554), + (8440137, 524), + (8440661, 609), + (8441270, 553), + (8441823, 525), + (8442348, 586), + (8442934, 553), + (8443487, 526), + (8444013, 602), + (8444615, 552), + (8445167, 526), + (8445693, 601), + (8446294, 553), + (8446847, 525), + (8447372, 602), + (8447974, 553), + (8448527, 526), + (8449053, 615), + (8449668, 552), + (8450220, 525), + (8450745, 614), + (8451359, 553), + (8451912, 525), + (8452437, 608), + (8453045, 553), + (8453598, 524), + (8454122, 619), + (8454741, 554), + (8455295, 525), + (8455820, 619), + (8456439, 552), + (8456991, 524), + (8457515, 587), + (8458102, 553), + (8458655, 526), + (8459181, 600), + (8459781, 552), + (8460333, 526), + (8460859, 601), + (8461460, 553), + (8462013, 525), + (8462538, 602), + (8463140, 553), + (8463693, 526), + (8464219, 615), + (8464834, 554), + (8465388, 524), + (8465912, 613), + (8466525, 553), + (8467078, 525), + (8467603, 607), + (8468210, 553), + (8468763, 525), + (8469288, 620), + (8469908, 553), + (8470461, 524), + (8470985, 621), + (8471606, 553), + (8472159, 524), + (8472683, 542), + (8473225, 553), + (8473778, 525), + (8474303, 571), + (8474874, 552), + (8475426, 524), + (8475950, 570), + (8476520, 554), + (8477074, 526), + (8477600, 572), + (8478172, 554), + (8478726, 526), + (8479252, 585), + (8479837, 553), + (8480390, 524), + (8480914, 585), + (8481499, 552), + (8482051, 525), + (8482576, 579), + (8483155, 553), + (8483708, 524), + (8484232, 592), + (8484824, 554), + (8485378, 525), + (8485903, 590), + (8486493, 552), + (8487045, 524), + (8487569, 570), + (8488139, 553), + (8488692, 524), + (8489216, 586), + (8489802, 553), + (8490355, 526), + (8490881, 586), + (8491467, 554), + (8492021, 526), + (8492547, 586), + (8493133, 553), + (8493686, 525), + (8494211, 599), + (8494810, 553), + (8495363, 526), + (8495889, 600), + (8496489, 553), + (8497042, 524), + (8497566, 593), + (8498159, 552), + (8498711, 525), + (8499236, 606), + (8499842, 554), + (8500396, 525), + (8500921, 605), + (8501526, 553), + (8502079, 526), + (8502605, 570), + (8503175, 553), + (8503728, 524), + (8504252, 587), + (8504839, 553), + (8505392, 525), + (8505917, 587), + (8506504, 553), + (8507057, 524), + (8507581, 588), + (8508169, 552), + (8508721, 525), + (8509246, 600), + (8509846, 552), + (8510398, 524), + (8510922, 599), + (8511521, 553), + (8512074, 524), + (8512598, 592), + (8513190, 554), + (8513744, 524), + (8514268, 604), + (8514872, 553), + (8515425, 524), + (8515949, 605), + (8516554, 552), + (8517106, 525), + (8517631, 572), + (8518203, 552), + (8518755, 525), + (8519280, 586), + (8519866, 552), + (8520418, 525), + (8520943, 588), + (8521531, 554), + (8522085, 524), + (8522609, 588), + (8523197, 553), + (8523750, 526), + (8524276, 601), + (8524877, 554), + (8525431, 526), + (8525957, 600), + (8526557, 552), + (8527109, 524), + (8527633, 594), + (8528227, 553), + (8528780, 526), + (8529306, 606), + (8529912, 552), + (8530464, 526), + (8530990, 605), + (8531595, 553), + (8532148, 525), + (8532673, 584), + (8533257, 554), + (8533811, 525), + (8534336, 597), + (8534933, 552), + (8535485, 525), + (8536010, 599), + (8536609, 554), + (8537163, 525), + (8537688, 599), + (8538287, 553), + (8538840, 525), + (8539365, 612), + (8539977, 552), + (8540529, 526), + (8541055, 611), + (8541666, 552), + (8542218, 524), + (8542742, 606), + (8543348, 554), + (8543902, 526), + (8544428, 619), + (8545047, 553), + (8545600, 525), + (8546125, 618), + (8546743, 553), + (8547296, 525), + (8547821, 584), + (8548405, 552), + (8548957, 524), + (8549481, 598), + (8550079, 554), + (8550633, 526), + (8551159, 599), + (8551758, 553), + (8552311, 524), + (8552835, 599), + (8553434, 553), + (8553987, 526), + (8554513, 611), + (8555124, 554), + (8555678, 525), + (8556203, 612), + (8556815, 552), + (8557367, 526), + (8557893, 605), + (8558498, 554), + (8559052, 526), + (8559578, 617), + (8560195, 553), + (8560748, 524), + (8561272, 617), + (8561889, 552), + (8562441, 524), + (8562965, 575), + (8563540, 554), + (8564094, 525), + (8564619, 589), + (8565208, 553), + (8565761, 525), + (8566286, 588), + (8566874, 553), + (8567427, 525), + (8567952, 590), + (8568542, 554), + (8569096, 525), + (8569621, 602), + (8570223, 552), + (8570775, 525), + (8571300, 601), + (8571901, 553), + (8572454, 524), + (8572978, 597), + (8573575, 553), + (8574128, 525), + (8574653, 609), + (8575262, 552), + (8575814, 526), + (8576340, 608), + (8576948, 554), + (8577502, 524), + (8578026, 587), + (8578613, 554), + (8579167, 524), + (8579691, 601), + (8580292, 552), + (8580844, 525), + (8581369, 600), + (8581969, 552), + (8582521, 525), + (8583046, 602), + (8583648, 553), + (8584201, 525), + (8584726, 613), + (8585339, 554), + (8585893, 525), + (8586418, 613), + (8587031, 552), + (8587583, 524), + (8588107, 609), + (8588716, 552), + (8589268, 525), + (8589793, 620), + (8590413, 554), + (8590967, 525), + (8591492, 621), + (8592113, 552), + (8592665, 525), + (8593190, 588), + (8593778, 553), + (8594331, 525), + (8594856, 601), + (8595457, 552), + (8596009, 526), + (8596535, 601), + (8597136, 553), + (8597689, 524), + (8598213, 602), + (8598815, 552), + (8599367, 524), + (8599891, 615), + (8600506, 553), + (8601059, 524), + (8601583, 615), + (8602198, 554), + (8602752, 525), + (8603277, 608), + (8603885, 553), + (8604438, 525), + (8604963, 619), + (8605582, 552), + (8606134, 525), + (8606659, 620), + (8607279, 554), + (8607833, 535), + (8608368, 542), + (8608910, 552), + (8609462, 534), + (8609996, 571), + (8610567, 552), + (8611119, 536), + (8611655, 571), + (8612226, 553), + (8612779, 534), + (8613313, 573), + (8613886, 554), + (8614440, 536), + (8614976, 585), + (8615561, 553), + (8616114, 535), + (8616649, 584), + (8617233, 553), + (8617786, 536), + (8618322, 580), + (8618902, 553), + (8619455, 535), + (8619990, 591), + (8620581, 553), + (8621134, 536), + (8621670, 591), + (8622261, 553), + (8622814, 535), + (8623349, 569), + (8623918, 553), + (8624471, 535), + (8625006, 585), + (8625591, 554), + (8626145, 536), + (8626681, 587), + (8627268, 553), + (8627821, 535), + (8628356, 587), + (8628943, 554), + (8629497, 534), + (8630031, 598), + (8630629, 553), + (8631182, 536), + (8631718, 600), + (8632318, 553), + (8632871, 536), + (8633407, 593), + (8634000, 553), + (8634553, 535), + (8635088, 605), + (8635693, 553), + (8636246, 536), + (8636782, 605), + (8637387, 554), + (8637941, 535), + (8638476, 569), + (8639045, 553), + (8639598, 535), + (8640133, 586), + (8640719, 554), + (8641273, 536), + (8641809, 586), + (8642395, 553), + (8642948, 536), + (8643484, 587), + (8644071, 552), + (8644623, 535), + (8645158, 599), + (8645757, 553), + (8646310, 536), + (8646846, 598), + (8647444, 553), + (8647997, 536), + (8648533, 593), + (8649126, 553), + (8649679, 535), + (8650214, 606), + (8650820, 554), + (8651374, 535), + (8651909, 605), + (8652514, 553), + (8653067, 536), + (8653603, 571), + (8654174, 554), + (8654728, 534), + (8655262, 588), + (8655850, 553), + (8656403, 535), + (8656938, 587), + (8657525, 553), + (8658078, 534), + (8658612, 588), + (8659200, 553), + (8659753, 534), + (8660287, 600), + (8660887, 554), + (8661441, 535), + (8661976, 599), + (8662575, 553), + (8663128, 536), + (8663664, 594), + (8664258, 552), + (8664810, 534), + (8665344, 605), + (8665949, 552), + (8666501, 535), + (8667036, 606), + (8667642, 554), + (8668196, 536), + (8668732, 585), + (8669317, 553), + (8669870, 534), + (8670404, 599), + (8671003, 554), + (8671557, 535), + (8672092, 599), + (8672691, 554), + (8673245, 534), + (8673779, 600), + (8674379, 553), + (8674932, 536), + (8675468, 612), + (8676080, 552), + (8676632, 536), + (8677168, 613), + (8677781, 554), + (8678335, 534), + (8678869, 606), + (8679475, 552), + (8680027, 535), + (8680562, 619), + (8681181, 553), + (8681734, 535), + (8682269, 617), + (8682886, 553), + (8683439, 535), + (8683974, 586), + (8684560, 552), + (8685112, 535), + (8685647, 598), + (8686245, 552), + (8686797, 534), + (8687331, 599), + (8687930, 554), + (8688484, 536), + (8689020, 601), + (8689621, 554), + (8690175, 536), + (8690711, 612), + (8691323, 554), + (8691877, 535), + (8692412, 612), + (8693024, 553), + (8693577, 535), + (8694112, 605), + (8694717, 553), + (8695270, 534), + (8695804, 618), + (8696422, 554), + (8696976, 534), + (8697510, 619), + (8698129, 554), + (8698683, 535), + (8699218, 574), + (8699792, 553), + (8700345, 535), + (8700880, 590), + (8701470, 554), + (8702024, 534), + (8702558, 588), + (8703146, 553), + (8703699, 534), + (8704233, 589), + (8704822, 551), + (8705373, 535), + (8705908, 602), + (8706510, 553), + (8707063, 535), + (8707598, 602), + (8708200, 554), + (8708754, 536), + (8709290, 596), + (8709886, 552), + (8710438, 535), + (8710973, 609), + (8711582, 552), + (8712134, 535), + (8712669, 607), + (8713276, 553), + (8713829, 536), + (8714365, 587), + (8714952, 553), + (8715505, 535), + (8716040, 601), + (8716641, 553), + (8717194, 534), + (8717728, 602), + (8718330, 552), + (8718882, 535), + (8719417, 602), + (8720019, 552), + (8720571, 535), + (8721106, 614), + (8721720, 553), + (8722273, 534), + (8722807, 613), + (8723420, 553), + (8723973, 534), + (8724507, 609), + (8725116, 553), + (8725669, 534), + (8726203, 620), + (8726823, 554), + (8727377, 534), + (8727911, 621), + (8728532, 552), + (8729084, 536), + (8729620, 587), + (8730207, 553), + (8730760, 535), + (8731295, 601), + (8731896, 554), + (8732450, 535), + (8732985, 601), + (8733586, 553), + (8734139, 535), + (8734674, 603), + (8735277, 553), + (8735830, 536), + (8736366, 613), + (8736979, 552), + (8737531, 536), + (8738067, 613), + (8738680, 552), + (8739232, 535), + (8739767, 609), + (8740376, 552), + (8740928, 536), + (8741464, 621), + (8742085, 553), + (8742638, 535), + (8743173, 619), + (8743792, 554), + (8744346, 541), + (8744887, 542), + (8745429, 553), + (8745982, 540), + (8746522, 569), + (8747091, 554), + (8747645, 541), + (8748186, 569), + (8748755, 552), + (8749307, 541), + (8749848, 571), + (8750419, 553), + (8750972, 540), + (8751512, 585), + (8752097, 554), + (8752651, 541), + (8753192, 586), + (8753778, 553), + (8754331, 542), + (8754873, 580), + (8755453, 553), + (8756006, 540), + (8756546, 591), + (8757137, 553), + (8757690, 541), + (8758231, 591), + (8758822, 552), + (8759374, 541), + (8759915, 570), + (8760485, 553), + (8761038, 541), + (8761579, 586), + (8762165, 554), + (8762719, 540), + (8763259, 585), + (8763844, 554), + (8764398, 541), + (8764939, 588), + (8765527, 554), + (8766081, 541), + (8766622, 600), + (8767222, 553), + (8767775, 541), + (8768316, 600), + (8768916, 553), + (8769469, 542), + (8770011, 594), + (8770605, 552), + (8771157, 541), + (8771698, 605), + (8772303, 553), + (8772856, 542), + (8773398, 604), + (8774002, 553), + (8774555, 541), + (8775096, 569), + (8775665, 553), + (8776218, 541), + (8776759, 586), + (8777345, 552), + (8777897, 541), + (8778438, 586), + (8779024, 553), + (8779577, 540), + (8780117, 588), + (8780705, 552), + (8781257, 540), + (8781797, 598), + (8782395, 553), + (8782948, 541), + (8783489, 599), + (8784088, 553), + (8784641, 542), + (8785183, 592), + (8785775, 554), + (8786329, 541), + (8786870, 605), + (8787475, 554), + (8788029, 541), + (8788570, 605), + (8789175, 553), + (8789728, 542), + (8790270, 572), + (8790842, 554), + (8791396, 541), + (8791937, 587), + (8792524, 553), + (8793077, 540), + (8793617, 586), + (8794203, 552), + (8794755, 542), + (8795297, 587), + (8795884, 554), + (8796438, 540), + (8796978, 600), + (8797578, 553), + (8798131, 541), + (8798672, 599), + (8799271, 552), + (8799823, 541), + (8800364, 595), + (8800959, 553), + (8801512, 542), + (8802054, 607), + (8802661, 554), + (8803215, 540), + (8803755, 606), + (8804361, 553), + (8804914, 542), + (8805456, 586), + (8806042, 552), + (8806594, 541), + (8807135, 599), + (8807734, 553), + (8808287, 541), + (8808828, 599), + (8809427, 554), + (8809981, 540), + (8810521, 601), + (8811122, 552), + (8811674, 541), + (8812215, 613), + (8812828, 554), + (8813382, 542), + (8813924, 612), + (8814536, 553), + (8815089, 541), + (8815630, 606), + (8816236, 553), + (8816789, 540), + (8817329, 619), + (8817948, 553), + (8818501, 541), + (8819042, 618), + (8819660, 553), + (8820213, 542), + (8820755, 586), + (8821341, 553), + (8821894, 541), + (8822435, 600), + (8823035, 553), + (8823588, 541), + (8824129, 599), + (8824728, 553), + (8825281, 542), + (8825823, 599), + (8826422, 553), + (8826975, 541), + (8827516, 612), + (8828128, 553), + (8828681, 540), + (8829221, 613), + (8829834, 554), + (8830388, 542), + (8830930, 605), + (8831535, 554), + (8832089, 541), + (8832630, 618), + (8833248, 554), + (8833802, 541), + (8834343, 618), + (8834961, 553), + (8835514, 540), + (8836054, 575), + (8836629, 554), + (8837183, 541), + (8837724, 589), + (8838313, 552), + (8838865, 540), + (8839405, 589), + (8839994, 553), + (8840547, 541), + (8841088, 591), + (8841679, 554), + (8842233, 542), + (8842775, 602), + (8843377, 553), + (8843930, 541), + (8844471, 601), + (8845072, 554), + (8845626, 541), + (8846167, 596), + (8846763, 554), + (8847317, 540), + (8847857, 608), + (8848465, 552), + (8849017, 541), + (8849558, 609), + (8850167, 553), + (8850720, 541), + (8851261, 587), + (8851848, 552), + (8852400, 540), + (8852940, 601), + (8853541, 553), + (8854094, 541), + (8854635, 602), + (8855237, 554), + (8855791, 541), + (8856332, 601), + (8856933, 553), + (8857486, 541), + (8858027, 615), + (8858642, 552), + (8859194, 541), + (8859735, 614), + (8860349, 554), + (8860903, 541), + (8861444, 608), + (8862052, 553), + (8862605, 542), + (8863147, 620), + (8863767, 553), + (8864320, 541), + (8864861, 621), + (8865482, 552), + (8866034, 541), + (8866575, 587), + (8867162, 553), + (8867715, 540), + (8868255, 600), + (8868855, 552), + (8869407, 540), + (8869947, 602), + (8870549, 553), + (8871102, 542), + (8871644, 601), + (8872245, 554), + (8872799, 541), + (8873340, 614), + (8873954, 552), + (8874506, 542), + (8875048, 615), + (8875663, 553), + (8876216, 540), + (8876756, 607), + (8877363, 552), + (8877915, 542), + (8878457, 620), + (8879077, 553), + (8879630, 541), + (8880171, 620), + (8880791, 553), + (8881344, 542), + (8881886, 542), + (8882428, 554), + (8882982, 540), + (8883522, 570), + (8884092, 553), + (8884645, 541), + (8885186, 569), + (8885755, 553), + (8886308, 542), + (8886850, 572), + (8887422, 554), + (8887976, 541), + (8888517, 586), + (8889103, 552), + (8889655, 542), + (8890197, 585), + (8890782, 553), + (8891335, 541), + (8891876, 578), + (8892454, 553), + (8893007, 541), + (8893548, 590), + (8894138, 553), + (8894691, 541), + (8895232, 590), + (8895822, 554), + (8896376, 541), + (8896917, 570), + (8897487, 554), + (8898041, 541), + (8898582, 587), + (8899169, 552), + (8899721, 541), + (8900262, 586), + (8900848, 554), + (8901402, 542), + (8901944, 587), + (8902531, 554), + (8903085, 541), + (8903626, 599), + (8904225, 554), + (8904779, 541), + (8905320, 599), + (8905919, 553), + (8906472, 541), + (8907013, 593), + (8907606, 552), + (8908158, 540), + (8908698, 605), + (8909303, 552), + (8909855, 540), + (8910395, 605), + (8911000, 553), + (8911553, 541), + (8912094, 571), + (8912665, 553), + (8913218, 541), + (8913759, 587), + (8914346, 553), + (8914899, 542), + (8915441, 586), + (8916027, 552), + (8916579, 541), + (8917120, 587), + (8917707, 552), + (8918259, 542), + (8918801, 600), + (8919401, 552), + (8919953, 541), + (8920494, 598), + (8921092, 554), + (8921646, 541), + (8922187, 594), + (8922781, 552), + (8923333, 540), + (8923873, 604), + (8924477, 552), + (8925029, 541), + (8925570, 605), + (8926175, 554), + (8926729, 542), + (8927271, 572), + (8927843, 554), + (8928397, 542), + (8928939, 586), + (8929525, 554), + (8930079, 540), + (8930619, 586), + (8931205, 553), + (8931758, 541), + (8932299, 587), + (8932886, 552), + (8933438, 542), + (8933980, 600), + (8934580, 554), + (8935134, 541), + (8935675, 600), + (8936275, 552), + (8936827, 541), + (8937368, 593), + (8937961, 553), + (8938514, 541), + (8939055, 606), + (8939661, 552), + (8940213, 541), + (8940754, 606), + (8941360, 553), + (8941913, 542), + (8942455, 586), + (8943041, 553), + (8943594, 542), + (8944136, 600), + (8944736, 553), + (8945289, 542), + (8945831, 599), + (8946430, 553), + (8946983, 542), + (8947525, 599), + (8948124, 552), + (8948676, 540), + (8949216, 613), + (8949829, 553), + (8950382, 541), + (8950923, 612), + (8951535, 553), + (8952088, 542), + (8952630, 605), + (8953235, 554), + (8953789, 540), + (8954329, 618), + (8954947, 553), + (8955500, 542), + (8956042, 619), + (8956661, 554), + (8957215, 542), + (8957757, 585), + (8958342, 553), + (8958895, 540), + (8959435, 600), + (8960035, 553), + (8960588, 541), + (8961129, 599), + (8961728, 553), + (8962281, 541), + (8962822, 600), + (8963422, 553), + (8963975, 542), + (8964517, 613), + (8965130, 552), + (8965682, 542), + (8966224, 612), + (8966836, 552), + (8967388, 540), + (8967928, 606), + (8968534, 553), + (8969087, 541), + (8969628, 618), + (8970246, 552), + (8970798, 541), + (8971339, 619), + (8971958, 553), + (8972511, 542), + (8973053, 575), + (8973628, 552), + (8974180, 542), + (8974722, 589), + (8975311, 553), + (8975864, 540), + (8976404, 589), + (8976993, 553), + (8977546, 540), + (8978086, 589), + (8978675, 553), + (8979228, 542), + (8979770, 602), + (8980372, 553), + (8980925, 541), + (8981466, 601), + (8982067, 554), + (8982621, 542), + (8983163, 596), + (8983759, 554), + (8984313, 541), + (8984854, 609), + (8985463, 553), + (8986016, 541), + (8986557, 608), + (8987165, 554), + (8987719, 542), + (8988261, 586), + (8988847, 552), + (8989399, 542), + (8989941, 601), + (8990542, 553), + (8991095, 541), + (8991636, 601), + (8992237, 552), + (8992789, 541), + (8993330, 602), + (8993932, 552), + (8994484, 540), + (8995024, 614), + (8995638, 553), + (8996191, 541), + (8996732, 614), + (8997346, 554), + (8997900, 540), + (8998440, 608), + (8999048, 552), + (8999600, 542), + (9000142, 620), + (9000762, 553), + (9001315, 541), + (9001856, 620), + (9002476, 554), + (9003030, 542), + (9003572, 587), + (9004159, 553), + (9004712, 542), + (9005254, 600), + (9005854, 552), + (9006406, 540), + (9006946, 600), + (9007546, 553), + (9008099, 541), + (9008640, 602), + (9009242, 554), + (9009796, 542), + (9010338, 613), + (9010951, 553), + (9011504, 542), + (9012046, 614), + (9012660, 553), + (9013213, 540), + (9013753, 607), + (9014360, 553), + (9014913, 541), + (9015454, 619), + (9016073, 553), + (9016626, 541), + (9017167, 621), + (9017788, 554), + (9018342, 537), + (9018879, 542), + (9019421, 554), + (9019975, 537), + (9020512, 571), + (9021083, 553), + (9021636, 537), + (9022173, 570), + (9022743, 553), + (9023296, 536), + (9023832, 571), + (9024403, 553), + (9024956, 535), + (9025491, 585), + (9026076, 553), + (9026629, 535), + (9027164, 585), + (9027749, 553), + (9028302, 536), + (9028838, 580), + (9029418, 553), + (9029971, 535), + (9030506, 591), + (9031097, 554), + (9031651, 537), + (9032188, 591), + (9032779, 552), + (9033331, 536), + (9033867, 570), + (9034437, 553), + (9034990, 536), + (9035526, 587), + (9036113, 552), + (9036665, 536), + (9037201, 586), + (9037787, 554), + (9038341, 536), + (9038877, 586), + (9039463, 554), + (9040017, 535), + (9040552, 600), + (9041152, 553), + (9041705, 535), + (9042240, 598), + (9042838, 553), + (9043391, 536), + (9043927, 594), + (9044521, 553), + (9045074, 536), + (9045610, 605), + (9046215, 552), + (9046767, 537), + (9047304, 604), + (9047908, 553), + (9048461, 537), + (9048998, 570), + (9049568, 553), + (9050121, 537), + (9050658, 586), + (9051244, 551), + (9051795, 535), + (9052330, 587), + (9052917, 554), + (9053471, 535), + (9054006, 588), + (9054594, 554), + (9055148, 537), + (9055685, 599), + (9056284, 552), + (9056836, 535), + (9057371, 600), + (9057971, 553), + (9058524, 536), + (9059060, 592), + (9059652, 553), + (9060205, 535), + (9060740, 606), + (9061346, 553), + (9061899, 535), + (9062434, 604), + (9063038, 553), + (9063591, 537), + (9064128, 572), + (9064700, 554), + (9065254, 535), + (9065789, 586), + (9066375, 554), + (9066929, 536), + (9067465, 588), + (9068053, 552), + (9068605, 536), + (9069141, 588), + (9069729, 553), + (9070282, 535), + (9070817, 600), + (9071417, 553), + (9071970, 536), + (9072506, 599), + (9073105, 553), + (9073658, 537), + (9074195, 593), + (9074788, 552), + (9075340, 536), + (9075876, 605), + (9076481, 554), + (9077035, 535), + (9077570, 606), + (9078176, 552), + (9078728, 537), + (9079265, 584), + (9079849, 553), + (9080402, 535), + (9080937, 600), + (9081537, 553), + (9082090, 535), + (9082625, 599), + (9083224, 554), + (9083778, 535), + (9084313, 599), + (9084912, 552), + (9085464, 537), + (9086001, 611), + (9086612, 552), + (9087164, 537), + (9087701, 612), + (9088313, 552), + (9088865, 535), + (9089400, 607), + (9090007, 554), + (9090561, 535), + (9091096, 617), + (9091713, 552), + (9092265, 536), + (9092801, 618), + (9093419, 553), + (9093972, 536), + (9094508, 586), + (9095094, 553), + (9095647, 537), + (9096184, 598), + (9096782, 554), + (9097336, 536), + (9097872, 598), + (9098470, 554), + (9099024, 536), + (9099560, 600), + (9100160, 553), + (9100713, 535), + (9101248, 612), + (9101860, 554), + (9102414, 536), + (9102950, 613), + (9103563, 552), + (9104115, 536), + (9104651, 605), + (9105256, 552), + (9105808, 537), + (9106345, 618), + (9106963, 553), + (9107516, 535), + (9108051, 617), + (9108668, 553), + (9109221, 536), + (9109757, 576), + (9110333, 553), + (9110886, 536), + (9111422, 590), + (9112012, 553), + (9112565, 536), + (9113101, 589), + (9113690, 553), + (9114243, 536), + (9114779, 590), + (9115369, 552), + (9115921, 536), + (9116457, 602), + (9117059, 552), + (9117611, 535), + (9118146, 603), + (9118749, 554), + (9119303, 536), + (9119839, 595), + (9120434, 553), + (9120987, 537), + (9121524, 608), + (9122132, 552), + (9122684, 535), + (9123219, 608), + (9123827, 554), + (9124381, 537), + (9124918, 587), + (9125505, 553), + (9126058, 537), + (9126595, 601), + (9127196, 553), + (9127749, 536), + (9128285, 601), + (9128886, 553), + (9129439, 536), + (9129975, 601), + (9130576, 552), + (9131128, 537), + (9131665, 614), + (9132279, 553), + (9132832, 537), + (9133369, 614), + (9133983, 554), + (9134537, 536), + (9135073, 608), + (9135681, 552), + (9136233, 536), + (9136769, 620), + (9137389, 553), + (9137942, 536), + (9138478, 620), + (9139098, 552), + (9139650, 535), + (9140185, 587), + (9140772, 552), + (9141324, 536), + (9141860, 601), + (9142461, 554), + (9143015, 536), + (9143551, 601), + (9144152, 553), + (9144705, 536), + (9145241, 603), + (9145844, 553), + (9146397, 537), + (9146934, 614), + (9147548, 554), + (9148102, 535), + (9148637, 615), + (9149252, 552), + (9149804, 535), + (9150339, 608), + (9150947, 553), + (9151500, 535), + (9152035, 620), + (9152655, 553), + (9153208, 535), + (9153743, 620), + (9154363, 553), + (9154916, 543), + (9155459, 541), + (9156000, 553), + (9156553, 543), + (9157096, 570), + (9157666, 554), + (9158220, 543), + (9158763, 570), + (9159333, 552), + (9159885, 542), + (9160427, 572), + (9160999, 554), + (9161553, 542), + (9162095, 584), + (9162679, 553), + (9163232, 542), + (9163774, 584), + (9164358, 552), + (9164910, 541), + (9165451, 580), + (9166031, 553), + (9166584, 542), + (9167126, 591), + (9167717, 553), + (9168270, 542), + (9168812, 592), + (9169404, 552), + (9169956, 542), + (9170498, 570), + (9171068, 553), + (9171621, 543), + (9172164, 586), + (9172750, 554), + (9173304, 542), + (9173846, 586), + (9174432, 552), + (9174984, 541), + (9175525, 587), + (9176112, 553), + (9176665, 543), + (9177208, 598), + (9177806, 553), + (9178359, 542), + (9178901, 598), + (9179499, 554), + (9180053, 543), + (9180596, 594), + (9181190, 554), + (9181744, 541), + (9182285, 605), + (9182890, 552), + (9183442, 541), + (9183983, 606), + (9184589, 552), + (9185141, 542), + (9185683, 570), + (9186253, 554), + (9186807, 542), + (9187349, 587), + (9187936, 554), + (9188490, 541), + (9189031, 587), + (9189618, 552), + (9190170, 542), + (9190712, 587), + (9191299, 552), + (9191851, 541), + (9192392, 598), + (9192990, 553), + (9193543, 543), + (9194086, 598), + (9194684, 554), + (9195238, 542), + (9195780, 593), + (9196373, 553), + (9196926, 543), + (9197469, 605), + (9198074, 553), + (9198627, 541), + (9199168, 604), + (9199772, 553), + (9200325, 542), + (9200867, 572), + (9201439, 552), + (9201991, 542), + (9202533, 587), + (9203120, 552), + (9203672, 543), + (9204215, 588), + (9204803, 552), + (9205355, 542), + (9205897, 587), + (9206484, 554), + (9207038, 543), + (9207581, 600), + (9208181, 554), + (9208735, 542), + (9209277, 601), + (9209878, 552), + (9210430, 542), + (9210972, 593), + (9211565, 553), + (9212118, 543), + (9212661, 606), + (9213267, 554), + (9213821, 542), + (9214363, 606), + (9214969, 553), + (9215522, 543), + (9216065, 586), + (9216651, 552), + (9217203, 542), + (9217745, 600), + (9218345, 553), + (9218898, 542), + (9219440, 598), + (9220038, 553), + (9220591, 541), + (9221132, 600), + (9221732, 552), + (9222284, 542), + (9222826, 612), + (9223438, 553), + (9223991, 543), + (9224534, 613), + (9225147, 553), + (9225700, 542), + (9226242, 606), + (9226848, 553), + (9227401, 543), + (9227944, 618), + (9228562, 552), + (9229114, 542), + (9229656, 618), + (9230274, 553), + (9230827, 543), + (9231370, 585), + (9231955, 552), + (9232507, 543), + (9233050, 598), + (9233648, 554), + (9234202, 542), + (9234744, 600), + (9235344, 553), + (9235897, 542), + (9236439, 600), + (9237039, 553), + (9237592, 543), + (9238135, 611), + (9238746, 554), + (9239300, 541), + (9239841, 611), + (9240452, 553), + (9241005, 542), + (9241547, 606), + (9242153, 553), + (9242706, 542), + (9243248, 618), + (9243866, 553), + (9244419, 542), + (9244961, 617), + (9245578, 552), + (9246130, 541), + (9246671, 576), + (9247247, 554), + (9247801, 541), + (9248342, 590), + (9248932, 554), + (9249486, 542), + (9250028, 589), + (9250617, 553), + (9251170, 542), + (9251712, 590), + (9252302, 554), + (9252856, 543), + (9253399, 602), + (9254001, 553), + (9254554, 542), + (9255096, 603), + (9255699, 553), + (9256252, 542), + (9256794, 595), + (9257389, 552), + (9257941, 542), + (9258483, 609), + (9259092, 553), + (9259645, 542), + (9260187, 607), + (9260794, 552), + (9261346, 543), + (9261889, 587), + (9262476, 554), + (9263030, 542), + (9263572, 600), + (9264172, 552), + (9264724, 541), + (9265265, 600), + (9265865, 553), + (9266418, 543), + (9266961, 603), + (9267564, 553), + (9268117, 542), + (9268659, 615), + (9269274, 554), + (9269828, 543), + (9270371, 615), + (9270986, 553), + (9271539, 541), + (9272080, 607), + (9272687, 553), + (9273240, 542), + (9273782, 621), + (9274403, 552), + (9274955, 542), + (9275497, 620), + (9276117, 552), + (9276669, 542), + (9277211, 587), + (9277798, 553), + (9278351, 542), + (9278893, 601), + (9279494, 554), + (9280048, 542), + (9280590, 601), + (9281191, 552), + (9281743, 542), + (9282285, 603), + (9282888, 554), + (9283442, 542), + (9283984, 613), + (9284597, 553), + (9285150, 542), + (9285692, 614), + (9286306, 552), + (9286858, 541), + (9287399, 609), + (9288008, 553), + (9288561, 542), + (9289103, 620), + (9289723, 553), + (9290276, 543), + (9290819, 619), + (9291438, 552), + (9291990, 542), + (9292532, 543), + (9293075, 552), + (9293627, 542), + (9294169, 571), + (9294740, 554), + (9295294, 541), + (9295835, 570), + (9296405, 553), + (9296958, 542), + (9297500, 572), + (9298072, 554), + (9298626, 541), + (9299167, 585), + (9299752, 552), + (9300304, 541), + (9300845, 586), + (9301431, 553), + (9301984, 542), + (9302526, 579), + (9303105, 553), + (9303658, 541), + (9304199, 592), + (9304791, 553), + (9305344, 541), + (9305885, 591), + (9306476, 552), + (9307028, 541), + (9307569, 569), + (9308138, 554), + (9308692, 543), + (9309235, 586), + (9309821, 553), + (9310374, 541), + (9310915, 586), + (9311501, 554), + (9312055, 543), + (9312598, 587), + (9313185, 554), + (9313739, 542), + (9314281, 600), + (9314881, 552), + (9315433, 541), + (9315974, 598), + (9316572, 553), + (9317125, 543), + (9317668, 594), + (9318262, 553), + (9318815, 543), + (9319358, 605), + (9319963, 553), + (9320516, 542), + (9321058, 605), + (9321663, 554), + (9322217, 541), + (9322758, 571), + (9323329, 552), + (9323881, 542), + (9324423, 586), + (9325009, 553), + (9325562, 543), + (9326105, 586), + (9326691, 552), + (9327243, 543), + (9327786, 586), + (9328372, 552), + (9328924, 543), + (9329467, 598), + (9330065, 554), + (9330619, 543), + (9331162, 598), + (9331760, 553), + (9332313, 541), + (9332854, 593), + (9333447, 553), + (9334000, 542), + (9334542, 605), + (9335147, 552), + (9335699, 541), + (9336240, 605), + (9336845, 552), + (9337397, 542), + (9337939, 572), + (9338511, 552), + (9339063, 542), + (9339605, 586), + (9340191, 552), + (9340743, 542), + (9341285, 588), + (9341873, 554), + (9342427, 542), + (9342969, 588), + (9343557, 553), + (9344110, 543), + (9344653, 601), + (9345254, 553), + (9345807, 543), + (9346350, 601), + (9346951, 554), + (9347505, 542), + (9348047, 594), + (9348641, 553), + (9349194, 542), + (9349736, 606), + (9350342, 552), + (9350894, 543), + (9351437, 606), + (9352043, 552), + (9352595, 543), + (9353138, 585), + (9353723, 553), + (9354276, 542), + (9354818, 600), + (9355418, 552), + (9355970, 543), + (9356513, 599), + (9357112, 553), + (9357665, 542), + (9358207, 599), + (9358806, 553), + (9359359, 542), + (9359901, 612), + (9360513, 554), + (9361067, 542), + (9361609, 612), + (9362221, 552), + (9362773, 542), + (9363315, 607), + (9363922, 552), + (9364474, 542), + (9365016, 619), + (9365635, 554), + (9366189, 543), + (9366732, 618), + (9367350, 553), + (9367903, 542), + (9368445, 586), + (9369031, 553), + (9369584, 542), + (9370126, 599), + (9370725, 553), + (9371278, 542), + (9371820, 599), + (9372419, 554), + (9372973, 542), + (9373515, 601), + (9374116, 552), + (9374668, 542), + (9375210, 612), + (9375822, 554), + (9376376, 541), + (9376917, 612), + (9377529, 553), + (9378082, 543), + (9378625, 606), + (9379231, 553), + (9379784, 541), + (9380325, 618), + (9380943, 554), + (9381497, 542), + (9382039, 617), + (9382656, 553), + (9383209, 542), + (9383751, 575), + (9384326, 554), + (9384880, 541), + (9385421, 590), + (9386011, 553), + (9386564, 542), + (9387106, 590), + (9387696, 553), + (9388249, 541), + (9388790, 590), + (9389380, 553), + (9389933, 541), + (9390474, 602), + (9391076, 553), + (9391629, 542), + (9392171, 602), + (9392773, 552), + (9393325, 541), + (9393866, 596), + (9394462, 553), + (9395015, 542), + (9395557, 608), + (9396165, 553), + (9396718, 543), + (9397261, 609), + (9397870, 553), + (9398423, 543), + (9398966, 587), + (9399553, 552), + (9400105, 542), + (9400647, 601), + (9401248, 553), + (9401801, 542), + (9402343, 601), + (9402944, 554), + (9403498, 542), + (9404040, 603), + (9404643, 553), + (9405196, 541), + (9405737, 614), + (9406351, 554), + (9406905, 543), + (9407448, 614), + (9408062, 553), + (9408615, 542), + (9409157, 608), + (9409765, 553), + (9410318, 542), + (9410860, 620), + (9411480, 554), + (9412034, 541), + (9412575, 620), + (9413195, 552), + (9413747, 541), + (9414288, 587), + (9414875, 552), + (9415427, 541), + (9415968, 600), + (9416568, 553), + (9417121, 543), + (9417664, 602), + (9418266, 553), + (9418819, 542), + (9419361, 602), + (9419963, 552), + (9420515, 542), + (9421057, 614), + (9421671, 553), + (9422224, 542), + (9422766, 614), + (9423380, 553), + (9423933, 541), + (9424474, 608), + (9425082, 552), + (9425634, 541), + (9426175, 619), + (9426794, 552), + (9427346, 541), + (9427887, 621), + (9428508, 552), + (9429060, 533), + (9429593, 541), + (9430134, 552), + (9430686, 532), + (9431218, 570), + (9431788, 553), + (9432341, 534), + (9432875, 571), + (9433446, 554), + (9434000, 534), + (9434534, 573), + (9435107, 553), + (9435660, 532), + (9436192, 586), + (9436778, 553), + (9437331, 532), + (9437863, 585), + (9438448, 552), + (9439000, 534), + (9439534, 579), + (9440113, 553), + (9440666, 533), + (9441199, 590), + (9441789, 554), + (9442343, 532), + (9442875, 592), + (9443467, 554), + (9444021, 534), + (9444555, 570), + (9445125, 553), + (9445678, 533), + (9446211, 586), + (9446797, 553), + (9447350, 533), + (9447883, 586), + (9448469, 553), + (9449022, 532), + (9449554, 588), + (9450142, 553), + (9450695, 532), + (9451227, 600), + (9451827, 552), + (9452379, 532), + (9452911, 598), + (9453509, 553), + (9454062, 533), + (9454595, 593), + (9455188, 553), + (9455741, 533), + (9456274, 605), + (9456879, 553), + (9457432, 534), + (9457966, 605), + (9458571, 552), + (9459123, 532), + (9459655, 570), + (9460225, 553), + (9460778, 532), + (9461310, 587), + (9461897, 553), + (9462450, 534), + (9462984, 587), + (9463571, 552), + (9464123, 533), + (9464656, 588), + (9465244, 553), + (9465797, 533), + (9466330, 599), + (9466929, 552), + (9467481, 534), + (9468015, 599), + (9468614, 554), + (9469168, 533), + (9469701, 594), + (9470295, 552), + (9470847, 533), + (9471380, 606), + (9471986, 553), + (9472539, 534), + (9473073, 606), + (9473679, 553), + (9474232, 532), + (9474764, 571), + (9475335, 554), + (9475889, 533), + (9476422, 587), + (9477009, 553), + (9477562, 533), + (9478095, 587), + (9478682, 552), + (9479234, 534), + (9479768, 588), + (9480356, 553), + (9480909, 533), + (9481442, 600), + (9482042, 554), + (9482596, 532), + (9483128, 600), + (9483728, 553), + (9484281, 532), + (9484813, 595), + (9485408, 553), + (9485961, 533), + (9486494, 605), + (9487099, 553), + (9487652, 533), + (9488185, 607), + (9488792, 552), + (9489344, 532), + (9489876, 585), + (9490461, 553), + (9491014, 532), + (9491546, 599), + (9492145, 554), + (9492699, 533), + (9493232, 598), + (9493830, 552), + (9494382, 534), + (9494916, 601), + (9495517, 553), + (9496070, 533), + (9496603, 613), + (9497216, 553), + (9497769, 533), + (9498302, 613), + (9498915, 553), + (9499468, 534), + (9500002, 605), + (9500607, 553), + (9501160, 534), + (9501694, 618), + (9502312, 552), + (9502864, 532), + (9503396, 618), + (9504014, 554), + (9504568, 533), + (9505101, 585), + (9505686, 553), + (9506239, 534), + (9506773, 598), + (9507371, 552), + (9507923, 532), + (9508455, 598), + (9509053, 553), + (9509606, 533), + (9510139, 600), + (9510739, 553), + (9511292, 534), + (9511826, 613), + (9512439, 553), + (9512992, 534), + (9513526, 612), + (9514138, 554), + (9514692, 533), + (9515225, 605), + (9515830, 554), + (9516384, 534), + (9516918, 618), + (9517536, 553), + (9518089, 533), + (9518622, 619), + (9519241, 552), + (9519793, 532), + (9520325, 575), + (9520900, 552), + (9521452, 534), + (9521986, 589), + (9522575, 554), + (9523129, 533), + (9523662, 589), + (9524251, 554), + (9524805, 532), + (9525337, 591), + (9525928, 553), + (9526481, 532), + (9527013, 602), + (9527615, 552), + (9528167, 533), + (9528700, 601), + (9529301, 552), + (9529853, 533), + (9530386, 596), + (9530982, 553), + (9531535, 532), + (9532067, 608), + (9532675, 552), + (9533227, 532), + (9533759, 608), + (9534367, 552), + (9534919, 533), + (9535452, 587), + (9536039, 553), + (9536592, 532), + (9537124, 601), + (9537725, 553), + (9538278, 533), + (9538811, 601), + (9539412, 553), + (9539965, 533), + (9540498, 603), + (9541101, 552), + (9541653, 534), + (9542187, 615), + (9542802, 553), + (9543355, 534), + (9543889, 615), + (9544504, 553), + (9545057, 533), + (9545590, 609), + (9546199, 554), + (9546753, 532), + (9547285, 619), + (9547904, 552), + (9548456, 533), + (9548989, 621), + (9549610, 552), + (9550162, 534), + (9550696, 587), + (9551283, 553), + (9551836, 534), + (9552370, 601), + (9552971, 553), + (9553524, 533), + (9554057, 600), + (9554657, 553), + (9555210, 533), + (9555743, 601), + (9556344, 553), + (9556897, 532), + (9557429, 614), + (9558043, 554), + (9558597, 532), + (9559129, 615), + (9559744, 554), + (9560298, 533), + (9560831, 608), + (9561439, 553), + (9561992, 532), + (9562524, 620), + (9563144, 553), + (9563697, 533), + (9564230, 621), + (9564851, 553), + (9565404, 549), + (9565953, 542), + (9566495, 553), + (9567048, 550), + (9567598, 569), + (9568167, 552), + (9568719, 551), + (9569270, 570), + (9569840, 553), + (9570393, 550), + (9570943, 571), + (9571514, 554), + (9572068, 549), + (9572617, 585), + (9573202, 554), + (9573756, 551), + (9574307, 586), + (9574893, 553), + (9575446, 549), + (9575995, 580), + (9576575, 554), + (9577129, 550), + (9577679, 592), + (9578271, 553), + (9578824, 551), + (9579375, 592), + (9579967, 552), + (9580519, 549), + (9581068, 570), + (9581638, 554), + (9582192, 551), + (9582743, 585), + (9583328, 553), + (9583881, 551), + (9584432, 585), + (9585017, 553), + (9585570, 549), + (9586119, 587), + (9586706, 553), + (9587259, 549), + (9587808, 598), + (9588406, 553), + (9588959, 550), + (9589509, 600), + (9590109, 554), + (9590663, 550), + (9591213, 592), + (9591805, 553), + (9592358, 550), + (9592908, 604), + (9593512, 554), + (9594066, 550), + (9594616, 605), + (9595221, 554), + (9595775, 551), + (9596326, 571), + (9596897, 554), + (9597451, 550), + (9598001, 586), + (9598587, 552), + (9599139, 551), + (9599690, 585), + (9600275, 553), + (9600828, 549), + (9601377, 587), + (9601964, 552), + (9602516, 549), + (9603065, 600), + (9603665, 554), + (9604219, 551), + (9604770, 599), + (9605369, 554), + (9605923, 549), + (9606472, 592), + (9607064, 553), + (9607617, 550), + (9608167, 605), + (9608772, 553), + (9609325, 550), + (9609875, 605), + (9610480, 553), + (9611033, 549), + (9611582, 573), + (9612155, 553), + (9612708, 551), + (9613259, 588), + (9613847, 553), + (9614400, 550), + (9614950, 588), + (9615538, 554), + (9616092, 550), + (9616642, 588), + (9617230, 554), + (9617784, 550), + (9618334, 601), + (9618935, 553), + (9619488, 551), + (9620039, 600), + (9620639, 553), + (9621192, 549), + (9621741, 594), + (9622335, 552), + (9622887, 550), + (9623437, 606), + (9624043, 553), + (9624596, 550), + (9625146, 606), + (9625752, 554), + (9626306, 550), + (9626856, 585), + (9627441, 553), + (9627994, 550), + (9628544, 598), + (9629142, 554), + (9629696, 550), + (9630246, 599), + (9630845, 553), + (9631398, 551), + (9631949, 600), + (9632549, 554), + (9633103, 550), + (9633653, 612), + (9634265, 553), + (9634818, 550), + (9635368, 612), + (9635980, 554), + (9636534, 551), + (9637085, 606), + (9637691, 554), + (9638245, 550), + (9638795, 619), + (9639414, 553), + (9639967, 551), + (9640518, 618), + (9641136, 552), + (9641688, 550), + (9642238, 585), + (9642823, 553), + (9643376, 550), + (9643926, 599), + (9644525, 552), + (9645077, 551), + (9645628, 600), + (9646228, 552), + (9646780, 551), + (9647331, 601), + (9647932, 554), + (9648486, 549), + (9649035, 611), + (9649646, 554), + (9650200, 550), + (9650750, 612), + (9651362, 552), + (9651914, 549), + (9652463, 605), + (9653068, 552), + (9653620, 550), + (9654170, 617), + (9654787, 552), + (9655339, 549), + (9655888, 618), + (9656506, 554), + (9657060, 551), + (9657611, 574), + (9658185, 552), + (9658737, 549), + (9659286, 589), + (9659875, 553), + (9660428, 549), + (9660977, 589), + (9661566, 553), + (9662119, 550), + (9662669, 589), + (9663258, 552), + (9663810, 551), + (9664361, 601), + (9664962, 552), + (9665514, 551), + (9666065, 603), + (9666668, 552), + (9667220, 551), + (9667771, 596), + (9668367, 553), + (9668920, 550), + (9669470, 609), + (9670079, 554), + (9670633, 550), + (9671183, 607), + (9671790, 552), + (9672342, 550), + (9672892, 587), + (9673479, 553), + (9674032, 551), + (9674583, 602), + (9675185, 553), + (9675738, 549), + (9676287, 602), + (9676889, 553), + (9677442, 551), + (9677993, 601), + (9678594, 552), + (9679146, 550), + (9679696, 614), + (9680310, 554), + (9680864, 550), + (9681414, 615), + (9682029, 552), + (9682581, 549), + (9683130, 607), + (9683737, 553), + (9684290, 549), + (9684839, 621), + (9685460, 554), + (9686014, 550), + (9686564, 620), + (9687184, 552), + (9687736, 549), + (9688285, 587), + (9688872, 552), + (9689424, 550), + (9689974, 601), + (9690575, 554), + (9691129, 551), + (9691680, 600), + (9692280, 552), + (9692832, 550), + (9693382, 603), + (9693985, 553), + (9694538, 550), + (9695088, 614), + (9695702, 553), + (9696255, 549), + (9696804, 614), + (9697418, 554), + (9697972, 549), + (9698521, 609), + (9699130, 554), + (9699684, 550), + (9700234, 620), + (9700854, 552), + (9701406, 550), + (9701956, 621), + (9702577, 553), + (9703130, 549), + (9703679, 542), + (9704221, 554), + (9704775, 550), + (9705325, 570), + (9705895, 552), + (9706447, 551), + (9706998, 570), + (9707568, 553), + (9708121, 551), + (9708672, 572), + (9709244, 554), + (9709798, 551), + (9710349, 585), + (9710934, 553), + (9711487, 549), + (9712036, 586), + (9712622, 554), + (9713176, 551), + (9713727, 579), + (9714306, 553), + (9714859, 551), + (9715410, 592), + (9716002, 553), + (9716555, 550), + (9717105, 591), + (9717696, 554), + (9718250, 550), + (9718800, 571), + (9719371, 554), + (9719925, 550), + (9720475, 587), + (9721062, 553), + (9721615, 549), + (9722164, 587), + (9722751, 553), + (9723304, 551), + (9723855, 588), + (9724443, 554), + (9724997, 551), + (9725548, 600), + (9726148, 552), + (9726700, 550), + (9727250, 599), + (9727849, 552), + (9728401, 550), + (9728951, 593), + (9729544, 553), + (9730097, 550), + (9730647, 606), + (9731253, 553), + (9731806, 550), + (9732356, 605), + (9732961, 552), + (9733513, 549), + (9734062, 569), + (9734631, 553), + (9735184, 550), + (9735734, 586), + (9736320, 553), + (9736873, 550), + (9737423, 586), + (9738009, 553), + (9738562, 549), + (9739111, 588), + (9739699, 552), + (9740251, 550), + (9740801, 600), + (9741401, 552), + (9741953, 550), + (9742503, 599), + (9743102, 553), + (9743655, 549), + (9744204, 593), + (9744797, 554), + (9745351, 550), + (9745901, 604), + (9746505, 553), + (9747058, 549), + (9747607, 605), + (9748212, 552), + (9748764, 550), + (9749314, 573), + (9749887, 553), + (9750440, 550), + (9750990, 587), + (9751577, 552), + (9752129, 550), + (9752679, 587), + (9753266, 552), + (9753818, 550), + (9754368, 589), + (9754957, 553), + (9755510, 550), + (9756060, 600), + (9756660, 552), + (9757212, 549), + (9757761, 601), + (9758362, 553), + (9758915, 551), + (9759466, 594), + (9760060, 552), + (9760612, 551), + (9761163, 607), + (9761770, 554), + (9762324, 551), + (9762875, 606), + (9763481, 553), + (9764034, 551), + (9764585, 585), + (9765170, 551), + (9765721, 549), + (9766270, 599), + (9766869, 554), + (9767423, 550), + (9767973, 600), + (9768573, 552), + (9769125, 550), + (9769675, 599), + (9770274, 553), + (9770827, 549), + (9771376, 611), + (9771987, 553), + (9772540, 549), + (9773089, 612), + (9773701, 553), + (9774254, 551), + (9774805, 607), + (9775412, 554), + (9775966, 550), + (9776516, 618), + (9777134, 554), + (9777688, 549), + (9778237, 619), + (9778856, 554), + (9779410, 550), + (9779960, 585), + (9780545, 552), + (9781097, 550), + (9781647, 599), + (9782246, 553), + (9782799, 550), + (9783349, 599), + (9783948, 553), + (9784501, 550), + (9785051, 600), + (9785651, 552), + (9786203, 550), + (9786753, 612), + (9787365, 554), + (9787919, 549), + (9788468, 611), + (9789079, 552), + (9789631, 551), + (9790182, 606), + (9790788, 554), + (9791342, 549), + (9791891, 617), + (9792508, 552), + (9793060, 550), + (9793610, 617), + (9794227, 553), + (9794780, 551), + (9795331, 575), + (9795906, 552), + (9796458, 551), + (9797009, 589), + (9797598, 552), + (9798150, 549), + (9798699, 589), + (9799288, 552), + (9799840, 550), + (9800390, 590), + (9800980, 553), + (9801533, 550), + (9802083, 603), + (9802686, 553), + (9803239, 549), + (9803788, 603), + (9804391, 554), + (9804945, 550), + (9805495, 595), + (9806090, 554), + (9806644, 550), + (9807194, 607), + (9807801, 553), + (9808354, 550), + (9808904, 608), + (9809512, 554), + (9810066, 550), + (9810616, 586), + (9811202, 554), + (9811756, 550), + (9812306, 601), + (9812907, 554), + (9813461, 551), + (9814012, 600), + (9814612, 552), + (9815164, 550), + (9815714, 602), + (9816316, 553), + (9816869, 550), + (9817419, 614), + (9818033, 554), + (9818587, 550), + (9819137, 614), + (9819751, 553), + (9820304, 550), + (9820854, 607), + (9821461, 553), + (9822014, 551), + (9822565, 620), + (9823185, 553), + (9823738, 551), + (9824289, 620), + (9824909, 553), + (9825462, 551), + (9826013, 587), + (9826600, 553), + (9827153, 550), + (9827703, 601), + (9828304, 552), + (9828856, 550), + (9829406, 601), + (9830007, 553), + (9830560, 550), + (9831110, 603), + (9831713, 553), + (9832266, 549), + (9832815, 614), + (9833429, 553), + (9833982, 550), + (9834532, 613), + (9835145, 554), + (9835699, 550), + (9836249, 608), + (9836857, 552), + (9837409, 550), + (9837959, 621), + (9838580, 553), + (9839133, 550), + (9839683, 621), + (9840304, 553), + (9840857, 560), + (9841417, 542), + (9841959, 552), + (9842511, 560), + (9843071, 571), + (9843642, 553), + (9844195, 559), + (9844754, 570), + (9845324, 554), + (9845878, 559), + (9846437, 572), + (9847009, 552), + (9847561, 561), + (9848122, 584), + (9848706, 553), + (9849259, 561), + (9849820, 585), + (9850405, 553), + (9850958, 559), + (9851517, 578), + (9852095, 552), + (9852647, 560), + (9853207, 591), + (9853798, 553), + (9854351, 558), + (9854909, 591), + (9855500, 552), + (9856052, 561), + (9856613, 570), + (9857183, 551), + (9857734, 559), + (9858293, 586), + (9858879, 553), + (9859432, 559), + (9859991, 587), + (9860578, 554), + (9861132, 559), + (9861691, 586), + (9862277, 554), + (9862831, 560), + (9863391, 600), + (9863991, 552), + (9864543, 561), + (9865104, 599), + (9865703, 554), + (9866257, 561), + (9866818, 593), + (9867411, 554), + (9867965, 561), + (9868526, 605), + (9869131, 554), + (9869685, 560), + (9870245, 605), + (9870850, 553), + (9871403, 560), + (9871963, 570), + (9872533, 552), + (9873085, 560), + (9873645, 587), + (9874232, 552), + (9874784, 559), + (9875343, 585), + (9875928, 553), + (9876481, 559), + (9877040, 586), + (9877626, 553), + (9878179, 560), + (9878739, 599), + (9879338, 552), + (9879890, 560), + (9880450, 599), + (9881049, 552), + (9881601, 561), + (9882162, 593), + (9882755, 553), + (9883308, 560), + (9883868, 605), + (9884473, 554), + (9885027, 560), + (9885587, 605), + (9886192, 554), + (9886746, 560), + (9887306, 571), + (9887877, 553), + (9888430, 560), + (9888990, 587), + (9889577, 554), + (9890131, 561), + (9890692, 587), + (9891279, 552), + (9891831, 561), + (9892392, 587), + (9892979, 553), + (9893532, 560), + (9894092, 599), + (9894691, 553), + (9895244, 559), + (9895803, 600), + (9896403, 553), + (9896956, 561), + (9897517, 595), + (9898112, 553), + (9898665, 560), + (9899225, 606), + (9899831, 554), + (9900385, 559), + (9900944, 605), + (9901549, 552), + (9902101, 560), + (9902661, 584), + (9903245, 553), + (9903798, 560), + (9904358, 598), + (9904956, 552), + (9905508, 561), + (9906069, 598), + (9906667, 552), + (9907219, 559), + (9907778, 600), + (9908378, 554), + (9908932, 561), + (9909493, 611), + (9910104, 553), + (9910657, 560), + (9911217, 611), + (9911828, 552), + (9912380, 560), + (9912940, 607), + (9913547, 553), + (9914100, 561), + (9914661, 618), + (9915279, 553), + (9915832, 561), + (9916393, 617), + (9917010, 553), + (9917563, 561), + (9918124, 585), + (9918709, 552), + (9919261, 560), + (9919821, 600), + (9920421, 553), + (9920974, 560), + (9921534, 599), + (9922133, 552), + (9922685, 560), + (9923245, 600), + (9923845, 554), + (9924399, 561), + (9924960, 612), + (9925572, 553), + (9926125, 559), + (9926684, 612), + (9927296, 553), + (9927849, 559), + (9928408, 605), + (9929013, 553), + (9929566, 561), + (9930127, 619), + (9930746, 553), + (9931299, 561), + (9931860, 618), + (9932478, 554), + (9933032, 560), + (9933592, 576), + (9934168, 553), + (9934721, 560), + (9935281, 589), + (9935870, 552), + (9936422, 560), + (9936982, 588), + (9937570, 554), + (9938124, 560), + (9938684, 590), + (9939274, 552), + (9939826, 559), + (9940385, 602), + (9940987, 554), + (9941541, 560), + (9942101, 603), + (9942704, 553), + (9943257, 559), + (9943816, 596), + (9944412, 553), + (9944965, 561), + (9945526, 608), + (9946134, 554), + (9946688, 560), + (9947248, 607), + (9947855, 553), + (9948408, 560), + (9948968, 587), + (9949555, 554), + (9950109, 561), + (9950670, 600), + (9951270, 553), + (9951823, 560), + (9952383, 600), + (9952983, 552), + (9953535, 559), + (9954094, 602), + (9954696, 553), + (9955249, 559), + (9955808, 614), + (9956422, 554), + (9956976, 559), + (9957535, 614), + (9958149, 554), + (9958703, 561), + (9959264, 609), + (9959873, 552), + (9960425, 560), + (9960985, 619), + (9961604, 554), + (9962158, 559), + (9962717, 620), + (9963337, 553), + (9963890, 559), + (9964449, 588), + (9965037, 553), + (9965590, 559), + (9966149, 601), + (9966750, 552), + (9967302, 560), + (9967862, 602), + (9968464, 554), + (9969018, 561), + (9969579, 602), + (9970181, 552), + (9970733, 560), + (9971293, 614), + (9971907, 553), + (9972460, 560), + (9973020, 615), + (9973635, 552), + (9974187, 560), + (9974747, 608), + (9975355, 554), + (9975909, 561), + (9976470, 620), + (9977090, 553), + (9977643, 560), + (9978203, 620), + (9978823, 553), + (9979376, 565), + (9979941, 541), + (9980482, 553), + (9981035, 565), + (9981600, 570), + (9982170, 553), + (9982723, 567), + (9983290, 571), + (9983861, 553), + (9984414, 566), + (9984980, 572), + (9985552, 553), + (9986105, 567), + (9986672, 586), + (9987258, 554), + (9987812, 566), + (9988378, 585), + (9988963, 553), + (9989516, 565), + (9990081, 580), + (9990661, 553), + (9991214, 567), + (9991781, 591), + (9992372, 553), + (9992925, 565), + (9993490, 591), + (9994081, 552), + (9994633, 567), + (9995200, 569), + (9995769, 552), + (9996321, 565), + (9996886, 586), + (9997472, 552), + (9998024, 565), + (9998589, 585), + (9999174, 553), + (9999727, 567), + (10000294, 586), + (10000880, 553), + (10001433, 566), + (10001999, 598), + (10002597, 553), + (10003150, 566), + (10003716, 599), + (10004315, 553), + (10004868, 565), + (10005433, 594), + (10006027, 553), + (10006580, 566), + (10007146, 604), + (10007750, 552), + (10008302, 565), + (10008867, 606), + (10009473, 553), + (10010026, 565), + (10010591, 570), + (10011161, 551), + (10011712, 567), + (10012279, 587), + (10012866, 554), + (10013420, 566), + (10013986, 587), + (10014573, 554), + (10015127, 566), + (10015693, 586), + (10016279, 554), + (10016833, 566), + (10017399, 599), + (10017998, 552), + (10018550, 566), + (10019116, 600), + (10019716, 553), + (10020269, 565), + (10020834, 593), + (10021427, 554), + (10021981, 565), + (10022546, 606), + (10023152, 553), + (10023705, 564), + (10024269, 605), + (10024874, 553), + (10025427, 566), + (10025993, 572), + (10026565, 553), + (10027118, 566), + (10027684, 587), + (10028271, 553), + (10028824, 566), + (10029390, 587), + (10029977, 553), + (10030530, 567), + (10031097, 588), + (10031685, 554), + (10032239, 567), + (10032806, 599), + (10033405, 553), + (10033958, 566), + (10034524, 600), + (10035124, 552), + (10035676, 566), + (10036242, 594), + (10036836, 553), + (10037389, 566), + (10037955, 606), + (10038561, 552), + (10039113, 567), + (10039680, 606), + (10040286, 553), + (10040839, 566), + (10041405, 584), + (10041989, 553), + (10042542, 566), + (10043108, 599), + (10043707, 554), + (10044261, 566), + (10044827, 598), + (10045425, 553), + (10045978, 566), + (10046544, 600), + (10047144, 553), + (10047697, 565), + (10048262, 612), + (10048874, 554), + (10049428, 565), + (10049993, 611), + (10050604, 552), + (10051156, 565), + (10051721, 606), + (10052327, 554), + (10052881, 566), + (10053447, 619), + (10054066, 553), + (10054619, 565), + (10055184, 618), + (10055802, 553), + (10056355, 567), + (10056922, 586), + (10057508, 552), + (10058060, 566), + (10058626, 599), + (10059225, 553), + (10059778, 566), + (10060344, 598), + (10060942, 553), + (10061495, 567), + (10062062, 601), + (10062663, 553), + (10063216, 567), + (10063783, 612), + (10064395, 553), + (10064948, 566), + (10065514, 611), + (10066125, 553), + (10066678, 566), + (10067244, 605), + (10067849, 552), + (10068401, 566), + (10068967, 618), + (10069585, 552), + (10070137, 565), + (10070702, 618), + (10071320, 554), + (10071874, 566), + (10072440, 576), + (10073016, 553), + (10073569, 566), + (10074135, 589), + (10074724, 552), + (10075276, 566), + (10075842, 588), + (10076430, 553), + (10076983, 567), + (10077550, 589), + (10078139, 554), + (10078693, 566), + (10079259, 603), + (10079862, 553), + (10080415, 566), + (10080981, 601), + (10081582, 553), + (10082135, 566), + (10082701, 596), + (10083297, 553), + (10083850, 567), + (10084417, 608), + (10085025, 553), + (10085578, 565), + (10086143, 607), + (10086750, 553), + (10087303, 567), + (10087870, 588), + (10088458, 553), + (10089011, 564), + (10089575, 601), + (10090176, 553), + (10090729, 565), + (10091294, 602), + (10091896, 553), + (10092449, 566), + (10093015, 603), + (10093618, 553), + (10094171, 566), + (10094737, 614), + (10095351, 552), + (10095903, 566), + (10096469, 614), + (10097083, 553), + (10097636, 567), + (10098203, 608), + (10098811, 554), + (10099365, 565), + (10099930, 621), + (10100551, 553), + (10101104, 567), + (10101671, 620), + (10102291, 553), + (10102844, 566), + (10103410, 586), + (10103996, 553), + (10104549, 566), + (10105115, 601), + (10105716, 554), + (10106270, 567), + (10106837, 600), + (10107437, 554), + (10107991, 566), + (10108557, 602), + (10109159, 552), + (10109711, 567), + (10110278, 613), + (10110891, 553), + (10111444, 566), + (10112010, 613), + (10112623, 551), + (10113174, 565), + (10113739, 608), + (10114347, 554), + (10114901, 565), + (10115466, 621), + (10116087, 554), + (10116641, 566), + (10117207, 620), + (10117827, 553), + (10118380, 566), + (10118946, 542), + (10119488, 553), + (10120041, 566), + (10120607, 570), + (10121177, 553), + (10121730, 566), + (10122296, 571), + (10122867, 553), + (10123420, 566), + (10123986, 573), + (10124559, 554), + (10125113, 566), + (10125679, 585), + (10126264, 553), + (10126817, 565), + (10127382, 585), + (10127967, 552), + (10128519, 566), + (10129085, 579), + (10129664, 554), + (10130218, 566), + (10130784, 590), + (10131374, 552), + (10131926, 567), + (10132493, 590), + (10133083, 552), + (10133635, 566), + (10134201, 570), + (10134771, 554), + (10135325, 567), + (10135892, 586), + (10136478, 553), + (10137031, 567), + (10137598, 586), + (10138184, 554), + (10138738, 566), + (10139304, 587), + (10139891, 554), + (10140445, 566), + (10141011, 599), + (10141610, 554), + (10142164, 566), + (10142730, 599), + (10143329, 553), + (10143882, 566), + (10144448, 593), + (10145041, 553), + (10145594, 566), + (10146160, 606), + (10146766, 553), + (10147319, 567), + (10147886, 605), + (10148491, 553), + (10149044, 566), + (10149610, 571), + (10150181, 552), + (10150733, 565), + (10151298, 585), + (10151883, 553), + (10152436, 566), + (10153002, 585), + (10153587, 553), + (10154140, 566), + (10154706, 586), + (10155292, 552), + (10155844, 566), + (10156410, 599), + (10157009, 552), + (10157561, 566), + (10158127, 599), + (10158726, 552), + (10159278, 565), + (10159843, 593), + (10160436, 552), + (10160988, 565), + (10161553, 606), + (10162159, 554), + (10162713, 566), + (10163279, 604), + (10163883, 552), + (10164435, 566), + (10165001, 573), + (10165574, 554), + (10166128, 566), + (10166694, 587), + (10167281, 552), + (10167833, 566), + (10168399, 586), + (10168985, 554), + (10169539, 566), + (10170105, 589), + (10170694, 552), + (10171246, 567), + (10171813, 600), + (10172413, 553), + (10172966, 566), + (10173532, 599), + (10174131, 553), + (10174684, 566), + (10175250, 593), + (10175843, 553), + (10176396, 566), + (10176962, 605), + (10177567, 553), + (10178120, 565), + (10178685, 606), + (10179291, 553), + (10179844, 565), + (10180409, 586), + (10180995, 554), + (10181549, 567), + (10182116, 598), + (10182714, 552), + (10183266, 567), + (10183833, 599), + (10184432, 553), + (10184985, 565), + (10185550, 600), + (10186150, 552), + (10186702, 565), + (10187267, 611), + (10187878, 554), + (10188432, 567), + (10188999, 612), + (10189611, 553), + (10190164, 567), + (10190731, 606), + (10191337, 553), + (10191890, 566), + (10192456, 618), + (10193074, 554), + (10193628, 565), + (10194193, 619), + (10194812, 552), + (10195364, 567), + (10195931, 585), + (10196516, 554), + (10197070, 566), + (10197636, 600), + (10198236, 554), + (10198790, 566), + (10199356, 600), + (10199956, 552), + (10200508, 567), + (10201075, 599), + (10201674, 554), + (10202228, 565), + (10202793, 612), + (10203405, 553), + (10203958, 566), + (10204524, 611), + (10205135, 554), + (10205689, 565), + (10206254, 607), + (10206861, 553), + (10207414, 566), + (10207980, 618), + (10208598, 553), + (10209151, 566), + (10209717, 618), + (10210335, 553), + (10210888, 567), + (10211455, 575), + (10212030, 553), + (10212583, 565), + (10213148, 590), + (10213738, 554), + (10214292, 566), + (10214858, 589), + (10215447, 553), + (10216000, 566), + (10216566, 591), + (10217157, 553), + (10217710, 566), + (10218276, 603), + (10218879, 553), + (10219432, 566), + (10219998, 602), + (10220600, 553), + (10221153, 567), + (10221720, 596), + (10222316, 552), + (10222868, 567), + (10223435, 607), + (10224042, 554), + (10224596, 566), + (10225162, 607), + (10225769, 554), + (10226323, 566), + (10226889, 587), + (10227476, 553), + (10228029, 566), + (10228595, 601), + (10229196, 553), + (10229749, 566), + (10230315, 601), + (10230916, 552), + (10231468, 565), + (10232033, 603), + (10232636, 552), + (10233188, 566), + (10233754, 615), + (10234369, 553), + (10234922, 567), + (10235489, 615), + (10236104, 553), + (10236657, 567), + (10237224, 608), + (10237832, 554), + (10238386, 566), + (10238952, 619), + (10239571, 554), + (10240125, 566), + (10240691, 619), + (10241310, 553), + (10241863, 565), + (10242428, 587), + (10243015, 552), + (10243567, 565), + (10244132, 601), + (10244733, 554), + (10245287, 567), + (10245854, 602), + (10246456, 554), + (10247010, 567), + (10247577, 602), + (10248179, 553), + (10248732, 566), + (10249298, 613), + (10249911, 554), + (10250465, 567), + (10251032, 615), + (10251647, 553), + (10252200, 567), + (10252767, 608), + (10253375, 554), + (10253929, 565), + (10254494, 620), + (10255114, 553), + (10255667, 567), + (10256234, 619), + (10256853, 553), + (10257406, 561), + (10257967, 542), + (10258509, 553), + (10259062, 562), + (10259624, 570), + (10260194, 553), + (10260747, 560), + (10261307, 571), + (10261878, 553), + (10262431, 561), + (10262992, 573), + (10263565, 552), + (10264117, 560), + (10264677, 586), + (10265263, 553), + (10265816, 560), + (10266376, 584), + (10266960, 553), + (10267513, 561), + (10268074, 579), + (10268653, 553), + (10269206, 560), + (10269766, 591), + (10270357, 553), + (10270910, 562), + (10271472, 591), + (10272063, 553), + (10272616, 561), + (10273177, 569), + (10273746, 553), + (10274299, 562), + (10274861, 585), + (10275446, 552), + (10275998, 561), + (10276559, 585), + (10277144, 553), + (10277697, 562), + (10278259, 587), + (10278846, 553), + (10279399, 561), + (10279960, 599), + (10280559, 554), + (10281113, 561), + (10281674, 600), + (10282274, 553), + (10282827, 562), + (10283389, 593), + (10283982, 553), + (10284535, 562), + (10285097, 604), + (10285701, 553), + (10286254, 561), + (10286815, 604), + (10287419, 552), + (10287971, 562), + (10288533, 570), + (10289103, 553), + (10289656, 560), + (10290216, 587), + (10290803, 553), + (10291356, 562), + (10291918, 586), + (10292504, 552), + (10293056, 561), + (10293617, 586), + (10294203, 552), + (10294755, 560), + (10295315, 598), + (10295913, 553), + (10296466, 562), + (10297028, 600), + (10297628, 553), + (10298181, 560), + (10298741, 594), + (10299335, 553), + (10299888, 560), + (10300448, 605), + (10301053, 553), + (10301606, 560), + (10302166, 604), + (10302770, 553), + (10303323, 561), + (10303884, 573), + (10304457, 553), + (10305010, 560), + (10305570, 586), + (10306156, 552), + (10306708, 561), + (10307269, 588), + (10307857, 554), + (10308411, 562), + (10308973, 588), + (10309561, 553), + (10310114, 561), + (10310675, 601), + (10311276, 551), + (10311827, 561), + (10312388, 600), + (10312988, 553), + (10313541, 561), + (10314102, 593), + (10314695, 553), + (10315248, 562), + (10315810, 606), + (10316416, 553), + (10316969, 562), + (10317531, 607), + (10318138, 553), + (10318691, 561), + (10319252, 585), + (10319837, 553), + (10320390, 562), + (10320952, 599), + (10321551, 554), + (10322105, 562), + (10322667, 600), + (10323267, 553), + (10323820, 561), + (10324381, 599), + (10324980, 554), + (10325534, 562), + (10326096, 613), + (10326709, 554), + (10327263, 561), + (10327824, 611), + (10328435, 553), + (10328988, 562), + (10329550, 605), + (10330155, 553), + (10330708, 562), + (10331270, 618), + (10331888, 553), + (10332441, 562), + (10333003, 617), + (10333620, 553), + (10334173, 560), + (10334733, 585), + (10335318, 554), + (10335872, 560), + (10336432, 599), + (10337031, 553), + (10337584, 560), + (10338144, 600), + (10338744, 552), + (10339296, 561), + (10339857, 600), + (10340457, 552), + (10341009, 560), + (10341569, 613), + (10342182, 552), + (10342734, 560), + (10343294, 613), + (10343907, 554), + (10344461, 562), + (10345023, 606), + (10345629, 552), + (10346181, 561), + (10346742, 618), + (10347360, 553), + (10347913, 561), + (10348474, 618), + (10349092, 552), + (10349644, 561), + (10350205, 575), + (10350780, 554), + (10351334, 562), + (10351896, 589), + (10352485, 553), + (10353038, 561), + (10353599, 589), + (10354188, 552), + (10354740, 562), + (10355302, 590), + (10355892, 552), + (10356444, 560), + (10357004, 601), + (10357605, 553), + (10358158, 560), + (10358718, 601), + (10359319, 553), + (10359872, 562), + (10360434, 595), + (10361029, 552), + (10361581, 561), + (10362142, 609), + (10362751, 553), + (10363304, 562), + (10363866, 607), + (10364473, 554), + (10365027, 560), + (10365587, 586), + (10366173, 553), + (10366726, 561), + (10367287, 601), + (10367888, 554), + (10368442, 560), + (10369002, 602), + (10369604, 553), + (10370157, 561), + (10370718, 601), + (10371319, 553), + (10371872, 561), + (10372433, 614), + (10373047, 553), + (10373600, 561), + (10374161, 614), + (10374775, 553), + (10375328, 560), + (10375888, 607), + (10376495, 554), + (10377049, 559), + (10377608, 620), + (10378228, 552), + (10378780, 560), + (10379340, 619), + (10379959, 554), + (10380513, 560), + (10381073, 587), + (10381660, 552), + (10382212, 561), + (10382773, 601), + (10383374, 553), + (10383927, 560), + (10384487, 602), + (10385089, 554), + (10385643, 562), + (10386205, 601), + (10386806, 553), + (10387359, 561), + (10387920, 614), + (10388534, 553), + (10389087, 560), + (10389647, 614), + (10390261, 553), + (10390814, 561), + (10391375, 608), + (10391983, 554), + (10392537, 560), + (10393097, 621), + (10393718, 553), + (10394271, 562), + (10394833, 621), + (10395454, 553), + (10396007, 568), + (10396575, 542), + (10397117, 553), + (10397670, 567), + (10398237, 571), + (10398808, 552), + (10399360, 568), + (10399928, 570), + (10400498, 553), + (10401051, 567), + (10401618, 572), + (10402190, 554), + (10402744, 566), + (10403310, 585), + (10403895, 553), + (10404448, 568), + (10405016, 585), + (10405601, 554), + (10406155, 566), + (10406721, 580), + (10407301, 552), + (10407853, 567), + (10408420, 589), + (10409009, 554), + (10409563, 566), + (10410129, 591), + (10410720, 553), + (10411273, 567), + (10411840, 569), + (10412409, 553), + (10412962, 567), + (10413529, 586), + (10414115, 553), + (10414668, 566), + (10415234, 586), + (10415820, 553), + (10416373, 566), + (10416939, 586), + (10417525, 552), + (10418077, 567), + (10418644, 599), + (10419243, 553), + (10419796, 568), + (10420364, 599), + (10420963, 554), + (10421517, 567), + (10422084, 592), + (10422676, 553), + (10423229, 566), + (10423795, 604), + (10424399, 553), + (10424952, 567), + (10425519, 604), + (10426123, 554), + (10426677, 568), + (10427245, 571), + (10427816, 553), + (10428369, 568), + (10428937, 585), + (10429522, 554), + (10430076, 568), + (10430644, 586), + (10431230, 553), + (10431783, 567), + (10432350, 588), + (10432938, 552), + (10433490, 568), + (10434058, 598), + (10434656, 554), + (10435210, 568), + (10435778, 600), + (10436378, 553), + (10436931, 567), + (10437498, 594), + (10438092, 553), + (10438645, 566), + (10439211, 605), + (10439816, 554), + (10440370, 567), + (10440937, 606), + (10441543, 553), + (10442096, 566), + (10442662, 571), + (10443233, 553), + (10443786, 568), + (10444354, 588), + (10444942, 553), + (10445495, 568), + (10446063, 587), + (10446650, 553), + (10447203, 567), + (10447770, 587), + (10448357, 553), + (10448910, 567), + (10449477, 601), + (10450078, 553), + (10450631, 567), + (10451198, 599), + (10451797, 553), + (10452350, 567), + (10452917, 593), + (10453510, 553), + (10454063, 568), + (10454631, 605), + (10455236, 553), + (10455789, 568), + (10456357, 606), + (10456963, 553), + (10457516, 566), + (10458082, 586), + (10458668, 553), + (10459221, 567), + (10459788, 599), + (10460387, 553), + (10460940, 568), + (10461508, 600), + (10462108, 553), + (10462661, 567), + (10463228, 600), + (10463828, 554), + (10464382, 568), + (10464950, 612), + (10465562, 553), + (10466115, 566), + (10466681, 612), + (10467293, 552), + (10467845, 567), + (10468412, 605), + (10469017, 554), + (10469571, 567), + (10470138, 618), + (10470756, 553), + (10471309, 567), + (10471876, 617), + (10472493, 553), + (10473046, 567), + (10473613, 585), + (10474198, 552), + (10474750, 567), + (10475317, 599), + (10475916, 553), + (10476469, 567), + (10477036, 599), + (10477635, 552), + (10478187, 567), + (10478754, 600), + (10479354, 552), + (10479906, 567), + (10480473, 611), + (10481084, 553), + (10481637, 567), + (10482204, 613), + (10482817, 554), + (10483371, 568), + (10483939, 606), + (10484545, 553), + (10485098, 567), + (10485665, 619), + (10486284, 553), + (10486837, 566), + (10487403, 618), + (10488021, 553), + (10488574, 567), + (10489141, 575), + (10489716, 552), + (10490268, 567), + (10490835, 588), + (10491423, 553), + (10491976, 568), + (10492544, 589), + (10493133, 553), + (10493686, 566), + (10494252, 589), + (10494841, 552), + (10495393, 567), + (10495960, 603), + (10496563, 552), + (10497115, 566), + (10497681, 603), + (10498284, 553), + (10498837, 566), + (10499403, 597), + (10500000, 554), + (10500554, 566), + (10501120, 607), + (10501727, 552), + (10502279, 567), + (10502846, 607), + (10503453, 553), + (10504006, 566), + (10504572, 587), + (10505159, 554), + (10505713, 568), + (10506281, 601), + (10506882, 552), + (10507434, 568), + (10508002, 600), + (10508602, 553), + (10509155, 567), + (10509722, 601), + (10510323, 553), + (10510876, 566), + (10511442, 614), + (10512056, 552), + (10512608, 567), + (10513175, 615), + (10513790, 552), + (10514342, 568), + (10514910, 607), + (10515517, 552), + (10516069, 567), + (10516636, 620), + (10517256, 553), + (10517809, 567), + (10518376, 621), + (10518997, 553), + (10519550, 566), + (10520116, 587), + (10520703, 552), + (10521255, 567), + (10521822, 600), + (10522422, 553), + (10522975, 567), + (10523542, 600), + (10524142, 554), + (10524696, 566), + (10525262, 602), + (10525864, 554), + (10526418, 566), + (10526984, 613), + (10527597, 554), + (10528151, 568), + (10528719, 615), + (10529334, 553), + (10529887, 567), + (10530454, 607), + (10531061, 553), + (10531614, 567), + (10532181, 620), + (10532801, 553), + (10533354, 568), + (10533922, 620), + (10534542, 554), + (10535096, 567), + (10535663, 541), + (10536204, 553), + (10536757, 567), + (10537324, 571), + (10537895, 552), + (10538447, 567), + (10539014, 569), + (10539583, 552), + (10540135, 566), + (10540701, 571), + (10541272, 553), + (10541825, 568), + (10542393, 585), + (10542978, 552), + (10543530, 567), + (10544097, 585), + (10544682, 553), + (10545235, 566), + (10545801, 578), + (10546379, 553), + (10546932, 567), + (10547499, 590), + (10548089, 553), + (10548642, 566), + (10549208, 591), + (10549799, 553), + (10550352, 567), + (10550919, 571), + (10551490, 554), + (10552044, 567), + (10552611, 586), + (10553197, 553), + (10553750, 566), + (10554316, 587), + (10554903, 552), + (10555455, 567), + (10556022, 587), + (10556609, 554), + (10557163, 567), + (10557730, 599), + (10558329, 554), + (10558883, 567), + (10559450, 599), + (10560049, 552), + (10560601, 567), + (10561168, 592), + (10561760, 553), + (10562313, 568), + (10562881, 604), + (10563485, 553), + (10564038, 568), + (10564606, 605), + (10565211, 554), + (10565765, 567), + (10566332, 569), + (10566901, 552), + (10567453, 568), + (10568021, 587), + (10568608, 553), + (10569161, 567), + (10569728, 585), + (10570313, 554), + (10570867, 567), + (10571434, 587), + (10572021, 554), + (10572575, 568), + (10573143, 600), + (10573743, 553), + (10574296, 567), + (10574863, 599), + (10575462, 553), + (10576015, 566), + (10576581, 592), + (10577173, 552), + (10577725, 567), + (10578292, 604), + (10578896, 553), + (10579449, 568), + (10580017, 606), + (10580623, 554), + (10581177, 567), + (10581744, 573), + (10582317, 554), + (10582871, 567), + (10583438, 586), + (10584024, 554), + (10584578, 567), + (10585145, 586), + (10585731, 554), + (10586285, 567), + (10586852, 588), + (10587440, 552), + (10587992, 567), + (10588559, 600), + (10589159, 552), + (10589711, 567), + (10590278, 600), + (10590878, 554), + (10591432, 567), + (10591999, 593), + (10592592, 553), + (10593145, 567), + (10593712, 607), + (10594319, 553), + (10594872, 567), + (10595439, 607), + (10596046, 552), + (10596598, 566), + (10597164, 585), + (10597749, 554), + (10598303, 568), + (10598871, 599), + (10599470, 554), + (10600024, 567), + (10600591, 599), + (10601190, 553), + (10601743, 566), + (10602309, 599), + (10602908, 553), + (10603461, 566), + (10604027, 613), + (10604640, 554), + (10605194, 567), + (10605761, 613), + (10606374, 552), + (10606926, 567), + (10607493, 606), + (10608099, 554), + (10608653, 566), + (10609219, 618), + (10609837, 554), + (10610391, 566), + (10610957, 619), + (10611576, 553), + (10612129, 567), + (10612696, 586), + (10613282, 553), + (10613835, 568), + (10614403, 600), + (10615003, 553), + (10615556, 567), + (10616123, 599), + (10616722, 554), + (10617276, 567), + (10617843, 600), + (10618443, 552), + (10618995, 567), + (10619562, 613), + (10620175, 552), + (10620727, 567), + (10621294, 612), + (10621906, 553), + (10622459, 567), + (10623026, 605), + (10623631, 554), + (10624185, 568), + (10624753, 618), + (10625371, 553), + (10625924, 568), + (10626492, 619), + (10627111, 553), + (10627664, 566), + (10628230, 574), + (10628804, 552), + (10629356, 567), + (10629923, 589), + (10630512, 553), + (10631065, 566), + (10631631, 590), + (10632221, 553), + (10632774, 566), + (10633340, 589), + (10633929, 554), + (10634483, 567), + (10635050, 602), + (10635652, 554), + (10636206, 567), + (10636773, 603), + (10637376, 554), + (10637930, 567), + (10638497, 596), + (10639093, 554), + (10639647, 567), + (10640214, 608), + (10640822, 553), + (10641375, 567), + (10641942, 609), + (10642551, 553), + (10643104, 567), + (10643671, 587), + (10644258, 553), + (10644811, 568), + (10645379, 602), + (10645981, 552), + (10646533, 567), + (10647100, 600), + (10647700, 553), + (10648253, 566), + (10648819, 601), + (10649420, 553), + (10649973, 567), + (10650540, 615), + (10651155, 552), + (10651707, 567), + (10652274, 615), + (10652889, 553), + (10653442, 566), + (10654008, 608), + (10654616, 552), + (10655168, 567), + (10655735, 620), + (10656355, 554), + (10656909, 568), + (10657477, 621), + (10658098, 553), + (10658651, 568), + (10659219, 587), + (10659806, 552), + (10660358, 568), + (10660926, 600), + (10661526, 552), + (10662078, 567), + (10662645, 601), + (10663246, 552), + (10663798, 566), + (10664364, 602), + (10664966, 552), + (10665518, 566), + (10666084, 613), + (10666697, 553), + (10667250, 566), + (10667816, 614), + (10668430, 553), + (10668983, 567), + (10669550, 608), + (10670158, 554), + (10670712, 568), + (10671280, 620), + (10671900, 552), + (10672452, 567), + (10673019, 620), + (10673639, 553), + (10674192, 534), + (10674726, 542), + (10675268, 553), + (10675821, 535), + (10676356, 570), + (10676926, 554), + (10677480, 534), + (10678014, 570), + (10678584, 553), + (10679137, 534), + (10679671, 572), + (10680243, 552), + (10680795, 533), + (10681328, 585), + (10681913, 554), + (10682467, 535), + (10683002, 585), + (10683587, 552), + (10684139, 533), + (10684672, 580), + (10685252, 554), + (10685806, 535), + (10686341, 590), + (10686931, 552), + (10687483, 535), + (10688018, 591), + (10688609, 552), + (10689161, 534), + (10689695, 570), + (10690265, 554), + (10690819, 533), + (10691352, 586), + (10691938, 553), + (10692491, 534), + (10693025, 586), + (10693611, 552), + (10694163, 533), + (10694696, 587), + (10695283, 553), + (10695836, 533), + (10696369, 599), + (10696968, 553), + (10697521, 534), + (10698055, 600), + (10698655, 552), + (10699207, 533), + (10699740, 593), + (10700333, 553), + (10700886, 535), + (10701421, 605), + (10702026, 553), + (10702579, 534), + (10703113, 605), + (10703718, 552), + (10704270, 533), + (10704803, 570), + (10705373, 553), + (10705926, 534), + (10706460, 586), + (10707046, 554), + (10707600, 533), + (10708133, 587), + (10708720, 553), + (10709273, 533), + (10709806, 587), + (10710393, 552), + (10710945, 534), + (10711479, 599), + (10712078, 552), + (10712630, 533), + (10713163, 599), + (10713762, 554), + (10714316, 534), + (10714850, 594), + (10715444, 553), + (10715997, 535), + (10716532, 606), + (10717138, 553), + (10717691, 535), + (10718226, 605), + (10718831, 552), + (10719383, 534), + (10719917, 572), + (10720489, 553), + (10721042, 534), + (10721576, 585), + (10722161, 553), + (10722714, 533), + (10723247, 587), + (10723834, 553), + (10724387, 534), + (10724921, 587), + (10725508, 554), + (10726062, 535), + (10726597, 599), + (10727196, 553), + (10727749, 534), + (10728283, 599), + (10728882, 552), + (10729434, 534), + (10729968, 594), + (10730562, 553), + (10731115, 535), + (10731650, 607), + (10732257, 553), + (10732810, 534), + (10733344, 607), + (10733951, 554), + (10734505, 534), + (10735039, 586), + (10735625, 553), + (10736178, 533), + (10736711, 599), + (10737310, 554), + (10737864, 533), + (10738397, 598), + (10738995, 553), + (10739548, 534), + (10740082, 601), + (10740683, 554), + (10741237, 533), + (10741770, 611), + (10742381, 552), + (10742933, 533), + (10743466, 611), + (10744077, 553), + (10744630, 534), + (10745164, 606), + (10745770, 553), + (10746323, 534), + (10746857, 618), + (10747475, 552), + (10748027, 535), + (10748562, 617), + (10749179, 553), + (10749732, 534), + (10750266, 586), + (10750852, 553), + (10751405, 533), + (10751938, 598), + (10752536, 552), + (10753088, 535), + (10753623, 598), + (10754221, 553), + (10754774, 535), + (10755309, 601), + (10755910, 552), + (10756462, 534), + (10756996, 612), + (10757608, 553), + (10758161, 534), + (10758695, 612), + (10759307, 553), + (10759860, 534), + (10760394, 606), + (10761000, 554), + (10761554, 534), + (10762088, 618), + (10762706, 552), + (10763258, 534), + (10763792, 618), + (10764410, 553), + (10764963, 534), + (10765497, 576), + (10766073, 552), + (10766625, 534), + (10767159, 590), + (10767749, 552), + (10768301, 534), + (10768835, 590), + (10769425, 553), + (10769978, 534), + (10770512, 589), + (10771101, 553), + (10771654, 533), + (10772187, 602), + (10772789, 553), + (10773342, 534), + (10773876, 601), + (10774477, 553), + (10775030, 535), + (10775565, 596), + (10776161, 552), + (10776713, 533), + (10777246, 608), + (10777854, 553), + (10778407, 534), + (10778941, 608), + (10779549, 552), + (10780101, 533), + (10780634, 587), + (10781221, 552), + (10781773, 534), + (10782307, 600), + (10782907, 553), + (10783460, 534), + (10783994, 601), + (10784595, 552), + (10785147, 535), + (10785682, 603), + (10786285, 553), + (10786838, 534), + (10787372, 614), + (10787986, 554), + (10788540, 535), + (10789075, 614), + (10789689, 553), + (10790242, 533), + (10790775, 609), + (10791384, 553), + (10791937, 534), + (10792471, 619), + (10793090, 553), + (10793643, 534), + (10794177, 619), + (10794796, 553), + (10795349, 535), + (10795884, 586), + (10796470, 554), + (10797024, 534), + (10797558, 600), + (10798158, 553), + (10798711, 535), + (10799246, 600), + (10799846, 553), + (10800399, 535), + (10800934, 601), + (10801535, 554), + (10802089, 534), + (10802623, 615), + (10803238, 553), + (10803791, 534), + (10804325, 614), + (10804939, 552), + (10805491, 533), + (10806024, 608), + (10806632, 553), + (10807185, 533), + (10807718, 620), + (10808338, 552), + (10808890, 534), + (10809424, 620), + (10810044, 553), + (10810597, 551), + (10811148, 542), + (10811690, 553), + (10812243, 551), + (10812794, 569), + (10813363, 554), + (10813917, 551), + (10814468, 569), + (10815037, 553), + (10815590, 550), + (10816140, 573), + (10816713, 552), + (10817265, 552), + (10817817, 585), + (10818402, 553), + (10818955, 550), + (10819505, 585), + (10820090, 554), + (10820644, 552), + (10821196, 579), + (10821775, 552), + (10822327, 552), + (10822879, 591), + (10823470, 553), + (10824023, 552), + (10824575, 591), + (10825166, 553), + (10825719, 550), + (10826269, 570), + (10826839, 552), + (10827391, 550), + (10827941, 586), + (10828527, 552), + (10829079, 552), + (10829631, 586), + (10830217, 553), + (10830770, 551), + (10831321, 588), + (10831909, 553), + (10832462, 551), + (10833013, 600), + (10833613, 553), + (10834166, 551), + (10834717, 599), + (10835316, 553), + (10835869, 550), + (10836419, 594), + (10837013, 552), + (10837565, 550), + (10838115, 605), + (10838720, 553), + (10839273, 552), + (10839825, 605), + (10840430, 552), + (10840982, 551), + (10841533, 570), + (10842103, 552), + (10842655, 552), + (10843207, 586), + (10843793, 552), + (10844345, 551), + (10844896, 586), + (10845482, 554), + (10846036, 552), + (10846588, 587), + (10847175, 554), + (10847729, 552), + (10848281, 598), + (10848879, 552), + (10849431, 551), + (10849982, 599), + (10850581, 553), + (10851134, 550), + (10851684, 594), + (10852278, 554), + (10852832, 551), + (10853383, 606), + (10853989, 553), + (10854542, 551), + (10855093, 605), + (10855698, 552), + (10856250, 551), + (10856801, 572), + (10857373, 554), + (10857927, 550), + (10858477, 588), + (10859065, 553), + (10859618, 551), + (10860169, 586), + (10860755, 554), + (10861309, 550), + (10861859, 588), + (10862447, 554), + (10863001, 550), + (10863551, 599), + (10864150, 553), + (10864703, 552), + (10865255, 600), + (10865855, 554), + (10866409, 551), + (10866960, 594), + (10867554, 553), + (10868107, 550), + (10868657, 606), + (10869263, 553), + (10869816, 551), + (10870367, 606), + (10870973, 552), + (10871525, 551), + (10872076, 586), + (10872662, 553), + (10873215, 551), + (10873766, 598), + (10874364, 553), + (10874917, 552), + (10875469, 598), + (10876067, 554), + (10876621, 552), + (10877173, 600), + (10877773, 552), + (10878325, 551), + (10878876, 612), + (10879488, 553), + (10880041, 551), + (10880592, 612), + (10881204, 552), + (10881756, 552), + (10882308, 605), + (10882913, 553), + (10883466, 551), + (10884017, 618), + (10884635, 552), + (10885187, 552), + (10885739, 617), + (10886356, 554), + (10886910, 550), + (10887460, 586), + (10888046, 553), + (10888599, 551), + (10889150, 599), + (10889749, 552), + (10890301, 552), + (10890853, 598), + (10891451, 554), + (10892005, 551), + (10892556, 600), + (10893156, 554), + (10893710, 552), + (10894262, 612), + (10894874, 554), + (10895428, 551), + (10895979, 611), + (10896590, 554), + (10897144, 550), + (10897694, 605), + (10898299, 553), + (10898852, 550), + (10899402, 617), + (10900019, 554), + (10900573, 550), + (10901123, 618), + (10901741, 553), + (10902294, 551), + (10902845, 575), + (10903420, 552), + (10903972, 551), + (10904523, 588), + (10905111, 554), + (10905665, 550), + (10906215, 588), + (10906803, 552), + (10907355, 551), + (10907906, 589), + (10908495, 553), + (10909048, 550), + (10909598, 602), + (10910200, 552), + (10910752, 551), + (10911303, 603), + (10911906, 552), + (10912458, 552), + (10913010, 595), + (10913605, 554), + (10914159, 550), + (10914709, 609), + (10915318, 554), + (10915872, 550), + (10916422, 608), + (10917030, 553), + (10917583, 552), + (10918135, 586), + (10918721, 554), + (10919275, 551), + (10919826, 600), + (10920426, 553), + (10920979, 552), + (10921531, 601), + (10922132, 553), + (10922685, 552), + (10923237, 601), + (10923838, 553), + (10924391, 551), + (10924942, 614), + (10925556, 553), + (10926109, 550), + (10926659, 614), + (10927273, 554), + (10927827, 550), + (10928377, 607), + (10928984, 552), + (10929536, 551), + (10930087, 621), + (10930708, 552), + (10931260, 552), + (10931812, 620), + (10932432, 554), + (10932986, 551), + (10933537, 588), + (10934125, 552), + (10934677, 552), + (10935229, 602), + (10935831, 553), + (10936384, 551), + (10936935, 601), + (10937536, 553), + (10938089, 551), + (10938640, 601), + (10939241, 554), + (10939795, 551), + (10940346, 614), + (10940960, 552), + (10941512, 551), + (10942063, 614), + (10942677, 553), + (10943230, 550), + (10943780, 609), + (10944389, 553), + (10944942, 550), + (10945492, 619), + (10946111, 552), + (10946663, 551), + (10947214, 619), + (10947833, 553), + (10948386, 551), + (10948937, 542), + (10949479, 553), + (10950032, 552), + (10950584, 570), + (10951154, 554), + (10951708, 551), + (10952259, 569), + (10952828, 554), + (10953382, 550), + (10953932, 572), + (10954504, 554), + (10955058, 552), + (10955610, 586), + (10956196, 553), + (10956749, 551), + (10957300, 585), + (10957885, 553), + (10958438, 551), + (10958989, 579), + (10959568, 553), + (10960121, 552), + (10960673, 591), + (10961264, 553), + (10961817, 550), + (10962367, 592), + (10962959, 554), + (10963513, 550), + (10964063, 570), + (10964633, 553), + (10965186, 551), + (10965737, 586), + (10966323, 553), + (10966876, 550), + (10967426, 585), + (10968011, 552), + (10968563, 551), + (10969114, 586), + (10969700, 552), + (10970252, 551), + (10970803, 599), + (10971402, 553), + (10971955, 550), + (10972505, 598), + (10973103, 554), + (10973657, 552), + (10974209, 593), + (10974802, 552), + (10975354, 550), + (10975904, 606), + (10976510, 553), + (10977063, 551), + (10977614, 604), + (10978218, 553), + (10978771, 551), + (10979322, 569), + (10979891, 552), + (10980443, 550), + (10980993, 585), + (10981578, 553), + (10982131, 552), + (10982683, 586), + (10983269, 554), + (10983823, 552), + (10984375, 588), + (10984963, 552), + (10985515, 550), + (10986065, 599), + (10986664, 554), + (10987218, 550), + (10987768, 599), + (10988367, 553), + (10988920, 551), + (10989471, 593), + (10990064, 553), + (10990617, 551), + (10991168, 604), + (10991772, 552), + (10992324, 550), + (10992874, 605), + (10993479, 553), + (10994032, 552), + (10994584, 571), + (10995155, 553), + (10995708, 551), + (10996259, 587), + (10996846, 554), + (10997400, 550), + (10997950, 587), + (10998537, 554), + (10999091, 551), + (10999642, 588), + (11000230, 554), + (11000784, 550), + (11001334, 600), + (11001934, 552), + (11002486, 550), + (11003036, 601), + (11003637, 554), + (11004191, 551), + (11004742, 595), + (11005337, 553), + (11005890, 552), + (11006442, 605), + (11007047, 554), + (11007601, 550), + (11008151, 605), + (11008756, 552), + (11009308, 550), + (11009858, 586), + (11010444, 554), + (11010998, 551), + (11011549, 600), + (11012149, 553), + (11012702, 551), + (11013253, 598), + (11013851, 552), + (11014403, 550), + (11014953, 601), + (11015554, 553), + (11016107, 551), + (11016658, 612), + (11017270, 553), + (11017823, 552), + (11018375, 611), + (11018986, 552), + (11019538, 551), + (11020089, 605), + (11020694, 553), + (11021247, 552), + (11021799, 618), + (11022417, 553), + (11022970, 552), + (11023522, 617), + (11024139, 553), + (11024692, 551), + (11025243, 585), + (11025828, 552), + (11026380, 551), + (11026931, 600), + (11027531, 553), + (11028084, 550), + (11028634, 600), + (11029234, 553), + (11029787, 551), + (11030338, 600), + (11030938, 552), + (11031490, 551), + (11032041, 613), + (11032654, 553), + (11033207, 551), + (11033758, 612), + (11034370, 553), + (11034923, 552), + (11035475, 606), + (11036081, 552), + (11036633, 552), + (11037185, 618), + (11037803, 554), + (11038357, 551), + (11038908, 618), + (11039526, 552), + (11040078, 552), + (11040630, 576), + (11041206, 554), + (11041760, 551), + (11042311, 589), + (11042900, 553), + (11043453, 552), + (11044005, 588), + (11044593, 553), + (11045146, 551), + (11045697, 590), + (11046287, 554), + (11046841, 551), + (11047392, 602), + (11047994, 554), + (11048548, 551), + (11049099, 602), + (11049701, 554), + (11050255, 552), + (11050807, 595), + (11051402, 553), + (11051955, 552), + (11052507, 608), + (11053115, 553), + (11053668, 551), + (11054219, 608), + (11054827, 554), + (11055381, 550), + (11055931, 586), + (11056517, 553), + (11057070, 551), + (11057621, 601), + (11058222, 553), + (11058775, 552), + (11059327, 602), + (11059929, 554), + (11060483, 550), + (11061033, 602), + (11061635, 554), + (11062189, 551), + (11062740, 615), + (11063355, 553), + (11063908, 551), + (11064459, 615), + (11065074, 554), + (11065628, 551), + (11066179, 608), + (11066787, 554), + (11067341, 551), + (11067892, 621), + (11068513, 552), + (11069065, 552), + (11069617, 620), + (11070237, 554), + (11070791, 551), + (11071342, 587), + (11071929, 553), + (11072482, 552), + (11073034, 601), + (11073635, 554), + (11074189, 552), + (11074741, 600), + (11075341, 554), + (11075895, 550), + (11076445, 601), + (11077046, 553), + (11077599, 551), + (11078150, 613), + (11078763, 553), + (11079316, 550), + (11079866, 614), + (11080480, 553), + (11081033, 551), + (11081584, 608), + (11082192, 553), + (11082745, 550), + (11083295, 619), + (11083914, 553), + (11084467, 552), + (11085019, 620), + (11085639, 554), + (11086193, 561), + (11086754, 542), + (11087296, 553), + (11087849, 560), + (11088409, 571), + (11088980, 553), + (11089533, 560), + (11090093, 570), + (11090663, 552), + (11091215, 562), + (11091777, 572), + (11092349, 553), + (11092902, 561), + (11093463, 585), + (11094048, 554), + (11094602, 561), + (11095163, 586), + (11095749, 554), + (11096303, 561), + (11096864, 579), + (11097443, 552), + (11097995, 561), + (11098556, 592), + (11099148, 554), + (11099702, 560), + (11100262, 591), + (11100853, 553), + (11101406, 561), + (11101967, 570), + (11102537, 554), + (11103091, 560), + (11103651, 586), + (11104237, 552), + (11104789, 561), + (11105350, 585), + (11105935, 552), + (11106487, 562), + (11107049, 587), + (11107636, 553), + (11108189, 560), + (11108749, 598), + (11109347, 553), + (11109900, 562), + (11110462, 599), + (11111061, 551), + (11111612, 560), + (11112172, 594), + (11112766, 554), + (11113320, 561), + (11113881, 604), + (11114485, 552), + (11115037, 561), + (11115598, 605), + (11116203, 553), + (11116756, 560), + (11117316, 571), + (11117887, 552), + (11118439, 562), + (11119001, 585), + (11119586, 554), + (11120140, 560), + (11120700, 586), + (11121286, 552), + (11121838, 562), + (11122400, 587), + (11122987, 553), + (11123540, 561), + (11124101, 599), + (11124700, 553), + (11125253, 561), + (11125814, 598), + (11126412, 552), + (11126964, 561), + (11127525, 592), + (11128117, 552), + (11128669, 562), + (11129231, 606), + (11129837, 552), + (11130389, 561), + (11130950, 605), + (11131555, 554), + (11132109, 561), + (11132670, 572), + (11133242, 553), + (11133795, 560), + (11134355, 587), + (11134942, 553), + (11135495, 560), + (11136055, 587), + (11136642, 552), + (11137194, 561), + (11137755, 589), + (11138344, 554), + (11138898, 560), + (11139458, 599), + (11140057, 554), + (11140611, 561), + (11141172, 599), + (11141771, 553), + (11142324, 561), + (11142885, 594), + (11143479, 553), + (11144032, 562), + (11144594, 606), + (11145200, 553), + (11145753, 562), + (11146315, 606), + (11146921, 552), + (11147473, 562), + (11148035, 585), + (11148620, 554), + (11149174, 561), + (11149735, 599), + (11150334, 553), + (11150887, 562), + (11151449, 598), + (11152047, 552), + (11152599, 560), + (11153159, 600), + (11153759, 553), + (11154312, 561), + (11154873, 611), + (11155484, 553), + (11156037, 560), + (11156597, 613), + (11157210, 552), + (11157762, 562), + (11158324, 607), + (11158931, 553), + (11159484, 560), + (11160044, 618), + (11160662, 554), + (11161216, 562), + (11161778, 618), + (11162396, 552), + (11162948, 561), + (11163509, 585), + (11164094, 553), + (11164647, 560), + (11165207, 598), + (11165805, 553), + (11166358, 560), + (11166918, 599), + (11167517, 553), + (11168070, 560), + (11168630, 601), + (11169231, 552), + (11169783, 561), + (11170344, 612), + (11170956, 553), + (11171509, 562), + (11172071, 612), + (11172683, 553), + (11173236, 562), + (11173798, 607), + (11174405, 554), + (11174959, 561), + (11175520, 618), + (11176138, 553), + (11176691, 562), + (11177253, 619), + (11177872, 553), + (11178425, 561), + (11178986, 575), + (11179561, 554), + (11180115, 561), + (11180676, 589), + (11181265, 552), + (11181817, 561), + (11182378, 590), + (11182968, 554), + (11183522, 562), + (11184084, 590), + (11184674, 553), + (11185227, 560), + (11185787, 601), + (11186388, 554), + (11186942, 562), + (11187504, 603), + (11188107, 553), + (11188660, 561), + (11189221, 596), + (11189817, 554), + (11190371, 561), + (11190932, 609), + (11191541, 553), + (11192094, 561), + (11192655, 608), + (11193263, 553), + (11193816, 562), + (11194378, 586), + (11194964, 553), + (11195517, 561), + (11196078, 601), + (11196679, 554), + (11197233, 562), + (11197795, 600), + (11198395, 553), + (11198948, 561), + (11199509, 601), + (11200110, 553), + (11200663, 561), + (11201224, 614), + (11201838, 554), + (11202392, 561), + (11202953, 615), + (11203568, 552), + (11204120, 560), + (11204680, 607), + (11205287, 554), + (11205841, 560), + (11206401, 620), + (11207021, 554), + (11207575, 561), + (11208136, 621), + (11208757, 553), + (11209310, 562), + (11209872, 586), + (11210458, 552), + (11211010, 562), + (11211572, 601), + (11212173, 554), + (11212727, 562), + (11213289, 601), + (11213890, 552), + (11214442, 561), + (11215003, 601), + (11215604, 553), + (11216157, 561), + (11216718, 615), + (11217333, 553), + (11217886, 561), + (11218447, 615), + (11219062, 552), + (11219614, 561), + (11220175, 608), + (11220783, 553), + (11221336, 562), + (11221898, 619), + (11222517, 553), + (11223070, 561), + (11223631, 619), + (11224250, 554), + (11224804, 567), + (11225371, 542), + (11225913, 553), + (11226466, 567), + (11227033, 571), + (11227604, 554), + (11228158, 567), + (11228725, 571), + (11229296, 552), + (11229848, 567), + (11230415, 573), + (11230988, 553), + (11231541, 568), + (11232109, 585), + (11232694, 554), + (11233248, 567), + (11233815, 585), + (11234400, 553), + (11234953, 567), + (11235520, 578), + (11236098, 554), + (11236652, 567), + (11237219, 590), + (11237809, 553), + (11238362, 566), + (11238928, 592), + (11239520, 554), + (11240074, 568), + (11240642, 571), + (11241213, 553), + (11241766, 566), + (11242332, 587), + (11242919, 553), + (11243472, 567), + (11244039, 587), + (11244626, 552), + (11245178, 567), + (11245745, 588), + (11246333, 554), + (11246887, 566), + (11247453, 598), + (11248051, 552), + (11248603, 567), + (11249170, 599), + (11249769, 553), + (11250322, 567), + (11250889, 593), + (11251482, 553), + (11252035, 567), + (11252602, 604), + (11253206, 553), + (11253759, 568), + (11254327, 604), + (11254931, 553), + (11255484, 568), + (11256052, 569), + (11256621, 552), + (11257173, 568), + (11257741, 585), + (11258326, 552), + (11258878, 567), + (11259445, 585), + (11260030, 552), + (11260582, 567), + (11261149, 587), + (11261736, 554), + (11262290, 567), + (11262857, 599), + (11263456, 554), + (11264010, 567), + (11264577, 600), + (11265177, 553), + (11265730, 566), + (11266296, 592), + (11266888, 553), + (11267441, 568), + (11268009, 605), + (11268614, 554), + (11269168, 566), + (11269734, 606), + (11270340, 554), + (11270894, 567), + (11271461, 572), + (11272033, 552), + (11272585, 566), + (11273151, 587), + (11273738, 553), + (11274291, 568), + (11274859, 588), + (11275447, 554), + (11276001, 567), + (11276568, 589), + (11277157, 553), + (11277710, 567), + (11278277, 601), + (11278878, 553), + (11279431, 567), + (11279998, 600), + (11280598, 553), + (11281151, 568), + (11281719, 594), + (11282313, 554), + (11282867, 568), + (11283435, 607), + (11284042, 553), + (11284595, 567), + (11285162, 607), + (11285769, 553), + (11286322, 568), + (11286890, 586), + (11287476, 553), + (11288029, 568), + (11288597, 599), + (11289196, 554), + (11289750, 567), + (11290317, 598), + (11290915, 552), + (11291467, 567), + (11292034, 600), + (11292634, 553), + (11293187, 567), + (11293754, 612), + (11294366, 554), + (11294920, 567), + (11295487, 612), + (11296099, 553), + (11296652, 567), + (11297219, 605), + (11297824, 552), + (11298376, 566), + (11298942, 617), + (11299559, 552), + (11300111, 567), + (11300678, 619), + (11301297, 552), + (11301849, 568), + (11302417, 586), + (11303003, 554), + (11303557, 567), + (11304124, 599), + (11304723, 552), + (11305275, 567), + (11305842, 598), + (11306440, 553), + (11306993, 568), + (11307561, 600), + (11308161, 553), + (11308714, 566), + (11309280, 611), + (11309891, 554), + (11310445, 568), + (11311013, 612), + (11311625, 553), + (11312178, 567), + (11312745, 607), + (11313352, 553), + (11313905, 567), + (11314472, 618), + (11315090, 553), + (11315643, 566), + (11316209, 618), + (11316827, 552), + (11317379, 568), + (11317947, 575), + (11318522, 553), + (11319075, 567), + (11319642, 589), + (11320231, 553), + (11320784, 566), + (11321350, 589), + (11321939, 554), + (11322493, 568), + (11323061, 589), + (11323650, 553), + (11324203, 567), + (11324770, 602), + (11325372, 552), + (11325924, 567), + (11326491, 602), + (11327093, 554), + (11327647, 568), + (11328215, 596), + (11328811, 553), + (11329364, 566), + (11329930, 609), + (11330539, 552), + (11331091, 567), + (11331658, 608), + (11332266, 553), + (11332819, 567), + (11333386, 587), + (11333973, 553), + (11334526, 567), + (11335093, 602), + (11335695, 554), + (11336249, 567), + (11336816, 602), + (11337418, 554), + (11337972, 567), + (11338539, 603), + (11339142, 554), + (11339696, 566), + (11340262, 614), + (11340876, 554), + (11341430, 567), + (11341997, 613), + (11342610, 553), + (11343163, 567), + (11343730, 609), + (11344339, 553), + (11344892, 567), + (11345459, 620), + (11346079, 552), + (11346631, 567), + (11347198, 619), + (11347817, 552), + (11348369, 567), + (11348936, 587), + (11349523, 552), + (11350075, 567), + (11350642, 601), + (11351243, 554), + (11351797, 566), + (11352363, 601), + (11352964, 553), + (11353517, 567), + (11354084, 602), + (11354686, 552), + (11355238, 567), + (11355805, 613), + (11356418, 554), + (11356972, 566), + (11357538, 614), + (11358152, 553), + (11358705, 568), + (11359273, 609), + (11359882, 552), + (11360434, 567), + (11361001, 621), + (11361622, 553), + (11362175, 568), + (11362743, 620), + (11363363, 554), + (11363917, 568), + (11364485, 543), + (11365028, 553), + (11365581, 568), + (11366149, 569), + (11366718, 553), + (11367271, 568), + (11367839, 570), + (11368409, 554), + (11368963, 568), + (11369531, 573), + (11370104, 553), + (11370657, 567), + (11371224, 586), + (11371810, 552), + (11372362, 567), + (11372929, 585), + (11373514, 553), + (11374067, 567), + (11374634, 580), + (11375214, 553), + (11375767, 566), + (11376333, 590), + (11376923, 552), + (11377475, 566), + (11378041, 590), + (11378631, 554), + (11379185, 567), + (11379752, 570), + (11380322, 553), + (11380875, 566), + (11381441, 586), + (11382027, 553), + (11382580, 567), + (11383147, 586), + (11383733, 553), + (11384286, 566), + (11384852, 588), + (11385440, 553), + (11385993, 567), + (11386560, 598), + (11387158, 553), + (11387711, 566), + (11388277, 599), + (11388876, 552), + (11389428, 566), + (11389994, 594), + (11390588, 552), + (11391140, 568), + (11391708, 604), + (11392312, 553), + (11392865, 567), + (11393432, 606), + (11394038, 552), + (11394590, 567), + (11395157, 569), + (11395726, 553), + (11396279, 567), + (11396846, 586), + (11397432, 552), + (11397984, 567), + (11398551, 585), + (11399136, 553), + (11399689, 567), + (11400256, 587), + (11400843, 553), + (11401396, 567), + (11401963, 598), + (11402561, 553), + (11403114, 567), + (11403681, 598), + (11404279, 552), + (11404831, 566), + (11405397, 592), + (11405989, 553), + (11406542, 567), + (11407109, 606), + (11407715, 554), + (11408269, 568), + (11408837, 605), + (11409442, 554), + (11409996, 568), + (11410564, 572), + (11411136, 554), + (11411690, 567), + (11412257, 587), + (11412844, 552), + (11413396, 566), + (11413962, 588), + (11414550, 552), + (11415102, 567), + (11415669, 589), + (11416258, 552), + (11416810, 566), + (11417376, 600), + (11417976, 554), + (11418530, 567), + (11419097, 601), + (11419698, 554), + (11420252, 568), + (11420820, 595), + (11421415, 553), + (11421968, 568), + (11422536, 606), + (11423142, 553), + (11423695, 568), + (11424263, 606), + (11424869, 553), + (11425422, 567), + (11425989, 585), + (11426574, 553), + (11427127, 567), + (11427694, 600), + (11428294, 552), + (11428846, 568), + (11429414, 600), + (11430014, 554), + (11430568, 567), + (11431135, 599), + (11431734, 552), + (11432286, 568), + (11432854, 612), + (11433466, 553), + (11434019, 567), + (11434586, 613), + (11435199, 554), + (11435753, 566), + (11436319, 606), + (11436925, 552), + (11437477, 567), + (11438044, 617), + (11438661, 554), + (11439215, 567), + (11439782, 617), + (11440399, 554), + (11440953, 568), + (11441521, 585), + (11442106, 552), + (11442658, 568), + (11443226, 599), + (11443825, 552), + (11444377, 567), + (11444944, 599), + (11445543, 552), + (11446095, 567), + (11446662, 600), + (11447262, 553), + (11447815, 567), + (11448382, 612), + (11448994, 551), + (11449545, 568), + (11450113, 613), + (11450726, 554), + (11451280, 566), + (11451846, 607), + (11452453, 552), + (11453005, 566), + (11453571, 619), + (11454190, 553), + (11454743, 567), + (11455310, 617), + (11455927, 553), + (11456480, 566), + (11457046, 574), + (11457620, 554), + (11458174, 568), + (11458742, 589), + (11459331, 554), + (11459885, 568), + (11460453, 589), + (11461042, 554), + (11461596, 566), + (11462162, 590), + (11462752, 552), + (11463304, 568), + (11463872, 601), + (11464473, 554), + (11465027, 567), + (11465594, 602), + (11466196, 552), + (11466748, 567), + (11467315, 596), + (11467911, 552), + (11468463, 566), + (11469029, 609), + (11469638, 553), + (11470191, 567), + (11470758, 607), + (11471365, 553), + (11471918, 566), + (11472484, 587), + (11473071, 552), + (11473623, 568), + (11474191, 601), + (11474792, 553), + (11475345, 567), + (11475912, 602), + (11476514, 553), + (11477067, 567), + (11477634, 602), + (11478236, 553), + (11478789, 567), + (11479356, 613), + (11479969, 553), + (11480522, 568), + (11481090, 615), + (11481705, 554), + (11482259, 568), + (11482827, 608), + (11483435, 553), + (11483988, 567), + (11484555, 620), + (11485175, 554), + (11485729, 566), + (11486295, 620), + (11486915, 554), + (11487469, 567), + (11488036, 587), + (11488623, 553), + (11489176, 568), + (11489744, 601), + (11490345, 552), + (11490897, 566), + (11491463, 601), + (11492064, 552), + (11492616, 568), + (11493184, 601), + (11493785, 554), + (11494339, 567), + (11494906, 614), + (11495520, 553), + (11496073, 567), + (11496640, 614), + (11497254, 552), + (11497806, 566), + (11498372, 607), + (11498979, 553), + (11499532, 568), + (11500100, 621), + (11500721, 554), + (11501275, 568), + (11501843, 620), + (11502463, 553), + (11503016, 563), + (11503579, 543), + (11504122, 553), + (11504675, 562), + (11505237, 570), + (11505807, 554), + (11506361, 563), + (11506924, 570), + (11507494, 553), + (11508047, 562), + (11508609, 573), + (11509182, 553), + (11509735, 561), + (11510296, 586), + (11510882, 554), + (11511436, 563), + (11511999, 585), + (11512584, 552), + (11513136, 562), + (11513698, 579), + (11514277, 553), + (11514830, 562), + (11515392, 591), + (11515983, 553), + (11516536, 563), + (11517099, 591), + (11517690, 552), + (11518242, 563), + (11518805, 570), + (11519375, 553), + (11519928, 563), + (11520491, 586), + (11521077, 553), + (11521630, 562), + (11522192, 587), + (11522779, 553), + (11523332, 561), + (11523893, 588), + (11524481, 552), + (11525033, 562), + (11525595, 599), + (11526194, 553), + (11526747, 562), + (11527309, 599), + (11527908, 553), + (11528461, 562), + (11529023, 593), + (11529616, 553), + (11530169, 563), + (11530732, 604), + (11531336, 553), + (11531889, 561), + (11532450, 606), + (11533056, 554), + (11533610, 561), + (11534171, 569), + (11534740, 554), + (11535294, 563), + (11535857, 586), + (11536443, 553), + (11536996, 563), + (11537559, 586), + (11538145, 554), + (11538699, 563), + (11539262, 586), + (11539848, 554), + (11540402, 563), + (11540965, 599), + (11541564, 552), + (11542116, 561), + (11542677, 599), + (11543276, 554), + (11543830, 562), + (11544392, 594), + (11544986, 553), + (11545539, 563), + (11546102, 605), + (11546707, 554), + (11547261, 563), + (11547824, 606), + (11548430, 553), + (11548983, 561), + (11549544, 573), + (11550117, 554), + (11550671, 561), + (11551232, 588), + (11551820, 553), + (11552373, 562), + (11552935, 588), + (11553523, 553), + (11554076, 562), + (11554638, 589), + (11555227, 552), + (11555779, 561), + (11556340, 601), + (11556941, 553), + (11557494, 562), + (11558056, 599), + (11558655, 553), + (11559208, 562), + (11559770, 593), + (11560363, 554), + (11560917, 563), + (11561480, 605), + (11562085, 553), + (11562638, 562), + (11563200, 606), + (11563806, 552), + (11564358, 562), + (11564920, 585), + (11565505, 553), + (11566058, 561), + (11566619, 599), + (11567218, 554), + (11567772, 563), + (11568335, 598), + (11568933, 553), + (11569486, 563), + (11570049, 599), + (11570648, 553), + (11571201, 563), + (11571764, 612), + (11572376, 553), + (11572929, 563), + (11573492, 613), + (11574105, 552), + (11574657, 562), + (11575219, 605), + (11575824, 553), + (11576377, 562), + (11576939, 618), + (11577557, 552), + (11578109, 562), + (11578671, 617), + (11579288, 554), + (11579842, 561), + (11580403, 586), + (11580989, 553), + (11581542, 563), + (11582105, 598), + (11582703, 553), + (11583256, 562), + (11583818, 600), + (11584418, 553), + (11584971, 561), + (11585532, 600), + (11586132, 553), + (11586685, 563), + (11587248, 612), + (11587860, 553), + (11588413, 562), + (11588975, 611), + (11589586, 553), + (11590139, 562), + (11590701, 605), + (11591306, 552), + (11591858, 562), + (11592420, 618), + (11593038, 552), + (11593590, 563), + (11594153, 619), + (11594772, 553), + (11595325, 562), + (11595887, 575), + (11596462, 554), + (11597016, 561), + (11597577, 590), + (11598167, 553), + (11598720, 561), + (11599281, 589), + (11599870, 553), + (11600423, 562), + (11600985, 590), + (11601575, 553), + (11602128, 563), + (11602691, 603), + (11603294, 554), + (11603848, 563), + (11604411, 603), + (11605014, 554), + (11605568, 563), + (11606131, 596), + (11606727, 552), + (11607279, 561), + (11607840, 608), + (11608448, 553), + (11609001, 563), + (11609564, 608), + (11610172, 554), + (11610726, 563), + (11611289, 587), + (11611876, 553), + (11612429, 562), + (11612991, 600), + (11613591, 554), + (11614145, 562), + (11614707, 601), + (11615308, 554), + (11615862, 561), + (11616423, 601), + (11617024, 554), + (11617578, 561), + (11618139, 615), + (11618754, 554), + (11619308, 561), + (11619869, 614), + (11620483, 554), + (11621037, 561), + (11621598, 608), + (11622206, 552), + (11622758, 562), + (11623320, 620), + (11623940, 553), + (11624493, 562), + (11625055, 621), + (11625676, 553), + (11626229, 561), + (11626790, 588), + (11627378, 552), + (11627930, 562), + (11628492, 600), + (11629092, 554), + (11629646, 563), + (11630209, 600), + (11630809, 554), + (11631363, 562), + (11631925, 602), + (11632527, 552), + (11633079, 562), + (11633641, 614), + (11634255, 553), + (11634808, 562), + (11635370, 614), + (11635984, 554), + (11636538, 562), + (11637100, 607), + (11637707, 553), + (11638260, 562), + (11638822, 619), + (11639441, 554), + (11639995, 563), + (11640558, 621), + (11641179, 554), + (11641733, 567), + (11642300, 542), + (11642842, 554), + (11643396, 568), + (11643964, 569), + (11644533, 554), + (11645087, 568), + (11645655, 570), + (11646225, 554), + (11646779, 569), + (11647348, 571), + (11647919, 553), + (11648472, 569), + (11649041, 584), + (11649625, 554), + (11650179, 568), + (11650747, 586), + (11651333, 554), + (11651887, 569), + (11652456, 580), + (11653036, 553), + (11653589, 569), + (11654158, 591), + (11654749, 553), + (11655302, 567), + (11655869, 592), + (11656461, 553), + (11657014, 569), + (11657583, 571), + (11658154, 553), + (11658707, 569), + (11659276, 587), + (11659863, 553), + (11660416, 569), + (11660985, 586), + (11661571, 553), + (11662124, 567), + (11662691, 588), + (11663279, 554), + (11663833, 568), + (11664401, 599), + (11665000, 552), + (11665552, 569), + (11666121, 599), + (11666720, 554), + (11667274, 567), + (11667841, 593), + (11668434, 553), + (11668987, 567), + (11669554, 603), + (11670157, 553), + (11670710, 569), + (11671279, 604), + (11671883, 553), + (11672436, 567), + (11673003, 570), + (11673573, 552), + (11674125, 567), + (11674692, 587), + (11675279, 554), + (11675833, 569), + (11676402, 585), + (11676987, 552), + (11677539, 569), + (11678108, 587), + (11678695, 553), + (11679248, 569), + (11679817, 598), + (11680415, 553), + (11680968, 567), + (11681535, 598), + (11682133, 552), + (11682685, 568), + (11683253, 594), + (11683847, 553), + (11684400, 568), + (11684968, 605), + (11685573, 554), + (11686127, 568), + (11686695, 605), + (11687300, 553), + (11687853, 568), + (11688421, 572), + (11688993, 553), + (11689546, 569), + (11690115, 587), + (11690702, 553), + (11691255, 569), + (11691824, 587), + (11692411, 553), + (11692964, 568), + (11693532, 588), + (11694120, 553), + (11694673, 569), + (11695242, 600), + (11695842, 553), + (11696395, 568), + (11696963, 600), + (11697563, 554), + (11698117, 567), + (11698684, 594), + (11699278, 553), + (11699831, 568), + (11700399, 606), + (11701005, 553), + (11701558, 569), + (11702127, 607), + (11702734, 553), + (11703287, 569), + (11703856, 584), + (11704440, 553), + (11704993, 568), + (11705561, 598), + (11706159, 553), + (11706712, 567), + (11707279, 600), + (11707879, 552), + (11708431, 569), + (11709000, 601), + (11709601, 552), + (11710153, 569), + (11710722, 612), + (11711334, 552), + (11711886, 569), + (11712455, 613), + (11713068, 554), + (11713622, 568), + (11714190, 605), + (11714795, 553), + (11715348, 568), + (11715916, 617), + (11716533, 553), + (11717086, 568), + (11717654, 618), + (11718272, 553), + (11718825, 567), + (11719392, 586), + (11719978, 554), + (11720532, 568), + (11721100, 600), + (11721700, 554), + (11722254, 568), + (11722822, 599), + (11723421, 553), + (11723974, 567), + (11724541, 599), + (11725140, 552), + (11725692, 569), + (11726261, 612), + (11726873, 553), + (11727426, 569), + (11727995, 613), + (11728608, 554), + (11729162, 569), + (11729731, 606), + (11730337, 553), + (11730890, 567), + (11731457, 618), + (11732075, 554), + (11732629, 569), + (11733198, 618), + (11733816, 553), + (11734369, 568), + (11734937, 575), + (11735512, 553), + (11736065, 567), + (11736632, 589), + (11737221, 552), + (11737773, 568), + (11738341, 589), + (11738930, 552), + (11739482, 568), + (11740050, 590), + (11740640, 553), + (11741193, 567), + (11741760, 602), + (11742362, 554), + (11742916, 567), + (11743483, 603), + (11744086, 553), + (11744639, 568), + (11745207, 596), + (11745803, 553), + (11746356, 568), + (11746924, 609), + (11747533, 553), + (11748086, 567), + (11748653, 607), + (11749260, 552), + (11749812, 569), + (11750381, 587), + (11750968, 554), + (11751522, 568), + (11752090, 601), + (11752691, 552), + (11753243, 567), + (11753810, 602), + (11754412, 552), + (11754964, 568), + (11755532, 602), + (11756134, 554), + (11756688, 568), + (11757256, 615), + (11757871, 552), + (11758423, 569), + (11758992, 613), + (11759605, 553), + (11760158, 567), + (11760725, 607), + (11761332, 553), + (11761885, 569), + (11762454, 620), + (11763074, 552), + (11763626, 569), + (11764195, 619), + (11764814, 553), + (11765367, 568), + (11765935, 587), + (11766522, 553), + (11767075, 569), + (11767644, 601), + (11768245, 552), + (11768797, 569), + (11769366, 601), + (11769967, 552), + (11770519, 567), + (11771086, 603), + (11771689, 552), + (11772241, 569), + (11772810, 615), + (11773425, 553), + (11773978, 569), + (11774547, 614), + (11775161, 554), + (11775715, 567), + (11776282, 608), + (11776890, 553), + (11777443, 568), + (11778011, 620), + (11778631, 554), + (11779185, 569), + (11779754, 619), + (11780373, 553), + (11780926, 568), + (11781494, 542), + (11782036, 553), + (11782589, 569), + (11783158, 571), + (11783729, 553), + (11784282, 569), + (11784851, 570), + (11785421, 553), + (11785974, 568), + (11786542, 571), + (11787113, 553), + (11787666, 567), + (11788233, 585), + (11788818, 554), + (11789372, 568), + (11789940, 584), + (11790524, 554), + (11791078, 568), + (11791646, 579), + (11792225, 553), + (11792778, 568), + (11793346, 591), + (11793937, 554), + (11794491, 567), + (11795058, 590), + (11795648, 552), + (11796200, 567), + (11796767, 569), + (11797336, 552), + (11797888, 569), + (11798457, 585), + (11799042, 552), + (11799594, 568), + (11800162, 586), + (11800748, 553), + (11801301, 568), + (11801869, 587), + (11802456, 553), + (11803009, 568), + (11803577, 600), + (11804177, 554), + (11804731, 569), + (11805300, 598), + (11805898, 552), + (11806450, 568), + (11807018, 592), + (11807610, 554), + (11808164, 568), + (11808732, 606), + (11809338, 552), + (11809890, 568), + (11810458, 606), + (11811064, 552), + (11811616, 569), + (11812185, 570), + (11812755, 554), + (11813309, 569), + (11813878, 587), + (11814465, 552), + (11815017, 567), + (11815584, 587), + (11816171, 552), + (11816723, 568), + (11817291, 587), + (11817878, 553), + (11818431, 567), + (11818998, 598), + (11819596, 553), + (11820149, 569), + (11820718, 600), + (11821318, 554), + (11821872, 569), + (11822441, 593), + (11823034, 554), + (11823588, 568), + (11824156, 605), + (11824761, 553), + (11825314, 567), + (11825881, 606), + (11826487, 553), + (11827040, 567), + (11827607, 571), + (11828178, 552), + (11828730, 569), + (11829299, 586), + (11829885, 552), + (11830437, 567), + (11831004, 588), + (11831592, 553), + (11832145, 568), + (11832713, 588), + (11833301, 554), + (11833855, 568), + (11834423, 599), + (11835022, 553), + (11835575, 569), + (11836144, 599), + (11836743, 553), + (11837296, 567), + (11837863, 595), + (11838458, 552), + (11839010, 567), + (11839577, 607), + (11840184, 553), + (11840737, 567), + (11841304, 606), + (11841910, 553), + (11842463, 569), + (11843032, 586), + (11843618, 554), + (11844172, 568), + (11844740, 599), + (11845339, 552), + (11845891, 567), + (11846458, 599), + (11847057, 553), + (11847610, 568), + (11848178, 599), + (11848777, 552), + (11849329, 567), + (11849896, 611), + (11850507, 553), + (11851060, 568), + (11851628, 612), + (11852240, 554), + (11852794, 568), + (11853362, 606), + (11853968, 553), + (11854521, 567), + (11855088, 617), + (11855705, 553), + (11856258, 568), + (11856826, 617), + (11857443, 554), + (11857997, 569), + (11858566, 585), + (11859151, 553), + (11859704, 568), + (11860272, 600), + (11860872, 552), + (11861424, 568), + (11861992, 599), + (11862591, 554), + (11863145, 568), + (11863713, 600), + (11864313, 552), + (11864865, 569), + (11865434, 613), + (11866047, 552), + (11866599, 569), + (11867168, 611), + (11867779, 552), + (11868331, 567), + (11868898, 607), + (11869505, 553), + (11870058, 568), + (11870626, 617), + (11871243, 553), + (11871796, 568), + (11872364, 618), + (11872982, 554), + (11873536, 569), + (11874105, 574), + (11874679, 553), + (11875232, 569), + (11875801, 588), + (11876389, 553), + (11876942, 569), + (11877511, 589), + (11878100, 553), + (11878653, 569), + (11879222, 589), + (11879811, 552), + (11880363, 569), + (11880932, 602), + (11881534, 553), + (11882087, 568), + (11882655, 601), + (11883256, 553), + (11883809, 568), + (11884377, 595), + (11884972, 553), + (11885525, 568), + (11886093, 608), + (11886701, 552), + (11887253, 568), + (11887821, 608), + (11888429, 552), + (11888981, 567), + (11889548, 587), + (11890135, 553), + (11890688, 568), + (11891256, 601), + (11891857, 554), + (11892411, 567), + (11892978, 601), + (11893579, 554), + (11894133, 567), + (11894700, 602), + (11895302, 553), + (11895855, 568), + (11896423, 615), + (11897038, 552), + (11897590, 569), + (11898159, 615), + (11898774, 553), + (11899327, 567), + (11899894, 609), + (11900503, 553), + (11901056, 568), + (11901624, 619), + (11902243, 552), + (11902795, 568), + (11903363, 620), + (11903983, 553), + (11904536, 568), + (11905104, 588), + (11905692, 553), + (11906245, 568), + (11906813, 602), + (11907415, 554), + (11907969, 568), + (11908537, 600), + (11909137, 554), + (11909691, 567), + (11910258, 603), + (11910861, 553), + (11911414, 568), + (11911982, 613), + (11912595, 554), + (11913149, 568), + (11913717, 614), + (11914331, 554), + (11914885, 568), + (11915453, 608), + (11916061, 553), + (11916614, 568), + (11917182, 620), + (11917802, 553), + (11918355, 568), + (11918923, 620), + (11919543, 553), + (11920096, 507), + (11920603, 542), + (11921145, 554), + (11921699, 508), + (11922207, 569), + (11922776, 552), + (11923328, 507), + (11923835, 570), + (11924405, 553), + (11924958, 508), + (11925466, 572), + (11926038, 553), + (11926591, 508), + (11927099, 584), + (11927683, 552), + (11928235, 508), + (11928743, 585), + (11929328, 553), + (11929881, 507), + (11930388, 578), + (11930966, 553), + (11931519, 509), + (11932028, 592), + (11932620, 552), + (11933172, 508), + (11933680, 590), + (11934270, 554), + (11934824, 507), + (11935331, 570), + (11935901, 553), + (11936454, 508), + (11936962, 585), + (11937547, 553), + (11938100, 507), + (11938607, 586), + (11939193, 554), + (11939747, 508), + (11940255, 588), + (11940843, 553), + (11941396, 509), + (11941905, 598), + (11942503, 553), + (11943056, 509), + (11943565, 598), + (11944163, 553), + (11944716, 509), + (11945225, 593), + (11945818, 552), + (11946370, 507), + (11946877, 606), + (11947483, 553), + (11948036, 508), + (11948544, 605), + (11949149, 552), + (11949701, 507), + (11950208, 569), + (11950777, 553), + (11951330, 508), + (11951838, 587), + (11952425, 554), + (11952979, 508), + (11953487, 587), + (11954074, 553), + (11954627, 508), + (11955135, 588), + (11955723, 552), + (11956275, 508), + (11956783, 598), + (11957381, 553), + (11957934, 509), + (11958443, 599), + (11959042, 552), + (11959594, 507), + (11960101, 592), + (11960693, 552), + (11961245, 508), + (11961753, 605), + (11962358, 553), + (11962911, 509), + (11963420, 606), + (11964026, 553), + (11964579, 507), + (11965086, 573), + (11965659, 553), + (11966212, 507), + (11966719, 587), + (11967306, 552), + (11967858, 507), + (11968365, 586), + (11968951, 552), + (11969503, 508), + (11970011, 587), + (11970598, 554), + (11971152, 508), + (11971660, 600), + (11972260, 553), + (11972813, 508), + (11973321, 599), + (11973920, 553), + (11974473, 508), + (11974981, 594), + (11975575, 554), + (11976129, 507), + (11976636, 607), + (11977243, 553), + (11977796, 509), + (11978305, 605), + (11978910, 552), + (11979462, 508), + (11979970, 585), + (11980555, 554), + (11981109, 508), + (11981617, 600), + (11982217, 553), + (11982770, 508), + (11983278, 599), + (11983877, 552), + (11984429, 508), + (11984937, 600), + (11985537, 553), + (11986090, 508), + (11986598, 611), + (11987209, 552), + (11987761, 509), + (11988270, 612), + (11988882, 552), + (11989434, 508), + (11989942, 607), + (11990549, 553), + (11991102, 507), + (11991609, 618), + (11992227, 552), + (11992779, 507), + (11993286, 618), + (11993904, 553), + (11994457, 507), + (11994964, 585), + (11995549, 554), + (11996103, 508), + (11996611, 600), + (11997211, 553), + (11997764, 508), + (11998272, 599), + (11998871, 553), + (11999424, 509), + (11999933, 601), + (12000534, 554), + (12001088, 507), + (12001595, 611), + (12002206, 552), + (12002758, 507), + (12003265, 612), + (12003877, 553), + (12004430, 509), + (12004939, 606), + (12005545, 553), + (12006098, 508), + (12006606, 619), + (12007225, 553), + (12007778, 508), + (12008286, 619), + (12008905, 552), + (12009457, 508), + (12009965, 575), + (12010540, 553), + (12011093, 507), + (12011600, 589), + (12012189, 553), + (12012742, 508), + (12013250, 588), + (12013838, 552), + (12014390, 509), + (12014899, 590), + (12015489, 553), + (12016042, 509), + (12016551, 602), + (12017153, 552), + (12017705, 509), + (12018214, 603), + (12018817, 553), + (12019370, 507), + (12019877, 596), + (12020473, 554), + (12021027, 509), + (12021536, 606), + (12022142, 554), + (12022696, 507), + (12023203, 608), + (12023811, 553), + (12024364, 508), + (12024872, 587), + (12025459, 553), + (12026012, 508), + (12026520, 601), + (12027121, 553), + (12027674, 509), + (12028183, 600), + (12028783, 552), + (12029335, 507), + (12029842, 602), + (12030444, 552), + (12030996, 508), + (12031504, 614), + (12032118, 553), + (12032671, 508), + (12033179, 614), + (12033793, 554), + (12034347, 508), + (12034855, 608), + (12035463, 554), + (12036017, 508), + (12036525, 619), + (12037144, 553), + (12037697, 508), + (12038205, 619), + (12038824, 552), + (12039376, 508), + (12039884, 586), + (12040470, 554), + (12041024, 509), + (12041533, 602), + (12042135, 553), + (12042688, 509), + (12043197, 601), + (12043798, 552), + (12044350, 507), + (12044857, 602), + (12045459, 553), + (12046012, 509), + (12046521, 614), + (12047135, 552), + (12047687, 508), + (12048195, 614), + (12048809, 553), + (12049362, 508), + (12049870, 607), + (12050477, 553), + (12051030, 507), + (12051537, 620), + (12052157, 553), + (12052710, 507), + (12053217, 621), + (12053838, 553), + (12054391, 524), + (12054915, 542), + (12055457, 553), + (12056010, 525), + (12056535, 571), + (12057106, 552), + (12057658, 526), + (12058184, 570), + (12058754, 553), + (12059307, 524), + (12059831, 572), + (12060403, 553), + (12060956, 525), + (12061481, 586), + (12062067, 552), + (12062619, 526), + (12063145, 585), + (12063730, 553), + (12064283, 524), + (12064807, 580), + (12065387, 554), + (12065941, 525), + (12066466, 590), + (12067056, 553), + (12067609, 526), + (12068135, 591), + (12068726, 553), + (12069279, 525), + (12069804, 569), + (12070373, 553), + (12070926, 525), + (12071451, 586), + (12072037, 554), + (12072591, 525), + (12073116, 586), + (12073702, 552), + (12074254, 525), + (12074779, 587), + (12075366, 553), + (12075919, 524), + (12076443, 599), + (12077042, 553), + (12077595, 524), + (12078119, 599), + (12078718, 554), + (12079272, 524), + (12079796, 594), + (12080390, 552), + (12080942, 525), + (12081467, 605), + (12082072, 553), + (12082625, 525), + (12083150, 605), + (12083755, 553), + (12084308, 524), + (12084832, 570), + (12085402, 553), + (12085955, 526), + (12086481, 585), + (12087066, 553), + (12087619, 525), + (12088144, 586), + (12088730, 553), + (12089283, 524), + (12089807, 587), + (12090394, 553), + (12090947, 525), + (12091472, 598), + (12092070, 553), + (12092623, 525), + (12093148, 598), + (12093746, 553), + (12094299, 523), + (12094822, 592), + (12095414, 553), + (12095967, 525), + (12096492, 605), + (12097097, 552), + (12097649, 525), + (12098174, 604), + (12098778, 553), + (12099331, 524), + (12099855, 571), + (12100426, 554), + (12100980, 524), + (12101504, 587), + (12102091, 553), + (12102644, 526), + (12103170, 586), + (12103756, 552), + (12104308, 526), + (12104834, 588), + (12105422, 553), + (12105975, 526), + (12106501, 601), + (12107102, 552), + (12107654, 526), + (12108180, 600), + (12108780, 554), + (12109334, 525), + (12109859, 594), + (12110453, 553), + (12111006, 525), + (12111531, 607), + (12112138, 553), + (12112691, 525), + (12113216, 605), + (12113821, 554), + (12114375, 525), + (12114900, 585), + (12115485, 552), + (12116037, 524), + (12116561, 600), + (12117161, 552), + (12117713, 526), + (12118239, 599), + (12118838, 553), + (12119391, 524), + (12119915, 600), + (12120515, 553), + (12121068, 525), + (12121593, 613), + (12122206, 552), + (12122758, 525), + (12123283, 613), + (12123896, 554), + (12124450, 526), + (12124976, 606), + (12125582, 554), + (12126136, 525), + (12126661, 617), + (12127278, 554), + (12127832, 524), + (12128356, 618), + (12128974, 553), + (12129527, 524), + (12130051, 586), + (12130637, 552), + (12131189, 525), + (12131714, 598), + (12132312, 552), + (12132864, 524), + (12133388, 599), + (12133987, 553), + (12134540, 524), + (12135064, 599), + (12135663, 553), + (12136216, 526), + (12136742, 611), + (12137353, 552), + (12137905, 524), + (12138429, 613), + (12139042, 553), + (12139595, 525), + (12140120, 605), + (12140725, 552), + (12141277, 526), + (12141803, 618), + (12142421, 552), + (12142973, 525), + (12143498, 618), + (12144116, 553), + (12144669, 525), + (12145194, 575), + (12145769, 553), + (12146322, 524), + (12146846, 589), + (12147435, 553), + (12147988, 525), + (12148513, 589), + (12149102, 554), + (12149656, 525), + (12150181, 590), + (12150771, 553), + (12151324, 525), + (12151849, 602), + (12152451, 554), + (12153005, 525), + (12153530, 603), + (12154133, 554), + (12154687, 524), + (12155211, 596), + (12155807, 553), + (12156360, 524), + (12156884, 608), + (12157492, 553), + (12158045, 525), + (12158570, 608), + (12159178, 552), + (12159730, 525), + (12160255, 586), + (12160841, 554), + (12161395, 526), + (12161921, 600), + (12162521, 554), + (12163075, 525), + (12163600, 601), + (12164201, 553), + (12164754, 525), + (12165279, 603), + (12165882, 553), + (12166435, 525), + (12166960, 613), + (12167573, 551), + (12168124, 525), + (12168649, 614), + (12169263, 553), + (12169816, 524), + (12170340, 609), + (12170949, 553), + (12171502, 525), + (12172027, 620), + (12172647, 553), + (12173200, 525), + (12173725, 620), + (12174345, 554), + (12174899, 526), + (12175425, 588), + (12176013, 553), + (12176566, 526), + (12177092, 601), + (12177693, 554), + (12178247, 525), + (12178772, 601), + (12179373, 552), + (12179925, 525), + (12180450, 603), + (12181053, 554), + (12181607, 525), + (12182132, 614), + (12182746, 553), + (12183299, 524), + (12183823, 613), + (12184436, 552), + (12184988, 525), + (12185513, 609), + (12186122, 553), + (12186675, 526), + (12187201, 620), + (12187821, 552), + (12188373, 525), + (12188898, 621), + (12189519, 553), + (12190072, 525), + (12190597, 542), + (12191139, 554), + (12191693, 525), + (12192218, 570), + (12192788, 553), + (12193341, 525), + (12193866, 570), + (12194436, 552), + (12194988, 526), + (12195514, 573), + (12196087, 554), + (12196641, 525), + (12197166, 585), + (12197751, 554), + (12198305, 526), + (12198831, 585), + (12199416, 553), + (12199969, 525), + (12200494, 579), + (12201073, 553), + (12201626, 524), + (12202150, 591), + (12202741, 552), + (12203293, 526), + (12203819, 591), + (12204410, 554), + (12204964, 524), + (12205488, 570), + (12206058, 554), + (12206612, 525), + (12207137, 586), + (12207723, 552), + (12208275, 524), + (12208799, 586), + (12209385, 553), + (12209938, 525), + (12210463, 587), + (12211050, 552), + (12211602, 525), + (12212127, 599), + (12212726, 552), + (12213278, 524), + (12213802, 599), + (12214401, 553), + (12214954, 525), + (12215479, 594), + (12216073, 553), + (12216626, 525), + (12217151, 604), + (12217755, 554), + (12218309, 525), + (12218834, 605), + (12219439, 552), + (12219991, 525), + (12220516, 570), + (12221086, 553), + (12221639, 526), + (12222165, 586), + (12222751, 554), + (12223305, 524), + (12223829, 586), + (12224415, 553), + (12224968, 524), + (12225492, 587), + (12226079, 553), + (12226632, 525), + (12227157, 599), + (12227756, 553), + (12228309, 525), + (12228834, 599), + (12229433, 552), + (12229985, 526), + (12230511, 593), + (12231104, 552), + (12231656, 524), + (12232180, 604), + (12232784, 553), + (12233337, 524), + (12233861, 605), + (12234466, 552), + (12235018, 524), + (12235542, 572), + (12236114, 554), + (12236668, 524), + (12237192, 586), + (12237778, 553), + (12238331, 526), + (12238857, 587), + (12239444, 553), + (12239997, 524), + (12240521, 589), + (12241110, 554), + (12241664, 524), + (12242188, 599), + (12242787, 554), + (12243341, 525), + (12243866, 600), + (12244466, 553), + (12245019, 525), + (12245544, 594), + (12246138, 553), + (12246691, 524), + (12247215, 605), + (12247820, 554), + (12248374, 524), + (12248898, 605), + (12249503, 552), + (12250055, 526), + (12250581, 586), + (12251167, 554), + (12251721, 524), + (12252245, 599), + (12252844, 552), + (12253396, 525), + (12253921, 600), + (12254521, 552), + (12255073, 525), + (12255598, 601), + (12256199, 553), + (12256752, 525), + (12257277, 611), + (12257888, 552), + (12258440, 525), + (12258965, 612), + (12259577, 554), + (12260131, 525), + (12260656, 607), + (12261263, 553), + (12261816, 524), + (12262340, 617), + (12262957, 553), + (12263510, 525), + (12264035, 618), + (12264653, 553), + (12265206, 525), + (12265731, 586), + (12266317, 554), + (12266871, 525), + (12267396, 598), + (12267994, 553), + (12268547, 524), + (12269071, 599), + (12269670, 553), + (12270223, 525), + (12270748, 600), + (12271348, 553), + (12271901, 524), + (12272425, 612), + (12273037, 552), + (12273589, 526), + (12274115, 611), + (12274726, 554), + (12275280, 525), + (12275805, 606), + (12276411, 553), + (12276964, 525), + (12277489, 618), + (12278107, 553), + (12278660, 526), + (12279186, 617), + (12279803, 553), + (12280356, 524), + (12280880, 575), + (12281455, 553), + (12282008, 525), + (12282533, 590), + (12283123, 554), + (12283677, 526), + (12284203, 590), + (12284793, 554), + (12285347, 524), + (12285871, 590), + (12286461, 553), + (12287014, 525), + (12287539, 602), + (12288141, 553), + (12288694, 525), + (12289219, 602), + (12289821, 553), + (12290374, 526), + (12290900, 597), + (12291497, 552), + (12292049, 525), + (12292574, 608), + (12293182, 553), + (12293735, 526), + (12294261, 608), + (12294869, 552), + (12295421, 526), + (12295947, 587), + (12296534, 553), + (12297087, 525), + (12297612, 602), + (12298214, 552), + (12298766, 524), + (12299290, 602), + (12299892, 552), + (12300444, 524), + (12300968, 603), + (12301571, 553), + (12302124, 526), + (12302650, 615), + (12303265, 552), + (12303817, 525), + (12304342, 613), + (12304955, 552), + (12305507, 525), + (12306032, 607), + (12306639, 553), + (12307192, 525), + (12307717, 619), + (12308336, 553), + (12308889, 525), + (12309414, 621), + (12310035, 554), + (12310589, 524), + (12311113, 587), + (12311700, 553), + (12312253, 525), + (12312778, 601), + (12313379, 553), + (12313932, 526), + (12314458, 601), + (12315059, 552), + (12315611, 525), + (12316136, 601), + (12316737, 552), + (12317289, 525), + (12317814, 613), + (12318427, 552), + (12318979, 525), + (12319504, 614), + (12320118, 552), + (12320670, 526), + (12321196, 609), + (12321805, 554), + (12322359, 525), + (12322884, 620), + (12323504, 554), + (12324058, 526), + (12324584, 620), + (12325204, 554), + (12325758, 536), + (12326294, 541), + (12326835, 554), + (12327389, 534), + (12327923, 571), + (12328494, 552), + (12329046, 534), + (12329580, 569), + (12330149, 553), + (12330702, 536), + (12331238, 572), + (12331810, 554), + (12332364, 534), + (12332898, 585), + (12333483, 553), + (12334036, 535), + (12334571, 585), + (12335156, 554), + (12335710, 535), + (12336245, 578), + (12336823, 552), + (12337375, 535), + (12337910, 591), + (12338501, 554), + (12339055, 535), + (12339590, 590), + (12340180, 552), + (12340732, 534), + (12341266, 570), + (12341836, 553), + (12342389, 535), + (12342924, 587), + (12343511, 553), + (12344064, 534), + (12344598, 586), + (12345184, 553), + (12345737, 534), + (12346271, 586), + (12346857, 553), + (12347410, 535), + (12347945, 599), + (12348544, 552), + (12349096, 536), + (12349632, 600), + (12350232, 553), + (12350785, 534), + (12351319, 594), + (12351913, 553), + (12352466, 534), + (12353000, 606), + (12353606, 552), + (12354158, 535), + (12354693, 606), + (12355299, 553), + (12355852, 534), + (12356386, 569), + (12356955, 554), + (12357509, 535), + (12358044, 586), + (12358630, 553), + (12359183, 534), + (12359717, 586), + (12360303, 553), + (12360856, 536), + (12361392, 588), + (12361980, 553), + (12362533, 536), + (12363069, 600), + (12363669, 553), + (12364222, 534), + (12364756, 600), + (12365356, 553), + (12365909, 536), + (12366445, 593), + (12367038, 552), + (12367590, 535), + (12368125, 604), + (12368729, 553), + (12369282, 536), + (12369818, 605), + (12370423, 553), + (12370976, 536), + (12371512, 573), + (12372085, 554), + (12372639, 535), + (12373174, 586), + (12373760, 552), + (12374312, 536), + (12374848, 587), + (12375435, 553), + (12375988, 535), + (12376523, 589), + (12377112, 554), + (12377666, 536), + (12378202, 599), + (12378801, 553), + (12379354, 535), + (12379889, 599), + (12380488, 554), + (12381042, 535), + (12381577, 593), + (12382170, 553), + (12382723, 535), + (12383258, 605), + (12383863, 554), + (12384417, 534), + (12384951, 607), + (12385558, 553), + (12386111, 534), + (12386645, 584), + (12387229, 554), + (12387783, 535), + (12388318, 599), + (12388917, 552), + (12389469, 536), + (12390005, 600), + (12390605, 553), + (12391158, 534), + (12391692, 600), + (12392292, 553), + (12392845, 534), + (12393379, 613), + (12393992, 553), + (12394545, 535), + (12395080, 612), + (12395692, 553), + (12396245, 535), + (12396780, 606), + (12397386, 554), + (12397940, 536), + (12398476, 618), + (12399094, 553), + (12399647, 535), + (12400182, 618), + (12400800, 553), + (12401353, 536), + (12401889, 585), + (12402474, 552), + (12403026, 535), + (12403561, 598), + (12404159, 553), + (12404712, 535), + (12405247, 599), + (12405846, 553), + (12406399, 536), + (12406935, 600), + (12407535, 554), + (12408089, 534), + (12408623, 613), + (12409236, 553), + (12409789, 536), + (12410325, 613), + (12410938, 553), + (12411491, 536), + (12412027, 605), + (12412632, 553), + (12413185, 536), + (12413721, 618), + (12414339, 553), + (12414892, 534), + (12415426, 618), + (12416044, 552), + (12416596, 534), + (12417130, 574), + (12417704, 552), + (12418256, 534), + (12418790, 589), + (12419379, 553), + (12419932, 535), + (12420467, 590), + (12421057, 554), + (12421611, 534), + (12422145, 590), + (12422735, 552), + (12423287, 535), + (12423822, 602), + (12424424, 553), + (12424977, 536), + (12425513, 603), + (12426116, 552), + (12426668, 535), + (12427203, 596), + (12427799, 553), + (12428352, 536), + (12428888, 609), + (12429497, 553), + (12430050, 535), + (12430585, 607), + (12431192, 553), + (12431745, 536), + (12432281, 587), + (12432868, 552), + (12433420, 535), + (12433955, 602), + (12434557, 553), + (12435110, 536), + (12435646, 601), + (12436247, 552), + (12436799, 536), + (12437335, 603), + (12437938, 553), + (12438491, 535), + (12439026, 614), + (12439640, 554), + (12440194, 534), + (12440728, 613), + (12441341, 552), + (12441893, 536), + (12442429, 607), + (12443036, 554), + (12443590, 536), + (12444126, 621), + (12444747, 554), + (12445301, 536), + (12445837, 619), + (12446456, 553), + (12447009, 535), + (12447544, 586), + (12448130, 553), + (12448683, 535), + (12449218, 602), + (12449820, 554), + (12450374, 535), + (12450909, 601), + (12451510, 552), + (12452062, 535), + (12452597, 603), + (12453200, 554), + (12453754, 534), + (12454288, 615), + (12454903, 553), + (12455456, 535), + (12455991, 613), + (12456604, 553), + (12457157, 536), + (12457693, 609), + (12458302, 552), + (12458854, 534), + (12459388, 619), + (12460007, 552), + (12460559, 535), + (12461094, 619), + (12461713, 554), + (12462267, 540), + (12462807, 541), + (12463348, 554), + (12463902, 540), + (12464442, 570), + (12465012, 552), + (12465564, 541), + (12466105, 570), + (12466675, 553), + (12467228, 542), + (12467770, 572), + (12468342, 554), + (12468896, 540), + (12469436, 586), + (12470022, 554), + (12470576, 540), + (12471116, 585), + (12471701, 554), + (12472255, 541), + (12472796, 580), + (12473376, 553), + (12473929, 541), + (12474470, 591), + (12475061, 553), + (12475614, 541), + (12476155, 591), + (12476746, 554), + (12477300, 542), + (12477842, 569), + (12478411, 553), + (12478964, 540), + (12479504, 585), + (12480089, 552), + (12480641, 540), + (12481181, 585), + (12481766, 554), + (12482320, 541), + (12482861, 587), + (12483448, 553), + (12484001, 542), + (12484543, 598), + (12485141, 553), + (12485694, 541), + (12486235, 599), + (12486834, 553), + (12487387, 540), + (12487927, 592), + (12488519, 553), + (12489072, 540), + (12489612, 606), + (12490218, 553), + (12490771, 541), + (12491312, 605), + (12491917, 553), + (12492470, 542), + (12493012, 570), + (12493582, 553), + (12494135, 541), + (12494676, 586), + (12495262, 553), + (12495815, 541), + (12496356, 586), + (12496942, 554), + (12497496, 540), + (12498036, 587), + (12498623, 554), + (12499177, 542), + (12499719, 600), + (12500319, 552), + (12500871, 541), + (12501412, 599), + (12502011, 554), + (12502565, 540), + (12503105, 592), + (12503697, 554), + (12504251, 541), + (12504792, 605), + (12505397, 553), + (12505950, 542), + (12506492, 605), + (12507097, 553), + (12507650, 541), + (12508191, 573), + (12508764, 553), + (12509317, 541), + (12509858, 587), + (12510445, 553), + (12510998, 541), + (12511539, 586), + (12512125, 553), + (12512678, 542), + (12513220, 588), + (12513808, 552), + (12514360, 541), + (12514901, 600), + (12515501, 554), + (12516055, 541), + (12516596, 601), + (12517197, 552), + (12517749, 542), + (12518291, 595), + (12518886, 554), + (12519440, 540), + (12519980, 606), + (12520586, 552), + (12521138, 542), + (12521680, 607), + (12522287, 554), + (12522841, 540), + (12523381, 585), + (12523966, 553), + (12524519, 540), + (12525059, 598), + (12525657, 553), + (12526210, 542), + (12526752, 598), + (12527350, 553), + (12527903, 540), + (12528443, 600), + (12529043, 553), + (12529596, 542), + (12530138, 612), + (12530750, 552), + (12531302, 541), + (12531843, 612), + (12532455, 552), + (12533007, 541), + (12533548, 607), + (12534155, 553), + (12534708, 541), + (12535249, 618), + (12535867, 553), + (12536420, 540), + (12536960, 619), + (12537579, 553), + (12538132, 541), + (12538673, 584), + (12539257, 552), + (12539809, 541), + (12540350, 599), + (12540949, 554), + (12541503, 541), + (12542044, 599), + (12542643, 552), + (12543195, 540), + (12543735, 600), + (12544335, 553), + (12544888, 541), + (12545429, 612), + (12546041, 553), + (12546594, 542), + (12547136, 612), + (12547748, 552), + (12548300, 541), + (12548841, 606), + (12549447, 553), + (12550000, 541), + (12550541, 617), + (12551158, 554), + (12551712, 541), + (12552253, 619), + (12552872, 553), + (12553425, 540), + (12553965, 575), + (12554540, 552), + (12555092, 542), + (12555634, 589), + (12556223, 552), + (12556775, 541), + (12557316, 590), + (12557906, 553), + (12558459, 541), + (12559000, 590), + (12559590, 554), + (12560144, 542), + (12560686, 603), + (12561289, 553), + (12561842, 542), + (12562384, 602), + (12562986, 554), + (12563540, 542), + (12564082, 595), + (12564677, 554), + (12565231, 540), + (12565771, 608), + (12566379, 553), + (12566932, 541), + (12567473, 607), + (12568080, 553), + (12568633, 541), + (12569174, 587), + (12569761, 552), + (12570313, 541), + (12570854, 601), + (12571455, 553), + (12572008, 540), + (12572548, 602), + (12573150, 553), + (12573703, 541), + (12574244, 602), + (12574846, 553), + (12575399, 541), + (12575940, 615), + (12576555, 553), + (12577108, 540), + (12577648, 614), + (12578262, 553), + (12578815, 541), + (12579356, 608), + (12579964, 553), + (12580517, 540), + (12581057, 619), + (12581676, 552), + (12582228, 540), + (12582768, 620), + (12583388, 554), + (12583942, 541), + (12584483, 587), + (12585070, 554), + (12585624, 541), + (12586165, 602), + (12586767, 553), + (12587320, 541), + (12587861, 600), + (12588461, 552), + (12589013, 541), + (12589554, 602), + (12590156, 553), + (12590709, 541), + (12591250, 614), + (12591864, 554), + (12592418, 540), + (12592958, 615), + (12593573, 554), + (12594127, 540), + (12594667, 609), + (12595276, 554), + (12595830, 542), + (12596372, 620), + (12596992, 553), + (12597545, 540), + (12598085, 621), + (12598706, 552), + (12599258, 541), + (12599799, 542), + (12600341, 552), + (12600893, 540), + (12601433, 570), + (12602003, 553), + (12602556, 541), + (12603097, 570), + (12603667, 552), + (12604219, 540), + (12604759, 571), + (12605330, 554), + (12605884, 541), + (12606425, 586), + (12607011, 553), + (12607564, 540), + (12608104, 585), + (12608689, 552), + (12609241, 541), + (12609782, 579), + (12610361, 552), + (12610913, 542), + (12611455, 591), + (12612046, 553), + (12612599, 540), + (12613139, 592), + (12613731, 552), + (12614283, 540), + (12614823, 571), + (12615394, 553), + (12615947, 541), + (12616488, 586), + (12617074, 553), + (12617627, 540), + (12618167, 585), + (12618752, 554), + (12619306, 541), + (12619847, 587), + (12620434, 552), + (12620986, 540), + (12621526, 598), + (12622124, 554), + (12622678, 540), + (12623218, 599), + (12623817, 553), + (12624370, 542), + (12624912, 592), + (12625504, 553), + (12626057, 540), + (12626597, 605), + (12627202, 553), + (12627755, 541), + (12628296, 604), + (12628900, 553), + (12629453, 542), + (12629995, 570), + (12630565, 554), + (12631119, 540), + (12631659, 586), + (12632245, 554), + (12632799, 540), + (12633339, 585), + (12633924, 552), + (12634476, 540), + (12635016, 587), + (12635603, 553), + (12636156, 541), + (12636697, 600), + (12637297, 554), + (12637851, 540), + (12638391, 599), + (12638990, 554), + (12639544, 540), + (12640084, 593), + (12640677, 552), + (12641229, 541), + (12641770, 605), + (12642375, 553), + (12642928, 541), + (12643469, 605), + (12644074, 554), + (12644628, 542), + (12645170, 571), + (12645741, 554), + (12646295, 540), + (12646835, 587), + (12647422, 552), + (12647974, 540), + (12648514, 586), + (12649100, 552), + (12649652, 541), + (12650193, 588), + (12650781, 553), + (12651334, 540), + (12651874, 599), + (12652473, 554), + (12653027, 540), + (12653567, 599), + (12654166, 554), + (12654720, 542), + (12655262, 594), + (12655856, 553), + (12656409, 541), + (12656950, 606), + (12657556, 553), + (12658109, 541), + (12658650, 606), + (12659256, 553), + (12659809, 542), + (12660351, 585), + (12660936, 554), + (12661490, 541), + (12662031, 598), + (12662629, 554), + (12663183, 541), + (12663724, 599), + (12664323, 552), + (12664875, 541), + (12665416, 599), + (12666015, 553), + (12666568, 542), + (12667110, 612), + (12667722, 554), + (12668276, 541), + (12668817, 613), + (12669430, 554), + (12669984, 541), + (12670525, 605), + (12671130, 553), + (12671683, 542), + (12672225, 617), + (12672842, 553), + (12673395, 541), + (12673936, 617), + (12674553, 554), + (12675107, 540), + (12675647, 584), + (12676231, 553), + (12676784, 542), + (12677326, 599), + (12677925, 554), + (12678479, 541), + (12679020, 599), + (12679619, 553), + (12680172, 541), + (12680713, 600), + (12681313, 554), + (12681867, 540), + (12682407, 611), + (12683018, 552), + (12683570, 541), + (12684111, 611), + (12684722, 554), + (12685276, 542), + (12685818, 607), + (12686425, 552), + (12686977, 541), + (12687518, 617), + (12688135, 553), + (12688688, 540), + (12689228, 619), + (12689847, 554), + (12690401, 540), + (12690941, 575), + (12691516, 553), + (12692069, 541), + (12692610, 588), + (12693198, 553), + (12693751, 541), + (12694292, 589), + (12694881, 554), + (12695435, 541), + (12695976, 589), + (12696565, 552), + (12697117, 542), + (12697659, 602), + (12698261, 553), + (12698814, 542), + (12699356, 601), + (12699957, 552), + (12700509, 542), + (12701051, 596), + (12701647, 553), + (12702200, 540), + (12702740, 608), + (12703348, 553), + (12703901, 540), + (12704441, 609), + (12705050, 553), + (12705603, 541), + (12706144, 588), + (12706732, 553), + (12707285, 541), + (12707826, 601), + (12708427, 553), + (12708980, 540), + (12709520, 601), + (12710121, 554), + (12710675, 541), + (12711216, 602), + (12711818, 553), + (12712371, 541), + (12712912, 614), + (12713526, 552), + (12714078, 542), + (12714620, 614), + (12715234, 553), + (12715787, 541), + (12716328, 607), + (12716935, 553), + (12717488, 541), + (12718029, 620), + (12718649, 554), + (12719203, 541), + (12719744, 620), + (12720364, 553), + (12720917, 541), + (12721458, 588), + (12722046, 553), + (12722599, 542), + (12723141, 600), + (12723741, 553), + (12724294, 541), + (12724835, 601), + (12725436, 553), + (12725989, 542), + (12726531, 602), + (12727133, 552), + (12727685, 541), + (12728226, 614), + (12728840, 552), + (12729392, 541), + (12729933, 613), + (12730546, 553), + (12731099, 541), + (12731640, 608), + (12732248, 553), + (12732801, 541), + (12733342, 621), + (12733963, 552), + (12734515, 541), + (12735056, 620), + (12735676, 553), + (12736229, 536), + (12736765, 543), + (12737308, 553), + (12737861, 536), + (12738397, 569), + (12738966, 554), + (12739520, 537), + (12740057, 570), + (12740627, 553), + (12741180, 536), + (12741716, 573), + (12742289, 554), + (12742843, 535), + (12743378, 584), + (12743962, 553), + (12744515, 535), + (12745050, 584), + (12745634, 553), + (12746187, 536), + (12746723, 579), + (12747302, 554), + (12747856, 536), + (12748392, 592), + (12748984, 553), + (12749537, 536), + (12750073, 591), + (12750664, 553), + (12751217, 537), + (12751754, 570), + (12752324, 553), + (12752877, 535), + (12753412, 586), + (12753998, 553), + (12754551, 536), + (12755087, 586), + (12755673, 554), + (12756227, 536), + (12756763, 587), + (12757350, 552), + (12757902, 537), + (12758439, 600), + (12759039, 554), + (12759593, 535), + (12760128, 600), + (12760728, 554), + (12761282, 537), + (12761819, 592), + (12762411, 553), + (12762964, 536), + (12763500, 606), + (12764106, 554), + (12764660, 535), + (12765195, 606), + (12765801, 553), + (12766354, 535), + (12766889, 569), + (12767458, 553), + (12768011, 535), + (12768546, 586), + (12769132, 552), + (12769684, 535), + (12770219, 586), + (12770805, 553), + (12771358, 537), + (12771895, 588), + (12772483, 554), + (12773037, 537), + (12773574, 598), + (12774172, 553), + (12774725, 536), + (12775261, 598), + (12775859, 553), + (12776412, 536), + (12776948, 593), + (12777541, 552), + (12778093, 535), + (12778628, 605), + (12779233, 552), + (12779785, 536), + (12780321, 605), + (12780926, 552), + (12781478, 535), + (12782013, 573), + (12782586, 554), + (12783140, 536), + (12783676, 587), + (12784263, 552), + (12784815, 537), + (12785352, 586), + (12785938, 554), + (12786492, 537), + (12787029, 588), + (12787617, 554), + (12788171, 537), + (12788708, 601), + (12789309, 553), + (12789862, 535), + (12790397, 601), + (12790998, 552), + (12791550, 536), + (12792086, 594), + (12792680, 553), + (12793233, 535), + (12793768, 607), + (12794375, 553), + (12794928, 535), + (12795463, 606), + (12796069, 553), + (12796622, 536), + (12797158, 586), + (12797744, 553), + (12798297, 535), + (12798832, 599), + (12799431, 552), + (12799983, 536), + (12800519, 599), + (12801118, 554), + (12801672, 536), + (12802208, 600), + (12802808, 552), + (12803360, 536), + (12803896, 612), + (12804508, 553), + (12805061, 537), + (12805598, 612), + (12806210, 554), + (12806764, 536), + (12807300, 605), + (12807905, 552), + (12808457, 536), + (12808993, 619), + (12809612, 553), + (12810165, 536), + (12810701, 618), + (12811319, 552), + (12811871, 535), + (12812406, 584), + (12812990, 553), + (12813543, 536), + (12814079, 599), + (12814678, 553), + (12815231, 535), + (12815766, 599), + (12816365, 552), + (12816917, 536), + (12817453, 599), + (12818052, 553), + (12818605, 536), + (12819141, 613), + (12819754, 552), + (12820306, 536), + (12820842, 611), + (12821453, 553), + (12822006, 537), + (12822543, 606), + (12823149, 554), + (12823703, 537), + (12824240, 618), + (12824858, 553), + (12825411, 535), + (12825946, 618), + (12826564, 553), + (12827117, 535), + (12827652, 574), + (12828226, 553), + (12828779, 536), + (12829315, 588), + (12829903, 553), + (12830456, 536), + (12830992, 588), + (12831580, 552), + (12832132, 537), + (12832669, 590), + (12833259, 554), + (12833813, 535), + (12834348, 602), + (12834950, 554), + (12835504, 536), + (12836040, 601), + (12836641, 553), + (12837194, 537), + (12837731, 595), + (12838326, 552), + (12838878, 536), + (12839414, 609), + (12840023, 552), + (12840575, 535), + (12841110, 609), + (12841719, 552), + (12842271, 535), + (12842806, 587), + (12843393, 554), + (12843947, 536), + (12844483, 602), + (12845085, 552), + (12845637, 536), + (12846173, 602), + (12846775, 554), + (12847329, 537), + (12847866, 602), + (12848468, 554), + (12849022, 536), + (12849558, 615), + (12850173, 553), + (12850726, 535), + (12851261, 614), + (12851875, 552), + (12852427, 536), + (12852963, 608), + (12853571, 552), + (12854123, 537), + (12854660, 620), + (12855280, 554), + (12855834, 536), + (12856370, 619), + (12856989, 554), + (12857543, 536), + (12858079, 588), + (12858667, 552), + (12859219, 537), + (12859756, 601), + (12860357, 554), + (12860911, 536), + (12861447, 600), + (12862047, 553), + (12862600, 536), + (12863136, 601), + (12863737, 554), + (12864291, 536), + (12864827, 614), + (12865441, 552), + (12865993, 535), + (12866528, 613), + (12867141, 553), + (12867694, 536), + (12868230, 609), + (12868839, 553), + (12869392, 537), + (12869929, 621), + (12870550, 553), + (12871103, 536), + (12871639, 620), + (12872259, 552), + (12872811, 543), + (12873354, 542), + (12873896, 554), + (12874450, 542), + (12874992, 570), + (12875562, 552), + (12876114, 542), + (12876656, 570), + (12877226, 552), + (12877778, 543), + (12878321, 572), + (12878893, 553), + (12879446, 542), + (12879988, 585), + (12880573, 554), + (12881127, 543), + (12881670, 584), + (12882254, 552), + (12882806, 541), + (12883347, 579), + (12883926, 554), + (12884480, 541), + (12885021, 591), + (12885612, 553), + (12886165, 543), + (12886708, 591), + (12887299, 552), + (12887851, 542), + (12888393, 570), + (12888963, 552), + (12889515, 542), + (12890057, 585), + (12890642, 553), + (12891195, 543), + (12891738, 587), + (12892325, 553), + (12892878, 542), + (12893420, 587), + (12894007, 554), + (12894561, 543), + (12895104, 599), + (12895703, 552), + (12896255, 542), + (12896797, 600), + (12897397, 553), + (12897950, 543), + (12898493, 594), + (12899087, 553), + (12899640, 541), + (12900181, 605), + (12900786, 554), + (12901340, 542), + (12901882, 605), + (12902487, 553), + (12903040, 543), + (12903583, 570), + (12904153, 552), + (12904705, 541), + (12905246, 587), + (12905833, 554), + (12906387, 542), + (12906929, 585), + (12907514, 552), + (12908066, 541), + (12908607, 586), + (12909193, 553), + (12909746, 542), + (12910288, 599), + (12910887, 552), + (12911439, 542), + (12911981, 598), + (12912579, 553), + (12913132, 542), + (12913674, 594), + (12914268, 553), + (12914821, 541), + (12915362, 606), + (12915968, 553), + (12916521, 542), + (12917063, 605), + (12917668, 553), + (12918221, 541), + (12918762, 572), + (12919334, 553), + (12919887, 542), + (12920429, 587), + (12921016, 553), + (12921569, 543), + (12922112, 586), + (12922698, 554), + (12923252, 543), + (12923795, 589), + (12924384, 553), + (12924937, 541), + (12925478, 600), + (12926078, 553), + (12926631, 543), + (12927174, 600), + (12927774, 553), + (12928327, 543), + (12928870, 594), + (12929464, 553), + (12930017, 541), + (12930558, 606), + (12931164, 553), + (12931717, 542), + (12932259, 606), + (12932865, 552), + (12933417, 543), + (12933960, 584), + (12934544, 554), + (12935098, 542), + (12935640, 599), + (12936239, 554), + (12936793, 542), + (12937335, 598), + (12937933, 554), + (12938487, 541), + (12939028, 599), + (12939627, 553), + (12940180, 542), + (12940722, 612), + (12941334, 553), + (12941887, 543), + (12942430, 612), + (12943042, 552), + (12943594, 542), + (12944136, 606), + (12944742, 553), + (12945295, 541), + (12945836, 618), + (12946454, 552), + (12947006, 542), + (12947548, 619), + (12948167, 554), + (12948721, 542), + (12949263, 585), + (12949848, 553), + (12950401, 543), + (12950944, 599), + (12951543, 553), + (12952096, 542), + (12952638, 599), + (12953237, 553), + (12953790, 542), + (12954332, 600), + (12954932, 554), + (12955486, 543), + (12956029, 613), + (12956642, 552), + (12957194, 541), + (12957735, 613), + (12958348, 553), + (12958901, 542), + (12959443, 607), + (12960050, 553), + (12960603, 542), + (12961145, 618), + (12961763, 552), + (12962315, 543), + (12962858, 618), + (12963476, 552), + (12964028, 542), + (12964570, 575), + (12965145, 553), + (12965698, 542), + (12966240, 589), + (12966829, 554), + (12967383, 542), + (12967925, 589), + (12968514, 554), + (12969068, 541), + (12969609, 589), + (12970198, 553), + (12970751, 543), + (12971294, 601), + (12971895, 553), + (12972448, 543), + (12972991, 601), + (12973592, 552), + (12974144, 541), + (12974685, 596), + (12975281, 553), + (12975834, 542), + (12976376, 609), + (12976985, 552), + (12977537, 542), + (12978079, 608), + (12978687, 552), + (12979239, 541), + (12979780, 586), + (12980366, 553), + (12980919, 541), + (12981460, 602), + (12982062, 553), + (12982615, 541), + (12983156, 602), + (12983758, 552), + (12984310, 542), + (12984852, 603), + (12985455, 552), + (12986007, 543), + (12986550, 615), + (12987165, 553), + (12987718, 541), + (12988259, 614), + (12988873, 554), + (12989427, 542), + (12989969, 607), + (12990576, 554), + (12991130, 542), + (12991672, 620), + (12992292, 552), + (12992844, 542), + (12993386, 620), + (12994006, 552), + (12994558, 543), + (12995101, 587), + (12995688, 552), + (12996240, 541), + (12996781, 601), + (12997382, 553), + (12997935, 541), + (12998476, 602), + (12999078, 552), + (12999630, 542), + (13000172, 602), + (13000774, 553), + (13001327, 542), + (13001869, 614), + (13002483, 553), + (13003036, 543), + (13003579, 615), + (13004194, 554), + (13004748, 542), + (13005290, 608), + (13005898, 552), + (13006450, 542), + (13006992, 620), + (13007612, 552), + (13008164, 542), + (13008706, 620), + (13009326, 552), + (13009878, 542), + (13010420, 542), + (13010962, 552), + (13011514, 542), + (13012056, 570), + (13012626, 553), + (13013179, 543), + (13013722, 569), + (13014291, 553), + (13014844, 542), + (13015386, 572), + (13015958, 553), + (13016511, 542), + (13017053, 585), + (13017638, 552), + (13018190, 543), + (13018733, 584), + (13019317, 554), + (13019871, 542), + (13020413, 580), + (13020993, 553), + (13021546, 541), + (13022087, 590), + (13022677, 554), + (13023231, 542), + (13023773, 591), + (13024364, 554), + (13024918, 543), + (13025461, 571), + (13026032, 552), + (13026584, 541), + (13027125, 585), + (13027710, 553), + (13028263, 541), + (13028804, 586), + (13029390, 554), + (13029944, 543), + (13030487, 587), + (13031074, 552), + (13031626, 542), + (13032168, 599), + (13032767, 554), + (13033321, 541), + (13033862, 599), + (13034461, 553), + (13035014, 542), + (13035556, 593), + (13036149, 553), + (13036702, 542), + (13037244, 605), + (13037849, 553), + (13038402, 542), + (13038944, 605), + (13039549, 553), + (13040102, 541), + (13040643, 570), + (13041213, 553), + (13041766, 542), + (13042308, 586), + (13042894, 553), + (13043447, 542), + (13043989, 586), + (13044575, 553), + (13045128, 541), + (13045669, 587), + (13046256, 553), + (13046809, 541), + (13047350, 599), + (13047949, 554), + (13048503, 543), + (13049046, 600), + (13049646, 553), + (13050199, 541), + (13050740, 593), + (13051333, 553), + (13051886, 541), + (13052427, 606), + (13053033, 552), + (13053585, 541), + (13054126, 605), + (13054731, 552), + (13055283, 542), + (13055825, 573), + (13056398, 554), + (13056952, 541), + (13057493, 587), + (13058080, 552), + (13058632, 542), + (13059174, 587), + (13059761, 553), + (13060314, 541), + (13060855, 588), + (13061443, 554), + (13061997, 542), + (13062539, 601), + (13063140, 552), + (13063692, 543), + (13064235, 600), + (13064835, 554), + (13065389, 541), + (13065930, 595), + (13066525, 553), + (13067078, 541), + (13067619, 605), + (13068224, 553), + (13068777, 542), + (13069319, 605), + (13069924, 553), + (13070477, 542), + (13071019, 586), + (13071605, 553), + (13072158, 541), + (13072699, 600), + (13073299, 553), + (13073852, 542), + (13074394, 598), + (13074992, 553), + (13075545, 541), + (13076086, 601), + (13076687, 554), + (13077241, 542), + (13077783, 611), + (13078394, 554), + (13078948, 543), + (13079491, 612), + (13080103, 553), + (13080656, 542), + (13081198, 606), + (13081804, 553), + (13082357, 542), + (13082899, 618), + (13083517, 553), + (13084070, 542), + (13084612, 619), + (13085231, 552), + (13085783, 542), + (13086325, 586), + (13086911, 553), + (13087464, 542), + (13088006, 598), + (13088604, 554), + (13089158, 542), + (13089700, 600), + (13090300, 553), + (13090853, 541), + (13091394, 599), + (13091993, 552), + (13092545, 543), + (13093088, 613), + (13093701, 553), + (13094254, 543), + (13094797, 611), + (13095408, 553), + (13095961, 542), + (13096503, 606), + (13097109, 552), + (13097661, 543), + (13098204, 617), + (13098821, 552), + (13099373, 543), + (13099916, 618), + (13100534, 553), + (13101087, 541), + (13101628, 576), + (13102204, 554), + (13102758, 543), + (13103301, 589), + (13103890, 553), + (13104443, 542), + (13104985, 589), + (13105574, 554), + (13106128, 542), + (13106670, 590), + (13107260, 553), + (13107813, 542), + (13108355, 603), + (13108958, 553), + (13109511, 542), + (13110053, 601), + (13110654, 552), + (13111206, 543), + (13111749, 596), + (13112345, 552), + (13112897, 542), + (13113439, 607), + (13114046, 554), + (13114600, 542), + (13115142, 608), + (13115750, 553), + (13116303, 541), + (13116844, 586), + (13117430, 552), + (13117982, 542), + (13118524, 600), + (13119124, 552), + (13119676, 543), + (13120219, 601), + (13120820, 554), + (13121374, 541), + (13121915, 602), + (13122517, 553), + (13123070, 541), + (13123611, 615), + (13124226, 553), + (13124779, 542), + (13125321, 615), + (13125936, 554), + (13126490, 541), + (13127031, 607), + (13127638, 552), + (13128190, 542), + (13128732, 619), + (13129351, 554), + (13129905, 542), + (13130447, 620), + (13131067, 553), + (13131620, 542), + (13132162, 586), + (13132748, 553), + (13133301, 541), + (13133842, 600), + (13134442, 553), + (13134995, 541), + (13135536, 601), + (13136137, 553), + (13136690, 542), + (13137232, 603), + (13137835, 553), + (13138388, 543), + (13138931, 614), + (13139545, 554), + (13140099, 542), + (13140641, 615), + (13141256, 553), + (13141809, 541), + (13142350, 609), + (13142959, 554), + (13143513, 542), + (13144055, 620), + (13144675, 553), + (13145228, 543), + (13145771, 621), + (13146392, 553), + (13146945, 529), + (13147474, 542), + (13148016, 553), + (13148569, 527), + (13149096, 570), + (13149666, 552), + (13150218, 529), + (13150747, 569), + (13151316, 553), + (13151869, 528), + (13152397, 571), + (13152968, 553), + (13153521, 528), + (13154049, 585), + (13154634, 553), + (13155187, 527), + (13155714, 586), + (13156300, 553), + (13156853, 529), + (13157382, 580), + (13157962, 552), + (13158514, 529), + (13159043, 591), + (13159634, 553), + (13160187, 528), + (13160715, 591), + (13161306, 554), + (13161860, 527), + (13162387, 570), + (13162957, 553), + (13163510, 528), + (13164038, 585), + (13164623, 554), + (13165177, 527), + (13165704, 586), + (13166290, 554), + (13166844, 528), + (13167372, 588), + (13167960, 553), + (13168513, 529), + (13169042, 599), + (13169641, 552), + (13170193, 528), + (13170721, 598), + (13171319, 553), + (13171872, 528), + (13172400, 594), + (13172994, 553), + (13173547, 528), + (13174075, 605), + (13174680, 552), + (13175232, 528), + (13175760, 605), + (13176365, 553), + (13176918, 527), + (13177445, 570), + (13178015, 554), + (13178569, 529), + (13179098, 586), + (13179684, 554), + (13180238, 528), + (13180766, 586), + (13181352, 553), + (13181905, 529), + (13182434, 586), + (13183020, 553), + (13183573, 529), + (13184102, 599), + (13184701, 552), + (13185253, 529), + (13185782, 599), + (13186381, 553), + (13186934, 528), + (13187462, 593), + (13188055, 553), + (13188608, 527), + (13189135, 606), + (13189741, 553), + (13190294, 528), + (13190822, 606), + (13191428, 554), + (13191982, 528), + (13192510, 573), + (13193083, 553), + (13193636, 528), + (13194164, 587), + (13194751, 553), + (13195304, 529), + (13195833, 587), + (13196420, 552), + (13196972, 528), + (13197500, 588), + (13198088, 553), + (13198641, 527), + (13199168, 601), + (13199769, 552), + (13200321, 528), + (13200849, 600), + (13201449, 554), + (13202003, 529), + (13202532, 594), + (13203126, 553), + (13203679, 528), + (13204207, 607), + (13204814, 552), + (13205366, 529), + (13205895, 606), + (13206501, 553), + (13207054, 529), + (13207583, 585), + (13208168, 553), + (13208721, 529), + (13209250, 598), + (13209848, 553), + (13210401, 528), + (13210929, 599), + (13211528, 553), + (13212081, 527), + (13212608, 601), + (13213209, 553), + (13213762, 528), + (13214290, 611), + (13214901, 553), + (13215454, 528), + (13215982, 611), + (13216593, 552), + (13217145, 527), + (13217672, 607), + (13218279, 552), + (13218831, 529), + (13219360, 619), + (13219979, 552), + (13220531, 528), + (13221059, 619), + (13221678, 552), + (13222230, 528), + (13222758, 586), + (13223344, 553), + (13223897, 528), + (13224425, 598), + (13225023, 552), + (13225575, 528), + (13226103, 600), + (13226703, 554), + (13227257, 529), + (13227786, 599), + (13228385, 552), + (13228937, 529), + (13229466, 611), + (13230077, 553), + (13230630, 527), + (13231157, 613), + (13231770, 553), + (13232323, 527), + (13232850, 606), + (13233456, 553), + (13234009, 529), + (13234538, 617), + (13235155, 554), + (13235709, 527), + (13236236, 618), + (13236854, 554), + (13237408, 527), + (13237935, 574), + (13238509, 553), + (13239062, 527), + (13239589, 588), + (13240177, 553), + (13240730, 528), + (13241258, 590), + (13241848, 553), + (13242401, 527), + (13242928, 590), + (13243518, 553), + (13244071, 527), + (13244598, 601), + (13245199, 552), + (13245751, 527), + (13246278, 601), + (13246879, 553), + (13247432, 529), + (13247961, 596), + (13248557, 553), + (13249110, 528), + (13249638, 608), + (13250246, 553), + (13250799, 529), + (13251328, 608), + (13251936, 554), + (13252490, 527), + (13253017, 587), + (13253604, 553), + (13254157, 528), + (13254685, 600), + (13255285, 553), + (13255838, 528), + (13256366, 602), + (13256968, 554), + (13257522, 528), + (13258050, 603), + (13258653, 553), + (13259206, 528), + (13259734, 614), + (13260348, 553), + (13260901, 528), + (13261429, 614), + (13262043, 553), + (13262596, 527), + (13263123, 607), + (13263730, 553), + (13264283, 528), + (13264811, 619), + (13265430, 553), + (13265983, 529), + (13266512, 619), + (13267131, 552), + (13267683, 529), + (13268212, 587), + (13268799, 553), + (13269352, 528), + (13269880, 601), + (13270481, 553), + (13271034, 529), + (13271563, 601), + (13272164, 554), + (13272718, 529), + (13273247, 603), + (13273850, 552), + (13274402, 527), + (13274929, 614), + (13275543, 553), + (13276096, 528), + (13276624, 614), + (13277238, 553), + (13277791, 529), + (13278320, 608), + (13278928, 554), + (13279482, 528), + (13280010, 619), + (13280629, 553), + (13281182, 529), + (13281711, 619), + (13282330, 552), + (13282882, 546), + (13283428, 541), + (13283969, 553), + (13284522, 546), + (13285068, 570), + (13285638, 553), + (13286191, 545), + (13286736, 570), + (13287306, 554), + (13287860, 544), + (13288404, 572), + (13288976, 553), + (13289529, 545), + (13290074, 584), + (13290658, 553), + (13291211, 546), + (13291757, 585), + (13292342, 553), + (13292895, 546), + (13293441, 579), + (13294020, 554), + (13294574, 545), + (13295119, 590), + (13295709, 552), + (13296261, 545), + (13296806, 590), + (13297396, 554), + (13297950, 544), + (13298494, 571), + (13299065, 554), + (13299619, 545), + (13300164, 586), + (13300750, 554), + (13301304, 545), + (13301849, 586), + (13302435, 552), + (13302987, 544), + (13303531, 586), + (13304117, 554), + (13304671, 545), + (13305216, 600), + (13305816, 553), + (13306369, 546), + (13306915, 600), + (13307515, 553), + (13308068, 546), + (13308614, 592), + (13309206, 553), + (13309759, 545), + (13310304, 605), + (13310909, 553), + (13311462, 546), + (13312008, 605), + (13312613, 552), + (13313165, 545), + (13313710, 570), + (13314280, 552), + (13314832, 544), + (13315376, 586), + (13315962, 552), + (13316514, 546), + (13317060, 586), + (13317646, 554), + (13318200, 544), + (13318744, 588), + (13319332, 552), + (13319884, 545), + (13320429, 598), + (13321027, 553), + (13321580, 545), + (13322125, 600), + (13322725, 552), + (13323277, 544), + (13323821, 592), + (13324413, 554), + (13324967, 544), + (13325511, 605), + (13326116, 552), + (13326668, 545), + (13327213, 605), + (13327818, 552), + (13328370, 545), + (13328915, 571), + (13329486, 553), + (13330039, 544), + (13330583, 587), + (13331170, 553), + (13331723, 545), + (13332268, 586), + (13332854, 554), + (13333408, 546), + (13333954, 588), + (13334542, 553), + (13335095, 546), + (13335641, 600), + (13336241, 553), + (13336794, 545), + (13337339, 600), + (13337939, 553), + (13338492, 546), + (13339038, 595), + (13339633, 553), + (13340186, 546), + (13340732, 605), + (13341337, 554), + (13341891, 546), + (13342437, 606), + (13343043, 553), + (13343596, 546), + (13344142, 585), + (13344727, 552), + (13345279, 545), + (13345824, 600), + (13346424, 552), + (13346976, 545), + (13347521, 598), + (13348119, 554), + (13348673, 546), + (13349219, 599), + (13349818, 553), + (13350371, 545), + (13350916, 613), + (13351529, 554), + (13352083, 546), + (13352629, 612), + (13353241, 554), + (13353795, 544), + (13354339, 605), + (13354944, 553), + (13355497, 546), + (13356043, 617), + (13356660, 553), + (13357213, 545), + (13357758, 619), + (13358377, 553), + (13358930, 546), + (13359476, 586), + (13360062, 553), + (13360615, 546), + (13361161, 600), + (13361761, 553), + (13362314, 544), + (13362858, 599), + (13363457, 552), + (13364009, 545), + (13364554, 600), + (13365154, 554), + (13365708, 545), + (13366253, 613), + (13366866, 552), + (13367418, 545), + (13367963, 611), + (13368574, 552), + (13369126, 546), + (13369672, 605), + (13370277, 553), + (13370830, 546), + (13371376, 618), + (13371994, 554), + (13372548, 545), + (13373093, 618), + (13373711, 554), + (13374265, 545), + (13374810, 574), + (13375384, 554), + (13375938, 546), + (13376484, 589), + (13377073, 554), + (13377627, 545), + (13378172, 588), + (13378760, 554), + (13379314, 546), + (13379860, 590), + (13380450, 553), + (13381003, 545), + (13381548, 602), + (13382150, 552), + (13382702, 545), + (13383247, 602), + (13383849, 554), + (13384403, 544), + (13384947, 596), + (13385543, 553), + (13386096, 546), + (13386642, 608), + (13387250, 554), + (13387804, 544), + (13388348, 608), + (13388956, 553), + (13389509, 546), + (13390055, 587), + (13390642, 553), + (13391195, 545), + (13391740, 600), + (13392340, 553), + (13392893, 545), + (13393438, 602), + (13394040, 552), + (13394592, 545), + (13395137, 601), + (13395738, 554), + (13396292, 544), + (13396836, 613), + (13397449, 553), + (13398002, 544), + (13398546, 613), + (13399159, 553), + (13399712, 545), + (13400257, 607), + (13400864, 552), + (13401416, 545), + (13401961, 621), + (13402582, 554), + (13403136, 544), + (13403680, 620), + (13404300, 553), + (13404853, 546), + (13405399, 586), + (13405985, 554), + (13406539, 545), + (13407084, 600), + (13407684, 554), + (13408238, 545), + (13408783, 602), + (13409385, 554), + (13409939, 545), + (13410484, 602), + (13411086, 552), + (13411638, 545), + (13412183, 614), + (13412797, 553), + (13413350, 546), + (13413896, 613), + (13414509, 552), + (13415061, 544), + (13415605, 608), + (13416213, 553), + (13416766, 546), + (13417312, 621), + (13417933, 554), + (13418487, 546), + (13419033, 619), + (13419652, 552), + (13420204, 544), + (13420748, 541), + (13421289, 553), + (13421842, 544), + (13422386, 570), + (13422956, 553), + (13423509, 545), + (13424054, 570), + (13424624, 553), + (13425177, 546), + (13425723, 572), + (13426295, 553), + (13426848, 545), + (13427393, 584), + (13427977, 553), + (13428530, 546), + (13429076, 584), + (13429660, 553), + (13430213, 545), + (13430758, 578), + (13431336, 553), + (13431889, 545), + (13432434, 591), + (13433025, 554), + (13433579, 546), + (13434125, 591), + (13434716, 553), + (13435269, 544), + (13435813, 569), + (13436382, 552), + (13436934, 545), + (13437479, 585), + (13438064, 553), + (13438617, 545), + (13439162, 586), + (13439748, 553), + (13440301, 544), + (13440845, 586), + (13441431, 553), + (13441984, 545), + (13442529, 599), + (13443128, 553), + (13443681, 545), + (13444226, 600), + (13444826, 553), + (13445379, 544), + (13445923, 593), + (13446516, 553), + (13447069, 546), + (13447615, 604), + (13448219, 553), + (13448772, 544), + (13449316, 605), + (13449921, 552), + (13450473, 545), + (13451018, 571), + (13451589, 553), + (13452142, 546), + (13452688, 585), + (13453273, 553), + (13453826, 545), + (13454371, 586), + (13454957, 553), + (13455510, 546), + (13456056, 588), + (13456644, 554), + (13457198, 546), + (13457744, 599), + (13458343, 553), + (13458896, 544), + (13459440, 598), + (13460038, 552), + (13460590, 544), + (13461134, 592), + (13461726, 553), + (13462279, 545), + (13462824, 604), + (13463428, 553), + (13463981, 546), + (13464527, 604), + (13465131, 553), + (13465684, 545), + (13466229, 572), + (13466801, 553), + (13467354, 546), + (13467900, 587), + (13468487, 553), + (13469040, 545), + (13469585, 587), + (13470172, 552), + (13470724, 546), + (13471270, 589), + (13471859, 553), + (13472412, 544), + (13472956, 599), + (13473555, 554), + (13474109, 544), + (13474653, 601), + (13475254, 553), + (13475807, 545), + (13476352, 593), + (13476945, 553), + (13477498, 545), + (13478043, 605), + (13478648, 553), + (13479201, 545), + (13479746, 607), + (13480353, 554), + (13480907, 546), + (13481453, 585), + (13482038, 552), + (13482590, 546), + (13483136, 600), + (13483736, 553), + (13484289, 546), + (13484835, 598), + (13485433, 553), + (13485986, 544), + (13486530, 601), + (13487131, 554), + (13487685, 546), + (13488231, 612), + (13488843, 553), + (13489396, 546), + (13489942, 613), + (13490555, 552), + (13491107, 544), + (13491651, 606), + (13492257, 553), + (13492810, 545), + (13493355, 619), + (13493974, 554), + (13494528, 544), + (13495072, 618), + (13495690, 553), + (13496243, 545), + (13496788, 585), + (13497373, 553), + (13497926, 544), + (13498470, 599), + (13499069, 552), + (13499621, 545), + (13500166, 600), + (13500766, 553), + (13501319, 546), + (13501865, 601), + (13502466, 552), + (13503018, 545), + (13503563, 611), + (13504174, 552), + (13504726, 546), + (13505272, 613), + (13505885, 554), + (13506439, 545), + (13506984, 606), + (13507590, 552), + (13508142, 546), + (13508688, 618), + (13509306, 554), + (13509860, 545), + (13510405, 617), + (13511022, 553), + (13511575, 545), + (13512120, 574), + (13512694, 554), + (13513248, 545), + (13513793, 589), + (13514382, 553), + (13514935, 545), + (13515480, 590), + (13516070, 554), + (13516624, 545), + (13517169, 590), + (13517759, 553), + (13518312, 544), + (13518856, 603), + (13519459, 554), + (13520013, 545), + (13520558, 601), + (13521159, 553), + (13521712, 545), + (13522257, 596), + (13522853, 554), + (13523407, 545), + (13523952, 608), + (13524560, 553), + (13525113, 546), + (13525659, 609), + (13526268, 553), + (13526821, 545), + (13527366, 586), + (13527952, 554), + (13528506, 545), + (13529051, 601), + (13529652, 553), + (13530205, 545), + (13530750, 602), + (13531352, 554), + (13531906, 545), + (13532451, 602), + (13533053, 553), + (13533606, 546), + (13534152, 614), + (13534766, 553), + (13535319, 544), + (13535863, 612), + (13536475, 554), + (13537029, 545), + (13537574, 609), + (13538183, 553), + (13538736, 545), + (13539281, 621), + (13539902, 553), + (13540455, 546), + (13541001, 620), + (13541621, 553), + (13542174, 545), + (13542719, 587), + (13543306, 553), + (13543859, 544), + (13544403, 601), + (13545004, 552), + (13545556, 545), + (13546101, 600), + (13546701, 553), + (13547254, 545), + (13547799, 603), + (13548402, 553), + (13548955, 546), + (13549501, 615), + (13550116, 553), + (13550669, 545), + (13551214, 613), + (13551827, 553), + (13552380, 545), + (13552925, 609), + (13553534, 553), + (13554087, 545), + (13554632, 619), + (13555251, 554), + (13555805, 544), + (13556349, 620), + (13556969, 553), + (13557522, 554), + (13558076, 543), + (13558619, 553), + (13559172, 555), + (13559727, 570), + (13560297, 553), + (13560850, 555), + (13561405, 570), + (13561975, 554), + (13562529, 555), + (13563084, 572), + (13563656, 554), + (13564210, 555), + (13564765, 584), + (13565349, 552), + (13565901, 555), + (13566456, 585), + (13567041, 554), + (13567595, 554), + (13568149, 578), + (13568727, 552), + (13569279, 555), + (13569834, 591), + (13570425, 553), + (13570978, 555), + (13571533, 590), + (13572123, 553), + (13572676, 555), + (13573231, 571), + (13573802, 552), + (13574354, 555), + (13574909, 586), + (13575495, 553), + (13576048, 555), + (13576603, 586), + (13577189, 554), + (13577743, 555), + (13578298, 587), + (13578885, 552), + (13579437, 556), + (13579993, 600), + (13580593, 552), + (13581145, 555), + (13581700, 599), + (13582299, 553), + (13582852, 556), + (13583408, 593), + (13584001, 553), + (13584554, 556), + (13585110, 606), + (13585716, 554), + (13586270, 554), + (13586824, 604), + (13587428, 554), + (13587982, 555), + (13588537, 570), + (13589107, 553), + (13589660, 555), + (13590215, 585), + (13590800, 552), + (13591352, 556), + (13591908, 586), + (13592494, 554), + (13593048, 554), + (13593602, 588), + (13594190, 553), + (13594743, 554), + (13595297, 599), + (13595896, 553), + (13596449, 555), + (13597004, 600), + (13597604, 552), + (13598156, 554), + (13598710, 593), + (13599303, 553), + (13599856, 555), + (13600411, 606), + (13601017, 553), + (13601570, 555), + (13602125, 605), + (13602730, 553), + (13603283, 555), + (13603838, 572), + (13604410, 553), + (13604963, 555), + (13605518, 586), + (13606104, 553), + (13606657, 555), + (13607212, 587), + (13607799, 552), + (13608351, 556), + (13608907, 588), + (13609495, 553), + (13610048, 556), + (13610604, 601), + (13611205, 553), + (13611758, 554), + (13612312, 599), + (13612911, 553), + (13613464, 554), + (13614018, 594), + (13614612, 552), + (13615164, 554), + (13615718, 606), + (13616324, 552), + (13616876, 555), + (13617431, 606), + (13618037, 553), + (13618590, 555), + (13619145, 586), + (13619731, 553), + (13620284, 555), + (13620839, 598), + (13621437, 553), + (13621990, 554), + (13622544, 599), + (13623143, 553), + (13623696, 556), + (13624252, 599), + (13624851, 551), + (13625402, 556), + (13625958, 613), + (13626571, 552), + (13627123, 555), + (13627678, 612), + (13628290, 554), + (13628844, 556), + (13629400, 606), + (13630006, 554), + (13630560, 554), + (13631114, 618), + (13631732, 554), + (13632286, 555), + (13632841, 618), + (13633459, 554), + (13634013, 555), + (13634568, 586), + (13635154, 553), + (13635707, 555), + (13636262, 600), + (13636862, 552), + (13637414, 555), + (13637969, 599), + (13638568, 554), + (13639122, 555), + (13639677, 599), + (13640276, 553), + (13640829, 554), + (13641383, 613), + (13641996, 552), + (13642548, 556), + (13643104, 612), + (13643716, 554), + (13644270, 554), + (13644824, 606), + (13645430, 554), + (13645984, 554), + (13646538, 619), + (13647157, 553), + (13647710, 555), + (13648265, 618), + (13648883, 553), + (13649436, 555), + (13649991, 576), + (13650567, 554), + (13651121, 555), + (13651676, 589), + (13652265, 554), + (13652819, 556), + (13653375, 589), + (13653964, 552), + (13654516, 556), + (13655072, 591), + (13655663, 552), + (13656215, 555), + (13656770, 602), + (13657372, 553), + (13657925, 555), + (13658480, 602), + (13659082, 554), + (13659636, 555), + (13660191, 595), + (13660786, 553), + (13661339, 556), + (13661895, 609), + (13662504, 552), + (13663056, 555), + (13663611, 608), + (13664219, 552), + (13664771, 555), + (13665326, 587), + (13665913, 553), + (13666466, 556), + (13667022, 600), + (13667622, 554), + (13668176, 554), + (13668730, 601), + (13669331, 554), + (13669885, 554), + (13670439, 601), + (13671040, 552), + (13671592, 554), + (13672146, 614), + (13672760, 554), + (13673314, 554), + (13673868, 615), + (13674483, 553), + (13675036, 556), + (13675592, 609), + (13676201, 552), + (13676753, 555), + (13677308, 619), + (13677927, 554), + (13678481, 555), + (13679036, 620), + (13679656, 552), + (13680208, 556), + (13680764, 587), + (13681351, 553), + (13681904, 555), + (13682459, 601), + (13683060, 554), + (13683614, 555), + (13684169, 600), + (13684769, 554), + (13685323, 555), + (13685878, 601), + (13686479, 554), + (13687033, 556), + (13687589, 615), + (13688204, 554), + (13688758, 555), + (13689313, 614), + (13689927, 554), + (13690481, 556), + (13691037, 607), + (13691644, 554), + (13692198, 555), + (13692753, 619), + (13693372, 554), + (13693926, 555), + (13694481, 621), + (13695102, 554), + (13695656, 561), + (13696217, 541), + (13696758, 553), + (13697311, 561), + (13697872, 570), + (13698442, 553), + (13698995, 561), + (13699556, 570), + (13700126, 553), + (13700679, 561), + (13701240, 572), + (13701812, 553), + (13702365, 562), + (13702927, 585), + (13703512, 554), + (13704066, 561), + (13704627, 585), + (13705212, 553), + (13705765, 561), + (13706326, 578), + (13706904, 553), + (13707457, 560), + (13708017, 592), + (13708609, 553), + (13709162, 562), + (13709724, 591), + (13710315, 553), + (13710868, 561), + (13711429, 570), + (13711999, 553), + (13712552, 562), + (13713114, 585), + (13713699, 553), + (13714252, 560), + (13714812, 587), + (13715399, 553), + (13715952, 560), + (13716512, 588), + (13717100, 554), + (13717654, 561), + (13718215, 599), + (13718814, 554), + (13719368, 562), + (13719930, 599), + (13720529, 553), + (13721082, 561), + (13721643, 592), + (13722235, 554), + (13722789, 560), + (13723349, 605), + (13723954, 553), + (13724507, 562), + (13725069, 606), + (13725675, 554), + (13726229, 562), + (13726791, 571), + (13727362, 554), + (13727916, 560), + (13728476, 585), + (13729061, 553), + (13729614, 560), + (13730174, 587), + (13730761, 552), + (13731313, 562), + (13731875, 586), + (13732461, 552), + (13733013, 562), + (13733575, 598), + (13734173, 552), + (13734725, 561), + (13735286, 598), + (13735884, 552), + (13736436, 560), + (13736996, 593), + (13737589, 553), + (13738142, 562), + (13738704, 605), + (13739309, 553), + (13739862, 560), + (13740422, 605), + (13741027, 553), + (13741580, 562), + (13742142, 571), + (13742713, 553), + (13743266, 561), + (13743827, 587), + (13744414, 552), + (13744966, 560), + (13745526, 587), + (13746113, 553), + (13746666, 562), + (13747228, 587), + (13747815, 553), + (13748368, 560), + (13748928, 599), + (13749527, 554), + (13750081, 561), + (13750642, 599), + (13751241, 552), + (13751793, 560), + (13752353, 594), + (13752947, 553), + (13753500, 561), + (13754061, 607), + (13754668, 552), + (13755220, 560), + (13755780, 607), + (13756387, 553), + (13756940, 562), + (13757502, 585), + (13758087, 553), + (13758640, 562), + (13759202, 599), + (13759801, 553), + (13760354, 562), + (13760916, 598), + (13761514, 554), + (13762068, 560), + (13762628, 599), + (13763227, 553), + (13763780, 561), + (13764341, 612), + (13764953, 553), + (13765506, 561), + (13766067, 613), + (13766680, 552), + (13767232, 562), + (13767794, 605), + (13768399, 553), + (13768952, 562), + (13769514, 618), + (13770132, 553), + (13770685, 562), + (13771247, 617), + (13771864, 553), + (13772417, 561), + (13772978, 585), + (13773563, 553), + (13774116, 562), + (13774678, 600), + (13775278, 552), + (13775830, 562), + (13776392, 599), + (13776991, 552), + (13777543, 562), + (13778105, 600), + (13778705, 554), + (13779259, 561), + (13779820, 612), + (13780432, 552), + (13780984, 560), + (13781544, 612), + (13782156, 553), + (13782709, 561), + (13783270, 605), + (13783875, 553), + (13784428, 561), + (13784989, 617), + (13785606, 552), + (13786158, 560), + (13786718, 617), + (13787335, 552), + (13787887, 561), + (13788448, 575), + (13789023, 554), + (13789577, 560), + (13790137, 589), + (13790726, 553), + (13791279, 561), + (13791840, 588), + (13792428, 553), + (13792981, 562), + (13793543, 589), + (13794132, 553), + (13794685, 562), + (13795247, 602), + (13795849, 554), + (13796403, 562), + (13796965, 601), + (13797566, 552), + (13798118, 561), + (13798679, 596), + (13799275, 553), + (13799828, 561), + (13800389, 608), + (13800997, 554), + (13801551, 560), + (13802111, 608), + (13802719, 552), + (13803271, 561), + (13803832, 588), + (13804420, 553), + (13804973, 561), + (13805534, 602), + (13806136, 554), + (13806690, 561), + (13807251, 600), + (13807851, 553), + (13808404, 561), + (13808965, 603), + (13809568, 554), + (13810122, 561), + (13810683, 615), + (13811298, 553), + (13811851, 561), + (13812412, 614), + (13813026, 553), + (13813579, 560), + (13814139, 607), + (13814746, 554), + (13815300, 561), + (13815861, 619), + (13816480, 552), + (13817032, 561), + (13817593, 620), + (13818213, 554), + (13818767, 561), + (13819328, 587), + (13819915, 553), + (13820468, 561), + (13821029, 600), + (13821629, 553), + (13822182, 562), + (13822744, 602), + (13823346, 553), + (13823899, 561), + (13824460, 602), + (13825062, 552), + (13825614, 560), + (13826174, 613), + (13826787, 553), + (13827340, 562), + (13827902, 613), + (13828515, 552), + (13829067, 561), + (13829628, 608), + (13830236, 554), + (13830790, 560), + (13831350, 619), + (13831969, 553), + (13832522, 561), + (13833083, 621), + (13833704, 553), + (13834257, 561), + (13834818, 542), + (13835360, 552), + (13835912, 561), + (13836473, 570), + (13837043, 553), + (13837596, 560), + (13838156, 569), + (13838725, 552), + (13839277, 561), + (13839838, 571), + (13840409, 553), + (13840962, 560), + (13841522, 585), + (13842107, 552), + (13842659, 561), + (13843220, 586), + (13843806, 554), + (13844360, 562), + (13844922, 578), + (13845500, 553), + (13846053, 560), + (13846613, 592), + (13847205, 552), + (13847757, 561), + (13848318, 591), + (13848909, 554), + (13849463, 561), + (13850024, 570), + (13850594, 553), + (13851147, 561), + (13851708, 586), + (13852294, 552), + (13852846, 560), + (13853406, 586), + (13853992, 553), + (13854545, 562), + (13855107, 588), + (13855695, 554), + (13856249, 560), + (13856809, 599), + (13857408, 553), + (13857961, 560), + (13858521, 600), + (13859121, 553), + (13859674, 561), + (13860235, 593), + (13860828, 552), + (13861380, 560), + (13861940, 605), + (13862545, 553), + (13863098, 561), + (13863659, 605), + (13864264, 554), + (13864818, 561), + (13865379, 569), + (13865948, 553), + (13866501, 561), + (13867062, 587), + (13867649, 553), + (13868202, 560), + (13868762, 586), + (13869348, 553), + (13869901, 562), + (13870463, 588), + (13871051, 554), + (13871605, 560), + (13872165, 600), + (13872765, 552), + (13873317, 561), + (13873878, 598), + (13874476, 553), + (13875029, 561), + (13875590, 592), + (13876182, 552), + (13876734, 562), + (13877296, 605), + (13877901, 553), + (13878454, 560), + (13879014, 604), + (13879618, 554), + (13880172, 561), + (13880733, 572), + (13881305, 553), + (13881858, 561), + (13882419, 588), + (13883007, 553), + (13883560, 562), + (13884122, 587), + (13884709, 552), + (13885261, 562), + (13885823, 588), + (13886411, 553), + (13886964, 560), + (13887524, 600), + (13888124, 554), + (13888678, 562), + (13889240, 600), + (13889840, 553), + (13890393, 562), + (13890955, 594), + (13891549, 554), + (13892103, 560), + (13892663, 606), + (13893269, 552), + (13893821, 560), + (13894381, 605), + (13894986, 553), + (13895539, 560), + (13896099, 586), + (13896685, 553), + (13897238, 560), + (13897798, 600), + (13898398, 554), + (13898952, 561), + (13899513, 600), + (13900113, 553), + (13900666, 561), + (13901227, 600), + (13901827, 553), + (13902380, 561), + (13902941, 613), + (13903554, 553), + (13904107, 562), + (13904669, 611), + (13905280, 553), + (13905833, 562), + (13906395, 606), + (13907001, 554), + (13907555, 562), + (13908117, 617), + (13908734, 552), + (13909286, 560), + (13909846, 619), + (13910465, 554), + (13911019, 560), + (13911579, 585), + (13912164, 552), + (13912716, 561), + (13913277, 599), + (13913876, 554), + (13914430, 560), + (13914990, 599), + (13915589, 554), + (13916143, 560), + (13916703, 599), + (13917302, 554), + (13917856, 562), + (13918418, 613), + (13919031, 552), + (13919583, 561), + (13920144, 613), + (13920757, 553), + (13921310, 561), + (13921871, 606), + (13922477, 553), + (13923030, 561), + (13923591, 618), + (13924209, 552), + (13924761, 561), + (13925322, 618), + (13925940, 554), + (13926494, 560), + (13927054, 576), + (13927630, 552), + (13928182, 561), + (13928743, 589), + (13929332, 553), + (13929885, 561), + (13930446, 589), + (13931035, 552), + (13931587, 561), + (13932148, 591), + (13932739, 553), + (13933292, 562), + (13933854, 603), + (13934457, 554), + (13935011, 560), + (13935571, 602), + (13936173, 553), + (13936726, 561), + (13937287, 595), + (13937882, 554), + (13938436, 561), + (13938997, 608), + (13939605, 554), + (13940159, 562), + (13940721, 608), + (13941329, 554), + (13941883, 561), + (13942444, 588), + (13943032, 553), + (13943585, 561), + (13944146, 601), + (13944747, 553), + (13945300, 561), + (13945861, 600), + (13946461, 552), + (13947013, 560), + (13947573, 601), + (13948174, 553), + (13948727, 562), + (13949289, 614), + (13949903, 553), + (13950456, 560), + (13951016, 614), + (13951630, 554), + (13952184, 560), + (13952744, 609), + (13953353, 554), + (13953907, 562), + (13954469, 621), + (13955090, 552), + (13955642, 561), + (13956203, 620), + (13956823, 552), + (13957375, 562), + (13957937, 586), + (13958523, 554), + (13959077, 561), + (13959638, 602), + (13960240, 552), + (13960792, 562), + (13961354, 602), + (13961956, 554), + (13962510, 561), + (13963071, 602), + (13963673, 553), + (13964226, 560), + (13964786, 614), + (13965400, 552), + (13965952, 560), + (13966512, 614), + (13967126, 553), + (13967679, 560), + (13968239, 609), + (13968848, 552), + (13969400, 561), + (13969961, 620), + (13970581, 554), + (13971135, 560), + (13971695, 621), + (13972316, 553), + (13972869, 557), + (13973426, 543), + (13973969, 553), + (13974522, 556), + (13975078, 570), + (13975648, 554), + (13976202, 556), + (13976758, 570), + (13977328, 553), + (13977881, 555), + (13978436, 571), + (13979007, 553), + (13979560, 557), + (13980117, 585), + (13980702, 553), + (13981255, 555), + (13981810, 585), + (13982395, 554), + (13982949, 557), + (13983506, 578), + (13984084, 553), + (13984637, 555), + (13985192, 592), + (13985784, 553), + (13986337, 556), + (13986893, 591), + (13987484, 554), + (13988038, 557), + (13988595, 571), + (13989166, 553), + (13989719, 556), + (13990275, 587), + (13990862, 554), + (13991416, 557), + (13991973, 587), + (13992560, 553), + (13993113, 556), + (13993669, 588), + (13994257, 553), + (13994810, 557), + (13995367, 599), + (13995966, 554), + (13996520, 557), + (13997077, 599), + (13997676, 554), + (13998230, 555), + (13998785, 594), + (13999379, 553), + (13999932, 555), + (14000487, 606), + (14001093, 552), + (14001645, 557), + (14002202, 605), + (14002807, 554), + (14003361, 555), + (14003916, 569), + (14004485, 552), + (14005037, 556), + (14005593, 586), + (14006179, 553), + (14006732, 557), + (14007289, 587), + (14007876, 554), + (14008430, 557), + (14008987, 586), + (14009573, 553), + (14010126, 555), + (14010681, 598), + (14011279, 554), + (14011833, 557), + (14012390, 599), + (14012989, 553), + (14013542, 555), + (14014097, 594), + (14014691, 553), + (14015244, 556), + (14015800, 604), + (14016404, 552), + (14016956, 557), + (14017513, 605), + (14018118, 554), + (14018672, 557), + (14019229, 571), + (14019800, 553), + (14020353, 555), + (14020908, 586), + (14021494, 553), + (14022047, 557), + (14022604, 587), + (14023191, 553), + (14023744, 556), + (14024300, 587), + (14024887, 552), + (14025439, 556), + (14025995, 599), + (14026594, 553), + (14027147, 556), + (14027703, 600), + (14028303, 554), + (14028857, 555), + (14029412, 593), + (14030005, 553), + (14030558, 556), + (14031114, 604), + (14031718, 553), + (14032271, 557), + (14032828, 606), + (14033434, 553), + (14033987, 556), + (14034543, 585), + (14035128, 552), + (14035680, 557), + (14036237, 600), + (14036837, 553), + (14037390, 556), + (14037946, 600), + (14038546, 553), + (14039099, 556), + (14039655, 601), + (14040256, 552), + (14040808, 557), + (14041365, 613), + (14041978, 553), + (14042531, 555), + (14043086, 611), + (14043697, 553), + (14044250, 556), + (14044806, 606), + (14045412, 552), + (14045964, 555), + (14046519, 618), + (14047137, 553), + (14047690, 557), + (14048247, 617), + (14048864, 553), + (14049417, 555), + (14049972, 585), + (14050557, 553), + (14051110, 556), + (14051666, 599), + (14052265, 552), + (14052817, 556), + (14053373, 599), + (14053972, 552), + (14054524, 556), + (14055080, 601), + (14055681, 554), + (14056235, 556), + (14056791, 612), + (14057403, 554), + (14057957, 556), + (14058513, 611), + (14059124, 553), + (14059677, 556), + (14060233, 607), + (14060840, 552), + (14061392, 555), + (14061947, 617), + (14062564, 554), + (14063118, 556), + (14063674, 617), + (14064291, 553), + (14064844, 557), + (14065401, 576), + (14065977, 552), + (14066529, 556), + (14067085, 589), + (14067674, 554), + (14068228, 556), + (14068784, 589), + (14069373, 552), + (14069925, 557), + (14070482, 590), + (14071072, 553), + (14071625, 557), + (14072182, 603), + (14072785, 554), + (14073339, 556), + (14073895, 601), + (14074496, 553), + (14075049, 557), + (14075606, 596), + (14076202, 554), + (14076756, 555), + (14077311, 609), + (14077920, 554), + (14078474, 555), + (14079029, 607), + (14079636, 554), + (14080190, 557), + (14080747, 587), + (14081334, 554), + (14081888, 557), + (14082445, 602), + (14083047, 552), + (14083599, 555), + (14084154, 600), + (14084754, 553), + (14085307, 556), + (14085863, 603), + (14086466, 553), + (14087019, 556), + (14087575, 615), + (14088190, 553), + (14088743, 556), + (14089299, 614), + (14089913, 552), + (14090465, 555), + (14091020, 608), + (14091628, 552), + (14092180, 555), + (14092735, 619), + (14093354, 552), + (14093906, 555), + (14094461, 619), + (14095080, 553), + (14095633, 557), + (14096190, 587), + (14096777, 554), + (14097331, 556), + (14097887, 600), + (14098487, 554), + (14099041, 556), + (14099597, 602), + (14100199, 553), + (14100752, 556), + (14101308, 601), + (14101909, 553), + (14102462, 556), + (14103018, 614), + (14103632, 554), + (14104186, 557), + (14104743, 613), + (14105356, 553), + (14105909, 555), + (14106464, 609), + (14107073, 553), + (14107626, 557), + (14108183, 620), + (14108803, 552), + (14109355, 556), + (14109911, 620), + (14110531, 554), + (14111085, 563), + (14111648, 541), + (14112189, 553), + (14112742, 562), + (14113304, 570), + (14113874, 553), + (14114427, 562), + (14114989, 571), + (14115560, 552), + (14116112, 562), + (14116674, 572), + (14117246, 552), + (14117798, 563), + (14118361, 584), + (14118945, 552), + (14119497, 562), + (14120059, 584), + (14120643, 552), + (14121195, 562), + (14121757, 579), + (14122336, 553), + (14122889, 562), + (14123451, 591), + (14124042, 552), + (14124594, 562), + (14125156, 592), + (14125748, 553), + (14126301, 561), + (14126862, 571), + (14127433, 554), + (14127987, 563), + (14128550, 585), + (14129135, 554), + (14129689, 562), + (14130251, 586), + (14130837, 553), + (14131390, 562), + (14131952, 587), + (14132539, 554), + (14133093, 561), + (14133654, 600), + (14134254, 552), + (14134806, 563), + (14135369, 600), + (14135969, 552), + (14136521, 563), + (14137084, 594), + (14137678, 553), + (14138231, 563), + (14138794, 606), + (14139400, 552), + (14139952, 561), + (14140513, 604), + (14141117, 554), + (14141671, 563), + (14142234, 569), + (14142803, 554), + (14143357, 563), + (14143920, 585), + (14144505, 553), + (14145058, 561), + (14145619, 586), + (14146205, 554), + (14146759, 562), + (14147321, 588), + (14147909, 552), + (14148461, 563), + (14149024, 599), + (14149623, 552), + (14150175, 562), + (14150737, 598), + (14151335, 552), + (14151887, 561), + (14152448, 593), + (14153041, 553), + (14153594, 562), + (14154156, 605), + (14154761, 553), + (14155314, 562), + (14155876, 604), + (14156480, 554), + (14157034, 562), + (14157596, 571), + (14158167, 554), + (14158721, 562), + (14159283, 586), + (14159869, 553), + (14160422, 561), + (14160983, 587), + (14161570, 554), + (14162124, 562), + (14162686, 587), + (14163273, 554), + (14163827, 563), + (14164390, 600), + (14164990, 554), + (14165544, 562), + (14166106, 600), + (14166706, 553), + (14167259, 562), + (14167821, 594), + (14168415, 552), + (14168967, 563), + (14169530, 605), + (14170135, 553), + (14170688, 562), + (14171250, 606), + (14171856, 553), + (14172409, 560), + (14172969, 584), + (14173553, 552), + (14174105, 562), + (14174667, 598), + (14175265, 553), + (14175818, 562), + (14176380, 599), + (14176979, 552), + (14177531, 562), + (14178093, 601), + (14178694, 553), + (14179247, 562), + (14179809, 612), + (14180421, 552), + (14180973, 562), + (14181535, 612), + (14182147, 553), + (14182700, 562), + (14183262, 606), + (14183868, 553), + (14184421, 562), + (14184983, 619), + (14185602, 553), + (14186155, 563), + (14186718, 619), + (14187337, 553), + (14187890, 562), + (14188452, 584), + (14189036, 554), + (14189590, 562), + (14190152, 599), + (14190751, 553), + (14191304, 562), + (14191866, 598), + (14192464, 553), + (14193017, 562), + (14193579, 600), + (14194179, 553), + (14194732, 561), + (14195293, 612), + (14195905, 553), + (14196458, 561), + (14197019, 611), + (14197630, 554), + (14198184, 561), + (14198745, 606), + (14199351, 553), + (14199904, 562), + (14200466, 619), + (14201085, 554), + (14201639, 562), + (14202201, 619), + (14202820, 554), + (14203374, 562), + (14203936, 574), + (14204510, 552), + (14205062, 562), + (14205624, 588), + (14206212, 552), + (14206764, 563), + (14207327, 590), + (14207917, 553), + (14208470, 561), + (14209031, 589), + (14209620, 553), + (14210173, 562), + (14210735, 603), + (14211338, 553), + (14211891, 562), + (14212453, 602), + (14213055, 552), + (14213607, 562), + (14214169, 596), + (14214765, 553), + (14215318, 561), + (14215879, 607), + (14216486, 553), + (14217039, 563), + (14217602, 608), + (14218210, 553), + (14218763, 562), + (14219325, 587), + (14219912, 553), + (14220465, 562), + (14221027, 601), + (14221628, 554), + (14222182, 561), + (14222743, 601), + (14223344, 553), + (14223897, 562), + (14224459, 603), + (14225062, 553), + (14225615, 562), + (14226177, 613), + (14226790, 552), + (14227342, 562), + (14227904, 615), + (14228519, 552), + (14229071, 563), + (14229634, 608), + (14230242, 553), + (14230795, 562), + (14231357, 621), + (14231978, 553), + (14232531, 562), + (14233093, 621), + (14233714, 553), + (14234267, 563), + (14234830, 588), + (14235418, 554), + (14235972, 562), + (14236534, 600), + (14237134, 552), + (14237686, 561), + (14238247, 602), + (14238849, 554), + (14239403, 562), + (14239965, 601), + (14240566, 553), + (14241119, 561), + (14241680, 613), + (14242293, 554), + (14242847, 562), + (14243409, 615), + (14244024, 554), + (14244578, 562), + (14245140, 609), + (14245749, 553), + (14246302, 562), + (14246864, 620), + (14247484, 553), + (14248037, 562), + (14248599, 619), + (14249218, 553), + (14249771, 561), + (14250332, 541), + (14250873, 554), + (14251427, 562), + (14251989, 569), + (14252558, 553), + (14253111, 561), + (14253672, 570), + (14254242, 553), + (14254795, 562), + (14255357, 572), + (14255929, 552), + (14256481, 563), + (14257044, 585), + (14257629, 554), + (14258183, 563), + (14258746, 586), + (14259332, 553), + (14259885, 562), + (14260447, 578), + (14261025, 552), + (14261577, 562), + (14262139, 591), + (14262730, 553), + (14263283, 562), + (14263845, 591), + (14264436, 553), + (14264989, 561), + (14265550, 571), + (14266121, 553), + (14266674, 563), + (14267237, 585), + (14267822, 552), + (14268374, 562), + (14268936, 587), + (14269523, 554), + (14270077, 562), + (14270639, 588), + (14271227, 553), + (14271780, 563), + (14272343, 599), + (14272942, 553), + (14273495, 562), + (14274057, 599), + (14274656, 553), + (14275209, 562), + (14275771, 593), + (14276364, 554), + (14276918, 562), + (14277480, 605), + (14278085, 552), + (14278637, 562), + (14279199, 604), + (14279803, 553), + (14280356, 563), + (14280919, 570), + (14281489, 554), + (14282043, 563), + (14282606, 585), + (14283191, 553), + (14283744, 562), + (14284306, 586), + (14284892, 554), + (14285446, 562), + (14286008, 586), + (14286594, 553), + (14287147, 561), + (14287708, 599), + (14288307, 553), + (14288860, 563), + (14289423, 599), + (14290022, 553), + (14290575, 563), + (14291138, 593), + (14291731, 552), + (14292283, 562), + (14292845, 605), + (14293450, 552), + (14294002, 563), + (14294565, 605), + (14295170, 553), + (14295723, 562), + (14296285, 572), + (14296857, 553), + (14297410, 562), + (14297972, 586), + (14298558, 553), + (14299111, 562), + (14299673, 586), + (14300259, 552), + (14300811, 563), + (14301374, 588), + (14301962, 552), + (14302514, 563), + (14303077, 600), + (14303677, 554), + (14304231, 562), + (14304793, 601), + (14305394, 553), + (14305947, 561), + (14306508, 595), + (14307103, 553), + (14307656, 563), + (14308219, 607), + (14308826, 554), + (14309380, 563), + (14309943, 607), + (14310550, 553), + (14311103, 562), + (14311665, 584), + (14312249, 553), + (14312802, 562), + (14313364, 600), + (14313964, 553), + (14314517, 562), + (14315079, 598), + (14315677, 553), + (14316230, 562), + (14316792, 599), + (14317391, 552), + (14317943, 563), + (14318506, 612), + (14319118, 554), + (14319672, 562), + (14320234, 612), + (14320846, 553), + (14321399, 562), + (14321961, 607), + (14322568, 552), + (14323120, 562), + (14323682, 617), + (14324299, 553), + (14324852, 562), + (14325414, 618), + (14326032, 554), + (14326586, 562), + (14327148, 585), + (14327733, 552), + (14328285, 561), + (14328846, 599), + (14329445, 553), + (14329998, 561), + (14330559, 599), + (14331158, 554), + (14331712, 561), + (14332273, 601), + (14332874, 554), + (14333428, 563), + (14333991, 613), + (14334604, 554), + (14335158, 562), + (14335720, 611), + (14336331, 553), + (14336884, 562), + (14337446, 607), + (14338053, 553), + (14338606, 563), + (14339169, 617), + (14339786, 553), + (14340339, 562), + (14340901, 617), + (14341518, 553), + (14342071, 563), + (14342634, 576), + (14343210, 553), + (14343763, 562), + (14344325, 589), + (14344914, 553), + (14345467, 562), + (14346029, 589), + (14346618, 553), + (14347171, 563), + (14347734, 590), + (14348324, 553), + (14348877, 562), + (14349439, 602), + (14350041, 554), + (14350595, 562), + (14351157, 601), + (14351758, 554), + (14352312, 562), + (14352874, 595), + (14353469, 553), + (14354022, 561), + (14354583, 609), + (14355192, 554), + (14355746, 563), + (14356309, 608), + (14356917, 553), + (14357470, 561), + (14358031, 587), + (14358618, 554), + (14359172, 562), + (14359734, 601), + (14360335, 552), + (14360887, 562), + (14361449, 601), + (14362050, 553), + (14362603, 561), + (14363164, 601), + (14363765, 553), + (14364318, 563), + (14364881, 615), + (14365496, 553), + (14366049, 563), + (14366612, 614), + (14367226, 552), + (14367778, 561), + (14368339, 608), + (14368947, 553), + (14369500, 562), + (14370062, 619), + (14370681, 553), + (14371234, 563), + (14371797, 620), + (14372417, 552), + (14372969, 561), + (14373530, 588), + (14374118, 554), + (14374672, 563), + (14375235, 602), + (14375837, 554), + (14376391, 562), + (14376953, 601), + (14377554, 552), + (14378106, 562), + (14378668, 602), + (14379270, 552), + (14379822, 561), + (14380383, 614), + (14380997, 553), + (14381550, 563), + (14382113, 615), + (14382728, 552), + (14383280, 563), + (14383843, 609), + (14384452, 553), + (14385005, 563), + (14385568, 620), + (14386188, 553), + (14386741, 562), + (14387303, 621), + (14387924, 554), + (14388478, 525), + (14389003, 542), + (14389545, 553), + (14390098, 526), + (14390624, 571), + (14391195, 553), + (14391748, 525), + (14392273, 571), + (14392844, 553), + (14393397, 527), + (14393924, 573), + (14394497, 554), + (14395051, 527), + (14395578, 585), + (14396163, 553), + (14396716, 527), + (14397243, 585), + (14397828, 554), + (14398382, 525), + (14398907, 578), + (14399485, 553), + (14400038, 526), + (14400564, 590), + (14401154, 553), + (14401707, 525), + (14402232, 591), + (14402823, 554), + (14403377, 526), + (14403903, 569), + (14404472, 552), + (14405024, 527), + (14405551, 587), + (14406138, 553), + (14406691, 527), + (14407218, 586), + (14407804, 553), + (14408357, 526), + (14408883, 588), + (14409471, 552), + (14410023, 526), + (14410549, 598), + (14411147, 554), + (14411701, 526), + (14412227, 599), + (14412826, 553), + (14413379, 526), + (14413905, 593), + (14414498, 553), + (14415051, 525), + (14415576, 604), + (14416180, 552), + (14416732, 526), + (14417258, 605), + (14417863, 552), + (14418415, 527), + (14418942, 569), + (14419511, 553), + (14420064, 527), + (14420591, 587), + (14421178, 554), + (14421732, 525), + (14422257, 587), + (14422844, 554), + (14423398, 526), + (14423924, 587), + (14424511, 554), + (14425065, 527), + (14425592, 598), + (14426190, 554), + (14426744, 527), + (14427271, 599), + (14427870, 552), + (14428422, 527), + (14428949, 594), + (14429543, 552), + (14430095, 527), + (14430622, 605), + (14431227, 552), + (14431779, 526), + (14432305, 604), + (14432909, 552), + (14433461, 527), + (14433988, 571), + (14434559, 552), + (14435111, 526), + (14435637, 587), + (14436224, 552), + (14436776, 525), + (14437301, 587), + (14437888, 553), + (14438441, 526), + (14438967, 587), + (14439554, 553), + (14440107, 526), + (14440633, 601), + (14441234, 553), + (14441787, 526), + (14442313, 601), + (14442914, 553), + (14443467, 526), + (14443993, 594), + (14444587, 553), + (14445140, 526), + (14445666, 607), + (14446273, 554), + (14446827, 526), + (14447353, 606), + (14447959, 553), + (14448512, 525), + (14449037, 584), + (14449621, 552), + (14450173, 526), + (14450699, 599), + (14451298, 554), + (14451852, 526), + (14452378, 598), + (14452976, 553), + (14453529, 526), + (14454055, 601), + (14454656, 552), + (14455208, 527), + (14455735, 611), + (14456346, 553), + (14456899, 527), + (14457426, 613), + (14458039, 553), + (14458592, 525), + (14459117, 605), + (14459722, 552), + (14460274, 526), + (14460800, 618), + (14461418, 553), + (14461971, 527), + (14462498, 619), + (14463117, 553), + (14463670, 525), + (14464195, 585), + (14464780, 553), + (14465333, 527), + (14465860, 599), + (14466459, 553), + (14467012, 526), + (14467538, 598), + (14468136, 553), + (14468689, 526), + (14469215, 599), + (14469814, 553), + (14470367, 527), + (14470894, 612), + (14471506, 554), + (14472060, 526), + (14472586, 613), + (14473199, 553), + (14473752, 526), + (14474278, 606), + (14474884, 553), + (14475437, 525), + (14475962, 618), + (14476580, 552), + (14477132, 525), + (14477657, 619), + (14478276, 553), + (14478829, 526), + (14479355, 575), + (14479930, 553), + (14480483, 526), + (14481009, 590), + (14481599, 553), + (14482152, 527), + (14482679, 589), + (14483268, 554), + (14483822, 526), + (14484348, 590), + (14484938, 553), + (14485491, 526), + (14486017, 603), + (14486620, 552), + (14487172, 525), + (14487697, 603), + (14488300, 554), + (14488854, 527), + (14489381, 597), + (14489978, 554), + (14490532, 526), + (14491058, 609), + (14491667, 553), + (14492220, 525), + (14492745, 608), + (14493353, 554), + (14493907, 527), + (14494434, 587), + (14495021, 554), + (14495575, 527), + (14496102, 601), + (14496703, 552), + (14497255, 526), + (14497781, 600), + (14498381, 553), + (14498934, 526), + (14499460, 601), + (14500061, 552), + (14500613, 526), + (14501139, 614), + (14501753, 554), + (14502307, 526), + (14502833, 614), + (14503447, 554), + (14504001, 527), + (14504528, 608), + (14505136, 553), + (14505689, 525), + (14506214, 620), + (14506834, 553), + (14507387, 527), + (14507914, 620), + (14508534, 553), + (14509087, 526), + (14509613, 588), + (14510201, 553), + (14510754, 525), + (14511279, 602), + (14511881, 553), + (14512434, 525), + (14512959, 601), + (14513560, 553), + (14514113, 525), + (14514638, 603), + (14515241, 552), + (14515793, 526), + (14516319, 614), + (14516933, 553), + (14517486, 526), + (14518012, 614), + (14518626, 554), + (14519180, 526), + (14519706, 609), + (14520315, 553), + (14520868, 526), + (14521394, 620), + (14522014, 552), + (14522566, 526), + (14523092, 621), + (14523713, 552), + (14524265, 542), + (14524807, 541), + (14525348, 553), + (14525901, 542), + (14526443, 571), + (14527014, 553), + (14527567, 543), + (14528110, 569), + (14528679, 553), + (14529232, 543), + (14529775, 571), + (14530346, 553), + (14530899, 542), + (14531441, 586), + (14532027, 552), + (14532579, 544), + (14533123, 585), + (14533708, 552), + (14534260, 544), + (14534804, 579), + (14535383, 554), + (14535937, 542), + (14536479, 592), + (14537071, 553), + (14537624, 543), + (14538167, 590), + (14538757, 552), + (14539309, 544), + (14539853, 570), + (14540423, 553), + (14540976, 544), + (14541520, 586), + (14542106, 554), + (14542660, 543), + (14543203, 586), + (14543789, 553), + (14544342, 542), + (14544884, 586), + (14545470, 553), + (14546023, 543), + (14546566, 599), + (14547165, 553), + (14547718, 543), + (14548261, 598), + (14548859, 553), + (14549412, 542), + (14549954, 593), + (14550547, 553), + (14551100, 542), + (14551642, 604), + (14552246, 554), + (14552800, 543), + (14553343, 606), + (14553949, 553), + (14554502, 542), + (14555044, 570), + (14555614, 554), + (14556168, 543), + (14556711, 586), + (14557297, 553), + (14557850, 543), + (14558393, 586), + (14558979, 553), + (14559532, 544), + (14560076, 587), + (14560663, 552), + (14561215, 543), + (14561758, 599), + (14562357, 554), + (14562911, 543), + (14563454, 598), + (14564052, 553), + (14564605, 543), + (14565148, 593), + (14565741, 553), + (14566294, 543), + (14566837, 605), + (14567442, 554), + (14567996, 543), + (14568539, 605), + (14569144, 554), + (14569698, 543), + (14570241, 572), + (14570813, 553), + (14571366, 543), + (14571909, 587), + (14572496, 552), + (14573048, 543), + (14573591, 587), + (14574178, 552), + (14574730, 542), + (14575272, 587), + (14575859, 554), + (14576413, 542), + (14576955, 600), + (14577555, 552), + (14578107, 542), + (14578649, 600), + (14579249, 553), + (14579802, 543), + (14580345, 593), + (14580938, 553), + (14581491, 543), + (14582034, 606), + (14582640, 553), + (14583193, 543), + (14583736, 606), + (14584342, 554), + (14584896, 542), + (14585438, 586), + (14586024, 552), + (14586576, 543), + (14587119, 599), + (14587718, 553), + (14588271, 543), + (14588814, 599), + (14589413, 552), + (14589965, 543), + (14590508, 600), + (14591108, 553), + (14591661, 544), + (14592205, 613), + (14592818, 553), + (14593371, 542), + (14593913, 612), + (14594525, 553), + (14595078, 542), + (14595620, 607), + (14596227, 553), + (14596780, 544), + (14597324, 618), + (14597942, 554), + (14598496, 542), + (14599038, 618), + (14599656, 553), + (14600209, 542), + (14600751, 586), + (14601337, 552), + (14601889, 544), + (14602433, 600), + (14603033, 553), + (14603586, 544), + (14604130, 598), + (14604728, 552), + (14605280, 544), + (14605824, 600), + (14606424, 552), + (14606976, 543), + (14607519, 612), + (14608131, 553), + (14608684, 544), + (14609228, 612), + (14609840, 554), + (14610394, 543), + (14610937, 607), + (14611544, 553), + (14612097, 543), + (14612640, 617), + (14613257, 552), + (14613809, 544), + (14614353, 617), + (14614970, 554), + (14615524, 542), + (14616066, 576), + (14616642, 554), + (14617196, 542), + (14617738, 587), + (14618325, 553), + (14618878, 544), + (14619422, 589), + (14620011, 553), + (14620564, 542), + (14621106, 591), + (14621697, 553), + (14622250, 544), + (14622794, 602), + (14623396, 553), + (14623949, 543), + (14624492, 602), + (14625094, 553), + (14625647, 542), + (14626189, 596), + (14626785, 554), + (14627339, 543), + (14627882, 607), + (14628489, 553), + (14629042, 544), + (14629586, 609), + (14630195, 553), + (14630748, 544), + (14631292, 588), + (14631880, 553), + (14632433, 544), + (14632977, 600), + (14633577, 554), + (14634131, 542), + (14634673, 601), + (14635274, 553), + (14635827, 543), + (14636370, 601), + (14636971, 553), + (14637524, 542), + (14638066, 613), + (14638679, 552), + (14639231, 544), + (14639775, 614), + (14640389, 554), + (14640943, 543), + (14641486, 607), + (14642093, 553), + (14642646, 544), + (14643190, 620), + (14643810, 552), + (14644362, 543), + (14644905, 620), + (14645525, 553), + (14646078, 543), + (14646621, 587), + (14647208, 554), + (14647762, 543), + (14648305, 601), + (14648906, 552), + (14649458, 542), + (14650000, 602), + (14650602, 553), + (14651155, 543), + (14651698, 601), + (14652299, 553), + (14652852, 542), + (14653394, 614), + (14654008, 553), + (14654561, 542), + (14655103, 614), + (14655717, 552), + (14656269, 544), + (14656813, 608), + (14657421, 553), + (14657974, 543), + (14658517, 620), + (14659137, 554), + (14659691, 544), + (14660235, 621), + (14660856, 553), + (14661409, 544), + (14661953, 542), + (14662495, 553), + (14663048, 543), + (14663591, 569), + (14664160, 553), + (14664713, 543), + (14665256, 569), + (14665825, 552), + (14666377, 544), + (14666921, 573), + (14667494, 554), + (14668048, 543), + (14668591, 586), + (14669177, 552), + (14669729, 543), + (14670272, 584), + (14670856, 554), + (14671410, 544), + (14671954, 579), + (14672533, 553), + (14673086, 543), + (14673629, 592), + (14674221, 552), + (14674773, 543), + (14675316, 591), + (14675907, 554), + (14676461, 544), + (14677005, 569), + (14677574, 553), + (14678127, 544), + (14678671, 587), + (14679258, 553), + (14679811, 544), + (14680355, 586), + (14680941, 553), + (14681494, 543), + (14682037, 587), + (14682624, 553), + (14683177, 542), + (14683719, 598), + (14684317, 552), + (14684869, 542), + (14685411, 600), + (14686011, 552), + (14686563, 543), + (14687106, 594), + (14687700, 552), + (14688252, 542), + (14688794, 605), + (14689399, 553), + (14689952, 544), + (14690496, 605), + (14691101, 554), + (14691655, 543), + (14692198, 570), + (14692768, 554), + (14693322, 544), + (14693866, 586), + (14694452, 553), + (14695005, 543), + (14695548, 587), + (14696135, 553), + (14696688, 544), + (14697232, 587), + (14697819, 552), + (14698371, 542), + (14698913, 599), + (14699512, 552), + (14700064, 544), + (14700608, 598), + (14701206, 553), + (14701759, 543), + (14702302, 592), + (14702894, 553), + (14703447, 543), + (14703990, 605), + (14704595, 553), + (14705148, 542), + (14705690, 605), + (14706295, 553), + (14706848, 543), + (14707391, 571), + (14707962, 553), + (14708515, 542), + (14709057, 587), + (14709644, 553), + (14710197, 544), + (14710741, 587), + (14711328, 552), + (14711880, 543), + (14712423, 587), + (14713010, 553), + (14713563, 544), + (14714107, 600), + (14714707, 553), + (14715260, 543), + (14715803, 600), + (14716403, 552), + (14716955, 543), + (14717498, 593), + (14718091, 552), + (14718643, 544), + (14719187, 606), + (14719793, 554), + (14720347, 543), + (14720890, 606), + (14721496, 554), + (14722050, 544), + (14722594, 584), + (14723178, 552), + (14723730, 543), + (14724273, 600), + (14724873, 554), + (14725427, 544), + (14725971, 599), + (14726570, 553), + (14727123, 544), + (14727667, 600), + (14728267, 554), + (14728821, 544), + (14729365, 612), + (14729977, 552), + (14730529, 542), + (14731071, 611), + (14731682, 554), + (14732236, 544), + (14732780, 606), + (14733386, 553), + (14733939, 542), + (14734481, 618), + (14735099, 554), + (14735653, 543), + (14736196, 619), + (14736815, 554), + (14737369, 544), + (14737913, 584), + (14738497, 554), + (14739051, 544), + (14739595, 599), + (14740194, 552), + (14740746, 543), + (14741289, 599), + (14741888, 554), + (14742442, 542), + (14742984, 600), + (14743584, 554), + (14744138, 542), + (14744680, 612), + (14745292, 553), + (14745845, 543), + (14746388, 613), + (14747001, 552), + (14747553, 544), + (14748097, 606), + (14748703, 553), + (14749256, 543), + (14749799, 619), + (14750418, 552), + (14750970, 544), + (14751514, 617), + (14752131, 553), + (14752684, 544), + (14753228, 574), + (14753802, 554), + (14754356, 543), + (14754899, 589), + (14755488, 553), + (14756041, 544), + (14756585, 589), + (14757174, 552), + (14757726, 542), + (14758268, 590), + (14758858, 553), + (14759411, 543), + (14759954, 601), + (14760555, 553), + (14761108, 544), + (14761652, 603), + (14762255, 552), + (14762807, 543), + (14763350, 597), + (14763947, 554), + (14764501, 542), + (14765043, 609), + (14765652, 553), + (14766205, 543), + (14766748, 609), + (14767357, 553), + (14767910, 543), + (14768453, 588), + (14769041, 553), + (14769594, 542), + (14770136, 601), + (14770737, 552), + (14771289, 543), + (14771832, 601), + (14772433, 553), + (14772986, 543), + (14773529, 602), + (14774131, 554), + (14774685, 544), + (14775229, 615), + (14775844, 553), + (14776397, 544), + (14776941, 613), + (14777554, 554), + (14778108, 544), + (14778652, 608), + (14779260, 553), + (14779813, 543), + (14780356, 621), + (14780977, 554), + (14781531, 542), + (14782073, 620), + (14782693, 552), + (14783245, 544), + (14783789, 588), + (14784377, 552), + (14784929, 543), + (14785472, 602), + (14786074, 552), + (14786626, 542), + (14787168, 602), + (14787770, 552), + (14788322, 542), + (14788864, 602), + (14789466, 553), + (14790019, 544), + (14790563, 614), + (14791177, 552), + (14791729, 543), + (14792272, 615), + (14792887, 553), + (14793440, 542), + (14793982, 607), + (14794589, 553), + (14795142, 543), + (14795685, 619), + (14796304, 552), + (14796856, 544), + (14797400, 621), + (14798021, 552), + (14798573, 553), + (14799126, 542), + (14799668, 553), + (14800221, 553), + (14800774, 569), + (14801343, 554), + (14801897, 553), + (14802450, 569), + (14803019, 553), + (14803572, 553), + (14804125, 572), + (14804697, 553), + (14805250, 553), + (14805803, 585), + (14806388, 554), + (14806942, 553), + (14807495, 585), + (14808080, 553), + (14808633, 553), + (14809186, 579), + (14809765, 554), + (14810319, 554), + (14810873, 591), + (14811464, 554), + (14812018, 552), + (14812570, 591), + (14813161, 553), + (14813714, 552), + (14814266, 569), + (14814835, 553), + (14815388, 553), + (14815941, 587), + (14816528, 554), + (14817082, 553), + (14817635, 585), + (14818220, 552), + (14818772, 554), + (14819326, 588), + (14819914, 554), + (14820468, 553), + (14821021, 598), + (14821619, 554), + (14822173, 554), + (14822727, 599), + (14823326, 553), + (14823879, 553), + (14824432, 593), + (14825025, 553), + (14825578, 553), + (14826131, 604), + (14826735, 552), + (14827287, 553), + (14827840, 606), + (14828446, 553), + (14828999, 553), + (14829552, 571), + (14830123, 554), + (14830677, 553), + (14831230, 586), + (14831816, 553), + (14832369, 554), + (14832923, 587), + (14833510, 553), + (14834063, 553), + (14834616, 587), + (14835203, 553), + (14835756, 552), + (14836308, 598), + (14836906, 553), + (14837459, 552), + (14838011, 599), + (14838610, 554), + (14839164, 554), + (14839718, 592), + (14840310, 554), + (14840864, 552), + (14841416, 604), + (14842020, 554), + (14842574, 553), + (14843127, 605), + (14843732, 553), + (14844285, 554), + (14844839, 571), + (14845410, 552), + (14845962, 552), + (14846514, 586), + (14847100, 553), + (14847653, 554), + (14848207, 587), + (14848794, 553), + (14849347, 552), + (14849899, 588), + (14850487, 554), + (14851041, 554), + (14851595, 601), + (14852196, 554), + (14852750, 553), + (14853303, 600), + (14853903, 554), + (14854457, 554), + (14855011, 594), + (14855605, 552), + (14856157, 553), + (14856710, 607), + (14857317, 552), + (14857869, 553), + (14858422, 607), + (14859029, 554), + (14859583, 554), + (14860137, 586), + (14860723, 554), + (14861277, 554), + (14861831, 600), + (14862431, 552), + (14862983, 553), + (14863536, 599), + (14864135, 554), + (14864689, 554), + (14865243, 600), + (14865843, 554), + (14866397, 553), + (14866950, 612), + (14867562, 553), + (14868115, 552), + (14868667, 612), + (14869279, 552), + (14869831, 553), + (14870384, 606), + (14870990, 553), + (14871543, 553), + (14872096, 617), + (14872713, 554), + (14873267, 552), + (14873819, 619), + (14874438, 553), + (14874991, 552), + (14875543, 584), + (14876127, 552), + (14876679, 552), + (14877231, 599), + (14877830, 552), + (14878382, 553), + (14878935, 598), + (14879533, 552), + (14880085, 553), + (14880638, 600), + (14881238, 553), + (14881791, 553), + (14882344, 612), + (14882956, 552), + (14883508, 552), + (14884060, 612), + (14884672, 553), + (14885225, 554), + (14885779, 605), + (14886384, 552), + (14886936, 553), + (14887489, 619), + (14888108, 554), + (14888662, 554), + (14889216, 618), + (14889834, 553), + (14890387, 554), + (14890941, 575), + (14891516, 554), + (14892070, 553), + (14892623, 590), + (14893213, 553), + (14893766, 553), + (14894319, 589), + (14894908, 554), + (14895462, 552), + (14896014, 591), + (14896605, 554), + (14897159, 552), + (14897711, 601), + (14898312, 554), + (14898866, 554), + (14899420, 602), + (14900022, 554), + (14900576, 554), + (14901130, 597), + (14901727, 553), + (14902280, 552), + (14902832, 609), + (14903441, 554), + (14903995, 553), + (14904548, 607), + (14905155, 553), + (14905708, 553), + (14906261, 587), + (14906848, 553), + (14907401, 553), + (14907954, 602), + (14908556, 552), + (14909108, 553), + (14909661, 601), + (14910262, 553), + (14910815, 552), + (14911367, 603), + (14911970, 553), + (14912523, 552), + (14913075, 614), + (14913689, 552), + (14914241, 552), + (14914793, 615), + (14915408, 553), + (14915961, 553), + (14916514, 607), + (14917121, 553), + (14917674, 553), + (14918227, 620), + (14918847, 553), + (14919400, 553), + (14919953, 619), + (14920572, 554), + (14921126, 553), + (14921679, 586), + (14922265, 553), + (14922818, 553), + (14923371, 602), + (14923973, 553), + (14924526, 553), + (14925079, 601), + (14925680, 554), + (14926234, 553), + (14926787, 602), + (14927389, 553), + (14927942, 553), + (14928495, 613), + (14929108, 553), + (14929661, 553), + (14930214, 614), + (14930828, 552), + (14931380, 553), + (14931933, 607), + (14932540, 552), + (14933092, 553), + (14933645, 620), + (14934265, 554), + (14934819, 554), + (14935373, 620), + (14935993, 554), + (14936547, 559), + (14937106, 541), + (14937647, 553), + (14938200, 558), + (14938758, 569), + (14939327, 553), + (14939880, 559), + (14940439, 570), + (14941009, 553), + (14941562, 559), + (14942121, 572), + (14942693, 552), + (14943245, 558), + (14943803, 584), + (14944387, 553), + (14944940, 559), + (14945499, 586), + (14946085, 554), + (14946639, 559), + (14947198, 579), + (14947777, 552), + (14948329, 559), + (14948888, 591), + (14949479, 553), + (14950032, 558), + (14950590, 592), + (14951182, 553), + (14951735, 558), + (14952293, 570), + (14952863, 553), + (14953416, 559), + (14953975, 586), + (14954561, 553), + (14955114, 560), + (14955674, 587), + (14956261, 553), + (14956814, 559), + (14957373, 587), + (14957960, 553), + (14958513, 560), + (14959073, 600), + (14959673, 553), + (14960226, 558), + (14960784, 599), + (14961383, 553), + (14961936, 558), + (14962494, 593), + (14963087, 553), + (14963640, 559), + (14964199, 605), + (14964804, 553), + (14965357, 559), + (14965916, 606), + (14966522, 552), + (14967074, 559), + (14967633, 570), + (14968203, 554), + (14968757, 558), + (14969315, 587), + (14969902, 553), + (14970455, 559), + (14971014, 586), + (14971600, 553), + (14972153, 559), + (14972712, 587), + (14973299, 553), + (14973852, 558), + (14974410, 598), + (14975008, 554), + (14975562, 559), + (14976121, 600), + (14976721, 553), + (14977274, 560), + (14977834, 594), + (14978428, 554), + (14978982, 560), + (14979542, 606), + (14980148, 553), + (14980701, 560), + (14981261, 606), + (14981867, 552), + (14982419, 558), + (14982977, 572), + (14983549, 553), + (14984102, 560), + (14984662, 587), + (14985249, 552), + (14985801, 559), + (14986360, 588), + (14986948, 552), + (14987500, 560), + (14988060, 588), + (14988648, 552), + (14989200, 559), + (14989759, 599), + (14990358, 552), + (14990910, 560), + (14991470, 600), + (14992070, 553), + (14992623, 560), + (14993183, 593), + (14993776, 552), + (14994328, 560), + (14994888, 605), + (14995493, 554), + (14996047, 559), + (14996606, 606), + (14997212, 554), + (14997766, 558), + (14998324, 585), + (14998909, 553), + (14999462, 559), + (15000021, 599), + (15000620, 552), + (15001172, 559), + (15001731, 599), + (15002330, 553), + (15002883, 559), + (15003442, 599), + (15004041, 553), + (15004594, 559), + (15005153, 612), + (15005765, 553), + (15006318, 559), + (15006877, 611), + (15007488, 552), + (15008040, 560), + (15008600, 607), + (15009207, 553), + (15009760, 558), + (15010318, 618), + (15010936, 553), + (15011489, 560), + (15012049, 619), + (15012668, 554), + (15013222, 559), + (15013781, 585), + (15014366, 554), + (15014920, 559), + (15015479, 598), + (15016077, 552), + (15016629, 560), + (15017189, 599), + (15017788, 553), + (15018341, 559), + (15018900, 599), + (15019499, 553), + (15020052, 559), + (15020611, 612), + (15021223, 553), + (15021776, 558), + (15022334, 612), + (15022946, 553), + (15023499, 558), + (15024057, 605), + (15024662, 554), + (15025216, 559), + (15025775, 618), + (15026393, 553), + (15026946, 560), + (15027506, 618), + (15028124, 553), + (15028677, 559), + (15029236, 574), + (15029810, 552), + (15030362, 559), + (15030921, 589), + (15031510, 552), + (15032062, 559), + (15032621, 589), + (15033210, 553), + (15033763, 560), + (15034323, 590), + (15034913, 553), + (15035466, 559), + (15036025, 602), + (15036627, 552), + (15037179, 559), + (15037738, 601), + (15038339, 552), + (15038891, 559), + (15039450, 595), + (15040045, 552), + (15040597, 559), + (15041156, 607), + (15041763, 554), + (15042317, 560), + (15042877, 608), + (15043485, 553), + (15044038, 559), + (15044597, 588), + (15045185, 553), + (15045738, 558), + (15046296, 602), + (15046898, 554), + (15047452, 558), + (15048010, 602), + (15048612, 552), + (15049164, 559), + (15049723, 602), + (15050325, 554), + (15050879, 559), + (15051438, 615), + (15052053, 553), + (15052606, 560), + (15053166, 614), + (15053780, 552), + (15054332, 560), + (15054892, 608), + (15055500, 553), + (15056053, 559), + (15056612, 621), + (15057233, 554), + (15057787, 558), + (15058345, 620), + (15058965, 553), + (15059518, 560), + (15060078, 587), + (15060665, 552), + (15061217, 559), + (15061776, 602), + (15062378, 552), + (15062930, 560), + (15063490, 602), + (15064092, 554), + (15064646, 560), + (15065206, 603), + (15065809, 554), + (15066363, 559), + (15066922, 614), + (15067536, 554), + (15068090, 559), + (15068649, 615), + (15069264, 553), + (15069817, 558), + (15070375, 609), + (15070984, 552), + (15071536, 558), + (15072094, 620), + (15072714, 552), + (15073266, 559), + (15073825, 619), + (15074444, 553), + (15074997, 560), + (15075557, 541), + (15076098, 552), + (15076650, 560), + (15077210, 571), + (15077781, 554), + (15078335, 557), + (15078892, 570), + (15079462, 554), + (15080016, 558), + (15080574, 573), + (15081147, 554), + (15081701, 559), + (15082260, 586), + (15082846, 553), + (15083399, 559), + (15083958, 585), + (15084543, 553), + (15085096, 560), + (15085656, 579), + (15086235, 553), + (15086788, 559), + (15087347, 591), + (15087938, 554), + (15088492, 559), + (15089051, 590), + (15089641, 552), + (15090193, 559), + (15090752, 570), + (15091322, 554), + (15091876, 558), + (15092434, 585), + (15093019, 553), + (15093572, 559), + (15094131, 586), + (15094717, 552), + (15095269, 560), + (15095829, 587), + (15096416, 553), + (15096969, 558), + (15097527, 599), + (15098126, 552), + (15098678, 560), + (15099238, 600), + (15099838, 554), + (15100392, 559), + (15100951, 594), + (15101545, 552), + (15102097, 558), + (15102655, 604), + (15103259, 553), + (15103812, 558), + (15104370, 605), + (15104975, 553), + (15105528, 559), + (15106087, 569), + (15106656, 552), + (15107208, 559), + (15107767, 587), + (15108354, 554), + (15108908, 559), + (15109467, 585), + (15110052, 554), + (15110606, 558), + (15111164, 588), + (15111752, 552), + (15112304, 558), + (15112862, 598), + (15113460, 554), + (15114014, 558), + (15114572, 600), + (15115172, 554), + (15115726, 558), + (15116284, 592), + (15116876, 552), + (15117428, 559), + (15117987, 604), + (15118591, 552), + (15119143, 560), + (15119703, 604), + (15120307, 553), + (15120860, 559), + (15121419, 572), + (15121991, 554), + (15122545, 560), + (15123105, 587), + (15123692, 552), + (15124244, 559), + (15124803, 587), + (15125390, 552), + (15125942, 559), + (15126501, 587), + (15127088, 553), + (15127641, 558), + (15128199, 600), + (15128799, 553), + (15129352, 558), + (15129910, 601), + (15130511, 552), + (15131063, 559), + (15131622, 594), + (15132216, 553), + (15132769, 559), + (15133328, 607), + (15133935, 554), + (15134489, 560), + (15135049, 606), + (15135655, 553), + (15136208, 559), + (15136767, 585), + (15137352, 552), + (15137904, 560), + (15138464, 599), + (15139063, 553), + (15139616, 560), + (15140176, 599), + (15140775, 552), + (15141327, 559), + (15141886, 601), + (15142487, 552), + (15143039, 559), + (15143598, 613), + (15144211, 553), + (15144764, 559), + (15145323, 612), + (15145935, 553), + (15146488, 559), + (15147047, 606), + (15147653, 553), + (15148206, 559), + (15148765, 618), + (15149383, 552), + (15149935, 559), + (15150494, 618), + (15151112, 553), + (15151665, 560), + (15152225, 584), + (15152809, 553), + (15153362, 558), + (15153920, 600), + (15154520, 554), + (15155074, 560), + (15155634, 600), + (15156234, 553), + (15156787, 559), + (15157346, 601), + (15157947, 554), + (15158501, 559), + (15159060, 611), + (15159671, 552), + (15160223, 560), + (15160783, 611), + (15161394, 553), + (15161947, 558), + (15162505, 607), + (15163112, 553), + (15163665, 559), + (15164224, 619), + (15164843, 553), + (15165396, 558), + (15165954, 619), + (15166573, 553), + (15167126, 560), + (15167686, 575), + (15168261, 554), + (15168815, 559), + (15169374, 590), + (15169964, 553), + (15170517, 559), + (15171076, 590), + (15171666, 552), + (15172218, 559), + (15172777, 590), + (15173367, 552), + (15173919, 559), + (15174478, 602), + (15175080, 553), + (15175633, 559), + (15176192, 602), + (15176794, 552), + (15177346, 560), + (15177906, 595), + (15178501, 553), + (15179054, 560), + (15179614, 609), + (15180223, 553), + (15180776, 559), + (15181335, 608), + (15181943, 554), + (15182497, 558), + (15183055, 586), + (15183641, 553), + (15184194, 560), + (15184754, 601), + (15185355, 554), + (15185909, 560), + (15186469, 600), + (15187069, 553), + (15187622, 559), + (15188181, 602), + (15188783, 553), + (15189336, 559), + (15189895, 613), + (15190508, 553), + (15191061, 560), + (15191621, 614), + (15192235, 554), + (15192789, 559), + (15193348, 608), + (15193956, 553), + (15194509, 558), + (15195067, 621), + (15195688, 553), + (15196241, 559), + (15196800, 621), + (15197421, 553), + (15197974, 559), + (15198533, 587), + (15199120, 553), + (15199673, 560), + (15200233, 600), + (15200833, 553), + (15201386, 560), + (15201946, 602), + (15202548, 553), + (15203101, 559), + (15203660, 602), + (15204262, 553), + (15204815, 560), + (15205375, 613), + (15205988, 553), + (15206541, 558), + (15207099, 614), + (15207713, 553), + (15208266, 560), + (15208826, 608), + (15209434, 552), + (15209986, 560), + (15210546, 620), + (15211166, 553), + (15211719, 560), + (15212279, 620), + (15212899, 553), + (15213452, 553), + (15214005, 542), + (15214547, 554), + (15215101, 553), + (15215654, 570), + (15216224, 553), + (15216777, 554), + (15217331, 569), + (15217900, 554), + (15218454, 554), + (15219008, 572), + (15219580, 552), + (15220132, 554), + (15220686, 584), + (15221270, 553), + (15221823, 553), + (15222376, 585), + (15222961, 552), + (15223513, 554), + (15224067, 580), + (15224647, 553), + (15225200, 554), + (15225754, 591), + (15226345, 553), + (15226898, 555), + (15227453, 591), + (15228044, 552), + (15228596, 554), + (15229150, 569), + (15229719, 554), + (15230273, 553), + (15230826, 587), + (15231413, 554), + (15231967, 554), + (15232521, 586), + (15233107, 554), + (15233661, 554), + (15234215, 587), + (15234802, 553), + (15235355, 554), + (15235909, 600), + (15236509, 553), + (15237062, 554), + (15237616, 599), + (15238215, 554), + (15238769, 553), + (15239322, 594), + (15239916, 553), + (15240469, 554), + (15241023, 606), + (15241629, 553), + (15242182, 555), + (15242737, 604), + (15243341, 552), + (15243893, 555), + (15244448, 570), + (15245018, 553), + (15245571, 554), + (15246125, 585), + (15246710, 553), + (15247263, 555), + (15247818, 586), + (15248404, 553), + (15248957, 555), + (15249512, 587), + (15250099, 554), + (15250653, 554), + (15251207, 600), + (15251807, 553), + (15252360, 553), + (15252913, 599), + (15253512, 552), + (15254064, 554), + (15254618, 592), + (15255210, 552), + (15255762, 554), + (15256316, 605), + (15256921, 554), + (15257475, 554), + (15258029, 604), + (15258633, 554), + (15259187, 553), + (15259740, 573), + (15260313, 553), + (15260866, 553), + (15261419, 587), + (15262006, 553), + (15262559, 553), + (15263112, 587), + (15263699, 553), + (15264252, 555), + (15264807, 587), + (15265394, 553), + (15265947, 554), + (15266501, 600), + (15267101, 552), + (15267653, 554), + (15268207, 600), + (15268807, 552), + (15269359, 555), + (15269914, 594), + (15270508, 553), + (15271061, 554), + (15271615, 606), + (15272221, 552), + (15272773, 553), + (15273326, 607), + (15273933, 553), + (15274486, 554), + (15275040, 585), + (15275625, 552), + (15276177, 554), + (15276731, 598), + (15277329, 554), + (15277883, 554), + (15278437, 598), + (15279035, 552), + (15279587, 553), + (15280140, 600), + (15280740, 553), + (15281293, 555), + (15281848, 612), + (15282460, 553), + (15283013, 555), + (15283568, 612), + (15284180, 553), + (15284733, 553), + (15285286, 605), + (15285891, 553), + (15286444, 554), + (15286998, 618), + (15287616, 553), + (15288169, 553), + (15288722, 617), + (15289339, 553), + (15289892, 554), + (15290446, 585), + (15291031, 552), + (15291583, 554), + (15292137, 599), + (15292736, 553), + (15293289, 553), + (15293842, 599), + (15294441, 554), + (15294995, 553), + (15295548, 598), + (15296146, 552), + (15296698, 555), + (15297253, 611), + (15297864, 552), + (15298416, 554), + (15298970, 613), + (15299583, 553), + (15300136, 553), + (15300689, 606), + (15301295, 553), + (15301848, 554), + (15302402, 618), + (15303020, 552), + (15303572, 554), + (15304126, 617), + (15304743, 552), + (15305295, 554), + (15305849, 574), + (15306423, 552), + (15306975, 554), + (15307529, 590), + (15308119, 552), + (15308671, 553), + (15309224, 589), + (15309813, 553), + (15310366, 555), + (15310921, 590), + (15311511, 553), + (15312064, 554), + (15312618, 603), + (15313221, 553), + (15313774, 554), + (15314328, 602), + (15314930, 553), + (15315483, 554), + (15316037, 596), + (15316633, 553), + (15317186, 555), + (15317741, 608), + (15318349, 553), + (15318902, 555), + (15319457, 607), + (15320064, 552), + (15320616, 554), + (15321170, 587), + (15321757, 553), + (15322310, 555), + (15322865, 601), + (15323466, 552), + (15324018, 554), + (15324572, 601), + (15325173, 553), + (15325726, 554), + (15326280, 602), + (15326882, 554), + (15327436, 554), + (15327990, 614), + (15328604, 553), + (15329157, 553), + (15329710, 613), + (15330323, 553), + (15330876, 554), + (15331430, 609), + (15332039, 552), + (15332591, 554), + (15333145, 621), + (15333766, 554), + (15334320, 554), + (15334874, 620), + (15335494, 554), + (15336048, 553), + (15336601, 586), + (15337187, 553), + (15337740, 555), + (15338295, 601), + (15338896, 553), + (15339449, 554), + (15340003, 601), + (15340604, 553), + (15341157, 554), + (15341711, 602), + (15342313, 553), + (15342866, 555), + (15343421, 614), + (15344035, 553), + (15344588, 554), + (15345142, 614), + (15345756, 553), + (15346309, 554), + (15346863, 607), + (15347470, 554), + (15348024, 553), + (15348577, 620), + (15349197, 554), + (15349751, 553), + (15350304, 620), + (15350924, 553), + (15351477, 561), + (15352038, 541), + (15352579, 554), + (15353133, 561), + (15353694, 571), + (15354265, 553), + (15354818, 560), + (15355378, 571), + (15355949, 554), + (15356503, 561), + (15357064, 571), + (15357635, 554), + (15358189, 561), + (15358750, 585), + (15359335, 553), + (15359888, 560), + (15360448, 585), + (15361033, 552), + (15361585, 559), + (15362144, 579), + (15362723, 553), + (15363276, 560), + (15363836, 591), + (15364427, 554), + (15364981, 560), + (15365541, 591), + (15366132, 554), + (15366686, 560), + (15367246, 571), + (15367817, 552), + (15368369, 560), + (15368929, 586), + (15369515, 553), + (15370068, 560), + (15370628, 586), + (15371214, 553), + (15371767, 560), + (15372327, 587), + (15372914, 553), + (15373467, 560), + (15374027, 600), + (15374627, 554), + (15375181, 560), + (15375741, 599), + (15376340, 553), + (15376893, 559), + (15377452, 593), + (15378045, 554), + (15378599, 561), + (15379160, 605), + (15379765, 552), + (15380317, 560), + (15380877, 605), + (15381482, 553), + (15382035, 559), + (15382594, 570), + (15383164, 553), + (15383717, 559), + (15384276, 586), + (15384862, 553), + (15385415, 561), + (15385976, 586), + (15386562, 553), + (15387115, 559), + (15387674, 588), + (15388262, 553), + (15388815, 560), + (15389375, 600), + (15389975, 552), + (15390527, 561), + (15391088, 599), + (15391687, 553), + (15392240, 561), + (15392801, 594), + (15393395, 552), + (15393947, 560), + (15394507, 606), + (15395113, 554), + (15395667, 560), + (15396227, 605), + (15396832, 553), + (15397385, 560), + (15397945, 571), + (15398516, 553), + (15399069, 561), + (15399630, 586), + (15400216, 553), + (15400769, 560), + (15401329, 587), + (15401916, 553), + (15402469, 561), + (15403030, 588), + (15403618, 552), + (15404170, 560), + (15404730, 600), + (15405330, 554), + (15405884, 561), + (15406445, 601), + (15407046, 552), + (15407598, 560), + (15408158, 594), + (15408752, 552), + (15409304, 559), + (15409863, 606), + (15410469, 552), + (15411021, 561), + (15411582, 606), + (15412188, 553), + (15412741, 560), + (15413301, 584), + (15413885, 552), + (15414437, 561), + (15414998, 599), + (15415597, 553), + (15416150, 561), + (15416711, 600), + (15417311, 554), + (15417865, 559), + (15418424, 601), + (15419025, 552), + (15419577, 559), + (15420136, 612), + (15420748, 554), + (15421302, 560), + (15421862, 612), + (15422474, 554), + (15423028, 559), + (15423587, 606), + (15424193, 554), + (15424747, 560), + (15425307, 619), + (15425926, 553), + (15426479, 560), + (15427039, 618), + (15427657, 553), + (15428210, 560), + (15428770, 584), + (15429354, 554), + (15429908, 559), + (15430467, 599), + (15431066, 553), + (15431619, 560), + (15432179, 599), + (15432778, 554), + (15433332, 561), + (15433893, 601), + (15434494, 554), + (15435048, 560), + (15435608, 611), + (15436219, 553), + (15436772, 560), + (15437332, 613), + (15437945, 553), + (15438498, 560), + (15439058, 606), + (15439664, 552), + (15440216, 560), + (15440776, 618), + (15441394, 553), + (15441947, 560), + (15442507, 619), + (15443126, 554), + (15443680, 561), + (15444241, 575), + (15444816, 553), + (15445369, 560), + (15445929, 589), + (15446518, 554), + (15447072, 560), + (15447632, 588), + (15448220, 553), + (15448773, 560), + (15449333, 589), + (15449922, 553), + (15450475, 561), + (15451036, 602), + (15451638, 553), + (15452191, 560), + (15452751, 603), + (15453354, 553), + (15453907, 561), + (15454468, 596), + (15455064, 552), + (15455616, 559), + (15456175, 608), + (15456783, 553), + (15457336, 559), + (15457895, 607), + (15458502, 554), + (15459056, 561), + (15459617, 588), + (15460205, 553), + (15460758, 559), + (15461317, 602), + (15461919, 553), + (15462472, 559), + (15463031, 600), + (15463631, 552), + (15464183, 560), + (15464743, 602), + (15465345, 554), + (15465899, 560), + (15466459, 613), + (15467072, 554), + (15467626, 560), + (15468186, 614), + (15468800, 552), + (15469352, 560), + (15469912, 608), + (15470520, 552), + (15471072, 559), + (15471631, 620), + (15472251, 554), + (15472805, 560), + (15473365, 620), + (15473985, 554), + (15474539, 560), + (15475099, 587), + (15475686, 552), + (15476238, 560), + (15476798, 601), + (15477399, 553), + (15477952, 559), + (15478511, 601), + (15479112, 553), + (15479665, 560), + (15480225, 603), + (15480828, 553), + (15481381, 561), + (15481942, 613), + (15482555, 554), + (15483109, 561), + (15483670, 614), + (15484284, 553), + (15484837, 561), + (15485398, 607), + (15486005, 553), + (15486558, 561), + (15487119, 620), + (15487739, 552), + (15488291, 560), + (15488851, 620), + (15489471, 553), + (15490024, 559), + (15490583, 543), + (15491126, 554), + (15491680, 561), + (15492241, 571), + (15492812, 553), + (15493365, 561), + (15493926, 569), + (15494495, 553), + (15495048, 559), + (15495607, 572), + (15496179, 554), + (15496733, 559), + (15497292, 584), + (15497876, 552), + (15498428, 561), + (15498989, 585), + (15499574, 553), + (15500127, 560), + (15500687, 578), + (15501265, 553), + (15501818, 559), + (15502377, 590), + (15502967, 553), + (15503520, 560), + (15504080, 591), + (15504671, 553), + (15505224, 560), + (15505784, 570), + (15506354, 553), + (15506907, 559), + (15507466, 587), + (15508053, 553), + (15508606, 560), + (15509166, 586), + (15509752, 553), + (15510305, 559), + (15510864, 587), + (15511451, 553), + (15512004, 561), + (15512565, 598), + (15513163, 553), + (15513716, 560), + (15514276, 599), + (15514875, 553), + (15515428, 560), + (15515988, 592), + (15516580, 553), + (15517133, 560), + (15517693, 606), + (15518299, 552), + (15518851, 561), + (15519412, 605), + (15520017, 554), + (15520571, 561), + (15521132, 571), + (15521703, 552), + (15522255, 561), + (15522816, 586), + (15523402, 554), + (15523956, 561), + (15524517, 586), + (15525103, 554), + (15525657, 560), + (15526217, 588), + (15526805, 553), + (15527358, 560), + (15527918, 598), + (15528516, 553), + (15529069, 560), + (15529629, 598), + (15530227, 553), + (15530780, 560), + (15531340, 593), + (15531933, 554), + (15532487, 560), + (15533047, 606), + (15533653, 553), + (15534206, 560), + (15534766, 605), + (15535371, 552), + (15535923, 560), + (15536483, 571), + (15537054, 552), + (15537606, 560), + (15538166, 588), + (15538754, 552), + (15539306, 559), + (15539865, 587), + (15540452, 553), + (15541005, 559), + (15541564, 588), + (15542152, 554), + (15542706, 560), + (15543266, 600), + (15543866, 553), + (15544419, 561), + (15544980, 601), + (15545581, 554), + (15546135, 560), + (15546695, 594), + (15547289, 553), + (15547842, 559), + (15548401, 605), + (15549006, 554), + (15549560, 560), + (15550120, 606), + (15550726, 553), + (15551279, 559), + (15551838, 585), + (15552423, 553), + (15552976, 561), + (15553537, 598), + (15554135, 554), + (15554689, 559), + (15555248, 599), + (15555847, 552), + (15556399, 561), + (15556960, 600), + (15557560, 552), + (15558112, 559), + (15558671, 612), + (15559283, 552), + (15559835, 560), + (15560395, 612), + (15561007, 554), + (15561561, 560), + (15562121, 606), + (15562727, 552), + (15563279, 561), + (15563840, 618), + (15564458, 553), + (15565011, 559), + (15565570, 618), + (15566188, 552), + (15566740, 561), + (15567301, 585), + (15567886, 552), + (15568438, 559), + (15568997, 599), + (15569596, 552), + (15570148, 560), + (15570708, 599), + (15571307, 552), + (15571859, 560), + (15572419, 600), + (15573019, 554), + (15573573, 560), + (15574133, 613), + (15574746, 553), + (15575299, 561), + (15575860, 613), + (15576473, 552), + (15577025, 560), + (15577585, 607), + (15578192, 552), + (15578744, 560), + (15579304, 619), + (15579923, 553), + (15580476, 559), + (15581035, 617), + (15581652, 553), + (15582205, 560), + (15582765, 574), + (15583339, 553), + (15583892, 561), + (15584453, 590), + (15585043, 553), + (15585596, 561), + (15586157, 589), + (15586746, 554), + (15587300, 560), + (15587860, 589), + (15588449, 552), + (15589001, 560), + (15589561, 602), + (15590163, 553), + (15590716, 560), + (15591276, 602), + (15591878, 552), + (15592430, 560), + (15592990, 596), + (15593586, 552), + (15594138, 560), + (15594698, 608), + (15595306, 553), + (15595859, 560), + (15596419, 609), + (15597028, 553), + (15597581, 560), + (15598141, 588), + (15598729, 554), + (15599283, 561), + (15599844, 602), + (15600446, 554), + (15601000, 560), + (15601560, 600), + (15602160, 552), + (15602712, 560), + (15603272, 602), + (15603874, 554), + (15604428, 560), + (15604988, 615), + (15605603, 554), + (15606157, 560), + (15606717, 614), + (15607331, 553), + (15607884, 559), + (15608443, 609), + (15609052, 554), + (15609606, 559), + (15610165, 619), + (15610784, 553), + (15611337, 560), + (15611897, 620), + (15612517, 554), + (15613071, 560), + (15613631, 588), + (15614219, 552), + (15614771, 560), + (15615331, 601), + (15615932, 553), + (15616485, 559), + (15617044, 600), + (15617644, 553), + (15618197, 559), + (15618756, 601), + (15619357, 553), + (15619910, 559), + (15620469, 613), + (15621082, 553), + (15621635, 560), + (15622195, 615), + (15622810, 553), + (15623363, 559), + (15623922, 608), + (15624530, 553), + (15625083, 560), + (15625643, 621), + (15626264, 553), + (15626817, 560), + (15627377, 620), + (15627997, 552), + (15628549, 555), + (15629104, 574), + (15629678, 553), + (15630231, 554), + (15630785, 571), + (15631356, 552), + (15631908, 560), + (15632468, 574), + (15633042, 554), + (15633596, 561), + (15634157, 571), + (15634728, 554), + (15635282, 562), + (15635844, 576), + (15636420, 553), + (15636973, 563), + (15637536, 571), + (15638107, 552), + (15638659, 562), + (15639221, 575), + (15639796, 552), + (15640348, 564), + (15640912, 571), + (15641483, 553), + (15642036, 563), + (15642599, 575), + (15643174, 553), + (15643727, 563), + (15644290, 571), + (15644861, 553), + (15645414, 532), + (15645946, 571), + (15646517, 553), + (15647070, 532), + (15647602, 569), + (15648171, 553), + (15648724, 535), + (15649259, 570), + (15649829, 554), + (15650383, 536), + (15650919, 570), + (15651489, 552), + (15652041, 554), + (15652595, 575), + (15653170, 553), + (15653723, 553), + (15654276, 573), + (15654849, 553), + (15655402, 561), + (15655963, 576), + (15656539, 553), + (15657092, 560), + (15657652, 571), + (15658223, 554), + (15658777, 562), + (15659339, 575), + (15659914, 552), + (15660466, 562), + (15661028, 571), + (15661599, 554), + (15662153, 563), + (15662716, 575), + (15663291, 553), + (15663844, 563), + (15664407, 571), + (15664978, 554), + (15665532, 563), + (15666095, 574), + (15666669, 552), + (15667221, 564), + (15667785, 573), + (15668358, 553), + (15668911, 532), + (15669443, 569), + (15670012, 553), + (15670565, 532), + (15671097, 571), + (15671668, 554), + (15672222, 535), + (15672757, 569), + (15673326, 552), + (15673878, 536), + (15674414, 569), + (15674983, 554), + (15675537, 554), + (15676091, 576), + (15676667, 554), + (15677221, 554), + (15677775, 573), + (15678348, 553), + (15678901, 561), + (15679462, 575), + (15680037, 553), + (15680590, 561), + (15681151, 571), + (15681722, 552), + (15682274, 562), + (15682836, 575), + (15683411, 553), + (15683964, 562), + (15684526, 572), + (15685098, 552), + (15685650, 563), + (15686213, 575), + (15686788, 553), + (15687341, 563), + (15687904, 571), + (15688475, 553), + (15689028, 563), + (15689591, 575), + (15690166, 553), + (15690719, 564), + (15691283, 573), + (15691856, 553), + (15692409, 531), + (15692940, 569), + (15693509, 554), + (15694063, 532), + (15694595, 570), + (15695165, 553), + (15695718, 535), + (15696253, 570), + (15696823, 552), + (15697375, 536), + (15697911, 569), + (15698480, 552), + (15699032, 554), + (15699586, 575), + (15700161, 553), + (15700714, 554), + (15701268, 572), + (15701840, 554), + (15702394, 562), + (15702956, 576), + (15703532, 552), + (15704084, 561), + (15704645, 572), + (15705217, 553), + (15705770, 562), + (15706332, 575), + (15706907, 552), + (15707459, 562), + (15708021, 572), + (15708593, 553), + (15709146, 563), + (15709709, 576), + (15710285, 554), + (15710839, 563), + (15711402, 572), + (15711974, 552), + (15712526, 563), + (15713089, 574), + (15713663, 554), + (15714217, 563), + (15714780, 572), + (15715352, 553), + (15715905, 530), + (15716435, 571), + (15717006, 553), + (15717559, 532), + (15718091, 569), + (15718660, 552), + (15719212, 537), + (15719749, 569), + (15720318, 553), + (15720871, 536), + (15721407, 569), + (15721976, 554), + (15722530, 554), + (15723084, 576), + (15723660, 554), + (15724214, 553), + (15724767, 572), + (15725339, 553), + (15725892, 561), + (15726453, 575), + (15727028, 553), + (15727581, 561), + (15728142, 571), + (15728713, 552), + (15729265, 563), + (15729828, 575), + (15730403, 552), + (15730955, 563), + (15731518, 572), + (15732090, 553), + (15732643, 564), + (15733207, 575), + (15733782, 553), + (15734335, 562), + (15734897, 571), + (15735468, 554), + (15736022, 563), + (15736585, 575), + (15737160, 553), + (15737713, 564), + (15738277, 572), + (15738849, 554), + (15739403, 531), + (15739934, 569), + (15740503, 552), + (15741055, 531), + (15741586, 570), + (15742156, 554), + (15742710, 536), + (15743246, 570), + (15743816, 554), + (15744370, 534), + (15744904, 571), + (15745475, 552), + (15746027, 553), + (15746580, 575), + (15747155, 552), + (15747707, 555), + (15748262, 572), + (15748834, 553), + (15749387, 562), + (15749949, 575), + (15750524, 552), + (15751076, 560), + (15751636, 573), + (15752209, 552), + (15752761, 563), + (15753324, 575), + (15753899, 553), + (15754452, 561), + (15755013, 573), + (15755586, 553), + (15756139, 563), + (15756702, 574), + (15757276, 552), + (15757828, 564), + (15758392, 571), + (15758963, 553), + (15759516, 563), + (15760079, 575), + (15760654, 554), + (15761208, 564), + (15761772, 571), + (15762343, 553), + (15762896, 530), + (15763426, 570), + (15763996, 553), + (15764549, 531), + (15765080, 570), + (15765650, 553), + (15766203, 535), + (15766738, 571), + (15767309, 552), + (15767861, 536), + (15768397, 569), + (15768966, 554), + (15769520, 554), + (15770074, 575), + (15770649, 552), + (15771201, 553), + (15771754, 572), + (15772326, 554), + (15772880, 560), + (15773440, 575), + (15774015, 553), + (15774568, 562), + (15775130, 573), + (15775703, 553), + (15776256, 563), + (15776819, 574), + (15777393, 554), + (15777947, 562), + (15778509, 572), + (15779081, 554), + (15779635, 562), + (15780197, 574), + (15780771, 553), + (15781324, 563), + (15781887, 572), + (15782459, 553), + (15783012, 564), + (15783576, 576), + (15784152, 554), + (15784706, 564), + (15785270, 573), + (15785843, 553), + (15786396, 532), + (15786928, 570), + (15787498, 554), + (15788052, 532), + (15788584, 569), + (15789153, 553), + (15789706, 535), + (15790241, 570), + (15790811, 553), + (15791364, 536), + (15791900, 570), + (15792470, 554), + (15793024, 554), + (15793578, 574), + (15794152, 554), + (15794706, 554), + (15795260, 572), + (15795832, 554), + (15796386, 560), + (15796946, 575), + (15797521, 553), + (15798074, 561), + (15798635, 571), + (15799206, 554), + (15799760, 562), + (15800322, 576), + (15800898, 553), + (15801451, 561), + (15802012, 572), + (15802584, 553), + (15803137, 562), + (15803699, 575), + (15804274, 553), + (15804827, 563), + (15805390, 572), + (15805962, 554), + (15806516, 562), + (15807078, 575), + (15807653, 552), + (15808205, 563), + (15808768, 571), + (15809339, 554), + (15809893, 531), + (15810424, 570), + (15810994, 554), + (15811548, 532), + (15812080, 571), + (15812651, 552), + (15813203, 536), + (15813739, 571), + (15814310, 554), + (15814864, 537), + (15815401, 571), + (15815972, 552), + (15816524, 554), + (15817078, 575), + (15817653, 553), + (15818206, 554), + (15818760, 572), + (15819332, 554), + (15819886, 561), + (15820447, 574), + (15821021, 554), + (15821575, 561), + (15822136, 572), + (15822708, 553), + (15823261, 562), + (15823823, 575), + (15824398, 553), + (15824951, 561), + (15825512, 573), + (15826085, 553), + (15826638, 563), + (15827201, 575), + (15827776, 554), + (15828330, 563), + (15828893, 572), + (15829465, 552), + (15830017, 562), + (15830579, 575), + (15831154, 552), + (15831706, 563), + (15832269, 572), + (15832841, 553), + (15833394, 532), + (15833926, 570), + (15834496, 552), + (15835048, 530), + (15835578, 570), + (15836148, 554), + (15836702, 536), + (15837238, 570), + (15837808, 553), + (15838361, 536), + (15838897, 571), + (15839468, 552), + (15840020, 553), + (15840573, 575), + (15841148, 553), + (15841701, 554), + (15842255, 571), + (15842826, 553), + (15843379, 561), + (15843940, 575), + (15844515, 554), + (15845069, 561), + (15845630, 572), + (15846202, 552), + (15846754, 562), + (15847316, 575), + (15847891, 553), + (15848444, 562), + (15849006, 572), + (15849578, 553), + (15850131, 563), + (15850694, 576), + (15851270, 553), + (15851823, 563), + (15852386, 573), + (15852959, 553), + (15853512, 562), + (15854074, 575), + (15854649, 552), + (15855201, 563), + (15855764, 572), + (15856336, 552), + (15856888, 532), + (15857420, 570), + (15857990, 554), + (15858544, 532), + (15859076, 569), + (15859645, 551), + (15860196, 537), + (15860733, 570), + (15861303, 552), + (15861855, 535), + (15862390, 571), + (15862961, 552), + (15863513, 554), + (15864067, 575), + (15864642, 553), + (15865195, 554), + (15865749, 572), + (15866321, 553), + (15866874, 560), + (15867434, 574), + (15868008, 554), + (15868562, 561), + (15869123, 572), + (15869695, 553), + (15870248, 562), + (15870810, 576), + (15871386, 554), + (15871940, 562), + (15872502, 572), + (15873074, 554), + (15873628, 563), + (15874191, 575), + (15874766, 554), + (15875320, 564), + (15875884, 572), + (15876456, 552), + (15877008, 562), + (15877570, 575), + (15878145, 553), + (15878698, 563), + (15879261, 571), + (15879832, 554), + (15880386, 531), + (15880917, 571), + (15881488, 554), + (15882042, 531), + (15882573, 570), + (15883143, 553), + (15883696, 535), + (15884231, 571), + (15884802, 552), + (15885354, 536), + (15885890, 571), + (15886461, 554), + (15887015, 554), + (15887569, 574), + (15888143, 552), + (15888695, 554), + (15889249, 573), + (15889822, 554), + (15890376, 559), + (15890935, 574), + (15891509, 553), + (15892062, 560), + (15892622, 572), + (15893194, 552), + (15893746, 562), + (15894308, 575), + (15894883, 553), + (15895436, 562), + (15895998, 573), + (15896571, 553), + (15897124, 564), + (15897688, 574), + (15898262, 553), + (15898815, 563), + (15899378, 573), + (15899951, 554), + (15900505, 564), + (15901069, 576), + (15901645, 553), + (15902198, 563), + (15902761, 571), + (15903332, 552), + (15903884, 530), + (15904414, 570), + (15904984, 554), + (15905538, 530), + (15906068, 570), + (15906638, 553), + (15907191, 537), + (15907728, 569), + (15908297, 554), + (15908851, 535), + (15909386, 571), + (15909957, 553), + (15910510, 555), + (15911065, 575), + (15911640, 553), + (15912193, 554), + (15912747, 572), + (15913319, 554), + (15913873, 560), + (15914433, 576), + (15915009, 553), + (15915562, 561), + (15916123, 573), + (15916696, 552), + (15917248, 561), + (15917809, 575), + (15918384, 553), + (15918937, 563), + (15919500, 572), + (15920072, 552), + (15920624, 562), + (15921186, 576), + (15921762, 553), + (15922315, 563), + (15922878, 573), + (15923451, 554), + (15924005, 562), + (15924567, 574), + (15925141, 554), + (15925695, 562), + (15926257, 572), + (15926829, 552), + (15927381, 531), + (15927912, 569), + (15928481, 554), + (15929035, 531), + (15929566, 569), + (15930135, 554), + (15930689, 536), + (15931225, 571), + (15931796, 553), + (15932349, 536), + (15932885, 570), + (15933455, 553), + (15934008, 554), + (15934562, 575), + (15935137, 553), + (15935690, 553), + (15936243, 571), + (15936814, 552), + (15937366, 561), + (15937927, 575), + (15938502, 553), + (15939055, 560), + (15939615, 571), + (15940186, 554), + (15940740, 561), + (15941301, 575), + (15941876, 553), + (15942429, 563), + (15942992, 572), + (15943564, 552), + (15944116, 563), + (15944679, 574), + (15945253, 553), + (15945806, 563), + (15946369, 573), + (15946942, 553), + (15947495, 562), + (15948057, 575), + (15948632, 554), + (15949186, 563), + (15949749, 572), + (15950321, 553), + (15950874, 530), + (15951404, 571), + (15951975, 553), + (15952528, 530), + (15953058, 570), + (15953628, 554), + (15954182, 535), + (15954717, 571), + (15955288, 554), + (15955842, 536), + (15956378, 569), + (15956947, 553), + (15957500, 554), + (15958054, 575), + (15958629, 553), + (15959182, 554), + (15959736, 572), + (15960308, 552), + (15960860, 562), + (15961422, 575), + (15961997, 552), + (15962549, 561), + (15963110, 573), + (15963683, 554), + (15964237, 561), + (15964798, 575), + (15965373, 554), + (15965927, 563), + (15966490, 572), + (15967062, 554), + (15967616, 563), + (15968179, 575), + (15968754, 553), + (15969307, 564), + (15969871, 571), + (15970442, 554), + (15970996, 564), + (15971560, 575), + (15972135, 552), + (15972687, 564), + (15973251, 572), + (15973823, 554), + (15974377, 532), + (15974909, 570), + (15975479, 553), + (15976032, 530), + (15976562, 571), + (15977133, 553), + (15977686, 535), + (15978221, 569), + (15978790, 553), + (15979343, 537), + (15979880, 570), + (15980450, 553), + (15981003, 554), + (15981557, 575), + (15982132, 553), + (15982685, 555), + (15983240, 572), + (15983812, 553), + (15984365, 561), + (15984926, 575), + (15985501, 553), + (15986054, 561), + (15986615, 571), + (15987186, 553), + (15987739, 562), + (15988301, 576), + (15988877, 553), + (15989430, 563), + (15989993, 572), + (15990565, 554), + (15991119, 563), + (15991682, 574), + (15992256, 553), + (15992809, 563), + (15993372, 573), + (15993945, 553), + (15994498, 563), + (15995061, 575), + (15995636, 553), + (15996189, 563), + (15996752, 572), + (15997324, 553), + (15997877, 532), + (15998409, 569), + (15998978, 554), + (15999532, 531), + (16000063, 570), + (16000633, 554), + (16001187, 537), + (16001724, 569), + (16002293, 553), + (16002846, 535), + (16003381, 569), + (16003950, 554), + (16004504, 570), + (16005074, 575), + (16005649, 554), + (16006203, 571), + (16006774, 572), + (16007346, 553), + (16007899, 572), + (16008471, 575), + (16009046, 553), + (16009599, 572), + (16010171, 571), + (16010742, 552), + (16011294, 572), + (16011866, 575), + (16012441, 552), + (16012993, 571), + (16013564, 572), + (16014136, 553), + (16014689, 571), + (16015260, 576), + (16015836, 554), + (16016390, 571), + (16016961, 573), + (16017534, 552), + (16018086, 571), + (16018657, 574), + (16019231, 552), + (16019783, 570), + (16020353, 573), + (16020926, 553), + (16021479, 571), + (16022050, 576), + (16022626, 552), + (16023178, 572), + (16023750, 572), + (16024322, 552), + (16024874, 571), + (16025445, 575), + (16026020, 553), + (16026573, 572), + (16027145, 572), + (16027717, 553), + (16028270, 571), + (16028841, 576), + (16029417, 553), + (16029970, 571), + (16030541, 573), + (16031114, 552), + (16031666, 572), + (16032238, 575), + (16032813, 554), + (16033367, 572), + (16033939, 573), + (16034512, 553), + (16035065, 571), + (16035636, 575), + (16036211, 554), + (16036765, 571), + (16037336, 572), + (16037908, 552), + (16038460, 571), + (16039031, 575), + (16039606, 553), + (16040159, 572), + (16040731, 571), + (16041302, 553), + (16041855, 570), + (16042425, 575), + (16043000, 552), + (16043552, 570), + (16044122, 573), + (16044695, 554), + (16045249, 571), + (16045820, 575), + (16046395, 553), + (16046948, 570), + (16047518, 572), + (16048090, 552), + (16048642, 571), + (16049213, 576), + (16049789, 553), + (16050342, 570), + (16050912, 572), + (16051484, 552), + (16052036, 571), + (16052607, 575), + (16053182, 553), + (16053735, 572), + (16054307, 572), + (16054879, 554), + (16055433, 571), + (16056004, 575), + (16056579, 554), + (16057133, 570), + (16057703, 572), + (16058275, 552), + (16058827, 578), + (16059405, 574), + (16059979, 554), + (16060533, 579), + (16061112, 572), + (16061684, 554), + (16062238, 579), + (16062817, 574), + (16063391, 553), + (16063944, 579), + (16064523, 572), + (16065095, 552), + (16065647, 578), + (16066225, 574), + (16066799, 554), + (16067353, 578), + (16067931, 572), + (16068503, 554), + (16069057, 579), + (16069636, 575), + (16070211, 552), + (16070763, 578), + (16071341, 571), + (16071912, 553), + (16072465, 578), + (16073043, 576), + (16073619, 553), + (16074172, 578), + (16074750, 573), + (16075323, 553), + (16075876, 577), + (16076453, 574), + (16077027, 553), + (16077580, 578), + (16078158, 571), + (16078729, 552), + (16079281, 577), + (16079858, 575), + (16080433, 552), + (16080985, 579), + (16081564, 572), + (16082136, 553), + (16082689, 577), + (16083266, 576), + (16083842, 554), + (16084396, 579), + (16084975, 573), + (16085548, 553), + (16086101, 578), + (16086679, 575), + (16087254, 552), + (16087806, 579), + (16088385, 571), + (16088956, 553), + (16089509, 578), + (16090087, 576), + (16090663, 553), + (16091216, 578), + (16091794, 572), + (16092366, 552), + (16092918, 579), + (16093497, 574), + (16094071, 553), + (16094624, 579), + (16095203, 572), + (16095775, 553), + (16096328, 578), + (16096906, 575), + (16097481, 553), + (16098034, 579), + (16098613, 572), + (16099185, 552), + (16099737, 579), + (16100316, 576), + (16100892, 553), + (16101445, 579), + (16102024, 572), + (16102596, 553), + (16103149, 578), + (16103727, 574), + (16104301, 554), + (16104855, 578), + (16105433, 572), + (16106005, 554), + (16106559, 577), + (16107136, 575), + (16107711, 553), + (16108264, 577), + (16108841, 571), + (16109412, 554), + (16109966, 578), + (16110544, 576), + (16111120, 553), + (16111673, 578), + (16112251, 573), + (16112824, 552), + (16113376, 575), + (16113951, 576), + (16114527, 553), + (16115080, 576), + (16115656, 571), + (16116227, 554), + (16116781, 574), + (16117355, 575), + (16117930, 554), + (16118484, 575), + (16119059, 572), + (16119631, 552), + (16120183, 574), + (16120757, 575), + (16121332, 552), + (16121884, 576), + (16122460, 572), + (16123032, 553), + (16123585, 574), + (16124159, 575), + (16124734, 553), + (16125287, 576), + (16125863, 572), + (16126435, 552), + (16126987, 575), + (16127562, 575), + (16128137, 553), + (16128690, 574), + (16129264, 571), + (16129835, 554), + (16130389, 575), + (16130964, 575), + (16131539, 553), + (16132092, 575), + (16132667, 571), + (16133238, 552), + (16133790, 575), + (16134365, 575), + (16134940, 553), + (16135493, 576), + (16136069, 571), + (16136640, 554), + (16137194, 575), + (16137769, 576), + (16138345, 553), + (16138898, 575), + (16139473, 571), + (16140044, 553), + (16140597, 576), + (16141173, 575), + (16141748, 554), + (16142302, 576), + (16142878, 572), + (16143450, 553), + (16144003, 575), + (16144578, 575), + (16145153, 553), + (16145706, 575), + (16146281, 572), + (16146853, 553), + (16147406, 575), + (16147981, 574), + (16148555, 553), + (16149108, 575), + (16149683, 573), + (16150256, 552), + (16150808, 575), + (16151383, 574), + (16151957, 552), + (16152509, 574), + (16153083, 572), + (16153655, 554), + (16154209, 575), + (16154784, 576), + (16155360, 553), + (16155913, 574), + (16156487, 572), + (16157059, 553), + (16157612, 575), + (16158187, 575), + (16158762, 553), + (16159315, 576), + (16159891, 572), + (16160463, 552), + (16161015, 576), + (16161591, 575), + (16162166, 554), + (16162720, 574), + (16163294, 571), + (16163865, 552), + (16164417, 576), + (16164993, 574), + (16165567, 553), + (16166120, 575), + (16166695, 573), + (16167268, 554), + (16167822, 583), + (16168405, 575), + (16168980, 553), + (16169533, 582), + (16170115, 572), + (16170687, 553), + (16171240, 581), + (16171821, 574), + (16172395, 553), + (16172948, 581), + (16173529, 572), + (16174101, 552), + (16174653, 583), + (16175236, 576), + (16175812, 554), + (16176366, 581), + (16176947, 573), + (16177520, 554), + (16178074, 583), + (16178657, 574), + (16179231, 554), + (16179785, 583), + (16180368, 571), + (16180939, 553), + (16181492, 582), + (16182074, 575), + (16182649, 552), + (16183201, 581), + (16183782, 573), + (16184355, 552), + (16184907, 582), + (16185489, 575), + (16186064, 553), + (16186617, 582), + (16187199, 571), + (16187770, 552), + (16188322, 582), + (16188904, 576), + (16189480, 553), + (16190033, 582), + (16190615, 572), + (16191187, 553), + (16191740, 582), + (16192322, 575), + (16192897, 554), + (16193451, 582), + (16194033, 572), + (16194605, 553), + (16195158, 581), + (16195739, 574), + (16196313, 554), + (16196867, 582), + (16197449, 572), + (16198021, 553), + (16198574, 582), + (16199156, 576), + (16199732, 553), + (16200285, 582), + (16200867, 572), + (16201439, 554), + (16201993, 581), + (16202574, 575), + (16203149, 553), + (16203702, 582), + (16204284, 572), + (16204856, 552), + (16205408, 582), + (16205990, 576), + (16206566, 553), + (16207119, 583), + (16207702, 571), + (16208273, 552), + (16208825, 582), + (16209407, 575), + (16209982, 553), + (16210535, 581), + (16211116, 571), + (16211687, 553), + (16212240, 582), + (16212822, 574), + (16213396, 553), + (16213949, 582), + (16214531, 573), + (16215104, 554), + (16215658, 582), + (16216240, 574), + (16216814, 553), + (16217367, 581), + (16217948, 572), + (16218520, 553), + (16219073, 583), + (16219656, 575), + (16220231, 553), + (16220784, 582), + (16221366, 573), + (16221939, 553), + (16222492, 570), + (16223062, 575), + (16223637, 554), + (16224191, 570), + (16224761, 571), + (16225332, 553), + (16225885, 570), + (16226455, 574), + (16227029, 554), + (16227583, 570), + (16228153, 572), + (16228725, 552), + (16229277, 571), + (16229848, 574), + (16230422, 554), + (16230976, 570), + (16231546, 573), + (16232119, 553), + (16232672, 570), + (16233242, 574), + (16233816, 553), + (16234369, 571), + (16234940, 572), + (16235512, 553), + (16236065, 571), + (16236636, 576), + (16237212, 554), + (16237766, 571), + (16238337, 572), + (16238909, 553), + (16239462, 571), + (16240033, 575), + (16240608, 554), + (16241162, 570), + (16241732, 571), + (16242303, 552), + (16242855, 570), + (16243425, 575), + (16244000, 554), + (16244554, 571), + (16245125, 572), + (16245697, 552), + (16246249, 569), + (16246818, 575), + (16247393, 553), + (16247946, 570), + (16248516, 572), + (16249088, 552), + (16249640, 570), + (16250210, 576), + (16250786, 553), + (16251339, 570), + (16251909, 572), + (16252481, 553), + (16253034, 570), + (16253604, 575), + (16254179, 553), + (16254732, 570), + (16255302, 573), + (16255875, 553), + (16256428, 571), + (16256999, 574), + (16257573, 553), + (16258126, 570), + (16258696, 573), + (16259269, 553), + (16259822, 569), + (16260391, 576), + (16260967, 552), + (16261519, 569), + (16262088, 571), + (16262659, 552), + (16263211, 570), + (16263781, 575), + (16264356, 554), + (16264910, 569), + (16265479, 572), + (16266051, 553), + (16266604, 570), + (16267174, 574), + (16267748, 554), + (16268302, 571), + (16268873, 572), + (16269445, 553), + (16269998, 570), + (16270568, 576), + (16271144, 552), + (16271696, 569), + (16272265, 572), + (16272837, 554), + (16273391, 570), + (16273961, 576), + (16274537, 554), + (16275091, 570), + (16275661, 572), + (16276233, 553), + (16276786, 577), + (16277363, 575), + (16277938, 553), + (16278491, 578), + (16279069, 572), + (16279641, 553), + (16280194, 577), + (16280771, 575), + (16281346, 553), + (16281899, 577), + (16282476, 572), + (16283048, 552), + (16283600, 577), + (16284177, 575), + (16284752, 553), + (16285305, 578), + (16285883, 572), + (16286455, 553), + (16287008, 576), + (16287584, 576), + (16288160, 552), + (16288712, 578), + (16289290, 571), + (16289861, 554), + (16290415, 576), + (16290991, 575), + (16291566, 553), + (16292119, 577), + (16292696, 572), + (16293268, 553), + (16293821, 577), + (16294398, 576), + (16294974, 553), + (16295527, 578), + (16296105, 572), + (16296677, 553), + (16297230, 578), + (16297808, 576), + (16298384, 553), + (16298937, 576), + (16299513, 572), + (16300085, 552), + (16300637, 576), + (16301213, 574), + (16301787, 553), + (16302340, 576), + (16302916, 572), + (16303488, 554), + (16304042, 577), + (16304619, 574), + (16305193, 554), + (16305747, 577), + (16306324, 572), + (16306896, 553), + (16307449, 576), + (16308025, 576), + (16308601, 553), + (16309154, 576), + (16309730, 573), + (16310303, 553), + (16310856, 577), + (16311433, 574), + (16312007, 552), + (16312559, 577), + (16313136, 572), + (16313708, 553), + (16314261, 577), + (16314838, 575), + (16315413, 554), + (16315967, 577), + (16316544, 572), + (16317116, 553), + (16317669, 576), + (16318245, 575), + (16318820, 553), + (16319373, 577), + (16319950, 571), + (16320521, 552), + (16321073, 576), + (16321649, 575), + (16322224, 553), + (16322777, 577), + (16323354, 572), + (16323926, 553), + (16324479, 578), + (16325057, 575), + (16325632, 554), + (16326186, 577), + (16326763, 573), + (16327336, 554), + (16327890, 576), + (16328466, 574), + (16329040, 554), + (16329594, 578), + (16330172, 572), + (16330744, 553), + (16331297, 574), + (16331871, 575), + (16332446, 554), + (16333000, 575), + (16333575, 572), + (16334147, 553), + (16334700, 574), + (16335274, 576), + (16335850, 553), + (16336403, 574), + (16336977, 573), + (16337550, 553), + (16338103, 575), + (16338678, 575), + (16339253, 554), + (16339807, 574), + (16340381, 572), + (16340953, 553), + (16341506, 574), + (16342080, 576), + (16342656, 553), + (16343209, 574), + (16343783, 572), + (16344355, 554), + (16344909, 575), + (16345484, 575), + (16346059, 553), + (16346612, 573), + (16347185, 572), + (16347757, 553), + (16348310, 573), + (16348883, 575), + (16349458, 554), + (16350012, 573), + (16350585, 572), + (16351157, 553), + (16351710, 574), + (16352284, 576), + (16352860, 553), + (16353413, 574), + (16353987, 573), + (16354560, 553), + (16355113, 573), + (16355686, 576), + (16356262, 553), + (16356815, 573), + (16357388, 572), + (16357960, 552), + (16358512, 574), + (16359086, 576), + (16359662, 553), + (16360215, 573), + (16360788, 573), + (16361361, 553), + (16361914, 574), + (16362488, 575), + (16363063, 553), + (16363616, 573), + (16364189, 571), + (16364760, 553), + (16365313, 574), + (16365887, 575), + (16366462, 552), + (16367014, 573), + (16367587, 572), + (16368159, 553), + (16368712, 574), + (16369286, 576), + (16369862, 553), + (16370415, 575), + (16370990, 572), + (16371562, 552), + (16372114, 574), + (16372688, 576), + (16373264, 554), + (16373818, 574), + (16374392, 572), + (16374964, 553), + (16375517, 575), + (16376092, 576), + (16376668, 553), + (16377221, 575), + (16377796, 572), + (16378368, 553), + (16378921, 575), + (16379496, 575), + (16380071, 553), + (16380624, 574), + (16381198, 572), + (16381770, 554), + (16382324, 573), + (16382897, 575), + (16383472, 553), + (16384025, 574), + (16384599, 571), + (16385170, 554), + (16385724, 582), + (16386306, 575), + (16386881, 553), + (16387434, 580), + (16388014, 572), + (16388586, 552), + (16389138, 580), + (16389718, 575), + (16390293, 552), + (16390845, 580), + (16391425, 572), + (16391997, 553), + (16392550, 581), + (16393131, 575), + (16393706, 553), + (16394259, 582), + (16394841, 572), + (16395413, 552), + (16395965, 581), + (16396546, 574), + (16397120, 553), + (16397673, 581), + (16398254, 572), + (16398826, 553), + (16399379, 581), + (16399960, 575), + (16400535, 554), + (16401089, 580), + (16401669, 571), + (16402240, 552), + (16402792, 581), + (16403373, 574), + (16403947, 553), + (16404500, 580), + (16405080, 572), + (16405652, 554), + (16406206, 581), + (16406787, 575), + (16407362, 554), + (16407916, 580), + (16408496, 573), + (16409069, 553), + (16409622, 581), + (16410203, 575), + (16410778, 552), + (16411330, 580), + (16411910, 573), + (16412483, 554), + (16413037, 582), + (16413619, 574), + (16414193, 553), + (16414746, 582), + (16415328, 572), + (16415900, 552), + (16416452, 582), + (16417034, 575), + (16417609, 553), + (16418162, 580), + (16418742, 572), + (16419314, 554), + (16419868, 581), + (16420449, 575), + (16421024, 553), + (16421577, 581), + (16422158, 572), + (16422730, 552), + (16423282, 580), + (16423862, 575), + (16424437, 553), + (16424990, 580), + (16425570, 573), + (16426143, 554), + (16426697, 580), + (16427277, 575), + (16427852, 552), + (16428404, 581), + (16428985, 571), + (16429556, 552), + (16430108, 582), + (16430690, 575), + (16431265, 554), + (16431819, 581), + (16432400, 572), + (16432972, 552), + (16433524, 581), + (16434105, 574), + (16434679, 553), + (16435232, 581), + (16435813, 572), + (16436385, 554), + (16436939, 580), + (16437519, 575), + (16438094, 552), + (16438646, 582), + (16439228, 571), + (16439799, 553), + (16440352, 570), + (16440922, 574), + (16441496, 553), + (16442049, 571), + (16442620, 573), + (16443193, 553), + (16443746, 571), + (16444317, 576), + (16444893, 554), + (16445447, 571), + (16446018, 573), + (16446591, 552), + (16447143, 569), + (16447712, 576), + (16448288, 553), + (16448841, 570), + (16449411, 571), + (16449982, 552), + (16450534, 570), + (16451104, 576), + (16451680, 554), + (16452234, 570), + (16452804, 572), + (16453376, 554), + (16453930, 570), + (16454500, 575), + (16455075, 553), + (16455628, 569), + (16456197, 571), + (16456768, 554), + (16457322, 569), + (16457891, 575), + (16458466, 553), + (16459019, 570), + (16459589, 572), + (16460161, 553), + (16460714, 570), + (16461284, 574), + (16461858, 554), + (16462412, 569), + (16462981, 572), + (16463553, 554), + (16464107, 570), + (16464677, 575), + (16465252, 553), + (16465805, 571), + (16466376, 572), + (16466948, 554), + (16467502, 570), + (16468072, 574), + (16468646, 554), + (16469200, 570), + (16469770, 572), + (16470342, 554), + (16470896, 569), + (16471465, 576), + (16472041, 553), + (16472594, 571), + (16473165, 571), + (16473736, 554), + (16474290, 570), + (16474860, 576), + (16475436, 553), + (16475989, 569), + (16476558, 572), + (16477130, 552), + (16477682, 570), + (16478252, 574), + (16478826, 554), + (16479380, 571), + (16479951, 573), + (16480524, 553), + (16481077, 570), + (16481647, 576), + (16482223, 553), + (16482776, 570), + (16483346, 572), + (16483918, 552), + (16484470, 570), + (16485040, 576), + (16485616, 553), + (16486169, 570), + (16486739, 573), + (16487312, 552), + (16487864, 570), + (16488434, 575), + (16489009, 553), + (16489562, 570), + (16490132, 573), + (16490705, 554), + (16491259, 571), + (16491830, 575), + (16492405, 553), + (16492958, 570), + (16493528, 572), + (16494100, 553), + (16494653, 578), + (16495231, 575), + (16495806, 553), + (16496359, 577), + (16496936, 571), + (16497507, 554), + (16498061, 578), + (16498639, 575), + (16499214, 553), + (16499767, 578), + (16500345, 572), + (16500917, 554), + (16501471, 576), + (16502047, 575), + (16502622, 553), + (16503175, 577), + (16503752, 573), + (16504325, 553), + (16504878, 577), + (16505455, 574), + (16506029, 554), + (16506583, 577), + (16507160, 571), + (16507731, 554), + (16508285, 578), + (16508863, 575), + (16509438, 553), + (16509991, 578), + (16510569, 572), + (16511141, 554), + (16511695, 577), + (16512272, 576), + (16512848, 553), + (16513401, 577), + (16513978, 572), + (16514550, 552), + (16515102, 578), + (16515680, 574), + (16516254, 552), + (16516806, 577), + (16517383, 571), + (16517954, 553), + (16518507, 576), + (16519083, 576), + (16519659, 553), + (16520212, 577), + (16520789, 573), + (16521362, 553), + (16521915, 578), + (16522493, 575), + (16523068, 554), + (16523622, 576), + (16524198, 573), + (16524771, 554), + (16525325, 578), + (16525903, 576), + (16526479, 553), + (16527032, 577), + (16527609, 571), + (16528180, 553), + (16528733, 577), + (16529310, 574), + (16529884, 553), + (16530437, 577), + (16531014, 572), + (16531586, 552), + (16532138, 577), + (16532715, 575), + (16533290, 552), + (16533842, 576), + (16534418, 571), + (16534989, 553), + (16535542, 577), + (16536119, 575), + (16536694, 552), + (16537246, 576), + (16537822, 573), + (16538395, 552), + (16538947, 576), + (16539523, 576), + (16540099, 553), + (16540652, 578), + (16541230, 572), + (16541802, 552), + (16542354, 577), + (16542931, 574), + (16543505, 553), + (16544058, 576), + (16544634, 572), + (16545206, 554), + (16545760, 576), + (16546336, 575), + (16546911, 554), + (16547465, 576), + (16548041, 572), + (16548613, 554), + (16549167, 573), + (16549740, 575), + (16550315, 553), + (16550868, 574), + (16551442, 571), + (16552013, 552), + (16552565, 574), + (16553139, 576), + (16553715, 552), + (16554267, 575), + (16554842, 572), + (16555414, 554), + (16555968, 573), + (16556541, 575), + (16557116, 552), + (16557668, 573), + (16558241, 571), + (16558812, 552), + (16559364, 573), + (16559937, 576), + (16560513, 552), + (16561065, 573), + (16561638, 572), + (16562210, 554), + (16562764, 575), + (16563339, 576), + (16563915, 554), + (16564469, 574), + (16565043, 572), + (16565615, 553), + (16566168, 574), + (16566742, 575), + (16567317, 552), + (16567869, 575), + (16568444, 573), + (16569017, 553), + (16569570, 573), + (16570143, 574), + (16570717, 553), + (16571270, 573), + (16571843, 572), + (16572415, 553), + (16572968, 575), + (16573543, 574), + (16574117, 554), + (16574671, 573), + (16575244, 572), + (16575816, 553), + (16576369, 573), + (16576942, 575), + (16577517, 553), + (16578070, 574), + (16578644, 571), + (16579215, 552), + (16579767, 573), + (16580340, 575), + (16580915, 553), + (16581468, 574), + (16582042, 572), + (16582614, 552), + (16583166, 574), + (16583740, 576), + (16584316, 552), + (16584868, 572), + (16585440, 573), + (16586013, 553), + (16586566, 574), + (16587140, 575), + (16587715, 552), + (16588267, 574), + (16588841, 572), + (16589413, 553), + (16589966, 574), + (16590540, 575), + (16591115, 554), + (16591669, 574), + (16592243, 571), + (16592814, 552), + (16593366, 573), + (16593939, 574), + (16594513, 553), + (16595066, 573), + (16595639, 572), + (16596211, 552), + (16596763, 573), + (16597336, 576), + (16597912, 553), + (16598465, 573), + (16599038, 572), + (16599610, 553), + (16600163, 573), + (16600736, 575), + (16601311, 552), + (16601863, 574), + (16602437, 571), + (16603008, 554), + (16603562, 581), + (16604143, 575), + (16604718, 552), + (16605270, 581), + (16605851, 572), + (16606423, 553), + (16606976, 582), + (16607558, 576), + (16608134, 554), + (16608688, 582), + (16609270, 572), + (16609842, 554), + (16610396, 582), + (16610978, 574), + (16611552, 552), + (16612104, 580), + (16612684, 573), + (16613257, 553), + (16613810, 581), + (16614391, 576), + (16614967, 552), + (16615519, 580), + (16616099, 572), + (16616671, 553), + (16617224, 582), + (16617806, 575), + (16618381, 553), + (16618934, 580), + (16619514, 571), + (16620085, 552), + (16620637, 580), + (16621217, 575), + (16621792, 554), + (16622346, 581), + (16622927, 572), + (16623499, 552), + (16624051, 581), + (16624632, 574), + (16625206, 554), + (16625760, 581), + (16626341, 573), + (16626914, 552), + (16627466, 581), + (16628047, 575), + (16628622, 552), + (16629174, 580), + (16629754, 572), + (16630326, 552), + (16630878, 581), + (16631459, 575), + (16632034, 553), + (16632587, 582), + (16633169, 572), + (16633741, 554), + (16634295, 580), + (16634875, 575), + (16635450, 553), + (16636003, 580), + (16636583, 572), + (16637155, 554), + (16637709, 582), + (16638291, 574), + (16638865, 553), + (16639418, 580), + (16639998, 572), + (16640570, 552), + (16641122, 581), + (16641703, 574), + (16642277, 552), + (16642829, 581), + (16643410, 571), + (16643981, 553), + (16644534, 581), + (16645115, 575), + (16645690, 554), + (16646244, 582), + (16646826, 572), + (16647398, 552), + (16647950, 581), + (16648531, 575), + (16649106, 552), + (16649658, 581), + (16650239, 572), + (16650811, 554), + (16651365, 581), + (16651946, 574), + (16652520, 554), + (16653074, 581), + (16653655, 571), + (16654226, 553), + (16654779, 580), + (16655359, 574), + (16655933, 554), + (16656487, 581), + (16657068, 572), + (16657640, 553), + (16658193, 571), + (16658764, 576), + (16659340, 554), + (16659894, 570), + (16660464, 573), + (16661037, 554), + (16661591, 570), + (16662161, 575), + (16662736, 553), + (16663289, 571), + (16663860, 572), + (16664432, 553), + (16664985, 569), + (16665554, 575), + (16666129, 554), + (16666683, 569), + (16667252, 572), + (16667824, 554), + (16668378, 569), + (16668947, 575), + (16669522, 552), + (16670074, 571), + (16670645, 571), + (16671216, 553), + (16671769, 570), + (16672339, 575), + (16672914, 553), + (16673467, 570), + (16674037, 572), + (16674609, 553), + (16675162, 569), + (16675731, 574), + (16676305, 554), + (16676859, 570), + (16677429, 572), + (16678001, 553), + (16678554, 570), + (16679124, 576), + (16679700, 552), + (16680252, 571), + (16680823, 572), + (16681395, 553), + (16681948, 569), + (16682517, 576), + (16683093, 552), + (16683645, 570), + (16684215, 572), + (16684787, 554), + (16685341, 570), + (16685911, 575), + (16686486, 553), + (16687039, 570), + (16687609, 571), + (16688180, 553), + (16688733, 571), + (16689304, 575), + (16689879, 553), + (16690432, 571), + (16691003, 571), + (16691574, 554), + (16692128, 569), + (16692697, 576), + (16693273, 553), + (16693826, 570), + (16694396, 573), + (16694969, 554), + (16695523, 569), + (16696092, 574), + (16696666, 552), + (16697218, 570), + (16697788, 572), + (16698360, 553), + (16698913, 570), + (16699483, 575), + (16700058, 553), + (16700611, 569), + (16701180, 571), + (16701751, 554), + (16702305, 570), + (16702875, 574), + (16703449, 553), + (16704002, 571), + (16704573, 572), + (16705145, 553), + (16705698, 570), + (16706268, 575), + (16706843, 553), + (16707396, 569), + (16707965, 573), + (16708538, 553), + (16709091, 571), + (16709662, 575), + (16710237, 552), + (16710789, 570), + (16711359, 571), + (16711930, 553), + (16712483, 577), + (16713060, 574), + (16713634, 553), + (16714187, 578), + (16714765, 572), + (16715337, 553), + (16715890, 577), + (16716467, 575), + (16717042, 554), + (16717596, 577), + (16718173, 572), + (16718745, 553), + (16719298, 577), + (16719875, 575), + (16720450, 552), + (16721002, 577), + (16721579, 573), + (16722152, 553), + (16722705, 576), + (16723281, 575), + (16723856, 554), + (16724410, 577), + (16724987, 571), + (16725558, 552), + (16726110, 576), + (16726686, 576), + (16727262, 553), + (16727815, 578), + (16728393, 572), + (16728965, 552), + (16729517, 577), + (16730094, 576), + (16730670, 552), + (16731222, 576), + (16731798, 571), + (16732369, 553), + (16732922, 576), + (16733498, 576), + (16734074, 554), + (16734628, 578), + (16735206, 573), + (16735779, 552), + (16736331, 577), + (16736908, 574), + (16737482, 553), + (16738035, 577), + (16738612, 572), + (16739184, 554), + (16739738, 577), + (16740315, 575), + (16740890, 553), + (16741443, 577), + (16742020, 572), + (16742592, 554), + (16743146, 577), + (16743723, 575), + (16744298, 553), + (16744851, 576), + (16745427, 571), + (16745998, 552), + (16746550, 577), + (16747127, 576), + (16747703, 552), + (16748255, 577), + (16748832, 571), + (16749403, 553), + (16749956, 577), + (16750533, 575), + (16751108, 552), + (16751660, 575), + (16752235, 572), + (16752807, 553), + (16753360, 577), + (16753937, 574), + (16754511, 553), + (16755064, 577), + (16755641, 572), + (16756213, 553), + (16756766, 576), + (16757342, 575), + (16757917, 553), + (16758470, 577), + (16759047, 573), + (16759620, 553), + (16760173, 578), + (16760751, 574), + (16761325, 552), + (16761877, 577), + (16762454, 571), + (16763025, 554), + (16763579, 577), + (16764156, 575), + (16764731, 554), + (16765285, 577), + (16765862, 570), + (16766432, 552), + (16766984, 574), + (16767558, 575), + (16768133, 553), + (16768686, 573), + (16769259, 572), + (16769831, 553), + (16770384, 574), + (16770958, 574), + (16771532, 553), + (16772085, 574), + (16772659, 571), + (16773230, 554), + (16773784, 575), + (16774359, 574), + (16774933, 553), + (16775486, 574), + (16776060, 572), + (16776632, 553), + (16777185, 573), + (16777758, 576), + (16778334, 554), + (16778888, 574), + (16779462, 573), + (16780035, 553), + (16780588, 574), + (16781162, 575), + (16781737, 554), + (16782291, 574), + (16782865, 573), + (16783438, 553), + (16783991, 575), + (16784566, 574), + (16785140, 554), + (16785694, 573), + (16786267, 571), + (16786838, 553), + (16787391, 573), + (16787964, 576), + (16788540, 554), + (16789094, 573), + (16789667, 572), + (16790239, 552), + (16790791, 575), + (16791366, 574), + (16791940, 552), + (16792492, 575), + (16793067, 573), + (16793640, 554), + (16794194, 574), + (16794768, 574), + (16795342, 553), + (16795895, 575), + (16796470, 571), + (16797041, 553), + (16797594, 573), + (16798167, 575), + (16798742, 553), + (16799295, 575), + (16799870, 572), + (16800442, 553), + (16800995, 574), + (16801569, 576), + (16802145, 552), + (16802697, 573), + (16803270, 571), + (16803841, 553), + (16804394, 575), + (16804969, 574), + (16805543, 553), + (16806096, 573), + (16806669, 572), + (16807241, 554), + (16807795, 575), + (16808370, 575), + (16808945, 553), + (16809498, 575), + (16810073, 572), + (16810645, 553), + (16811198, 575), + (16811773, 575), + (16812348, 554), + (16812902, 574), + (16813476, 573), + (16814049, 554), + (16814603, 574), + (16815177, 576), + (16815753, 552), + (16816305, 574), + (16816879, 573), + (16817452, 553), + (16818005, 574), + (16818579, 574), + (16819153, 553), + (16819706, 574), + (16820280, 572), + (16820852, 553), + (16821405, 581), + (16821986, 574), + (16822560, 554), + (16823114, 581), + (16823695, 573), + (16824268, 553), + (16824821, 581), + (16825402, 576), + (16825978, 553), + (16826531, 580), + (16827111, 572), + (16827683, 553), + (16828236, 581), + (16828817, 576), + (16829393, 553), + (16829946, 580), + (16830526, 572), + (16831098, 553), + (16831651, 580), + (16832231, 575), + (16832806, 554), + (16833360, 580), + (16833940, 571), + (16834511, 552), + (16835063, 582), + (16835645, 575), + (16836220, 553), + (16836773, 580), + (16837353, 573), + (16837926, 552), + (16838478, 580), + (16839058, 575), + (16839633, 553), + (16840186, 581), + (16840767, 572), + (16841339, 554), + (16841893, 582), + (16842475, 575), + (16843050, 552), + (16843602, 582), + (16844184, 572), + (16844756, 553), + (16845309, 580), + (16845889, 576), + (16846465, 553), + (16847018, 580), + (16847598, 572), + (16848170, 552), + (16848722, 582), + (16849304, 574), + (16849878, 552), + (16850430, 582), + (16851012, 571), + (16851583, 552), + (16852135, 580), + (16852715, 574), + (16853289, 554), + (16853843, 580), + (16854423, 573), + (16854996, 553), + (16855549, 581), + (16856130, 574), + (16856704, 554), + (16857258, 582), + (16857840, 571), + (16858411, 554), + (16858965, 582), + (16859547, 575), + (16860122, 553), + (16860675, 582), + (16861257, 571), + (16861828, 553), + (16862381, 580), + (16862961, 574), + (16863535, 554), + (16864089, 581), + (16864670, 572), + (16865242, 554), + (16865796, 581), + (16866377, 574), + (16866951, 553), + (16867504, 581), + (16868085, 572), + (16868657, 552), + (16869209, 580), + (16869789, 576), + (16870365, 552), + (16870917, 582), + (16871499, 572), + (16872071, 553), + (16872624, 581), + (16873205, 575), + (16873780, 552), + (16874332, 581), + (16874913, 572), + (16875485, 553), + (16876038, 538), + (16876576, 546), + (16877122, 536), + (16877658, 545), + (16878203, 532), + (16878735, 536), + (16879271, 530), + (16879801, 545), + (16880346, 538), + (16880884, 545), + (16881429, 537), + (16881966, 583), + (16882549, 538), + (16883087, 567), + (16883654, 536), + (16884190, 528), + (16884718, 536), + (16885254, 512), + (16885766, 537), + (16886303, 544), + (16886847, 537), + (16887384, 546), + (16887930, 537), + (16888467, 547), + (16889014, 536), + (16889550, 583), + (16890133, 538), + (16890671, 567), + (16891238, 537), + (16891775, 530), + (16892305, 537), + (16892842, 511), + (16893353, 536), + (16893889, 545), + (16894434, 555), + (16894989, 555), + (16895544, 554), + (16896098, 592), + (16896690, 553), + (16897243, 577), + (16897820, 554), + (16898374, 537), + (16898911, 554), + (16899465, 520), + (16899985, 553), + (16900538, 552), + (16901090, 538), + (16901628, 547), + (16902175, 532), + (16902707, 537), + (16903244, 532), + (16903776, 547), + (16904323, 537), + (16904860, 546), + (16905406, 531), + (16905937, 537), + (16906474, 547), + (16907021, 568), + (16907589, 538), + (16908127, 545), + (16908672, 553), + (16909225, 536), + (16909761, 546), + (16910307, 514), + (16910821, 538), + (16911359, 547), + (16911906, 497), + (16912403, 536), + (16912939, 546), + (16913485, 529), + (16914014, 537), + (16914551, 531), + (16915082, 546), + (16915628, 537), + (16916165, 568), + (16916733, 547), + (16917280, 536), + (16917816, 552), + (16918368, 547), + (16918915, 537), + (16919452, 513), + (16919965, 546), + (16920511, 537), + (16921048, 497), + (16921545, 546), + (16922091, 536), + (16922627, 528), + (16923155, 546), + (16923701, 536), + (16924237, 546), + (16924783, 530), + (16925313, 538), + (16925851, 584), + (16926435, 531), + (16926966, 537), + (16927503, 566), + (16928069, 532), + (16928601, 538), + (16929139, 529), + (16929668, 531), + (16930199, 537), + (16930736, 513), + (16931249, 531), + (16931780, 537), + (16932317, 544), + (16932861, 531), + (16933392, 537), + (16933929, 531), + (16934460, 545), + (16935005, 538), + (16935543, 531), + (16936074, 583), + (16936657, 536), + (16937193, 532), + (16937725, 566), + (16938291, 536), + (16938827, 531), + (16939358, 529), + (16939887, 537), + (16940424, 531), + (16940955, 513), + (16941468, 538), + (16942006, 531), + (16942537, 544), + (16943081, 536), + (16943617, 525), + (16944142, 525), + (16944667, 526), + (16945193, 526), + (16945719, 545), + (16946264, 544), + (16946808, 535), + (16947343, 526), + (16947869, 525), + (16948394, 525), + (16948919, 525), + (16949444, 545), + (16949989, 545), + (16950534, 535), + (16951069, 526), + (16951595, 562), + (16952157, 525), + (16952682, 525), + (16953207, 580), + (16953787, 544), + (16954331, 534), + (16954865, 524), + (16955389, 545), + (16955934, 525), + (16956459, 525), + (16956984, 566), + (16957550, 544), + (16958094, 535), + (16958629, 526), + (16959155, 508), + (16959663, 525), + (16960188, 525), + (16960713, 528), + (16961241, 544), + (16961785, 535), + (16962320, 524), + (16962844, 491), + (16963335, 526), + (16963861, 525), + (16964386, 510), + (16964896, 544), + (16965440, 535), + (16965975, 525), + (16966500, 523), + (16967023, 524), + (16967547, 526), + (16968073, 543), + (16968616, 545), + (16969161, 535), + (16969696, 525), + (16970221, 526), + (16970747, 525), + (16971272, 525), + (16971797, 543), + (16972340, 544), + (16972884, 535), + (16973419, 563), + (16973982, 524), + (16974506, 525), + (16975031, 525), + (16975556, 545), + (16976101, 581), + (16976682, 536), + (16977218, 546), + (16977764, 525), + (16978289, 525), + (16978814, 525), + (16979339, 545), + (16979884, 565), + (16980449, 536), + (16980985, 508), + (16981493, 526), + (16982019, 525), + (16982544, 525), + (16983069, 544), + (16983613, 528), + (16984141, 534), + (16984675, 491), + (16985166, 525), + (16985691, 524), + (16986215, 524), + (16986739, 544), + (16987283, 509), + (16987792, 535), + (16988327, 524), + (16988851, 525), + (16989376, 524), + (16989900, 526), + (16990426, 544), + (16990970, 542), + (16991512, 533), + (16992045, 526), + (16992571, 525), + (16993096, 525), + (16993621, 525), + (16994146, 525), + (16994671, 525), + (16995196, 527), + (16995723, 529), + (16996252, 525), + (16996777, 526), + (16997303, 525), + (16997828, 525), + (16998353, 528), + (16998881, 527), + (16999408, 525), + (16999933, 526), + (17000459, 526), + (17000985, 526), + (17001511, 526), + (17002037, 528), + (17002565, 527), + (17003092, 524), + (17003616, 525), + (17004141, 525), + (17004666, 526), + (17005192, 544), + (17005736, 544), + (17006280, 535), + (17006815, 537), + (17007352, 536), + (17007888, 537), + (17008425, 537), + (17008962, 536), + (17009498, 552), + (17010050, 552), + (17010602, 534), + (17011136, 525), + (17011661, 525), + (17012186, 526), + (17012712, 526), + (17013238, 526), + (17013764, 525), + (17014289, 527), + (17014816, 528), + (17015344, 526), + (17015870, 525), + (17016395, 524), + (17016919, 529), + (17017448, 529), + (17017977, 526), + (17018503, 525), + (17019028, 526), + (17019554, 526), + (17020080, 525), + (17020605, 524), + (17021129, 528), + (17021657, 528), + (17022185, 526), + (17022711, 524), + (17023235, 525), + (17023760, 525), + (17024285, 543), + (17024828, 543), + (17025371, 535), + (17025906, 537), + (17026443, 535), + (17026978, 536), + (17027514, 537), + (17028051, 535), + (17028586, 551), + (17029137, 553), + (17029690, 535), + (17030225, 524), + (17030749, 525), + (17031274, 525), + (17031799, 525), + (17032324, 525), + (17032849, 524), + (17033373, 528), + (17033901, 527), + (17034428, 524), + (17034952, 525), + (17035477, 524), + (17036001, 529), + (17036530, 527), + (17037057, 525), + (17037582, 524), + (17038106, 525), + (17038631, 525), + (17039156, 525), + (17039681, 525), + (17040206, 529), + (17040735, 528), + (17041263, 525), + (17041788, 525), + (17042313, 525), + (17042838, 524), + (17043362, 544), + (17043906, 545), + (17044451, 535), + (17044986, 536), + (17045522, 536), + (17046058, 537), + (17046595, 537), + (17047132, 536), + (17047668, 551), + (17048219, 551), + (17048770, 534), + (17049304, 525), + (17049829, 524), + (17050353, 525), + (17050878, 524), + (17051402, 526), + (17051928, 526), + (17052454, 529), + (17052983, 528), + (17053511, 526), + (17054037, 526), + (17054563, 526), + (17055089, 529), + (17055618, 528), + (17056146, 526), + (17056672, 526), + (17057198, 524), + (17057722, 524), + (17058246, 524), + (17058770, 525), + (17059295, 528), + (17059823, 528), + (17060351, 525), + (17060876, 524), + (17061400, 525), + (17061925, 525), + (17062450, 544), + (17062994, 545), + (17063539, 535), + (17064074, 536), + (17064610, 574), + (17065184, 536), + (17065720, 536), + (17066256, 537), + (17066793, 552), + (17067345, 553), + (17067898, 536), + (17068434, 524), + (17068958, 524), + (17069482, 525), + (17070007, 526), + (17070533, 526), + (17071059, 524), + (17071583, 528), + (17072111, 528), + (17072639, 526), + (17073165, 526), + (17073691, 524), + (17074215, 527), + (17074742, 527), + (17075269, 525), + (17075794, 525), + (17076319, 526), + (17076845, 525), + (17077370, 524), + (17077894, 526), + (17078420, 528), + (17078948, 528), + (17079476, 525), + (17080001, 525), + (17080526, 525), + (17081051, 525), + (17081576, 543), + (17082119, 544), + (17082663, 537), + (17083200, 535), + (17083735, 557), + (17084292, 535), + (17084827, 536), + (17085363, 537), + (17085900, 552), + (17086452, 553), + (17087005, 535), + (17087540, 525), + (17088065, 526), + (17088591, 525), + (17089116, 525), + (17089641, 526), + (17090167, 525), + (17090692, 529), + (17091221, 529), + (17091750, 525), + (17092275, 525), + (17092800, 525), + (17093325, 527), + (17093852, 527), + (17094379, 526), + (17094905, 524), + (17095429, 525), + (17095954, 525), + (17096479, 525), + (17097004, 524), + (17097528, 528), + (17098056, 527), + (17098583, 526), + (17099109, 526), + (17099635, 524), + (17100159, 525), + (17100684, 544), + (17101228, 545), + (17101773, 537), + (17102310, 537), + (17102847, 519), + (17103366, 536), + (17103902, 537), + (17104439, 536), + (17104975, 553), + (17105528, 552), + (17106080, 536), + (17106616, 524), + (17107140, 526), + (17107666, 526), + (17108192, 526), + (17108718, 526), + (17109244, 524), + (17109768, 527), + (17110295, 527), + (17110822, 526), + (17111348, 525), + (17111873, 526), + (17112399, 528), + (17112927, 527), + (17113454, 525), + (17113979, 525), + (17114504, 525), + (17115029, 524), + (17115553, 526), + (17116079, 525), + (17116604, 527), + (17117131, 528), + (17117659, 525), + (17118184, 525), + (17118709, 526), + (17119235, 525), + (17119760, 544), + (17120304, 544), + (17120848, 537), + (17121385, 536), + (17121921, 501), + (17122422, 536), + (17122958, 536), + (17123494, 536), + (17124030, 553), + (17124583, 552), + (17125135, 534), + (17125669, 524), + (17126193, 524), + (17126717, 525), + (17127242, 526), + (17127768, 525), + (17128293, 525), + (17128818, 528), + (17129346, 528), + (17129874, 525), + (17130399, 524), + (17130923, 525), + (17131448, 528), + (17131976, 528), + (17132504, 524), + (17133028, 525), + (17133553, 525), + (17134078, 525), + (17134603, 524), + (17135127, 525), + (17135652, 528), + (17136180, 529), + (17136709, 526), + (17137235, 525), + (17137760, 525), + (17138285, 525), + (17138810, 545), + (17139355, 545), + (17139900, 537), + (17140437, 537), + (17140974, 534), + (17141508, 536), + (17142044, 537), + (17142581, 537), + (17143118, 552), + (17143670, 551), + (17144221, 535), + (17144756, 526), + (17145282, 525), + (17145807, 525), + (17146332, 526), + (17146858, 525), + (17147383, 525), + (17147908, 529), + (17148437, 527), + (17148964, 526), + (17149490, 526), + (17150016, 526), + (17150542, 528), + (17151070, 527), + (17151597, 525), + (17152122, 524), + (17152646, 526), + (17153172, 525), + (17153697, 526), + (17154223, 525), + (17154748, 528), + (17155276, 527), + (17155803, 525), + (17156328, 525), + (17156853, 525), + (17157378, 525), + (17157903, 543), + (17158446, 543), + (17158989, 535), + (17159524, 536), + (17160060, 535), + (17160595, 537), + (17161132, 537), + (17161669, 536), + (17162205, 552), + (17162757, 551), + (17163308, 536), + (17163844, 524), + (17164368, 525), + (17164893, 526), + (17165419, 526), + (17165945, 526), + (17166471, 526), + (17166997, 529), + (17167526, 528), + (17168054, 525), + (17168579, 526), + (17169105, 526), + (17169631, 528), + (17170159, 528), + (17170687, 524), + (17171211, 525), + (17171736, 524), + (17172260, 526), + (17172786, 525), + (17173311, 524), + (17173835, 528), + (17174363, 528), + (17174891, 525), + (17175416, 524), + (17175940, 525), + (17176465, 525), + (17176990, 543), + (17177533, 543), + (17178076, 537), + (17178613, 535), + (17179148, 536), + (17179684, 572), + (17180256, 536), + (17180792, 537), + (17181329, 553), + (17181882, 551), + (17182433, 535), + (17182968, 524), + (17183492, 525), + (17184017, 526), + (17184543, 526), + (17185069, 525), + (17185594, 526), + (17186120, 528), + (17186648, 528), + (17187176, 525), + (17187701, 525), + (17188226, 525), + (17188751, 527), + (17189278, 527), + (17189805, 524), + (17190329, 525), + (17190854, 525), + (17191379, 524), + (17191903, 525), + (17192428, 524), + (17192952, 527), + (17193479, 527), + (17194006, 526), + (17194532, 524), + (17195056, 525), + (17195581, 525), + (17196106, 544), + (17196650, 545), + (17197195, 536), + (17197731, 537), + (17198268, 535), + (17198803, 556), + (17199359, 536), + (17199895, 536), + (17200431, 552), + (17200983, 552), + (17201535, 535), + (17202070, 526), + (17202596, 526), + (17203122, 525), + (17203647, 526), + (17204173, 526), + (17204699, 525), + (17205224, 528), + (17205752, 527), + (17206279, 525), + (17206804, 525), + (17207329, 525), + (17207854, 528), + (17208382, 528), + (17208910, 524), + (17209434, 524), + (17209958, 525), + (17210483, 524), + (17211007, 524), + (17211531, 525), + (17212056, 527), + (17212583, 528), + (17213111, 525), + (17213636, 525), + (17214161, 526), + (17214687, 524), + (17215211, 544), + (17215755, 544), + (17216299, 535), + (17216834, 537), + (17217371, 535), + (17217906, 520), + (17218426, 535), + (17218961, 535), + (17219496, 552), + (17220048, 552), + (17220600, 534), + (17221134, 525), + (17221659, 525), + (17222184, 526), + (17222710, 526), + (17223236, 525), + (17223761, 526), + (17224287, 528), + (17224815, 529), + (17225344, 524), + (17225868, 526), + (17226394, 526), + (17226920, 529), + (17227449, 529), + (17227978, 525), + (17228503, 525), + (17229028, 526), + (17229554, 526), + (17230080, 526), + (17230606, 524), + (17231130, 529), + (17231659, 528), + (17232187, 525), + (17232712, 525), + (17233237, 524), + (17233761, 524), + (17234285, 545), + (17234830, 544), + (17235374, 535), + (17235909, 536), + (17236445, 535), + (17236980, 501), + (17237481, 536), + (17238017, 537), + (17238554, 552), + (17239106, 553), + (17239659, 534), + (17240193, 526), + (17240719, 525), + (17241244, 525), + (17241769, 526), + (17242295, 525), + (17242820, 525), + (17243345, 529), + (17243874, 529), + (17244403, 525), + (17244928, 525), + (17245453, 525), + (17245978, 528), + (17246506, 527), + (17247033, 525), + (17247558, 524), + (17248082, 525), + (17248607, 525), + (17249132, 526), + (17249658, 525), + (17250183, 528), + (17250711, 527), + (17251238, 525), + (17251763, 525), + (17252288, 524), + (17252812, 525), + (17253337, 544), + (17253881, 543), + (17254424, 535), + (17254959, 536), + (17255495, 535), + (17256030, 534), + (17256564, 535), + (17257099, 536), + (17257635, 552), + (17258187, 552), + (17258739, 535), + (17259274, 525), + (17259799, 526), + (17260325, 525), + (17260850, 526), + (17261376, 525), + (17261901, 526), + (17262427, 529), + (17262956, 528), + (17263484, 526), + (17264010, 525), + (17264535, 525), + (17265060, 529), + (17265589, 528), + (17266117, 526), + (17266643, 525), + (17267168, 525), + (17267693, 526), + (17268219, 524), + (17268743, 525), + (17269268, 528), + (17269796, 528), + (17270324, 525), + (17270849, 525), + (17271374, 525), + (17271899, 524), + (17272423, 544), + (17272967, 545), + (17273512, 536), + (17274048, 536), + (17274584, 536), + (17275120, 536), + (17275656, 537), + (17276193, 536), + (17276729, 551), + (17277280, 553), + (17277833, 536), + (17278369, 525), + (17278894, 525), + (17279419, 525), + (17279944, 525), + (17280469, 526), + (17280995, 525), + (17281520, 529), + (17282049, 529), + (17282578, 525), + (17283103, 524), + (17283627, 526), + (17284153, 528), + (17284681, 528), + (17285209, 525), + (17285734, 524), + (17286258, 525), + (17286783, 525), + (17287308, 526), + (17287834, 526), + (17288360, 529), + (17288889, 528), + (17289417, 525), + (17289942, 526), + (17290468, 525), + (17290993, 525), + (17291518, 545), + (17292063, 543), + (17292606, 536), + (17293142, 536), + (17293678, 537), + (17294215, 536), + (17294751, 536), + (17295287, 535), + (17295822, 589), + (17296411, 552), + (17296963, 536), + (17297499, 524), + (17298023, 524), + (17298547, 525), + (17299072, 525), + (17299597, 525), + (17300122, 526), + (17300648, 527), + (17301175, 527), + (17301702, 524), + (17302226, 525), + (17302751, 526), + (17303277, 528), + (17303805, 528), + (17304333, 524), + (17304857, 525), + (17305382, 525), + (17305907, 526), + (17306433, 525), + (17306958, 525), + (17307483, 528), + (17308011, 528), + (17308539, 525), + (17309064, 525), + (17309589, 525), + (17310114, 525), + (17310639, 544), + (17311183, 544), + (17311727, 536), + (17312263, 535), + (17312798, 535), + (17313333, 535), + (17313868, 535), + (17314403, 535), + (17314938, 573), + (17315511, 551), + (17316062, 535), + (17316597, 525), + (17317122, 526), + (17317648, 524), + (17318172, 526), + (17318698, 525), + (17319223, 524), + (17319747, 528), + (17320275, 527), + (17320802, 525), + (17321327, 524), + (17321851, 525), + (17322376, 528), + (17322904, 529), + (17323433, 525), + (17323958, 526), + (17324484, 525), + (17325009, 524), + (17325533, 525), + (17326058, 524), + (17326582, 529), + (17327111, 528), + (17327639, 526), + (17328165, 525), + (17328690, 526), + (17329216, 526), + (17329742, 544), + (17330286, 545), + (17330831, 535), + (17331366, 535), + (17331901, 536), + (17332437, 537), + (17332974, 537), + (17333511, 537), + (17334048, 535), + (17334583, 552), + (17335135, 534), + (17335669, 525), + (17336194, 524), + (17336718, 525), + (17337243, 526), + (17337769, 525), + (17338294, 524), + (17338818, 529), + (17339347, 528), + (17339875, 525), + (17340400, 525), + (17340925, 525), + (17341450, 528), + (17341978, 527), + (17342505, 525), + (17343030, 524), + (17343554, 524), + (17344078, 526), + (17344604, 525), + (17345129, 525), + (17345654, 527), + (17346181, 528), + (17346709, 525), + (17347234, 526), + (17347760, 526), + (17348286, 525), + (17348811, 545), + (17349356, 543), + (17349899, 536), + (17350435, 536), + (17350971, 536), + (17351507, 536), + (17352043, 535), + (17352578, 537), + (17353115, 518), + (17353633, 552), + (17354185, 536), + (17354721, 525), + (17355246, 525), + (17355771, 525), + (17356296, 526), + (17356822, 526), + (17357348, 525), + (17357873, 528), + (17358401, 528), + (17358929, 524), + (17359453, 524), + (17359977, 524), + (17360501, 529), + (17361030, 527), + (17361557, 524), + (17362081, 525), + (17362606, 524), + (17363130, 525), + (17363655, 526), + (17364181, 526), + (17364707, 528), + (17365235, 527), + (17365762, 526), + (17366288, 524), + (17366812, 524), + (17367336, 525), + (17367861, 544), + (17368405, 544), + (17368949, 537), + (17369486, 535), + (17370021, 536), + (17370557, 537), + (17371094, 536), + (17371630, 536), + (17372166, 550), + (17372716, 553), + (17373269, 1472), + (17374741, 579), + (17375320, 893), + (17376213, 2911), + (17379124, 914), + (17380038, 1980), + (17382018, 1421), + (17383439, 1342), + (17384781, 993), + (17385774, 1188), + (17386962, 2104), + (17389066, 837), + (17389903, 1122), + (17391025, 1620), + (17392645, 1670), + (17394315, 867), + (17395182, 1172), + (17396354, 2711), + (17399065, 1169), + (17400234, 1706), + (17401940, 1228), + (17403168, 2135), + (17405303, 1371), + (17406674, 1295), + (17407969, 1095), + (17409064, 1477), + (17410541, 950), + (17411491, 983), + (17412474, 525), + (17412999, 675), + (17413674, 6404), + (17420078, 938), + (17421016, 543), + (17421559, 655), + (17422214, 682), +]; +const CASES: &[Case] = &[ + Case { id: "crl::structure::crl-invalid-signature", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "undetermined", trusted: &[1], intermediates: &[], leaf: 0 }, + Case { id: "crl::structure::crl-wrong-signing-key", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "undetermined", trusted: &[3, 4], intermediates: &[], leaf: 2 }, + Case { id: "crl::structure::crl-empty", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "undetermined", trusted: &[6], intermediates: &[], leaf: 5 }, + Case { id: "crl::structure::crl-very-large", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "undetermined", trusted: &[8], intermediates: &[], leaf: 7 }, + Case { id: "crl::structure::crl-duplicate-revoked-serial", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "undetermined", trusted: &[10], intermediates: &[], leaf: 9 }, + Case { id: "crl::structure::crl-unknown-critical-extension", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "undetermined", trusted: &[12], intermediates: &[], leaf: 11 }, + Case { id: "crl::structure::crl-unknown-noncritical-extension", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "undetermined", trusted: &[14], intermediates: &[], leaf: 13 }, + Case { id: "crl::structure::entry-unknown-critical-extension", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "undetermined", trusted: &[16], intermediates: &[], leaf: 15 }, + Case { id: "crl::structure::entry-unknown-noncritical-extension", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "undetermined", trusted: &[18], intermediates: &[], leaf: 17 }, + Case { id: "crl::revoked-certificate-with-crl", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "revoked.example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "high", trusted: &[20], intermediates: &[], leaf: 19 }, + Case { id: "crl::crlnumber-missing", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "missing-crlnumber.example.com"), peer_names: &[], time: "1970-01-01T00:00:03+00:00", features: &["has-crl"], importance: "high", trusted: &[22], intermediates: &[], leaf: 21 }, + Case { id: "crl::certificate-not-on-crl", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "high", trusted: &[24], intermediates: &[], leaf: 23 }, + Case { id: "crl::certificate-serial-on-crl-different-issuer", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "high", trusted: &[26, 27], intermediates: &[], leaf: 25 }, + Case { id: "crl::crlnumber-critical", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "crlnumber-critical.example.com"), peer_names: &[], time: "1970-01-01T00:00:03+00:00", features: &["has-crl"], importance: "high", trusted: &[29], intermediates: &[], leaf: 28 }, + Case { id: "crl::issuer-missing-crlsign", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "issuer-missing-crlsign.example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "high", trusted: &[31], intermediates: &[], leaf: 30 }, + Case { id: "crl::issuer-no-keyusage-extension", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "issuer-no-keyusage.example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "high", trusted: &[33], intermediates: &[], leaf: 32 }, + Case { id: "crl::issuer-valid-crlsign-and-keycertsign", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "issuer-valid-crlsign.example.com"), peer_names: &[], time: "2024-01-01T00:00:00+00:00", features: &["has-crl"], importance: "high", trusted: &[35], intermediates: &[], leaf: 34 }, + Case { id: "cve::cve-2024-0567", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "cve-2024-0567.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[37], intermediates: &[38, 39, 40, 41, 42, 43, 44, 45, 46], leaf: 36 }, + Case { id: "cve::cve-2025-61727", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "bar.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[48], intermediates: &[49], leaf: 47 }, + Case { id: "cve::cve-2025-61727-nc-permits-variant", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "foo.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[51], intermediates: &[52], leaf: 50 }, + Case { id: "invalid::invalid-issuer-key", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[54], intermediates: &[55], leaf: 53 }, + Case { id: "pathlen::ee-with-intermediate-pathlen-0", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[57], intermediates: &[58], leaf: 56 }, + Case { id: "pathlen::ee-with-intermediate-pathlen-1", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[60], intermediates: &[61], leaf: 59 }, + Case { id: "pathlen::ee-with-intermediate-pathlen-2", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[63], intermediates: &[64], leaf: 62 }, + Case { id: "pathlen::validation-ignores-pathlen-in-leaf", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[66], intermediates: &[67], leaf: 65 }, + Case { id: "pathlen::intermediate-violates-pathlen-0", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[69], intermediates: &[70, 71], leaf: 68 }, + Case { id: "pathlen::intermediate-pathlen-may-increase", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[73], intermediates: &[74, 75], leaf: 72 }, + Case { id: "pathlen::intermediate-pathlen-too-long", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[77], intermediates: &[78, 79, 80], leaf: 76 }, + Case { id: "pathlen::self-issued-certs-pathlen", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[82], intermediates: &[83, 84, 85], leaf: 81 }, + Case { id: "pathlen::max-chain-depth-0", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["max-chain-depth"], importance: "undetermined", trusted: &[87], intermediates: &[], leaf: 86 }, + Case { id: "pathlen::max-chain-depth-0-exhausted", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["max-chain-depth"], importance: "undetermined", trusted: &[89], intermediates: &[90], leaf: 88 }, + Case { id: "pathlen::max-chain-depth-1", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["max-chain-depth"], importance: "undetermined", trusted: &[92], intermediates: &[93], leaf: 91 }, + Case { id: "pathlen::max-chain-depth-1-exhausted", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["max-chain-depth"], importance: "undetermined", trusted: &[95], intermediates: &[96, 97], leaf: 94 }, + Case { id: "pathlen::max-chain-depth-1-self-issued", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["max-chain-depth"], importance: "undetermined", trusted: &[99], intermediates: &[100, 101], leaf: 98 }, + Case { id: "pathological::multiple-chains-expired-intermediate", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[103, 104], intermediates: &[105], leaf: 102 }, + Case { id: "pathological::intermediate-cycle-distinct-cas", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[107], intermediates: &[108, 109], leaf: 106 }, + Case { id: "pathological::intermediate-cycle-distinct-cas-max-depth", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[111], intermediates: &[112, 113], leaf: 110 }, + Case { id: "pathological::intermediate-cycle-same-logical-ca", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[115], intermediates: &[116, 117], leaf: 114 }, + Case { id: "pathological::nc-dos-1", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "t0.test"), peer_names: &[], time: "", features: &["denial-of-service"], importance: "undetermined", trusted: &[119], intermediates: &[], leaf: 118 }, + Case { id: "pathological::nc-dos-2", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "t0.test"), peer_names: &[], time: "", features: &["denial-of-service"], importance: "undetermined", trusted: &[121], intermediates: &[], leaf: 120 }, + Case { id: "pathological::nc-dos-3", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "t0.test"), peer_names: &[], time: "", features: &["denial-of-service"], importance: "undetermined", trusted: &[123], intermediates: &[], leaf: 122 }, + Case { id: "pathological::pathological-chain-distinct-subject-distinct-key", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["denial-of-service"], importance: "undetermined", trusted: &[125], intermediates: &[126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225], leaf: 124 }, + Case { id: "pathological::pathological-chain-same-subject-distinct-key", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["denial-of-service"], importance: "undetermined", trusted: &[227], intermediates: &[228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327], leaf: 226 }, + Case { id: "pathological::pathological-chain-distinct-subject-same-key", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["denial-of-service"], importance: "undetermined", trusted: &[329], intermediates: &[330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429], leaf: 328 }, + Case { id: "pathological::pathological-chain-same-subject-same-key", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["denial-of-service"], importance: "undetermined", trusted: &[431], intermediates: &[432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531], leaf: 430 }, + Case { id: "rfc5280::aki::critical-aki", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[533], intermediates: &[], leaf: 532 }, + Case { id: "rfc5280::aki::leaf-missing-aki", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[535], intermediates: &[], leaf: 534 }, + Case { id: "rfc5280::aki::intermediate-missing-aki", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[537], intermediates: &[538], leaf: 536 }, + Case { id: "rfc5280::aki::self-signed-root-missing-aki", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[540], intermediates: &[], leaf: 539 }, + Case { id: "rfc5280::aki::cross-signed-root-missing-aki", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-rfc5280"], importance: "undetermined", trusted: &[542], intermediates: &[], leaf: 541 }, + Case { id: "rfc5280::eku::ee-wrong-eku", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[544], intermediates: &[], leaf: 543 }, + Case { id: "rfc5280::eku::ee-without-eku", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[546], intermediates: &[], leaf: 545 }, + Case { id: "rfc5280::eku::ee-eku-empty", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[548], intermediates: &[], leaf: 547 }, + Case { id: "rfc5280::nc::permitted-dns-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[550], intermediates: &[], leaf: 549 }, + Case { id: "rfc5280::nc::excluded-dns-match", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[552], intermediates: &[553], leaf: 551 }, + Case { id: "rfc5280::nc::permitted-dns-match", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[555], intermediates: &[], leaf: 554 }, + Case { id: "rfc5280::nc::permitted-dns-match-noncritical", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["rfc5280-incompatible-with-webpki"], importance: "undetermined", trusted: &[557], intermediates: &[], leaf: 556 }, + Case { id: "rfc5280::nc::permitted-dns-match-more", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "foo.bar.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[559], intermediates: &[], leaf: 558 }, + Case { id: "rfc5280::nc::excluded-dns-match-second", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[561], intermediates: &[], leaf: 560 }, + Case { id: "rfc5280::nc::permitted-ip-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("IP", "192.0.3.1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[563], intermediates: &[], leaf: 562 }, + Case { id: "rfc5280::nc::excluded-ipv4-match", kind: "SERVER", expected: "FAILURE", peer: ("IP", "192.0.2.1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[565], intermediates: &[], leaf: 564 }, + Case { id: "rfc5280::nc::excluded-ipv6-match", kind: "SERVER", expected: "FAILURE", peer: ("IP", "::1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[567], intermediates: &[], leaf: 566 }, + Case { id: "rfc5280::nc::permitted-ipv4-match", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "192.0.2.1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[569], intermediates: &[], leaf: 568 }, + Case { id: "rfc5280::nc::permitted-ipv6-match", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "::1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[571], intermediates: &[], leaf: 570 }, + Case { id: "rfc5280::nc::permitted-dn-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["name-constraint-dn"], importance: "undetermined", trusted: &[573], intermediates: &[], leaf: 572 }, + Case { id: "rfc5280::nc::excluded-dn-match", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["name-constraint-dn"], importance: "undetermined", trusted: &[575], intermediates: &[], leaf: 574 }, + Case { id: "rfc5280::nc::permitted-dn-match", kind: "SERVER", expected: "SUCCESS", peer: ("", ""), peer_names: &[], time: "", features: &["name-constraint-dn"], importance: "undetermined", trusted: &[577], intermediates: &[], leaf: 576 }, + Case { id: "rfc5280::nc::permitted-dn-match-subject-san-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["name-constraint-dn"], importance: "undetermined", trusted: &[579], intermediates: &[], leaf: 578 }, + Case { id: "rfc5280::nc::excluded-dn-match-sub-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["name-constraint-dn"], importance: "undetermined", trusted: &[581], intermediates: &[], leaf: 580 }, + Case { id: "rfc5280::nc::permitted-self-issued", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[583], intermediates: &[584], leaf: 582 }, + Case { id: "rfc5280::nc::excluded-self-issued-leaf", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "not-example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[586], intermediates: &[587], leaf: 585 }, + Case { id: "rfc5280::nc::excluded-match-permitted-and-excluded", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[589], intermediates: &[], leaf: 588 }, + Case { id: "rfc5280::nc::permitted-empty-sequence-excluded-nonempty", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-rfc5280"], importance: "undetermined", trusted: &[591], intermediates: &[592], leaf: 590 }, + Case { id: "rfc5280::nc::permitted-nonempty-excluded-nonempty", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-rfc5280"], importance: "undetermined", trusted: &[594], intermediates: &[595], leaf: 593 }, + Case { id: "rfc5280::nc::permitted-nonempty-excluded-empty-sequence", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-rfc5280"], importance: "undetermined", trusted: &[597], intermediates: &[598], leaf: 596 }, + Case { id: "rfc5280::nc::permitted-different-constraint-type", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[600], intermediates: &[], leaf: 599 }, + Case { id: "rfc5280::nc::excluded-different-constraint-type", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[602], intermediates: &[], leaf: 601 }, + Case { id: "rfc5280::nc::invalid-dnsname-wildcard", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "foo.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[604], intermediates: &[], leaf: 603 }, + Case { id: "rfc5280::nc::invalid-dnsname-leading-period", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "foo.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[606], intermediates: &[], leaf: 605 }, + Case { id: "rfc5280::nc::invalid-ipv4-address", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[608], intermediates: &[], leaf: 607 }, + Case { id: "rfc5280::nc::invalid-ipv6-address", kind: "SERVER", expected: "FAILURE", peer: ("IP", "::1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[610], intermediates: &[], leaf: 609 }, + Case { id: "rfc5280::nc::invalid-email-address", kind: "CLIENT", expected: "FAILURE", peer: ("", ""), peer_names: &[("RFC822", "example@example.com")], time: "", features: &[], importance: "undetermined", trusted: &[612], intermediates: &[], leaf: 611 }, + Case { id: "rfc5280::nc::not-allowed-in-ee-noncritical", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[614], intermediates: &[], leaf: 613 }, + Case { id: "rfc5280::nc::not-allowed-in-ee-critical", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[616], intermediates: &[], leaf: 615 }, + Case { id: "rfc5280::nc::intermediate-with-san-rejected-by-intermediate-nc", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "permitted.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[618], intermediates: &[619, 620], leaf: 617 }, + Case { id: "rfc5280::nc::intermediate-with-san-rejected-by-root-nc", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "permitted.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[622], intermediates: &[623, 624], leaf: 621 }, + Case { id: "rfc5280::nc::restrictive-permits-in-intermediates-narrows", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "foo.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[626], intermediates: &[627, 628], leaf: 625 }, + Case { id: "rfc5280::nc::restrictive-permits-in-intermediates-widens", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "foo.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[630], intermediates: &[631, 632], leaf: 629 }, + Case { id: "rfc5280::nc::nc-permits-invalid-dns-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "foo.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[634], intermediates: &[635], leaf: 633 }, + Case { id: "rfc5280::nc::nc-permits-invalid-ip-san", kind: "SERVER", expected: "FAILURE", peer: ("IP", "192.0.2.1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[637], intermediates: &[638], leaf: 636 }, + Case { id: "rfc5280::nc::nc-permits-invalid-email-san", kind: "CLIENT", expected: "FAILURE", peer: ("", ""), peer_names: &[("RFC822", "good@example.com"), ("RFC822", "alsogood@example.com")], time: "", features: &[], importance: "undetermined", trusted: &[640], intermediates: &[641], leaf: 639 }, + Case { id: "rfc5280::nc::nc-forbids-alternate-chain-ica", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "permitted.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[643], intermediates: &[644, 645, 646], leaf: 642 }, + Case { id: "rfc5280::nc::nc-forbids-same-chain-ica", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "unconstrained.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[648, 649], intermediates: &[650, 651, 652], leaf: 647 }, + Case { id: "rfc5280::nc::nc-permits-email-exact", kind: "CLIENT", expected: "SUCCESS", peer: ("", ""), peer_names: &[("RFC822", "foo@example.com")], time: "", features: &[], importance: "undetermined", trusted: &[654], intermediates: &[655], leaf: 653 }, + Case { id: "rfc5280::nc::nc-permits-email-domain", kind: "CLIENT", expected: "SUCCESS", peer: ("", ""), peer_names: &[("RFC822", "foo@example.com")], time: "", features: &[], importance: "undetermined", trusted: &[657], intermediates: &[658], leaf: 656 }, + Case { id: "rfc5280::nc::nc-permits-email-domain-rejects-subdomain", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[660], intermediates: &[661], leaf: 659 }, + Case { id: "rfc5280::nc::nc-permits-email-subdomains-rejects-apex", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[663], intermediates: &[664], leaf: 662 }, + Case { id: "rfc5280::nc::nc-permits-email-literal-asterisk-exact-match", kind: "CLIENT", expected: "SUCCESS", peer: ("", ""), peer_names: &[("RFC822", "*@example.com")], time: "", features: &[], importance: "undetermined", trusted: &[666], intermediates: &[667], leaf: 665 }, + Case { id: "rfc5280::nc::nc-permits-email-literal-asterisk-rejects-user", kind: "CLIENT", expected: "FAILURE", peer: ("", ""), peer_names: &[("RFC822", "user@example.com")], time: "", features: &[], importance: "undetermined", trusted: &[669], intermediates: &[670], leaf: 668 }, + Case { id: "rfc5280::nc::nc-permits-email-literal-asterisk-rejects-subdomain", kind: "CLIENT", expected: "FAILURE", peer: ("", ""), peer_names: &[("RFC822", "*@subdomain.example.com")], time: "", features: &[], importance: "undetermined", trusted: &[672], intermediates: &[673], leaf: 671 }, + Case { id: "rfc5280::nc::nc-permits-email-literal-double-asterisk", kind: "CLIENT", expected: "SUCCESS", peer: ("", ""), peer_names: &[("RFC822", "**@example.com")], time: "", features: &[], importance: "undetermined", trusted: &[675], intermediates: &[676], leaf: 674 }, + Case { id: "rfc5280::nc::nc-permits-email-literal-double-asterisk-rejects-single", kind: "CLIENT", expected: "FAILURE", peer: ("", ""), peer_names: &[("RFC822", "*@example.com")], time: "", features: &[], importance: "undetermined", trusted: &[678], intermediates: &[679], leaf: 677 }, + Case { id: "rfc5280::nc::nc-permits-email-literal-mid-asterisk", kind: "CLIENT", expected: "SUCCESS", peer: ("", ""), peer_names: &[("RFC822", "user*@example.com")], time: "", features: &[], importance: "undetermined", trusted: &[681], intermediates: &[682], leaf: 680 }, + Case { id: "rfc5280::nc::nc-permits-uri-host-rejects-subdomain", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[684], intermediates: &[685], leaf: 683 }, + Case { id: "rfc5280::nc::nc-permits-uri-subdomains-rejects-apex", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[687], intermediates: &[688], leaf: 686 }, + Case { id: "rfc5280::nc::nc-forbids-othername", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[690], intermediates: &[691], leaf: 689 }, + Case { id: "rfc5280::nc::nc-forbids-othername-noop", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[693], intermediates: &[694], leaf: 692 }, + Case { id: "rfc5280::nc::nc-forbids-dnsname-wildcard-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "bar.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[696], intermediates: &[697], leaf: 695 }, + Case { id: "rfc5280::pc::ica-noncritical-pc", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["has-policy-constraints"], importance: "undetermined", trusted: &[699], intermediates: &[700], leaf: 698 }, + Case { id: "rfc5280::san::malformed", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[702], intermediates: &[], leaf: 701 }, + Case { id: "rfc5280::san::noncritical-with-empty-subject", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[704], intermediates: &[], leaf: 703 }, + Case { id: "rfc5280::san::underscore-dns", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "foo_bar.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[706], intermediates: &[], leaf: 705 }, + Case { id: "rfc5280::san::ip-in-dns", kind: "SERVER", expected: "FAILURE", peer: ("IP", "8.8.8.8"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[708], intermediates: &[], leaf: 707 }, + Case { id: "rfc5280::serial::too-long", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-serial-number"], importance: "undetermined", trusted: &[710], intermediates: &[], leaf: 709 }, + Case { id: "rfc5280::serial::zero", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-serial-number"], importance: "undetermined", trusted: &[712], intermediates: &[], leaf: 711 }, + Case { id: "rfc5280::serial::negative", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "gov.us"), peer_names: &[], time: "2016-09-01T00:00:00+00:00", features: &["pedantic-serial-number"], importance: "undetermined", trusted: &[713], intermediates: &[], leaf: 713 }, + Case { id: "rfc5280::ski::critical-ski", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[715], intermediates: &[], leaf: 714 }, + Case { id: "rfc5280::ski::root-missing-ski", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[717], intermediates: &[], leaf: 716 }, + Case { id: "rfc5280::ski::intermediate-missing-ski", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[719], intermediates: &[720], leaf: 718 }, + Case { id: "rfc5280::validity::expired-root", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2022-01-01T00:00:00+00:00", features: &[], importance: "undetermined", trusted: &[722], intermediates: &[723], leaf: 721 }, + Case { id: "rfc5280::validity::expired-intermediate", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2022-01-01T00:00:00+00:00", features: &[], importance: "critical", trusted: &[725], intermediates: &[726], leaf: 724 }, + Case { id: "rfc5280::validity::expired-leaf", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2022-01-01T00:00:00+00:00", features: &[], importance: "critical", trusted: &[728], intermediates: &[729], leaf: 727 }, + Case { id: "rfc5280::validity::notbefore-exact", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-03-01T00:00:00+00:00", features: &[], importance: "undetermined", trusted: &[731], intermediates: &[732], leaf: 730 }, + Case { id: "rfc5280::validity::notbefore-fractional", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-03-01T00:00:00.999+00:00", features: &[], importance: "undetermined", trusted: &[734], intermediates: &[735], leaf: 733 }, + Case { id: "rfc5280::validity::notafter-exact", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-04-01T00:00:00+00:00", features: &[], importance: "undetermined", trusted: &[737], intermediates: &[738], leaf: 736 }, + Case { id: "rfc5280::validity::notafter-fractional", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-04-01T00:00:00.005+00:00", features: &[], importance: "undetermined", trusted: &[740], intermediates: &[741], leaf: 739 }, + Case { id: "rfc5280::validity::expired-1-second", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-04-01T00:00:01+00:00", features: &[], importance: "critical", trusted: &[743], intermediates: &[744], leaf: 742 }, + Case { id: "rfc5280::validity::expired-5-seconds", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-04-01T00:00:05+00:00", features: &[], importance: "critical", trusted: &[746], intermediates: &[747], leaf: 745 }, + Case { id: "rfc5280::validity::not-yet-valid-1-second", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-03-01T00:00:00+00:00", features: &[], importance: "critical", trusted: &[749], intermediates: &[750], leaf: 748 }, + Case { id: "rfc5280::validity::not-yet-valid-5-seconds", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-03-01T00:00:00+00:00", features: &[], importance: "critical", trusted: &[752], intermediates: &[753], leaf: 751 }, + Case { id: "rfc5280::ee-empty-issuer", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[755], intermediates: &[], leaf: 754 }, + Case { id: "rfc5280::ca-empty-subject", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[757], intermediates: &[], leaf: 756 }, + Case { id: "rfc5280::unknown-critical-extension-ee", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[759], intermediates: &[], leaf: 758 }, + Case { id: "rfc5280::unknown-critical-extension-root", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[761], intermediates: &[], leaf: 760 }, + Case { id: "rfc5280::unknown-critical-extension-unrelated-root", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[763, 764], intermediates: &[], leaf: 762 }, + Case { id: "rfc5280::unknown-critical-extension-unrelated-intermediate", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[766], intermediates: &[767, 768], leaf: 765 }, + Case { id: "rfc5280::unknown-critical-extension-intermediate", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[770], intermediates: &[771], leaf: 769 }, + Case { id: "rfc5280::chain-untrusted-root", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[773], intermediates: &[774, 775], leaf: 772 }, + Case { id: "rfc5280::intermediate-ca-without-ca-bit", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[777], intermediates: &[778], leaf: 776 }, + Case { id: "rfc5280::intermediate-ca-missing-basic-constraints", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[780], intermediates: &[], leaf: 779 }, + Case { id: "rfc5280::root-missing-basic-constraints", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[782], intermediates: &[], leaf: 781 }, + Case { id: "rfc5280::root-non-critical-basic-constraints", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[784], intermediates: &[], leaf: 783 }, + Case { id: "rfc5280::root-inconsistent-ca-extensions", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[786], intermediates: &[], leaf: 785 }, + Case { id: "rfc5280::ica-ku-keycertsign", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[788], intermediates: &[], leaf: 787 }, + Case { id: "rfc5280::leaf-ku-keycertsign", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[790], intermediates: &[], leaf: 789 }, + Case { id: "rfc5280::ee-aia", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[792], intermediates: &[], leaf: 791 }, + Case { id: "rfc5280::ee-critical-aia-invalid", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[794], intermediates: &[], leaf: 793 }, + Case { id: "rfc5280::duplicate-extensions", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[796], intermediates: &[], leaf: 795 }, + Case { id: "rfc5280::no-keyusage", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[798], intermediates: &[], leaf: 797 }, + Case { id: "rfc5280::no-basicconstraints", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[800], intermediates: &[], leaf: 799 }, + Case { id: "rfc5280::mismatching-signature-algorithm", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "cryptography.io"), peer_names: &[], time: "2023-07-10T00:00:00+00:00", features: &[], importance: "undetermined", trusted: &[802], intermediates: &[803], leaf: 801 }, + Case { id: "rfc5280::ca-as-leaf", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "ca.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[805], intermediates: &[], leaf: 804 }, + Case { id: "rfc5280::ca-as-leaf-wrong-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "some-other-ca.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[807], intermediates: &[], leaf: 806 }, + Case { id: "rfc5280::root-and-intermediate-swapped", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[809], intermediates: &[810], leaf: 808 }, + Case { id: "rfc9881::ml-dsa-44", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["has-mldsa"], importance: "undetermined", trusted: &[812], intermediates: &[], leaf: 811 }, + Case { id: "rfc9881::ml-dsa-65", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["has-mldsa"], importance: "undetermined", trusted: &[814], intermediates: &[], leaf: 813 }, + Case { id: "rfc9881::ml-dsa-87", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["has-mldsa"], importance: "undetermined", trusted: &[816], intermediates: &[], leaf: 815 }, + Case { id: "rfc9881::ml-dsa-44-bad-signature", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["has-mldsa"], importance: "undetermined", trusted: &[818], intermediates: &[], leaf: 817 }, + Case { id: "rfc9881::ml-dsa-44-key-encipherment", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["has-mldsa", "pedantic-rfc5280"], importance: "low", trusted: &[820], intermediates: &[], leaf: 819 }, + Case { id: "rfc9881::ml-dsa-44-key-agreement", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["has-mldsa", "pedantic-rfc5280"], importance: "low", trusted: &[822], intermediates: &[], leaf: 821 }, + Case { id: "webpki::aki::root-with-aki-missing-keyidentifier", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[824], intermediates: &[], leaf: 823 }, + Case { id: "webpki::aki::root-with-aki-authoritycertissuer", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[826], intermediates: &[], leaf: 825 }, + Case { id: "webpki::aki::root-with-aki-authoritycertserialnumber", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[828], intermediates: &[], leaf: 827 }, + Case { id: "webpki::aki::root-with-aki-all-fields", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[830], intermediates: &[], leaf: 829 }, + Case { id: "webpki::aki::root-with-aki-ski-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[832], intermediates: &[], leaf: 831 }, + Case { id: "webpki::cn::ipv4-hex-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("IP", "192.168.1.1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[834], intermediates: &[], leaf: 833 }, + Case { id: "webpki::cn::ipv4-leading-zeros-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("IP", "192.168.1.1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[836], intermediates: &[], leaf: 835 }, + Case { id: "webpki::cn::ipv6-uppercase-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("IP", "2001:db8::8a2e:370:7334"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[838], intermediates: &[], leaf: 837 }, + Case { id: "webpki::cn::ipv6-uncompressed-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("IP", "2001:db8::1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[840], intermediates: &[], leaf: 839 }, + Case { id: "webpki::cn::ipv6-non-rfc5952-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("IP", "2001:db8::1:0:0:1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[842], intermediates: &[], leaf: 841 }, + Case { id: "webpki::cn::punycode-not-in-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "xn--n3h.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[844], intermediates: &[], leaf: 843 }, + Case { id: "webpki::cn::utf8-vs-punycode-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "xn--test--wg5h0h.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[846], intermediates: &[], leaf: 845 }, + Case { id: "webpki::cn::not-in-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "valid.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[848], intermediates: &[], leaf: 847 }, + Case { id: "webpki::cn::case-mismatch", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[850], intermediates: &[], leaf: 849 }, + Case { id: "webpki::eku::ee-anyeku", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-webpki-eku"], importance: "undetermined", trusted: &[852], intermediates: &[], leaf: 851 }, + Case { id: "webpki::eku::ee-critical-eku", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-webpki-eku"], importance: "undetermined", trusted: &[854], intermediates: &[], leaf: 853 }, + Case { id: "webpki::eku::ee-without-eku", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-webpki-eku"], importance: "undetermined", trusted: &[856], intermediates: &[], leaf: 855 }, + Case { id: "webpki::eku::root-has-eku", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-webpki-eku"], importance: "undetermined", trusted: &[858], intermediates: &[], leaf: 857 }, + Case { id: "webpki::nc::permitted-dns-match-noncritical", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[860], intermediates: &[], leaf: 859 }, + Case { id: "webpki::nc::intermediate-permitted-excluded-subtrees-both-null", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[862], intermediates: &[863], leaf: 861 }, + Case { id: "webpki::nc::intermediate-permitted-excluded-subtrees-both-empty-sequences", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[865], intermediates: &[866], leaf: 864 }, + Case { id: "webpki::nc::nc-permits-dns-san-pattern", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "foo.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[868], intermediates: &[869], leaf: 867 }, + Case { id: "webpki::san::exact-dns-san", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[871], intermediates: &[], leaf: 870 }, + Case { id: "webpki::san::exact-localhost-ip-san", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[873], intermediates: &[], leaf: 872 }, + Case { id: "webpki::san::mismatch-domain-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example2.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[875], intermediates: &[], leaf: 874 }, + Case { id: "webpki::san::mismatch-subdomain-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "def.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[877], intermediates: &[], leaf: 876 }, + Case { id: "webpki::san::mismatch-subdomain-apex-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "abc.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[879], intermediates: &[], leaf: 878 }, + Case { id: "webpki::san::mismatch-apex-subdomain-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[881], intermediates: &[], leaf: 880 }, + Case { id: "webpki::san::public-suffix-wildcard-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-public-suffix-wildcard"], importance: "undetermined", trusted: &[883], intermediates: &[], leaf: 882 }, + Case { id: "webpki::san::public-suffix-multi-label-wildcard-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.co.uk"), peer_names: &[], time: "", features: &["pedantic-public-suffix-wildcard"], importance: "undetermined", trusted: &[885], intermediates: &[], leaf: 884 }, + Case { id: "webpki::san::public-suffix-private-namespace-wildcard-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.s3.amazonaws.com"), peer_names: &[], time: "", features: &["pedantic-public-suffix-wildcard"], importance: "undetermined", trusted: &[887], intermediates: &[], leaf: 886 }, + Case { id: "webpki::san::leftmost-wildcard-san", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "foo.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[889], intermediates: &[], leaf: 888 }, + Case { id: "webpki::san::wildcard-embedded-leftmost-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "baz.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[891], intermediates: &[], leaf: 890 }, + Case { id: "webpki::san::wildcard-not-in-leftmost-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "foo.bar.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[893], intermediates: &[], leaf: 892 }, + Case { id: "webpki::san::wildcard-match-across-labels-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "foo.bar.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[895], intermediates: &[], leaf: 894 }, + Case { id: "webpki::san::wildcard-embedded-ulabel-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "xn--bliss-1b3c148a.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[897], intermediates: &[], leaf: 896 }, + Case { id: "webpki::san::unicode-emoji-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "xn--628h.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[899], intermediates: &[], leaf: 898 }, + Case { id: "webpki::san::no-san", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[901], intermediates: &[], leaf: 900 }, + Case { id: "webpki::san::san-critical-with-nonempty-subject", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[903], intermediates: &[], leaf: 902 }, + Case { id: "webpki::san::san-wildcard-only", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[905], intermediates: &[], leaf: 904 }, + Case { id: "webpki::san::san-wildcard-only-tld", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[907], intermediates: &[], leaf: 906 }, + Case { id: "webpki::explicit-curve", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "2024-03-13T00:00:00+00:00", features: &[], importance: "undetermined", trusted: &[909], intermediates: &[], leaf: 908 }, + Case { id: "webpki::cryptographydotio-chain", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "cryptography.io"), peer_names: &[], time: "2023-07-10T00:00:00+00:00", features: &[], importance: "undetermined", trusted: &[802], intermediates: &[803], leaf: 910 }, + Case { id: "webpki::cryptographydotio-chain-missing-intermediate", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "cryptography.io"), peer_names: &[], time: "2023-07-10T00:00:00+00:00", features: &[], importance: "undetermined", trusted: &[802], intermediates: &[], leaf: 910 }, + Case { id: "webpki::malformed-aia", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[912], intermediates: &[], leaf: 911 }, + Case { id: "webpki::forbidden-p192-root", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[914], intermediates: &[], leaf: 913 }, + Case { id: "webpki::forbidden-p192-leaf", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-webpki-subscriber-key"], importance: "undetermined", trusted: &[916], intermediates: &[], leaf: 915 }, + Case { id: "webpki::forbidden-dsa-root", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[918], intermediates: &[], leaf: 917 }, + Case { id: "webpki::forbidden-dsa-leaf", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-webpki-subscriber-key"], importance: "undetermined", trusted: &[920], intermediates: &[], leaf: 919 }, + Case { id: "webpki::forbidden-weak-rsa-key-in-root", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[922], intermediates: &[], leaf: 921 }, + Case { id: "webpki::forbidden-weak-rsa-in-leaf", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-webpki-subscriber-key"], importance: "undetermined", trusted: &[924], intermediates: &[], leaf: 923 }, + Case { id: "webpki::forbidden-rsa-not-divisible-by-8-in-root", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[926], intermediates: &[], leaf: 925 }, + Case { id: "webpki::forbidden-rsa-key-not-divisible-by-8-in-leaf", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &["pedantic-webpki-subscriber-key"], importance: "undetermined", trusted: &[928], intermediates: &[], leaf: 927 }, + Case { id: "webpki::v1-cert", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[930], intermediates: &[], leaf: 929 }, + Case { id: "webpki::ee-basicconstraints-ca", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[932], intermediates: &[], leaf: 931 }, + Case { id: "webpki::ca-as-leaf", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "ca.example.com"), peer_names: &[], time: "", features: &[], importance: "undetermined", trusted: &[934], intermediates: &[], leaf: 933 }, + Case { id: "bettertls::nameconstraints::tc0", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[937, 938], leaf: 935 }, + Case { id: "bettertls::nameconstraints::tc1", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[940, 941], leaf: 939 }, + Case { id: "bettertls::nameconstraints::tc2", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[943, 944], leaf: 942 }, + Case { id: "bettertls::nameconstraints::tc3", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[946, 947], leaf: 945 }, + Case { id: "bettertls::nameconstraints::tc4", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[949, 950], leaf: 948 }, + Case { id: "bettertls::nameconstraints::tc5", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[952, 953], leaf: 951 }, + Case { id: "bettertls::nameconstraints::tc6", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[955, 956], leaf: 954 }, + Case { id: "bettertls::nameconstraints::tc7", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[958, 959], leaf: 957 }, + Case { id: "bettertls::nameconstraints::tc8", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[961, 962], leaf: 960 }, + Case { id: "bettertls::nameconstraints::tc9", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[964, 965], leaf: 963 }, + Case { id: "bettertls::nameconstraints::tc10", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[967, 968], leaf: 966 }, + Case { id: "bettertls::nameconstraints::tc11", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[970, 971], leaf: 969 }, + Case { id: "bettertls::nameconstraints::tc12", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[973, 974], leaf: 972 }, + Case { id: "bettertls::nameconstraints::tc13", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[976, 977], leaf: 975 }, + Case { id: "bettertls::nameconstraints::tc14", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[979, 980], leaf: 978 }, + Case { id: "bettertls::nameconstraints::tc15", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[982, 983], leaf: 981 }, + Case { id: "bettertls::nameconstraints::tc16", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[985, 986], leaf: 984 }, + Case { id: "bettertls::nameconstraints::tc17", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[988, 989], leaf: 987 }, + Case { id: "bettertls::nameconstraints::tc18", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[991, 992], leaf: 990 }, + Case { id: "bettertls::nameconstraints::tc19", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[994, 995], leaf: 993 }, + Case { id: "bettertls::nameconstraints::tc20", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[997, 998], leaf: 996 }, + Case { id: "bettertls::nameconstraints::tc21", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1000, 1001], leaf: 999 }, + Case { id: "bettertls::nameconstraints::tc22", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1003, 1004], leaf: 1002 }, + Case { id: "bettertls::nameconstraints::tc23", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1006, 1007], leaf: 1005 }, + Case { id: "bettertls::nameconstraints::tc24", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1009, 1010], leaf: 1008 }, + Case { id: "bettertls::nameconstraints::tc25", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1012, 1013], leaf: 1011 }, + Case { id: "bettertls::nameconstraints::tc26", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1015, 1016], leaf: 1014 }, + Case { id: "bettertls::nameconstraints::tc27", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1018, 1019], leaf: 1017 }, + Case { id: "bettertls::nameconstraints::tc28", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1021, 1022], leaf: 1020 }, + Case { id: "bettertls::nameconstraints::tc29", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1024, 1025], leaf: 1023 }, + Case { id: "bettertls::nameconstraints::tc30", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1027, 1028], leaf: 1026 }, + Case { id: "bettertls::nameconstraints::tc31", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1030, 1031], leaf: 1029 }, + Case { id: "bettertls::nameconstraints::tc32", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1033, 1034], leaf: 1032 }, + Case { id: "bettertls::nameconstraints::tc33", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1036, 1037], leaf: 1035 }, + Case { id: "bettertls::nameconstraints::tc34", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1039, 1040], leaf: 1038 }, + Case { id: "bettertls::nameconstraints::tc35", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1042, 1043], leaf: 1041 }, + Case { id: "bettertls::nameconstraints::tc36", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1045, 1046], leaf: 1044 }, + Case { id: "bettertls::nameconstraints::tc37", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1048, 1049], leaf: 1047 }, + Case { id: "bettertls::nameconstraints::tc38", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1051, 1052], leaf: 1050 }, + Case { id: "bettertls::nameconstraints::tc39", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1054, 1055], leaf: 1053 }, + Case { id: "bettertls::nameconstraints::tc40", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1057, 1058], leaf: 1056 }, + Case { id: "bettertls::nameconstraints::tc41", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1060, 1061], leaf: 1059 }, + Case { id: "bettertls::nameconstraints::tc42", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1063, 1064], leaf: 1062 }, + Case { id: "bettertls::nameconstraints::tc43", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1066, 1067], leaf: 1065 }, + Case { id: "bettertls::nameconstraints::tc44", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1069, 1070], leaf: 1068 }, + Case { id: "bettertls::nameconstraints::tc45", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1072, 1073], leaf: 1071 }, + Case { id: "bettertls::nameconstraints::tc46", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1075, 1076], leaf: 1074 }, + Case { id: "bettertls::nameconstraints::tc47", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1078, 1079], leaf: 1077 }, + Case { id: "bettertls::nameconstraints::tc48", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1081, 1082], leaf: 1080 }, + Case { id: "bettertls::nameconstraints::tc49", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1084, 1085], leaf: 1083 }, + Case { id: "bettertls::nameconstraints::tc50", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1087, 1088], leaf: 1086 }, + Case { id: "bettertls::nameconstraints::tc51", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1090, 1091], leaf: 1089 }, + Case { id: "bettertls::nameconstraints::tc52", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1093, 1094], leaf: 1092 }, + Case { id: "bettertls::nameconstraints::tc53", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1096, 1097], leaf: 1095 }, + Case { id: "bettertls::nameconstraints::tc54", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1099, 1100], leaf: 1098 }, + Case { id: "bettertls::nameconstraints::tc55", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1102, 1103], leaf: 1101 }, + Case { id: "bettertls::nameconstraints::tc56", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1105, 1106], leaf: 1104 }, + Case { id: "bettertls::nameconstraints::tc57", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1108, 1109], leaf: 1107 }, + Case { id: "bettertls::nameconstraints::tc58", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1111, 1112], leaf: 1110 }, + Case { id: "bettertls::nameconstraints::tc59", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1114, 1115], leaf: 1113 }, + Case { id: "bettertls::nameconstraints::tc60", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1117, 1118], leaf: 1116 }, + Case { id: "bettertls::nameconstraints::tc61", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1120, 1121], leaf: 1119 }, + Case { id: "bettertls::nameconstraints::tc62", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1123, 1124], leaf: 1122 }, + Case { id: "bettertls::nameconstraints::tc63", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1126, 1127], leaf: 1125 }, + Case { id: "bettertls::nameconstraints::tc64", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1129, 1130], leaf: 1128 }, + Case { id: "bettertls::nameconstraints::tc65", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1132, 1133], leaf: 1131 }, + Case { id: "bettertls::nameconstraints::tc66", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1135, 1136], leaf: 1134 }, + Case { id: "bettertls::nameconstraints::tc67", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1138, 1139], leaf: 1137 }, + Case { id: "bettertls::nameconstraints::tc68", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1141, 1142], leaf: 1140 }, + Case { id: "bettertls::nameconstraints::tc69", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1144, 1145], leaf: 1143 }, + Case { id: "bettertls::nameconstraints::tc70", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1147, 1148], leaf: 1146 }, + Case { id: "bettertls::nameconstraints::tc71", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1150, 1151], leaf: 1149 }, + Case { id: "bettertls::nameconstraints::tc72", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1153, 1154], leaf: 1152 }, + Case { id: "bettertls::nameconstraints::tc73", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1156, 1157], leaf: 1155 }, + Case { id: "bettertls::nameconstraints::tc74", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1159, 1160], leaf: 1158 }, + Case { id: "bettertls::nameconstraints::tc75", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1162, 1163], leaf: 1161 }, + Case { id: "bettertls::nameconstraints::tc76", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1165, 1166], leaf: 1164 }, + Case { id: "bettertls::nameconstraints::tc77", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1168, 1169], leaf: 1167 }, + Case { id: "bettertls::nameconstraints::tc78", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1171, 1172], leaf: 1170 }, + Case { id: "bettertls::nameconstraints::tc79", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1174, 1175], leaf: 1173 }, + Case { id: "bettertls::nameconstraints::tc80", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1177, 1178], leaf: 1176 }, + Case { id: "bettertls::nameconstraints::tc81", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1180, 1181], leaf: 1179 }, + Case { id: "bettertls::nameconstraints::tc82", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1183, 1184], leaf: 1182 }, + Case { id: "bettertls::nameconstraints::tc83", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1186, 1187], leaf: 1185 }, + Case { id: "bettertls::nameconstraints::tc84", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1189, 1190], leaf: 1188 }, + Case { id: "bettertls::nameconstraints::tc85", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1192, 1193], leaf: 1191 }, + Case { id: "bettertls::nameconstraints::tc86", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1195, 1196], leaf: 1194 }, + Case { id: "bettertls::nameconstraints::tc87", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1198, 1199], leaf: 1197 }, + Case { id: "bettertls::nameconstraints::tc88", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1201, 1202], leaf: 1200 }, + Case { id: "bettertls::nameconstraints::tc89", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1204, 1205], leaf: 1203 }, + Case { id: "bettertls::nameconstraints::tc90", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1207, 1208], leaf: 1206 }, + Case { id: "bettertls::nameconstraints::tc91", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1210, 1211], leaf: 1209 }, + Case { id: "bettertls::nameconstraints::tc92", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1213, 1214], leaf: 1212 }, + Case { id: "bettertls::nameconstraints::tc93", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1216, 1217], leaf: 1215 }, + Case { id: "bettertls::nameconstraints::tc94", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1219, 1220], leaf: 1218 }, + Case { id: "bettertls::nameconstraints::tc95", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1222, 1223], leaf: 1221 }, + Case { id: "bettertls::nameconstraints::tc96", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1225, 1226], leaf: 1224 }, + Case { id: "bettertls::nameconstraints::tc97", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1228, 1229], leaf: 1227 }, + Case { id: "bettertls::nameconstraints::tc98", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1231, 1232], leaf: 1230 }, + Case { id: "bettertls::nameconstraints::tc99", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1234, 1235], leaf: 1233 }, + Case { id: "bettertls::nameconstraints::tc100", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1237, 1238], leaf: 1236 }, + Case { id: "bettertls::nameconstraints::tc101", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1240, 1241], leaf: 1239 }, + Case { id: "bettertls::nameconstraints::tc102", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1243, 1244], leaf: 1242 }, + Case { id: "bettertls::nameconstraints::tc103", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1246, 1247], leaf: 1245 }, + Case { id: "bettertls::nameconstraints::tc104", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1249, 1250], leaf: 1248 }, + Case { id: "bettertls::nameconstraints::tc105", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1252, 1253], leaf: 1251 }, + Case { id: "bettertls::nameconstraints::tc106", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1255, 1256], leaf: 1254 }, + Case { id: "bettertls::nameconstraints::tc107", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1258, 1259], leaf: 1257 }, + Case { id: "bettertls::nameconstraints::tc108", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1261, 1262], leaf: 1260 }, + Case { id: "bettertls::nameconstraints::tc109", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1264, 1265], leaf: 1263 }, + Case { id: "bettertls::nameconstraints::tc110", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1267, 1268], leaf: 1266 }, + Case { id: "bettertls::nameconstraints::tc111", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1270, 1271], leaf: 1269 }, + Case { id: "bettertls::nameconstraints::tc112", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1273, 1274], leaf: 1272 }, + Case { id: "bettertls::nameconstraints::tc113", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1276, 1277], leaf: 1275 }, + Case { id: "bettertls::nameconstraints::tc114", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1279, 1280], leaf: 1278 }, + Case { id: "bettertls::nameconstraints::tc115", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1282, 1283], leaf: 1281 }, + Case { id: "bettertls::nameconstraints::tc116", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1285, 1286], leaf: 1284 }, + Case { id: "bettertls::nameconstraints::tc117", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1288, 1289], leaf: 1287 }, + Case { id: "bettertls::nameconstraints::tc118", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1291, 1292], leaf: 1290 }, + Case { id: "bettertls::nameconstraints::tc119", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1294, 1295], leaf: 1293 }, + Case { id: "bettertls::nameconstraints::tc120", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1297, 1298], leaf: 1296 }, + Case { id: "bettertls::nameconstraints::tc121", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1300, 1301], leaf: 1299 }, + Case { id: "bettertls::nameconstraints::tc122", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1303, 1304], leaf: 1302 }, + Case { id: "bettertls::nameconstraints::tc123", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1306, 1307], leaf: 1305 }, + Case { id: "bettertls::nameconstraints::tc124", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1309, 1310], leaf: 1308 }, + Case { id: "bettertls::nameconstraints::tc125", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1312, 1313], leaf: 1311 }, + Case { id: "bettertls::nameconstraints::tc126", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1315, 1316], leaf: 1314 }, + Case { id: "bettertls::nameconstraints::tc127", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1318, 1319], leaf: 1317 }, + Case { id: "bettertls::nameconstraints::tc128", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1321, 1322], leaf: 1320 }, + Case { id: "bettertls::nameconstraints::tc129", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1324, 1325], leaf: 1323 }, + Case { id: "bettertls::nameconstraints::tc130", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1327, 1328], leaf: 1326 }, + Case { id: "bettertls::nameconstraints::tc131", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1330, 1331], leaf: 1329 }, + Case { id: "bettertls::nameconstraints::tc132", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1333, 1334], leaf: 1332 }, + Case { id: "bettertls::nameconstraints::tc133", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1336, 1337], leaf: 1335 }, + Case { id: "bettertls::nameconstraints::tc134", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1339, 1340], leaf: 1338 }, + Case { id: "bettertls::nameconstraints::tc135", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1342, 1343], leaf: 1341 }, + Case { id: "bettertls::nameconstraints::tc136", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1345, 1346], leaf: 1344 }, + Case { id: "bettertls::nameconstraints::tc137", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1348, 1349], leaf: 1347 }, + Case { id: "bettertls::nameconstraints::tc138", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1351, 1352], leaf: 1350 }, + Case { id: "bettertls::nameconstraints::tc139", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1354, 1355], leaf: 1353 }, + Case { id: "bettertls::nameconstraints::tc140", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1357, 1358], leaf: 1356 }, + Case { id: "bettertls::nameconstraints::tc141", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1360, 1361], leaf: 1359 }, + Case { id: "bettertls::nameconstraints::tc142", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1363, 1364], leaf: 1362 }, + Case { id: "bettertls::nameconstraints::tc143", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1366, 1367], leaf: 1365 }, + Case { id: "bettertls::nameconstraints::tc144", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1369, 1370], leaf: 1368 }, + Case { id: "bettertls::nameconstraints::tc145", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1372, 1373], leaf: 1371 }, + Case { id: "bettertls::nameconstraints::tc146", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1375, 1376], leaf: 1374 }, + Case { id: "bettertls::nameconstraints::tc147", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1378, 1379], leaf: 1377 }, + Case { id: "bettertls::nameconstraints::tc148", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1381, 1382], leaf: 1380 }, + Case { id: "bettertls::nameconstraints::tc149", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1384, 1385], leaf: 1383 }, + Case { id: "bettertls::nameconstraints::tc150", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1387, 1388], leaf: 1386 }, + Case { id: "bettertls::nameconstraints::tc151", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1390, 1391], leaf: 1389 }, + Case { id: "bettertls::nameconstraints::tc152", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1393, 1394], leaf: 1392 }, + Case { id: "bettertls::nameconstraints::tc153", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1396, 1397], leaf: 1395 }, + Case { id: "bettertls::nameconstraints::tc154", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1399, 1400], leaf: 1398 }, + Case { id: "bettertls::nameconstraints::tc155", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1402, 1403], leaf: 1401 }, + Case { id: "bettertls::nameconstraints::tc156", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1405, 1406], leaf: 1404 }, + Case { id: "bettertls::nameconstraints::tc157", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1408, 1409], leaf: 1407 }, + Case { id: "bettertls::nameconstraints::tc158", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1411, 1412], leaf: 1410 }, + Case { id: "bettertls::nameconstraints::tc159", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1414, 1415], leaf: 1413 }, + Case { id: "bettertls::nameconstraints::tc160", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1417, 1418], leaf: 1416 }, + Case { id: "bettertls::nameconstraints::tc161", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1420, 1421], leaf: 1419 }, + Case { id: "bettertls::nameconstraints::tc162", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1423, 1424], leaf: 1422 }, + Case { id: "bettertls::nameconstraints::tc163", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1426, 1427], leaf: 1425 }, + Case { id: "bettertls::nameconstraints::tc164", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1429, 1430], leaf: 1428 }, + Case { id: "bettertls::nameconstraints::tc165", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1432, 1433], leaf: 1431 }, + Case { id: "bettertls::nameconstraints::tc166", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1435, 1436], leaf: 1434 }, + Case { id: "bettertls::nameconstraints::tc167", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1438, 1439], leaf: 1437 }, + Case { id: "bettertls::nameconstraints::tc168", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1441, 1442], leaf: 1440 }, + Case { id: "bettertls::nameconstraints::tc169", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1444, 1445], leaf: 1443 }, + Case { id: "bettertls::nameconstraints::tc170", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1447, 1448], leaf: 1446 }, + Case { id: "bettertls::nameconstraints::tc171", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1450, 1451], leaf: 1449 }, + Case { id: "bettertls::nameconstraints::tc172", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1453, 1454], leaf: 1452 }, + Case { id: "bettertls::nameconstraints::tc173", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1456, 1457], leaf: 1455 }, + Case { id: "bettertls::nameconstraints::tc174", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1459, 1460], leaf: 1458 }, + Case { id: "bettertls::nameconstraints::tc175", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1462, 1463], leaf: 1461 }, + Case { id: "bettertls::nameconstraints::tc176", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1465, 1466], leaf: 1464 }, + Case { id: "bettertls::nameconstraints::tc177", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1468, 1469], leaf: 1467 }, + Case { id: "bettertls::nameconstraints::tc178", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1471, 1472], leaf: 1470 }, + Case { id: "bettertls::nameconstraints::tc179", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1474, 1475], leaf: 1473 }, + Case { id: "bettertls::nameconstraints::tc180", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1477, 1478], leaf: 1476 }, + Case { id: "bettertls::nameconstraints::tc181", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1480, 1481], leaf: 1479 }, + Case { id: "bettertls::nameconstraints::tc182", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1483, 1484], leaf: 1482 }, + Case { id: "bettertls::nameconstraints::tc183", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1486, 1487], leaf: 1485 }, + Case { id: "bettertls::nameconstraints::tc184", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1489, 1490], leaf: 1488 }, + Case { id: "bettertls::nameconstraints::tc185", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1492, 1493], leaf: 1491 }, + Case { id: "bettertls::nameconstraints::tc186", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1495, 1496], leaf: 1494 }, + Case { id: "bettertls::nameconstraints::tc187", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1498, 1499], leaf: 1497 }, + Case { id: "bettertls::nameconstraints::tc188", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1501, 1502], leaf: 1500 }, + Case { id: "bettertls::nameconstraints::tc189", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1504, 1505], leaf: 1503 }, + Case { id: "bettertls::nameconstraints::tc190", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1507, 1508], leaf: 1506 }, + Case { id: "bettertls::nameconstraints::tc191", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1510, 1511], leaf: 1509 }, + Case { id: "bettertls::nameconstraints::tc192", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1513, 1514], leaf: 1512 }, + Case { id: "bettertls::nameconstraints::tc193", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1516, 1517], leaf: 1515 }, + Case { id: "bettertls::nameconstraints::tc194", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1519, 1520], leaf: 1518 }, + Case { id: "bettertls::nameconstraints::tc195", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1522, 1523], leaf: 1521 }, + Case { id: "bettertls::nameconstraints::tc196", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1525, 1526], leaf: 1524 }, + Case { id: "bettertls::nameconstraints::tc197", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1528, 1529], leaf: 1527 }, + Case { id: "bettertls::nameconstraints::tc198", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1531, 1532], leaf: 1530 }, + Case { id: "bettertls::nameconstraints::tc199", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1534, 1535], leaf: 1533 }, + Case { id: "bettertls::nameconstraints::tc200", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1537, 1538], leaf: 1536 }, + Case { id: "bettertls::nameconstraints::tc201", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1540, 1541], leaf: 1539 }, + Case { id: "bettertls::nameconstraints::tc202", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1543, 1544], leaf: 1542 }, + Case { id: "bettertls::nameconstraints::tc203", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1546, 1547], leaf: 1545 }, + Case { id: "bettertls::nameconstraints::tc204", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1549, 1550], leaf: 1548 }, + Case { id: "bettertls::nameconstraints::tc205", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1552, 1553], leaf: 1551 }, + Case { id: "bettertls::nameconstraints::tc206", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1555, 1556], leaf: 1554 }, + Case { id: "bettertls::nameconstraints::tc207", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1558, 1559], leaf: 1557 }, + Case { id: "bettertls::nameconstraints::tc208", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1561, 1562], leaf: 1560 }, + Case { id: "bettertls::nameconstraints::tc209", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1564, 1565], leaf: 1563 }, + Case { id: "bettertls::nameconstraints::tc210", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1567, 1568], leaf: 1566 }, + Case { id: "bettertls::nameconstraints::tc211", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1570, 1571], leaf: 1569 }, + Case { id: "bettertls::nameconstraints::tc212", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1573, 1574], leaf: 1572 }, + Case { id: "bettertls::nameconstraints::tc213", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1576, 1577], leaf: 1575 }, + Case { id: "bettertls::nameconstraints::tc214", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1579, 1580], leaf: 1578 }, + Case { id: "bettertls::nameconstraints::tc215", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1582, 1583], leaf: 1581 }, + Case { id: "bettertls::nameconstraints::tc216", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1585, 1586], leaf: 1584 }, + Case { id: "bettertls::nameconstraints::tc217", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1588, 1589], leaf: 1587 }, + Case { id: "bettertls::nameconstraints::tc218", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1591, 1592], leaf: 1590 }, + Case { id: "bettertls::nameconstraints::tc219", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1594, 1595], leaf: 1593 }, + Case { id: "bettertls::nameconstraints::tc220", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1597, 1598], leaf: 1596 }, + Case { id: "bettertls::nameconstraints::tc221", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1600, 1601], leaf: 1599 }, + Case { id: "bettertls::nameconstraints::tc222", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1603, 1604], leaf: 1602 }, + Case { id: "bettertls::nameconstraints::tc223", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1606, 1607], leaf: 1605 }, + Case { id: "bettertls::nameconstraints::tc224", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1609, 1610], leaf: 1608 }, + Case { id: "bettertls::nameconstraints::tc225", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1612, 1613], leaf: 1611 }, + Case { id: "bettertls::nameconstraints::tc226", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1615, 1616], leaf: 1614 }, + Case { id: "bettertls::nameconstraints::tc227", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1618, 1619], leaf: 1617 }, + Case { id: "bettertls::nameconstraints::tc228", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1621, 1622], leaf: 1620 }, + Case { id: "bettertls::nameconstraints::tc229", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1624, 1625], leaf: 1623 }, + Case { id: "bettertls::nameconstraints::tc230", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1627, 1628], leaf: 1626 }, + Case { id: "bettertls::nameconstraints::tc231", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1630, 1631], leaf: 1629 }, + Case { id: "bettertls::nameconstraints::tc232", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1633, 1634], leaf: 1632 }, + Case { id: "bettertls::nameconstraints::tc233", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1636, 1637], leaf: 1635 }, + Case { id: "bettertls::nameconstraints::tc234", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1639, 1640], leaf: 1638 }, + Case { id: "bettertls::nameconstraints::tc235", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1642, 1643], leaf: 1641 }, + Case { id: "bettertls::nameconstraints::tc236", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1645, 1646], leaf: 1644 }, + Case { id: "bettertls::nameconstraints::tc237", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1648, 1649], leaf: 1647 }, + Case { id: "bettertls::nameconstraints::tc238", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1651, 1652], leaf: 1650 }, + Case { id: "bettertls::nameconstraints::tc239", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1654, 1655], leaf: 1653 }, + Case { id: "bettertls::nameconstraints::tc240", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1657, 1658], leaf: 1656 }, + Case { id: "bettertls::nameconstraints::tc241", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1660, 1661], leaf: 1659 }, + Case { id: "bettertls::nameconstraints::tc242", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1663, 1664], leaf: 1662 }, + Case { id: "bettertls::nameconstraints::tc243", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1666, 1667], leaf: 1665 }, + Case { id: "bettertls::nameconstraints::tc244", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1669, 1670], leaf: 1668 }, + Case { id: "bettertls::nameconstraints::tc245", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1672, 1673], leaf: 1671 }, + Case { id: "bettertls::nameconstraints::tc246", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1675, 1676], leaf: 1674 }, + Case { id: "bettertls::nameconstraints::tc247", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1678, 1679], leaf: 1677 }, + Case { id: "bettertls::nameconstraints::tc248", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1681, 1682], leaf: 1680 }, + Case { id: "bettertls::nameconstraints::tc249", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1684, 1685], leaf: 1683 }, + Case { id: "bettertls::nameconstraints::tc250", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1687, 1688], leaf: 1686 }, + Case { id: "bettertls::nameconstraints::tc251", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1690, 1691], leaf: 1689 }, + Case { id: "bettertls::nameconstraints::tc252", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1693, 1694], leaf: 1692 }, + Case { id: "bettertls::nameconstraints::tc253", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1696, 1697], leaf: 1695 }, + Case { id: "bettertls::nameconstraints::tc254", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1699, 1700], leaf: 1698 }, + Case { id: "bettertls::nameconstraints::tc255", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1702, 1703], leaf: 1701 }, + Case { id: "bettertls::nameconstraints::tc256", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1705, 1706], leaf: 1704 }, + Case { id: "bettertls::nameconstraints::tc257", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1708, 1709], leaf: 1707 }, + Case { id: "bettertls::nameconstraints::tc258", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1711, 1712], leaf: 1710 }, + Case { id: "bettertls::nameconstraints::tc259", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1714, 1715], leaf: 1713 }, + Case { id: "bettertls::nameconstraints::tc260", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1717, 1718], leaf: 1716 }, + Case { id: "bettertls::nameconstraints::tc261", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1720, 1721], leaf: 1719 }, + Case { id: "bettertls::nameconstraints::tc262", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1723, 1724], leaf: 1722 }, + Case { id: "bettertls::nameconstraints::tc263", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1726, 1727], leaf: 1725 }, + Case { id: "bettertls::nameconstraints::tc264", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1729, 1730], leaf: 1728 }, + Case { id: "bettertls::nameconstraints::tc265", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1732, 1733], leaf: 1731 }, + Case { id: "bettertls::nameconstraints::tc266", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1735, 1736], leaf: 1734 }, + Case { id: "bettertls::nameconstraints::tc267", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1738, 1739], leaf: 1737 }, + Case { id: "bettertls::nameconstraints::tc268", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1741, 1742], leaf: 1740 }, + Case { id: "bettertls::nameconstraints::tc269", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1744, 1745], leaf: 1743 }, + Case { id: "bettertls::nameconstraints::tc270", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1747, 1748], leaf: 1746 }, + Case { id: "bettertls::nameconstraints::tc271", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1750, 1751], leaf: 1749 }, + Case { id: "bettertls::nameconstraints::tc272", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1753, 1754], leaf: 1752 }, + Case { id: "bettertls::nameconstraints::tc273", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1756, 1757], leaf: 1755 }, + Case { id: "bettertls::nameconstraints::tc274", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1759, 1760], leaf: 1758 }, + Case { id: "bettertls::nameconstraints::tc275", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1762, 1763], leaf: 1761 }, + Case { id: "bettertls::nameconstraints::tc276", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1765, 1766], leaf: 1764 }, + Case { id: "bettertls::nameconstraints::tc277", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1768, 1769], leaf: 1767 }, + Case { id: "bettertls::nameconstraints::tc278", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1771, 1772], leaf: 1770 }, + Case { id: "bettertls::nameconstraints::tc279", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1774, 1775], leaf: 1773 }, + Case { id: "bettertls::nameconstraints::tc280", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1777, 1778], leaf: 1776 }, + Case { id: "bettertls::nameconstraints::tc281", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1780, 1781], leaf: 1779 }, + Case { id: "bettertls::nameconstraints::tc282", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1783, 1784], leaf: 1782 }, + Case { id: "bettertls::nameconstraints::tc283", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1786, 1787], leaf: 1785 }, + Case { id: "bettertls::nameconstraints::tc284", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1789, 1790], leaf: 1788 }, + Case { id: "bettertls::nameconstraints::tc285", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1792, 1793], leaf: 1791 }, + Case { id: "bettertls::nameconstraints::tc286", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1795, 1796], leaf: 1794 }, + Case { id: "bettertls::nameconstraints::tc287", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1798, 1799], leaf: 1797 }, + Case { id: "bettertls::nameconstraints::tc288", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1801, 1802], leaf: 1800 }, + Case { id: "bettertls::nameconstraints::tc289", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1804, 1805], leaf: 1803 }, + Case { id: "bettertls::nameconstraints::tc290", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1807, 1808], leaf: 1806 }, + Case { id: "bettertls::nameconstraints::tc291", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1810, 1811], leaf: 1809 }, + Case { id: "bettertls::nameconstraints::tc292", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1813, 1814], leaf: 1812 }, + Case { id: "bettertls::nameconstraints::tc293", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1816, 1817], leaf: 1815 }, + Case { id: "bettertls::nameconstraints::tc294", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1819, 1820], leaf: 1818 }, + Case { id: "bettertls::nameconstraints::tc295", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1822, 1823], leaf: 1821 }, + Case { id: "bettertls::nameconstraints::tc296", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1825, 1826], leaf: 1824 }, + Case { id: "bettertls::nameconstraints::tc297", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1828, 1829], leaf: 1827 }, + Case { id: "bettertls::nameconstraints::tc298", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1831, 1832], leaf: 1830 }, + Case { id: "bettertls::nameconstraints::tc299", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1834, 1835], leaf: 1833 }, + Case { id: "bettertls::nameconstraints::tc300", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1837, 1838], leaf: 1836 }, + Case { id: "bettertls::nameconstraints::tc301", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1840, 1841], leaf: 1839 }, + Case { id: "bettertls::nameconstraints::tc302", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1843, 1844], leaf: 1842 }, + Case { id: "bettertls::nameconstraints::tc303", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1846, 1847], leaf: 1845 }, + Case { id: "bettertls::nameconstraints::tc304", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1849, 1850], leaf: 1848 }, + Case { id: "bettertls::nameconstraints::tc305", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1852, 1853], leaf: 1851 }, + Case { id: "bettertls::nameconstraints::tc306", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1855, 1856], leaf: 1854 }, + Case { id: "bettertls::nameconstraints::tc307", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1858, 1859], leaf: 1857 }, + Case { id: "bettertls::nameconstraints::tc308", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1861, 1862], leaf: 1860 }, + Case { id: "bettertls::nameconstraints::tc309", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1864, 1865], leaf: 1863 }, + Case { id: "bettertls::nameconstraints::tc310", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1867, 1868], leaf: 1866 }, + Case { id: "bettertls::nameconstraints::tc311", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1870, 1871], leaf: 1869 }, + Case { id: "bettertls::nameconstraints::tc312", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1873, 1874], leaf: 1872 }, + Case { id: "bettertls::nameconstraints::tc313", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1876, 1877], leaf: 1875 }, + Case { id: "bettertls::nameconstraints::tc314", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1879, 1880], leaf: 1878 }, + Case { id: "bettertls::nameconstraints::tc315", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1882, 1883], leaf: 1881 }, + Case { id: "bettertls::nameconstraints::tc316", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1885, 1886], leaf: 1884 }, + Case { id: "bettertls::nameconstraints::tc317", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1888, 1889], leaf: 1887 }, + Case { id: "bettertls::nameconstraints::tc318", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1891, 1892], leaf: 1890 }, + Case { id: "bettertls::nameconstraints::tc319", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1894, 1895], leaf: 1893 }, + Case { id: "bettertls::nameconstraints::tc320", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1897, 1898], leaf: 1896 }, + Case { id: "bettertls::nameconstraints::tc321", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1900, 1901], leaf: 1899 }, + Case { id: "bettertls::nameconstraints::tc322", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1903, 1904], leaf: 1902 }, + Case { id: "bettertls::nameconstraints::tc323", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1906, 1907], leaf: 1905 }, + Case { id: "bettertls::nameconstraints::tc324", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1909, 1910], leaf: 1908 }, + Case { id: "bettertls::nameconstraints::tc325", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1912, 1913], leaf: 1911 }, + Case { id: "bettertls::nameconstraints::tc326", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1915, 1916], leaf: 1914 }, + Case { id: "bettertls::nameconstraints::tc327", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1918, 1919], leaf: 1917 }, + Case { id: "bettertls::nameconstraints::tc328", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1921, 1922], leaf: 1920 }, + Case { id: "bettertls::nameconstraints::tc329", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1924, 1925], leaf: 1923 }, + Case { id: "bettertls::nameconstraints::tc330", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1927, 1928], leaf: 1926 }, + Case { id: "bettertls::nameconstraints::tc331", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1930, 1931], leaf: 1929 }, + Case { id: "bettertls::nameconstraints::tc332", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1933, 1934], leaf: 1932 }, + Case { id: "bettertls::nameconstraints::tc333", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1936, 1937], leaf: 1935 }, + Case { id: "bettertls::nameconstraints::tc334", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1939, 1940], leaf: 1938 }, + Case { id: "bettertls::nameconstraints::tc335", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1942, 1943], leaf: 1941 }, + Case { id: "bettertls::nameconstraints::tc336", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1945, 1946], leaf: 1944 }, + Case { id: "bettertls::nameconstraints::tc337", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1948, 1949], leaf: 1947 }, + Case { id: "bettertls::nameconstraints::tc338", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1951, 1952], leaf: 1950 }, + Case { id: "bettertls::nameconstraints::tc339", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1954, 1955], leaf: 1953 }, + Case { id: "bettertls::nameconstraints::tc340", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1957, 1958], leaf: 1956 }, + Case { id: "bettertls::nameconstraints::tc341", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1960, 1961], leaf: 1959 }, + Case { id: "bettertls::nameconstraints::tc342", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1963, 1964], leaf: 1962 }, + Case { id: "bettertls::nameconstraints::tc343", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1966, 1967], leaf: 1965 }, + Case { id: "bettertls::nameconstraints::tc344", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1969, 1970], leaf: 1968 }, + Case { id: "bettertls::nameconstraints::tc345", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1972, 1973], leaf: 1971 }, + Case { id: "bettertls::nameconstraints::tc346", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1975, 1976], leaf: 1974 }, + Case { id: "bettertls::nameconstraints::tc347", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1978, 1979], leaf: 1977 }, + Case { id: "bettertls::nameconstraints::tc348", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1981, 1982], leaf: 1980 }, + Case { id: "bettertls::nameconstraints::tc349", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1984, 1985], leaf: 1983 }, + Case { id: "bettertls::nameconstraints::tc350", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1987, 1988], leaf: 1986 }, + Case { id: "bettertls::nameconstraints::tc351", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1990, 1991], leaf: 1989 }, + Case { id: "bettertls::nameconstraints::tc352", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1993, 1994], leaf: 1992 }, + Case { id: "bettertls::nameconstraints::tc353", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1996, 1997], leaf: 1995 }, + Case { id: "bettertls::nameconstraints::tc354", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[1999, 2000], leaf: 1998 }, + Case { id: "bettertls::nameconstraints::tc355", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2002, 2003], leaf: 2001 }, + Case { id: "bettertls::nameconstraints::tc356", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2005, 2006], leaf: 2004 }, + Case { id: "bettertls::nameconstraints::tc357", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2008, 2009], leaf: 2007 }, + Case { id: "bettertls::nameconstraints::tc358", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2011, 2012], leaf: 2010 }, + Case { id: "bettertls::nameconstraints::tc359", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2014, 2015], leaf: 2013 }, + Case { id: "bettertls::nameconstraints::tc360", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2017, 2018], leaf: 2016 }, + Case { id: "bettertls::nameconstraints::tc361", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2020, 2021], leaf: 2019 }, + Case { id: "bettertls::nameconstraints::tc362", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2023, 2024], leaf: 2022 }, + Case { id: "bettertls::nameconstraints::tc363", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2026, 2027], leaf: 2025 }, + Case { id: "bettertls::nameconstraints::tc364", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2029, 2030], leaf: 2028 }, + Case { id: "bettertls::nameconstraints::tc365", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2032, 2033], leaf: 2031 }, + Case { id: "bettertls::nameconstraints::tc366", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2035, 2036], leaf: 2034 }, + Case { id: "bettertls::nameconstraints::tc367", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2038, 2039], leaf: 2037 }, + Case { id: "bettertls::nameconstraints::tc368", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2041, 2042], leaf: 2040 }, + Case { id: "bettertls::nameconstraints::tc369", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2044, 2045], leaf: 2043 }, + Case { id: "bettertls::nameconstraints::tc370", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2047, 2048], leaf: 2046 }, + Case { id: "bettertls::nameconstraints::tc371", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2050, 2051], leaf: 2049 }, + Case { id: "bettertls::nameconstraints::tc372", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2053, 2054], leaf: 2052 }, + Case { id: "bettertls::nameconstraints::tc373", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2056, 2057], leaf: 2055 }, + Case { id: "bettertls::nameconstraints::tc374", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2059, 2060], leaf: 2058 }, + Case { id: "bettertls::nameconstraints::tc375", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2062, 2063], leaf: 2061 }, + Case { id: "bettertls::nameconstraints::tc376", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2065, 2066], leaf: 2064 }, + Case { id: "bettertls::nameconstraints::tc377", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2068, 2069], leaf: 2067 }, + Case { id: "bettertls::nameconstraints::tc378", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2071, 2072], leaf: 2070 }, + Case { id: "bettertls::nameconstraints::tc379", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2074, 2075], leaf: 2073 }, + Case { id: "bettertls::nameconstraints::tc380", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2077, 2078], leaf: 2076 }, + Case { id: "bettertls::nameconstraints::tc381", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2080, 2081], leaf: 2079 }, + Case { id: "bettertls::nameconstraints::tc382", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2083, 2084], leaf: 2082 }, + Case { id: "bettertls::nameconstraints::tc383", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2086, 2087], leaf: 2085 }, + Case { id: "bettertls::nameconstraints::tc384", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2089, 2090], leaf: 2088 }, + Case { id: "bettertls::nameconstraints::tc385", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2092, 2093], leaf: 2091 }, + Case { id: "bettertls::nameconstraints::tc386", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2095, 2096], leaf: 2094 }, + Case { id: "bettertls::nameconstraints::tc387", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2098, 2099], leaf: 2097 }, + Case { id: "bettertls::nameconstraints::tc388", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2101, 2102], leaf: 2100 }, + Case { id: "bettertls::nameconstraints::tc389", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2104, 2105], leaf: 2103 }, + Case { id: "bettertls::nameconstraints::tc390", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2107, 2108], leaf: 2106 }, + Case { id: "bettertls::nameconstraints::tc391", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2110, 2111], leaf: 2109 }, + Case { id: "bettertls::nameconstraints::tc392", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2113, 2114], leaf: 2112 }, + Case { id: "bettertls::nameconstraints::tc393", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2116, 2117], leaf: 2115 }, + Case { id: "bettertls::nameconstraints::tc394", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2119, 2120], leaf: 2118 }, + Case { id: "bettertls::nameconstraints::tc395", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2122, 2123], leaf: 2121 }, + Case { id: "bettertls::nameconstraints::tc396", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2125, 2126], leaf: 2124 }, + Case { id: "bettertls::nameconstraints::tc397", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2128, 2129], leaf: 2127 }, + Case { id: "bettertls::nameconstraints::tc398", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2131, 2132], leaf: 2130 }, + Case { id: "bettertls::nameconstraints::tc399", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2134, 2135], leaf: 2133 }, + Case { id: "bettertls::nameconstraints::tc400", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2137, 2138], leaf: 2136 }, + Case { id: "bettertls::nameconstraints::tc401", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2140, 2141], leaf: 2139 }, + Case { id: "bettertls::nameconstraints::tc402", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2143, 2144], leaf: 2142 }, + Case { id: "bettertls::nameconstraints::tc403", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2146, 2147], leaf: 2145 }, + Case { id: "bettertls::nameconstraints::tc404", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2149, 2150], leaf: 2148 }, + Case { id: "bettertls::nameconstraints::tc405", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2152, 2153], leaf: 2151 }, + Case { id: "bettertls::nameconstraints::tc406", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2155, 2156], leaf: 2154 }, + Case { id: "bettertls::nameconstraints::tc407", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2158, 2159], leaf: 2157 }, + Case { id: "bettertls::nameconstraints::tc408", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2161, 2162], leaf: 2160 }, + Case { id: "bettertls::nameconstraints::tc409", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2164, 2165], leaf: 2163 }, + Case { id: "bettertls::nameconstraints::tc410", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2167, 2168], leaf: 2166 }, + Case { id: "bettertls::nameconstraints::tc411", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2170, 2171], leaf: 2169 }, + Case { id: "bettertls::nameconstraints::tc412", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2173, 2174], leaf: 2172 }, + Case { id: "bettertls::nameconstraints::tc413", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2176, 2177], leaf: 2175 }, + Case { id: "bettertls::nameconstraints::tc414", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2179, 2180], leaf: 2178 }, + Case { id: "bettertls::nameconstraints::tc415", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2182, 2183], leaf: 2181 }, + Case { id: "bettertls::nameconstraints::tc416", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2185, 2186], leaf: 2184 }, + Case { id: "bettertls::nameconstraints::tc417", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2188, 2189], leaf: 2187 }, + Case { id: "bettertls::nameconstraints::tc418", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2191, 2192], leaf: 2190 }, + Case { id: "bettertls::nameconstraints::tc419", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2194, 2195], leaf: 2193 }, + Case { id: "bettertls::nameconstraints::tc420", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2197, 2198], leaf: 2196 }, + Case { id: "bettertls::nameconstraints::tc421", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2200, 2201], leaf: 2199 }, + Case { id: "bettertls::nameconstraints::tc422", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2203, 2204], leaf: 2202 }, + Case { id: "bettertls::nameconstraints::tc423", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2206, 2207], leaf: 2205 }, + Case { id: "bettertls::nameconstraints::tc424", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2209, 2210], leaf: 2208 }, + Case { id: "bettertls::nameconstraints::tc425", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2212, 2213], leaf: 2211 }, + Case { id: "bettertls::nameconstraints::tc426", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2215, 2216], leaf: 2214 }, + Case { id: "bettertls::nameconstraints::tc427", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2218, 2219], leaf: 2217 }, + Case { id: "bettertls::nameconstraints::tc428", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2221, 2222], leaf: 2220 }, + Case { id: "bettertls::nameconstraints::tc429", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2224, 2225], leaf: 2223 }, + Case { id: "bettertls::nameconstraints::tc430", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2227, 2228], leaf: 2226 }, + Case { id: "bettertls::nameconstraints::tc431", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2230, 2231], leaf: 2229 }, + Case { id: "bettertls::nameconstraints::tc432", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2233, 2234], leaf: 2232 }, + Case { id: "bettertls::nameconstraints::tc433", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2236, 2237], leaf: 2235 }, + Case { id: "bettertls::nameconstraints::tc434", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2239, 2240], leaf: 2238 }, + Case { id: "bettertls::nameconstraints::tc435", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2242, 2243], leaf: 2241 }, + Case { id: "bettertls::nameconstraints::tc436", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2245, 2246], leaf: 2244 }, + Case { id: "bettertls::nameconstraints::tc437", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2248, 2249], leaf: 2247 }, + Case { id: "bettertls::nameconstraints::tc438", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2251, 2252], leaf: 2250 }, + Case { id: "bettertls::nameconstraints::tc439", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2254, 2255], leaf: 2253 }, + Case { id: "bettertls::nameconstraints::tc440", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2257, 2258], leaf: 2256 }, + Case { id: "bettertls::nameconstraints::tc441", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2260, 2261], leaf: 2259 }, + Case { id: "bettertls::nameconstraints::tc442", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2263, 2264], leaf: 2262 }, + Case { id: "bettertls::nameconstraints::tc443", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2266, 2267], leaf: 2265 }, + Case { id: "bettertls::nameconstraints::tc444", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2269, 2270], leaf: 2268 }, + Case { id: "bettertls::nameconstraints::tc445", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2272, 2273], leaf: 2271 }, + Case { id: "bettertls::nameconstraints::tc446", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2275, 2276], leaf: 2274 }, + Case { id: "bettertls::nameconstraints::tc447", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2278, 2279], leaf: 2277 }, + Case { id: "bettertls::nameconstraints::tc448", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2281, 2282], leaf: 2280 }, + Case { id: "bettertls::nameconstraints::tc449", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2284, 2285], leaf: 2283 }, + Case { id: "bettertls::nameconstraints::tc450", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2287, 2288], leaf: 2286 }, + Case { id: "bettertls::nameconstraints::tc451", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2290, 2291], leaf: 2289 }, + Case { id: "bettertls::nameconstraints::tc452", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2293, 2294], leaf: 2292 }, + Case { id: "bettertls::nameconstraints::tc453", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2296, 2297], leaf: 2295 }, + Case { id: "bettertls::nameconstraints::tc454", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2299, 2300], leaf: 2298 }, + Case { id: "bettertls::nameconstraints::tc455", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2302, 2303], leaf: 2301 }, + Case { id: "bettertls::nameconstraints::tc456", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2305, 2306], leaf: 2304 }, + Case { id: "bettertls::nameconstraints::tc457", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2308, 2309], leaf: 2307 }, + Case { id: "bettertls::nameconstraints::tc458", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2311, 2312], leaf: 2310 }, + Case { id: "bettertls::nameconstraints::tc459", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2314, 2315], leaf: 2313 }, + Case { id: "bettertls::nameconstraints::tc460", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2317, 2318], leaf: 2316 }, + Case { id: "bettertls::nameconstraints::tc461", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2320, 2321], leaf: 2319 }, + Case { id: "bettertls::nameconstraints::tc462", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2323, 2324], leaf: 2322 }, + Case { id: "bettertls::nameconstraints::tc463", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2326, 2327], leaf: 2325 }, + Case { id: "bettertls::nameconstraints::tc464", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2329, 2330], leaf: 2328 }, + Case { id: "bettertls::nameconstraints::tc465", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2332, 2333], leaf: 2331 }, + Case { id: "bettertls::nameconstraints::tc466", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2335, 2336], leaf: 2334 }, + Case { id: "bettertls::nameconstraints::tc467", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2338, 2339], leaf: 2337 }, + Case { id: "bettertls::nameconstraints::tc468", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2341, 2342], leaf: 2340 }, + Case { id: "bettertls::nameconstraints::tc469", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2344, 2345], leaf: 2343 }, + Case { id: "bettertls::nameconstraints::tc470", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2347, 2348], leaf: 2346 }, + Case { id: "bettertls::nameconstraints::tc471", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2350, 2351], leaf: 2349 }, + Case { id: "bettertls::nameconstraints::tc472", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2353, 2354], leaf: 2352 }, + Case { id: "bettertls::nameconstraints::tc473", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2356, 2357], leaf: 2355 }, + Case { id: "bettertls::nameconstraints::tc474", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2359, 2360], leaf: 2358 }, + Case { id: "bettertls::nameconstraints::tc475", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2362, 2363], leaf: 2361 }, + Case { id: "bettertls::nameconstraints::tc476", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2365, 2366], leaf: 2364 }, + Case { id: "bettertls::nameconstraints::tc477", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2368, 2369], leaf: 2367 }, + Case { id: "bettertls::nameconstraints::tc478", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2371, 2372], leaf: 2370 }, + Case { id: "bettertls::nameconstraints::tc479", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2374, 2375], leaf: 2373 }, + Case { id: "bettertls::nameconstraints::tc480", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2377, 2378], leaf: 2376 }, + Case { id: "bettertls::nameconstraints::tc481", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2380, 2381], leaf: 2379 }, + Case { id: "bettertls::nameconstraints::tc482", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2383, 2384], leaf: 2382 }, + Case { id: "bettertls::nameconstraints::tc483", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2386, 2387], leaf: 2385 }, + Case { id: "bettertls::nameconstraints::tc484", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2389, 2390], leaf: 2388 }, + Case { id: "bettertls::nameconstraints::tc485", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2392, 2393], leaf: 2391 }, + Case { id: "bettertls::nameconstraints::tc486", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2395, 2396], leaf: 2394 }, + Case { id: "bettertls::nameconstraints::tc487", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2398, 2399], leaf: 2397 }, + Case { id: "bettertls::nameconstraints::tc488", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2401, 2402], leaf: 2400 }, + Case { id: "bettertls::nameconstraints::tc489", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2404, 2405], leaf: 2403 }, + Case { id: "bettertls::nameconstraints::tc490", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2407, 2408], leaf: 2406 }, + Case { id: "bettertls::nameconstraints::tc491", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2410, 2411], leaf: 2409 }, + Case { id: "bettertls::nameconstraints::tc492", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2413, 2414], leaf: 2412 }, + Case { id: "bettertls::nameconstraints::tc493", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2416, 2417], leaf: 2415 }, + Case { id: "bettertls::nameconstraints::tc494", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2419, 2420], leaf: 2418 }, + Case { id: "bettertls::nameconstraints::tc495", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2422, 2423], leaf: 2421 }, + Case { id: "bettertls::nameconstraints::tc496", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2425, 2426], leaf: 2424 }, + Case { id: "bettertls::nameconstraints::tc497", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2428, 2429], leaf: 2427 }, + Case { id: "bettertls::nameconstraints::tc498", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2431, 2432], leaf: 2430 }, + Case { id: "bettertls::nameconstraints::tc499", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2434, 2435], leaf: 2433 }, + Case { id: "bettertls::nameconstraints::tc500", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2437, 2438], leaf: 2436 }, + Case { id: "bettertls::nameconstraints::tc501", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2440, 2441], leaf: 2439 }, + Case { id: "bettertls::nameconstraints::tc502", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2443, 2444], leaf: 2442 }, + Case { id: "bettertls::nameconstraints::tc503", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2446, 2447], leaf: 2445 }, + Case { id: "bettertls::nameconstraints::tc504", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2449, 2450], leaf: 2448 }, + Case { id: "bettertls::nameconstraints::tc505", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2452, 2453], leaf: 2451 }, + Case { id: "bettertls::nameconstraints::tc506", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2455, 2456], leaf: 2454 }, + Case { id: "bettertls::nameconstraints::tc507", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2458, 2459], leaf: 2457 }, + Case { id: "bettertls::nameconstraints::tc508", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2461, 2462], leaf: 2460 }, + Case { id: "bettertls::nameconstraints::tc509", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2464, 2465], leaf: 2463 }, + Case { id: "bettertls::nameconstraints::tc510", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2467, 2468], leaf: 2466 }, + Case { id: "bettertls::nameconstraints::tc511", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2470, 2471], leaf: 2469 }, + Case { id: "bettertls::nameconstraints::tc512", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2473, 2474], leaf: 2472 }, + Case { id: "bettertls::nameconstraints::tc513", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2476, 2477], leaf: 2475 }, + Case { id: "bettertls::nameconstraints::tc514", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2479, 2480], leaf: 2478 }, + Case { id: "bettertls::nameconstraints::tc515", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2482, 2483], leaf: 2481 }, + Case { id: "bettertls::nameconstraints::tc516", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2485, 2486], leaf: 2484 }, + Case { id: "bettertls::nameconstraints::tc517", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2488, 2489], leaf: 2487 }, + Case { id: "bettertls::nameconstraints::tc518", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2491, 2492], leaf: 2490 }, + Case { id: "bettertls::nameconstraints::tc519", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2494, 2495], leaf: 2493 }, + Case { id: "bettertls::nameconstraints::tc520", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2497, 2498], leaf: 2496 }, + Case { id: "bettertls::nameconstraints::tc521", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2500, 2501], leaf: 2499 }, + Case { id: "bettertls::nameconstraints::tc522", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2503, 2504], leaf: 2502 }, + Case { id: "bettertls::nameconstraints::tc523", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2506, 2507], leaf: 2505 }, + Case { id: "bettertls::nameconstraints::tc524", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2509, 2510], leaf: 2508 }, + Case { id: "bettertls::nameconstraints::tc525", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2512, 2513], leaf: 2511 }, + Case { id: "bettertls::nameconstraints::tc526", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2515, 2516], leaf: 2514 }, + Case { id: "bettertls::nameconstraints::tc527", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2518, 2519], leaf: 2517 }, + Case { id: "bettertls::nameconstraints::tc528", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2521, 2522], leaf: 2520 }, + Case { id: "bettertls::nameconstraints::tc529", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2524, 2525], leaf: 2523 }, + Case { id: "bettertls::nameconstraints::tc530", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2527, 2528], leaf: 2526 }, + Case { id: "bettertls::nameconstraints::tc531", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2530, 2531], leaf: 2529 }, + Case { id: "bettertls::nameconstraints::tc532", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2533, 2534], leaf: 2532 }, + Case { id: "bettertls::nameconstraints::tc533", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2536, 2537], leaf: 2535 }, + Case { id: "bettertls::nameconstraints::tc534", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2539, 2540], leaf: 2538 }, + Case { id: "bettertls::nameconstraints::tc535", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2542, 2543], leaf: 2541 }, + Case { id: "bettertls::nameconstraints::tc536", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2545, 2546], leaf: 2544 }, + Case { id: "bettertls::nameconstraints::tc537", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2548, 2549], leaf: 2547 }, + Case { id: "bettertls::nameconstraints::tc538", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2551, 2552], leaf: 2550 }, + Case { id: "bettertls::nameconstraints::tc539", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2554, 2555], leaf: 2553 }, + Case { id: "bettertls::nameconstraints::tc540", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2557, 2558], leaf: 2556 }, + Case { id: "bettertls::nameconstraints::tc541", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2560, 2561], leaf: 2559 }, + Case { id: "bettertls::nameconstraints::tc542", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2563, 2564], leaf: 2562 }, + Case { id: "bettertls::nameconstraints::tc543", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2566, 2567], leaf: 2565 }, + Case { id: "bettertls::nameconstraints::tc544", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2569, 2570], leaf: 2568 }, + Case { id: "bettertls::nameconstraints::tc545", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2572, 2573], leaf: 2571 }, + Case { id: "bettertls::nameconstraints::tc546", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2575, 2576], leaf: 2574 }, + Case { id: "bettertls::nameconstraints::tc547", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2578, 2579], leaf: 2577 }, + Case { id: "bettertls::nameconstraints::tc548", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2581, 2582], leaf: 2580 }, + Case { id: "bettertls::nameconstraints::tc549", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2584, 2585], leaf: 2583 }, + Case { id: "bettertls::nameconstraints::tc550", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2587, 2588], leaf: 2586 }, + Case { id: "bettertls::nameconstraints::tc551", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2590, 2591], leaf: 2589 }, + Case { id: "bettertls::nameconstraints::tc552", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2593, 2594], leaf: 2592 }, + Case { id: "bettertls::nameconstraints::tc553", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2596, 2597], leaf: 2595 }, + Case { id: "bettertls::nameconstraints::tc554", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2599, 2600], leaf: 2598 }, + Case { id: "bettertls::nameconstraints::tc555", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2602, 2603], leaf: 2601 }, + Case { id: "bettertls::nameconstraints::tc556", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2605, 2606], leaf: 2604 }, + Case { id: "bettertls::nameconstraints::tc557", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2608, 2609], leaf: 2607 }, + Case { id: "bettertls::nameconstraints::tc558", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2611, 2612], leaf: 2610 }, + Case { id: "bettertls::nameconstraints::tc559", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2614, 2615], leaf: 2613 }, + Case { id: "bettertls::nameconstraints::tc560", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2617, 2618], leaf: 2616 }, + Case { id: "bettertls::nameconstraints::tc561", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2620, 2621], leaf: 2619 }, + Case { id: "bettertls::nameconstraints::tc562", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2623, 2624], leaf: 2622 }, + Case { id: "bettertls::nameconstraints::tc563", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2626, 2627], leaf: 2625 }, + Case { id: "bettertls::nameconstraints::tc564", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2629, 2630], leaf: 2628 }, + Case { id: "bettertls::nameconstraints::tc565", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2632, 2633], leaf: 2631 }, + Case { id: "bettertls::nameconstraints::tc566", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2635, 2636], leaf: 2634 }, + Case { id: "bettertls::nameconstraints::tc567", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2638, 2639], leaf: 2637 }, + Case { id: "bettertls::nameconstraints::tc568", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2641, 2642], leaf: 2640 }, + Case { id: "bettertls::nameconstraints::tc569", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2644, 2645], leaf: 2643 }, + Case { id: "bettertls::nameconstraints::tc570", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2647, 2648], leaf: 2646 }, + Case { id: "bettertls::nameconstraints::tc571", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2650, 2651], leaf: 2649 }, + Case { id: "bettertls::nameconstraints::tc572", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2653, 2654], leaf: 2652 }, + Case { id: "bettertls::nameconstraints::tc573", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2656, 2657], leaf: 2655 }, + Case { id: "bettertls::nameconstraints::tc574", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2659, 2660], leaf: 2658 }, + Case { id: "bettertls::nameconstraints::tc575", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2662, 2663], leaf: 2661 }, + Case { id: "bettertls::nameconstraints::tc576", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2665, 2666], leaf: 2664 }, + Case { id: "bettertls::nameconstraints::tc577", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2668, 2669], leaf: 2667 }, + Case { id: "bettertls::nameconstraints::tc578", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2671, 2672], leaf: 2670 }, + Case { id: "bettertls::nameconstraints::tc579", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2674, 2675], leaf: 2673 }, + Case { id: "bettertls::nameconstraints::tc580", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2677, 2678], leaf: 2676 }, + Case { id: "bettertls::nameconstraints::tc581", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2680, 2681], leaf: 2679 }, + Case { id: "bettertls::nameconstraints::tc582", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2683, 2684], leaf: 2682 }, + Case { id: "bettertls::nameconstraints::tc583", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2686, 2687], leaf: 2685 }, + Case { id: "bettertls::nameconstraints::tc584", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2689, 2690], leaf: 2688 }, + Case { id: "bettertls::nameconstraints::tc585", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2692, 2693], leaf: 2691 }, + Case { id: "bettertls::nameconstraints::tc586", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2695, 2696], leaf: 2694 }, + Case { id: "bettertls::nameconstraints::tc587", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2698, 2699], leaf: 2697 }, + Case { id: "bettertls::nameconstraints::tc588", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2701, 2702], leaf: 2700 }, + Case { id: "bettertls::nameconstraints::tc589", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2704, 2705], leaf: 2703 }, + Case { id: "bettertls::nameconstraints::tc590", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2707, 2708], leaf: 2706 }, + Case { id: "bettertls::nameconstraints::tc591", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2710, 2711], leaf: 2709 }, + Case { id: "bettertls::nameconstraints::tc592", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2713, 2714], leaf: 2712 }, + Case { id: "bettertls::nameconstraints::tc593", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2716, 2717], leaf: 2715 }, + Case { id: "bettertls::nameconstraints::tc594", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2719, 2720], leaf: 2718 }, + Case { id: "bettertls::nameconstraints::tc595", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2722, 2723], leaf: 2721 }, + Case { id: "bettertls::nameconstraints::tc596", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2725, 2726], leaf: 2724 }, + Case { id: "bettertls::nameconstraints::tc597", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2728, 2729], leaf: 2727 }, + Case { id: "bettertls::nameconstraints::tc598", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2731, 2732], leaf: 2730 }, + Case { id: "bettertls::nameconstraints::tc599", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2734, 2735], leaf: 2733 }, + Case { id: "bettertls::nameconstraints::tc600", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2737, 2738], leaf: 2736 }, + Case { id: "bettertls::nameconstraints::tc601", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2740, 2741], leaf: 2739 }, + Case { id: "bettertls::nameconstraints::tc602", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2743, 2744], leaf: 2742 }, + Case { id: "bettertls::nameconstraints::tc603", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2746, 2747], leaf: 2745 }, + Case { id: "bettertls::nameconstraints::tc604", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2749, 2750], leaf: 2748 }, + Case { id: "bettertls::nameconstraints::tc605", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2752, 2753], leaf: 2751 }, + Case { id: "bettertls::nameconstraints::tc606", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2755, 2756], leaf: 2754 }, + Case { id: "bettertls::nameconstraints::tc607", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2758, 2759], leaf: 2757 }, + Case { id: "bettertls::nameconstraints::tc608", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2761, 2762], leaf: 2760 }, + Case { id: "bettertls::nameconstraints::tc609", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2764, 2765], leaf: 2763 }, + Case { id: "bettertls::nameconstraints::tc610", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2767, 2768], leaf: 2766 }, + Case { id: "bettertls::nameconstraints::tc611", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2770, 2771], leaf: 2769 }, + Case { id: "bettertls::nameconstraints::tc612", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2773, 2774], leaf: 2772 }, + Case { id: "bettertls::nameconstraints::tc613", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2776, 2777], leaf: 2775 }, + Case { id: "bettertls::nameconstraints::tc614", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2779, 2780], leaf: 2778 }, + Case { id: "bettertls::nameconstraints::tc615", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2782, 2783], leaf: 2781 }, + Case { id: "bettertls::nameconstraints::tc616", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2785, 2786], leaf: 2784 }, + Case { id: "bettertls::nameconstraints::tc617", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2788, 2789], leaf: 2787 }, + Case { id: "bettertls::nameconstraints::tc618", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2791, 2792], leaf: 2790 }, + Case { id: "bettertls::nameconstraints::tc619", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2794, 2795], leaf: 2793 }, + Case { id: "bettertls::nameconstraints::tc620", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2797, 2798], leaf: 2796 }, + Case { id: "bettertls::nameconstraints::tc621", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2800, 2801], leaf: 2799 }, + Case { id: "bettertls::nameconstraints::tc622", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2803, 2804], leaf: 2802 }, + Case { id: "bettertls::nameconstraints::tc623", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2806, 2807], leaf: 2805 }, + Case { id: "bettertls::nameconstraints::tc624", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2809, 2810], leaf: 2808 }, + Case { id: "bettertls::nameconstraints::tc625", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2812, 2813], leaf: 2811 }, + Case { id: "bettertls::nameconstraints::tc626", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2815, 2816], leaf: 2814 }, + Case { id: "bettertls::nameconstraints::tc627", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2818, 2819], leaf: 2817 }, + Case { id: "bettertls::nameconstraints::tc628", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2821, 2822], leaf: 2820 }, + Case { id: "bettertls::nameconstraints::tc629", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2824, 2825], leaf: 2823 }, + Case { id: "bettertls::nameconstraints::tc630", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2827, 2828], leaf: 2826 }, + Case { id: "bettertls::nameconstraints::tc631", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2830, 2831], leaf: 2829 }, + Case { id: "bettertls::nameconstraints::tc632", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2833, 2834], leaf: 2832 }, + Case { id: "bettertls::nameconstraints::tc633", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2836, 2837], leaf: 2835 }, + Case { id: "bettertls::nameconstraints::tc634", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2839, 2840], leaf: 2838 }, + Case { id: "bettertls::nameconstraints::tc635", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2842, 2843], leaf: 2841 }, + Case { id: "bettertls::nameconstraints::tc636", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2845, 2846], leaf: 2844 }, + Case { id: "bettertls::nameconstraints::tc637", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2848, 2849], leaf: 2847 }, + Case { id: "bettertls::nameconstraints::tc638", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2851, 2852], leaf: 2850 }, + Case { id: "bettertls::nameconstraints::tc639", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2854, 2855], leaf: 2853 }, + Case { id: "bettertls::nameconstraints::tc640", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2857, 2858], leaf: 2856 }, + Case { id: "bettertls::nameconstraints::tc641", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2860, 2861], leaf: 2859 }, + Case { id: "bettertls::nameconstraints::tc642", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2863, 2864], leaf: 2862 }, + Case { id: "bettertls::nameconstraints::tc643", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2866, 2867], leaf: 2865 }, + Case { id: "bettertls::nameconstraints::tc644", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2869, 2870], leaf: 2868 }, + Case { id: "bettertls::nameconstraints::tc645", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2872, 2873], leaf: 2871 }, + Case { id: "bettertls::nameconstraints::tc646", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2875, 2876], leaf: 2874 }, + Case { id: "bettertls::nameconstraints::tc647", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2878, 2879], leaf: 2877 }, + Case { id: "bettertls::nameconstraints::tc648", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2881, 2882], leaf: 2880 }, + Case { id: "bettertls::nameconstraints::tc649", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2884, 2885], leaf: 2883 }, + Case { id: "bettertls::nameconstraints::tc650", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2887, 2888], leaf: 2886 }, + Case { id: "bettertls::nameconstraints::tc651", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2890, 2891], leaf: 2889 }, + Case { id: "bettertls::nameconstraints::tc652", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2893, 2894], leaf: 2892 }, + Case { id: "bettertls::nameconstraints::tc653", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2896, 2897], leaf: 2895 }, + Case { id: "bettertls::nameconstraints::tc654", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2899, 2900], leaf: 2898 }, + Case { id: "bettertls::nameconstraints::tc655", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2902, 2903], leaf: 2901 }, + Case { id: "bettertls::nameconstraints::tc656", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2905, 2906], leaf: 2904 }, + Case { id: "bettertls::nameconstraints::tc657", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2908, 2909], leaf: 2907 }, + Case { id: "bettertls::nameconstraints::tc658", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2911, 2912], leaf: 2910 }, + Case { id: "bettertls::nameconstraints::tc659", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2914, 2915], leaf: 2913 }, + Case { id: "bettertls::nameconstraints::tc660", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2917, 2918], leaf: 2916 }, + Case { id: "bettertls::nameconstraints::tc661", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2920, 2921], leaf: 2919 }, + Case { id: "bettertls::nameconstraints::tc662", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2923, 2924], leaf: 2922 }, + Case { id: "bettertls::nameconstraints::tc663", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2926, 2927], leaf: 2925 }, + Case { id: "bettertls::nameconstraints::tc664", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2929, 2930], leaf: 2928 }, + Case { id: "bettertls::nameconstraints::tc665", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2932, 2933], leaf: 2931 }, + Case { id: "bettertls::nameconstraints::tc666", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2935, 2936], leaf: 2934 }, + Case { id: "bettertls::nameconstraints::tc667", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2938, 2939], leaf: 2937 }, + Case { id: "bettertls::nameconstraints::tc668", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2941, 2942], leaf: 2940 }, + Case { id: "bettertls::nameconstraints::tc669", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2944, 2945], leaf: 2943 }, + Case { id: "bettertls::nameconstraints::tc670", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2947, 2948], leaf: 2946 }, + Case { id: "bettertls::nameconstraints::tc671", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2950, 2951], leaf: 2949 }, + Case { id: "bettertls::nameconstraints::tc672", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2953, 2954], leaf: 2952 }, + Case { id: "bettertls::nameconstraints::tc673", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2956, 2957], leaf: 2955 }, + Case { id: "bettertls::nameconstraints::tc674", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2959, 2960], leaf: 2958 }, + Case { id: "bettertls::nameconstraints::tc675", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2962, 2963], leaf: 2961 }, + Case { id: "bettertls::nameconstraints::tc676", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2965, 2966], leaf: 2964 }, + Case { id: "bettertls::nameconstraints::tc677", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2968, 2969], leaf: 2967 }, + Case { id: "bettertls::nameconstraints::tc678", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2971, 2972], leaf: 2970 }, + Case { id: "bettertls::nameconstraints::tc679", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2974, 2975], leaf: 2973 }, + Case { id: "bettertls::nameconstraints::tc680", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2977, 2978], leaf: 2976 }, + Case { id: "bettertls::nameconstraints::tc681", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2980, 2981], leaf: 2979 }, + Case { id: "bettertls::nameconstraints::tc682", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2983, 2984], leaf: 2982 }, + Case { id: "bettertls::nameconstraints::tc683", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2986, 2987], leaf: 2985 }, + Case { id: "bettertls::nameconstraints::tc684", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2989, 2990], leaf: 2988 }, + Case { id: "bettertls::nameconstraints::tc685", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2992, 2993], leaf: 2991 }, + Case { id: "bettertls::nameconstraints::tc686", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2995, 2996], leaf: 2994 }, + Case { id: "bettertls::nameconstraints::tc687", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[2998, 2999], leaf: 2997 }, + Case { id: "bettertls::nameconstraints::tc688", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3001, 3002], leaf: 3000 }, + Case { id: "bettertls::nameconstraints::tc689", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3004, 3005], leaf: 3003 }, + Case { id: "bettertls::nameconstraints::tc690", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3007, 3008], leaf: 3006 }, + Case { id: "bettertls::nameconstraints::tc691", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3010, 3011], leaf: 3009 }, + Case { id: "bettertls::nameconstraints::tc692", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3013, 3014], leaf: 3012 }, + Case { id: "bettertls::nameconstraints::tc693", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3016, 3017], leaf: 3015 }, + Case { id: "bettertls::nameconstraints::tc694", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3019, 3020], leaf: 3018 }, + Case { id: "bettertls::nameconstraints::tc695", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3022, 3023], leaf: 3021 }, + Case { id: "bettertls::nameconstraints::tc696", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3025, 3026], leaf: 3024 }, + Case { id: "bettertls::nameconstraints::tc697", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3028, 3029], leaf: 3027 }, + Case { id: "bettertls::nameconstraints::tc698", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3031, 3032], leaf: 3030 }, + Case { id: "bettertls::nameconstraints::tc699", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3034, 3035], leaf: 3033 }, + Case { id: "bettertls::nameconstraints::tc700", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3037, 3038], leaf: 3036 }, + Case { id: "bettertls::nameconstraints::tc701", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3040, 3041], leaf: 3039 }, + Case { id: "bettertls::nameconstraints::tc702", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3043, 3044], leaf: 3042 }, + Case { id: "bettertls::nameconstraints::tc703", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3046, 3047], leaf: 3045 }, + Case { id: "bettertls::nameconstraints::tc704", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3049, 3050], leaf: 3048 }, + Case { id: "bettertls::nameconstraints::tc705", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3052, 3053], leaf: 3051 }, + Case { id: "bettertls::nameconstraints::tc706", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3055, 3056], leaf: 3054 }, + Case { id: "bettertls::nameconstraints::tc707", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3058, 3059], leaf: 3057 }, + Case { id: "bettertls::nameconstraints::tc708", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3061, 3062], leaf: 3060 }, + Case { id: "bettertls::nameconstraints::tc709", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:50+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3064, 3065], leaf: 3063 }, + Case { id: "bettertls::nameconstraints::tc710", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3067, 3068], leaf: 3066 }, + Case { id: "bettertls::nameconstraints::tc711", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3070, 3071], leaf: 3069 }, + Case { id: "bettertls::nameconstraints::tc712", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3073, 3074], leaf: 3072 }, + Case { id: "bettertls::nameconstraints::tc713", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3076, 3077], leaf: 3075 }, + Case { id: "bettertls::nameconstraints::tc714", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3079, 3080], leaf: 3078 }, + Case { id: "bettertls::nameconstraints::tc715", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3082, 3083], leaf: 3081 }, + Case { id: "bettertls::nameconstraints::tc716", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3085, 3086], leaf: 3084 }, + Case { id: "bettertls::nameconstraints::tc717", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3088, 3089], leaf: 3087 }, + Case { id: "bettertls::nameconstraints::tc718", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3091, 3092], leaf: 3090 }, + Case { id: "bettertls::nameconstraints::tc719", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3094, 3095], leaf: 3093 }, + Case { id: "bettertls::nameconstraints::tc720", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3097, 3098], leaf: 3096 }, + Case { id: "bettertls::nameconstraints::tc721", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3100, 3101], leaf: 3099 }, + Case { id: "bettertls::nameconstraints::tc722", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3103, 3104], leaf: 3102 }, + Case { id: "bettertls::nameconstraints::tc723", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3106, 3107], leaf: 3105 }, + Case { id: "bettertls::nameconstraints::tc724", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3109, 3110], leaf: 3108 }, + Case { id: "bettertls::nameconstraints::tc725", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3112, 3113], leaf: 3111 }, + Case { id: "bettertls::nameconstraints::tc726", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3115, 3116], leaf: 3114 }, + Case { id: "bettertls::nameconstraints::tc727", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3118, 3119], leaf: 3117 }, + Case { id: "bettertls::nameconstraints::tc728", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3121, 3122], leaf: 3120 }, + Case { id: "bettertls::nameconstraints::tc729", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3124, 3125], leaf: 3123 }, + Case { id: "bettertls::nameconstraints::tc730", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3127, 3128], leaf: 3126 }, + Case { id: "bettertls::nameconstraints::tc731", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3130, 3131], leaf: 3129 }, + Case { id: "bettertls::nameconstraints::tc732", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3133, 3134], leaf: 3132 }, + Case { id: "bettertls::nameconstraints::tc733", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3136, 3137], leaf: 3135 }, + Case { id: "bettertls::nameconstraints::tc734", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3139, 3140], leaf: 3138 }, + Case { id: "bettertls::nameconstraints::tc735", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3142, 3143], leaf: 3141 }, + Case { id: "bettertls::nameconstraints::tc736", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3145, 3146], leaf: 3144 }, + Case { id: "bettertls::nameconstraints::tc737", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3148, 3149], leaf: 3147 }, + Case { id: "bettertls::nameconstraints::tc738", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3151, 3152], leaf: 3150 }, + Case { id: "bettertls::nameconstraints::tc739", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3154, 3155], leaf: 3153 }, + Case { id: "bettertls::nameconstraints::tc740", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3157, 3158], leaf: 3156 }, + Case { id: "bettertls::nameconstraints::tc741", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3160, 3161], leaf: 3159 }, + Case { id: "bettertls::nameconstraints::tc742", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3163, 3164], leaf: 3162 }, + Case { id: "bettertls::nameconstraints::tc743", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3166, 3167], leaf: 3165 }, + Case { id: "bettertls::nameconstraints::tc744", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3169, 3170], leaf: 3168 }, + Case { id: "bettertls::nameconstraints::tc745", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3172, 3173], leaf: 3171 }, + Case { id: "bettertls::nameconstraints::tc746", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3175, 3176], leaf: 3174 }, + Case { id: "bettertls::nameconstraints::tc747", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3178, 3179], leaf: 3177 }, + Case { id: "bettertls::nameconstraints::tc748", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3181, 3182], leaf: 3180 }, + Case { id: "bettertls::nameconstraints::tc749", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3184, 3185], leaf: 3183 }, + Case { id: "bettertls::nameconstraints::tc750", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3187, 3188], leaf: 3186 }, + Case { id: "bettertls::nameconstraints::tc751", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3190, 3191], leaf: 3189 }, + Case { id: "bettertls::nameconstraints::tc752", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3193, 3194], leaf: 3192 }, + Case { id: "bettertls::nameconstraints::tc753", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3196, 3197], leaf: 3195 }, + Case { id: "bettertls::nameconstraints::tc754", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3199, 3200], leaf: 3198 }, + Case { id: "bettertls::nameconstraints::tc755", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3202, 3203], leaf: 3201 }, + Case { id: "bettertls::nameconstraints::tc756", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3205, 3206], leaf: 3204 }, + Case { id: "bettertls::nameconstraints::tc757", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3208, 3209], leaf: 3207 }, + Case { id: "bettertls::nameconstraints::tc758", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3211, 3212], leaf: 3210 }, + Case { id: "bettertls::nameconstraints::tc759", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3214, 3215], leaf: 3213 }, + Case { id: "bettertls::nameconstraints::tc760", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3217, 3218], leaf: 3216 }, + Case { id: "bettertls::nameconstraints::tc761", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3220, 3221], leaf: 3219 }, + Case { id: "bettertls::nameconstraints::tc762", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3223, 3224], leaf: 3222 }, + Case { id: "bettertls::nameconstraints::tc763", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3226, 3227], leaf: 3225 }, + Case { id: "bettertls::nameconstraints::tc764", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3229, 3230], leaf: 3228 }, + Case { id: "bettertls::nameconstraints::tc765", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3232, 3233], leaf: 3231 }, + Case { id: "bettertls::nameconstraints::tc766", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3235, 3236], leaf: 3234 }, + Case { id: "bettertls::nameconstraints::tc767", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3238, 3239], leaf: 3237 }, + Case { id: "bettertls::nameconstraints::tc768", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3241, 3242], leaf: 3240 }, + Case { id: "bettertls::nameconstraints::tc769", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3244, 3245], leaf: 3243 }, + Case { id: "bettertls::nameconstraints::tc770", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3247, 3248], leaf: 3246 }, + Case { id: "bettertls::nameconstraints::tc771", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3250, 3251], leaf: 3249 }, + Case { id: "bettertls::nameconstraints::tc772", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3253, 3254], leaf: 3252 }, + Case { id: "bettertls::nameconstraints::tc773", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3256, 3257], leaf: 3255 }, + Case { id: "bettertls::nameconstraints::tc774", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3259, 3260], leaf: 3258 }, + Case { id: "bettertls::nameconstraints::tc775", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3262, 3263], leaf: 3261 }, + Case { id: "bettertls::nameconstraints::tc776", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3265, 3266], leaf: 3264 }, + Case { id: "bettertls::nameconstraints::tc777", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3268, 3269], leaf: 3267 }, + Case { id: "bettertls::nameconstraints::tc778", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3271, 3272], leaf: 3270 }, + Case { id: "bettertls::nameconstraints::tc779", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3274, 3275], leaf: 3273 }, + Case { id: "bettertls::nameconstraints::tc780", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3277, 3278], leaf: 3276 }, + Case { id: "bettertls::nameconstraints::tc781", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3280, 3281], leaf: 3279 }, + Case { id: "bettertls::nameconstraints::tc782", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3283, 3284], leaf: 3282 }, + Case { id: "bettertls::nameconstraints::tc783", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3286, 3287], leaf: 3285 }, + Case { id: "bettertls::nameconstraints::tc784", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3289, 3290], leaf: 3288 }, + Case { id: "bettertls::nameconstraints::tc785", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3292, 3293], leaf: 3291 }, + Case { id: "bettertls::nameconstraints::tc786", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3295, 3296], leaf: 3294 }, + Case { id: "bettertls::nameconstraints::tc787", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3298, 3299], leaf: 3297 }, + Case { id: "bettertls::nameconstraints::tc788", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3301, 3302], leaf: 3300 }, + Case { id: "bettertls::nameconstraints::tc789", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3304, 3305], leaf: 3303 }, + Case { id: "bettertls::nameconstraints::tc790", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3307, 3308], leaf: 3306 }, + Case { id: "bettertls::nameconstraints::tc791", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3310, 3311], leaf: 3309 }, + Case { id: "bettertls::nameconstraints::tc792", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3313, 3314], leaf: 3312 }, + Case { id: "bettertls::nameconstraints::tc793", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3316, 3317], leaf: 3315 }, + Case { id: "bettertls::nameconstraints::tc794", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3319, 3320], leaf: 3318 }, + Case { id: "bettertls::nameconstraints::tc795", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3322, 3323], leaf: 3321 }, + Case { id: "bettertls::nameconstraints::tc796", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3325, 3326], leaf: 3324 }, + Case { id: "bettertls::nameconstraints::tc797", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3328, 3329], leaf: 3327 }, + Case { id: "bettertls::nameconstraints::tc798", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3331, 3332], leaf: 3330 }, + Case { id: "bettertls::nameconstraints::tc799", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3334, 3335], leaf: 3333 }, + Case { id: "bettertls::nameconstraints::tc800", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3337, 3338], leaf: 3336 }, + Case { id: "bettertls::nameconstraints::tc801", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3340, 3341], leaf: 3339 }, + Case { id: "bettertls::nameconstraints::tc802", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3343, 3344], leaf: 3342 }, + Case { id: "bettertls::nameconstraints::tc803", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3346, 3347], leaf: 3345 }, + Case { id: "bettertls::nameconstraints::tc804", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3349, 3350], leaf: 3348 }, + Case { id: "bettertls::nameconstraints::tc805", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3352, 3353], leaf: 3351 }, + Case { id: "bettertls::nameconstraints::tc806", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3355, 3356], leaf: 3354 }, + Case { id: "bettertls::nameconstraints::tc807", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3358, 3359], leaf: 3357 }, + Case { id: "bettertls::nameconstraints::tc808", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3361, 3362], leaf: 3360 }, + Case { id: "bettertls::nameconstraints::tc809", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3364, 3365], leaf: 3363 }, + Case { id: "bettertls::nameconstraints::tc810", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3367, 3368], leaf: 3366 }, + Case { id: "bettertls::nameconstraints::tc811", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3370, 3371], leaf: 3369 }, + Case { id: "bettertls::nameconstraints::tc812", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3373, 3374], leaf: 3372 }, + Case { id: "bettertls::nameconstraints::tc813", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3376, 3377], leaf: 3375 }, + Case { id: "bettertls::nameconstraints::tc814", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3379, 3380], leaf: 3378 }, + Case { id: "bettertls::nameconstraints::tc815", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3382, 3383], leaf: 3381 }, + Case { id: "bettertls::nameconstraints::tc816", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3385, 3386], leaf: 3384 }, + Case { id: "bettertls::nameconstraints::tc817", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3388, 3389], leaf: 3387 }, + Case { id: "bettertls::nameconstraints::tc818", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3391, 3392], leaf: 3390 }, + Case { id: "bettertls::nameconstraints::tc819", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3394, 3395], leaf: 3393 }, + Case { id: "bettertls::nameconstraints::tc820", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3397, 3398], leaf: 3396 }, + Case { id: "bettertls::nameconstraints::tc821", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3400, 3401], leaf: 3399 }, + Case { id: "bettertls::nameconstraints::tc822", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3403, 3404], leaf: 3402 }, + Case { id: "bettertls::nameconstraints::tc823", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3406, 3407], leaf: 3405 }, + Case { id: "bettertls::nameconstraints::tc824", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3409, 3410], leaf: 3408 }, + Case { id: "bettertls::nameconstraints::tc825", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3412, 3413], leaf: 3411 }, + Case { id: "bettertls::nameconstraints::tc826", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3415, 3416], leaf: 3414 }, + Case { id: "bettertls::nameconstraints::tc827", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3418, 3419], leaf: 3417 }, + Case { id: "bettertls::nameconstraints::tc828", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3421, 3422], leaf: 3420 }, + Case { id: "bettertls::nameconstraints::tc829", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3424, 3425], leaf: 3423 }, + Case { id: "bettertls::nameconstraints::tc830", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3427, 3428], leaf: 3426 }, + Case { id: "bettertls::nameconstraints::tc831", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3430, 3431], leaf: 3429 }, + Case { id: "bettertls::nameconstraints::tc832", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3433, 3434], leaf: 3432 }, + Case { id: "bettertls::nameconstraints::tc833", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3436, 3437], leaf: 3435 }, + Case { id: "bettertls::nameconstraints::tc834", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3439, 3440], leaf: 3438 }, + Case { id: "bettertls::nameconstraints::tc835", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3442, 3443], leaf: 3441 }, + Case { id: "bettertls::nameconstraints::tc836", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3445, 3446], leaf: 3444 }, + Case { id: "bettertls::nameconstraints::tc837", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3448, 3449], leaf: 3447 }, + Case { id: "bettertls::nameconstraints::tc838", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3451, 3452], leaf: 3450 }, + Case { id: "bettertls::nameconstraints::tc839", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3454, 3455], leaf: 3453 }, + Case { id: "bettertls::nameconstraints::tc840", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3457, 3458], leaf: 3456 }, + Case { id: "bettertls::nameconstraints::tc841", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3460, 3461], leaf: 3459 }, + Case { id: "bettertls::nameconstraints::tc842", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3463, 3464], leaf: 3462 }, + Case { id: "bettertls::nameconstraints::tc843", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3466, 3467], leaf: 3465 }, + Case { id: "bettertls::nameconstraints::tc844", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3469, 3470], leaf: 3468 }, + Case { id: "bettertls::nameconstraints::tc845", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3472, 3473], leaf: 3471 }, + Case { id: "bettertls::nameconstraints::tc846", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3475, 3476], leaf: 3474 }, + Case { id: "bettertls::nameconstraints::tc847", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3478, 3479], leaf: 3477 }, + Case { id: "bettertls::nameconstraints::tc848", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3481, 3482], leaf: 3480 }, + Case { id: "bettertls::nameconstraints::tc849", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3484, 3485], leaf: 3483 }, + Case { id: "bettertls::nameconstraints::tc850", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3487, 3488], leaf: 3486 }, + Case { id: "bettertls::nameconstraints::tc851", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3490, 3491], leaf: 3489 }, + Case { id: "bettertls::nameconstraints::tc852", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3493, 3494], leaf: 3492 }, + Case { id: "bettertls::nameconstraints::tc853", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3496, 3497], leaf: 3495 }, + Case { id: "bettertls::nameconstraints::tc854", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3499, 3500], leaf: 3498 }, + Case { id: "bettertls::nameconstraints::tc855", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3502, 3503], leaf: 3501 }, + Case { id: "bettertls::nameconstraints::tc856", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3505, 3506], leaf: 3504 }, + Case { id: "bettertls::nameconstraints::tc857", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3508, 3509], leaf: 3507 }, + Case { id: "bettertls::nameconstraints::tc858", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3511, 3512], leaf: 3510 }, + Case { id: "bettertls::nameconstraints::tc859", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3514, 3515], leaf: 3513 }, + Case { id: "bettertls::nameconstraints::tc860", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3517, 3518], leaf: 3516 }, + Case { id: "bettertls::nameconstraints::tc861", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3520, 3521], leaf: 3519 }, + Case { id: "bettertls::nameconstraints::tc862", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3523, 3524], leaf: 3522 }, + Case { id: "bettertls::nameconstraints::tc863", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3526, 3527], leaf: 3525 }, + Case { id: "bettertls::nameconstraints::tc864", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3529, 3530], leaf: 3528 }, + Case { id: "bettertls::nameconstraints::tc865", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3532, 3533], leaf: 3531 }, + Case { id: "bettertls::nameconstraints::tc866", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3535, 3536], leaf: 3534 }, + Case { id: "bettertls::nameconstraints::tc867", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3538, 3539], leaf: 3537 }, + Case { id: "bettertls::nameconstraints::tc868", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3541, 3542], leaf: 3540 }, + Case { id: "bettertls::nameconstraints::tc869", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3544, 3545], leaf: 3543 }, + Case { id: "bettertls::nameconstraints::tc870", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3547, 3548], leaf: 3546 }, + Case { id: "bettertls::nameconstraints::tc871", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3550, 3551], leaf: 3549 }, + Case { id: "bettertls::nameconstraints::tc872", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3553, 3554], leaf: 3552 }, + Case { id: "bettertls::nameconstraints::tc873", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3556, 3557], leaf: 3555 }, + Case { id: "bettertls::nameconstraints::tc874", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3559, 3560], leaf: 3558 }, + Case { id: "bettertls::nameconstraints::tc875", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3562, 3563], leaf: 3561 }, + Case { id: "bettertls::nameconstraints::tc876", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3565, 3566], leaf: 3564 }, + Case { id: "bettertls::nameconstraints::tc877", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3568, 3569], leaf: 3567 }, + Case { id: "bettertls::nameconstraints::tc878", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3571, 3572], leaf: 3570 }, + Case { id: "bettertls::nameconstraints::tc879", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3574, 3575], leaf: 3573 }, + Case { id: "bettertls::nameconstraints::tc880", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3577, 3578], leaf: 3576 }, + Case { id: "bettertls::nameconstraints::tc881", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3580, 3581], leaf: 3579 }, + Case { id: "bettertls::nameconstraints::tc882", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3583, 3584], leaf: 3582 }, + Case { id: "bettertls::nameconstraints::tc883", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3586, 3587], leaf: 3585 }, + Case { id: "bettertls::nameconstraints::tc884", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3589, 3590], leaf: 3588 }, + Case { id: "bettertls::nameconstraints::tc885", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3592, 3593], leaf: 3591 }, + Case { id: "bettertls::nameconstraints::tc886", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3595, 3596], leaf: 3594 }, + Case { id: "bettertls::nameconstraints::tc887", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3598, 3599], leaf: 3597 }, + Case { id: "bettertls::nameconstraints::tc888", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3601, 3602], leaf: 3600 }, + Case { id: "bettertls::nameconstraints::tc889", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3604, 3605], leaf: 3603 }, + Case { id: "bettertls::nameconstraints::tc890", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3607, 3608], leaf: 3606 }, + Case { id: "bettertls::nameconstraints::tc891", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3610, 3611], leaf: 3609 }, + Case { id: "bettertls::nameconstraints::tc892", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3613, 3614], leaf: 3612 }, + Case { id: "bettertls::nameconstraints::tc893", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3616, 3617], leaf: 3615 }, + Case { id: "bettertls::nameconstraints::tc894", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3619, 3620], leaf: 3618 }, + Case { id: "bettertls::nameconstraints::tc895", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3622, 3623], leaf: 3621 }, + Case { id: "bettertls::nameconstraints::tc896", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3625, 3626], leaf: 3624 }, + Case { id: "bettertls::nameconstraints::tc897", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3628, 3629], leaf: 3627 }, + Case { id: "bettertls::nameconstraints::tc898", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3631, 3632], leaf: 3630 }, + Case { id: "bettertls::nameconstraints::tc899", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3634, 3635], leaf: 3633 }, + Case { id: "bettertls::nameconstraints::tc900", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3637, 3638], leaf: 3636 }, + Case { id: "bettertls::nameconstraints::tc901", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3640, 3641], leaf: 3639 }, + Case { id: "bettertls::nameconstraints::tc902", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3643, 3644], leaf: 3642 }, + Case { id: "bettertls::nameconstraints::tc903", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3646, 3647], leaf: 3645 }, + Case { id: "bettertls::nameconstraints::tc904", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3649, 3650], leaf: 3648 }, + Case { id: "bettertls::nameconstraints::tc905", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3652, 3653], leaf: 3651 }, + Case { id: "bettertls::nameconstraints::tc906", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3655, 3656], leaf: 3654 }, + Case { id: "bettertls::nameconstraints::tc907", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3658, 3659], leaf: 3657 }, + Case { id: "bettertls::nameconstraints::tc908", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3661, 3662], leaf: 3660 }, + Case { id: "bettertls::nameconstraints::tc909", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3664, 3665], leaf: 3663 }, + Case { id: "bettertls::nameconstraints::tc910", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3667, 3668], leaf: 3666 }, + Case { id: "bettertls::nameconstraints::tc911", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3670, 3671], leaf: 3669 }, + Case { id: "bettertls::nameconstraints::tc912", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3673, 3674], leaf: 3672 }, + Case { id: "bettertls::nameconstraints::tc913", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3676, 3677], leaf: 3675 }, + Case { id: "bettertls::nameconstraints::tc914", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3679, 3680], leaf: 3678 }, + Case { id: "bettertls::nameconstraints::tc915", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3682, 3683], leaf: 3681 }, + Case { id: "bettertls::nameconstraints::tc916", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3685, 3686], leaf: 3684 }, + Case { id: "bettertls::nameconstraints::tc917", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3688, 3689], leaf: 3687 }, + Case { id: "bettertls::nameconstraints::tc918", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3691, 3692], leaf: 3690 }, + Case { id: "bettertls::nameconstraints::tc919", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3694, 3695], leaf: 3693 }, + Case { id: "bettertls::nameconstraints::tc920", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3697, 3698], leaf: 3696 }, + Case { id: "bettertls::nameconstraints::tc921", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3700, 3701], leaf: 3699 }, + Case { id: "bettertls::nameconstraints::tc922", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3703, 3704], leaf: 3702 }, + Case { id: "bettertls::nameconstraints::tc923", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3706, 3707], leaf: 3705 }, + Case { id: "bettertls::nameconstraints::tc924", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3709, 3710], leaf: 3708 }, + Case { id: "bettertls::nameconstraints::tc925", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3712, 3713], leaf: 3711 }, + Case { id: "bettertls::nameconstraints::tc926", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3715, 3716], leaf: 3714 }, + Case { id: "bettertls::nameconstraints::tc927", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3718, 3719], leaf: 3717 }, + Case { id: "bettertls::nameconstraints::tc928", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3721, 3722], leaf: 3720 }, + Case { id: "bettertls::nameconstraints::tc929", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3724, 3725], leaf: 3723 }, + Case { id: "bettertls::nameconstraints::tc930", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3727, 3728], leaf: 3726 }, + Case { id: "bettertls::nameconstraints::tc931", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3730, 3731], leaf: 3729 }, + Case { id: "bettertls::nameconstraints::tc932", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3733, 3734], leaf: 3732 }, + Case { id: "bettertls::nameconstraints::tc933", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3736, 3737], leaf: 3735 }, + Case { id: "bettertls::nameconstraints::tc934", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3739, 3740], leaf: 3738 }, + Case { id: "bettertls::nameconstraints::tc935", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3742, 3743], leaf: 3741 }, + Case { id: "bettertls::nameconstraints::tc936", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3745, 3746], leaf: 3744 }, + Case { id: "bettertls::nameconstraints::tc937", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3748, 3749], leaf: 3747 }, + Case { id: "bettertls::nameconstraints::tc938", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3751, 3752], leaf: 3750 }, + Case { id: "bettertls::nameconstraints::tc939", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3754, 3755], leaf: 3753 }, + Case { id: "bettertls::nameconstraints::tc940", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3757, 3758], leaf: 3756 }, + Case { id: "bettertls::nameconstraints::tc941", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3760, 3761], leaf: 3759 }, + Case { id: "bettertls::nameconstraints::tc942", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3763, 3764], leaf: 3762 }, + Case { id: "bettertls::nameconstraints::tc943", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3766, 3767], leaf: 3765 }, + Case { id: "bettertls::nameconstraints::tc944", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3769, 3770], leaf: 3768 }, + Case { id: "bettertls::nameconstraints::tc945", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3772, 3773], leaf: 3771 }, + Case { id: "bettertls::nameconstraints::tc946", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3775, 3776], leaf: 3774 }, + Case { id: "bettertls::nameconstraints::tc947", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3778, 3779], leaf: 3777 }, + Case { id: "bettertls::nameconstraints::tc948", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3781, 3782], leaf: 3780 }, + Case { id: "bettertls::nameconstraints::tc949", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3784, 3785], leaf: 3783 }, + Case { id: "bettertls::nameconstraints::tc950", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3787, 3788], leaf: 3786 }, + Case { id: "bettertls::nameconstraints::tc951", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3790, 3791], leaf: 3789 }, + Case { id: "bettertls::nameconstraints::tc952", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3793, 3794], leaf: 3792 }, + Case { id: "bettertls::nameconstraints::tc953", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3796, 3797], leaf: 3795 }, + Case { id: "bettertls::nameconstraints::tc954", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3799, 3800], leaf: 3798 }, + Case { id: "bettertls::nameconstraints::tc955", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3802, 3803], leaf: 3801 }, + Case { id: "bettertls::nameconstraints::tc956", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3805, 3806], leaf: 3804 }, + Case { id: "bettertls::nameconstraints::tc957", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3808, 3809], leaf: 3807 }, + Case { id: "bettertls::nameconstraints::tc958", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3811, 3812], leaf: 3810 }, + Case { id: "bettertls::nameconstraints::tc959", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3814, 3815], leaf: 3813 }, + Case { id: "bettertls::nameconstraints::tc960", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3817, 3818], leaf: 3816 }, + Case { id: "bettertls::nameconstraints::tc961", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3820, 3821], leaf: 3819 }, + Case { id: "bettertls::nameconstraints::tc962", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3823, 3824], leaf: 3822 }, + Case { id: "bettertls::nameconstraints::tc963", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3826, 3827], leaf: 3825 }, + Case { id: "bettertls::nameconstraints::tc964", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3829, 3830], leaf: 3828 }, + Case { id: "bettertls::nameconstraints::tc965", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3832, 3833], leaf: 3831 }, + Case { id: "bettertls::nameconstraints::tc966", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3835, 3836], leaf: 3834 }, + Case { id: "bettertls::nameconstraints::tc967", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3838, 3839], leaf: 3837 }, + Case { id: "bettertls::nameconstraints::tc968", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3841, 3842], leaf: 3840 }, + Case { id: "bettertls::nameconstraints::tc969", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3844, 3845], leaf: 3843 }, + Case { id: "bettertls::nameconstraints::tc970", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3847, 3848], leaf: 3846 }, + Case { id: "bettertls::nameconstraints::tc971", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3850, 3851], leaf: 3849 }, + Case { id: "bettertls::nameconstraints::tc972", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3853, 3854], leaf: 3852 }, + Case { id: "bettertls::nameconstraints::tc973", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3856, 3857], leaf: 3855 }, + Case { id: "bettertls::nameconstraints::tc974", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3859, 3860], leaf: 3858 }, + Case { id: "bettertls::nameconstraints::tc975", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3862, 3863], leaf: 3861 }, + Case { id: "bettertls::nameconstraints::tc976", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3865, 3866], leaf: 3864 }, + Case { id: "bettertls::nameconstraints::tc977", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3868, 3869], leaf: 3867 }, + Case { id: "bettertls::nameconstraints::tc978", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3871, 3872], leaf: 3870 }, + Case { id: "bettertls::nameconstraints::tc979", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3874, 3875], leaf: 3873 }, + Case { id: "bettertls::nameconstraints::tc980", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3877, 3878], leaf: 3876 }, + Case { id: "bettertls::nameconstraints::tc981", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3880, 3881], leaf: 3879 }, + Case { id: "bettertls::nameconstraints::tc982", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3883, 3884], leaf: 3882 }, + Case { id: "bettertls::nameconstraints::tc983", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3886, 3887], leaf: 3885 }, + Case { id: "bettertls::nameconstraints::tc984", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3889, 3890], leaf: 3888 }, + Case { id: "bettertls::nameconstraints::tc985", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3892, 3893], leaf: 3891 }, + Case { id: "bettertls::nameconstraints::tc986", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3895, 3896], leaf: 3894 }, + Case { id: "bettertls::nameconstraints::tc987", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3898, 3899], leaf: 3897 }, + Case { id: "bettertls::nameconstraints::tc988", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3901, 3902], leaf: 3900 }, + Case { id: "bettertls::nameconstraints::tc989", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3904, 3905], leaf: 3903 }, + Case { id: "bettertls::nameconstraints::tc990", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3907, 3908], leaf: 3906 }, + Case { id: "bettertls::nameconstraints::tc991", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3910, 3911], leaf: 3909 }, + Case { id: "bettertls::nameconstraints::tc992", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3913, 3914], leaf: 3912 }, + Case { id: "bettertls::nameconstraints::tc993", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3916, 3917], leaf: 3915 }, + Case { id: "bettertls::nameconstraints::tc994", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3919, 3920], leaf: 3918 }, + Case { id: "bettertls::nameconstraints::tc995", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3922, 3923], leaf: 3921 }, + Case { id: "bettertls::nameconstraints::tc996", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3925, 3926], leaf: 3924 }, + Case { id: "bettertls::nameconstraints::tc997", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3928, 3929], leaf: 3927 }, + Case { id: "bettertls::nameconstraints::tc998", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3931, 3932], leaf: 3930 }, + Case { id: "bettertls::nameconstraints::tc999", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3934, 3935], leaf: 3933 }, + Case { id: "bettertls::nameconstraints::tc1000", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3937, 3938], leaf: 3936 }, + Case { id: "bettertls::nameconstraints::tc1001", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3940, 3941], leaf: 3939 }, + Case { id: "bettertls::nameconstraints::tc1002", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3943, 3944], leaf: 3942 }, + Case { id: "bettertls::nameconstraints::tc1003", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3946, 3947], leaf: 3945 }, + Case { id: "bettertls::nameconstraints::tc1004", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3949, 3950], leaf: 3948 }, + Case { id: "bettertls::nameconstraints::tc1005", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3952, 3953], leaf: 3951 }, + Case { id: "bettertls::nameconstraints::tc1006", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3955, 3956], leaf: 3954 }, + Case { id: "bettertls::nameconstraints::tc1007", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3958, 3959], leaf: 3957 }, + Case { id: "bettertls::nameconstraints::tc1008", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3961, 3962], leaf: 3960 }, + Case { id: "bettertls::nameconstraints::tc1009", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3964, 3965], leaf: 3963 }, + Case { id: "bettertls::nameconstraints::tc1010", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3967, 3968], leaf: 3966 }, + Case { id: "bettertls::nameconstraints::tc1011", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3970, 3971], leaf: 3969 }, + Case { id: "bettertls::nameconstraints::tc1012", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3973, 3974], leaf: 3972 }, + Case { id: "bettertls::nameconstraints::tc1013", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3976, 3977], leaf: 3975 }, + Case { id: "bettertls::nameconstraints::tc1014", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3979, 3980], leaf: 3978 }, + Case { id: "bettertls::nameconstraints::tc1015", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3982, 3983], leaf: 3981 }, + Case { id: "bettertls::nameconstraints::tc1016", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3985, 3986], leaf: 3984 }, + Case { id: "bettertls::nameconstraints::tc1017", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3988, 3989], leaf: 3987 }, + Case { id: "bettertls::nameconstraints::tc1018", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3991, 3992], leaf: 3990 }, + Case { id: "bettertls::nameconstraints::tc1019", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3994, 3995], leaf: 3993 }, + Case { id: "bettertls::nameconstraints::tc1020", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[3997, 3998], leaf: 3996 }, + Case { id: "bettertls::nameconstraints::tc1021", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4000, 4001], leaf: 3999 }, + Case { id: "bettertls::nameconstraints::tc1022", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4003, 4004], leaf: 4002 }, + Case { id: "bettertls::nameconstraints::tc1023", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4006, 4007], leaf: 4005 }, + Case { id: "bettertls::nameconstraints::tc1024", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4009, 4010], leaf: 4008 }, + Case { id: "bettertls::nameconstraints::tc1025", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4012, 4013], leaf: 4011 }, + Case { id: "bettertls::nameconstraints::tc1026", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4015, 4016], leaf: 4014 }, + Case { id: "bettertls::nameconstraints::tc1027", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4018, 4019], leaf: 4017 }, + Case { id: "bettertls::nameconstraints::tc1028", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4021, 4022], leaf: 4020 }, + Case { id: "bettertls::nameconstraints::tc1029", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4024, 4025], leaf: 4023 }, + Case { id: "bettertls::nameconstraints::tc1030", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4027, 4028], leaf: 4026 }, + Case { id: "bettertls::nameconstraints::tc1031", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4030, 4031], leaf: 4029 }, + Case { id: "bettertls::nameconstraints::tc1032", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4033, 4034], leaf: 4032 }, + Case { id: "bettertls::nameconstraints::tc1033", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4036, 4037], leaf: 4035 }, + Case { id: "bettertls::nameconstraints::tc1034", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4039, 4040], leaf: 4038 }, + Case { id: "bettertls::nameconstraints::tc1035", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4042, 4043], leaf: 4041 }, + Case { id: "bettertls::nameconstraints::tc1036", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4045, 4046], leaf: 4044 }, + Case { id: "bettertls::nameconstraints::tc1037", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4048, 4049], leaf: 4047 }, + Case { id: "bettertls::nameconstraints::tc1038", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4051, 4052], leaf: 4050 }, + Case { id: "bettertls::nameconstraints::tc1039", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4054, 4055], leaf: 4053 }, + Case { id: "bettertls::nameconstraints::tc1040", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4057, 4058], leaf: 4056 }, + Case { id: "bettertls::nameconstraints::tc1041", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4060, 4061], leaf: 4059 }, + Case { id: "bettertls::nameconstraints::tc1042", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4063, 4064], leaf: 4062 }, + Case { id: "bettertls::nameconstraints::tc1043", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4066, 4067], leaf: 4065 }, + Case { id: "bettertls::nameconstraints::tc1044", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4069, 4070], leaf: 4068 }, + Case { id: "bettertls::nameconstraints::tc1045", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4072, 4073], leaf: 4071 }, + Case { id: "bettertls::nameconstraints::tc1046", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4075, 4076], leaf: 4074 }, + Case { id: "bettertls::nameconstraints::tc1047", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4078, 4079], leaf: 4077 }, + Case { id: "bettertls::nameconstraints::tc1048", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4081, 4082], leaf: 4080 }, + Case { id: "bettertls::nameconstraints::tc1049", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4084, 4085], leaf: 4083 }, + Case { id: "bettertls::nameconstraints::tc1050", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4087, 4088], leaf: 4086 }, + Case { id: "bettertls::nameconstraints::tc1051", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4090, 4091], leaf: 4089 }, + Case { id: "bettertls::nameconstraints::tc1052", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4093, 4094], leaf: 4092 }, + Case { id: "bettertls::nameconstraints::tc1053", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4096, 4097], leaf: 4095 }, + Case { id: "bettertls::nameconstraints::tc1054", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4099, 4100], leaf: 4098 }, + Case { id: "bettertls::nameconstraints::tc1055", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4102, 4103], leaf: 4101 }, + Case { id: "bettertls::nameconstraints::tc1056", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4105, 4106], leaf: 4104 }, + Case { id: "bettertls::nameconstraints::tc1057", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4108, 4109], leaf: 4107 }, + Case { id: "bettertls::nameconstraints::tc1058", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4111, 4112], leaf: 4110 }, + Case { id: "bettertls::nameconstraints::tc1059", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4114, 4115], leaf: 4113 }, + Case { id: "bettertls::nameconstraints::tc1060", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4117, 4118], leaf: 4116 }, + Case { id: "bettertls::nameconstraints::tc1061", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4120, 4121], leaf: 4119 }, + Case { id: "bettertls::nameconstraints::tc1062", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4123, 4124], leaf: 4122 }, + Case { id: "bettertls::nameconstraints::tc1063", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4126, 4127], leaf: 4125 }, + Case { id: "bettertls::nameconstraints::tc1064", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4129, 4130], leaf: 4128 }, + Case { id: "bettertls::nameconstraints::tc1065", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4132, 4133], leaf: 4131 }, + Case { id: "bettertls::nameconstraints::tc1066", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4135, 4136], leaf: 4134 }, + Case { id: "bettertls::nameconstraints::tc1067", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4138, 4139], leaf: 4137 }, + Case { id: "bettertls::nameconstraints::tc1068", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4141, 4142], leaf: 4140 }, + Case { id: "bettertls::nameconstraints::tc1069", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4144, 4145], leaf: 4143 }, + Case { id: "bettertls::nameconstraints::tc1070", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4147, 4148], leaf: 4146 }, + Case { id: "bettertls::nameconstraints::tc1071", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4150, 4151], leaf: 4149 }, + Case { id: "bettertls::nameconstraints::tc1072", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4153, 4154], leaf: 4152 }, + Case { id: "bettertls::nameconstraints::tc1073", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4156, 4157], leaf: 4155 }, + Case { id: "bettertls::nameconstraints::tc1074", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4159, 4160], leaf: 4158 }, + Case { id: "bettertls::nameconstraints::tc1075", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4162, 4163], leaf: 4161 }, + Case { id: "bettertls::nameconstraints::tc1076", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4165, 4166], leaf: 4164 }, + Case { id: "bettertls::nameconstraints::tc1077", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4168, 4169], leaf: 4167 }, + Case { id: "bettertls::nameconstraints::tc1078", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4171, 4172], leaf: 4170 }, + Case { id: "bettertls::nameconstraints::tc1079", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4174, 4175], leaf: 4173 }, + Case { id: "bettertls::nameconstraints::tc1080", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4177, 4178], leaf: 4176 }, + Case { id: "bettertls::nameconstraints::tc1081", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4180, 4181], leaf: 4179 }, + Case { id: "bettertls::nameconstraints::tc1082", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4183, 4184], leaf: 4182 }, + Case { id: "bettertls::nameconstraints::tc1083", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4186, 4187], leaf: 4185 }, + Case { id: "bettertls::nameconstraints::tc1084", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4189, 4190], leaf: 4188 }, + Case { id: "bettertls::nameconstraints::tc1085", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4192, 4193], leaf: 4191 }, + Case { id: "bettertls::nameconstraints::tc1086", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4195, 4196], leaf: 4194 }, + Case { id: "bettertls::nameconstraints::tc1087", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4198, 4199], leaf: 4197 }, + Case { id: "bettertls::nameconstraints::tc1088", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4201, 4202], leaf: 4200 }, + Case { id: "bettertls::nameconstraints::tc1089", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4204, 4205], leaf: 4203 }, + Case { id: "bettertls::nameconstraints::tc1090", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4207, 4208], leaf: 4206 }, + Case { id: "bettertls::nameconstraints::tc1091", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4210, 4211], leaf: 4209 }, + Case { id: "bettertls::nameconstraints::tc1092", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4213, 4214], leaf: 4212 }, + Case { id: "bettertls::nameconstraints::tc1093", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4216, 4217], leaf: 4215 }, + Case { id: "bettertls::nameconstraints::tc1094", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4219, 4220], leaf: 4218 }, + Case { id: "bettertls::nameconstraints::tc1095", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4222, 4223], leaf: 4221 }, + Case { id: "bettertls::nameconstraints::tc1096", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4225, 4226], leaf: 4224 }, + Case { id: "bettertls::nameconstraints::tc1097", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4228, 4229], leaf: 4227 }, + Case { id: "bettertls::nameconstraints::tc1098", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4231, 4232], leaf: 4230 }, + Case { id: "bettertls::nameconstraints::tc1099", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4234, 4235], leaf: 4233 }, + Case { id: "bettertls::nameconstraints::tc1100", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4237, 4238], leaf: 4236 }, + Case { id: "bettertls::nameconstraints::tc1101", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4240, 4241], leaf: 4239 }, + Case { id: "bettertls::nameconstraints::tc1102", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4243, 4244], leaf: 4242 }, + Case { id: "bettertls::nameconstraints::tc1103", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4246, 4247], leaf: 4245 }, + Case { id: "bettertls::nameconstraints::tc1104", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4249, 4250], leaf: 4248 }, + Case { id: "bettertls::nameconstraints::tc1105", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4252, 4253], leaf: 4251 }, + Case { id: "bettertls::nameconstraints::tc1106", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4255, 4256], leaf: 4254 }, + Case { id: "bettertls::nameconstraints::tc1107", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4258, 4259], leaf: 4257 }, + Case { id: "bettertls::nameconstraints::tc1108", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4261, 4262], leaf: 4260 }, + Case { id: "bettertls::nameconstraints::tc1109", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4264, 4265], leaf: 4263 }, + Case { id: "bettertls::nameconstraints::tc1110", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4267, 4268], leaf: 4266 }, + Case { id: "bettertls::nameconstraints::tc1111", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4270, 4271], leaf: 4269 }, + Case { id: "bettertls::nameconstraints::tc1112", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4273, 4274], leaf: 4272 }, + Case { id: "bettertls::nameconstraints::tc1113", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4276, 4277], leaf: 4275 }, + Case { id: "bettertls::nameconstraints::tc1114", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4279, 4280], leaf: 4278 }, + Case { id: "bettertls::nameconstraints::tc1115", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4282, 4283], leaf: 4281 }, + Case { id: "bettertls::nameconstraints::tc1116", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4285, 4286], leaf: 4284 }, + Case { id: "bettertls::nameconstraints::tc1117", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4288, 4289], leaf: 4287 }, + Case { id: "bettertls::nameconstraints::tc1118", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4291, 4292], leaf: 4290 }, + Case { id: "bettertls::nameconstraints::tc1119", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4294, 4295], leaf: 4293 }, + Case { id: "bettertls::nameconstraints::tc1120", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4297, 4298], leaf: 4296 }, + Case { id: "bettertls::nameconstraints::tc1121", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4300, 4301], leaf: 4299 }, + Case { id: "bettertls::nameconstraints::tc1122", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4303, 4304], leaf: 4302 }, + Case { id: "bettertls::nameconstraints::tc1123", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4306, 4307], leaf: 4305 }, + Case { id: "bettertls::nameconstraints::tc1124", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4309, 4310], leaf: 4308 }, + Case { id: "bettertls::nameconstraints::tc1125", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4312, 4313], leaf: 4311 }, + Case { id: "bettertls::nameconstraints::tc1126", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4315, 4316], leaf: 4314 }, + Case { id: "bettertls::nameconstraints::tc1127", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4318, 4319], leaf: 4317 }, + Case { id: "bettertls::nameconstraints::tc1128", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4321, 4322], leaf: 4320 }, + Case { id: "bettertls::nameconstraints::tc1129", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4324, 4325], leaf: 4323 }, + Case { id: "bettertls::nameconstraints::tc1130", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4327, 4328], leaf: 4326 }, + Case { id: "bettertls::nameconstraints::tc1131", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4330, 4331], leaf: 4329 }, + Case { id: "bettertls::nameconstraints::tc1132", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4333, 4334], leaf: 4332 }, + Case { id: "bettertls::nameconstraints::tc1133", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4336, 4337], leaf: 4335 }, + Case { id: "bettertls::nameconstraints::tc1134", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4339, 4340], leaf: 4338 }, + Case { id: "bettertls::nameconstraints::tc1135", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4342, 4343], leaf: 4341 }, + Case { id: "bettertls::nameconstraints::tc1136", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4345, 4346], leaf: 4344 }, + Case { id: "bettertls::nameconstraints::tc1137", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4348, 4349], leaf: 4347 }, + Case { id: "bettertls::nameconstraints::tc1138", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4351, 4352], leaf: 4350 }, + Case { id: "bettertls::nameconstraints::tc1139", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4354, 4355], leaf: 4353 }, + Case { id: "bettertls::nameconstraints::tc1140", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4357, 4358], leaf: 4356 }, + Case { id: "bettertls::nameconstraints::tc1141", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4360, 4361], leaf: 4359 }, + Case { id: "bettertls::nameconstraints::tc1142", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4363, 4364], leaf: 4362 }, + Case { id: "bettertls::nameconstraints::tc1143", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4366, 4367], leaf: 4365 }, + Case { id: "bettertls::nameconstraints::tc1144", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4369, 4370], leaf: 4368 }, + Case { id: "bettertls::nameconstraints::tc1145", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4372, 4373], leaf: 4371 }, + Case { id: "bettertls::nameconstraints::tc1146", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4375, 4376], leaf: 4374 }, + Case { id: "bettertls::nameconstraints::tc1147", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4378, 4379], leaf: 4377 }, + Case { id: "bettertls::nameconstraints::tc1148", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4381, 4382], leaf: 4380 }, + Case { id: "bettertls::nameconstraints::tc1149", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4384, 4385], leaf: 4383 }, + Case { id: "bettertls::nameconstraints::tc1150", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4387, 4388], leaf: 4386 }, + Case { id: "bettertls::nameconstraints::tc1151", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4390, 4391], leaf: 4389 }, + Case { id: "bettertls::nameconstraints::tc1152", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4393, 4394], leaf: 4392 }, + Case { id: "bettertls::nameconstraints::tc1153", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4396, 4397], leaf: 4395 }, + Case { id: "bettertls::nameconstraints::tc1154", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4399, 4400], leaf: 4398 }, + Case { id: "bettertls::nameconstraints::tc1155", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4402, 4403], leaf: 4401 }, + Case { id: "bettertls::nameconstraints::tc1156", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4405, 4406], leaf: 4404 }, + Case { id: "bettertls::nameconstraints::tc1157", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4408, 4409], leaf: 4407 }, + Case { id: "bettertls::nameconstraints::tc1158", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4411, 4412], leaf: 4410 }, + Case { id: "bettertls::nameconstraints::tc1159", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4414, 4415], leaf: 4413 }, + Case { id: "bettertls::nameconstraints::tc1160", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4417, 4418], leaf: 4416 }, + Case { id: "bettertls::nameconstraints::tc1161", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4420, 4421], leaf: 4419 }, + Case { id: "bettertls::nameconstraints::tc1162", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4423, 4424], leaf: 4422 }, + Case { id: "bettertls::nameconstraints::tc1163", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4426, 4427], leaf: 4425 }, + Case { id: "bettertls::nameconstraints::tc1164", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4429, 4430], leaf: 4428 }, + Case { id: "bettertls::nameconstraints::tc1165", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4432, 4433], leaf: 4431 }, + Case { id: "bettertls::nameconstraints::tc1166", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4435, 4436], leaf: 4434 }, + Case { id: "bettertls::nameconstraints::tc1167", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4438, 4439], leaf: 4437 }, + Case { id: "bettertls::nameconstraints::tc1168", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4441, 4442], leaf: 4440 }, + Case { id: "bettertls::nameconstraints::tc1169", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4444, 4445], leaf: 4443 }, + Case { id: "bettertls::nameconstraints::tc1170", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4447, 4448], leaf: 4446 }, + Case { id: "bettertls::nameconstraints::tc1171", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4450, 4451], leaf: 4449 }, + Case { id: "bettertls::nameconstraints::tc1172", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4453, 4454], leaf: 4452 }, + Case { id: "bettertls::nameconstraints::tc1173", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4456, 4457], leaf: 4455 }, + Case { id: "bettertls::nameconstraints::tc1174", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4459, 4460], leaf: 4458 }, + Case { id: "bettertls::nameconstraints::tc1175", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4462, 4463], leaf: 4461 }, + Case { id: "bettertls::nameconstraints::tc1176", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4465, 4466], leaf: 4464 }, + Case { id: "bettertls::nameconstraints::tc1177", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4468, 4469], leaf: 4467 }, + Case { id: "bettertls::nameconstraints::tc1178", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4471, 4472], leaf: 4470 }, + Case { id: "bettertls::nameconstraints::tc1179", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4474, 4475], leaf: 4473 }, + Case { id: "bettertls::nameconstraints::tc1180", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4477, 4478], leaf: 4476 }, + Case { id: "bettertls::nameconstraints::tc1181", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4480, 4481], leaf: 4479 }, + Case { id: "bettertls::nameconstraints::tc1182", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4483, 4484], leaf: 4482 }, + Case { id: "bettertls::nameconstraints::tc1183", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4486, 4487], leaf: 4485 }, + Case { id: "bettertls::nameconstraints::tc1184", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4489, 4490], leaf: 4488 }, + Case { id: "bettertls::nameconstraints::tc1185", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4492, 4493], leaf: 4491 }, + Case { id: "bettertls::nameconstraints::tc1186", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4495, 4496], leaf: 4494 }, + Case { id: "bettertls::nameconstraints::tc1187", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4498, 4499], leaf: 4497 }, + Case { id: "bettertls::nameconstraints::tc1188", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4501, 4502], leaf: 4500 }, + Case { id: "bettertls::nameconstraints::tc1189", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4504, 4505], leaf: 4503 }, + Case { id: "bettertls::nameconstraints::tc1190", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4507, 4508], leaf: 4506 }, + Case { id: "bettertls::nameconstraints::tc1191", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4510, 4511], leaf: 4509 }, + Case { id: "bettertls::nameconstraints::tc1192", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4513, 4514], leaf: 4512 }, + Case { id: "bettertls::nameconstraints::tc1193", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4516, 4517], leaf: 4515 }, + Case { id: "bettertls::nameconstraints::tc1194", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4519, 4520], leaf: 4518 }, + Case { id: "bettertls::nameconstraints::tc1195", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4522, 4523], leaf: 4521 }, + Case { id: "bettertls::nameconstraints::tc1196", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4525, 4526], leaf: 4524 }, + Case { id: "bettertls::nameconstraints::tc1197", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4528, 4529], leaf: 4527 }, + Case { id: "bettertls::nameconstraints::tc1198", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4531, 4532], leaf: 4530 }, + Case { id: "bettertls::nameconstraints::tc1199", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4534, 4535], leaf: 4533 }, + Case { id: "bettertls::nameconstraints::tc1200", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4537, 4538], leaf: 4536 }, + Case { id: "bettertls::nameconstraints::tc1201", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4540, 4541], leaf: 4539 }, + Case { id: "bettertls::nameconstraints::tc1202", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4543, 4544], leaf: 4542 }, + Case { id: "bettertls::nameconstraints::tc1203", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4546, 4547], leaf: 4545 }, + Case { id: "bettertls::nameconstraints::tc1204", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4549, 4550], leaf: 4548 }, + Case { id: "bettertls::nameconstraints::tc1205", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4552, 4553], leaf: 4551 }, + Case { id: "bettertls::nameconstraints::tc1206", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4555, 4556], leaf: 4554 }, + Case { id: "bettertls::nameconstraints::tc1207", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4558, 4559], leaf: 4557 }, + Case { id: "bettertls::nameconstraints::tc1208", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4561, 4562], leaf: 4560 }, + Case { id: "bettertls::nameconstraints::tc1209", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4564, 4565], leaf: 4563 }, + Case { id: "bettertls::nameconstraints::tc1210", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4567, 4568], leaf: 4566 }, + Case { id: "bettertls::nameconstraints::tc1211", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4570, 4571], leaf: 4569 }, + Case { id: "bettertls::nameconstraints::tc1212", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4573, 4574], leaf: 4572 }, + Case { id: "bettertls::nameconstraints::tc1213", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4576, 4577], leaf: 4575 }, + Case { id: "bettertls::nameconstraints::tc1214", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4579, 4580], leaf: 4578 }, + Case { id: "bettertls::nameconstraints::tc1215", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4582, 4583], leaf: 4581 }, + Case { id: "bettertls::nameconstraints::tc1216", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4585, 4586], leaf: 4584 }, + Case { id: "bettertls::nameconstraints::tc1217", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4588, 4589], leaf: 4587 }, + Case { id: "bettertls::nameconstraints::tc1218", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4591, 4592], leaf: 4590 }, + Case { id: "bettertls::nameconstraints::tc1219", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4594, 4595], leaf: 4593 }, + Case { id: "bettertls::nameconstraints::tc1220", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4597, 4598], leaf: 4596 }, + Case { id: "bettertls::nameconstraints::tc1221", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4600, 4601], leaf: 4599 }, + Case { id: "bettertls::nameconstraints::tc1222", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4603, 4604], leaf: 4602 }, + Case { id: "bettertls::nameconstraints::tc1223", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4606, 4607], leaf: 4605 }, + Case { id: "bettertls::nameconstraints::tc1224", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4609, 4610], leaf: 4608 }, + Case { id: "bettertls::nameconstraints::tc1225", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4612, 4613], leaf: 4611 }, + Case { id: "bettertls::nameconstraints::tc1226", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4615, 4616], leaf: 4614 }, + Case { id: "bettertls::nameconstraints::tc1227", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4618, 4619], leaf: 4617 }, + Case { id: "bettertls::nameconstraints::tc1228", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4621, 4622], leaf: 4620 }, + Case { id: "bettertls::nameconstraints::tc1229", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4624, 4625], leaf: 4623 }, + Case { id: "bettertls::nameconstraints::tc1230", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4627, 4628], leaf: 4626 }, + Case { id: "bettertls::nameconstraints::tc1231", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4630, 4631], leaf: 4629 }, + Case { id: "bettertls::nameconstraints::tc1232", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4633, 4634], leaf: 4632 }, + Case { id: "bettertls::nameconstraints::tc1233", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4636, 4637], leaf: 4635 }, + Case { id: "bettertls::nameconstraints::tc1234", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4639, 4640], leaf: 4638 }, + Case { id: "bettertls::nameconstraints::tc1235", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4642, 4643], leaf: 4641 }, + Case { id: "bettertls::nameconstraints::tc1236", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4645, 4646], leaf: 4644 }, + Case { id: "bettertls::nameconstraints::tc1237", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4648, 4649], leaf: 4647 }, + Case { id: "bettertls::nameconstraints::tc1238", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4651, 4652], leaf: 4650 }, + Case { id: "bettertls::nameconstraints::tc1239", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4654, 4655], leaf: 4653 }, + Case { id: "bettertls::nameconstraints::tc1240", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4657, 4658], leaf: 4656 }, + Case { id: "bettertls::nameconstraints::tc1241", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4660, 4661], leaf: 4659 }, + Case { id: "bettertls::nameconstraints::tc1242", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4663, 4664], leaf: 4662 }, + Case { id: "bettertls::nameconstraints::tc1243", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4666, 4667], leaf: 4665 }, + Case { id: "bettertls::nameconstraints::tc1244", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4669, 4670], leaf: 4668 }, + Case { id: "bettertls::nameconstraints::tc1245", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4672, 4673], leaf: 4671 }, + Case { id: "bettertls::nameconstraints::tc1246", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4675, 4676], leaf: 4674 }, + Case { id: "bettertls::nameconstraints::tc1247", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4678, 4679], leaf: 4677 }, + Case { id: "bettertls::nameconstraints::tc1248", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4681, 4682], leaf: 4680 }, + Case { id: "bettertls::nameconstraints::tc1249", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4684, 4685], leaf: 4683 }, + Case { id: "bettertls::nameconstraints::tc1250", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4687, 4688], leaf: 4686 }, + Case { id: "bettertls::nameconstraints::tc1251", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4690, 4691], leaf: 4689 }, + Case { id: "bettertls::nameconstraints::tc1252", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4693, 4694], leaf: 4692 }, + Case { id: "bettertls::nameconstraints::tc1253", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4696, 4697], leaf: 4695 }, + Case { id: "bettertls::nameconstraints::tc1254", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4699, 4700], leaf: 4698 }, + Case { id: "bettertls::nameconstraints::tc1255", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4702, 4703], leaf: 4701 }, + Case { id: "bettertls::nameconstraints::tc1256", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4705, 4706], leaf: 4704 }, + Case { id: "bettertls::nameconstraints::tc1257", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4708, 4709], leaf: 4707 }, + Case { id: "bettertls::nameconstraints::tc1258", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4711, 4712], leaf: 4710 }, + Case { id: "bettertls::nameconstraints::tc1259", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4714, 4715], leaf: 4713 }, + Case { id: "bettertls::nameconstraints::tc1260", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4717, 4718], leaf: 4716 }, + Case { id: "bettertls::nameconstraints::tc1261", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4720, 4721], leaf: 4719 }, + Case { id: "bettertls::nameconstraints::tc1262", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4723, 4724], leaf: 4722 }, + Case { id: "bettertls::nameconstraints::tc1263", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4726, 4727], leaf: 4725 }, + Case { id: "bettertls::nameconstraints::tc1264", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4729, 4730], leaf: 4728 }, + Case { id: "bettertls::nameconstraints::tc1265", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4732, 4733], leaf: 4731 }, + Case { id: "bettertls::nameconstraints::tc1266", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4735, 4736], leaf: 4734 }, + Case { id: "bettertls::nameconstraints::tc1267", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4738, 4739], leaf: 4737 }, + Case { id: "bettertls::nameconstraints::tc1268", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4741, 4742], leaf: 4740 }, + Case { id: "bettertls::nameconstraints::tc1269", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4744, 4745], leaf: 4743 }, + Case { id: "bettertls::nameconstraints::tc1270", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4747, 4748], leaf: 4746 }, + Case { id: "bettertls::nameconstraints::tc1271", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4750, 4751], leaf: 4749 }, + Case { id: "bettertls::nameconstraints::tc1272", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4753, 4754], leaf: 4752 }, + Case { id: "bettertls::nameconstraints::tc1273", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4756, 4757], leaf: 4755 }, + Case { id: "bettertls::nameconstraints::tc1274", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4759, 4760], leaf: 4758 }, + Case { id: "bettertls::nameconstraints::tc1275", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4762, 4763], leaf: 4761 }, + Case { id: "bettertls::nameconstraints::tc1276", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4765, 4766], leaf: 4764 }, + Case { id: "bettertls::nameconstraints::tc1277", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4768, 4769], leaf: 4767 }, + Case { id: "bettertls::nameconstraints::tc1278", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4771, 4772], leaf: 4770 }, + Case { id: "bettertls::nameconstraints::tc1279", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4774, 4775], leaf: 4773 }, + Case { id: "bettertls::nameconstraints::tc1280", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4777, 4778], leaf: 4776 }, + Case { id: "bettertls::nameconstraints::tc1281", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4780, 4781], leaf: 4779 }, + Case { id: "bettertls::nameconstraints::tc1282", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4783, 4784], leaf: 4782 }, + Case { id: "bettertls::nameconstraints::tc1283", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4786, 4787], leaf: 4785 }, + Case { id: "bettertls::nameconstraints::tc1284", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4789, 4790], leaf: 4788 }, + Case { id: "bettertls::nameconstraints::tc1285", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4792, 4793], leaf: 4791 }, + Case { id: "bettertls::nameconstraints::tc1286", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4795, 4796], leaf: 4794 }, + Case { id: "bettertls::nameconstraints::tc1287", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4798, 4799], leaf: 4797 }, + Case { id: "bettertls::nameconstraints::tc1288", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4801, 4802], leaf: 4800 }, + Case { id: "bettertls::nameconstraints::tc1289", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4804, 4805], leaf: 4803 }, + Case { id: "bettertls::nameconstraints::tc1290", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4807, 4808], leaf: 4806 }, + Case { id: "bettertls::nameconstraints::tc1291", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4810, 4811], leaf: 4809 }, + Case { id: "bettertls::nameconstraints::tc1292", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4813, 4814], leaf: 4812 }, + Case { id: "bettertls::nameconstraints::tc1293", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4816, 4817], leaf: 4815 }, + Case { id: "bettertls::nameconstraints::tc1294", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4819, 4820], leaf: 4818 }, + Case { id: "bettertls::nameconstraints::tc1295", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4822, 4823], leaf: 4821 }, + Case { id: "bettertls::nameconstraints::tc1296", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4825, 4826], leaf: 4824 }, + Case { id: "bettertls::nameconstraints::tc1297", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4828, 4829], leaf: 4827 }, + Case { id: "bettertls::nameconstraints::tc1298", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4831, 4832], leaf: 4830 }, + Case { id: "bettertls::nameconstraints::tc1299", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4834, 4835], leaf: 4833 }, + Case { id: "bettertls::nameconstraints::tc1300", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4837, 4838], leaf: 4836 }, + Case { id: "bettertls::nameconstraints::tc1301", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4840, 4841], leaf: 4839 }, + Case { id: "bettertls::nameconstraints::tc1302", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4843, 4844], leaf: 4842 }, + Case { id: "bettertls::nameconstraints::tc1303", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4846, 4847], leaf: 4845 }, + Case { id: "bettertls::nameconstraints::tc1304", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4849, 4850], leaf: 4848 }, + Case { id: "bettertls::nameconstraints::tc1305", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4852, 4853], leaf: 4851 }, + Case { id: "bettertls::nameconstraints::tc1306", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4855, 4856], leaf: 4854 }, + Case { id: "bettertls::nameconstraints::tc1307", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4858, 4859], leaf: 4857 }, + Case { id: "bettertls::nameconstraints::tc1308", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4861, 4862], leaf: 4860 }, + Case { id: "bettertls::nameconstraints::tc1309", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4864, 4865], leaf: 4863 }, + Case { id: "bettertls::nameconstraints::tc1310", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4867, 4868], leaf: 4866 }, + Case { id: "bettertls::nameconstraints::tc1311", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4870, 4871], leaf: 4869 }, + Case { id: "bettertls::nameconstraints::tc1312", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4873, 4874], leaf: 4872 }, + Case { id: "bettertls::nameconstraints::tc1313", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4876, 4877], leaf: 4875 }, + Case { id: "bettertls::nameconstraints::tc1314", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4879, 4880], leaf: 4878 }, + Case { id: "bettertls::nameconstraints::tc1315", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4882, 4883], leaf: 4881 }, + Case { id: "bettertls::nameconstraints::tc1316", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4885, 4886], leaf: 4884 }, + Case { id: "bettertls::nameconstraints::tc1317", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4888, 4889], leaf: 4887 }, + Case { id: "bettertls::nameconstraints::tc1318", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4891, 4892], leaf: 4890 }, + Case { id: "bettertls::nameconstraints::tc1319", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4894, 4895], leaf: 4893 }, + Case { id: "bettertls::nameconstraints::tc1320", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4897, 4898], leaf: 4896 }, + Case { id: "bettertls::nameconstraints::tc1321", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4900, 4901], leaf: 4899 }, + Case { id: "bettertls::nameconstraints::tc1322", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4903, 4904], leaf: 4902 }, + Case { id: "bettertls::nameconstraints::tc1323", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4906, 4907], leaf: 4905 }, + Case { id: "bettertls::nameconstraints::tc1324", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4909, 4910], leaf: 4908 }, + Case { id: "bettertls::nameconstraints::tc1325", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4912, 4913], leaf: 4911 }, + Case { id: "bettertls::nameconstraints::tc1326", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4915, 4916], leaf: 4914 }, + Case { id: "bettertls::nameconstraints::tc1327", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4918, 4919], leaf: 4917 }, + Case { id: "bettertls::nameconstraints::tc1328", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4921, 4922], leaf: 4920 }, + Case { id: "bettertls::nameconstraints::tc1329", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4924, 4925], leaf: 4923 }, + Case { id: "bettertls::nameconstraints::tc1330", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4927, 4928], leaf: 4926 }, + Case { id: "bettertls::nameconstraints::tc1331", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4930, 4931], leaf: 4929 }, + Case { id: "bettertls::nameconstraints::tc1332", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4933, 4934], leaf: 4932 }, + Case { id: "bettertls::nameconstraints::tc1333", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4936, 4937], leaf: 4935 }, + Case { id: "bettertls::nameconstraints::tc1334", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4939, 4940], leaf: 4938 }, + Case { id: "bettertls::nameconstraints::tc1335", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4942, 4943], leaf: 4941 }, + Case { id: "bettertls::nameconstraints::tc1336", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4945, 4946], leaf: 4944 }, + Case { id: "bettertls::nameconstraints::tc1337", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4948, 4949], leaf: 4947 }, + Case { id: "bettertls::nameconstraints::tc1338", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4951, 4952], leaf: 4950 }, + Case { id: "bettertls::nameconstraints::tc1339", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4954, 4955], leaf: 4953 }, + Case { id: "bettertls::nameconstraints::tc1340", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4957, 4958], leaf: 4956 }, + Case { id: "bettertls::nameconstraints::tc1341", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4960, 4961], leaf: 4959 }, + Case { id: "bettertls::nameconstraints::tc1342", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4963, 4964], leaf: 4962 }, + Case { id: "bettertls::nameconstraints::tc1343", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4966, 4967], leaf: 4965 }, + Case { id: "bettertls::nameconstraints::tc1344", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4969, 4970], leaf: 4968 }, + Case { id: "bettertls::nameconstraints::tc1345", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4972, 4973], leaf: 4971 }, + Case { id: "bettertls::nameconstraints::tc1346", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4975, 4976], leaf: 4974 }, + Case { id: "bettertls::nameconstraints::tc1347", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4978, 4979], leaf: 4977 }, + Case { id: "bettertls::nameconstraints::tc1348", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4981, 4982], leaf: 4980 }, + Case { id: "bettertls::nameconstraints::tc1349", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4984, 4985], leaf: 4983 }, + Case { id: "bettertls::nameconstraints::tc1350", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4987, 4988], leaf: 4986 }, + Case { id: "bettertls::nameconstraints::tc1351", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4990, 4991], leaf: 4989 }, + Case { id: "bettertls::nameconstraints::tc1352", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4993, 4994], leaf: 4992 }, + Case { id: "bettertls::nameconstraints::tc1353", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4996, 4997], leaf: 4995 }, + Case { id: "bettertls::nameconstraints::tc1354", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[4999, 5000], leaf: 4998 }, + Case { id: "bettertls::nameconstraints::tc1355", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5002, 5003], leaf: 5001 }, + Case { id: "bettertls::nameconstraints::tc1356", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5005, 5006], leaf: 5004 }, + Case { id: "bettertls::nameconstraints::tc1357", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5008, 5009], leaf: 5007 }, + Case { id: "bettertls::nameconstraints::tc1358", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5011, 5012], leaf: 5010 }, + Case { id: "bettertls::nameconstraints::tc1359", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5014, 5015], leaf: 5013 }, + Case { id: "bettertls::nameconstraints::tc1360", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5017, 5018], leaf: 5016 }, + Case { id: "bettertls::nameconstraints::tc1361", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5020, 5021], leaf: 5019 }, + Case { id: "bettertls::nameconstraints::tc1362", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5023, 5024], leaf: 5022 }, + Case { id: "bettertls::nameconstraints::tc1363", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5026, 5027], leaf: 5025 }, + Case { id: "bettertls::nameconstraints::tc1364", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5029, 5030], leaf: 5028 }, + Case { id: "bettertls::nameconstraints::tc1365", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5032, 5033], leaf: 5031 }, + Case { id: "bettertls::nameconstraints::tc1366", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5035, 5036], leaf: 5034 }, + Case { id: "bettertls::nameconstraints::tc1367", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5038, 5039], leaf: 5037 }, + Case { id: "bettertls::nameconstraints::tc1368", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5041, 5042], leaf: 5040 }, + Case { id: "bettertls::nameconstraints::tc1369", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5044, 5045], leaf: 5043 }, + Case { id: "bettertls::nameconstraints::tc1370", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5047, 5048], leaf: 5046 }, + Case { id: "bettertls::nameconstraints::tc1371", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5050, 5051], leaf: 5049 }, + Case { id: "bettertls::nameconstraints::tc1372", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5053, 5054], leaf: 5052 }, + Case { id: "bettertls::nameconstraints::tc1373", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5056, 5057], leaf: 5055 }, + Case { id: "bettertls::nameconstraints::tc1374", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5059, 5060], leaf: 5058 }, + Case { id: "bettertls::nameconstraints::tc1375", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5062, 5063], leaf: 5061 }, + Case { id: "bettertls::nameconstraints::tc1376", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5065, 5066], leaf: 5064 }, + Case { id: "bettertls::nameconstraints::tc1377", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5068, 5069], leaf: 5067 }, + Case { id: "bettertls::nameconstraints::tc1378", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5071, 5072], leaf: 5070 }, + Case { id: "bettertls::nameconstraints::tc1379", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5074, 5075], leaf: 5073 }, + Case { id: "bettertls::nameconstraints::tc1380", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5077, 5078], leaf: 5076 }, + Case { id: "bettertls::nameconstraints::tc1381", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5080, 5081], leaf: 5079 }, + Case { id: "bettertls::nameconstraints::tc1382", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5083, 5084], leaf: 5082 }, + Case { id: "bettertls::nameconstraints::tc1383", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5086, 5087], leaf: 5085 }, + Case { id: "bettertls::nameconstraints::tc1384", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5089, 5090], leaf: 5088 }, + Case { id: "bettertls::nameconstraints::tc1385", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5092, 5093], leaf: 5091 }, + Case { id: "bettertls::nameconstraints::tc1386", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5095, 5096], leaf: 5094 }, + Case { id: "bettertls::nameconstraints::tc1387", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5098, 5099], leaf: 5097 }, + Case { id: "bettertls::nameconstraints::tc1388", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5101, 5102], leaf: 5100 }, + Case { id: "bettertls::nameconstraints::tc1389", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5104, 5105], leaf: 5103 }, + Case { id: "bettertls::nameconstraints::tc1390", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5107, 5108], leaf: 5106 }, + Case { id: "bettertls::nameconstraints::tc1391", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5110, 5111], leaf: 5109 }, + Case { id: "bettertls::nameconstraints::tc1392", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5113, 5114], leaf: 5112 }, + Case { id: "bettertls::nameconstraints::tc1393", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5116, 5117], leaf: 5115 }, + Case { id: "bettertls::nameconstraints::tc1394", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5119, 5120], leaf: 5118 }, + Case { id: "bettertls::nameconstraints::tc1395", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5122, 5123], leaf: 5121 }, + Case { id: "bettertls::nameconstraints::tc1396", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5125, 5126], leaf: 5124 }, + Case { id: "bettertls::nameconstraints::tc1397", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5128, 5129], leaf: 5127 }, + Case { id: "bettertls::nameconstraints::tc1398", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5131, 5132], leaf: 5130 }, + Case { id: "bettertls::nameconstraints::tc1399", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5134, 5135], leaf: 5133 }, + Case { id: "bettertls::nameconstraints::tc1400", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5137, 5138], leaf: 5136 }, + Case { id: "bettertls::nameconstraints::tc1401", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5140, 5141], leaf: 5139 }, + Case { id: "bettertls::nameconstraints::tc1402", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5143, 5144], leaf: 5142 }, + Case { id: "bettertls::nameconstraints::tc1403", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5146, 5147], leaf: 5145 }, + Case { id: "bettertls::nameconstraints::tc1404", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5149, 5150], leaf: 5148 }, + Case { id: "bettertls::nameconstraints::tc1405", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5152, 5153], leaf: 5151 }, + Case { id: "bettertls::nameconstraints::tc1406", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5155, 5156], leaf: 5154 }, + Case { id: "bettertls::nameconstraints::tc1407", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5158, 5159], leaf: 5157 }, + Case { id: "bettertls::nameconstraints::tc1408", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5161, 5162], leaf: 5160 }, + Case { id: "bettertls::nameconstraints::tc1409", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5164, 5165], leaf: 5163 }, + Case { id: "bettertls::nameconstraints::tc1410", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5167, 5168], leaf: 5166 }, + Case { id: "bettertls::nameconstraints::tc1411", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5170, 5171], leaf: 5169 }, + Case { id: "bettertls::nameconstraints::tc1412", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5173, 5174], leaf: 5172 }, + Case { id: "bettertls::nameconstraints::tc1413", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5176, 5177], leaf: 5175 }, + Case { id: "bettertls::nameconstraints::tc1414", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5179, 5180], leaf: 5178 }, + Case { id: "bettertls::nameconstraints::tc1415", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5182, 5183], leaf: 5181 }, + Case { id: "bettertls::nameconstraints::tc1416", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5185, 5186], leaf: 5184 }, + Case { id: "bettertls::nameconstraints::tc1417", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5188, 5189], leaf: 5187 }, + Case { id: "bettertls::nameconstraints::tc1418", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5191, 5192], leaf: 5190 }, + Case { id: "bettertls::nameconstraints::tc1419", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5194, 5195], leaf: 5193 }, + Case { id: "bettertls::nameconstraints::tc1420", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5197, 5198], leaf: 5196 }, + Case { id: "bettertls::nameconstraints::tc1421", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5200, 5201], leaf: 5199 }, + Case { id: "bettertls::nameconstraints::tc1422", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5203, 5204], leaf: 5202 }, + Case { id: "bettertls::nameconstraints::tc1423", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5206, 5207], leaf: 5205 }, + Case { id: "bettertls::nameconstraints::tc1424", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5209, 5210], leaf: 5208 }, + Case { id: "bettertls::nameconstraints::tc1425", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5212, 5213], leaf: 5211 }, + Case { id: "bettertls::nameconstraints::tc1426", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5215, 5216], leaf: 5214 }, + Case { id: "bettertls::nameconstraints::tc1427", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5218, 5219], leaf: 5217 }, + Case { id: "bettertls::nameconstraints::tc1428", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5221, 5222], leaf: 5220 }, + Case { id: "bettertls::nameconstraints::tc1429", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5224, 5225], leaf: 5223 }, + Case { id: "bettertls::nameconstraints::tc1430", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5227, 5228], leaf: 5226 }, + Case { id: "bettertls::nameconstraints::tc1431", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5230, 5231], leaf: 5229 }, + Case { id: "bettertls::nameconstraints::tc1432", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5233, 5234], leaf: 5232 }, + Case { id: "bettertls::nameconstraints::tc1433", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5236, 5237], leaf: 5235 }, + Case { id: "bettertls::nameconstraints::tc1434", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5239, 5240], leaf: 5238 }, + Case { id: "bettertls::nameconstraints::tc1435", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5242, 5243], leaf: 5241 }, + Case { id: "bettertls::nameconstraints::tc1436", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5245, 5246], leaf: 5244 }, + Case { id: "bettertls::nameconstraints::tc1437", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5248, 5249], leaf: 5247 }, + Case { id: "bettertls::nameconstraints::tc1438", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5251, 5252], leaf: 5250 }, + Case { id: "bettertls::nameconstraints::tc1439", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5254, 5255], leaf: 5253 }, + Case { id: "bettertls::nameconstraints::tc1440", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5257, 5258], leaf: 5256 }, + Case { id: "bettertls::nameconstraints::tc1441", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5260, 5261], leaf: 5259 }, + Case { id: "bettertls::nameconstraints::tc1442", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5263, 5264], leaf: 5262 }, + Case { id: "bettertls::nameconstraints::tc1443", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5266, 5267], leaf: 5265 }, + Case { id: "bettertls::nameconstraints::tc1444", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5269, 5270], leaf: 5268 }, + Case { id: "bettertls::nameconstraints::tc1445", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5272, 5273], leaf: 5271 }, + Case { id: "bettertls::nameconstraints::tc1446", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5275, 5276], leaf: 5274 }, + Case { id: "bettertls::nameconstraints::tc1447", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5278, 5279], leaf: 5277 }, + Case { id: "bettertls::nameconstraints::tc1448", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5281, 5282], leaf: 5280 }, + Case { id: "bettertls::nameconstraints::tc1449", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5284, 5285], leaf: 5283 }, + Case { id: "bettertls::nameconstraints::tc1450", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5287, 5288], leaf: 5286 }, + Case { id: "bettertls::nameconstraints::tc1451", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5290, 5291], leaf: 5289 }, + Case { id: "bettertls::nameconstraints::tc1452", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5293, 5294], leaf: 5292 }, + Case { id: "bettertls::nameconstraints::tc1453", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5296, 5297], leaf: 5295 }, + Case { id: "bettertls::nameconstraints::tc1454", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5299, 5300], leaf: 5298 }, + Case { id: "bettertls::nameconstraints::tc1455", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5302, 5303], leaf: 5301 }, + Case { id: "bettertls::nameconstraints::tc1456", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5305, 5306], leaf: 5304 }, + Case { id: "bettertls::nameconstraints::tc1457", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5308, 5309], leaf: 5307 }, + Case { id: "bettertls::nameconstraints::tc1458", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5311, 5312], leaf: 5310 }, + Case { id: "bettertls::nameconstraints::tc1459", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5314, 5315], leaf: 5313 }, + Case { id: "bettertls::nameconstraints::tc1460", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5317, 5318], leaf: 5316 }, + Case { id: "bettertls::nameconstraints::tc1461", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5320, 5321], leaf: 5319 }, + Case { id: "bettertls::nameconstraints::tc1462", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5323, 5324], leaf: 5322 }, + Case { id: "bettertls::nameconstraints::tc1463", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5326, 5327], leaf: 5325 }, + Case { id: "bettertls::nameconstraints::tc1464", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5329, 5330], leaf: 5328 }, + Case { id: "bettertls::nameconstraints::tc1465", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5332, 5333], leaf: 5331 }, + Case { id: "bettertls::nameconstraints::tc1466", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5335, 5336], leaf: 5334 }, + Case { id: "bettertls::nameconstraints::tc1467", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5338, 5339], leaf: 5337 }, + Case { id: "bettertls::nameconstraints::tc1468", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5341, 5342], leaf: 5340 }, + Case { id: "bettertls::nameconstraints::tc1469", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5344, 5345], leaf: 5343 }, + Case { id: "bettertls::nameconstraints::tc1470", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5347, 5348], leaf: 5346 }, + Case { id: "bettertls::nameconstraints::tc1471", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5350, 5351], leaf: 5349 }, + Case { id: "bettertls::nameconstraints::tc1472", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5353, 5354], leaf: 5352 }, + Case { id: "bettertls::nameconstraints::tc1473", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5356, 5357], leaf: 5355 }, + Case { id: "bettertls::nameconstraints::tc1474", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5359, 5360], leaf: 5358 }, + Case { id: "bettertls::nameconstraints::tc1475", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5362, 5363], leaf: 5361 }, + Case { id: "bettertls::nameconstraints::tc1476", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5365, 5366], leaf: 5364 }, + Case { id: "bettertls::nameconstraints::tc1477", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5368, 5369], leaf: 5367 }, + Case { id: "bettertls::nameconstraints::tc1478", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5371, 5372], leaf: 5370 }, + Case { id: "bettertls::nameconstraints::tc1479", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5374, 5375], leaf: 5373 }, + Case { id: "bettertls::nameconstraints::tc1480", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5377, 5378], leaf: 5376 }, + Case { id: "bettertls::nameconstraints::tc1481", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5380, 5381], leaf: 5379 }, + Case { id: "bettertls::nameconstraints::tc1482", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5383, 5384], leaf: 5382 }, + Case { id: "bettertls::nameconstraints::tc1483", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5386, 5387], leaf: 5385 }, + Case { id: "bettertls::nameconstraints::tc1484", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5389, 5390], leaf: 5388 }, + Case { id: "bettertls::nameconstraints::tc1485", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5392, 5393], leaf: 5391 }, + Case { id: "bettertls::nameconstraints::tc1486", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5395, 5396], leaf: 5394 }, + Case { id: "bettertls::nameconstraints::tc1487", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5398, 5399], leaf: 5397 }, + Case { id: "bettertls::nameconstraints::tc1488", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5401, 5402], leaf: 5400 }, + Case { id: "bettertls::nameconstraints::tc1489", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5404, 5405], leaf: 5403 }, + Case { id: "bettertls::nameconstraints::tc1490", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5407, 5408], leaf: 5406 }, + Case { id: "bettertls::nameconstraints::tc1491", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5410, 5411], leaf: 5409 }, + Case { id: "bettertls::nameconstraints::tc1492", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5413, 5414], leaf: 5412 }, + Case { id: "bettertls::nameconstraints::tc1493", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5416, 5417], leaf: 5415 }, + Case { id: "bettertls::nameconstraints::tc1494", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5419, 5420], leaf: 5418 }, + Case { id: "bettertls::nameconstraints::tc1495", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5422, 5423], leaf: 5421 }, + Case { id: "bettertls::nameconstraints::tc1496", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5425, 5426], leaf: 5424 }, + Case { id: "bettertls::nameconstraints::tc1497", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5428, 5429], leaf: 5427 }, + Case { id: "bettertls::nameconstraints::tc1498", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5431, 5432], leaf: 5430 }, + Case { id: "bettertls::nameconstraints::tc1499", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5434, 5435], leaf: 5433 }, + Case { id: "bettertls::nameconstraints::tc1500", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5437, 5438], leaf: 5436 }, + Case { id: "bettertls::nameconstraints::tc1501", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5440, 5441], leaf: 5439 }, + Case { id: "bettertls::nameconstraints::tc1502", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5443, 5444], leaf: 5442 }, + Case { id: "bettertls::nameconstraints::tc1503", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5446, 5447], leaf: 5445 }, + Case { id: "bettertls::nameconstraints::tc1504", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5449, 5450], leaf: 5448 }, + Case { id: "bettertls::nameconstraints::tc1505", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5452, 5453], leaf: 5451 }, + Case { id: "bettertls::nameconstraints::tc1506", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5455, 5456], leaf: 5454 }, + Case { id: "bettertls::nameconstraints::tc1507", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5458, 5459], leaf: 5457 }, + Case { id: "bettertls::nameconstraints::tc1508", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5461, 5462], leaf: 5460 }, + Case { id: "bettertls::nameconstraints::tc1509", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5464, 5465], leaf: 5463 }, + Case { id: "bettertls::nameconstraints::tc1510", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5467, 5468], leaf: 5466 }, + Case { id: "bettertls::nameconstraints::tc1511", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5470, 5471], leaf: 5469 }, + Case { id: "bettertls::nameconstraints::tc1512", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5473, 5474], leaf: 5472 }, + Case { id: "bettertls::nameconstraints::tc1513", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5476, 5477], leaf: 5475 }, + Case { id: "bettertls::nameconstraints::tc1514", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5479, 5480], leaf: 5478 }, + Case { id: "bettertls::nameconstraints::tc1515", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5482, 5483], leaf: 5481 }, + Case { id: "bettertls::nameconstraints::tc1516", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5485, 5486], leaf: 5484 }, + Case { id: "bettertls::nameconstraints::tc1517", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5488, 5489], leaf: 5487 }, + Case { id: "bettertls::nameconstraints::tc1518", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5491, 5492], leaf: 5490 }, + Case { id: "bettertls::nameconstraints::tc1519", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5494, 5495], leaf: 5493 }, + Case { id: "bettertls::nameconstraints::tc1520", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5497, 5498], leaf: 5496 }, + Case { id: "bettertls::nameconstraints::tc1521", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5500, 5501], leaf: 5499 }, + Case { id: "bettertls::nameconstraints::tc1522", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5503, 5504], leaf: 5502 }, + Case { id: "bettertls::nameconstraints::tc1523", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5506, 5507], leaf: 5505 }, + Case { id: "bettertls::nameconstraints::tc1524", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5509, 5510], leaf: 5508 }, + Case { id: "bettertls::nameconstraints::tc1525", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5512, 5513], leaf: 5511 }, + Case { id: "bettertls::nameconstraints::tc1526", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5515, 5516], leaf: 5514 }, + Case { id: "bettertls::nameconstraints::tc1527", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5518, 5519], leaf: 5517 }, + Case { id: "bettertls::nameconstraints::tc1528", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5521, 5522], leaf: 5520 }, + Case { id: "bettertls::nameconstraints::tc1529", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5524, 5525], leaf: 5523 }, + Case { id: "bettertls::nameconstraints::tc1530", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5527, 5528], leaf: 5526 }, + Case { id: "bettertls::nameconstraints::tc1531", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5530, 5531], leaf: 5529 }, + Case { id: "bettertls::nameconstraints::tc1532", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5533, 5534], leaf: 5532 }, + Case { id: "bettertls::nameconstraints::tc1533", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5536, 5537], leaf: 5535 }, + Case { id: "bettertls::nameconstraints::tc1534", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5539, 5540], leaf: 5538 }, + Case { id: "bettertls::nameconstraints::tc1535", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5542, 5543], leaf: 5541 }, + Case { id: "bettertls::nameconstraints::tc1536", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5545, 5546], leaf: 5544 }, + Case { id: "bettertls::nameconstraints::tc1537", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5548, 5549], leaf: 5547 }, + Case { id: "bettertls::nameconstraints::tc1538", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5551, 5552], leaf: 5550 }, + Case { id: "bettertls::nameconstraints::tc1539", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5554, 5555], leaf: 5553 }, + Case { id: "bettertls::nameconstraints::tc1540", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5557, 5558], leaf: 5556 }, + Case { id: "bettertls::nameconstraints::tc1541", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5560, 5561], leaf: 5559 }, + Case { id: "bettertls::nameconstraints::tc1542", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5563, 5564], leaf: 5562 }, + Case { id: "bettertls::nameconstraints::tc1543", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5566, 5567], leaf: 5565 }, + Case { id: "bettertls::nameconstraints::tc1544", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5569, 5570], leaf: 5568 }, + Case { id: "bettertls::nameconstraints::tc1545", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5572, 5573], leaf: 5571 }, + Case { id: "bettertls::nameconstraints::tc1546", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5575, 5576], leaf: 5574 }, + Case { id: "bettertls::nameconstraints::tc1547", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5578, 5579], leaf: 5577 }, + Case { id: "bettertls::nameconstraints::tc1548", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5581, 5582], leaf: 5580 }, + Case { id: "bettertls::nameconstraints::tc1549", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5584, 5585], leaf: 5583 }, + Case { id: "bettertls::nameconstraints::tc1550", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5587, 5588], leaf: 5586 }, + Case { id: "bettertls::nameconstraints::tc1551", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5590, 5591], leaf: 5589 }, + Case { id: "bettertls::nameconstraints::tc1552", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5593, 5594], leaf: 5592 }, + Case { id: "bettertls::nameconstraints::tc1553", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5596, 5597], leaf: 5595 }, + Case { id: "bettertls::nameconstraints::tc1554", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5599, 5600], leaf: 5598 }, + Case { id: "bettertls::nameconstraints::tc1555", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5602, 5603], leaf: 5601 }, + Case { id: "bettertls::nameconstraints::tc1556", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5605, 5606], leaf: 5604 }, + Case { id: "bettertls::nameconstraints::tc1557", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5608, 5609], leaf: 5607 }, + Case { id: "bettertls::nameconstraints::tc1558", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5611, 5612], leaf: 5610 }, + Case { id: "bettertls::nameconstraints::tc1559", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5614, 5615], leaf: 5613 }, + Case { id: "bettertls::nameconstraints::tc1560", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5617, 5618], leaf: 5616 }, + Case { id: "bettertls::nameconstraints::tc1561", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5620, 5621], leaf: 5619 }, + Case { id: "bettertls::nameconstraints::tc1562", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5623, 5624], leaf: 5622 }, + Case { id: "bettertls::nameconstraints::tc1563", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5626, 5627], leaf: 5625 }, + Case { id: "bettertls::nameconstraints::tc1564", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5629, 5630], leaf: 5628 }, + Case { id: "bettertls::nameconstraints::tc1565", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5632, 5633], leaf: 5631 }, + Case { id: "bettertls::nameconstraints::tc1566", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5635, 5636], leaf: 5634 }, + Case { id: "bettertls::nameconstraints::tc1567", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5638, 5639], leaf: 5637 }, + Case { id: "bettertls::nameconstraints::tc1568", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5641, 5642], leaf: 5640 }, + Case { id: "bettertls::nameconstraints::tc1569", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5644, 5645], leaf: 5643 }, + Case { id: "bettertls::nameconstraints::tc1570", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5647, 5648], leaf: 5646 }, + Case { id: "bettertls::nameconstraints::tc1571", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5650, 5651], leaf: 5649 }, + Case { id: "bettertls::nameconstraints::tc1572", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5653, 5654], leaf: 5652 }, + Case { id: "bettertls::nameconstraints::tc1573", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5656, 5657], leaf: 5655 }, + Case { id: "bettertls::nameconstraints::tc1574", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5659, 5660], leaf: 5658 }, + Case { id: "bettertls::nameconstraints::tc1575", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5662, 5663], leaf: 5661 }, + Case { id: "bettertls::nameconstraints::tc1576", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5665, 5666], leaf: 5664 }, + Case { id: "bettertls::nameconstraints::tc1577", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5668, 5669], leaf: 5667 }, + Case { id: "bettertls::nameconstraints::tc1578", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5671, 5672], leaf: 5670 }, + Case { id: "bettertls::nameconstraints::tc1579", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5674, 5675], leaf: 5673 }, + Case { id: "bettertls::nameconstraints::tc1580", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5677, 5678], leaf: 5676 }, + Case { id: "bettertls::nameconstraints::tc1581", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5680, 5681], leaf: 5679 }, + Case { id: "bettertls::nameconstraints::tc1582", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5683, 5684], leaf: 5682 }, + Case { id: "bettertls::nameconstraints::tc1583", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5686, 5687], leaf: 5685 }, + Case { id: "bettertls::nameconstraints::tc1584", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5689, 5690], leaf: 5688 }, + Case { id: "bettertls::nameconstraints::tc1585", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5692, 5693], leaf: 5691 }, + Case { id: "bettertls::nameconstraints::tc1586", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5695, 5696], leaf: 5694 }, + Case { id: "bettertls::nameconstraints::tc1587", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5698, 5699], leaf: 5697 }, + Case { id: "bettertls::nameconstraints::tc1588", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5701, 5702], leaf: 5700 }, + Case { id: "bettertls::nameconstraints::tc1589", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5704, 5705], leaf: 5703 }, + Case { id: "bettertls::nameconstraints::tc1590", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5707, 5708], leaf: 5706 }, + Case { id: "bettertls::nameconstraints::tc1591", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5710, 5711], leaf: 5709 }, + Case { id: "bettertls::nameconstraints::tc1592", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5713, 5714], leaf: 5712 }, + Case { id: "bettertls::nameconstraints::tc1593", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5716, 5717], leaf: 5715 }, + Case { id: "bettertls::nameconstraints::tc1594", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5719, 5720], leaf: 5718 }, + Case { id: "bettertls::nameconstraints::tc1595", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5722, 5723], leaf: 5721 }, + Case { id: "bettertls::nameconstraints::tc1596", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5725, 5726], leaf: 5724 }, + Case { id: "bettertls::nameconstraints::tc1597", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5728, 5729], leaf: 5727 }, + Case { id: "bettertls::nameconstraints::tc1598", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5731, 5732], leaf: 5730 }, + Case { id: "bettertls::nameconstraints::tc1599", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5734, 5735], leaf: 5733 }, + Case { id: "bettertls::nameconstraints::tc1600", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5737, 5738], leaf: 5736 }, + Case { id: "bettertls::nameconstraints::tc1601", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5740, 5741], leaf: 5739 }, + Case { id: "bettertls::nameconstraints::tc1602", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5743, 5744], leaf: 5742 }, + Case { id: "bettertls::nameconstraints::tc1603", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5746, 5747], leaf: 5745 }, + Case { id: "bettertls::nameconstraints::tc1604", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5749, 5750], leaf: 5748 }, + Case { id: "bettertls::nameconstraints::tc1605", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5752, 5753], leaf: 5751 }, + Case { id: "bettertls::nameconstraints::tc1606", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5755, 5756], leaf: 5754 }, + Case { id: "bettertls::nameconstraints::tc1607", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5758, 5759], leaf: 5757 }, + Case { id: "bettertls::nameconstraints::tc1608", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5761, 5762], leaf: 5760 }, + Case { id: "bettertls::nameconstraints::tc1609", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5764, 5765], leaf: 5763 }, + Case { id: "bettertls::nameconstraints::tc1610", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5767, 5768], leaf: 5766 }, + Case { id: "bettertls::nameconstraints::tc1611", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5770, 5771], leaf: 5769 }, + Case { id: "bettertls::nameconstraints::tc1612", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5773, 5774], leaf: 5772 }, + Case { id: "bettertls::nameconstraints::tc1613", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5776, 5777], leaf: 5775 }, + Case { id: "bettertls::nameconstraints::tc1614", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5779, 5780], leaf: 5778 }, + Case { id: "bettertls::nameconstraints::tc1615", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5782, 5783], leaf: 5781 }, + Case { id: "bettertls::nameconstraints::tc1616", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5785, 5786], leaf: 5784 }, + Case { id: "bettertls::nameconstraints::tc1617", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5788, 5789], leaf: 5787 }, + Case { id: "bettertls::nameconstraints::tc1618", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5791, 5792], leaf: 5790 }, + Case { id: "bettertls::nameconstraints::tc1619", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5794, 5795], leaf: 5793 }, + Case { id: "bettertls::nameconstraints::tc1620", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5797, 5798], leaf: 5796 }, + Case { id: "bettertls::nameconstraints::tc1621", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5800, 5801], leaf: 5799 }, + Case { id: "bettertls::nameconstraints::tc1622", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5803, 5804], leaf: 5802 }, + Case { id: "bettertls::nameconstraints::tc1623", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5806, 5807], leaf: 5805 }, + Case { id: "bettertls::nameconstraints::tc1624", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5809, 5810], leaf: 5808 }, + Case { id: "bettertls::nameconstraints::tc1625", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5812, 5813], leaf: 5811 }, + Case { id: "bettertls::nameconstraints::tc1626", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5815, 5816], leaf: 5814 }, + Case { id: "bettertls::nameconstraints::tc1627", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5818, 5819], leaf: 5817 }, + Case { id: "bettertls::nameconstraints::tc1628", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5821, 5822], leaf: 5820 }, + Case { id: "bettertls::nameconstraints::tc1629", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5824, 5825], leaf: 5823 }, + Case { id: "bettertls::nameconstraints::tc1630", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5827, 5828], leaf: 5826 }, + Case { id: "bettertls::nameconstraints::tc1631", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5830, 5831], leaf: 5829 }, + Case { id: "bettertls::nameconstraints::tc1632", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5833, 5834], leaf: 5832 }, + Case { id: "bettertls::nameconstraints::tc1633", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5836, 5837], leaf: 5835 }, + Case { id: "bettertls::nameconstraints::tc1634", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5839, 5840], leaf: 5838 }, + Case { id: "bettertls::nameconstraints::tc1635", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5842, 5843], leaf: 5841 }, + Case { id: "bettertls::nameconstraints::tc1636", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5845, 5846], leaf: 5844 }, + Case { id: "bettertls::nameconstraints::tc1637", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5848, 5849], leaf: 5847 }, + Case { id: "bettertls::nameconstraints::tc1638", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5851, 5852], leaf: 5850 }, + Case { id: "bettertls::nameconstraints::tc1639", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5854, 5855], leaf: 5853 }, + Case { id: "bettertls::nameconstraints::tc1640", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5857, 5858], leaf: 5856 }, + Case { id: "bettertls::nameconstraints::tc1641", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5860, 5861], leaf: 5859 }, + Case { id: "bettertls::nameconstraints::tc1642", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5863, 5864], leaf: 5862 }, + Case { id: "bettertls::nameconstraints::tc1643", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5866, 5867], leaf: 5865 }, + Case { id: "bettertls::nameconstraints::tc1644", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5869, 5870], leaf: 5868 }, + Case { id: "bettertls::nameconstraints::tc1645", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5872, 5873], leaf: 5871 }, + Case { id: "bettertls::nameconstraints::tc1646", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5875, 5876], leaf: 5874 }, + Case { id: "bettertls::nameconstraints::tc1647", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5878, 5879], leaf: 5877 }, + Case { id: "bettertls::nameconstraints::tc1648", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5881, 5882], leaf: 5880 }, + Case { id: "bettertls::nameconstraints::tc1649", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5884, 5885], leaf: 5883 }, + Case { id: "bettertls::nameconstraints::tc1650", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5887, 5888], leaf: 5886 }, + Case { id: "bettertls::nameconstraints::tc1651", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5890, 5891], leaf: 5889 }, + Case { id: "bettertls::nameconstraints::tc1652", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5893, 5894], leaf: 5892 }, + Case { id: "bettertls::nameconstraints::tc1653", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5896, 5897], leaf: 5895 }, + Case { id: "bettertls::nameconstraints::tc1654", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5899, 5900], leaf: 5898 }, + Case { id: "bettertls::nameconstraints::tc1655", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5902, 5903], leaf: 5901 }, + Case { id: "bettertls::nameconstraints::tc1656", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5905, 5906], leaf: 5904 }, + Case { id: "bettertls::nameconstraints::tc1657", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5908, 5909], leaf: 5907 }, + Case { id: "bettertls::nameconstraints::tc1658", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5911, 5912], leaf: 5910 }, + Case { id: "bettertls::nameconstraints::tc1659", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5914, 5915], leaf: 5913 }, + Case { id: "bettertls::nameconstraints::tc1660", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5917, 5918], leaf: 5916 }, + Case { id: "bettertls::nameconstraints::tc1661", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5920, 5921], leaf: 5919 }, + Case { id: "bettertls::nameconstraints::tc1662", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5923, 5924], leaf: 5922 }, + Case { id: "bettertls::nameconstraints::tc1663", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5926, 5927], leaf: 5925 }, + Case { id: "bettertls::nameconstraints::tc1664", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5929, 5930], leaf: 5928 }, + Case { id: "bettertls::nameconstraints::tc1665", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5932, 5933], leaf: 5931 }, + Case { id: "bettertls::nameconstraints::tc1666", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5935, 5936], leaf: 5934 }, + Case { id: "bettertls::nameconstraints::tc1667", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5938, 5939], leaf: 5937 }, + Case { id: "bettertls::nameconstraints::tc1668", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5941, 5942], leaf: 5940 }, + Case { id: "bettertls::nameconstraints::tc1669", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5944, 5945], leaf: 5943 }, + Case { id: "bettertls::nameconstraints::tc1670", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5947, 5948], leaf: 5946 }, + Case { id: "bettertls::nameconstraints::tc1671", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5950, 5951], leaf: 5949 }, + Case { id: "bettertls::nameconstraints::tc1672", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5953, 5954], leaf: 5952 }, + Case { id: "bettertls::nameconstraints::tc1673", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5956, 5957], leaf: 5955 }, + Case { id: "bettertls::nameconstraints::tc1674", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5959, 5960], leaf: 5958 }, + Case { id: "bettertls::nameconstraints::tc1675", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5962, 5963], leaf: 5961 }, + Case { id: "bettertls::nameconstraints::tc1676", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5965, 5966], leaf: 5964 }, + Case { id: "bettertls::nameconstraints::tc1677", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5968, 5969], leaf: 5967 }, + Case { id: "bettertls::nameconstraints::tc1678", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5971, 5972], leaf: 5970 }, + Case { id: "bettertls::nameconstraints::tc1679", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5974, 5975], leaf: 5973 }, + Case { id: "bettertls::nameconstraints::tc1680", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5977, 5978], leaf: 5976 }, + Case { id: "bettertls::nameconstraints::tc1681", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5980, 5981], leaf: 5979 }, + Case { id: "bettertls::nameconstraints::tc1682", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5983, 5984], leaf: 5982 }, + Case { id: "bettertls::nameconstraints::tc1683", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5986, 5987], leaf: 5985 }, + Case { id: "bettertls::nameconstraints::tc1684", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5989, 5990], leaf: 5988 }, + Case { id: "bettertls::nameconstraints::tc1685", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5992, 5993], leaf: 5991 }, + Case { id: "bettertls::nameconstraints::tc1686", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5995, 5996], leaf: 5994 }, + Case { id: "bettertls::nameconstraints::tc1687", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[5998, 5999], leaf: 5997 }, + Case { id: "bettertls::nameconstraints::tc1688", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6001, 6002], leaf: 6000 }, + Case { id: "bettertls::nameconstraints::tc1689", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6004, 6005], leaf: 6003 }, + Case { id: "bettertls::nameconstraints::tc1690", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6007, 6008], leaf: 6006 }, + Case { id: "bettertls::nameconstraints::tc1691", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6010, 6011], leaf: 6009 }, + Case { id: "bettertls::nameconstraints::tc1692", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6013, 6014], leaf: 6012 }, + Case { id: "bettertls::nameconstraints::tc1693", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6016, 6017], leaf: 6015 }, + Case { id: "bettertls::nameconstraints::tc1694", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6019, 6020], leaf: 6018 }, + Case { id: "bettertls::nameconstraints::tc1695", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6022, 6023], leaf: 6021 }, + Case { id: "bettertls::nameconstraints::tc1696", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6025, 6026], leaf: 6024 }, + Case { id: "bettertls::nameconstraints::tc1697", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6028, 6029], leaf: 6027 }, + Case { id: "bettertls::nameconstraints::tc1698", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6031, 6032], leaf: 6030 }, + Case { id: "bettertls::nameconstraints::tc1699", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6034, 6035], leaf: 6033 }, + Case { id: "bettertls::nameconstraints::tc1700", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6037, 6038], leaf: 6036 }, + Case { id: "bettertls::nameconstraints::tc1701", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6040, 6041], leaf: 6039 }, + Case { id: "bettertls::nameconstraints::tc1702", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6043, 6044], leaf: 6042 }, + Case { id: "bettertls::nameconstraints::tc1703", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6046, 6047], leaf: 6045 }, + Case { id: "bettertls::nameconstraints::tc1704", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6049, 6050], leaf: 6048 }, + Case { id: "bettertls::nameconstraints::tc1705", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6052, 6053], leaf: 6051 }, + Case { id: "bettertls::nameconstraints::tc1706", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6055, 6056], leaf: 6054 }, + Case { id: "bettertls::nameconstraints::tc1707", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6058, 6059], leaf: 6057 }, + Case { id: "bettertls::nameconstraints::tc1708", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6061, 6062], leaf: 6060 }, + Case { id: "bettertls::nameconstraints::tc1709", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6064, 6065], leaf: 6063 }, + Case { id: "bettertls::nameconstraints::tc1710", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6067, 6068], leaf: 6066 }, + Case { id: "bettertls::nameconstraints::tc1711", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6070, 6071], leaf: 6069 }, + Case { id: "bettertls::nameconstraints::tc1712", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6073, 6074], leaf: 6072 }, + Case { id: "bettertls::nameconstraints::tc1713", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6076, 6077], leaf: 6075 }, + Case { id: "bettertls::nameconstraints::tc1714", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6079, 6080], leaf: 6078 }, + Case { id: "bettertls::nameconstraints::tc1715", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6082, 6083], leaf: 6081 }, + Case { id: "bettertls::nameconstraints::tc1716", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6085, 6086], leaf: 6084 }, + Case { id: "bettertls::nameconstraints::tc1717", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6088, 6089], leaf: 6087 }, + Case { id: "bettertls::nameconstraints::tc1718", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6091, 6092], leaf: 6090 }, + Case { id: "bettertls::nameconstraints::tc1719", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6094, 6095], leaf: 6093 }, + Case { id: "bettertls::nameconstraints::tc1720", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6097, 6098], leaf: 6096 }, + Case { id: "bettertls::nameconstraints::tc1721", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6100, 6101], leaf: 6099 }, + Case { id: "bettertls::nameconstraints::tc1722", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6103, 6104], leaf: 6102 }, + Case { id: "bettertls::nameconstraints::tc1723", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6106, 6107], leaf: 6105 }, + Case { id: "bettertls::nameconstraints::tc1724", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6109, 6110], leaf: 6108 }, + Case { id: "bettertls::nameconstraints::tc1725", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6112, 6113], leaf: 6111 }, + Case { id: "bettertls::nameconstraints::tc1726", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6115, 6116], leaf: 6114 }, + Case { id: "bettertls::nameconstraints::tc1727", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6118, 6119], leaf: 6117 }, + Case { id: "bettertls::nameconstraints::tc1728", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6121, 6122], leaf: 6120 }, + Case { id: "bettertls::nameconstraints::tc1729", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6124, 6125], leaf: 6123 }, + Case { id: "bettertls::nameconstraints::tc1730", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6127, 6128], leaf: 6126 }, + Case { id: "bettertls::nameconstraints::tc1731", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6130, 6131], leaf: 6129 }, + Case { id: "bettertls::nameconstraints::tc1732", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6133, 6134], leaf: 6132 }, + Case { id: "bettertls::nameconstraints::tc1733", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6136, 6137], leaf: 6135 }, + Case { id: "bettertls::nameconstraints::tc1734", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6139, 6140], leaf: 6138 }, + Case { id: "bettertls::nameconstraints::tc1735", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6142, 6143], leaf: 6141 }, + Case { id: "bettertls::nameconstraints::tc1736", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6145, 6146], leaf: 6144 }, + Case { id: "bettertls::nameconstraints::tc1737", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6148, 6149], leaf: 6147 }, + Case { id: "bettertls::nameconstraints::tc1738", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6151, 6152], leaf: 6150 }, + Case { id: "bettertls::nameconstraints::tc1739", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6154, 6155], leaf: 6153 }, + Case { id: "bettertls::nameconstraints::tc1740", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6157, 6158], leaf: 6156 }, + Case { id: "bettertls::nameconstraints::tc1741", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6160, 6161], leaf: 6159 }, + Case { id: "bettertls::nameconstraints::tc1742", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6163, 6164], leaf: 6162 }, + Case { id: "bettertls::nameconstraints::tc1743", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6166, 6167], leaf: 6165 }, + Case { id: "bettertls::nameconstraints::tc1744", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6169, 6170], leaf: 6168 }, + Case { id: "bettertls::nameconstraints::tc1745", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6172, 6173], leaf: 6171 }, + Case { id: "bettertls::nameconstraints::tc1746", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6175, 6176], leaf: 6174 }, + Case { id: "bettertls::nameconstraints::tc1747", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6178, 6179], leaf: 6177 }, + Case { id: "bettertls::nameconstraints::tc1748", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6181, 6182], leaf: 6180 }, + Case { id: "bettertls::nameconstraints::tc1749", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6184, 6185], leaf: 6183 }, + Case { id: "bettertls::nameconstraints::tc1750", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6187, 6188], leaf: 6186 }, + Case { id: "bettertls::nameconstraints::tc1751", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6190, 6191], leaf: 6189 }, + Case { id: "bettertls::nameconstraints::tc1752", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6193, 6194], leaf: 6192 }, + Case { id: "bettertls::nameconstraints::tc1753", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6196, 6197], leaf: 6195 }, + Case { id: "bettertls::nameconstraints::tc1754", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6199, 6200], leaf: 6198 }, + Case { id: "bettertls::nameconstraints::tc1755", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6202, 6203], leaf: 6201 }, + Case { id: "bettertls::nameconstraints::tc1756", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6205, 6206], leaf: 6204 }, + Case { id: "bettertls::nameconstraints::tc1757", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6208, 6209], leaf: 6207 }, + Case { id: "bettertls::nameconstraints::tc1758", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6211, 6212], leaf: 6210 }, + Case { id: "bettertls::nameconstraints::tc1759", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6214, 6215], leaf: 6213 }, + Case { id: "bettertls::nameconstraints::tc1760", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6217, 6218], leaf: 6216 }, + Case { id: "bettertls::nameconstraints::tc1761", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6220, 6221], leaf: 6219 }, + Case { id: "bettertls::nameconstraints::tc1762", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6223, 6224], leaf: 6222 }, + Case { id: "bettertls::nameconstraints::tc1763", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6226, 6227], leaf: 6225 }, + Case { id: "bettertls::nameconstraints::tc1764", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6229, 6230], leaf: 6228 }, + Case { id: "bettertls::nameconstraints::tc1765", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6232, 6233], leaf: 6231 }, + Case { id: "bettertls::nameconstraints::tc1766", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6235, 6236], leaf: 6234 }, + Case { id: "bettertls::nameconstraints::tc1767", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6238, 6239], leaf: 6237 }, + Case { id: "bettertls::nameconstraints::tc1768", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6241, 6242], leaf: 6240 }, + Case { id: "bettertls::nameconstraints::tc1769", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6244, 6245], leaf: 6243 }, + Case { id: "bettertls::nameconstraints::tc1770", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6247, 6248], leaf: 6246 }, + Case { id: "bettertls::nameconstraints::tc1771", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6250, 6251], leaf: 6249 }, + Case { id: "bettertls::nameconstraints::tc1772", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6253, 6254], leaf: 6252 }, + Case { id: "bettertls::nameconstraints::tc1773", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6256, 6257], leaf: 6255 }, + Case { id: "bettertls::nameconstraints::tc1774", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6259, 6260], leaf: 6258 }, + Case { id: "bettertls::nameconstraints::tc1775", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6262, 6263], leaf: 6261 }, + Case { id: "bettertls::nameconstraints::tc1776", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6265, 6266], leaf: 6264 }, + Case { id: "bettertls::nameconstraints::tc1777", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6268, 6269], leaf: 6267 }, + Case { id: "bettertls::nameconstraints::tc1778", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6271, 6272], leaf: 6270 }, + Case { id: "bettertls::nameconstraints::tc1779", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6274, 6275], leaf: 6273 }, + Case { id: "bettertls::nameconstraints::tc1780", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6277, 6278], leaf: 6276 }, + Case { id: "bettertls::nameconstraints::tc1781", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6280, 6281], leaf: 6279 }, + Case { id: "bettertls::nameconstraints::tc1782", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6283, 6284], leaf: 6282 }, + Case { id: "bettertls::nameconstraints::tc1783", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6286, 6287], leaf: 6285 }, + Case { id: "bettertls::nameconstraints::tc1784", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6289, 6290], leaf: 6288 }, + Case { id: "bettertls::nameconstraints::tc1785", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6292, 6293], leaf: 6291 }, + Case { id: "bettertls::nameconstraints::tc1786", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6295, 6296], leaf: 6294 }, + Case { id: "bettertls::nameconstraints::tc1787", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6298, 6299], leaf: 6297 }, + Case { id: "bettertls::nameconstraints::tc1788", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6301, 6302], leaf: 6300 }, + Case { id: "bettertls::nameconstraints::tc1789", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6304, 6305], leaf: 6303 }, + Case { id: "bettertls::nameconstraints::tc1790", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6307, 6308], leaf: 6306 }, + Case { id: "bettertls::nameconstraints::tc1791", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6310, 6311], leaf: 6309 }, + Case { id: "bettertls::nameconstraints::tc1792", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6313, 6314], leaf: 6312 }, + Case { id: "bettertls::nameconstraints::tc1793", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6316, 6317], leaf: 6315 }, + Case { id: "bettertls::nameconstraints::tc1794", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6319, 6320], leaf: 6318 }, + Case { id: "bettertls::nameconstraints::tc1795", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6322, 6323], leaf: 6321 }, + Case { id: "bettertls::nameconstraints::tc1796", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6325, 6326], leaf: 6324 }, + Case { id: "bettertls::nameconstraints::tc1797", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6328, 6329], leaf: 6327 }, + Case { id: "bettertls::nameconstraints::tc1798", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6331, 6332], leaf: 6330 }, + Case { id: "bettertls::nameconstraints::tc1799", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6334, 6335], leaf: 6333 }, + Case { id: "bettertls::nameconstraints::tc1800", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6337, 6338], leaf: 6336 }, + Case { id: "bettertls::nameconstraints::tc1801", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6340, 6341], leaf: 6339 }, + Case { id: "bettertls::nameconstraints::tc1802", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6343, 6344], leaf: 6342 }, + Case { id: "bettertls::nameconstraints::tc1803", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6346, 6347], leaf: 6345 }, + Case { id: "bettertls::nameconstraints::tc1804", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6349, 6350], leaf: 6348 }, + Case { id: "bettertls::nameconstraints::tc1805", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6352, 6353], leaf: 6351 }, + Case { id: "bettertls::nameconstraints::tc1806", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6355, 6356], leaf: 6354 }, + Case { id: "bettertls::nameconstraints::tc1807", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6358, 6359], leaf: 6357 }, + Case { id: "bettertls::nameconstraints::tc1808", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6361, 6362], leaf: 6360 }, + Case { id: "bettertls::nameconstraints::tc1809", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6364, 6365], leaf: 6363 }, + Case { id: "bettertls::nameconstraints::tc1810", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6367, 6368], leaf: 6366 }, + Case { id: "bettertls::nameconstraints::tc1811", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6370, 6371], leaf: 6369 }, + Case { id: "bettertls::nameconstraints::tc1812", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6373, 6374], leaf: 6372 }, + Case { id: "bettertls::nameconstraints::tc1813", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6376, 6377], leaf: 6375 }, + Case { id: "bettertls::nameconstraints::tc1814", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6379, 6380], leaf: 6378 }, + Case { id: "bettertls::nameconstraints::tc1815", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6382, 6383], leaf: 6381 }, + Case { id: "bettertls::nameconstraints::tc1816", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6385, 6386], leaf: 6384 }, + Case { id: "bettertls::nameconstraints::tc1817", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6388, 6389], leaf: 6387 }, + Case { id: "bettertls::nameconstraints::tc1818", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6391, 6392], leaf: 6390 }, + Case { id: "bettertls::nameconstraints::tc1819", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6394, 6395], leaf: 6393 }, + Case { id: "bettertls::nameconstraints::tc1820", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6397, 6398], leaf: 6396 }, + Case { id: "bettertls::nameconstraints::tc1821", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6400, 6401], leaf: 6399 }, + Case { id: "bettertls::nameconstraints::tc1822", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6403, 6404], leaf: 6402 }, + Case { id: "bettertls::nameconstraints::tc1823", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6406, 6407], leaf: 6405 }, + Case { id: "bettertls::nameconstraints::tc1824", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6409, 6410], leaf: 6408 }, + Case { id: "bettertls::nameconstraints::tc1825", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6412, 6413], leaf: 6411 }, + Case { id: "bettertls::nameconstraints::tc1826", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6415, 6416], leaf: 6414 }, + Case { id: "bettertls::nameconstraints::tc1827", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6418, 6419], leaf: 6417 }, + Case { id: "bettertls::nameconstraints::tc1828", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6421, 6422], leaf: 6420 }, + Case { id: "bettertls::nameconstraints::tc1829", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6424, 6425], leaf: 6423 }, + Case { id: "bettertls::nameconstraints::tc1830", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6427, 6428], leaf: 6426 }, + Case { id: "bettertls::nameconstraints::tc1831", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6430, 6431], leaf: 6429 }, + Case { id: "bettertls::nameconstraints::tc1832", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6433, 6434], leaf: 6432 }, + Case { id: "bettertls::nameconstraints::tc1833", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6436, 6437], leaf: 6435 }, + Case { id: "bettertls::nameconstraints::tc1834", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6439, 6440], leaf: 6438 }, + Case { id: "bettertls::nameconstraints::tc1835", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6442, 6443], leaf: 6441 }, + Case { id: "bettertls::nameconstraints::tc1836", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6445, 6446], leaf: 6444 }, + Case { id: "bettertls::nameconstraints::tc1837", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6448, 6449], leaf: 6447 }, + Case { id: "bettertls::nameconstraints::tc1838", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6451, 6452], leaf: 6450 }, + Case { id: "bettertls::nameconstraints::tc1839", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6454, 6455], leaf: 6453 }, + Case { id: "bettertls::nameconstraints::tc1840", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6457, 6458], leaf: 6456 }, + Case { id: "bettertls::nameconstraints::tc1841", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6460, 6461], leaf: 6459 }, + Case { id: "bettertls::nameconstraints::tc1842", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6463, 6464], leaf: 6462 }, + Case { id: "bettertls::nameconstraints::tc1843", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6466, 6467], leaf: 6465 }, + Case { id: "bettertls::nameconstraints::tc1844", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6469, 6470], leaf: 6468 }, + Case { id: "bettertls::nameconstraints::tc1845", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6472, 6473], leaf: 6471 }, + Case { id: "bettertls::nameconstraints::tc1846", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6475, 6476], leaf: 6474 }, + Case { id: "bettertls::nameconstraints::tc1847", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6478, 6479], leaf: 6477 }, + Case { id: "bettertls::nameconstraints::tc1848", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6481, 6482], leaf: 6480 }, + Case { id: "bettertls::nameconstraints::tc1849", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6484, 6485], leaf: 6483 }, + Case { id: "bettertls::nameconstraints::tc1850", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6487, 6488], leaf: 6486 }, + Case { id: "bettertls::nameconstraints::tc1851", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6490, 6491], leaf: 6489 }, + Case { id: "bettertls::nameconstraints::tc1852", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6493, 6494], leaf: 6492 }, + Case { id: "bettertls::nameconstraints::tc1853", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6496, 6497], leaf: 6495 }, + Case { id: "bettertls::nameconstraints::tc1854", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6499, 6500], leaf: 6498 }, + Case { id: "bettertls::nameconstraints::tc1855", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6502, 6503], leaf: 6501 }, + Case { id: "bettertls::nameconstraints::tc1856", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6505, 6506], leaf: 6504 }, + Case { id: "bettertls::nameconstraints::tc1857", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6508, 6509], leaf: 6507 }, + Case { id: "bettertls::nameconstraints::tc1858", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6511, 6512], leaf: 6510 }, + Case { id: "bettertls::nameconstraints::tc1859", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6514, 6515], leaf: 6513 }, + Case { id: "bettertls::nameconstraints::tc1860", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6517, 6518], leaf: 6516 }, + Case { id: "bettertls::nameconstraints::tc1861", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6520, 6521], leaf: 6519 }, + Case { id: "bettertls::nameconstraints::tc1862", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6523, 6524], leaf: 6522 }, + Case { id: "bettertls::nameconstraints::tc1863", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6526, 6527], leaf: 6525 }, + Case { id: "bettertls::nameconstraints::tc1864", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6529, 6530], leaf: 6528 }, + Case { id: "bettertls::nameconstraints::tc1865", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6532, 6533], leaf: 6531 }, + Case { id: "bettertls::nameconstraints::tc1866", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6535, 6536], leaf: 6534 }, + Case { id: "bettertls::nameconstraints::tc1867", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6538, 6539], leaf: 6537 }, + Case { id: "bettertls::nameconstraints::tc1868", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6541, 6542], leaf: 6540 }, + Case { id: "bettertls::nameconstraints::tc1869", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6544, 6545], leaf: 6543 }, + Case { id: "bettertls::nameconstraints::tc1870", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6547, 6548], leaf: 6546 }, + Case { id: "bettertls::nameconstraints::tc1871", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6550, 6551], leaf: 6549 }, + Case { id: "bettertls::nameconstraints::tc1872", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6553, 6554], leaf: 6552 }, + Case { id: "bettertls::nameconstraints::tc1873", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6556, 6557], leaf: 6555 }, + Case { id: "bettertls::nameconstraints::tc1874", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6559, 6560], leaf: 6558 }, + Case { id: "bettertls::nameconstraints::tc1875", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6562, 6563], leaf: 6561 }, + Case { id: "bettertls::nameconstraints::tc1876", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6565, 6566], leaf: 6564 }, + Case { id: "bettertls::nameconstraints::tc1877", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6568, 6569], leaf: 6567 }, + Case { id: "bettertls::nameconstraints::tc1878", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6571, 6572], leaf: 6570 }, + Case { id: "bettertls::nameconstraints::tc1879", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6574, 6575], leaf: 6573 }, + Case { id: "bettertls::nameconstraints::tc1880", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6577, 6578], leaf: 6576 }, + Case { id: "bettertls::nameconstraints::tc1881", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6580, 6581], leaf: 6579 }, + Case { id: "bettertls::nameconstraints::tc1882", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6583, 6584], leaf: 6582 }, + Case { id: "bettertls::nameconstraints::tc1883", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6586, 6587], leaf: 6585 }, + Case { id: "bettertls::nameconstraints::tc1884", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6589, 6590], leaf: 6588 }, + Case { id: "bettertls::nameconstraints::tc1885", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6592, 6593], leaf: 6591 }, + Case { id: "bettertls::nameconstraints::tc1886", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6595, 6596], leaf: 6594 }, + Case { id: "bettertls::nameconstraints::tc1887", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6598, 6599], leaf: 6597 }, + Case { id: "bettertls::nameconstraints::tc1888", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6601, 6602], leaf: 6600 }, + Case { id: "bettertls::nameconstraints::tc1889", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6604, 6605], leaf: 6603 }, + Case { id: "bettertls::nameconstraints::tc1890", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6607, 6608], leaf: 6606 }, + Case { id: "bettertls::nameconstraints::tc1891", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6610, 6611], leaf: 6609 }, + Case { id: "bettertls::nameconstraints::tc1892", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6613, 6614], leaf: 6612 }, + Case { id: "bettertls::nameconstraints::tc1893", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6616, 6617], leaf: 6615 }, + Case { id: "bettertls::nameconstraints::tc1894", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6619, 6620], leaf: 6618 }, + Case { id: "bettertls::nameconstraints::tc1895", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6622, 6623], leaf: 6621 }, + Case { id: "bettertls::nameconstraints::tc1896", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6625, 6626], leaf: 6624 }, + Case { id: "bettertls::nameconstraints::tc1897", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6628, 6629], leaf: 6627 }, + Case { id: "bettertls::nameconstraints::tc1898", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6631, 6632], leaf: 6630 }, + Case { id: "bettertls::nameconstraints::tc1899", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6634, 6635], leaf: 6633 }, + Case { id: "bettertls::nameconstraints::tc1900", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6637, 6638], leaf: 6636 }, + Case { id: "bettertls::nameconstraints::tc1901", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6640, 6641], leaf: 6639 }, + Case { id: "bettertls::nameconstraints::tc1902", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6643, 6644], leaf: 6642 }, + Case { id: "bettertls::nameconstraints::tc1903", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6646, 6647], leaf: 6645 }, + Case { id: "bettertls::nameconstraints::tc1904", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6649, 6650], leaf: 6648 }, + Case { id: "bettertls::nameconstraints::tc1905", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6652, 6653], leaf: 6651 }, + Case { id: "bettertls::nameconstraints::tc1906", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6655, 6656], leaf: 6654 }, + Case { id: "bettertls::nameconstraints::tc1907", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6658, 6659], leaf: 6657 }, + Case { id: "bettertls::nameconstraints::tc1908", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6661, 6662], leaf: 6660 }, + Case { id: "bettertls::nameconstraints::tc1909", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6664, 6665], leaf: 6663 }, + Case { id: "bettertls::nameconstraints::tc1910", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6667, 6668], leaf: 6666 }, + Case { id: "bettertls::nameconstraints::tc1911", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6670, 6671], leaf: 6669 }, + Case { id: "bettertls::nameconstraints::tc1912", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6673, 6674], leaf: 6672 }, + Case { id: "bettertls::nameconstraints::tc1913", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6676, 6677], leaf: 6675 }, + Case { id: "bettertls::nameconstraints::tc1914", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6679, 6680], leaf: 6678 }, + Case { id: "bettertls::nameconstraints::tc1915", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6682, 6683], leaf: 6681 }, + Case { id: "bettertls::nameconstraints::tc1916", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6685, 6686], leaf: 6684 }, + Case { id: "bettertls::nameconstraints::tc1917", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6688, 6689], leaf: 6687 }, + Case { id: "bettertls::nameconstraints::tc1918", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6691, 6692], leaf: 6690 }, + Case { id: "bettertls::nameconstraints::tc1919", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6694, 6695], leaf: 6693 }, + Case { id: "bettertls::nameconstraints::tc1920", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6697, 6698], leaf: 6696 }, + Case { id: "bettertls::nameconstraints::tc1921", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6700, 6701], leaf: 6699 }, + Case { id: "bettertls::nameconstraints::tc1922", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6703, 6704], leaf: 6702 }, + Case { id: "bettertls::nameconstraints::tc1923", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6706, 6707], leaf: 6705 }, + Case { id: "bettertls::nameconstraints::tc1924", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6709, 6710], leaf: 6708 }, + Case { id: "bettertls::nameconstraints::tc1925", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6712, 6713], leaf: 6711 }, + Case { id: "bettertls::nameconstraints::tc1926", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6715, 6716], leaf: 6714 }, + Case { id: "bettertls::nameconstraints::tc1927", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6718, 6719], leaf: 6717 }, + Case { id: "bettertls::nameconstraints::tc1928", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6721, 6722], leaf: 6720 }, + Case { id: "bettertls::nameconstraints::tc1929", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6724, 6725], leaf: 6723 }, + Case { id: "bettertls::nameconstraints::tc1930", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6727, 6728], leaf: 6726 }, + Case { id: "bettertls::nameconstraints::tc1931", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6730, 6731], leaf: 6729 }, + Case { id: "bettertls::nameconstraints::tc1932", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6733, 6734], leaf: 6732 }, + Case { id: "bettertls::nameconstraints::tc1933", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6736, 6737], leaf: 6735 }, + Case { id: "bettertls::nameconstraints::tc1934", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6739, 6740], leaf: 6738 }, + Case { id: "bettertls::nameconstraints::tc1935", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6742, 6743], leaf: 6741 }, + Case { id: "bettertls::nameconstraints::tc1936", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6745, 6746], leaf: 6744 }, + Case { id: "bettertls::nameconstraints::tc1937", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6748, 6749], leaf: 6747 }, + Case { id: "bettertls::nameconstraints::tc1938", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6751, 6752], leaf: 6750 }, + Case { id: "bettertls::nameconstraints::tc1939", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6754, 6755], leaf: 6753 }, + Case { id: "bettertls::nameconstraints::tc1940", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6757, 6758], leaf: 6756 }, + Case { id: "bettertls::nameconstraints::tc1941", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6760, 6761], leaf: 6759 }, + Case { id: "bettertls::nameconstraints::tc1942", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6763, 6764], leaf: 6762 }, + Case { id: "bettertls::nameconstraints::tc1943", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6766, 6767], leaf: 6765 }, + Case { id: "bettertls::nameconstraints::tc1944", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6769, 6770], leaf: 6768 }, + Case { id: "bettertls::nameconstraints::tc1945", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6772, 6773], leaf: 6771 }, + Case { id: "bettertls::nameconstraints::tc1946", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6775, 6776], leaf: 6774 }, + Case { id: "bettertls::nameconstraints::tc1947", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6778, 6779], leaf: 6777 }, + Case { id: "bettertls::nameconstraints::tc1948", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6781, 6782], leaf: 6780 }, + Case { id: "bettertls::nameconstraints::tc1949", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6784, 6785], leaf: 6783 }, + Case { id: "bettertls::nameconstraints::tc1950", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6787, 6788], leaf: 6786 }, + Case { id: "bettertls::nameconstraints::tc1951", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6790, 6791], leaf: 6789 }, + Case { id: "bettertls::nameconstraints::tc1952", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6793, 6794], leaf: 6792 }, + Case { id: "bettertls::nameconstraints::tc1953", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6796, 6797], leaf: 6795 }, + Case { id: "bettertls::nameconstraints::tc1954", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6799, 6800], leaf: 6798 }, + Case { id: "bettertls::nameconstraints::tc1955", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6802, 6803], leaf: 6801 }, + Case { id: "bettertls::nameconstraints::tc1956", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6805, 6806], leaf: 6804 }, + Case { id: "bettertls::nameconstraints::tc1957", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6808, 6809], leaf: 6807 }, + Case { id: "bettertls::nameconstraints::tc1958", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6811, 6812], leaf: 6810 }, + Case { id: "bettertls::nameconstraints::tc1959", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6814, 6815], leaf: 6813 }, + Case { id: "bettertls::nameconstraints::tc1960", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6817, 6818], leaf: 6816 }, + Case { id: "bettertls::nameconstraints::tc1961", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6820, 6821], leaf: 6819 }, + Case { id: "bettertls::nameconstraints::tc1962", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6823, 6824], leaf: 6822 }, + Case { id: "bettertls::nameconstraints::tc1963", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6826, 6827], leaf: 6825 }, + Case { id: "bettertls::nameconstraints::tc1964", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6829, 6830], leaf: 6828 }, + Case { id: "bettertls::nameconstraints::tc1965", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6832, 6833], leaf: 6831 }, + Case { id: "bettertls::nameconstraints::tc1966", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6835, 6836], leaf: 6834 }, + Case { id: "bettertls::nameconstraints::tc1967", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6838, 6839], leaf: 6837 }, + Case { id: "bettertls::nameconstraints::tc1968", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6841, 6842], leaf: 6840 }, + Case { id: "bettertls::nameconstraints::tc1969", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6844, 6845], leaf: 6843 }, + Case { id: "bettertls::nameconstraints::tc1970", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6847, 6848], leaf: 6846 }, + Case { id: "bettertls::nameconstraints::tc1971", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6850, 6851], leaf: 6849 }, + Case { id: "bettertls::nameconstraints::tc1972", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6853, 6854], leaf: 6852 }, + Case { id: "bettertls::nameconstraints::tc1973", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6856, 6857], leaf: 6855 }, + Case { id: "bettertls::nameconstraints::tc1974", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6859, 6860], leaf: 6858 }, + Case { id: "bettertls::nameconstraints::tc1975", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6862, 6863], leaf: 6861 }, + Case { id: "bettertls::nameconstraints::tc1976", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6865, 6866], leaf: 6864 }, + Case { id: "bettertls::nameconstraints::tc1977", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6868, 6869], leaf: 6867 }, + Case { id: "bettertls::nameconstraints::tc1978", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6871, 6872], leaf: 6870 }, + Case { id: "bettertls::nameconstraints::tc1979", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6874, 6875], leaf: 6873 }, + Case { id: "bettertls::nameconstraints::tc1980", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6877, 6878], leaf: 6876 }, + Case { id: "bettertls::nameconstraints::tc1981", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6880, 6881], leaf: 6879 }, + Case { id: "bettertls::nameconstraints::tc1982", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6883, 6884], leaf: 6882 }, + Case { id: "bettertls::nameconstraints::tc1983", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6886, 6887], leaf: 6885 }, + Case { id: "bettertls::nameconstraints::tc1984", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6889, 6890], leaf: 6888 }, + Case { id: "bettertls::nameconstraints::tc1985", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6892, 6893], leaf: 6891 }, + Case { id: "bettertls::nameconstraints::tc1986", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6895, 6896], leaf: 6894 }, + Case { id: "bettertls::nameconstraints::tc1987", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6898, 6899], leaf: 6897 }, + Case { id: "bettertls::nameconstraints::tc1988", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6901, 6902], leaf: 6900 }, + Case { id: "bettertls::nameconstraints::tc1989", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6904, 6905], leaf: 6903 }, + Case { id: "bettertls::nameconstraints::tc1990", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6907, 6908], leaf: 6906 }, + Case { id: "bettertls::nameconstraints::tc1991", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6910, 6911], leaf: 6909 }, + Case { id: "bettertls::nameconstraints::tc1992", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6913, 6914], leaf: 6912 }, + Case { id: "bettertls::nameconstraints::tc1993", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6916, 6917], leaf: 6915 }, + Case { id: "bettertls::nameconstraints::tc1994", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6919, 6920], leaf: 6918 }, + Case { id: "bettertls::nameconstraints::tc1995", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6922, 6923], leaf: 6921 }, + Case { id: "bettertls::nameconstraints::tc1996", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6925, 6926], leaf: 6924 }, + Case { id: "bettertls::nameconstraints::tc1997", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6928, 6929], leaf: 6927 }, + Case { id: "bettertls::nameconstraints::tc1998", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6931, 6932], leaf: 6930 }, + Case { id: "bettertls::nameconstraints::tc1999", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6934, 6935], leaf: 6933 }, + Case { id: "bettertls::nameconstraints::tc2000", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6937, 6938], leaf: 6936 }, + Case { id: "bettertls::nameconstraints::tc2001", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6940, 6941], leaf: 6939 }, + Case { id: "bettertls::nameconstraints::tc2002", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6943, 6944], leaf: 6942 }, + Case { id: "bettertls::nameconstraints::tc2003", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6946, 6947], leaf: 6945 }, + Case { id: "bettertls::nameconstraints::tc2004", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6949, 6950], leaf: 6948 }, + Case { id: "bettertls::nameconstraints::tc2005", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6952, 6953], leaf: 6951 }, + Case { id: "bettertls::nameconstraints::tc2006", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6955, 6956], leaf: 6954 }, + Case { id: "bettertls::nameconstraints::tc2007", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6958, 6959], leaf: 6957 }, + Case { id: "bettertls::nameconstraints::tc2008", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6961, 6962], leaf: 6960 }, + Case { id: "bettertls::nameconstraints::tc2009", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6964, 6965], leaf: 6963 }, + Case { id: "bettertls::nameconstraints::tc2010", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6967, 6968], leaf: 6966 }, + Case { id: "bettertls::nameconstraints::tc2011", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6970, 6971], leaf: 6969 }, + Case { id: "bettertls::nameconstraints::tc2012", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6973, 6974], leaf: 6972 }, + Case { id: "bettertls::nameconstraints::tc2013", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6976, 6977], leaf: 6975 }, + Case { id: "bettertls::nameconstraints::tc2014", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6979, 6980], leaf: 6978 }, + Case { id: "bettertls::nameconstraints::tc2015", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6982, 6983], leaf: 6981 }, + Case { id: "bettertls::nameconstraints::tc2016", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6985, 6986], leaf: 6984 }, + Case { id: "bettertls::nameconstraints::tc2017", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6988, 6989], leaf: 6987 }, + Case { id: "bettertls::nameconstraints::tc2018", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6991, 6992], leaf: 6990 }, + Case { id: "bettertls::nameconstraints::tc2019", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6994, 6995], leaf: 6993 }, + Case { id: "bettertls::nameconstraints::tc2020", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[6997, 6998], leaf: 6996 }, + Case { id: "bettertls::nameconstraints::tc2021", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7000, 7001], leaf: 6999 }, + Case { id: "bettertls::nameconstraints::tc2022", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7003, 7004], leaf: 7002 }, + Case { id: "bettertls::nameconstraints::tc2023", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7006, 7007], leaf: 7005 }, + Case { id: "bettertls::nameconstraints::tc2024", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7009, 7010], leaf: 7008 }, + Case { id: "bettertls::nameconstraints::tc2025", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7012, 7013], leaf: 7011 }, + Case { id: "bettertls::nameconstraints::tc2026", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7015, 7016], leaf: 7014 }, + Case { id: "bettertls::nameconstraints::tc2027", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7018, 7019], leaf: 7017 }, + Case { id: "bettertls::nameconstraints::tc2028", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7021, 7022], leaf: 7020 }, + Case { id: "bettertls::nameconstraints::tc2029", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7024, 7025], leaf: 7023 }, + Case { id: "bettertls::nameconstraints::tc2030", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7027, 7028], leaf: 7026 }, + Case { id: "bettertls::nameconstraints::tc2031", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7030, 7031], leaf: 7029 }, + Case { id: "bettertls::nameconstraints::tc2032", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7033, 7034], leaf: 7032 }, + Case { id: "bettertls::nameconstraints::tc2033", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7036, 7037], leaf: 7035 }, + Case { id: "bettertls::nameconstraints::tc2034", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7039, 7040], leaf: 7038 }, + Case { id: "bettertls::nameconstraints::tc2035", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7042, 7043], leaf: 7041 }, + Case { id: "bettertls::nameconstraints::tc2036", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7045, 7046], leaf: 7044 }, + Case { id: "bettertls::nameconstraints::tc2037", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7048, 7049], leaf: 7047 }, + Case { id: "bettertls::nameconstraints::tc2038", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7051, 7052], leaf: 7050 }, + Case { id: "bettertls::nameconstraints::tc2039", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7054, 7055], leaf: 7053 }, + Case { id: "bettertls::nameconstraints::tc2040", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7057, 7058], leaf: 7056 }, + Case { id: "bettertls::nameconstraints::tc2041", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7060, 7061], leaf: 7059 }, + Case { id: "bettertls::nameconstraints::tc2042", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7063, 7064], leaf: 7062 }, + Case { id: "bettertls::nameconstraints::tc2043", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7066, 7067], leaf: 7065 }, + Case { id: "bettertls::nameconstraints::tc2044", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7069, 7070], leaf: 7068 }, + Case { id: "bettertls::nameconstraints::tc2045", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7072, 7073], leaf: 7071 }, + Case { id: "bettertls::nameconstraints::tc2046", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7075, 7076], leaf: 7074 }, + Case { id: "bettertls::nameconstraints::tc2047", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7078, 7079], leaf: 7077 }, + Case { id: "bettertls::nameconstraints::tc2048", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7081, 7082], leaf: 7080 }, + Case { id: "bettertls::nameconstraints::tc2049", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7084, 7085], leaf: 7083 }, + Case { id: "bettertls::nameconstraints::tc2050", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7087, 7088], leaf: 7086 }, + Case { id: "bettertls::nameconstraints::tc2051", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7090, 7091], leaf: 7089 }, + Case { id: "bettertls::nameconstraints::tc2052", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7093, 7094], leaf: 7092 }, + Case { id: "bettertls::nameconstraints::tc2053", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7096, 7097], leaf: 7095 }, + Case { id: "bettertls::nameconstraints::tc2054", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7099, 7100], leaf: 7098 }, + Case { id: "bettertls::nameconstraints::tc2055", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7102, 7103], leaf: 7101 }, + Case { id: "bettertls::nameconstraints::tc2056", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7105, 7106], leaf: 7104 }, + Case { id: "bettertls::nameconstraints::tc2057", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7108, 7109], leaf: 7107 }, + Case { id: "bettertls::nameconstraints::tc2058", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7111, 7112], leaf: 7110 }, + Case { id: "bettertls::nameconstraints::tc2059", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7114, 7115], leaf: 7113 }, + Case { id: "bettertls::nameconstraints::tc2060", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7117, 7118], leaf: 7116 }, + Case { id: "bettertls::nameconstraints::tc2061", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7120, 7121], leaf: 7119 }, + Case { id: "bettertls::nameconstraints::tc2062", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7123, 7124], leaf: 7122 }, + Case { id: "bettertls::nameconstraints::tc2063", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7126, 7127], leaf: 7125 }, + Case { id: "bettertls::nameconstraints::tc2064", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7129, 7130], leaf: 7128 }, + Case { id: "bettertls::nameconstraints::tc2065", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7132, 7133], leaf: 7131 }, + Case { id: "bettertls::nameconstraints::tc2066", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7135, 7136], leaf: 7134 }, + Case { id: "bettertls::nameconstraints::tc2067", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7138, 7139], leaf: 7137 }, + Case { id: "bettertls::nameconstraints::tc2068", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7141, 7142], leaf: 7140 }, + Case { id: "bettertls::nameconstraints::tc2069", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7144, 7145], leaf: 7143 }, + Case { id: "bettertls::nameconstraints::tc2070", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7147, 7148], leaf: 7146 }, + Case { id: "bettertls::nameconstraints::tc2071", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7150, 7151], leaf: 7149 }, + Case { id: "bettertls::nameconstraints::tc2072", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7153, 7154], leaf: 7152 }, + Case { id: "bettertls::nameconstraints::tc2073", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7156, 7157], leaf: 7155 }, + Case { id: "bettertls::nameconstraints::tc2074", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7159, 7160], leaf: 7158 }, + Case { id: "bettertls::nameconstraints::tc2075", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7162, 7163], leaf: 7161 }, + Case { id: "bettertls::nameconstraints::tc2076", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7165, 7166], leaf: 7164 }, + Case { id: "bettertls::nameconstraints::tc2077", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7168, 7169], leaf: 7167 }, + Case { id: "bettertls::nameconstraints::tc2078", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7171, 7172], leaf: 7170 }, + Case { id: "bettertls::nameconstraints::tc2079", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7174, 7175], leaf: 7173 }, + Case { id: "bettertls::nameconstraints::tc2080", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7177, 7178], leaf: 7176 }, + Case { id: "bettertls::nameconstraints::tc2081", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7180, 7181], leaf: 7179 }, + Case { id: "bettertls::nameconstraints::tc2082", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7183, 7184], leaf: 7182 }, + Case { id: "bettertls::nameconstraints::tc2083", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7186, 7187], leaf: 7185 }, + Case { id: "bettertls::nameconstraints::tc2084", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7189, 7190], leaf: 7188 }, + Case { id: "bettertls::nameconstraints::tc2085", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7192, 7193], leaf: 7191 }, + Case { id: "bettertls::nameconstraints::tc2086", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7195, 7196], leaf: 7194 }, + Case { id: "bettertls::nameconstraints::tc2087", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7198, 7199], leaf: 7197 }, + Case { id: "bettertls::nameconstraints::tc2088", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7201, 7202], leaf: 7200 }, + Case { id: "bettertls::nameconstraints::tc2089", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7204, 7205], leaf: 7203 }, + Case { id: "bettertls::nameconstraints::tc2090", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7207, 7208], leaf: 7206 }, + Case { id: "bettertls::nameconstraints::tc2091", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7210, 7211], leaf: 7209 }, + Case { id: "bettertls::nameconstraints::tc2092", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7213, 7214], leaf: 7212 }, + Case { id: "bettertls::nameconstraints::tc2093", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7216, 7217], leaf: 7215 }, + Case { id: "bettertls::nameconstraints::tc2094", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7219, 7220], leaf: 7218 }, + Case { id: "bettertls::nameconstraints::tc2095", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7222, 7223], leaf: 7221 }, + Case { id: "bettertls::nameconstraints::tc2096", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7225, 7226], leaf: 7224 }, + Case { id: "bettertls::nameconstraints::tc2097", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7228, 7229], leaf: 7227 }, + Case { id: "bettertls::nameconstraints::tc2098", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7231, 7232], leaf: 7230 }, + Case { id: "bettertls::nameconstraints::tc2099", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7234, 7235], leaf: 7233 }, + Case { id: "bettertls::nameconstraints::tc2100", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7237, 7238], leaf: 7236 }, + Case { id: "bettertls::nameconstraints::tc2101", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7240, 7241], leaf: 7239 }, + Case { id: "bettertls::nameconstraints::tc2102", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7243, 7244], leaf: 7242 }, + Case { id: "bettertls::nameconstraints::tc2103", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7246, 7247], leaf: 7245 }, + Case { id: "bettertls::nameconstraints::tc2104", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7249, 7250], leaf: 7248 }, + Case { id: "bettertls::nameconstraints::tc2105", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7252, 7253], leaf: 7251 }, + Case { id: "bettertls::nameconstraints::tc2106", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7255, 7256], leaf: 7254 }, + Case { id: "bettertls::nameconstraints::tc2107", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7258, 7259], leaf: 7257 }, + Case { id: "bettertls::nameconstraints::tc2108", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7261, 7262], leaf: 7260 }, + Case { id: "bettertls::nameconstraints::tc2109", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7264, 7265], leaf: 7263 }, + Case { id: "bettertls::nameconstraints::tc2110", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7267, 7268], leaf: 7266 }, + Case { id: "bettertls::nameconstraints::tc2111", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7270, 7271], leaf: 7269 }, + Case { id: "bettertls::nameconstraints::tc2112", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7273, 7274], leaf: 7272 }, + Case { id: "bettertls::nameconstraints::tc2113", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7276, 7277], leaf: 7275 }, + Case { id: "bettertls::nameconstraints::tc2114", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7279, 7280], leaf: 7278 }, + Case { id: "bettertls::nameconstraints::tc2115", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7282, 7283], leaf: 7281 }, + Case { id: "bettertls::nameconstraints::tc2116", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7285, 7286], leaf: 7284 }, + Case { id: "bettertls::nameconstraints::tc2117", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7288, 7289], leaf: 7287 }, + Case { id: "bettertls::nameconstraints::tc2118", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7291, 7292], leaf: 7290 }, + Case { id: "bettertls::nameconstraints::tc2119", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7294, 7295], leaf: 7293 }, + Case { id: "bettertls::nameconstraints::tc2120", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7297, 7298], leaf: 7296 }, + Case { id: "bettertls::nameconstraints::tc2121", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7300, 7301], leaf: 7299 }, + Case { id: "bettertls::nameconstraints::tc2122", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7303, 7304], leaf: 7302 }, + Case { id: "bettertls::nameconstraints::tc2123", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7306, 7307], leaf: 7305 }, + Case { id: "bettertls::nameconstraints::tc2124", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7309, 7310], leaf: 7308 }, + Case { id: "bettertls::nameconstraints::tc2125", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7312, 7313], leaf: 7311 }, + Case { id: "bettertls::nameconstraints::tc2126", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7315, 7316], leaf: 7314 }, + Case { id: "bettertls::nameconstraints::tc2127", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7318, 7319], leaf: 7317 }, + Case { id: "bettertls::nameconstraints::tc2128", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7321, 7322], leaf: 7320 }, + Case { id: "bettertls::nameconstraints::tc2129", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7324, 7325], leaf: 7323 }, + Case { id: "bettertls::nameconstraints::tc2130", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7327, 7328], leaf: 7326 }, + Case { id: "bettertls::nameconstraints::tc2131", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7330, 7331], leaf: 7329 }, + Case { id: "bettertls::nameconstraints::tc2132", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7333, 7334], leaf: 7332 }, + Case { id: "bettertls::nameconstraints::tc2133", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7336, 7337], leaf: 7335 }, + Case { id: "bettertls::nameconstraints::tc2134", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7339, 7340], leaf: 7338 }, + Case { id: "bettertls::nameconstraints::tc2135", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7342, 7343], leaf: 7341 }, + Case { id: "bettertls::nameconstraints::tc2136", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7345, 7346], leaf: 7344 }, + Case { id: "bettertls::nameconstraints::tc2137", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7348, 7349], leaf: 7347 }, + Case { id: "bettertls::nameconstraints::tc2138", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7351, 7352], leaf: 7350 }, + Case { id: "bettertls::nameconstraints::tc2139", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7354, 7355], leaf: 7353 }, + Case { id: "bettertls::nameconstraints::tc2140", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7357, 7358], leaf: 7356 }, + Case { id: "bettertls::nameconstraints::tc2141", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7360, 7361], leaf: 7359 }, + Case { id: "bettertls::nameconstraints::tc2142", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7363, 7364], leaf: 7362 }, + Case { id: "bettertls::nameconstraints::tc2143", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7366, 7367], leaf: 7365 }, + Case { id: "bettertls::nameconstraints::tc2144", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7369, 7370], leaf: 7368 }, + Case { id: "bettertls::nameconstraints::tc2145", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7372, 7373], leaf: 7371 }, + Case { id: "bettertls::nameconstraints::tc2146", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7375, 7376], leaf: 7374 }, + Case { id: "bettertls::nameconstraints::tc2147", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7378, 7379], leaf: 7377 }, + Case { id: "bettertls::nameconstraints::tc2148", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7381, 7382], leaf: 7380 }, + Case { id: "bettertls::nameconstraints::tc2149", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7384, 7385], leaf: 7383 }, + Case { id: "bettertls::nameconstraints::tc2150", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7387, 7388], leaf: 7386 }, + Case { id: "bettertls::nameconstraints::tc2151", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7390, 7391], leaf: 7389 }, + Case { id: "bettertls::nameconstraints::tc2152", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7393, 7394], leaf: 7392 }, + Case { id: "bettertls::nameconstraints::tc2153", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7396, 7397], leaf: 7395 }, + Case { id: "bettertls::nameconstraints::tc2154", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7399, 7400], leaf: 7398 }, + Case { id: "bettertls::nameconstraints::tc2155", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7402, 7403], leaf: 7401 }, + Case { id: "bettertls::nameconstraints::tc2156", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7405, 7406], leaf: 7404 }, + Case { id: "bettertls::nameconstraints::tc2157", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7408, 7409], leaf: 7407 }, + Case { id: "bettertls::nameconstraints::tc2158", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7411, 7412], leaf: 7410 }, + Case { id: "bettertls::nameconstraints::tc2159", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7414, 7415], leaf: 7413 }, + Case { id: "bettertls::nameconstraints::tc2160", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7417, 7418], leaf: 7416 }, + Case { id: "bettertls::nameconstraints::tc2161", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7420, 7421], leaf: 7419 }, + Case { id: "bettertls::nameconstraints::tc2162", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7423, 7424], leaf: 7422 }, + Case { id: "bettertls::nameconstraints::tc2163", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7426, 7427], leaf: 7425 }, + Case { id: "bettertls::nameconstraints::tc2164", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7429, 7430], leaf: 7428 }, + Case { id: "bettertls::nameconstraints::tc2165", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7432, 7433], leaf: 7431 }, + Case { id: "bettertls::nameconstraints::tc2166", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7435, 7436], leaf: 7434 }, + Case { id: "bettertls::nameconstraints::tc2167", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7438, 7439], leaf: 7437 }, + Case { id: "bettertls::nameconstraints::tc2168", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7441, 7442], leaf: 7440 }, + Case { id: "bettertls::nameconstraints::tc2169", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7444, 7445], leaf: 7443 }, + Case { id: "bettertls::nameconstraints::tc2170", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7447, 7448], leaf: 7446 }, + Case { id: "bettertls::nameconstraints::tc2171", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7450, 7451], leaf: 7449 }, + Case { id: "bettertls::nameconstraints::tc2172", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7453, 7454], leaf: 7452 }, + Case { id: "bettertls::nameconstraints::tc2173", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7456, 7457], leaf: 7455 }, + Case { id: "bettertls::nameconstraints::tc2174", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7459, 7460], leaf: 7458 }, + Case { id: "bettertls::nameconstraints::tc2175", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7462, 7463], leaf: 7461 }, + Case { id: "bettertls::nameconstraints::tc2176", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7465, 7466], leaf: 7464 }, + Case { id: "bettertls::nameconstraints::tc2177", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7468, 7469], leaf: 7467 }, + Case { id: "bettertls::nameconstraints::tc2178", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7471, 7472], leaf: 7470 }, + Case { id: "bettertls::nameconstraints::tc2179", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7474, 7475], leaf: 7473 }, + Case { id: "bettertls::nameconstraints::tc2180", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7477, 7478], leaf: 7476 }, + Case { id: "bettertls::nameconstraints::tc2181", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7480, 7481], leaf: 7479 }, + Case { id: "bettertls::nameconstraints::tc2182", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7483, 7484], leaf: 7482 }, + Case { id: "bettertls::nameconstraints::tc2183", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7486, 7487], leaf: 7485 }, + Case { id: "bettertls::nameconstraints::tc2184", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7489, 7490], leaf: 7488 }, + Case { id: "bettertls::nameconstraints::tc2185", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7492, 7493], leaf: 7491 }, + Case { id: "bettertls::nameconstraints::tc2186", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7495, 7496], leaf: 7494 }, + Case { id: "bettertls::nameconstraints::tc2187", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7498, 7499], leaf: 7497 }, + Case { id: "bettertls::nameconstraints::tc2188", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7501, 7502], leaf: 7500 }, + Case { id: "bettertls::nameconstraints::tc2189", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7504, 7505], leaf: 7503 }, + Case { id: "bettertls::nameconstraints::tc2190", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7507, 7508], leaf: 7506 }, + Case { id: "bettertls::nameconstraints::tc2191", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7510, 7511], leaf: 7509 }, + Case { id: "bettertls::nameconstraints::tc2192", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7513, 7514], leaf: 7512 }, + Case { id: "bettertls::nameconstraints::tc2193", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7516, 7517], leaf: 7515 }, + Case { id: "bettertls::nameconstraints::tc2194", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7519, 7520], leaf: 7518 }, + Case { id: "bettertls::nameconstraints::tc2195", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7522, 7523], leaf: 7521 }, + Case { id: "bettertls::nameconstraints::tc2196", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7525, 7526], leaf: 7524 }, + Case { id: "bettertls::nameconstraints::tc2197", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7528, 7529], leaf: 7527 }, + Case { id: "bettertls::nameconstraints::tc2198", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7531, 7532], leaf: 7530 }, + Case { id: "bettertls::nameconstraints::tc2199", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7534, 7535], leaf: 7533 }, + Case { id: "bettertls::nameconstraints::tc2200", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7537, 7538], leaf: 7536 }, + Case { id: "bettertls::nameconstraints::tc2201", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7540, 7541], leaf: 7539 }, + Case { id: "bettertls::nameconstraints::tc2202", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7543, 7544], leaf: 7542 }, + Case { id: "bettertls::nameconstraints::tc2203", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7546, 7547], leaf: 7545 }, + Case { id: "bettertls::nameconstraints::tc2204", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7549, 7550], leaf: 7548 }, + Case { id: "bettertls::nameconstraints::tc2205", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7552, 7553], leaf: 7551 }, + Case { id: "bettertls::nameconstraints::tc2206", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7555, 7556], leaf: 7554 }, + Case { id: "bettertls::nameconstraints::tc2207", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7558, 7559], leaf: 7557 }, + Case { id: "bettertls::nameconstraints::tc2208", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7561, 7562], leaf: 7560 }, + Case { id: "bettertls::nameconstraints::tc2209", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7564, 7565], leaf: 7563 }, + Case { id: "bettertls::nameconstraints::tc2210", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7567, 7568], leaf: 7566 }, + Case { id: "bettertls::nameconstraints::tc2211", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7570, 7571], leaf: 7569 }, + Case { id: "bettertls::nameconstraints::tc2212", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7573, 7574], leaf: 7572 }, + Case { id: "bettertls::nameconstraints::tc2213", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7576, 7577], leaf: 7575 }, + Case { id: "bettertls::nameconstraints::tc2214", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7579, 7580], leaf: 7578 }, + Case { id: "bettertls::nameconstraints::tc2215", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7582, 7583], leaf: 7581 }, + Case { id: "bettertls::nameconstraints::tc2216", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7585, 7586], leaf: 7584 }, + Case { id: "bettertls::nameconstraints::tc2217", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7588, 7589], leaf: 7587 }, + Case { id: "bettertls::nameconstraints::tc2218", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7591, 7592], leaf: 7590 }, + Case { id: "bettertls::nameconstraints::tc2219", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7594, 7595], leaf: 7593 }, + Case { id: "bettertls::nameconstraints::tc2220", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7597, 7598], leaf: 7596 }, + Case { id: "bettertls::nameconstraints::tc2221", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7600, 7601], leaf: 7599 }, + Case { id: "bettertls::nameconstraints::tc2222", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7603, 7604], leaf: 7602 }, + Case { id: "bettertls::nameconstraints::tc2223", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7606, 7607], leaf: 7605 }, + Case { id: "bettertls::nameconstraints::tc2224", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7609, 7610], leaf: 7608 }, + Case { id: "bettertls::nameconstraints::tc2225", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7612, 7613], leaf: 7611 }, + Case { id: "bettertls::nameconstraints::tc2226", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7615, 7616], leaf: 7614 }, + Case { id: "bettertls::nameconstraints::tc2227", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7618, 7619], leaf: 7617 }, + Case { id: "bettertls::nameconstraints::tc2228", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7621, 7622], leaf: 7620 }, + Case { id: "bettertls::nameconstraints::tc2229", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7624, 7625], leaf: 7623 }, + Case { id: "bettertls::nameconstraints::tc2230", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7627, 7628], leaf: 7626 }, + Case { id: "bettertls::nameconstraints::tc2231", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7630, 7631], leaf: 7629 }, + Case { id: "bettertls::nameconstraints::tc2232", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7633, 7634], leaf: 7632 }, + Case { id: "bettertls::nameconstraints::tc2233", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7636, 7637], leaf: 7635 }, + Case { id: "bettertls::nameconstraints::tc2234", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7639, 7640], leaf: 7638 }, + Case { id: "bettertls::nameconstraints::tc2235", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7642, 7643], leaf: 7641 }, + Case { id: "bettertls::nameconstraints::tc2236", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7645, 7646], leaf: 7644 }, + Case { id: "bettertls::nameconstraints::tc2237", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7648, 7649], leaf: 7647 }, + Case { id: "bettertls::nameconstraints::tc2238", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7651, 7652], leaf: 7650 }, + Case { id: "bettertls::nameconstraints::tc2239", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7654, 7655], leaf: 7653 }, + Case { id: "bettertls::nameconstraints::tc2240", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7657, 7658], leaf: 7656 }, + Case { id: "bettertls::nameconstraints::tc2241", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7660, 7661], leaf: 7659 }, + Case { id: "bettertls::nameconstraints::tc2242", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7663, 7664], leaf: 7662 }, + Case { id: "bettertls::nameconstraints::tc2243", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7666, 7667], leaf: 7665 }, + Case { id: "bettertls::nameconstraints::tc2244", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7669, 7670], leaf: 7668 }, + Case { id: "bettertls::nameconstraints::tc2245", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7672, 7673], leaf: 7671 }, + Case { id: "bettertls::nameconstraints::tc2246", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7675, 7676], leaf: 7674 }, + Case { id: "bettertls::nameconstraints::tc2247", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7678, 7679], leaf: 7677 }, + Case { id: "bettertls::nameconstraints::tc2248", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7681, 7682], leaf: 7680 }, + Case { id: "bettertls::nameconstraints::tc2249", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7684, 7685], leaf: 7683 }, + Case { id: "bettertls::nameconstraints::tc2250", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7687, 7688], leaf: 7686 }, + Case { id: "bettertls::nameconstraints::tc2251", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7690, 7691], leaf: 7689 }, + Case { id: "bettertls::nameconstraints::tc2252", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7693, 7694], leaf: 7692 }, + Case { id: "bettertls::nameconstraints::tc2253", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7696, 7697], leaf: 7695 }, + Case { id: "bettertls::nameconstraints::tc2254", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7699, 7700], leaf: 7698 }, + Case { id: "bettertls::nameconstraints::tc2255", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7702, 7703], leaf: 7701 }, + Case { id: "bettertls::nameconstraints::tc2256", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7705, 7706], leaf: 7704 }, + Case { id: "bettertls::nameconstraints::tc2257", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7708, 7709], leaf: 7707 }, + Case { id: "bettertls::nameconstraints::tc2258", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7711, 7712], leaf: 7710 }, + Case { id: "bettertls::nameconstraints::tc2259", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7714, 7715], leaf: 7713 }, + Case { id: "bettertls::nameconstraints::tc2260", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7717, 7718], leaf: 7716 }, + Case { id: "bettertls::nameconstraints::tc2261", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7720, 7721], leaf: 7719 }, + Case { id: "bettertls::nameconstraints::tc2262", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7723, 7724], leaf: 7722 }, + Case { id: "bettertls::nameconstraints::tc2263", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7726, 7727], leaf: 7725 }, + Case { id: "bettertls::nameconstraints::tc2264", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7729, 7730], leaf: 7728 }, + Case { id: "bettertls::nameconstraints::tc2265", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7732, 7733], leaf: 7731 }, + Case { id: "bettertls::nameconstraints::tc2266", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7735, 7736], leaf: 7734 }, + Case { id: "bettertls::nameconstraints::tc2267", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7738, 7739], leaf: 7737 }, + Case { id: "bettertls::nameconstraints::tc2268", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7741, 7742], leaf: 7740 }, + Case { id: "bettertls::nameconstraints::tc2269", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7744, 7745], leaf: 7743 }, + Case { id: "bettertls::nameconstraints::tc2270", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7747, 7748], leaf: 7746 }, + Case { id: "bettertls::nameconstraints::tc2271", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7750, 7751], leaf: 7749 }, + Case { id: "bettertls::nameconstraints::tc2272", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7753, 7754], leaf: 7752 }, + Case { id: "bettertls::nameconstraints::tc2273", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7756, 7757], leaf: 7755 }, + Case { id: "bettertls::nameconstraints::tc2274", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7759, 7760], leaf: 7758 }, + Case { id: "bettertls::nameconstraints::tc2275", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7762, 7763], leaf: 7761 }, + Case { id: "bettertls::nameconstraints::tc2276", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7765, 7766], leaf: 7764 }, + Case { id: "bettertls::nameconstraints::tc2277", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7768, 7769], leaf: 7767 }, + Case { id: "bettertls::nameconstraints::tc2278", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7771, 7772], leaf: 7770 }, + Case { id: "bettertls::nameconstraints::tc2279", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7774, 7775], leaf: 7773 }, + Case { id: "bettertls::nameconstraints::tc2280", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7777, 7778], leaf: 7776 }, + Case { id: "bettertls::nameconstraints::tc2281", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7780, 7781], leaf: 7779 }, + Case { id: "bettertls::nameconstraints::tc2282", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7783, 7784], leaf: 7782 }, + Case { id: "bettertls::nameconstraints::tc2283", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7786, 7787], leaf: 7785 }, + Case { id: "bettertls::nameconstraints::tc2284", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7789, 7790], leaf: 7788 }, + Case { id: "bettertls::nameconstraints::tc2285", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7792, 7793], leaf: 7791 }, + Case { id: "bettertls::nameconstraints::tc2286", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7795, 7796], leaf: 7794 }, + Case { id: "bettertls::nameconstraints::tc2287", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7798, 7799], leaf: 7797 }, + Case { id: "bettertls::nameconstraints::tc2288", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7801, 7802], leaf: 7800 }, + Case { id: "bettertls::nameconstraints::tc2289", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7804, 7805], leaf: 7803 }, + Case { id: "bettertls::nameconstraints::tc2290", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7807, 7808], leaf: 7806 }, + Case { id: "bettertls::nameconstraints::tc2291", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7810, 7811], leaf: 7809 }, + Case { id: "bettertls::nameconstraints::tc2292", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7813, 7814], leaf: 7812 }, + Case { id: "bettertls::nameconstraints::tc2293", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7816, 7817], leaf: 7815 }, + Case { id: "bettertls::nameconstraints::tc2294", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7819, 7820], leaf: 7818 }, + Case { id: "bettertls::nameconstraints::tc2295", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7822, 7823], leaf: 7821 }, + Case { id: "bettertls::nameconstraints::tc2296", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7825, 7826], leaf: 7824 }, + Case { id: "bettertls::nameconstraints::tc2297", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7828, 7829], leaf: 7827 }, + Case { id: "bettertls::nameconstraints::tc2298", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7831, 7832], leaf: 7830 }, + Case { id: "bettertls::nameconstraints::tc2299", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7834, 7835], leaf: 7833 }, + Case { id: "bettertls::nameconstraints::tc2300", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7837, 7838], leaf: 7836 }, + Case { id: "bettertls::nameconstraints::tc2301", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7840, 7841], leaf: 7839 }, + Case { id: "bettertls::nameconstraints::tc2302", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7843, 7844], leaf: 7842 }, + Case { id: "bettertls::nameconstraints::tc2303", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7846, 7847], leaf: 7845 }, + Case { id: "bettertls::nameconstraints::tc2304", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7849, 7850], leaf: 7848 }, + Case { id: "bettertls::nameconstraints::tc2305", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7852, 7853], leaf: 7851 }, + Case { id: "bettertls::nameconstraints::tc2306", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7855, 7856], leaf: 7854 }, + Case { id: "bettertls::nameconstraints::tc2307", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7858, 7859], leaf: 7857 }, + Case { id: "bettertls::nameconstraints::tc2308", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7861, 7862], leaf: 7860 }, + Case { id: "bettertls::nameconstraints::tc2309", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7864, 7865], leaf: 7863 }, + Case { id: "bettertls::nameconstraints::tc2310", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7867, 7868], leaf: 7866 }, + Case { id: "bettertls::nameconstraints::tc2311", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7870, 7871], leaf: 7869 }, + Case { id: "bettertls::nameconstraints::tc2312", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7873, 7874], leaf: 7872 }, + Case { id: "bettertls::nameconstraints::tc2313", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7876, 7877], leaf: 7875 }, + Case { id: "bettertls::nameconstraints::tc2314", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7879, 7880], leaf: 7878 }, + Case { id: "bettertls::nameconstraints::tc2315", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7882, 7883], leaf: 7881 }, + Case { id: "bettertls::nameconstraints::tc2316", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7885, 7886], leaf: 7884 }, + Case { id: "bettertls::nameconstraints::tc2317", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7888, 7889], leaf: 7887 }, + Case { id: "bettertls::nameconstraints::tc2318", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7891, 7892], leaf: 7890 }, + Case { id: "bettertls::nameconstraints::tc2319", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7894, 7895], leaf: 7893 }, + Case { id: "bettertls::nameconstraints::tc2320", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7897, 7898], leaf: 7896 }, + Case { id: "bettertls::nameconstraints::tc2321", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7900, 7901], leaf: 7899 }, + Case { id: "bettertls::nameconstraints::tc2322", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7903, 7904], leaf: 7902 }, + Case { id: "bettertls::nameconstraints::tc2323", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7906, 7907], leaf: 7905 }, + Case { id: "bettertls::nameconstraints::tc2324", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7909, 7910], leaf: 7908 }, + Case { id: "bettertls::nameconstraints::tc2325", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7912, 7913], leaf: 7911 }, + Case { id: "bettertls::nameconstraints::tc2326", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7915, 7916], leaf: 7914 }, + Case { id: "bettertls::nameconstraints::tc2327", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7918, 7919], leaf: 7917 }, + Case { id: "bettertls::nameconstraints::tc2328", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7921, 7922], leaf: 7920 }, + Case { id: "bettertls::nameconstraints::tc2329", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7924, 7925], leaf: 7923 }, + Case { id: "bettertls::nameconstraints::tc2330", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7927, 7928], leaf: 7926 }, + Case { id: "bettertls::nameconstraints::tc2331", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7930, 7931], leaf: 7929 }, + Case { id: "bettertls::nameconstraints::tc2332", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7933, 7934], leaf: 7932 }, + Case { id: "bettertls::nameconstraints::tc2333", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7936, 7937], leaf: 7935 }, + Case { id: "bettertls::nameconstraints::tc2334", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7939, 7940], leaf: 7938 }, + Case { id: "bettertls::nameconstraints::tc2335", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7942, 7943], leaf: 7941 }, + Case { id: "bettertls::nameconstraints::tc2336", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7945, 7946], leaf: 7944 }, + Case { id: "bettertls::nameconstraints::tc2337", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7948, 7949], leaf: 7947 }, + Case { id: "bettertls::nameconstraints::tc2338", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7951, 7952], leaf: 7950 }, + Case { id: "bettertls::nameconstraints::tc2339", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7954, 7955], leaf: 7953 }, + Case { id: "bettertls::nameconstraints::tc2340", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7957, 7958], leaf: 7956 }, + Case { id: "bettertls::nameconstraints::tc2341", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7960, 7961], leaf: 7959 }, + Case { id: "bettertls::nameconstraints::tc2342", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7963, 7964], leaf: 7962 }, + Case { id: "bettertls::nameconstraints::tc2343", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7966, 7967], leaf: 7965 }, + Case { id: "bettertls::nameconstraints::tc2344", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7969, 7970], leaf: 7968 }, + Case { id: "bettertls::nameconstraints::tc2345", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7972, 7973], leaf: 7971 }, + Case { id: "bettertls::nameconstraints::tc2346", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7975, 7976], leaf: 7974 }, + Case { id: "bettertls::nameconstraints::tc2347", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7978, 7979], leaf: 7977 }, + Case { id: "bettertls::nameconstraints::tc2348", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7981, 7982], leaf: 7980 }, + Case { id: "bettertls::nameconstraints::tc2349", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7984, 7985], leaf: 7983 }, + Case { id: "bettertls::nameconstraints::tc2350", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7987, 7988], leaf: 7986 }, + Case { id: "bettertls::nameconstraints::tc2351", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7990, 7991], leaf: 7989 }, + Case { id: "bettertls::nameconstraints::tc2352", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7993, 7994], leaf: 7992 }, + Case { id: "bettertls::nameconstraints::tc2353", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7996, 7997], leaf: 7995 }, + Case { id: "bettertls::nameconstraints::tc2354", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[7999, 8000], leaf: 7998 }, + Case { id: "bettertls::nameconstraints::tc2355", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8002, 8003], leaf: 8001 }, + Case { id: "bettertls::nameconstraints::tc2356", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8005, 8006], leaf: 8004 }, + Case { id: "bettertls::nameconstraints::tc2357", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8008, 8009], leaf: 8007 }, + Case { id: "bettertls::nameconstraints::tc2358", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8011, 8012], leaf: 8010 }, + Case { id: "bettertls::nameconstraints::tc2359", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8014, 8015], leaf: 8013 }, + Case { id: "bettertls::nameconstraints::tc2360", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8017, 8018], leaf: 8016 }, + Case { id: "bettertls::nameconstraints::tc2361", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8020, 8021], leaf: 8019 }, + Case { id: "bettertls::nameconstraints::tc2362", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8023, 8024], leaf: 8022 }, + Case { id: "bettertls::nameconstraints::tc2363", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8026, 8027], leaf: 8025 }, + Case { id: "bettertls::nameconstraints::tc2364", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8029, 8030], leaf: 8028 }, + Case { id: "bettertls::nameconstraints::tc2365", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8032, 8033], leaf: 8031 }, + Case { id: "bettertls::nameconstraints::tc2366", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8035, 8036], leaf: 8034 }, + Case { id: "bettertls::nameconstraints::tc2367", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8038, 8039], leaf: 8037 }, + Case { id: "bettertls::nameconstraints::tc2368", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8041, 8042], leaf: 8040 }, + Case { id: "bettertls::nameconstraints::tc2369", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8044, 8045], leaf: 8043 }, + Case { id: "bettertls::nameconstraints::tc2370", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8047, 8048], leaf: 8046 }, + Case { id: "bettertls::nameconstraints::tc2371", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8050, 8051], leaf: 8049 }, + Case { id: "bettertls::nameconstraints::tc2372", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8053, 8054], leaf: 8052 }, + Case { id: "bettertls::nameconstraints::tc2373", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8056, 8057], leaf: 8055 }, + Case { id: "bettertls::nameconstraints::tc2374", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8059, 8060], leaf: 8058 }, + Case { id: "bettertls::nameconstraints::tc2375", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8062, 8063], leaf: 8061 }, + Case { id: "bettertls::nameconstraints::tc2376", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8065, 8066], leaf: 8064 }, + Case { id: "bettertls::nameconstraints::tc2377", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8068, 8069], leaf: 8067 }, + Case { id: "bettertls::nameconstraints::tc2378", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8071, 8072], leaf: 8070 }, + Case { id: "bettertls::nameconstraints::tc2379", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8074, 8075], leaf: 8073 }, + Case { id: "bettertls::nameconstraints::tc2380", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8077, 8078], leaf: 8076 }, + Case { id: "bettertls::nameconstraints::tc2381", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8080, 8081], leaf: 8079 }, + Case { id: "bettertls::nameconstraints::tc2382", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8083, 8084], leaf: 8082 }, + Case { id: "bettertls::nameconstraints::tc2383", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8086, 8087], leaf: 8085 }, + Case { id: "bettertls::nameconstraints::tc2384", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8089, 8090], leaf: 8088 }, + Case { id: "bettertls::nameconstraints::tc2385", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8092, 8093], leaf: 8091 }, + Case { id: "bettertls::nameconstraints::tc2386", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8095, 8096], leaf: 8094 }, + Case { id: "bettertls::nameconstraints::tc2387", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8098, 8099], leaf: 8097 }, + Case { id: "bettertls::nameconstraints::tc2388", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8101, 8102], leaf: 8100 }, + Case { id: "bettertls::nameconstraints::tc2389", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8104, 8105], leaf: 8103 }, + Case { id: "bettertls::nameconstraints::tc2390", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8107, 8108], leaf: 8106 }, + Case { id: "bettertls::nameconstraints::tc2391", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8110, 8111], leaf: 8109 }, + Case { id: "bettertls::nameconstraints::tc2392", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8113, 8114], leaf: 8112 }, + Case { id: "bettertls::nameconstraints::tc2393", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8116, 8117], leaf: 8115 }, + Case { id: "bettertls::nameconstraints::tc2394", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8119, 8120], leaf: 8118 }, + Case { id: "bettertls::nameconstraints::tc2395", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8122, 8123], leaf: 8121 }, + Case { id: "bettertls::nameconstraints::tc2396", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8125, 8126], leaf: 8124 }, + Case { id: "bettertls::nameconstraints::tc2397", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8128, 8129], leaf: 8127 }, + Case { id: "bettertls::nameconstraints::tc2398", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8131, 8132], leaf: 8130 }, + Case { id: "bettertls::nameconstraints::tc2399", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8134, 8135], leaf: 8133 }, + Case { id: "bettertls::nameconstraints::tc2400", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8137, 8138], leaf: 8136 }, + Case { id: "bettertls::nameconstraints::tc2401", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8140, 8141], leaf: 8139 }, + Case { id: "bettertls::nameconstraints::tc2402", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8143, 8144], leaf: 8142 }, + Case { id: "bettertls::nameconstraints::tc2403", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8146, 8147], leaf: 8145 }, + Case { id: "bettertls::nameconstraints::tc2404", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8149, 8150], leaf: 8148 }, + Case { id: "bettertls::nameconstraints::tc2405", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8152, 8153], leaf: 8151 }, + Case { id: "bettertls::nameconstraints::tc2406", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8155, 8156], leaf: 8154 }, + Case { id: "bettertls::nameconstraints::tc2407", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8158, 8159], leaf: 8157 }, + Case { id: "bettertls::nameconstraints::tc2408", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8161, 8162], leaf: 8160 }, + Case { id: "bettertls::nameconstraints::tc2409", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8164, 8165], leaf: 8163 }, + Case { id: "bettertls::nameconstraints::tc2410", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8167, 8168], leaf: 8166 }, + Case { id: "bettertls::nameconstraints::tc2411", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8170, 8171], leaf: 8169 }, + Case { id: "bettertls::nameconstraints::tc2412", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8173, 8174], leaf: 8172 }, + Case { id: "bettertls::nameconstraints::tc2413", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8176, 8177], leaf: 8175 }, + Case { id: "bettertls::nameconstraints::tc2414", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8179, 8180], leaf: 8178 }, + Case { id: "bettertls::nameconstraints::tc2415", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8182, 8183], leaf: 8181 }, + Case { id: "bettertls::nameconstraints::tc2416", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8185, 8186], leaf: 8184 }, + Case { id: "bettertls::nameconstraints::tc2417", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8188, 8189], leaf: 8187 }, + Case { id: "bettertls::nameconstraints::tc2418", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8191, 8192], leaf: 8190 }, + Case { id: "bettertls::nameconstraints::tc2419", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8194, 8195], leaf: 8193 }, + Case { id: "bettertls::nameconstraints::tc2420", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8197, 8198], leaf: 8196 }, + Case { id: "bettertls::nameconstraints::tc2421", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8200, 8201], leaf: 8199 }, + Case { id: "bettertls::nameconstraints::tc2422", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8203, 8204], leaf: 8202 }, + Case { id: "bettertls::nameconstraints::tc2423", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8206, 8207], leaf: 8205 }, + Case { id: "bettertls::nameconstraints::tc2424", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8209, 8210], leaf: 8208 }, + Case { id: "bettertls::nameconstraints::tc2425", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8212, 8213], leaf: 8211 }, + Case { id: "bettertls::nameconstraints::tc2426", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8215, 8216], leaf: 8214 }, + Case { id: "bettertls::nameconstraints::tc2427", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8218, 8219], leaf: 8217 }, + Case { id: "bettertls::nameconstraints::tc2428", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8221, 8222], leaf: 8220 }, + Case { id: "bettertls::nameconstraints::tc2429", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8224, 8225], leaf: 8223 }, + Case { id: "bettertls::nameconstraints::tc2430", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8227, 8228], leaf: 8226 }, + Case { id: "bettertls::nameconstraints::tc2431", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8230, 8231], leaf: 8229 }, + Case { id: "bettertls::nameconstraints::tc2432", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8233, 8234], leaf: 8232 }, + Case { id: "bettertls::nameconstraints::tc2433", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8236, 8237], leaf: 8235 }, + Case { id: "bettertls::nameconstraints::tc2434", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8239, 8240], leaf: 8238 }, + Case { id: "bettertls::nameconstraints::tc2435", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8242, 8243], leaf: 8241 }, + Case { id: "bettertls::nameconstraints::tc2436", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8245, 8246], leaf: 8244 }, + Case { id: "bettertls::nameconstraints::tc2437", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8248, 8249], leaf: 8247 }, + Case { id: "bettertls::nameconstraints::tc2438", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8251, 8252], leaf: 8250 }, + Case { id: "bettertls::nameconstraints::tc2439", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8254, 8255], leaf: 8253 }, + Case { id: "bettertls::nameconstraints::tc2440", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8257, 8258], leaf: 8256 }, + Case { id: "bettertls::nameconstraints::tc2441", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8260, 8261], leaf: 8259 }, + Case { id: "bettertls::nameconstraints::tc2442", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8263, 8264], leaf: 8262 }, + Case { id: "bettertls::nameconstraints::tc2443", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8266, 8267], leaf: 8265 }, + Case { id: "bettertls::nameconstraints::tc2444", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8269, 8270], leaf: 8268 }, + Case { id: "bettertls::nameconstraints::tc2445", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8272, 8273], leaf: 8271 }, + Case { id: "bettertls::nameconstraints::tc2446", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8275, 8276], leaf: 8274 }, + Case { id: "bettertls::nameconstraints::tc2447", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8278, 8279], leaf: 8277 }, + Case { id: "bettertls::nameconstraints::tc2448", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8281, 8282], leaf: 8280 }, + Case { id: "bettertls::nameconstraints::tc2449", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8284, 8285], leaf: 8283 }, + Case { id: "bettertls::nameconstraints::tc2450", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8287, 8288], leaf: 8286 }, + Case { id: "bettertls::nameconstraints::tc2451", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8290, 8291], leaf: 8289 }, + Case { id: "bettertls::nameconstraints::tc2452", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8293, 8294], leaf: 8292 }, + Case { id: "bettertls::nameconstraints::tc2453", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8296, 8297], leaf: 8295 }, + Case { id: "bettertls::nameconstraints::tc2454", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8299, 8300], leaf: 8298 }, + Case { id: "bettertls::nameconstraints::tc2455", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8302, 8303], leaf: 8301 }, + Case { id: "bettertls::nameconstraints::tc2456", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8305, 8306], leaf: 8304 }, + Case { id: "bettertls::nameconstraints::tc2457", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8308, 8309], leaf: 8307 }, + Case { id: "bettertls::nameconstraints::tc2458", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8311, 8312], leaf: 8310 }, + Case { id: "bettertls::nameconstraints::tc2459", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8314, 8315], leaf: 8313 }, + Case { id: "bettertls::nameconstraints::tc2460", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8317, 8318], leaf: 8316 }, + Case { id: "bettertls::nameconstraints::tc2461", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8320, 8321], leaf: 8319 }, + Case { id: "bettertls::nameconstraints::tc2462", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8323, 8324], leaf: 8322 }, + Case { id: "bettertls::nameconstraints::tc2463", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8326, 8327], leaf: 8325 }, + Case { id: "bettertls::nameconstraints::tc2464", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8329, 8330], leaf: 8328 }, + Case { id: "bettertls::nameconstraints::tc2465", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8332, 8333], leaf: 8331 }, + Case { id: "bettertls::nameconstraints::tc2466", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8335, 8336], leaf: 8334 }, + Case { id: "bettertls::nameconstraints::tc2467", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8338, 8339], leaf: 8337 }, + Case { id: "bettertls::nameconstraints::tc2468", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8341, 8342], leaf: 8340 }, + Case { id: "bettertls::nameconstraints::tc2469", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8344, 8345], leaf: 8343 }, + Case { id: "bettertls::nameconstraints::tc2470", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8347, 8348], leaf: 8346 }, + Case { id: "bettertls::nameconstraints::tc2471", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8350, 8351], leaf: 8349 }, + Case { id: "bettertls::nameconstraints::tc2472", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8353, 8354], leaf: 8352 }, + Case { id: "bettertls::nameconstraints::tc2473", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8356, 8357], leaf: 8355 }, + Case { id: "bettertls::nameconstraints::tc2474", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8359, 8360], leaf: 8358 }, + Case { id: "bettertls::nameconstraints::tc2475", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8362, 8363], leaf: 8361 }, + Case { id: "bettertls::nameconstraints::tc2476", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8365, 8366], leaf: 8364 }, + Case { id: "bettertls::nameconstraints::tc2477", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8368, 8369], leaf: 8367 }, + Case { id: "bettertls::nameconstraints::tc2478", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8371, 8372], leaf: 8370 }, + Case { id: "bettertls::nameconstraints::tc2479", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8374, 8375], leaf: 8373 }, + Case { id: "bettertls::nameconstraints::tc2480", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8377, 8378], leaf: 8376 }, + Case { id: "bettertls::nameconstraints::tc2481", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8380, 8381], leaf: 8379 }, + Case { id: "bettertls::nameconstraints::tc2482", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8383, 8384], leaf: 8382 }, + Case { id: "bettertls::nameconstraints::tc2483", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8386, 8387], leaf: 8385 }, + Case { id: "bettertls::nameconstraints::tc2484", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8389, 8390], leaf: 8388 }, + Case { id: "bettertls::nameconstraints::tc2485", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8392, 8393], leaf: 8391 }, + Case { id: "bettertls::nameconstraints::tc2486", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8395, 8396], leaf: 8394 }, + Case { id: "bettertls::nameconstraints::tc2487", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8398, 8399], leaf: 8397 }, + Case { id: "bettertls::nameconstraints::tc2488", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8401, 8402], leaf: 8400 }, + Case { id: "bettertls::nameconstraints::tc2489", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8404, 8405], leaf: 8403 }, + Case { id: "bettertls::nameconstraints::tc2490", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8407, 8408], leaf: 8406 }, + Case { id: "bettertls::nameconstraints::tc2491", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8410, 8411], leaf: 8409 }, + Case { id: "bettertls::nameconstraints::tc2492", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8413, 8414], leaf: 8412 }, + Case { id: "bettertls::nameconstraints::tc2493", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8416, 8417], leaf: 8415 }, + Case { id: "bettertls::nameconstraints::tc2494", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8419, 8420], leaf: 8418 }, + Case { id: "bettertls::nameconstraints::tc2495", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8422, 8423], leaf: 8421 }, + Case { id: "bettertls::nameconstraints::tc2496", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8425, 8426], leaf: 8424 }, + Case { id: "bettertls::nameconstraints::tc2497", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8428, 8429], leaf: 8427 }, + Case { id: "bettertls::nameconstraints::tc2498", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8431, 8432], leaf: 8430 }, + Case { id: "bettertls::nameconstraints::tc2499", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8434, 8435], leaf: 8433 }, + Case { id: "bettertls::nameconstraints::tc2500", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8437, 8438], leaf: 8436 }, + Case { id: "bettertls::nameconstraints::tc2501", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8440, 8441], leaf: 8439 }, + Case { id: "bettertls::nameconstraints::tc2502", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8443, 8444], leaf: 8442 }, + Case { id: "bettertls::nameconstraints::tc2503", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8446, 8447], leaf: 8445 }, + Case { id: "bettertls::nameconstraints::tc2504", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8449, 8450], leaf: 8448 }, + Case { id: "bettertls::nameconstraints::tc2505", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8452, 8453], leaf: 8451 }, + Case { id: "bettertls::nameconstraints::tc2506", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8455, 8456], leaf: 8454 }, + Case { id: "bettertls::nameconstraints::tc2507", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8458, 8459], leaf: 8457 }, + Case { id: "bettertls::nameconstraints::tc2508", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8461, 8462], leaf: 8460 }, + Case { id: "bettertls::nameconstraints::tc2509", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8464, 8465], leaf: 8463 }, + Case { id: "bettertls::nameconstraints::tc2510", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8467, 8468], leaf: 8466 }, + Case { id: "bettertls::nameconstraints::tc2511", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8470, 8471], leaf: 8469 }, + Case { id: "bettertls::nameconstraints::tc2512", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8473, 8474], leaf: 8472 }, + Case { id: "bettertls::nameconstraints::tc2513", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8476, 8477], leaf: 8475 }, + Case { id: "bettertls::nameconstraints::tc2514", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8479, 8480], leaf: 8478 }, + Case { id: "bettertls::nameconstraints::tc2515", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8482, 8483], leaf: 8481 }, + Case { id: "bettertls::nameconstraints::tc2516", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8485, 8486], leaf: 8484 }, + Case { id: "bettertls::nameconstraints::tc2517", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8488, 8489], leaf: 8487 }, + Case { id: "bettertls::nameconstraints::tc2518", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8491, 8492], leaf: 8490 }, + Case { id: "bettertls::nameconstraints::tc2519", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8494, 8495], leaf: 8493 }, + Case { id: "bettertls::nameconstraints::tc2520", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8497, 8498], leaf: 8496 }, + Case { id: "bettertls::nameconstraints::tc2521", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8500, 8501], leaf: 8499 }, + Case { id: "bettertls::nameconstraints::tc2522", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8503, 8504], leaf: 8502 }, + Case { id: "bettertls::nameconstraints::tc2523", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8506, 8507], leaf: 8505 }, + Case { id: "bettertls::nameconstraints::tc2524", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8509, 8510], leaf: 8508 }, + Case { id: "bettertls::nameconstraints::tc2525", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8512, 8513], leaf: 8511 }, + Case { id: "bettertls::nameconstraints::tc2526", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8515, 8516], leaf: 8514 }, + Case { id: "bettertls::nameconstraints::tc2527", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8518, 8519], leaf: 8517 }, + Case { id: "bettertls::nameconstraints::tc2528", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8521, 8522], leaf: 8520 }, + Case { id: "bettertls::nameconstraints::tc2529", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8524, 8525], leaf: 8523 }, + Case { id: "bettertls::nameconstraints::tc2530", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8527, 8528], leaf: 8526 }, + Case { id: "bettertls::nameconstraints::tc2531", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8530, 8531], leaf: 8529 }, + Case { id: "bettertls::nameconstraints::tc2532", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8533, 8534], leaf: 8532 }, + Case { id: "bettertls::nameconstraints::tc2533", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8536, 8537], leaf: 8535 }, + Case { id: "bettertls::nameconstraints::tc2534", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8539, 8540], leaf: 8538 }, + Case { id: "bettertls::nameconstraints::tc2535", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8542, 8543], leaf: 8541 }, + Case { id: "bettertls::nameconstraints::tc2536", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8545, 8546], leaf: 8544 }, + Case { id: "bettertls::nameconstraints::tc2537", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8548, 8549], leaf: 8547 }, + Case { id: "bettertls::nameconstraints::tc2538", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8551, 8552], leaf: 8550 }, + Case { id: "bettertls::nameconstraints::tc2539", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8554, 8555], leaf: 8553 }, + Case { id: "bettertls::nameconstraints::tc2540", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8557, 8558], leaf: 8556 }, + Case { id: "bettertls::nameconstraints::tc2541", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8560, 8561], leaf: 8559 }, + Case { id: "bettertls::nameconstraints::tc2542", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8563, 8564], leaf: 8562 }, + Case { id: "bettertls::nameconstraints::tc2543", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8566, 8567], leaf: 8565 }, + Case { id: "bettertls::nameconstraints::tc2544", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8569, 8570], leaf: 8568 }, + Case { id: "bettertls::nameconstraints::tc2545", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8572, 8573], leaf: 8571 }, + Case { id: "bettertls::nameconstraints::tc2546", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8575, 8576], leaf: 8574 }, + Case { id: "bettertls::nameconstraints::tc2547", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8578, 8579], leaf: 8577 }, + Case { id: "bettertls::nameconstraints::tc2548", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8581, 8582], leaf: 8580 }, + Case { id: "bettertls::nameconstraints::tc2549", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8584, 8585], leaf: 8583 }, + Case { id: "bettertls::nameconstraints::tc2550", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8587, 8588], leaf: 8586 }, + Case { id: "bettertls::nameconstraints::tc2551", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8590, 8591], leaf: 8589 }, + Case { id: "bettertls::nameconstraints::tc2552", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8593, 8594], leaf: 8592 }, + Case { id: "bettertls::nameconstraints::tc2553", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8596, 8597], leaf: 8595 }, + Case { id: "bettertls::nameconstraints::tc2554", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8599, 8600], leaf: 8598 }, + Case { id: "bettertls::nameconstraints::tc2555", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8602, 8603], leaf: 8601 }, + Case { id: "bettertls::nameconstraints::tc2556", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8605, 8606], leaf: 8604 }, + Case { id: "bettertls::nameconstraints::tc2557", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8608, 8609], leaf: 8607 }, + Case { id: "bettertls::nameconstraints::tc2558", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8611, 8612], leaf: 8610 }, + Case { id: "bettertls::nameconstraints::tc2559", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8614, 8615], leaf: 8613 }, + Case { id: "bettertls::nameconstraints::tc2560", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8617, 8618], leaf: 8616 }, + Case { id: "bettertls::nameconstraints::tc2561", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8620, 8621], leaf: 8619 }, + Case { id: "bettertls::nameconstraints::tc2562", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8623, 8624], leaf: 8622 }, + Case { id: "bettertls::nameconstraints::tc2563", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8626, 8627], leaf: 8625 }, + Case { id: "bettertls::nameconstraints::tc2564", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8629, 8630], leaf: 8628 }, + Case { id: "bettertls::nameconstraints::tc2565", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8632, 8633], leaf: 8631 }, + Case { id: "bettertls::nameconstraints::tc2566", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8635, 8636], leaf: 8634 }, + Case { id: "bettertls::nameconstraints::tc2567", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8638, 8639], leaf: 8637 }, + Case { id: "bettertls::nameconstraints::tc2568", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8641, 8642], leaf: 8640 }, + Case { id: "bettertls::nameconstraints::tc2569", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8644, 8645], leaf: 8643 }, + Case { id: "bettertls::nameconstraints::tc2570", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8647, 8648], leaf: 8646 }, + Case { id: "bettertls::nameconstraints::tc2571", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8650, 8651], leaf: 8649 }, + Case { id: "bettertls::nameconstraints::tc2572", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8653, 8654], leaf: 8652 }, + Case { id: "bettertls::nameconstraints::tc2573", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8656, 8657], leaf: 8655 }, + Case { id: "bettertls::nameconstraints::tc2574", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8659, 8660], leaf: 8658 }, + Case { id: "bettertls::nameconstraints::tc2575", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8662, 8663], leaf: 8661 }, + Case { id: "bettertls::nameconstraints::tc2576", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8665, 8666], leaf: 8664 }, + Case { id: "bettertls::nameconstraints::tc2577", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8668, 8669], leaf: 8667 }, + Case { id: "bettertls::nameconstraints::tc2578", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8671, 8672], leaf: 8670 }, + Case { id: "bettertls::nameconstraints::tc2579", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8674, 8675], leaf: 8673 }, + Case { id: "bettertls::nameconstraints::tc2580", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8677, 8678], leaf: 8676 }, + Case { id: "bettertls::nameconstraints::tc2581", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8680, 8681], leaf: 8679 }, + Case { id: "bettertls::nameconstraints::tc2582", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8683, 8684], leaf: 8682 }, + Case { id: "bettertls::nameconstraints::tc2583", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8686, 8687], leaf: 8685 }, + Case { id: "bettertls::nameconstraints::tc2584", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8689, 8690], leaf: 8688 }, + Case { id: "bettertls::nameconstraints::tc2585", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8692, 8693], leaf: 8691 }, + Case { id: "bettertls::nameconstraints::tc2586", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8695, 8696], leaf: 8694 }, + Case { id: "bettertls::nameconstraints::tc2587", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8698, 8699], leaf: 8697 }, + Case { id: "bettertls::nameconstraints::tc2588", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8701, 8702], leaf: 8700 }, + Case { id: "bettertls::nameconstraints::tc2589", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8704, 8705], leaf: 8703 }, + Case { id: "bettertls::nameconstraints::tc2590", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8707, 8708], leaf: 8706 }, + Case { id: "bettertls::nameconstraints::tc2591", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8710, 8711], leaf: 8709 }, + Case { id: "bettertls::nameconstraints::tc2592", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8713, 8714], leaf: 8712 }, + Case { id: "bettertls::nameconstraints::tc2593", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8716, 8717], leaf: 8715 }, + Case { id: "bettertls::nameconstraints::tc2594", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8719, 8720], leaf: 8718 }, + Case { id: "bettertls::nameconstraints::tc2595", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8722, 8723], leaf: 8721 }, + Case { id: "bettertls::nameconstraints::tc2596", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8725, 8726], leaf: 8724 }, + Case { id: "bettertls::nameconstraints::tc2597", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8728, 8729], leaf: 8727 }, + Case { id: "bettertls::nameconstraints::tc2598", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8731, 8732], leaf: 8730 }, + Case { id: "bettertls::nameconstraints::tc2599", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8734, 8735], leaf: 8733 }, + Case { id: "bettertls::nameconstraints::tc2600", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8737, 8738], leaf: 8736 }, + Case { id: "bettertls::nameconstraints::tc2601", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8740, 8741], leaf: 8739 }, + Case { id: "bettertls::nameconstraints::tc2602", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8743, 8744], leaf: 8742 }, + Case { id: "bettertls::nameconstraints::tc2603", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8746, 8747], leaf: 8745 }, + Case { id: "bettertls::nameconstraints::tc2604", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8749, 8750], leaf: 8748 }, + Case { id: "bettertls::nameconstraints::tc2605", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8752, 8753], leaf: 8751 }, + Case { id: "bettertls::nameconstraints::tc2606", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8755, 8756], leaf: 8754 }, + Case { id: "bettertls::nameconstraints::tc2607", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8758, 8759], leaf: 8757 }, + Case { id: "bettertls::nameconstraints::tc2608", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8761, 8762], leaf: 8760 }, + Case { id: "bettertls::nameconstraints::tc2609", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8764, 8765], leaf: 8763 }, + Case { id: "bettertls::nameconstraints::tc2610", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8767, 8768], leaf: 8766 }, + Case { id: "bettertls::nameconstraints::tc2611", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8770, 8771], leaf: 8769 }, + Case { id: "bettertls::nameconstraints::tc2612", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8773, 8774], leaf: 8772 }, + Case { id: "bettertls::nameconstraints::tc2613", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8776, 8777], leaf: 8775 }, + Case { id: "bettertls::nameconstraints::tc2614", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8779, 8780], leaf: 8778 }, + Case { id: "bettertls::nameconstraints::tc2615", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8782, 8783], leaf: 8781 }, + Case { id: "bettertls::nameconstraints::tc2616", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8785, 8786], leaf: 8784 }, + Case { id: "bettertls::nameconstraints::tc2617", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8788, 8789], leaf: 8787 }, + Case { id: "bettertls::nameconstraints::tc2618", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8791, 8792], leaf: 8790 }, + Case { id: "bettertls::nameconstraints::tc2619", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8794, 8795], leaf: 8793 }, + Case { id: "bettertls::nameconstraints::tc2620", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8797, 8798], leaf: 8796 }, + Case { id: "bettertls::nameconstraints::tc2621", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8800, 8801], leaf: 8799 }, + Case { id: "bettertls::nameconstraints::tc2622", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8803, 8804], leaf: 8802 }, + Case { id: "bettertls::nameconstraints::tc2623", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8806, 8807], leaf: 8805 }, + Case { id: "bettertls::nameconstraints::tc2624", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8809, 8810], leaf: 8808 }, + Case { id: "bettertls::nameconstraints::tc2625", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8812, 8813], leaf: 8811 }, + Case { id: "bettertls::nameconstraints::tc2626", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8815, 8816], leaf: 8814 }, + Case { id: "bettertls::nameconstraints::tc2627", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8818, 8819], leaf: 8817 }, + Case { id: "bettertls::nameconstraints::tc2628", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8821, 8822], leaf: 8820 }, + Case { id: "bettertls::nameconstraints::tc2629", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8824, 8825], leaf: 8823 }, + Case { id: "bettertls::nameconstraints::tc2630", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8827, 8828], leaf: 8826 }, + Case { id: "bettertls::nameconstraints::tc2631", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8830, 8831], leaf: 8829 }, + Case { id: "bettertls::nameconstraints::tc2632", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8833, 8834], leaf: 8832 }, + Case { id: "bettertls::nameconstraints::tc2633", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8836, 8837], leaf: 8835 }, + Case { id: "bettertls::nameconstraints::tc2634", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8839, 8840], leaf: 8838 }, + Case { id: "bettertls::nameconstraints::tc2635", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8842, 8843], leaf: 8841 }, + Case { id: "bettertls::nameconstraints::tc2636", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8845, 8846], leaf: 8844 }, + Case { id: "bettertls::nameconstraints::tc2637", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8848, 8849], leaf: 8847 }, + Case { id: "bettertls::nameconstraints::tc2638", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8851, 8852], leaf: 8850 }, + Case { id: "bettertls::nameconstraints::tc2639", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8854, 8855], leaf: 8853 }, + Case { id: "bettertls::nameconstraints::tc2640", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8857, 8858], leaf: 8856 }, + Case { id: "bettertls::nameconstraints::tc2641", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8860, 8861], leaf: 8859 }, + Case { id: "bettertls::nameconstraints::tc2642", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8863, 8864], leaf: 8862 }, + Case { id: "bettertls::nameconstraints::tc2643", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8866, 8867], leaf: 8865 }, + Case { id: "bettertls::nameconstraints::tc2644", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8869, 8870], leaf: 8868 }, + Case { id: "bettertls::nameconstraints::tc2645", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8872, 8873], leaf: 8871 }, + Case { id: "bettertls::nameconstraints::tc2646", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8875, 8876], leaf: 8874 }, + Case { id: "bettertls::nameconstraints::tc2647", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8878, 8879], leaf: 8877 }, + Case { id: "bettertls::nameconstraints::tc2648", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8881, 8882], leaf: 8880 }, + Case { id: "bettertls::nameconstraints::tc2649", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8884, 8885], leaf: 8883 }, + Case { id: "bettertls::nameconstraints::tc2650", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8887, 8888], leaf: 8886 }, + Case { id: "bettertls::nameconstraints::tc2651", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8890, 8891], leaf: 8889 }, + Case { id: "bettertls::nameconstraints::tc2652", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8893, 8894], leaf: 8892 }, + Case { id: "bettertls::nameconstraints::tc2653", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8896, 8897], leaf: 8895 }, + Case { id: "bettertls::nameconstraints::tc2654", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8899, 8900], leaf: 8898 }, + Case { id: "bettertls::nameconstraints::tc2655", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8902, 8903], leaf: 8901 }, + Case { id: "bettertls::nameconstraints::tc2656", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8905, 8906], leaf: 8904 }, + Case { id: "bettertls::nameconstraints::tc2657", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8908, 8909], leaf: 8907 }, + Case { id: "bettertls::nameconstraints::tc2658", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8911, 8912], leaf: 8910 }, + Case { id: "bettertls::nameconstraints::tc2659", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8914, 8915], leaf: 8913 }, + Case { id: "bettertls::nameconstraints::tc2660", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8917, 8918], leaf: 8916 }, + Case { id: "bettertls::nameconstraints::tc2661", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8920, 8921], leaf: 8919 }, + Case { id: "bettertls::nameconstraints::tc2662", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8923, 8924], leaf: 8922 }, + Case { id: "bettertls::nameconstraints::tc2663", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8926, 8927], leaf: 8925 }, + Case { id: "bettertls::nameconstraints::tc2664", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8929, 8930], leaf: 8928 }, + Case { id: "bettertls::nameconstraints::tc2665", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8932, 8933], leaf: 8931 }, + Case { id: "bettertls::nameconstraints::tc2666", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8935, 8936], leaf: 8934 }, + Case { id: "bettertls::nameconstraints::tc2667", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8938, 8939], leaf: 8937 }, + Case { id: "bettertls::nameconstraints::tc2668", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8941, 8942], leaf: 8940 }, + Case { id: "bettertls::nameconstraints::tc2669", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8944, 8945], leaf: 8943 }, + Case { id: "bettertls::nameconstraints::tc2670", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8947, 8948], leaf: 8946 }, + Case { id: "bettertls::nameconstraints::tc2671", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8950, 8951], leaf: 8949 }, + Case { id: "bettertls::nameconstraints::tc2672", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8953, 8954], leaf: 8952 }, + Case { id: "bettertls::nameconstraints::tc2673", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8956, 8957], leaf: 8955 }, + Case { id: "bettertls::nameconstraints::tc2674", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8959, 8960], leaf: 8958 }, + Case { id: "bettertls::nameconstraints::tc2675", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8962, 8963], leaf: 8961 }, + Case { id: "bettertls::nameconstraints::tc2676", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8965, 8966], leaf: 8964 }, + Case { id: "bettertls::nameconstraints::tc2677", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8968, 8969], leaf: 8967 }, + Case { id: "bettertls::nameconstraints::tc2678", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8971, 8972], leaf: 8970 }, + Case { id: "bettertls::nameconstraints::tc2679", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8974, 8975], leaf: 8973 }, + Case { id: "bettertls::nameconstraints::tc2680", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8977, 8978], leaf: 8976 }, + Case { id: "bettertls::nameconstraints::tc2681", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8980, 8981], leaf: 8979 }, + Case { id: "bettertls::nameconstraints::tc2682", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8983, 8984], leaf: 8982 }, + Case { id: "bettertls::nameconstraints::tc2683", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8986, 8987], leaf: 8985 }, + Case { id: "bettertls::nameconstraints::tc2684", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8989, 8990], leaf: 8988 }, + Case { id: "bettertls::nameconstraints::tc2685", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8992, 8993], leaf: 8991 }, + Case { id: "bettertls::nameconstraints::tc2686", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8995, 8996], leaf: 8994 }, + Case { id: "bettertls::nameconstraints::tc2687", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[8998, 8999], leaf: 8997 }, + Case { id: "bettertls::nameconstraints::tc2688", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9001, 9002], leaf: 9000 }, + Case { id: "bettertls::nameconstraints::tc2689", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9004, 9005], leaf: 9003 }, + Case { id: "bettertls::nameconstraints::tc2690", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9007, 9008], leaf: 9006 }, + Case { id: "bettertls::nameconstraints::tc2691", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9010, 9011], leaf: 9009 }, + Case { id: "bettertls::nameconstraints::tc2692", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9013, 9014], leaf: 9012 }, + Case { id: "bettertls::nameconstraints::tc2693", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9016, 9017], leaf: 9015 }, + Case { id: "bettertls::nameconstraints::tc2694", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9019, 9020], leaf: 9018 }, + Case { id: "bettertls::nameconstraints::tc2695", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9022, 9023], leaf: 9021 }, + Case { id: "bettertls::nameconstraints::tc2696", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9025, 9026], leaf: 9024 }, + Case { id: "bettertls::nameconstraints::tc2697", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9028, 9029], leaf: 9027 }, + Case { id: "bettertls::nameconstraints::tc2698", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9031, 9032], leaf: 9030 }, + Case { id: "bettertls::nameconstraints::tc2699", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9034, 9035], leaf: 9033 }, + Case { id: "bettertls::nameconstraints::tc2700", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9037, 9038], leaf: 9036 }, + Case { id: "bettertls::nameconstraints::tc2701", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:51+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9040, 9041], leaf: 9039 }, + Case { id: "bettertls::nameconstraints::tc2702", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9043, 9044], leaf: 9042 }, + Case { id: "bettertls::nameconstraints::tc2703", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9046, 9047], leaf: 9045 }, + Case { id: "bettertls::nameconstraints::tc2704", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9049, 9050], leaf: 9048 }, + Case { id: "bettertls::nameconstraints::tc2705", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9052, 9053], leaf: 9051 }, + Case { id: "bettertls::nameconstraints::tc2706", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9055, 9056], leaf: 9054 }, + Case { id: "bettertls::nameconstraints::tc2707", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9058, 9059], leaf: 9057 }, + Case { id: "bettertls::nameconstraints::tc2708", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9061, 9062], leaf: 9060 }, + Case { id: "bettertls::nameconstraints::tc2709", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9064, 9065], leaf: 9063 }, + Case { id: "bettertls::nameconstraints::tc2710", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9067, 9068], leaf: 9066 }, + Case { id: "bettertls::nameconstraints::tc2711", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9070, 9071], leaf: 9069 }, + Case { id: "bettertls::nameconstraints::tc2712", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9073, 9074], leaf: 9072 }, + Case { id: "bettertls::nameconstraints::tc2713", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9076, 9077], leaf: 9075 }, + Case { id: "bettertls::nameconstraints::tc2714", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9079, 9080], leaf: 9078 }, + Case { id: "bettertls::nameconstraints::tc2715", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9082, 9083], leaf: 9081 }, + Case { id: "bettertls::nameconstraints::tc2716", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9085, 9086], leaf: 9084 }, + Case { id: "bettertls::nameconstraints::tc2717", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9088, 9089], leaf: 9087 }, + Case { id: "bettertls::nameconstraints::tc2718", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9091, 9092], leaf: 9090 }, + Case { id: "bettertls::nameconstraints::tc2719", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9094, 9095], leaf: 9093 }, + Case { id: "bettertls::nameconstraints::tc2720", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9097, 9098], leaf: 9096 }, + Case { id: "bettertls::nameconstraints::tc2721", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9100, 9101], leaf: 9099 }, + Case { id: "bettertls::nameconstraints::tc2722", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9103, 9104], leaf: 9102 }, + Case { id: "bettertls::nameconstraints::tc2723", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9106, 9107], leaf: 9105 }, + Case { id: "bettertls::nameconstraints::tc2724", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9109, 9110], leaf: 9108 }, + Case { id: "bettertls::nameconstraints::tc2725", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9112, 9113], leaf: 9111 }, + Case { id: "bettertls::nameconstraints::tc2726", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9115, 9116], leaf: 9114 }, + Case { id: "bettertls::nameconstraints::tc2727", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9118, 9119], leaf: 9117 }, + Case { id: "bettertls::nameconstraints::tc2728", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9121, 9122], leaf: 9120 }, + Case { id: "bettertls::nameconstraints::tc2729", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9124, 9125], leaf: 9123 }, + Case { id: "bettertls::nameconstraints::tc2730", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9127, 9128], leaf: 9126 }, + Case { id: "bettertls::nameconstraints::tc2731", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9130, 9131], leaf: 9129 }, + Case { id: "bettertls::nameconstraints::tc2732", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9133, 9134], leaf: 9132 }, + Case { id: "bettertls::nameconstraints::tc2733", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9136, 9137], leaf: 9135 }, + Case { id: "bettertls::nameconstraints::tc2734", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9139, 9140], leaf: 9138 }, + Case { id: "bettertls::nameconstraints::tc2735", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9142, 9143], leaf: 9141 }, + Case { id: "bettertls::nameconstraints::tc2736", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9145, 9146], leaf: 9144 }, + Case { id: "bettertls::nameconstraints::tc2737", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9148, 9149], leaf: 9147 }, + Case { id: "bettertls::nameconstraints::tc2738", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9151, 9152], leaf: 9150 }, + Case { id: "bettertls::nameconstraints::tc2739", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9154, 9155], leaf: 9153 }, + Case { id: "bettertls::nameconstraints::tc2740", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9157, 9158], leaf: 9156 }, + Case { id: "bettertls::nameconstraints::tc2741", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9160, 9161], leaf: 9159 }, + Case { id: "bettertls::nameconstraints::tc2742", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9163, 9164], leaf: 9162 }, + Case { id: "bettertls::nameconstraints::tc2743", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9166, 9167], leaf: 9165 }, + Case { id: "bettertls::nameconstraints::tc2744", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9169, 9170], leaf: 9168 }, + Case { id: "bettertls::nameconstraints::tc2745", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9172, 9173], leaf: 9171 }, + Case { id: "bettertls::nameconstraints::tc2746", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9175, 9176], leaf: 9174 }, + Case { id: "bettertls::nameconstraints::tc2747", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9178, 9179], leaf: 9177 }, + Case { id: "bettertls::nameconstraints::tc2748", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9181, 9182], leaf: 9180 }, + Case { id: "bettertls::nameconstraints::tc2749", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9184, 9185], leaf: 9183 }, + Case { id: "bettertls::nameconstraints::tc2750", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9187, 9188], leaf: 9186 }, + Case { id: "bettertls::nameconstraints::tc2751", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9190, 9191], leaf: 9189 }, + Case { id: "bettertls::nameconstraints::tc2752", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9193, 9194], leaf: 9192 }, + Case { id: "bettertls::nameconstraints::tc2753", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9196, 9197], leaf: 9195 }, + Case { id: "bettertls::nameconstraints::tc2754", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9199, 9200], leaf: 9198 }, + Case { id: "bettertls::nameconstraints::tc2755", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9202, 9203], leaf: 9201 }, + Case { id: "bettertls::nameconstraints::tc2756", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9205, 9206], leaf: 9204 }, + Case { id: "bettertls::nameconstraints::tc2757", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9208, 9209], leaf: 9207 }, + Case { id: "bettertls::nameconstraints::tc2758", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9211, 9212], leaf: 9210 }, + Case { id: "bettertls::nameconstraints::tc2759", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9214, 9215], leaf: 9213 }, + Case { id: "bettertls::nameconstraints::tc2760", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9217, 9218], leaf: 9216 }, + Case { id: "bettertls::nameconstraints::tc2761", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9220, 9221], leaf: 9219 }, + Case { id: "bettertls::nameconstraints::tc2762", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9223, 9224], leaf: 9222 }, + Case { id: "bettertls::nameconstraints::tc2763", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9226, 9227], leaf: 9225 }, + Case { id: "bettertls::nameconstraints::tc2764", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9229, 9230], leaf: 9228 }, + Case { id: "bettertls::nameconstraints::tc2765", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9232, 9233], leaf: 9231 }, + Case { id: "bettertls::nameconstraints::tc2766", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9235, 9236], leaf: 9234 }, + Case { id: "bettertls::nameconstraints::tc2767", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9238, 9239], leaf: 9237 }, + Case { id: "bettertls::nameconstraints::tc2768", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9241, 9242], leaf: 9240 }, + Case { id: "bettertls::nameconstraints::tc2769", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9244, 9245], leaf: 9243 }, + Case { id: "bettertls::nameconstraints::tc2770", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9247, 9248], leaf: 9246 }, + Case { id: "bettertls::nameconstraints::tc2771", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9250, 9251], leaf: 9249 }, + Case { id: "bettertls::nameconstraints::tc2772", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9253, 9254], leaf: 9252 }, + Case { id: "bettertls::nameconstraints::tc2773", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9256, 9257], leaf: 9255 }, + Case { id: "bettertls::nameconstraints::tc2774", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9259, 9260], leaf: 9258 }, + Case { id: "bettertls::nameconstraints::tc2775", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9262, 9263], leaf: 9261 }, + Case { id: "bettertls::nameconstraints::tc2776", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9265, 9266], leaf: 9264 }, + Case { id: "bettertls::nameconstraints::tc2777", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9268, 9269], leaf: 9267 }, + Case { id: "bettertls::nameconstraints::tc2778", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9271, 9272], leaf: 9270 }, + Case { id: "bettertls::nameconstraints::tc2779", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9274, 9275], leaf: 9273 }, + Case { id: "bettertls::nameconstraints::tc2780", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9277, 9278], leaf: 9276 }, + Case { id: "bettertls::nameconstraints::tc2781", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9280, 9281], leaf: 9279 }, + Case { id: "bettertls::nameconstraints::tc2782", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9283, 9284], leaf: 9282 }, + Case { id: "bettertls::nameconstraints::tc2783", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9286, 9287], leaf: 9285 }, + Case { id: "bettertls::nameconstraints::tc2784", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9289, 9290], leaf: 9288 }, + Case { id: "bettertls::nameconstraints::tc2785", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9292, 9293], leaf: 9291 }, + Case { id: "bettertls::nameconstraints::tc2786", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9295, 9296], leaf: 9294 }, + Case { id: "bettertls::nameconstraints::tc2787", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9298, 9299], leaf: 9297 }, + Case { id: "bettertls::nameconstraints::tc2788", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9301, 9302], leaf: 9300 }, + Case { id: "bettertls::nameconstraints::tc2789", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9304, 9305], leaf: 9303 }, + Case { id: "bettertls::nameconstraints::tc2790", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9307, 9308], leaf: 9306 }, + Case { id: "bettertls::nameconstraints::tc2791", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9310, 9311], leaf: 9309 }, + Case { id: "bettertls::nameconstraints::tc2792", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9313, 9314], leaf: 9312 }, + Case { id: "bettertls::nameconstraints::tc2793", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9316, 9317], leaf: 9315 }, + Case { id: "bettertls::nameconstraints::tc2794", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9319, 9320], leaf: 9318 }, + Case { id: "bettertls::nameconstraints::tc2795", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9322, 9323], leaf: 9321 }, + Case { id: "bettertls::nameconstraints::tc2796", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9325, 9326], leaf: 9324 }, + Case { id: "bettertls::nameconstraints::tc2797", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9328, 9329], leaf: 9327 }, + Case { id: "bettertls::nameconstraints::tc2798", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9331, 9332], leaf: 9330 }, + Case { id: "bettertls::nameconstraints::tc2799", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9334, 9335], leaf: 9333 }, + Case { id: "bettertls::nameconstraints::tc2800", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9337, 9338], leaf: 9336 }, + Case { id: "bettertls::nameconstraints::tc2801", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9340, 9341], leaf: 9339 }, + Case { id: "bettertls::nameconstraints::tc2802", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9343, 9344], leaf: 9342 }, + Case { id: "bettertls::nameconstraints::tc2803", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9346, 9347], leaf: 9345 }, + Case { id: "bettertls::nameconstraints::tc2804", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9349, 9350], leaf: 9348 }, + Case { id: "bettertls::nameconstraints::tc2805", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9352, 9353], leaf: 9351 }, + Case { id: "bettertls::nameconstraints::tc2806", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9355, 9356], leaf: 9354 }, + Case { id: "bettertls::nameconstraints::tc2807", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9358, 9359], leaf: 9357 }, + Case { id: "bettertls::nameconstraints::tc2808", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9361, 9362], leaf: 9360 }, + Case { id: "bettertls::nameconstraints::tc2809", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9364, 9365], leaf: 9363 }, + Case { id: "bettertls::nameconstraints::tc2810", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9367, 9368], leaf: 9366 }, + Case { id: "bettertls::nameconstraints::tc2811", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9370, 9371], leaf: 9369 }, + Case { id: "bettertls::nameconstraints::tc2812", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9373, 9374], leaf: 9372 }, + Case { id: "bettertls::nameconstraints::tc2813", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9376, 9377], leaf: 9375 }, + Case { id: "bettertls::nameconstraints::tc2814", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9379, 9380], leaf: 9378 }, + Case { id: "bettertls::nameconstraints::tc2815", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9382, 9383], leaf: 9381 }, + Case { id: "bettertls::nameconstraints::tc2816", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9385, 9386], leaf: 9384 }, + Case { id: "bettertls::nameconstraints::tc2817", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9388, 9389], leaf: 9387 }, + Case { id: "bettertls::nameconstraints::tc2818", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9391, 9392], leaf: 9390 }, + Case { id: "bettertls::nameconstraints::tc2819", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9394, 9395], leaf: 9393 }, + Case { id: "bettertls::nameconstraints::tc2820", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9397, 9398], leaf: 9396 }, + Case { id: "bettertls::nameconstraints::tc2821", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9400, 9401], leaf: 9399 }, + Case { id: "bettertls::nameconstraints::tc2822", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9403, 9404], leaf: 9402 }, + Case { id: "bettertls::nameconstraints::tc2823", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9406, 9407], leaf: 9405 }, + Case { id: "bettertls::nameconstraints::tc2824", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9409, 9410], leaf: 9408 }, + Case { id: "bettertls::nameconstraints::tc2825", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9412, 9413], leaf: 9411 }, + Case { id: "bettertls::nameconstraints::tc2826", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9415, 9416], leaf: 9414 }, + Case { id: "bettertls::nameconstraints::tc2827", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9418, 9419], leaf: 9417 }, + Case { id: "bettertls::nameconstraints::tc2828", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9421, 9422], leaf: 9420 }, + Case { id: "bettertls::nameconstraints::tc2829", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9424, 9425], leaf: 9423 }, + Case { id: "bettertls::nameconstraints::tc2830", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9427, 9428], leaf: 9426 }, + Case { id: "bettertls::nameconstraints::tc2831", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9430, 9431], leaf: 9429 }, + Case { id: "bettertls::nameconstraints::tc2832", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9433, 9434], leaf: 9432 }, + Case { id: "bettertls::nameconstraints::tc2833", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9436, 9437], leaf: 9435 }, + Case { id: "bettertls::nameconstraints::tc2834", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9439, 9440], leaf: 9438 }, + Case { id: "bettertls::nameconstraints::tc2835", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9442, 9443], leaf: 9441 }, + Case { id: "bettertls::nameconstraints::tc2836", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9445, 9446], leaf: 9444 }, + Case { id: "bettertls::nameconstraints::tc2837", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9448, 9449], leaf: 9447 }, + Case { id: "bettertls::nameconstraints::tc2838", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9451, 9452], leaf: 9450 }, + Case { id: "bettertls::nameconstraints::tc2839", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9454, 9455], leaf: 9453 }, + Case { id: "bettertls::nameconstraints::tc2840", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9457, 9458], leaf: 9456 }, + Case { id: "bettertls::nameconstraints::tc2841", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9460, 9461], leaf: 9459 }, + Case { id: "bettertls::nameconstraints::tc2842", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9463, 9464], leaf: 9462 }, + Case { id: "bettertls::nameconstraints::tc2843", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9466, 9467], leaf: 9465 }, + Case { id: "bettertls::nameconstraints::tc2844", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9469, 9470], leaf: 9468 }, + Case { id: "bettertls::nameconstraints::tc2845", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9472, 9473], leaf: 9471 }, + Case { id: "bettertls::nameconstraints::tc2846", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9475, 9476], leaf: 9474 }, + Case { id: "bettertls::nameconstraints::tc2847", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9478, 9479], leaf: 9477 }, + Case { id: "bettertls::nameconstraints::tc2848", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9481, 9482], leaf: 9480 }, + Case { id: "bettertls::nameconstraints::tc2849", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9484, 9485], leaf: 9483 }, + Case { id: "bettertls::nameconstraints::tc2850", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9487, 9488], leaf: 9486 }, + Case { id: "bettertls::nameconstraints::tc2851", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9490, 9491], leaf: 9489 }, + Case { id: "bettertls::nameconstraints::tc2852", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9493, 9494], leaf: 9492 }, + Case { id: "bettertls::nameconstraints::tc2853", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9496, 9497], leaf: 9495 }, + Case { id: "bettertls::nameconstraints::tc2854", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9499, 9500], leaf: 9498 }, + Case { id: "bettertls::nameconstraints::tc2855", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9502, 9503], leaf: 9501 }, + Case { id: "bettertls::nameconstraints::tc2856", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9505, 9506], leaf: 9504 }, + Case { id: "bettertls::nameconstraints::tc2857", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9508, 9509], leaf: 9507 }, + Case { id: "bettertls::nameconstraints::tc2858", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9511, 9512], leaf: 9510 }, + Case { id: "bettertls::nameconstraints::tc2859", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9514, 9515], leaf: 9513 }, + Case { id: "bettertls::nameconstraints::tc2860", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9517, 9518], leaf: 9516 }, + Case { id: "bettertls::nameconstraints::tc2861", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9520, 9521], leaf: 9519 }, + Case { id: "bettertls::nameconstraints::tc2862", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9523, 9524], leaf: 9522 }, + Case { id: "bettertls::nameconstraints::tc2863", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9526, 9527], leaf: 9525 }, + Case { id: "bettertls::nameconstraints::tc2864", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9529, 9530], leaf: 9528 }, + Case { id: "bettertls::nameconstraints::tc2865", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9532, 9533], leaf: 9531 }, + Case { id: "bettertls::nameconstraints::tc2866", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9535, 9536], leaf: 9534 }, + Case { id: "bettertls::nameconstraints::tc2867", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9538, 9539], leaf: 9537 }, + Case { id: "bettertls::nameconstraints::tc2868", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9541, 9542], leaf: 9540 }, + Case { id: "bettertls::nameconstraints::tc2869", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9544, 9545], leaf: 9543 }, + Case { id: "bettertls::nameconstraints::tc2870", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9547, 9548], leaf: 9546 }, + Case { id: "bettertls::nameconstraints::tc2871", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9550, 9551], leaf: 9549 }, + Case { id: "bettertls::nameconstraints::tc2872", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9553, 9554], leaf: 9552 }, + Case { id: "bettertls::nameconstraints::tc2873", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9556, 9557], leaf: 9555 }, + Case { id: "bettertls::nameconstraints::tc2874", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9559, 9560], leaf: 9558 }, + Case { id: "bettertls::nameconstraints::tc2875", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9562, 9563], leaf: 9561 }, + Case { id: "bettertls::nameconstraints::tc2876", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9565, 9566], leaf: 9564 }, + Case { id: "bettertls::nameconstraints::tc2877", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9568, 9569], leaf: 9567 }, + Case { id: "bettertls::nameconstraints::tc2878", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9571, 9572], leaf: 9570 }, + Case { id: "bettertls::nameconstraints::tc2879", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9574, 9575], leaf: 9573 }, + Case { id: "bettertls::nameconstraints::tc2880", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9577, 9578], leaf: 9576 }, + Case { id: "bettertls::nameconstraints::tc2881", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9580, 9581], leaf: 9579 }, + Case { id: "bettertls::nameconstraints::tc2882", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9583, 9584], leaf: 9582 }, + Case { id: "bettertls::nameconstraints::tc2883", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9586, 9587], leaf: 9585 }, + Case { id: "bettertls::nameconstraints::tc2884", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9589, 9590], leaf: 9588 }, + Case { id: "bettertls::nameconstraints::tc2885", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9592, 9593], leaf: 9591 }, + Case { id: "bettertls::nameconstraints::tc2886", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9595, 9596], leaf: 9594 }, + Case { id: "bettertls::nameconstraints::tc2887", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9598, 9599], leaf: 9597 }, + Case { id: "bettertls::nameconstraints::tc2888", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9601, 9602], leaf: 9600 }, + Case { id: "bettertls::nameconstraints::tc2889", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9604, 9605], leaf: 9603 }, + Case { id: "bettertls::nameconstraints::tc2890", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9607, 9608], leaf: 9606 }, + Case { id: "bettertls::nameconstraints::tc2891", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9610, 9611], leaf: 9609 }, + Case { id: "bettertls::nameconstraints::tc2892", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9613, 9614], leaf: 9612 }, + Case { id: "bettertls::nameconstraints::tc2893", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9616, 9617], leaf: 9615 }, + Case { id: "bettertls::nameconstraints::tc2894", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9619, 9620], leaf: 9618 }, + Case { id: "bettertls::nameconstraints::tc2895", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9622, 9623], leaf: 9621 }, + Case { id: "bettertls::nameconstraints::tc2896", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9625, 9626], leaf: 9624 }, + Case { id: "bettertls::nameconstraints::tc2897", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9628, 9629], leaf: 9627 }, + Case { id: "bettertls::nameconstraints::tc2898", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9631, 9632], leaf: 9630 }, + Case { id: "bettertls::nameconstraints::tc2899", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9634, 9635], leaf: 9633 }, + Case { id: "bettertls::nameconstraints::tc2900", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9637, 9638], leaf: 9636 }, + Case { id: "bettertls::nameconstraints::tc2901", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9640, 9641], leaf: 9639 }, + Case { id: "bettertls::nameconstraints::tc2902", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9643, 9644], leaf: 9642 }, + Case { id: "bettertls::nameconstraints::tc2903", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9646, 9647], leaf: 9645 }, + Case { id: "bettertls::nameconstraints::tc2904", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9649, 9650], leaf: 9648 }, + Case { id: "bettertls::nameconstraints::tc2905", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9652, 9653], leaf: 9651 }, + Case { id: "bettertls::nameconstraints::tc2906", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9655, 9656], leaf: 9654 }, + Case { id: "bettertls::nameconstraints::tc2907", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9658, 9659], leaf: 9657 }, + Case { id: "bettertls::nameconstraints::tc2908", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9661, 9662], leaf: 9660 }, + Case { id: "bettertls::nameconstraints::tc2909", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9664, 9665], leaf: 9663 }, + Case { id: "bettertls::nameconstraints::tc2910", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9667, 9668], leaf: 9666 }, + Case { id: "bettertls::nameconstraints::tc2911", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9670, 9671], leaf: 9669 }, + Case { id: "bettertls::nameconstraints::tc2912", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9673, 9674], leaf: 9672 }, + Case { id: "bettertls::nameconstraints::tc2913", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9676, 9677], leaf: 9675 }, + Case { id: "bettertls::nameconstraints::tc2914", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9679, 9680], leaf: 9678 }, + Case { id: "bettertls::nameconstraints::tc2915", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9682, 9683], leaf: 9681 }, + Case { id: "bettertls::nameconstraints::tc2916", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9685, 9686], leaf: 9684 }, + Case { id: "bettertls::nameconstraints::tc2917", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9688, 9689], leaf: 9687 }, + Case { id: "bettertls::nameconstraints::tc2918", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9691, 9692], leaf: 9690 }, + Case { id: "bettertls::nameconstraints::tc2919", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9694, 9695], leaf: 9693 }, + Case { id: "bettertls::nameconstraints::tc2920", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9697, 9698], leaf: 9696 }, + Case { id: "bettertls::nameconstraints::tc2921", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9700, 9701], leaf: 9699 }, + Case { id: "bettertls::nameconstraints::tc2922", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9703, 9704], leaf: 9702 }, + Case { id: "bettertls::nameconstraints::tc2923", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9706, 9707], leaf: 9705 }, + Case { id: "bettertls::nameconstraints::tc2924", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9709, 9710], leaf: 9708 }, + Case { id: "bettertls::nameconstraints::tc2925", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9712, 9713], leaf: 9711 }, + Case { id: "bettertls::nameconstraints::tc2926", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9715, 9716], leaf: 9714 }, + Case { id: "bettertls::nameconstraints::tc2927", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9718, 9719], leaf: 9717 }, + Case { id: "bettertls::nameconstraints::tc2928", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9721, 9722], leaf: 9720 }, + Case { id: "bettertls::nameconstraints::tc2929", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9724, 9725], leaf: 9723 }, + Case { id: "bettertls::nameconstraints::tc2930", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9727, 9728], leaf: 9726 }, + Case { id: "bettertls::nameconstraints::tc2931", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9730, 9731], leaf: 9729 }, + Case { id: "bettertls::nameconstraints::tc2932", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9733, 9734], leaf: 9732 }, + Case { id: "bettertls::nameconstraints::tc2933", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9736, 9737], leaf: 9735 }, + Case { id: "bettertls::nameconstraints::tc2934", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9739, 9740], leaf: 9738 }, + Case { id: "bettertls::nameconstraints::tc2935", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9742, 9743], leaf: 9741 }, + Case { id: "bettertls::nameconstraints::tc2936", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9745, 9746], leaf: 9744 }, + Case { id: "bettertls::nameconstraints::tc2937", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9748, 9749], leaf: 9747 }, + Case { id: "bettertls::nameconstraints::tc2938", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9751, 9752], leaf: 9750 }, + Case { id: "bettertls::nameconstraints::tc2939", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9754, 9755], leaf: 9753 }, + Case { id: "bettertls::nameconstraints::tc2940", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9757, 9758], leaf: 9756 }, + Case { id: "bettertls::nameconstraints::tc2941", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9760, 9761], leaf: 9759 }, + Case { id: "bettertls::nameconstraints::tc2942", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9763, 9764], leaf: 9762 }, + Case { id: "bettertls::nameconstraints::tc2943", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9766, 9767], leaf: 9765 }, + Case { id: "bettertls::nameconstraints::tc2944", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9769, 9770], leaf: 9768 }, + Case { id: "bettertls::nameconstraints::tc2945", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9772, 9773], leaf: 9771 }, + Case { id: "bettertls::nameconstraints::tc2946", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9775, 9776], leaf: 9774 }, + Case { id: "bettertls::nameconstraints::tc2947", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9778, 9779], leaf: 9777 }, + Case { id: "bettertls::nameconstraints::tc2948", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9781, 9782], leaf: 9780 }, + Case { id: "bettertls::nameconstraints::tc2949", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9784, 9785], leaf: 9783 }, + Case { id: "bettertls::nameconstraints::tc2950", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9787, 9788], leaf: 9786 }, + Case { id: "bettertls::nameconstraints::tc2951", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9790, 9791], leaf: 9789 }, + Case { id: "bettertls::nameconstraints::tc2952", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9793, 9794], leaf: 9792 }, + Case { id: "bettertls::nameconstraints::tc2953", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9796, 9797], leaf: 9795 }, + Case { id: "bettertls::nameconstraints::tc2954", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9799, 9800], leaf: 9798 }, + Case { id: "bettertls::nameconstraints::tc2955", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9802, 9803], leaf: 9801 }, + Case { id: "bettertls::nameconstraints::tc2956", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9805, 9806], leaf: 9804 }, + Case { id: "bettertls::nameconstraints::tc2957", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9808, 9809], leaf: 9807 }, + Case { id: "bettertls::nameconstraints::tc2958", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9811, 9812], leaf: 9810 }, + Case { id: "bettertls::nameconstraints::tc2959", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9814, 9815], leaf: 9813 }, + Case { id: "bettertls::nameconstraints::tc2960", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9817, 9818], leaf: 9816 }, + Case { id: "bettertls::nameconstraints::tc2961", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9820, 9821], leaf: 9819 }, + Case { id: "bettertls::nameconstraints::tc2962", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9823, 9824], leaf: 9822 }, + Case { id: "bettertls::nameconstraints::tc2963", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9826, 9827], leaf: 9825 }, + Case { id: "bettertls::nameconstraints::tc2964", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9829, 9830], leaf: 9828 }, + Case { id: "bettertls::nameconstraints::tc2965", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9832, 9833], leaf: 9831 }, + Case { id: "bettertls::nameconstraints::tc2966", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9835, 9836], leaf: 9834 }, + Case { id: "bettertls::nameconstraints::tc2967", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9838, 9839], leaf: 9837 }, + Case { id: "bettertls::nameconstraints::tc2968", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9841, 9842], leaf: 9840 }, + Case { id: "bettertls::nameconstraints::tc2969", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9844, 9845], leaf: 9843 }, + Case { id: "bettertls::nameconstraints::tc2970", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9847, 9848], leaf: 9846 }, + Case { id: "bettertls::nameconstraints::tc2971", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9850, 9851], leaf: 9849 }, + Case { id: "bettertls::nameconstraints::tc2972", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9853, 9854], leaf: 9852 }, + Case { id: "bettertls::nameconstraints::tc2973", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9856, 9857], leaf: 9855 }, + Case { id: "bettertls::nameconstraints::tc2974", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9859, 9860], leaf: 9858 }, + Case { id: "bettertls::nameconstraints::tc2975", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9862, 9863], leaf: 9861 }, + Case { id: "bettertls::nameconstraints::tc2976", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9865, 9866], leaf: 9864 }, + Case { id: "bettertls::nameconstraints::tc2977", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9868, 9869], leaf: 9867 }, + Case { id: "bettertls::nameconstraints::tc2978", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9871, 9872], leaf: 9870 }, + Case { id: "bettertls::nameconstraints::tc2979", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9874, 9875], leaf: 9873 }, + Case { id: "bettertls::nameconstraints::tc2980", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9877, 9878], leaf: 9876 }, + Case { id: "bettertls::nameconstraints::tc2981", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9880, 9881], leaf: 9879 }, + Case { id: "bettertls::nameconstraints::tc2982", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9883, 9884], leaf: 9882 }, + Case { id: "bettertls::nameconstraints::tc2983", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9886, 9887], leaf: 9885 }, + Case { id: "bettertls::nameconstraints::tc2984", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9889, 9890], leaf: 9888 }, + Case { id: "bettertls::nameconstraints::tc2985", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9892, 9893], leaf: 9891 }, + Case { id: "bettertls::nameconstraints::tc2986", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9895, 9896], leaf: 9894 }, + Case { id: "bettertls::nameconstraints::tc2987", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9898, 9899], leaf: 9897 }, + Case { id: "bettertls::nameconstraints::tc2988", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9901, 9902], leaf: 9900 }, + Case { id: "bettertls::nameconstraints::tc2989", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9904, 9905], leaf: 9903 }, + Case { id: "bettertls::nameconstraints::tc2990", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9907, 9908], leaf: 9906 }, + Case { id: "bettertls::nameconstraints::tc2991", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9910, 9911], leaf: 9909 }, + Case { id: "bettertls::nameconstraints::tc2992", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9913, 9914], leaf: 9912 }, + Case { id: "bettertls::nameconstraints::tc2993", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9916, 9917], leaf: 9915 }, + Case { id: "bettertls::nameconstraints::tc2994", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9919, 9920], leaf: 9918 }, + Case { id: "bettertls::nameconstraints::tc2995", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9922, 9923], leaf: 9921 }, + Case { id: "bettertls::nameconstraints::tc2996", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9925, 9926], leaf: 9924 }, + Case { id: "bettertls::nameconstraints::tc2997", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9928, 9929], leaf: 9927 }, + Case { id: "bettertls::nameconstraints::tc2998", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9931, 9932], leaf: 9930 }, + Case { id: "bettertls::nameconstraints::tc2999", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9934, 9935], leaf: 9933 }, + Case { id: "bettertls::nameconstraints::tc3000", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9937, 9938], leaf: 9936 }, + Case { id: "bettertls::nameconstraints::tc3001", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9940, 9941], leaf: 9939 }, + Case { id: "bettertls::nameconstraints::tc3002", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9943, 9944], leaf: 9942 }, + Case { id: "bettertls::nameconstraints::tc3003", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9946, 9947], leaf: 9945 }, + Case { id: "bettertls::nameconstraints::tc3004", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9949, 9950], leaf: 9948 }, + Case { id: "bettertls::nameconstraints::tc3005", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9952, 9953], leaf: 9951 }, + Case { id: "bettertls::nameconstraints::tc3006", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9955, 9956], leaf: 9954 }, + Case { id: "bettertls::nameconstraints::tc3007", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9958, 9959], leaf: 9957 }, + Case { id: "bettertls::nameconstraints::tc3008", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9961, 9962], leaf: 9960 }, + Case { id: "bettertls::nameconstraints::tc3009", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9964, 9965], leaf: 9963 }, + Case { id: "bettertls::nameconstraints::tc3010", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9967, 9968], leaf: 9966 }, + Case { id: "bettertls::nameconstraints::tc3011", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9970, 9971], leaf: 9969 }, + Case { id: "bettertls::nameconstraints::tc3012", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9973, 9974], leaf: 9972 }, + Case { id: "bettertls::nameconstraints::tc3013", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9976, 9977], leaf: 9975 }, + Case { id: "bettertls::nameconstraints::tc3014", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9979, 9980], leaf: 9978 }, + Case { id: "bettertls::nameconstraints::tc3015", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9982, 9983], leaf: 9981 }, + Case { id: "bettertls::nameconstraints::tc3016", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9985, 9986], leaf: 9984 }, + Case { id: "bettertls::nameconstraints::tc3017", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9988, 9989], leaf: 9987 }, + Case { id: "bettertls::nameconstraints::tc3018", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9991, 9992], leaf: 9990 }, + Case { id: "bettertls::nameconstraints::tc3019", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9994, 9995], leaf: 9993 }, + Case { id: "bettertls::nameconstraints::tc3020", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[9997, 9998], leaf: 9996 }, + Case { id: "bettertls::nameconstraints::tc3021", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10000, 10001], leaf: 9999 }, + Case { id: "bettertls::nameconstraints::tc3022", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10003, 10004], leaf: 10002 }, + Case { id: "bettertls::nameconstraints::tc3023", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10006, 10007], leaf: 10005 }, + Case { id: "bettertls::nameconstraints::tc3024", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10009, 10010], leaf: 10008 }, + Case { id: "bettertls::nameconstraints::tc3025", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10012, 10013], leaf: 10011 }, + Case { id: "bettertls::nameconstraints::tc3026", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10015, 10016], leaf: 10014 }, + Case { id: "bettertls::nameconstraints::tc3027", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10018, 10019], leaf: 10017 }, + Case { id: "bettertls::nameconstraints::tc3028", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10021, 10022], leaf: 10020 }, + Case { id: "bettertls::nameconstraints::tc3029", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10024, 10025], leaf: 10023 }, + Case { id: "bettertls::nameconstraints::tc3030", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10027, 10028], leaf: 10026 }, + Case { id: "bettertls::nameconstraints::tc3031", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10030, 10031], leaf: 10029 }, + Case { id: "bettertls::nameconstraints::tc3032", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10033, 10034], leaf: 10032 }, + Case { id: "bettertls::nameconstraints::tc3033", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10036, 10037], leaf: 10035 }, + Case { id: "bettertls::nameconstraints::tc3034", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10039, 10040], leaf: 10038 }, + Case { id: "bettertls::nameconstraints::tc3035", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10042, 10043], leaf: 10041 }, + Case { id: "bettertls::nameconstraints::tc3036", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10045, 10046], leaf: 10044 }, + Case { id: "bettertls::nameconstraints::tc3037", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10048, 10049], leaf: 10047 }, + Case { id: "bettertls::nameconstraints::tc3038", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10051, 10052], leaf: 10050 }, + Case { id: "bettertls::nameconstraints::tc3039", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10054, 10055], leaf: 10053 }, + Case { id: "bettertls::nameconstraints::tc3040", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10057, 10058], leaf: 10056 }, + Case { id: "bettertls::nameconstraints::tc3041", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10060, 10061], leaf: 10059 }, + Case { id: "bettertls::nameconstraints::tc3042", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10063, 10064], leaf: 10062 }, + Case { id: "bettertls::nameconstraints::tc3043", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10066, 10067], leaf: 10065 }, + Case { id: "bettertls::nameconstraints::tc3044", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10069, 10070], leaf: 10068 }, + Case { id: "bettertls::nameconstraints::tc3045", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10072, 10073], leaf: 10071 }, + Case { id: "bettertls::nameconstraints::tc3046", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10075, 10076], leaf: 10074 }, + Case { id: "bettertls::nameconstraints::tc3047", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10078, 10079], leaf: 10077 }, + Case { id: "bettertls::nameconstraints::tc3048", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10081, 10082], leaf: 10080 }, + Case { id: "bettertls::nameconstraints::tc3049", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10084, 10085], leaf: 10083 }, + Case { id: "bettertls::nameconstraints::tc3050", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10087, 10088], leaf: 10086 }, + Case { id: "bettertls::nameconstraints::tc3051", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10090, 10091], leaf: 10089 }, + Case { id: "bettertls::nameconstraints::tc3052", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10093, 10094], leaf: 10092 }, + Case { id: "bettertls::nameconstraints::tc3053", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10096, 10097], leaf: 10095 }, + Case { id: "bettertls::nameconstraints::tc3054", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10099, 10100], leaf: 10098 }, + Case { id: "bettertls::nameconstraints::tc3055", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10102, 10103], leaf: 10101 }, + Case { id: "bettertls::nameconstraints::tc3056", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10105, 10106], leaf: 10104 }, + Case { id: "bettertls::nameconstraints::tc3057", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10108, 10109], leaf: 10107 }, + Case { id: "bettertls::nameconstraints::tc3058", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10111, 10112], leaf: 10110 }, + Case { id: "bettertls::nameconstraints::tc3059", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10114, 10115], leaf: 10113 }, + Case { id: "bettertls::nameconstraints::tc3060", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10117, 10118], leaf: 10116 }, + Case { id: "bettertls::nameconstraints::tc3061", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10120, 10121], leaf: 10119 }, + Case { id: "bettertls::nameconstraints::tc3062", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10123, 10124], leaf: 10122 }, + Case { id: "bettertls::nameconstraints::tc3063", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10126, 10127], leaf: 10125 }, + Case { id: "bettertls::nameconstraints::tc3064", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10129, 10130], leaf: 10128 }, + Case { id: "bettertls::nameconstraints::tc3065", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10132, 10133], leaf: 10131 }, + Case { id: "bettertls::nameconstraints::tc3066", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10135, 10136], leaf: 10134 }, + Case { id: "bettertls::nameconstraints::tc3067", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10138, 10139], leaf: 10137 }, + Case { id: "bettertls::nameconstraints::tc3068", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10141, 10142], leaf: 10140 }, + Case { id: "bettertls::nameconstraints::tc3069", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10144, 10145], leaf: 10143 }, + Case { id: "bettertls::nameconstraints::tc3070", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10147, 10148], leaf: 10146 }, + Case { id: "bettertls::nameconstraints::tc3071", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10150, 10151], leaf: 10149 }, + Case { id: "bettertls::nameconstraints::tc3072", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10153, 10154], leaf: 10152 }, + Case { id: "bettertls::nameconstraints::tc3073", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10156, 10157], leaf: 10155 }, + Case { id: "bettertls::nameconstraints::tc3074", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10159, 10160], leaf: 10158 }, + Case { id: "bettertls::nameconstraints::tc3075", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10162, 10163], leaf: 10161 }, + Case { id: "bettertls::nameconstraints::tc3076", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10165, 10166], leaf: 10164 }, + Case { id: "bettertls::nameconstraints::tc3077", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10168, 10169], leaf: 10167 }, + Case { id: "bettertls::nameconstraints::tc3078", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10171, 10172], leaf: 10170 }, + Case { id: "bettertls::nameconstraints::tc3079", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10174, 10175], leaf: 10173 }, + Case { id: "bettertls::nameconstraints::tc3080", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10177, 10178], leaf: 10176 }, + Case { id: "bettertls::nameconstraints::tc3081", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10180, 10181], leaf: 10179 }, + Case { id: "bettertls::nameconstraints::tc3082", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10183, 10184], leaf: 10182 }, + Case { id: "bettertls::nameconstraints::tc3083", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10186, 10187], leaf: 10185 }, + Case { id: "bettertls::nameconstraints::tc3084", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10189, 10190], leaf: 10188 }, + Case { id: "bettertls::nameconstraints::tc3085", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10192, 10193], leaf: 10191 }, + Case { id: "bettertls::nameconstraints::tc3086", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10195, 10196], leaf: 10194 }, + Case { id: "bettertls::nameconstraints::tc3087", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10198, 10199], leaf: 10197 }, + Case { id: "bettertls::nameconstraints::tc3088", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10201, 10202], leaf: 10200 }, + Case { id: "bettertls::nameconstraints::tc3089", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10204, 10205], leaf: 10203 }, + Case { id: "bettertls::nameconstraints::tc3090", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10207, 10208], leaf: 10206 }, + Case { id: "bettertls::nameconstraints::tc3091", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10210, 10211], leaf: 10209 }, + Case { id: "bettertls::nameconstraints::tc3092", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10213, 10214], leaf: 10212 }, + Case { id: "bettertls::nameconstraints::tc3093", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10216, 10217], leaf: 10215 }, + Case { id: "bettertls::nameconstraints::tc3094", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10219, 10220], leaf: 10218 }, + Case { id: "bettertls::nameconstraints::tc3095", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10222, 10223], leaf: 10221 }, + Case { id: "bettertls::nameconstraints::tc3096", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10225, 10226], leaf: 10224 }, + Case { id: "bettertls::nameconstraints::tc3097", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10228, 10229], leaf: 10227 }, + Case { id: "bettertls::nameconstraints::tc3098", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10231, 10232], leaf: 10230 }, + Case { id: "bettertls::nameconstraints::tc3099", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10234, 10235], leaf: 10233 }, + Case { id: "bettertls::nameconstraints::tc3100", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10237, 10238], leaf: 10236 }, + Case { id: "bettertls::nameconstraints::tc3101", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10240, 10241], leaf: 10239 }, + Case { id: "bettertls::nameconstraints::tc3102", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10243, 10244], leaf: 10242 }, + Case { id: "bettertls::nameconstraints::tc3103", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10246, 10247], leaf: 10245 }, + Case { id: "bettertls::nameconstraints::tc3104", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10249, 10250], leaf: 10248 }, + Case { id: "bettertls::nameconstraints::tc3105", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10252, 10253], leaf: 10251 }, + Case { id: "bettertls::nameconstraints::tc3106", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10255, 10256], leaf: 10254 }, + Case { id: "bettertls::nameconstraints::tc3107", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10258, 10259], leaf: 10257 }, + Case { id: "bettertls::nameconstraints::tc3108", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10261, 10262], leaf: 10260 }, + Case { id: "bettertls::nameconstraints::tc3109", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10264, 10265], leaf: 10263 }, + Case { id: "bettertls::nameconstraints::tc3110", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10267, 10268], leaf: 10266 }, + Case { id: "bettertls::nameconstraints::tc3111", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10270, 10271], leaf: 10269 }, + Case { id: "bettertls::nameconstraints::tc3112", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10273, 10274], leaf: 10272 }, + Case { id: "bettertls::nameconstraints::tc3113", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10276, 10277], leaf: 10275 }, + Case { id: "bettertls::nameconstraints::tc3114", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10279, 10280], leaf: 10278 }, + Case { id: "bettertls::nameconstraints::tc3115", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10282, 10283], leaf: 10281 }, + Case { id: "bettertls::nameconstraints::tc3116", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10285, 10286], leaf: 10284 }, + Case { id: "bettertls::nameconstraints::tc3117", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10288, 10289], leaf: 10287 }, + Case { id: "bettertls::nameconstraints::tc3118", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10291, 10292], leaf: 10290 }, + Case { id: "bettertls::nameconstraints::tc3119", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10294, 10295], leaf: 10293 }, + Case { id: "bettertls::nameconstraints::tc3120", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10297, 10298], leaf: 10296 }, + Case { id: "bettertls::nameconstraints::tc3121", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10300, 10301], leaf: 10299 }, + Case { id: "bettertls::nameconstraints::tc3122", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10303, 10304], leaf: 10302 }, + Case { id: "bettertls::nameconstraints::tc3123", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10306, 10307], leaf: 10305 }, + Case { id: "bettertls::nameconstraints::tc3124", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10309, 10310], leaf: 10308 }, + Case { id: "bettertls::nameconstraints::tc3125", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10312, 10313], leaf: 10311 }, + Case { id: "bettertls::nameconstraints::tc3126", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10315, 10316], leaf: 10314 }, + Case { id: "bettertls::nameconstraints::tc3127", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10318, 10319], leaf: 10317 }, + Case { id: "bettertls::nameconstraints::tc3128", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10321, 10322], leaf: 10320 }, + Case { id: "bettertls::nameconstraints::tc3129", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10324, 10325], leaf: 10323 }, + Case { id: "bettertls::nameconstraints::tc3130", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10327, 10328], leaf: 10326 }, + Case { id: "bettertls::nameconstraints::tc3131", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10330, 10331], leaf: 10329 }, + Case { id: "bettertls::nameconstraints::tc3132", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10333, 10334], leaf: 10332 }, + Case { id: "bettertls::nameconstraints::tc3133", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10336, 10337], leaf: 10335 }, + Case { id: "bettertls::nameconstraints::tc3134", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10339, 10340], leaf: 10338 }, + Case { id: "bettertls::nameconstraints::tc3135", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10342, 10343], leaf: 10341 }, + Case { id: "bettertls::nameconstraints::tc3136", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10345, 10346], leaf: 10344 }, + Case { id: "bettertls::nameconstraints::tc3137", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10348, 10349], leaf: 10347 }, + Case { id: "bettertls::nameconstraints::tc3138", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10351, 10352], leaf: 10350 }, + Case { id: "bettertls::nameconstraints::tc3139", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10354, 10355], leaf: 10353 }, + Case { id: "bettertls::nameconstraints::tc3140", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10357, 10358], leaf: 10356 }, + Case { id: "bettertls::nameconstraints::tc3141", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10360, 10361], leaf: 10359 }, + Case { id: "bettertls::nameconstraints::tc3142", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10363, 10364], leaf: 10362 }, + Case { id: "bettertls::nameconstraints::tc3143", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10366, 10367], leaf: 10365 }, + Case { id: "bettertls::nameconstraints::tc3144", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10369, 10370], leaf: 10368 }, + Case { id: "bettertls::nameconstraints::tc3145", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10372, 10373], leaf: 10371 }, + Case { id: "bettertls::nameconstraints::tc3146", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10375, 10376], leaf: 10374 }, + Case { id: "bettertls::nameconstraints::tc3147", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10378, 10379], leaf: 10377 }, + Case { id: "bettertls::nameconstraints::tc3148", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10381, 10382], leaf: 10380 }, + Case { id: "bettertls::nameconstraints::tc3149", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10384, 10385], leaf: 10383 }, + Case { id: "bettertls::nameconstraints::tc3150", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10387, 10388], leaf: 10386 }, + Case { id: "bettertls::nameconstraints::tc3151", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10390, 10391], leaf: 10389 }, + Case { id: "bettertls::nameconstraints::tc3152", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10393, 10394], leaf: 10392 }, + Case { id: "bettertls::nameconstraints::tc3153", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10396, 10397], leaf: 10395 }, + Case { id: "bettertls::nameconstraints::tc3154", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10399, 10400], leaf: 10398 }, + Case { id: "bettertls::nameconstraints::tc3155", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10402, 10403], leaf: 10401 }, + Case { id: "bettertls::nameconstraints::tc3156", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10405, 10406], leaf: 10404 }, + Case { id: "bettertls::nameconstraints::tc3157", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10408, 10409], leaf: 10407 }, + Case { id: "bettertls::nameconstraints::tc3158", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10411, 10412], leaf: 10410 }, + Case { id: "bettertls::nameconstraints::tc3159", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10414, 10415], leaf: 10413 }, + Case { id: "bettertls::nameconstraints::tc3160", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10417, 10418], leaf: 10416 }, + Case { id: "bettertls::nameconstraints::tc3161", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10420, 10421], leaf: 10419 }, + Case { id: "bettertls::nameconstraints::tc3162", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10423, 10424], leaf: 10422 }, + Case { id: "bettertls::nameconstraints::tc3163", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10426, 10427], leaf: 10425 }, + Case { id: "bettertls::nameconstraints::tc3164", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10429, 10430], leaf: 10428 }, + Case { id: "bettertls::nameconstraints::tc3165", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10432, 10433], leaf: 10431 }, + Case { id: "bettertls::nameconstraints::tc3166", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10435, 10436], leaf: 10434 }, + Case { id: "bettertls::nameconstraints::tc3167", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10438, 10439], leaf: 10437 }, + Case { id: "bettertls::nameconstraints::tc3168", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10441, 10442], leaf: 10440 }, + Case { id: "bettertls::nameconstraints::tc3169", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10444, 10445], leaf: 10443 }, + Case { id: "bettertls::nameconstraints::tc3170", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10447, 10448], leaf: 10446 }, + Case { id: "bettertls::nameconstraints::tc3171", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10450, 10451], leaf: 10449 }, + Case { id: "bettertls::nameconstraints::tc3172", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10453, 10454], leaf: 10452 }, + Case { id: "bettertls::nameconstraints::tc3173", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10456, 10457], leaf: 10455 }, + Case { id: "bettertls::nameconstraints::tc3174", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10459, 10460], leaf: 10458 }, + Case { id: "bettertls::nameconstraints::tc3175", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10462, 10463], leaf: 10461 }, + Case { id: "bettertls::nameconstraints::tc3176", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10465, 10466], leaf: 10464 }, + Case { id: "bettertls::nameconstraints::tc3177", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10468, 10469], leaf: 10467 }, + Case { id: "bettertls::nameconstraints::tc3178", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10471, 10472], leaf: 10470 }, + Case { id: "bettertls::nameconstraints::tc3179", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10474, 10475], leaf: 10473 }, + Case { id: "bettertls::nameconstraints::tc3180", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10477, 10478], leaf: 10476 }, + Case { id: "bettertls::nameconstraints::tc3181", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10480, 10481], leaf: 10479 }, + Case { id: "bettertls::nameconstraints::tc3182", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10483, 10484], leaf: 10482 }, + Case { id: "bettertls::nameconstraints::tc3183", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10486, 10487], leaf: 10485 }, + Case { id: "bettertls::nameconstraints::tc3184", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10489, 10490], leaf: 10488 }, + Case { id: "bettertls::nameconstraints::tc3185", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10492, 10493], leaf: 10491 }, + Case { id: "bettertls::nameconstraints::tc3186", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10495, 10496], leaf: 10494 }, + Case { id: "bettertls::nameconstraints::tc3187", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10498, 10499], leaf: 10497 }, + Case { id: "bettertls::nameconstraints::tc3188", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10501, 10502], leaf: 10500 }, + Case { id: "bettertls::nameconstraints::tc3189", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10504, 10505], leaf: 10503 }, + Case { id: "bettertls::nameconstraints::tc3190", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10507, 10508], leaf: 10506 }, + Case { id: "bettertls::nameconstraints::tc3191", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10510, 10511], leaf: 10509 }, + Case { id: "bettertls::nameconstraints::tc3192", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10513, 10514], leaf: 10512 }, + Case { id: "bettertls::nameconstraints::tc3193", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10516, 10517], leaf: 10515 }, + Case { id: "bettertls::nameconstraints::tc3194", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10519, 10520], leaf: 10518 }, + Case { id: "bettertls::nameconstraints::tc3195", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10522, 10523], leaf: 10521 }, + Case { id: "bettertls::nameconstraints::tc3196", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10525, 10526], leaf: 10524 }, + Case { id: "bettertls::nameconstraints::tc3197", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10528, 10529], leaf: 10527 }, + Case { id: "bettertls::nameconstraints::tc3198", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10531, 10532], leaf: 10530 }, + Case { id: "bettertls::nameconstraints::tc3199", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10534, 10535], leaf: 10533 }, + Case { id: "bettertls::nameconstraints::tc3200", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10537, 10538], leaf: 10536 }, + Case { id: "bettertls::nameconstraints::tc3201", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10540, 10541], leaf: 10539 }, + Case { id: "bettertls::nameconstraints::tc3202", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10543, 10544], leaf: 10542 }, + Case { id: "bettertls::nameconstraints::tc3203", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10546, 10547], leaf: 10545 }, + Case { id: "bettertls::nameconstraints::tc3204", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10549, 10550], leaf: 10548 }, + Case { id: "bettertls::nameconstraints::tc3205", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10552, 10553], leaf: 10551 }, + Case { id: "bettertls::nameconstraints::tc3206", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10555, 10556], leaf: 10554 }, + Case { id: "bettertls::nameconstraints::tc3207", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10558, 10559], leaf: 10557 }, + Case { id: "bettertls::nameconstraints::tc3208", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10561, 10562], leaf: 10560 }, + Case { id: "bettertls::nameconstraints::tc3209", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10564, 10565], leaf: 10563 }, + Case { id: "bettertls::nameconstraints::tc3210", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10567, 10568], leaf: 10566 }, + Case { id: "bettertls::nameconstraints::tc3211", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10570, 10571], leaf: 10569 }, + Case { id: "bettertls::nameconstraints::tc3212", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10573, 10574], leaf: 10572 }, + Case { id: "bettertls::nameconstraints::tc3213", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10576, 10577], leaf: 10575 }, + Case { id: "bettertls::nameconstraints::tc3214", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10579, 10580], leaf: 10578 }, + Case { id: "bettertls::nameconstraints::tc3215", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10582, 10583], leaf: 10581 }, + Case { id: "bettertls::nameconstraints::tc3216", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10585, 10586], leaf: 10584 }, + Case { id: "bettertls::nameconstraints::tc3217", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10588, 10589], leaf: 10587 }, + Case { id: "bettertls::nameconstraints::tc3218", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10591, 10592], leaf: 10590 }, + Case { id: "bettertls::nameconstraints::tc3219", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10594, 10595], leaf: 10593 }, + Case { id: "bettertls::nameconstraints::tc3220", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10597, 10598], leaf: 10596 }, + Case { id: "bettertls::nameconstraints::tc3221", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10600, 10601], leaf: 10599 }, + Case { id: "bettertls::nameconstraints::tc3222", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10603, 10604], leaf: 10602 }, + Case { id: "bettertls::nameconstraints::tc3223", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10606, 10607], leaf: 10605 }, + Case { id: "bettertls::nameconstraints::tc3224", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10609, 10610], leaf: 10608 }, + Case { id: "bettertls::nameconstraints::tc3225", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10612, 10613], leaf: 10611 }, + Case { id: "bettertls::nameconstraints::tc3226", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10615, 10616], leaf: 10614 }, + Case { id: "bettertls::nameconstraints::tc3227", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10618, 10619], leaf: 10617 }, + Case { id: "bettertls::nameconstraints::tc3228", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10621, 10622], leaf: 10620 }, + Case { id: "bettertls::nameconstraints::tc3229", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10624, 10625], leaf: 10623 }, + Case { id: "bettertls::nameconstraints::tc3230", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10627, 10628], leaf: 10626 }, + Case { id: "bettertls::nameconstraints::tc3231", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10630, 10631], leaf: 10629 }, + Case { id: "bettertls::nameconstraints::tc3232", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10633, 10634], leaf: 10632 }, + Case { id: "bettertls::nameconstraints::tc3233", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10636, 10637], leaf: 10635 }, + Case { id: "bettertls::nameconstraints::tc3234", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10639, 10640], leaf: 10638 }, + Case { id: "bettertls::nameconstraints::tc3235", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10642, 10643], leaf: 10641 }, + Case { id: "bettertls::nameconstraints::tc3236", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10645, 10646], leaf: 10644 }, + Case { id: "bettertls::nameconstraints::tc3237", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10648, 10649], leaf: 10647 }, + Case { id: "bettertls::nameconstraints::tc3238", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10651, 10652], leaf: 10650 }, + Case { id: "bettertls::nameconstraints::tc3239", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10654, 10655], leaf: 10653 }, + Case { id: "bettertls::nameconstraints::tc3240", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10657, 10658], leaf: 10656 }, + Case { id: "bettertls::nameconstraints::tc3241", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10660, 10661], leaf: 10659 }, + Case { id: "bettertls::nameconstraints::tc3242", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10663, 10664], leaf: 10662 }, + Case { id: "bettertls::nameconstraints::tc3243", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10666, 10667], leaf: 10665 }, + Case { id: "bettertls::nameconstraints::tc3244", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10669, 10670], leaf: 10668 }, + Case { id: "bettertls::nameconstraints::tc3245", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10672, 10673], leaf: 10671 }, + Case { id: "bettertls::nameconstraints::tc3246", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10675, 10676], leaf: 10674 }, + Case { id: "bettertls::nameconstraints::tc3247", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10678, 10679], leaf: 10677 }, + Case { id: "bettertls::nameconstraints::tc3248", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10681, 10682], leaf: 10680 }, + Case { id: "bettertls::nameconstraints::tc3249", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10684, 10685], leaf: 10683 }, + Case { id: "bettertls::nameconstraints::tc3250", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10687, 10688], leaf: 10686 }, + Case { id: "bettertls::nameconstraints::tc3251", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10690, 10691], leaf: 10689 }, + Case { id: "bettertls::nameconstraints::tc3252", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10693, 10694], leaf: 10692 }, + Case { id: "bettertls::nameconstraints::tc3253", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10696, 10697], leaf: 10695 }, + Case { id: "bettertls::nameconstraints::tc3254", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10699, 10700], leaf: 10698 }, + Case { id: "bettertls::nameconstraints::tc3255", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10702, 10703], leaf: 10701 }, + Case { id: "bettertls::nameconstraints::tc3256", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10705, 10706], leaf: 10704 }, + Case { id: "bettertls::nameconstraints::tc3257", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10708, 10709], leaf: 10707 }, + Case { id: "bettertls::nameconstraints::tc3258", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10711, 10712], leaf: 10710 }, + Case { id: "bettertls::nameconstraints::tc3259", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10714, 10715], leaf: 10713 }, + Case { id: "bettertls::nameconstraints::tc3260", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10717, 10718], leaf: 10716 }, + Case { id: "bettertls::nameconstraints::tc3261", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10720, 10721], leaf: 10719 }, + Case { id: "bettertls::nameconstraints::tc3262", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10723, 10724], leaf: 10722 }, + Case { id: "bettertls::nameconstraints::tc3263", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10726, 10727], leaf: 10725 }, + Case { id: "bettertls::nameconstraints::tc3264", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10729, 10730], leaf: 10728 }, + Case { id: "bettertls::nameconstraints::tc3265", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10732, 10733], leaf: 10731 }, + Case { id: "bettertls::nameconstraints::tc3266", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10735, 10736], leaf: 10734 }, + Case { id: "bettertls::nameconstraints::tc3267", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10738, 10739], leaf: 10737 }, + Case { id: "bettertls::nameconstraints::tc3268", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10741, 10742], leaf: 10740 }, + Case { id: "bettertls::nameconstraints::tc3269", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10744, 10745], leaf: 10743 }, + Case { id: "bettertls::nameconstraints::tc3270", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10747, 10748], leaf: 10746 }, + Case { id: "bettertls::nameconstraints::tc3271", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10750, 10751], leaf: 10749 }, + Case { id: "bettertls::nameconstraints::tc3272", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10753, 10754], leaf: 10752 }, + Case { id: "bettertls::nameconstraints::tc3273", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10756, 10757], leaf: 10755 }, + Case { id: "bettertls::nameconstraints::tc3274", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10759, 10760], leaf: 10758 }, + Case { id: "bettertls::nameconstraints::tc3275", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10762, 10763], leaf: 10761 }, + Case { id: "bettertls::nameconstraints::tc3276", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10765, 10766], leaf: 10764 }, + Case { id: "bettertls::nameconstraints::tc3277", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10768, 10769], leaf: 10767 }, + Case { id: "bettertls::nameconstraints::tc3278", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10771, 10772], leaf: 10770 }, + Case { id: "bettertls::nameconstraints::tc3279", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10774, 10775], leaf: 10773 }, + Case { id: "bettertls::nameconstraints::tc3280", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10777, 10778], leaf: 10776 }, + Case { id: "bettertls::nameconstraints::tc3281", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10780, 10781], leaf: 10779 }, + Case { id: "bettertls::nameconstraints::tc3282", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10783, 10784], leaf: 10782 }, + Case { id: "bettertls::nameconstraints::tc3283", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10786, 10787], leaf: 10785 }, + Case { id: "bettertls::nameconstraints::tc3284", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10789, 10790], leaf: 10788 }, + Case { id: "bettertls::nameconstraints::tc3285", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10792, 10793], leaf: 10791 }, + Case { id: "bettertls::nameconstraints::tc3286", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10795, 10796], leaf: 10794 }, + Case { id: "bettertls::nameconstraints::tc3287", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10798, 10799], leaf: 10797 }, + Case { id: "bettertls::nameconstraints::tc3288", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10801, 10802], leaf: 10800 }, + Case { id: "bettertls::nameconstraints::tc3289", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10804, 10805], leaf: 10803 }, + Case { id: "bettertls::nameconstraints::tc3290", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10807, 10808], leaf: 10806 }, + Case { id: "bettertls::nameconstraints::tc3291", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10810, 10811], leaf: 10809 }, + Case { id: "bettertls::nameconstraints::tc3292", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10813, 10814], leaf: 10812 }, + Case { id: "bettertls::nameconstraints::tc3293", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10816, 10817], leaf: 10815 }, + Case { id: "bettertls::nameconstraints::tc3294", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10819, 10820], leaf: 10818 }, + Case { id: "bettertls::nameconstraints::tc3295", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10822, 10823], leaf: 10821 }, + Case { id: "bettertls::nameconstraints::tc3296", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10825, 10826], leaf: 10824 }, + Case { id: "bettertls::nameconstraints::tc3297", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10828, 10829], leaf: 10827 }, + Case { id: "bettertls::nameconstraints::tc3298", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10831, 10832], leaf: 10830 }, + Case { id: "bettertls::nameconstraints::tc3299", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10834, 10835], leaf: 10833 }, + Case { id: "bettertls::nameconstraints::tc3300", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10837, 10838], leaf: 10836 }, + Case { id: "bettertls::nameconstraints::tc3301", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10840, 10841], leaf: 10839 }, + Case { id: "bettertls::nameconstraints::tc3302", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10843, 10844], leaf: 10842 }, + Case { id: "bettertls::nameconstraints::tc3303", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10846, 10847], leaf: 10845 }, + Case { id: "bettertls::nameconstraints::tc3304", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10849, 10850], leaf: 10848 }, + Case { id: "bettertls::nameconstraints::tc3305", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10852, 10853], leaf: 10851 }, + Case { id: "bettertls::nameconstraints::tc3306", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10855, 10856], leaf: 10854 }, + Case { id: "bettertls::nameconstraints::tc3307", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10858, 10859], leaf: 10857 }, + Case { id: "bettertls::nameconstraints::tc3308", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10861, 10862], leaf: 10860 }, + Case { id: "bettertls::nameconstraints::tc3309", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10864, 10865], leaf: 10863 }, + Case { id: "bettertls::nameconstraints::tc3310", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10867, 10868], leaf: 10866 }, + Case { id: "bettertls::nameconstraints::tc3311", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10870, 10871], leaf: 10869 }, + Case { id: "bettertls::nameconstraints::tc3312", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10873, 10874], leaf: 10872 }, + Case { id: "bettertls::nameconstraints::tc3313", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10876, 10877], leaf: 10875 }, + Case { id: "bettertls::nameconstraints::tc3314", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10879, 10880], leaf: 10878 }, + Case { id: "bettertls::nameconstraints::tc3315", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10882, 10883], leaf: 10881 }, + Case { id: "bettertls::nameconstraints::tc3316", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10885, 10886], leaf: 10884 }, + Case { id: "bettertls::nameconstraints::tc3317", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10888, 10889], leaf: 10887 }, + Case { id: "bettertls::nameconstraints::tc3318", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10891, 10892], leaf: 10890 }, + Case { id: "bettertls::nameconstraints::tc3319", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10894, 10895], leaf: 10893 }, + Case { id: "bettertls::nameconstraints::tc3320", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10897, 10898], leaf: 10896 }, + Case { id: "bettertls::nameconstraints::tc3321", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10900, 10901], leaf: 10899 }, + Case { id: "bettertls::nameconstraints::tc3322", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10903, 10904], leaf: 10902 }, + Case { id: "bettertls::nameconstraints::tc3323", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10906, 10907], leaf: 10905 }, + Case { id: "bettertls::nameconstraints::tc3324", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10909, 10910], leaf: 10908 }, + Case { id: "bettertls::nameconstraints::tc3325", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10912, 10913], leaf: 10911 }, + Case { id: "bettertls::nameconstraints::tc3326", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10915, 10916], leaf: 10914 }, + Case { id: "bettertls::nameconstraints::tc3327", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10918, 10919], leaf: 10917 }, + Case { id: "bettertls::nameconstraints::tc3328", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10921, 10922], leaf: 10920 }, + Case { id: "bettertls::nameconstraints::tc3329", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10924, 10925], leaf: 10923 }, + Case { id: "bettertls::nameconstraints::tc3330", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10927, 10928], leaf: 10926 }, + Case { id: "bettertls::nameconstraints::tc3331", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10930, 10931], leaf: 10929 }, + Case { id: "bettertls::nameconstraints::tc3332", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10933, 10934], leaf: 10932 }, + Case { id: "bettertls::nameconstraints::tc3333", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10936, 10937], leaf: 10935 }, + Case { id: "bettertls::nameconstraints::tc3334", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10939, 10940], leaf: 10938 }, + Case { id: "bettertls::nameconstraints::tc3335", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10942, 10943], leaf: 10941 }, + Case { id: "bettertls::nameconstraints::tc3336", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10945, 10946], leaf: 10944 }, + Case { id: "bettertls::nameconstraints::tc3337", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10948, 10949], leaf: 10947 }, + Case { id: "bettertls::nameconstraints::tc3338", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10951, 10952], leaf: 10950 }, + Case { id: "bettertls::nameconstraints::tc3339", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10954, 10955], leaf: 10953 }, + Case { id: "bettertls::nameconstraints::tc3340", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10957, 10958], leaf: 10956 }, + Case { id: "bettertls::nameconstraints::tc3341", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10960, 10961], leaf: 10959 }, + Case { id: "bettertls::nameconstraints::tc3342", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10963, 10964], leaf: 10962 }, + Case { id: "bettertls::nameconstraints::tc3343", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10966, 10967], leaf: 10965 }, + Case { id: "bettertls::nameconstraints::tc3344", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10969, 10970], leaf: 10968 }, + Case { id: "bettertls::nameconstraints::tc3345", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10972, 10973], leaf: 10971 }, + Case { id: "bettertls::nameconstraints::tc3346", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10975, 10976], leaf: 10974 }, + Case { id: "bettertls::nameconstraints::tc3347", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10978, 10979], leaf: 10977 }, + Case { id: "bettertls::nameconstraints::tc3348", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10981, 10982], leaf: 10980 }, + Case { id: "bettertls::nameconstraints::tc3349", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10984, 10985], leaf: 10983 }, + Case { id: "bettertls::nameconstraints::tc3350", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10987, 10988], leaf: 10986 }, + Case { id: "bettertls::nameconstraints::tc3351", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10990, 10991], leaf: 10989 }, + Case { id: "bettertls::nameconstraints::tc3352", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10993, 10994], leaf: 10992 }, + Case { id: "bettertls::nameconstraints::tc3353", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10996, 10997], leaf: 10995 }, + Case { id: "bettertls::nameconstraints::tc3354", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[10999, 11000], leaf: 10998 }, + Case { id: "bettertls::nameconstraints::tc3355", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11002, 11003], leaf: 11001 }, + Case { id: "bettertls::nameconstraints::tc3356", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11005, 11006], leaf: 11004 }, + Case { id: "bettertls::nameconstraints::tc3357", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11008, 11009], leaf: 11007 }, + Case { id: "bettertls::nameconstraints::tc3358", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11011, 11012], leaf: 11010 }, + Case { id: "bettertls::nameconstraints::tc3359", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11014, 11015], leaf: 11013 }, + Case { id: "bettertls::nameconstraints::tc3360", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11017, 11018], leaf: 11016 }, + Case { id: "bettertls::nameconstraints::tc3361", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11020, 11021], leaf: 11019 }, + Case { id: "bettertls::nameconstraints::tc3362", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11023, 11024], leaf: 11022 }, + Case { id: "bettertls::nameconstraints::tc3363", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11026, 11027], leaf: 11025 }, + Case { id: "bettertls::nameconstraints::tc3364", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11029, 11030], leaf: 11028 }, + Case { id: "bettertls::nameconstraints::tc3365", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11032, 11033], leaf: 11031 }, + Case { id: "bettertls::nameconstraints::tc3366", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11035, 11036], leaf: 11034 }, + Case { id: "bettertls::nameconstraints::tc3367", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11038, 11039], leaf: 11037 }, + Case { id: "bettertls::nameconstraints::tc3368", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11041, 11042], leaf: 11040 }, + Case { id: "bettertls::nameconstraints::tc3369", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11044, 11045], leaf: 11043 }, + Case { id: "bettertls::nameconstraints::tc3370", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11047, 11048], leaf: 11046 }, + Case { id: "bettertls::nameconstraints::tc3371", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11050, 11051], leaf: 11049 }, + Case { id: "bettertls::nameconstraints::tc3372", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11053, 11054], leaf: 11052 }, + Case { id: "bettertls::nameconstraints::tc3373", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11056, 11057], leaf: 11055 }, + Case { id: "bettertls::nameconstraints::tc3374", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11059, 11060], leaf: 11058 }, + Case { id: "bettertls::nameconstraints::tc3375", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11062, 11063], leaf: 11061 }, + Case { id: "bettertls::nameconstraints::tc3376", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11065, 11066], leaf: 11064 }, + Case { id: "bettertls::nameconstraints::tc3377", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11068, 11069], leaf: 11067 }, + Case { id: "bettertls::nameconstraints::tc3378", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11071, 11072], leaf: 11070 }, + Case { id: "bettertls::nameconstraints::tc3379", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11074, 11075], leaf: 11073 }, + Case { id: "bettertls::nameconstraints::tc3380", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11077, 11078], leaf: 11076 }, + Case { id: "bettertls::nameconstraints::tc3381", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11080, 11081], leaf: 11079 }, + Case { id: "bettertls::nameconstraints::tc3382", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11083, 11084], leaf: 11082 }, + Case { id: "bettertls::nameconstraints::tc3383", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11086, 11087], leaf: 11085 }, + Case { id: "bettertls::nameconstraints::tc3384", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11089, 11090], leaf: 11088 }, + Case { id: "bettertls::nameconstraints::tc3385", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11092, 11093], leaf: 11091 }, + Case { id: "bettertls::nameconstraints::tc3386", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11095, 11096], leaf: 11094 }, + Case { id: "bettertls::nameconstraints::tc3387", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11098, 11099], leaf: 11097 }, + Case { id: "bettertls::nameconstraints::tc3388", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11101, 11102], leaf: 11100 }, + Case { id: "bettertls::nameconstraints::tc3389", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11104, 11105], leaf: 11103 }, + Case { id: "bettertls::nameconstraints::tc3390", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11107, 11108], leaf: 11106 }, + Case { id: "bettertls::nameconstraints::tc3391", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11110, 11111], leaf: 11109 }, + Case { id: "bettertls::nameconstraints::tc3392", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11113, 11114], leaf: 11112 }, + Case { id: "bettertls::nameconstraints::tc3393", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11116, 11117], leaf: 11115 }, + Case { id: "bettertls::nameconstraints::tc3394", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11119, 11120], leaf: 11118 }, + Case { id: "bettertls::nameconstraints::tc3395", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11122, 11123], leaf: 11121 }, + Case { id: "bettertls::nameconstraints::tc3396", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11125, 11126], leaf: 11124 }, + Case { id: "bettertls::nameconstraints::tc3397", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11128, 11129], leaf: 11127 }, + Case { id: "bettertls::nameconstraints::tc3398", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11131, 11132], leaf: 11130 }, + Case { id: "bettertls::nameconstraints::tc3399", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11134, 11135], leaf: 11133 }, + Case { id: "bettertls::nameconstraints::tc3400", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11137, 11138], leaf: 11136 }, + Case { id: "bettertls::nameconstraints::tc3401", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11140, 11141], leaf: 11139 }, + Case { id: "bettertls::nameconstraints::tc3402", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11143, 11144], leaf: 11142 }, + Case { id: "bettertls::nameconstraints::tc3403", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11146, 11147], leaf: 11145 }, + Case { id: "bettertls::nameconstraints::tc3404", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11149, 11150], leaf: 11148 }, + Case { id: "bettertls::nameconstraints::tc3405", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11152, 11153], leaf: 11151 }, + Case { id: "bettertls::nameconstraints::tc3406", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11155, 11156], leaf: 11154 }, + Case { id: "bettertls::nameconstraints::tc3407", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11158, 11159], leaf: 11157 }, + Case { id: "bettertls::nameconstraints::tc3408", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11161, 11162], leaf: 11160 }, + Case { id: "bettertls::nameconstraints::tc3409", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11164, 11165], leaf: 11163 }, + Case { id: "bettertls::nameconstraints::tc3410", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11167, 11168], leaf: 11166 }, + Case { id: "bettertls::nameconstraints::tc3411", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11170, 11171], leaf: 11169 }, + Case { id: "bettertls::nameconstraints::tc3412", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11173, 11174], leaf: 11172 }, + Case { id: "bettertls::nameconstraints::tc3413", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11176, 11177], leaf: 11175 }, + Case { id: "bettertls::nameconstraints::tc3414", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11179, 11180], leaf: 11178 }, + Case { id: "bettertls::nameconstraints::tc3415", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11182, 11183], leaf: 11181 }, + Case { id: "bettertls::nameconstraints::tc3416", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11185, 11186], leaf: 11184 }, + Case { id: "bettertls::nameconstraints::tc3417", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11188, 11189], leaf: 11187 }, + Case { id: "bettertls::nameconstraints::tc3418", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11191, 11192], leaf: 11190 }, + Case { id: "bettertls::nameconstraints::tc3419", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11194, 11195], leaf: 11193 }, + Case { id: "bettertls::nameconstraints::tc3420", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11197, 11198], leaf: 11196 }, + Case { id: "bettertls::nameconstraints::tc3421", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11200, 11201], leaf: 11199 }, + Case { id: "bettertls::nameconstraints::tc3422", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11203, 11204], leaf: 11202 }, + Case { id: "bettertls::nameconstraints::tc3423", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11206, 11207], leaf: 11205 }, + Case { id: "bettertls::nameconstraints::tc3424", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11209, 11210], leaf: 11208 }, + Case { id: "bettertls::nameconstraints::tc3425", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11212, 11213], leaf: 11211 }, + Case { id: "bettertls::nameconstraints::tc3426", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11215, 11216], leaf: 11214 }, + Case { id: "bettertls::nameconstraints::tc3427", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11218, 11219], leaf: 11217 }, + Case { id: "bettertls::nameconstraints::tc3428", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11221, 11222], leaf: 11220 }, + Case { id: "bettertls::nameconstraints::tc3429", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11224, 11225], leaf: 11223 }, + Case { id: "bettertls::nameconstraints::tc3430", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11227, 11228], leaf: 11226 }, + Case { id: "bettertls::nameconstraints::tc3431", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11230, 11231], leaf: 11229 }, + Case { id: "bettertls::nameconstraints::tc3432", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11233, 11234], leaf: 11232 }, + Case { id: "bettertls::nameconstraints::tc3433", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11236, 11237], leaf: 11235 }, + Case { id: "bettertls::nameconstraints::tc3434", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11239, 11240], leaf: 11238 }, + Case { id: "bettertls::nameconstraints::tc3435", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11242, 11243], leaf: 11241 }, + Case { id: "bettertls::nameconstraints::tc3436", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11245, 11246], leaf: 11244 }, + Case { id: "bettertls::nameconstraints::tc3437", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11248, 11249], leaf: 11247 }, + Case { id: "bettertls::nameconstraints::tc3438", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11251, 11252], leaf: 11250 }, + Case { id: "bettertls::nameconstraints::tc3439", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11254, 11255], leaf: 11253 }, + Case { id: "bettertls::nameconstraints::tc3440", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11257, 11258], leaf: 11256 }, + Case { id: "bettertls::nameconstraints::tc3441", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11260, 11261], leaf: 11259 }, + Case { id: "bettertls::nameconstraints::tc3442", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11263, 11264], leaf: 11262 }, + Case { id: "bettertls::nameconstraints::tc3443", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11266, 11267], leaf: 11265 }, + Case { id: "bettertls::nameconstraints::tc3444", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11269, 11270], leaf: 11268 }, + Case { id: "bettertls::nameconstraints::tc3445", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11272, 11273], leaf: 11271 }, + Case { id: "bettertls::nameconstraints::tc3446", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11275, 11276], leaf: 11274 }, + Case { id: "bettertls::nameconstraints::tc3447", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11278, 11279], leaf: 11277 }, + Case { id: "bettertls::nameconstraints::tc3448", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11281, 11282], leaf: 11280 }, + Case { id: "bettertls::nameconstraints::tc3449", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11284, 11285], leaf: 11283 }, + Case { id: "bettertls::nameconstraints::tc3450", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11287, 11288], leaf: 11286 }, + Case { id: "bettertls::nameconstraints::tc3451", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11290, 11291], leaf: 11289 }, + Case { id: "bettertls::nameconstraints::tc3452", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11293, 11294], leaf: 11292 }, + Case { id: "bettertls::nameconstraints::tc3453", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11296, 11297], leaf: 11295 }, + Case { id: "bettertls::nameconstraints::tc3454", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11299, 11300], leaf: 11298 }, + Case { id: "bettertls::nameconstraints::tc3455", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11302, 11303], leaf: 11301 }, + Case { id: "bettertls::nameconstraints::tc3456", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11305, 11306], leaf: 11304 }, + Case { id: "bettertls::nameconstraints::tc3457", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11308, 11309], leaf: 11307 }, + Case { id: "bettertls::nameconstraints::tc3458", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11311, 11312], leaf: 11310 }, + Case { id: "bettertls::nameconstraints::tc3459", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11314, 11315], leaf: 11313 }, + Case { id: "bettertls::nameconstraints::tc3460", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11317, 11318], leaf: 11316 }, + Case { id: "bettertls::nameconstraints::tc3461", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11320, 11321], leaf: 11319 }, + Case { id: "bettertls::nameconstraints::tc3462", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11323, 11324], leaf: 11322 }, + Case { id: "bettertls::nameconstraints::tc3463", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11326, 11327], leaf: 11325 }, + Case { id: "bettertls::nameconstraints::tc3464", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11329, 11330], leaf: 11328 }, + Case { id: "bettertls::nameconstraints::tc3465", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11332, 11333], leaf: 11331 }, + Case { id: "bettertls::nameconstraints::tc3466", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11335, 11336], leaf: 11334 }, + Case { id: "bettertls::nameconstraints::tc3467", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11338, 11339], leaf: 11337 }, + Case { id: "bettertls::nameconstraints::tc3468", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11341, 11342], leaf: 11340 }, + Case { id: "bettertls::nameconstraints::tc3469", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11344, 11345], leaf: 11343 }, + Case { id: "bettertls::nameconstraints::tc3470", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11347, 11348], leaf: 11346 }, + Case { id: "bettertls::nameconstraints::tc3471", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11350, 11351], leaf: 11349 }, + Case { id: "bettertls::nameconstraints::tc3472", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11353, 11354], leaf: 11352 }, + Case { id: "bettertls::nameconstraints::tc3473", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11356, 11357], leaf: 11355 }, + Case { id: "bettertls::nameconstraints::tc3474", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11359, 11360], leaf: 11358 }, + Case { id: "bettertls::nameconstraints::tc3475", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11362, 11363], leaf: 11361 }, + Case { id: "bettertls::nameconstraints::tc3476", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11365, 11366], leaf: 11364 }, + Case { id: "bettertls::nameconstraints::tc3477", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11368, 11369], leaf: 11367 }, + Case { id: "bettertls::nameconstraints::tc3478", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11371, 11372], leaf: 11370 }, + Case { id: "bettertls::nameconstraints::tc3479", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11374, 11375], leaf: 11373 }, + Case { id: "bettertls::nameconstraints::tc3480", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11377, 11378], leaf: 11376 }, + Case { id: "bettertls::nameconstraints::tc3481", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11380, 11381], leaf: 11379 }, + Case { id: "bettertls::nameconstraints::tc3482", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11383, 11384], leaf: 11382 }, + Case { id: "bettertls::nameconstraints::tc3483", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11386, 11387], leaf: 11385 }, + Case { id: "bettertls::nameconstraints::tc3484", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11389, 11390], leaf: 11388 }, + Case { id: "bettertls::nameconstraints::tc3485", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11392, 11393], leaf: 11391 }, + Case { id: "bettertls::nameconstraints::tc3486", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11395, 11396], leaf: 11394 }, + Case { id: "bettertls::nameconstraints::tc3487", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11398, 11399], leaf: 11397 }, + Case { id: "bettertls::nameconstraints::tc3488", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11401, 11402], leaf: 11400 }, + Case { id: "bettertls::nameconstraints::tc3489", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11404, 11405], leaf: 11403 }, + Case { id: "bettertls::nameconstraints::tc3490", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11407, 11408], leaf: 11406 }, + Case { id: "bettertls::nameconstraints::tc3491", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11410, 11411], leaf: 11409 }, + Case { id: "bettertls::nameconstraints::tc3492", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11413, 11414], leaf: 11412 }, + Case { id: "bettertls::nameconstraints::tc3493", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11416, 11417], leaf: 11415 }, + Case { id: "bettertls::nameconstraints::tc3494", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11419, 11420], leaf: 11418 }, + Case { id: "bettertls::nameconstraints::tc3495", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11422, 11423], leaf: 11421 }, + Case { id: "bettertls::nameconstraints::tc3496", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11425, 11426], leaf: 11424 }, + Case { id: "bettertls::nameconstraints::tc3497", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11428, 11429], leaf: 11427 }, + Case { id: "bettertls::nameconstraints::tc3498", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11431, 11432], leaf: 11430 }, + Case { id: "bettertls::nameconstraints::tc3499", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11434, 11435], leaf: 11433 }, + Case { id: "bettertls::nameconstraints::tc3500", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11437, 11438], leaf: 11436 }, + Case { id: "bettertls::nameconstraints::tc3501", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11440, 11441], leaf: 11439 }, + Case { id: "bettertls::nameconstraints::tc3502", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11443, 11444], leaf: 11442 }, + Case { id: "bettertls::nameconstraints::tc3503", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11446, 11447], leaf: 11445 }, + Case { id: "bettertls::nameconstraints::tc3504", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11449, 11450], leaf: 11448 }, + Case { id: "bettertls::nameconstraints::tc3505", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11452, 11453], leaf: 11451 }, + Case { id: "bettertls::nameconstraints::tc3506", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11455, 11456], leaf: 11454 }, + Case { id: "bettertls::nameconstraints::tc3507", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11458, 11459], leaf: 11457 }, + Case { id: "bettertls::nameconstraints::tc3508", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11461, 11462], leaf: 11460 }, + Case { id: "bettertls::nameconstraints::tc3509", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11464, 11465], leaf: 11463 }, + Case { id: "bettertls::nameconstraints::tc3510", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11467, 11468], leaf: 11466 }, + Case { id: "bettertls::nameconstraints::tc3511", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11470, 11471], leaf: 11469 }, + Case { id: "bettertls::nameconstraints::tc3512", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11473, 11474], leaf: 11472 }, + Case { id: "bettertls::nameconstraints::tc3513", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11476, 11477], leaf: 11475 }, + Case { id: "bettertls::nameconstraints::tc3514", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11479, 11480], leaf: 11478 }, + Case { id: "bettertls::nameconstraints::tc3515", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11482, 11483], leaf: 11481 }, + Case { id: "bettertls::nameconstraints::tc3516", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11485, 11486], leaf: 11484 }, + Case { id: "bettertls::nameconstraints::tc3517", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11488, 11489], leaf: 11487 }, + Case { id: "bettertls::nameconstraints::tc3518", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11491, 11492], leaf: 11490 }, + Case { id: "bettertls::nameconstraints::tc3519", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11494, 11495], leaf: 11493 }, + Case { id: "bettertls::nameconstraints::tc3520", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11497, 11498], leaf: 11496 }, + Case { id: "bettertls::nameconstraints::tc3521", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11500, 11501], leaf: 11499 }, + Case { id: "bettertls::nameconstraints::tc3522", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11503, 11504], leaf: 11502 }, + Case { id: "bettertls::nameconstraints::tc3523", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11506, 11507], leaf: 11505 }, + Case { id: "bettertls::nameconstraints::tc3524", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11509, 11510], leaf: 11508 }, + Case { id: "bettertls::nameconstraints::tc3525", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11512, 11513], leaf: 11511 }, + Case { id: "bettertls::nameconstraints::tc3526", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11515, 11516], leaf: 11514 }, + Case { id: "bettertls::nameconstraints::tc3527", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11518, 11519], leaf: 11517 }, + Case { id: "bettertls::nameconstraints::tc3528", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11521, 11522], leaf: 11520 }, + Case { id: "bettertls::nameconstraints::tc3529", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11524, 11525], leaf: 11523 }, + Case { id: "bettertls::nameconstraints::tc3530", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11527, 11528], leaf: 11526 }, + Case { id: "bettertls::nameconstraints::tc3531", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11530, 11531], leaf: 11529 }, + Case { id: "bettertls::nameconstraints::tc3532", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11533, 11534], leaf: 11532 }, + Case { id: "bettertls::nameconstraints::tc3533", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11536, 11537], leaf: 11535 }, + Case { id: "bettertls::nameconstraints::tc3534", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11539, 11540], leaf: 11538 }, + Case { id: "bettertls::nameconstraints::tc3535", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11542, 11543], leaf: 11541 }, + Case { id: "bettertls::nameconstraints::tc3536", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11545, 11546], leaf: 11544 }, + Case { id: "bettertls::nameconstraints::tc3537", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11548, 11549], leaf: 11547 }, + Case { id: "bettertls::nameconstraints::tc3538", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11551, 11552], leaf: 11550 }, + Case { id: "bettertls::nameconstraints::tc3539", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11554, 11555], leaf: 11553 }, + Case { id: "bettertls::nameconstraints::tc3540", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11557, 11558], leaf: 11556 }, + Case { id: "bettertls::nameconstraints::tc3541", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11560, 11561], leaf: 11559 }, + Case { id: "bettertls::nameconstraints::tc3542", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11563, 11564], leaf: 11562 }, + Case { id: "bettertls::nameconstraints::tc3543", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11566, 11567], leaf: 11565 }, + Case { id: "bettertls::nameconstraints::tc3544", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11569, 11570], leaf: 11568 }, + Case { id: "bettertls::nameconstraints::tc3545", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11572, 11573], leaf: 11571 }, + Case { id: "bettertls::nameconstraints::tc3546", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11575, 11576], leaf: 11574 }, + Case { id: "bettertls::nameconstraints::tc3547", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11578, 11579], leaf: 11577 }, + Case { id: "bettertls::nameconstraints::tc3548", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11581, 11582], leaf: 11580 }, + Case { id: "bettertls::nameconstraints::tc3549", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11584, 11585], leaf: 11583 }, + Case { id: "bettertls::nameconstraints::tc3550", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11587, 11588], leaf: 11586 }, + Case { id: "bettertls::nameconstraints::tc3551", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11590, 11591], leaf: 11589 }, + Case { id: "bettertls::nameconstraints::tc3552", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11593, 11594], leaf: 11592 }, + Case { id: "bettertls::nameconstraints::tc3553", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11596, 11597], leaf: 11595 }, + Case { id: "bettertls::nameconstraints::tc3554", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11599, 11600], leaf: 11598 }, + Case { id: "bettertls::nameconstraints::tc3555", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11602, 11603], leaf: 11601 }, + Case { id: "bettertls::nameconstraints::tc3556", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11605, 11606], leaf: 11604 }, + Case { id: "bettertls::nameconstraints::tc3557", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11608, 11609], leaf: 11607 }, + Case { id: "bettertls::nameconstraints::tc3558", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11611, 11612], leaf: 11610 }, + Case { id: "bettertls::nameconstraints::tc3559", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11614, 11615], leaf: 11613 }, + Case { id: "bettertls::nameconstraints::tc3560", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11617, 11618], leaf: 11616 }, + Case { id: "bettertls::nameconstraints::tc3561", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11620, 11621], leaf: 11619 }, + Case { id: "bettertls::nameconstraints::tc3562", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11623, 11624], leaf: 11622 }, + Case { id: "bettertls::nameconstraints::tc3563", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11626, 11627], leaf: 11625 }, + Case { id: "bettertls::nameconstraints::tc3564", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11629, 11630], leaf: 11628 }, + Case { id: "bettertls::nameconstraints::tc3565", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11632, 11633], leaf: 11631 }, + Case { id: "bettertls::nameconstraints::tc3566", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11635, 11636], leaf: 11634 }, + Case { id: "bettertls::nameconstraints::tc3567", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11638, 11639], leaf: 11637 }, + Case { id: "bettertls::nameconstraints::tc3568", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11641, 11642], leaf: 11640 }, + Case { id: "bettertls::nameconstraints::tc3569", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11644, 11645], leaf: 11643 }, + Case { id: "bettertls::nameconstraints::tc3570", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11647, 11648], leaf: 11646 }, + Case { id: "bettertls::nameconstraints::tc3571", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11650, 11651], leaf: 11649 }, + Case { id: "bettertls::nameconstraints::tc3572", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11653, 11654], leaf: 11652 }, + Case { id: "bettertls::nameconstraints::tc3573", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11656, 11657], leaf: 11655 }, + Case { id: "bettertls::nameconstraints::tc3574", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11659, 11660], leaf: 11658 }, + Case { id: "bettertls::nameconstraints::tc3575", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11662, 11663], leaf: 11661 }, + Case { id: "bettertls::nameconstraints::tc3576", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11665, 11666], leaf: 11664 }, + Case { id: "bettertls::nameconstraints::tc3577", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11668, 11669], leaf: 11667 }, + Case { id: "bettertls::nameconstraints::tc3578", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11671, 11672], leaf: 11670 }, + Case { id: "bettertls::nameconstraints::tc3579", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11674, 11675], leaf: 11673 }, + Case { id: "bettertls::nameconstraints::tc3580", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11677, 11678], leaf: 11676 }, + Case { id: "bettertls::nameconstraints::tc3581", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11680, 11681], leaf: 11679 }, + Case { id: "bettertls::nameconstraints::tc3582", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11683, 11684], leaf: 11682 }, + Case { id: "bettertls::nameconstraints::tc3583", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11686, 11687], leaf: 11685 }, + Case { id: "bettertls::nameconstraints::tc3584", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11689, 11690], leaf: 11688 }, + Case { id: "bettertls::nameconstraints::tc3585", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11692, 11693], leaf: 11691 }, + Case { id: "bettertls::nameconstraints::tc3586", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11695, 11696], leaf: 11694 }, + Case { id: "bettertls::nameconstraints::tc3587", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11698, 11699], leaf: 11697 }, + Case { id: "bettertls::nameconstraints::tc3588", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11701, 11702], leaf: 11700 }, + Case { id: "bettertls::nameconstraints::tc3589", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11704, 11705], leaf: 11703 }, + Case { id: "bettertls::nameconstraints::tc3590", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11707, 11708], leaf: 11706 }, + Case { id: "bettertls::nameconstraints::tc3591", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11710, 11711], leaf: 11709 }, + Case { id: "bettertls::nameconstraints::tc3592", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11713, 11714], leaf: 11712 }, + Case { id: "bettertls::nameconstraints::tc3593", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11716, 11717], leaf: 11715 }, + Case { id: "bettertls::nameconstraints::tc3594", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11719, 11720], leaf: 11718 }, + Case { id: "bettertls::nameconstraints::tc3595", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11722, 11723], leaf: 11721 }, + Case { id: "bettertls::nameconstraints::tc3596", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11725, 11726], leaf: 11724 }, + Case { id: "bettertls::nameconstraints::tc3597", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11728, 11729], leaf: 11727 }, + Case { id: "bettertls::nameconstraints::tc3598", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11731, 11732], leaf: 11730 }, + Case { id: "bettertls::nameconstraints::tc3599", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11734, 11735], leaf: 11733 }, + Case { id: "bettertls::nameconstraints::tc3600", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11737, 11738], leaf: 11736 }, + Case { id: "bettertls::nameconstraints::tc3601", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11740, 11741], leaf: 11739 }, + Case { id: "bettertls::nameconstraints::tc3602", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11743, 11744], leaf: 11742 }, + Case { id: "bettertls::nameconstraints::tc3603", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11746, 11747], leaf: 11745 }, + Case { id: "bettertls::nameconstraints::tc3604", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11749, 11750], leaf: 11748 }, + Case { id: "bettertls::nameconstraints::tc3605", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11752, 11753], leaf: 11751 }, + Case { id: "bettertls::nameconstraints::tc3606", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11755, 11756], leaf: 11754 }, + Case { id: "bettertls::nameconstraints::tc3607", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11758, 11759], leaf: 11757 }, + Case { id: "bettertls::nameconstraints::tc3608", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11761, 11762], leaf: 11760 }, + Case { id: "bettertls::nameconstraints::tc3609", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11764, 11765], leaf: 11763 }, + Case { id: "bettertls::nameconstraints::tc3610", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11767, 11768], leaf: 11766 }, + Case { id: "bettertls::nameconstraints::tc3611", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11770, 11771], leaf: 11769 }, + Case { id: "bettertls::nameconstraints::tc3612", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11773, 11774], leaf: 11772 }, + Case { id: "bettertls::nameconstraints::tc3613", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11776, 11777], leaf: 11775 }, + Case { id: "bettertls::nameconstraints::tc3614", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11779, 11780], leaf: 11778 }, + Case { id: "bettertls::nameconstraints::tc3615", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11782, 11783], leaf: 11781 }, + Case { id: "bettertls::nameconstraints::tc3616", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11785, 11786], leaf: 11784 }, + Case { id: "bettertls::nameconstraints::tc3617", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11788, 11789], leaf: 11787 }, + Case { id: "bettertls::nameconstraints::tc3618", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11791, 11792], leaf: 11790 }, + Case { id: "bettertls::nameconstraints::tc3619", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11794, 11795], leaf: 11793 }, + Case { id: "bettertls::nameconstraints::tc3620", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11797, 11798], leaf: 11796 }, + Case { id: "bettertls::nameconstraints::tc3621", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11800, 11801], leaf: 11799 }, + Case { id: "bettertls::nameconstraints::tc3622", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11803, 11804], leaf: 11802 }, + Case { id: "bettertls::nameconstraints::tc3623", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11806, 11807], leaf: 11805 }, + Case { id: "bettertls::nameconstraints::tc3624", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11809, 11810], leaf: 11808 }, + Case { id: "bettertls::nameconstraints::tc3625", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11812, 11813], leaf: 11811 }, + Case { id: "bettertls::nameconstraints::tc3626", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11815, 11816], leaf: 11814 }, + Case { id: "bettertls::nameconstraints::tc3627", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11818, 11819], leaf: 11817 }, + Case { id: "bettertls::nameconstraints::tc3628", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11821, 11822], leaf: 11820 }, + Case { id: "bettertls::nameconstraints::tc3629", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11824, 11825], leaf: 11823 }, + Case { id: "bettertls::nameconstraints::tc3630", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11827, 11828], leaf: 11826 }, + Case { id: "bettertls::nameconstraints::tc3631", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11830, 11831], leaf: 11829 }, + Case { id: "bettertls::nameconstraints::tc3632", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11833, 11834], leaf: 11832 }, + Case { id: "bettertls::nameconstraints::tc3633", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11836, 11837], leaf: 11835 }, + Case { id: "bettertls::nameconstraints::tc3634", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11839, 11840], leaf: 11838 }, + Case { id: "bettertls::nameconstraints::tc3635", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11842, 11843], leaf: 11841 }, + Case { id: "bettertls::nameconstraints::tc3636", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11845, 11846], leaf: 11844 }, + Case { id: "bettertls::nameconstraints::tc3637", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11848, 11849], leaf: 11847 }, + Case { id: "bettertls::nameconstraints::tc3638", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11851, 11852], leaf: 11850 }, + Case { id: "bettertls::nameconstraints::tc3639", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11854, 11855], leaf: 11853 }, + Case { id: "bettertls::nameconstraints::tc3640", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11857, 11858], leaf: 11856 }, + Case { id: "bettertls::nameconstraints::tc3641", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11860, 11861], leaf: 11859 }, + Case { id: "bettertls::nameconstraints::tc3642", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11863, 11864], leaf: 11862 }, + Case { id: "bettertls::nameconstraints::tc3643", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11866, 11867], leaf: 11865 }, + Case { id: "bettertls::nameconstraints::tc3644", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11869, 11870], leaf: 11868 }, + Case { id: "bettertls::nameconstraints::tc3645", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11872, 11873], leaf: 11871 }, + Case { id: "bettertls::nameconstraints::tc3646", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11875, 11876], leaf: 11874 }, + Case { id: "bettertls::nameconstraints::tc3647", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11878, 11879], leaf: 11877 }, + Case { id: "bettertls::nameconstraints::tc3648", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11881, 11882], leaf: 11880 }, + Case { id: "bettertls::nameconstraints::tc3649", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11884, 11885], leaf: 11883 }, + Case { id: "bettertls::nameconstraints::tc3650", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11887, 11888], leaf: 11886 }, + Case { id: "bettertls::nameconstraints::tc3651", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11890, 11891], leaf: 11889 }, + Case { id: "bettertls::nameconstraints::tc3652", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11893, 11894], leaf: 11892 }, + Case { id: "bettertls::nameconstraints::tc3653", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11896, 11897], leaf: 11895 }, + Case { id: "bettertls::nameconstraints::tc3654", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11899, 11900], leaf: 11898 }, + Case { id: "bettertls::nameconstraints::tc3655", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11902, 11903], leaf: 11901 }, + Case { id: "bettertls::nameconstraints::tc3656", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11905, 11906], leaf: 11904 }, + Case { id: "bettertls::nameconstraints::tc3657", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11908, 11909], leaf: 11907 }, + Case { id: "bettertls::nameconstraints::tc3658", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11911, 11912], leaf: 11910 }, + Case { id: "bettertls::nameconstraints::tc3659", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11914, 11915], leaf: 11913 }, + Case { id: "bettertls::nameconstraints::tc3660", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11917, 11918], leaf: 11916 }, + Case { id: "bettertls::nameconstraints::tc3661", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11920, 11921], leaf: 11919 }, + Case { id: "bettertls::nameconstraints::tc3662", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11923, 11924], leaf: 11922 }, + Case { id: "bettertls::nameconstraints::tc3663", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11926, 11927], leaf: 11925 }, + Case { id: "bettertls::nameconstraints::tc3664", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11929, 11930], leaf: 11928 }, + Case { id: "bettertls::nameconstraints::tc3665", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11932, 11933], leaf: 11931 }, + Case { id: "bettertls::nameconstraints::tc3666", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11935, 11936], leaf: 11934 }, + Case { id: "bettertls::nameconstraints::tc3667", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11938, 11939], leaf: 11937 }, + Case { id: "bettertls::nameconstraints::tc3668", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11941, 11942], leaf: 11940 }, + Case { id: "bettertls::nameconstraints::tc3669", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11944, 11945], leaf: 11943 }, + Case { id: "bettertls::nameconstraints::tc3670", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11947, 11948], leaf: 11946 }, + Case { id: "bettertls::nameconstraints::tc3671", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11950, 11951], leaf: 11949 }, + Case { id: "bettertls::nameconstraints::tc3672", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11953, 11954], leaf: 11952 }, + Case { id: "bettertls::nameconstraints::tc3673", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11956, 11957], leaf: 11955 }, + Case { id: "bettertls::nameconstraints::tc3674", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11959, 11960], leaf: 11958 }, + Case { id: "bettertls::nameconstraints::tc3675", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11962, 11963], leaf: 11961 }, + Case { id: "bettertls::nameconstraints::tc3676", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11965, 11966], leaf: 11964 }, + Case { id: "bettertls::nameconstraints::tc3677", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11968, 11969], leaf: 11967 }, + Case { id: "bettertls::nameconstraints::tc3678", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11971, 11972], leaf: 11970 }, + Case { id: "bettertls::nameconstraints::tc3679", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11974, 11975], leaf: 11973 }, + Case { id: "bettertls::nameconstraints::tc3680", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11977, 11978], leaf: 11976 }, + Case { id: "bettertls::nameconstraints::tc3681", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11980, 11981], leaf: 11979 }, + Case { id: "bettertls::nameconstraints::tc3682", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11983, 11984], leaf: 11982 }, + Case { id: "bettertls::nameconstraints::tc3683", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11986, 11987], leaf: 11985 }, + Case { id: "bettertls::nameconstraints::tc3684", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11989, 11990], leaf: 11988 }, + Case { id: "bettertls::nameconstraints::tc3685", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11992, 11993], leaf: 11991 }, + Case { id: "bettertls::nameconstraints::tc3686", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11995, 11996], leaf: 11994 }, + Case { id: "bettertls::nameconstraints::tc3687", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[11998, 11999], leaf: 11997 }, + Case { id: "bettertls::nameconstraints::tc3688", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12001, 12002], leaf: 12000 }, + Case { id: "bettertls::nameconstraints::tc3689", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12004, 12005], leaf: 12003 }, + Case { id: "bettertls::nameconstraints::tc3690", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12007, 12008], leaf: 12006 }, + Case { id: "bettertls::nameconstraints::tc3691", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12010, 12011], leaf: 12009 }, + Case { id: "bettertls::nameconstraints::tc3692", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12013, 12014], leaf: 12012 }, + Case { id: "bettertls::nameconstraints::tc3693", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12016, 12017], leaf: 12015 }, + Case { id: "bettertls::nameconstraints::tc3694", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12019, 12020], leaf: 12018 }, + Case { id: "bettertls::nameconstraints::tc3695", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12022, 12023], leaf: 12021 }, + Case { id: "bettertls::nameconstraints::tc3696", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12025, 12026], leaf: 12024 }, + Case { id: "bettertls::nameconstraints::tc3697", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12028, 12029], leaf: 12027 }, + Case { id: "bettertls::nameconstraints::tc3698", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12031, 12032], leaf: 12030 }, + Case { id: "bettertls::nameconstraints::tc3699", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12034, 12035], leaf: 12033 }, + Case { id: "bettertls::nameconstraints::tc3700", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12037, 12038], leaf: 12036 }, + Case { id: "bettertls::nameconstraints::tc3701", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12040, 12041], leaf: 12039 }, + Case { id: "bettertls::nameconstraints::tc3702", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12043, 12044], leaf: 12042 }, + Case { id: "bettertls::nameconstraints::tc3703", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12046, 12047], leaf: 12045 }, + Case { id: "bettertls::nameconstraints::tc3704", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12049, 12050], leaf: 12048 }, + Case { id: "bettertls::nameconstraints::tc3705", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12052, 12053], leaf: 12051 }, + Case { id: "bettertls::nameconstraints::tc3706", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12055, 12056], leaf: 12054 }, + Case { id: "bettertls::nameconstraints::tc3707", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12058, 12059], leaf: 12057 }, + Case { id: "bettertls::nameconstraints::tc3708", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12061, 12062], leaf: 12060 }, + Case { id: "bettertls::nameconstraints::tc3709", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12064, 12065], leaf: 12063 }, + Case { id: "bettertls::nameconstraints::tc3710", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12067, 12068], leaf: 12066 }, + Case { id: "bettertls::nameconstraints::tc3711", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12070, 12071], leaf: 12069 }, + Case { id: "bettertls::nameconstraints::tc3712", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12073, 12074], leaf: 12072 }, + Case { id: "bettertls::nameconstraints::tc3713", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12076, 12077], leaf: 12075 }, + Case { id: "bettertls::nameconstraints::tc3714", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12079, 12080], leaf: 12078 }, + Case { id: "bettertls::nameconstraints::tc3715", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12082, 12083], leaf: 12081 }, + Case { id: "bettertls::nameconstraints::tc3716", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12085, 12086], leaf: 12084 }, + Case { id: "bettertls::nameconstraints::tc3717", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12088, 12089], leaf: 12087 }, + Case { id: "bettertls::nameconstraints::tc3718", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12091, 12092], leaf: 12090 }, + Case { id: "bettertls::nameconstraints::tc3719", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12094, 12095], leaf: 12093 }, + Case { id: "bettertls::nameconstraints::tc3720", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12097, 12098], leaf: 12096 }, + Case { id: "bettertls::nameconstraints::tc3721", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12100, 12101], leaf: 12099 }, + Case { id: "bettertls::nameconstraints::tc3722", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12103, 12104], leaf: 12102 }, + Case { id: "bettertls::nameconstraints::tc3723", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12106, 12107], leaf: 12105 }, + Case { id: "bettertls::nameconstraints::tc3724", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12109, 12110], leaf: 12108 }, + Case { id: "bettertls::nameconstraints::tc3725", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12112, 12113], leaf: 12111 }, + Case { id: "bettertls::nameconstraints::tc3726", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12115, 12116], leaf: 12114 }, + Case { id: "bettertls::nameconstraints::tc3727", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12118, 12119], leaf: 12117 }, + Case { id: "bettertls::nameconstraints::tc3728", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12121, 12122], leaf: 12120 }, + Case { id: "bettertls::nameconstraints::tc3729", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12124, 12125], leaf: 12123 }, + Case { id: "bettertls::nameconstraints::tc3730", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12127, 12128], leaf: 12126 }, + Case { id: "bettertls::nameconstraints::tc3731", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12130, 12131], leaf: 12129 }, + Case { id: "bettertls::nameconstraints::tc3732", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12133, 12134], leaf: 12132 }, + Case { id: "bettertls::nameconstraints::tc3733", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12136, 12137], leaf: 12135 }, + Case { id: "bettertls::nameconstraints::tc3734", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12139, 12140], leaf: 12138 }, + Case { id: "bettertls::nameconstraints::tc3735", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12142, 12143], leaf: 12141 }, + Case { id: "bettertls::nameconstraints::tc3736", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12145, 12146], leaf: 12144 }, + Case { id: "bettertls::nameconstraints::tc3737", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12148, 12149], leaf: 12147 }, + Case { id: "bettertls::nameconstraints::tc3738", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12151, 12152], leaf: 12150 }, + Case { id: "bettertls::nameconstraints::tc3739", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12154, 12155], leaf: 12153 }, + Case { id: "bettertls::nameconstraints::tc3740", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12157, 12158], leaf: 12156 }, + Case { id: "bettertls::nameconstraints::tc3741", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12160, 12161], leaf: 12159 }, + Case { id: "bettertls::nameconstraints::tc3742", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12163, 12164], leaf: 12162 }, + Case { id: "bettertls::nameconstraints::tc3743", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12166, 12167], leaf: 12165 }, + Case { id: "bettertls::nameconstraints::tc3744", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12169, 12170], leaf: 12168 }, + Case { id: "bettertls::nameconstraints::tc3745", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12172, 12173], leaf: 12171 }, + Case { id: "bettertls::nameconstraints::tc3746", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12175, 12176], leaf: 12174 }, + Case { id: "bettertls::nameconstraints::tc3747", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12178, 12179], leaf: 12177 }, + Case { id: "bettertls::nameconstraints::tc3748", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12181, 12182], leaf: 12180 }, + Case { id: "bettertls::nameconstraints::tc3749", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12184, 12185], leaf: 12183 }, + Case { id: "bettertls::nameconstraints::tc3750", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12187, 12188], leaf: 12186 }, + Case { id: "bettertls::nameconstraints::tc3751", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12190, 12191], leaf: 12189 }, + Case { id: "bettertls::nameconstraints::tc3752", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12193, 12194], leaf: 12192 }, + Case { id: "bettertls::nameconstraints::tc3753", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12196, 12197], leaf: 12195 }, + Case { id: "bettertls::nameconstraints::tc3754", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12199, 12200], leaf: 12198 }, + Case { id: "bettertls::nameconstraints::tc3755", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12202, 12203], leaf: 12201 }, + Case { id: "bettertls::nameconstraints::tc3756", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12205, 12206], leaf: 12204 }, + Case { id: "bettertls::nameconstraints::tc3757", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12208, 12209], leaf: 12207 }, + Case { id: "bettertls::nameconstraints::tc3758", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12211, 12212], leaf: 12210 }, + Case { id: "bettertls::nameconstraints::tc3759", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12214, 12215], leaf: 12213 }, + Case { id: "bettertls::nameconstraints::tc3760", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12217, 12218], leaf: 12216 }, + Case { id: "bettertls::nameconstraints::tc3761", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12220, 12221], leaf: 12219 }, + Case { id: "bettertls::nameconstraints::tc3762", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12223, 12224], leaf: 12222 }, + Case { id: "bettertls::nameconstraints::tc3763", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12226, 12227], leaf: 12225 }, + Case { id: "bettertls::nameconstraints::tc3764", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12229, 12230], leaf: 12228 }, + Case { id: "bettertls::nameconstraints::tc3765", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12232, 12233], leaf: 12231 }, + Case { id: "bettertls::nameconstraints::tc3766", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12235, 12236], leaf: 12234 }, + Case { id: "bettertls::nameconstraints::tc3767", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12238, 12239], leaf: 12237 }, + Case { id: "bettertls::nameconstraints::tc3768", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12241, 12242], leaf: 12240 }, + Case { id: "bettertls::nameconstraints::tc3769", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12244, 12245], leaf: 12243 }, + Case { id: "bettertls::nameconstraints::tc3770", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12247, 12248], leaf: 12246 }, + Case { id: "bettertls::nameconstraints::tc3771", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12250, 12251], leaf: 12249 }, + Case { id: "bettertls::nameconstraints::tc3772", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12253, 12254], leaf: 12252 }, + Case { id: "bettertls::nameconstraints::tc3773", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12256, 12257], leaf: 12255 }, + Case { id: "bettertls::nameconstraints::tc3774", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12259, 12260], leaf: 12258 }, + Case { id: "bettertls::nameconstraints::tc3775", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12262, 12263], leaf: 12261 }, + Case { id: "bettertls::nameconstraints::tc3776", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12265, 12266], leaf: 12264 }, + Case { id: "bettertls::nameconstraints::tc3777", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12268, 12269], leaf: 12267 }, + Case { id: "bettertls::nameconstraints::tc3778", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12271, 12272], leaf: 12270 }, + Case { id: "bettertls::nameconstraints::tc3779", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12274, 12275], leaf: 12273 }, + Case { id: "bettertls::nameconstraints::tc3780", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12277, 12278], leaf: 12276 }, + Case { id: "bettertls::nameconstraints::tc3781", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12280, 12281], leaf: 12279 }, + Case { id: "bettertls::nameconstraints::tc3782", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12283, 12284], leaf: 12282 }, + Case { id: "bettertls::nameconstraints::tc3783", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12286, 12287], leaf: 12285 }, + Case { id: "bettertls::nameconstraints::tc3784", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12289, 12290], leaf: 12288 }, + Case { id: "bettertls::nameconstraints::tc3785", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12292, 12293], leaf: 12291 }, + Case { id: "bettertls::nameconstraints::tc3786", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12295, 12296], leaf: 12294 }, + Case { id: "bettertls::nameconstraints::tc3787", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12298, 12299], leaf: 12297 }, + Case { id: "bettertls::nameconstraints::tc3788", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12301, 12302], leaf: 12300 }, + Case { id: "bettertls::nameconstraints::tc3789", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12304, 12305], leaf: 12303 }, + Case { id: "bettertls::nameconstraints::tc3790", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12307, 12308], leaf: 12306 }, + Case { id: "bettertls::nameconstraints::tc3791", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12310, 12311], leaf: 12309 }, + Case { id: "bettertls::nameconstraints::tc3792", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12313, 12314], leaf: 12312 }, + Case { id: "bettertls::nameconstraints::tc3793", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12316, 12317], leaf: 12315 }, + Case { id: "bettertls::nameconstraints::tc3794", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12319, 12320], leaf: 12318 }, + Case { id: "bettertls::nameconstraints::tc3795", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12322, 12323], leaf: 12321 }, + Case { id: "bettertls::nameconstraints::tc3796", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12325, 12326], leaf: 12324 }, + Case { id: "bettertls::nameconstraints::tc3797", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12328, 12329], leaf: 12327 }, + Case { id: "bettertls::nameconstraints::tc3798", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12331, 12332], leaf: 12330 }, + Case { id: "bettertls::nameconstraints::tc3799", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12334, 12335], leaf: 12333 }, + Case { id: "bettertls::nameconstraints::tc3800", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12337, 12338], leaf: 12336 }, + Case { id: "bettertls::nameconstraints::tc3801", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12340, 12341], leaf: 12339 }, + Case { id: "bettertls::nameconstraints::tc3802", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12343, 12344], leaf: 12342 }, + Case { id: "bettertls::nameconstraints::tc3803", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12346, 12347], leaf: 12345 }, + Case { id: "bettertls::nameconstraints::tc3804", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12349, 12350], leaf: 12348 }, + Case { id: "bettertls::nameconstraints::tc3805", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12352, 12353], leaf: 12351 }, + Case { id: "bettertls::nameconstraints::tc3806", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12355, 12356], leaf: 12354 }, + Case { id: "bettertls::nameconstraints::tc3807", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12358, 12359], leaf: 12357 }, + Case { id: "bettertls::nameconstraints::tc3808", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12361, 12362], leaf: 12360 }, + Case { id: "bettertls::nameconstraints::tc3809", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12364, 12365], leaf: 12363 }, + Case { id: "bettertls::nameconstraints::tc3810", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12367, 12368], leaf: 12366 }, + Case { id: "bettertls::nameconstraints::tc3811", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12370, 12371], leaf: 12369 }, + Case { id: "bettertls::nameconstraints::tc3812", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12373, 12374], leaf: 12372 }, + Case { id: "bettertls::nameconstraints::tc3813", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12376, 12377], leaf: 12375 }, + Case { id: "bettertls::nameconstraints::tc3814", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12379, 12380], leaf: 12378 }, + Case { id: "bettertls::nameconstraints::tc3815", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12382, 12383], leaf: 12381 }, + Case { id: "bettertls::nameconstraints::tc3816", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12385, 12386], leaf: 12384 }, + Case { id: "bettertls::nameconstraints::tc3817", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12388, 12389], leaf: 12387 }, + Case { id: "bettertls::nameconstraints::tc3818", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12391, 12392], leaf: 12390 }, + Case { id: "bettertls::nameconstraints::tc3819", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12394, 12395], leaf: 12393 }, + Case { id: "bettertls::nameconstraints::tc3820", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12397, 12398], leaf: 12396 }, + Case { id: "bettertls::nameconstraints::tc3821", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12400, 12401], leaf: 12399 }, + Case { id: "bettertls::nameconstraints::tc3822", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12403, 12404], leaf: 12402 }, + Case { id: "bettertls::nameconstraints::tc3823", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12406, 12407], leaf: 12405 }, + Case { id: "bettertls::nameconstraints::tc3824", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12409, 12410], leaf: 12408 }, + Case { id: "bettertls::nameconstraints::tc3825", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12412, 12413], leaf: 12411 }, + Case { id: "bettertls::nameconstraints::tc3826", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12415, 12416], leaf: 12414 }, + Case { id: "bettertls::nameconstraints::tc3827", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12418, 12419], leaf: 12417 }, + Case { id: "bettertls::nameconstraints::tc3828", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12421, 12422], leaf: 12420 }, + Case { id: "bettertls::nameconstraints::tc3829", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12424, 12425], leaf: 12423 }, + Case { id: "bettertls::nameconstraints::tc3830", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12427, 12428], leaf: 12426 }, + Case { id: "bettertls::nameconstraints::tc3831", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12430, 12431], leaf: 12429 }, + Case { id: "bettertls::nameconstraints::tc3832", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12433, 12434], leaf: 12432 }, + Case { id: "bettertls::nameconstraints::tc3833", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12436, 12437], leaf: 12435 }, + Case { id: "bettertls::nameconstraints::tc3834", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12439, 12440], leaf: 12438 }, + Case { id: "bettertls::nameconstraints::tc3835", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12442, 12443], leaf: 12441 }, + Case { id: "bettertls::nameconstraints::tc3836", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12445, 12446], leaf: 12444 }, + Case { id: "bettertls::nameconstraints::tc3837", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12448, 12449], leaf: 12447 }, + Case { id: "bettertls::nameconstraints::tc3838", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12451, 12452], leaf: 12450 }, + Case { id: "bettertls::nameconstraints::tc3839", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12454, 12455], leaf: 12453 }, + Case { id: "bettertls::nameconstraints::tc3840", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12457, 12458], leaf: 12456 }, + Case { id: "bettertls::nameconstraints::tc3841", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12460, 12461], leaf: 12459 }, + Case { id: "bettertls::nameconstraints::tc3842", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12463, 12464], leaf: 12462 }, + Case { id: "bettertls::nameconstraints::tc3843", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12466, 12467], leaf: 12465 }, + Case { id: "bettertls::nameconstraints::tc3844", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12469, 12470], leaf: 12468 }, + Case { id: "bettertls::nameconstraints::tc3845", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12472, 12473], leaf: 12471 }, + Case { id: "bettertls::nameconstraints::tc3846", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12475, 12476], leaf: 12474 }, + Case { id: "bettertls::nameconstraints::tc3847", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12478, 12479], leaf: 12477 }, + Case { id: "bettertls::nameconstraints::tc3848", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12481, 12482], leaf: 12480 }, + Case { id: "bettertls::nameconstraints::tc3849", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12484, 12485], leaf: 12483 }, + Case { id: "bettertls::nameconstraints::tc3850", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12487, 12488], leaf: 12486 }, + Case { id: "bettertls::nameconstraints::tc3851", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12490, 12491], leaf: 12489 }, + Case { id: "bettertls::nameconstraints::tc3852", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12493, 12494], leaf: 12492 }, + Case { id: "bettertls::nameconstraints::tc3853", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12496, 12497], leaf: 12495 }, + Case { id: "bettertls::nameconstraints::tc3854", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12499, 12500], leaf: 12498 }, + Case { id: "bettertls::nameconstraints::tc3855", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12502, 12503], leaf: 12501 }, + Case { id: "bettertls::nameconstraints::tc3856", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12505, 12506], leaf: 12504 }, + Case { id: "bettertls::nameconstraints::tc3857", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12508, 12509], leaf: 12507 }, + Case { id: "bettertls::nameconstraints::tc3858", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12511, 12512], leaf: 12510 }, + Case { id: "bettertls::nameconstraints::tc3859", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12514, 12515], leaf: 12513 }, + Case { id: "bettertls::nameconstraints::tc3860", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12517, 12518], leaf: 12516 }, + Case { id: "bettertls::nameconstraints::tc3861", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12520, 12521], leaf: 12519 }, + Case { id: "bettertls::nameconstraints::tc3862", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12523, 12524], leaf: 12522 }, + Case { id: "bettertls::nameconstraints::tc3863", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12526, 12527], leaf: 12525 }, + Case { id: "bettertls::nameconstraints::tc3864", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12529, 12530], leaf: 12528 }, + Case { id: "bettertls::nameconstraints::tc3865", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12532, 12533], leaf: 12531 }, + Case { id: "bettertls::nameconstraints::tc3866", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12535, 12536], leaf: 12534 }, + Case { id: "bettertls::nameconstraints::tc3867", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12538, 12539], leaf: 12537 }, + Case { id: "bettertls::nameconstraints::tc3868", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12541, 12542], leaf: 12540 }, + Case { id: "bettertls::nameconstraints::tc3869", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12544, 12545], leaf: 12543 }, + Case { id: "bettertls::nameconstraints::tc3870", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12547, 12548], leaf: 12546 }, + Case { id: "bettertls::nameconstraints::tc3871", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12550, 12551], leaf: 12549 }, + Case { id: "bettertls::nameconstraints::tc3872", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12553, 12554], leaf: 12552 }, + Case { id: "bettertls::nameconstraints::tc3873", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12556, 12557], leaf: 12555 }, + Case { id: "bettertls::nameconstraints::tc3874", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12559, 12560], leaf: 12558 }, + Case { id: "bettertls::nameconstraints::tc3875", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12562, 12563], leaf: 12561 }, + Case { id: "bettertls::nameconstraints::tc3876", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12565, 12566], leaf: 12564 }, + Case { id: "bettertls::nameconstraints::tc3877", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12568, 12569], leaf: 12567 }, + Case { id: "bettertls::nameconstraints::tc3878", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12571, 12572], leaf: 12570 }, + Case { id: "bettertls::nameconstraints::tc3879", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12574, 12575], leaf: 12573 }, + Case { id: "bettertls::nameconstraints::tc3880", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12577, 12578], leaf: 12576 }, + Case { id: "bettertls::nameconstraints::tc3881", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12580, 12581], leaf: 12579 }, + Case { id: "bettertls::nameconstraints::tc3882", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12583, 12584], leaf: 12582 }, + Case { id: "bettertls::nameconstraints::tc3883", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12586, 12587], leaf: 12585 }, + Case { id: "bettertls::nameconstraints::tc3884", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12589, 12590], leaf: 12588 }, + Case { id: "bettertls::nameconstraints::tc3885", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12592, 12593], leaf: 12591 }, + Case { id: "bettertls::nameconstraints::tc3886", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12595, 12596], leaf: 12594 }, + Case { id: "bettertls::nameconstraints::tc3887", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12598, 12599], leaf: 12597 }, + Case { id: "bettertls::nameconstraints::tc3888", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12601, 12602], leaf: 12600 }, + Case { id: "bettertls::nameconstraints::tc3889", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12604, 12605], leaf: 12603 }, + Case { id: "bettertls::nameconstraints::tc3890", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12607, 12608], leaf: 12606 }, + Case { id: "bettertls::nameconstraints::tc3891", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12610, 12611], leaf: 12609 }, + Case { id: "bettertls::nameconstraints::tc3892", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12613, 12614], leaf: 12612 }, + Case { id: "bettertls::nameconstraints::tc3893", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12616, 12617], leaf: 12615 }, + Case { id: "bettertls::nameconstraints::tc3894", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12619, 12620], leaf: 12618 }, + Case { id: "bettertls::nameconstraints::tc3895", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12622, 12623], leaf: 12621 }, + Case { id: "bettertls::nameconstraints::tc3896", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12625, 12626], leaf: 12624 }, + Case { id: "bettertls::nameconstraints::tc3897", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12628, 12629], leaf: 12627 }, + Case { id: "bettertls::nameconstraints::tc3898", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12631, 12632], leaf: 12630 }, + Case { id: "bettertls::nameconstraints::tc3899", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12634, 12635], leaf: 12633 }, + Case { id: "bettertls::nameconstraints::tc3900", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12637, 12638], leaf: 12636 }, + Case { id: "bettertls::nameconstraints::tc3901", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12640, 12641], leaf: 12639 }, + Case { id: "bettertls::nameconstraints::tc3902", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12643, 12644], leaf: 12642 }, + Case { id: "bettertls::nameconstraints::tc3903", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12646, 12647], leaf: 12645 }, + Case { id: "bettertls::nameconstraints::tc3904", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12649, 12650], leaf: 12648 }, + Case { id: "bettertls::nameconstraints::tc3905", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12652, 12653], leaf: 12651 }, + Case { id: "bettertls::nameconstraints::tc3906", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12655, 12656], leaf: 12654 }, + Case { id: "bettertls::nameconstraints::tc3907", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12658, 12659], leaf: 12657 }, + Case { id: "bettertls::nameconstraints::tc3908", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12661, 12662], leaf: 12660 }, + Case { id: "bettertls::nameconstraints::tc3909", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12664, 12665], leaf: 12663 }, + Case { id: "bettertls::nameconstraints::tc3910", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12667, 12668], leaf: 12666 }, + Case { id: "bettertls::nameconstraints::tc3911", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12670, 12671], leaf: 12669 }, + Case { id: "bettertls::nameconstraints::tc3912", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12673, 12674], leaf: 12672 }, + Case { id: "bettertls::nameconstraints::tc3913", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12676, 12677], leaf: 12675 }, + Case { id: "bettertls::nameconstraints::tc3914", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12679, 12680], leaf: 12678 }, + Case { id: "bettertls::nameconstraints::tc3915", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12682, 12683], leaf: 12681 }, + Case { id: "bettertls::nameconstraints::tc3916", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12685, 12686], leaf: 12684 }, + Case { id: "bettertls::nameconstraints::tc3917", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12688, 12689], leaf: 12687 }, + Case { id: "bettertls::nameconstraints::tc3918", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12691, 12692], leaf: 12690 }, + Case { id: "bettertls::nameconstraints::tc3919", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12694, 12695], leaf: 12693 }, + Case { id: "bettertls::nameconstraints::tc3920", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12697, 12698], leaf: 12696 }, + Case { id: "bettertls::nameconstraints::tc3921", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12700, 12701], leaf: 12699 }, + Case { id: "bettertls::nameconstraints::tc3922", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12703, 12704], leaf: 12702 }, + Case { id: "bettertls::nameconstraints::tc3923", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12706, 12707], leaf: 12705 }, + Case { id: "bettertls::nameconstraints::tc3924", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12709, 12710], leaf: 12708 }, + Case { id: "bettertls::nameconstraints::tc3925", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12712, 12713], leaf: 12711 }, + Case { id: "bettertls::nameconstraints::tc3926", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12715, 12716], leaf: 12714 }, + Case { id: "bettertls::nameconstraints::tc3927", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12718, 12719], leaf: 12717 }, + Case { id: "bettertls::nameconstraints::tc3928", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12721, 12722], leaf: 12720 }, + Case { id: "bettertls::nameconstraints::tc3929", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12724, 12725], leaf: 12723 }, + Case { id: "bettertls::nameconstraints::tc3930", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12727, 12728], leaf: 12726 }, + Case { id: "bettertls::nameconstraints::tc3931", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12730, 12731], leaf: 12729 }, + Case { id: "bettertls::nameconstraints::tc3932", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12733, 12734], leaf: 12732 }, + Case { id: "bettertls::nameconstraints::tc3933", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12736, 12737], leaf: 12735 }, + Case { id: "bettertls::nameconstraints::tc3934", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12739, 12740], leaf: 12738 }, + Case { id: "bettertls::nameconstraints::tc3935", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12742, 12743], leaf: 12741 }, + Case { id: "bettertls::nameconstraints::tc3936", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12745, 12746], leaf: 12744 }, + Case { id: "bettertls::nameconstraints::tc3937", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12748, 12749], leaf: 12747 }, + Case { id: "bettertls::nameconstraints::tc3938", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12751, 12752], leaf: 12750 }, + Case { id: "bettertls::nameconstraints::tc3939", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12754, 12755], leaf: 12753 }, + Case { id: "bettertls::nameconstraints::tc3940", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12757, 12758], leaf: 12756 }, + Case { id: "bettertls::nameconstraints::tc3941", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12760, 12761], leaf: 12759 }, + Case { id: "bettertls::nameconstraints::tc3942", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12763, 12764], leaf: 12762 }, + Case { id: "bettertls::nameconstraints::tc3943", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12766, 12767], leaf: 12765 }, + Case { id: "bettertls::nameconstraints::tc3944", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12769, 12770], leaf: 12768 }, + Case { id: "bettertls::nameconstraints::tc3945", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12772, 12773], leaf: 12771 }, + Case { id: "bettertls::nameconstraints::tc3946", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12775, 12776], leaf: 12774 }, + Case { id: "bettertls::nameconstraints::tc3947", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12778, 12779], leaf: 12777 }, + Case { id: "bettertls::nameconstraints::tc3948", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12781, 12782], leaf: 12780 }, + Case { id: "bettertls::nameconstraints::tc3949", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12784, 12785], leaf: 12783 }, + Case { id: "bettertls::nameconstraints::tc3950", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12787, 12788], leaf: 12786 }, + Case { id: "bettertls::nameconstraints::tc3951", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12790, 12791], leaf: 12789 }, + Case { id: "bettertls::nameconstraints::tc3952", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12793, 12794], leaf: 12792 }, + Case { id: "bettertls::nameconstraints::tc3953", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12796, 12797], leaf: 12795 }, + Case { id: "bettertls::nameconstraints::tc3954", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12799, 12800], leaf: 12798 }, + Case { id: "bettertls::nameconstraints::tc3955", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12802, 12803], leaf: 12801 }, + Case { id: "bettertls::nameconstraints::tc3956", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12805, 12806], leaf: 12804 }, + Case { id: "bettertls::nameconstraints::tc3957", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12808, 12809], leaf: 12807 }, + Case { id: "bettertls::nameconstraints::tc3958", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12811, 12812], leaf: 12810 }, + Case { id: "bettertls::nameconstraints::tc3959", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12814, 12815], leaf: 12813 }, + Case { id: "bettertls::nameconstraints::tc3960", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12817, 12818], leaf: 12816 }, + Case { id: "bettertls::nameconstraints::tc3961", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12820, 12821], leaf: 12819 }, + Case { id: "bettertls::nameconstraints::tc3962", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12823, 12824], leaf: 12822 }, + Case { id: "bettertls::nameconstraints::tc3963", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12826, 12827], leaf: 12825 }, + Case { id: "bettertls::nameconstraints::tc3964", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12829, 12830], leaf: 12828 }, + Case { id: "bettertls::nameconstraints::tc3965", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12832, 12833], leaf: 12831 }, + Case { id: "bettertls::nameconstraints::tc3966", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12835, 12836], leaf: 12834 }, + Case { id: "bettertls::nameconstraints::tc3967", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12838, 12839], leaf: 12837 }, + Case { id: "bettertls::nameconstraints::tc3968", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12841, 12842], leaf: 12840 }, + Case { id: "bettertls::nameconstraints::tc3969", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12844, 12845], leaf: 12843 }, + Case { id: "bettertls::nameconstraints::tc3970", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12847, 12848], leaf: 12846 }, + Case { id: "bettertls::nameconstraints::tc3971", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12850, 12851], leaf: 12849 }, + Case { id: "bettertls::nameconstraints::tc3972", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12853, 12854], leaf: 12852 }, + Case { id: "bettertls::nameconstraints::tc3973", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12856, 12857], leaf: 12855 }, + Case { id: "bettertls::nameconstraints::tc3974", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12859, 12860], leaf: 12858 }, + Case { id: "bettertls::nameconstraints::tc3975", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12862, 12863], leaf: 12861 }, + Case { id: "bettertls::nameconstraints::tc3976", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12865, 12866], leaf: 12864 }, + Case { id: "bettertls::nameconstraints::tc3977", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12868, 12869], leaf: 12867 }, + Case { id: "bettertls::nameconstraints::tc3978", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12871, 12872], leaf: 12870 }, + Case { id: "bettertls::nameconstraints::tc3979", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12874, 12875], leaf: 12873 }, + Case { id: "bettertls::nameconstraints::tc3980", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12877, 12878], leaf: 12876 }, + Case { id: "bettertls::nameconstraints::tc3981", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12880, 12881], leaf: 12879 }, + Case { id: "bettertls::nameconstraints::tc3982", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12883, 12884], leaf: 12882 }, + Case { id: "bettertls::nameconstraints::tc3983", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12886, 12887], leaf: 12885 }, + Case { id: "bettertls::nameconstraints::tc3984", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12889, 12890], leaf: 12888 }, + Case { id: "bettertls::nameconstraints::tc3985", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12892, 12893], leaf: 12891 }, + Case { id: "bettertls::nameconstraints::tc3986", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12895, 12896], leaf: 12894 }, + Case { id: "bettertls::nameconstraints::tc3987", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12898, 12899], leaf: 12897 }, + Case { id: "bettertls::nameconstraints::tc3988", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12901, 12902], leaf: 12900 }, + Case { id: "bettertls::nameconstraints::tc3989", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12904, 12905], leaf: 12903 }, + Case { id: "bettertls::nameconstraints::tc3990", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12907, 12908], leaf: 12906 }, + Case { id: "bettertls::nameconstraints::tc3991", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12910, 12911], leaf: 12909 }, + Case { id: "bettertls::nameconstraints::tc3992", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12913, 12914], leaf: 12912 }, + Case { id: "bettertls::nameconstraints::tc3993", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12916, 12917], leaf: 12915 }, + Case { id: "bettertls::nameconstraints::tc3994", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12919, 12920], leaf: 12918 }, + Case { id: "bettertls::nameconstraints::tc3995", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12922, 12923], leaf: 12921 }, + Case { id: "bettertls::nameconstraints::tc3996", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12925, 12926], leaf: 12924 }, + Case { id: "bettertls::nameconstraints::tc3997", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12928, 12929], leaf: 12927 }, + Case { id: "bettertls::nameconstraints::tc3998", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12931, 12932], leaf: 12930 }, + Case { id: "bettertls::nameconstraints::tc3999", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12934, 12935], leaf: 12933 }, + Case { id: "bettertls::nameconstraints::tc4000", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12937, 12938], leaf: 12936 }, + Case { id: "bettertls::nameconstraints::tc4001", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12940, 12941], leaf: 12939 }, + Case { id: "bettertls::nameconstraints::tc4002", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12943, 12944], leaf: 12942 }, + Case { id: "bettertls::nameconstraints::tc4003", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12946, 12947], leaf: 12945 }, + Case { id: "bettertls::nameconstraints::tc4004", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12949, 12950], leaf: 12948 }, + Case { id: "bettertls::nameconstraints::tc4005", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12952, 12953], leaf: 12951 }, + Case { id: "bettertls::nameconstraints::tc4006", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12955, 12956], leaf: 12954 }, + Case { id: "bettertls::nameconstraints::tc4007", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12958, 12959], leaf: 12957 }, + Case { id: "bettertls::nameconstraints::tc4008", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12961, 12962], leaf: 12960 }, + Case { id: "bettertls::nameconstraints::tc4009", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12964, 12965], leaf: 12963 }, + Case { id: "bettertls::nameconstraints::tc4010", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12967, 12968], leaf: 12966 }, + Case { id: "bettertls::nameconstraints::tc4011", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12970, 12971], leaf: 12969 }, + Case { id: "bettertls::nameconstraints::tc4012", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12973, 12974], leaf: 12972 }, + Case { id: "bettertls::nameconstraints::tc4013", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12976, 12977], leaf: 12975 }, + Case { id: "bettertls::nameconstraints::tc4014", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12979, 12980], leaf: 12978 }, + Case { id: "bettertls::nameconstraints::tc4015", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12982, 12983], leaf: 12981 }, + Case { id: "bettertls::nameconstraints::tc4016", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12985, 12986], leaf: 12984 }, + Case { id: "bettertls::nameconstraints::tc4017", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12988, 12989], leaf: 12987 }, + Case { id: "bettertls::nameconstraints::tc4018", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12991, 12992], leaf: 12990 }, + Case { id: "bettertls::nameconstraints::tc4019", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12994, 12995], leaf: 12993 }, + Case { id: "bettertls::nameconstraints::tc4020", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[12997, 12998], leaf: 12996 }, + Case { id: "bettertls::nameconstraints::tc4021", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13000, 13001], leaf: 12999 }, + Case { id: "bettertls::nameconstraints::tc4022", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13003, 13004], leaf: 13002 }, + Case { id: "bettertls::nameconstraints::tc4023", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13006, 13007], leaf: 13005 }, + Case { id: "bettertls::nameconstraints::tc4024", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13009, 13010], leaf: 13008 }, + Case { id: "bettertls::nameconstraints::tc4025", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13012, 13013], leaf: 13011 }, + Case { id: "bettertls::nameconstraints::tc4026", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13015, 13016], leaf: 13014 }, + Case { id: "bettertls::nameconstraints::tc4027", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13018, 13019], leaf: 13017 }, + Case { id: "bettertls::nameconstraints::tc4028", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13021, 13022], leaf: 13020 }, + Case { id: "bettertls::nameconstraints::tc4029", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13024, 13025], leaf: 13023 }, + Case { id: "bettertls::nameconstraints::tc4030", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13027, 13028], leaf: 13026 }, + Case { id: "bettertls::nameconstraints::tc4031", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13030, 13031], leaf: 13029 }, + Case { id: "bettertls::nameconstraints::tc4032", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13033, 13034], leaf: 13032 }, + Case { id: "bettertls::nameconstraints::tc4033", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13036, 13037], leaf: 13035 }, + Case { id: "bettertls::nameconstraints::tc4034", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13039, 13040], leaf: 13038 }, + Case { id: "bettertls::nameconstraints::tc4035", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13042, 13043], leaf: 13041 }, + Case { id: "bettertls::nameconstraints::tc4036", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13045, 13046], leaf: 13044 }, + Case { id: "bettertls::nameconstraints::tc4037", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13048, 13049], leaf: 13047 }, + Case { id: "bettertls::nameconstraints::tc4038", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13051, 13052], leaf: 13050 }, + Case { id: "bettertls::nameconstraints::tc4039", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13054, 13055], leaf: 13053 }, + Case { id: "bettertls::nameconstraints::tc4040", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13057, 13058], leaf: 13056 }, + Case { id: "bettertls::nameconstraints::tc4041", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13060, 13061], leaf: 13059 }, + Case { id: "bettertls::nameconstraints::tc4042", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13063, 13064], leaf: 13062 }, + Case { id: "bettertls::nameconstraints::tc4043", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13066, 13067], leaf: 13065 }, + Case { id: "bettertls::nameconstraints::tc4044", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13069, 13070], leaf: 13068 }, + Case { id: "bettertls::nameconstraints::tc4045", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13072, 13073], leaf: 13071 }, + Case { id: "bettertls::nameconstraints::tc4046", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13075, 13076], leaf: 13074 }, + Case { id: "bettertls::nameconstraints::tc4047", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13078, 13079], leaf: 13077 }, + Case { id: "bettertls::nameconstraints::tc4048", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13081, 13082], leaf: 13080 }, + Case { id: "bettertls::nameconstraints::tc4049", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13084, 13085], leaf: 13083 }, + Case { id: "bettertls::nameconstraints::tc4050", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13087, 13088], leaf: 13086 }, + Case { id: "bettertls::nameconstraints::tc4051", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13090, 13091], leaf: 13089 }, + Case { id: "bettertls::nameconstraints::tc4052", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13093, 13094], leaf: 13092 }, + Case { id: "bettertls::nameconstraints::tc4053", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13096, 13097], leaf: 13095 }, + Case { id: "bettertls::nameconstraints::tc4054", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13099, 13100], leaf: 13098 }, + Case { id: "bettertls::nameconstraints::tc4055", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13102, 13103], leaf: 13101 }, + Case { id: "bettertls::nameconstraints::tc4056", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13105, 13106], leaf: 13104 }, + Case { id: "bettertls::nameconstraints::tc4057", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13108, 13109], leaf: 13107 }, + Case { id: "bettertls::nameconstraints::tc4058", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13111, 13112], leaf: 13110 }, + Case { id: "bettertls::nameconstraints::tc4059", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13114, 13115], leaf: 13113 }, + Case { id: "bettertls::nameconstraints::tc4060", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13117, 13118], leaf: 13116 }, + Case { id: "bettertls::nameconstraints::tc4061", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13120, 13121], leaf: 13119 }, + Case { id: "bettertls::nameconstraints::tc4062", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13123, 13124], leaf: 13122 }, + Case { id: "bettertls::nameconstraints::tc4063", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13126, 13127], leaf: 13125 }, + Case { id: "bettertls::nameconstraints::tc4064", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13129, 13130], leaf: 13128 }, + Case { id: "bettertls::nameconstraints::tc4065", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13132, 13133], leaf: 13131 }, + Case { id: "bettertls::nameconstraints::tc4066", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13135, 13136], leaf: 13134 }, + Case { id: "bettertls::nameconstraints::tc4067", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13138, 13139], leaf: 13137 }, + Case { id: "bettertls::nameconstraints::tc4068", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13141, 13142], leaf: 13140 }, + Case { id: "bettertls::nameconstraints::tc4069", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13144, 13145], leaf: 13143 }, + Case { id: "bettertls::nameconstraints::tc4070", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13147, 13148], leaf: 13146 }, + Case { id: "bettertls::nameconstraints::tc4071", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13150, 13151], leaf: 13149 }, + Case { id: "bettertls::nameconstraints::tc4072", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13153, 13154], leaf: 13152 }, + Case { id: "bettertls::nameconstraints::tc4073", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13156, 13157], leaf: 13155 }, + Case { id: "bettertls::nameconstraints::tc4074", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13159, 13160], leaf: 13158 }, + Case { id: "bettertls::nameconstraints::tc4075", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13162, 13163], leaf: 13161 }, + Case { id: "bettertls::nameconstraints::tc4076", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13165, 13166], leaf: 13164 }, + Case { id: "bettertls::nameconstraints::tc4077", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13168, 13169], leaf: 13167 }, + Case { id: "bettertls::nameconstraints::tc4078", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13171, 13172], leaf: 13170 }, + Case { id: "bettertls::nameconstraints::tc4079", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13174, 13175], leaf: 13173 }, + Case { id: "bettertls::nameconstraints::tc4080", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13177, 13178], leaf: 13176 }, + Case { id: "bettertls::nameconstraints::tc4081", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13180, 13181], leaf: 13179 }, + Case { id: "bettertls::nameconstraints::tc4082", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13183, 13184], leaf: 13182 }, + Case { id: "bettertls::nameconstraints::tc4083", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13186, 13187], leaf: 13185 }, + Case { id: "bettertls::nameconstraints::tc4084", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13189, 13190], leaf: 13188 }, + Case { id: "bettertls::nameconstraints::tc4085", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13192, 13193], leaf: 13191 }, + Case { id: "bettertls::nameconstraints::tc4086", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13195, 13196], leaf: 13194 }, + Case { id: "bettertls::nameconstraints::tc4087", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13198, 13199], leaf: 13197 }, + Case { id: "bettertls::nameconstraints::tc4088", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13201, 13202], leaf: 13200 }, + Case { id: "bettertls::nameconstraints::tc4089", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13204, 13205], leaf: 13203 }, + Case { id: "bettertls::nameconstraints::tc4090", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13207, 13208], leaf: 13206 }, + Case { id: "bettertls::nameconstraints::tc4091", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13210, 13211], leaf: 13209 }, + Case { id: "bettertls::nameconstraints::tc4092", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13213, 13214], leaf: 13212 }, + Case { id: "bettertls::nameconstraints::tc4093", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13216, 13217], leaf: 13215 }, + Case { id: "bettertls::nameconstraints::tc4094", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13219, 13220], leaf: 13218 }, + Case { id: "bettertls::nameconstraints::tc4095", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13222, 13223], leaf: 13221 }, + Case { id: "bettertls::nameconstraints::tc4096", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13225, 13226], leaf: 13224 }, + Case { id: "bettertls::nameconstraints::tc4097", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13228, 13229], leaf: 13227 }, + Case { id: "bettertls::nameconstraints::tc4098", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13231, 13232], leaf: 13230 }, + Case { id: "bettertls::nameconstraints::tc4099", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13234, 13235], leaf: 13233 }, + Case { id: "bettertls::nameconstraints::tc4100", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13237, 13238], leaf: 13236 }, + Case { id: "bettertls::nameconstraints::tc4101", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13240, 13241], leaf: 13239 }, + Case { id: "bettertls::nameconstraints::tc4102", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13243, 13244], leaf: 13242 }, + Case { id: "bettertls::nameconstraints::tc4103", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13246, 13247], leaf: 13245 }, + Case { id: "bettertls::nameconstraints::tc4104", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13249, 13250], leaf: 13248 }, + Case { id: "bettertls::nameconstraints::tc4105", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13252, 13253], leaf: 13251 }, + Case { id: "bettertls::nameconstraints::tc4106", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13255, 13256], leaf: 13254 }, + Case { id: "bettertls::nameconstraints::tc4107", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13258, 13259], leaf: 13257 }, + Case { id: "bettertls::nameconstraints::tc4108", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13261, 13262], leaf: 13260 }, + Case { id: "bettertls::nameconstraints::tc4109", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13264, 13265], leaf: 13263 }, + Case { id: "bettertls::nameconstraints::tc4110", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13267, 13268], leaf: 13266 }, + Case { id: "bettertls::nameconstraints::tc4111", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13270, 13271], leaf: 13269 }, + Case { id: "bettertls::nameconstraints::tc4112", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13273, 13274], leaf: 13272 }, + Case { id: "bettertls::nameconstraints::tc4113", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13276, 13277], leaf: 13275 }, + Case { id: "bettertls::nameconstraints::tc4114", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13279, 13280], leaf: 13278 }, + Case { id: "bettertls::nameconstraints::tc4115", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13282, 13283], leaf: 13281 }, + Case { id: "bettertls::nameconstraints::tc4116", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13285, 13286], leaf: 13284 }, + Case { id: "bettertls::nameconstraints::tc4117", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13288, 13289], leaf: 13287 }, + Case { id: "bettertls::nameconstraints::tc4118", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13291, 13292], leaf: 13290 }, + Case { id: "bettertls::nameconstraints::tc4119", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13294, 13295], leaf: 13293 }, + Case { id: "bettertls::nameconstraints::tc4120", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13297, 13298], leaf: 13296 }, + Case { id: "bettertls::nameconstraints::tc4121", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13300, 13301], leaf: 13299 }, + Case { id: "bettertls::nameconstraints::tc4122", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13303, 13304], leaf: 13302 }, + Case { id: "bettertls::nameconstraints::tc4123", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13306, 13307], leaf: 13305 }, + Case { id: "bettertls::nameconstraints::tc4124", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13309, 13310], leaf: 13308 }, + Case { id: "bettertls::nameconstraints::tc4125", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13312, 13313], leaf: 13311 }, + Case { id: "bettertls::nameconstraints::tc4126", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13315, 13316], leaf: 13314 }, + Case { id: "bettertls::nameconstraints::tc4127", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13318, 13319], leaf: 13317 }, + Case { id: "bettertls::nameconstraints::tc4128", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13321, 13322], leaf: 13320 }, + Case { id: "bettertls::nameconstraints::tc4129", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13324, 13325], leaf: 13323 }, + Case { id: "bettertls::nameconstraints::tc4130", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13327, 13328], leaf: 13326 }, + Case { id: "bettertls::nameconstraints::tc4131", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13330, 13331], leaf: 13329 }, + Case { id: "bettertls::nameconstraints::tc4132", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13333, 13334], leaf: 13332 }, + Case { id: "bettertls::nameconstraints::tc4133", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13336, 13337], leaf: 13335 }, + Case { id: "bettertls::nameconstraints::tc4134", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13339, 13340], leaf: 13338 }, + Case { id: "bettertls::nameconstraints::tc4135", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13342, 13343], leaf: 13341 }, + Case { id: "bettertls::nameconstraints::tc4136", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13345, 13346], leaf: 13344 }, + Case { id: "bettertls::nameconstraints::tc4137", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13348, 13349], leaf: 13347 }, + Case { id: "bettertls::nameconstraints::tc4138", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13351, 13352], leaf: 13350 }, + Case { id: "bettertls::nameconstraints::tc4139", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13354, 13355], leaf: 13353 }, + Case { id: "bettertls::nameconstraints::tc4140", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13357, 13358], leaf: 13356 }, + Case { id: "bettertls::nameconstraints::tc4141", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13360, 13361], leaf: 13359 }, + Case { id: "bettertls::nameconstraints::tc4142", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13363, 13364], leaf: 13362 }, + Case { id: "bettertls::nameconstraints::tc4143", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13366, 13367], leaf: 13365 }, + Case { id: "bettertls::nameconstraints::tc4144", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13369, 13370], leaf: 13368 }, + Case { id: "bettertls::nameconstraints::tc4145", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13372, 13373], leaf: 13371 }, + Case { id: "bettertls::nameconstraints::tc4146", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13375, 13376], leaf: 13374 }, + Case { id: "bettertls::nameconstraints::tc4147", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13378, 13379], leaf: 13377 }, + Case { id: "bettertls::nameconstraints::tc4148", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13381, 13382], leaf: 13380 }, + Case { id: "bettertls::nameconstraints::tc4149", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13384, 13385], leaf: 13383 }, + Case { id: "bettertls::nameconstraints::tc4150", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13387, 13388], leaf: 13386 }, + Case { id: "bettertls::nameconstraints::tc4151", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13390, 13391], leaf: 13389 }, + Case { id: "bettertls::nameconstraints::tc4152", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13393, 13394], leaf: 13392 }, + Case { id: "bettertls::nameconstraints::tc4153", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13396, 13397], leaf: 13395 }, + Case { id: "bettertls::nameconstraints::tc4154", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13399, 13400], leaf: 13398 }, + Case { id: "bettertls::nameconstraints::tc4155", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13402, 13403], leaf: 13401 }, + Case { id: "bettertls::nameconstraints::tc4156", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13405, 13406], leaf: 13404 }, + Case { id: "bettertls::nameconstraints::tc4157", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13408, 13409], leaf: 13407 }, + Case { id: "bettertls::nameconstraints::tc4158", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13411, 13412], leaf: 13410 }, + Case { id: "bettertls::nameconstraints::tc4159", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13414, 13415], leaf: 13413 }, + Case { id: "bettertls::nameconstraints::tc4160", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13417, 13418], leaf: 13416 }, + Case { id: "bettertls::nameconstraints::tc4161", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13420, 13421], leaf: 13419 }, + Case { id: "bettertls::nameconstraints::tc4162", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13423, 13424], leaf: 13422 }, + Case { id: "bettertls::nameconstraints::tc4163", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13426, 13427], leaf: 13425 }, + Case { id: "bettertls::nameconstraints::tc4164", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13429, 13430], leaf: 13428 }, + Case { id: "bettertls::nameconstraints::tc4165", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13432, 13433], leaf: 13431 }, + Case { id: "bettertls::nameconstraints::tc4166", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13435, 13436], leaf: 13434 }, + Case { id: "bettertls::nameconstraints::tc4167", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13438, 13439], leaf: 13437 }, + Case { id: "bettertls::nameconstraints::tc4168", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13441, 13442], leaf: 13440 }, + Case { id: "bettertls::nameconstraints::tc4169", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13444, 13445], leaf: 13443 }, + Case { id: "bettertls::nameconstraints::tc4170", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13447, 13448], leaf: 13446 }, + Case { id: "bettertls::nameconstraints::tc4171", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13450, 13451], leaf: 13449 }, + Case { id: "bettertls::nameconstraints::tc4172", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13453, 13454], leaf: 13452 }, + Case { id: "bettertls::nameconstraints::tc4173", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13456, 13457], leaf: 13455 }, + Case { id: "bettertls::nameconstraints::tc4174", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13459, 13460], leaf: 13458 }, + Case { id: "bettertls::nameconstraints::tc4175", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13462, 13463], leaf: 13461 }, + Case { id: "bettertls::nameconstraints::tc4176", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13465, 13466], leaf: 13464 }, + Case { id: "bettertls::nameconstraints::tc4177", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13468, 13469], leaf: 13467 }, + Case { id: "bettertls::nameconstraints::tc4178", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13471, 13472], leaf: 13470 }, + Case { id: "bettertls::nameconstraints::tc4179", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13474, 13475], leaf: 13473 }, + Case { id: "bettertls::nameconstraints::tc4180", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13477, 13478], leaf: 13476 }, + Case { id: "bettertls::nameconstraints::tc4181", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13480, 13481], leaf: 13479 }, + Case { id: "bettertls::nameconstraints::tc4182", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13483, 13484], leaf: 13482 }, + Case { id: "bettertls::nameconstraints::tc4183", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13486, 13487], leaf: 13485 }, + Case { id: "bettertls::nameconstraints::tc4184", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13489, 13490], leaf: 13488 }, + Case { id: "bettertls::nameconstraints::tc4185", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13492, 13493], leaf: 13491 }, + Case { id: "bettertls::nameconstraints::tc4186", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13495, 13496], leaf: 13494 }, + Case { id: "bettertls::nameconstraints::tc4187", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13498, 13499], leaf: 13497 }, + Case { id: "bettertls::nameconstraints::tc4188", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13501, 13502], leaf: 13500 }, + Case { id: "bettertls::nameconstraints::tc4189", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13504, 13505], leaf: 13503 }, + Case { id: "bettertls::nameconstraints::tc4190", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13507, 13508], leaf: 13506 }, + Case { id: "bettertls::nameconstraints::tc4191", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13510, 13511], leaf: 13509 }, + Case { id: "bettertls::nameconstraints::tc4192", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13513, 13514], leaf: 13512 }, + Case { id: "bettertls::nameconstraints::tc4193", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13516, 13517], leaf: 13515 }, + Case { id: "bettertls::nameconstraints::tc4194", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13519, 13520], leaf: 13518 }, + Case { id: "bettertls::nameconstraints::tc4195", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13522, 13523], leaf: 13521 }, + Case { id: "bettertls::nameconstraints::tc4196", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13525, 13526], leaf: 13524 }, + Case { id: "bettertls::nameconstraints::tc4197", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13528, 13529], leaf: 13527 }, + Case { id: "bettertls::nameconstraints::tc4198", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13531, 13532], leaf: 13530 }, + Case { id: "bettertls::nameconstraints::tc4199", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13534, 13535], leaf: 13533 }, + Case { id: "bettertls::nameconstraints::tc4200", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13537, 13538], leaf: 13536 }, + Case { id: "bettertls::nameconstraints::tc4201", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13540, 13541], leaf: 13539 }, + Case { id: "bettertls::nameconstraints::tc4202", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13543, 13544], leaf: 13542 }, + Case { id: "bettertls::nameconstraints::tc4203", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13546, 13547], leaf: 13545 }, + Case { id: "bettertls::nameconstraints::tc4204", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13549, 13550], leaf: 13548 }, + Case { id: "bettertls::nameconstraints::tc4205", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13552, 13553], leaf: 13551 }, + Case { id: "bettertls::nameconstraints::tc4206", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13555, 13556], leaf: 13554 }, + Case { id: "bettertls::nameconstraints::tc4207", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13558, 13559], leaf: 13557 }, + Case { id: "bettertls::nameconstraints::tc4208", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13561, 13562], leaf: 13560 }, + Case { id: "bettertls::nameconstraints::tc4209", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13564, 13565], leaf: 13563 }, + Case { id: "bettertls::nameconstraints::tc4210", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13567, 13568], leaf: 13566 }, + Case { id: "bettertls::nameconstraints::tc4211", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13570, 13571], leaf: 13569 }, + Case { id: "bettertls::nameconstraints::tc4212", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13573, 13574], leaf: 13572 }, + Case { id: "bettertls::nameconstraints::tc4213", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13576, 13577], leaf: 13575 }, + Case { id: "bettertls::nameconstraints::tc4214", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13579, 13580], leaf: 13578 }, + Case { id: "bettertls::nameconstraints::tc4215", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13582, 13583], leaf: 13581 }, + Case { id: "bettertls::nameconstraints::tc4216", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13585, 13586], leaf: 13584 }, + Case { id: "bettertls::nameconstraints::tc4217", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13588, 13589], leaf: 13587 }, + Case { id: "bettertls::nameconstraints::tc4218", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13591, 13592], leaf: 13590 }, + Case { id: "bettertls::nameconstraints::tc4219", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13594, 13595], leaf: 13593 }, + Case { id: "bettertls::nameconstraints::tc4220", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13597, 13598], leaf: 13596 }, + Case { id: "bettertls::nameconstraints::tc4221", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13600, 13601], leaf: 13599 }, + Case { id: "bettertls::nameconstraints::tc4222", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13603, 13604], leaf: 13602 }, + Case { id: "bettertls::nameconstraints::tc4223", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13606, 13607], leaf: 13605 }, + Case { id: "bettertls::nameconstraints::tc4224", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13609, 13610], leaf: 13608 }, + Case { id: "bettertls::nameconstraints::tc4225", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13612, 13613], leaf: 13611 }, + Case { id: "bettertls::nameconstraints::tc4226", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13615, 13616], leaf: 13614 }, + Case { id: "bettertls::nameconstraints::tc4227", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13618, 13619], leaf: 13617 }, + Case { id: "bettertls::nameconstraints::tc4228", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13621, 13622], leaf: 13620 }, + Case { id: "bettertls::nameconstraints::tc4229", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13624, 13625], leaf: 13623 }, + Case { id: "bettertls::nameconstraints::tc4230", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13627, 13628], leaf: 13626 }, + Case { id: "bettertls::nameconstraints::tc4231", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13630, 13631], leaf: 13629 }, + Case { id: "bettertls::nameconstraints::tc4232", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13633, 13634], leaf: 13632 }, + Case { id: "bettertls::nameconstraints::tc4233", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13636, 13637], leaf: 13635 }, + Case { id: "bettertls::nameconstraints::tc4234", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13639, 13640], leaf: 13638 }, + Case { id: "bettertls::nameconstraints::tc4235", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13642, 13643], leaf: 13641 }, + Case { id: "bettertls::nameconstraints::tc4236", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13645, 13646], leaf: 13644 }, + Case { id: "bettertls::nameconstraints::tc4237", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13648, 13649], leaf: 13647 }, + Case { id: "bettertls::nameconstraints::tc4238", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13651, 13652], leaf: 13650 }, + Case { id: "bettertls::nameconstraints::tc4239", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13654, 13655], leaf: 13653 }, + Case { id: "bettertls::nameconstraints::tc4240", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13657, 13658], leaf: 13656 }, + Case { id: "bettertls::nameconstraints::tc4241", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13660, 13661], leaf: 13659 }, + Case { id: "bettertls::nameconstraints::tc4242", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13663, 13664], leaf: 13662 }, + Case { id: "bettertls::nameconstraints::tc4243", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13666, 13667], leaf: 13665 }, + Case { id: "bettertls::nameconstraints::tc4244", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13669, 13670], leaf: 13668 }, + Case { id: "bettertls::nameconstraints::tc4245", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13672, 13673], leaf: 13671 }, + Case { id: "bettertls::nameconstraints::tc4246", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13675, 13676], leaf: 13674 }, + Case { id: "bettertls::nameconstraints::tc4247", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13678, 13679], leaf: 13677 }, + Case { id: "bettertls::nameconstraints::tc4248", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13681, 13682], leaf: 13680 }, + Case { id: "bettertls::nameconstraints::tc4249", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13684, 13685], leaf: 13683 }, + Case { id: "bettertls::nameconstraints::tc4250", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13687, 13688], leaf: 13686 }, + Case { id: "bettertls::nameconstraints::tc4251", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13690, 13691], leaf: 13689 }, + Case { id: "bettertls::nameconstraints::tc4252", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13693, 13694], leaf: 13692 }, + Case { id: "bettertls::nameconstraints::tc4253", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13696, 13697], leaf: 13695 }, + Case { id: "bettertls::nameconstraints::tc4254", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13699, 13700], leaf: 13698 }, + Case { id: "bettertls::nameconstraints::tc4255", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13702, 13703], leaf: 13701 }, + Case { id: "bettertls::nameconstraints::tc4256", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13705, 13706], leaf: 13704 }, + Case { id: "bettertls::nameconstraints::tc4257", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13708, 13709], leaf: 13707 }, + Case { id: "bettertls::nameconstraints::tc4258", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13711, 13712], leaf: 13710 }, + Case { id: "bettertls::nameconstraints::tc4259", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13714, 13715], leaf: 13713 }, + Case { id: "bettertls::nameconstraints::tc4260", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13717, 13718], leaf: 13716 }, + Case { id: "bettertls::nameconstraints::tc4261", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13720, 13721], leaf: 13719 }, + Case { id: "bettertls::nameconstraints::tc4262", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13723, 13724], leaf: 13722 }, + Case { id: "bettertls::nameconstraints::tc4263", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13726, 13727], leaf: 13725 }, + Case { id: "bettertls::nameconstraints::tc4264", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13729, 13730], leaf: 13728 }, + Case { id: "bettertls::nameconstraints::tc4265", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13732, 13733], leaf: 13731 }, + Case { id: "bettertls::nameconstraints::tc4266", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13735, 13736], leaf: 13734 }, + Case { id: "bettertls::nameconstraints::tc4267", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13738, 13739], leaf: 13737 }, + Case { id: "bettertls::nameconstraints::tc4268", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13741, 13742], leaf: 13740 }, + Case { id: "bettertls::nameconstraints::tc4269", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13744, 13745], leaf: 13743 }, + Case { id: "bettertls::nameconstraints::tc4270", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13747, 13748], leaf: 13746 }, + Case { id: "bettertls::nameconstraints::tc4271", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13750, 13751], leaf: 13749 }, + Case { id: "bettertls::nameconstraints::tc4272", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13753, 13754], leaf: 13752 }, + Case { id: "bettertls::nameconstraints::tc4273", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13756, 13757], leaf: 13755 }, + Case { id: "bettertls::nameconstraints::tc4274", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13759, 13760], leaf: 13758 }, + Case { id: "bettertls::nameconstraints::tc4275", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13762, 13763], leaf: 13761 }, + Case { id: "bettertls::nameconstraints::tc4276", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13765, 13766], leaf: 13764 }, + Case { id: "bettertls::nameconstraints::tc4277", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13768, 13769], leaf: 13767 }, + Case { id: "bettertls::nameconstraints::tc4278", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13771, 13772], leaf: 13770 }, + Case { id: "bettertls::nameconstraints::tc4279", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13774, 13775], leaf: 13773 }, + Case { id: "bettertls::nameconstraints::tc4280", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13777, 13778], leaf: 13776 }, + Case { id: "bettertls::nameconstraints::tc4281", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13780, 13781], leaf: 13779 }, + Case { id: "bettertls::nameconstraints::tc4282", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13783, 13784], leaf: 13782 }, + Case { id: "bettertls::nameconstraints::tc4283", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13786, 13787], leaf: 13785 }, + Case { id: "bettertls::nameconstraints::tc4284", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13789, 13790], leaf: 13788 }, + Case { id: "bettertls::nameconstraints::tc4285", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13792, 13793], leaf: 13791 }, + Case { id: "bettertls::nameconstraints::tc4286", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13795, 13796], leaf: 13794 }, + Case { id: "bettertls::nameconstraints::tc4287", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13798, 13799], leaf: 13797 }, + Case { id: "bettertls::nameconstraints::tc4288", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13801, 13802], leaf: 13800 }, + Case { id: "bettertls::nameconstraints::tc4289", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13804, 13805], leaf: 13803 }, + Case { id: "bettertls::nameconstraints::tc4290", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13807, 13808], leaf: 13806 }, + Case { id: "bettertls::nameconstraints::tc4291", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13810, 13811], leaf: 13809 }, + Case { id: "bettertls::nameconstraints::tc4292", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13813, 13814], leaf: 13812 }, + Case { id: "bettertls::nameconstraints::tc4293", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13816, 13817], leaf: 13815 }, + Case { id: "bettertls::nameconstraints::tc4294", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13819, 13820], leaf: 13818 }, + Case { id: "bettertls::nameconstraints::tc4295", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13822, 13823], leaf: 13821 }, + Case { id: "bettertls::nameconstraints::tc4296", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13825, 13826], leaf: 13824 }, + Case { id: "bettertls::nameconstraints::tc4297", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13828, 13829], leaf: 13827 }, + Case { id: "bettertls::nameconstraints::tc4298", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13831, 13832], leaf: 13830 }, + Case { id: "bettertls::nameconstraints::tc4299", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13834, 13835], leaf: 13833 }, + Case { id: "bettertls::nameconstraints::tc4300", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13837, 13838], leaf: 13836 }, + Case { id: "bettertls::nameconstraints::tc4301", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13840, 13841], leaf: 13839 }, + Case { id: "bettertls::nameconstraints::tc4302", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13843, 13844], leaf: 13842 }, + Case { id: "bettertls::nameconstraints::tc4303", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13846, 13847], leaf: 13845 }, + Case { id: "bettertls::nameconstraints::tc4304", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13849, 13850], leaf: 13848 }, + Case { id: "bettertls::nameconstraints::tc4305", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13852, 13853], leaf: 13851 }, + Case { id: "bettertls::nameconstraints::tc4306", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13855, 13856], leaf: 13854 }, + Case { id: "bettertls::nameconstraints::tc4307", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13858, 13859], leaf: 13857 }, + Case { id: "bettertls::nameconstraints::tc4308", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13861, 13862], leaf: 13860 }, + Case { id: "bettertls::nameconstraints::tc4309", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13864, 13865], leaf: 13863 }, + Case { id: "bettertls::nameconstraints::tc4310", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13867, 13868], leaf: 13866 }, + Case { id: "bettertls::nameconstraints::tc4311", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13870, 13871], leaf: 13869 }, + Case { id: "bettertls::nameconstraints::tc4312", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13873, 13874], leaf: 13872 }, + Case { id: "bettertls::nameconstraints::tc4313", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13876, 13877], leaf: 13875 }, + Case { id: "bettertls::nameconstraints::tc4314", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13879, 13880], leaf: 13878 }, + Case { id: "bettertls::nameconstraints::tc4315", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13882, 13883], leaf: 13881 }, + Case { id: "bettertls::nameconstraints::tc4316", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13885, 13886], leaf: 13884 }, + Case { id: "bettertls::nameconstraints::tc4317", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13888, 13889], leaf: 13887 }, + Case { id: "bettertls::nameconstraints::tc4318", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13891, 13892], leaf: 13890 }, + Case { id: "bettertls::nameconstraints::tc4319", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13894, 13895], leaf: 13893 }, + Case { id: "bettertls::nameconstraints::tc4320", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13897, 13898], leaf: 13896 }, + Case { id: "bettertls::nameconstraints::tc4321", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13900, 13901], leaf: 13899 }, + Case { id: "bettertls::nameconstraints::tc4322", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13903, 13904], leaf: 13902 }, + Case { id: "bettertls::nameconstraints::tc4323", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13906, 13907], leaf: 13905 }, + Case { id: "bettertls::nameconstraints::tc4324", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13909, 13910], leaf: 13908 }, + Case { id: "bettertls::nameconstraints::tc4325", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13912, 13913], leaf: 13911 }, + Case { id: "bettertls::nameconstraints::tc4326", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13915, 13916], leaf: 13914 }, + Case { id: "bettertls::nameconstraints::tc4327", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13918, 13919], leaf: 13917 }, + Case { id: "bettertls::nameconstraints::tc4328", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13921, 13922], leaf: 13920 }, + Case { id: "bettertls::nameconstraints::tc4329", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13924, 13925], leaf: 13923 }, + Case { id: "bettertls::nameconstraints::tc4330", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13927, 13928], leaf: 13926 }, + Case { id: "bettertls::nameconstraints::tc4331", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13930, 13931], leaf: 13929 }, + Case { id: "bettertls::nameconstraints::tc4332", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13933, 13934], leaf: 13932 }, + Case { id: "bettertls::nameconstraints::tc4333", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13936, 13937], leaf: 13935 }, + Case { id: "bettertls::nameconstraints::tc4334", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13939, 13940], leaf: 13938 }, + Case { id: "bettertls::nameconstraints::tc4335", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13942, 13943], leaf: 13941 }, + Case { id: "bettertls::nameconstraints::tc4336", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13945, 13946], leaf: 13944 }, + Case { id: "bettertls::nameconstraints::tc4337", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13948, 13949], leaf: 13947 }, + Case { id: "bettertls::nameconstraints::tc4338", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13951, 13952], leaf: 13950 }, + Case { id: "bettertls::nameconstraints::tc4339", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13954, 13955], leaf: 13953 }, + Case { id: "bettertls::nameconstraints::tc4340", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13957, 13958], leaf: 13956 }, + Case { id: "bettertls::nameconstraints::tc4341", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13960, 13961], leaf: 13959 }, + Case { id: "bettertls::nameconstraints::tc4342", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13963, 13964], leaf: 13962 }, + Case { id: "bettertls::nameconstraints::tc4343", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13966, 13967], leaf: 13965 }, + Case { id: "bettertls::nameconstraints::tc4344", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13969, 13970], leaf: 13968 }, + Case { id: "bettertls::nameconstraints::tc4345", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13972, 13973], leaf: 13971 }, + Case { id: "bettertls::nameconstraints::tc4346", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13975, 13976], leaf: 13974 }, + Case { id: "bettertls::nameconstraints::tc4347", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13978, 13979], leaf: 13977 }, + Case { id: "bettertls::nameconstraints::tc4348", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13981, 13982], leaf: 13980 }, + Case { id: "bettertls::nameconstraints::tc4349", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13984, 13985], leaf: 13983 }, + Case { id: "bettertls::nameconstraints::tc4350", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13987, 13988], leaf: 13986 }, + Case { id: "bettertls::nameconstraints::tc4351", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13990, 13991], leaf: 13989 }, + Case { id: "bettertls::nameconstraints::tc4352", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13993, 13994], leaf: 13992 }, + Case { id: "bettertls::nameconstraints::tc4353", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13996, 13997], leaf: 13995 }, + Case { id: "bettertls::nameconstraints::tc4354", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[13999, 14000], leaf: 13998 }, + Case { id: "bettertls::nameconstraints::tc4355", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14002, 14003], leaf: 14001 }, + Case { id: "bettertls::nameconstraints::tc4356", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14005, 14006], leaf: 14004 }, + Case { id: "bettertls::nameconstraints::tc4357", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14008, 14009], leaf: 14007 }, + Case { id: "bettertls::nameconstraints::tc4358", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14011, 14012], leaf: 14010 }, + Case { id: "bettertls::nameconstraints::tc4359", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14014, 14015], leaf: 14013 }, + Case { id: "bettertls::nameconstraints::tc4360", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14017, 14018], leaf: 14016 }, + Case { id: "bettertls::nameconstraints::tc4361", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14020, 14021], leaf: 14019 }, + Case { id: "bettertls::nameconstraints::tc4362", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14023, 14024], leaf: 14022 }, + Case { id: "bettertls::nameconstraints::tc4363", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14026, 14027], leaf: 14025 }, + Case { id: "bettertls::nameconstraints::tc4364", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14029, 14030], leaf: 14028 }, + Case { id: "bettertls::nameconstraints::tc4365", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14032, 14033], leaf: 14031 }, + Case { id: "bettertls::nameconstraints::tc4366", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14035, 14036], leaf: 14034 }, + Case { id: "bettertls::nameconstraints::tc4367", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14038, 14039], leaf: 14037 }, + Case { id: "bettertls::nameconstraints::tc4368", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14041, 14042], leaf: 14040 }, + Case { id: "bettertls::nameconstraints::tc4369", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14044, 14045], leaf: 14043 }, + Case { id: "bettertls::nameconstraints::tc4370", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14047, 14048], leaf: 14046 }, + Case { id: "bettertls::nameconstraints::tc4371", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14050, 14051], leaf: 14049 }, + Case { id: "bettertls::nameconstraints::tc4372", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14053, 14054], leaf: 14052 }, + Case { id: "bettertls::nameconstraints::tc4373", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14056, 14057], leaf: 14055 }, + Case { id: "bettertls::nameconstraints::tc4374", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14059, 14060], leaf: 14058 }, + Case { id: "bettertls::nameconstraints::tc4375", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14062, 14063], leaf: 14061 }, + Case { id: "bettertls::nameconstraints::tc4376", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14065, 14066], leaf: 14064 }, + Case { id: "bettertls::nameconstraints::tc4377", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14068, 14069], leaf: 14067 }, + Case { id: "bettertls::nameconstraints::tc4378", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14071, 14072], leaf: 14070 }, + Case { id: "bettertls::nameconstraints::tc4379", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14074, 14075], leaf: 14073 }, + Case { id: "bettertls::nameconstraints::tc4380", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14077, 14078], leaf: 14076 }, + Case { id: "bettertls::nameconstraints::tc4381", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14080, 14081], leaf: 14079 }, + Case { id: "bettertls::nameconstraints::tc4382", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14083, 14084], leaf: 14082 }, + Case { id: "bettertls::nameconstraints::tc4383", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14086, 14087], leaf: 14085 }, + Case { id: "bettertls::nameconstraints::tc4384", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14089, 14090], leaf: 14088 }, + Case { id: "bettertls::nameconstraints::tc4385", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14092, 14093], leaf: 14091 }, + Case { id: "bettertls::nameconstraints::tc4386", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14095, 14096], leaf: 14094 }, + Case { id: "bettertls::nameconstraints::tc4387", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14098, 14099], leaf: 14097 }, + Case { id: "bettertls::nameconstraints::tc4388", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14101, 14102], leaf: 14100 }, + Case { id: "bettertls::nameconstraints::tc4389", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14104, 14105], leaf: 14103 }, + Case { id: "bettertls::nameconstraints::tc4390", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14107, 14108], leaf: 14106 }, + Case { id: "bettertls::nameconstraints::tc4391", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14110, 14111], leaf: 14109 }, + Case { id: "bettertls::nameconstraints::tc4392", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14113, 14114], leaf: 14112 }, + Case { id: "bettertls::nameconstraints::tc4393", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14116, 14117], leaf: 14115 }, + Case { id: "bettertls::nameconstraints::tc4394", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14119, 14120], leaf: 14118 }, + Case { id: "bettertls::nameconstraints::tc4395", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14122, 14123], leaf: 14121 }, + Case { id: "bettertls::nameconstraints::tc4396", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14125, 14126], leaf: 14124 }, + Case { id: "bettertls::nameconstraints::tc4397", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14128, 14129], leaf: 14127 }, + Case { id: "bettertls::nameconstraints::tc4398", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14131, 14132], leaf: 14130 }, + Case { id: "bettertls::nameconstraints::tc4399", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14134, 14135], leaf: 14133 }, + Case { id: "bettertls::nameconstraints::tc4400", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14137, 14138], leaf: 14136 }, + Case { id: "bettertls::nameconstraints::tc4401", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14140, 14141], leaf: 14139 }, + Case { id: "bettertls::nameconstraints::tc4402", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14143, 14144], leaf: 14142 }, + Case { id: "bettertls::nameconstraints::tc4403", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14146, 14147], leaf: 14145 }, + Case { id: "bettertls::nameconstraints::tc4404", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14149, 14150], leaf: 14148 }, + Case { id: "bettertls::nameconstraints::tc4405", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14152, 14153], leaf: 14151 }, + Case { id: "bettertls::nameconstraints::tc4406", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14155, 14156], leaf: 14154 }, + Case { id: "bettertls::nameconstraints::tc4407", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14158, 14159], leaf: 14157 }, + Case { id: "bettertls::nameconstraints::tc4408", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14161, 14162], leaf: 14160 }, + Case { id: "bettertls::nameconstraints::tc4409", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14164, 14165], leaf: 14163 }, + Case { id: "bettertls::nameconstraints::tc4410", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14167, 14168], leaf: 14166 }, + Case { id: "bettertls::nameconstraints::tc4411", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14170, 14171], leaf: 14169 }, + Case { id: "bettertls::nameconstraints::tc4412", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14173, 14174], leaf: 14172 }, + Case { id: "bettertls::nameconstraints::tc4413", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14176, 14177], leaf: 14175 }, + Case { id: "bettertls::nameconstraints::tc4414", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14179, 14180], leaf: 14178 }, + Case { id: "bettertls::nameconstraints::tc4415", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14182, 14183], leaf: 14181 }, + Case { id: "bettertls::nameconstraints::tc4416", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14185, 14186], leaf: 14184 }, + Case { id: "bettertls::nameconstraints::tc4417", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14188, 14189], leaf: 14187 }, + Case { id: "bettertls::nameconstraints::tc4418", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14191, 14192], leaf: 14190 }, + Case { id: "bettertls::nameconstraints::tc4419", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14194, 14195], leaf: 14193 }, + Case { id: "bettertls::nameconstraints::tc4420", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14197, 14198], leaf: 14196 }, + Case { id: "bettertls::nameconstraints::tc4421", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14200, 14201], leaf: 14199 }, + Case { id: "bettertls::nameconstraints::tc4422", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14203, 14204], leaf: 14202 }, + Case { id: "bettertls::nameconstraints::tc4423", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14206, 14207], leaf: 14205 }, + Case { id: "bettertls::nameconstraints::tc4424", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14209, 14210], leaf: 14208 }, + Case { id: "bettertls::nameconstraints::tc4425", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14212, 14213], leaf: 14211 }, + Case { id: "bettertls::nameconstraints::tc4426", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14215, 14216], leaf: 14214 }, + Case { id: "bettertls::nameconstraints::tc4427", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14218, 14219], leaf: 14217 }, + Case { id: "bettertls::nameconstraints::tc4428", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14221, 14222], leaf: 14220 }, + Case { id: "bettertls::nameconstraints::tc4429", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14224, 14225], leaf: 14223 }, + Case { id: "bettertls::nameconstraints::tc4430", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14227, 14228], leaf: 14226 }, + Case { id: "bettertls::nameconstraints::tc4431", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14230, 14231], leaf: 14229 }, + Case { id: "bettertls::nameconstraints::tc4432", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14233, 14234], leaf: 14232 }, + Case { id: "bettertls::nameconstraints::tc4433", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14236, 14237], leaf: 14235 }, + Case { id: "bettertls::nameconstraints::tc4434", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14239, 14240], leaf: 14238 }, + Case { id: "bettertls::nameconstraints::tc4435", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14242, 14243], leaf: 14241 }, + Case { id: "bettertls::nameconstraints::tc4436", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14245, 14246], leaf: 14244 }, + Case { id: "bettertls::nameconstraints::tc4437", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14248, 14249], leaf: 14247 }, + Case { id: "bettertls::nameconstraints::tc4438", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14251, 14252], leaf: 14250 }, + Case { id: "bettertls::nameconstraints::tc4439", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14254, 14255], leaf: 14253 }, + Case { id: "bettertls::nameconstraints::tc4440", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14257, 14258], leaf: 14256 }, + Case { id: "bettertls::nameconstraints::tc4441", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14260, 14261], leaf: 14259 }, + Case { id: "bettertls::nameconstraints::tc4442", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14263, 14264], leaf: 14262 }, + Case { id: "bettertls::nameconstraints::tc4443", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14266, 14267], leaf: 14265 }, + Case { id: "bettertls::nameconstraints::tc4444", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14269, 14270], leaf: 14268 }, + Case { id: "bettertls::nameconstraints::tc4445", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14272, 14273], leaf: 14271 }, + Case { id: "bettertls::nameconstraints::tc4446", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14275, 14276], leaf: 14274 }, + Case { id: "bettertls::nameconstraints::tc4447", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14278, 14279], leaf: 14277 }, + Case { id: "bettertls::nameconstraints::tc4448", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14281, 14282], leaf: 14280 }, + Case { id: "bettertls::nameconstraints::tc4449", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14284, 14285], leaf: 14283 }, + Case { id: "bettertls::nameconstraints::tc4450", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14287, 14288], leaf: 14286 }, + Case { id: "bettertls::nameconstraints::tc4451", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14290, 14291], leaf: 14289 }, + Case { id: "bettertls::nameconstraints::tc4452", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14293, 14294], leaf: 14292 }, + Case { id: "bettertls::nameconstraints::tc4453", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14296, 14297], leaf: 14295 }, + Case { id: "bettertls::nameconstraints::tc4454", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14299, 14300], leaf: 14298 }, + Case { id: "bettertls::nameconstraints::tc4455", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14302, 14303], leaf: 14301 }, + Case { id: "bettertls::nameconstraints::tc4456", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14305, 14306], leaf: 14304 }, + Case { id: "bettertls::nameconstraints::tc4457", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14308, 14309], leaf: 14307 }, + Case { id: "bettertls::nameconstraints::tc4458", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14311, 14312], leaf: 14310 }, + Case { id: "bettertls::nameconstraints::tc4459", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14314, 14315], leaf: 14313 }, + Case { id: "bettertls::nameconstraints::tc4460", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14317, 14318], leaf: 14316 }, + Case { id: "bettertls::nameconstraints::tc4461", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14320, 14321], leaf: 14319 }, + Case { id: "bettertls::nameconstraints::tc4462", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14323, 14324], leaf: 14322 }, + Case { id: "bettertls::nameconstraints::tc4463", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14326, 14327], leaf: 14325 }, + Case { id: "bettertls::nameconstraints::tc4464", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14329, 14330], leaf: 14328 }, + Case { id: "bettertls::nameconstraints::tc4465", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14332, 14333], leaf: 14331 }, + Case { id: "bettertls::nameconstraints::tc4466", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14335, 14336], leaf: 14334 }, + Case { id: "bettertls::nameconstraints::tc4467", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14338, 14339], leaf: 14337 }, + Case { id: "bettertls::nameconstraints::tc4468", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14341, 14342], leaf: 14340 }, + Case { id: "bettertls::nameconstraints::tc4469", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14344, 14345], leaf: 14343 }, + Case { id: "bettertls::nameconstraints::tc4470", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14347, 14348], leaf: 14346 }, + Case { id: "bettertls::nameconstraints::tc4471", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14350, 14351], leaf: 14349 }, + Case { id: "bettertls::nameconstraints::tc4472", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14353, 14354], leaf: 14352 }, + Case { id: "bettertls::nameconstraints::tc4473", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14356, 14357], leaf: 14355 }, + Case { id: "bettertls::nameconstraints::tc4474", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14359, 14360], leaf: 14358 }, + Case { id: "bettertls::nameconstraints::tc4475", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14362, 14363], leaf: 14361 }, + Case { id: "bettertls::nameconstraints::tc4476", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14365, 14366], leaf: 14364 }, + Case { id: "bettertls::nameconstraints::tc4477", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14368, 14369], leaf: 14367 }, + Case { id: "bettertls::nameconstraints::tc4478", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14371, 14372], leaf: 14370 }, + Case { id: "bettertls::nameconstraints::tc4479", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14374, 14375], leaf: 14373 }, + Case { id: "bettertls::nameconstraints::tc4480", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14377, 14378], leaf: 14376 }, + Case { id: "bettertls::nameconstraints::tc4481", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14380, 14381], leaf: 14379 }, + Case { id: "bettertls::nameconstraints::tc4482", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14383, 14384], leaf: 14382 }, + Case { id: "bettertls::nameconstraints::tc4483", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14386, 14387], leaf: 14385 }, + Case { id: "bettertls::nameconstraints::tc4484", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14389, 14390], leaf: 14388 }, + Case { id: "bettertls::nameconstraints::tc4485", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14392, 14393], leaf: 14391 }, + Case { id: "bettertls::nameconstraints::tc4486", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14395, 14396], leaf: 14394 }, + Case { id: "bettertls::nameconstraints::tc4487", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14398, 14399], leaf: 14397 }, + Case { id: "bettertls::nameconstraints::tc4488", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14401, 14402], leaf: 14400 }, + Case { id: "bettertls::nameconstraints::tc4489", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14404, 14405], leaf: 14403 }, + Case { id: "bettertls::nameconstraints::tc4490", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14407, 14408], leaf: 14406 }, + Case { id: "bettertls::nameconstraints::tc4491", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14410, 14411], leaf: 14409 }, + Case { id: "bettertls::nameconstraints::tc4492", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14413, 14414], leaf: 14412 }, + Case { id: "bettertls::nameconstraints::tc4493", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14416, 14417], leaf: 14415 }, + Case { id: "bettertls::nameconstraints::tc4494", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14419, 14420], leaf: 14418 }, + Case { id: "bettertls::nameconstraints::tc4495", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14422, 14423], leaf: 14421 }, + Case { id: "bettertls::nameconstraints::tc4496", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14425, 14426], leaf: 14424 }, + Case { id: "bettertls::nameconstraints::tc4497", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14428, 14429], leaf: 14427 }, + Case { id: "bettertls::nameconstraints::tc4498", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14431, 14432], leaf: 14430 }, + Case { id: "bettertls::nameconstraints::tc4499", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14434, 14435], leaf: 14433 }, + Case { id: "bettertls::nameconstraints::tc4500", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14437, 14438], leaf: 14436 }, + Case { id: "bettertls::nameconstraints::tc4501", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14440, 14441], leaf: 14439 }, + Case { id: "bettertls::nameconstraints::tc4502", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14443, 14444], leaf: 14442 }, + Case { id: "bettertls::nameconstraints::tc4503", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14446, 14447], leaf: 14445 }, + Case { id: "bettertls::nameconstraints::tc4504", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14449, 14450], leaf: 14448 }, + Case { id: "bettertls::nameconstraints::tc4505", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14452, 14453], leaf: 14451 }, + Case { id: "bettertls::nameconstraints::tc4506", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14455, 14456], leaf: 14454 }, + Case { id: "bettertls::nameconstraints::tc4507", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14458, 14459], leaf: 14457 }, + Case { id: "bettertls::nameconstraints::tc4508", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14461, 14462], leaf: 14460 }, + Case { id: "bettertls::nameconstraints::tc4509", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14464, 14465], leaf: 14463 }, + Case { id: "bettertls::nameconstraints::tc4510", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14467, 14468], leaf: 14466 }, + Case { id: "bettertls::nameconstraints::tc4511", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14470, 14471], leaf: 14469 }, + Case { id: "bettertls::nameconstraints::tc4512", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14473, 14474], leaf: 14472 }, + Case { id: "bettertls::nameconstraints::tc4513", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14476, 14477], leaf: 14475 }, + Case { id: "bettertls::nameconstraints::tc4514", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14479, 14480], leaf: 14478 }, + Case { id: "bettertls::nameconstraints::tc4515", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14482, 14483], leaf: 14481 }, + Case { id: "bettertls::nameconstraints::tc4516", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14485, 14486], leaf: 14484 }, + Case { id: "bettertls::nameconstraints::tc4517", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14488, 14489], leaf: 14487 }, + Case { id: "bettertls::nameconstraints::tc4518", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14491, 14492], leaf: 14490 }, + Case { id: "bettertls::nameconstraints::tc4519", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14494, 14495], leaf: 14493 }, + Case { id: "bettertls::nameconstraints::tc4520", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14497, 14498], leaf: 14496 }, + Case { id: "bettertls::nameconstraints::tc4521", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14500, 14501], leaf: 14499 }, + Case { id: "bettertls::nameconstraints::tc4522", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14503, 14504], leaf: 14502 }, + Case { id: "bettertls::nameconstraints::tc4523", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14506, 14507], leaf: 14505 }, + Case { id: "bettertls::nameconstraints::tc4524", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14509, 14510], leaf: 14508 }, + Case { id: "bettertls::nameconstraints::tc4525", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14512, 14513], leaf: 14511 }, + Case { id: "bettertls::nameconstraints::tc4526", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14515, 14516], leaf: 14514 }, + Case { id: "bettertls::nameconstraints::tc4527", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14518, 14519], leaf: 14517 }, + Case { id: "bettertls::nameconstraints::tc4528", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14521, 14522], leaf: 14520 }, + Case { id: "bettertls::nameconstraints::tc4529", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14524, 14525], leaf: 14523 }, + Case { id: "bettertls::nameconstraints::tc4530", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14527, 14528], leaf: 14526 }, + Case { id: "bettertls::nameconstraints::tc4531", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14530, 14531], leaf: 14529 }, + Case { id: "bettertls::nameconstraints::tc4532", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14533, 14534], leaf: 14532 }, + Case { id: "bettertls::nameconstraints::tc4533", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14536, 14537], leaf: 14535 }, + Case { id: "bettertls::nameconstraints::tc4534", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14539, 14540], leaf: 14538 }, + Case { id: "bettertls::nameconstraints::tc4535", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14542, 14543], leaf: 14541 }, + Case { id: "bettertls::nameconstraints::tc4536", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14545, 14546], leaf: 14544 }, + Case { id: "bettertls::nameconstraints::tc4537", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14548, 14549], leaf: 14547 }, + Case { id: "bettertls::nameconstraints::tc4538", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14551, 14552], leaf: 14550 }, + Case { id: "bettertls::nameconstraints::tc4539", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14554, 14555], leaf: 14553 }, + Case { id: "bettertls::nameconstraints::tc4540", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14557, 14558], leaf: 14556 }, + Case { id: "bettertls::nameconstraints::tc4541", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14560, 14561], leaf: 14559 }, + Case { id: "bettertls::nameconstraints::tc4542", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14563, 14564], leaf: 14562 }, + Case { id: "bettertls::nameconstraints::tc4543", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14566, 14567], leaf: 14565 }, + Case { id: "bettertls::nameconstraints::tc4544", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14569, 14570], leaf: 14568 }, + Case { id: "bettertls::nameconstraints::tc4545", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14572, 14573], leaf: 14571 }, + Case { id: "bettertls::nameconstraints::tc4546", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14575, 14576], leaf: 14574 }, + Case { id: "bettertls::nameconstraints::tc4547", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14578, 14579], leaf: 14577 }, + Case { id: "bettertls::nameconstraints::tc4548", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14581, 14582], leaf: 14580 }, + Case { id: "bettertls::nameconstraints::tc4549", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14584, 14585], leaf: 14583 }, + Case { id: "bettertls::nameconstraints::tc4550", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14587, 14588], leaf: 14586 }, + Case { id: "bettertls::nameconstraints::tc4551", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14590, 14591], leaf: 14589 }, + Case { id: "bettertls::nameconstraints::tc4552", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14593, 14594], leaf: 14592 }, + Case { id: "bettertls::nameconstraints::tc4553", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14596, 14597], leaf: 14595 }, + Case { id: "bettertls::nameconstraints::tc4554", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14599, 14600], leaf: 14598 }, + Case { id: "bettertls::nameconstraints::tc4555", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14602, 14603], leaf: 14601 }, + Case { id: "bettertls::nameconstraints::tc4556", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14605, 14606], leaf: 14604 }, + Case { id: "bettertls::nameconstraints::tc4557", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14608, 14609], leaf: 14607 }, + Case { id: "bettertls::nameconstraints::tc4558", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14611, 14612], leaf: 14610 }, + Case { id: "bettertls::nameconstraints::tc4559", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14614, 14615], leaf: 14613 }, + Case { id: "bettertls::nameconstraints::tc4560", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14617, 14618], leaf: 14616 }, + Case { id: "bettertls::nameconstraints::tc4561", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14620, 14621], leaf: 14619 }, + Case { id: "bettertls::nameconstraints::tc4562", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14623, 14624], leaf: 14622 }, + Case { id: "bettertls::nameconstraints::tc4563", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14626, 14627], leaf: 14625 }, + Case { id: "bettertls::nameconstraints::tc4564", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14629, 14630], leaf: 14628 }, + Case { id: "bettertls::nameconstraints::tc4565", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14632, 14633], leaf: 14631 }, + Case { id: "bettertls::nameconstraints::tc4566", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14635, 14636], leaf: 14634 }, + Case { id: "bettertls::nameconstraints::tc4567", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14638, 14639], leaf: 14637 }, + Case { id: "bettertls::nameconstraints::tc4568", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14641, 14642], leaf: 14640 }, + Case { id: "bettertls::nameconstraints::tc4569", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14644, 14645], leaf: 14643 }, + Case { id: "bettertls::nameconstraints::tc4570", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14647, 14648], leaf: 14646 }, + Case { id: "bettertls::nameconstraints::tc4571", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14650, 14651], leaf: 14649 }, + Case { id: "bettertls::nameconstraints::tc4572", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14653, 14654], leaf: 14652 }, + Case { id: "bettertls::nameconstraints::tc4573", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14656, 14657], leaf: 14655 }, + Case { id: "bettertls::nameconstraints::tc4574", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14659, 14660], leaf: 14658 }, + Case { id: "bettertls::nameconstraints::tc4575", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14662, 14663], leaf: 14661 }, + Case { id: "bettertls::nameconstraints::tc4576", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14665, 14666], leaf: 14664 }, + Case { id: "bettertls::nameconstraints::tc4577", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14668, 14669], leaf: 14667 }, + Case { id: "bettertls::nameconstraints::tc4578", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14671, 14672], leaf: 14670 }, + Case { id: "bettertls::nameconstraints::tc4579", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14674, 14675], leaf: 14673 }, + Case { id: "bettertls::nameconstraints::tc4580", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14677, 14678], leaf: 14676 }, + Case { id: "bettertls::nameconstraints::tc4581", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14680, 14681], leaf: 14679 }, + Case { id: "bettertls::nameconstraints::tc4582", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14683, 14684], leaf: 14682 }, + Case { id: "bettertls::nameconstraints::tc4583", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14686, 14687], leaf: 14685 }, + Case { id: "bettertls::nameconstraints::tc4584", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14689, 14690], leaf: 14688 }, + Case { id: "bettertls::nameconstraints::tc4585", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14692, 14693], leaf: 14691 }, + Case { id: "bettertls::nameconstraints::tc4586", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14695, 14696], leaf: 14694 }, + Case { id: "bettertls::nameconstraints::tc4587", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14698, 14699], leaf: 14697 }, + Case { id: "bettertls::nameconstraints::tc4588", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14701, 14702], leaf: 14700 }, + Case { id: "bettertls::nameconstraints::tc4589", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14704, 14705], leaf: 14703 }, + Case { id: "bettertls::nameconstraints::tc4590", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14707, 14708], leaf: 14706 }, + Case { id: "bettertls::nameconstraints::tc4591", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14710, 14711], leaf: 14709 }, + Case { id: "bettertls::nameconstraints::tc4592", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14713, 14714], leaf: 14712 }, + Case { id: "bettertls::nameconstraints::tc4593", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14716, 14717], leaf: 14715 }, + Case { id: "bettertls::nameconstraints::tc4594", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14719, 14720], leaf: 14718 }, + Case { id: "bettertls::nameconstraints::tc4595", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14722, 14723], leaf: 14721 }, + Case { id: "bettertls::nameconstraints::tc4596", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14725, 14726], leaf: 14724 }, + Case { id: "bettertls::nameconstraints::tc4597", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14728, 14729], leaf: 14727 }, + Case { id: "bettertls::nameconstraints::tc4598", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14731, 14732], leaf: 14730 }, + Case { id: "bettertls::nameconstraints::tc4599", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14734, 14735], leaf: 14733 }, + Case { id: "bettertls::nameconstraints::tc4600", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14737, 14738], leaf: 14736 }, + Case { id: "bettertls::nameconstraints::tc4601", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14740, 14741], leaf: 14739 }, + Case { id: "bettertls::nameconstraints::tc4602", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14743, 14744], leaf: 14742 }, + Case { id: "bettertls::nameconstraints::tc4603", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14746, 14747], leaf: 14745 }, + Case { id: "bettertls::nameconstraints::tc4604", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14749, 14750], leaf: 14748 }, + Case { id: "bettertls::nameconstraints::tc4605", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14752, 14753], leaf: 14751 }, + Case { id: "bettertls::nameconstraints::tc4606", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14755, 14756], leaf: 14754 }, + Case { id: "bettertls::nameconstraints::tc4607", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14758, 14759], leaf: 14757 }, + Case { id: "bettertls::nameconstraints::tc4608", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14761, 14762], leaf: 14760 }, + Case { id: "bettertls::nameconstraints::tc4609", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14764, 14765], leaf: 14763 }, + Case { id: "bettertls::nameconstraints::tc4610", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14767, 14768], leaf: 14766 }, + Case { id: "bettertls::nameconstraints::tc4611", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14770, 14771], leaf: 14769 }, + Case { id: "bettertls::nameconstraints::tc4612", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14773, 14774], leaf: 14772 }, + Case { id: "bettertls::nameconstraints::tc4613", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14776, 14777], leaf: 14775 }, + Case { id: "bettertls::nameconstraints::tc4614", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14779, 14780], leaf: 14778 }, + Case { id: "bettertls::nameconstraints::tc4615", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14782, 14783], leaf: 14781 }, + Case { id: "bettertls::nameconstraints::tc4616", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14785, 14786], leaf: 14784 }, + Case { id: "bettertls::nameconstraints::tc4617", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14788, 14789], leaf: 14787 }, + Case { id: "bettertls::nameconstraints::tc4618", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14791, 14792], leaf: 14790 }, + Case { id: "bettertls::nameconstraints::tc4619", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14794, 14795], leaf: 14793 }, + Case { id: "bettertls::nameconstraints::tc4620", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14797, 14798], leaf: 14796 }, + Case { id: "bettertls::nameconstraints::tc4621", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14800, 14801], leaf: 14799 }, + Case { id: "bettertls::nameconstraints::tc4622", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14803, 14804], leaf: 14802 }, + Case { id: "bettertls::nameconstraints::tc4623", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14806, 14807], leaf: 14805 }, + Case { id: "bettertls::nameconstraints::tc4624", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14809, 14810], leaf: 14808 }, + Case { id: "bettertls::nameconstraints::tc4625", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14812, 14813], leaf: 14811 }, + Case { id: "bettertls::nameconstraints::tc4626", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14815, 14816], leaf: 14814 }, + Case { id: "bettertls::nameconstraints::tc4627", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14818, 14819], leaf: 14817 }, + Case { id: "bettertls::nameconstraints::tc4628", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14821, 14822], leaf: 14820 }, + Case { id: "bettertls::nameconstraints::tc4629", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14824, 14825], leaf: 14823 }, + Case { id: "bettertls::nameconstraints::tc4630", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14827, 14828], leaf: 14826 }, + Case { id: "bettertls::nameconstraints::tc4631", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14830, 14831], leaf: 14829 }, + Case { id: "bettertls::nameconstraints::tc4632", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14833, 14834], leaf: 14832 }, + Case { id: "bettertls::nameconstraints::tc4633", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14836, 14837], leaf: 14835 }, + Case { id: "bettertls::nameconstraints::tc4634", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14839, 14840], leaf: 14838 }, + Case { id: "bettertls::nameconstraints::tc4635", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14842, 14843], leaf: 14841 }, + Case { id: "bettertls::nameconstraints::tc4636", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14845, 14846], leaf: 14844 }, + Case { id: "bettertls::nameconstraints::tc4637", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14848, 14849], leaf: 14847 }, + Case { id: "bettertls::nameconstraints::tc4638", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14851, 14852], leaf: 14850 }, + Case { id: "bettertls::nameconstraints::tc4639", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14854, 14855], leaf: 14853 }, + Case { id: "bettertls::nameconstraints::tc4640", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14857, 14858], leaf: 14856 }, + Case { id: "bettertls::nameconstraints::tc4641", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14860, 14861], leaf: 14859 }, + Case { id: "bettertls::nameconstraints::tc4642", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14863, 14864], leaf: 14862 }, + Case { id: "bettertls::nameconstraints::tc4643", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14866, 14867], leaf: 14865 }, + Case { id: "bettertls::nameconstraints::tc4644", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14869, 14870], leaf: 14868 }, + Case { id: "bettertls::nameconstraints::tc4645", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14872, 14873], leaf: 14871 }, + Case { id: "bettertls::nameconstraints::tc4646", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14875, 14876], leaf: 14874 }, + Case { id: "bettertls::nameconstraints::tc4647", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14878, 14879], leaf: 14877 }, + Case { id: "bettertls::nameconstraints::tc4648", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14881, 14882], leaf: 14880 }, + Case { id: "bettertls::nameconstraints::tc4649", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14884, 14885], leaf: 14883 }, + Case { id: "bettertls::nameconstraints::tc4650", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14887, 14888], leaf: 14886 }, + Case { id: "bettertls::nameconstraints::tc4651", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14890, 14891], leaf: 14889 }, + Case { id: "bettertls::nameconstraints::tc4652", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14893, 14894], leaf: 14892 }, + Case { id: "bettertls::nameconstraints::tc4653", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14896, 14897], leaf: 14895 }, + Case { id: "bettertls::nameconstraints::tc4654", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14899, 14900], leaf: 14898 }, + Case { id: "bettertls::nameconstraints::tc4655", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14902, 14903], leaf: 14901 }, + Case { id: "bettertls::nameconstraints::tc4656", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14905, 14906], leaf: 14904 }, + Case { id: "bettertls::nameconstraints::tc4657", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14908, 14909], leaf: 14907 }, + Case { id: "bettertls::nameconstraints::tc4658", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14911, 14912], leaf: 14910 }, + Case { id: "bettertls::nameconstraints::tc4659", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14914, 14915], leaf: 14913 }, + Case { id: "bettertls::nameconstraints::tc4660", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14917, 14918], leaf: 14916 }, + Case { id: "bettertls::nameconstraints::tc4661", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14920, 14921], leaf: 14919 }, + Case { id: "bettertls::nameconstraints::tc4662", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14923, 14924], leaf: 14922 }, + Case { id: "bettertls::nameconstraints::tc4663", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14926, 14927], leaf: 14925 }, + Case { id: "bettertls::nameconstraints::tc4664", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14929, 14930], leaf: 14928 }, + Case { id: "bettertls::nameconstraints::tc4665", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14932, 14933], leaf: 14931 }, + Case { id: "bettertls::nameconstraints::tc4666", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14935, 14936], leaf: 14934 }, + Case { id: "bettertls::nameconstraints::tc4667", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14938, 14939], leaf: 14937 }, + Case { id: "bettertls::nameconstraints::tc4668", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14941, 14942], leaf: 14940 }, + Case { id: "bettertls::nameconstraints::tc4669", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14944, 14945], leaf: 14943 }, + Case { id: "bettertls::nameconstraints::tc4670", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14947, 14948], leaf: 14946 }, + Case { id: "bettertls::nameconstraints::tc4671", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14950, 14951], leaf: 14949 }, + Case { id: "bettertls::nameconstraints::tc4672", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14953, 14954], leaf: 14952 }, + Case { id: "bettertls::nameconstraints::tc4673", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14956, 14957], leaf: 14955 }, + Case { id: "bettertls::nameconstraints::tc4674", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14959, 14960], leaf: 14958 }, + Case { id: "bettertls::nameconstraints::tc4675", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14962, 14963], leaf: 14961 }, + Case { id: "bettertls::nameconstraints::tc4676", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14965, 14966], leaf: 14964 }, + Case { id: "bettertls::nameconstraints::tc4677", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14968, 14969], leaf: 14967 }, + Case { id: "bettertls::nameconstraints::tc4678", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14971, 14972], leaf: 14970 }, + Case { id: "bettertls::nameconstraints::tc4679", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14974, 14975], leaf: 14973 }, + Case { id: "bettertls::nameconstraints::tc4680", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14977, 14978], leaf: 14976 }, + Case { id: "bettertls::nameconstraints::tc4681", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14980, 14981], leaf: 14979 }, + Case { id: "bettertls::nameconstraints::tc4682", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14983, 14984], leaf: 14982 }, + Case { id: "bettertls::nameconstraints::tc4683", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14986, 14987], leaf: 14985 }, + Case { id: "bettertls::nameconstraints::tc4684", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14989, 14990], leaf: 14988 }, + Case { id: "bettertls::nameconstraints::tc4685", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14992, 14993], leaf: 14991 }, + Case { id: "bettertls::nameconstraints::tc4686", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14995, 14996], leaf: 14994 }, + Case { id: "bettertls::nameconstraints::tc4687", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[14998, 14999], leaf: 14997 }, + Case { id: "bettertls::nameconstraints::tc4688", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15001, 15002], leaf: 15000 }, + Case { id: "bettertls::nameconstraints::tc4689", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15004, 15005], leaf: 15003 }, + Case { id: "bettertls::nameconstraints::tc4690", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15007, 15008], leaf: 15006 }, + Case { id: "bettertls::nameconstraints::tc4691", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15010, 15011], leaf: 15009 }, + Case { id: "bettertls::nameconstraints::tc4692", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15013, 15014], leaf: 15012 }, + Case { id: "bettertls::nameconstraints::tc4693", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15016, 15017], leaf: 15015 }, + Case { id: "bettertls::nameconstraints::tc4694", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15019, 15020], leaf: 15018 }, + Case { id: "bettertls::nameconstraints::tc4695", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15022, 15023], leaf: 15021 }, + Case { id: "bettertls::nameconstraints::tc4696", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15025, 15026], leaf: 15024 }, + Case { id: "bettertls::nameconstraints::tc4697", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15028, 15029], leaf: 15027 }, + Case { id: "bettertls::nameconstraints::tc4698", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15031, 15032], leaf: 15030 }, + Case { id: "bettertls::nameconstraints::tc4699", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15034, 15035], leaf: 15033 }, + Case { id: "bettertls::nameconstraints::tc4700", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15037, 15038], leaf: 15036 }, + Case { id: "bettertls::nameconstraints::tc4701", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15040, 15041], leaf: 15039 }, + Case { id: "bettertls::nameconstraints::tc4702", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15043, 15044], leaf: 15042 }, + Case { id: "bettertls::nameconstraints::tc4703", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15046, 15047], leaf: 15045 }, + Case { id: "bettertls::nameconstraints::tc4704", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15049, 15050], leaf: 15048 }, + Case { id: "bettertls::nameconstraints::tc4705", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15052, 15053], leaf: 15051 }, + Case { id: "bettertls::nameconstraints::tc4706", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15055, 15056], leaf: 15054 }, + Case { id: "bettertls::nameconstraints::tc4707", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15058, 15059], leaf: 15057 }, + Case { id: "bettertls::nameconstraints::tc4708", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15061, 15062], leaf: 15060 }, + Case { id: "bettertls::nameconstraints::tc4709", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15064, 15065], leaf: 15063 }, + Case { id: "bettertls::nameconstraints::tc4710", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15067, 15068], leaf: 15066 }, + Case { id: "bettertls::nameconstraints::tc4711", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:52+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15070, 15071], leaf: 15069 }, + Case { id: "bettertls::nameconstraints::tc4712", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15073, 15074], leaf: 15072 }, + Case { id: "bettertls::nameconstraints::tc4713", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15076, 15077], leaf: 15075 }, + Case { id: "bettertls::nameconstraints::tc4714", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15079, 15080], leaf: 15078 }, + Case { id: "bettertls::nameconstraints::tc4715", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15082, 15083], leaf: 15081 }, + Case { id: "bettertls::nameconstraints::tc4716", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15085, 15086], leaf: 15084 }, + Case { id: "bettertls::nameconstraints::tc4717", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15088, 15089], leaf: 15087 }, + Case { id: "bettertls::nameconstraints::tc4718", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15091, 15092], leaf: 15090 }, + Case { id: "bettertls::nameconstraints::tc4719", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15094, 15095], leaf: 15093 }, + Case { id: "bettertls::nameconstraints::tc4720", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15097, 15098], leaf: 15096 }, + Case { id: "bettertls::nameconstraints::tc4721", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15100, 15101], leaf: 15099 }, + Case { id: "bettertls::nameconstraints::tc4722", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15103, 15104], leaf: 15102 }, + Case { id: "bettertls::nameconstraints::tc4723", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15106, 15107], leaf: 15105 }, + Case { id: "bettertls::nameconstraints::tc4724", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15109, 15110], leaf: 15108 }, + Case { id: "bettertls::nameconstraints::tc4725", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15112, 15113], leaf: 15111 }, + Case { id: "bettertls::nameconstraints::tc4726", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15115, 15116], leaf: 15114 }, + Case { id: "bettertls::nameconstraints::tc4727", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15118, 15119], leaf: 15117 }, + Case { id: "bettertls::nameconstraints::tc4728", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15121, 15122], leaf: 15120 }, + Case { id: "bettertls::nameconstraints::tc4729", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15124, 15125], leaf: 15123 }, + Case { id: "bettertls::nameconstraints::tc4730", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15127, 15128], leaf: 15126 }, + Case { id: "bettertls::nameconstraints::tc4731", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15130, 15131], leaf: 15129 }, + Case { id: "bettertls::nameconstraints::tc4732", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15133, 15134], leaf: 15132 }, + Case { id: "bettertls::nameconstraints::tc4733", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15136, 15137], leaf: 15135 }, + Case { id: "bettertls::nameconstraints::tc4734", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15139, 15140], leaf: 15138 }, + Case { id: "bettertls::nameconstraints::tc4735", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15142, 15143], leaf: 15141 }, + Case { id: "bettertls::nameconstraints::tc4736", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15145, 15146], leaf: 15144 }, + Case { id: "bettertls::nameconstraints::tc4737", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15148, 15149], leaf: 15147 }, + Case { id: "bettertls::nameconstraints::tc4738", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15151, 15152], leaf: 15150 }, + Case { id: "bettertls::nameconstraints::tc4739", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15154, 15155], leaf: 15153 }, + Case { id: "bettertls::nameconstraints::tc4740", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15157, 15158], leaf: 15156 }, + Case { id: "bettertls::nameconstraints::tc4741", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15160, 15161], leaf: 15159 }, + Case { id: "bettertls::nameconstraints::tc4742", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15163, 15164], leaf: 15162 }, + Case { id: "bettertls::nameconstraints::tc4743", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15166, 15167], leaf: 15165 }, + Case { id: "bettertls::nameconstraints::tc4744", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15169, 15170], leaf: 15168 }, + Case { id: "bettertls::nameconstraints::tc4745", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15172, 15173], leaf: 15171 }, + Case { id: "bettertls::nameconstraints::tc4746", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15175, 15176], leaf: 15174 }, + Case { id: "bettertls::nameconstraints::tc4747", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15178, 15179], leaf: 15177 }, + Case { id: "bettertls::nameconstraints::tc4748", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15181, 15182], leaf: 15180 }, + Case { id: "bettertls::nameconstraints::tc4749", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15184, 15185], leaf: 15183 }, + Case { id: "bettertls::nameconstraints::tc4750", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15187, 15188], leaf: 15186 }, + Case { id: "bettertls::nameconstraints::tc4751", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15190, 15191], leaf: 15189 }, + Case { id: "bettertls::nameconstraints::tc4752", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15193, 15194], leaf: 15192 }, + Case { id: "bettertls::nameconstraints::tc4753", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15196, 15197], leaf: 15195 }, + Case { id: "bettertls::nameconstraints::tc4754", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15199, 15200], leaf: 15198 }, + Case { id: "bettertls::nameconstraints::tc4755", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15202, 15203], leaf: 15201 }, + Case { id: "bettertls::nameconstraints::tc4756", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15205, 15206], leaf: 15204 }, + Case { id: "bettertls::nameconstraints::tc4757", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15208, 15209], leaf: 15207 }, + Case { id: "bettertls::nameconstraints::tc4758", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15211, 15212], leaf: 15210 }, + Case { id: "bettertls::nameconstraints::tc4759", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15214, 15215], leaf: 15213 }, + Case { id: "bettertls::nameconstraints::tc4760", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15217, 15218], leaf: 15216 }, + Case { id: "bettertls::nameconstraints::tc4761", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15220, 15221], leaf: 15219 }, + Case { id: "bettertls::nameconstraints::tc4762", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15223, 15224], leaf: 15222 }, + Case { id: "bettertls::nameconstraints::tc4763", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15226, 15227], leaf: 15225 }, + Case { id: "bettertls::nameconstraints::tc4764", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15229, 15230], leaf: 15228 }, + Case { id: "bettertls::nameconstraints::tc4765", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15232, 15233], leaf: 15231 }, + Case { id: "bettertls::nameconstraints::tc4766", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15235, 15236], leaf: 15234 }, + Case { id: "bettertls::nameconstraints::tc4767", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15238, 15239], leaf: 15237 }, + Case { id: "bettertls::nameconstraints::tc4768", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15241, 15242], leaf: 15240 }, + Case { id: "bettertls::nameconstraints::tc4769", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15244, 15245], leaf: 15243 }, + Case { id: "bettertls::nameconstraints::tc4770", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15247, 15248], leaf: 15246 }, + Case { id: "bettertls::nameconstraints::tc4771", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15250, 15251], leaf: 15249 }, + Case { id: "bettertls::nameconstraints::tc4772", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15253, 15254], leaf: 15252 }, + Case { id: "bettertls::nameconstraints::tc4773", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15256, 15257], leaf: 15255 }, + Case { id: "bettertls::nameconstraints::tc4774", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15259, 15260], leaf: 15258 }, + Case { id: "bettertls::nameconstraints::tc4775", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15262, 15263], leaf: 15261 }, + Case { id: "bettertls::nameconstraints::tc4776", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15265, 15266], leaf: 15264 }, + Case { id: "bettertls::nameconstraints::tc4777", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15268, 15269], leaf: 15267 }, + Case { id: "bettertls::nameconstraints::tc4778", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15271, 15272], leaf: 15270 }, + Case { id: "bettertls::nameconstraints::tc4779", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15274, 15275], leaf: 15273 }, + Case { id: "bettertls::nameconstraints::tc4780", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15277, 15278], leaf: 15276 }, + Case { id: "bettertls::nameconstraints::tc4781", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15280, 15281], leaf: 15279 }, + Case { id: "bettertls::nameconstraints::tc4782", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15283, 15284], leaf: 15282 }, + Case { id: "bettertls::nameconstraints::tc4783", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15286, 15287], leaf: 15285 }, + Case { id: "bettertls::nameconstraints::tc4784", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15289, 15290], leaf: 15288 }, + Case { id: "bettertls::nameconstraints::tc4785", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15292, 15293], leaf: 15291 }, + Case { id: "bettertls::nameconstraints::tc4786", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15295, 15296], leaf: 15294 }, + Case { id: "bettertls::nameconstraints::tc4787", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15298, 15299], leaf: 15297 }, + Case { id: "bettertls::nameconstraints::tc4788", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15301, 15302], leaf: 15300 }, + Case { id: "bettertls::nameconstraints::tc4789", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15304, 15305], leaf: 15303 }, + Case { id: "bettertls::nameconstraints::tc4790", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15307, 15308], leaf: 15306 }, + Case { id: "bettertls::nameconstraints::tc4791", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15310, 15311], leaf: 15309 }, + Case { id: "bettertls::nameconstraints::tc4792", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15313, 15314], leaf: 15312 }, + Case { id: "bettertls::nameconstraints::tc4793", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15316, 15317], leaf: 15315 }, + Case { id: "bettertls::nameconstraints::tc4794", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15319, 15320], leaf: 15318 }, + Case { id: "bettertls::nameconstraints::tc4795", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15322, 15323], leaf: 15321 }, + Case { id: "bettertls::nameconstraints::tc4796", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15325, 15326], leaf: 15324 }, + Case { id: "bettertls::nameconstraints::tc4797", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15328, 15329], leaf: 15327 }, + Case { id: "bettertls::nameconstraints::tc4798", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15331, 15332], leaf: 15330 }, + Case { id: "bettertls::nameconstraints::tc4799", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15334, 15335], leaf: 15333 }, + Case { id: "bettertls::nameconstraints::tc4800", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15337, 15338], leaf: 15336 }, + Case { id: "bettertls::nameconstraints::tc4801", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15340, 15341], leaf: 15339 }, + Case { id: "bettertls::nameconstraints::tc4802", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15343, 15344], leaf: 15342 }, + Case { id: "bettertls::nameconstraints::tc4803", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15346, 15347], leaf: 15345 }, + Case { id: "bettertls::nameconstraints::tc4804", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15349, 15350], leaf: 15348 }, + Case { id: "bettertls::nameconstraints::tc4805", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15352, 15353], leaf: 15351 }, + Case { id: "bettertls::nameconstraints::tc4806", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15355, 15356], leaf: 15354 }, + Case { id: "bettertls::nameconstraints::tc4807", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15358, 15359], leaf: 15357 }, + Case { id: "bettertls::nameconstraints::tc4808", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15361, 15362], leaf: 15360 }, + Case { id: "bettertls::nameconstraints::tc4809", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15364, 15365], leaf: 15363 }, + Case { id: "bettertls::nameconstraints::tc4810", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15367, 15368], leaf: 15366 }, + Case { id: "bettertls::nameconstraints::tc4811", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15370, 15371], leaf: 15369 }, + Case { id: "bettertls::nameconstraints::tc4812", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15373, 15374], leaf: 15372 }, + Case { id: "bettertls::nameconstraints::tc4813", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15376, 15377], leaf: 15375 }, + Case { id: "bettertls::nameconstraints::tc4814", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15379, 15380], leaf: 15378 }, + Case { id: "bettertls::nameconstraints::tc4815", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15382, 15383], leaf: 15381 }, + Case { id: "bettertls::nameconstraints::tc4816", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15385, 15386], leaf: 15384 }, + Case { id: "bettertls::nameconstraints::tc4817", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15388, 15389], leaf: 15387 }, + Case { id: "bettertls::nameconstraints::tc4818", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15391, 15392], leaf: 15390 }, + Case { id: "bettertls::nameconstraints::tc4819", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15394, 15395], leaf: 15393 }, + Case { id: "bettertls::nameconstraints::tc4820", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15397, 15398], leaf: 15396 }, + Case { id: "bettertls::nameconstraints::tc4821", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15400, 15401], leaf: 15399 }, + Case { id: "bettertls::nameconstraints::tc4822", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15403, 15404], leaf: 15402 }, + Case { id: "bettertls::nameconstraints::tc4823", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15406, 15407], leaf: 15405 }, + Case { id: "bettertls::nameconstraints::tc4824", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15409, 15410], leaf: 15408 }, + Case { id: "bettertls::nameconstraints::tc4825", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15412, 15413], leaf: 15411 }, + Case { id: "bettertls::nameconstraints::tc4826", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15415, 15416], leaf: 15414 }, + Case { id: "bettertls::nameconstraints::tc4827", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15418, 15419], leaf: 15417 }, + Case { id: "bettertls::nameconstraints::tc4828", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15421, 15422], leaf: 15420 }, + Case { id: "bettertls::nameconstraints::tc4829", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15424, 15425], leaf: 15423 }, + Case { id: "bettertls::nameconstraints::tc4830", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15427, 15428], leaf: 15426 }, + Case { id: "bettertls::nameconstraints::tc4831", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15430, 15431], leaf: 15429 }, + Case { id: "bettertls::nameconstraints::tc4832", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15433, 15434], leaf: 15432 }, + Case { id: "bettertls::nameconstraints::tc4833", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15436, 15437], leaf: 15435 }, + Case { id: "bettertls::nameconstraints::tc4834", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15439, 15440], leaf: 15438 }, + Case { id: "bettertls::nameconstraints::tc4835", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15442, 15443], leaf: 15441 }, + Case { id: "bettertls::nameconstraints::tc4836", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15445, 15446], leaf: 15444 }, + Case { id: "bettertls::nameconstraints::tc4837", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15448, 15449], leaf: 15447 }, + Case { id: "bettertls::nameconstraints::tc4838", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15451, 15452], leaf: 15450 }, + Case { id: "bettertls::nameconstraints::tc4839", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15454, 15455], leaf: 15453 }, + Case { id: "bettertls::nameconstraints::tc4840", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15457, 15458], leaf: 15456 }, + Case { id: "bettertls::nameconstraints::tc4841", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15460, 15461], leaf: 15459 }, + Case { id: "bettertls::nameconstraints::tc4842", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15463, 15464], leaf: 15462 }, + Case { id: "bettertls::nameconstraints::tc4843", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15466, 15467], leaf: 15465 }, + Case { id: "bettertls::nameconstraints::tc4844", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15469, 15470], leaf: 15468 }, + Case { id: "bettertls::nameconstraints::tc4845", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15472, 15473], leaf: 15471 }, + Case { id: "bettertls::nameconstraints::tc4846", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15475, 15476], leaf: 15474 }, + Case { id: "bettertls::nameconstraints::tc4847", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15478, 15479], leaf: 15477 }, + Case { id: "bettertls::nameconstraints::tc4848", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15481, 15482], leaf: 15480 }, + Case { id: "bettertls::nameconstraints::tc4849", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15484, 15485], leaf: 15483 }, + Case { id: "bettertls::nameconstraints::tc4850", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15487, 15488], leaf: 15486 }, + Case { id: "bettertls::nameconstraints::tc4851", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15490, 15491], leaf: 15489 }, + Case { id: "bettertls::nameconstraints::tc4852", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15493, 15494], leaf: 15492 }, + Case { id: "bettertls::nameconstraints::tc4853", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15496, 15497], leaf: 15495 }, + Case { id: "bettertls::nameconstraints::tc4854", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15499, 15500], leaf: 15498 }, + Case { id: "bettertls::nameconstraints::tc4855", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15502, 15503], leaf: 15501 }, + Case { id: "bettertls::nameconstraints::tc4856", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15505, 15506], leaf: 15504 }, + Case { id: "bettertls::nameconstraints::tc4857", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15508, 15509], leaf: 15507 }, + Case { id: "bettertls::nameconstraints::tc4858", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15511, 15512], leaf: 15510 }, + Case { id: "bettertls::nameconstraints::tc4859", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15514, 15515], leaf: 15513 }, + Case { id: "bettertls::nameconstraints::tc4860", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15517, 15518], leaf: 15516 }, + Case { id: "bettertls::nameconstraints::tc4861", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15520, 15521], leaf: 15519 }, + Case { id: "bettertls::nameconstraints::tc4862", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15523, 15524], leaf: 15522 }, + Case { id: "bettertls::nameconstraints::tc4863", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15526, 15527], leaf: 15525 }, + Case { id: "bettertls::nameconstraints::tc4864", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15529, 15530], leaf: 15528 }, + Case { id: "bettertls::nameconstraints::tc4865", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15532, 15533], leaf: 15531 }, + Case { id: "bettertls::nameconstraints::tc4866", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15535, 15536], leaf: 15534 }, + Case { id: "bettertls::nameconstraints::tc4867", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15538, 15539], leaf: 15537 }, + Case { id: "bettertls::nameconstraints::tc4868", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15541, 15542], leaf: 15540 }, + Case { id: "bettertls::nameconstraints::tc4869", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15544, 15545], leaf: 15543 }, + Case { id: "bettertls::nameconstraints::tc4870", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15547, 15548], leaf: 15546 }, + Case { id: "bettertls::nameconstraints::tc4871", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15550, 15551], leaf: 15549 }, + Case { id: "bettertls::nameconstraints::tc4872", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15553, 15554], leaf: 15552 }, + Case { id: "bettertls::nameconstraints::tc4873", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15556, 15557], leaf: 15555 }, + Case { id: "bettertls::nameconstraints::tc4874", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15559, 15560], leaf: 15558 }, + Case { id: "bettertls::nameconstraints::tc4875", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15562, 15563], leaf: 15561 }, + Case { id: "bettertls::nameconstraints::tc4876", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15565, 15566], leaf: 15564 }, + Case { id: "bettertls::nameconstraints::tc4877", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15568, 15569], leaf: 15567 }, + Case { id: "bettertls::nameconstraints::tc4878", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15571, 15572], leaf: 15570 }, + Case { id: "bettertls::nameconstraints::tc4879", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15574, 15575], leaf: 15573 }, + Case { id: "bettertls::nameconstraints::tc4880", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15577, 15578], leaf: 15576 }, + Case { id: "bettertls::nameconstraints::tc4881", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15580, 15581], leaf: 15579 }, + Case { id: "bettertls::nameconstraints::tc4882", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15583, 15584], leaf: 15582 }, + Case { id: "bettertls::nameconstraints::tc4883", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15586, 15587], leaf: 15585 }, + Case { id: "bettertls::nameconstraints::tc4884", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15589, 15590], leaf: 15588 }, + Case { id: "bettertls::nameconstraints::tc4885", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15592, 15593], leaf: 15591 }, + Case { id: "bettertls::nameconstraints::tc4886", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15595, 15596], leaf: 15594 }, + Case { id: "bettertls::nameconstraints::tc4887", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15598, 15599], leaf: 15597 }, + Case { id: "bettertls::nameconstraints::tc4888", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15601, 15602], leaf: 15600 }, + Case { id: "bettertls::nameconstraints::tc4889", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15604, 15605], leaf: 15603 }, + Case { id: "bettertls::nameconstraints::tc4890", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15607, 15608], leaf: 15606 }, + Case { id: "bettertls::nameconstraints::tc4891", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15610, 15611], leaf: 15609 }, + Case { id: "bettertls::nameconstraints::tc4892", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15613, 15614], leaf: 15612 }, + Case { id: "bettertls::nameconstraints::tc4893", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15616, 15617], leaf: 15615 }, + Case { id: "bettertls::nameconstraints::tc4894", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15619, 15620], leaf: 15618 }, + Case { id: "bettertls::nameconstraints::tc4895", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15622, 15623], leaf: 15621 }, + Case { id: "bettertls::nameconstraints::tc4896", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15625, 15626], leaf: 15624 }, + Case { id: "bettertls::nameconstraints::tc4897", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15628, 15629], leaf: 15627 }, + Case { id: "bettertls::nameconstraints::tc4898", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15631, 15632], leaf: 15630 }, + Case { id: "bettertls::nameconstraints::tc4899", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15634, 15635], leaf: 15633 }, + Case { id: "bettertls::nameconstraints::tc4900", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15637, 15638], leaf: 15636 }, + Case { id: "bettertls::nameconstraints::tc4901", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15640, 15641], leaf: 15639 }, + Case { id: "bettertls::nameconstraints::tc4902", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15643, 15644], leaf: 15642 }, + Case { id: "bettertls::nameconstraints::tc4903", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15646, 15647], leaf: 15645 }, + Case { id: "bettertls::nameconstraints::tc4904", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15649, 15650], leaf: 15648 }, + Case { id: "bettertls::nameconstraints::tc4905", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15652, 15653], leaf: 15651 }, + Case { id: "bettertls::nameconstraints::tc4906", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15655, 15656], leaf: 15654 }, + Case { id: "bettertls::nameconstraints::tc4907", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15658, 15659], leaf: 15657 }, + Case { id: "bettertls::nameconstraints::tc4908", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15661, 15662], leaf: 15660 }, + Case { id: "bettertls::nameconstraints::tc4909", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15664, 15665], leaf: 15663 }, + Case { id: "bettertls::nameconstraints::tc4910", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15667, 15668], leaf: 15666 }, + Case { id: "bettertls::nameconstraints::tc4911", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15670, 15671], leaf: 15669 }, + Case { id: "bettertls::nameconstraints::tc4912", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15673, 15674], leaf: 15672 }, + Case { id: "bettertls::nameconstraints::tc4913", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15676, 15677], leaf: 15675 }, + Case { id: "bettertls::nameconstraints::tc4914", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15679, 15680], leaf: 15678 }, + Case { id: "bettertls::nameconstraints::tc4915", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15682, 15683], leaf: 15681 }, + Case { id: "bettertls::nameconstraints::tc4916", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15685, 15686], leaf: 15684 }, + Case { id: "bettertls::nameconstraints::tc4917", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15688, 15689], leaf: 15687 }, + Case { id: "bettertls::nameconstraints::tc4918", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15691, 15692], leaf: 15690 }, + Case { id: "bettertls::nameconstraints::tc4919", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15694, 15695], leaf: 15693 }, + Case { id: "bettertls::nameconstraints::tc4920", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15697, 15698], leaf: 15696 }, + Case { id: "bettertls::nameconstraints::tc4921", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15700, 15701], leaf: 15699 }, + Case { id: "bettertls::nameconstraints::tc4922", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15703, 15704], leaf: 15702 }, + Case { id: "bettertls::nameconstraints::tc4923", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15706, 15707], leaf: 15705 }, + Case { id: "bettertls::nameconstraints::tc4924", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15709, 15710], leaf: 15708 }, + Case { id: "bettertls::nameconstraints::tc4925", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15712, 15713], leaf: 15711 }, + Case { id: "bettertls::nameconstraints::tc4926", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15715, 15716], leaf: 15714 }, + Case { id: "bettertls::nameconstraints::tc4927", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15718, 15719], leaf: 15717 }, + Case { id: "bettertls::nameconstraints::tc4928", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15721, 15722], leaf: 15720 }, + Case { id: "bettertls::nameconstraints::tc4929", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15724, 15725], leaf: 15723 }, + Case { id: "bettertls::nameconstraints::tc4930", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15727, 15728], leaf: 15726 }, + Case { id: "bettertls::nameconstraints::tc4931", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15730, 15731], leaf: 15729 }, + Case { id: "bettertls::nameconstraints::tc4932", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15733, 15734], leaf: 15732 }, + Case { id: "bettertls::nameconstraints::tc4933", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15736, 15737], leaf: 15735 }, + Case { id: "bettertls::nameconstraints::tc4934", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15739, 15740], leaf: 15738 }, + Case { id: "bettertls::nameconstraints::tc4935", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15742, 15743], leaf: 15741 }, + Case { id: "bettertls::nameconstraints::tc4936", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15745, 15746], leaf: 15744 }, + Case { id: "bettertls::nameconstraints::tc4937", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15748, 15749], leaf: 15747 }, + Case { id: "bettertls::nameconstraints::tc4938", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15751, 15752], leaf: 15750 }, + Case { id: "bettertls::nameconstraints::tc4939", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15754, 15755], leaf: 15753 }, + Case { id: "bettertls::nameconstraints::tc4940", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15757, 15758], leaf: 15756 }, + Case { id: "bettertls::nameconstraints::tc4941", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15760, 15761], leaf: 15759 }, + Case { id: "bettertls::nameconstraints::tc4942", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15763, 15764], leaf: 15762 }, + Case { id: "bettertls::nameconstraints::tc4943", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15766, 15767], leaf: 15765 }, + Case { id: "bettertls::nameconstraints::tc4944", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15769, 15770], leaf: 15768 }, + Case { id: "bettertls::nameconstraints::tc4945", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15772, 15773], leaf: 15771 }, + Case { id: "bettertls::nameconstraints::tc4946", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15775, 15776], leaf: 15774 }, + Case { id: "bettertls::nameconstraints::tc4947", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15778, 15779], leaf: 15777 }, + Case { id: "bettertls::nameconstraints::tc4948", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15781, 15782], leaf: 15780 }, + Case { id: "bettertls::nameconstraints::tc4949", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15784, 15785], leaf: 15783 }, + Case { id: "bettertls::nameconstraints::tc4950", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15787, 15788], leaf: 15786 }, + Case { id: "bettertls::nameconstraints::tc4951", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15790, 15791], leaf: 15789 }, + Case { id: "bettertls::nameconstraints::tc4952", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15793, 15794], leaf: 15792 }, + Case { id: "bettertls::nameconstraints::tc4953", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15796, 15797], leaf: 15795 }, + Case { id: "bettertls::nameconstraints::tc4954", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15799, 15800], leaf: 15798 }, + Case { id: "bettertls::nameconstraints::tc4955", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15802, 15803], leaf: 15801 }, + Case { id: "bettertls::nameconstraints::tc4956", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15805, 15806], leaf: 15804 }, + Case { id: "bettertls::nameconstraints::tc4957", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15808, 15809], leaf: 15807 }, + Case { id: "bettertls::nameconstraints::tc4958", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15811, 15812], leaf: 15810 }, + Case { id: "bettertls::nameconstraints::tc4959", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15814, 15815], leaf: 15813 }, + Case { id: "bettertls::nameconstraints::tc4960", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15817, 15818], leaf: 15816 }, + Case { id: "bettertls::nameconstraints::tc4961", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15820, 15821], leaf: 15819 }, + Case { id: "bettertls::nameconstraints::tc4962", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15823, 15824], leaf: 15822 }, + Case { id: "bettertls::nameconstraints::tc4963", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15826, 15827], leaf: 15825 }, + Case { id: "bettertls::nameconstraints::tc4964", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15829, 15830], leaf: 15828 }, + Case { id: "bettertls::nameconstraints::tc4965", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15832, 15833], leaf: 15831 }, + Case { id: "bettertls::nameconstraints::tc4966", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15835, 15836], leaf: 15834 }, + Case { id: "bettertls::nameconstraints::tc4967", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15838, 15839], leaf: 15837 }, + Case { id: "bettertls::nameconstraints::tc4968", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15841, 15842], leaf: 15840 }, + Case { id: "bettertls::nameconstraints::tc4969", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15844, 15845], leaf: 15843 }, + Case { id: "bettertls::nameconstraints::tc4970", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15847, 15848], leaf: 15846 }, + Case { id: "bettertls::nameconstraints::tc4971", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15850, 15851], leaf: 15849 }, + Case { id: "bettertls::nameconstraints::tc4972", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15853, 15854], leaf: 15852 }, + Case { id: "bettertls::nameconstraints::tc4973", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15856, 15857], leaf: 15855 }, + Case { id: "bettertls::nameconstraints::tc4974", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15859, 15860], leaf: 15858 }, + Case { id: "bettertls::nameconstraints::tc4975", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15862, 15863], leaf: 15861 }, + Case { id: "bettertls::nameconstraints::tc4976", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15865, 15866], leaf: 15864 }, + Case { id: "bettertls::nameconstraints::tc4977", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15868, 15869], leaf: 15867 }, + Case { id: "bettertls::nameconstraints::tc4978", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15871, 15872], leaf: 15870 }, + Case { id: "bettertls::nameconstraints::tc4979", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15874, 15875], leaf: 15873 }, + Case { id: "bettertls::nameconstraints::tc4980", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15877, 15878], leaf: 15876 }, + Case { id: "bettertls::nameconstraints::tc4981", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15880, 15881], leaf: 15879 }, + Case { id: "bettertls::nameconstraints::tc4982", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15883, 15884], leaf: 15882 }, + Case { id: "bettertls::nameconstraints::tc4983", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15886, 15887], leaf: 15885 }, + Case { id: "bettertls::nameconstraints::tc4984", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15889, 15890], leaf: 15888 }, + Case { id: "bettertls::nameconstraints::tc4985", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15892, 15893], leaf: 15891 }, + Case { id: "bettertls::nameconstraints::tc4986", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15895, 15896], leaf: 15894 }, + Case { id: "bettertls::nameconstraints::tc4987", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15898, 15899], leaf: 15897 }, + Case { id: "bettertls::nameconstraints::tc4988", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15901, 15902], leaf: 15900 }, + Case { id: "bettertls::nameconstraints::tc4989", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15904, 15905], leaf: 15903 }, + Case { id: "bettertls::nameconstraints::tc4990", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15907, 15908], leaf: 15906 }, + Case { id: "bettertls::nameconstraints::tc4991", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15910, 15911], leaf: 15909 }, + Case { id: "bettertls::nameconstraints::tc4992", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15913, 15914], leaf: 15912 }, + Case { id: "bettertls::nameconstraints::tc4993", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15916, 15917], leaf: 15915 }, + Case { id: "bettertls::nameconstraints::tc4994", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15919, 15920], leaf: 15918 }, + Case { id: "bettertls::nameconstraints::tc4995", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15922, 15923], leaf: 15921 }, + Case { id: "bettertls::nameconstraints::tc4996", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15925, 15926], leaf: 15924 }, + Case { id: "bettertls::nameconstraints::tc4997", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15928, 15929], leaf: 15927 }, + Case { id: "bettertls::nameconstraints::tc4998", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15931, 15932], leaf: 15930 }, + Case { id: "bettertls::nameconstraints::tc4999", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15934, 15935], leaf: 15933 }, + Case { id: "bettertls::nameconstraints::tc5000", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15937, 15938], leaf: 15936 }, + Case { id: "bettertls::nameconstraints::tc5001", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15940, 15941], leaf: 15939 }, + Case { id: "bettertls::nameconstraints::tc5002", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15943, 15944], leaf: 15942 }, + Case { id: "bettertls::nameconstraints::tc5003", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15946, 15947], leaf: 15945 }, + Case { id: "bettertls::nameconstraints::tc5004", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15949, 15950], leaf: 15948 }, + Case { id: "bettertls::nameconstraints::tc5005", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15952, 15953], leaf: 15951 }, + Case { id: "bettertls::nameconstraints::tc5006", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15955, 15956], leaf: 15954 }, + Case { id: "bettertls::nameconstraints::tc5007", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15958, 15959], leaf: 15957 }, + Case { id: "bettertls::nameconstraints::tc5008", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15961, 15962], leaf: 15960 }, + Case { id: "bettertls::nameconstraints::tc5009", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15964, 15965], leaf: 15963 }, + Case { id: "bettertls::nameconstraints::tc5010", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15967, 15968], leaf: 15966 }, + Case { id: "bettertls::nameconstraints::tc5011", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15970, 15971], leaf: 15969 }, + Case { id: "bettertls::nameconstraints::tc5012", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15973, 15974], leaf: 15972 }, + Case { id: "bettertls::nameconstraints::tc5013", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15976, 15977], leaf: 15975 }, + Case { id: "bettertls::nameconstraints::tc5014", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15979, 15980], leaf: 15978 }, + Case { id: "bettertls::nameconstraints::tc5015", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15982, 15983], leaf: 15981 }, + Case { id: "bettertls::nameconstraints::tc5016", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15985, 15986], leaf: 15984 }, + Case { id: "bettertls::nameconstraints::tc5017", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15988, 15989], leaf: 15987 }, + Case { id: "bettertls::nameconstraints::tc5018", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15991, 15992], leaf: 15990 }, + Case { id: "bettertls::nameconstraints::tc5019", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15994, 15995], leaf: 15993 }, + Case { id: "bettertls::nameconstraints::tc5020", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[15997, 15998], leaf: 15996 }, + Case { id: "bettertls::nameconstraints::tc5021", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16000, 16001], leaf: 15999 }, + Case { id: "bettertls::nameconstraints::tc5022", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16003, 16004], leaf: 16002 }, + Case { id: "bettertls::nameconstraints::tc5023", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16006, 16007], leaf: 16005 }, + Case { id: "bettertls::nameconstraints::tc5024", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16009, 16010], leaf: 16008 }, + Case { id: "bettertls::nameconstraints::tc5025", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16012, 16013], leaf: 16011 }, + Case { id: "bettertls::nameconstraints::tc5026", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16015, 16016], leaf: 16014 }, + Case { id: "bettertls::nameconstraints::tc5027", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16018, 16019], leaf: 16017 }, + Case { id: "bettertls::nameconstraints::tc5028", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16021, 16022], leaf: 16020 }, + Case { id: "bettertls::nameconstraints::tc5029", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16024, 16025], leaf: 16023 }, + Case { id: "bettertls::nameconstraints::tc5030", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16027, 16028], leaf: 16026 }, + Case { id: "bettertls::nameconstraints::tc5031", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16030, 16031], leaf: 16029 }, + Case { id: "bettertls::nameconstraints::tc5032", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16033, 16034], leaf: 16032 }, + Case { id: "bettertls::nameconstraints::tc5033", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16036, 16037], leaf: 16035 }, + Case { id: "bettertls::nameconstraints::tc5034", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16039, 16040], leaf: 16038 }, + Case { id: "bettertls::nameconstraints::tc5035", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16042, 16043], leaf: 16041 }, + Case { id: "bettertls::nameconstraints::tc5036", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16045, 16046], leaf: 16044 }, + Case { id: "bettertls::nameconstraints::tc5037", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16048, 16049], leaf: 16047 }, + Case { id: "bettertls::nameconstraints::tc5038", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16051, 16052], leaf: 16050 }, + Case { id: "bettertls::nameconstraints::tc5039", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16054, 16055], leaf: 16053 }, + Case { id: "bettertls::nameconstraints::tc5040", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16057, 16058], leaf: 16056 }, + Case { id: "bettertls::nameconstraints::tc5041", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16060, 16061], leaf: 16059 }, + Case { id: "bettertls::nameconstraints::tc5042", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16063, 16064], leaf: 16062 }, + Case { id: "bettertls::nameconstraints::tc5043", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16066, 16067], leaf: 16065 }, + Case { id: "bettertls::nameconstraints::tc5044", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16069, 16070], leaf: 16068 }, + Case { id: "bettertls::nameconstraints::tc5045", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16072, 16073], leaf: 16071 }, + Case { id: "bettertls::nameconstraints::tc5046", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16075, 16076], leaf: 16074 }, + Case { id: "bettertls::nameconstraints::tc5047", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16078, 16079], leaf: 16077 }, + Case { id: "bettertls::nameconstraints::tc5048", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16081, 16082], leaf: 16080 }, + Case { id: "bettertls::nameconstraints::tc5049", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16084, 16085], leaf: 16083 }, + Case { id: "bettertls::nameconstraints::tc5050", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16087, 16088], leaf: 16086 }, + Case { id: "bettertls::nameconstraints::tc5051", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16090, 16091], leaf: 16089 }, + Case { id: "bettertls::nameconstraints::tc5052", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16093, 16094], leaf: 16092 }, + Case { id: "bettertls::nameconstraints::tc5053", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16096, 16097], leaf: 16095 }, + Case { id: "bettertls::nameconstraints::tc5054", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16099, 16100], leaf: 16098 }, + Case { id: "bettertls::nameconstraints::tc5055", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16102, 16103], leaf: 16101 }, + Case { id: "bettertls::nameconstraints::tc5056", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16105, 16106], leaf: 16104 }, + Case { id: "bettertls::nameconstraints::tc5057", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16108, 16109], leaf: 16107 }, + Case { id: "bettertls::nameconstraints::tc5058", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16111, 16112], leaf: 16110 }, + Case { id: "bettertls::nameconstraints::tc5059", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16114, 16115], leaf: 16113 }, + Case { id: "bettertls::nameconstraints::tc5060", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16117, 16118], leaf: 16116 }, + Case { id: "bettertls::nameconstraints::tc5061", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16120, 16121], leaf: 16119 }, + Case { id: "bettertls::nameconstraints::tc5062", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16123, 16124], leaf: 16122 }, + Case { id: "bettertls::nameconstraints::tc5063", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16126, 16127], leaf: 16125 }, + Case { id: "bettertls::nameconstraints::tc5064", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16129, 16130], leaf: 16128 }, + Case { id: "bettertls::nameconstraints::tc5065", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16132, 16133], leaf: 16131 }, + Case { id: "bettertls::nameconstraints::tc5066", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16135, 16136], leaf: 16134 }, + Case { id: "bettertls::nameconstraints::tc5067", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16138, 16139], leaf: 16137 }, + Case { id: "bettertls::nameconstraints::tc5068", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16141, 16142], leaf: 16140 }, + Case { id: "bettertls::nameconstraints::tc5069", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16144, 16145], leaf: 16143 }, + Case { id: "bettertls::nameconstraints::tc5070", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16147, 16148], leaf: 16146 }, + Case { id: "bettertls::nameconstraints::tc5071", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16150, 16151], leaf: 16149 }, + Case { id: "bettertls::nameconstraints::tc5072", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16153, 16154], leaf: 16152 }, + Case { id: "bettertls::nameconstraints::tc5073", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16156, 16157], leaf: 16155 }, + Case { id: "bettertls::nameconstraints::tc5074", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16159, 16160], leaf: 16158 }, + Case { id: "bettertls::nameconstraints::tc5075", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16162, 16163], leaf: 16161 }, + Case { id: "bettertls::nameconstraints::tc5076", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16165, 16166], leaf: 16164 }, + Case { id: "bettertls::nameconstraints::tc5077", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16168, 16169], leaf: 16167 }, + Case { id: "bettertls::nameconstraints::tc5078", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16171, 16172], leaf: 16170 }, + Case { id: "bettertls::nameconstraints::tc5079", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16174, 16175], leaf: 16173 }, + Case { id: "bettertls::nameconstraints::tc5080", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16177, 16178], leaf: 16176 }, + Case { id: "bettertls::nameconstraints::tc5081", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16180, 16181], leaf: 16179 }, + Case { id: "bettertls::nameconstraints::tc5082", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16183, 16184], leaf: 16182 }, + Case { id: "bettertls::nameconstraints::tc5083", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16186, 16187], leaf: 16185 }, + Case { id: "bettertls::nameconstraints::tc5084", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16189, 16190], leaf: 16188 }, + Case { id: "bettertls::nameconstraints::tc5085", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16192, 16193], leaf: 16191 }, + Case { id: "bettertls::nameconstraints::tc5086", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16195, 16196], leaf: 16194 }, + Case { id: "bettertls::nameconstraints::tc5087", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16198, 16199], leaf: 16197 }, + Case { id: "bettertls::nameconstraints::tc5088", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16201, 16202], leaf: 16200 }, + Case { id: "bettertls::nameconstraints::tc5089", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16204, 16205], leaf: 16203 }, + Case { id: "bettertls::nameconstraints::tc5090", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16207, 16208], leaf: 16206 }, + Case { id: "bettertls::nameconstraints::tc5091", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16210, 16211], leaf: 16209 }, + Case { id: "bettertls::nameconstraints::tc5092", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16213, 16214], leaf: 16212 }, + Case { id: "bettertls::nameconstraints::tc5093", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16216, 16217], leaf: 16215 }, + Case { id: "bettertls::nameconstraints::tc5094", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16219, 16220], leaf: 16218 }, + Case { id: "bettertls::nameconstraints::tc5095", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16222, 16223], leaf: 16221 }, + Case { id: "bettertls::nameconstraints::tc5096", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16225, 16226], leaf: 16224 }, + Case { id: "bettertls::nameconstraints::tc5097", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16228, 16229], leaf: 16227 }, + Case { id: "bettertls::nameconstraints::tc5098", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16231, 16232], leaf: 16230 }, + Case { id: "bettertls::nameconstraints::tc5099", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16234, 16235], leaf: 16233 }, + Case { id: "bettertls::nameconstraints::tc5100", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16237, 16238], leaf: 16236 }, + Case { id: "bettertls::nameconstraints::tc5101", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16240, 16241], leaf: 16239 }, + Case { id: "bettertls::nameconstraints::tc5102", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16243, 16244], leaf: 16242 }, + Case { id: "bettertls::nameconstraints::tc5103", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16246, 16247], leaf: 16245 }, + Case { id: "bettertls::nameconstraints::tc5104", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16249, 16250], leaf: 16248 }, + Case { id: "bettertls::nameconstraints::tc5105", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16252, 16253], leaf: 16251 }, + Case { id: "bettertls::nameconstraints::tc5106", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16255, 16256], leaf: 16254 }, + Case { id: "bettertls::nameconstraints::tc5107", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16258, 16259], leaf: 16257 }, + Case { id: "bettertls::nameconstraints::tc5108", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16261, 16262], leaf: 16260 }, + Case { id: "bettertls::nameconstraints::tc5109", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16264, 16265], leaf: 16263 }, + Case { id: "bettertls::nameconstraints::tc5110", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16267, 16268], leaf: 16266 }, + Case { id: "bettertls::nameconstraints::tc5111", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16270, 16271], leaf: 16269 }, + Case { id: "bettertls::nameconstraints::tc5112", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16273, 16274], leaf: 16272 }, + Case { id: "bettertls::nameconstraints::tc5113", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16276, 16277], leaf: 16275 }, + Case { id: "bettertls::nameconstraints::tc5114", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16279, 16280], leaf: 16278 }, + Case { id: "bettertls::nameconstraints::tc5115", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16282, 16283], leaf: 16281 }, + Case { id: "bettertls::nameconstraints::tc5116", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16285, 16286], leaf: 16284 }, + Case { id: "bettertls::nameconstraints::tc5117", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16288, 16289], leaf: 16287 }, + Case { id: "bettertls::nameconstraints::tc5118", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16291, 16292], leaf: 16290 }, + Case { id: "bettertls::nameconstraints::tc5119", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16294, 16295], leaf: 16293 }, + Case { id: "bettertls::nameconstraints::tc5120", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16297, 16298], leaf: 16296 }, + Case { id: "bettertls::nameconstraints::tc5121", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16300, 16301], leaf: 16299 }, + Case { id: "bettertls::nameconstraints::tc5122", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16303, 16304], leaf: 16302 }, + Case { id: "bettertls::nameconstraints::tc5123", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16306, 16307], leaf: 16305 }, + Case { id: "bettertls::nameconstraints::tc5124", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16309, 16310], leaf: 16308 }, + Case { id: "bettertls::nameconstraints::tc5125", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16312, 16313], leaf: 16311 }, + Case { id: "bettertls::nameconstraints::tc5126", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16315, 16316], leaf: 16314 }, + Case { id: "bettertls::nameconstraints::tc5127", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16318, 16319], leaf: 16317 }, + Case { id: "bettertls::nameconstraints::tc5128", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16321, 16322], leaf: 16320 }, + Case { id: "bettertls::nameconstraints::tc5129", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16324, 16325], leaf: 16323 }, + Case { id: "bettertls::nameconstraints::tc5130", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16327, 16328], leaf: 16326 }, + Case { id: "bettertls::nameconstraints::tc5131", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16330, 16331], leaf: 16329 }, + Case { id: "bettertls::nameconstraints::tc5132", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16333, 16334], leaf: 16332 }, + Case { id: "bettertls::nameconstraints::tc5133", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16336, 16337], leaf: 16335 }, + Case { id: "bettertls::nameconstraints::tc5134", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16339, 16340], leaf: 16338 }, + Case { id: "bettertls::nameconstraints::tc5135", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16342, 16343], leaf: 16341 }, + Case { id: "bettertls::nameconstraints::tc5136", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16345, 16346], leaf: 16344 }, + Case { id: "bettertls::nameconstraints::tc5137", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16348, 16349], leaf: 16347 }, + Case { id: "bettertls::nameconstraints::tc5138", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16351, 16352], leaf: 16350 }, + Case { id: "bettertls::nameconstraints::tc5139", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16354, 16355], leaf: 16353 }, + Case { id: "bettertls::nameconstraints::tc5140", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16357, 16358], leaf: 16356 }, + Case { id: "bettertls::nameconstraints::tc5141", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16360, 16361], leaf: 16359 }, + Case { id: "bettertls::nameconstraints::tc5142", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16363, 16364], leaf: 16362 }, + Case { id: "bettertls::nameconstraints::tc5143", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16366, 16367], leaf: 16365 }, + Case { id: "bettertls::nameconstraints::tc5144", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16369, 16370], leaf: 16368 }, + Case { id: "bettertls::nameconstraints::tc5145", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16372, 16373], leaf: 16371 }, + Case { id: "bettertls::nameconstraints::tc5146", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16375, 16376], leaf: 16374 }, + Case { id: "bettertls::nameconstraints::tc5147", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16378, 16379], leaf: 16377 }, + Case { id: "bettertls::nameconstraints::tc5148", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16381, 16382], leaf: 16380 }, + Case { id: "bettertls::nameconstraints::tc5149", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16384, 16385], leaf: 16383 }, + Case { id: "bettertls::nameconstraints::tc5150", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16387, 16388], leaf: 16386 }, + Case { id: "bettertls::nameconstraints::tc5151", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16390, 16391], leaf: 16389 }, + Case { id: "bettertls::nameconstraints::tc5152", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16393, 16394], leaf: 16392 }, + Case { id: "bettertls::nameconstraints::tc5153", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16396, 16397], leaf: 16395 }, + Case { id: "bettertls::nameconstraints::tc5154", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16399, 16400], leaf: 16398 }, + Case { id: "bettertls::nameconstraints::tc5155", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16402, 16403], leaf: 16401 }, + Case { id: "bettertls::nameconstraints::tc5156", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16405, 16406], leaf: 16404 }, + Case { id: "bettertls::nameconstraints::tc5157", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16408, 16409], leaf: 16407 }, + Case { id: "bettertls::nameconstraints::tc5158", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16411, 16412], leaf: 16410 }, + Case { id: "bettertls::nameconstraints::tc5159", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16414, 16415], leaf: 16413 }, + Case { id: "bettertls::nameconstraints::tc5160", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16417, 16418], leaf: 16416 }, + Case { id: "bettertls::nameconstraints::tc5161", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16420, 16421], leaf: 16419 }, + Case { id: "bettertls::nameconstraints::tc5162", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16423, 16424], leaf: 16422 }, + Case { id: "bettertls::nameconstraints::tc5163", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16426, 16427], leaf: 16425 }, + Case { id: "bettertls::nameconstraints::tc5164", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16429, 16430], leaf: 16428 }, + Case { id: "bettertls::nameconstraints::tc5165", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16432, 16433], leaf: 16431 }, + Case { id: "bettertls::nameconstraints::tc5166", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16435, 16436], leaf: 16434 }, + Case { id: "bettertls::nameconstraints::tc5167", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16438, 16439], leaf: 16437 }, + Case { id: "bettertls::nameconstraints::tc5168", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16441, 16442], leaf: 16440 }, + Case { id: "bettertls::nameconstraints::tc5169", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16444, 16445], leaf: 16443 }, + Case { id: "bettertls::nameconstraints::tc5170", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16447, 16448], leaf: 16446 }, + Case { id: "bettertls::nameconstraints::tc5171", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16450, 16451], leaf: 16449 }, + Case { id: "bettertls::nameconstraints::tc5172", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16453, 16454], leaf: 16452 }, + Case { id: "bettertls::nameconstraints::tc5173", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16456, 16457], leaf: 16455 }, + Case { id: "bettertls::nameconstraints::tc5174", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16459, 16460], leaf: 16458 }, + Case { id: "bettertls::nameconstraints::tc5175", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16462, 16463], leaf: 16461 }, + Case { id: "bettertls::nameconstraints::tc5176", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16465, 16466], leaf: 16464 }, + Case { id: "bettertls::nameconstraints::tc5177", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16468, 16469], leaf: 16467 }, + Case { id: "bettertls::nameconstraints::tc5178", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16471, 16472], leaf: 16470 }, + Case { id: "bettertls::nameconstraints::tc5179", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16474, 16475], leaf: 16473 }, + Case { id: "bettertls::nameconstraints::tc5180", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16477, 16478], leaf: 16476 }, + Case { id: "bettertls::nameconstraints::tc5181", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16480, 16481], leaf: 16479 }, + Case { id: "bettertls::nameconstraints::tc5182", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16483, 16484], leaf: 16482 }, + Case { id: "bettertls::nameconstraints::tc5183", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16486, 16487], leaf: 16485 }, + Case { id: "bettertls::nameconstraints::tc5184", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16489, 16490], leaf: 16488 }, + Case { id: "bettertls::nameconstraints::tc5185", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16492, 16493], leaf: 16491 }, + Case { id: "bettertls::nameconstraints::tc5186", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16495, 16496], leaf: 16494 }, + Case { id: "bettertls::nameconstraints::tc5187", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16498, 16499], leaf: 16497 }, + Case { id: "bettertls::nameconstraints::tc5188", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16501, 16502], leaf: 16500 }, + Case { id: "bettertls::nameconstraints::tc5189", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16504, 16505], leaf: 16503 }, + Case { id: "bettertls::nameconstraints::tc5190", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16507, 16508], leaf: 16506 }, + Case { id: "bettertls::nameconstraints::tc5191", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16510, 16511], leaf: 16509 }, + Case { id: "bettertls::nameconstraints::tc5192", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16513, 16514], leaf: 16512 }, + Case { id: "bettertls::nameconstraints::tc5193", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16516, 16517], leaf: 16515 }, + Case { id: "bettertls::nameconstraints::tc5194", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16519, 16520], leaf: 16518 }, + Case { id: "bettertls::nameconstraints::tc5195", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16522, 16523], leaf: 16521 }, + Case { id: "bettertls::nameconstraints::tc5196", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16525, 16526], leaf: 16524 }, + Case { id: "bettertls::nameconstraints::tc5197", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16528, 16529], leaf: 16527 }, + Case { id: "bettertls::nameconstraints::tc5198", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16531, 16532], leaf: 16530 }, + Case { id: "bettertls::nameconstraints::tc5199", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16534, 16535], leaf: 16533 }, + Case { id: "bettertls::nameconstraints::tc5200", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16537, 16538], leaf: 16536 }, + Case { id: "bettertls::nameconstraints::tc5201", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16540, 16541], leaf: 16539 }, + Case { id: "bettertls::nameconstraints::tc5202", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16543, 16544], leaf: 16542 }, + Case { id: "bettertls::nameconstraints::tc5203", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16546, 16547], leaf: 16545 }, + Case { id: "bettertls::nameconstraints::tc5204", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16549, 16550], leaf: 16548 }, + Case { id: "bettertls::nameconstraints::tc5205", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16552, 16553], leaf: 16551 }, + Case { id: "bettertls::nameconstraints::tc5206", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16555, 16556], leaf: 16554 }, + Case { id: "bettertls::nameconstraints::tc5207", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16558, 16559], leaf: 16557 }, + Case { id: "bettertls::nameconstraints::tc5208", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16561, 16562], leaf: 16560 }, + Case { id: "bettertls::nameconstraints::tc5209", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16564, 16565], leaf: 16563 }, + Case { id: "bettertls::nameconstraints::tc5210", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16567, 16568], leaf: 16566 }, + Case { id: "bettertls::nameconstraints::tc5211", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16570, 16571], leaf: 16569 }, + Case { id: "bettertls::nameconstraints::tc5212", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16573, 16574], leaf: 16572 }, + Case { id: "bettertls::nameconstraints::tc5213", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16576, 16577], leaf: 16575 }, + Case { id: "bettertls::nameconstraints::tc5214", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16579, 16580], leaf: 16578 }, + Case { id: "bettertls::nameconstraints::tc5215", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16582, 16583], leaf: 16581 }, + Case { id: "bettertls::nameconstraints::tc5216", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16585, 16586], leaf: 16584 }, + Case { id: "bettertls::nameconstraints::tc5217", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16588, 16589], leaf: 16587 }, + Case { id: "bettertls::nameconstraints::tc5218", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16591, 16592], leaf: 16590 }, + Case { id: "bettertls::nameconstraints::tc5219", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16594, 16595], leaf: 16593 }, + Case { id: "bettertls::nameconstraints::tc5220", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16597, 16598], leaf: 16596 }, + Case { id: "bettertls::nameconstraints::tc5221", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16600, 16601], leaf: 16599 }, + Case { id: "bettertls::nameconstraints::tc5222", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16603, 16604], leaf: 16602 }, + Case { id: "bettertls::nameconstraints::tc5223", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16606, 16607], leaf: 16605 }, + Case { id: "bettertls::nameconstraints::tc5224", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16609, 16610], leaf: 16608 }, + Case { id: "bettertls::nameconstraints::tc5225", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16612, 16613], leaf: 16611 }, + Case { id: "bettertls::nameconstraints::tc5226", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16615, 16616], leaf: 16614 }, + Case { id: "bettertls::nameconstraints::tc5227", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16618, 16619], leaf: 16617 }, + Case { id: "bettertls::nameconstraints::tc5228", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16621, 16622], leaf: 16620 }, + Case { id: "bettertls::nameconstraints::tc5229", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16624, 16625], leaf: 16623 }, + Case { id: "bettertls::nameconstraints::tc5230", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16627, 16628], leaf: 16626 }, + Case { id: "bettertls::nameconstraints::tc5231", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16630, 16631], leaf: 16629 }, + Case { id: "bettertls::nameconstraints::tc5232", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16633, 16634], leaf: 16632 }, + Case { id: "bettertls::nameconstraints::tc5233", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16636, 16637], leaf: 16635 }, + Case { id: "bettertls::nameconstraints::tc5234", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16639, 16640], leaf: 16638 }, + Case { id: "bettertls::nameconstraints::tc5235", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16642, 16643], leaf: 16641 }, + Case { id: "bettertls::nameconstraints::tc5236", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16645, 16646], leaf: 16644 }, + Case { id: "bettertls::nameconstraints::tc5237", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16648, 16649], leaf: 16647 }, + Case { id: "bettertls::nameconstraints::tc5238", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16651, 16652], leaf: 16650 }, + Case { id: "bettertls::nameconstraints::tc5239", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16654, 16655], leaf: 16653 }, + Case { id: "bettertls::nameconstraints::tc5240", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16657, 16658], leaf: 16656 }, + Case { id: "bettertls::nameconstraints::tc5241", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16660, 16661], leaf: 16659 }, + Case { id: "bettertls::nameconstraints::tc5242", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16663, 16664], leaf: 16662 }, + Case { id: "bettertls::nameconstraints::tc5243", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16666, 16667], leaf: 16665 }, + Case { id: "bettertls::nameconstraints::tc5244", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16669, 16670], leaf: 16668 }, + Case { id: "bettertls::nameconstraints::tc5245", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16672, 16673], leaf: 16671 }, + Case { id: "bettertls::nameconstraints::tc5246", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16675, 16676], leaf: 16674 }, + Case { id: "bettertls::nameconstraints::tc5247", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16678, 16679], leaf: 16677 }, + Case { id: "bettertls::nameconstraints::tc5248", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16681, 16682], leaf: 16680 }, + Case { id: "bettertls::nameconstraints::tc5249", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16684, 16685], leaf: 16683 }, + Case { id: "bettertls::nameconstraints::tc5250", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16687, 16688], leaf: 16686 }, + Case { id: "bettertls::nameconstraints::tc5251", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16690, 16691], leaf: 16689 }, + Case { id: "bettertls::nameconstraints::tc5252", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16693, 16694], leaf: 16692 }, + Case { id: "bettertls::nameconstraints::tc5253", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16696, 16697], leaf: 16695 }, + Case { id: "bettertls::nameconstraints::tc5254", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16699, 16700], leaf: 16698 }, + Case { id: "bettertls::nameconstraints::tc5255", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16702, 16703], leaf: 16701 }, + Case { id: "bettertls::nameconstraints::tc5256", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16705, 16706], leaf: 16704 }, + Case { id: "bettertls::nameconstraints::tc5257", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16708, 16709], leaf: 16707 }, + Case { id: "bettertls::nameconstraints::tc5258", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16711, 16712], leaf: 16710 }, + Case { id: "bettertls::nameconstraints::tc5259", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16714, 16715], leaf: 16713 }, + Case { id: "bettertls::nameconstraints::tc5260", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16717, 16718], leaf: 16716 }, + Case { id: "bettertls::nameconstraints::tc5261", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16720, 16721], leaf: 16719 }, + Case { id: "bettertls::nameconstraints::tc5262", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16723, 16724], leaf: 16722 }, + Case { id: "bettertls::nameconstraints::tc5263", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16726, 16727], leaf: 16725 }, + Case { id: "bettertls::nameconstraints::tc5264", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16729, 16730], leaf: 16728 }, + Case { id: "bettertls::nameconstraints::tc5265", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16732, 16733], leaf: 16731 }, + Case { id: "bettertls::nameconstraints::tc5266", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16735, 16736], leaf: 16734 }, + Case { id: "bettertls::nameconstraints::tc5267", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16738, 16739], leaf: 16737 }, + Case { id: "bettertls::nameconstraints::tc5268", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16741, 16742], leaf: 16740 }, + Case { id: "bettertls::nameconstraints::tc5269", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16744, 16745], leaf: 16743 }, + Case { id: "bettertls::nameconstraints::tc5270", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16747, 16748], leaf: 16746 }, + Case { id: "bettertls::nameconstraints::tc5271", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16750, 16751], leaf: 16749 }, + Case { id: "bettertls::nameconstraints::tc5272", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16753, 16754], leaf: 16752 }, + Case { id: "bettertls::nameconstraints::tc5273", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16756, 16757], leaf: 16755 }, + Case { id: "bettertls::nameconstraints::tc5274", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16759, 16760], leaf: 16758 }, + Case { id: "bettertls::nameconstraints::tc5275", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16762, 16763], leaf: 16761 }, + Case { id: "bettertls::nameconstraints::tc5276", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16765, 16766], leaf: 16764 }, + Case { id: "bettertls::nameconstraints::tc5277", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16768, 16769], leaf: 16767 }, + Case { id: "bettertls::nameconstraints::tc5278", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16771, 16772], leaf: 16770 }, + Case { id: "bettertls::nameconstraints::tc5279", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16774, 16775], leaf: 16773 }, + Case { id: "bettertls::nameconstraints::tc5280", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16777, 16778], leaf: 16776 }, + Case { id: "bettertls::nameconstraints::tc5281", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16780, 16781], leaf: 16779 }, + Case { id: "bettertls::nameconstraints::tc5282", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16783, 16784], leaf: 16782 }, + Case { id: "bettertls::nameconstraints::tc5283", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16786, 16787], leaf: 16785 }, + Case { id: "bettertls::nameconstraints::tc5284", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16789, 16790], leaf: 16788 }, + Case { id: "bettertls::nameconstraints::tc5285", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16792, 16793], leaf: 16791 }, + Case { id: "bettertls::nameconstraints::tc5286", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16795, 16796], leaf: 16794 }, + Case { id: "bettertls::nameconstraints::tc5287", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16798, 16799], leaf: 16797 }, + Case { id: "bettertls::nameconstraints::tc5288", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16801, 16802], leaf: 16800 }, + Case { id: "bettertls::nameconstraints::tc5289", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16804, 16805], leaf: 16803 }, + Case { id: "bettertls::nameconstraints::tc5290", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16807, 16808], leaf: 16806 }, + Case { id: "bettertls::nameconstraints::tc5291", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16810, 16811], leaf: 16809 }, + Case { id: "bettertls::nameconstraints::tc5292", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16813, 16814], leaf: 16812 }, + Case { id: "bettertls::nameconstraints::tc5293", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16816, 16817], leaf: 16815 }, + Case { id: "bettertls::nameconstraints::tc5294", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16819, 16820], leaf: 16818 }, + Case { id: "bettertls::nameconstraints::tc5295", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16822, 16823], leaf: 16821 }, + Case { id: "bettertls::nameconstraints::tc5296", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16825, 16826], leaf: 16824 }, + Case { id: "bettertls::nameconstraints::tc5297", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16828, 16829], leaf: 16827 }, + Case { id: "bettertls::nameconstraints::tc5298", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16831, 16832], leaf: 16830 }, + Case { id: "bettertls::nameconstraints::tc5299", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16834, 16835], leaf: 16833 }, + Case { id: "bettertls::nameconstraints::tc5300", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16837, 16838], leaf: 16836 }, + Case { id: "bettertls::nameconstraints::tc5301", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16840, 16841], leaf: 16839 }, + Case { id: "bettertls::nameconstraints::tc5302", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16843, 16844], leaf: 16842 }, + Case { id: "bettertls::nameconstraints::tc5303", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16846, 16847], leaf: 16845 }, + Case { id: "bettertls::nameconstraints::tc5304", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16849, 16850], leaf: 16848 }, + Case { id: "bettertls::nameconstraints::tc5305", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16852, 16853], leaf: 16851 }, + Case { id: "bettertls::nameconstraints::tc5306", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16855, 16856], leaf: 16854 }, + Case { id: "bettertls::nameconstraints::tc5307", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16858, 16859], leaf: 16857 }, + Case { id: "bettertls::nameconstraints::tc5308", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16861, 16862], leaf: 16860 }, + Case { id: "bettertls::nameconstraints::tc5309", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16864, 16865], leaf: 16863 }, + Case { id: "bettertls::nameconstraints::tc5310", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16867, 16868], leaf: 16866 }, + Case { id: "bettertls::nameconstraints::tc5311", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16870, 16871], leaf: 16869 }, + Case { id: "bettertls::nameconstraints::tc5312", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16873, 16874], leaf: 16872 }, + Case { id: "bettertls::nameconstraints::tc5313", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16876, 16877], leaf: 16875 }, + Case { id: "bettertls::nameconstraints::tc5314", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16879, 16880], leaf: 16878 }, + Case { id: "bettertls::nameconstraints::tc5315", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16882, 16883], leaf: 16881 }, + Case { id: "bettertls::nameconstraints::tc5316", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16885, 16886], leaf: 16884 }, + Case { id: "bettertls::nameconstraints::tc5317", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16888, 16889], leaf: 16887 }, + Case { id: "bettertls::nameconstraints::tc5318", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16891, 16892], leaf: 16890 }, + Case { id: "bettertls::nameconstraints::tc5319", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16894, 16895], leaf: 16893 }, + Case { id: "bettertls::nameconstraints::tc5320", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16897, 16898], leaf: 16896 }, + Case { id: "bettertls::nameconstraints::tc5321", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16900, 16901], leaf: 16899 }, + Case { id: "bettertls::nameconstraints::tc5322", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16903, 16904], leaf: 16902 }, + Case { id: "bettertls::nameconstraints::tc5323", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16906, 16907], leaf: 16905 }, + Case { id: "bettertls::nameconstraints::tc5324", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16909, 16910], leaf: 16908 }, + Case { id: "bettertls::nameconstraints::tc5325", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16912, 16913], leaf: 16911 }, + Case { id: "bettertls::nameconstraints::tc5326", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16915, 16916], leaf: 16914 }, + Case { id: "bettertls::nameconstraints::tc5327", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16918, 16919], leaf: 16917 }, + Case { id: "bettertls::nameconstraints::tc5328", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16921, 16922], leaf: 16920 }, + Case { id: "bettertls::nameconstraints::tc5329", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16924, 16925], leaf: 16923 }, + Case { id: "bettertls::nameconstraints::tc5330", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16927, 16928], leaf: 16926 }, + Case { id: "bettertls::nameconstraints::tc5331", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16930, 16931], leaf: 16929 }, + Case { id: "bettertls::nameconstraints::tc5332", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16933, 16934], leaf: 16932 }, + Case { id: "bettertls::nameconstraints::tc5333", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16936, 16937], leaf: 16935 }, + Case { id: "bettertls::nameconstraints::tc5334", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16939, 16940], leaf: 16938 }, + Case { id: "bettertls::nameconstraints::tc5335", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16942, 16943], leaf: 16941 }, + Case { id: "bettertls::nameconstraints::tc5336", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16945, 16946], leaf: 16944 }, + Case { id: "bettertls::nameconstraints::tc5337", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16948, 16949], leaf: 16947 }, + Case { id: "bettertls::nameconstraints::tc5338", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16951, 16952], leaf: 16950 }, + Case { id: "bettertls::nameconstraints::tc5339", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16954, 16955], leaf: 16953 }, + Case { id: "bettertls::nameconstraints::tc5340", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16957, 16958], leaf: 16956 }, + Case { id: "bettertls::nameconstraints::tc5341", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16960, 16961], leaf: 16959 }, + Case { id: "bettertls::nameconstraints::tc5342", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16963, 16964], leaf: 16962 }, + Case { id: "bettertls::nameconstraints::tc5343", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16966, 16967], leaf: 16965 }, + Case { id: "bettertls::nameconstraints::tc5344", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16969, 16970], leaf: 16968 }, + Case { id: "bettertls::nameconstraints::tc5345", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16972, 16973], leaf: 16971 }, + Case { id: "bettertls::nameconstraints::tc5346", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16975, 16976], leaf: 16974 }, + Case { id: "bettertls::nameconstraints::tc5347", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16978, 16979], leaf: 16977 }, + Case { id: "bettertls::nameconstraints::tc5348", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16981, 16982], leaf: 16980 }, + Case { id: "bettertls::nameconstraints::tc5349", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16984, 16985], leaf: 16983 }, + Case { id: "bettertls::nameconstraints::tc5350", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16987, 16988], leaf: 16986 }, + Case { id: "bettertls::nameconstraints::tc5351", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16990, 16991], leaf: 16989 }, + Case { id: "bettertls::nameconstraints::tc5352", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16993, 16994], leaf: 16992 }, + Case { id: "bettertls::nameconstraints::tc5353", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16996, 16997], leaf: 16995 }, + Case { id: "bettertls::nameconstraints::tc5354", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[16999, 17000], leaf: 16998 }, + Case { id: "bettertls::nameconstraints::tc5355", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17002, 17003], leaf: 17001 }, + Case { id: "bettertls::nameconstraints::tc5356", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17005, 17006], leaf: 17004 }, + Case { id: "bettertls::nameconstraints::tc5357", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17008, 17009], leaf: 17007 }, + Case { id: "bettertls::nameconstraints::tc5358", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17011, 17012], leaf: 17010 }, + Case { id: "bettertls::nameconstraints::tc5359", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17014, 17015], leaf: 17013 }, + Case { id: "bettertls::nameconstraints::tc5360", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17017, 17018], leaf: 17016 }, + Case { id: "bettertls::nameconstraints::tc5361", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17020, 17021], leaf: 17019 }, + Case { id: "bettertls::nameconstraints::tc5362", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17023, 17024], leaf: 17022 }, + Case { id: "bettertls::nameconstraints::tc5363", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17026, 17027], leaf: 17025 }, + Case { id: "bettertls::nameconstraints::tc5364", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17029, 17030], leaf: 17028 }, + Case { id: "bettertls::nameconstraints::tc5365", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17032, 17033], leaf: 17031 }, + Case { id: "bettertls::nameconstraints::tc5366", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17035, 17036], leaf: 17034 }, + Case { id: "bettertls::nameconstraints::tc5367", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17038, 17039], leaf: 17037 }, + Case { id: "bettertls::nameconstraints::tc5368", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17041, 17042], leaf: 17040 }, + Case { id: "bettertls::nameconstraints::tc5369", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17044, 17045], leaf: 17043 }, + Case { id: "bettertls::nameconstraints::tc5370", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17047, 17048], leaf: 17046 }, + Case { id: "bettertls::nameconstraints::tc5371", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17050, 17051], leaf: 17049 }, + Case { id: "bettertls::nameconstraints::tc5372", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17053, 17054], leaf: 17052 }, + Case { id: "bettertls::nameconstraints::tc5373", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17056, 17057], leaf: 17055 }, + Case { id: "bettertls::nameconstraints::tc5374", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17059, 17060], leaf: 17058 }, + Case { id: "bettertls::nameconstraints::tc5375", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17062, 17063], leaf: 17061 }, + Case { id: "bettertls::nameconstraints::tc5376", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17065, 17066], leaf: 17064 }, + Case { id: "bettertls::nameconstraints::tc5377", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17068, 17069], leaf: 17067 }, + Case { id: "bettertls::nameconstraints::tc5378", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17071, 17072], leaf: 17070 }, + Case { id: "bettertls::nameconstraints::tc5379", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17074, 17075], leaf: 17073 }, + Case { id: "bettertls::nameconstraints::tc5380", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17077, 17078], leaf: 17076 }, + Case { id: "bettertls::nameconstraints::tc5381", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17080, 17081], leaf: 17079 }, + Case { id: "bettertls::nameconstraints::tc5382", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17083, 17084], leaf: 17082 }, + Case { id: "bettertls::nameconstraints::tc5383", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17086, 17087], leaf: 17085 }, + Case { id: "bettertls::nameconstraints::tc5384", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17089, 17090], leaf: 17088 }, + Case { id: "bettertls::nameconstraints::tc5385", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17092, 17093], leaf: 17091 }, + Case { id: "bettertls::nameconstraints::tc5386", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17095, 17096], leaf: 17094 }, + Case { id: "bettertls::nameconstraints::tc5387", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17098, 17099], leaf: 17097 }, + Case { id: "bettertls::nameconstraints::tc5388", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17101, 17102], leaf: 17100 }, + Case { id: "bettertls::nameconstraints::tc5389", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17104, 17105], leaf: 17103 }, + Case { id: "bettertls::nameconstraints::tc5390", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17107, 17108], leaf: 17106 }, + Case { id: "bettertls::nameconstraints::tc5391", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17110, 17111], leaf: 17109 }, + Case { id: "bettertls::nameconstraints::tc5392", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17113, 17114], leaf: 17112 }, + Case { id: "bettertls::nameconstraints::tc5393", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17116, 17117], leaf: 17115 }, + Case { id: "bettertls::nameconstraints::tc5394", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17119, 17120], leaf: 17118 }, + Case { id: "bettertls::nameconstraints::tc5395", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17122, 17123], leaf: 17121 }, + Case { id: "bettertls::nameconstraints::tc5396", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17125, 17126], leaf: 17124 }, + Case { id: "bettertls::nameconstraints::tc5397", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17128, 17129], leaf: 17127 }, + Case { id: "bettertls::nameconstraints::tc5398", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17131, 17132], leaf: 17130 }, + Case { id: "bettertls::nameconstraints::tc5399", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17134, 17135], leaf: 17133 }, + Case { id: "bettertls::nameconstraints::tc5400", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17137, 17138], leaf: 17136 }, + Case { id: "bettertls::nameconstraints::tc5401", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17140, 17141], leaf: 17139 }, + Case { id: "bettertls::nameconstraints::tc5402", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17143, 17144], leaf: 17142 }, + Case { id: "bettertls::nameconstraints::tc5403", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17146, 17147], leaf: 17145 }, + Case { id: "bettertls::nameconstraints::tc5404", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17149, 17150], leaf: 17148 }, + Case { id: "bettertls::nameconstraints::tc5405", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17152, 17153], leaf: 17151 }, + Case { id: "bettertls::nameconstraints::tc5406", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17155, 17156], leaf: 17154 }, + Case { id: "bettertls::nameconstraints::tc5407", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17158, 17159], leaf: 17157 }, + Case { id: "bettertls::nameconstraints::tc5408", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17161, 17162], leaf: 17160 }, + Case { id: "bettertls::nameconstraints::tc5409", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17164, 17165], leaf: 17163 }, + Case { id: "bettertls::nameconstraints::tc5410", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17167, 17168], leaf: 17166 }, + Case { id: "bettertls::nameconstraints::tc5411", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17170, 17171], leaf: 17169 }, + Case { id: "bettertls::nameconstraints::tc5412", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17173, 17174], leaf: 17172 }, + Case { id: "bettertls::nameconstraints::tc5413", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17176, 17177], leaf: 17175 }, + Case { id: "bettertls::nameconstraints::tc5414", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17179, 17180], leaf: 17178 }, + Case { id: "bettertls::nameconstraints::tc5415", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17182, 17183], leaf: 17181 }, + Case { id: "bettertls::nameconstraints::tc5416", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17185, 17186], leaf: 17184 }, + Case { id: "bettertls::nameconstraints::tc5417", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17188, 17189], leaf: 17187 }, + Case { id: "bettertls::nameconstraints::tc5418", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17191, 17192], leaf: 17190 }, + Case { id: "bettertls::nameconstraints::tc5419", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17194, 17195], leaf: 17193 }, + Case { id: "bettertls::nameconstraints::tc5420", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17197, 17198], leaf: 17196 }, + Case { id: "bettertls::nameconstraints::tc5421", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17200, 17201], leaf: 17199 }, + Case { id: "bettertls::nameconstraints::tc5422", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17203, 17204], leaf: 17202 }, + Case { id: "bettertls::nameconstraints::tc5423", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17206, 17207], leaf: 17205 }, + Case { id: "bettertls::nameconstraints::tc5424", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17209, 17210], leaf: 17208 }, + Case { id: "bettertls::nameconstraints::tc5425", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17212, 17213], leaf: 17211 }, + Case { id: "bettertls::nameconstraints::tc5426", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17215, 17216], leaf: 17214 }, + Case { id: "bettertls::nameconstraints::tc5427", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17218, 17219], leaf: 17217 }, + Case { id: "bettertls::nameconstraints::tc5428", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17221, 17222], leaf: 17220 }, + Case { id: "bettertls::nameconstraints::tc5429", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17224, 17225], leaf: 17223 }, + Case { id: "bettertls::nameconstraints::tc5430", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17227, 17228], leaf: 17226 }, + Case { id: "bettertls::nameconstraints::tc5431", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17230, 17231], leaf: 17229 }, + Case { id: "bettertls::nameconstraints::tc5432", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17233, 17234], leaf: 17232 }, + Case { id: "bettertls::nameconstraints::tc5433", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17236, 17237], leaf: 17235 }, + Case { id: "bettertls::nameconstraints::tc5434", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17239, 17240], leaf: 17238 }, + Case { id: "bettertls::nameconstraints::tc5435", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17242, 17243], leaf: 17241 }, + Case { id: "bettertls::nameconstraints::tc5436", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17245, 17246], leaf: 17244 }, + Case { id: "bettertls::nameconstraints::tc5437", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17248, 17249], leaf: 17247 }, + Case { id: "bettertls::nameconstraints::tc5438", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17251, 17252], leaf: 17250 }, + Case { id: "bettertls::nameconstraints::tc5439", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17254, 17255], leaf: 17253 }, + Case { id: "bettertls::nameconstraints::tc5440", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17257, 17258], leaf: 17256 }, + Case { id: "bettertls::nameconstraints::tc5441", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17260, 17261], leaf: 17259 }, + Case { id: "bettertls::nameconstraints::tc5442", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17263, 17264], leaf: 17262 }, + Case { id: "bettertls::nameconstraints::tc5443", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17266, 17267], leaf: 17265 }, + Case { id: "bettertls::nameconstraints::tc5444", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17269, 17270], leaf: 17268 }, + Case { id: "bettertls::nameconstraints::tc5445", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17272, 17273], leaf: 17271 }, + Case { id: "bettertls::nameconstraints::tc5446", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17275, 17276], leaf: 17274 }, + Case { id: "bettertls::nameconstraints::tc5447", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17278, 17279], leaf: 17277 }, + Case { id: "bettertls::nameconstraints::tc5448", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17281, 17282], leaf: 17280 }, + Case { id: "bettertls::nameconstraints::tc5449", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17284, 17285], leaf: 17283 }, + Case { id: "bettertls::nameconstraints::tc5450", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17287, 17288], leaf: 17286 }, + Case { id: "bettertls::nameconstraints::tc5451", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17290, 17291], leaf: 17289 }, + Case { id: "bettertls::nameconstraints::tc5452", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17293, 17294], leaf: 17292 }, + Case { id: "bettertls::nameconstraints::tc5453", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17296, 17297], leaf: 17295 }, + Case { id: "bettertls::nameconstraints::tc5454", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17299, 17300], leaf: 17298 }, + Case { id: "bettertls::nameconstraints::tc5455", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17302, 17303], leaf: 17301 }, + Case { id: "bettertls::nameconstraints::tc5456", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17305, 17306], leaf: 17304 }, + Case { id: "bettertls::nameconstraints::tc5457", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17308, 17309], leaf: 17307 }, + Case { id: "bettertls::nameconstraints::tc5458", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17311, 17312], leaf: 17310 }, + Case { id: "bettertls::nameconstraints::tc5459", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17314, 17315], leaf: 17313 }, + Case { id: "bettertls::nameconstraints::tc5460", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17317, 17318], leaf: 17316 }, + Case { id: "bettertls::nameconstraints::tc5461", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17320, 17321], leaf: 17319 }, + Case { id: "bettertls::nameconstraints::tc5462", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17323, 17324], leaf: 17322 }, + Case { id: "bettertls::nameconstraints::tc5463", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17326, 17327], leaf: 17325 }, + Case { id: "bettertls::nameconstraints::tc5464", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17329, 17330], leaf: 17328 }, + Case { id: "bettertls::nameconstraints::tc5465", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17332, 17333], leaf: 17331 }, + Case { id: "bettertls::nameconstraints::tc5466", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17335, 17336], leaf: 17334 }, + Case { id: "bettertls::nameconstraints::tc5467", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17338, 17339], leaf: 17337 }, + Case { id: "bettertls::nameconstraints::tc5468", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17341, 17342], leaf: 17340 }, + Case { id: "bettertls::nameconstraints::tc5469", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17344, 17345], leaf: 17343 }, + Case { id: "bettertls::nameconstraints::tc5470", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17347, 17348], leaf: 17346 }, + Case { id: "bettertls::nameconstraints::tc5471", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17350, 17351], leaf: 17349 }, + Case { id: "bettertls::nameconstraints::tc5472", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17353, 17354], leaf: 17352 }, + Case { id: "bettertls::nameconstraints::tc5473", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17356, 17357], leaf: 17355 }, + Case { id: "bettertls::nameconstraints::tc5474", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17359, 17360], leaf: 17358 }, + Case { id: "bettertls::nameconstraints::tc5475", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17362, 17363], leaf: 17361 }, + Case { id: "bettertls::nameconstraints::tc5476", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17365, 17366], leaf: 17364 }, + Case { id: "bettertls::nameconstraints::tc5477", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17368, 17369], leaf: 17367 }, + Case { id: "bettertls::nameconstraints::tc5478", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17371, 17372], leaf: 17370 }, + Case { id: "bettertls::nameconstraints::tc5479", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17374, 17375], leaf: 17373 }, + Case { id: "bettertls::nameconstraints::tc5480", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17377, 17378], leaf: 17376 }, + Case { id: "bettertls::nameconstraints::tc5481", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17380, 17381], leaf: 17379 }, + Case { id: "bettertls::nameconstraints::tc5482", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17383, 17384], leaf: 17382 }, + Case { id: "bettertls::nameconstraints::tc5483", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17386, 17387], leaf: 17385 }, + Case { id: "bettertls::nameconstraints::tc5484", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17389, 17390], leaf: 17388 }, + Case { id: "bettertls::nameconstraints::tc5485", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17392, 17393], leaf: 17391 }, + Case { id: "bettertls::nameconstraints::tc5486", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17395, 17396], leaf: 17394 }, + Case { id: "bettertls::nameconstraints::tc5487", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17398, 17399], leaf: 17397 }, + Case { id: "bettertls::nameconstraints::tc5488", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17401, 17402], leaf: 17400 }, + Case { id: "bettertls::nameconstraints::tc5489", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17404, 17405], leaf: 17403 }, + Case { id: "bettertls::nameconstraints::tc5490", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17407, 17408], leaf: 17406 }, + Case { id: "bettertls::nameconstraints::tc5491", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17410, 17411], leaf: 17409 }, + Case { id: "bettertls::nameconstraints::tc5492", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17413, 17414], leaf: 17412 }, + Case { id: "bettertls::nameconstraints::tc5493", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17416, 17417], leaf: 17415 }, + Case { id: "bettertls::nameconstraints::tc5494", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17419, 17420], leaf: 17418 }, + Case { id: "bettertls::nameconstraints::tc5495", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17422, 17423], leaf: 17421 }, + Case { id: "bettertls::nameconstraints::tc5496", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17425, 17426], leaf: 17424 }, + Case { id: "bettertls::nameconstraints::tc5497", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17428, 17429], leaf: 17427 }, + Case { id: "bettertls::nameconstraints::tc5498", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17431, 17432], leaf: 17430 }, + Case { id: "bettertls::nameconstraints::tc5499", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17434, 17435], leaf: 17433 }, + Case { id: "bettertls::nameconstraints::tc5500", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17437, 17438], leaf: 17436 }, + Case { id: "bettertls::nameconstraints::tc5501", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17440, 17441], leaf: 17439 }, + Case { id: "bettertls::nameconstraints::tc5502", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17443, 17444], leaf: 17442 }, + Case { id: "bettertls::nameconstraints::tc5503", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17446, 17447], leaf: 17445 }, + Case { id: "bettertls::nameconstraints::tc5504", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17449, 17450], leaf: 17448 }, + Case { id: "bettertls::nameconstraints::tc5505", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17452, 17453], leaf: 17451 }, + Case { id: "bettertls::nameconstraints::tc5506", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17455, 17456], leaf: 17454 }, + Case { id: "bettertls::nameconstraints::tc5507", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17458, 17459], leaf: 17457 }, + Case { id: "bettertls::nameconstraints::tc5508", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17461, 17462], leaf: 17460 }, + Case { id: "bettertls::nameconstraints::tc5509", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17464, 17465], leaf: 17463 }, + Case { id: "bettertls::nameconstraints::tc5510", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17467, 17468], leaf: 17466 }, + Case { id: "bettertls::nameconstraints::tc5511", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17470, 17471], leaf: 17469 }, + Case { id: "bettertls::nameconstraints::tc5512", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17473, 17474], leaf: 17472 }, + Case { id: "bettertls::nameconstraints::tc5513", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17476, 17477], leaf: 17475 }, + Case { id: "bettertls::nameconstraints::tc5514", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17479, 17480], leaf: 17478 }, + Case { id: "bettertls::nameconstraints::tc5515", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17482, 17483], leaf: 17481 }, + Case { id: "bettertls::nameconstraints::tc5516", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17485, 17486], leaf: 17484 }, + Case { id: "bettertls::nameconstraints::tc5517", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17488, 17489], leaf: 17487 }, + Case { id: "bettertls::nameconstraints::tc5518", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17491, 17492], leaf: 17490 }, + Case { id: "bettertls::nameconstraints::tc5519", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17494, 17495], leaf: 17493 }, + Case { id: "bettertls::nameconstraints::tc5520", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17497, 17498], leaf: 17496 }, + Case { id: "bettertls::nameconstraints::tc5521", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17500, 17501], leaf: 17499 }, + Case { id: "bettertls::nameconstraints::tc5522", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17503, 17504], leaf: 17502 }, + Case { id: "bettertls::nameconstraints::tc5523", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17506, 17507], leaf: 17505 }, + Case { id: "bettertls::nameconstraints::tc5524", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17509, 17510], leaf: 17508 }, + Case { id: "bettertls::nameconstraints::tc5525", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17512, 17513], leaf: 17511 }, + Case { id: "bettertls::nameconstraints::tc5526", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17515, 17516], leaf: 17514 }, + Case { id: "bettertls::nameconstraints::tc5527", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17518, 17519], leaf: 17517 }, + Case { id: "bettertls::nameconstraints::tc5528", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17521, 17522], leaf: 17520 }, + Case { id: "bettertls::nameconstraints::tc5529", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17524, 17525], leaf: 17523 }, + Case { id: "bettertls::nameconstraints::tc5530", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17527, 17528], leaf: 17526 }, + Case { id: "bettertls::nameconstraints::tc5531", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17530, 17531], leaf: 17529 }, + Case { id: "bettertls::nameconstraints::tc5532", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17533, 17534], leaf: 17532 }, + Case { id: "bettertls::nameconstraints::tc5533", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17536, 17537], leaf: 17535 }, + Case { id: "bettertls::nameconstraints::tc5534", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17539, 17540], leaf: 17538 }, + Case { id: "bettertls::nameconstraints::tc5535", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17542, 17543], leaf: 17541 }, + Case { id: "bettertls::nameconstraints::tc5536", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17545, 17546], leaf: 17544 }, + Case { id: "bettertls::nameconstraints::tc5537", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17548, 17549], leaf: 17547 }, + Case { id: "bettertls::nameconstraints::tc5538", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17551, 17552], leaf: 17550 }, + Case { id: "bettertls::nameconstraints::tc5539", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17554, 17555], leaf: 17553 }, + Case { id: "bettertls::nameconstraints::tc5540", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17557, 17558], leaf: 17556 }, + Case { id: "bettertls::nameconstraints::tc5541", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17560, 17561], leaf: 17559 }, + Case { id: "bettertls::nameconstraints::tc5542", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17563, 17564], leaf: 17562 }, + Case { id: "bettertls::nameconstraints::tc5543", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17566, 17567], leaf: 17565 }, + Case { id: "bettertls::nameconstraints::tc5544", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17569, 17570], leaf: 17568 }, + Case { id: "bettertls::nameconstraints::tc5545", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17572, 17573], leaf: 17571 }, + Case { id: "bettertls::nameconstraints::tc5546", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17575, 17576], leaf: 17574 }, + Case { id: "bettertls::nameconstraints::tc5547", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17578, 17579], leaf: 17577 }, + Case { id: "bettertls::nameconstraints::tc5548", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17581, 17582], leaf: 17580 }, + Case { id: "bettertls::nameconstraints::tc5549", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17584, 17585], leaf: 17583 }, + Case { id: "bettertls::nameconstraints::tc5550", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17587, 17588], leaf: 17586 }, + Case { id: "bettertls::nameconstraints::tc5551", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17590, 17591], leaf: 17589 }, + Case { id: "bettertls::nameconstraints::tc5552", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17593, 17594], leaf: 17592 }, + Case { id: "bettertls::nameconstraints::tc5553", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17596, 17597], leaf: 17595 }, + Case { id: "bettertls::nameconstraints::tc5554", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17599, 17600], leaf: 17598 }, + Case { id: "bettertls::nameconstraints::tc5555", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17602, 17603], leaf: 17601 }, + Case { id: "bettertls::nameconstraints::tc5556", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17605, 17606], leaf: 17604 }, + Case { id: "bettertls::nameconstraints::tc5557", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17608, 17609], leaf: 17607 }, + Case { id: "bettertls::nameconstraints::tc5558", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17611, 17612], leaf: 17610 }, + Case { id: "bettertls::nameconstraints::tc5559", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17614, 17615], leaf: 17613 }, + Case { id: "bettertls::nameconstraints::tc5560", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17617, 17618], leaf: 17616 }, + Case { id: "bettertls::nameconstraints::tc5561", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17620, 17621], leaf: 17619 }, + Case { id: "bettertls::nameconstraints::tc5562", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17623, 17624], leaf: 17622 }, + Case { id: "bettertls::nameconstraints::tc5563", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17626, 17627], leaf: 17625 }, + Case { id: "bettertls::nameconstraints::tc5564", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17629, 17630], leaf: 17628 }, + Case { id: "bettertls::nameconstraints::tc5565", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17632, 17633], leaf: 17631 }, + Case { id: "bettertls::nameconstraints::tc5566", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17635, 17636], leaf: 17634 }, + Case { id: "bettertls::nameconstraints::tc5567", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17638, 17639], leaf: 17637 }, + Case { id: "bettertls::nameconstraints::tc5568", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17641, 17642], leaf: 17640 }, + Case { id: "bettertls::nameconstraints::tc5569", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17644, 17645], leaf: 17643 }, + Case { id: "bettertls::nameconstraints::tc5570", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17647, 17648], leaf: 17646 }, + Case { id: "bettertls::nameconstraints::tc5571", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17650, 17651], leaf: 17649 }, + Case { id: "bettertls::nameconstraints::tc5572", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17653, 17654], leaf: 17652 }, + Case { id: "bettertls::nameconstraints::tc5573", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17656, 17657], leaf: 17655 }, + Case { id: "bettertls::nameconstraints::tc5574", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17659, 17660], leaf: 17658 }, + Case { id: "bettertls::nameconstraints::tc5575", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17662, 17663], leaf: 17661 }, + Case { id: "bettertls::nameconstraints::tc5576", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17665, 17666], leaf: 17664 }, + Case { id: "bettertls::nameconstraints::tc5577", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17668, 17669], leaf: 17667 }, + Case { id: "bettertls::nameconstraints::tc5578", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17671, 17672], leaf: 17670 }, + Case { id: "bettertls::nameconstraints::tc5579", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17674, 17675], leaf: 17673 }, + Case { id: "bettertls::nameconstraints::tc5580", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17677, 17678], leaf: 17676 }, + Case { id: "bettertls::nameconstraints::tc5581", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17680, 17681], leaf: 17679 }, + Case { id: "bettertls::nameconstraints::tc5582", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17683, 17684], leaf: 17682 }, + Case { id: "bettertls::nameconstraints::tc5583", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17686, 17687], leaf: 17685 }, + Case { id: "bettertls::nameconstraints::tc5584", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17689, 17690], leaf: 17688 }, + Case { id: "bettertls::nameconstraints::tc5585", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17692, 17693], leaf: 17691 }, + Case { id: "bettertls::nameconstraints::tc5586", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17695, 17696], leaf: 17694 }, + Case { id: "bettertls::nameconstraints::tc5587", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17698, 17699], leaf: 17697 }, + Case { id: "bettertls::nameconstraints::tc5588", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17701, 17702], leaf: 17700 }, + Case { id: "bettertls::nameconstraints::tc5589", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17704, 17705], leaf: 17703 }, + Case { id: "bettertls::nameconstraints::tc5590", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17707, 17708], leaf: 17706 }, + Case { id: "bettertls::nameconstraints::tc5591", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17710, 17711], leaf: 17709 }, + Case { id: "bettertls::nameconstraints::tc5592", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17713, 17714], leaf: 17712 }, + Case { id: "bettertls::nameconstraints::tc5593", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17716, 17717], leaf: 17715 }, + Case { id: "bettertls::nameconstraints::tc5594", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17719, 17720], leaf: 17718 }, + Case { id: "bettertls::nameconstraints::tc5595", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17722, 17723], leaf: 17721 }, + Case { id: "bettertls::nameconstraints::tc5596", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17725, 17726], leaf: 17724 }, + Case { id: "bettertls::nameconstraints::tc5597", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17728, 17729], leaf: 17727 }, + Case { id: "bettertls::nameconstraints::tc5598", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17731, 17732], leaf: 17730 }, + Case { id: "bettertls::nameconstraints::tc5599", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17734, 17735], leaf: 17733 }, + Case { id: "bettertls::nameconstraints::tc5600", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17737, 17738], leaf: 17736 }, + Case { id: "bettertls::nameconstraints::tc5601", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17740, 17741], leaf: 17739 }, + Case { id: "bettertls::nameconstraints::tc5602", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17743, 17744], leaf: 17742 }, + Case { id: "bettertls::nameconstraints::tc5603", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17746, 17747], leaf: 17745 }, + Case { id: "bettertls::nameconstraints::tc5604", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17749, 17750], leaf: 17748 }, + Case { id: "bettertls::nameconstraints::tc5605", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17752, 17753], leaf: 17751 }, + Case { id: "bettertls::nameconstraints::tc5606", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17755, 17756], leaf: 17754 }, + Case { id: "bettertls::nameconstraints::tc5607", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17758, 17759], leaf: 17757 }, + Case { id: "bettertls::nameconstraints::tc5608", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17761, 17762], leaf: 17760 }, + Case { id: "bettertls::nameconstraints::tc5609", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17764, 17765], leaf: 17763 }, + Case { id: "bettertls::nameconstraints::tc5610", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17767, 17768], leaf: 17766 }, + Case { id: "bettertls::nameconstraints::tc5611", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17770, 17771], leaf: 17769 }, + Case { id: "bettertls::nameconstraints::tc5612", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17773, 17774], leaf: 17772 }, + Case { id: "bettertls::nameconstraints::tc5613", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17776, 17777], leaf: 17775 }, + Case { id: "bettertls::nameconstraints::tc5614", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17779, 17780], leaf: 17778 }, + Case { id: "bettertls::nameconstraints::tc5615", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17782, 17783], leaf: 17781 }, + Case { id: "bettertls::nameconstraints::tc5616", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17785, 17786], leaf: 17784 }, + Case { id: "bettertls::nameconstraints::tc5617", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17788, 17789], leaf: 17787 }, + Case { id: "bettertls::nameconstraints::tc5618", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17791, 17792], leaf: 17790 }, + Case { id: "bettertls::nameconstraints::tc5619", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17794, 17795], leaf: 17793 }, + Case { id: "bettertls::nameconstraints::tc5620", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17797, 17798], leaf: 17796 }, + Case { id: "bettertls::nameconstraints::tc5621", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17800, 17801], leaf: 17799 }, + Case { id: "bettertls::nameconstraints::tc5622", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17803, 17804], leaf: 17802 }, + Case { id: "bettertls::nameconstraints::tc5623", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17806, 17807], leaf: 17805 }, + Case { id: "bettertls::nameconstraints::tc5624", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17809, 17810], leaf: 17808 }, + Case { id: "bettertls::nameconstraints::tc5625", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17812, 17813], leaf: 17811 }, + Case { id: "bettertls::nameconstraints::tc5626", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17815, 17816], leaf: 17814 }, + Case { id: "bettertls::nameconstraints::tc5627", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17818, 17819], leaf: 17817 }, + Case { id: "bettertls::nameconstraints::tc5628", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17821, 17822], leaf: 17820 }, + Case { id: "bettertls::nameconstraints::tc5629", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17824, 17825], leaf: 17823 }, + Case { id: "bettertls::nameconstraints::tc5630", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17827, 17828], leaf: 17826 }, + Case { id: "bettertls::nameconstraints::tc5631", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17830, 17831], leaf: 17829 }, + Case { id: "bettertls::nameconstraints::tc5632", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17833, 17834], leaf: 17832 }, + Case { id: "bettertls::nameconstraints::tc5633", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17836, 17837], leaf: 17835 }, + Case { id: "bettertls::nameconstraints::tc5634", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17839, 17840], leaf: 17838 }, + Case { id: "bettertls::nameconstraints::tc5635", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17842, 17843], leaf: 17841 }, + Case { id: "bettertls::nameconstraints::tc5636", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17845, 17846], leaf: 17844 }, + Case { id: "bettertls::nameconstraints::tc5637", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17848, 17849], leaf: 17847 }, + Case { id: "bettertls::nameconstraints::tc5638", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17851, 17852], leaf: 17850 }, + Case { id: "bettertls::nameconstraints::tc5639", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17854, 17855], leaf: 17853 }, + Case { id: "bettertls::nameconstraints::tc5640", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17857, 17858], leaf: 17856 }, + Case { id: "bettertls::nameconstraints::tc5641", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17860, 17861], leaf: 17859 }, + Case { id: "bettertls::nameconstraints::tc5642", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17863, 17864], leaf: 17862 }, + Case { id: "bettertls::nameconstraints::tc5643", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17866, 17867], leaf: 17865 }, + Case { id: "bettertls::nameconstraints::tc5644", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17869, 17870], leaf: 17868 }, + Case { id: "bettertls::nameconstraints::tc5645", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17872, 17873], leaf: 17871 }, + Case { id: "bettertls::nameconstraints::tc5646", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17875, 17876], leaf: 17874 }, + Case { id: "bettertls::nameconstraints::tc5647", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17878, 17879], leaf: 17877 }, + Case { id: "bettertls::nameconstraints::tc5648", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17881, 17882], leaf: 17880 }, + Case { id: "bettertls::nameconstraints::tc5649", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17884, 17885], leaf: 17883 }, + Case { id: "bettertls::nameconstraints::tc5650", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17887, 17888], leaf: 17886 }, + Case { id: "bettertls::nameconstraints::tc5651", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17890, 17891], leaf: 17889 }, + Case { id: "bettertls::nameconstraints::tc5652", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17893, 17894], leaf: 17892 }, + Case { id: "bettertls::nameconstraints::tc5653", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17896, 17897], leaf: 17895 }, + Case { id: "bettertls::nameconstraints::tc5654", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17899, 17900], leaf: 17898 }, + Case { id: "bettertls::nameconstraints::tc5655", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17902, 17903], leaf: 17901 }, + Case { id: "bettertls::nameconstraints::tc5656", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17905, 17906], leaf: 17904 }, + Case { id: "bettertls::nameconstraints::tc5657", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17908, 17909], leaf: 17907 }, + Case { id: "bettertls::nameconstraints::tc5658", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17911, 17912], leaf: 17910 }, + Case { id: "bettertls::nameconstraints::tc5659", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17914, 17915], leaf: 17913 }, + Case { id: "bettertls::nameconstraints::tc5660", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17917, 17918], leaf: 17916 }, + Case { id: "bettertls::nameconstraints::tc5661", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17920, 17921], leaf: 17919 }, + Case { id: "bettertls::nameconstraints::tc5662", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17923, 17924], leaf: 17922 }, + Case { id: "bettertls::nameconstraints::tc5663", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17926, 17927], leaf: 17925 }, + Case { id: "bettertls::nameconstraints::tc5664", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17929, 17930], leaf: 17928 }, + Case { id: "bettertls::nameconstraints::tc5665", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17932, 17933], leaf: 17931 }, + Case { id: "bettertls::nameconstraints::tc5666", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17935, 17936], leaf: 17934 }, + Case { id: "bettertls::nameconstraints::tc5667", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17938, 17939], leaf: 17937 }, + Case { id: "bettertls::nameconstraints::tc5668", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17941, 17942], leaf: 17940 }, + Case { id: "bettertls::nameconstraints::tc5669", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17944, 17945], leaf: 17943 }, + Case { id: "bettertls::nameconstraints::tc5670", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17947, 17948], leaf: 17946 }, + Case { id: "bettertls::nameconstraints::tc5671", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17950, 17951], leaf: 17949 }, + Case { id: "bettertls::nameconstraints::tc5672", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17953, 17954], leaf: 17952 }, + Case { id: "bettertls::nameconstraints::tc5673", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17956, 17957], leaf: 17955 }, + Case { id: "bettertls::nameconstraints::tc5674", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17959, 17960], leaf: 17958 }, + Case { id: "bettertls::nameconstraints::tc5675", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17962, 17963], leaf: 17961 }, + Case { id: "bettertls::nameconstraints::tc5676", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17965, 17966], leaf: 17964 }, + Case { id: "bettertls::nameconstraints::tc5677", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17968, 17969], leaf: 17967 }, + Case { id: "bettertls::nameconstraints::tc5678", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17971, 17972], leaf: 17970 }, + Case { id: "bettertls::nameconstraints::tc5679", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17974, 17975], leaf: 17973 }, + Case { id: "bettertls::nameconstraints::tc5680", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17977, 17978], leaf: 17976 }, + Case { id: "bettertls::nameconstraints::tc5681", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17980, 17981], leaf: 17979 }, + Case { id: "bettertls::nameconstraints::tc5682", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17983, 17984], leaf: 17982 }, + Case { id: "bettertls::nameconstraints::tc5683", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17986, 17987], leaf: 17985 }, + Case { id: "bettertls::nameconstraints::tc5684", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17989, 17990], leaf: 17988 }, + Case { id: "bettertls::nameconstraints::tc5685", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17992, 17993], leaf: 17991 }, + Case { id: "bettertls::nameconstraints::tc5686", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17995, 17996], leaf: 17994 }, + Case { id: "bettertls::nameconstraints::tc5687", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[17998, 17999], leaf: 17997 }, + Case { id: "bettertls::nameconstraints::tc5688", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18001, 18002], leaf: 18000 }, + Case { id: "bettertls::nameconstraints::tc5689", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18004, 18005], leaf: 18003 }, + Case { id: "bettertls::nameconstraints::tc5690", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18007, 18008], leaf: 18006 }, + Case { id: "bettertls::nameconstraints::tc5691", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18010, 18011], leaf: 18009 }, + Case { id: "bettertls::nameconstraints::tc5692", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18013, 18014], leaf: 18012 }, + Case { id: "bettertls::nameconstraints::tc5693", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18016, 18017], leaf: 18015 }, + Case { id: "bettertls::nameconstraints::tc5694", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18019, 18020], leaf: 18018 }, + Case { id: "bettertls::nameconstraints::tc5695", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18022, 18023], leaf: 18021 }, + Case { id: "bettertls::nameconstraints::tc5696", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18025, 18026], leaf: 18024 }, + Case { id: "bettertls::nameconstraints::tc5697", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18028, 18029], leaf: 18027 }, + Case { id: "bettertls::nameconstraints::tc5698", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18031, 18032], leaf: 18030 }, + Case { id: "bettertls::nameconstraints::tc5699", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18034, 18035], leaf: 18033 }, + Case { id: "bettertls::nameconstraints::tc5700", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18037, 18038], leaf: 18036 }, + Case { id: "bettertls::nameconstraints::tc5701", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18040, 18041], leaf: 18039 }, + Case { id: "bettertls::nameconstraints::tc5702", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18043, 18044], leaf: 18042 }, + Case { id: "bettertls::nameconstraints::tc5703", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18046, 18047], leaf: 18045 }, + Case { id: "bettertls::nameconstraints::tc5704", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18049, 18050], leaf: 18048 }, + Case { id: "bettertls::nameconstraints::tc5705", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18052, 18053], leaf: 18051 }, + Case { id: "bettertls::nameconstraints::tc5706", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18055, 18056], leaf: 18054 }, + Case { id: "bettertls::nameconstraints::tc5707", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18058, 18059], leaf: 18057 }, + Case { id: "bettertls::nameconstraints::tc5708", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18061, 18062], leaf: 18060 }, + Case { id: "bettertls::nameconstraints::tc5709", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18064, 18065], leaf: 18063 }, + Case { id: "bettertls::nameconstraints::tc5710", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18067, 18068], leaf: 18066 }, + Case { id: "bettertls::nameconstraints::tc5711", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18070, 18071], leaf: 18069 }, + Case { id: "bettertls::nameconstraints::tc5712", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18073, 18074], leaf: 18072 }, + Case { id: "bettertls::nameconstraints::tc5713", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18076, 18077], leaf: 18075 }, + Case { id: "bettertls::nameconstraints::tc5714", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18079, 18080], leaf: 18078 }, + Case { id: "bettertls::nameconstraints::tc5715", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18082, 18083], leaf: 18081 }, + Case { id: "bettertls::nameconstraints::tc5716", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18085, 18086], leaf: 18084 }, + Case { id: "bettertls::nameconstraints::tc5717", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18088, 18089], leaf: 18087 }, + Case { id: "bettertls::nameconstraints::tc5718", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18091, 18092], leaf: 18090 }, + Case { id: "bettertls::nameconstraints::tc5719", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18094, 18095], leaf: 18093 }, + Case { id: "bettertls::nameconstraints::tc5720", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18097, 18098], leaf: 18096 }, + Case { id: "bettertls::nameconstraints::tc5721", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18100, 18101], leaf: 18099 }, + Case { id: "bettertls::nameconstraints::tc5722", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18103, 18104], leaf: 18102 }, + Case { id: "bettertls::nameconstraints::tc5723", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18106, 18107], leaf: 18105 }, + Case { id: "bettertls::nameconstraints::tc5724", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18109, 18110], leaf: 18108 }, + Case { id: "bettertls::nameconstraints::tc5725", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18112, 18113], leaf: 18111 }, + Case { id: "bettertls::nameconstraints::tc5726", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18115, 18116], leaf: 18114 }, + Case { id: "bettertls::nameconstraints::tc5727", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18118, 18119], leaf: 18117 }, + Case { id: "bettertls::nameconstraints::tc5728", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18121, 18122], leaf: 18120 }, + Case { id: "bettertls::nameconstraints::tc5729", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18124, 18125], leaf: 18123 }, + Case { id: "bettertls::nameconstraints::tc5730", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18127, 18128], leaf: 18126 }, + Case { id: "bettertls::nameconstraints::tc5731", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18130, 18131], leaf: 18129 }, + Case { id: "bettertls::nameconstraints::tc5732", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18133, 18134], leaf: 18132 }, + Case { id: "bettertls::nameconstraints::tc5733", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18136, 18137], leaf: 18135 }, + Case { id: "bettertls::nameconstraints::tc5734", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18139, 18140], leaf: 18138 }, + Case { id: "bettertls::nameconstraints::tc5735", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18142, 18143], leaf: 18141 }, + Case { id: "bettertls::nameconstraints::tc5736", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18145, 18146], leaf: 18144 }, + Case { id: "bettertls::nameconstraints::tc5737", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18148, 18149], leaf: 18147 }, + Case { id: "bettertls::nameconstraints::tc5738", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18151, 18152], leaf: 18150 }, + Case { id: "bettertls::nameconstraints::tc5739", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18154, 18155], leaf: 18153 }, + Case { id: "bettertls::nameconstraints::tc5740", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18157, 18158], leaf: 18156 }, + Case { id: "bettertls::nameconstraints::tc5741", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18160, 18161], leaf: 18159 }, + Case { id: "bettertls::nameconstraints::tc5742", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18163, 18164], leaf: 18162 }, + Case { id: "bettertls::nameconstraints::tc5743", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18166, 18167], leaf: 18165 }, + Case { id: "bettertls::nameconstraints::tc5744", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18169, 18170], leaf: 18168 }, + Case { id: "bettertls::nameconstraints::tc5745", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18172, 18173], leaf: 18171 }, + Case { id: "bettertls::nameconstraints::tc5746", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18175, 18176], leaf: 18174 }, + Case { id: "bettertls::nameconstraints::tc5747", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18178, 18179], leaf: 18177 }, + Case { id: "bettertls::nameconstraints::tc5748", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18181, 18182], leaf: 18180 }, + Case { id: "bettertls::nameconstraints::tc5749", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18184, 18185], leaf: 18183 }, + Case { id: "bettertls::nameconstraints::tc5750", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18187, 18188], leaf: 18186 }, + Case { id: "bettertls::nameconstraints::tc5751", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18190, 18191], leaf: 18189 }, + Case { id: "bettertls::nameconstraints::tc5752", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18193, 18194], leaf: 18192 }, + Case { id: "bettertls::nameconstraints::tc5753", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18196, 18197], leaf: 18195 }, + Case { id: "bettertls::nameconstraints::tc5754", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18199, 18200], leaf: 18198 }, + Case { id: "bettertls::nameconstraints::tc5755", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18202, 18203], leaf: 18201 }, + Case { id: "bettertls::nameconstraints::tc5756", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18205, 18206], leaf: 18204 }, + Case { id: "bettertls::nameconstraints::tc5757", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18208, 18209], leaf: 18207 }, + Case { id: "bettertls::nameconstraints::tc5758", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18211, 18212], leaf: 18210 }, + Case { id: "bettertls::nameconstraints::tc5759", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18214, 18215], leaf: 18213 }, + Case { id: "bettertls::nameconstraints::tc5760", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18217, 18218], leaf: 18216 }, + Case { id: "bettertls::nameconstraints::tc5761", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18220, 18221], leaf: 18219 }, + Case { id: "bettertls::nameconstraints::tc5762", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18223, 18224], leaf: 18222 }, + Case { id: "bettertls::nameconstraints::tc5763", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18226, 18227], leaf: 18225 }, + Case { id: "bettertls::nameconstraints::tc5764", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18229, 18230], leaf: 18228 }, + Case { id: "bettertls::nameconstraints::tc5765", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18232, 18233], leaf: 18231 }, + Case { id: "bettertls::nameconstraints::tc5766", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18235, 18236], leaf: 18234 }, + Case { id: "bettertls::nameconstraints::tc5767", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18238, 18239], leaf: 18237 }, + Case { id: "bettertls::nameconstraints::tc5768", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18241, 18242], leaf: 18240 }, + Case { id: "bettertls::nameconstraints::tc5769", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18244, 18245], leaf: 18243 }, + Case { id: "bettertls::nameconstraints::tc5770", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18247, 18248], leaf: 18246 }, + Case { id: "bettertls::nameconstraints::tc5771", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18250, 18251], leaf: 18249 }, + Case { id: "bettertls::nameconstraints::tc5772", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18253, 18254], leaf: 18252 }, + Case { id: "bettertls::nameconstraints::tc5773", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18256, 18257], leaf: 18255 }, + Case { id: "bettertls::nameconstraints::tc5774", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18259, 18260], leaf: 18258 }, + Case { id: "bettertls::nameconstraints::tc5775", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18262, 18263], leaf: 18261 }, + Case { id: "bettertls::nameconstraints::tc5776", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18265, 18266], leaf: 18264 }, + Case { id: "bettertls::nameconstraints::tc5777", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18268, 18269], leaf: 18267 }, + Case { id: "bettertls::nameconstraints::tc5778", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18271, 18272], leaf: 18270 }, + Case { id: "bettertls::nameconstraints::tc5779", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18274, 18275], leaf: 18273 }, + Case { id: "bettertls::nameconstraints::tc5780", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18277, 18278], leaf: 18276 }, + Case { id: "bettertls::nameconstraints::tc5781", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18280, 18281], leaf: 18279 }, + Case { id: "bettertls::nameconstraints::tc5782", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18283, 18284], leaf: 18282 }, + Case { id: "bettertls::nameconstraints::tc5783", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18286, 18287], leaf: 18285 }, + Case { id: "bettertls::nameconstraints::tc5784", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18289, 18290], leaf: 18288 }, + Case { id: "bettertls::nameconstraints::tc5785", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18292, 18293], leaf: 18291 }, + Case { id: "bettertls::nameconstraints::tc5786", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18295, 18296], leaf: 18294 }, + Case { id: "bettertls::nameconstraints::tc5787", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18298, 18299], leaf: 18297 }, + Case { id: "bettertls::nameconstraints::tc5788", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18301, 18302], leaf: 18300 }, + Case { id: "bettertls::nameconstraints::tc5789", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18304, 18305], leaf: 18303 }, + Case { id: "bettertls::nameconstraints::tc5790", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18307, 18308], leaf: 18306 }, + Case { id: "bettertls::nameconstraints::tc5791", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18310, 18311], leaf: 18309 }, + Case { id: "bettertls::nameconstraints::tc5792", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18313, 18314], leaf: 18312 }, + Case { id: "bettertls::nameconstraints::tc5793", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18316, 18317], leaf: 18315 }, + Case { id: "bettertls::nameconstraints::tc5794", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18319, 18320], leaf: 18318 }, + Case { id: "bettertls::nameconstraints::tc5795", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18322, 18323], leaf: 18321 }, + Case { id: "bettertls::nameconstraints::tc5796", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18325, 18326], leaf: 18324 }, + Case { id: "bettertls::nameconstraints::tc5797", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18328, 18329], leaf: 18327 }, + Case { id: "bettertls::nameconstraints::tc5798", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18331, 18332], leaf: 18330 }, + Case { id: "bettertls::nameconstraints::tc5799", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18334, 18335], leaf: 18333 }, + Case { id: "bettertls::nameconstraints::tc5800", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18337, 18338], leaf: 18336 }, + Case { id: "bettertls::nameconstraints::tc5801", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18340, 18341], leaf: 18339 }, + Case { id: "bettertls::nameconstraints::tc5802", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18343, 18344], leaf: 18342 }, + Case { id: "bettertls::nameconstraints::tc5803", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18346, 18347], leaf: 18345 }, + Case { id: "bettertls::nameconstraints::tc5804", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18349, 18350], leaf: 18348 }, + Case { id: "bettertls::nameconstraints::tc5805", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18352, 18353], leaf: 18351 }, + Case { id: "bettertls::nameconstraints::tc5806", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18355, 18356], leaf: 18354 }, + Case { id: "bettertls::nameconstraints::tc5807", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18358, 18359], leaf: 18357 }, + Case { id: "bettertls::nameconstraints::tc5808", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18361, 18362], leaf: 18360 }, + Case { id: "bettertls::nameconstraints::tc5809", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18364, 18365], leaf: 18363 }, + Case { id: "bettertls::nameconstraints::tc5810", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18367, 18368], leaf: 18366 }, + Case { id: "bettertls::nameconstraints::tc5811", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18370, 18371], leaf: 18369 }, + Case { id: "bettertls::nameconstraints::tc5812", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18373, 18374], leaf: 18372 }, + Case { id: "bettertls::nameconstraints::tc5813", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18376, 18377], leaf: 18375 }, + Case { id: "bettertls::nameconstraints::tc5814", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18379, 18380], leaf: 18378 }, + Case { id: "bettertls::nameconstraints::tc5815", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18382, 18383], leaf: 18381 }, + Case { id: "bettertls::nameconstraints::tc5816", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18385, 18386], leaf: 18384 }, + Case { id: "bettertls::nameconstraints::tc5817", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18388, 18389], leaf: 18387 }, + Case { id: "bettertls::nameconstraints::tc5818", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18391, 18392], leaf: 18390 }, + Case { id: "bettertls::nameconstraints::tc5819", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18394, 18395], leaf: 18393 }, + Case { id: "bettertls::nameconstraints::tc5820", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18397, 18398], leaf: 18396 }, + Case { id: "bettertls::nameconstraints::tc5821", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18400, 18401], leaf: 18399 }, + Case { id: "bettertls::nameconstraints::tc5822", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18403, 18404], leaf: 18402 }, + Case { id: "bettertls::nameconstraints::tc5823", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18406, 18407], leaf: 18405 }, + Case { id: "bettertls::nameconstraints::tc5824", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18409, 18410], leaf: 18408 }, + Case { id: "bettertls::nameconstraints::tc5825", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18412, 18413], leaf: 18411 }, + Case { id: "bettertls::nameconstraints::tc5826", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18415, 18416], leaf: 18414 }, + Case { id: "bettertls::nameconstraints::tc5827", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18418, 18419], leaf: 18417 }, + Case { id: "bettertls::nameconstraints::tc5828", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18421, 18422], leaf: 18420 }, + Case { id: "bettertls::nameconstraints::tc5829", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18424, 18425], leaf: 18423 }, + Case { id: "bettertls::nameconstraints::tc5830", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18427, 18428], leaf: 18426 }, + Case { id: "bettertls::nameconstraints::tc5831", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18430, 18431], leaf: 18429 }, + Case { id: "bettertls::nameconstraints::tc5832", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18433, 18434], leaf: 18432 }, + Case { id: "bettertls::nameconstraints::tc5833", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18436, 18437], leaf: 18435 }, + Case { id: "bettertls::nameconstraints::tc5834", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18439, 18440], leaf: 18438 }, + Case { id: "bettertls::nameconstraints::tc5835", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18442, 18443], leaf: 18441 }, + Case { id: "bettertls::nameconstraints::tc5836", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18445, 18446], leaf: 18444 }, + Case { id: "bettertls::nameconstraints::tc5837", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18448, 18449], leaf: 18447 }, + Case { id: "bettertls::nameconstraints::tc5838", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18451, 18452], leaf: 18450 }, + Case { id: "bettertls::nameconstraints::tc5839", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18454, 18455], leaf: 18453 }, + Case { id: "bettertls::nameconstraints::tc5840", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18457, 18458], leaf: 18456 }, + Case { id: "bettertls::nameconstraints::tc5841", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18460, 18461], leaf: 18459 }, + Case { id: "bettertls::nameconstraints::tc5842", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18463, 18464], leaf: 18462 }, + Case { id: "bettertls::nameconstraints::tc5843", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18466, 18467], leaf: 18465 }, + Case { id: "bettertls::nameconstraints::tc5844", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18469, 18470], leaf: 18468 }, + Case { id: "bettertls::nameconstraints::tc5845", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18472, 18473], leaf: 18471 }, + Case { id: "bettertls::nameconstraints::tc5846", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18475, 18476], leaf: 18474 }, + Case { id: "bettertls::nameconstraints::tc5847", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18478, 18479], leaf: 18477 }, + Case { id: "bettertls::nameconstraints::tc5848", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18481, 18482], leaf: 18480 }, + Case { id: "bettertls::nameconstraints::tc5849", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18484, 18485], leaf: 18483 }, + Case { id: "bettertls::nameconstraints::tc5850", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18487, 18488], leaf: 18486 }, + Case { id: "bettertls::nameconstraints::tc5851", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18490, 18491], leaf: 18489 }, + Case { id: "bettertls::nameconstraints::tc5852", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18493, 18494], leaf: 18492 }, + Case { id: "bettertls::nameconstraints::tc5853", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18496, 18497], leaf: 18495 }, + Case { id: "bettertls::nameconstraints::tc5854", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18499, 18500], leaf: 18498 }, + Case { id: "bettertls::nameconstraints::tc5855", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18502, 18503], leaf: 18501 }, + Case { id: "bettertls::nameconstraints::tc5856", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18505, 18506], leaf: 18504 }, + Case { id: "bettertls::nameconstraints::tc5857", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18508, 18509], leaf: 18507 }, + Case { id: "bettertls::nameconstraints::tc5858", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18511, 18512], leaf: 18510 }, + Case { id: "bettertls::nameconstraints::tc5859", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18514, 18515], leaf: 18513 }, + Case { id: "bettertls::nameconstraints::tc5860", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18517, 18518], leaf: 18516 }, + Case { id: "bettertls::nameconstraints::tc5861", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18520, 18521], leaf: 18519 }, + Case { id: "bettertls::nameconstraints::tc5862", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18523, 18524], leaf: 18522 }, + Case { id: "bettertls::nameconstraints::tc5863", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18526, 18527], leaf: 18525 }, + Case { id: "bettertls::nameconstraints::tc5864", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18529, 18530], leaf: 18528 }, + Case { id: "bettertls::nameconstraints::tc5865", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18532, 18533], leaf: 18531 }, + Case { id: "bettertls::nameconstraints::tc5866", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18535, 18536], leaf: 18534 }, + Case { id: "bettertls::nameconstraints::tc5867", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18538, 18539], leaf: 18537 }, + Case { id: "bettertls::nameconstraints::tc5868", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18541, 18542], leaf: 18540 }, + Case { id: "bettertls::nameconstraints::tc5869", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18544, 18545], leaf: 18543 }, + Case { id: "bettertls::nameconstraints::tc5870", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18547, 18548], leaf: 18546 }, + Case { id: "bettertls::nameconstraints::tc5871", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18550, 18551], leaf: 18549 }, + Case { id: "bettertls::nameconstraints::tc5872", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18553, 18554], leaf: 18552 }, + Case { id: "bettertls::nameconstraints::tc5873", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18556, 18557], leaf: 18555 }, + Case { id: "bettertls::nameconstraints::tc5874", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18559, 18560], leaf: 18558 }, + Case { id: "bettertls::nameconstraints::tc5875", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18562, 18563], leaf: 18561 }, + Case { id: "bettertls::nameconstraints::tc5876", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18565, 18566], leaf: 18564 }, + Case { id: "bettertls::nameconstraints::tc5877", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18568, 18569], leaf: 18567 }, + Case { id: "bettertls::nameconstraints::tc5878", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18571, 18572], leaf: 18570 }, + Case { id: "bettertls::nameconstraints::tc5879", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18574, 18575], leaf: 18573 }, + Case { id: "bettertls::nameconstraints::tc5880", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18577, 18578], leaf: 18576 }, + Case { id: "bettertls::nameconstraints::tc5881", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18580, 18581], leaf: 18579 }, + Case { id: "bettertls::nameconstraints::tc5882", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18583, 18584], leaf: 18582 }, + Case { id: "bettertls::nameconstraints::tc5883", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18586, 18587], leaf: 18585 }, + Case { id: "bettertls::nameconstraints::tc5884", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18589, 18590], leaf: 18588 }, + Case { id: "bettertls::nameconstraints::tc5885", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18592, 18593], leaf: 18591 }, + Case { id: "bettertls::nameconstraints::tc5886", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18595, 18596], leaf: 18594 }, + Case { id: "bettertls::nameconstraints::tc5887", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18598, 18599], leaf: 18597 }, + Case { id: "bettertls::nameconstraints::tc5888", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18601, 18602], leaf: 18600 }, + Case { id: "bettertls::nameconstraints::tc5889", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18604, 18605], leaf: 18603 }, + Case { id: "bettertls::nameconstraints::tc5890", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18607, 18608], leaf: 18606 }, + Case { id: "bettertls::nameconstraints::tc5891", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18610, 18611], leaf: 18609 }, + Case { id: "bettertls::nameconstraints::tc5892", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18613, 18614], leaf: 18612 }, + Case { id: "bettertls::nameconstraints::tc5893", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18616, 18617], leaf: 18615 }, + Case { id: "bettertls::nameconstraints::tc5894", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18619, 18620], leaf: 18618 }, + Case { id: "bettertls::nameconstraints::tc5895", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18622, 18623], leaf: 18621 }, + Case { id: "bettertls::nameconstraints::tc5896", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18625, 18626], leaf: 18624 }, + Case { id: "bettertls::nameconstraints::tc5897", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18628, 18629], leaf: 18627 }, + Case { id: "bettertls::nameconstraints::tc5898", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18631, 18632], leaf: 18630 }, + Case { id: "bettertls::nameconstraints::tc5899", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18634, 18635], leaf: 18633 }, + Case { id: "bettertls::nameconstraints::tc5900", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18637, 18638], leaf: 18636 }, + Case { id: "bettertls::nameconstraints::tc5901", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18640, 18641], leaf: 18639 }, + Case { id: "bettertls::nameconstraints::tc5902", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18643, 18644], leaf: 18642 }, + Case { id: "bettertls::nameconstraints::tc5903", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18646, 18647], leaf: 18645 }, + Case { id: "bettertls::nameconstraints::tc5904", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18649, 18650], leaf: 18648 }, + Case { id: "bettertls::nameconstraints::tc5905", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18652, 18653], leaf: 18651 }, + Case { id: "bettertls::nameconstraints::tc5906", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18655, 18656], leaf: 18654 }, + Case { id: "bettertls::nameconstraints::tc5907", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18658, 18659], leaf: 18657 }, + Case { id: "bettertls::nameconstraints::tc5908", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18661, 18662], leaf: 18660 }, + Case { id: "bettertls::nameconstraints::tc5909", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18664, 18665], leaf: 18663 }, + Case { id: "bettertls::nameconstraints::tc5910", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18667, 18668], leaf: 18666 }, + Case { id: "bettertls::nameconstraints::tc5911", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18670, 18671], leaf: 18669 }, + Case { id: "bettertls::nameconstraints::tc5912", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18673, 18674], leaf: 18672 }, + Case { id: "bettertls::nameconstraints::tc5913", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18676, 18677], leaf: 18675 }, + Case { id: "bettertls::nameconstraints::tc5914", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18679, 18680], leaf: 18678 }, + Case { id: "bettertls::nameconstraints::tc5915", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18682, 18683], leaf: 18681 }, + Case { id: "bettertls::nameconstraints::tc5916", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18685, 18686], leaf: 18684 }, + Case { id: "bettertls::nameconstraints::tc5917", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18688, 18689], leaf: 18687 }, + Case { id: "bettertls::nameconstraints::tc5918", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18691, 18692], leaf: 18690 }, + Case { id: "bettertls::nameconstraints::tc5919", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18694, 18695], leaf: 18693 }, + Case { id: "bettertls::nameconstraints::tc5920", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18697, 18698], leaf: 18696 }, + Case { id: "bettertls::nameconstraints::tc5921", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18700, 18701], leaf: 18699 }, + Case { id: "bettertls::nameconstraints::tc5922", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18703, 18704], leaf: 18702 }, + Case { id: "bettertls::nameconstraints::tc5923", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18706, 18707], leaf: 18705 }, + Case { id: "bettertls::nameconstraints::tc5924", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18709, 18710], leaf: 18708 }, + Case { id: "bettertls::nameconstraints::tc5925", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18712, 18713], leaf: 18711 }, + Case { id: "bettertls::nameconstraints::tc5926", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18715, 18716], leaf: 18714 }, + Case { id: "bettertls::nameconstraints::tc5927", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18718, 18719], leaf: 18717 }, + Case { id: "bettertls::nameconstraints::tc5928", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18721, 18722], leaf: 18720 }, + Case { id: "bettertls::nameconstraints::tc5929", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18724, 18725], leaf: 18723 }, + Case { id: "bettertls::nameconstraints::tc5930", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18727, 18728], leaf: 18726 }, + Case { id: "bettertls::nameconstraints::tc5931", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18730, 18731], leaf: 18729 }, + Case { id: "bettertls::nameconstraints::tc5932", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18733, 18734], leaf: 18732 }, + Case { id: "bettertls::nameconstraints::tc5933", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18736, 18737], leaf: 18735 }, + Case { id: "bettertls::nameconstraints::tc5934", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18739, 18740], leaf: 18738 }, + Case { id: "bettertls::nameconstraints::tc5935", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18742, 18743], leaf: 18741 }, + Case { id: "bettertls::nameconstraints::tc5936", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18745, 18746], leaf: 18744 }, + Case { id: "bettertls::nameconstraints::tc5937", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18748, 18749], leaf: 18747 }, + Case { id: "bettertls::nameconstraints::tc5938", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18751, 18752], leaf: 18750 }, + Case { id: "bettertls::nameconstraints::tc5939", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18754, 18755], leaf: 18753 }, + Case { id: "bettertls::nameconstraints::tc5940", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18757, 18758], leaf: 18756 }, + Case { id: "bettertls::nameconstraints::tc5941", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18760, 18761], leaf: 18759 }, + Case { id: "bettertls::nameconstraints::tc5942", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18763, 18764], leaf: 18762 }, + Case { id: "bettertls::nameconstraints::tc5943", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18766, 18767], leaf: 18765 }, + Case { id: "bettertls::nameconstraints::tc5944", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18769, 18770], leaf: 18768 }, + Case { id: "bettertls::nameconstraints::tc5945", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18772, 18773], leaf: 18771 }, + Case { id: "bettertls::nameconstraints::tc5946", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18775, 18776], leaf: 18774 }, + Case { id: "bettertls::nameconstraints::tc5947", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18778, 18779], leaf: 18777 }, + Case { id: "bettertls::nameconstraints::tc5948", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18781, 18782], leaf: 18780 }, + Case { id: "bettertls::nameconstraints::tc5949", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18784, 18785], leaf: 18783 }, + Case { id: "bettertls::nameconstraints::tc5950", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18787, 18788], leaf: 18786 }, + Case { id: "bettertls::nameconstraints::tc5951", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18790, 18791], leaf: 18789 }, + Case { id: "bettertls::nameconstraints::tc5952", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18793, 18794], leaf: 18792 }, + Case { id: "bettertls::nameconstraints::tc5953", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18796, 18797], leaf: 18795 }, + Case { id: "bettertls::nameconstraints::tc5954", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18799, 18800], leaf: 18798 }, + Case { id: "bettertls::nameconstraints::tc5955", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18802, 18803], leaf: 18801 }, + Case { id: "bettertls::nameconstraints::tc5956", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18805, 18806], leaf: 18804 }, + Case { id: "bettertls::nameconstraints::tc5957", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18808, 18809], leaf: 18807 }, + Case { id: "bettertls::nameconstraints::tc5958", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18811, 18812], leaf: 18810 }, + Case { id: "bettertls::nameconstraints::tc5959", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18814, 18815], leaf: 18813 }, + Case { id: "bettertls::nameconstraints::tc5960", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18817, 18818], leaf: 18816 }, + Case { id: "bettertls::nameconstraints::tc5961", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18820, 18821], leaf: 18819 }, + Case { id: "bettertls::nameconstraints::tc5962", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18823, 18824], leaf: 18822 }, + Case { id: "bettertls::nameconstraints::tc5963", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18826, 18827], leaf: 18825 }, + Case { id: "bettertls::nameconstraints::tc5964", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18829, 18830], leaf: 18828 }, + Case { id: "bettertls::nameconstraints::tc5965", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18832, 18833], leaf: 18831 }, + Case { id: "bettertls::nameconstraints::tc5966", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18835, 18836], leaf: 18834 }, + Case { id: "bettertls::nameconstraints::tc5967", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18838, 18839], leaf: 18837 }, + Case { id: "bettertls::nameconstraints::tc5968", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18841, 18842], leaf: 18840 }, + Case { id: "bettertls::nameconstraints::tc5969", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18844, 18845], leaf: 18843 }, + Case { id: "bettertls::nameconstraints::tc5970", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18847, 18848], leaf: 18846 }, + Case { id: "bettertls::nameconstraints::tc5971", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18850, 18851], leaf: 18849 }, + Case { id: "bettertls::nameconstraints::tc5972", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18853, 18854], leaf: 18852 }, + Case { id: "bettertls::nameconstraints::tc5973", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18856, 18857], leaf: 18855 }, + Case { id: "bettertls::nameconstraints::tc5974", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18859, 18860], leaf: 18858 }, + Case { id: "bettertls::nameconstraints::tc5975", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18862, 18863], leaf: 18861 }, + Case { id: "bettertls::nameconstraints::tc5976", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18865, 18866], leaf: 18864 }, + Case { id: "bettertls::nameconstraints::tc5977", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18868, 18869], leaf: 18867 }, + Case { id: "bettertls::nameconstraints::tc5978", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18871, 18872], leaf: 18870 }, + Case { id: "bettertls::nameconstraints::tc5979", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18874, 18875], leaf: 18873 }, + Case { id: "bettertls::nameconstraints::tc5980", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18877, 18878], leaf: 18876 }, + Case { id: "bettertls::nameconstraints::tc5981", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18880, 18881], leaf: 18879 }, + Case { id: "bettertls::nameconstraints::tc5982", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18883, 18884], leaf: 18882 }, + Case { id: "bettertls::nameconstraints::tc5983", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18886, 18887], leaf: 18885 }, + Case { id: "bettertls::nameconstraints::tc5984", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18889, 18890], leaf: 18888 }, + Case { id: "bettertls::nameconstraints::tc5985", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18892, 18893], leaf: 18891 }, + Case { id: "bettertls::nameconstraints::tc5986", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18895, 18896], leaf: 18894 }, + Case { id: "bettertls::nameconstraints::tc5987", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18898, 18899], leaf: 18897 }, + Case { id: "bettertls::nameconstraints::tc5988", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18901, 18902], leaf: 18900 }, + Case { id: "bettertls::nameconstraints::tc5989", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18904, 18905], leaf: 18903 }, + Case { id: "bettertls::nameconstraints::tc5990", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18907, 18908], leaf: 18906 }, + Case { id: "bettertls::nameconstraints::tc5991", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18910, 18911], leaf: 18909 }, + Case { id: "bettertls::nameconstraints::tc5992", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18913, 18914], leaf: 18912 }, + Case { id: "bettertls::nameconstraints::tc5993", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18916, 18917], leaf: 18915 }, + Case { id: "bettertls::nameconstraints::tc5994", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18919, 18920], leaf: 18918 }, + Case { id: "bettertls::nameconstraints::tc5995", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18922, 18923], leaf: 18921 }, + Case { id: "bettertls::nameconstraints::tc5996", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18925, 18926], leaf: 18924 }, + Case { id: "bettertls::nameconstraints::tc5997", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18928, 18929], leaf: 18927 }, + Case { id: "bettertls::nameconstraints::tc5998", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18931, 18932], leaf: 18930 }, + Case { id: "bettertls::nameconstraints::tc5999", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18934, 18935], leaf: 18933 }, + Case { id: "bettertls::nameconstraints::tc6000", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18937, 18938], leaf: 18936 }, + Case { id: "bettertls::nameconstraints::tc6001", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18940, 18941], leaf: 18939 }, + Case { id: "bettertls::nameconstraints::tc6002", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18943, 18944], leaf: 18942 }, + Case { id: "bettertls::nameconstraints::tc6003", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18946, 18947], leaf: 18945 }, + Case { id: "bettertls::nameconstraints::tc6004", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18949, 18950], leaf: 18948 }, + Case { id: "bettertls::nameconstraints::tc6005", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18952, 18953], leaf: 18951 }, + Case { id: "bettertls::nameconstraints::tc6006", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18955, 18956], leaf: 18954 }, + Case { id: "bettertls::nameconstraints::tc6007", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18958, 18959], leaf: 18957 }, + Case { id: "bettertls::nameconstraints::tc6008", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18961, 18962], leaf: 18960 }, + Case { id: "bettertls::nameconstraints::tc6009", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18964, 18965], leaf: 18963 }, + Case { id: "bettertls::nameconstraints::tc6010", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18967, 18968], leaf: 18966 }, + Case { id: "bettertls::nameconstraints::tc6011", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18970, 18971], leaf: 18969 }, + Case { id: "bettertls::nameconstraints::tc6012", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18973, 18974], leaf: 18972 }, + Case { id: "bettertls::nameconstraints::tc6013", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18976, 18977], leaf: 18975 }, + Case { id: "bettertls::nameconstraints::tc6014", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18979, 18980], leaf: 18978 }, + Case { id: "bettertls::nameconstraints::tc6015", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18982, 18983], leaf: 18981 }, + Case { id: "bettertls::nameconstraints::tc6016", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18985, 18986], leaf: 18984 }, + Case { id: "bettertls::nameconstraints::tc6017", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18988, 18989], leaf: 18987 }, + Case { id: "bettertls::nameconstraints::tc6018", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18991, 18992], leaf: 18990 }, + Case { id: "bettertls::nameconstraints::tc6019", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18994, 18995], leaf: 18993 }, + Case { id: "bettertls::nameconstraints::tc6020", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[18997, 18998], leaf: 18996 }, + Case { id: "bettertls::nameconstraints::tc6021", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19000, 19001], leaf: 18999 }, + Case { id: "bettertls::nameconstraints::tc6022", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19003, 19004], leaf: 19002 }, + Case { id: "bettertls::nameconstraints::tc6023", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19006, 19007], leaf: 19005 }, + Case { id: "bettertls::nameconstraints::tc6024", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19009, 19010], leaf: 19008 }, + Case { id: "bettertls::nameconstraints::tc6025", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19012, 19013], leaf: 19011 }, + Case { id: "bettertls::nameconstraints::tc6026", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19015, 19016], leaf: 19014 }, + Case { id: "bettertls::nameconstraints::tc6027", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19018, 19019], leaf: 19017 }, + Case { id: "bettertls::nameconstraints::tc6028", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19021, 19022], leaf: 19020 }, + Case { id: "bettertls::nameconstraints::tc6029", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19024, 19025], leaf: 19023 }, + Case { id: "bettertls::nameconstraints::tc6030", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19027, 19028], leaf: 19026 }, + Case { id: "bettertls::nameconstraints::tc6031", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19030, 19031], leaf: 19029 }, + Case { id: "bettertls::nameconstraints::tc6032", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19033, 19034], leaf: 19032 }, + Case { id: "bettertls::nameconstraints::tc6033", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19036, 19037], leaf: 19035 }, + Case { id: "bettertls::nameconstraints::tc6034", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19039, 19040], leaf: 19038 }, + Case { id: "bettertls::nameconstraints::tc6035", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19042, 19043], leaf: 19041 }, + Case { id: "bettertls::nameconstraints::tc6036", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19045, 19046], leaf: 19044 }, + Case { id: "bettertls::nameconstraints::tc6037", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19048, 19049], leaf: 19047 }, + Case { id: "bettertls::nameconstraints::tc6038", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19051, 19052], leaf: 19050 }, + Case { id: "bettertls::nameconstraints::tc6039", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19054, 19055], leaf: 19053 }, + Case { id: "bettertls::nameconstraints::tc6040", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19057, 19058], leaf: 19056 }, + Case { id: "bettertls::nameconstraints::tc6041", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19060, 19061], leaf: 19059 }, + Case { id: "bettertls::nameconstraints::tc6042", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19063, 19064], leaf: 19062 }, + Case { id: "bettertls::nameconstraints::tc6043", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19066, 19067], leaf: 19065 }, + Case { id: "bettertls::nameconstraints::tc6044", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19069, 19070], leaf: 19068 }, + Case { id: "bettertls::nameconstraints::tc6045", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19072, 19073], leaf: 19071 }, + Case { id: "bettertls::nameconstraints::tc6046", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19075, 19076], leaf: 19074 }, + Case { id: "bettertls::nameconstraints::tc6047", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19078, 19079], leaf: 19077 }, + Case { id: "bettertls::nameconstraints::tc6048", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19081, 19082], leaf: 19080 }, + Case { id: "bettertls::nameconstraints::tc6049", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19084, 19085], leaf: 19083 }, + Case { id: "bettertls::nameconstraints::tc6050", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19087, 19088], leaf: 19086 }, + Case { id: "bettertls::nameconstraints::tc6051", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19090, 19091], leaf: 19089 }, + Case { id: "bettertls::nameconstraints::tc6052", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19093, 19094], leaf: 19092 }, + Case { id: "bettertls::nameconstraints::tc6053", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19096, 19097], leaf: 19095 }, + Case { id: "bettertls::nameconstraints::tc6054", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19099, 19100], leaf: 19098 }, + Case { id: "bettertls::nameconstraints::tc6055", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19102, 19103], leaf: 19101 }, + Case { id: "bettertls::nameconstraints::tc6056", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19105, 19106], leaf: 19104 }, + Case { id: "bettertls::nameconstraints::tc6057", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19108, 19109], leaf: 19107 }, + Case { id: "bettertls::nameconstraints::tc6058", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19111, 19112], leaf: 19110 }, + Case { id: "bettertls::nameconstraints::tc6059", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19114, 19115], leaf: 19113 }, + Case { id: "bettertls::nameconstraints::tc6060", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19117, 19118], leaf: 19116 }, + Case { id: "bettertls::nameconstraints::tc6061", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19120, 19121], leaf: 19119 }, + Case { id: "bettertls::nameconstraints::tc6062", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19123, 19124], leaf: 19122 }, + Case { id: "bettertls::nameconstraints::tc6063", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19126, 19127], leaf: 19125 }, + Case { id: "bettertls::nameconstraints::tc6064", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19129, 19130], leaf: 19128 }, + Case { id: "bettertls::nameconstraints::tc6065", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19132, 19133], leaf: 19131 }, + Case { id: "bettertls::nameconstraints::tc6066", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19135, 19136], leaf: 19134 }, + Case { id: "bettertls::nameconstraints::tc6067", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19138, 19139], leaf: 19137 }, + Case { id: "bettertls::nameconstraints::tc6068", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19141, 19142], leaf: 19140 }, + Case { id: "bettertls::nameconstraints::tc6069", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19144, 19145], leaf: 19143 }, + Case { id: "bettertls::nameconstraints::tc6070", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19147, 19148], leaf: 19146 }, + Case { id: "bettertls::nameconstraints::tc6071", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19150, 19151], leaf: 19149 }, + Case { id: "bettertls::nameconstraints::tc6072", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19153, 19154], leaf: 19152 }, + Case { id: "bettertls::nameconstraints::tc6073", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19156, 19157], leaf: 19155 }, + Case { id: "bettertls::nameconstraints::tc6074", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19159, 19160], leaf: 19158 }, + Case { id: "bettertls::nameconstraints::tc6075", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19162, 19163], leaf: 19161 }, + Case { id: "bettertls::nameconstraints::tc6076", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19165, 19166], leaf: 19164 }, + Case { id: "bettertls::nameconstraints::tc6077", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19168, 19169], leaf: 19167 }, + Case { id: "bettertls::nameconstraints::tc6078", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19171, 19172], leaf: 19170 }, + Case { id: "bettertls::nameconstraints::tc6079", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19174, 19175], leaf: 19173 }, + Case { id: "bettertls::nameconstraints::tc6080", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19177, 19178], leaf: 19176 }, + Case { id: "bettertls::nameconstraints::tc6081", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19180, 19181], leaf: 19179 }, + Case { id: "bettertls::nameconstraints::tc6082", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19183, 19184], leaf: 19182 }, + Case { id: "bettertls::nameconstraints::tc6083", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19186, 19187], leaf: 19185 }, + Case { id: "bettertls::nameconstraints::tc6084", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19189, 19190], leaf: 19188 }, + Case { id: "bettertls::nameconstraints::tc6085", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19192, 19193], leaf: 19191 }, + Case { id: "bettertls::nameconstraints::tc6086", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19195, 19196], leaf: 19194 }, + Case { id: "bettertls::nameconstraints::tc6087", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19198, 19199], leaf: 19197 }, + Case { id: "bettertls::nameconstraints::tc6088", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19201, 19202], leaf: 19200 }, + Case { id: "bettertls::nameconstraints::tc6089", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19204, 19205], leaf: 19203 }, + Case { id: "bettertls::nameconstraints::tc6090", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19207, 19208], leaf: 19206 }, + Case { id: "bettertls::nameconstraints::tc6091", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19210, 19211], leaf: 19209 }, + Case { id: "bettertls::nameconstraints::tc6092", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19213, 19214], leaf: 19212 }, + Case { id: "bettertls::nameconstraints::tc6093", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19216, 19217], leaf: 19215 }, + Case { id: "bettertls::nameconstraints::tc6094", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19219, 19220], leaf: 19218 }, + Case { id: "bettertls::nameconstraints::tc6095", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19222, 19223], leaf: 19221 }, + Case { id: "bettertls::nameconstraints::tc6096", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19225, 19226], leaf: 19224 }, + Case { id: "bettertls::nameconstraints::tc6097", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19228, 19229], leaf: 19227 }, + Case { id: "bettertls::nameconstraints::tc6098", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19231, 19232], leaf: 19230 }, + Case { id: "bettertls::nameconstraints::tc6099", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19234, 19235], leaf: 19233 }, + Case { id: "bettertls::nameconstraints::tc6100", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19237, 19238], leaf: 19236 }, + Case { id: "bettertls::nameconstraints::tc6101", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19240, 19241], leaf: 19239 }, + Case { id: "bettertls::nameconstraints::tc6102", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19243, 19244], leaf: 19242 }, + Case { id: "bettertls::nameconstraints::tc6103", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19246, 19247], leaf: 19245 }, + Case { id: "bettertls::nameconstraints::tc6104", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19249, 19250], leaf: 19248 }, + Case { id: "bettertls::nameconstraints::tc6105", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19252, 19253], leaf: 19251 }, + Case { id: "bettertls::nameconstraints::tc6106", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19255, 19256], leaf: 19254 }, + Case { id: "bettertls::nameconstraints::tc6107", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19258, 19259], leaf: 19257 }, + Case { id: "bettertls::nameconstraints::tc6108", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19261, 19262], leaf: 19260 }, + Case { id: "bettertls::nameconstraints::tc6109", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19264, 19265], leaf: 19263 }, + Case { id: "bettertls::nameconstraints::tc6110", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19267, 19268], leaf: 19266 }, + Case { id: "bettertls::nameconstraints::tc6111", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19270, 19271], leaf: 19269 }, + Case { id: "bettertls::nameconstraints::tc6112", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19273, 19274], leaf: 19272 }, + Case { id: "bettertls::nameconstraints::tc6113", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19276, 19277], leaf: 19275 }, + Case { id: "bettertls::nameconstraints::tc6114", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19279, 19280], leaf: 19278 }, + Case { id: "bettertls::nameconstraints::tc6115", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19282, 19283], leaf: 19281 }, + Case { id: "bettertls::nameconstraints::tc6116", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19285, 19286], leaf: 19284 }, + Case { id: "bettertls::nameconstraints::tc6117", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19288, 19289], leaf: 19287 }, + Case { id: "bettertls::nameconstraints::tc6118", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19291, 19292], leaf: 19290 }, + Case { id: "bettertls::nameconstraints::tc6119", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19294, 19295], leaf: 19293 }, + Case { id: "bettertls::nameconstraints::tc6120", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19297, 19298], leaf: 19296 }, + Case { id: "bettertls::nameconstraints::tc6121", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19300, 19301], leaf: 19299 }, + Case { id: "bettertls::nameconstraints::tc6122", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19303, 19304], leaf: 19302 }, + Case { id: "bettertls::nameconstraints::tc6123", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19306, 19307], leaf: 19305 }, + Case { id: "bettertls::nameconstraints::tc6124", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19309, 19310], leaf: 19308 }, + Case { id: "bettertls::nameconstraints::tc6125", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19312, 19313], leaf: 19311 }, + Case { id: "bettertls::nameconstraints::tc6126", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19315, 19316], leaf: 19314 }, + Case { id: "bettertls::nameconstraints::tc6127", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19318, 19319], leaf: 19317 }, + Case { id: "bettertls::nameconstraints::tc6128", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19321, 19322], leaf: 19320 }, + Case { id: "bettertls::nameconstraints::tc6129", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19324, 19325], leaf: 19323 }, + Case { id: "bettertls::nameconstraints::tc6130", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19327, 19328], leaf: 19326 }, + Case { id: "bettertls::nameconstraints::tc6131", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19330, 19331], leaf: 19329 }, + Case { id: "bettertls::nameconstraints::tc6132", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19333, 19334], leaf: 19332 }, + Case { id: "bettertls::nameconstraints::tc6133", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19336, 19337], leaf: 19335 }, + Case { id: "bettertls::nameconstraints::tc6134", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19339, 19340], leaf: 19338 }, + Case { id: "bettertls::nameconstraints::tc6135", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19342, 19343], leaf: 19341 }, + Case { id: "bettertls::nameconstraints::tc6136", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19345, 19346], leaf: 19344 }, + Case { id: "bettertls::nameconstraints::tc6137", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19348, 19349], leaf: 19347 }, + Case { id: "bettertls::nameconstraints::tc6138", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19351, 19352], leaf: 19350 }, + Case { id: "bettertls::nameconstraints::tc6139", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19354, 19355], leaf: 19353 }, + Case { id: "bettertls::nameconstraints::tc6140", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19357, 19358], leaf: 19356 }, + Case { id: "bettertls::nameconstraints::tc6141", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19360, 19361], leaf: 19359 }, + Case { id: "bettertls::nameconstraints::tc6142", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19363, 19364], leaf: 19362 }, + Case { id: "bettertls::nameconstraints::tc6143", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19366, 19367], leaf: 19365 }, + Case { id: "bettertls::nameconstraints::tc6144", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19369, 19370], leaf: 19368 }, + Case { id: "bettertls::nameconstraints::tc6145", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19372, 19373], leaf: 19371 }, + Case { id: "bettertls::nameconstraints::tc6146", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19375, 19376], leaf: 19374 }, + Case { id: "bettertls::nameconstraints::tc6147", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19378, 19379], leaf: 19377 }, + Case { id: "bettertls::nameconstraints::tc6148", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19381, 19382], leaf: 19380 }, + Case { id: "bettertls::nameconstraints::tc6149", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19384, 19385], leaf: 19383 }, + Case { id: "bettertls::nameconstraints::tc6150", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19387, 19388], leaf: 19386 }, + Case { id: "bettertls::nameconstraints::tc6151", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19390, 19391], leaf: 19389 }, + Case { id: "bettertls::nameconstraints::tc6152", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19393, 19394], leaf: 19392 }, + Case { id: "bettertls::nameconstraints::tc6153", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19396, 19397], leaf: 19395 }, + Case { id: "bettertls::nameconstraints::tc6154", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19399, 19400], leaf: 19398 }, + Case { id: "bettertls::nameconstraints::tc6155", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19402, 19403], leaf: 19401 }, + Case { id: "bettertls::nameconstraints::tc6156", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19405, 19406], leaf: 19404 }, + Case { id: "bettertls::nameconstraints::tc6157", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19408, 19409], leaf: 19407 }, + Case { id: "bettertls::nameconstraints::tc6158", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19411, 19412], leaf: 19410 }, + Case { id: "bettertls::nameconstraints::tc6159", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19414, 19415], leaf: 19413 }, + Case { id: "bettertls::nameconstraints::tc6160", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19417, 19418], leaf: 19416 }, + Case { id: "bettertls::nameconstraints::tc6161", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19420, 19421], leaf: 19419 }, + Case { id: "bettertls::nameconstraints::tc6162", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19423, 19424], leaf: 19422 }, + Case { id: "bettertls::nameconstraints::tc6163", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19426, 19427], leaf: 19425 }, + Case { id: "bettertls::nameconstraints::tc6164", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19429, 19430], leaf: 19428 }, + Case { id: "bettertls::nameconstraints::tc6165", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19432, 19433], leaf: 19431 }, + Case { id: "bettertls::nameconstraints::tc6166", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19435, 19436], leaf: 19434 }, + Case { id: "bettertls::nameconstraints::tc6167", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19438, 19439], leaf: 19437 }, + Case { id: "bettertls::nameconstraints::tc6168", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19441, 19442], leaf: 19440 }, + Case { id: "bettertls::nameconstraints::tc6169", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19444, 19445], leaf: 19443 }, + Case { id: "bettertls::nameconstraints::tc6170", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19447, 19448], leaf: 19446 }, + Case { id: "bettertls::nameconstraints::tc6171", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19450, 19451], leaf: 19449 }, + Case { id: "bettertls::nameconstraints::tc6172", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19453, 19454], leaf: 19452 }, + Case { id: "bettertls::nameconstraints::tc6173", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19456, 19457], leaf: 19455 }, + Case { id: "bettertls::nameconstraints::tc6174", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19459, 19460], leaf: 19458 }, + Case { id: "bettertls::nameconstraints::tc6175", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19462, 19463], leaf: 19461 }, + Case { id: "bettertls::nameconstraints::tc6176", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19465, 19466], leaf: 19464 }, + Case { id: "bettertls::nameconstraints::tc6177", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19468, 19469], leaf: 19467 }, + Case { id: "bettertls::nameconstraints::tc6178", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19471, 19472], leaf: 19470 }, + Case { id: "bettertls::nameconstraints::tc6179", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19474, 19475], leaf: 19473 }, + Case { id: "bettertls::nameconstraints::tc6180", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19477, 19478], leaf: 19476 }, + Case { id: "bettertls::nameconstraints::tc6181", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19480, 19481], leaf: 19479 }, + Case { id: "bettertls::nameconstraints::tc6182", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19483, 19484], leaf: 19482 }, + Case { id: "bettertls::nameconstraints::tc6183", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19486, 19487], leaf: 19485 }, + Case { id: "bettertls::nameconstraints::tc6184", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19489, 19490], leaf: 19488 }, + Case { id: "bettertls::nameconstraints::tc6185", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19492, 19493], leaf: 19491 }, + Case { id: "bettertls::nameconstraints::tc6186", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19495, 19496], leaf: 19494 }, + Case { id: "bettertls::nameconstraints::tc6187", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19498, 19499], leaf: 19497 }, + Case { id: "bettertls::nameconstraints::tc6188", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19501, 19502], leaf: 19500 }, + Case { id: "bettertls::nameconstraints::tc6189", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19504, 19505], leaf: 19503 }, + Case { id: "bettertls::nameconstraints::tc6190", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19507, 19508], leaf: 19506 }, + Case { id: "bettertls::nameconstraints::tc6191", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19510, 19511], leaf: 19509 }, + Case { id: "bettertls::nameconstraints::tc6192", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19513, 19514], leaf: 19512 }, + Case { id: "bettertls::nameconstraints::tc6193", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19516, 19517], leaf: 19515 }, + Case { id: "bettertls::nameconstraints::tc6194", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19519, 19520], leaf: 19518 }, + Case { id: "bettertls::nameconstraints::tc6195", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19522, 19523], leaf: 19521 }, + Case { id: "bettertls::nameconstraints::tc6196", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19525, 19526], leaf: 19524 }, + Case { id: "bettertls::nameconstraints::tc6197", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19528, 19529], leaf: 19527 }, + Case { id: "bettertls::nameconstraints::tc6198", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19531, 19532], leaf: 19530 }, + Case { id: "bettertls::nameconstraints::tc6199", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19534, 19535], leaf: 19533 }, + Case { id: "bettertls::nameconstraints::tc6200", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19537, 19538], leaf: 19536 }, + Case { id: "bettertls::nameconstraints::tc6201", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19540, 19541], leaf: 19539 }, + Case { id: "bettertls::nameconstraints::tc6202", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19543, 19544], leaf: 19542 }, + Case { id: "bettertls::nameconstraints::tc6203", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19546, 19547], leaf: 19545 }, + Case { id: "bettertls::nameconstraints::tc6204", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19549, 19550], leaf: 19548 }, + Case { id: "bettertls::nameconstraints::tc6205", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19552, 19553], leaf: 19551 }, + Case { id: "bettertls::nameconstraints::tc6206", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19555, 19556], leaf: 19554 }, + Case { id: "bettertls::nameconstraints::tc6207", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19558, 19559], leaf: 19557 }, + Case { id: "bettertls::nameconstraints::tc6208", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19561, 19562], leaf: 19560 }, + Case { id: "bettertls::nameconstraints::tc6209", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19564, 19565], leaf: 19563 }, + Case { id: "bettertls::nameconstraints::tc6210", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19567, 19568], leaf: 19566 }, + Case { id: "bettertls::nameconstraints::tc6211", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19570, 19571], leaf: 19569 }, + Case { id: "bettertls::nameconstraints::tc6212", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19573, 19574], leaf: 19572 }, + Case { id: "bettertls::nameconstraints::tc6213", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19576, 19577], leaf: 19575 }, + Case { id: "bettertls::nameconstraints::tc6214", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19579, 19580], leaf: 19578 }, + Case { id: "bettertls::nameconstraints::tc6215", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19582, 19583], leaf: 19581 }, + Case { id: "bettertls::nameconstraints::tc6216", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19585, 19586], leaf: 19584 }, + Case { id: "bettertls::nameconstraints::tc6217", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19588, 19589], leaf: 19587 }, + Case { id: "bettertls::nameconstraints::tc6218", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19591, 19592], leaf: 19590 }, + Case { id: "bettertls::nameconstraints::tc6219", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19594, 19595], leaf: 19593 }, + Case { id: "bettertls::nameconstraints::tc6220", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19597, 19598], leaf: 19596 }, + Case { id: "bettertls::nameconstraints::tc6221", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19600, 19601], leaf: 19599 }, + Case { id: "bettertls::nameconstraints::tc6222", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19603, 19604], leaf: 19602 }, + Case { id: "bettertls::nameconstraints::tc6223", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19606, 19607], leaf: 19605 }, + Case { id: "bettertls::nameconstraints::tc6224", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19609, 19610], leaf: 19608 }, + Case { id: "bettertls::nameconstraints::tc6225", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19612, 19613], leaf: 19611 }, + Case { id: "bettertls::nameconstraints::tc6226", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19615, 19616], leaf: 19614 }, + Case { id: "bettertls::nameconstraints::tc6227", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19618, 19619], leaf: 19617 }, + Case { id: "bettertls::nameconstraints::tc6228", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19621, 19622], leaf: 19620 }, + Case { id: "bettertls::nameconstraints::tc6229", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19624, 19625], leaf: 19623 }, + Case { id: "bettertls::nameconstraints::tc6230", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19627, 19628], leaf: 19626 }, + Case { id: "bettertls::nameconstraints::tc6231", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19630, 19631], leaf: 19629 }, + Case { id: "bettertls::nameconstraints::tc6232", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19633, 19634], leaf: 19632 }, + Case { id: "bettertls::nameconstraints::tc6233", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19636, 19637], leaf: 19635 }, + Case { id: "bettertls::nameconstraints::tc6234", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19639, 19640], leaf: 19638 }, + Case { id: "bettertls::nameconstraints::tc6235", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19642, 19643], leaf: 19641 }, + Case { id: "bettertls::nameconstraints::tc6236", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19645, 19646], leaf: 19644 }, + Case { id: "bettertls::nameconstraints::tc6237", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19648, 19649], leaf: 19647 }, + Case { id: "bettertls::nameconstraints::tc6238", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19651, 19652], leaf: 19650 }, + Case { id: "bettertls::nameconstraints::tc6239", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19654, 19655], leaf: 19653 }, + Case { id: "bettertls::nameconstraints::tc6240", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19657, 19658], leaf: 19656 }, + Case { id: "bettertls::nameconstraints::tc6241", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19660, 19661], leaf: 19659 }, + Case { id: "bettertls::nameconstraints::tc6242", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19663, 19664], leaf: 19662 }, + Case { id: "bettertls::nameconstraints::tc6243", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19666, 19667], leaf: 19665 }, + Case { id: "bettertls::nameconstraints::tc6244", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19669, 19670], leaf: 19668 }, + Case { id: "bettertls::nameconstraints::tc6245", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19672, 19673], leaf: 19671 }, + Case { id: "bettertls::nameconstraints::tc6246", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19675, 19676], leaf: 19674 }, + Case { id: "bettertls::nameconstraints::tc6247", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19678, 19679], leaf: 19677 }, + Case { id: "bettertls::nameconstraints::tc6248", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19681, 19682], leaf: 19680 }, + Case { id: "bettertls::nameconstraints::tc6249", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19684, 19685], leaf: 19683 }, + Case { id: "bettertls::nameconstraints::tc6250", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19687, 19688], leaf: 19686 }, + Case { id: "bettertls::nameconstraints::tc6251", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19690, 19691], leaf: 19689 }, + Case { id: "bettertls::nameconstraints::tc6252", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19693, 19694], leaf: 19692 }, + Case { id: "bettertls::nameconstraints::tc6253", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19696, 19697], leaf: 19695 }, + Case { id: "bettertls::nameconstraints::tc6254", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19699, 19700], leaf: 19698 }, + Case { id: "bettertls::nameconstraints::tc6255", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19702, 19703], leaf: 19701 }, + Case { id: "bettertls::nameconstraints::tc6256", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19705, 19706], leaf: 19704 }, + Case { id: "bettertls::nameconstraints::tc6257", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19708, 19709], leaf: 19707 }, + Case { id: "bettertls::nameconstraints::tc6258", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19711, 19712], leaf: 19710 }, + Case { id: "bettertls::nameconstraints::tc6259", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19714, 19715], leaf: 19713 }, + Case { id: "bettertls::nameconstraints::tc6260", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19717, 19718], leaf: 19716 }, + Case { id: "bettertls::nameconstraints::tc6261", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19720, 19721], leaf: 19719 }, + Case { id: "bettertls::nameconstraints::tc6262", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19723, 19724], leaf: 19722 }, + Case { id: "bettertls::nameconstraints::tc6263", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19726, 19727], leaf: 19725 }, + Case { id: "bettertls::nameconstraints::tc6264", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19729, 19730], leaf: 19728 }, + Case { id: "bettertls::nameconstraints::tc6265", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19732, 19733], leaf: 19731 }, + Case { id: "bettertls::nameconstraints::tc6266", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19735, 19736], leaf: 19734 }, + Case { id: "bettertls::nameconstraints::tc6267", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19738, 19739], leaf: 19737 }, + Case { id: "bettertls::nameconstraints::tc6268", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19741, 19742], leaf: 19740 }, + Case { id: "bettertls::nameconstraints::tc6269", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19744, 19745], leaf: 19743 }, + Case { id: "bettertls::nameconstraints::tc6270", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19747, 19748], leaf: 19746 }, + Case { id: "bettertls::nameconstraints::tc6271", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19750, 19751], leaf: 19749 }, + Case { id: "bettertls::nameconstraints::tc6272", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19753, 19754], leaf: 19752 }, + Case { id: "bettertls::nameconstraints::tc6273", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19756, 19757], leaf: 19755 }, + Case { id: "bettertls::nameconstraints::tc6274", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19759, 19760], leaf: 19758 }, + Case { id: "bettertls::nameconstraints::tc6275", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19762, 19763], leaf: 19761 }, + Case { id: "bettertls::nameconstraints::tc6276", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19765, 19766], leaf: 19764 }, + Case { id: "bettertls::nameconstraints::tc6277", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19768, 19769], leaf: 19767 }, + Case { id: "bettertls::nameconstraints::tc6278", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19771, 19772], leaf: 19770 }, + Case { id: "bettertls::nameconstraints::tc6279", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19774, 19775], leaf: 19773 }, + Case { id: "bettertls::nameconstraints::tc6280", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19777, 19778], leaf: 19776 }, + Case { id: "bettertls::nameconstraints::tc6281", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19780, 19781], leaf: 19779 }, + Case { id: "bettertls::nameconstraints::tc6282", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19783, 19784], leaf: 19782 }, + Case { id: "bettertls::nameconstraints::tc6283", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19786, 19787], leaf: 19785 }, + Case { id: "bettertls::nameconstraints::tc6284", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19789, 19790], leaf: 19788 }, + Case { id: "bettertls::nameconstraints::tc6285", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19792, 19793], leaf: 19791 }, + Case { id: "bettertls::nameconstraints::tc6286", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19795, 19796], leaf: 19794 }, + Case { id: "bettertls::nameconstraints::tc6287", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19798, 19799], leaf: 19797 }, + Case { id: "bettertls::nameconstraints::tc6288", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19801, 19802], leaf: 19800 }, + Case { id: "bettertls::nameconstraints::tc6289", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19804, 19805], leaf: 19803 }, + Case { id: "bettertls::nameconstraints::tc6290", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19807, 19808], leaf: 19806 }, + Case { id: "bettertls::nameconstraints::tc6291", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19810, 19811], leaf: 19809 }, + Case { id: "bettertls::nameconstraints::tc6292", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19813, 19814], leaf: 19812 }, + Case { id: "bettertls::nameconstraints::tc6293", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19816, 19817], leaf: 19815 }, + Case { id: "bettertls::nameconstraints::tc6294", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19819, 19820], leaf: 19818 }, + Case { id: "bettertls::nameconstraints::tc6295", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19822, 19823], leaf: 19821 }, + Case { id: "bettertls::nameconstraints::tc6296", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19825, 19826], leaf: 19824 }, + Case { id: "bettertls::nameconstraints::tc6297", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19828, 19829], leaf: 19827 }, + Case { id: "bettertls::nameconstraints::tc6298", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19831, 19832], leaf: 19830 }, + Case { id: "bettertls::nameconstraints::tc6299", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19834, 19835], leaf: 19833 }, + Case { id: "bettertls::nameconstraints::tc6300", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19837, 19838], leaf: 19836 }, + Case { id: "bettertls::nameconstraints::tc6301", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19840, 19841], leaf: 19839 }, + Case { id: "bettertls::nameconstraints::tc6302", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19843, 19844], leaf: 19842 }, + Case { id: "bettertls::nameconstraints::tc6303", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19846, 19847], leaf: 19845 }, + Case { id: "bettertls::nameconstraints::tc6304", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19849, 19850], leaf: 19848 }, + Case { id: "bettertls::nameconstraints::tc6305", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19852, 19853], leaf: 19851 }, + Case { id: "bettertls::nameconstraints::tc6306", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19855, 19856], leaf: 19854 }, + Case { id: "bettertls::nameconstraints::tc6307", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19858, 19859], leaf: 19857 }, + Case { id: "bettertls::nameconstraints::tc6308", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19861, 19862], leaf: 19860 }, + Case { id: "bettertls::nameconstraints::tc6309", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19864, 19865], leaf: 19863 }, + Case { id: "bettertls::nameconstraints::tc6310", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19867, 19868], leaf: 19866 }, + Case { id: "bettertls::nameconstraints::tc6311", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19870, 19871], leaf: 19869 }, + Case { id: "bettertls::nameconstraints::tc6312", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19873, 19874], leaf: 19872 }, + Case { id: "bettertls::nameconstraints::tc6313", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19876, 19877], leaf: 19875 }, + Case { id: "bettertls::nameconstraints::tc6314", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19879, 19880], leaf: 19878 }, + Case { id: "bettertls::nameconstraints::tc6315", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19882, 19883], leaf: 19881 }, + Case { id: "bettertls::nameconstraints::tc6316", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19885, 19886], leaf: 19884 }, + Case { id: "bettertls::nameconstraints::tc6317", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19888, 19889], leaf: 19887 }, + Case { id: "bettertls::nameconstraints::tc6318", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19891, 19892], leaf: 19890 }, + Case { id: "bettertls::nameconstraints::tc6319", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19894, 19895], leaf: 19893 }, + Case { id: "bettertls::nameconstraints::tc6320", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19897, 19898], leaf: 19896 }, + Case { id: "bettertls::nameconstraints::tc6321", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19900, 19901], leaf: 19899 }, + Case { id: "bettertls::nameconstraints::tc6322", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19903, 19904], leaf: 19902 }, + Case { id: "bettertls::nameconstraints::tc6323", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19906, 19907], leaf: 19905 }, + Case { id: "bettertls::nameconstraints::tc6324", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19909, 19910], leaf: 19908 }, + Case { id: "bettertls::nameconstraints::tc6325", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19912, 19913], leaf: 19911 }, + Case { id: "bettertls::nameconstraints::tc6326", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19915, 19916], leaf: 19914 }, + Case { id: "bettertls::nameconstraints::tc6327", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19918, 19919], leaf: 19917 }, + Case { id: "bettertls::nameconstraints::tc6328", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19921, 19922], leaf: 19920 }, + Case { id: "bettertls::nameconstraints::tc6329", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19924, 19925], leaf: 19923 }, + Case { id: "bettertls::nameconstraints::tc6330", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19927, 19928], leaf: 19926 }, + Case { id: "bettertls::nameconstraints::tc6331", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19930, 19931], leaf: 19929 }, + Case { id: "bettertls::nameconstraints::tc6332", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19933, 19934], leaf: 19932 }, + Case { id: "bettertls::nameconstraints::tc6333", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19936, 19937], leaf: 19935 }, + Case { id: "bettertls::nameconstraints::tc6334", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19939, 19940], leaf: 19938 }, + Case { id: "bettertls::nameconstraints::tc6335", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19942, 19943], leaf: 19941 }, + Case { id: "bettertls::nameconstraints::tc6336", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19945, 19946], leaf: 19944 }, + Case { id: "bettertls::nameconstraints::tc6337", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19948, 19949], leaf: 19947 }, + Case { id: "bettertls::nameconstraints::tc6338", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19951, 19952], leaf: 19950 }, + Case { id: "bettertls::nameconstraints::tc6339", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19954, 19955], leaf: 19953 }, + Case { id: "bettertls::nameconstraints::tc6340", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19957, 19958], leaf: 19956 }, + Case { id: "bettertls::nameconstraints::tc6341", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19960, 19961], leaf: 19959 }, + Case { id: "bettertls::nameconstraints::tc6342", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19963, 19964], leaf: 19962 }, + Case { id: "bettertls::nameconstraints::tc6343", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19966, 19967], leaf: 19965 }, + Case { id: "bettertls::nameconstraints::tc6344", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19969, 19970], leaf: 19968 }, + Case { id: "bettertls::nameconstraints::tc6345", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19972, 19973], leaf: 19971 }, + Case { id: "bettertls::nameconstraints::tc6346", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19975, 19976], leaf: 19974 }, + Case { id: "bettertls::nameconstraints::tc6347", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19978, 19979], leaf: 19977 }, + Case { id: "bettertls::nameconstraints::tc6348", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19981, 19982], leaf: 19980 }, + Case { id: "bettertls::nameconstraints::tc6349", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19984, 19985], leaf: 19983 }, + Case { id: "bettertls::nameconstraints::tc6350", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19987, 19988], leaf: 19986 }, + Case { id: "bettertls::nameconstraints::tc6351", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19990, 19991], leaf: 19989 }, + Case { id: "bettertls::nameconstraints::tc6352", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19993, 19994], leaf: 19992 }, + Case { id: "bettertls::nameconstraints::tc6353", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19996, 19997], leaf: 19995 }, + Case { id: "bettertls::nameconstraints::tc6354", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[19999, 20000], leaf: 19998 }, + Case { id: "bettertls::nameconstraints::tc6355", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20002, 20003], leaf: 20001 }, + Case { id: "bettertls::nameconstraints::tc6356", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20005, 20006], leaf: 20004 }, + Case { id: "bettertls::nameconstraints::tc6357", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20008, 20009], leaf: 20007 }, + Case { id: "bettertls::nameconstraints::tc6358", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20011, 20012], leaf: 20010 }, + Case { id: "bettertls::nameconstraints::tc6359", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20014, 20015], leaf: 20013 }, + Case { id: "bettertls::nameconstraints::tc6360", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20017, 20018], leaf: 20016 }, + Case { id: "bettertls::nameconstraints::tc6361", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20020, 20021], leaf: 20019 }, + Case { id: "bettertls::nameconstraints::tc6362", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20023, 20024], leaf: 20022 }, + Case { id: "bettertls::nameconstraints::tc6363", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20026, 20027], leaf: 20025 }, + Case { id: "bettertls::nameconstraints::tc6364", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20029, 20030], leaf: 20028 }, + Case { id: "bettertls::nameconstraints::tc6365", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20032, 20033], leaf: 20031 }, + Case { id: "bettertls::nameconstraints::tc6366", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20035, 20036], leaf: 20034 }, + Case { id: "bettertls::nameconstraints::tc6367", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20038, 20039], leaf: 20037 }, + Case { id: "bettertls::nameconstraints::tc6368", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20041, 20042], leaf: 20040 }, + Case { id: "bettertls::nameconstraints::tc6369", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20044, 20045], leaf: 20043 }, + Case { id: "bettertls::nameconstraints::tc6370", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20047, 20048], leaf: 20046 }, + Case { id: "bettertls::nameconstraints::tc6371", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20050, 20051], leaf: 20049 }, + Case { id: "bettertls::nameconstraints::tc6372", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20053, 20054], leaf: 20052 }, + Case { id: "bettertls::nameconstraints::tc6373", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20056, 20057], leaf: 20055 }, + Case { id: "bettertls::nameconstraints::tc6374", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20059, 20060], leaf: 20058 }, + Case { id: "bettertls::nameconstraints::tc6375", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20062, 20063], leaf: 20061 }, + Case { id: "bettertls::nameconstraints::tc6376", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20065, 20066], leaf: 20064 }, + Case { id: "bettertls::nameconstraints::tc6377", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20068, 20069], leaf: 20067 }, + Case { id: "bettertls::nameconstraints::tc6378", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20071, 20072], leaf: 20070 }, + Case { id: "bettertls::nameconstraints::tc6379", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20074, 20075], leaf: 20073 }, + Case { id: "bettertls::nameconstraints::tc6380", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20077, 20078], leaf: 20076 }, + Case { id: "bettertls::nameconstraints::tc6381", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20080, 20081], leaf: 20079 }, + Case { id: "bettertls::nameconstraints::tc6382", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20083, 20084], leaf: 20082 }, + Case { id: "bettertls::nameconstraints::tc6383", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20086, 20087], leaf: 20085 }, + Case { id: "bettertls::nameconstraints::tc6384", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20089, 20090], leaf: 20088 }, + Case { id: "bettertls::nameconstraints::tc6385", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20092, 20093], leaf: 20091 }, + Case { id: "bettertls::nameconstraints::tc6386", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20095, 20096], leaf: 20094 }, + Case { id: "bettertls::nameconstraints::tc6387", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20098, 20099], leaf: 20097 }, + Case { id: "bettertls::nameconstraints::tc6388", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20101, 20102], leaf: 20100 }, + Case { id: "bettertls::nameconstraints::tc6389", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20104, 20105], leaf: 20103 }, + Case { id: "bettertls::nameconstraints::tc6390", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20107, 20108], leaf: 20106 }, + Case { id: "bettertls::nameconstraints::tc6391", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20110, 20111], leaf: 20109 }, + Case { id: "bettertls::nameconstraints::tc6392", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20113, 20114], leaf: 20112 }, + Case { id: "bettertls::nameconstraints::tc6393", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20116, 20117], leaf: 20115 }, + Case { id: "bettertls::nameconstraints::tc6394", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20119, 20120], leaf: 20118 }, + Case { id: "bettertls::nameconstraints::tc6395", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20122, 20123], leaf: 20121 }, + Case { id: "bettertls::nameconstraints::tc6396", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20125, 20126], leaf: 20124 }, + Case { id: "bettertls::nameconstraints::tc6397", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20128, 20129], leaf: 20127 }, + Case { id: "bettertls::nameconstraints::tc6398", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20131, 20132], leaf: 20130 }, + Case { id: "bettertls::nameconstraints::tc6399", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20134, 20135], leaf: 20133 }, + Case { id: "bettertls::nameconstraints::tc6400", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20137, 20138], leaf: 20136 }, + Case { id: "bettertls::nameconstraints::tc6401", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20140, 20141], leaf: 20139 }, + Case { id: "bettertls::nameconstraints::tc6402", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20143, 20144], leaf: 20142 }, + Case { id: "bettertls::nameconstraints::tc6403", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20146, 20147], leaf: 20145 }, + Case { id: "bettertls::nameconstraints::tc6404", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20149, 20150], leaf: 20148 }, + Case { id: "bettertls::nameconstraints::tc6405", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20152, 20153], leaf: 20151 }, + Case { id: "bettertls::nameconstraints::tc6406", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20155, 20156], leaf: 20154 }, + Case { id: "bettertls::nameconstraints::tc6407", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20158, 20159], leaf: 20157 }, + Case { id: "bettertls::nameconstraints::tc6408", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20161, 20162], leaf: 20160 }, + Case { id: "bettertls::nameconstraints::tc6409", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20164, 20165], leaf: 20163 }, + Case { id: "bettertls::nameconstraints::tc6410", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20167, 20168], leaf: 20166 }, + Case { id: "bettertls::nameconstraints::tc6411", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20170, 20171], leaf: 20169 }, + Case { id: "bettertls::nameconstraints::tc6412", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20173, 20174], leaf: 20172 }, + Case { id: "bettertls::nameconstraints::tc6413", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20176, 20177], leaf: 20175 }, + Case { id: "bettertls::nameconstraints::tc6414", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20179, 20180], leaf: 20178 }, + Case { id: "bettertls::nameconstraints::tc6415", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20182, 20183], leaf: 20181 }, + Case { id: "bettertls::nameconstraints::tc6416", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20185, 20186], leaf: 20184 }, + Case { id: "bettertls::nameconstraints::tc6417", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20188, 20189], leaf: 20187 }, + Case { id: "bettertls::nameconstraints::tc6418", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20191, 20192], leaf: 20190 }, + Case { id: "bettertls::nameconstraints::tc6419", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20194, 20195], leaf: 20193 }, + Case { id: "bettertls::nameconstraints::tc6420", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20197, 20198], leaf: 20196 }, + Case { id: "bettertls::nameconstraints::tc6421", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20200, 20201], leaf: 20199 }, + Case { id: "bettertls::nameconstraints::tc6422", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20203, 20204], leaf: 20202 }, + Case { id: "bettertls::nameconstraints::tc6423", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20206, 20207], leaf: 20205 }, + Case { id: "bettertls::nameconstraints::tc6424", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20209, 20210], leaf: 20208 }, + Case { id: "bettertls::nameconstraints::tc6425", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20212, 20213], leaf: 20211 }, + Case { id: "bettertls::nameconstraints::tc6426", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20215, 20216], leaf: 20214 }, + Case { id: "bettertls::nameconstraints::tc6427", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20218, 20219], leaf: 20217 }, + Case { id: "bettertls::nameconstraints::tc6428", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20221, 20222], leaf: 20220 }, + Case { id: "bettertls::nameconstraints::tc6429", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20224, 20225], leaf: 20223 }, + Case { id: "bettertls::nameconstraints::tc6430", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20227, 20228], leaf: 20226 }, + Case { id: "bettertls::nameconstraints::tc6431", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20230, 20231], leaf: 20229 }, + Case { id: "bettertls::nameconstraints::tc6432", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20233, 20234], leaf: 20232 }, + Case { id: "bettertls::nameconstraints::tc6433", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20236, 20237], leaf: 20235 }, + Case { id: "bettertls::nameconstraints::tc6434", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20239, 20240], leaf: 20238 }, + Case { id: "bettertls::nameconstraints::tc6435", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20242, 20243], leaf: 20241 }, + Case { id: "bettertls::nameconstraints::tc6436", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20245, 20246], leaf: 20244 }, + Case { id: "bettertls::nameconstraints::tc6437", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20248, 20249], leaf: 20247 }, + Case { id: "bettertls::nameconstraints::tc6438", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20251, 20252], leaf: 20250 }, + Case { id: "bettertls::nameconstraints::tc6439", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20254, 20255], leaf: 20253 }, + Case { id: "bettertls::nameconstraints::tc6440", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20257, 20258], leaf: 20256 }, + Case { id: "bettertls::nameconstraints::tc6441", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20260, 20261], leaf: 20259 }, + Case { id: "bettertls::nameconstraints::tc6442", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20263, 20264], leaf: 20262 }, + Case { id: "bettertls::nameconstraints::tc6443", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20266, 20267], leaf: 20265 }, + Case { id: "bettertls::nameconstraints::tc6444", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20269, 20270], leaf: 20268 }, + Case { id: "bettertls::nameconstraints::tc6445", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20272, 20273], leaf: 20271 }, + Case { id: "bettertls::nameconstraints::tc6446", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20275, 20276], leaf: 20274 }, + Case { id: "bettertls::nameconstraints::tc6447", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20278, 20279], leaf: 20277 }, + Case { id: "bettertls::nameconstraints::tc6448", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20281, 20282], leaf: 20280 }, + Case { id: "bettertls::nameconstraints::tc6449", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20284, 20285], leaf: 20283 }, + Case { id: "bettertls::nameconstraints::tc6450", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20287, 20288], leaf: 20286 }, + Case { id: "bettertls::nameconstraints::tc6451", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20290, 20291], leaf: 20289 }, + Case { id: "bettertls::nameconstraints::tc6452", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20293, 20294], leaf: 20292 }, + Case { id: "bettertls::nameconstraints::tc6453", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20296, 20297], leaf: 20295 }, + Case { id: "bettertls::nameconstraints::tc6454", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20299, 20300], leaf: 20298 }, + Case { id: "bettertls::nameconstraints::tc6455", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20302, 20303], leaf: 20301 }, + Case { id: "bettertls::nameconstraints::tc6456", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20305, 20306], leaf: 20304 }, + Case { id: "bettertls::nameconstraints::tc6457", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20308, 20309], leaf: 20307 }, + Case { id: "bettertls::nameconstraints::tc6458", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20311, 20312], leaf: 20310 }, + Case { id: "bettertls::nameconstraints::tc6459", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20314, 20315], leaf: 20313 }, + Case { id: "bettertls::nameconstraints::tc6460", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20317, 20318], leaf: 20316 }, + Case { id: "bettertls::nameconstraints::tc6461", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20320, 20321], leaf: 20319 }, + Case { id: "bettertls::nameconstraints::tc6462", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20323, 20324], leaf: 20322 }, + Case { id: "bettertls::nameconstraints::tc6463", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20326, 20327], leaf: 20325 }, + Case { id: "bettertls::nameconstraints::tc6464", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20329, 20330], leaf: 20328 }, + Case { id: "bettertls::nameconstraints::tc6465", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20332, 20333], leaf: 20331 }, + Case { id: "bettertls::nameconstraints::tc6466", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20335, 20336], leaf: 20334 }, + Case { id: "bettertls::nameconstraints::tc6467", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20338, 20339], leaf: 20337 }, + Case { id: "bettertls::nameconstraints::tc6468", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20341, 20342], leaf: 20340 }, + Case { id: "bettertls::nameconstraints::tc6469", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20344, 20345], leaf: 20343 }, + Case { id: "bettertls::nameconstraints::tc6470", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20347, 20348], leaf: 20346 }, + Case { id: "bettertls::nameconstraints::tc6471", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20350, 20351], leaf: 20349 }, + Case { id: "bettertls::nameconstraints::tc6472", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20353, 20354], leaf: 20352 }, + Case { id: "bettertls::nameconstraints::tc6473", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20356, 20357], leaf: 20355 }, + Case { id: "bettertls::nameconstraints::tc6474", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20359, 20360], leaf: 20358 }, + Case { id: "bettertls::nameconstraints::tc6475", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20362, 20363], leaf: 20361 }, + Case { id: "bettertls::nameconstraints::tc6476", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20365, 20366], leaf: 20364 }, + Case { id: "bettertls::nameconstraints::tc6477", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20368, 20369], leaf: 20367 }, + Case { id: "bettertls::nameconstraints::tc6478", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20371, 20372], leaf: 20370 }, + Case { id: "bettertls::nameconstraints::tc6479", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20374, 20375], leaf: 20373 }, + Case { id: "bettertls::nameconstraints::tc6480", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20377, 20378], leaf: 20376 }, + Case { id: "bettertls::nameconstraints::tc6481", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20380, 20381], leaf: 20379 }, + Case { id: "bettertls::nameconstraints::tc6482", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20383, 20384], leaf: 20382 }, + Case { id: "bettertls::nameconstraints::tc6483", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20386, 20387], leaf: 20385 }, + Case { id: "bettertls::nameconstraints::tc6484", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20389, 20390], leaf: 20388 }, + Case { id: "bettertls::nameconstraints::tc6485", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20392, 20393], leaf: 20391 }, + Case { id: "bettertls::nameconstraints::tc6486", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20395, 20396], leaf: 20394 }, + Case { id: "bettertls::nameconstraints::tc6487", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20398, 20399], leaf: 20397 }, + Case { id: "bettertls::nameconstraints::tc6488", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20401, 20402], leaf: 20400 }, + Case { id: "bettertls::nameconstraints::tc6489", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20404, 20405], leaf: 20403 }, + Case { id: "bettertls::nameconstraints::tc6490", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20407, 20408], leaf: 20406 }, + Case { id: "bettertls::nameconstraints::tc6491", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20410, 20411], leaf: 20409 }, + Case { id: "bettertls::nameconstraints::tc6492", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20413, 20414], leaf: 20412 }, + Case { id: "bettertls::nameconstraints::tc6493", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20416, 20417], leaf: 20415 }, + Case { id: "bettertls::nameconstraints::tc6494", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20419, 20420], leaf: 20418 }, + Case { id: "bettertls::nameconstraints::tc6495", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20422, 20423], leaf: 20421 }, + Case { id: "bettertls::nameconstraints::tc6496", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20425, 20426], leaf: 20424 }, + Case { id: "bettertls::nameconstraints::tc6497", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20428, 20429], leaf: 20427 }, + Case { id: "bettertls::nameconstraints::tc6498", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20431, 20432], leaf: 20430 }, + Case { id: "bettertls::nameconstraints::tc6499", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20434, 20435], leaf: 20433 }, + Case { id: "bettertls::nameconstraints::tc6500", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20437, 20438], leaf: 20436 }, + Case { id: "bettertls::nameconstraints::tc6501", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20440, 20441], leaf: 20439 }, + Case { id: "bettertls::nameconstraints::tc6502", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20443, 20444], leaf: 20442 }, + Case { id: "bettertls::nameconstraints::tc6503", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20446, 20447], leaf: 20445 }, + Case { id: "bettertls::nameconstraints::tc6504", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20449, 20450], leaf: 20448 }, + Case { id: "bettertls::nameconstraints::tc6505", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20452, 20453], leaf: 20451 }, + Case { id: "bettertls::nameconstraints::tc6506", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20455, 20456], leaf: 20454 }, + Case { id: "bettertls::nameconstraints::tc6507", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20458, 20459], leaf: 20457 }, + Case { id: "bettertls::nameconstraints::tc6508", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20461, 20462], leaf: 20460 }, + Case { id: "bettertls::nameconstraints::tc6509", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20464, 20465], leaf: 20463 }, + Case { id: "bettertls::nameconstraints::tc6510", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20467, 20468], leaf: 20466 }, + Case { id: "bettertls::nameconstraints::tc6511", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20470, 20471], leaf: 20469 }, + Case { id: "bettertls::nameconstraints::tc6512", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20473, 20474], leaf: 20472 }, + Case { id: "bettertls::nameconstraints::tc6513", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20476, 20477], leaf: 20475 }, + Case { id: "bettertls::nameconstraints::tc6514", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20479, 20480], leaf: 20478 }, + Case { id: "bettertls::nameconstraints::tc6515", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20482, 20483], leaf: 20481 }, + Case { id: "bettertls::nameconstraints::tc6516", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20485, 20486], leaf: 20484 }, + Case { id: "bettertls::nameconstraints::tc6517", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20488, 20489], leaf: 20487 }, + Case { id: "bettertls::nameconstraints::tc6518", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20491, 20492], leaf: 20490 }, + Case { id: "bettertls::nameconstraints::tc6519", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20494, 20495], leaf: 20493 }, + Case { id: "bettertls::nameconstraints::tc6520", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20497, 20498], leaf: 20496 }, + Case { id: "bettertls::nameconstraints::tc6521", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20500, 20501], leaf: 20499 }, + Case { id: "bettertls::nameconstraints::tc6522", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20503, 20504], leaf: 20502 }, + Case { id: "bettertls::nameconstraints::tc6523", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20506, 20507], leaf: 20505 }, + Case { id: "bettertls::nameconstraints::tc6524", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20509, 20510], leaf: 20508 }, + Case { id: "bettertls::nameconstraints::tc6525", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20512, 20513], leaf: 20511 }, + Case { id: "bettertls::nameconstraints::tc6526", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20515, 20516], leaf: 20514 }, + Case { id: "bettertls::nameconstraints::tc6527", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20518, 20519], leaf: 20517 }, + Case { id: "bettertls::nameconstraints::tc6528", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20521, 20522], leaf: 20520 }, + Case { id: "bettertls::nameconstraints::tc6529", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20524, 20525], leaf: 20523 }, + Case { id: "bettertls::nameconstraints::tc6530", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20527, 20528], leaf: 20526 }, + Case { id: "bettertls::nameconstraints::tc6531", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20530, 20531], leaf: 20529 }, + Case { id: "bettertls::nameconstraints::tc6532", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20533, 20534], leaf: 20532 }, + Case { id: "bettertls::nameconstraints::tc6533", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20536, 20537], leaf: 20535 }, + Case { id: "bettertls::nameconstraints::tc6534", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20539, 20540], leaf: 20538 }, + Case { id: "bettertls::nameconstraints::tc6535", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20542, 20543], leaf: 20541 }, + Case { id: "bettertls::nameconstraints::tc6536", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20545, 20546], leaf: 20544 }, + Case { id: "bettertls::nameconstraints::tc6537", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20548, 20549], leaf: 20547 }, + Case { id: "bettertls::nameconstraints::tc6538", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20551, 20552], leaf: 20550 }, + Case { id: "bettertls::nameconstraints::tc6539", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20554, 20555], leaf: 20553 }, + Case { id: "bettertls::nameconstraints::tc6540", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20557, 20558], leaf: 20556 }, + Case { id: "bettertls::nameconstraints::tc6541", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20560, 20561], leaf: 20559 }, + Case { id: "bettertls::nameconstraints::tc6542", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20563, 20564], leaf: 20562 }, + Case { id: "bettertls::nameconstraints::tc6543", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20566, 20567], leaf: 20565 }, + Case { id: "bettertls::nameconstraints::tc6544", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20569, 20570], leaf: 20568 }, + Case { id: "bettertls::nameconstraints::tc6545", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20572, 20573], leaf: 20571 }, + Case { id: "bettertls::nameconstraints::tc6546", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20575, 20576], leaf: 20574 }, + Case { id: "bettertls::nameconstraints::tc6547", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20578, 20579], leaf: 20577 }, + Case { id: "bettertls::nameconstraints::tc6548", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20581, 20582], leaf: 20580 }, + Case { id: "bettertls::nameconstraints::tc6549", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20584, 20585], leaf: 20583 }, + Case { id: "bettertls::nameconstraints::tc6550", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20587, 20588], leaf: 20586 }, + Case { id: "bettertls::nameconstraints::tc6551", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20590, 20591], leaf: 20589 }, + Case { id: "bettertls::nameconstraints::tc6552", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20593, 20594], leaf: 20592 }, + Case { id: "bettertls::nameconstraints::tc6553", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20596, 20597], leaf: 20595 }, + Case { id: "bettertls::nameconstraints::tc6554", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20599, 20600], leaf: 20598 }, + Case { id: "bettertls::nameconstraints::tc6555", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20602, 20603], leaf: 20601 }, + Case { id: "bettertls::nameconstraints::tc6556", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20605, 20606], leaf: 20604 }, + Case { id: "bettertls::nameconstraints::tc6557", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20608, 20609], leaf: 20607 }, + Case { id: "bettertls::nameconstraints::tc6558", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20611, 20612], leaf: 20610 }, + Case { id: "bettertls::nameconstraints::tc6559", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20614, 20615], leaf: 20613 }, + Case { id: "bettertls::nameconstraints::tc6560", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20617, 20618], leaf: 20616 }, + Case { id: "bettertls::nameconstraints::tc6561", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20620, 20621], leaf: 20619 }, + Case { id: "bettertls::nameconstraints::tc6562", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20623, 20624], leaf: 20622 }, + Case { id: "bettertls::nameconstraints::tc6563", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20626, 20627], leaf: 20625 }, + Case { id: "bettertls::nameconstraints::tc6564", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20629, 20630], leaf: 20628 }, + Case { id: "bettertls::nameconstraints::tc6565", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20632, 20633], leaf: 20631 }, + Case { id: "bettertls::nameconstraints::tc6566", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20635, 20636], leaf: 20634 }, + Case { id: "bettertls::nameconstraints::tc6567", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20638, 20639], leaf: 20637 }, + Case { id: "bettertls::nameconstraints::tc6568", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20641, 20642], leaf: 20640 }, + Case { id: "bettertls::nameconstraints::tc6569", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20644, 20645], leaf: 20643 }, + Case { id: "bettertls::nameconstraints::tc6570", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20647, 20648], leaf: 20646 }, + Case { id: "bettertls::nameconstraints::tc6571", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20650, 20651], leaf: 20649 }, + Case { id: "bettertls::nameconstraints::tc6572", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20653, 20654], leaf: 20652 }, + Case { id: "bettertls::nameconstraints::tc6573", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20656, 20657], leaf: 20655 }, + Case { id: "bettertls::nameconstraints::tc6574", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20659, 20660], leaf: 20658 }, + Case { id: "bettertls::nameconstraints::tc6575", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20662, 20663], leaf: 20661 }, + Case { id: "bettertls::nameconstraints::tc6576", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20665, 20666], leaf: 20664 }, + Case { id: "bettertls::nameconstraints::tc6577", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20668, 20669], leaf: 20667 }, + Case { id: "bettertls::nameconstraints::tc6578", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20671, 20672], leaf: 20670 }, + Case { id: "bettertls::nameconstraints::tc6579", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20674, 20675], leaf: 20673 }, + Case { id: "bettertls::nameconstraints::tc6580", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20677, 20678], leaf: 20676 }, + Case { id: "bettertls::nameconstraints::tc6581", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20680, 20681], leaf: 20679 }, + Case { id: "bettertls::nameconstraints::tc6582", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20683, 20684], leaf: 20682 }, + Case { id: "bettertls::nameconstraints::tc6583", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20686, 20687], leaf: 20685 }, + Case { id: "bettertls::nameconstraints::tc6584", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20689, 20690], leaf: 20688 }, + Case { id: "bettertls::nameconstraints::tc6585", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20692, 20693], leaf: 20691 }, + Case { id: "bettertls::nameconstraints::tc6586", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20695, 20696], leaf: 20694 }, + Case { id: "bettertls::nameconstraints::tc6587", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20698, 20699], leaf: 20697 }, + Case { id: "bettertls::nameconstraints::tc6588", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20701, 20702], leaf: 20700 }, + Case { id: "bettertls::nameconstraints::tc6589", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20704, 20705], leaf: 20703 }, + Case { id: "bettertls::nameconstraints::tc6590", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20707, 20708], leaf: 20706 }, + Case { id: "bettertls::nameconstraints::tc6591", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20710, 20711], leaf: 20709 }, + Case { id: "bettertls::nameconstraints::tc6592", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20713, 20714], leaf: 20712 }, + Case { id: "bettertls::nameconstraints::tc6593", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20716, 20717], leaf: 20715 }, + Case { id: "bettertls::nameconstraints::tc6594", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20719, 20720], leaf: 20718 }, + Case { id: "bettertls::nameconstraints::tc6595", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20722, 20723], leaf: 20721 }, + Case { id: "bettertls::nameconstraints::tc6596", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20725, 20726], leaf: 20724 }, + Case { id: "bettertls::nameconstraints::tc6597", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20728, 20729], leaf: 20727 }, + Case { id: "bettertls::nameconstraints::tc6598", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20731, 20732], leaf: 20730 }, + Case { id: "bettertls::nameconstraints::tc6599", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20734, 20735], leaf: 20733 }, + Case { id: "bettertls::nameconstraints::tc6600", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20737, 20738], leaf: 20736 }, + Case { id: "bettertls::nameconstraints::tc6601", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20740, 20741], leaf: 20739 }, + Case { id: "bettertls::nameconstraints::tc6602", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20743, 20744], leaf: 20742 }, + Case { id: "bettertls::nameconstraints::tc6603", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20746, 20747], leaf: 20745 }, + Case { id: "bettertls::nameconstraints::tc6604", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20749, 20750], leaf: 20748 }, + Case { id: "bettertls::nameconstraints::tc6605", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20752, 20753], leaf: 20751 }, + Case { id: "bettertls::nameconstraints::tc6606", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20755, 20756], leaf: 20754 }, + Case { id: "bettertls::nameconstraints::tc6607", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20758, 20759], leaf: 20757 }, + Case { id: "bettertls::nameconstraints::tc6608", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20761, 20762], leaf: 20760 }, + Case { id: "bettertls::nameconstraints::tc6609", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20764, 20765], leaf: 20763 }, + Case { id: "bettertls::nameconstraints::tc6610", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20767, 20768], leaf: 20766 }, + Case { id: "bettertls::nameconstraints::tc6611", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20770, 20771], leaf: 20769 }, + Case { id: "bettertls::nameconstraints::tc6612", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20773, 20774], leaf: 20772 }, + Case { id: "bettertls::nameconstraints::tc6613", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20776, 20777], leaf: 20775 }, + Case { id: "bettertls::nameconstraints::tc6614", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20779, 20780], leaf: 20778 }, + Case { id: "bettertls::nameconstraints::tc6615", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20782, 20783], leaf: 20781 }, + Case { id: "bettertls::nameconstraints::tc6616", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20785, 20786], leaf: 20784 }, + Case { id: "bettertls::nameconstraints::tc6617", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20788, 20789], leaf: 20787 }, + Case { id: "bettertls::nameconstraints::tc6618", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20791, 20792], leaf: 20790 }, + Case { id: "bettertls::nameconstraints::tc6619", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20794, 20795], leaf: 20793 }, + Case { id: "bettertls::nameconstraints::tc6620", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20797, 20798], leaf: 20796 }, + Case { id: "bettertls::nameconstraints::tc6621", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20800, 20801], leaf: 20799 }, + Case { id: "bettertls::nameconstraints::tc6622", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20803, 20804], leaf: 20802 }, + Case { id: "bettertls::nameconstraints::tc6623", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20806, 20807], leaf: 20805 }, + Case { id: "bettertls::nameconstraints::tc6624", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20809, 20810], leaf: 20808 }, + Case { id: "bettertls::nameconstraints::tc6625", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20812, 20813], leaf: 20811 }, + Case { id: "bettertls::nameconstraints::tc6626", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20815, 20816], leaf: 20814 }, + Case { id: "bettertls::nameconstraints::tc6627", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20818, 20819], leaf: 20817 }, + Case { id: "bettertls::nameconstraints::tc6628", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20821, 20822], leaf: 20820 }, + Case { id: "bettertls::nameconstraints::tc6629", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20824, 20825], leaf: 20823 }, + Case { id: "bettertls::nameconstraints::tc6630", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20827, 20828], leaf: 20826 }, + Case { id: "bettertls::nameconstraints::tc6631", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20830, 20831], leaf: 20829 }, + Case { id: "bettertls::nameconstraints::tc6632", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20833, 20834], leaf: 20832 }, + Case { id: "bettertls::nameconstraints::tc6633", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20836, 20837], leaf: 20835 }, + Case { id: "bettertls::nameconstraints::tc6634", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20839, 20840], leaf: 20838 }, + Case { id: "bettertls::nameconstraints::tc6635", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20842, 20843], leaf: 20841 }, + Case { id: "bettertls::nameconstraints::tc6636", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20845, 20846], leaf: 20844 }, + Case { id: "bettertls::nameconstraints::tc6637", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20848, 20849], leaf: 20847 }, + Case { id: "bettertls::nameconstraints::tc6638", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20851, 20852], leaf: 20850 }, + Case { id: "bettertls::nameconstraints::tc6639", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20854, 20855], leaf: 20853 }, + Case { id: "bettertls::nameconstraints::tc6640", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20857, 20858], leaf: 20856 }, + Case { id: "bettertls::nameconstraints::tc6641", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20860, 20861], leaf: 20859 }, + Case { id: "bettertls::nameconstraints::tc6642", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20863, 20864], leaf: 20862 }, + Case { id: "bettertls::nameconstraints::tc6643", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20866, 20867], leaf: 20865 }, + Case { id: "bettertls::nameconstraints::tc6644", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20869, 20870], leaf: 20868 }, + Case { id: "bettertls::nameconstraints::tc6645", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20872, 20873], leaf: 20871 }, + Case { id: "bettertls::nameconstraints::tc6646", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20875, 20876], leaf: 20874 }, + Case { id: "bettertls::nameconstraints::tc6647", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20878, 20879], leaf: 20877 }, + Case { id: "bettertls::nameconstraints::tc6648", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20881, 20882], leaf: 20880 }, + Case { id: "bettertls::nameconstraints::tc6649", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20884, 20885], leaf: 20883 }, + Case { id: "bettertls::nameconstraints::tc6650", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20887, 20888], leaf: 20886 }, + Case { id: "bettertls::nameconstraints::tc6651", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20890, 20891], leaf: 20889 }, + Case { id: "bettertls::nameconstraints::tc6652", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20893, 20894], leaf: 20892 }, + Case { id: "bettertls::nameconstraints::tc6653", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20896, 20897], leaf: 20895 }, + Case { id: "bettertls::nameconstraints::tc6654", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20899, 20900], leaf: 20898 }, + Case { id: "bettertls::nameconstraints::tc6655", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20902, 20903], leaf: 20901 }, + Case { id: "bettertls::nameconstraints::tc6656", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20905, 20906], leaf: 20904 }, + Case { id: "bettertls::nameconstraints::tc6657", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20908, 20909], leaf: 20907 }, + Case { id: "bettertls::nameconstraints::tc6658", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20911, 20912], leaf: 20910 }, + Case { id: "bettertls::nameconstraints::tc6659", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20914, 20915], leaf: 20913 }, + Case { id: "bettertls::nameconstraints::tc6660", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20917, 20918], leaf: 20916 }, + Case { id: "bettertls::nameconstraints::tc6661", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20920, 20921], leaf: 20919 }, + Case { id: "bettertls::nameconstraints::tc6662", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20923, 20924], leaf: 20922 }, + Case { id: "bettertls::nameconstraints::tc6663", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20926, 20927], leaf: 20925 }, + Case { id: "bettertls::nameconstraints::tc6664", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20929, 20930], leaf: 20928 }, + Case { id: "bettertls::nameconstraints::tc6665", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20932, 20933], leaf: 20931 }, + Case { id: "bettertls::nameconstraints::tc6666", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20935, 20936], leaf: 20934 }, + Case { id: "bettertls::nameconstraints::tc6667", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20938, 20939], leaf: 20937 }, + Case { id: "bettertls::nameconstraints::tc6668", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20941, 20942], leaf: 20940 }, + Case { id: "bettertls::nameconstraints::tc6669", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20944, 20945], leaf: 20943 }, + Case { id: "bettertls::nameconstraints::tc6670", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20947, 20948], leaf: 20946 }, + Case { id: "bettertls::nameconstraints::tc6671", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20950, 20951], leaf: 20949 }, + Case { id: "bettertls::nameconstraints::tc6672", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20953, 20954], leaf: 20952 }, + Case { id: "bettertls::nameconstraints::tc6673", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20956, 20957], leaf: 20955 }, + Case { id: "bettertls::nameconstraints::tc6674", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20959, 20960], leaf: 20958 }, + Case { id: "bettertls::nameconstraints::tc6675", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20962, 20963], leaf: 20961 }, + Case { id: "bettertls::nameconstraints::tc6676", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20965, 20966], leaf: 20964 }, + Case { id: "bettertls::nameconstraints::tc6677", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20968, 20969], leaf: 20967 }, + Case { id: "bettertls::nameconstraints::tc6678", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20971, 20972], leaf: 20970 }, + Case { id: "bettertls::nameconstraints::tc6679", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20974, 20975], leaf: 20973 }, + Case { id: "bettertls::nameconstraints::tc6680", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20977, 20978], leaf: 20976 }, + Case { id: "bettertls::nameconstraints::tc6681", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20980, 20981], leaf: 20979 }, + Case { id: "bettertls::nameconstraints::tc6682", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20983, 20984], leaf: 20982 }, + Case { id: "bettertls::nameconstraints::tc6683", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20986, 20987], leaf: 20985 }, + Case { id: "bettertls::nameconstraints::tc6684", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20989, 20990], leaf: 20988 }, + Case { id: "bettertls::nameconstraints::tc6685", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20992, 20993], leaf: 20991 }, + Case { id: "bettertls::nameconstraints::tc6686", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20995, 20996], leaf: 20994 }, + Case { id: "bettertls::nameconstraints::tc6687", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[20998, 20999], leaf: 20997 }, + Case { id: "bettertls::nameconstraints::tc6688", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21001, 21002], leaf: 21000 }, + Case { id: "bettertls::nameconstraints::tc6689", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21004, 21005], leaf: 21003 }, + Case { id: "bettertls::nameconstraints::tc6690", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21007, 21008], leaf: 21006 }, + Case { id: "bettertls::nameconstraints::tc6691", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21010, 21011], leaf: 21009 }, + Case { id: "bettertls::nameconstraints::tc6692", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21013, 21014], leaf: 21012 }, + Case { id: "bettertls::nameconstraints::tc6693", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21016, 21017], leaf: 21015 }, + Case { id: "bettertls::nameconstraints::tc6694", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21019, 21020], leaf: 21018 }, + Case { id: "bettertls::nameconstraints::tc6695", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21022, 21023], leaf: 21021 }, + Case { id: "bettertls::nameconstraints::tc6696", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21025, 21026], leaf: 21024 }, + Case { id: "bettertls::nameconstraints::tc6697", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21028, 21029], leaf: 21027 }, + Case { id: "bettertls::nameconstraints::tc6698", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21031, 21032], leaf: 21030 }, + Case { id: "bettertls::nameconstraints::tc6699", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21034, 21035], leaf: 21033 }, + Case { id: "bettertls::nameconstraints::tc6700", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21037, 21038], leaf: 21036 }, + Case { id: "bettertls::nameconstraints::tc6701", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21040, 21041], leaf: 21039 }, + Case { id: "bettertls::nameconstraints::tc6702", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21043, 21044], leaf: 21042 }, + Case { id: "bettertls::nameconstraints::tc6703", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21046, 21047], leaf: 21045 }, + Case { id: "bettertls::nameconstraints::tc6704", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21049, 21050], leaf: 21048 }, + Case { id: "bettertls::nameconstraints::tc6705", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21052, 21053], leaf: 21051 }, + Case { id: "bettertls::nameconstraints::tc6706", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21055, 21056], leaf: 21054 }, + Case { id: "bettertls::nameconstraints::tc6707", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21058, 21059], leaf: 21057 }, + Case { id: "bettertls::nameconstraints::tc6708", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21061, 21062], leaf: 21060 }, + Case { id: "bettertls::nameconstraints::tc6709", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21064, 21065], leaf: 21063 }, + Case { id: "bettertls::nameconstraints::tc6710", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21067, 21068], leaf: 21066 }, + Case { id: "bettertls::nameconstraints::tc6711", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21070, 21071], leaf: 21069 }, + Case { id: "bettertls::nameconstraints::tc6712", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21073, 21074], leaf: 21072 }, + Case { id: "bettertls::nameconstraints::tc6713", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21076, 21077], leaf: 21075 }, + Case { id: "bettertls::nameconstraints::tc6714", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21079, 21080], leaf: 21078 }, + Case { id: "bettertls::nameconstraints::tc6715", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21082, 21083], leaf: 21081 }, + Case { id: "bettertls::nameconstraints::tc6716", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21085, 21086], leaf: 21084 }, + Case { id: "bettertls::nameconstraints::tc6717", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21088, 21089], leaf: 21087 }, + Case { id: "bettertls::nameconstraints::tc6718", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21091, 21092], leaf: 21090 }, + Case { id: "bettertls::nameconstraints::tc6719", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21094, 21095], leaf: 21093 }, + Case { id: "bettertls::nameconstraints::tc6720", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21097, 21098], leaf: 21096 }, + Case { id: "bettertls::nameconstraints::tc6721", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21100, 21101], leaf: 21099 }, + Case { id: "bettertls::nameconstraints::tc6722", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21103, 21104], leaf: 21102 }, + Case { id: "bettertls::nameconstraints::tc6723", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21106, 21107], leaf: 21105 }, + Case { id: "bettertls::nameconstraints::tc6724", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:53+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21109, 21110], leaf: 21108 }, + Case { id: "bettertls::nameconstraints::tc6725", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21112, 21113], leaf: 21111 }, + Case { id: "bettertls::nameconstraints::tc6726", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21115, 21116], leaf: 21114 }, + Case { id: "bettertls::nameconstraints::tc6727", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21118, 21119], leaf: 21117 }, + Case { id: "bettertls::nameconstraints::tc6728", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21121, 21122], leaf: 21120 }, + Case { id: "bettertls::nameconstraints::tc6729", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21124, 21125], leaf: 21123 }, + Case { id: "bettertls::nameconstraints::tc6730", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21127, 21128], leaf: 21126 }, + Case { id: "bettertls::nameconstraints::tc6731", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21130, 21131], leaf: 21129 }, + Case { id: "bettertls::nameconstraints::tc6732", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21133, 21134], leaf: 21132 }, + Case { id: "bettertls::nameconstraints::tc6733", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21136, 21137], leaf: 21135 }, + Case { id: "bettertls::nameconstraints::tc6734", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21139, 21140], leaf: 21138 }, + Case { id: "bettertls::nameconstraints::tc6735", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21142, 21143], leaf: 21141 }, + Case { id: "bettertls::nameconstraints::tc6736", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21145, 21146], leaf: 21144 }, + Case { id: "bettertls::nameconstraints::tc6737", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21148, 21149], leaf: 21147 }, + Case { id: "bettertls::nameconstraints::tc6738", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21151, 21152], leaf: 21150 }, + Case { id: "bettertls::nameconstraints::tc6739", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21154, 21155], leaf: 21153 }, + Case { id: "bettertls::nameconstraints::tc6740", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21157, 21158], leaf: 21156 }, + Case { id: "bettertls::nameconstraints::tc6741", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21160, 21161], leaf: 21159 }, + Case { id: "bettertls::nameconstraints::tc6742", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21163, 21164], leaf: 21162 }, + Case { id: "bettertls::nameconstraints::tc6743", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21166, 21167], leaf: 21165 }, + Case { id: "bettertls::nameconstraints::tc6744", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21169, 21170], leaf: 21168 }, + Case { id: "bettertls::nameconstraints::tc6745", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21172, 21173], leaf: 21171 }, + Case { id: "bettertls::nameconstraints::tc6746", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21175, 21176], leaf: 21174 }, + Case { id: "bettertls::nameconstraints::tc6747", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21178, 21179], leaf: 21177 }, + Case { id: "bettertls::nameconstraints::tc6748", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21181, 21182], leaf: 21180 }, + Case { id: "bettertls::nameconstraints::tc6749", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21184, 21185], leaf: 21183 }, + Case { id: "bettertls::nameconstraints::tc6750", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21187, 21188], leaf: 21186 }, + Case { id: "bettertls::nameconstraints::tc6751", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21190, 21191], leaf: 21189 }, + Case { id: "bettertls::nameconstraints::tc6752", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21193, 21194], leaf: 21192 }, + Case { id: "bettertls::nameconstraints::tc6753", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21196, 21197], leaf: 21195 }, + Case { id: "bettertls::nameconstraints::tc6754", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21199, 21200], leaf: 21198 }, + Case { id: "bettertls::nameconstraints::tc6755", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21202, 21203], leaf: 21201 }, + Case { id: "bettertls::nameconstraints::tc6756", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21205, 21206], leaf: 21204 }, + Case { id: "bettertls::nameconstraints::tc6757", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21208, 21209], leaf: 21207 }, + Case { id: "bettertls::nameconstraints::tc6758", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21211, 21212], leaf: 21210 }, + Case { id: "bettertls::nameconstraints::tc6759", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21214, 21215], leaf: 21213 }, + Case { id: "bettertls::nameconstraints::tc6760", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21217, 21218], leaf: 21216 }, + Case { id: "bettertls::nameconstraints::tc6761", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21220, 21221], leaf: 21219 }, + Case { id: "bettertls::nameconstraints::tc6762", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21223, 21224], leaf: 21222 }, + Case { id: "bettertls::nameconstraints::tc6763", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21226, 21227], leaf: 21225 }, + Case { id: "bettertls::nameconstraints::tc6764", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21229, 21230], leaf: 21228 }, + Case { id: "bettertls::nameconstraints::tc6765", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21232, 21233], leaf: 21231 }, + Case { id: "bettertls::nameconstraints::tc6766", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21235, 21236], leaf: 21234 }, + Case { id: "bettertls::nameconstraints::tc6767", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21238, 21239], leaf: 21237 }, + Case { id: "bettertls::nameconstraints::tc6768", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21241, 21242], leaf: 21240 }, + Case { id: "bettertls::nameconstraints::tc6769", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21244, 21245], leaf: 21243 }, + Case { id: "bettertls::nameconstraints::tc6770", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21247, 21248], leaf: 21246 }, + Case { id: "bettertls::nameconstraints::tc6771", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21250, 21251], leaf: 21249 }, + Case { id: "bettertls::nameconstraints::tc6772", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21253, 21254], leaf: 21252 }, + Case { id: "bettertls::nameconstraints::tc6773", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21256, 21257], leaf: 21255 }, + Case { id: "bettertls::nameconstraints::tc6774", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21259, 21260], leaf: 21258 }, + Case { id: "bettertls::nameconstraints::tc6775", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21262, 21263], leaf: 21261 }, + Case { id: "bettertls::nameconstraints::tc6776", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21265, 21266], leaf: 21264 }, + Case { id: "bettertls::nameconstraints::tc6777", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21268, 21269], leaf: 21267 }, + Case { id: "bettertls::nameconstraints::tc6778", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21271, 21272], leaf: 21270 }, + Case { id: "bettertls::nameconstraints::tc6779", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21274, 21275], leaf: 21273 }, + Case { id: "bettertls::nameconstraints::tc6780", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21277, 21278], leaf: 21276 }, + Case { id: "bettertls::nameconstraints::tc6781", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21280, 21281], leaf: 21279 }, + Case { id: "bettertls::nameconstraints::tc6782", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21283, 21284], leaf: 21282 }, + Case { id: "bettertls::nameconstraints::tc6783", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21286, 21287], leaf: 21285 }, + Case { id: "bettertls::nameconstraints::tc6784", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21289, 21290], leaf: 21288 }, + Case { id: "bettertls::nameconstraints::tc6785", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21292, 21293], leaf: 21291 }, + Case { id: "bettertls::nameconstraints::tc6786", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21295, 21296], leaf: 21294 }, + Case { id: "bettertls::nameconstraints::tc6787", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21298, 21299], leaf: 21297 }, + Case { id: "bettertls::nameconstraints::tc6788", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21301, 21302], leaf: 21300 }, + Case { id: "bettertls::nameconstraints::tc6789", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21304, 21305], leaf: 21303 }, + Case { id: "bettertls::nameconstraints::tc6790", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21307, 21308], leaf: 21306 }, + Case { id: "bettertls::nameconstraints::tc6791", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21310, 21311], leaf: 21309 }, + Case { id: "bettertls::nameconstraints::tc6792", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21313, 21314], leaf: 21312 }, + Case { id: "bettertls::nameconstraints::tc6793", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21316, 21317], leaf: 21315 }, + Case { id: "bettertls::nameconstraints::tc6794", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21319, 21320], leaf: 21318 }, + Case { id: "bettertls::nameconstraints::tc6795", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21322, 21323], leaf: 21321 }, + Case { id: "bettertls::nameconstraints::tc6796", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21325, 21326], leaf: 21324 }, + Case { id: "bettertls::nameconstraints::tc6797", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21328, 21329], leaf: 21327 }, + Case { id: "bettertls::nameconstraints::tc6798", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21331, 21332], leaf: 21330 }, + Case { id: "bettertls::nameconstraints::tc6799", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21334, 21335], leaf: 21333 }, + Case { id: "bettertls::nameconstraints::tc6800", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21337, 21338], leaf: 21336 }, + Case { id: "bettertls::nameconstraints::tc6801", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21340, 21341], leaf: 21339 }, + Case { id: "bettertls::nameconstraints::tc6802", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21343, 21344], leaf: 21342 }, + Case { id: "bettertls::nameconstraints::tc6803", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21346, 21347], leaf: 21345 }, + Case { id: "bettertls::nameconstraints::tc6804", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21349, 21350], leaf: 21348 }, + Case { id: "bettertls::nameconstraints::tc6805", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21352, 21353], leaf: 21351 }, + Case { id: "bettertls::nameconstraints::tc6806", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21355, 21356], leaf: 21354 }, + Case { id: "bettertls::nameconstraints::tc6807", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21358, 21359], leaf: 21357 }, + Case { id: "bettertls::nameconstraints::tc6808", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21361, 21362], leaf: 21360 }, + Case { id: "bettertls::nameconstraints::tc6809", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21364, 21365], leaf: 21363 }, + Case { id: "bettertls::nameconstraints::tc6810", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21367, 21368], leaf: 21366 }, + Case { id: "bettertls::nameconstraints::tc6811", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21370, 21371], leaf: 21369 }, + Case { id: "bettertls::nameconstraints::tc6812", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21373, 21374], leaf: 21372 }, + Case { id: "bettertls::nameconstraints::tc6813", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21376, 21377], leaf: 21375 }, + Case { id: "bettertls::nameconstraints::tc6814", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21379, 21380], leaf: 21378 }, + Case { id: "bettertls::nameconstraints::tc6815", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21382, 21383], leaf: 21381 }, + Case { id: "bettertls::nameconstraints::tc6816", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21385, 21386], leaf: 21384 }, + Case { id: "bettertls::nameconstraints::tc6817", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21388, 21389], leaf: 21387 }, + Case { id: "bettertls::nameconstraints::tc6818", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21391, 21392], leaf: 21390 }, + Case { id: "bettertls::nameconstraints::tc6819", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21394, 21395], leaf: 21393 }, + Case { id: "bettertls::nameconstraints::tc6820", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21397, 21398], leaf: 21396 }, + Case { id: "bettertls::nameconstraints::tc6821", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21400, 21401], leaf: 21399 }, + Case { id: "bettertls::nameconstraints::tc6822", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21403, 21404], leaf: 21402 }, + Case { id: "bettertls::nameconstraints::tc6823", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21406, 21407], leaf: 21405 }, + Case { id: "bettertls::nameconstraints::tc6824", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21409, 21410], leaf: 21408 }, + Case { id: "bettertls::nameconstraints::tc6825", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21412, 21413], leaf: 21411 }, + Case { id: "bettertls::nameconstraints::tc6826", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21415, 21416], leaf: 21414 }, + Case { id: "bettertls::nameconstraints::tc6827", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21418, 21419], leaf: 21417 }, + Case { id: "bettertls::nameconstraints::tc6828", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21421, 21422], leaf: 21420 }, + Case { id: "bettertls::nameconstraints::tc6829", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21424, 21425], leaf: 21423 }, + Case { id: "bettertls::nameconstraints::tc6830", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21427, 21428], leaf: 21426 }, + Case { id: "bettertls::nameconstraints::tc6831", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21430, 21431], leaf: 21429 }, + Case { id: "bettertls::nameconstraints::tc6832", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21433, 21434], leaf: 21432 }, + Case { id: "bettertls::nameconstraints::tc6833", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21436, 21437], leaf: 21435 }, + Case { id: "bettertls::nameconstraints::tc6834", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21439, 21440], leaf: 21438 }, + Case { id: "bettertls::nameconstraints::tc6835", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21442, 21443], leaf: 21441 }, + Case { id: "bettertls::nameconstraints::tc6836", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21445, 21446], leaf: 21444 }, + Case { id: "bettertls::nameconstraints::tc6837", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21448, 21449], leaf: 21447 }, + Case { id: "bettertls::nameconstraints::tc6838", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21451, 21452], leaf: 21450 }, + Case { id: "bettertls::nameconstraints::tc6839", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21454, 21455], leaf: 21453 }, + Case { id: "bettertls::nameconstraints::tc6840", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21457, 21458], leaf: 21456 }, + Case { id: "bettertls::nameconstraints::tc6841", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21460, 21461], leaf: 21459 }, + Case { id: "bettertls::nameconstraints::tc6842", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21463, 21464], leaf: 21462 }, + Case { id: "bettertls::nameconstraints::tc6843", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21466, 21467], leaf: 21465 }, + Case { id: "bettertls::nameconstraints::tc6844", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21469, 21470], leaf: 21468 }, + Case { id: "bettertls::nameconstraints::tc6845", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21472, 21473], leaf: 21471 }, + Case { id: "bettertls::nameconstraints::tc6846", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21475, 21476], leaf: 21474 }, + Case { id: "bettertls::nameconstraints::tc6847", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21478, 21479], leaf: 21477 }, + Case { id: "bettertls::nameconstraints::tc6848", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21481, 21482], leaf: 21480 }, + Case { id: "bettertls::nameconstraints::tc6849", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21484, 21485], leaf: 21483 }, + Case { id: "bettertls::nameconstraints::tc6850", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21487, 21488], leaf: 21486 }, + Case { id: "bettertls::nameconstraints::tc6851", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21490, 21491], leaf: 21489 }, + Case { id: "bettertls::nameconstraints::tc6852", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21493, 21494], leaf: 21492 }, + Case { id: "bettertls::nameconstraints::tc6853", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21496, 21497], leaf: 21495 }, + Case { id: "bettertls::nameconstraints::tc6854", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21499, 21500], leaf: 21498 }, + Case { id: "bettertls::nameconstraints::tc6855", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21502, 21503], leaf: 21501 }, + Case { id: "bettertls::nameconstraints::tc6856", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21505, 21506], leaf: 21504 }, + Case { id: "bettertls::nameconstraints::tc6857", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21508, 21509], leaf: 21507 }, + Case { id: "bettertls::nameconstraints::tc6858", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21511, 21512], leaf: 21510 }, + Case { id: "bettertls::nameconstraints::tc6859", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21514, 21515], leaf: 21513 }, + Case { id: "bettertls::nameconstraints::tc6860", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21517, 21518], leaf: 21516 }, + Case { id: "bettertls::nameconstraints::tc6861", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21520, 21521], leaf: 21519 }, + Case { id: "bettertls::nameconstraints::tc6862", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21523, 21524], leaf: 21522 }, + Case { id: "bettertls::nameconstraints::tc6863", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21526, 21527], leaf: 21525 }, + Case { id: "bettertls::nameconstraints::tc6864", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21529, 21530], leaf: 21528 }, + Case { id: "bettertls::nameconstraints::tc6865", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21532, 21533], leaf: 21531 }, + Case { id: "bettertls::nameconstraints::tc6866", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21535, 21536], leaf: 21534 }, + Case { id: "bettertls::nameconstraints::tc6867", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21538, 21539], leaf: 21537 }, + Case { id: "bettertls::nameconstraints::tc6868", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21541, 21542], leaf: 21540 }, + Case { id: "bettertls::nameconstraints::tc6869", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21544, 21545], leaf: 21543 }, + Case { id: "bettertls::nameconstraints::tc6870", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21547, 21548], leaf: 21546 }, + Case { id: "bettertls::nameconstraints::tc6871", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21550, 21551], leaf: 21549 }, + Case { id: "bettertls::nameconstraints::tc6872", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21553, 21554], leaf: 21552 }, + Case { id: "bettertls::nameconstraints::tc6873", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21556, 21557], leaf: 21555 }, + Case { id: "bettertls::nameconstraints::tc6874", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21559, 21560], leaf: 21558 }, + Case { id: "bettertls::nameconstraints::tc6875", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21562, 21563], leaf: 21561 }, + Case { id: "bettertls::nameconstraints::tc6876", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21565, 21566], leaf: 21564 }, + Case { id: "bettertls::nameconstraints::tc6877", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21568, 21569], leaf: 21567 }, + Case { id: "bettertls::nameconstraints::tc6878", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21571, 21572], leaf: 21570 }, + Case { id: "bettertls::nameconstraints::tc6879", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21574, 21575], leaf: 21573 }, + Case { id: "bettertls::nameconstraints::tc6880", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21577, 21578], leaf: 21576 }, + Case { id: "bettertls::nameconstraints::tc6881", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21580, 21581], leaf: 21579 }, + Case { id: "bettertls::nameconstraints::tc6882", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21583, 21584], leaf: 21582 }, + Case { id: "bettertls::nameconstraints::tc6883", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21586, 21587], leaf: 21585 }, + Case { id: "bettertls::nameconstraints::tc6884", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21589, 21590], leaf: 21588 }, + Case { id: "bettertls::nameconstraints::tc6885", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21592, 21593], leaf: 21591 }, + Case { id: "bettertls::nameconstraints::tc6886", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21595, 21596], leaf: 21594 }, + Case { id: "bettertls::nameconstraints::tc6887", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21598, 21599], leaf: 21597 }, + Case { id: "bettertls::nameconstraints::tc6888", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21601, 21602], leaf: 21600 }, + Case { id: "bettertls::nameconstraints::tc6889", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21604, 21605], leaf: 21603 }, + Case { id: "bettertls::nameconstraints::tc6890", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21607, 21608], leaf: 21606 }, + Case { id: "bettertls::nameconstraints::tc6891", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21610, 21611], leaf: 21609 }, + Case { id: "bettertls::nameconstraints::tc6892", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21613, 21614], leaf: 21612 }, + Case { id: "bettertls::nameconstraints::tc6893", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21616, 21617], leaf: 21615 }, + Case { id: "bettertls::nameconstraints::tc6894", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21619, 21620], leaf: 21618 }, + Case { id: "bettertls::nameconstraints::tc6895", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21622, 21623], leaf: 21621 }, + Case { id: "bettertls::nameconstraints::tc6896", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21625, 21626], leaf: 21624 }, + Case { id: "bettertls::nameconstraints::tc6897", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21628, 21629], leaf: 21627 }, + Case { id: "bettertls::nameconstraints::tc6898", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21631, 21632], leaf: 21630 }, + Case { id: "bettertls::nameconstraints::tc6899", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21634, 21635], leaf: 21633 }, + Case { id: "bettertls::nameconstraints::tc6900", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21637, 21638], leaf: 21636 }, + Case { id: "bettertls::nameconstraints::tc6901", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21640, 21641], leaf: 21639 }, + Case { id: "bettertls::nameconstraints::tc6902", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21643, 21644], leaf: 21642 }, + Case { id: "bettertls::nameconstraints::tc6903", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21646, 21647], leaf: 21645 }, + Case { id: "bettertls::nameconstraints::tc6904", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21649, 21650], leaf: 21648 }, + Case { id: "bettertls::nameconstraints::tc6905", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21652, 21653], leaf: 21651 }, + Case { id: "bettertls::nameconstraints::tc6906", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21655, 21656], leaf: 21654 }, + Case { id: "bettertls::nameconstraints::tc6907", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21658, 21659], leaf: 21657 }, + Case { id: "bettertls::nameconstraints::tc6908", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21661, 21662], leaf: 21660 }, + Case { id: "bettertls::nameconstraints::tc6909", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21664, 21665], leaf: 21663 }, + Case { id: "bettertls::nameconstraints::tc6910", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21667, 21668], leaf: 21666 }, + Case { id: "bettertls::nameconstraints::tc6911", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21670, 21671], leaf: 21669 }, + Case { id: "bettertls::nameconstraints::tc6912", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21673, 21674], leaf: 21672 }, + Case { id: "bettertls::nameconstraints::tc6913", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21676, 21677], leaf: 21675 }, + Case { id: "bettertls::nameconstraints::tc6914", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21679, 21680], leaf: 21678 }, + Case { id: "bettertls::nameconstraints::tc6915", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21682, 21683], leaf: 21681 }, + Case { id: "bettertls::nameconstraints::tc6916", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21685, 21686], leaf: 21684 }, + Case { id: "bettertls::nameconstraints::tc6917", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21688, 21689], leaf: 21687 }, + Case { id: "bettertls::nameconstraints::tc6918", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21691, 21692], leaf: 21690 }, + Case { id: "bettertls::nameconstraints::tc6919", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21694, 21695], leaf: 21693 }, + Case { id: "bettertls::nameconstraints::tc6920", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21697, 21698], leaf: 21696 }, + Case { id: "bettertls::nameconstraints::tc6921", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21700, 21701], leaf: 21699 }, + Case { id: "bettertls::nameconstraints::tc6922", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21703, 21704], leaf: 21702 }, + Case { id: "bettertls::nameconstraints::tc6923", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21706, 21707], leaf: 21705 }, + Case { id: "bettertls::nameconstraints::tc6924", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21709, 21710], leaf: 21708 }, + Case { id: "bettertls::nameconstraints::tc6925", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21712, 21713], leaf: 21711 }, + Case { id: "bettertls::nameconstraints::tc6926", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21715, 21716], leaf: 21714 }, + Case { id: "bettertls::nameconstraints::tc6927", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21718, 21719], leaf: 21717 }, + Case { id: "bettertls::nameconstraints::tc6928", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21721, 21722], leaf: 21720 }, + Case { id: "bettertls::nameconstraints::tc6929", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21724, 21725], leaf: 21723 }, + Case { id: "bettertls::nameconstraints::tc6930", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21727, 21728], leaf: 21726 }, + Case { id: "bettertls::nameconstraints::tc6931", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21730, 21731], leaf: 21729 }, + Case { id: "bettertls::nameconstraints::tc6932", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21733, 21734], leaf: 21732 }, + Case { id: "bettertls::nameconstraints::tc6933", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21736, 21737], leaf: 21735 }, + Case { id: "bettertls::nameconstraints::tc6934", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21739, 21740], leaf: 21738 }, + Case { id: "bettertls::nameconstraints::tc6935", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21742, 21743], leaf: 21741 }, + Case { id: "bettertls::nameconstraints::tc6936", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21745, 21746], leaf: 21744 }, + Case { id: "bettertls::nameconstraints::tc6937", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21748, 21749], leaf: 21747 }, + Case { id: "bettertls::nameconstraints::tc6938", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21751, 21752], leaf: 21750 }, + Case { id: "bettertls::nameconstraints::tc6939", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21754, 21755], leaf: 21753 }, + Case { id: "bettertls::nameconstraints::tc6940", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21757, 21758], leaf: 21756 }, + Case { id: "bettertls::nameconstraints::tc6941", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21760, 21761], leaf: 21759 }, + Case { id: "bettertls::nameconstraints::tc6942", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21763, 21764], leaf: 21762 }, + Case { id: "bettertls::nameconstraints::tc6943", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21766, 21767], leaf: 21765 }, + Case { id: "bettertls::nameconstraints::tc6944", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21769, 21770], leaf: 21768 }, + Case { id: "bettertls::nameconstraints::tc6945", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21772, 21773], leaf: 21771 }, + Case { id: "bettertls::nameconstraints::tc6946", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21775, 21776], leaf: 21774 }, + Case { id: "bettertls::nameconstraints::tc6947", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21778, 21779], leaf: 21777 }, + Case { id: "bettertls::nameconstraints::tc6948", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21781, 21782], leaf: 21780 }, + Case { id: "bettertls::nameconstraints::tc6949", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21784, 21785], leaf: 21783 }, + Case { id: "bettertls::nameconstraints::tc6950", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21787, 21788], leaf: 21786 }, + Case { id: "bettertls::nameconstraints::tc6951", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21790, 21791], leaf: 21789 }, + Case { id: "bettertls::nameconstraints::tc6952", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21793, 21794], leaf: 21792 }, + Case { id: "bettertls::nameconstraints::tc6953", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21796, 21797], leaf: 21795 }, + Case { id: "bettertls::nameconstraints::tc6954", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21799, 21800], leaf: 21798 }, + Case { id: "bettertls::nameconstraints::tc6955", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21802, 21803], leaf: 21801 }, + Case { id: "bettertls::nameconstraints::tc6956", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21805, 21806], leaf: 21804 }, + Case { id: "bettertls::nameconstraints::tc6957", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21808, 21809], leaf: 21807 }, + Case { id: "bettertls::nameconstraints::tc6958", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21811, 21812], leaf: 21810 }, + Case { id: "bettertls::nameconstraints::tc6959", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21814, 21815], leaf: 21813 }, + Case { id: "bettertls::nameconstraints::tc6960", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21817, 21818], leaf: 21816 }, + Case { id: "bettertls::nameconstraints::tc6961", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21820, 21821], leaf: 21819 }, + Case { id: "bettertls::nameconstraints::tc6962", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21823, 21824], leaf: 21822 }, + Case { id: "bettertls::nameconstraints::tc6963", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21826, 21827], leaf: 21825 }, + Case { id: "bettertls::nameconstraints::tc6964", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21829, 21830], leaf: 21828 }, + Case { id: "bettertls::nameconstraints::tc6965", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21832, 21833], leaf: 21831 }, + Case { id: "bettertls::nameconstraints::tc6966", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21835, 21836], leaf: 21834 }, + Case { id: "bettertls::nameconstraints::tc6967", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21838, 21839], leaf: 21837 }, + Case { id: "bettertls::nameconstraints::tc6968", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21841, 21842], leaf: 21840 }, + Case { id: "bettertls::nameconstraints::tc6969", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21844, 21845], leaf: 21843 }, + Case { id: "bettertls::nameconstraints::tc6970", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21847, 21848], leaf: 21846 }, + Case { id: "bettertls::nameconstraints::tc6971", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21850, 21851], leaf: 21849 }, + Case { id: "bettertls::nameconstraints::tc6972", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21853, 21854], leaf: 21852 }, + Case { id: "bettertls::nameconstraints::tc6973", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21856, 21857], leaf: 21855 }, + Case { id: "bettertls::nameconstraints::tc6974", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21859, 21860], leaf: 21858 }, + Case { id: "bettertls::nameconstraints::tc6975", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21862, 21863], leaf: 21861 }, + Case { id: "bettertls::nameconstraints::tc6976", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21865, 21866], leaf: 21864 }, + Case { id: "bettertls::nameconstraints::tc6977", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21868, 21869], leaf: 21867 }, + Case { id: "bettertls::nameconstraints::tc6978", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21871, 21872], leaf: 21870 }, + Case { id: "bettertls::nameconstraints::tc6979", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21874, 21875], leaf: 21873 }, + Case { id: "bettertls::nameconstraints::tc6980", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21877, 21878], leaf: 21876 }, + Case { id: "bettertls::nameconstraints::tc6981", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21880, 21881], leaf: 21879 }, + Case { id: "bettertls::nameconstraints::tc6982", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21883, 21884], leaf: 21882 }, + Case { id: "bettertls::nameconstraints::tc6983", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21886, 21887], leaf: 21885 }, + Case { id: "bettertls::nameconstraints::tc6984", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21889, 21890], leaf: 21888 }, + Case { id: "bettertls::nameconstraints::tc6985", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21892, 21893], leaf: 21891 }, + Case { id: "bettertls::nameconstraints::tc6986", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21895, 21896], leaf: 21894 }, + Case { id: "bettertls::nameconstraints::tc6987", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21898, 21899], leaf: 21897 }, + Case { id: "bettertls::nameconstraints::tc6988", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21901, 21902], leaf: 21900 }, + Case { id: "bettertls::nameconstraints::tc6989", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21904, 21905], leaf: 21903 }, + Case { id: "bettertls::nameconstraints::tc6990", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21907, 21908], leaf: 21906 }, + Case { id: "bettertls::nameconstraints::tc6991", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21910, 21911], leaf: 21909 }, + Case { id: "bettertls::nameconstraints::tc6992", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21913, 21914], leaf: 21912 }, + Case { id: "bettertls::nameconstraints::tc6993", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21916, 21917], leaf: 21915 }, + Case { id: "bettertls::nameconstraints::tc6994", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21919, 21920], leaf: 21918 }, + Case { id: "bettertls::nameconstraints::tc6995", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21922, 21923], leaf: 21921 }, + Case { id: "bettertls::nameconstraints::tc6996", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21925, 21926], leaf: 21924 }, + Case { id: "bettertls::nameconstraints::tc6997", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21928, 21929], leaf: 21927 }, + Case { id: "bettertls::nameconstraints::tc6998", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21931, 21932], leaf: 21930 }, + Case { id: "bettertls::nameconstraints::tc6999", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21934, 21935], leaf: 21933 }, + Case { id: "bettertls::nameconstraints::tc7000", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21937, 21938], leaf: 21936 }, + Case { id: "bettertls::nameconstraints::tc7001", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21940, 21941], leaf: 21939 }, + Case { id: "bettertls::nameconstraints::tc7002", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21943, 21944], leaf: 21942 }, + Case { id: "bettertls::nameconstraints::tc7003", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21946, 21947], leaf: 21945 }, + Case { id: "bettertls::nameconstraints::tc7004", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21949, 21950], leaf: 21948 }, + Case { id: "bettertls::nameconstraints::tc7005", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21952, 21953], leaf: 21951 }, + Case { id: "bettertls::nameconstraints::tc7006", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21955, 21956], leaf: 21954 }, + Case { id: "bettertls::nameconstraints::tc7007", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21958, 21959], leaf: 21957 }, + Case { id: "bettertls::nameconstraints::tc7008", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21961, 21962], leaf: 21960 }, + Case { id: "bettertls::nameconstraints::tc7009", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21964, 21965], leaf: 21963 }, + Case { id: "bettertls::nameconstraints::tc7010", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21967, 21968], leaf: 21966 }, + Case { id: "bettertls::nameconstraints::tc7011", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21970, 21971], leaf: 21969 }, + Case { id: "bettertls::nameconstraints::tc7012", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21973, 21974], leaf: 21972 }, + Case { id: "bettertls::nameconstraints::tc7013", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21976, 21977], leaf: 21975 }, + Case { id: "bettertls::nameconstraints::tc7014", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21979, 21980], leaf: 21978 }, + Case { id: "bettertls::nameconstraints::tc7015", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21982, 21983], leaf: 21981 }, + Case { id: "bettertls::nameconstraints::tc7016", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21985, 21986], leaf: 21984 }, + Case { id: "bettertls::nameconstraints::tc7017", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21988, 21989], leaf: 21987 }, + Case { id: "bettertls::nameconstraints::tc7018", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21991, 21992], leaf: 21990 }, + Case { id: "bettertls::nameconstraints::tc7019", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21994, 21995], leaf: 21993 }, + Case { id: "bettertls::nameconstraints::tc7020", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[21997, 21998], leaf: 21996 }, + Case { id: "bettertls::nameconstraints::tc7021", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22000, 22001], leaf: 21999 }, + Case { id: "bettertls::nameconstraints::tc7022", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22003, 22004], leaf: 22002 }, + Case { id: "bettertls::nameconstraints::tc7023", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22006, 22007], leaf: 22005 }, + Case { id: "bettertls::nameconstraints::tc7024", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22009, 22010], leaf: 22008 }, + Case { id: "bettertls::nameconstraints::tc7025", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22012, 22013], leaf: 22011 }, + Case { id: "bettertls::nameconstraints::tc7026", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22015, 22016], leaf: 22014 }, + Case { id: "bettertls::nameconstraints::tc7027", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22018, 22019], leaf: 22017 }, + Case { id: "bettertls::nameconstraints::tc7028", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22021, 22022], leaf: 22020 }, + Case { id: "bettertls::nameconstraints::tc7029", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22024, 22025], leaf: 22023 }, + Case { id: "bettertls::nameconstraints::tc7030", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22027, 22028], leaf: 22026 }, + Case { id: "bettertls::nameconstraints::tc7031", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22030, 22031], leaf: 22029 }, + Case { id: "bettertls::nameconstraints::tc7032", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22033, 22034], leaf: 22032 }, + Case { id: "bettertls::nameconstraints::tc7033", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22036, 22037], leaf: 22035 }, + Case { id: "bettertls::nameconstraints::tc7034", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22039, 22040], leaf: 22038 }, + Case { id: "bettertls::nameconstraints::tc7035", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22042, 22043], leaf: 22041 }, + Case { id: "bettertls::nameconstraints::tc7036", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22045, 22046], leaf: 22044 }, + Case { id: "bettertls::nameconstraints::tc7037", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22048, 22049], leaf: 22047 }, + Case { id: "bettertls::nameconstraints::tc7038", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22051, 22052], leaf: 22050 }, + Case { id: "bettertls::nameconstraints::tc7039", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22054, 22055], leaf: 22053 }, + Case { id: "bettertls::nameconstraints::tc7040", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22057, 22058], leaf: 22056 }, + Case { id: "bettertls::nameconstraints::tc7041", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22060, 22061], leaf: 22059 }, + Case { id: "bettertls::nameconstraints::tc7042", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22063, 22064], leaf: 22062 }, + Case { id: "bettertls::nameconstraints::tc7043", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22066, 22067], leaf: 22065 }, + Case { id: "bettertls::nameconstraints::tc7044", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22069, 22070], leaf: 22068 }, + Case { id: "bettertls::nameconstraints::tc7045", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22072, 22073], leaf: 22071 }, + Case { id: "bettertls::nameconstraints::tc7046", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22075, 22076], leaf: 22074 }, + Case { id: "bettertls::nameconstraints::tc7047", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22078, 22079], leaf: 22077 }, + Case { id: "bettertls::nameconstraints::tc7048", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22081, 22082], leaf: 22080 }, + Case { id: "bettertls::nameconstraints::tc7049", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22084, 22085], leaf: 22083 }, + Case { id: "bettertls::nameconstraints::tc7050", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22087, 22088], leaf: 22086 }, + Case { id: "bettertls::nameconstraints::tc7051", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22090, 22091], leaf: 22089 }, + Case { id: "bettertls::nameconstraints::tc7052", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22093, 22094], leaf: 22092 }, + Case { id: "bettertls::nameconstraints::tc7053", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22096, 22097], leaf: 22095 }, + Case { id: "bettertls::nameconstraints::tc7054", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22099, 22100], leaf: 22098 }, + Case { id: "bettertls::nameconstraints::tc7055", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22102, 22103], leaf: 22101 }, + Case { id: "bettertls::nameconstraints::tc7056", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22105, 22106], leaf: 22104 }, + Case { id: "bettertls::nameconstraints::tc7057", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22108, 22109], leaf: 22107 }, + Case { id: "bettertls::nameconstraints::tc7058", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22111, 22112], leaf: 22110 }, + Case { id: "bettertls::nameconstraints::tc7059", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22114, 22115], leaf: 22113 }, + Case { id: "bettertls::nameconstraints::tc7060", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22117, 22118], leaf: 22116 }, + Case { id: "bettertls::nameconstraints::tc7061", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22120, 22121], leaf: 22119 }, + Case { id: "bettertls::nameconstraints::tc7062", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22123, 22124], leaf: 22122 }, + Case { id: "bettertls::nameconstraints::tc7063", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22126, 22127], leaf: 22125 }, + Case { id: "bettertls::nameconstraints::tc7064", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22129, 22130], leaf: 22128 }, + Case { id: "bettertls::nameconstraints::tc7065", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22132, 22133], leaf: 22131 }, + Case { id: "bettertls::nameconstraints::tc7066", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22135, 22136], leaf: 22134 }, + Case { id: "bettertls::nameconstraints::tc7067", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22138, 22139], leaf: 22137 }, + Case { id: "bettertls::nameconstraints::tc7068", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22141, 22142], leaf: 22140 }, + Case { id: "bettertls::nameconstraints::tc7069", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22144, 22145], leaf: 22143 }, + Case { id: "bettertls::nameconstraints::tc7070", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22147, 22148], leaf: 22146 }, + Case { id: "bettertls::nameconstraints::tc7071", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22150, 22151], leaf: 22149 }, + Case { id: "bettertls::nameconstraints::tc7072", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22153, 22154], leaf: 22152 }, + Case { id: "bettertls::nameconstraints::tc7073", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22156, 22157], leaf: 22155 }, + Case { id: "bettertls::nameconstraints::tc7074", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22159, 22160], leaf: 22158 }, + Case { id: "bettertls::nameconstraints::tc7075", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22162, 22163], leaf: 22161 }, + Case { id: "bettertls::nameconstraints::tc7076", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22165, 22166], leaf: 22164 }, + Case { id: "bettertls::nameconstraints::tc7077", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22168, 22169], leaf: 22167 }, + Case { id: "bettertls::nameconstraints::tc7078", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22171, 22172], leaf: 22170 }, + Case { id: "bettertls::nameconstraints::tc7079", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22174, 22175], leaf: 22173 }, + Case { id: "bettertls::nameconstraints::tc7080", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22177, 22178], leaf: 22176 }, + Case { id: "bettertls::nameconstraints::tc7081", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22180, 22181], leaf: 22179 }, + Case { id: "bettertls::nameconstraints::tc7082", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22183, 22184], leaf: 22182 }, + Case { id: "bettertls::nameconstraints::tc7083", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22186, 22187], leaf: 22185 }, + Case { id: "bettertls::nameconstraints::tc7084", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22189, 22190], leaf: 22188 }, + Case { id: "bettertls::nameconstraints::tc7085", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22192, 22193], leaf: 22191 }, + Case { id: "bettertls::nameconstraints::tc7086", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22195, 22196], leaf: 22194 }, + Case { id: "bettertls::nameconstraints::tc7087", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22198, 22199], leaf: 22197 }, + Case { id: "bettertls::nameconstraints::tc7088", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22201, 22202], leaf: 22200 }, + Case { id: "bettertls::nameconstraints::tc7089", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22204, 22205], leaf: 22203 }, + Case { id: "bettertls::nameconstraints::tc7090", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22207, 22208], leaf: 22206 }, + Case { id: "bettertls::nameconstraints::tc7091", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22210, 22211], leaf: 22209 }, + Case { id: "bettertls::nameconstraints::tc7092", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22213, 22214], leaf: 22212 }, + Case { id: "bettertls::nameconstraints::tc7093", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22216, 22217], leaf: 22215 }, + Case { id: "bettertls::nameconstraints::tc7094", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22219, 22220], leaf: 22218 }, + Case { id: "bettertls::nameconstraints::tc7095", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22222, 22223], leaf: 22221 }, + Case { id: "bettertls::nameconstraints::tc7096", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22225, 22226], leaf: 22224 }, + Case { id: "bettertls::nameconstraints::tc7097", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22228, 22229], leaf: 22227 }, + Case { id: "bettertls::nameconstraints::tc7098", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22231, 22232], leaf: 22230 }, + Case { id: "bettertls::nameconstraints::tc7099", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22234, 22235], leaf: 22233 }, + Case { id: "bettertls::nameconstraints::tc7100", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22237, 22238], leaf: 22236 }, + Case { id: "bettertls::nameconstraints::tc7101", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22240, 22241], leaf: 22239 }, + Case { id: "bettertls::nameconstraints::tc7102", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22243, 22244], leaf: 22242 }, + Case { id: "bettertls::nameconstraints::tc7103", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22246, 22247], leaf: 22245 }, + Case { id: "bettertls::nameconstraints::tc7104", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22249, 22250], leaf: 22248 }, + Case { id: "bettertls::nameconstraints::tc7105", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22252, 22253], leaf: 22251 }, + Case { id: "bettertls::nameconstraints::tc7106", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22255, 22256], leaf: 22254 }, + Case { id: "bettertls::nameconstraints::tc7107", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22258, 22259], leaf: 22257 }, + Case { id: "bettertls::nameconstraints::tc7108", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22261, 22262], leaf: 22260 }, + Case { id: "bettertls::nameconstraints::tc7109", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22264, 22265], leaf: 22263 }, + Case { id: "bettertls::nameconstraints::tc7110", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22267, 22268], leaf: 22266 }, + Case { id: "bettertls::nameconstraints::tc7111", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22270, 22271], leaf: 22269 }, + Case { id: "bettertls::nameconstraints::tc7112", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22273, 22274], leaf: 22272 }, + Case { id: "bettertls::nameconstraints::tc7113", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22276, 22277], leaf: 22275 }, + Case { id: "bettertls::nameconstraints::tc7114", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22279, 22280], leaf: 22278 }, + Case { id: "bettertls::nameconstraints::tc7115", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22282, 22283], leaf: 22281 }, + Case { id: "bettertls::nameconstraints::tc7116", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22285, 22286], leaf: 22284 }, + Case { id: "bettertls::nameconstraints::tc7117", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22288, 22289], leaf: 22287 }, + Case { id: "bettertls::nameconstraints::tc7118", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22291, 22292], leaf: 22290 }, + Case { id: "bettertls::nameconstraints::tc7119", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22294, 22295], leaf: 22293 }, + Case { id: "bettertls::nameconstraints::tc7120", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22297, 22298], leaf: 22296 }, + Case { id: "bettertls::nameconstraints::tc7121", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22300, 22301], leaf: 22299 }, + Case { id: "bettertls::nameconstraints::tc7122", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22303, 22304], leaf: 22302 }, + Case { id: "bettertls::nameconstraints::tc7123", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22306, 22307], leaf: 22305 }, + Case { id: "bettertls::nameconstraints::tc7124", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22309, 22310], leaf: 22308 }, + Case { id: "bettertls::nameconstraints::tc7125", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22312, 22313], leaf: 22311 }, + Case { id: "bettertls::nameconstraints::tc7126", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22315, 22316], leaf: 22314 }, + Case { id: "bettertls::nameconstraints::tc7127", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22318, 22319], leaf: 22317 }, + Case { id: "bettertls::nameconstraints::tc7128", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22321, 22322], leaf: 22320 }, + Case { id: "bettertls::nameconstraints::tc7129", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22324, 22325], leaf: 22323 }, + Case { id: "bettertls::nameconstraints::tc7130", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22327, 22328], leaf: 22326 }, + Case { id: "bettertls::nameconstraints::tc7131", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22330, 22331], leaf: 22329 }, + Case { id: "bettertls::nameconstraints::tc7132", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22333, 22334], leaf: 22332 }, + Case { id: "bettertls::nameconstraints::tc7133", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22336, 22337], leaf: 22335 }, + Case { id: "bettertls::nameconstraints::tc7134", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22339, 22340], leaf: 22338 }, + Case { id: "bettertls::nameconstraints::tc7135", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22342, 22343], leaf: 22341 }, + Case { id: "bettertls::nameconstraints::tc7136", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22345, 22346], leaf: 22344 }, + Case { id: "bettertls::nameconstraints::tc7137", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22348, 22349], leaf: 22347 }, + Case { id: "bettertls::nameconstraints::tc7138", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22351, 22352], leaf: 22350 }, + Case { id: "bettertls::nameconstraints::tc7139", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22354, 22355], leaf: 22353 }, + Case { id: "bettertls::nameconstraints::tc7140", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22357, 22358], leaf: 22356 }, + Case { id: "bettertls::nameconstraints::tc7141", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22360, 22361], leaf: 22359 }, + Case { id: "bettertls::nameconstraints::tc7142", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22363, 22364], leaf: 22362 }, + Case { id: "bettertls::nameconstraints::tc7143", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22366, 22367], leaf: 22365 }, + Case { id: "bettertls::nameconstraints::tc7144", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22369, 22370], leaf: 22368 }, + Case { id: "bettertls::nameconstraints::tc7145", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22372, 22373], leaf: 22371 }, + Case { id: "bettertls::nameconstraints::tc7146", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22375, 22376], leaf: 22374 }, + Case { id: "bettertls::nameconstraints::tc7147", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22378, 22379], leaf: 22377 }, + Case { id: "bettertls::nameconstraints::tc7148", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22381, 22382], leaf: 22380 }, + Case { id: "bettertls::nameconstraints::tc7149", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22384, 22385], leaf: 22383 }, + Case { id: "bettertls::nameconstraints::tc7150", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22387, 22388], leaf: 22386 }, + Case { id: "bettertls::nameconstraints::tc7151", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22390, 22391], leaf: 22389 }, + Case { id: "bettertls::nameconstraints::tc7152", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22393, 22394], leaf: 22392 }, + Case { id: "bettertls::nameconstraints::tc7153", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22396, 22397], leaf: 22395 }, + Case { id: "bettertls::nameconstraints::tc7154", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22399, 22400], leaf: 22398 }, + Case { id: "bettertls::nameconstraints::tc7155", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22402, 22403], leaf: 22401 }, + Case { id: "bettertls::nameconstraints::tc7156", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22405, 22406], leaf: 22404 }, + Case { id: "bettertls::nameconstraints::tc7157", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22408, 22409], leaf: 22407 }, + Case { id: "bettertls::nameconstraints::tc7158", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22411, 22412], leaf: 22410 }, + Case { id: "bettertls::nameconstraints::tc7159", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22414, 22415], leaf: 22413 }, + Case { id: "bettertls::nameconstraints::tc7160", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22417, 22418], leaf: 22416 }, + Case { id: "bettertls::nameconstraints::tc7161", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22420, 22421], leaf: 22419 }, + Case { id: "bettertls::nameconstraints::tc7162", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22423, 22424], leaf: 22422 }, + Case { id: "bettertls::nameconstraints::tc7163", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22426, 22427], leaf: 22425 }, + Case { id: "bettertls::nameconstraints::tc7164", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22429, 22430], leaf: 22428 }, + Case { id: "bettertls::nameconstraints::tc7165", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22432, 22433], leaf: 22431 }, + Case { id: "bettertls::nameconstraints::tc7166", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22435, 22436], leaf: 22434 }, + Case { id: "bettertls::nameconstraints::tc7167", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22438, 22439], leaf: 22437 }, + Case { id: "bettertls::nameconstraints::tc7168", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22441, 22442], leaf: 22440 }, + Case { id: "bettertls::nameconstraints::tc7169", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22444, 22445], leaf: 22443 }, + Case { id: "bettertls::nameconstraints::tc7170", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22447, 22448], leaf: 22446 }, + Case { id: "bettertls::nameconstraints::tc7171", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22450, 22451], leaf: 22449 }, + Case { id: "bettertls::nameconstraints::tc7172", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22453, 22454], leaf: 22452 }, + Case { id: "bettertls::nameconstraints::tc7173", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22456, 22457], leaf: 22455 }, + Case { id: "bettertls::nameconstraints::tc7174", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22459, 22460], leaf: 22458 }, + Case { id: "bettertls::nameconstraints::tc7175", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22462, 22463], leaf: 22461 }, + Case { id: "bettertls::nameconstraints::tc7176", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22465, 22466], leaf: 22464 }, + Case { id: "bettertls::nameconstraints::tc7177", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22468, 22469], leaf: 22467 }, + Case { id: "bettertls::nameconstraints::tc7178", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22471, 22472], leaf: 22470 }, + Case { id: "bettertls::nameconstraints::tc7179", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22474, 22475], leaf: 22473 }, + Case { id: "bettertls::nameconstraints::tc7180", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22477, 22478], leaf: 22476 }, + Case { id: "bettertls::nameconstraints::tc7181", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22480, 22481], leaf: 22479 }, + Case { id: "bettertls::nameconstraints::tc7182", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22483, 22484], leaf: 22482 }, + Case { id: "bettertls::nameconstraints::tc7183", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22486, 22487], leaf: 22485 }, + Case { id: "bettertls::nameconstraints::tc7184", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22489, 22490], leaf: 22488 }, + Case { id: "bettertls::nameconstraints::tc7185", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22492, 22493], leaf: 22491 }, + Case { id: "bettertls::nameconstraints::tc7186", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22495, 22496], leaf: 22494 }, + Case { id: "bettertls::nameconstraints::tc7187", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22498, 22499], leaf: 22497 }, + Case { id: "bettertls::nameconstraints::tc7188", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22501, 22502], leaf: 22500 }, + Case { id: "bettertls::nameconstraints::tc7189", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22504, 22505], leaf: 22503 }, + Case { id: "bettertls::nameconstraints::tc7190", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22507, 22508], leaf: 22506 }, + Case { id: "bettertls::nameconstraints::tc7191", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22510, 22511], leaf: 22509 }, + Case { id: "bettertls::nameconstraints::tc7192", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22513, 22514], leaf: 22512 }, + Case { id: "bettertls::nameconstraints::tc7193", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22516, 22517], leaf: 22515 }, + Case { id: "bettertls::nameconstraints::tc7194", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22519, 22520], leaf: 22518 }, + Case { id: "bettertls::nameconstraints::tc7195", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22522, 22523], leaf: 22521 }, + Case { id: "bettertls::nameconstraints::tc7196", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22525, 22526], leaf: 22524 }, + Case { id: "bettertls::nameconstraints::tc7197", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22528, 22529], leaf: 22527 }, + Case { id: "bettertls::nameconstraints::tc7198", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22531, 22532], leaf: 22530 }, + Case { id: "bettertls::nameconstraints::tc7199", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22534, 22535], leaf: 22533 }, + Case { id: "bettertls::nameconstraints::tc7200", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22537, 22538], leaf: 22536 }, + Case { id: "bettertls::nameconstraints::tc7201", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22540, 22541], leaf: 22539 }, + Case { id: "bettertls::nameconstraints::tc7202", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22543, 22544], leaf: 22542 }, + Case { id: "bettertls::nameconstraints::tc7203", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22546, 22547], leaf: 22545 }, + Case { id: "bettertls::nameconstraints::tc7204", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22549, 22550], leaf: 22548 }, + Case { id: "bettertls::nameconstraints::tc7205", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22552, 22553], leaf: 22551 }, + Case { id: "bettertls::nameconstraints::tc7206", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22555, 22556], leaf: 22554 }, + Case { id: "bettertls::nameconstraints::tc7207", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22558, 22559], leaf: 22557 }, + Case { id: "bettertls::nameconstraints::tc7208", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22561, 22562], leaf: 22560 }, + Case { id: "bettertls::nameconstraints::tc7209", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22564, 22565], leaf: 22563 }, + Case { id: "bettertls::nameconstraints::tc7210", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22567, 22568], leaf: 22566 }, + Case { id: "bettertls::nameconstraints::tc7211", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22570, 22571], leaf: 22569 }, + Case { id: "bettertls::nameconstraints::tc7212", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22573, 22574], leaf: 22572 }, + Case { id: "bettertls::nameconstraints::tc7213", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22576, 22577], leaf: 22575 }, + Case { id: "bettertls::nameconstraints::tc7214", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22579, 22580], leaf: 22578 }, + Case { id: "bettertls::nameconstraints::tc7215", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22582, 22583], leaf: 22581 }, + Case { id: "bettertls::nameconstraints::tc7216", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22585, 22586], leaf: 22584 }, + Case { id: "bettertls::nameconstraints::tc7217", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22588, 22589], leaf: 22587 }, + Case { id: "bettertls::nameconstraints::tc7218", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22591, 22592], leaf: 22590 }, + Case { id: "bettertls::nameconstraints::tc7219", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22594, 22595], leaf: 22593 }, + Case { id: "bettertls::nameconstraints::tc7220", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22597, 22598], leaf: 22596 }, + Case { id: "bettertls::nameconstraints::tc7221", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22600, 22601], leaf: 22599 }, + Case { id: "bettertls::nameconstraints::tc7222", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22603, 22604], leaf: 22602 }, + Case { id: "bettertls::nameconstraints::tc7223", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22606, 22607], leaf: 22605 }, + Case { id: "bettertls::nameconstraints::tc7224", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22609, 22610], leaf: 22608 }, + Case { id: "bettertls::nameconstraints::tc7225", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22612, 22613], leaf: 22611 }, + Case { id: "bettertls::nameconstraints::tc7226", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22615, 22616], leaf: 22614 }, + Case { id: "bettertls::nameconstraints::tc7227", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22618, 22619], leaf: 22617 }, + Case { id: "bettertls::nameconstraints::tc7228", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22621, 22622], leaf: 22620 }, + Case { id: "bettertls::nameconstraints::tc7229", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22624, 22625], leaf: 22623 }, + Case { id: "bettertls::nameconstraints::tc7230", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22627, 22628], leaf: 22626 }, + Case { id: "bettertls::nameconstraints::tc7231", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22630, 22631], leaf: 22629 }, + Case { id: "bettertls::nameconstraints::tc7232", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22633, 22634], leaf: 22632 }, + Case { id: "bettertls::nameconstraints::tc7233", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22636, 22637], leaf: 22635 }, + Case { id: "bettertls::nameconstraints::tc7234", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22639, 22640], leaf: 22638 }, + Case { id: "bettertls::nameconstraints::tc7235", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22642, 22643], leaf: 22641 }, + Case { id: "bettertls::nameconstraints::tc7236", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22645, 22646], leaf: 22644 }, + Case { id: "bettertls::nameconstraints::tc7237", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22648, 22649], leaf: 22647 }, + Case { id: "bettertls::nameconstraints::tc7238", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22651, 22652], leaf: 22650 }, + Case { id: "bettertls::nameconstraints::tc7239", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22654, 22655], leaf: 22653 }, + Case { id: "bettertls::nameconstraints::tc7240", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22657, 22658], leaf: 22656 }, + Case { id: "bettertls::nameconstraints::tc7241", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22660, 22661], leaf: 22659 }, + Case { id: "bettertls::nameconstraints::tc7242", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22663, 22664], leaf: 22662 }, + Case { id: "bettertls::nameconstraints::tc7243", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22666, 22667], leaf: 22665 }, + Case { id: "bettertls::nameconstraints::tc7244", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22669, 22670], leaf: 22668 }, + Case { id: "bettertls::nameconstraints::tc7245", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22672, 22673], leaf: 22671 }, + Case { id: "bettertls::nameconstraints::tc7246", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22675, 22676], leaf: 22674 }, + Case { id: "bettertls::nameconstraints::tc7247", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22678, 22679], leaf: 22677 }, + Case { id: "bettertls::nameconstraints::tc7248", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22681, 22682], leaf: 22680 }, + Case { id: "bettertls::nameconstraints::tc7249", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22684, 22685], leaf: 22683 }, + Case { id: "bettertls::nameconstraints::tc7250", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22687, 22688], leaf: 22686 }, + Case { id: "bettertls::nameconstraints::tc7251", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22690, 22691], leaf: 22689 }, + Case { id: "bettertls::nameconstraints::tc7252", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22693, 22694], leaf: 22692 }, + Case { id: "bettertls::nameconstraints::tc7253", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22696, 22697], leaf: 22695 }, + Case { id: "bettertls::nameconstraints::tc7254", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22699, 22700], leaf: 22698 }, + Case { id: "bettertls::nameconstraints::tc7255", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22702, 22703], leaf: 22701 }, + Case { id: "bettertls::nameconstraints::tc7256", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22705, 22706], leaf: 22704 }, + Case { id: "bettertls::nameconstraints::tc7257", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22708, 22709], leaf: 22707 }, + Case { id: "bettertls::nameconstraints::tc7258", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22711, 22712], leaf: 22710 }, + Case { id: "bettertls::nameconstraints::tc7259", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22714, 22715], leaf: 22713 }, + Case { id: "bettertls::nameconstraints::tc7260", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22717, 22718], leaf: 22716 }, + Case { id: "bettertls::nameconstraints::tc7261", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22720, 22721], leaf: 22719 }, + Case { id: "bettertls::nameconstraints::tc7262", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22723, 22724], leaf: 22722 }, + Case { id: "bettertls::nameconstraints::tc7263", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22726, 22727], leaf: 22725 }, + Case { id: "bettertls::nameconstraints::tc7264", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22729, 22730], leaf: 22728 }, + Case { id: "bettertls::nameconstraints::tc7265", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22732, 22733], leaf: 22731 }, + Case { id: "bettertls::nameconstraints::tc7266", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22735, 22736], leaf: 22734 }, + Case { id: "bettertls::nameconstraints::tc7267", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22738, 22739], leaf: 22737 }, + Case { id: "bettertls::nameconstraints::tc7268", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22741, 22742], leaf: 22740 }, + Case { id: "bettertls::nameconstraints::tc7269", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22744, 22745], leaf: 22743 }, + Case { id: "bettertls::nameconstraints::tc7270", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22747, 22748], leaf: 22746 }, + Case { id: "bettertls::nameconstraints::tc7271", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22750, 22751], leaf: 22749 }, + Case { id: "bettertls::nameconstraints::tc7272", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22753, 22754], leaf: 22752 }, + Case { id: "bettertls::nameconstraints::tc7273", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22756, 22757], leaf: 22755 }, + Case { id: "bettertls::nameconstraints::tc7274", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22759, 22760], leaf: 22758 }, + Case { id: "bettertls::nameconstraints::tc7275", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22762, 22763], leaf: 22761 }, + Case { id: "bettertls::nameconstraints::tc7276", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22765, 22766], leaf: 22764 }, + Case { id: "bettertls::nameconstraints::tc7277", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22768, 22769], leaf: 22767 }, + Case { id: "bettertls::nameconstraints::tc7278", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22771, 22772], leaf: 22770 }, + Case { id: "bettertls::nameconstraints::tc7279", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22774, 22775], leaf: 22773 }, + Case { id: "bettertls::nameconstraints::tc7280", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22777, 22778], leaf: 22776 }, + Case { id: "bettertls::nameconstraints::tc7281", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22780, 22781], leaf: 22779 }, + Case { id: "bettertls::nameconstraints::tc7282", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22783, 22784], leaf: 22782 }, + Case { id: "bettertls::nameconstraints::tc7283", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22786, 22787], leaf: 22785 }, + Case { id: "bettertls::nameconstraints::tc7284", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22789, 22790], leaf: 22788 }, + Case { id: "bettertls::nameconstraints::tc7285", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22792, 22793], leaf: 22791 }, + Case { id: "bettertls::nameconstraints::tc7286", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22795, 22796], leaf: 22794 }, + Case { id: "bettertls::nameconstraints::tc7287", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22798, 22799], leaf: 22797 }, + Case { id: "bettertls::nameconstraints::tc7288", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22801, 22802], leaf: 22800 }, + Case { id: "bettertls::nameconstraints::tc7289", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22804, 22805], leaf: 22803 }, + Case { id: "bettertls::nameconstraints::tc7290", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22807, 22808], leaf: 22806 }, + Case { id: "bettertls::nameconstraints::tc7291", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22810, 22811], leaf: 22809 }, + Case { id: "bettertls::nameconstraints::tc7292", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22813, 22814], leaf: 22812 }, + Case { id: "bettertls::nameconstraints::tc7293", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22816, 22817], leaf: 22815 }, + Case { id: "bettertls::nameconstraints::tc7294", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22819, 22820], leaf: 22818 }, + Case { id: "bettertls::nameconstraints::tc7295", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22822, 22823], leaf: 22821 }, + Case { id: "bettertls::nameconstraints::tc7296", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22825, 22826], leaf: 22824 }, + Case { id: "bettertls::nameconstraints::tc7297", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22828, 22829], leaf: 22827 }, + Case { id: "bettertls::nameconstraints::tc7298", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22831, 22832], leaf: 22830 }, + Case { id: "bettertls::nameconstraints::tc7299", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22834, 22835], leaf: 22833 }, + Case { id: "bettertls::nameconstraints::tc7300", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22837, 22838], leaf: 22836 }, + Case { id: "bettertls::nameconstraints::tc7301", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22840, 22841], leaf: 22839 }, + Case { id: "bettertls::nameconstraints::tc7302", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22843, 22844], leaf: 22842 }, + Case { id: "bettertls::nameconstraints::tc7303", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22846, 22847], leaf: 22845 }, + Case { id: "bettertls::nameconstraints::tc7304", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22849, 22850], leaf: 22848 }, + Case { id: "bettertls::nameconstraints::tc7305", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22852, 22853], leaf: 22851 }, + Case { id: "bettertls::nameconstraints::tc7306", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22855, 22856], leaf: 22854 }, + Case { id: "bettertls::nameconstraints::tc7307", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22858, 22859], leaf: 22857 }, + Case { id: "bettertls::nameconstraints::tc7308", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22861, 22862], leaf: 22860 }, + Case { id: "bettertls::nameconstraints::tc7309", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22864, 22865], leaf: 22863 }, + Case { id: "bettertls::nameconstraints::tc7310", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22867, 22868], leaf: 22866 }, + Case { id: "bettertls::nameconstraints::tc7311", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22870, 22871], leaf: 22869 }, + Case { id: "bettertls::nameconstraints::tc7312", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22873, 22874], leaf: 22872 }, + Case { id: "bettertls::nameconstraints::tc7313", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22876, 22877], leaf: 22875 }, + Case { id: "bettertls::nameconstraints::tc7314", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22879, 22880], leaf: 22878 }, + Case { id: "bettertls::nameconstraints::tc7315", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22882, 22883], leaf: 22881 }, + Case { id: "bettertls::nameconstraints::tc7316", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22885, 22886], leaf: 22884 }, + Case { id: "bettertls::nameconstraints::tc7317", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22888, 22889], leaf: 22887 }, + Case { id: "bettertls::nameconstraints::tc7318", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22891, 22892], leaf: 22890 }, + Case { id: "bettertls::nameconstraints::tc7319", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22894, 22895], leaf: 22893 }, + Case { id: "bettertls::nameconstraints::tc7320", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22897, 22898], leaf: 22896 }, + Case { id: "bettertls::nameconstraints::tc7321", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22900, 22901], leaf: 22899 }, + Case { id: "bettertls::nameconstraints::tc7322", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22903, 22904], leaf: 22902 }, + Case { id: "bettertls::nameconstraints::tc7323", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22906, 22907], leaf: 22905 }, + Case { id: "bettertls::nameconstraints::tc7324", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22909, 22910], leaf: 22908 }, + Case { id: "bettertls::nameconstraints::tc7325", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22912, 22913], leaf: 22911 }, + Case { id: "bettertls::nameconstraints::tc7326", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22915, 22916], leaf: 22914 }, + Case { id: "bettertls::nameconstraints::tc7327", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22918, 22919], leaf: 22917 }, + Case { id: "bettertls::nameconstraints::tc7328", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22921, 22922], leaf: 22920 }, + Case { id: "bettertls::nameconstraints::tc7329", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22924, 22925], leaf: 22923 }, + Case { id: "bettertls::nameconstraints::tc7330", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22927, 22928], leaf: 22926 }, + Case { id: "bettertls::nameconstraints::tc7331", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22930, 22931], leaf: 22929 }, + Case { id: "bettertls::nameconstraints::tc7332", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22933, 22934], leaf: 22932 }, + Case { id: "bettertls::nameconstraints::tc7333", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22936, 22937], leaf: 22935 }, + Case { id: "bettertls::nameconstraints::tc7334", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22939, 22940], leaf: 22938 }, + Case { id: "bettertls::nameconstraints::tc7335", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22942, 22943], leaf: 22941 }, + Case { id: "bettertls::nameconstraints::tc7336", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22945, 22946], leaf: 22944 }, + Case { id: "bettertls::nameconstraints::tc7337", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22948, 22949], leaf: 22947 }, + Case { id: "bettertls::nameconstraints::tc7338", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22951, 22952], leaf: 22950 }, + Case { id: "bettertls::nameconstraints::tc7339", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22954, 22955], leaf: 22953 }, + Case { id: "bettertls::nameconstraints::tc7340", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22957, 22958], leaf: 22956 }, + Case { id: "bettertls::nameconstraints::tc7341", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22960, 22961], leaf: 22959 }, + Case { id: "bettertls::nameconstraints::tc7342", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22963, 22964], leaf: 22962 }, + Case { id: "bettertls::nameconstraints::tc7343", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22966, 22967], leaf: 22965 }, + Case { id: "bettertls::nameconstraints::tc7344", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22969, 22970], leaf: 22968 }, + Case { id: "bettertls::nameconstraints::tc7345", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22972, 22973], leaf: 22971 }, + Case { id: "bettertls::nameconstraints::tc7346", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22975, 22976], leaf: 22974 }, + Case { id: "bettertls::nameconstraints::tc7347", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22978, 22979], leaf: 22977 }, + Case { id: "bettertls::nameconstraints::tc7348", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22981, 22982], leaf: 22980 }, + Case { id: "bettertls::nameconstraints::tc7349", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22984, 22985], leaf: 22983 }, + Case { id: "bettertls::nameconstraints::tc7350", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22987, 22988], leaf: 22986 }, + Case { id: "bettertls::nameconstraints::tc7351", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22990, 22991], leaf: 22989 }, + Case { id: "bettertls::nameconstraints::tc7352", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22993, 22994], leaf: 22992 }, + Case { id: "bettertls::nameconstraints::tc7353", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22996, 22997], leaf: 22995 }, + Case { id: "bettertls::nameconstraints::tc7354", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[22999, 23000], leaf: 22998 }, + Case { id: "bettertls::nameconstraints::tc7355", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23002, 23003], leaf: 23001 }, + Case { id: "bettertls::nameconstraints::tc7356", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23005, 23006], leaf: 23004 }, + Case { id: "bettertls::nameconstraints::tc7357", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23008, 23009], leaf: 23007 }, + Case { id: "bettertls::nameconstraints::tc7358", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23011, 23012], leaf: 23010 }, + Case { id: "bettertls::nameconstraints::tc7359", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23014, 23015], leaf: 23013 }, + Case { id: "bettertls::nameconstraints::tc7360", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23017, 23018], leaf: 23016 }, + Case { id: "bettertls::nameconstraints::tc7361", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23020, 23021], leaf: 23019 }, + Case { id: "bettertls::nameconstraints::tc7362", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23023, 23024], leaf: 23022 }, + Case { id: "bettertls::nameconstraints::tc7363", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23026, 23027], leaf: 23025 }, + Case { id: "bettertls::nameconstraints::tc7364", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23029, 23030], leaf: 23028 }, + Case { id: "bettertls::nameconstraints::tc7365", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23032, 23033], leaf: 23031 }, + Case { id: "bettertls::nameconstraints::tc7366", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23035, 23036], leaf: 23034 }, + Case { id: "bettertls::nameconstraints::tc7367", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23038, 23039], leaf: 23037 }, + Case { id: "bettertls::nameconstraints::tc7368", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23041, 23042], leaf: 23040 }, + Case { id: "bettertls::nameconstraints::tc7369", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23044, 23045], leaf: 23043 }, + Case { id: "bettertls::nameconstraints::tc7370", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23047, 23048], leaf: 23046 }, + Case { id: "bettertls::nameconstraints::tc7371", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23050, 23051], leaf: 23049 }, + Case { id: "bettertls::nameconstraints::tc7372", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23053, 23054], leaf: 23052 }, + Case { id: "bettertls::nameconstraints::tc7373", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23056, 23057], leaf: 23055 }, + Case { id: "bettertls::nameconstraints::tc7374", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23059, 23060], leaf: 23058 }, + Case { id: "bettertls::nameconstraints::tc7375", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23062, 23063], leaf: 23061 }, + Case { id: "bettertls::nameconstraints::tc7376", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23065, 23066], leaf: 23064 }, + Case { id: "bettertls::nameconstraints::tc7377", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23068, 23069], leaf: 23067 }, + Case { id: "bettertls::nameconstraints::tc7378", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23071, 23072], leaf: 23070 }, + Case { id: "bettertls::nameconstraints::tc7379", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23074, 23075], leaf: 23073 }, + Case { id: "bettertls::nameconstraints::tc7380", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23077, 23078], leaf: 23076 }, + Case { id: "bettertls::nameconstraints::tc7381", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23080, 23081], leaf: 23079 }, + Case { id: "bettertls::nameconstraints::tc7382", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23083, 23084], leaf: 23082 }, + Case { id: "bettertls::nameconstraints::tc7383", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23086, 23087], leaf: 23085 }, + Case { id: "bettertls::nameconstraints::tc7384", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23089, 23090], leaf: 23088 }, + Case { id: "bettertls::nameconstraints::tc7385", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23092, 23093], leaf: 23091 }, + Case { id: "bettertls::nameconstraints::tc7386", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23095, 23096], leaf: 23094 }, + Case { id: "bettertls::nameconstraints::tc7387", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23098, 23099], leaf: 23097 }, + Case { id: "bettertls::nameconstraints::tc7388", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23101, 23102], leaf: 23100 }, + Case { id: "bettertls::nameconstraints::tc7389", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23104, 23105], leaf: 23103 }, + Case { id: "bettertls::nameconstraints::tc7390", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23107, 23108], leaf: 23106 }, + Case { id: "bettertls::nameconstraints::tc7391", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23110, 23111], leaf: 23109 }, + Case { id: "bettertls::nameconstraints::tc7392", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23113, 23114], leaf: 23112 }, + Case { id: "bettertls::nameconstraints::tc7393", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23116, 23117], leaf: 23115 }, + Case { id: "bettertls::nameconstraints::tc7394", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23119, 23120], leaf: 23118 }, + Case { id: "bettertls::nameconstraints::tc7395", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23122, 23123], leaf: 23121 }, + Case { id: "bettertls::nameconstraints::tc7396", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23125, 23126], leaf: 23124 }, + Case { id: "bettertls::nameconstraints::tc7397", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23128, 23129], leaf: 23127 }, + Case { id: "bettertls::nameconstraints::tc7398", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23131, 23132], leaf: 23130 }, + Case { id: "bettertls::nameconstraints::tc7399", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23134, 23135], leaf: 23133 }, + Case { id: "bettertls::nameconstraints::tc7400", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23137, 23138], leaf: 23136 }, + Case { id: "bettertls::nameconstraints::tc7401", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23140, 23141], leaf: 23139 }, + Case { id: "bettertls::nameconstraints::tc7402", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23143, 23144], leaf: 23142 }, + Case { id: "bettertls::nameconstraints::tc7403", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23146, 23147], leaf: 23145 }, + Case { id: "bettertls::nameconstraints::tc7404", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23149, 23150], leaf: 23148 }, + Case { id: "bettertls::nameconstraints::tc7405", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23152, 23153], leaf: 23151 }, + Case { id: "bettertls::nameconstraints::tc7406", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23155, 23156], leaf: 23154 }, + Case { id: "bettertls::nameconstraints::tc7407", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23158, 23159], leaf: 23157 }, + Case { id: "bettertls::nameconstraints::tc7408", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23161, 23162], leaf: 23160 }, + Case { id: "bettertls::nameconstraints::tc7409", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23164, 23165], leaf: 23163 }, + Case { id: "bettertls::nameconstraints::tc7410", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23167, 23168], leaf: 23166 }, + Case { id: "bettertls::nameconstraints::tc7411", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23170, 23171], leaf: 23169 }, + Case { id: "bettertls::nameconstraints::tc7412", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23173, 23174], leaf: 23172 }, + Case { id: "bettertls::nameconstraints::tc7413", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23176, 23177], leaf: 23175 }, + Case { id: "bettertls::nameconstraints::tc7414", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23179, 23180], leaf: 23178 }, + Case { id: "bettertls::nameconstraints::tc7415", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23182, 23183], leaf: 23181 }, + Case { id: "bettertls::nameconstraints::tc7416", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23185, 23186], leaf: 23184 }, + Case { id: "bettertls::nameconstraints::tc7417", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23188, 23189], leaf: 23187 }, + Case { id: "bettertls::nameconstraints::tc7418", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23191, 23192], leaf: 23190 }, + Case { id: "bettertls::nameconstraints::tc7419", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23194, 23195], leaf: 23193 }, + Case { id: "bettertls::nameconstraints::tc7420", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23197, 23198], leaf: 23196 }, + Case { id: "bettertls::nameconstraints::tc7421", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23200, 23201], leaf: 23199 }, + Case { id: "bettertls::nameconstraints::tc7422", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23203, 23204], leaf: 23202 }, + Case { id: "bettertls::nameconstraints::tc7423", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23206, 23207], leaf: 23205 }, + Case { id: "bettertls::nameconstraints::tc7424", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23209, 23210], leaf: 23208 }, + Case { id: "bettertls::nameconstraints::tc7425", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23212, 23213], leaf: 23211 }, + Case { id: "bettertls::nameconstraints::tc7426", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23215, 23216], leaf: 23214 }, + Case { id: "bettertls::nameconstraints::tc7427", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23218, 23219], leaf: 23217 }, + Case { id: "bettertls::nameconstraints::tc7428", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23221, 23222], leaf: 23220 }, + Case { id: "bettertls::nameconstraints::tc7429", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23224, 23225], leaf: 23223 }, + Case { id: "bettertls::nameconstraints::tc7430", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23227, 23228], leaf: 23226 }, + Case { id: "bettertls::nameconstraints::tc7431", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23230, 23231], leaf: 23229 }, + Case { id: "bettertls::nameconstraints::tc7432", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23233, 23234], leaf: 23232 }, + Case { id: "bettertls::nameconstraints::tc7433", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23236, 23237], leaf: 23235 }, + Case { id: "bettertls::nameconstraints::tc7434", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23239, 23240], leaf: 23238 }, + Case { id: "bettertls::nameconstraints::tc7435", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23242, 23243], leaf: 23241 }, + Case { id: "bettertls::nameconstraints::tc7436", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23245, 23246], leaf: 23244 }, + Case { id: "bettertls::nameconstraints::tc7437", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23248, 23249], leaf: 23247 }, + Case { id: "bettertls::nameconstraints::tc7438", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23251, 23252], leaf: 23250 }, + Case { id: "bettertls::nameconstraints::tc7439", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23254, 23255], leaf: 23253 }, + Case { id: "bettertls::nameconstraints::tc7440", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23257, 23258], leaf: 23256 }, + Case { id: "bettertls::nameconstraints::tc7441", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23260, 23261], leaf: 23259 }, + Case { id: "bettertls::nameconstraints::tc7442", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23263, 23264], leaf: 23262 }, + Case { id: "bettertls::nameconstraints::tc7443", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23266, 23267], leaf: 23265 }, + Case { id: "bettertls::nameconstraints::tc7444", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23269, 23270], leaf: 23268 }, + Case { id: "bettertls::nameconstraints::tc7445", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23272, 23273], leaf: 23271 }, + Case { id: "bettertls::nameconstraints::tc7446", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23275, 23276], leaf: 23274 }, + Case { id: "bettertls::nameconstraints::tc7447", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23278, 23279], leaf: 23277 }, + Case { id: "bettertls::nameconstraints::tc7448", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23281, 23282], leaf: 23280 }, + Case { id: "bettertls::nameconstraints::tc7449", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23284, 23285], leaf: 23283 }, + Case { id: "bettertls::nameconstraints::tc7450", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23287, 23288], leaf: 23286 }, + Case { id: "bettertls::nameconstraints::tc7451", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23290, 23291], leaf: 23289 }, + Case { id: "bettertls::nameconstraints::tc7452", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23293, 23294], leaf: 23292 }, + Case { id: "bettertls::nameconstraints::tc7453", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23296, 23297], leaf: 23295 }, + Case { id: "bettertls::nameconstraints::tc7454", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23299, 23300], leaf: 23298 }, + Case { id: "bettertls::nameconstraints::tc7455", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23302, 23303], leaf: 23301 }, + Case { id: "bettertls::nameconstraints::tc7456", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23305, 23306], leaf: 23304 }, + Case { id: "bettertls::nameconstraints::tc7457", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23308, 23309], leaf: 23307 }, + Case { id: "bettertls::nameconstraints::tc7458", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23311, 23312], leaf: 23310 }, + Case { id: "bettertls::nameconstraints::tc7459", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23314, 23315], leaf: 23313 }, + Case { id: "bettertls::nameconstraints::tc7460", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23317, 23318], leaf: 23316 }, + Case { id: "bettertls::nameconstraints::tc7461", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23320, 23321], leaf: 23319 }, + Case { id: "bettertls::nameconstraints::tc7462", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23323, 23324], leaf: 23322 }, + Case { id: "bettertls::nameconstraints::tc7463", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23326, 23327], leaf: 23325 }, + Case { id: "bettertls::nameconstraints::tc7464", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23329, 23330], leaf: 23328 }, + Case { id: "bettertls::nameconstraints::tc7465", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23332, 23333], leaf: 23331 }, + Case { id: "bettertls::nameconstraints::tc7466", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23335, 23336], leaf: 23334 }, + Case { id: "bettertls::nameconstraints::tc7467", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23338, 23339], leaf: 23337 }, + Case { id: "bettertls::nameconstraints::tc7468", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23341, 23342], leaf: 23340 }, + Case { id: "bettertls::nameconstraints::tc7469", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23344, 23345], leaf: 23343 }, + Case { id: "bettertls::nameconstraints::tc7470", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23347, 23348], leaf: 23346 }, + Case { id: "bettertls::nameconstraints::tc7471", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23350, 23351], leaf: 23349 }, + Case { id: "bettertls::nameconstraints::tc7472", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23353, 23354], leaf: 23352 }, + Case { id: "bettertls::nameconstraints::tc7473", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23356, 23357], leaf: 23355 }, + Case { id: "bettertls::nameconstraints::tc7474", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23359, 23360], leaf: 23358 }, + Case { id: "bettertls::nameconstraints::tc7475", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23362, 23363], leaf: 23361 }, + Case { id: "bettertls::nameconstraints::tc7476", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23365, 23366], leaf: 23364 }, + Case { id: "bettertls::nameconstraints::tc7477", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23368, 23369], leaf: 23367 }, + Case { id: "bettertls::nameconstraints::tc7478", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23371, 23372], leaf: 23370 }, + Case { id: "bettertls::nameconstraints::tc7479", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23374, 23375], leaf: 23373 }, + Case { id: "bettertls::nameconstraints::tc7480", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23377, 23378], leaf: 23376 }, + Case { id: "bettertls::nameconstraints::tc7481", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23380, 23381], leaf: 23379 }, + Case { id: "bettertls::nameconstraints::tc7482", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23383, 23384], leaf: 23382 }, + Case { id: "bettertls::nameconstraints::tc7483", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23386, 23387], leaf: 23385 }, + Case { id: "bettertls::nameconstraints::tc7484", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23389, 23390], leaf: 23388 }, + Case { id: "bettertls::nameconstraints::tc7485", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23392, 23393], leaf: 23391 }, + Case { id: "bettertls::nameconstraints::tc7486", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23395, 23396], leaf: 23394 }, + Case { id: "bettertls::nameconstraints::tc7487", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23398, 23399], leaf: 23397 }, + Case { id: "bettertls::nameconstraints::tc7488", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23401, 23402], leaf: 23400 }, + Case { id: "bettertls::nameconstraints::tc7489", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23404, 23405], leaf: 23403 }, + Case { id: "bettertls::nameconstraints::tc7490", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23407, 23408], leaf: 23406 }, + Case { id: "bettertls::nameconstraints::tc7491", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23410, 23411], leaf: 23409 }, + Case { id: "bettertls::nameconstraints::tc7492", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23413, 23414], leaf: 23412 }, + Case { id: "bettertls::nameconstraints::tc7493", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23416, 23417], leaf: 23415 }, + Case { id: "bettertls::nameconstraints::tc7494", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23419, 23420], leaf: 23418 }, + Case { id: "bettertls::nameconstraints::tc7495", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23422, 23423], leaf: 23421 }, + Case { id: "bettertls::nameconstraints::tc7496", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23425, 23426], leaf: 23424 }, + Case { id: "bettertls::nameconstraints::tc7497", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23428, 23429], leaf: 23427 }, + Case { id: "bettertls::nameconstraints::tc7498", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23431, 23432], leaf: 23430 }, + Case { id: "bettertls::nameconstraints::tc7499", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23434, 23435], leaf: 23433 }, + Case { id: "bettertls::nameconstraints::tc7500", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23437, 23438], leaf: 23436 }, + Case { id: "bettertls::nameconstraints::tc7501", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23440, 23441], leaf: 23439 }, + Case { id: "bettertls::nameconstraints::tc7502", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23443, 23444], leaf: 23442 }, + Case { id: "bettertls::nameconstraints::tc7503", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23446, 23447], leaf: 23445 }, + Case { id: "bettertls::nameconstraints::tc7504", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23449, 23450], leaf: 23448 }, + Case { id: "bettertls::nameconstraints::tc7505", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23452, 23453], leaf: 23451 }, + Case { id: "bettertls::nameconstraints::tc7506", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23455, 23456], leaf: 23454 }, + Case { id: "bettertls::nameconstraints::tc7507", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23458, 23459], leaf: 23457 }, + Case { id: "bettertls::nameconstraints::tc7508", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23461, 23462], leaf: 23460 }, + Case { id: "bettertls::nameconstraints::tc7509", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23464, 23465], leaf: 23463 }, + Case { id: "bettertls::nameconstraints::tc7510", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23467, 23468], leaf: 23466 }, + Case { id: "bettertls::nameconstraints::tc7511", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23470, 23471], leaf: 23469 }, + Case { id: "bettertls::nameconstraints::tc7512", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23473, 23474], leaf: 23472 }, + Case { id: "bettertls::nameconstraints::tc7513", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23476, 23477], leaf: 23475 }, + Case { id: "bettertls::nameconstraints::tc7514", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23479, 23480], leaf: 23478 }, + Case { id: "bettertls::nameconstraints::tc7515", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23482, 23483], leaf: 23481 }, + Case { id: "bettertls::nameconstraints::tc7516", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23485, 23486], leaf: 23484 }, + Case { id: "bettertls::nameconstraints::tc7517", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23488, 23489], leaf: 23487 }, + Case { id: "bettertls::nameconstraints::tc7518", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23491, 23492], leaf: 23490 }, + Case { id: "bettertls::nameconstraints::tc7519", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23494, 23495], leaf: 23493 }, + Case { id: "bettertls::nameconstraints::tc7520", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23497, 23498], leaf: 23496 }, + Case { id: "bettertls::nameconstraints::tc7521", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23500, 23501], leaf: 23499 }, + Case { id: "bettertls::nameconstraints::tc7522", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23503, 23504], leaf: 23502 }, + Case { id: "bettertls::nameconstraints::tc7523", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23506, 23507], leaf: 23505 }, + Case { id: "bettertls::nameconstraints::tc7524", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23509, 23510], leaf: 23508 }, + Case { id: "bettertls::nameconstraints::tc7525", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23512, 23513], leaf: 23511 }, + Case { id: "bettertls::nameconstraints::tc7526", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23515, 23516], leaf: 23514 }, + Case { id: "bettertls::nameconstraints::tc7527", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23518, 23519], leaf: 23517 }, + Case { id: "bettertls::nameconstraints::tc7528", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23521, 23522], leaf: 23520 }, + Case { id: "bettertls::nameconstraints::tc7529", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23524, 23525], leaf: 23523 }, + Case { id: "bettertls::nameconstraints::tc7530", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23527, 23528], leaf: 23526 }, + Case { id: "bettertls::nameconstraints::tc7531", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23530, 23531], leaf: 23529 }, + Case { id: "bettertls::nameconstraints::tc7532", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23533, 23534], leaf: 23532 }, + Case { id: "bettertls::nameconstraints::tc7533", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23536, 23537], leaf: 23535 }, + Case { id: "bettertls::nameconstraints::tc7534", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23539, 23540], leaf: 23538 }, + Case { id: "bettertls::nameconstraints::tc7535", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23542, 23543], leaf: 23541 }, + Case { id: "bettertls::nameconstraints::tc7536", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23545, 23546], leaf: 23544 }, + Case { id: "bettertls::nameconstraints::tc7537", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23548, 23549], leaf: 23547 }, + Case { id: "bettertls::nameconstraints::tc7538", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23551, 23552], leaf: 23550 }, + Case { id: "bettertls::nameconstraints::tc7539", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23554, 23555], leaf: 23553 }, + Case { id: "bettertls::nameconstraints::tc7540", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23557, 23558], leaf: 23556 }, + Case { id: "bettertls::nameconstraints::tc7541", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23560, 23561], leaf: 23559 }, + Case { id: "bettertls::nameconstraints::tc7542", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23563, 23564], leaf: 23562 }, + Case { id: "bettertls::nameconstraints::tc7543", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23566, 23567], leaf: 23565 }, + Case { id: "bettertls::nameconstraints::tc7544", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23569, 23570], leaf: 23568 }, + Case { id: "bettertls::nameconstraints::tc7545", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23572, 23573], leaf: 23571 }, + Case { id: "bettertls::nameconstraints::tc7546", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23575, 23576], leaf: 23574 }, + Case { id: "bettertls::nameconstraints::tc7547", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23578, 23579], leaf: 23577 }, + Case { id: "bettertls::nameconstraints::tc7548", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23581, 23582], leaf: 23580 }, + Case { id: "bettertls::nameconstraints::tc7549", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23584, 23585], leaf: 23583 }, + Case { id: "bettertls::nameconstraints::tc7550", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23587, 23588], leaf: 23586 }, + Case { id: "bettertls::nameconstraints::tc7551", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23590, 23591], leaf: 23589 }, + Case { id: "bettertls::nameconstraints::tc7552", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23593, 23594], leaf: 23592 }, + Case { id: "bettertls::nameconstraints::tc7553", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23596, 23597], leaf: 23595 }, + Case { id: "bettertls::nameconstraints::tc7554", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23599, 23600], leaf: 23598 }, + Case { id: "bettertls::nameconstraints::tc7555", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23602, 23603], leaf: 23601 }, + Case { id: "bettertls::nameconstraints::tc7556", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23605, 23606], leaf: 23604 }, + Case { id: "bettertls::nameconstraints::tc7557", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23608, 23609], leaf: 23607 }, + Case { id: "bettertls::nameconstraints::tc7558", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23611, 23612], leaf: 23610 }, + Case { id: "bettertls::nameconstraints::tc7559", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23614, 23615], leaf: 23613 }, + Case { id: "bettertls::nameconstraints::tc7560", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23617, 23618], leaf: 23616 }, + Case { id: "bettertls::nameconstraints::tc7561", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23620, 23621], leaf: 23619 }, + Case { id: "bettertls::nameconstraints::tc7562", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23623, 23624], leaf: 23622 }, + Case { id: "bettertls::nameconstraints::tc7563", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23626, 23627], leaf: 23625 }, + Case { id: "bettertls::nameconstraints::tc7564", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23629, 23630], leaf: 23628 }, + Case { id: "bettertls::nameconstraints::tc7565", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23632, 23633], leaf: 23631 }, + Case { id: "bettertls::nameconstraints::tc7566", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23635, 23636], leaf: 23634 }, + Case { id: "bettertls::nameconstraints::tc7567", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23638, 23639], leaf: 23637 }, + Case { id: "bettertls::nameconstraints::tc7568", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23641, 23642], leaf: 23640 }, + Case { id: "bettertls::nameconstraints::tc7569", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23644, 23645], leaf: 23643 }, + Case { id: "bettertls::nameconstraints::tc7570", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23647, 23648], leaf: 23646 }, + Case { id: "bettertls::nameconstraints::tc7571", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23650, 23651], leaf: 23649 }, + Case { id: "bettertls::nameconstraints::tc7572", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23653, 23654], leaf: 23652 }, + Case { id: "bettertls::nameconstraints::tc7573", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23656, 23657], leaf: 23655 }, + Case { id: "bettertls::nameconstraints::tc7574", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23659, 23660], leaf: 23658 }, + Case { id: "bettertls::nameconstraints::tc7575", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23662, 23663], leaf: 23661 }, + Case { id: "bettertls::nameconstraints::tc7576", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23665, 23666], leaf: 23664 }, + Case { id: "bettertls::nameconstraints::tc7577", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23668, 23669], leaf: 23667 }, + Case { id: "bettertls::nameconstraints::tc7578", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23671, 23672], leaf: 23670 }, + Case { id: "bettertls::nameconstraints::tc7579", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23674, 23675], leaf: 23673 }, + Case { id: "bettertls::nameconstraints::tc7580", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23677, 23678], leaf: 23676 }, + Case { id: "bettertls::nameconstraints::tc7581", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23680, 23681], leaf: 23679 }, + Case { id: "bettertls::nameconstraints::tc7582", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23683, 23684], leaf: 23682 }, + Case { id: "bettertls::nameconstraints::tc7583", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23686, 23687], leaf: 23685 }, + Case { id: "bettertls::nameconstraints::tc7584", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23689, 23690], leaf: 23688 }, + Case { id: "bettertls::nameconstraints::tc7585", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23692, 23693], leaf: 23691 }, + Case { id: "bettertls::nameconstraints::tc7586", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23695, 23696], leaf: 23694 }, + Case { id: "bettertls::nameconstraints::tc7587", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23698, 23699], leaf: 23697 }, + Case { id: "bettertls::nameconstraints::tc7588", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23701, 23702], leaf: 23700 }, + Case { id: "bettertls::nameconstraints::tc7589", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23704, 23705], leaf: 23703 }, + Case { id: "bettertls::nameconstraints::tc7590", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23707, 23708], leaf: 23706 }, + Case { id: "bettertls::nameconstraints::tc7591", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23710, 23711], leaf: 23709 }, + Case { id: "bettertls::nameconstraints::tc7592", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23713, 23714], leaf: 23712 }, + Case { id: "bettertls::nameconstraints::tc7593", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23716, 23717], leaf: 23715 }, + Case { id: "bettertls::nameconstraints::tc7594", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23719, 23720], leaf: 23718 }, + Case { id: "bettertls::nameconstraints::tc7595", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23722, 23723], leaf: 23721 }, + Case { id: "bettertls::nameconstraints::tc7596", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23725, 23726], leaf: 23724 }, + Case { id: "bettertls::nameconstraints::tc7597", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23728, 23729], leaf: 23727 }, + Case { id: "bettertls::nameconstraints::tc7598", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23731, 23732], leaf: 23730 }, + Case { id: "bettertls::nameconstraints::tc7599", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23734, 23735], leaf: 23733 }, + Case { id: "bettertls::nameconstraints::tc7600", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23737, 23738], leaf: 23736 }, + Case { id: "bettertls::nameconstraints::tc7601", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23740, 23741], leaf: 23739 }, + Case { id: "bettertls::nameconstraints::tc7602", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23743, 23744], leaf: 23742 }, + Case { id: "bettertls::nameconstraints::tc7603", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23746, 23747], leaf: 23745 }, + Case { id: "bettertls::nameconstraints::tc7604", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23749, 23750], leaf: 23748 }, + Case { id: "bettertls::nameconstraints::tc7605", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23752, 23753], leaf: 23751 }, + Case { id: "bettertls::nameconstraints::tc7606", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23755, 23756], leaf: 23754 }, + Case { id: "bettertls::nameconstraints::tc7607", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23758, 23759], leaf: 23757 }, + Case { id: "bettertls::nameconstraints::tc7608", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23761, 23762], leaf: 23760 }, + Case { id: "bettertls::nameconstraints::tc7609", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23764, 23765], leaf: 23763 }, + Case { id: "bettertls::nameconstraints::tc7610", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23767, 23768], leaf: 23766 }, + Case { id: "bettertls::nameconstraints::tc7611", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23770, 23771], leaf: 23769 }, + Case { id: "bettertls::nameconstraints::tc7612", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23773, 23774], leaf: 23772 }, + Case { id: "bettertls::nameconstraints::tc7613", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23776, 23777], leaf: 23775 }, + Case { id: "bettertls::nameconstraints::tc7614", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23779, 23780], leaf: 23778 }, + Case { id: "bettertls::nameconstraints::tc7615", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23782, 23783], leaf: 23781 }, + Case { id: "bettertls::nameconstraints::tc7616", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23785, 23786], leaf: 23784 }, + Case { id: "bettertls::nameconstraints::tc7617", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23788, 23789], leaf: 23787 }, + Case { id: "bettertls::nameconstraints::tc7618", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23791, 23792], leaf: 23790 }, + Case { id: "bettertls::nameconstraints::tc7619", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23794, 23795], leaf: 23793 }, + Case { id: "bettertls::nameconstraints::tc7620", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23797, 23798], leaf: 23796 }, + Case { id: "bettertls::nameconstraints::tc7621", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23800, 23801], leaf: 23799 }, + Case { id: "bettertls::nameconstraints::tc7622", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23803, 23804], leaf: 23802 }, + Case { id: "bettertls::nameconstraints::tc7623", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23806, 23807], leaf: 23805 }, + Case { id: "bettertls::nameconstraints::tc7624", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23809, 23810], leaf: 23808 }, + Case { id: "bettertls::nameconstraints::tc7625", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23812, 23813], leaf: 23811 }, + Case { id: "bettertls::nameconstraints::tc7626", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23815, 23816], leaf: 23814 }, + Case { id: "bettertls::nameconstraints::tc7627", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23818, 23819], leaf: 23817 }, + Case { id: "bettertls::nameconstraints::tc7628", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23821, 23822], leaf: 23820 }, + Case { id: "bettertls::nameconstraints::tc7629", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23824, 23825], leaf: 23823 }, + Case { id: "bettertls::nameconstraints::tc7630", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23827, 23828], leaf: 23826 }, + Case { id: "bettertls::nameconstraints::tc7631", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23830, 23831], leaf: 23829 }, + Case { id: "bettertls::nameconstraints::tc7632", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23833, 23834], leaf: 23832 }, + Case { id: "bettertls::nameconstraints::tc7633", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23836, 23837], leaf: 23835 }, + Case { id: "bettertls::nameconstraints::tc7634", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23839, 23840], leaf: 23838 }, + Case { id: "bettertls::nameconstraints::tc7635", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23842, 23843], leaf: 23841 }, + Case { id: "bettertls::nameconstraints::tc7636", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23845, 23846], leaf: 23844 }, + Case { id: "bettertls::nameconstraints::tc7637", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23848, 23849], leaf: 23847 }, + Case { id: "bettertls::nameconstraints::tc7638", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23851, 23852], leaf: 23850 }, + Case { id: "bettertls::nameconstraints::tc7639", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23854, 23855], leaf: 23853 }, + Case { id: "bettertls::nameconstraints::tc7640", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23857, 23858], leaf: 23856 }, + Case { id: "bettertls::nameconstraints::tc7641", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23860, 23861], leaf: 23859 }, + Case { id: "bettertls::nameconstraints::tc7642", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23863, 23864], leaf: 23862 }, + Case { id: "bettertls::nameconstraints::tc7643", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23866, 23867], leaf: 23865 }, + Case { id: "bettertls::nameconstraints::tc7644", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23869, 23870], leaf: 23868 }, + Case { id: "bettertls::nameconstraints::tc7645", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23872, 23873], leaf: 23871 }, + Case { id: "bettertls::nameconstraints::tc7646", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23875, 23876], leaf: 23874 }, + Case { id: "bettertls::nameconstraints::tc7647", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23878, 23879], leaf: 23877 }, + Case { id: "bettertls::nameconstraints::tc7648", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23881, 23882], leaf: 23880 }, + Case { id: "bettertls::nameconstraints::tc7649", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23884, 23885], leaf: 23883 }, + Case { id: "bettertls::nameconstraints::tc7650", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23887, 23888], leaf: 23886 }, + Case { id: "bettertls::nameconstraints::tc7651", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23890, 23891], leaf: 23889 }, + Case { id: "bettertls::nameconstraints::tc7652", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23893, 23894], leaf: 23892 }, + Case { id: "bettertls::nameconstraints::tc7653", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23896, 23897], leaf: 23895 }, + Case { id: "bettertls::nameconstraints::tc7654", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23899, 23900], leaf: 23898 }, + Case { id: "bettertls::nameconstraints::tc7655", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23902, 23903], leaf: 23901 }, + Case { id: "bettertls::nameconstraints::tc7656", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23905, 23906], leaf: 23904 }, + Case { id: "bettertls::nameconstraints::tc7657", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23908, 23909], leaf: 23907 }, + Case { id: "bettertls::nameconstraints::tc7658", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23911, 23912], leaf: 23910 }, + Case { id: "bettertls::nameconstraints::tc7659", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23914, 23915], leaf: 23913 }, + Case { id: "bettertls::nameconstraints::tc7660", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23917, 23918], leaf: 23916 }, + Case { id: "bettertls::nameconstraints::tc7661", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23920, 23921], leaf: 23919 }, + Case { id: "bettertls::nameconstraints::tc7662", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23923, 23924], leaf: 23922 }, + Case { id: "bettertls::nameconstraints::tc7663", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23926, 23927], leaf: 23925 }, + Case { id: "bettertls::nameconstraints::tc7664", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23929, 23930], leaf: 23928 }, + Case { id: "bettertls::nameconstraints::tc7665", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23932, 23933], leaf: 23931 }, + Case { id: "bettertls::nameconstraints::tc7666", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23935, 23936], leaf: 23934 }, + Case { id: "bettertls::nameconstraints::tc7667", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23938, 23939], leaf: 23937 }, + Case { id: "bettertls::nameconstraints::tc7668", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23941, 23942], leaf: 23940 }, + Case { id: "bettertls::nameconstraints::tc7669", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23944, 23945], leaf: 23943 }, + Case { id: "bettertls::nameconstraints::tc7670", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23947, 23948], leaf: 23946 }, + Case { id: "bettertls::nameconstraints::tc7671", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23950, 23951], leaf: 23949 }, + Case { id: "bettertls::nameconstraints::tc7672", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23953, 23954], leaf: 23952 }, + Case { id: "bettertls::nameconstraints::tc7673", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23956, 23957], leaf: 23955 }, + Case { id: "bettertls::nameconstraints::tc7674", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23959, 23960], leaf: 23958 }, + Case { id: "bettertls::nameconstraints::tc7675", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23962, 23963], leaf: 23961 }, + Case { id: "bettertls::nameconstraints::tc7676", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23965, 23966], leaf: 23964 }, + Case { id: "bettertls::nameconstraints::tc7677", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23968, 23969], leaf: 23967 }, + Case { id: "bettertls::nameconstraints::tc7678", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23971, 23972], leaf: 23970 }, + Case { id: "bettertls::nameconstraints::tc7679", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23974, 23975], leaf: 23973 }, + Case { id: "bettertls::nameconstraints::tc7680", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23977, 23978], leaf: 23976 }, + Case { id: "bettertls::nameconstraints::tc7681", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23980, 23981], leaf: 23979 }, + Case { id: "bettertls::nameconstraints::tc7682", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23983, 23984], leaf: 23982 }, + Case { id: "bettertls::nameconstraints::tc7683", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23986, 23987], leaf: 23985 }, + Case { id: "bettertls::nameconstraints::tc7684", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23989, 23990], leaf: 23988 }, + Case { id: "bettertls::nameconstraints::tc7685", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23992, 23993], leaf: 23991 }, + Case { id: "bettertls::nameconstraints::tc7686", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23995, 23996], leaf: 23994 }, + Case { id: "bettertls::nameconstraints::tc7687", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[23998, 23999], leaf: 23997 }, + Case { id: "bettertls::nameconstraints::tc7688", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24001, 24002], leaf: 24000 }, + Case { id: "bettertls::nameconstraints::tc7689", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24004, 24005], leaf: 24003 }, + Case { id: "bettertls::nameconstraints::tc7690", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24007, 24008], leaf: 24006 }, + Case { id: "bettertls::nameconstraints::tc7691", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24010, 24011], leaf: 24009 }, + Case { id: "bettertls::nameconstraints::tc7692", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24013, 24014], leaf: 24012 }, + Case { id: "bettertls::nameconstraints::tc7693", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24016, 24017], leaf: 24015 }, + Case { id: "bettertls::nameconstraints::tc7694", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24019, 24020], leaf: 24018 }, + Case { id: "bettertls::nameconstraints::tc7695", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24022, 24023], leaf: 24021 }, + Case { id: "bettertls::nameconstraints::tc7696", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24025, 24026], leaf: 24024 }, + Case { id: "bettertls::nameconstraints::tc7697", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24028, 24029], leaf: 24027 }, + Case { id: "bettertls::nameconstraints::tc7698", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24031, 24032], leaf: 24030 }, + Case { id: "bettertls::nameconstraints::tc7699", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24034, 24035], leaf: 24033 }, + Case { id: "bettertls::nameconstraints::tc7700", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24037, 24038], leaf: 24036 }, + Case { id: "bettertls::nameconstraints::tc7701", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24040, 24041], leaf: 24039 }, + Case { id: "bettertls::nameconstraints::tc7702", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24043, 24044], leaf: 24042 }, + Case { id: "bettertls::nameconstraints::tc7703", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24046, 24047], leaf: 24045 }, + Case { id: "bettertls::nameconstraints::tc7704", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24049, 24050], leaf: 24048 }, + Case { id: "bettertls::nameconstraints::tc7705", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24052, 24053], leaf: 24051 }, + Case { id: "bettertls::nameconstraints::tc7706", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24055, 24056], leaf: 24054 }, + Case { id: "bettertls::nameconstraints::tc7707", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24058, 24059], leaf: 24057 }, + Case { id: "bettertls::nameconstraints::tc7708", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24061, 24062], leaf: 24060 }, + Case { id: "bettertls::nameconstraints::tc7709", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24064, 24065], leaf: 24063 }, + Case { id: "bettertls::nameconstraints::tc7710", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24067, 24068], leaf: 24066 }, + Case { id: "bettertls::nameconstraints::tc7711", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24070, 24071], leaf: 24069 }, + Case { id: "bettertls::nameconstraints::tc7712", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24073, 24074], leaf: 24072 }, + Case { id: "bettertls::nameconstraints::tc7713", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24076, 24077], leaf: 24075 }, + Case { id: "bettertls::nameconstraints::tc7714", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24079, 24080], leaf: 24078 }, + Case { id: "bettertls::nameconstraints::tc7715", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24082, 24083], leaf: 24081 }, + Case { id: "bettertls::nameconstraints::tc7716", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24085, 24086], leaf: 24084 }, + Case { id: "bettertls::nameconstraints::tc7717", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24088, 24089], leaf: 24087 }, + Case { id: "bettertls::nameconstraints::tc7718", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24091, 24092], leaf: 24090 }, + Case { id: "bettertls::nameconstraints::tc7719", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24094, 24095], leaf: 24093 }, + Case { id: "bettertls::nameconstraints::tc7720", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24097, 24098], leaf: 24096 }, + Case { id: "bettertls::nameconstraints::tc7721", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24100, 24101], leaf: 24099 }, + Case { id: "bettertls::nameconstraints::tc7722", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24103, 24104], leaf: 24102 }, + Case { id: "bettertls::nameconstraints::tc7723", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24106, 24107], leaf: 24105 }, + Case { id: "bettertls::nameconstraints::tc7724", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24109, 24110], leaf: 24108 }, + Case { id: "bettertls::nameconstraints::tc7725", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24112, 24113], leaf: 24111 }, + Case { id: "bettertls::nameconstraints::tc7726", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24115, 24116], leaf: 24114 }, + Case { id: "bettertls::nameconstraints::tc7727", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24118, 24119], leaf: 24117 }, + Case { id: "bettertls::nameconstraints::tc7728", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24121, 24122], leaf: 24120 }, + Case { id: "bettertls::nameconstraints::tc7729", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24124, 24125], leaf: 24123 }, + Case { id: "bettertls::nameconstraints::tc7730", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24127, 24128], leaf: 24126 }, + Case { id: "bettertls::nameconstraints::tc7731", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24130, 24131], leaf: 24129 }, + Case { id: "bettertls::nameconstraints::tc7732", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24133, 24134], leaf: 24132 }, + Case { id: "bettertls::nameconstraints::tc7733", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24136, 24137], leaf: 24135 }, + Case { id: "bettertls::nameconstraints::tc7734", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24139, 24140], leaf: 24138 }, + Case { id: "bettertls::nameconstraints::tc7735", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24142, 24143], leaf: 24141 }, + Case { id: "bettertls::nameconstraints::tc7736", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24145, 24146], leaf: 24144 }, + Case { id: "bettertls::nameconstraints::tc7737", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24148, 24149], leaf: 24147 }, + Case { id: "bettertls::nameconstraints::tc7738", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24151, 24152], leaf: 24150 }, + Case { id: "bettertls::nameconstraints::tc7739", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24154, 24155], leaf: 24153 }, + Case { id: "bettertls::nameconstraints::tc7740", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24157, 24158], leaf: 24156 }, + Case { id: "bettertls::nameconstraints::tc7741", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24160, 24161], leaf: 24159 }, + Case { id: "bettertls::nameconstraints::tc7742", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24163, 24164], leaf: 24162 }, + Case { id: "bettertls::nameconstraints::tc7743", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24166, 24167], leaf: 24165 }, + Case { id: "bettertls::nameconstraints::tc7744", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24169, 24170], leaf: 24168 }, + Case { id: "bettertls::nameconstraints::tc7745", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24172, 24173], leaf: 24171 }, + Case { id: "bettertls::nameconstraints::tc7746", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24175, 24176], leaf: 24174 }, + Case { id: "bettertls::nameconstraints::tc7747", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24178, 24179], leaf: 24177 }, + Case { id: "bettertls::nameconstraints::tc7748", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24181, 24182], leaf: 24180 }, + Case { id: "bettertls::nameconstraints::tc7749", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24184, 24185], leaf: 24183 }, + Case { id: "bettertls::nameconstraints::tc7750", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24187, 24188], leaf: 24186 }, + Case { id: "bettertls::nameconstraints::tc7751", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24190, 24191], leaf: 24189 }, + Case { id: "bettertls::nameconstraints::tc7752", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24193, 24194], leaf: 24192 }, + Case { id: "bettertls::nameconstraints::tc7753", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24196, 24197], leaf: 24195 }, + Case { id: "bettertls::nameconstraints::tc7754", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24199, 24200], leaf: 24198 }, + Case { id: "bettertls::nameconstraints::tc7755", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24202, 24203], leaf: 24201 }, + Case { id: "bettertls::nameconstraints::tc7756", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24205, 24206], leaf: 24204 }, + Case { id: "bettertls::nameconstraints::tc7757", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24208, 24209], leaf: 24207 }, + Case { id: "bettertls::nameconstraints::tc7758", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24211, 24212], leaf: 24210 }, + Case { id: "bettertls::nameconstraints::tc7759", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24214, 24215], leaf: 24213 }, + Case { id: "bettertls::nameconstraints::tc7760", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24217, 24218], leaf: 24216 }, + Case { id: "bettertls::nameconstraints::tc7761", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24220, 24221], leaf: 24219 }, + Case { id: "bettertls::nameconstraints::tc7762", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24223, 24224], leaf: 24222 }, + Case { id: "bettertls::nameconstraints::tc7763", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24226, 24227], leaf: 24225 }, + Case { id: "bettertls::nameconstraints::tc7764", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24229, 24230], leaf: 24228 }, + Case { id: "bettertls::nameconstraints::tc7765", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24232, 24233], leaf: 24231 }, + Case { id: "bettertls::nameconstraints::tc7766", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24235, 24236], leaf: 24234 }, + Case { id: "bettertls::nameconstraints::tc7767", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24238, 24239], leaf: 24237 }, + Case { id: "bettertls::nameconstraints::tc7768", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24241, 24242], leaf: 24240 }, + Case { id: "bettertls::nameconstraints::tc7769", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24244, 24245], leaf: 24243 }, + Case { id: "bettertls::nameconstraints::tc7770", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24247, 24248], leaf: 24246 }, + Case { id: "bettertls::nameconstraints::tc7771", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24250, 24251], leaf: 24249 }, + Case { id: "bettertls::nameconstraints::tc7772", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24253, 24254], leaf: 24252 }, + Case { id: "bettertls::nameconstraints::tc7773", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24256, 24257], leaf: 24255 }, + Case { id: "bettertls::nameconstraints::tc7774", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24259, 24260], leaf: 24258 }, + Case { id: "bettertls::nameconstraints::tc7775", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24262, 24263], leaf: 24261 }, + Case { id: "bettertls::nameconstraints::tc7776", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24265, 24266], leaf: 24264 }, + Case { id: "bettertls::nameconstraints::tc7777", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24268, 24269], leaf: 24267 }, + Case { id: "bettertls::nameconstraints::tc7778", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24271, 24272], leaf: 24270 }, + Case { id: "bettertls::nameconstraints::tc7779", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24274, 24275], leaf: 24273 }, + Case { id: "bettertls::nameconstraints::tc7780", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24277, 24278], leaf: 24276 }, + Case { id: "bettertls::nameconstraints::tc7781", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24280, 24281], leaf: 24279 }, + Case { id: "bettertls::nameconstraints::tc7782", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24283, 24284], leaf: 24282 }, + Case { id: "bettertls::nameconstraints::tc7783", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24286, 24287], leaf: 24285 }, + Case { id: "bettertls::nameconstraints::tc7784", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24289, 24290], leaf: 24288 }, + Case { id: "bettertls::nameconstraints::tc7785", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24292, 24293], leaf: 24291 }, + Case { id: "bettertls::nameconstraints::tc7786", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24295, 24296], leaf: 24294 }, + Case { id: "bettertls::nameconstraints::tc7787", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24298, 24299], leaf: 24297 }, + Case { id: "bettertls::nameconstraints::tc7788", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24301, 24302], leaf: 24300 }, + Case { id: "bettertls::nameconstraints::tc7789", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24304, 24305], leaf: 24303 }, + Case { id: "bettertls::nameconstraints::tc7790", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24307, 24308], leaf: 24306 }, + Case { id: "bettertls::nameconstraints::tc7791", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24310, 24311], leaf: 24309 }, + Case { id: "bettertls::nameconstraints::tc7792", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24313, 24314], leaf: 24312 }, + Case { id: "bettertls::nameconstraints::tc7793", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24316, 24317], leaf: 24315 }, + Case { id: "bettertls::nameconstraints::tc7794", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24319, 24320], leaf: 24318 }, + Case { id: "bettertls::nameconstraints::tc7795", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24322, 24323], leaf: 24321 }, + Case { id: "bettertls::nameconstraints::tc7796", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24325, 24326], leaf: 24324 }, + Case { id: "bettertls::nameconstraints::tc7797", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24328, 24329], leaf: 24327 }, + Case { id: "bettertls::nameconstraints::tc7798", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24331, 24332], leaf: 24330 }, + Case { id: "bettertls::nameconstraints::tc7799", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24334, 24335], leaf: 24333 }, + Case { id: "bettertls::nameconstraints::tc7800", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24337, 24338], leaf: 24336 }, + Case { id: "bettertls::nameconstraints::tc7801", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24340, 24341], leaf: 24339 }, + Case { id: "bettertls::nameconstraints::tc7802", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24343, 24344], leaf: 24342 }, + Case { id: "bettertls::nameconstraints::tc7803", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24346, 24347], leaf: 24345 }, + Case { id: "bettertls::nameconstraints::tc7804", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24349, 24350], leaf: 24348 }, + Case { id: "bettertls::nameconstraints::tc7805", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24352, 24353], leaf: 24351 }, + Case { id: "bettertls::nameconstraints::tc7806", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24355, 24356], leaf: 24354 }, + Case { id: "bettertls::nameconstraints::tc7807", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24358, 24359], leaf: 24357 }, + Case { id: "bettertls::nameconstraints::tc7808", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24361, 24362], leaf: 24360 }, + Case { id: "bettertls::nameconstraints::tc7809", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24364, 24365], leaf: 24363 }, + Case { id: "bettertls::nameconstraints::tc7810", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24367, 24368], leaf: 24366 }, + Case { id: "bettertls::nameconstraints::tc7811", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24370, 24371], leaf: 24369 }, + Case { id: "bettertls::nameconstraints::tc7812", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24373, 24374], leaf: 24372 }, + Case { id: "bettertls::nameconstraints::tc7813", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24376, 24377], leaf: 24375 }, + Case { id: "bettertls::nameconstraints::tc7814", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24379, 24380], leaf: 24378 }, + Case { id: "bettertls::nameconstraints::tc7815", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24382, 24383], leaf: 24381 }, + Case { id: "bettertls::nameconstraints::tc7816", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24385, 24386], leaf: 24384 }, + Case { id: "bettertls::nameconstraints::tc7817", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24388, 24389], leaf: 24387 }, + Case { id: "bettertls::nameconstraints::tc7818", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24391, 24392], leaf: 24390 }, + Case { id: "bettertls::nameconstraints::tc7819", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24394, 24395], leaf: 24393 }, + Case { id: "bettertls::nameconstraints::tc7820", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24397, 24398], leaf: 24396 }, + Case { id: "bettertls::nameconstraints::tc7821", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24400, 24401], leaf: 24399 }, + Case { id: "bettertls::nameconstraints::tc7822", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24403, 24404], leaf: 24402 }, + Case { id: "bettertls::nameconstraints::tc7823", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24406, 24407], leaf: 24405 }, + Case { id: "bettertls::nameconstraints::tc7824", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24409, 24410], leaf: 24408 }, + Case { id: "bettertls::nameconstraints::tc7825", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24412, 24413], leaf: 24411 }, + Case { id: "bettertls::nameconstraints::tc7826", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24415, 24416], leaf: 24414 }, + Case { id: "bettertls::nameconstraints::tc7827", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24418, 24419], leaf: 24417 }, + Case { id: "bettertls::nameconstraints::tc7828", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24421, 24422], leaf: 24420 }, + Case { id: "bettertls::nameconstraints::tc7829", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24424, 24425], leaf: 24423 }, + Case { id: "bettertls::nameconstraints::tc7830", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24427, 24428], leaf: 24426 }, + Case { id: "bettertls::nameconstraints::tc7831", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24430, 24431], leaf: 24429 }, + Case { id: "bettertls::nameconstraints::tc7832", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24433, 24434], leaf: 24432 }, + Case { id: "bettertls::nameconstraints::tc7833", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24436, 24437], leaf: 24435 }, + Case { id: "bettertls::nameconstraints::tc7834", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24439, 24440], leaf: 24438 }, + Case { id: "bettertls::nameconstraints::tc7835", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24442, 24443], leaf: 24441 }, + Case { id: "bettertls::nameconstraints::tc7836", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24445, 24446], leaf: 24444 }, + Case { id: "bettertls::nameconstraints::tc7837", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24448, 24449], leaf: 24447 }, + Case { id: "bettertls::nameconstraints::tc7838", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24451, 24452], leaf: 24450 }, + Case { id: "bettertls::nameconstraints::tc7839", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24454, 24455], leaf: 24453 }, + Case { id: "bettertls::nameconstraints::tc7840", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24457, 24458], leaf: 24456 }, + Case { id: "bettertls::nameconstraints::tc7841", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24460, 24461], leaf: 24459 }, + Case { id: "bettertls::nameconstraints::tc7842", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24463, 24464], leaf: 24462 }, + Case { id: "bettertls::nameconstraints::tc7843", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24466, 24467], leaf: 24465 }, + Case { id: "bettertls::nameconstraints::tc7844", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24469, 24470], leaf: 24468 }, + Case { id: "bettertls::nameconstraints::tc7845", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24472, 24473], leaf: 24471 }, + Case { id: "bettertls::nameconstraints::tc7846", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24475, 24476], leaf: 24474 }, + Case { id: "bettertls::nameconstraints::tc7847", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24478, 24479], leaf: 24477 }, + Case { id: "bettertls::nameconstraints::tc7848", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24481, 24482], leaf: 24480 }, + Case { id: "bettertls::nameconstraints::tc7849", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24484, 24485], leaf: 24483 }, + Case { id: "bettertls::nameconstraints::tc7850", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24487, 24488], leaf: 24486 }, + Case { id: "bettertls::nameconstraints::tc7851", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24490, 24491], leaf: 24489 }, + Case { id: "bettertls::nameconstraints::tc7852", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24493, 24494], leaf: 24492 }, + Case { id: "bettertls::nameconstraints::tc7853", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24496, 24497], leaf: 24495 }, + Case { id: "bettertls::nameconstraints::tc7854", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24499, 24500], leaf: 24498 }, + Case { id: "bettertls::nameconstraints::tc7855", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24502, 24503], leaf: 24501 }, + Case { id: "bettertls::nameconstraints::tc7856", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24505, 24506], leaf: 24504 }, + Case { id: "bettertls::nameconstraints::tc7857", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24508, 24509], leaf: 24507 }, + Case { id: "bettertls::nameconstraints::tc7858", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24511, 24512], leaf: 24510 }, + Case { id: "bettertls::nameconstraints::tc7859", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24514, 24515], leaf: 24513 }, + Case { id: "bettertls::nameconstraints::tc7860", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24517, 24518], leaf: 24516 }, + Case { id: "bettertls::nameconstraints::tc7861", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24520, 24521], leaf: 24519 }, + Case { id: "bettertls::nameconstraints::tc7862", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24523, 24524], leaf: 24522 }, + Case { id: "bettertls::nameconstraints::tc7863", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24526, 24527], leaf: 24525 }, + Case { id: "bettertls::nameconstraints::tc7864", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24529, 24530], leaf: 24528 }, + Case { id: "bettertls::nameconstraints::tc7865", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24532, 24533], leaf: 24531 }, + Case { id: "bettertls::nameconstraints::tc7866", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24535, 24536], leaf: 24534 }, + Case { id: "bettertls::nameconstraints::tc7867", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24538, 24539], leaf: 24537 }, + Case { id: "bettertls::nameconstraints::tc7868", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24541, 24542], leaf: 24540 }, + Case { id: "bettertls::nameconstraints::tc7869", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24544, 24545], leaf: 24543 }, + Case { id: "bettertls::nameconstraints::tc7870", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24547, 24548], leaf: 24546 }, + Case { id: "bettertls::nameconstraints::tc7871", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24550, 24551], leaf: 24549 }, + Case { id: "bettertls::nameconstraints::tc7872", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24553, 24554], leaf: 24552 }, + Case { id: "bettertls::nameconstraints::tc7873", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24556, 24557], leaf: 24555 }, + Case { id: "bettertls::nameconstraints::tc7874", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24559, 24560], leaf: 24558 }, + Case { id: "bettertls::nameconstraints::tc7875", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24562, 24563], leaf: 24561 }, + Case { id: "bettertls::nameconstraints::tc7876", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24565, 24566], leaf: 24564 }, + Case { id: "bettertls::nameconstraints::tc7877", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24568, 24569], leaf: 24567 }, + Case { id: "bettertls::nameconstraints::tc7878", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24571, 24572], leaf: 24570 }, + Case { id: "bettertls::nameconstraints::tc7879", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24574, 24575], leaf: 24573 }, + Case { id: "bettertls::nameconstraints::tc7880", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24577, 24578], leaf: 24576 }, + Case { id: "bettertls::nameconstraints::tc7881", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24580, 24581], leaf: 24579 }, + Case { id: "bettertls::nameconstraints::tc7882", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24583, 24584], leaf: 24582 }, + Case { id: "bettertls::nameconstraints::tc7883", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24586, 24587], leaf: 24585 }, + Case { id: "bettertls::nameconstraints::tc7884", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24589, 24590], leaf: 24588 }, + Case { id: "bettertls::nameconstraints::tc7885", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24592, 24593], leaf: 24591 }, + Case { id: "bettertls::nameconstraints::tc7886", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24595, 24596], leaf: 24594 }, + Case { id: "bettertls::nameconstraints::tc7887", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24598, 24599], leaf: 24597 }, + Case { id: "bettertls::nameconstraints::tc7888", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24601, 24602], leaf: 24600 }, + Case { id: "bettertls::nameconstraints::tc7889", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24604, 24605], leaf: 24603 }, + Case { id: "bettertls::nameconstraints::tc7890", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24607, 24608], leaf: 24606 }, + Case { id: "bettertls::nameconstraints::tc7891", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24610, 24611], leaf: 24609 }, + Case { id: "bettertls::nameconstraints::tc7892", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24613, 24614], leaf: 24612 }, + Case { id: "bettertls::nameconstraints::tc7893", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24616, 24617], leaf: 24615 }, + Case { id: "bettertls::nameconstraints::tc7894", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24619, 24620], leaf: 24618 }, + Case { id: "bettertls::nameconstraints::tc7895", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24622, 24623], leaf: 24621 }, + Case { id: "bettertls::nameconstraints::tc7896", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24625, 24626], leaf: 24624 }, + Case { id: "bettertls::nameconstraints::tc7897", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24628, 24629], leaf: 24627 }, + Case { id: "bettertls::nameconstraints::tc7898", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24631, 24632], leaf: 24630 }, + Case { id: "bettertls::nameconstraints::tc7899", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24634, 24635], leaf: 24633 }, + Case { id: "bettertls::nameconstraints::tc7900", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24637, 24638], leaf: 24636 }, + Case { id: "bettertls::nameconstraints::tc7901", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24640, 24641], leaf: 24639 }, + Case { id: "bettertls::nameconstraints::tc7902", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24643, 24644], leaf: 24642 }, + Case { id: "bettertls::nameconstraints::tc7903", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24646, 24647], leaf: 24645 }, + Case { id: "bettertls::nameconstraints::tc7904", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24649, 24650], leaf: 24648 }, + Case { id: "bettertls::nameconstraints::tc7905", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24652, 24653], leaf: 24651 }, + Case { id: "bettertls::nameconstraints::tc7906", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24655, 24656], leaf: 24654 }, + Case { id: "bettertls::nameconstraints::tc7907", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24658, 24659], leaf: 24657 }, + Case { id: "bettertls::nameconstraints::tc7908", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24661, 24662], leaf: 24660 }, + Case { id: "bettertls::nameconstraints::tc7909", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24664, 24665], leaf: 24663 }, + Case { id: "bettertls::nameconstraints::tc7910", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24667, 24668], leaf: 24666 }, + Case { id: "bettertls::nameconstraints::tc7911", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24670, 24671], leaf: 24669 }, + Case { id: "bettertls::nameconstraints::tc7912", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24673, 24674], leaf: 24672 }, + Case { id: "bettertls::nameconstraints::tc7913", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24676, 24677], leaf: 24675 }, + Case { id: "bettertls::nameconstraints::tc7914", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24679, 24680], leaf: 24678 }, + Case { id: "bettertls::nameconstraints::tc7915", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24682, 24683], leaf: 24681 }, + Case { id: "bettertls::nameconstraints::tc7916", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24685, 24686], leaf: 24684 }, + Case { id: "bettertls::nameconstraints::tc7917", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24688, 24689], leaf: 24687 }, + Case { id: "bettertls::nameconstraints::tc7918", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24691, 24692], leaf: 24690 }, + Case { id: "bettertls::nameconstraints::tc7919", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24694, 24695], leaf: 24693 }, + Case { id: "bettertls::nameconstraints::tc7920", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24697, 24698], leaf: 24696 }, + Case { id: "bettertls::nameconstraints::tc7921", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24700, 24701], leaf: 24699 }, + Case { id: "bettertls::nameconstraints::tc7922", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24703, 24704], leaf: 24702 }, + Case { id: "bettertls::nameconstraints::tc7923", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24706, 24707], leaf: 24705 }, + Case { id: "bettertls::nameconstraints::tc7924", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24709, 24710], leaf: 24708 }, + Case { id: "bettertls::nameconstraints::tc7925", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24712, 24713], leaf: 24711 }, + Case { id: "bettertls::nameconstraints::tc7926", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24715, 24716], leaf: 24714 }, + Case { id: "bettertls::nameconstraints::tc7927", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24718, 24719], leaf: 24717 }, + Case { id: "bettertls::nameconstraints::tc7928", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24721, 24722], leaf: 24720 }, + Case { id: "bettertls::nameconstraints::tc7929", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24724, 24725], leaf: 24723 }, + Case { id: "bettertls::nameconstraints::tc7930", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24727, 24728], leaf: 24726 }, + Case { id: "bettertls::nameconstraints::tc7931", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24730, 24731], leaf: 24729 }, + Case { id: "bettertls::nameconstraints::tc7932", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24733, 24734], leaf: 24732 }, + Case { id: "bettertls::nameconstraints::tc7933", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24736, 24737], leaf: 24735 }, + Case { id: "bettertls::nameconstraints::tc7934", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24739, 24740], leaf: 24738 }, + Case { id: "bettertls::nameconstraints::tc7935", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24742, 24743], leaf: 24741 }, + Case { id: "bettertls::nameconstraints::tc7936", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24745, 24746], leaf: 24744 }, + Case { id: "bettertls::nameconstraints::tc7937", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24748, 24749], leaf: 24747 }, + Case { id: "bettertls::nameconstraints::tc7938", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24751, 24752], leaf: 24750 }, + Case { id: "bettertls::nameconstraints::tc7939", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24754, 24755], leaf: 24753 }, + Case { id: "bettertls::nameconstraints::tc7940", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24757, 24758], leaf: 24756 }, + Case { id: "bettertls::nameconstraints::tc7941", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24760, 24761], leaf: 24759 }, + Case { id: "bettertls::nameconstraints::tc7942", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24763, 24764], leaf: 24762 }, + Case { id: "bettertls::nameconstraints::tc7943", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24766, 24767], leaf: 24765 }, + Case { id: "bettertls::nameconstraints::tc7944", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24769, 24770], leaf: 24768 }, + Case { id: "bettertls::nameconstraints::tc7945", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24772, 24773], leaf: 24771 }, + Case { id: "bettertls::nameconstraints::tc7946", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24775, 24776], leaf: 24774 }, + Case { id: "bettertls::nameconstraints::tc7947", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24778, 24779], leaf: 24777 }, + Case { id: "bettertls::nameconstraints::tc7948", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24781, 24782], leaf: 24780 }, + Case { id: "bettertls::nameconstraints::tc7949", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24784, 24785], leaf: 24783 }, + Case { id: "bettertls::nameconstraints::tc7950", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24787, 24788], leaf: 24786 }, + Case { id: "bettertls::nameconstraints::tc7951", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24790, 24791], leaf: 24789 }, + Case { id: "bettertls::nameconstraints::tc7952", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24793, 24794], leaf: 24792 }, + Case { id: "bettertls::nameconstraints::tc7953", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24796, 24797], leaf: 24795 }, + Case { id: "bettertls::nameconstraints::tc7954", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24799, 24800], leaf: 24798 }, + Case { id: "bettertls::nameconstraints::tc7955", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24802, 24803], leaf: 24801 }, + Case { id: "bettertls::nameconstraints::tc7956", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24805, 24806], leaf: 24804 }, + Case { id: "bettertls::nameconstraints::tc7957", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24808, 24809], leaf: 24807 }, + Case { id: "bettertls::nameconstraints::tc7958", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24811, 24812], leaf: 24810 }, + Case { id: "bettertls::nameconstraints::tc7959", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24814, 24815], leaf: 24813 }, + Case { id: "bettertls::nameconstraints::tc7960", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24817, 24818], leaf: 24816 }, + Case { id: "bettertls::nameconstraints::tc7961", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24820, 24821], leaf: 24819 }, + Case { id: "bettertls::nameconstraints::tc7962", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24823, 24824], leaf: 24822 }, + Case { id: "bettertls::nameconstraints::tc7963", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24826, 24827], leaf: 24825 }, + Case { id: "bettertls::nameconstraints::tc7964", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24829, 24830], leaf: 24828 }, + Case { id: "bettertls::nameconstraints::tc7965", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24832, 24833], leaf: 24831 }, + Case { id: "bettertls::nameconstraints::tc7966", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24835, 24836], leaf: 24834 }, + Case { id: "bettertls::nameconstraints::tc7967", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24838, 24839], leaf: 24837 }, + Case { id: "bettertls::nameconstraints::tc7968", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24841, 24842], leaf: 24840 }, + Case { id: "bettertls::nameconstraints::tc7969", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24844, 24845], leaf: 24843 }, + Case { id: "bettertls::nameconstraints::tc7970", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24847, 24848], leaf: 24846 }, + Case { id: "bettertls::nameconstraints::tc7971", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24850, 24851], leaf: 24849 }, + Case { id: "bettertls::nameconstraints::tc7972", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24853, 24854], leaf: 24852 }, + Case { id: "bettertls::nameconstraints::tc7973", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24856, 24857], leaf: 24855 }, + Case { id: "bettertls::nameconstraints::tc7974", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24859, 24860], leaf: 24858 }, + Case { id: "bettertls::nameconstraints::tc7975", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24862, 24863], leaf: 24861 }, + Case { id: "bettertls::nameconstraints::tc7976", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24865, 24866], leaf: 24864 }, + Case { id: "bettertls::nameconstraints::tc7977", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24868, 24869], leaf: 24867 }, + Case { id: "bettertls::nameconstraints::tc7978", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24871, 24872], leaf: 24870 }, + Case { id: "bettertls::nameconstraints::tc7979", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24874, 24875], leaf: 24873 }, + Case { id: "bettertls::nameconstraints::tc7980", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24877, 24878], leaf: 24876 }, + Case { id: "bettertls::nameconstraints::tc7981", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24880, 24881], leaf: 24879 }, + Case { id: "bettertls::nameconstraints::tc7982", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24883, 24884], leaf: 24882 }, + Case { id: "bettertls::nameconstraints::tc7983", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24886, 24887], leaf: 24885 }, + Case { id: "bettertls::nameconstraints::tc7984", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24889, 24890], leaf: 24888 }, + Case { id: "bettertls::nameconstraints::tc7985", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24892, 24893], leaf: 24891 }, + Case { id: "bettertls::nameconstraints::tc7986", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24895, 24896], leaf: 24894 }, + Case { id: "bettertls::nameconstraints::tc7987", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24898, 24899], leaf: 24897 }, + Case { id: "bettertls::nameconstraints::tc7988", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24901, 24902], leaf: 24900 }, + Case { id: "bettertls::nameconstraints::tc7989", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24904, 24905], leaf: 24903 }, + Case { id: "bettertls::nameconstraints::tc7990", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24907, 24908], leaf: 24906 }, + Case { id: "bettertls::nameconstraints::tc7991", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24910, 24911], leaf: 24909 }, + Case { id: "bettertls::nameconstraints::tc7992", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24913, 24914], leaf: 24912 }, + Case { id: "bettertls::nameconstraints::tc7993", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24916, 24917], leaf: 24915 }, + Case { id: "bettertls::nameconstraints::tc7994", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24919, 24920], leaf: 24918 }, + Case { id: "bettertls::nameconstraints::tc7995", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24922, 24923], leaf: 24921 }, + Case { id: "bettertls::nameconstraints::tc7996", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24925, 24926], leaf: 24924 }, + Case { id: "bettertls::nameconstraints::tc7997", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24928, 24929], leaf: 24927 }, + Case { id: "bettertls::nameconstraints::tc7998", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24931, 24932], leaf: 24930 }, + Case { id: "bettertls::nameconstraints::tc7999", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24934, 24935], leaf: 24933 }, + Case { id: "bettertls::nameconstraints::tc8000", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24937, 24938], leaf: 24936 }, + Case { id: "bettertls::nameconstraints::tc8001", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24940, 24941], leaf: 24939 }, + Case { id: "bettertls::nameconstraints::tc8002", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24943, 24944], leaf: 24942 }, + Case { id: "bettertls::nameconstraints::tc8003", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24946, 24947], leaf: 24945 }, + Case { id: "bettertls::nameconstraints::tc8004", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24949, 24950], leaf: 24948 }, + Case { id: "bettertls::nameconstraints::tc8005", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24952, 24953], leaf: 24951 }, + Case { id: "bettertls::nameconstraints::tc8006", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24955, 24956], leaf: 24954 }, + Case { id: "bettertls::nameconstraints::tc8007", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24958, 24959], leaf: 24957 }, + Case { id: "bettertls::nameconstraints::tc8008", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24961, 24962], leaf: 24960 }, + Case { id: "bettertls::nameconstraints::tc8009", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24964, 24965], leaf: 24963 }, + Case { id: "bettertls::nameconstraints::tc8010", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24967, 24968], leaf: 24966 }, + Case { id: "bettertls::nameconstraints::tc8011", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24970, 24971], leaf: 24969 }, + Case { id: "bettertls::nameconstraints::tc8012", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24973, 24974], leaf: 24972 }, + Case { id: "bettertls::nameconstraints::tc8013", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24976, 24977], leaf: 24975 }, + Case { id: "bettertls::nameconstraints::tc8014", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24979, 24980], leaf: 24978 }, + Case { id: "bettertls::nameconstraints::tc8015", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24982, 24983], leaf: 24981 }, + Case { id: "bettertls::nameconstraints::tc8016", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24985, 24986], leaf: 24984 }, + Case { id: "bettertls::nameconstraints::tc8017", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24988, 24989], leaf: 24987 }, + Case { id: "bettertls::nameconstraints::tc8018", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24991, 24992], leaf: 24990 }, + Case { id: "bettertls::nameconstraints::tc8019", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24994, 24995], leaf: 24993 }, + Case { id: "bettertls::nameconstraints::tc8020", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[24997, 24998], leaf: 24996 }, + Case { id: "bettertls::nameconstraints::tc8021", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25000, 25001], leaf: 24999 }, + Case { id: "bettertls::nameconstraints::tc8022", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25003, 25004], leaf: 25002 }, + Case { id: "bettertls::nameconstraints::tc8023", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25006, 25007], leaf: 25005 }, + Case { id: "bettertls::nameconstraints::tc8024", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25009, 25010], leaf: 25008 }, + Case { id: "bettertls::nameconstraints::tc8025", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25012, 25013], leaf: 25011 }, + Case { id: "bettertls::nameconstraints::tc8026", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25015, 25016], leaf: 25014 }, + Case { id: "bettertls::nameconstraints::tc8027", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25018, 25019], leaf: 25017 }, + Case { id: "bettertls::nameconstraints::tc8028", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25021, 25022], leaf: 25020 }, + Case { id: "bettertls::nameconstraints::tc8029", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25024, 25025], leaf: 25023 }, + Case { id: "bettertls::nameconstraints::tc8030", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25027, 25028], leaf: 25026 }, + Case { id: "bettertls::nameconstraints::tc8031", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25030, 25031], leaf: 25029 }, + Case { id: "bettertls::nameconstraints::tc8032", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25033, 25034], leaf: 25032 }, + Case { id: "bettertls::nameconstraints::tc8033", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25036, 25037], leaf: 25035 }, + Case { id: "bettertls::nameconstraints::tc8034", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25039, 25040], leaf: 25038 }, + Case { id: "bettertls::nameconstraints::tc8035", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25042, 25043], leaf: 25041 }, + Case { id: "bettertls::nameconstraints::tc8036", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25045, 25046], leaf: 25044 }, + Case { id: "bettertls::nameconstraints::tc8037", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25048, 25049], leaf: 25047 }, + Case { id: "bettertls::nameconstraints::tc8038", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25051, 25052], leaf: 25050 }, + Case { id: "bettertls::nameconstraints::tc8039", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25054, 25055], leaf: 25053 }, + Case { id: "bettertls::nameconstraints::tc8040", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25057, 25058], leaf: 25056 }, + Case { id: "bettertls::nameconstraints::tc8041", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25060, 25061], leaf: 25059 }, + Case { id: "bettertls::nameconstraints::tc8042", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25063, 25064], leaf: 25062 }, + Case { id: "bettertls::nameconstraints::tc8043", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25066, 25067], leaf: 25065 }, + Case { id: "bettertls::nameconstraints::tc8044", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25069, 25070], leaf: 25068 }, + Case { id: "bettertls::nameconstraints::tc8045", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25072, 25073], leaf: 25071 }, + Case { id: "bettertls::nameconstraints::tc8046", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25075, 25076], leaf: 25074 }, + Case { id: "bettertls::nameconstraints::tc8047", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25078, 25079], leaf: 25077 }, + Case { id: "bettertls::nameconstraints::tc8048", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25081, 25082], leaf: 25080 }, + Case { id: "bettertls::nameconstraints::tc8049", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25084, 25085], leaf: 25083 }, + Case { id: "bettertls::nameconstraints::tc8050", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25087, 25088], leaf: 25086 }, + Case { id: "bettertls::nameconstraints::tc8051", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25090, 25091], leaf: 25089 }, + Case { id: "bettertls::nameconstraints::tc8052", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25093, 25094], leaf: 25092 }, + Case { id: "bettertls::nameconstraints::tc8053", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25096, 25097], leaf: 25095 }, + Case { id: "bettertls::nameconstraints::tc8054", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25099, 25100], leaf: 25098 }, + Case { id: "bettertls::nameconstraints::tc8055", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25102, 25103], leaf: 25101 }, + Case { id: "bettertls::nameconstraints::tc8056", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25105, 25106], leaf: 25104 }, + Case { id: "bettertls::nameconstraints::tc8057", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25108, 25109], leaf: 25107 }, + Case { id: "bettertls::nameconstraints::tc8058", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25111, 25112], leaf: 25110 }, + Case { id: "bettertls::nameconstraints::tc8059", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25114, 25115], leaf: 25113 }, + Case { id: "bettertls::nameconstraints::tc8060", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25117, 25118], leaf: 25116 }, + Case { id: "bettertls::nameconstraints::tc8061", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25120, 25121], leaf: 25119 }, + Case { id: "bettertls::nameconstraints::tc8062", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25123, 25124], leaf: 25122 }, + Case { id: "bettertls::nameconstraints::tc8063", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25126, 25127], leaf: 25125 }, + Case { id: "bettertls::nameconstraints::tc8064", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25129, 25130], leaf: 25128 }, + Case { id: "bettertls::nameconstraints::tc8065", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25132, 25133], leaf: 25131 }, + Case { id: "bettertls::nameconstraints::tc8066", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25135, 25136], leaf: 25134 }, + Case { id: "bettertls::nameconstraints::tc8067", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25138, 25139], leaf: 25137 }, + Case { id: "bettertls::nameconstraints::tc8068", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25141, 25142], leaf: 25140 }, + Case { id: "bettertls::nameconstraints::tc8069", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25144, 25145], leaf: 25143 }, + Case { id: "bettertls::nameconstraints::tc8070", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25147, 25148], leaf: 25146 }, + Case { id: "bettertls::nameconstraints::tc8071", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25150, 25151], leaf: 25149 }, + Case { id: "bettertls::nameconstraints::tc8072", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25153, 25154], leaf: 25152 }, + Case { id: "bettertls::nameconstraints::tc8073", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25156, 25157], leaf: 25155 }, + Case { id: "bettertls::nameconstraints::tc8074", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25159, 25160], leaf: 25158 }, + Case { id: "bettertls::nameconstraints::tc8075", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25162, 25163], leaf: 25161 }, + Case { id: "bettertls::nameconstraints::tc8076", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25165, 25166], leaf: 25164 }, + Case { id: "bettertls::nameconstraints::tc8077", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25168, 25169], leaf: 25167 }, + Case { id: "bettertls::nameconstraints::tc8078", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25171, 25172], leaf: 25170 }, + Case { id: "bettertls::nameconstraints::tc8079", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25174, 25175], leaf: 25173 }, + Case { id: "bettertls::nameconstraints::tc8080", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25177, 25178], leaf: 25176 }, + Case { id: "bettertls::nameconstraints::tc8081", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25180, 25181], leaf: 25179 }, + Case { id: "bettertls::nameconstraints::tc8082", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25183, 25184], leaf: 25182 }, + Case { id: "bettertls::nameconstraints::tc8083", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25186, 25187], leaf: 25185 }, + Case { id: "bettertls::nameconstraints::tc8084", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25189, 25190], leaf: 25188 }, + Case { id: "bettertls::nameconstraints::tc8085", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25192, 25193], leaf: 25191 }, + Case { id: "bettertls::nameconstraints::tc8086", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25195, 25196], leaf: 25194 }, + Case { id: "bettertls::nameconstraints::tc8087", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25198, 25199], leaf: 25197 }, + Case { id: "bettertls::nameconstraints::tc8088", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25201, 25202], leaf: 25200 }, + Case { id: "bettertls::nameconstraints::tc8089", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25204, 25205], leaf: 25203 }, + Case { id: "bettertls::nameconstraints::tc8090", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25207, 25208], leaf: 25206 }, + Case { id: "bettertls::nameconstraints::tc8091", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25210, 25211], leaf: 25209 }, + Case { id: "bettertls::nameconstraints::tc8092", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25213, 25214], leaf: 25212 }, + Case { id: "bettertls::nameconstraints::tc8093", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25216, 25217], leaf: 25215 }, + Case { id: "bettertls::nameconstraints::tc8094", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25219, 25220], leaf: 25218 }, + Case { id: "bettertls::nameconstraints::tc8095", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25222, 25223], leaf: 25221 }, + Case { id: "bettertls::nameconstraints::tc8096", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25225, 25226], leaf: 25224 }, + Case { id: "bettertls::nameconstraints::tc8097", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25228, 25229], leaf: 25227 }, + Case { id: "bettertls::nameconstraints::tc8098", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25231, 25232], leaf: 25230 }, + Case { id: "bettertls::nameconstraints::tc8099", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25234, 25235], leaf: 25233 }, + Case { id: "bettertls::nameconstraints::tc8100", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25237, 25238], leaf: 25236 }, + Case { id: "bettertls::nameconstraints::tc8101", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25240, 25241], leaf: 25239 }, + Case { id: "bettertls::nameconstraints::tc8102", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25243, 25244], leaf: 25242 }, + Case { id: "bettertls::nameconstraints::tc8103", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25246, 25247], leaf: 25245 }, + Case { id: "bettertls::nameconstraints::tc8104", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25249, 25250], leaf: 25248 }, + Case { id: "bettertls::nameconstraints::tc8105", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25252, 25253], leaf: 25251 }, + Case { id: "bettertls::nameconstraints::tc8106", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25255, 25256], leaf: 25254 }, + Case { id: "bettertls::nameconstraints::tc8107", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25258, 25259], leaf: 25257 }, + Case { id: "bettertls::nameconstraints::tc8108", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25261, 25262], leaf: 25260 }, + Case { id: "bettertls::nameconstraints::tc8109", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25264, 25265], leaf: 25263 }, + Case { id: "bettertls::nameconstraints::tc8110", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25267, 25268], leaf: 25266 }, + Case { id: "bettertls::nameconstraints::tc8111", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25270, 25271], leaf: 25269 }, + Case { id: "bettertls::nameconstraints::tc8112", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25273, 25274], leaf: 25272 }, + Case { id: "bettertls::nameconstraints::tc8113", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25276, 25277], leaf: 25275 }, + Case { id: "bettertls::nameconstraints::tc8114", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25279, 25280], leaf: 25278 }, + Case { id: "bettertls::nameconstraints::tc8115", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25282, 25283], leaf: 25281 }, + Case { id: "bettertls::nameconstraints::tc8116", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25285, 25286], leaf: 25284 }, + Case { id: "bettertls::nameconstraints::tc8117", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25288, 25289], leaf: 25287 }, + Case { id: "bettertls::nameconstraints::tc8118", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25291, 25292], leaf: 25290 }, + Case { id: "bettertls::nameconstraints::tc8119", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25294, 25295], leaf: 25293 }, + Case { id: "bettertls::nameconstraints::tc8120", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25297, 25298], leaf: 25296 }, + Case { id: "bettertls::nameconstraints::tc8121", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25300, 25301], leaf: 25299 }, + Case { id: "bettertls::nameconstraints::tc8122", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25303, 25304], leaf: 25302 }, + Case { id: "bettertls::nameconstraints::tc8123", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25306, 25307], leaf: 25305 }, + Case { id: "bettertls::nameconstraints::tc8124", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25309, 25310], leaf: 25308 }, + Case { id: "bettertls::nameconstraints::tc8125", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25312, 25313], leaf: 25311 }, + Case { id: "bettertls::nameconstraints::tc8126", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25315, 25316], leaf: 25314 }, + Case { id: "bettertls::nameconstraints::tc8127", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25318, 25319], leaf: 25317 }, + Case { id: "bettertls::nameconstraints::tc8128", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25321, 25322], leaf: 25320 }, + Case { id: "bettertls::nameconstraints::tc8129", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25324, 25325], leaf: 25323 }, + Case { id: "bettertls::nameconstraints::tc8130", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25327, 25328], leaf: 25326 }, + Case { id: "bettertls::nameconstraints::tc8131", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25330, 25331], leaf: 25329 }, + Case { id: "bettertls::nameconstraints::tc8132", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25333, 25334], leaf: 25332 }, + Case { id: "bettertls::nameconstraints::tc8133", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25336, 25337], leaf: 25335 }, + Case { id: "bettertls::nameconstraints::tc8134", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25339, 25340], leaf: 25338 }, + Case { id: "bettertls::nameconstraints::tc8135", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25342, 25343], leaf: 25341 }, + Case { id: "bettertls::nameconstraints::tc8136", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25345, 25346], leaf: 25344 }, + Case { id: "bettertls::nameconstraints::tc8137", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25348, 25349], leaf: 25347 }, + Case { id: "bettertls::nameconstraints::tc8138", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25351, 25352], leaf: 25350 }, + Case { id: "bettertls::nameconstraints::tc8139", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25354, 25355], leaf: 25353 }, + Case { id: "bettertls::nameconstraints::tc8140", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25357, 25358], leaf: 25356 }, + Case { id: "bettertls::nameconstraints::tc8141", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25360, 25361], leaf: 25359 }, + Case { id: "bettertls::nameconstraints::tc8142", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25363, 25364], leaf: 25362 }, + Case { id: "bettertls::nameconstraints::tc8143", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25366, 25367], leaf: 25365 }, + Case { id: "bettertls::nameconstraints::tc8144", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25369, 25370], leaf: 25368 }, + Case { id: "bettertls::nameconstraints::tc8145", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25372, 25373], leaf: 25371 }, + Case { id: "bettertls::nameconstraints::tc8146", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25375, 25376], leaf: 25374 }, + Case { id: "bettertls::nameconstraints::tc8147", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25378, 25379], leaf: 25377 }, + Case { id: "bettertls::nameconstraints::tc8148", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25381, 25382], leaf: 25380 }, + Case { id: "bettertls::nameconstraints::tc8149", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25384, 25385], leaf: 25383 }, + Case { id: "bettertls::nameconstraints::tc8150", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25387, 25388], leaf: 25386 }, + Case { id: "bettertls::nameconstraints::tc8151", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25390, 25391], leaf: 25389 }, + Case { id: "bettertls::nameconstraints::tc8152", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25393, 25394], leaf: 25392 }, + Case { id: "bettertls::nameconstraints::tc8153", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25396, 25397], leaf: 25395 }, + Case { id: "bettertls::nameconstraints::tc8154", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25399, 25400], leaf: 25398 }, + Case { id: "bettertls::nameconstraints::tc8155", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25402, 25403], leaf: 25401 }, + Case { id: "bettertls::nameconstraints::tc8156", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25405, 25406], leaf: 25404 }, + Case { id: "bettertls::nameconstraints::tc8157", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25408, 25409], leaf: 25407 }, + Case { id: "bettertls::nameconstraints::tc8158", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25411, 25412], leaf: 25410 }, + Case { id: "bettertls::nameconstraints::tc8159", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25414, 25415], leaf: 25413 }, + Case { id: "bettertls::nameconstraints::tc8160", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25417, 25418], leaf: 25416 }, + Case { id: "bettertls::nameconstraints::tc8161", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25420, 25421], leaf: 25419 }, + Case { id: "bettertls::nameconstraints::tc8162", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25423, 25424], leaf: 25422 }, + Case { id: "bettertls::nameconstraints::tc8163", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25426, 25427], leaf: 25425 }, + Case { id: "bettertls::nameconstraints::tc8164", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25429, 25430], leaf: 25428 }, + Case { id: "bettertls::nameconstraints::tc8165", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25432, 25433], leaf: 25431 }, + Case { id: "bettertls::nameconstraints::tc8166", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25435, 25436], leaf: 25434 }, + Case { id: "bettertls::nameconstraints::tc8167", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25438, 25439], leaf: 25437 }, + Case { id: "bettertls::nameconstraints::tc8168", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25441, 25442], leaf: 25440 }, + Case { id: "bettertls::nameconstraints::tc8169", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25444, 25445], leaf: 25443 }, + Case { id: "bettertls::nameconstraints::tc8170", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25447, 25448], leaf: 25446 }, + Case { id: "bettertls::nameconstraints::tc8171", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25450, 25451], leaf: 25449 }, + Case { id: "bettertls::nameconstraints::tc8172", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25453, 25454], leaf: 25452 }, + Case { id: "bettertls::nameconstraints::tc8173", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25456, 25457], leaf: 25455 }, + Case { id: "bettertls::nameconstraints::tc8174", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25459, 25460], leaf: 25458 }, + Case { id: "bettertls::nameconstraints::tc8175", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25462, 25463], leaf: 25461 }, + Case { id: "bettertls::nameconstraints::tc8176", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25465, 25466], leaf: 25464 }, + Case { id: "bettertls::nameconstraints::tc8177", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25468, 25469], leaf: 25467 }, + Case { id: "bettertls::nameconstraints::tc8178", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25471, 25472], leaf: 25470 }, + Case { id: "bettertls::nameconstraints::tc8179", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25474, 25475], leaf: 25473 }, + Case { id: "bettertls::nameconstraints::tc8180", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25477, 25478], leaf: 25476 }, + Case { id: "bettertls::nameconstraints::tc8181", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25480, 25481], leaf: 25479 }, + Case { id: "bettertls::nameconstraints::tc8182", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25483, 25484], leaf: 25482 }, + Case { id: "bettertls::nameconstraints::tc8183", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25486, 25487], leaf: 25485 }, + Case { id: "bettertls::nameconstraints::tc8184", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25489, 25490], leaf: 25488 }, + Case { id: "bettertls::nameconstraints::tc8185", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25492, 25493], leaf: 25491 }, + Case { id: "bettertls::nameconstraints::tc8186", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25495, 25496], leaf: 25494 }, + Case { id: "bettertls::nameconstraints::tc8187", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25498, 25499], leaf: 25497 }, + Case { id: "bettertls::nameconstraints::tc8188", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25501, 25502], leaf: 25500 }, + Case { id: "bettertls::nameconstraints::tc8189", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25504, 25505], leaf: 25503 }, + Case { id: "bettertls::nameconstraints::tc8190", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25507, 25508], leaf: 25506 }, + Case { id: "bettertls::nameconstraints::tc8191", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25510, 25511], leaf: 25509 }, + Case { id: "bettertls::nameconstraints::tc8192", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25513, 25514], leaf: 25512 }, + Case { id: "bettertls::nameconstraints::tc8193", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25516, 25517], leaf: 25515 }, + Case { id: "bettertls::nameconstraints::tc8194", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25519, 25520], leaf: 25518 }, + Case { id: "bettertls::nameconstraints::tc8195", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25522, 25523], leaf: 25521 }, + Case { id: "bettertls::nameconstraints::tc8196", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25525, 25526], leaf: 25524 }, + Case { id: "bettertls::nameconstraints::tc8197", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25528, 25529], leaf: 25527 }, + Case { id: "bettertls::nameconstraints::tc8198", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25531, 25532], leaf: 25530 }, + Case { id: "bettertls::nameconstraints::tc8199", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25534, 25535], leaf: 25533 }, + Case { id: "bettertls::nameconstraints::tc8200", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25537, 25538], leaf: 25536 }, + Case { id: "bettertls::nameconstraints::tc8201", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25540, 25541], leaf: 25539 }, + Case { id: "bettertls::nameconstraints::tc8202", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25543, 25544], leaf: 25542 }, + Case { id: "bettertls::nameconstraints::tc8203", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25546, 25547], leaf: 25545 }, + Case { id: "bettertls::nameconstraints::tc8204", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25549, 25550], leaf: 25548 }, + Case { id: "bettertls::nameconstraints::tc8205", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25552, 25553], leaf: 25551 }, + Case { id: "bettertls::nameconstraints::tc8206", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25555, 25556], leaf: 25554 }, + Case { id: "bettertls::nameconstraints::tc8207", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25558, 25559], leaf: 25557 }, + Case { id: "bettertls::nameconstraints::tc8208", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25561, 25562], leaf: 25560 }, + Case { id: "bettertls::nameconstraints::tc8209", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25564, 25565], leaf: 25563 }, + Case { id: "bettertls::nameconstraints::tc8210", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25567, 25568], leaf: 25566 }, + Case { id: "bettertls::nameconstraints::tc8211", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25570, 25571], leaf: 25569 }, + Case { id: "bettertls::nameconstraints::tc8212", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25573, 25574], leaf: 25572 }, + Case { id: "bettertls::nameconstraints::tc8213", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25576, 25577], leaf: 25575 }, + Case { id: "bettertls::nameconstraints::tc8214", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25579, 25580], leaf: 25578 }, + Case { id: "bettertls::nameconstraints::tc8215", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25582, 25583], leaf: 25581 }, + Case { id: "bettertls::nameconstraints::tc8216", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25585, 25586], leaf: 25584 }, + Case { id: "bettertls::nameconstraints::tc8217", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25588, 25589], leaf: 25587 }, + Case { id: "bettertls::nameconstraints::tc8218", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25591, 25592], leaf: 25590 }, + Case { id: "bettertls::nameconstraints::tc8219", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25594, 25595], leaf: 25593 }, + Case { id: "bettertls::nameconstraints::tc8220", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25597, 25598], leaf: 25596 }, + Case { id: "bettertls::nameconstraints::tc8221", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25600, 25601], leaf: 25599 }, + Case { id: "bettertls::nameconstraints::tc8222", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25603, 25604], leaf: 25602 }, + Case { id: "bettertls::nameconstraints::tc8223", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25606, 25607], leaf: 25605 }, + Case { id: "bettertls::nameconstraints::tc8224", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25609, 25610], leaf: 25608 }, + Case { id: "bettertls::nameconstraints::tc8225", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25612, 25613], leaf: 25611 }, + Case { id: "bettertls::nameconstraints::tc8226", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25615, 25616], leaf: 25614 }, + Case { id: "bettertls::nameconstraints::tc8227", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25618, 25619], leaf: 25617 }, + Case { id: "bettertls::nameconstraints::tc8228", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25621, 25622], leaf: 25620 }, + Case { id: "bettertls::nameconstraints::tc8229", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25624, 25625], leaf: 25623 }, + Case { id: "bettertls::nameconstraints::tc8230", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25627, 25628], leaf: 25626 }, + Case { id: "bettertls::nameconstraints::tc8231", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25630, 25631], leaf: 25629 }, + Case { id: "bettertls::nameconstraints::tc8232", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25633, 25634], leaf: 25632 }, + Case { id: "bettertls::nameconstraints::tc8233", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25636, 25637], leaf: 25635 }, + Case { id: "bettertls::nameconstraints::tc8234", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25639, 25640], leaf: 25638 }, + Case { id: "bettertls::nameconstraints::tc8235", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25642, 25643], leaf: 25641 }, + Case { id: "bettertls::nameconstraints::tc8236", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25645, 25646], leaf: 25644 }, + Case { id: "bettertls::nameconstraints::tc8237", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25648, 25649], leaf: 25647 }, + Case { id: "bettertls::nameconstraints::tc8238", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25651, 25652], leaf: 25650 }, + Case { id: "bettertls::nameconstraints::tc8239", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25654, 25655], leaf: 25653 }, + Case { id: "bettertls::nameconstraints::tc8240", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25657, 25658], leaf: 25656 }, + Case { id: "bettertls::nameconstraints::tc8241", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25660, 25661], leaf: 25659 }, + Case { id: "bettertls::nameconstraints::tc8242", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25663, 25664], leaf: 25662 }, + Case { id: "bettertls::nameconstraints::tc8243", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25666, 25667], leaf: 25665 }, + Case { id: "bettertls::nameconstraints::tc8244", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25669, 25670], leaf: 25668 }, + Case { id: "bettertls::nameconstraints::tc8245", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25672, 25673], leaf: 25671 }, + Case { id: "bettertls::nameconstraints::tc8246", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25675, 25676], leaf: 25674 }, + Case { id: "bettertls::nameconstraints::tc8247", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25678, 25679], leaf: 25677 }, + Case { id: "bettertls::nameconstraints::tc8248", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25681, 25682], leaf: 25680 }, + Case { id: "bettertls::nameconstraints::tc8249", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25684, 25685], leaf: 25683 }, + Case { id: "bettertls::nameconstraints::tc8250", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25687, 25688], leaf: 25686 }, + Case { id: "bettertls::nameconstraints::tc8251", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25690, 25691], leaf: 25689 }, + Case { id: "bettertls::nameconstraints::tc8252", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25693, 25694], leaf: 25692 }, + Case { id: "bettertls::nameconstraints::tc8253", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25696, 25697], leaf: 25695 }, + Case { id: "bettertls::nameconstraints::tc8254", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25699, 25700], leaf: 25698 }, + Case { id: "bettertls::nameconstraints::tc8255", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25702, 25703], leaf: 25701 }, + Case { id: "bettertls::nameconstraints::tc8256", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25705, 25706], leaf: 25704 }, + Case { id: "bettertls::nameconstraints::tc8257", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25708, 25709], leaf: 25707 }, + Case { id: "bettertls::nameconstraints::tc8258", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25711, 25712], leaf: 25710 }, + Case { id: "bettertls::nameconstraints::tc8259", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25714, 25715], leaf: 25713 }, + Case { id: "bettertls::nameconstraints::tc8260", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25717, 25718], leaf: 25716 }, + Case { id: "bettertls::nameconstraints::tc8261", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25720, 25721], leaf: 25719 }, + Case { id: "bettertls::nameconstraints::tc8262", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25723, 25724], leaf: 25722 }, + Case { id: "bettertls::nameconstraints::tc8263", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25726, 25727], leaf: 25725 }, + Case { id: "bettertls::nameconstraints::tc8264", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25729, 25730], leaf: 25728 }, + Case { id: "bettertls::nameconstraints::tc8265", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25732, 25733], leaf: 25731 }, + Case { id: "bettertls::nameconstraints::tc8266", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25735, 25736], leaf: 25734 }, + Case { id: "bettertls::nameconstraints::tc8267", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25738, 25739], leaf: 25737 }, + Case { id: "bettertls::nameconstraints::tc8268", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25741, 25742], leaf: 25740 }, + Case { id: "bettertls::nameconstraints::tc8269", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25744, 25745], leaf: 25743 }, + Case { id: "bettertls::nameconstraints::tc8270", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25747, 25748], leaf: 25746 }, + Case { id: "bettertls::nameconstraints::tc8271", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25750, 25751], leaf: 25749 }, + Case { id: "bettertls::nameconstraints::tc8272", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25753, 25754], leaf: 25752 }, + Case { id: "bettertls::nameconstraints::tc8273", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25756, 25757], leaf: 25755 }, + Case { id: "bettertls::nameconstraints::tc8274", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25759, 25760], leaf: 25758 }, + Case { id: "bettertls::nameconstraints::tc8275", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25762, 25763], leaf: 25761 }, + Case { id: "bettertls::nameconstraints::tc8276", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25765, 25766], leaf: 25764 }, + Case { id: "bettertls::nameconstraints::tc8277", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25768, 25769], leaf: 25767 }, + Case { id: "bettertls::nameconstraints::tc8278", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25771, 25772], leaf: 25770 }, + Case { id: "bettertls::nameconstraints::tc8279", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25774, 25775], leaf: 25773 }, + Case { id: "bettertls::nameconstraints::tc8280", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25777, 25778], leaf: 25776 }, + Case { id: "bettertls::nameconstraints::tc8281", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25780, 25781], leaf: 25779 }, + Case { id: "bettertls::nameconstraints::tc8282", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25783, 25784], leaf: 25782 }, + Case { id: "bettertls::nameconstraints::tc8283", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25786, 25787], leaf: 25785 }, + Case { id: "bettertls::nameconstraints::tc8284", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25789, 25790], leaf: 25788 }, + Case { id: "bettertls::nameconstraints::tc8285", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25792, 25793], leaf: 25791 }, + Case { id: "bettertls::nameconstraints::tc8286", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25795, 25796], leaf: 25794 }, + Case { id: "bettertls::nameconstraints::tc8287", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25798, 25799], leaf: 25797 }, + Case { id: "bettertls::nameconstraints::tc8288", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25801, 25802], leaf: 25800 }, + Case { id: "bettertls::nameconstraints::tc8289", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25804, 25805], leaf: 25803 }, + Case { id: "bettertls::nameconstraints::tc8290", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25807, 25808], leaf: 25806 }, + Case { id: "bettertls::nameconstraints::tc8291", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25810, 25811], leaf: 25809 }, + Case { id: "bettertls::nameconstraints::tc8292", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25813, 25814], leaf: 25812 }, + Case { id: "bettertls::nameconstraints::tc8293", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25816, 25817], leaf: 25815 }, + Case { id: "bettertls::nameconstraints::tc8294", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25819, 25820], leaf: 25818 }, + Case { id: "bettertls::nameconstraints::tc8295", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25822, 25823], leaf: 25821 }, + Case { id: "bettertls::nameconstraints::tc8296", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25825, 25826], leaf: 25824 }, + Case { id: "bettertls::nameconstraints::tc8297", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25828, 25829], leaf: 25827 }, + Case { id: "bettertls::nameconstraints::tc8298", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25831, 25832], leaf: 25830 }, + Case { id: "bettertls::nameconstraints::tc8299", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25834, 25835], leaf: 25833 }, + Case { id: "bettertls::nameconstraints::tc8300", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25837, 25838], leaf: 25836 }, + Case { id: "bettertls::nameconstraints::tc8301", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25840, 25841], leaf: 25839 }, + Case { id: "bettertls::nameconstraints::tc8302", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25843, 25844], leaf: 25842 }, + Case { id: "bettertls::nameconstraints::tc8303", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25846, 25847], leaf: 25845 }, + Case { id: "bettertls::nameconstraints::tc8304", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25849, 25850], leaf: 25848 }, + Case { id: "bettertls::nameconstraints::tc8305", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25852, 25853], leaf: 25851 }, + Case { id: "bettertls::nameconstraints::tc8306", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25855, 25856], leaf: 25854 }, + Case { id: "bettertls::nameconstraints::tc8307", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25858, 25859], leaf: 25857 }, + Case { id: "bettertls::nameconstraints::tc8308", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25861, 25862], leaf: 25860 }, + Case { id: "bettertls::nameconstraints::tc8309", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25864, 25865], leaf: 25863 }, + Case { id: "bettertls::nameconstraints::tc8310", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25867, 25868], leaf: 25866 }, + Case { id: "bettertls::nameconstraints::tc8311", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25870, 25871], leaf: 25869 }, + Case { id: "bettertls::nameconstraints::tc8312", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25873, 25874], leaf: 25872 }, + Case { id: "bettertls::nameconstraints::tc8313", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25876, 25877], leaf: 25875 }, + Case { id: "bettertls::nameconstraints::tc8314", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25879, 25880], leaf: 25878 }, + Case { id: "bettertls::nameconstraints::tc8315", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25882, 25883], leaf: 25881 }, + Case { id: "bettertls::nameconstraints::tc8316", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25885, 25886], leaf: 25884 }, + Case { id: "bettertls::nameconstraints::tc8317", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25888, 25889], leaf: 25887 }, + Case { id: "bettertls::nameconstraints::tc8318", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25891, 25892], leaf: 25890 }, + Case { id: "bettertls::nameconstraints::tc8319", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25894, 25895], leaf: 25893 }, + Case { id: "bettertls::nameconstraints::tc8320", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25897, 25898], leaf: 25896 }, + Case { id: "bettertls::nameconstraints::tc8321", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25900, 25901], leaf: 25899 }, + Case { id: "bettertls::nameconstraints::tc8322", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25903, 25904], leaf: 25902 }, + Case { id: "bettertls::nameconstraints::tc8323", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25906, 25907], leaf: 25905 }, + Case { id: "bettertls::nameconstraints::tc8324", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25909, 25910], leaf: 25908 }, + Case { id: "bettertls::nameconstraints::tc8325", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25912, 25913], leaf: 25911 }, + Case { id: "bettertls::nameconstraints::tc8326", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25915, 25916], leaf: 25914 }, + Case { id: "bettertls::nameconstraints::tc8327", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25918, 25919], leaf: 25917 }, + Case { id: "bettertls::nameconstraints::tc8328", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25921, 25922], leaf: 25920 }, + Case { id: "bettertls::nameconstraints::tc8329", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25924, 25925], leaf: 25923 }, + Case { id: "bettertls::nameconstraints::tc8330", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25927, 25928], leaf: 25926 }, + Case { id: "bettertls::nameconstraints::tc8331", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25930, 25931], leaf: 25929 }, + Case { id: "bettertls::nameconstraints::tc8332", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25933, 25934], leaf: 25932 }, + Case { id: "bettertls::nameconstraints::tc8333", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25936, 25937], leaf: 25935 }, + Case { id: "bettertls::nameconstraints::tc8334", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25939, 25940], leaf: 25938 }, + Case { id: "bettertls::nameconstraints::tc8335", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25942, 25943], leaf: 25941 }, + Case { id: "bettertls::nameconstraints::tc8336", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25945, 25946], leaf: 25944 }, + Case { id: "bettertls::nameconstraints::tc8337", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25948, 25949], leaf: 25947 }, + Case { id: "bettertls::nameconstraints::tc8338", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25951, 25952], leaf: 25950 }, + Case { id: "bettertls::nameconstraints::tc8339", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25954, 25955], leaf: 25953 }, + Case { id: "bettertls::nameconstraints::tc8340", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25957, 25958], leaf: 25956 }, + Case { id: "bettertls::nameconstraints::tc8341", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25960, 25961], leaf: 25959 }, + Case { id: "bettertls::nameconstraints::tc8342", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25963, 25964], leaf: 25962 }, + Case { id: "bettertls::nameconstraints::tc8343", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25966, 25967], leaf: 25965 }, + Case { id: "bettertls::nameconstraints::tc8344", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25969, 25970], leaf: 25968 }, + Case { id: "bettertls::nameconstraints::tc8345", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25972, 25973], leaf: 25971 }, + Case { id: "bettertls::nameconstraints::tc8346", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25975, 25976], leaf: 25974 }, + Case { id: "bettertls::nameconstraints::tc8347", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25978, 25979], leaf: 25977 }, + Case { id: "bettertls::nameconstraints::tc8348", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25981, 25982], leaf: 25980 }, + Case { id: "bettertls::nameconstraints::tc8349", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25984, 25985], leaf: 25983 }, + Case { id: "bettertls::nameconstraints::tc8350", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25987, 25988], leaf: 25986 }, + Case { id: "bettertls::nameconstraints::tc8351", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25990, 25991], leaf: 25989 }, + Case { id: "bettertls::nameconstraints::tc8352", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25993, 25994], leaf: 25992 }, + Case { id: "bettertls::nameconstraints::tc8353", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25996, 25997], leaf: 25995 }, + Case { id: "bettertls::nameconstraints::tc8354", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[25999, 26000], leaf: 25998 }, + Case { id: "bettertls::nameconstraints::tc8355", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26002, 26003], leaf: 26001 }, + Case { id: "bettertls::nameconstraints::tc8356", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26005, 26006], leaf: 26004 }, + Case { id: "bettertls::nameconstraints::tc8357", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26008, 26009], leaf: 26007 }, + Case { id: "bettertls::nameconstraints::tc8358", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26011, 26012], leaf: 26010 }, + Case { id: "bettertls::nameconstraints::tc8359", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26014, 26015], leaf: 26013 }, + Case { id: "bettertls::nameconstraints::tc8360", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26017, 26018], leaf: 26016 }, + Case { id: "bettertls::nameconstraints::tc8361", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26020, 26021], leaf: 26019 }, + Case { id: "bettertls::nameconstraints::tc8362", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26023, 26024], leaf: 26022 }, + Case { id: "bettertls::nameconstraints::tc8363", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26026, 26027], leaf: 26025 }, + Case { id: "bettertls::nameconstraints::tc8364", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26029, 26030], leaf: 26028 }, + Case { id: "bettertls::nameconstraints::tc8365", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26032, 26033], leaf: 26031 }, + Case { id: "bettertls::nameconstraints::tc8366", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26035, 26036], leaf: 26034 }, + Case { id: "bettertls::nameconstraints::tc8367", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26038, 26039], leaf: 26037 }, + Case { id: "bettertls::nameconstraints::tc8368", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26041, 26042], leaf: 26040 }, + Case { id: "bettertls::nameconstraints::tc8369", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26044, 26045], leaf: 26043 }, + Case { id: "bettertls::nameconstraints::tc8370", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26047, 26048], leaf: 26046 }, + Case { id: "bettertls::nameconstraints::tc8371", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26050, 26051], leaf: 26049 }, + Case { id: "bettertls::nameconstraints::tc8372", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26053, 26054], leaf: 26052 }, + Case { id: "bettertls::nameconstraints::tc8373", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26056, 26057], leaf: 26055 }, + Case { id: "bettertls::nameconstraints::tc8374", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26059, 26060], leaf: 26058 }, + Case { id: "bettertls::nameconstraints::tc8375", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26062, 26063], leaf: 26061 }, + Case { id: "bettertls::nameconstraints::tc8376", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26065, 26066], leaf: 26064 }, + Case { id: "bettertls::nameconstraints::tc8377", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26068, 26069], leaf: 26067 }, + Case { id: "bettertls::nameconstraints::tc8378", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26071, 26072], leaf: 26070 }, + Case { id: "bettertls::nameconstraints::tc8379", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26074, 26075], leaf: 26073 }, + Case { id: "bettertls::nameconstraints::tc8380", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26077, 26078], leaf: 26076 }, + Case { id: "bettertls::nameconstraints::tc8381", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26080, 26081], leaf: 26079 }, + Case { id: "bettertls::nameconstraints::tc8382", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26083, 26084], leaf: 26082 }, + Case { id: "bettertls::nameconstraints::tc8383", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26086, 26087], leaf: 26085 }, + Case { id: "bettertls::nameconstraints::tc8384", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26089, 26090], leaf: 26088 }, + Case { id: "bettertls::nameconstraints::tc8385", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26092, 26093], leaf: 26091 }, + Case { id: "bettertls::nameconstraints::tc8386", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26095, 26096], leaf: 26094 }, + Case { id: "bettertls::nameconstraints::tc8387", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26098, 26099], leaf: 26097 }, + Case { id: "bettertls::nameconstraints::tc8388", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26101, 26102], leaf: 26100 }, + Case { id: "bettertls::nameconstraints::tc8389", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26104, 26105], leaf: 26103 }, + Case { id: "bettertls::nameconstraints::tc8390", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26107, 26108], leaf: 26106 }, + Case { id: "bettertls::nameconstraints::tc8391", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26110, 26111], leaf: 26109 }, + Case { id: "bettertls::nameconstraints::tc8392", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26113, 26114], leaf: 26112 }, + Case { id: "bettertls::nameconstraints::tc8393", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26116, 26117], leaf: 26115 }, + Case { id: "bettertls::nameconstraints::tc8394", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26119, 26120], leaf: 26118 }, + Case { id: "bettertls::nameconstraints::tc8395", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26122, 26123], leaf: 26121 }, + Case { id: "bettertls::nameconstraints::tc8396", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26125, 26126], leaf: 26124 }, + Case { id: "bettertls::nameconstraints::tc8397", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26128, 26129], leaf: 26127 }, + Case { id: "bettertls::nameconstraints::tc8398", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26131, 26132], leaf: 26130 }, + Case { id: "bettertls::nameconstraints::tc8399", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26134, 26135], leaf: 26133 }, + Case { id: "bettertls::nameconstraints::tc8400", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26137, 26138], leaf: 26136 }, + Case { id: "bettertls::nameconstraints::tc8401", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26140, 26141], leaf: 26139 }, + Case { id: "bettertls::nameconstraints::tc8402", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26143, 26144], leaf: 26142 }, + Case { id: "bettertls::nameconstraints::tc8403", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26146, 26147], leaf: 26145 }, + Case { id: "bettertls::nameconstraints::tc8404", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26149, 26150], leaf: 26148 }, + Case { id: "bettertls::nameconstraints::tc8405", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26152, 26153], leaf: 26151 }, + Case { id: "bettertls::nameconstraints::tc8406", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26155, 26156], leaf: 26154 }, + Case { id: "bettertls::nameconstraints::tc8407", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26158, 26159], leaf: 26157 }, + Case { id: "bettertls::nameconstraints::tc8408", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26161, 26162], leaf: 26160 }, + Case { id: "bettertls::nameconstraints::tc8409", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26164, 26165], leaf: 26163 }, + Case { id: "bettertls::nameconstraints::tc8410", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26167, 26168], leaf: 26166 }, + Case { id: "bettertls::nameconstraints::tc8411", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26170, 26171], leaf: 26169 }, + Case { id: "bettertls::nameconstraints::tc8412", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26173, 26174], leaf: 26172 }, + Case { id: "bettertls::nameconstraints::tc8413", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26176, 26177], leaf: 26175 }, + Case { id: "bettertls::nameconstraints::tc8414", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26179, 26180], leaf: 26178 }, + Case { id: "bettertls::nameconstraints::tc8415", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26182, 26183], leaf: 26181 }, + Case { id: "bettertls::nameconstraints::tc8416", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26185, 26186], leaf: 26184 }, + Case { id: "bettertls::nameconstraints::tc8417", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26188, 26189], leaf: 26187 }, + Case { id: "bettertls::nameconstraints::tc8418", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26191, 26192], leaf: 26190 }, + Case { id: "bettertls::nameconstraints::tc8419", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26194, 26195], leaf: 26193 }, + Case { id: "bettertls::nameconstraints::tc8420", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26197, 26198], leaf: 26196 }, + Case { id: "bettertls::nameconstraints::tc8421", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26200, 26201], leaf: 26199 }, + Case { id: "bettertls::nameconstraints::tc8422", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26203, 26204], leaf: 26202 }, + Case { id: "bettertls::nameconstraints::tc8423", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26206, 26207], leaf: 26205 }, + Case { id: "bettertls::nameconstraints::tc8424", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26209, 26210], leaf: 26208 }, + Case { id: "bettertls::nameconstraints::tc8425", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26212, 26213], leaf: 26211 }, + Case { id: "bettertls::nameconstraints::tc8426", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26215, 26216], leaf: 26214 }, + Case { id: "bettertls::nameconstraints::tc8427", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26218, 26219], leaf: 26217 }, + Case { id: "bettertls::nameconstraints::tc8428", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26221, 26222], leaf: 26220 }, + Case { id: "bettertls::nameconstraints::tc8429", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26224, 26225], leaf: 26223 }, + Case { id: "bettertls::nameconstraints::tc8430", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26227, 26228], leaf: 26226 }, + Case { id: "bettertls::nameconstraints::tc8431", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26230, 26231], leaf: 26229 }, + Case { id: "bettertls::nameconstraints::tc8432", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26233, 26234], leaf: 26232 }, + Case { id: "bettertls::nameconstraints::tc8433", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26236, 26237], leaf: 26235 }, + Case { id: "bettertls::nameconstraints::tc8434", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26239, 26240], leaf: 26238 }, + Case { id: "bettertls::nameconstraints::tc8435", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26242, 26243], leaf: 26241 }, + Case { id: "bettertls::nameconstraints::tc8436", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26245, 26246], leaf: 26244 }, + Case { id: "bettertls::nameconstraints::tc8437", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26248, 26249], leaf: 26247 }, + Case { id: "bettertls::nameconstraints::tc8438", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26251, 26252], leaf: 26250 }, + Case { id: "bettertls::nameconstraints::tc8439", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26254, 26255], leaf: 26253 }, + Case { id: "bettertls::nameconstraints::tc8440", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26257, 26258], leaf: 26256 }, + Case { id: "bettertls::nameconstraints::tc8441", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26260, 26261], leaf: 26259 }, + Case { id: "bettertls::nameconstraints::tc8442", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26263, 26264], leaf: 26262 }, + Case { id: "bettertls::nameconstraints::tc8443", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26266, 26267], leaf: 26265 }, + Case { id: "bettertls::nameconstraints::tc8444", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26269, 26270], leaf: 26268 }, + Case { id: "bettertls::nameconstraints::tc8445", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26272, 26273], leaf: 26271 }, + Case { id: "bettertls::nameconstraints::tc8446", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26275, 26276], leaf: 26274 }, + Case { id: "bettertls::nameconstraints::tc8447", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26278, 26279], leaf: 26277 }, + Case { id: "bettertls::nameconstraints::tc8448", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26281, 26282], leaf: 26280 }, + Case { id: "bettertls::nameconstraints::tc8449", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26284, 26285], leaf: 26283 }, + Case { id: "bettertls::nameconstraints::tc8450", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26287, 26288], leaf: 26286 }, + Case { id: "bettertls::nameconstraints::tc8451", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26290, 26291], leaf: 26289 }, + Case { id: "bettertls::nameconstraints::tc8452", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26293, 26294], leaf: 26292 }, + Case { id: "bettertls::nameconstraints::tc8453", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26296, 26297], leaf: 26295 }, + Case { id: "bettertls::nameconstraints::tc8454", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26299, 26300], leaf: 26298 }, + Case { id: "bettertls::nameconstraints::tc8455", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26302, 26303], leaf: 26301 }, + Case { id: "bettertls::nameconstraints::tc8456", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26305, 26306], leaf: 26304 }, + Case { id: "bettertls::nameconstraints::tc8457", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26308, 26309], leaf: 26307 }, + Case { id: "bettertls::nameconstraints::tc8458", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26311, 26312], leaf: 26310 }, + Case { id: "bettertls::nameconstraints::tc8459", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26314, 26315], leaf: 26313 }, + Case { id: "bettertls::nameconstraints::tc8460", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26317, 26318], leaf: 26316 }, + Case { id: "bettertls::nameconstraints::tc8461", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26320, 26321], leaf: 26319 }, + Case { id: "bettertls::nameconstraints::tc8462", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26323, 26324], leaf: 26322 }, + Case { id: "bettertls::nameconstraints::tc8463", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26326, 26327], leaf: 26325 }, + Case { id: "bettertls::nameconstraints::tc8464", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26329, 26330], leaf: 26328 }, + Case { id: "bettertls::nameconstraints::tc8465", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26332, 26333], leaf: 26331 }, + Case { id: "bettertls::nameconstraints::tc8466", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26335, 26336], leaf: 26334 }, + Case { id: "bettertls::nameconstraints::tc8467", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26338, 26339], leaf: 26337 }, + Case { id: "bettertls::nameconstraints::tc8468", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26341, 26342], leaf: 26340 }, + Case { id: "bettertls::nameconstraints::tc8469", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26344, 26345], leaf: 26343 }, + Case { id: "bettertls::nameconstraints::tc8470", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26347, 26348], leaf: 26346 }, + Case { id: "bettertls::nameconstraints::tc8471", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26350, 26351], leaf: 26349 }, + Case { id: "bettertls::nameconstraints::tc8472", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26353, 26354], leaf: 26352 }, + Case { id: "bettertls::nameconstraints::tc8473", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26356, 26357], leaf: 26355 }, + Case { id: "bettertls::nameconstraints::tc8474", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26359, 26360], leaf: 26358 }, + Case { id: "bettertls::nameconstraints::tc8475", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26362, 26363], leaf: 26361 }, + Case { id: "bettertls::nameconstraints::tc8476", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26365, 26366], leaf: 26364 }, + Case { id: "bettertls::nameconstraints::tc8477", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26368, 26369], leaf: 26367 }, + Case { id: "bettertls::nameconstraints::tc8478", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26371, 26372], leaf: 26370 }, + Case { id: "bettertls::nameconstraints::tc8479", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26374, 26375], leaf: 26373 }, + Case { id: "bettertls::nameconstraints::tc8480", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26377, 26378], leaf: 26376 }, + Case { id: "bettertls::nameconstraints::tc8481", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26380, 26381], leaf: 26379 }, + Case { id: "bettertls::nameconstraints::tc8482", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26383, 26384], leaf: 26382 }, + Case { id: "bettertls::nameconstraints::tc8483", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26386, 26387], leaf: 26385 }, + Case { id: "bettertls::nameconstraints::tc8484", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26389, 26390], leaf: 26388 }, + Case { id: "bettertls::nameconstraints::tc8485", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26392, 26393], leaf: 26391 }, + Case { id: "bettertls::nameconstraints::tc8486", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26395, 26396], leaf: 26394 }, + Case { id: "bettertls::nameconstraints::tc8487", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26398, 26399], leaf: 26397 }, + Case { id: "bettertls::nameconstraints::tc8488", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26401, 26402], leaf: 26400 }, + Case { id: "bettertls::nameconstraints::tc8489", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26404, 26405], leaf: 26403 }, + Case { id: "bettertls::nameconstraints::tc8490", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26407, 26408], leaf: 26406 }, + Case { id: "bettertls::nameconstraints::tc8491", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26410, 26411], leaf: 26409 }, + Case { id: "bettertls::nameconstraints::tc8492", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26413, 26414], leaf: 26412 }, + Case { id: "bettertls::nameconstraints::tc8493", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26416, 26417], leaf: 26415 }, + Case { id: "bettertls::nameconstraints::tc8494", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26419, 26420], leaf: 26418 }, + Case { id: "bettertls::nameconstraints::tc8495", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26422, 26423], leaf: 26421 }, + Case { id: "bettertls::nameconstraints::tc8496", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26425, 26426], leaf: 26424 }, + Case { id: "bettertls::nameconstraints::tc8497", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26428, 26429], leaf: 26427 }, + Case { id: "bettertls::nameconstraints::tc8498", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26431, 26432], leaf: 26430 }, + Case { id: "bettertls::nameconstraints::tc8499", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26434, 26435], leaf: 26433 }, + Case { id: "bettertls::nameconstraints::tc8500", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26437, 26438], leaf: 26436 }, + Case { id: "bettertls::nameconstraints::tc8501", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26440, 26441], leaf: 26439 }, + Case { id: "bettertls::nameconstraints::tc8502", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26443, 26444], leaf: 26442 }, + Case { id: "bettertls::nameconstraints::tc8503", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26446, 26447], leaf: 26445 }, + Case { id: "bettertls::nameconstraints::tc8504", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26449, 26450], leaf: 26448 }, + Case { id: "bettertls::nameconstraints::tc8505", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26452, 26453], leaf: 26451 }, + Case { id: "bettertls::nameconstraints::tc8506", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26455, 26456], leaf: 26454 }, + Case { id: "bettertls::nameconstraints::tc8507", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26458, 26459], leaf: 26457 }, + Case { id: "bettertls::nameconstraints::tc8508", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26461, 26462], leaf: 26460 }, + Case { id: "bettertls::nameconstraints::tc8509", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26464, 26465], leaf: 26463 }, + Case { id: "bettertls::nameconstraints::tc8510", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26467, 26468], leaf: 26466 }, + Case { id: "bettertls::nameconstraints::tc8511", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26470, 26471], leaf: 26469 }, + Case { id: "bettertls::nameconstraints::tc8512", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26473, 26474], leaf: 26472 }, + Case { id: "bettertls::nameconstraints::tc8513", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26476, 26477], leaf: 26475 }, + Case { id: "bettertls::nameconstraints::tc8514", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26479, 26480], leaf: 26478 }, + Case { id: "bettertls::nameconstraints::tc8515", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26482, 26483], leaf: 26481 }, + Case { id: "bettertls::nameconstraints::tc8516", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26485, 26486], leaf: 26484 }, + Case { id: "bettertls::nameconstraints::tc8517", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26488, 26489], leaf: 26487 }, + Case { id: "bettertls::nameconstraints::tc8518", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26491, 26492], leaf: 26490 }, + Case { id: "bettertls::nameconstraints::tc8519", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26494, 26495], leaf: 26493 }, + Case { id: "bettertls::nameconstraints::tc8520", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26497, 26498], leaf: 26496 }, + Case { id: "bettertls::nameconstraints::tc8521", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26500, 26501], leaf: 26499 }, + Case { id: "bettertls::nameconstraints::tc8522", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26503, 26504], leaf: 26502 }, + Case { id: "bettertls::nameconstraints::tc8523", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26506, 26507], leaf: 26505 }, + Case { id: "bettertls::nameconstraints::tc8524", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26509, 26510], leaf: 26508 }, + Case { id: "bettertls::nameconstraints::tc8525", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26512, 26513], leaf: 26511 }, + Case { id: "bettertls::nameconstraints::tc8526", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26515, 26516], leaf: 26514 }, + Case { id: "bettertls::nameconstraints::tc8527", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26518, 26519], leaf: 26517 }, + Case { id: "bettertls::nameconstraints::tc8528", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26521, 26522], leaf: 26520 }, + Case { id: "bettertls::nameconstraints::tc8529", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26524, 26525], leaf: 26523 }, + Case { id: "bettertls::nameconstraints::tc8530", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26527, 26528], leaf: 26526 }, + Case { id: "bettertls::nameconstraints::tc8531", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26530, 26531], leaf: 26529 }, + Case { id: "bettertls::nameconstraints::tc8532", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26533, 26534], leaf: 26532 }, + Case { id: "bettertls::nameconstraints::tc8533", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26536, 26537], leaf: 26535 }, + Case { id: "bettertls::nameconstraints::tc8534", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26539, 26540], leaf: 26538 }, + Case { id: "bettertls::nameconstraints::tc8535", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26542, 26543], leaf: 26541 }, + Case { id: "bettertls::nameconstraints::tc8536", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26545, 26546], leaf: 26544 }, + Case { id: "bettertls::nameconstraints::tc8537", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26548, 26549], leaf: 26547 }, + Case { id: "bettertls::nameconstraints::tc8538", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26551, 26552], leaf: 26550 }, + Case { id: "bettertls::nameconstraints::tc8539", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26554, 26555], leaf: 26553 }, + Case { id: "bettertls::nameconstraints::tc8540", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26557, 26558], leaf: 26556 }, + Case { id: "bettertls::nameconstraints::tc8541", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26560, 26561], leaf: 26559 }, + Case { id: "bettertls::nameconstraints::tc8542", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26563, 26564], leaf: 26562 }, + Case { id: "bettertls::nameconstraints::tc8543", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26566, 26567], leaf: 26565 }, + Case { id: "bettertls::nameconstraints::tc8544", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26569, 26570], leaf: 26568 }, + Case { id: "bettertls::nameconstraints::tc8545", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26572, 26573], leaf: 26571 }, + Case { id: "bettertls::nameconstraints::tc8546", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26575, 26576], leaf: 26574 }, + Case { id: "bettertls::nameconstraints::tc8547", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26578, 26579], leaf: 26577 }, + Case { id: "bettertls::nameconstraints::tc8548", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26581, 26582], leaf: 26580 }, + Case { id: "bettertls::nameconstraints::tc8549", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26584, 26585], leaf: 26583 }, + Case { id: "bettertls::nameconstraints::tc8550", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26587, 26588], leaf: 26586 }, + Case { id: "bettertls::nameconstraints::tc8551", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26590, 26591], leaf: 26589 }, + Case { id: "bettertls::nameconstraints::tc8552", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26593, 26594], leaf: 26592 }, + Case { id: "bettertls::nameconstraints::tc8553", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26596, 26597], leaf: 26595 }, + Case { id: "bettertls::nameconstraints::tc8554", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26599, 26600], leaf: 26598 }, + Case { id: "bettertls::nameconstraints::tc8555", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26602, 26603], leaf: 26601 }, + Case { id: "bettertls::nameconstraints::tc8556", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26605, 26606], leaf: 26604 }, + Case { id: "bettertls::nameconstraints::tc8557", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26608, 26609], leaf: 26607 }, + Case { id: "bettertls::nameconstraints::tc8558", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26611, 26612], leaf: 26610 }, + Case { id: "bettertls::nameconstraints::tc8559", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26614, 26615], leaf: 26613 }, + Case { id: "bettertls::nameconstraints::tc8560", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26617, 26618], leaf: 26616 }, + Case { id: "bettertls::nameconstraints::tc8561", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26620, 26621], leaf: 26619 }, + Case { id: "bettertls::nameconstraints::tc8562", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26623, 26624], leaf: 26622 }, + Case { id: "bettertls::nameconstraints::tc8563", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26626, 26627], leaf: 26625 }, + Case { id: "bettertls::nameconstraints::tc8564", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26629, 26630], leaf: 26628 }, + Case { id: "bettertls::nameconstraints::tc8565", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26632, 26633], leaf: 26631 }, + Case { id: "bettertls::nameconstraints::tc8566", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26635, 26636], leaf: 26634 }, + Case { id: "bettertls::nameconstraints::tc8567", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26638, 26639], leaf: 26637 }, + Case { id: "bettertls::nameconstraints::tc8568", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26641, 26642], leaf: 26640 }, + Case { id: "bettertls::nameconstraints::tc8569", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26644, 26645], leaf: 26643 }, + Case { id: "bettertls::nameconstraints::tc8570", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26647, 26648], leaf: 26646 }, + Case { id: "bettertls::nameconstraints::tc8571", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26650, 26651], leaf: 26649 }, + Case { id: "bettertls::nameconstraints::tc8572", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26653, 26654], leaf: 26652 }, + Case { id: "bettertls::nameconstraints::tc8573", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26656, 26657], leaf: 26655 }, + Case { id: "bettertls::nameconstraints::tc8574", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26659, 26660], leaf: 26658 }, + Case { id: "bettertls::nameconstraints::tc8575", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26662, 26663], leaf: 26661 }, + Case { id: "bettertls::nameconstraints::tc8576", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26665, 26666], leaf: 26664 }, + Case { id: "bettertls::nameconstraints::tc8577", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26668, 26669], leaf: 26667 }, + Case { id: "bettertls::nameconstraints::tc8578", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26671, 26672], leaf: 26670 }, + Case { id: "bettertls::nameconstraints::tc8579", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26674, 26675], leaf: 26673 }, + Case { id: "bettertls::nameconstraints::tc8580", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26677, 26678], leaf: 26676 }, + Case { id: "bettertls::nameconstraints::tc8581", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26680, 26681], leaf: 26679 }, + Case { id: "bettertls::nameconstraints::tc8582", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26683, 26684], leaf: 26682 }, + Case { id: "bettertls::nameconstraints::tc8583", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26686, 26687], leaf: 26685 }, + Case { id: "bettertls::nameconstraints::tc8584", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26689, 26690], leaf: 26688 }, + Case { id: "bettertls::nameconstraints::tc8585", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26692, 26693], leaf: 26691 }, + Case { id: "bettertls::nameconstraints::tc8586", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26695, 26696], leaf: 26694 }, + Case { id: "bettertls::nameconstraints::tc8587", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26698, 26699], leaf: 26697 }, + Case { id: "bettertls::nameconstraints::tc8588", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26701, 26702], leaf: 26700 }, + Case { id: "bettertls::nameconstraints::tc8589", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26704, 26705], leaf: 26703 }, + Case { id: "bettertls::nameconstraints::tc8590", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26707, 26708], leaf: 26706 }, + Case { id: "bettertls::nameconstraints::tc8591", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26710, 26711], leaf: 26709 }, + Case { id: "bettertls::nameconstraints::tc8592", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26713, 26714], leaf: 26712 }, + Case { id: "bettertls::nameconstraints::tc8593", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26716, 26717], leaf: 26715 }, + Case { id: "bettertls::nameconstraints::tc8594", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26719, 26720], leaf: 26718 }, + Case { id: "bettertls::nameconstraints::tc8595", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26722, 26723], leaf: 26721 }, + Case { id: "bettertls::nameconstraints::tc8596", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26725, 26726], leaf: 26724 }, + Case { id: "bettertls::nameconstraints::tc8597", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26728, 26729], leaf: 26727 }, + Case { id: "bettertls::nameconstraints::tc8598", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26731, 26732], leaf: 26730 }, + Case { id: "bettertls::nameconstraints::tc8599", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26734, 26735], leaf: 26733 }, + Case { id: "bettertls::nameconstraints::tc8600", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26737, 26738], leaf: 26736 }, + Case { id: "bettertls::nameconstraints::tc8601", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26740, 26741], leaf: 26739 }, + Case { id: "bettertls::nameconstraints::tc8602", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26743, 26744], leaf: 26742 }, + Case { id: "bettertls::nameconstraints::tc8603", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26746, 26747], leaf: 26745 }, + Case { id: "bettertls::nameconstraints::tc8604", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26749, 26750], leaf: 26748 }, + Case { id: "bettertls::nameconstraints::tc8605", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26752, 26753], leaf: 26751 }, + Case { id: "bettertls::nameconstraints::tc8606", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26755, 26756], leaf: 26754 }, + Case { id: "bettertls::nameconstraints::tc8607", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26758, 26759], leaf: 26757 }, + Case { id: "bettertls::nameconstraints::tc8608", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26761, 26762], leaf: 26760 }, + Case { id: "bettertls::nameconstraints::tc8609", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26764, 26765], leaf: 26763 }, + Case { id: "bettertls::nameconstraints::tc8610", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26767, 26768], leaf: 26766 }, + Case { id: "bettertls::nameconstraints::tc8611", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26770, 26771], leaf: 26769 }, + Case { id: "bettertls::nameconstraints::tc8612", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26773, 26774], leaf: 26772 }, + Case { id: "bettertls::nameconstraints::tc8613", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26776, 26777], leaf: 26775 }, + Case { id: "bettertls::nameconstraints::tc8614", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26779, 26780], leaf: 26778 }, + Case { id: "bettertls::nameconstraints::tc8615", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26782, 26783], leaf: 26781 }, + Case { id: "bettertls::nameconstraints::tc8616", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26785, 26786], leaf: 26784 }, + Case { id: "bettertls::nameconstraints::tc8617", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26788, 26789], leaf: 26787 }, + Case { id: "bettertls::nameconstraints::tc8618", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26791, 26792], leaf: 26790 }, + Case { id: "bettertls::nameconstraints::tc8619", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26794, 26795], leaf: 26793 }, + Case { id: "bettertls::nameconstraints::tc8620", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26797, 26798], leaf: 26796 }, + Case { id: "bettertls::nameconstraints::tc8621", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26800, 26801], leaf: 26799 }, + Case { id: "bettertls::nameconstraints::tc8622", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26803, 26804], leaf: 26802 }, + Case { id: "bettertls::nameconstraints::tc8623", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26806, 26807], leaf: 26805 }, + Case { id: "bettertls::nameconstraints::tc8624", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26809, 26810], leaf: 26808 }, + Case { id: "bettertls::nameconstraints::tc8625", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26812, 26813], leaf: 26811 }, + Case { id: "bettertls::nameconstraints::tc8626", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26815, 26816], leaf: 26814 }, + Case { id: "bettertls::nameconstraints::tc8627", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26818, 26819], leaf: 26817 }, + Case { id: "bettertls::nameconstraints::tc8628", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26821, 26822], leaf: 26820 }, + Case { id: "bettertls::nameconstraints::tc8629", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26824, 26825], leaf: 26823 }, + Case { id: "bettertls::nameconstraints::tc8630", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26827, 26828], leaf: 26826 }, + Case { id: "bettertls::nameconstraints::tc8631", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26830, 26831], leaf: 26829 }, + Case { id: "bettertls::nameconstraints::tc8632", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26833, 26834], leaf: 26832 }, + Case { id: "bettertls::nameconstraints::tc8633", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26836, 26837], leaf: 26835 }, + Case { id: "bettertls::nameconstraints::tc8634", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26839, 26840], leaf: 26838 }, + Case { id: "bettertls::nameconstraints::tc8635", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26842, 26843], leaf: 26841 }, + Case { id: "bettertls::nameconstraints::tc8636", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26845, 26846], leaf: 26844 }, + Case { id: "bettertls::nameconstraints::tc8637", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26848, 26849], leaf: 26847 }, + Case { id: "bettertls::nameconstraints::tc8638", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26851, 26852], leaf: 26850 }, + Case { id: "bettertls::nameconstraints::tc8639", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26854, 26855], leaf: 26853 }, + Case { id: "bettertls::nameconstraints::tc8640", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26857, 26858], leaf: 26856 }, + Case { id: "bettertls::nameconstraints::tc8641", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26860, 26861], leaf: 26859 }, + Case { id: "bettertls::nameconstraints::tc8642", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26863, 26864], leaf: 26862 }, + Case { id: "bettertls::nameconstraints::tc8643", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26866, 26867], leaf: 26865 }, + Case { id: "bettertls::nameconstraints::tc8644", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26869, 26870], leaf: 26868 }, + Case { id: "bettertls::nameconstraints::tc8645", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26872, 26873], leaf: 26871 }, + Case { id: "bettertls::nameconstraints::tc8646", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26875, 26876], leaf: 26874 }, + Case { id: "bettertls::nameconstraints::tc8647", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26878, 26879], leaf: 26877 }, + Case { id: "bettertls::nameconstraints::tc8648", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26881, 26882], leaf: 26880 }, + Case { id: "bettertls::nameconstraints::tc8649", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26884, 26885], leaf: 26883 }, + Case { id: "bettertls::nameconstraints::tc8650", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26887, 26888], leaf: 26886 }, + Case { id: "bettertls::nameconstraints::tc8651", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26890, 26891], leaf: 26889 }, + Case { id: "bettertls::nameconstraints::tc8652", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26893, 26894], leaf: 26892 }, + Case { id: "bettertls::nameconstraints::tc8653", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26896, 26897], leaf: 26895 }, + Case { id: "bettertls::nameconstraints::tc8654", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26899, 26900], leaf: 26898 }, + Case { id: "bettertls::nameconstraints::tc8655", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26902, 26903], leaf: 26901 }, + Case { id: "bettertls::nameconstraints::tc8656", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26905, 26906], leaf: 26904 }, + Case { id: "bettertls::nameconstraints::tc8657", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26908, 26909], leaf: 26907 }, + Case { id: "bettertls::nameconstraints::tc8658", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26911, 26912], leaf: 26910 }, + Case { id: "bettertls::nameconstraints::tc8659", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26914, 26915], leaf: 26913 }, + Case { id: "bettertls::nameconstraints::tc8660", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26917, 26918], leaf: 26916 }, + Case { id: "bettertls::nameconstraints::tc8661", kind: "SERVER", expected: "SUCCESS", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26920, 26921], leaf: 26919 }, + Case { id: "bettertls::nameconstraints::tc8662", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26923, 26924], leaf: 26922 }, + Case { id: "bettertls::nameconstraints::tc8663", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26926, 26927], leaf: 26925 }, + Case { id: "bettertls::nameconstraints::tc8664", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26929, 26930], leaf: 26928 }, + Case { id: "bettertls::nameconstraints::tc8665", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26932, 26933], leaf: 26931 }, + Case { id: "bettertls::nameconstraints::tc8666", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26935, 26936], leaf: 26934 }, + Case { id: "bettertls::nameconstraints::tc8667", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26938, 26939], leaf: 26937 }, + Case { id: "bettertls::nameconstraints::tc8668", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26941, 26942], leaf: 26940 }, + Case { id: "bettertls::nameconstraints::tc8669", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26944, 26945], leaf: 26943 }, + Case { id: "bettertls::nameconstraints::tc8670", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26947, 26948], leaf: 26946 }, + Case { id: "bettertls::nameconstraints::tc8671", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26950, 26951], leaf: 26949 }, + Case { id: "bettertls::nameconstraints::tc8672", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26953, 26954], leaf: 26952 }, + Case { id: "bettertls::nameconstraints::tc8673", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26956, 26957], leaf: 26955 }, + Case { id: "bettertls::nameconstraints::tc8674", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26959, 26960], leaf: 26958 }, + Case { id: "bettertls::nameconstraints::tc8675", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26962, 26963], leaf: 26961 }, + Case { id: "bettertls::nameconstraints::tc8676", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26965, 26966], leaf: 26964 }, + Case { id: "bettertls::nameconstraints::tc8677", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26968, 26969], leaf: 26967 }, + Case { id: "bettertls::nameconstraints::tc8678", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26971, 26972], leaf: 26970 }, + Case { id: "bettertls::nameconstraints::tc8679", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26974, 26975], leaf: 26973 }, + Case { id: "bettertls::nameconstraints::tc8680", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26977, 26978], leaf: 26976 }, + Case { id: "bettertls::nameconstraints::tc8681", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26980, 26981], leaf: 26979 }, + Case { id: "bettertls::nameconstraints::tc8682", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26983, 26984], leaf: 26982 }, + Case { id: "bettertls::nameconstraints::tc8683", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26986, 26987], leaf: 26985 }, + Case { id: "bettertls::nameconstraints::tc8684", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26989, 26990], leaf: 26988 }, + Case { id: "bettertls::nameconstraints::tc8685", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26992, 26993], leaf: 26991 }, + Case { id: "bettertls::nameconstraints::tc8686", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26995, 26996], leaf: 26994 }, + Case { id: "bettertls::nameconstraints::tc8687", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[26998, 26999], leaf: 26997 }, + Case { id: "bettertls::nameconstraints::tc8688", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27001, 27002], leaf: 27000 }, + Case { id: "bettertls::nameconstraints::tc8689", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27004, 27005], leaf: 27003 }, + Case { id: "bettertls::nameconstraints::tc8690", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27007, 27008], leaf: 27006 }, + Case { id: "bettertls::nameconstraints::tc8691", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27010, 27011], leaf: 27009 }, + Case { id: "bettertls::nameconstraints::tc8692", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27013, 27014], leaf: 27012 }, + Case { id: "bettertls::nameconstraints::tc8693", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27016, 27017], leaf: 27015 }, + Case { id: "bettertls::nameconstraints::tc8694", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27019, 27020], leaf: 27018 }, + Case { id: "bettertls::nameconstraints::tc8695", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27022, 27023], leaf: 27021 }, + Case { id: "bettertls::nameconstraints::tc8696", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27025, 27026], leaf: 27024 }, + Case { id: "bettertls::nameconstraints::tc8697", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27028, 27029], leaf: 27027 }, + Case { id: "bettertls::nameconstraints::tc8698", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27031, 27032], leaf: 27030 }, + Case { id: "bettertls::nameconstraints::tc8699", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27034, 27035], leaf: 27033 }, + Case { id: "bettertls::nameconstraints::tc8700", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27037, 27038], leaf: 27036 }, + Case { id: "bettertls::nameconstraints::tc8701", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27040, 27041], leaf: 27039 }, + Case { id: "bettertls::nameconstraints::tc8702", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27043, 27044], leaf: 27042 }, + Case { id: "bettertls::nameconstraints::tc8703", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27046, 27047], leaf: 27045 }, + Case { id: "bettertls::nameconstraints::tc8704", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27049, 27050], leaf: 27048 }, + Case { id: "bettertls::nameconstraints::tc8705", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27052, 27053], leaf: 27051 }, + Case { id: "bettertls::nameconstraints::tc8706", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27055, 27056], leaf: 27054 }, + Case { id: "bettertls::nameconstraints::tc8707", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27058, 27059], leaf: 27057 }, + Case { id: "bettertls::nameconstraints::tc8708", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27061, 27062], leaf: 27060 }, + Case { id: "bettertls::nameconstraints::tc8709", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27064, 27065], leaf: 27063 }, + Case { id: "bettertls::nameconstraints::tc8710", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27067, 27068], leaf: 27066 }, + Case { id: "bettertls::nameconstraints::tc8711", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27070, 27071], leaf: 27069 }, + Case { id: "bettertls::nameconstraints::tc8712", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27073, 27074], leaf: 27072 }, + Case { id: "bettertls::nameconstraints::tc8713", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27076, 27077], leaf: 27075 }, + Case { id: "bettertls::nameconstraints::tc8714", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27079, 27080], leaf: 27078 }, + Case { id: "bettertls::nameconstraints::tc8715", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27082, 27083], leaf: 27081 }, + Case { id: "bettertls::nameconstraints::tc8716", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27085, 27086], leaf: 27084 }, + Case { id: "bettertls::nameconstraints::tc8717", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27088, 27089], leaf: 27087 }, + Case { id: "bettertls::nameconstraints::tc8718", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27091, 27092], leaf: 27090 }, + Case { id: "bettertls::nameconstraints::tc8719", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27094, 27095], leaf: 27093 }, + Case { id: "bettertls::nameconstraints::tc8720", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27097, 27098], leaf: 27096 }, + Case { id: "bettertls::nameconstraints::tc8721", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27100, 27101], leaf: 27099 }, + Case { id: "bettertls::nameconstraints::tc8722", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27103, 27104], leaf: 27102 }, + Case { id: "bettertls::nameconstraints::tc8723", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27106, 27107], leaf: 27105 }, + Case { id: "bettertls::nameconstraints::tc8724", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27109, 27110], leaf: 27108 }, + Case { id: "bettertls::nameconstraints::tc8725", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27112, 27113], leaf: 27111 }, + Case { id: "bettertls::nameconstraints::tc8726", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27115, 27116], leaf: 27114 }, + Case { id: "bettertls::nameconstraints::tc8727", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27118, 27119], leaf: 27117 }, + Case { id: "bettertls::nameconstraints::tc8728", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:54+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27121, 27122], leaf: 27120 }, + Case { id: "bettertls::nameconstraints::tc8729", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27124, 27125], leaf: 27123 }, + Case { id: "bettertls::nameconstraints::tc8730", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27127, 27128], leaf: 27126 }, + Case { id: "bettertls::nameconstraints::tc8731", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27130, 27131], leaf: 27129 }, + Case { id: "bettertls::nameconstraints::tc8732", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27133, 27134], leaf: 27132 }, + Case { id: "bettertls::nameconstraints::tc8733", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27136, 27137], leaf: 27135 }, + Case { id: "bettertls::nameconstraints::tc8734", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27139, 27140], leaf: 27138 }, + Case { id: "bettertls::nameconstraints::tc8735", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27142, 27143], leaf: 27141 }, + Case { id: "bettertls::nameconstraints::tc8736", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27145, 27146], leaf: 27144 }, + Case { id: "bettertls::nameconstraints::tc8737", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27148, 27149], leaf: 27147 }, + Case { id: "bettertls::nameconstraints::tc8738", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27151, 27152], leaf: 27150 }, + Case { id: "bettertls::nameconstraints::tc8739", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27154, 27155], leaf: 27153 }, + Case { id: "bettertls::nameconstraints::tc8740", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27157, 27158], leaf: 27156 }, + Case { id: "bettertls::nameconstraints::tc8741", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27160, 27161], leaf: 27159 }, + Case { id: "bettertls::nameconstraints::tc8742", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27163, 27164], leaf: 27162 }, + Case { id: "bettertls::nameconstraints::tc8743", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27166, 27167], leaf: 27165 }, + Case { id: "bettertls::nameconstraints::tc8744", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27169, 27170], leaf: 27168 }, + Case { id: "bettertls::nameconstraints::tc8745", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27172, 27173], leaf: 27171 }, + Case { id: "bettertls::nameconstraints::tc8746", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27175, 27176], leaf: 27174 }, + Case { id: "bettertls::nameconstraints::tc8747", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27178, 27179], leaf: 27177 }, + Case { id: "bettertls::nameconstraints::tc8748", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27181, 27182], leaf: 27180 }, + Case { id: "bettertls::nameconstraints::tc8749", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27184, 27185], leaf: 27183 }, + Case { id: "bettertls::nameconstraints::tc8750", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27187, 27188], leaf: 27186 }, + Case { id: "bettertls::nameconstraints::tc8751", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27190, 27191], leaf: 27189 }, + Case { id: "bettertls::nameconstraints::tc8752", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27193, 27194], leaf: 27192 }, + Case { id: "bettertls::nameconstraints::tc8753", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27196, 27197], leaf: 27195 }, + Case { id: "bettertls::nameconstraints::tc8754", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27199, 27200], leaf: 27198 }, + Case { id: "bettertls::nameconstraints::tc8755", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27202, 27203], leaf: 27201 }, + Case { id: "bettertls::nameconstraints::tc8756", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27205, 27206], leaf: 27204 }, + Case { id: "bettertls::nameconstraints::tc8757", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27208, 27209], leaf: 27207 }, + Case { id: "bettertls::nameconstraints::tc8758", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27211, 27212], leaf: 27210 }, + Case { id: "bettertls::nameconstraints::tc8759", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27214, 27215], leaf: 27213 }, + Case { id: "bettertls::nameconstraints::tc8760", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27217, 27218], leaf: 27216 }, + Case { id: "bettertls::nameconstraints::tc8761", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27220, 27221], leaf: 27219 }, + Case { id: "bettertls::nameconstraints::tc8762", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27223, 27224], leaf: 27222 }, + Case { id: "bettertls::nameconstraints::tc8763", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27226, 27227], leaf: 27225 }, + Case { id: "bettertls::nameconstraints::tc8764", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27229, 27230], leaf: 27228 }, + Case { id: "bettertls::nameconstraints::tc8765", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27232, 27233], leaf: 27231 }, + Case { id: "bettertls::nameconstraints::tc8766", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27235, 27236], leaf: 27234 }, + Case { id: "bettertls::nameconstraints::tc8767", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27238, 27239], leaf: 27237 }, + Case { id: "bettertls::nameconstraints::tc8768", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27241, 27242], leaf: 27240 }, + Case { id: "bettertls::nameconstraints::tc8769", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27244, 27245], leaf: 27243 }, + Case { id: "bettertls::nameconstraints::tc8770", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27247, 27248], leaf: 27246 }, + Case { id: "bettertls::nameconstraints::tc8771", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27250, 27251], leaf: 27249 }, + Case { id: "bettertls::nameconstraints::tc8772", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27253, 27254], leaf: 27252 }, + Case { id: "bettertls::nameconstraints::tc8773", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27256, 27257], leaf: 27255 }, + Case { id: "bettertls::nameconstraints::tc8774", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27259, 27260], leaf: 27258 }, + Case { id: "bettertls::nameconstraints::tc8775", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27262, 27263], leaf: 27261 }, + Case { id: "bettertls::nameconstraints::tc8776", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27265, 27266], leaf: 27264 }, + Case { id: "bettertls::nameconstraints::tc8777", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27268, 27269], leaf: 27267 }, + Case { id: "bettertls::nameconstraints::tc8778", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27271, 27272], leaf: 27270 }, + Case { id: "bettertls::nameconstraints::tc8779", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27274, 27275], leaf: 27273 }, + Case { id: "bettertls::nameconstraints::tc8780", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27277, 27278], leaf: 27276 }, + Case { id: "bettertls::nameconstraints::tc8781", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27280, 27281], leaf: 27279 }, + Case { id: "bettertls::nameconstraints::tc8782", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27283, 27284], leaf: 27282 }, + Case { id: "bettertls::nameconstraints::tc8783", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27286, 27287], leaf: 27285 }, + Case { id: "bettertls::nameconstraints::tc8784", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27289, 27290], leaf: 27288 }, + Case { id: "bettertls::nameconstraints::tc8785", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27292, 27293], leaf: 27291 }, + Case { id: "bettertls::nameconstraints::tc8786", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27295, 27296], leaf: 27294 }, + Case { id: "bettertls::nameconstraints::tc8787", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27298, 27299], leaf: 27297 }, + Case { id: "bettertls::nameconstraints::tc8788", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27301, 27302], leaf: 27300 }, + Case { id: "bettertls::nameconstraints::tc8789", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27304, 27305], leaf: 27303 }, + Case { id: "bettertls::nameconstraints::tc8790", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27307, 27308], leaf: 27306 }, + Case { id: "bettertls::nameconstraints::tc8791", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27310, 27311], leaf: 27309 }, + Case { id: "bettertls::nameconstraints::tc8792", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27313, 27314], leaf: 27312 }, + Case { id: "bettertls::nameconstraints::tc8793", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27316, 27317], leaf: 27315 }, + Case { id: "bettertls::nameconstraints::tc8794", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27319, 27320], leaf: 27318 }, + Case { id: "bettertls::nameconstraints::tc8795", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27322, 27323], leaf: 27321 }, + Case { id: "bettertls::nameconstraints::tc8796", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27325, 27326], leaf: 27324 }, + Case { id: "bettertls::nameconstraints::tc8797", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27328, 27329], leaf: 27327 }, + Case { id: "bettertls::nameconstraints::tc8798", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27331, 27332], leaf: 27330 }, + Case { id: "bettertls::nameconstraints::tc8799", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27334, 27335], leaf: 27333 }, + Case { id: "bettertls::nameconstraints::tc8800", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27337, 27338], leaf: 27336 }, + Case { id: "bettertls::nameconstraints::tc8801", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27340, 27341], leaf: 27339 }, + Case { id: "bettertls::nameconstraints::tc8802", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27343, 27344], leaf: 27342 }, + Case { id: "bettertls::nameconstraints::tc8803", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27346, 27347], leaf: 27345 }, + Case { id: "bettertls::nameconstraints::tc8804", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27349, 27350], leaf: 27348 }, + Case { id: "bettertls::nameconstraints::tc8805", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27352, 27353], leaf: 27351 }, + Case { id: "bettertls::nameconstraints::tc8806", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27355, 27356], leaf: 27354 }, + Case { id: "bettertls::nameconstraints::tc8807", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27358, 27359], leaf: 27357 }, + Case { id: "bettertls::nameconstraints::tc8808", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27361, 27362], leaf: 27360 }, + Case { id: "bettertls::nameconstraints::tc8809", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27364, 27365], leaf: 27363 }, + Case { id: "bettertls::nameconstraints::tc8810", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27367, 27368], leaf: 27366 }, + Case { id: "bettertls::nameconstraints::tc8811", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27370, 27371], leaf: 27369 }, + Case { id: "bettertls::nameconstraints::tc8812", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27373, 27374], leaf: 27372 }, + Case { id: "bettertls::nameconstraints::tc8813", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27376, 27377], leaf: 27375 }, + Case { id: "bettertls::nameconstraints::tc8814", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27379, 27380], leaf: 27378 }, + Case { id: "bettertls::nameconstraints::tc8815", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27382, 27383], leaf: 27381 }, + Case { id: "bettertls::nameconstraints::tc8816", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27385, 27386], leaf: 27384 }, + Case { id: "bettertls::nameconstraints::tc8817", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27388, 27389], leaf: 27387 }, + Case { id: "bettertls::nameconstraints::tc8818", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27391, 27392], leaf: 27390 }, + Case { id: "bettertls::nameconstraints::tc8819", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27394, 27395], leaf: 27393 }, + Case { id: "bettertls::nameconstraints::tc8820", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27397, 27398], leaf: 27396 }, + Case { id: "bettertls::nameconstraints::tc8821", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27400, 27401], leaf: 27399 }, + Case { id: "bettertls::nameconstraints::tc8822", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27403, 27404], leaf: 27402 }, + Case { id: "bettertls::nameconstraints::tc8823", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27406, 27407], leaf: 27405 }, + Case { id: "bettertls::nameconstraints::tc8824", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27409, 27410], leaf: 27408 }, + Case { id: "bettertls::nameconstraints::tc8825", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27412, 27413], leaf: 27411 }, + Case { id: "bettertls::nameconstraints::tc8826", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27415, 27416], leaf: 27414 }, + Case { id: "bettertls::nameconstraints::tc8827", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27418, 27419], leaf: 27417 }, + Case { id: "bettertls::nameconstraints::tc8828", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27421, 27422], leaf: 27420 }, + Case { id: "bettertls::nameconstraints::tc8829", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27424, 27425], leaf: 27423 }, + Case { id: "bettertls::nameconstraints::tc8830", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27427, 27428], leaf: 27426 }, + Case { id: "bettertls::nameconstraints::tc8831", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27430, 27431], leaf: 27429 }, + Case { id: "bettertls::nameconstraints::tc8832", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27433, 27434], leaf: 27432 }, + Case { id: "bettertls::nameconstraints::tc8833", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27436, 27437], leaf: 27435 }, + Case { id: "bettertls::nameconstraints::tc8834", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27439, 27440], leaf: 27438 }, + Case { id: "bettertls::nameconstraints::tc8835", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27442, 27443], leaf: 27441 }, + Case { id: "bettertls::nameconstraints::tc8836", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27445, 27446], leaf: 27444 }, + Case { id: "bettertls::nameconstraints::tc8837", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27448, 27449], leaf: 27447 }, + Case { id: "bettertls::nameconstraints::tc8838", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27451, 27452], leaf: 27450 }, + Case { id: "bettertls::nameconstraints::tc8839", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27454, 27455], leaf: 27453 }, + Case { id: "bettertls::nameconstraints::tc8840", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27457, 27458], leaf: 27456 }, + Case { id: "bettertls::nameconstraints::tc8841", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27460, 27461], leaf: 27459 }, + Case { id: "bettertls::nameconstraints::tc8842", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27463, 27464], leaf: 27462 }, + Case { id: "bettertls::nameconstraints::tc8843", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27466, 27467], leaf: 27465 }, + Case { id: "bettertls::nameconstraints::tc8844", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27469, 27470], leaf: 27468 }, + Case { id: "bettertls::nameconstraints::tc8845", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27472, 27473], leaf: 27471 }, + Case { id: "bettertls::nameconstraints::tc8846", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27475, 27476], leaf: 27474 }, + Case { id: "bettertls::nameconstraints::tc8847", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27478, 27479], leaf: 27477 }, + Case { id: "bettertls::nameconstraints::tc8848", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27481, 27482], leaf: 27480 }, + Case { id: "bettertls::nameconstraints::tc8849", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27484, 27485], leaf: 27483 }, + Case { id: "bettertls::nameconstraints::tc8850", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27487, 27488], leaf: 27486 }, + Case { id: "bettertls::nameconstraints::tc8851", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27490, 27491], leaf: 27489 }, + Case { id: "bettertls::nameconstraints::tc8852", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27493, 27494], leaf: 27492 }, + Case { id: "bettertls::nameconstraints::tc8853", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27496, 27497], leaf: 27495 }, + Case { id: "bettertls::nameconstraints::tc8854", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27499, 27500], leaf: 27498 }, + Case { id: "bettertls::nameconstraints::tc8855", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27502, 27503], leaf: 27501 }, + Case { id: "bettertls::nameconstraints::tc8856", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27505, 27506], leaf: 27504 }, + Case { id: "bettertls::nameconstraints::tc8857", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27508, 27509], leaf: 27507 }, + Case { id: "bettertls::nameconstraints::tc8858", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27511, 27512], leaf: 27510 }, + Case { id: "bettertls::nameconstraints::tc8859", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27514, 27515], leaf: 27513 }, + Case { id: "bettertls::nameconstraints::tc8860", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27517, 27518], leaf: 27516 }, + Case { id: "bettertls::nameconstraints::tc8861", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27520, 27521], leaf: 27519 }, + Case { id: "bettertls::nameconstraints::tc8862", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27523, 27524], leaf: 27522 }, + Case { id: "bettertls::nameconstraints::tc8863", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27526, 27527], leaf: 27525 }, + Case { id: "bettertls::nameconstraints::tc8864", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27529, 27530], leaf: 27528 }, + Case { id: "bettertls::nameconstraints::tc8865", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27532, 27533], leaf: 27531 }, + Case { id: "bettertls::nameconstraints::tc8866", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27535, 27536], leaf: 27534 }, + Case { id: "bettertls::nameconstraints::tc8867", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27538, 27539], leaf: 27537 }, + Case { id: "bettertls::nameconstraints::tc8868", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27541, 27542], leaf: 27540 }, + Case { id: "bettertls::nameconstraints::tc8869", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27544, 27545], leaf: 27543 }, + Case { id: "bettertls::nameconstraints::tc8870", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27547, 27548], leaf: 27546 }, + Case { id: "bettertls::nameconstraints::tc8871", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27550, 27551], leaf: 27549 }, + Case { id: "bettertls::nameconstraints::tc8872", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27553, 27554], leaf: 27552 }, + Case { id: "bettertls::nameconstraints::tc8873", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27556, 27557], leaf: 27555 }, + Case { id: "bettertls::nameconstraints::tc8874", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27559, 27560], leaf: 27558 }, + Case { id: "bettertls::nameconstraints::tc8875", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27562, 27563], leaf: 27561 }, + Case { id: "bettertls::nameconstraints::tc8876", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27565, 27566], leaf: 27564 }, + Case { id: "bettertls::nameconstraints::tc8877", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27568, 27569], leaf: 27567 }, + Case { id: "bettertls::nameconstraints::tc8878", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27571, 27572], leaf: 27570 }, + Case { id: "bettertls::nameconstraints::tc8879", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27574, 27575], leaf: 27573 }, + Case { id: "bettertls::nameconstraints::tc8880", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27577, 27578], leaf: 27576 }, + Case { id: "bettertls::nameconstraints::tc8881", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27580, 27581], leaf: 27579 }, + Case { id: "bettertls::nameconstraints::tc8882", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27583, 27584], leaf: 27582 }, + Case { id: "bettertls::nameconstraints::tc8883", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27586, 27587], leaf: 27585 }, + Case { id: "bettertls::nameconstraints::tc8884", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27589, 27590], leaf: 27588 }, + Case { id: "bettertls::nameconstraints::tc8885", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27592, 27593], leaf: 27591 }, + Case { id: "bettertls::nameconstraints::tc8886", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27595, 27596], leaf: 27594 }, + Case { id: "bettertls::nameconstraints::tc8887", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27598, 27599], leaf: 27597 }, + Case { id: "bettertls::nameconstraints::tc8888", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27601, 27602], leaf: 27600 }, + Case { id: "bettertls::nameconstraints::tc8889", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27604, 27605], leaf: 27603 }, + Case { id: "bettertls::nameconstraints::tc8890", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27607, 27608], leaf: 27606 }, + Case { id: "bettertls::nameconstraints::tc8891", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27610, 27611], leaf: 27609 }, + Case { id: "bettertls::nameconstraints::tc8892", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27613, 27614], leaf: 27612 }, + Case { id: "bettertls::nameconstraints::tc8893", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27616, 27617], leaf: 27615 }, + Case { id: "bettertls::nameconstraints::tc8894", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27619, 27620], leaf: 27618 }, + Case { id: "bettertls::nameconstraints::tc8895", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27622, 27623], leaf: 27621 }, + Case { id: "bettertls::nameconstraints::tc8896", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27625, 27626], leaf: 27624 }, + Case { id: "bettertls::nameconstraints::tc8897", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27628, 27629], leaf: 27627 }, + Case { id: "bettertls::nameconstraints::tc8898", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27631, 27632], leaf: 27630 }, + Case { id: "bettertls::nameconstraints::tc8899", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27634, 27635], leaf: 27633 }, + Case { id: "bettertls::nameconstraints::tc8900", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27637, 27638], leaf: 27636 }, + Case { id: "bettertls::nameconstraints::tc8901", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27640, 27641], leaf: 27639 }, + Case { id: "bettertls::nameconstraints::tc8902", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27643, 27644], leaf: 27642 }, + Case { id: "bettertls::nameconstraints::tc8903", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27646, 27647], leaf: 27645 }, + Case { id: "bettertls::nameconstraints::tc8904", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27649, 27650], leaf: 27648 }, + Case { id: "bettertls::nameconstraints::tc8905", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27652, 27653], leaf: 27651 }, + Case { id: "bettertls::nameconstraints::tc8906", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27655, 27656], leaf: 27654 }, + Case { id: "bettertls::nameconstraints::tc8907", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27658, 27659], leaf: 27657 }, + Case { id: "bettertls::nameconstraints::tc8908", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27661, 27662], leaf: 27660 }, + Case { id: "bettertls::nameconstraints::tc8909", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27664, 27665], leaf: 27663 }, + Case { id: "bettertls::nameconstraints::tc8910", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27667, 27668], leaf: 27666 }, + Case { id: "bettertls::nameconstraints::tc8911", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27670, 27671], leaf: 27669 }, + Case { id: "bettertls::nameconstraints::tc8912", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27673, 27674], leaf: 27672 }, + Case { id: "bettertls::nameconstraints::tc8913", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27676, 27677], leaf: 27675 }, + Case { id: "bettertls::nameconstraints::tc8914", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27679, 27680], leaf: 27678 }, + Case { id: "bettertls::nameconstraints::tc8915", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27682, 27683], leaf: 27681 }, + Case { id: "bettertls::nameconstraints::tc8916", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27685, 27686], leaf: 27684 }, + Case { id: "bettertls::nameconstraints::tc8917", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27688, 27689], leaf: 27687 }, + Case { id: "bettertls::nameconstraints::tc8918", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27691, 27692], leaf: 27690 }, + Case { id: "bettertls::nameconstraints::tc8919", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27694, 27695], leaf: 27693 }, + Case { id: "bettertls::nameconstraints::tc8920", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27697, 27698], leaf: 27696 }, + Case { id: "bettertls::nameconstraints::tc8921", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27700, 27701], leaf: 27699 }, + Case { id: "bettertls::nameconstraints::tc8922", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27703, 27704], leaf: 27702 }, + Case { id: "bettertls::nameconstraints::tc8923", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27706, 27707], leaf: 27705 }, + Case { id: "bettertls::nameconstraints::tc8924", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27709, 27710], leaf: 27708 }, + Case { id: "bettertls::nameconstraints::tc8925", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27712, 27713], leaf: 27711 }, + Case { id: "bettertls::nameconstraints::tc8926", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27715, 27716], leaf: 27714 }, + Case { id: "bettertls::nameconstraints::tc8927", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27718, 27719], leaf: 27717 }, + Case { id: "bettertls::nameconstraints::tc8928", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27721, 27722], leaf: 27720 }, + Case { id: "bettertls::nameconstraints::tc8929", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27724, 27725], leaf: 27723 }, + Case { id: "bettertls::nameconstraints::tc8930", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27727, 27728], leaf: 27726 }, + Case { id: "bettertls::nameconstraints::tc8931", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27730, 27731], leaf: 27729 }, + Case { id: "bettertls::nameconstraints::tc8932", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27733, 27734], leaf: 27732 }, + Case { id: "bettertls::nameconstraints::tc8933", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27736, 27737], leaf: 27735 }, + Case { id: "bettertls::nameconstraints::tc8934", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27739, 27740], leaf: 27738 }, + Case { id: "bettertls::nameconstraints::tc8935", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27742, 27743], leaf: 27741 }, + Case { id: "bettertls::nameconstraints::tc8936", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27745, 27746], leaf: 27744 }, + Case { id: "bettertls::nameconstraints::tc8937", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27748, 27749], leaf: 27747 }, + Case { id: "bettertls::nameconstraints::tc8938", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27751, 27752], leaf: 27750 }, + Case { id: "bettertls::nameconstraints::tc8939", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27754, 27755], leaf: 27753 }, + Case { id: "bettertls::nameconstraints::tc8940", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27757, 27758], leaf: 27756 }, + Case { id: "bettertls::nameconstraints::tc8941", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27760, 27761], leaf: 27759 }, + Case { id: "bettertls::nameconstraints::tc8942", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27763, 27764], leaf: 27762 }, + Case { id: "bettertls::nameconstraints::tc8943", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27766, 27767], leaf: 27765 }, + Case { id: "bettertls::nameconstraints::tc8944", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27769, 27770], leaf: 27768 }, + Case { id: "bettertls::nameconstraints::tc8945", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27772, 27773], leaf: 27771 }, + Case { id: "bettertls::nameconstraints::tc8946", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27775, 27776], leaf: 27774 }, + Case { id: "bettertls::nameconstraints::tc8947", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27778, 27779], leaf: 27777 }, + Case { id: "bettertls::nameconstraints::tc8948", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27781, 27782], leaf: 27780 }, + Case { id: "bettertls::nameconstraints::tc8949", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27784, 27785], leaf: 27783 }, + Case { id: "bettertls::nameconstraints::tc8950", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27787, 27788], leaf: 27786 }, + Case { id: "bettertls::nameconstraints::tc8951", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27790, 27791], leaf: 27789 }, + Case { id: "bettertls::nameconstraints::tc8952", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27793, 27794], leaf: 27792 }, + Case { id: "bettertls::nameconstraints::tc8953", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27796, 27797], leaf: 27795 }, + Case { id: "bettertls::nameconstraints::tc8954", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27799, 27800], leaf: 27798 }, + Case { id: "bettertls::nameconstraints::tc8955", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27802, 27803], leaf: 27801 }, + Case { id: "bettertls::nameconstraints::tc8956", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27805, 27806], leaf: 27804 }, + Case { id: "bettertls::nameconstraints::tc8957", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27808, 27809], leaf: 27807 }, + Case { id: "bettertls::nameconstraints::tc8958", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27811, 27812], leaf: 27810 }, + Case { id: "bettertls::nameconstraints::tc8959", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27814, 27815], leaf: 27813 }, + Case { id: "bettertls::nameconstraints::tc8960", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27817, 27818], leaf: 27816 }, + Case { id: "bettertls::nameconstraints::tc8961", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27820, 27821], leaf: 27819 }, + Case { id: "bettertls::nameconstraints::tc8962", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27823, 27824], leaf: 27822 }, + Case { id: "bettertls::nameconstraints::tc8963", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27826, 27827], leaf: 27825 }, + Case { id: "bettertls::nameconstraints::tc8964", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27829, 27830], leaf: 27828 }, + Case { id: "bettertls::nameconstraints::tc8965", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27832, 27833], leaf: 27831 }, + Case { id: "bettertls::nameconstraints::tc8966", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27835, 27836], leaf: 27834 }, + Case { id: "bettertls::nameconstraints::tc8967", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27838, 27839], leaf: 27837 }, + Case { id: "bettertls::nameconstraints::tc8968", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27841, 27842], leaf: 27840 }, + Case { id: "bettertls::nameconstraints::tc8969", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27844, 27845], leaf: 27843 }, + Case { id: "bettertls::nameconstraints::tc8970", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27847, 27848], leaf: 27846 }, + Case { id: "bettertls::nameconstraints::tc8971", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27850, 27851], leaf: 27849 }, + Case { id: "bettertls::nameconstraints::tc8972", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27853, 27854], leaf: 27852 }, + Case { id: "bettertls::nameconstraints::tc8973", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27856, 27857], leaf: 27855 }, + Case { id: "bettertls::nameconstraints::tc8974", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27859, 27860], leaf: 27858 }, + Case { id: "bettertls::nameconstraints::tc8975", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27862, 27863], leaf: 27861 }, + Case { id: "bettertls::nameconstraints::tc8976", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27865, 27866], leaf: 27864 }, + Case { id: "bettertls::nameconstraints::tc8977", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27868, 27869], leaf: 27867 }, + Case { id: "bettertls::nameconstraints::tc8978", kind: "SERVER", expected: "FAILURE", peer: ("IP", "127.0.0.1"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27871, 27872], leaf: 27870 }, + Case { id: "bettertls::nameconstraints::tc8979", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27874, 27875], leaf: 27873 }, + Case { id: "bettertls::nameconstraints::tc8980", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27877, 27878], leaf: 27876 }, + Case { id: "bettertls::nameconstraints::tc8981", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27880, 27881], leaf: 27879 }, + Case { id: "bettertls::nameconstraints::tc8982", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27883, 27884], leaf: 27882 }, + Case { id: "bettertls::nameconstraints::tc8983", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27886, 27887], leaf: 27885 }, + Case { id: "bettertls::nameconstraints::tc8984", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27889, 27890], leaf: 27888 }, + Case { id: "bettertls::nameconstraints::tc8985", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27892, 27893], leaf: 27891 }, + Case { id: "bettertls::nameconstraints::tc8986", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27895, 27896], leaf: 27894 }, + Case { id: "bettertls::nameconstraints::tc8987", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27898, 27899], leaf: 27897 }, + Case { id: "bettertls::nameconstraints::tc8988", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27901, 27902], leaf: 27900 }, + Case { id: "bettertls::nameconstraints::tc8989", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27904, 27905], leaf: 27903 }, + Case { id: "bettertls::nameconstraints::tc8990", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27907, 27908], leaf: 27906 }, + Case { id: "bettertls::nameconstraints::tc8991", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27910, 27911], leaf: 27909 }, + Case { id: "bettertls::nameconstraints::tc8992", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27913, 27914], leaf: 27912 }, + Case { id: "bettertls::nameconstraints::tc8993", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27916, 27917], leaf: 27915 }, + Case { id: "bettertls::nameconstraints::tc8994", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27919, 27920], leaf: 27918 }, + Case { id: "bettertls::nameconstraints::tc8995", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27922, 27923], leaf: 27921 }, + Case { id: "bettertls::nameconstraints::tc8996", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27925, 27926], leaf: 27924 }, + Case { id: "bettertls::nameconstraints::tc8997", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27928, 27929], leaf: 27927 }, + Case { id: "bettertls::nameconstraints::tc8998", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27931, 27932], leaf: 27930 }, + Case { id: "bettertls::nameconstraints::tc8999", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27934, 27935], leaf: 27933 }, + Case { id: "bettertls::nameconstraints::tc9000", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27937, 27938], leaf: 27936 }, + Case { id: "bettertls::nameconstraints::tc9001", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27940, 27941], leaf: 27939 }, + Case { id: "bettertls::nameconstraints::tc9002", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27943, 27944], leaf: 27942 }, + Case { id: "bettertls::nameconstraints::tc9003", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27946, 27947], leaf: 27945 }, + Case { id: "bettertls::nameconstraints::tc9004", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27949, 27950], leaf: 27948 }, + Case { id: "bettertls::nameconstraints::tc9005", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27952, 27953], leaf: 27951 }, + Case { id: "bettertls::nameconstraints::tc9006", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27955, 27956], leaf: 27954 }, + Case { id: "bettertls::nameconstraints::tc9007", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27958, 27959], leaf: 27957 }, + Case { id: "bettertls::nameconstraints::tc9008", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27961, 27962], leaf: 27960 }, + Case { id: "bettertls::nameconstraints::tc9009", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27964, 27965], leaf: 27963 }, + Case { id: "bettertls::nameconstraints::tc9010", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27967, 27968], leaf: 27966 }, + Case { id: "bettertls::nameconstraints::tc9011", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27970, 27971], leaf: 27969 }, + Case { id: "bettertls::nameconstraints::tc9012", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27973, 27974], leaf: 27972 }, + Case { id: "bettertls::nameconstraints::tc9013", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27976, 27977], leaf: 27975 }, + Case { id: "bettertls::nameconstraints::tc9014", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27979, 27980], leaf: 27978 }, + Case { id: "bettertls::nameconstraints::tc9015", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27982, 27983], leaf: 27981 }, + Case { id: "bettertls::nameconstraints::tc9016", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27985, 27986], leaf: 27984 }, + Case { id: "bettertls::nameconstraints::tc9017", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27988, 27989], leaf: 27987 }, + Case { id: "bettertls::nameconstraints::tc9018", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27991, 27992], leaf: 27990 }, + Case { id: "bettertls::nameconstraints::tc9019", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27994, 27995], leaf: 27993 }, + Case { id: "bettertls::nameconstraints::tc9020", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[27997, 27998], leaf: 27996 }, + Case { id: "bettertls::nameconstraints::tc9021", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28000, 28001], leaf: 27999 }, + Case { id: "bettertls::nameconstraints::tc9022", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28003, 28004], leaf: 28002 }, + Case { id: "bettertls::nameconstraints::tc9023", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28006, 28007], leaf: 28005 }, + Case { id: "bettertls::nameconstraints::tc9024", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28009, 28010], leaf: 28008 }, + Case { id: "bettertls::nameconstraints::tc9025", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28012, 28013], leaf: 28011 }, + Case { id: "bettertls::nameconstraints::tc9026", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28015, 28016], leaf: 28014 }, + Case { id: "bettertls::nameconstraints::tc9027", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28018, 28019], leaf: 28017 }, + Case { id: "bettertls::nameconstraints::tc9028", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28021, 28022], leaf: 28020 }, + Case { id: "bettertls::nameconstraints::tc9029", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28024, 28025], leaf: 28023 }, + Case { id: "bettertls::nameconstraints::tc9030", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28027, 28028], leaf: 28026 }, + Case { id: "bettertls::nameconstraints::tc9031", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28030, 28031], leaf: 28029 }, + Case { id: "bettertls::nameconstraints::tc9032", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28033, 28034], leaf: 28032 }, + Case { id: "bettertls::nameconstraints::tc9033", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28036, 28037], leaf: 28035 }, + Case { id: "bettertls::nameconstraints::tc9034", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28039, 28040], leaf: 28038 }, + Case { id: "bettertls::nameconstraints::tc9035", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28042, 28043], leaf: 28041 }, + Case { id: "bettertls::nameconstraints::tc9036", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28045, 28046], leaf: 28044 }, + Case { id: "bettertls::nameconstraints::tc9037", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28048, 28049], leaf: 28047 }, + Case { id: "bettertls::nameconstraints::tc9038", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28051, 28052], leaf: 28050 }, + Case { id: "bettertls::nameconstraints::tc9039", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28054, 28055], leaf: 28053 }, + Case { id: "bettertls::nameconstraints::tc9040", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28057, 28058], leaf: 28056 }, + Case { id: "bettertls::nameconstraints::tc9041", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28060, 28061], leaf: 28059 }, + Case { id: "bettertls::nameconstraints::tc9042", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28063, 28064], leaf: 28062 }, + Case { id: "bettertls::nameconstraints::tc9043", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28066, 28067], leaf: 28065 }, + Case { id: "bettertls::nameconstraints::tc9044", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28069, 28070], leaf: 28068 }, + Case { id: "bettertls::nameconstraints::tc9045", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28072, 28073], leaf: 28071 }, + Case { id: "bettertls::nameconstraints::tc9046", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28075, 28076], leaf: 28074 }, + Case { id: "bettertls::nameconstraints::tc9047", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28078, 28079], leaf: 28077 }, + Case { id: "bettertls::nameconstraints::tc9048", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28081, 28082], leaf: 28080 }, + Case { id: "bettertls::nameconstraints::tc9049", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28084, 28085], leaf: 28083 }, + Case { id: "bettertls::nameconstraints::tc9050", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28087, 28088], leaf: 28086 }, + Case { id: "bettertls::nameconstraints::tc9051", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28090, 28091], leaf: 28089 }, + Case { id: "bettertls::nameconstraints::tc9052", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28093, 28094], leaf: 28092 }, + Case { id: "bettertls::nameconstraints::tc9053", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28096, 28097], leaf: 28095 }, + Case { id: "bettertls::nameconstraints::tc9054", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28099, 28100], leaf: 28098 }, + Case { id: "bettertls::nameconstraints::tc9055", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28102, 28103], leaf: 28101 }, + Case { id: "bettertls::nameconstraints::tc9056", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28105, 28106], leaf: 28104 }, + Case { id: "bettertls::nameconstraints::tc9057", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28108, 28109], leaf: 28107 }, + Case { id: "bettertls::nameconstraints::tc9058", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28111, 28112], leaf: 28110 }, + Case { id: "bettertls::nameconstraints::tc9059", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28114, 28115], leaf: 28113 }, + Case { id: "bettertls::nameconstraints::tc9060", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28117, 28118], leaf: 28116 }, + Case { id: "bettertls::nameconstraints::tc9061", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28120, 28121], leaf: 28119 }, + Case { id: "bettertls::nameconstraints::tc9062", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28123, 28124], leaf: 28122 }, + Case { id: "bettertls::nameconstraints::tc9063", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28126, 28127], leaf: 28125 }, + Case { id: "bettertls::nameconstraints::tc9064", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28129, 28130], leaf: 28128 }, + Case { id: "bettertls::nameconstraints::tc9065", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28132, 28133], leaf: 28131 }, + Case { id: "bettertls::nameconstraints::tc9066", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28135, 28136], leaf: 28134 }, + Case { id: "bettertls::nameconstraints::tc9067", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28138, 28139], leaf: 28137 }, + Case { id: "bettertls::nameconstraints::tc9068", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28141, 28142], leaf: 28140 }, + Case { id: "bettertls::nameconstraints::tc9069", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28144, 28145], leaf: 28143 }, + Case { id: "bettertls::nameconstraints::tc9070", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28147, 28148], leaf: 28146 }, + Case { id: "bettertls::nameconstraints::tc9071", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28150, 28151], leaf: 28149 }, + Case { id: "bettertls::nameconstraints::tc9072", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28153, 28154], leaf: 28152 }, + Case { id: "bettertls::nameconstraints::tc9073", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28156, 28157], leaf: 28155 }, + Case { id: "bettertls::nameconstraints::tc9074", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28159, 28160], leaf: 28158 }, + Case { id: "bettertls::nameconstraints::tc9075", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28162, 28163], leaf: 28161 }, + Case { id: "bettertls::nameconstraints::tc9076", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28165, 28166], leaf: 28164 }, + Case { id: "bettertls::nameconstraints::tc9077", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28168, 28169], leaf: 28167 }, + Case { id: "bettertls::nameconstraints::tc9078", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28171, 28172], leaf: 28170 }, + Case { id: "bettertls::nameconstraints::tc9079", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28174, 28175], leaf: 28173 }, + Case { id: "bettertls::nameconstraints::tc9080", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28177, 28178], leaf: 28176 }, + Case { id: "bettertls::nameconstraints::tc9081", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28180, 28181], leaf: 28179 }, + Case { id: "bettertls::nameconstraints::tc9082", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28183, 28184], leaf: 28182 }, + Case { id: "bettertls::nameconstraints::tc9083", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28186, 28187], leaf: 28185 }, + Case { id: "bettertls::nameconstraints::tc9084", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28189, 28190], leaf: 28188 }, + Case { id: "bettertls::nameconstraints::tc9085", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28192, 28193], leaf: 28191 }, + Case { id: "bettertls::nameconstraints::tc9086", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28195, 28196], leaf: 28194 }, + Case { id: "bettertls::nameconstraints::tc9087", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28198, 28199], leaf: 28197 }, + Case { id: "bettertls::nameconstraints::tc9088", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28201, 28202], leaf: 28200 }, + Case { id: "bettertls::nameconstraints::tc9089", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28204, 28205], leaf: 28203 }, + Case { id: "bettertls::nameconstraints::tc9090", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28207, 28208], leaf: 28206 }, + Case { id: "bettertls::nameconstraints::tc9091", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28210, 28211], leaf: 28209 }, + Case { id: "bettertls::nameconstraints::tc9092", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28213, 28214], leaf: 28212 }, + Case { id: "bettertls::nameconstraints::tc9093", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28216, 28217], leaf: 28215 }, + Case { id: "bettertls::nameconstraints::tc9094", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28219, 28220], leaf: 28218 }, + Case { id: "bettertls::nameconstraints::tc9095", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28222, 28223], leaf: 28221 }, + Case { id: "bettertls::nameconstraints::tc9096", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28225, 28226], leaf: 28224 }, + Case { id: "bettertls::nameconstraints::tc9097", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28228, 28229], leaf: 28227 }, + Case { id: "bettertls::nameconstraints::tc9098", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28231, 28232], leaf: 28230 }, + Case { id: "bettertls::nameconstraints::tc9099", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28234, 28235], leaf: 28233 }, + Case { id: "bettertls::nameconstraints::tc9100", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28237, 28238], leaf: 28236 }, + Case { id: "bettertls::nameconstraints::tc9101", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28240, 28241], leaf: 28239 }, + Case { id: "bettertls::nameconstraints::tc9102", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28243, 28244], leaf: 28242 }, + Case { id: "bettertls::nameconstraints::tc9103", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28246, 28247], leaf: 28245 }, + Case { id: "bettertls::nameconstraints::tc9104", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28249, 28250], leaf: 28248 }, + Case { id: "bettertls::nameconstraints::tc9105", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28252, 28253], leaf: 28251 }, + Case { id: "bettertls::nameconstraints::tc9106", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28255, 28256], leaf: 28254 }, + Case { id: "bettertls::nameconstraints::tc9107", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28258, 28259], leaf: 28257 }, + Case { id: "bettertls::nameconstraints::tc9108", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28261, 28262], leaf: 28260 }, + Case { id: "bettertls::nameconstraints::tc9109", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28264, 28265], leaf: 28263 }, + Case { id: "bettertls::nameconstraints::tc9110", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28267, 28268], leaf: 28266 }, + Case { id: "bettertls::nameconstraints::tc9111", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28270, 28271], leaf: 28269 }, + Case { id: "bettertls::nameconstraints::tc9112", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28273, 28274], leaf: 28272 }, + Case { id: "bettertls::nameconstraints::tc9113", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28276, 28277], leaf: 28275 }, + Case { id: "bettertls::nameconstraints::tc9114", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28279, 28280], leaf: 28278 }, + Case { id: "bettertls::nameconstraints::tc9115", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28282, 28283], leaf: 28281 }, + Case { id: "bettertls::nameconstraints::tc9116", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28285, 28286], leaf: 28284 }, + Case { id: "bettertls::nameconstraints::tc9117", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28288, 28289], leaf: 28287 }, + Case { id: "bettertls::nameconstraints::tc9118", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28291, 28292], leaf: 28290 }, + Case { id: "bettertls::nameconstraints::tc9119", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28294, 28295], leaf: 28293 }, + Case { id: "bettertls::nameconstraints::tc9120", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28297, 28298], leaf: 28296 }, + Case { id: "bettertls::nameconstraints::tc9121", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28300, 28301], leaf: 28299 }, + Case { id: "bettertls::nameconstraints::tc9122", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28303, 28304], leaf: 28302 }, + Case { id: "bettertls::nameconstraints::tc9123", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28306, 28307], leaf: 28305 }, + Case { id: "bettertls::nameconstraints::tc9124", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28309, 28310], leaf: 28308 }, + Case { id: "bettertls::nameconstraints::tc9125", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28312, 28313], leaf: 28311 }, + Case { id: "bettertls::nameconstraints::tc9126", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28315, 28316], leaf: 28314 }, + Case { id: "bettertls::nameconstraints::tc9127", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28318, 28319], leaf: 28317 }, + Case { id: "bettertls::nameconstraints::tc9128", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28321, 28322], leaf: 28320 }, + Case { id: "bettertls::nameconstraints::tc9129", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28324, 28325], leaf: 28323 }, + Case { id: "bettertls::nameconstraints::tc9130", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28327, 28328], leaf: 28326 }, + Case { id: "bettertls::nameconstraints::tc9131", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28330, 28331], leaf: 28329 }, + Case { id: "bettertls::nameconstraints::tc9132", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28333, 28334], leaf: 28332 }, + Case { id: "bettertls::nameconstraints::tc9133", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28336, 28337], leaf: 28335 }, + Case { id: "bettertls::nameconstraints::tc9134", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28339, 28340], leaf: 28338 }, + Case { id: "bettertls::nameconstraints::tc9135", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28342, 28343], leaf: 28341 }, + Case { id: "bettertls::nameconstraints::tc9136", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28345, 28346], leaf: 28344 }, + Case { id: "bettertls::nameconstraints::tc9137", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28348, 28349], leaf: 28347 }, + Case { id: "bettertls::nameconstraints::tc9138", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28351, 28352], leaf: 28350 }, + Case { id: "bettertls::nameconstraints::tc9139", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28354, 28355], leaf: 28353 }, + Case { id: "bettertls::nameconstraints::tc9140", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28357, 28358], leaf: 28356 }, + Case { id: "bettertls::nameconstraints::tc9141", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28360, 28361], leaf: 28359 }, + Case { id: "bettertls::nameconstraints::tc9142", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28363, 28364], leaf: 28362 }, + Case { id: "bettertls::nameconstraints::tc9143", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28366, 28367], leaf: 28365 }, + Case { id: "bettertls::nameconstraints::tc9144", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28369, 28370], leaf: 28368 }, + Case { id: "bettertls::nameconstraints::tc9145", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28372, 28373], leaf: 28371 }, + Case { id: "bettertls::nameconstraints::tc9146", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28375, 28376], leaf: 28374 }, + Case { id: "bettertls::nameconstraints::tc9147", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28378, 28379], leaf: 28377 }, + Case { id: "bettertls::nameconstraints::tc9148", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28381, 28382], leaf: 28380 }, + Case { id: "bettertls::nameconstraints::tc9149", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28384, 28385], leaf: 28383 }, + Case { id: "bettertls::nameconstraints::tc9150", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28387, 28388], leaf: 28386 }, + Case { id: "bettertls::nameconstraints::tc9151", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28390, 28391], leaf: 28389 }, + Case { id: "bettertls::nameconstraints::tc9152", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28393, 28394], leaf: 28392 }, + Case { id: "bettertls::nameconstraints::tc9153", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28396, 28397], leaf: 28395 }, + Case { id: "bettertls::nameconstraints::tc9154", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28399, 28400], leaf: 28398 }, + Case { id: "bettertls::nameconstraints::tc9155", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28402, 28403], leaf: 28401 }, + Case { id: "bettertls::nameconstraints::tc9156", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28405, 28406], leaf: 28404 }, + Case { id: "bettertls::nameconstraints::tc9157", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28408, 28409], leaf: 28407 }, + Case { id: "bettertls::nameconstraints::tc9158", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28411, 28412], leaf: 28410 }, + Case { id: "bettertls::nameconstraints::tc9159", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28414, 28415], leaf: 28413 }, + Case { id: "bettertls::nameconstraints::tc9160", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28417, 28418], leaf: 28416 }, + Case { id: "bettertls::nameconstraints::tc9161", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28420, 28421], leaf: 28419 }, + Case { id: "bettertls::nameconstraints::tc9162", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28423, 28424], leaf: 28422 }, + Case { id: "bettertls::nameconstraints::tc9163", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28426, 28427], leaf: 28425 }, + Case { id: "bettertls::nameconstraints::tc9164", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28429, 28430], leaf: 28428 }, + Case { id: "bettertls::nameconstraints::tc9165", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28432, 28433], leaf: 28431 }, + Case { id: "bettertls::nameconstraints::tc9166", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28435, 28436], leaf: 28434 }, + Case { id: "bettertls::nameconstraints::tc9167", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28438, 28439], leaf: 28437 }, + Case { id: "bettertls::nameconstraints::tc9168", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28441, 28442], leaf: 28440 }, + Case { id: "bettertls::nameconstraints::tc9169", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28444, 28445], leaf: 28443 }, + Case { id: "bettertls::nameconstraints::tc9170", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28447, 28448], leaf: 28446 }, + Case { id: "bettertls::nameconstraints::tc9171", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28450, 28451], leaf: 28449 }, + Case { id: "bettertls::nameconstraints::tc9172", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28453, 28454], leaf: 28452 }, + Case { id: "bettertls::nameconstraints::tc9173", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28456, 28457], leaf: 28455 }, + Case { id: "bettertls::nameconstraints::tc9174", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28459, 28460], leaf: 28458 }, + Case { id: "bettertls::nameconstraints::tc9175", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28462, 28463], leaf: 28461 }, + Case { id: "bettertls::nameconstraints::tc9176", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28465, 28466], leaf: 28464 }, + Case { id: "bettertls::nameconstraints::tc9177", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28468, 28469], leaf: 28467 }, + Case { id: "bettertls::nameconstraints::tc9178", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28471, 28472], leaf: 28470 }, + Case { id: "bettertls::nameconstraints::tc9179", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28474, 28475], leaf: 28473 }, + Case { id: "bettertls::nameconstraints::tc9180", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28477, 28478], leaf: 28476 }, + Case { id: "bettertls::nameconstraints::tc9181", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28480, 28481], leaf: 28479 }, + Case { id: "bettertls::nameconstraints::tc9182", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28483, 28484], leaf: 28482 }, + Case { id: "bettertls::nameconstraints::tc9183", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28486, 28487], leaf: 28485 }, + Case { id: "bettertls::nameconstraints::tc9184", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28489, 28490], leaf: 28488 }, + Case { id: "bettertls::nameconstraints::tc9185", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28492, 28493], leaf: 28491 }, + Case { id: "bettertls::nameconstraints::tc9186", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28495, 28496], leaf: 28494 }, + Case { id: "bettertls::nameconstraints::tc9187", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28498, 28499], leaf: 28497 }, + Case { id: "bettertls::nameconstraints::tc9188", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28501, 28502], leaf: 28500 }, + Case { id: "bettertls::nameconstraints::tc9189", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28504, 28505], leaf: 28503 }, + Case { id: "bettertls::nameconstraints::tc9190", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28507, 28508], leaf: 28506 }, + Case { id: "bettertls::nameconstraints::tc9191", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28510, 28511], leaf: 28509 }, + Case { id: "bettertls::nameconstraints::tc9192", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28513, 28514], leaf: 28512 }, + Case { id: "bettertls::nameconstraints::tc9193", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28516, 28517], leaf: 28515 }, + Case { id: "bettertls::nameconstraints::tc9194", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28519, 28520], leaf: 28518 }, + Case { id: "bettertls::nameconstraints::tc9195", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28522, 28523], leaf: 28521 }, + Case { id: "bettertls::nameconstraints::tc9196", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28525, 28526], leaf: 28524 }, + Case { id: "bettertls::nameconstraints::tc9197", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28528, 28529], leaf: 28527 }, + Case { id: "bettertls::nameconstraints::tc9198", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28531, 28532], leaf: 28530 }, + Case { id: "bettertls::nameconstraints::tc9199", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28534, 28535], leaf: 28533 }, + Case { id: "bettertls::nameconstraints::tc9200", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28537, 28538], leaf: 28536 }, + Case { id: "bettertls::nameconstraints::tc9201", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28540, 28541], leaf: 28539 }, + Case { id: "bettertls::nameconstraints::tc9202", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28543, 28544], leaf: 28542 }, + Case { id: "bettertls::nameconstraints::tc9203", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28546, 28547], leaf: 28545 }, + Case { id: "bettertls::nameconstraints::tc9204", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28549, 28550], leaf: 28548 }, + Case { id: "bettertls::nameconstraints::tc9205", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28552, 28553], leaf: 28551 }, + Case { id: "bettertls::nameconstraints::tc9206", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28555, 28556], leaf: 28554 }, + Case { id: "bettertls::nameconstraints::tc9207", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28558, 28559], leaf: 28557 }, + Case { id: "bettertls::nameconstraints::tc9208", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28561, 28562], leaf: 28560 }, + Case { id: "bettertls::nameconstraints::tc9209", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28564, 28565], leaf: 28563 }, + Case { id: "bettertls::nameconstraints::tc9210", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28567, 28568], leaf: 28566 }, + Case { id: "bettertls::nameconstraints::tc9211", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28570, 28571], leaf: 28569 }, + Case { id: "bettertls::nameconstraints::tc9212", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28573, 28574], leaf: 28572 }, + Case { id: "bettertls::nameconstraints::tc9213", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28576, 28577], leaf: 28575 }, + Case { id: "bettertls::nameconstraints::tc9214", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28579, 28580], leaf: 28578 }, + Case { id: "bettertls::nameconstraints::tc9215", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28582, 28583], leaf: 28581 }, + Case { id: "bettertls::nameconstraints::tc9216", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28585, 28586], leaf: 28584 }, + Case { id: "bettertls::nameconstraints::tc9217", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28588, 28589], leaf: 28587 }, + Case { id: "bettertls::nameconstraints::tc9218", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28591, 28592], leaf: 28590 }, + Case { id: "bettertls::nameconstraints::tc9219", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28594, 28595], leaf: 28593 }, + Case { id: "bettertls::nameconstraints::tc9220", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28597, 28598], leaf: 28596 }, + Case { id: "bettertls::nameconstraints::tc9221", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28600, 28601], leaf: 28599 }, + Case { id: "bettertls::nameconstraints::tc9222", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28603, 28604], leaf: 28602 }, + Case { id: "bettertls::nameconstraints::tc9223", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28606, 28607], leaf: 28605 }, + Case { id: "bettertls::nameconstraints::tc9224", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28609, 28610], leaf: 28608 }, + Case { id: "bettertls::nameconstraints::tc9225", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28612, 28613], leaf: 28611 }, + Case { id: "bettertls::nameconstraints::tc9226", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28615, 28616], leaf: 28614 }, + Case { id: "bettertls::nameconstraints::tc9227", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28618, 28619], leaf: 28617 }, + Case { id: "bettertls::nameconstraints::tc9228", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28621, 28622], leaf: 28620 }, + Case { id: "bettertls::nameconstraints::tc9229", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28624, 28625], leaf: 28623 }, + Case { id: "bettertls::nameconstraints::tc9230", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28627, 28628], leaf: 28626 }, + Case { id: "bettertls::nameconstraints::tc9231", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28630, 28631], leaf: 28629 }, + Case { id: "bettertls::nameconstraints::tc9232", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28633, 28634], leaf: 28632 }, + Case { id: "bettertls::nameconstraints::tc9233", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28636, 28637], leaf: 28635 }, + Case { id: "bettertls::nameconstraints::tc9234", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28639, 28640], leaf: 28638 }, + Case { id: "bettertls::nameconstraints::tc9235", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28642, 28643], leaf: 28641 }, + Case { id: "bettertls::nameconstraints::tc9236", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28645, 28646], leaf: 28644 }, + Case { id: "bettertls::nameconstraints::tc9237", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28648, 28649], leaf: 28647 }, + Case { id: "bettertls::nameconstraints::tc9238", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28651, 28652], leaf: 28650 }, + Case { id: "bettertls::nameconstraints::tc9239", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28654, 28655], leaf: 28653 }, + Case { id: "bettertls::nameconstraints::tc9240", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28657, 28658], leaf: 28656 }, + Case { id: "bettertls::nameconstraints::tc9241", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28660, 28661], leaf: 28659 }, + Case { id: "bettertls::nameconstraints::tc9242", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28663, 28664], leaf: 28662 }, + Case { id: "bettertls::nameconstraints::tc9243", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28666, 28667], leaf: 28665 }, + Case { id: "bettertls::nameconstraints::tc9244", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28669, 28670], leaf: 28668 }, + Case { id: "bettertls::nameconstraints::tc9245", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28672, 28673], leaf: 28671 }, + Case { id: "bettertls::nameconstraints::tc9246", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28675, 28676], leaf: 28674 }, + Case { id: "bettertls::nameconstraints::tc9247", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28678, 28679], leaf: 28677 }, + Case { id: "bettertls::nameconstraints::tc9248", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28681, 28682], leaf: 28680 }, + Case { id: "bettertls::nameconstraints::tc9249", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28684, 28685], leaf: 28683 }, + Case { id: "bettertls::nameconstraints::tc9250", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28687, 28688], leaf: 28686 }, + Case { id: "bettertls::nameconstraints::tc9251", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28690, 28691], leaf: 28689 }, + Case { id: "bettertls::nameconstraints::tc9252", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28693, 28694], leaf: 28692 }, + Case { id: "bettertls::nameconstraints::tc9253", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28696, 28697], leaf: 28695 }, + Case { id: "bettertls::nameconstraints::tc9254", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28699, 28700], leaf: 28698 }, + Case { id: "bettertls::nameconstraints::tc9255", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28702, 28703], leaf: 28701 }, + Case { id: "bettertls::nameconstraints::tc9256", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28705, 28706], leaf: 28704 }, + Case { id: "bettertls::nameconstraints::tc9257", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28708, 28709], leaf: 28707 }, + Case { id: "bettertls::nameconstraints::tc9258", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28711, 28712], leaf: 28710 }, + Case { id: "bettertls::nameconstraints::tc9259", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28714, 28715], leaf: 28713 }, + Case { id: "bettertls::nameconstraints::tc9260", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28717, 28718], leaf: 28716 }, + Case { id: "bettertls::nameconstraints::tc9261", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28720, 28721], leaf: 28719 }, + Case { id: "bettertls::nameconstraints::tc9262", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28723, 28724], leaf: 28722 }, + Case { id: "bettertls::nameconstraints::tc9263", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28726, 28727], leaf: 28725 }, + Case { id: "bettertls::nameconstraints::tc9264", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28729, 28730], leaf: 28728 }, + Case { id: "bettertls::nameconstraints::tc9265", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28732, 28733], leaf: 28731 }, + Case { id: "bettertls::nameconstraints::tc9266", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28735, 28736], leaf: 28734 }, + Case { id: "bettertls::nameconstraints::tc9267", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28738, 28739], leaf: 28737 }, + Case { id: "bettertls::nameconstraints::tc9268", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28741, 28742], leaf: 28740 }, + Case { id: "bettertls::nameconstraints::tc9269", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28744, 28745], leaf: 28743 }, + Case { id: "bettertls::nameconstraints::tc9270", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28747, 28748], leaf: 28746 }, + Case { id: "bettertls::nameconstraints::tc9271", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28750, 28751], leaf: 28749 }, + Case { id: "bettertls::nameconstraints::tc9272", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28753, 28754], leaf: 28752 }, + Case { id: "bettertls::nameconstraints::tc9273", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28756, 28757], leaf: 28755 }, + Case { id: "bettertls::nameconstraints::tc9274", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28759, 28760], leaf: 28758 }, + Case { id: "bettertls::nameconstraints::tc9275", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28762, 28763], leaf: 28761 }, + Case { id: "bettertls::nameconstraints::tc9276", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28765, 28766], leaf: 28764 }, + Case { id: "bettertls::nameconstraints::tc9277", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28768, 28769], leaf: 28767 }, + Case { id: "bettertls::nameconstraints::tc9278", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28771, 28772], leaf: 28770 }, + Case { id: "bettertls::nameconstraints::tc9279", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28774, 28775], leaf: 28773 }, + Case { id: "bettertls::nameconstraints::tc9280", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28777, 28778], leaf: 28776 }, + Case { id: "bettertls::nameconstraints::tc9281", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28780, 28781], leaf: 28779 }, + Case { id: "bettertls::nameconstraints::tc9282", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28783, 28784], leaf: 28782 }, + Case { id: "bettertls::nameconstraints::tc9283", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28786, 28787], leaf: 28785 }, + Case { id: "bettertls::nameconstraints::tc9284", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28789, 28790], leaf: 28788 }, + Case { id: "bettertls::nameconstraints::tc9285", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28792, 28793], leaf: 28791 }, + Case { id: "bettertls::nameconstraints::tc9286", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28795, 28796], leaf: 28794 }, + Case { id: "bettertls::nameconstraints::tc9287", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28798, 28799], leaf: 28797 }, + Case { id: "bettertls::nameconstraints::tc9288", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28801, 28802], leaf: 28800 }, + Case { id: "bettertls::nameconstraints::tc9289", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28804, 28805], leaf: 28803 }, + Case { id: "bettertls::nameconstraints::tc9290", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28807, 28808], leaf: 28806 }, + Case { id: "bettertls::nameconstraints::tc9291", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28810, 28811], leaf: 28809 }, + Case { id: "bettertls::nameconstraints::tc9292", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28813, 28814], leaf: 28812 }, + Case { id: "bettertls::nameconstraints::tc9293", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28816, 28817], leaf: 28815 }, + Case { id: "bettertls::nameconstraints::tc9294", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28819, 28820], leaf: 28818 }, + Case { id: "bettertls::nameconstraints::tc9295", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28822, 28823], leaf: 28821 }, + Case { id: "bettertls::nameconstraints::tc9296", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28825, 28826], leaf: 28824 }, + Case { id: "bettertls::nameconstraints::tc9297", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28828, 28829], leaf: 28827 }, + Case { id: "bettertls::nameconstraints::tc9298", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28831, 28832], leaf: 28830 }, + Case { id: "bettertls::nameconstraints::tc9299", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28834, 28835], leaf: 28833 }, + Case { id: "bettertls::nameconstraints::tc9300", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28837, 28838], leaf: 28836 }, + Case { id: "bettertls::nameconstraints::tc9301", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28840, 28841], leaf: 28839 }, + Case { id: "bettertls::nameconstraints::tc9302", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28843, 28844], leaf: 28842 }, + Case { id: "bettertls::nameconstraints::tc9303", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28846, 28847], leaf: 28845 }, + Case { id: "bettertls::nameconstraints::tc9304", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28849, 28850], leaf: 28848 }, + Case { id: "bettertls::nameconstraints::tc9305", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28852, 28853], leaf: 28851 }, + Case { id: "bettertls::nameconstraints::tc9306", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28855, 28856], leaf: 28854 }, + Case { id: "bettertls::nameconstraints::tc9307", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28858, 28859], leaf: 28857 }, + Case { id: "bettertls::nameconstraints::tc9308", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28861, 28862], leaf: 28860 }, + Case { id: "bettertls::nameconstraints::tc9309", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28864, 28865], leaf: 28863 }, + Case { id: "bettertls::nameconstraints::tc9310", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28867, 28868], leaf: 28866 }, + Case { id: "bettertls::nameconstraints::tc9311", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28870, 28871], leaf: 28869 }, + Case { id: "bettertls::nameconstraints::tc9312", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28873, 28874], leaf: 28872 }, + Case { id: "bettertls::nameconstraints::tc9313", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28876, 28877], leaf: 28875 }, + Case { id: "bettertls::nameconstraints::tc9314", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28879, 28880], leaf: 28878 }, + Case { id: "bettertls::nameconstraints::tc9315", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28882, 28883], leaf: 28881 }, + Case { id: "bettertls::nameconstraints::tc9316", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28885, 28886], leaf: 28884 }, + Case { id: "bettertls::nameconstraints::tc9317", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28888, 28889], leaf: 28887 }, + Case { id: "bettertls::nameconstraints::tc9318", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28891, 28892], leaf: 28890 }, + Case { id: "bettertls::nameconstraints::tc9319", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28894, 28895], leaf: 28893 }, + Case { id: "bettertls::nameconstraints::tc9320", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28897, 28898], leaf: 28896 }, + Case { id: "bettertls::nameconstraints::tc9321", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28900, 28901], leaf: 28899 }, + Case { id: "bettertls::nameconstraints::tc9322", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28903, 28904], leaf: 28902 }, + Case { id: "bettertls::nameconstraints::tc9323", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28906, 28907], leaf: 28905 }, + Case { id: "bettertls::nameconstraints::tc9324", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28909, 28910], leaf: 28908 }, + Case { id: "bettertls::nameconstraints::tc9325", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28912, 28913], leaf: 28911 }, + Case { id: "bettertls::nameconstraints::tc9326", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28915, 28916], leaf: 28914 }, + Case { id: "bettertls::nameconstraints::tc9327", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28918, 28919], leaf: 28917 }, + Case { id: "bettertls::nameconstraints::tc9328", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28921, 28922], leaf: 28920 }, + Case { id: "bettertls::nameconstraints::tc9329", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28924, 28925], leaf: 28923 }, + Case { id: "bettertls::nameconstraints::tc9330", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28927, 28928], leaf: 28926 }, + Case { id: "bettertls::nameconstraints::tc9331", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28930, 28931], leaf: 28929 }, + Case { id: "bettertls::nameconstraints::tc9332", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28933, 28934], leaf: 28932 }, + Case { id: "bettertls::nameconstraints::tc9333", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28936, 28937], leaf: 28935 }, + Case { id: "bettertls::nameconstraints::tc9334", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28939, 28940], leaf: 28938 }, + Case { id: "bettertls::nameconstraints::tc9335", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28942, 28943], leaf: 28941 }, + Case { id: "bettertls::nameconstraints::tc9336", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28945, 28946], leaf: 28944 }, + Case { id: "bettertls::nameconstraints::tc9337", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28948, 28949], leaf: 28947 }, + Case { id: "bettertls::nameconstraints::tc9338", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28951, 28952], leaf: 28950 }, + Case { id: "bettertls::nameconstraints::tc9339", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28954, 28955], leaf: 28953 }, + Case { id: "bettertls::nameconstraints::tc9340", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28957, 28958], leaf: 28956 }, + Case { id: "bettertls::nameconstraints::tc9341", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28960, 28961], leaf: 28959 }, + Case { id: "bettertls::nameconstraints::tc9342", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28963, 28964], leaf: 28962 }, + Case { id: "bettertls::nameconstraints::tc9343", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28966, 28967], leaf: 28965 }, + Case { id: "bettertls::nameconstraints::tc9344", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28969, 28970], leaf: 28968 }, + Case { id: "bettertls::nameconstraints::tc9345", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28972, 28973], leaf: 28971 }, + Case { id: "bettertls::nameconstraints::tc9346", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28975, 28976], leaf: 28974 }, + Case { id: "bettertls::nameconstraints::tc9347", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28978, 28979], leaf: 28977 }, + Case { id: "bettertls::nameconstraints::tc9348", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28981, 28982], leaf: 28980 }, + Case { id: "bettertls::nameconstraints::tc9349", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28984, 28985], leaf: 28983 }, + Case { id: "bettertls::nameconstraints::tc9350", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28987, 28988], leaf: 28986 }, + Case { id: "bettertls::nameconstraints::tc9351", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28990, 28991], leaf: 28989 }, + Case { id: "bettertls::nameconstraints::tc9352", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28993, 28994], leaf: 28992 }, + Case { id: "bettertls::nameconstraints::tc9353", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28996, 28997], leaf: 28995 }, + Case { id: "bettertls::nameconstraints::tc9354", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[28999, 29000], leaf: 28998 }, + Case { id: "bettertls::nameconstraints::tc9355", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29002, 29003], leaf: 29001 }, + Case { id: "bettertls::nameconstraints::tc9356", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29005, 29006], leaf: 29004 }, + Case { id: "bettertls::nameconstraints::tc9357", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29008, 29009], leaf: 29007 }, + Case { id: "bettertls::nameconstraints::tc9358", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29011, 29012], leaf: 29010 }, + Case { id: "bettertls::nameconstraints::tc9359", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29014, 29015], leaf: 29013 }, + Case { id: "bettertls::nameconstraints::tc9360", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29017, 29018], leaf: 29016 }, + Case { id: "bettertls::nameconstraints::tc9361", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29020, 29021], leaf: 29019 }, + Case { id: "bettertls::nameconstraints::tc9362", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29023, 29024], leaf: 29022 }, + Case { id: "bettertls::nameconstraints::tc9363", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29026, 29027], leaf: 29025 }, + Case { id: "bettertls::nameconstraints::tc9364", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29029, 29030], leaf: 29028 }, + Case { id: "bettertls::nameconstraints::tc9365", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29032, 29033], leaf: 29031 }, + Case { id: "bettertls::nameconstraints::tc9366", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29035, 29036], leaf: 29034 }, + Case { id: "bettertls::nameconstraints::tc9367", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29038, 29039], leaf: 29037 }, + Case { id: "bettertls::nameconstraints::tc9368", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29041, 29042], leaf: 29040 }, + Case { id: "bettertls::nameconstraints::tc9369", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29044, 29045], leaf: 29043 }, + Case { id: "bettertls::nameconstraints::tc9370", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29047, 29048], leaf: 29046 }, + Case { id: "bettertls::nameconstraints::tc9371", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29050, 29051], leaf: 29049 }, + Case { id: "bettertls::nameconstraints::tc9372", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29053, 29054], leaf: 29052 }, + Case { id: "bettertls::nameconstraints::tc9373", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29056, 29057], leaf: 29055 }, + Case { id: "bettertls::nameconstraints::tc9374", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29059, 29060], leaf: 29058 }, + Case { id: "bettertls::nameconstraints::tc9375", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29062, 29063], leaf: 29061 }, + Case { id: "bettertls::nameconstraints::tc9376", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29065, 29066], leaf: 29064 }, + Case { id: "bettertls::nameconstraints::tc9377", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29068, 29069], leaf: 29067 }, + Case { id: "bettertls::nameconstraints::tc9378", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29071, 29072], leaf: 29070 }, + Case { id: "bettertls::nameconstraints::tc9379", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29074, 29075], leaf: 29073 }, + Case { id: "bettertls::nameconstraints::tc9380", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29077, 29078], leaf: 29076 }, + Case { id: "bettertls::nameconstraints::tc9381", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29080, 29081], leaf: 29079 }, + Case { id: "bettertls::nameconstraints::tc9382", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29083, 29084], leaf: 29082 }, + Case { id: "bettertls::nameconstraints::tc9383", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29086, 29087], leaf: 29085 }, + Case { id: "bettertls::nameconstraints::tc9384", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29089, 29090], leaf: 29088 }, + Case { id: "bettertls::nameconstraints::tc9385", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29092, 29093], leaf: 29091 }, + Case { id: "bettertls::nameconstraints::tc9386", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29095, 29096], leaf: 29094 }, + Case { id: "bettertls::nameconstraints::tc9387", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29098, 29099], leaf: 29097 }, + Case { id: "bettertls::nameconstraints::tc9388", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29101, 29102], leaf: 29100 }, + Case { id: "bettertls::nameconstraints::tc9389", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29104, 29105], leaf: 29103 }, + Case { id: "bettertls::nameconstraints::tc9390", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29107, 29108], leaf: 29106 }, + Case { id: "bettertls::nameconstraints::tc9391", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29110, 29111], leaf: 29109 }, + Case { id: "bettertls::nameconstraints::tc9392", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29113, 29114], leaf: 29112 }, + Case { id: "bettertls::nameconstraints::tc9393", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29116, 29117], leaf: 29115 }, + Case { id: "bettertls::nameconstraints::tc9394", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29119, 29120], leaf: 29118 }, + Case { id: "bettertls::nameconstraints::tc9395", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29122, 29123], leaf: 29121 }, + Case { id: "bettertls::nameconstraints::tc9396", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29125, 29126], leaf: 29124 }, + Case { id: "bettertls::nameconstraints::tc9397", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29128, 29129], leaf: 29127 }, + Case { id: "bettertls::nameconstraints::tc9398", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29131, 29132], leaf: 29130 }, + Case { id: "bettertls::nameconstraints::tc9399", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29134, 29135], leaf: 29133 }, + Case { id: "bettertls::nameconstraints::tc9400", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29137, 29138], leaf: 29136 }, + Case { id: "bettertls::nameconstraints::tc9401", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29140, 29141], leaf: 29139 }, + Case { id: "bettertls::nameconstraints::tc9402", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29143, 29144], leaf: 29142 }, + Case { id: "bettertls::nameconstraints::tc9403", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29146, 29147], leaf: 29145 }, + Case { id: "bettertls::nameconstraints::tc9404", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29149, 29150], leaf: 29148 }, + Case { id: "bettertls::nameconstraints::tc9405", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29152, 29153], leaf: 29151 }, + Case { id: "bettertls::nameconstraints::tc9406", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29155, 29156], leaf: 29154 }, + Case { id: "bettertls::nameconstraints::tc9407", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29158, 29159], leaf: 29157 }, + Case { id: "bettertls::nameconstraints::tc9408", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29161, 29162], leaf: 29160 }, + Case { id: "bettertls::nameconstraints::tc9409", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29164, 29165], leaf: 29163 }, + Case { id: "bettertls::nameconstraints::tc9410", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29167, 29168], leaf: 29166 }, + Case { id: "bettertls::nameconstraints::tc9411", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29170, 29171], leaf: 29169 }, + Case { id: "bettertls::nameconstraints::tc9412", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29173, 29174], leaf: 29172 }, + Case { id: "bettertls::nameconstraints::tc9413", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29176, 29177], leaf: 29175 }, + Case { id: "bettertls::nameconstraints::tc9414", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29179, 29180], leaf: 29178 }, + Case { id: "bettertls::nameconstraints::tc9415", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29182, 29183], leaf: 29181 }, + Case { id: "bettertls::nameconstraints::tc9416", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29185, 29186], leaf: 29184 }, + Case { id: "bettertls::nameconstraints::tc9417", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29188, 29189], leaf: 29187 }, + Case { id: "bettertls::nameconstraints::tc9418", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29191, 29192], leaf: 29190 }, + Case { id: "bettertls::nameconstraints::tc9419", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29194, 29195], leaf: 29193 }, + Case { id: "bettertls::nameconstraints::tc9420", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29197, 29198], leaf: 29196 }, + Case { id: "bettertls::nameconstraints::tc9421", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29200, 29201], leaf: 29199 }, + Case { id: "bettertls::nameconstraints::tc9422", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29203, 29204], leaf: 29202 }, + Case { id: "bettertls::nameconstraints::tc9423", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29206, 29207], leaf: 29205 }, + Case { id: "bettertls::nameconstraints::tc9424", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29209, 29210], leaf: 29208 }, + Case { id: "bettertls::nameconstraints::tc9425", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29212, 29213], leaf: 29211 }, + Case { id: "bettertls::nameconstraints::tc9426", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29215, 29216], leaf: 29214 }, + Case { id: "bettertls::nameconstraints::tc9427", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29218, 29219], leaf: 29217 }, + Case { id: "bettertls::nameconstraints::tc9428", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29221, 29222], leaf: 29220 }, + Case { id: "bettertls::nameconstraints::tc9429", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29224, 29225], leaf: 29223 }, + Case { id: "bettertls::nameconstraints::tc9430", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29227, 29228], leaf: 29226 }, + Case { id: "bettertls::nameconstraints::tc9431", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29230, 29231], leaf: 29229 }, + Case { id: "bettertls::nameconstraints::tc9432", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29233, 29234], leaf: 29232 }, + Case { id: "bettertls::nameconstraints::tc9433", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29236, 29237], leaf: 29235 }, + Case { id: "bettertls::nameconstraints::tc9434", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29239, 29240], leaf: 29238 }, + Case { id: "bettertls::nameconstraints::tc9435", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29242, 29243], leaf: 29241 }, + Case { id: "bettertls::nameconstraints::tc9436", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29245, 29246], leaf: 29244 }, + Case { id: "bettertls::nameconstraints::tc9437", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29248, 29249], leaf: 29247 }, + Case { id: "bettertls::nameconstraints::tc9438", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29251, 29252], leaf: 29250 }, + Case { id: "bettertls::nameconstraints::tc9439", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29254, 29255], leaf: 29253 }, + Case { id: "bettertls::nameconstraints::tc9440", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29257, 29258], leaf: 29256 }, + Case { id: "bettertls::nameconstraints::tc9441", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29260, 29261], leaf: 29259 }, + Case { id: "bettertls::nameconstraints::tc9442", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29263, 29264], leaf: 29262 }, + Case { id: "bettertls::nameconstraints::tc9443", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29266, 29267], leaf: 29265 }, + Case { id: "bettertls::nameconstraints::tc9444", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29269, 29270], leaf: 29268 }, + Case { id: "bettertls::nameconstraints::tc9445", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29272, 29273], leaf: 29271 }, + Case { id: "bettertls::nameconstraints::tc9446", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29275, 29276], leaf: 29274 }, + Case { id: "bettertls::nameconstraints::tc9447", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29278, 29279], leaf: 29277 }, + Case { id: "bettertls::nameconstraints::tc9448", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29281, 29282], leaf: 29280 }, + Case { id: "bettertls::nameconstraints::tc9449", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29284, 29285], leaf: 29283 }, + Case { id: "bettertls::nameconstraints::tc9450", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29287, 29288], leaf: 29286 }, + Case { id: "bettertls::nameconstraints::tc9451", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29290, 29291], leaf: 29289 }, + Case { id: "bettertls::nameconstraints::tc9452", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29293, 29294], leaf: 29292 }, + Case { id: "bettertls::nameconstraints::tc9453", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29296, 29297], leaf: 29295 }, + Case { id: "bettertls::nameconstraints::tc9454", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29299, 29300], leaf: 29298 }, + Case { id: "bettertls::nameconstraints::tc9455", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29302, 29303], leaf: 29301 }, + Case { id: "bettertls::nameconstraints::tc9456", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29305, 29306], leaf: 29304 }, + Case { id: "bettertls::nameconstraints::tc9457", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29308, 29309], leaf: 29307 }, + Case { id: "bettertls::nameconstraints::tc9458", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29311, 29312], leaf: 29310 }, + Case { id: "bettertls::nameconstraints::tc9459", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29314, 29315], leaf: 29313 }, + Case { id: "bettertls::nameconstraints::tc9460", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29317, 29318], leaf: 29316 }, + Case { id: "bettertls::nameconstraints::tc9461", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29320, 29321], leaf: 29319 }, + Case { id: "bettertls::nameconstraints::tc9462", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29323, 29324], leaf: 29322 }, + Case { id: "bettertls::nameconstraints::tc9463", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29326, 29327], leaf: 29325 }, + Case { id: "bettertls::nameconstraints::tc9464", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29329, 29330], leaf: 29328 }, + Case { id: "bettertls::nameconstraints::tc9465", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29332, 29333], leaf: 29331 }, + Case { id: "bettertls::nameconstraints::tc9466", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29335, 29336], leaf: 29334 }, + Case { id: "bettertls::nameconstraints::tc9467", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29338, 29339], leaf: 29337 }, + Case { id: "bettertls::nameconstraints::tc9468", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29341, 29342], leaf: 29340 }, + Case { id: "bettertls::nameconstraints::tc9469", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29344, 29345], leaf: 29343 }, + Case { id: "bettertls::nameconstraints::tc9470", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29347, 29348], leaf: 29346 }, + Case { id: "bettertls::nameconstraints::tc9471", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29350, 29351], leaf: 29349 }, + Case { id: "bettertls::nameconstraints::tc9472", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29353, 29354], leaf: 29352 }, + Case { id: "bettertls::nameconstraints::tc9473", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29356, 29357], leaf: 29355 }, + Case { id: "bettertls::nameconstraints::tc9474", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29359, 29360], leaf: 29358 }, + Case { id: "bettertls::nameconstraints::tc9475", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29362, 29363], leaf: 29361 }, + Case { id: "bettertls::nameconstraints::tc9476", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29365, 29366], leaf: 29364 }, + Case { id: "bettertls::nameconstraints::tc9477", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29368, 29369], leaf: 29367 }, + Case { id: "bettertls::nameconstraints::tc9478", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29371, 29372], leaf: 29370 }, + Case { id: "bettertls::nameconstraints::tc9479", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29374, 29375], leaf: 29373 }, + Case { id: "bettertls::nameconstraints::tc9480", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29377, 29378], leaf: 29376 }, + Case { id: "bettertls::nameconstraints::tc9481", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29380, 29381], leaf: 29379 }, + Case { id: "bettertls::nameconstraints::tc9482", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29383, 29384], leaf: 29382 }, + Case { id: "bettertls::nameconstraints::tc9483", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29386, 29387], leaf: 29385 }, + Case { id: "bettertls::nameconstraints::tc9484", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29389, 29390], leaf: 29388 }, + Case { id: "bettertls::nameconstraints::tc9485", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29392, 29393], leaf: 29391 }, + Case { id: "bettertls::nameconstraints::tc9486", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29395, 29396], leaf: 29394 }, + Case { id: "bettertls::nameconstraints::tc9487", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29398, 29399], leaf: 29397 }, + Case { id: "bettertls::nameconstraints::tc9488", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29401, 29402], leaf: 29400 }, + Case { id: "bettertls::nameconstraints::tc9489", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29404, 29405], leaf: 29403 }, + Case { id: "bettertls::nameconstraints::tc9490", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "test.localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29407, 29408], leaf: 29406 }, + Case { id: "bettertls::pathbuilding::tc0", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29410], leaf: 29409 }, + Case { id: "bettertls::pathbuilding::tc1", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29412, 29413], leaf: 29411 }, + Case { id: "bettertls::pathbuilding::tc2", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29415, 29416], leaf: 29414 }, + Case { id: "bettertls::pathbuilding::tc3", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2027-01-21T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29418], leaf: 29417 }, + Case { id: "bettertls::pathbuilding::tc4", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29420], leaf: 29419 }, + Case { id: "bettertls::pathbuilding::tc5", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29422], leaf: 29421 }, + Case { id: "bettertls::pathbuilding::tc6", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29424], leaf: 29423 }, + Case { id: "bettertls::pathbuilding::tc7", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29426], leaf: 29425 }, + Case { id: "bettertls::pathbuilding::tc8", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29428], leaf: 29427 }, + Case { id: "bettertls::pathbuilding::tc9", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29430], leaf: 29429 }, + Case { id: "bettertls::pathbuilding::tc10", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2027-01-21T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29432], leaf: 29431 }, + Case { id: "bettertls::pathbuilding::tc11", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29434], leaf: 29433 }, + Case { id: "bettertls::pathbuilding::tc12", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29436], leaf: 29435 }, + Case { id: "bettertls::pathbuilding::tc13", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29438], leaf: 29437 }, + Case { id: "bettertls::pathbuilding::tc14", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29440], leaf: 29439 }, + Case { id: "bettertls::pathbuilding::tc15", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29442], leaf: 29441 }, + Case { id: "bettertls::pathbuilding::tc16", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29444], leaf: 29443 }, + Case { id: "bettertls::pathbuilding::tc17", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29446], leaf: 29445 }, + Case { id: "bettertls::pathbuilding::tc18", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29448], leaf: 29447 }, + Case { id: "bettertls::pathbuilding::tc19", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29450], leaf: 29449 }, + Case { id: "bettertls::pathbuilding::tc20", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29452], leaf: 29451 }, + Case { id: "bettertls::pathbuilding::tc21", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29454], leaf: 29453 }, + Case { id: "bettertls::pathbuilding::tc22", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29456, 29457], leaf: 29455 }, + Case { id: "bettertls::pathbuilding::tc23", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29459, 29460], leaf: 29458 }, + Case { id: "bettertls::pathbuilding::tc24", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29462, 29463], leaf: 29461 }, + Case { id: "bettertls::pathbuilding::tc25", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29465, 29466], leaf: 29464 }, + Case { id: "bettertls::pathbuilding::tc26", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29468, 29469], leaf: 29467 }, + Case { id: "bettertls::pathbuilding::tc27", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29471, 29472], leaf: 29470 }, + Case { id: "bettertls::pathbuilding::tc28", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29474, 29475], leaf: 29473 }, + Case { id: "bettertls::pathbuilding::tc29", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29477, 29478], leaf: 29476 }, + Case { id: "bettertls::pathbuilding::tc30", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29480, 29481], leaf: 29479 }, + Case { id: "bettertls::pathbuilding::tc31", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29483, 29484], leaf: 29482 }, + Case { id: "bettertls::pathbuilding::tc32", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29486, 29487], leaf: 29485 }, + Case { id: "bettertls::pathbuilding::tc33", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29489, 29490], leaf: 29488 }, + Case { id: "bettertls::pathbuilding::tc34", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29492, 29493], leaf: 29491 }, + Case { id: "bettertls::pathbuilding::tc35", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29495, 29496], leaf: 29494 }, + Case { id: "bettertls::pathbuilding::tc36", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2027-01-21T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29498, 29499], leaf: 29497 }, + Case { id: "bettertls::pathbuilding::tc37", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29501, 29502], leaf: 29500 }, + Case { id: "bettertls::pathbuilding::tc38", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29504, 29505], leaf: 29503 }, + Case { id: "bettertls::pathbuilding::tc39", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29507, 29508], leaf: 29506 }, + Case { id: "bettertls::pathbuilding::tc40", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29510, 29511], leaf: 29509 }, + Case { id: "bettertls::pathbuilding::tc41", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29513, 29514], leaf: 29512 }, + Case { id: "bettertls::pathbuilding::tc42", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2027-01-21T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29516, 29517], leaf: 29515 }, + Case { id: "bettertls::pathbuilding::tc43", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29519, 29520], leaf: 29518 }, + Case { id: "bettertls::pathbuilding::tc44", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29522, 29523], leaf: 29521 }, + Case { id: "bettertls::pathbuilding::tc45", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29525, 29526], leaf: 29524 }, + Case { id: "bettertls::pathbuilding::tc46", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29528, 29529], leaf: 29527 }, + Case { id: "bettertls::pathbuilding::tc47", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29531, 29532], leaf: 29530 }, + Case { id: "bettertls::pathbuilding::tc48", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29534, 29535, 29536, 29537, 29538, 29539], leaf: 29533 }, + Case { id: "bettertls::pathbuilding::tc49", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29541, 29542, 29543, 29544, 29545, 29546], leaf: 29540 }, + Case { id: "bettertls::pathbuilding::tc50", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29548, 29549, 29550, 29551, 29552, 29553], leaf: 29547 }, + Case { id: "bettertls::pathbuilding::tc51", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29555, 29556, 29557, 29558, 29559, 29560], leaf: 29554 }, + Case { id: "bettertls::pathbuilding::tc52", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29562, 29563, 29564, 29565, 29566, 29567], leaf: 29561 }, + Case { id: "bettertls::pathbuilding::tc53", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29569, 29570, 29571, 29572, 29573, 29574], leaf: 29568 }, + Case { id: "bettertls::pathbuilding::tc54", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29576, 29577, 29578, 29579, 29580, 29581], leaf: 29575 }, + Case { id: "bettertls::pathbuilding::tc55", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29583, 29584, 29585, 29586, 29587, 29588], leaf: 29582 }, + Case { id: "bettertls::pathbuilding::tc56", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29590, 29591, 29592, 29593, 29594, 29595], leaf: 29589 }, + Case { id: "bettertls::pathbuilding::tc57", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29597, 29598, 29599, 29600, 29601, 29602], leaf: 29596 }, + Case { id: "bettertls::pathbuilding::tc58", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29604, 29605, 29606, 29607, 29608, 29609], leaf: 29603 }, + Case { id: "bettertls::pathbuilding::tc59", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29611, 29612, 29613, 29614, 29615, 29616], leaf: 29610 }, + Case { id: "bettertls::pathbuilding::tc60", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29618, 29619, 29620, 29621, 29622, 29623], leaf: 29617 }, + Case { id: "bettertls::pathbuilding::tc61", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29625, 29626, 29627, 29628, 29629, 29630, 29631, 29632, 29633, 29634, 29635, 29636, 29637, 29638, 29639, 29640, 29641, 29642, 29643, 29644, 29645, 29646, 29647, 29648, 29649, 29650, 29651, 29652, 29653, 29654, 29655, 29656, 29657, 29658, 29659], leaf: 29624 }, + Case { id: "bettertls::pathbuilding::tc62", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29661, 29662, 29663, 29664, 29665, 29666, 29667, 29668, 29669, 29670, 29671, 29672, 29673, 29674, 29675, 29676, 29677, 29678, 29679, 29680, 29681, 29682, 29683, 29684, 29685, 29686, 29687, 29688, 29689, 29690, 29691, 29692, 29693, 29694, 29695], leaf: 29660 }, + Case { id: "bettertls::pathbuilding::tc63", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29697, 29698, 29699, 29700, 29701, 29702, 29703, 29704, 29705, 29706, 29707, 29708, 29709, 29710, 29711, 29712, 29713, 29714, 29715, 29716, 29717, 29718, 29719, 29720, 29721, 29722, 29723, 29724, 29725, 29726, 29727, 29728, 29729, 29730, 29731], leaf: 29696 }, + Case { id: "bettertls::pathbuilding::tc64", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29733, 29734, 29735, 29736, 29737, 29738, 29739, 29740, 29741, 29742, 29743, 29744, 29745, 29746, 29747, 29748, 29749, 29750, 29751, 29752, 29753, 29754, 29755, 29756, 29757, 29758, 29759, 29760, 29761, 29762, 29763, 29764, 29765, 29766, 29767], leaf: 29732 }, + Case { id: "bettertls::pathbuilding::tc65", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29769, 29770, 29771, 29772, 29773, 29774, 29775, 29776, 29777, 29778, 29779, 29780, 29781, 29782, 29783, 29784, 29785, 29786, 29787, 29788, 29789, 29790, 29791, 29792, 29793, 29794, 29795, 29796, 29797, 29798, 29799, 29800, 29801, 29802, 29803], leaf: 29768 }, + Case { id: "bettertls::pathbuilding::tc66", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29805, 29806, 29807, 29808, 29809, 29810, 29811, 29812, 29813, 29814, 29815, 29816, 29817, 29818, 29819, 29820, 29821, 29822, 29823, 29824, 29825, 29826, 29827, 29828, 29829, 29830, 29831, 29832, 29833, 29834, 29835, 29836, 29837, 29838, 29839], leaf: 29804 }, + Case { id: "bettertls::pathbuilding::tc67", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29841, 29842, 29843, 29844, 29845, 29846, 29847, 29848, 29849, 29850, 29851, 29852, 29853, 29854, 29855, 29856, 29857, 29858, 29859, 29860, 29861, 29862, 29863, 29864, 29865, 29866, 29867, 29868, 29869, 29870, 29871, 29872, 29873, 29874, 29875], leaf: 29840 }, + Case { id: "bettertls::pathbuilding::tc68", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29877, 29878, 29879, 29880, 29881, 29882, 29883, 29884, 29885, 29886, 29887, 29888, 29889, 29890, 29891, 29892, 29893, 29894, 29895, 29896, 29897, 29898, 29899, 29900, 29901, 29902, 29903, 29904, 29905, 29906, 29907, 29908, 29909, 29910, 29911], leaf: 29876 }, + Case { id: "bettertls::pathbuilding::tc69", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2027-01-21T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29913, 29914, 29915, 29916, 29917, 29918, 29919, 29920, 29921, 29922, 29923, 29924, 29925, 29926, 29927, 29928, 29929, 29930, 29931, 29932, 29933, 29934, 29935, 29936, 29937, 29938, 29939, 29940, 29941, 29942, 29943, 29944, 29945, 29946, 29947], leaf: 29912 }, + Case { id: "bettertls::pathbuilding::tc70", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29949, 29950, 29951, 29952, 29953, 29954, 29955, 29956, 29957, 29958, 29959, 29960, 29961, 29962, 29963, 29964, 29965, 29966, 29967, 29968, 29969, 29970, 29971, 29972, 29973, 29974, 29975, 29976, 29977, 29978, 29979, 29980, 29981, 29982, 29983], leaf: 29948 }, + Case { id: "bettertls::pathbuilding::tc71", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[29985, 29986, 29987, 29988, 29989, 29990, 29991, 29992, 29993, 29994, 29995, 29996, 29997, 29998, 29999, 30000, 30001, 30002, 30003, 30004, 30005, 30006, 30007, 30008, 30009, 30010, 30011, 30012, 30013, 30014, 30015, 30016, 30017, 30018, 30019], leaf: 29984 }, + Case { id: "bettertls::pathbuilding::tc72", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[30021, 30022, 30023, 30024, 30025, 30026, 30027, 30028, 30029, 30030, 30031, 30032, 30033, 30034, 30035, 30036, 30037, 30038, 30039, 30040, 30041, 30042, 30043, 30044, 30045, 30046, 30047, 30048, 30049, 30050, 30051, 30052, 30053, 30054, 30055], leaf: 30020 }, + Case { id: "bettertls::pathbuilding::tc73", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[30057, 30058, 30059, 30060, 30061, 30062, 30063, 30064, 30065, 30066, 30067, 30068, 30069, 30070, 30071, 30072, 30073, 30074, 30075, 30076, 30077, 30078, 30079, 30080, 30081, 30082, 30083, 30084, 30085, 30086, 30087, 30088, 30089, 30090, 30091], leaf: 30056 }, + Case { id: "bettertls::pathbuilding::tc74", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[30093, 30094, 30095, 30096, 30097, 30098, 30099, 30100, 30101, 30102, 30103, 30104, 30105, 30106, 30107, 30108, 30109, 30110, 30111, 30112, 30113, 30114, 30115, 30116, 30117, 30118, 30119, 30120, 30121, 30122, 30123, 30124, 30125, 30126, 30127], leaf: 30092 }, + Case { id: "bettertls::pathbuilding::tc75", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2027-01-21T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[30129, 30130, 30131, 30132, 30133, 30134, 30135, 30136, 30137, 30138, 30139, 30140, 30141, 30142, 30143, 30144, 30145, 30146, 30147, 30148, 30149, 30150, 30151, 30152, 30153, 30154, 30155, 30156, 30157, 30158, 30159, 30160, 30161, 30162, 30163], leaf: 30128 }, + Case { id: "bettertls::pathbuilding::tc76", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[30165, 30166, 30167, 30168, 30169, 30170, 30171, 30172, 30173, 30174, 30175, 30176, 30177, 30178, 30179, 30180, 30181, 30182, 30183, 30184, 30185, 30186, 30187, 30188, 30189, 30190, 30191, 30192, 30193, 30194, 30195, 30196, 30197, 30198, 30199], leaf: 30164 }, + Case { id: "bettertls::pathbuilding::tc77", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[30201, 30202, 30203, 30204, 30205, 30206, 30207, 30208, 30209, 30210, 30211, 30212, 30213, 30214, 30215, 30216, 30217, 30218, 30219, 30220, 30221, 30222, 30223, 30224, 30225, 30226, 30227, 30228, 30229, 30230, 30231, 30232, 30233, 30234, 30235], leaf: 30200 }, + Case { id: "bettertls::pathbuilding::tc78", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[30237, 30238, 30239, 30240, 30241, 30242, 30243, 30244, 30245, 30246, 30247, 30248, 30249, 30250, 30251, 30252, 30253, 30254, 30255, 30256, 30257, 30258, 30259, 30260, 30261, 30262, 30263, 30264, 30265, 30266, 30267, 30268, 30269, 30270, 30271], leaf: 30236 }, + Case { id: "bettertls::pathbuilding::tc79", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[30273, 30274, 30275, 30276, 30277, 30278, 30279, 30280, 30281, 30282, 30283, 30284, 30285, 30286, 30287, 30288, 30289, 30290, 30291, 30292, 30293, 30294, 30295, 30296, 30297, 30298, 30299, 30300, 30301, 30302, 30303, 30304, 30305, 30306, 30307], leaf: 30272 }, + Case { id: "bettertls::pathbuilding::tc80", kind: "SERVER", expected: "FAILURE", peer: ("DNS", "localhost"), peer_names: &[], time: "2026-01-19T17:25:55+00:00", features: &[], importance: "undetermined", trusted: &[936], intermediates: &[30309, 30310, 30311, 30312, 30313, 30314, 30315, 30316, 30317, 30318, 30319, 30320, 30321, 30322, 30323, 30324, 30325, 30326, 30327, 30328, 30329, 30330, 30331, 30332, 30333, 30334, 30335, 30336, 30337, 30338, 30339, 30340, 30341, 30342, 30343], leaf: 30308 }, + Case { id: "online::akamai.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "akamai.com"), peer_names: &[], time: "2026-05-18T00:00:01+00:00", features: &[], importance: "undetermined", trusted: &[30345], intermediates: &[30346], leaf: 30344 }, + Case { id: "online::bing.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "bing.com"), peer_names: &[], time: "2026-09-01T17:05:47+00:00", features: &[], importance: "undetermined", trusted: &[30348], intermediates: &[30349, 30350], leaf: 30347 }, + Case { id: "online::fastly.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "fastly.com"), peer_names: &[], time: "2026-08-25T19:32:01+00:00", features: &[], importance: "undetermined", trusted: &[30352], intermediates: &[30353], leaf: 30351 }, + Case { id: "online::s3.amazonaws.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "s3.amazonaws.com"), peer_names: &[], time: "2025-11-18T00:00:01+00:00", features: &[], importance: "undetermined", trusted: &[30355], intermediates: &[30356], leaf: 30354 }, + Case { id: "online::aws.amazon.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "aws.amazon.com"), peer_names: &[], time: "2025-11-06T00:00:01+00:00", features: &[], importance: "undetermined", trusted: &[30355], intermediates: &[30356], leaf: 30357 }, + Case { id: "online::docs.python.org", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "docs.python.org"), peer_names: &[], time: "2026-01-13T13:03:47+00:00", features: &[], importance: "undetermined", trusted: &[30359], intermediates: &[30360], leaf: 30358 }, + Case { id: "online::amazon.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "amazon.com"), peer_names: &[], time: "2026-05-05T00:00:01+00:00", features: &[], importance: "undetermined", trusted: &[30348], intermediates: &[30362], leaf: 30361 }, + Case { id: "online::facebook.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "facebook.com"), peer_names: &[], time: "2026-06-18T00:00:01+00:00", features: &[], importance: "undetermined", trusted: &[30348], intermediates: &[30364], leaf: 30363 }, + Case { id: "online::google.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "google.com"), peer_names: &[], time: "2026-08-10T08:37:36+00:00", features: &[], importance: "undetermined", trusted: &[30366], intermediates: &[30367], leaf: 30365 }, + Case { id: "online::storage.googleapis.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "storage.googleapis.com"), peer_names: &[], time: "2026-08-10T08:41:54+00:00", features: &[], importance: "undetermined", trusted: &[30366], intermediates: &[30367], leaf: 30368 }, + Case { id: "online::apple.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "apple.com"), peer_names: &[], time: "2026-08-13T16:20:02+00:00", features: &[], importance: "undetermined", trusted: &[30345], intermediates: &[30370], leaf: 30369 }, + Case { id: "online::cloudflare.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "cloudflare.com"), peer_names: &[], time: "2026-09-05T22:29:40+00:00", features: &[], importance: "undetermined", trusted: &[30372], intermediates: &[30373], leaf: 30371 }, + Case { id: "online::microsoft.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "microsoft.com"), peer_names: &[], time: "2026-06-23T09:04:18+00:00", features: &[], importance: "undetermined", trusted: &[30348], intermediates: &[30349, 30350], leaf: 30374 }, + Case { id: "online::stackoverflow.com", kind: "SERVER", expected: "SUCCESS", peer: ("DNS", "stackoverflow.com"), peer_names: &[], time: "2026-08-15T12:39:07+00:00", features: &[], importance: "undetermined", trusted: &[30376], intermediates: &[30377, 30378], leaf: 30375 }, +]; diff --git a/crates/clazel-x509/tests/generated/x509_limbo_certs.bin b/crates/clazel-x509/tests/generated/x509_limbo_certs.bin new file mode 100644 index 0000000..3989457 Binary files /dev/null and b/crates/clazel-x509/tests/generated/x509_limbo_certs.bin differ diff --git a/crates/clazel-x509/tests/limbo/not_yet_supported.rs b/crates/clazel-x509/tests/limbo/not_yet_supported.rs new file mode 100644 index 0000000..0cae7fc --- /dev/null +++ b/crates/clazel-x509/tests/limbo/not_yet_supported.rs @@ -0,0 +1,8891 @@ +// Testcases not covered by the leaf pin in `pin_of` (conformance_limbo.rs), +// with the reason. Checked in by hand: when path validation lands, move cases +// out of this list. The test fails on any id that is missing or extra. + +const NEEDS_PATH_VALIDATION: &str = "needs path validation (3.5b)"; +const NEEDS_CRL: &str = "needs path validation (3.5b) and CRL checking (Phase 8)"; +const NEEDS_CHAIN_SEARCH_LIMITS: &str = "needs path validation (3.5b) with chain-search limits"; +const NEEDS_MLDSA: &str = "needs path validation (3.5b) and ML-DSA signatures (not in the 3.5b algorithm set)"; +const NEEDS_CLIENT_VALIDATION: &str = "needs client-certificate path validation (3.5b); only server leaf checks exist"; +const LEAF_POLICY: &str = "limbo (RFC 5280 only) accepts a CA certificate in leaf position; check_leaf_certificate rejects it as an end entity (BasicConstraints cA, and KeyUsage without digitalSignature), a stricter WebPKI-style policy, not a decoder bug"; +const NO_PEER_NAME: &str = "SUCCESS without a DNS or IP peer name, so no RFC 9525 check applies; needs path validation (3.5b)"; + +const NOT_YET_SUPPORTED: &[(&str, &str)] = &[ + ("crl::structure::crl-invalid-signature", NEEDS_CRL), + ("crl::structure::crl-wrong-signing-key", NEEDS_CRL), + ("crl::structure::crl-duplicate-revoked-serial", NEEDS_CRL), + ("crl::structure::crl-unknown-critical-extension", NEEDS_CRL), + ("crl::structure::entry-unknown-critical-extension", NEEDS_CRL), + ("crl::structure::entry-unknown-noncritical-extension", NEEDS_CRL), + ("crl::revoked-certificate-with-crl", NEEDS_CRL), + ("crl::crlnumber-missing", NEEDS_CRL), + ("crl::crlnumber-critical", NEEDS_CRL), + ("crl::issuer-missing-crlsign", NEEDS_CRL), + ("cve::cve-2025-61727", NEEDS_PATH_VALIDATION), + ("cve::cve-2025-61727-nc-permits-variant", NEEDS_PATH_VALIDATION), + ("invalid::invalid-issuer-key", NEEDS_PATH_VALIDATION), + ("pathlen::intermediate-violates-pathlen-0", NEEDS_PATH_VALIDATION), + ("pathlen::intermediate-pathlen-too-long", NEEDS_PATH_VALIDATION), + ("pathlen::max-chain-depth-0-exhausted", NEEDS_PATH_VALIDATION), + ("pathlen::max-chain-depth-1-exhausted", NEEDS_PATH_VALIDATION), + ("pathological::intermediate-cycle-distinct-cas", NEEDS_CHAIN_SEARCH_LIMITS), + ("pathological::intermediate-cycle-distinct-cas-max-depth", NEEDS_CHAIN_SEARCH_LIMITS), + ("pathological::intermediate-cycle-same-logical-ca", NEEDS_CHAIN_SEARCH_LIMITS), + ("pathological::nc-dos-1", NEEDS_CHAIN_SEARCH_LIMITS), + ("pathological::nc-dos-2", NEEDS_CHAIN_SEARCH_LIMITS), + ("pathological::nc-dos-3", NEEDS_CHAIN_SEARCH_LIMITS), + ("pathological::pathological-chain-distinct-subject-distinct-key", NEEDS_CHAIN_SEARCH_LIMITS), + ("pathological::pathological-chain-same-subject-distinct-key", NEEDS_CHAIN_SEARCH_LIMITS), + ("pathological::pathological-chain-distinct-subject-same-key", NEEDS_CHAIN_SEARCH_LIMITS), + ("pathological::pathological-chain-same-subject-same-key", NEEDS_CHAIN_SEARCH_LIMITS), + ("rfc5280::aki::critical-aki", NEEDS_PATH_VALIDATION), + ("rfc5280::aki::leaf-missing-aki", NEEDS_PATH_VALIDATION), + ("rfc5280::aki::intermediate-missing-aki", NEEDS_PATH_VALIDATION), + ("rfc5280::aki::cross-signed-root-missing-aki", NEEDS_PATH_VALIDATION), + ("rfc5280::eku::ee-wrong-eku", NEEDS_PATH_VALIDATION), + ("rfc5280::eku::ee-eku-empty", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::permitted-dns-mismatch", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::excluded-dns-match", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::permitted-dns-match-noncritical", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::excluded-dns-match-second", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::permitted-ip-mismatch", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::excluded-ipv4-match", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::excluded-ipv6-match", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::permitted-dn-mismatch", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::excluded-dn-match", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::permitted-dn-match", NO_PEER_NAME), + ("rfc5280::nc::permitted-dn-match-subject-san-mismatch", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::excluded-dn-match-sub-mismatch", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::excluded-self-issued-leaf", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::excluded-match-permitted-and-excluded", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::permitted-empty-sequence-excluded-nonempty", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::permitted-nonempty-excluded-empty-sequence", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::invalid-dnsname-wildcard", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::invalid-dnsname-leading-period", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::invalid-ipv4-address", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::invalid-ipv6-address", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::invalid-email-address", NEEDS_CLIENT_VALIDATION), + ("rfc5280::nc::not-allowed-in-ee-noncritical", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::not-allowed-in-ee-critical", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::intermediate-with-san-rejected-by-intermediate-nc", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::intermediate-with-san-rejected-by-root-nc", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::restrictive-permits-in-intermediates-narrows", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::restrictive-permits-in-intermediates-widens", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::nc-permits-invalid-dns-san", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::nc-permits-invalid-ip-san", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::nc-permits-invalid-email-san", NEEDS_CLIENT_VALIDATION), + ("rfc5280::nc::nc-permits-email-exact", NEEDS_CLIENT_VALIDATION), + ("rfc5280::nc::nc-permits-email-domain", NEEDS_CLIENT_VALIDATION), + ("rfc5280::nc::nc-permits-email-domain-rejects-subdomain", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::nc-permits-email-subdomains-rejects-apex", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::nc-permits-email-literal-asterisk-exact-match", NEEDS_CLIENT_VALIDATION), + ("rfc5280::nc::nc-permits-email-literal-asterisk-rejects-user", NEEDS_CLIENT_VALIDATION), + ("rfc5280::nc::nc-permits-email-literal-asterisk-rejects-subdomain", NEEDS_CLIENT_VALIDATION), + ("rfc5280::nc::nc-permits-email-literal-double-asterisk", NEEDS_CLIENT_VALIDATION), + ("rfc5280::nc::nc-permits-email-literal-double-asterisk-rejects-single", NEEDS_CLIENT_VALIDATION), + ("rfc5280::nc::nc-permits-email-literal-mid-asterisk", NEEDS_CLIENT_VALIDATION), + ("rfc5280::nc::nc-permits-uri-host-rejects-subdomain", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::nc-permits-uri-subdomains-rejects-apex", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::nc-forbids-othername", NEEDS_PATH_VALIDATION), + ("rfc5280::nc::nc-forbids-dnsname-wildcard-san", NEEDS_PATH_VALIDATION), + ("rfc5280::pc::ica-noncritical-pc", NEEDS_PATH_VALIDATION), + ("rfc5280::san::malformed", NEEDS_PATH_VALIDATION), + ("rfc5280::san::noncritical-with-empty-subject", NEEDS_PATH_VALIDATION), + ("rfc5280::san::underscore-dns", NEEDS_PATH_VALIDATION), + ("rfc5280::san::ip-in-dns", NEEDS_PATH_VALIDATION), + ("rfc5280::serial::too-long", NEEDS_PATH_VALIDATION), + ("rfc5280::serial::zero", NEEDS_PATH_VALIDATION), + ("rfc5280::serial::negative", NEEDS_PATH_VALIDATION), + ("rfc5280::ski::critical-ski", NEEDS_PATH_VALIDATION), + ("rfc5280::ski::root-missing-ski", NEEDS_PATH_VALIDATION), + ("rfc5280::ski::intermediate-missing-ski", NEEDS_PATH_VALIDATION), + ("rfc5280::validity::expired-root", NEEDS_PATH_VALIDATION), + ("rfc5280::validity::expired-intermediate", NEEDS_PATH_VALIDATION), + ("rfc5280::validity::expired-leaf", NEEDS_PATH_VALIDATION), + ("rfc5280::validity::notbefore-fractional", NEEDS_PATH_VALIDATION), + ("rfc5280::validity::expired-1-second", NEEDS_PATH_VALIDATION), + ("rfc5280::validity::expired-5-seconds", NEEDS_PATH_VALIDATION), + ("rfc5280::validity::not-yet-valid-1-second", NEEDS_PATH_VALIDATION), + ("rfc5280::validity::not-yet-valid-5-seconds", NEEDS_PATH_VALIDATION), + ("rfc5280::ee-empty-issuer", NEEDS_PATH_VALIDATION), + ("rfc5280::ca-empty-subject", NEEDS_PATH_VALIDATION), + ("rfc5280::unknown-critical-extension-ee", NEEDS_PATH_VALIDATION), + ("rfc5280::unknown-critical-extension-root", NEEDS_PATH_VALIDATION), + ("rfc5280::unknown-critical-extension-intermediate", NEEDS_PATH_VALIDATION), + ("rfc5280::chain-untrusted-root", NEEDS_PATH_VALIDATION), + ("rfc5280::intermediate-ca-without-ca-bit", NEEDS_PATH_VALIDATION), + ("rfc5280::intermediate-ca-missing-basic-constraints", NEEDS_PATH_VALIDATION), + ("rfc5280::root-missing-basic-constraints", NEEDS_PATH_VALIDATION), + ("rfc5280::root-non-critical-basic-constraints", NEEDS_PATH_VALIDATION), + ("rfc5280::root-inconsistent-ca-extensions", NEEDS_PATH_VALIDATION), + ("rfc5280::ica-ku-keycertsign", NEEDS_PATH_VALIDATION), + ("rfc5280::leaf-ku-keycertsign", NEEDS_PATH_VALIDATION), + ("rfc5280::ee-critical-aia-invalid", NEEDS_PATH_VALIDATION), + ("rfc5280::duplicate-extensions", NEEDS_PATH_VALIDATION), + ("rfc5280::mismatching-signature-algorithm", NEEDS_PATH_VALIDATION), + ("rfc5280::ca-as-leaf-wrong-san", NEEDS_PATH_VALIDATION), + ("rfc9881::ml-dsa-44-bad-signature", NEEDS_MLDSA), + ("rfc9881::ml-dsa-44-key-encipherment", NEEDS_MLDSA), + ("rfc9881::ml-dsa-44-key-agreement", NEEDS_MLDSA), + ("webpki::aki::root-with-aki-missing-keyidentifier", NEEDS_PATH_VALIDATION), + ("webpki::aki::root-with-aki-authoritycertissuer", NEEDS_PATH_VALIDATION), + ("webpki::aki::root-with-aki-authoritycertserialnumber", NEEDS_PATH_VALIDATION), + ("webpki::aki::root-with-aki-all-fields", NEEDS_PATH_VALIDATION), + ("webpki::aki::root-with-aki-ski-mismatch", NEEDS_PATH_VALIDATION), + ("webpki::cn::ipv4-hex-mismatch", NEEDS_PATH_VALIDATION), + ("webpki::cn::ipv4-leading-zeros-mismatch", NEEDS_PATH_VALIDATION), + ("webpki::cn::ipv6-uppercase-mismatch", NEEDS_PATH_VALIDATION), + ("webpki::cn::ipv6-uncompressed-mismatch", NEEDS_PATH_VALIDATION), + ("webpki::cn::ipv6-non-rfc5952-mismatch", NEEDS_PATH_VALIDATION), + ("webpki::cn::punycode-not-in-san", NEEDS_PATH_VALIDATION), + ("webpki::cn::utf8-vs-punycode-mismatch", NEEDS_PATH_VALIDATION), + ("webpki::cn::not-in-san", NEEDS_PATH_VALIDATION), + ("webpki::cn::case-mismatch", NEEDS_PATH_VALIDATION), + ("webpki::eku::ee-anyeku", NEEDS_PATH_VALIDATION), + ("webpki::eku::ee-critical-eku", NEEDS_PATH_VALIDATION), + ("webpki::eku::ee-without-eku", NEEDS_PATH_VALIDATION), + ("webpki::eku::root-has-eku", NEEDS_PATH_VALIDATION), + ("webpki::nc::intermediate-permitted-excluded-subtrees-both-null", NEEDS_PATH_VALIDATION), + ("webpki::nc::intermediate-permitted-excluded-subtrees-both-empty-sequences", NEEDS_PATH_VALIDATION), + ("webpki::san::mismatch-domain-san", NEEDS_PATH_VALIDATION), + ("webpki::san::mismatch-subdomain-san", NEEDS_PATH_VALIDATION), + ("webpki::san::mismatch-subdomain-apex-san", NEEDS_PATH_VALIDATION), + ("webpki::san::mismatch-apex-subdomain-san", NEEDS_PATH_VALIDATION), + ("webpki::san::public-suffix-wildcard-san", NEEDS_PATH_VALIDATION), + ("webpki::san::public-suffix-multi-label-wildcard-san", NEEDS_PATH_VALIDATION), + ("webpki::san::public-suffix-private-namespace-wildcard-san", NEEDS_PATH_VALIDATION), + ("webpki::san::wildcard-embedded-leftmost-san", NEEDS_PATH_VALIDATION), + ("webpki::san::wildcard-not-in-leftmost-san", NEEDS_PATH_VALIDATION), + ("webpki::san::wildcard-match-across-labels-san", NEEDS_PATH_VALIDATION), + ("webpki::san::wildcard-embedded-ulabel-san", NEEDS_PATH_VALIDATION), + ("webpki::san::unicode-emoji-san", NEEDS_PATH_VALIDATION), + ("webpki::san::no-san", NEEDS_PATH_VALIDATION), + ("webpki::san::san-critical-with-nonempty-subject", NEEDS_PATH_VALIDATION), + ("webpki::san::san-wildcard-only", NEEDS_PATH_VALIDATION), + ("webpki::san::san-wildcard-only-tld", NEEDS_PATH_VALIDATION), + ("webpki::explicit-curve", NEEDS_PATH_VALIDATION), + ("webpki::cryptographydotio-chain-missing-intermediate", NEEDS_PATH_VALIDATION), + ("webpki::malformed-aia", NEEDS_PATH_VALIDATION), + ("webpki::forbidden-p192-root", NEEDS_PATH_VALIDATION), + ("webpki::forbidden-p192-leaf", NEEDS_PATH_VALIDATION), + ("webpki::forbidden-dsa-root", NEEDS_PATH_VALIDATION), + ("webpki::forbidden-dsa-leaf", NEEDS_PATH_VALIDATION), + ("webpki::forbidden-weak-rsa-key-in-root", NEEDS_PATH_VALIDATION), + ("webpki::forbidden-weak-rsa-in-leaf", NEEDS_PATH_VALIDATION), + ("webpki::forbidden-rsa-not-divisible-by-8-in-root", NEEDS_PATH_VALIDATION), + ("webpki::forbidden-rsa-key-not-divisible-by-8-in-leaf", NEEDS_PATH_VALIDATION), + ("webpki::v1-cert", NEEDS_PATH_VALIDATION), + ("webpki::ee-basicconstraints-ca", NEEDS_PATH_VALIDATION), + ("webpki::ca-as-leaf", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc10", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc11", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc12", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc13", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc14", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc15", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc16", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc17", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc18", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc19", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc20", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc21", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc22", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc23", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc24", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc25", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc26", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc27", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc28", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc29", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc30", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc31", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc32", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc33", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc34", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc35", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc36", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc37", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc38", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc39", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc40", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc41", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc42", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc43", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc44", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc45", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc46", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc47", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc48", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc49", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc50", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc51", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc52", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc53", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc54", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc55", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc56", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc57", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc58", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc59", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc60", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc61", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc62", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc63", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc64", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc65", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc66", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc67", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc68", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc69", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc70", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc71", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc72", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc73", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc74", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc75", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc76", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc77", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc78", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc79", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc80", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc81", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc82", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc83", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc84", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc85", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc86", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc87", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc88", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc89", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc90", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc91", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc92", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc93", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc94", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc95", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc96", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc97", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc98", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc99", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc100", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc101", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc102", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc103", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc104", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc105", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc106", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc107", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc108", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc109", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc110", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc111", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc112", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc113", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc114", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc115", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc116", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc117", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc118", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc119", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc120", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc121", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc122", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc123", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc124", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc125", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc126", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc127", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc128", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc129", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc130", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc131", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc132", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc133", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc134", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc135", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc136", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc137", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc138", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc139", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc140", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc141", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc142", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc143", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc144", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc145", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc146", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc147", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc148", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc149", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc150", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc151", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc152", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc153", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc154", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc155", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc156", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc157", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc158", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc159", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc160", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc161", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc162", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc163", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc164", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc165", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc166", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc167", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc168", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc169", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc170", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc171", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc172", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc173", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc174", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc175", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc176", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc177", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc178", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc179", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc180", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc181", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc182", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc183", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc184", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc185", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc186", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc187", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc188", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc189", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc190", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc191", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc192", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc193", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc194", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc195", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc196", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc197", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc198", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc199", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc200", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc201", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc202", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc203", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc204", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc205", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc206", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc207", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc208", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc209", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc210", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc211", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc212", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc213", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc214", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc215", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc216", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc217", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc218", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc219", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc220", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc221", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc222", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc223", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc224", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc225", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc226", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc227", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc228", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc229", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc230", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc231", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc232", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc233", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc234", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc235", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc236", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc237", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc238", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc239", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc240", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc241", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc242", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc243", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc244", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc245", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc246", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc247", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc248", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc249", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc253", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc254", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc255", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc262", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc263", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc264", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc271", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc272", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc273", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc280", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc281", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc282", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc289", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc290", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc291", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc298", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc299", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc300", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc304", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc305", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc306", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc307", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc308", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc309", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc310", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc311", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc312", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc313", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc314", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc315", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc316", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc317", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc318", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc319", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc320", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc321", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc322", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc323", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc324", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc325", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc326", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc327", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc328", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc329", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc330", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc332", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc334", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc335", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc336", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc338", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc341", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc343", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc344", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc345", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc347", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc349", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc350", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc351", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc352", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc353", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc354", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc355", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc356", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc357", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc359", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc361", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc362", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc363", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc365", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc368", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc370", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc371", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc372", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc374", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc376", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc377", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc378", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc379", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc380", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc381", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc382", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc383", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc384", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc385", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc386", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc387", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc388", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc389", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc390", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc391", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc392", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc393", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc394", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc395", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc396", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc397", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc398", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc399", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc400", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc401", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc402", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc403", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc404", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc405", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc406", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc407", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc408", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc409", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc410", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc411", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc414", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc415", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc416", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc417", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc420", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc421", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc422", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc423", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc424", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc425", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc426", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc427", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc428", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc429", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc432", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc433", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc434", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc435", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc438", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc441", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc442", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc443", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc444", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc447", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc448", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc449", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc450", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc451", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc452", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc453", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc454", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc455", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc456", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc459", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc460", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc461", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc462", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc465", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc466", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc467", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc468", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc469", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc470", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc471", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc472", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc473", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc474", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc475", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc476", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc477", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc478", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc479", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc480", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc481", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc482", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc483", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc484", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc485", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc486", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc487", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc488", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc489", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc490", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc491", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc492", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc493", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc494", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc495", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc496", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc497", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc498", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc499", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc500", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc501", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc502", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc503", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc504", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc505", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc506", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc507", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc508", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc509", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc510", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc511", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc512", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc513", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc514", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc515", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc516", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc517", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc518", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc519", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc520", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc521", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc522", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc523", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc524", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc525", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc526", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc527", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc528", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc529", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc530", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc531", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc532", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc533", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc534", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc535", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc536", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc537", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc538", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc539", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc540", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc541", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc542", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc543", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc544", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc545", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc546", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc547", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc548", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc549", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc550", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc551", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc552", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc553", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc554", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc555", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc556", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc557", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc558", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc559", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc560", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc561", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc562", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc563", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc564", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc565", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc566", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc567", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc568", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc569", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc570", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc571", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc572", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc573", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc574", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc575", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc576", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc577", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc578", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc579", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc580", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc581", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc582", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc583", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc584", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc585", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc586", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc587", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc588", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc589", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc590", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc591", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc592", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc593", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc594", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc595", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc596", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc597", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc598", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc599", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc600", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc601", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc602", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc603", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc604", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc605", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc606", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc607", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc608", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc609", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc610", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc611", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc612", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc613", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc614", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc615", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc616", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc617", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc618", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc619", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc620", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc621", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc622", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc623", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc624", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc625", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc626", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc627", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc628", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc629", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc630", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc631", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc632", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc633", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc634", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc635", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc636", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc637", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc638", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc639", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc640", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc641", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc642", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc643", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc644", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc645", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc646", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc647", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc648", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc649", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc650", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc651", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc652", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc653", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc654", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc655", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc656", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc657", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc658", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc659", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc660", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc661", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc662", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc663", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc664", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc665", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc666", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc667", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc668", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc669", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc670", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc671", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc672", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc673", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc674", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc675", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc676", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc677", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc678", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc679", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc680", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc681", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc682", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc683", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc684", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc685", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc686", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc687", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc688", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc689", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc690", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc691", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc692", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc693", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc694", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc695", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc696", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc697", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc698", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc699", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc700", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc701", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc702", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc703", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc704", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc705", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc706", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc707", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc708", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc709", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc710", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc711", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc712", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc713", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc714", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc715", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc716", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc717", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc718", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc719", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc720", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc721", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc722", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc723", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc724", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc725", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc726", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc727", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc728", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc729", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc730", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc731", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc732", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc733", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc734", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc735", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc736", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc737", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc738", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc739", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc740", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc741", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc742", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc743", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc744", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc745", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc746", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc747", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc748", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc749", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc750", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc751", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc752", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc753", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc754", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc755", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc756", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc757", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc758", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc759", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc760", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc761", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc762", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc763", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc764", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc765", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc766", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc767", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc768", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc769", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc770", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc771", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc772", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc773", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc774", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc775", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc776", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc777", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc778", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc779", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc780", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc781", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc782", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc783", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc784", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc785", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc786", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc787", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc788", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc789", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc790", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc791", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc792", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc793", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc794", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc795", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc796", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc797", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc798", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc799", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc800", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc801", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc802", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc803", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc804", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc805", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc806", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc807", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc808", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc809", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc810", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc811", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc812", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc813", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc814", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc815", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc816", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc817", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc818", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc819", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc820", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc821", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc822", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc823", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc824", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc825", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc826", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc827", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc828", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc829", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc830", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc831", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc832", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc833", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc834", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc835", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc836", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc837", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc838", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc839", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc840", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc841", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc842", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc843", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc844", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc845", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc846", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc847", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc848", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc849", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc850", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc851", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc852", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc853", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc854", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc855", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc856", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc857", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc858", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc859", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc860", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc861", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc862", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc863", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc864", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc865", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc866", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc867", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc868", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc869", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc870", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc871", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc872", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc873", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc874", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc875", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc876", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc877", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc878", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc879", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc880", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc881", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc882", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc883", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc884", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc885", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc886", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc887", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc888", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc889", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc890", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc891", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc892", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc893", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc894", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc895", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc896", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc897", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc898", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc899", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc900", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc901", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc902", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc903", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc904", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc905", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc906", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc907", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc908", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc909", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc910", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc911", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc912", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc913", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc914", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc915", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc916", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc917", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc918", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc919", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc920", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc921", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc922", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc923", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc924", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc925", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc926", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc927", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc928", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc929", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc930", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc931", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc932", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc933", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc934", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc935", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc936", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc937", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc938", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc939", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc940", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc941", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc942", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc943", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc944", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc945", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc946", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc947", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc948", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc949", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc950", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc951", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc952", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc953", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc954", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc955", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc956", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc957", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc958", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc959", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc960", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc961", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc962", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc963", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc964", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc965", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc966", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc967", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc968", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc969", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc970", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc971", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc972", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc973", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc974", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc975", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc976", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc977", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc978", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc982", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc983", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc984", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc991", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc992", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc993", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1000", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1001", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1002", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1009", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1010", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1011", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1018", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1019", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1020", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1027", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1028", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1029", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1033", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1034", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1035", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1036", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1037", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1038", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1039", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1040", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1041", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1042", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1043", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1044", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1045", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1046", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1047", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1048", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1049", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1050", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1051", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1052", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1053", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1054", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1055", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1056", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1057", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1058", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1059", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1061", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1063", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1064", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1065", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1067", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1070", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1072", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1073", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1074", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1076", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1078", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1079", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1080", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1081", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1082", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1083", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1084", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1085", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1086", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1088", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1090", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1091", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1092", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1094", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1097", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1099", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1100", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1101", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1103", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1105", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1106", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1107", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1108", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1109", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1110", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1111", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1112", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1113", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1114", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1115", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1116", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1117", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1118", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1119", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1120", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1121", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1122", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1123", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1124", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1125", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1126", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1127", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1128", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1129", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1130", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1131", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1132", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1133", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1134", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1135", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1136", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1137", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1138", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1139", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1140", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1143", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1144", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1145", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1146", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1149", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1150", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1151", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1152", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1153", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1154", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1155", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1156", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1157", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1158", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1161", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1162", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1163", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1164", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1167", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1170", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1171", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1172", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1173", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1176", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1177", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1178", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1179", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1180", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1181", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1182", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1183", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1184", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1185", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1188", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1189", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1190", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1191", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1194", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1195", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1196", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1197", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1198", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1199", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1200", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1201", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1202", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1203", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1204", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1205", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1206", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1207", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1208", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1209", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1210", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1211", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1212", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1213", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1214", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1215", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1216", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1217", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1218", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1219", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1220", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1221", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1222", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1223", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1224", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1225", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1226", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1227", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1228", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1229", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1230", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1231", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1232", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1233", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1234", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1235", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1236", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1237", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1238", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1239", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1240", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1241", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1242", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1243", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1244", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1245", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1246", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1247", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1248", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1249", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1250", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1251", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1252", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1253", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1254", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1255", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1256", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1257", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1258", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1259", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1260", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1261", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1262", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1263", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1264", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1265", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1266", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1267", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1268", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1269", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1270", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1271", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1272", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1273", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1274", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1275", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1276", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1277", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1278", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1279", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1280", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1281", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1282", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1283", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1284", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1285", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1286", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1287", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1288", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1289", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1290", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1291", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1292", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1293", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1294", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1295", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1296", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1297", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1298", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1299", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1300", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1301", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1302", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1303", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1304", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1305", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1306", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1307", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1308", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1309", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1310", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1311", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1312", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1313", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1314", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1315", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1316", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1317", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1318", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1319", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1320", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1321", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1322", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1323", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1324", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1325", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1326", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1327", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1328", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1329", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1330", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1331", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1332", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1333", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1334", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1335", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1336", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1337", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1338", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1339", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1340", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1341", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1342", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1343", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1344", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1345", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1346", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1347", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1348", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1349", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1350", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1351", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1352", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1353", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1354", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1355", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1356", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1357", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1358", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1359", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1360", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1361", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1362", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1363", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1364", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1365", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1366", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1367", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1368", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1369", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1370", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1371", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1372", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1373", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1374", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1375", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1376", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1377", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1378", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1379", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1380", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1381", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1382", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1383", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1384", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1385", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1386", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1387", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1388", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1389", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1390", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1391", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1392", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1393", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1394", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1395", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1396", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1397", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1398", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1399", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1400", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1401", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1402", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1403", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1404", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1405", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1406", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1407", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1408", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1409", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1410", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1411", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1412", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1413", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1414", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1415", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1416", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1417", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1418", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1419", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1420", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1421", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1422", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1423", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1424", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1425", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1426", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1427", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1428", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1429", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1430", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1431", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1432", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1433", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1434", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1435", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1436", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1437", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1438", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1439", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1440", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1441", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1442", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1443", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1444", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1445", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1446", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1447", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1448", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1449", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1450", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1451", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1452", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1453", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1454", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1455", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1456", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1457", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1458", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1459", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1460", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1461", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1462", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1463", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1464", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1465", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1466", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1467", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1468", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1469", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1470", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1471", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1472", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1473", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1474", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1475", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1476", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1477", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1478", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1479", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1480", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1481", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1482", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1483", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1484", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1485", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1486", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1487", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1488", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1489", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1490", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1491", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1492", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1493", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1494", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1495", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1496", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1497", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1498", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1499", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1500", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1501", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1502", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1503", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1504", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1505", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1506", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1507", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1508", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1509", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1510", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1511", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1512", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1513", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1514", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1515", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1516", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1517", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1518", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1519", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1520", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1521", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1522", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1523", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1524", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1525", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1526", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1527", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1528", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1529", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1530", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1531", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1532", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1533", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1534", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1535", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1536", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1537", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1538", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1539", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1540", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1541", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1542", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1543", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1544", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1545", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1546", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1547", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1548", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1549", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1550", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1551", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1552", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1553", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1554", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1555", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1556", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1557", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1558", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1559", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1560", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1561", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1562", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1563", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1564", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1565", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1566", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1567", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1568", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1569", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1570", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1571", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1572", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1573", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1574", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1575", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1576", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1577", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1578", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1579", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1580", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1581", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1582", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1583", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1584", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1585", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1586", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1587", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1588", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1589", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1590", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1591", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1592", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1593", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1594", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1595", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1596", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1597", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1598", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1599", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1600", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1601", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1602", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1603", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1604", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1605", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1606", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1607", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1608", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1609", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1610", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1611", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1612", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1613", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1614", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1615", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1616", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1617", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1618", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1619", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1620", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1621", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1622", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1623", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1624", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1625", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1626", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1627", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1628", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1629", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1630", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1631", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1632", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1633", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1634", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1635", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1636", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1637", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1638", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1639", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1640", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1641", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1642", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1643", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1644", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1645", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1646", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1647", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1648", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1649", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1650", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1651", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1652", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1653", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1654", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1655", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1656", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1657", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1658", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1659", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1660", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1661", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1662", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1663", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1664", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1665", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1666", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1667", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1668", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1669", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1670", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1671", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1672", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1673", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1674", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1675", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1676", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1677", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1678", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1679", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1680", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1681", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1682", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1683", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1684", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1685", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1686", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1687", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1688", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1689", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1690", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1691", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1692", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1693", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1694", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1695", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1696", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1697", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1698", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1699", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1700", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1701", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1702", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1703", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1704", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1705", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1706", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1707", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1711", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1712", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1713", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1720", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1721", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1722", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1729", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1730", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1731", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1738", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1739", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1740", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1747", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1748", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1749", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1756", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1757", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1758", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1762", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1763", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1764", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1765", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1766", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1767", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1768", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1769", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1770", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1771", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1772", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1773", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1774", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1775", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1776", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1777", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1778", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1779", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1780", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1781", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1782", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1783", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1784", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1785", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1786", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1787", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1788", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1790", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1792", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1793", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1794", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1796", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1799", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1801", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1802", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1803", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1805", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1807", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1808", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1809", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1810", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1811", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1812", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1813", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1814", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1815", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1817", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1819", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1820", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1821", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1823", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1826", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1828", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1829", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1830", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1832", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1834", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1835", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1836", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1837", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1838", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1839", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1840", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1841", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1842", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1843", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1844", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1845", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1846", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1847", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1848", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1849", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1850", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1851", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1852", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1853", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1854", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1855", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1856", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1857", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1858", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1859", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1860", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1861", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1862", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1863", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1864", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1865", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1866", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1867", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1868", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1869", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1872", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1873", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1874", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1875", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1878", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1879", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1880", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1881", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1882", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1883", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1884", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1885", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1886", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1887", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1890", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1891", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1892", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1893", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1896", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1899", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1900", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1901", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1902", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1905", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1906", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1907", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1908", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1909", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1910", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1911", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1912", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1913", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1914", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1917", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1918", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1919", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1920", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1923", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1924", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1925", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1926", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1927", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1928", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1929", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1930", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1931", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1932", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1933", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1934", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1935", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1936", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1937", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1938", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1939", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1940", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1941", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1942", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1943", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1944", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1945", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1946", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1947", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1948", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1949", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1950", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1951", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1952", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1953", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1954", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1955", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1956", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1957", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1958", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1959", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1960", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1961", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1962", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1963", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1964", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1965", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1966", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1967", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1968", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1969", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1970", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1971", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1972", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1973", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1974", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1975", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1976", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1977", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1978", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1979", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1980", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1981", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1982", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1983", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1984", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1985", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1986", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1987", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1988", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1989", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1990", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1991", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1992", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1993", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1994", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1995", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1996", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1997", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1998", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc1999", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2000", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2001", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2002", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2003", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2004", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2005", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2006", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2007", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2008", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2009", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2010", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2011", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2012", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2013", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2014", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2015", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2016", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2017", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2018", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2019", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2020", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2021", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2022", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2023", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2024", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2025", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2026", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2027", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2028", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2029", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2030", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2031", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2032", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2033", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2034", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2035", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2036", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2037", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2038", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2039", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2040", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2041", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2042", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2043", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2044", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2045", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2046", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2047", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2048", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2049", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2050", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2051", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2052", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2053", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2054", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2055", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2056", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2057", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2058", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2059", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2060", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2061", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2062", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2063", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2064", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2065", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2066", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2067", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2068", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2069", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2070", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2071", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2072", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2073", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2074", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2075", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2076", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2077", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2078", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2079", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2080", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2081", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2082", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2083", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2084", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2085", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2086", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2087", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2088", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2089", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2090", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2091", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2092", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2093", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2094", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2095", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2096", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2097", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2098", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2099", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2100", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2101", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2102", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2103", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2104", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2105", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2106", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2107", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2108", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2109", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2110", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2111", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2112", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2113", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2114", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2115", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2116", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2117", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2118", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2119", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2120", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2121", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2122", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2123", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2124", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2125", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2126", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2127", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2128", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2129", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2130", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2131", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2132", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2133", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2134", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2135", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2136", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2137", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2138", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2139", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2140", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2141", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2142", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2143", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2144", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2145", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2146", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2147", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2148", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2149", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2150", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2151", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2152", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2153", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2154", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2155", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2156", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2157", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2158", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2159", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2160", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2161", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2162", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2163", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2164", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2165", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2166", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2167", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2168", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2169", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2170", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2171", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2172", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2173", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2174", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2175", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2176", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2177", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2178", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2179", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2180", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2181", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2182", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2183", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2184", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2185", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2186", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2187", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2188", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2189", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2190", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2191", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2192", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2193", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2194", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2195", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2196", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2197", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2198", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2199", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2200", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2201", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2202", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2203", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2204", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2205", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2206", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2207", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2208", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2209", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2210", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2211", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2212", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2213", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2214", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2215", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2216", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2217", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2218", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2219", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2220", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2221", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2222", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2223", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2224", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2225", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2226", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2227", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2228", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2229", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2230", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2231", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2232", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2233", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2234", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2235", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2236", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2237", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2238", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2239", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2240", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2241", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2242", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2243", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2244", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2245", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2246", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2247", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2248", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2249", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2250", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2251", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2252", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2253", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2254", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2255", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2256", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2257", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2258", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2259", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2260", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2261", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2262", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2263", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2264", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2265", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2266", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2267", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2268", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2269", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2270", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2271", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2272", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2273", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2274", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2275", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2276", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2277", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2278", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2279", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2280", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2281", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2282", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2283", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2284", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2285", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2286", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2287", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2288", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2289", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2290", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2291", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2292", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2293", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2294", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2295", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2296", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2297", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2298", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2299", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2300", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2301", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2302", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2303", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2304", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2305", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2306", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2307", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2308", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2309", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2310", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2311", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2312", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2313", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2314", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2315", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2316", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2317", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2318", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2319", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2320", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2321", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2322", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2323", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2324", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2325", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2326", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2327", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2328", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2329", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2330", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2331", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2332", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2333", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2334", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2335", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2336", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2337", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2338", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2339", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2340", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2341", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2342", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2343", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2344", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2345", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2346", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2347", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2348", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2349", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2350", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2351", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2352", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2353", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2354", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2355", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2356", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2357", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2358", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2359", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2360", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2361", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2362", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2363", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2364", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2365", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2366", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2367", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2368", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2369", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2370", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2371", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2372", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2373", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2374", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2375", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2376", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2377", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2378", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2379", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2380", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2381", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2382", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2383", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2384", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2385", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2386", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2387", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2388", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2389", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2390", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2391", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2392", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2393", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2394", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2395", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2396", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2397", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2398", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2399", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2400", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2401", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2402", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2403", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2404", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2405", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2406", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2407", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2408", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2409", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2410", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2411", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2412", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2413", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2414", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2415", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2416", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2417", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2418", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2419", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2420", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2421", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2422", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2423", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2424", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2425", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2426", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2427", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2428", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2429", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2430", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2431", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2432", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2433", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2434", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2435", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2436", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2440", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2441", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2442", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2449", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2450", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2451", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2458", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2459", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2460", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2467", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2468", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2469", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2476", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2477", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2478", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2485", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2486", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2487", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2491", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2492", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2493", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2494", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2495", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2496", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2497", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2498", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2499", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2500", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2501", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2502", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2503", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2504", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2505", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2506", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2507", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2508", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2509", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2510", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2511", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2512", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2513", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2514", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2515", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2516", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2517", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2519", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2521", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2522", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2523", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2525", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2528", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2530", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2531", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2532", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2534", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2536", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2537", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2538", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2539", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2540", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2541", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2542", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2543", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2544", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2546", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2548", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2549", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2550", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2552", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2555", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2557", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2558", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2559", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2561", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2563", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2564", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2565", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2566", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2567", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2568", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2569", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2570", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2571", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2572", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2573", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2574", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2575", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2576", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2577", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2578", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2579", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2580", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2581", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2582", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2583", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2584", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2585", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2586", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2587", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2588", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2589", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2590", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2591", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2592", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2593", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2594", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2595", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2596", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2597", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2598", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2601", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2602", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2603", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2604", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2607", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2608", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2609", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2610", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2611", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2612", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2613", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2614", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2615", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2616", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2619", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2620", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2621", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2622", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2625", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2628", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2629", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2630", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2631", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2634", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2635", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2636", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2637", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2638", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2639", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2640", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2641", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2642", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2643", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2646", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2647", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2648", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2649", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2652", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2653", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2654", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2655", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2656", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2657", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2658", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2659", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2660", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2661", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2662", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2663", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2664", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2665", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2666", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2667", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2668", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2669", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2670", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2671", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2672", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2673", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2674", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2675", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2676", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2677", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2678", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2679", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2680", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2681", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2682", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2683", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2684", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2685", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2686", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2687", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2688", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2689", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2690", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2691", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2692", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2693", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2694", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2695", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2696", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2697", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2698", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2699", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2700", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2701", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2702", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2703", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2704", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2705", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2706", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2707", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2708", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2709", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2710", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2711", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2712", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2713", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2714", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2715", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2716", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2717", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2718", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2719", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2720", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2721", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2722", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2723", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2724", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2725", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2726", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2727", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2728", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2729", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2730", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2731", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2732", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2733", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2734", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2735", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2736", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2737", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2738", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2739", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2740", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2741", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2742", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2743", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2744", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2745", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2746", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2747", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2748", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2749", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2750", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2751", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2752", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2753", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2754", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2755", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2756", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2757", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2758", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2759", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2760", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2761", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2762", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2763", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2764", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2765", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2766", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2767", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2768", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2769", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2770", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2771", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2772", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2773", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2774", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2775", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2776", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2777", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2778", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2779", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2780", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2781", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2782", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2783", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2784", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2785", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2786", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2787", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2788", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2789", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2790", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2791", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2792", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2793", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2794", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2795", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2796", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2797", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2798", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2799", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2800", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2801", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2802", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2803", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2804", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2805", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2806", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2807", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2808", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2809", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2810", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2811", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2812", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2813", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2814", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2815", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2816", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2817", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2818", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2819", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2820", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2821", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2822", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2823", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2824", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2825", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2826", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2827", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2828", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2829", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2830", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2831", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2832", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2833", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2834", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2835", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2836", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2837", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2838", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2839", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2840", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2841", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2842", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2843", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2844", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2845", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2846", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2847", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2848", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2849", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2850", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2851", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2852", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2853", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2854", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2855", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2856", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2857", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2858", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2859", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2860", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2861", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2862", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2863", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2864", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2865", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2866", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2867", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2868", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2869", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2870", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2871", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2872", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2873", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2874", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2875", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2876", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2877", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2878", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2879", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2880", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2881", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2882", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2883", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2884", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2885", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2886", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2887", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2888", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2889", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2890", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2891", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2892", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2893", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2894", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2895", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2896", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2897", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2898", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2899", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2900", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2901", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2902", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2903", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2904", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2905", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2906", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2907", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2908", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2909", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2910", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2911", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2912", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2913", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2914", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2915", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2916", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2917", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2918", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2919", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2920", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2921", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2922", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2923", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2924", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2925", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2926", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2927", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2928", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2929", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2930", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2931", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2932", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2933", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2934", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2935", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2936", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2937", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2938", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2939", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2940", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2941", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2942", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2943", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2944", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2945", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2946", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2947", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2948", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2949", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2950", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2951", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2952", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2953", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2954", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2955", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2956", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2957", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2958", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2959", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2960", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2961", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2962", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2963", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2964", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2965", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2966", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2967", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2968", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2969", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2970", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2971", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2972", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2973", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2974", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2975", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2976", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2977", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2978", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2979", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2980", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2981", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2982", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2983", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2984", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2985", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2986", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2987", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2988", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2989", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2990", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2991", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2992", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2993", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2994", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2995", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2996", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2997", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2998", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc2999", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3000", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3001", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3002", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3003", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3004", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3005", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3006", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3007", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3008", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3009", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3010", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3011", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3012", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3013", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3014", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3015", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3016", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3017", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3018", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3019", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3020", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3021", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3022", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3023", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3024", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3025", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3026", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3027", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3028", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3029", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3030", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3031", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3032", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3033", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3034", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3035", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3036", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3037", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3038", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3039", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3040", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3041", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3042", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3043", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3044", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3045", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3046", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3047", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3048", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3049", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3050", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3051", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3052", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3053", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3054", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3055", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3056", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3057", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3058", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3059", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3060", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3061", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3062", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3063", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3064", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3065", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3066", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3067", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3068", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3069", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3070", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3071", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3072", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3073", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3074", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3075", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3076", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3077", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3078", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3079", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3080", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3081", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3082", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3083", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3084", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3085", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3086", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3087", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3088", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3089", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3090", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3091", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3092", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3093", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3094", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3095", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3096", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3097", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3098", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3099", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3100", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3101", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3102", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3103", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3104", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3105", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3106", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3107", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3108", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3109", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3110", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3111", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3112", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3113", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3114", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3115", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3116", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3117", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3118", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3119", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3120", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3121", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3122", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3123", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3124", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3125", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3126", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3127", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3128", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3129", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3130", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3131", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3132", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3133", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3134", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3135", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3136", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3137", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3138", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3139", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3140", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3141", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3142", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3143", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3144", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3145", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3146", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3147", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3148", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3149", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3150", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3151", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3152", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3153", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3154", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3155", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3156", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3157", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3158", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3159", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3160", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3161", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3162", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3163", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3164", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3165", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3169", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3170", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3171", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3178", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3179", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3180", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3187", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3188", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3189", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3196", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3197", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3198", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3205", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3206", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3207", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3214", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3215", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3216", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3220", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3221", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3222", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3223", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3224", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3225", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3226", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3227", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3228", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3229", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3230", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3231", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3232", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3233", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3234", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3235", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3236", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3237", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3238", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3239", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3240", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3241", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3242", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3243", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3244", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3245", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3246", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3248", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3250", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3251", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3252", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3254", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3257", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3259", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3260", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3261", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3263", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3265", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3266", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3267", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3268", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3269", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3270", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3271", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3272", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3273", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3275", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3277", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3278", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3279", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3281", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3284", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3286", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3287", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3288", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3290", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3292", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3293", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3294", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3295", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3296", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3297", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3298", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3299", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3300", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3301", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3302", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3303", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3304", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3305", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3306", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3307", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3308", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3309", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3310", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3311", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3312", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3313", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3314", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3315", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3316", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3317", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3318", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3319", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3320", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3321", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3322", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3323", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3324", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3325", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3326", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3327", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3330", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3331", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3332", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3333", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3336", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3337", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3338", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3339", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3340", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3341", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3342", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3343", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3344", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3345", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3348", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3349", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3350", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3351", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3354", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3357", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3358", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3359", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3360", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3363", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3364", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3365", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3366", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3367", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3368", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3369", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3370", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3371", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3372", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3375", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3376", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3377", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3378", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3381", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3382", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3383", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3384", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3385", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3386", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3387", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3388", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3389", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3390", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3391", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3392", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3393", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3394", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3395", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3396", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3397", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3398", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3399", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3400", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3401", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3402", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3403", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3404", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3405", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3406", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3407", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3408", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3409", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3410", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3411", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3412", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3413", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3414", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3415", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3416", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3417", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3418", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3419", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3420", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3421", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3422", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3423", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3424", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3425", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3426", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3427", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3428", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3429", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3430", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3431", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3432", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3433", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3434", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3435", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3436", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3437", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3438", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3439", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3440", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3441", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3442", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3443", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3444", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3445", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3446", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3447", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3448", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3449", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3450", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3451", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3452", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3453", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3454", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3455", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3456", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3457", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3458", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3459", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3460", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3461", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3462", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3463", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3464", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3465", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3466", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3467", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3468", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3469", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3470", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3471", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3472", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3473", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3474", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3475", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3476", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3477", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3478", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3479", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3480", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3481", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3482", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3483", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3484", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3485", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3486", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3487", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3488", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3489", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3490", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3491", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3492", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3493", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3494", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3495", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3496", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3497", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3498", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3499", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3500", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3501", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3502", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3503", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3504", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3505", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3506", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3507", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3508", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3509", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3510", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3511", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3512", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3513", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3514", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3515", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3516", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3517", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3518", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3519", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3520", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3521", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3522", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3523", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3524", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3525", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3526", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3527", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3528", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3529", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3530", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3531", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3532", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3533", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3534", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3535", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3536", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3537", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3538", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3539", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3540", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3541", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3542", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3543", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3544", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3545", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3546", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3547", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3548", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3549", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3550", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3551", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3552", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3553", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3554", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3555", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3556", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3557", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3558", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3559", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3560", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3561", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3562", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3563", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3564", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3565", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3566", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3567", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3568", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3569", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3570", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3571", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3572", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3573", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3574", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3575", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3576", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3577", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3578", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3579", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3580", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3581", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3582", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3583", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3584", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3585", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3586", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3587", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3588", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3589", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3590", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3591", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3592", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3593", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3594", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3595", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3596", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3597", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3598", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3599", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3600", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3601", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3602", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3603", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3604", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3605", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3606", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3607", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3608", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3609", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3610", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3611", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3612", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3613", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3614", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3615", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3616", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3617", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3618", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3619", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3620", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3621", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3622", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3623", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3624", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3625", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3626", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3627", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3628", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3629", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3630", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3631", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3632", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3633", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3634", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3635", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3636", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3637", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3638", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3639", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3640", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3641", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3642", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3643", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3644", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3645", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3646", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3647", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3648", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3649", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3650", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3651", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3652", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3653", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3654", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3655", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3656", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3657", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3658", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3659", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3660", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3661", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3662", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3663", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3664", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3665", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3666", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3667", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3668", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3669", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3670", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3671", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3672", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3673", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3674", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3675", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3676", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3677", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3678", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3679", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3680", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3681", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3682", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3683", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3684", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3685", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3686", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3687", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3688", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3689", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3690", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3691", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3692", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3693", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3694", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3695", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3696", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3697", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3698", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3699", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3700", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3701", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3702", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3703", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3704", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3705", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3706", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3707", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3708", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3709", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3710", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3711", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3712", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3713", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3714", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3715", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3716", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3717", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3718", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3719", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3720", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3721", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3722", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3723", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3724", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3725", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3726", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3727", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3728", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3729", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3730", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3731", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3732", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3733", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3734", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3735", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3736", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3737", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3738", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3739", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3740", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3741", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3742", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3743", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3744", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3745", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3746", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3747", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3748", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3749", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3750", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3751", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3752", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3753", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3754", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3755", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3756", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3757", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3758", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3759", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3760", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3761", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3762", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3763", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3764", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3765", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3766", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3767", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3768", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3769", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3770", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3771", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3772", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3773", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3774", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3775", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3776", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3777", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3778", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3779", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3780", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3781", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3782", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3783", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3784", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3785", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3786", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3787", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3788", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3789", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3790", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3791", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3792", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3793", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3794", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3795", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3796", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3797", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3798", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3799", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3800", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3801", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3802", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3803", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3804", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3805", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3806", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3807", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3808", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3809", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3810", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3811", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3812", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3813", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3814", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3815", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3816", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3817", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3818", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3819", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3820", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3821", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3822", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3823", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3824", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3825", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3826", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3827", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3828", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3829", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3830", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3831", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3832", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3833", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3834", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3835", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3836", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3837", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3838", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3839", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3840", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3841", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3842", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3843", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3844", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3845", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3846", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3847", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3848", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3849", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3850", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3851", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3852", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3853", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3854", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3855", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3856", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3857", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3858", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3859", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3860", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3861", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3862", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3863", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3864", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3865", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3866", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3867", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3868", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3869", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3870", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3871", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3872", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3873", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3874", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3875", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3876", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3877", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3878", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3879", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3880", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3881", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3882", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3883", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3884", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3885", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3886", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3887", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3888", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3889", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3890", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3891", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3892", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3893", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3894", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3898", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3899", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3900", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3907", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3908", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3909", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3916", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3917", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3918", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3925", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3926", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3927", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3934", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3935", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3936", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3943", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3944", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3945", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3949", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3950", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3951", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3952", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3953", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3954", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3955", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3956", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3957", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3958", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3959", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3960", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3961", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3962", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3963", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3964", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3965", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3966", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3967", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3968", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3969", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3970", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3971", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3972", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3973", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3974", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3975", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3977", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3979", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3980", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3981", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3983", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3986", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3988", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3989", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3990", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3992", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3994", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3995", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3996", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3997", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3998", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc3999", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4000", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4001", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4002", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4004", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4006", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4007", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4008", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4010", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4013", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4015", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4016", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4017", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4019", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4021", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4022", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4023", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4024", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4025", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4026", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4027", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4028", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4029", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4030", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4031", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4032", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4033", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4034", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4035", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4036", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4037", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4038", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4039", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4040", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4041", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4042", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4043", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4044", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4045", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4046", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4047", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4048", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4049", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4050", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4051", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4052", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4053", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4054", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4055", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4056", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4059", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4060", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4061", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4062", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4065", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4066", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4067", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4068", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4069", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4070", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4071", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4072", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4073", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4074", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4077", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4078", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4079", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4080", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4083", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4086", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4087", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4088", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4089", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4092", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4093", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4094", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4095", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4096", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4097", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4098", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4099", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4100", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4101", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4104", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4105", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4106", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4107", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4110", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4111", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4112", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4113", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4114", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4115", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4116", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4117", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4118", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4119", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4120", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4121", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4122", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4123", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4124", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4125", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4126", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4127", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4128", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4129", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4130", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4131", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4132", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4133", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4134", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4135", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4136", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4137", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4138", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4139", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4140", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4141", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4142", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4143", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4144", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4145", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4146", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4147", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4148", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4149", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4150", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4151", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4152", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4153", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4154", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4155", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4156", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4157", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4158", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4159", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4160", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4161", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4162", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4163", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4164", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4165", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4166", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4167", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4168", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4169", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4170", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4171", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4172", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4173", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4174", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4175", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4176", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4177", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4178", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4179", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4180", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4181", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4182", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4183", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4184", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4185", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4186", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4187", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4188", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4189", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4190", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4191", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4192", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4193", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4194", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4195", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4196", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4197", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4198", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4199", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4200", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4201", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4202", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4203", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4204", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4205", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4206", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4207", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4208", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4209", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4210", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4211", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4212", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4213", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4214", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4215", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4216", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4217", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4218", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4219", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4220", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4221", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4222", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4223", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4224", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4225", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4226", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4227", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4228", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4229", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4230", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4231", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4232", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4233", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4234", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4235", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4236", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4237", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4238", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4239", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4240", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4241", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4242", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4243", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4244", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4245", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4246", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4247", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4248", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4249", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4250", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4251", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4252", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4253", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4254", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4255", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4256", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4257", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4258", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4259", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4260", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4261", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4262", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4263", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4264", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4265", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4266", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4267", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4268", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4269", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4270", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4271", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4272", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4273", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4274", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4275", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4276", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4277", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4278", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4279", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4280", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4281", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4282", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4283", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4284", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4285", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4286", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4287", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4288", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4289", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4290", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4291", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4292", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4293", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4294", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4295", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4296", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4297", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4298", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4299", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4300", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4301", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4302", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4303", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4304", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4305", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4306", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4307", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4308", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4309", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4310", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4311", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4312", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4313", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4314", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4315", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4316", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4317", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4318", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4319", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4320", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4321", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4322", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4323", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4324", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4325", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4326", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4327", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4328", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4329", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4330", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4331", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4332", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4333", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4334", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4335", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4336", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4337", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4338", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4339", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4340", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4341", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4342", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4343", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4344", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4345", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4346", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4347", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4348", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4349", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4350", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4351", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4352", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4353", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4354", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4355", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4356", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4357", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4358", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4359", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4360", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4361", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4362", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4363", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4364", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4365", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4366", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4367", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4368", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4369", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4370", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4371", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4372", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4373", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4374", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4375", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4376", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4377", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4378", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4379", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4380", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4381", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4382", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4383", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4384", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4385", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4386", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4387", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4388", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4389", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4390", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4391", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4392", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4393", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4394", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4395", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4396", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4397", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4398", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4399", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4400", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4401", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4402", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4403", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4404", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4405", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4406", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4407", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4408", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4409", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4410", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4411", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4412", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4413", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4414", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4415", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4416", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4417", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4418", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4419", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4420", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4421", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4422", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4423", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4424", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4425", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4426", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4427", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4428", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4429", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4430", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4431", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4432", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4433", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4434", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4435", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4436", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4437", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4438", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4439", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4440", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4441", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4442", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4443", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4444", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4445", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4446", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4447", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4448", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4449", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4450", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4451", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4452", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4453", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4454", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4455", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4456", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4457", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4458", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4459", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4460", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4461", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4463", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4466", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4469", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4472", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4475", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4478", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4480", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4481", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4482", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4483", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4484", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4485", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4486", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4487", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4488", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4490", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4493", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4496", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4499", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4502", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4505", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4507", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4508", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4509", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4510", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4511", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4512", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4513", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4514", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4515", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4517", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4520", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4523", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4526", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4529", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4532", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4534", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4535", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4536", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4537", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4538", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4539", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4540", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4541", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4542", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4543", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4544", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4545", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4546", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4547", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4548", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4549", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4550", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4551", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4552", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4553", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4554", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4555", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4556", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4557", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4558", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4559", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4560", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4561", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4562", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4563", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4564", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4565", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4566", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4567", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4568", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4569", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4570", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4571", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4572", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4573", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4574", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4575", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4576", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4577", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4578", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4579", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4580", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4581", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4582", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4583", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4584", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4585", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4586", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4587", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4588", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4589", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4590", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4591", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4592", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4593", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4594", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4595", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4596", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4597", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4598", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4599", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4600", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4601", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4602", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4603", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4604", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4605", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4606", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4607", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4608", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4609", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4610", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4611", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4612", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4613", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4614", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4615", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4616", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4617", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4618", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4619", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4620", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4621", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4622", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4623", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4624", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4625", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4626", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4627", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4628", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4629", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4630", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4631", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4632", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4633", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4634", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4635", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4636", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4637", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4638", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4639", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4640", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4641", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4642", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4643", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4644", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4645", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4646", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4647", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4648", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4649", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4650", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4651", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4652", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4653", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4654", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4655", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4656", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4657", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4658", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4659", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4660", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4661", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4662", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4663", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4664", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4665", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4666", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4667", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4668", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4669", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4670", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4671", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4672", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4673", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4674", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4675", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4676", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4677", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4678", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4679", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4680", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4681", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4682", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4683", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4684", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4685", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4686", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4687", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4688", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4689", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4690", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4691", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4692", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4693", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4694", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4695", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4696", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4697", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4698", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4699", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4700", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4701", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4702", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4703", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4704", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4706", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4708", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4709", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4710", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4712", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4715", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4717", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4718", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4719", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4721", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4723", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4724", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4725", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4726", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4727", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4728", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4729", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4730", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4731", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4733", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4735", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4736", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4737", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4739", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4742", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4744", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4745", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4746", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4748", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4750", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4751", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4752", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4753", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4754", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4755", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4756", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4757", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4758", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4759", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4760", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4761", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4762", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4763", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4764", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4765", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4766", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4767", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4768", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4769", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4770", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4771", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4772", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4773", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4774", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4775", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4776", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4777", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4778", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4779", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4780", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4781", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4782", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4783", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4784", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4785", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4786", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4787", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4788", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4789", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4790", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4791", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4792", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4793", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4794", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4795", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4796", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4797", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4798", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4799", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4800", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4801", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4802", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4803", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4804", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4805", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4806", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4807", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4808", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4809", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4810", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4811", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4812", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4813", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4814", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4815", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4816", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4817", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4818", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4819", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4820", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4821", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4822", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4823", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4824", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4825", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4826", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4827", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4828", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4829", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4830", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4831", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4832", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4833", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4834", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4835", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4836", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4837", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4838", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4839", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4840", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4841", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4842", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4843", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4844", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4845", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4846", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4847", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4848", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4849", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4850", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4851", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4852", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4853", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4854", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4855", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4856", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4857", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4858", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4859", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4860", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4861", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4862", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4863", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4864", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4865", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4866", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4867", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4868", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4869", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4870", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4871", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4872", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4873", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4874", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4875", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4876", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4877", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4878", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4879", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4880", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4881", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4882", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4883", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4884", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4885", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4886", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4887", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4888", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4889", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4890", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4891", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4892", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4893", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4894", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4895", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4896", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4897", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4898", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4899", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4900", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4901", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4902", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4903", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4904", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4905", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4906", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4907", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4908", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4909", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4910", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4911", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4912", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4913", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4914", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4915", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4916", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4917", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4918", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4919", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4920", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4921", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4922", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4923", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4924", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4925", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4926", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4927", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4928", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4929", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4930", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4931", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4932", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4933", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4934", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4935", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4936", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4937", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4938", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4939", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4940", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4941", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4942", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4943", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4944", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4945", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4946", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4947", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4949", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4952", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4954", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4955", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4956", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4958", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4961", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4963", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4964", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4965", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4966", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4967", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4968", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4969", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4970", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4971", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4972", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4973", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4974", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4975", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4976", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4977", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4978", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4979", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4980", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4981", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4982", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4983", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4984", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4985", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4986", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4987", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4988", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4989", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4990", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4991", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4992", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4993", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4994", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4995", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4996", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4997", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4998", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc4999", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5000", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5001", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5003", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5006", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5008", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5009", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5010", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5012", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5015", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5017", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5018", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5019", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5020", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5021", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5022", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5023", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5024", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5025", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5026", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5027", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5028", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5029", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5030", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5031", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5032", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5033", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5034", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5035", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5036", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5037", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5038", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5039", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5040", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5041", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5042", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5043", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5044", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5045", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5046", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5047", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5048", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5049", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5050", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5051", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5052", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5053", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5054", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5055", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5056", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5057", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5058", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5059", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5060", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5061", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5062", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5063", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5064", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5065", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5066", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5067", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5068", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5069", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5070", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5071", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5072", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5073", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5074", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5075", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5076", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5077", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5078", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5079", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5080", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5081", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5082", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5083", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5084", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5085", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5086", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5087", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5088", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5089", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5090", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5091", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5092", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5093", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5094", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5095", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5096", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5097", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5098", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5099", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5100", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5101", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5102", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5103", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5104", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5105", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5106", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5107", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5108", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5109", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5110", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5111", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5112", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5113", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5114", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5115", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5116", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5117", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5118", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5119", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5120", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5121", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5122", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5123", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5124", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5125", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5126", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5127", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5128", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5129", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5130", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5131", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5132", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5133", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5134", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5135", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5136", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5137", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5138", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5139", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5140", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5141", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5142", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5143", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5144", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5145", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5146", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5147", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5148", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5149", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5150", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5151", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5152", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5153", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5154", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5155", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5156", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5157", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5158", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5159", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5160", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5161", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5162", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5163", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5164", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5165", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5166", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5167", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5168", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5169", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5170", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5171", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5172", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5173", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5174", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5175", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5176", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5177", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5178", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5179", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5180", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5181", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5182", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5183", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5184", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5185", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5186", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5187", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5188", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5189", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5190", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5192", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5195", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5198", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5201", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5204", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5207", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5209", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5210", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5211", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5212", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5213", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5214", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5215", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5216", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5217", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5219", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5222", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5225", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5228", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5231", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5234", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5236", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5237", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5238", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5239", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5240", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5241", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5242", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5243", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5244", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5246", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5249", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5252", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5255", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5258", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5261", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5263", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5264", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5265", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5266", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5267", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5268", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5269", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5270", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5271", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5272", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5273", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5274", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5275", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5276", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5277", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5278", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5279", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5280", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5281", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5282", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5283", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5284", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5285", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5286", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5287", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5288", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5289", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5290", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5291", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5292", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5293", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5294", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5295", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5296", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5297", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5298", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5299", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5300", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5301", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5302", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5303", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5304", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5305", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5306", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5307", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5308", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5309", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5310", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5311", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5312", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5313", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5314", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5315", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5316", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5317", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5318", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5319", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5320", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5321", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5322", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5323", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5324", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5325", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5326", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5327", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5328", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5329", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5330", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5331", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5332", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5333", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5334", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5335", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5336", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5337", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5338", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5339", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5340", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5341", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5342", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5343", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5344", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5345", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5346", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5347", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5348", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5349", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5350", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5351", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5352", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5353", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5354", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5355", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5356", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5357", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5358", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5359", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5360", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5361", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5362", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5363", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5364", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5365", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5366", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5367", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5368", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5369", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5370", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5371", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5372", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5373", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5374", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5375", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5376", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5377", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5378", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5379", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5380", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5381", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5382", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5383", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5384", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5385", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5386", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5387", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5388", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5389", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5390", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5391", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5392", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5393", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5394", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5395", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5396", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5397", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5398", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5399", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5400", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5401", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5402", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5403", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5404", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5405", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5406", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5407", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5408", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5409", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5410", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5411", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5412", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5413", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5414", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5415", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5416", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5417", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5418", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5419", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5420", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5421", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5422", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5423", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5424", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5425", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5426", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5427", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5428", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5429", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5430", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5431", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5432", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5433", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5435", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5437", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5438", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5439", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5441", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5444", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5446", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5447", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5448", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5450", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5452", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5453", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5454", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5455", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5456", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5457", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5458", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5459", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5460", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5462", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5464", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5465", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5466", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5468", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5471", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5473", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5474", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5475", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5477", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5479", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5480", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5481", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5482", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5483", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5484", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5485", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5486", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5487", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5488", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5489", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5490", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5491", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5492", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5493", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5494", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5495", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5496", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5497", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5498", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5499", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5500", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5501", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5502", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5503", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5504", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5505", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5506", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5507", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5508", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5509", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5510", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5511", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5512", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5513", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5514", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5515", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5516", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5517", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5518", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5519", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5520", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5521", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5522", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5523", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5524", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5525", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5526", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5527", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5528", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5529", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5530", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5531", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5532", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5533", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5534", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5535", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5536", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5537", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5538", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5539", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5540", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5541", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5542", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5543", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5544", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5545", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5546", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5547", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5548", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5549", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5550", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5551", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5552", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5553", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5554", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5555", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5556", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5557", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5558", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5559", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5560", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5561", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5562", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5563", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5564", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5565", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5566", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5567", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5568", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5569", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5570", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5571", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5572", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5573", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5574", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5575", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5576", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5577", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5578", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5579", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5580", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5581", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5582", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5583", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5584", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5585", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5586", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5587", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5588", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5589", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5590", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5591", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5592", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5593", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5594", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5595", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5596", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5597", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5598", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5599", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5600", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5601", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5602", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5603", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5604", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5605", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5606", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5607", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5608", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5609", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5610", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5611", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5612", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5613", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5614", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5615", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5616", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5617", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5618", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5619", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5620", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5621", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5622", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5623", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5624", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5625", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5626", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5627", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5628", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5629", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5630", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5631", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5632", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5633", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5634", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5635", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5636", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5637", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5638", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5639", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5640", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5641", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5642", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5643", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5644", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5645", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5646", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5647", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5648", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5649", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5650", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5651", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5652", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5653", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5654", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5655", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5656", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5657", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5658", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5659", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5660", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5661", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5662", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5663", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5664", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5665", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5666", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5667", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5668", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5669", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5670", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5671", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5672", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5673", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5674", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5675", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5676", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5678", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5681", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5683", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5684", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5685", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5687", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5690", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5692", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5693", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5694", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5695", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5696", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5697", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5698", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5699", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5700", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5701", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5702", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5703", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5704", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5705", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5706", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5707", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5708", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5709", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5710", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5711", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5712", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5713", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5714", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5715", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5716", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5717", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5718", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5719", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5720", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5721", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5722", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5723", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5724", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5725", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5726", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5727", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5728", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5729", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5730", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5732", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5735", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5737", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5738", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5739", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5741", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5744", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5746", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5747", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5748", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5749", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5750", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5751", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5752", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5753", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5754", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5755", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5756", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5757", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5758", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5759", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5760", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5761", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5762", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5763", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5764", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5765", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5766", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5767", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5768", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5769", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5770", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5771", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5772", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5773", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5774", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5775", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5776", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5777", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5778", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5779", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5780", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5781", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5782", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5783", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5784", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5785", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5786", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5787", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5788", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5789", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5790", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5791", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5792", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5793", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5794", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5795", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5796", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5797", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5798", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5799", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5800", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5801", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5802", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5803", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5804", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5805", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5806", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5807", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5808", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5809", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5810", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5811", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5812", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5813", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5814", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5815", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5816", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5817", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5818", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5819", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5820", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5821", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5822", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5823", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5824", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5825", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5826", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5827", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5828", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5829", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5830", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5831", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5832", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5833", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5834", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5835", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5836", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5837", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5838", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5839", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5840", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5841", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5842", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5843", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5844", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5845", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5846", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5847", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5848", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5849", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5850", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5851", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5852", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5853", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5854", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5855", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5856", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5857", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5858", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5859", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5860", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5861", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5862", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5863", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5864", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5865", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5866", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5867", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5868", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5869", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5870", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5871", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5872", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5873", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5874", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5875", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5876", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5877", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5878", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5879", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5880", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5881", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5882", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5883", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5884", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5885", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5886", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5887", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5888", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5889", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5890", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5891", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5892", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5893", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5894", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5895", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5896", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5897", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5898", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5899", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5900", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5901", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5902", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5903", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5904", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5905", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5906", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5907", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5908", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5909", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5910", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5911", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5912", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5913", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5914", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5915", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5916", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5917", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5918", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5919", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5921", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5924", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5927", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5930", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5933", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5936", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5938", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5939", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5940", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5941", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5942", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5943", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5944", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5945", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5946", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5948", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5951", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5954", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5957", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5960", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5963", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5965", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5966", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5967", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5968", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5969", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5970", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5971", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5972", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5973", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5975", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5978", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5981", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5984", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5987", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5990", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5992", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5993", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5994", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5995", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5996", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5997", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5998", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc5999", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6000", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6001", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6002", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6003", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6004", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6005", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6006", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6007", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6008", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6009", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6010", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6011", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6012", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6013", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6014", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6015", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6016", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6017", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6018", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6019", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6020", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6021", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6022", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6023", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6024", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6025", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6026", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6027", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6028", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6029", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6030", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6031", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6032", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6033", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6034", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6035", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6036", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6037", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6038", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6039", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6040", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6041", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6042", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6043", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6044", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6045", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6046", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6047", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6048", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6049", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6050", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6051", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6052", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6053", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6054", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6055", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6056", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6057", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6058", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6059", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6060", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6061", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6062", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6063", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6064", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6065", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6066", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6067", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6068", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6069", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6070", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6071", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6072", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6073", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6074", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6075", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6076", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6077", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6078", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6079", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6080", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6081", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6082", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6083", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6084", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6085", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6086", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6087", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6088", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6089", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6090", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6091", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6092", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6093", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6094", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6095", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6096", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6097", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6098", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6099", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6100", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6101", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6102", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6103", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6104", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6105", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6106", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6107", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6108", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6109", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6110", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6111", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6112", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6113", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6114", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6115", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6116", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6117", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6118", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6119", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6120", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6121", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6122", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6123", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6124", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6125", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6126", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6127", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6128", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6129", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6130", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6131", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6132", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6133", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6134", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6135", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6136", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6137", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6138", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6139", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6140", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6141", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6142", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6143", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6144", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6145", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6146", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6147", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6148", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6149", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6150", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6151", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6152", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6153", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6154", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6155", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6156", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6157", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6158", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6159", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6160", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6161", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6162", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6164", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6166", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6167", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6168", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6170", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6173", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6175", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6176", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6177", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6179", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6181", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6182", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6183", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6184", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6185", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6186", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6187", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6188", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6189", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6191", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6193", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6194", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6195", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6197", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6200", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6202", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6203", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6204", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6206", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6208", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6209", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6210", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6211", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6212", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6213", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6214", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6215", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6216", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6217", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6218", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6219", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6220", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6221", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6222", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6223", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6224", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6225", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6226", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6227", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6228", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6229", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6230", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6231", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6232", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6233", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6234", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6235", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6236", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6237", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6238", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6239", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6240", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6241", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6242", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6243", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6244", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6245", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6246", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6247", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6248", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6249", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6250", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6251", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6252", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6253", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6254", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6255", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6256", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6257", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6258", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6259", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6260", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6261", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6262", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6263", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6264", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6265", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6266", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6267", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6268", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6269", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6270", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6271", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6272", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6273", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6274", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6275", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6276", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6277", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6278", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6279", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6280", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6281", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6282", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6283", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6284", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6285", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6286", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6287", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6288", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6289", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6290", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6291", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6292", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6293", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6294", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6295", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6296", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6297", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6298", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6299", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6300", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6301", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6302", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6303", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6304", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6305", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6306", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6307", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6308", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6309", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6310", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6311", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6312", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6313", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6314", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6315", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6316", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6317", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6318", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6319", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6320", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6321", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6322", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6323", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6324", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6325", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6326", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6327", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6328", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6329", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6330", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6331", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6332", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6333", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6334", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6335", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6336", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6337", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6338", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6339", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6340", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6341", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6342", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6343", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6344", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6345", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6346", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6347", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6348", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6349", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6350", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6351", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6352", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6353", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6354", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6355", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6356", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6357", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6358", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6359", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6360", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6361", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6362", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6363", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6364", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6365", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6366", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6367", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6368", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6369", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6370", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6371", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6372", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6373", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6374", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6375", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6376", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6377", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6378", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6379", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6380", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6381", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6382", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6383", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6384", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6385", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6386", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6387", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6388", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6389", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6390", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6391", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6392", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6393", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6394", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6395", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6396", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6397", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6398", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6399", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6400", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6401", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6402", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6403", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6404", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6405", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6407", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6410", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6412", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6413", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6414", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6416", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6419", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6421", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6422", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6423", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6424", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6425", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6426", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6427", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6428", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6429", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6430", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6431", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6432", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6433", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6434", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6435", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6436", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6437", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6438", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6439", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6440", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6441", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6442", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6443", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6444", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6445", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6446", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6447", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6448", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6449", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6450", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6451", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6452", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6453", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6454", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6455", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6456", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6457", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6458", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6459", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6461", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6464", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6466", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6467", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6468", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6470", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6473", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6475", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6476", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6477", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6478", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6479", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6480", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6481", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6482", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6483", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6484", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6485", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6486", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6487", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6488", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6489", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6490", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6491", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6492", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6493", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6494", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6495", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6496", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6497", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6498", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6499", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6500", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6501", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6502", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6503", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6504", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6505", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6506", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6507", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6508", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6509", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6510", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6511", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6512", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6513", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6514", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6515", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6516", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6517", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6518", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6519", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6520", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6521", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6522", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6523", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6524", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6525", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6526", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6527", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6528", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6529", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6530", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6531", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6532", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6533", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6534", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6535", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6536", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6537", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6538", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6539", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6540", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6541", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6542", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6543", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6544", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6545", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6546", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6547", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6548", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6549", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6550", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6551", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6552", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6553", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6554", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6555", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6556", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6557", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6558", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6559", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6560", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6561", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6562", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6563", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6564", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6565", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6566", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6567", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6568", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6569", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6570", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6571", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6572", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6573", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6574", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6575", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6576", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6577", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6578", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6579", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6580", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6581", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6582", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6583", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6584", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6585", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6586", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6587", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6588", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6589", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6590", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6591", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6592", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6593", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6594", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6595", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6596", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6597", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6598", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6599", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6600", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6601", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6602", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6603", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6604", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6605", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6606", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6607", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6608", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6609", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6610", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6611", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6612", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6613", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6614", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6615", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6616", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6617", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6618", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6619", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6620", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6621", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6622", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6623", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6624", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6625", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6626", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6627", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6628", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6629", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6630", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6631", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6632", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6633", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6634", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6635", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6636", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6637", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6638", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6639", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6640", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6641", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6642", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6643", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6644", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6645", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6646", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6647", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6648", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6650", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6653", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6656", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6659", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6662", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6665", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6667", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6668", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6669", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6670", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6671", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6672", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6673", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6674", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6675", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6677", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6680", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6683", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6686", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6689", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6692", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6694", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6695", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6696", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6697", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6698", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6699", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6700", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6701", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6702", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6704", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6707", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6710", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6713", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6716", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6719", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6721", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6722", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6723", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6724", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6725", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6726", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6727", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6728", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6729", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6730", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6731", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6732", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6733", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6734", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6735", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6736", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6737", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6738", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6739", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6740", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6741", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6742", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6743", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6744", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6745", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6746", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6747", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6748", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6749", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6750", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6751", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6752", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6753", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6754", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6755", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6756", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6757", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6758", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6759", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6760", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6761", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6762", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6763", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6764", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6765", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6766", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6767", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6768", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6769", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6770", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6771", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6772", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6773", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6774", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6775", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6776", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6777", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6778", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6779", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6780", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6781", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6782", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6783", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6784", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6785", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6786", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6787", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6788", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6789", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6790", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6791", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6792", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6793", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6794", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6795", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6796", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6797", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6798", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6799", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6800", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6801", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6802", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6803", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6804", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6805", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6806", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6807", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6808", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6809", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6810", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6811", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6812", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6813", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6814", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6815", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6816", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6817", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6818", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6819", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6820", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6821", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6822", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6823", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6824", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6825", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6826", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6827", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6828", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6829", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6830", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6831", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6832", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6833", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6834", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6835", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6836", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6837", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6838", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6839", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6840", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6841", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6842", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6843", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6844", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6845", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6846", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6847", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6848", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6849", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6850", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6851", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6852", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6853", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6854", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6855", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6856", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6857", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6858", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6859", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6860", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6861", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6862", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6863", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6864", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6865", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6866", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6867", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6868", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6869", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6870", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6871", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6872", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6873", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6874", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6875", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6876", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6877", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6878", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6879", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6880", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6881", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6882", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6883", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6884", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6885", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6886", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6887", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6888", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6889", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6890", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6891", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6893", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6895", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6896", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6897", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6899", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6902", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6904", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6905", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6906", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6908", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6910", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6911", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6912", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6913", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6914", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6915", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6916", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6917", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6918", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6920", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6922", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6923", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6924", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6926", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6929", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6931", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6932", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6933", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6935", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6937", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6938", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6939", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6940", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6941", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6942", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6943", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6944", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6945", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6946", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6947", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6948", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6949", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6950", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6951", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6952", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6953", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6954", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6955", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6956", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6957", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6958", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6959", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6960", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6961", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6962", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6963", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6964", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6965", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6966", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6967", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6968", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6969", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6970", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6971", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6972", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6973", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6974", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6975", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6976", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6977", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6978", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6979", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6980", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6981", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6982", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6983", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6984", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6985", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6986", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6987", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6988", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6989", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6990", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6991", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6992", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6993", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6994", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6995", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6996", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6997", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6998", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc6999", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7000", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7001", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7002", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7003", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7004", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7005", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7006", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7007", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7008", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7009", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7010", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7011", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7012", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7013", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7014", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7015", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7016", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7017", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7018", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7019", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7020", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7021", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7022", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7023", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7024", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7025", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7026", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7027", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7028", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7029", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7030", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7031", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7032", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7033", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7034", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7035", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7036", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7037", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7038", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7039", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7040", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7041", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7042", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7043", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7044", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7045", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7046", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7047", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7048", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7049", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7050", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7051", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7052", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7053", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7054", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7055", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7056", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7057", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7058", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7059", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7060", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7061", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7062", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7063", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7064", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7065", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7066", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7067", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7068", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7069", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7070", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7071", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7072", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7073", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7074", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7075", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7076", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7077", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7078", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7079", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7080", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7081", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7082", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7083", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7084", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7085", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7086", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7087", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7088", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7089", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7090", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7091", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7092", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7093", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7094", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7095", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7096", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7097", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7098", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7099", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7100", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7101", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7102", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7103", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7104", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7105", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7106", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7107", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7108", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7109", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7110", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7111", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7112", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7113", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7114", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7115", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7116", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7117", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7118", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7119", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7120", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7121", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7122", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7123", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7124", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7125", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7126", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7127", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7128", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7129", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7130", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7131", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7132", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7133", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7134", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7136", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7139", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7141", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7142", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7143", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7145", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7148", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7150", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7151", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7152", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7153", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7154", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7155", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7156", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7157", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7158", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7159", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7160", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7161", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7162", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7163", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7164", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7165", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7166", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7167", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7168", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7169", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7170", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7171", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7172", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7173", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7174", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7175", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7176", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7177", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7178", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7179", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7180", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7181", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7182", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7183", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7184", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7185", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7186", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7187", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7188", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7190", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7193", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7195", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7196", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7197", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7199", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7202", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7204", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7205", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7206", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7207", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7208", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7209", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7210", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7211", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7212", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7213", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7214", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7215", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7216", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7217", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7218", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7219", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7220", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7221", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7222", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7223", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7224", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7225", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7226", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7227", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7228", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7229", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7230", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7231", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7232", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7233", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7234", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7235", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7236", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7237", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7238", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7239", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7240", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7241", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7242", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7243", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7244", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7245", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7246", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7247", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7248", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7249", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7250", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7251", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7252", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7253", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7254", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7255", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7256", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7257", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7258", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7259", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7260", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7261", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7262", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7263", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7264", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7265", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7266", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7267", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7268", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7269", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7270", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7271", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7272", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7273", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7274", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7275", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7276", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7277", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7278", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7279", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7280", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7281", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7282", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7283", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7284", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7285", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7286", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7287", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7288", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7289", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7290", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7291", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7292", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7293", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7294", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7295", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7296", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7297", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7298", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7299", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7300", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7301", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7302", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7303", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7304", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7305", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7306", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7307", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7308", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7309", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7310", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7311", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7312", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7313", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7314", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7315", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7316", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7317", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7318", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7319", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7320", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7321", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7322", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7323", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7324", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7325", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7326", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7327", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7328", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7329", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7330", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7331", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7332", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7333", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7334", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7335", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7336", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7337", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7338", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7339", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7340", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7341", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7342", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7343", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7344", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7345", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7346", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7347", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7348", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7349", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7350", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7351", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7352", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7353", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7354", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7355", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7356", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7357", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7358", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7359", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7360", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7361", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7362", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7363", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7364", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7365", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7366", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7367", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7368", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7369", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7370", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7371", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7372", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7373", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7374", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7375", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7376", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7377", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7379", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7382", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7385", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7388", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7391", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7394", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7396", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7397", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7398", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7399", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7400", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7401", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7402", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7403", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7404", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7406", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7409", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7412", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7415", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7418", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7421", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7423", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7424", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7425", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7426", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7427", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7428", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7429", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7430", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7431", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7433", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7436", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7439", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7442", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7445", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7448", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7450", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7451", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7452", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7453", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7454", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7455", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7456", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7457", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7458", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7459", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7460", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7461", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7462", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7463", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7464", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7465", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7466", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7467", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7468", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7469", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7470", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7471", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7472", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7473", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7474", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7475", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7476", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7477", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7478", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7479", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7480", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7481", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7482", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7483", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7484", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7485", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7486", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7487", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7488", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7489", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7490", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7491", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7492", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7493", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7494", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7495", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7496", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7497", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7498", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7499", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7500", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7501", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7502", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7503", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7504", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7505", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7506", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7507", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7508", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7509", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7510", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7511", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7512", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7513", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7514", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7515", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7516", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7517", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7518", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7519", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7520", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7521", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7522", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7523", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7524", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7525", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7526", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7527", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7528", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7529", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7530", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7531", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7532", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7533", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7534", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7535", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7536", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7537", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7538", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7539", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7540", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7541", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7542", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7543", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7544", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7545", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7546", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7547", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7548", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7549", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7550", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7551", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7552", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7553", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7554", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7555", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7556", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7557", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7558", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7559", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7560", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7561", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7562", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7563", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7564", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7565", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7566", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7567", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7568", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7569", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7570", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7571", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7572", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7573", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7574", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7575", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7576", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7577", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7578", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7579", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7580", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7581", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7582", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7583", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7584", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7585", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7586", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7587", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7588", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7589", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7590", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7591", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7592", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7593", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7594", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7595", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7596", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7597", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7598", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7599", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7600", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7601", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7602", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7603", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7604", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7605", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7606", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7607", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7608", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7609", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7610", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7611", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7612", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7613", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7614", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7615", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7616", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7617", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7618", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7619", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7620", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7622", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7624", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7625", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7626", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7628", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7631", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7633", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7634", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7635", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7637", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7639", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7640", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7641", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7642", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7643", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7644", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7645", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7646", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7647", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7649", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7651", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7652", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7653", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7655", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7658", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7660", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7661", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7662", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7664", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7666", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7667", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7668", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7669", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7670", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7671", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7672", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7673", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7674", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7675", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7676", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7677", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7678", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7679", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7680", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7681", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7682", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7683", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7684", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7685", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7686", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7687", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7688", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7689", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7690", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7691", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7692", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7693", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7694", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7695", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7696", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7697", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7698", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7699", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7700", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7701", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7702", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7703", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7704", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7705", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7706", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7707", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7708", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7709", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7710", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7711", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7712", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7713", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7714", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7715", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7716", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7717", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7718", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7719", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7720", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7721", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7722", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7723", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7724", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7725", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7726", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7727", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7728", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7729", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7730", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7731", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7732", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7733", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7734", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7735", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7736", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7737", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7738", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7739", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7740", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7741", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7742", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7743", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7744", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7745", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7746", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7747", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7748", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7749", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7750", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7751", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7752", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7753", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7754", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7755", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7756", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7757", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7758", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7759", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7760", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7761", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7762", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7763", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7764", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7765", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7766", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7767", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7768", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7769", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7770", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7771", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7772", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7773", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7774", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7775", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7776", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7777", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7778", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7779", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7780", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7781", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7782", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7783", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7784", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7785", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7786", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7787", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7788", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7789", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7790", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7791", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7792", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7793", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7794", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7795", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7796", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7797", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7798", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7799", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7800", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7801", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7802", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7803", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7804", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7805", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7806", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7807", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7808", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7809", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7810", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7811", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7812", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7813", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7814", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7815", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7816", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7817", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7818", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7819", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7820", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7821", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7822", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7823", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7824", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7825", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7826", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7827", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7828", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7829", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7830", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7831", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7832", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7833", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7834", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7835", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7836", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7837", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7838", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7839", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7840", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7841", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7842", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7843", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7844", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7845", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7846", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7847", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7848", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7849", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7850", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7851", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7852", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7853", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7854", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7855", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7856", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7857", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7858", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7859", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7860", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7861", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7862", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7863", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7865", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7868", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7870", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7871", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7872", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7874", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7877", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7879", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7880", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7881", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7882", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7883", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7884", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7885", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7886", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7887", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7888", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7889", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7890", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7891", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7892", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7893", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7894", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7895", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7896", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7897", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7898", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7899", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7900", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7901", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7902", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7903", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7904", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7905", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7906", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7907", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7908", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7909", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7910", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7911", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7912", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7913", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7914", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7915", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7916", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7917", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7919", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7922", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7924", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7925", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7926", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7928", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7931", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7933", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7934", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7935", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7936", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7937", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7938", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7939", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7940", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7941", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7942", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7943", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7944", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7945", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7946", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7947", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7948", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7949", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7950", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7951", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7952", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7953", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7954", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7955", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7956", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7957", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7958", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7959", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7960", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7961", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7962", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7963", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7964", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7965", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7966", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7967", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7968", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7969", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7970", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7971", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7972", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7973", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7974", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7975", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7976", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7977", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7978", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7979", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7980", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7981", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7982", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7983", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7984", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7985", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7986", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7987", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7988", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7989", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7990", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7991", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7992", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7993", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7994", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7995", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7996", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7997", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7998", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc7999", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8000", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8001", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8002", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8003", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8004", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8005", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8006", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8007", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8008", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8009", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8010", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8011", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8012", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8013", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8014", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8015", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8016", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8017", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8018", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8019", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8020", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8021", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8022", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8023", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8024", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8025", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8026", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8027", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8028", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8029", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8030", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8031", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8032", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8033", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8034", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8035", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8036", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8037", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8038", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8039", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8040", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8041", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8042", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8043", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8044", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8045", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8046", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8047", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8048", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8049", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8050", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8051", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8052", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8053", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8054", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8055", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8056", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8057", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8058", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8059", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8060", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8061", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8062", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8063", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8064", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8065", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8066", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8067", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8068", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8069", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8070", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8071", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8072", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8073", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8074", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8075", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8076", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8077", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8078", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8079", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8080", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8081", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8082", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8083", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8084", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8085", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8086", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8087", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8088", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8089", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8090", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8091", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8092", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8093", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8094", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8095", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8096", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8097", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8098", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8099", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8100", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8101", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8102", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8103", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8104", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8105", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8106", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8108", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8111", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8114", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8117", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8120", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8123", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8125", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8126", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8127", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8128", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8129", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8130", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8131", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8132", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8133", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8135", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8138", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8141", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8144", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8147", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8150", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8152", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8153", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8154", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8155", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8156", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8157", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8158", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8159", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8160", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8162", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8165", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8168", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8171", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8174", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8177", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8179", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8180", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8181", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8182", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8183", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8184", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8185", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8186", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8187", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8188", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8189", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8190", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8191", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8192", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8193", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8194", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8195", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8196", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8197", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8198", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8199", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8200", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8201", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8202", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8203", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8204", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8205", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8206", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8207", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8208", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8209", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8210", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8211", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8212", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8213", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8214", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8215", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8216", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8217", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8218", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8219", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8220", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8221", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8222", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8223", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8224", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8225", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8226", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8227", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8228", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8229", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8230", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8231", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8232", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8233", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8234", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8235", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8236", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8237", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8238", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8239", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8240", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8241", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8242", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8243", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8244", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8245", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8246", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8247", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8248", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8249", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8250", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8251", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8252", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8253", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8254", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8255", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8256", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8257", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8258", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8259", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8260", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8261", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8262", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8263", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8264", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8265", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8266", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8267", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8268", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8269", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8270", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8271", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8272", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8273", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8274", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8275", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8276", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8277", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8278", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8279", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8280", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8281", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8282", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8283", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8284", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8285", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8286", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8287", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8288", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8289", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8290", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8291", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8292", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8293", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8294", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8295", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8296", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8297", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8298", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8299", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8300", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8301", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8302", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8303", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8304", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8305", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8306", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8307", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8308", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8309", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8310", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8311", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8312", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8313", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8314", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8315", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8316", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8317", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8318", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8319", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8320", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8321", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8322", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8323", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8324", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8325", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8326", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8327", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8328", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8329", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8330", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8331", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8332", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8333", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8334", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8335", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8336", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8337", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8338", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8339", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8340", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8341", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8342", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8343", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8344", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8345", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8346", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8347", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8348", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8349", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8351", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8353", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8354", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8355", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8357", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8360", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8362", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8363", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8364", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8366", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8368", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8369", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8370", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8371", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8372", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8373", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8374", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8375", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8376", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8378", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8380", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8381", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8382", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8384", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8387", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8389", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8390", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8391", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8393", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8395", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8396", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8397", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8398", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8399", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8400", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8401", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8402", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8403", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8404", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8405", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8406", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8407", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8408", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8409", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8410", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8411", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8412", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8413", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8414", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8415", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8416", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8417", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8418", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8419", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8420", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8421", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8422", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8423", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8424", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8425", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8426", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8427", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8428", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8429", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8430", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8431", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8432", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8433", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8434", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8435", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8436", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8437", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8438", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8439", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8440", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8441", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8442", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8443", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8444", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8445", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8446", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8447", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8448", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8449", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8450", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8451", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8452", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8453", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8454", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8455", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8456", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8457", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8458", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8459", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8460", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8461", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8462", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8463", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8464", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8465", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8466", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8467", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8468", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8469", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8470", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8471", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8472", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8473", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8474", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8475", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8476", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8477", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8478", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8479", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8480", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8481", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8482", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8483", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8484", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8485", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8486", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8487", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8488", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8489", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8490", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8491", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8492", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8493", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8494", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8495", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8496", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8497", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8498", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8499", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8500", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8501", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8502", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8503", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8504", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8505", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8506", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8507", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8508", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8509", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8510", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8511", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8512", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8513", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8514", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8515", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8516", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8517", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8518", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8519", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8520", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8521", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8522", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8523", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8524", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8525", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8526", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8527", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8528", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8529", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8530", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8531", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8532", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8533", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8534", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8535", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8536", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8537", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8538", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8539", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8540", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8541", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8542", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8543", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8544", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8545", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8546", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8547", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8548", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8549", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8550", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8551", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8552", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8553", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8554", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8555", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8556", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8557", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8558", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8559", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8560", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8561", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8562", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8563", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8564", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8565", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8566", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8567", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8568", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8569", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8570", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8571", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8572", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8573", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8574", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8575", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8576", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8577", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8578", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8579", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8580", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8581", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8582", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8583", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8584", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8585", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8586", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8587", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8588", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8589", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8590", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8591", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8592", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8594", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8597", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8599", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8600", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8601", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8603", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8606", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8608", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8609", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8610", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8611", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8612", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8613", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8614", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8615", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8616", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8617", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8618", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8619", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8620", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8621", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8622", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8623", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8624", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8625", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8626", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8627", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8628", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8629", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8630", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8631", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8632", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8633", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8634", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8635", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8636", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8637", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8638", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8639", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8640", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8641", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8642", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8643", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8644", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8645", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8646", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8648", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8651", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8653", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8654", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8655", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8657", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8660", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8662", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8663", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8664", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8665", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8666", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8667", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8668", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8669", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8670", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8671", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8672", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8673", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8674", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8675", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8676", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8677", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8678", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8679", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8680", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8681", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8682", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8683", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8684", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8685", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8686", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8687", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8688", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8689", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8690", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8691", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8692", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8693", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8694", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8695", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8696", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8697", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8698", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8699", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8700", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8701", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8702", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8703", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8704", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8705", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8706", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8707", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8708", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8709", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8710", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8711", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8712", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8713", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8714", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8715", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8716", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8717", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8718", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8719", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8720", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8721", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8722", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8723", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8724", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8725", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8726", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8727", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8728", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8729", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8730", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8731", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8732", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8733", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8734", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8735", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8736", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8737", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8738", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8739", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8740", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8741", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8742", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8743", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8744", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8745", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8746", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8747", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8748", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8749", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8750", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8751", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8752", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8753", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8754", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8755", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8756", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8757", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8758", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8759", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8760", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8761", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8762", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8763", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8764", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8765", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8766", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8767", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8768", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8769", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8770", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8771", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8772", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8773", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8774", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8775", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8776", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8777", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8778", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8779", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8780", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8781", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8782", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8783", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8784", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8785", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8786", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8787", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8788", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8789", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8790", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8791", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8792", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8793", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8794", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8795", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8796", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8797", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8798", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8799", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8800", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8801", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8802", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8803", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8804", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8805", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8806", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8807", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8808", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8809", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8810", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8811", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8812", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8813", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8814", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8815", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8816", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8817", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8818", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8819", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8820", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8821", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8822", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8823", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8824", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8825", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8826", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8827", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8828", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8829", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8830", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8831", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8832", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8833", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8834", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8835", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8836", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8837", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8838", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8839", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8840", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8841", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8842", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8843", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8844", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8845", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8846", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8847", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8848", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8849", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8850", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8851", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8852", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8853", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8854", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8855", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8856", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8857", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8858", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8859", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8860", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8861", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8862", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8863", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8864", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8865", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8866", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8867", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8868", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8869", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8870", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8871", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8872", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8873", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8874", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8875", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8876", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8877", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8878", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8879", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8880", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8881", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8882", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8883", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8884", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8885", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8886", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8887", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8888", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8889", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8890", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8891", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8892", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8893", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8894", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8895", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8896", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8897", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8898", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8899", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8900", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8901", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8902", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8903", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8904", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8905", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8906", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8907", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8908", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8909", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8910", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8911", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8912", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8913", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8914", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8915", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8916", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8917", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8918", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8919", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8920", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8921", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8922", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8923", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8924", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8925", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8926", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8927", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8928", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8929", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8930", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8931", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8932", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8933", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8934", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8935", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8936", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8937", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8938", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8939", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8940", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8941", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8942", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8943", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8944", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8945", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8946", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8947", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8948", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8949", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8950", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8951", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8952", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8953", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8954", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8955", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8956", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8957", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8958", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8959", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8960", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8961", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8962", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8963", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8964", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8965", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8966", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8967", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8968", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8969", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8970", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8971", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8972", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8973", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8974", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8975", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8976", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8977", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8978", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8979", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8980", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8981", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8982", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8983", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8984", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8985", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8986", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8987", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8988", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8989", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8990", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8991", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8992", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8993", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8994", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8995", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8996", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8997", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8998", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc8999", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9000", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9001", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9002", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9003", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9004", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9005", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9006", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9007", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9008", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9009", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9010", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9011", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9012", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9013", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9014", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9015", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9016", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9017", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9018", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9019", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9020", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9021", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9022", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9023", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9024", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9025", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9026", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9027", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9028", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9029", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9030", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9031", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9032", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9033", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9034", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9035", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9036", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9037", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9038", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9039", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9040", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9041", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9042", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9043", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9044", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9045", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9046", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9047", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9048", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9049", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9050", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9051", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9052", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9053", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9054", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9055", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9056", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9057", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9058", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9059", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9060", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9061", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9062", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9063", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9064", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9065", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9066", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9067", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9068", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9069", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9070", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9071", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9072", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9073", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9074", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9075", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9076", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9077", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9078", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9079", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9080", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9081", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9082", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9083", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9084", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9085", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9086", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9087", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9088", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9089", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9090", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9091", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9092", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9093", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9094", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9095", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9096", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9097", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9098", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9099", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9100", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9101", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9102", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9103", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9104", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9105", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9106", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9107", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9108", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9109", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9110", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9111", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9112", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9113", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9114", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9115", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9116", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9117", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9118", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9119", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9120", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9121", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9122", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9123", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9124", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9125", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9126", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9127", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9128", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9129", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9130", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9131", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9132", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9133", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9134", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9135", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9136", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9137", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9138", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9139", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9140", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9141", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9142", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9143", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9144", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9145", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9146", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9147", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9148", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9149", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9150", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9151", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9152", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9153", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9154", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9155", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9156", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9157", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9158", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9159", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9160", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9161", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9162", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9163", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9164", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9165", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9166", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9167", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9168", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9169", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9170", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9171", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9172", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9173", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9174", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9175", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9176", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9177", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9178", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9179", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9180", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9181", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9182", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9183", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9184", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9185", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9186", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9187", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9188", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9189", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9190", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9191", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9192", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9193", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9194", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9195", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9196", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9197", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9198", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9199", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9200", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9201", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9202", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9203", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9204", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9205", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9206", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9207", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9208", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9209", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9210", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9211", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9212", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9213", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9214", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9215", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9216", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9217", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9218", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9219", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9220", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9221", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9222", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9223", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9224", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9225", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9226", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9227", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9228", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9229", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9230", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9231", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9232", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9233", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9234", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9235", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9236", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9237", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9238", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9239", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9240", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9241", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9242", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9243", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9244", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9245", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9246", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9247", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9248", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9249", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9250", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9251", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9252", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9253", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9254", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9255", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9256", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9257", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9258", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9259", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9260", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9261", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9262", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9263", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9264", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9265", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9266", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9267", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9268", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9269", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9270", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9271", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9272", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9273", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9274", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9275", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9276", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9277", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9278", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9279", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9280", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9281", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9282", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9283", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9284", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9285", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9286", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9287", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9288", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9289", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9290", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9291", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9292", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9293", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9294", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9295", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9296", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9297", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9298", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9299", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9300", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9301", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9302", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9303", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9304", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9305", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9306", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9307", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9308", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9309", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9310", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9311", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9312", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9313", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9314", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9315", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9316", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9317", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9318", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9319", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9320", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9321", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9322", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9323", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9324", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9325", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9326", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9327", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9328", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9329", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9330", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9331", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9332", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9333", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9334", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9335", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9336", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9337", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9338", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9339", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9340", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9341", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9342", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9343", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9344", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9345", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9346", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9347", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9348", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9349", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9350", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9351", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9352", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9353", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9354", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9355", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9356", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9357", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9358", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9359", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9360", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9361", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9362", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9363", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9364", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9365", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9366", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9367", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9368", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9369", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9370", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9371", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9372", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9373", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9374", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9375", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9376", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9377", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9378", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9379", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9380", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9381", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9382", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9383", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9384", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9385", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9386", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9387", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9388", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9389", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9390", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9391", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9392", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9393", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9394", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9395", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9396", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9397", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9398", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9399", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9400", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9401", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9402", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9403", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9404", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9405", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9406", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9407", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9408", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9409", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9410", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9411", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9412", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9413", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9414", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9415", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9416", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9417", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9418", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9419", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9420", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9421", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9422", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9423", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9424", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9425", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9426", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9427", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9428", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9429", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9430", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9431", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9432", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9433", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9434", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9435", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9436", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9437", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9438", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9439", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9440", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9441", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9442", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9443", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9444", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9445", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9446", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9447", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9448", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9449", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9450", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9451", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9452", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9453", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9454", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9455", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9456", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9457", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9458", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9459", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9460", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9461", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9462", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9463", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9464", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9465", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9466", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9467", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9468", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9469", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9470", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9471", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9472", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9473", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9474", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9475", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9476", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9477", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9478", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9479", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9480", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9481", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9482", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9483", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9484", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9485", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9486", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9487", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9488", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9489", NEEDS_PATH_VALIDATION), + ("bettertls::nameconstraints::tc9490", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc3", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc4", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc5", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc6", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc7", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc8", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc10", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc11", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc12", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc13", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc14", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc15", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc36", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc37", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc38", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc39", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc40", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc41", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc42", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc43", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc44", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc45", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc46", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc47", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc69", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc70", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc71", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc72", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc73", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc74", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc75", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc76", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc77", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc78", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc79", NEEDS_PATH_VALIDATION), + ("bettertls::pathbuilding::tc80", NEEDS_PATH_VALIDATION), + // Server-leaf pins that fail on the crate's leaf policy, not on a decoder. + ("pathlen::validation-ignores-pathlen-in-leaf", LEAF_POLICY), + ("rfc5280::ca-as-leaf", LEAF_POLICY), +]; + diff --git a/xtask/src/testdata.rs b/xtask/src/testdata.rs index 692b038..b611e6e 100644 --- a/xtask/src/testdata.rs +++ b/xtask/src/testdata.rs @@ -27,6 +27,7 @@ mod wpt_url_percent; mod wpt_url_setters; mod wpt_urltestdata; mod wpt_webstorage; +mod x509_limbo; use std::path::{Path, PathBuf}; @@ -93,8 +94,21 @@ const CONVERTERS: &[(&str, Convert, &[&str])] = &[ wpt_urltestdata::convert, wpt_urltestdata::FILES, ), + ("x509-limbo", x509_limbo::convert, x509_limbo::FILES), ]; +/// A converter for a binary artefact written beside a suite's Rust table. +type ConvertBytes = fn(&Path) -> Result, String>; + +/// Binary artefacts, by suite directory name: the file name under +/// `tests/generated/` and its converter. They are checked exactly like the +/// Rust tables (stale or missing is a problem; orphans are rejected). +const EXTRA_OUTPUTS: &[(&str, &str, ConvertBytes)] = &[( + "x509-limbo", + x509_limbo::CERTS_BIN, + x509_limbo::convert_certs, +)]; + /// Files every suite directory has besides the converter's inputs. const ALWAYS: &[&str] = &["SOURCE.md", "LICENSE.md"]; @@ -210,6 +224,13 @@ fn orphans(c: &Crate, suites: &[Suite]) -> Vec { .flatten() .map(|e| e.path()) .filter(|p| !suites.iter().any(|s| &s.generated == p)) + .filter(|p| { + !EXTRA_OUTPUTS.iter().any(|(suite, file, _)| { + suites + .iter() + .any(|s| s.dir.file_name().is_some_and(|n| n == *suite) && dir.join(file) == *p) + }) + }) .map(|p| { format!( "{}: generated file with no suite in tests/data/", @@ -268,6 +289,36 @@ pub fn run(crates: &[Crate], write: bool) -> (Vec, Vec) { run `cargo xtask testdata` and commit the result" )); } + for (_, file, convert) in EXTRA_OUTPUTS + .iter() + .filter(|(suite, _, _)| s.dir.file_name().is_some_and(|n| n == *suite)) + { + let path = s.generated.with_file_name(file); + let rel = workspace::relative(&path); + let fresh = match convert(&s.dir) { + Ok(f) => f, + Err(e) => { + problems.push(format!("{}: {e}", workspace::relative(&s.dir))); + continue; + } + }; + let current = std::fs::read(&path).ok(); + if current.as_deref() == Some(fresh.as_slice()) { + notes.push(format!("{rel}: up to date ({} bytes)", fresh.len())); + } else if write { + match std::fs::write(&path, &fresh) { + Ok(()) => notes.push(format!("{rel}: written ({} bytes)", fresh.len())), + Err(e) => problems.push(format!("{rel}: {e}")), + } + } else if current.is_none() { + problems.push(format!("{rel}: missing; run `cargo xtask testdata`")); + } else { + problems.push(format!( + "{rel}: stale (differs from what the converter produces); \ + run `cargo xtask testdata` and commit the result" + )); + } + } } } (problems, notes) diff --git a/xtask/src/testdata/x509_limbo.rs b/xtask/src/testdata/x509_limbo.rs new file mode 100644 index 0000000..56ba34b --- /dev/null +++ b/xtask/src/testdata/x509_limbo.rs @@ -0,0 +1,328 @@ +//! x509-limbo `limbo.json` (C2SP): path-validation testcases, reduced to two +//! derived artefacts, because the corpus is far too large to become Rust +//! literals (41.8 MB, 30,379 distinct certificates). +//! +//! * `tests/generated/x509_limbo.rs`: a Rust index of the testcases (id, +//! validation kind, expected result and peer name, validation time, +//! features, importance) whose certificates are indices into +//! * `tests/generated/x509_limbo_certs.bin`: every distinct certificate as +//! DER, concatenated in order of first use (leaf, then trust anchors, then +//! intermediates, per testcase). The index records each one's offset and +//! length. +//! +//! The PEM text of every `trusted_certs`, `untrusted_intermediates` and +//! `peer_certificate` is decoded here with a small strict base64 decoder of +//! our own (clazel-base64 works on code points under Verus and is not a +//! dependency of xtask). The converter checks the shape it relies on, that +//! testcase ids are unique, that every PEM has exactly one CERTIFICATE block +//! with canonical padded base64, and that every DER starts with a SEQUENCE. +//! A null `validation_time` becomes the empty string in the index. Fields the harness does not use (`peer_certificate_key`, CRLs, signature +//! algorithm lists) are not carried over. + +use std::collections::HashMap; +use std::fmt::Write as _; +use std::path::Path; + +use serde_json::Value; + +/// The files vendored for this suite (besides LICENSE.md and SOURCE.md). +pub const FILES: &[&str] = &["limbo.json"]; + +/// Name of the binary artefact beside the generated index. +pub const CERTS_BIN: &str = "x509_limbo_certs.bin"; + +const BEGIN: &str = "-----BEGIN CERTIFICATE-----"; +const END: &str = "-----END CERTIFICATE-----"; + +struct Case { + id: String, + kind: String, + expected: String, + peer: (String, String), + peer_names: Vec<(String, String)>, + time: String, + features: Vec, + importance: String, + trusted: Vec, + intermediates: Vec, + leaf: usize, +} + +struct Loaded { + cases: Vec, + certs: Vec>, +} + +fn sextet(b: u8) -> Option { + match b { + b'A'..=b'Z' => Some(u32::from(b).saturating_sub(u32::from(b'A'))), + b'a'..=b'z' => Some( + u32::from(b) + .saturating_sub(u32::from(b'a')) + .saturating_add(26), + ), + b'0'..=b'9' => Some( + u32::from(b) + .saturating_sub(u32::from(b'0')) + .saturating_add(52), + ), + b'+' => Some(62), + b'/' => Some(63), + _ => None, + } +} + +/// Strict standard-alphabet base64 with padding and no stray characters. +fn base64(text: &str) -> Result, String> { + let bytes = text.as_bytes(); + if bytes.is_empty() || !bytes.len().is_multiple_of(4) { + return Err("base64 length is not a positive multiple of 4".to_owned()); + } + let mut out = Vec::new(); + let (groups, _) = bytes.as_chunks::<4>(); + let last = groups.len().saturating_sub(1); + for (i, g) in groups.iter().enumerate() { + let pad = g.iter().rev().take_while(|&&b| b == b'=').count(); + if pad > 2 || (pad > 0 && i != last) { + return Err("misplaced base64 padding".to_owned()); + } + let mut acc = 0u32; + for &b in g.iter().take(4usize.saturating_sub(pad)) { + acc = acc + .saturating_mul(64) + .saturating_add(sextet(b).ok_or("bad base64 digit")?); + } + acc = acc + .checked_shl( + u32::try_from(pad) + .map_err(|e| e.to_string())? + .saturating_mul(6), + ) + .ok_or("shift")?; + let b3 = acc.to_be_bytes(); + let keep = 3usize.saturating_sub(pad); + out.extend(b3.iter().skip(1).take(keep)); + // Canonical: the bits below the kept ones must be zero. + let low_mask = match pad { + 1 => 0xff, + 2 => 0xffff, + _ => 0, + }; + if acc & low_mask != 0 { + return Err("non-canonical base64 padding bits".to_owned()); + } + } + Ok(out) +} + +fn pem_to_der(pem: &str, at: &str) -> Result, String> { + let t = pem.trim(); + let body = t + .strip_prefix(BEGIN) + .and_then(|r| r.strip_suffix(END)) + .ok_or_else(|| format!("{at}: not exactly one CERTIFICATE PEM block"))?; + if body.contains("-----") { + return Err(format!("{at}: more than one PEM block")); + } + let joined: String = body.split_whitespace().collect(); + let der = base64(&joined).map_err(|e| format!("{at}: {e}"))?; + if der.first() != Some(&0x30) { + return Err(format!("{at}: DER does not start with a SEQUENCE")); + } + Ok(der) +} + +fn text<'a>(v: &'a Value, key: &str, at: &str) -> Result<&'a str, String> { + v.get(key) + .and_then(Value::as_str) + .ok_or_else(|| format!("{at}: no string {key:?}")) +} + +fn strings(v: &Value, key: &str, at: &str) -> Result, String> { + v.get(key) + .and_then(Value::as_array) + .ok_or_else(|| format!("{at}: no array {key:?}"))? + .iter() + .map(|s| { + s.as_str() + .map(str::to_owned) + .ok_or_else(|| format!("{at}: {key:?} holds a non-string")) + }) + .collect() +} + +fn peer(v: &Value, at: &str) -> Result<(String, String), String> { + match v { + Value::Null => Ok((String::new(), String::new())), + Value::Object(_) => Ok(( + text(v, "kind", at)?.to_owned(), + text(v, "value", at)?.to_owned(), + )), + _ => Err(format!("{at}: peer name is neither null nor an object")), + } +} + +fn load(dir: &Path) -> Result { + let path = dir.join("limbo.json"); + let raw = std::fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?; + let json: Value = serde_json::from_str(&raw).map_err(|e| format!("limbo.json: {e}"))?; + if json.get("version").and_then(Value::as_u64) != Some(1) { + return Err("limbo.json: version is not 1".to_owned()); + } + let tests = json + .get("testcases") + .and_then(Value::as_array) + .ok_or("limbo.json: no testcases")?; + let mut certs: Vec> = Vec::new(); + let mut seen: HashMap, usize> = HashMap::new(); + let mut ids: HashMap = HashMap::new(); + let mut cases = Vec::new(); + let mut intern = |der: Vec| -> usize { + if let Some(&i) = seen.get(&der) { + return i; + } + let i = certs.len(); + seen.insert(der.clone(), i); + certs.push(der); + i + }; + for t in tests { + let id = text(t, "id", "testcase")?.to_owned(); + let at = format!("testcase {id}"); + if ids.insert(id.clone(), ()).is_some() { + return Err(format!("{at}: duplicate id")); + } + let kind = text(t, "validation_kind", &at)?.to_owned(); + if !["SERVER", "CLIENT"].contains(&kind.as_str()) { + return Err(format!("{at}: unknown validation_kind {kind:?}")); + } + let expected = text(t, "expected_result", &at)?.to_owned(); + if !["SUCCESS", "FAILURE"].contains(&expected.as_str()) { + return Err(format!("{at}: unknown expected_result {expected:?}")); + } + let leaf_pem = text(t, "peer_certificate", &at)?; + let leaf = intern(pem_to_der(leaf_pem, &format!("{at}: peer_certificate"))?); + let mut trusted = Vec::new(); + for p in strings(t, "trusted_certs", &at)? { + trusted.push(intern(pem_to_der(&p, &format!("{at}: trusted_certs"))?)); + } + let mut intermediates = Vec::new(); + for p in strings(t, "untrusted_intermediates", &at)? { + intermediates.push(intern(pem_to_der(&p, &format!("{at}: intermediate"))?)); + } + let mut peer_names = Vec::new(); + for n in t + .get("expected_peer_names") + .and_then(Value::as_array) + .ok_or_else(|| format!("{at}: no expected_peer_names"))? + { + peer_names.push(peer(n, &at)?); + } + cases.push(Case { + peer: peer(t.get("expected_peer_name").unwrap_or(&Value::Null), &at)?, + peer_names, + time: match t.get("validation_time") { + Some(Value::Null) => String::new(), + _ => text(t, "validation_time", &at)?.to_owned(), + }, + features: strings(t, "features", &at)?, + importance: text(t, "importance", &at)?.to_owned(), + id, + kind, + expected, + trusted, + intermediates, + leaf, + }); + } + Ok(Loaded { cases, certs }) +} + +fn list(items: &[T]) -> String { + items + .iter() + .map(ToString::to_string) + .collect::>() + .join(", ") +} + +/// The generated Rust index. +pub fn convert(dir: &Path) -> Result { + let l = load(dir)?; + let mut out = String::new(); + out.push_str( + "// @generated by `cargo xtask testdata` from tests/data/x509-limbo/.\n\ + // Do not edit: `cargo xtask verify` fails if this differs from what the\n\ + // converter (xtask/src/testdata/x509_limbo.rs) produces.\n\ + // Source, commit and license: tests/data/x509-limbo/SOURCE.md.\n\ + // Certificates are in tests/generated/x509_limbo_certs.bin.\n\ + /// Number of testcases in `limbo.json`.\n", + ); + writeln!(out, "const TESTCASE_COUNT: usize = {};", l.cases.len()).map_err(|e| e.to_string())?; + out.push_str("/// (offset, length) of each distinct certificate in the binary file.\n"); + out.push_str("const CERT_SPANS: &[(u32, u32)] = &[\n"); + let mut off = 0usize; + for c in &l.certs { + writeln!(out, " ({off}, {}),", c.len()).map_err(|e| e.to_string())?; + off = off + .checked_add(c.len()) + .ok_or("certificate bytes overflow")?; + } + out.push_str("];\nconst CASES: &[Case] = &[\n"); + for c in &l.cases { + let names = c + .peer_names + .iter() + .map(|(k, v)| format!("({k:?}, {v:?})")) + .collect::>() + .join(", "); + let features = c + .features + .iter() + .map(|f| format!("{f:?}")) + .collect::>() + .join(", "); + writeln!( + out, + " Case {{ id: {:?}, kind: {:?}, expected: {:?}, peer: ({:?}, {:?}), peer_names: &[{}], time: {:?}, features: &[{}], importance: {:?}, trusted: &[{}], intermediates: &[{}], leaf: {} }},", + c.id, c.kind, c.expected, c.peer.0, c.peer.1, names, c.time, features, c.importance, + list(&c.trusted), list(&c.intermediates), c.leaf + ) + .map_err(|e| e.to_string())?; + } + out.push_str("];\n"); + Ok(out) +} + +/// The binary certificate file. +pub fn convert_certs(dir: &Path) -> Result, String> { + Ok(load(dir)?.certs.concat()) +} + +#[cfg(test)] +mod tests { + use super::{base64, pem_to_der}; + + #[test] + fn base64_is_strict() { + assert_eq!(base64("TWFu"), Ok(b"Man".to_vec())); + assert_eq!(base64("TWE="), Ok(b"Ma".to_vec())); + assert_eq!(base64("TQ=="), Ok(b"M".to_vec())); + assert!(base64("TWF").is_err()); + assert!(base64("TWF=u===").is_err()); + assert!(base64("TQ==TQ==").is_err()); + assert!(base64("TR==").is_err(), "non-zero padding bits"); + assert!(base64("T!Fu").is_err()); + } + + #[test] + fn pem_needs_one_certificate_block_with_a_sequence() { + let ok = format!("{}\nMAA=\n{}\n", super::BEGIN, super::END); + assert_eq!(pem_to_der(&ok, "t"), Ok(vec![0x30, 0x00])); + assert!(pem_to_der("MAA=", "t").is_err()); + let two = format!("{ok}{ok}"); + assert!(pem_to_der(&two, "t").is_err()); + let not_seq = format!("{}\nAQA=\n{}", super::BEGIN, super::END); + assert!(pem_to_der(¬_seq, "t").is_err()); + } +}